# Comparing Genomics Data Transfer Protocols In one sentence, a genomics data transfer protocol comparison comes down to this: TCP-based tools such as SFTP, rsync, and HTTPS move genomic files reliably but lose throughput on long or lossy network paths, while UDP-based tools such as Aspera FASP and Globus GridFTP are built to sustain high throughput across those same paths, and read-level APIs such as htsget avoid bulk movement altogether. The rule of thumb is simple. If both endpoints sit on the same fast, well-managed network, SFTP or rsync over SSH is usually enough. If you are pushing hundreds of gigabytes across a continent or an ocean, use a UDP-based transfer tool or Globus. If your collaborators only need to query reads or variants inside files you hold, serve those files through htsget or an object storage API instead of shipping them. This article walks through each of the main genomics data transfer protocol options, compares them on the criteria that actually decide real deployments, and works through concrete scenarios drawn from day-to-day bioinformatics [data management](/blog/guides/data-management-basics-principles-processes-and-best-practices). ## Why Transfer Choice Matters More in Genomics Than Elsewhere A single [Illumina sequencing](/blog/guides/illumina-sequencing) run can produce terabytes of BCL and FASTQ output. An aligned, coordinate-sorted BAM file for a 30x human whole genome typically runs on the order of 100 GB, and a large cohort project accumulates thousands of those files. Moving that volume is not an edge case in genomics. It is the routine cost of doing business, and it sits at the center of modern bioinformatics data management. The physics of the network, not the biology, determines whether that movement takes hours or weeks. Two facts drive everything else in this comparison: 1. Genomic data files are large but highly compressible and highly checksum-able, which makes them good candidates for aggressive parallel transfer and streaming. 2. The datasets usually need to move between institutions, which means the network path includes the public internet, with its latency, packet loss, and firewalls. The field has been dealing with interoperability problems for a long time. An early attempt to standardize exchange of genome mapping data produced a generic XML schema, GenomicMappingData.xsd, precisely because heterogeneous datasources had no common information exchange standard and data integration had to be performed in an ad hoc manner [1]. That problem never went away. It just moved up the stack, from map coordinates to petabyte-scale read archives. Transfer protocol choice is now one of the highest-leverage infrastructure decisions a genomics group makes, alongside genomics data storage architecture itself. ## The Two Transport Families, and Why They Behave Differently Every protocol in this comparison rides on either TCP or UDP, and that single fact explains most of the performance differences you will observe. **TCP-based transfer.** TCP (Transmission Control Protocol) guarantees ordered, reliable delivery. When packets are lost, TCP interprets the loss as congestion and shrinks its sending window. On a short path with no loss, this is invisible. On a transcontinental or intercontinental path, a single lost packet can stall the window growth and keep throughput far below the line rate. The relevant quantity is the bandwidth-delay product, the product of link bandwidth and round-trip time. At 10 Gbps and a 100 ms round trip, roughly 125 MB must be in flight at once to fill the pipe. Ordinary single-stream TCP struggles to keep that much data in flight when any loss occurs. **UDP-based transfer.** UDP (User Datagram Protocol) does not guarantee delivery. Tools built on UDP implement their own reliability and rate control, so they can keep many segments in flight and respond to loss differently than TCP does. On high bandwidth-delay product paths, these tools routinely sustain throughput that standard TCP cannot reach. This is why commercial accelerators and GridFTP both exist as product categories. A third family avoids bulk transfer entirely. Streaming and query APIs such as htsget, and federated analysis platforms, let the computation travel to the data instead of the data traveling to the computation. The EU Child Cohort Network explicitly chose this route, analyzing harmonized cohort data on a federated platform that removes the need to physically transfer data and thereby makes the data more accessible to researchers [2]. ## Side-by-Side Comparison Table The table below is the core of this genomics data transfer protocol comparison. Each row is explained in detail in the sections that follow. | Protocol | Underlying transport | Security model | Resume and verification | Typical best fit | Main drawback | |--|--|--|--|--|--| | SFTP / SCP | TCP over SSH (port 22) | SSH encryption and key or password authentication | Manual resume, checksum outside protocol | Ad hoc file exchange with a collaborator, small to medium batches | Throughput collapses on long lossy paths | | rsync over SSH | TCP over SSH | SSH encryption | Delta transfer and per-file resume, checksums | Directory synchronization, incremental updates of aligned outputs | Many small files are slow, delta transfer helps little on BAM/FASTQ | | HTTPS to object storage (S3-compatible) | TCP over TLS | TLS plus signed URLs or IAM credentials | Multipart upload, per-part retry, ETag or checksum validation | Cloud-native pipelines, workflow outputs, public data release | Tooling sprawl, credential management, egress costs | | IBM Aspera (FASP) | UDP with proprietary reliability layer | AES encryption in transit, per-transfer credentials | Automatic resume, embedded integrity checks | Large intercontinental transfers to and from managed endpoints | Commercial licensing, both sides need the client and endpoint | | Globus (GridFTP) | TCP with many parallel streams | TLS and X.509 or OAuth identity federation | Checkpointed restart, checksum verification | Multi-institution consortia, managed endpoint-to-endpoint transfer | Requires endpoint setup, identity federation overhead | | Signiant | UDP with proprietary reliability layer | Encryption in transit with per-job credentials | Automatic resume and integrity checking | Media-scale and enterprise genomics deployments with vendor contracts | Proprietary and priced for enterprise use | | Open-source UDP tools (Tsunami-UDP, UDT-based) | UDP with application-level reliability | Usually none built in, often wrapped in SSH or VPN tunnels | Varies by tool, often weak | Point-to-point acceleration where licensing is not an option | No support contract, weak security, weak auditability | | htsget | HTTPS with JSON responses | TLS, standard web authentication | Stateless, request-level | Querying reads or variants by genomic region without bulk download | Requires server deployment, covers reads and variants, not all file types | | Federated analysis | No bulk data movement | Each site retains control of its data | Not applicable | Multi-cohort research where governance forbids centralization | Analytical constraints, federation software to maintain | ## Option-by-Option Breakdown ### SFTP and SCP SFTP (SSH File Transfer Protocol) and SCP (Secure Copy Protocol) run over SSH, the encrypted shell protocol present on essentially every Unix system. Authentication uses SSH keys or passwords. Encryption is always on, which satisfies the baseline security expectation for human genomic data in transit. The strengths are universality and zero procurement. Every sequencer vendor, every HPC cluster, and every collaborator with a laptop can speak SSH. For a lab exchanging a handful of VCF files or a single BAM with a collaborator, SFTP remains the correct answer, and over engineering it with anything else wastes effort. The weakness shows up under distance and loss. A single TCP stream crossing an ocean with any packet loss can deliver a small fraction of the provisioned bandwidth. SFTP also offers no meaningful resume of a partially transferred 100 GB file in most server implementations, so a dropped connection at hour three can mean starting over. If your transfer windows are measured in minutes and your paths are short, none of this matters. If they are not, plan for something stronger. ### rsync over SSH rsync adds two things to plain SSH copy: a delta-transfer algorithm that sends only the differences between an existing file and its updated version, and per-file resume behavior. For bioinformatics data management, rsync shines in one specific pattern, synchronizing a directory of analysis outputs to a backup or archive target on a repeated schedule. When you re-run a pipeline and only a few files change, rsync sends only those files, and within changed text files such as compressed VCFs it can send only changed blocks. The delta-transfer trick helps little with binary alignment files that change wholesale, and rsync inherits TCP's distance sensitivity because it usually runs inside a single SSH connection. Options such as running multiple concurrent rsync processes, or enabling its built-in delta compression for text-like formats, recover some ground. Still, for a one-time, multi-terabyte, intercontinental push, rsync is the wrong tool, and pretending otherwise is a common source of multi-week transfers that should have taken a day. ### HTTPS and Object Storage APIs Cloud genomics data storage has made HTTPS-based transfer over object storage APIs (Amazon S3 and its many compatible implementations, Azure Blob Storage, Google Cloud Storage) a default. The pattern looks like this. A producer uploads objects, possibly with multipart upload so that a 100 GB BAM becomes many independently retried parts. A consumer downloads through a pre-signed URL, a time-limited HTTPS link that grants access without sharing long-term credentials. The strengths are substantial. Multipart upload gives you resumable, parallel transfer over ordinary HTTPS. Checksums such as MD5 or SHA-256 can be attached and verified on receipt. Access control integrates with institutional identity systems. Workflow engines and data repositories speak these APIs natively, and public data release through signed URLs has become the lingua franca of shared genomics data storage. The drawbacks are operational. Credential hygiene becomes part of the transfer problem, because leaked long-lived keys to a bucket of human genomes are a serious incident. Egress charges from public clouds can dwarf the compute costs of a project if the access pattern is wrong. And raw HTTPS still rides on TCP, so cloud-to-on-premises transfers over lossy links benefit from the same accelerators as any other TCP traffic, which is why cloud vendors ship their own transfer agents and why hybrid deployments often pair object storage with a UDP-based tool for the last mile. ### IBM Aspera (FASP) Aspera's FASP (Fast and Secure Protocol) is the best-known UDP-based transfer technology in genomics. It sends data over UDP while managing its own reliability, retransmission, and rate control, decoupling throughput from round-trip time in the way single-stream TCP cannot. Both NCBI and EMBL-EBI have historically offered Aspera endpoints for downloading archive data, which tells you how entrenched the protocol is in genomics data storage practice. Encryption in transit and per-transfer credentials satisfy security review, and automatic resume with embedded integrity checking handles the reality of multi-day transfers. The costs are commercial and logistical. You need licenses, and both the sending and receiving sides need compatible Aspera software, which means the protocol works best between organizations that have both invested. For consortia with stable membership and an IT budget, that investment pays for itself quickly. For a one-off exchange with an academic collaborator who will not install a client, it is a non-starter. ### Globus (GridFTP) GridFTP extends FTP with parallel TCP streams, checkpointed restart, and strong checksum-based verification. The Globus service wraps GridFTP in a managed endpoint model with federated identity, so researchers authenticate with their institutional credentials and transfers are orchestrated, monitored, and logged by the platform rather than by a person watching a terminal. Globus is the de facto standard for multi-institution genomics consortia in the research world precisely because of that orchestration layer. A coordinating center can set up a transfer, delegate it to endpoints at each site, watch progress from a dashboard, and produce an audit trail. The trade-offs are administrative. Someone must install and maintain an endpoint at each site, and identity federation must actually work across the participating institutions. For large recurring flows between institutions that already cooperate, Globus is usually the best genomics data transfer protocol choice in the TCP family, and its parallel-stream approach narrows, though does not always fully close, the gap to UDP-based tools on lossy paths. ### Signiant and Other Commercial Accelerators Signiant occupies similar territory to Aspera, UDP-based transport with proprietary reliability and enterprise-oriented management tooling. In genomics it appears mainly where enterprise contracts already exist, for example when a sequencing provider and a pharmaceutical partner need a governed pipeline between them. The comparison logic is the same as for Aspera, with procurement and ecosystem fit deciding between the two vendors more often than raw throughput does. ### Open-Source UDP Tools Tsunami-UDP and UDT-based tools exist for teams that need UDP-class throughput without a commercial license. They can work well for point-to-point pushes between two sites that trust each other. Be clear-eyed about the trade: most of these tools have no built-in encryption and limited auditing, so they must be wrapped in a VPN or SSH tunnel, and their resume behavior is often weaker than the commercial products. They are a legitimate part of the genomics data transfer protocol comparison options list, but they shift the burden of security and reliability onto your own scripts. ### htsget and GA4GH Data Access Interfaces htsget, a standard from the Global Alliance for Genomics and Health (GA4GH), flips the model. Instead of transferring whole files, a client asks a server for the reads or variants in a genomic region, and the server responds with JSON describing where to fetch the data, typically as block-compressed chunks of BAM, CRAM, or BCF. A variant analyst who needs only the reads covering one gene does not need to pull a 100 GB file. They pull megabytes. This matters most when many downstream users consume a small slice of a large repository. It also changes the security posture, because access control happens per query through ordinary web authentication rather than per file through filesystem permissions. The limitation is coverage. htsget addresses sequence reads and variants, so it complements rather than replaces bulk transfer for reference genomes, annotation, and raw signal files. Deploying an htsget server is real work, which is why it usually appears inside data repositories and coordinated access mechanisms rather than in ad hoc lab sharing. ### Federated Analysis, the Anti-Transfer Option The most radical answer to the transfer problem is to not transfer at all. In a federated design, each participating site keeps its data under its own governance, and an analysis platform sends computations to the data instead. The EU Child Cohort Network built its FAIR (findable, accessible, interoperable, reusable) variable set and analyzes it on a federated platform explicitly to remove the need for physical data transfer [2]. Projects that share sensitive samples and derived data with qualified external investigators, such as the Emory 3q29 Project's publicly accessible biobank resource, show how governance and access control arrangements determine what kind of transfer architecture is even permissible for a given cohort [3]. Federation does not eliminate movement entirely. Indexes, harmonized variable tables, and aggregate results still travel. But it converts the hardest transfer problem, moving identifiable individual-level genomic data across borders and institutions, into a smaller and more governable one. ## The Criteria That Decide Real Choices ![Decision path asking about path length, endpoint control and access pattern, ending in SFTP, Globus or Aspera, object storage, or htsget.](/article-images/illustrations/genomics-data-transfer-protocol-comparison-protocol-triage.webp) Understanding each protocol on its own terms is half the job. The other half is scoring them on the dimensions that actually decide deployments. ### Path length and quality This is the single biggest determinant. On a campus LAN or a dedicated inter-site link with single-digit millisecond latency and negligible loss, TCP-based tools saturate the link and the UDP alternatives buy you little. On intercontinental paths, the ranking inverts. If you can measure the path, measure it. A quick iperf3 run between the two endpoints, or simply timing a 1 GB test transfer with rsync, tells you more than any vendor claim. ### Data volume and cadence One-time terabyte migrations favor bulk protocols with strong resume, Aspera, Globus, or multipart upload to object storage. Continuous incremental flows, daily synchronization of new runs, favor rsync or object storage APIs with lifecycle tooling. Query-heavy access patterns, many users reading small genomic slices, favor htsget or direct object reads, because bulk download becomes the bottleneck of the analysis rather than a step in it. ### Security, compliance, and auditability Human genomic data is sensitive, and the governance requirements around its collection, storage, and sharing are documented across national genomics initiatives, which emphasize transparent and accountable governance structures communicated clearly to participants [4]. Practically, that translates into three questions for any protocol. Is data encrypted in transit, and is the encryption auditable. Can you produce a log of who moved what, when, for every transfer. Does access control integrate with institutional identity rather than with shared passwords. SFTP, Globus, and the managed commercial tools score well on all three. Raw open-source UDP tools score poorly and need wrappers. Object storage scores well if credential management is disciplined. ### Ecosystem and workflow integration Modern pipelines are orchestrated by workflow engines, and a transfer protocol that cannot be called from the orchestrator creates manual toil. Object storage APIs integrate natively with Nextflow, Cromwell, and Galaxy. Globus integrates through its CLI and SDK. htsget integrates through client libraries in samtools-compatible tooling. A protocol that only exists as a desktop GUI application is a poor fit for automated bioinformatics data management, however fast it is. ### Who controls the endpoints The most underweighted criterion. Aspera requires compatible software on both ends. Globus requires an endpoint on both ends. htsget requires a server you may not be able to convince the other side to run. SFTP requires almost nothing from the other side. When the far endpoint is outside your control, and in academic collaboration it usually is, the achievable protocol set shrinks fast, and the best genomics data transfer protocol in the abstract is not the best one for that particular pair of endpoints. ## Worked Scenarios ![Comparison of four worked scenarios showing data volume, network path, chosen pattern and the reason it fits.](/article-images/illustrations/genomics-data-transfer-protocol-comparison-scenario-fit.webp) ### Scenario 1, Clinical sequencing lab to a cloud analysis environment A clinical lab generates about 2 TB per sequencing week and uploads to cloud object storage for pipeline processing. The link is a business internet connection with moderate latency. The right pattern is multipart upload through a transfer agent into S3-compatible storage, with checksums verified on arrival and lifecycle rules archiving to colder tiers afterward. If the link proves lossy and uploads crawl, adding a UDP-based accelerator between the on-premises gateway and the cloud region is a targeted fix that does not disturb the rest of the architecture. ### Scenario 2, Multi-site cohort consortium Eight universities contribute whole-genome data to a coordinating center for a joint analysis. Transfers recur, volumes are large, and every site has different local policies. Globus is the natural fit, endpoints at each site, federated identity, dashboards, and audit logs that satisfy governance review. Governance planning is not an afterthought here. Comparative work on large-scale genomics initiatives in England, France, and Germany shows that collection, storage, and sharing arrangements directly affect trust and the rights and duties of each party, so the transfer architecture should be designed alongside the data governance agreement, not after it [4]. ### Scenario 3, Researcher querying a public repository An analyst needs reads spanning a 2 Mb region from thousands of accessions in a repository. Downloading thousands of full BAM files through FTP or HTTPS would move petabytes of unneeded sequence. Region-scoped access through htsget, or through the repository's native range-request API against object storage, reduces the movement by orders of magnitude. This is the scenario where the protocol choice changes the feasibility of the science, not merely its speed. ### Scenario 4, Recurring backup of analysis outputs A small lab needs a nightly synchronization of aligned outputs and variant calls to an institutional archive two network hops away on well-provisioned links. rsync over SSH, with checksum verification and deletion flags handled deliberately, is the correct, boring, reliable answer. Escalating to a commercial accelerator here would add licensing, endpoints, and failure modes for no benefit. ## Where Formats and Compression Fit Into Transfer Planning Protocol and format are intertwined, and a fair genomics data transfer protocol comparison has to acknowledge that the cheapest bytes are the ones you never send. Standard genomics data storage practice already exploits this. BAM files are BGZF-compressed, position-sorted, and indexed so that both HTTP range requests and htsget can serve slices. CRAM stores alignments relative to a reference, reducing aligned data size substantially compared to BAM when the reference is available at both ends. VCFs and FASTAs travel block-compressed and indexed for the same reason. Two practical consequences follow. First, before accelerating a transfer, check whether re-compressing or reference-encoding the data shrinks it. A CRAM conversion can halve a transfer in a way no protocol tuning can. Second, always attach checksums at file creation time, MD5 or SHA-256 sidecar files, so that every downstream protocol can verify integrity against a common reference. Inter-laboratory work in adjacent biomolecular fields shows how much consistency depends on standardization of practice across sites, since even a shared written protocol produced variation between laboratories in one multi-site comparison of extracellular vesicle isolation, underscoring that transfer and processing steps need explicit verification, not trust [5]. ## Harmonization Before Transfer Transferring bytes is only half of interoperability. The meaning of the bytes must survive the journey. Harmonization initiatives in population genomics formalize this. The Public Population Project in Genomics (P3G) was organized around optimizing study design and promoting harmonization of information across biobanks so that data from different studies could be pooled, including producing comparison charts of calibration approaches so collaborating groups unfamiliar with a method could align on it [6]. The EU Child Cohort Network went through the same exercise at the variable level, defining core variables, a harmonization protocol, and a catalogue to make the data findable and reusable before any analysis could be federated across cohorts [2]. The lesson for transfer planning is to treat semantic harmonization as a deliverable that ships with the data. A schema version, a data dictionary, and a checksum manifest should move in the same transfer job as the BAMs and VCFs. Retrofitting meaning after a protocol mismatch is far more expensive than sending it along the first time. This is the same problem the earlier XML mapping-schema work attacked at a smaller scale, providing a lightweight common document format for exchange where none existed [1]. ## Common Mistakes and Limitations These are the errors that show up repeatedly in real genomics infrastructure work. 1. **Benchmarking on the wrong path.** Teams test throughput on their LAN, approve a protocol, then discover that the production path crosses two ISPs and a congested exchange point. Always benchmark the actual end-to-end path with a representative file size. 2. **Treating resume as optional.** A 500 GB transfer with no resume capability, restarted from byte zero after a failure at 90 percent, is a schedule-killer. Verify resume behavior in a failure drill before committing to a protocol for a large migration. 3. **Skipping checksum verification.** "The transfer tool said it finished" is not integrity verification. Generate MD5 or SHA-256 checksums at the source, transfer them with the data, and verify at the destination automatically. Make verification a pipeline step, not a human habit. 4. **Sharing credentials to make transfer easy.** Shared SFTP passwords or long-lived cloud keys pasted into a ticket are the most common security failure in academic genomic data exchange. Use per-user keys, short-lived signed URLs, or federated identity. The governance literature on national genomics initiatives is blunt that confidentiality and trust depend on how access is actually managed, not on how policies are worded [4]. 5. **Assuming one protocol must serve every flow.** Mature groups run several protocols side by side, Globus for consortium flows, object storage APIs for pipeline I/O, SFTP for quick collaborator exchanges, htsget for repository queries. Insisting on a single protocol standardizes the wrong thing. 6. **Ignoring egress and endpoint economics.** A protocol that looks free can carry cloud egress charges that dominate a project budget, or require an endpoint installation at an institution that will never staff it. Cost and operational ownership belong in the comparison, alongside throughput. 7. **Confusing transfer with governance approval.** A fast, secure, audited pipeline to a destination does not authorize sending identifiable human genomic data there. Data use agreements, access committees, and participant consent terms decide that. The transfer protocol comparison should happen only after the governance question is answered. 8. **A limitation of this comparison.** Exact throughput figures depend on hardware, path conditions, concurrency settings, and vendor versions, and they change with every release. This article deliberately compares protocols qualitatively. Before committing budget, run your own transfer benchmark on your own path with your own representative data, and treat vendor or community throughput claims as hypotheses to test rather than facts to inherit. ## Frequently Asked Questions ### What is the best genomics data transfer protocol? There is no single best protocol, because the deciding factors are path length and quality, data volume, endpoint control, and compliance requirements. For same-site or well-provisioned links, rsync or SFTP is best. For large intercontinental transfers between prepared endpoints, UDP-based tools such as Aspera or Globus are best. For cloud-native pipelines, object storage APIs are best. For region-level queries of reads and variants, htsget is best. ### Is SFTP enough for large genomics files? SFTP is enough when the network path is short, low-loss, and the file sizes are moderate, and it is the right choice for quick collaborator exchanges because every system supports SSH. It is not a good choice for multi-terabyte or intercontinental transfers, where single-stream TCP throughput collapses and resume support is weak. Escalate to a parallel or UDP-based protocol when transfer time starts to shape your project schedule. ### What is htsget and when should I use it? htsget is a GA4GH standard API that lets a client request reads or variants for a specific genomic region, with the server returning the locations of the relevant data chunks instead of the whole file. Use it when many consumers need small slices of a large repository, for example variant analysts querying single genes across thousands of genomes. Do not use it as a bulk transfer replacement for whole files or for data types it does not cover, such as reference assemblies. ### Do UDP-based transfer tools compromise security? Not inherently, but it depends on the tool. Commercial UDP-based products such as Aspera and Signiant include encryption in transit and per-transfer credentials as core features. Open-source UDP tools often lack built-in encryption and auditing, so they must be wrapped in a VPN or SSH tunnel and supplemented with your own checksum and logging practices. Evaluate the security features of the specific product, not the transport protocol category. ### Should I transfer data or analyze it where it lives? Transfer when the analysis is long-running, the compute is local, and the data will be reused many times. Analyze where the data lives, through federated analysis or cloud compute, when governance restricts movement, when the data is too large to move economically, or when many sites must contribute to a joint result. Federated designs keep individual-level data under each site's control and send computations instead, which is how several large cohort networks handle the problem. ### How do I verify files arrived intact? Generate MD5 or SHA-256 checksums at the source before transfer, ship them alongside the data, and verify them automatically at the destination as a pipeline step. For object storage, use the built-in per-part checksums and ETag validation in addition to file-level checksums. For Globus and the commercial accelerators, use their embedded integrity checking, then spot-check with your own checksums for end-to-end assurance. ## Sources 1. [An XML transfer schema for exchange of genomic and genetic mapping data: implementation as a web service in a Taverna workflow.](https://pubmed.ncbi.nlm.nih.gov/19682365/) 2. [The EU Child Cohort Network's core data: establishing a set of findable, accessible, interoperable and re-usable (FAIR) variables.](https://pubmed.ncbi.nlm.nih.gov/33884544/) 3. [Study protocol for The Emory 3q29 Project: evaluation of neurodevelopmental, psychiatric, and medical symptoms in 3q29 deletion syndrome.](https://pubmed.ncbi.nlm.nih.gov/29884173/) 4. [Managing expectations, rights, and duties in large-scale genomics initiatives: a European comparison.](https://pubmed.ncbi.nlm.nih.gov/36471117/) 5. [Inter-Laboratory Comparison of Extracellular Vesicle Isolation Based on Ultracentrifugation.](https://pubmed.ncbi.nlm.nih.gov/33708052/) 6. [Study protocol: the empirical investigation of methods to correct for measurement error in biobanks with dietary assessment.](https://pubmed.ncbi.nlm.nih.gov/21974830/)