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.7 by loizides, Wed Jun 18 19:08:14 2008 UTC vs.
Revision 1.19 by bendavid, Mon Sep 22 10:39:54 2008 UTC

#	Line 3 | Line 3
3		//
4		// Track
5		//
6	<	// This will 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	>	// (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).
23	>	//
24	>	// A bit value of 1 indicates a hit in the corresponding layer, and 0 indicates no hit.
25	>	//
26	>	// Note that currently this only stores information about hits in the Tracker,
27	>	// but muon chamber information will likely be added as well.
28	>	//
29	>	// Bit-Layer assignments (starting from bit 0):
30	>	// Bit  0: PXB L1
31	>	// Bit  1: PXB L2
32	>	// Bit  2: PXB L3
33	>	// Bit  3: PXF L1
34	>	// Bit  4: PXF L2
35	>	// Bit  5: TIB L1 r-phi
36	>	// Bit  6: TIB L1 stereo
37	>	// Bit  7: TIB L2 r-phi
38	>	// Bit  8: TIB L2 stereo
39	>	// Bit  9: TIB L3 r-phi
40	>	// Bit 10: TIB L4 r-phi
41	>	// Bit 11: TID L1 r-phi
42	>	// Bit 12: TID L1 stereo
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
66		//
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/BitMask.h"
76	+	#include "MitAna/DataTree/interface/Types.h"
77
78		namespace mithep
79		{
80		class Track : public DataObject
81		{
82		public:
83	<	Track() {}
84	<	Track(Double_t phi, Double_t d0, Double_t pt, Double_t dz, Double_t theta) :
85	<	fPhi(phi), fD0(d0), fPt(pt), fDz(dz), fTheta(theta) {}
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) {}
125	>	Track(Double_t qOverP, Double_t lambda, Double_t phi0, Double_t dxy, Double_t dsz) :
126	>	fQOverP(qOverP), fQOverPErr(0), fLambda(lambda), fLambdaErr(0),
127	>	fPhi0(phi0), fPhi0Err(0), fDxy(dxy), fDxyErr(0), fDsz(dsz), fDszErr(0),
128	>	fChi2(0), fNdof(0) {}
129		~Track() {}
130
131	<	void      SetHelix (Double_t phi, Double_t d0, Double_t pt, Double_t dz, Double_t theta);
132	<	void      SetErrors(Double_t phiErr, Double_t d0Err, Double_t ptErr, Double_t dzErr,
133	<	Double_t thetaErr);
134	<
135	<	Double_t  Phi()      const { return fPhi; }
136	<	Double_t  D0()       const { return fD0; }
137	<	Double_t  Pt()       const { return fPt; }
138	<	Double_t  Dz()       const { return fDz; }
139	<	Double_t  Theta()    const { return fTheta; }
140	<
141	<	Double_t  PhiErr()   const { return fPhiErr; }
142	<	Double_t  D0Err()    const { return fD0Err; }
143	<	Double_t  PtErr()    const { return fPtErr; }
144	<	Double_t  DzErr()    const { return fDzErr; }
145	<	Double_t  ThetaErr() const { return fThetaErr; }
146	<
147	<	Int_t     Charge()   const { return fCharge; }
148	<
149	<	void      SetCharge(Int_t charge) { fCharge = charge; }
150	<
131	>	Int_t              Charge()         const { return (fQOverP>0) ? 1 : -1; }
132	>	Double_t           Chi2()           const { return fChi2; }
133	>	void               ClearHit(EHitLayer l)  { fHits.ClearBit(l); }
134	>	Double_t           D0()             const { return -fDxy; }
135	>	Double_t           D0Err()          const { return fDxyErr; }
136	>	Double_t           Dsz()            const { return fDsz; }
137	>	Double_t           DszErr()         const { return fDszErr; }
138	>	Double_t           Dxy()            const { return fDxy; }
139	>	Double_t           DxyErr()         const { return fDxyErr; }
140	>	Double_t           E(Double_t m)    const { return TMath::Sqrt(E2(m)); }
141	>	Double_t           E2(Double_t m)   const { return P2()+m*m; }
142	>	Bool_t             Hit(EHitLayer l) const { return fHits.TestBit(l); }
143	>	Double_t           Lambda()         const { return fLambda; }
144	>	Double_t           LambdaErr()      const { return fLambdaErr; }
145	>	const MCParticle  *MCPart()         const;
146	>	ThreeVector        Mom()            const { return ThreeVector(Px(),Py(),Pz()); }
147	>	FourVector         Mom4(Double_t m) const { return FourVector(Px(),Py(),Pz(),E(m)); }
148	>	UInt_t             Ndof()           const { return fNdof; }
149	>	UInt_t             NHits()          const { return fHits.NBitsSet(); }
150	>	Double_t           P2()             const { return P()*P(); }
151	>	Double_t           P()              const { return TMath::Abs(1./fQOverP); }
152	>	Double_t           Phi()            const { return fPhi0; }
153	>	Double_t           Phi0()           const { return fPhi0; }
154	>	Double_t           Phi0Err()        const { return fPhi0Err; }
155	>	Double_t           Prob()           const { return TMath::Prob(fChi2,fNdof); }
156	>	Double_t           Pt()             const { return TMath::Abs(TMath::Cos(fLambda)/fQOverP); }
157	>	Double_t           Px()             const { return Pt()*TMath::Cos(fPhi0); }
158	>	Double_t           Py()             const { return Pt()*TMath::Sin(fPhi0); }
159	>	Double_t           Pz()             const { return P()*TMath::Sin(fLambda); }
160	>	Double_t           QOverP()         const { return fQOverP; }
161	>	Double_t           QOverPErr()      const { return fQOverPErr; }
162	>	Double_t           Theta()          const { return (TMath::PiOver2() - fLambda); }
163	>	Double_t           Z0()             const { return fDsz/TMath::Cos(fLambda); }
164	>	void               SetChi2(Double_t chi2) { fChi2 = chi2; }
165	>	void               SetErrors(Double_t qOverPErr, Double_t lambdaErr, Double_t phi0Err,
166	>	Double_t dXyErr, Double_t dSzErr);
167	>	void               SetHelix (Double_t qOverP, Double_t lambda, Double_t phi0,
168	>	Double_t dXy, Double_t dSz);
169	>	void               SetHit(EHitLayer l)      { fHits.SetBit(l); }
170	>	void               SetNdof(UInt_t dof)      { fNdof = dof; }
171	>	void               SetMCPart(MCParticle *p) { fMCParticleRef = p; }
172	>
173		protected:
174	<	Double_t fPhi;      // azimuthal angle
175	<	Double_t fD0;       // raw impact parameter
176	<	Double_t fPt;       // transverse momentum
177	<	Double_t fDz;       // z-displacement
178	<	Double_t fTheta;    // polar angle
179	<	Double_t fPhiErr;   // uncertainy on phi
180	<	Double_t fD0Err;    // uncertainty on D0
181	<	Double_t fPtErr;    // uncertainty on pt
182	<	Double_t fDzErr;    // uncertainty on dz
183	<	Double_t fThetaErr; // uncertainty on theta
184	<	Int_t    fCharge;   // electric charge of reconstructed track
174	>	BitMask64          fHits;                //storage for mostly hit information
175	>	Double_t           fQOverP;              //signed inverse of momentum [1/GeV]
176	>	Double_t           fQOverPErr;           //error of q/p
177	>	Double_t           fLambda;              //pi/2 - polar angle at the reference point
178	>	Double_t           fLambdaErr;           //error of lambda
179	>	Double_t           fPhi0;                //azimuth angle at the given point
180	>	Double_t           fPhi0Err;             //error of azimuthal angle
181	>	Double_t           fDxy;                 //transverse distance to reference point [cm]
182	>	Double_t           fDxyErr;              //error of transverse distance
183	>	Double_t           fDsz;                 //longitudinal distance to reference point [cm]
184	>	Double_t           fDszErr;              //error of longitudinal distance
185	>	Double_t           fChi2;                //chi squared of track fit
186	>	UInt_t             fNdof;                //degree-of-freedom of track fit
187	>	TRef               fMCParticleRef;       //reference to sim particle (for monte carlo)
188
189	<	ClassDef(Track, 1) // Track class
189	>	ClassDef(Track, 1) // Track class
190		};
191		}
192
193		//--------------------------------------------------------------------------------------------------
194		inline
195	<	void mithep::Track::SetHelix(Double_t phi, Double_t d0, Double_t pt, Double_t dz, Double_t theta)
195	>	void mithep::Track::SetHelix(Double_t qOverP, Double_t lambda, Double_t phi0,
196	>	Double_t dxy, Double_t dsz)
197		{
198	<	fPhi   = phi;
199	<	fD0    = d0;
200	<	fPt    = pt;
201	<	fDz    = dz;
202	<	fTheta = theta;
198	>	// Set helix parameters.
199	>
200	>	fQOverP = qOverP;
201	>	fLambda = lambda;
202	>	fPhi0   = phi0;
203	>	fDxy    = dxy;
204	>	fDsz    = dsz;
205		}
206
207		//--------------------------------------------------------------------------------------------------
208		inline
209	<	void mithep::Track::SetErrors(Double_t phiErr, Double_t d0Err, Double_t ptErr, Double_t dzErr,
210	<	Double_t thetaErr)
209	>	void mithep::Track::SetErrors(Double_t qOverPErr, Double_t lambdaErr, Double_t phi0Err,
210	>	Double_t dxyErr, Double_t dszErr)
211		{
212	<	fPhiErr   = phiErr;
213	<	fD0Err    = d0Err;
214	<	fPtErr    = ptErr;
215	<	fDzErr    = dzErr;
216	<	fThetaErr = thetaErr;
212	>	// Set helix errors.
213	>
214	>	fQOverPErr = qOverPErr;
215	>	fLambdaErr = lambdaErr;
216	>	fPhi0Err   = phi0Err;
217	>	fDxyErr    = dxyErr;
218	>	fDszErr    = dszErr;
219	>	}
220	>
221	>	//--------------------------------------------------------------------------------------------------
222	>	inline
223	>	const mithep::MCParticle *mithep::Track::MCPart() const
224	>	{
225	>	// Get reference to simulated particle.
226	>
227	>	return static_cast<const MCParticle*>(fMCParticleRef.GetObject());
228		}
229		#endif

Diff Legend

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