ViewVC Help
View File | Revision Log | Show Annotations | Root Listing
root/cvsroot/UserCode/MitAna/DataTree/interface/Track.h
(Generate patch)

Comparing UserCode/MitAna/DataTree/interface/Track.h (file contents):
Revision 1.16 by loizides, Fri Aug 29 01:51:01 2008 UTC vs.
Revision 1.20 by bendavid, Tue Sep 30 12:49:36 2008 UTC

# Line 12 | Line 12
12   // phi = azimuth angle at the given point
13   // dxy = -vx*sin(phi) + vy*cos(phi) [cm]
14   // dsz = vz*cos(lambda) - (vx*cos(phi)+vy*sin(phi))*sin(lambda) [cm]
15 + // (See http://cmslxr.fnal.gov/lxr/source/DataFormats/TrackReco/interface/TrackBase.h)
16   //
17   // Format for fHits: (We do not use anything resembling reco::HitPattern from CMSSW because that
18   // data format requires 800 bits per track!)
# Line 66 | Line 67
67   // Authors: C.Loizides, J.Bendavid, C.Paus
68   //--------------------------------------------------------------------------------------------------
69  
70 < #ifndef DATATREE_TRACK_H
71 < #define DATATREE_TRACK_H
70 > #ifndef MITANA_DATATREE_TRACK_H
71 > #define MITANA_DATATREE_TRACK_H
72  
73   #include "MitAna/DataTree/interface/DataObject.h"
74   #include "MitAna/DataTree/interface/MCParticle.h"
75 < #include "MitAna/DataTree/interface/BitMask32.h"
75 < #include "MitAna/DataTree/interface/BitMask64.h"
75 > #include "MitAna/DataTree/interface/BitMask.h"
76   #include "MitAna/DataTree/interface/Types.h"
77  
78   namespace mithep
# Line 80 | Line 80 | namespace mithep
80    class Track : public DataObject
81    {
82      public:
83 <      enum HitLayer { PXB1,
84 <                      PXB2,
85 <                      PXB3,
86 <                      PXF1,
87 <                      PXF2,
88 <                      TIB1,
89 <                      TIB1S,
90 <                      TIB2,
91 <                      TIB2S,
92 <                      TIB3,
93 <                      TIB4,
94 <                      TID1,
95 <                      TID1S,
96 <                      TID2,
97 <                      TID2S,
98 <                      TID3,
99 <                      TOB1,
100 <                      TOB1S,
101 <                      TOB2,
102 <                      TOB2S,
103 <                      TOB3,
104 <                      TOB4,
105 <                      TOB5,
106 <                      TOB6,
107 <                      TEC1,
108 <                      TEC1S,
109 <                      TEC2,
110 <                      TEC2S,
111 <                      TEC3,
112 <                      TEC4,
113 <                      TEC5,
114 <                      TEC5S,
115 <                      TEC6,
116 <                      TEC7,
117 <                      TEC8,
118 <                      TEC9 };
119 <    
83 >      enum EHitLayer {
84 >        PXB1,
85 >        PXB2,
86 >        PXB3,
87 >        PXF1,
88 >        PXF2,
89 >        TIB1,
90 >        TIB1S,
91 >        TIB2,
92 >        TIB2S,
93 >        TIB3,
94 >        TIB4,
95 >        TID1,
96 >        TID1S,
97 >        TID2,
98 >        TID2S,
99 >        TID3,
100 >        TOB1,
101 >        TOB1S,
102 >        TOB2,
103 >        TOB2S,
104 >        TOB3,
105 >        TOB4,
106 >        TOB5,
107 >        TOB6,
108 >        TEC1,
109 >        TEC1S,
110 >        TEC2,
111 >        TEC2S,
112 >        TEC3,
113 >        TEC4,
114 >        TEC5,
115 >        TEC5S,
116 >        TEC6,
117 >        TEC7,
118 >        TEC8,
119 >        TEC9
120 >      };
121 >
122        Track() : fQOverP(0), fQOverPErr(0), fLambda(0), fLambdaErr(0),
123                  fPhi0(0), fPhi0Err(0), fDxy(0), fDxyErr(0), fDsz(0), fDszErr(0),
124                  fChi2(0), fNdof(0) {}
# Line 126 | Line 128 | namespace mithep
128                  fChi2(0), fNdof(0) {}
129        ~Track() {}
130  
131 <      Double_t           QOverP()       const { return fQOverP; }
132 <      Double_t           QOverPErr()    const { return fQOverPErr; }
133 <      Double_t           Lambda()       const { return fLambda; }
134 <      Double_t           LambdaErr()    const { return fLambdaErr; }
135 <      Double_t           Phi0()         const { return fPhi0; }
136 <      Double_t           Phi0Err()      const { return fPhi0Err; }
137 <      Double_t           Dxy()          const { return fDxy; }
138 <      Double_t           DxyErr()       const { return fDxyErr; }
139 <      Double_t           Dsz()          const { return fDsz; }
140 <      Double_t           DszErr()       const { return fDszErr; }
139 <      
140 <
141 <
142 <      Int_t              Charge()       const { return (fQOverP>0) ? 1 : -1; }
143 <      Double_t           Chi2()         const { return fChi2; }
144 <      void               ClearHit(HitLayer l) { fHits.ClearBit(l); }
145 <      Double_t           D0()           const { return -fDxy; }
146 <      Double_t           D0Err()        const { return fDxyErr; }
147 <      Bool_t             Hit(HitLayer l) const { return fHits.TestBit(l); }
148 <      BitMask64         &Hits()               { return fHits; }
149 <      const BitMask64   &Hits()         const { return fHits; }
150 <      ULong64_t          HitMask()      const { return fHits.Bits(); }
151 <      ThreeVector        Mom()          const { return ThreeVector(Px(),Py(),Pz()); }
152 <      UInt_t             Ndof()         const { return fNdof; }
153 <      Double_t           P2()           const { return P()*P(); }
154 <      Double_t           P()            const { return TMath::Abs(1./fQOverP); }
155 <      Double_t           Px()           const { return Pt()*TMath::Cos(fPhi0); }      
156 <      Double_t           Py()           const { return Pt()*TMath::Sin(fPhi0); }
157 <      Double_t           Pz()           const { return P()*TMath::Sin(fLambda); }
158 <      Double_t           Phi()          const { return fPhi0; }
159 <      Double_t           Pt()           const { return TMath::Abs(TMath::Cos(fLambda)/fQOverP); }
160 <      //Double_t           PtErr()        const { return fPtErr; }
161 <      void               SetChi2(Double_t chi2) { fChi2 = chi2; }
162 <      void               SetHit(HitLayer l)     { fHits.SetBit(l); }
163 <      void               SetHits(BitMask64 hits)  { fHits = hits; }
164 <      void               SetHits(ULong64_t hitMask)  { fHits.SetBits(hitMask); }
165 <      void               SetNdof(UInt_t dof)      { fNdof = dof; }
166 <      void               SetStat(BitMask32 stat)  { fStat = stat; }
167 <      void               SetStat(UInt_t statBits) { fStat.SetBits(statBits); }
168 <      BitMask32         &Stat()               { return fStat; }
169 <      const BitMask32   &Stat()         const { return fStat; }
170 <      UInt_t             StatBits()     const { return fStat.Bits(); }
171 <      Double_t           Theta()        const { return (TMath::PiOver2() - fLambda); }
172 <      Double_t           Z0()           const { return fDsz/TMath::Cos(fLambda); }
173 <      //Double_t           Z0Err()        const { return fZ0Err; }
174 <      
175 <      FourVector         Mom4(Double_t m) const { return FourVector(Px(),Py(),Pz(),E(m)); }
176 <      Double_t           E2(Double_t m)   const { return P2()+m*m; }
131 >      Int_t              Charge()         const { return (fQOverP>0) ? 1 : -1; }
132 >      Double_t           Chi2()           const { return fChi2; }
133 >      Double_t           RChi2()          const { return fChi2/(Double_t)fNdof; }
134 >      void               ClearHit(EHitLayer l)  { fHits.ClearBit(l); }
135 >      Double_t           D0()             const { return -fDxy; }
136 >      Double_t           D0Err()          const { return fDxyErr; }
137 >      Double_t           Dsz()            const { return fDsz; }
138 >      Double_t           DszErr()         const { return fDszErr; }
139 >      Double_t           Dxy()            const { return fDxy; }
140 >      Double_t           DxyErr()         const { return fDxyErr; }
141        Double_t           E(Double_t m)    const { return TMath::Sqrt(E2(m)); }
142 +      Double_t           E2(Double_t m)   const { return P2()+m*m; }
143 +      Bool_t             Hit(EHitLayer l) const { return fHits.TestBit(l); }
144 +      Double_t           Lambda()         const { return fLambda; }
145 +      Double_t           LambdaErr()      const { return fLambdaErr; }
146 +      const MCParticle  *MCPart()         const;
147 +      ThreeVector        Mom()            const { return ThreeVector(Px(),Py(),Pz()); }
148 +      FourVector         Mom4(Double_t m) const { return FourVector(Px(),Py(),Pz(),E(m)); }
149 +      UInt_t             Ndof()           const { return fNdof; }
150        UInt_t             NHits()          const { return fHits.NBitsSet(); }
151 <
152 <      void               SetHelix (Double_t qOverP, Double_t lambda, Double_t phi0,
153 <                                   Double_t dXy, Double_t dSz);
151 >      Double_t           P2()             const { return P()*P(); }
152 >      Double_t           P()              const { return TMath::Abs(1./fQOverP); }
153 >      Double_t           Phi()            const { return fPhi0; }
154 >      Double_t           Phi0()           const { return fPhi0; }
155 >      Double_t           Phi0Err()        const { return fPhi0Err; }
156 >      Double_t           Prob()           const { return TMath::Prob(fChi2,fNdof); }
157 >      Double_t           Pt()             const { return TMath::Abs(TMath::Cos(fLambda)/fQOverP); }
158 >      Double_t           Px()             const { return Pt()*TMath::Cos(fPhi0); }      
159 >      Double_t           Py()             const { return Pt()*TMath::Sin(fPhi0); }
160 >      Double_t           Pz()             const { return P()*TMath::Sin(fLambda); }
161 >      Double_t           QOverP()         const { return fQOverP; }
162 >      Double_t           QOverPErr()      const { return fQOverPErr; }
163 >      Double_t           Theta()          const { return (TMath::PiOver2() - fLambda); }
164 >      Double_t           Z0()             const { return fDsz/TMath::Cos(fLambda); }
165 >      void               SetChi2(Double_t chi2) { fChi2 = chi2; }
166        void               SetErrors(Double_t qOverPErr, Double_t lambdaErr, Double_t phi0Err,
167                                     Double_t dXyErr, Double_t dSzErr);
168 <      
169 <      const MCParticle  *MCPart()      const;
168 >      void               SetHelix (Double_t qOverP, Double_t lambda, Double_t phi0,
169 >                                   Double_t dXy, Double_t dSz);
170 >      void               SetHit(EHitLayer l)      { fHits.SetBit(l); }
171 >      void               SetNdof(UInt_t dof)      { fNdof = dof; }
172        void               SetMCPart(MCParticle *p) { fMCParticleRef = p; }
173 <      
173 >
174      protected:
175 <          // Constant which is store in the file
176 <      BitMask64          fHits;                // Mostly Hit informations
177 <      BitMask32          fStat;                // Storage for various interesting things
178 <      Double_t           fQOverP, fQOverPErr;
179 <      Double_t           fLambda, fLambdaErr;
180 <      Double_t           fPhi0,fPhi0Err;       // Follow track parameters/uncertainties
181 <      Double_t           fDxy,  fDxyErr;
182 <      Double_t           fDsz,  fDszErr;
183 <      
184 <      Double_t           fChi2; //chi squared of track fit
185 <      UInt_t             fNdof; //number of dof of track fit
186 <      
187 <      TRef               fMCParticleRef; //reference to sim particle (for monte carlo)
175 >      BitMask64          fHits;                //storage for mostly hit information
176 >      Double_t           fQOverP;              //signed inverse of momentum [1/GeV]
177 >      Double_t           fQOverPErr;           //error of q/p
178 >      Double_t           fLambda;              //pi/2 - polar angle at the reference point
179 >      Double_t           fLambdaErr;           //error of lambda
180 >      Double_t           fPhi0;                //azimuth angle at the given point
181 >      Double_t           fPhi0Err;             //error of azimuthal angle
182 >      Double_t           fDxy;                 //transverse distance to reference point [cm]
183 >      Double_t           fDxyErr;              //error of transverse distance
184 >      Double_t           fDsz;                 //longitudinal distance to reference point [cm]
185 >      Double_t           fDszErr;              //error of longitudinal distance
186 >      Double_t           fChi2;                //chi squared of track fit
187 >      UInt_t             fNdof;                //degree-of-freedom of track fit
188 >      TRef               fMCParticleRef;       //reference to sim particle (for monte carlo)
189                
190      ClassDef(Track, 1) // Track class
191    };

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines