DataTree/interface/Track.h

//--------------------------------------------------------------------------------------------------
// $Id: Track.h,v 1.22 2008/10/13 10:34:00 bendavid Exp $
//
// Track
//
// We store the CMSSW track parameterization
// Parameters associated to the 5D curvilinear covariance matrix:
// (qoverp, lambda, phi, dxy, dsz)
// defined as:
// qoverp = q / abs(p) = signed inverse of momentum [1/GeV]
// lambda = pi/2 - polar angle at the given point
// phi = azimuth angle at the given point
// dxy = -vx*sin(phi) + vy*cos(phi) [cm]
// dsz = vz*cos(lambda) - (vx*cos(phi)+vy*sin(phi))*sin(lambda) [cm]
// (See http://cmslxr.fnal.gov/lxr/source/DataFormats/TrackReco/interface/TrackBase.h)
//
// Format for fHits: (We do not use anything resembling reco::HitPattern from CMSSW because that
// data format requires 800 bits per track!)
// There is a one to one mapping between bits and tracker layers, where layers are enumerated
// seperately in the PXB, PXF, TIB, TID, TOB, TEC and r-phi and stereo modules are treated as
// seperate layers in those detectors which have them
// (TIB L1,L2, TID L1,L2, TOB L1,L2, TEC L1,L2,L5).
// 
// A bit value of 1 indicates a hit in the corresponding layer, and 0 indicates no hit.
//
// Note that currently this only stores information about hits in the Tracker,
// but muon chamber information will likely be added as well.
//
// Bit-Layer assignments (starting from bit 0):
// Bit  0: PXB L1
// Bit  1: PXB L2
// Bit  2: PXB L3
// Bit  3: PXF L1
// Bit  4: PXF L2
// Bit  5: TIB L1 r-phi
// Bit  6: TIB L1 stereo
// Bit  7: TIB L2 r-phi
// Bit  8: TIB L2 stereo
// Bit  9: TIB L3 r-phi
// Bit 10: TIB L4 r-phi
// Bit 11: TID L1 r-phi
// Bit 12: TID L1 stereo
// Bit 13: TID L2 r-phi
// Bit 14: TID L2 stereo
// Bit 15: TID L3 r-phi
// Bit 16: TID L3 stereo
// Bit 17: TOB L1 r-phi
// Bit 18: TOB L1 stereo
// Bit 19: TOB L2 r-phi
// Bit 20: TOB L2 stereo
// Bit 21: TOB L3 r-phi
// Bit 22: TOB L4 r-phi
// Bit 23: TOB L5 r-phi
// Bit 24: TOB L6 r-phi
// Bit 25: TEC L1 r-phi
// Bit 26: TEC L1 stereo
// Bit 27: TEC L2 r-phi
// Bit 28: TEC L2 stereo
// Bit 29: TEC L3 r-phi
// Bit 30: TEC L3 stereo
// Bit 31: TEC L4 r-phi
// Bit 32: TEC L4 stereo
// Bit 33: TEC L5 r-phi
// Bit 34: TEC L5 stereo
// Bit 35: TEC L6 r-phi
// Bit 36: TEC L6 stereo
// Bit 37: TEC L7 r-phi
// Bit 38: TEC L7 stereo
// Bit 39: TEC L8 r-phi
// Bit 40: TEC L8 stereo
// Bit 41: TEC L9 r-phi
// Bit 42: TEC L9 stereo
//
// Authors: C.Loizides, J.Bendavid, C.Paus
//--------------------------------------------------------------------------------------------------

#ifndef MITANA_DATATREE_TRACK_H
#define MITANA_DATATREE_TRACK_H
 
#include "MitAna/DataTree/interface/DataObject.h"
#include "MitAna/DataTree/interface/MCParticle.h"
#include "MitAna/DataTree/interface/BitMask.h"
#include "MitAna/DataTree/interface/Types.h"

namespace mithep 
{
  class Track : public DataObject
  {
    public:
      enum EHitLayer { 
        PXB1, 
        PXB2,
        PXB3,
        PXF1,
        PXF2,
        TIB1,
        TIB1S,
        TIB2,
        TIB2S,
        TIB3,
        TIB4,
        TID1,
        TID1S,
        TID2,
        TID2S,
        TID3,
        TID3S,
        TOB1,
        TOB1S,
        TOB2,
        TOB2S,
        TOB3,
        TOB4,
        TOB5,
        TOB6,
        TEC1,
        TEC1S,
        TEC2,
        TEC2S,
        TEC3,
        TEC3S,
        TEC4,
        TEC4S,
        TEC5,
        TEC5S,
        TEC6,
        TEC6S,
        TEC7,
        TEC7S,
        TEC8,
        TEC8S,
        TEC9,
        TEC9S
      };

      Track() : fQOverP(0), fQOverPErr(0), fLambda(0), fLambdaErr(0),
                fPhi0(0), fPhi0Err(0), fDxy(0), fDxyErr(0), fDsz(0), fDszErr(0),
                fChi2(0), fNdof(0) {}
      Track(Double_t qOverP, Double_t lambda, Double_t phi0, Double_t dxy, Double_t dsz) :
                fQOverP(qOverP), fQOverPErr(0), fLambda(lambda), fLambdaErr(0),
                fPhi0(phi0), fPhi0Err(0), fDxy(dxy), fDxyErr(0), fDsz(dsz), fDszErr(0),
                fChi2(0), fNdof(0) {}
      ~Track() {}

      Int_t              Charge()         const { return (fQOverP>0) ? 1 : -1; }
      Double_t           Chi2()           const { return fChi2; }
      Double_t           RChi2()          const { return fChi2/(Double_t)fNdof; }
      void               ClearHit(EHitLayer l)  { fHits.ClearBit(l); } 
      Double_t           D0()             const { return -fDxy; }
      Double_t           D0Err()          const { return fDxyErr; }
      Double_t           Dsz()            const { return fDsz; }
      Double_t           DszErr()         const { return fDszErr; }
      Double_t           Dxy()            const { return fDxy; }
      Double_t           DxyErr()         const { return fDxyErr; }
      Double_t           E(Double_t m)    const { return TMath::Sqrt(E2(m)); }
      Double_t           E2(Double_t m)   const { return P2()+m*m; }
      Double_t           Eta()            const { return Mom().Eta(); }
      Bool_t             Hit(EHitLayer l) const { return fHits.TestBit(l); }
      const BitMask64   &Hits()           const { return fHits; }
      Double_t           Lambda()         const { return fLambda; }
      Double_t           LambdaErr()      const { return fLambdaErr; }
      const MCParticle  *MCPart()         const;
      ThreeVector        Mom()            const { return ThreeVector(Px(),Py(),Pz()); }
      FourVector         Mom4(Double_t m) const { return FourVector(Px(),Py(),Pz(),E(m)); }
      UInt_t             Ndof()           const { return fNdof; }
      UInt_t             NHits()          const { return fHits.NBitsSet(); }
      Double_t           P2()             const { return P()*P(); }
      Double_t           P()              const { return TMath::Abs(1./fQOverP); }
      Double_t           Phi()            const { return fPhi0; }
      Double_t           Phi0()           const { return fPhi0; }
      Double_t           Phi0Err()        const { return fPhi0Err; }
      Double_t           Prob()           const { return TMath::Prob(fChi2,fNdof); }
      Double_t           Pt()             const { return TMath::Abs(TMath::Cos(fLambda)/fQOverP); }
      Double_t           Px()             const { return Pt()*TMath::Cos(fPhi0); }      
      Double_t           Py()             const { return Pt()*TMath::Sin(fPhi0); }
      Double_t           Pz()             const { return P()*TMath::Sin(fLambda); }
      Double_t           QOverP()         const { return fQOverP; }
      Double_t           QOverPErr()      const { return fQOverPErr; }
      Double_t           Theta()          const { return (TMath::PiOver2() - fLambda); }
      Double_t           Z0()             const { return fDsz/TMath::Cos(fLambda); }
      void               SetChi2(Double_t chi2) { fChi2 = chi2; }
      void               SetErrors(Double_t qOverPErr, Double_t lambdaErr, Double_t phi0Err, 
                                   Double_t dXyErr, Double_t dSzErr);
      void               SetHelix (Double_t qOverP, Double_t lambda, Double_t phi0, 
                                   Double_t dXy, Double_t dSz);
      void               SetHit(EHitLayer l)      { fHits.SetBit(l); }
      void               SetHits(const BitMask64 &hits) { fHits = hits; }
      void               SetNdof(UInt_t dof)      { fNdof = dof; }
      void               SetMCPart(MCParticle *p) { fMCParticleRef = p; }

    protected:
      BitMask64          fHits;                //storage for mostly hit information
      Double_t           fQOverP;              //signed inverse of momentum [1/GeV]
      Double_t           fQOverPErr;           //error of q/p
      Double_t           fLambda;              //pi/2 - polar angle at the reference point
      Double_t           fLambdaErr;           //error of lambda
      Double_t           fPhi0;                //azimuth angle at the given point
      Double_t           fPhi0Err;             //error of azimuthal angle
      Double_t           fDxy;                 //transverse distance to reference point [cm]
      Double_t           fDxyErr;              //error of transverse distance
      Double_t           fDsz;                 //longitudinal distance to reference point [cm]
      Double_t           fDszErr;              //error of longitudinal distance
      Double_t           fChi2;                //chi squared of track fit
      UInt_t             fNdof;                //degree-of-freedom of track fit
      TRef               fMCParticleRef;       //reference to sim particle (for monte carlo)
              
    ClassDef(Track, 1) // Track class
  };
}

//--------------------------------------------------------------------------------------------------
inline
void mithep::Track::SetHelix(Double_t qOverP, Double_t lambda, Double_t phi0, 
                                   Double_t dxy, Double_t dsz)
{
  // Set helix parameters.

  fQOverP = qOverP;
  fLambda = lambda;
  fPhi0   = phi0;
  fDxy    = dxy;
  fDsz    = dsz;
}

//--------------------------------------------------------------------------------------------------
inline
void mithep::Track::SetErrors(Double_t qOverPErr, Double_t lambdaErr, Double_t phi0Err, 
                                   Double_t dxyErr, Double_t dszErr)
{
  // Set helix errors.

  fQOverPErr = qOverPErr;
  fLambdaErr = lambdaErr;
  fPhi0Err   = phi0Err;
  fDxyErr    = dxyErr;
  fDszErr    = dszErr;
}

//--------------------------------------------------------------------------------------------------
inline
const mithep::MCParticle *mithep::Track::MCPart() const 
{ 
  // Get reference to simulated particle.

  return static_cast<const MCParticle*>(fMCParticleRef.GetObject()); 
}
#endif
Revision:	1.23
Committed:	Thu Oct 16 16:13:23 2008 UTC (16 years, 6 months ago) by bendavid
Content type:	text/plain
Branch:	MAIN
CVS Tags:	Mit_005
Changes since 1.22:	+37 -23 lines
Log Message:	Fixed broken track hit mask format
#	User	Rev	Content
1	loizides	1.1	//--------------------------------------------------------------------------------------------------
2	bendavid	1.23	// $Id: Track.h,v 1.22 2008/10/13 10:34:00 bendavid Exp $
3	loizides	1.1	//
4			// Track
5			//
6	bendavid	1.15	// 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 = -vxsin(phi) + vycos(phi) [cm]
14			// dsz = vzcos(lambda) - (vxcos(phi)+vysin(phi))sin(lambda) [cm]
15	loizides	1.18	// (See http://cmslxr.fnal.gov/lxr/source/DataFormats/TrackReco/interface/TrackBase.h)
16	bendavid	1.15	//
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	loizides	1.16	// (TIB L1,L2, TID L1,L2, TOB L1,L2, TEC L1,L2,L5).
23	bendavid	1.15	//
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	loizides	1.16	// but muon chamber information will likely be added as well.
28	bendavid	1.15	//
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	loizides	1.16	// Bit 11: TID L1 r-phi
42	bendavid	1.15	// Bit 12: TID L1 stereo
43	loizides	1.16	// Bit 13: TID L2 r-phi
44	bendavid	1.15	// Bit 14: TID L2 stereo
45	loizides	1.16	// Bit 15: TID L3 r-phi
46	bendavid	1.23	// 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	loizides	1.1	//
74	loizides	1.5	// Authors: C.Loizides, J.Bendavid, C.Paus
75	loizides	1.1	//--------------------------------------------------------------------------------------------------
76	loizides	1.7
77	loizides	1.17	#ifndef MITANA_DATATREE_TRACK_H
78			#define MITANA_DATATREE_TRACK_H
79	paus	1.6
80			#include "MitAna/DataTree/interface/DataObject.h"
81	bendavid	1.14	#include "MitAna/DataTree/interface/MCParticle.h"
82	loizides	1.18	#include "MitAna/DataTree/interface/BitMask.h"
83	loizides	1.9	#include "MitAna/DataTree/interface/Types.h"
84	loizides	1.1
85			namespace mithep
86			{
87			class Track : public DataObject
88			{
89			public:
90	loizides	1.18	enum EHitLayer {
91			PXB1,
92			PXB2,
93			PXB3,
94			PXF1,
95			PXF2,
96			TIB1,
97			TIB1S,
98			TIB2,
99			TIB2S,
100			TIB3,
101			TIB4,
102			TID1,
103			TID1S,
104			TID2,
105			TID2S,
106			TID3,
107	bendavid	1.23	TID3S,
108	loizides	1.18	TOB1,
109			TOB1S,
110			TOB2,
111			TOB2S,
112			TOB3,
113			TOB4,
114			TOB5,
115			TOB6,
116			TEC1,
117			TEC1S,
118			TEC2,
119			TEC2S,
120			TEC3,
121	bendavid	1.23	TEC3S,
122	loizides	1.18	TEC4,
123	bendavid	1.23	TEC4S,
124	loizides	1.18	TEC5,
125			TEC5S,
126			TEC6,
127	bendavid	1.23	TEC6S,
128	loizides	1.18	TEC7,
129	bendavid	1.23	TEC7S,
130	loizides	1.18	TEC8,
131	bendavid	1.23	TEC8S,
132			TEC9,
133			TEC9S
134	loizides	1.18	};
135
136	bendavid	1.15	Track() : fQOverP(0), fQOverPErr(0), fLambda(0), fLambdaErr(0),
137			fPhi0(0), fPhi0Err(0), fDxy(0), fDxyErr(0), fDsz(0), fDszErr(0),
138			fChi2(0), fNdof(0) {}
139			Track(Double_t qOverP, Double_t lambda, Double_t phi0, Double_t dxy, Double_t dsz) :
140			fQOverP(qOverP), fQOverPErr(0), fLambda(lambda), fLambdaErr(0),
141			fPhi0(phi0), fPhi0Err(0), fDxy(dxy), fDxyErr(0), fDsz(dsz), fDszErr(0),
142			fChi2(0), fNdof(0) {}
143	loizides	1.1	~Track() {}
144
145	loizides	1.18	Int_t Charge() const { return (fQOverP>0) ? 1 : -1; }
146			Double_t Chi2() const { return fChi2; }
147	bendavid	1.20	Double_t RChi2() const { return fChi2/(Double_t)fNdof; }
148	loizides	1.18	void ClearHit(EHitLayer l) { fHits.ClearBit(l); }
149			Double_t D0() const { return -fDxy; }
150			Double_t D0Err() const { return fDxyErr; }
151			Double_t Dsz() const { return fDsz; }
152			Double_t DszErr() const { return fDszErr; }
153			Double_t Dxy() const { return fDxy; }
154			Double_t DxyErr() const { return fDxyErr; }
155			Double_t E(Double_t m) const { return TMath::Sqrt(E2(m)); }
156			Double_t E2(Double_t m) const { return P2()+m*m; }
157	sixie	1.21	Double_t Eta() const { return Mom().Eta(); }
158	loizides	1.18	Bool_t Hit(EHitLayer l) const { return fHits.TestBit(l); }
159	bendavid	1.22	const BitMask64 &Hits() const { return fHits; }
160	loizides	1.18	Double_t Lambda() const { return fLambda; }
161			Double_t LambdaErr() const { return fLambdaErr; }
162			const MCParticle *MCPart() const;
163			ThreeVector Mom() const { return ThreeVector(Px(),Py(),Pz()); }
164			FourVector Mom4(Double_t m) const { return FourVector(Px(),Py(),Pz(),E(m)); }
165			UInt_t Ndof() const { return fNdof; }
166			UInt_t NHits() const { return fHits.NBitsSet(); }
167			Double_t P2() const { return P()*P(); }
168			Double_t P() const { return TMath::Abs(1./fQOverP); }
169			Double_t Phi() const { return fPhi0; }
170			Double_t Phi0() const { return fPhi0; }
171			Double_t Phi0Err() const { return fPhi0Err; }
172	bendavid	1.19	Double_t Prob() const { return TMath::Prob(fChi2,fNdof); }
173	loizides	1.18	Double_t Pt() const { return TMath::Abs(TMath::Cos(fLambda)/fQOverP); }
174			Double_t Px() const { return Pt()*TMath::Cos(fPhi0); }
175			Double_t Py() const { return Pt()*TMath::Sin(fPhi0); }
176			Double_t Pz() const { return P()*TMath::Sin(fLambda); }
177			Double_t QOverP() const { return fQOverP; }
178			Double_t QOverPErr() const { return fQOverPErr; }
179			Double_t Theta() const { return (TMath::PiOver2() - fLambda); }
180			Double_t Z0() const { return fDsz/TMath::Cos(fLambda); }
181			void SetChi2(Double_t chi2) { fChi2 = chi2; }
182			void SetErrors(Double_t qOverPErr, Double_t lambdaErr, Double_t phi0Err,
183			Double_t dXyErr, Double_t dSzErr);
184	bendavid	1.15	void SetHelix (Double_t qOverP, Double_t lambda, Double_t phi0,
185			Double_t dXy, Double_t dSz);
186	loizides	1.18	void SetHit(EHitLayer l) { fHits.SetBit(l); }
187	bendavid	1.23	void SetHits(const BitMask64 &hits) { fHits = hits; }
188	loizides	1.18	void SetNdof(UInt_t dof) { fNdof = dof; }
189			void SetMCPart(MCParticle *p) { fMCParticleRef = p; }
190
191	paus	1.4	protected:
192	loizides	1.17	BitMask64 fHits; //storage for mostly hit information
193	loizides	1.18	Double_t fQOverP; //signed inverse of momentum [1/GeV]
194			Double_t fQOverPErr; //error of q/p
195			Double_t fLambda; //pi/2 - polar angle at the reference point
196			Double_t fLambdaErr; //error of lambda
197			Double_t fPhi0; //azimuth angle at the given point
198			Double_t fPhi0Err; //error of azimuthal angle
199			Double_t fDxy; //transverse distance to reference point [cm]
200			Double_t fDxyErr; //error of transverse distance
201			Double_t fDsz; //longitudinal distance to reference point [cm]
202			Double_t fDszErr; //error of longitudinal distance
203	loizides	1.17	Double_t fChi2; //chi squared of track fit
204	loizides	1.18	UInt_t fNdof; //degree-of-freedom of track fit
205	loizides	1.17	TRef fMCParticleRef; //reference to sim particle (for monte carlo)
206	loizides	1.5
207	loizides	1.8	ClassDef(Track, 1) // Track class
208	loizides	1.1	};
209	loizides	1.5	}
210	loizides	1.1
211	loizides	1.5	//--------------------------------------------------------------------------------------------------
212	paus	1.4	inline
213	bendavid	1.15	void mithep::Track::SetHelix(Double_t qOverP, Double_t lambda, Double_t phi0,
214			Double_t dxy, Double_t dsz)
215	loizides	1.5	{
216	loizides	1.13	// Set helix parameters.
217
218	bendavid	1.15	fQOverP = qOverP;
219			fLambda = lambda;
220			fPhi0 = phi0;
221			fDxy = dxy;
222			fDsz = dsz;
223	paus	1.4	}
224
225	loizides	1.5	//--------------------------------------------------------------------------------------------------
226	paus	1.4	inline
227	bendavid	1.15	void mithep::Track::SetErrors(Double_t qOverPErr, Double_t lambdaErr, Double_t phi0Err,
228			Double_t dxyErr, Double_t dszErr)
229	loizides	1.5	{
230	loizides	1.13	// Set helix errors.
231
232	bendavid	1.15	fQOverPErr = qOverPErr;
233			fLambdaErr = lambdaErr;
234			fPhi0Err = phi0Err;
235			fDxyErr = dxyErr;
236			fDszErr = dszErr;
237	paus	1.4	}
238	loizides	1.13
239			//--------------------------------------------------------------------------------------------------
240			inline
241	bendavid	1.14	const mithep::MCParticle *mithep::Track::MCPart() const
242	loizides	1.13	{
243			// Get reference to simulated particle.
244
245	bendavid	1.14	return static_cast<const MCParticle*>(fMCParticleRef.GetObject());
246	loizides	1.13	}
247	loizides	1.5	#endif