/**
* For each variant in the file, determine the phasing for the child and replace the child's
* genotype with the trio's genotype
*
* @param tracker the reference meta-data tracker
* @param ref the reference context
* @param context the alignment context
* @return null
*/
@Override
public Integer map(RefMetaDataTracker tracker, ReferenceContext ref, AlignmentContext context) {
if (tracker != null) {
for (VariantContext vc :
tracker.getValues(variantCollection.variants, context.getLocation())) {
vc = vc.subContextFromSamples(samples);
if (!vc.isPolymorphicInSamples()) continue;
double log10pSomatic = calcLog10pSomatic(vc);
// write in the somatic status probability
Map<String, Object> attrs = new HashMap<String, Object>(); // vc.getAttributes());
if (!minimalVCF) attrs.putAll(vc.getAttributes());
attrs.put(SOMATIC_LOD_TAG_NAME, log10pSomatic);
if (log10pSomatic > somaticMinLOD) {
attrs.put(VCFConstants.SOMATIC_KEY, true);
attrs.put(SOMATIC_NONREF_TAG_NAME, calculateTumorNNR(vc));
attrs.put(SOMATIC_AC_TAG_NAME, calculateTumorAC(vc));
}
final VariantContextBuilder builder = new VariantContextBuilder(vc).attributes(attrs);
VariantContextUtils.calculateChromosomeCounts(builder, false);
VariantContext newvc = builder.make();
vcfWriter.add(newvc);
}
return null;
}
return null;
}
@Override
public CallableBaseState map(
RefMetaDataTracker tracker, ReferenceContext ref, AlignmentContext context) {
CalledState state;
if (BaseUtils.isNBase(ref.getBase())) {
state = CalledState.REF_N;
} else {
// count up the depths of all and QC+ bases
int rawDepth = 0, QCDepth = 0, lowMAPQDepth = 0;
for (PileupElement e : context.getBasePileup()) {
rawDepth++;
if (e.getMappingQual() <= maxLowMAPQ) lowMAPQDepth++;
if (e.getMappingQual() >= minMappingQuality
&& (e.getQual() >= minBaseQuality || e.isDeletion())) {
QCDepth++;
}
}
// System.out.printf("%s rawdepth = %d QCDepth = %d lowMAPQ = %d%n", context.getLocation(),
// rawDepth, QCDepth, lowMAPQDepth);
if (rawDepth == 0) {
state = CalledState.NO_COVERAGE;
} else if (rawDepth >= minDepthLowMAPQ
&& MathUtils.ratio(lowMAPQDepth, rawDepth) >= maxLowMAPQFraction) {
state = CalledState.POOR_MAPPING_QUALITY;
} else if (QCDepth < minDepth) {
state = CalledState.LOW_COVERAGE;
} else if (rawDepth >= maxDepth && maxDepth != -1) {
state = CalledState.EXCESSIVE_COVERAGE;
} else {
state = CalledState.CALLABLE;
}
}
return new CallableBaseState(getToolkit().getGenomeLocParser(), context.getLocation(), state);
}
/**
* For each site of interest, annotate based on the requested annotation types
*
* @param tracker the meta-data tracker
* @param ref the reference base
* @param context the context for the given locus
* @return 1 if the locus was successfully processed, 0 if otherwise
*/
public Integer map(RefMetaDataTracker tracker, ReferenceContext ref, AlignmentContext context) {
if (tracker == null) return 0;
// get the variant contexts for all the variants at the location
Collection<VariantContext> VCs =
tracker.getValues(variantCollection.variants, context.getLocation());
if (VCs.isEmpty()) return 0;
Collection<VariantContext> annotatedVCs = VCs;
// if the reference base is not ambiguous, we can annotate
Map<String, AlignmentContext> stratifiedContexts;
if (BaseUtils.simpleBaseToBaseIndex(ref.getBase()) != -1) {
stratifiedContexts = AlignmentContextUtils.splitContextBySampleName(context.getBasePileup());
annotatedVCs = new ArrayList<>(VCs.size());
for (VariantContext vc : VCs)
annotatedVCs.add(engine.annotateContext(tracker, ref, stratifiedContexts, vc));
}
for (VariantContext annotatedVC : annotatedVCs) vcfWriter.add(annotatedVC);
return 1;
}
public Integer map(RefMetaDataTracker tracker, ReferenceContext ref, AlignmentContext context) {
if (tracker == null) return 0;
final Collection<VariantContext> VCs = tracker.getValues(variants, context.getLocation());
if (VCs.size() == 0) return 0;
final VCcontext vc = new VCcontext(VariantContextUtils.sitesOnlyVariantContexts(VCs), ref);
// TODO -- what should we do about filtered records?
if (!queue.isEmpty()) {
final VCcontext previous = queue.getLast();
if (!previous.loc.onSameContig(vc.loc)
|| previous.loc.distance(vc.loc) > MAX_DISTANCE_BETWEEN_MERGED_RECORDS
|| queue.getFirst().loc.distance(vc.loc) > MAX_HAPLOTYPE_TO_CONSIDER) {
purgeQueue();
}
}
queue.addLast(vc);
return 0;
}
public Event map(RefMetaDataTracker tracker, ReferenceContext ref, AlignmentContext context) {
boolean hasIndel = false;
boolean hasInsertion = false;
boolean hasPointEvent = false;
int furthestStopPos = -1;
// look at the rods for indels or SNPs
if (tracker != null) {
for (VariantContext vc : tracker.getValues(known)) {
switch (vc.getType()) {
case INDEL:
hasIndel = true;
if (vc.isSimpleInsertion()) hasInsertion = true;
break;
case SNP:
hasPointEvent = true;
break;
case MIXED:
hasPointEvent = true;
hasIndel = true;
if (vc.isSimpleInsertion()) hasInsertion = true;
break;
default:
break;
}
if (hasIndel) furthestStopPos = vc.getEnd();
}
}
// look at the normal context to get deletions and positions with high entropy
final ReadBackedPileup pileup = context.getBasePileup();
int mismatchQualities = 0, totalQualities = 0;
final byte refBase = ref.getBase();
for (PileupElement p : pileup) {
// check the ends of the reads to see how far they extend
furthestStopPos = Math.max(furthestStopPos, p.getRead().getAlignmentEnd());
// is it a deletion or insertion?
if (p.isDeletion() || p.isBeforeInsertion()) {
hasIndel = true;
if (p.isBeforeInsertion()) hasInsertion = true;
}
// look for mismatches
else if (lookForMismatchEntropy) {
if (p.getBase() != refBase) mismatchQualities += p.getQual();
totalQualities += p.getQual();
}
}
// make sure we're supposed to look for high entropy
if (lookForMismatchEntropy
&& pileup.getNumberOfElements() >= minReadsAtLocus
&& (double) mismatchQualities / (double) totalQualities >= mismatchThreshold)
hasPointEvent = true;
// return null if no event occurred
if (!hasIndel && !hasPointEvent) return null;
// return null if we didn't find any usable reads/rods associated with the event
if (furthestStopPos == -1) return null;
GenomeLoc eventLoc = context.getLocation();
if (hasInsertion)
eventLoc =
getToolkit()
.getGenomeLocParser()
.createGenomeLoc(eventLoc.getContig(), eventLoc.getStart(), eventLoc.getStart() + 1);
EVENT_TYPE eventType =
(hasIndel
? (hasPointEvent ? EVENT_TYPE.BOTH : EVENT_TYPE.INDEL_EVENT)
: EVENT_TYPE.POINT_EVENT);
return new Event(eventLoc, furthestStopPos, eventType);
}
public CountedData map(
RefMetaDataTracker tracker, ReferenceContext ref, AlignmentContext context) {
final CountedData counter = new CountedData();
// For some reason RodWalkers get map calls with null trackers
if (tracker == null) return counter;
VariantContext vcComp = tracker.getFirstValue(alleles);
if (vcComp == null) return counter;
// todo - not sure I want this, may be misleading to filter extended indel events.
if (isInsideExtendedIndel(vcComp, ref)) return counter;
// Do not operate on variants that are not covered to the optional minimum depth
if (!context.hasReads()
|| (minDepth > 0 && context.getBasePileup().getBases().length < minDepth)) {
counter.nUncovered = 1L;
final GVstatus status = getGVstatus(vcComp);
if (status == GVstatus.T) counter.nAltNotCalled = 1L;
else if (status == GVstatus.F) counter.nRefNotCalled = 1L;
else counter.nNoStatusNotCalled = 1L;
return counter;
}
VariantCallContext call;
if (vcComp.isSNP()) {
call = snpEngine.calculateLikelihoodsAndGenotypes(tracker, ref, context).get(0);
} else if (vcComp.isIndel()) {
call = indelEngine.calculateLikelihoodsAndGenotypes(tracker, ref, context).get(0);
} else if (bamIsTruth) {
// assume it's a SNP if no variation is present; this is necessary so that we can test
// supposed monomorphic sites against the truth bam
call = snpEngine.calculateLikelihoodsAndGenotypes(tracker, ref, context).get(0);
} else {
logger.info(
"Not SNP or INDEL "
+ vcComp.getChr()
+ ":"
+ vcComp.getStart()
+ " "
+ vcComp.getAlleles());
return counter;
}
boolean writeVariant = true;
if (bamIsTruth) {
if (call.confidentlyCalled) {
// If truth is a confident REF call
if (call.isVariant()) {
if (vcComp.isVariant()) counter.nAltCalledAlt = 1L;
else {
counter.nAltCalledRef = 1L;
if (printInterestingSites)
System.out.println("Truth=ALT Call=REF at " + call.getChr() + ":" + call.getStart());
}
}
// If truth is a confident ALT call
else {
if (vcComp.isVariant()) {
counter.nRefCalledAlt = 1L;
if (printInterestingSites)
System.out.println("Truth=REF Call=ALT at " + call.getChr() + ":" + call.getStart());
} else counter.nRefCalledRef = 1L;
}
} else {
counter.nNotConfidentCalls = 1L;
if (printInterestingSites)
System.out.println("Truth is not confident at " + call.getChr() + ":" + call.getStart());
writeVariant = false;
}
} else {
// if (!vcComp.hasExtendedAttribute("GV"))
// throw new UserException.BadInput("Variant has no GV annotation in the INFO
// field. " + vcComp.getChr() + ":" + vcComp.getStart());
final GVstatus status = getGVstatus(vcComp);
if (call.isCalledAlt(callConf)) {
if (status == GVstatus.T) counter.nAltCalledAlt = 1L;
else if (status == GVstatus.F) {
counter.nRefCalledAlt = 1L;
if (printInterestingSites)
System.out.println("Truth=REF Call=ALT at " + call.getChr() + ":" + call.getStart());
} else counter.nNoStatusCalledAlt = 1L;
} else if (call.isCalledRef(callConf)) {
if (status == GVstatus.T) {
counter.nAltCalledRef = 1L;
if (printInterestingSites)
System.out.println("Truth=ALT Call=REF at " + call.getChr() + ":" + call.getStart());
} else if (status == GVstatus.F) counter.nRefCalledRef = 1L;
else counter.nNoStatusCalledRef = 1L;
} else {
counter.nNotConfidentCalls = 1L;
if (status == GVstatus.T) counter.nAltNotCalled = 1L;
else if (status == GVstatus.F) counter.nRefNotCalled = 1L;
else counter.nNoStatusNotCalled = 1L;
if (printInterestingSites)
System.out.println("Truth is not confident at " + call.getChr() + ":" + call.getStart());
writeVariant = false;
}
}
if (vcfWriter != null && writeVariant) {
if (!vcComp.hasAttribute(GATKVCFConstants.GENOTYPE_AND_VALIDATE_STATUS_KEY)) {
vcfWriter.add(
new VariantContextBuilder(vcComp)
.attribute(
GATKVCFConstants.GENOTYPE_AND_VALIDATE_STATUS_KEY,
call.isCalledAlt(callConf) ? "ALT" : "REF")
.make());
} else vcfWriter.add(vcComp);
}
return counter;
}