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.55 by paus, Thu Mar 29 23:41:55 2012 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,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	>	//
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: 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/SuperCluster.h"
86
87		namespace mithep
88		{
89		class Track : public DataObject
90		{
91		public:
92	<	Track() {}
93	<	Track(Double_t phi, Double_t d0, Double_t pt, Double_t dz, Double_t theta) :
94	<	fPhi(phi), fD0(d0), fPt(pt), fDz(dz), fTheta(theta) {}
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() : fNHits(0), fNPixelHits(0), fNMissingHits(0), fNExpectedHitsInner(0), fNExpectedHitsOuter(0),
173	>	fAlgo(undefAlgorithm), fIsGsf(0), fPtErr(0), fQOverP(0), fQOverPErr(0),
174	>	fLambda(0), fLambdaErr(0), fPhi0(0), fPhi0Err(0),
175	>	fDxy(0), fDxyErr(0), fDsz(0), fDszErr(0), fChi2(0),
176	>	fNdof(0), fEtaEcal(0), fPhiEcal(0) {}
177	>	Track(Double_t qOverP, Double_t lambda, Double_t phi0, Double_t dxy, Double_t dsz) :
178	>	fNHits(0), fNPixelHits(0), fNMissingHits(0), fNExpectedHitsInner(0), fNExpectedHitsOuter(0),
179	>	fAlgo(undefAlgorithm), fIsGsf(0), fPtErr(0), fQOverP(qOverP), fQOverPErr(0),
180	>	fLambda(lambda), fLambdaErr(0), fPhi0(phi0), fPhi0Err(0),
181	>	fDxy(dxy), fDxyErr(0), fDsz(dsz), fDszErr(0), fChi2(0),
182	>	fNdof(0), fEtaEcal(0), fPhiEcal(0) {}
183		~Track() {}
184
185	<	void      SetHelix (Double_t phi, Double_t d0, Double_t pt, Double_t dz, Double_t theta);
186	<	void      SetErrors(Double_t phiErr, Double_t d0Err, Double_t ptErr, Double_t dzErr,
187	<	Double_t thetaErr);
188	<
189	<	Double_t  Phi()      const { return fPhi; }
190	<	Double_t  D0()       const { return fD0; }
191	<	Double_t  Pt()       const { return fPt; }
192	<	Double_t  Dz()       const { return fDz; }
193	<	Double_t  Theta()    const { return fTheta; }
194	<
195	<	Double_t  PhiErr()   const { return fPhiErr; }
196	<	Double_t  D0Err()    const { return fD0Err; }
197	<	Double_t  PtErr()    const { return fPtErr; }
198	<	Double_t  DzErr()    const { return fDzErr; }
199	<	Double_t  ThetaErr() const { return fThetaErr; }
200	<
201	<	Int_t     Charge()   const { return fCharge; }
202	<
203	<	void      SetCharge(Int_t charge) { fCharge = charge; }
204	<
185	>	ETrackAlgorithm      Algo()           const { return fAlgo;                 }
186	>	Int_t                Charge()         const { return (fQOverP>0) ? 1 : -1;  }
187	>	Double_t             Chi2()           const { return fChi2;                 }
188	>	void                 ClearHit(EHitLayer l)  { fHits.ClearBit(l);            }
189	>	Double_t             D0()             const { return -fDxy;                 }
190	>	Double_t             D0Corrected(const BaseVertex &iVertex) const;
191	>	Double_t             DzCorrected(const BaseVertex &iVertex) const;
192	>	Double_t             D0Err()          const { return fDxyErr;               }
193	>	Double_t             Dsz()            const { return fDsz;                  }
194	>	Double_t             DszErr()         const { return fDszErr;               }
195	>	Double_t             Dxy()            const { return fDxy;                  }
196	>	Double_t             DxyErr()         const { return fDxyErr;               }
197	>	Double_t             E(Double_t m)    const { return TMath::Sqrt(E2(m));    }
198	>	Double_t             E2(Double_t m)   const { return P2()+m*m;              }
199	>	Double_t             Eta()            const { return Mom().Eta();           }
200	>	Double_t             EtaEcal()        const { return fEtaEcal;              }
201	>	Bool_t               Hit(EHitLayer l) const { return fHits.TestBit(l);      }
202	>	const BitMask48     &Hits()           const { return fHits;                 }
203	>	const BitMask48     &MissingHits()    const { return fMissingHits;          }
204	>	const BitMask48     &ExpectedHitsInner() const { return fExpectedHitsInner; }
205	>	const BitMask48     &ExpectedHitsOuter() const { return fExpectedHitsOuter; }
206	>	Bool_t               IsGsf()          const { return fIsGsf;                }
207	>	Double_t             Lambda()         const { return fLambda;               }
208	>	Double_t             LambdaErr()      const { return fLambdaErr;            }
209	>	const MCParticle    *MCPart()         const { return fMCParticleRef.Obj();  }
210	>	const ThreeVectorC  &Mom()            const;
211	>	FourVectorM          Mom4(Double_t m) const { return FourVectorM(Pt(),Eta(),Phi(),m); }
212	>	UShort_t             Ndof()           const { return fNdof;                              }
213	>	UInt_t               NHits()          const { if (fNHits) return fNHits; else return fHits.NBitsSet(); }
214	>	UInt_t               NMissingHits()   const { if (fNMissingHits) return fNMissingHits; else return fMissingHits.NBitsSet(); }
215	>	UInt_t               NExpectedHitsInner() const { if (fNExpectedHitsInner) return fNExpectedHitsInner; else return fExpectedHitsInner.NBitsSet(); }
216	>	UInt_t               NExpectedHitsOuter() const { if (fNExpectedHitsOuter) return fNExpectedHitsOuter; else return fExpectedHitsOuter.NBitsSet(); }
217	>	UInt_t               NStereoHits()    const { return StereoHits().NBitsSet();            }
218	>	UInt_t               NPixelHits()     const { if (fNPixelHits) return fNPixelHits; else return PixelHits().NBitsSet(); }
219	>	EObjType             ObjType()        const { return kTrack;                             }
220	>	Double_t             P2()             const { return 1./fQOverP/fQOverP;                 }
221	>	Double_t             P()              const { return TMath::Abs(1./fQOverP);             }
222	>	Double_t             Phi()            const { return fPhi0;                              }
223	>	Double_t             Phi0()           const { return fPhi0;                              }
224	>	Double_t             Phi0Err()        const { return fPhi0Err;                           }
225	>	Double_t             PhiEcal()        const { return fPhiEcal;                           }
226	>	Double_t             Prob()           const { return TMath::Prob(fChi2,fNdof);           }
227	>	Double_t             Pt()             const { return Mom().Rho();                        }
228	>	Double_t             PtErr()          const { return fPtErr;                             }
229	>	Double_t             Px()             const { return Mom().X();                          }
230	>	Double_t             Py()             const { return Mom().Y();                          }
231	>	Double_t             Pz()             const { return Mom().Z();                          }
232	>	Double_t             QOverP()         const { return fQOverP;                            }
233	>	Double_t             QOverPErr()      const { return fQOverPErr;                         }
234	>	Double_t             RChi2()          const { return fChi2/(Double_t)fNdof; }
235	>	Double_t             Theta()          const { return (TMath::PiOver2() - fLambda);       }
236	>	const SuperCluster  *SCluster()       const { return fSuperClusterRef.Obj();             }
237	>	const BitMask48      PixelHits()      const { return (fHits & PixelLayers());            }
238	>	const TrackQuality  &Quality()        const { return fQuality;                           }
239	>	TrackQuality        &Quality()              { return fQuality;                           }
240	>	const BitMask48      StereoHits()     const { return (fHits & StereoLayers());           }
241	>	void                 SetAlgo(ETrackAlgorithm e)          { fAlgo = e;                    }
242	>	void                 SetChi2(Double_t chi2)              { fChi2 = chi2;                 }
243	>	void                 SetErrors(Double_t qOverPErr, Double_t lambdaErr, Double_t phi0Err,
244	>	Double_t dXyErr, Double_t dSzErr);
245	>	void                 SetEtaEcal(Double_t eta)            { fEtaEcal = eta;               }
246	>	void                 SetHelix (Double_t qOverP, Double_t lambda, Double_t phi0,
247	>	Double_t dXy, Double_t dSz);
248	>	void                 SetPtErr(Double_t ptErr)            { fPtErr = ptErr;               }
249	>	void                 SetHit(EHitLayer l)                 { fHits.SetBit(l);              }
250	>	void                 SetHits(const BitMask48 &hits)      { fHits = hits;                 }
251	>	void                 SetMissingHits(const BitMask48 &h)  { fMissingHits = h;             }
252	>	void                 SetExpectedHitsInner(const BitMask48 &h) { fExpectedHitsInner = h;  }
253	>	void                 SetExpectedHitsOuter(const BitMask48 &h) { fExpectedHitsOuter = h;  }
254	>	void                 SetIsGsf(Bool_t b)                  { fIsGsf = b;                   }
255	>	void                 SetNHits(Byte_t n)                  { fNHits = n;                   }
256	>	void                 SetNPixelHits(Byte_t n)             { fNPixelHits = n;              }
257	>	void                 SetNMissingHits(Byte_t n)           { fNMissingHits = n;            }
258	>	void                 SetNExpectedHitsInner(Byte_t n)     { fNExpectedHitsInner = n;      }
259	>	void                 SetNExpectedHitsOuter(Byte_t n)     { fNExpectedHitsOuter = n;      }
260	>	void                 SetNdof(UShort_t dof)               { fNdof = dof;                  }
261	>	void                 SetMCPart(const MCParticle *p)      { fMCParticleRef = p;           }
262	>	void                 SetPhiEcal(Double_t phi)            { fPhiEcal = phi;               }
263	>	void                 SetSCluster(const SuperCluster* sc) { fSuperClusterRef = sc;        }
264	>	Double_t             X0()             const { return  D0()*TMath::Sin(Phi());            }
265	>	Double_t             Y0()             const { return -D0()*TMath::Cos(Phi());            }
266	>	Double_t             Z0()             const { return fDsz/TMath::Cos(fLambda);           }
267	>
268	>
269	>	static const BitMask48      StereoLayers();
270	>	static const BitMask48      PixelLayers();
271	>
272	>	// Some structural tools
273	>	void                 Mark(UInt_t i=1) const;
274	>
275		protected:
276	<	Double_t fPhi;      // azimuthal angle
277	<	Double_t fD0;       // raw impact parameter
278	<	Double_t fPt;       // transverse momentum
279	<	Double_t fDz;       // z-displacement
280	<	Double_t fTheta;    // polar angle
281	<	Double_t fPhiErr;   // uncertainy on phi
282	<	Double_t fD0Err;    // uncertainty on D0
283	<	Double_t fPtErr;    // uncertainty on pt
284	<	Double_t fDzErr;    // uncertainty on dz
285	<	Double_t fThetaErr; // uncertainty on theta
286	<	Int_t    fCharge;   // electric charge of reconstructed track
276	>	void                 ClearMom()       const { fCacheMomFlag.ClearCache(); }
277	>	void                 GetMom()         const;
278	>
279	>	BitMask48            fHits;                //storage for mostly hit information
280	>	BitMask48            fMissingHits;         //missing hits in crossed good modules
281	>	BitMask48            fExpectedHitsInner;   //expected hits before first hit
282	>	BitMask48            fExpectedHitsOuter;   //expected hits after last hit
283	>	Byte_t               fNHits;               //number of valid hits
284	>	Byte_t               fNPixelHits;          //number of valid pixel hits
285	>	Byte_t               fNMissingHits;        //number of missing hits
286	>	Byte_t               fNExpectedHitsInner;  //number of expected inner hits
287	>	Byte_t               fNExpectedHitsOuter;  //number of expected outer hits
288	>	ETrackAlgorithm      fAlgo;                //track algorithm
289	>	TrackQuality         fQuality;             //track quality
290	>	Bool_t               fIsGsf;               //flag to identify gsf tracks
291	>	Double32_t           fPtErr;               //[0,0,12]pt uncertainty
292	>	Double32_t           fQOverP;              //[0,0,14]signed inverse of momentum [1/GeV]
293	>	Double32_t           fQOverPErr;           //[0,0,14]error of q/p
294	>	Double32_t           fLambda;              //[0,0,14]pi/2 - polar angle at the reference point
295	>	Double32_t           fLambdaErr;           //[0,0,14]error of lambda
296	>	Double32_t           fPhi0;                //[0,0,14]azimuth angle at the given point
297	>	Double32_t           fPhi0Err;             //[0,0,14]error of azimuthal angle
298	>	Double32_t           fDxy;                 //[0,0,14]trans. distance to reference point [cm]
299	>	Double32_t           fDxyErr;              //[0,0,14]error of transverse distance
300	>	Double32_t           fDsz;                 //[0,0,14]long. distance to reference point [cm]
301	>	Double32_t           fDszErr;              //[0,0,14]error of longitudinal distance
302	>	Double32_t           fChi2;                //[0,0,12]chi squared of track fit
303	>	UShort_t             fNdof;                //degree-of-freedom of track fit
304	>	Double32_t           fEtaEcal;             //[0,0,12]eta of track at Ecal front face
305	>	Double32_t           fPhiEcal;             //[0,0,12]phi of track at Ecal front face
306	>	Ref<SuperCluster>    fSuperClusterRef;     //superCluster crossed by track
307	>	Ref<MCParticle>      fMCParticleRef;       //reference to sim particle (for monte carlo)
308	>	mutable CacheFlag    fCacheMomFlag;        //||cache validity flag for momentum
309	>	mutable ThreeVectorC fCachedMom;           //!cached momentum vector
310
311	<	ClassDef(Track, 1) // Track class
311	>	ClassDef(Track, 6) // Track class
312		};
313		}
314
315		//--------------------------------------------------------------------------------------------------
316	<	inline
317	<	void mithep::Track::SetHelix(Double_t phi, Double_t d0, Double_t pt, Double_t dz, Double_t theta)
316	>	inline void mithep::Track::Mark(UInt_t ib) const
317	>	{
318	>	// mark myself
319	>	mithep::DataObject::Mark(ib);
320	>	// mark my dependencies if they are there
321	>	if (fSuperClusterRef.IsValid())
322	>	fSuperClusterRef.Obj()->Mark(ib);
323	>	if (fMCParticleRef.IsValid())
324	>	fMCParticleRef.Obj()->Mark(ib);
325	>	}
326	>
327	>	//--------------------------------------------------------------------------------------------------
328	>	inline void mithep::Track::GetMom() const
329	>	{
330	>	// Compute three momentum.
331	>
332	>	Double_t pt = TMath::Abs(TMath::Cos(fLambda)/fQOverP);
333	>	Double_t eta = - TMath::Log(TMath::Tan(Theta()/2.));
334	>	fCachedMom.SetCoordinates(pt,eta,Phi());
335	>	}
336	>
337	>	//--------------------------------------------------------------------------------------------------
338	>	inline const mithep::ThreeVectorC &mithep::Track::Mom() const
339	>	{
340	>	// Return cached momentum value.
341	>
342	>	if (!fCacheMomFlag.IsValid()) {
343	>	GetMom();
344	>	fCacheMomFlag.SetValid();
345	>	}
346	>	return fCachedMom;
347	>	}
348	>
349	>	//--------------------------------------------------------------------------------------------------
350	>	inline Double_t mithep::Track::D0Corrected(const BaseVertex &iVertex) const
351	>	{
352	>	// Return corrected d0 with respect to primary vertex or beamspot.
353	>
354	>	Double_t lXM =  -TMath::Sin(Phi()) * D0();
355	>	Double_t lYM =   TMath::Cos(Phi()) * D0();
356	>	Double_t lDX = (lXM + iVertex.X());
357	>	Double_t lDY = (lYM + iVertex.Y());
358	>	Double_t d0Corr = (Px()*lDY - Py()*lDX)/Pt();
359	>
360	>	return d0Corr;
361	>	}
362	>
363	>	//--------------------------------------------------------------------------------------------------
364	>	inline Double_t mithep::Track::DzCorrected(const mithep::BaseVertex &iVertex) const
365	>	{
366	>	// Compute Dxy with respect to a given position
367	>	mithep::ThreeVector momPerp(Px(),Py(),0);
368	>	mithep::ThreeVector posPerp(X0()-iVertex.X(),Y0()-iVertex.Y(),0);
369	>	return Z0() - iVertex.Z() - posPerp.Dot(momPerp)/Pt() * (Pz()/Pt());
370	>
371	>	}
372	>
373	>	//--------------------------------------------------------------------------------------------------
374	>	inline void mithep::Track::SetHelix(Double_t qOverP, Double_t lambda, Double_t phi0,
375	>	Double_t dxy, Double_t dsz)
376		{
377	<	fPhi   = phi;
378	<	fD0    = d0;
379	<	fPt    = pt;
380	<	fDz    = dz;
381	<	fTheta = theta;
377	>	// Set helix parameters.
378	>
379	>	fQOverP = qOverP;
380	>	fLambda = lambda;
381	>	fPhi0   = phi0;
382	>	fDxy    = dxy;
383	>	fDsz    = dsz;
384	>	ClearMom();
385	>	}
386	>
387	>	//--------------------------------------------------------------------------------------------------
388	>	inline void mithep::Track::SetErrors(Double_t qOverPErr, Double_t lambdaErr, Double_t phi0Err,
389	>	Double_t dxyErr, Double_t dszErr)
390	>	{
391	>	// Set helix errors.
392	>
393	>	fQOverPErr = qOverPErr;
394	>	fLambdaErr = lambdaErr;
395	>	fPhi0Err   = phi0Err;
396	>	fDxyErr    = dxyErr;
397	>	fDszErr    = dszErr;
398		}
399
400		//--------------------------------------------------------------------------------------------------
401	<	inline
402	<	void mithep::Track::SetErrors(Double_t phiErr, Double_t d0Err, Double_t ptErr, Double_t dzErr,
403	<	Double_t thetaErr)
404	<	{
405	<	fPhiErr   = phiErr;
406	<	fD0Err    = d0Err;
407	<	fPtErr    = ptErr;
408	<	fDzErr    = dzErr;
409	<	fThetaErr = thetaErr;
401	>	inline const mithep::BitMask48 mithep::Track::StereoLayers()
402	>	{
403	>	// Build and return BitMask of stereo layers.
404	>
405	>	mithep::BitMask48 stereoLayers;
406	>	stereoLayers.SetBit(mithep::Track::TIB1S);
407	>	stereoLayers.SetBit(mithep::Track::TIB2S);
408	>	stereoLayers.SetBit(mithep::Track::TID1S);
409	>	stereoLayers.SetBit(mithep::Track::TID2S);
410	>	stereoLayers.SetBit(mithep::Track::TID3S);
411	>	stereoLayers.SetBit(mithep::Track::TOB1S);
412	>	stereoLayers.SetBit(mithep::Track::TOB2S);
413	>	stereoLayers.SetBit(mithep::Track::TEC1S);
414	>	stereoLayers.SetBit(mithep::Track::TEC2S);
415	>	stereoLayers.SetBit(mithep::Track::TEC3S);
416	>	stereoLayers.SetBit(mithep::Track::TEC4S);
417	>	stereoLayers.SetBit(mithep::Track::TEC5S);
418	>	stereoLayers.SetBit(mithep::Track::TEC6S);
419	>	stereoLayers.SetBit(mithep::Track::TEC7S);
420	>	stereoLayers.SetBit(mithep::Track::TEC8S);
421	>	stereoLayers.SetBit(mithep::Track::TEC9S);
422	>	return stereoLayers;
423	>	}
424	>
425	>	//--------------------------------------------------------------------------------------------------
426	>	inline const mithep::BitMask48 mithep::Track::PixelLayers()
427	>	{
428	>	// Build and return BitMask of stereo layers.
429	>
430	>	mithep::BitMask48 pixelLayers;
431	>	pixelLayers.SetBit(mithep::Track::PXB1);
432	>	pixelLayers.SetBit(mithep::Track::PXB2);
433	>	pixelLayers.SetBit(mithep::Track::PXB3);
434	>	pixelLayers.SetBit(mithep::Track::PXF1);
435	>	pixelLayers.SetBit(mithep::Track::PXF2);
436	>	return pixelLayers;
437		}
438		#endif

Diff Legend

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