ViewVC Help
View File | Revision Log | Show Annotations | Root Listing
root/cvsroot/UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc
Revision: 1.29
Committed: Sun Jun 3 15:51:51 2012 UTC (12 years, 11 months ago) by khahn
Content type: text/plain
Branch: MAIN
Changes since 1.28: +332 -0 lines
Log Message: 
FSR syncing...

File Contents

# Content
1 #include <math.h>
2
3 #include "IsolationSelection.h"
4 #include "IsolationSelectionDefs.h"
5
6 #include "MathUtils.h"
7 #include "MuonTools.h"
8 #include "MuonIDMVA.h"
9 #include "ElectronTools.h"
10 #include "ElectronIDMVA.h"
11
12 using namespace mithep;
13
14 mithep::MuonIDMVA * muIsoMVA;
15 mithep::MuonTools muT;
16 mithep::ElectronIDMVA * eleIsoMVA;
17 mithep::ElectronTools eleT;
18
19 // global hack to sync
20 double gChargedIso;
21 double gGammaIso;
22 double gNeutralIso;
23
24 extern vector<bool> PFnoPUflag;
25
26 //--------------------------------------------------------------------------------------------------
27 Float_t computePFMuonIso(const mithep::Muon *muon,
28 const mithep::Vertex * vtx,
29 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
30 const Double_t dRMax)
31 //--------------------------------------------------------------------------------------------------
32 {
33 const Double_t dRMin = 0;
34 const Double_t neuPtMin = 1.0;
35 const Double_t dzMax = 0.1;
36
37 Double_t zLepton = (muon->BestTrk()) ? muon->BestTrk()->DzCorrected(*vtx) : 0.0;
38
39 Float_t iso=0;
40 for(UInt_t ipf=0; ipf<fPFCandidates->GetEntries(); ipf++) {
41 const PFCandidate *pfcand = fPFCandidates->At(ipf);
42
43 if(!pfcand->HasTrk() && (pfcand->Pt()<=neuPtMin)) continue; // pT cut on neutral particles
44
45 // exclude THE muon
46 if(pfcand->TrackerTrk() && muon->TrackerTrk() && (pfcand->TrackerTrk()==muon->TrackerTrk())) continue;
47
48 // dz cut
49 Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(*vtx) - zLepton) : 0;
50 if(dz >= dzMax) continue;
51
52 // check iso cone
53 Double_t dr = MathUtils::DeltaR(muon->Mom(), pfcand->Mom());
54 if(dr<dRMax && dr>=dRMin)
55 iso += pfcand->Pt();
56 }
57
58 return iso;
59 }
60
61 //--------------------------------------------------------------------------------------------------
62 Float_t computePFEleIso(const mithep::Electron *electron,
63 const mithep::Vertex * fVertex,
64 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
65 const Double_t dRMax)
66 //--------------------------------------------------------------------------------------------------
67 {
68 const Double_t dRMin = 0;
69 const Double_t neuPtMin = 1.0;
70 const Double_t dzMax = 0.1;
71
72 Double_t zLepton = (electron->BestTrk()) ? electron->BestTrk()->DzCorrected(*fVertex) : 0.0;
73
74 Float_t iso=0;
75 for(UInt_t ipf=0; ipf<fPFCandidates->GetEntries(); ipf++) {
76 const PFCandidate *pfcand = (PFCandidate*)(fPFCandidates->At(ipf));
77
78 if(!pfcand->HasTrk() && (pfcand->Pt()<=neuPtMin)) continue; // pT cut on neutral particles
79
80 // dz cut
81 Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(*fVertex) - zLepton) : 0;
82 if(dz >= dzMax) continue;
83
84 // remove THE electron
85 if(pfcand->TrackerTrk() && electron->TrackerTrk() && (pfcand->TrackerTrk()==electron->TrackerTrk())) continue;
86 if(pfcand->GsfTrk() && electron->GsfTrk() && (pfcand->GsfTrk()==electron->GsfTrk())) continue;
87
88 // check iso cone
89 Double_t dr = MathUtils::DeltaR(electron->Mom(), pfcand->Mom());
90 if(dr<dRMax && dr>=dRMin) {
91 // eta-strip veto for photons
92 if((pfcand->PFType() == PFCandidate::eGamma) && fabs(electron->Eta() - pfcand->Eta()) < 0.025) continue;
93
94 // Inner cone (one tower = dR < 0.07) veto for non-photon neutrals
95 if(!pfcand->HasTrk() && (pfcand->PFType() == PFCandidate::eNeutralHadron) &&
96 (MathUtils::DeltaR(electron->Mom(), pfcand->Mom()) < 0.07)) continue;
97
98 iso += pfcand->Pt();
99 }
100 }
101
102 return iso;
103 };
104
105 //--------------------------------------------------------------------------------------------------
106 bool pairwiseIsoSelection( ControlFlags &ctrl,
107 vector<SimpleLepton> &lepvec,
108 float rho )
109 //--------------------------------------------------------------------------------------------------
110 {
111
112 bool passiso=true;
113
114 for( int i=0; i<lepvec.size(); i++ )
115 {
116
117 if( !(lepvec[i].is4l) ) continue;
118
119 float effArea_ecal_i, effArea_hcal_i;
120 if( lepvec[i].isEB ) {
121 if( lepvec[i].type == 11 ) {
122 effArea_ecal_i = 0.101;
123 effArea_hcal_i = 0.021;
124 } else {
125 effArea_ecal_i = 0.074;
126 effArea_hcal_i = 0.022;
127 }
128 } else {
129 if( lepvec[i].type == 11 ) {
130 effArea_ecal_i = 0.046;
131 effArea_hcal_i = 0.040;
132 } else {
133 effArea_ecal_i = 0.045;
134 effArea_hcal_i = 0.030;
135 }
136 }
137
138 float isoEcal_corr_i = lepvec[i].isoEcal - (effArea_ecal_i*rho);
139 float isoHcal_corr_i = lepvec[i].isoHcal - (effArea_hcal_i*rho);
140
141 for( int j=i+1; j<lepvec.size(); j++ )
142 {
143
144 if( !(lepvec[j].is4l) ) continue;
145
146 float effArea_ecal_j, effArea_hcal_j;
147 if( lepvec[j].isEB ) {
148 if( lepvec[j].type == 11 ) {
149 effArea_ecal_j = 0.101;
150 effArea_hcal_j = 0.021;
151 } else {
152 effArea_ecal_j = 0.074;
153 effArea_hcal_j = 0.022;
154 }
155 } else {
156 if( lepvec[j].type == 11 ) {
157 effArea_ecal_j = 0.046;
158 effArea_hcal_j = 0.040;
159 } else {
160 effArea_ecal_j = 0.045;
161 effArea_hcal_j = 0.030;
162 }
163 }
164
165 float isoEcal_corr_j = lepvec[j].isoEcal - (effArea_ecal_j*rho);
166 float isoHcal_corr_j = lepvec[j].isoHcal - (effArea_hcal_j*rho);
167 float RIso_i = (lepvec[i].isoTrk+isoEcal_corr_i+isoHcal_corr_i)/lepvec[i].vec.Pt();
168 float RIso_j = (lepvec[j].isoTrk+isoEcal_corr_j+isoHcal_corr_j)/lepvec[j].vec.Pt();
169 float comboIso = RIso_i + RIso_j;
170
171 if( comboIso > 0.35 ) {
172 if( ctrl.debug ) cout << "combo failing for indices: " << i << "," << j << endl;
173 passiso = false;
174 return passiso;
175 }
176 }
177 }
178
179 return passiso;
180 }
181
182 //--------------------------------------------------------------------------------------------------
183 SelectionStatus muonIsoSelection(ControlFlags &ctrl,
184 const mithep::Muon * mu,
185 const mithep::Vertex * vtx,
186 const mithep::Array<mithep::PFCandidate> * fPFCandidateCol )
187 //--------------------------------------------------------------------------------------------------
188 {
189 float reliso = computePFMuonIso(mu,vtx,fPFCandidateCol,0.3)/mu->Pt();
190 bool isEB = (fabs(mu->Eta()) < 1.479 ? 1 : 0 );
191 bool failiso = false;
192 if( isEB && mu->Pt() > 20 && reliso > PFISO_MU_LOOSE_EB_HIGHPT ) {
193 failiso = true;
194 }
195 if( isEB && mu->Pt() < 20 && reliso > PFISO_MU_LOOSE_EB_LOWPT ) {
196 failiso = true;
197 }
198 if( !(isEB) && mu->Pt() > 20 && reliso > PFISO_MU_LOOSE_EE_HIGHPT ) {
199 failiso = true;
200 }
201 if( !(isEB) && mu->Pt() < 20 && reliso > PFISO_MU_LOOSE_EE_LOWPT ) {
202 failiso = true;
203 }
204
205 SelectionStatus status;
206 if( !failiso ) status.setStatus(SelectionStatus::LOOSEISO);
207 if( !failiso ) status.setStatus(SelectionStatus::TIGHTISO);
208 return status;
209
210 };
211
212 //--------------------------------------------------------------------------------------------------
213 SelectionStatus electronIsoSelection(ControlFlags &ctrl,
214 const mithep::Electron * ele,
215 const mithep::Vertex *fVertex,
216 const mithep::Array<mithep::PFCandidate> * fPFCandidates)
217 //--------------------------------------------------------------------------------------------------
218 {
219
220 bool failiso=false;
221
222 float reliso = computePFEleIso(ele,fVertex,fPFCandidates,0.4)/ele->Pt();
223
224 if( ele->IsEB() && ele->Pt() > 20 && reliso > PFISO_ELE_LOOSE_EB_HIGHPT ) {
225 failiso = true;
226 }
227 if( ele->IsEB() && ele->Pt() < 20 && reliso > PFISO_ELE_LOOSE_EB_LOWPT ) {
228 failiso = true;
229 }
230 if( !(ele->IsEB()) && ele->Pt() > 20 && reliso > PFISO_ELE_LOOSE_EE_HIGHPT ) {
231 failiso = true;
232 }
233 if( !(ele->IsEB()) && ele->Pt() < 20 && reliso > PFISO_ELE_LOOSE_EE_LOWPT ) {
234 failiso = true;
235 }
236
237 SelectionStatus status;
238 if( !failiso ) {
239 status.orStatus(SelectionStatus::LOOSEISO);
240 status.orStatus(SelectionStatus::TIGHTISO);
241 }
242 if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
243 return status;
244
245 }
246
247
248 bool noIso(ControlFlags &, vector<SimpleLepton> &, float rho) {
249
250 return true;
251 }
252
253
254 //--------------------------------------------------------------------------------------------------
255 SelectionStatus muonIsoMVASelection(ControlFlags &ctrl,
256 const mithep::Muon * mu,
257 const mithep::Vertex * vtx,
258 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
259 const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
260 mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
261 vector<const mithep::Muon*> muonsToVeto,
262 vector<const mithep::Electron*> electronsToVeto)
263 //--------------------------------------------------------------------------------------------------
264 {
265
266 if( ctrl.debug ) {
267 cout << "muonIsoMVASelection :: muons to veto " << endl;
268 for( int i=0; i<muonsToVeto.size(); i++ ) {
269 const mithep::Muon * vmu = muonsToVeto[i];
270 cout << "\tpt: " << vmu->Pt()
271 << "\teta: " << vmu->Eta()
272 << "\tphi: " << vmu->Phi()
273 << endl;
274 }
275 cout << "muonIsoMVASelection :: electrson to veto " << endl;
276 for( int i=0; i<electronsToVeto.size(); i++ ) {
277 const mithep::Electron * vel = electronsToVeto[i];
278 cout << "\tpt: " << vel->Pt()
279 << "\teta: " << vel->Eta()
280 << "\tphi: " << vel->Phi()
281 << endl;
282 }
283 }
284 bool failiso=false;
285
286 //
287 // tmp iso rings
288 //
289 Double_t tmpChargedIso_DR0p0To0p1 = 0;
290 Double_t tmpChargedIso_DR0p1To0p2 = 0;
291 Double_t tmpChargedIso_DR0p2To0p3 = 0;
292 Double_t tmpChargedIso_DR0p3To0p4 = 0;
293 Double_t tmpChargedIso_DR0p4To0p5 = 0;
294 Double_t tmpChargedIso_DR0p5To0p7 = 0;
295
296 Double_t tmpGammaIso_DR0p0To0p1 = 0;
297 Double_t tmpGammaIso_DR0p1To0p2 = 0;
298 Double_t tmpGammaIso_DR0p2To0p3 = 0;
299 Double_t tmpGammaIso_DR0p3To0p4 = 0;
300 Double_t tmpGammaIso_DR0p4To0p5 = 0;
301 Double_t tmpGammaIso_DR0p5To0p7 = 0;
302
303 Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
304 Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
305 Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
306 Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
307 Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
308 Double_t tmpNeutralHadronIso_DR0p5To0p7 = 0;
309
310
311
312 //
313 // final rings for the MVA
314 //
315 Double_t fChargedIso_DR0p0To0p1;
316 Double_t fChargedIso_DR0p1To0p2;
317 Double_t fChargedIso_DR0p2To0p3;
318 Double_t fChargedIso_DR0p3To0p4;
319 Double_t fChargedIso_DR0p4To0p5;
320 Double_t fChargedIso_DR0p5To0p7;
321
322 Double_t fGammaIso_DR0p0To0p1;
323 Double_t fGammaIso_DR0p1To0p2;
324 Double_t fGammaIso_DR0p2To0p3;
325 Double_t fGammaIso_DR0p3To0p4;
326 Double_t fGammaIso_DR0p4To0p5;
327 Double_t fGammaIso_DR0p5To0p7;
328
329 Double_t fNeutralHadronIso_DR0p0To0p1;
330 Double_t fNeutralHadronIso_DR0p1To0p2;
331 Double_t fNeutralHadronIso_DR0p2To0p3;
332 Double_t fNeutralHadronIso_DR0p3To0p4;
333 Double_t fNeutralHadronIso_DR0p4To0p5;
334 Double_t fNeutralHadronIso_DR0p5To0p7;
335
336
337 //
338 //Loop over PF Candidates
339 //
340 for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
341
342 if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
343
344 const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
345
346 Double_t deta = (mu->Eta() - pf->Eta());
347 Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
348 Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
349 if (dr > 1.0) continue;
350
351 if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
352
353 //
354 // Lepton Footprint Removal
355 //
356 Bool_t IsLeptonFootprint = kFALSE;
357 if (dr < 1.0) {
358
359 //
360 // Check for electrons
361 //
362 for (Int_t q=0; q < electronsToVeto.size(); ++q) {
363 const mithep::Electron *tmpele = electronsToVeto[q];
364 // 4l electron
365 if( pf->HasTrackerTrk() ) {
366 if( pf->TrackerTrk() == tmpele->TrackerTrk() )
367 IsLeptonFootprint = kTRUE;
368 }
369 if( pf->HasGsfTrk() ) {
370 if( pf->GsfTrk() == tmpele->GsfTrk() )
371 IsLeptonFootprint = kTRUE;
372 }
373 // PF charged
374 if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479
375 && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
376 IsLeptonFootprint = kTRUE;
377 // PF gamma
378 if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
379 && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
380 IsLeptonFootprint = kTRUE;
381 } // loop over electrons
382
383 /* KH - commented for sync
384 //
385 // Check for muons
386 //
387 for (Int_t q=0; q < muonsToVeto.size(); ++q) {
388 const mithep::Muon *tmpmu = muonsToVeto[q];
389 // 4l muon
390 if( pf->HasTrackerTrk() ) {
391 if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
392 IsLeptonFootprint = kTRUE;
393 }
394 // PF charged
395 if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
396 IsLeptonFootprint = kTRUE;
397 } // loop over muons
398 */
399
400 if (IsLeptonFootprint)
401 continue;
402
403 //
404 // Charged Iso Rings
405 //
406 if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
407
408 if( dr < 0.01 ) continue; // only for muon iso mva?
409 if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
410
411 // if( pf->HasTrackerTrk() ) {
412 // if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
413 // if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
414 // << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
415 // << dr << endl;
416 // }
417 // if( pf->HasGsfTrk() ) {
418 // if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
419 // if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
420 // << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
421 // << dr << endl;
422 // }
423
424 // Footprint Veto
425 if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
426 if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
427 if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
428 if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
429 if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
430 if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
431 }
432
433 //
434 // Gamma Iso Rings
435 //
436 else if (abs(pf->PFType()) == PFCandidate::eGamma) {
437 if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
438 if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
439 if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
440 if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
441 if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
442 if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
443 }
444
445 //
446 // Other Neutral Iso Rings
447 //
448 else {
449 if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
450 if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
451 if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
452 if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
453 if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
454 if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
455 }
456
457 }
458
459 }
460
461 fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5);
462 fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5);
463 fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5);
464 fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5);
465 fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5);
466
467
468 double rho = 0;
469 if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
470 rho = fPUEnergyDensity->At(0)->Rho();
471
472 // if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
473 // rho = fPUEnergyDensity->At(0)->RhoLowEta();
474
475 // WARNING!!!!
476 // hardcode for sync ...
477 EffectiveAreaVersion = muT.kMuEAData2011;
478 // WARNING!!!!
479
480
481 fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
482 -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p0To0p1,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
483 ,2.5)
484 ,0.0);
485 fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
486 -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p1To0p2,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
487 ,2.5)
488 ,0.0);
489 fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
490 -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p2To0p3,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
491 ,2.5)
492 ,0.0);
493 fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
494 -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p3To0p4,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
495 ,2.5)
496 ,0.0);
497 fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
498 -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p4To0p5,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
499 ,2.5)
500 ,0.0);
501
502
503
504 fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
505 -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p0To0p1,
506 mu->Eta(),EffectiveAreaVersion))/mu->Pt()
507 , 2.5)
508 , 0.0);
509 fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
510 -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p1To0p2,
511 mu->Eta(),EffectiveAreaVersion))/mu->Pt()
512 , 2.5)
513 , 0.0);
514 fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
515 -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p2To0p3,
516 mu->Eta(),EffectiveAreaVersion))/mu->Pt()
517 , 2.5)
518 , 0.0);
519 fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
520 -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p3To0p4,
521 mu->Eta(), EffectiveAreaVersion))/mu->Pt()
522 , 2.5)
523 , 0.0);
524 fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
525 -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p4To0p5,
526 mu->Eta(), EffectiveAreaVersion))/mu->Pt()
527 , 2.5)
528 , 0.0);
529
530
531 double mvaval = muIsoMVA->MVAValue_IsoRings( mu->Pt(),
532 mu->Eta(),
533 mu->IsGlobalMuon(),
534 mu->IsTrackerMuon(),
535 fChargedIso_DR0p0To0p1,
536 fChargedIso_DR0p1To0p2,
537 fChargedIso_DR0p2To0p3,
538 fChargedIso_DR0p3To0p4,
539 fChargedIso_DR0p4To0p5,
540 fGammaIso_DR0p0To0p1,
541 fGammaIso_DR0p1To0p2,
542 fGammaIso_DR0p2To0p3,
543 fGammaIso_DR0p3To0p4,
544 fGammaIso_DR0p4To0p5,
545 fNeutralHadronIso_DR0p0To0p1,
546 fNeutralHadronIso_DR0p1To0p2,
547 fNeutralHadronIso_DR0p2To0p3,
548 fNeutralHadronIso_DR0p3To0p4,
549 fNeutralHadronIso_DR0p4To0p5,
550 ctrl.debug);
551
552 SelectionStatus status;
553 bool pass;
554
555 pass = false;
556 if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
557 && fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN0) pass = true;
558 else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
559 && fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN1) pass = true;
560 else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
561 && fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN2) pass = true;
562 else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
563 && fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN3) pass = true;
564 else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN4) pass = true;
565 else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN5) pass = true;
566 if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
567
568 /*
569 pass = false;
570 if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
571 && fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN0) pass = true;
572 else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
573 && fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN1) pass = true;
574 else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
575 && fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN2) pass = true;
576 else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
577 && fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN3) pass = true;
578 else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN4) pass = true;
579 else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN5) pass = true;
580 if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
581 */
582
583 // pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
584
585 status.isoMVA = mvaval;
586
587 if(ctrl.debug) {
588 cout << "returning status : " << hex << status.getStatus() << dec << endl;
589 cout << "MVAVAL : " << status.isoMVA << endl;
590 }
591 return status;
592
593 }
594
595
596 //--------------------------------------------------------------------------------------------------
597 SelectionStatus muonIsoMVASelection(ControlFlags &ctrl,
598 const mithep::Muon * mu,
599 const mithep::Vertex * vtx,
600 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
601 float rho,
602 //const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
603 mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
604 vector<const mithep::Muon*> muonsToVeto,
605 vector<const mithep::Electron*> electronsToVeto)
606 //--------------------------------------------------------------------------------------------------
607 // hacked version
608 {
609
610 if( ctrl.debug ) {
611 cout << "muonIsoMVASelection :: muons to veto " << endl;
612 for( int i=0; i<muonsToVeto.size(); i++ ) {
613 const mithep::Muon * vmu = muonsToVeto[i];
614 cout << "\tpt: " << vmu->Pt()
615 << "\teta: " << vmu->Eta()
616 << "\tphi: " << vmu->Phi()
617 << endl;
618 }
619 cout << "muonIsoMVASelection :: electrson to veto " << endl;
620 for( int i=0; i<electronsToVeto.size(); i++ ) {
621 const mithep::Electron * vel = electronsToVeto[i];
622 cout << "\tpt: " << vel->Pt()
623 << "\teta: " << vel->Eta()
624 << "\tphi: " << vel->Phi()
625 << endl;
626 }
627 }
628 bool failiso=false;
629
630 //
631 // tmp iso rings
632 //
633 Double_t tmpChargedIso_DR0p0To0p1 = 0;
634 Double_t tmpChargedIso_DR0p1To0p2 = 0;
635 Double_t tmpChargedIso_DR0p2To0p3 = 0;
636 Double_t tmpChargedIso_DR0p3To0p4 = 0;
637 Double_t tmpChargedIso_DR0p4To0p5 = 0;
638 Double_t tmpChargedIso_DR0p5To0p7 = 0;
639
640 Double_t tmpGammaIso_DR0p0To0p1 = 0;
641 Double_t tmpGammaIso_DR0p1To0p2 = 0;
642 Double_t tmpGammaIso_DR0p2To0p3 = 0;
643 Double_t tmpGammaIso_DR0p3To0p4 = 0;
644 Double_t tmpGammaIso_DR0p4To0p5 = 0;
645 Double_t tmpGammaIso_DR0p5To0p7 = 0;
646
647 Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
648 Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
649 Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
650 Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
651 Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
652 Double_t tmpNeutralHadronIso_DR0p5To0p7 = 0;
653
654
655
656 //
657 // final rings for the MVA
658 //
659 Double_t fChargedIso_DR0p0To0p1;
660 Double_t fChargedIso_DR0p1To0p2;
661 Double_t fChargedIso_DR0p2To0p3;
662 Double_t fChargedIso_DR0p3To0p4;
663 Double_t fChargedIso_DR0p4To0p5;
664 Double_t fChargedIso_DR0p5To0p7;
665
666 Double_t fGammaIso_DR0p0To0p1;
667 Double_t fGammaIso_DR0p1To0p2;
668 Double_t fGammaIso_DR0p2To0p3;
669 Double_t fGammaIso_DR0p3To0p4;
670 Double_t fGammaIso_DR0p4To0p5;
671 Double_t fGammaIso_DR0p5To0p7;
672
673 Double_t fNeutralHadronIso_DR0p0To0p1;
674 Double_t fNeutralHadronIso_DR0p1To0p2;
675 Double_t fNeutralHadronIso_DR0p2To0p3;
676 Double_t fNeutralHadronIso_DR0p3To0p4;
677 Double_t fNeutralHadronIso_DR0p4To0p5;
678 Double_t fNeutralHadronIso_DR0p5To0p7;
679
680
681 //
682 //Loop over PF Candidates
683 //
684 for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
685
686 if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
687
688 const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
689
690 Double_t deta = (mu->Eta() - pf->Eta());
691 Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
692 Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
693 if (dr > 1.0) continue;
694
695 if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
696
697 //
698 // Lepton Footprint Removal
699 //
700 Bool_t IsLeptonFootprint = kFALSE;
701 if (dr < 1.0) {
702
703 //
704 // Check for electrons
705 //
706 for (Int_t q=0; q < electronsToVeto.size(); ++q) {
707 const mithep::Electron *tmpele = electronsToVeto[q];
708 // 4l electron
709 if( pf->HasTrackerTrk() ) {
710 if( pf->TrackerTrk() == tmpele->TrackerTrk() )
711 IsLeptonFootprint = kTRUE;
712 }
713 if( pf->HasGsfTrk() ) {
714 if( pf->GsfTrk() == tmpele->GsfTrk() )
715 IsLeptonFootprint = kTRUE;
716 }
717 // PF charged
718 if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479
719 && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
720 IsLeptonFootprint = kTRUE;
721 // PF gamma
722 if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
723 && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
724 IsLeptonFootprint = kTRUE;
725 } // loop over electrons
726
727 /* KH - commented for sync
728 //
729 // Check for muons
730 //
731 for (Int_t q=0; q < muonsToVeto.size(); ++q) {
732 const mithep::Muon *tmpmu = muonsToVeto[q];
733 // 4l muon
734 if( pf->HasTrackerTrk() ) {
735 if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
736 IsLeptonFootprint = kTRUE;
737 }
738 // PF charged
739 if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
740 IsLeptonFootprint = kTRUE;
741 } // loop over muons
742 */
743
744 if (IsLeptonFootprint)
745 continue;
746
747 //
748 // Charged Iso Rings
749 //
750 if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
751
752 if( dr < 0.01 ) continue; // only for muon iso mva?
753 if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
754
755 // if( pf->HasTrackerTrk() ) {
756 // if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
757 // if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
758 // << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
759 // << dr << endl;
760 // }
761 // if( pf->HasGsfTrk() ) {
762 // if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
763 // if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
764 // << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
765 // << dr << endl;
766 // }
767
768 // Footprint Veto
769 if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
770 if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
771 if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
772 if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
773 if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
774 if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
775 }
776
777 //
778 // Gamma Iso Rings
779 //
780 else if (abs(pf->PFType()) == PFCandidate::eGamma) {
781 if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
782 if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
783 if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
784 if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
785 if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
786 if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
787 }
788
789 //
790 // Other Neutral Iso Rings
791 //
792 else {
793 if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
794 if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
795 if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
796 if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
797 if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
798 if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
799 }
800
801 }
802
803 }
804
805 fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5);
806 fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5);
807 fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5);
808 fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5);
809 fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5);
810
811
812 // double rho = 0;
813 // if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
814 // rho = fPUEnergyDensity->At(0)->Rho();
815 // if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
816 // rho = fPUEnergyDensity->At(0)->RhoLowEta();
817
818 // WARNING!!!!
819 // hardcode for sync ...
820 EffectiveAreaVersion = muT.kMuEAData2011;
821 // WARNING!!!!
822
823
824 fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
825 -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p0To0p1,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
826 ,2.5)
827 ,0.0);
828 fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
829 -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p1To0p2,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
830 ,2.5)
831 ,0.0);
832 fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
833 -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p2To0p3,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
834 ,2.5)
835 ,0.0);
836 fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
837 -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p3To0p4,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
838 ,2.5)
839 ,0.0);
840 fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
841 -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p4To0p5,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
842 ,2.5)
843 ,0.0);
844
845
846
847 fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
848 -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p0To0p1,
849 mu->Eta(),EffectiveAreaVersion))/mu->Pt()
850 , 2.5)
851 , 0.0);
852 fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
853 -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p1To0p2,
854 mu->Eta(),EffectiveAreaVersion))/mu->Pt()
855 , 2.5)
856 , 0.0);
857 fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
858 -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p2To0p3,
859 mu->Eta(),EffectiveAreaVersion))/mu->Pt()
860 , 2.5)
861 , 0.0);
862 fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
863 -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p3To0p4,
864 mu->Eta(), EffectiveAreaVersion))/mu->Pt()
865 , 2.5)
866 , 0.0);
867 fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
868 -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p4To0p5,
869 mu->Eta(), EffectiveAreaVersion))/mu->Pt()
870 , 2.5)
871 , 0.0);
872
873
874 double mvaval = muIsoMVA->MVAValue_IsoRings( mu->Pt(),
875 mu->Eta(),
876 mu->IsGlobalMuon(),
877 mu->IsTrackerMuon(),
878 fChargedIso_DR0p0To0p1,
879 fChargedIso_DR0p1To0p2,
880 fChargedIso_DR0p2To0p3,
881 fChargedIso_DR0p3To0p4,
882 fChargedIso_DR0p4To0p5,
883 fGammaIso_DR0p0To0p1,
884 fGammaIso_DR0p1To0p2,
885 fGammaIso_DR0p2To0p3,
886 fGammaIso_DR0p3To0p4,
887 fGammaIso_DR0p4To0p5,
888 fNeutralHadronIso_DR0p0To0p1,
889 fNeutralHadronIso_DR0p1To0p2,
890 fNeutralHadronIso_DR0p2To0p3,
891 fNeutralHadronIso_DR0p3To0p4,
892 fNeutralHadronIso_DR0p4To0p5,
893 ctrl.debug);
894
895 SelectionStatus status;
896 bool pass;
897
898 pass = false;
899 if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
900 && fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN0) pass = true;
901 else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
902 && fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN1) pass = true;
903 else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
904 && fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN2) pass = true;
905 else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
906 && fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN3) pass = true;
907 else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN4) pass = true;
908 else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN5) pass = true;
909 if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
910
911 /*
912 pass = false;
913 if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
914 && fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN0) pass = true;
915 else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
916 && fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN1) pass = true;
917 else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
918 && fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN2) pass = true;
919 else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
920 && fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN3) pass = true;
921 else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN4) pass = true;
922 else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN5) pass = true;
923 if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
924 */
925
926 // pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
927
928 status.isoMVA = mvaval;
929
930 if(ctrl.debug) {
931 cout << "returning status : " << hex << status.getStatus() << dec << endl;
932 cout << "MVAVAL : " << status.isoMVA << endl;
933 }
934 return status;
935
936 }
937
938
939 //--------------------------------------------------------------------------------------------------
940 void initMuonIsoMVA() {
941 //--------------------------------------------------------------------------------------------------
942 muIsoMVA = new mithep::MuonIDMVA();
943 vector<string> weightFiles;
944 weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_barrel_lowpt.weights.xml");
945 weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_barrel_highpt.weights.xml");
946 weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_endcap_lowpt.weights.xml");
947 weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_endcap_highpt.weights.xml");
948 weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_tracker.weights.xml");
949 weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_global.weights.xml");
950 muIsoMVA->Initialize( "MuonIsoMVA",
951 mithep::MuonIDMVA::kIsoRingsV0,
952 kTRUE, weightFiles);
953 }
954
955
956
957
958 //--------------------------------------------------------------------------------------------------
959 double muonPFIso04(ControlFlags &ctrl,
960 const mithep::Muon * mu,
961 const mithep::Vertex * vtx,
962 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
963 const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
964 mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
965 vector<const mithep::Muon*> muonsToVeto,
966 vector<const mithep::Electron*> electronsToVeto)
967 //--------------------------------------------------------------------------------------------------
968 {
969
970 extern double gChargedIso;
971 extern double gGammaIso;
972 extern double gNeutralIso;
973
974 if( ctrl.debug ) {
975 cout << "muonIsoMVASelection :: muons to veto " << endl;
976 for( int i=0; i<muonsToVeto.size(); i++ ) {
977 const mithep::Muon * vmu = muonsToVeto[i];
978 cout << "\tpt: " << vmu->Pt()
979 << "\teta: " << vmu->Eta()
980 << "\tphi: " << vmu->Phi()
981 << endl;
982 }
983 cout << "muonIsoMVASelection :: electrson to veto " << endl;
984 for( int i=0; i<electronsToVeto.size(); i++ ) {
985 const mithep::Electron * vel = electronsToVeto[i];
986 cout << "\tpt: " << vel->Pt()
987 << "\teta: " << vel->Eta()
988 << "\tphi: " << vel->Phi()
989 << endl;
990 }
991 }
992
993 //
994 // final iso
995 //
996 Double_t fChargedIso = 0.0;
997 Double_t fGammaIso = 0.0;
998 Double_t fNeutralHadronIso = 0.0;
999
1000 //
1001 //Loop over PF Candidates
1002 //
1003 for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1004
1005 if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1006 const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1007
1008 Double_t deta = (mu->Eta() - pf->Eta());
1009 Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
1010 Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
1011 if (dr > 0.4) continue;
1012
1013 if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
1014
1015 //
1016 // Lepton Footprint Removal
1017 //
1018 Bool_t IsLeptonFootprint = kFALSE;
1019 if (dr < 1.0) {
1020
1021 //
1022 // Check for electrons
1023 //
1024 for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1025 const mithep::Electron *tmpele = electronsToVeto[q];
1026 // 4l electron
1027 if( pf->HasTrackerTrk() ) {
1028 if( pf->TrackerTrk() == tmpele->TrackerTrk() )
1029 IsLeptonFootprint = kTRUE;
1030 }
1031 if( pf->HasGsfTrk() ) {
1032 if( pf->GsfTrk() == tmpele->GsfTrk() )
1033 IsLeptonFootprint = kTRUE;
1034 }
1035 // PF charged
1036 if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1037 && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
1038 if( ctrl.debug) cout << "\tcharged trk, dR ("
1039 << mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta())
1040 << " matches 4L ele ..." << endl;
1041 IsLeptonFootprint = kTRUE;
1042 }
1043 // PF gamma
1044 if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1045 && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
1046 IsLeptonFootprint = kTRUE;
1047 } // loop over electrons
1048
1049 /* KH - comment for sync
1050 //
1051 // Check for muons
1052 //
1053 for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1054 const mithep::Muon *tmpmu = muonsToVeto[q];
1055 // 4l muon
1056 if( pf->HasTrackerTrk() ) {
1057 if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
1058 IsLeptonFootprint = kTRUE;
1059 }
1060 // PF charged
1061 if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
1062 IsLeptonFootprint = kTRUE;
1063 } // loop over muons
1064 */
1065
1066 if (IsLeptonFootprint)
1067 continue;
1068
1069 //
1070 // Charged Iso
1071 //
1072 if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1073
1074 //if( dr < 0.01 ) continue; // only for muon iso mva?
1075 if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1076
1077
1078 // if( pf->HasTrackerTrk() ) {
1079 // if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1080 // if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1081 // << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1082 // << dr << endl;
1083 // }
1084 // if( pf->HasGsfTrk() ) {
1085 // if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1086 // if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1087 // << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1088 // << dr << endl;
1089 // }
1090
1091
1092 fChargedIso += pf->Pt();
1093 }
1094
1095 //
1096 // Gamma Iso
1097 //
1098 else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1099 // KH, add to sync
1100 if( pf->Pt() > 0.5 )
1101 fGammaIso += pf->Pt();
1102 }
1103
1104 //
1105 // Other Neutrals
1106 //
1107 else {
1108 // KH, add to sync
1109 if( pf->Pt() > 0.5 )
1110 fNeutralHadronIso += pf->Pt();
1111 }
1112
1113 }
1114
1115 }
1116
1117 double rho=0;
1118 if( (EffectiveAreaVersion == mithep::MuonTools::kMuEAFall11MC) ||
1119 (EffectiveAreaVersion == mithep::MuonTools::kMuEAData2011) ) {
1120 if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25()) ||
1121 isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25())))
1122 rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25();
1123 //rho = fPUEnergyDensity->At(0)->Rho();
1124 // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
1125 EffectiveAreaVersion = mithep::MuonTools::kMuEAData2011;
1126 // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
1127 } else {
1128 if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral()) ||
1129 isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral())))
1130 rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral();
1131 // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
1132 EffectiveAreaVersion = mithep::MuonTools::kMuEAData2012;
1133 // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
1134 }
1135 if(ctrl.debug) cout << "rho: " << rho << endl;
1136
1137 double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1138 -rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
1139 mu->Eta(),EffectiveAreaVersion)));
1140 gChargedIso = fChargedIso;
1141 gGammaIso = fGammaIso;
1142 gNeutralIso = fNeutralHadronIso;
1143
1144 return pfIso;
1145 }
1146
1147
1148
1149
1150 //--------------------------------------------------------------------------------------------------
1151 // hacked version
1152 double muonPFIso04(ControlFlags &ctrl,
1153 const mithep::Muon * mu,
1154 const mithep::Vertex * vtx,
1155 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1156 float rho,
1157 mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1158 vector<const mithep::Muon*> muonsToVeto,
1159 vector<const mithep::Electron*> electronsToVeto)
1160 //--------------------------------------------------------------------------------------------------
1161 {
1162
1163 extern double gChargedIso;
1164 extern double gGammaIso;
1165 extern double gNeutralIso;
1166
1167 if( ctrl.debug ) {
1168 cout << "muonIsoMVASelection :: muons to veto " << endl;
1169 for( int i=0; i<muonsToVeto.size(); i++ ) {
1170 const mithep::Muon * vmu = muonsToVeto[i];
1171 cout << "\tpt: " << vmu->Pt()
1172 << "\teta: " << vmu->Eta()
1173 << "\tphi: " << vmu->Phi()
1174 << endl;
1175 }
1176 cout << "muonIsoMVASelection :: electrson to veto " << endl;
1177 for( int i=0; i<electronsToVeto.size(); i++ ) {
1178 const mithep::Electron * vel = electronsToVeto[i];
1179 cout << "\tpt: " << vel->Pt()
1180 << "\teta: " << vel->Eta()
1181 << "\tphi: " << vel->Phi()
1182 << endl;
1183 }
1184 }
1185
1186 //
1187 // final iso
1188 //
1189 Double_t fChargedIso = 0.0;
1190 Double_t fGammaIso = 0.0;
1191 Double_t fNeutralHadronIso = 0.0;
1192
1193 //
1194 //Loop over PF Candidates
1195 //
1196 for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1197
1198 if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1199 const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1200
1201 Double_t deta = (mu->Eta() - pf->Eta());
1202 Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
1203 Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
1204 if (dr > 0.4) continue;
1205
1206 if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
1207
1208 //
1209 // Lepton Footprint Removal
1210 //
1211 Bool_t IsLeptonFootprint = kFALSE;
1212 if (dr < 1.0) {
1213
1214 //
1215 // Check for electrons
1216 //
1217 for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1218 const mithep::Electron *tmpele = electronsToVeto[q];
1219 // 4l electron
1220 if( pf->HasTrackerTrk() ) {
1221 if( pf->TrackerTrk() == tmpele->TrackerTrk() )
1222 IsLeptonFootprint = kTRUE;
1223 }
1224 if( pf->HasGsfTrk() ) {
1225 if( pf->GsfTrk() == tmpele->GsfTrk() )
1226 IsLeptonFootprint = kTRUE;
1227 }
1228 // PF charged
1229 if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1230 && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
1231 IsLeptonFootprint = kTRUE;
1232 // PF gamma
1233 if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1234 && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
1235 IsLeptonFootprint = kTRUE;
1236 } // loop over electrons
1237
1238 /* KH - comment for sync
1239 //
1240 // Check for muons
1241 //
1242 for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1243 const mithep::Muon *tmpmu = muonsToVeto[q];
1244 // 4l muon
1245 if( pf->HasTrackerTrk() ) {
1246 if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
1247 IsLeptonFootprint = kTRUE;
1248 }
1249 // PF charged
1250 if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
1251 IsLeptonFootprint = kTRUE;
1252 } // loop over muons
1253 */
1254
1255 if (IsLeptonFootprint)
1256 continue;
1257
1258 //
1259 // Charged Iso
1260 //
1261 if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1262
1263 //if( dr < 0.01 ) continue; // only for muon iso mva?
1264 if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1265
1266
1267 // if( pf->HasTrackerTrk() ) {
1268 // if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1269 // if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1270 // << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1271 // << dr << endl;
1272 // }
1273 // if( pf->HasGsfTrk() ) {
1274 // if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1275 // if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1276 // << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1277 // << dr << endl;
1278 // }
1279
1280
1281 fChargedIso += pf->Pt();
1282 }
1283
1284 //
1285 // Gamma Iso
1286 //
1287 else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1288 // KH, add to sync
1289 if( pf->Pt() > 0.5 )
1290 fGammaIso += pf->Pt();
1291 }
1292
1293 //
1294 // Other Neutrals
1295 //
1296 else {
1297 // KH, add to sync
1298 if( pf->Pt() > 0.5 )
1299 fNeutralHadronIso += pf->Pt();
1300 }
1301
1302 }
1303
1304 }
1305
1306 // double rho = 0;
1307 // if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1308 // rho = fPUEnergyDensity->At(0)->Rho();
1309
1310 // WARNING!!!!
1311 // hardcode for sync ...
1312 EffectiveAreaVersion = muT.kMuEAData2011;
1313 // WARNING!!!!
1314
1315
1316 double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1317 -rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
1318 mu->Eta(),EffectiveAreaVersion)));
1319 gChargedIso = fChargedIso;
1320 gGammaIso = fGammaIso;
1321 gNeutralIso = fNeutralHadronIso;
1322
1323 return pfIso;
1324 }
1325
1326
1327 //--------------------------------------------------------------------------------------------------
1328 SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1329 const mithep::Muon * mu,
1330 const mithep::Vertex * vtx,
1331 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1332 const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1333 mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1334 vector<const mithep::Muon*> muonsToVeto,
1335 vector<const mithep::Electron*> electronsToVeto)
1336 //--------------------------------------------------------------------------------------------------
1337 {
1338
1339 SelectionStatus status;
1340
1341 double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, fPUEnergyDensity,
1342 EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1343 // cout << "--------------> setting muon isoPF04 to" << pfIso << endl;
1344 status.isoPF04 = pfIso;
1345 status.chisoPF04 = gChargedIso;
1346 status.gaisoPF04 = gGammaIso;
1347 status.neisoPF04 = gNeutralIso;
1348
1349 bool pass = false;
1350 if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1351
1352 if( pass ) {
1353 status.orStatus(SelectionStatus::LOOSEISO);
1354 status.orStatus(SelectionStatus::TIGHTISO);
1355 }
1356 if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1357 return status;
1358
1359 }
1360
1361
1362 //--------------------------------------------------------------------------------------------------
1363 // hacked version
1364 SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1365 const mithep::Muon * mu,
1366 const mithep::Vertex * vtx,
1367 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1368 float rho,
1369 mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1370 vector<const mithep::Muon*> muonsToVeto,
1371 vector<const mithep::Electron*> electronsToVeto)
1372 //--------------------------------------------------------------------------------------------------
1373 {
1374
1375 SelectionStatus status;
1376
1377 double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, rho,
1378 EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1379
1380 status.isoPF04 = pfIso;
1381 status.chisoPF04 = gChargedIso;
1382 status.gaisoPF04 = gGammaIso;
1383 status.neisoPF04 = gNeutralIso;
1384
1385 bool pass = false;
1386 if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1387
1388 if( pass ) {
1389 status.orStatus(SelectionStatus::LOOSEISO);
1390 status.orStatus(SelectionStatus::TIGHTISO);
1391 }
1392 if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1393 return status;
1394
1395 }
1396
1397
1398
1399
1400 //--------------------------------------------------------------------------------------------------
1401 SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1402 const mithep::Electron * ele,
1403 const mithep::Vertex * vtx,
1404 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1405 const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1406 mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1407 vector<const mithep::Muon*> muonsToVeto,
1408 vector<const mithep::Electron*> electronsToVeto)
1409 //--------------------------------------------------------------------------------------------------
1410 {
1411
1412 if( ctrl.debug ) {
1413 cout << "electronIsoMVASelection :: muons to veto " << endl;
1414 for( int i=0; i<muonsToVeto.size(); i++ ) {
1415 const mithep::Muon * vmu = muonsToVeto[i];
1416 cout << "\tpt: " << vmu->Pt()
1417 << "\teta: " << vmu->Eta()
1418 << "\tphi: " << vmu->Phi()
1419 << endl;
1420 }
1421 cout << "electronIsoMVASelection :: electrson to veto " << endl;
1422 for( int i=0; i<electronsToVeto.size(); i++ ) {
1423 const mithep::Electron * vel = electronsToVeto[i];
1424 cout << "\tpt: " << vel->Pt()
1425 << "\teta: " << vel->Eta()
1426 << "\tphi: " << vel->Phi()
1427 << "\ttrk: " << vel->TrackerTrk()
1428 << endl;
1429 }
1430 }
1431
1432 bool failiso=false;
1433
1434 //
1435 // tmp iso rings
1436 //
1437 Double_t tmpChargedIso_DR0p0To0p1 = 0;
1438 Double_t tmpChargedIso_DR0p1To0p2 = 0;
1439 Double_t tmpChargedIso_DR0p2To0p3 = 0;
1440 Double_t tmpChargedIso_DR0p3To0p4 = 0;
1441 Double_t tmpChargedIso_DR0p4To0p5 = 0;
1442
1443 Double_t tmpGammaIso_DR0p0To0p1 = 0;
1444 Double_t tmpGammaIso_DR0p1To0p2 = 0;
1445 Double_t tmpGammaIso_DR0p2To0p3 = 0;
1446 Double_t tmpGammaIso_DR0p3To0p4 = 0;
1447 Double_t tmpGammaIso_DR0p4To0p5 = 0;
1448
1449
1450 Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
1451 Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
1452 Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
1453 Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
1454 Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
1455
1456
1457
1458 //
1459 // final rings for the MVA
1460 //
1461 Double_t fChargedIso_DR0p0To0p1;
1462 Double_t fChargedIso_DR0p1To0p2;
1463 Double_t fChargedIso_DR0p2To0p3;
1464 Double_t fChargedIso_DR0p3To0p4;
1465 Double_t fChargedIso_DR0p4To0p5;
1466
1467 Double_t fGammaIso_DR0p0To0p1;
1468 Double_t fGammaIso_DR0p1To0p2;
1469 Double_t fGammaIso_DR0p2To0p3;
1470 Double_t fGammaIso_DR0p3To0p4;
1471 Double_t fGammaIso_DR0p4To0p5;
1472
1473 Double_t fNeutralHadronIso_DR0p0To0p1;
1474 Double_t fNeutralHadronIso_DR0p1To0p2;
1475 Double_t fNeutralHadronIso_DR0p2To0p3;
1476 Double_t fNeutralHadronIso_DR0p3To0p4;
1477 Double_t fNeutralHadronIso_DR0p4To0p5;
1478
1479
1480 //
1481 //Loop over PF Candidates
1482 //
1483 for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1484
1485 if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1486
1487 const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1488 Double_t deta = (ele->Eta() - pf->Eta());
1489 Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1490 Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1491 if (dr > 1.0) continue;
1492
1493 if(ctrl.debug) {
1494 cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1495 if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx);
1496 cout << endl;
1497 }
1498
1499
1500 if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
1501 (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1502
1503
1504 //
1505 // Lepton Footprint Removal
1506 //
1507 Bool_t IsLeptonFootprint = kFALSE;
1508 if (dr < 1.0) {
1509
1510
1511 //
1512 // Check for electrons
1513 //
1514
1515 for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1516 const mithep::Electron *tmpele = electronsToVeto[q];
1517 double tmpdr = mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1518
1519 // 4l electron
1520 if( pf->HasTrackerTrk() ) {
1521 if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
1522 if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1523 IsLeptonFootprint = kTRUE;
1524 }
1525 }
1526 if( pf->HasGsfTrk() ) {
1527 if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1528 if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1529 IsLeptonFootprint = kTRUE;
1530 }
1531 }
1532 // PF charged
1533 if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1534 if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1535 IsLeptonFootprint = kTRUE;
1536 }
1537 // PF gamma
1538 if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1539 && tmpdr < 0.08) {
1540 if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1541 IsLeptonFootprint = kTRUE;
1542 }
1543 } // loop over electrons
1544
1545
1546 /* KH - comment for sync
1547 //
1548 // Check for muons
1549 //
1550 for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1551 const mithep::Muon *tmpmu = muonsToVeto[q];
1552 // 4l muon
1553 if( pf->HasTrackerTrk() ) {
1554 if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1555 if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1556 IsLeptonFootprint = kTRUE;
1557 }
1558 }
1559 // PF charged
1560 if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1561 if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1562 IsLeptonFootprint = kTRUE;
1563 }
1564 } // loop over muons
1565 */
1566
1567 if (IsLeptonFootprint)
1568 continue;
1569
1570 //
1571 // Charged Iso Rings
1572 //
1573 if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1574
1575 // if( pf->HasGsfTrk() ) {
1576 // if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1577 // } else if( pf->HasTrackerTrk() ){
1578 // if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1579 // }
1580
1581 // Veto any PFmuon, or PFEle
1582 if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1583
1584 // Footprint Veto
1585 if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
1586
1587 if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
1588 << "\ttype: " << pf->PFType()
1589 << "\ttrk: " << pf->TrackerTrk() << endl;
1590
1591 if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
1592 if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
1593 if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1594 if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1595 if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
1596
1597 }
1598
1599 //
1600 // Gamma Iso Rings
1601 //
1602 else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1603
1604 if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
1605
1606 if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1607 << dr << endl;
1608
1609 if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
1610 if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
1611 if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1612 if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1613 if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
1614 }
1615
1616 //
1617 // Other Neutral Iso Rings
1618 //
1619 else {
1620 if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
1621 << dr << endl;
1622 if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
1623 if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
1624 if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1625 if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1626 if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
1627 }
1628
1629 }
1630
1631 }
1632
1633 fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1634 fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1635 fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1636 fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1637 fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1638
1639 if(ctrl.debug) {
1640 cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1 << endl;
1641 cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2 << endl;
1642 cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3 << endl;
1643 cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4 << endl;
1644 cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5 << endl;
1645 }
1646
1647
1648 double rho = 0;
1649 if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1650 rho = fPUEnergyDensity->At(0)->Rho();
1651 // if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
1652 // rho = fPUEnergyDensity->At(0)->RhoLowEta();
1653
1654 // WARNING!!!!
1655 // hardcode for sync ...
1656 EffectiveAreaVersion = eleT.kEleEAData2011;
1657 // WARNING!!!!
1658
1659 if( ctrl.debug) {
1660 cout << "RHO: " << rho << endl;
1661 cout << "eta: " << ele->SCluster()->Eta() << endl;
1662 cout << "target: " << EffectiveAreaVersion << endl;
1663 cout << "effA 0-1: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1664 ele->SCluster()->Eta(),
1665 EffectiveAreaVersion)
1666 << endl;
1667 cout << "effA 1-2: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1668 ele->SCluster()->Eta(),
1669 EffectiveAreaVersion)
1670 << endl;
1671 cout << "effA 2-3: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1672 ele->SCluster()->Eta(),
1673 EffectiveAreaVersion)
1674 << endl;
1675 cout << "effA 3-4: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1676 ele->SCluster()->Eta(),
1677 EffectiveAreaVersion)
1678 << endl;
1679 }
1680
1681 fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
1682 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
1683 ele->SCluster()->Eta(),
1684 EffectiveAreaVersion))/ele->Pt()
1685 ,2.5)
1686 ,0.0);
1687 fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
1688 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
1689 ele->SCluster()->Eta(),
1690 EffectiveAreaVersion))/ele->Pt()
1691 ,2.5)
1692 ,0.0);
1693 fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
1694 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
1695 ele->SCluster()->Eta()
1696 ,EffectiveAreaVersion))/ele->Pt()
1697 ,2.5)
1698 ,0.0);
1699 fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
1700 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
1701 ele->SCluster()->Eta(),
1702 EffectiveAreaVersion))/ele->Pt()
1703 ,2.5)
1704 ,0.0);
1705 fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
1706 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
1707 ele->SCluster()->Eta(),
1708 EffectiveAreaVersion))/ele->Pt()
1709 ,2.5)
1710 ,0.0);
1711
1712
1713 if( ctrl.debug) {
1714 cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
1715 cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
1716 cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
1717 cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
1718 cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
1719 }
1720
1721 fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
1722 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1723 ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1724 , 2.5)
1725 , 0.0);
1726 fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
1727 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1728 ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1729 , 2.5)
1730 , 0.0);
1731 fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
1732 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1733 ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1734 , 2.5)
1735 , 0.0);
1736 fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
1737 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1738 ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1739 , 2.5)
1740 , 0.0);
1741 fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
1742 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
1743 ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1744 , 2.5)
1745 , 0.0);
1746
1747 if( ctrl.debug) {
1748 cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
1749 cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
1750 cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
1751 cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
1752 cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
1753 }
1754
1755 double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
1756 ele->SCluster()->Eta(),
1757 fChargedIso_DR0p0To0p1,
1758 fChargedIso_DR0p1To0p2,
1759 fChargedIso_DR0p2To0p3,
1760 fChargedIso_DR0p3To0p4,
1761 fChargedIso_DR0p4To0p5,
1762 fGammaIso_DR0p0To0p1,
1763 fGammaIso_DR0p1To0p2,
1764 fGammaIso_DR0p2To0p3,
1765 fGammaIso_DR0p3To0p4,
1766 fGammaIso_DR0p4To0p5,
1767 fNeutralHadronIso_DR0p0To0p1,
1768 fNeutralHadronIso_DR0p1To0p2,
1769 fNeutralHadronIso_DR0p2To0p3,
1770 fNeutralHadronIso_DR0p3To0p4,
1771 fNeutralHadronIso_DR0p4To0p5,
1772 ctrl.debug);
1773
1774 SelectionStatus status;
1775 status.isoMVA = mvaval;
1776 bool pass = false;
1777
1778 Int_t subdet = 0;
1779 if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
1780 else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
1781 else subdet = 2;
1782
1783 Int_t ptBin = 0;
1784 if (ele->Pt() >= 10.0) ptBin = 1;
1785
1786 Int_t MVABin = -1;
1787 if (subdet == 0 && ptBin == 0) MVABin = 0;
1788 if (subdet == 1 && ptBin == 0) MVABin = 1;
1789 if (subdet == 2 && ptBin == 0) MVABin = 2;
1790 if (subdet == 0 && ptBin == 1) MVABin = 3;
1791 if (subdet == 1 && ptBin == 1) MVABin = 4;
1792 if (subdet == 2 && ptBin == 1) MVABin = 5;
1793
1794 pass = false;
1795 if( MVABin == 0 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN0 ) pass = true;
1796 if( MVABin == 1 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN1 ) pass = true;
1797 if( MVABin == 2 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN2 ) pass = true;
1798 if( MVABin == 3 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN3 ) pass = true;
1799 if( MVABin == 4 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN4 ) pass = true;
1800 if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN5 ) pass = true;
1801 // pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
1802 if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
1803
1804 // pass = false;
1805 // if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
1806 // if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
1807 // if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
1808 // if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
1809 // if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
1810 // if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
1811 // if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
1812
1813 if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1814 return status;
1815
1816 }
1817
1818
1819 //--------------------------------------------------------------------------------------------------
1820 SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1821 const mithep::Electron * ele,
1822 const mithep::Vertex * vtx,
1823 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1824 float rho,
1825 //const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1826 mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1827 vector<const mithep::Muon*> muonsToVeto,
1828 vector<const mithep::Electron*> electronsToVeto)
1829 //--------------------------------------------------------------------------------------------------
1830 // hacked version
1831 {
1832 if( ctrl.debug ) {
1833 cout << "================> hacked ele Iso MVA <======================" << endl;
1834 }
1835
1836 if( ctrl.debug ) {
1837 cout << "electronIsoMVASelection :: muons to veto " << endl;
1838 for( int i=0; i<muonsToVeto.size(); i++ ) {
1839 const mithep::Muon * vmu = muonsToVeto[i];
1840 cout << "\tpt: " << vmu->Pt()
1841 << "\teta: " << vmu->Eta()
1842 << "\tphi: " << vmu->Phi()
1843 << endl;
1844 }
1845 cout << "electronIsoMVASelection :: electrson to veto " << endl;
1846 for( int i=0; i<electronsToVeto.size(); i++ ) {
1847 const mithep::Electron * vel = electronsToVeto[i];
1848 cout << "\tpt: " << vel->Pt()
1849 << "\teta: " << vel->Eta()
1850 << "\tphi: " << vel->Phi()
1851 << "\ttrk: " << vel->TrackerTrk()
1852 << endl;
1853 }
1854 }
1855
1856 bool failiso=false;
1857
1858 //
1859 // tmp iso rings
1860 //
1861 Double_t tmpChargedIso_DR0p0To0p1 = 0;
1862 Double_t tmpChargedIso_DR0p1To0p2 = 0;
1863 Double_t tmpChargedIso_DR0p2To0p3 = 0;
1864 Double_t tmpChargedIso_DR0p3To0p4 = 0;
1865 Double_t tmpChargedIso_DR0p4To0p5 = 0;
1866
1867 Double_t tmpGammaIso_DR0p0To0p1 = 0;
1868 Double_t tmpGammaIso_DR0p1To0p2 = 0;
1869 Double_t tmpGammaIso_DR0p2To0p3 = 0;
1870 Double_t tmpGammaIso_DR0p3To0p4 = 0;
1871 Double_t tmpGammaIso_DR0p4To0p5 = 0;
1872
1873
1874 Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
1875 Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
1876 Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
1877 Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
1878 Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
1879
1880
1881
1882 //
1883 // final rings for the MVA
1884 //
1885 Double_t fChargedIso_DR0p0To0p1;
1886 Double_t fChargedIso_DR0p1To0p2;
1887 Double_t fChargedIso_DR0p2To0p3;
1888 Double_t fChargedIso_DR0p3To0p4;
1889 Double_t fChargedIso_DR0p4To0p5;
1890
1891 Double_t fGammaIso_DR0p0To0p1;
1892 Double_t fGammaIso_DR0p1To0p2;
1893 Double_t fGammaIso_DR0p2To0p3;
1894 Double_t fGammaIso_DR0p3To0p4;
1895 Double_t fGammaIso_DR0p4To0p5;
1896
1897 Double_t fNeutralHadronIso_DR0p0To0p1;
1898 Double_t fNeutralHadronIso_DR0p1To0p2;
1899 Double_t fNeutralHadronIso_DR0p2To0p3;
1900 Double_t fNeutralHadronIso_DR0p3To0p4;
1901 Double_t fNeutralHadronIso_DR0p4To0p5;
1902
1903
1904 //
1905 //Loop over PF Candidates
1906 //
1907 for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1908
1909 if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1910
1911 const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1912 Double_t deta = (ele->Eta() - pf->Eta());
1913 Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1914 Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1915 if (dr > 1.0) continue;
1916
1917 if(ctrl.debug) {
1918 cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1919 if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx);
1920 cout << endl;
1921 }
1922
1923
1924 if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
1925 (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1926
1927
1928 //
1929 // Lepton Footprint Removal
1930 //
1931 Bool_t IsLeptonFootprint = kFALSE;
1932 if (dr < 1.0) {
1933
1934
1935 //
1936 // Check for electrons
1937 //
1938
1939 for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1940 const mithep::Electron *tmpele = electronsToVeto[q];
1941 double tmpdr = mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1942
1943 // 4l electron
1944 if( pf->HasTrackerTrk() ) {
1945 if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
1946 if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1947 IsLeptonFootprint = kTRUE;
1948 }
1949 }
1950 if( pf->HasGsfTrk() ) {
1951 if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1952 if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1953 IsLeptonFootprint = kTRUE;
1954 }
1955 }
1956 // PF charged
1957 if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1958 if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1959 IsLeptonFootprint = kTRUE;
1960 }
1961 // PF gamma
1962 if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1963 && tmpdr < 0.08) {
1964 if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1965 IsLeptonFootprint = kTRUE;
1966 }
1967 } // loop over electrons
1968
1969
1970 /* KH - comment for sync
1971 //
1972 // Check for muons
1973 //
1974 for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1975 const mithep::Muon *tmpmu = muonsToVeto[q];
1976 // 4l muon
1977 if( pf->HasTrackerTrk() ) {
1978 if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1979 if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1980 IsLeptonFootprint = kTRUE;
1981 }
1982 }
1983 // PF charged
1984 if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1985 if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1986 IsLeptonFootprint = kTRUE;
1987 }
1988 } // loop over muons
1989 */
1990
1991 if (IsLeptonFootprint)
1992 continue;
1993
1994 //
1995 // Charged Iso Rings
1996 //
1997 if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1998
1999 // if( pf->HasGsfTrk() ) {
2000 // if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2001 // } else if( pf->HasTrackerTrk() ){
2002 // if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2003 // }
2004
2005 // Veto any PFmuon, or PFEle
2006 if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
2007
2008 // Footprint Veto
2009 if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
2010
2011 if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
2012 << "\ttype: " << pf->PFType()
2013 << "\ttrk: " << pf->TrackerTrk() << endl;
2014
2015 if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
2016 if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
2017 if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
2018 if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
2019 if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
2020
2021 }
2022
2023 //
2024 // Gamma Iso Rings
2025 //
2026 else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2027
2028 if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
2029
2030 if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2031 << dr << endl;
2032
2033 if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
2034 if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
2035 if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
2036 if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
2037 if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
2038 }
2039
2040 //
2041 // Other Neutral Iso Rings
2042 //
2043 else {
2044 if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2045 << dr << endl;
2046 if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
2047 if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
2048 if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
2049 if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
2050 if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
2051 }
2052
2053 }
2054
2055 }
2056
2057 fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
2058 fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
2059 fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
2060 fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
2061 fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
2062
2063 if(ctrl.debug) {
2064 cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1 << endl;
2065 cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2 << endl;
2066 cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3 << endl;
2067 cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4 << endl;
2068 cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5 << endl;
2069 }
2070
2071
2072 // rho=0;
2073 // double rho = 0;
2074 // if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
2075 // rho = fPUEnergyDensity->At(0)->Rho();
2076 // if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
2077 // rho = fPUEnergyDensity->At(0)->RhoLowEta();
2078
2079 // WARNING!!!!
2080 // hardcode for sync ...
2081 EffectiveAreaVersion = eleT.kEleEAData2011;
2082 // WARNING!!!!
2083
2084 if( ctrl.debug) {
2085 cout << "RHO: " << rho << endl;
2086 cout << "eta: " << ele->SCluster()->Eta() << endl;
2087 cout << "target: " << EffectiveAreaVersion << endl;
2088 cout << "effA 0-1: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
2089 ele->SCluster()->Eta(),
2090 EffectiveAreaVersion)
2091 << endl;
2092 cout << "effA 1-2: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
2093 ele->SCluster()->Eta(),
2094 EffectiveAreaVersion)
2095 << endl;
2096 cout << "effA 2-3: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
2097 ele->SCluster()->Eta(),
2098 EffectiveAreaVersion)
2099 << endl;
2100 cout << "effA 3-4: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
2101 ele->SCluster()->Eta(),
2102 EffectiveAreaVersion)
2103 << endl;
2104 }
2105
2106 fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
2107 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
2108 ele->SCluster()->Eta(),
2109 EffectiveAreaVersion))/ele->Pt()
2110 ,2.5)
2111 ,0.0);
2112 fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
2113 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
2114 ele->SCluster()->Eta(),
2115 EffectiveAreaVersion))/ele->Pt()
2116 ,2.5)
2117 ,0.0);
2118 fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
2119 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
2120 ele->SCluster()->Eta()
2121 ,EffectiveAreaVersion))/ele->Pt()
2122 ,2.5)
2123 ,0.0);
2124 fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
2125 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
2126 ele->SCluster()->Eta(),
2127 EffectiveAreaVersion))/ele->Pt()
2128 ,2.5)
2129 ,0.0);
2130 fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
2131 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
2132 ele->SCluster()->Eta(),
2133 EffectiveAreaVersion))/ele->Pt()
2134 ,2.5)
2135 ,0.0);
2136
2137
2138 if( ctrl.debug) {
2139 cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
2140 cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
2141 cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
2142 cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
2143 cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
2144 }
2145
2146 fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
2147 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
2148 ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2149 , 2.5)
2150 , 0.0);
2151 fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
2152 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
2153 ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2154 , 2.5)
2155 , 0.0);
2156 fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
2157 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
2158 ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2159 , 2.5)
2160 , 0.0);
2161 fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
2162 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
2163 ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
2164 , 2.5)
2165 , 0.0);
2166 fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
2167 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
2168 ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
2169 , 2.5)
2170 , 0.0);
2171
2172 if( ctrl.debug) {
2173 cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
2174 cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
2175 cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
2176 cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
2177 cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
2178 }
2179
2180 double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
2181 ele->SCluster()->Eta(),
2182 fChargedIso_DR0p0To0p1,
2183 fChargedIso_DR0p1To0p2,
2184 fChargedIso_DR0p2To0p3,
2185 fChargedIso_DR0p3To0p4,
2186 fChargedIso_DR0p4To0p5,
2187 fGammaIso_DR0p0To0p1,
2188 fGammaIso_DR0p1To0p2,
2189 fGammaIso_DR0p2To0p3,
2190 fGammaIso_DR0p3To0p4,
2191 fGammaIso_DR0p4To0p5,
2192 fNeutralHadronIso_DR0p0To0p1,
2193 fNeutralHadronIso_DR0p1To0p2,
2194 fNeutralHadronIso_DR0p2To0p3,
2195 fNeutralHadronIso_DR0p3To0p4,
2196 fNeutralHadronIso_DR0p4To0p5,
2197 ctrl.debug);
2198
2199 SelectionStatus status;
2200 status.isoMVA = mvaval;
2201 bool pass = false;
2202
2203 Int_t subdet = 0;
2204 if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
2205 else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
2206 else subdet = 2;
2207
2208 Int_t ptBin = 0;
2209 if (ele->Pt() >= 10.0) ptBin = 1;
2210
2211 Int_t MVABin = -1;
2212 if (subdet == 0 && ptBin == 0) MVABin = 0;
2213 if (subdet == 1 && ptBin == 0) MVABin = 1;
2214 if (subdet == 2 && ptBin == 0) MVABin = 2;
2215 if (subdet == 0 && ptBin == 1) MVABin = 3;
2216 if (subdet == 1 && ptBin == 1) MVABin = 4;
2217 if (subdet == 2 && ptBin == 1) MVABin = 5;
2218
2219 pass = false;
2220 if( MVABin == 0 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN0 ) pass = true;
2221 if( MVABin == 1 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN1 ) pass = true;
2222 if( MVABin == 2 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN2 ) pass = true;
2223 if( MVABin == 3 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN3 ) pass = true;
2224 if( MVABin == 4 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN4 ) pass = true;
2225 if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN5 ) pass = true;
2226 if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
2227
2228 // pass = false;
2229 // if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
2230 // if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
2231 // if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
2232 // if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
2233 // if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
2234 // if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
2235 // if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
2236
2237 if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2238 return status;
2239
2240 }
2241
2242
2243 //--------------------------------------------------------------------------------------------------
2244 void initElectronIsoMVA() {
2245 //--------------------------------------------------------------------------------------------------
2246 eleIsoMVA = new mithep::ElectronIDMVA();
2247 vector<string> weightFiles;
2248 weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_BarrelPt5To10.weights.xml");
2249 weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_EndcapPt5To10.weights.xml");
2250 weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_BarrelPt10ToInf.weights.xml");
2251 weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_EndcapPt10ToInf.weights.xml");
2252 eleIsoMVA->Initialize( "ElectronIsoMVA",
2253 mithep::ElectronIDMVA::kIsoRingsV0,
2254 kTRUE, weightFiles);
2255 }
2256
2257
2258
2259
2260 //--------------------------------------------------------------------------------------------------
2261 float electronPFIso04(ControlFlags &ctrl,
2262 const mithep::Electron * ele,
2263 const mithep::Vertex * vtx,
2264 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2265 const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2266 mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2267 vector<const mithep::Muon*> muonsToVeto,
2268 vector<const mithep::Electron*> electronsToVeto)
2269 //--------------------------------------------------------------------------------------------------
2270 {
2271 /*
2272 if( ctrl.debug ) {
2273 cout << "electronIsoMVASelection :: muons to veto " << endl;
2274 for( int i=0; i<muonsToVeto.size(); i++ ) {
2275 const mithep::Muon * vmu = muonsToVeto[i];
2276 cout << "\tpt: " << vmu->Pt()
2277 << "\teta: " << vmu->Eta()
2278 << "\tphi: " << vmu->Phi()
2279 << endl;
2280 }
2281 cout << "electronIsoMVASelection :: electrons to veto " << endl;
2282 for( int i=0; i<electronsToVeto.size(); i++ ) {
2283 const mithep::Electron * vel = electronsToVeto[i];
2284 cout << "\tpt: " << vel->Pt()
2285 << "\teta: " << vel->Eta()
2286 << "\tphi: " << vel->Phi()
2287 << "\ttrk: " << vel->TrackerTrk()
2288 << endl;
2289 }
2290 }
2291 */
2292
2293 //
2294 // final iso
2295 //
2296 Double_t fChargedIso = 0.0;
2297 Double_t fGammaIso = 0.0;
2298 Double_t fNeutralHadronIso = 0.0;
2299
2300
2301 //
2302 //Loop over PF Candidates
2303 //
2304 for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2305
2306
2307 const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2308 Double_t deta = (ele->Eta() - pf->Eta());
2309 Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
2310 Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
2311
2312 if (dr > 0.4) continue;
2313 if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
2314
2315 if(ctrl.debug) {
2316 cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
2317 if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx)
2318 << "\ttrk: " << pf->HasTrackerTrk()
2319 << "\tgsf: " << pf->HasGsfTrk();
2320
2321 cout << endl;
2322 }
2323
2324
2325 //
2326 // sync : I don't think theyre doing this ...
2327 //
2328 // if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
2329 // (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
2330 // if( ctrl.debug ) cout << "\tskipping, matches to the electron ..." << endl;
2331 // continue;
2332 // }
2333
2334
2335 //
2336 // Lepton Footprint Removal
2337 //
2338 Bool_t IsLeptonFootprint = kFALSE;
2339 if (dr < 1.0) {
2340
2341 //
2342 // Check for electrons
2343 //
2344 for (Int_t q=0; q < electronsToVeto.size(); ++q) {
2345 const mithep::Electron *tmpele = electronsToVeto[q];
2346 /*
2347 // 4l electron
2348 if( pf->HasTrackerTrk() ) {
2349 if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
2350 if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
2351 IsLeptonFootprint = kTRUE;
2352 }
2353 }
2354 if( pf->HasGsfTrk() ) {
2355 if( pf->GsfTrk() == tmpele->GsfTrk() ) {
2356 if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
2357 IsLeptonFootprint = kTRUE;
2358 }
2359 }
2360 */
2361 // PF charged
2362 if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
2363 && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
2364 if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
2365 IsLeptonFootprint = kTRUE;
2366 }
2367 // PF gamma
2368 if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
2369 && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
2370 if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
2371 IsLeptonFootprint = kTRUE;
2372 }
2373 } // loop over electrons
2374
2375 /* KH - comment for sync
2376 //
2377 // Check for muons
2378 //
2379 for (Int_t q=0; q < muonsToVeto.size(); ++q) {
2380 const mithep::Muon *tmpmu = muonsToVeto[q];
2381 // 4l muon
2382 if( pf->HasTrackerTrk() ) {
2383 if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
2384 if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
2385 IsLeptonFootprint = kTRUE;
2386 }
2387 }
2388 // PF charged
2389 if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
2390 if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
2391 IsLeptonFootprint = kTRUE;
2392 }
2393 } // loop over muons
2394 */
2395
2396 if (IsLeptonFootprint)
2397 continue;
2398
2399 //
2400 // Charged Iso
2401 //
2402 if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
2403
2404 // if( pf->HasTrackerTrk() )
2405 // if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2406 // if( pf->HasGsfTrk() )
2407 // if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2408
2409 // Veto any PFmuon, or PFEle
2410 if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) {
2411 if( ctrl.debug ) cout << "\t skipping, pf is and ele or mu .." <<endl;
2412 continue;
2413 }
2414
2415 // Footprint Veto
2416 if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
2417
2418 if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
2419 << "\ttype: " << pf->PFType()
2420 << "\ttrk: " << pf->TrackerTrk() << endl;
2421
2422 fChargedIso += pf->Pt();
2423 }
2424
2425 //
2426 // Gamma Iso
2427 //
2428 else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2429
2430 if (fabs(ele->SCluster()->Eta()) > 1.479) {
2431 if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
2432 }
2433 if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2434 << dr << endl;
2435 // KH, add to sync
2436 // if( pf->Pt() > 0.5 )
2437 fGammaIso += pf->Pt();
2438 }
2439
2440 //
2441 // Neutral Iso
2442 //
2443 else {
2444 if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2445 << dr << endl;
2446 // KH, add to sync
2447 // if( pf->Pt() > 0.5 )
2448 fNeutralHadronIso += pf->Pt();
2449 }
2450
2451 }
2452
2453 }
2454
2455
2456 double rho=0;
2457 if( (EffectiveAreaVersion == mithep::ElectronTools::kEleEAFall11MC) ||
2458 (EffectiveAreaVersion == mithep::ElectronTools::kEleEAData2011) ) {
2459 if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25()) ||
2460 isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25())))
2461 rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25();
2462 // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2463 EffectiveAreaVersion = mithep::ElectronTools::kEleEAData2011;
2464 // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2465 } else {
2466 if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJets()) ||
2467 isinf(fPUEnergyDensity->At(0)->RhoKt6PFJets())))
2468 rho = fPUEnergyDensity->At(0)->RhoKt6PFJets();
2469 // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2470 EffectiveAreaVersion = mithep::ElectronTools::kEleEAData2012;
2471 // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2472 }
2473 if(ctrl.debug) cout << "rho: " << rho << endl;
2474
2475 double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2476 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2477 ele->Eta(),EffectiveAreaVersion)));
2478
2479
2480 gChargedIso = fChargedIso;
2481 gGammaIso = fGammaIso;
2482 gNeutralIso = fNeutralHadronIso;
2483 return pfIso;
2484 }
2485
2486
2487
2488 //--------------------------------------------------------------------------------------------------
2489 // hacked version
2490 float electronPFIso04(ControlFlags &ctrl,
2491 const mithep::Electron * ele,
2492 const mithep::Vertex * vtx,
2493 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2494 float rho,
2495 mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2496 vector<const mithep::Muon*> muonsToVeto,
2497 vector<const mithep::Electron*> electronsToVeto)
2498 //--------------------------------------------------------------------------------------------------
2499 {
2500
2501 if( ctrl.debug ) {
2502 cout << "electronIsoMVASelection :: muons to veto " << endl;
2503 for( int i=0; i<muonsToVeto.size(); i++ ) {
2504 const mithep::Muon * vmu = muonsToVeto[i];
2505 cout << "\tpt: " << vmu->Pt()
2506 << "\teta: " << vmu->Eta()
2507 << "\tphi: " << vmu->Phi()
2508 << endl;
2509 }
2510 cout << "electronIsoMVASelection :: electrons to veto " << endl;
2511 for( int i=0; i<electronsToVeto.size(); i++ ) {
2512 const mithep::Electron * vel = electronsToVeto[i];
2513 cout << "\tpt: " << vel->Pt()
2514 << "\teta: " << vel->Eta()
2515 << "\tphi: " << vel->Phi()
2516 << "\ttrk: " << vel->TrackerTrk()
2517 << endl;
2518 }
2519 }
2520
2521
2522 //
2523 // final iso
2524 //
2525 Double_t fChargedIso = 0.0;
2526 Double_t fGammaIso = 0.0;
2527 Double_t fNeutralHadronIso = 0.0;
2528
2529
2530 //
2531 //Loop over PF Candidates
2532 //
2533 for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2534
2535
2536 const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2537 Double_t deta = (ele->Eta() - pf->Eta());
2538 Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
2539 Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
2540
2541 if (dr > 0.4) continue;
2542 if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
2543
2544 if(ctrl.debug) {
2545 cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
2546 if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx)
2547 << "\ttrk: " << pf->HasTrackerTrk()
2548 << "\tgsf: " << pf->HasGsfTrk();
2549
2550 cout << endl;
2551 }
2552
2553
2554 //
2555 // sync : I don't think theyre doing this ...
2556 //
2557 // if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
2558 // (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
2559 // if( ctrl.debug ) cout << "\tskipping, matches to the electron ..." << endl;
2560 // continue;
2561 // }
2562
2563
2564 //
2565 // Lepton Footprint Removal
2566 //
2567 Bool_t IsLeptonFootprint = kFALSE;
2568 if (dr < 1.0) {
2569
2570 //
2571 // Check for electrons
2572 //
2573 for (Int_t q=0; q < electronsToVeto.size(); ++q) {
2574 const mithep::Electron *tmpele = electronsToVeto[q];
2575 /*
2576 // 4l electron
2577 if( pf->HasTrackerTrk() ) {
2578 if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
2579 if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
2580 IsLeptonFootprint = kTRUE;
2581 }
2582 }
2583 if( pf->HasGsfTrk() ) {
2584 if( pf->GsfTrk() == tmpele->GsfTrk() ) {
2585 if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
2586 IsLeptonFootprint = kTRUE;
2587 }
2588 }
2589 */
2590 // PF charged
2591 if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
2592 && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
2593 if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
2594 IsLeptonFootprint = kTRUE;
2595 }
2596 // PF gamma
2597 if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
2598 && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
2599 if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
2600 IsLeptonFootprint = kTRUE;
2601 }
2602 } // loop over electrons
2603
2604 /* KH - comment for sync
2605 //
2606 // Check for muons
2607 //
2608 for (Int_t q=0; q < muonsToVeto.size(); ++q) {
2609 const mithep::Muon *tmpmu = muonsToVeto[q];
2610 // 4l muon
2611 if( pf->HasTrackerTrk() ) {
2612 if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
2613 if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
2614 IsLeptonFootprint = kTRUE;
2615 }
2616 }
2617 // PF charged
2618 if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
2619 if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
2620 IsLeptonFootprint = kTRUE;
2621 }
2622 } // loop over muons
2623 */
2624
2625 if (IsLeptonFootprint)
2626 continue;
2627
2628 //
2629 // Charged Iso
2630 //
2631 if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
2632
2633 // if( pf->HasTrackerTrk() )
2634 // if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2635 // if( pf->HasGsfTrk() )
2636 // if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2637
2638 // Veto any PFmuon, or PFEle
2639 if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) {
2640 if( ctrl.debug ) cout << "\t skipping, pf is and ele or mu .." <<endl;
2641 continue;
2642 }
2643
2644 // Footprint Veto
2645 if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
2646
2647 if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
2648 << "\ttype: " << pf->PFType()
2649 << "\ttrk: " << pf->TrackerTrk() << endl;
2650
2651 fChargedIso += pf->Pt();
2652 }
2653
2654 //
2655 // Gamma Iso
2656 //
2657 else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2658
2659 if (fabs(ele->SCluster()->Eta()) > 1.479) {
2660 if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
2661 }
2662 if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2663 << dr << endl;
2664 // KH, add to sync
2665 // if( pf->Pt() > 0.5 )
2666 fGammaIso += pf->Pt();
2667 }
2668
2669 //
2670 // Neutral Iso
2671 //
2672 else {
2673 if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2674 << dr << endl;
2675 // KH, add to sync
2676 // if( pf->Pt() > 0.5 )
2677 fNeutralHadronIso += pf->Pt();
2678 }
2679
2680 }
2681
2682 }
2683
2684 // double rho = 0;
2685 // if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
2686 // rho = fPUEnergyDensity->At(0)->Rho();
2687
2688 // WARNING!!!!
2689 // hardcode for sync ...
2690 EffectiveAreaVersion = eleT.kEleEAData2011;
2691 // WARNING!!!!
2692
2693
2694 double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2695 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2696 ele->Eta(),EffectiveAreaVersion)));
2697
2698
2699 gChargedIso = fChargedIso;
2700 gGammaIso = fGammaIso;
2701 gNeutralIso = fNeutralHadronIso;
2702 return pfIso;
2703 }
2704
2705
2706 //--------------------------------------------------------------------------------------------------
2707 SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2708 const mithep::Electron * ele,
2709 const mithep::Vertex * vtx,
2710 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2711 const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2712 mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2713 vector<const mithep::Muon*> muonsToVeto,
2714 vector<const mithep::Electron*> electronsToVeto)
2715 //--------------------------------------------------------------------------------------------------
2716 {
2717
2718 SelectionStatus status;
2719
2720 double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, fPUEnergyDensity,
2721 EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
2722 // cout << "--------------> setting electron isoPF04 to " << pfIso << endl;
2723 status.isoPF04 = pfIso;
2724 status.chisoPF04 = gChargedIso;
2725 status.gaisoPF04 = gGammaIso;
2726 status.neisoPF04 = gNeutralIso;
2727
2728 bool pass = false;
2729 if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
2730
2731 if( pass ) {
2732 status.orStatus(SelectionStatus::LOOSEISO);
2733 status.orStatus(SelectionStatus::TIGHTISO);
2734 }
2735 if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2736 return status;
2737
2738 }
2739
2740
2741 //--------------------------------------------------------------------------------------------------
2742 // hacked version
2743 SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2744 const mithep::Electron * ele,
2745 const mithep::Vertex * vtx,
2746 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2747 float rho,
2748 mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2749 vector<const mithep::Muon*> muonsToVeto,
2750 vector<const mithep::Electron*> electronsToVeto)
2751 //--------------------------------------------------------------------------------------------------
2752 {
2753
2754 SelectionStatus status;
2755
2756 double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, rho,
2757 EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
2758 status.isoPF04 = pfIso;
2759 status.chisoPF04 = gChargedIso;
2760 status.gaisoPF04 = gGammaIso;
2761 status.neisoPF04 = gNeutralIso;
2762 bool pass = false;
2763 if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
2764
2765 if( pass ) {
2766 status.orStatus(SelectionStatus::LOOSEISO);
2767 status.orStatus(SelectionStatus::TIGHTISO);
2768 }
2769 if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2770 return status;
2771
2772 }
2773
2774
2775
2776 //--------------------------------------------------------------------------------------------------
2777 double dbetaCorrectedIsoDr03(ControlFlags & ctrl,
2778 const mithep::PFCandidate * photon,
2779 const mithep::Muon * lepton,
2780 const mithep::Array<mithep::PFCandidate> * fPFCandidates)
2781 //--------------------------------------------------------------------------------------------------
2782 {
2783
2784 //
2785 // final iso
2786 //
2787 Double_t fChargedIso = 0.0;
2788 Double_t fGammaIso = 0.0;
2789 Double_t fNeutralHadronIso = 0.0;
2790 Double_t fpfPU = 0.0;
2791
2792 //
2793 // Loop over PF Candidates
2794 //
2795 for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2796
2797 const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2798
2799 Double_t deta = (photon->Eta() - pf->Eta());
2800 Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2801 Double_t dr = mithep::MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2802 if (dr > 0.3) continue;
2803
2804 if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2805 if( pf->Pt() >= 0.2 && dr > 0.01 )
2806 fpfPU += pf->Pt();
2807 continue;
2808 }
2809
2810 //
2811 // skip this photon
2812 //
2813 if( abs(pf->PFType()) == mithep::PFCandidate::eGamma &&
2814 pf->Et() == photon->Et() ) continue;
2815
2816
2817 //
2818 // Charged Iso
2819 //
2820 if (pf->Charge() != 0 ) {
2821 if( dr > 0.01 && pf->Pt() >= 0.2 &&
2822 !(pf->TrackerTrk() == lepton->TrackerTrk()) )
2823 fChargedIso += pf->Pt();
2824 }
2825
2826 //
2827 // Gamma Iso
2828 //
2829 else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
2830 if( pf->Pt() > 0.5 && dr > 0.01)
2831 fGammaIso += pf->Pt();
2832 }
2833
2834 //
2835 // Other Neutrals
2836 //
2837 else {
2838 if( pf->Pt() > 0.5 && dr > 0.01)
2839 fNeutralHadronIso += pf->Pt();
2840 }
2841
2842 }
2843
2844 if( ctrl.debug ) {
2845 cout << "photon dbetaIso :: " << endl;
2846 cout << "\tfChargedIso: " << fChargedIso
2847 << "\tfGammaIso: " << fGammaIso
2848 << "\tfNeutralHadronIso: " << fNeutralHadronIso
2849 << "\tfpfPU: " << fpfPU
2850 << endl;
2851 }
2852 double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso - 0.5*fpfPU;
2853 return pfIso/photon->Pt();
2854 }
2855
2856
2857 //--------------------------------------------------------------------------------------------------
2858 double dbetaCorrectedIsoDr03(ControlFlags & ctrl,
2859 const mithep::PFCandidate * photon,
2860 const mithep::Electron * lepton,
2861 const mithep::Array<mithep::PFCandidate> * fPFCandidates)
2862 //--------------------------------------------------------------------------------------------------
2863 {
2864
2865 //
2866 // final iso
2867 //
2868 Double_t fChargedIso = 0.0;
2869 Double_t fGammaIso = 0.0;
2870 Double_t fNeutralHadronIso = 0.0;
2871 Double_t fpfPU = 0.0;
2872
2873 //
2874 // Loop over PF Candidates
2875 //
2876 for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2877
2878 const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2879
2880 Double_t deta = (photon->Eta() - pf->Eta());
2881 Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2882 Double_t dr = mithep::MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2883 if (dr > 0.3) continue;
2884
2885 if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2886 if( pf->Pt() >= 0.2 && dr > 0.01 )
2887 fpfPU += pf->Pt();
2888 continue;
2889 }
2890
2891 //
2892 // skip this photon
2893 //
2894 if( abs(pf->PFType()) == mithep::PFCandidate::eGamma &&
2895 pf->Et() == photon->Et() ) continue;
2896
2897
2898 //
2899 // Charged Iso
2900 //
2901 if (pf->Charge() != 0 ) {
2902 if( dr > 0.01 && pf->Pt() >= 0.2 &&
2903 !(pf->TrackerTrk() == lepton->TrackerTrk()) )
2904 fChargedIso += pf->Pt();
2905 }
2906
2907 //
2908 // Gamma Iso
2909 //
2910 else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
2911 if( pf->Pt() > 0.5 && dr > 0.01)
2912 fGammaIso += pf->Pt();
2913 }
2914
2915 //
2916 // Other Neutrals
2917 //
2918 else {
2919 if( pf->Pt() > 0.5 && dr > 0.01)
2920 fNeutralHadronIso += pf->Pt();
2921 }
2922
2923 }
2924
2925 if( ctrl.debug ) {
2926 cout << "photon dbetaIso :: " << endl;
2927 cout << "\tfChargedIso: " << fChargedIso
2928 << "\tfGammaIso: " << fGammaIso
2929 << "\tfNeutralHadronIso: " << fNeutralHadronIso
2930 << "\tfpfPU: " << fpfPU
2931 << endl;
2932 }
2933 double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso - 0.5*fpfPU;
2934 return pfIso/photon->Pt();
2935 }
2936
2937
2938
2939
2940
2941 //--------------------------------------------------------------------------------------------------
2942 double betaCorrectedIsoDr03(ControlFlags & ctrl,
2943 const mithep::PFCandidate * photon,
2944 const mithep::Muon * lepton,
2945 const mithep::Array<mithep::PFCandidate> * fPFCandidates)
2946 //--------------------------------------------------------------------------------------------------
2947 {
2948
2949 //
2950 // final iso
2951 //
2952 Double_t fChargedIso = 0.0;
2953 Double_t fGammaIso = 0.0;
2954 Double_t fNeutralHadronIso = 0.0;
2955 Double_t fpfPU = 0.0;
2956
2957 //
2958 // Loop over PF Candidates
2959 //
2960 for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2961
2962 const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2963
2964 Double_t deta = (photon->Eta() - pf->Eta());
2965 Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2966 Double_t dr = mithep::MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2967 if (dr > 0.3) continue;
2968
2969 if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2970 if( pf->Pt() >= 0.2 && dr > 0.01 )
2971 fpfPU += pf->Pt();
2972 continue;
2973 }
2974
2975 //
2976 // skip this photon
2977 //
2978 if( abs(pf->PFType()) == mithep::PFCandidate::eGamma &&
2979 pf->Et() == photon->Et() ) continue;
2980
2981
2982 //
2983 // Charged Iso
2984 //
2985 if (pf->Charge() != 0 ) {
2986 if( dr > 0.01 && pf->Pt() >= 0.2 &&
2987 !(pf->TrackerTrk() == lepton->TrackerTrk()) )
2988 fChargedIso += pf->Pt();
2989 }
2990
2991 //
2992 // Gamma Iso
2993 //
2994 else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
2995 if( pf->Pt() > 0.5 && dr > 0.01)
2996 fGammaIso += pf->Pt();
2997 }
2998
2999 //
3000 // Other Neutrals
3001 //
3002 else {
3003 if( pf->Pt() > 0.5 && dr > 0.01)
3004 fNeutralHadronIso += pf->Pt();
3005 }
3006
3007 }
3008
3009 if( ctrl.debug ) {
3010 cout << "photon dbetaIso :: " << endl;
3011 cout << "\tfChargedIso: " << fChargedIso
3012 << "\tfGammaIso: " << fGammaIso
3013 << "\tfNeutralHadronIso: " << fNeutralHadronIso
3014 << "\tfpfPU: " << fpfPU
3015 << endl;
3016 }
3017 double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso + fpfPU;
3018 return pfIso/photon->Pt();
3019 }
3020
3021
3022 //--------------------------------------------------------------------------------------------------
3023 double betaCorrectedIsoDr03(ControlFlags & ctrl,
3024 const mithep::PFCandidate * photon,
3025 const mithep::Electron * lepton,
3026 const mithep::Array<mithep::PFCandidate> * fPFCandidates)
3027 //--------------------------------------------------------------------------------------------------
3028 {
3029
3030 //
3031 // final iso
3032 //
3033 Double_t fChargedIso = 0.0;
3034 Double_t fGammaIso = 0.0;
3035 Double_t fNeutralHadronIso = 0.0;
3036 Double_t fpfPU = 0.0;
3037
3038 //
3039 // Loop over PF Candidates
3040 //
3041 for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
3042
3043 const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
3044
3045 Double_t deta = (photon->Eta() - pf->Eta());
3046 Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
3047 Double_t dr = mithep::MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
3048 if (dr > 0.3) continue;
3049
3050 if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
3051 if( pf->Pt() >= 0.2 && dr > 0.01 )
3052 fpfPU += pf->Pt();
3053 continue;
3054 }
3055
3056 //
3057 // skip this photon
3058 //
3059 if( abs(pf->PFType()) == mithep::PFCandidate::eGamma &&
3060 pf->Et() == photon->Et() ) continue;
3061
3062
3063 //
3064 // Charged Iso
3065 //
3066 if (pf->Charge() != 0 ) {
3067 if( dr > 0.01 && pf->Pt() >= 0.2 &&
3068 !(pf->TrackerTrk() == lepton->TrackerTrk()) )
3069 fChargedIso += pf->Pt();
3070 }
3071
3072 //
3073 // Gamma Iso
3074 //
3075 else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
3076 if( pf->Pt() > 0.5 && dr > 0.01)
3077 fGammaIso += pf->Pt();
3078 }
3079
3080 //
3081 // Other Neutrals
3082 //
3083 else {
3084 if( pf->Pt() > 0.5 && dr > 0.01)
3085 fNeutralHadronIso += pf->Pt();
3086 }
3087
3088 }
3089
3090 if( ctrl.debug ) {
3091 cout << "photon dbetaIso :: " << endl;
3092 cout << "\tfChargedIso: " << fChargedIso
3093 << "\tfGammaIso: " << fGammaIso
3094 << "\tfNeutralHadronIso: " << fNeutralHadronIso
3095 << "\tfpfPU: " << fpfPU
3096 << endl;
3097 }
3098 double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso + fpfPU;
3099 return pfIso/photon->Pt();
3100 }
3101
3102
3103