diff -N DefaultStrategy.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ DefaultStrategy.java	7 Aug 2006 17:46:30 -0000	1.1
@@ -0,0 +1,47 @@

+/*
+ * DefaultStrategy.java
+ *
+ * Created on March 29, 2006, 3:45 PM
+ *
+ */
+
+package org.lcsim.contrib.seedtracker;
+
+import java.util.List;
+import java.util.ArrayList;
+
+/**
+ *
+ * @author Richard Partridge
+ * @version 1.0
+ */
+public class DefaultStrategy
+{
+    private List<SeedStrategy> StrategyList;
+    
+    /** Creates a new instance of DefaultStrategy */
+    public DefaultStrategy()
+    {
+        StrategyList = new ArrayList();
+        
+        List<SeedLayer> TD012Layers = new ArrayList();
+        TD012Layers.add(new SeedLayer("TrackerEndcap", 0, SeedLayer.SeedType.SeedInner));
+        TD012Layers.add(new SeedLayer("TrackerEndcap", 1, SeedLayer.SeedType.SeedMiddle));
+        TD012Layers.add(new SeedLayer("TrackerEndcap", 2, SeedLayer.SeedType.SeedOuter));
+//        StrategyList.add(new SeedStrategy("TD012",TD012Layers));
+        
+        List<SeedLayer> VB012Layers = new ArrayList();
+        VB012Layers.add(new SeedLayer("VertexBarrel", 2, SeedLayer.SeedType.SeedInner));
+        VB012Layers.add(new SeedLayer("VertexBarrel", 3, SeedLayer.SeedType.SeedMiddle));
+        VB012Layers.add(new SeedLayer("VertexBarrel", 4, SeedLayer.SeedType.SeedOuter));
+        VB012Layers.add(new SeedLayer("TrackerBarrel", 0, SeedLayer.SeedType.Confirm3D));
+//        VB012Layers.add(new SeedLayer("VertexBarrel", 0, SeedLayer.SeedType.Confirm3D));
+//        VB012Layers.add(new SeedLayer("VertexBarrel", 1, SeedLayer.SeedType.Confirm3D));
+        StrategyList.add(new SeedStrategy("VB012",VB012Layers));
+        
+    }
+    public List<SeedStrategy> getStrategyList()
+    {
+        return StrategyList;
+    }
+}

diff -N SeedLayer.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ SeedLayer.java	7 Aug 2006 17:46:31 -0000	1.1
@@ -0,0 +1,100 @@

+/*
+ * SeedLayer.java
+ *
+ * Created on March 29, 2006, 1:59 PM
+ *
+ */
+
+package org.lcsim.contrib.seedtracker;
+
+//import org.lcsim.event.SimTrackerHit;
+import org.lcsim.event.base.BaseTrackerHitMC;
+import java.util.List;
+import java.util.ArrayList;
+import org.lcsim.geometry.subdetector.DiskTracker;
+import org.lcsim.geometry.subdetector.MultiLayerTracker;
+
+/**
+ *
+ * @author Richard Partridge
+ * @version 1.0
+ */
+public class SeedLayer
+{
+    public enum SeedType {SeedInner, SeedMiddle, SeedOuter, Confirm2D, Confirm3D, Search2D, Search3D}
+    
+    protected String DetName;
+    protected int Layer;
+    protected SeedType Type;
+    protected List<BaseTrackerHitMC> HitList;
+    protected double RMax = 0;
+    protected double RMin = 99999;
+    protected double ZMax = 99999;
+    protected boolean IsEndcap = false;
+
+    /** Creates a new instance of SeedLayer */
+    public SeedLayer(String DetName, int Layer, SeedType Type)
+    {
+        this.DetName = DetName;
+        this.Layer = Layer;
+        this.Type = Type;
+        HitList = new ArrayList<BaseTrackerHitMC>();
+    }
+    public String getDetName()
+    {
+        return DetName;
+    }
+    public int getLayer()
+    {
+        return Layer;
+    }
+    public SeedType getType()
+    {
+        return Type;
+    }
+    public List<BaseTrackerHitMC> getHitList()
+    {
+        return HitList;
+    }
+    public void putDetName(String DetName)
+    {
+        this.DetName = DetName;
+        return;
+    }
+    public void putLayer(int Layer)
+    {
+        this.Layer = Layer;
+        return;
+    }
+    public void putType(SeedType Type)
+    {
+        this.Type = Type;
+        return;
+    }
+    public void addHit(BaseTrackerHitMC Hit)
+    {
+        if (HitList.isEmpty()) {
+            IsEndcap = Hit.getSimHits().get(0).getSubdetector().isEndcap();
+            if (IsEndcap) {
+                DiskTracker dtrkr = (DiskTracker) Hit.getSimHits().get(0).getSubdetector();
+                RMin = dtrkr.getInnerR()[Layer];
+                RMax = dtrkr.getOuterR()[Layer];
+                ZMax = dtrkr.getInnerZ()[Layer];
+            }
+            else {
+                MultiLayerTracker ctrkr = (MultiLayerTracker) Hit.getSimHits().get(0).getSubdetector();
+                RMin = 0.;
+                RMax = ctrkr.getInnerR()[Layer];
+                ZMax = ctrkr.getOuterZ()[Layer];
+            }
+            System.out.println(DetName+" Layer "+Layer+" RMIN "+RMin+" RMAX "+RMax+" ZMax "+ZMax);
+        }
+        HitList.add(Hit);
+        return;
+    }
+    public void clearHitList()
+    {
+        HitList.clear();
+        return;
+    }
+}

diff -N SeedStrategy.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ SeedStrategy.java	7 Aug 2006 17:46:31 -0000	1.1
@@ -0,0 +1,149 @@

+/*
+ * SeedStrategy.java
+ *
+ * Created on March 29, 2006, 3:04 PM
+ *
+ */
+
+package org.lcsim.contrib.seedtracker;
+
+import java.util.*;
+import org.lcsim.contrib.seedtracker.SeedLayer;
+
+/**
+ *
+ * @author Richard Partridge
+ * @version 1.0
+ */
+public class SeedStrategy {
+    private String Name;
+    private List<SeedLayer> LayerList;
+    private double MinPT = 0.5;
+    private double MaxDCA = 10.0;
+    private double MaxZ0 = 10.0;
+    private double MaxChisq = 100.;
+    private int MinConfirm = 1;
+    private int MinHits = 4;
+    
+    /** Creates a new instance of SeedStrategy */
+    public SeedStrategy(String Name, List<SeedLayer> LayerList, double MinPT,
+            double MaxDCA, double MaxZ0, double MaxChisq, int MinConfirm, int MinHits) {
+        this.Name = Name;
+        this.LayerList = LayerList;
+        this.MinPT = MinPT;
+        this.MaxDCA = MaxDCA;
+        this.MaxZ0 = MaxZ0;
+        this.MaxChisq = MaxChisq;
+        this.MinConfirm = MinConfirm;
+        this.MinHits = MinHits;
+    }
+    public SeedStrategy(String Name, double MinPT, double MaxDCA,double MaxZ0,
+            double MaxChisq, int MinConfirm, int MinHits) {
+        this.Name = Name;
+        this.LayerList = new ArrayList<SeedLayer>();
+        this.MinPT = MinPT;
+        this.MaxDCA = MaxDCA;
+        this.MaxZ0 = MaxZ0;
+        this.MaxChisq = MaxChisq;
+        this.MinConfirm = MinConfirm;
+        this.MinHits = MinHits;
+    }
+    public SeedStrategy(String Name) {
+        this.Name = Name;
+        this.LayerList = new ArrayList<SeedLayer>();
+    }
+    public SeedStrategy(String Name, List<SeedLayer> LayerList) {
+        this.Name = Name;
+        this.LayerList = LayerList;
+    }
+    public String getName() {
+        return Name;
+    }
+    public List<SeedLayer> getLayerList() {
+        return LayerList;
+    }
+    public double getMinPT() {
+        return MinPT;
+    }
+    public double getMaxDCA() {
+        return MaxDCA;
+    }
+    public double getMaxZ0() {
+        return MaxZ0;
+    }
+    public double getMaxChisq() {
+        return MaxChisq;
+    }
+    public int getMinConfirm() {
+        return MinConfirm;
+    }
+    public int getMinHits() {
+        return MinHits;
+    }
+    public void putName(String Name) {
+        this.Name=Name;
+        return;
+    }
+    public void putLayerList(List<SeedLayer> LayerList) {
+        this.LayerList = LayerList;
+        return;
+    }
+    public void putMinPT(double MinPT) {
+        this.MinPT = MinPT;
+        return;
+    }
+    public void putMaxDCA(double MaxDCA) {
+        this.MaxDCA = MaxDCA;
+        return;
+    }
+    public void putMaxZ0(double MaxZ0) {
+        this.MaxZ0 = MaxZ0;
+        return;
+    }
+    public void putMaxChisq(double MaxChisq) {
+        this.MaxChisq = MaxChisq;
+        return;
+    }
+    public void putMinConfirm(int MinConfirm) {
+        this.MinConfirm = MinConfirm;
+        return;
+    }
+    public void putMinHits(int MinHits) {
+        this.MinHits = MinHits;
+        return;
+    }
+    public void addLayer(SeedLayer Layer) {
+        LayerList.add(Layer);
+        return;
+    }
+    public SeedLayer getSeedInner() {
+        SeedLayer Inner = new SeedLayer("Dummy",0,SeedLayer.SeedType.SeedInner);
+        for (SeedLayer layer : LayerList) {
+            if (layer.getType() == SeedLayer.SeedType.SeedInner) Inner = layer;
+        }
+        return Inner;
+    }
+    
+     public SeedLayer getSeedMiddle() {
+        SeedLayer Middle = new SeedLayer("Dummy",0,SeedLayer.SeedType.SeedMiddle);
+        for (SeedLayer layer : LayerList) {
+            if (layer.getType() == SeedLayer.SeedType.SeedMiddle) Middle = layer;
+        }
+        return Middle;
+     }
+     
+     public SeedLayer getSeedOuter() {
+        SeedLayer Outer = new SeedLayer("Dummy",0,SeedLayer.SeedType.SeedOuter);
+        for (SeedLayer layer : LayerList) {
+            if (layer.getType() == SeedLayer.SeedType.SeedOuter) Outer = layer;
+        }
+        return Outer;
+    }
+    public List<SeedLayer> getConfirmLayers() {
+        List<SeedLayer> confirmlayers = new ArrayList();
+        for (SeedLayer layer : LayerList) {
+            if (layer.getType() == SeedLayer.SeedType.Confirm3D) confirmlayers.add(layer);
+        }
+        return confirmlayers;
+    } 
+}

diff -N SeedTracker.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ SeedTracker.java	7 Aug 2006 17:46:31 -0000	1.1
@@ -0,0 +1,285 @@

+/*
+ * SeedTracker.java
+ *
+ * Created on August 16, 2005, 8:54 AM
+ *
+ */
+
+package org.lcsim.contrib.seedtracker;
+
+import java.util.ArrayList;
+import java.util.ListIterator;
+import org.lcsim.event.MCParticle;
+import org.lcsim.event.SimTrackerHit;
+import org.lcsim.event.Track;
+import org.lcsim.event.TrackerHit;
+import org.lcsim.event.base.BaseTrack;
+import org.lcsim.event.base.BaseTrackerHitMC;
+import org.lcsim.fit.helicaltrack.HelicalTrackFit;
+import org.lcsim.geometry.Detector;
+import org.lcsim.geometry.subdetector.MultiLayerTracker;
+import org.lcsim.util.Driver;
+import org.lcsim.event.EventHeader;
+import java.util.List;
+
+/**
+ * Tracking algorithm based on forming track seeds from all 3-hit combinations
+ * and adding tracks to the helix defined by the three hits.
+ *
+ * @author Richard Partridge
+ * @version 1.0
+ */
+public class SeedTracker extends Driver {
+    private DefaultStrategy DS = new DefaultStrategy();
+    private List<SeedStrategy> StrategyList = DS.getStrategyList();
+    private HelicalTrackFitter hf = new HelicalTrackFitter();
+    private HelicalTrackFit helix;
+    private double[] IP = {0.,0.,0.};
+    private double BField;
+    
+    /** Creates a new instance of SeedTracker */
+    public SeedTracker() {
+    }
+    
+    protected void process(EventHeader event) {
+        
+        // Find the magnetic field
+        Detector detector = event.getDetector();
+        BField = detector.getFieldMap().getField(IP)[2];
+        
+        // Associate hits with layers (ignore layers that aren't included in a strategy
+        AssociateHits(event);
+        
+        // Create a list of tracks
+        List<BaseTrack> tracklist = new ArrayList();
+        
+        // Loop over all strategies
+        for (SeedStrategy strategy : StrategyList) {
+            // Find the 3 hits seeds for this strategy
+            List<List<BaseTrackerHitMC>> seedlist = FindSeeds(strategy);
+            // Loop over the seeds
+            for (List<BaseTrackerHitMC> hitlist : seedlist) {
+                // See if we can create a helix that satisfies the cuts for this strategy
+                boolean status = FindHelix(strategy, hitlist);
+                if (!status) continue;
+                List<List<BaseTrackerHitMC>> confirmlist = FindConfirms(strategy, hitlist);
+                int maxhits = 3 + strategy.getConfirmLayers().size();
+                int minhits = 3 + strategy.getMinConfirm();
+                // First try to find one or more tracks using all the confirm hits
+                // If this fails, work our way down to the minimum number
+                for (int nhit = maxhits; nhit >= minhits; nhit--) {
+                    boolean foundtrack = false;
+                    for (List<BaseTrackerHitMC> candidate : confirmlist) {
+                        if (candidate.size() == nhit) {
+                            if (!isDuplicate(candidate, tracklist)) {
+                                boolean status2 = FindHelix(strategy, candidate);
+                                if (status2) {
+                                    // Create a new track
+                                    BaseTrack track = new BaseTrack();
+                                    track.setReferencePoint(IP);
+                                    track.setRefPointIsDCA(false);
+                                    track.setTrackParameters(helix.parameters(), BField);
+                                    track.setChisq(helix.chisq()[0]+helix.chisq()[1]);
+                                    track.setNDF(helix.ndf()[0]+helix.ndf()[1]);
+                                    track.setCovarianceMatrix(helix.covariance());
+                                    track.setTrackType(0);
+                                    List<TrackerHit> castcand = new ArrayList();
+                                    for (BaseTrackerHitMC hit : candidate) {
+                                        castcand.add((TrackerHit) hit);
+                                    }
+                                    track.addHits(castcand);
+                                    tracklist.add(track);
+                                    foundtrack = true;
+                                }
+                            }
+                        }
+                    }
+                    if (foundtrack) break;
+                }
+            }
+        }
+        event.put("Tracks", tracklist, Track.class, 0);
+    }
+    
+    private void AssociateHits(EventHeader event) {
+        List<BaseTrackerHitMC>  hitcol = event.get(BaseTrackerHitMC.class,"BaseTrackerHitMC");
+        
+        for (SeedStrategy strategy : StrategyList) {
+            for (SeedLayer slyr : strategy.getLayerList()) {
+                slyr.clearHitList();
+                for (BaseTrackerHitMC hit : hitcol) {
+                    for (SimTrackerHit simhit : hit.getSimHits()) {
+                        if (simhit.getLayer() == slyr.Layer) {
+                            if (simhit.getSubdetector().getName().equals(slyr.getDetName())) {
+                                slyr.addHit(hit);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return;
+    }
+    public List<SeedStrategy> getStrategyList() {
+        return StrategyList;
+    }
+    
+    public void putStrategyList(List<SeedStrategy> StrategyList) {
+        this.StrategyList = StrategyList;
+        return;
+    }
+    
+    private List<List<BaseTrackerHitMC>> FindSeeds(SeedStrategy strategy) {
+        SeedLayer inner = strategy.getSeedInner();
+        SeedLayer middle = strategy.getSeedMiddle();
+        SeedLayer outer = strategy.getSeedOuter();
+        
+        // Todo: add code to limit seeds to those that satisfy cuts
+        List<List<BaseTrackerHitMC>> seedlist = new ArrayList();
+        
+        for (BaseTrackerHitMC si : inner.getHitList()) {
+            for (BaseTrackerHitMC sm : middle.getHitList()) {
+                for (BaseTrackerHitMC so : outer.getHitList()) {
+                    List<BaseTrackerHitMC> hitlist = new ArrayList();
+                    hitlist.add(si);
+                    hitlist.add(sm);
+                    hitlist.add(so);
+                    seedlist.add(hitlist);
+                }
+            }
+        }
+        System.out.println(" Number of seeds: "+seedlist.size());
+        
+        return seedlist;
+    }
+    
+    private boolean FindHelix(SeedStrategy strategy, List<BaseTrackerHitMC> hitlist) {
+        boolean status = false;
+        int np = hitlist.size();
+        double[] xx = new double[np];
+        double[] yy = new double[np];
+        double[] zz = new double[np];
+        double[] drphi = new double[np];
+        double[] dz = new double[np];
+        
+        for (int i=0; i<np; i++) {
+            BaseTrackerHitMC hit = hitlist.get(i);
+            double[] position = hit.getPosition();
+            xx[i] = position[0];
+            yy[i] = position[1];
+            zz[i] = position[2];
+            double[] covmat = hit.getCovMatrix();
+            drphi[i] = rphi_error(position, covmat);
+            dz[i] = Math.sqrt(covmat[5]);
+        }
+        boolean goodfit = hf.fit(xx, yy, zz, drphi, dz, np);
+        if (goodfit) {
+            helix = hf.getFit();
+            double[] params = helix.parameters();
+            double pT = 0.0003 * BField / Math.abs(params[2]);
+            if (helix.chisq()[0]+helix.chisq()[1] < strategy.getMaxChisq()) {
+                if (pT > strategy.getMinPT()) {
+                    double d0 = params[0];
+                    if (d0 < strategy.getMaxDCA()) {
+                        double z0 = params[3];
+                        if (z0 < strategy.getMaxZ0()) {
+            System.out.println(" d0 "+params[0]);
+            System.out.println(" phi0 "+params[1]);
+            System.out.println(" curvatures "+params[2]);
+            System.out.println(" z0 "+params[3]);
+            System.out.println(" slope "+params[4]);
+                System.out.println(" pT "+pT);
+                            status = true;
+                        }
+                    }
+                }
+            }
+        }
+        return status;
+    }
+    
+    private List<List<BaseTrackerHitMC>> FindConfirms(SeedStrategy strategy, List<BaseTrackerHitMC> seedhits) {
+        // Create a list of possible confirmation hits for each confirmation layer
+        List<List<BaseTrackerHitMC>> confirmbylayer = new ArrayList();
+        // Loop over the various layers
+        for (SeedLayer layer : strategy.getConfirmLayers()) {
+            // Get the list of potential confirmation hits for this layer
+            // Todo - select only hits near tracks
+            List<BaseTrackerHitMC> confirmhits = layer.getHitList();
+            // If we have some confirmation hits in this layer, add the list of hits for this layer
+            if (confirmhits.size()>0) confirmbylayer.add(confirmhits);
+        }
+        // Initialize a list of track candidates that include confirmation hits
+        List<List<BaseTrackerHitMC>> candlist = new ArrayList();
+        // check that there are sufficient layers with confirmation hits
+        if (confirmbylayer.size() >= strategy.getMinConfirm()) {
+            // Start with our seed hits as a candidate
+            candlist.add(seedhits);
+            // Loop over all the confirming layers
+            for (List<BaseTrackerHitMC> confirmhits : confirmbylayer) {
+                // Create a list of new candidates that have hits added from this layer
+                List<List<BaseTrackerHitMC>> newcandlist = new ArrayList();
+                // Loop over all existing candidates
+                for (List<BaseTrackerHitMC> oldcand : candlist) {
+                    // Loop over all the hits in this confirming layer
+                    for (BaseTrackerHitMC hit : confirmhits) {
+                        // Create a new track candidate that adds this hit
+                        List<BaseTrackerHitMC> newcand = new ArrayList();
+                        boolean status = newcand.addAll(oldcand);
+                        newcand.add(hit);
+                        newcandlist.add(newcand);
+                    }
+                }
+                boolean status = candlist.addAll(newcandlist);
+            }
+        }
+        // Remove candidates that have too few confirmation hits
+//        ListIterator<List<BaseTrackerHitMC>> itr = candlist.listIterator();
+//        while (itr.hasNext()) {
+//            List<BaseTrackerHitMC> hitlist = itr.next();
+//            if (hitlist.size() < strategy.getMinConfirm()+3) candlist.remove(hitlist);
+//        }
+        
+        return candlist;
+    }
+    
+    private boolean isDuplicate(List<BaseTrackerHitMC> hitlist, List<BaseTrack> tracklist) {
+        boolean isDuplicate = false;
+        for (BaseTrack track : tracklist) {
+            List<TrackerHit> hitlist2 = track.getTrackerHits();
+            boolean matchall = true;
+            if (hitlist.size() <= hitlist2.size()) {
+                for ( BaseTrackerHitMC hit1 : hitlist) {
+                    boolean match = false;
+                    for (TrackerHit hit2 : hitlist2) {
+                        if (hit1 == (BaseTrackerHitMC) hit2) {
+                            match = true;
+                            break;
+                        }
+                    }
+                    if (!match) {
+                        matchall = false;
+                        break;
+                    }
+                }
+                if (matchall) {
+                    isDuplicate = true;
+                    break;
+                }
+            }
+        }
+        return isDuplicate;
+    }
+    
+    private double rphi_error(double[] position, double[] covmat) {
+        // Todo: include MS errors in weight
+        double x = position[0];
+        double y = position[1];
+        double r2 = x * x + y * y;
+        double varxx = covmat[0];
+        double varxy = covmat[1];
+        double varyy = covmat[2];
+        return Math.sqrt((y * y * varxx + x * x * varyy - 2 * x * y * varxy) / r2);
+    }
+    
+}

\ No newline at end of file

diff -N SeedTrackerDriver.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ SeedTrackerDriver.java	7 Aug 2006 17:46:32 -0000	1.1
@@ -0,0 +1,34 @@

+/*
+ * SeedTrackerDriver.java
+ *
+ * Created on March 29, 2006, 4:58 PM
+ *
+ */
+
+// package org.lcsim.contrib.seedtracker;
+
+import org.lcsim.contrib.seedtracker.SeedTracker;
+import org.lcsim.contrib.seedtracker.SmearMCHits;
+import org.lcsim.event.EventHeader;
+import org.lcsim.util.Driver;
+
+/**
+ *
+ * @author Richard Partridge
+ * @version 1.0
+ */
+public class SeedTrackerDriver extends Driver
+{  
+    /** Creates a new instance of SeedTrackerDriver */
+    public SeedTrackerDriver()
+    {
+        add(new SmearMCHits());
+        add(new SeedTracker());
+    }
+
+    public void process(EventHeader event)
+    {
+        super.process(event);
+        return;     
+    }    
+}

diff -N SmearMCHits.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ SmearMCHits.java	7 Aug 2006 17:46:32 -0000	1.1
@@ -0,0 +1,82 @@

+/*
+ * SmearMCHits.java
+ *
+ * Created on July 12, 2006, 10:25 AM
+ *
+ * To change this template, choose Tools | Template Manager
+ * and open the template in the editor.
+ */
+
+package org.lcsim.contrib.seedtracker;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import org.lcsim.util.Driver;
+import org.lcsim.event.EventHeader;
+import org.lcsim.event.SimTrackerHit;
+import org.lcsim.event.base.BaseTrackerHitMC;
+
+/**
+ *
+ * @author partridge
+ */
+public class SmearMCHits extends Driver{
+    
+    Random rn = new Random();
+    double drphi = 0.005;
+    double dz = 0.005;
+    
+    /** Creates a new instance of SmearMCHits */
+    public SmearMCHits() {
+    }
+    
+    public void process(EventHeader event) {
+        
+        //  Initialize the TrackerHit list
+        List<BaseTrackerHitMC> trkhits = new ArrayList<BaseTrackerHitMC>();
+        //  Get the SimTrackerHit collections
+        List<List<SimTrackerHit>> allgenhits = event.get(SimTrackerHit.class);
+        //  Loop over the various hit collections
+        for (List<SimTrackerHit> genhitcol : allgenhits) {
+            //  Now loop over the hits in a particular collection
+            for (SimTrackerHit genhit : genhitcol) {
+                //  Generate a new BaseTrackerHitMC for each SimTrackerHit
+                //  Note: treat all layers the same for now, hard code the resolution
+                double x = genhit.getPoint()[0];
+                double y = genhit.getPoint()[1];
+                double z = genhit.getPoint()[2];
+                double r = Math.sqrt(x*x + y*y);
+                double phi = Math.atan2(y,x);
+                phi = phi + (drphi / r) * rn.nextGaussian();
+                z = z + dz * rn.nextGaussian();
+                // Fill in smeared position
+                double[] pos = new double[3];
+                pos[0] = r * Math.cos(phi);
+                pos[1] = r * Math.sin(phi);
+                pos[2] = z;
+                // covariance matrix in lower triangular form
+                double[] cov = new double[6];
+                cov[0] = Math.pow(Math.sin(phi)*drphi,2);
+                cov[1] = -Math.sin(phi)*Math.cos(phi)*drphi*drphi;
+                cov[2] = Math.pow(Math.cos(phi)*drphi,2);
+                cov[3] = 0.;
+                cov[4] = 0.;
+                cov[5] = dz*dz;
+                
+                double time = genhit.getTime();
+                
+                double dedx = genhit.getdEdx();
+                
+                int type = 0;
+                //  Create the list of SimTrackerHits for this TrackerHit and add our hit to the list
+                List<SimTrackerHit> hits = new ArrayList<SimTrackerHit>();
+                hits.add(genhit);
+                //  Create a new TrackerHit and add it to our list of tracker hits
+                trkhits.add(new BaseTrackerHitMC(pos, cov,  time, dedx, type, hits));
+            }
+        }
+        //  Put the list of TrackerHits into the event
+        event.put("BaseTrackerHitMC",trkhits,BaseTrackerHitMC.class,0);
+    }  
+}