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.13 by loizides, Mon Jul 14 20:55:19 2008 UTC vs.
Revision 1.16 by loizides, Fri Aug 29 01:51:01 2008 UTC

#	Line 3 | Line 3
3		//
4		// Track
5		//
6	<	// This will/must be re-written :-)
6	>	// We store the CMSSW track parameterization
7	>	// Parameters associated to the 5D curvilinear covariance matrix:
8	>	// (qoverp, lambda, phi, dxy, dsz)
9	>	// defined as:
10	>	// qoverp = q / abs(p) = signed inverse of momentum [1/GeV]
11	>	// lambda = pi/2 - polar angle at the given point
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	>	//
16	>	// Format for fHits: (We do not use anything resembling reco::HitPattern from CMSSW because that
17	>	// data format requires 800 bits per track!)
18	>	// There is a one to one mapping between bits and tracker layers, where layers are enumerated
19	>	// seperately in the PXB, PXF, TIB, TID, TOB, TEC and r-phi and stereo modules are treated as
20	>	// seperate layers in those detectors which have them
21	>	// (TIB L1,L2, TID L1,L2, TOB L1,L2, TEC L1,L2,L5).
22	>	//
23	>	// A bit value of 1 indicates a hit in the corresponding layer, and 0 indicates no hit.
24	>	//
25	>	// Note that currently this only stores information about hits in the Tracker,
26	>	// but muon chamber information will likely be added as well.
27	>	//
28	>	// Bit-Layer assignments (starting from bit 0):
29	>	// Bit  0: PXB L1
30	>	// Bit  1: PXB L2
31	>	// Bit  2: PXB L3
32	>	// Bit  3: PXF L1
33	>	// Bit  4: PXF L2
34	>	// Bit  5: TIB L1 r-phi
35	>	// Bit  6: TIB L1 stereo
36	>	// Bit  7: TIB L2 r-phi
37	>	// Bit  8: TIB L2 stereo
38	>	// Bit  9: TIB L3 r-phi
39	>	// Bit 10: TIB L4 r-phi
40	>	// Bit 11: TID L1 r-phi
41	>	// Bit 12: TID L1 stereo
42	>	// Bit 13: TID L2 r-phi
43	>	// Bit 14: TID L2 stereo
44	>	// Bit 15: TID L3 r-phi
45	>	// Bit 16: TOB L1 r-phi
46	>	// Bit 17: TOB L1 stereo
47	>	// Bit 18: TOB L2 r-phi
48	>	// Bit 19: TOB L2 stereo
49	>	// Bit 20: TOB L3 r-phi
50	>	// Bit 21: TOB L4 r-phi
51	>	// Bit 22: TOB L5 r-phi
52	>	// Bit 23: TOB L6 r-phi
53	>	// Bit 24: TEC L1 r-phi
54	>	// Bit 25: TEC L1 stereo
55	>	// Bit 26: TEC L2 r-phi
56	>	// Bit 27: TEC L2 stereo
57	>	// Bit 28: TEC L3 r-phi
58	>	// Bit 29: TEC L4 r-phi
59	>	// Bit 30: TEC L5 r-phi
60	>	// Bit 31: TEC L5 stereo
61	>	// Bit 32: TEC L6 r-phi
62	>	// Bit 33: TEC L7 r-phi
63	>	// Bit 34: TEC L8 r-phi
64	>	// Bit 35: TEC L9 r-phi
65		//
66		// Authors: C.Loizides, J.Bendavid, C.Paus
67		//--------------------------------------------------------------------------------------------------
#	Line 12 | Line 70
70		#define DATATREE_TRACK_H
71
72		#include "MitAna/DataTree/interface/DataObject.h"
73	<	#include "MitAna/DataTree/interface/SimParticle.h"
73	>	#include "MitAna/DataTree/interface/MCParticle.h"
74	>	#include "MitAna/DataTree/interface/BitMask32.h"
75	>	#include "MitAna/DataTree/interface/BitMask64.h"
76		#include "MitAna/DataTree/interface/Types.h"
77
78		namespace mithep
#	Line 20 | Line 80 | namespace mithep
80		class Track : public DataObject
81		{
82		public:
83	<	Track() : fPhi(0), fD0(0), fPt(0), fDz(0), fTheta(0), fPhiErr(0), fD0Err(0), fPtErr(0),
84	<	fDzErr(0), fThetaErr(0), fCharge(0) {}
85	<	Track(Double_t phi, Double_t d0, Double_t pt, Double_t dz, Double_t theta) :
86	<	fPhi(phi), fD0(d0), fPt(pt), fDz(dz), fTheta(theta), fPhiErr(0), fD0Err(0), fPtErr(0),
87	<	fDzErr(0), fThetaErr(0), fCharge(0) {}
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	>
120	>	Track() : fQOverP(0), fQOverPErr(0), fLambda(0), fLambdaErr(0),
121	>	fPhi0(0), fPhi0Err(0), fDxy(0), fDxyErr(0), fDsz(0), fDszErr(0),
122	>	fChi2(0), fNdof(0) {}
123	>	Track(Double_t qOverP, Double_t lambda, Double_t phi0, Double_t dxy, Double_t dsz) :
124	>	fQOverP(qOverP), fQOverPErr(0), fLambda(lambda), fLambdaErr(0),
125	>	fPhi0(phi0), fPhi0Err(0), fDxy(dxy), fDxyErr(0), fDsz(dsz), fDszErr(0),
126	>	fChi2(0), fNdof(0) {}
127		~Track() {}
128
129	<	Int_t              Charge()       const { return fCharge; }
130	<	Double_t           D0()           const { return fD0; }
131	<	Double_t           D0Err()        const { return fD0Err; }
132	<	Double_t           Dz()           const { return fDz; }
133	<	Double_t           DzErr()        const { return fDzErr; }
129	>	Double_t           QOverP()       const { return fQOverP; }
130	>	Double_t           QOverPErr()    const { return fQOverPErr; }
131	>	Double_t           Lambda()       const { return fLambda; }
132	>	Double_t           LambdaErr()    const { return fLambdaErr; }
133	>	Double_t           Phi0()         const { return fPhi0; }
134	>	Double_t           Phi0Err()      const { return fPhi0Err; }
135	>	Double_t           Dxy()          const { return fDxy; }
136	>	Double_t           DxyErr()       const { return fDxyErr; }
137	>	Double_t           Dsz()          const { return fDsz; }
138	>	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	<	Double_t           P2()           const { return Px()*Px()+Py()*Py()+Pz()*Pz(); }
153	<	Double_t           P()            const { return TMath::Sqrt(P2()); }
154	<	Double_t           Px()           const { return TMath::Cos(fPhi)*fabs(fPt); }
155	<	Double_t           Py()           const { return TMath::Sin(fPhi)*fabs(fPt); }
156	<	Double_t           Pz()           const { return TMath::Abs(fPt)/TMath::Tan(fTheta); }
157	<	Double_t           Phi()          const { return fPhi; }
158	<	Double_t           PhiErr()       const { return fPhiErr; }
159	<	Double_t           Pt()           const { return fPt; }
160	<	Double_t           PtErr()        const { return fPtErr; }
161	<	Double_t           Theta()        const { return fTheta; }
162	<	Double_t           ThetaErr()     const { return fThetaErr; }
163	<
164	<	FourVector         Mom4(double m) const { return FourVector(Px(),Py(),Pz(),E(m)); }
165	<	Double_t           E2(double m)   const { return P2()+m*m; }
166	<	Double_t           E(double m)    const { return TMath::Sqrt(E2(m)); }
167	<
168	<	void               SetCharge(Int_t charge) { fCharge = charge; }
169	<	void               SetHelix (Double_t phi, Double_t d0, Double_t pt,
170	<	Double_t dz, Double_t theta);
171	<	void               SetErrors(Double_t phiErr, Double_t d0Err, Double_t ptErr,
172	<	Double_t dzErr, Double_t thetaErr);
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; }
177	>	Double_t           E(Double_t m)    const { return TMath::Sqrt(E2(m)); }
178	>	UInt_t             NHits()          const { return fHits.NBitsSet(); }
179	>
180	>	void               SetHelix (Double_t qOverP, Double_t lambda, Double_t phi0,
181	>	Double_t dXy, Double_t dSz);
182	>	void               SetErrors(Double_t qOverPErr, Double_t lambdaErr, Double_t phi0Err,
183	>	Double_t dXyErr, Double_t dSzErr);
184
185	<	const SimParticle *SimPart()      const;
186	<	void               SetSimPart(SimParticle *p) { fSimParticleRef = p; }
185	>	const MCParticle  *MCPart()      const;
186	>	void               SetMCPart(MCParticle *p) { fMCParticleRef = p; }
187
188		protected:
189	<	Double_t           fPhi;            //azimuthal angle
190	<	Double_t           fD0;             //raw impact parameter
191	<	Double_t           fPt;             //transverse momentum
192	<	Double_t           fDz;             //z-displacement
193	<	Double_t           fTheta;          //polar angle
194	<	Double_t           fPhiErr;         //uncertainy on phi
195	<	Double_t           fD0Err;          //uncertainty on D0
196	<	Double_t           fPtErr;          //uncertainty on pt
197	<	Double_t           fDzErr;          //uncertainty on dz
198	<	Double_t           fThetaErr;       //uncertainty on theta
199	<	Int_t              fCharge;         //electric charge of reconstructed track
200	<	TRef               fSimParticleRef; //reference to sim particle (for monte carlo)
189	>	// Constant which is store in the file
190	>	BitMask64          fHits;                // Mostly Hit informations
191	>	BitMask32          fStat;                // Storage for various interesting things
192	>	Double_t           fQOverP, fQOverPErr;
193	>	Double_t           fLambda, fLambdaErr;
194	>	Double_t           fPhi0,fPhi0Err;       // Follow track parameters/uncertainties
195	>	Double_t           fDxy,  fDxyErr;
196	>	Double_t           fDsz,  fDszErr;
197	>
198	>	Double_t           fChi2; //chi squared of track fit
199	>	UInt_t             fNdof; //number of dof of track fit
200	>
201	>	TRef               fMCParticleRef; //reference to sim particle (for monte carlo)
202
203		ClassDef(Track, 1) // Track class
204		};
#	Line 78 | Line 206 | namespace mithep
206
207		//--------------------------------------------------------------------------------------------------
208		inline
209	<	void mithep::Track::SetHelix(Double_t phi, Double_t d0, Double_t pt, Double_t dz, Double_t theta)
209	>	void mithep::Track::SetHelix(Double_t qOverP, Double_t lambda, Double_t phi0,
210	>	Double_t dxy, Double_t dsz)
211		{
212		// Set helix parameters.
213
214	<	fPhi   = phi;
215	<	fD0    = d0;
216	<	fPt    = pt;
217	<	fDz    = dz;
218	<	fTheta = theta;
214	>	fQOverP = qOverP;
215	>	fLambda = lambda;
216	>	fPhi0   = phi0;
217	>	fDxy    = dxy;
218	>	fDsz    = dsz;
219		}
220
221		//--------------------------------------------------------------------------------------------------
222		inline
223	<	void mithep::Track::SetErrors(Double_t phiErr, Double_t d0Err, Double_t ptErr, Double_t dzErr,
224	<	Double_t thetaErr)
223	>	void mithep::Track::SetErrors(Double_t qOverPErr, Double_t lambdaErr, Double_t phi0Err,
224	>	Double_t dxyErr, Double_t dszErr)
225		{
226		// Set helix errors.
227
228	<	fPhiErr   = phiErr;
229	<	fD0Err    = d0Err;
230	<	fPtErr    = ptErr;
231	<	fDzErr    = dzErr;
232	<	fThetaErr = thetaErr;
228	>	fQOverPErr = qOverPErr;
229	>	fLambdaErr = lambdaErr;
230	>	fPhi0Err   = phi0Err;
231	>	fDxyErr    = dxyErr;
232	>	fDszErr    = dszErr;
233		}
234
235		//--------------------------------------------------------------------------------------------------
236		inline
237	<	const mithep::SimParticle *mithep::Track::SimPart() const
237	>	const mithep::MCParticle *mithep::Track::MCPart() const
238		{
239		// Get reference to simulated particle.
240
241	<	return static_cast<const SimParticle*>(fSimParticleRef.GetObject());
241	>	return static_cast<const MCParticle*>(fMCParticleRef.GetObject());
242		}
243		#endif

Diff Legend

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