DataTree/interface/Track.h

//--------------------------------------------------------------------------------------------------
// $Id: Track.h,v 1.18 2008/09/17 04:16:25 loizides 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: TOB L1 r-phi
// Bit 17: TOB L1 stereo
// Bit 18: TOB L2 r-phi
// Bit 19: TOB L2 stereo
// Bit 20: TOB L3 r-phi
// Bit 21: TOB L4 r-phi
// Bit 22: TOB L5 r-phi
// Bit 23: TOB L6 r-phi
// Bit 24: TEC L1 r-phi
// Bit 25: TEC L1 stereo
// Bit 26: TEC L2 r-phi
// Bit 27: TEC L2 stereo
// Bit 28: TEC L3 r-phi
// Bit 29: TEC L4 r-phi
// Bit 30: TEC L5 r-phi
// Bit 31: TEC L5 stereo
// Bit 32: TEC L6 r-phi
// Bit 33: TEC L7 r-phi
// Bit 34: TEC L8 r-phi
// Bit 35: TEC L9 r-phi
//
// 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,
        TOB1,
        TOB1S,
        TOB2,
        TOB2S,
        TOB3,
        TOB4,
        TOB5,
        TOB6,
        TEC1,
        TEC1S,
        TEC2,
        TEC2S,
        TEC3,
        TEC4,
        TEC5,
        TEC5S,
        TEC6,
        TEC7,
        TEC8,
        TEC9 
      };

      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; }
      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; }
      Bool_t             Hit(EHitLayer l) const { return fHits.TestBit(l); }
      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               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.19
Committed:	Mon Sep 22 10:39:54 2008 UTC (16 years, 7 months ago) by bendavid
Content type:	text/plain
Branch:	MAIN
Changes since 1.18:	+2 -1 lines
Log Message:	Added fit probability accessor
#	User	Rev	Content
1	loizides	1.1	//--------------------------------------------------------------------------------------------------
2	bendavid	1.19	// $Id: Track.h,v 1.18 2008/09/17 04:16:25 loizides 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.15	// 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	loizides	1.16	// Bit 24: TEC L1 r-phi
55	bendavid	1.15	// Bit 25: TEC L1 stereo
56	loizides	1.16	// Bit 26: TEC L2 r-phi
57	bendavid	1.15	// Bit 27: TEC L2 stereo
58	loizides	1.16	// Bit 28: TEC L3 r-phi
59			// Bit 29: TEC L4 r-phi
60			// Bit 30: TEC L5 r-phi
61	bendavid	1.15	// Bit 31: TEC L5 stereo
62	loizides	1.16	// 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	loizides	1.1	//
67	loizides	1.5	// Authors: C.Loizides, J.Bendavid, C.Paus
68	loizides	1.1	//--------------------------------------------------------------------------------------------------
69	loizides	1.7
70	loizides	1.17	#ifndef MITANA_DATATREE_TRACK_H
71			#define MITANA_DATATREE_TRACK_H
72	paus	1.6
73			#include "MitAna/DataTree/interface/DataObject.h"
74	bendavid	1.14	#include "MitAna/DataTree/interface/MCParticle.h"
75	loizides	1.18	#include "MitAna/DataTree/interface/BitMask.h"
76	loizides	1.9	#include "MitAna/DataTree/interface/Types.h"
77	loizides	1.1
78			namespace mithep
79			{
80			class Track : public DataObject
81			{
82			public:
83	loizides	1.18	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	bendavid	1.15	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	loizides	1.1	~Track() {}
130
131	loizides	1.18	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	bendavid	1.19	Double_t Prob() const { return TMath::Prob(fChi2,fNdof); }
156	loizides	1.18	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	bendavid	1.15	void SetHelix (Double_t qOverP, Double_t lambda, Double_t phi0,
168			Double_t dXy, Double_t dSz);
169	loizides	1.18	void SetHit(EHitLayer l) { fHits.SetBit(l); }
170			void SetNdof(UInt_t dof) { fNdof = dof; }
171			void SetMCPart(MCParticle *p) { fMCParticleRef = p; }
172
173	paus	1.4	protected:
174	loizides	1.17	BitMask64 fHits; //storage for mostly hit information
175	loizides	1.18	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	loizides	1.17	Double_t fChi2; //chi squared of track fit
186	loizides	1.18	UInt_t fNdof; //degree-of-freedom of track fit
187	loizides	1.17	TRef fMCParticleRef; //reference to sim particle (for monte carlo)
188	loizides	1.5
189	loizides	1.8	ClassDef(Track, 1) // Track class
190	loizides	1.1	};
191	loizides	1.5	}
192	loizides	1.1
193	loizides	1.5	//--------------------------------------------------------------------------------------------------
194	paus	1.4	inline
195	bendavid	1.15	void mithep::Track::SetHelix(Double_t qOverP, Double_t lambda, Double_t phi0,
196			Double_t dxy, Double_t dsz)
197	loizides	1.5	{
198	loizides	1.13	// Set helix parameters.
199
200	bendavid	1.15	fQOverP = qOverP;
201			fLambda = lambda;
202			fPhi0 = phi0;
203			fDxy = dxy;
204			fDsz = dsz;
205	paus	1.4	}
206
207	loizides	1.5	//--------------------------------------------------------------------------------------------------
208	paus	1.4	inline
209	bendavid	1.15	void mithep::Track::SetErrors(Double_t qOverPErr, Double_t lambdaErr, Double_t phi0Err,
210			Double_t dxyErr, Double_t dszErr)
211	loizides	1.5	{
212	loizides	1.13	// Set helix errors.
213
214	bendavid	1.15	fQOverPErr = qOverPErr;
215			fLambdaErr = lambdaErr;
216			fPhi0Err = phi0Err;
217			fDxyErr = dxyErr;
218			fDszErr = dszErr;
219	paus	1.4	}
220	loizides	1.13
221			//--------------------------------------------------------------------------------------------------
222			inline
223	bendavid	1.14	const mithep::MCParticle *mithep::Track::MCPart() const
224	loizides	1.13	{
225			// Get reference to simulated particle.
226
227	bendavid	1.14	return static_cast<const MCParticle*>(fMCParticleRef.GetObject());
228	loizides	1.13	}
229	loizides	1.5	#endif