public String getPairOrientation() {
// LOG.info("getPairOrientation");
String pairOrientation = "";
if (EntryFlagHelper.isPaired(entry)
&& !EntryFlagHelper.isMateUnmapped(entry)
&& entry.getTargetIndex() == entry.getPairAlignmentLink().getTargetIndex()) {
char s1 = EntryFlagHelper.isReadReverseStrand(entry) ? 'R' : 'F';
char s2 = EntryFlagHelper.isMateReverseStrand(entry) ? 'R' : 'F';
char o1 = ' ';
char o2 = ' ';
char[] tmp = new char[4];
if (EntryFlagHelper.isFirstInPair(entry)) {
o1 = '1';
o2 = '2';
} else if (EntryFlagHelper.isSecondInPair(entry)) {
o1 = '2';
o2 = '1';
}
if (getInferredInsertSize() > 0) {
tmp[0] = s1;
tmp[1] = o1;
tmp[2] = s2;
tmp[3] = o2;
} else {
tmp[2] = s1;
tmp[3] = o1;
tmp[0] = s2;
tmp[1] = o2;
}
pairOrientation = new String(tmp);
}
return pairOrientation;
}
/**
* Determine if this iterator has more alignment entries in the given window.
*
* @return True if next() will return an alignment, False otherwise.
*/
public boolean hasNext() {
/* LOG.debug(String.format("previousPosition: %d endReferencePosition %d previousReferenceIndex %d targetIndex %d",
previousPosition, endReferencePosition, previousReferenceIndex, targetIndex)
); */
// Fetch the next entry with skipTo
if (nextEntry != null) return true;
try {
if (!useWindow) {
// all results are returned
if (!reader.hasNext()) return false;
nextEntry = reader.next();
} else {
// we return only within a window
nextEntry = reader.skipTo(targetIndex, startReferencePosition);
if (nextEntry == null
|| (nextEntry.getTargetIndex() != targetIndex
|| nextEntry.getPosition() < startReferencePosition
|| nextEntry.getPosition() > endReferencePosition)) {
// No next entry, on a different target sequence, or before the position of interest:
nextEntry = null;
}
}
} catch (IOException e) {
nextEntry = null;
LOG.error(e);
// throw new RuntimeException("IO error reading next Goby alignment entry", e);
return false;
} catch (GobyRuntimeException e) {
nextEntry = null;
LOG.error(e);
// throw new RuntimeException("IO error reading next Goby alignment entry", e);
return false;
}
final boolean result = nextEntry != null;
// LOG.debug("hasNext returning :" + result);
return result;
}
/**
* Verify that the list has an appropriate unbroken chain of back links.
*
* @param list the list of splices to validate
* @return true if the list has an unbroken chain of back links
*/
boolean spliceListIsValid(final ObjectArrayList<GobyAlignment> list) {
if (list != null && list.size() > 1) {
Alignments.AlignmentEntry prevEntry = list.get(0).entry;
for (int i = 1; i < list.size(); i++) {
Alignments.AlignmentEntry currentEntry = list.get(i).entry;
if (!currentEntry.hasSplicedBackwardAlignmentLink()) return false;
else {
Alignments.RelatedAlignmentEntry currentBackwardLink =
currentEntry.getSplicedBackwardAlignmentLink();
if ((prevEntry.getQueryIndex() != currentEntry.getQueryIndex())
|| (prevEntry.getFragmentIndex() != currentBackwardLink.getFragmentIndex())
|| (prevEntry.getPosition() != currentBackwardLink.getPosition())
|| (prevEntry.getTargetIndex() != currentBackwardLink.getTargetIndex())) {
return false;
}
}
prevEntry = currentEntry;
}
}
return true;
}
@Test
public void testLastToCompact1() throws IOException {
// test LastToCompact convert+filtering
// read fake data and convert+filter
final LastToCompactMode processor = new LastToCompactMode();
final int LAST_TO_COMPACT_M_PARAM = 2;
processor.setAmbiguityThreshold(LAST_TO_COMPACT_M_PARAM);
processor.setInputFile("test-results/alignments/last-to-compact/last-101.maf");
processor.setOutputFile("test-results/alignments/last-to-compact/last-101.compact");
processor.setTargetReferenceIdsFilename(
"test-results/alignments/last-to-compact/last-reference.compact-reads");
processor.setOnlyMafFile(true);
processor.setNumberOfReads(2857819);
processor.setLargestQueryIndex(2857819);
processor.setSmallestQueryIndex(0);
processor.setPropagateQueryIds(false);
processor.setPropagateTargetIds(true);
processor.execute();
// read compact alignment results
final AlignmentReaderImpl reader = new AlignmentReaderImpl(processor.getOutputFile());
reader.readHeader();
assertEquals(2857819, reader.getNumberOfQueries());
assertEquals(1, reader.getNumberOfTargets());
assertTrue(reader.hasQueryIndexOccurrences());
// lookup tables
final Int2IntOpenHashMap queryIndex2NumberOfHits = new Int2IntOpenHashMap();
final Int2FloatOpenHashMap queryIndex2Score = new Int2FloatOpenHashMap();
final Int2IntOpenHashMap queryIndex2Multiplicity = new Int2IntOpenHashMap();
final Int2IntOpenHashMap queryIndex2NumberOfIndels = new Int2IntOpenHashMap();
final Int2IntOpenHashMap queryIndex2NumberOfMismatches = new Int2IntOpenHashMap();
final Int2IntOpenHashMap queryIndex2Position = new Int2IntOpenHashMap();
final Int2IntOpenHashMap queryIndex2QueryAlignedLength = new Int2IntOpenHashMap();
final Int2IntOpenHashMap queryIndex2QueryPosition = new Int2IntOpenHashMap();
final Int2IntOpenHashMap queryIndex2TargetIndex = new Int2IntOpenHashMap();
final Int2BooleanOpenHashMap queryIndex2MatchingReverseStrand = new Int2BooleanOpenHashMap();
final Int2IntOpenHashMap queryIndex2TargetAlignedLength = new Int2IntOpenHashMap();
final Int2IntOpenHashMap queryIndex2QueryIndexOcc = new Int2IntOpenHashMap();
final Int2IntOpenHashMap queryIndex2Ambiguity = new Int2IntOpenHashMap();
// enter alignment data
int qii;
while (reader.hasNext()) {
final Alignments.AlignmentEntry aln = reader.next();
qii = aln.getQueryIndex();
final int numHits = queryIndex2NumberOfHits.get(qii);
queryIndex2NumberOfHits.put(qii, numHits + 1);
queryIndex2Score.put(qii, aln.getScore());
queryIndex2Multiplicity.put(qii, aln.getMultiplicity());
queryIndex2NumberOfIndels.put(qii, aln.getNumberOfIndels());
queryIndex2NumberOfMismatches.put(qii, aln.getNumberOfMismatches());
queryIndex2Position.put(qii, aln.getPosition());
queryIndex2QueryAlignedLength.put(qii, aln.getQueryAlignedLength());
queryIndex2QueryPosition.put(qii, aln.getQueryPosition());
queryIndex2TargetIndex.put(qii, aln.getTargetIndex());
queryIndex2MatchingReverseStrand.put(qii, aln.getMatchingReverseStrand());
queryIndex2TargetAlignedLength.put(qii, aln.getTargetAlignedLength());
queryIndex2QueryIndexOcc.put(qii, aln.getQueryIndexOccurrences());
queryIndex2Ambiguity.put(qii, aln.getAmbiguity());
}
//
// validate alignment data using values from getMafInput() below
//
// there are a total of 5 entries with ID 2857818
// 2 entries have score = 35 (the maximum score for this ID)
// 3 entries are filtered b/c their scores are below 35
qii = 2857818;
assertEquals(queryIndex2NumberOfHits.get(qii), 2);
assertEquals((int) queryIndex2Score.get(qii), 35);
assertEquals(queryIndex2Multiplicity.get(qii), 1);
assertEquals(queryIndex2NumberOfIndels.get(qii), 0);
assertEquals(queryIndex2NumberOfMismatches.get(qii), 0);
assertEquals(queryIndex2Position.get(qii), 1614); // last entry added
assertEquals(queryIndex2QueryAlignedLength.get(qii), 35);
assertEquals(queryIndex2QueryPosition.get(qii), 0);
assertEquals(queryIndex2TargetIndex.get(qii), 0);
assertEquals(queryIndex2MatchingReverseStrand.get(qii), false);
assertEquals(queryIndex2TargetAlignedLength.get(qii), 35);
assertEquals(2, queryIndex2QueryIndexOcc.get(qii));
assertEquals(2, queryIndex2Ambiguity.get(qii));
// there are 5 entries with the score = 35 (the maximum score for this ID)
// filtered due to ambiguity
qii = 577287;
assertEquals(queryIndex2NumberOfHits.get(qii), 0);
assertEquals((int) queryIndex2Score.get(qii), 0);
assertEquals(queryIndex2Multiplicity.get(qii), 0);
assertEquals(queryIndex2NumberOfIndels.get(qii), 0);
assertEquals(queryIndex2NumberOfMismatches.get(qii), 0);
assertEquals(queryIndex2Position.get(qii), 0);
assertEquals(queryIndex2QueryAlignedLength.get(qii), 0);
assertEquals(queryIndex2QueryPosition.get(qii), 0);
assertEquals(queryIndex2TargetIndex.get(qii), 0);
assertEquals(queryIndex2MatchingReverseStrand.get(qii), false);
assertEquals(queryIndex2TargetAlignedLength.get(qii), 0);
assertEquals(0, queryIndex2QueryIndexOcc.get(qii));
assertEquals(0, queryIndex2Ambiguity.get(qii));
//
reader.close();
}
/** Get the reference id from the iterator, prepend "chr". */
public String getChromosome() {
return "chr" + iterator.indexToReferenceId.getId(entry.getTargetIndex()).toString();
}