zzh
/
gatk-3.8
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Some changes involving output of marginal calls to different, per-filter files. 

git-svn-id: file:///humgen/gsa-scr1/gsa-engineering/svn_contents/trunk@1191 348d0f76-0448-11de-a6fe-93d51630548a
This commit is contained in:
kiran 2009-07-08 16:12:57 +00:00
parent 787c84d68b
commit 6e31057e6b
1 changed files with 91 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

148
java/src/org/broadinstitute/sting/playground/gatk/walkers/variants/VariantFiltrationWalker.java
View File

@ -27,15 +27,16 @@ import java.util.HashSet;
*/ */
@Requires(value={DataSource.READS, DataSource.REFERENCE},referenceMetaData=@RMD(name="variant",type=rodVariants.class)) @Requires(value={DataSource.READS, DataSource.REFERENCE},referenceMetaData=@RMD(name="variant",type=rodVariants.class))
public class VariantFiltrationWalker extends LocusWalker<Integer, Integer> { public class VariantFiltrationWalker extends LocusWalker<Integer, Integer> {
@Argument(fullName="features", shortName="F", doc="Feature test (optionally with arguments) to apply to genotype posteriors. Syntax: 'testname[:arguments]'") public String[] FEATURES; @Argument(fullName="variants_out_head", shortName="VOH", doc="File to which modified variants should be written") public String VARIANTS_OUT_HEAD;
@Argument(fullName="exclusion_criterion", shortName="X", doc="Exclusion test (optionally with arguments) to apply to variant call. Syntax: 'testname[:arguments]'") public String[] EXCLUSIONS; @Argument(fullName="features", shortName="F", doc="Feature test (optionally with arguments) to apply to genotype posteriors. Syntax: 'testname[:arguments]'", required=false) public String[] FEATURES;
@Argument(fullName="variants_out", shortName="VO", doc="File to which modified variants should be written") public File VARIANTS_OUT; @Argument(fullName="exclusion_criterion", shortName="X", doc="Exclusion test (optionally with arguments) to apply to variant call. Syntax: 'testname[:arguments]'", required=false) public String[] EXCLUSIONS;
@Argument(fullName="verbose", shortName="V", doc="Show how the variant likelihoods are changing with the application of each feature") public Boolean VERBOSE = false; @Argument(fullName="verbose", shortName="V", doc="Show how the variant likelihoods are changing with the application of each feature") public Boolean VERBOSE = false;
@Argument(fullName="list", shortName="ls", doc="List the available features and exclusion criteria and exit") public Boolean LIST = false; @Argument(fullName="list", shortName="ls", doc="List the available features and exclusion criteria and exit") public Boolean LIST = false;
private ArrayList<Class> featureClasses; private ArrayList<Class> featureClasses;
private ArrayList<Class> exclusionClasses; private ArrayList<Class> exclusionClasses;
private PrintWriter vwriter; private PrintWriter vwriter;
private HashMap<String, PrintWriter> ewriters;
/** /**
* Prepare the output file and the list of available features. * Prepare the output file and the list of available features.
@ -45,17 +46,37 @@ public class VariantFiltrationWalker extends LocusWalker<Integer, Integer> {
exclusionClasses = PackageUtils.getClassesImplementingInterface(VariantExclusionCriterion.class); exclusionClasses = PackageUtils.getClassesImplementingInterface(VariantExclusionCriterion.class);
if (LIST) { if (LIST) {
out.println("\nAvailable features: " + getAvailableClasses(featureClasses) + "\n"); out.println("\nAvailable features: " + getAvailableClasses(featureClasses));
out.println("\nAvailable exclusion criteria: " + getAvailableClasses(exclusionClasses) + "\n"); out.println("Available exclusion criteria: " + getAvailableClasses(exclusionClasses) + "\n");
System.exit(0); System.exit(0);
} }
try { try {
vwriter = new PrintWriter(VARIANTS_OUT); vwriter = new PrintWriter(VARIANTS_OUT_HEAD + ".included.geli.calls");
vwriter.println(AlleleFrequencyEstimate.geliHeaderString()); vwriter.println(AlleleFrequencyEstimate.geliHeaderString());
ewriters = new HashMap<String, PrintWriter>();
if (EXCLUSIONS != null) {
for (String requestedExclusionString : EXCLUSIONS) {
String[] requestedExclusionPieces = requestedExclusionString.split(":");
String requestedExclusionName = requestedExclusionPieces[0];
for ( Class exclusionClass : exclusionClasses ) {
String exclusionClassName = rationalizeClassName(exclusionClass);
if (requestedExclusionName.equalsIgnoreCase(exclusionClassName)) {
PrintWriter writer = new PrintWriter(VARIANTS_OUT_HEAD + ".excluded." + exclusionClassName + ".geli.calls");
writer.println(AlleleFrequencyEstimate.geliHeaderString());
ewriters.put(exclusionClassName, writer);
}
}
}
}
} catch (FileNotFoundException e) { } catch (FileNotFoundException e) {
throw new StingException(String.format("Could not open file '%s' for writing", VARIANTS_OUT.getAbsolutePath())); //throw new StingException(String.format("Could not open file '%s' for writing", VARIANTS_OUT.getAbsolutePath()));
throw new StingException(String.format("Could not open file(s) for writing"));
} }
} }
@ -111,82 +132,91 @@ public class VariantFiltrationWalker extends LocusWalker<Integer, Integer> {
if (VERBOSE) { out.println("Original:\n " + variant); } if (VERBOSE) { out.println("Original:\n " + variant); }
// Apply features that modify the likelihoods and LOD scores // Apply features that modify the likelihoods and LOD scores
for (String requestedFeatureString : FEATURES) { if (FEATURES != null) {
String[] requestedFeaturePieces = requestedFeatureString.split(":"); for (String requestedFeatureString : FEATURES) {
String requestedFeatureName = requestedFeaturePieces[0]; String[] requestedFeaturePieces = requestedFeatureString.split(":");
String requestedFeatureArgs = (requestedFeaturePieces.length == 2) ? requestedFeaturePieces[1] : ""; String requestedFeatureName = requestedFeaturePieces[0];
String requestedFeatureArgs = (requestedFeaturePieces.length == 2) ? requestedFeaturePieces[1] : "";
int notYetSeenFeature = 0; int notYetSeenFeature = 0;
for ( Class featureClass : featureClasses ) { for ( Class featureClass : featureClasses ) {
String featureClassName = rationalizeClassName(featureClass); String featureClassName = rationalizeClassName(featureClass);
if (requestedFeatureName.equalsIgnoreCase(featureClassName)) { if (requestedFeatureName.equalsIgnoreCase(featureClassName)) {
try { try {
IndependentVariantFeature ivf = (IndependentVariantFeature) featureClass.newInstance(); IndependentVariantFeature ivf = (IndependentVariantFeature) featureClass.newInstance();
ivf.initialize(requestedFeatureArgs); ivf.initialize(requestedFeatureArgs);
variant.adjustLikelihoods(ivf.compute(ref, context)); variant.adjustLikelihoods(ivf.compute(ref, context));
if (VERBOSE) { out.println(featureClassName + ":\n " + variant); } if (VERBOSE) { out.println(featureClassName + ":\n " + variant); }
} catch (InstantiationException e) { } catch (InstantiationException e) {
throw new StingException(String.format("Cannot instantiate feature class '%s': must be concrete class", featureClass.getSimpleName())); throw new StingException(String.format("Cannot instantiate feature class '%s': must be concrete class", featureClass.getSimpleName()));
} catch (IllegalAccessException e) { } catch (IllegalAccessException e) {
throw new StingException(String.format("Cannot instantiate feature class '%s': must have no-arg constructor", featureClass.getSimpleName())); throw new StingException(String.format("Cannot instantiate feature class '%s': must have no-arg constructor", featureClass.getSimpleName()));
}
} else {
notYetSeenFeature++;
} }
} else {
notYetSeenFeature++;
} }
}
if (notYetSeenFeature == featureClasses.size()) { if (notYetSeenFeature == featureClasses.size()) {
throw new StingException(String.format("Unknown feature '%s'. Valid features are '%s'", requestedFeatureName, getAvailableClasses(featureClasses))); throw new StingException(String.format("Unknown feature '%s'. Valid features are '%s'", requestedFeatureName, getAvailableClasses(featureClasses)));
}
} }
} }
// Apply exclusion tests that accept or reject the variant call // Apply exclusion tests that accept or reject the variant call
ArrayList<String> exclusionResults = new ArrayList<String>(); ArrayList<String> exclusionResults = new ArrayList<String>();
for (String requestedExclusionString : EXCLUSIONS) { if (EXCLUSIONS != null) {
String[] requestedExclusionPieces = requestedExclusionString.split(":"); for (String requestedExclusionString : EXCLUSIONS) {
String requestedExclusionName = requestedExclusionPieces[0]; String[] requestedExclusionPieces = requestedExclusionString.split(":");
String requestedExclusionArgs = (requestedExclusionPieces.length == 2) ? requestedExclusionPieces[1] : ""; String requestedExclusionName = requestedExclusionPieces[0];
String requestedExclusionArgs = (requestedExclusionPieces.length == 2) ? requestedExclusionPieces[1] : "";
int notYetSeenExclusion = 0; int notYetSeenExclusion = 0;
for ( Class exclusionClass : exclusionClasses ) { for ( Class exclusionClass : exclusionClasses ) {
String exclusionClassName = rationalizeClassName(exclusionClass); String exclusionClassName = rationalizeClassName(exclusionClass);
if (requestedExclusionName.equalsIgnoreCase(exclusionClassName)) { if (requestedExclusionName.equalsIgnoreCase(exclusionClassName)) {
try { try {
VariantExclusionCriterion vec = (VariantExclusionCriterion) exclusionClass.newInstance(); VariantExclusionCriterion vec = (VariantExclusionCriterion) exclusionClass.newInstance();
vec.initialize(requestedExclusionArgs); vec.initialize(requestedExclusionArgs);
boolean excludeResult = vec.exclude(ref, context, variant); boolean excludeResult = vec.exclude(ref, context, variant);
if (excludeResult) { if (excludeResult) {
exclusionResults.add(exclusionClassName); exclusionResults.add(exclusionClassName);
}
} catch (InstantiationException e) {
throw new StingException(String.format("Cannot instantiate exclusion class '%s': must be concrete class", exclusionClass.getSimpleName()));
} catch (IllegalAccessException e) {
throw new StingException(String.format("Cannot instantiate exclusion class '%s': must have no-arg constructor", exclusionClass.getSimpleName()));
} }
} else {
} catch (InstantiationException e) { notYetSeenExclusion++;
throw new StingException(String.format("Cannot instantiate exclusion class '%s': must be concrete class", exclusionClass.getSimpleName()));
} catch (IllegalAccessException e) {
throw new StingException(String.format("Cannot instantiate exclusion class '%s': must have no-arg constructor", exclusionClass.getSimpleName()));
} }
} else {
notYetSeenExclusion++;
} }
}
if (notYetSeenExclusion == exclusionClasses.size()) { if (notYetSeenExclusion == exclusionClasses.size()) {
throw new StingException(String.format("Unknown exclusion '%s'. Valid exclusions are '%s'", requestedExclusionName, getAvailableClasses(exclusionClasses))); throw new StingException(String.format("Unknown exclusion '%s'. Valid exclusions are '%s'", requestedExclusionName, getAvailableClasses(exclusionClasses)));
}
} }
} }
if (exclusionResults.size() > 0) { if (exclusionResults.size() > 0) {
if (VERBOSE) { String exclusions = "";
String exclusions = ""; for (int i = 0; i < exclusionResults.size(); i++) {
for (int i = 0; i < exclusionResults.size(); i++) { exclusions += exclusionResults.get(i) + (i == exclusionResults.size() - 1 ? "" : ",");
exclusions += exclusionResults.get(i) + (i == exclusionResults.size() - 1 ? "" : ",");
PrintWriter writer = ewriters.get(exclusionResults.get(i));
if (writer != null) {
writer.println(variant);
} }
}
if (VERBOSE) {
out.printf("Exclusions: %s\n", exclusions); out.printf("Exclusions: %s\n", exclusions);
} }
} else { } else {
@ -221,5 +251,9 @@ public class VariantFiltrationWalker extends LocusWalker<Integer, Integer> {
out.printf("Processed %d loci.\n", result); out.printf("Processed %d loci.\n", result);
vwriter.close(); vwriter.close();
for (PrintWriter writer : ewriters.values()) {
writer.close();
}
} }
} }