/** * Return all VariantTypes subtypes given a VariantType. * {@link VariantType} represents a hierarchical structure where SNV includes all SNP, MNV includes MNP * and SV includes INSERTION, DELETION, TRANSLOCATION, INVERSION and CNV * * @param variantType Variant Type * @return Set of subtypes */ public static Set<VariantType> subTypes(VariantType variantType) { if(variantType.equals(VariantType.SNV)) { return Collections.singleton(VariantType.SNP); } else if (variantType.equals(VariantType.MNV)) { return Collections.singleton(VariantType.MNP); } else if (variantType.equals(VariantType.SV)) { return SV_SUBTYPES; } else { return Collections.emptySet(); } }
private static int inferLengthSymbolic(VariantType type, String alternate, int start, int end) { int length; if (type.equals(VariantType.INSERTION)) { if (!Allele.wouldBeSymbolicAllele(alternate.getBytes())) { length = alternate.length(); } else { // TODO: Check attribute SVLEN? length = Variant.UNKNOWN_LENGTH; } } else if (type.equals(VariantType.BREAKEND) || type.equals(VariantType.TRANSLOCATION)) { length = Variant.UNKNOWN_LENGTH; // WARNING: breakends length set to UNKNOWN_LENGTH in any case - breakends shall // not be stored in the future translocations formed by 4 breakends must be parsed and managed // instead } else { length = end - start + 1; } return length; }
public VariantAvroFilters addTypeFilter(VariantType variantType) { filters.add(variant -> variant.getType().equals(variantType)); return this; }
public static boolean validVariant(Variant variant) { return !variant.getType().equals(VariantType.NO_VARIATION); }
private boolean allSameTypeAndGT(Collection<Variant> conflicts, VariantType type) { boolean differentType = conflicts.stream().filter(v -> !v.getType().equals(type)).findAny().isPresent(); if (differentType) { return false; } StudyEntry studyEntry = conflicts.stream().findAny().get().getStudies().get(0); String sample = studyEntry.getSamplesName().stream().findFirst().get(); String gt = studyEntry.getSampleData(sample, GENOTYPE_KEY); long count = conflicts.stream().filter(v -> v.getType().equals(type) && StringUtils.equals(gt, v.getStudies().get(0).getSampleData(sample, GENOTYPE_KEY))).count(); return ((int) count) == conflicts.size(); }
private void isValidVariant(Variant current) throws IllegalArgumentException{ if (current.getType().equals(VariantType.NO_VARIATION)) { throw new IllegalStateException("Current variant can't be a NO_VARIANT"); } // Validate variant information // ensureGtFormat(current); if (getStudy(current).getFormat() == null || getStudy(current).getFormat().isEmpty()) { throw new IllegalArgumentException("Format of sample data is empty!!!!!!"); } }
private boolean potentialCodingSNVOverlap(Variant variant1, Variant variant2) { return Math.abs(variant1.getStart() - variant2.getStart()) < 3 && variant1.getChromosome().equals(variant2.getChromosome()) && variant1.getType().equals(VariantType.SNV) && variant2.getType().equals(VariantType.SNV) && samePhase(variant1, variant2); }
private boolean potentialCodingSNVOverlap(Variant variant1, Variant variant2) { return Math.abs(variant1.getStart() - variant2.getStart()) < 3 && variant1.getChromosome().equals(variant2.getChromosome()) && variant1.getType().equals(VariantType.SNV) && variant2.getType().equals(VariantType.SNV) && samePhase(variant1, variant2); }
public static int inferLength(String reference, String alternate, int start, int end, VariantType type) { final int length; if (isSV(type) || type.equals(VariantType.NO_VARIATION)) { length = inferLengthSymbolic(type, alternate, start, end); } else { length = inferLengthSimpleVariant(reference, alternate); } return length; }
/** * Build a list of all the alternates from a variant. Includes the main and the secondary alternates. * @param variant * @return */ public List<AlternateCoordinate> buildAltList(Variant variant) { AlternateCoordinate mainAlternate = getMainAlternate(variant); List<AlternateCoordinate> alternates = new ArrayList<>(); boolean emptyRefBlock = mainAlternate.getType().equals(VariantType.NO_VARIATION) && (mainAlternate.getAlternate().isEmpty() || mainAlternate.getAlternate().equals(Allele.NO_CALL_STRING)); // Skip Reference Blocks (NO_VARIATION) where the alternate is empty if (!emptyRefBlock) { alternates.add(mainAlternate); } StudyEntry se = getStudy(variant); if(se.getSecondaryAlternates() != null){ se.getSecondaryAlternates().forEach( alt -> alternates.add(copyAlt(variant, alt))); } return alternates; }
public static VariantType getVariantType(Variant variant) throws UnsupportedURLVariantFormat { if (variant.getType() == null) { variant.setType(Variant.inferType(variant.getReference(), variant.getAlternate())); } // FIXME: remove the if block below as soon as the Variant.inferType method is able to differentiate between // FIXME: insertions and deletions // if (variant.getType().equals(VariantType.INDEL) || variant.getType().equals(VariantType.SV)) { if (variant.getType().equals(VariantType.INDEL)) { if (variant.getReference().isEmpty()) { // variant.setType(VariantType.INSERTION); return VariantType.INSERTION; } else if (variant.getAlternate().isEmpty()) { // variant.setType(VariantType.DELETION); return VariantType.DELETION; } else { return VariantType.MNV; } } return variant.getType(); // return getVariantType(variant.getReference(), variant.getAlternate()); } }
public static VariantType getVariantType(Variant variant) throws UnsupportedURLVariantFormat { if (variant.getType() == null) { variant.setType(Variant.inferType(variant.getReference(), variant.getAlternate())); } // FIXME: remove the if block below as soon as the Variant.inferType method is able to differentiate between // FIXME: insertions and deletions // if (variant.getType().equals(VariantType.INDEL) || variant.getType().equals(VariantType.SV)) { if (variant.getType().equals(VariantType.INDEL)) { if (variant.getReference().isEmpty()) { // variant.setType(VariantType.INSERTION); return VariantType.INSERTION; } else if (variant.getAlternate().isEmpty()) { // variant.setType(VariantType.DELETION); return VariantType.DELETION; } else { return VariantType.MNV; } } return variant.getType(); // return getVariantType(variant.getReference(), variant.getAlternate()); } }
/** * Adjust start/end if a reference base is required due to an empty allele. All variants are checked due to SecAlts. * @param variant {@link Variant} object. * @param study Study * @return Pair<Integer, Integer> The adjusted (or same) start/end position e.g. SV and MNV as SecAlt, INDEL, etc. */ public static Pair<Integer, Integer> adjustedVariantStart(Variant variant, StudyEntry study, Map<Integer, Character> referenceAlleles) { if (variant.getType().equals(VariantType.NO_VARIATION)) { return new ImmutablePair<>(variant.getStart(), variant.getEnd()); } MutablePair<Integer, Integer> pos = adjustedVariantStart(variant.getStart(), variant.getEnd(), variant.getReference(), variant.getAlternate(), referenceAlleles, null); for (AlternateCoordinate alternateCoordinate : study.getSecondaryAlternates()) { int alternateStart = alternateCoordinate.getStart() == null ? variant.getStart() : alternateCoordinate.getStart().intValue(); int alternateEnd = alternateCoordinate.getEnd() == null ? variant.getEnd() : alternateCoordinate.getEnd().intValue(); String reference = alternateCoordinate.getReference() == null ? variant.getReference() : alternateCoordinate.getReference(); String alternate = alternateCoordinate.getAlternate() == null ? variant.getAlternate() : alternateCoordinate.getAlternate(); adjustedVariantStart(alternateStart, alternateEnd, reference, alternate, referenceAlleles, pos); } return pos; }
@Deprecated public static StructuralVariation getStructuralVariation(Variant variant, StructuralVariantType tandemDuplication) { int[] impreciseStart = getImpreciseStart(variant); int[] impreciseEnd = getImpreciseEnd(variant); String[] svInsSeq = getSvInsSeq(variant); StructuralVariation sv = new StructuralVariation(); sv.setCiStartLeft(impreciseStart[0]); sv.setCiStartRight(impreciseStart[1]); sv.setCiEndLeft(impreciseEnd[0]); sv.setCiEndRight(impreciseEnd[1]); sv.setLeftSvInsSeq(svInsSeq[0]); sv.setRightSvInsSeq(svInsSeq[1]); // If it's not a tandem duplication, this will set the type to null sv.setType(tandemDuplication); // Will properly set the type if it's a CNV if (variant.getType().equals(VariantType.CNV)) { Integer copyNumber = getCopyNumberFromAlternate(variant.getAlternate()); if (copyNumber != null) { sv.setCopyNumber(copyNumber); sv.setType(getCNVSubtype(copyNumber)); } } return sv; }
default QueryResult<T> getByVariant(Variant variant, QueryOptions options) { Query query; if (VariantType.CNV.equals(variant.getType())) { query = new Query(VariantDBAdaptor.QueryParams.CHROMOSOME.key(), variant.getChromosome()) .append(VariantDBAdaptor.QueryParams.CI_START_LEFT.key(), variant.getSv().getCiStartLeft()) .append(VariantDBAdaptor.QueryParams.CI_START_RIGHT.key(), variant.getSv().getCiStartRight()) .append(VariantDBAdaptor.QueryParams.CI_END_LEFT.key(), variant.getSv().getCiEndLeft()) .append(VariantDBAdaptor.QueryParams.CI_END_RIGHT.key(), variant.getSv().getCiEndRight()) .append(VariantDBAdaptor.QueryParams.REFERENCE.key(), variant.getReference()) .append(VariantDBAdaptor.QueryParams.ALTERNATE.key(), variant.getAlternate()); } else { query = new Query(VariantDBAdaptor.QueryParams.CHROMOSOME.key(), variant.getChromosome()) .append(VariantDBAdaptor.QueryParams.START.key(), variant.getStart()) .append(VariantDBAdaptor.QueryParams.REFERENCE.key(), variant.getReference()) .append(VariantDBAdaptor.QueryParams.ALTERNATE.key(), variant.getAlternate()); } return get(query, options); }
default QueryResult<T> getByVariant(Variant variant, QueryOptions options) { Query query; if (VariantType.CNV.equals(variant.getType())) { query = new Query(VariantDBAdaptor.QueryParams.CHROMOSOME.key(), variant.getChromosome()) .append(VariantDBAdaptor.QueryParams.CI_START_LEFT.key(), variant.getSv().getCiStartLeft()) .append(VariantDBAdaptor.QueryParams.CI_START_RIGHT.key(), variant.getSv().getCiStartRight()) .append(VariantDBAdaptor.QueryParams.CI_END_LEFT.key(), variant.getSv().getCiEndLeft()) .append(VariantDBAdaptor.QueryParams.CI_END_RIGHT.key(), variant.getSv().getCiEndRight()) .append(VariantDBAdaptor.QueryParams.REFERENCE.key(), variant.getReference()) .append(VariantDBAdaptor.QueryParams.ALTERNATE.key(), variant.getAlternate()); } else { query = new Query(VariantDBAdaptor.QueryParams.CHROMOSOME.key(), variant.getChromosome()) .append(VariantDBAdaptor.QueryParams.START.key(), variant.getStart()) .append(VariantDBAdaptor.QueryParams.REFERENCE.key(), variant.getReference()) .append(VariantDBAdaptor.QueryParams.ALTERNATE.key(), variant.getAlternate()); } return get(query, options); }