diff -N HelicalTrack2DHit.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ HelicalTrack2DHit.java	11 Dec 2007 20:35:04 -0000	1.1
@@ -0,0 +1,82 @@

+/*
+ * HelicalTrack2DHit.java
+ *
+ * Created on November 13, 2007, 1:10 PM
+ *
+ */
+
+package org.lcsim.fit.helicaltrack;
+
+import org.lcsim.event.TrackerHit;
+
+/**
+ * Encapsulate 2D hit info needed by HelicalTrackFit.  This class is
+ * applicable to barrel strip hits that measure the r-phi coordinate
+ * and place limits on the z coordinate.
+ * @author Richard Partridge
+ * @version 1.0
+ */
+public class HelicalTrack2DHit extends HelicalTrackHit {
+    private double _zmin;
+    private double _zmax;
+    
+    /**
+     * Fully qualified constructor to produce a HelicalTrack2DHit.
+     * @param hit corresponding TrackerHit
+     * @param zmin minimum value of z for this hit
+     * @param zmax maximum value of z for this hit
+     */
+    public HelicalTrack2DHit(TrackerHit hit, double zmin, double zmax) {
+        super(hit);
+        _zmin = zmin;
+        _zmax = zmax;
+    }
+    
+    /**
+     * Creates a new instance of HelicalTrack2DHit from a TrackerHit.
+     * The z coordinate of the hit is assumed to be at the center of
+     * the strip, and the error in z is assumed to be half the strip
+     * length in z.
+     * @param hit TrackerHit to be used
+     */
+    public HelicalTrack2DHit(TrackerHit hit) {
+        super(hit);
+        double z = this.z();
+        double[] cov = hit.getCovMatrix();
+        _zmin = z - Math.sqrt(cov[5]);
+        _zmax = z + Math.sqrt(cov[5]);
+    }
+    
+    /**
+     * Create a new instance of HelicalTrack2DHit from coordinates.  This
+     * constructor is provided to support the legacy method of performing
+     * HelicalTrackFits based on arrays of coordinates and errors.
+     * @param x x coordinate of the hit
+     * @param y y coordinate of the hit
+     * @param z z coordinate of the hit
+     * @param drphi uncertainty in the r-phi coordinate
+     * @param zmin minimum z of the hit
+     * @param zmax maximum z of the hit
+     */
+    public HelicalTrack2DHit(double x, double y, double z, double drphi, double zmin, double zmax) {
+        super(x, y, z, drphi);
+        _zmin = zmin;
+        _zmax = zmax;
+    }
+    
+    /**
+     * Return the minimum z coordinate
+     * @return minimum z coordinate
+     */
+    public double zmin() {
+        return _zmin;
+    }
+    
+    /**
+     * Return the maximum z coordinate
+     * @return maximum z coordinate
+     */
+    public double zmax() {
+        return _zmax;
+    }
+}

\ No newline at end of file

diff -N HelicalTrack3DHit.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ HelicalTrack3DHit.java	11 Dec 2007 20:35:04 -0000	1.1
@@ -0,0 +1,63 @@

+/*
+ * HelicalTrack3DHit.java
+ *
+ * Created on November 13, 2007, 12:39 PM
+ *
+ */
+
+package org.lcsim.fit.helicaltrack;
+
+import org.lcsim.event.TrackerHit;
+import org.lcsim.geometry.subdetector.BarrelEndcapFlag;
+
+/**
+ * Encapsulate 3D hit info needed by HelicalTrackFit
+ * @author Richard Partridge
+ * @version 1.0
+ */
+public class HelicalTrack3DHit extends HelicalTrackHit {
+    private BarrelEndcapFlag _beflag;
+    private double _dz;
+    
+    /**
+     * Creates a new instance of HelicalTrack3DHit from a SpacePoint
+     * @param hit TrackerHit for this hit
+     * @param beflag BarrelEndcapFlag for this hit
+     */
+    public HelicalTrack3DHit(TrackerHit hit, BarrelEndcapFlag beflag) {
+        super(hit);
+        _beflag = beflag;
+        _dz = hit.getCovMatrix()[5];
+    }
+    
+    /**
+     * Creates a HelicalTrack3DHit from scratch.
+     * @param x x coordinate of the hit
+     * @param y y coordinate of the hit
+     * @param z z coordinate of the hit
+     * @param drphi error in the bend (r-phi) coordinate
+     * @param dz error in the non-bend coordinate
+     */
+    public HelicalTrack3DHit(double x, double y, double z, double drphi, double dz) {
+        super(x, y, z, drphi);
+        _beflag = BarrelEndcapFlag.BARREL;
+        _dz = dz;
+    }
+
+    /**
+     * Return the uncertainty in the z coordinate
+     * @return uncertainty in the z coordinate
+     */
+    public double dz() {
+        return _dz;
+    }
+    
+    /**
+     * Returns true if the hit is in a barrel sensor, false for
+     * endcap (disk-like) sensors.
+     * @return true if the hit is a barrel sensor
+     */
+    public boolean isBarrel() {
+        return _beflag == BarrelEndcapFlag.BARREL;
+    }
+}

\ No newline at end of file

diff -N HelicalTrackHit.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ HelicalTrackHit.java	11 Dec 2007 20:35:04 -0000	1.1
@@ -0,0 +1,157 @@

+/*
+ * HelicalTrackHit.java
+ *
+ * Created on November 13, 2007, 12:18 PM
+ *
+ */
+
+package org.lcsim.fit.helicaltrack;
+
+import hep.physics.vec.BasicHep3Vector;
+
+import java.lang.Comparable;
+
+import org.lcsim.event.TrackerHit;
+
+/**
+ * Encapsulate the hit information needed by HelicalTrackFitter
+ * @author Richard Partridge
+ * @version 1.0
+ */
+public class HelicalTrackHit implements Comparable {
+    
+    private TrackerHit _trackerhit;
+    private double _x;
+    private double _y;
+    private double _z;
+    private double _r;
+    private double _phi;
+    private double _drphi;
+    private double _dr;
+    
+    /**
+     * Creates a new instance of HelicalTrack from a TrackerHit
+     * @param hit Corresponding TrackerHit
+     */
+    public HelicalTrackHit(TrackerHit hit) {
+        _trackerhit = hit;
+        double[] pos = hit.getPosition();
+        _x = pos[0];
+        _y = pos[1];
+        _z = pos[2];
+        setPolarCoordinates();
+        _r = Math.sqrt(_x * _x + _y * _y);
+        double[] cov = hit.getCovMatrix();
+        _drphi = Math.sqrt(_y * _y * cov[0] + _x * _x * cov[2] - 2. * _x * _y * cov[1]) / _r;
+        _dr = Math.sqrt(_x * _x * cov[0] + _y * _y * cov[2] + 2. * _x * _y * cov[1]) / _r;
+    }
+    
+    /**
+     * Create a new instance of HelicalTrackHit from coordinates.  This
+     * constructor is provided to support the legacy method of performing
+     * HelicalTrackFits based on arrays of coordinates and errors.
+     * @param x x coordinate of the hit
+     * @param y y coordinate of the hit
+     * @param z z coordinate of the hit
+     * @param drphi Uncertainty in the r-phi coordinate
+     */
+    public HelicalTrackHit(double x, double y, double z, double drphi) {
+        _trackerhit = null;
+        _x = x;
+        _y = y;
+        _z = z;
+        _r = Math.sqrt(_x * _x + _y * _y);
+        _phi = Math.atan2(_y, _x);
+        _drphi = drphi;
+        _dr = 0.;
+    }
+    
+    /**
+     * Return the TrackerHit that corresponds to this HelicalTrackHit
+     * @return Associated TrackerHit
+     */
+    public TrackerHit getTrackerHit() {
+        return _trackerhit;
+    }
+    
+    /**
+     * Return the x coordinate of the HelicalTrack3DHit
+     * @return x coordinate
+     */
+    public double x() {
+        return _x;
+    }
+    
+    /**
+     * Return the y coordinate of the HelicalTrack3DHit
+     * @return y coordinate
+     */
+    public double y() {
+        return _y;
+    }
+    
+    /**
+     * Return the z coordinate of the HelicalTrack3DHit
+     * @return z coordinate
+     */
+    public double z() {
+        return _z;
+    }
+    
+    /**
+     * Return the radius of the hit (i.e., distance from the z axis)
+     * @return radial coordinate
+     */
+    public double r() {
+        return _r;
+    }
+    
+    /**
+     * Return the azimuthal coordinate of the hit
+     * @return azimuthal coordinate
+     */
+    public double phi() {
+        return _phi;
+    }
+    
+    /**
+     * Return the weight used in the circle fit
+     * @return weight used in the circle fit
+     */
+    public double drphi() {
+        return _drphi;
+    }
+    
+    /**
+     * Return the uncertainty in r for the hit
+     * @return uncertainty in the radiu
+     */
+    public double dr() {
+        return _dr;
+    }
+    
+    /**
+     * Implement comparable interface to allow hits to be sorted
+     * by their z coordinate
+     * @param hit2 HelicalTrackHit to be compared against this instance
+     * @return 1 if the z for this hit is greater than for the one in the argument
+     */
+    public int compareTo(Object hit2) {
+        double zhit = ((HelicalTrackHit) hit2).z();
+        if (_z < zhit) return -1;
+        if (_z == zhit) return 0;
+        return 1;
+    }
+    
+    /**
+     * Calculate the polar coordinates _r, _phi from the cartesian
+     * coordinates _x, _y and cache them in this object since we
+     * expect them to be used repeatedly by the track finding code.
+     */
+    private void setPolarCoordinates() {
+        _r = Math.sqrt(_x * _x + _y * _y);
+        _phi = Math.atan2(_y, _x);
+        if (_phi < 0.) _phi += 2. * Math.PI;
+        return;
+    }
+}

\ No newline at end of file

diff -N HelicalTrackHitDriver.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ HelicalTrackHitDriver.java	11 Dec 2007 20:35:05 -0000	1.1
@@ -0,0 +1,139 @@

+/*
+ * HelicalTrackHitDriver.java
+ *
+ * Created on November 30, 2007, 3:50 PM
+ *
+ */
+
+package org.lcsim.fit.helicaltrack;
+
+import hep.physics.vec.BasicHep3Vector;
+import hep.physics.vec.Hep3Vector;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.lcsim.contrib.onoprien.tracking.geom.Sensor;
+import org.lcsim.contrib.onoprien.tracking.geom.SensorType;
+import org.lcsim.contrib.onoprien.tracking.hit.DigiTrackerHit;
+import org.lcsim.contrib.onoprien.tracking.hit.TrackerCluster;
+import org.lcsim.contrib.onoprien.tracking.hitmaking.OldTrackerHit;
+import org.lcsim.event.EventHeader;
+import org.lcsim.event.TrackerHit;
+import org.lcsim.geometry.subdetector.BarrelEndcapFlag;
+import org.lcsim.util.Driver;
+
+/**
+ * Create the appropriate HelicalTrackHits for the specified TrackerHit
+ * collections.  The resulting HelicalTrackHits encapsulate the information
+ * needed to perform a helical track hit for either a segmented strip
+ * detector, a pixel detector, or cross hits from a stereo detector.
+ * 
+ * At this time, this driver supports the virtual segmentation hits
+ * produced by the packages in contrib.onoprien.tracking.  Additional
+ * coding needs to be done to support fully segmented detectors.
+ * 
+ * The list of hit collections to be converted must be specified
+ * before the process method is executed.
+ * 
+ * Currently,
+ * @author Richard Partridge
+ * @version 1.0
+ */
+public class HelicalTrackHitDriver extends Driver {
+    /**
+     * Type of hits to be converted/
+     */
+    public enum HitType {
+        /**
+         * Virtual segmentation (OldTrackerHit) hits.
+         */
+        VirtualSegmentation}
+    private List<String> _vscol = new ArrayList<String>();
+    private String _outname = "HelicalTrackHits";
+    
+    /** Creates a new instance of HelicalTrackHitDriver */
+    public HelicalTrackHitDriver() {
+    }
+    
+    /**
+     * Create the HelicalTrackHits for the specified hit collections.
+     * @param event EventHeader of the event to be processed
+     */
+    public void process(EventHeader event) {
+        super.process(event);
+
+        //  Initialize the list of HelicalTrackHits and vector with local z direction
+        List<HelicalTrackHit> helhits = new ArrayList<HelicalTrackHit>();
+        Hep3Vector lz = new BasicHep3Vector(0., 0., 1.);
+        
+        //  Loop over the collections of hits with virtual segmentation
+        for (String colname : _vscol) {
+            //  Get the hits for this collection and loop over the hits
+            List<TrackerHit> hitlist = (List<TrackerHit>) event.get(colname);
+            for (TrackerHit hit : hitlist) {
+                //  Check that these hits are actually instances of OldTrackerHit and cast accordingly
+                if (hit instanceof OldTrackerHit) {
+                    OldTrackerHit vshit = (OldTrackerHit) hit;
+                    //  Get the cluster(s) and a sensor for this hit
+                    List<TrackerCluster> clist = vshit.getClusters();
+                    Sensor sensor = clist.get(0).getSensor();
+                    //  Check if this is a barrel or endcap hit by transforming the sensor
+                    //  normal in local coordinates to the global coordniate system
+                    Hep3Vector gz = sensor.getRotation().transformFrom(lz);
+                    BarrelEndcapFlag beflag = BarrelEndcapFlag.BARREL;
+                    if (Math.pow(gz.z(),2) > 0.5) {
+                        //  If the sensor normal mostly points in the z direction call it
+                        //  an endcap hit.  Check which endcap we are in.
+                        if (hit.getPosition()[2]>0) beflag = BarrelEndcapFlag.ENDCAP_NORTH;
+                        else beflag = BarrelEndcapFlag.ENDCAP_SOUTH;
+                    }
+                    //  If there are more than one (i.e., two) clusters for this hit, we
+                    //  have a cross formed from two stereo layers
+                    if (clist.size() > 1) {
+                        // Stereo hit found - make a HelicalTrack3DHit
+                        helhits.add((HelicalTrackHit) new HelicalTrack3DHit(hit, beflag));
+                    } else {
+                        //  Check the number of readout dimensions (1 = strip, 2 = pixel)
+                        SensorType stype = sensor.getType();
+                        if (stype.getHitDimension() == 2) {
+                            //  Pixel hit found - make a HelicalTrack3DHit
+                            helhits.add((HelicalTrackHit) new HelicalTrack3DHit(hit, beflag));
+                        } else if (stype.getHitDimension() == 1 && beflag == BarrelEndcapFlag.BARREL) {
+                            //  Barrel strip hit found - find the ends of the strip in z
+                            Hep3Vector pos = new BasicHep3Vector(hit.getPosition());
+                            Hep3Vector stripgeom = stype.getChannelDimensions(stype.getChannelID(pos));
+                            double zmin = pos.z() - 0.5 * stripgeom.y();
+                            double zmax = pos.z() + 0.5 * stripgeom.y();
+                            //  Make a HelicalTrack2DHit
+                            helhits.add((HelicalTrackHit) new HelicalTrack2DHit(hit, zmin, zmax));
+                        }
+                    }
+                }
+            }
+        }
+        //  Put the HelicalTrackHits back into the event
+        event.put(_outname, helhits);
+    }
+    
+    /**
+     * Add a TrackerHit collection to be processed.
+     * @param name Name of the hit collection
+     * @param type Type of collection
+     */
+    public void addCollection(String name, HitType type) {
+        if (type == HitType.VirtualSegmentation) {
+            _vscol.add(name);
+        }
+        return;
+    }
+    
+    /**
+     * Name of the HelicalTrackHit collection to be put back in the event.
+     * @param outname Name to use for the HelicalTrackHit collection
+     */
+    public void OutputCollection(String outname) {
+        _outname = outname;
+        return;
+    }
+}

\ No newline at end of file

diff -N MultipleScatter.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ MultipleScatter.java	11 Dec 2007 20:35:05 -0000	1.1
@@ -0,0 +1,50 @@

+/*
+ * MultipleScatter.java
+ *
+ * Created on November 21, 2007, 1:12 PM
+ *
+ */
+
+package org.lcsim.fit.helicaltrack;
+
+/**
+ * Encapsulate multiple scattering errors for a hit
+ * in the bend (r-phi) and non-bend (z for barrel,
+ * r for disk) coordinates.
+ * @author Richard Partridge
+ * @version 1.0
+ */
+public class MultipleScatter {
+    private double _bendMS;
+    private double _straightMS;
+    
+    /**
+     * Creates a new instance of MultipleScatter to encapsulate
+     * multiple scattering errors in the bend coordinate (r-phi)
+     * and the non-bend coordinate (z for barrel sensors, r for
+     * disk sensors).
+     * @param bendMS Multiple scattering error in the bend coordinate
+     * @param straightMS Multiple scattering error in the non-bend coordinate
+     */
+    public MultipleScatter(double bendMS, double straightMS) {
+        _bendMS = bendMS;
+        _straightMS = straightMS;
+    }
+    
+    /**
+     * Return the multiple scattering error in the bend (r-phi) coordinate
+     * @return bend coordinate multiple scattering error (units are mm)
+     */
+    public double bendMS() {
+        return _bendMS;
+    }
+    
+    /**
+     * Return the multiple scattering error in non-bend coordinate.
+     * This is the z coordinate for barrel hits, r for disk hits.
+     * @return non-bend coordinate multiple scattering error (units are mm)
+     */
+    public double straightMS() {
+        return _straightMS;
+    }
+}

\ No newline at end of file

diff -u -r1.4 -r1.5
--- HelicalTrackFit.java	23 Oct 2006 19:42:36 -0000	1.4
+++ HelicalTrackFit.java	11 Dec 2007 20:35:04 -0000	1.5
@@ -3,57 +3,67 @@

  *
  * Created on March 25, 2006, 6:11 PM
  *

- * $Id: HelicalTrackFit.java,v 1.4 2006/10/23 19:42:36 tonyj Exp $

+ * $Id: HelicalTrackFit.java,v 1.5 2007/12/11 20:35:04 partridge Exp $

  */
 
 package org.lcsim.fit.helicaltrack;
 
 import hep.physics.matrix.SymmetricMatrix;
 

+import java.util.HashMap;
+import java.util.Map;
+
+import org.lcsim.fit.circle.CircleFit;
+import org.lcsim.fit.line.SlopeInterceptLineFit;
+import org.lcsim.fit.zsegment.ZSegmentFit;
+

 /**
  * Represents the result of a fit to a helical track.
  * @author Norman Graf
  */

-public class HelicalTrackFit
-{

+public class HelicalTrackFit {

     // fit independently to a circle in x-y and a line in s-z
     // first is circle, second is line
     private double[] _chisq = new double[2];
     private int[] _ndf = new int[2];
     private double[] _parameters;
     private SymmetricMatrix _covmatrix;

-    private double[] _circleParameters = new double[3];

+    private Map<HelicalTrackHit, Double> _smap;

     
     /** Creates a new instance of HelicalTrackFit */

-    public HelicalTrackFit(double[] pars, SymmetricMatrix cov, double[] chisq, int[] ndf)
-    {

+    public HelicalTrackFit(double[] pars, SymmetricMatrix cov, double[] chisq, int[] ndf) {
+        this(pars, cov, chisq, ndf, new HashMap<HelicalTrackHit, Double>());
+    }
+    
+    public HelicalTrackFit(double[]pars, SymmetricMatrix cov, double[] chisq, int[] ndf,
+            Map<HelicalTrackHit, Double> smap) {

         _parameters = pars;
         _covmatrix = cov;
         _chisq = chisq;
         _ndf = ndf;

+        _smap = smap;

     }
     

-    public double[] parameters()
-    {

+    public double[] parameters() {

         return _parameters;
     }

-    public SymmetricMatrix covariance()
-    {

+    public SymmetricMatrix covariance() {

         return _covmatrix;
     }
     

-    public double[] chisq()
-    {

+    public double[] chisq() {

         return _chisq;
     }
     

-    public int[] ndf()
-    {

+    public int[] ndf() {

         return _ndf;
     }
     

-    public String toString()
-    {

+    public Map<HelicalTrackHit, Double> pathmap() {
+        return _smap;
+    }
+    
+    public String toString() {

         StringBuffer sb = new StringBuffer("HelicalTrackFit: \n");
         
         sb.append("d0= "+_parameters[0]+"\n");

@@ -65,14 +75,6 @@

         return sb.toString();
     }
     

-    public void setCircleParameters(double[] pars)
-    {
-        System.arraycopy(pars,0,_circleParameters,0,3);
-    }

-    public double[] circleParameters()
-    {
-        return _circleParameters;
-    }

     
 }