DSTF Review of TkrRecon
 Transient Data Store (TDS) Classes

Brief Overview:

Today's review will look at the current implementation of the TkrRecon TDS Classes resulting from the output of the reconstruction.  The overall TkrRecon reconstruction process currently consists of four main algorithms (see diagram): Clustering, Track Pattern Recognition, Track Fitting and Gamma/Vertex Finding. Each of these algorithms produces a number of objects of the same class (e.g. a large number of cluster objects are output from the Clustering algorithm) which are then "contained" by a single TDS class. So, the TkrRecon TDS output classes fall into two categories: 1) Container classes, which inherit from Gaudi's DataObject and are the classes actually stored in the TDS, and 2) Contained classes which represent the actual result of a particular algorithm (e.g. a fit track).

Class Design Considerations:

1. The TDS classes will reside in the GlastEvent package, not in the TkrRecon package
   • This requires separating the TkrRecon specific methods of creating/filling the classes from the classes themselves
   • Should limit to methods which fill the classes and access their information
2. The Permanent Data Storage classes will be clones of the TDS classes
   • Want to store all TDS info in PDS
   • Want to be able to recreate the full TDS classes from PDS
3. The Track Candidate/Fit/Vertex classes should have a generic interface to facilitate use by the "external" user
   • "Typical" user only interested in base information, provide a uniform interface to facilitate this.
   • Still allow the "serious" user to access to full range of information.
4. The general form of the classes should be as generic as possible to allow them to be created/filled by different implementations of a particular algorithm. 
   • For Example: there currently exist (in cvs) three implementations of a pattern recognition algorithm all filling the same TkrPatCand candidate track class.

Classes to be reviewed:

1. The Clustering Classes
   • Output Classes:
     • The TkrClusters class contains the actual TkrCluster objects, kept in two separate lists. It provides, primarily, methods for accessing TkrCluster objects, either individually or via pointers to lists broken down in convenient groupings. It inherits from DataObject.
     • The class TkrCluster contains information for a single cluster and provides access methods to them.
   • Construction:
     • The clusters are constructed by TkrMakeClusters. This class does not inherit from TkrClusters.
     • In the course of making clusters, TkrBadStripsSvc can be used to merge clusters separated only by bad strips.
   • TkrRecon Utilities:
     •  TkrQueryClusters contains methods which return more elaborate information about the clusters.
2. The Pattern Recognition Classes
   • Output Classes:
     • TkrCandidates is the DataObject class which contains the TkrPatCand  objects. It consists of a vector of pointers to the candidate track objects and provides methods to add candidates and access them. 
     • The TkrPatCand objects contain summary information for a single candidate track. In addition it contains a vector of pointers to TkrPatCandHit objects which contain information for each "hit" (i.e. cluster) on the track, **for those pattern recognition algorithms that supply this information**. TkrPatCand inherits from the abstract interface definition TkrRecInfo which defines summary track information which the class should make available (more information below). It also provides methods for accessing the TkrPatCandHit information.
   • Construction:
     • In the current implementation, the classes which perform the track finding inherit from TkrCandidates. These classes find candidate tracks, then create the appropriate TkrPatCand object and add it to the list of candidates. There are currently three pattern recognition algorithms in cvs, in various states of completion:
       • TkrLinkAndTree implementing a very simple (and not fully functional) link and tree pattern recognition algorithm,
       • TkrNeuralNet implementing a Neural Net algorithm similar to that used by ALEPH, 
       • TkrComboPR implementing a combinatoric pattern recognition based on the method employed by the pdrApp era code. 
     • Note: The current method of constructing through inheritance allows the constructing method to hide "extra" (non-standard) algorithm specific information in the TDS class for use in a later stage of reconstruction. It is not intended to export this information to the PDS. Probably future incarnations of TkrRecon will attempt to find a "better" way to present this information.  
   • TkrRecon Utilities:
     • None at this time
3. The Track Fit Classes
   • Output Classes:
     • TkrTracks is the DataObject class which contains the TkrFitTrack objects. It consists of a vector of pointers to the fit track objects and provides methods to add fit tracks and access them.
     • The TkrFitTrack objects contain the information for each fit track. It contains base summary information provided by the fitter (e.g. track c²) and a vector of TkrFitPlane objects which contain fit information for each track hit. The TkrFitTrack class inherits from abstract interface class TkrRecInfo, implementing the summary track information methods defined there. In addition, it provides access to some other summary fit information as well as methods to add and access the TkrFitPlane objects.
     • The TkrFitPlane objects contain specific fit information for each hit on the track. Besides including hit "bookkeeping" info (e.g. cluster id) it also contains a series of TkrFitHit objects for a) the "measured" hit (cluster), b) the "predicted" hit (that predicted by extrapolating from the last position), c) the "fit" hit (currently the Kalman Filter weighted mean of the predicted and measured hit) and d) the "smoothed" hit (the result of the Kalman Filter smoothing process). 
     • TkrFitHit objects consist of a TkrFitPar and a TkrFitMatrix object. The TkrFitPar objects are the Track Parameters (which are x, x_slope, y, y_slope), the TkrFitMatrix objects are the associated covariance matrix.
   • Construction:
     • As with Pattern Recognition, the current implementation has the constructing class inherit from TkrTracks, fitting each candidate track, creating a TkrFitTrack object and adding it to the list. The current implementation also has a separate constructing class for each type of pattern recognition algorithm with the intention of allowing the fitting algorithm to employ any "special" information available. At this time the only real differences between fit algorithms is in obtaining the energy estimate for the particular track. The three TkrFitTrack constructing algorithms are: 
       • TkrLinkAndTreeFit
       • TkrNeuralNetFit
       • TkrComboFit
   • TkrRecon Utilities
     • None at this time
4. The Gamma Finding/Vertexing Classes
   • Output Classes:
     • TkrVertexCol is the DataObject class which contains the TkrVertex objects. It consists of a vector of pointers to the gamma/vertex objects and provides methods for adding and accessing them.
     • TkrVertex is the object containing the information for a found vertex. It contains summary information for this vertex, including what is necessary to return the information defined by the abstract interface class TkrRecInfo. It also contains a vector of pointers to the TkrFitTrack objects which have been associated with this vertex (note that these are pointers to the same objects also pointed to by TkrTracks).
   • Construction:
     • Construction of the vertexing TDS classes follows the same model as above, the particular vertexing algorithm inherits from the TkrVertexCol class, finds and "fits" vertices, creates a TkrVertex object and adds it to the list. The scheme is again intended to allow "extra" information from the particular choice of pattern recognition and/or track fit to be employed at this stage. However, the single algorithm currently in existence, TkrComboVtx,  is a highly simplified combinatoric algorithm intended primarily to test the code chain... 
   • TkrRecon Utilities
     • None at this time
5. The Abstract Interface TkrRecInfo 
   • The intention is to define a base set of quantities typically needed by the "casual" user (e.g. Cal Recon):
     • Position and direction
     • Track parameters and covariance matrix
     • Track energy
     • Track Quality 
     • etc.
   • Assuming that the needs of the ACD are different from the Cal, these values can be obtained at either the start or the end of the track
   • Track parameters and covariance matrix are provided as a future release of the particle propagator (at least the Geant version) will take these as input, transport them for the user to a specified plane and return the new values. For example, transporting from the end of a fit track to the face of the calorimeter will be done completely by the propagator resulting in a picture similar to the following:
     
     
     
     The blue line represents the fit track in the Tracker, the black track is the extrapolation of the fit track to the face of the calorimeter. The extrapolation is done by the propagator taking as input the track parameters and covariance matrix at the end of the fit track. It then returns the updated parameters and matrix at the face of the calorimeter.
     
     

T. Usher Last Modified: 2002-05-02 10:27:14 -0700