ViewVC Help
View File | Revision Log | Show Annotations | Root Listing
root/cvsroot/UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc
Revision: 1.31
Committed: Tue Jun 12 01:23:03 2012 UTC (12 years, 11 months ago) by khahn
Content type: text/plain
Branch: MAIN
CVS Tags: synced_FSR_2
Changes since 1.30: +2 -2 lines
Log Message: 
don't update muon kinematics after FSR recovery

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