private CandidateAllele GetMatches(CandidateAllele toCollapse, IEnumerable <CandidateAllele> targets, IAlleleSource source)
{
var potentialMatches = targets.Where(c => CanCollapse(toCollapse, c) &&
c != toCollapse).ToList();
if (potentialMatches.Count == 0)
{
return(null);
}
// reset frequency - could have changed from last time fetched
foreach (var variant in potentialMatches)
{
var callableVariant = AlleleHelper.Map(variant);
_coverageCalculator.Compute(callableVariant, source);
variant.Frequency = callableVariant.Frequency;
}
// to collapse frequency
var toCollapseCallableVariant = AlleleHelper.Map(toCollapse);
_coverageCalculator.Compute(toCollapseCallableVariant, source);
potentialMatches.Sort(this);
// if there's an exact match to a fully anchored variant, take that first
// otherwise take the most likely potential match
var exactMatch = potentialMatches.FirstOrDefault(m => m.Equals(toCollapse) && !m.OpenOnLeft && !m.OpenOnRight);
// if no exact match to fully anchored, take first potential match that meets threshold requirements
return(exactMatch ?? potentialMatches.FirstOrDefault(m => m.Frequency >= _freqThreshold && m.Frequency / toCollapseCallableVariant.Frequency > _freqRatioThreshold));
}
private bool IsCallable(CandidateIndel indel, IAlleleSource alleleSource)
{
// set frequency
var callable = AlleleHelper.Map(indel);
_coverageCalculator.Compute(callable, alleleSource);
indel.Frequency = callable.Frequency;
return(indel.IsKnown || callable.Frequency >= _frequencyCutoff);
}
public void MapToCandidateAllele()
{
var allele = new CalledAllele();
allele.Chromosome = "chr1";
allele.Coordinate = 1;
allele.Reference = "A";
allele.Alternate = "T";
allele.Type = AlleleCategory.Snv;
allele.SupportByDirection = new[] { 10, 20, 30 };
var mappedAllele = AlleleHelper.Map(allele);
Assert.Equal(mappedAllele.Chromosome, allele.Chromosome);
Assert.Equal(mappedAllele.Coordinate, allele.Coordinate);
Assert.Equal(mappedAllele.Reference, allele.Reference);
Assert.Equal(mappedAllele.Alternate, allele.Alternate);
Assert.Equal(mappedAllele.Type, allele.Type);
Assert.Equal(mappedAllele.SupportByDirection.Count(), allele.SupportByDirection.Count());
for (int i = 0; i < allele.SupportByDirection.Count(); i++)
{
Assert.Equal(mappedAllele.SupportByDirection[i], allele.SupportByDirection[i]);
}
}
public void MapToBaseCalledAllele()
{
//Called variant
var allele = new CandidateAllele("chr1", 1, "A", "G", AlleleCategory.Snv);
allele.SupportByDirection = new[] { 10, 20, 30 };
var BaseCalledAllele = AlleleHelper.Map(allele);
Assert.True(BaseCalledAllele.Type != AlleleCategory.Reference);
Assert.Equal(BaseCalledAllele.Chromosome, allele.Chromosome);
Assert.Equal(BaseCalledAllele.Coordinate, allele.Coordinate);
Assert.Equal(BaseCalledAllele.Reference, allele.Reference);
Assert.Equal(BaseCalledAllele.Alternate, allele.Alternate);
Assert.Equal(BaseCalledAllele.Type, allele.Type);
Assert.Equal(BaseCalledAllele.SupportByDirection.Count(), allele.SupportByDirection.Count());
for (int i = 0; i < allele.SupportByDirection.Count(); i++)
{
Assert.Equal(BaseCalledAllele.SupportByDirection[i], allele.SupportByDirection[i]);
}
//Called reference
allele.Type = AlleleCategory.Reference;
var calledReference = AlleleHelper.Map(allele);
Assert.True(calledReference.Type == AlleleCategory.Reference);
Assert.Equal(calledReference.Chromosome, allele.Chromosome);
Assert.Equal(calledReference.Coordinate, allele.Coordinate);
Assert.Equal(calledReference.Reference, allele.Reference);
Assert.Equal(calledReference.Alternate, allele.Alternate);
Assert.Equal(calledReference.Type, allele.Type);
Assert.Equal(calledReference.SupportByDirection.Count(), allele.SupportByDirection.Count());
for (int i = 0; i < allele.SupportByDirection.Count(); i++)
{
Assert.Equal(calledReference.SupportByDirection[i], allele.SupportByDirection[i]);
}
}
private SortedList <int, List <CalledAllele> > CallForPositions(List <CandidateAllele> candidates, IAlleleSource source, int?maxPosition)
{
var calledAllelesByPosition = new SortedList <int, List <CalledAllele> >();
var failedMnvs = new List <CalledAllele>();
var callableAlleles = new List <CalledAllele>();
if (_collapser != null)
{
candidates = _collapser.Collapse(candidates.ToList(), source, maxPosition);
}
foreach (var candidate in candidates)
{
var variant = AlleleHelper.Map(candidate);
if (variant.Type == AlleleCategory.Mnv)
{
ProcessVariant(source, variant);
if (IsCallable(variant))
{
callableAlleles.Add(variant);
}
else
{
failedMnvs.Add(variant);
}
}
else
{
callableAlleles.Add(variant);
}
}
var leftoversInNextBlock = MnvReallocator.ReallocateFailedMnvs(failedMnvs, callableAlleles, maxPosition);
source.AddCandidates(leftoversInNextBlock.Select(AlleleHelper.Map));
source.AddGappedMnvRefCount(GetRefSupportFromGappedMnvs(callableAlleles));
// need to re-process variants since they may have additional support
foreach (var baseCalledAllele in callableAlleles)
{
ProcessVariant(source, baseCalledAllele);
if (IsCallable(baseCalledAllele) && ShouldReport(baseCalledAllele))
{
List <CalledAllele> calledAtPosition;
if (!calledAllelesByPosition.TryGetValue(baseCalledAllele.Coordinate, out calledAtPosition))
{
calledAtPosition = new List <CalledAllele>();
calledAllelesByPosition.Add(baseCalledAllele.Coordinate, calledAtPosition);
}
calledAtPosition.Add(baseCalledAllele);
}
}
// re-process variants by loci to get GT (to potentially take into account multiple var alleles at same loci)
// and prune allele lists as needed.
foreach (var allelesAtPosition in calledAllelesByPosition.Values)
{
//pruning ref calls
if (allelesAtPosition.Any(v => v.Type != AlleleCategory.Reference))//(v => v is BaseCalledAllele))
{
allelesAtPosition.RemoveAll(v => (v.Type == AlleleCategory.Reference));
}
//set GT and GT score, and prune any variant calls that exceed the ploidy model
var allelesToPrune = _genotypeCalculator.SetGenotypes(allelesAtPosition);
foreach (var alleleToPrune in allelesToPrune)
{
allelesAtPosition.Remove(alleleToPrune);
}
foreach (var allele in allelesAtPosition)
{
if (_config.LowGTqFilter.HasValue && allele.GenotypeQscore < _config.LowGTqFilter)
{
allele.AddFilter(FilterType.LowGenotypeQuality);
}
}
allelesAtPosition.Sort((a1, a2) =>
{
var refCompare = a1.Reference.CompareTo(a2.Reference);
return(refCompare == 0 ? a1.Alternate.CompareTo(a2.Alternate) : refCompare);
});
}
return(calledAllelesByPosition);
}
private SortedList <int, List <CalledAllele> > CallForPositions(List <CandidateAllele> candidates, IAlleleSource source, int?maxPosition)
{
var failedMnvs = new List <CalledAllele>();
var callableAlleles = new List <CalledAllele>();
if (_collapser != null)
{
candidates = _collapser.Collapse(candidates.ToList(), source, maxPosition);
}
foreach (var candidate in candidates)
{
var variant = AlleleHelper.Map(candidate);
if (variant.Type == AlleleCategory.Mnv)
{
ProcessVariant(source, variant);
if (IsCallable(variant))
{
callableAlleles.Add(variant);
}
else
{
failedMnvs.Add(variant);
}
}
else
{
callableAlleles.Add(variant);
}
}
var leftoversInNextBlock = MnvReallocator.ReallocateFailedMnvs(failedMnvs, callableAlleles, maxPosition);
source.AddCandidates(leftoversInNextBlock.Select(AlleleHelper.Map));
source.AddGappedMnvRefCount(GetRefSupportFromGappedMnvs(callableAlleles));
var calledAllelesByPosition = new SortedList <int, List <CalledAllele> >(); //
foreach (var failedMNV in failedMnvs)
{
//if any of these failed MNVs was an injected ForcedGT varaint, we need to spike it back in,
//so it still gets reported to the VCF
if (IsForcedAllele(failedMNV))
{
callableAlleles.Add(failedMNV);
}
}
// need to re-process variants since they may have additional support
foreach (var baseCalledAllele in callableAlleles)
{
ProcessVariant(source, baseCalledAllele);
if (IsForcedAllele(baseCalledAllele) && !(IsCallable(baseCalledAllele) && ShouldReport(baseCalledAllele)))
{
baseCalledAllele.IsForcedToReport = true;
baseCalledAllele.AddFilter(FilterType.ForcedReport);
}
if ((IsCallable(baseCalledAllele) && ShouldReport(baseCalledAllele)) || IsForcedAllele(baseCalledAllele))
{
List <CalledAllele> calledAtPosition;
if (!calledAllelesByPosition.TryGetValue(baseCalledAllele.ReferencePosition, out calledAtPosition))
{
calledAtPosition = new List <CalledAllele>();
calledAllelesByPosition.Add(baseCalledAllele.ReferencePosition, calledAtPosition);
}
calledAtPosition.Add(baseCalledAllele);
}
}
// re-process variants by loci to get GT (to potentially take into account multiple var alleles at same loci)
// and prune allele lists as needed.
foreach (var allelesAtPosition in calledAllelesByPosition.Values)
{
ComputeGenotypeAndFilterAllele(allelesAtPosition);
_locusProcessor.Process(allelesAtPosition);
}
return(calledAllelesByPosition);
}