/** * Given specific eval and comp VCs and the sample name, return an iterable over all of the * applicable state keys. * * <p>this code isn't structured yet for efficiency. Here we currently are doing the following * inefficient algorithm: * * <p>for each strat: get list of relevant states that eval and comp according to strat add this * list of states to a list of list states * * <p>then * * <p>ask the strat manager to look up all of the keys associated with the combinations of these * states. For example, suppose we have a single variant S. We have active strats EvalRod, * CompRod, and Novelty. We produce a list that looks like: * * <p>L = [[Eval], [Comp], [All, Novel]] * * <p>We then go through the strat manager tree to produce the keys associated with these states: * * <p>K = [0, 1] where EVAL x COMP x ALL = 0 and EVAL x COMP x NOVEL = 1 * * <p>It's clear that a better * * <p>TODO -- create an inline version that doesn't create the intermediate list of list * * @param tracker * @param ref * @param eval * @param evalName * @param comp * @param compName * @param sampleName * @return */ protected Collection<EvaluationContext> getEvaluationContexts( final RefMetaDataTracker tracker, final ReferenceContext ref, final VariantContext eval, final String evalName, final VariantContext comp, final String compName, final String sampleName) { final List<List<Object>> states = new LinkedList<List<Object>>(); for (final VariantStratifier vs : stratManager.getStratifiers()) { states.add(vs.getRelevantStates(ref, tracker, comp, compName, eval, evalName, sampleName)); } return stratManager.values(states); }
final void checkForIncompatibleEvaluatorsAndStratifiers( final List<VariantStratifier> stratificationObjects, Set<Class<? extends VariantEvaluator>> evaluationClasses) { for (final VariantStratifier vs : stratificationObjects) { for (Class<? extends VariantEvaluator> ec : evaluationClasses) if (vs.getIncompatibleEvaluators().contains(ec)) throw new UserException.BadArgumentValue( "ST and ET", "The selected stratification " + vs.getName() + " and evaluator " + ec.getSimpleName() + " are incompatible due to combinatorial memory requirements." + " Please disable one"); } }
/** * Output the finalized report * * @param result an integer that doesn't get used for anything */ public void onTraversalDone(Integer result) { logger.info("Finalizing variant report"); for (StateKey stateKey : evaluationContexts.keySet()) { NewEvaluationContext nec = evaluationContexts.get(stateKey); for (VariantEvaluator ve : nec.getEvaluationClassList().values()) { ve.finalizeEvaluation(); AnalysisModuleScanner scanner = new AnalysisModuleScanner(ve); Map<Field, DataPoint> datamap = scanner.getData(); for (Field field : datamap.keySet()) { try { field.setAccessible(true); if (field.get(ve) instanceof TableType) { TableType t = (TableType) field.get(ve); String subTableName = ve.getClass().getSimpleName() + "." + field.getName(); final DataPoint dataPointAnn = datamap.get(field); GATKReportTable table; if (!report.hasTable(subTableName)) { report.addTable(subTableName, dataPointAnn.description()); table = report.getTable(subTableName); table.addPrimaryKey("entry", false); table.addColumn(subTableName, subTableName); for (VariantStratifier vs : stratificationObjects) { table.addColumn(vs.getName(), "unknown"); } table.addColumn("row", "unknown"); for (Object o : t.getColumnKeys()) { String c; if (o instanceof String) { c = (String) o; } else { c = o.toString(); } table.addColumn(c, 0.0); } } else { table = report.getTable(subTableName); } for (int row = 0; row < t.getRowKeys().length; row++) { String r = (String) t.getRowKeys()[row]; for (VariantStratifier vs : stratificationObjects) { final String columnName = vs.getName(); table.set(stateKey.toString() + r, columnName, stateKey.get(columnName)); } for (int col = 0; col < t.getColumnKeys().length; col++) { String c; if (t.getColumnKeys()[col] instanceof String) { c = (String) t.getColumnKeys()[col]; } else { c = t.getColumnKeys()[col].toString(); } String newStateKey = stateKey.toString() + r; table.set(newStateKey, c, t.getCell(row, col)); table.set(newStateKey, "row", r); } } } else { GATKReportTable table = report.getTable(ve.getClass().getSimpleName()); for (VariantStratifier vs : stratificationObjects) { String columnName = vs.getName(); table.set(stateKey.toString(), columnName, stateKey.get(vs.getName())); } table.set(stateKey.toString(), field.getName(), field.get(ve)); } } catch (IllegalAccessException e) { throw new StingException("IllegalAccessException: " + e); } } } } report.print(out); }
/** Collect relevant information from each variant in the supplied VCFs */ @Override public Integer map(RefMetaDataTracker tracker, ReferenceContext ref, AlignmentContext context) { for (NewEvaluationContext nec : evaluationContexts.values()) { synchronized (nec) { nec.update0(tracker, ref, context); } } if (tracker != null) { String aastr = (ancestralAlignments == null) ? null : new String( ancestralAlignments .getSubsequenceAt( ref.getLocus().getContig(), ref.getLocus().getStart(), ref.getLocus().getStop()) .getBases()); // --------- track --------- sample - VariantContexts - HashMap<RodBinding<VariantContext>, HashMap<String, Collection<VariantContext>>> evalVCs = variantEvalUtils.bindVariantContexts( tracker, ref, evals, byFilterIsEnabled, true, perSampleIsEnabled, mergeEvals); HashMap<RodBinding<VariantContext>, HashMap<String, Collection<VariantContext>>> compVCs = variantEvalUtils.bindVariantContexts( tracker, ref, comps, byFilterIsEnabled, false, false, false); // for each eval track for (final RodBinding<VariantContext> evalRod : evals) { final Map<String, Collection<VariantContext>> emptyEvalMap = Collections.emptyMap(); final Map<String, Collection<VariantContext>> evalSet = evalVCs.containsKey(evalRod) ? evalVCs.get(evalRod) : emptyEvalMap; // for each sample stratifier for (final String sampleName : sampleNamesForStratification) { Collection<VariantContext> evalSetBySample = evalSet.get(sampleName); if (evalSetBySample == null) { evalSetBySample = new HashSet<VariantContext>(1); evalSetBySample.add(null); } // for each eval in the track for (VariantContext eval : evalSetBySample) { // deal with ancestral alleles if requested if (eval != null && aastr != null) { eval = new VariantContextBuilder(eval).attribute("ANCESTRALALLELE", aastr).make(); } // for each comp track for (final RodBinding<VariantContext> compRod : comps) { // no sample stratification for comps final HashMap<String, Collection<VariantContext>> compSetHash = compVCs.get(compRod); final Collection<VariantContext> compSet = (compSetHash == null || compSetHash.size() == 0) ? Collections.<VariantContext>emptyList() : compVCs.get(compRod).values().iterator().next(); // find the comp final VariantContext comp = findMatchingComp(eval, compSet); HashMap<VariantStratifier, List<String>> stateMap = new HashMap<VariantStratifier, List<String>>(); for (VariantStratifier vs : stratificationObjects) { List<String> states = vs.getRelevantStates( ref, tracker, comp, compRod.getName(), eval, evalRod.getName(), sampleName); stateMap.put(vs, states); } ArrayList<StateKey> stateKeys = new ArrayList<StateKey>(); variantEvalUtils.initializeStateKeys(stateMap, null, null, stateKeys); HashSet<StateKey> stateKeysHash = new HashSet<StateKey>(stateKeys); for (StateKey stateKey : stateKeysHash) { NewEvaluationContext nec = evaluationContexts.get(stateKey); // eval against the comp synchronized (nec) { nec.apply(tracker, ref, context, comp, eval); } // eval=null against all comps of different type that aren't bound to another eval for (VariantContext otherComp : compSet) { if (otherComp != comp && !compHasMatchingEval(otherComp, evalSetBySample)) { synchronized (nec) { nec.apply(tracker, ref, context, otherComp, null); } } } } } } } if (mergeEvals) break; // stop processing the eval tracks } } return null; }
/** 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); } }