ViewVC Help
View File | Revision Log | Show Annotations | Root Listing
root/cvsroot/UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc
Revision: 1.26
Committed: Mon May 28 12:37:10 2012 UTC (12 years, 11 months ago) by anlevin
Content type: text/plain
Branch: MAIN
Changes since 1.25: +1 -1 lines
Log Message: 
added macros for frs and tp efficiencies

File Contents

# User Rev Content
1 khahn 1.1 #include <math.h>
2    
3     #include "IsolationSelection.h"
4     #include "IsolationSelectionDefs.h"
5    
6 khahn 1.4 #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 khahn 1.15 // global hack to sync
20     double gChargedIso;
21     double gGammaIso;
22     double gNeutralIso;
23    
24 khahn 1.19 extern vector<bool> PFnoPUflag;
25 khahn 1.15
26 khahn 1.4 //--------------------------------------------------------------------------------------------------
27     Float_t computePFMuonIso(const mithep::Muon *muon,
28 anlevin 1.22 const mithep::Vertex * vtx,
29 khahn 1.4 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 anlevin 1.22 Double_t zLepton = (muon->BestTrk()) ? muon->BestTrk()->DzCorrected(*vtx) : 0.0;
38 khahn 1.4
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 anlevin 1.22 Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(*vtx) - zLepton) : 0;
50 khahn 1.4 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 anlevin 1.22 const mithep::Vertex * fVertex,
64 khahn 1.4 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 anlevin 1.22 Double_t zLepton = (electron->BestTrk()) ? electron->BestTrk()->DzCorrected(*fVertex) : 0.0;
73 khahn 1.4
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 anlevin 1.22 Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(*fVertex) - zLepton) : 0;
82 khahn 1.4 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 khahn 1.2
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 khahn 1.13 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 khahn 1.2 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 khahn 1.4 //--------------------------------------------------------------------------------------------------
183     SelectionStatus muonIsoSelection(ControlFlags &ctrl,
184     const mithep::Muon * mu,
185 anlevin 1.22 const mithep::Vertex * vtx,
186 khahn 1.4 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 khahn 1.1 bool failiso = false;
192 khahn 1.4 if( isEB && mu->Pt() > 20 && reliso > PFISO_MU_LOOSE_EB_HIGHPT ) {
193 khahn 1.1 failiso = true;
194     }
195 khahn 1.4 if( isEB && mu->Pt() < 20 && reliso > PFISO_MU_LOOSE_EB_LOWPT ) {
196 khahn 1.1 failiso = true;
197     }
198 khahn 1.4 if( !(isEB) && mu->Pt() > 20 && reliso > PFISO_MU_LOOSE_EE_HIGHPT ) {
199 khahn 1.1 failiso = true;
200     }
201 khahn 1.4 if( !(isEB) && mu->Pt() < 20 && reliso > PFISO_MU_LOOSE_EE_LOWPT ) {
202 khahn 1.1 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 khahn 1.4 //--------------------------------------------------------------------------------------------------
213     SelectionStatus electronIsoSelection(ControlFlags &ctrl,
214     const mithep::Electron * ele,
215 anlevin 1.22 const mithep::Vertex *fVertex,
216 khahn 1.4 const mithep::Array<mithep::PFCandidate> * fPFCandidates)
217     //--------------------------------------------------------------------------------------------------
218     {
219 khahn 1.1
220 khahn 1.4 bool failiso=false;
221 khahn 1.1
222 khahn 1.4 float reliso = computePFEleIso(ele,fVertex,fPFCandidates,0.4)/ele->Pt();
223 khahn 1.1
224 khahn 1.4 if( ele->IsEB() && ele->Pt() > 20 && reliso > PFISO_ELE_LOOSE_EB_HIGHPT ) {
225 khahn 1.1 failiso = true;
226     }
227 khahn 1.4 if( ele->IsEB() && ele->Pt() < 20 && reliso > PFISO_ELE_LOOSE_EB_LOWPT ) {
228 khahn 1.1 failiso = true;
229     }
230 khahn 1.4 if( !(ele->IsEB()) && ele->Pt() > 20 && reliso > PFISO_ELE_LOOSE_EE_HIGHPT ) {
231 khahn 1.1 failiso = true;
232     }
233 khahn 1.4 if( !(ele->IsEB()) && ele->Pt() < 20 && reliso > PFISO_ELE_LOOSE_EE_LOWPT ) {
234 khahn 1.1 failiso = true;
235     }
236    
237     SelectionStatus status;
238     if( !failiso ) {
239 khahn 1.4 status.orStatus(SelectionStatus::LOOSEISO);
240     status.orStatus(SelectionStatus::TIGHTISO);
241 khahn 1.1 }
242     if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
243     return status;
244    
245     }
246 anlevin 1.3
247 khahn 1.4
248 anlevin 1.3 bool noIso(ControlFlags &, vector<SimpleLepton> &, float rho) {
249    
250     return true;
251     }
252 khahn 1.4
253 khahn 1.21
254 khahn 1.4 //--------------------------------------------------------------------------------------------------
255     SelectionStatus muonIsoMVASelection(ControlFlags &ctrl,
256     const mithep::Muon * mu,
257 anlevin 1.22 const mithep::Vertex * vtx,
258 khahn 1.4 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 khahn 1.7 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 khahn 1.4 bool failiso=false;
285    
286     //
287     // tmp iso rings
288     //
289 khahn 1.7 Double_t tmpChargedIso_DR0p0To0p1 = 0;
290     Double_t tmpChargedIso_DR0p1To0p2 = 0;
291     Double_t tmpChargedIso_DR0p2To0p3 = 0;
292 khahn 1.4 Double_t tmpChargedIso_DR0p3To0p4 = 0;
293     Double_t tmpChargedIso_DR0p4To0p5 = 0;
294 khahn 1.7 Double_t tmpChargedIso_DR0p5To0p7 = 0;
295 khahn 1.4
296 khahn 1.7 Double_t tmpGammaIso_DR0p0To0p1 = 0;
297     Double_t tmpGammaIso_DR0p1To0p2 = 0;
298     Double_t tmpGammaIso_DR0p2To0p3 = 0;
299 khahn 1.4 Double_t tmpGammaIso_DR0p3To0p4 = 0;
300     Double_t tmpGammaIso_DR0p4To0p5 = 0;
301 khahn 1.7 Double_t tmpGammaIso_DR0p5To0p7 = 0;
302 khahn 1.4
303 khahn 1.7 Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
304     Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
305     Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
306 khahn 1.4 Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
307     Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
308 khahn 1.7 Double_t tmpNeutralHadronIso_DR0p5To0p7 = 0;
309    
310 khahn 1.4
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 khahn 1.7 Double_t fChargedIso_DR0p5To0p7;
321 khahn 1.4
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 khahn 1.7 Double_t fGammaIso_DR0p5To0p7;
328 khahn 1.4
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 khahn 1.7 Double_t fNeutralHadronIso_DR0p5To0p7;
335 khahn 1.4
336    
337     //
338     //Loop over PF Candidates
339     //
340     for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
341 khahn 1.21
342     if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
343    
344 khahn 1.4 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 khahn 1.21 if (dr > 1.0) continue;
350 khahn 1.4
351 khahn 1.7 if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
352 khahn 1.4
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 khahn 1.7 // 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 khahn 1.4 // PF charged
374 khahn 1.19 if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479
375 khahn 1.4 && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
376     IsLeptonFootprint = kTRUE;
377     // PF gamma
378 khahn 1.19 if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
379 khahn 1.4 && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
380     IsLeptonFootprint = kTRUE;
381     } // loop over electrons
382    
383 khahn 1.21 /* KH - commented for sync
384 khahn 1.4 //
385     // Check for muons
386     //
387     for (Int_t q=0; q < muonsToVeto.size(); ++q) {
388     const mithep::Muon *tmpmu = muonsToVeto[q];
389 khahn 1.7 // 4l muon
390     if( pf->HasTrackerTrk() ) {
391     if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
392     IsLeptonFootprint = kTRUE;
393     }
394 khahn 1.4 // 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 khahn 1.14 */
399 khahn 1.4
400     if (IsLeptonFootprint)
401     continue;
402    
403     //
404     // Charged Iso Rings
405     //
406 khahn 1.7 if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
407    
408 khahn 1.19 if( dr < 0.01 ) continue; // only for muon iso mva?
409 khahn 1.7 if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
410 khahn 1.4
411 khahn 1.19 // 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 khahn 1.21 // 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 khahn 1.4
424     // Footprint Veto
425 khahn 1.7 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 khahn 1.4 }
432    
433     //
434     // Gamma Iso Rings
435     //
436 khahn 1.7 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 khahn 1.4 }
444    
445     //
446     // Other Neutral Iso Rings
447     //
448     else {
449 khahn 1.7 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 khahn 1.4 }
456    
457     }
458    
459     }
460    
461 khahn 1.19 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 khahn 1.4
467 khahn 1.7
468 khahn 1.4 double rho = 0;
469 khahn 1.21 if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
470     rho = fPUEnergyDensity->At(0)->Rho();
471     // if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
472     // rho = fPUEnergyDensity->At(0)->RhoLowEta();
473 khahn 1.4
474 khahn 1.18 // WARNING!!!!
475     // hardcode for sync ...
476     EffectiveAreaVersion = muT.kMuEAData2011;
477     // WARNING!!!!
478    
479 khahn 1.4
480 khahn 1.19 fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
481 khahn 1.4 -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p0To0p1,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
482     ,2.5)
483     ,0.0);
484 khahn 1.19 fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
485 khahn 1.4 -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p1To0p2,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
486     ,2.5)
487     ,0.0);
488 khahn 1.19 fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
489 khahn 1.4 -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p2To0p3,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
490     ,2.5)
491     ,0.0);
492 khahn 1.19 fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
493 khahn 1.4 -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p3To0p4,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
494     ,2.5)
495     ,0.0);
496 khahn 1.19 fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
497 khahn 1.4 -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p4To0p5,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
498     ,2.5)
499     ,0.0);
500    
501    
502 khahn 1.7
503 khahn 1.19 fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
504 khahn 1.4 -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p0To0p1,
505     mu->Eta(),EffectiveAreaVersion))/mu->Pt()
506     , 2.5)
507     , 0.0);
508 khahn 1.19 fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
509 khahn 1.4 -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p1To0p2,
510     mu->Eta(),EffectiveAreaVersion))/mu->Pt()
511     , 2.5)
512     , 0.0);
513 khahn 1.19 fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
514 khahn 1.4 -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p2To0p3,
515     mu->Eta(),EffectiveAreaVersion))/mu->Pt()
516     , 2.5)
517     , 0.0);
518 khahn 1.19 fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
519 khahn 1.4 -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p3To0p4,
520     mu->Eta(), EffectiveAreaVersion))/mu->Pt()
521     , 2.5)
522     , 0.0);
523 khahn 1.19 fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
524 khahn 1.4 -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p4To0p5,
525     mu->Eta(), EffectiveAreaVersion))/mu->Pt()
526     , 2.5)
527     , 0.0);
528    
529 khahn 1.7
530 khahn 1.4 double mvaval = muIsoMVA->MVAValue_IsoRings( mu->Pt(),
531 khahn 1.18 mu->Eta(),
532     mu->IsGlobalMuon(),
533     mu->IsTrackerMuon(),
534     fChargedIso_DR0p0To0p1,
535     fChargedIso_DR0p1To0p2,
536     fChargedIso_DR0p2To0p3,
537     fChargedIso_DR0p3To0p4,
538     fChargedIso_DR0p4To0p5,
539     fGammaIso_DR0p0To0p1,
540     fGammaIso_DR0p1To0p2,
541     fGammaIso_DR0p2To0p3,
542     fGammaIso_DR0p3To0p4,
543     fGammaIso_DR0p4To0p5,
544     fNeutralHadronIso_DR0p0To0p1,
545     fNeutralHadronIso_DR0p1To0p2,
546     fNeutralHadronIso_DR0p2To0p3,
547     fNeutralHadronIso_DR0p3To0p4,
548     fNeutralHadronIso_DR0p4To0p5,
549     ctrl.debug);
550 khahn 1.4
551     SelectionStatus status;
552 khahn 1.10 bool pass;
553 khahn 1.4
554 khahn 1.10 pass = false;
555 khahn 1.4 if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
556 khahn 1.21 && fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN0) pass = true;
557 khahn 1.4 else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
558 khahn 1.21 && fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN1) pass = true;
559 khahn 1.4 else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
560 khahn 1.21 && fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN2) pass = true;
561 khahn 1.4 else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
562 khahn 1.21 && fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN3) pass = true;
563     else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN4) pass = true;
564     else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN5) pass = true;
565 khahn 1.10 if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
566 khahn 1.4
567 khahn 1.21 /*
568 khahn 1.10 pass = false;
569     if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
570     && fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN0) pass = true;
571     else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
572     && fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN1) pass = true;
573     else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
574     && fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN2) pass = true;
575     else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
576     && fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN3) pass = true;
577     else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN4) pass = true;
578     else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN5) pass = true;
579     if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
580 khahn 1.21 */
581 khahn 1.4
582 khahn 1.10 // pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
583 khahn 1.7
584 khahn 1.21 status.isoMVA = mvaval;
585    
586     if(ctrl.debug) {
587     cout << "returning status : " << hex << status.getStatus() << dec << endl;
588     cout << "MVAVAL : " << status.isoMVA << endl;
589     }
590 khahn 1.4 return status;
591    
592     }
593    
594    
595 khahn 1.10 //--------------------------------------------------------------------------------------------------
596 khahn 1.19 SelectionStatus muonIsoMVASelection(ControlFlags &ctrl,
597     const mithep::Muon * mu,
598 anlevin 1.22 const mithep::Vertex * vtx,
599 khahn 1.19 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
600     float rho,
601     //const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
602     mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
603     vector<const mithep::Muon*> muonsToVeto,
604     vector<const mithep::Electron*> electronsToVeto)
605 khahn 1.10 //--------------------------------------------------------------------------------------------------
606 khahn 1.19 // hacked version
607 khahn 1.10 {
608 khahn 1.19
609 khahn 1.10 if( ctrl.debug ) {
610     cout << "muonIsoMVASelection :: muons to veto " << endl;
611     for( int i=0; i<muonsToVeto.size(); i++ ) {
612     const mithep::Muon * vmu = muonsToVeto[i];
613     cout << "\tpt: " << vmu->Pt()
614     << "\teta: " << vmu->Eta()
615     << "\tphi: " << vmu->Phi()
616     << endl;
617     }
618     cout << "muonIsoMVASelection :: electrson to veto " << endl;
619     for( int i=0; i<electronsToVeto.size(); i++ ) {
620     const mithep::Electron * vel = electronsToVeto[i];
621     cout << "\tpt: " << vel->Pt()
622     << "\teta: " << vel->Eta()
623     << "\tphi: " << vel->Phi()
624     << endl;
625     }
626     }
627 khahn 1.19 bool failiso=false;
628    
629     //
630     // tmp iso rings
631     //
632     Double_t tmpChargedIso_DR0p0To0p1 = 0;
633     Double_t tmpChargedIso_DR0p1To0p2 = 0;
634     Double_t tmpChargedIso_DR0p2To0p3 = 0;
635     Double_t tmpChargedIso_DR0p3To0p4 = 0;
636     Double_t tmpChargedIso_DR0p4To0p5 = 0;
637     Double_t tmpChargedIso_DR0p5To0p7 = 0;
638    
639     Double_t tmpGammaIso_DR0p0To0p1 = 0;
640     Double_t tmpGammaIso_DR0p1To0p2 = 0;
641     Double_t tmpGammaIso_DR0p2To0p3 = 0;
642     Double_t tmpGammaIso_DR0p3To0p4 = 0;
643     Double_t tmpGammaIso_DR0p4To0p5 = 0;
644     Double_t tmpGammaIso_DR0p5To0p7 = 0;
645    
646     Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
647     Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
648     Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
649     Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
650     Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
651     Double_t tmpNeutralHadronIso_DR0p5To0p7 = 0;
652    
653    
654 khahn 1.10
655     //
656 khahn 1.19 // final rings for the MVA
657 khahn 1.10 //
658 khahn 1.19 Double_t fChargedIso_DR0p0To0p1;
659     Double_t fChargedIso_DR0p1To0p2;
660     Double_t fChargedIso_DR0p2To0p3;
661     Double_t fChargedIso_DR0p3To0p4;
662     Double_t fChargedIso_DR0p4To0p5;
663     Double_t fChargedIso_DR0p5To0p7;
664    
665     Double_t fGammaIso_DR0p0To0p1;
666     Double_t fGammaIso_DR0p1To0p2;
667     Double_t fGammaIso_DR0p2To0p3;
668     Double_t fGammaIso_DR0p3To0p4;
669     Double_t fGammaIso_DR0p4To0p5;
670     Double_t fGammaIso_DR0p5To0p7;
671    
672     Double_t fNeutralHadronIso_DR0p0To0p1;
673     Double_t fNeutralHadronIso_DR0p1To0p2;
674     Double_t fNeutralHadronIso_DR0p2To0p3;
675     Double_t fNeutralHadronIso_DR0p3To0p4;
676     Double_t fNeutralHadronIso_DR0p4To0p5;
677     Double_t fNeutralHadronIso_DR0p5To0p7;
678    
679 khahn 1.10
680     //
681     //Loop over PF Candidates
682     //
683     for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
684 khahn 1.19
685     if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
686    
687 khahn 1.10 const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
688    
689     Double_t deta = (mu->Eta() - pf->Eta());
690     Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
691     Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
692 khahn 1.19 if (dr > 1.0) continue;
693 khahn 1.10
694     if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
695    
696     //
697     // Lepton Footprint Removal
698     //
699     Bool_t IsLeptonFootprint = kFALSE;
700     if (dr < 1.0) {
701    
702     //
703     // Check for electrons
704     //
705     for (Int_t q=0; q < electronsToVeto.size(); ++q) {
706     const mithep::Electron *tmpele = electronsToVeto[q];
707     // 4l electron
708     if( pf->HasTrackerTrk() ) {
709     if( pf->TrackerTrk() == tmpele->TrackerTrk() )
710     IsLeptonFootprint = kTRUE;
711     }
712     if( pf->HasGsfTrk() ) {
713     if( pf->GsfTrk() == tmpele->GsfTrk() )
714     IsLeptonFootprint = kTRUE;
715     }
716     // PF charged
717 khahn 1.19 if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479
718 khahn 1.10 && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
719     IsLeptonFootprint = kTRUE;
720     // PF gamma
721 khahn 1.19 if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
722 khahn 1.10 && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
723     IsLeptonFootprint = kTRUE;
724     } // loop over electrons
725 khahn 1.19
726     /* KH - commented for sync
727 khahn 1.15 //
728     // Check for muons
729     //
730     for (Int_t q=0; q < muonsToVeto.size(); ++q) {
731     const mithep::Muon *tmpmu = muonsToVeto[q];
732     // 4l muon
733     if( pf->HasTrackerTrk() ) {
734     if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
735     IsLeptonFootprint = kTRUE;
736     }
737     // PF charged
738     if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
739     IsLeptonFootprint = kTRUE;
740     } // loop over muons
741     */
742    
743     if (IsLeptonFootprint)
744     continue;
745    
746     //
747 khahn 1.19 // Charged Iso Rings
748 khahn 1.15 //
749 khahn 1.19 if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
750 khahn 1.15
751 khahn 1.19 if( dr < 0.01 ) continue; // only for muon iso mva?
752 khahn 1.15 if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
753    
754 khahn 1.19 // if( pf->HasTrackerTrk() ) {
755     // if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
756     // if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
757     // << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
758     // << dr << endl;
759     // }
760     // if( pf->HasGsfTrk() ) {
761     // if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
762     // if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
763     // << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
764     // << dr << endl;
765     // }
766 khahn 1.15
767 khahn 1.19 // Footprint Veto
768     if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
769     if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
770     if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
771     if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
772     if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
773     if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
774 khahn 1.15 }
775    
776     //
777 khahn 1.19 // Gamma Iso Rings
778 khahn 1.15 //
779     else if (abs(pf->PFType()) == PFCandidate::eGamma) {
780 khahn 1.19 if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
781     if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
782     if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
783     if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
784     if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
785     if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
786 khahn 1.15 }
787    
788     //
789 khahn 1.19 // Other Neutral Iso Rings
790 khahn 1.15 //
791     else {
792 khahn 1.19 if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
793     if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
794     if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
795     if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
796     if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
797     if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
798 khahn 1.15 }
799 khahn 1.19
800 khahn 1.15 }
801 khahn 1.19
802 khahn 1.15 }
803 khahn 1.19
804     fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5);
805     fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5);
806     fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5);
807     fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5);
808     fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5);
809    
810    
811     // double rho = 0;
812     // if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
813     // rho = fPUEnergyDensity->At(0)->Rho();
814     // if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
815     // rho = fPUEnergyDensity->At(0)->RhoLowEta();
816 khahn 1.15
817     // WARNING!!!!
818     // hardcode for sync ...
819     EffectiveAreaVersion = muT.kMuEAData2011;
820     // WARNING!!!!
821    
822 khahn 1.19
823     fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
824     -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p0To0p1,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
825     ,2.5)
826     ,0.0);
827     fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
828     -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p1To0p2,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
829     ,2.5)
830     ,0.0);
831     fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
832     -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p2To0p3,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
833     ,2.5)
834     ,0.0);
835     fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
836     -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p3To0p4,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
837     ,2.5)
838     ,0.0);
839     fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
840     -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p4To0p5,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
841     ,2.5)
842     ,0.0);
843 khahn 1.15
844    
845    
846 khahn 1.19 fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
847     -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p0To0p1,
848     mu->Eta(),EffectiveAreaVersion))/mu->Pt()
849     , 2.5)
850     , 0.0);
851     fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
852     -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p1To0p2,
853     mu->Eta(),EffectiveAreaVersion))/mu->Pt()
854     , 2.5)
855     , 0.0);
856     fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
857     -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p2To0p3,
858     mu->Eta(),EffectiveAreaVersion))/mu->Pt()
859     , 2.5)
860     , 0.0);
861     fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
862     -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p3To0p4,
863     mu->Eta(), EffectiveAreaVersion))/mu->Pt()
864     , 2.5)
865     , 0.0);
866     fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
867     -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p4To0p5,
868     mu->Eta(), EffectiveAreaVersion))/mu->Pt()
869     , 2.5)
870     , 0.0);
871 khahn 1.15
872    
873 khahn 1.19 double mvaval = muIsoMVA->MVAValue_IsoRings( mu->Pt(),
874     mu->Eta(),
875     mu->IsGlobalMuon(),
876     mu->IsTrackerMuon(),
877     fChargedIso_DR0p0To0p1,
878     fChargedIso_DR0p1To0p2,
879     fChargedIso_DR0p2To0p3,
880     fChargedIso_DR0p3To0p4,
881     fChargedIso_DR0p4To0p5,
882     fGammaIso_DR0p0To0p1,
883     fGammaIso_DR0p1To0p2,
884     fGammaIso_DR0p2To0p3,
885     fGammaIso_DR0p3To0p4,
886     fGammaIso_DR0p4To0p5,
887     fNeutralHadronIso_DR0p0To0p1,
888     fNeutralHadronIso_DR0p1To0p2,
889     fNeutralHadronIso_DR0p2To0p3,
890     fNeutralHadronIso_DR0p3To0p4,
891     fNeutralHadronIso_DR0p4To0p5,
892     ctrl.debug);
893    
894     SelectionStatus status;
895     bool pass;
896    
897     pass = false;
898     if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
899     && fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN0) pass = true;
900     else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
901     && fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN1) pass = true;
902     else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
903     && fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN2) pass = true;
904     else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
905     && fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN3) pass = true;
906     else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN4) pass = true;
907     else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN5) pass = true;
908     if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
909    
910     /*
911     pass = false;
912     if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
913     && fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN0) pass = true;
914     else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
915     && fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN1) pass = true;
916     else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
917     && fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN2) pass = true;
918     else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
919     && fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN3) pass = true;
920     else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN4) pass = true;
921     else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN5) pass = true;
922     if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
923     */
924    
925     // pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
926    
927     status.isoMVA = mvaval;
928    
929     if(ctrl.debug) {
930     cout << "returning status : " << hex << status.getStatus() << dec << endl;
931     cout << "MVAVAL : " << status.isoMVA << endl;
932     }
933     return status;
934    
935     }
936    
937    
938     //--------------------------------------------------------------------------------------------------
939     void initMuonIsoMVA() {
940     //--------------------------------------------------------------------------------------------------
941     muIsoMVA = new mithep::MuonIDMVA();
942     vector<string> weightFiles;
943     weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_barrel_lowpt.weights.xml");
944     weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_barrel_highpt.weights.xml");
945     weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_endcap_lowpt.weights.xml");
946     weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_endcap_highpt.weights.xml");
947     weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_tracker.weights.xml");
948     weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_global.weights.xml");
949     muIsoMVA->Initialize( "MuonIsoMVA",
950     mithep::MuonIDMVA::kIsoRingsV0,
951     kTRUE, weightFiles);
952     }
953    
954    
955 khahn 1.21
956    
957 khahn 1.19 //--------------------------------------------------------------------------------------------------
958     double muonPFIso04(ControlFlags &ctrl,
959     const mithep::Muon * mu,
960 anlevin 1.22 const mithep::Vertex * vtx,
961 khahn 1.19 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
962     const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
963     mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
964     vector<const mithep::Muon*> muonsToVeto,
965     vector<const mithep::Electron*> electronsToVeto)
966     //--------------------------------------------------------------------------------------------------
967     {
968 khahn 1.21
969     extern double gChargedIso;
970     extern double gGammaIso;
971     extern double gNeutralIso;
972 khahn 1.15
973     if( ctrl.debug ) {
974     cout << "muonIsoMVASelection :: muons to veto " << endl;
975     for( int i=0; i<muonsToVeto.size(); i++ ) {
976     const mithep::Muon * vmu = muonsToVeto[i];
977     cout << "\tpt: " << vmu->Pt()
978     << "\teta: " << vmu->Eta()
979     << "\tphi: " << vmu->Phi()
980     << endl;
981     }
982     cout << "muonIsoMVASelection :: electrson to veto " << endl;
983     for( int i=0; i<electronsToVeto.size(); i++ ) {
984     const mithep::Electron * vel = electronsToVeto[i];
985     cout << "\tpt: " << vel->Pt()
986     << "\teta: " << vel->Eta()
987     << "\tphi: " << vel->Phi()
988     << endl;
989     }
990     }
991    
992     //
993     // final iso
994     //
995     Double_t fChargedIso = 0.0;
996     Double_t fGammaIso = 0.0;
997     Double_t fNeutralHadronIso = 0.0;
998    
999     //
1000     //Loop over PF Candidates
1001     //
1002     for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1003 khahn 1.21
1004     if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1005 khahn 1.15 const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1006    
1007     Double_t deta = (mu->Eta() - pf->Eta());
1008     Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
1009     Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
1010     if (dr > 0.4) continue;
1011    
1012     if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
1013    
1014     //
1015     // Lepton Footprint Removal
1016     //
1017     Bool_t IsLeptonFootprint = kFALSE;
1018     if (dr < 1.0) {
1019    
1020     //
1021     // Check for electrons
1022     //
1023     for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1024     const mithep::Electron *tmpele = electronsToVeto[q];
1025     // 4l electron
1026     if( pf->HasTrackerTrk() ) {
1027     if( pf->TrackerTrk() == tmpele->TrackerTrk() )
1028     IsLeptonFootprint = kTRUE;
1029     }
1030     if( pf->HasGsfTrk() ) {
1031     if( pf->GsfTrk() == tmpele->GsfTrk() )
1032     IsLeptonFootprint = kTRUE;
1033     }
1034     // PF charged
1035     if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1036 khahn 1.23 && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
1037     if( ctrl.debug) cout << "\tcharged trk, dR ("
1038     << mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta())
1039     << " matches 4L ele ..." << endl;
1040 khahn 1.15 IsLeptonFootprint = kTRUE;
1041 khahn 1.23 }
1042 khahn 1.15 // PF gamma
1043     if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1044     && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
1045     IsLeptonFootprint = kTRUE;
1046     } // loop over electrons
1047    
1048 khahn 1.21 /* KH - comment for sync
1049 khahn 1.10 //
1050     // Check for muons
1051     //
1052     for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1053     const mithep::Muon *tmpmu = muonsToVeto[q];
1054     // 4l muon
1055     if( pf->HasTrackerTrk() ) {
1056     if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
1057     IsLeptonFootprint = kTRUE;
1058     }
1059     // PF charged
1060     if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
1061     IsLeptonFootprint = kTRUE;
1062     } // loop over muons
1063 khahn 1.14 */
1064 khahn 1.10
1065     if (IsLeptonFootprint)
1066     continue;
1067    
1068     //
1069 khahn 1.14 // Charged Iso
1070 khahn 1.10 //
1071 khahn 1.21 if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1072 khahn 1.10
1073 khahn 1.19 //if( dr < 0.01 ) continue; // only for muon iso mva?
1074 khahn 1.10 if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1075    
1076 khahn 1.21
1077     // if( pf->HasTrackerTrk() ) {
1078     // if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1079     // if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1080     // << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1081     // << dr << endl;
1082     // }
1083     // if( pf->HasGsfTrk() ) {
1084     // if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1085     // if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1086     // << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1087     // << dr << endl;
1088     // }
1089 khahn 1.10
1090    
1091 khahn 1.11 fChargedIso += pf->Pt();
1092 khahn 1.10 }
1093    
1094     //
1095     // Gamma Iso
1096     //
1097     else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1098 khahn 1.19 // KH, add to sync
1099     if( pf->Pt() > 0.5 )
1100     fGammaIso += pf->Pt();
1101     }
1102    
1103     //
1104     // Other Neutrals
1105     //
1106     else {
1107     // KH, add to sync
1108     if( pf->Pt() > 0.5 )
1109     fNeutralHadronIso += pf->Pt();
1110     }
1111    
1112     }
1113    
1114     }
1115 khahn 1.21
1116     double rho=0;
1117 anlevin 1.24 if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral()) || isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral())))
1118     rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral();
1119 khahn 1.19
1120 khahn 1.21
1121 khahn 1.19 double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1122     -rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
1123     mu->Eta(),EffectiveAreaVersion)));
1124     gChargedIso = fChargedIso;
1125 khahn 1.21 gGammaIso = fGammaIso;
1126     gNeutralIso = fNeutralHadronIso;
1127    
1128 khahn 1.19 return pfIso;
1129     }
1130    
1131    
1132 khahn 1.21
1133    
1134 khahn 1.19 //--------------------------------------------------------------------------------------------------
1135     // hacked version
1136     double muonPFIso04(ControlFlags &ctrl,
1137     const mithep::Muon * mu,
1138 anlevin 1.22 const mithep::Vertex * vtx,
1139 khahn 1.19 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1140     float rho,
1141     mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1142     vector<const mithep::Muon*> muonsToVeto,
1143     vector<const mithep::Electron*> electronsToVeto)
1144     //--------------------------------------------------------------------------------------------------
1145     {
1146    
1147     extern double gChargedIso;
1148     extern double gGammaIso;
1149     extern double gNeutralIso;
1150    
1151     if( ctrl.debug ) {
1152     cout << "muonIsoMVASelection :: muons to veto " << endl;
1153     for( int i=0; i<muonsToVeto.size(); i++ ) {
1154     const mithep::Muon * vmu = muonsToVeto[i];
1155     cout << "\tpt: " << vmu->Pt()
1156     << "\teta: " << vmu->Eta()
1157     << "\tphi: " << vmu->Phi()
1158     << endl;
1159     }
1160     cout << "muonIsoMVASelection :: electrson to veto " << endl;
1161     for( int i=0; i<electronsToVeto.size(); i++ ) {
1162     const mithep::Electron * vel = electronsToVeto[i];
1163     cout << "\tpt: " << vel->Pt()
1164     << "\teta: " << vel->Eta()
1165     << "\tphi: " << vel->Phi()
1166     << endl;
1167     }
1168     }
1169    
1170     //
1171     // final iso
1172     //
1173     Double_t fChargedIso = 0.0;
1174     Double_t fGammaIso = 0.0;
1175     Double_t fNeutralHadronIso = 0.0;
1176    
1177     //
1178     //Loop over PF Candidates
1179     //
1180     for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1181    
1182     if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1183     const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1184    
1185     Double_t deta = (mu->Eta() - pf->Eta());
1186     Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
1187     Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
1188     if (dr > 0.4) continue;
1189    
1190     if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
1191    
1192     //
1193     // Lepton Footprint Removal
1194     //
1195     Bool_t IsLeptonFootprint = kFALSE;
1196     if (dr < 1.0) {
1197    
1198     //
1199     // Check for electrons
1200     //
1201     for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1202     const mithep::Electron *tmpele = electronsToVeto[q];
1203     // 4l electron
1204     if( pf->HasTrackerTrk() ) {
1205     if( pf->TrackerTrk() == tmpele->TrackerTrk() )
1206     IsLeptonFootprint = kTRUE;
1207     }
1208     if( pf->HasGsfTrk() ) {
1209     if( pf->GsfTrk() == tmpele->GsfTrk() )
1210     IsLeptonFootprint = kTRUE;
1211     }
1212     // PF charged
1213     if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1214     && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
1215     IsLeptonFootprint = kTRUE;
1216     // PF gamma
1217     if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1218     && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
1219     IsLeptonFootprint = kTRUE;
1220     } // loop over electrons
1221    
1222     /* KH - comment for sync
1223     //
1224     // Check for muons
1225     //
1226     for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1227     const mithep::Muon *tmpmu = muonsToVeto[q];
1228     // 4l muon
1229     if( pf->HasTrackerTrk() ) {
1230     if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
1231     IsLeptonFootprint = kTRUE;
1232     }
1233     // PF charged
1234     if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
1235     IsLeptonFootprint = kTRUE;
1236     } // loop over muons
1237     */
1238    
1239     if (IsLeptonFootprint)
1240     continue;
1241    
1242     //
1243     // Charged Iso
1244     //
1245     if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1246    
1247     //if( dr < 0.01 ) continue; // only for muon iso mva?
1248     if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1249    
1250    
1251     // if( pf->HasTrackerTrk() ) {
1252     // if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1253     // if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1254     // << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1255     // << dr << endl;
1256     // }
1257     // if( pf->HasGsfTrk() ) {
1258     // if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1259     // if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1260     // << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1261     // << dr << endl;
1262     // }
1263    
1264    
1265     fChargedIso += pf->Pt();
1266     }
1267    
1268     //
1269     // Gamma Iso
1270     //
1271     else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1272     // KH, add to sync
1273 khahn 1.18 if( pf->Pt() > 0.5 )
1274 khahn 1.11 fGammaIso += pf->Pt();
1275 khahn 1.10 }
1276 khahn 1.19
1277     //
1278     // Other Neutrals
1279     //
1280     else {
1281     // KH, add to sync
1282     if( pf->Pt() > 0.5 )
1283     fNeutralHadronIso += pf->Pt();
1284     }
1285    
1286     }
1287    
1288     }
1289    
1290     // double rho = 0;
1291     // if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1292     // rho = fPUEnergyDensity->At(0)->Rho();
1293    
1294     // WARNING!!!!
1295     // hardcode for sync ...
1296     EffectiveAreaVersion = muT.kMuEAData2011;
1297     // WARNING!!!!
1298    
1299    
1300     double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1301     -rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
1302     mu->Eta(),EffectiveAreaVersion)));
1303     gChargedIso = fChargedIso;
1304     gGammaIso = fGammaIso;
1305     gNeutralIso = fNeutralHadronIso;
1306    
1307     return pfIso;
1308     }
1309    
1310    
1311     //--------------------------------------------------------------------------------------------------
1312     SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1313     const mithep::Muon * mu,
1314 anlevin 1.22 const mithep::Vertex * vtx,
1315 khahn 1.19 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1316     const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1317     mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1318     vector<const mithep::Muon*> muonsToVeto,
1319     vector<const mithep::Electron*> electronsToVeto)
1320     //--------------------------------------------------------------------------------------------------
1321     {
1322    
1323     SelectionStatus status;
1324    
1325     double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, fPUEnergyDensity,
1326     EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1327     // cout << "--------------> setting muon isoPF04 to" << pfIso << endl;
1328     status.isoPF04 = pfIso;
1329     status.chisoPF04 = gChargedIso;
1330     status.gaisoPF04 = gGammaIso;
1331     status.neisoPF04 = gNeutralIso;
1332    
1333     bool pass = false;
1334     if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1335    
1336     if( pass ) {
1337     status.orStatus(SelectionStatus::LOOSEISO);
1338     status.orStatus(SelectionStatus::TIGHTISO);
1339     }
1340     if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1341     return status;
1342    
1343     }
1344    
1345    
1346     //--------------------------------------------------------------------------------------------------
1347     // hacked version
1348     SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1349     const mithep::Muon * mu,
1350 anlevin 1.22 const mithep::Vertex * vtx,
1351 khahn 1.19 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1352     float rho,
1353     mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1354     vector<const mithep::Muon*> muonsToVeto,
1355     vector<const mithep::Electron*> electronsToVeto)
1356     //--------------------------------------------------------------------------------------------------
1357     {
1358    
1359     SelectionStatus status;
1360    
1361     double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, rho,
1362     EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1363    
1364     status.isoPF04 = pfIso;
1365     status.chisoPF04 = gChargedIso;
1366     status.gaisoPF04 = gGammaIso;
1367     status.neisoPF04 = gNeutralIso;
1368    
1369     bool pass = false;
1370     if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1371    
1372     if( pass ) {
1373     status.orStatus(SelectionStatus::LOOSEISO);
1374     status.orStatus(SelectionStatus::TIGHTISO);
1375     }
1376     if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1377     return status;
1378    
1379     }
1380    
1381    
1382    
1383 khahn 1.21
1384 khahn 1.19 //--------------------------------------------------------------------------------------------------
1385     SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1386     const mithep::Electron * ele,
1387 anlevin 1.22 const mithep::Vertex * vtx,
1388 khahn 1.19 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1389     const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1390     mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1391     vector<const mithep::Muon*> muonsToVeto,
1392     vector<const mithep::Electron*> electronsToVeto)
1393     //--------------------------------------------------------------------------------------------------
1394     {
1395    
1396     if( ctrl.debug ) {
1397     cout << "electronIsoMVASelection :: muons to veto " << endl;
1398     for( int i=0; i<muonsToVeto.size(); i++ ) {
1399     const mithep::Muon * vmu = muonsToVeto[i];
1400     cout << "\tpt: " << vmu->Pt()
1401     << "\teta: " << vmu->Eta()
1402     << "\tphi: " << vmu->Phi()
1403     << endl;
1404     }
1405     cout << "electronIsoMVASelection :: electrson to veto " << endl;
1406     for( int i=0; i<electronsToVeto.size(); i++ ) {
1407     const mithep::Electron * vel = electronsToVeto[i];
1408     cout << "\tpt: " << vel->Pt()
1409     << "\teta: " << vel->Eta()
1410     << "\tphi: " << vel->Phi()
1411     << "\ttrk: " << vel->TrackerTrk()
1412     << endl;
1413     }
1414     }
1415    
1416     bool failiso=false;
1417    
1418     //
1419     // tmp iso rings
1420     //
1421     Double_t tmpChargedIso_DR0p0To0p1 = 0;
1422     Double_t tmpChargedIso_DR0p1To0p2 = 0;
1423     Double_t tmpChargedIso_DR0p2To0p3 = 0;
1424     Double_t tmpChargedIso_DR0p3To0p4 = 0;
1425     Double_t tmpChargedIso_DR0p4To0p5 = 0;
1426    
1427     Double_t tmpGammaIso_DR0p0To0p1 = 0;
1428     Double_t tmpGammaIso_DR0p1To0p2 = 0;
1429     Double_t tmpGammaIso_DR0p2To0p3 = 0;
1430     Double_t tmpGammaIso_DR0p3To0p4 = 0;
1431     Double_t tmpGammaIso_DR0p4To0p5 = 0;
1432 khahn 1.21
1433 khahn 1.19
1434     Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
1435     Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
1436     Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
1437     Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
1438     Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
1439    
1440    
1441    
1442     //
1443     // final rings for the MVA
1444     //
1445     Double_t fChargedIso_DR0p0To0p1;
1446     Double_t fChargedIso_DR0p1To0p2;
1447     Double_t fChargedIso_DR0p2To0p3;
1448     Double_t fChargedIso_DR0p3To0p4;
1449     Double_t fChargedIso_DR0p4To0p5;
1450    
1451     Double_t fGammaIso_DR0p0To0p1;
1452     Double_t fGammaIso_DR0p1To0p2;
1453     Double_t fGammaIso_DR0p2To0p3;
1454     Double_t fGammaIso_DR0p3To0p4;
1455     Double_t fGammaIso_DR0p4To0p5;
1456    
1457     Double_t fNeutralHadronIso_DR0p0To0p1;
1458     Double_t fNeutralHadronIso_DR0p1To0p2;
1459     Double_t fNeutralHadronIso_DR0p2To0p3;
1460     Double_t fNeutralHadronIso_DR0p3To0p4;
1461     Double_t fNeutralHadronIso_DR0p4To0p5;
1462    
1463    
1464     //
1465     //Loop over PF Candidates
1466     //
1467     for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1468    
1469     if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1470    
1471     const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1472     Double_t deta = (ele->Eta() - pf->Eta());
1473     Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1474     Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1475 khahn 1.21 if (dr > 1.0) continue;
1476    
1477 khahn 1.19 if(ctrl.debug) {
1478     cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1479 anlevin 1.22 if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx);
1480 khahn 1.19 cout << endl;
1481     }
1482    
1483    
1484     if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
1485     (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1486    
1487    
1488     //
1489     // Lepton Footprint Removal
1490     //
1491     Bool_t IsLeptonFootprint = kFALSE;
1492     if (dr < 1.0) {
1493    
1494 khahn 1.21
1495 khahn 1.19 //
1496     // Check for electrons
1497     //
1498 khahn 1.21
1499 khahn 1.19 for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1500     const mithep::Electron *tmpele = electronsToVeto[q];
1501 khahn 1.21 double tmpdr = mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1502    
1503 khahn 1.19 // 4l electron
1504     if( pf->HasTrackerTrk() ) {
1505     if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
1506     if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1507     IsLeptonFootprint = kTRUE;
1508     }
1509     }
1510     if( pf->HasGsfTrk() ) {
1511     if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1512     if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1513     IsLeptonFootprint = kTRUE;
1514     }
1515     }
1516     // PF charged
1517 khahn 1.21 if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1518 khahn 1.19 if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1519     IsLeptonFootprint = kTRUE;
1520     }
1521     // PF gamma
1522     if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1523 khahn 1.21 && tmpdr < 0.08) {
1524 khahn 1.19 if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1525     IsLeptonFootprint = kTRUE;
1526     }
1527     } // loop over electrons
1528    
1529 khahn 1.21
1530 khahn 1.19 /* KH - comment for sync
1531     //
1532     // Check for muons
1533     //
1534     for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1535     const mithep::Muon *tmpmu = muonsToVeto[q];
1536     // 4l muon
1537     if( pf->HasTrackerTrk() ) {
1538     if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1539     if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1540     IsLeptonFootprint = kTRUE;
1541     }
1542     }
1543     // PF charged
1544     if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1545     if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1546     IsLeptonFootprint = kTRUE;
1547     }
1548     } // loop over muons
1549     */
1550    
1551     if (IsLeptonFootprint)
1552     continue;
1553    
1554     //
1555     // Charged Iso Rings
1556     //
1557     if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1558    
1559     // if( pf->HasGsfTrk() ) {
1560     // if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1561     // } else if( pf->HasTrackerTrk() ){
1562     // if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1563     // }
1564    
1565     // Veto any PFmuon, or PFEle
1566     if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1567    
1568     // Footprint Veto
1569     if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
1570    
1571     if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
1572     << "\ttype: " << pf->PFType()
1573     << "\ttrk: " << pf->TrackerTrk() << endl;
1574    
1575     if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
1576     if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
1577     if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1578     if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1579     if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
1580    
1581     }
1582    
1583     //
1584     // Gamma Iso Rings
1585     //
1586     else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1587    
1588 khahn 1.21 if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
1589 khahn 1.19
1590     if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1591     << dr << endl;
1592    
1593     if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
1594     if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
1595     if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1596     if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1597     if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
1598     }
1599    
1600     //
1601     // Other Neutral Iso Rings
1602     //
1603     else {
1604     if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
1605     << dr << endl;
1606     if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
1607     if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
1608     if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1609     if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1610     if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
1611     }
1612    
1613     }
1614    
1615     }
1616    
1617     fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1618     fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1619     fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1620     fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1621     fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1622    
1623 khahn 1.21 if(ctrl.debug) {
1624     cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1 << endl;
1625     cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2 << endl;
1626     cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3 << endl;
1627     cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4 << endl;
1628     cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5 << endl;
1629     }
1630    
1631    
1632 khahn 1.19 double rho = 0;
1633 khahn 1.21 if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1634     rho = fPUEnergyDensity->At(0)->Rho();
1635     // if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
1636     // rho = fPUEnergyDensity->At(0)->RhoLowEta();
1637    
1638 khahn 1.19 // WARNING!!!!
1639     // hardcode for sync ...
1640 khahn 1.21 EffectiveAreaVersion = eleT.kEleEAData2011;
1641 khahn 1.19 // WARNING!!!!
1642    
1643     if( ctrl.debug) {
1644     cout << "RHO: " << rho << endl;
1645     cout << "eta: " << ele->SCluster()->Eta() << endl;
1646     cout << "target: " << EffectiveAreaVersion << endl;
1647     cout << "effA 0-1: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1648     ele->SCluster()->Eta(),
1649     EffectiveAreaVersion)
1650     << endl;
1651     cout << "effA 1-2: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1652     ele->SCluster()->Eta(),
1653     EffectiveAreaVersion)
1654     << endl;
1655     cout << "effA 2-3: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1656     ele->SCluster()->Eta(),
1657     EffectiveAreaVersion)
1658     << endl;
1659     cout << "effA 3-4: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1660     ele->SCluster()->Eta(),
1661     EffectiveAreaVersion)
1662     << endl;
1663 khahn 1.10 }
1664    
1665 khahn 1.19 fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
1666     -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
1667     ele->SCluster()->Eta(),
1668     EffectiveAreaVersion))/ele->Pt()
1669     ,2.5)
1670     ,0.0);
1671     fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
1672     -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
1673     ele->SCluster()->Eta(),
1674     EffectiveAreaVersion))/ele->Pt()
1675     ,2.5)
1676     ,0.0);
1677     fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
1678     -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
1679     ele->SCluster()->Eta()
1680     ,EffectiveAreaVersion))/ele->Pt()
1681     ,2.5)
1682     ,0.0);
1683     fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
1684     -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
1685     ele->SCluster()->Eta(),
1686     EffectiveAreaVersion))/ele->Pt()
1687     ,2.5)
1688     ,0.0);
1689     fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
1690     -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
1691     ele->SCluster()->Eta(),
1692     EffectiveAreaVersion))/ele->Pt()
1693     ,2.5)
1694     ,0.0);
1695 khahn 1.11
1696    
1697 khahn 1.21 if( ctrl.debug) {
1698     cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
1699     cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
1700     cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
1701     cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
1702     cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
1703     }
1704    
1705 khahn 1.19 fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
1706     -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1707     ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1708     , 2.5)
1709     , 0.0);
1710     fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
1711     -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1712     ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1713     , 2.5)
1714     , 0.0);
1715     fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
1716     -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1717     ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1718     , 2.5)
1719     , 0.0);
1720     fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
1721     -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1722     ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1723     , 2.5)
1724     , 0.0);
1725     fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
1726     -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
1727     ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1728     , 2.5)
1729     , 0.0);
1730 khahn 1.10
1731 khahn 1.21 if( ctrl.debug) {
1732     cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
1733     cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
1734     cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
1735     cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
1736     cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
1737     }
1738    
1739 khahn 1.19 double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
1740     ele->SCluster()->Eta(),
1741     fChargedIso_DR0p0To0p1,
1742     fChargedIso_DR0p1To0p2,
1743     fChargedIso_DR0p2To0p3,
1744     fChargedIso_DR0p3To0p4,
1745     fChargedIso_DR0p4To0p5,
1746     fGammaIso_DR0p0To0p1,
1747     fGammaIso_DR0p1To0p2,
1748     fGammaIso_DR0p2To0p3,
1749     fGammaIso_DR0p3To0p4,
1750     fGammaIso_DR0p4To0p5,
1751     fNeutralHadronIso_DR0p0To0p1,
1752     fNeutralHadronIso_DR0p1To0p2,
1753     fNeutralHadronIso_DR0p2To0p3,
1754     fNeutralHadronIso_DR0p3To0p4,
1755     fNeutralHadronIso_DR0p4To0p5,
1756     ctrl.debug);
1757 khahn 1.15
1758 khahn 1.10 SelectionStatus status;
1759 khahn 1.21 status.isoMVA = mvaval;
1760 khahn 1.19 bool pass = false;
1761 khahn 1.15
1762 khahn 1.19 Int_t subdet = 0;
1763     if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
1764     else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
1765     else subdet = 2;
1766 khahn 1.21
1767 khahn 1.19 Int_t ptBin = 0;
1768 khahn 1.21 if (ele->Pt() >= 10.0) ptBin = 1;
1769 khahn 1.19
1770     Int_t MVABin = -1;
1771     if (subdet == 0 && ptBin == 0) MVABin = 0;
1772     if (subdet == 1 && ptBin == 0) MVABin = 1;
1773     if (subdet == 2 && ptBin == 0) MVABin = 2;
1774     if (subdet == 0 && ptBin == 1) MVABin = 3;
1775     if (subdet == 1 && ptBin == 1) MVABin = 4;
1776     if (subdet == 2 && ptBin == 1) MVABin = 5;
1777 khahn 1.15
1778 khahn 1.19 pass = false;
1779 khahn 1.21 if( MVABin == 0 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN0 ) pass = true;
1780     if( MVABin == 1 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN1 ) pass = true;
1781     if( MVABin == 2 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN2 ) pass = true;
1782     if( MVABin == 3 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN3 ) pass = true;
1783     if( MVABin == 4 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN4 ) pass = true;
1784     if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN5 ) pass = true;
1785     // pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
1786 khahn 1.19 if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
1787 khahn 1.15
1788 khahn 1.19 // pass = false;
1789     // if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
1790     // if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
1791     // if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
1792     // if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
1793     // if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
1794     // if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
1795     // if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
1796 khahn 1.15
1797 khahn 1.10 if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1798     return status;
1799    
1800     }
1801    
1802    
1803 khahn 1.4 //--------------------------------------------------------------------------------------------------
1804     SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1805     const mithep::Electron * ele,
1806 anlevin 1.22 const mithep::Vertex * vtx,
1807 khahn 1.4 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1808 khahn 1.19 float rho,
1809     //const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1810 khahn 1.4 mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1811     vector<const mithep::Muon*> muonsToVeto,
1812     vector<const mithep::Electron*> electronsToVeto)
1813     //--------------------------------------------------------------------------------------------------
1814 khahn 1.19 // hacked version
1815 khahn 1.4 {
1816 khahn 1.19 if( ctrl.debug ) {
1817     cout << "================> hacked ele Iso MVA <======================" << endl;
1818     }
1819 khahn 1.4
1820 khahn 1.7 if( ctrl.debug ) {
1821     cout << "electronIsoMVASelection :: muons to veto " << endl;
1822     for( int i=0; i<muonsToVeto.size(); i++ ) {
1823     const mithep::Muon * vmu = muonsToVeto[i];
1824     cout << "\tpt: " << vmu->Pt()
1825     << "\teta: " << vmu->Eta()
1826     << "\tphi: " << vmu->Phi()
1827     << endl;
1828     }
1829     cout << "electronIsoMVASelection :: electrson to veto " << endl;
1830     for( int i=0; i<electronsToVeto.size(); i++ ) {
1831     const mithep::Electron * vel = electronsToVeto[i];
1832     cout << "\tpt: " << vel->Pt()
1833     << "\teta: " << vel->Eta()
1834     << "\tphi: " << vel->Phi()
1835     << "\ttrk: " << vel->TrackerTrk()
1836     << endl;
1837     }
1838     }
1839    
1840 khahn 1.4 bool failiso=false;
1841    
1842     //
1843     // tmp iso rings
1844     //
1845 khahn 1.7 Double_t tmpChargedIso_DR0p0To0p1 = 0;
1846     Double_t tmpChargedIso_DR0p1To0p2 = 0;
1847     Double_t tmpChargedIso_DR0p2To0p3 = 0;
1848 khahn 1.4 Double_t tmpChargedIso_DR0p3To0p4 = 0;
1849     Double_t tmpChargedIso_DR0p4To0p5 = 0;
1850    
1851 khahn 1.7 Double_t tmpGammaIso_DR0p0To0p1 = 0;
1852     Double_t tmpGammaIso_DR0p1To0p2 = 0;
1853     Double_t tmpGammaIso_DR0p2To0p3 = 0;
1854 khahn 1.4 Double_t tmpGammaIso_DR0p3To0p4 = 0;
1855     Double_t tmpGammaIso_DR0p4To0p5 = 0;
1856 khahn 1.19
1857 khahn 1.4
1858 khahn 1.7 Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
1859     Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
1860     Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
1861 khahn 1.4 Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
1862     Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
1863 khahn 1.7
1864 khahn 1.4
1865    
1866     //
1867     // final rings for the MVA
1868     //
1869     Double_t fChargedIso_DR0p0To0p1;
1870     Double_t fChargedIso_DR0p1To0p2;
1871     Double_t fChargedIso_DR0p2To0p3;
1872     Double_t fChargedIso_DR0p3To0p4;
1873     Double_t fChargedIso_DR0p4To0p5;
1874    
1875     Double_t fGammaIso_DR0p0To0p1;
1876     Double_t fGammaIso_DR0p1To0p2;
1877     Double_t fGammaIso_DR0p2To0p3;
1878     Double_t fGammaIso_DR0p3To0p4;
1879     Double_t fGammaIso_DR0p4To0p5;
1880    
1881     Double_t fNeutralHadronIso_DR0p0To0p1;
1882     Double_t fNeutralHadronIso_DR0p1To0p2;
1883     Double_t fNeutralHadronIso_DR0p2To0p3;
1884     Double_t fNeutralHadronIso_DR0p3To0p4;
1885     Double_t fNeutralHadronIso_DR0p4To0p5;
1886    
1887    
1888     //
1889     //Loop over PF Candidates
1890     //
1891     for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1892 khahn 1.19
1893     if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1894    
1895 khahn 1.4 const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1896     Double_t deta = (ele->Eta() - pf->Eta());
1897     Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1898     Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1899 khahn 1.19 if (dr > 1.0) continue;
1900    
1901 khahn 1.7 if(ctrl.debug) {
1902     cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1903 anlevin 1.22 if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx);
1904 khahn 1.7 cout << endl;
1905     }
1906    
1907 khahn 1.4
1908 khahn 1.7 if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
1909     (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1910    
1911 khahn 1.4
1912     //
1913     // Lepton Footprint Removal
1914     //
1915     Bool_t IsLeptonFootprint = kFALSE;
1916     if (dr < 1.0) {
1917    
1918 khahn 1.19
1919 khahn 1.4 //
1920     // Check for electrons
1921     //
1922 khahn 1.19
1923 khahn 1.4 for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1924     const mithep::Electron *tmpele = electronsToVeto[q];
1925 khahn 1.19 double tmpdr = mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1926    
1927 khahn 1.7 // 4l electron
1928     if( pf->HasTrackerTrk() ) {
1929     if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
1930     if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1931     IsLeptonFootprint = kTRUE;
1932     }
1933     }
1934     if( pf->HasGsfTrk() ) {
1935     if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1936     if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1937     IsLeptonFootprint = kTRUE;
1938     }
1939     }
1940 khahn 1.4 // PF charged
1941 khahn 1.19 if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1942 khahn 1.7 if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1943 khahn 1.4 IsLeptonFootprint = kTRUE;
1944 khahn 1.7 }
1945 khahn 1.4 // PF gamma
1946 khahn 1.19 if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1947     && tmpdr < 0.08) {
1948 khahn 1.7 if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1949 khahn 1.4 IsLeptonFootprint = kTRUE;
1950 khahn 1.7 }
1951 khahn 1.4 } // loop over electrons
1952 khahn 1.14
1953 khahn 1.19
1954 khahn 1.14 /* KH - comment for sync
1955 khahn 1.4 //
1956     // Check for muons
1957     //
1958     for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1959     const mithep::Muon *tmpmu = muonsToVeto[q];
1960 khahn 1.7 // 4l muon
1961     if( pf->HasTrackerTrk() ) {
1962     if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1963     if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1964     IsLeptonFootprint = kTRUE;
1965     }
1966     }
1967 khahn 1.4 // PF charged
1968 khahn 1.7 if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1969     if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1970 khahn 1.4 IsLeptonFootprint = kTRUE;
1971 khahn 1.7 }
1972 khahn 1.4 } // loop over muons
1973 khahn 1.14 */
1974 khahn 1.4
1975     if (IsLeptonFootprint)
1976     continue;
1977    
1978     //
1979     // Charged Iso Rings
1980     //
1981 khahn 1.7 if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1982    
1983 khahn 1.19 // if( pf->HasGsfTrk() ) {
1984     // if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1985     // } else if( pf->HasTrackerTrk() ){
1986     // if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1987     // }
1988 khahn 1.4
1989     // Veto any PFmuon, or PFEle
1990 khahn 1.7 if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1991 khahn 1.4
1992     // Footprint Veto
1993 khahn 1.7 if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
1994    
1995     if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
1996     << "\ttype: " << pf->PFType()
1997     << "\ttrk: " << pf->TrackerTrk() << endl;
1998    
1999     if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
2000     if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
2001     if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
2002     if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
2003     if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
2004 khahn 1.4
2005     }
2006    
2007     //
2008     // Gamma Iso Rings
2009     //
2010 khahn 1.7 else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2011    
2012 khahn 1.19 if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
2013 khahn 1.7
2014     if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2015     << dr << endl;
2016    
2017     if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
2018     if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
2019     if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
2020     if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
2021     if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
2022 khahn 1.4 }
2023    
2024     //
2025     // Other Neutral Iso Rings
2026     //
2027     else {
2028 khahn 1.7 if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2029     << dr << endl;
2030     if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
2031     if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
2032     if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
2033     if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
2034     if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
2035 khahn 1.4 }
2036    
2037     }
2038    
2039     }
2040    
2041 khahn 1.19 fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
2042     fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
2043     fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
2044     fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
2045     fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
2046    
2047     if(ctrl.debug) {
2048     cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1 << endl;
2049     cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2 << endl;
2050     cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3 << endl;
2051     cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4 << endl;
2052     cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5 << endl;
2053     }
2054    
2055 khahn 1.4
2056 khahn 1.19 // rho=0;
2057     // double rho = 0;
2058 khahn 1.18 // if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
2059     // rho = fPUEnergyDensity->At(0)->Rho();
2060 khahn 1.19 // if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
2061     // rho = fPUEnergyDensity->At(0)->RhoLowEta();
2062    
2063 khahn 1.18 // WARNING!!!!
2064     // hardcode for sync ...
2065     EffectiveAreaVersion = eleT.kEleEAData2011;
2066     // WARNING!!!!
2067 khahn 1.7
2068     if( ctrl.debug) {
2069     cout << "RHO: " << rho << endl;
2070     cout << "eta: " << ele->SCluster()->Eta() << endl;
2071     cout << "target: " << EffectiveAreaVersion << endl;
2072     cout << "effA 0-1: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
2073     ele->SCluster()->Eta(),
2074     EffectiveAreaVersion)
2075     << endl;
2076     cout << "effA 1-2: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
2077     ele->SCluster()->Eta(),
2078     EffectiveAreaVersion)
2079     << endl;
2080     cout << "effA 2-3: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
2081     ele->SCluster()->Eta(),
2082     EffectiveAreaVersion)
2083     << endl;
2084     cout << "effA 3-4: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
2085     ele->SCluster()->Eta(),
2086     EffectiveAreaVersion)
2087     << endl;
2088     }
2089    
2090 khahn 1.19 fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
2091 khahn 1.4 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
2092 khahn 1.7 ele->SCluster()->Eta(),
2093 khahn 1.4 EffectiveAreaVersion))/ele->Pt()
2094     ,2.5)
2095     ,0.0);
2096 khahn 1.19 fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
2097 khahn 1.4 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
2098 khahn 1.7 ele->SCluster()->Eta(),
2099 khahn 1.4 EffectiveAreaVersion))/ele->Pt()
2100     ,2.5)
2101     ,0.0);
2102 khahn 1.19 fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
2103 khahn 1.4 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
2104 khahn 1.7 ele->SCluster()->Eta()
2105 khahn 1.4 ,EffectiveAreaVersion))/ele->Pt()
2106     ,2.5)
2107     ,0.0);
2108 khahn 1.19 fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
2109 khahn 1.4 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
2110 khahn 1.7 ele->SCluster()->Eta(),
2111 khahn 1.4 EffectiveAreaVersion))/ele->Pt()
2112     ,2.5)
2113     ,0.0);
2114 khahn 1.19 fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
2115 khahn 1.4 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
2116 khahn 1.7 ele->SCluster()->Eta(),
2117 khahn 1.4 EffectiveAreaVersion))/ele->Pt()
2118     ,2.5)
2119     ,0.0);
2120    
2121    
2122 khahn 1.19 if( ctrl.debug) {
2123     cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
2124     cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
2125     cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
2126     cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
2127     cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
2128     }
2129    
2130     fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
2131 khahn 1.4 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
2132 khahn 1.7 ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2133 khahn 1.4 , 2.5)
2134     , 0.0);
2135 khahn 1.19 fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
2136 khahn 1.4 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
2137 khahn 1.7 ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2138 khahn 1.4 , 2.5)
2139     , 0.0);
2140 khahn 1.19 fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
2141 khahn 1.4 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
2142 khahn 1.7 ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2143 khahn 1.4 , 2.5)
2144     , 0.0);
2145 khahn 1.19 fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
2146 khahn 1.4 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
2147 khahn 1.7 ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
2148 khahn 1.4 , 2.5)
2149     , 0.0);
2150 khahn 1.19 fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
2151 khahn 1.4 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
2152 khahn 1.7 ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
2153 khahn 1.4 , 2.5)
2154     , 0.0);
2155    
2156 khahn 1.19 if( ctrl.debug) {
2157     cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
2158     cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
2159     cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
2160     cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
2161     cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
2162     }
2163    
2164 khahn 1.4 double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
2165 khahn 1.7 ele->SCluster()->Eta(),
2166     fChargedIso_DR0p0To0p1,
2167     fChargedIso_DR0p1To0p2,
2168     fChargedIso_DR0p2To0p3,
2169     fChargedIso_DR0p3To0p4,
2170     fChargedIso_DR0p4To0p5,
2171     fGammaIso_DR0p0To0p1,
2172     fGammaIso_DR0p1To0p2,
2173     fGammaIso_DR0p2To0p3,
2174     fGammaIso_DR0p3To0p4,
2175     fGammaIso_DR0p4To0p5,
2176     fNeutralHadronIso_DR0p0To0p1,
2177     fNeutralHadronIso_DR0p1To0p2,
2178     fNeutralHadronIso_DR0p2To0p3,
2179     fNeutralHadronIso_DR0p3To0p4,
2180     fNeutralHadronIso_DR0p4To0p5,
2181     ctrl.debug);
2182 khahn 1.4
2183     SelectionStatus status;
2184 khahn 1.19 status.isoMVA = mvaval;
2185 khahn 1.4 bool pass = false;
2186    
2187     Int_t subdet = 0;
2188     if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
2189     else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
2190     else subdet = 2;
2191 khahn 1.19
2192 khahn 1.4 Int_t ptBin = 0;
2193 khahn 1.19 if (ele->Pt() >= 10.0) ptBin = 1;
2194 khahn 1.4
2195     Int_t MVABin = -1;
2196     if (subdet == 0 && ptBin == 0) MVABin = 0;
2197     if (subdet == 1 && ptBin == 0) MVABin = 1;
2198     if (subdet == 2 && ptBin == 0) MVABin = 2;
2199     if (subdet == 0 && ptBin == 1) MVABin = 3;
2200     if (subdet == 1 && ptBin == 1) MVABin = 4;
2201     if (subdet == 2 && ptBin == 1) MVABin = 5;
2202    
2203 khahn 1.10 pass = false;
2204     if( MVABin == 0 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN0 ) pass = true;
2205     if( MVABin == 1 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN1 ) pass = true;
2206     if( MVABin == 2 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN2 ) pass = true;
2207     if( MVABin == 3 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN3 ) pass = true;
2208     if( MVABin == 4 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN4 ) pass = true;
2209     if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN5 ) pass = true;
2210     if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
2211    
2212 khahn 1.18 // pass = false;
2213     // if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
2214     // if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
2215     // if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
2216     // if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
2217     // if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
2218     // if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
2219     // if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
2220 khahn 1.7
2221 khahn 1.4 if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2222     return status;
2223 khahn 1.10
2224 khahn 1.4 }
2225    
2226    
2227     //--------------------------------------------------------------------------------------------------
2228     void initElectronIsoMVA() {
2229     //--------------------------------------------------------------------------------------------------
2230     eleIsoMVA = new mithep::ElectronIDMVA();
2231     vector<string> weightFiles;
2232     weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_BarrelPt5To10.weights.xml");
2233     weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_EndcapPt5To10.weights.xml");
2234     weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_BarrelPt10ToInf.weights.xml");
2235     weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_EndcapPt10ToInf.weights.xml");
2236     eleIsoMVA->Initialize( "ElectronIsoMVA",
2237     mithep::ElectronIDMVA::kIsoRingsV0,
2238     kTRUE, weightFiles);
2239     }
2240 khahn 1.10
2241    
2242    
2243 khahn 1.21
2244 khahn 1.10 //--------------------------------------------------------------------------------------------------
2245     float electronPFIso04(ControlFlags &ctrl,
2246 khahn 1.21 const mithep::Electron * ele,
2247 anlevin 1.22 const mithep::Vertex * vtx,
2248 khahn 1.21 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2249     const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2250     mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2251     vector<const mithep::Muon*> muonsToVeto,
2252     vector<const mithep::Electron*> electronsToVeto)
2253 khahn 1.10 //--------------------------------------------------------------------------------------------------
2254     {
2255 khahn 1.23 /*
2256 khahn 1.10 if( ctrl.debug ) {
2257     cout << "electronIsoMVASelection :: muons to veto " << endl;
2258     for( int i=0; i<muonsToVeto.size(); i++ ) {
2259     const mithep::Muon * vmu = muonsToVeto[i];
2260     cout << "\tpt: " << vmu->Pt()
2261     << "\teta: " << vmu->Eta()
2262     << "\tphi: " << vmu->Phi()
2263     << endl;
2264     }
2265 khahn 1.21 cout << "electronIsoMVASelection :: electrons to veto " << endl;
2266 khahn 1.10 for( int i=0; i<electronsToVeto.size(); i++ ) {
2267     const mithep::Electron * vel = electronsToVeto[i];
2268     cout << "\tpt: " << vel->Pt()
2269     << "\teta: " << vel->Eta()
2270     << "\tphi: " << vel->Phi()
2271     << "\ttrk: " << vel->TrackerTrk()
2272     << endl;
2273     }
2274     }
2275 khahn 1.23 */
2276 khahn 1.10
2277     //
2278     // final iso
2279     //
2280 khahn 1.12 Double_t fChargedIso = 0.0;
2281     Double_t fGammaIso = 0.0;
2282     Double_t fNeutralHadronIso = 0.0;
2283 khahn 1.10
2284    
2285     //
2286     //Loop over PF Candidates
2287     //
2288     for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2289 khahn 1.21
2290    
2291 khahn 1.10 const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2292     Double_t deta = (ele->Eta() - pf->Eta());
2293     Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
2294     Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
2295 khahn 1.21
2296     if (dr > 0.4) continue;
2297     if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
2298    
2299 khahn 1.10 if(ctrl.debug) {
2300 khahn 1.21 cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
2301 anlevin 1.22 if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx)
2302 khahn 1.21 << "\ttrk: " << pf->HasTrackerTrk()
2303     << "\tgsf: " << pf->HasGsfTrk();
2304    
2305 khahn 1.10 cout << endl;
2306     }
2307    
2308    
2309 khahn 1.21 //
2310     // sync : I don't think theyre doing this ...
2311     //
2312     // if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
2313     // (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
2314     // if( ctrl.debug ) cout << "\tskipping, matches to the electron ..." << endl;
2315     // continue;
2316     // }
2317    
2318 khahn 1.10
2319     //
2320     // Lepton Footprint Removal
2321     //
2322     Bool_t IsLeptonFootprint = kFALSE;
2323     if (dr < 1.0) {
2324    
2325     //
2326     // Check for electrons
2327     //
2328     for (Int_t q=0; q < electronsToVeto.size(); ++q) {
2329     const mithep::Electron *tmpele = electronsToVeto[q];
2330 khahn 1.21 /*
2331 khahn 1.10 // 4l electron
2332     if( pf->HasTrackerTrk() ) {
2333     if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
2334     if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
2335     IsLeptonFootprint = kTRUE;
2336     }
2337     }
2338     if( pf->HasGsfTrk() ) {
2339     if( pf->GsfTrk() == tmpele->GsfTrk() ) {
2340     if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
2341     IsLeptonFootprint = kTRUE;
2342     }
2343     }
2344 khahn 1.21 */
2345 khahn 1.10 // PF charged
2346     if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
2347     && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
2348     if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
2349     IsLeptonFootprint = kTRUE;
2350     }
2351     // PF gamma
2352     if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
2353     && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
2354     if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
2355     IsLeptonFootprint = kTRUE;
2356     }
2357     } // loop over electrons
2358 khahn 1.14
2359 khahn 1.21 /* KH - comment for sync
2360 khahn 1.15 //
2361     // Check for muons
2362     //
2363     for (Int_t q=0; q < muonsToVeto.size(); ++q) {
2364     const mithep::Muon *tmpmu = muonsToVeto[q];
2365     // 4l muon
2366     if( pf->HasTrackerTrk() ) {
2367     if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
2368     if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
2369     IsLeptonFootprint = kTRUE;
2370     }
2371     }
2372     // PF charged
2373     if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
2374     if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
2375     IsLeptonFootprint = kTRUE;
2376     }
2377     } // loop over muons
2378 khahn 1.21 */
2379 khahn 1.15
2380     if (IsLeptonFootprint)
2381     continue;
2382    
2383     //
2384     // Charged Iso
2385     //
2386 khahn 1.21 if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
2387 khahn 1.15
2388 khahn 1.21 // if( pf->HasTrackerTrk() )
2389     // if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2390     // if( pf->HasGsfTrk() )
2391     // if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2392 khahn 1.15
2393     // Veto any PFmuon, or PFEle
2394 khahn 1.21 if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) {
2395 anlevin 1.26 if( ctrl.debug) cout << "\t skipping, pf is and ele or mu .." <<endl;
2396 khahn 1.21 continue;
2397     }
2398 khahn 1.15
2399     // Footprint Veto
2400     if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
2401    
2402     if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
2403     << "\ttype: " << pf->PFType()
2404     << "\ttrk: " << pf->TrackerTrk() << endl;
2405    
2406     fChargedIso += pf->Pt();
2407     }
2408    
2409     //
2410     // Gamma Iso
2411     //
2412     else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2413    
2414     if (fabs(ele->SCluster()->Eta()) > 1.479) {
2415     if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
2416     }
2417     if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2418     << dr << endl;
2419 khahn 1.19 // KH, add to sync
2420 khahn 1.21 // if( pf->Pt() > 0.5 )
2421 khahn 1.17 fGammaIso += pf->Pt();
2422 khahn 1.15 }
2423    
2424     //
2425     // Neutral Iso
2426     //
2427     else {
2428     if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2429     << dr << endl;
2430 khahn 1.19 // KH, add to sync
2431 khahn 1.21 // if( pf->Pt() > 0.5 )
2432 khahn 1.15 fNeutralHadronIso += pf->Pt();
2433     }
2434    
2435     }
2436    
2437     }
2438    
2439 khahn 1.21
2440     double rho=0;
2441 anlevin 1.24 if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJets()) || isinf(fPUEnergyDensity->At(0)->RhoKt6PFJets())))
2442     rho = fPUEnergyDensity->At(0)->RhoKt6PFJets();
2443    
2444    
2445 khahn 1.19 double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2446     -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2447     ele->Eta(),EffectiveAreaVersion)));
2448 khahn 1.15
2449 khahn 1.21
2450 khahn 1.15 gChargedIso = fChargedIso;
2451     gGammaIso = fGammaIso;
2452     gNeutralIso = fNeutralHadronIso;
2453     return pfIso;
2454     }
2455    
2456 khahn 1.21
2457    
2458 khahn 1.15 //--------------------------------------------------------------------------------------------------
2459     // hacked version
2460     float electronPFIso04(ControlFlags &ctrl,
2461     const mithep::Electron * ele,
2462 anlevin 1.22 const mithep::Vertex * vtx,
2463 khahn 1.15 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2464     float rho,
2465     mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2466     vector<const mithep::Muon*> muonsToVeto,
2467     vector<const mithep::Electron*> electronsToVeto)
2468     //--------------------------------------------------------------------------------------------------
2469     {
2470    
2471     if( ctrl.debug ) {
2472     cout << "electronIsoMVASelection :: muons to veto " << endl;
2473     for( int i=0; i<muonsToVeto.size(); i++ ) {
2474     const mithep::Muon * vmu = muonsToVeto[i];
2475     cout << "\tpt: " << vmu->Pt()
2476     << "\teta: " << vmu->Eta()
2477     << "\tphi: " << vmu->Phi()
2478     << endl;
2479     }
2480 khahn 1.19 cout << "electronIsoMVASelection :: electrons to veto " << endl;
2481 khahn 1.15 for( int i=0; i<electronsToVeto.size(); i++ ) {
2482     const mithep::Electron * vel = electronsToVeto[i];
2483     cout << "\tpt: " << vel->Pt()
2484     << "\teta: " << vel->Eta()
2485     << "\tphi: " << vel->Phi()
2486     << "\ttrk: " << vel->TrackerTrk()
2487     << endl;
2488     }
2489     }
2490    
2491    
2492     //
2493     // final iso
2494     //
2495     Double_t fChargedIso = 0.0;
2496     Double_t fGammaIso = 0.0;
2497     Double_t fNeutralHadronIso = 0.0;
2498    
2499    
2500     //
2501     //Loop over PF Candidates
2502     //
2503     for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2504 khahn 1.19
2505    
2506 khahn 1.15 const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2507     Double_t deta = (ele->Eta() - pf->Eta());
2508     Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
2509     Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
2510 khahn 1.19
2511     if (dr > 0.4) continue;
2512     if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
2513    
2514 khahn 1.15 if(ctrl.debug) {
2515 khahn 1.19 cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
2516 anlevin 1.22 if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx)
2517 khahn 1.19 << "\ttrk: " << pf->HasTrackerTrk()
2518     << "\tgsf: " << pf->HasGsfTrk();
2519    
2520 khahn 1.15 cout << endl;
2521     }
2522    
2523    
2524 khahn 1.19 //
2525     // sync : I don't think theyre doing this ...
2526     //
2527     // if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
2528     // (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
2529     // if( ctrl.debug ) cout << "\tskipping, matches to the electron ..." << endl;
2530     // continue;
2531     // }
2532    
2533 khahn 1.15
2534     //
2535     // Lepton Footprint Removal
2536     //
2537     Bool_t IsLeptonFootprint = kFALSE;
2538     if (dr < 1.0) {
2539    
2540     //
2541     // Check for electrons
2542     //
2543     for (Int_t q=0; q < electronsToVeto.size(); ++q) {
2544     const mithep::Electron *tmpele = electronsToVeto[q];
2545 khahn 1.19 /*
2546 khahn 1.15 // 4l electron
2547     if( pf->HasTrackerTrk() ) {
2548     if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
2549     if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
2550     IsLeptonFootprint = kTRUE;
2551     }
2552     }
2553     if( pf->HasGsfTrk() ) {
2554     if( pf->GsfTrk() == tmpele->GsfTrk() ) {
2555     if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
2556     IsLeptonFootprint = kTRUE;
2557     }
2558     }
2559 khahn 1.19 */
2560 khahn 1.15 // PF charged
2561     if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
2562     && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
2563     if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
2564     IsLeptonFootprint = kTRUE;
2565     }
2566     // PF gamma
2567     if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
2568     && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
2569     if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
2570     IsLeptonFootprint = kTRUE;
2571     }
2572     } // loop over electrons
2573    
2574 khahn 1.14 /* KH - comment for sync
2575 khahn 1.10 //
2576     // Check for muons
2577     //
2578     for (Int_t q=0; q < muonsToVeto.size(); ++q) {
2579     const mithep::Muon *tmpmu = muonsToVeto[q];
2580     // 4l muon
2581     if( pf->HasTrackerTrk() ) {
2582     if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
2583     if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
2584     IsLeptonFootprint = kTRUE;
2585     }
2586     }
2587     // PF charged
2588     if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
2589     if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
2590     IsLeptonFootprint = kTRUE;
2591     }
2592     } // loop over muons
2593 khahn 1.14 */
2594 khahn 1.10
2595     if (IsLeptonFootprint)
2596     continue;
2597    
2598     //
2599 khahn 1.14 // Charged Iso
2600 khahn 1.10 //
2601     if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
2602    
2603 khahn 1.19 // if( pf->HasTrackerTrk() )
2604     // if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2605     // if( pf->HasGsfTrk() )
2606     // if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2607 khahn 1.10
2608     // Veto any PFmuon, or PFEle
2609 khahn 1.19 if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) {
2610     cout << "\t skipping, pf is and ele or mu .." <<endl;
2611     continue;
2612     }
2613 khahn 1.10
2614     // Footprint Veto
2615     if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
2616    
2617     if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
2618     << "\ttype: " << pf->PFType()
2619     << "\ttrk: " << pf->TrackerTrk() << endl;
2620    
2621 khahn 1.11 fChargedIso += pf->Pt();
2622 khahn 1.10 }
2623    
2624     //
2625     // Gamma Iso
2626     //
2627     else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2628    
2629     if (fabs(ele->SCluster()->Eta()) > 1.479) {
2630     if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
2631     }
2632     if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2633     << dr << endl;
2634 khahn 1.19 // KH, add to sync
2635     // if( pf->Pt() > 0.5 )
2636     fGammaIso += pf->Pt();
2637 khahn 1.10 }
2638    
2639     //
2640     // Neutral Iso
2641     //
2642     else {
2643     if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2644     << dr << endl;
2645 khahn 1.14 // KH, add to sync
2646 khahn 1.20 // if( pf->Pt() > 0.5 )
2647 khahn 1.14 fNeutralHadronIso += pf->Pt();
2648 khahn 1.10 }
2649    
2650     }
2651    
2652     }
2653    
2654 khahn 1.15 // double rho = 0;
2655     // if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
2656     // rho = fPUEnergyDensity->At(0)->Rho();
2657 khahn 1.10
2658 khahn 1.11 // WARNING!!!!
2659     // hardcode for sync ...
2660     EffectiveAreaVersion = eleT.kEleEAData2011;
2661     // WARNING!!!!
2662 khahn 1.10
2663    
2664 khahn 1.19 double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2665     -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2666     ele->Eta(),EffectiveAreaVersion)));
2667    
2668    
2669     gChargedIso = fChargedIso;
2670     gGammaIso = fGammaIso;
2671     gNeutralIso = fNeutralHadronIso;
2672 khahn 1.11 return pfIso;
2673 khahn 1.10 }
2674    
2675 khahn 1.15
2676 khahn 1.10 //--------------------------------------------------------------------------------------------------
2677 khahn 1.11 SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2678 khahn 1.10 const mithep::Electron * ele,
2679 anlevin 1.22 const mithep::Vertex * vtx,
2680 khahn 1.10 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2681     const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2682     mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2683     vector<const mithep::Muon*> muonsToVeto,
2684     vector<const mithep::Electron*> electronsToVeto)
2685     //--------------------------------------------------------------------------------------------------
2686     {
2687    
2688     SelectionStatus status;
2689    
2690     double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, fPUEnergyDensity,
2691     EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
2692 khahn 1.19 // cout << "--------------> setting electron isoPF04 to " << pfIso << endl;
2693 khahn 1.15 status.isoPF04 = pfIso;
2694     status.chisoPF04 = gChargedIso;
2695     status.gaisoPF04 = gGammaIso;
2696     status.neisoPF04 = gNeutralIso;
2697    
2698     bool pass = false;
2699     if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
2700    
2701     if( pass ) {
2702     status.orStatus(SelectionStatus::LOOSEISO);
2703     status.orStatus(SelectionStatus::TIGHTISO);
2704     }
2705     if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2706     return status;
2707    
2708     }
2709    
2710    
2711     //--------------------------------------------------------------------------------------------------
2712     // hacked version
2713     SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2714     const mithep::Electron * ele,
2715 anlevin 1.22 const mithep::Vertex * vtx,
2716 khahn 1.15 const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2717     float rho,
2718     mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2719     vector<const mithep::Muon*> muonsToVeto,
2720     vector<const mithep::Electron*> electronsToVeto)
2721     //--------------------------------------------------------------------------------------------------
2722     {
2723    
2724     SelectionStatus status;
2725    
2726     double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, rho,
2727     EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
2728 khahn 1.19 status.isoPF04 = pfIso;
2729     status.chisoPF04 = gChargedIso;
2730     status.gaisoPF04 = gGammaIso;
2731     status.neisoPF04 = gNeutralIso;
2732 khahn 1.10 bool pass = false;
2733     if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
2734    
2735     if( pass ) {
2736     status.orStatus(SelectionStatus::LOOSEISO);
2737     status.orStatus(SelectionStatus::TIGHTISO);
2738     }
2739     if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2740     return status;
2741    
2742     }