TTrackerReconModule.hxx

Go to the documentation of this file.

/// /// For questions or suggestions about this module please contact the
/// current responsible and CC in the eventAnalysis package manager.
///
/// 21-Jul-2010: Current responsible for this module is,
/// Blair Jamieson (jamieson [*a*t*] physics.ubc.ca)
///
#ifndef TTrackerReconModule_hxx_seen
#define TTrackerReconModule_hxx_seen

#include <string>

#include <TClonesArray.h>
#include <TLorentzVector.h>
#include <TNamed.h>
#include <TTree.h>

#include <TND280Event.hxx>

#include <TG4PrimaryVertex.hxx>
#include <TG4Trajectory.hxx>
#include <TReconPID.hxx>
#include <TReconVertex.hxx>

#include "TAnalysisReconModuleBase.hxx"
#include "TTrueVertex.hxx"

namespace ND {
class TTrackerReconModule;
};

/// This module summarizes the reconstruction information from the trackerRecon.
class ND::TTrackerReconModule : public TAnalysisReconModuleBase {
 public:
  /// An object to describe a reconstructed track.

  /// An object to store unused hits
  /// That is, hits that were not associated with any track
  class TUnusedHit : public TObject {
   public:
    virtual ~TUnusedHit();

    double TotalCharge;  ///< Deposited charge (the hit EDeposit)

    TVector3 Position;  ///< The position of the hit component 0=x 1=y 2=z in mm

    TVector3 Variance;  ///< The position variance in mm

    double Time;  ///< Time of the hit in ns

    double TimeUnc;  ///< Time Uncertainty of hit in ns

    ClassDef(TTrackerReconModule::TUnusedHit, 1);
  };

  /// An object to describe a reconstructed vertex
  class TTrackerVertex : public TObject {
   public:
    virtual ~TTrackerVertex();

    std::string
        AlgorithmName;  ///< The name of the algorithm that created this object.

    int Status;  ///< The status for the fit.

    double Quality;  ///< The quality of the fit. Ie. the Prob(chi2,ndof)

    int NDOF;  ///< The number of degrees of freedom.

    /// The position of the vertex
    /// components [0]=x [1]=y [2]=z [3]=t
    /// x,y,z are in mm, t is in ns
    TLorentzVector Position;  //! The position of the vertex

    /// The position variance;
    /// components [0]=var(x) [1]=var(y) [2]=var(z) [3]=var(t)
    /// x,y,z are in mm^2, t is in ns^2
    TLorentzVector Variance;  //! The position variance;

    ClassDef(TTrackerReconModule::TTrackerVertex, 1);
  };

  /// TPC pid and track variables
  class TTPCTrack : public TObject {
   public:
    virtual ~TTPCTrack();
    UInt_t UniqueID;  ///< Unique ID number to allow matching to Global Reconobject.
    int Detector;     ///< TPC number 1, 2 or 3
    int Ndof;         ///< Number of degrees of freedom in TPC fit
    double Chi2;      ///< TPC chi2 calculated after likelihood fit
    int NHits;        ///< number of clusters used in TPC fit

    double Momentum;       ///< Momentum of the TPC pid in MeV/c
    double MomentumError;  ///< Uncertainty in the Momentum in MeV/c from theTPC pid
    double Charge;         ///< Charge from the TPC pid (+1, or -1)
    TLorentzVector
        Position;  ///< Position at which kinematics are reported in mm, ns
    TLorentzVector PositionVariance;  ///< Variance in Position  in mm^2, ns^2

    TVector3 Direction;  ///< TPC pid direction vector in mm
    TVector3
        DirectionVariance;  ///< TPC pid variance in vector direction in mm^2

    double NTrun;          ///< 70% of the number of clusters
    double Ccorr;          ///< Corrected truncated mean charge deposit in PID
    double PullEle;        ///< Pull for TPC pid electron hypothesis
    double PullMuon;       ///< Pull for TPC pid muon hypothesis
    double PullPion;       ///< Pull for TPC pid pion hypothesis
    double PullKaon;       ///< Pull for TPC pid kaon hypothesis
    double PullProton;     ///< Pull for TPC pid proton hypothesis
    double dEdxexpEle;     ///< Estimated dE/dx for electron hypothesis
    double dEdxexpMuon;    ///< Estimated dE/dx for muon hypothesis
    double dEdxexpPion;    ///< Estimated dE/dx for pion hypothesis
    double dEdxexpKaon;    ///< Estimated dE/dx for kaon hypothesis
    double dEdxexpProton;  ///< Estimated dE/dx for proton hypothesis
    double SigmaEle;   ///< Sigma estimated width of TPC pid electron hypothesis
    double SigmaMuon;  ///< Sigma estimated width of TPC pid muon hypothesis
    double SigmaPion;  ///< Sigma estimated width of TPC pid pion hypothesis
    double SigmaKaon;  ///< Sigma estimated width of TPC pid kaon hypothesis
    double SigmaProton;  ///< Sigma estimated width of TPC pid proton hypothesis

    // Other fit parameters (diffusion related)
    /// TPC track diffusion parameters depend on diffusion model used
    /// Original TPC diffusion model was:
    ///    sigma^2 = sigma0 + sigma1*drift + sigma*drift^2
    /// Updated TPC diffusion model is:
    ///    sigma^2 = sigma0*(drift-mean_drift) + sigma1*mean_drift +
    ///    sigma2*drift^2
    ///    units are mm, to convert to microns/sqrt(cm) take for example:
    ///    D = sqrt( sigma/10 )*10000
    double Sigma0;     ///< TPC track diffusion sigma0 parameter
    double Sigma1;     ///< TPC track diffusion sigma1 parameter
    double Sigma2;     ///< TPC track diffusion sigma2 parameter
    double MeanDrift;  ///< TPC track mean drift value used in diffusion model

    /// Number of constituents (probably 1, for track!)
    int NConstituents;

    // dig for original track and store curvature information
    // -- somewhat redundant with pid information, but here for checking --
    TVector3 TrDirection;     ///< track direction vector
    TVector3 TrDirectionVar;  ///< variance in track direction vector
    double TrCurvature;       ///< track curvature, units are 1/mm
    double TrCurvatureVar;    ///< variance in track direction vector, units are(1mm)^2

    // Associated FGD information using Claudio's 2010a method of hit
    // association
    bool HasExtrapolation;  ///< extrapolation method of vertex is calculated ornot
    double
        ExtrapolatedVertexXX;  ///< for xbar vertex, this is x coordinate in mm
    double
        ExtrapolatedVertexZX;  ///< for xbar vertex, this is z coordinate in mm
    double
        ExtrapolatedVertexYY;  ///< for ybar vertex, this is y coordinate in mm
    double
        ExtrapolatedVertexZY;  ///< for ybar vertex, this is z coordinate in mm
    bool EnteringFGD;          ///< not sure
    // std::vector<TVector3*> ExtrapolatedHits;

    ClassDef(TTrackerReconModule::TTPCTrack, 1);
  };

  /// An object to hold specific FGD track variables
  class TFGDTrack : public TObject {
   public:
    virtual ~TFGDTrack();
    UInt_t UniqueID;  ///< Unique ID number to allow matching to Global Reconobject.
    int Detector;     ///< FGD number 1 or 2
    int Ndof;         ///< Number of degrees of freedom in FGD track fit
    double Chi2;      ///< Chi2 of the FGD track fit the FGD track starting position vector coordinates in order x,y,z,t where x,y,z are in mm, t is in ns
    TLorentzVector Position;
    /// the FGD track direction vector (dx,dy,dz)
    TVector3 Direction;
    /// the FGD track energy deposit (total number of pe's)
    double EDeposit;

    ClassDef(TTrackerReconModule::TFGDTrack, 1);
  };

  /// An object to describe the true G4 particle associated to the
  /// TTrackerResult
  class TTrueParticle : public TObject {
   public:
    virtual ~TTrueParticle();
    int ID;                  ///< Trajectoy  Id
    double Pur;              ///< The purity for matching
    double Eff;              ///< The efficiency for matching
    ND::TTrueVertex Vertex;  ///< True vertex associated to this TrueParticle

    ClassDef(TTrackerReconModule::TTrueParticle, 1);
  };

  /// An object to describe a track that has
  /// no fit result
  class TTrackOther : public TObject {
   public:
    TTrackOther();
    virtual ~TTrackOther();
    std::string
        AlgorithmName;  ///< The name of the algorithm that created this object.

    int Detector;  ///< Detector used (1,2,3 for TPC, or 4,5 for FGD?)

    int NHits;  ///< The number of hits.

    TClonesArray *Hits;  ///< The hits

    double EDeposit;  ///< The deposited charge for the object.

    TLorentzVector FrontPosition;  ///< The position of the track at itsupstream-most end (x,y,z,t) in mm, ns

    TLorentzVector BackPosition;  ///< The position of the track at itsdownstream-most end     (x,y,z,t) in mm,ns

    // JIMHACK - Just for now include an instance of TUnusedHit object here as
    // TFile::MakeProject does not seem able to find them when they are hidden
    // inside a
    // TClonesArray. Nothing is done with these - it is just an ugly workaround.
    TUnusedHit hackHits;  ///<This is just here to fool TFile::MakeProject, nota real object.
    ClassDef(TTrackerReconModule::TTrackOther, 1);
  };

  /// An object to describe a constituent of a
  /// trackerRecon result.  These are combinations
  /// of FGD and TPC pid results.
  class TTrackerConstituent : public TObject {
   public:
    TTrackerConstituent();
    virtual ~TTrackerConstituent();
    std::string AlgorithmName;  ///< algorithm that created this object.
    int Detectors;              ///< Detectors used
    unsigned long Status;       ///< The status for the fit.
    double Quality;             ///< The quality of the fit.(probability)
    int NDOF;                   ///< The number of degrees of freedom.
    double Chi2;                ///< The chi2 of the fit.
    int NNodes;                 ///< The number of nodes
    int NHits;                  ///< The number of hits.
    Int_t NConstituents;  ///< The number of constituents this constituent ismade of
    Int_t ConstitIdx[2];  ///< Index into Constituents inTTrackerResult::Constituents of this constituent'sconstituents
    bool isForward;       ///< Sense of track
    double Charge;        ///< The Charge of this constituent (+-1)
    double EDeposit;      ///< The deposited charge for the constituent object(number of pe's).
    TLorentzVector FrontPosition;  ///< The 4-vector position at the front ofthe track (x,y,z,t) in mm, ns
    TLorentzVector BackPosition;   ///< The 4-vector position of the back of thetrack (x,y,z,t) in mm, ns
    TLorentzVector FrontVariance;  ///< The 4-vector position variance at thefront of the track(var(x),var(y),var(z),var(t)) in mm^2,ns^2
    TLorentzVector BackVariance;   ///< The 4-vector position variance at theback of the track(var(x),var(y),var(z),var(t)) in mm^2, ns^2
    TVector3
        FrontDirection;      ///< The direction vector at the front of the track
    TVector3 BackDirection;  ///< The direction vector at the back of the track
    double FrontMomentum;  ///< the momentum at the front of the track in MeV/c
    double BackMomentum;   ///< the momentum at the back of the track iin MeV/c
    TLorentzVector Position;     ///< position 4-vector (x,y,z,t) in mm, ns
    TLorentzVector Variance;     ///< position variance 4-vector(var(x),var(y),var(z),var(t)) in mm^2, ns^2
    TVector3 Direction;          ///< direction vector
    TVector3 DirectionVariance;  ///< direction variance vector
    double Momentum;             ///< momentum MeV/c
    double MomentumError;        ///< uncertainty in momentum MeV/c
    ClassDef(TTrackerReconModule::TTrackerConstituent, 1);
  };

  /// Object to describe the fit parameters at a track node
  class TTrackerNode : public TObject {
   public:
    virtual ~TTrackerNode();
    double Charge;            ///< The Charge (+-1)
    double EDeposit;          ///< The Energy Deposit (number of pe's)
    TLorentzVector Position;  ///< Position 4-vector (at node) x,y,z,t in mm, ns
    TLorentzVector Variance;  ///< Position variance 4-vector (at node)var(x),var(y),var(z),var(t) in mm^2, ns^2
    TVector3 Direction;       ///< Direction vector (at node)
    TVector3 DirectionVariance;  ///< Direction variance vector (at node)
    double Momentum;             ///< Track Momentum (at node) in MeV/c
    double MomentumError;  ///< Track Momentum uncertainty (at node) in MeV/c
    ClassDef(TTrackerReconModule::TTrackerNode, 1);
  };

  /// An object to describe a reconstructed trackerRecon result.
  class TTrackerResult : public TObject {
   public:
    TTrackerResult();
    virtual ~TTrackerResult();
    UInt_t UniqueID;  ///< Unique ID number to allow matching to Global Reconobject.
    std::string
        AlgorithmName;  ///< The name of the algorithm that created this object.
    int Detectors;      ///< Detectors used
    unsigned long Status;  ///< The status for the fit.
    double Quality;        ///< The quality of the fit.(probability(chi2,ndof))
    int NDOF;              ///< The number of degrees of freedom.
    double Chi2;           ///< The chi2 of the fit.
    int NHits;             ///< The number of hits.
    Int_t NConstituents;  ///< The number of constituents (tracks and pids) usedto build this track
    Int_t ConstitIdx[2];  ///< Index into Constituents of the constituents usedto build this track
    Int_t NTotalConstituents;  ///< Number of all constituents, andconstituents-constituents...
    TClonesArray
        *Constituents;  ///< All constituents, and constituents-constituents...
    bool isForward;     ///< Sense of object.
    double Charge;      ///< The Charge (+-1)
    double EDeposit;  ///< The deposited charge for the object (number of pe's)
    double Length;    ///< The total length of the object in mm
    int matchingFailure_flag;  ///< Flag a object where the TPC-FGD matchingfailed

    /// the PID likelihoods for combined PID
    /// for now this is the product of the three TPC PID probabilities
    /// The first entry is the most likely hypothesis, followed by alternate
    /// hypotheses
    /// The Pid for the given likelihood is in the same index into the vectors.
    /// Value of the Pid is based on the one from TReconPID, ie:
    ///       notset=0, other=1, shower=2, em=3, electron=4, gamma=5,
    ///       hadronic=6, pi0=7, light-track=8, muon=9, pion=10,
    ///       heavy-track=11, proton=12, kaon=13
    std::vector<double> Likelihoods;
    std::vector<int> Pids;    ///< the PID that goes with Likelihoods
    TLorentzVector Position;  ///< track position 4-vector (x,y,z,t) in mm, ns
    TLorentzVector Variance;  ///< track position variance 4-vectorvar(x),var(y),var(z),var(t) in mm^2, ns^2
    TVector3 Direction;       ///< track direction vector
    TVector3 DirectionVariance;  ///< track direction variance
    double Momentum;             ///< track momentum MeV/c
    double MomentumError;        ///< track momentum MeV/c
    TTrueParticle TrueParticle;  ///< information about the true particleassociated with this track
    Int_t NTPCs;        ///< Number of TPC tracks used to build this track
    TClonesArray *TPC;  ///< Information about the TPC pids/tracks used to buildthis track
    Int_t NFGDs;        ///< Number of FGD Specific objects
    TClonesArray *FGD;  ///< FGD objects associated with track
    int NNodes;         ///< The number of nodes (fgd hits + tpc tracks)
    TClonesArray
        *Nodes;  ///< Kinematics of the track at each node in the track fit

    // JIMHACK - Just for now include an instance of TPC, FGD, Constituents
    // object here as
    // TFile::MakeProject does not seem able to find them when they are hidden
    // inside a
    // TClonesArray. Nothing is done with these - it is just an ugly workaround.
    TTrackerConstituent hackConstituentsObject;  ///<This is just here to foolTFile::MakeProject, not areal object.
    TTPCTrack hackTPCTrack;  ///<This is just here to fool TFile::MakeProject,not a real object.
    TFGDTrack hackFGDTrack;  ///<This is just here to fool TFile::MakeProject,not a real object.
    TTrackerNode hackNodes;  ///<This is just here to fool TFile::MakeProject,not a real object.

    ClassDef(TTrackerReconModule::TTrackerResult, 1);
  };

 public:
  /// Constructor
  TTrackerReconModule(const char *name = "Tracker",
                      const char *title = "Tracker Recon Module");

  /// Destructor
  virtual ~TTrackerReconModule();

  /// Method for special handling of first event
  virtual Bool_t ProcessFirstEvent(ND::TND280Event &event);

 protected:
  /// Method to initialize this module
  virtual void InitializeModule();

  /// Method to find the total  number of hits used to build the
  /// reconstructed track/pid/etc.
  int GetNumberOfHits(ND::THandle<ND::TReconBase> object);

  /// Initialize the branches in the trackerRecon eventAnalysis tree
  virtual void InitializeBranches();

  void FillConfigTree(TTree* configTree);

  /// Main call to fill all of the branches of the trackerRecon
  /// eventAnalysis tree for a given event
  virtual bool FillTree(ND::TND280Event &);

  /// Method to fill trackerRecon tree with vertex information
  /// Input is a TReconVertex.  The method makes a new TTrackerVertex
  /// tree entry and fills its values.  The method is passed a pointer
  /// to the TClonesArray of TReconVertex to add values to at index idx.
  void FillVertex(ND::THandle<ND::TReconVertex> in, TClonesArray *out, int idx);

  /// Method to fill trackerRecon tree with TPC information
  /// Input is a TReconPID of TPC fit information.  The method makes a new
  /// TTPCTrack
  /// tree entry and fills its values.  The method is passed a pointer
  /// to the TClonesArray of TTPCTrack to add values to at index idx.
  /// It is done this way so the same method can be called, but passing
  /// different
  /// pointer to TClonesArray of TTPCTrack for both the TTrackerResult::TPC and
  /// the fTPCIso isolated tpc tracks.
  void FillTPC(ND::THandle<ND::TReconPID> in, TClonesArray *out, int idx);

  /// Method to make a TPC object with extrapolated hit association information.
  bool ExtrapolateTPC(ND::THandle<ND::TReconPID> in, TClonesArray *out, int idx,
                      ND::THandle<ND::THitSelection> fgd);

  /// Method to fill trackerRecon tree with FGD information
  /// Input is a TReconPID of FGD fit information.  The method makes a new
  /// TFGDTrack
  /// tree entry and fills its values.  The method is passed a pointer
  /// to the TClonesArray of TFGDTrack to add values to at index idx.
  /// It is done this way so the same method can be called, but passing
  /// different
  /// pointer to TClonesArray of TFGDTrack for both the TTrackerResult::FGD and
  /// the fFGDIso isolated fgd tracks.
  void FillFGD(ND::THandle<ND::TReconTrack> in, TClonesArray *out, int idx);

  /// Method to fill trackerRecon tree with unfit track information
  /// Input is a TReconTrack that was not fit.  The method makes a new
  /// TTrackOther
  /// tree entry and fills its values.  The method is passed a pointer
  /// to the TClonesArray of TTrackOther to add values to at index idx.
  /// It is done this way so the same method can be called, but passing
  /// different
  /// pointer to TClonesArray of TTrackOther for both the fFGDOther and
  /// the fTPCOther tracks without fits.
  void FillOther(ND::THandle<ND::TReconTrack> in, TClonesArray *out, int idx);

  /// Method to get the tpc combo hits from the tpc hit selection (used for tpc
  /// other)
  ND::THandle<ND::THitSelection> GetHitsFromComboHits(
      ND::THandle<ND::THitSelection> tpc);

  /// Method to fill information about constituent pids.  That is the pid
  /// pieces used to build the final pid.  Note that only the multiple detector
  /// constituents are filled here, while the FGD and TPC only tracks are filled
  /// by calling FillTPC and FillFGD.  This method is recursively called to fill
  /// all constituents, constituents of constituents, and so on.
  /// If new constituent is created it returns true, otherwise returns false,
  /// and
  /// returns the index into TTrackResult::Constituents if a new constituent was
  /// added to the tree.
  bool FillConstituentPid(TTrackerResult *result, ND::THandle<ND::TReconPID> in,
                          int &idx);

  /// Method to fill information about constituent tracks.  That is the track
  /// pieces used to build the final track.  Note that only the multiple
  /// detector
  /// constituents are filled here, while the FGD and TPC only tracks are filled
  /// by calling FillTPC and FillFGD.  This method is recursively called to fill
  /// all constituents, constituents of constituents, and so on.
  /// If new constituent is created it returns true, otherwise returns false,
  /// and
  /// returns the index into TTrackResult::Constituents if a new constituent was
  /// added to the tree.
  bool FillConstituentTrack(TTrackerResult *result,
                            ND::THandle<ND::TReconTrack> in, int &idx);

  /// Helper method to convert TTrackState curvature information into momentum
  /// and momentum uncertainty
  void GetMomentum(ND::THandle<ND::TTrackState> state, double &p, double &ep);

  /// Helper method to convert TTrackState curvature information into track
  /// charge
  double GetCharge(ND::THandle<ND::TTrackState> state);

  /// Method to fill a trackerRecon result entry
  void FillFinalPid(TTrackerResult *result, ND::THandle<ND::TReconPID> reco);

  /// Method to fill a trackerRecon result entry
  void FillFinalTrack(TTrackerResult *result,
                      ND::THandle<ND::TReconTrack> reco);

  /// Method to build an integer key that describes the detectors used
  /// to build the TRecon object.  Each base 10 digit of the integer
  /// represents one detector that was used.  the numbering of the
  /// detectors is: 1=TPC1, 2=TPC2, 3=TPC3, 4=FGD1, 5=FGD2, 6=DSECAL,
  /// 7=BarrelECAL, 8=P0D, 9=SMRD
  int GetDetectorNumber(ND::THandle<ND::TReconBase> object);

  /// Method to get the G4 trajectory that best matches the TRecon object
  ND::TG4Trajectory GetTrajectory(ND::TND280Event &event,
                                  ND::THandle<ND::TReconBase> reco);

  /// Method to measure the purity of a reconstructed track against the truth
  std::map<int, double> TrkRecModGetG4TrajectoryFractions(
      const ND::THandle<ND::TReconBase> track);

  /// Method to fill the true particle information given a G4track
  void FillTrueParticle(ND::TG4Trajectory *G4track, double pur, double eff,
                        ND::TTrackerReconModule::TTrueParticle &trueParticle);

  /// Method to get the parent G4 track for a given G4 track
  ND::THandle<ND::TG4Trajectory> GetParent(ND::TG4Trajectory *G4track);
  ND::THandle<ND::TG4Trajectory> GetParent(
      ND::THandle<ND::TG4Trajectory> G4track);

  /// Method to fill the true vertex information from a given G4 vertex
  void FillTrueVertex(bool found, const ND::TG4PrimaryVertex &G4vertex,
                      double pur, double eff, ND::TTrueVertex &vertex);

  /// Method to find the best matching G4 vertex for a given G4 track
  bool GetG4Vertex(ND::TG4Trajectory *G4track, ND::TG4PrimaryVertex &G4vertex);

  /// Method to find the incident particle (neutrino) that gave rise to a given
  /// G4 track
  bool GetIncomingParticle(const ND::TG4PrimaryVertex &G4vertex,
                           ND::TG4PrimaryParticle &incoming);

  /// called recursively to look for bottom level track that built a PID.  In
  /// case
  /// the PID is made of several PIDs, the one with the track with smallest
  /// relative curvature
  /// error is returned.
  ND::THandle<ND::TReconTrack> GetConstituentTrack(
      ND::THandle<ND::TReconPID> in, int &nconstit);

  /// Method to find FGD constituent track from a matching object and fill
  /// matchingFailure_flag
  void CheckMatchingFailure(TTrackerResult *result,
                            ND::THandle<ND::TReconBase> reco);

 public:
  /// Tree Entries
  Int_t fNVertices;  ///< The number of added vertices
  TClonesArray
      *fVertices;  ///< The vector of trackerRecon vertices (none ever?).

  Int_t fNTracks;         ///< The number of trackerRecon results
  TClonesArray *fTracks;  ///< The vector of overall trackerRecon results

  Int_t fNFGDOther;  ///< The number of FGD tracks with no fit (none ever?).
  TClonesArray *fFGDOther;  ///< The vector of FGD tracks with no fit

  Int_t fNTPCOther;         ///< The number of TPC tracks with no fit
  TClonesArray *fTPCOther;  ///< The vector of TPC tracks with no fit

  // The code producing the TPC iso objects is commented out in trackerRecon
  // v0r9
  Int_t fNTPCIso;  ///< The number of isolated TPC tracks with fits (none ever?)
  TClonesArray *fTPCIso;  ///< The vector of isolated TPC tracks with fits

  Int_t fNTPCUnused;         ///< The number of unused TPC hits
  TClonesArray *fTPCUnused;  ///< The vector of unused TPC hits

  Int_t fNFGDUnused;         ///< The number of unused FGD hits
  TClonesArray *fFGDUnused;  ///< The vector of unused TPC hits

  Int_t fNTPCExtrapolation;  ///< The number of TPC tracks extrapolated into theFGD following Claudio's (2010a) method
  TClonesArray *fTPCExtrapolation;  ///< The vector of TPC tracks extrapolatedinto the FGD following Claudio's (2010a)method

 private:
  double fMaxDrift;       ///< TPC maximum drift used for tpc other hits
  double fCathodeOffset;  ///< TPC cathode offset used for tpc other hits
  double fDriftVelocity;  ///< TPC drift velocity used for tpc other hits

};
#endif