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.9 by phedex, Wed Jul 6 18:49:35 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 34 | Line 34 | MetTools::MetTools(const MuonCol *fMuons
34		}
35		}
36		if (isMuonTrack) continue;
37	<
37	>
38		if (fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) {
39		trackNumeratorX -= fPFCandidates->At(i)->Px();
40		trackNumeratorY -= fPFCandidates->At(i)->Py();
#	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() || fPFCandidates->At(i)->HasGsfTrk()){
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		}
81		}
82		if (isElectronTrack) continue;
83
84	+	if ((fPFCandidates->At(i)->HasTrackerTrk() && fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) ||
85	+	(fPFCandidates->At(i)->HasGsfTrk()     && fabs(fPFCandidates->At(i)->GsfTrk()->DzCorrected(*fVertex)    ) < deltaZCut)) {
86	+	trackNumeratorX -= fPFCandidates->At(i)->Px();
87	+	trackNumeratorY -= fPFCandidates->At(i)->Py();
88	+	}
89	+	}
90	+
91	+	// neutral
92	+	if (fPFCandidates->At(i)->PFType()== PFCandidate::eNeutralHadron || fPFCandidates->At(i)->PFType()== PFCandidate::eGamma) {
93	+	if (fPFCandidates->At(i)->Pt() > ptCut and fabs(fPFCandidates->At(i)->Eta()) < etaCut ) {
94	+	neutralNumeratorX -= fPFCandidates->At(i)->Px();
95	+	neutralNumeratorY -= fPFCandidates->At(i)->Py();
96	+	}
97	+	}
98	+	}
99	+
100	+	fCorrectedMet = mithep::Met(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
101	+	fCorrectedTrackMet = mithep::Met(trackNumeratorX, trackNumeratorY);
102	+	}
103	+
104	+
105	+	//--------------------------------------------------------------------------------------------------
106	+	MetTools::MetTools(const MuonCol *fMuons, const PFCandidateCol *fPFCandidates, const PFJetCol *pfJets, const Vertex *fVertex,
107	+	float deltaZCut, float ptCut, float etaCut) {
108	+
109	+	float trackNumeratorX  =0, trackNumeratorY  =0;
110	+	float neutralNumeratorX=0, neutralNumeratorY=0;
111	+
112	+	// muons Pt
113	+	for (UInt_t m = 0; m < fMuons->GetEntries(); ++m) {
114	+	trackNumeratorX -= fMuons->At(m)->Px();
115	+	trackNumeratorY -= fMuons->At(m)->Py();
116	+	}
117	+
118	+	// jets Pt
119	+	for (UInt_t j = 0; j < pfJets->GetEntries(); ++j) {
120	+	trackNumeratorX -= pfJets->At(j)->Px();
121	+	trackNumeratorY -= pfJets->At(j)->Py();
122	+	}
123	+
124	+	// PF candidates pT
125	+	for (UInt_t i=0; i<fPFCandidates->GetEntries(); ++i) {
126	+
127	+	// jets
128	+	bool inTheJet = false;
129	+	for (UInt_t j = 0; j < pfJets->GetEntries(); ++j) {
130	+	for (UInt_t c=0;c<pfJets->At(j)->NPFCands();++c){
131	+	if (pfJets->At(j)->PFCand(c) == fPFCandidates->At(i)) {
132	+	inTheJet=true;
133	+	break;
134	+	}
135	+	}
136	+	if (inTheJet) break;
137	+	}
138	+	if (inTheJet) continue;
139	+
140	+	// charged
141	+	if (fPFCandidates->At(i)->HasTrackerTrk()){
142	+
143	+	bool isMuonTrack = false;
144	+	for (UInt_t m = 0; m < fMuons->GetEntries(); ++m) {
145	+	if (fMuons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) {
146	+	isMuonTrack = true;
147	+	break;
148	+	}
149	+	}
150	+	if (isMuonTrack) continue;
151	+
152		if (fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) {
153		trackNumeratorX -= fPFCandidates->At(i)->Px();
154		trackNumeratorY -= fPFCandidates->At(i)->Py();
#	Line 95 | Line 163 | MetTools::MetTools(const ElectronCol *fE
163		}
164		}
165		}
166	<	mithep::Met fCorrectedMet(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
167	<	mithep::Met fCorrectedTrackMet(trackNumeratorX, trackNumeratorY);
166	>
167	>	fCorrectedMet = mithep::Met(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
168	>	fCorrectedTrackMet = mithep::Met(trackNumeratorX, trackNumeratorY);
169	>	}
170	>
171	>
172	>	MetTools::MetTools(const ElectronCol *fElectrons, const PFCandidateCol *fPFCandidates, const PFJetCol *pfJets, const Vertex *fVertex,
173	>	float deltaZCut, float ptCut, float etaCut) {
174	>
175	>	float trackNumeratorX  =0, trackNumeratorY  =0;
176	>	float neutralNumeratorX=0, neutralNumeratorY=0;
177	>
178	>	// electrons Pt
179	>	for (UInt_t m = 0; m < fElectrons->GetEntries(); ++m) {
180	>	trackNumeratorX -= fElectrons->At(m)->Px();
181	>	trackNumeratorY -= fElectrons->At(m)->Py();
182	>	}
183	>
184	>	// jets Pt
185	>	for (UInt_t j = 0; j < pfJets->GetEntries(); ++j) {
186	>	trackNumeratorX -= pfJets->At(j)->Px();
187	>	trackNumeratorY -= pfJets->At(j)->Py();
188	>	}
189	>
190	>	// PF candidates pT
191	>	for (UInt_t i=0; i<fPFCandidates->GetEntries(); ++i) {
192	>
193	>	// jets
194	>	bool inTheJet = false;
195	>	for (UInt_t j = 0; j < pfJets->GetEntries(); ++j) {
196	>	for (UInt_t c=0;c<pfJets->At(j)->NPFCands();++c){
197	>	if (pfJets->At(j)->PFCand(c) == fPFCandidates->At(i)) {
198	>	inTheJet=true;
199	>	break;
200	>	}
201	>	}
202	>	if (inTheJet) break;
203	>	}
204	>	if (inTheJet) continue;
205	>
206	>	// charged
207	>	if (fPFCandidates->At(i)->HasTrackerTrk() || fPFCandidates->At(i)->HasGsfTrk()){
208	>	bool isElectronTrack = false;
209	>	for (UInt_t m = 0; m < fElectrons->GetEntries(); ++m) {
210	>	if ( (fElectrons->At(m)->HasTrackerTrk() and fElectrons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) or
211	>	(fElectrons->At(m)->HasGsfTrk() and fElectrons->At(m)->GsfTrk() == fPFCandidates->At(i)->GsfTrk()) ) {
212	>	isElectronTrack = true;
213	>	break;
214	>	}
215	>	}
216	>	if (isElectronTrack) continue;
217	>
218	>	if ((fPFCandidates->At(i)->HasTrackerTrk() && fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) ||
219	>	(fPFCandidates->At(i)->HasGsfTrk()     && fabs(fPFCandidates->At(i)->GsfTrk()->DzCorrected(*fVertex)    ) < deltaZCut)) {
220	>	trackNumeratorX -= fPFCandidates->At(i)->Px();
221	>	trackNumeratorY -= fPFCandidates->At(i)->Py();
222	>	}
223	>	}
224	>
225	>	// neutral
226	>	if (fPFCandidates->At(i)->PFType()== PFCandidate::eNeutralHadron || fPFCandidates->At(i)->PFType()== PFCandidate::eGamma) {
227	>	if (fPFCandidates->At(i)->Pt() > ptCut and fabs(fPFCandidates->At(i)->Eta()) < etaCut ) {
228	>	neutralNumeratorX -= fPFCandidates->At(i)->Px();
229	>	neutralNumeratorY -= fPFCandidates->At(i)->Py();
230	>	}
231	>	}
232	>	}
233	>
234	>	fCorrectedMet = mithep::Met(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
235	>	fCorrectedTrackMet = mithep::Met(trackNumeratorX, trackNumeratorY);
236	>	}
237	>
238	>
239	>	void MetTools::AddToCorrectedTrackMet( const Particle *p) {
240	>	float MetX = fCorrectedTrackMet.Mex();
241	>	float MetY = fCorrectedTrackMet.Mey();
242	>
243	>	MetX -= p->Px();
244	>	MetY -= p->Py();
245	>
246	>	fCorrectedTrackMet.SetMex(MetX);
247	>	fCorrectedTrackMet.SetMey(MetY);
248	>
249	>	return;
250		}
251
252	+	void MetTools::AddToCorrectedMet( const Particle *p) {
253	+	float MetX=fCorrectedMet.Mex();
254	+	float MetY=fCorrectedMet.Mey();
255	+
256	+	MetX -= p->Px();
257	+	MetY -= p->Py();
258	+
259	+	fCorrectedMet.SetMex(MetX);
260	+	fCorrectedMet.SetMey(MetY);
261	+
262	+	return;
263	+	}
264	+
265	+
266		MetTools::MetTools(const MuonCol *fMuons, const ElectronCol *fElectrons, const PFCandidateCol *fPFCandidates,
267		const Vertex *fVertex, float deltaZCut, float ptCut, float etaCut) {
268
#	Line 121 | Line 285 | MetTools::MetTools(const MuonCol *fMuons
285		for (UInt_t i=0; i<fPFCandidates->GetEntries(); ++i) {
286
287		// charged
288	<	if (fPFCandidates->At(i)->TrackerTrk()){
288	>	if (fPFCandidates->At(i)->HasTrackerTrk() || fPFCandidates->At(i)->HasGsfTrk()){
289		bool isMuonTrack = false;
290		for (UInt_t m = 0; m < fMuons->GetEntries(); ++m) {
291		if (fMuons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) {
#	Line 133 | Line 297 | MetTools::MetTools(const MuonCol *fMuons
297
298		bool isElectronTrack = false;
299		for (UInt_t m = 0; m < fElectrons->GetEntries(); ++m) {
300	<	if ((fElectrons->At(m)->TrackerTrk() && fPFCandidates->At(i)->TrackerTrk() && fElectrons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) or
301	<	(fElectrons->At(m)->GsfTrk()     && fPFCandidates->At(i)->GsfTrk()     && fElectrons->At(m)->GsfTrk()     == fPFCandidates->At(i)->GsfTrk())) {
300	>	if ( (fElectrons->At(m)->HasTrackerTrk() and fElectrons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) or
301	>	(fElectrons->At(m)->HasGsfTrk() and fElectrons->At(m)->GsfTrk() == fPFCandidates->At(i)->GsfTrk()) ) {
302		isElectronTrack = true;
303		break;
304		}
305		}
306		if (isElectronTrack) continue;
307
308	<	if (fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) {
308	>	if ((fPFCandidates->At(i)->HasTrackerTrk() && fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) ||
309	>	(fPFCandidates->At(i)->HasGsfTrk()     && fabs(fPFCandidates->At(i)->GsfTrk()->DzCorrected(*fVertex)    ) < deltaZCut)) {
310		trackNumeratorX -= fPFCandidates->At(i)->Px();
311		trackNumeratorY -= fPFCandidates->At(i)->Py();
312		}
#	Line 155 | Line 320 | MetTools::MetTools(const MuonCol *fMuons
320		}
321		}
322		}
323	<	mithep::Met fCorrectedMet(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
324	<	mithep::Met fCorrectedTrackMet(trackNumeratorX, trackNumeratorY);
323	>	fCorrectedMet = mithep::Met(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
324	>	fCorrectedTrackMet = mithep::Met(trackNumeratorX, trackNumeratorY);
325		}
326
327	<	Met MetTools::GetMimumMet(const Met *UncorrectedMet) {
327	>
328	>	MetTools::MetTools(const MuonCol *fMuons, const ElectronCol *fElectrons, const PFCandidateCol *fPFCandidates,
329	>	const PFJetCol *pfJets,
330	>	const Vertex *fVertex, float deltaZCut, float ptCut, float etaCut) {
331	>
332	>	float trackNumeratorX  =0, trackNumeratorY  =0;
333	>	float neutralNumeratorX=0, neutralNumeratorY=0;
334	>
335	>	// muons Pt
336	>	for (UInt_t m = 0; m < fMuons->GetEntries(); ++m) {
337	>	trackNumeratorX -= fMuons->At(m)->Px();
338	>	trackNumeratorY -= fMuons->At(m)->Py();
339	>	}
340	>
341	>	// electrons Pt
342	>	for (UInt_t m = 0; m < fElectrons->GetEntries(); ++m) {
343	>	trackNumeratorX -= fElectrons->At(m)->Px();
344	>	trackNumeratorY -= fElectrons->At(m)->Py();
345	>	}
346	>
347	>	// jets Pt
348	>	for (UInt_t j = 0; j < pfJets->GetEntries(); ++j) {
349	>	trackNumeratorX -= pfJets->At(j)->Px();
350	>	trackNumeratorY -= pfJets->At(j)->Py();
351	>	}
352	>
353	>	// PF candidates pT
354	>	for (UInt_t i=0; i<fPFCandidates->GetEntries(); ++i) {
355	>
356	>	// jets
357	>	bool inTheJet = false;
358	>	for (UInt_t j = 0; j < pfJets->GetEntries(); ++j) {
359	>	for (UInt_t c=0;c<pfJets->At(j)->NPFCands();++c){
360	>	if (pfJets->At(j)->PFCand(c) == fPFCandidates->At(i)) {
361	>	inTheJet=true;
362	>	break;
363	>	}
364	>	}
365	>	if (inTheJet) break;
366	>	}
367	>	if (inTheJet) continue;
368	>
369	>
370	>	// charged
371	>	if (fPFCandidates->At(i)->HasTrackerTrk() || fPFCandidates->At(i)->HasGsfTrk()){
372	>	bool isMuonTrack = false;
373	>	for (UInt_t m = 0; m < fMuons->GetEntries(); ++m) {
374	>	if (fMuons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) {
375	>	isMuonTrack = true;
376	>	break;
377	>	}
378	>	}
379	>	if (isMuonTrack) continue;
380	>
381	>	bool isElectronTrack = false;
382	>	for (UInt_t m = 0; m < fElectrons->GetEntries(); ++m) {
383	>	if ( (fElectrons->At(m)->HasTrackerTrk() and fElectrons->At(m)->TrackerTrk() == fPFCandidates->At(i)->TrackerTrk()) or
384	>	(fElectrons->At(m)->HasGsfTrk() and fElectrons->At(m)->GsfTrk() == fPFCandidates->At(i)->GsfTrk()) ) {
385	>	isElectronTrack = true;
386	>	break;
387	>	}
388	>	}
389	>	if (isElectronTrack) continue;
390	>
391	>	if ((fPFCandidates->At(i)->HasTrackerTrk() && fabs(fPFCandidates->At(i)->TrackerTrk()->DzCorrected(*fVertex)) < deltaZCut) ||
392	>	(fPFCandidates->At(i)->HasGsfTrk()     && fabs(fPFCandidates->At(i)->GsfTrk()->DzCorrected(*fVertex)    ) < deltaZCut)) {
393	>	trackNumeratorX -= fPFCandidates->At(i)->Px();
394	>	trackNumeratorY -= fPFCandidates->At(i)->Py();
395	>	}
396	>	}
397	>
398	>	// neutral
399	>	if (fPFCandidates->At(i)->PFType()== PFCandidate::eNeutralHadron || fPFCandidates->At(i)->PFType()== PFCandidate::eGamma) {
400	>	if (fPFCandidates->At(i)->Pt() > ptCut and fabs(fPFCandidates->At(i)->Eta()) < etaCut ) {
401	>	neutralNumeratorX -= fPFCandidates->At(i)->Px();
402	>	neutralNumeratorY -= fPFCandidates->At(i)->Py();
403	>	}
404	>	}
405	>	}
406	>	fCorrectedMet = mithep::Met(trackNumeratorX+neutralNumeratorX, trackNumeratorY+neutralNumeratorY);
407	>	fCorrectedTrackMet = mithep::Met(trackNumeratorX, trackNumeratorY);
408	>	}
409	>
410	>
411	>	Met MetTools::GetMinimumMet(const Met *UncorrectedMet) {
412
413		return (fCorrectedMet.Pt() < UncorrectedMet->Pt()) ?  fCorrectedMet : *UncorrectedMet;
414		}
415
416	<	Met MetTools::GetMimumTrackMet(const Met *UncorrectedMet) {
416	>	Met MetTools::GetMinimumTrackMet(const Met *UncorrectedMet) {
417
418		return (fCorrectedTrackMet.Pt() < UncorrectedMet->Pt()) ?  fCorrectedTrackMet : *UncorrectedMet;
419		}

Diff Legend

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