public void validateReferenceBases(Allele reference, Byte paddedRefBase) {
if (reference == null) return;
// don't validate if we're a complex event
if (!isComplexIndel() && !reference.isNull() && !reference.basesMatch(getReference())) {
throw new TribbleException.InternalCodecException(
String.format(
"the REF allele is incorrect for the record at position %s:%d, fasta says %s vs. VCF says %s",
getChr(), getStart(), reference.getBaseString(), getReference().getBaseString()));
}
// we also need to validate the padding base for simple indels
if (hasReferenceBaseForIndel() && !getReferenceBaseForIndel().equals(paddedRefBase)) {
throw new TribbleException.InternalCodecException(
String.format(
"the padded REF base is incorrect for the record at position %s:%d, fasta says %s vs. VCF says %s",
getChr(),
getStart(),
(char) paddedRefBase.byteValue(),
(char) getReferenceBaseForIndel().byteValue()));
}
}
public void writeBeagleOutput(
VariantContext preferredVC, VariantContext otherVC, boolean isValidationSite, double prior) {
GenomeLoc currentLoc =
VariantContextUtils.getLocation(getToolkit().getGenomeLocParser(), preferredVC);
StringBuffer beagleOut = new StringBuffer();
String marker = String.format("%s:%d ", currentLoc.getContig(), currentLoc.getStart());
beagleOut.append(marker);
if (markers != null)
markers.append(marker).append("\t").append(Integer.toString(markerCounter++)).append("\t");
for (Allele allele : preferredVC.getAlleles()) {
String bglPrintString;
if (allele.isNoCall() || allele.isNull()) bglPrintString = "-";
else bglPrintString = allele.getBaseString(); // get rid of * in case of reference allele
beagleOut.append(String.format("%s ", bglPrintString));
if (markers != null) markers.append(bglPrintString).append("\t");
}
if (markers != null) markers.append("\n");
GenotypesContext preferredGenotypes = preferredVC.getGenotypes();
GenotypesContext otherGenotypes = goodSite(otherVC) ? otherVC.getGenotypes() : null;
for (String sample : samples) {
boolean isMaleOnChrX = CHECK_IS_MALE_ON_CHR_X && getSample(sample).getGender() == Gender.MALE;
Genotype genotype;
boolean isValidation;
// use sample as key into genotypes structure
if (preferredGenotypes.containsSample(sample)) {
genotype = preferredGenotypes.get(sample);
isValidation = isValidationSite;
} else if (otherGenotypes != null && otherGenotypes.containsSample(sample)) {
genotype = otherGenotypes.get(sample);
isValidation = !isValidationSite;
} else {
// there is magically no genotype for this sample.
throw new StingException(
"Sample "
+ sample
+ " arose with no genotype in variant or validation VCF. This should never happen.");
}
/*
* Use likelihoods if: is validation, prior is negative; or: is not validation, has genotype key
*/
double[] log10Likelihoods = null;
if ((isValidation && prior < 0.0) || genotype.hasLikelihoods()) {
log10Likelihoods = genotype.getLikelihoods().getAsVector();
// see if we need to randomly mask out genotype in this position.
if (GenomeAnalysisEngine.getRandomGenerator().nextDouble() <= insertedNoCallRate) {
// we are masking out this genotype
log10Likelihoods =
isMaleOnChrX ? HAPLOID_FLAT_LOG10_LIKELIHOODS : DIPLOID_FLAT_LOG10_LIKELIHOODS;
}
if (isMaleOnChrX) {
log10Likelihoods[1] = -255; // todo -- warning this is dangerous for multi-allele case
}
}
/** otherwise, use the prior uniformly */
else if (!isValidation && genotype.isCalled() && !genotype.hasLikelihoods()) {
// hack to deal with input VCFs with no genotype likelihoods. Just assume the called
// genotype
// is confident. This is useful for Hapmap and 1KG release VCFs.
double AA = (1.0 - prior) / 2.0;
double AB = (1.0 - prior) / 2.0;
double BB = (1.0 - prior) / 2.0;
if (genotype.isHomRef()) {
AA = prior;
} else if (genotype.isHet()) {
AB = prior;
} else if (genotype.isHomVar()) {
BB = prior;
}
log10Likelihoods = MathUtils.toLog10(new double[] {AA, isMaleOnChrX ? 0.0 : AB, BB});
} else {
log10Likelihoods =
isMaleOnChrX ? HAPLOID_FLAT_LOG10_LIKELIHOODS : DIPLOID_FLAT_LOG10_LIKELIHOODS;
}
writeSampleLikelihoods(beagleOut, preferredVC, log10Likelihoods);
}
beagleWriter.println(beagleOut.toString());
}
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;
}
