ViewVC Help
View File | Revision Log | Show Annotations | Root Listing
root/cvsroot/UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc
Revision: 1.34
Committed: Tue Oct 23 10:41:23 2012 UTC (12 years, 6 months ago) by dkralph
Content type: text/plain
Branch: MAIN
Changes since 1.33: +177 -743 lines
Log Message: 
*** empty log message ***

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 dkralph 1.34 MuonIDMVA * muIsoMVA;
13     MuonTools muT;
14     ElectronIDMVA * eleIsoMVA;
15     ElectronTools eleT;
16 khahn 1.4
17 khahn 1.15 // global hack to sync
18     double gChargedIso;
19     double gGammaIso;
20     double gNeutralIso;
21    
22 khahn 1.19 extern vector<bool> PFnoPUflag;
23 khahn 1.15
24 khahn 1.4 //--------------------------------------------------------------------------------------------------
25 dkralph 1.34 Float_t computePFMuonIso(const Muon *muon,
26     const Vertex * vtx,
27     const Array<PFCandidate> * fPFCandidates,
28 khahn 1.4 const Double_t dRMax)
29     //--------------------------------------------------------------------------------------------------
30     {
31     const Double_t dRMin = 0;
32     const Double_t neuPtMin = 1.0;
33     const Double_t dzMax = 0.1;
34    
35 anlevin 1.22 Double_t zLepton = (muon->BestTrk()) ? muon->BestTrk()->DzCorrected(*vtx) : 0.0;
36 khahn 1.4
37     Float_t iso=0;
38     for(UInt_t ipf=0; ipf<fPFCandidates->GetEntries(); ipf++) {
39     const PFCandidate *pfcand = fPFCandidates->At(ipf);
40    
41     if(!pfcand->HasTrk() && (pfcand->Pt()<=neuPtMin)) continue; // pT cut on neutral particles
42    
43     // exclude THE muon
44     if(pfcand->TrackerTrk() && muon->TrackerTrk() && (pfcand->TrackerTrk()==muon->TrackerTrk())) continue;
45    
46     // dz cut
47 anlevin 1.22 Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(*vtx) - zLepton) : 0;
48 khahn 1.4 if(dz >= dzMax) continue;
49    
50     // check iso cone
51     Double_t dr = MathUtils::DeltaR(muon->Mom(), pfcand->Mom());
52     if(dr<dRMax && dr>=dRMin)
53     iso += pfcand->Pt();
54     }
55    
56     return iso;
57     }
58    
59     //--------------------------------------------------------------------------------------------------
60 dkralph 1.34 Float_t computePFEleIso(const Electron *electron,
61     const Vertex * fVertex,
62     const Array<PFCandidate> * fPFCandidates,
63 khahn 1.4 const Double_t dRMax)
64     //--------------------------------------------------------------------------------------------------
65     {
66     const Double_t dRMin = 0;
67     const Double_t neuPtMin = 1.0;
68     const Double_t dzMax = 0.1;
69    
70 anlevin 1.22 Double_t zLepton = (electron->BestTrk()) ? electron->BestTrk()->DzCorrected(*fVertex) : 0.0;
71 khahn 1.4
72     Float_t iso=0;
73     for(UInt_t ipf=0; ipf<fPFCandidates->GetEntries(); ipf++) {
74     const PFCandidate *pfcand = (PFCandidate*)(fPFCandidates->At(ipf));
75    
76     if(!pfcand->HasTrk() && (pfcand->Pt()<=neuPtMin)) continue; // pT cut on neutral particles
77    
78     // dz cut
79 anlevin 1.22 Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(*fVertex) - zLepton) : 0;
80 khahn 1.4 if(dz >= dzMax) continue;
81    
82     // remove THE electron
83     if(pfcand->TrackerTrk() && electron->TrackerTrk() && (pfcand->TrackerTrk()==electron->TrackerTrk())) continue;
84     if(pfcand->GsfTrk() && electron->GsfTrk() && (pfcand->GsfTrk()==electron->GsfTrk())) continue;
85    
86     // check iso cone
87     Double_t dr = MathUtils::DeltaR(electron->Mom(), pfcand->Mom());
88     if(dr<dRMax && dr>=dRMin) {
89     // eta-strip veto for photons
90     if((pfcand->PFType() == PFCandidate::eGamma) && fabs(electron->Eta() - pfcand->Eta()) < 0.025) continue;
91    
92     // Inner cone (one tower = dR < 0.07) veto for non-photon neutrals
93     if(!pfcand->HasTrk() && (pfcand->PFType() == PFCandidate::eNeutralHadron) &&
94     (MathUtils::DeltaR(electron->Mom(), pfcand->Mom()) < 0.07)) continue;
95    
96     iso += pfcand->Pt();
97     }
98     }
99    
100     return iso;
101     };
102     //--------------------------------------------------------------------------------------------------
103     SelectionStatus muonIsoSelection(ControlFlags &ctrl,
104 dkralph 1.34 const Muon * mu,
105     const Vertex * vtx,
106     const Array<PFCandidate> * fPFCandidateCol )
107 khahn 1.4 //--------------------------------------------------------------------------------------------------
108     {
109     float reliso = computePFMuonIso(mu,vtx,fPFCandidateCol,0.3)/mu->Pt();
110     bool isEB = (fabs(mu->Eta()) < 1.479 ? 1 : 0 );
111 khahn 1.1 bool failiso = false;
112 khahn 1.4 if( isEB && mu->Pt() > 20 && reliso > PFISO_MU_LOOSE_EB_HIGHPT ) {
113 khahn 1.1 failiso = true;
114     }
115 khahn 1.4 if( isEB && mu->Pt() < 20 && reliso > PFISO_MU_LOOSE_EB_LOWPT ) {
116 khahn 1.1 failiso = true;
117     }
118 khahn 1.4 if( !(isEB) && mu->Pt() > 20 && reliso > PFISO_MU_LOOSE_EE_HIGHPT ) {
119 khahn 1.1 failiso = true;
120     }
121 khahn 1.4 if( !(isEB) && mu->Pt() < 20 && reliso > PFISO_MU_LOOSE_EE_LOWPT ) {
122 khahn 1.1 failiso = true;
123     }
124    
125     SelectionStatus status;
126     if( !failiso ) status.setStatus(SelectionStatus::LOOSEISO);
127     if( !failiso ) status.setStatus(SelectionStatus::TIGHTISO);
128     return status;
129    
130     };
131    
132 khahn 1.4 //--------------------------------------------------------------------------------------------------
133     SelectionStatus electronIsoSelection(ControlFlags &ctrl,
134 dkralph 1.34 const Electron * ele,
135     const Vertex *fVertex,
136     const Array<PFCandidate> * fPFCandidates)
137 khahn 1.4 //--------------------------------------------------------------------------------------------------
138     {
139 khahn 1.1
140 khahn 1.4 bool failiso=false;
141 khahn 1.1
142 khahn 1.4 float reliso = computePFEleIso(ele,fVertex,fPFCandidates,0.4)/ele->Pt();
143 khahn 1.1
144 khahn 1.4 if( ele->IsEB() && ele->Pt() > 20 && reliso > PFISO_ELE_LOOSE_EB_HIGHPT ) {
145 khahn 1.1 failiso = true;
146     }
147 khahn 1.4 if( ele->IsEB() && ele->Pt() < 20 && reliso > PFISO_ELE_LOOSE_EB_LOWPT ) {
148 khahn 1.1 failiso = true;
149     }
150 khahn 1.4 if( !(ele->IsEB()) && ele->Pt() > 20 && reliso > PFISO_ELE_LOOSE_EE_HIGHPT ) {
151 khahn 1.1 failiso = true;
152     }
153 khahn 1.4 if( !(ele->IsEB()) && ele->Pt() < 20 && reliso > PFISO_ELE_LOOSE_EE_LOWPT ) {
154 khahn 1.1 failiso = true;
155     }
156    
157     SelectionStatus status;
158     if( !failiso ) {
159 khahn 1.4 status.orStatus(SelectionStatus::LOOSEISO);
160     status.orStatus(SelectionStatus::TIGHTISO);
161 khahn 1.1 }
162     if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
163     return status;
164    
165     }
166 anlevin 1.3
167 khahn 1.4
168 anlevin 1.3 bool noIso(ControlFlags &, vector<SimpleLepton> &, float rho) {
169    
170     return true;
171     }
172 khahn 1.4
173     //--------------------------------------------------------------------------------------------------
174     SelectionStatus muonIsoMVASelection(ControlFlags &ctrl,
175 dkralph 1.34 const Muon * mu,
176     const Vertex * vtx,
177     const Array<PFCandidate> * fPFCandidates,
178     const Array<PileupEnergyDensity> * fPUEnergyDensity,
179     MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
180     vector<const Muon*> muonsToVeto,
181     vector<const Electron*> electronsToVeto)
182 khahn 1.4 //--------------------------------------------------------------------------------------------------
183     {
184    
185 khahn 1.7 if( ctrl.debug ) {
186     cout << "muonIsoMVASelection :: muons to veto " << endl;
187     for( int i=0; i<muonsToVeto.size(); i++ ) {
188 dkralph 1.34 const Muon * vmu = muonsToVeto[i];
189 khahn 1.7 cout << "\tpt: " << vmu->Pt()
190     << "\teta: " << vmu->Eta()
191     << "\tphi: " << vmu->Phi()
192     << endl;
193     }
194     cout << "muonIsoMVASelection :: electrson to veto " << endl;
195     for( int i=0; i<electronsToVeto.size(); i++ ) {
196 dkralph 1.34 const Electron * vel = electronsToVeto[i];
197 khahn 1.7 cout << "\tpt: " << vel->Pt()
198     << "\teta: " << vel->Eta()
199     << "\tphi: " << vel->Phi()
200     << endl;
201     }
202     }
203 khahn 1.4 bool failiso=false;
204    
205     //
206     // tmp iso rings
207     //
208 khahn 1.7 Double_t tmpChargedIso_DR0p0To0p1 = 0;
209     Double_t tmpChargedIso_DR0p1To0p2 = 0;
210     Double_t tmpChargedIso_DR0p2To0p3 = 0;
211 khahn 1.4 Double_t tmpChargedIso_DR0p3To0p4 = 0;
212     Double_t tmpChargedIso_DR0p4To0p5 = 0;
213 khahn 1.7 Double_t tmpChargedIso_DR0p5To0p7 = 0;
214 khahn 1.4
215 khahn 1.7 Double_t tmpGammaIso_DR0p0To0p1 = 0;
216     Double_t tmpGammaIso_DR0p1To0p2 = 0;
217     Double_t tmpGammaIso_DR0p2To0p3 = 0;
218 khahn 1.4 Double_t tmpGammaIso_DR0p3To0p4 = 0;
219     Double_t tmpGammaIso_DR0p4To0p5 = 0;
220 khahn 1.7 Double_t tmpGammaIso_DR0p5To0p7 = 0;
221 khahn 1.4
222 khahn 1.7 Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
223     Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
224     Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
225 khahn 1.4 Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
226     Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
227 khahn 1.7 Double_t tmpNeutralHadronIso_DR0p5To0p7 = 0;
228    
229 khahn 1.4
230    
231     //
232     // final rings for the MVA
233     //
234     Double_t fChargedIso_DR0p0To0p1;
235     Double_t fChargedIso_DR0p1To0p2;
236     Double_t fChargedIso_DR0p2To0p3;
237     Double_t fChargedIso_DR0p3To0p4;
238     Double_t fChargedIso_DR0p4To0p5;
239 khahn 1.7 Double_t fChargedIso_DR0p5To0p7;
240 khahn 1.4
241     Double_t fGammaIso_DR0p0To0p1;
242     Double_t fGammaIso_DR0p1To0p2;
243     Double_t fGammaIso_DR0p2To0p3;
244     Double_t fGammaIso_DR0p3To0p4;
245     Double_t fGammaIso_DR0p4To0p5;
246 khahn 1.7 Double_t fGammaIso_DR0p5To0p7;
247 khahn 1.4
248     Double_t fNeutralHadronIso_DR0p0To0p1;
249     Double_t fNeutralHadronIso_DR0p1To0p2;
250     Double_t fNeutralHadronIso_DR0p2To0p3;
251     Double_t fNeutralHadronIso_DR0p3To0p4;
252     Double_t fNeutralHadronIso_DR0p4To0p5;
253 khahn 1.7 Double_t fNeutralHadronIso_DR0p5To0p7;
254 khahn 1.4
255    
256     //
257     //Loop over PF Candidates
258     //
259     for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
260 khahn 1.21
261     if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
262    
263 dkralph 1.34 const PFCandidate *pf = (PFCandidate*)((*fPFCandidates)[k]);
264 khahn 1.4
265     Double_t deta = (mu->Eta() - pf->Eta());
266 dkralph 1.34 Double_t dphi = MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
267     Double_t dr = MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
268 khahn 1.21 if (dr > 1.0) continue;
269 khahn 1.4
270 khahn 1.7 if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
271 khahn 1.4
272     //
273     // Lepton Footprint Removal
274     //
275     Bool_t IsLeptonFootprint = kFALSE;
276     if (dr < 1.0) {
277    
278     //
279     // Check for electrons
280     //
281     for (Int_t q=0; q < electronsToVeto.size(); ++q) {
282 dkralph 1.34 const Electron *tmpele = electronsToVeto[q];
283 khahn 1.7 // 4l electron
284     if( pf->HasTrackerTrk() ) {
285     if( pf->TrackerTrk() == tmpele->TrackerTrk() )
286     IsLeptonFootprint = kTRUE;
287     }
288     if( pf->HasGsfTrk() ) {
289     if( pf->GsfTrk() == tmpele->GsfTrk() )
290     IsLeptonFootprint = kTRUE;
291     }
292 khahn 1.4 // PF charged
293 khahn 1.19 if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479
294 dkralph 1.34 && MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
295 khahn 1.4 IsLeptonFootprint = kTRUE;
296     // PF gamma
297 khahn 1.19 if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
298 dkralph 1.34 && MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
299 khahn 1.4 IsLeptonFootprint = kTRUE;
300     } // loop over electrons
301    
302 khahn 1.21 /* KH - commented for sync
303 khahn 1.4 //
304     // Check for muons
305     //
306     for (Int_t q=0; q < muonsToVeto.size(); ++q) {
307 dkralph 1.34 const Muon *tmpmu = muonsToVeto[q];
308 khahn 1.7 // 4l muon
309     if( pf->HasTrackerTrk() ) {
310     if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
311     IsLeptonFootprint = kTRUE;
312     }
313 khahn 1.4 // PF charged
314 dkralph 1.34 if (pf->Charge() != 0 && MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
315 khahn 1.4 IsLeptonFootprint = kTRUE;
316     } // loop over muons
317 khahn 1.14 */
318 khahn 1.4
319     if (IsLeptonFootprint)
320     continue;
321    
322     //
323     // Charged Iso Rings
324     //
325 khahn 1.7 if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
326    
327 khahn 1.19 if( dr < 0.01 ) continue; // only for muon iso mva?
328 khahn 1.7 if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
329 khahn 1.4
330 khahn 1.19 // if( pf->HasTrackerTrk() ) {
331     // if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
332     // if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
333     // << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
334     // << dr << endl;
335     // }
336 khahn 1.21 // if( pf->HasGsfTrk() ) {
337     // if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
338     // if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
339     // << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
340     // << dr << endl;
341     // }
342 khahn 1.4
343     // Footprint Veto
344 khahn 1.7 if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
345     if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
346     if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
347     if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
348     if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
349     if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
350 khahn 1.4 }
351    
352     //
353     // Gamma Iso Rings
354     //
355 khahn 1.7 else if (abs(pf->PFType()) == PFCandidate::eGamma) {
356     if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
357     if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
358     if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
359     if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
360     if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
361     if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
362 khahn 1.4 }
363    
364     //
365     // Other Neutral Iso Rings
366     //
367     else {
368 khahn 1.7 if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
369     if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
370     if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
371     if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
372     if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
373     if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
374 khahn 1.4 }
375    
376     }
377    
378     }
379    
380 khahn 1.19 fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5);
381     fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5);
382     fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5);
383     fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5);
384     fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5);
385 khahn 1.4
386 khahn 1.7
387 khahn 1.4 double rho = 0;
388 khahn 1.21 if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
389     rho = fPUEnergyDensity->At(0)->Rho();
390 khahn 1.27
391 khahn 1.21 // if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
392     // rho = fPUEnergyDensity->At(0)->RhoLowEta();
393 khahn 1.4
394 khahn 1.18 // WARNING!!!!
395     // hardcode for sync ...
396     EffectiveAreaVersion = muT.kMuEAData2011;
397     // WARNING!!!!
398    
399 khahn 1.4
400 khahn 1.19 fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
401 khahn 1.4 -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p0To0p1,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
402     ,2.5)
403     ,0.0);
404 khahn 1.19 fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
405 khahn 1.4 -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p1To0p2,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
406     ,2.5)
407     ,0.0);
408 khahn 1.19 fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
409 khahn 1.4 -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p2To0p3,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
410     ,2.5)
411     ,0.0);
412 khahn 1.19 fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
413 khahn 1.4 -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p3To0p4,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
414     ,2.5)
415     ,0.0);
416 khahn 1.19 fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
417 khahn 1.4 -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p4To0p5,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
418     ,2.5)
419     ,0.0);
420    
421    
422 khahn 1.7
423 khahn 1.19 fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
424 khahn 1.4 -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p0To0p1,
425     mu->Eta(),EffectiveAreaVersion))/mu->Pt()
426     , 2.5)
427     , 0.0);
428 khahn 1.19 fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
429 khahn 1.4 -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p1To0p2,
430     mu->Eta(),EffectiveAreaVersion))/mu->Pt()
431     , 2.5)
432     , 0.0);
433 khahn 1.19 fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
434 khahn 1.4 -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p2To0p3,
435     mu->Eta(),EffectiveAreaVersion))/mu->Pt()
436     , 2.5)
437     , 0.0);
438 khahn 1.19 fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
439 khahn 1.4 -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p3To0p4,
440     mu->Eta(), EffectiveAreaVersion))/mu->Pt()
441     , 2.5)
442     , 0.0);
443 khahn 1.19 fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
444 khahn 1.4 -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p4To0p5,
445     mu->Eta(), EffectiveAreaVersion))/mu->Pt()
446     , 2.5)
447     , 0.0);
448    
449 khahn 1.7
450 khahn 1.4 double mvaval = muIsoMVA->MVAValue_IsoRings( mu->Pt(),
451 khahn 1.18 mu->Eta(),
452     mu->IsGlobalMuon(),
453     mu->IsTrackerMuon(),
454     fChargedIso_DR0p0To0p1,
455     fChargedIso_DR0p1To0p2,
456     fChargedIso_DR0p2To0p3,
457     fChargedIso_DR0p3To0p4,
458     fChargedIso_DR0p4To0p5,
459     fGammaIso_DR0p0To0p1,
460     fGammaIso_DR0p1To0p2,
461     fGammaIso_DR0p2To0p3,
462     fGammaIso_DR0p3To0p4,
463     fGammaIso_DR0p4To0p5,
464     fNeutralHadronIso_DR0p0To0p1,
465     fNeutralHadronIso_DR0p1To0p2,
466     fNeutralHadronIso_DR0p2To0p3,
467     fNeutralHadronIso_DR0p3To0p4,
468     fNeutralHadronIso_DR0p4To0p5,
469     ctrl.debug);
470 khahn 1.4
471     SelectionStatus status;
472 khahn 1.10 bool pass;
473 khahn 1.4
474 khahn 1.10 pass = false;
475 khahn 1.4 if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
476 khahn 1.21 && fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN0) pass = true;
477 khahn 1.4 else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
478 khahn 1.21 && fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN1) pass = true;
479 khahn 1.4 else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
480 khahn 1.21 && fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN2) pass = true;
481 khahn 1.4 else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
482 khahn 1.21 && fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN3) pass = true;
483     else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN4) pass = true;
484     else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN5) pass = true;
485 khahn 1.10 if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
486 khahn 1.4
487 khahn 1.21 /*
488 khahn 1.10 pass = false;
489     if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
490     && fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN0) pass = true;
491     else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
492     && fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN1) pass = true;
493     else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
494     && fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN2) pass = true;
495     else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
496     && fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN3) pass = true;
497     else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN4) pass = true;
498     else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN5) pass = true;
499     if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
500 khahn 1.21 */
501 khahn 1.4
502 khahn 1.10 // pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
503 khahn 1.7
504 khahn 1.21 status.isoMVA = mvaval;
505    
506     if(ctrl.debug) {
507     cout << "returning status : " << hex << status.getStatus() << dec << endl;
508     cout << "MVAVAL : " << status.isoMVA << endl;
509     }
510 khahn 1.4 return status;
511    
512     }
513    
514    
515 khahn 1.10 //--------------------------------------------------------------------------------------------------
516 khahn 1.19 SelectionStatus muonIsoMVASelection(ControlFlags &ctrl,
517 dkralph 1.34 const Muon * mu,
518     const Vertex * vtx,
519     const Array<PFCandidate> * fPFCandidates,
520 khahn 1.19 float rho,
521 dkralph 1.34 //const Array<PileupEnergyDensity> * fPUEnergyDensity,
522     MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
523     vector<const Muon*> muonsToVeto,
524     vector<const Electron*> electronsToVeto)
525 khahn 1.10 //--------------------------------------------------------------------------------------------------
526 khahn 1.19 // hacked version
527 khahn 1.10 {
528 khahn 1.19
529 khahn 1.10 if( ctrl.debug ) {
530     cout << "muonIsoMVASelection :: muons to veto " << endl;
531     for( int i=0; i<muonsToVeto.size(); i++ ) {
532 dkralph 1.34 const Muon * vmu = muonsToVeto[i];
533 khahn 1.10 cout << "\tpt: " << vmu->Pt()
534     << "\teta: " << vmu->Eta()
535     << "\tphi: " << vmu->Phi()
536     << endl;
537     }
538     cout << "muonIsoMVASelection :: electrson to veto " << endl;
539     for( int i=0; i<electronsToVeto.size(); i++ ) {
540 dkralph 1.34 const Electron * vel = electronsToVeto[i];
541 khahn 1.10 cout << "\tpt: " << vel->Pt()
542     << "\teta: " << vel->Eta()
543     << "\tphi: " << vel->Phi()
544     << endl;
545     }
546     }
547 khahn 1.19 bool failiso=false;
548    
549     //
550     // tmp iso rings
551     //
552     Double_t tmpChargedIso_DR0p0To0p1 = 0;
553     Double_t tmpChargedIso_DR0p1To0p2 = 0;
554     Double_t tmpChargedIso_DR0p2To0p3 = 0;
555     Double_t tmpChargedIso_DR0p3To0p4 = 0;
556     Double_t tmpChargedIso_DR0p4To0p5 = 0;
557     Double_t tmpChargedIso_DR0p5To0p7 = 0;
558    
559     Double_t tmpGammaIso_DR0p0To0p1 = 0;
560     Double_t tmpGammaIso_DR0p1To0p2 = 0;
561     Double_t tmpGammaIso_DR0p2To0p3 = 0;
562     Double_t tmpGammaIso_DR0p3To0p4 = 0;
563     Double_t tmpGammaIso_DR0p4To0p5 = 0;
564     Double_t tmpGammaIso_DR0p5To0p7 = 0;
565    
566     Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
567     Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
568     Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
569     Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
570     Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
571     Double_t tmpNeutralHadronIso_DR0p5To0p7 = 0;
572    
573    
574 khahn 1.10
575     //
576 khahn 1.19 // final rings for the MVA
577 khahn 1.10 //
578 khahn 1.19 Double_t fChargedIso_DR0p0To0p1;
579     Double_t fChargedIso_DR0p1To0p2;
580     Double_t fChargedIso_DR0p2To0p3;
581     Double_t fChargedIso_DR0p3To0p4;
582     Double_t fChargedIso_DR0p4To0p5;
583     Double_t fChargedIso_DR0p5To0p7;
584    
585     Double_t fGammaIso_DR0p0To0p1;
586     Double_t fGammaIso_DR0p1To0p2;
587     Double_t fGammaIso_DR0p2To0p3;
588     Double_t fGammaIso_DR0p3To0p4;
589     Double_t fGammaIso_DR0p4To0p5;
590     Double_t fGammaIso_DR0p5To0p7;
591    
592     Double_t fNeutralHadronIso_DR0p0To0p1;
593     Double_t fNeutralHadronIso_DR0p1To0p2;
594     Double_t fNeutralHadronIso_DR0p2To0p3;
595     Double_t fNeutralHadronIso_DR0p3To0p4;
596     Double_t fNeutralHadronIso_DR0p4To0p5;
597     Double_t fNeutralHadronIso_DR0p5To0p7;
598    
599 khahn 1.10
600     //
601     //Loop over PF Candidates
602     //
603     for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
604 khahn 1.19
605     if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
606    
607 dkralph 1.34 const PFCandidate *pf = (PFCandidate*)((*fPFCandidates)[k]);
608 khahn 1.10
609     Double_t deta = (mu->Eta() - pf->Eta());
610 dkralph 1.34 Double_t dphi = MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
611     Double_t dr = MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
612 khahn 1.19 if (dr > 1.0) continue;
613 khahn 1.10
614     if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
615    
616     //
617     // Lepton Footprint Removal
618     //
619     Bool_t IsLeptonFootprint = kFALSE;
620     if (dr < 1.0) {
621    
622     //
623     // Check for electrons
624     //
625     for (Int_t q=0; q < electronsToVeto.size(); ++q) {
626 dkralph 1.34 const Electron *tmpele = electronsToVeto[q];
627 khahn 1.10 // 4l electron
628     if( pf->HasTrackerTrk() ) {
629     if( pf->TrackerTrk() == tmpele->TrackerTrk() )
630     IsLeptonFootprint = kTRUE;
631     }
632     if( pf->HasGsfTrk() ) {
633     if( pf->GsfTrk() == tmpele->GsfTrk() )
634     IsLeptonFootprint = kTRUE;
635     }
636     // PF charged
637 khahn 1.19 if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479
638 dkralph 1.34 && MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
639 khahn 1.10 IsLeptonFootprint = kTRUE;
640     // PF gamma
641 khahn 1.19 if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
642 dkralph 1.34 && MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
643 khahn 1.10 IsLeptonFootprint = kTRUE;
644     } // loop over electrons
645 khahn 1.19
646     /* KH - commented for sync
647 khahn 1.15 //
648     // Check for muons
649     //
650     for (Int_t q=0; q < muonsToVeto.size(); ++q) {
651 dkralph 1.34 const Muon *tmpmu = muonsToVeto[q];
652 khahn 1.15 // 4l muon
653     if( pf->HasTrackerTrk() ) {
654     if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
655     IsLeptonFootprint = kTRUE;
656     }
657     // PF charged
658 dkralph 1.34 if (pf->Charge() != 0 && MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
659 khahn 1.15 IsLeptonFootprint = kTRUE;
660     } // loop over muons
661     */
662    
663     if (IsLeptonFootprint)
664     continue;
665    
666     //
667 khahn 1.19 // Charged Iso Rings
668 khahn 1.15 //
669 khahn 1.19 if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
670 khahn 1.15
671 khahn 1.19 if( dr < 0.01 ) continue; // only for muon iso mva?
672 khahn 1.15 if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
673    
674 khahn 1.19 // if( pf->HasTrackerTrk() ) {
675     // if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
676     // if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
677     // << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
678     // << dr << endl;
679     // }
680     // if( pf->HasGsfTrk() ) {
681     // if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
682     // if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
683     // << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
684     // << dr << endl;
685     // }
686 khahn 1.15
687 khahn 1.19 // Footprint Veto
688     if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
689     if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
690     if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
691     if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
692     if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
693     if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
694 khahn 1.15 }
695    
696     //
697 khahn 1.19 // Gamma Iso Rings
698 khahn 1.15 //
699     else if (abs(pf->PFType()) == PFCandidate::eGamma) {
700 khahn 1.19 if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
701     if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
702     if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
703     if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
704     if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
705     if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
706 khahn 1.15 }
707    
708     //
709 khahn 1.19 // Other Neutral Iso Rings
710 khahn 1.15 //
711     else {
712 khahn 1.19 if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
713     if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
714     if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
715     if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
716     if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
717     if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
718 khahn 1.15 }
719 khahn 1.19
720 khahn 1.15 }
721 khahn 1.19
722 khahn 1.15 }
723 khahn 1.19
724     fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5);
725     fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5);
726     fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5);
727     fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5);
728     fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5);
729    
730    
731     // double rho = 0;
732     // if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
733     // rho = fPUEnergyDensity->At(0)->Rho();
734     // if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
735     // rho = fPUEnergyDensity->At(0)->RhoLowEta();
736 khahn 1.15
737     // WARNING!!!!
738     // hardcode for sync ...
739     EffectiveAreaVersion = muT.kMuEAData2011;
740     // WARNING!!!!
741    
742 khahn 1.19
743     fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
744     -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p0To0p1,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
745     ,2.5)
746     ,0.0);
747     fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
748     -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p1To0p2,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
749     ,2.5)
750     ,0.0);
751     fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
752     -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p2To0p3,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
753     ,2.5)
754     ,0.0);
755     fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
756     -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p3To0p4,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
757     ,2.5)
758     ,0.0);
759     fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
760     -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p4To0p5,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
761     ,2.5)
762     ,0.0);
763 khahn 1.15
764    
765    
766 khahn 1.19 fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
767     -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p0To0p1,
768     mu->Eta(),EffectiveAreaVersion))/mu->Pt()
769     , 2.5)
770     , 0.0);
771     fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
772     -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p1To0p2,
773     mu->Eta(),EffectiveAreaVersion))/mu->Pt()
774     , 2.5)
775     , 0.0);
776     fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
777     -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p2To0p3,
778     mu->Eta(),EffectiveAreaVersion))/mu->Pt()
779     , 2.5)
780     , 0.0);
781     fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
782     -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p3To0p4,
783     mu->Eta(), EffectiveAreaVersion))/mu->Pt()
784     , 2.5)
785     , 0.0);
786     fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
787     -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p4To0p5,
788     mu->Eta(), EffectiveAreaVersion))/mu->Pt()
789     , 2.5)
790     , 0.0);
791 khahn 1.15
792    
793 khahn 1.19 double mvaval = muIsoMVA->MVAValue_IsoRings( mu->Pt(),
794     mu->Eta(),
795     mu->IsGlobalMuon(),
796     mu->IsTrackerMuon(),
797     fChargedIso_DR0p0To0p1,
798     fChargedIso_DR0p1To0p2,
799     fChargedIso_DR0p2To0p3,
800     fChargedIso_DR0p3To0p4,
801     fChargedIso_DR0p4To0p5,
802     fGammaIso_DR0p0To0p1,
803     fGammaIso_DR0p1To0p2,
804     fGammaIso_DR0p2To0p3,
805     fGammaIso_DR0p3To0p4,
806     fGammaIso_DR0p4To0p5,
807     fNeutralHadronIso_DR0p0To0p1,
808     fNeutralHadronIso_DR0p1To0p2,
809     fNeutralHadronIso_DR0p2To0p3,
810     fNeutralHadronIso_DR0p3To0p4,
811     fNeutralHadronIso_DR0p4To0p5,
812     ctrl.debug);
813    
814     SelectionStatus status;
815     bool pass;
816    
817     pass = false;
818     if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
819     && fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN0) pass = true;
820     else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
821     && fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN1) pass = true;
822     else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
823     && fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN2) pass = true;
824     else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
825     && fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN3) pass = true;
826     else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN4) pass = true;
827     else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN5) pass = true;
828     if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
829    
830     /*
831     pass = false;
832     if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
833     && fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN0) pass = true;
834     else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
835     && fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN1) pass = true;
836     else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
837     && fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN2) pass = true;
838     else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
839     && fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN3) pass = true;
840     else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN4) pass = true;
841     else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN5) pass = true;
842     if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
843     */
844    
845     // pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
846    
847     status.isoMVA = mvaval;
848    
849     if(ctrl.debug) {
850     cout << "returning status : " << hex << status.getStatus() << dec << endl;
851     cout << "MVAVAL : " << status.isoMVA << endl;
852     }
853     return status;
854    
855     }
856    
857    
858     //--------------------------------------------------------------------------------------------------
859     void initMuonIsoMVA() {
860     //--------------------------------------------------------------------------------------------------
861 dkralph 1.34 muIsoMVA = new MuonIDMVA();
862 khahn 1.19 vector<string> weightFiles;
863     weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_barrel_lowpt.weights.xml");
864     weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_barrel_highpt.weights.xml");
865     weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_endcap_lowpt.weights.xml");
866     weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_endcap_highpt.weights.xml");
867     weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_tracker.weights.xml");
868     weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_global.weights.xml");
869     muIsoMVA->Initialize( "MuonIsoMVA",
870 dkralph 1.34 MuonIDMVA::kIsoRingsV0,
871 khahn 1.19 kTRUE, weightFiles);
872     }
873    
874    
875 khahn 1.21
876 khahn 1.19 //--------------------------------------------------------------------------------------------------
877     double muonPFIso04(ControlFlags &ctrl,
878 dkralph 1.34 const Muon * mu,
879     const Vertex * vtx,
880     const Array<PFCandidate> * fPFCandidates,
881     const Array<PileupEnergyDensity> * fPUEnergyDensity,
882     MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
883     vector<const PFCandidate*> photonsToVeto)
884 khahn 1.19 //--------------------------------------------------------------------------------------------------
885     {
886 khahn 1.21
887     extern double gChargedIso;
888     extern double gGammaIso;
889     extern double gNeutralIso;
890 khahn 1.15
891     //
892     // final iso
893     //
894     Double_t fChargedIso = 0.0;
895     Double_t fGammaIso = 0.0;
896     Double_t fNeutralHadronIso = 0.0;
897    
898     //
899     //Loop over PF Candidates
900     //
901 dkralph 1.34 if(ctrl.debug) cout << " muonPFIso04(): ----> " << endl;
902 khahn 1.15 for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
903 khahn 1.21
904     if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
905 dkralph 1.34 const PFCandidate *pf = (PFCandidate*)((*fPFCandidates)[k]);
906 khahn 1.15
907 khahn 1.30 //
908     // veto FSR recovered photons
909     //
910     bool vetoPhoton = false;
911     for( int p=0; p<photonsToVeto.size(); p++ ) {
912     if( pf == photonsToVeto[p] ) {
913     vetoPhoton = true;
914     break;
915     }
916     } if( vetoPhoton ) continue;
917     //
918     //
919     //
920    
921 khahn 1.15 Double_t deta = (mu->Eta() - pf->Eta());
922 dkralph 1.34 Double_t dphi = MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
923     Double_t dr = MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
924 khahn 1.15 if (dr > 0.4) continue;
925    
926     if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
927    
928     //
929 khahn 1.14 // Charged Iso
930 khahn 1.10 //
931 khahn 1.21 if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
932 khahn 1.10
933 khahn 1.19 //if( dr < 0.01 ) continue; // only for muon iso mva?
934 khahn 1.10 if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
935 khahn 1.11 fChargedIso += pf->Pt();
936 khahn 1.10 }
937 khahn 1.30
938 khahn 1.10 //
939     // Gamma Iso
940     //
941     else if (abs(pf->PFType()) == PFCandidate::eGamma) {
942 khahn 1.19 // KH, add to sync
943 anlevin 1.33 if( pf->Pt() > 0.5 && dr > 0.01)
944 khahn 1.19 fGammaIso += pf->Pt();
945     }
946 khahn 1.30
947 khahn 1.19 //
948     // Other Neutrals
949     //
950     else {
951 anlevin 1.33
952     if( pf->Pt() > 0.5 && dr > 0.01)
953 khahn 1.19 fNeutralHadronIso += pf->Pt();
954     }
955     }
956 khahn 1.21
957     double rho=0;
958 dkralph 1.34 if( (EffectiveAreaVersion == MuonTools::kMuEAFall11MC) ||
959     (EffectiveAreaVersion == MuonTools::kMuEAData2011) ) {
960 khahn 1.27 if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25()) ||
961     isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25())))
962     rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25();
963 khahn 1.29 //rho = fPUEnergyDensity->At(0)->Rho();
964 khahn 1.27 // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
965 dkralph 1.34 EffectiveAreaVersion = MuonTools::kMuEAData2011;
966 khahn 1.27 // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
967     } else {
968     if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral()) ||
969     isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral())))
970     rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral();
971     // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
972 dkralph 1.34 EffectiveAreaVersion = MuonTools::kMuEAData2012;
973 khahn 1.27 // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
974     }
975 dkralph 1.34 if(ctrl.debug) cout << " rho: " << rho << endl;
976 khahn 1.21
977 khahn 1.30 TLorentzVector tmpvec;
978     tmpvec.SetPtEtaPhiM(mu->Pt(),mu->Eta(),mu->Phi(),mu->Mass());
979     for( int p=0; p<photonsToVeto.size(); p++ ) {
980 dkralph 1.34 const PFCandidate * pf = photonsToVeto[p];
981 khahn 1.30 TLorentzVector pfvec;
982     pfvec.SetPtEtaPhiM(pf->Pt(),pf->Eta(),pf->Phi(),0.);
983     tmpvec += pfvec;
984     }
985    
986 khahn 1.19 double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
987     -rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
988 khahn 1.31 //tmpvec.Eta(),EffectiveAreaVersion)));
989     mu->Eta(),EffectiveAreaVersion)));
990 khahn 1.19 gChargedIso = fChargedIso;
991 khahn 1.21 gGammaIso = fGammaIso;
992     gNeutralIso = fNeutralHadronIso;
993    
994 khahn 1.30 if( ctrl.debug ) {
995 dkralph 1.34 cout << " PFiso: " << pfIso
996 khahn 1.30 << "\tfChargedIso: " << fChargedIso
997     << "\tfGammaIso: " << fGammaIso
998     << "\tfNeutralHadronIso: " << fNeutralHadronIso
999     << endl;
1000     }
1001    
1002 khahn 1.19 return pfIso;
1003     }
1004    
1005     //--------------------------------------------------------------------------------------------------
1006     SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1007 dkralph 1.34 const Muon * mu,
1008     const Vertex * vtx,
1009     const Array<PFCandidate> * fPFCandidates,
1010     const Array<PileupEnergyDensity> * fPUEnergyDensity,
1011     MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1012     vector<const PFCandidate*> photonsToVeto)
1013 khahn 1.19 //--------------------------------------------------------------------------------------------------
1014     {
1015    
1016     SelectionStatus status;
1017    
1018     double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, fPUEnergyDensity,
1019 khahn 1.30 EffectiveAreaVersion, photonsToVeto);
1020 khahn 1.19 status.isoPF04 = pfIso;
1021     status.chisoPF04 = gChargedIso;
1022     status.gaisoPF04 = gGammaIso;
1023     status.neisoPF04 = gNeutralIso;
1024    
1025     bool pass = false;
1026     if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1027    
1028     if( pass ) {
1029     status.orStatus(SelectionStatus::LOOSEISO);
1030     status.orStatus(SelectionStatus::TIGHTISO);
1031     }
1032 dkralph 1.34 if(ctrl.debug)
1033     cout << " --> mu relpfIso: " << pfIso/mu->Pt() << ", returning status : " << hex << status.getStatus() << dec << endl;
1034 khahn 1.19 return status;
1035     }
1036    
1037     //--------------------------------------------------------------------------------------------------
1038     SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1039 dkralph 1.34 const Electron * ele,
1040     const Vertex * vtx,
1041     const Array<PFCandidate> * fPFCandidates,
1042     const Array<PileupEnergyDensity> * fPUEnergyDensity,
1043     ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1044     vector<const Muon*> muonsToVeto,
1045     vector<const Electron*> electronsToVeto)
1046 khahn 1.19 //--------------------------------------------------------------------------------------------------
1047     {
1048    
1049     if( ctrl.debug ) {
1050     cout << "electronIsoMVASelection :: muons to veto " << endl;
1051     for( int i=0; i<muonsToVeto.size(); i++ ) {
1052 dkralph 1.34 const Muon * vmu = muonsToVeto[i];
1053 khahn 1.19 cout << "\tpt: " << vmu->Pt()
1054     << "\teta: " << vmu->Eta()
1055     << "\tphi: " << vmu->Phi()
1056     << endl;
1057     }
1058     cout << "electronIsoMVASelection :: electrson to veto " << endl;
1059     for( int i=0; i<electronsToVeto.size(); i++ ) {
1060 dkralph 1.34 const Electron * vel = electronsToVeto[i];
1061 khahn 1.19 cout << "\tpt: " << vel->Pt()
1062     << "\teta: " << vel->Eta()
1063     << "\tphi: " << vel->Phi()
1064     << "\ttrk: " << vel->TrackerTrk()
1065     << endl;
1066     }
1067     }
1068    
1069     bool failiso=false;
1070    
1071     //
1072     // tmp iso rings
1073     //
1074     Double_t tmpChargedIso_DR0p0To0p1 = 0;
1075     Double_t tmpChargedIso_DR0p1To0p2 = 0;
1076     Double_t tmpChargedIso_DR0p2To0p3 = 0;
1077     Double_t tmpChargedIso_DR0p3To0p4 = 0;
1078     Double_t tmpChargedIso_DR0p4To0p5 = 0;
1079    
1080     Double_t tmpGammaIso_DR0p0To0p1 = 0;
1081     Double_t tmpGammaIso_DR0p1To0p2 = 0;
1082     Double_t tmpGammaIso_DR0p2To0p3 = 0;
1083     Double_t tmpGammaIso_DR0p3To0p4 = 0;
1084     Double_t tmpGammaIso_DR0p4To0p5 = 0;
1085 khahn 1.21
1086 khahn 1.19
1087     Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
1088     Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
1089     Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
1090     Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
1091     Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
1092    
1093    
1094    
1095     //
1096     // final rings for the MVA
1097     //
1098     Double_t fChargedIso_DR0p0To0p1;
1099     Double_t fChargedIso_DR0p1To0p2;
1100     Double_t fChargedIso_DR0p2To0p3;
1101     Double_t fChargedIso_DR0p3To0p4;
1102     Double_t fChargedIso_DR0p4To0p5;
1103    
1104     Double_t fGammaIso_DR0p0To0p1;
1105     Double_t fGammaIso_DR0p1To0p2;
1106     Double_t fGammaIso_DR0p2To0p3;
1107     Double_t fGammaIso_DR0p3To0p4;
1108     Double_t fGammaIso_DR0p4To0p5;
1109    
1110     Double_t fNeutralHadronIso_DR0p0To0p1;
1111     Double_t fNeutralHadronIso_DR0p1To0p2;
1112     Double_t fNeutralHadronIso_DR0p2To0p3;
1113     Double_t fNeutralHadronIso_DR0p3To0p4;
1114     Double_t fNeutralHadronIso_DR0p4To0p5;
1115    
1116    
1117     //
1118     //Loop over PF Candidates
1119     //
1120     for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1121    
1122     if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1123    
1124 dkralph 1.34 const PFCandidate *pf = (PFCandidate*)((*fPFCandidates)[k]);
1125 khahn 1.19 Double_t deta = (ele->Eta() - pf->Eta());
1126 dkralph 1.34 Double_t dphi = MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1127     Double_t dr = MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1128 khahn 1.21 if (dr > 1.0) continue;
1129    
1130 khahn 1.19 if(ctrl.debug) {
1131     cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1132 anlevin 1.22 if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx);
1133 khahn 1.19 cout << endl;
1134     }
1135    
1136    
1137     if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
1138     (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1139    
1140    
1141     //
1142     // Lepton Footprint Removal
1143     //
1144     Bool_t IsLeptonFootprint = kFALSE;
1145     if (dr < 1.0) {
1146    
1147 khahn 1.21
1148 khahn 1.19 //
1149     // Check for electrons
1150     //
1151 khahn 1.21
1152 khahn 1.19 for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1153 dkralph 1.34 const Electron *tmpele = electronsToVeto[q];
1154     double tmpdr = MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1155 khahn 1.21
1156 khahn 1.19 // 4l electron
1157     if( pf->HasTrackerTrk() ) {
1158     if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
1159     if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1160     IsLeptonFootprint = kTRUE;
1161     }
1162     }
1163     if( pf->HasGsfTrk() ) {
1164     if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1165     if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1166     IsLeptonFootprint = kTRUE;
1167     }
1168     }
1169     // PF charged
1170 khahn 1.21 if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1171 khahn 1.19 if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1172     IsLeptonFootprint = kTRUE;
1173     }
1174     // PF gamma
1175     if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1176 khahn 1.21 && tmpdr < 0.08) {
1177 khahn 1.19 if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1178     IsLeptonFootprint = kTRUE;
1179     }
1180     } // loop over electrons
1181    
1182 khahn 1.21
1183 khahn 1.19 /* KH - comment for sync
1184     //
1185     // Check for muons
1186     //
1187     for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1188 dkralph 1.34 const Muon *tmpmu = muonsToVeto[q];
1189 khahn 1.19 // 4l muon
1190     if( pf->HasTrackerTrk() ) {
1191     if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1192     if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1193     IsLeptonFootprint = kTRUE;
1194     }
1195     }
1196     // PF charged
1197 dkralph 1.34 if (pf->Charge() != 0 && MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1198 khahn 1.19 if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1199     IsLeptonFootprint = kTRUE;
1200     }
1201     } // loop over muons
1202     */
1203    
1204     if (IsLeptonFootprint)
1205     continue;
1206    
1207     //
1208     // Charged Iso Rings
1209     //
1210     if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1211    
1212     // if( pf->HasGsfTrk() ) {
1213     // if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1214     // } else if( pf->HasTrackerTrk() ){
1215     // if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1216     // }
1217    
1218     // Veto any PFmuon, or PFEle
1219     if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1220    
1221     // Footprint Veto
1222     if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
1223    
1224     if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
1225     << "\ttype: " << pf->PFType()
1226     << "\ttrk: " << pf->TrackerTrk() << endl;
1227    
1228     if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
1229     if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
1230     if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1231     if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1232     if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
1233    
1234     }
1235    
1236     //
1237     // Gamma Iso Rings
1238     //
1239     else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1240    
1241 khahn 1.21 if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
1242 khahn 1.19
1243     if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1244     << dr << endl;
1245    
1246     if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
1247     if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
1248     if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1249     if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1250     if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
1251     }
1252    
1253     //
1254     // Other Neutral Iso Rings
1255     //
1256     else {
1257     if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
1258     << dr << endl;
1259     if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
1260     if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
1261     if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1262     if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1263     if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
1264     }
1265    
1266     }
1267    
1268     }
1269    
1270     fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1271     fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1272     fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1273     fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1274     fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1275    
1276 khahn 1.21 if(ctrl.debug) {
1277     cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1 << endl;
1278     cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2 << endl;
1279     cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3 << endl;
1280     cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4 << endl;
1281     cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5 << endl;
1282     }
1283    
1284    
1285 khahn 1.19 double rho = 0;
1286 khahn 1.21 if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1287     rho = fPUEnergyDensity->At(0)->Rho();
1288     // if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
1289     // rho = fPUEnergyDensity->At(0)->RhoLowEta();
1290    
1291 khahn 1.19 // WARNING!!!!
1292     // hardcode for sync ...
1293 khahn 1.21 EffectiveAreaVersion = eleT.kEleEAData2011;
1294 khahn 1.19 // WARNING!!!!
1295    
1296     if( ctrl.debug) {
1297     cout << "RHO: " << rho << endl;
1298     cout << "eta: " << ele->SCluster()->Eta() << endl;
1299     cout << "target: " << EffectiveAreaVersion << endl;
1300     cout << "effA 0-1: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1301     ele->SCluster()->Eta(),
1302     EffectiveAreaVersion)
1303     << endl;
1304     cout << "effA 1-2: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1305     ele->SCluster()->Eta(),
1306     EffectiveAreaVersion)
1307     << endl;
1308     cout << "effA 2-3: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1309     ele->SCluster()->Eta(),
1310     EffectiveAreaVersion)
1311     << endl;
1312     cout << "effA 3-4: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1313     ele->SCluster()->Eta(),
1314     EffectiveAreaVersion)
1315     << endl;
1316 khahn 1.10 }
1317    
1318 khahn 1.19 fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
1319     -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
1320     ele->SCluster()->Eta(),
1321     EffectiveAreaVersion))/ele->Pt()
1322     ,2.5)
1323     ,0.0);
1324     fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
1325     -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
1326     ele->SCluster()->Eta(),
1327     EffectiveAreaVersion))/ele->Pt()
1328     ,2.5)
1329     ,0.0);
1330     fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
1331     -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
1332     ele->SCluster()->Eta()
1333     ,EffectiveAreaVersion))/ele->Pt()
1334     ,2.5)
1335     ,0.0);
1336     fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
1337     -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
1338     ele->SCluster()->Eta(),
1339     EffectiveAreaVersion))/ele->Pt()
1340     ,2.5)
1341     ,0.0);
1342     fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
1343     -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
1344     ele->SCluster()->Eta(),
1345     EffectiveAreaVersion))/ele->Pt()
1346     ,2.5)
1347     ,0.0);
1348 khahn 1.11
1349    
1350 khahn 1.21 if( ctrl.debug) {
1351     cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
1352     cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
1353     cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
1354     cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
1355     cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
1356     }
1357    
1358 khahn 1.19 fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
1359     -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1360     ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1361     , 2.5)
1362     , 0.0);
1363     fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
1364     -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1365     ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1366     , 2.5)
1367     , 0.0);
1368     fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
1369     -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1370     ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1371     , 2.5)
1372     , 0.0);
1373     fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
1374     -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1375     ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1376     , 2.5)
1377     , 0.0);
1378     fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
1379     -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
1380     ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1381     , 2.5)
1382     , 0.0);
1383 khahn 1.10
1384 khahn 1.21 if( ctrl.debug) {
1385     cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
1386     cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
1387     cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
1388     cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
1389     cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
1390     }
1391    
1392 khahn 1.19 double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
1393     ele->SCluster()->Eta(),
1394     fChargedIso_DR0p0To0p1,
1395     fChargedIso_DR0p1To0p2,
1396     fChargedIso_DR0p2To0p3,
1397     fChargedIso_DR0p3To0p4,
1398     fChargedIso_DR0p4To0p5,
1399     fGammaIso_DR0p0To0p1,
1400     fGammaIso_DR0p1To0p2,
1401     fGammaIso_DR0p2To0p3,
1402     fGammaIso_DR0p3To0p4,
1403     fGammaIso_DR0p4To0p5,
1404     fNeutralHadronIso_DR0p0To0p1,
1405     fNeutralHadronIso_DR0p1To0p2,
1406     fNeutralHadronIso_DR0p2To0p3,
1407     fNeutralHadronIso_DR0p3To0p4,
1408     fNeutralHadronIso_DR0p4To0p5,
1409     ctrl.debug);
1410 khahn 1.15
1411 khahn 1.10 SelectionStatus status;
1412 khahn 1.21 status.isoMVA = mvaval;
1413 khahn 1.19 bool pass = false;
1414 khahn 1.15
1415 khahn 1.19 Int_t subdet = 0;
1416     if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
1417     else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
1418     else subdet = 2;
1419 khahn 1.21
1420 khahn 1.19 Int_t ptBin = 0;
1421 khahn 1.21 if (ele->Pt() >= 10.0) ptBin = 1;
1422 khahn 1.19
1423     Int_t MVABin = -1;
1424     if (subdet == 0 && ptBin == 0) MVABin = 0;
1425     if (subdet == 1 && ptBin == 0) MVABin = 1;
1426     if (subdet == 2 && ptBin == 0) MVABin = 2;
1427     if (subdet == 0 && ptBin == 1) MVABin = 3;
1428     if (subdet == 1 && ptBin == 1) MVABin = 4;
1429     if (subdet == 2 && ptBin == 1) MVABin = 5;
1430 khahn 1.15
1431 khahn 1.19 pass = false;
1432 khahn 1.21 if( MVABin == 0 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN0 ) pass = true;
1433     if( MVABin == 1 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN1 ) pass = true;
1434     if( MVABin == 2 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN2 ) pass = true;
1435     if( MVABin == 3 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN3 ) pass = true;
1436     if( MVABin == 4 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN4 ) pass = true;
1437     if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN5 ) pass = true;
1438     // pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
1439 khahn 1.19 if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
1440 khahn 1.15
1441 khahn 1.19 // pass = false;
1442     // if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
1443     // if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
1444     // if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
1445     // if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
1446     // if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
1447     // if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
1448     // if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
1449 khahn 1.15
1450 khahn 1.10 if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1451     return status;
1452    
1453     }
1454    
1455    
1456 khahn 1.4 //--------------------------------------------------------------------------------------------------
1457     SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1458 dkralph 1.34 const Electron * ele,
1459     const Vertex * vtx,
1460     const Array<PFCandidate> * fPFCandidates,
1461 khahn 1.19 float rho,
1462 dkralph 1.34 //const Array<PileupEnergyDensity> * fPUEnergyDensity,
1463     ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1464     vector<const Muon*> muonsToVeto,
1465     vector<const Electron*> electronsToVeto)
1466 khahn 1.4 //--------------------------------------------------------------------------------------------------
1467 khahn 1.19 // hacked version
1468 khahn 1.4 {
1469 khahn 1.19 if( ctrl.debug ) {
1470     cout << "================> hacked ele Iso MVA <======================" << endl;
1471     }
1472 khahn 1.4
1473 khahn 1.7 if( ctrl.debug ) {
1474     cout << "electronIsoMVASelection :: muons to veto " << endl;
1475     for( int i=0; i<muonsToVeto.size(); i++ ) {
1476 dkralph 1.34 const Muon * vmu = muonsToVeto[i];
1477 khahn 1.7 cout << "\tpt: " << vmu->Pt()
1478     << "\teta: " << vmu->Eta()
1479     << "\tphi: " << vmu->Phi()
1480     << endl;
1481     }
1482     cout << "electronIsoMVASelection :: electrson to veto " << endl;
1483     for( int i=0; i<electronsToVeto.size(); i++ ) {
1484 dkralph 1.34 const Electron * vel = electronsToVeto[i];
1485 khahn 1.7 cout << "\tpt: " << vel->Pt()
1486     << "\teta: " << vel->Eta()
1487     << "\tphi: " << vel->Phi()
1488     << "\ttrk: " << vel->TrackerTrk()
1489     << endl;
1490     }
1491     }
1492    
1493 khahn 1.4 bool failiso=false;
1494    
1495     //
1496     // tmp iso rings
1497     //
1498 khahn 1.7 Double_t tmpChargedIso_DR0p0To0p1 = 0;
1499     Double_t tmpChargedIso_DR0p1To0p2 = 0;
1500     Double_t tmpChargedIso_DR0p2To0p3 = 0;
1501 khahn 1.4 Double_t tmpChargedIso_DR0p3To0p4 = 0;
1502     Double_t tmpChargedIso_DR0p4To0p5 = 0;
1503    
1504 khahn 1.7 Double_t tmpGammaIso_DR0p0To0p1 = 0;
1505     Double_t tmpGammaIso_DR0p1To0p2 = 0;
1506     Double_t tmpGammaIso_DR0p2To0p3 = 0;
1507 khahn 1.4 Double_t tmpGammaIso_DR0p3To0p4 = 0;
1508     Double_t tmpGammaIso_DR0p4To0p5 = 0;
1509 khahn 1.19
1510 khahn 1.4
1511 khahn 1.7 Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
1512     Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
1513     Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
1514 khahn 1.4 Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
1515     Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
1516 khahn 1.7
1517 khahn 1.4
1518    
1519     //
1520     // final rings for the MVA
1521     //
1522     Double_t fChargedIso_DR0p0To0p1;
1523     Double_t fChargedIso_DR0p1To0p2;
1524     Double_t fChargedIso_DR0p2To0p3;
1525     Double_t fChargedIso_DR0p3To0p4;
1526     Double_t fChargedIso_DR0p4To0p5;
1527    
1528     Double_t fGammaIso_DR0p0To0p1;
1529     Double_t fGammaIso_DR0p1To0p2;
1530     Double_t fGammaIso_DR0p2To0p3;
1531     Double_t fGammaIso_DR0p3To0p4;
1532     Double_t fGammaIso_DR0p4To0p5;
1533    
1534     Double_t fNeutralHadronIso_DR0p0To0p1;
1535     Double_t fNeutralHadronIso_DR0p1To0p2;
1536     Double_t fNeutralHadronIso_DR0p2To0p3;
1537     Double_t fNeutralHadronIso_DR0p3To0p4;
1538     Double_t fNeutralHadronIso_DR0p4To0p5;
1539    
1540    
1541     //
1542     //Loop over PF Candidates
1543     //
1544     for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1545 khahn 1.19
1546     if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1547    
1548 dkralph 1.34 const PFCandidate *pf = (PFCandidate*)((*fPFCandidates)[k]);
1549 khahn 1.4 Double_t deta = (ele->Eta() - pf->Eta());
1550 dkralph 1.34 Double_t dphi = MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1551     Double_t dr = MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1552 khahn 1.19 if (dr > 1.0) continue;
1553    
1554 khahn 1.7 if(ctrl.debug) {
1555     cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1556 anlevin 1.22 if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx);
1557 khahn 1.7 cout << endl;
1558     }
1559    
1560 khahn 1.4
1561 khahn 1.7 if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
1562     (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1563    
1564 khahn 1.4
1565     //
1566     // Lepton Footprint Removal
1567     //
1568     Bool_t IsLeptonFootprint = kFALSE;
1569     if (dr < 1.0) {
1570    
1571 khahn 1.19
1572 khahn 1.4 //
1573     // Check for electrons
1574     //
1575 khahn 1.19
1576 khahn 1.4 for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1577 dkralph 1.34 const Electron *tmpele = electronsToVeto[q];
1578     double tmpdr = MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1579 khahn 1.19
1580 khahn 1.7 // 4l electron
1581     if( pf->HasTrackerTrk() ) {
1582     if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
1583     if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1584     IsLeptonFootprint = kTRUE;
1585     }
1586     }
1587     if( pf->HasGsfTrk() ) {
1588     if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1589     if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1590     IsLeptonFootprint = kTRUE;
1591     }
1592     }
1593 khahn 1.4 // PF charged
1594 khahn 1.19 if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1595 khahn 1.7 if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1596 khahn 1.4 IsLeptonFootprint = kTRUE;
1597 khahn 1.7 }
1598 khahn 1.4 // PF gamma
1599 khahn 1.19 if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1600     && tmpdr < 0.08) {
1601 khahn 1.7 if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1602 khahn 1.4 IsLeptonFootprint = kTRUE;
1603 khahn 1.7 }
1604 khahn 1.4 } // loop over electrons
1605 khahn 1.14
1606 khahn 1.19
1607 khahn 1.14 /* KH - comment for sync
1608 khahn 1.4 //
1609     // Check for muons
1610     //
1611     for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1612 dkralph 1.34 const Muon *tmpmu = muonsToVeto[q];
1613 khahn 1.7 // 4l muon
1614     if( pf->HasTrackerTrk() ) {
1615     if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1616     if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1617     IsLeptonFootprint = kTRUE;
1618     }
1619     }
1620 khahn 1.4 // PF charged
1621 dkralph 1.34 if (pf->Charge() != 0 && MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1622 khahn 1.7 if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1623 khahn 1.4 IsLeptonFootprint = kTRUE;
1624 khahn 1.7 }
1625 khahn 1.4 } // loop over muons
1626 khahn 1.14 */
1627 khahn 1.4
1628     if (IsLeptonFootprint)
1629     continue;
1630    
1631     //
1632     // Charged Iso Rings
1633     //
1634 khahn 1.7 if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1635    
1636 khahn 1.19 // if( pf->HasGsfTrk() ) {
1637     // if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1638     // } else if( pf->HasTrackerTrk() ){
1639     // if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1640     // }
1641 khahn 1.4
1642     // Veto any PFmuon, or PFEle
1643 khahn 1.7 if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1644 khahn 1.4
1645     // Footprint Veto
1646 khahn 1.7 if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
1647    
1648     if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
1649     << "\ttype: " << pf->PFType()
1650     << "\ttrk: " << pf->TrackerTrk() << endl;
1651    
1652     if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
1653     if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
1654     if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1655     if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1656     if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
1657 khahn 1.4
1658     }
1659    
1660     //
1661     // Gamma Iso Rings
1662     //
1663 khahn 1.7 else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1664    
1665 khahn 1.19 if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
1666 khahn 1.7
1667     if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1668     << dr << endl;
1669    
1670     if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
1671     if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
1672     if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1673     if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1674     if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
1675 khahn 1.4 }
1676    
1677     //
1678     // Other Neutral Iso Rings
1679     //
1680     else {
1681 khahn 1.7 if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
1682     << dr << endl;
1683     if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
1684     if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
1685     if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1686     if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1687     if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
1688 khahn 1.4 }
1689    
1690     }
1691    
1692     }
1693    
1694 khahn 1.19 fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1695     fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1696     fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1697     fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1698     fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1699    
1700     if(ctrl.debug) {
1701     cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1 << endl;
1702     cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2 << endl;
1703     cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3 << endl;
1704     cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4 << endl;
1705     cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5 << endl;
1706     }
1707    
1708 khahn 1.4
1709 khahn 1.19 // rho=0;
1710     // double rho = 0;
1711 khahn 1.18 // if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1712     // rho = fPUEnergyDensity->At(0)->Rho();
1713 khahn 1.19 // if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
1714     // rho = fPUEnergyDensity->At(0)->RhoLowEta();
1715    
1716 khahn 1.18 // WARNING!!!!
1717     // hardcode for sync ...
1718     EffectiveAreaVersion = eleT.kEleEAData2011;
1719     // WARNING!!!!
1720 khahn 1.7
1721     if( ctrl.debug) {
1722     cout << "RHO: " << rho << endl;
1723     cout << "eta: " << ele->SCluster()->Eta() << endl;
1724     cout << "target: " << EffectiveAreaVersion << endl;
1725     cout << "effA 0-1: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1726     ele->SCluster()->Eta(),
1727     EffectiveAreaVersion)
1728     << endl;
1729     cout << "effA 1-2: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1730     ele->SCluster()->Eta(),
1731     EffectiveAreaVersion)
1732     << endl;
1733     cout << "effA 2-3: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1734     ele->SCluster()->Eta(),
1735     EffectiveAreaVersion)
1736     << endl;
1737     cout << "effA 3-4: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1738     ele->SCluster()->Eta(),
1739     EffectiveAreaVersion)
1740     << endl;
1741     }
1742    
1743 khahn 1.19 fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
1744 khahn 1.4 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
1745 khahn 1.7 ele->SCluster()->Eta(),
1746 khahn 1.4 EffectiveAreaVersion))/ele->Pt()
1747     ,2.5)
1748     ,0.0);
1749 khahn 1.19 fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
1750 khahn 1.4 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
1751 khahn 1.7 ele->SCluster()->Eta(),
1752 khahn 1.4 EffectiveAreaVersion))/ele->Pt()
1753     ,2.5)
1754     ,0.0);
1755 khahn 1.19 fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
1756 khahn 1.4 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
1757 khahn 1.7 ele->SCluster()->Eta()
1758 khahn 1.4 ,EffectiveAreaVersion))/ele->Pt()
1759     ,2.5)
1760     ,0.0);
1761 khahn 1.19 fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
1762 khahn 1.4 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
1763 khahn 1.7 ele->SCluster()->Eta(),
1764 khahn 1.4 EffectiveAreaVersion))/ele->Pt()
1765     ,2.5)
1766     ,0.0);
1767 khahn 1.19 fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
1768 khahn 1.4 -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
1769 khahn 1.7 ele->SCluster()->Eta(),
1770 khahn 1.4 EffectiveAreaVersion))/ele->Pt()
1771     ,2.5)
1772     ,0.0);
1773    
1774    
1775 khahn 1.19 if( ctrl.debug) {
1776     cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
1777     cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
1778     cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
1779     cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
1780     cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
1781     }
1782    
1783     fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
1784 khahn 1.4 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1785 khahn 1.7 ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1786 khahn 1.4 , 2.5)
1787     , 0.0);
1788 khahn 1.19 fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
1789 khahn 1.4 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1790 khahn 1.7 ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1791 khahn 1.4 , 2.5)
1792     , 0.0);
1793 khahn 1.19 fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
1794 khahn 1.4 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1795 khahn 1.7 ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1796 khahn 1.4 , 2.5)
1797     , 0.0);
1798 khahn 1.19 fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
1799 khahn 1.4 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1800 khahn 1.7 ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1801 khahn 1.4 , 2.5)
1802     , 0.0);
1803 khahn 1.19 fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
1804 khahn 1.4 -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
1805 khahn 1.7 ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1806 khahn 1.4 , 2.5)
1807     , 0.0);
1808    
1809 khahn 1.19 if( ctrl.debug) {
1810     cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
1811     cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
1812     cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
1813     cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
1814     cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
1815     }
1816    
1817 khahn 1.4 double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
1818 khahn 1.7 ele->SCluster()->Eta(),
1819     fChargedIso_DR0p0To0p1,
1820     fChargedIso_DR0p1To0p2,
1821     fChargedIso_DR0p2To0p3,
1822     fChargedIso_DR0p3To0p4,
1823     fChargedIso_DR0p4To0p5,
1824     fGammaIso_DR0p0To0p1,
1825     fGammaIso_DR0p1To0p2,
1826     fGammaIso_DR0p2To0p3,
1827     fGammaIso_DR0p3To0p4,
1828     fGammaIso_DR0p4To0p5,
1829     fNeutralHadronIso_DR0p0To0p1,
1830     fNeutralHadronIso_DR0p1To0p2,
1831     fNeutralHadronIso_DR0p2To0p3,
1832     fNeutralHadronIso_DR0p3To0p4,
1833     fNeutralHadronIso_DR0p4To0p5,
1834     ctrl.debug);
1835 khahn 1.4
1836     SelectionStatus status;
1837 khahn 1.19 status.isoMVA = mvaval;
1838 khahn 1.4 bool pass = false;
1839    
1840     Int_t subdet = 0;
1841     if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
1842     else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
1843     else subdet = 2;
1844 khahn 1.19
1845 khahn 1.4 Int_t ptBin = 0;
1846 khahn 1.19 if (ele->Pt() >= 10.0) ptBin = 1;
1847 khahn 1.4
1848     Int_t MVABin = -1;
1849     if (subdet == 0 && ptBin == 0) MVABin = 0;
1850     if (subdet == 1 && ptBin == 0) MVABin = 1;
1851     if (subdet == 2 && ptBin == 0) MVABin = 2;
1852     if (subdet == 0 && ptBin == 1) MVABin = 3;
1853     if (subdet == 1 && ptBin == 1) MVABin = 4;
1854     if (subdet == 2 && ptBin == 1) MVABin = 5;
1855    
1856 khahn 1.10 pass = false;
1857     if( MVABin == 0 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN0 ) pass = true;
1858     if( MVABin == 1 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN1 ) pass = true;
1859     if( MVABin == 2 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN2 ) pass = true;
1860     if( MVABin == 3 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN3 ) pass = true;
1861     if( MVABin == 4 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN4 ) pass = true;
1862     if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN5 ) pass = true;
1863     if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
1864    
1865 khahn 1.18 // pass = false;
1866     // if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
1867     // if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
1868     // if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
1869     // if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
1870     // if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
1871     // if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
1872     // if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
1873 khahn 1.7
1874 khahn 1.4 if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1875     return status;
1876 khahn 1.10
1877 khahn 1.4 }
1878    
1879    
1880     //--------------------------------------------------------------------------------------------------
1881     void initElectronIsoMVA() {
1882     //--------------------------------------------------------------------------------------------------
1883 dkralph 1.34 eleIsoMVA = new ElectronIDMVA();
1884 khahn 1.4 vector<string> weightFiles;
1885     weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_BarrelPt5To10.weights.xml");
1886     weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_EndcapPt5To10.weights.xml");
1887     weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_BarrelPt10ToInf.weights.xml");
1888     weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_EndcapPt10ToInf.weights.xml");
1889     eleIsoMVA->Initialize( "ElectronIsoMVA",
1890 dkralph 1.34 ElectronIDMVA::kIsoRingsV0,
1891 khahn 1.4 kTRUE, weightFiles);
1892     }
1893 khahn 1.10
1894    
1895    
1896 khahn 1.21
1897 khahn 1.10 //--------------------------------------------------------------------------------------------------
1898     float electronPFIso04(ControlFlags &ctrl,
1899 dkralph 1.34 const Electron * ele,
1900     const Vertex * vtx,
1901     const Array<PFCandidate> * fPFCandidates,
1902     const Array<PileupEnergyDensity> * fPUEnergyDensity,
1903     ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1904     vector<const PFCandidate*> photonsToVeto)
1905 khahn 1.10 //--------------------------------------------------------------------------------------------------
1906     {
1907    
1908     //
1909     // final iso
1910     //
1911 khahn 1.12 Double_t fChargedIso = 0.0;
1912     Double_t fGammaIso = 0.0;
1913     Double_t fNeutralHadronIso = 0.0;
1914 khahn 1.10
1915    
1916     //
1917     //Loop over PF Candidates
1918     //
1919 dkralph 1.34 if(ctrl.debug) cout << " electronPFIso04(): ----> " << endl;
1920 khahn 1.10 for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1921 khahn 1.21
1922 dkralph 1.34 const PFCandidate *pf = (PFCandidate*)((*fPFCandidates)[k]);
1923 khahn 1.30
1924     //
1925     // veto FSR recovered photons
1926     //
1927     bool vetoPhoton = false;
1928     for( int p=0; p<photonsToVeto.size(); p++ ) {
1929     if( pf == photonsToVeto[p] ) {
1930     vetoPhoton = true;
1931     break;
1932     }
1933     } if( vetoPhoton ) continue;
1934 khahn 1.21
1935 khahn 1.10 Double_t deta = (ele->Eta() - pf->Eta());
1936 dkralph 1.34 Double_t dphi = MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1937     Double_t dr = MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1938 khahn 1.21
1939     if (dr > 0.4) continue;
1940     if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1941    
1942 khahn 1.10 if(ctrl.debug) {
1943 dkralph 1.34 cout << " pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
1944 anlevin 1.22 if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx)
1945 khahn 1.21 << "\ttrk: " << pf->HasTrackerTrk()
1946     << "\tgsf: " << pf->HasGsfTrk();
1947 khahn 1.10 cout << endl;
1948     }
1949    
1950 khahn 1.21 //
1951     // sync : I don't think theyre doing this ...
1952     //
1953     // if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
1954     // (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
1955     // if( ctrl.debug ) cout << "\tskipping, matches to the electron ..." << endl;
1956     // continue;
1957     // }
1958    
1959 khahn 1.10
1960     //
1961     // Lepton Footprint Removal
1962     //
1963     Bool_t IsLeptonFootprint = kFALSE;
1964     if (dr < 1.0) {
1965    
1966 khahn 1.15
1967     //
1968     // Charged Iso
1969     //
1970 khahn 1.21 if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1971 khahn 1.15
1972     // Veto any PFmuon, or PFEle
1973 khahn 1.21 if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) {
1974 dkralph 1.34 if( ctrl.debug ) cout << " skipping, pf is an ele or mu .." <<endl;
1975 khahn 1.21 continue;
1976     }
1977 khahn 1.15
1978     // Footprint Veto
1979     if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
1980    
1981 dkralph 1.34 if( ctrl.debug) cout << " charged:: pt: " << pf->Pt()
1982 khahn 1.15 << "\ttype: " << pf->PFType()
1983     << "\ttrk: " << pf->TrackerTrk() << endl;
1984    
1985     fChargedIso += pf->Pt();
1986     }
1987    
1988     //
1989     // Gamma Iso
1990     //
1991     else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1992    
1993     if (fabs(ele->SCluster()->Eta()) > 1.479) {
1994 dkralph 1.34 if (MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
1995 khahn 1.15 }
1996 anlevin 1.32
1997     assert(ele->HasSuperCluster());
1998     if(ele->GsfTrk()->NExpectedHitsInner()>0 && pf->MvaGamma() > 0.99 && pf->HasSCluster() && ele->SCluster() == pf->SCluster()) continue;
1999    
2000    
2001 dkralph 1.34 if( ctrl.debug) cout << " gamma:: " << pf->Pt() << " "
2002 khahn 1.15 << dr << endl;
2003 khahn 1.19 // KH, add to sync
2004 khahn 1.21 // if( pf->Pt() > 0.5 )
2005 khahn 1.17 fGammaIso += pf->Pt();
2006 khahn 1.15 }
2007    
2008     //
2009     // Neutral Iso
2010     //
2011     else {
2012 dkralph 1.34 if( ctrl.debug) cout << " neutral:: " << pf->Pt() << " "
2013 khahn 1.15 << dr << endl;
2014 khahn 1.19 // KH, add to sync
2015 khahn 1.21 // if( pf->Pt() > 0.5 )
2016 khahn 1.15 fNeutralHadronIso += pf->Pt();
2017     }
2018    
2019     }
2020    
2021     }
2022    
2023 khahn 1.21
2024     double rho=0;
2025 dkralph 1.34 if( (EffectiveAreaVersion == ElectronTools::kEleEAFall11MC) ||
2026     (EffectiveAreaVersion == ElectronTools::kEleEAData2011) ) {
2027 khahn 1.27 if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25()) ||
2028     isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25())))
2029     rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25();
2030     // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2031 dkralph 1.34 EffectiveAreaVersion = ElectronTools::kEleEAData2011;
2032 khahn 1.27 // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2033     } else {
2034     if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJets()) ||
2035     isinf(fPUEnergyDensity->At(0)->RhoKt6PFJets())))
2036     rho = fPUEnergyDensity->At(0)->RhoKt6PFJets();
2037     // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2038 dkralph 1.34 EffectiveAreaVersion = ElectronTools::kEleEAData2012;
2039 khahn 1.27 // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2040     }
2041 dkralph 1.34 if(ctrl.debug) cout << " rho: " << rho << endl;
2042 anlevin 1.24
2043 khahn 1.19 double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2044     -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2045     ele->Eta(),EffectiveAreaVersion)));
2046 khahn 1.15
2047 khahn 1.21
2048 khahn 1.15 gChargedIso = fChargedIso;
2049     gGammaIso = fGammaIso;
2050     gNeutralIso = fNeutralHadronIso;
2051 khahn 1.30
2052     if( ctrl.debug ) {
2053 dkralph 1.34 cout << " PFiso: " << pfIso
2054 khahn 1.30 << "\tfChargedIso: " << fChargedIso
2055     << "\tfGammaIso: " << fGammaIso
2056     << "\tfNeutralHadronIso: " << fNeutralHadronIso
2057     << endl;
2058     }
2059    
2060 khahn 1.15 return pfIso;
2061     }
2062    
2063 khahn 1.10 //--------------------------------------------------------------------------------------------------
2064 khahn 1.11 SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2065 dkralph 1.34 const Electron * ele,
2066     const Vertex * vtx,
2067     const Array<PFCandidate> * fPFCandidates,
2068     const Array<PileupEnergyDensity> * fPUEnergyDensity,
2069     ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2070     vector<const PFCandidate*> photonsToVeto)
2071 khahn 1.10 //--------------------------------------------------------------------------------------------------
2072     {
2073    
2074     SelectionStatus status;
2075    
2076     double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, fPUEnergyDensity,
2077 khahn 1.30 EffectiveAreaVersion, photonsToVeto);
2078 khahn 1.15 status.isoPF04 = pfIso;
2079     status.chisoPF04 = gChargedIso;
2080     status.gaisoPF04 = gGammaIso;
2081     status.neisoPF04 = gNeutralIso;
2082    
2083     bool pass = false;
2084     if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
2085    
2086     if( pass ) {
2087     status.orStatus(SelectionStatus::LOOSEISO);
2088     status.orStatus(SelectionStatus::TIGHTISO);
2089     }
2090 dkralph 1.34 if(ctrl.debug)
2091     cout << " --> ele relpfIso: " << pfIso/ele->Pt() << ", returning status : " << hex << status.getStatus() << dec << endl;
2092 khahn 1.10 return status;
2093     }
2094 khahn 1.29
2095     //--------------------------------------------------------------------------------------------------
2096     double dbetaCorrectedIsoDr03(ControlFlags & ctrl,
2097 dkralph 1.34 const PFCandidate * photon,
2098     const Muon * lepton,
2099     const Array<PFCandidate> * fPFCandidates)
2100 khahn 1.29 //--------------------------------------------------------------------------------------------------
2101     {
2102    
2103     //
2104     // final iso
2105     //
2106     Double_t fChargedIso = 0.0;
2107     Double_t fGammaIso = 0.0;
2108     Double_t fNeutralHadronIso = 0.0;
2109     Double_t fpfPU = 0.0;
2110    
2111     //
2112     // Loop over PF Candidates
2113     //
2114     for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2115    
2116 dkralph 1.34 const PFCandidate *pf = (PFCandidate*)((*fPFCandidates)[k]);
2117 khahn 1.29
2118     Double_t deta = (photon->Eta() - pf->Eta());
2119 dkralph 1.34 Double_t dphi = MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2120     Double_t dr = MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2121 khahn 1.29 if (dr > 0.3) continue;
2122    
2123     if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2124     if( pf->Pt() >= 0.2 && dr > 0.01 )
2125     fpfPU += pf->Pt();
2126     continue;
2127     }
2128    
2129     //
2130     // skip this photon
2131     //
2132 dkralph 1.34 if( abs(pf->PFType()) == PFCandidate::eGamma &&
2133 khahn 1.29 pf->Et() == photon->Et() ) continue;
2134    
2135    
2136     //
2137     // Charged Iso
2138     //
2139     if (pf->Charge() != 0 ) {
2140     if( dr > 0.01 && pf->Pt() >= 0.2 &&
2141     !(pf->TrackerTrk() == lepton->TrackerTrk()) )
2142     fChargedIso += pf->Pt();
2143     }
2144    
2145     //
2146     // Gamma Iso
2147     //
2148 dkralph 1.34 else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2149 khahn 1.29 if( pf->Pt() > 0.5 && dr > 0.01)
2150     fGammaIso += pf->Pt();
2151     }
2152    
2153     //
2154     // Other Neutrals
2155     //
2156     else {
2157     if( pf->Pt() > 0.5 && dr > 0.01)
2158     fNeutralHadronIso += pf->Pt();
2159     }
2160    
2161     }
2162    
2163     if( ctrl.debug ) {
2164 dkralph 1.34 cout << " ---> photon dbetaIso :: " << endl;
2165 khahn 1.29 cout << "\tfChargedIso: " << fChargedIso
2166     << "\tfGammaIso: " << fGammaIso
2167     << "\tfNeutralHadronIso: " << fNeutralHadronIso
2168     << "\tfpfPU: " << fpfPU
2169     << endl;
2170     }
2171     double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso - 0.5*fpfPU;
2172     return pfIso/photon->Pt();
2173     }
2174    
2175    
2176     //--------------------------------------------------------------------------------------------------
2177     double dbetaCorrectedIsoDr03(ControlFlags & ctrl,
2178 dkralph 1.34 const PFCandidate * photon,
2179     const Electron * lepton,
2180     const Array<PFCandidate> * fPFCandidates)
2181 khahn 1.29 //--------------------------------------------------------------------------------------------------
2182     {
2183    
2184     //
2185     // final iso
2186     //
2187     Double_t fChargedIso = 0.0;
2188     Double_t fGammaIso = 0.0;
2189     Double_t fNeutralHadronIso = 0.0;
2190     Double_t fpfPU = 0.0;
2191    
2192     //
2193     // Loop over PF Candidates
2194     //
2195     for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2196    
2197 dkralph 1.34 const PFCandidate *pf = (PFCandidate*)((*fPFCandidates)[k]);
2198 khahn 1.29
2199     Double_t deta = (photon->Eta() - pf->Eta());
2200 dkralph 1.34 Double_t dphi = MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2201     Double_t dr = MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2202 khahn 1.29 if (dr > 0.3) continue;
2203    
2204     if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2205     if( pf->Pt() >= 0.2 && dr > 0.01 )
2206     fpfPU += pf->Pt();
2207     continue;
2208     }
2209    
2210     //
2211     // skip this photon
2212     //
2213 dkralph 1.34 if( abs(pf->PFType()) == PFCandidate::eGamma &&
2214 khahn 1.29 pf->Et() == photon->Et() ) continue;
2215    
2216    
2217     //
2218     // Charged Iso
2219     //
2220     if (pf->Charge() != 0 ) {
2221     if( dr > 0.01 && pf->Pt() >= 0.2 &&
2222     !(pf->TrackerTrk() == lepton->TrackerTrk()) )
2223     fChargedIso += pf->Pt();
2224     }
2225    
2226     //
2227     // Gamma Iso
2228     //
2229 dkralph 1.34 else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2230 khahn 1.29 if( pf->Pt() > 0.5 && dr > 0.01)
2231     fGammaIso += pf->Pt();
2232     }
2233    
2234     //
2235     // Other Neutrals
2236     //
2237     else {
2238     if( pf->Pt() > 0.5 && dr > 0.01)
2239     fNeutralHadronIso += pf->Pt();
2240     }
2241    
2242     }
2243    
2244     if( ctrl.debug ) {
2245 dkralph 1.34 cout << " ---> photon dbetaIso :: " << endl;
2246 khahn 1.29 cout << "\tfChargedIso: " << fChargedIso
2247     << "\tfGammaIso: " << fGammaIso
2248     << "\tfNeutralHadronIso: " << fNeutralHadronIso
2249     << "\tfpfPU: " << fpfPU
2250     << endl;
2251     }
2252     double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso - 0.5*fpfPU;
2253     return pfIso/photon->Pt();
2254     }
2255    
2256    
2257    
2258    
2259    
2260     //--------------------------------------------------------------------------------------------------
2261 khahn 1.30 double nonCorrectedIsoDr03(ControlFlags & ctrl,
2262 dkralph 1.34 const PFCandidate * photon,
2263     const Muon * lepton,
2264     const Array<PFCandidate> * fPFCandidates)
2265 khahn 1.29 //--------------------------------------------------------------------------------------------------
2266     {
2267    
2268     //
2269     // final iso
2270     //
2271     Double_t fChargedIso = 0.0;
2272     Double_t fGammaIso = 0.0;
2273     Double_t fNeutralHadronIso = 0.0;
2274     Double_t fpfPU = 0.0;
2275    
2276     //
2277     // Loop over PF Candidates
2278     //
2279     for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2280    
2281 dkralph 1.34 const PFCandidate *pf = (PFCandidate*)((*fPFCandidates)[k]);
2282 khahn 1.30
2283 khahn 1.29 Double_t deta = (photon->Eta() - pf->Eta());
2284 dkralph 1.34 Double_t dphi = MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2285     Double_t dr = MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2286 khahn 1.29 if (dr > 0.3) continue;
2287    
2288     if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2289     if( pf->Pt() >= 0.2 && dr > 0.01 )
2290     fpfPU += pf->Pt();
2291     continue;
2292     }
2293    
2294     //
2295     // skip this photon
2296     //
2297 dkralph 1.34 if( abs(pf->PFType()) == PFCandidate::eGamma &&
2298 khahn 1.29 pf->Et() == photon->Et() ) continue;
2299    
2300    
2301     //
2302     // Charged Iso
2303     //
2304     if (pf->Charge() != 0 ) {
2305     if( dr > 0.01 && pf->Pt() >= 0.2 &&
2306     !(pf->TrackerTrk() == lepton->TrackerTrk()) )
2307     fChargedIso += pf->Pt();
2308     }
2309    
2310     //
2311     // Gamma Iso
2312     //
2313 dkralph 1.34 else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2314 khahn 1.29 if( pf->Pt() > 0.5 && dr > 0.01)
2315     fGammaIso += pf->Pt();
2316     }
2317    
2318     //
2319     // Other Neutrals
2320     //
2321     else {
2322     if( pf->Pt() > 0.5 && dr > 0.01)
2323     fNeutralHadronIso += pf->Pt();
2324     }
2325    
2326     }
2327    
2328     if( ctrl.debug ) {
2329 dkralph 1.34 cout << " ---> photon dbetaIso :: " << endl;
2330 khahn 1.29 cout << "\tfChargedIso: " << fChargedIso
2331     << "\tfGammaIso: " << fGammaIso
2332     << "\tfNeutralHadronIso: " << fNeutralHadronIso
2333     << "\tfpfPU: " << fpfPU
2334     << endl;
2335 dkralph 1.34 }
2336 khahn 1.29 double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso + fpfPU;
2337     return pfIso/photon->Pt();
2338     }
2339    
2340    
2341 khahn 1.30
2342 khahn 1.29 //--------------------------------------------------------------------------------------------------
2343 khahn 1.30 double nonCorrectedIsoDr03(ControlFlags & ctrl,
2344 dkralph 1.34 const PFCandidate * photon,
2345     const Electron * lepton,
2346     const Array<PFCandidate> * fPFCandidates)
2347 khahn 1.29 //--------------------------------------------------------------------------------------------------
2348     {
2349    
2350     //
2351     // final iso
2352     //
2353     Double_t fChargedIso = 0.0;
2354     Double_t fGammaIso = 0.0;
2355     Double_t fNeutralHadronIso = 0.0;
2356     Double_t fpfPU = 0.0;
2357    
2358     //
2359     // Loop over PF Candidates
2360     //
2361     for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2362    
2363 dkralph 1.34 const PFCandidate *pf = (PFCandidate*)((*fPFCandidates)[k]);
2364 khahn 1.30
2365 khahn 1.29 Double_t deta = (photon->Eta() - pf->Eta());
2366 dkralph 1.34 Double_t dphi = MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2367     Double_t dr = MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2368 khahn 1.29 if (dr > 0.3) continue;
2369    
2370     if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2371     if( pf->Pt() >= 0.2 && dr > 0.01 )
2372     fpfPU += pf->Pt();
2373     continue;
2374     }
2375    
2376     //
2377     // skip this photon
2378     //
2379 dkralph 1.34 if( abs(pf->PFType()) == PFCandidate::eGamma &&
2380 khahn 1.29 pf->Et() == photon->Et() ) continue;
2381    
2382    
2383     //
2384     // Charged Iso
2385     //
2386     if (pf->Charge() != 0 ) {
2387     if( dr > 0.01 && pf->Pt() >= 0.2 &&
2388     !(pf->TrackerTrk() == lepton->TrackerTrk()) )
2389     fChargedIso += pf->Pt();
2390     }
2391    
2392     //
2393     // Gamma Iso
2394     //
2395 dkralph 1.34 else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2396 khahn 1.29 if( pf->Pt() > 0.5 && dr > 0.01)
2397     fGammaIso += pf->Pt();
2398     }
2399    
2400     //
2401     // Other Neutrals
2402     //
2403     else {
2404     if( pf->Pt() > 0.5 && dr > 0.01)
2405     fNeutralHadronIso += pf->Pt();
2406     }
2407    
2408     }
2409    
2410     if( ctrl.debug ) {
2411     cout << "photon dbetaIso :: " << endl;
2412     cout << "\tfChargedIso: " << fChargedIso
2413     << "\tfGammaIso: " << fGammaIso
2414     << "\tfNeutralHadronIso: " << fNeutralHadronIso
2415     << "\tfpfPU: " << fpfPU
2416     << endl;
2417     }
2418     double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso + fpfPU;
2419     return pfIso/photon->Pt();
2420     }
2421    
2422    
2423