You can get hit links without re-running tracking.  The way to do it
is to first load in the hit set with all corrections (via CT_TrackingModule)
and then to search a road around the track for its hits.  If any hits used to
make the original track are outside the road (D_hit > D_road), you will not 
get all of the hits used to make the track.  If there are more hits in the 
road than in the original pattern recognition (N_search > N_original), you 
will get the best-matched hits to the track.  The number of hits will 
correspond the number in the original pattern recognition.

  To perform this method, you need to do the following:


1)  Include CT_TrackingModule in your binary and add the 
following talk-to to your tcl file:

  mod talk CT_TrackingModule
    NoTracking set t 
  exit


2)  Inside your code, add TrackingCT/CT_ReFit.hh to your list of 
included header files.  


3)  Create a reference to your track (call it, e.g., trk).  Then restore the 
hit links with the following code:

  CT_ReFit refit;
  refit.setSearchRoad(0.1);   // 1 mm is a little more than 5 sigma
  refit.restore(trk);	      // this restores the hit links by putting them
			      // into the LayerData structure of CT_ReFit
  if (!refit.ok()) continue;  // continue if something went wrong 


4)  The links are now available, and you can access the individual links: 
  
       // loop over COT layers
       int ilr = 0;
       const CT_ReFit::LayerData* ldat = refit.layer_data();
       for (int sl = 0; sl < 8; ++sl) {
         for (int wr = 0; wr < 12; ++wr, ++ilr) {
           if (ldat[ilr].link.is_valid()) {

		// actual hit
                CT_Hit hit = ldat[ilr].link.hit();

                // residual
                float res = ldat[ilr].deltaY();

                // hit width
                int hitwidth = hit.width();

		// optionally print out hit info
	        //ldat.print();	// (see CT_ReFit.icc for details)
				
		// Cell of hit
                int cell = ldat[ilr].link.cell();

		// Hit x,y
                CT_Vec2d xy = hit.getHitXY(sl,cell,wire);

		// Do the following to obtain hit z (note -- you need to 
		//		include linalg/CT_Helix.hh for this to work)
                CT_Helix helix(CT_Standard::icu, refit.par()[CT_Standard::icu],
                               CT_Standard::id0, refit.par()[CT_Standard::id0],
                               CT_Standard::ip0, refit.par()[CT_Standard::ip0],
                               CT_Standard::iz0, refit.par()[CT_Standard::iz0],
                               CT_Standard::ict, refit.par()[CT_Standard::ict]);
                CT_FTYPE r = xy.mag();

		// Hit z
                CT_FTYPE z = helix.zAtR(r);

              } // if layer data link is valid
            } // next wire
          } // next sl
        } // loop over tracks