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.42 by loizides, Mon Jul 13 11:00:32 2009 UTC vs.
Revision 1.48 by bendavid, Tue Mar 23 16:52:46 2010 UTC

# Line 78 | Line 78
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"
# Line 134 | Line 135 | namespace mithep
135          TEC9S
136        };
137  
138 <      Track() : fQOverP(0), fQOverPErr(0), fLambda(0), fLambdaErr(0),
139 <                fPhi0(0), fPhi0Err(0), fDxy(0), fDxyErr(0), fDsz(0), fDszErr(0),
140 <                fChi2(0), fNdof(0), fEtaEcal(0), fPhiEcal(0) {}
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), fEtaEcal(0), fPhiEcal(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 +      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);            }
# Line 159 | Line 197 | namespace mithep
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 +      const BitMask48     &MissingHits()    const { return fMissingHits;          }
201 +      const BitMask48     &ExpectedHitsInner() const { return fExpectedHitsInner; }
202 +      const BitMask48     &ExpectedHitsOuter() const { return fExpectedHitsOuter; }
203 +      Bool_t               IsGsf()          const { return fIsGsf;                }
204        Double_t             Lambda()         const { return fLambda;               }
205        Double_t             LambdaErr()      const { return fLambdaErr;            }
206        const MCParticle    *MCPart()         const { return fMCParticleRef.Obj();  }
# Line 166 | Line 208 | namespace mithep
208        FourVectorM          Mom4(Double_t m) const { return FourVectorM(Pt(),Eta(),Phi(),m); }
209        UShort_t             Ndof()           const { return fNdof;                              }
210        UInt_t               NHits()          const { return fHits.NBitsSet();                   }
211 +      UInt_t               NMissingHits()   const { return fMissingHits.NBitsSet();            }
212 +      UInt_t               NExpectedHitsInner() const { return fExpectedHitsInner.NBitsSet();  }
213 +      UInt_t               NExpectedHitsOuter() const { return fExpectedHitsOuter.NBitsSet();  }
214        UInt_t               NStereoHits()    const { return StereoHits().NBitsSet();            }
215 +      UInt_t               NPixelHits()     const { return PixelHits().NBitsSet();             }
216        EObjType             ObjType()        const { return kTrack;                             }    
217        Double_t             P2()             const { return 1./fQOverP/fQOverP;                 }
218        Double_t             P()              const { return TMath::Abs(1./fQOverP);             }
# Line 184 | Line 230 | namespace mithep
230        Double_t             RChi2()          const { return fChi2/(Double_t)fNdof; }
231        Double_t             Theta()          const { return (TMath::PiOver2() - fLambda);       }
232        const SuperCluster  *SCluster()       const { return fSuperClusterRef.Obj();             }
233 +      const BitMask48      PixelHits()      const { return (fHits & PixelLayers());            }
234 +      const TrackQuality  &Quality()        const { return fQuality;                           }
235 +      TrackQuality        &Quality()              { return fQuality;                           }
236        const BitMask48      StereoHits()     const { return (fHits & StereoLayers());           }
237 +      void                 SetAlgo(ETrackAlgorithm e)          { fAlgo = e;                    }
238        void                 SetChi2(Double_t chi2)              { fChi2 = chi2;                 }
239        void                 SetErrors(Double_t qOverPErr, Double_t lambdaErr, Double_t phi0Err,
240                                       Double_t dXyErr, Double_t dSzErr);
# Line 193 | Line 243 | namespace mithep
243                                       Double_t dXy, Double_t dSz);
244        void                 SetHit(EHitLayer l)                 { fHits.SetBit(l);              }
245        void                 SetHits(const BitMask48 &hits)      { fHits = hits;                 }
246 +      void                 SetMissingHits(const BitMask48 &h)  { fMissingHits = h;             }
247 +      void                 SetExpectedHitsInner(const BitMask48 &h) { fExpectedHitsInner = h;  }
248 +      void                 SetExpectedHitsOuter(const BitMask48 &h) { fExpectedHitsInner = h;  }
249 +      void                 SetIsGsf(Bool_t b)                  { fIsGsf = b;                   }
250        void                 SetNdof(UShort_t dof)               { fNdof = dof;                  }
251        void                 SetMCPart(const MCParticle *p)      { fMCParticleRef = p;           }
252        void                 SetPhiEcal(Double_t phi)            { fPhiEcal = phi;               }
253        void                 SetSCluster(const SuperCluster* sc) { fSuperClusterRef = sc;        }
254        Double_t             Z0()             const { return fDsz/TMath::Cos(fLambda);           }
255  
256 <      static
257 <      const BitMask48      StereoLayers();
256 >      
257 >      static const BitMask48      StereoLayers();
258 >      static const BitMask48      PixelLayers();
259  
260      protected:
261        void                 ClearMom()    const { fCacheMomFlag.ClearCache(); }
262        void                 GetMom()      const;
263  
264        BitMask48            fHits;                //storage for mostly hit information
265 +      BitMask48            fMissingHits;         //missing hits in crossed good modules
266 +      BitMask48            fExpectedHitsInner;   //expected hits before first hit
267 +      BitMask48            fExpectedHitsOuter;   //expected hits after last hit
268 +      ETrackAlgorithm      fAlgo;                //track algorithm
269 +      TrackQuality         fQuality;             //track quality
270 +      Bool_t               fIsGsf;               //flag to identify gsf tracks
271        Double32_t           fQOverP;              //[0,0,14]signed inverse of momentum [1/GeV]
272        Double32_t           fQOverPErr;           //[0,0,14]error of q/p
273        Double32_t           fLambda;              //[0,0,14]pi/2 - polar angle at the reference point
# Line 226 | Line 287 | namespace mithep
287        mutable CacheFlag    fCacheMomFlag;        //||cache validity flag for momentum
288        mutable ThreeVectorC fCachedMom;           //!cached momentum vector
289                
290 <    ClassDef(Track, 1) // Track class
290 >    ClassDef(Track, 4) // Track class
291    };
292   }
293  
# Line 267 | Line 328 | inline Double_t mithep::Track::D0Correct
328   }
329  
330   //--------------------------------------------------------------------------------------------------
331 < inline
332 < void mithep::Track::SetHelix(Double_t qOverP, Double_t lambda, Double_t phi0,
272 <                             Double_t dxy, Double_t dsz)
331 > inline void mithep::Track::SetHelix(Double_t qOverP, Double_t lambda, Double_t phi0,
332 >                                    Double_t dxy, Double_t dsz)
333   {
334    // Set helix parameters.
335  
# Line 282 | Line 342 | void mithep::Track::SetHelix(Double_t qO
342   }
343  
344   //--------------------------------------------------------------------------------------------------
345 < inline
346 < void mithep::Track::SetErrors(Double_t qOverPErr, Double_t lambdaErr, Double_t phi0Err,
287 <                              Double_t dxyErr, Double_t dszErr)
345 > inline void mithep::Track::SetErrors(Double_t qOverPErr, Double_t lambdaErr, Double_t phi0Err,
346 >                                     Double_t dxyErr, Double_t dszErr)
347   {
348    // Set helix errors.
349  
# Line 296 | Line 355 | void mithep::Track::SetErrors(Double_t q
355   }
356  
357   //--------------------------------------------------------------------------------------------------
358 < inline
300 < const mithep::BitMask48 mithep::Track::StereoLayers()
358 > inline const mithep::BitMask48 mithep::Track::StereoLayers()
359   {
360    // Build and return BitMask of stereo layers.
361  
# Line 320 | Line 378 | const mithep::BitMask48 mithep::Track::S
378    stereoLayers.SetBit(mithep::Track::TEC9S);
379    return stereoLayers;
380   }
381 +
382 + //--------------------------------------------------------------------------------------------------
383 + inline const mithep::BitMask48 mithep::Track::PixelLayers()
384 + {
385 +  // Build and return BitMask of stereo layers.
386 +
387 +  mithep::BitMask48 pixelLayers;
388 +  pixelLayers.SetBit(mithep::Track::PXB1);
389 +  pixelLayers.SetBit(mithep::Track::PXB2);
390 +  pixelLayers.SetBit(mithep::Track::PXB3);
391 +  pixelLayers.SetBit(mithep::Track::PXF1);
392 +  pixelLayers.SetBit(mithep::Track::PXF2);
393 +  return pixelLayers;
394 + }
395   #endif

Diff Legend

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