/// <summary> /// Combine two variants. /// Variant B can be null. /// We never try to combine two different variant alleles. /// </summary> /// <param name="VariantsA"></param> /// <param name="VariantsB"></param> /// <param name="ComparisonCase"></param> /// <param name="Consensus"></param> public AggregateAllele CombineVariants(CalledAllele VariantA, CalledAllele VariantB, VariantComparisonCase ComparisonCase) { SampleAggregationParameters SampleAggregationOptions = _options.SampleAggregationParameters; var Consensus = new AggregateAllele(new List <CalledAllele> { VariantA, VariantB }); int DepthA = 0; int DepthB = 0; //(A) set the reference data. //this should be the same for both. if (VariantA != null) { DoDefensiveGenotyping(VariantA); Consensus.Chromosome = VariantA.Chromosome; Consensus.ReferencePosition = VariantA.ReferencePosition; Consensus.ReferenceAllele = VariantA.ReferenceAllele; DepthA = VariantA.TotalCoverage; } if (VariantB != null) { DoDefensiveGenotyping(VariantB); Consensus.Chromosome = VariantB.Chromosome; Consensus.ReferencePosition = VariantB.ReferencePosition; Consensus.ReferenceAllele = VariantB.ReferenceAllele; DepthB = VariantB.TotalCoverage; } //normally the reference data is the same for both, no matter what the case. //but if we have one deletion and one not, we might have different ref alleles. //So we need to get this right. Consensus.ReferenceAllele = CombineReferenceAlleles(VariantA, VariantB, ComparisonCase); // (B) set the Alternate data Consensus.AlternateAllele = CombineVariantAlleles(VariantA, VariantB, ComparisonCase); // (C) set filters, etc. Consensus.Filters = CombineFilters(VariantA, VariantB); // (E) set GT data, includes calculating the probe-pool bias and quality scores RecalculateScoring(VariantA, VariantB, ComparisonCase, Consensus, SampleAggregationOptions, _options.VariantCallingParams); return(Consensus); }
private void WriteVarsToVennFiles(VariantComparisonCase ComparisonCase, CalledAllele VariantA, CalledAllele VariantB) { AggregateAllele AggregateA = AggregateAllele.SafeCopy(VariantA, new List <CalledAllele> { VariantA, VariantB }); AggregateAllele AggregateB = AggregateAllele.SafeCopy(VariantB, new List <CalledAllele> { VariantB, VariantA }); if (ComparisonCase == VariantComparisonCase.AgreedOnAlternate) { _vennDiagramWriters["AandB"].Write(new List <AggregateAllele>() { AggregateA }); _vennDiagramWriters["BandA"].Write(new List <AggregateAllele>() { AggregateB }); } if ((ComparisonCase == VariantComparisonCase.OneReferenceOneAlternate) || (ComparisonCase == VariantComparisonCase.CanNotCombine)) { if ((VariantA != null) && (VariantA.Type != Pisces.Domain.Types.AlleleCategory.Reference)) { _vennDiagramWriters["AnotB"].Write(new List <CalledAllele>() { VariantA }); } if ((VariantB != null) && (VariantB.Type != Pisces.Domain.Types.AlleleCategory.Reference)) { _vennDiagramWriters["BnotA"].Write(new List <CalledAllele>() { VariantB }); } } }
/// <summary> /// perfom a Venn split between two samples /// </summary> /// <param name="sampleName"></param> /// <param name="consensusFilePath"></param> /// <param name="inputPaths"></param> /// <param name="outputTwoSampleResults"></param> public void DoPairwiseVenn(bool mFirst) { bool doConsensus = (consensusBuilder != null); bool requireGenotypes = false; using (VcfReader ReaderA = new VcfReader(_inputPaths[0], requireGenotypes)) using (VcfReader ReaderB = new VcfReader(_inputPaths[1], requireGenotypes)) { if (doConsensus) { consensusBuilder.OpenConsensusFile(ReaderA.HeaderLines); } OpenVennDiagramStreams(ReaderA.HeaderLines); //read the first variant from each gvcf file... var currentAllele = new CalledAllele(); var backLogPoolAVcfVariant = new VcfVariant(); var backLogPoolBVcfVariant = new VcfVariant(); var backLogExistPoolA = ReaderA.GetNextVariant(backLogPoolAVcfVariant); var backLogExistPoolB = ReaderB.GetNextVariant(backLogPoolBVcfVariant); var backLogPoolAAlleles = backLogExistPoolA ? VcfVariantUtilities.Convert(new List <VcfVariant> { backLogPoolAVcfVariant }).ToList() : null; var backLogPoolBAlleles = backLogExistPoolB ? VcfVariantUtilities.Convert(new List <VcfVariant> { backLogPoolBVcfVariant }).ToList() : null; //keep reading and processing until we are done with both gvcfs while (true) { try { //1) Get the next set of variants. Pull from the backlog first, //choosing all the variants at the first available position. var coLocatedPoolAAlleles = new List <CalledAllele>(); var coLocatedPoolBAlleles = new List <CalledAllele>(); //We need to set up which location to look at next. //Choose the first one from the backlog. if (backLogExistPoolA || backLogExistPoolB) { if (backLogExistPoolA && backLogExistPoolB) { int OrderResult = AlleleCompareByLoci.OrderAlleles( backLogPoolAAlleles.First(), backLogPoolBAlleles.First(), mFirst); if (OrderResult < 0) { currentAllele.Chromosome = backLogPoolAAlleles.First().Chromosome; currentAllele.ReferencePosition = backLogPoolAAlleles.First().ReferencePosition; } else { currentAllele.Chromosome = backLogPoolBAlleles.First().Chromosome; currentAllele.ReferencePosition = backLogPoolBAlleles.First().ReferencePosition; } } else if (backLogExistPoolB) { currentAllele.Chromosome = backLogPoolBAlleles.First().Chromosome; currentAllele.ReferencePosition = backLogPoolBAlleles.First().ReferencePosition; } else //if (backLogExistPoolA) { currentAllele.Chromosome = backLogPoolAAlleles.First().Chromosome; currentAllele.ReferencePosition = backLogPoolAAlleles.First().ReferencePosition; } //assemble lists of co-located variants at the position of the current variant coLocatedPoolAAlleles = AssembleColocatedList(ReaderA, currentAllele, mFirst, ref backLogExistPoolA, ref backLogPoolAAlleles); coLocatedPoolBAlleles = AssembleColocatedList(ReaderB, currentAllele, mFirst, ref backLogExistPoolB, ref backLogPoolBAlleles); } //else, if there is nothing in either backlog, the colocated-variant list should stay empty. //2) Now we have finshed reading out all the co-located variants... //We need organize them into pairs, to know which allele to compare with which. var Pairs = SelectPairs(coLocatedPoolAAlleles, coLocatedPoolBAlleles); var ConsensusVariants = new List <CalledAllele>(); AggregateAllele lastConsensusReferenceCall = null; //3) For each pair, combine them and mark if biased or not. for (int PairIndex = 0; PairIndex < Pairs.Count; PairIndex++) { var VariantA = Pairs[PairIndex][0]; var VariantB = Pairs[PairIndex][1]; var ComparisonCase = GetComparisonCase(VariantA, VariantB); //add VarA and VarB to appropriate venn diagram files. WriteVarsToVennFiles(ComparisonCase, VariantA, VariantB); AggregateAllele Consensus = null; if (doConsensus) { Consensus = consensusBuilder.CombineVariants( VariantA, VariantB, ComparisonCase); //Its possible for multiallelic sites, a pair of variants could //end up as a concensus reference. And we already may have //called a reference for this loci already. //we might have some cleaning up to do... if (Consensus.Genotype == Pisces.Domain.Types.Genotype.HomozygousRef) { //this is the first time we see a reference at this loci if (lastConsensusReferenceCall == null) { lastConsensusReferenceCall = Consensus; //its OK to fall through and add our Consensus variant to the list. } //Else, if we have already called a reference variant // for this loci already // we want to merge the results from this reference with the old one. // *before* we write it to file. else { //the chr, pos, ref, alt,and depth should be correct. //We'll merge the filters, //and take the max SB and PB. (where a higher value indicates worse value, so we stay conservative) lastConsensusReferenceCall.Filters = ConsensusBuilder.CombineFilters(lastConsensusReferenceCall, Consensus); lastConsensusReferenceCall.StrandBiasResults = new Pisces.Domain.Models.BiasResults() { GATKBiasScore = Math.Max(lastConsensusReferenceCall.StrandBiasResults.GATKBiasScore, Consensus.StrandBiasResults.GATKBiasScore) }; lastConsensusReferenceCall.PoolBiasResults = new Pisces.Domain.Models.BiasResults() { GATKBiasScore = Math.Max(lastConsensusReferenceCall.PoolBiasResults.GATKBiasScore, Consensus.PoolBiasResults.GATKBiasScore) }; //we are going to take the min Q and NL score, to be conservative lastConsensusReferenceCall.NoiseLevelApplied = Math.Min(lastConsensusReferenceCall.NoiseLevelApplied, Consensus.NoiseLevelApplied); lastConsensusReferenceCall.GenotypeQscore = Math.Min(lastConsensusReferenceCall.GenotypeQscore, Consensus.GenotypeQscore); lastConsensusReferenceCall.VariantQscore = Math.Min(lastConsensusReferenceCall.VariantQscore, Consensus.GenotypeQscore); continue; } } ConsensusVariants.Add(Consensus); } } //4) Write out the results to file. (this will be a list of co-located variants) if (doConsensus) { consensusBuilder.WriteConsensusVariantsToFile(ConsensusVariants); } //we assembled everyone and no one is left. if ((backLogPoolAAlleles == null) && (backLogPoolBAlleles == null)) { break; } } catch (Exception ex) { OnError(string.Format("Fatal error encountered comparing paired sample vcfs; Check {0}, position {1}. Exception: {2}", currentAllele.Chromosome, currentAllele.ReferencePosition, ex)); throw; } } //close assemble list }//close usings if (doConsensus) { consensusBuilder.CloseConsensusFile(); } CloseVennDiagramStreams(); }
public void VennVcf_CombineTwoPoolVariants_Qscore_DiffentNL_Test() { //chr3 41266161 . A G 30 PASS DP=3067 GT:GQ:AD:VF:NL:SB 0/1:30:3005,54:0.0176:35:-100.0000 CalledAllele VarA = new CalledAllele() { Chromosome = "chr3", ReferencePosition = 41266161, TotalCoverage = 3067, Genotype = Pisces.Domain.Types.Genotype.HeterozygousAltRef, VariantQscore = 30, GenotypeQscore = 30, AlleleSupport = 54, ReferenceSupport = 3005, NoiseLevelApplied = 35, StrandBiasResults = new Pisces.Domain.Models.BiasResults() { GATKBiasScore = -100.0000 }, ReferenceAllele = "A", AlternateAllele = "G", Type = Pisces.Domain.Types.AlleleCategory.Snv }; ///chr3 41266161 . A . 75 PASS DP=3795 GT:GQ:AD:VF:NL:SB 0/0:75:3780:0.0040:2:-100.0000 CalledAllele VarB = new CalledAllele() { Chromosome = "chr3", ReferencePosition = 41266161, TotalCoverage = 3795, Genotype = Pisces.Domain.Types.Genotype.HomozygousRef, VariantQscore = 75, GenotypeQscore = 75, AlleleSupport = 3780, ReferenceSupport = 3780, NoiseLevelApplied = 2, StrandBiasResults = new Pisces.Domain.Models.BiasResults() { GATKBiasScore = -100.0000 }, ReferenceAllele = "A", AlternateAllele = ".", Type = Pisces.Domain.Types.AlleleCategory.Reference }; //old answer //chr3 41266161 . A . 100.00 PASS DP=6862;cosmic=COSM1423020,COSM1423021;EVS=0|69.0|6503;phastCons GT:GQ:AD:VF:NL:SB:PB:GQX 0/0:100:6785:0.0079:35:-100:-100.0000:100 SampleAggregationParameters SampleAggregationOptions = new SampleAggregationParameters(); SampleAggregationOptions.ProbePoolBiasThreshold = 0.5f; SampleAggregationOptions.HowToCombineQScore = SampleAggregationParameters.CombineQScoreMethod.CombinePoolsAndReCalculate; _basicOptions.BamFilterParams.MinimumBaseCallQuality = 20; _basicOptions.VariantCallingParams.MinimumFrequency = 0.01f; _basicOptions.VariantCallingParams.MinimumFrequencyFilter = 0.03f; _basicOptions.SampleAggregationParameters = SampleAggregationOptions; string consensusOut = Path.Combine(_TestDataPath, "ConsensusOut.vcf"); VariantComparisonCase ComparisonCase = VennProcessor.GetComparisonCase(VarA, VarB); ConsensusBuilder consensusBuilder = new ConsensusBuilder(consensusOut, _basicOptions); AggregateAllele consensus = consensusBuilder.CombineVariants(VarA, VarB, ComparisonCase); Console.WriteLine(consensus.ToString()); double expectedNoiseLevel = MathOperations.PtoQ( (MathOperations.QtoP(35) + MathOperations.QtoP(2)) / (2.0)); // 5 //GT:GQ:AD:VF:NL:SB:PB:GQX 0/0:100:6785:0.0079:35:-100:-100.0000:100 Assert.NotNull(consensus); Assert.Equal(consensus.VariantQscore, 100); Assert.Equal(consensus.ReferenceAllele, "A"); Assert.Equal(consensus.AlternateAllele, "."); Assert.Equal(consensus.Genotype, Pisces.Domain.Types.Genotype.HomozygousRef); Assert.Equal(consensus.TotalCoverage, 6862); Assert.Equal(consensus.ReferenceSupport, 6785); Assert.Equal(consensus.AlleleSupport, 6785); Assert.Equal(consensus.GenotypeQscore, 100); Assert.Equal(consensus.Frequency, 0.98877877f); Assert.Equal(consensus.NoiseLevelApplied, ((int)expectedNoiseLevel)); Assert.Equal(consensus.NoiseLevelApplied, 5); Assert.Equal(consensus.StrandBiasResults.GATKBiasScore, -100); Assert.Equal(consensus.PoolBiasResults.GATKBiasScore, -100.0000); //now check, we take the min NL score if we are taking the min Q score. // (in this case of combined alt+ref -> ref, the q score will still need to be recalculated. //just with the MIN NL. SampleAggregationOptions.HowToCombineQScore = SampleAggregationParameters.CombineQScoreMethod.TakeMin; ComparisonCase = VennProcessor.GetComparisonCase(VarA, VarB); consensus = consensusBuilder.CombineVariants(VarA, VarB, ComparisonCase); Assert.Equal(consensus.NoiseLevelApplied, 2); Assert.Equal(consensus.VariantQscore, 100); //ok, now sanity check we dont barf if either input is null: ComparisonCase = VennProcessor.GetComparisonCase(VarA, null); consensus = consensusBuilder.CombineVariants(VarA, null, ComparisonCase); Assert.Equal(consensus.NoiseLevelApplied, 35); Assert.Equal(consensus.VariantQscore, 100); ComparisonCase = VennProcessor.GetComparisonCase(null, VarB); consensus = consensusBuilder.CombineVariants(null, VarB, ComparisonCase); Assert.Equal(consensus.NoiseLevelApplied, 2); Assert.Equal(consensus.VariantQscore, 100); //ok, lets check this again, for the PoolQScores option. //sanity check we dont barf if either input is null: SampleAggregationOptions.HowToCombineQScore = SampleAggregationParameters.CombineQScoreMethod.CombinePoolsAndReCalculate; ComparisonCase = VennProcessor.GetComparisonCase(VarA, null); consensus = consensusBuilder.CombineVariants(VarA, null, ComparisonCase); Assert.Equal(consensus.NoiseLevelApplied, 35); Assert.Equal(consensus.VariantQscore, 100);//low freq variant -> nocall. note, qscore would be 41 if NL = 20. ComparisonCase = VennProcessor.GetComparisonCase(null, VarB); consensus = consensusBuilder.CombineVariants(null, VarB, ComparisonCase); Assert.Equal(consensus.NoiseLevelApplied, 2); Assert.Equal(consensus.VariantQscore, 100); //sold ref }
public void VennVcf_CombineTwoPoolVariants_Qscore_Test() { //Var A, kdot-43_S3.genome.vcf //chr3 41266161 . A G 30 PASS DP=3067 GT:GQ:AD:VF:NL:SB 0/1:30:3005,54:0.0176:35:-100.0000 CalledAllele VarA = new CalledAllele(); VarA.Chromosome = "chr3"; VarA.ReferencePosition = 41266161; VarA.TotalCoverage = 3067; VarA.Genotype = Pisces.Domain.Types.Genotype.HeterozygousAltRef; VarA.GenotypeQscore = 30; VarA.AlleleSupport = 54; VarA.ReferenceSupport = 3005; // "VF", "0.0176" VarA.NoiseLevelApplied = 35; VarA.StrandBiasResults = new Pisces.Domain.Models.BiasResults() { GATKBiasScore = -100 }; VarA.ReferenceAllele = "A"; VarA.AlternateAllele = "G"; VarA.Filters = new List <Pisces.Domain.Types.FilterType>(); VarA.VariantQscore = 30; VarA.Type = Pisces.Domain.Types.AlleleCategory.Snv; //Var B, kdot-43_S4.genome.vcf //chr3 41266161 . A . 75 PASS DP=3795 GT:GQ:AD:VF:NL:SB 0/0:75:3780:0.0040:35:-100.0000 CalledAllele VarB = new CalledAllele(); VarB.Chromosome = "chr3"; VarB.ReferencePosition = 41266161; VarB.TotalCoverage = 3795; VarB.Genotype = Pisces.Domain.Types.Genotype.HomozygousRef; VarB.GenotypeQscore = 75; VarB.AlleleSupport = 3780; VarB.ReferenceSupport = 3780; // "VF", "0.0040" VarB.NoiseLevelApplied = 35; VarB.StrandBiasResults = new Pisces.Domain.Models.BiasResults() { GATKBiasScore = -100 }; VarB.ReferenceAllele = "A"; VarB.AlternateAllele = "."; VarB.Filters = new List <Pisces.Domain.Types.FilterType>(); VarB.VariantQscore = 75; VarB.Type = Pisces.Domain.Types.AlleleCategory.Reference; //old answer //chr3 41266161 . A . 100.00 PASS DP=6862;cosmic=COSM1423020,COSM1423021;EVS=0|69.0|6503;phastCons GT:GQ:AD:VF:NL:SB:PB:GQX 0/0:100:6785:0.0079:35:-100:-100.0000:100 VennVcfOptions parameters = new VennVcfOptions(); parameters.VariantCallingParams.MinimumFrequencyFilter = 0.03f; parameters.VariantCallingParams.MinimumFrequency = 0.01f; parameters.BamFilterParams.MinimumBaseCallQuality = 20; parameters.SampleAggregationParameters.ProbePoolBiasThreshold = 0.5f; parameters.SampleAggregationParameters.HowToCombineQScore = SampleAggregationParameters.CombineQScoreMethod.TakeMin; VariantComparisonCase ComparisonCase = VennProcessor.GetComparisonCase(VarA, VarB); ConsensusBuilder consensusBuilder = new ConsensusBuilder("", parameters); AggregateAllele consensus = consensusBuilder.CombineVariants(VarA, VarB, ComparisonCase); //GT:GQ:AD:VF:NL:SB:PB:GQX 0/0:100:6785:0.0079:35:-100:-100.0000:100 Assert.NotNull(consensus); Assert.Equal(consensus.VariantQscore, 100); Assert.Equal(consensus.GenotypeQscore, 100); Assert.Equal(consensus.ReferenceAllele, "A"); Assert.Equal(consensus.AlternateAllele, "."); Assert.Equal(consensus.Genotype, Pisces.Domain.Types.Genotype.HomozygousRef); Assert.Equal(consensus.GenotypeQscore, 100); Assert.Equal(consensus.AlleleSupport, 6785); Assert.Equal(consensus.ReferenceSupport, 6785); Assert.Equal(consensus.TotalCoverage, 6862); Assert.Equal(consensus.Frequency, 0.98877, 4); Assert.Equal(consensus.NoiseLevelApplied, 35); Assert.Equal(consensus.StrandBiasResults.GATKBiasScore, -100); Assert.Equal(consensus.PoolBiasResults.GATKBiasScore, -100); }
private static void RecalculateScoring(CalledAllele VariantA, CalledAllele VariantB, VariantComparisonCase Case, AggregateAllele ConsensusAllele, SampleAggregationParameters SampleAggregationOptions, VariantCallingParameters variantCallingParameters) { int RefCountB = 0, RefCountA = 0; int AltCountB = 0, AltCountA = 0; int DepthA = 0; int DepthB = 0; //1) first, calculate all the component values (variant frequency, etc...) if (VariantA != null) { RefCountA = VariantA.ReferenceSupport; AltCountA = (VariantA.IsRefType) ? 0 : VariantA.AlleleSupport; DepthA = VariantA.TotalCoverage; } if (VariantB != null) { RefCountB = VariantB.ReferenceSupport; AltCountB = (VariantB.IsRefType) ? 0 : VariantB.AlleleSupport; DepthB = VariantB.TotalCoverage; } int TotalDepth = DepthA + DepthB; int ReferenceDepth = RefCountA + RefCountB; int AltDepth = AltCountA + AltCountB; double VarFrequency = ((AltDepth == 0) || (TotalDepth == 0)) ? 0.0 : ((double)AltDepth) / ((double)(TotalDepth)); double VarFrequencyA = ((AltCountA == 0) || (DepthA == 0)) ? 0.0 : ((double)AltCountA) / ((double)(DepthA)); double VarFrequencyB = ((AltCountB == 0) || (DepthB == 0)) ? 0.0 : ((double)AltCountB) / ((double)(DepthB)); ConsensusAllele.TotalCoverage = TotalDepth; ConsensusAllele.AlleleSupport = AltDepth; ConsensusAllele.ReferenceSupport = ReferenceDepth; var GT = GetGenotype(VariantA, VariantB, Case, TotalDepth, VarFrequency, VarFrequencyA, VarFrequencyB, SampleAggregationOptions, variantCallingParameters); ConsensusAllele.NoiseLevelApplied = GetCombinedNLValue(VariantA, VariantB, SampleAggregationOptions); ConsensusAllele.StrandBiasResults = GetCombinedSBValue(VariantA, VariantB, SampleAggregationOptions); //its possible the GTString went from var -> ref when we combined the results. //If that is the case we do not want to write "variant" anymore to the .vcf. //We also have to re-calculate the Q scores for a reference call. //They need to be based on a reference model, not a variant model. bool AltChangedToRef = PushThroughRamificationsOfGTChange(VariantA, VariantB, ConsensusAllele, RefCountA, RefCountB, DepthA, DepthB, GT, variantCallingParameters.MaximumVariantQScore, Case); ConsensusAllele.Genotype = GT; ConsensusAllele.PoolBiasResults = GetProbePoolBiasScore(Case, ConsensusAllele, SampleAggregationOptions.ProbePoolBiasThreshold, variantCallingParameters, AltCountA, AltCountB, DepthA, DepthB, GT, AltChangedToRef); if (SampleAggregationOptions.HowToCombineQScore == SampleAggregationParameters.CombineQScoreMethod.TakeMin) { ConsensusAllele.VariantQscore = CombineQualitiesByTakingMinValue(VariantA, VariantB); } else //VariantCallingCombinePoolSettings.CombineQScoreMethod.CombinePoolsAndReCalculate { //where we apply the reference Q model: if (Case == VariantComparisonCase.AgreedOnReference) { ConsensusAllele.VariantQscore = CombineQualitiesByPoolingReads(ReferenceDepth, TotalDepth, ConsensusAllele.NoiseLevelApplied, variantCallingParameters.MaximumVariantQScore); } else if ((Case == VariantComparisonCase.OneReferenceOneAlternate) && (AltChangedToRef)) { ConsensusAllele.VariantQscore = CombineQualitiesByPoolingReads(ReferenceDepth, TotalDepth, ConsensusAllele.NoiseLevelApplied, variantCallingParameters.MaximumVariantQScore); } else if ((Case == VariantComparisonCase.CanNotCombine) && (AltDepth == 0)) //so the only call we had must have been ref { ConsensusAllele.VariantQscore = CombineQualitiesByPoolingReads(ReferenceDepth, TotalDepth, ConsensusAllele.NoiseLevelApplied, variantCallingParameters.MaximumVariantQScore); } //where we apply the variant Q model. this is most cases else // cases are aggreed on alt, or one alt call. in which case, apply variant Q model. { ConsensusAllele.VariantQscore = CombineQualitiesByPoolingReads(AltDepth, TotalDepth, ConsensusAllele.NoiseLevelApplied, variantCallingParameters.MaximumVariantQScore); } } //assuming this is only used on Somatic... ConsensusAllele.GenotypeQscore = ConsensusAllele.VariantQscore; ConsensusAllele.SetType(); if (ConsensusAllele.IsRefType) { ConsensusAllele.AlleleSupport = ConsensusAllele.ReferenceSupport; } }