private SAMRecord createUnmappedRead(String name) { return ArtificialSAMUtils.createArtificialRead( header, name, SAMRecord.NO_ALIGNMENT_REFERENCE_INDEX, SAMRecord.NO_ALIGNMENT_START, ArtificialSAMUtils.DEFAULT_READ_LENGTH); }
public static GATKSAMRecord createArtificialRead(Cigar cigar) { int length = cigar.getReadLength(); byte [] base = {'A'}; byte [] qual = {30}; byte [] bases = Utils.arrayFromArrayWithLength(base, length); byte [] quals = Utils.arrayFromArrayWithLength(qual, length); SAMFileHeader header = ArtificialSAMUtils.createArtificialSamHeader(); return ArtificialSAMUtils.createArtificialRead(header, "default_read", 0, 10000, bases, quals, cigar.toString()); }
for (int i = 0; i < pileupSize / 2; i++) { final String readName = "read" + i; final int leftStart = ranIntInclusive(ran, 1, pos); final int fragmentSize = (int) (ran.nextGaussian() * insertSizeVariation + insertSize); final int rightStart = leftStart + fragmentSize - readLen; List<GATKSAMRecord> pair = createPair(header, readName, readLen, leftStart, rightStart, leftIsFirst, leftIsNegative); final GATKSAMRecord left = pair.get(0); final GATKSAMRecord right = pair.get(1);
public Collection<SAMRecord> createReads() { Collection<SAMRecord> reads = new ArrayList<SAMRecord>(totalReads); SAMFileHeader header = ArtificialSAMUtils.createArtificialSamHeader(1, 1, 1000000); reads.addAll(ArtificialSAMUtils.createStackOfIdenticalArtificialReads(totalReads, header, "foo", 0, 1, 100)); return reads; } }
private SAMFileHeader createHeader() { SAMFileHeader header = ArtificialSAMUtils.createArtificialSamHeader(maxContigs, 1, (streamDensity.maxDistanceBetweenStacks + MAX_READ_LENGTH) * streamStacksPerContig.maxStacksPerContig + 100000); List<String> readGroups = new ArrayList<String>(numSamples); List<String> sampleNames = new ArrayList<String>(numSamples); for ( int i = 0; i < numSamples; i++ ) { readGroups.add("ReadGroup" + i); sampleNames.add("Sample" + i); } return ArtificialSAMUtils.createEnumeratedReadGroups(header, readGroups, sampleNames); }
/** * Creates an artificial sam header with standard test parameters * * @return the sam header */ public static SAMFileHeader createArtificialSamHeader() { return createArtificialSamHeader(1, 1, 1000000); }
@Test public void testSimplePositionalDownsamplerSignalNoMoreReadsBefore() { ReadsDownsampler<SAMRecord> downsampler = new SimplePositionalDownsampler<SAMRecord>(1000); SAMFileHeader header = ArtificialSAMUtils.createArtificialSamHeader(1, 1, 1000000); Collection<SAMRecord> readStack = new ArrayList<SAMRecord>(); readStack.addAll(ArtificialSAMUtils.createStackOfIdenticalArtificialReads(50, header, "foo", 0, 1, 100)); downsampler.submit(readStack); Assert.assertFalse(downsampler.hasFinalizedItems()); Assert.assertTrue(downsampler.peekFinalized() == null); Assert.assertTrue(downsampler.hasPendingItems()); Assert.assertTrue(downsampler.peekPending() != null); SAMRecord laterRead = ArtificialSAMUtils.createArtificialRead(header, "foo", 0, 2, 100); downsampler.signalNoMoreReadsBefore(laterRead); Assert.assertTrue(downsampler.hasFinalizedItems()); Assert.assertTrue(downsampler.peekFinalized() != null); Assert.assertFalse(downsampler.hasPendingItems()); Assert.assertTrue(downsampler.peekPending() == null); List<SAMRecord> downsampledReads = downsampler.consumeFinalizedItems(); Assert.assertEquals(downsampledReads.size(), readStack.size()); }
@Test public void testSecondaryAlignmentsDoNotCauseAccidentalRemovalOfMate() { final List<GATKSAMRecord> properReads = ArtificialSAMUtils.createPair(header, "foo", 1, 530, 1594, true, false); final GATKSAMRecord read1 = properReads.get(0); read1.setFlags(99); // first in proper pair, mate negative strand final GATKSAMRecord read2Primary = properReads.get(1); read2Primary.setFlags(147); // second in pair, mate unmapped, not primary alignment read2Primary.setAlignmentStart(1596); // move the read final GATKSAMRecord read2NonPrimary = new GATKSAMRecord(read2Primary); read2NonPrimary.setReadName("foo"); read2NonPrimary.setFlags(393); // second in proper pair, on reverse strand read2NonPrimary.setAlignmentStart(451); read2NonPrimary.setMateAlignmentStart(451); final ConstrainedMateFixingManager manager = new ConstrainedMateFixingManager(null, genomeLocParser, 10000, 200, 10000); manager.addRead(read2NonPrimary, false, false); manager.addRead(read1, false, false); for ( int i = 0; i < ConstrainedMateFixingManager.EMIT_FREQUENCY; i++ ) manager.addRead(ArtificialSAMUtils.createArtificialRead(header, "foo" + i, 0, 1500, 10), false, false); Assert.assertTrue(manager.forMateMatching.containsKey("foo")); }
@Override protected void setUp() { final int nPileupsToGenerate = 100; pileups = new ArrayList<ReadBackedPileup>(nPileupsToGenerate); SAMFileHeader header = ArtificialSAMUtils.createArtificialSamHeader(1, 1, 1000); GenomeLocParser genomeLocParser; genomeLocParser = new GenomeLocParser(header.getSequenceDictionary()); GenomeLoc loc = genomeLocParser.createGenomeLoc("chr1", 50); final int readLen = 100; for ( int pileupN = 0; pileupN < nPileupsToGenerate; pileupN++ ) { ReadBackedPileup rbp = ArtificialSAMUtils.createReadBackedPileup(header, loc, readLen, insertSize, pileupSize); pileups.add(rbp); } }
@Test(enabled = !DEBUG, expectedExceptions = IllegalArgumentException.class) public void testOutOfOrder() { final List<GATKSAMRecord> pair = ArtificialSAMUtils.createPair(header, "readpair", 100, 1, 50, true, true); final GATKSAMRecord left = pair.get(0); final GATKSAMRecord right = pair.get(1); final List<GATKSAMRecord> reads = Arrays.asList(right, left); // OUT OF ORDER! final List<Integer> offsets = Arrays.asList(0, 50); final ReadBackedPileup pileup = new ReadBackedPileupImpl(null, reads, offsets); FragmentUtils.create(pileup); // should throw exception }
/** * Create an iterator containing the specified reads * * @param reads the reads * @return iterator for the reads */ public static GATKSAMIterator createReadIterator(SAMRecord... reads) { return createReadIterator(Arrays.asList(reads)); }
private void makeReads() { int alignmentStart = 1; for ( int readsThisStack : readCountsPerAlignmentStart ) { ArrayList<GATKSAMRecord> stackReads = new ArrayList<GATKSAMRecord>(ArtificialSAMUtils.createStackOfIdenticalArtificialReads(readsThisStack, header, "foo", 0, alignmentStart, MathUtils.randomIntegerInRange(50, 100))); ArrayList<AlignmentStateMachine> stackRecordStates = new ArrayList<AlignmentStateMachine>(); for ( GATKSAMRecord read : stackReads ) { stackRecordStates.add(new AlignmentStateMachine(read)); } reads.addAll(stackReads); recordStatesByAlignmentStart.add(stackRecordStates); } } }
@BeforeClass private void init() throws IOException { referenceFile = new File(b37KGReference); reference = new CachingIndexedFastaSequenceFile(referenceFile); dictionary = reference.getSequenceDictionary(); genomeLocParser = new GenomeLocParser(dictionary); header = ArtificialSAMUtils.createDefaultReadGroup(new SAMFileHeader(), "test", "test"); header.setSequenceDictionary(dictionary); header.setSortOrder(SAMFileHeader.SortOrder.coordinate); readGroup = new GATKSAMReadGroupRecord(header.getReadGroup("test")); final List<GATKSAMRecord> reads = new ArrayList<>(); for ( final String contig : contigs ) { for ( int i = 1; i <= numReadsPerContig; i++ ) { reads.add(buildSAMRecord("read" + contig + "_" + i, contig, i)); } } createBAM(reads); }
/** * Composes the mock up SAM file header. * * It must return an equivalent (equal) value each time it is invoked. * * @return never <code>null</code>. */ protected SAMFileHeader composeHeader() { return ArtificialSAMUtils.createArtificialSamHeader( DEFAULT_CHROMOSOME_COUNT, DEFAULT_CHROMOSOME_START_INDEX, DEFAULT_CHROMOSOME_SIZE); }
public Collection<SAMRecord> createReads() { Collection<SAMRecord> reads = new ArrayList<SAMRecord>(totalReads); SAMFileHeader header = ArtificialSAMUtils.createArtificialSamHeader(1, 1, 1000000); reads.addAll(ArtificialSAMUtils.createStackOfIdenticalArtificialReads(totalReads, header, "foo", 0, 1, 100)); return reads; } }
private static final void addSAMHeader() { final SAMFileHeader header = ArtificialSAMUtils.createArtificialSamHeader(1, 1, 10); ArtificialSAMUtils.createEnumeratedReadGroups(header, Arrays.asList("1", "2", "3"), Arrays.asList("kid", "mom", "dad")); builder.addSamplesFromSAMHeader(header); }
private FragmentUtilsTest(String name, int readLen, int leftStart, int rightStart, boolean leftIsFirst, boolean leftIsNegative) { super(FragmentUtilsTest.class, String.format("%s-leftIsFirst:%b-leftIsNegative:%b", name, leftIsFirst, leftIsNegative)); List<GATKSAMRecord> pair = ArtificialSAMUtils.createPair(header, "readpair", readLen, leftStart, rightStart, leftIsFirst, leftIsNegative); GATKSAMRecord left = pair.get(0); GATKSAMRecord right = pair.get(1); for ( int pos = leftStart; pos < rightStart + readLen; pos++) { boolean posCoveredByLeft = pos >= left.getAlignmentStart() && pos <= left.getAlignmentEnd(); boolean posCoveredByRight = pos >= right.getAlignmentStart() && pos <= right.getAlignmentEnd(); if ( posCoveredByLeft || posCoveredByRight ) { List<GATKSAMRecord> reads = new ArrayList<>(); List<Integer> offsets = new ArrayList<>(); if ( posCoveredByLeft ) { reads.add(left); offsets.add(pos - left.getAlignmentStart()); } if ( posCoveredByRight ) { reads.add(right); offsets.add(pos - right.getAlignmentStart()); } boolean shouldBeFragment = posCoveredByLeft && posCoveredByRight; ReadBackedPileup pileup = new ReadBackedPileupImpl(null, reads, offsets); TestState testState = new TestState(shouldBeFragment ? 0 : 1, shouldBeFragment ? 1 : 0, pileup, null); statesForPileup.add(testState); } TestState testState = left.getAlignmentEnd() >= right.getAlignmentStart() ? new TestState(0, 1, null, pair) : new TestState(2, 0, null, pair); statesForReads.add(testState); } } }
@Test(expectedExceptions = ReviewedGATKException.class) public void testMappedAndUnmapped() { new IntervalOverlapFilteringIterator( ArtificialSAMUtils.createReadIterator(testReads), Arrays.asList(firstContig, GenomeLoc.UNMAPPED)); }
protected GATKSAMRecord buildSAMRecord(String readName, String contig, int alignmentStart, int alignmentEnd) { SAMFileHeader header = ArtificialSAMUtils.createDefaultReadGroup(new SAMFileHeader(), "test", "test"); header.setSequenceDictionary(dictionary); header.setSortOrder(SAMFileHeader.SortOrder.coordinate); GATKSAMRecord record = new GATKSAMRecord(header); record.setReadName(readName); record.setReferenceIndex(dictionary.getSequenceIndex(contig)); record.setAlignmentStart(alignmentStart); Cigar cigar = new Cigar(); int len = alignmentEnd - alignmentStart + 1; cigar.add(new CigarElement(len, CigarOperator.M)); record.setCigar(cigar); record.setReadString(new String(new char[len]).replace("\0", "A")); record.setBaseQualities(new byte[len]); record.setReadGroup(new GATKSAMReadGroupRecord(header.getReadGroup("test"))); return record; }
private SAMRecord createMappedRead(String name, int start) { return ArtificialSAMUtils.createArtificialRead( header, name, 0, start, ArtificialSAMUtils.DEFAULT_READ_LENGTH); } }