public int getNumberOfSamplesForEvaluation() { if (sampleNamesForEvaluation != null && !sampleNamesForEvaluation.isEmpty()) return sampleNamesForEvaluation.size(); else { return numSamplesFromArgument; } }
/** * Compares the covariate report lists. * * @param diffs map where to annotate the difference. * @param other the argument collection to compare against. * @param thisRole the name for this argument collection that makes sense to the user. * @param otherRole the name for the other argument collection that makes sense to the end user. * @return <code>true</code> if a difference was found. */ @Requires("diffs != null && other != null && thisRole != null && otherRole != null") private boolean compareRequestedCovariates( final Map<String, String> diffs, final RecalibrationArgumentCollection other, final String thisRole, final String otherRole) { final Set<String> beforeNames = new HashSet<>(this.COVARIATES.length); final Set<String> afterNames = new HashSet<>(other.COVARIATES.length); Utils.addAll(beforeNames, this.COVARIATES); Utils.addAll(afterNames, other.COVARIATES); final Set<String> intersect = new HashSet<>(Math.min(beforeNames.size(), afterNames.size())); intersect.addAll(beforeNames); intersect.retainAll(afterNames); String diffMessage = null; if (intersect.size() == 0) { // In practice this is not possible due to required covariates but... diffMessage = String.format( "There are no common covariates between '%s' and '%s'" + " recalibrator reports. Covariates in '%s': {%s}. Covariates in '%s': {%s}.", thisRole, otherRole, thisRole, Utils.join(", ", this.COVARIATES), otherRole, Utils.join(",", other.COVARIATES)); } else if (intersect.size() != beforeNames.size() || intersect.size() != afterNames.size()) { beforeNames.removeAll(intersect); afterNames.removeAll(intersect); diffMessage = String.format( "There are differences in the set of covariates requested in the" + " '%s' and '%s' recalibrator reports. " + " Exclusive to '%s': {%s}. Exclusive to '%s': {%s}.", thisRole, otherRole, thisRole, Utils.join(", ", beforeNames), otherRole, Utils.join(", ", afterNames)); } if (diffMessage != null) { diffs.put("covariate", diffMessage); return true; } else { return false; } }
/** Initialize the stratifications, evaluations, evaluation contexts, and reporting object */ public void initialize() { // Just list the modules, and exit quickly. if (LIST) { variantEvalUtils.listModulesAndExit(); } // maintain the full list of comps comps.addAll(compsProvided); if (dbsnp.dbsnp.isBound()) { comps.add(dbsnp.dbsnp); knowns.add(dbsnp.dbsnp); } // Add a dummy comp track if none exists if (comps.size() == 0) comps.add( new RodBinding<VariantContext>(VariantContext.class, "none", "UNBOUND", "", new Tags())); // Set up set of additional knowns for (RodBinding<VariantContext> compRod : comps) { if (KNOWN_NAMES.contains(compRod.getName())) knowns.add(compRod); } // Now that we have all the rods categorized, determine the sample list from the eval rods. Map<String, VCFHeader> vcfRods = VCFUtils.getVCFHeadersFromRods(getToolkit(), evals); Set<String> vcfSamples = SampleUtils.getSampleList(vcfRods, VariantContextUtils.GenotypeMergeType.REQUIRE_UNIQUE); // Load the sample list sampleNamesForEvaluation.addAll( SampleUtils.getSamplesFromCommandLineInput(vcfSamples, SAMPLE_EXPRESSIONS)); numSamples = NUM_SAMPLES > 0 ? NUM_SAMPLES : sampleNamesForEvaluation.size(); if (Arrays.asList(STRATIFICATIONS_TO_USE).contains("Sample")) { sampleNamesForStratification.addAll(sampleNamesForEvaluation); } sampleNamesForStratification.add(ALL_SAMPLE_NAME); // Initialize select expressions for (VariantContextUtils.JexlVCMatchExp jexl : VariantContextUtils.initializeMatchExps(SELECT_NAMES, SELECT_EXPS)) { SortableJexlVCMatchExp sjexl = new SortableJexlVCMatchExp(jexl.name, jexl.exp); jexlExpressions.add(sjexl); } // Initialize the set of stratifications and evaluations to use stratificationObjects = variantEvalUtils.initializeStratificationObjects( this, NO_STANDARD_STRATIFICATIONS, STRATIFICATIONS_TO_USE); Set<Class<? extends VariantEvaluator>> evaluationObjects = variantEvalUtils.initializeEvaluationObjects(NO_STANDARD_MODULES, MODULES_TO_USE); for (VariantStratifier vs : getStratificationObjects()) { if (vs.getName().equals("Filter")) byFilterIsEnabled = true; else if (vs.getName().equals("Sample")) perSampleIsEnabled = true; } if (intervalsFile != null) { boolean fail = true; for (final VariantStratifier vs : stratificationObjects) { if (vs.getClass().equals(IntervalStratification.class)) fail = false; } if (fail) throw new UserException.BadArgumentValue( "ST", "stratIntervals argument provided but -ST IntervalStratification not provided"); } // Initialize the evaluation contexts evaluationContexts = variantEvalUtils.initializeEvaluationContexts( stratificationObjects, evaluationObjects, null, null); // Initialize report table report = variantEvalUtils.initializeGATKReport(stratificationObjects, evaluationObjects); // Load ancestral alignments if (ancestralAlignmentsFile != null) { try { ancestralAlignments = new IndexedFastaSequenceFile(ancestralAlignmentsFile); } catch (FileNotFoundException e) { throw new ReviewedStingException( String.format( "The ancestral alignments file, '%s', could not be found", ancestralAlignmentsFile.getAbsolutePath())); } } // initialize CNVs if (knownCNVsFile != null) { knownCNVsByContig = createIntervalTreeByContig(knownCNVsFile); } }