ViewVC Help
View File | Revision Log | Show Annotations | Root Listing
root/cvsroot/UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc
Revision: 1.33
Committed: Wed Oct 17 01:31:22 2012 UTC (12 years, 7 months ago) by anlevin
Content type: text/plain
Branch: MAIN
Changes since 1.32: +6 -4 lines
Log Message: 
updates for hcp sync

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::PFCandidate*> photonsToVeto)
966 //--------------------------------------------------------------------------------------------------
967 {
968
969 extern double gChargedIso;
970 extern double gGammaIso;
971 extern double gNeutralIso;
972
973 //
974 // final iso
975 //
976 Double_t fChargedIso = 0.0;
977 Double_t fGammaIso = 0.0;
978 Double_t fNeutralHadronIso = 0.0;
979
980 //
981 //Loop over PF Candidates
982 //
983 for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
984
985 if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
986 const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
987
988 //
989 // veto FSR recovered photons
990 //
991 bool vetoPhoton = false;
992 for( int p=0; p<photonsToVeto.size(); p++ ) {
993 if( pf == photonsToVeto[p] ) {
994 vetoPhoton = true;
995 break;
996 }
997 } if( vetoPhoton ) continue;
998 //
999 //
1000 //
1001
1002 Double_t deta = (mu->Eta() - pf->Eta());
1003 Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
1004 Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
1005 if (dr > 0.4) continue;
1006
1007 if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
1008
1009 //
1010 // Charged Iso
1011 //
1012 if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1013
1014 //if( dr < 0.01 ) continue; // only for muon iso mva?
1015 if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1016 fChargedIso += pf->Pt();
1017 }
1018
1019 //
1020 // Gamma Iso
1021 //
1022 else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1023 // KH, add to sync
1024 if( pf->Pt() > 0.5 && dr > 0.01)
1025 fGammaIso += pf->Pt();
1026 }
1027
1028 //
1029 // Other Neutrals
1030 //
1031 else {
1032
1033 if( pf->Pt() > 0.5 && dr > 0.01)
1034 fNeutralHadronIso += pf->Pt();
1035 }
1036 }
1037
1038 double rho=0;
1039 if( (EffectiveAreaVersion == mithep::MuonTools::kMuEAFall11MC) ||
1040 (EffectiveAreaVersion == mithep::MuonTools::kMuEAData2011) ) {
1041 if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25()) ||
1042 isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25())))
1043 rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25();
1044 //rho = fPUEnergyDensity->At(0)->Rho();
1045 // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
1046 EffectiveAreaVersion = mithep::MuonTools::kMuEAData2011;
1047 // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
1048 } else {
1049 if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral()) ||
1050 isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral())))
1051 rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral();
1052 // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
1053 EffectiveAreaVersion = mithep::MuonTools::kMuEAData2012;
1054 // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
1055 }
1056 if(ctrl.debug) cout << "rho: " << rho << endl;
1057
1058 TLorentzVector tmpvec;
1059 tmpvec.SetPtEtaPhiM(mu->Pt(),mu->Eta(),mu->Phi(),mu->Mass());
1060 for( int p=0; p<photonsToVeto.size(); p++ ) {
1061 const mithep::PFCandidate * pf = photonsToVeto[p];
1062 TLorentzVector pfvec;
1063 pfvec.SetPtEtaPhiM(pf->Pt(),pf->Eta(),pf->Phi(),0.);
1064 tmpvec += pfvec;
1065 }
1066
1067 double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1068 -rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
1069 //tmpvec.Eta(),EffectiveAreaVersion)));
1070 mu->Eta(),EffectiveAreaVersion)));
1071 gChargedIso = fChargedIso;
1072 gGammaIso = fGammaIso;
1073 gNeutralIso = fNeutralHadronIso;
1074
1075 if( ctrl.debug ) {
1076 cout << "PFiso: " << pfIso
1077 << "\tfChargedIso: " << fChargedIso
1078 << "\tfGammaIso: " << fGammaIso
1079 << "\tfNeutralHadronIso: " << fNeutralHadronIso
1080 << endl;
1081 }
1082
1083 return pfIso;
1084 }
1085
1086
1087
1088
1089 //--------------------------------------------------------------------------------------------------
1090 // hacked version
1091 double muonPFIso04(ControlFlags &ctrl,
1092 const mithep::Muon * mu,
1093 const mithep::Vertex * vtx,
1094 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1095 float rho,
1096 mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1097 vector<const mithep::Muon*> muonsToVeto,
1098 vector<const mithep::Electron*> electronsToVeto)
1099 //--------------------------------------------------------------------------------------------------
1100 {
1101
1102 extern double gChargedIso;
1103 extern double gGammaIso;
1104 extern double gNeutralIso;
1105
1106 if( ctrl.debug ) {
1107 cout << "muonIsoMVASelection :: muons to veto " << endl;
1108 for( int i=0; i<muonsToVeto.size(); i++ ) {
1109 const mithep::Muon * vmu = muonsToVeto[i];
1110 cout << "\tpt: " << vmu->Pt()
1111 << "\teta: " << vmu->Eta()
1112 << "\tphi: " << vmu->Phi()
1113 << endl;
1114 }
1115 cout << "muonIsoMVASelection :: electrson to veto " << endl;
1116 for( int i=0; i<electronsToVeto.size(); i++ ) {
1117 const mithep::Electron * vel = electronsToVeto[i];
1118 cout << "\tpt: " << vel->Pt()
1119 << "\teta: " << vel->Eta()
1120 << "\tphi: " << vel->Phi()
1121 << endl;
1122 }
1123 }
1124
1125 //
1126 // final iso
1127 //
1128 Double_t fChargedIso = 0.0;
1129 Double_t fGammaIso = 0.0;
1130 Double_t fNeutralHadronIso = 0.0;
1131
1132 //
1133 //Loop over PF Candidates
1134 //
1135 for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1136
1137 if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1138 const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1139
1140 Double_t deta = (mu->Eta() - pf->Eta());
1141 Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
1142 Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
1143 if (dr > 0.4) continue;
1144
1145 if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
1146
1147 //
1148 // Lepton Footprint Removal
1149 //
1150 Bool_t IsLeptonFootprint = kFALSE;
1151 if (dr < 1.0) {
1152
1153 //
1154 // Check for electrons
1155 //
1156 for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1157 const mithep::Electron *tmpele = electronsToVeto[q];
1158 // 4l electron
1159 if( pf->HasTrackerTrk() ) {
1160 if( pf->TrackerTrk() == tmpele->TrackerTrk() )
1161 IsLeptonFootprint = kTRUE;
1162 }
1163 if( pf->HasGsfTrk() ) {
1164 if( pf->GsfTrk() == tmpele->GsfTrk() )
1165 IsLeptonFootprint = kTRUE;
1166 }
1167 // PF charged
1168 if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1169 && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
1170 IsLeptonFootprint = kTRUE;
1171 // PF gamma
1172 if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1173 && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
1174 IsLeptonFootprint = kTRUE;
1175 } // loop over electrons
1176
1177 /* KH - comment for sync
1178 //
1179 // Check for muons
1180 //
1181 for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1182 const mithep::Muon *tmpmu = muonsToVeto[q];
1183 // 4l muon
1184 if( pf->HasTrackerTrk() ) {
1185 if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
1186 IsLeptonFootprint = kTRUE;
1187 }
1188 // PF charged
1189 if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
1190 IsLeptonFootprint = kTRUE;
1191 } // loop over muons
1192 */
1193
1194 if (IsLeptonFootprint)
1195 continue;
1196
1197 //
1198 // Charged Iso
1199 //
1200 if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1201
1202 //if( dr < 0.01 ) continue; // only for muon iso mva?
1203 if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1204
1205
1206 // if( pf->HasTrackerTrk() ) {
1207 // if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1208 // if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1209 // << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1210 // << dr << endl;
1211 // }
1212 // if( pf->HasGsfTrk() ) {
1213 // if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1214 // if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1215 // << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1216 // << dr << endl;
1217 // }
1218
1219
1220 fChargedIso += pf->Pt();
1221 }
1222
1223 //
1224 // Gamma Iso
1225 //
1226 else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1227 // KH, add to sync
1228 if( pf->Pt() > 0.5 )
1229 fGammaIso += pf->Pt();
1230 }
1231
1232 //
1233 // Other Neutrals
1234 //
1235 else {
1236 // KH, add to sync
1237 if( pf->Pt() > 0.5 )
1238 fNeutralHadronIso += pf->Pt();
1239 }
1240
1241 }
1242
1243 }
1244
1245 // double rho = 0;
1246 // if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1247 // rho = fPUEnergyDensity->At(0)->Rho();
1248
1249 // WARNING!!!!
1250 // hardcode for sync ...
1251 EffectiveAreaVersion = muT.kMuEAData2011;
1252 // WARNING!!!!
1253
1254
1255 double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1256 -rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
1257 mu->Eta(),EffectiveAreaVersion)));
1258 gChargedIso = fChargedIso;
1259 gGammaIso = fGammaIso;
1260 gNeutralIso = fNeutralHadronIso;
1261
1262 return pfIso;
1263 }
1264
1265
1266 //--------------------------------------------------------------------------------------------------
1267 SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1268 const mithep::Muon * mu,
1269 const mithep::Vertex * vtx,
1270 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1271 const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1272 mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1273 vector<const mithep::PFCandidate*> photonsToVeto)
1274 //--------------------------------------------------------------------------------------------------
1275 {
1276
1277 SelectionStatus status;
1278
1279 double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, fPUEnergyDensity,
1280 EffectiveAreaVersion, photonsToVeto);
1281 // cout << "--------------> setting muon isoPF04 to" << pfIso << endl;
1282 status.isoPF04 = pfIso;
1283 status.chisoPF04 = gChargedIso;
1284 status.gaisoPF04 = gGammaIso;
1285 status.neisoPF04 = gNeutralIso;
1286
1287 bool pass = false;
1288 if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1289
1290 if( pass ) {
1291 status.orStatus(SelectionStatus::LOOSEISO);
1292 status.orStatus(SelectionStatus::TIGHTISO);
1293 }
1294 if(ctrl.debug) {
1295 cout << "mu relpfIso: " << pfIso/mu->Pt() << endl;
1296 cout << "returning status : " << hex << status.getStatus() << dec << endl;
1297 }
1298 return status;
1299
1300 }
1301
1302
1303 //--------------------------------------------------------------------------------------------------
1304 // hacked version
1305 SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1306 const mithep::Muon * mu,
1307 const mithep::Vertex * vtx,
1308 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1309 float rho,
1310 mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1311 vector<const mithep::Muon*> muonsToVeto,
1312 vector<const mithep::Electron*> electronsToVeto)
1313 //--------------------------------------------------------------------------------------------------
1314 {
1315
1316 SelectionStatus status;
1317
1318 double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, rho,
1319 EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1320
1321 status.isoPF04 = pfIso;
1322 status.chisoPF04 = gChargedIso;
1323 status.gaisoPF04 = gGammaIso;
1324 status.neisoPF04 = gNeutralIso;
1325
1326 bool pass = false;
1327 if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1328
1329 if( pass ) {
1330 status.orStatus(SelectionStatus::LOOSEISO);
1331 status.orStatus(SelectionStatus::TIGHTISO);
1332 }
1333 if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1334 return status;
1335
1336 }
1337
1338
1339
1340
1341 //--------------------------------------------------------------------------------------------------
1342 SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1343 const mithep::Electron * ele,
1344 const mithep::Vertex * vtx,
1345 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1346 const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1347 mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1348 vector<const mithep::Muon*> muonsToVeto,
1349 vector<const mithep::Electron*> electronsToVeto)
1350 //--------------------------------------------------------------------------------------------------
1351 {
1352
1353 if( ctrl.debug ) {
1354 cout << "electronIsoMVASelection :: muons to veto " << endl;
1355 for( int i=0; i<muonsToVeto.size(); i++ ) {
1356 const mithep::Muon * vmu = muonsToVeto[i];
1357 cout << "\tpt: " << vmu->Pt()
1358 << "\teta: " << vmu->Eta()
1359 << "\tphi: " << vmu->Phi()
1360 << endl;
1361 }
1362 cout << "electronIsoMVASelection :: electrson to veto " << endl;
1363 for( int i=0; i<electronsToVeto.size(); i++ ) {
1364 const mithep::Electron * vel = electronsToVeto[i];
1365 cout << "\tpt: " << vel->Pt()
1366 << "\teta: " << vel->Eta()
1367 << "\tphi: " << vel->Phi()
1368 << "\ttrk: " << vel->TrackerTrk()
1369 << endl;
1370 }
1371 }
1372
1373 bool failiso=false;
1374
1375 //
1376 // tmp iso rings
1377 //
1378 Double_t tmpChargedIso_DR0p0To0p1 = 0;
1379 Double_t tmpChargedIso_DR0p1To0p2 = 0;
1380 Double_t tmpChargedIso_DR0p2To0p3 = 0;
1381 Double_t tmpChargedIso_DR0p3To0p4 = 0;
1382 Double_t tmpChargedIso_DR0p4To0p5 = 0;
1383
1384 Double_t tmpGammaIso_DR0p0To0p1 = 0;
1385 Double_t tmpGammaIso_DR0p1To0p2 = 0;
1386 Double_t tmpGammaIso_DR0p2To0p3 = 0;
1387 Double_t tmpGammaIso_DR0p3To0p4 = 0;
1388 Double_t tmpGammaIso_DR0p4To0p5 = 0;
1389
1390
1391 Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
1392 Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
1393 Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
1394 Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
1395 Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
1396
1397
1398
1399 //
1400 // final rings for the MVA
1401 //
1402 Double_t fChargedIso_DR0p0To0p1;
1403 Double_t fChargedIso_DR0p1To0p2;
1404 Double_t fChargedIso_DR0p2To0p3;
1405 Double_t fChargedIso_DR0p3To0p4;
1406 Double_t fChargedIso_DR0p4To0p5;
1407
1408 Double_t fGammaIso_DR0p0To0p1;
1409 Double_t fGammaIso_DR0p1To0p2;
1410 Double_t fGammaIso_DR0p2To0p3;
1411 Double_t fGammaIso_DR0p3To0p4;
1412 Double_t fGammaIso_DR0p4To0p5;
1413
1414 Double_t fNeutralHadronIso_DR0p0To0p1;
1415 Double_t fNeutralHadronIso_DR0p1To0p2;
1416 Double_t fNeutralHadronIso_DR0p2To0p3;
1417 Double_t fNeutralHadronIso_DR0p3To0p4;
1418 Double_t fNeutralHadronIso_DR0p4To0p5;
1419
1420
1421 //
1422 //Loop over PF Candidates
1423 //
1424 for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1425
1426 if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1427
1428 const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1429 Double_t deta = (ele->Eta() - pf->Eta());
1430 Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1431 Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1432 if (dr > 1.0) continue;
1433
1434 if(ctrl.debug) {
1435 cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1436 if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx);
1437 cout << endl;
1438 }
1439
1440
1441 if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
1442 (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1443
1444
1445 //
1446 // Lepton Footprint Removal
1447 //
1448 Bool_t IsLeptonFootprint = kFALSE;
1449 if (dr < 1.0) {
1450
1451
1452 //
1453 // Check for electrons
1454 //
1455
1456 for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1457 const mithep::Electron *tmpele = electronsToVeto[q];
1458 double tmpdr = mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1459
1460 // 4l electron
1461 if( pf->HasTrackerTrk() ) {
1462 if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
1463 if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1464 IsLeptonFootprint = kTRUE;
1465 }
1466 }
1467 if( pf->HasGsfTrk() ) {
1468 if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1469 if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1470 IsLeptonFootprint = kTRUE;
1471 }
1472 }
1473 // PF charged
1474 if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1475 if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1476 IsLeptonFootprint = kTRUE;
1477 }
1478 // PF gamma
1479 if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1480 && tmpdr < 0.08) {
1481 if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1482 IsLeptonFootprint = kTRUE;
1483 }
1484 } // loop over electrons
1485
1486
1487 /* KH - comment for sync
1488 //
1489 // Check for muons
1490 //
1491 for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1492 const mithep::Muon *tmpmu = muonsToVeto[q];
1493 // 4l muon
1494 if( pf->HasTrackerTrk() ) {
1495 if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1496 if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1497 IsLeptonFootprint = kTRUE;
1498 }
1499 }
1500 // PF charged
1501 if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1502 if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1503 IsLeptonFootprint = kTRUE;
1504 }
1505 } // loop over muons
1506 */
1507
1508 if (IsLeptonFootprint)
1509 continue;
1510
1511 //
1512 // Charged Iso Rings
1513 //
1514 if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1515
1516 // if( pf->HasGsfTrk() ) {
1517 // if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1518 // } else if( pf->HasTrackerTrk() ){
1519 // if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1520 // }
1521
1522 // Veto any PFmuon, or PFEle
1523 if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1524
1525 // Footprint Veto
1526 if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
1527
1528 if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
1529 << "\ttype: " << pf->PFType()
1530 << "\ttrk: " << pf->TrackerTrk() << endl;
1531
1532 if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
1533 if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
1534 if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1535 if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1536 if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
1537
1538 }
1539
1540 //
1541 // Gamma Iso Rings
1542 //
1543 else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1544
1545 if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
1546
1547 if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1548 << dr << endl;
1549
1550 if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
1551 if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
1552 if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1553 if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1554 if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
1555 }
1556
1557 //
1558 // Other Neutral Iso Rings
1559 //
1560 else {
1561 if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
1562 << dr << endl;
1563 if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
1564 if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
1565 if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1566 if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1567 if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
1568 }
1569
1570 }
1571
1572 }
1573
1574 fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1575 fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1576 fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1577 fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1578 fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1579
1580 if(ctrl.debug) {
1581 cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1 << endl;
1582 cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2 << endl;
1583 cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3 << endl;
1584 cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4 << endl;
1585 cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5 << endl;
1586 }
1587
1588
1589 double rho = 0;
1590 if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1591 rho = fPUEnergyDensity->At(0)->Rho();
1592 // if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
1593 // rho = fPUEnergyDensity->At(0)->RhoLowEta();
1594
1595 // WARNING!!!!
1596 // hardcode for sync ...
1597 EffectiveAreaVersion = eleT.kEleEAData2011;
1598 // WARNING!!!!
1599
1600 if( ctrl.debug) {
1601 cout << "RHO: " << rho << endl;
1602 cout << "eta: " << ele->SCluster()->Eta() << endl;
1603 cout << "target: " << EffectiveAreaVersion << endl;
1604 cout << "effA 0-1: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1605 ele->SCluster()->Eta(),
1606 EffectiveAreaVersion)
1607 << endl;
1608 cout << "effA 1-2: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1609 ele->SCluster()->Eta(),
1610 EffectiveAreaVersion)
1611 << endl;
1612 cout << "effA 2-3: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1613 ele->SCluster()->Eta(),
1614 EffectiveAreaVersion)
1615 << endl;
1616 cout << "effA 3-4: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1617 ele->SCluster()->Eta(),
1618 EffectiveAreaVersion)
1619 << endl;
1620 }
1621
1622 fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
1623 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
1624 ele->SCluster()->Eta(),
1625 EffectiveAreaVersion))/ele->Pt()
1626 ,2.5)
1627 ,0.0);
1628 fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
1629 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
1630 ele->SCluster()->Eta(),
1631 EffectiveAreaVersion))/ele->Pt()
1632 ,2.5)
1633 ,0.0);
1634 fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
1635 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
1636 ele->SCluster()->Eta()
1637 ,EffectiveAreaVersion))/ele->Pt()
1638 ,2.5)
1639 ,0.0);
1640 fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
1641 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
1642 ele->SCluster()->Eta(),
1643 EffectiveAreaVersion))/ele->Pt()
1644 ,2.5)
1645 ,0.0);
1646 fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
1647 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
1648 ele->SCluster()->Eta(),
1649 EffectiveAreaVersion))/ele->Pt()
1650 ,2.5)
1651 ,0.0);
1652
1653
1654 if( ctrl.debug) {
1655 cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
1656 cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
1657 cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
1658 cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
1659 cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
1660 }
1661
1662 fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
1663 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1664 ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1665 , 2.5)
1666 , 0.0);
1667 fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
1668 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1669 ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1670 , 2.5)
1671 , 0.0);
1672 fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
1673 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1674 ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1675 , 2.5)
1676 , 0.0);
1677 fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
1678 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1679 ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1680 , 2.5)
1681 , 0.0);
1682 fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
1683 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
1684 ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1685 , 2.5)
1686 , 0.0);
1687
1688 if( ctrl.debug) {
1689 cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
1690 cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
1691 cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
1692 cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
1693 cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
1694 }
1695
1696 double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
1697 ele->SCluster()->Eta(),
1698 fChargedIso_DR0p0To0p1,
1699 fChargedIso_DR0p1To0p2,
1700 fChargedIso_DR0p2To0p3,
1701 fChargedIso_DR0p3To0p4,
1702 fChargedIso_DR0p4To0p5,
1703 fGammaIso_DR0p0To0p1,
1704 fGammaIso_DR0p1To0p2,
1705 fGammaIso_DR0p2To0p3,
1706 fGammaIso_DR0p3To0p4,
1707 fGammaIso_DR0p4To0p5,
1708 fNeutralHadronIso_DR0p0To0p1,
1709 fNeutralHadronIso_DR0p1To0p2,
1710 fNeutralHadronIso_DR0p2To0p3,
1711 fNeutralHadronIso_DR0p3To0p4,
1712 fNeutralHadronIso_DR0p4To0p5,
1713 ctrl.debug);
1714
1715 SelectionStatus status;
1716 status.isoMVA = mvaval;
1717 bool pass = false;
1718
1719 Int_t subdet = 0;
1720 if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
1721 else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
1722 else subdet = 2;
1723
1724 Int_t ptBin = 0;
1725 if (ele->Pt() >= 10.0) ptBin = 1;
1726
1727 Int_t MVABin = -1;
1728 if (subdet == 0 && ptBin == 0) MVABin = 0;
1729 if (subdet == 1 && ptBin == 0) MVABin = 1;
1730 if (subdet == 2 && ptBin == 0) MVABin = 2;
1731 if (subdet == 0 && ptBin == 1) MVABin = 3;
1732 if (subdet == 1 && ptBin == 1) MVABin = 4;
1733 if (subdet == 2 && ptBin == 1) MVABin = 5;
1734
1735 pass = false;
1736 if( MVABin == 0 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN0 ) pass = true;
1737 if( MVABin == 1 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN1 ) pass = true;
1738 if( MVABin == 2 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN2 ) pass = true;
1739 if( MVABin == 3 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN3 ) pass = true;
1740 if( MVABin == 4 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN4 ) pass = true;
1741 if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN5 ) pass = true;
1742 // pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
1743 if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
1744
1745 // pass = false;
1746 // if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
1747 // if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
1748 // if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
1749 // if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
1750 // if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
1751 // if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
1752 // if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
1753
1754 if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1755 return status;
1756
1757 }
1758
1759
1760 //--------------------------------------------------------------------------------------------------
1761 SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1762 const mithep::Electron * ele,
1763 const mithep::Vertex * vtx,
1764 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1765 float rho,
1766 //const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1767 mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1768 vector<const mithep::Muon*> muonsToVeto,
1769 vector<const mithep::Electron*> electronsToVeto)
1770 //--------------------------------------------------------------------------------------------------
1771 // hacked version
1772 {
1773 if( ctrl.debug ) {
1774 cout << "================> hacked ele Iso MVA <======================" << endl;
1775 }
1776
1777 if( ctrl.debug ) {
1778 cout << "electronIsoMVASelection :: muons to veto " << endl;
1779 for( int i=0; i<muonsToVeto.size(); i++ ) {
1780 const mithep::Muon * vmu = muonsToVeto[i];
1781 cout << "\tpt: " << vmu->Pt()
1782 << "\teta: " << vmu->Eta()
1783 << "\tphi: " << vmu->Phi()
1784 << endl;
1785 }
1786 cout << "electronIsoMVASelection :: electrson to veto " << endl;
1787 for( int i=0; i<electronsToVeto.size(); i++ ) {
1788 const mithep::Electron * vel = electronsToVeto[i];
1789 cout << "\tpt: " << vel->Pt()
1790 << "\teta: " << vel->Eta()
1791 << "\tphi: " << vel->Phi()
1792 << "\ttrk: " << vel->TrackerTrk()
1793 << endl;
1794 }
1795 }
1796
1797 bool failiso=false;
1798
1799 //
1800 // tmp iso rings
1801 //
1802 Double_t tmpChargedIso_DR0p0To0p1 = 0;
1803 Double_t tmpChargedIso_DR0p1To0p2 = 0;
1804 Double_t tmpChargedIso_DR0p2To0p3 = 0;
1805 Double_t tmpChargedIso_DR0p3To0p4 = 0;
1806 Double_t tmpChargedIso_DR0p4To0p5 = 0;
1807
1808 Double_t tmpGammaIso_DR0p0To0p1 = 0;
1809 Double_t tmpGammaIso_DR0p1To0p2 = 0;
1810 Double_t tmpGammaIso_DR0p2To0p3 = 0;
1811 Double_t tmpGammaIso_DR0p3To0p4 = 0;
1812 Double_t tmpGammaIso_DR0p4To0p5 = 0;
1813
1814
1815 Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
1816 Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
1817 Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
1818 Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
1819 Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
1820
1821
1822
1823 //
1824 // final rings for the MVA
1825 //
1826 Double_t fChargedIso_DR0p0To0p1;
1827 Double_t fChargedIso_DR0p1To0p2;
1828 Double_t fChargedIso_DR0p2To0p3;
1829 Double_t fChargedIso_DR0p3To0p4;
1830 Double_t fChargedIso_DR0p4To0p5;
1831
1832 Double_t fGammaIso_DR0p0To0p1;
1833 Double_t fGammaIso_DR0p1To0p2;
1834 Double_t fGammaIso_DR0p2To0p3;
1835 Double_t fGammaIso_DR0p3To0p4;
1836 Double_t fGammaIso_DR0p4To0p5;
1837
1838 Double_t fNeutralHadronIso_DR0p0To0p1;
1839 Double_t fNeutralHadronIso_DR0p1To0p2;
1840 Double_t fNeutralHadronIso_DR0p2To0p3;
1841 Double_t fNeutralHadronIso_DR0p3To0p4;
1842 Double_t fNeutralHadronIso_DR0p4To0p5;
1843
1844
1845 //
1846 //Loop over PF Candidates
1847 //
1848 for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1849
1850 if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1851
1852 const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1853 Double_t deta = (ele->Eta() - pf->Eta());
1854 Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1855 Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1856 if (dr > 1.0) continue;
1857
1858 if(ctrl.debug) {
1859 cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1860 if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx);
1861 cout << endl;
1862 }
1863
1864
1865 if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
1866 (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1867
1868
1869 //
1870 // Lepton Footprint Removal
1871 //
1872 Bool_t IsLeptonFootprint = kFALSE;
1873 if (dr < 1.0) {
1874
1875
1876 //
1877 // Check for electrons
1878 //
1879
1880 for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1881 const mithep::Electron *tmpele = electronsToVeto[q];
1882 double tmpdr = mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1883
1884 // 4l electron
1885 if( pf->HasTrackerTrk() ) {
1886 if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
1887 if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1888 IsLeptonFootprint = kTRUE;
1889 }
1890 }
1891 if( pf->HasGsfTrk() ) {
1892 if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1893 if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1894 IsLeptonFootprint = kTRUE;
1895 }
1896 }
1897 // PF charged
1898 if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1899 if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1900 IsLeptonFootprint = kTRUE;
1901 }
1902 // PF gamma
1903 if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1904 && tmpdr < 0.08) {
1905 if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1906 IsLeptonFootprint = kTRUE;
1907 }
1908 } // loop over electrons
1909
1910
1911 /* KH - comment for sync
1912 //
1913 // Check for muons
1914 //
1915 for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1916 const mithep::Muon *tmpmu = muonsToVeto[q];
1917 // 4l muon
1918 if( pf->HasTrackerTrk() ) {
1919 if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1920 if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1921 IsLeptonFootprint = kTRUE;
1922 }
1923 }
1924 // PF charged
1925 if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1926 if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1927 IsLeptonFootprint = kTRUE;
1928 }
1929 } // loop over muons
1930 */
1931
1932 if (IsLeptonFootprint)
1933 continue;
1934
1935 //
1936 // Charged Iso Rings
1937 //
1938 if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1939
1940 // if( pf->HasGsfTrk() ) {
1941 // if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1942 // } else if( pf->HasTrackerTrk() ){
1943 // if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1944 // }
1945
1946 // Veto any PFmuon, or PFEle
1947 if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1948
1949 // Footprint Veto
1950 if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
1951
1952 if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
1953 << "\ttype: " << pf->PFType()
1954 << "\ttrk: " << pf->TrackerTrk() << endl;
1955
1956 if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
1957 if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
1958 if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1959 if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1960 if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
1961
1962 }
1963
1964 //
1965 // Gamma Iso Rings
1966 //
1967 else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1968
1969 if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
1970
1971 if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1972 << dr << endl;
1973
1974 if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
1975 if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
1976 if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1977 if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1978 if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
1979 }
1980
1981 //
1982 // Other Neutral Iso Rings
1983 //
1984 else {
1985 if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
1986 << dr << endl;
1987 if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
1988 if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
1989 if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1990 if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1991 if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
1992 }
1993
1994 }
1995
1996 }
1997
1998 fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1999 fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
2000 fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
2001 fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
2002 fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
2003
2004 if(ctrl.debug) {
2005 cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1 << endl;
2006 cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2 << endl;
2007 cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3 << endl;
2008 cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4 << endl;
2009 cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5 << endl;
2010 }
2011
2012
2013 // rho=0;
2014 // double rho = 0;
2015 // if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
2016 // rho = fPUEnergyDensity->At(0)->Rho();
2017 // if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
2018 // rho = fPUEnergyDensity->At(0)->RhoLowEta();
2019
2020 // WARNING!!!!
2021 // hardcode for sync ...
2022 EffectiveAreaVersion = eleT.kEleEAData2011;
2023 // WARNING!!!!
2024
2025 if( ctrl.debug) {
2026 cout << "RHO: " << rho << endl;
2027 cout << "eta: " << ele->SCluster()->Eta() << endl;
2028 cout << "target: " << EffectiveAreaVersion << endl;
2029 cout << "effA 0-1: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
2030 ele->SCluster()->Eta(),
2031 EffectiveAreaVersion)
2032 << endl;
2033 cout << "effA 1-2: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
2034 ele->SCluster()->Eta(),
2035 EffectiveAreaVersion)
2036 << endl;
2037 cout << "effA 2-3: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
2038 ele->SCluster()->Eta(),
2039 EffectiveAreaVersion)
2040 << endl;
2041 cout << "effA 3-4: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
2042 ele->SCluster()->Eta(),
2043 EffectiveAreaVersion)
2044 << endl;
2045 }
2046
2047 fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
2048 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
2049 ele->SCluster()->Eta(),
2050 EffectiveAreaVersion))/ele->Pt()
2051 ,2.5)
2052 ,0.0);
2053 fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
2054 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
2055 ele->SCluster()->Eta(),
2056 EffectiveAreaVersion))/ele->Pt()
2057 ,2.5)
2058 ,0.0);
2059 fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
2060 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
2061 ele->SCluster()->Eta()
2062 ,EffectiveAreaVersion))/ele->Pt()
2063 ,2.5)
2064 ,0.0);
2065 fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
2066 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
2067 ele->SCluster()->Eta(),
2068 EffectiveAreaVersion))/ele->Pt()
2069 ,2.5)
2070 ,0.0);
2071 fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
2072 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
2073 ele->SCluster()->Eta(),
2074 EffectiveAreaVersion))/ele->Pt()
2075 ,2.5)
2076 ,0.0);
2077
2078
2079 if( ctrl.debug) {
2080 cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
2081 cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
2082 cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
2083 cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
2084 cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
2085 }
2086
2087 fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
2088 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
2089 ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2090 , 2.5)
2091 , 0.0);
2092 fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
2093 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
2094 ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2095 , 2.5)
2096 , 0.0);
2097 fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
2098 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
2099 ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2100 , 2.5)
2101 , 0.0);
2102 fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
2103 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
2104 ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
2105 , 2.5)
2106 , 0.0);
2107 fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
2108 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
2109 ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
2110 , 2.5)
2111 , 0.0);
2112
2113 if( ctrl.debug) {
2114 cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
2115 cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
2116 cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
2117 cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
2118 cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
2119 }
2120
2121 double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
2122 ele->SCluster()->Eta(),
2123 fChargedIso_DR0p0To0p1,
2124 fChargedIso_DR0p1To0p2,
2125 fChargedIso_DR0p2To0p3,
2126 fChargedIso_DR0p3To0p4,
2127 fChargedIso_DR0p4To0p5,
2128 fGammaIso_DR0p0To0p1,
2129 fGammaIso_DR0p1To0p2,
2130 fGammaIso_DR0p2To0p3,
2131 fGammaIso_DR0p3To0p4,
2132 fGammaIso_DR0p4To0p5,
2133 fNeutralHadronIso_DR0p0To0p1,
2134 fNeutralHadronIso_DR0p1To0p2,
2135 fNeutralHadronIso_DR0p2To0p3,
2136 fNeutralHadronIso_DR0p3To0p4,
2137 fNeutralHadronIso_DR0p4To0p5,
2138 ctrl.debug);
2139
2140 SelectionStatus status;
2141 status.isoMVA = mvaval;
2142 bool pass = false;
2143
2144 Int_t subdet = 0;
2145 if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
2146 else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
2147 else subdet = 2;
2148
2149 Int_t ptBin = 0;
2150 if (ele->Pt() >= 10.0) ptBin = 1;
2151
2152 Int_t MVABin = -1;
2153 if (subdet == 0 && ptBin == 0) MVABin = 0;
2154 if (subdet == 1 && ptBin == 0) MVABin = 1;
2155 if (subdet == 2 && ptBin == 0) MVABin = 2;
2156 if (subdet == 0 && ptBin == 1) MVABin = 3;
2157 if (subdet == 1 && ptBin == 1) MVABin = 4;
2158 if (subdet == 2 && ptBin == 1) MVABin = 5;
2159
2160 pass = false;
2161 if( MVABin == 0 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN0 ) pass = true;
2162 if( MVABin == 1 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN1 ) pass = true;
2163 if( MVABin == 2 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN2 ) pass = true;
2164 if( MVABin == 3 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN3 ) pass = true;
2165 if( MVABin == 4 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN4 ) pass = true;
2166 if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN5 ) pass = true;
2167 if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
2168
2169 // pass = false;
2170 // if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
2171 // if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
2172 // if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
2173 // if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
2174 // if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
2175 // if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
2176 // if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
2177
2178 if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2179 return status;
2180
2181 }
2182
2183
2184 //--------------------------------------------------------------------------------------------------
2185 void initElectronIsoMVA() {
2186 //--------------------------------------------------------------------------------------------------
2187 eleIsoMVA = new mithep::ElectronIDMVA();
2188 vector<string> weightFiles;
2189 weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_BarrelPt5To10.weights.xml");
2190 weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_EndcapPt5To10.weights.xml");
2191 weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_BarrelPt10ToInf.weights.xml");
2192 weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_EndcapPt10ToInf.weights.xml");
2193 eleIsoMVA->Initialize( "ElectronIsoMVA",
2194 mithep::ElectronIDMVA::kIsoRingsV0,
2195 kTRUE, weightFiles);
2196 }
2197
2198
2199
2200
2201 //--------------------------------------------------------------------------------------------------
2202 float electronPFIso04(ControlFlags &ctrl,
2203 const mithep::Electron * ele,
2204 const mithep::Vertex * vtx,
2205 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2206 const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2207 mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2208 vector<const mithep::PFCandidate*> photonsToVeto)
2209 //--------------------------------------------------------------------------------------------------
2210 {
2211
2212 //
2213 // final iso
2214 //
2215 Double_t fChargedIso = 0.0;
2216 Double_t fGammaIso = 0.0;
2217 Double_t fNeutralHadronIso = 0.0;
2218
2219
2220 //
2221 //Loop over PF Candidates
2222 //
2223 for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2224
2225 const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2226
2227 //
2228 // veto FSR recovered photons
2229 //
2230 bool vetoPhoton = false;
2231 for( int p=0; p<photonsToVeto.size(); p++ ) {
2232 if( pf == photonsToVeto[p] ) {
2233 vetoPhoton = true;
2234 break;
2235 }
2236 } if( vetoPhoton ) continue;
2237
2238 Double_t deta = (ele->Eta() - pf->Eta());
2239 Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
2240 Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
2241
2242 if (dr > 0.4) continue;
2243 if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
2244
2245 if(ctrl.debug) {
2246 cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
2247 if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx)
2248 << "\ttrk: " << pf->HasTrackerTrk()
2249 << "\tgsf: " << pf->HasGsfTrk();
2250
2251 cout << endl;
2252 }
2253
2254
2255 //
2256 // sync : I don't think theyre doing this ...
2257 //
2258 // if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
2259 // (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
2260 // if( ctrl.debug ) cout << "\tskipping, matches to the electron ..." << endl;
2261 // continue;
2262 // }
2263
2264
2265 //
2266 // Lepton Footprint Removal
2267 //
2268 Bool_t IsLeptonFootprint = kFALSE;
2269 if (dr < 1.0) {
2270
2271
2272 //
2273 // Charged Iso
2274 //
2275 if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
2276
2277 // Veto any PFmuon, or PFEle
2278 if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) {
2279 if( ctrl.debug ) cout << "\t skipping, pf is and ele or mu .." <<endl;
2280 continue;
2281 }
2282
2283 // Footprint Veto
2284 if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
2285
2286 if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
2287 << "\ttype: " << pf->PFType()
2288 << "\ttrk: " << pf->TrackerTrk() << endl;
2289
2290 fChargedIso += pf->Pt();
2291 }
2292
2293 //
2294 // Gamma Iso
2295 //
2296 else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2297
2298 if (fabs(ele->SCluster()->Eta()) > 1.479) {
2299 if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
2300 }
2301
2302 assert(ele->HasSuperCluster());
2303 if(ele->GsfTrk()->NExpectedHitsInner()>0 && pf->MvaGamma() > 0.99 && pf->HasSCluster() && ele->SCluster() == pf->SCluster()) continue;
2304
2305
2306 if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2307 << dr << endl;
2308 // KH, add to sync
2309 // if( pf->Pt() > 0.5 )
2310 fGammaIso += pf->Pt();
2311 }
2312
2313 //
2314 // Neutral Iso
2315 //
2316 else {
2317 if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2318 << dr << endl;
2319 // KH, add to sync
2320 // if( pf->Pt() > 0.5 )
2321 fNeutralHadronIso += pf->Pt();
2322 }
2323
2324 }
2325
2326 }
2327
2328
2329 double rho=0;
2330 if( (EffectiveAreaVersion == mithep::ElectronTools::kEleEAFall11MC) ||
2331 (EffectiveAreaVersion == mithep::ElectronTools::kEleEAData2011) ) {
2332 if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25()) ||
2333 isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25())))
2334 rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25();
2335 // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2336 EffectiveAreaVersion = mithep::ElectronTools::kEleEAData2011;
2337 // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2338 } else {
2339 if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJets()) ||
2340 isinf(fPUEnergyDensity->At(0)->RhoKt6PFJets())))
2341 rho = fPUEnergyDensity->At(0)->RhoKt6PFJets();
2342 // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2343 EffectiveAreaVersion = mithep::ElectronTools::kEleEAData2012;
2344 // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2345 }
2346 if(ctrl.debug) cout << "rho: " << rho << endl;
2347
2348 double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2349 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2350 ele->Eta(),EffectiveAreaVersion)));
2351
2352
2353 gChargedIso = fChargedIso;
2354 gGammaIso = fGammaIso;
2355 gNeutralIso = fNeutralHadronIso;
2356
2357 if( ctrl.debug ) {
2358 cout << "PFiso: " << pfIso
2359 << "\tfChargedIso: " << fChargedIso
2360 << "\tfGammaIso: " << fGammaIso
2361 << "\tfNeutralHadronIso: " << fNeutralHadronIso
2362 << endl;
2363 }
2364
2365 return pfIso;
2366 }
2367
2368
2369
2370 //--------------------------------------------------------------------------------------------------
2371 // hacked version
2372 float electronPFIso04(ControlFlags &ctrl,
2373 const mithep::Electron * ele,
2374 const mithep::Vertex * vtx,
2375 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2376 float rho,
2377 mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2378 vector<const mithep::Muon*> muonsToVeto,
2379 vector<const mithep::Electron*> electronsToVeto)
2380 //--------------------------------------------------------------------------------------------------
2381 {
2382
2383 if( ctrl.debug ) {
2384 cout << "electronIsoMVASelection :: muons to veto " << endl;
2385 for( int i=0; i<muonsToVeto.size(); i++ ) {
2386 const mithep::Muon * vmu = muonsToVeto[i];
2387 cout << "\tpt: " << vmu->Pt()
2388 << "\teta: " << vmu->Eta()
2389 << "\tphi: " << vmu->Phi()
2390 << endl;
2391 }
2392 cout << "electronIsoMVASelection :: electrons to veto " << endl;
2393 for( int i=0; i<electronsToVeto.size(); i++ ) {
2394 const mithep::Electron * vel = electronsToVeto[i];
2395 cout << "\tpt: " << vel->Pt()
2396 << "\teta: " << vel->Eta()
2397 << "\tphi: " << vel->Phi()
2398 << "\ttrk: " << vel->TrackerTrk()
2399 << endl;
2400 }
2401 }
2402
2403
2404 //
2405 // final iso
2406 //
2407 Double_t fChargedIso = 0.0;
2408 Double_t fGammaIso = 0.0;
2409 Double_t fNeutralHadronIso = 0.0;
2410
2411
2412 //
2413 //Loop over PF Candidates
2414 //
2415 for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2416
2417
2418 const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2419 Double_t deta = (ele->Eta() - pf->Eta());
2420 Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
2421 Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
2422
2423 if (dr > 0.4) continue;
2424 if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
2425
2426 if(ctrl.debug) {
2427 cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
2428 if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx)
2429 << "\ttrk: " << pf->HasTrackerTrk()
2430 << "\tgsf: " << pf->HasGsfTrk();
2431
2432 cout << endl;
2433 }
2434
2435
2436 //
2437 // sync : I don't think theyre doing this ...
2438 //
2439 // if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
2440 // (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
2441 // if( ctrl.debug ) cout << "\tskipping, matches to the electron ..." << endl;
2442 // continue;
2443 // }
2444
2445
2446 //
2447 // Lepton Footprint Removal
2448 //
2449 Bool_t IsLeptonFootprint = kFALSE;
2450 if (dr < 1.0) {
2451
2452 //
2453 // Check for electrons
2454 //
2455 for (Int_t q=0; q < electronsToVeto.size(); ++q) {
2456 const mithep::Electron *tmpele = electronsToVeto[q];
2457 /*
2458 // 4l electron
2459 if( pf->HasTrackerTrk() ) {
2460 if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
2461 if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
2462 IsLeptonFootprint = kTRUE;
2463 }
2464 }
2465 if( pf->HasGsfTrk() ) {
2466 if( pf->GsfTrk() == tmpele->GsfTrk() ) {
2467 if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
2468 IsLeptonFootprint = kTRUE;
2469 }
2470 }
2471 */
2472 // PF charged
2473 if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
2474 && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
2475 if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
2476 IsLeptonFootprint = kTRUE;
2477 }
2478 // PF gamma
2479 if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
2480 && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
2481 if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
2482 IsLeptonFootprint = kTRUE;
2483 }
2484 } // loop over electrons
2485
2486 /* KH - comment for sync
2487 //
2488 // Check for muons
2489 //
2490 for (Int_t q=0; q < muonsToVeto.size(); ++q) {
2491 const mithep::Muon *tmpmu = muonsToVeto[q];
2492 // 4l muon
2493 if( pf->HasTrackerTrk() ) {
2494 if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
2495 if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
2496 IsLeptonFootprint = kTRUE;
2497 }
2498 }
2499 // PF charged
2500 if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
2501 if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
2502 IsLeptonFootprint = kTRUE;
2503 }
2504 } // loop over muons
2505 */
2506
2507 if (IsLeptonFootprint)
2508 continue;
2509
2510 //
2511 // Charged Iso
2512 //
2513 if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
2514
2515 // if( pf->HasTrackerTrk() )
2516 // if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2517 // if( pf->HasGsfTrk() )
2518 // if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2519
2520 // Veto any PFmuon, or PFEle
2521 if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) {
2522 if( ctrl.debug ) cout << "\t skipping, pf is and ele or mu .." <<endl;
2523 continue;
2524 }
2525
2526 // Footprint Veto
2527 if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
2528
2529 if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
2530 << "\ttype: " << pf->PFType()
2531 << "\ttrk: " << pf->TrackerTrk() << endl;
2532
2533 fChargedIso += pf->Pt();
2534 }
2535
2536 //
2537 // Gamma Iso
2538 //
2539 else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2540
2541 if (fabs(ele->SCluster()->Eta()) > 1.479) {
2542 if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
2543 }
2544 if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2545 << dr << endl;
2546 // KH, add to sync
2547 // if( pf->Pt() > 0.5 )
2548 fGammaIso += pf->Pt();
2549 }
2550
2551 //
2552 // Neutral Iso
2553 //
2554 else {
2555 if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2556 << dr << endl;
2557 // KH, add to sync
2558 // if( pf->Pt() > 0.5 )
2559 fNeutralHadronIso += pf->Pt();
2560 }
2561
2562 }
2563
2564 }
2565
2566 // double rho = 0;
2567 // if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
2568 // rho = fPUEnergyDensity->At(0)->Rho();
2569
2570 // WARNING!!!!
2571 // hardcode for sync ...
2572 EffectiveAreaVersion = eleT.kEleEAData2011;
2573 // WARNING!!!!
2574
2575
2576 double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2577 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2578 ele->Eta(),EffectiveAreaVersion)));
2579
2580
2581 gChargedIso = fChargedIso;
2582 gGammaIso = fGammaIso;
2583 gNeutralIso = fNeutralHadronIso;
2584 return pfIso;
2585 }
2586
2587
2588 //--------------------------------------------------------------------------------------------------
2589 SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2590 const mithep::Electron * ele,
2591 const mithep::Vertex * vtx,
2592 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2593 const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2594 mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2595 vector<const mithep::PFCandidate*> photonsToVeto)
2596 //--------------------------------------------------------------------------------------------------
2597 {
2598
2599 SelectionStatus status;
2600
2601 double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, fPUEnergyDensity,
2602 EffectiveAreaVersion, photonsToVeto);
2603 // cout << "--------------> setting electron isoPF04 to " << pfIso << endl;
2604 status.isoPF04 = pfIso;
2605 status.chisoPF04 = gChargedIso;
2606 status.gaisoPF04 = gGammaIso;
2607 status.neisoPF04 = gNeutralIso;
2608
2609 bool pass = false;
2610 if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
2611
2612 if( pass ) {
2613 status.orStatus(SelectionStatus::LOOSEISO);
2614 status.orStatus(SelectionStatus::TIGHTISO);
2615 }
2616 if(ctrl.debug) {
2617 cout << "el relpfIso: " << pfIso/ele->Pt() << endl;
2618 cout << "returning status : " << hex << status.getStatus() << dec << endl;
2619 }
2620 return status;
2621
2622 }
2623
2624
2625 //--------------------------------------------------------------------------------------------------
2626 // hacked version
2627 SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2628 const mithep::Electron * ele,
2629 const mithep::Vertex * vtx,
2630 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2631 float rho,
2632 mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2633 vector<const mithep::Muon*> muonsToVeto,
2634 vector<const mithep::Electron*> electronsToVeto)
2635 //--------------------------------------------------------------------------------------------------
2636 {
2637
2638 SelectionStatus status;
2639
2640 double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, rho,
2641 EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
2642 status.isoPF04 = pfIso;
2643 status.chisoPF04 = gChargedIso;
2644 status.gaisoPF04 = gGammaIso;
2645 status.neisoPF04 = gNeutralIso;
2646 bool pass = false;
2647 if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
2648
2649 if( pass ) {
2650 status.orStatus(SelectionStatus::LOOSEISO);
2651 status.orStatus(SelectionStatus::TIGHTISO);
2652 }
2653 if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2654 return status;
2655
2656 }
2657
2658
2659
2660 //--------------------------------------------------------------------------------------------------
2661 double dbetaCorrectedIsoDr03(ControlFlags & ctrl,
2662 const mithep::PFCandidate * photon,
2663 const mithep::Muon * lepton,
2664 const mithep::Array<mithep::PFCandidate> * fPFCandidates)
2665 //--------------------------------------------------------------------------------------------------
2666 {
2667
2668 //
2669 // final iso
2670 //
2671 Double_t fChargedIso = 0.0;
2672 Double_t fGammaIso = 0.0;
2673 Double_t fNeutralHadronIso = 0.0;
2674 Double_t fpfPU = 0.0;
2675
2676 //
2677 // Loop over PF Candidates
2678 //
2679 for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2680
2681 const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2682
2683 Double_t deta = (photon->Eta() - pf->Eta());
2684 Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2685 Double_t dr = mithep::MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2686 if (dr > 0.3) continue;
2687
2688 if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2689 if( pf->Pt() >= 0.2 && dr > 0.01 )
2690 fpfPU += pf->Pt();
2691 continue;
2692 }
2693
2694 //
2695 // skip this photon
2696 //
2697 if( abs(pf->PFType()) == mithep::PFCandidate::eGamma &&
2698 pf->Et() == photon->Et() ) continue;
2699
2700
2701 //
2702 // Charged Iso
2703 //
2704 if (pf->Charge() != 0 ) {
2705 if( dr > 0.01 && pf->Pt() >= 0.2 &&
2706 !(pf->TrackerTrk() == lepton->TrackerTrk()) )
2707 fChargedIso += pf->Pt();
2708 }
2709
2710 //
2711 // Gamma Iso
2712 //
2713 else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
2714 if( pf->Pt() > 0.5 && dr > 0.01)
2715 fGammaIso += pf->Pt();
2716 }
2717
2718 //
2719 // Other Neutrals
2720 //
2721 else {
2722 if( pf->Pt() > 0.5 && dr > 0.01)
2723 fNeutralHadronIso += pf->Pt();
2724 }
2725
2726 }
2727
2728 if( ctrl.debug ) {
2729 cout << "photon dbetaIso :: " << endl;
2730 cout << "\tfChargedIso: " << fChargedIso
2731 << "\tfGammaIso: " << fGammaIso
2732 << "\tfNeutralHadronIso: " << fNeutralHadronIso
2733 << "\tfpfPU: " << fpfPU
2734 << endl;
2735 }
2736 double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso - 0.5*fpfPU;
2737 return pfIso/photon->Pt();
2738 }
2739
2740
2741 //--------------------------------------------------------------------------------------------------
2742 double dbetaCorrectedIsoDr03(ControlFlags & ctrl,
2743 const mithep::PFCandidate * photon,
2744 const mithep::Electron * lepton,
2745 const mithep::Array<mithep::PFCandidate> * fPFCandidates)
2746 //--------------------------------------------------------------------------------------------------
2747 {
2748
2749 //
2750 // final iso
2751 //
2752 Double_t fChargedIso = 0.0;
2753 Double_t fGammaIso = 0.0;
2754 Double_t fNeutralHadronIso = 0.0;
2755 Double_t fpfPU = 0.0;
2756
2757 //
2758 // Loop over PF Candidates
2759 //
2760 for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2761
2762 const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2763
2764 Double_t deta = (photon->Eta() - pf->Eta());
2765 Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2766 Double_t dr = mithep::MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2767 if (dr > 0.3) continue;
2768
2769 if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2770 if( pf->Pt() >= 0.2 && dr > 0.01 )
2771 fpfPU += pf->Pt();
2772 continue;
2773 }
2774
2775 //
2776 // skip this photon
2777 //
2778 if( abs(pf->PFType()) == mithep::PFCandidate::eGamma &&
2779 pf->Et() == photon->Et() ) continue;
2780
2781
2782 //
2783 // Charged Iso
2784 //
2785 if (pf->Charge() != 0 ) {
2786 if( dr > 0.01 && pf->Pt() >= 0.2 &&
2787 !(pf->TrackerTrk() == lepton->TrackerTrk()) )
2788 fChargedIso += pf->Pt();
2789 }
2790
2791 //
2792 // Gamma Iso
2793 //
2794 else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
2795 if( pf->Pt() > 0.5 && dr > 0.01)
2796 fGammaIso += pf->Pt();
2797 }
2798
2799 //
2800 // Other Neutrals
2801 //
2802 else {
2803 if( pf->Pt() > 0.5 && dr > 0.01)
2804 fNeutralHadronIso += pf->Pt();
2805 }
2806
2807 }
2808
2809 if( ctrl.debug ) {
2810 cout << "photon dbetaIso :: " << endl;
2811 cout << "\tfChargedIso: " << fChargedIso
2812 << "\tfGammaIso: " << fGammaIso
2813 << "\tfNeutralHadronIso: " << fNeutralHadronIso
2814 << "\tfpfPU: " << fpfPU
2815 << endl;
2816 }
2817 double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso - 0.5*fpfPU;
2818 return pfIso/photon->Pt();
2819 }
2820
2821
2822
2823
2824
2825 //--------------------------------------------------------------------------------------------------
2826 double nonCorrectedIsoDr03(ControlFlags & ctrl,
2827 const mithep::PFCandidate * photon,
2828 const mithep::Muon * lepton,
2829 const mithep::Array<mithep::PFCandidate> * fPFCandidates)
2830 //--------------------------------------------------------------------------------------------------
2831 {
2832
2833 //
2834 // final iso
2835 //
2836 Double_t fChargedIso = 0.0;
2837 Double_t fGammaIso = 0.0;
2838 Double_t fNeutralHadronIso = 0.0;
2839 Double_t fpfPU = 0.0;
2840
2841 //
2842 // Loop over PF Candidates
2843 //
2844 for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2845
2846 const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2847
2848 Double_t deta = (photon->Eta() - pf->Eta());
2849 Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2850 Double_t dr = mithep::MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2851 if (dr > 0.3) continue;
2852
2853 if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2854 if( pf->Pt() >= 0.2 && dr > 0.01 )
2855 fpfPU += pf->Pt();
2856 continue;
2857 }
2858
2859 //
2860 // skip this photon
2861 //
2862 if( abs(pf->PFType()) == mithep::PFCandidate::eGamma &&
2863 pf->Et() == photon->Et() ) continue;
2864
2865
2866 //
2867 // Charged Iso
2868 //
2869 if (pf->Charge() != 0 ) {
2870 if( dr > 0.01 && pf->Pt() >= 0.2 &&
2871 !(pf->TrackerTrk() == lepton->TrackerTrk()) )
2872 fChargedIso += pf->Pt();
2873 }
2874
2875 //
2876 // Gamma Iso
2877 //
2878 else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
2879 if( pf->Pt() > 0.5 && dr > 0.01)
2880 fGammaIso += pf->Pt();
2881 }
2882
2883 //
2884 // Other Neutrals
2885 //
2886 else {
2887 if( pf->Pt() > 0.5 && dr > 0.01)
2888 fNeutralHadronIso += pf->Pt();
2889 }
2890
2891 }
2892
2893 if( ctrl.debug ) {
2894 cout << "photon dbetaIso :: " << endl;
2895 cout << "\tfChargedIso: " << fChargedIso
2896 << "\tfGammaIso: " << fGammaIso
2897 << "\tfNeutralHadronIso: " << fNeutralHadronIso
2898 << "\tfpfPU: " << fpfPU
2899 << endl;
2900 }
2901
2902 double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso + fpfPU;
2903 return pfIso/photon->Pt();
2904 }
2905
2906
2907
2908 //--------------------------------------------------------------------------------------------------
2909 double nonCorrectedIsoDr03(ControlFlags & ctrl,
2910 const mithep::PFCandidate * photon,
2911 const mithep::Electron * lepton,
2912 const mithep::Array<mithep::PFCandidate> * fPFCandidates)
2913 //--------------------------------------------------------------------------------------------------
2914 {
2915
2916 //
2917 // final iso
2918 //
2919 Double_t fChargedIso = 0.0;
2920 Double_t fGammaIso = 0.0;
2921 Double_t fNeutralHadronIso = 0.0;
2922 Double_t fpfPU = 0.0;
2923
2924 //
2925 // Loop over PF Candidates
2926 //
2927 for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2928
2929 const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2930
2931 Double_t deta = (photon->Eta() - pf->Eta());
2932 Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2933 Double_t dr = mithep::MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2934 if (dr > 0.3) continue;
2935
2936 if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2937 if( pf->Pt() >= 0.2 && dr > 0.01 )
2938 fpfPU += pf->Pt();
2939 continue;
2940 }
2941
2942 //
2943 // skip this photon
2944 //
2945 if( abs(pf->PFType()) == mithep::PFCandidate::eGamma &&
2946 pf->Et() == photon->Et() ) continue;
2947
2948
2949 //
2950 // Charged Iso
2951 //
2952 if (pf->Charge() != 0 ) {
2953 if( dr > 0.01 && pf->Pt() >= 0.2 &&
2954 !(pf->TrackerTrk() == lepton->TrackerTrk()) )
2955 fChargedIso += pf->Pt();
2956 }
2957
2958 //
2959 // Gamma Iso
2960 //
2961 else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
2962 if( pf->Pt() > 0.5 && dr > 0.01)
2963 fGammaIso += pf->Pt();
2964 }
2965
2966 //
2967 // Other Neutrals
2968 //
2969 else {
2970 if( pf->Pt() > 0.5 && dr > 0.01)
2971 fNeutralHadronIso += pf->Pt();
2972 }
2973
2974 }
2975
2976 if( ctrl.debug ) {
2977 cout << "photon dbetaIso :: " << endl;
2978 cout << "\tfChargedIso: " << fChargedIso
2979 << "\tfGammaIso: " << fGammaIso
2980 << "\tfNeutralHadronIso: " << fNeutralHadronIso
2981 << "\tfpfPU: " << fpfPU
2982 << endl;
2983 }
2984 double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso + fpfPU;
2985 return pfIso/photon->Pt();
2986 }
2987
2988
2989