/**
* Returns a context identical to this with the REF and ALT alleles reverse complemented.
*
* @param vc variant context
* @return new vc
*/
public static VariantContext reverseComplement(VariantContext vc) {
// create a mapping from original allele to reverse complemented allele
HashMap<Allele, Allele> alleleMap = new HashMap<Allele, Allele>(vc.getAlleles().size());
for (Allele originalAllele : vc.getAlleles()) {
Allele newAllele;
if (originalAllele.isNoCall() || originalAllele.isNull()) newAllele = originalAllele;
else
newAllele =
Allele.create(
BaseUtils.simpleReverseComplement(originalAllele.getBases()),
originalAllele.isReference());
alleleMap.put(originalAllele, newAllele);
}
// create new Genotype objects
GenotypesContext newGenotypes = GenotypesContext.create(vc.getNSamples());
for (final Genotype genotype : vc.getGenotypes()) {
List<Allele> newAlleles = new ArrayList<Allele>();
for (Allele allele : genotype.getAlleles()) {
Allele newAllele = alleleMap.get(allele);
if (newAllele == null) newAllele = Allele.NO_CALL;
newAlleles.add(newAllele);
}
newGenotypes.add(Genotype.modifyAlleles(genotype, newAlleles));
}
return new VariantContextBuilder(vc).alleles(alleleMap.values()).genotypes(newGenotypes).make();
}
private Allele ensureMergedAllele(
Allele all1, Allele all2, boolean creatingReferenceForFirstTime) {
AlleleOneAndTwo all12 = new AlleleOneAndTwo(all1, all2);
Allele mergedAllele = mergedAlleles.get(all12);
if (mergedAllele == null) {
byte[] bases1 = all1.getBases();
byte[] bases2 = all2.getBases();
byte[] mergedBases = new byte[bases1.length + intermediateLength + bases2.length];
System.arraycopy(bases1, 0, mergedBases, 0, bases1.length);
if (intermediateBases != null)
System.arraycopy(intermediateBases, 0, mergedBases, bases1.length, intermediateLength);
System.arraycopy(bases2, 0, mergedBases, bases1.length + intermediateLength, bases2.length);
mergedAllele = Allele.create(mergedBases, creatingReferenceForFirstTime);
mergedAlleles.put(all12, mergedAllele);
}
return mergedAllele;
}
private static AlleleMapper resolveIncompatibleAlleles(
Allele refAllele, VariantContext vc, Set<Allele> allAlleles) {
if (refAllele.equals(vc.getReference())) return new AlleleMapper(vc);
else {
// we really need to do some work. The refAllele is the longest reference allele seen at this
// start site. So imagine it is:
//
// refAllele: ACGTGA
// myRef: ACGT
// myAlt: -
//
// We need to remap all of the alleles in vc to include the extra GA so that
// myRef => refAllele and myAlt => GA
//
Allele myRef = vc.getReference();
if (refAllele.length() <= myRef.length())
throw new ReviewedStingException(
"BUG: myRef=" + myRef + " is longer than refAllele=" + refAllele);
byte[] extraBases =
Arrays.copyOfRange(refAllele.getBases(), myRef.length(), refAllele.length());
// System.out.printf("Remapping allele at %s%n", vc);
// System.out.printf("ref %s%n", refAllele);
// System.out.printf("myref %s%n", myRef );
// System.out.printf("extrabases %s%n", new String(extraBases));
Map<Allele, Allele> map = new HashMap<Allele, Allele>();
for (Allele a : vc.getAlleles()) {
if (a.isReference()) map.put(a, refAllele);
else {
Allele extended = Allele.extend(a, extraBases);
for (Allele b : allAlleles) if (extended.equals(b)) extended = b;
// System.out.printf(" Extending %s => %s%n", a, extended);
map.put(a, extended);
}
}
// debugging
// System.out.printf("mapping %s%n", map);
return new AlleleMapper(map);
}
}
public static VariantContext createVariantContextWithTrimmedAlleles(VariantContext inputVC) {
// see if we need to trim common reference base from all alleles
boolean trimVC;
// We need to trim common reference base from all alleles in all genotypes if a ref base is
// common to all alleles
Allele refAllele = inputVC.getReference();
if (!inputVC.isVariant()) trimVC = false;
else if (refAllele.isNull()) trimVC = false;
else {
trimVC =
(AbstractVCFCodec.computeForwardClipping(
new ArrayList<Allele>(inputVC.getAlternateAlleles()),
inputVC.getReference().getDisplayString())
> 0);
}
// nothing to do if we don't need to trim bases
if (trimVC) {
List<Allele> alleles = new ArrayList<Allele>();
GenotypesContext genotypes = GenotypesContext.create();
// set the reference base for indels in the attributes
Map<String, Object> attributes = new TreeMap<String, Object>(inputVC.getAttributes());
Map<Allele, Allele> originalToTrimmedAlleleMap = new HashMap<Allele, Allele>();
for (Allele a : inputVC.getAlleles()) {
if (a.isSymbolic()) {
alleles.add(a);
originalToTrimmedAlleleMap.put(a, a);
} else {
// get bases for current allele and create a new one with trimmed bases
byte[] newBases = Arrays.copyOfRange(a.getBases(), 1, a.length());
Allele trimmedAllele = Allele.create(newBases, a.isReference());
alleles.add(trimmedAllele);
originalToTrimmedAlleleMap.put(a, trimmedAllele);
}
}
// detect case where we're trimming bases but resulting vc doesn't have any null allele. In
// that case, we keep original representation
// example: mixed records such as {TA*,TGA,TG}
boolean hasNullAlleles = false;
for (Allele a : originalToTrimmedAlleleMap.values()) {
if (a.isNull()) hasNullAlleles = true;
if (a.isReference()) refAllele = a;
}
if (!hasNullAlleles) return inputVC;
// now we can recreate new genotypes with trimmed alleles
for (final Genotype genotype : inputVC.getGenotypes()) {
List<Allele> originalAlleles = genotype.getAlleles();
List<Allele> trimmedAlleles = new ArrayList<Allele>();
for (Allele a : originalAlleles) {
if (a.isCalled()) trimmedAlleles.add(originalToTrimmedAlleleMap.get(a));
else trimmedAlleles.add(Allele.NO_CALL);
}
genotypes.add(Genotype.modifyAlleles(genotype, trimmedAlleles));
}
final VariantContextBuilder builder = new VariantContextBuilder(inputVC);
return builder
.alleles(alleles)
.genotypes(genotypes)
.attributes(attributes)
.referenceBaseForIndel(new Byte(inputVC.getReference().getBases()[0]))
.make();
}
return inputVC;
}
public static boolean isTransversion(Allele ref, Allele alt) {
return BaseUtils.SNPSubstitutionType(ref.getBases()[0], alt.getBases()[0])
== BaseUtils.BaseSubstitutionType.TRANSVERSION;
}