class Google::Apis::GenomicsV1::Read

A read alignment describes a linear alignment of a string of DNA to a reference sequence, 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. For more genomics resource definitions, see [Fundamentals of Google Genomics](cloud.google.com/genomics/ 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 ` return cigarStr

Attributes

aligned_quality[RW]

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. Corresponds to the JSON property `alignedQuality` @return [Array<Fixnum>]

aligned_sequence[RW]

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. Corresponds to the JSON property `alignedSequence` @return [String]

alignment[RW]

A linear alignment can be represented by one CIGAR string. Describes the mapped position and local alignment of the read to the reference. Corresponds to the JSON property `alignment` @return [Google::Apis::GenomicsV1::LinearAlignment]

duplicate_fragment[RW]

The fragment is a PCR or optical duplicate (SAM flag 0x400). Corresponds to the JSON property `duplicateFragment` @return [Boolean]

duplicate_fragment?[RW]

The fragment is a PCR or optical duplicate (SAM flag 0x400). Corresponds to the JSON property `duplicateFragment` @return [Boolean]

failed_vendor_quality_checks[RW]

Whether this read did not pass filters, such as platform or vendor quality controls (SAM flag 0x200). Corresponds to the JSON property `failedVendorQualityChecks` @return [Boolean]

failed_vendor_quality_checks?[RW]

Whether this read did not pass filters, such as platform or vendor quality controls (SAM flag 0x200). Corresponds to the JSON property `failedVendorQualityChecks` @return [Boolean]

fragment_length[RW]

The observed length of the fragment, equivalent to TLEN in SAM. Corresponds to the JSON property `fragmentLength` @return [Fixnum]

fragment_name[RW]

The fragment name. Equivalent to QNAME (query template name) in SAM. Corresponds to the JSON property `fragmentName` @return [String]

id[RW]

The server-generated read ID, unique across all reads. This is different from the `fragmentName`. Corresponds to the JSON property `id` @return [String]

info[RW]

A map of additional read alignment information. This must be of the form map ( string key mapping to a list of string values). Corresponds to the JSON property `info` @return [Hash<String,Array<Object>>]

next_mate_position[RW]

An abstraction for referring to a genomic position, in relation to some already known reference. For now, represents a genomic position as a reference name, a base number on that reference (0-based), and a determination of forward or reverse strand. Corresponds to the JSON property `nextMatePosition` @return [Google::Apis::GenomicsV1::Position]

number_reads[RW]

The number of reads in the fragment (extension to SAM flag 0x1). Corresponds to the JSON property `numberReads` @return [Fixnum]

proper_placement[RW]

The orientation and the distance between reads from the fragment are consistent with the sequencing protocol (SAM flag 0x2). Corresponds to the JSON property `properPlacement` @return [Boolean]

proper_placement?[RW]

The orientation and the distance between reads from the fragment are consistent with the sequencing protocol (SAM flag 0x2). Corresponds to the JSON property `properPlacement` @return [Boolean]

read_group_id[RW]

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 Google::Apis::GenomicsV1::ReadGroup#name). Corresponds to the JSON property `readGroupId` @return [String]

read_group_set_id[RW]

The ID of the read group set this read belongs to. A read belongs to exactly one read group set. Corresponds to the JSON property `readGroupSetId` @return [String]

read_number[RW]

The read number in sequencing. 0-based and less than numberReads. This field replaces SAM flag 0x40 and 0x80. Corresponds to the JSON property `readNumber` @return [Fixnum]

secondary_alignment[RW]

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. Corresponds to the JSON property `secondaryAlignment` @return [Boolean]

secondary_alignment?[RW]

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. Corresponds to the JSON property `secondaryAlignment` @return [Boolean]

supplementary_alignment[RW]

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. Corresponds to the JSON property `supplementaryAlignment` @return [Boolean]

supplementary_alignment?[RW]

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. Corresponds to the JSON property `supplementaryAlignment` @return [Boolean]

Public Class Methods

new(**args) click to toggle source
# File generated/google/apis/genomics_v1/classes.rb, line 1883
def initialize(**args)
   update!(**args)
end

Public Instance Methods

update!(**args) click to toggle source

Update properties of this object

# File generated/google/apis/genomics_v1/classes.rb, line 1888
def update!(**args)
  @id = args[:id] if args.key?(:id)
  @read_group_id = args[:read_group_id] if args.key?(:read_group_id)
  @read_group_set_id = args[:read_group_set_id] if args.key?(:read_group_set_id)
  @fragment_name = args[:fragment_name] if args.key?(:fragment_name)
  @proper_placement = args[:proper_placement] if args.key?(:proper_placement)
  @duplicate_fragment = args[:duplicate_fragment] if args.key?(:duplicate_fragment)
  @fragment_length = args[:fragment_length] if args.key?(:fragment_length)
  @read_number = args[:read_number] if args.key?(:read_number)
  @number_reads = args[:number_reads] if args.key?(:number_reads)
  @failed_vendor_quality_checks = args[:failed_vendor_quality_checks] if args.key?(:failed_vendor_quality_checks)
  @alignment = args[:alignment] if args.key?(:alignment)
  @secondary_alignment = args[:secondary_alignment] if args.key?(:secondary_alignment)
  @supplementary_alignment = args[:supplementary_alignment] if args.key?(:supplementary_alignment)
  @aligned_sequence = args[:aligned_sequence] if args.key?(:aligned_sequence)
  @aligned_quality = args[:aligned_quality] if args.key?(:aligned_quality)
  @next_mate_position = args[:next_mate_position] if args.key?(:next_mate_position)
  @info = args[:info] if args.key?(:info)
end