diff -N AbstractTrack.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ AbstractTrack.java	18 Jun 2012 23:02:13 -0000	1.1
@@ -0,0 +1,40 @@

+/* AbstractTrack.java
+
+   Abstract track used in implementing the LCSim Track interface.
+
+ Created by  Mike Ronan  July '00
+ Modified by
+
+ */
+
+package org.lcsim.recon.ztracking;
+
+import hep.physics.matrix.SymmetricMatrix;
+import org.lcsim.event.Track;
+import org.lcsim.event.TrackerHit;
+import java.util.ArrayList;
+import java.util.List;
+
+public abstract class AbstractTrack implements Track
+{
+    public double[] getReferencePoint() { double[] point = new double[] {0.,0.,0.}; return point; }
+    public double getReferencePointX() { return 0.; }
+    public double getReferencePointY() { return 0.; }
+    public double getReferencePointZ() { return 0.; }
+    public boolean isReferencePointPCA() { return false; }
+
+    public boolean fitSuccess() { return false; }
+    public double getTrackParameter(int i) { return 0.; }
+    public double[] getTrackParameters() { double[] parameters = new double[] {0.,0.,0.,0.,0.}; return parameters; }
+    public SymmetricMatrix getErrorMatrix() { return new SymmetricMatrix(5); }
+    public double getChi2() { return 0.; }
+    public int getNDF() { return 0; }
+
+    public double getdEdx() { return 0.; }
+    public double getdEdxError() { return 0.; }
+    public double getRadiusOfInnermostHit() { return 0.; }
+    public int[] getSubdetectorHitNumbers() { int[] hitNumbers = new int[]{0}; return hitNumbers; }
+    public List<Track> getTracks() { List<Track> list = new ArrayList<Track>(); return list; }
+    public List<TrackerHit> getTrackerHits() { List<TrackerHit> list = new ArrayList<TrackerHit>(); return list; }
+    public int getType() { return 0; }
+}

diff -N BasicTrack.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ BasicTrack.java	18 Jun 2012 23:02:13 -0000	1.1
@@ -0,0 +1,189 @@

+package org.lcsim.recon.cat.util;
+
+import java.util.*;
+import org.lcsim.event.*;
+import org.lcsim.util.*;
+import hep.physics.matrix.SymmetricMatrix;
+import org.lcsim.spacegeom.SpacePoint;
+import org.lcsim.spacegeom.SpaceVector;
+import org.lcsim.conditions.ConditionsListener;
+import org.lcsim.conditions.ConditionsEvent;
+import org.lcsim.conditions.ConditionsManager;
+import org.lcsim.conditions.ConditionsManager.ConditionsSetNotFoundException;
+import org.lcsim.geometry.Detector;
+import org.lcsim.util.swim.HelixSwimmer;
+
+/**
+ * Basic implementation of {@link org.lcsim.event.Track} interface.
+ * Includes method for initializing track parameters from momentum at a given point.
+ *
+ * @author D. Onoprienko
+ * @version $Id: BasicTrack.java,v 1.1 2012/06/18 23:02:13 jeremy Exp $
+ */
+public class BasicTrack implements Track {
+
+// -- Constructors and static initialization :  --------------------------------
+ 
+  /** 
+   * Initialization of static members.
+   * Runs automatically once the detector classes have been initialized.
+   */
+  static public void initialize(Detector detector) {
+    _bField = detector.getFieldMap().getField(new double[]{0.,0.,0.})[2];
+    _swimmer = new HelixSwimmer(_bField);
+  }
+  
+  /** Default constructor. */
+  public BasicTrack() {
+    _refPoint = new double[3];
+    _refPointIsPCA = false;
+    _parameters = new double[5];
+    _covMatrix = new SymmetricMatrix(5);
+    _momentum = new double[3];
+    _charge = 0;
+    _fitSuccess = false;
+    _chi2 = 0.;
+    _ndf = 1;
+    _dEdx = 0.;
+    _dEdxErr = 0.;
+    _innermostHitRadius = 9999.;
+    _nHitsSubdet = new int[4];
+    _tracks = new ArrayList<Track>(1);
+    _hits = new ArrayList<TrackerHit>(1);
+    _type = 0;
+  }
+  
+  /** Copy constructor. */
+  public BasicTrack(BasicTrack track) {
+    _refPoint = new double[3];
+    System.arraycopy(track._refPoint, 0, _refPoint, 0, 3);
+    _refPointIsPCA = track._refPointIsPCA;
+    _parameters = new double[5];
+    System.arraycopy(track._parameters, 0, _parameters, 0, 5);
+    _covMatrix = new SymmetricMatrix(track._covMatrix);
+    _momentum = new double[3];
+    System.arraycopy(track._momentum, 0, _momentum, 0, 3);
+    _charge = track._charge;
+    _fitSuccess = track._fitSuccess;
+    _chi2 = track._chi2;
+    _ndf = track._ndf;
+    _dEdx = track._dEdx;
+    _dEdxErr = track._dEdxErr;
+    _innermostHitRadius = track._innermostHitRadius;
+    _nHitsSubdet = new int[4];
+    System.arraycopy(track._nHitsSubdet, 0, _nHitsSubdet, 0, 4);
+    _tracks = new ArrayList<Track>(track._tracks);
+    _hits = new ArrayList<TrackerHit>(track._hits);
+    _type = track._type;
+  }
+
+// -- Standard getters (implementing Track interface) :  -----------------------
+  
+  public int getCharge() {return _charge;}
+
+  public double[] getReferencePoint() {return _refPoint;}
+  public double getReferencePointX()  {return _refPoint[0];}
+  public double getReferencePointY()  {return _refPoint[1];}
+  public double getReferencePointZ()  {return _refPoint[2];}
+
+  public boolean isReferencePointPCA() {return _refPointIsPCA;}
+
+  public double[] getMomentum() {return _momentum;}
+  public double getPX() {return _momentum[0];}
+  public double getPY() {return _momentum[1];}
+  public double getPZ() {return _momentum[2];}
+
+  public double[] getTrackParameters() {return _parameters;}
+  public double getTrackParameter(int i) {return _parameters[i];}
+  public SymmetricMatrix getErrorMatrix() {return _covMatrix;}
+
+  public boolean fitSuccess() {return _fitSuccess;}
+  public double getChi2() {return _chi2;}
+  public int getNDF() {return _ndf;}
+
+  public double getdEdx() {return _dEdx;}
+  public double getdEdxError() {return _dEdxErr;}
+
+  public double getRadiusOfInnermostHit() {return _innermostHitRadius;}
+
+  public int[] getSubdetectorHitNumbers() {return _nHitsSubdet;}
+
+  public List<Track> getTracks() {return _tracks;}
+
+  public List<TrackerHit> getTrackerHits() {return _hits;}
+
+  public int getType() {return _type;}
+  
+// -- Additional getters :  ----------------------------------------------------
+  
+  /** Returns transverse momentum of the track. */
+  public double getPt() {
+    return Math.hypot(_momentum[0], _momentum[1]);
+  }
+  
+  /** Returns amplitude of the track momentum. */
+  public double getP() {
+    double[] p = getMomentum();
+    return Math.sqrt(_momentum[0]*_momentum[0]+_momentum[1]*_momentum[1]+_momentum[2]*_momentum[2]);
+  }
+  
+// -- Setters :  ---------------------------------------------------------------
+  
+  /** Add track to the list of tracks associated with this track. */
+  public void addTrack(Track track) {_tracks.add(track);}
+  
+  /** Removes track from the list of tracks associated with this track. */
+  public void removeTrack(Track track) {_tracks.remove(track);}
+  
+  /** Remove all tracks from the list of tracks associated with this track. */
+  public void removeTracks() {_tracks.clear();}
+  
+  public void setHelixParameters(SpacePoint refPoint, SpacePoint position, SpaceVector momentum, int charge) {
+    _refPoint = refPoint.v();
+    _swimmer.setTrack(momentum, position, charge);
+    double alpha = _swimmer.getTrackLengthToPoint(refPoint);
+    SpacePoint poca = _swimmer.getPointAtLength(alpha);
+    SpaceVector momentumAtPoca = _swimmer.getMomentumAtLength(alpha);
+    LCIOParameters parameters = LCIOParameters.SpaceMomentum2Parameters(poca, momentumAtPoca, refPoint, charge, _bField);
+    _parameters = parameters.getValues();
+    _momentum = momentumAtPoca.v();
+    _charge = charge;
+  }
+  
+// -- Private parts :  ---------------------------------------------------------
+
+  protected double[] _refPoint;
+  protected boolean _refPointIsPCA;
+  protected double[] _parameters;
+  protected SymmetricMatrix _covMatrix;
+  protected double[] _momentum;
+  protected int _charge;
+  protected boolean _fitSuccess;
+  protected double _chi2;
+  protected int _ndf;
+  protected double _dEdx;
+  protected double _dEdxErr;
+  protected double _innermostHitRadius;
+  protected int[] _nHitsSubdet;
+  protected ArrayList<Track> _tracks;
+  protected ArrayList<TrackerHit> _hits;
+  protected int _type;
+  
+  protected static double _bField;
+  protected static HelixSwimmer _swimmer;
+  
+  protected static ConditionsListener _conListener = new ConditionsListener() {
+    public void conditionsChanged(ConditionsEvent event) {
+      ConditionsManager conMan = (event == null) ? ConditionsManager.defaultInstance() : event.getConditionsManager();
+      try {
+        Detector det = conMan.getCachedConditions(Detector.class,"compact.xml").getCachedData();
+        initialize(det);
+      } catch (ConditionsSetNotFoundException x) {}
+    }
+  };
+  static {
+    ConditionsManager.defaultInstance().addConditionsListener(_conListener);
+    _conListener.conditionsChanged(null);
+  }
+  
+}

diff -N FastMCTrack.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ FastMCTrack.java	18 Jun 2012 23:02:13 -0000	1.1
@@ -0,0 +1,190 @@

+/**
+ * @version $Id: FastMCTrack.java,v 1.1 2012/06/18 23:02:13 jeremy Exp $
+ */
+package org.lcsim.mc.fast.tracking.fix;
+
+import static java.lang.Math.sqrt;
+import hep.physics.matrix.SymmetricMatrix;
+import hep.physics.vec.Hep3Vector;
+
+import java.util.List;
+
+import org.lcsim.event.LCIOParameters;
+import org.lcsim.event.MCParticle;
+import org.lcsim.event.Track;
+import org.lcsim.event.TrackerHit;
+import org.lcsim.event.LCIOParameters.ParameterName;
+import org.lcsim.spacegeom.CartesianPoint;
+import org.lcsim.spacegeom.CartesianVector;
+import org.lcsim.spacegeom.SpacePoint;
+import org.lcsim.spacegeom.SpaceVector;
+
+
+/**
+ * @author jstrube
+ * The class to store the measurement information of the track of a charged particle in a magnetic field.
+ * This class represents the FastMC simulation.
+ * An invariant of this class is that the "origin" is the point of closest approach to the reference point.
+ */
+public class FastMCTrack implements Track {
+    protected LCIOParameters _parameters;
+    protected SymmetricMatrix _errorMatrix;
+    protected SpacePoint _referencePoint;
+    protected int _charge;
+    protected MCParticle _particle = null;
+        
+    protected FastMCTrack(SpacePoint refPoint, LCIOParameters parameters, SymmetricMatrix errorMatrix, int charge) {
+        _referencePoint = refPoint;
+        _parameters = parameters;
+        _charge = charge;
+        _errorMatrix = errorMatrix;
+    }
+    
+    protected FastMCTrack(SpacePoint refPoint, LCIOParameters parameters, SymmetricMatrix errorMatrix, int charge, MCParticle part) {
+        this(refPoint, parameters, errorMatrix, charge);
+        _particle = part;
+    }
+            
+    public FastMCTrack(Track t) {
+    	double[] p = t.getMomentum();
+    	double pt = sqrt(p[0]*p[0] + p[1]*p[1]);
+    	_parameters = new LCIOParameters(t.getTrackParameters(), pt);
+    	_errorMatrix = t.getErrorMatrix();
+    	_referencePoint = new CartesianPoint(t.getReferencePoint());
+    	_charge = t.getCharge();
+    }
+
+    public boolean fitSuccess() {
+        return false;
+    }
+    /* (non-Javadoc)
+     * @see org.lcsim.contrib.JanStrube.tracking.Track#getCharge()
+     */
+    public int getCharge() {
+        return _charge;
+    }
+
+    public double getChi2() {
+        return -1;
+    }
+    
+    public double getdEdx() {
+        return 0;
+    }
+    
+    public double getdEdxError() {
+        return 0;
+    }
+    
+    /* (non-Javadoc)
+     * @see org.lcsim.contrib.JanStrube.tracking.Track#getErrorMatrix()
+     */
+    public SymmetricMatrix getErrorMatrix() {
+        return _errorMatrix;
+    }
+    
+    public MCParticle getMCParticle() {
+        return _particle;
+    }
+    
+    public double[] getMomentum() {
+        return momentum().v();
+    }
+    
+    public int getNDF() {
+        return 0;
+    }
+    
+    /* (non-Javadoc)
+     * @see org.lcsim.contrib.JanStrube.tracking.Track#getParameter(org.lcsim.contrib.JanStrube.tracking.FastMCTrack.ParameterName)
+     */
+    public double getParameter(ParameterName name) {
+        return _parameters.get(name);
+    }
+    
+    /* (non-Javadoc)
+     * @see org.lcsim.contrib.JanStrube.tracking.Track#getParameters()
+     */
+    public LCIOParameters getParameters() {
+        return _parameters; 
+    }
+    /* (non-Javadoc)
+     * @see org.lcsim.contrib.JanStrube.tracking.Track#getPt()
+     */
+    public double getPt() {
+        return _parameters.getPt();
+    }
+    public double getPX() {
+        return momentum().x();
+    }
+    
+    public double getPY() {
+        return momentum().y();
+    }
+    
+    public double getPZ() {
+        return momentum().z();
+    }
+ 
+    public double getRadiusOfInnermostHit() {
+        return -1;
+    }
+    
+    public double[] getReferencePoint() {
+        return _referencePoint.v();
+    }    
+    public double getReferencePointX() {
+        return referencePoint().x();
+    }
+    
+    public double getReferencePointY() {
+        return referencePoint().y();
+    }
+    
+    public double getReferencePointZ() {
+        return referencePoint().z();
+    }
+    
+    public int[] getSubdetectorHitNumbers() {
+        return null;
+    }
+    
+    public List<TrackerHit> getTrackerHits() {
+        return null;
+    }
+    
+    public double getTrackParameter(int i) {
+        return _parameters.getValues()[i];
+    }
+    
+    public double[] getTrackParameters() {
+        return _parameters.getValues();
+    }
+    
+    public List<Track> getTracks() {
+        return null;
+    }
+    
+    public int getType() {
+        return 0;
+    }
+    
+    public boolean isReferencePointPCA() {
+        return true;
+    }
+    
+    public Hep3Vector momentum() {
+        return new CartesianVector(LCIOParameters.Parameters2Momentum(_parameters).v());
+    }
+    
+    public SpacePoint position() {
+        return LCIOParameters.Parameters2Position(_parameters, _referencePoint);
+    }
+    
+    /* (non-Javadoc)
+     * @see org.lcsim.contrib.JanStrube.tracking.Track#getReferencePoint()
+     */
+    public SpacePoint referencePoint() {
+        return _referencePoint;
+    }
+}

diff -N FoundTrack.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ FoundTrack.java	18 Jun 2012 23:02:13 -0000	1.1
@@ -0,0 +1,39 @@

+/* FoundTrack.java
+
+   Found track used in constructing cheater and reconstructed tracks.
+
+ Created by  Mike Ronan  July '00
+ Modified by
+
+ */
+
+package org.lcsim.recon.ztracking;
+
+import org.lcsim.event.SimTrackerHit;
+import org.lcsim.event.TrackerHit;
+import java.util.ArrayList;
+import java.util.List;
+
+
+public class FoundTrack extends AbstractTrack
+{
+    protected List<SimTrackerHit> list = new ArrayList();
+    protected double p = 0., px = 0., py = 0., pz = 0.;
+    protected double[] momentum;
+    protected int charge = 0;
+
+    /** */
+    public FoundTrack()
+    {
+    }
+
+    public void addHit(SimTrackerHit hit) { list.add(hit); }
+    public int  getNPoints() { return list.size(); }
+    public List<SimTrackerHit> getHits() { return list; }
+
+    public int getCharge() { return charge; }
+    public double getPX() { return px; }
+    public double getPY() { return py; }
+    public double getPZ() { return pz; }
+    public double[] getMomentum() { return momentum; }
+}

diff -N MakeTracks.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ MakeTracks.java	18 Jun 2012 23:02:13 -0000	1.1
@@ -0,0 +1,101 @@

+/*
+ * MakeTracks.java
+ *
+ * Created on February 6, 2008, 11:40 AM
+ *
+ */
+
+package org.lcsim.recon.tracking.seedtracker;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.lcsim.event.EventHeader;
+import org.lcsim.event.Track;
+import org.lcsim.event.TrackerHit;
+import org.lcsim.fit.helicaltrack.HelicalTrackFit;
+import org.lcsim.fit.helicaltrack.HelicalTrackHit;
+import org.lcsim.util.lcio.LCIOConstants;
+
+/**
+ * Create a list of SeedTracks from a list of SeedCandidates that have passed
+ * the SeedTracker algorithm and store these tracks back into the event.
+ * @author Richard Partridge
+ * @version 1.0
+ */
+public class MakeTracks {
+
+    private String _TrkCollectionName = EventHeader.TRACKS;
+    TrackCheck _trackCheck; // set by SeedTracker
+
+    /**
+     * Creates a new instance of MakeTracks.
+     */
+    public MakeTracks() {
+    }
+    
+    /**
+     * Process a list of SeedCandidates to make a list of SeedTracks and store
+     * these tracks back into the event.
+     * @param event event header
+     * @param seedlist list of SeedCandidates that are to be turned into tracks
+     * @param bfield magnetic field (used to turn curvature into momentum)
+     */
+    public void Process(EventHeader event, List<SeedCandidate> seedlist, double bfield) {
+        
+        //  Create a the track list
+        List<Track> tracks = new ArrayList<Track>();
+        
+        //  Initialize the reference point to the origin
+        double[] ref = new double[3];
+        ref[0] = 0.;
+        ref[1] = 0.;
+        ref[2] = 0.;
+        
+        //  Loop over the SeedCandidates that have survived
+        for (SeedCandidate trackseed : seedlist) {
+            
+            //  Create a new SeedTrack (SeedTrack extends BaseTrack)
+            SeedTrack trk = new SeedTrack();
+            
+            //  Add the hits to the track
+            for (HelicalTrackHit hit : trackseed.getHits()) {
+                trk.addHit((TrackerHit) hit);
+            }
+            
+            //  Retrieve the helix and save the relevant bits of helix info
+            HelicalTrackFit helix = trackseed.getHelix();
+            trk.setTrackParameters(helix.parameters(), bfield);
+            trk.setCovarianceMatrix(helix.covariance());
+            trk.setChisq(helix.chisqtot());
+            trk.setNDF(helix.ndf()[0]+helix.ndf()[1]);
+            
+            //  Flag that the fit was successful and set the reference point
+            trk.setFitSuccess(true);
+            trk.setReferencePoint(ref);
+            trk.setRefPointIsDCA(true);
+            
+            //  Set the strategy used to find this track
+            trk.setStratetgy(trackseed.getSeedStrategy());
+            
+            //  Set the SeedCandidate this track is based on
+            trk.setSeedCandidate(trackseed);
+
+            // Check the track - hook for plugging in external constraint
+            if ((_trackCheck != null) && (! _trackCheck.checkTrack(trk))) continue;
+
+            //  Add the track to the list of tracks
+            tracks.add((Track) trk);
+        }
+        
+        // Put the tracks back into the event and exit
+        int flag = 1<<LCIOConstants.TRBIT_HITS;
+        event.put(_TrkCollectionName, tracks, Track.class, flag);
+        
+        return;
+    }
+
+    void setTrkCollectionName(String name) {
+        _TrkCollectionName = name;
+    }
+}

diff -N SIOTrack.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ SIOTrack.java	18 Jun 2012 23:02:13 -0000	1.1
@@ -0,0 +1,136 @@

+package org.lcsim.util.lcio;
+
+import hep.io.sio.SIOInputStream;
+import hep.io.sio.SIOOutputStream;
+import hep.io.sio.SIORef;
+import hep.physics.matrix.SymmetricMatrix;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import org.lcsim.event.Track;
+import org.lcsim.event.TrackerHit;
+import org.lcsim.event.base.BaseTrack;
+
+
+/**
+ *
+ * @author Tony Johnson
+ * @version $Id: SIOTrack.java,v 1.1 2012/06/18 23:02:13 jeremy Exp $
+ */
+class SIOTrack extends BaseTrack
+{
+   private List<SIORef> tempHits;
+   private List<SIORef> tempTracks;
+   
+   SIOTrack(SIOInputStream in, int flag, int version, double bField) throws IOException
+   {
+      _type = in.readInt();
+      double[] parameters = new double[5];
+      for (int i=0; i<parameters.length; i++) parameters[i] = in.readFloat();
+      setTrackParameters(parameters,bField);
+      double[] covMatrix = new double[15];
+      for (int i=0; i<covMatrix.length; i++) covMatrix[i] = in.readFloat();
+      _covMatrix = new SymmetricMatrix(5,covMatrix,true);
+      _refPoint = new double[3];
+      _refPoint[0] = in.readFloat();
+      _refPoint[1] = in.readFloat();
+      _refPoint[2] = in.readFloat();
+      _chi2 = in.readFloat();
+      _ndf = in.readInt() ;
+      _dEdx = in.readFloat();
+      _dEdxErr = in.readFloat();
+      _innermostHitRadius = in.readFloat() ;
+      int nHitNumbers = in.readInt() ;
+      _subdetId = new int[nHitNumbers] ;
+      for (int i = 0; i < nHitNumbers; i++)
+      {
+         _subdetId[i] = in.readInt() ;
+      }
+      int nTracks = in.readInt();
+      tempTracks = new ArrayList(nTracks);
+      _tracks = null;
+      for (int i=0; i<nTracks; i++)
+      {
+         tempTracks.add(in.readPntr());
+      }
+      if (LCIOUtil.bitTest(flag,LCIOConstants.TRBIT_HITS))
+      {
+         int nHits = in.readInt();
+         tempHits = new ArrayList(nHits);
+         _hits = null;
+         for (int i = 0; i < nHits; i++)
+         {
+            tempHits.add(in.readPntr());
+         }
+      }
+      
+      in.readPTag(this);
+   }
+   static void write(Track track, SIOOutputStream out, int flag) throws IOException
+   {
+      out.writeInt(track.getType());
+      double[] parm = track.getTrackParameters();
+      for (int i=0; i<5; i++) out.writeFloat((float) parm[i]);
+      double[] covMatrix = track.getErrorMatrix().asPackedArray(true);
+      for (int i=0; i<15; i++) out.writeFloat((float) covMatrix[i]);
+      double[] referencePoint = track.getReferencePoint();
+      for (int i=0; i<3; i++) out.writeFloat((float) referencePoint[i]);
+      out.writeFloat((float) track.getChi2());
+      out.writeInt(track.getNDF());
+      out.writeFloat((float) track.getdEdx());
+      out.writeFloat((float) track.getdEdxError());
+      out.writeFloat((float) track.getRadiusOfInnermostHit()) ;
+      int[] hitNumbers = track.getSubdetectorHitNumbers();
+      out.writeInt( hitNumbers.length ) ;
+      for (int i = 0; i < hitNumbers.length; i++)
+      {
+         out.writeInt( hitNumbers[i] ) ;
+      }
+      List<Track> tracks = track.getTracks() ;
+      out.writeInt( tracks.size()  ) ;
+      for (Track t : tracks)
+      {
+         out.writePntr(t);
+      }
+      if(LCIOUtil.bitTest(flag,LCIOConstants.TRBIT_HITS))
+      {
+         List<TrackerHit> hits = track.getTrackerHits();
+         out.writeInt(hits.size());
+         for (TrackerHit hit : hits)
+         {
+            out.writePntr(hit);
+         }
+      }
+      out.writePTag(track);
+   }
+   
+   public List<TrackerHit> getTrackerHits()
+   {
+      if (_hits == null && tempHits != null)
+      {
+         _hits = new ArrayList<TrackerHit>(tempHits.size());
+         for (SIORef ref : tempHits)
+         {
+            _hits.add((TrackerHit) ref.getObject());
+         }
+         tempHits = null;
+      }
+      return _hits == null ? Collections.<TrackerHit>emptyList() : _hits;
+   }
+   
+   public List<Track> getTracks()
+   {
+      if (_tracks == null && tempTracks != null)
+      {
+         _tracks = new ArrayList<Track>(tempTracks.size());
+         for (SIORef ref : tempTracks)
+         {
+            _tracks.add((Track) ref.getObject());
+         }
+         tempTracks = null;
+      }
+      return _tracks == null ? Collections.<Track>emptyList() : _tracks;
+   }
+}

diff -N Track.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ Track.java	18 Jun 2012 23:02:14 -0000	1.1
@@ -0,0 +1,131 @@

+package org.lcsim.event;
+
+import hep.physics.matrix.SymmetricMatrix;
+
+import java.util.List;
+
+
+/**
+ * Represents a found (reconstructed) track
+ * 
+ * @author tonyj
+ * @version $Id: Track.java,v 1.1 2012/06/18 23:02:14 jeremy Exp $
+ */
+
+public interface Track 
+{
+    int getCharge();
+
+    double[] getReferencePoint();
+
+    double getReferencePointX();
+
+    double getReferencePointY();
+
+    double getReferencePointZ();
+
+    boolean isReferencePointPCA();
+
+    double[] getMomentum();
+
+    // Hep3Vector momentum();
+    // SpacePoint referencePoint();
+    double getPX();
+
+    double getPY();
+
+    double getPZ();
+
+    // MCParticle getMCParticle();
+
+    /**
+     * Returns true if the track has been successfully fitted
+     */
+
+    boolean fitSuccess();
+
+    /**
+     * Get an individual track parameter
+     * 
+     * The track parameters for LCD are defined as follows <table>
+     * <tr>
+     * <th>Index</th>
+     * <th>Meaning</th>
+     * </tr>
+     * <tr>
+     * <td> 0 </td>
+     * <td> d0 = XY impact parameter </td>
+     * <tr>
+     * <tr>
+     * <td> 1 </td>
+     * <td> phi0 </td>
+     * <tr> </td>
+     * <tr>
+     * <tr>
+     * <td> 2 </td>
+     * <td> omega = 1/curv.radius (negative for negative tracks) </td>
+     * <tr>
+     * <tr>
+     * <td> 3 </td>
+     * <td> z0 = z of track origin (z impact parameter) </td>
+     * <tr>
+     * <tr>
+     * <td> 4 </td>
+     * <td> s = tan lambda </td>
+     * <tr> </table> Parameters according to <a
+     * href="../util/swim/doc-files/L3_helix.pdf">the L3 conventions</a><br />
+     * 
+     * @param i
+     *                The index of the track parameter
+     * @return The track parameter with the specified index
+     */
+    double getTrackParameter(int i);
+
+    /**
+     * Get the track parameters as an array
+     * 
+     * @see #getTrackParameter
+     */
+    double[] getTrackParameters();
+
+    /**
+     * Get the error matrix
+     * 
+     * @see #getTrackParameter
+     */
+    SymmetricMatrix getErrorMatrix();
+
+    /**
+     * Get the Chi Squared for the track fit
+     * 
+     * @see #getNDF
+     * @return Chi Squared
+     */
+    double getChi2();
+
+    /**
+     * Get the numbers of degrees of freedom for the fit
+     * 
+     * @see #getChi2
+     * @return The number of degrees of freedom
+     */
+    int getNDF();
+
+    double getdEdx();
+
+    double getdEdxError();
+
+    double getRadiusOfInnermostHit();
+
+    int[] getSubdetectorHitNumbers();
+
+    List<Track> getTracks();
+
+    List<TrackerHit> getTrackerHits();
+
+    int getType();
+
+    // double parameter(ParameterName n);
+    // similar name is not a problem, because of different signature
+    // Parameters parameters();
+}

diff -N TrackTableModel.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ TrackTableModel.java	18 Jun 2012 23:02:14 -0000	1.1
@@ -0,0 +1,30 @@

+package org.lcsim.plugin.browser;
+import org.lcsim.event.Track;
+
+
+/**
+ *
+ * @author tonyj
+ */
+class TrackTableModel extends GenericTableModel
+{
+   private static final String[] columns = {"Type","D0","Phi","Omega","Z0","TanLambda","Chi2","NDF","dEdx","Momentum"};
+   private static Class klass = Track.class;
+
+   TrackTableModel()
+   {
+      super(klass,columns);
+   }
+
+   public Object getValueAt(int row, int column)
+   {
+      if (column > 0 && column <= 5) return ((Track) getData(row)).getTrackParameter(column-1);
+      else return super.getValueAt(row,column);
+   }
+   
+   public Class getColumnClass(int column)
+   {
+       if (column > 0 && column <= 5) return Double.class;
+       else return super.getColumnClass(column);
+   }
+}

diff -N TrackState.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ TrackState.java	18 Jun 2012 23:02:14 -0000	1.2
@@ -0,0 +1,90 @@

+package org.lcsim.event;
+
+/** 
+ * The LCIO TrackState interface.
+ * 
+ * @author gaede, engels
+ * @author Jeremy McCormick
+ * @version $Id: TrackState.java,v 1.2 2012/06/18 23:02:14 jeremy Exp $
+ */
+public interface TrackState 
+{
+    // TrackState location codes.
+    public final static int AtOther = 0;  // Any location other than the ones defined below. 
+    public final static int AtIP = 1;
+    public final static int AtFirstHit = 2;
+    public final static int AtLastHit = 3;
+    public final static int AtCalorimeter = 4;
+    public final static int AtVertex = 5;
+    public final static int LastLocation = AtVertex;
+    
+    /** 
+     * The location of the track state.
+     * Location can be set to: AtIP, AtFirstHit, AtLastHit, AtCalorimeter, AtVertex, AtOther
+     */
+    public int getLocation();
+
+    /** 
+     * Impact paramter of the track in (r-phi).
+     */
+    public double getD0();
+
+    /** 
+     * Phi of the track at the reference point.
+     * @see getReferencePoint
+     */
+    public double getPhi();
+
+    /** 
+     * Omega is the signed curvature of the track in [1/mm].
+     * The sign is that of the particle's charge.
+     */
+    public double getOmega();
+
+    /** 
+     * Impact paramter of the track in (r-z).
+     */
+    public double getZ0();
+
+    /** 
+     * Lambda is the dip angle of the track in r-z at the reference point. 
+     * @see getReferencePoint
+     */
+    public double getTanLambda();
+    
+    /**
+     * Get the ordered list of 5 LCIO track parameters.
+     * @return The track parameters as a double array of size 5.
+     */
+    public double[] getParameters();
+
+    /** 
+     * Covariance matrix of the track parameters. Stored as lower triangle matrix where
+     * the order of parameters is:   d0, phi, omega, z0, tan(lambda).
+     * So we have cov(d0,d0), cov( phi, d0 ), cov( phi, phi), ...
+     * @return A double array of size 15 containing the covariance matrix of the track parameters.
+     */
+    public double[] getCovMatrix();
+
+    /** 
+     * Reference point of the track parameters.
+     * The default for the reference point is the point of closest approach.
+     * @return The reference point of the track parameters as a double array of size 3.
+     */
+    public double[] getReferencePoint();
+    
+    public double[] getMomentum();
+    
+    /**
+     * Get an individual track parameter.
+     * They are returned by the following keys: 
+     * 0 = d0
+     * 1 = phi
+     * 2 = omega
+     * 3 = z0
+     * 4 = tanLambda
+     * This order is defined in BaseTrack. 
+     * @return The track parameters.
+     */
+    public double getParameter(int iparam);
+}

\ No newline at end of file

diff -u -r1.11 -r1.12
--- Track.java	23 May 2008 06:53:35 -0000	1.11
+++ Track.java	18 Jun 2012 23:02:14 -0000	1.12
@@ -9,7 +9,7 @@

  * Represents a found (reconstructed) track
  * 
  * @author tonyj

- * @version $Id: Track.java,v 1.11 2008/05/23 06:53:35 jeremy Exp $

+ * @version $Id: Track.java,v 1.12 2012/06/18 23:02:14 jeremy Exp $

  */
 
 public interface Track 

@@ -124,6 +124,8 @@

     List<TrackerHit> getTrackerHits();
 
     int getType();

+    
+    List<TrackState> getTrackStates();

 
     // double parameter(ParameterName n);
     // similar name is not a problem, because of different signature

diff -u -r1.10 -r1.11
--- ReconTrack.java	25 Apr 2008 06:13:09 -0000	1.10
+++ ReconTrack.java	18 Jun 2012 23:02:14 -0000	1.11
@@ -6,6 +6,8 @@

 import hep.physics.particle.Particle;
 import hep.physics.vec.Hep3Vector;
 import org.lcsim.event.Track;

+import org.lcsim.event.TrackState;
+

 import java.io.*;
 import java.util.Collections;
 import java.util.List;

@@ -19,7 +21,7 @@

  * are provided. <br>
  *
  * @author Tony Johnson, Wolfgang Walkowiak

- * @version $Id: ReconTrack.java,v 1.10 2008/04/25 06:13:09 timb Exp $

+ * @version $Id: ReconTrack.java,v 1.11 2012/06/18 23:02:14 jeremy Exp $

  */
 public class ReconTrack implements Track
 {

@@ -559,4 +561,9 @@

       }
       return errMatrix;
    }

-}

+   
+   public List<TrackState> getTrackStates()
+   {
+       return null;
+   }
+}

\ No newline at end of file

diff -u -r1.1 -r1.2
--- FastMCTrack.java	29 Nov 2007 21:29:35 -0000	1.1
+++ FastMCTrack.java	18 Jun 2012 23:02:14 -0000	1.2
@@ -1,5 +1,5 @@

 /**

- * @version $Id: FastMCTrack.java,v 1.1 2007/11/29 21:29:35 jstrube Exp $

+ * @version $Id: FastMCTrack.java,v 1.2 2012/06/18 23:02:14 jeremy Exp $

  */
 package org.lcsim.mc.fast.tracking.fix;
 

@@ -12,6 +12,7 @@

 import org.lcsim.event.LCIOParameters;
 import org.lcsim.event.MCParticle;
 import org.lcsim.event.Track;

+import org.lcsim.event.TrackState;

 import org.lcsim.event.TrackerHit;
 import org.lcsim.event.LCIOParameters.ParameterName;
 import org.lcsim.spacegeom.CartesianPoint;

@@ -187,4 +188,9 @@

     public SpacePoint referencePoint() {
         return _referencePoint;
     }

-}

+    
+    public List<TrackState> getTrackStates()
+    {
+        return null;
+    }
+}

\ No newline at end of file

diff -u -r1.3 -r1.4
--- TrackTableModel.java	16 Aug 2007 21:06:58 -0000	1.3
+++ TrackTableModel.java	18 Jun 2012 23:02:14 -0000	1.4
@@ -8,18 +8,40 @@

  */
 class TrackTableModel extends GenericTableModel
 {

-   private static final String[] columns = {"Type","D0","Phi","Omega","Z0","TanLambda","Chi2","NDF","dEdx","Momentum"};

+   private static final String[] columns = {"Type", "D0", "Phi", "Omega", "Z0", "TanLambda", "Track States", "Momentum", "Chi2", "NDF", "dEdx"};
+       //, "Momentum"};

    private static Class klass = Track.class;
 
    TrackTableModel()
    {

-      super(klass,columns);

+       super(klass,columns);

    }
 
    public Object getValueAt(int row, int column)
    {

-      if (column > 0 && column <= 5) return ((Track) getData(row)).getTrackParameter(column-1);
-      else return super.getValueAt(row,column);

+       if (column == 0)
+       {
+           // Track type (???).
+           return ((Track)getData(row)).getType();
+       }
+       else if (column >= 1 && column <= 5)
+       {
+           // Displays data about first TrackState, only.
+           return ((Track)getData(row)).getTrackStates().get(0).getParameter(column-1);
+      }
+      else if (column == 6)
+      {
+          // Number of total TrackStates.
+          return ((Track)getData(row)).getTrackStates().size();
+      }
+      else if (column == 7)
+      {
+          return ((Track)getData(row)).getTrackStates().get(0).getMomentum();
+      }
+      else 
+      {
+          return super.getValueAt(row,column);
+      }

    }
    
    public Class getColumnClass(int column)

@@ -27,4 +49,4 @@

        if (column > 0 && column <= 5) return Double.class;
        else return super.getColumnClass(column);
    }

-}

+}

\ No newline at end of file

diff -u -r1.2 -r1.3
--- GarfieldTrack.java	21 Sep 2007 12:07:47 -0000	1.2
+++ GarfieldTrack.java	18 Jun 2012 23:02:14 -0000	1.3
@@ -25,7 +25,7 @@

  *
  * @author  E. von Toerne
  * @author  D. Onoprienko

- * @version $Id: GarfieldTrack.java,v 1.2 2007/09/21 12:07:47 onoprien Exp $

+ * @version $Id: GarfieldTrack.java,v 1.3 2012/06/18 23:02:14 jeremy Exp $

  */
 public class GarfieldTrack implements Track {
   

@@ -960,7 +960,10 @@

     return hel.base(2);
   }
   

-  

+  public List<TrackState> getTrackStates()
+  {
+      return null;
+  }

 }
 
 

diff -u -r1.3 -r1.4
--- BasicTrack.java	29 Nov 2007 02:25:59 -0000	1.3
+++ BasicTrack.java	18 Jun 2012 23:02:14 -0000	1.4
@@ -1,6 +1,7 @@

 package org.lcsim.recon.cat.util;
 
 import java.util.*;

+

 import org.lcsim.event.*;
 import org.lcsim.util.*;
 import hep.physics.matrix.SymmetricMatrix;

@@ -18,7 +19,7 @@

  * Includes method for initializing track parameters from momentum at a given point.
  *
  * @author D. Onoprienko

- * @version $Id: BasicTrack.java,v 1.3 2007/11/29 02:25:59 jstrube Exp $

+ * @version $Id: BasicTrack.java,v 1.4 2012/06/18 23:02:14 jeremy Exp $

  */
 public class BasicTrack implements Track {
 

@@ -186,4 +187,8 @@

     _conListener.conditionsChanged(null);
   }
   

+  public List<TrackState> getTrackStates()
+  {
+      return null;
+  }

 }

diff -u -r1.4 -r1.5
--- MakeTracks.java	7 Aug 2009 23:33:17 -0000	1.4
+++ MakeTracks.java	18 Jun 2012 23:02:14 -0000	1.5
@@ -47,10 +47,7 @@

         List<Track> tracks = new ArrayList<Track>();
         
         //  Initialize the reference point to the origin

-        double[] ref = new double[3];
-        ref[0] = 0.;
-        ref[1] = 0.;
-        ref[2] = 0.;

+        double[] ref = new double[] {0., 0., 0.};

         
         //  Loop over the SeedCandidates that have survived
         for (SeedCandidate trackseed : seedlist) {

@@ -65,14 +62,14 @@

             
             //  Retrieve the helix and save the relevant bits of helix info
             HelicalTrackFit helix = trackseed.getHelix();

-            trk.setTrackParameters(helix.parameters(), bfield);
-            trk.setCovarianceMatrix(helix.covariance());

+            trk.setTrackParameters(helix.parameters(), bfield); // Sets first TrackState.
+            trk.setCovarianceMatrix(helix.covariance()); // Modifies first TrackState.

             trk.setChisq(helix.chisqtot());
             trk.setNDF(helix.ndf()[0]+helix.ndf()[1]);
             
             //  Flag that the fit was successful and set the reference point
             trk.setFitSuccess(true);

-            trk.setReferencePoint(ref);

+            trk.setReferencePoint(ref); // Modifies first TrackState.

             trk.setRefPointIsDCA(true);
             
             //  Set the strategy used to find this track

diff -u -r1.24 -r1.25
--- ZvTrack.java	23 Oct 2006 19:42:26 -0000	1.24
+++ ZvTrack.java	18 Jun 2012 23:02:14 -0000	1.25
@@ -1,5 +1,9 @@

 package org.lcsim.recon.vertexing.zvtop4;
 

+import static java.lang.Math.acos;
+import static java.lang.Math.cos;
+import static java.lang.Math.sin;
+import static java.lang.Math.sqrt;

 import hep.physics.matrix.SymmetricMatrix;
 import hep.physics.vec.BasicHep3Vector;
 import hep.physics.vec.Hep3Vector;

@@ -8,23 +12,16 @@

 import java.util.List;
 
 import org.lcsim.event.Track;

+import org.lcsim.event.TrackState;

 import org.lcsim.event.TrackerHit;

-import org.lcsim.geometry.compact.converter.lcdd.util.Rotation;

 import org.lcsim.spacegeom.CartesianPoint;
 import org.lcsim.spacegeom.SpacePoint;

-import org.lcsim.util.swim.Helix;
-
-import static java.lang.Math.sqrt;
-import static java.lang.Math.cos;
-import static java.lang.Math.sin;
-import static java.lang.Math.acos;
-import static java.lang.Math.PI;

 
 /**
  * Representation of the Gaussian tubes
  * 
  * @author jstrube

- * @version $Id: ZvTrack.java,v 1.24 2006/10/23 19:42:26 tonyj Exp $

+ * @version $Id: ZvTrack.java,v 1.25 2012/06/18 23:02:14 jeremy Exp $

  */
 public class ZvTrack implements Track {
 

@@ -610,4 +607,9 @@

         t178 = Math.pow(-54 * t5 * t4 - 0.54e2 * t10 * t8 + 0.54e2 * t14 * t13 + 54 * z1 * t4 + 0.6e1 * t175, 0.1e1 / 0.3e1);
         return(t178 * t2 / 0.6e1 + 0.1e1 / t178 * t2 * (0.2e1 * t157 + 0.2e1 * t152 - t20 - 0.2e1 * t150 - 0.1e1));
     }

+    
+    public List<TrackState> getTrackStates()
+    {
+        return null;
+    }

 }

diff -u -r1.3 -r1.4
--- AbstractTrack.java	23 Oct 2006 19:42:36 -0000	1.3
+++ AbstractTrack.java	18 Jun 2012 23:02:14 -0000	1.4
@@ -11,6 +11,7 @@

 
 import hep.physics.matrix.SymmetricMatrix;
 import org.lcsim.event.Track;

+import org.lcsim.event.TrackState;

 import org.lcsim.event.TrackerHit;
 import java.util.ArrayList;
 import java.util.List;

@@ -37,4 +38,8 @@

     public List<Track> getTracks() { List<Track> list = new ArrayList<Track>(); return list; }
     public List<TrackerHit> getTrackerHits() { List<TrackerHit> list = new ArrayList<TrackerHit>(); return list; }
     public int getType() { return 0; }

+    public List<TrackState> getTrackStates()
+    {
+        return null;
+    }

 }

diff -u -r1.3 -r1.4
--- FoundTrack.java	5 Aug 2005 00:47:00 -0000	1.3
+++ FoundTrack.java	18 Jun 2012 23:02:14 -0000	1.4
@@ -10,6 +10,7 @@

 package org.lcsim.recon.ztracking;
 
 import org.lcsim.event.SimTrackerHit;

+import org.lcsim.event.TrackState;

 import org.lcsim.event.TrackerHit;
 import java.util.ArrayList;
 import java.util.List;

@@ -36,4 +37,8 @@

     public double getPY() { return py; }
     public double getPZ() { return pz; }
     public double[] getMomentum() { return momentum; }

+    public List<TrackState> getTrackStates()
+    {
+        return null;
+    }

 }

diff -u -r1.15 -r1.16
--- LCIOConstants.java	24 Aug 2011 18:51:18 -0000	1.15
+++ LCIOConstants.java	18 Jun 2012 23:02:14 -0000	1.16
@@ -6,9 +6,11 @@

  */
 public interface LCIOConstants
 {

-   int MAJORVERSION = 1;
-   int MINORVERSION = 60;
-   

+   //int MAJORVERSION = 1;
+   //int MINORVERSION = 60;
+   int MAJORVERSION = 2;
+   int MINORVERSION = 0;
+    

    // bits in flag words
    // SimCalorimeterHit (CH)
    int CHBIT_LONG = 31;