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.47 by bendavid, Mon Jan 18 14:35:10 2010 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!)
19   // There is a one to one mapping between bits and tracker layers, where layers are enumerated
20   // seperately in the PXB, PXF, TIB, TID, TOB, TEC and r-phi and stereo modules are treated as
21   // seperate layers in those detectors which have them
22 < // (TIB L1,L2, TID L1,L2, TOB L1,L2, TEC L1,L2,L5).
22 > // (TIB L1,L2, TID L1,L2,L3, TOB L1,L2, TEC L1,L2,L3,L4,L5,L6,L7,L8,L9).
23   //
24   // A bit value of 1 indicates a hit in the corresponding layer, and 0 indicates no hit.
25   //
# Line 42 | Line 43
43   // Bit 13: TID L2 r-phi
44   // Bit 14: TID L2 stereo
45   // Bit 15: TID L3 r-phi
46 < // Bit 16: TOB L1 r-phi
47 < // Bit 17: TOB L1 stereo
48 < // Bit 18: TOB L2 r-phi
49 < // Bit 19: TOB L2 stereo
50 < // Bit 20: TOB L3 r-phi
51 < // Bit 21: TOB L4 r-phi
52 < // Bit 22: TOB L5 r-phi
53 < // Bit 23: TOB L6 r-phi
54 < // Bit 24: TEC L1 r-phi
55 < // Bit 25: TEC L1 stereo
56 < // Bit 26: TEC L2 r-phi
57 < // Bit 27: TEC L2 stereo
58 < // Bit 28: TEC L3 r-phi
59 < // Bit 29: TEC L4 r-phi
60 < // Bit 30: TEC L5 r-phi
61 < // Bit 31: TEC L5 stereo
62 < // Bit 32: TEC L6 r-phi
63 < // Bit 33: TEC L7 r-phi
64 < // Bit 34: TEC L8 r-phi
65 < // Bit 35: TEC L9 r-phi
46 > // Bit 16: TID L3 stereo
47 > // Bit 17: TOB L1 r-phi
48 > // Bit 18: TOB L1 stereo
49 > // Bit 19: TOB L2 r-phi
50 > // Bit 20: TOB L2 stereo
51 > // Bit 21: TOB L3 r-phi
52 > // Bit 22: TOB L4 r-phi
53 > // Bit 23: TOB L5 r-phi
54 > // Bit 24: TOB L6 r-phi
55 > // Bit 25: TEC L1 r-phi
56 > // Bit 26: TEC L1 stereo
57 > // Bit 27: TEC L2 r-phi
58 > // Bit 28: TEC L2 stereo
59 > // Bit 29: TEC L3 r-phi
60 > // Bit 30: TEC L3 stereo
61 > // Bit 31: TEC L4 r-phi
62 > // Bit 32: TEC L4 stereo
63 > // Bit 33: TEC L5 r-phi
64 > // Bit 34: TEC L5 stereo
65 > // Bit 35: TEC L6 r-phi
66 > // Bit 36: TEC L6 stereo
67 > // Bit 37: TEC L7 r-phi
68 > // Bit 38: TEC L7 stereo
69 > // Bit 39: TEC L8 r-phi
70 > // Bit 40: TEC L8 stereo
71 > // Bit 41: TEC L9 r-phi
72 > // Bit 42: TEC L9 stereo
73   //
74   // Authors: C.Loizides, J.Bendavid, C.Paus
75   //--------------------------------------------------------------------------------------------------
76  
77 < #ifndef DATATREE_TRACK_H
78 < #define DATATREE_TRACK_H
77 > #ifndef MITANA_DATATREE_TRACK_H
78 > #define MITANA_DATATREE_TRACK_H
79  
80 + #include "MitAna/DataCont/interface/BitMask.h"
81 + #include "MitAna/DataTree/interface/TrackQuality.h"
82 + #include "MitAna/DataTree/interface/BaseVertex.h"
83   #include "MitAna/DataTree/interface/DataObject.h"
84   #include "MitAna/DataTree/interface/MCParticle.h"
85 < #include "MitAna/DataTree/interface/BitMask32.h"
75 < #include "MitAna/DataTree/interface/BitMask64.h"
76 < #include "MitAna/DataTree/interface/Types.h"
85 > #include "MitAna/DataTree/interface/SuperCluster.h"
86  
87   namespace mithep
88   {
89    class Track : public DataObject
90    {
91      public:
92 <      enum HitLayer { PXB1,
93 <                      PXB2,
94 <                      PXB3,
95 <                      PXF1,
96 <                      PXF2,
97 <                      TIB1,
98 <                      TIB1S,
99 <                      TIB2,
100 <                      TIB2S,
101 <                      TIB3,
102 <                      TIB4,
103 <                      TID1,
104 <                      TID1S,
105 <                      TID2,
106 <                      TID2S,
107 <                      TID3,
108 <                      TOB1,
109 <                      TOB1S,
110 <                      TOB2,
111 <                      TOB2S,
112 <                      TOB3,
113 <                      TOB4,
114 <                      TOB5,
115 <                      TOB6,
116 <                      TEC1,
117 <                      TEC1S,
118 <                      TEC2,
119 <                      TEC2S,
120 <                      TEC3,
121 <                      TEC4,
122 <                      TEC5,
123 <                      TEC5S,
124 <                      TEC6,
125 <                      TEC7,
126 <                      TEC8,
127 <                      TEC9 };
128 <    
129 <      Track() : fQOverP(0), fQOverPErr(0), fLambda(0), fLambdaErr(0),
130 <                fPhi0(0), fPhi0Err(0), fDxy(0), fDxyErr(0), fDsz(0), fDszErr(0),
131 <                fChi2(0), fNdof(0) {}
92 >      enum EHitLayer {
93 >        PXB1,
94 >        PXB2,
95 >        PXB3,
96 >        PXF1,
97 >        PXF2,
98 >        TIB1,
99 >        TIB1S,
100 >        TIB2,
101 >        TIB2S,
102 >        TIB3,
103 >        TIB4,
104 >        TID1,
105 >        TID1S,
106 >        TID2,
107 >        TID2S,
108 >        TID3,
109 >        TID3S,
110 >        TOB1,
111 >        TOB1S,
112 >        TOB2,
113 >        TOB2S,
114 >        TOB3,
115 >        TOB4,
116 >        TOB5,
117 >        TOB6,
118 >        TEC1,
119 >        TEC1S,
120 >        TEC2,
121 >        TEC2S,
122 >        TEC3,
123 >        TEC3S,
124 >        TEC4,
125 >        TEC4S,
126 >        TEC5,
127 >        TEC5S,
128 >        TEC6,
129 >        TEC6S,
130 >        TEC7,
131 >        TEC7S,
132 >        TEC8,
133 >        TEC8S,
134 >        TEC9,
135 >        TEC9S
136 >      };
137 >
138 >      enum ETrackAlgorithm { //taken from DataFormats/TrackReco/interface/TrackBase.h
139 >        undefAlgorithm=0,
140 >        ctf=1,
141 >        rs=2,
142 >        cosmics=3,
143 >        iter0=4,
144 >        iter1=5,
145 >        iter2=6,
146 >        iter3=7,
147 >        iter4=8,
148 >        iter5=9,
149 >        iter6=10,
150 >        iter7=11,
151 >        iter8=12,
152 >        iter9=13,
153 >        iter10=14,
154 >        outInEcalSeededConv=15,
155 >        inOutEcalSeededConv=16,
156 >        nuclInter=17,
157 >        standAloneMuon=18,
158 >        globalMuon=19,
159 >        cosmicStandAloneMuon=20,
160 >        cosmicGlobalMuon=21,
161 >        iter1LargeD0=22,
162 >        iter2LargeD0=23,
163 >        iter3LargeD0=24,
164 >        iter4LargeD0=25,
165 >        iter5LargeD0=26,
166 >        bTagGhostTracks=27,
167 >        beamhalo=28,
168 >        algoSize=29
169 >      };
170 >
171 >
172 >      Track() : fAlgo(undefAlgorithm), fIsGsf(0), fQOverP(0), fQOverPErr(0),
173 >                fLambda(0), fLambdaErr(0), fPhi0(0), fPhi0Err(0),
174 >                fDxy(0), fDxyErr(0), fDsz(0), fDszErr(0), fChi2(0),
175 >                fNdof(0), fEtaEcal(0), fPhiEcal(0) {}
176        Track(Double_t qOverP, Double_t lambda, Double_t phi0, Double_t dxy, Double_t dsz) :
177 <                fQOverP(qOverP), fQOverPErr(0), fLambda(lambda), fLambdaErr(0),
178 <                fPhi0(phi0), fPhi0Err(0), fDxy(dxy), fDxyErr(0), fDsz(dsz), fDszErr(0),
179 <                fChi2(0), fNdof(0) {}
177 >                fAlgo(undefAlgorithm), fIsGsf(0), fQOverP(qOverP), fQOverPErr(0),
178 >                fLambda(lambda), fLambdaErr(0), fPhi0(phi0), fPhi0Err(0),
179 >                fDxy(dxy), fDxyErr(0), fDsz(dsz), fDszErr(0), fChi2(0),
180 >                fNdof(0), fEtaEcal(0), fPhiEcal(0) {}
181        ~Track() {}
182  
183 <      Double_t           QOverP()       const { return fQOverP; }
184 <      Double_t           QOverPErr()    const { return fQOverPErr; }
185 <      Double_t           Lambda()       const { return fLambda; }
186 <      Double_t           LambdaErr()    const { return fLambdaErr; }
187 <      Double_t           Phi0()         const { return fPhi0; }
188 <      Double_t           Phi0Err()      const { return fPhi0Err; }
189 <      Double_t           Dxy()          const { return fDxy; }
190 <      Double_t           DxyErr()       const { return fDxyErr; }
191 <      Double_t           Dsz()          const { return fDsz; }
192 <      Double_t           DszErr()       const { return fDszErr; }
193 <      
194 <
195 <
196 <      Int_t              Charge()       const { return (fQOverP>0) ? 1 : -1; }
197 <      Double_t           Chi2()         const { return fChi2; }
198 <      void               ClearHit(HitLayer l) { fHits.ClearBit(l); }
199 <      Double_t           D0()           const { return -fDxy; }
200 <      Double_t           D0Err()        const { return fDxyErr; }
201 <      Bool_t             Hit(HitLayer l) const { return fHits.TestBit(l); }
202 <      BitMask64         &Hits()               { return fHits; }
203 <      const BitMask64   &Hits()         const { return fHits; }
204 <      ULong64_t          HitMask()      const { return fHits.Bits(); }
205 <      ThreeVector        Mom()          const { return ThreeVector(Px(),Py(),Pz()); }
206 <      UInt_t             Ndof()         const { return fNdof; }
207 <      Double_t           P2()           const { return P()*P(); }
208 <      Double_t           P()            const { return TMath::Abs(1./fQOverP); }
209 <      Double_t           Px()           const { return Pt()*TMath::Cos(fPhi0); }      
210 <      Double_t           Py()           const { return Pt()*TMath::Sin(fPhi0); }
211 <      Double_t           Pz()           const { return P()*TMath::Sin(fLambda); }
212 <      Double_t           Phi()          const { return fPhi0; }
213 <      Double_t           Pt()           const { return TMath::Abs(TMath::Cos(fLambda)/fQOverP); }
214 <      //Double_t           PtErr()        const { return fPtErr; }
215 <      void               SetChi2(Double_t chi2) { fChi2 = chi2; }
216 <      void               SetHit(HitLayer l)     { fHits.SetBit(l); }
217 <      void               SetHits(BitMask64 hits)  { fHits = hits; }
218 <      void               SetHits(ULong64_t hitMask)  { fHits.SetBits(hitMask); }
219 <      void               SetNdof(UInt_t dof)      { fNdof = dof; }
220 <      void               SetStat(BitMask32 stat)  { fStat = stat; }
221 <      void               SetStat(UInt_t statBits) { fStat.SetBits(statBits); }
222 <      BitMask32         &Stat()               { return fStat; }
223 <      const BitMask32   &Stat()         const { return fStat; }
224 <      UInt_t             StatBits()     const { return fStat.Bits(); }
225 <      Double_t           Theta()        const { return (TMath::PiOver2() - fLambda); }
226 <      Double_t           Z0()           const { return fDsz/TMath::Cos(fLambda); }
227 <      //Double_t           Z0Err()        const { return fZ0Err; }
228 <      
229 <      FourVector         Mom4(Double_t m) const { return FourVector(Px(),Py(),Pz(),E(m)); }
230 <      Double_t           E2(Double_t m)   const { return P2()+m*m; }
231 <      Double_t           E(Double_t m)    const { return TMath::Sqrt(E2(m)); }
232 <      UInt_t             NHits()          const { return fHits.NBitsSet(); }
233 <
234 <      void               SetHelix (Double_t qOverP, Double_t lambda, Double_t phi0,
235 <                                   Double_t dXy, Double_t dSz);
236 <      void               SetErrors(Double_t qOverPErr, Double_t lambdaErr, Double_t phi0Err,
237 <                                   Double_t dXyErr, Double_t dSzErr);
238 <      
239 <      const MCParticle  *MCPart()      const;
240 <      void               SetMCPart(MCParticle *p) { fMCParticleRef = p; }
241 <      
183 >      ETrackAlgorithm      Algo()           const { return fAlgo;                 }
184 >      Int_t                Charge()         const { return (fQOverP>0) ? 1 : -1;  }
185 >      Double_t             Chi2()           const { return fChi2;                 }
186 >      void                 ClearHit(EHitLayer l)  { fHits.ClearBit(l);            }
187 >      Double_t             D0()             const { return -fDxy;                 }
188 >      Double_t             D0Corrected(const BaseVertex &iVertex) const;
189 >      Double_t             D0Err()          const { return fDxyErr;               }
190 >      Double_t             Dsz()            const { return fDsz;                  }
191 >      Double_t             DszErr()         const { return fDszErr;               }
192 >      Double_t             Dxy()            const { return fDxy;                  }
193 >      Double_t             DxyErr()         const { return fDxyErr;               }
194 >      Double_t             E(Double_t m)    const { return TMath::Sqrt(E2(m));    }
195 >      Double_t             E2(Double_t m)   const { return P2()+m*m;              }
196 >      Double_t             Eta()            const { return Mom().Eta();           }
197 >      Double_t             EtaEcal()        const { return fEtaEcal;              }
198 >      Bool_t               Hit(EHitLayer l) const { return fHits.TestBit(l);      }
199 >      const BitMask48     &Hits()           const { return fHits;                 }
200 >      Bool_t               IsGsf()          const { return fIsGsf;                }
201 >      Double_t             Lambda()         const { return fLambda;               }
202 >      Double_t             LambdaErr()      const { return fLambdaErr;            }
203 >      const MCParticle    *MCPart()         const { return fMCParticleRef.Obj();  }
204 >      const ThreeVectorC  &Mom()            const;
205 >      FourVectorM          Mom4(Double_t m) const { return FourVectorM(Pt(),Eta(),Phi(),m); }
206 >      UShort_t             Ndof()           const { return fNdof;                              }
207 >      UInt_t               NHits()          const { return fHits.NBitsSet();                   }
208 >      UInt_t               NStereoHits()    const { return StereoHits().NBitsSet();            }
209 >      UInt_t               NPixelHits()     const { return PixelHits().NBitsSet();             }
210 >      EObjType             ObjType()        const { return kTrack;                             }    
211 >      Double_t             P2()             const { return 1./fQOverP/fQOverP;                 }
212 >      Double_t             P()              const { return TMath::Abs(1./fQOverP);             }
213 >      Double_t             Phi()            const { return fPhi0;                              }
214 >      Double_t             Phi0()           const { return fPhi0;                              }
215 >      Double_t             Phi0Err()        const { return fPhi0Err;                           }
216 >      Double_t             PhiEcal()        const { return fPhiEcal;                           }
217 >      Double_t             Prob()           const { return TMath::Prob(fChi2,fNdof);           }
218 >      Double_t             Pt()             const { return Mom().Rho();                        }
219 >      Double_t             Px()             const { return Mom().X();                          }
220 >      Double_t             Py()             const { return Mom().Y();                          }
221 >      Double_t             Pz()             const { return Mom().Z();                          }
222 >      Double_t             QOverP()         const { return fQOverP;                            }
223 >      Double_t             QOverPErr()      const { return fQOverPErr;                         }
224 >      Double_t             RChi2()          const { return fChi2/(Double_t)fNdof; }
225 >      Double_t             Theta()          const { return (TMath::PiOver2() - fLambda);       }
226 >      const SuperCluster  *SCluster()       const { return fSuperClusterRef.Obj();             }
227 >      const BitMask48      PixelHits()      const { return (fHits & PixelLayers());            }
228 >      const TrackQuality  &Quality()        const { return fQuality;                           }
229 >      TrackQuality        &Quality()              { return fQuality;                           }
230 >      const BitMask48      StereoHits()     const { return (fHits & StereoLayers());           }
231 >      void                 SetAlgo(ETrackAlgorithm e)          { fAlgo = e;                    }
232 >      void                 SetChi2(Double_t chi2)              { fChi2 = chi2;                 }
233 >      void                 SetErrors(Double_t qOverPErr, Double_t lambdaErr, Double_t phi0Err,
234 >                                     Double_t dXyErr, Double_t dSzErr);
235 >      void                 SetEtaEcal(Double_t eta)            { fEtaEcal = eta;               }
236 >      void                 SetHelix (Double_t qOverP, Double_t lambda, Double_t phi0,
237 >                                     Double_t dXy, Double_t dSz);
238 >      void                 SetHit(EHitLayer l)                 { fHits.SetBit(l);              }
239 >      void                 SetHits(const BitMask48 &hits)      { fHits = hits;                 }
240 >      void                 SetIsGsf(Bool_t b)                  { fIsGsf = b;                   }
241 >      void                 SetNdof(UShort_t dof)               { fNdof = dof;                  }
242 >      void                 SetMCPart(const MCParticle *p)      { fMCParticleRef = p;           }
243 >      void                 SetPhiEcal(Double_t phi)            { fPhiEcal = phi;               }
244 >      void                 SetSCluster(const SuperCluster* sc) { fSuperClusterRef = sc;        }
245 >      Double_t             Z0()             const { return fDsz/TMath::Cos(fLambda);           }
246 >
247 >      
248 >      static const BitMask48      StereoLayers();
249 >      static const BitMask48      PixelLayers();
250 >
251      protected:
252 <          // Constant which is store in the file
253 <      BitMask64          fHits;                // Mostly Hit informations
254 <      BitMask32          fStat;                // Storage for various interesting things
255 <      Double_t           fQOverP, fQOverPErr;
256 <      Double_t           fLambda, fLambdaErr;
257 <      Double_t           fPhi0,fPhi0Err;       // Follow track parameters/uncertainties
258 <      Double_t           fDxy,  fDxyErr;
259 <      Double_t           fDsz,  fDszErr;
260 <      
261 <      Double_t           fChi2; //chi squared of track fit
262 <      UInt_t             fNdof; //number of dof of track fit
263 <      
264 <      TRef               fMCParticleRef; //reference to sim particle (for monte carlo)
252 >      void                 ClearMom()    const { fCacheMomFlag.ClearCache(); }
253 >      void                 GetMom()      const;
254 >
255 >      BitMask48            fHits;                //storage for mostly hit information
256 >      ETrackAlgorithm      fAlgo;                //track algorithm
257 >      TrackQuality         fQuality;             //track quality
258 >      Bool_t               fIsGsf;               //flag to identify gsf tracks
259 >      Double32_t           fQOverP;              //[0,0,14]signed inverse of momentum [1/GeV]
260 >      Double32_t           fQOverPErr;           //[0,0,14]error of q/p
261 >      Double32_t           fLambda;              //[0,0,14]pi/2 - polar angle at the reference point
262 >      Double32_t           fLambdaErr;           //[0,0,14]error of lambda
263 >      Double32_t           fPhi0;                //[0,0,14]azimuth angle at the given point
264 >      Double32_t           fPhi0Err;             //[0,0,14]error of azimuthal angle
265 >      Double32_t           fDxy;                 //[0,0,14]trans. distance to reference point [cm]
266 >      Double32_t           fDxyErr;              //[0,0,14]error of transverse distance
267 >      Double32_t           fDsz;                 //[0,0,14]long. distance to reference point [cm]
268 >      Double32_t           fDszErr;              //[0,0,14]error of longitudinal distance
269 >      Double32_t           fChi2;                //[0,0,12]chi squared of track fit
270 >      UShort_t             fNdof;                //degree-of-freedom of track fit
271 >      Double32_t           fEtaEcal;             //[0,0,12]eta of track at Ecal front face
272 >      Double32_t           fPhiEcal;             //[0,0,12]phi of track at Ecal front face
273 >      Ref<SuperCluster>    fSuperClusterRef;     //superCluster crossed by track
274 >      Ref<MCParticle>      fMCParticleRef;       //reference to sim particle (for monte carlo)
275 >      mutable CacheFlag    fCacheMomFlag;        //||cache validity flag for momentum
276 >      mutable ThreeVectorC fCachedMom;           //!cached momentum vector
277                
278 <    ClassDef(Track, 1) // Track class
278 >    ClassDef(Track, 3) // Track class
279    };
280   }
281  
282   //--------------------------------------------------------------------------------------------------
283 < inline
284 < void mithep::Track::SetHelix(Double_t qOverP, Double_t lambda, Double_t phi0,
285 <                                   Double_t dxy, Double_t dsz)
283 > inline void mithep::Track::GetMom() const
284 > {
285 >  // Compute three momentum.
286 >
287 >  Double_t pt = TMath::Abs(TMath::Cos(fLambda)/fQOverP);
288 >  Double_t eta = - TMath::Log(TMath::Tan(Theta()/2.));
289 >  fCachedMom.SetCoordinates(pt,eta,Phi());
290 > }
291 >
292 > //--------------------------------------------------------------------------------------------------
293 > inline const mithep::ThreeVectorC &mithep::Track::Mom() const
294 > {
295 >  // Return cached momentum value.
296 >
297 >  if (!fCacheMomFlag.IsValid()) {
298 >    GetMom();
299 >    fCacheMomFlag.SetValid();
300 >  }
301 >  return fCachedMom;
302 > }
303 >
304 > //--------------------------------------------------------------------------------------------------
305 > inline Double_t mithep::Track::D0Corrected(const BaseVertex &iVertex) const
306 > {
307 >  // Return corrected d0 with respect to primary vertex or beamspot.
308 >
309 >  Double_t lXM =  -TMath::Sin(Phi()) * D0();
310 >  Double_t lYM =   TMath::Cos(Phi()) * D0();
311 >  Double_t lDX = (lXM + iVertex.X());
312 >  Double_t lDY = (lYM + iVertex.Y());
313 >  Double_t d0Corr = (Px()*lDY - Py()*lDX)/Pt();
314 >  
315 >  return d0Corr;
316 > }
317 >
318 > //--------------------------------------------------------------------------------------------------
319 > inline void mithep::Track::SetHelix(Double_t qOverP, Double_t lambda, Double_t phi0,
320 >                                    Double_t dxy, Double_t dsz)
321   {
322    // Set helix parameters.
323  
# Line 216 | Line 326 | void mithep::Track::SetHelix(Double_t qO
326    fPhi0   = phi0;
327    fDxy    = dxy;
328    fDsz    = dsz;
329 +  ClearMom();
330   }
331  
332   //--------------------------------------------------------------------------------------------------
333 < inline
334 < void mithep::Track::SetErrors(Double_t qOverPErr, Double_t lambdaErr, Double_t phi0Err,
224 <                                   Double_t dxyErr, Double_t dszErr)
333 > inline void mithep::Track::SetErrors(Double_t qOverPErr, Double_t lambdaErr, Double_t phi0Err,
334 >                                     Double_t dxyErr, Double_t dszErr)
335   {
336    // Set helix errors.
337  
# Line 233 | Line 343 | void mithep::Track::SetErrors(Double_t q
343   }
344  
345   //--------------------------------------------------------------------------------------------------
346 < inline
347 < const mithep::MCParticle *mithep::Track::MCPart() const
346 > inline const mithep::BitMask48 mithep::Track::StereoLayers()
347 > {
348 >  // Build and return BitMask of stereo layers.
349 >
350 >  mithep::BitMask48 stereoLayers;
351 >  stereoLayers.SetBit(mithep::Track::TIB1S);
352 >  stereoLayers.SetBit(mithep::Track::TIB2S);
353 >  stereoLayers.SetBit(mithep::Track::TID1S);
354 >  stereoLayers.SetBit(mithep::Track::TID2S);
355 >  stereoLayers.SetBit(mithep::Track::TID3S);
356 >  stereoLayers.SetBit(mithep::Track::TOB1S);
357 >  stereoLayers.SetBit(mithep::Track::TOB2S);
358 >  stereoLayers.SetBit(mithep::Track::TEC1S);
359 >  stereoLayers.SetBit(mithep::Track::TEC2S);
360 >  stereoLayers.SetBit(mithep::Track::TEC3S);
361 >  stereoLayers.SetBit(mithep::Track::TEC4S);
362 >  stereoLayers.SetBit(mithep::Track::TEC5S);
363 >  stereoLayers.SetBit(mithep::Track::TEC6S);
364 >  stereoLayers.SetBit(mithep::Track::TEC7S);
365 >  stereoLayers.SetBit(mithep::Track::TEC8S);
366 >  stereoLayers.SetBit(mithep::Track::TEC9S);
367 >  return stereoLayers;
368 > }
369 >
370 > //--------------------------------------------------------------------------------------------------
371 > inline const mithep::BitMask48 mithep::Track::PixelLayers()
372   {
373 <  // Get reference to simulated particle.
373 >  // Build and return BitMask of stereo layers.
374  
375 <  return static_cast<const MCParticle*>(fMCParticleRef.GetObject());
375 >  mithep::BitMask48 pixelLayers;
376 >  pixelLayers.SetBit(mithep::Track::PXB1);
377 >  pixelLayers.SetBit(mithep::Track::PXB2);
378 >  pixelLayers.SetBit(mithep::Track::PXB3);
379 >  pixelLayers.SetBit(mithep::Track::PXF1);
380 >  pixelLayers.SetBit(mithep::Track::PXF2);
381 >  return pixelLayers;
382   }
383   #endif

Diff Legend

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