ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/UserCode/MitAna/DataTree/interface/Track.h

Comparing UserCode/MitAna/DataTree/interface/Track.h (file contents):
Revision 1.18 by loizides, Wed Sep 17 04:16:25 2008 UTC vs.
Revision 1.46 by bendavid, Thu Jan 7 11:03:41 2010 UTC

#	Line 19 | Line 19
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 43 | 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		//--------------------------------------------------------------------------------------------------
#	Line 70 | Line 77
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/BaseVertex.h"
82		#include "MitAna/DataTree/interface/DataObject.h"
83		#include "MitAna/DataTree/interface/MCParticle.h"
84	<	#include "MitAna/DataTree/interface/BitMask.h"
76	<	#include "MitAna/DataTree/interface/Types.h"
84	>	#include "MitAna/DataTree/interface/SuperCluster.h"
85
86		namespace mithep
87		{
#	Line 97 | Line 105 | namespace mithep
105		TID2,
106		TID2S,
107		TID3,
108	+	TID3S,
109		TOB1,
110		TOB1S,
111		TOB2,
#	Line 110 | Line 119 | namespace mithep
119		TEC2,
120		TEC2S,
121		TEC3,
122	+	TEC3S,
123		TEC4,
124	+	TEC4S,
125		TEC5,
126		TEC5S,
127		TEC6,
128	+	TEC6S,
129		TEC7,
130	+	TEC7S,
131		TEC8,
132	<	TEC9
132	>	TEC8S,
133	>	TEC9,
134	>	TEC9S
135		};
136
137	<	Track() : fQOverP(0), fQOverPErr(0), fLambda(0), fLambdaErr(0),
138	<	fPhi0(0), fPhi0Err(0), fDxy(0), fDxyErr(0), fDsz(0), fDszErr(0),
139	<	fChi2(0), fNdof(0) {}
137	>	enum ETrackAlgorithm { //taken from DataFormats/TrackReco/interface/TrackBase.h
138	>	undefAlgorithm=0,
139	>	ctf=1,
140	>	rs=2,
141	>	cosmics=3,
142	>	iter0=4,
143	>	iter1=5,
144	>	iter2=6,
145	>	iter3=7,
146	>	iter4=8,
147	>	iter5=9,
148	>	iter6=10,
149	>	iter7=11,
150	>	iter8=12,
151	>	iter9=13,
152	>	iter10=14,
153	>	outInEcalSeededConv=15,
154	>	inOutEcalSeededConv=16,
155	>	nuclInter=17,
156	>	standAloneMuon=18,
157	>	globalMuon=19,
158	>	cosmicStandAloneMuon=20,
159	>	cosmicGlobalMuon=21,
160	>	iter1LargeD0=22,
161	>	iter2LargeD0=23,
162	>	iter3LargeD0=24,
163	>	iter4LargeD0=25,
164	>	iter5LargeD0=26,
165	>	bTagGhostTracks=27,
166	>	beamhalo=28,
167	>	algoSize=29
168	>	};
169	>
170	>
171	>	Track() : fAlgo(undefAlgorithm), fIsGsf(0), fQOverP(0), fQOverPErr(0),
172	>	fLambda(0), fLambdaErr(0), fPhi0(0), fPhi0Err(0),
173	>	fDxy(0), fDxyErr(0), fDsz(0), fDszErr(0), fChi2(0),
174	>	fNdof(0), fEtaEcal(0), fPhiEcal(0) {}
175		Track(Double_t qOverP, Double_t lambda, Double_t phi0, Double_t dxy, Double_t dsz) :
176	<	fQOverP(qOverP), fQOverPErr(0), fLambda(lambda), fLambdaErr(0),
177	<	fPhi0(phi0), fPhi0Err(0), fDxy(dxy), fDxyErr(0), fDsz(dsz), fDszErr(0),
178	<	fChi2(0), fNdof(0) {}
176	>	fAlgo(undefAlgorithm), fIsGsf(0), fQOverP(qOverP), fQOverPErr(0),
177	>	fLambda(lambda), fLambdaErr(0), fPhi0(phi0), fPhi0Err(0),
178	>	fDxy(dxy), fDxyErr(0), fDsz(dsz), fDszErr(0), fChi2(0),
179	>	fNdof(0), fEtaEcal(0), fPhiEcal(0) {}
180		~Track() {}
181
182	<	Int_t              Charge()         const { return (fQOverP>0) ? 1 : -1; }
183	<	Double_t           Chi2()           const { return fChi2; }
184	<	void               ClearHit(EHitLayer l)  { fHits.ClearBit(l); }
185	<	Double_t           D0()             const { return -fDxy; }
186	<	Double_t           D0Err()          const { return fDxyErr; }
187	<	Double_t           Dsz()            const { return fDsz; }
188	<	Double_t           DszErr()         const { return fDszErr; }
189	<	Double_t           Dxy()            const { return fDxy; }
190	<	Double_t           DxyErr()         const { return fDxyErr; }
191	<	Double_t           E(Double_t m)    const { return TMath::Sqrt(E2(m)); }
192	<	Double_t           E2(Double_t m)   const { return P2()+m*m; }
193	<	Bool_t             Hit(EHitLayer l) const { return fHits.TestBit(l); }
194	<	Double_t           Lambda()         const { return fLambda; }
195	<	Double_t           LambdaErr()      const { return fLambdaErr; }
196	<	const MCParticle  *MCPart()         const;
197	<	ThreeVector        Mom()            const { return ThreeVector(Px(),Py(),Pz()); }
198	<	FourVector         Mom4(Double_t m) const { return FourVector(Px(),Py(),Pz(),E(m)); }
199	<	UInt_t             Ndof()           const { return fNdof; }
200	<	UInt_t             NHits()          const { return fHits.NBitsSet(); }
201	<	Double_t           P2()             const { return P()*P(); }
202	<	Double_t           P()              const { return TMath::Abs(1./fQOverP); }
203	<	Double_t           Phi()            const { return fPhi0; }
204	<	Double_t           Phi0()           const { return fPhi0; }
205	<	Double_t           Phi0Err()        const { return fPhi0Err; }
206	<	Double_t           Pt()             const { return TMath::Abs(TMath::Cos(fLambda)/fQOverP); }
207	<	Double_t           Px()             const { return Pt()*TMath::Cos(fPhi0); }
208	<	Double_t           Py()             const { return Pt()*TMath::Sin(fPhi0); }
209	<	Double_t           Pz()             const { return P()*TMath::Sin(fLambda); }
210	<	Double_t           QOverP()         const { return fQOverP; }
211	<	Double_t           QOverPErr()      const { return fQOverPErr; }
212	<	Double_t           Theta()          const { return (TMath::PiOver2() - fLambda); }
213	<	Double_t           Z0()             const { return fDsz/TMath::Cos(fLambda); }
214	<	void               SetChi2(Double_t chi2) { fChi2 = chi2; }
215	<	void               SetErrors(Double_t qOverPErr, Double_t lambdaErr, Double_t phi0Err,
216	<	Double_t dXyErr, Double_t dSzErr);
217	<	void               SetHelix (Double_t qOverP, Double_t lambda, Double_t phi0,
218	<	Double_t dXy, Double_t dSz);
219	<	void               SetHit(EHitLayer l)      { fHits.SetBit(l); }
220	<	void               SetNdof(UInt_t dof)      { fNdof = dof; }
221	<	void               SetMCPart(MCParticle *p) { fMCParticleRef = p; }
182	>	ETrackAlgorithm      Algo()           const { return fAlgo;                 }
183	>	Int_t                Charge()         const { return (fQOverP>0) ? 1 : -1;  }
184	>	Double_t             Chi2()           const { return fChi2;                 }
185	>	void                 ClearHit(EHitLayer l)  { fHits.ClearBit(l);            }
186	>	Double_t             D0()             const { return -fDxy;                 }
187	>	Double_t             D0Corrected(const BaseVertex &iVertex) const;
188	>	Double_t             D0Err()          const { return fDxyErr;               }
189	>	Double_t             Dsz()            const { return fDsz;                  }
190	>	Double_t             DszErr()         const { return fDszErr;               }
191	>	Double_t             Dxy()            const { return fDxy;                  }
192	>	Double_t             DxyErr()         const { return fDxyErr;               }
193	>	Double_t             E(Double_t m)    const { return TMath::Sqrt(E2(m));    }
194	>	Double_t             E2(Double_t m)   const { return P2()+m*m;              }
195	>	Double_t             Eta()            const { return Mom().Eta();           }
196	>	Double_t             EtaEcal()        const { return fEtaEcal;              }
197	>	Bool_t               Hit(EHitLayer l) const { return fHits.TestBit(l);      }
198	>	const BitMask48     &Hits()           const { return fHits;                 }
199	>	Bool_t               IsGsf()          const { return fIsGsf;                }
200	>	Double_t             Lambda()         const { return fLambda;               }
201	>	Double_t             LambdaErr()      const { return fLambdaErr;            }
202	>	const MCParticle    *MCPart()         const { return fMCParticleRef.Obj();  }
203	>	const ThreeVectorC  &Mom()            const;
204	>	FourVectorM          Mom4(Double_t m) const { return FourVectorM(Pt(),Eta(),Phi(),m); }
205	>	UShort_t             Ndof()           const { return fNdof;                              }
206	>	UInt_t               NHits()          const { return fHits.NBitsSet();                   }
207	>	UInt_t               NStereoHits()    const { return StereoHits().NBitsSet();            }
208	>	UInt_t               NPixelHits()     const { return PixelHits().NBitsSet();             }
209	>	EObjType             ObjType()        const { return kTrack;                             }
210	>	Double_t             P2()             const { return 1./fQOverP/fQOverP;                 }
211	>	Double_t             P()              const { return TMath::Abs(1./fQOverP);             }
212	>	Double_t             Phi()            const { return fPhi0;                              }
213	>	Double_t             Phi0()           const { return fPhi0;                              }
214	>	Double_t             Phi0Err()        const { return fPhi0Err;                           }
215	>	Double_t             PhiEcal()        const { return fPhiEcal;                           }
216	>	Double_t             Prob()           const { return TMath::Prob(fChi2,fNdof);           }
217	>	Double_t             Pt()             const { return Mom().Rho();                        }
218	>	Double_t             Px()             const { return Mom().X();                          }
219	>	Double_t             Py()             const { return Mom().Y();                          }
220	>	Double_t             Pz()             const { return Mom().Z();                          }
221	>	Double_t             QOverP()         const { return fQOverP;                            }
222	>	Double_t             QOverPErr()      const { return fQOverPErr;                         }
223	>	Double_t             RChi2()          const { return fChi2/(Double_t)fNdof; }
224	>	Double_t             Theta()          const { return (TMath::PiOver2() - fLambda);       }
225	>	const SuperCluster  *SCluster()       const { return fSuperClusterRef.Obj();             }
226	>	const BitMask48      PixelHits()      const { return (fHits & PixelLayers());            }
227	>	const BitMask48      StereoHits()     const { return (fHits & StereoLayers());           }
228	>	void                 SetAlgo(ETrackAlgorithm e)          { fAlgo = e;                    }
229	>	void                 SetChi2(Double_t chi2)              { fChi2 = chi2;                 }
230	>	void                 SetErrors(Double_t qOverPErr, Double_t lambdaErr, Double_t phi0Err,
231	>	Double_t dXyErr, Double_t dSzErr);
232	>	void                 SetEtaEcal(Double_t eta)            { fEtaEcal = eta;               }
233	>	void                 SetHelix (Double_t qOverP, Double_t lambda, Double_t phi0,
234	>	Double_t dXy, Double_t dSz);
235	>	void                 SetHit(EHitLayer l)                 { fHits.SetBit(l);              }
236	>	void                 SetHits(const BitMask48 &hits)      { fHits = hits;                 }
237	>	void                 SetIsGsf(Bool_t b)                  { fIsGsf = b;                   }
238	>	void                 SetNdof(UShort_t dof)               { fNdof = dof;                  }
239	>	void                 SetMCPart(const MCParticle *p)      { fMCParticleRef = p;           }
240	>	void                 SetPhiEcal(Double_t phi)            { fPhiEcal = phi;               }
241	>	void                 SetSCluster(const SuperCluster* sc) { fSuperClusterRef = sc;        }
242	>	Double_t             Z0()             const { return fDsz/TMath::Cos(fLambda);           }
243	>
244	>
245	>	static const BitMask48      StereoLayers();
246	>	static const BitMask48      PixelLayers();
247
248		protected:
249	<	BitMask64          fHits;                //storage for mostly hit information
250	<	Double_t           fQOverP;              //signed inverse of momentum [1/GeV]
251	<	Double_t           fQOverPErr;           //error of q/p
252	<	Double_t           fLambda;              //pi/2 - polar angle at the reference point
253	<	Double_t           fLambdaErr;           //error of lambda
254	<	Double_t           fPhi0;                //azimuth angle at the given point
255	<	Double_t           fPhi0Err;             //error of azimuthal angle
256	<	Double_t           fDxy;                 //transverse distance to reference point [cm]
257	<	Double_t           fDxyErr;              //error of transverse distance
258	<	Double_t           fDsz;                 //longitudinal distance to reference point [cm]
259	<	Double_t           fDszErr;              //error of longitudinal distance
260	<	Double_t           fChi2;                //chi squared of track fit
261	<	UInt_t             fNdof;                //degree-of-freedom of track fit
262	<	TRef               fMCParticleRef;       //reference to sim particle (for monte carlo)
249	>	void                 ClearMom()    const { fCacheMomFlag.ClearCache(); }
250	>	void                 GetMom()      const;
251	>
252	>	BitMask48            fHits;                //storage for mostly hit information
253	>	ETrackAlgorithm      fAlgo;                //track algorithm
254	>	Bool_t               fIsGsf;               //flag to identify gsf tracks
255	>	Double32_t           fQOverP;              //[0,0,14]signed inverse of momentum [1/GeV]
256	>	Double32_t           fQOverPErr;           //[0,0,14]error of q/p
257	>	Double32_t           fLambda;              //[0,0,14]pi/2 - polar angle at the reference point
258	>	Double32_t           fLambdaErr;           //[0,0,14]error of lambda
259	>	Double32_t           fPhi0;                //[0,0,14]azimuth angle at the given point
260	>	Double32_t           fPhi0Err;             //[0,0,14]error of azimuthal angle
261	>	Double32_t           fDxy;                 //[0,0,14]trans. distance to reference point [cm]
262	>	Double32_t           fDxyErr;              //[0,0,14]error of transverse distance
263	>	Double32_t           fDsz;                 //[0,0,14]long. distance to reference point [cm]
264	>	Double32_t           fDszErr;              //[0,0,14]error of longitudinal distance
265	>	Double32_t           fChi2;                //[0,0,12]chi squared of track fit
266	>	UShort_t             fNdof;                //degree-of-freedom of track fit
267	>	Double32_t           fEtaEcal;             //[0,0,12]eta of track at Ecal front face
268	>	Double32_t           fPhiEcal;             //[0,0,12]phi of track at Ecal front face
269	>	Ref<SuperCluster>    fSuperClusterRef;     //superCluster crossed by track
270	>	Ref<MCParticle>      fMCParticleRef;       //reference to sim particle (for monte carlo)
271	>	mutable CacheFlag    fCacheMomFlag;        //||cache validity flag for momentum
272	>	mutable ThreeVectorC fCachedMom;           //!cached momentum vector
273
274	<	ClassDef(Track, 1) // Track class
274	>	ClassDef(Track, 2) // Track class
275		};
276		}
277
278		//--------------------------------------------------------------------------------------------------
279	<	inline
280	<	void mithep::Track::SetHelix(Double_t qOverP, Double_t lambda, Double_t phi0,
281	<	Double_t dxy, Double_t dsz)
279	>	inline void mithep::Track::GetMom() const
280	>	{
281	>	// Compute three momentum.
282	>
283	>	Double_t pt = TMath::Abs(TMath::Cos(fLambda)/fQOverP);
284	>	Double_t eta = - TMath::Log(TMath::Tan(Theta()/2.));
285	>	fCachedMom.SetCoordinates(pt,eta,Phi());
286	>	}
287	>
288	>	//--------------------------------------------------------------------------------------------------
289	>	inline const mithep::ThreeVectorC &mithep::Track::Mom() const
290	>	{
291	>	// Return cached momentum value.
292	>
293	>	if (!fCacheMomFlag.IsValid()) {
294	>	GetMom();
295	>	fCacheMomFlag.SetValid();
296	>	}
297	>	return fCachedMom;
298	>	}
299	>
300	>	//--------------------------------------------------------------------------------------------------
301	>	inline Double_t mithep::Track::D0Corrected(const BaseVertex &iVertex) const
302	>	{
303	>	// Return corrected d0 with respect to primary vertex or beamspot.
304	>
305	>	Double_t lXM =  -TMath::Sin(Phi()) * D0();
306	>	Double_t lYM =   TMath::Cos(Phi()) * D0();
307	>	Double_t lDX = (lXM + iVertex.X());
308	>	Double_t lDY = (lYM + iVertex.Y());
309	>	Double_t d0Corr = (Px()*lDY - Py()*lDX)/Pt();
310	>
311	>	return d0Corr;
312	>	}
313	>
314	>	//--------------------------------------------------------------------------------------------------
315	>	inline void mithep::Track::SetHelix(Double_t qOverP, Double_t lambda, Double_t phi0,
316	>	Double_t dxy, Double_t dsz)
317		{
318		// Set helix parameters.
319
#	Line 201 | Line 322 | void mithep::Track::SetHelix(Double_t qO
322		fPhi0   = phi0;
323		fDxy    = dxy;
324		fDsz    = dsz;
325	+	ClearMom();
326		}
327
328		//--------------------------------------------------------------------------------------------------
329	<	inline
330	<	void mithep::Track::SetErrors(Double_t qOverPErr, Double_t lambdaErr, Double_t phi0Err,
209	<	Double_t dxyErr, Double_t dszErr)
329	>	inline void mithep::Track::SetErrors(Double_t qOverPErr, Double_t lambdaErr, Double_t phi0Err,
330	>	Double_t dxyErr, Double_t dszErr)
331		{
332		// Set helix errors.
333
#	Line 218 | Line 339 | void mithep::Track::SetErrors(Double_t q
339		}
340
341		//--------------------------------------------------------------------------------------------------
342	<	inline
343	<	const mithep::MCParticle *mithep::Track::MCPart() const
342	>	inline const mithep::BitMask48 mithep::Track::StereoLayers()
343	>	{
344	>	// Build and return BitMask of stereo layers.
345	>
346	>	mithep::BitMask48 stereoLayers;
347	>	stereoLayers.SetBit(mithep::Track::TIB1S);
348	>	stereoLayers.SetBit(mithep::Track::TIB2S);
349	>	stereoLayers.SetBit(mithep::Track::TID1S);
350	>	stereoLayers.SetBit(mithep::Track::TID2S);
351	>	stereoLayers.SetBit(mithep::Track::TID3S);
352	>	stereoLayers.SetBit(mithep::Track::TOB1S);
353	>	stereoLayers.SetBit(mithep::Track::TOB2S);
354	>	stereoLayers.SetBit(mithep::Track::TEC1S);
355	>	stereoLayers.SetBit(mithep::Track::TEC2S);
356	>	stereoLayers.SetBit(mithep::Track::TEC3S);
357	>	stereoLayers.SetBit(mithep::Track::TEC4S);
358	>	stereoLayers.SetBit(mithep::Track::TEC5S);
359	>	stereoLayers.SetBit(mithep::Track::TEC6S);
360	>	stereoLayers.SetBit(mithep::Track::TEC7S);
361	>	stereoLayers.SetBit(mithep::Track::TEC8S);
362	>	stereoLayers.SetBit(mithep::Track::TEC9S);
363	>	return stereoLayers;
364	>	}
365	>
366	>	//--------------------------------------------------------------------------------------------------
367	>	inline const mithep::BitMask48 mithep::Track::PixelLayers()
368		{
369	<	// Get reference to simulated particle.
369	>	// Build and return BitMask of stereo layers.
370
371	<	return static_cast<const MCParticle*>(fMCParticleRef.GetObject());
371	>	mithep::BitMask48 pixelLayers;
372	>	pixelLayers.SetBit(mithep::Track::PXB1);
373	>	pixelLayers.SetBit(mithep::Track::PXB2);
374	>	pixelLayers.SetBit(mithep::Track::PXB3);
375	>	pixelLayers.SetBit(mithep::Track::PXF1);
376	>	pixelLayers.SetBit(mithep::Track::PXF2);
377	>	return pixelLayers;
378		}
379		#endif

Diff Legend

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