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

the last-mile commit for Tribble integration. The system is now ready for Tribble to be turned on, as soon as we've removed any dependencies in the ROD code on interfaces that aren't in the Tribble library (i.e. the Variation or Genotype interface on RODs). All of the walkers should be up to date. 

a caveat: for anyone asking for all of the ROD's back from the RefMetaDataTracker (if your not using the facilities to get the track by name), you'll now be getting back a collection of GATKFeature objects.  This object will contain the track name, and a method for getting the underlying object (getUnderlyingObject()), which will be the traditional RodVCF, rodDbSNP, etc.  This layer is needed so we can integrate Tribble tracks (which don't natively have names).  Calls that ask for RODs by name will still get back the traditional reference ordered data objects (RodVCF, rodDbSNP, etc).

Sorry for the inconvenience!  More changes to come, but this is by far the largest (as has the greatest effect on end users).


git-svn-id: file:///humgen/gsa-scr1/gsa-engineering/svn_contents/trunk@3104 348d0f76-0448-11de-a6fe-93d51630548a
This commit is contained in:
aaron 2010-03-31 22:39:56 +00:00
parent 4fcee248f9
commit 3d3d19a6a7
77 changed files with 1042 additions and 1166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
java/src/org/broadinstitute/sting/gatk/GenomeAnalysisEngine.java
View File

@ -25,33 +25,32 @@
package org.broadinstitute.sting.gatk;
import net.sf.picard.reference.ReferenceSequenceFile;
import net.sf.picard.filter.SamRecordFilter;
import net.sf.picard.reference.ReferenceSequenceFile;
import net.sf.samtools.*;
import org.apache.log4j.Logger;
import org.broadinstitute.sting.gatk.datasources.simpleDataSources.*;
import org.broadinstitute.sting.gatk.arguments.GATKArgumentCollection;
import org.broadinstitute.sting.gatk.arguments.IntervalMergingRule;
import org.broadinstitute.sting.gatk.arguments.ValidationExclusion;
import org.broadinstitute.sting.gatk.datasources.shards.MonolithicShardStrategy;
import org.broadinstitute.sting.gatk.datasources.shards.Shard;
import org.broadinstitute.sting.gatk.datasources.shards.ShardStrategy;
import org.broadinstitute.sting.gatk.datasources.shards.ShardStrategyFactory;
import org.broadinstitute.sting.gatk.datasources.shards.Shard;
import org.broadinstitute.sting.gatk.datasources.shards.MonolithicShardStrategy;
import org.broadinstitute.sting.gatk.datasources.simpleDataSources.*;
import org.broadinstitute.sting.gatk.executive.MicroScheduler;
import org.broadinstitute.sting.gatk.arguments.GATKArgumentCollection;
import org.broadinstitute.sting.gatk.arguments.ValidationExclusion;
import org.broadinstitute.sting.gatk.arguments.IntervalMergingRule;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedData;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedDatum;
import org.broadinstitute.sting.gatk.walkers.*;
import org.broadinstitute.sting.gatk.filters.ZeroMappingQualityReadFilter;
import org.broadinstitute.sting.gatk.filters.FilterManager;
import org.broadinstitute.sting.gatk.filters.ReadGroupBlackListFilter;
import org.broadinstitute.sting.gatk.filters.ZeroMappingQualityReadFilter;
import org.broadinstitute.sting.gatk.io.OutputTracker;
import org.broadinstitute.sting.gatk.io.stubs.Stub;
import org.broadinstitute.sting.gatk.refdata.tracks.RMDTrack;
import org.broadinstitute.sting.gatk.refdata.tracks.RMDTrackManager;
import org.broadinstitute.sting.gatk.walkers.*;
import org.broadinstitute.sting.utils.*;
import org.broadinstitute.sting.utils.bed.BedParser;
import org.broadinstitute.sting.utils.fasta.IndexedFastaSequenceFile;
import org.broadinstitute.sting.utils.cmdLine.ArgumentException;
import org.broadinstitute.sting.utils.cmdLine.ArgumentSource;
import org.broadinstitute.sting.gatk.io.stubs.Stub;
import org.broadinstitute.sting.utils.fasta.IndexedFastaSequenceFile;
import java.io.File;
import java.io.FileNotFoundException;
@ -281,9 +280,6 @@ public class GenomeAnalysisEngine {
validateReadsAndReferenceAreCompatible(readsDataSource, referenceDataSource);
// our reference ordered data collection
List<ReferenceOrderedData<? extends ReferenceOrderedDatum>> rods = new ArrayList<ReferenceOrderedData<? extends ReferenceOrderedDatum>>();
//
// please don't use these in the future, use the new syntax <- if we're not using these please remove them
//
@ -297,12 +293,11 @@ public class GenomeAnalysisEngine {
bindConvenienceRods("interval", "Intervals", argCollection.intervals.get(0).replaceAll(",", ""));
}
// parse out the rod bindings
ReferenceOrderedData.parseBindings(argCollection.RODBindings, rods);
RMDTrackManager manager = new RMDTrackManager();
List<RMDTrack> tracks = manager.getReferenceMetaDataSources(argCollection.RODBindings);
validateSuppliedReferenceOrderedDataAgainstWalker(my_walker, tracks);
validateSuppliedReferenceOrderedDataAgainstWalker(my_walker, rods);
rodDataSources = getReferenceOrderedDataSources(my_walker, rods);
rodDataSources = getReferenceOrderedDataSources(my_walker, tracks);
}
/**
@ -571,12 +566,12 @@ public class GenomeAnalysisEngine {
* @param walker Walker to test.
* @param rods Reference-ordered data to load.
*/
private void validateSuppliedReferenceOrderedDataAgainstWalker(Walker walker, List<ReferenceOrderedData<? extends ReferenceOrderedDatum>> rods) {
private void validateSuppliedReferenceOrderedDataAgainstWalker(Walker walker, List<RMDTrack> rods) {
// Check to make sure that all required metadata is present.
List<RMD> allRequired = WalkerManager.getRequiredMetaData(walker);
for (RMD required : allRequired) {
boolean found = false;
for (ReferenceOrderedData<? extends ReferenceOrderedDatum> rod : rods) {
for (RMDTrack rod : rods) {
if (rod.matches(required.name(), required.type()))
found = true;
}
@ -585,7 +580,7 @@ public class GenomeAnalysisEngine {
}
// Check to see that no forbidden rods are present.
for (ReferenceOrderedData<? extends ReferenceOrderedDatum> rod : rods) {
for (RMDTrack rod : rods) {
if (!WalkerManager.isAllowed(walker, rod))
throw new ArgumentException(String.format("Walker of type %s does not allow access to metadata: %s. If this is incorrect, change the @Allows metadata", walker.getClass(), rod.getName()));
}
@ -812,9 +807,9 @@ public class GenomeAnalysisEngine {
* @param rods the reference order data to execute using
* @return A list of reference-ordered data sources.
*/
private List<ReferenceOrderedDataSource> getReferenceOrderedDataSources(Walker walker, List<ReferenceOrderedData<? extends ReferenceOrderedDatum>> rods) {
private List<ReferenceOrderedDataSource> getReferenceOrderedDataSources(Walker walker, List<RMDTrack> rods) {
List<ReferenceOrderedDataSource> dataSources = new ArrayList<ReferenceOrderedDataSource>();
for (ReferenceOrderedData<? extends ReferenceOrderedDatum> rod : rods)
for (RMDTrack rod : rods)
dataSources.add(new ReferenceOrderedDataSource(walker, rod));
return dataSources;
}

27
java/src/org/broadinstitute/sting/gatk/WalkerManager.java
View File

@ -25,20 +25,19 @@
package org.broadinstitute.sting.gatk;
import java.util.*;
import org.broadinstitute.sting.gatk.walkers.*;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedDatum;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedData;
import org.broadinstitute.sting.gatk.filters.FilterManager;
import org.broadinstitute.sting.utils.StingException;
import org.broadinstitute.sting.utils.PluginManager;
import org.broadinstitute.sting.utils.TextFormattingUtils;
import org.broadinstitute.sting.utils.help.DisplayNameTaglet;
import org.broadinstitute.sting.utils.help.DescriptionTaglet;
import org.broadinstitute.sting.utils.help.SummaryTaglet;
import org.apache.log4j.Logger;
import net.sf.picard.filter.SamRecordFilter;
import org.apache.log4j.Logger;
import org.broadinstitute.sting.gatk.filters.FilterManager;
import org.broadinstitute.sting.gatk.refdata.tracks.RMDTrack;
import org.broadinstitute.sting.gatk.walkers.*;
import org.broadinstitute.sting.utils.PluginManager;
import org.broadinstitute.sting.utils.StingException;
import org.broadinstitute.sting.utils.TextFormattingUtils;
import org.broadinstitute.sting.utils.help.DescriptionTaglet;
import org.broadinstitute.sting.utils.help.DisplayNameTaglet;
import org.broadinstitute.sting.utils.help.SummaryTaglet;
import java.util.*;
/**
* Created by IntelliJ IDEA.
@ -184,7 +183,7 @@ public class WalkerManager extends PluginManager<Walker> {
* @param rod Source to check.
* @return True if the walker forbids this data type. False otherwise.
*/
public static boolean isAllowed(Walker walker, ReferenceOrderedData<? extends ReferenceOrderedDatum> rod) {
public static boolean isAllowed(Walker walker, RMDTrack rod) {
Allows allowsDataSource = getWalkerAllowed(walker);
// Allows is less restrictive than requires. If an allows

20
java/src/org/broadinstitute/sting/gatk/datasources/providers/RODMetaDataContainer.java
View File

@ -1,6 +1,6 @@
package org.broadinstitute.sting.gatk.datasources.providers;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedDatum;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeature;
import org.broadinstitute.sting.utils.Pair;
import java.util.*;
@ -23,26 +23,26 @@ import java.util.*;
*/
public class RODMetaDataContainer {
// we only allow non-dupplicate ROD names, a HashMap is fine
private final HashMap<String, ReferenceOrderedDatum> nameMap = new HashMap<String, ReferenceOrderedDatum>();
private final HashMap<String, GATKFeature> nameMap = new HashMap<String, GATKFeature>();
// we do allow duplicate class entries, so we need to store pairs of data
private final List<Pair<Class, ReferenceOrderedDatum>> classMap = new ArrayList<Pair<Class, ReferenceOrderedDatum>>();
private final List<Pair<Class, GATKFeature>> classMap = new ArrayList<Pair<Class, GATKFeature>>();
public void addEntry(ReferenceOrderedDatum data) {
public void addEntry(GATKFeature data) {
nameMap.put(data.getName(),data);
classMap.add(new Pair<Class, ReferenceOrderedDatum>(data.getClass(),data));
classMap.add(new Pair<Class, GATKFeature>(data.getClass(),data));
}
public Collection<ReferenceOrderedDatum> getSet(String name) {
public Collection<GATKFeature> getSet(String name) {
if (name == null) return nameMap.values();
Set<ReferenceOrderedDatum> set = new HashSet<ReferenceOrderedDatum>();
Set<GATKFeature> set = new HashSet<GATKFeature>();
if (nameMap.containsKey(name)) set.add(nameMap.get(name));
return set;
}
// the brute force (n) search ended up being faster than sorting and binary search in all but the most extreme cases (thousands of RODs at a location).
public Collection<ReferenceOrderedDatum> getSet(Class cls) {
Collection<ReferenceOrderedDatum> ret = new ArrayList<ReferenceOrderedDatum>();
for (Pair<Class, ReferenceOrderedDatum> pair: classMap)
public Collection<GATKFeature> getSet(Class cls) {
Collection<GATKFeature> ret = new ArrayList<GATKFeature>();
for (Pair<Class, GATKFeature> pair: classMap)
if (pair.first.equals(cls)) ret.add(pair.second);
return ret;
}

13
java/src/org/broadinstitute/sting/gatk/datasources/providers/ReadBasedReferenceOrderedView.java
View File

@ -26,14 +26,17 @@ package org.broadinstitute.sting.gatk.datasources.providers;
import net.sf.samtools.SAMRecord;
import org.broadinstitute.sting.gatk.datasources.simpleDataSources.ReferenceOrderedDataSource;
import org.broadinstitute.sting.gatk.refdata.ReadMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedDatum;
import org.broadinstitute.sting.gatk.refdata.utils.FlashBackIterator;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeature;
import org.broadinstitute.sting.gatk.refdata.utils.LocationAwareSeekableRODIterator;
import org.broadinstitute.sting.gatk.refdata.utils.RODRecordList;
import org.broadinstitute.sting.utils.GenomeLoc;
import org.broadinstitute.sting.utils.GenomeLocParser;
import java.util.*;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.TreeMap;
/** a ROD view for reads. This provides the Read traversals a way of getting a ReadMetaDataTracker */
public class ReadBasedReferenceOrderedView implements View {
@ -71,7 +74,7 @@ public class ReadBasedReferenceOrderedView implements View {
/** stores a window of data, dropping RODs if we've passed the new reads start point. */
class WindowedData {
// the queue of possibly in-frame RODs; RODs are dropped removed as soon as they are out of scope
// the queue of possibly in-frame RODs; RODs are removed as soon as they are out of scope
private final TreeMap<Long, RODMetaDataContainer> mapping = new TreeMap<Long, RODMetaDataContainer>();
// our current location from the last read we processed
@ -102,7 +105,7 @@ class WindowedData {
states = new ArrayList<RMDDataState>();
if (provider != null && provider.getReferenceOrderedData() != null)
for (ReferenceOrderedDataSource dataSource : provider.getReferenceOrderedData())
states.add(new RMDDataState(dataSource, (LocationAwareSeekableRODIterator)dataSource.seek(GenomeLocParser.createGenomeLoc(rec.getReferenceIndex(), rec.getAlignmentStart()))));
states.add(new RMDDataState(dataSource, dataSource.seek(GenomeLocParser.createGenomeLoc(rec.getReferenceIndex(), rec.getAlignmentStart()))));
}
/**
@ -147,7 +150,7 @@ class WindowedData {
state.iterator.next();
while (state.iterator.hasNext() && state.iterator.peekNextLocation().overlapsP(currentLoc)) {
RODRecordList list = state.iterator.next();
for (ReferenceOrderedDatum datum : list) {
for (GATKFeature datum : list) {
if (!mapping.containsKey(list.getLocation().getStart()))
mapping.put(list.getLocation().getStart(), new RODMetaDataContainer());
mapping.get(list.getLocation().getStart()).addEntry(datum);

21
java/src/org/broadinstitute/sting/gatk/datasources/simpleDataSources/ReferenceOrderedDataSource.java
View File

@ -1,10 +1,8 @@
package org.broadinstitute.sting.gatk.datasources.simpleDataSources;
import org.broadinstitute.sting.gatk.refdata.IntervalRod;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedDatum;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedData;
import org.broadinstitute.sting.gatk.datasources.shards.Shard;
import org.broadinstitute.sting.gatk.refdata.SeekableRODIterator;
import org.broadinstitute.sting.gatk.refdata.tracks.RMDTrack;
import org.broadinstitute.sting.gatk.refdata.utils.FlashBackIterator;
import org.broadinstitute.sting.gatk.refdata.utils.LocationAwareSeekableRODIterator;
import org.broadinstitute.sting.gatk.walkers.ReadWalker;
@ -12,7 +10,6 @@ import org.broadinstitute.sting.gatk.walkers.Walker;
import org.broadinstitute.sting.utils.GenomeLoc;
import org.broadinstitute.sting.utils.StingException;
import java.util.Iterator;
import java.util.List;
/**
* User: hanna
@ -34,7 +31,7 @@ public class ReferenceOrderedDataSource implements SimpleDataSource {
/**
* The reference-ordered data itself.
*/
private final ReferenceOrderedData rod;
private final RMDTrack rod;
/**
* A pool of iterators for navigating through the genome.
@ -45,8 +42,9 @@ public class ReferenceOrderedDataSource implements SimpleDataSource {
* Create a new reference-ordered data source.
* @param rod
*/
public ReferenceOrderedDataSource( Walker walker, ReferenceOrderedData rod) {
public ReferenceOrderedDataSource( Walker walker, RMDTrack rod) {
this.rod = rod;
// if (!rod.supportsQuery()) // TODO: Aaron turn on to enable Tribble searches
this.iteratorPool = new ReferenceOrderedDataPool( walker, rod );
}
@ -55,14 +53,14 @@ public class ReferenceOrderedDataSource implements SimpleDataSource {
* @return Name of the underlying rod.
*/
public String getName() {
return this.rod.getName();
return this.rod.getName().toLowerCase(); // TODO: Aaron fix this. this is a hack, because RODs always lowercased their names, but in for consistency for now
}
/**
* Return the underlying reference-ordered data.
* @return the underlying rod.
*/
public ReferenceOrderedData getReferenceOrderedData() {
public RMDTrack getReferenceOrderedData() {
return this.rod;
}
@ -105,9 +103,9 @@ public class ReferenceOrderedDataSource implements SimpleDataSource {
* A pool of reference-ordered data iterators.
*/
class ReferenceOrderedDataPool extends ResourcePool<LocationAwareSeekableRODIterator, LocationAwareSeekableRODIterator> {
private final ReferenceOrderedData<? extends ReferenceOrderedDatum> rod;
private final RMDTrack rod;
boolean flashbackData = false;
public ReferenceOrderedDataPool( Walker walker, ReferenceOrderedData<? extends ReferenceOrderedDatum> rod ) {
public ReferenceOrderedDataPool( Walker walker, RMDTrack rod ) {
if (walker instanceof ReadWalker) flashbackData = true; // && (rod.getType() != IntervalRod.class)
this.rod = rod;
}
@ -118,7 +116,8 @@ class ReferenceOrderedDataPool extends ResourcePool<LocationAwareSeekableRODIter
* @return The newly created resource.
*/
public LocationAwareSeekableRODIterator createNewResource() {
return (flashbackData) ? new FlashBackIterator(rod.iterator()) : rod.iterator();
LocationAwareSeekableRODIterator iter = new SeekableRODIterator(rod.getIterator());
return (flashbackData) ? new FlashBackIterator(iter) : iter;
}
/**

44
java/src/org/broadinstitute/sting/gatk/refdata/RODRecordListImpl.java
View File

@ -1,5 +1,6 @@
package org.broadinstitute.sting.gatk.refdata;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeature;
import org.broadinstitute.sting.gatk.refdata.utils.RODRecordList;
import org.broadinstitute.sting.utils.GenomeLoc;
import org.broadinstitute.sting.utils.StingException;
@ -13,43 +14,43 @@ import java.util.*;
* Time: 6:10:48 PM
* To change this template use File | Settings | File Templates.
*/
public class RODRecordListImpl extends AbstractList<ReferenceOrderedDatum> implements Comparable<RODRecordList>, Cloneable, RODRecordList {
private List<ReferenceOrderedDatum> records;
public class RODRecordListImpl extends AbstractList<GATKFeature> implements Comparable<RODRecordList>, Cloneable, RODRecordList {
private List<GATKFeature> records;
private GenomeLoc location = null;
private String name = null;
public RODRecordListImpl(String name) {
records = new ArrayList<ReferenceOrderedDatum>();
records = new ArrayList<GATKFeature>();
this.name = name;
}
/**
* Fully qualified constructor: instantiates a new ReferenceOrderedDatumRecordList object with specified ReferenceOrderedDatum track name, location on the
* reference, and list of associated ReferenceOrderedDatums. This is a knee-deep COPY constructor: passed name, loc, and data element
* objects will be referenced from the created ReferenceOrderedDatumRecordList (so that changing them from outside will affect data
* Fully qualified constructor: instantiates a new GATKFeatureRecordList object with specified GATKFeature track name, location on the
* reference, and list of associated GATKFeatures. This is a knee-deep COPY constructor: passed name, loc, and data element
* objects will be referenced from the created GATKFeatureRecordList (so that changing them from outside will affect data
* in this object), however, the data elements will be copied into a newly
* allocated list, so that the 'data' collection argument can be modified afterwards without affecting the state
* of this record list. WARNING: this constructor is (semi-)validating: passed name and location
* are allowed to be nulls (although it maybe unsafe, use caution), but if they are not nulls, then passed non-null ReferenceOrderedDatum data
* are allowed to be nulls (although it maybe unsafe, use caution), but if they are not nulls, then passed non-null GATKFeature data
* elements must have same track name, and their locations must overlap with the passed 'location' argument. Null
* data elements or null 'data' collection argument are allowed as well.
* @param name
* @param data
* @param loc
* @param name the name of the track
* @param data the collection of features at this location
* @param loc the location
*/
public RODRecordListImpl(String name, Collection<ReferenceOrderedDatum> data, GenomeLoc loc) {
this.records = new ArrayList<ReferenceOrderedDatum>(data==null?0:data.size());
public RODRecordListImpl(String name, Collection<GATKFeature> data, GenomeLoc loc) {
this.records = new ArrayList<GATKFeature>(data==null?0:data.size());
this.name = name;
this.location = loc;
if ( data == null || data.size() == 0 ) return; // empty dataset, nothing to do
for ( ReferenceOrderedDatum r : data ) {
for ( GATKFeature r : data ) {
records.add(r);
if ( r == null ) continue;
if ( ! this.name.equals(r.getName() ) ) {
throw new StingException("Attempt to add ReferenceOrderedDatum with non-matching name "+r.getName()+" to the track "+name);
throw new StingException("Attempt to add GATKFeature with non-matching name "+r.getName()+" to the track "+name);
}
if ( location != null && ! location.overlapsP(r.getLocation()) ) {
throw new StingException("Attempt to add ReferenceOrderedDatum that lies outside of specified interval "+location+"; offending ReferenceOrderedDatum:\n"+r.toString());
throw new StingException("Attempt to add GATKFeature that lies outside of specified interval "+location+"; offending GATKFeature:\n"+r.toString());
}
}
}
@ -57,22 +58,21 @@ public class RODRecordListImpl extends AbstractList<ReferenceOrderedDatum> imple
public GenomeLoc getLocation() { return location; }
public String getName() { return name; }
public List<ReferenceOrderedDatum> getRecords() { return records; }
public Iterator<ReferenceOrderedDatum> iterator() { return records.iterator() ; }
public Iterator<GATKFeature> iterator() { return records.iterator() ; }
public void clear() { records.clear(); }
public boolean isEmpty() { return records.isEmpty(); }
public boolean add(ReferenceOrderedDatum record) { add(record, false); return true;}
public boolean add(GATKFeature record) { add(record, false); return true;}
@Override
public ReferenceOrderedDatum get(int i) {
public GATKFeature get(int i) {
return records.get(i);
}
public void add(ReferenceOrderedDatum record, boolean allowNameMismatch) {
public void add(GATKFeature record, boolean allowNameMismatch) {
if ( record != null ) {
if ( ! allowNameMismatch && ! name.equals(record.getName() ) )
throw new StingException("Attempt to add ReferenceOrderedDatum with non-matching name "+record.getName()+" to the track "+name);
throw new StingException("Attempt to add GATKFeature with non-matching name "+record.getName()+" to the track "+name);
}
records.add(record);
}
@ -80,7 +80,7 @@ public class RODRecordListImpl extends AbstractList<ReferenceOrderedDatum> imple
public void add(RODRecordList records ) { add( records, false ); }
public void add(RODRecordList records, boolean allowNameMismatch) {
for ( ReferenceOrderedDatum record : records )
for ( GATKFeature record : records )
add(record, allowNameMismatch);
}

28
java/src/org/broadinstitute/sting/gatk/refdata/ReadMetaDataTracker.java
View File

@ -25,10 +25,14 @@ package org.broadinstitute.sting.gatk.refdata;
import net.sf.samtools.SAMRecord;
import org.broadinstitute.sting.gatk.datasources.providers.RODMetaDataContainer;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeature;
import org.broadinstitute.sting.utils.GenomeLoc;
import org.broadinstitute.sting.utils.GenomeLocParser;
import java.util.*;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.TreeMap;
/**
@ -65,15 +69,15 @@ public class ReadMetaDataTracker {
*
* @return a mapping from the position in the read to the reference ordered datum
*/
private Map<Long, Collection<ReferenceOrderedDatum>> createReadAlignment(SAMRecord record, TreeMap<Long, RODMetaDataContainer> queue, Class cl, String name) {
private Map<Long, Collection<GATKFeature>> createReadAlignment(SAMRecord record, TreeMap<Long, RODMetaDataContainer> queue, Class cl, String name) {
if (name != null && cl != null) throw new IllegalStateException("Both a class and name cannot be specified");
Map<Long, Collection<ReferenceOrderedDatum>> ret = new LinkedHashMap<Long, Collection<ReferenceOrderedDatum>>();
Map<Long, Collection<GATKFeature>> ret = new LinkedHashMap<Long, Collection<GATKFeature>>();
GenomeLoc location = GenomeLocParser.createGenomeLoc(record);
int length = record.getReadLength();
for (Long loc : queue.keySet()) {
Long position = loc - location.getStart();
if (position >= 0 && position < length) {
Collection<ReferenceOrderedDatum> set;
Collection<GATKFeature> set;
if (cl != null)
set = queue.get(loc).getSet(cl);
else
@ -91,8 +95,8 @@ public class ReadMetaDataTracker {
*
* @return a mapping from the position in the read to the reference ordered datum
*/
private Map<Long, Collection<ReferenceOrderedDatum>> createGenomeLocAlignment(SAMRecord record, TreeMap<Long, RODMetaDataContainer> mapping, Class cl, String name) {
Map<Long, Collection<ReferenceOrderedDatum>> ret = new LinkedHashMap<Long, Collection<ReferenceOrderedDatum>>();
private Map<Long, Collection<GATKFeature>> createGenomeLocAlignment(SAMRecord record, TreeMap<Long, RODMetaDataContainer> mapping, Class cl, String name) {
Map<Long, Collection<GATKFeature>> ret = new LinkedHashMap<Long, Collection<GATKFeature>>();
int start = record.getAlignmentStart();
int stop = record.getAlignmentEnd();
for (Long location : mapping.keySet()) {
@ -110,7 +114,7 @@ public class ReadMetaDataTracker {
*
* @return a mapping of read offset to ROD(s)
*/
public Map<Long, Collection<ReferenceOrderedDatum>> getReadOffsetMapping() {
public Map<Long, Collection<GATKFeature>> getReadOffsetMapping() {
return createReadAlignment(record, mapping, null, null);
}
@ -119,7 +123,7 @@ public class ReadMetaDataTracker {
*
* @return a mapping of genome loc position to ROD(s)
*/
public Map<Long, Collection<ReferenceOrderedDatum>> getContigOffsetMapping() {
public Map<Long, Collection<GATKFeature>> getContigOffsetMapping() {
return createGenomeLocAlignment(record, mapping, null, null);
}
@ -128,7 +132,7 @@ public class ReadMetaDataTracker {
*
* @return a mapping of read offset to ROD(s)
*/
public Map<Long, Collection<ReferenceOrderedDatum>> getReadOffsetMapping(String name) {
public Map<Long, Collection<GATKFeature>> getReadOffsetMapping(String name) {
return createReadAlignment(record, mapping, null, name);
}
@ -137,7 +141,7 @@ public class ReadMetaDataTracker {
*
* @return a mapping of genome loc position to ROD(s)
*/
public Map<Long, Collection<ReferenceOrderedDatum>> getContigOffsetMapping(String name) {
public Map<Long, Collection<GATKFeature>> getContigOffsetMapping(String name) {
return createGenomeLocAlignment(record, mapping, null, name);
}
@ -146,7 +150,7 @@ public class ReadMetaDataTracker {
*
* @return a mapping of read offset to ROD(s)
*/
public Map<Long, Collection<ReferenceOrderedDatum>> getReadOffsetMapping(Class cl) {
public Map<Long, Collection<GATKFeature>> getReadOffsetMapping(Class cl) {
return createReadAlignment(record, mapping, cl, null);
}
@ -155,7 +159,7 @@ public class ReadMetaDataTracker {
*
* @return a mapping of genome loc position to ROD(s)
*/
public Map<Long, Collection<ReferenceOrderedDatum>> getContigOffsetMapping(Class cl) {
public Map<Long, Collection<GATKFeature>> getContigOffsetMapping(Class cl) {
return createGenomeLocAlignment(record, mapping, cl, null);
}
}

266
java/src/org/broadinstitute/sting/gatk/refdata/RefMetaDataTracker.java
View File

@ -1,8 +1,9 @@
package org.broadinstitute.sting.gatk.refdata;
import org.apache.log4j.Logger;
import org.broadinstitute.sting.gatk.contexts.variantcontext.VariantContext;
import org.broadinstitute.sting.gatk.contexts.variantcontext.Allele;
import org.broadinstitute.sting.gatk.contexts.variantcontext.VariantContext;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeature;
import org.broadinstitute.sting.gatk.refdata.utils.RODRecordList;
import org.broadinstitute.sting.utils.GenomeLoc;
import org.broadinstitute.sting.utils.StingException;
@ -11,14 +12,14 @@ import java.util.*;
/**
* This class represents the Reference Metadata available at a particular site in the genome. It can be
* used to conveniently lookup the RODs at this site, as well just getting a list of all of the RODs
* used to conveniently lookup the RMDs at this site, as well just getting a list of all of the RMDs
*
* The standard interaction model is:
*
* Traversal system arrives at a site, which has a bunch of rods covering it
Genotype * Traversal calls tracker.bind(name, rod) for each rod in rods
* Traversal system arrives at a site, which has a bunch of RMDs covering it
Genotype * Traversal calls tracker.bind(name, RMD) for each RMDs in RMDs
* Traversal passes tracker to the walker
* walker calls lookup(name, default) to obtain the rod values at this site, or default if none was
* walker calls lookup(name, default) to obtain the RMDs values at this site, or default if none was
* bound at this site.
*
* User: mdepristo
@ -29,101 +30,72 @@ public class RefMetaDataTracker {
final HashMap<String, RODRecordList> map = new HashMap<String, RODRecordList>();
protected static Logger logger = Logger.getLogger(RefMetaDataTracker.class);
/**
* Finds the reference meta data named name, if it exists, otherwise returns the defaultValue.
* This is a legacy method that works with "singleton" tracks, in which a single ROD record can be associated
* with any given site. If track provides multiple records associated with a site, this method will return
* the first one.
* @param name
* @param defaultValue
* @return
* get all the reference meta data associated with a track name.
* @param name the name of the track we're looking for
* @return a list of objects, representing the underlying objects that the tracks produce. I.e. for a
* dbSNP RMD this will be a RodDbSNP, etc.
*
* Important: The list returned by this function is guaranteed not to be null, but may be empty!
*/
public List<Object> getReferenceMetaData(final String name) {
RODRecordList list = getTrackDataByName(name, true);
List<Object> objects = new ArrayList<Object>();
if (list == null) return objects;
for (GATKFeature feature : list)
objects.add(feature.getUnderlyingObject());
return objects;
}
/**
* get all the reference meta data associated with a track name.
* @param name the name of the track we're looking for
* @param requireExactMatch do we require an exact match for the name (true) or do we require only that the name starts with
* the passed in parameter (false).
* @return a list of objects, representing the underlying objects that the tracks produce. I.e. for a
* dbSNP rod this will be a RodDbSNP, etc.
*
* Important: The list returned by this function is guaranteed not to be null, but may be empty!
*/
public List<Object> getReferenceMetaData(final String name, boolean requireExactMatch) {
RODRecordList list = getTrackDataByName(name, requireExactMatch);
List<Object> objects = new ArrayList<Object>();
if (list == null) return objects;
for (GATKFeature feature : list)
objects.add(feature.getUnderlyingObject());
return objects;
}
/**
* get a singleton record, given the name and a type. This function will return the first record at the current position seen,
* and emit a logger warning if there were more than one option.
*
* WARNING: this method is deprecated, since we now suppport more than one RMD at a single position for all tracks. If there are
* are multiple RMD objects at this location, there is no contract for which object this method will pick, and which object gets
* picked may change from time to time! BE WARNED!
*
* @param name the name of the track
* @param clazz the underlying type to return
* @param <T> the type to parameterize on, matching the clazz argument
* @return a record of type T, or null if no record is present.
*/
@Deprecated
public ReferenceOrderedDatum lookup(final String name, ReferenceOrderedDatum defaultValue) {
//logger.debug(String.format("Lookup %s%n", name));
final String luName = canonicalName(name);
if ( map.containsKey(luName) ) {
RODRecordList value = map.get(luName) ;
if ( value != null ) {
List<ReferenceOrderedDatum> l = value;
if ( l != null & l.size() > 0 ) return value.get(0);
}
}
return defaultValue;
}
public <T> T lookup(final String name, Class<T> clazz) {
RODRecordList objects = getTrackDataByName(name, true);
/**
* Finds the reference metadata track named 'name' and returns all ROD records from that track associated
* with the current site as a RODRecordList collection object. If no data track with specified name is available,
* returns defaultValue wrapped as RODRecordList object. NOTE: if defaultValue is null, it will be wrapped up
* with track name set to 'name' and location set to null; otherwise the wrapper object will have name and
* location set to defaultValue.getName() and defaultValue.getLocation(), respectively (use caution,
* defaultValue.getLocation() may be not equal to what RODRecordList's location would be expected to be otherwise:
* for instance, on locus traversal, location is usually expected to be a single base we are currently looking at,
* regardless of the presence of "extended" RODs overlapping with that location).
* @param name
* @param defaultValue
* @return
*/
public RODRecordList getTrackData(final String name, ReferenceOrderedDatum defaultValue, boolean requireExactMatch) {
//logger.debug(String.format("Lookup %s%n", name));
// if emtpy or null return null;
if (objects == null || objects.size() < 1) return null;
final String luName = canonicalName(name);
RODRecordList trackData = null;
if (objects.size() > 1)
logger.info("lookup is choosing the first record from " + (objects.size() - 1) + " options");
if ( requireExactMatch ) {
if ( map.containsKey(luName) )
trackData = map.get(luName);
} else {
for ( Map.Entry<String, RODRecordList> datum : map.entrySet() ) {
final String rodName = datum.getKey();
if ( rodName.startsWith(luName) ) {
if ( trackData == null ) trackData = new RODRecordListImpl(name);
//System.out.printf("Adding bindings from %s to %s at %s%n", rodName, name, datum.getValue().getLocation());
((RODRecordListImpl)trackData).add(datum.getValue(), true);
}
}
}
Object obj = objects.get(0).getUnderlyingObject();
if (!(clazz.isAssignableFrom(obj.getClass())))
throw new StingException("Unable to case track named " + name + " to type of " + clazz.toString()
+ " it's of type " + obj.getClass());
if ( trackData != null )
return trackData;
else if ( defaultValue == null )
return null;
else
return new RODRecordListImpl(defaultValue.getName(),
Collections.singletonList(defaultValue),
defaultValue.getLocation());
}
public RODRecordList getTrackData(final String name, ReferenceOrderedDatum defaultValue) {
return getTrackData(name, defaultValue, true);
}
/**
* @see this.lookup
* @param name
* @param defaultValue
* @return
*/
@Deprecated
public Object lookup(final String name, Object defaultValue) {
final String luName = canonicalName(name);
if ( map.containsKey(luName) )
return map.get(luName);
else
return defaultValue;
}
/**
* Returns the canonical name of the rod name
* @param name
* @return
*/
private final String canonicalName(final String name)
{
//return name; // .toLowerCase();
return name.toLowerCase();
return (T)obj;
}
/**
@ -133,17 +105,18 @@ public class RefMetaDataTracker {
* @return true if it has the rod
*/
public boolean hasROD(final String name) {
return map.containsKey(canonicalName(name));
return map.containsKey(canonicalName(name));
}
/**
* Get all of the RODs at the current site. The collection is "flattened": for any track that has multiple records
* Get all of the RMDs at the current site. The collection is "flattened": for any track that has multiple records
* at the current site, they all will be added to the list as separate elements.
*
*
* @return
*/
public Collection<ReferenceOrderedDatum> getAllRods() {
List<ReferenceOrderedDatum> l = new ArrayList<ReferenceOrderedDatum>();
public Collection<GATKFeature> getAllRods() {
List<GATKFeature> l = new ArrayList<GATKFeature>();
for ( RODRecordList rl : map.values() ) {
if ( rl == null ) continue; // how do we get null value stored for a track? shouldn't the track be missing from the map alltogether?
l.addAll(rl);
@ -153,16 +126,16 @@ public class RefMetaDataTracker {
}
/**
* Get all of the ROD tracks at the current site. Each track is returned as a single compound
* object (RODRecordList) that may contain multiple ROD records associated with the current site.
* Get all of the RMD tracks at the current site. Each track is returned as a single compound
* object (RODRecordList) that may contain multiple RMD records associated with the current site.
*
* @return
*/
public Collection<RODRecordList> getBoundRodTracks() {
LinkedList<RODRecordList> bound = new LinkedList<RODRecordList>();
for ( RODRecordList value : map.values() ) {
if ( value != null && value.size() != 0 ) bound.add(value);
if ( value != null && value.size() != 0 ) bound.add(value);
}
return bound;
@ -177,26 +150,26 @@ public class RefMetaDataTracker {
int n = 0;
for ( RODRecordList value : map.values() ) {
if ( value != null && ! value.isEmpty() ) {
if ( exclude == null || ! value.getName().equals(exclude) )
if ( value != null && ! value.isEmpty() ) {
if ( exclude == null || ! value.getName().equals(exclude) )
n++;
}
}
}
return n;
}
public Collection<ReferenceOrderedDatum> getBoundRodRecords() {
LinkedList<ReferenceOrderedDatum> bound = new LinkedList<ReferenceOrderedDatum>();
for ( RODRecordList valueList : map.values() ) {
for ( ReferenceOrderedDatum value : valueList ) {
if ( value != null )
bound.add(value);
}
}
return bound;
/**
* Binds the list of reference ordered data records (RMDs) to track name at this site. Should be used only by the traversal
* system to provide access to RMDs in a structured way to the walkers.
*
* @param name the name of the track
* @param rod the collection of RMD data
*/
public void bind(final String name, RODRecordList rod) {
//logger.debug(String.format("Binding %s to %s", name, rod));
map.put(canonicalName(name), rod);
}
@ -208,7 +181,6 @@ public class RefMetaDataTracker {
return getAllVariantContexts(null, null, false, false);
}
/**
* Converts all possible ROD tracks to VariantContexts objects. If allowedTypes != null, then only
* VariantContexts in the allow set of types will be returned. If requireStartsHere is true, then curLocation
@ -264,7 +236,7 @@ public class RefMetaDataTracker {
Collection<VariantContext> contexts = new ArrayList<VariantContext>();
for ( String name : names ) {
RODRecordList rodList = getTrackData(name, null);
RODRecordList rodList = getTrackDataByName(name,true); // require that the name is an exact match
if ( rodList != null )
addVariantContexts(contexts, rodList, allowedTypes, curLocation, ref, requireStartHere, takeFirstOnly );
@ -294,17 +266,18 @@ public class RefMetaDataTracker {
return contexts.iterator().next();
}
private void addVariantContexts(Collection<VariantContext> contexts, RODRecordList rodList, EnumSet<VariantContext.Type> allowedTypes, GenomeLoc curLocation, Allele ref, boolean requireStartHere, boolean takeFirstOnly ) {
for ( ReferenceOrderedDatum rec : rodList ) {
if ( VariantContextAdaptors.canBeConvertedToVariantContext(rec) ) {
for ( GATKFeature rec : rodList ) {
if ( VariantContextAdaptors.canBeConvertedToVariantContext(rec.getUnderlyingObject()) ) {
// ok, we might actually be able to turn this record in a variant context
VariantContext vc;
if ( ref == null )
vc = VariantContextAdaptors.toVariantContext(rodList.getName(), rec);
vc = VariantContextAdaptors.toVariantContext(rodList.getName(), rec.getUnderlyingObject());
else
vc = VariantContextAdaptors.toVariantContext(rodList.getName(), rec, ref);
vc = VariantContextAdaptors.toVariantContext(rodList.getName(), rec.getUnderlyingObject(), ref);
if ( vc == null ) // sometimes the track has odd stuff in it that can't be converted
if ( vc == null ) // sometimes the track has odd stuff in it that can't be converted
continue;
// now, let's decide if we want to keep it
@ -322,16 +295,49 @@ public class RefMetaDataTracker {
}
}
/**
* Finds the reference metadata track named 'name' and returns all ROD records from that track associated
* with the current site as a RODRecordList collection object. If no data track with specified name is available,
* returns defaultValue wrapped as RODRecordList object. NOTE: if defaultValue is null, it will be wrapped up
* with track name set to 'name' and location set to null; otherwise the wrapper object will have name and
* location set to defaultValue.getName() and defaultValue.getLocation(), respectively (use caution,
* defaultValue.getLocation() may be not equal to what RODRecordList's location would be expected to be otherwise:
* for instance, on locus traversal, location is usually expected to be a single base we are currently looking at,
* regardless of the presence of "extended" RODs overlapping with that location).
* @param name
* @return
*/
private RODRecordList getTrackDataByName(final String name, boolean requireExactMatch) {
//logger.debug(String.format("Lookup %s%n", name));
final String luName = canonicalName(name);
RODRecordList trackData = null;
if ( requireExactMatch ) {
if ( map.containsKey(luName) )
trackData = map.get(luName);
} else {
for ( Map.Entry<String, RODRecordList> datum : map.entrySet() ) {
final String rodName = datum.getKey();
if ( rodName.startsWith(luName) ) {
if ( trackData == null ) trackData = new RODRecordListImpl(name);
//System.out.printf("Adding bindings from %s to %s at %s%n", rodName, name, datum.getValue().getLocation());
((RODRecordListImpl)trackData).add(datum.getValue(), true);
}
}
}
if ( trackData != null )
return trackData;
else
return null;
}
/**
* Binds the list of reference ordered data records (RODs) to track name at this site. Should be used only by the traversal
* system to provide access to RODs in a structured way to the walkers.
*
* @param name
* @param rod
* Returns the canonical name of the rod name (lowercases it)
* @param name the name of the rod
* @return
*/
public void bind(final String name, RODRecordList rod) {
//logger.debug(String.format("Binding %s to %s", name, rod));
map.put(canonicalName(name), rod);
private final String canonicalName(final String name) {
return name.toLowerCase();
}
}

271
java/src/org/broadinstitute/sting/gatk/refdata/ReferenceOrderedData.java
View File

@ -1,19 +1,13 @@
package org.broadinstitute.sting.gatk.refdata;
import org.apache.log4j.Logger;
import org.broadinstitute.sting.gatk.refdata.tracks.RMDTrack;
import org.broadinstitute.sting.gatk.refdata.tracks.RMDTrackCreationException;
import org.broadinstitute.sting.gatk.refdata.tracks.RODRMDTrack;
import org.broadinstitute.sting.gatk.refdata.tracks.builders.RMDTrackBuilder;
import org.broadinstitute.sting.gatk.refdata.utils.LocationAwareSeekableRODIterator;
import org.broadinstitute.sting.gatk.refdata.utils.RODRecordList;
import org.broadinstitute.sting.oneoffprojects.refdata.HapmapVCFROD;
import org.broadinstitute.sting.utils.StingException;
import org.broadinstitute.sting.utils.Utils;
import java.io.*;
import java.lang.reflect.Method;
import java.util.*;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* Class for representing arbitrary reference ordered data sets
@ -23,7 +17,7 @@ import java.util.*;
* Time: 10:47:14 AM
* To change this template use File | Settings | File Templates.
*/
public class ReferenceOrderedData<ROD extends ReferenceOrderedDatum> implements Iterable<RODRecordList> {
public class ReferenceOrderedData<ROD extends ReferenceOrderedDatum> implements Iterable<ReferenceOrderedDatum> {
private String name;
private File file = null;
// private String fieldDelimiter;
@ -36,102 +30,6 @@ public class ReferenceOrderedData<ROD extends ReferenceOrderedDatum> implements
/** our log, which we want to capture anything from this class */
private static Logger logger = Logger.getLogger(ReferenceOrderedData.class);
// ----------------------------------------------------------------------
//
// Static ROD type management
//
// ----------------------------------------------------------------------
public static class RODBinding {
public final String name;
public final Class<? extends ReferenceOrderedDatum> type;
public RODBinding(final String name, final Class<? extends ReferenceOrderedDatum> type) {
this.name = name;
this.type = type;
}
}
public static HashMap<String, RODBinding> Types = new HashMap<String, RODBinding>();
public static void addModule(final String name, final Class<? extends ReferenceOrderedDatum> rodType) {
final String boundName = name.toLowerCase();
if (Types.containsKey(boundName)) {
throw new RuntimeException(String.format("GATK BUG: adding ROD module %s that is already bound", boundName));
}
logger.info(String.format("* Adding rod class %s", name));
Types.put(boundName, new RODBinding(name, rodType));
}
static {
// All known ROD types
addModule("GFF", RodGenotypeChipAsGFF.class);
addModule("dbSNP", rodDbSNP.class);
addModule("HapMapAlleleFrequencies", HapMapAlleleFrequenciesROD.class);
addModule("SAMPileup", rodSAMPileup.class);
addModule("GELI", rodGELI.class);
addModule("RefSeq", rodRefSeq.class);
addModule("Table", TabularROD.class);
addModule("PooledEM", PooledEMSNPROD.class);
addModule("CleanedOutSNP", CleanedOutSNPROD.class);
addModule("Sequenom", SequenomROD.class);
addModule("SangerSNP", SangerSNPROD.class);
addModule("SimpleIndel", SimpleIndelROD.class);
addModule("PointIndel", PointIndelROD.class);
addModule("HapMapGenotype", HapMapGenotypeROD.class);
addModule("Intervals", IntervalRod.class);
addModule("Variants", RodGeliText.class);
addModule("GLF", RodGLF.class);
addModule("VCF", RodVCF.class);
addModule("PicardDbSNP", rodPicardDbSNP.class);
addModule("HapmapVCF", HapmapVCFROD.class);
addModule("Beagle", BeagleROD.class);
addModule("Plink", PlinkRod.class);
}
/**
* Parse the ROD bindings. These are of the form of a single list of strings, each triplet of the
* form <name>,<type>,<file>. After this function, the List of RODs contains new RODs bound to each of
* name, of type, ready to read from the file. This function does check for the strings to be well formed
* and such.
*
* @param bindings
* @param rods
*/
public static void parseBindings(ArrayList<String> bindings, List<ReferenceOrderedData<? extends ReferenceOrderedDatum>> rods) {
// pre-process out any files that were passed in as rod binding command line options
for (int x = 0; x < bindings.size(); x++) {
if (new File(bindings.get(x)).exists()) {
extractRodsFromFile(bindings, bindings.get(x));
bindings.remove(x);
x--;
}
}
// Loop over triplets
for (String bindingSets : bindings) {
String[] bindingTokens = bindingSets.split(",");
if (bindingTokens.length % 3 != 0)
Utils.scareUser(String.format("Invalid ROD specification: requires triplets of <name>,<type>,<file> but got %s", Utils.join(",", bindings)));
for (int bindingSet = 0; bindingSet < bindingTokens.length; bindingSet += 3) {
logger.info("Processing ROD bindings: " + bindings.size() + " -> " + Utils.join(" : ", bindingTokens));
final String name = bindingTokens[bindingSet];
final String typeName = bindingTokens[bindingSet + 1];
final String fileName = bindingTokens[bindingSet + 2];
ReferenceOrderedData<?> rod = parse1Binding(name, typeName, fileName);
// check that we're not generating duplicate bindings
for (ReferenceOrderedData rod2 : rods)
if (rod2.getName().equals(rod.getName()))
Utils.scareUser(String.format("Found duplicate rod bindings", rod.getName()));
rods.add(rod);
}
}
}
/**
* given an existing file, open it and append all the valid triplet lines to an existing list
*
@ -156,28 +54,6 @@ public class ReferenceOrderedData<ROD extends ReferenceOrderedDatum> implements
}
}
/**
* Helpful function that parses a single triplet of <name> <type> <file> and returns the corresponding ROD with
* <name>, of type <type> that reads its input from <file>.
*
* @param trackName
* @param typeName
* @param fileName
* @return
*/
public static ReferenceOrderedData<?> parse1Binding(final String trackName, final String typeName, final String fileName) {
// Gracefully fail if we don't have the type
if (ReferenceOrderedData.Types.get(typeName.toLowerCase()) == null)
Utils.scareUser(String.format("Unknown ROD type: %s", typeName));
// Lookup the type
Class rodClass = ReferenceOrderedData.Types.get(typeName.toLowerCase()).type;
// Create the ROD
ReferenceOrderedData<?> rod = new ReferenceOrderedData<ReferenceOrderedDatum>(trackName.toLowerCase(), new File(fileName), rodClass );
logger.info(String.format("Created binding from %s to %s of type %s", trackName.toLowerCase(), fileName, rodClass));
return rod;
}
// ----------------------------------------------------------------------
//
@ -212,7 +88,7 @@ public class ReferenceOrderedData<ROD extends ReferenceOrderedDatum> implements
return this.name.equals(name) && type.isAssignableFrom(this.type);
}
public LocationAwareSeekableRODIterator iterator() {
public Iterator<ReferenceOrderedDatum> iterator() {
Iterator<ReferenceOrderedDatum> it;
try {
Method m = type.getDeclaredMethod("createIterator", String.class, java.io.File.class);
@ -231,7 +107,7 @@ public class ReferenceOrderedData<ROD extends ReferenceOrderedDatum> implements
throw new RuntimeException(e);
}
// return new RODIterator<ROD>(it);
return new SeekableRODIterator(it);
return it;
}
// ----------------------------------------------------------------------
@ -239,20 +115,6 @@ public class ReferenceOrderedData<ROD extends ReferenceOrderedDatum> implements
// Manipulations of all of the data
//
// ----------------------------------------------------------------------
public ArrayList<ReferenceOrderedDatum> readAll() {
ArrayList<ReferenceOrderedDatum> elts = new ArrayList<ReferenceOrderedDatum>();
for ( List<ReferenceOrderedDatum> l : this ) {
for (ReferenceOrderedDatum rec : l) {
elts.add(rec);
}
}
elts.trimToSize();
return elts;
}
public static void sortRODDataInMemory(ArrayList<ReferenceOrderedDatum> data) {
Collections.sort(data);
}
public static void write(ArrayList<ReferenceOrderedDatum> data, File output) throws IOException {
final FileWriter out = new FileWriter(output);
@ -264,126 +126,5 @@ public class ReferenceOrderedData<ROD extends ReferenceOrderedDatum> implements
out.close();
}
public boolean validateFile() throws Exception {
ReferenceOrderedDatum last = null;
for ( List<ReferenceOrderedDatum> l : this ) {
for (ReferenceOrderedDatum rec : l) {
if (last != null && last.compareTo(rec) > 1) {
// It's out of order
throw new Exception("Out of order elements at \n" + last.toString() + "\n" + rec.toString());
}
last = rec;
}
}
return true;
}
public void indexFile() {
// Fixme -- get access to the linear index system from Jim
}
// ----------------------------------------------------------------------
//
// Iteration
//
// ----------------------------------------------------------------------
// private class SimpleRODIterator implements Iterator<ROD> {
// private xReadLines parser = null;
//
// public SimpleRODIterator() {
// try {
// parser = new xReadLines(file);
// } catch (FileNotFoundException e) {
// Utils.scareUser("Couldn't open file: " + file);
// }
// }
//
// public boolean hasNext() {
// //System.out.printf("Parser has next: %b%n", parser.hasNext());
// return parser.hasNext();
// }
//
// public ROD next() {
// ROD n = null;
// boolean success = false;
// boolean firstFailure = true;
//
// do {
// final String line = parser.next();
// //System.out.printf("Line is '%s'%n", line);
// String parts[] = line.split(fieldDelimiter);
//
// try {
// n = parseLine(parts);
// // Two failure conditions:
// // 1) parseLine throws an exception.
// // 2) parseLine returns null.
// // 3) parseLine throws a RuntimeException.
// // TODO: Clean this up so that all errors are handled in one spot.
// success = (n != null);
// }
// catch (MalformedGenomeLocException ex) {
// if (firstFailure) {
// Utils.warnUser("Failed to parse contig on line '" + line + "'. The reason given was: " + ex.getMessage() + " Skipping ahead to the next recognized GenomeLoc. ");
// firstFailure = false;
// }
// if (!parser.hasNext())
// Utils.warnUser("Unable to find more valid reference-ordered data. Giving up.");
// }
//
// } while (!success && parser.hasNext());
//
// return n;
// }
//
// public void remove() {
// throw new UnsupportedOperationException();
// }
// }
// ----------------------------------------------------------------------
//
// Parsing
//
// ----------------------------------------------------------------------
// private Constructor<ROD> parsing_constructor;
// private ROD newROD(final String name, final Class<ROD> type) {
// try {
// return (ROD) parsing_constructor.newInstance(name);
// } catch (java.lang.InstantiationException e) {
// throw new RuntimeException(e);
// } catch (java.lang.IllegalAccessException e) {
// throw new RuntimeException(e);
// } catch (InvocationTargetException e) {
// throw new RuntimeException(e);
// }
// }
// private Object initializeROD(final String name, final File file, final Class<ROD> type) {
// try {
// parsing_constructor = type.getConstructor(String.class);
// }
// catch (java.lang.NoSuchMethodException e) {
// throw new RuntimeException(e);
// }
// ROD rod = newROD(name, type);
// try {
// return rod.initialize(file);
// } catch (FileNotFoundException e) {
// throw new RuntimeException(e);
// }
// }
// private ROD parseLine(final String[] parts) {
// //System.out.printf("Parsing GFFLine %s%n", Utils.join(" ", parts));
// ROD obj = newROD(name, type);
// try {
// if (!obj.parseLine(header, parts))
// obj = null;
// } catch (IOException e) {
// throw new RuntimeException("Badly formed ROD: " + e);
// }
// return obj;
// }
}

27
java/src/org/broadinstitute/sting/gatk/refdata/SeekableRODIterator.java
View File

@ -1,6 +1,7 @@
package org.broadinstitute.sting.gatk.refdata;
import org.broadinstitute.sting.gatk.iterators.PushbackIterator;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeature;
import org.broadinstitute.sting.gatk.refdata.utils.LocationAwareSeekableRODIterator;
import org.broadinstitute.sting.gatk.refdata.utils.RODRecordList;
import org.broadinstitute.sting.utils.GenomeLoc;
@ -8,8 +9,8 @@ import org.broadinstitute.sting.utils.GenomeLocParser;
import org.broadinstitute.sting.utils.StingException;
import java.util.Iterator;
import java.util.List;
import java.util.LinkedList;
import java.util.List;
/**
* Wrapper class for iterators over ROD objects. It is assumed that the underlying iterator can only
@ -35,8 +36,8 @@ import java.util.LinkedList;
* To change this template use File | Settings | File Templates.
*/
public class SeekableRODIterator implements LocationAwareSeekableRODIterator {
private PushbackIterator<ReferenceOrderedDatum> it;
List<ReferenceOrderedDatum> records = null; // here we will keep a pile of records overlaping with current position; when we iterate
private PushbackIterator<GATKFeature> it;
List<GATKFeature> records = null; // here we will keep a pile of records overlaping with current position; when we iterate
// and step out of record's scope, we purge it from the list
String name = null; // name of the ROD track wrapped by this iterator. Will be pulled from underlying iterator.
@ -77,15 +78,15 @@ public class SeekableRODIterator implements LocationAwareSeekableRODIterator {
// This implementation tracks the query history and makes next() illegal after a seekforward query of length > 1,
// but re-enables next() again after a length-1 query.
public SeekableRODIterator(Iterator<ReferenceOrderedDatum> it) {
this.it = new PushbackIterator<ReferenceOrderedDatum>(it);
records = new LinkedList<ReferenceOrderedDatum>();
public SeekableRODIterator(Iterator<GATKFeature> it) {
this.it = new PushbackIterator<GATKFeature>(it);
records = new LinkedList<GATKFeature>();
// the following is a trick: we would like the iterator to know the actual name assigned to
// the ROD implementing object we are working with. But the only way to do that is to
// get an instance of that ROD and query it for its name. Now, the only generic way we have at this point to instantiate
// the ROD is to make the underlying stream iterator to do it for us. So we are reading (or rather peeking into)
// the first line of the track data file just to get the ROD object created.
ReferenceOrderedDatum r = null;
GATKFeature r = null;
if (this.it.hasNext()) r = this.it.element();
name = (r==null?null:r.getName());
}
@ -114,7 +115,7 @@ public class SeekableRODIterator implements LocationAwareSeekableRODIterator {
// the location we will jump to upon next call to next() is the start of the next ROD record that we did
// not read yet:
if ( it.hasNext() ) {
ReferenceOrderedDatum r = it.element(); // peek, do not load!
GATKFeature r = it.element(); // peek, do not load!
return GenomeLocParser.createGenomeLoc(r.getLocation().getContigIndex(),r.getLocation().getStart());
}
return null; // underlying iterator has no more records, there is no next location!
@ -142,7 +143,7 @@ public class SeekableRODIterator implements LocationAwareSeekableRODIterator {
// ooops, we are past the end of all loaded records - kill them all at once,
// load next record and reinitialize by fastforwarding current position to the start of next record
records.clear();
ReferenceOrderedDatum r = it.next(); // if hasNext() previously returned true, we are guaranteed that this call to reader.next() is safe
GATKFeature r = it.next(); // if hasNext() previously returned true, we are guaranteed that this call to reader.next() is safe
records.add( r );
curr_contig = r.getLocation().getContigIndex();
curr_position = r.getLocation().getStart();
@ -155,7 +156,7 @@ public class SeekableRODIterator implements LocationAwareSeekableRODIterator {
// covered by new records, so we need to load them too:
while ( it.hasNext() ) {
ReferenceOrderedDatum r = it.element();
GATKFeature r = it.element();
if ( r == null ) {
it.next();
continue;
@ -284,7 +285,7 @@ public class SeekableRODIterator implements LocationAwareSeekableRODIterator {
// curr_contig and curr_position are set to where we asked to scroll to
while ( it.hasNext() ) {
ReferenceOrderedDatum r = it.next();
GATKFeature r = it.next();
if ( r == null ) continue;
int that_contig = r.getLocation().getContigIndex();
@ -323,9 +324,9 @@ public class SeekableRODIterator implements LocationAwareSeekableRODIterator {
* curr_position <= max_position, as well as that we are still on the same contig.
*/
private void purgeOutOfScopeRecords() {
Iterator<ReferenceOrderedDatum> i = records.iterator();
Iterator<GATKFeature> i = records.iterator();
while ( i.hasNext() ) {
ReferenceOrderedDatum r = i.next();
GATKFeature r = i.next();
if ( r.getLocation().getStop() < curr_position ) {
i.remove(); // we moved past the end of interval the record r is associated with, purge the record forever
}

7
java/src/org/broadinstitute/sting/gatk/refdata/rodDbSNP.java
View File

@ -1,7 +1,6 @@
package org.broadinstitute.sting.gatk.refdata;
import net.sf.samtools.util.SequenceUtil;
import org.broadinstitute.sting.gatk.refdata.utils.RODRecordList;
import org.broadinstitute.sting.utils.*;
import java.util.ArrayList;
@ -281,13 +280,13 @@ public class rodDbSNP extends BasicReferenceOrderedDatum implements VariationRod
return getAlternateAlleleList().size() == 1;
}
public static rodDbSNP getFirstRealSNP(RODRecordList dbsnpList) {
public static rodDbSNP getFirstRealSNP(List<Object> dbsnpList) {
if (dbsnpList == null)
return null;
rodDbSNP dbsnp = null;
for (ReferenceOrderedDatum d : dbsnpList) {
if (((rodDbSNP) d).isSNP()) {
for (Object d : dbsnpList) {
if (d instanceof rodDbSNP && ((rodDbSNP) d).isSNP()) {
dbsnp = (rodDbSNP) d;
break;
}

19
java/src/org/broadinstitute/sting/gatk/refdata/rodRefSeq.java
View File

@ -1,12 +1,13 @@
package org.broadinstitute.sting.gatk.refdata;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeature;
import org.broadinstitute.sting.gatk.refdata.utils.RODRecordList;
import org.broadinstitute.sting.utils.GenomeLoc;
import org.broadinstitute.sting.utils.StingException;
import org.broadinstitute.sting.utils.GenomeLocParser;
import org.broadinstitute.sting.utils.StingException;
import java.util.List;
import java.util.ArrayList;
import java.util.List;
/**
* Created by IntelliJ IDEA.
@ -135,7 +136,7 @@ public class rodRefSeq extends BasicReferenceOrderedDatum implements Transcript
* rodRefSeq though: takes list of rods (transcripts) overlapping with a given position and determines whether
* this position is fully whithin an exon of <i>any</i> of those transcripts. Passing null is safe (will return false).
* NOTE: position can be still within a UTR, see #isCoding
* @return
* @return true if it's an exon
*/
public static boolean isExon(RODRecordList l) {
@ -143,8 +144,8 @@ public class rodRefSeq extends BasicReferenceOrderedDatum implements Transcript
GenomeLoc loc = l.getLocation();
for ( ReferenceOrderedDatum t : l ) {
if ( ((rodRefSeq)t).overlapsExonP(loc) ) return true;
for ( GATKFeature t : l ) {
if ( ((rodRefSeq)t.getUnderlyingObject()).overlapsExonP(loc) ) return true;
}
return false;
@ -166,8 +167,8 @@ public class rodRefSeq extends BasicReferenceOrderedDatum implements Transcript
GenomeLoc loc = l.getLocation();
for ( ReferenceOrderedDatum t : l ) {
if ( ((rodRefSeq)t).overlapsCodingP(loc) ) return true;
for ( GATKFeature t : l ) {
if ( ((rodRefSeq)t.getUnderlyingObject()).overlapsCodingP(loc) ) return true;
}
return false;
@ -186,8 +187,8 @@ public class rodRefSeq extends BasicReferenceOrderedDatum implements Transcript
GenomeLoc loc = l.getLocation();
for ( ReferenceOrderedDatum t : l ) {
if ( ((rodRefSeq)t).overlapsCodingP(loc) && ((rodRefSeq)t).overlapsExonP(loc) ) return true;
for ( GATKFeature t : l ) {
if ( ((rodRefSeq)t.getUnderlyingObject()).overlapsCodingP(loc) && ((rodRefSeq)t.getUnderlyingObject()).overlapsExonP(loc) ) return true;
}
return false;

5
java/src/org/broadinstitute/sting/gatk/refdata/tracks/RMDTrack.java
View File

@ -26,6 +26,7 @@ package org.broadinstitute.sting.gatk.refdata.tracks;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeature;
import java.io.File;
import java.lang.reflect.Type;
import java.util.Iterator;
@ -82,8 +83,8 @@ public abstract class RMDTrack {
*
* @return true on a match, false if the name or type is different
*/
public boolean matches(String name, String type) {
return (name.equals(this.name) && type.equals(this.type.getSimpleName()));
public boolean matches(String name, Type type) {
return (name.equals(this.name) && (type.getClass().isAssignableFrom(this.type.getClass())));
}
/**

21
java/src/org/broadinstitute/sting/gatk/refdata/tracks/RMDTrackManager.java
View File

@ -27,7 +27,6 @@ import org.broadinstitute.sting.gatk.refdata.tracks.builders.RMDTrackBuilder;
import org.broadinstitute.sting.gatk.refdata.utils.RMDTriplet;
import org.broadinstitute.sting.utils.PluginManager;
import org.broadinstitute.sting.utils.StingException;
import org.broadinstitute.sting.utils.Utils;
import java.io.File;
import java.util.ArrayList;
@ -52,7 +51,7 @@ public class RMDTrackManager extends PluginManager<RMDTrackBuilder> {
Map<String, Class> availableTrackClasses;
/** Create a new track plugin manager. */
protected RMDTrackManager() {
public RMDTrackManager() {
super(RMDTrackBuilder.class, "TrackBuilders", null);
}
@ -66,17 +65,18 @@ public class RMDTrackManager extends PluginManager<RMDTrackBuilder> {
public List<RMDTrack> getReferenceMetaDataSources(List<String> triplets) {
if (availableTracks == null || availableTrackClasses == null) initialize(triplets);
// try and make the tracks given their requests
return createTracksRequestedTrackObjects(availableTracks, availableTrackClasses);
return createRequestedTrackObjects(availableTracks, availableTrackClasses);
}
/**
* initialize our lists of tracks and builders
* @param triplets the input to the GATK, as a list of strings passed in through the -B options
*/
private void initialize(List<String> triplets) {
if (triplets.size() % 3 != 0) throw new StingException("Incorect ROD line " + Utils.join(" ", triplets));
for (int x = 0; x < triplets.size(); x = x + 3) {
inputs.add(new RMDTriplet(triplets.get(x), triplets.get(x + 1), triplets.get(x + 2)));
private void initialize(List<String> triplets) {
for (String value: triplets) {
String[] split = value.split(",");
if (split.length != 3) throw new IllegalArgumentException(value + " is not a valid reference metadata track description");
inputs.add(new RMDTriplet(split[0], split[1], split[2]));
}
// create an active mapping of builder instances, and a map of the name -> class for convenience
@ -97,7 +97,6 @@ public class RMDTrackManager extends PluginManager<RMDTrackBuilder> {
for (String name : builder.getAvailableTrackNamesAndTypes().keySet()) {
availableTracks.put(name.toUpperCase(), builder);
availableTrackClasses.put(name.toUpperCase(), builder.getAvailableTrackNamesAndTypes().get(name));
System.err.println("Adding track " + name.toUpperCase());
}
}
}
@ -110,15 +109,15 @@ public class RMDTrackManager extends PluginManager<RMDTrackBuilder> {
*
* @return a list of the tracks, one for each of the requested input tracks
*/
private List<RMDTrack> createTracksRequestedTrackObjects(Map<String, RMDTrackBuilder> availableTracks, Map<String, Class> availableTrackClasses) {
private List<RMDTrack> createRequestedTrackObjects(Map<String, RMDTrackBuilder> availableTracks, Map<String, Class> availableTrackClasses) {
// create of live instances of the tracks
List<RMDTrack> tracks = new ArrayList<RMDTrack>();
// create instances of each of the requested types
for (RMDTriplet trip : inputs) {
RMDTrackBuilder b = availableTracks.get(trip.getType());
RMDTrackBuilder b = availableTracks.get(trip.getType().toUpperCase());
if (b == null) throw new StingException("Unable to find track for " + trip.getType());
tracks.add(b.createInstanceOfTrack(availableTrackClasses.get(trip.getType()), trip.getName(), new File(trip.getFile())));
tracks.add(b.createInstanceOfTrack(availableTrackClasses.get(trip.getType().toUpperCase()), trip.getName(), new File(trip.getFile())));
}
return tracks;
}

38
java/src/org/broadinstitute/sting/gatk/refdata/tracks/RODRMDTrack.java
View File

@ -25,8 +25,7 @@ package org.broadinstitute.sting.gatk.refdata.tracks;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedData;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeature;
import org.broadinstitute.sting.gatk.refdata.utils.LocationAwareSeekableRODIterator;
import org.broadinstitute.sting.gatk.refdata.utils.RODRecordList;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeatureIterator;
import java.io.File;
import java.util.Iterator;
@ -66,7 +65,7 @@ public class RODRMDTrack extends RMDTrack {
*/
@Override
public Iterator<GATKFeature> getIterator() {
return new RODIteratorToRMDIterator(data.iterator());
return new GATKFeatureIterator(data.iterator());
}
/**
@ -80,36 +79,3 @@ public class RODRMDTrack extends RMDTrack {
}
}
/**
* this class wraps a ROD iterator, so that it produces GATKFeatures (basicly features that can generate a GenomeLoc
* for its position).
*/
class RODIteratorToRMDIterator implements Iterator<GATKFeature> {
private RODRecordList list = null;
private LocationAwareSeekableRODIterator iterator = null;
RODIteratorToRMDIterator(LocationAwareSeekableRODIterator iter) {
iterator = iter;
}
public boolean hasNext() {
if (this.list != null && list.size() > 0) return true;
return iterator.hasNext();
}
public GATKFeature next() {
if (this.list != null && list.size() > 0) {
GATKFeature f = new GATKFeature.RODGATKFeature(list.get(0));
list.remove(0);
return f;
}
else {
list = iterator.next();
return next();
}
}
public void remove() {
throw new UnsupportedOperationException("not supported");
}
}

87
java/src/org/broadinstitute/sting/gatk/refdata/tracks/builders/RODTrackBuilder.java
View File

@ -47,41 +47,35 @@ public class RODTrackBuilder implements RMDTrackBuilder {
/** our log, which we want to capture anything from this class */
private static Logger logger = Logger.getLogger(ReferenceOrderedData.class);
public static HashMap<String, ReferenceOrderedData.RODBinding> Types = new HashMap<String, ReferenceOrderedData.RODBinding>();
public static void addModule(final String name, final Class<? extends ReferenceOrderedDatum> rodType) {
final String boundName = name.toLowerCase();
if (Types.containsKey(boundName)) {
throw new RuntimeException(String.format("GATK BUG: adding ROD module %s that is already bound", boundName));
}
logger.info(String.format("* Adding rod class %s", name));
Types.put(boundName, new ReferenceOrderedData.RODBinding(name, rodType));
}
/**
* the bindings from track name to the ROD class we use
*/
private static HashMap<String, Class<? extends ReferenceOrderedDatum>> Types = new HashMap<String, Class<? extends ReferenceOrderedDatum>>();
static {
// All known ROD types
addModule("GFF", RodGenotypeChipAsGFF.class);
//addModule("dbSNP", rodDbSNP.class);
addModule("HapMapAlleleFrequencies", HapMapAlleleFrequenciesROD.class);
addModule("SAMPileup", rodSAMPileup.class);
addModule("GELI", rodGELI.class);
addModule("RefSeq", rodRefSeq.class);
addModule("Table", TabularROD.class);
addModule("PooledEM", PooledEMSNPROD.class);
addModule("CleanedOutSNP", CleanedOutSNPROD.class);
addModule("Sequenom", SequenomROD.class);
addModule("SangerSNP", SangerSNPROD.class);
addModule("SimpleIndel", SimpleIndelROD.class);
addModule("PointIndel", PointIndelROD.class);
addModule("HapMapGenotype", HapMapGenotypeROD.class);
addModule("Intervals", IntervalRod.class);
addModule("Variants", RodGeliText.class);
addModule("GLF", RodGLF.class);
addModule("VCF", RodVCF.class);
addModule("PicardDbSNP", rodPicardDbSNP.class);
addModule("HapmapVCF", HapmapVCFROD.class);
addModule("Beagle", BeagleROD.class);
addModule("Plink", PlinkRod.class);
Types.put("GFF", RodGenotypeChipAsGFF.class);
Types.put("dbSNP", rodDbSNP.class);
Types.put("HapMapAlleleFrequencies", HapMapAlleleFrequenciesROD.class);
Types.put("SAMPileup", rodSAMPileup.class);
Types.put("GELI", rodGELI.class);
Types.put("RefSeq", rodRefSeq.class);
Types.put("Table", TabularROD.class);
Types.put("PooledEM", PooledEMSNPROD.class);
Types.put("CleanedOutSNP", CleanedOutSNPROD.class);
Types.put("Sequenom", SequenomROD.class);
Types.put("SangerSNP", SangerSNPROD.class);
Types.put("SimpleIndel", SimpleIndelROD.class);
Types.put("PointIndel", PointIndelROD.class);
Types.put("HapMapGenotype", HapMapGenotypeROD.class);
Types.put("Intervals", IntervalRod.class);
Types.put("Variants", RodGeliText.class);
Types.put("GLF", RodGLF.class);
Types.put("VCF", RodVCF.class);
Types.put("PicardDbSNP", rodPicardDbSNP.class);
Types.put("HapmapVCF", HapmapVCFROD.class);
Types.put("Beagle", BeagleROD.class);
Types.put("Plink", PlinkRod.class);
}
/**
@ -97,15 +91,32 @@ public class RODTrackBuilder implements RMDTrackBuilder {
*/
//@Override
public RMDTrack createInstanceOfTrack(Class targetClass, String name, File inputFile) throws RMDTrackCreationException {
return new RODRMDTrack(targetClass, name, inputFile, ReferenceOrderedData.parse1Binding(name,targetClass.getName(),inputFile.getAbsolutePath()));
return new RODRMDTrack(targetClass, name, inputFile, createROD(name,targetClass,inputFile));
}
/** @return a map of all available tracks we currently have access to create */
//@Override
/** @return a map of all available tracks we currently have access to create */
public Map<String, Class> getAvailableTrackNamesAndTypes() {
Map<String, Class> ret = new HashMap<String, Class>();
for (ReferenceOrderedData.RODBinding binding: Types.values())
ret.put(binding.name, binding.type);
for (String name : Types.keySet())
ret.put(name, Types.get(name));
return ret;
}
}
/**
* Helpful function that parses a single triplet of <name> <type> <file> and returns the corresponding ROD with
* <name>, of type <type> that reads its input from <file>.
*
* @param trackName the name of the track to create
* @param type the type of the track to create
* @param fileName the filename to create the track from
* @return a reference ordered data track
*/
public ReferenceOrderedData createROD(final String trackName, Class type, File fileName) {
// Create the ROD
ReferenceOrderedData<?> rod = new ReferenceOrderedData<ReferenceOrderedDatum>(trackName.toLowerCase(), fileName, type );
logger.info(String.format("Created binding from %s to %s of type %s", trackName.toLowerCase(), fileName, type));
return rod;
}
}

4
java/src/org/broadinstitute/sting/gatk/refdata/tracks/builders/TribbleRMDTrackBuilder.java
View File

@ -64,8 +64,8 @@ public class TribbleRMDTrackBuilder extends PluginManager<FeatureCodec> implemen
@Override
public Map<String, Class> getAvailableTrackNamesAndTypes() {
Map<String, Class> classes = new HashMap<String, Class>();
for (String c : this.pluginsByName.keySet())
classes.put(c,this.pluginsByName.get(c));
//for (String c : this.pluginsByName.keySet()) // TODO: Aaron uncomment these two lines when Tribble is live
// if (!c.contains("SNP")) classes.put(c,this.pluginsByName.get(c));
return classes;
}

59
java/src/org/broadinstitute/sting/gatk/refdata/utils/GATKFeatureIterator.java 100644
View File

@ -0,0 +1,59 @@
/*
* Copyright (c) 2010. The Broad Institute
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use,
* copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following
* conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
* THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/
package org.broadinstitute.sting.gatk.refdata.utils;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedDatum;
import java.util.Iterator;
/**
*
* @author aaron
*
* Class GATKFeatureIterator
*
* Takes a RODatum iterator and makes it an iterator of GATKFeatures. Shazam!
*/
public class GATKFeatureIterator implements Iterator<GATKFeature> {
private final Iterator<ReferenceOrderedDatum> iter;
public GATKFeatureIterator(Iterator<ReferenceOrderedDatum> iter) {
this.iter = iter;
}
@Override
public boolean hasNext() {
return iter.hasNext();
}
@Override
public GATKFeature next() {
return new GATKFeature.RODGATKFeature(iter.next());
}
@Override
public void remove() {
throw new UnsupportedOperationException("Remove not supported");
}
}

3
java/src/org/broadinstitute/sting/gatk/refdata/utils/RODRecordList.java
View File

@ -23,7 +23,6 @@
package org.broadinstitute.sting.gatk.refdata.utils;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedDatum;
import org.broadinstitute.sting.utils.GenomeLoc;
import java.util.List;
@ -37,7 +36,7 @@ import java.util.List;
* make the RODRecord list an interface, so we can stub in other implementations
* during testing.
*/
public interface RODRecordList extends List<ReferenceOrderedDatum>, Comparable<RODRecordList> {
public interface RODRecordList extends List<GATKFeature>, Comparable<RODRecordList> {
public GenomeLoc getLocation();
public String getName();
}

22
java/src/org/broadinstitute/sting/gatk/walkers/PileupWalker.java
View File

@ -26,14 +26,15 @@ package org.broadinstitute.sting.gatk.walkers;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedDatum;
import org.broadinstitute.sting.gatk.refdata.rodDbSNP;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.utils.pileup.ReadBackedPileup;
import org.broadinstitute.sting.utils.pileup.ReadBackedExtendedEventPileup;
import org.broadinstitute.sting.utils.Utils;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeature;
import org.broadinstitute.sting.utils.Pair;
import org.broadinstitute.sting.utils.Utils;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.utils.pileup.ReadBackedExtendedEventPileup;
import org.broadinstitute.sting.utils.pileup.ReadBackedPileup;
import java.util.ArrayList;
import java.util.List;
@ -140,15 +141,16 @@ public class PileupWalker extends LocusWalker<Integer, Integer> implements TreeR
*/
private String getReferenceOrderedData( RefMetaDataTracker tracker ) {
ArrayList<String> rodStrings = new ArrayList<String>();
for ( ReferenceOrderedDatum datum : tracker.getAllRods() ) {
if ( datum != null && ! (datum instanceof rodDbSNP)) {
rodStrings.add(datum.toSimpleString());
for ( GATKFeature datum : tracker.getAllRods() ) {
if ( datum != null && ! (datum.getUnderlyingObject() instanceof rodDbSNP)) {
rodStrings.add(((ReferenceOrderedDatum)datum.getUnderlyingObject()).toSimpleString()); // TODO: Aaron figure out what to do with this line, it's bad form
}
}
String rodString = Utils.join(", ", rodStrings);
rodDbSNP dbsnp = (rodDbSNP)tracker.lookup("dbSNP", null);
if ( dbsnp != null )
rodDbSNP dbsnp = tracker.lookup("dbSNP",rodDbSNP.class);
if ( dbsnp != null)
rodString += dbsnp.toMediumString();
if ( !rodString.equals("") )

10
java/src/org/broadinstitute/sting/gatk/walkers/PrintRODsWalker.java
View File

@ -25,8 +25,10 @@
package org.broadinstitute.sting.gatk.walkers;
import org.broadinstitute.sting.gatk.contexts.*;
import org.broadinstitute.sting.gatk.refdata.*;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeature;
import org.broadinstitute.sting.utils.genotype.Variation;
import java.util.Iterator;
@ -56,9 +58,9 @@ public class PrintRODsWalker extends RodWalker<Integer, Integer> {
if ( tracker == null )
return 0;
Iterator<ReferenceOrderedDatum> rods = tracker.getAllRods().iterator();
Iterator<GATKFeature> rods = tracker.getAllRods().iterator();
while ( rods.hasNext() ) {
ReferenceOrderedDatum rod = rods.next();
Object rod = rods.next().getUnderlyingObject();
if ( rod instanceof Variation )
out.println(rod.toString());
}

9
java/src/org/broadinstitute/sting/gatk/walkers/RMD.java
View File

@ -1,8 +1,9 @@
package org.broadinstitute.sting.gatk.walkers;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedDatum;
import java.lang.annotation.*;
import java.lang.annotation.Documented;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
/**
* User: hanna
* Date: May 19, 2009
@ -24,5 +25,5 @@ import java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)
public @interface RMD {
String name();
Class<? extends ReferenceOrderedDatum> type();
Class type();
}

11
java/src/org/broadinstitute/sting/gatk/walkers/VariantsToVCF.java
View File

@ -2,12 +2,11 @@ package org.broadinstitute.sting.gatk.walkers;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.contexts.variantcontext.VariantContext;
import org.broadinstitute.sting.gatk.contexts.variantcontext.Allele;
import org.broadinstitute.sting.gatk.contexts.variantcontext.VariantContext;
import org.broadinstitute.sting.gatk.refdata.*;
import org.broadinstitute.sting.gatk.refdata.utils.RODRecordList;
import org.broadinstitute.sting.utils.genotype.vcf.*;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.utils.genotype.vcf.*;
import java.util.*;
@ -33,7 +32,7 @@ public class VariantsToVCF extends RodWalker<Integer, Integer> {
if ( tracker == null )
return 0;
rodDbSNP dbsnp = rodDbSNP.getFirstRealSNP(tracker.getTrackData("dbsnp", null));
rodDbSNP dbsnp = rodDbSNP.getFirstRealSNP(tracker.getReferenceMetaData("dbsnp"));
Allele refAllele = new Allele(Character.toString(ref.getBase()), true);
Collection<VariantContext> contexts = tracker.getVariantContexts(INPUT_ROD_NAME, ALLOWED_VARIANT_CONTEXT_TYPES, context.getLocation(), refAllele, true, false);
@ -64,11 +63,11 @@ public class VariantsToVCF extends RodWalker<Integer, Integer> {
samples.add(sampleName);
} else {
RODRecordList rods = tracker.getTrackData(INPUT_ROD_NAME, null);
List<Object> rods = tracker.getReferenceMetaData(INPUT_ROD_NAME);
if ( rods.size() == 0 )
throw new IllegalStateException("VCF record was created, but no rod data is present");
ReferenceOrderedDatum rod = rods.get(0);
Object rod = rods.get(0);
if ( rod instanceof RodVCF )
samples.addAll(Arrays.asList(((RodVCF)rod).getSampleNames()));
else if ( rod instanceof HapMapGenotypeROD )

6
java/src/org/broadinstitute/sting/gatk/walkers/annotator/Alignability.java
View File

@ -8,8 +8,8 @@ import org.broadinstitute.sting.gatk.refdata.TabularROD;
import org.broadinstitute.sting.gatk.walkers.annotator.interfaces.InfoFieldAnnotation;
import org.broadinstitute.sting.utils.genotype.vcf.VCFInfoHeaderLine;
import java.util.Map;
import java.util.HashMap;
import java.util.Map;
public class Alignability implements InfoFieldAnnotation {
@ -19,8 +19,8 @@ public class Alignability implements InfoFieldAnnotation {
Map<String, StratifiedAlignmentContext> stratifiedContexts,
VariantContext vc)
{
TabularROD record = (TabularROD)(tracker.lookup("alignability", null));
if (record == null)
TabularROD record = tracker.lookup("alignability",TabularROD.class);
if (record == null)
return null;
if (record.get("alignability") == null)

36
java/src/org/broadinstitute/sting/gatk/walkers/annotator/VariantAnnotator.java
View File

@ -1,17 +1,28 @@
package org.broadinstitute.sting.gatk.walkers.annotator;
import org.broadinstitute.sting.gatk.contexts.*;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.contexts.StratifiedAlignmentContext;
import org.broadinstitute.sting.gatk.contexts.variantcontext.VariantContext;
import org.broadinstitute.sting.gatk.refdata.*;
import org.broadinstitute.sting.gatk.refdata.utils.RODRecordList;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.RodVCF;
import org.broadinstitute.sting.gatk.refdata.VariantContextAdaptors;
import org.broadinstitute.sting.gatk.walkers.*;
import org.broadinstitute.sting.gatk.walkers.annotator.interfaces.*;
import org.broadinstitute.sting.utils.*;
import org.broadinstitute.sting.utils.genotype.vcf.*;
import org.broadinstitute.sting.gatk.walkers.annotator.interfaces.AnnotationType;
import org.broadinstitute.sting.gatk.walkers.annotator.interfaces.GenotypeAnnotation;
import org.broadinstitute.sting.gatk.walkers.annotator.interfaces.InfoFieldAnnotation;
import org.broadinstitute.sting.utils.BaseUtils;
import org.broadinstitute.sting.utils.PackageUtils;
import org.broadinstitute.sting.utils.Pair;
import org.broadinstitute.sting.utils.SampleUtils;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.utils.genotype.vcf.VCFHeader;
import org.broadinstitute.sting.utils.genotype.vcf.VCFHeaderLine;
import org.broadinstitute.sting.utils.genotype.vcf.VCFUtils;
import org.broadinstitute.sting.utils.genotype.vcf.VCFWriter;
import java.io.File;
import java.util.*;
import java.io.*;
/**
@ -132,12 +143,12 @@ public class VariantAnnotator extends LocusWalker<Integer, Integer> {
if ( tracker == null )
return 0;
RODRecordList rods = tracker.getTrackData("variant", null);
List<Object> rods = tracker.getReferenceMetaData("variant");
// ignore places where we don't have a variant
if ( rods == null || rods.size() == 0 )
if ( rods.size() == 0 )
return 0;
ReferenceOrderedDatum variant = rods.get(0);
Object variant = rods.get(0);
VariantContext vc = VariantContextAdaptors.toVariantContext("variant", variant);
if ( vc == null )
return 0;
@ -150,8 +161,9 @@ public class VariantAnnotator extends LocusWalker<Integer, Integer> {
}
}
vcfWriter.addRecord(VariantContextAdaptors.toVCF(vc, ref.getBase()));
if ( variant instanceof RodVCF )
vcfWriter.addRecord(VariantContextAdaptors.toVCF(vc, ref.getBase()));
return 1;
}

33
java/src/org/broadinstitute/sting/gatk/walkers/annotator/VariantAnnotatorEngine.java
View File

@ -1,15 +1,22 @@
package org.broadinstitute.sting.gatk.walkers.annotator;
import org.broadinstitute.sting.gatk.contexts.*;
import org.broadinstitute.sting.gatk.GenomeAnalysisEngine;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.contexts.StratifiedAlignmentContext;
import org.broadinstitute.sting.gatk.contexts.variantcontext.Genotype;
import org.broadinstitute.sting.gatk.contexts.variantcontext.VariantContext;
import org.broadinstitute.sting.gatk.refdata.*;
import org.broadinstitute.sting.gatk.refdata.utils.RODRecordList;
import org.broadinstitute.sting.gatk.walkers.annotator.interfaces.*;
import org.broadinstitute.sting.gatk.datasources.simpleDataSources.ReferenceOrderedDataSource;
import org.broadinstitute.sting.gatk.GenomeAnalysisEngine;
import org.broadinstitute.sting.utils.*;
import org.broadinstitute.sting.utils.genotype.vcf.*;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.rodDbSNP;
import org.broadinstitute.sting.gatk.refdata.tracks.RMDTrack;
import org.broadinstitute.sting.gatk.walkers.annotator.interfaces.AnnotationType;
import org.broadinstitute.sting.gatk.walkers.annotator.interfaces.GenotypeAnnotation;
import org.broadinstitute.sting.gatk.walkers.annotator.interfaces.InfoFieldAnnotation;
import org.broadinstitute.sting.utils.PackageUtils;
import org.broadinstitute.sting.utils.StingException;
import org.broadinstitute.sting.utils.genotype.vcf.VCFHeaderLine;
import org.broadinstitute.sting.utils.genotype.vcf.VCFInfoHeaderLine;
import org.broadinstitute.sting.utils.genotype.vcf.VCFRecord;
import java.util.*;
@ -105,7 +112,7 @@ public class VariantAnnotatorEngine {
// check to see whether a dbsnp rod was included
List<ReferenceOrderedDataSource> dataSources = engine.getRodDataSources();
for ( ReferenceOrderedDataSource source : dataSources ) {
ReferenceOrderedData rod = source.getReferenceOrderedData();
RMDTrack rod = source.getReferenceOrderedData();
if ( rod.getType().equals(rodDbSNP.class) ) {
annotateDbsnp = true;
}
@ -142,7 +149,7 @@ public class VariantAnnotatorEngine {
// annotate dbsnp occurrence
if ( annotateDbsnp ) {
rodDbSNP dbsnp = rodDbSNP.getFirstRealSNP(tracker.getTrackData("dbsnp", null));
rodDbSNP dbsnp = rodDbSNP.getFirstRealSNP(tracker.getReferenceMetaData("dbsnp"));
infoAnnotations.put(VCFRecord.DBSNP_KEY, dbsnp == null ? "0" : "1");
// annotate dbsnp id if available and not already there
if ( dbsnp != null && !vc.hasAttribute("ID") )
@ -150,13 +157,13 @@ public class VariantAnnotatorEngine {
}
if ( annotateHapmap2 ) {
RODRecordList hapmap2 = tracker.getTrackData("hapmap2",null);
infoAnnotations.put(VCFRecord.HAPMAP2_KEY, hapmap2 == null? "0" : "1");
List<Object> hapmap2 = tracker.getReferenceMetaData("hapmap2");
infoAnnotations.put(VCFRecord.HAPMAP2_KEY, hapmap2.size() == 0 ? "0" : "1");
}
if ( annotateHapmap3 ) {
RODRecordList hapmap3 = tracker.getTrackData("hapmap3",null);
infoAnnotations.put(VCFRecord.HAPMAP3_KEY, hapmap3 == null ? "0" : "1");
List<Object> hapmap3 = tracker.getReferenceMetaData("hapmap3");
infoAnnotations.put(VCFRecord.HAPMAP3_KEY, hapmap3.size() == 0 ? "0" : "1");
}
for ( InfoFieldAnnotation annotation : requestedInfoAnnotations ) {

22
java/src/org/broadinstitute/sting/gatk/walkers/concordance/CallsetConcordanceWalker.java
View File

@ -1,11 +1,17 @@
package org.broadinstitute.sting.gatk.walkers.concordance;
import org.broadinstitute.sting.gatk.contexts.*;
import org.broadinstitute.sting.gatk.refdata.*;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.RodVCF;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeature;
import org.broadinstitute.sting.gatk.walkers.*;
import org.broadinstitute.sting.utils.*;
import org.broadinstitute.sting.utils.genotype.vcf.*;
import org.broadinstitute.sting.utils.PackageUtils;
import org.broadinstitute.sting.utils.Pair;
import org.broadinstitute.sting.utils.SampleUtils;
import org.broadinstitute.sting.utils.StingException;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.utils.genotype.vcf.*;
import java.io.File;
import java.util.*;
@ -127,11 +133,11 @@ public class CallsetConcordanceWalker extends RodWalker<Integer, Integer> {
// get all of the vcf rods at this locus
ArrayList<RodVCF> vcfRods = new ArrayList<RodVCF>();
Iterator<ReferenceOrderedDatum> rods = rodData.getAllRods().iterator();
Iterator<GATKFeature> rods = rodData.getAllRods().iterator();
while (rods.hasNext()) {
ReferenceOrderedDatum rod = rods.next();
if ( rod instanceof RodVCF )
vcfRods.add((RodVCF)rod);
GATKFeature rod = rods.next();
if ( rod.getUnderlyingObject() instanceof RodVCF )
vcfRods.add((RodVCF)rod.getUnderlyingObject());
}
if ( vcfRods.size() == 0 )

12
java/src/org/broadinstitute/sting/gatk/walkers/coverage/CoverageStatistics.java
View File

@ -5,8 +5,10 @@ import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedData;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedDatum;
import org.broadinstitute.sting.gatk.refdata.SeekableRODIterator;
import org.broadinstitute.sting.gatk.refdata.rodRefSeq;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeature;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeatureIterator;
import org.broadinstitute.sting.gatk.refdata.utils.LocationAwareSeekableRODIterator;
import org.broadinstitute.sting.gatk.refdata.utils.RODRecordList;
import org.broadinstitute.sting.gatk.walkers.By;
@ -339,9 +341,9 @@ public class CoverageStatistics extends LocusWalker<Map<String,int[]>, CoverageA
RODRecordList annotationList = refseqIterator.seekForward(target);
if (annotationList == null) { return "UNKNOWN"; }
for(ReferenceOrderedDatum rec : annotationList) {
if ( ((rodRefSeq)rec).overlapsExonP(target) ) {
return ((rodRefSeq)rec).getGeneName();
for(GATKFeature rec : annotationList) {
if ( ((rodRefSeq)rec.getUnderlyingObject()).overlapsExonP(target) ) {
return ((rodRefSeq)rec.getUnderlyingObject()).getGeneName();
}
}
@ -352,7 +354,7 @@ public class CoverageStatistics extends LocusWalker<Map<String,int[]>, CoverageA
private LocationAwareSeekableRODIterator initializeRefSeq() {
ReferenceOrderedData<rodRefSeq> refseq = new ReferenceOrderedData<rodRefSeq>("refseq",
refSeqGeneList, rodRefSeq.class);
return refseq.iterator();
return new SeekableRODIterator(new GATKFeatureIterator(refseq.iterator()));
}
private void printTargetSummary(PrintStream output, Pair<?,DepthOfCoverageStats> intervalStats) {

22
java/src/org/broadinstitute/sting/gatk/walkers/fasta/FastaAlternateReferenceWalker.java
View File

@ -2,13 +2,19 @@ package org.broadinstitute.sting.gatk.walkers.fasta;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.refdata.*;
import org.broadinstitute.sting.gatk.walkers.*;
import org.broadinstitute.sting.utils.*;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeature;
import org.broadinstitute.sting.gatk.walkers.DataSource;
import org.broadinstitute.sting.gatk.walkers.Requires;
import org.broadinstitute.sting.gatk.walkers.WalkerName;
import org.broadinstitute.sting.utils.GenomeLoc;
import org.broadinstitute.sting.utils.Pair;
import org.broadinstitute.sting.utils.Utils;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.utils.genotype.Variation;
import java.io.*;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Iterator;
/**
@ -46,13 +52,13 @@ public class FastaAlternateReferenceWalker extends FastaReferenceWalker {
return new Pair<GenomeLoc, String>(context.getLocation(), "");
}
Iterator<ReferenceOrderedDatum> rods = rodData.getAllRods().iterator();
Iterator<GATKFeature> rods = rodData.getAllRods().iterator();
while (rods.hasNext()) {
ReferenceOrderedDatum rod = rods.next();
if (!(rod instanceof Variation))
GATKFeature rod = rods.next();
if (!(rod.getUnderlyingObject() instanceof Variation))
continue;
// if we have multiple variants at a locus, just take the first damn one we see for now
Variation variant = (Variation) rod;
Variation variant = (Variation) rod.getUnderlyingObject();
if (!rod.getName().startsWith("snpmask") && variant.isDeletion()) {
deletionBasesRemaining = variant.getAlleleList().get(0).length();
basesSeen++;

26
java/src/org/broadinstitute/sting/gatk/walkers/filters/VariantFiltrationWalker.java
View File

@ -1,18 +1,22 @@
package org.broadinstitute.sting.gatk.walkers.filters;
import org.broadinstitute.sting.gatk.contexts.*;
import org.apache.commons.jexl.Expression;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.contexts.variantcontext.Genotype;
import org.broadinstitute.sting.gatk.contexts.variantcontext.VariantContext;
import org.broadinstitute.sting.gatk.contexts.variantcontext.VariantContextUtils;
import org.broadinstitute.sting.gatk.contexts.variantcontext.Genotype;
import org.broadinstitute.sting.gatk.refdata.*;
import org.broadinstitute.sting.gatk.refdata.utils.RODRecordList;
import org.broadinstitute.sting.gatk.walkers.*;
import org.broadinstitute.sting.gatk.datasources.simpleDataSources.ReferenceOrderedDataSource;
import org.broadinstitute.sting.utils.genotype.vcf.*;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedDatum;
import org.broadinstitute.sting.gatk.refdata.VariantContextAdaptors;
import org.broadinstitute.sting.gatk.walkers.RMD;
import org.broadinstitute.sting.gatk.walkers.Requires;
import org.broadinstitute.sting.gatk.walkers.RodWalker;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.utils.genotype.vcf.*;
import java.util.*;
import org.apache.commons.jexl.*;
/**
@ -119,9 +123,9 @@ public class VariantFiltrationWalker extends RodWalker<Integer, Integer> {
if ( tracker == null )
return 0;
RODRecordList rods = tracker.getTrackData("variant", null);
List<Object> rods = tracker.getReferenceMetaData("variant");
// ignore places where we don't have a variant
if ( rods == null || rods.size() == 0 )
if ( rods.size() == 0 )
return 0;
VariantContext vc = VariantContextAdaptors.toVariantContext("variant", rods.get(0));
@ -176,8 +180,8 @@ public class VariantFiltrationWalker extends RodWalker<Integer, Integer> {
Set<String> filters = new LinkedHashSet<String>(vc.getFilters());
// test for SNP mask, if present
RODRecordList mask = context.getTracker().getTrackData("mask", null);
if ( mask != null && mask.size() > 0 )
List<Object> mask = context.getTracker().getReferenceMetaData("mask");
if ( mask.size() > 0 )
filters.add(MASK_NAME);
// test for clustered SNPs if requested

16
java/src/org/broadinstitute/sting/gatk/walkers/genotyper/GenotypeCalculationModel.java
View File

@ -1,14 +1,16 @@
package org.broadinstitute.sting.gatk.walkers.genotyper;
import org.broadinstitute.sting.gatk.contexts.*;
import org.apache.log4j.Logger;
import org.broadinstitute.sting.gatk.contexts.StratifiedAlignmentContext;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.rodDbSNP;
import org.broadinstitute.sting.utils.*;
import org.broadinstitute.sting.utils.genotype.*;
import org.apache.log4j.Logger;
import org.broadinstitute.sting.utils.GenomeLoc;
import org.broadinstitute.sting.utils.genotype.GenotypeWriterFactory;
import java.io.*;
import java.util.*;
import java.io.PrintStream;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
/**
@ -110,6 +112,6 @@ public abstract class GenotypeCalculationModel implements Cloneable {
* @return the dbsnp rod if there is one at this position
*/
public static rodDbSNP getDbSNP(RefMetaDataTracker tracker) {
return rodDbSNP.getFirstRealSNP(tracker.getTrackData("dbsnp", null));
return rodDbSNP.getFirstRealSNP(tracker.getReferenceMetaData("dbsnp"));
}
}

27
java/src/org/broadinstitute/sting/gatk/walkers/genotyper/UnifiedGenotyperEngine.java
View File

@ -25,23 +25,32 @@
package org.broadinstitute.sting.gatk.walkers.genotyper;
import org.apache.log4j.Logger;
import org.broadinstitute.sting.gatk.GenomeAnalysisEngine;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.contexts.StratifiedAlignmentContext;
import org.broadinstitute.sting.gatk.datasources.simpleDataSources.ReferenceOrderedDataSource;
import org.broadinstitute.sting.gatk.contexts.*;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedData;
import org.broadinstitute.sting.gatk.refdata.rodDbSNP;
import org.broadinstitute.sting.gatk.refdata.tracks.RMDTrack;
import org.broadinstitute.sting.gatk.walkers.annotator.VariantAnnotatorEngine;
import org.broadinstitute.sting.utils.*;
import org.broadinstitute.sting.utils.pileup.*;
import org.broadinstitute.sting.utils.genotype.*;
import org.broadinstitute.sting.utils.AlignmentUtils;
import org.broadinstitute.sting.utils.BaseUtils;
import org.broadinstitute.sting.utils.SampleUtils;
import org.broadinstitute.sting.utils.StingException;
import org.broadinstitute.sting.utils.genotype.GenotypeWriter;
import org.broadinstitute.sting.utils.genotype.GenotypeWriterFactory;
import org.broadinstitute.sting.utils.genotype.geli.GeliGenotypeWriter;
import org.broadinstitute.sting.utils.genotype.glf.GLFGenotypeWriter;
import org.broadinstitute.sting.utils.genotype.vcf.*;
import org.apache.log4j.Logger;
import org.broadinstitute.sting.utils.genotype.vcf.VCFGenotypeWriter;
import org.broadinstitute.sting.utils.pileup.ExtendedEventPileupElement;
import org.broadinstitute.sting.utils.pileup.PileupElement;
import org.broadinstitute.sting.utils.pileup.ReadBackedExtendedEventPileup;
import org.broadinstitute.sting.utils.pileup.ReadBackedPileup;
import java.util.*;
import java.io.PrintStream;
import java.util.*;
public class UnifiedGenotyperEngine {
@ -111,7 +120,7 @@ public class UnifiedGenotyperEngine {
// check to see whether a dbsnp rod was included
List<ReferenceOrderedDataSource> dataSources = toolkit.getRodDataSources();
for ( ReferenceOrderedDataSource source : dataSources ) {
ReferenceOrderedData rod = source.getReferenceOrderedData();
RMDTrack rod = source.getReferenceOrderedData();
if ( rod.getType().equals(rodDbSNP.class) ) {
this.annotateDbsnp = true;
}

26
java/src/org/broadinstitute/sting/gatk/walkers/indels/IndelGenotyperV2Walker.java
View File

@ -1,24 +1,24 @@
package org.broadinstitute.sting.gatk.walkers.indels;
import net.sf.samtools.Cigar;
import net.sf.samtools.CigarElement;
import net.sf.samtools.CigarOperator;
import net.sf.samtools.SAMRecord;
import org.broadinstitute.sting.gatk.filters.Platform454Filter;
import org.broadinstitute.sting.gatk.filters.PlatformUnitFilter;
import org.broadinstitute.sting.gatk.filters.PlatformUnitFilterHelper;
import org.broadinstitute.sting.gatk.filters.ZeroMappingQualityReadFilter;
import org.broadinstitute.sting.gatk.refdata.*;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeatureIterator;
import org.broadinstitute.sting.gatk.refdata.utils.LocationAwareSeekableRODIterator;
import org.broadinstitute.sting.gatk.refdata.utils.RODRecordList;
import org.broadinstitute.sting.gatk.walkers.ReadFilters;
import org.broadinstitute.sting.gatk.walkers.ReadWalker;
import org.broadinstitute.sting.gatk.filters.Platform454Filter;
import org.broadinstitute.sting.gatk.filters.ZeroMappingQualityReadFilter;
import org.broadinstitute.sting.gatk.filters.PlatformUnitFilter;
import org.broadinstitute.sting.gatk.filters.PlatformUnitFilterHelper;
import org.broadinstitute.sting.gatk.refdata.*;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.utils.*;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import java.util.*;
import java.io.IOException;
import net.sf.samtools.SAMRecord;
import net.sf.samtools.Cigar;
import net.sf.samtools.CigarOperator;
import net.sf.samtools.CigarElement;
import java.util.*;
/**
* This is a simple, counts-and-cutoffs based tool for calling indels from aligned (preferrably MSA cleaned) sequencing
@ -110,7 +110,7 @@ public class IndelGenotyperV2Walker extends ReadWalker<Integer,Integer> {
ReferenceOrderedData<rodRefSeq> refseq = new ReferenceOrderedData<rodRefSeq>("refseq",
new java.io.File(RefseqFileName), rodRefSeq.class);
refseqIterator = refseq.iterator();
refseqIterator = new SeekableRODIterator(new GATKFeatureIterator(refseq.iterator()));
logger.info("Using RefSeq annotations from "+RefseqFileName);
}

29
java/src/org/broadinstitute/sting/gatk/walkers/indels/IndelRealigner.java
View File

@ -1,20 +1,21 @@
package org.broadinstitute.sting.gatk.walkers.indels;
import org.broadinstitute.sting.utils.*;
import org.broadinstitute.sting.gatk.walkers.ReadWalker;
import org.broadinstitute.sting.gatk.GenomeAnalysisEngine;
import org.broadinstitute.sting.gatk.contexts.variantcontext.VariantContext;
import org.broadinstitute.sting.gatk.datasources.simpleDataSources.SAMReaderID;
import org.broadinstitute.sting.gatk.arguments.IntervalMergingRule;
import org.broadinstitute.sting.gatk.refdata.*;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import net.sf.samtools.*;
import net.sf.samtools.util.StringUtil;
import org.broadinstitute.sting.gatk.GenomeAnalysisEngine;
import org.broadinstitute.sting.gatk.arguments.IntervalMergingRule;
import org.broadinstitute.sting.gatk.contexts.variantcontext.VariantContext;
import org.broadinstitute.sting.gatk.datasources.simpleDataSources.SAMReaderID;
import org.broadinstitute.sting.gatk.refdata.ReadMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.VariantContextAdaptors;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeature;
import org.broadinstitute.sting.gatk.walkers.ReadWalker;
import org.broadinstitute.sting.utils.*;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import java.util.*;
import java.io.File;
import java.io.FileWriter;
import java.util.*;
/**
* Performs local realignment of reads based on misalignments due to the presence of indels.
@ -93,7 +94,7 @@ public class IndelRealigner extends ReadWalker<Integer, Integer> {
// the reads and known indels that fall into the current interval
private final ReadBin readsToClean = new ReadBin();
private final ArrayList<SAMRecord> readsNotToClean = new ArrayList<SAMRecord>();
private final IdentityHashMap<ReferenceOrderedDatum, VariantContext> knownIndelsToTry = new IdentityHashMap<ReferenceOrderedDatum, VariantContext>();
private final IdentityHashMap<Object, VariantContext> knownIndelsToTry = new IdentityHashMap<Object, VariantContext>();
// the wrapper around the SAM writer
private Map<String, SAMFileWriter> writers = null;
@ -348,10 +349,10 @@ public class IndelRealigner extends ReadWalker<Integer, Integer> {
}
private void populateKnownIndels(ReadMetaDataTracker metaDataTracker) {
for ( Collection<ReferenceOrderedDatum> rods : metaDataTracker.getContigOffsetMapping().values() ) {
Iterator<ReferenceOrderedDatum> rodIter = rods.iterator();
for ( Collection<GATKFeature> rods : metaDataTracker.getContigOffsetMapping().values() ) {
Iterator<GATKFeature> rodIter = rods.iterator();
while ( rodIter.hasNext() ) {
ReferenceOrderedDatum rod = rodIter.next();
Object rod = rodIter.next().getUnderlyingObject();
if ( knownIndelsToTry.containsKey(rod) )
continue;
if ( VariantContextAdaptors.canBeConvertedToVariantContext(rod))

24
java/src/org/broadinstitute/sting/gatk/walkers/indels/RealignerTargetCreator.java
View File

@ -1,18 +1,26 @@
package org.broadinstitute.sting.gatk.walkers.indels;
import net.sf.samtools.*;
import org.broadinstitute.sting.gatk.refdata.*;
import org.broadinstitute.sting.gatk.walkers.LocusWalker;
import net.sf.samtools.SAMRecord;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.filters.Platform454Filter;
import org.broadinstitute.sting.gatk.filters.ZeroMappingQualityReadFilter;
import org.broadinstitute.sting.utils.*;
import org.broadinstitute.sting.utils.pileup.*;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.VariationRod;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeature;
import org.broadinstitute.sting.gatk.walkers.LocusWalker;
import org.broadinstitute.sting.gatk.walkers.ReadFilters;
import org.broadinstitute.sting.utils.GenomeLoc;
import org.broadinstitute.sting.utils.GenomeLocParser;
import org.broadinstitute.sting.utils.StingException;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.utils.pileup.ExtendedEventPileupElement;
import org.broadinstitute.sting.utils.pileup.PileupElement;
import org.broadinstitute.sting.utils.pileup.ReadBackedExtendedEventPileup;
import org.broadinstitute.sting.utils.pileup.ReadBackedPileup;
import java.util.*;
import java.util.ArrayList;
import java.util.Iterator;
/**
* Emits intervals for the Local Indel Realigner to target for cleaning. Ignores 454 and MQ0 reads.
@ -67,9 +75,9 @@ public class RealignerTargetCreator extends LocusWalker<RealignerTargetCreator.E
// look at the rods for indels or SNPs
if ( tracker != null ) {
Iterator<ReferenceOrderedDatum> rods = tracker.getAllRods().iterator();
Iterator<GATKFeature> rods = tracker.getAllRods().iterator();
while ( rods.hasNext() ) {
ReferenceOrderedDatum rod = rods.next();
Object rod = rods.next().getUnderlyingObject();
if ( rod instanceof VariationRod ) {
if ( ((VariationRod)rod).isIndel() ) {
hasIndel = true;

12
java/src/org/broadinstitute/sting/gatk/walkers/qc/ValidatingPileupWalker.java
View File

@ -3,13 +3,13 @@ package org.broadinstitute.sting.gatk.walkers.qc;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.rodSAMPileup;
import org.broadinstitute.sting.gatk.refdata.SAMPileupRecord;
import org.broadinstitute.sting.gatk.refdata.rodSAMPileup;
import org.broadinstitute.sting.gatk.walkers.*;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.utils.Utils;
import org.broadinstitute.sting.utils.pileup.ReadBackedPileup;
import org.broadinstitute.sting.utils.StingException;
import org.broadinstitute.sting.utils.Utils;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.utils.pileup.ReadBackedPileup;
import java.util.Arrays;
@ -99,9 +99,9 @@ public class ValidatingPileupWalker extends LocusWalker<Integer, ValidationStats
* @return True pileup data.
*/
private SAMPileupRecord getTruePileup( RefMetaDataTracker tracker ) {
rodSAMPileup pileup = (rodSAMPileup)tracker.lookup("pileup", null);
rodSAMPileup pileup = tracker.lookup("pileup",rodSAMPileup.class);
if( pileup == null )
if( pileup == null)
return null;
if( pileup.hasPointGenotype() )

42
java/src/org/broadinstitute/sting/gatk/walkers/recalibration/CovariateCounterWalker.java
View File

@ -1,5 +1,19 @@
package org.broadinstitute.sting.gatk.walkers.recalibration;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.datasources.simpleDataSources.ReferenceOrderedDataSource;
import org.broadinstitute.sting.gatk.filters.ZeroMappingQualityReadFilter;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeature;
import org.broadinstitute.sting.gatk.walkers.*;
import org.broadinstitute.sting.utils.*;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.utils.cmdLine.ArgumentCollection;
import org.broadinstitute.sting.utils.genotype.Variation;
import org.broadinstitute.sting.utils.pileup.PileupElement;
import org.broadinstitute.sting.utils.sam.GATKSAMRecord;
import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.util.ArrayList;
@ -7,30 +21,6 @@ import java.util.Collections;
import java.util.List;
import java.util.Map;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.datasources.simpleDataSources.ReferenceOrderedDataSource;
import org.broadinstitute.sting.gatk.filters.ZeroMappingQualityReadFilter;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedDatum;
import org.broadinstitute.sting.gatk.walkers.By;
import org.broadinstitute.sting.gatk.walkers.DataSource;
import org.broadinstitute.sting.gatk.walkers.LocusWalker;
import org.broadinstitute.sting.gatk.walkers.ReadFilters;
import org.broadinstitute.sting.gatk.walkers.Requires;
import org.broadinstitute.sting.gatk.walkers.WalkerName;
import org.broadinstitute.sting.utils.BaseUtils;
import org.broadinstitute.sting.utils.NestedHashMap;
import org.broadinstitute.sting.utils.PackageUtils;
import org.broadinstitute.sting.utils.Pair;
import org.broadinstitute.sting.utils.StingException;
import org.broadinstitute.sting.utils.Utils;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.utils.cmdLine.ArgumentCollection;
import org.broadinstitute.sting.utils.genotype.Variation;
import org.broadinstitute.sting.utils.pileup.PileupElement;
import org.broadinstitute.sting.utils.sam.GATKSAMRecord;
/*
* Copyright (c) 2009 The Broad Institute
*
@ -259,8 +249,8 @@ public class CovariateCounterWalker extends LocusWalker<Integer, PrintStream> {
// Pull out data for this locus for all the input RODs and check if this is a known variant site in any of them
boolean isSNP = false;
for( ReferenceOrderedDatum rod : tracker.getAllRods() ) {
if( rod != null && rod instanceof Variation && ((Variation)rod).isSNP() ) {
for( GATKFeature rod : tracker.getAllRods() ) {
if( rod != null && rod.getUnderlyingObject() instanceof Variation && ((Variation)rod.getUnderlyingObject()).isSNP() ) {
isSNP = true; // At least one of the rods says this is a snp site
break;
}

6
java/src/org/broadinstitute/sting/gatk/walkers/sequenom/CreateSequenomMask.java
View File

@ -3,7 +3,7 @@ package org.broadinstitute.sting.gatk.walkers.sequenom;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedDatum;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeature;
import org.broadinstitute.sting.gatk.walkers.RodWalker;
import org.broadinstitute.sting.utils.genotype.Variation;
@ -21,9 +21,9 @@ public class CreateSequenomMask extends RodWalker<Integer, Integer> {
if ( rodData == null ) // apparently, RodWalkers make funky map calls
return 0;
Iterator<ReferenceOrderedDatum> rods = rodData.getAllRods().iterator();
Iterator<GATKFeature> rods = rodData.getAllRods().iterator();
while (rods.hasNext()) {
ReferenceOrderedDatum rod = rods.next();
Object rod = rods.next().getUnderlyingObject();
if ( rod instanceof Variation && ((Variation)rod).isSNP() ) {
out.println(context.getLocation());
result = 1;

18
java/src/org/broadinstitute/sting/gatk/walkers/sequenom/PickSequenomProbes.java
View File

@ -1,17 +1,21 @@
package org.broadinstitute.sting.gatk.walkers.sequenom;
import org.broadinstitute.sting.gatk.GenomeAnalysisEngine;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.refdata.*;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeature;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeatureIterator;
import org.broadinstitute.sting.gatk.refdata.utils.LocationAwareSeekableRODIterator;
import org.broadinstitute.sting.gatk.refdata.utils.RODRecordList;
import org.broadinstitute.sting.gatk.walkers.*;
import org.broadinstitute.sting.utils.*;
import org.broadinstitute.sting.utils.GenomeLoc;
import org.broadinstitute.sting.utils.GenomeLocParser;
import org.broadinstitute.sting.utils.Utils;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.utils.genotype.Variation;
import java.util.*;
import java.util.Arrays;
import java.util.Iterator;
/**
@ -45,7 +49,7 @@ public class PickSequenomProbes extends RefWalker<String, String> {
snp_mask = new ReferenceOrderedData<TabularROD>("snp_mask",
new java.io.File(SNP_MASK), TabularROD.class);
}
snpMaskIterator = snp_mask.iterator();
snpMaskIterator = new SeekableRODIterator(new GATKFeatureIterator(snp_mask.iterator()));
}
}
@ -55,10 +59,10 @@ public class PickSequenomProbes extends RefWalker<String, String> {
String refBase = String.valueOf(ref.getBase());
Iterator<ReferenceOrderedDatum> rods = rodData.getAllRods().iterator();
Iterator<GATKFeature> rods = rodData.getAllRods().iterator();
Variation variant = null;
while (rods.hasNext()) {
ReferenceOrderedDatum rod = rods.next();
Object rod = rods.next().getUnderlyingObject();
// if we have multiple variants at a locus, just take the first one we see
if ( rod instanceof Variation ) {
@ -79,7 +83,7 @@ public class PickSequenomProbes extends RefWalker<String, String> {
if ( snpMaskIterator != null ) {
RODRecordList snpList = snpMaskIterator.seekForward(GenomeLocParser.createGenomeLoc(contig,offset-200,offset+200));
if ( snpList != null && snpList.size() != 0 ) {
Iterator<ReferenceOrderedDatum> snpsInWindow = snpList.iterator();
Iterator<GATKFeature> snpsInWindow = snpList.iterator();
int i = 0;
while ( snpsInWindow.hasNext() ) {
GenomeLoc snp = snpsInWindow.next().getLocation();

18
java/src/org/broadinstitute/sting/gatk/walkers/sequenom/SequenomValidationConverter.java
View File

@ -2,16 +2,18 @@ package org.broadinstitute.sting.gatk.walkers.sequenom;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.contexts.variantcontext.*;
import org.broadinstitute.sting.utils.StingException;
import org.broadinstitute.sting.utils.QualityUtils;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.contexts.variantcontext.Allele;
import org.broadinstitute.sting.gatk.contexts.variantcontext.VariantContext;
import org.broadinstitute.sting.gatk.contexts.variantcontext.VariantContextUtils;
import org.broadinstitute.sting.gatk.refdata.PlinkRod;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedDatum;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.VariantContextAdaptors;
import org.broadinstitute.sting.gatk.walkers.RodWalker;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeature;
import org.broadinstitute.sting.gatk.walkers.Reference;
import org.broadinstitute.sting.gatk.walkers.RodWalker;
import org.broadinstitute.sting.gatk.walkers.Window;
import org.broadinstitute.sting.utils.QualityUtils;
import org.broadinstitute.sting.utils.StingException;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.utils.genotype.vcf.*;
@ -74,9 +76,9 @@ public class SequenomValidationConverter extends RodWalker<VCFRecord,Integer> {
// get the Plink rod at this locus if there is one
PlinkRod plinkRod = null;
Iterator<ReferenceOrderedDatum> rods = tracker.getAllRods().iterator();
Iterator<GATKFeature> rods = tracker.getAllRods().iterator();
while (rods.hasNext()) {
ReferenceOrderedDatum rod = rods.next();
Object rod = rods.next().getUnderlyingObject();
if ( rod instanceof PlinkRod ) {
plinkRod = (PlinkRod)rod;
break;

21
java/src/org/broadinstitute/sting/gatk/walkers/varianteval/ChipConcordance.java
View File

@ -1,18 +1,22 @@
package org.broadinstitute.sting.gatk.walkers.varianteval;
import org.broadinstitute.sting.gatk.refdata.utils.RODRecordList;
import org.broadinstitute.sting.utils.genotype.Variation;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.utils.BaseUtils;
import org.broadinstitute.sting.utils.Pair;
import org.broadinstitute.sting.utils.StingException;
import org.broadinstitute.sting.utils.genotype.Genotype;
import org.broadinstitute.sting.utils.genotype.VariantBackedByGenotype;
import org.broadinstitute.sting.utils.*;
import org.broadinstitute.sting.gatk.refdata.*;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.utils.genotype.Variation;
import java.util.*;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* The Broad Institute
@ -79,8 +83,7 @@ public abstract class ChipConcordance extends BasicVariantAnalysis {
// get all of the chip rods at this locus
HashMap<String, Genotype> chips = new HashMap<String, Genotype>();
for ( String name : rodNames ) {
RODRecordList rods = tracker.getTrackData(name, null);
Variation chip = (rods == null ? null : (Variation)rods.get(0));
Variation chip = tracker.lookup(name,Variation.class);
if ( chip != null ) {
// chips must be Genotypes
if ( !(chip instanceof VariantBackedByGenotype) )

2
java/src/org/broadinstitute/sting/gatk/walkers/varianteval/ClusterCounterAnalysis.java
View File

@ -49,7 +49,7 @@ public class ClusterCounterAnalysis extends BasicVariantAnalysis implements Geno
String r = null;
if ( eval != null && eval.isSNP() ) {
IntervalRod intervalROD = (IntervalRod)tracker.lookup("interval", null);
IntervalRod intervalROD = tracker.lookup("interval",IntervalRod.class);
GenomeLoc interval = intervalROD == null ? null : intervalROD.getLocation();
if (lastVariation != null) {

3
java/src/org/broadinstitute/sting/gatk/walkers/varianteval/NeighborDistanceAnalysis.java
View File

@ -39,7 +39,8 @@ public class NeighborDistanceAnalysis extends BasicVariantAnalysis implements Ge
String r = null;
if ( eval != null && eval.isSNP() ) {
IntervalRod intervalROD = (IntervalRod)tracker.lookup("interval", null);
IntervalRod intervalROD = tracker.lookup("interval",IntervalRod.class);
GenomeLoc interval = intervalROD == null ? null : intervalROD.getLocation();
if (lastVariation != null) {

10
java/src/org/broadinstitute/sting/gatk/walkers/varianteval/ValidationDataAnalysis.java
View File

@ -1,11 +1,11 @@
package org.broadinstitute.sting.gatk.walkers.varianteval;
import org.broadinstitute.sting.utils.genotype.Variation;
import org.broadinstitute.sting.gatk.refdata.*;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.utils.genotype.Variation;
import java.util.List;
import java.util.ArrayList;
import java.util.List;
/**
* Created by IntelliJ IDEA.
@ -29,8 +29,8 @@ public class ValidationDataAnalysis extends BasicVariantAnalysis implements Geno
public String update(Variation eval, RefMetaDataTracker tracker, char ref, AlignmentContext context) {
validated_sites++;
Variation val_data = (Variation) tracker.lookup("validation", null);
Variation dbsnp = (Variation) tracker.lookup("dbsnp",null);
List<Object> objects = tracker.getReferenceMetaData("validation");
Object val_data = (objects.size() > 0) ? objects.get(0) : null;
if (eval != null) {
calls_at_sites_validated_true++;

14
java/src/org/broadinstitute/sting/gatk/walkers/varianteval/VariantDBCoverage.java
View File

@ -1,8 +1,8 @@
package org.broadinstitute.sting.gatk.walkers.varianteval;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.refdata.*;
import org.broadinstitute.sting.gatk.refdata.utils.RODRecordList;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.RodVCF;
import org.broadinstitute.sting.utils.Utils;
import org.broadinstitute.sting.utils.genotype.Variation;
@ -59,14 +59,14 @@ public class VariantDBCoverage extends BasicVariantAnalysis implements GenotypeA
return nConcordant() / (1.0 * nSNPsAtdbSNPs());
}
public static Variation getFirstRealSNP(RODRecordList dbsnpList) {
public static Variation getFirstRealSNP(List<Object> dbsnpList) {
if (dbsnpList == null)
return null;
Variation dbsnp = null;
for (ReferenceOrderedDatum d : dbsnpList) {
if (((Variation) d).isSNP() && (! (d instanceof RodVCF) || ! ((RodVCF)d).isFiltered())) {
dbsnp = (Variation)d;
for (Object d : dbsnpList) {
if (((Variation) d).isSNP() && (!(d instanceof RodVCF) || !((RodVCF) d).isFiltered())) {
dbsnp = (Variation) d;
break;
}
}
@ -75,7 +75,7 @@ public class VariantDBCoverage extends BasicVariantAnalysis implements GenotypeA
}
public String update(Variation eval, RefMetaDataTracker tracker, char ref, AlignmentContext context) {
Variation dbSNP = getFirstRealSNP(tracker.getTrackData( dbName, null, false ));
Variation dbSNP = getFirstRealSNP(tracker.getReferenceMetaData( dbName, false ));
String result = null;
if ( dbSNP != null ) nDBSNPs++; // count the number of real dbSNP events

25
java/src/org/broadinstitute/sting/gatk/walkers/varianteval/VariantEvalWalker.java
View File

@ -2,27 +2,24 @@ package org.broadinstitute.sting.gatk.walkers.varianteval;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.refdata.utils.RODRecordList;
import org.broadinstitute.sting.gatk.walkers.*;
import org.broadinstitute.sting.gatk.refdata.*;
import org.broadinstitute.sting.gatk.walkers.DataSource;
import org.broadinstitute.sting.gatk.walkers.RMD;
import org.broadinstitute.sting.gatk.walkers.Requires;
import org.broadinstitute.sting.gatk.walkers.RodWalker;
import org.broadinstitute.sting.utils.StingException;
import org.broadinstitute.sting.utils.Utils;
import org.broadinstitute.sting.utils.GenomeLoc;
import org.broadinstitute.sting.utils.QualityUtils;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.utils.genotype.Variation;
import org.broadinstitute.sting.utils.genotype.Genotype;
import org.broadinstitute.sting.utils.genotype.BasicGenotype;
import org.broadinstitute.sting.utils.genotype.vcf.VCFRecord;
import org.broadinstitute.sting.utils.genotype.vcf.VCFGenotypeEncoding;
import org.broadinstitute.sting.utils.genotype.vcf.VCFGenotypeRecord;
import java.util.regex.Pattern;
import org.broadinstitute.sting.utils.genotype.vcf.VCFRecord;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.util.*;
import java.util.regex.Pattern;
/**
* A robust and general purpose tool for characterizing the quality of SNPs, Indels, and other variants that includes basic
@ -273,10 +270,10 @@ public class VariantEvalWalker extends RodWalker<Integer, Integer> {
int nBoundGoodRods = tracker.getNBoundRodTracks("interval");
if (nBoundGoodRods > 0) {
//System.out.printf("%s: n = %d%n", context.getLocation(), nBoundGoodRods );
// System.out.printf("%s: n = %d%n", context.getLocation(), nBoundGoodRods );
// Iterate over each analysis, and update it
Variation eval = (Variation) tracker.lookup("eval", null);
Variation eval = tracker.lookup("eval",Variation.class);
Variation evalForFilter = null;
// ensure that the variation we're looking at is bi-allelic
@ -360,12 +357,12 @@ public class VariantEvalWalker extends RodWalker<Integer, Integer> {
}
private ANALYSIS_TYPE getNovelAnalysisType(RefMetaDataTracker tracker) {
RODRecordList dbsnpList = tracker.getTrackData("dbsnp", null);
List<Object> dbsnpList = tracker.getReferenceMetaData("dbsnp");
if (dbsnpList == null)
if (dbsnpList.size() == 0)
return ANALYSIS_TYPE.NOVEL_SNPS;
for (ReferenceOrderedDatum d : dbsnpList) {
for (Object d : dbsnpList) {
if (((rodDbSNP) d).isSNP()) {
return ANALYSIS_TYPE.KNOWN_SNPS;
}

3
java/src/org/broadinstitute/sting/gatk/walkers/varianteval/VariantMatcher.java
View File

@ -24,7 +24,8 @@ public class VariantMatcher extends BasicVariantAnalysis implements GenotypeAnal
public String update(Variation eval, RefMetaDataTracker tracker, char ref, AlignmentContext context) {
String r = null;
Variation db = (Variation)tracker.lookup(dbName, null);
Variation db = tracker.lookup(dbName,Variation.class);
if ( eval != null || db != null ) {
String matchFlag = " ";

13
java/src/org/broadinstitute/sting/oneoffprojects/multisamplecaller/MultiSampleCaller.java
View File

@ -9,12 +9,17 @@ import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.walkers.LocusWalker;
import org.broadinstitute.sting.utils.*;
import org.broadinstitute.sting.utils.BaseUtils;
import org.broadinstitute.sting.utils.GenomeLoc;
import org.broadinstitute.sting.utils.GenomeLocParser;
import org.broadinstitute.sting.utils.Utils;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import java.io.File;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.util.*;
import java.util.zip.*;
import java.io.*;
import java.util.zip.GZIPOutputStream;
// Beta iterative multi-sample caller
// j.maguire 6-11-2009
@ -876,7 +881,7 @@ public class MultiSampleCaller extends LocusWalker<MultiSampleCaller.MultiSample
MultiSampleCallResult MultiSampleCall(RefMetaDataTracker tracker, char ref, AlignmentContext context, List<String> sample_names)
{
String in_dbsnp;
if (tracker.lookup("DBSNP", null) != null) { in_dbsnp = "known"; } else { in_dbsnp = "novel"; }
if (tracker.getReferenceMetaData("DBSNP").size() > 0) { in_dbsnp = "known"; } else { in_dbsnp = "novel"; }
AlignmentContext[] contexts = filterAlignmentContext(context, sample_names, 0);
glCache.clear(); // reset the cache

9
java/src/org/broadinstitute/sting/oneoffprojects/walkers/AlleleBalanceHistogramWalker.java
View File

@ -5,9 +5,11 @@ import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.contexts.StratifiedAlignmentContext;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.RodVCF;
import org.broadinstitute.sting.gatk.walkers.*;
import org.broadinstitute.sting.gatk.walkers.DataSource;
import org.broadinstitute.sting.gatk.walkers.LocusWalker;
import org.broadinstitute.sting.gatk.walkers.RMD;
import org.broadinstitute.sting.gatk.walkers.Requires;
import org.broadinstitute.sting.utils.BaseUtils;
import org.broadinstitute.sting.utils.genotype.vcf.VCFGenotypeRecord;
import org.broadinstitute.sting.utils.genotype.vcf.VCFRecord;
import org.broadinstitute.sting.utils.pileup.PileupElement;
@ -45,7 +47,8 @@ public class AlleleBalanceHistogramWalker extends LocusWalker<Map<String,Double>
}
public Map<String,Double> map(RefMetaDataTracker tracker, ReferenceContext ref, AlignmentContext context) {
RodVCF vcfRod = (RodVCF) tracker.lookup("variants",null);
RodVCF vcfRod = tracker.lookup("variants",RodVCF.class);
if ( vcfRod == null ) {
return null;
}

33
java/src/org/broadinstitute/sting/oneoffprojects/walkers/HapmapPoolAllelicInfoWalker.java
View File

@ -1,23 +1,25 @@
package org.broadinstitute.sting.oneoffprojects.walkers;
import org.broadinstitute.sting.gatk.refdata.utils.RODRecordList;
import org.broadinstitute.sting.gatk.walkers.LocusWalker;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.utils.*;
import org.broadinstitute.sting.utils.pileup.ReadBackedPileup;
import org.broadinstitute.sting.utils.genotype.Genotype;
import org.broadinstitute.sting.utils.genotype.Variation;
import org.broadinstitute.sting.utils.genotype.VariantBackedByGenotype;
import org.broadinstitute.sting.playground.gatk.walkers.poolseq.PowerBelowFrequencyWalker;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.walkers.LocusWalker;
import org.broadinstitute.sting.gatk.walkers.varianteval.ConcordanceTruthTable;
import org.broadinstitute.sting.playground.gatk.walkers.poolseq.PowerBelowFrequencyWalker;
import org.broadinstitute.sting.utils.BaseUtils;
import org.broadinstitute.sting.utils.GenomeLoc;
import org.broadinstitute.sting.utils.Pair;
import org.broadinstitute.sting.utils.StingException;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.utils.genotype.Genotype;
import org.broadinstitute.sting.utils.genotype.VariantBackedByGenotype;
import org.broadinstitute.sting.utils.genotype.Variation;
import org.broadinstitute.sting.utils.pileup.ReadBackedPileup;
import java.io.*;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.ArrayList;
/**
* Created by IntelliJ IDEA.
@ -81,7 +83,8 @@ public class HapmapPoolAllelicInfoWalker extends LocusWalker<String, PrintWriter
int depth = context.size();
double power = powerWalker.calculatePowerAtFrequency(context,numVariantAllele);
int called;
Variation call = (Variation) tracker.lookup("calls",null);
Variation call = tracker.lookup("calls",Variation.class);
if ( call == null ) {
called = 0;
} else if ( call.isReference() || call.getNegLog10PError() < minCallQ-EPSILON ) {
@ -134,8 +137,8 @@ public class HapmapPoolAllelicInfoWalker extends LocusWalker<String, PrintWriter
private List<Pair<Genotype,Genotype>> getChips(String[] rodNames, RefMetaDataTracker tracker) {
List<Pair<Genotype, Genotype>> chips = new ArrayList <Pair<Genotype,Genotype>>(rodNames.length);
for ( String name : rodNames ) {
RODRecordList rods = tracker.getTrackData(name, null);
Variation chip = (rods == null ? null : (Variation)rods.get(0));
List<Object> rods = tracker.getReferenceMetaData(name);
Variation chip = (rods.size() == 0 ? null : (Variation)rods.get(0));
if ( chip != null ) {
// chips must be Genotypes
if ( !(chip instanceof VariantBackedByGenotype) )

2
java/src/org/broadinstitute/sting/oneoffprojects/walkers/ValidateDbSNPConversion.java
View File

@ -21,7 +21,7 @@ public class ValidateDbSNPConversion extends RefWalker<Pair<Matrix.BASE, Matrix.
@Override
public Pair<Matrix.BASE, Matrix.BASE> map(RefMetaDataTracker tracker, ReferenceContext ref, AlignmentContext context) {
if (!tracker.hasROD("dbsnp")) return null;
rodDbSNP rod = (rodDbSNP) tracker.lookup("dbSNP", null);
rodDbSNP rod = tracker.lookup("dbSNP",rodDbSNP.class);
if (rod != null && rod.isSNP() && rod.isBiallelic()) {
return new Pair<Matrix.BASE, Matrix.BASE>(Matrix.BASE.toBase((byte) ref.getBase()), Matrix.BASE.toBase((byte) rod.getAlternativeBaseForSNP()));
}

11
java/src/org/broadinstitute/sting/oneoffprojects/walkers/annotator/ThousandGenomesAnnotator.java
View File

@ -4,13 +4,12 @@ import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.contexts.StratifiedAlignmentContext;
import org.broadinstitute.sting.gatk.contexts.variantcontext.VariantContext;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.utils.RODRecordList;
import org.broadinstitute.sting.gatk.walkers.annotator.interfaces.InfoFieldAnnotation;
import org.broadinstitute.sting.oneoffprojects.refdata.HapmapVCFROD;
import org.broadinstitute.sting.utils.genotype.vcf.VCFInfoHeaderLine;
import java.util.Map;
import java.util.HashMap;
import java.util.Map;
/**
* IF THERE IS NO JAVADOC RIGHT HERE, YELL AT chartl
@ -33,17 +32,17 @@ public class ThousandGenomesAnnotator implements InfoFieldAnnotation {
if ( tracker == null )
return null;
RODRecordList pilot1 = tracker.getTrackData("pilot1",null);
RODRecordList pilot2 = tracker.getTrackData("pilot2",null);
HapmapVCFROD pilot1 = tracker.lookup("pilot1",HapmapVCFROD.class);
HapmapVCFROD pilot2 = tracker.lookup("pilot2",HapmapVCFROD.class);
String result;
if ( pilot1 == null && pilot2 == null) {
result = "0";
} else {
if ( pilot1 != null && ! ( (HapmapVCFROD) pilot1.get(0)).getRecord().isFiltered() ) {
if ( pilot1 != null && ! pilot1.getRecord().isFiltered() ) {
result = "1";
} else if ( pilot2 != null && ! ( (HapmapVCFROD) pilot2.get(0)).getRecord().isFiltered() ) {
} else if ( pilot2 != null && !pilot2.getRecord().isFiltered() ) {
result = "1";
} else {
result = "0";

8
java/src/org/broadinstitute/sting/oneoffprojects/walkers/varianteval/multisample/MultiSampleConcordanceWalker.java
View File

@ -3,7 +3,6 @@ package org.broadinstitute.sting.oneoffprojects.walkers.varianteval.multisample;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedDatum;
import org.broadinstitute.sting.gatk.refdata.RodVCF;
import org.broadinstitute.sting.gatk.walkers.DataSource;
import org.broadinstitute.sting.gatk.walkers.RMD;
@ -48,15 +47,14 @@ public class MultiSampleConcordanceWalker extends RodWalker< LocusConcordanceInf
if ( tracker == null ) {
return null;
}
RodVCF variantData = tracker.lookup("variants",RodVCF.class);
if ( ignoreKnownSites ) { // ignoreKnownSites && tracker.lookup("variants",null) != null && ! ( (RodVCF) tracker.lookup("variants",null)).isNovel() ) )
if ( tracker.lookup("variants",null) != null && ! ( (RodVCF) tracker.lookup("variants",null)).isNovel() ) {
if ( variantData != null && ! variantData.isNovel() ) {
//logger.info("Not novel: "+( (RodVCF) tracker.lookup("variants",null)).getID());
return null;
}
}
ReferenceOrderedDatum truthData = tracker.lookup("truth", null);
ReferenceOrderedDatum variantData = tracker.lookup("variants",null);
RodVCF truthData = tracker.lookup("truth",RodVCF.class);
LocusConcordanceInfo concordance;
if ( truthData == null && variantData == null) {

20
java/src/org/broadinstitute/sting/oneoffprojects/walkers/vcftools/BeagleTrioToVCFWalker.java
View File

@ -2,19 +2,21 @@ package org.broadinstitute.sting.oneoffprojects.walkers.vcftools;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.contexts.variantcontext.VariantContext;
import org.broadinstitute.sting.gatk.contexts.variantcontext.Genotype;
import org.broadinstitute.sting.gatk.contexts.variantcontext.Allele;
import org.broadinstitute.sting.gatk.contexts.variantcontext.Genotype;
import org.broadinstitute.sting.gatk.contexts.variantcontext.VariantContext;
import org.broadinstitute.sting.gatk.refdata.*;
import org.broadinstitute.sting.gatk.walkers.RodWalker;
import org.broadinstitute.sting.gatk.walkers.Requires;
import org.broadinstitute.sting.gatk.walkers.DataSource;
import org.broadinstitute.sting.gatk.walkers.RMD;
import org.broadinstitute.sting.utils.genotype.vcf.VCFWriter;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.gatk.walkers.Requires;
import org.broadinstitute.sting.gatk.walkers.RodWalker;
import org.broadinstitute.sting.oneoffprojects.walkers.varianteval2.MendelianViolationEvaluator;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.utils.genotype.vcf.VCFWriter;
import java.util.*;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
/**
* Test routine for new VariantContext object
@ -46,11 +48,11 @@ public class BeagleTrioToVCFWalker extends RodWalker<VariantContext, Long> {
if ( ref != null ) {
vc = tracker.getVariantContext(TRACK_NAME, null, context.getLocation(), false);
BeagleROD beagle = (BeagleROD)tracker.lookup(BEAGLE_NAME, null);
BeagleROD beagle = tracker.lookup(BEAGLE_NAME,BeagleROD.class);
if ( vc != null ) {
if ( ! headerWritten ) {
RodVCF vcfrod = (RodVCF)tracker.lookup(TRACK_NAME, null);
RodVCF vcfrod = tracker.lookup(TRACK_NAME,RodVCF.class);
writer.writeHeader(vcfrod.getHeader());
headerWritten = true;
}

7
java/src/org/broadinstitute/sting/oneoffprojects/walkers/vcftools/SimpleVCFIntersectWalker.java
View File

@ -5,12 +5,9 @@ import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.RodVCF;
import org.broadinstitute.sting.gatk.walkers.RodWalker;
import org.broadinstitute.sting.utils.ListUtils;
import org.broadinstitute.sting.utils.StingException;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.utils.genotype.vcf.*;
import java.lang.Long;
import java.util.*;
/**
@ -48,8 +45,8 @@ public class SimpleVCFIntersectWalker extends RodWalker<VCFRecordMerger,Long>{
return null;
}
RodVCF priorityCall = ( RodVCF ) tracker.lookup("priority",null);
RodVCF otherCall = ( RodVCF ) tracker.lookup("other",null);
RodVCF priorityCall = tracker.lookup("priority",RodVCF.class);
RodVCF otherCall = tracker.lookup("other",RodVCF.class);
if ( priorityCall == null && otherCall == null ) {
return null;

5
java/src/org/broadinstitute/sting/playground/gatk/walkers/DeNovoSNPWalker.java
View File

@ -44,8 +44,9 @@ public class DeNovoSNPWalker extends RefWalker<String, Integer>{
}
public String map(RefMetaDataTracker tracker, ReferenceContext ref, AlignmentContext context) {
VariationRod child = (VariationRod)tracker.lookup("child", null);
VariationRod dbsnp = (VariationRod)tracker.lookup("dbSNP", null);
VariationRod child = tracker.lookup("child",VariationRod.class);
VariationRod dbsnp = tracker.lookup("dbSNP",VariationRod.class);
if (child != null) {
if (child.isSNP() && child.getNegLog10PError() > 5) { // BTR > 5

27
java/src/org/broadinstitute/sting/playground/gatk/walkers/LocusMismatchWalker.java
View File

@ -1,17 +1,24 @@
package org.broadinstitute.sting.playground.gatk.walkers;
import org.broadinstitute.sting.gatk.walkers.*;
import org.broadinstitute.sting.gatk.walkers.genotyper.*;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedDatum;
import org.broadinstitute.sting.gatk.refdata.VariationRod;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.contexts.variantcontext.Genotype;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.VariationRod;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeature;
import org.broadinstitute.sting.gatk.walkers.By;
import org.broadinstitute.sting.gatk.walkers.DataSource;
import org.broadinstitute.sting.gatk.walkers.LocusWalker;
import org.broadinstitute.sting.gatk.walkers.TreeReducible;
import org.broadinstitute.sting.gatk.walkers.genotyper.BaseMismatchModel;
import org.broadinstitute.sting.gatk.walkers.genotyper.UnifiedArgumentCollection;
import org.broadinstitute.sting.gatk.walkers.genotyper.UnifiedGenotyperEngine;
import org.broadinstitute.sting.gatk.walkers.genotyper.VariantCallContext;
import org.broadinstitute.sting.utils.BaseUtils;
import org.broadinstitute.sting.utils.StingException;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.utils.*;
import org.broadinstitute.sting.utils.pileup.ReadBackedPileup;
import org.broadinstitute.sting.utils.pileup.PileupElement;
import org.broadinstitute.sting.utils.pileup.ReadBackedPileup;
/**
@ -142,8 +149,8 @@ public class LocusMismatchWalker extends LocusWalker<String,Integer> implements
}
private boolean notCoveredByVariations( RefMetaDataTracker tracker ) {
for ( ReferenceOrderedDatum datum : tracker.getAllRods() ) {
if ( datum instanceof VariationRod || datum instanceof Genotype ) {
for ( GATKFeature datum : tracker.getAllRods() ) {
if ( datum.getUnderlyingObject() instanceof VariationRod || datum.getUnderlyingObject() instanceof Genotype ) {
//System.out.printf("Ignoring site because of %s%n", datum);
return false;
}

13
java/src/org/broadinstitute/sting/playground/gatk/walkers/diagnostics/AlleleBalanceInspector.java
View File

@ -1,11 +1,10 @@
package org.broadinstitute.sting.playground.gatk.walkers.diagnostics;
import org.broadinstitute.sting.gatk.walkers.LocusWalker;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedDatum;
import org.broadinstitute.sting.gatk.refdata.RodGenotypeChipAsGFF;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.RodGenotypeChipAsGFF;
import org.broadinstitute.sting.gatk.walkers.LocusWalker;
import org.broadinstitute.sting.utils.BaseUtils;
/**
@ -19,13 +18,13 @@ public class AlleleBalanceInspector extends LocusWalker<Integer, Integer> {
}
public boolean filter(RefMetaDataTracker tracker, ReferenceContext ref, AlignmentContext context) {
RodGenotypeChipAsGFF hc = (RodGenotypeChipAsGFF) tracker.lookup("hapmap-chip", null);
RodGenotypeChipAsGFF hc = tracker.lookup("child",RodGenotypeChipAsGFF.class);
return hc != null && hc.getCalledGenotype().isVariant(ref.getBase());
}
public Integer map(RefMetaDataTracker tracker, ReferenceContext ref, AlignmentContext context) {
RodGenotypeChipAsGFF hc = (RodGenotypeChipAsGFF) tracker.lookup("hapmap-chip", null);
RodGenotypeChipAsGFF hc = tracker.lookup("child",RodGenotypeChipAsGFF.class);
String state;
if (hc.getCalledGenotype().isHet()) {

23
java/src/org/broadinstitute/sting/playground/gatk/walkers/diagnostics/SNPDensity.java
View File

@ -1,14 +1,15 @@
package org.broadinstitute.sting.playground.gatk.walkers.diagnostics;
import org.broadinstitute.sting.gatk.refdata.utils.RODRecordList;
import org.broadinstitute.sting.gatk.walkers.*;
import org.broadinstitute.sting.gatk.refdata.*;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.contexts.variantcontext.VariantContext;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.RodVCF;
import org.broadinstitute.sting.gatk.refdata.VariantContextAdaptors;
import org.broadinstitute.sting.gatk.walkers.*;
import org.broadinstitute.sting.utils.GenomeLoc;
import org.broadinstitute.sting.utils.Pair;
import org.broadinstitute.sting.utils.cmdLine.Argument;
/**
* Computes the density of SNPs passing and failing filters in intervals on the genome and emits a table for display
@ -38,15 +39,9 @@ public class SNPDensity extends RefWalker<Pair<VariantContext, GenomeLoc>, SNPDe
public Pair<VariantContext, GenomeLoc> map(RefMetaDataTracker tracker, ReferenceContext ref, AlignmentContext context) {
VariantContext vc = null;
RODRecordList vcfList = tracker.getTrackData("eval", null);
if (vcfList != null) {
for (ReferenceOrderedDatum d : vcfList) {
RodVCF vcfRecord = (RodVCF)d;
vc = VariantContextAdaptors.toVariantContext("eval", vcfRecord);
break;
}
}
RodVCF vcf = tracker.lookup("eval",RodVCF.class);
if (vcf != null)
vc = VariantContextAdaptors.toVariantContext("eval", vcf);
return new Pair<VariantContext, GenomeLoc>(vc, context.getLocation());
}

46
java/src/org/broadinstitute/sting/playground/gatk/walkers/graphalign/GraphReferenceBuilder.java
View File

@ -1,29 +1,27 @@
package org.broadinstitute.sting.playground.gatk.walkers.graphalign;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.refdata.*;
import org.broadinstitute.sting.gatk.walkers.*;
import org.broadinstitute.sting.gatk.walkers.fasta.FastaReferenceWalker;
import org.broadinstitute.sting.utils.*;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.utils.genotype.Variation;
import org.jgrapht.Graph;
import org.jgrapht.graph.DefaultEdge;
import org.jgrapht.graph.SimpleGraph;
import org.jgrapht.graph.SimpleDirectedGraph;
import org.apache.log4j.Logger;
import java.util.*;
import java.io.ObjectOutputStream;
import java.io.FileOutputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import net.sf.picard.reference.ReferenceSequence;
import net.sf.picard.reference.ReferenceSequenceFile;
import net.sf.picard.reference.ReferenceSequenceFileFactory;
import net.sf.samtools.util.StringUtil;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeature;
import org.broadinstitute.sting.gatk.walkers.DataSource;
import org.broadinstitute.sting.gatk.walkers.RefWalker;
import org.broadinstitute.sting.gatk.walkers.Requires;
import org.broadinstitute.sting.gatk.walkers.WalkerName;
import org.broadinstitute.sting.utils.GenomeLoc;
import org.broadinstitute.sting.utils.StingException;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.utils.genotype.Variation;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.Arrays;
import java.util.List;
/**
* A completely experimental walker that constructs a graphical reference that incorporates variation from provided
@ -86,10 +84,10 @@ public class GraphReferenceBuilder extends RefWalker<Integer, Integer> {
// }
boolean alreadyAddedAtThisLoc = false;
for ( ReferenceOrderedDatum rod : rodData.getAllRods() ) {
if ( rod instanceof Variation && ! alreadyAddedAtThisLoc ) {
for ( GATKFeature rod : rodData.getAllRods() ) {
if ( rod.getUnderlyingObject() instanceof Variation && ! alreadyAddedAtThisLoc ) {
// if we have multiple variants at a locus, just take the first damn one we see for now
Variation variant = (Variation) rod;
Variation variant = (Variation) rod.getUnderlyingObject();
// todo -- getAlternativeBases should be getAlleles()
GenomeLoc loc = variant.getLocation();
String[] allAllelesList = null; // variant.getAlternateBases().split(""); // todo fixme

16
java/src/org/broadinstitute/sting/playground/gatk/walkers/hybridselection/CoverageAcrossBaitsWalker.java
View File

@ -1,19 +1,21 @@
package org.broadinstitute.sting.playground.gatk.walkers.hybridselection;
import org.broadinstitute.sting.gatk.walkers.*;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.IntervalRod;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import net.sf.samtools.SAMRecord;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.refdata.IntervalRod;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.walkers.By;
import org.broadinstitute.sting.gatk.walkers.DataSource;
import org.broadinstitute.sting.gatk.walkers.LocusWalker;
import org.broadinstitute.sting.utils.GenomeLoc;
import org.broadinstitute.sting.utils.Pair;
import org.broadinstitute.sting.utils.StingException;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import net.sf.samtools.SAMRecord;
import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* Accumulates coverage across hybrid selection bait intervals to assess effect of bait adjacency and overlap on coverage
@ -55,8 +57,8 @@ public class CoverageAcrossBaitsWalker extends LocusWalker<Pair<Integer, Integer
public Pair<Integer, Integer> map(RefMetaDataTracker tracker, ReferenceContext ref, AlignmentContext context) {
List<SAMRecord> reads = context.getReads();
IntervalRod intervalROD = tracker.lookup("interval",IntervalRod.class);
IntervalRod intervalROD = (IntervalRod)tracker.lookup("interval", null);
GenomeLoc interval = intervalROD == null ? null : intervalROD.getLocation();
if (interval == null) { throw new StingException("No intervals at locus; should not happen"); }
int offset = (int)(context.getPosition() - interval.getStart());

56
java/src/org/broadinstitute/sting/playground/gatk/walkers/hybridselection/HybSelPerformanceWalker.java
View File

@ -1,30 +1,34 @@
package org.broadinstitute.sting.playground.gatk.walkers.hybridselection;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.refdata.utils.LocationAwareSeekableRODIterator;
import org.broadinstitute.sting.gatk.refdata.utils.RODRecordList;
import org.broadinstitute.sting.gatk.walkers.LocusWalker;
import org.broadinstitute.sting.gatk.walkers.By;
import org.broadinstitute.sting.gatk.walkers.DataSource;
import org.broadinstitute.sting.gatk.walkers.TreeReducible;
import org.broadinstitute.sting.gatk.refdata.*;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.utils.Pair;
import org.broadinstitute.sting.utils.GenomeLoc;
import org.broadinstitute.sting.utils.fasta.IndexedFastaSequenceFile;
import java.util.List;
import java.util.Collection;
import java.io.IOException;
import java.io.File;
import net.sf.samtools.SAMRecord;
import net.sf.samtools.util.StringUtil;
import net.sf.picard.reference.ReferenceSequence;
import net.sf.picard.util.Interval;
import net.sf.picard.util.OverlapDetector;
import net.sf.picard.util.IntervalList;
import net.sf.picard.util.OverlapDetector;
import net.sf.samtools.SAMRecord;
import net.sf.samtools.util.StringUtil;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedData;
import org.broadinstitute.sting.gatk.refdata.SeekableRODIterator;
import org.broadinstitute.sting.gatk.refdata.rodRefSeq;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeature;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeatureIterator;
import org.broadinstitute.sting.gatk.refdata.utils.LocationAwareSeekableRODIterator;
import org.broadinstitute.sting.gatk.refdata.utils.RODRecordList;
import org.broadinstitute.sting.gatk.walkers.By;
import org.broadinstitute.sting.gatk.walkers.DataSource;
import org.broadinstitute.sting.gatk.walkers.LocusWalker;
import org.broadinstitute.sting.gatk.walkers.TreeReducible;
import org.broadinstitute.sting.utils.GenomeLoc;
import org.broadinstitute.sting.utils.Pair;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.utils.fasta.IndexedFastaSequenceFile;
import java.io.File;
import java.io.IOException;
import java.util.Collection;
import java.util.List;
/**
* Given intervals corresponding to targets or baits in a hybrid selection experiment, this walker gives the following interval-by-interval data:
@ -82,7 +86,7 @@ public class HybSelPerformanceWalker extends LocusWalker<Integer, HybSelPerforma
ReferenceOrderedData<rodRefSeq> refseq = new ReferenceOrderedData<rodRefSeq>("refseq",
new java.io.File(REFSEQ_FILE), rodRefSeq.class);
refseqIterator = refseq.iterator();
refseqIterator = new SeekableRODIterator(new GATKFeatureIterator(refseq.iterator()));
logger.info("Using RefSeq annotations from "+REFSEQ_FILE);
}
@ -252,9 +256,9 @@ public class HybSelPerformanceWalker extends LocusWalker<Integer, HybSelPerforma
RODRecordList annotationList = refseqIterator.seekForward(target);
if (annotationList == null) { return "UNKNOWN"; }
for(ReferenceOrderedDatum rec : annotationList) {
if ( ((rodRefSeq)rec).overlapsExonP(target) ) {
return ((rodRefSeq)rec).getGeneName();
for(GATKFeature rec : annotationList) {
if ( ((rodRefSeq)rec.getUnderlyingObject()).overlapsExonP(target) ) {
return ((rodRefSeq)rec.getUnderlyingObject()).getGeneName();
}
}

24
java/src/org/broadinstitute/sting/playground/gatk/walkers/variantoptimizer/AnalyzeAnnotationsWalker.java
View File

@ -1,12 +1,12 @@
package org.broadinstitute.sting.playground.gatk.walkers.variantoptimizer;
import org.broadinstitute.sting.gatk.refdata.RodGLF;
import org.broadinstitute.sting.gatk.walkers.RodWalker;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedDatum;
import org.broadinstitute.sting.gatk.refdata.RodVCF;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.RodGLF;
import org.broadinstitute.sting.gatk.refdata.RodVCF;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeature;
import org.broadinstitute.sting.gatk.walkers.RodWalker;
import org.broadinstitute.sting.utils.StingException;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.utils.genotype.VariantBackedByGenotype;
@ -108,8 +108,9 @@ public class AnalyzeAnnotationsWalker extends RodWalker<Integer, Integer> {
// First find out if this variant is in the truth sets
boolean isInTruthSet = false;
boolean isTrueVariant = false;
for( final ReferenceOrderedDatum rod : tracker.getAllRods() ) {
if( rod != null && rod.getName().toUpperCase().startsWith("TRUTH") ) {
for( final GATKFeature feature : tracker.getAllRods() ) {
Object rod = feature.getUnderlyingObject();
if( rod != null && feature.getName().toUpperCase().startsWith("TRUTH") ) {
isInTruthSet = true;
// Next see if the truth sets say this site is variant or reference
@ -126,14 +127,15 @@ public class AnalyzeAnnotationsWalker extends RodWalker<Integer, Integer> {
isTrueVariant = true;
}
} else {
throw new StingException( "Truth ROD is of unknown ROD type: " + rod.getName() );
throw new StingException( "Truth ROD is of unknown ROD type: " + feature.getName() );
}
}
}
// Add each annotation in this VCF Record to the dataManager
for( final ReferenceOrderedDatum rod : tracker.getAllRods() ) {
if( rod != null && rod instanceof RodVCF && !rod.getName().toUpperCase().startsWith("TRUTH") ) {
for( final GATKFeature feature : tracker.getAllRods() ) {
Object rod = feature.getUnderlyingObject();
if( rod != null && rod instanceof RodVCF && !feature.getName().toUpperCase().startsWith("TRUTH") ) {
final RodVCF variant = (RodVCF) rod;
if( variant.isSNP() ) {
dataManager.addAnnotations( variant, SAMPLE_NAME, isInTruthSet, isTrueVariant );

5
java/src/org/broadinstitute/sting/playground/gatk/walkers/variantoptimizer/ApplyVariantClustersWalker.java
View File

@ -3,8 +3,8 @@ package org.broadinstitute.sting.playground.gatk.walkers.variantoptimizer;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedDatum;
import org.broadinstitute.sting.gatk.refdata.RodVCF;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeature;
import org.broadinstitute.sting.gatk.walkers.RodWalker;
import org.broadinstitute.sting.utils.*;
import org.broadinstitute.sting.utils.cmdLine.Argument;
@ -133,7 +133,8 @@ public class ApplyVariantClustersWalker extends RodWalker<ExpandingArrayList<Var
}
for( final ReferenceOrderedDatum rod : tracker.getAllRods() ) {
for( final GATKFeature feature : tracker.getAllRods() ) {
Object rod = feature.getUnderlyingObject();
if( rod != null && rod instanceof RodVCF ) {
final RodVCF rodVCF = ((RodVCF) rod);
//BUGBUG: figure out how to make this use VariantContext to be consistent with other VariantOptimizer walkers

4
java/src/org/broadinstitute/sting/playground/gatk/walkers/variantoptimizer/VariantConcordanceROCCurveWalker.java
View File

@ -82,10 +82,10 @@ public class VariantConcordanceROCCurveWalker extends RodWalker<ExpandingArrayLi
for( ReferenceOrderedDataSource rod : this.getToolkit().getRodDataSources() ) {
if( rod != null && !rod.getName().toUpperCase().startsWith("TRUTH") ) {
if( rod.getReferenceOrderedData().iterator().next().get(0) instanceof RodVCF ) {
if( rod.getReferenceOrderedData().getIterator().next().getUnderlyingObject() instanceof RodVCF ) {
inputRodNames.add(rod.getName());
if( sampleName == null ) {
sampleName = ((RodVCF)rod.getReferenceOrderedData().iterator().next().get(0)).getSampleNames()[0]; // BUGBUG: single sample calls only for now
sampleName = ((RodVCF)rod.getReferenceOrderedData().getIterator().next().getUnderlyingObject()).getSampleNames()[0]; // BUGBUG: single sample calls only for now
}
}
}

26
java/src/org/broadinstitute/sting/playground/gatk/walkers/vcftools/VCFCombine.java
View File

@ -1,15 +1,21 @@
package org.broadinstitute.sting.playground.gatk.walkers.vcftools;
import org.broadinstitute.sting.gatk.walkers.RodWalker;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.RodVCF;
import org.broadinstitute.sting.gatk.refdata.tracks.RMDTrack;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeature;
import org.broadinstitute.sting.gatk.walkers.Requires;
import org.broadinstitute.sting.gatk.refdata.*;
import org.broadinstitute.sting.gatk.contexts.*;
import org.broadinstitute.sting.utils.*;
import org.broadinstitute.sting.utils.genotype.vcf.*;
import org.broadinstitute.sting.gatk.walkers.RodWalker;
import org.broadinstitute.sting.utils.Pair;
import org.broadinstitute.sting.utils.SampleUtils;
import org.broadinstitute.sting.utils.StingException;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.utils.genotype.vcf.*;
import java.util.*;
import java.io.File;
import java.util.*;
/**
* Combines VCF records from different sources; supports both full merges and set unions.
@ -82,7 +88,7 @@ public class VCFCombine extends RodWalker<VCFRecord, VCFWriter> {
}
private void validateAnnotateUnionArguments(String[] priority) {
Set<ReferenceOrderedData> rods = VCFUtils.getRodVCFs(getToolkit());
Set<RMDTrack> rods = VCFUtils.getRodVCFs(getToolkit());
if ( rods.size() != priority.length ) {
throw new StingException("A complete priority list must be provided when annotateUnion is provided");
}
@ -92,7 +98,7 @@ public class VCFCombine extends RodWalker<VCFRecord, VCFWriter> {
for ( String p : priority ) {
boolean good = false;
for ( ReferenceOrderedData data : rods ) {
for ( RMDTrack data : rods ) {
if ( p.equals(data.getName()) )
good = true;
}
@ -106,9 +112,9 @@ public class VCFCombine extends RodWalker<VCFRecord, VCFWriter> {
// get all of the vcf rods at this locus
ArrayList<RodVCF> vcfRods = new ArrayList<RodVCF>();
Iterator<ReferenceOrderedDatum> rods = tracker.getAllRods().iterator();
Iterator<GATKFeature> rods = tracker.getAllRods().iterator();
while (rods.hasNext()) {
ReferenceOrderedDatum rod = rods.next();
Object rod = rods.next().getUnderlyingObject();
if ( rod instanceof RodVCF )
vcfRods.add((RodVCF)rod);
}

26
java/src/org/broadinstitute/sting/playground/gatk/walkers/vcftools/VCFSelectWalker.java
View File

@ -1,16 +1,21 @@
package org.broadinstitute.sting.playground.gatk.walkers.vcftools;
import org.broadinstitute.sting.gatk.contexts.*;
import org.broadinstitute.sting.gatk.refdata.*;
import org.broadinstitute.sting.gatk.refdata.utils.RODRecordList;
import org.broadinstitute.sting.gatk.walkers.*;
import org.broadinstitute.sting.gatk.datasources.simpleDataSources.ReferenceOrderedDataSource;
import org.broadinstitute.sting.utils.*;
import org.broadinstitute.sting.utils.genotype.vcf.*;
import org.apache.commons.jexl.Expression;
import org.apache.commons.jexl.ExpressionFactory;
import org.apache.commons.jexl.JexlContext;
import org.apache.commons.jexl.JexlHelper;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.RodVCF;
import org.broadinstitute.sting.gatk.walkers.RMD;
import org.broadinstitute.sting.gatk.walkers.Requires;
import org.broadinstitute.sting.gatk.walkers.RodWalker;
import org.broadinstitute.sting.utils.StingException;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.utils.genotype.vcf.*;
import java.util.*;
import org.apache.commons.jexl.*;
/**
* Selects variant calls for output from a user-supplied VCF file using a number of user-selectable, parameterizable criteria.
@ -78,12 +83,11 @@ public class VCFSelectWalker extends RodWalker<Integer, Integer> {
if ( tracker == null )
return 0;
RODRecordList rods = tracker.getTrackData("variant", null);
RodVCF variant = tracker.lookup("variant",RodVCF.class);
// ignore places where we don't have a variant
if ( rods == null || rods.size() == 0 )
if ( variant == null )
return 0;
RodVCF variant = (RodVCF)rods.get(0);
boolean someoneMatched = false;
for ( MatchExp exp : matchExpressions ) {
Map<String, String> infoMap = new HashMap<String, String>(variant.mCurrentRecord.getInfoValues());

19
java/src/org/broadinstitute/sting/playground/gatk/walkers/vcftools/VCFSubsetWalker.java
View File

@ -1,16 +1,18 @@
package org.broadinstitute.sting.playground.gatk.walkers.vcftools;
import org.broadinstitute.sting.gatk.walkers.RodWalker;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedDatum;
import org.broadinstitute.sting.gatk.refdata.RodVCF;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.contexts.AlignmentContext;
import org.broadinstitute.sting.utils.genotype.vcf.*;
import org.broadinstitute.sting.gatk.contexts.ReferenceContext;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.RodVCF;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeature;
import org.broadinstitute.sting.gatk.walkers.RodWalker;
import org.broadinstitute.sting.utils.cmdLine.Argument;
import org.broadinstitute.sting.utils.genotype.vcf.*;
import java.util.*;
import java.io.File;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;
/**
* Extracts subsets of a VCF file like one or more samples, all or only variant loci, all or filtered loci.
@ -51,7 +53,8 @@ public class VCFSubsetWalker extends RodWalker<ArrayList<VCFRecord>, VCFWriter>
ArrayList<VCFRecord> records = new ArrayList<VCFRecord>();
if (tracker != null) {
for (ReferenceOrderedDatum rod : tracker.getAllRods()) {
for (GATKFeature feature : tracker.getAllRods()) {
Object rod = feature.getUnderlyingObject();
if (rod instanceof RodVCF) {
RodVCF vcfrod = (RodVCF) rod;
VCFRecord record = vcfrod.mCurrentRecord;

17
java/src/org/broadinstitute/sting/utils/SampleUtils.java
View File

@ -1,16 +1,15 @@
package org.broadinstitute.sting.utils;
import net.sf.samtools.SAMReadGroupRecord;
import net.sf.samtools.SAMFileHeader;
import net.sf.samtools.SAMReadGroupRecord;
import org.broadinstitute.sting.gatk.GenomeAnalysisEngine;
import org.broadinstitute.sting.gatk.datasources.simpleDataSources.ReferenceOrderedDataSource;
import org.broadinstitute.sting.gatk.refdata.RodVCF;
import org.broadinstitute.sting.gatk.refdata.tracks.RMDTrack;
import org.broadinstitute.sting.utils.genotype.vcf.VCFReader;
import java.util.*;
import org.broadinstitute.sting.utils.genotype.vcf.VCFReader;
import org.broadinstitute.sting.gatk.GenomeAnalysisEngine;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedData;
import org.broadinstitute.sting.gatk.refdata.RodVCF;
import org.broadinstitute.sting.gatk.datasources.simpleDataSources.ReferenceOrderedDataSource;
/**
* SampleUtils is a static class (no instantiation allowed!) with some utility methods for getting samples
@ -53,7 +52,7 @@ public class SampleUtils {
// iterate to get all of the sample names
List<ReferenceOrderedDataSource> dataSources = toolkit.getRodDataSources();
for ( ReferenceOrderedDataSource source : dataSources ) {
ReferenceOrderedData rod = source.getReferenceOrderedData();
RMDTrack rod = source.getReferenceOrderedData();
if ( rod.getType().equals(RodVCF.class) ) {
VCFReader reader = new VCFReader(rod.getFile());
samples.addAll(reader.getHeader().getGenotypeSamples());
@ -82,7 +81,7 @@ public class SampleUtils {
// iterate to get all of the sample names
List<ReferenceOrderedDataSource> dataSources = toolkit.getRodDataSources();
for ( ReferenceOrderedDataSource source : dataSources ) {
ReferenceOrderedData rod = source.getReferenceOrderedData();
RMDTrack rod = source.getReferenceOrderedData();
if ( rod.getType().equals(RodVCF.class) ) {
VCFReader reader = new VCFReader(rod.getFile());
Set<String> vcfSamples = reader.getHeader().getGenotypeSamples();

14
java/src/org/broadinstitute/sting/utils/genotype/vcf/VCFUtils.java
View File

@ -1,9 +1,9 @@
package org.broadinstitute.sting.utils.genotype.vcf;
import org.broadinstitute.sting.gatk.datasources.simpleDataSources.ReferenceOrderedDataSource;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedData;
import org.broadinstitute.sting.gatk.refdata.RodVCF;
import org.broadinstitute.sting.gatk.GenomeAnalysisEngine;
import org.broadinstitute.sting.gatk.datasources.simpleDataSources.ReferenceOrderedDataSource;
import org.broadinstitute.sting.gatk.refdata.RodVCF;
import org.broadinstitute.sting.gatk.refdata.tracks.RMDTrack;
import org.broadinstitute.sting.utils.Pair;
import org.broadinstitute.sting.utils.Utils;
@ -18,11 +18,11 @@ public class VCFUtils {
*/
private VCFUtils() { }
public static Set<ReferenceOrderedData> getRodVCFs(GenomeAnalysisEngine toolkit) {
Set<ReferenceOrderedData> vcfs = new HashSet<ReferenceOrderedData>();
public static Set<RMDTrack> getRodVCFs(GenomeAnalysisEngine toolkit) {
Set<RMDTrack> vcfs = new HashSet<RMDTrack>();
for ( ReferenceOrderedDataSource source : toolkit.getRodDataSources() ) {
ReferenceOrderedData rod = source.getReferenceOrderedData();
RMDTrack rod = source.getReferenceOrderedData();
if ( rod.getType().equals(RodVCF.class) ) {
vcfs.add(rod);
}
@ -46,7 +46,7 @@ public class VCFUtils {
// iterate to get all of the sample names
List<ReferenceOrderedDataSource> dataSources = toolkit.getRodDataSources();
for ( ReferenceOrderedDataSource source : dataSources ) {
ReferenceOrderedData rod = source.getReferenceOrderedData();
RMDTrack rod = source.getReferenceOrderedData();
if ( rod.getType().equals(RodVCF.class) ) {
VCFReader reader = new VCFReader(rod.getFile());
fields.addAll(reader.getHeader().getMetaData());

15
java/test/org/broadinstitute/sting/gatk/datasources/providers/ReadBasedReferenceOrderedViewTest.java
View File

@ -28,7 +28,7 @@ import net.sf.samtools.SAMRecord;
import org.broadinstitute.sting.BaseTest;
import org.broadinstitute.sting.gatk.refdata.ReadMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.ReadMetaDataTrackerTest;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedDatum;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeature;
import org.broadinstitute.sting.gatk.refdata.utils.LocationAwareSeekableRODIterator;
import org.broadinstitute.sting.gatk.refdata.utils.RODRecordList;
import org.broadinstitute.sting.utils.GenomeLoc;
@ -81,7 +81,7 @@ public class ReadBasedReferenceOrderedViewTest extends BaseTest {
for (SAMRecord rec : records) {
ReadMetaDataTracker tracker = view.getReferenceOrderedDataForRead(rec);
Map<Long, Collection<ReferenceOrderedDatum>> map = tracker.getReadOffsetMapping();
Map<Long, Collection<GATKFeature>> map = tracker.getReadOffsetMapping();
for (Long i : map.keySet()) {
Assert.assertEquals(1, map.get(i).size());
}
@ -97,13 +97,12 @@ class FakePeekingRODIterator implements LocationAwareSeekableRODIterator {
// current location
private GenomeLoc location;
private ReadMetaDataTrackerTest.FakeRODatum curROD;
private GATKFeature curROD;
private final String name;
public FakePeekingRODIterator(GenomeLoc startingLoc, String name) {
this.name = name;
this.location = GenomeLocParser.createGenomeLoc(startingLoc.getContigIndex(), startingLoc.getStart() + 1, startingLoc.getStop() + 1);
;
}
@Override
@ -145,15 +144,15 @@ class FakePeekingRODIterator implements LocationAwareSeekableRODIterator {
}
}
class FakeRODRecordList extends AbstractList<ReferenceOrderedDatum> implements RODRecordList {
private final List<ReferenceOrderedDatum> list = new ArrayList<ReferenceOrderedDatum>();
class FakeRODRecordList extends AbstractList<GATKFeature> implements RODRecordList {
private final List<GATKFeature> list = new ArrayList<GATKFeature>();
public boolean add(ReferenceOrderedDatum data) {
public boolean add(GATKFeature data) {
return list.add(data);
}
@Override
public ReferenceOrderedDatum get(int i) {
public GATKFeature get(int i) {
return list.get(i);
}

37
java/test/org/broadinstitute/sting/gatk/datasources/providers/ReferenceOrderedViewTest.java
View File

@ -1,22 +1,23 @@
package org.broadinstitute.sting.gatk.datasources.providers;
import org.junit.Test;
import org.junit.BeforeClass;
import org.junit.Assert;
import org.broadinstitute.sting.utils.fasta.IndexedFastaSequenceFile;
import org.broadinstitute.sting.utils.GenomeLocParser;
import org.broadinstitute.sting.BaseTest;
import org.broadinstitute.sting.gatk.datasources.shards.LocusShard;
import org.broadinstitute.sting.gatk.datasources.shards.Shard;
import org.broadinstitute.sting.gatk.datasources.simpleDataSources.ReferenceOrderedDataSource;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedData;
import org.broadinstitute.sting.gatk.refdata.TabularROD;
import org.broadinstitute.sting.gatk.refdata.RefMetaDataTracker;
import org.broadinstitute.sting.gatk.datasources.shards.Shard;
import org.broadinstitute.sting.gatk.datasources.shards.LocusShard;
import org.broadinstitute.sting.gatk.datasources.simpleDataSources.ReferenceOrderedDataSource;
import org.broadinstitute.sting.BaseTest;
import org.broadinstitute.sting.gatk.refdata.tracks.RODRMDTrack;
import org.broadinstitute.sting.utils.GenomeLocParser;
import org.broadinstitute.sting.utils.fasta.IndexedFastaSequenceFile;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Collections;
import java.util.Arrays;
import java.util.Collections;
/**
* User: hanna
* Date: May 27, 2009
@ -57,7 +58,7 @@ public class ReferenceOrderedViewTest extends BaseTest {
ReferenceOrderedView view = new ManagingReferenceOrderedView( provider );
RefMetaDataTracker tracker = view.getReferenceOrderedDataAtLocus(GenomeLocParser.createGenomeLoc("chrM",10));
Assert.assertNull("The tracker should not have produced any data", tracker.lookup("tableTest",null));
Assert.assertEquals("The tracker should not have produced any data", 0, tracker.getAllRods().size());
}
/**
@ -67,7 +68,7 @@ public class ReferenceOrderedViewTest extends BaseTest {
public void testSingleBinding() {
File file = new File(testDir + "TabularDataTest.dat");
ReferenceOrderedData rod = new ReferenceOrderedData("tableTest", file, TabularROD.class);
ReferenceOrderedDataSource dataSource = new ReferenceOrderedDataSource(null,rod);
ReferenceOrderedDataSource dataSource = new ReferenceOrderedDataSource(null, new RODRMDTrack(TabularROD.class,"tableTest",file,rod));
Shard shard = new LocusShard(Collections.singletonList(GenomeLocParser.createGenomeLoc("chrM",1,30)));
@ -75,7 +76,7 @@ public class ReferenceOrderedViewTest extends BaseTest {
ReferenceOrderedView view = new ManagingReferenceOrderedView( provider );
RefMetaDataTracker tracker = view.getReferenceOrderedDataAtLocus(GenomeLocParser.createGenomeLoc("chrM",20));
TabularROD datum = (TabularROD)tracker.lookup("tableTest",null);
TabularROD datum = tracker.lookup("tableTest",TabularROD.class);
Assert.assertEquals("datum parameter for COL1 is incorrect", "C", datum.get("COL1"));
Assert.assertEquals("datum parameter for COL2 is incorrect", "D", datum.get("COL2"));
@ -90,9 +91,9 @@ public class ReferenceOrderedViewTest extends BaseTest {
File file = new File(testDir + "TabularDataTest.dat");
ReferenceOrderedData rod1 = new ReferenceOrderedData("tableTest1", file, TabularROD.class);
ReferenceOrderedDataSource dataSource1 = new ReferenceOrderedDataSource(null,rod1);
ReferenceOrderedDataSource dataSource1 = new ReferenceOrderedDataSource(null,new RODRMDTrack(TabularROD.class,"tableTest1",file,rod1));
ReferenceOrderedData rod2 = new ReferenceOrderedData("tableTest2", file, TabularROD.class);
ReferenceOrderedDataSource dataSource2 = new ReferenceOrderedDataSource(null,rod2);
ReferenceOrderedDataSource dataSource2 = new ReferenceOrderedDataSource(null,new RODRMDTrack(TabularROD.class,"tableTest2",file,rod2));;
Shard shard = new LocusShard(Collections.singletonList(GenomeLocParser.createGenomeLoc("chrM",1,30)));
@ -101,13 +102,13 @@ public class ReferenceOrderedViewTest extends BaseTest {
ReferenceOrderedView view = new ManagingReferenceOrderedView( provider );
RefMetaDataTracker tracker = view.getReferenceOrderedDataAtLocus(GenomeLocParser.createGenomeLoc("chrM",20));
TabularROD datum1 = (TabularROD)tracker.lookup("tableTest1",null);
TabularROD datum1 = tracker.lookup("tableTest1",TabularROD.class);
Assert.assertEquals("datum1 parameter for COL1 is incorrect", "C", datum1.get("COL1"));
Assert.assertEquals("datum1 parameter for COL2 is incorrect", "D", datum1.get("COL2"));
Assert.assertEquals("datum1 parameter for COL3 is incorrect", "E", datum1.get("COL3"));
TabularROD datum2 = (TabularROD)tracker.lookup("tableTest2",null);
TabularROD datum2 = tracker.lookup("tableTest2",TabularROD.class);
Assert.assertEquals("datum2 parameter for COL1 is incorrect", "C", datum2.get("COL1"));
Assert.assertEquals("datum2 parameter for COL2 is incorrect", "D", datum2.get("COL2"));

42
java/test/org/broadinstitute/sting/gatk/datasources/simpleDataSources/ReferenceOrderedDataPoolTest.java
View File

@ -1,21 +1,23 @@
package org.broadinstitute.sting.gatk.datasources.simpleDataSources;
import org.broadinstitute.sting.gatk.refdata.utils.FlashBackIterator;
import org.broadinstitute.sting.BaseTest;
import org.broadinstitute.sting.gatk.refdata.ReferenceOrderedData;
import org.broadinstitute.sting.gatk.refdata.TabularROD;
import org.broadinstitute.sting.gatk.refdata.tracks.RMDTrack;
import org.broadinstitute.sting.gatk.refdata.tracks.RODRMDTrack;
import org.broadinstitute.sting.gatk.refdata.utils.LocationAwareSeekableRODIterator;
import org.broadinstitute.sting.utils.GenomeLoc;
import org.broadinstitute.sting.utils.GenomeLocParser;
import org.broadinstitute.sting.utils.fasta.IndexedFastaSequenceFile;
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.Assert;
import static org.junit.Assert.assertTrue;
import org.broadinstitute.sting.BaseTest;
import org.broadinstitute.sting.utils.fasta.IndexedFastaSequenceFile;
import org.broadinstitute.sting.utils.GenomeLoc;
import org.broadinstitute.sting.utils.GenomeLocParser;
import org.broadinstitute.sting.gatk.refdata.*;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Collections;
import static org.junit.Assert.assertTrue;
/**
* User: hanna
* Date: May 21, 2009
@ -35,7 +37,7 @@ import java.util.Collections;
public class ReferenceOrderedDataPoolTest extends BaseTest {
private ReferenceOrderedData<? extends ReferenceOrderedDatum> rod = null;
private RMDTrack rod = null;
private final GenomeLoc testSite1 = GenomeLocParser.createGenomeLoc("chrM",10);
private final GenomeLoc testSite2 = GenomeLocParser.createGenomeLoc("chrM",20);
@ -51,7 +53,7 @@ public class ReferenceOrderedDataPoolTest extends BaseTest {
@Before
public void setUp() {
File file = new File(testDir + "TabularDataTest.dat");
rod = new ReferenceOrderedData("tableTest", file, TabularROD.class);
rod = new RODRMDTrack(TabularROD.class, "tableTest", file, new ReferenceOrderedData("tableTest", file, TabularROD.class));
}
@Test
@ -62,7 +64,7 @@ public class ReferenceOrderedDataPoolTest extends BaseTest {
Assert.assertEquals("Number of iterators in the pool is incorrect", 1, iteratorPool.numIterators());
Assert.assertEquals("Number of available iterators in the pool is incorrect", 0, iteratorPool.numAvailableIterators());
TabularROD datum = (TabularROD)iterator.next().get(0);
TabularROD datum = (TabularROD)iterator.next().get(0).getUnderlyingObject();
assertTrue(datum.getLocation().equals(testSite1));
assertTrue(datum.get("COL1").equals("A"));
@ -88,26 +90,26 @@ public class ReferenceOrderedDataPoolTest extends BaseTest {
// Test out-of-order access: first iterator2, then iterator1.
// Ugh...first call to a region needs to be a seek.
TabularROD datum = (TabularROD)iterator2.seekForward(testSite2).get(0);
TabularROD datum = (TabularROD)iterator2.seekForward(testSite2).get(0).getUnderlyingObject();
assertTrue(datum.getLocation().equals(testSite2));
assertTrue(datum.get("COL1").equals("C"));
assertTrue(datum.get("COL2").equals("D"));
assertTrue(datum.get("COL3").equals("E"));
datum = (TabularROD)iterator1.next().get(0);
datum = (TabularROD)iterator1.next().get(0).getUnderlyingObject();
assertTrue(datum.getLocation().equals(testSite1));
assertTrue(datum.get("COL1").equals("A"));
assertTrue(datum.get("COL2").equals("B"));
assertTrue(datum.get("COL3").equals("C"));
// Advance iterator2, and make sure both iterator's contents are still correct.
datum = (TabularROD)iterator2.next().get(0);
datum = (TabularROD)iterator2.next().get(0).getUnderlyingObject();
assertTrue(datum.getLocation().equals(testSite3));
assertTrue(datum.get("COL1").equals("F"));
assertTrue(datum.get("COL2").equals("G"));
assertTrue(datum.get("COL3").equals("H"));
datum = (TabularROD)iterator1.next().get(0);
datum = (TabularROD)iterator1.next().get(0).getUnderlyingObject();
assertTrue(datum.getLocation().equals(testSite2));
assertTrue(datum.get("COL1").equals("C"));
assertTrue(datum.get("COL2").equals("D"));
@ -133,7 +135,7 @@ public class ReferenceOrderedDataPoolTest extends BaseTest {
Assert.assertEquals("Number of iterators in the pool is incorrect", 1, iteratorPool.numIterators());
Assert.assertEquals("Number of available iterators in the pool is incorrect", 0, iteratorPool.numAvailableIterators());
TabularROD datum = (TabularROD)iterator.next().get(0);
TabularROD datum = (TabularROD)iterator.next().get(0).getUnderlyingObject();
assertTrue(datum.getLocation().equals(testSite1));
assertTrue(datum.get("COL1").equals("A"));
assertTrue(datum.get("COL2").equals("B"));
@ -148,7 +150,7 @@ public class ReferenceOrderedDataPoolTest extends BaseTest {
Assert.assertEquals("Number of iterators in the pool is incorrect", 1, iteratorPool.numIterators());
Assert.assertEquals("Number of available iterators in the pool is incorrect", 0, iteratorPool.numAvailableIterators());
datum = (TabularROD)iterator.seekForward(testSite3).get(0);
datum = (TabularROD)iterator.seekForward(testSite3).get(0).getUnderlyingObject();
assertTrue(datum.getLocation().equals(testSite3));
assertTrue(datum.get("COL1").equals("F"));
assertTrue(datum.get("COL2").equals("G"));
@ -168,7 +170,7 @@ public class ReferenceOrderedDataPoolTest extends BaseTest {
Assert.assertEquals("Number of iterators in the pool is incorrect", 1, iteratorPool.numIterators());
Assert.assertEquals("Number of available iterators in the pool is incorrect", 0, iteratorPool.numAvailableIterators());
TabularROD datum = (TabularROD)iterator.seekForward(testSite3).get(0);
TabularROD datum = (TabularROD)iterator.seekForward(testSite3).get(0).getUnderlyingObject();
assertTrue(datum.getLocation().equals(testSite3));
assertTrue(datum.get("COL1").equals("F"));
assertTrue(datum.get("COL2").equals("G"));
@ -183,7 +185,7 @@ public class ReferenceOrderedDataPoolTest extends BaseTest {
Assert.assertEquals("Number of iterators in the pool is incorrect", 2, iteratorPool.numIterators());
Assert.assertEquals("Number of available iterators in the pool is incorrect", 1, iteratorPool.numAvailableIterators());
datum = (TabularROD)iterator.next().get(0);
datum = (TabularROD)iterator.next().get(0).getUnderlyingObject();
assertTrue(datum.getLocation().equals(testSite1));
assertTrue(datum.get("COL1").equals("A"));
assertTrue(datum.get("COL2").equals("B"));

68
java/test/org/broadinstitute/sting/gatk/refdata/ReadMetaDataTrackerTest.java
View File

@ -27,6 +27,7 @@ import net.sf.samtools.SAMFileHeader;
import net.sf.samtools.SAMRecord;
import org.broadinstitute.sting.BaseTest;
import org.broadinstitute.sting.gatk.datasources.providers.RODMetaDataContainer;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeature;
import org.broadinstitute.sting.utils.GenomeLoc;
import org.broadinstitute.sting.utils.GenomeLocParser;
import org.broadinstitute.sting.utils.sam.ArtificialSAMUtils;
@ -35,9 +36,6 @@ import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.*;
@ -103,7 +101,7 @@ public class ReadMetaDataTrackerTest extends BaseTest {
// count the positions
int count = 0;
Map<Long, Collection<ReferenceOrderedDatum>> map = tracker.getReadOffsetMapping("default");
Map<Long, Collection<GATKFeature>> map = tracker.getReadOffsetMapping("default");
for (Long x : map.keySet()) {
count++;
Assert.assertEquals(1, map.get(x).size());
@ -117,7 +115,7 @@ public class ReadMetaDataTrackerTest extends BaseTest {
ReadMetaDataTracker tracker = getRMDT(1, nameSet, false); // create both RODs of the same type
// count the positions
int count = 0;
Map<Long, Collection<ReferenceOrderedDatum>> map = tracker.getReadOffsetMapping(FakeRODatum.class);
Map<Long, Collection<GATKFeature>> map = tracker.getReadOffsetMapping(FakeRODatum.class);
for (Long x : map.keySet()) {
count++;
Assert.assertEquals(2, map.get(x).size());
@ -136,7 +134,7 @@ public class ReadMetaDataTrackerTest extends BaseTest {
ReadMetaDataTracker tracker = getRMDT(1, nameSet, false); // create both RODs of the same type
// count the positions
int count = 0;
Map<Long, Collection<ReferenceOrderedDatum>> map = tracker.getReadOffsetMapping(FakeRODatum.class);
Map<Long, Collection<GATKFeature>> map = tracker.getReadOffsetMapping(FakeRODatum.class);
for (Long x : map.keySet()) {
count++;
Assert.assertEquals(y + 2, map.get(x).size());
@ -155,7 +153,7 @@ public class ReadMetaDataTrackerTest extends BaseTest {
// count the positions
int count = 0;
Map<Long, Collection<ReferenceOrderedDatum>> map = tracker.getReadOffsetMapping(Fake2RODatum.class);
Map<Long, Collection<GATKFeature>> map = tracker.getReadOffsetMapping(Fake2RODatum.class);
for (long x : map.keySet()) {
count++;
Assert.assertEquals(1, map.get(x).size());
@ -230,12 +228,13 @@ public class ReadMetaDataTrackerTest extends BaseTest {
/** for testing only */
static public class FakeRODatum implements ReferenceOrderedDatum {
static public class FakeRODatum extends GATKFeature {
final GenomeLoc location;
final String name;
public FakeRODatum(GenomeLoc location, String name) {
super(name);
this.location = location;
this.name = name;
}
@ -245,52 +244,29 @@ public class ReadMetaDataTrackerTest extends BaseTest {
return name;
}
@Override
public boolean parseLine(Object header, String[] parts) throws IOException {
return false;
}
@Override
public String toSimpleString() {
return "";
}
@Override
public String repl() {
return "";
}
/**
* Used by the ROD system to determine how to split input lines
*
* @return Regex string delimiter separating fields
*/
@Override
public String delimiterRegex() {
return "";
}
@Override
public GenomeLoc getLocation() {
return location;
return this.location;
}
@Override
public int compareTo(ReferenceOrderedDatum that) {
return location.compareTo(that.getLocation());
public Object getUnderlyingObject() {
return null; //To change body of implemented methods use File | Settings | File Templates.
}
/**
* Backdoor hook to read header, meta-data, etc. associated with the file. Will be
* called by the ROD system before streaming starts
*
* @param source source data file on disk from which this rod stream will be pulled
*
* @return a header object that will be passed to parseLine command
*/
@Override
public Object initialize(File source) throws FileNotFoundException {
return null;
public String getChr() {
return location.getContig();
}
@Override
public int getStart() {
return (int)this.location.getStart();
}
@Override
public int getEnd() {
return (int)this.location.getStop();
}
}
}

57
java/test/org/broadinstitute/sting/gatk/refdata/TabularRODTest.java
View File

@ -4,22 +4,25 @@ package org.broadinstitute.sting.gatk.refdata;
// the imports for unit testing.
import net.sf.picard.reference.ReferenceSequenceFile;
import org.broadinstitute.sting.BaseTest;
import org.broadinstitute.sting.gatk.refdata.utils.GATKFeatureIterator;
import org.broadinstitute.sting.gatk.refdata.utils.LocationAwareSeekableRODIterator;
import org.broadinstitute.sting.gatk.refdata.utils.RODRecordList;
import org.junit.*;
import static org.junit.Assert.assertTrue;
import org.broadinstitute.sting.BaseTest;
import org.broadinstitute.sting.utils.fasta.IndexedFastaSequenceFile;
import org.broadinstitute.sting.utils.GenomeLocParser;
import org.broadinstitute.sting.utils.fasta.IndexedFastaSequenceFile;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import java.io.File;
import java.io.PrintStream;
import java.io.FileOutputStream;
import java.io.FileNotFoundException;
import java.util.Arrays;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Arrays;
import net.sf.picard.reference.ReferenceSequenceFile;
import static org.junit.Assert.assertTrue;
/**
* Basic unit test for TabularROD
@ -43,7 +46,7 @@ public class TabularRODTest extends BaseTest {
TabularROD.setDelimiter(TabularROD.DEFAULT_DELIMITER, TabularROD.DEFAULT_DELIMITER_REGEX);
File file = new File(testDir + "TabularDataTest.dat");
ROD = new ReferenceOrderedData("tableTest", file, TabularROD.class);
iter = ROD.iterator();
iter = new SeekableRODIterator(new GATKFeatureIterator(ROD.iterator()));
}
@ -51,7 +54,7 @@ public class TabularRODTest extends BaseTest {
public void test1() {
logger.warn("Executing test1");
RODRecordList oneList = iter.next();
TabularROD one = (TabularROD)oneList.get(0);
TabularROD one = (TabularROD)oneList.get(0).getUnderlyingObject();
assertTrue(one.size() == 4);
assertTrue(one.getLocation().equals(GenomeLocParser.createGenomeLoc("chrM", 10)));
assertTrue(one.get("COL1").equals("A"));
@ -64,8 +67,8 @@ public class TabularRODTest extends BaseTest {
logger.warn("Executing test2");
RODRecordList oneList = iter.next();
RODRecordList twoList = iter.next();
TabularROD one = (TabularROD)oneList.get(0);
TabularROD two = (TabularROD)twoList.get(0);
TabularROD one = (TabularROD)oneList.get(0).getUnderlyingObject();
TabularROD two = (TabularROD)twoList.get(0).getUnderlyingObject();
assertTrue(two.size() == 4);
assertTrue(two.getLocation().equals(GenomeLocParser.createGenomeLoc("chrM", 20)));
assertTrue(two.get("COL1").equals("C"));
@ -79,9 +82,9 @@ public class TabularRODTest extends BaseTest {
RODRecordList oneList = iter.next();
RODRecordList twoList = iter.next();
RODRecordList threeList = iter.next();
TabularROD one = (TabularROD)oneList.get(0);
TabularROD two = (TabularROD)twoList.get(0);
TabularROD three = (TabularROD)threeList.get(0);
TabularROD one = (TabularROD)oneList.get(0).getUnderlyingObject();
TabularROD two = (TabularROD)twoList.get(0).getUnderlyingObject();
TabularROD three = (TabularROD)threeList.get(0).getUnderlyingObject();
assertTrue(three.size() == 4);
assertTrue(three.getLocation().equals(GenomeLocParser.createGenomeLoc("chrM", 30)));
assertTrue(three.get("COL1").equals("F"));
@ -95,9 +98,9 @@ public class TabularRODTest extends BaseTest {
RODRecordList oneList = iter.next();
RODRecordList twoList = iter.next();
RODRecordList threeList = iter.next();
TabularROD one = (TabularROD)oneList.get(0);
TabularROD two = (TabularROD)twoList.get(0);
TabularROD three = (TabularROD)threeList.get(0);
TabularROD one = (TabularROD)oneList.get(0).getUnderlyingObject();
TabularROD two = (TabularROD)twoList.get(0).getUnderlyingObject();
TabularROD three = (TabularROD)threeList.get(0).getUnderlyingObject();
assertTrue(!iter.hasNext());
}
@ -105,7 +108,7 @@ public class TabularRODTest extends BaseTest {
public void testSeek() {
logger.warn("Executing testSeek");
RODRecordList twoList = iter.seekForward(GenomeLocParser.createGenomeLoc("chrM", 20));
TabularROD two = (TabularROD)twoList.get(0);
TabularROD two = (TabularROD)twoList.get(0).getUnderlyingObject();
assertTrue(two.size() == 4);
assertTrue(two.getLocation().equals(GenomeLocParser.createGenomeLoc("chrM", 20)));
assertTrue(two.get("COL1").equals("C"));
@ -117,7 +120,7 @@ public class TabularRODTest extends BaseTest {
public void testToString() {
logger.warn("Executing testToString");
RODRecordList oneList = iter.next();
TabularROD one = (TabularROD)oneList.get(0);
TabularROD one = (TabularROD)oneList.get(0).getUnderlyingObject();
assertTrue(one.toString().equals("chrM:10\tA\tB\tC"));
}
@ -126,11 +129,11 @@ public class TabularRODTest extends BaseTest {
public void testDelim1() {
File file2 = new File(testDir + "TabularDataTest2.dat");
ReferenceOrderedData ROD_commas = new ReferenceOrderedData("tableTest", file2, TabularROD.class);
LocationAwareSeekableRODIterator iter_commas = ROD_commas.iterator();
LocationAwareSeekableRODIterator iter_commas = new SeekableRODIterator(new GATKFeatureIterator(ROD_commas.iterator()));
logger.warn("Executing testDelim1");
RODRecordList one2List = iter_commas.next();
TabularROD one2 = (TabularROD)one2List.get(0);
TabularROD one2 = (TabularROD)one2List.get(0).getUnderlyingObject();
assertTrue(one2.size() == 5);
assertTrue(one2.getLocation().equals(GenomeLocParser.createGenomeLoc("chrM", 10)));
assertTrue(one2.get("COL1").equals("A"));
@ -144,11 +147,11 @@ public class TabularRODTest extends BaseTest {
TabularROD.setDelimiter(",",",");
File file2 = new File(testDir + "TabularDataTest2.dat");
ReferenceOrderedData ROD_commas = new ReferenceOrderedData("tableTest", file2, TabularROD.class);
LocationAwareSeekableRODIterator iter_commas = ROD_commas.iterator();
LocationAwareSeekableRODIterator iter_commas = new SeekableRODIterator(new GATKFeatureIterator(ROD_commas.iterator()));
logger.warn("Executing testDelim1");
RODRecordList one2List = iter_commas.next();
TabularROD one2 = (TabularROD)one2List.get(0);
TabularROD one2 = (TabularROD)one2List.get(0).getUnderlyingObject();
assertTrue(one2.size() == 5);
assertTrue(one2.getLocation().equals(GenomeLocParser.createGenomeLoc("chrM", 10)));
assertTrue(one2.get("COL1").equals("A"));
@ -189,10 +192,10 @@ public class TabularRODTest extends BaseTest {
out.println(row.toString());
ReferenceOrderedData ROD_commas = new ReferenceOrderedData("tableTest", outputFile, TabularROD.class);
LocationAwareSeekableRODIterator iter_commas = ROD_commas.iterator();
LocationAwareSeekableRODIterator iter_commas = new SeekableRODIterator(new GATKFeatureIterator(ROD_commas.iterator()));
RODRecordList oneList = iter_commas.next();
TabularROD one = (TabularROD)oneList.get(0);
TabularROD one = (TabularROD)oneList.get(0).getUnderlyingObject();
assertTrue(one.size() == 4);
assertTrue(one.getLocation().equals(GenomeLocParser.createGenomeLoc("chrM", 1)));
assertTrue(one.get("col1").equals("1"));
@ -200,7 +203,7 @@ public class TabularRODTest extends BaseTest {
assertTrue(one.get("col3").equals("3"));
RODRecordList twoList = iter_commas.next();
TabularROD two = (TabularROD)twoList.get(0);
TabularROD two = (TabularROD)twoList.get(0).getUnderlyingObject();
assertTrue(two.size() == 4);
assertTrue(two.getLocation().equals(GenomeLocParser.createGenomeLoc("chrM", 2)));
assertTrue(two.get("col1").equals("3"));

16
java/test/org/broadinstitute/sting/gatk/refdata/tracks/RMDTrackManagerTest.java
View File

@ -54,13 +54,17 @@ public class RMDTrackManagerTest extends BaseTest {
triplets = new ArrayList<String>();
// add our db snp data
triplets.add("MyDbSNP");
triplets.add("DBSNP");
triplets.add("testdata/small.dbsnp.rod");
tracks = manager.getReferenceMetaDataSources(triplets);
triplets.add("MyDbSNP,DBSNP,testdata/small.dbsnp.rod");
// TODO: Aaron remove following comment, reinstate line
//tracks = manager.getReferenceMetaDataSources(triplets);
}
@Test
@Test // TODO: Aaron remove me
public void voidTest() {
}
//@Test -- TODO: Aaron fix with next round of Tribble integration
public void testBuilderQuery() {
for (RMDTrack t : tracks) {
System.err.println("name = " + t.getName() + " type = " + t.getType().getSimpleName() + " file = " + t.getFile());
@ -79,7 +83,7 @@ public class RMDTrackManagerTest extends BaseTest {
}
}
@Test
//@Test
public void testBuilderIterator() {
for (RMDTrack t : tracks) {
System.err.println("name = " + t.getName() + " type = " + t.getType().getSimpleName() + " file = " + t.getFile());

35
java/test/org/broadinstitute/sting/gatk/refdata/utils/FlashBackIteratorTest.java
View File

@ -175,7 +175,7 @@ class FakeSeekableRODIterator implements LocationAwareSeekableRODIterator {
@Override
public RODRecordList next() {
RODRecordList list = new FakeRODRecordList();
curROD = new FakeRODatum(location);
curROD = new FakeRODatum("STUPIDNAME", location);
location = GenomeLocParser.createGenomeLoc(location.getContigIndex(), location.getStart() + 1, location.getStop() + 1);
list.add(curROD);
recordCount--;
@ -190,11 +190,12 @@ class FakeSeekableRODIterator implements LocationAwareSeekableRODIterator {
/** for testing only */
class FakeRODatum implements ReferenceOrderedDatum {
class FakeRODatum extends GATKFeature implements ReferenceOrderedDatum {
final GenomeLoc location;
public FakeRODatum(GenomeLoc location) {
public FakeRODatum(String name, GenomeLoc location) {
super(name);
this.location = location;
}
@ -233,6 +234,11 @@ class FakeRODatum implements ReferenceOrderedDatum {
return location;
}
@Override
public Object getUnderlyingObject() {
return this;
}
@Override
public int compareTo(ReferenceOrderedDatum that) {
return location.compareTo(that.getLocation());
@ -250,17 +256,32 @@ class FakeRODatum implements ReferenceOrderedDatum {
public Object initialize(File source) throws FileNotFoundException {
return null;
}
@Override
public String getChr() {
return location.getContig();
}
@Override
public int getStart() {
return (int)location.getStart();
}
@Override
public int getEnd() {
return (int)location.getStop();
}
}
class FakeRODRecordList extends AbstractList<ReferenceOrderedDatum> implements RODRecordList {
private final List<ReferenceOrderedDatum> list = new ArrayList<ReferenceOrderedDatum>();
class FakeRODRecordList extends AbstractList<GATKFeature> implements RODRecordList {
private final List<GATKFeature> list = new ArrayList<GATKFeature>();
public boolean add(ReferenceOrderedDatum data) {
public boolean add(GATKFeature data) {
return list.add(data);
}
@Override
public ReferenceOrderedDatum get(int i) {
public GATKFeature get(int i) {
return list.get(i);
}