private static void addSpan(final int seqId, final int start, final int span, final int count, final Map<Integer, AlignmentSpan> map) { if (map.containsKey(seqId)) { map.get(seqId).add(start, span, count); } else { map.put(seqId, new AlignmentSpan(start, span, count)); } }
private static Map<Integer, AlignmentSpan> addAllSpans(final Map<Integer, AlignmentSpan> spanMap, final Map<Integer, AlignmentSpan> addition) { for (final Map.Entry<Integer, AlignmentSpan> entry:addition.entrySet()) { addSpan(entry.getKey(), entry.getValue().getStart(), entry.getValue().getCount(), entry.getValue().getSpan(), spanMap); } return spanMap; }
/** * Add multiple reads to the span. * * @param start alignment start * @param span alignment span * @param count number of reads to add */ public void add(final int start, final int span, final int count) { if (this.getStart() > start) { this.setSpan(Math.max(this.getStart() + this.getSpan(), start + span) - start); this.setStart(start); } else if (this.getStart() < start) { this.setSpan(Math.max(this.getStart() + this.getSpan(), start + span) - this.getStart()); } else { this.setSpan(Math.max(this.getSpan(), span)); } this.count += count; }
/** * Return a list of CRAI Entries; one for each reference in the multireference slice. * TODO: this should be refactored and delegate to container/slice */ private static Collection<CRAIEntry> getCRAIEntriesForMultiRefSlice( final Slice slice, final CompressionHeader header, final long containerOffset, final int[] landmarks) { final Map<Integer, AlignmentSpan> spans = slice.getMultiRefAlignmentSpans(header, ValidationStringency.DEFAULT_STRINGENCY); List<CRAIEntry> entries = new ArrayList<>(spans.size()); for (int seqId : spans.keySet()) { CRAIEntry e = new CRAIEntry(); e.sequenceId = seqId; AlignmentSpan span = spans.get(seqId); e.alignmentStart = span.getStart(); e.alignmentSpan = span.getSpan(); e.sliceSize = slice.size; e.sliceIndex = slice.index; e.containerStartOffset = containerOffset; e.sliceOffset = landmarks[slice.index]; entries.add(e); } return entries; }
public static Map<Integer, AlignmentSpan> getSpans(List<SAMRecord> samRecords) { Map<Integer, AlignmentSpan> spans = new HashMap<Integer, AlignmentSpan>(); int unmapped = 0; for (final SAMRecord r : samRecords) { int refId = r.getReferenceIndex(); if (refId == SAMRecord.NO_ALIGNMENT_REFERENCE_INDEX) { unmapped++; continue; } int start = r.getAlignmentStart(); int end = r.getAlignmentEnd(); if (spans.containsKey(refId)) { spans.get(refId).add(start, end - start, 1); } else { spans.put(refId, new AlignmentSpan(start, end - start)); } } if (unmapped > 0) { AlignmentSpan span = new AlignmentSpan(AlignmentSpan.UNMAPPED_SPAN.getStart(), AlignmentSpan.UNMAPPED_SPAN.getSpan(), unmapped); spans.put(SAMRecord.NO_ALIGNMENT_REFERENCE_INDEX, span); } return spans; }
private void readCramRecord() { final CramCompressionRecord cramRecord = new CramCompressionRecord(); super.read(cramRecord); if (APDelta) { currentAlignmentStart += cramRecord.alignmentDelta; } else { currentAlignmentStart = cramRecord.alignmentStart; } if (!spans.containsKey(cramRecord.sequenceId)) { spans.put(cramRecord.sequenceId, new AlignmentSpan(currentAlignmentStart, cramRecord.readLength)); } else { spans.get(cramRecord.sequenceId).addSingle(currentAlignmentStart, cramRecord.readLength); } } }
@Test public void testMultirefContainerWithUnmapped() { final List<AlignmentSpan> expectedSpans = new ArrayList<>(); expectedSpans.add(new AlignmentSpan(1, 3, 1)); expectedSpans.add(new AlignmentSpan(2, 3, 1)); Assert.assertEquals(unmappedSpan.getCount(), 1);
Assert.assertTrue(spans.containsKey(2)); Assert.assertTrue(spans.containsKey(SAMRecord.NO_ALIGNMENT_REFERENCE_INDEX)); Assert.assertEquals(spans.get(1), new AlignmentSpan(1, 5, 2)); Assert.assertEquals(spans.get(2), new AlignmentSpan(2, 3, 1)); Assert.assertNotNull(spans.get(SAMRecord.NO_ALIGNMENT_REFERENCE_INDEX));
/** * Add a single read to the span * * @param start alignment start * @param span read span on the reference */ public void addSingle(final int start, final int span) { add(start, span, 1); }
/** * Create index entries for a single container. * @param container the container to index */ public void processContainer(final Container container) { // TODO: this should be refactored and delegate to container/slice if (!container.isEOF()) { for (final Slice s: container.slices) { if (s.sequenceId == Slice.MULTI_REFERENCE) { final Map<Integer, AlignmentSpan> spans = s.getMultiRefAlignmentSpans(container.header, ValidationStringency.DEFAULT_STRINGENCY); this.entries.addAll(spans.entrySet().stream() .map(e -> new CRAIEntry(e.getKey(), e.getValue().getStart(), e.getValue().getSpan(), container.offset, container.landmarks[s.index], s.size)) .collect(Collectors.toList())); } else { entries.add(s.getCRAIEntry(container.offset)); } } } }
private void readCramRecord() { final CramCompressionRecord cramRecord = new CramCompressionRecord(); super.read(cramRecord); if (APDelta) { currentAlignmentStart += cramRecord.alignmentDelta; } else { currentAlignmentStart = cramRecord.alignmentStart; } if (!spans.containsKey(cramRecord.sequenceId)) { spans.put(cramRecord.sequenceId, new AlignmentSpan(currentAlignmentStart, cramRecord.readLength)); } else { spans.get(cramRecord.sequenceId).addSingle(currentAlignmentStart, cramRecord.readLength); } } }
/** * Create a new span with a multiple reads in it. * * @param start alignment start of the span * @param span alignment span * @param count number of reads in the span */ public AlignmentSpan(final int start, final int span, final int count) { this.setStart(start); this.setSpan(span); this.count = count; }
@Test public void testMultirefContainer() { final Map<Integer, AlignmentSpan> expectedSpans = new HashMap<>(); for (int i = 0; i < 10; i++) { expectedSpans.put(i, new AlignmentSpan(i + 1, 3, 1)); } final ContainerFactory factory = new ContainerFactory(ContainerFactoryTest.getSAMFileHeaderForTests(), TEST_RECORD_COUNT); final Container container = factory.buildContainer(ContainerFactoryTest.getMultiRefRecords()); final ContainerParser parser = new ContainerParser(ContainerFactoryTest.getSAMFileHeaderForTests()); final Map<Integer, AlignmentSpan> referenceSet = parser.getReferences(container, ValidationStringency.STRICT); Assert.assertEquals(referenceSet, expectedSpans); }
/** * Add a single read to the span * * @param start alignment start * @param span read span on the reference */ public void addSingle(final int start, final int span) { add(start, span, 1); }
private static Map<Integer, AlignmentSpan> addAllSpans(final Map<Integer, AlignmentSpan> spanMap, final Map<Integer, AlignmentSpan> addition) { for (final Map.Entry<Integer, AlignmentSpan> entry:addition.entrySet()) { addSpan(entry.getKey(), entry.getValue().getStart(), entry.getValue().getSpan(), entry.getValue().getCount(), spanMap); } return spanMap; }
/** * Add multiple reads to the span. * * @param start alignment start * @param span alignment span * @param count number of reads to add */ public void add(final int start, final int span, final int count) { if (this.getStart() > start) { this.setSpan(Math.max(this.getStart() + this.getSpan(), start + span) - start); this.setStart(start); } else if (this.getStart() < start) { this.setSpan(Math.max(this.getStart() + this.getSpan(), start + span) - this.getStart()); } else { this.setSpan(Math.max(this.getSpan(), span)); } this.count += count; }
private static void addSpan(final int seqId, final int start, final int span, final int count, final Map<Integer, AlignmentSpan> map) { if (map.containsKey(seqId)) { map.get(seqId).add(start, span, count); } else { map.put(seqId, new AlignmentSpan(start, span, count)); } }