GlueX TRACKING Reconstruction Page

Note: Names containing a colon (:) specify a factory with a (non-emtpy) tag. The format is class:tag.

Factory DMCTrackHit

Hits from "truth" tags including track number and primary flag.

This is one of two possible paths through which MC data can enter the tracking code. (The other is through the individual subsystems using their internal mechanisms to supply "hits".)

This path is useful because it is easy to correlate MC "truth" information with the tracking results. The identifier(ID) attribute of each DMCTrackHit object will be the same as the identifier for the corresponding DTrackHit object produced by the DTrackHit:MC factory.

All MC "truth" information used by the TRACKING package for track finding and fitting is contained in only this factory. (The DTrackEfficiency factory also uses truth info for efficiency studies.)

(Factory Identifier)
float r,phi,z;           // in cm and radians
int track;               // GEANT track number starting from 1
int primary;             // 1=primary track hit, otherwise, it's from a secondary
DetectorSystem_t system; // Detector system (see GlueX.h)

Factory DTrackHit:MC

Hits from "truth" tags, but in the form of real data.

This factory takes the hits from the DMCTrackHit factory and makes them into DTrackHit objects. This is done so that the DTrackCandidate factory can use hits from this factory (using tag="MC") in the same way as it uses hits from the real data DTrackHit factory (using an empty tag).

Factory DTrackHit

Combined list of hits from all detector systems.

This factory creates a single list of hits by combining the lists provided by the "Hit" factories for all the detector systems.

This is how real data enters into the tracking package. This is also the second path in which MC data can enter into the tracking package. In this path, it is the responsibility of the individual "Hit" factories upstream to format the MC data to look like real data.

It should be noted that while the factory presents a list of pointers of class DTrackHit, the underlying objects are actually a subclass of DTrackHit. The subclass, Dtrkhit contains fields used during the track finding that have little or no meaning outside of the factory.

(Factory Identifier)
float x,y,z,r,phi;              ///< location of hit in lab coordinates
int system;                     ///< detector system ID
MISSING COVARIANCE MATRIX!!

Factory DTrackCandidate

Track candidates with preliminary fit parameters.

This implements the Track Finding or Pattern Recognition phase of tracking. It takes a list of DTrackHit objects as input and looks for patterns consistent with a helix. Only the CDC and FDC hits are considered at this stage since they come from the central part of the solenoid where the field is nearly homogeneous.

As the tracks are found, a preliminary fit is done to the points to determine starting values for the vertex and momentum of each track. Errors are not considered in the fit and the magnetic field is assumed constant and in the z-direction.

(Factory Identifier)
int Nhits;
vector<identifier_t> hitid;  ///< ids of hits in DTrackHit factory
float x0,y0;                       ///< center of circle
float z_vertex;                    ///< z coordinate of vertex
float dphidz;                      ///< dphi/dz in radians per cm
float q;                           ///< electric charge 
float p, p_trans;                  ///< total and transverse momenta in GeV/c
float phi, theta;                  ///< theta and phi in radians

Factory DTrack

Tracks with final fit parameters.

This implements the Final Track Fitting phase of tracking. It performs a Kalman Filter fit using the list of DTrackCandidate objects as input.

This is the primary output of the tracking package.

(Factory Identifier)
float q;                   ///< electric charge
float p;                   ///< Total momentum in GeV/c
float theta,phi;           ///< Inital theta and phi angles in radians
float x,y,z;               ///< Vertex position in cm
identifier_t candidateid;  ///< id of DTrackCandidate this came from

Factory DTrack:LowResolution

Tracks with preliminary fit parameters.

This factory produces DTrack objects using information from DTrackCandiate, but without any additional fitting. This exists for cases where the preliminary fits done in DTrackCandidate are sufficient for a program to achieve its purpose. Examples would be the L3 trigger, or a high statistics monitoring program.

By having this factory produce objects of the same type as DTrack it will be trivial to switch a program back and forth between using low resolution and high resolution tracking.

This is (neccessarily) of the same form as the DTrack factory data above

Factory DTrackEfficiency

Tracking efficiency from truth info.

This factory has a 1-1 relationship with the DTrack (or DTrackHit:LowResolution factory). It uses truth information from the DMCTrackHit factory to determine which thrown track it is most closely related to (i.e. has the most hits from). It is used by DEventProcessor_TrackHists to help plot the overall tracking efficiency vs. the available kinematic variables.

/// Objects in this class correspond 1 to 1 with those in DThrown
int Nhits_thrown;            ///< Num hits in thrown (primary) track
int Nhits_found;             ///< Num hits in reconstructed (primary) track
int Nhits_thrown_and_found;  ///< Num hits in both thrown and found (primary) tracks
int Nhits_found_different;   ///< Nfound - Nhits_thrown_and_found
int Nhits_thrown_unused;     ///< Nthrown - Nhits_thrown_and_found
int fittable;                ///< non-zero if at least 10 primary hits
identifier_t trackid;        ///< id of DTrack (if any)