public void CallVariants_MnvReallocatesToSnvOutsideInterval()
{
var config = new VariantCallerConfig
{
MaxVariantQscore = 100,
EstimatedBaseCallQuality = 20,
IncludeReferenceCalls = true,
MinFrequency = 6f / 150
};
var intervalSet = new ChrIntervalSet(new List <Region>()
{
new Region(1900, 1950)
}, "chr1");
var variantCaller = new AlleleCaller(config, intervalSet);
// -----------------------------------------------
// Passing MNV that spans interval edge should be called if it begins within intervals
// Failing MNVs that span interval edge and are reallocated to SNVs should only have those SNVs called if they are within intervals
// (broken-out SNVs outside intervals should not be called even if they gain enough support to be called).
// -----------------------------------------------
var passingMnv = new CandidateAllele("chr1", 1950, "TTT", "CCC", AlleleCategory.Mnv)
{
SupportByDirection = new[] { 10, 0, 0 }
};
var failingMnv1 = new CandidateAllele("chr1", 1950, "TTT", "GGG", AlleleCategory.Mnv) // only the first SNV should be called (1950 T>G)
{
SupportByDirection = new[] { 5, 0, 0 }
};
var failingMnv1Booster = new CandidateAllele("chr1", 1949, "TTTT", "GGGG", AlleleCategory.Mnv) // only the second SNV should be called (1950 T>G)
{
SupportByDirection = new[] { 5, 0, 0 }
};
var failingMnv2 = new CandidateAllele("chr1", 1950, "TTT", "AAA", AlleleCategory.Mnv) // none of these should be called
{
SupportByDirection = new[] { 5, 0, 0 }
};
var mockStateManager = MockStateManager(306, 0);
var candidateVariants = new List <CandidateAllele>
{
passingMnv,
failingMnv1,
failingMnv2,
failingMnv1Booster
};
var batch = new CandidateBatch(candidateVariants)
{
MaxClearedPosition = 2000
};
var calledVariants = variantCaller.Call(batch, mockStateManager.Object);
PrintResults(calledVariants.ToList());
Assert.Equal(2, calledVariants.Count());
}
public void Constructor()
{
var intervalSet = new ChrIntervalSet(new List <BasicRegion>()
{
new BasicRegion(4, 6),
new BasicRegion(8, 8),
new BasicRegion(9, 10)
}, "chr1");
Assert.Equal(4, intervalSet.MinPosition);
Assert.Equal(10, intervalSet.MaxPosition);
Assert.Equal("chr1", intervalSet.ChrName);
intervalSet = new ChrIntervalSet(new List <BasicRegion>(), "chr1");
Assert.Equal(0, intervalSet.MinPosition);
Assert.Equal(0, intervalSet.MaxPosition);
Assert.Throws <ArgumentException>(() => new ChrIntervalSet(null, "chr1"));
Assert.Throws <ArgumentException>(() => new ChrIntervalSet(new List <BasicRegion>(), null));
Assert.Throws <ArgumentException>(() => new ChrIntervalSet(new List <BasicRegion>(), ""));
Assert.Throws <ArgumentException>(() => new ChrIntervalSet(new List <BasicRegion>()
{
new BasicRegion(7, 6)
}, "chr1"));
}
public RegionStateManager(bool includeRefAlleles = false, int minBasecallQuality = 20, ChrIntervalSet intervalSet = null, int blockSize = Constants.RegionSize)
{
_regionSize = blockSize;
_minBasecallQuality = minBasecallQuality;
_includeRefAlleles = includeRefAlleles;
_intervalSet = intervalSet;
}
/// <summary>
/// CollapsedRegionStateManager
/// </summary>
/// <param name="includeRefAlleles"></param>
/// <param name="minBasecallQuality"></param>
/// <param name="intervalSet"></param>
/// <param name="blockSize"></param>
/// <param name="trackOpenEnded"></param>
/// <param name="trackReadSummaries"></param>
/// <remarks>create CollapsedRegionStateManager (derived) if both ExpectCollapsedReads and ExpectStitchedReads are true
/// otherwise use RegionStateManager (based) instead </remarks>
public CollapsedRegionStateManager(bool includeRefAlleles = false, int minBasecallQuality = 20,
ChrIntervalSet intervalSet = null, int blockSize = 1000,
bool trackOpenEnded = false, bool trackReadSummaries = false, int trackedAnchorSize = 5)
: base(includeRefAlleles, minBasecallQuality, true, intervalSet, blockSize, trackOpenEnded,
trackReadSummaries, trackedAnchorSize)
{
ExpectCollapsedReads = true;
}
public AlleleCaller(VariantCallerConfig config, ChrIntervalSet intervalSet = null,
IVariantCollapser variantCollapser = null, ICoverageCalculator coverageCalculator = null)
{
_config = config;
_intervalSet = intervalSet;
_collapser = variantCollapser;
_coverageCalculator = coverageCalculator ?? new CoverageCalculator();
_genotypeCalculator = config.GenotypeCalculator;
}
public List <CalledAllele> DoFiltering(List <CalledAllele> alleles)
{
var result = new List <CalledAllele>();
if (alleles.Count == 0)
{
return(result);
}
var chrName = alleles[0].Chromosome;
if (chrName != _currentChr)
{
if (_regionsByChr.ContainsKey(chrName))
{
_currentChrIntervalSet = new ChrIntervalSet(_regionsByChr[chrName], chrName);
}
else
{
_currentChrIntervalSet = new ChrIntervalSet(new List <Region>()
{
}, chrName);
return(result);
}
}
if (_currentChrIntervalSet.Intervals.Count == 0)
{
return(result);
}
switch (_mode)
{
case GeometricFilterParameters.InclusionModel.ByOverlap:
{
throw new ArgumentException("Option GeometricFilterParameters.InclusionModel.ByOverlap not currently supported.");
}
case GeometricFilterParameters.InclusionModel.Expanded:
{
result = DoFilteringByExpandingRegion(alleles, _currentChrIntervalSet);
break;
}
default:
{
result = DoFilteringByStartPosition(alleles, _currentChrIntervalSet);
break;
}
}
return(result);
}
private void ExecuteTest_Minus(BasicRegion keepRegion, List <BasicRegion> excludeRegions, List <BasicRegion> expectedRegions)
{
var results = ChrIntervalSet.GetMinus(keepRegion, excludeRegions);
Assert.Equal(expectedRegions.Count, results.Count);
for (var i = 0; i < expectedRegions.Count; i++)
{
Assert.Equal(expectedRegions[i], results[i]);
}
}
private void ExecuteTest_SortAndCollapse(ChrIntervalSet set, List <BasicRegion> expectedRegions)
{
set.SortAndCollapse();
Assert.Equal(expectedRegions.Count, set.Intervals.Count);
for (var i = 0; i < expectedRegions.Count; i++)
{
Assert.Equal(expectedRegions[i], set.Intervals[i]);
}
}
public RegionStateManager(bool includeRefAlleles = false, int minBasecallQuality = 20, bool expectStitchedReads = false,
ChrIntervalSet intervalSet = null, int blockSize = 1000,
bool trackOpenEnded = false, bool trackReadSummaries = false)
{
_regionSize = blockSize;
_minBasecallQuality = minBasecallQuality;
_includeRefAlleles = includeRefAlleles;
_intervalSet = intervalSet;
_trackOpenEnded = trackOpenEnded;
_trackReadSummaries = trackReadSummaries;
_expectStitchedReads = expectStitchedReads;
}
public SomaticVariantCaller(IAlignmentSource alignmentSource, ICandidateVariantFinder variantFinder, IAlleleCaller alleleCaller,
IVcfWriter <CalledAllele> vcfWriter, IStateManager stateManager, ChrReference chrReference, IRegionMapper regionMapper,
IStrandBiasFileWriter biasFileWriter, ChrIntervalSet intervalSet = null)
{
_alignmentSource = alignmentSource;
_variantFinder = variantFinder;
_alleleCaller = alleleCaller;
_vcfWriter = vcfWriter;
_stateManager = stateManager;
_chrReference = chrReference;
_regionMapper = regionMapper;
_biasFileWriter = biasFileWriter;
_intervalSet = intervalSet;
}
public SomaticVariantCaller(IAlignmentSource alignmentSource, ICandidateVariantFinder variantFinder, IAlleleCaller alleleCaller,
IVcfWriter <CalledAllele> vcfWriter, IStateManager stateManager, ChrReference chrReference, IRegionMapper regionMapper,
IStrandBiasFileWriter biasFileWriter, ChrIntervalSet intervalSet = null, HashSet <Tuple <string, int, string, string> > forcedGTAlleles = null)
{
_alignmentSource = alignmentSource;
_variantFinder = variantFinder;
_alleleCaller = alleleCaller;
_vcfWriter = vcfWriter;
_stateManager = stateManager;
_chrReference = chrReference;
_regionMapper = regionMapper;
_biasFileWriter = biasFileWriter;
_intervalSet = intervalSet;
_forcedGtAlleles = forcedGTAlleles;
_unProcessedForcedAllelesByPos = CreateForcedAllelePos(_forcedGtAlleles);
}
protected virtual IStateManager CreateStateManager(ChrIntervalSet intervalSet, bool expectStitchedReads = false, bool expectCollapsedReads = true)
{
if (expectStitchedReads && expectCollapsedReads)
{
// Create CollapsedRegionStateManager if input BAM is collapsed and stitched.
return(new CollapsedRegionStateManager(_options.VcfWritingParameters.OutputGvcfFile,
_options.BamFilterParameters.MinimumBaseCallQuality, intervalSet,
trackOpenEnded: _options.Collapse, blockSize: GlobalConstants.RegionSize,
trackReadSummaries: _options.CoverageMethod == CoverageMethod.Exact, trackedAnchorSize: (int)_options.TrackedAnchorSize));
}
// otherwise use the base
return(new RegionStateManager(_options.VcfWritingParameters.OutputGvcfFile,
_options.BamFilterParameters.MinimumBaseCallQuality, expectStitchedReads,
intervalSet,
trackOpenEnded: _options.Collapse, blockSize: GlobalConstants.RegionSize,
trackReadSummaries: _options.CoverageMethod == CoverageMethod.Exact, numAnchorTypes: (int)_options.TrackedAnchorSize));
}
private ChrIntervalSet GetIntervalSet(string chrName, string bamFilePath)
{
ChrIntervalSet chrIntervalSet = null;
if (_bamIntervalLookup.ContainsKey(bamFilePath))
{
var bamIntervals = _bamIntervalLookup[bamFilePath];
var chrRegions = bamIntervals.ContainsKey(chrName)
? bamIntervals[chrName]
: new List <Region>(); // empty means intervals applied, but none found for this chromosome
chrIntervalSet = new ChrIntervalSet(chrRegions, chrName);
chrIntervalSet.SortAndCollapse(); // make sure intervals are valid
}
return(chrIntervalSet);
}
public RegionStateManager(bool includeRefAlleles = false, int minBasecallQuality = 20,
bool expectStitchedReads = false,
ChrIntervalSet intervalSet = null, int blockSize = 1000,
bool trackOpenEnded = false, bool trackReadSummaries = false,
bool trackAmpliconCounts = false,
int numAnchorTypes = 5)
{
_regionSize = blockSize;
_minBasecallQuality = minBasecallQuality;
_includeRefAlleles = includeRefAlleles;
_intervalSet = intervalSet;
_trackOpenEnded = trackOpenEnded;
_trackReadSummaries = trackReadSummaries;
ExpectStitchedReads = expectStitchedReads;
ExpectCollapsedReads = false;
_numAnchorTypes = numAnchorTypes;
_trackAmpliconCounts = trackAmpliconCounts;
}
private void ExecuteTest_GetClipped(BasicRegion clipRegion, List <BasicRegion> excludeRegions, List <BasicRegion> expectedRegions = null)
{
var intervalSet = new ChrIntervalSet(
new List <BasicRegion>()
{
new BasicRegion(5, 10),
new BasicRegion(20, 30),
new BasicRegion(40, 50),
}, "chr1");
var results = intervalSet.GetClipped(clipRegion, excludeRegions);
Assert.Equal(expectedRegions.Count, results.Count);
for (var i = 0; i < expectedRegions.Count; i++)
{
Assert.Equal(expectedRegions[i], results[i]);
}
}
public void Constructor()
{
//Happy Path
var intervalSet = new ChrIntervalSet(new List <BasicRegion>()
{
new BasicRegion(4, 6),
new BasicRegion(8, 8),
new BasicRegion(9, 10)
}, "chr1");
Assert.Equal(4, intervalSet.MinPosition);
Assert.Equal(10, intervalSet.MaxPosition);
Assert.Equal("chr1", intervalSet.ChrName);
intervalSet = new ChrIntervalSet(new List <BasicRegion>(), "chr1");
Assert.Equal(0, intervalSet.MinPosition);
Assert.Equal(0, intervalSet.MaxPosition);
//Null Intervals
Assert.Throws <ArgumentException>(() => new ChrIntervalSet(null, "chr1"));
//Null Chromosome Name
Assert.Throws <ArgumentException>(() => new ChrIntervalSet(new List <BasicRegion>(), null));
//Empty Chromosome Name
Assert.Throws <ArgumentException>(() => new ChrIntervalSet(new List <BasicRegion>(), ""));
//Invalid Interval - StartPosition > End Position
Assert.Throws <ArgumentException>(() => new ChrIntervalSet(new List <BasicRegion>()
{
new BasicRegion(7, 6)
}, "chr1"));
//Invalid Interval - StartPosition <= 0
Assert.Throws <ArgumentException>(() => new ChrIntervalSet(new List <BasicRegion>()
{
new BasicRegion(0, 6)
}, "chr1"));
//Invalid Interval - EndPosition <= 0
Assert.Throws <ArgumentException>(() => new ChrIntervalSet(new List <BasicRegion>()
{
new BasicRegion(7, 0)
}, "chr1"));
}
public void ForceAlleleNotBeReportedWhenOutOfInterval()
{
var testRegion = new MyRegionState(10, 15);
var myChrRef = new ChrReference()
{
Name = "chr1",
Sequence = "ATGGCCTACGATTAGTAGGT"
};
HashSet <Tuple <string, int, string, string> > forcedAlleles = new HashSet <Tuple <string, int, string, string> >
{
new Tuple <string, int, string, string>("chr1", 12, "T", "C"),
new Tuple <string, int, string, string>("chr1", 12, "T", "A")
};
var myIntervals = new ChrIntervalSet(new List <Region> {
new Region(13, 15)
}, "chr1");
var observedCandidateAllele = testRegion.GetAllCandidates(true, myChrRef, myIntervals, forcedAlleles);
Assert.Equal(3, observedCandidateAllele.Count);
Assert.True(observedCandidateAllele.All(x => x.ReferencePosition > 12));
}
public List <CalledAllele> DoFilteringByStartPosition(List <CalledAllele> alleles, ChrIntervalSet chrIntervalSet)
{
//these should all be co-located alleles
var testAllele = alleles[0];
var result = new List <CalledAllele> {
};
if (chrIntervalSet.ContainsPosition(testAllele.ReferencePosition))
{
result = alleles;
}
chrIntervalSet.SetCleared(testAllele.ReferencePosition);
return(result);
}
protected override IRegionPadder CreateRegionPadder(ChrReference chrReference, ChrIntervalSet intervalSet, bool includeReferences)
{
return(MockRegionMapper != null ? MockRegionMapper.Object : base.CreateRegionPadder(chrReference, intervalSet, includeReferences));
}
protected override IStateManager CreateStateManager(ChrIntervalSet intervalSet)
{
return(MockStateManager != null ? MockStateManager.Object : base.CreateStateManager(intervalSet));
}
protected override IAlleleCaller CreateVariantCaller(ChrReference chrReference, ChrIntervalSet intervalSet)
{
return(MockVariantCaller != null ? MockVariantCaller.Object : base.CreateVariantCaller(chrReference, intervalSet));
}
private HashSet <Tuple <string, int, string, string> > SelectForcedAllele(Dictionary <string, HashSet <Tuple <string, int, string, string> > > forcedAllelesByChrom, string referenceName, ChrIntervalSet intervalSet)
{
var forcedGtAlleles = _forcedAllelesByChrom.ContainsKey(referenceName) ? _forcedAllelesByChrom[referenceName] : new HashSet <Tuple <string, int, string, string> >();
if (intervalSet == null)
{
return(forcedGtAlleles);
}
var allelesInInterval = new HashSet <Tuple <string, int, string, string> >();
foreach (var allele in forcedGtAlleles)
{
if (allele.Item1 == intervalSet.ChrName && intervalSet.ContainsPosition(allele.Item2))
{
allelesInInterval.Add(allele);
}
}
return(allelesInInterval);
}
protected virtual IRegionMapper CreateRegionPadder(ChrReference chrReference, ChrIntervalSet intervalSet, bool includeReference)
{
// padder is only required if there are intervals and we are including reference calls
return(intervalSet == null || !_options.VcfWritingParameters.OutputGvcfFile ? null : new RegionMapper(chrReference, intervalSet, _options.BamFilterParameters.MinimumBaseCallQuality));
}
protected virtual IAlleleCaller CreateVariantCaller(ChrReference chrReference, ChrIntervalSet intervalSet, IAlignmentSource alignmentSource, HashSet <Tuple <string, int, string, string> > forceGtAlleles = null)
{
var coverageCalculator = CreateCoverageCalculator(alignmentSource);
var genotypeCalculator = GenotypeCreator.CreateGenotypeCalculator(
_options.VariantCallingParameters.PloidyModel, _options.VariantCallingParameters.MinimumFrequencyFilter,
_options.VariantCallingParameters.MinimumCoverage,
_options.VariantCallingParameters.DiploidSNVThresholdingParameters,
_options.VariantCallingParameters.DiploidINDELThresholdingParameters,
_options.VariantCallingParameters.AdaptiveGenotypingParameters,
_options.VariantCallingParameters.MinimumGenotypeQScore,
_options.VariantCallingParameters.MaximumGenotypeQScore,
_options.VariantCallingParameters.TargetLODFrequency,
_options.VariantCallingParameters.MinimumFrequency,
chrReference.Name, _options.VariantCallingParameters.IsMale);
genotypeCalculator.SetMinFreqFilter(_options.VariantCallingParameters.MinimumFrequencyFilter);
var locusProcessor = _options.VariantCallingParameters.PloidyModel == PloidyModel.DiploidByThresholding
? (ILocusProcessor) new DiploidLocusProcessor()
: new SomaticLocusProcessor();
var variantCallerConfig = new VariantCallerConfig
{
IncludeReferenceCalls = _options.VcfWritingParameters.OutputGvcfFile,
MinVariantQscore = _options.VariantCallingParameters.MinimumVariantQScore,
MaxVariantQscore = _options.VariantCallingParameters.MaximumVariantQScore,
MinGenotypeQscore = _options.VariantCallingParameters.MinimumGenotypeQScore,
MaxGenotypeQscore = _options.VariantCallingParameters.MaximumGenotypeQScore,
VariantQscoreFilterThreshold = _options.VariantCallingParameters.MinimumVariantQScoreFilter,
NoCallFilterThreshold = _options.VariantCallingParameters.NoCallFilterThreshold,
AmpliconBiasFilterThreshold = _options.VariantCallingParameters.AmpliconBiasFilterThreshold,
MinCoverage = _options.VariantCallingParameters.MinimumCoverage,
MinFrequency = genotypeCalculator.MinVarFrequency,
NoiseLevelUsedForQScoring = _options.VariantCallingParameters.NoiseLevelUsedForQScoring,
StrandBiasModel = _options.VariantCallingParameters.StrandBiasModel,
StrandBiasFilterThreshold = _options.VariantCallingParameters.StrandBiasAcceptanceCriteria,
FilterSingleStrandVariants = _options.VariantCallingParameters.FilterOutVariantsPresentOnlyOneStrand,
GenotypeCalculator = genotypeCalculator,
VariantFreqFilter = genotypeCalculator.MinVarFrequencyFilter,
LowGTqFilter = _options.VariantCallingParameters.LowGenotypeQualityFilter,
IndelRepeatFilter = _options.VariantCallingParameters.IndelRepeatFilter,
LowDepthFilter = _options.VariantCallingParameters.LowDepthFilter,
ChrReference = chrReference,
RMxNFilterSettings = new RMxNFilterSettings
{
RMxNFilterMaxLengthRepeat = _options.VariantCallingParameters.RMxNFilterMaxLengthRepeat,
RMxNFilterMinRepetitions = _options.VariantCallingParameters.RMxNFilterMinRepetitions,
RMxNFilterFrequencyLimit = _options.VariantCallingParameters.RMxNFilterFrequencyLimit
},
NoiseModel = _options.VariantCallingParameters.NoiseModel,
LocusProcessor = locusProcessor
};
var alleleCaller = new AlleleCaller(variantCallerConfig, intervalSet,
CreateVariantCollapser(chrReference.Name, coverageCalculator),
coverageCalculator);
alleleCaller.AddForcedGtAlleles(forceGtAlleles);
return(alleleCaller);
}
protected override IStateManager CreateStateManager(ChrIntervalSet intervalSet, bool expectStitchedReads = false, bool expectCollapsedReads = false)
{
return(MockStateManager != null ? MockStateManager.Object : base.CreateStateManager(intervalSet));
}
/// <summary>
/// Sole job is to pad empty reference calls when using intervals. Assumes batch has already included reference calls (either empty or not)
/// for cleared regions.
/// </summary>
/// <param name="chrReference"></param>
/// <param name="includeReferenceCalls"></param>
/// <param name="intervals"></param>
public RegionPadder(ChrReference chrReference, ChrIntervalSet intervals)
{
_chrReference = chrReference;
IntervalSet = intervals;
}
public AlleleCaller(VariantCallerConfig config, ChrIntervalSet intervalSet = null)
{
_config = config;
_intervalSet = intervalSet;
}
public List <CandidateAllele> GetAllCandidates(bool includeRefAlleles, ChrReference chrReference,
ChrIntervalSet intervals = null, HashSet <Tuple <string, int, string, string> > forcesGtAlleles = null)
{
var alleles = new List <CandidateAllele>();
// add all candidates - these are potentially collapsable targets
foreach (var positionLookup in _candidateVariantsLookup)
{
if (positionLookup != null)
{
alleles.AddRange(positionLookup);
}
}
var IntervalsInUse = includeRefAlleles ? intervals : CreateIntervalsFromAllels(chrReference, forcesGtAlleles);
if (includeRefAlleles || (forcesGtAlleles != null && forcesGtAlleles.Count != 0))
{
var regionsToFetch = IntervalsInUse == null
? new List <Region> {
this
} // fetch whole block region
: IntervalsInUse.GetClipped(this); // clip intervals to block region
for (var i = 0; i < regionsToFetch.Count; i++)
{
var clippedInterval = regionsToFetch[i];
for (var position = clippedInterval.StartPosition;
position <= clippedInterval.EndPosition;
position++)
{
var positionIndex = position - StartPosition;
// add ref alleles within region to fetch - note that zero coverage ref positions are only added if input intervals provided
if (position > chrReference.Sequence.Length)
{
break;
}
var refBase = chrReference.Sequence[position - 1].ToString();
var refBaseIndex = (int)AlleleHelper.GetAlleleType(refBase);
var refAllele = new CandidateAllele(chrReference.Name, position,
refBase, refBase, AlleleCategory.Reference);
// gather support for allele
var totalSupport = 0;
for (var alleleTypeIndex = 0; alleleTypeIndex < Constants.NumAlleleTypes; alleleTypeIndex++)
{
for (var directionIndex = 0; directionIndex < Constants.NumDirectionTypes; directionIndex++)
{
var count = 0;
for (int anchorIndex = 0; anchorIndex < NumAnchorIndexes; anchorIndex++)
{
var countForAnchorType = _alleleCounts[positionIndex, alleleTypeIndex, directionIndex, anchorIndex];
count += countForAnchorType;
}
if (alleleTypeIndex == refBaseIndex)
{
refAllele.SupportByDirection[directionIndex] = count;
// TODO this isn't really proven to be well-anchored, nor is it proven not to be
//refAllele.WellAnchoredSupportByDirection[directionIndex] = count;
}
totalSupport += count;
}
}
if (IntervalsInUse != null || totalSupport > 0)
{
alleles.Add(refAllele);
}
}
}
}
return(alleles);
}
public void ExecuteTest_GetCandidates(bool withReference, bool withIntervals)
{
var testRegion = new RegionState(1, 50);
var chrReference = new ChrReference()
{
Name = "chr1",
Sequence = string.Concat(Enumerable.Repeat("A", 50))
};
var snv1 = new CandidateAllele("chr1", 5, "A", "T", AlleleCategory.Snv)
{
SupportByDirection = new [] { 10, 5, 0 }
};
var snv2 = new CandidateAllele("chr1", 15, "A", "T", AlleleCategory.Snv)
{
SupportByDirection = new[] { 10, 5, 0 }
};
testRegion.AddCandidate(snv1);
testRegion.AddCandidate(snv2);
for (var i = 0; i < 5; i++)
{
testRegion.AddAlleleCount(5, AlleleType.A, DirectionType.Stitched); // ref @ variant position
testRegion.AddAlleleCount(6, AlleleType.A, DirectionType.Stitched); // ref by itself
testRegion.AddAlleleCount(10, AlleleType.C, DirectionType.Stitched); // nonref by itself (no ref)
testRegion.AddAlleleCount(15, AlleleType.A, DirectionType.Reverse); // ref (multiple directions) + nonref
testRegion.AddAlleleCount(15, AlleleType.A, DirectionType.Forward);
testRegion.AddAlleleCount(15, AlleleType.T, DirectionType.Reverse);
}
ChrIntervalSet intervals = null;
if (withIntervals)
{
intervals = new ChrIntervalSet(new List <CallSomaticVariants.Logic.RegionState.Region>()
{
new CallSomaticVariants.Logic.RegionState.Region(3, 6),
new CallSomaticVariants.Logic.RegionState.Region(16, 16)
}, "chr1");
}
var expectedList = new List <CandidateAllele>();
expectedList.Add(snv1);
expectedList.Add(snv2);
if (withReference)
{
expectedList.Add(new CandidateAllele("chr1", 5, "A", "A", AlleleCategory.Reference)
{
SupportByDirection = new[] { 0, 0, 5 }
});
expectedList.Add(new CandidateAllele("chr1", 6, "A", "A", AlleleCategory.Reference)
{
SupportByDirection = new[] { 0, 0, 5 }
});
expectedList.Add(new CandidateAllele("chr1", 10, "A", "A", AlleleCategory.Reference)
{
SupportByDirection = new[] { 0, 0, 0 }
});
expectedList.Add(new CandidateAllele("chr1", 15, "A", "A", AlleleCategory.Reference)
{
SupportByDirection = new[] { 5, 5, 0 }
});
}
if (withIntervals)
{
expectedList = expectedList.Where(c => c.Coordinate == 5 || c.Coordinate == 6 || c.Type != AlleleCategory.Reference).ToList();
if (withReference)
{
expectedList.Add(new CandidateAllele("chr1", 3, "A", "A", AlleleCategory.Reference)
{
SupportByDirection = new[] { 0, 0, 0 }
});
expectedList.Add(new CandidateAllele("chr1", 4, "A", "A", AlleleCategory.Reference)
{
SupportByDirection = new[] { 0, 0, 0 }
});
expectedList.Add(new CandidateAllele("chr1", 16, "A", "A", AlleleCategory.Reference)
{
SupportByDirection = new[] { 0, 0, 0 }
});
}
}
var allCandidates = testRegion.GetAllCandidates(withReference, chrReference, intervals);
VerifyCandidates(expectedList, allCandidates);
}
public List <CalledAllele> DoFilteringByExpandingRegion(List <CalledAllele> alleles, ChrIntervalSet chrIntervalSet)
{
//these should all be co-located alleles
var emptyResult = new List <CalledAllele> {
};
var testAllele = alleles[0];
if (chrIntervalSet.ContainsPosition(testAllele.ReferencePosition))
{
chrIntervalSet.SetCleared(testAllele.ReferencePosition);
return(alleles);
}
else //we already know the start positons are NOT in the interval. Now check the rest of the bases.
{
bool expandInterval = false;
foreach (var allele in alleles)
{
int startPosPlusOne = allele.ReferencePosition + 1;
int endPos = allele.ReferencePosition + allele.ReferenceAllele.Length - 1;
for (int internalPosition = startPosPlusOne; internalPosition <= endPos; internalPosition++)
{
if (chrIntervalSet.ContainsPosition(internalPosition))
{
chrIntervalSet.ExpandInterval(internalPosition, testAllele.ReferencePosition);
expandInterval = true;
break;
}
}
}
chrIntervalSet.SetCleared(testAllele.ReferencePosition);
if (expandInterval)
{
return(alleles);
}
else
{
return(emptyResult);
}
}
}
