コード例 #1
0
ファイル: ReadUtils.java プロジェクト: AriesLL/gatk
 /**
  * Check to ensure that the alignment makes sense based on the contents of the header.
  *
  * @param header The SAM file header.
  * @param read The read to verify.
  * @return true if alignment agrees with header, false otherwise.
  */
 public static boolean alignmentAgreesWithHeader(final SAMFileHeader header, final GATKRead read) {
   final int referenceIndex = getReferenceIndex(read, header);
   // Read is aligned to nonexistent contig
   if (!read.isUnmapped() && referenceIndex == SAMRecord.NO_ALIGNMENT_REFERENCE_INDEX) {
     return false;
   }
   final SAMSequenceRecord contigHeader = header.getSequence(referenceIndex);
   // Read is aligned to a point after the end of the contig
   return read.isUnmapped() || read.getStart() <= contigHeader.getSequenceLength();
 }
コード例 #2
0
ファイル: ReadUtils.java プロジェクト: AriesLL/gatk
 /**
  * Finds the adaptor boundary around the read and returns the first base inside the adaptor that
  * is closest to the read boundary. If the read is in the positive strand, this is the first base
  * after the end of the fragment (Picard calls it 'insert'), if the read is in the negative
  * strand, this is the first base before the beginning of the fragment.
  *
  * <p>There are two cases we need to treat here:
  *
  * <p>1) Our read is in the reverse strand :
  *
  * <p><----------------------| * |--------------------->
  *
  * <p>in these cases, the adaptor boundary is at the mate start (minus one)
  *
  * <p>2) Our read is in the forward strand :
  *
  * <p>|----------------------> * <----------------------|
  *
  * <p>in these cases the adaptor boundary is at the start of the read plus the inferred insert
  * size (plus one)
  *
  * @param read the read being tested for the adaptor boundary
  * @return the reference coordinate for the adaptor boundary (effectively the first base IN the
  *     adaptor, closest to the read. CANNOT_COMPUTE_ADAPTOR_BOUNDARY if the read is unmapped or
  *     the mate is mapped to another contig.
  */
 public static int getAdaptorBoundary(final GATKRead read) {
   if (!hasWellDefinedFragmentSize(read)) {
     return CANNOT_COMPUTE_ADAPTOR_BOUNDARY;
   } else if (read.isReverseStrand()) {
     return read.getMateStart() - 1; // case 1 (see header)
   } else {
     final int insertSize =
         Math.abs(
             read
                 .getFragmentLength()); // the inferred insert size can be negative if the mate is
                                        // mapped before the read (so we take the absolute value)
     return read.getStart() + insertSize + 1; // case 2 (see header)
   }
 }
コード例 #3
0
ファイル: ReadUtils.java プロジェクト: AriesLL/gatk
  /**
   * Calculates the reference coordinate for the beginning of the read taking into account soft
   * clips but not hard clips.
   *
   * <p>Note: getUnclippedStart() adds soft and hard clips, this function only adds soft clips.
   *
   * @param read the read
   * @param cigar the read's cigar
   *     <p>Note: this overload of the function takes the cigar as input for speed because getCigar
   *     is an expensive operation. Most callers should use the overload that does not take the
   *     cigar.
   * @return the unclipped start of the read taking soft clips (but not hard clips) into account
   */
  public static int getSoftStart(final GATKRead read, final Cigar cigar) {
    Utils.nonNull(read, "read");
    Utils.nonNull(cigar, "cigar");

    int softStart = read.getStart();
    for (final CigarElement cig : cigar.getCigarElements()) {
      final CigarOperator op = cig.getOperator();

      if (op == CigarOperator.SOFT_CLIP) {
        softStart -= cig.getLength();
      } else if (op != CigarOperator.HARD_CLIP) {
        break;
      }
    }
    return softStart;
  }
コード例 #4
0
ファイル: ReadUtils.java プロジェクト: AriesLL/gatk
  /**
   * Can the adaptor sequence of read be reliably removed from the read based on the alignment of
   * read and its mate?
   *
   * @param read the read to check
   * @return true if it can, false otherwise
   */
  public static boolean hasWellDefinedFragmentSize(final GATKRead read) {
    if (read.getFragmentLength() == 0)
    // no adaptors in reads with mates in another chromosome or unmapped pairs
    {
      return false;
    }
    if (!read.isPaired())
    // only reads that are paired can be adaptor trimmed
    {
      return false;
    }
    if (read.isUnmapped() || read.mateIsUnmapped())
    // only reads when both reads are mapped can be trimmed
    {
      return false;
    }
    //        if ( ! read.isProperlyPaired() )
    //            // note this flag isn't always set properly in BAMs, can will stop us from
    // eliminating some proper pairs
    //            // reads that aren't part of a proper pair (i.e., have strange alignments) can't
    // be trimmed
    //            return false;
    if (read.isReverseStrand() == read.mateIsReverseStrand())
    // sanity check on isProperlyPaired to ensure that read1 and read2 aren't on the same strand
    {
      return false;
    }

    if (read.isReverseStrand()) {
      // we're on the negative strand, so our read runs right to left
      return read.getEnd() > read.getMateStart();
    } else {
      // we're on the positive strand, so our mate should be to our right (his start + insert size
      // should be past our start)
      return read.getStart() <= read.getMateStart() + read.getFragmentLength();
    }
  }
コード例 #5
0
ファイル: ReadUtils.java プロジェクト: AriesLL/gatk
 /**
  * Is a base inside a read?
  *
  * @param read the read to evaluate
  * @param referenceCoordinate the reference coordinate of the base to test
  * @return true if it is inside the read, false otherwise.
  */
 public static boolean isInsideRead(final GATKRead read, final int referenceCoordinate) {
   return referenceCoordinate >= read.getStart() && referenceCoordinate <= read.getEnd();
 }