Java VariantContextUtils.calculateChromosomeCounts方法代码示例

import htsjdk.variant.variantcontext.VariantContextUtils; //导入方法依赖的package包/类
/**
 * Split variant context into its biallelic components if there are more than 2 alleles
 *
 * For VC has A/B/C alleles, returns A/B and A/C contexts.
 * Genotypes are all no-calls now (it's not possible to fix them easily)
 * Alleles are right trimmed to satisfy VCF conventions
 *
 * If vc is biallelic or non-variant it is just returned
 *
 * Chromosome counts are updated (but they are by definition 0)
 *
 * @param vc a potentially multi-allelic variant context
 * @param trimLeft if true, we will also left trim alleles, potentially moving the resulting vcs forward on the genome
 * @return a list of bi-allelic (or monomorphic) variant context
 */
public static List<VariantContext> splitVariantContextToBiallelics(final VariantContext vc, final boolean trimLeft, final GenotypeAssignmentMethod genotypeAssignmentMethod) {
    if ( ! vc.isVariant() || vc.isBiallelic() )
        // non variant or biallelics already satisfy the contract
        return Collections.singletonList(vc);
    else {
        final List<VariantContext> biallelics = new LinkedList<>();

        for ( final Allele alt : vc.getAlternateAlleles() ) {
            VariantContextBuilder builder = new VariantContextBuilder(vc);
            final List<Allele> alleles = Arrays.asList(vc.getReference(), alt);
            builder.alleles(alleles);
            builder.genotypes(subsetDiploidAlleles(vc, alleles, genotypeAssignmentMethod));
            VariantContextUtils.calculateChromosomeCounts(builder, true);
            final VariantContext trimmed = trimAlleles(builder.make(), trimLeft, true);
            biallelics.add(trimmed);
        }

        return biallelics;
    }
}
 

import htsjdk.variant.variantcontext.VariantContextUtils; //导入方法依赖的package包/类
public Map<String, Object> annotate(final RefMetaDataTracker tracker,
                                    final AnnotatorCompatible walker,
                                    final ReferenceContext ref,
                                    final Map<String, AlignmentContext> stratifiedContexts,
                                    final VariantContext vc,
                                    final Map<String, PerReadAlleleLikelihoodMap> perReadAlleleLikelihoodMap) {
    if (!vc.hasGenotypes())
        return null;

    return VariantContextUtils.calculateChromosomeCounts(vc, new HashMap<String, Object>(), true, founderIds);
}
 

import htsjdk.variant.variantcontext.VariantContextUtils; //导入方法依赖的package包/类
public Map<String, Object> annotate(final VariantDataTracker tracker,
                                    final ChromosomeInformationShare ref,
                                    final Mpileup mpileup,
                                    final VariantContext vc,
                                    final Map<String, PerReadAlleleLikelihoodMap> perReadAlleleLikelihoodMap ) {
    if ( ! vc.hasGenotypes() )
        return null;

    return VariantContextUtils.calculateChromosomeCounts(vc, new HashMap<String, Object>(), true,founderIds);
}
 

import htsjdk.variant.variantcontext.VariantContextUtils; //导入方法依赖的package包/类
@Override
public Map<String, Object> annotate(RefMetaDataTracker tracker, ChromosomeInformationShare ref, VariantContext vc) {
	if ( ! vc.hasGenotypes() )
           return null;
       //if none of the "founders" are in the vc samples, assume we uniquified the samples upstream and they are all founders
       if (!didUniquifiedSampleNameCheck) {
           checkSampleNames(vc);
           didUniquifiedSampleNameCheck = true;
       }

       return VariantContextUtils.calculateChromosomeCounts(vc, new HashMap<String, Object>(), true,founderIds);
}
 

import htsjdk.variant.variantcontext.VariantContextUtils; //导入方法依赖的package包/类
@Override
public void apply(final VariantContext variant,
                  final ReadsContext readsContext,
                  final ReferenceContext referenceContext,
                  final FeatureContext featureContext) {
    final Collection<VariantContext> vcs = featureContext.getValues(getDrivingVariantsFeatureInput());

    final Collection<VariantContext> otherVCs = featureContext.getValues(supportVariants);

    final int missing = supportVariants.size() - otherVCs.size();

    for ( final VariantContext vc : vcs ) {
        final VariantContext vc_familyPriors;
        final VariantContext vc_bothPriors;

        //do family priors first (if applicable)
        final VariantContextBuilder builder = new VariantContextBuilder(vc);
        //only compute family priors for biallelelic sites
        if (!skipFamilyPriors && vc.isBiallelic()){
            final GenotypesContext gc = famUtils.calculatePosteriorGLs(vc);
            builder.genotypes(gc);
        }
        VariantContextUtils.calculateChromosomeCounts(builder, false);
        vc_familyPriors = builder.make();

        if (!skipPopulationPriors) {
            vc_bothPriors = PosteriorProbabilitiesUtils.calculatePosteriorProbs(vc_familyPriors, otherVCs, missing * numRefIfMissing, globalPrior, !ignoreInputSamples, defaultToAC, useACoff);
        } else {
            final VariantContextBuilder builder2 = new VariantContextBuilder(vc_familyPriors);
            VariantContextUtils.calculateChromosomeCounts(builder, false);
            vc_bothPriors = builder2.make();
        }
        vcfWriter.add(vc_bothPriors);
    }
}
 

import htsjdk.variant.variantcontext.VariantContextUtils; //导入方法依赖的package包/类
@Override
public Map<String, Object> annotate(final ReferenceContext ref,
                                    final VariantContext vc,
                                    ReadLikelihoods<Allele> likelihoods) {
    Utils.nonNull(vc);
    if ( ! vc.hasGenotypes() ) {
        return Collections.emptyMap();
    }

    return VariantContextUtils.calculateChromosomeCounts(vc, new LinkedHashMap<>(), true, Collections.emptySet());
}
 

import htsjdk.variant.variantcontext.VariantContextUtils; //导入方法依赖的package包/类
private void addAnnotations(final VariantContextBuilder builder, final VariantContext originalVC, final Set<String> selectedSampleNames) {
    if (fullyDecode) {
        return; // TODO -- annotations are broken with fully decoded data
    }

    if (keepOriginalChrCounts) {
        final int[] indexOfOriginalAlleleForNewAllele;
        final List<Allele> newAlleles = builder.getAlleles();
        final int numOriginalAlleles = originalVC.getNAlleles();

        // if the alleles already match up, we can just copy the previous list of counts
        if (numOriginalAlleles == newAlleles.size()) {
            indexOfOriginalAlleleForNewAllele = null;
        }
        // otherwise we need to parse them and select out the correct ones
        else {
            indexOfOriginalAlleleForNewAllele = new int[newAlleles.size() - 1];
            Arrays.fill(indexOfOriginalAlleleForNewAllele, -1);

            // note that we don't care about the reference allele at position 0
            for (int newI = 1; newI < newAlleles.size(); newI++) {
                final Allele newAlt = newAlleles.get(newI);
                for (int oldI = 0; oldI < numOriginalAlleles - 1; oldI++) {
                    if (newAlt.equals(originalVC.getAlternateAllele(oldI), false)) {
                        indexOfOriginalAlleleForNewAllele[newI - 1] = oldI;
                        break;
                    }
                }
            }
        }

        if (originalVC.hasAttribute(VCFConstants.ALLELE_COUNT_KEY)) {
            builder.attribute(GATKVCFConstants.ORIGINAL_AC_KEY,
                    getReorderedAttributes(originalVC.getAttribute(VCFConstants.ALLELE_COUNT_KEY), indexOfOriginalAlleleForNewAllele));
        }
        if (originalVC.hasAttribute(VCFConstants.ALLELE_FREQUENCY_KEY)) {
            builder.attribute(GATKVCFConstants.ORIGINAL_AF_KEY,
                    getReorderedAttributes(originalVC.getAttribute(VCFConstants.ALLELE_FREQUENCY_KEY), indexOfOriginalAlleleForNewAllele));
        }
        if (originalVC.hasAttribute(VCFConstants.ALLELE_NUMBER_KEY)) {
            builder.attribute(GATKVCFConstants.ORIGINAL_AN_KEY, originalVC.getAttribute(VCFConstants.ALLELE_NUMBER_KEY));
        }
    }

    VariantContextUtils.calculateChromosomeCounts(builder, false);

    if (keepOriginalDepth && originalVC.hasAttribute(VCFConstants.DEPTH_KEY)) {
        builder.attribute(GATKVCFConstants.ORIGINAL_DP_KEY, originalVC.getAttribute(VCFConstants.DEPTH_KEY));
    }

    boolean sawDP = false;
    int depth = 0;
    for (final String sample : selectedSampleNames ) {
        final Genotype g = originalVC.getGenotype(sample);
        if (!g.isFiltered()) {
            if (g.hasDP()) {
                depth += g.getDP();
                sawDP = true;
            }
        }
    }

    if (sawDP) {
        builder.attribute(VCFConstants.DEPTH_KEY, depth);
    }
}