zzh
/
gatk-3.8
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

All integration tests and VC/Allele unit tests are passing

This commit is contained in:
Eric Banks 2012-07-27 17:03:49 -04:00
parent beb7610195
commit 2b1b00ade5
4 changed files with 22 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
protected/java/src/org/broadinstitute/sting/gatk/walkers/genotyper/PoolIndelGenotypeLikelihoodsCalculationModel.java
View File

@ -42,7 +42,6 @@ public class PoolIndelGenotypeLikelihoodsCalculationModel extends PoolGenotypeLi
private static final int MAX_NUM_ALLELES_TO_GENOTYPE = 4; private static final int MAX_NUM_ALLELES_TO_GENOTYPE = 4;
private PairHMMIndelErrorModel pairModel; private PairHMMIndelErrorModel pairModel;
private boolean allelesArePadded = false;
/* /*
private static ThreadLocal<HashMap<PileupElement, LinkedHashMap<Allele, Double>>> indelLikelihoodMap = private static ThreadLocal<HashMap<PileupElement, LinkedHashMap<Allele, Double>>> indelLikelihoodMap =
new ThreadLocal<HashMap<PileupElement, LinkedHashMap<Allele, Double>>>() { new ThreadLocal<HashMap<PileupElement, LinkedHashMap<Allele, Double>>>() {
@ -88,12 +87,10 @@ public class PoolIndelGenotypeLikelihoodsCalculationModel extends PoolGenotypeLi
final List<Allele> allAllelesToUse){ final List<Allele> allAllelesToUse){
final Pair<List<Allele>,Boolean> pair = IndelGenotypeLikelihoodsCalculationModel.getInitialAlleleList(tracker, ref, contexts, contextType, locParser, UAC,true); List<Allele> alleles = IndelGenotypeLikelihoodsCalculationModel.getInitialAlleleList(tracker, ref, contexts, contextType, locParser, UAC,true);
List<Allele> alleles = pair.first;
if (alleles.size() > MAX_NUM_ALLELES_TO_GENOTYPE) if (alleles.size() > MAX_NUM_ALLELES_TO_GENOTYPE)
alleles = alleles.subList(0,MAX_NUM_ALLELES_TO_GENOTYPE); alleles = alleles.subList(0,MAX_NUM_ALLELES_TO_GENOTYPE);
allelesArePadded = pair.second;
if (contextType == AlignmentContextUtils.ReadOrientation.COMPLETE) { if (contextType == AlignmentContextUtils.ReadOrientation.COMPLETE) {
IndelGenotypeLikelihoodsCalculationModel.getIndelLikelihoodMap().clear(); IndelGenotypeLikelihoodsCalculationModel.getIndelLikelihoodMap().clear();
haplotypeMap.clear(); haplotypeMap.clear();
@ -121,6 +118,6 @@ public class PoolIndelGenotypeLikelihoodsCalculationModel extends PoolGenotypeLi
protected int getEndLocation(final RefMetaDataTracker tracker, protected int getEndLocation(final RefMetaDataTracker tracker,
final ReferenceContext ref, final ReferenceContext ref,
final List<Allele> allelesToUse) { final List<Allele> allelesToUse) {
return IndelGenotypeLikelihoodsCalculationModel.computeEndLocation(allelesToUse, ref.getLocus(), allelesArePadded); return ref.getLocus().getStart() + allelesToUse.get(0).length() - 1;
} }
} }

11
public/java/src/org/broadinstitute/sting/utils/variantcontext/Allele.java
View File

@ -180,14 +180,9 @@ public class Allele implements Comparable<Allele> {
public static Allele extend(Allele left, byte[] right) { public static Allele extend(Allele left, byte[] right) {
if (left.isSymbolic()) if (left.isSymbolic())
throw new IllegalArgumentException("Cannot extend a symbolic allele"); throw new IllegalArgumentException("Cannot extend a symbolic allele");
byte[] bases; byte[] bases = new byte[left.length() + right.length];
if ( left.length() == 0 ) System.arraycopy(left.getBases(), 0, bases, 0, left.length());
bases = right; System.arraycopy(right, 0, bases, left.length(), right.length);
else {
bases = new byte[left.length() + right.length];
System.arraycopy(left.getBases(), 0, bases, 0, left.length());
System.arraycopy(right, 0, bases, left.length(), right.length);
}
return create(bases, left.isReference()); return create(bases, left.isReference());
} }

32
public/java/test/org/broadinstitute/sting/utils/variantcontext/AlleleUnitTest.java
View File

@ -47,13 +47,10 @@ import org.testng.annotations.Test;
* Basic unit test for RecalData * Basic unit test for RecalData
*/ */
public class AlleleUnitTest { public class AlleleUnitTest {
Allele ARef, del, delRef, A, T, ATIns, ATCIns, NoCall; Allele ARef, A, T, ATIns, ATCIns, NoCall;
@BeforeSuite @BeforeSuite
public void before() { public void before() {
del = Allele.create("-");
delRef = Allele.create("-", true);
A = Allele.create("A"); A = Allele.create("A");
ARef = Allele.create("A", true); ARef = Allele.create("A", true);
T = Allele.create("T"); T = Allele.create("T");
@ -99,14 +96,6 @@ public class AlleleUnitTest {
Assert.assertEquals(ATCIns.length(), 3); Assert.assertEquals(ATCIns.length(), 3);
Assert.assertEquals(ATIns.getBases(), "AT".getBytes()); Assert.assertEquals(ATIns.getBases(), "AT".getBytes());
Assert.assertEquals(ATCIns.getBases(), "ATC".getBytes()); Assert.assertEquals(ATCIns.getBases(), "ATC".getBytes());
Assert.assertTrue(del.isNonReference());
Assert.assertFalse(delRef.isNonReference());
Assert.assertFalse(del.isReference());
Assert.assertTrue(delRef.isReference());
Assert.assertFalse(del.basesMatch("-"));
Assert.assertTrue(del.basesMatch(""));
Assert.assertEquals(del.length(), 0);
} }
@ -122,18 +111,6 @@ public class AlleleUnitTest {
Assert.assertFalse(a1.equals(a4)); Assert.assertFalse(a1.equals(a4));
} }
@Test
public void testDelConstructors() {
Allele a1 = Allele.create("-");
Allele a2 = Allele.create("-".getBytes());
Allele a3 = Allele.create("");
Allele a4 = Allele.create("", true);
Assert.assertTrue(a1.equals(a2));
Assert.assertTrue(a1.equals(a3));
Assert.assertFalse(a1.equals(a4));
}
@Test @Test
public void testInsConstructors() { public void testInsConstructors() {
Allele a1 = Allele.create("AC"); Allele a1 = Allele.create("AC");
@ -150,7 +127,6 @@ public class AlleleUnitTest {
public void testEquals() { public void testEquals() {
Assert.assertTrue(ARef.basesMatch(A)); Assert.assertTrue(ARef.basesMatch(A));
Assert.assertFalse(ARef.equals(A)); Assert.assertFalse(ARef.equals(A));
Assert.assertFalse(ARef.equals(del));
Assert.assertFalse(ARef.equals(ATIns)); Assert.assertFalse(ARef.equals(ATIns));
Assert.assertFalse(ARef.equals(ATCIns)); Assert.assertFalse(ARef.equals(ATCIns));
@ -158,11 +134,6 @@ public class AlleleUnitTest {
Assert.assertFalse(T.basesMatch(A)); Assert.assertFalse(T.basesMatch(A));
Assert.assertFalse(T.equals(A)); Assert.assertFalse(T.equals(A));
Assert.assertTrue(del.basesMatch(del));
Assert.assertTrue(del.basesMatch(delRef));
Assert.assertTrue(del.equals(del));
Assert.assertFalse(del.equals(delRef));
Assert.assertTrue(ATIns.equals(ATIns)); Assert.assertTrue(ATIns.equals(ATIns));
Assert.assertFalse(ATIns.equals(ATCIns)); Assert.assertFalse(ATIns.equals(ATCIns));
Assert.assertTrue(ATIns.basesMatch("AT")); Assert.assertTrue(ATIns.basesMatch("AT"));
@ -203,7 +174,6 @@ public class AlleleUnitTest {
public void testExtend() { public void testExtend() {
Assert.assertEquals("AT", Allele.extend(Allele.create("A"), "T".getBytes()).toString()); Assert.assertEquals("AT", Allele.extend(Allele.create("A"), "T".getBytes()).toString());
Assert.assertEquals("ATA", Allele.extend(Allele.create("A"), "TA".getBytes()).toString()); Assert.assertEquals("ATA", Allele.extend(Allele.create("A"), "TA".getBytes()).toString());
Assert.assertEquals("A", Allele.extend(Allele.create("-"), "A".getBytes()).toString());
Assert.assertEquals("A", Allele.extend(Allele.NO_CALL, "A".getBytes()).toString()); Assert.assertEquals("A", Allele.extend(Allele.NO_CALL, "A".getBytes()).toString());
Assert.assertEquals("ATCGA", Allele.extend(Allele.create("AT"), "CGA".getBytes()).toString()); Assert.assertEquals("ATCGA", Allele.extend(Allele.create("AT"), "CGA".getBytes()).toString());
Assert.assertEquals("ATCGA", Allele.extend(Allele.create("ATC"), "GA".getBytes()).toString()); Assert.assertEquals("ATCGA", Allele.extend(Allele.create("ATC"), "GA".getBytes()).toString());

42
public/java/test/org/broadinstitute/sting/utils/variantcontext/VariantContextUnitTest.java
View File

@ -381,13 +381,13 @@ public class VariantContextUnitTest extends BaseTest {
@Test @Test
public void testAccessingCompleteGenotypes() { public void testAccessingCompleteGenotypes() {
List<Allele> alleles = Arrays.asList(Aref, T, del); List<Allele> alleles = Arrays.asList(Aref, T, ATC);
Genotype g1 = GenotypeBuilder.create("AA", Arrays.asList(Aref, Aref)); Genotype g1 = GenotypeBuilder.create("AA", Arrays.asList(Aref, Aref));
Genotype g2 = GenotypeBuilder.create("AT", Arrays.asList(Aref, T)); Genotype g2 = GenotypeBuilder.create("AT", Arrays.asList(Aref, T));
Genotype g3 = GenotypeBuilder.create("TT", Arrays.asList(T, T)); Genotype g3 = GenotypeBuilder.create("TT", Arrays.asList(T, T));
Genotype g4 = GenotypeBuilder.create("Td", Arrays.asList(T, del)); Genotype g4 = GenotypeBuilder.create("Td", Arrays.asList(T, ATC));
Genotype g5 = GenotypeBuilder.create("dd", Arrays.asList(del, del)); Genotype g5 = GenotypeBuilder.create("dd", Arrays.asList(ATC, ATC));
Genotype g6 = GenotypeBuilder.create("..", Arrays.asList(Allele.NO_CALL, Allele.NO_CALL)); Genotype g6 = GenotypeBuilder.create("..", Arrays.asList(Allele.NO_CALL, Allele.NO_CALL));
VariantContext vc = new VariantContextBuilder("test", snpLoc, snpLocStart, snpLocStop, alleles) VariantContext vc = new VariantContextBuilder("test", snpLoc, snpLocStart, snpLocStop, alleles)
@ -403,7 +403,7 @@ public class VariantContextUnitTest extends BaseTest {
Assert.assertEquals(10, vc.getCalledChrCount()); Assert.assertEquals(10, vc.getCalledChrCount());
Assert.assertEquals(3, vc.getCalledChrCount(Aref)); Assert.assertEquals(3, vc.getCalledChrCount(Aref));
Assert.assertEquals(4, vc.getCalledChrCount(T)); Assert.assertEquals(4, vc.getCalledChrCount(T));
Assert.assertEquals(3, vc.getCalledChrCount(del)); Assert.assertEquals(3, vc.getCalledChrCount(ATC));
Assert.assertEquals(2, vc.getCalledChrCount(Allele.NO_CALL)); Assert.assertEquals(2, vc.getCalledChrCount(Allele.NO_CALL));
} }
@ -411,7 +411,7 @@ public class VariantContextUnitTest extends BaseTest {
public void testAccessingRefGenotypes() { public void testAccessingRefGenotypes() {
List<Allele> alleles1 = Arrays.asList(Aref, T); List<Allele> alleles1 = Arrays.asList(Aref, T);
List<Allele> alleles2 = Arrays.asList(Aref); List<Allele> alleles2 = Arrays.asList(Aref);
List<Allele> alleles3 = Arrays.asList(Aref, T, del); List<Allele> alleles3 = Arrays.asList(Aref, T);
for ( List<Allele> alleles : Arrays.asList(alleles1, alleles2, alleles3)) { for ( List<Allele> alleles : Arrays.asList(alleles1, alleles2, alleles3)) {
Genotype g1 = GenotypeBuilder.create("AA1", Arrays.asList(Aref, Aref)); Genotype g1 = GenotypeBuilder.create("AA1", Arrays.asList(Aref, Aref));
Genotype g2 = GenotypeBuilder.create("AA2", Arrays.asList(Aref, Aref)); Genotype g2 = GenotypeBuilder.create("AA2", Arrays.asList(Aref, Aref));
@ -433,7 +433,7 @@ public class VariantContextUnitTest extends BaseTest {
@Test @Test
public void testFilters() { public void testFilters() {
List<Allele> alleles = Arrays.asList(Aref, T, del); List<Allele> alleles = Arrays.asList(Aref, T);
Genotype g1 = GenotypeBuilder.create("AA", Arrays.asList(Aref, Aref)); Genotype g1 = GenotypeBuilder.create("AA", Arrays.asList(Aref, Aref));
Genotype g2 = GenotypeBuilder.create("AT", Arrays.asList(Aref, T)); Genotype g2 = GenotypeBuilder.create("AT", Arrays.asList(Aref, T));
@ -492,15 +492,15 @@ public class VariantContextUnitTest extends BaseTest {
Assert.assertEquals(VariantContextUtils.findRepeatedSubstring("AATAATA".getBytes()),7); Assert.assertEquals(VariantContextUtils.findRepeatedSubstring("AATAATA".getBytes()),7);
// -*,ATC, context = ATC ATC ATC : (ATC)3 -> (ATC)4 // A*,ATC, context = ATC ATC ATC : (ATC)3 -> (ATC)4
VariantContext vc = new VariantContextBuilder("foo", insLoc, insLocStart, insLocStop, Arrays.asList(nullR,atc)).make(); VariantContext vc = new VariantContextBuilder("foo", insLoc, insLocStart, insLocStop, Arrays.asList(nullR,atc)).make();
result = VariantContextUtils.getNumTandemRepeatUnits(vc,refBytes); result = VariantContextUtils.getNumTandemRepeatUnits(vc,refBytes);
Assert.assertEquals(result.getFirst().toArray()[0],3); Assert.assertEquals(result.getFirst().toArray()[0],3);
Assert.assertEquals(result.getFirst().toArray()[1],4); Assert.assertEquals(result.getFirst().toArray()[1],4);
Assert.assertEquals(result.getSecond().length,3); Assert.assertEquals(result.getSecond().length,3);
// ATC*,-,ATCATC // ATC*,A,ATCATC
vc = new VariantContextBuilder("foo", insLoc, insLocStart, insLocStop, Arrays.asList(ATCref,nullA,atcatc)).make(); vc = new VariantContextBuilder("foo", insLoc, insLocStart, insLocStart+3, Arrays.asList(Allele.create("AATC", true),nullA,atcatc)).make();
result = VariantContextUtils.getNumTandemRepeatUnits(vc,refBytes); result = VariantContextUtils.getNumTandemRepeatUnits(vc,refBytes);
Assert.assertEquals(result.getFirst().toArray()[0],3); Assert.assertEquals(result.getFirst().toArray()[0],3);
Assert.assertEquals(result.getFirst().toArray()[1],2); Assert.assertEquals(result.getFirst().toArray()[1],2);
@ -517,7 +517,7 @@ public class VariantContextUnitTest extends BaseTest {
// CCCC*,CC,-,CCCCCC, context = CCC: (C)7 -> (C)5,(C)3,(C)9 // CCCC*,CC,-,CCCCCC, context = CCC: (C)7 -> (C)5,(C)3,(C)9
refBytes = "TCCCCCCCAGAGAGAG".getBytes(); refBytes = "TCCCCCCCAGAGAGAG".getBytes();
vc = new VariantContextBuilder("foo", insLoc, insLocStart, insLocStop, Arrays.asList(ccccR,cc, nullA,cccccc)).make(); vc = new VariantContextBuilder("foo", insLoc, insLocStart, insLocStart+4, Arrays.asList(ccccR,cc, nullA,cccccc)).make();
result = VariantContextUtils.getNumTandemRepeatUnits(vc,refBytes); result = VariantContextUtils.getNumTandemRepeatUnits(vc,refBytes);
Assert.assertEquals(result.getFirst().toArray()[0],7); Assert.assertEquals(result.getFirst().toArray()[0],7);
Assert.assertEquals(result.getFirst().toArray()[1],5); Assert.assertEquals(result.getFirst().toArray()[1],5);
@ -527,7 +527,7 @@ public class VariantContextUnitTest extends BaseTest {
// GAGA*,-,GAGAGAGA // GAGA*,-,GAGAGAGA
refBytes = "TGAGAGAGAGATTT".getBytes(); refBytes = "TGAGAGAGAGATTT".getBytes();
vc = new VariantContextBuilder("foo", insLoc, insLocStart, insLocStop, Arrays.asList(gagaR, nullA,gagagaga)).make(); vc = new VariantContextBuilder("foo", insLoc, insLocStart, insLocStart+4, Arrays.asList(gagaR, nullA,gagagaga)).make();
result = VariantContextUtils.getNumTandemRepeatUnits(vc,refBytes); result = VariantContextUtils.getNumTandemRepeatUnits(vc,refBytes);
Assert.assertEquals(result.getFirst().toArray()[0],5); Assert.assertEquals(result.getFirst().toArray()[0],5);
Assert.assertEquals(result.getFirst().toArray()[1],3); Assert.assertEquals(result.getFirst().toArray()[1],3);
@ -559,27 +559,24 @@ public class VariantContextUnitTest extends BaseTest {
@Test @Test
public void testVCFfromGenotypes() { public void testVCFfromGenotypes() {
List<Allele> alleles = Arrays.asList(Aref, T, del); List<Allele> alleles = Arrays.asList(Aref, T);
Genotype g1 = GenotypeBuilder.create("AA", Arrays.asList(Aref, Aref)); Genotype g1 = GenotypeBuilder.create("AA", Arrays.asList(Aref, Aref));
Genotype g2 = GenotypeBuilder.create("AT", Arrays.asList(Aref, T)); Genotype g2 = GenotypeBuilder.create("AT", Arrays.asList(Aref, T));
Genotype g3 = GenotypeBuilder.create("TT", Arrays.asList(T, T)); Genotype g3 = GenotypeBuilder.create("TT", Arrays.asList(T, T));
Genotype g4 = GenotypeBuilder.create("..", Arrays.asList(Allele.NO_CALL, Allele.NO_CALL)); Genotype g4 = GenotypeBuilder.create("..", Arrays.asList(Allele.NO_CALL, Allele.NO_CALL));
Genotype g5 = GenotypeBuilder.create("--", Arrays.asList(del, del)); VariantContext vc = new VariantContextBuilder("genotypes", snpLoc, snpLocStart, snpLocStop, alleles).genotypes(g1,g2,g3,g4).make();
VariantContext vc = new VariantContextBuilder("genotypes", snpLoc, snpLocStart, snpLocStop, alleles).genotypes(g1,g2,g3,g4,g5).make();
VariantContext vc12 = vc.subContextFromSamples(new HashSet<String>(Arrays.asList(g1.getSampleName(), g2.getSampleName())), true); VariantContext vc12 = vc.subContextFromSamples(new HashSet<String>(Arrays.asList(g1.getSampleName(), g2.getSampleName())), true);
VariantContext vc1 = vc.subContextFromSamples(new HashSet<String>(Arrays.asList(g1.getSampleName())), true); VariantContext vc1 = vc.subContextFromSamples(new HashSet<String>(Arrays.asList(g1.getSampleName())), true);
VariantContext vc23 = vc.subContextFromSamples(new HashSet<String>(Arrays.asList(g2.getSampleName(), g3.getSampleName())), true); VariantContext vc23 = vc.subContextFromSamples(new HashSet<String>(Arrays.asList(g2.getSampleName(), g3.getSampleName())), true);
VariantContext vc4 = vc.subContextFromSamples(new HashSet<String>(Arrays.asList(g4.getSampleName())), true); VariantContext vc4 = vc.subContextFromSamples(new HashSet<String>(Arrays.asList(g4.getSampleName())), true);
VariantContext vc14 = vc.subContextFromSamples(new HashSet<String>(Arrays.asList(g1.getSampleName(), g4.getSampleName())), true); VariantContext vc14 = vc.subContextFromSamples(new HashSet<String>(Arrays.asList(g1.getSampleName(), g4.getSampleName())), true);
VariantContext vc5 = vc.subContextFromSamples(new HashSet<String>(Arrays.asList(g5.getSampleName())), true);
Assert.assertTrue(vc12.isPolymorphicInSamples()); Assert.assertTrue(vc12.isPolymorphicInSamples());
Assert.assertTrue(vc23.isPolymorphicInSamples()); Assert.assertTrue(vc23.isPolymorphicInSamples());
Assert.assertTrue(vc1.isMonomorphicInSamples()); Assert.assertTrue(vc1.isMonomorphicInSamples());
Assert.assertTrue(vc4.isMonomorphicInSamples()); Assert.assertTrue(vc4.isMonomorphicInSamples());
Assert.assertTrue(vc14.isMonomorphicInSamples()); Assert.assertTrue(vc14.isMonomorphicInSamples());
Assert.assertTrue(vc5.isPolymorphicInSamples());
Assert.assertTrue(vc12.isSNP()); Assert.assertTrue(vc12.isSNP());
Assert.assertTrue(vc12.isVariant()); Assert.assertTrue(vc12.isVariant());
@ -601,17 +598,11 @@ public class VariantContextUnitTest extends BaseTest {
Assert.assertFalse(vc14.isVariant()); Assert.assertFalse(vc14.isVariant());
Assert.assertFalse(vc14.isBiallelic()); Assert.assertFalse(vc14.isBiallelic());
Assert.assertTrue(vc5.isIndel());
Assert.assertTrue(vc5.isSimpleDeletion());
Assert.assertTrue(vc5.isVariant());
Assert.assertTrue(vc5.isBiallelic());
Assert.assertEquals(3, vc12.getCalledChrCount(Aref)); Assert.assertEquals(3, vc12.getCalledChrCount(Aref));
Assert.assertEquals(1, vc23.getCalledChrCount(Aref)); Assert.assertEquals(1, vc23.getCalledChrCount(Aref));
Assert.assertEquals(2, vc1.getCalledChrCount(Aref)); Assert.assertEquals(2, vc1.getCalledChrCount(Aref));
Assert.assertEquals(0, vc4.getCalledChrCount(Aref)); Assert.assertEquals(0, vc4.getCalledChrCount(Aref));
Assert.assertEquals(2, vc14.getCalledChrCount(Aref)); Assert.assertEquals(2, vc14.getCalledChrCount(Aref));
Assert.assertEquals(0, vc5.getCalledChrCount(Aref));
} }
public void testGetGenotypeMethods() { public void testGetGenotypeMethods() {
@ -659,13 +650,12 @@ public class VariantContextUnitTest extends BaseTest {
@DataProvider(name = "getAlleles") @DataProvider(name = "getAlleles")
public Object[][] mergeAllelesData() { public Object[][] mergeAllelesData() {
new GetAllelesTest("A*", Aref); new GetAllelesTest("A*", Aref);
new GetAllelesTest("-*", delRef);
new GetAllelesTest("A*/C", Aref, C); new GetAllelesTest("A*/C", Aref, C);
new GetAllelesTest("A*/C/T", Aref, C, T); new GetAllelesTest("A*/C/T", Aref, C, T);
new GetAllelesTest("A*/T/C", Aref, T, C); new GetAllelesTest("A*/T/C", Aref, T, C);
new GetAllelesTest("A*/C/T/-", Aref, C, T, del); new GetAllelesTest("A*/C/T/ATC", Aref, C, T, ATC);
new GetAllelesTest("A*/T/C/-", Aref, T, C, del); new GetAllelesTest("A*/T/C/ATC", Aref, T, C, ATC);
new GetAllelesTest("A*/-/T/C", Aref, del, T, C); new GetAllelesTest("A*/ATC/T/C", Aref, ATC, T, C);
return GetAllelesTest.getTests(GetAllelesTest.class); return GetAllelesTest.getTests(GetAllelesTest.class);
} }