private Map<String, AlignmentContext> getFilteredAndStratifiedContexts(
UnifiedArgumentCollection UAC,
ReferenceContext refContext,
AlignmentContext rawContext,
final GenotypeLikelihoodsCalculationModel.Model model) {
if (!BaseUtils.isRegularBase(refContext.getBase())) return null;
Map<String, AlignmentContext> stratifiedContexts = null;
if (model.name().contains("INDEL")) {
final ReadBackedPileup pileup =
rawContext.getBasePileup().getMappingFilteredPileup(UAC.MIN_BASE_QUALTY_SCORE);
// don't call when there is no coverage
if (pileup.getNumberOfElements() == 0 && UAC.OutputMode != OUTPUT_MODE.EMIT_ALL_SITES)
return null;
// stratify the AlignmentContext and cut by sample
stratifiedContexts = AlignmentContextUtils.splitContextBySampleName(pileup);
} else if (model.name().contains("SNP")) {
// stratify the AlignmentContext and cut by sample
stratifiedContexts =
AlignmentContextUtils.splitContextBySampleName(rawContext.getBasePileup());
if (!(UAC.OutputMode == OUTPUT_MODE.EMIT_ALL_SITES
&& UAC.GenotypingMode
!= GenotypeLikelihoodsCalculationModel.GENOTYPING_MODE.GENOTYPE_GIVEN_ALLELES)) {
int numDeletions = 0;
for (final PileupElement p : rawContext.getBasePileup()) {
if (p.isDeletion()) numDeletions++;
}
if (((double) numDeletions) / ((double) rawContext.getBasePileup().getNumberOfElements())
> UAC.MAX_DELETION_FRACTION) {
return null;
}
}
}
return stratifiedContexts;
}
private VariantCallContext generateEmptyContext(
RefMetaDataTracker tracker,
ReferenceContext ref,
Map<String, AlignmentContext> stratifiedContexts,
AlignmentContext rawContext) {
VariantContext vc;
if (UAC.GenotypingMode
== GenotypeLikelihoodsCalculationModel.GENOTYPING_MODE.GENOTYPE_GIVEN_ALLELES) {
VariantContext vcInput =
UnifiedGenotyperEngine.getVCFromAllelesRod(
tracker, ref, rawContext.getLocation(), false, logger, UAC.alleles);
if (vcInput == null) return null;
vc =
new VariantContextBuilder(
"UG_call",
ref.getLocus().getContig(),
vcInput.getStart(),
vcInput.getEnd(),
vcInput.getAlleles())
.make();
} else {
// deal with bad/non-standard reference bases
if (!Allele.acceptableAlleleBases(new byte[] {ref.getBase()})) return null;
Set<Allele> alleles = new HashSet<Allele>();
alleles.add(Allele.create(ref.getBase(), true));
vc =
new VariantContextBuilder(
"UG_call",
ref.getLocus().getContig(),
ref.getLocus().getStart(),
ref.getLocus().getStart(),
alleles)
.make();
}
if (annotationEngine != null) {
// Note: we want to use the *unfiltered* and *unBAQed* context for the annotations
final ReadBackedPileup pileup = rawContext.getBasePileup();
stratifiedContexts = AlignmentContextUtils.splitContextBySampleName(pileup);
vc = annotationEngine.annotateContext(tracker, ref, stratifiedContexts, vc);
}
return new VariantCallContext(vc, false);
}
/**
* Main entry function to calculate genotypes of a given VC with corresponding GL's
*
* @param tracker Tracker
* @param refContext Reference context
* @param rawContext Raw context
* @param stratifiedContexts Stratified alignment contexts
* @param vc Input VC
* @param model GL calculation model
* @param inheritAttributesFromInputVC Output VC will contain attributes inherited from input vc
* @return VC with assigned genotypes
*/
public VariantCallContext calculateGenotypes(
final RefMetaDataTracker tracker,
final ReferenceContext refContext,
final AlignmentContext rawContext,
Map<String, AlignmentContext> stratifiedContexts,
final VariantContext vc,
final GenotypeLikelihoodsCalculationModel.Model model,
final boolean inheritAttributesFromInputVC,
final Map<String, org.broadinstitute.sting.utils.genotyper.PerReadAlleleLikelihoodMap>
perReadAlleleLikelihoodMap) {
boolean limitedContext =
tracker == null || refContext == null || rawContext == null || stratifiedContexts == null;
// initialize the data for this thread if that hasn't been done yet
if (afcm.get() == null) {
afcm.set(AFCalcFactory.createAFCalc(UAC, N, logger));
}
// estimate our confidence in a reference call and return
if (vc.getNSamples() == 0) {
if (limitedContext) return null;
return (UAC.OutputMode != OUTPUT_MODE.EMIT_ALL_SITES
? estimateReferenceConfidence(vc, stratifiedContexts, getTheta(model), false, 1.0)
: generateEmptyContext(tracker, refContext, stratifiedContexts, rawContext));
}
AFCalcResult AFresult = afcm.get().getLog10PNonRef(vc, getAlleleFrequencyPriors(model));
// is the most likely frequency conformation AC=0 for all alternate alleles?
boolean bestGuessIsRef = true;
// determine which alternate alleles have AF>0
final List<Allele> myAlleles = new ArrayList<Allele>(vc.getAlleles().size());
final List<Integer> alleleCountsofMLE = new ArrayList<Integer>(vc.getAlleles().size());
myAlleles.add(vc.getReference());
for (int i = 0; i < AFresult.getAllelesUsedInGenotyping().size(); i++) {
final Allele alternateAllele = AFresult.getAllelesUsedInGenotyping().get(i);
if (alternateAllele.isReference()) continue;
// we are non-ref if the probability of being non-ref > the emit confidence.
// the emit confidence is phred-scaled, say 30 => 10^-3.
// the posterior AF > 0 is log10: -5 => 10^-5
// we are non-ref if 10^-5 < 10^-3 => -5 < -3
final boolean isNonRef =
AFresult.isPolymorphic(alternateAllele, UAC.STANDARD_CONFIDENCE_FOR_EMITTING / -10.0);
// if the most likely AC is not 0, then this is a good alternate allele to use
if (isNonRef) {
myAlleles.add(alternateAllele);
alleleCountsofMLE.add(AFresult.getAlleleCountAtMLE(alternateAllele));
bestGuessIsRef = false;
}
// if in GENOTYPE_GIVEN_ALLELES mode, we still want to allow the use of a poor allele
else if (UAC.GenotypingMode
== GenotypeLikelihoodsCalculationModel.GENOTYPING_MODE.GENOTYPE_GIVEN_ALLELES) {
myAlleles.add(alternateAllele);
alleleCountsofMLE.add(AFresult.getAlleleCountAtMLE(alternateAllele));
}
}
final double PoFGT0 = Math.pow(10, AFresult.getLog10PosteriorOfAFGT0());
// note the math.abs is necessary because -10 * 0.0 => -0.0 which isn't nice
final double phredScaledConfidence =
Math.abs(
!bestGuessIsRef
|| UAC.GenotypingMode
== GenotypeLikelihoodsCalculationModel.GENOTYPING_MODE
.GENOTYPE_GIVEN_ALLELES
? -10 * AFresult.getLog10PosteriorOfAFEq0()
: -10 * AFresult.getLog10PosteriorOfAFGT0());
// return a null call if we don't pass the confidence cutoff or the most likely allele frequency
// is zero
if (UAC.OutputMode != OUTPUT_MODE.EMIT_ALL_SITES
&& !passesEmitThreshold(phredScaledConfidence, bestGuessIsRef)) {
// technically, at this point our confidence in a reference call isn't accurately estimated
// because it didn't take into account samples with no data, so let's get a better estimate
return limitedContext
? null
: estimateReferenceConfidence(vc, stratifiedContexts, getTheta(model), true, PoFGT0);
}
// start constructing the resulting VC
final GenomeLoc loc = genomeLocParser.createGenomeLoc(vc);
final VariantContextBuilder builder =
new VariantContextBuilder(
"UG_call", loc.getContig(), loc.getStart(), loc.getStop(), myAlleles);
builder.log10PError(phredScaledConfidence / -10.0);
if (!passesCallThreshold(phredScaledConfidence)) builder.filters(filter);
// create the genotypes
final GenotypesContext genotypes = afcm.get().subsetAlleles(vc, myAlleles, true, ploidy);
builder.genotypes(genotypes);
// print out stats if we have a writer
if (verboseWriter != null && !limitedContext)
printVerboseData(refContext.getLocus().toString(), vc, PoFGT0, phredScaledConfidence, model);
// *** note that calculating strand bias involves overwriting data structures, so we do that
// last
final HashMap<String, Object> attributes = new HashMap<String, Object>();
// inherit attributed from input vc if requested
if (inheritAttributesFromInputVC) attributes.putAll(vc.getAttributes());
// if the site was downsampled, record that fact
if (!limitedContext && rawContext.hasPileupBeenDownsampled())
attributes.put(VCFConstants.DOWNSAMPLED_KEY, true);
if (UAC.ANNOTATE_NUMBER_OF_ALLELES_DISCOVERED)
attributes.put(NUMBER_OF_DISCOVERED_ALLELES_KEY, vc.getAlternateAlleles().size());
// add the MLE AC and AF annotations
if (alleleCountsofMLE.size() > 0) {
attributes.put(VCFConstants.MLE_ALLELE_COUNT_KEY, alleleCountsofMLE);
final int AN = builder.make().getCalledChrCount();
final ArrayList<Double> MLEfrequencies = new ArrayList<Double>(alleleCountsofMLE.size());
// the MLEAC is allowed to be larger than the AN (e.g. in the case of all PLs being 0, the GT
// is ./. but the exact model may arbitrarily choose an AC>1)
for (int AC : alleleCountsofMLE) MLEfrequencies.add(Math.min(1.0, (double) AC / (double) AN));
attributes.put(VCFConstants.MLE_ALLELE_FREQUENCY_KEY, MLEfrequencies);
}
if (UAC.COMPUTE_SLOD && !limitedContext && !bestGuessIsRef) {
// final boolean DEBUG_SLOD = false;
// the overall lod
// double overallLog10PofNull = AFresult.log10AlleleFrequencyPosteriors[0];
double overallLog10PofF = AFresult.getLog10LikelihoodOfAFGT0();
// if ( DEBUG_SLOD ) System.out.println("overallLog10PofF=" + overallLog10PofF);
List<Allele> allAllelesToUse = builder.make().getAlleles();
// the forward lod
VariantContext vcForward =
calculateLikelihoods(
tracker,
refContext,
stratifiedContexts,
AlignmentContextUtils.ReadOrientation.FORWARD,
allAllelesToUse,
false,
model,
perReadAlleleLikelihoodMap);
AFresult = afcm.get().getLog10PNonRef(vcForward, getAlleleFrequencyPriors(model));
// double[] normalizedLog10Posteriors =
// MathUtils.normalizeFromLog10(AFresult.log10AlleleFrequencyPosteriors, true);
double forwardLog10PofNull = AFresult.getLog10LikelihoodOfAFEq0();
double forwardLog10PofF = AFresult.getLog10LikelihoodOfAFGT0();
// if ( DEBUG_SLOD ) System.out.println("forwardLog10PofNull=" + forwardLog10PofNull + ",
// forwardLog10PofF=" + forwardLog10PofF);
// the reverse lod
VariantContext vcReverse =
calculateLikelihoods(
tracker,
refContext,
stratifiedContexts,
AlignmentContextUtils.ReadOrientation.REVERSE,
allAllelesToUse,
false,
model,
perReadAlleleLikelihoodMap);
AFresult = afcm.get().getLog10PNonRef(vcReverse, getAlleleFrequencyPriors(model));
// normalizedLog10Posteriors =
// MathUtils.normalizeFromLog10(AFresult.log10AlleleFrequencyPosteriors, true);
double reverseLog10PofNull = AFresult.getLog10LikelihoodOfAFEq0();
double reverseLog10PofF = AFresult.getLog10LikelihoodOfAFGT0();
// if ( DEBUG_SLOD ) System.out.println("reverseLog10PofNull=" + reverseLog10PofNull + ",
// reverseLog10PofF=" + reverseLog10PofF);
double forwardLod = forwardLog10PofF + reverseLog10PofNull - overallLog10PofF;
double reverseLod = reverseLog10PofF + forwardLog10PofNull - overallLog10PofF;
// if ( DEBUG_SLOD ) System.out.println("forward lod=" + forwardLod + ", reverse lod=" +
// reverseLod);
// strand score is max bias between forward and reverse strands
double strandScore = Math.max(forwardLod, reverseLod);
// rescale by a factor of 10
strandScore *= 10.0;
// logger.debug(String.format("SLOD=%f", strandScore));
if (!Double.isNaN(strandScore)) attributes.put("SB", strandScore);
}
// finish constructing the resulting VC
builder.attributes(attributes);
VariantContext vcCall = builder.make();
// if we are subsetting alleles (either because there were too many or because some were not
// polymorphic)
// then we may need to trim the alleles (because the original VariantContext may have had to pad
// at the end).
if (myAlleles.size() != vc.getAlleles().size()
&& !limitedContext) // limitedContext callers need to handle allele trimming on their own to
// keep their perReadAlleleLikelihoodMap alleles in sync
vcCall = VariantContextUtils.reverseTrimAlleles(vcCall);
if (annotationEngine != null
&& !limitedContext) { // limitedContext callers need to handle annotations on their own by
// calling their own annotationEngine
// Note: we want to use the *unfiltered* and *unBAQed* context for the annotations
final ReadBackedPileup pileup = rawContext.getBasePileup();
stratifiedContexts = AlignmentContextUtils.splitContextBySampleName(pileup);
vcCall =
annotationEngine.annotateContext(
tracker, refContext, stratifiedContexts, vcCall, perReadAlleleLikelihoodMap);
}
return new VariantCallContext(vcCall, confidentlyCalled(phredScaledConfidence, PoFGT0));
}