diff -N SeedTrackerTrackStateDriver.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ SeedTrackerTrackStateDriver.java	18 May 2010 20:29:08 -0000	1.1
@@ -0,0 +1,91 @@

+// $Id: SeedTrackerTrackStateDriver.java,v 1.1 2010/05/18 20:29:08 jeremy Exp $
+package org.lcsim.recon.tracking.seedtracker;
+
+import hep.physics.vec.Hep3Vector;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.lcsim.event.EventHeader;
+import org.lcsim.event.GenericObject;
+import org.lcsim.event.Track;
+import org.lcsim.util.Driver;
+
+import org.lcsim.fit.helicaltrack.*;
+
+/**
+ * This Driver creates the three TrackState collections expected by slicPandora
+ * by using information from the SeedTracker objects.  It must be run in the same 
+ * job as SeedTracker, NOT by reading in a persisted LCIO file, which will not
+ * work due to lost data and type information.  And (obviously) it must be run 
+ * after SeedTracker itself.
+ * 
+ * @author richp
+ * @author jeremym
+ */
+public class SeedTrackerTrackStateDriver extends Driver
+{
+    public void process(EventHeader event)
+    {
+        // Get the Tracks from the event. Collection name is SeedTracker's default.
+        List<Track> tracks = event.get(Track.class, "Tracks");
+        
+        // TrackState lists.
+        List<GenericObject> startObjs = new ArrayList<GenericObject>();
+        List<GenericObject> endObjs = new ArrayList<GenericObject>();
+        List<GenericObject> ecalObjs = new ArrayList<GenericObject>();        
+       
+        // Loop over all the Tracks in the collection.
+        for (Track track : tracks)
+        {
+            SeedTrack strk = (SeedTrack) track;
+            SeedCandidate scand = strk.getSeedCandidate();
+            HelicalTrackFit helix = scand.getHelix();
+            double smax = -9999.;
+            HelicalTrackHit last = null;
+            for (HelicalTrackHit hit : scand.getHits())
+            {
+                double s = helix.PathMap().get(hit);
+                if (s > smax)
+                {
+                    smax = s;
+                    last = hit;
+                }
+            }
+            TrackDirection trkdir = HelixUtils.CalculateTrackDirection(helix,
+                    smax);
+            Hep3Vector dir = trkdir.Direction();
+            Hep3Vector pos = null;
+            if (last instanceof HelicalTrackCross)
+            {
+                HelicalTrackCross cross = (HelicalTrackCross) last;
+                cross.setTrackDirection(trkdir, helix.covariance());
+                pos = cross.getCorrectedPosition();
+            }
+            else
+            {
+                pos = last.getCorrectedPosition();
+            }
+            
+            // Set both the End and ECal TrackStates from the outermost hit on the track.
+            double[] xpos = pos.v();            
+            double[] xmomentum = dir.v();            
+            TrackState ecalState = new TrackState(xpos[0], xpos[1], xpos[2], xmomentum[0], xmomentum[1], xmomentum[2]);
+            ecalObjs.add(ecalState);            
+            TrackState endState = new TrackState(xpos[0], xpos[1], xpos[2], xmomentum[0], xmomentum[1], xmomentum[2]);
+            endObjs.add(endState);
+            
+            // Calculate the Start state and add to list.
+            TrackDirection startDir = HelixUtils.CalculateTrackDirection(helix, 0.);
+            double[] smom = startDir.Direction().v();
+            double[] spos = HelixUtils.PointOnHelix(helix, 0.).v();
+            TrackState startState = new TrackState(spos[0], spos[1], spos[2], smom[0], smom[1], smom[2]);
+            startObjs.add(startState);             
+        }
+        
+        // Add the lists to the event.
+        event.put("StateAtStart", startObjs, GenericObject.class, 0);
+        event.put("StateAtECal", ecalObjs, GenericObject.class, 0);
+        event.put("StateAtEnd", endObjs, GenericObject.class, 0);
+    }
+}

diff -N TrackState.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ TrackState.java	18 May 2010 20:29:08 -0000	1.1
@@ -0,0 +1,92 @@

+package org.lcsim.recon.tracking.seedtracker;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.lcsim.event.GenericObject;
+
+/**
+ * Simple implementation of TrackState as an LCIO GenericObject containing 6
+ * floats corresponding to position (x,y,z) and momentum (px,py,pz).
+ * 
+ * @author jeremym
+ */
+public class TrackState implements GenericObject
+{
+    List<Float> vals = new ArrayList<Float>();
+
+    /**
+     * Float constructor.
+     * 
+     * @param x
+     * @param y
+     * @param z
+     * @param px
+     * @param py
+     * @param pz
+     */
+    public TrackState(float x, float y, float z, float px, float py, float pz)
+    {
+        vals.add(x);
+        vals.add(y);
+        vals.add(z);
+        vals.add(px);
+        vals.add(py);
+        vals.add(pz);
+    }
+
+    /**
+     * Double constructor.
+     * 
+     * @param x
+     * @param y
+     * @param z
+     * @param px
+     * @param py
+     * @param pz
+     */
+    public TrackState(double x, double y, double z, double px, double py, double pz)
+    {
+        vals.add((float) x);
+        vals.add((float) y);
+        vals.add((float) z);
+        vals.add((float) px);
+        vals.add((float) py);
+        vals.add((float) pz);
+    }
+
+    public double getDoubleVal(int index)
+    {
+        return 0;
+    }
+
+    public float getFloatVal(int index)
+    {
+        return vals.get(index);
+    }
+
+    public int getIntVal(int index)
+    {
+        return 0;
+    }
+
+    public int getNDouble()
+    {
+        return 0;
+    }
+
+    public int getNFloat()
+    {
+        return 6;
+    }
+
+    public int getNInt()
+    {
+        return 0;
+    }
+
+    public boolean isFixedSize()
+    {
+        return true;
+    }
+}

\ No newline at end of file