@Override
public Integer map(RefMetaDataTracker tracker, ReferenceContext ref, AlignmentContext context) {
// First, verify that the metadata tracker is not null (meaning there is a variant at this locus
// to process).
if (tracker != null) {
// Get all of the "VariantContext" objects that span this locus. A VariantContext represents
// a line in a VCF file.
Collection<VariantContext> vcs =
tracker.getVariantContexts(ref, "variant", null, context.getLocation(), true, false);
// There may be more than one variant at this locus. Process them all.
for (VariantContext vc : vcs) {
out.println(
"Hello, ref="
+ vc.getReference()
+ ",alt="
+ vc.getAltAlleleWithHighestAlleleCount()
+ " at "
+ vc.getChr()
+ ":"
+ vc.getStart());
}
// Return 1, indicating that we saw a variant.
return 1;
}
// We saw nothing of interest, so return 0.
return 0;
}
@Override
public String toString() {
return String.format(
"ExactCall %s:%d alleles=%s nSamples=%s orig.pNonRef=%.2f orig.runtime=%s",
vc.getChr(),
vc.getStart(),
vc.getAlleles(),
vc.getNSamples(),
originalCall.getLog10PosteriorOfAFGT0(),
new AutoFormattingTime(runtime / 1e9).toString());
}
@Requires({
"vc != null",
"variable != null",
"key != null",
"value != null",
"callReport != null"
})
private void printCallElement(
final VariantContext vc, final Object variable, final Object key, final Object value) {
final String loc = String.format("%s:%d", vc.getChr(), vc.getStart());
callReport.println(Utils.join("\t", Arrays.asList(loc, variable, key, value)));
}
private static Allele determineReferenceAllele(List<VariantContext> VCs) {
Allele ref = null;
for (VariantContext vc : VCs) {
Allele myRef = vc.getReference();
if (ref == null || ref.length() < myRef.length()) ref = myRef;
else if (ref.length() == myRef.length() && !ref.equals(myRef))
throw new UserException.BadInput(
String.format(
"The provided variant file(s) have inconsistent references for the same position(s) at %s:%d, %s vs. %s",
vc.getChr(), vc.getStart(), ref, myRef));
}
return ref;
}
/**
* Copy constructor
*
* @param other the VariantContext to copy
*/
protected VariantContext(VariantContext other) {
this(
other.getSource(),
other.getID(),
other.getChr(),
other.getStart(),
other.getEnd(),
other.getAlleles(),
other.getGenotypes(),
other.getLog10PError(),
other.getFiltersMaybeNull(),
other.getAttributes(),
other.REFERENCE_BASE_FOR_INDEL,
NO_VALIDATION);
}
/**
* add a record to the file
*
* @param vc the Variant Context object
* @param refBase the ref base used for indels
* @param refBaseShouldBeAppliedToEndOfAlleles *** THIS SHOULD BE FALSE EXCEPT FOR AN INDEL AT THE
* EXTREME BEGINNING OF A CONTIG (WHERE THERE IS NO PREVIOUS BASE, SO WE USE THE BASE AFTER
* THE EVENT INSTEAD)
*/
public void add(VariantContext vc, byte refBase, boolean refBaseShouldBeAppliedToEndOfAlleles) {
if (mHeader == null)
throw new IllegalStateException(
"The VCF Header must be written before records can be added: " + locationString());
if (doNotWriteGenotypes) vc = VariantContext.modifyGenotypes(vc, null);
try {
vc =
VariantContext.createVariantContextWithPaddedAlleles(
vc, refBase, refBaseShouldBeAppliedToEndOfAlleles);
// if we are doing on the fly indexing, add the record ***before*** we write any bytes
if (indexer != null) indexer.addFeature(vc, positionalStream.getPosition());
Map<Allele, String> alleleMap = new HashMap<Allele, String>(vc.getAlleles().size());
alleleMap.put(Allele.NO_CALL, VCFConstants.EMPTY_ALLELE); // convenience for lookup
// CHROM
mWriter.write(vc.getChr());
mWriter.write(VCFConstants.FIELD_SEPARATOR);
// POS
mWriter.write(String.valueOf(vc.getStart()));
mWriter.write(VCFConstants.FIELD_SEPARATOR);
// ID
String ID = vc.hasID() ? vc.getID() : VCFConstants.EMPTY_ID_FIELD;
mWriter.write(ID);
mWriter.write(VCFConstants.FIELD_SEPARATOR);
// REF
alleleMap.put(vc.getReference(), "0");
String refString = vc.getReference().getDisplayString();
mWriter.write(refString);
mWriter.write(VCFConstants.FIELD_SEPARATOR);
// ALT
if (vc.isVariant()) {
Allele altAllele = vc.getAlternateAllele(0);
alleleMap.put(altAllele, "1");
String alt = altAllele.getDisplayString();
mWriter.write(alt);
for (int i = 1; i < vc.getAlternateAlleles().size(); i++) {
altAllele = vc.getAlternateAllele(i);
alleleMap.put(altAllele, String.valueOf(i + 1));
alt = altAllele.getDisplayString();
mWriter.write(",");
mWriter.write(alt);
}
} else {
mWriter.write(VCFConstants.EMPTY_ALTERNATE_ALLELE_FIELD);
}
mWriter.write(VCFConstants.FIELD_SEPARATOR);
// QUAL
if (!vc.hasNegLog10PError()) mWriter.write(VCFConstants.MISSING_VALUE_v4);
else mWriter.write(getQualValue(vc.getPhredScaledQual()));
mWriter.write(VCFConstants.FIELD_SEPARATOR);
// FILTER
String filters =
vc.isFiltered()
? ParsingUtils.join(";", ParsingUtils.sortList(vc.getFilters()))
: (filtersWereAppliedToContext || vc.filtersWereApplied()
? VCFConstants.PASSES_FILTERS_v4
: VCFConstants.UNFILTERED);
mWriter.write(filters);
mWriter.write(VCFConstants.FIELD_SEPARATOR);
// INFO
Map<String, String> infoFields = new TreeMap<String, String>();
for (Map.Entry<String, Object> field : vc.getAttributes().entrySet()) {
String key = field.getKey();
if (key.equals(VariantContext.ID_KEY)
|| key.equals(VariantContext.REFERENCE_BASE_FOR_INDEL_KEY)
|| key.equals(VariantContext.UNPARSED_GENOTYPE_MAP_KEY)
|| key.equals(VariantContext.UNPARSED_GENOTYPE_PARSER_KEY)) continue;
String outputValue = formatVCFField(field.getValue());
if (outputValue != null) infoFields.put(key, outputValue);
}
writeInfoString(infoFields);
// FORMAT
if (vc.hasAttribute(VariantContext.UNPARSED_GENOTYPE_MAP_KEY)) {
mWriter.write(VCFConstants.FIELD_SEPARATOR);
mWriter.write(vc.getAttributeAsString(VariantContext.UNPARSED_GENOTYPE_MAP_KEY, ""));
} else {
List<String> genotypeAttributeKeys = new ArrayList<String>();
if (vc.hasGenotypes()) {
genotypeAttributeKeys.addAll(calcVCFGenotypeKeys(vc));
} else if (mHeader.hasGenotypingData()) {
// this needs to be done in case all samples are no-calls
genotypeAttributeKeys.add(VCFConstants.GENOTYPE_KEY);
}
if (genotypeAttributeKeys.size() > 0) {
String genotypeFormatString =
ParsingUtils.join(VCFConstants.GENOTYPE_FIELD_SEPARATOR, genotypeAttributeKeys);
mWriter.write(VCFConstants.FIELD_SEPARATOR);
mWriter.write(genotypeFormatString);
addGenotypeData(vc, alleleMap, genotypeAttributeKeys);
}
}
mWriter.write("\n");
mWriter.flush(); // necessary so that writing to an output stream will work
} catch (IOException e) {
throw new RuntimeException("Unable to write the VCF object to " + locationString());
}
}
/**
* Subset VC record if necessary and emit the modified record (provided it satisfies criteria for
* printing)
*
* @param tracker the ROD tracker
* @param ref reference information
* @param context alignment info
* @return 1 if the record was printed to the output file, 0 if otherwise
*/
@Override
public Integer map(RefMetaDataTracker tracker, ReferenceContext ref, AlignmentContext context) {
if (tracker == null) return 0;
Collection<VariantContext> vcs =
tracker.getValues(variantCollection.variants, context.getLocation());
if (vcs == null || vcs.size() == 0) {
return 0;
}
for (VariantContext vc : vcs) {
if (MENDELIAN_VIOLATIONS) {
boolean foundMV = false;
for (MendelianViolation mv : mvSet) {
if (mv.isViolation(vc)) {
foundMV = true;
// System.out.println(vc.toString());
if (outMVFile != null)
outMVFileStream.format(
"MV@%s:%d. REF=%s, ALT=%s, AC=%d, momID=%s, dadID=%s, childID=%s, momG=%s, momGL=%s, dadG=%s, dadGL=%s, "
+ "childG=%s childGL=%s\n",
vc.getChr(),
vc.getStart(),
vc.getReference().getDisplayString(),
vc.getAlternateAllele(0).getDisplayString(),
vc.getChromosomeCount(vc.getAlternateAllele(0)),
mv.getSampleMom(),
mv.getSampleDad(),
mv.getSampleChild(),
vc.getGenotype(mv.getSampleMom()).toBriefString(),
vc.getGenotype(mv.getSampleMom()).getLikelihoods().getAsString(),
vc.getGenotype(mv.getSampleDad()).toBriefString(),
vc.getGenotype(mv.getSampleMom()).getLikelihoods().getAsString(),
vc.getGenotype(mv.getSampleChild()).toBriefString(),
vc.getGenotype(mv.getSampleChild()).getLikelihoods().getAsString());
}
}
if (!foundMV) break;
}
if (DISCORDANCE_ONLY) {
Collection<VariantContext> compVCs =
tracker.getValues(discordanceTrack, context.getLocation());
if (!isDiscordant(vc, compVCs)) return 0;
}
if (CONCORDANCE_ONLY) {
Collection<VariantContext> compVCs =
tracker.getValues(concordanceTrack, context.getLocation());
if (!isConcordant(vc, compVCs)) return 0;
}
if (alleleRestriction.equals(NumberAlleleRestriction.BIALLELIC) && !vc.isBiallelic())
continue;
if (alleleRestriction.equals(NumberAlleleRestriction.MULTIALLELIC) && vc.isBiallelic())
continue;
if (!selectedTypes.contains(vc.getType())) continue;
VariantContext sub = subsetRecord(vc, samples);
if ((sub.isPolymorphic() || !EXCLUDE_NON_VARIANTS)
&& (!sub.isFiltered() || !EXCLUDE_FILTERED)) {
for (VariantContextUtils.JexlVCMatchExp jexl : jexls) {
if (!VariantContextUtils.match(sub, jexl)) {
return 0;
}
}
if (SELECT_RANDOM_NUMBER) {
randomlyAddVariant(++variantNumber, sub, ref.getBase());
} else if (!SELECT_RANDOM_FRACTION
|| (GenomeAnalysisEngine.getRandomGenerator().nextDouble() < fractionRandom)) {
vcfWriter.add(sub);
}
}
}
return 1;
}
public static VariantContext createVariantContextWithPaddedAlleles(
VariantContext inputVC, boolean refBaseShouldBeAppliedToEndOfAlleles) {
// see if we need to pad common reference base from all alleles
boolean padVC;
// We need to pad a VC with a common base if the length of the reference allele is less than the
// length of the VariantContext.
// This happens because the position of e.g. an indel is always one before the actual event (as
// per VCF convention).
long locLength = (inputVC.getEnd() - inputVC.getStart()) + 1;
if (inputVC.hasSymbolicAlleles()) padVC = true;
else if (inputVC.getReference().length() == locLength) padVC = false;
else if (inputVC.getReference().length() == locLength - 1) padVC = true;
else
throw new IllegalArgumentException(
"Badly formed variant context at location "
+ String.valueOf(inputVC.getStart())
+ " in contig "
+ inputVC.getChr()
+ ". Reference length must be at most one base shorter than location size");
// nothing to do if we don't need to pad bases
if (padVC) {
if (!inputVC.hasReferenceBaseForIndel())
throw new ReviewedStingException(
"Badly formed variant context at location "
+ inputVC.getChr()
+ ":"
+ inputVC.getStart()
+ "; no padded reference base is available.");
Byte refByte = inputVC.getReferenceBaseForIndel();
List<Allele> alleles = new ArrayList<Allele>();
for (Allele a : inputVC.getAlleles()) {
// get bases for current allele and create a new one with trimmed bases
if (a.isSymbolic()) {
alleles.add(a);
} else {
String newBases;
if (refBaseShouldBeAppliedToEndOfAlleles)
newBases = a.getBaseString() + new String(new byte[] {refByte});
else newBases = new String(new byte[] {refByte}) + a.getBaseString();
alleles.add(Allele.create(newBases, a.isReference()));
}
}
// now we can recreate new genotypes with trimmed alleles
GenotypesContext genotypes = GenotypesContext.create(inputVC.getNSamples());
for (final Genotype g : inputVC.getGenotypes()) {
List<Allele> inAlleles = g.getAlleles();
List<Allele> newGenotypeAlleles = new ArrayList<Allele>(g.getAlleles().size());
for (Allele a : inAlleles) {
if (a.isCalled()) {
if (a.isSymbolic()) {
newGenotypeAlleles.add(a);
} else {
String newBases;
if (refBaseShouldBeAppliedToEndOfAlleles)
newBases = a.getBaseString() + new String(new byte[] {refByte});
else newBases = new String(new byte[] {refByte}) + a.getBaseString();
newGenotypeAlleles.add(Allele.create(newBases, a.isReference()));
}
} else {
// add no-call allele
newGenotypeAlleles.add(Allele.NO_CALL);
}
}
genotypes.add(
new Genotype(
g.getSampleName(),
newGenotypeAlleles,
g.getLog10PError(),
g.getFilters(),
g.getAttributes(),
g.isPhased()));
}
return new VariantContextBuilder(inputVC).alleles(alleles).genotypes(genotypes).make();
} else return inputVC;
}
/**
* create a genome location, given a variant context
*
* @param genomeLocParser parser
* @param vc the variant context
* @return the genomeLoc
*/
public static final GenomeLoc getLocation(GenomeLocParser genomeLocParser, VariantContext vc) {
return genomeLocParser.createGenomeLoc(vc.getChr(), vc.getStart(), vc.getEnd(), true);
}
static VariantContext reallyMergeIntoMNP(
VariantContext vc1, VariantContext vc2, ReferenceSequenceFile referenceFile) {
int startInter = vc1.getEnd() + 1;
int endInter = vc2.getStart() - 1;
byte[] intermediateBases = null;
if (startInter <= endInter) {
intermediateBases =
referenceFile.getSubsequenceAt(vc1.getChr(), startInter, endInter).getBases();
StringUtil.toUpperCase(intermediateBases);
}
MergedAllelesData mergeData =
new MergedAllelesData(
intermediateBases, vc1, vc2); // ensures that the reference allele is added
GenotypesContext mergedGenotypes = GenotypesContext.create();
for (final Genotype gt1 : vc1.getGenotypes()) {
Genotype gt2 = vc2.getGenotype(gt1.getSampleName());
List<Allele> site1Alleles = gt1.getAlleles();
List<Allele> site2Alleles = gt2.getAlleles();
List<Allele> mergedAllelesForSample = new LinkedList<Allele>();
/* NOTE: Since merged alleles are added to mergedAllelesForSample in the SAME order as in the input VC records,
we preserve phase information (if any) relative to whatever precedes vc1:
*/
Iterator<Allele> all2It = site2Alleles.iterator();
for (Allele all1 : site1Alleles) {
Allele all2 = all2It.next(); // this is OK, since allSamplesAreMergeable()
Allele mergedAllele = mergeData.ensureMergedAllele(all1, all2);
mergedAllelesForSample.add(mergedAllele);
}
double mergedGQ = Math.max(gt1.getLog10PError(), gt2.getLog10PError());
Set<String> mergedGtFilters =
new HashSet<
String>(); // Since gt1 and gt2 were unfiltered, the Genotype remains unfiltered
Map<String, Object> mergedGtAttribs = new HashMap<String, Object>();
PhaseAndQuality phaseQual = calcPhaseForMergedGenotypes(gt1, gt2);
if (phaseQual.PQ != null) mergedGtAttribs.put(ReadBackedPhasingWalker.PQ_KEY, phaseQual.PQ);
Genotype mergedGt =
new Genotype(
gt1.getSampleName(),
mergedAllelesForSample,
mergedGQ,
mergedGtFilters,
mergedGtAttribs,
phaseQual.isPhased);
mergedGenotypes.add(mergedGt);
}
String mergedName = mergeVariantContextNames(vc1.getSource(), vc2.getSource());
double mergedLog10PError = Math.min(vc1.getLog10PError(), vc2.getLog10PError());
Set<String> mergedFilters =
new HashSet<
String>(); // Since vc1 and vc2 were unfiltered, the merged record remains unfiltered
Map<String, Object> mergedAttribs = mergeVariantContextAttributes(vc1, vc2);
// ids
List<String> mergedIDs = new ArrayList<String>();
if (vc1.hasID()) mergedIDs.add(vc1.getID());
if (vc2.hasID()) mergedIDs.add(vc2.getID());
String mergedID =
mergedIDs.isEmpty()
? VCFConstants.EMPTY_ID_FIELD
: Utils.join(VCFConstants.ID_FIELD_SEPARATOR, mergedIDs);
VariantContextBuilder mergedBuilder =
new VariantContextBuilder(
mergedName,
vc1.getChr(),
vc1.getStart(),
vc2.getEnd(),
mergeData.getAllMergedAlleles())
.id(mergedID)
.genotypes(mergedGenotypes)
.log10PError(mergedLog10PError)
.filters(mergedFilters)
.attributes(mergedAttribs);
VariantContextUtils.calculateChromosomeCounts(mergedBuilder, true);
return mergedBuilder.make();
}