Fixing public -> private dep
This commit is contained in:
Mark DePristo
parent
7bf5ca51ee
commit
2f004665fb
|
|
@ -1,175 +0,0 @@
|
||||||
package org.broadinstitute.sting.utils.recalibration;
|
|
||||||
|
|
||||||
import java.util.*;
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Functions for working with AdaptiveContexts
|
|
||||||
*
|
|
||||||
* User: depristo
|
|
||||||
* Date: 8/3/12
|
|
||||||
* Time: 12:21 PM
|
|
||||||
* To change this template use File | Settings | File Templates.
|
|
||||||
*/
|
|
||||||
public class AdaptiveContext {
|
|
||||||
private AdaptiveContext() {}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Return a freshly allocated tree filled in completely to fillDepth with
|
|
||||||
* all combinations of {A,C,G,T}^filldepth contexts. For nodes
|
|
||||||
* in the tree, they are simply copied. When the algorithm needs to
|
|
||||||
* generate new nodes (because they are missing) the subnodes inherit the
|
|
||||||
* observation and error counts of their parent.
|
|
||||||
*
|
|
||||||
* This algorithm produces data consistent with the standard output in a BQSR recal
|
|
||||||
* file for the Context covariate.
|
|
||||||
*
|
|
||||||
* Suppose you have input tree
|
|
||||||
*
|
|
||||||
* - x
|
|
||||||
* - A
|
|
||||||
* - C
|
|
||||||
* - T
|
|
||||||
* - C
|
|
||||||
* - T
|
|
||||||
*
|
|
||||||
* This will produce the following contexts with fill depth of 2
|
|
||||||
*
|
|
||||||
* AA <- gets A info
|
|
||||||
* CA <- gets CA info
|
|
||||||
* GA <- gets A info
|
|
||||||
* TA <- get TA info
|
|
||||||
* .. for all 16 contexts
|
|
||||||
*
|
|
||||||
* @param root
|
|
||||||
* @param fillDepth
|
|
||||||
* @return
|
|
||||||
*/
|
|
||||||
public static RecalDatumNode<ContextDatum> fillToDepth(final RecalDatumNode<ContextDatum> root,
|
|
||||||
final int fillDepth,
|
|
||||||
final boolean debugWriteN) {
|
|
||||||
if ( root == null ) throw new IllegalArgumentException("root is null");
|
|
||||||
if ( fillDepth < 0 ) throw new IllegalArgumentException("fillDepth is < 0");
|
|
||||||
|
|
||||||
return fillToDepthRec(root, fillDepth, 0, debugWriteN);
|
|
||||||
}
|
|
||||||
|
|
||||||
private static RecalDatumNode<ContextDatum> fillToDepthRec(final RecalDatumNode<ContextDatum> parent,
|
|
||||||
final int fillDepth,
|
|
||||||
final int currentDepth,
|
|
||||||
final boolean debugWriteN) {
|
|
||||||
// three cases:
|
|
||||||
// We are in the tree and so just recursively build
|
|
||||||
// We have reached our depth goal, so just return the parent since we are done
|
|
||||||
// We are outside of the tree, in which case we need to pointer to our parent node so we can
|
|
||||||
// we info (N, M) and we need a running context
|
|
||||||
if ( currentDepth < fillDepth ) {
|
|
||||||
// we need to create subnodes for each base, and propogate N and M down
|
|
||||||
final RecalDatumNode<ContextDatum> newParent = new RecalDatumNode<ContextDatum>(parent.getRecalDatum());
|
|
||||||
|
|
||||||
for ( final String base : Arrays.asList("A", "C", "G", "T")) {
|
|
||||||
final String subContextBases = base + parent.getRecalDatum().context;
|
|
||||||
ContextDatum subContext;
|
|
||||||
Set<RecalDatumNode<ContextDatum>> subContexts;
|
|
||||||
|
|
||||||
final RecalDatumNode<ContextDatum> subNode = findSubcontext(subContextBases, parent);
|
|
||||||
if ( subNode != null ) {
|
|
||||||
// we have a subnode corresponding to the expected one, just copy and recurse
|
|
||||||
subContext = subNode.getRecalDatum();
|
|
||||||
subContexts = subNode.getSubnodes();
|
|
||||||
} else {
|
|
||||||
// have to create a new one
|
|
||||||
subContext = new ContextDatum(debugWriteN ? ("N" + parent.getRecalDatum().context ) : subContextBases,
|
|
||||||
parent.getRecalDatum().getNumObservations(), parent.getRecalDatum().getNumMismatches());
|
|
||||||
subContexts = Collections.emptySet();
|
|
||||||
}
|
|
||||||
|
|
||||||
newParent.addSubnode(
|
|
||||||
fillToDepthRec(new RecalDatumNode<ContextDatum>(subContext, subContexts),
|
|
||||||
fillDepth, currentDepth + 1, debugWriteN));
|
|
||||||
}
|
|
||||||
return newParent;
|
|
||||||
} else {
|
|
||||||
return parent;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Go from a flat list of contexts to the tree implied by the contexts
|
|
||||||
*
|
|
||||||
* Implicit nodes are created as needed, and their observation and error counts are the sum of the
|
|
||||||
* all of their subnodes.
|
|
||||||
*
|
|
||||||
* Note this does not guarentee the tree is complete, as some contexts (e.g., AAT) may be missing
|
|
||||||
* from the tree because they are absent from the input list of contexts.
|
|
||||||
*
|
|
||||||
* For input AAG, AAT, AC, G would produce the following tree:
|
|
||||||
*
|
|
||||||
* - x [root]
|
|
||||||
* - A
|
|
||||||
* - A
|
|
||||||
* - T
|
|
||||||
* - G
|
|
||||||
* - C
|
|
||||||
* - G
|
|
||||||
*
|
|
||||||
* sets the fixed penalties in the resulting tree as well
|
|
||||||
*
|
|
||||||
* @param flatContexts list of flat contexts
|
|
||||||
* @return
|
|
||||||
*/
|
|
||||||
public static RecalDatumNode<ContextDatum> createTreeFromFlatContexts(final List<ContextDatum> flatContexts) {
|
|
||||||
if ( flatContexts == null || flatContexts.isEmpty() )
|
|
||||||
throw new IllegalArgumentException("flatContexts cannot be empty or null");
|
|
||||||
|
|
||||||
final Queue<RecalDatumNode<ContextDatum>> remaining = new LinkedList<RecalDatumNode<ContextDatum>>();
|
|
||||||
final Map<String, RecalDatumNode<ContextDatum>> contextToNodes = new HashMap<String, RecalDatumNode<ContextDatum>>();
|
|
||||||
RecalDatumNode<ContextDatum> root = null;
|
|
||||||
|
|
||||||
// initialize -- start with all of the contexts
|
|
||||||
for ( final ContextDatum cd : flatContexts )
|
|
||||||
remaining.add(new RecalDatumNode<ContextDatum>(cd));
|
|
||||||
|
|
||||||
while ( remaining.peek() != null ) {
|
|
||||||
final RecalDatumNode<ContextDatum> add = remaining.poll();
|
|
||||||
final ContextDatum cd = add.getRecalDatum();
|
|
||||||
|
|
||||||
final String parentContext = cd.getParentContext();
|
|
||||||
RecalDatumNode<ContextDatum> parent = contextToNodes.get(parentContext);
|
|
||||||
if ( parent == null ) {
|
|
||||||
// haven't yet found parent, so make one, and enqueue it for processing
|
|
||||||
parent = new RecalDatumNode<ContextDatum>(new ContextDatum(parentContext, 0, 0));
|
|
||||||
contextToNodes.put(parentContext, parent);
|
|
||||||
|
|
||||||
if ( ! parent.getRecalDatum().isRootContext() )
|
|
||||||
remaining.add(parent);
|
|
||||||
else
|
|
||||||
root = parent;
|
|
||||||
}
|
|
||||||
|
|
||||||
parent.getRecalDatum().incrementNumObservations(cd.getNumObservations());
|
|
||||||
parent.getRecalDatum().incrementNumMismatches(cd.getNumMismatches());
|
|
||||||
parent.addSubnode(add);
|
|
||||||
}
|
|
||||||
|
|
||||||
if ( root == null )
|
|
||||||
throw new RuntimeException("root is unexpectedly null");
|
|
||||||
|
|
||||||
// set the fixed penalty everywhere in the tree, so that future modifications don't change the penalties
|
|
||||||
root.calcAndSetFixedPenalty(true);
|
|
||||||
|
|
||||||
return root;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Finds immediate subnode with contextToFind, or null if none exists
|
|
||||||
*
|
|
||||||
* @param tree whose subnodes should be searched
|
|
||||||
* @return
|
|
||||||
*/
|
|
||||||
public static RecalDatumNode<ContextDatum> findSubcontext(final String contextToFind, final RecalDatumNode<ContextDatum> tree) {
|
|
||||||
for ( final RecalDatumNode<ContextDatum> sub : tree.getSubnodes() )
|
|
||||||
if ( sub.getRecalDatum().context.equals(contextToFind) )
|
|
||||||
return sub;
|
|
||||||
return null;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Loading…
Reference in New Issue