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); }