private int compareCoordinates(final SAMRecord record1, final SAMRecord record2) {
final int seqIndex1 = record1.getReferenceIndex();
final int seqIndex2 = record2.getReferenceIndex();
if (seqIndex1 == -1) {
return ((seqIndex2 == -1) ? 0 : -1);
} else if (seqIndex2 == -1) {
return 1;
}
int result = seqIndex1 - seqIndex2;
if (result != 0) {
return result;
}
result = record1.getAlignmentStart() - record2.getAlignmentStart();
return result;
}
/**
* HACK TO CREATE GATKSAMRECORD BASED ONLY A SAMRECORD FOR TESTING PURPOSES ONLY
*
* @param read
*/
public GATKSAMRecord(final SAMRecord read) {
super(read.getHeader());
super.setReferenceIndex(read.getReferenceIndex());
super.setAlignmentStart(read.getAlignmentStart());
super.setReadName(read.getReadName());
super.setMappingQuality(read.getMappingQuality());
// indexing bin done below
super.setCigar(read.getCigar());
super.setFlags(read.getFlags());
super.setMateReferenceIndex(read.getMateReferenceIndex());
super.setMateAlignmentStart(read.getMateAlignmentStart());
super.setInferredInsertSize(read.getInferredInsertSize());
SAMReadGroupRecord samRG = read.getReadGroup();
SAMBinaryTagAndValue samAttr = GATKBin.getReadBinaryAttributes(read);
if (samAttr == null) {
clearAttributes();
} else {
setAttributes(samAttr);
}
if (samRG != null) {
GATKSAMReadGroupRecord rg = new GATKSAMReadGroupRecord(samRG);
setReadGroup(rg);
}
super.setFileSource(read.getFileSource());
super.setReadName(read.getReadName());
super.setCigarString(read.getCigarString());
super.setReadBases(read.getReadBases());
super.setBaseQualities(read.getBaseQualities());
// From SAMRecord constructor: Do this after the above because setCigarString will clear it.
GATKBin.setReadIndexingBin(this, GATKBin.getReadIndexingBin(read));
}
/** Tests that we can successfully merge two files with */
@Test
public void testMerging() {
File INPUT[] = {
new File(TEST_DATA_DIR, "SamFileHeaderMergerTest/Chromosome1to10.bam"),
new File(TEST_DATA_DIR, "SamFileHeaderMergerTest/Chromosome5to9.bam")
};
final List<SAMFileReader> readers = new ArrayList<SAMFileReader>();
final List<SAMFileHeader> headers = new ArrayList<SAMFileHeader>();
for (final File inFile : INPUT) {
IOUtil.assertFileIsReadable(inFile);
final SAMFileReader in = new SAMFileReader(inFile);
// We are now checking for zero-length reads, so suppress complaint about that.
in.setValidationStringency(ValidationStringency.SILENT);
readers.add(in);
headers.add(in.getFileHeader());
}
final MergingSamRecordIterator iterator;
final SamFileHeaderMerger headerMerger =
new SamFileHeaderMerger(SAMFileHeader.SortOrder.unsorted, headers, true);
iterator = new MergingSamRecordIterator(headerMerger, readers, false);
headerMerger.getMergedHeader();
// count the total reads, and record read counts for each sequence
Map<Integer, Integer> seqCounts = new HashMap<Integer, Integer>();
int totalCount = 0;
while (iterator.hasNext()) {
SAMRecord r = iterator.next();
if (seqCounts.containsKey(r.getReferenceIndex())) {
seqCounts.put(r.getReferenceIndex(), seqCounts.get(r.getReferenceIndex()) + 1);
} else {
seqCounts.put(r.getReferenceIndex(), 1);
}
++totalCount;
}
assertEquals(totalCount, 1500);
for (Integer i : seqCounts.keySet()) {
if (i < 4 || i > 8) {
// seqeunce 5 - 9 should have 200 reads (indices 4 - 8)
assertEquals(seqCounts.get(i).intValue(), 100);
} else {
// the others should have 100
assertEquals(seqCounts.get(i).intValue(), 200);
}
}
}
/**
* Record any index information for a given BAM record. If this alignment starts a new reference,
* write out the old reference. Requires a non-null value for rec.getFileSource().
*
* @param rec The BAM record
*/
public void processAlignment(final SAMRecord rec) {
try {
final int reference = rec.getReferenceIndex();
if (reference != SAMRecord.NO_ALIGNMENT_REFERENCE_INDEX && reference != currentReference) {
// process any completed references
advanceToReference(reference);
}
indexBuilder.processAlignment(rec);
} catch (final Exception e) {
throw new SAMException("Exception creating BAM index for record " + rec, e);
}
}
/**
* Record any index information for a given BAM record
*
* @param rec The BAM record. Requires rec.getFileSource() is non-null.
*/
public void processAlignment(final SAMRecord rec) {
// metadata
indexStats.recordMetaData(rec);
if (rec.getAlignmentStart() == SAMRecord.NO_ALIGNMENT_START) {
return; // do nothing for records without coordinates, but count them
}
// various checks
final int reference = rec.getReferenceIndex();
if (reference != currentReference) {
throw new SAMException(
"Unexpected reference "
+ reference
+ " when constructing index for "
+ currentReference
+ " for record "
+ rec);
}
binningIndexBuilder.processFeature(
new BinningIndexBuilder.FeatureToBeIndexed() {
@Override
public int getStart() {
return rec.getAlignmentStart();
}
@Override
public int getEnd() {
return rec.getAlignmentEnd();
}
@Override
public Integer getIndexingBin() {
final Integer binNumber = rec.getIndexingBin();
return (binNumber == null ? rec.computeIndexingBin() : binNumber);
}
@Override
public Chunk getChunk() {
final SAMFileSource source = rec.getFileSource();
if (source == null) {
throw new SAMException(
"No source (virtual file offsets); needed for indexing on BAM Record " + rec);
}
return ((BAMFileSpan) source.getFilePointer()).getSingleChunk();
}
});
}
private void collectReadData(final SAMRecord record, final ReferenceSequence ref) {
metrics.TOTAL_READS++;
readLengthHistogram.increment(record.getReadBases().length);
if (!record.getReadFailsVendorQualityCheckFlag()) {
metrics.PF_READS++;
if (isNoiseRead(record)) metrics.PF_NOISE_READS++;
if (record.getReadUnmappedFlag()) {
// If the read is unmapped see if it's adapter sequence
final byte[] readBases = record.getReadBases();
if (!(record instanceof BAMRecord)) StringUtil.toUpperCase(readBases);
if (isAdapterSequence(readBases)) {
this.adapterReads++;
}
} else if (doRefMetrics) {
metrics.PF_READS_ALIGNED++;
if (!record.getReadNegativeStrandFlag()) numPositiveStrand++;
if (record.getReadPairedFlag() && !record.getMateUnmappedFlag()) {
metrics.READS_ALIGNED_IN_PAIRS++;
// Check that both ends have mapq > minimum
final Integer mateMq = record.getIntegerAttribute("MQ");
if (mateMq == null
|| mateMq >= MAPPING_QUALITY_THRESOLD
&& record.getMappingQuality() >= MAPPING_QUALITY_THRESOLD) {
++this.chimerasDenominator;
// With both reads mapped we can see if this pair is chimeric
if (Math.abs(record.getInferredInsertSize()) > maxInsertSize
|| !record.getReferenceIndex().equals(record.getMateReferenceIndex())) {
++this.chimeras;
}
}
}
}
}
}
