public static void WittyerVariantIntervalCorrect([NotNull] string variant, uint start, uint end,
uint posStart, uint posEnd, uint endStart, uint endEnd)
{
const string sampleName = "tumor";
var vcfVariant = VcfVariant.TryParse(variant,
VcfVariantParserSettings.Create(ImmutableList.Create("normal", sampleName), GenomeAssembly.Hg38))
.GetOrThrowDebug();
var _ = WittyerType.ParseFromVariant(vcfVariant, false, sampleName, out var type);
if (type == null)
{
throw new NotSupportedException("This test does not handle svType null");
}
var wittyerVariant = WittyerVariantInternal
.Create(vcfVariant, vcfVariant.Samples[sampleName], type, Bins, PercentDistance, BasepairDistance);
var expectedStart = ContigAndInterval.Create(vcfVariant.Contig, start, end);
var expectedPos = BedInterval.Create(posStart, posEnd);
var expectedEnd = BedInterval.Create(endStart, endEnd);
MultiAssert.Equal(expectedStart, wittyerVariant);
MultiAssert.Equal(expectedPos, wittyerVariant.CiPosInterval);
MultiAssert.Equal(expectedEnd, wittyerVariant.CiEndInterval);
MultiAssert.AssertAll();
}
private static IWittyerSimpleVariant CreateWittyerVariant([NotNull] string vcfline)
{
var baseVariant = VcfVariant.TryParse(vcfline,
VcfVariantParserSettings.Create(ImmutableList.Create("normal"), GenomeAssembly.Grch37))
.GetOrThrowDebug();
WittyerType.ParseFromVariant(baseVariant, true, null, out var svType);
if (svType == null)
{
throw new NotSupportedException("This method does not handle svType null");
}
return(WittyerVariantInternal
.Create(baseVariant, baseVariant.Samples["normal"], svType, Bins, PercentDistance, BasepairDistance));
}
internal static IContigProvider CreateVariant([NotNull] IVcfVariant vcfVariant, [CanBeNull] IVcfSample sample, bool isTruth,
[CanBeNull] string sampleName, IReadOnlyDictionary <WittyerType, InputSpec> inputSpecDict,
IDictionary <IGeneralBnd, IVcfVariant> bndSet, List <string> errorList, bool isCrossTypeOn)
{
var failedReason = WittyerType.ParseFromVariant(vcfVariant, isCrossTypeOn, sampleName, out var svType);
if (failedReason != null)
{
return(CreateUnsupportedVariant(vcfVariant, sample,
failedReason.Value == FailedReason.Unset
? throw new ArgumentOutOfRangeException(
$"Got {nameof(FailedReason)}.{FailedReason.Unset} which means bug in {nameof(WittyerType.TryParse)}")
: failedReason.Value,
isTruth));
}
if (svType == null)
{
throw new InvalidDataException("svType should not be null with no failed reason");
}
//User does not specify this SVTYPE in input spec, consider user want to exlude this particular SVTYPE comparison entirely
if (!inputSpecDict.TryGetValue(svType, out var inputSpec))
{
return(CreateUnsupportedVariant(vcfVariant, sample, FailedReason.VariantTypeSkipped, isTruth));
}
var isSupportedVariant = IsSupportedVariant();
if (!isSupportedVariant.Equals(FailedReason.Unset))
{
return(CreateUnsupportedVariant(vcfVariant, sample, isSupportedVariant, isTruth));
}
var bpd = inputSpec.BasepairDistance;
var pd = inputSpec.PercentDistance;
var bins = inputSpec.BinSizes;
if (svType == WittyerType.Insertion)
{
//insertion is basically using one same record as the both entries of the breakend pair
return(WittyerBndInternal.Create(vcfVariant,
sample, inputSpec.VariantType, bins.Select(sizeSkipTuple => sizeSkipTuple.size).ToReadOnlyList(), bpd, pd, vcfVariant));
}
if (svType == WittyerType.CopyNumberReference &&
vcfVariant.Info.TryGetValue(VcfConstants.SvTypeKey, out var svTypeString) &&
!WittyerConstants.BaseLevelStatsTypeStrings.Contains(svTypeString))
{
// any non-DEL/DUP/CNV that is determined to be reference copy number is not supported.
return(CreateUnsupportedVariant(vcfVariant, sample,
FailedReason.UnsupportedRefCall, isTruth));
}
if (svType == WittyerType.TranslocationBreakend ||
svType == WittyerType.IntraChromosomeBreakend)
{
var currentBnd = GeneralBnd.CreateFromVariant(vcfVariant);
//Note: this means the paired BND is found as a key in dictionary. Checkout the comparer for details
if (bndSet.TryGetValue(currentBnd, out var secondVariant))
{
if (!bndSet.Remove(currentBnd))
{
throw new InvalidOperationException(
$"Cannot remove {secondVariant} from breakend dictionary when pair is found: {vcfVariant}! Find a developer to debug!");
}
return(WittyerBndInternal.Create(vcfVariant, sample, svType, bins.Select(sizeSkipTuple => sizeSkipTuple.size).ToReadOnlyList(), bpd, pd, secondVariant));
}
bndSet.Add(currentBnd, vcfVariant);
return(currentBnd);
}
try
{
return(WittyerVariantInternal.Create(vcfVariant, sample, svType, bins.Select(sizeSkipTuple => sizeSkipTuple.size).ToReadOnlyList(), pd, bpd));
}
catch (Exception e)
{
if (errorList.Count <= MaxNonSupportedVariantToPrint)
{
errorList.Add(
new[] { "Exception caught:", e.ToString(), vcfVariant.ToString() }
.StringJoin(Environment.NewLine));
}
return(CreateUnsupportedVariant(vcfVariant, sample, FailedReason.Other, isTruth));
}
FailedReason IsSupportedVariant()
{
// Check filters.
IReadOnlyCollection <string> includedFilters, excludedFilters;
if (isTruth)
{
includedFilters = WittyerConstants.DefaultIncludeFilters;
excludedFilters = WittyerConstants.DefaultExcludeFilters;
}
else
{
includedFilters = inputSpec.IncludedFilters;
excludedFilters = inputSpec.ExcludedFilters;
}
if (vcfVariant.Filters.Any(excludedFilters.Contains) ||
includedFilters.Count > 0 &&
(vcfVariant.Filters.Count == 0 || !vcfVariant.Filters.Any(includedFilters.Contains)))
{
return(FailedReason.FilteredBySettings);
}
// SVLEN = 0 when they are supposed to have overlaps (svlen is needed for overlapping windows) are ignored
if (svType.HasOverlappingWindows &&
(vcfVariant.Info.TryGetValue(VcfConstants.EndTagKey, out var endString) &&
vcfVariant.Position.ToString() == endString ||
vcfVariant.Info.TryGetValue(VcfConstants.SvLenKey, out var svLenString) &&
svLenString == "0"))
{
return(FailedReason.InvalidSvLen);
}
// Bnd with pos and alt to be same position (temporarily to accomendate the situation of SVLEN=0 INV representing as bnd)
if (svType == WittyerType.IntraChromosomeBreakend)
{
var mate = SimpleBreakEnd.TryParse(vcfVariant.GetSingleAlt()).GetOrThrow();
return(vcfVariant.Position == mate.Position ? FailedReason.InvalidSvLen : FailedReason.Unset);
}
// todo: truth does not care about Sample FT tag, is that ok?
var sampleFilterOk = isTruth || !includedFilters.Contains(VcfConstants.PassFilter) || !vcfVariant.IsPassFilter() || IsSampleFtPassFilter();
if (!sampleFilterOk)
{
return(FailedReason.FailedSampleFilter);
}
// used include bed and variant is completely within a single contig and the bed doesn't include the contig
if (inputSpec.IncludedRegions != null && svType != WittyerType.TranslocationBreakend &&
!inputSpec.IncludedRegions.IntervalTree.ContainsKey(vcfVariant.Contig))
{
return(FailedReason.OutsideBedRegion);
}
return(FailedReason.Unset);
bool IsSampleFtPassFilter()
=> sample != null && (!sample.SampleDictionary.TryGetValue(WittyerConstants.Ft, out var ft) ||
ft.Equals(VcfConstants.PassFilter));
}
}
