Java Code Examples for htsjdk.variant.variantcontext.VariantContext#Type

public GenotypeConcordanceSummaryMetrics(final VariantContext.Type variantType, final GenotypeConcordanceCounts concordanceCounts,
                                  final String truthSample, final String callSample, final boolean missingSitesFlag) {
    this.VARIANT_TYPE = variantType;
    this.TRUTH_SAMPLE = truthSample;
    this.CALL_SAMPLE = callSample;

    final GenotypeConcordanceSchemeFactory schemeFactory = new GenotypeConcordanceSchemeFactory();
    final GenotypeConcordanceScheme scheme = schemeFactory.getScheme(missingSitesFlag);
    scheme.validateScheme();
    concordanceCounts.validateCountsAgainstScheme(scheme);

    this.HET_SENSITIVITY = concordanceCounts.getSensitivity(scheme, GenotypeConcordanceCounts.HET_TRUTH_STATES);
    this.HET_PPV = concordanceCounts.Ppv(scheme, GenotypeConcordanceCounts.HET_CALL_STATES);
    this.HET_SPECIFICITY = Double.NaN;

    this.HOMVAR_SENSITIVITY = concordanceCounts.getSensitivity(scheme, GenotypeConcordanceCounts.HOM_VAR_TRUTH_STATES);
    this.HOMVAR_PPV = concordanceCounts.Ppv(scheme, GenotypeConcordanceCounts.HOM_VAR_CALL_STATES);
    this.HOMVAR_SPECIFICITY = Double.NaN;

    this.VAR_SENSITIVITY = concordanceCounts.getSensitivity(scheme, GenotypeConcordanceCounts.VAR_TRUTH_STATES);
    this.VAR_PPV = concordanceCounts.Ppv(scheme, GenotypeConcordanceCounts.VAR_CALL_STATES);
    this.VAR_SPECIFICITY = concordanceCounts.getSpecificity(scheme, GenotypeConcordanceCounts.VAR_TRUTH_STATES);

    this.GENOTYPE_CONCORDANCE = concordanceCounts.calculateGenotypeConcordance(scheme, missingSitesFlag);
    this.NON_REF_GENOTYPE_CONCORDANCE = concordanceCounts.calculateNonRefGenotypeConcordance(scheme, missingSitesFlag);
}
 

public GenotypeConcordanceContingencyMetrics(final VariantContext.Type variantType, final GenotypeConcordanceCounts concordanceCounts,
                                      final String truthSample, final String callSample, final boolean missingSitesFlag) {
    this.VARIANT_TYPE = variantType;
    this.TRUTH_SAMPLE = truthSample;
    this.CALL_SAMPLE = callSample;

    final GenotypeConcordanceSchemeFactory schemeFactory = new GenotypeConcordanceSchemeFactory();
    final GenotypeConcordanceScheme scheme = schemeFactory.getScheme(missingSitesFlag);
    scheme.validateScheme();
    concordanceCounts.validateCountsAgainstScheme(scheme);

    Map<ContingencyState, Long> counts = concordanceCounts.getContingencyStateCounts(scheme);
    this.TP_COUNT = counts.get(ContingencyState.TP);
    this.TN_COUNT = counts.get(ContingencyState.TN);
    this.FP_COUNT = counts.get(ContingencyState.FP);
    this.FN_COUNT = counts.get(ContingencyState.FN);
    this.EMPTY_COUNT = counts.get(ContingencyState.EMPTY);
}
 

/**
 * @param genotype The genotype to test whether we can attempt to validate.  Never {@code null}
 * @param referenceAllele The reference allele (from parent VariantContext).  Never {@code null}
 * @return whether this class can even attempt a validation of the genotype in question.
 */
public static boolean isAbleToValidateGenotype(final Genotype genotype, final Allele referenceAllele) {
    Utils.nonNull(genotype);
    Utils.nonNull(referenceAllele);

    // In order to proceed, we have some assumptions:
    //  - The genotype has a ploidy of 2
    //  - The genotype is a simple indel or a xNP
    //  - The first allele of the genotype is reference
    final boolean isDiploid = genotype.getAlleles().size() == 2;
    final boolean doesGenotypeHaveReference = genotype.getAllele(0).equals(referenceAllele);
    final boolean isReferenceNotSymbolic = !referenceAllele.isSymbolic();
    final VariantContext.Type variantType = GATKVariantContextUtils.typeOfVariant(genotype.getAllele(0), genotype.getAllele(1));
    final boolean isValidatableVariantType = VALIDATABLE_TYPES.contains(variantType)
                    && !GATKVariantContextUtils.isComplexIndel(genotype.getAllele(0), genotype.getAllele(1));
    final boolean hasKnownCoverage = genotype.hasAD() && (genotype.getAD().length == 2);
    final boolean isValidateable = (isDiploid && doesGenotypeHaveReference && isValidatableVariantType && hasKnownCoverage && isReferenceNotSymbolic);
    if (!isValidateable) {
        logger.info("Cannot validate genotype: " + genotype + "  ploidy2: " + isDiploid +
                "  genotypeHasReferenceAllele: " + doesGenotypeHaveReference + "   validatableVariant: " + isValidatableVariantType +
                "  hasCompleteAD field: " + hasKnownCoverage + "  isNonSymbolicReference: " + isReferenceNotSymbolic);
    }

    return isValidateable;
}
 

/**
 * Prepare the type inclusion list to be used by the type filter
 */
private Set<VariantContext.Type> createSampleTypeInclusionList() {

    // if user specified types to include, add these, otherwise, add all possible variant context types to list of vc types to include
    if (typesToInclude.isEmpty()) {
        selectedTypes.addAll(Arrays.asList(VariantContext.Type.values()));
    }
    else {
        selectedTypes.addAll(typesToInclude);
    }

    // Exclude types take precedence over include - remove specified exclude types
    selectedTypes.removeAll(typesToExclude);

    return selectedTypes;
}
 

@Override
protected ConcordanceSummaryRecord createRecord(final DataLine dataLine) {
    final VariantContext.Type type = VariantContext.Type.valueOf(dataLine.get(VARIANT_TYPE_COLUMN_NAME));
    final long truePositives = Long.parseLong(dataLine.get(TRUE_POSITIVE_COLUMN_NAME));
    final long falsePositives = Long.parseLong(dataLine.get(FALSE_POSITIVE_COLUMN_NAME));
    final long falseNegatives = Long.parseLong(dataLine.get(FALSE_NEGATIVE_COLUMN_NAME));

    return new ConcordanceSummaryRecord(type, truePositives, falsePositives, falseNegatives);
}
 

@Override
protected ConcordanceSummaryRecord createRecord(final DataLine dataLine) {
    final VariantContext.Type type = VariantContext.Type.valueOf(dataLine.get(VARIANT_TYPE_COLUMN_NAME));
    final long truePositives = Long.parseLong(dataLine.get(TRUE_POSITIVE_COLUMN_NAME));
    final long falsePositives = Long.parseLong(dataLine.get(FALSE_POSITIVE_COLUMN_NAME));
    final long falseNegatives = Long.parseLong(dataLine.get(FALSE_NEGATIVE_COLUMN_NAME));

    return new ConcordanceSummaryRecord(type, truePositives, falsePositives, falseNegatives);
}
 

@Override
protected InfoConcordanceRecord createRecord(DataLine dataLine) {
    VariantContext.Type type = VariantContext.Type.valueOf(dataLine.get(VARIANT_TYPE_COLUMN_NAME));
    String evalKey = dataLine.get(EVAL_INFO_KEY);
    String trueKey = dataLine.get(TRUE_INFO_KEY);
    double mean = Double.parseDouble(dataLine.get(MEAN_DIFFERENCE));
    double std = Double.parseDouble(dataLine.get(STD_DIFFERENCE));
    return new InfoConcordanceRecord(type, evalKey, trueKey, mean, std);
}
 

public ConcordanceSummaryRecord(final VariantContext.Type type, final long truePositives, final long falsePositives, final long falseNegatives){
    this.type = type;
    this.truePositives = truePositives;
    this.falsePositives = falsePositives;
    this.falseNegatives = falseNegatives;
}
 

public VariantTypesVariantFilter(Set<VariantContext.Type> includeTypes) {
    Utils.nonNull(includeTypes);
    sampleTypes = includeTypes;
}
 

@Override
public boolean test(final VariantContext vc) {
    final VariantContext.Type vcSampleType = vc.getType();
    return sampleTypes.contains(vcSampleType);
}
 

public ConcordanceSummaryRecord(final VariantContext.Type type, final long truePositives, final long falsePositives, final long falseNegatives){
    this.type = type;
    this.truePositives = truePositives;
    this.falsePositives = falsePositives;
    this.falseNegatives = falseNegatives;
}
 

@Override
public void initialize() {
    for (VariantContext.Type t : VariantContext.Type.values())
        states.add(t.toString());
}
 

/**
 * Record keeps track of concordance between values from INFO-field keys of a VCF.
 *
 * @param type SNP or INDEL
 * @param evalKey The INFO field key from the eval VCF
 * @param trueKey The INFO field key from the truth VCF
 * @param mean The mean of the differences in values for these INFO fields.
 * @param std The standard deviation of the differences in values for these INFO fields.
 */
public InfoConcordanceRecord(VariantContext.Type type, String evalKey, String trueKey, double mean, double std) {
    this.type = type;
    this.evalKey = evalKey;
    this.trueKey = trueKey;
    this.mean = mean;
    this.std = std;
}
 

/**
 *
 * @return Variant type (e.g. SNP or INDEL)
 */
public VariantContext.Type getVariantType() {
    return this.type;
}
 

public VariantContext.Type getVariantType() { return type; } 

public VariantContext.Type getVariantType() { return type; }