ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/UserCode/MitAna/DataTree/interface/Electron.h

Comparing UserCode/MitAna/DataTree/interface/Electron.h (file contents):
Revision 1.23 by loizides, Thu Jan 22 14:21:32 2009 UTC vs.
Revision 1.27 by loizides, Tue Mar 3 17:04:09 2009 UTC

#	Line 13 | Line 13
13
14		#include "MitAna/DataTree/interface/SuperCluster.h"
15		#include "MitAna/DataTree/interface/ChargedParticle.h"
16	+	#include "MitAna/DataCont/interface/Ref.h"
17
18		namespace mithep
19		{
#	Line 27 | Line 28 | namespace mithep
28		fCaloIsolation(0), fCaloTowerIsolation(0), fTrackIsolation(0),
29		fEcalJurassicIsolation(0), fHcalJurassicIsolation(0), fPassLooseID(0),
30		fPassTightID(0), fIDLikelihood(0), fPIn(0), fPOut(0) {}
30	–	~Electron() {}
31
32		const Track         *BestTrk()               const;
33	<	const Track         *GsfTrk()                const;
34	<	const Track         *TrackerTrk()            const;
35	<	const SuperCluster  *SCluster()              const;
36	<	FourVector           Mom()                   const;
37	<	const Track         *Trk()                   const { return BestTrk();                }
38	<	Double_t    CaloIsolation()                  const { return fCaloIsolation;           }
39	<	Double_t    CaloTowerIsolation()             const { return fCaloTowerIsolation;      }
40	<	Double_t    Classification()                 const { return fClassification;          }
41	<	Double_t    CovEtaEta()                      const { return fCovEtaEta;               }
42	<	Double_t    CovEtaPhi()                      const { return fCovEtaPhi;               }
43	<	Double_t    CovPhiPhi()                      const { return fCovPhiPhi;               }
44	<	Double_t    CoviEtaiEta()                    const { return fCoviEtaiEta;             }
45	<	Double_t    DeltaEtaSuperClusterTrackAtVtx() const { return fDeltaEtaSuperClTrkAtVtx; }
46	<	Double_t    DeltaEtaSeedClusterTrackAtCalo() const { return fDeltaEtaSeedClTrkAtCalo; }
47	<	Double_t    DeltaPhiSuperClusterTrackAtVtx() const { return fDeltaPhiSuperClTrkAtVtx; }
48	<	Double_t    DeltaPhiSeedClusterTrackAtCalo() const { return fDeltaPhiSeedClTrkAtCalo; }
49	<	Double_t    E()                              const;
50	<	Double_t    E33()                            const { return fE33;                     }
51	<	Double_t    E55()                            const { return fE55;                     }
52	<	Double_t    EcalJurassicIsolation()          const { return fEcalJurassicIsolation;   }
53	<	Double_t    ESuperClusterOverP()             const { return fESuperClusterOverP;      }
54	<	Double_t    ESeedClusterOverPout()           const { return fESeedClusterOverPout;    }
55	<	Double_t    ESeedClusterOverPIn()            const;
56	<	Double_t    IDLikelihood()                   const { return fIDLikelihood;            }
57	<	Double_t    IsEnergyScaleCorrected()         const { return fIsEnergyScaleCorrected;  }
58	<	Double_t    IsMomentumCorrected()            const { return fIsMomentumCorrected;     }
59	<	Double_t    HadronicOverEm()                 const { return fHadronicOverEm;          }
60	<	Double_t    HcalIsolation()                  const { return fHcalJurassicIsolation;   }
61	<	Double_t    Mass()                           const { return 0.51099892e-3;            }
62	<	Double_t    NumberOfClusters()               const { return fNumberOfClusters;        }
63	<	EObjType    ObjType()                        const { return kElectron;                }
64	<	Double_t    PassLooseID()                    const { return fPassLooseID;             }
65	<	Double_t    PassTightID()                    const { return fPassTightID;             }
66	<	Double_t    PIn()                            const { return fPIn;                     }
67	<	Double_t    POut()                           const { return fPOut;                    }
68	<	Double_t    P()                              const;
69	<	Double_t    Pt()                             const;
70	<	Double_t    Px()                             const;
71	<	Double_t    Py()                             const;
72	<	Double_t    Pz()                             const;
73	<	Double_t    TrackIsolation()                 const { return fTrackIsolation;          }
74	<	void        SetGsfTrk(const Track* t)
75	<	{ fGsfTrackRef = const_cast<Track*>(t); }
76	<	void        SetTrackerTrk(const Track* t)
77	<	{ fTrackerTrackRef = const_cast<Track*>(t); }
78	<	void        SetSuperCluster(const SuperCluster* sc)
79	<	{ fSuperClusterRef = const_cast<SuperCluster*>(sc); }
80	<	void        SetCaloIsolation(Double_t CaloIsolation)      { fCaloIsolation = CaloIsolation;  }
81	<	void        SetCaloTowerIsolation(Double_t TowerIso)      { fCaloTowerIsolation = TowerIso;  }
82	<	void        SetClassification(Double_t x)                 { fClassification = x;             }
83	<	void        SetCovEtaEta(Double_t CovEtaEta)              { fCovEtaEta = CovEtaEta;          }
84	<	void        SetCovEtaPhi(Double_t CovEtaPhi)              { fCovEtaPhi = CovEtaPhi;          }
85	<	void        SetCovPhiPhi(Double_t CovPhiPhi)              { fCovPhiPhi = CovPhiPhi;          }
86	<	void        SetCoviEtaiEta(Double_t CoviEtaiEta)          { fCoviEtaiEta = CoviEtaiEta;      }
87	<	void        SetDeltaEtaSuperClusterTrackAtVtx(Double_t x) { fDeltaEtaSuperClTrkAtVtx = x;    }
88	<	void        SetDeltaEtaSeedClusterTrackAtCalo(Double_t x) { fDeltaEtaSeedClTrkAtCalo = x;    }
89	<	void        SetDeltaPhiSuperClusterTrackAtVtx(Double_t x) { fDeltaPhiSuperClTrkAtVtx = x;    }
90	<	void        SetDeltaPhiSeedClusterTrackAtCalo(Double_t x) { fDeltaPhiSeedClTrkAtCalo = x;    }
91	<	void        SetE33(Double_t E33)                          { fE33 = E33;                      }
92	<	void        SetE55(Double_t E55)                          { fE55 = E55;                      }
93	<	void        SetEcalJurassicIsolation(Double_t iso )       { fEcalJurassicIsolation = iso;    }
94	<	void        SetESuperClusterOverP(Double_t x)             { fESuperClusterOverP = x;         }
95	<	void        SetESeedClusterOverPout(Double_t x)           { fESeedClusterOverPout = x;       }
96	<	void        SetHadronicOverEm(Double_t x)                 { fHadronicOverEm = x;             }
97	<	void        SetIDLikelihood(Double_t likelihood)          { fIDLikelihood = likelihood;      }
98	<	void        SetIsEnergyScaleCorrected(Double_t x)         { fIsEnergyScaleCorrected = x;     }
99	<	void        SetIsMomentumCorrected(Double_t x)            { fIsMomentumCorrected = x;        }
100	<	void        SetHcalIsolation(Double_t iso )               { fHcalJurassicIsolation = iso;    }
101	<	void        SetNumberOfClusters(Double_t x)               { fNumberOfClusters = x;           }
102	<	void        SetPassLooseID(Double_t passLooseID)          { fPassLooseID = passLooseID;      }
103	<	void        SetPassTightID(Double_t passTightID)          { fPassTightID = passTightID;      }
104	<	void        SetPIn(Double_t PIn)                          { fPIn = PIn;                      }
105	<	void        SetPOut(Double_t POut)                        { fPOut = POut;                    }
106	<	void        SetTrackIsolation(Double_t TrackIsolation)    { fTrackIsolation = TrackIsolation;}
33	>	const Track         *GsfTrk()                const { return fGsfTrackRef.Obj();          }
34	>	const Track         *TrackerTrk()            const { return fTrackerTrackRef.Obj();      }
35	>	const SuperCluster  *SCluster()              const { return fSuperClusterRef.Obj();      }
36	>	const Track         *Trk()                   const { return BestTrk();                   }
37	>	Double_t             CaloIsolation()         const { return fCaloIsolation;              }
38	>	Double_t             CaloTowerIsolation()    const { return fCaloTowerIsolation;         }
39	>	Double_t             Classification()        const { return fClassification;             }
40	>	Double_t             CovEtaEta()             const { return fCovEtaEta;                  }
41	>	Double_t             CovEtaPhi()             const { return fCovEtaPhi;                  }
42	>	Double_t             CovPhiPhi()             const { return fCovPhiPhi;                  }
43	>	Double_t             CoviEtaiEta()           const { return fCoviEtaiEta;                }
44	>	Double_t             DeltaEtaSuperClusterTrackAtVtx() const
45	>	{ return fDeltaEtaSuperClTrkAtVtx; }
46	>	Double_t             DeltaEtaSeedClusterTrackAtCalo() const
47	>	{ return fDeltaEtaSeedClTrkAtCalo; }
48	>	Double_t             DeltaPhiSuperClusterTrackAtVtx() const
49	>	{ return fDeltaPhiSuperClTrkAtVtx; }
50	>	Double_t             DeltaPhiSeedClusterTrackAtCalo() const
51	>	{ return fDeltaPhiSeedClTrkAtCalo; }
52	>	Double_t             E33()                   const { return fE33;                        }
53	>	Double_t             E55()                   const { return fE55;                        }
54	>	Double_t             EcalJurassicIsolation() const { return fEcalJurassicIsolation;      }
55	>	Double_t             ESuperClusterOverP()    const { return fESuperClusterOverP;         }
56	>	Double_t             ESeedClusterOverPout()  const { return fESeedClusterOverPout;       }
57	>	Double_t             ESeedClusterOverPIn()   const;
58	>	Double_t             IDLikelihood()          const { return fIDLikelihood;               }
59	>	Double_t             IsEnergyScaleCorrected()const { return fIsEnergyScaleCorrected;     }
60	>	Double_t             IsMomentumCorrected()   const { return fIsMomentumCorrected;        }
61	>	Double_t             HadronicOverEm()        const { return fHadronicOverEm;             }
62	>	Bool_t               HasGsfTrk()             const { return fGsfTrackRef.IsValid();      }
63	>	Bool_t               HasTrackerTrk()         const { return fTrackerTrackRef.IsValid();  }
64	>	Bool_t               HasSuperCluster()       const { return fSuperClusterRef.IsValid();  }
65	>	Double_t             HcalIsolation()         const { return fHcalJurassicIsolation;      }
66	>	Double_t             NumberOfClusters()      const { return fNumberOfClusters;           }
67	>	EObjType             ObjType()               const { return kElectron;                   }
68	>	Double_t             PassLooseID()           const { return fPassLooseID;                }
69	>	Double_t             PassTightID()           const { return fPassTightID;                }
70	>	Double_t             PIn()                   const { return fPIn;                        }
71	>	Double_t             POut()                  const { return fPOut;                       }
72	>	Double_t             TrackIsolation()        const { return fTrackIsolation;             }
73	>	void                 SetGsfTrk(const Track* t)
74	>	{ fGsfTrackRef = t;     ClearMom(); ClearCharge(); }
75	>	void                 SetTrackerTrk(const Track* t)
76	>	{ fTrackerTrackRef = t; ClearMom(); ClearCharge(); }
77	>	void                 SetSuperCluster(const SuperCluster* sc)
78	>	{ fSuperClusterRef = sc; ClearMom(); }
79	>	void                 SetCaloIsolation(Double_t caloiso)    { fCaloIsolation = caloiso;   }
80	>	void                 SetCaloTowerIsolation(Double_t tiso)  { fCaloTowerIsolation = tiso; }
81	>	void                 SetClassification(Double_t x)         { fClassification = x;        }
82	>	void                 SetCovEtaEta(Double_t CovEtaEta)      { fCovEtaEta = CovEtaEta;     }
83	>	void                 SetCovEtaPhi(Double_t CovEtaPhi)      { fCovEtaPhi = CovEtaPhi;     }
84	>	void                 SetCovPhiPhi(Double_t CovPhiPhi)      { fCovPhiPhi = CovPhiPhi;     }
85	>	void                 SetCoviEtaiEta(Double_t CoviEtaiEta)  { fCoviEtaiEta = CoviEtaiEta; }
86	>	void                 SetDeltaEtaSuperClusterTrackAtVtx(Double_t x)
87	>	{ fDeltaEtaSuperClTrkAtVtx = x;   }
88	>	void                 SetDeltaEtaSeedClusterTrackAtCalo(Double_t x)
89	>	{ fDeltaEtaSeedClTrkAtCalo = x;   }
90	>	void                 SetDeltaPhiSuperClusterTrackAtVtx(Double_t x)
91	>	{ fDeltaPhiSuperClTrkAtVtx = x;   }
92	>	void                 SetDeltaPhiSeedClusterTrackAtCalo(Double_t x)
93	>	{ fDeltaPhiSeedClTrkAtCalo = x;   }
94	>	void                 SetE33(Double_t E33)                  { fE33 = E33;                     }
95	>	void                 SetE55(Double_t E55)                  { fE55 = E55;                     }
96	>	void                 SetEcalJurassicIso(Double_t iso )     { fEcalJurassicIsolation = iso;   }
97	>	void                 SetESuperClusterOverP(Double_t x)     { fESuperClusterOverP = x;        }
98	>	void                 SetESeedClusterOverPout(Double_t x)   { fESeedClusterOverPout = x;      }
99	>	void                 SetHadronicOverEm(Double_t x)         { fHadronicOverEm = x;            }
100	>	void                 SetIDLikelihood(Double_t likelihood)  { fIDLikelihood = likelihood;     }
101	>	void                 SetIsEnergyScaleCorrected(Double_t x) { fIsEnergyScaleCorrected = x;    }
102	>	void                 SetIsMomentumCorrected(Double_t x)    { fIsMomentumCorrected = x;       }
103	>	void                 SetHcalIsolation(Double_t iso )       { fHcalJurassicIsolation = iso;   }
104	>	void                 SetNumberOfClusters(Double_t x)       { fNumberOfClusters = x;          }
105	>	void                 SetPassLooseID(Double_t passLooseID)  { fPassLooseID = passLooseID;     }
106	>	void                 SetPassTightID(Double_t passTightID)  { fPassTightID = passTightID;     }
107	>	void                 SetPIn(Double_t PIn)                  { fPIn = PIn;                     }
108	>	void                 SetPOut(Double_t POut)                { fPOut = POut;                   }
109	>	void                 SetTrackIsolation(Double_t trkiso)    { fTrackIsolation = trkiso;       }
110
111		protected:
112	<	TRef        fGsfTrackRef;               //global combined track reference
113	<	TRef        fTrackerTrackRef;           //tracker track reference
114	<	TRef        fSuperClusterRef;           //reference to SuperCluster
115	<	Double_t    fESuperClusterOverP;        //
116	<	Double_t    fESeedClusterOverPout;      //
117	<	Double_t    fDeltaEtaSuperClTrkAtVtx;   //
118	<	Double_t    fDeltaEtaSeedClTrkAtCalo;   //
119	<	Double_t    fDeltaPhiSuperClTrkAtVtx;   //
120	<	Double_t    fDeltaPhiSeedClTrkAtCalo;   //
121	<	Double_t    fHadronicOverEm;            //
122	<	Double_t    fIsEnergyScaleCorrected;    //
123	<	Double_t    fIsMomentumCorrected;       //
124	<	Double_t    fNumberOfClusters;          //
125	<	Double_t    fClassification;            //
126	<	Double_t    fE33;                       //
127	<	Double_t    fE55;                       //
128	<	Double_t    fCovEtaEta;                 //
129	<	Double_t    fCoviEtaiEta;               //
130	<	Double_t    fCovEtaPhi;                 //
131	<	Double_t    fCovPhiPhi;                 //
132	<	Double_t    fCaloIsolation;             //
133	<	Double_t    fCaloTowerIsolation;        //
134	<	Double_t    fTrackIsolation;            //
135	<	Double_t    fEcalJurassicIsolation;     //
136	<	Double_t    fHcalJurassicIsolation;     //
137	<	Double_t    fPassLooseID;               //
138	<	Double_t    fPassTightID;               //
139	<	Double_t    fIDLikelihood;              //
140	<	Double_t    fPIn;                       //
141	<	Double_t    fPOut;                      //
112	>	Double_t             GetMass()               const         { return 0.51099892e-3;           }
113	>	void                 GetMom()                const;
114	>
115	>	Ref<Track>           fGsfTrackRef;               //gsf track reference
116	>	Ref<Track>           fTrackerTrackRef;           //tracker track reference
117	>	Ref<SuperCluster>    fSuperClusterRef;           //reference to SuperCluster
118	>	Double32_t           fESuperClusterOverP;        //
119	>	Double32_t           fESeedClusterOverPout;      //
120	>	Double32_t           fDeltaEtaSuperClTrkAtVtx;   //
121	>	Double32_t           fDeltaEtaSeedClTrkAtCalo;   //
122	>	Double32_t           fDeltaPhiSuperClTrkAtVtx;   //
123	>	Double32_t           fDeltaPhiSeedClTrkAtCalo;   //
124	>	Double32_t           fHadronicOverEm;            //
125	>	Double32_t           fIsEnergyScaleCorrected;    //
126	>	Double32_t           fIsMomentumCorrected;       //
127	>	Double32_t           fNumberOfClusters;          //
128	>	Double32_t           fClassification;            //
129	>	Double32_t           fE33;                       //
130	>	Double32_t           fE55;                       //
131	>	Double32_t           fCovEtaEta;                 //
132	>	Double32_t           fCoviEtaiEta;               //
133	>	Double32_t           fCovEtaPhi;                 //
134	>	Double32_t           fCovPhiPhi;                 //
135	>	Double32_t           fCaloIsolation;             //
136	>	Double32_t           fCaloTowerIsolation;        //
137	>	Double32_t           fTrackIsolation;            //
138	>	Double32_t           fEcalJurassicIsolation;     //
139	>	Double32_t           fHcalJurassicIsolation;     //
140	>	Double32_t           fPassLooseID;               //
141	>	Double32_t           fPassTightID;               //
142	>	Double32_t           fIDLikelihood;              //
143	>	Double32_t           fPIn;                       //
144	>	Double32_t           fPOut;                      //
145
146		ClassDef(Electron, 1) // Electron class
147		};
#	Line 146 | Line 152 | inline const mithep::Track *mithep::Elec
152		{
153		// Return "best" track.
154
155	<	if (GsfTrk())
155	>	if (HasGsfTrk())
156		return GsfTrk();
157	<	else if (TrackerTrk())
157	>	else if (HasTrackerTrk())
158		return TrackerTrk();
159
160		return 0;
161		}
162
163		//--------------------------------------------------------------------------------------------------
164	<	inline const mithep::Track *mithep::Electron::GsfTrk() const
164	>	inline void mithep::Electron::GetMom() const
165		{
166	<	// Return global combined track.
166	>	// Get momentum of the electron. We use the direction of the
167	>	// track and the energy of the SuperCluster.
168
169	<	return static_cast<const Track*>(fGsfTrackRef.GetObject());
163	<	}
169	>	const mithep::Track *trk = Trk();
170
171	<	//--------------------------------------------------------------------------------------------------
172	<	inline const mithep::Track *mithep::Electron::TrackerTrk() const
173	<	{
174	<	// Return tracker track.
171	>	if (!trk) {
172	>	fCachedMom.SetCoordinates(0,0,0,0);
173	>	return;
174	>	}
175
176	<	return static_cast<const Track*>(fTrackerTrackRef.GetObject());
177	<	}
172	<	//--------------------------------------------------------------------------------------------------
173	<	inline const mithep::SuperCluster *mithep::Electron::SCluster() const
174	<	{
175	<	// Return super cluster.
176	<
177	<	return static_cast<const SuperCluster*>(fSuperClusterRef.GetObject());
178	<	}
176	>	Double_t p = 0;
177	>	Double_t mass = GetMass();
178
179	<	//-------------------------------------------------------------------------------------------------
180	<	inline mithep::FourVector mithep::Electron::Mom() const
181	<	{
182	<	// Return momentum of the electron. We use the direction of the
183	<	// track and the energy of the SuperCluster.
179	>	const mithep::SuperCluster *sc = SCluster();
180	>	if (sc)
181	>	p = TMath::Sqrt(sc->Energy()*sc->Energy() - mass*mass);
182	>	else
183	>	p = trk->P();
184
185	<	return FourVector(Px(), Py(), Pz(), E());
185	>	Double_t pt = TMath::Abs(p*TMath::Cos(trk->Lambda()));
186	>	fCachedMom.SetCoordinates(pt,trk->Eta(),trk->Phi(),mass);
187		}
188
189		//-------------------------------------------------------------------------------------------------
#	Line 194 | Line 194 | inline Double_t mithep::Electron::ESeedC
194
195		return SCluster()->Seed()->Energy() / PIn();
196		}
197	–
198	–	//-------------------------------------------------------------------------------------------------
199	–	inline Double_t mithep::Electron::E() const
200	–	{
201	–	// Return energy of the SuperCluster if present
202	–	// or else return energy derived from the track.
203	–
204	–	const mithep::SuperCluster *sc = SCluster();
205	–	if (sc)
206	–	return sc->Energy();
207	–	else
208	–	return TMath::Sqrt(Trk()->P()*Trk()->P() + Mass()*Mass());
209	–	}
210	–
211	–	//-------------------------------------------------------------------------------------------------
212	–	inline Double_t mithep::Electron::P() const
213	–	{
214	–	// Return momentum derived from the SuperCluster if present
215	–	// or else return momentum from the track.
216	–
217	–	const mithep::SuperCluster *sc = SCluster();
218	–	if (sc)
219	–	return TMath::Sqrt(sc->Energy()*sc->Energy() - Mass()*Mass());
220	–	else
221	–	return Trk()->P();
222	–	}
223	–
224	–	//-------------------------------------------------------------------------------------------------
225	–	inline Double_t mithep::Electron::Px() const
226	–	{
227	–	// Return px.
228	–
229	–	return Pt()*TMath::Cos(Trk()->Phi());
230	–	}
231	–
232	–	//-------------------------------------------------------------------------------------------------
233	–	inline Double_t mithep::Electron::Py() const
234	–	{
235	–	// Return py.
236	–
237	–	return Pt()*TMath::Sin(Trk()->Phi());
238	–	}
239	–
240	–	//-------------------------------------------------------------------------------------------------
241	–	inline Double_t mithep::Electron::Pz() const
242	–	{
243	–	// Return pz.
244	–
245	–	return P()*TMath::Sin(Trk()->Lambda());
246	–	}
247	–
248	–	//-------------------------------------------------------------------------------------------------
249	–	inline Double_t mithep::Electron::Pt() const
250	–	{
251	–	// Return pt.
252	–
253	–	return TMath::Abs(P()*TMath::Cos(Trk()->Lambda()));
254	–	}
197		#endif

Diff Legend

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