ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/UserCode/MitPhysics/Utils/src/MetTools.cc

Comparing UserCode/MitPhysics/Utils/src/MetTools.cc (file contents):
Revision 1.2 by ceballos, Tue Mar 15 08:35:01 2011 UTC vs.
Revision 1.5 by mzanetti, Tue Apr 12 23:17:06 2011 UTC

#	Line 24 | Line 24 | MetTools::MetTools(const MuonCol *fMuons
24		for (UInt_t i=0; i<fPFCandidates->GetEntries(); ++i) {
25
26		// charged
27	<	if (fPFCandidates->At(i)->TrackerTrk()){
27	>	if (fPFCandidates->At(i)->HasTrackerTrk()){
28
29		bool isMuonTrack = false;
30		for (UInt_t m = 0; m < fMuons->GetEntries(); ++m) {
#	Line 50 | Line 50 | MetTools::MetTools(const MuonCol *fMuons
50		}
51		}
52
53	<	mithep::Met fCorrectedMet(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
54	<	mithep::Met fCorrectedTrackMet(trackNumeratorX, trackNumeratorY);
53	>	fCorrectedMet = mithep::Met(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
54	>	fCorrectedTrackMet = mithep::Met(trackNumeratorX, trackNumeratorY);
55		}
56
57		MetTools::MetTools(const ElectronCol *fElectrons, const PFCandidateCol *fPFCandidates, const Vertex *fVertex,
#	Line 70 | Line 70 | MetTools::MetTools(const ElectronCol *fE
70		for (UInt_t i=0; i<fPFCandidates->GetEntries(); ++i) {
71
72		// charged
73	<	if (fPFCandidates->At(i)->TrackerTrk()){
73	>	if (fPFCandidates->At(i)->HasTrackerTrk()){
74		bool isElectronTrack = false;
75		for (UInt_t m = 0; m < fElectrons->GetEntries(); ++m) {
76	<	if ((fElectrons->At(m)->TrackerTrk() && fPFCandidates->At(i)->TrackerTrk() && fElectrons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) or
77	<	(fElectrons->At(m)->GsfTrk()     && fPFCandidates->At(i)->GsfTrk()     && fElectrons->At(m)->GsfTrk()     == fPFCandidates->At(i)->GsfTrk())) {
76	>	if ( (fElectrons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) or
77	>	(fElectrons->At(m)->HasGsfTrk() and fElectrons->At(m)->GsfTrk() == fPFCandidates->At(i)->GsfTrk()) ) {
78		isElectronTrack = true;
79		break;
80		}
#	Line 95 | Line 95 | MetTools::MetTools(const ElectronCol *fE
95		}
96		}
97		}
98	<	mithep::Met fCorrectedMet(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
99	<	mithep::Met fCorrectedTrackMet(trackNumeratorX, trackNumeratorY);
98	>
99	>	fCorrectedMet = mithep::Met(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
100	>	fCorrectedTrackMet = mithep::Met(trackNumeratorX, trackNumeratorY);
101		}
102
103	+
104	+	//--------------------------------------------------------------------------------------------------
105	+	MetTools::MetTools(const MuonCol *fMuons, const PFCandidateCol *fPFCandidates, const PFJetCol *pfJets, const Vertex *fVertex,
106	+	float deltaZCut, float ptCut, float etaCut) {
107	+
108	+	float trackNumeratorX  =0, trackNumeratorY  =0;
109	+	float neutralNumeratorX=0, neutralNumeratorY=0;
110	+
111	+	// muons Pt
112	+	for (UInt_t m = 0; m < fMuons->GetEntries(); ++m) {
113	+	trackNumeratorX -= fMuons->At(m)->Px();
114	+	trackNumeratorY -= fMuons->At(m)->Py();
115	+	}
116	+
117	+	// jets Pt
118	+	for (UInt_t j = 0; j < pfJets->GetEntries(); ++j) {
119	+	trackNumeratorX -= pfJets->At(j)->Px();
120	+	trackNumeratorY -= pfJets->At(j)->Py();
121	+	}
122	+
123	+	// PF candidates pT
124	+	for (UInt_t i=0; i<fPFCandidates->GetEntries(); ++i) {
125	+
126	+	// jets
127	+	bool inTheJet = false;
128	+	for (UInt_t j = 0; j < pfJets->GetEntries(); ++j) {
129	+	for (UInt_t c=0;c<pfJets->At(j)->NPFCands();++c){
130	+	if (pfJets->At(j)->PFCand(c) == fPFCandidates->At(i)) {
131	+	inTheJet=true;
132	+	break;
133	+	}
134	+	}
135	+	if (inTheJet) break;
136	+	}
137	+	if (inTheJet) continue;
138	+
139	+	// charged
140	+	if (fPFCandidates->At(i)->HasTrackerTrk()){
141	+
142	+	bool isMuonTrack = false;
143	+	for (UInt_t m = 0; m < fMuons->GetEntries(); ++m) {
144	+	if (fMuons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) {
145	+	isMuonTrack = true;
146	+	break;
147	+	}
148	+	}
149	+	if (isMuonTrack) continue;
150	+
151	+	if (fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) {
152	+	trackNumeratorX -= fPFCandidates->At(i)->Px();
153	+	trackNumeratorY -= fPFCandidates->At(i)->Py();
154	+	}
155	+	}
156	+
157	+	// neutral
158	+	if (fPFCandidates->At(i)->PFType()== PFCandidate::eNeutralHadron || fPFCandidates->At(i)->PFType()== PFCandidate::eGamma) {
159	+	if (fPFCandidates->At(i)->Pt() > ptCut and fabs(fPFCandidates->At(i)->Eta()) < etaCut ) {
160	+	neutralNumeratorX -= fPFCandidates->At(i)->Px();
161	+	neutralNumeratorY -= fPFCandidates->At(i)->Py();
162	+	}
163	+	}
164	+	}
165	+
166	+	fCorrectedMet = mithep::Met(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
167	+	fCorrectedTrackMet = mithep::Met(trackNumeratorX, trackNumeratorY);
168	+	}
169	+
170	+
171	+	MetTools::MetTools(const ElectronCol *fElectrons, const PFCandidateCol *fPFCandidates, const PFJetCol *pfJets, const Vertex *fVertex,
172	+	float deltaZCut, float ptCut, float etaCut) {
173	+
174	+	float trackNumeratorX  =0, trackNumeratorY  =0;
175	+	float neutralNumeratorX=0, neutralNumeratorY=0;
176	+
177	+	// electrons Pt
178	+	for (UInt_t m = 0; m < fElectrons->GetEntries(); ++m) {
179	+	trackNumeratorX -= fElectrons->At(m)->Px();
180	+	trackNumeratorY -= fElectrons->At(m)->Py();
181	+	}
182	+
183	+	// jets Pt
184	+	for (UInt_t j = 0; j < pfJets->GetEntries(); ++j) {
185	+	trackNumeratorX -= pfJets->At(j)->Px();
186	+	trackNumeratorY -= pfJets->At(j)->Py();
187	+	}
188	+
189	+	// PF candidates pT
190	+	for (UInt_t i=0; i<fPFCandidates->GetEntries(); ++i) {
191	+
192	+	// jets
193	+	bool inTheJet = false;
194	+	for (UInt_t j = 0; j < pfJets->GetEntries(); ++j) {
195	+	for (UInt_t c=0;c<pfJets->At(j)->NPFCands();++c){
196	+	if (pfJets->At(j)->PFCand(c) == fPFCandidates->At(i)) {
197	+	inTheJet=true;
198	+	break;
199	+	}
200	+	}
201	+	if (inTheJet) break;
202	+	}
203	+	if (inTheJet) continue;
204	+
205	+	// charged
206	+	if (fPFCandidates->At(i)->HasTrackerTrk()){
207	+	bool isElectronTrack = false;
208	+	for (UInt_t m = 0; m < fElectrons->GetEntries(); ++m) {
209	+	if ( (fElectrons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) or
210	+	(fElectrons->At(m)->HasGsfTrk() and fElectrons->At(m)->GsfTrk() == fPFCandidates->At(i)->GsfTrk()) ) {
211	+	isElectronTrack = true;
212	+	break;
213	+	}
214	+	}
215	+	if (isElectronTrack) continue;
216	+
217	+	if (fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) {
218	+	trackNumeratorX -= fPFCandidates->At(i)->Px();
219	+	trackNumeratorY -= fPFCandidates->At(i)->Py();
220	+	}
221	+	}
222	+
223	+	// neutral
224	+	if (fPFCandidates->At(i)->PFType()== PFCandidate::eNeutralHadron || fPFCandidates->At(i)->PFType()== PFCandidate::eGamma) {
225	+	if (fPFCandidates->At(i)->Pt() > ptCut and fabs(fPFCandidates->At(i)->Eta()) < etaCut ) {
226	+	neutralNumeratorX -= fPFCandidates->At(i)->Px();
227	+	neutralNumeratorY -= fPFCandidates->At(i)->Py();
228	+	}
229	+	}
230	+	}
231	+
232	+	fCorrectedMet = mithep::Met(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
233	+	fCorrectedTrackMet = mithep::Met(trackNumeratorX, trackNumeratorY);
234	+	}
235	+
236	+
237	+	MetTools::MetTools(const MuonCol *fMuons, const ElectronCol *fElectrons, const PFCandidateCol *fPFCandidates,
238	+	const Vertex *fVertex, float deltaZCut, float ptCut, float etaCut) {
239	+
240	+	float trackNumeratorX  =0, trackNumeratorY  =0;
241	+	float neutralNumeratorX=0, neutralNumeratorY=0;
242	+
243	+	// muons Pt
244	+	for (UInt_t m = 0; m < fMuons->GetEntries(); ++m) {
245	+	trackNumeratorX -= fMuons->At(m)->Px();
246	+	trackNumeratorY -= fMuons->At(m)->Py();
247	+	}
248	+
249	+	// electrons Pt
250	+	for (UInt_t m = 0; m < fElectrons->GetEntries(); ++m) {
251	+	trackNumeratorX -= fElectrons->At(m)->Px();
252	+	trackNumeratorY -= fElectrons->At(m)->Py();
253	+	}
254	+
255	+	// PF candidates pT
256	+	for (UInt_t i=0; i<fPFCandidates->GetEntries(); ++i) {
257	+
258	+	// charged
259	+	if (fPFCandidates->At(i)->HasTrackerTrk()){
260	+	bool isMuonTrack = false;
261	+	for (UInt_t m = 0; m < fMuons->GetEntries(); ++m) {
262	+	if (fMuons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) {
263	+	isMuonTrack = true;
264	+	break;
265	+	}
266	+	}
267	+	if (isMuonTrack) continue;
268	+
269	+	bool isElectronTrack = false;
270	+	for (UInt_t m = 0; m < fElectrons->GetEntries(); ++m) {
271	+	if ( (fElectrons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) or
272	+	(fElectrons->At(m)->HasGsfTrk() and fElectrons->At(m)->GsfTrk() == fPFCandidates->At(i)->GsfTrk()) ) {
273	+	isElectronTrack = true;
274	+	break;
275	+	}
276	+	}
277	+	if (isElectronTrack) continue;
278	+
279	+	if (fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) {
280	+	trackNumeratorX -= fPFCandidates->At(i)->Px();
281	+	trackNumeratorY -= fPFCandidates->At(i)->Py();
282	+	}
283	+	}
284	+
285	+	// neutral
286	+	if (fPFCandidates->At(i)->PFType()== PFCandidate::eNeutralHadron || fPFCandidates->At(i)->PFType()== PFCandidate::eGamma) {
287	+	if (fPFCandidates->At(i)->Pt() > ptCut and fabs(fPFCandidates->At(i)->Eta()) < etaCut ) {
288	+	neutralNumeratorX -= fPFCandidates->At(i)->Px();
289	+	neutralNumeratorY -= fPFCandidates->At(i)->Py();
290	+	}
291	+	}
292	+	}
293	+	fCorrectedMet = mithep::Met(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
294	+	fCorrectedTrackMet = mithep::Met(trackNumeratorX, trackNumeratorY);
295	+	}
296	+
297	+
298		MetTools::MetTools(const MuonCol *fMuons, const ElectronCol *fElectrons, const PFCandidateCol *fPFCandidates,
299	+	const PFJetCol *pfJets,
300		const Vertex *fVertex, float deltaZCut, float ptCut, float etaCut) {
301
302		float trackNumeratorX  =0, trackNumeratorY  =0;
#	Line 117 | Line 314 | MetTools::MetTools(const MuonCol *fMuons
314		trackNumeratorY -= fElectrons->At(m)->Py();
315		}
316
317	+	// jets Pt
318	+	for (UInt_t j = 0; j < pfJets->GetEntries(); ++j) {
319	+	trackNumeratorX -= pfJets->At(j)->Px();
320	+	trackNumeratorY -= pfJets->At(j)->Py();
321	+	}
322	+
323		// PF candidates pT
324		for (UInt_t i=0; i<fPFCandidates->GetEntries(); ++i) {
325
326	+	// jets
327	+	bool inTheJet = false;
328	+	for (UInt_t j = 0; j < pfJets->GetEntries(); ++j) {
329	+	for (UInt_t c=0;c<pfJets->At(j)->NPFCands();++c){
330	+	if (pfJets->At(j)->PFCand(c) == fPFCandidates->At(i)) {
331	+	inTheJet=true;
332	+	break;
333	+	}
334	+	}
335	+	if (inTheJet) break;
336	+	}
337	+	if (inTheJet) continue;
338	+
339	+
340		// charged
341	<	if (fPFCandidates->At(i)->TrackerTrk()){
341	>	if (fPFCandidates->At(i)->HasTrackerTrk()){
342		bool isMuonTrack = false;
343		for (UInt_t m = 0; m < fMuons->GetEntries(); ++m) {
344		if (fMuons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) {
#	Line 133 | Line 350 | MetTools::MetTools(const MuonCol *fMuons
350
351		bool isElectronTrack = false;
352		for (UInt_t m = 0; m < fElectrons->GetEntries(); ++m) {
353	<	if ((fElectrons->At(m)->TrackerTrk() && fPFCandidates->At(i)->TrackerTrk() && fElectrons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) or
354	<	(fElectrons->At(m)->GsfTrk()     && fPFCandidates->At(i)->GsfTrk()     && fElectrons->At(m)->GsfTrk()     == fPFCandidates->At(i)->GsfTrk())) {
353	>	if ( (fElectrons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) or
354	>	(fElectrons->At(m)->HasGsfTrk() and fElectrons->At(m)->GsfTrk() == fPFCandidates->At(i)->GsfTrk()) ) {
355		isElectronTrack = true;
356		break;
357		}
#	Line 155 | Line 372 | MetTools::MetTools(const MuonCol *fMuons
372		}
373		}
374		}
375	<	mithep::Met fCorrectedMet(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
376	<	mithep::Met fCorrectedTrackMet(trackNumeratorX, trackNumeratorY);
375	>	fCorrectedMet = mithep::Met(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
376	>	fCorrectedTrackMet = mithep::Met(trackNumeratorX, trackNumeratorY);
377		}
378
379	<	Met MetTools::GetMimumMet(const Met *UncorrectedMet) {
379	>
380	>	Met MetTools::GetMinimumMet(const Met *UncorrectedMet) {
381
382		return (fCorrectedMet.Pt() < UncorrectedMet->Pt()) ?  fCorrectedMet : *UncorrectedMet;
383		}
384
385	<	Met MetTools::GetMimumTrackMet(const Met *UncorrectedMet) {
385	>	Met MetTools::GetMinimumTrackMet(const Met *UncorrectedMet) {
386
387		return (fCorrectedTrackMet.Pt() < UncorrectedMet->Pt()) ?  fCorrectedTrackMet : *UncorrectedMet;
388		}

Diff Legend

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