private static void TestExpectations(bool isHGsort, bool isGRCHsort, ChrCompare chrCompare)
{
// These should work with any std sort order
TestWithSameChrExpectations(chrCompare);
TestWithHG19Expectations(chrCompare);
TestWithGRCH37Expectations(chrCompare);
//depends on where chrM is expected
TestWithChrMExpectations(chrCompare, isHGsort);
TestWithMExpectations(chrCompare, isGRCHsort);
//These only work if a "chr[.]" HG19 type aware sort order is applied.
OnlyPassWithHG19Ordering(chrCompare, isHGsort);
OnlyPassWithGRCHOrdering(chrCompare, isGRCHsort);
// decoy chrs
Assert.Equal(-1, chrCompare.Compare("cat", "dog"));
Assert.Equal(-1, chrCompare.Compare("GL000194.1", "KI270755.1"));
Assert.Equal(1, chrCompare.Compare("KI270755.1", "GL000194.1"));
// One numeric, one chr[x]
Assert.Equal(-1, chrCompare.Compare("8", "chr9"));
Assert.Equal(-1, chrCompare.Compare("chr8", "M"));
Assert.Equal(-1, chrCompare.Compare("2", "chrY"));
Assert.Equal(-1, chrCompare.Compare("chrM", "X"));
Assert.Equal(-1, chrCompare.Compare("chrX", "Y"));
Assert.Equal(1, chrCompare.Compare("X", "chrY"));
}
public void OrderChrs_HG19Header()
{
var orderedList = ChrCompare.GetChrListFromVcfHeader(_exampleHeaderLinesHG19WithDecoy);
var chrCompare = new ChrCompare(orderedList);
bool isHGsort = true;
bool isGRCHsort = false;
TestExpectations(isHGsort, isGRCHsort, chrCompare);
}
public void OrderChrs_GRCH37Header()
{
bool isHG19sort = false;
bool isGRCHsort = true;
var orderedList = ChrCompare.GetChrListFromVcfHeader(_exampleHeaderLinesWithGRCh37);
var chrCompare = new ChrCompare(orderedList);
TestExpectations(isHG19sort, isGRCHsort, chrCompare);
}
private static void TestWithSameChrExpectations(ChrCompare chrCompare)
{
Assert.Equal(0, chrCompare.Compare("chr9", "chr9"));
Assert.Equal(0, chrCompare.Compare("chrM", "chrM"));
Assert.Equal(0, chrCompare.Compare("chrX", "chrX"));
Assert.Equal(0, chrCompare.Compare("foo", "foo"));
Assert.Equal(0, chrCompare.Compare("1", "1"));
Assert.Equal(0, chrCompare.Compare("-1", "-1"));
Assert.Equal(0, chrCompare.Compare("KQ031386.1", "KQ031386.1"));
}
private static void OnlyPassWithHG19Ordering(ChrCompare chrCompare, bool isHG19Sort)
{
var expectation = (isHG19Sort) ? -1 : 1;
Assert.Equal(expectation, chrCompare.Compare("chr2", "chr12"));
Assert.Equal(expectation, chrCompare.Compare("chr4", "chr22"));
Assert.Equal(expectation, chrCompare.Compare("chr2", "chr10"));
Assert.Equal(expectation, chrCompare.Compare("chr2", "chr19"));
Assert.Equal(-1 * expectation, chrCompare.Compare("chr12", "chr2"));
Assert.Equal(-1 * expectation, chrCompare.Compare("chr22", "chr4"));
Assert.Equal(-1 * expectation, chrCompare.Compare("chr10", "chr2"));
Assert.Equal(-1 * expectation, chrCompare.Compare("chr19", "chr2"));
}
private static void TestWithHG19Expectations(ChrCompare chrCompare)
{
Assert.Equal(-1, chrCompare.Compare("chr8", "chr9"));
Assert.Equal(-1, chrCompare.Compare("chr2", "chrY"));
Assert.Equal(-1, chrCompare.Compare("chrX", "chrY"));
Assert.Equal(-1, chrCompare.Compare("chr20", "chr22"));
Assert.Equal(-1, chrCompare.Compare("chr2", "chr22"));
// diff chr, std chr[i] format
Assert.Equal(1, chrCompare.Compare("chr9", "chr8"));
Assert.Equal(1, chrCompare.Compare("chrY", "chr2"));
Assert.Equal(1, chrCompare.Compare("chrY", "chrX"));
Assert.Equal(1, chrCompare.Compare("chr22", "chr20"));
Assert.Equal(1, chrCompare.Compare("chr22", "chr2"));
}
private static void TestWithGRCH37Expectations(ChrCompare chrCompare)
{
// diff chr, std [i] format
Assert.Equal(-1, chrCompare.Compare("8", "9"));
Assert.Equal(-1, chrCompare.Compare("2", "Y"));
Assert.Equal(-1, chrCompare.Compare("X", "Y"));
Assert.Equal(-1, chrCompare.Compare("20", "22"));
Assert.Equal(-1, chrCompare.Compare("2", "22"));
// diff chr, std [i] format
Assert.Equal(1, chrCompare.Compare("9", "8"));
Assert.Equal(1, chrCompare.Compare("Y", "2"));
Assert.Equal(1, chrCompare.Compare("Y", "X"));
Assert.Equal(1, chrCompare.Compare("22", "20"));
Assert.Equal(1, chrCompare.Compare("22", "2"));
}
private static void OnlyPassWithGRCHOrdering(ChrCompare chrCompare, bool isGRCHsort)
{
var expectation = (isGRCHsort) ? -1 : 1;
//note these will be counter-intuitive UNLESS an order is supplied
Assert.Equal(-1 * expectation, chrCompare.Compare("12", "2"));
Assert.Equal(-1 * expectation, chrCompare.Compare("22", "4"));
Assert.Equal(-1 * expectation, chrCompare.Compare("10", "2"));
Assert.Equal(-1 * expectation, chrCompare.Compare("19", "2"));
//note these will be counter-intuitive UNLESS an order is supplied
Assert.Equal(expectation, chrCompare.Compare("2", "12"));
Assert.Equal(expectation, chrCompare.Compare("4", "22"));
Assert.Equal(expectation, chrCompare.Compare("2", "10"));
Assert.Equal(expectation, chrCompare.Compare("2", "19"));
}
private static void TestWithChrMExpectations(ChrCompare chrCompare, bool chrMAfterChrXY)
{
var expectChrMAfterChrXY = (chrMAfterChrXY) ? 1 : -1;
//M should always be after the numbered chrs
Assert.Equal(-1, chrCompare.Compare("chr8", "chrM"));
Assert.Equal(-1, chrCompare.Compare("chr20", "chrM"));
Assert.Equal(-1, chrCompare.Compare("chr2", "chrM"));
Assert.Equal(1, chrCompare.Compare("chrM", "chr8"));
//where is M w.r.t X and Y ?
Assert.Equal(expectChrMAfterChrXY, chrCompare.Compare("chrM", "chrX"));
Assert.Equal(expectChrMAfterChrXY, chrCompare.Compare("chrM", "chrY"));
Assert.Equal(-1 * expectChrMAfterChrXY, chrCompare.Compare("chrX", "chrM"));
Assert.Equal(-1 * expectChrMAfterChrXY, chrCompare.Compare("chrY", "chrM"));
}
public void ParseContigs()
{
var orderedList = ChrCompare.GetChrListFromVcfHeader(_exampleHeaderLinesHG19WithDecoy);
Assert.Equal(18, orderedList.Count);
Assert.Equal("chr1", orderedList[0]);
Assert.Equal("chr2", orderedList[1]);
Assert.Equal("chr3", orderedList[2]);
Assert.Equal("chrX", orderedList[9]);
Assert.Equal("chrY", orderedList[10]);
Assert.Equal("chrM", orderedList[11]);
Assert.Equal("KI270756.1", orderedList[16]);
Assert.Equal("KI270757.1", orderedList[17]);
orderedList = ChrCompare.GetChrListFromVcfHeader(_exampleHeaderLinesWithGRCh37);
Assert.Equal(18, orderedList.Count);
Assert.Equal("1", orderedList[0]);
Assert.Equal("2", orderedList[1]);
Assert.Equal("4", orderedList[2]);
Assert.Equal("20", orderedList[12]);
Assert.Equal("21", orderedList[13]);
Assert.Equal("X", orderedList[15]);
Assert.Equal("M", orderedList[17]);
orderedList = ChrCompare.GetChrListFromVcfHeader(_exampleHeaderLinesPathological);
Assert.Equal(5, orderedList.Count);
Assert.Equal("frog", orderedList[0]);
Assert.Equal("9", orderedList[1]);
Assert.Equal("7", orderedList[2]);
Assert.Equal("2", orderedList[3]);
Assert.Equal("-2", orderedList[4]);
}
public void OrderChrs_PathologicalContigList()
{
var orderedList = ChrCompare.GetChrListFromVcfHeader(_exampleHeaderLinesPathological);
var chrCompare = new ChrCompare(orderedList);
//by default, it falls back to string sort.
bool isHGsort = false;
bool isGRCHsort = false;
TestExpectations(isHGsort, isGRCHsort, chrCompare);
//plus test how it handles these extras:
//we said "frog" had to come befor "9" , "9" before "7", and "2" before "-2"
Assert.Equal(-1, chrCompare.Compare("frog", "9"));
Assert.Equal(-1, chrCompare.Compare("9", "7"));
Assert.Equal(-1, chrCompare.Compare("2", "-2"));
Assert.Equal(1, chrCompare.Compare("9", "frog"));
Assert.Equal(1, chrCompare.Compare("7", "9"));
Assert.Equal(1, chrCompare.Compare("-2", "2"));
//how does it handle stuff it never heard of before? fall back to string compare
Assert.Equal(-1, chrCompare.Compare("3", "4"));
Assert.Equal(1, chrCompare.Compare("frog", "app.le"));
}
/// <summary>
/// perfom a Venn split between two samples
/// </summary>
/// <param name="sampleName"></param>
/// <param name="consensusFilePath"></param>
/// <param name="inputPaths"></param>
/// <param name="outputTwoSampleResults"></param>
public void DoPairwiseVenn()
{
bool doConsensus = (consensusBuilder != null);
bool requireGenotypes = false;
var backLogPoolAAlleles = new List <CalledAllele>()
{
};
var backLogPoolBAlleles = new List <CalledAllele>()
{
};
using (AlleleReader ReaderA = new AlleleReader(_inputPaths[0], requireGenotypes))
using (AlleleReader ReaderB = new AlleleReader(_inputPaths[1], requireGenotypes))
{
var vcfA_HeaderLines = ReaderA.HeaderLines;
var chrOrderingFromInput = ChrCompare.GetChrListFromVcfHeader(vcfA_HeaderLines);
var alleleCompareByLoci = new AlleleCompareByLoci(chrOrderingFromInput);
if (doConsensus)
{
consensusBuilder.OpenConsensusFile(vcfA_HeaderLines);
}
OpenVennDiagramStreams(ReaderA.HeaderLines);
//read the first variant from each gvcf file...
var currentAllele = new CalledAllele();
var backLogExistPoolA = ReaderA.GetNextVariants(out backLogPoolAAlleles);
var backLogExistPoolB = ReaderB.GetNextVariants(out backLogPoolBAlleles);
//keep reading and processing until we are done with both gvcfs
while (true)
{
try
{
//1) Get the next set of variants. Pull from the backlog first,
//choosing all the variants at the first available position.
var coLocatedPoolAAlleles = new List <CalledAllele>();
var coLocatedPoolBAlleles = new List <CalledAllele>();
//We need to set up which location to look at next.
//Choose the first one from the backlog.
if (backLogExistPoolA || backLogExistPoolB)
{
if (backLogExistPoolA && backLogExistPoolB)
{
int OrderResult = alleleCompareByLoci.OrderAlleles(
backLogPoolAAlleles.First(), backLogPoolBAlleles.First());
if (OrderResult < 0)
{
currentAllele.Chromosome = backLogPoolAAlleles.First().Chromosome;
currentAllele.ReferencePosition = backLogPoolAAlleles.First().ReferencePosition;
}
else
{
currentAllele.Chromosome = backLogPoolBAlleles.First().Chromosome;
currentAllele.ReferencePosition = backLogPoolBAlleles.First().ReferencePosition;
}
}
else if (backLogExistPoolB)
{
currentAllele.Chromosome = backLogPoolBAlleles.First().Chromosome;
currentAllele.ReferencePosition = backLogPoolBAlleles.First().ReferencePosition;
}
else //if (backLogExistPoolA)
{
currentAllele.Chromosome = backLogPoolAAlleles.First().Chromosome;
currentAllele.ReferencePosition = backLogPoolAAlleles.First().ReferencePosition;
}
//assemble lists of co-located variants at the position of the current variant
coLocatedPoolAAlleles = AssembleColocatedList(ReaderA, currentAllele, alleleCompareByLoci,
ref backLogExistPoolA, ref backLogPoolAAlleles);
coLocatedPoolBAlleles = AssembleColocatedList(ReaderB, currentAllele, alleleCompareByLoci,
ref backLogExistPoolB, ref backLogPoolBAlleles);
} //else, if there is nothing in either backlog, the colocated-variant list should stay empty.
//2) Now we have finshed reading out all the co-located variants...
//We need organize them into pairs, to know which allele to compare with which.
var Pairs = SelectPairs(coLocatedPoolAAlleles, coLocatedPoolBAlleles);
var ConsensusVariants = new List <CalledAllele>();
AggregateAllele lastConsensusReferenceCall = null;
//3) For each pair, combine them and mark if biased or not.
for (int PairIndex = 0; PairIndex < Pairs.Count; PairIndex++)
{
var VariantA = Pairs[PairIndex][0];
var VariantB = Pairs[PairIndex][1];
var ComparisonCase = GetComparisonCase(VariantA, VariantB);
//add VarA and VarB to appropriate venn diagram files.
WriteVarsToVennFiles(ComparisonCase, VariantA, VariantB);
AggregateAllele Consensus = null;
if (doConsensus)
{
Consensus = consensusBuilder.CombineVariants(
VariantA, VariantB, ComparisonCase);
//Its possible for multiallelic sites, a pair of variants could
//end up as a concensus reference. And we already may have
//called a reference for this loci already.
//we might have some cleaning up to do...
if (Consensus.Genotype == Pisces.Domain.Types.Genotype.HomozygousRef)
{
//this is the first time we see a reference at this loci
if (lastConsensusReferenceCall == null)
{
lastConsensusReferenceCall = Consensus;
//its OK to fall through and add our Consensus variant to the list.
}
//Else, if we have already called a reference variant
// for this loci already
// we want to merge the results from this reference with the old one.
// *before* we write it to file.
else
{
//the chr, pos, ref, alt,and depth should be correct.
//We'll merge the filters,
//and take the max SB and PB. (where a higher value indicates worse value, so we stay conservative)
lastConsensusReferenceCall.Filters = ConsensusBuilder.CombineFilters(lastConsensusReferenceCall, Consensus);
lastConsensusReferenceCall.StrandBiasResults = new Pisces.Domain.Models.BiasResults()
{
GATKBiasScore = Math.Max(lastConsensusReferenceCall.StrandBiasResults.GATKBiasScore, Consensus.StrandBiasResults.GATKBiasScore)
};
lastConsensusReferenceCall.PoolBiasResults = new Pisces.Domain.Models.BiasResults()
{
GATKBiasScore = Math.Max(lastConsensusReferenceCall.PoolBiasResults.GATKBiasScore, Consensus.PoolBiasResults.GATKBiasScore)
};
//we are going to take the min Q and NL score, to be conservative
lastConsensusReferenceCall.NoiseLevelApplied = Math.Min(lastConsensusReferenceCall.NoiseLevelApplied, Consensus.NoiseLevelApplied);
lastConsensusReferenceCall.GenotypeQscore = Math.Min(lastConsensusReferenceCall.GenotypeQscore, Consensus.GenotypeQscore);
lastConsensusReferenceCall.VariantQscore = Math.Min(lastConsensusReferenceCall.VariantQscore, Consensus.GenotypeQscore);
continue;
}
}
ConsensusVariants.Add(Consensus);
}
}
//4) Write out the results to file. (this will be a list of co-located variants)
if (doConsensus)
{
consensusBuilder.WriteConsensusVariantsToFile(ConsensusVariants);
}
//we assembled everyone and no one is left.
if ((backLogPoolAAlleles == null) &&
(backLogPoolBAlleles == null))
{
break;
}
}
catch (Exception ex)
{
OnError(string.Format("Fatal error encountered comparing paired sample vcfs; Check {0}, position {1}. Exception: {2}",
currentAllele.Chromosome, currentAllele.ReferencePosition, ex));
throw;
}
} //close assemble list
}//close usings
if (doConsensus)
{
consensusBuilder.CloseConsensusFile();
}
CloseVennDiagramStreams();
}
