ViewVC Help
View File | Revision Log | Show Annotations | Root Listing
root/cvsroot/UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc
Revision: 1.22
Committed: Tue May 22 22:31:17 2012 UTC (12 years, 11 months ago) by anlevin
Content type: text/plain
Branch: MAIN
Changes since 1.21: +24 -24 lines
Log Message: 
made changes for new round of synchronization

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