Struct gapi_grpc::google::genomics::v1::Read

pub struct Read {
    pub id: String,
    pub read_group_id: String,
    pub read_group_set_id: String,
    pub fragment_name: String,
    pub proper_placement: bool,
    pub duplicate_fragment: bool,
    pub fragment_length: i32,
    pub read_number: i32,
    pub number_reads: i32,
    pub failed_vendor_quality_checks: bool,
    pub alignment: Option<LinearAlignment>,
    pub secondary_alignment: bool,
    pub supplementary_alignment: bool,
    pub aligned_sequence: String,
    pub aligned_quality: Vec<i32>,
    pub next_mate_position: Option<Position>,
    pub info: HashMap<String, ListValue>,
}

A read alignment describes a linear alignment of a string of DNA to a [reference sequence][google.genomics.v1.Reference], in addition to metadata about the fragment (the molecule of DNA sequenced) and the read (the bases which were read by the sequencer). A read is equivalent to a line in a SAM file. A read belongs to exactly one read group and exactly one [read group set][google.genomics.v1.ReadGroupSet].

For more genomics resource definitions, see Fundamentals of Google Genomics

Reverse-stranded reads

Mapped reads (reads having a non-null alignment) can be aligned to either the forward or the reverse strand of their associated reference. Strandedness of a mapped read is encoded by alignment.position.reverseStrand.

If we consider the reference to be a forward-stranded coordinate space of [0, reference.length) with 0 as the left-most position and reference.length as the right-most position, reads are always aligned left to right. That is, alignment.position.position always refers to the left-most reference coordinate and alignment.cigar describes the alignment of this read to the reference from left to right. All per-base fields such as alignedSequence and alignedQuality share this same left-to-right orientation; this is true of reads which are aligned to either strand. For reverse-stranded reads, this means that alignedSequence is the reverse complement of the bases that were originally reported by the sequencing machine.

Generating a reference-aligned sequence string

When interacting with mapped reads, it’s often useful to produce a string representing the local alignment of the read to reference. The following pseudocode demonstrates one way of doing this:

out = ""
offset = 0
for c in read.alignment.cigar {
  switch c.operation {
  case "ALIGNMENT_MATCH", "SEQUENCE_MATCH", "SEQUENCE_MISMATCH":
    out += read.alignedSequence[offset:offset+c.operationLength]
    offset += c.operationLength
    break
  case "CLIP_SOFT", "INSERT":
    offset += c.operationLength
    break
  case "PAD":
    out += repeat("*", c.operationLength)
    break
  case "DELETE":
    out += repeat("-", c.operationLength)
    break
  case "SKIP":
    out += repeat(" ", c.operationLength)
    break
  case "CLIP_HARD":
    break
  }
}
return out

Converting to SAM’s CIGAR string

The following pseudocode generates a SAM CIGAR string from the cigar field. Note that this is a lossy conversion (cigar.referenceSequence is lost).

cigarMap = {
  "ALIGNMENT_MATCH": "M",
  "INSERT": "I",
  "DELETE": "D",
  "SKIP": "N",
  "CLIP_SOFT": "S",
  "CLIP_HARD": "H",
  "PAD": "P",
  "SEQUENCE_MATCH": "=",
  "SEQUENCE_MISMATCH": "X",
}
cigarStr = ""
for c in read.alignment.cigar {
  cigarStr += c.operationLength + cigarMap[c.operation]
}
return cigarStr

Fields

id: String

The server-generated read ID, unique across all reads. This is different from the fragmentName.

read_group_id: String

The ID of the read group this read belongs to. A read belongs to exactly one read group. This is a server-generated ID which is distinct from SAM’s RG tag (for that value, see [ReadGroup.name][google.genomics.v1.ReadGroup.name]).

read_group_set_id: String

The ID of the read group set this read belongs to. A read belongs to exactly one read group set.

fragment_name: String

The fragment name. Equivalent to QNAME (query template name) in SAM.

proper_placement: bool

The orientation and the distance between reads from the fragment are consistent with the sequencing protocol (SAM flag 0x2).

duplicate_fragment: bool

The fragment is a PCR or optical duplicate (SAM flag 0x400).

fragment_length: i32

The observed length of the fragment, equivalent to TLEN in SAM.

read_number: i32

The read number in sequencing. 0-based and less than numberReads. This field replaces SAM flag 0x40 and 0x80.

number_reads: i32

The number of reads in the fragment (extension to SAM flag 0x1).

failed_vendor_quality_checks: bool

Whether this read did not pass filters, such as platform or vendor quality controls (SAM flag 0x200).

alignment: Option<LinearAlignment>

The linear alignment for this alignment record. This field is null for unmapped reads.

secondary_alignment: bool

Whether this alignment is secondary. Equivalent to SAM flag 0x100. A secondary alignment represents an alternative to the primary alignment for this read. Aligners may return secondary alignments if a read can map ambiguously to multiple coordinates in the genome. By convention, each read has one and only one alignment where both secondaryAlignment and supplementaryAlignment are false.

supplementary_alignment: bool

Whether this alignment is supplementary. Equivalent to SAM flag 0x800. Supplementary alignments are used in the representation of a chimeric alignment. In a chimeric alignment, a read is split into multiple linear alignments that map to different reference contigs. The first linear alignment in the read will be designated as the representative alignment; the remaining linear alignments will be designated as supplementary alignments. These alignments may have different mapping quality scores. In each linear alignment in a chimeric alignment, the read will be hard clipped. The alignedSequence and alignedQuality fields in the alignment record will only represent the bases for its respective linear alignment.

aligned_sequence: String

The bases of the read sequence contained in this alignment record, without CIGAR operations applied (equivalent to SEQ in SAM). alignedSequence and alignedQuality may be shorter than the full read sequence and quality. This will occur if the alignment is part of a chimeric alignment, or if the read was trimmed. When this occurs, the CIGAR for this read will begin/end with a hard clip operator that will indicate the length of the excised sequence.

aligned_quality: Vec<i32>

The quality of the read sequence contained in this alignment record (equivalent to QUAL in SAM). alignedSequence and alignedQuality may be shorter than the full read sequence and quality. This will occur if the alignment is part of a chimeric alignment, or if the read was trimmed. When this occurs, the CIGAR for this read will begin/end with a hard clip operator that will indicate the length of the excised sequence.

next_mate_position: Option<Position>

The mapping of the primary alignment of the (readNumber+1)%numberReads read in the fragment. It replaces mate position and mate strand in SAM.

info: HashMap<String, ListValue>

A map of additional read alignment information. This must be of the form map<string, string[]> (string key mapping to a list of string values).

Trait Implementations

impl Clone for Read

fn clone(&self) -> Read

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Read

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Read

fn default() -> Read

Returns the “default value” for a type.

impl Message for Read

fn encode_raw<B>(&self, buf: &mut B) where
    B: BufMut, 

fn merge_field<B>(
    &mut self,
    tag: u32,
    wire_type: WireType,
    buf: &mut B,
    ctx: DecodeContext
) -> Result<(), DecodeError> where
    B: Buf, 

fn encoded_len(&self) -> usize

Returns the encoded length of the message without a length delimiter.

fn clear(&mut self)

Clears the message, resetting all fields to their default.

pub fn encode<B>(&self, buf: &mut B) -> Result<(), EncodeError> where
    B: BufMut, 

Encodes the message to a buffer.

pub fn encode_length_delimited<B>(&self, buf: &mut B) -> Result<(), EncodeError> where
    B: BufMut, 

Encodes the message with a length-delimiter to a buffer.

pub fn decode<B>(buf: B) -> Result<Self, DecodeError> where
    Self: Default,
    B: Buf, 

Decodes an instance of the message from a buffer.

pub fn decode_length_delimited<B>(buf: B) -> Result<Self, DecodeError> where
    Self: Default,
    B: Buf, 

Decodes a length-delimited instance of the message from the buffer.

pub fn merge<B>(&mut self, buf: B) -> Result<(), DecodeError> where
    B: Buf, 

Decodes an instance of the message from a buffer, and merges it into self.

pub fn merge_length_delimited<B>(&mut self, buf: B) -> Result<(), DecodeError> where
    B: Buf, 

Decodes a length-delimited instance of the message from buffer, and merges it into self.

impl PartialEq<Read> for Read

fn eq(&self, other: &Read) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Read) -> bool

This method tests for !=.

impl StructuralPartialEq for Read