public void InsertSameTreeIntoTree()
{
var tree = MergedIntervalTree.Create(ExistingIntervals);
foreach (var target in ExistingIntervals)
{
tree.Add(target);
}
// non-overlapping should have one more interval
MultiAssert.True(ExistingIntervals.SequenceEqual(tree));
// subtract back the stuff we added to get leftovers.
var fpTree = MergedIntervalTree.Create <uint>();
foreach (var interval in tree)
{
var overlaps = ExistingTree.Search(interval).ToList();
if (overlaps.Count == 0)
{
fpTree.Add(interval);
}
else
{
fpTree.AddRange(interval.Subtract(overlaps));
}
}
// since we added the same, leftovers should be none.
MultiAssert.False(fpTree.Any());
MultiAssert.AssertAll();
}
private static GenomeIntervalTree <IContigAndInterval> CreateGenomeIntervalTree(
[NotNull] IEnumerable <IContigAndInterval> contigIntervals)
{
var dictionary = new Dictionary <IContigInfo, MergedIntervalTree <uint> >();
var listOrder = new List <IContigInfo>();
foreach (var contigInterval in contigIntervals)
{
if (!dictionary.TryGetValue(contigInterval.Contig, out var tree))
{
tree = MergedIntervalTree <uint> .Create(null);
listOrder.Add(contigInterval.Contig);
dictionary.Add(contigInterval.Contig, tree);
}
tree.Add(contigInterval);
}
var ret = GenomeIntervalTree <IContigAndInterval> .Create();
foreach (var contig in listOrder)
{
ret.AddRange(dictionary[contig]
.Select(i => i as IContigAndInterval ?? ContigAndInterval.Create(contig, i.Start, i.Stop)));
}
return(ret);
}
public void InsertTotallyOverlappingBecomesOneInterval()
{
var tree = MergedIntervalTree.Create(ExistingIntervals);
var target =
new ClosedOpenInterval <uint>(ExistingIntervals[0].Stop - 1, ExistingIntervals.Last().Start + 1);
tree.Add(target);
MultiAssert.Equal(1, tree.Count());
MultiAssert.Equal(ExistingIntervals.First().Start, tree.First().Start);
MultiAssert.Equal(ExistingIntervals.Last().Stop, tree.Last().Stop);
// subtract back the stuff we added to get leftovers.
var fpTree = MergedIntervalTree.Create <uint>();
foreach (var interval in tree)
{
var overlaps = ExistingTree.Search(interval).ToList();
if (overlaps.Count == 0)
{
fpTree.Add(interval);
}
else
{
fpTree.AddRange(interval.Subtract(overlaps));
}
}
// should be one less since it's the # of gaps
MultiAssert.Equal(ExistingIntervals.Count - 1, fpTree.Count());
MultiAssert.AssertAll();
}
public void InsertNonOverlappingAtEnd()
{
var tree = MergedIntervalTree.Create(ExistingIntervals);
var target = new ClosedOpenInterval <uint>(ExistingIntervals.Last().Stop, uint.MaxValue);
tree.Add(target);
MultiAssert.Equal(ExistingIntervals.Count + 1, tree.Count());
MultiAssert.Equal(target, tree.Last());
// subtract back the stuff we added to get leftovers.
var fpTree = MergedIntervalTree.Create <uint>();
foreach (var interval in tree)
{
var overlaps = ExistingTree.Search(interval).ToList();
if (overlaps.Count == 0)
{
fpTree.Add(interval);
}
else
{
fpTree.AddRange(interval.Subtract(overlaps));
}
}
MultiAssert.Equal(1, fpTree.Count());
MultiAssert.Equal(target.GetLength(), fpTree.FirstOrDefault()?.GetLength());
MultiAssert.AssertAll();
}
public void InsertNonOverlappingAtEnd()
{
var tree = MergedIntervalTree.Create(ExistingIntervals);
var target = new InclusiveInterval <uint>(ExistingIntervals.Last().Stop + 1, uint.MaxValue);
tree.Add(target);
MultiAssert.Equal(ExistingIntervals.Count + 1, tree.Count());
MultiAssert.Equal(target, tree.Last());
MultiAssert.AssertAll();
}
public void InsertNonOverlappingAtMiddle()
{
var tree = MergedIntervalTree.Create(ExistingIntervals);
var target = new InclusiveInterval <uint>(ExistingIntervals[0].Stop + 1, ExistingIntervals[1].Start - 1);
tree.Add(target);
// non-overlapping should have one more interval
Assert.Equal(ExistingIntervals.Count + 1, tree.Count());
}
public void InsertTotallyOverlappingBecomesOneInterval()
{
var tree = MergedIntervalTree.Create(ExistingIntervals);
var target = new InclusiveInterval <uint>(ExistingIntervals[0].Stop, ExistingIntervals.Last().Start);
tree.Add(target);
MultiAssert.Equal(1, tree.Count());
MultiAssert.Equal(ExistingIntervals.First().Start, tree.First().Start);
MultiAssert.Equal(ExistingIntervals.Last().Stop, tree.Last().Stop);
MultiAssert.AssertAll();
}
public void InsertSameTreeIntoTree()
{
var tree = MergedIntervalTree.Create(ExistingIntervals);
foreach (var target in ExistingIntervals)
{
tree.Add(target);
}
// non-overlapping should have one more interval
Assert.True(ExistingIntervals.SequenceEqual(tree));
}
public void InsertNonOverlappingAtBeginning()
{
var tree = MergedIntervalTree.Create(ExistingIntervals);
var target = new InclusiveInterval <uint>(uint.MinValue, ExistingIntervals[0].Start - 1);
tree.Add(target);
// non-overlapping should have one more interval
MultiAssert.Equal(ExistingIntervals.Count + 1, tree.Count());
MultiAssert.Equal(tree.First().Start, target.Start);
MultiAssert.Equal(tree.First().Stop, target.Stop);
MultiAssert.AssertAll();
}
public void InsertIntervalBarelyOverlappingFirstTwoInterval()
{
var tree = MergedIntervalTree.Create(ExistingIntervals);
var target = new InclusiveInterval <uint>(ExistingIntervals[0].Stop, ExistingIntervals[1].Start);
tree.Add(target);
// insert one, but remove 2 would be net of - 1
MultiAssert.Equal(ExistingIntervals.Count - 1, tree.Count());
MultiAssert.Equal(ExistingIntervals.First().Start, tree.First().Start);
// overlapping the two first ones means the second's stop is the stop of first in tree
MultiAssert.Equal(ExistingIntervals.Skip(1).First().Stop, tree.First().Stop);
MultiAssert.AssertAll();
}
public void InsertSameTreeSlightlyExpandedIntervalsIntoTree()
{
var tree = MergedIntervalTree.Create(ExistingIntervals);
var newIntervals = new List <IInterval <uint> >();
foreach (var target in ExistingIntervals)
{
var interval = ClosedOpenInterval <uint> .Create(target.Start - 1, target.IsStartInclusive, target.Stop + 1, target.IsStopInclusive);
tree.Add(interval);
newIntervals.Add(interval);
}
// non-overlapping should have one more interval
Assert.True(newIntervals.SequenceEqual(tree));
}
public void InsertSameTreeSlightlyExpandedIntervalsIntoTree()
{
var tree = MergedIntervalTree.Create(ExistingIntervals);
var newIntervals = new List <IInterval <uint> >();
foreach (var target in ExistingIntervals)
{
var interval = ClosedOpenInterval <uint> .Create(target.Start - 1, target.IsStartInclusive,
target.Stop + 1, target.IsStopInclusive);
tree.Add(interval);
newIntervals.Add(interval);
}
// non-overlapping should have one more interval
MultiAssert.True(newIntervals.SequenceEqual(tree));
// subtract back the stuff we added to get leftovers.
var fpTree = MergedIntervalTree.Create <uint>();
foreach (var interval in tree)
{
var overlaps = ExistingTree.Search(interval).ToList();
if (overlaps.Count == 0)
{
fpTree.Add(interval);
}
else
{
fpTree.AddRange(interval.Subtract(overlaps));
}
}
// double since we basically add a 1-length interval on each side.
MultiAssert.Equal(ExistingIntervals.Count * 2, fpTree.Count());
MultiAssert.AssertAll();
}
public void InsertIntervalBarelyOverlappingFirstTwoInterval()
{
var tree = MergedIntervalTree.Create(ExistingIntervals);
var target =
new ClosedOpenInterval <uint>(ExistingIntervals[0].Stop - 1, ExistingIntervals[1].Start + 1);
tree.Add(target);
// insert one, but remove 2 would be net of - 1
MultiAssert.Equal(ExistingIntervals.Count - 1, tree.Count());
MultiAssert.Equal(ExistingIntervals.First().Start, tree.First().Start);
// overlapping the two first ones means the second's stop is the stop of first in tree
MultiAssert.Equal(ExistingIntervals.Skip(1).First().Stop, tree.First().Stop);
// subtract back the stuff we added to get leftovers.
var fpTree = MergedIntervalTree.Create <uint>();
foreach (var interval in tree)
{
var overlaps = ExistingTree.Search(interval).ToList();
if (overlaps.Count == 0)
{
fpTree.Add(interval);
}
else
{
fpTree.AddRange(interval.Subtract(overlaps));
}
}
// since only 2 overlapped, those 2 get removed, while 1 gets added.
MultiAssert.Equal(1, fpTree.Count());
// gets trimmed by 2 since we overlap 2 intervals
MultiAssert.Equal(target.GetLength() - 2, fpTree.FirstOrDefault()?.GetLength());
MultiAssert.AssertAll();
}
public void AddFalseCount(IContigInfo contig, IInterval <uint> interval) => _falseCount.GetOrAdd(contig, _ => MergedIntervalTree.Create <uint>()).Add(interval);
public void CnvWorksWithSimpleCounting()
{
if (MiscUtils.IsRunningAnyLinux)
{
return; // currently failing on linux :(
}
var outputDirectory = Path.GetRandomFileName().ToDirectoryInfo();
var wittyerSettings = WittyerSettings.Create(outputDirectory, CnvTruth, CnvQuery,
ImmutableList <ISamplePair> .Empty, EvaluationMode.SimpleCounting, InputSpecs);
var actualStats = MainLauncher
.GenerateJson(wittyerSettings, MainLauncher.GenerateResults(wittyerSettings).EnumerateSuccesses(),
EmptyCmd).GetOrThrow().PerSampleStats.First();
//var str = JsonConvert.SerializeObject(actualStats, Formatting.Indented);
var jsonText = File.ReadAllText(CnvJsonSc.FullName);
var expectedStats = JsonConvert.DeserializeObject <GeneralStats>(jsonText)
.PerSampleStats.First();
var expectedOverall = expectedStats.OverallStats;
var actualOverall = actualStats.OverallStats;
var expectedOverallEventStats = expectedOverall.Single(x => x.StatsType.Equals(StatsType.Event));
var actualOverallEventStats = actualOverall.Single(x => x.StatsType.Equals(StatsType.Event));
MultiAssert.Equal(expectedOverallEventStats.QueryFpCount, actualOverallEventStats.QueryFpCount);
MultiAssert.Equal(expectedOverallEventStats.QueryTpCount, actualOverallEventStats.QueryTpCount);
MultiAssert.Equal(expectedOverallEventStats.QueryTotalCount, actualOverallEventStats.QueryTotalCount);
MultiAssert.Equal(expectedOverallEventStats.TruthTpCount, actualOverallEventStats.TruthTpCount);
MultiAssert.Equal(expectedOverallEventStats.TruthFnCount, actualOverallEventStats.TruthFnCount);
MultiAssert.Equal(expectedOverallEventStats.TruthTotalCount, actualOverallEventStats.TruthTotalCount);
var expectedCnvTypeOverallStats = expectedStats.DetailedStats
.Single(x => x.VariantType == WittyerType.CopyNumberGain.Name).OverallStats.Concat(expectedStats
.DetailedStats.Single(x => x.VariantType == WittyerType.CopyNumberLoss.Name).OverallStats)
.ToReadOnlyList();
var actualCnvTypeOverallStats = actualStats.DetailedStats
.Single(x => x.VariantType == WittyerType.CopyNumberGain.Name).OverallStats.Concat(actualStats
.DetailedStats.Single(x => x.VariantType == WittyerType.CopyNumberLoss.Name).OverallStats)
.ToReadOnlyList();
var expectedOverallCnvEventStats = expectedCnvTypeOverallStats
.Where(x => x.StatsType.Equals(StatsType.Event))
.Aggregate(BasicJsonStats.Create(StatsType.Event, 0, 0, 0, 0), (acc, target) => acc + target);
var actualOverallCnvEventStats = actualCnvTypeOverallStats.Where(x => x.StatsType.Equals(StatsType.Event))
.Aggregate(BasicJsonStats.Create(StatsType.Event, 0, 0, 0, 0), (acc, target) => acc + target);
MultiAssert.Equal(expectedOverallCnvEventStats.QueryFpCount, actualOverallCnvEventStats.QueryFpCount);
MultiAssert.Equal(expectedOverallCnvEventStats.QueryTpCount, actualOverallCnvEventStats.QueryTpCount);
MultiAssert.Equal(expectedOverallCnvEventStats.QueryTotalCount, actualOverallCnvEventStats.QueryTotalCount);
MultiAssert.Equal(expectedOverallCnvEventStats.TruthTpCount, actualOverallCnvEventStats.TruthTpCount);
MultiAssert.Equal(expectedOverallCnvEventStats.TruthFnCount, actualOverallCnvEventStats.TruthFnCount);
MultiAssert.Equal(expectedOverallCnvEventStats.TruthTotalCount, actualOverallCnvEventStats.TruthTotalCount);
var expectedOverallCnvBaseStats = expectedCnvTypeOverallStats.Where(x => x.StatsType.Equals(StatsType.Base))
.Aggregate(BasicJsonStats.Create(StatsType.Base, 0, 0, 0, 0), (acc, target) => acc + target);
var actualOverallCnvBaseStats = actualCnvTypeOverallStats.Where(x => x.StatsType.Equals(StatsType.Base))
.Aggregate(BasicJsonStats.Create(StatsType.Base, 0, 0, 0, 0), (acc, target) => acc + target);
MultiAssert.Equal(expectedOverallCnvBaseStats.QueryFpCount, actualOverallCnvBaseStats.QueryFpCount);
MultiAssert.Equal(expectedOverallCnvBaseStats.QueryTpCount, actualOverallCnvBaseStats.QueryTpCount);
MultiAssert.Equal(expectedOverallCnvBaseStats.QueryTotalCount, actualOverallCnvBaseStats.QueryTotalCount);
MultiAssert.Equal(expectedOverallCnvBaseStats.TruthTpCount, actualOverallCnvBaseStats.TruthTpCount);
MultiAssert.Equal(expectedOverallCnvBaseStats.TruthFnCount, actualOverallCnvBaseStats.TruthFnCount);
MultiAssert.Equal(expectedOverallCnvBaseStats.TruthTotalCount, actualOverallCnvBaseStats.TruthTotalCount);
#region test CNVs w/o Refs
// ReSharper disable ConditionIsAlwaysTrueOrFalse
var refs = false;
var(expectedOrthogonalTruthBaseTotal, expectedOrthogonalTruthEventTotal) = GetTotalCnvs(CnvTruth, refs);
var(expectedOrthogonalQueryBaseTotal, expectedOrthogonalQueryEventTotal) = GetTotalCnvs(CnvQuery, refs);
var actualCnvBaseStatsBinned = GetCnvStats(actualStats, refs);
var expectedCnvBaseStatsBinned = GetCnvStats(expectedStats, refs);
var(actualTruthBaseTotal, actualQueryBaseTotal, actualTruthEventTotal, actualQueryEventTotal) =
GetActualTotalStatsFromBins(expectedCnvBaseStatsBinned, actualCnvBaseStatsBinned, refs);
// expected truth is off by 6, five of which is because of overlap. Last off by 1 is unexplained. Not sure why, but there could be a hidden bug somewhere.
MultiAssert.Equal(expectedOrthogonalTruthBaseTotal, actualTruthBaseTotal - 6);
MultiAssert.Equal(expectedOrthogonalQueryBaseTotal, actualQueryBaseTotal);
MultiAssert.Equal(expectedOrthogonalTruthEventTotal, actualTruthEventTotal);
MultiAssert.Equal(expectedOrthogonalQueryEventTotal, actualQueryEventTotal);
MultiAssert.Equal(expectedOverallCnvBaseStats.TruthTotalCount, actualTruthBaseTotal - 5);
MultiAssert.Equal(expectedOverallCnvBaseStats.QueryTotalCount, actualQueryBaseTotal);
MultiAssert.Equal(expectedOrthogonalTruthBaseTotal, actualOverallCnvBaseStats.TruthTotalCount - 1);
MultiAssert.Equal(expectedOrthogonalQueryBaseTotal, actualOverallCnvBaseStats.QueryTotalCount);
#endregion
#region test CNVs w/ Refs
refs = true;
(expectedOrthogonalTruthBaseTotal, expectedOrthogonalTruthEventTotal) = GetTotalCnvs(CnvTruth, refs);
(expectedOrthogonalQueryBaseTotal, expectedOrthogonalQueryEventTotal) = GetTotalCnvs(CnvQuery, refs);
actualCnvBaseStatsBinned = GetCnvStats(actualStats, refs);
expectedCnvBaseStatsBinned = GetCnvStats(expectedStats, refs);
(actualTruthBaseTotal, actualQueryBaseTotal, actualTruthEventTotal, actualQueryEventTotal) =
GetActualTotalStatsFromBins(expectedCnvBaseStatsBinned, actualCnvBaseStatsBinned, refs);
// ReSharper restore ConditionIsAlwaysTrueOrFalse
// expected truth is off by 6, five of which is because of overlap. Last off by 1 is unexplained. Not sure why, but there could be a hidden bug somewhere.
MultiAssert.Equal(expectedOrthogonalTruthBaseTotal, actualTruthBaseTotal - 6);
MultiAssert.Equal(expectedOrthogonalQueryBaseTotal, actualQueryBaseTotal);
MultiAssert.Equal(expectedOverall.Single(j => j.StatsType == StatsType.Base).TruthTotalCount,
actualTruthBaseTotal - 6);
MultiAssert.Equal(expectedOverall.Single(j => j.StatsType == StatsType.Base).QueryTotalCount,
actualQueryBaseTotal);
MultiAssert.Equal(expectedOrthogonalTruthEventTotal, actualTruthEventTotal);
MultiAssert.Equal(expectedOrthogonalQueryEventTotal, actualQueryEventTotal);
MultiAssert.Equal(expectedOrthogonalTruthBaseTotal,
actualOverall.Single(s => s.StatsType == StatsType.Base).TruthTotalCount);
MultiAssert.Equal(expectedOrthogonalQueryBaseTotal,
actualOverall.Single(s => s.StatsType == StatsType.Base).QueryTotalCount);
#endregion
MultiAssert.AssertAll();
Dictionary <string, Dictionary <StatsType, BasicJsonStats> > GetCnvStats(SampleStats sampleStats,
bool includeRef)
=> sampleStats.DetailedStats
.Where(x => x.VariantType.Equals(WittyerType.CopyNumberGain.Name) ||
x.VariantType.Equals(WittyerType.CopyNumberLoss.Name) ||
includeRef && x.VariantType.Equals(WittyerType.CopyNumberReference.Name))
.SelectMany(v => v.PerBinStats)
.GroupBy(s => s.Bin).ToDictionary(binGroups => binGroups.Key,
binGroups => binGroups.SelectMany(binStats => binStats.Stats).GroupBy(s => s.StatsType)
.ToDictionary(statsGroup => statsGroup.Key,
statsGroup => statsGroup.Aggregate(BasicJsonStats.Create(statsGroup.Key, 0, 0, 0, 0),
(acc, stat) => acc + stat)));
(ulong totalLength, uint numEvents) GetTotalCnvs(FileInfo vcf, bool includeRefs)
{
var trees = new ConcurrentDictionary <IContigInfo, MergedIntervalTree <uint> >();
// DO NOT delete: the line below are left there case we want to test without overlapping variants for test tweaking etc. i.e. it's debug code.
// IContigAndInterval lastInterval = null;
var numEvents = 0U;
foreach (var variant in VcfReader.TryCreate(vcf).GetOrThrow().Select(v => v.GetOrThrow()))
{
if (!IsCountedCnv(variant))
{
continue;
}
numEvents++;
var tree = trees.GetOrAdd(variant.Contig, _ => MergedIntervalTree.Create <uint>());
IContigAndInterval interval;
var start = variant.Position;
if (variant.Info.TryGetValue(VcfConstants.EndTagKey, out var end))
{
if (uint.TryParse(end, out var endVal))
{
interval = GetInterval(variant.Contig, start, endVal);
}
else
{
throw new ParserException($"couldn't parse {end} into END!");
}
}
else if (variant.Info.TryGetValue(VcfConstants.SvLenKey, out var svLen))
{
if (int.TryParse(svLen, out var len))
{
interval = len < 0
? GetInterval(variant.Contig, start - (uint)-len, start)
: GetInterval(variant.Contig, start, start + (uint)len);
}
else
{
throw new ParserException($"couldn't parse {svLen} into svLen!");
}
}
else
{
throw new NotImplementedException(
"Parsing using anything but svlen is not supported, should probably add it.");
}
tree.Add(interval);
// DO NOT delete: the line below are left there case we want to test without overlapping variants for test tweaking etc. i.e. it's debug code.
//lastInterval = interval;
}
return(trees.GetTotalLength(), numEvents);
IContigAndInterval GetInterval(IContigInfo contig, uint position, uint end)
{
var interval = ContigAndInterval.Create(contig, position, end);
return(interval);
// DO NOT delete: the remaining lines below are left there case we want to test without overlapping variants for test tweaking etc. i.e. it's debug code.
//if (lastInterval == null || !interval.Contig.Equals(lastInterval.Contig)) return interval;
//// adjust for possible overlaps between bins. (see https://jira.illumina.com/browse/WIT-84)
//var overlap = interval.TryGetOverlap(lastInterval).Select(o => o.GetLength()).GetOrDefault();
//if (overlap > 0)
// interval = ContigAndInterval.Create(interval.Contig, interval.Start + overlap,
// interval.Stop + overlap);
//return interval;
}
bool IsCountedCnv(IVcfVariant variant)
{
if (variant.Filters.SingleOrDefault() != VcfConstants.PassFilter)
{
// if not single or not PASS return false
return(false);
}
var isRef = variant.Alts.SingleOrDefault() == VcfConstants.MissingValueString;
if (isRef)
{
return(includeRefs);
}
if (variant.Samples.Count == 0)
{
return(false);
}
var hasCn = variant.Samples[0].SampleDictionary
.TryGetValue(VcfConstants.CnSampleFieldKey, out var cn);
var hasGt = variant.Samples[0].SampleDictionary.TryGetValue(VcfConstants.GenotypeKey, out var gt);
if (!hasCn)
{
return(includeRefs && // no cn means only true if we include Refs
hasGt && gt.Split(VcfConstants.GtPhasedValueDelimiter[0],
VcfConstants.GtUnphasedValueDelimiter[0])
.All(x => x == "0"));
}
if (!variant.Info.TryGetValue(VcfConstants.SvTypeKey, out var svType) ||
!WittyerConstants.BaseLevelStatsTypeStrings.Contains(svType))
{
return(false);
}
if (!int.TryParse(cn, out var ploidy))
{
return(false);
}
isRef = (hasGt
? gt.Split(VcfConstants.GtPhasedValueDelimiter[0],
VcfConstants.GtUnphasedValueDelimiter[0]).Length
: 2) == ploidy;
return(!isRef || includeRefs);
}
}
(ulong, ulong, ulong, ulong) GetActualTotalStatsFromBins(
Dictionary <string, Dictionary <StatsType, BasicJsonStats> > expectedBinned,
Dictionary <string, Dictionary <StatsType, BasicJsonStats> > actualBinned, bool includeRefs)
{
var actualTruthBase = 0UL;
var actualQueryBase = 0UL;
var actualTruthEvent = 0UL;
var actualQueryEvent = 0UL;
foreach (var(bin, binStats) in expectedBinned)
{
foreach (var(type, expectedCnvStats) in binStats)
{
var actualCnvStats = actualBinned[bin][type];
if (type == StatsType.Base)
{
actualTruthBase += actualCnvStats.TruthTotalCount;
actualQueryBase += actualCnvStats.QueryTotalCount;
}
else
{
actualTruthEvent += actualCnvStats.TruthTotalCount;
actualQueryEvent += actualCnvStats.QueryTotalCount;
}
if (!expectedCnvStats.Equals(actualCnvStats))
{
MultiAssert.Equal(expectedCnvStats, actualCnvStats);
MultiAssert.Equal("Expected ", includeRefs.ToString());
}
}
}
return(actualTruthBase, actualQueryBase, actualTruthEvent, actualQueryEvent);
}
}
