private void requireReadPaired() { if (!getReadPairedFlag()) { throw new IllegalStateException("Inappropriate call if not paired read"); } }
/** * @return The ith hit for a un-paired read. Never returns null. * Do not call if paired read. */ public SAMRecord getFragment(final int i) { final SAMRecord samRecord = firstOfPairOrFragment.get(i); if (samRecord.getReadPairedFlag()) throw new UnsupportedOperationException("getFragment called for paired read"); return samRecord; }
public static ReadOrdinality of(final SAMRecord sam) { if (!sam.getReadPairedFlag()) { return null; } return sam.getFirstOfPairFlag() ? ReadOrdinality.FIRST : ReadOrdinality.SECOND; } }
private void updateTotalClusters(final SAMRecord rec, final Map<String, GcObject> gcData) { for (final Map.Entry<String, GcObject> entry : gcData.entrySet()) { final GcObject gcCur = entry.getValue(); if (!rec.getReadPairedFlag() || rec.getFirstOfPairFlag()) ++gcCur.totalClusters; } }
/** * @throws if numHits() == 0 */ public boolean isPaired() { return getRepresentativeRead().getReadPairedFlag(); }
/** * Is the given read one for which we can fix its mate? * * @param read the read * @return true if we could fix its mate, false otherwise */ protected boolean isMateFixableRead(final SAMRecord read) { return read.getReadPairedFlag() && !read.isSecondaryOrSupplementary(); }
@Override public boolean filterOut(final SAMRecord rec) { if (!rec.getReadPairedFlag()) return true; final int ins = Math.abs(rec.getInferredInsertSize()); return ins < minInsertSize || ins > maxInsertSize; }
public String getPairedReadName() { final StringBuilder builder = new StringBuilder(64); builder.append(getReadName()); if (getReadPairedFlag()) { if (getFirstOfPairFlag()) { builder.append(" 1/2"); } else { builder.append(" 2/2"); } } return builder.toString(); }
@Override public boolean getReadPairedFlag() { if (!initializedFlags.contains(LazyFlag.READ_PAIRED)) { setReadPairedFlag(getReadPairedFlagImpl()); } return super.getReadPairedFlag(); }
private void countRecord(final SAMRecord rec) { final boolean isNegativeStrand = rec.getReadNegativeStrandFlag(); final boolean isReadTwo = rec.getReadPairedFlag() && rec.getSecondOfPairFlag(); if (isReadTwo) { if (isNegativeStrand) this.R2_NEG++; else this.R2_POS++; } else { if (isNegativeStrand) this.R1_NEG++; else this.R1_POS++; } }
private static boolean isPairedAndBothMapped(final SAMRecord record) { return record.getReadPairedFlag() && !record.getReadUnmappedFlag() && !record.getMateUnmappedFlag(); }
/** * Checks to see if it is valid for this record to have a mate CIGAR (MC) and then if there is a mate CIGAR available. This is done by * checking that this record is paired, its mate is mapped, and that it returns a non-null mate CIGAR. * * @param rec * @return */ public static boolean hasMateCigar(SAMRecord rec) { // NB: use getMateCigarString rather than getMateCigar to avoid validation. return (rec.getReadPairedFlag() && !rec.getMateUnmappedFlag() && null != SAMUtils.getMateCigarString(rec)); }
@Override protected void handleAdditionalRecords(SAMRecord currentRecord, Map<SAMReadGroupRecord, List<FastqWriter>> tagWriters, SAMRecord read1, SAMRecord read2) { final List<FastqWriter> rgTagWriters = tagWriters.get(currentRecord.getReadGroup()); if (currentRecord.getReadPairedFlag()) { if (read1 != null && read2 !=null) { writeTagRecords(read1, 1, rgTagWriters); writeTagRecords(read2, 2, rgTagWriters); } } else { writeTagRecords(currentRecord, null, rgTagWriters); } }
/** Updates the duplication metrics given the provided duplicate */ private void updateDuplicationMetrics(final ReadEndsForMateCigar duplicate, final DuplicationMetrics metrics) { // Update the duplication metrics if (!duplicate.getRecord().getReadPairedFlag() || duplicate.getRecord().getMateUnmappedFlag()) { ++metrics.UNPAIRED_READ_DUPLICATES; } else { ++metrics.READ_PAIR_DUPLICATES;// will need to be divided by 2 at the end } this.numDuplicates++; }
private int getMateReferenceIndex(final SAMRecord record) { if (record.getReadPairedFlag() && !record.getReadUnmappedFlag() && !record.getMateUnmappedFlag()) { return record.getMateReferenceIndex(); } else { return -1; } }
/** * The record should already have the DS and MC tags computed */ public void addRecord(final SAMRecord record) { if (record.getReadPairedFlag() && !record.getMateUnmappedFlag() && null == record.getAttribute(SAMTag.MC.getBinaryTag())) { throw new SAMException("Mate Cigar tag (MC) not found in: " + record.getReadName()); } this.records.add(record); }
public boolean filterOut(SAMRecord read) { return (! read.getReadPairedFlag() ) || read.getMateUnmappedFlag() || read.getDuplicateReadFlag() || read.getReadFailsVendorQualityCheckFlag() || (read.getMateNegativeStrandFlag() == read.getReadNegativeStrandFlag()); } }
private int getMateCoordinate(final SAMRecord record) { if (record.getReadPairedFlag() && !record.getReadUnmappedFlag() && !record.getMateUnmappedFlag()) { return record.getMateNegativeStrandFlag() ? SAMUtils.getMateUnclippedEnd(record) : SAMUtils.getMateUnclippedStart(record); } else { return -1; } }
private int getPairedOrientation(final SAMRecord record) { if (record.getReadPairedFlag() && !record.getReadUnmappedFlag() && !record.getMateUnmappedFlag()) { return getPairedOrientationByte(record.getReadNegativeStrandFlag(), record.getMateNegativeStrandFlag()); } else { return getFragmentOrientation(record); } }
/** * Converts a {@link SAMRecord} into a {@link FastqRecord}. */ public static FastqRecord asFastqRecord(final SAMRecord record) { String readName = record.getReadName(); if(record.getReadPairedFlag() && (record.getFirstOfPairFlag() || record.getSecondOfPairFlag())) { readName += (record.getFirstOfPairFlag()) ? FastqConstants.FIRST_OF_PAIR : FastqConstants.SECOND_OF_PAIR; } return new FastqRecord(readName, record.getReadString(), record.getStringAttribute(SAMTag.CO.name()), record.getBaseQualityString()); }