ViewVC Help
View File | Revision Log | Show Annotations | Root Listing
root/cvsroot/UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc
(Generate patch)

Comparing UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc (file contents):
Revision 1.13 by khahn, Thu May 10 00:14:35 2012 UTC vs.
Revision 1.26 by anlevin, Mon May 28 12:37:10 2012 UTC

# Line 16 | Line 16 | mithep::MuonTools       muT;
16   mithep::ElectronIDMVA * eleIsoMVA;
17   mithep::ElectronTools   eleT;
18  
19 + // global hack to sync
20 + double gChargedIso;
21 + double gGammaIso;
22 + double gNeutralIso;
23 +
24 + extern vector<bool> PFnoPUflag;
25 +
26   //--------------------------------------------------------------------------------------------------
27   Float_t computePFMuonIso(const mithep::Muon *muon,
28 <                         const mithep::Vertex & vtx,
28 >                         const mithep::Vertex * vtx,
29                           const mithep::Array<mithep::PFCandidate> * fPFCandidates,
30                           const Double_t dRMax)
31   //--------------------------------------------------------------------------------------------------
# Line 27 | Line 34 | Float_t computePFMuonIso(const mithep::M
34    const Double_t neuPtMin = 1.0;
35    const Double_t dzMax    = 0.1;
36      
37 <  Double_t zLepton = (muon->BestTrk()) ? muon->BestTrk()->DzCorrected(vtx) : 0.0;
37 >  Double_t zLepton = (muon->BestTrk()) ? muon->BestTrk()->DzCorrected(*vtx) : 0.0;
38    
39    Float_t iso=0;
40    for(UInt_t ipf=0; ipf<fPFCandidates->GetEntries(); ipf++) {
# Line 39 | Line 46 | Float_t computePFMuonIso(const mithep::M
46      if(pfcand->TrackerTrk() && muon->TrackerTrk() && (pfcand->TrackerTrk()==muon->TrackerTrk())) continue;
47      
48      // dz cut
49 <    Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(vtx) - zLepton) : 0;
49 >    Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(*vtx) - zLepton) : 0;
50      if(dz >= dzMax) continue;
51      
52      // check iso cone
# Line 53 | Line 60 | Float_t computePFMuonIso(const mithep::M
60  
61   //--------------------------------------------------------------------------------------------------
62   Float_t computePFEleIso(const mithep::Electron *electron,
63 <                        const mithep::Vertex & fVertex,
63 >                        const mithep::Vertex * fVertex,
64                          const mithep::Array<mithep::PFCandidate> * fPFCandidates,
65                          const Double_t dRMax)
66   //--------------------------------------------------------------------------------------------------
# Line 62 | Line 69 | Float_t computePFEleIso(const mithep::El
69    const Double_t neuPtMin = 1.0;
70    const Double_t dzMax    = 0.1;
71      
72 <  Double_t zLepton = (electron->BestTrk()) ? electron->BestTrk()->DzCorrected(fVertex) : 0.0;
72 >  Double_t zLepton = (electron->BestTrk()) ? electron->BestTrk()->DzCorrected(*fVertex) : 0.0;
73    
74    Float_t iso=0;
75    for(UInt_t ipf=0; ipf<fPFCandidates->GetEntries(); ipf++) {
# Line 71 | Line 78 | Float_t computePFEleIso(const mithep::El
78      if(!pfcand->HasTrk() && (pfcand->Pt()<=neuPtMin)) continue;  // pT cut on neutral particles
79      
80      // dz cut
81 <    Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(fVertex) - zLepton) : 0;
81 >    Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(*fVertex) - zLepton) : 0;
82      if(dz >= dzMax) continue;
83      
84      // remove THE electron
# Line 175 | Line 182 | bool pairwiseIsoSelection( ControlFlags
182   //--------------------------------------------------------------------------------------------------
183   SelectionStatus muonIsoSelection(ControlFlags &ctrl,
184                                   const mithep::Muon * mu,
185 <                                 const mithep::Vertex & vtx,
185 >                                 const mithep::Vertex * vtx,
186                                   const mithep::Array<mithep::PFCandidate> * fPFCandidateCol   )
187   //--------------------------------------------------------------------------------------------------
188   {
# Line 205 | Line 212 | SelectionStatus muonIsoSelection(Control
212   //--------------------------------------------------------------------------------------------------
213   SelectionStatus electronIsoSelection(ControlFlags &ctrl,
214                                       const mithep::Electron * ele,
215 <                                     const mithep::Vertex &fVertex,
215 >                                     const mithep::Vertex *fVertex,
216                                       const mithep::Array<mithep::PFCandidate> * fPFCandidates)
217   //--------------------------------------------------------------------------------------------------
218   {
# Line 220 | Line 227 | SelectionStatus electronIsoSelection(Con
227    if( ele->IsEB() && ele->Pt() < 20 && reliso > PFISO_ELE_LOOSE_EB_LOWPT ) {
228      failiso = true;
229    }
223 –  if(ctrl.debug) cout << "before iso check ..." << endl;
230    if( !(ele->IsEB()) && ele->Pt() > 20 && reliso > PFISO_ELE_LOOSE_EE_HIGHPT ) {
225 –    if(ctrl.debug) cout << "\tit fails ..." << endl;
231      failiso = true;
232    }
233    if( !(ele->IsEB()) && ele->Pt() < 20 && reliso > PFISO_ELE_LOOSE_EE_LOWPT ) {
# Line 245 | Line 250 | bool noIso(ControlFlags &, vector<Simple
250          return true;
251   }
252  
253 +
254   //--------------------------------------------------------------------------------------------------
255   SelectionStatus muonIsoMVASelection(ControlFlags &ctrl,
256                                      const mithep::Muon * mu,
257 <                                    const mithep::Vertex & vtx,
257 >                                    const mithep::Vertex * vtx,
258                                      const mithep::Array<mithep::PFCandidate> * fPFCandidates,
259                                      const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
260                                      mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
# Line 332 | Line 338 | SelectionStatus muonIsoMVASelection(Cont
338    //Loop over PF Candidates
339    //
340    for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
341 +
342 +    if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
343 +
344      const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
345  
346      Double_t deta = (mu->Eta() - pf->Eta());
# Line 362 | Line 371 | SelectionStatus muonIsoMVASelection(Cont
371              IsLeptonFootprint = kTRUE;
372          }
373          // PF charged
374 <        if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
374 >        if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479
375              && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
376            IsLeptonFootprint = kTRUE;
377          // PF gamma
378 <        if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
378 >        if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
379              && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
380            IsLeptonFootprint = kTRUE;
381        } // loop over electrons
382        
383 +      /* KH - commented for sync
384        //
385        // Check for muons
386        //
# Line 385 | Line 395 | SelectionStatus muonIsoMVASelection(Cont
395          if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
396            IsLeptonFootprint = kTRUE;
397        } // loop over muons
398 <
398 >      */
399  
400      if (IsLeptonFootprint)
401        continue;
# Line 398 | Line 408 | SelectionStatus muonIsoMVASelection(Cont
408        if( dr < 0.01 ) continue; // only for muon iso mva?
409        if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
410  
411 <      if( pf->HasTrackerTrk() ) {
412 <        if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
413 <        if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
414 <                              << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
415 <                              << dr << endl;
416 <      }
417 <      if( pf->HasGsfTrk() ) {
418 <        if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
419 <        if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
420 <                              << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
421 <                              << dr << endl;
422 <      }
411 > //       if( pf->HasTrackerTrk() ) {
412 > //      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
413 > //      if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
414 > //                            << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
415 > //                            << dr << endl;
416 > //       }
417 > //       if( pf->HasGsfTrk() ) {
418 > //      if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
419 > //      if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
420 > //                            << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
421 > //                            << dr << endl;
422 > //       }
423  
424        // Footprint Veto
425        if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
# Line 448 | Line 458 | SelectionStatus muonIsoMVASelection(Cont
458  
459    }
460  
461 <  fChargedIso_DR0p0To0p1   = min((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5);
462 <  fChargedIso_DR0p1To0p2   = min((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5);
463 <  fChargedIso_DR0p2To0p3   = min((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5);
464 <  fChargedIso_DR0p3To0p4   = min((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5);
465 <  fChargedIso_DR0p4To0p5   = min((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5);
461 >  fChargedIso_DR0p0To0p1   = fmin((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5);
462 >  fChargedIso_DR0p1To0p2   = fmin((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5);
463 >  fChargedIso_DR0p2To0p3   = fmin((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5);
464 >  fChargedIso_DR0p3To0p4   = fmin((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5);
465 >  fChargedIso_DR0p4To0p5   = fmin((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5);
466  
467  
468    double rho = 0;
469    if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
470      rho = fPUEnergyDensity->At(0)->Rho();
471 + //   if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
472 + //     rho = fPUEnergyDensity->At(0)->RhoLowEta();
473    
474 +  // WARNING!!!!  
475 +  // hardcode for sync ...
476 +  EffectiveAreaVersion = muT.kMuEAData2011;
477 +  // WARNING!!!!  
478 +
479  
480 <  fGammaIso_DR0p0To0p1 = max(min((tmpGammaIso_DR0p0To0p1
480 >  fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
481                                    -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p0To0p1,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
482                                   ,2.5)
483                               ,0.0);
484 <  fGammaIso_DR0p1To0p2 = max(min((tmpGammaIso_DR0p1To0p2
484 >  fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
485                                    -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p1To0p2,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
486                                   ,2.5)
487                               ,0.0);
488 <  fGammaIso_DR0p2To0p3 = max(min((tmpGammaIso_DR0p2To0p3
488 >  fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
489                                    -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p2To0p3,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
490                                   ,2.5)
491                               ,0.0);
492 <  fGammaIso_DR0p3To0p4 = max(min((tmpGammaIso_DR0p3To0p4
492 >  fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
493                                    -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p3To0p4,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
494                                   ,2.5)
495                               ,0.0);
496 <  fGammaIso_DR0p4To0p5 = max(min((tmpGammaIso_DR0p4To0p5
496 >  fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
497                                    -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p4To0p5,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
498                                   ,2.5)
499                               ,0.0);
500  
501  
502  
503 <  fNeutralHadronIso_DR0p0To0p1 = max(min((tmpNeutralHadronIso_DR0p0To0p1
503 >  fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
504                                            -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p0To0p1,
505                                                                   mu->Eta(),EffectiveAreaVersion))/mu->Pt()
506                                           , 2.5)
507                                       , 0.0);
508 <  fNeutralHadronIso_DR0p1To0p2 = max(min((tmpNeutralHadronIso_DR0p1To0p2
508 >  fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
509                                              -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p1To0p2,
510                                                                     mu->Eta(),EffectiveAreaVersion))/mu->Pt()
511                                             , 2.5)
512                                         , 0.0);
513 <  fNeutralHadronIso_DR0p2To0p3 = max(min((tmpNeutralHadronIso_DR0p2To0p3
513 >  fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
514                                            -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p2To0p3,
515                                                                   mu->Eta(),EffectiveAreaVersion))/mu->Pt()
516                                           , 2.5)
517                                       , 0.0);
518 <  fNeutralHadronIso_DR0p3To0p4 = max(min((tmpNeutralHadronIso_DR0p3To0p4
518 >  fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
519                                            -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p3To0p4,
520                                                                   mu->Eta(), EffectiveAreaVersion))/mu->Pt()
521                                           , 2.5)
522                                       , 0.0);
523 <  fNeutralHadronIso_DR0p4To0p5 = max(min((tmpNeutralHadronIso_DR0p4To0p5
523 >  fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
524                                            -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p4To0p5,
525                                                                   mu->Eta(), EffectiveAreaVersion))/mu->Pt()
526                                           , 2.5)
# Line 511 | Line 528 | SelectionStatus muonIsoMVASelection(Cont
528  
529  
530    double mvaval = muIsoMVA->MVAValue_IsoRings( mu->Pt(),
531 <                                             mu->Eta(),
532 <                                             fChargedIso_DR0p0To0p1,
533 <                                             fChargedIso_DR0p1To0p2,
534 <                                             fChargedIso_DR0p2To0p3,
535 <                                             fChargedIso_DR0p3To0p4,
536 <                                             fChargedIso_DR0p4To0p5,
537 <                                             fGammaIso_DR0p0To0p1,
538 <                                             fGammaIso_DR0p1To0p2,
539 <                                             fGammaIso_DR0p2To0p3,
540 <                                             fGammaIso_DR0p3To0p4,
541 <                                             fGammaIso_DR0p4To0p5,
542 <                                             fNeutralHadronIso_DR0p0To0p1,
543 <                                             fNeutralHadronIso_DR0p1To0p2,
544 <                                             fNeutralHadronIso_DR0p2To0p3,
545 <                                             fNeutralHadronIso_DR0p3To0p4,
546 <                                             fNeutralHadronIso_DR0p4To0p5,
547 <                                             ctrl.debug);
531 >                                               mu->Eta(),
532 >                                               mu->IsGlobalMuon(),
533 >                                               mu->IsTrackerMuon(),
534 >                                               fChargedIso_DR0p0To0p1,
535 >                                               fChargedIso_DR0p1To0p2,
536 >                                               fChargedIso_DR0p2To0p3,
537 >                                               fChargedIso_DR0p3To0p4,
538 >                                               fChargedIso_DR0p4To0p5,
539 >                                               fGammaIso_DR0p0To0p1,
540 >                                               fGammaIso_DR0p1To0p2,
541 >                                               fGammaIso_DR0p2To0p3,
542 >                                               fGammaIso_DR0p3To0p4,
543 >                                               fGammaIso_DR0p4To0p5,
544 >                                               fNeutralHadronIso_DR0p0To0p1,
545 >                                               fNeutralHadronIso_DR0p1To0p2,
546 >                                               fNeutralHadronIso_DR0p2To0p3,
547 >                                               fNeutralHadronIso_DR0p3To0p4,
548 >                                               fNeutralHadronIso_DR0p4To0p5,
549 >                                               ctrl.debug);
550 >
551 >  SelectionStatus status;
552 >  bool pass;
553 >
554 >  pass = false;
555 >  if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
556 >      && fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN0)   pass = true;
557 >  else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
558 >           && fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN1)  pass = true;
559 >  else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
560 >           && fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN2)  pass = true;
561 >  else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
562 >           && fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN3)  pass = true;
563 >  else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN4)  pass = true;
564 >  else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN5)  pass = true;
565 >  if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
566 >
567 >  /*
568 >  pass = false;
569 >  if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
570 >      && fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN0)   pass = true;
571 >  else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
572 >           && fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN1)  pass = true;
573 >  else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
574 >           && fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN2)  pass = true;
575 >  else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
576 >           && fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN3)  pass = true;
577 >  else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN4)  pass = true;
578 >  else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN5)  pass = true;
579 >  if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
580 >  */
581 >
582 >  //  pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
583 >
584 >  status.isoMVA = mvaval;
585 >
586 >  if(ctrl.debug)  {
587 >    cout << "returning status : " << hex << status.getStatus() << dec << endl;
588 >    cout << "MVAVAL : " << status.isoMVA << endl;
589 >  }
590 >  return status;
591 >
592 > }
593 >
594 >
595 > //--------------------------------------------------------------------------------------------------
596 > SelectionStatus muonIsoMVASelection(ControlFlags &ctrl,
597 >                                    const mithep::Muon * mu,
598 >                                    const mithep::Vertex * vtx,
599 >                                    const mithep::Array<mithep::PFCandidate> * fPFCandidates,
600 >                                    float rho,
601 >                                    //const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
602 >                                    mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
603 >                                    vector<const mithep::Muon*> muonsToVeto,
604 >                                    vector<const mithep::Electron*> electronsToVeto)
605 > //--------------------------------------------------------------------------------------------------
606 > // hacked version
607 > {
608 >
609 >  if( ctrl.debug ) {
610 >    cout << "muonIsoMVASelection :: muons to veto " << endl;
611 >    for( int i=0; i<muonsToVeto.size(); i++ ) {
612 >      const mithep::Muon * vmu = muonsToVeto[i];
613 >      cout << "\tpt: " << vmu->Pt()
614 >           << "\teta: " << vmu->Eta()
615 >           << "\tphi: " << vmu->Phi()
616 >           << endl;
617 >    }
618 >    cout << "muonIsoMVASelection :: electrson to veto " << endl;
619 >    for( int i=0; i<electronsToVeto.size(); i++ ) {
620 >      const mithep::Electron * vel = electronsToVeto[i];
621 >      cout << "\tpt: " << vel->Pt()
622 >           << "\teta: " << vel->Eta()
623 >           << "\tphi: " << vel->Phi()
624 >           << endl;
625 >    }
626 >  }
627 >  bool failiso=false;
628 >
629 >  //
630 >  // tmp iso rings
631 >  //
632 >  Double_t tmpChargedIso_DR0p0To0p1  = 0;
633 >  Double_t tmpChargedIso_DR0p1To0p2  = 0;
634 >  Double_t tmpChargedIso_DR0p2To0p3  = 0;
635 >  Double_t tmpChargedIso_DR0p3To0p4  = 0;
636 >  Double_t tmpChargedIso_DR0p4To0p5  = 0;
637 >  Double_t tmpChargedIso_DR0p5To0p7  = 0;
638 >
639 >  Double_t tmpGammaIso_DR0p0To0p1  = 0;
640 >  Double_t tmpGammaIso_DR0p1To0p2  = 0;
641 >  Double_t tmpGammaIso_DR0p2To0p3  = 0;
642 >  Double_t tmpGammaIso_DR0p3To0p4  = 0;
643 >  Double_t tmpGammaIso_DR0p4To0p5  = 0;
644 >  Double_t tmpGammaIso_DR0p5To0p7  = 0;
645 >
646 >  Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
647 >  Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
648 >  Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
649 >  Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
650 >  Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
651 >  Double_t tmpNeutralHadronIso_DR0p5To0p7  = 0;
652 >
653 >        
654 >
655 >  //
656 >  // final rings for the MVA
657 >  //
658 >  Double_t fChargedIso_DR0p0To0p1;
659 >  Double_t fChargedIso_DR0p1To0p2;
660 >  Double_t fChargedIso_DR0p2To0p3;
661 >  Double_t fChargedIso_DR0p3To0p4;
662 >  Double_t fChargedIso_DR0p4To0p5;
663 >  Double_t fChargedIso_DR0p5To0p7;
664 >
665 >  Double_t fGammaIso_DR0p0To0p1;
666 >  Double_t fGammaIso_DR0p1To0p2;
667 >  Double_t fGammaIso_DR0p2To0p3;
668 >  Double_t fGammaIso_DR0p3To0p4;
669 >  Double_t fGammaIso_DR0p4To0p5;
670 >  Double_t fGammaIso_DR0p5To0p7;
671 >
672 >  Double_t fNeutralHadronIso_DR0p0To0p1;
673 >  Double_t fNeutralHadronIso_DR0p1To0p2;
674 >  Double_t fNeutralHadronIso_DR0p2To0p3;
675 >  Double_t fNeutralHadronIso_DR0p3To0p4;
676 >  Double_t fNeutralHadronIso_DR0p4To0p5;
677 >  Double_t fNeutralHadronIso_DR0p5To0p7;
678 >
679 >
680 >  //
681 >  //Loop over PF Candidates
682 >  //
683 >  for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
684 >
685 >    if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
686 >
687 >    const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
688 >
689 >    Double_t deta = (mu->Eta() - pf->Eta());
690 >    Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
691 >    Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
692 >    if (dr > 1.0) continue;
693 >
694 >    if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
695 >
696 >    //
697 >    // Lepton Footprint Removal
698 >    //
699 >    Bool_t IsLeptonFootprint = kFALSE;
700 >    if (dr < 1.0) {
701 >
702 >      //
703 >      // Check for electrons
704 >      //
705 >      for (Int_t q=0; q < electronsToVeto.size(); ++q) {
706 >        const mithep::Electron *tmpele = electronsToVeto[q];
707 >        // 4l electron
708 >        if( pf->HasTrackerTrk() ) {
709 >          if( pf->TrackerTrk() == tmpele->TrackerTrk() )
710 >            IsLeptonFootprint = kTRUE;
711 >        }
712 >        if( pf->HasGsfTrk() ) {
713 >          if( pf->GsfTrk() == tmpele->GsfTrk() )
714 >            IsLeptonFootprint = kTRUE;
715 >        }
716 >        // PF charged
717 >        if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479
718 >            && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
719 >          IsLeptonFootprint = kTRUE;
720 >        // PF gamma
721 >        if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
722 >            && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
723 >          IsLeptonFootprint = kTRUE;
724 >      } // loop over electrons
725 >      
726 >      /* KH - commented for sync
727 >      //
728 >      // Check for muons
729 >      //
730 >      for (Int_t q=0; q < muonsToVeto.size(); ++q) {
731 >        const mithep::Muon *tmpmu = muonsToVeto[q];
732 >        // 4l muon
733 >        if( pf->HasTrackerTrk() ) {
734 >          if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
735 >            IsLeptonFootprint = kTRUE;
736 >        }
737 >        // PF charged
738 >        if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
739 >          IsLeptonFootprint = kTRUE;
740 >      } // loop over muons
741 >      */
742 >
743 >    if (IsLeptonFootprint)
744 >      continue;
745 >
746 >    //
747 >    // Charged Iso Rings
748 >    //
749 >    if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
750 >
751 >      if( dr < 0.01 ) continue; // only for muon iso mva?
752 >      if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
753 >
754 > //       if( pf->HasTrackerTrk() ) {
755 > //      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
756 > //      if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
757 > //                            << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
758 > //                            << dr << endl;
759 > //       }
760 > //       if( pf->HasGsfTrk() ) {
761 > //      if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
762 > //      if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
763 > //                            << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
764 > //                            << dr << endl;
765 > //       }
766 >
767 >      // Footprint Veto
768 >      if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
769 >      if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
770 >      if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
771 >      if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
772 >      if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
773 >      if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
774 >    }
775 >
776 >    //
777 >    // Gamma Iso Rings
778 >    //
779 >    else if (abs(pf->PFType()) == PFCandidate::eGamma) {
780 >      if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
781 >      if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
782 >      if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
783 >      if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
784 >      if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
785 >      if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
786 >    }
787 >
788 >    //
789 >    // Other Neutral Iso Rings
790 >    //
791 >    else {
792 >      if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
793 >      if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
794 >      if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
795 >      if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
796 >      if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
797 >      if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
798 >    }
799 >
800 >    }
801 >
802 >  }
803 >
804 >  fChargedIso_DR0p0To0p1   = fmin((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5);
805 >  fChargedIso_DR0p1To0p2   = fmin((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5);
806 >  fChargedIso_DR0p2To0p3   = fmin((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5);
807 >  fChargedIso_DR0p3To0p4   = fmin((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5);
808 >  fChargedIso_DR0p4To0p5   = fmin((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5);
809 >
810 >
811 > //   double rho = 0;
812 > //   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
813 > //     rho = fPUEnergyDensity->At(0)->Rho();
814 > //   if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
815 > //     rho = fPUEnergyDensity->At(0)->RhoLowEta();
816 >  
817 >  // WARNING!!!!  
818 >  // hardcode for sync ...
819 >  EffectiveAreaVersion = muT.kMuEAData2011;
820 >  // WARNING!!!!  
821 >
822 >
823 >  fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
824 >                                  -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p0To0p1,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
825 >                                 ,2.5)
826 >                             ,0.0);
827 >  fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
828 >                                  -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p1To0p2,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
829 >                                 ,2.5)
830 >                             ,0.0);
831 >  fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
832 >                                  -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p2To0p3,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
833 >                                 ,2.5)
834 >                             ,0.0);
835 >  fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
836 >                                  -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p3To0p4,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
837 >                                 ,2.5)
838 >                             ,0.0);
839 >  fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
840 >                                  -rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p4To0p5,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
841 >                                 ,2.5)
842 >                             ,0.0);
843 >
844 >
845 >
846 >  fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
847 >                                          -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p0To0p1,
848 >                                                                 mu->Eta(),EffectiveAreaVersion))/mu->Pt()
849 >                                         , 2.5)
850 >                                     , 0.0);
851 >  fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
852 >                                            -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p1To0p2,
853 >                                                                   mu->Eta(),EffectiveAreaVersion))/mu->Pt()
854 >                                           , 2.5)
855 >                                       , 0.0);
856 >  fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
857 >                                          -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p2To0p3,
858 >                                                                 mu->Eta(),EffectiveAreaVersion))/mu->Pt()
859 >                                         , 2.5)
860 >                                     , 0.0);
861 >  fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
862 >                                          -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p3To0p4,
863 >                                                                 mu->Eta(), EffectiveAreaVersion))/mu->Pt()
864 >                                         , 2.5)
865 >                                     , 0.0);
866 >  fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
867 >                                          -rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p4To0p5,
868 >                                                                 mu->Eta(), EffectiveAreaVersion))/mu->Pt()
869 >                                         , 2.5)
870 >                                     , 0.0);
871 >
872 >
873 >  double mvaval = muIsoMVA->MVAValue_IsoRings( mu->Pt(),
874 >                                               mu->Eta(),
875 >                                               mu->IsGlobalMuon(),
876 >                                               mu->IsTrackerMuon(),
877 >                                               fChargedIso_DR0p0To0p1,
878 >                                               fChargedIso_DR0p1To0p2,
879 >                                               fChargedIso_DR0p2To0p3,
880 >                                               fChargedIso_DR0p3To0p4,
881 >                                               fChargedIso_DR0p4To0p5,
882 >                                               fGammaIso_DR0p0To0p1,
883 >                                               fGammaIso_DR0p1To0p2,
884 >                                               fGammaIso_DR0p2To0p3,
885 >                                               fGammaIso_DR0p3To0p4,
886 >                                               fGammaIso_DR0p4To0p5,
887 >                                               fNeutralHadronIso_DR0p0To0p1,
888 >                                               fNeutralHadronIso_DR0p1To0p2,
889 >                                               fNeutralHadronIso_DR0p2To0p3,
890 >                                               fNeutralHadronIso_DR0p3To0p4,
891 >                                               fNeutralHadronIso_DR0p4To0p5,
892 >                                               ctrl.debug);
893  
894    SelectionStatus status;
895    bool pass;
# Line 545 | Line 907 | SelectionStatus muonIsoMVASelection(Cont
907    else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN5)  pass = true;
908    if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
909  
910 +  /*
911    pass = false;
912    if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
913        && fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN0)   pass = true;
# Line 557 | Line 920 | SelectionStatus muonIsoMVASelection(Cont
920    else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN4)  pass = true;
921    else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN5)  pass = true;
922    if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
923 +  */
924  
925    //  pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
926  
927 <  if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
927 >  status.isoMVA = mvaval;
928 >
929 >  if(ctrl.debug)  {
930 >    cout << "returning status : " << hex << status.getStatus() << dec << endl;
931 >    cout << "MVAVAL : " << status.isoMVA << endl;
932 >  }
933    return status;
934  
935   }
936  
937 +
938   //--------------------------------------------------------------------------------------------------
939   void initMuonIsoMVA() {
940   //--------------------------------------------------------------------------------------------------
# Line 582 | Line 952 | void initMuonIsoMVA() {
952   }
953  
954  
955 +
956 +
957   //--------------------------------------------------------------------------------------------------
958   double  muonPFIso04(ControlFlags &ctrl,
959                      const mithep::Muon * mu,
960 <                    const mithep::Vertex & vtx,
960 >                    const mithep::Vertex * vtx,
961                      const mithep::Array<mithep::PFCandidate> * fPFCandidates,
962                      const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
963                      mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
# Line 593 | Line 965 | double  muonPFIso04(ControlFlags &ctrl,
965                      vector<const mithep::Electron*> electronsToVeto)
966   //--------------------------------------------------------------------------------------------------
967   {
968 +
969 +  extern double gChargedIso;  
970 +  extern double  gGammaIso;      
971 +  extern double  gNeutralIso;
972    
973    if( ctrl.debug ) {
974      cout << "muonIsoMVASelection :: muons to veto " << endl;
# Line 624 | Line 1000 | double  muonPFIso04(ControlFlags &ctrl,
1000    //Loop over PF Candidates
1001    //
1002    for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1003 +
1004 +    if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1005      const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1006  
1007      Double_t deta = (mu->Eta() - pf->Eta());
# Line 655 | Line 1033 | double  muonPFIso04(ControlFlags &ctrl,
1033          }
1034          // PF charged
1035          if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1036 <            && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
1036 >            && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
1037 >          if( ctrl.debug) cout << "\tcharged trk, dR ("
1038 >                               << mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta())
1039 >                               << " matches 4L ele ..." << endl;
1040            IsLeptonFootprint = kTRUE;
1041 +        }
1042          // PF gamma
1043          if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1044              && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
1045            IsLeptonFootprint = kTRUE;
1046        } // loop over electrons
1047 <      
1047 >
1048 >      /* KH - comment for sync      
1049        //
1050        // Check for muons
1051        //
# Line 677 | Line 1060 | double  muonPFIso04(ControlFlags &ctrl,
1060          if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
1061            IsLeptonFootprint = kTRUE;
1062        } // loop over muons
1063 +      */
1064 +
1065 +    if (IsLeptonFootprint)
1066 +      continue;
1067 +
1068 +    //
1069 +    // Charged Iso
1070 +    //
1071 +    if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1072 +
1073 +      //if( dr < 0.01 ) continue; // only for muon iso mva?
1074 +      if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1075 +
1076 +
1077 + //       if( pf->HasTrackerTrk() ) {
1078 + //      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1079 + //      if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1080 + //                            << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1081 + //                            << dr << endl;
1082 + //       }
1083 + //       if( pf->HasGsfTrk() ) {
1084 + //      if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1085 + //      if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1086 + //                            << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1087 + //                            << dr << endl;
1088 + //       }
1089 +
1090 +
1091 +      fChargedIso += pf->Pt();
1092 +    }
1093 +
1094 +    //
1095 +    // Gamma Iso
1096 +    //
1097 +    else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1098 +      // KH, add to sync
1099 +      if( pf->Pt() > 0.5 )
1100 +      fGammaIso += pf->Pt();
1101 +    }
1102 +
1103 +    //
1104 +    // Other Neutrals
1105 +    //
1106 +    else {
1107 +      // KH, add to sync
1108 +      if( pf->Pt() > 0.5 )
1109 +        fNeutralHadronIso += pf->Pt();
1110 +    }
1111 +    
1112 +    }
1113 +    
1114 +  }
1115 +
1116 +  double rho=0;
1117 +  if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral()) || isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral())))
1118 +    rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral();
1119 +
1120 +
1121 +  double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1122 +                                        -rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
1123 +                                                                   mu->Eta(),EffectiveAreaVersion)));
1124 +  gChargedIso = fChargedIso;
1125 +  gGammaIso   = fGammaIso;
1126 +  gNeutralIso = fNeutralHadronIso;
1127 +  
1128 +  return pfIso;
1129 + }
1130 +
1131 +
1132 +
1133 +
1134 + //--------------------------------------------------------------------------------------------------
1135 + // hacked version
1136 + double  muonPFIso04(ControlFlags &ctrl,
1137 +                    const mithep::Muon * mu,
1138 +                    const mithep::Vertex * vtx,
1139 +                    const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1140 +                    float rho,
1141 +                    mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1142 +                    vector<const mithep::Muon*> muonsToVeto,
1143 +                    vector<const mithep::Electron*> electronsToVeto)
1144 + //--------------------------------------------------------------------------------------------------
1145 + {
1146 +
1147 +  extern double gChargedIso;  
1148 +  extern double  gGammaIso;      
1149 +  extern double  gNeutralIso;
1150 +  
1151 +  if( ctrl.debug ) {
1152 +    cout << "muonIsoMVASelection :: muons to veto " << endl;
1153 +    for( int i=0; i<muonsToVeto.size(); i++ ) {
1154 +      const mithep::Muon * vmu = muonsToVeto[i];
1155 +      cout << "\tpt: " << vmu->Pt()
1156 +           << "\teta: " << vmu->Eta()
1157 +           << "\tphi: " << vmu->Phi()
1158 +           << endl;
1159 +    }
1160 +    cout << "muonIsoMVASelection :: electrson to veto " << endl;
1161 +    for( int i=0; i<electronsToVeto.size(); i++ ) {
1162 +      const mithep::Electron * vel = electronsToVeto[i];
1163 +      cout << "\tpt: " << vel->Pt()
1164 +           << "\teta: " << vel->Eta()
1165 +           << "\tphi: " << vel->Phi()
1166 +           << endl;
1167 +    }
1168 +  }
1169 +
1170 +  //
1171 +  // final iso
1172 +  //
1173 +  Double_t fChargedIso  = 0.0;
1174 +  Double_t fGammaIso  = 0.0;
1175 +  Double_t fNeutralHadronIso  = 0.0;
1176 +
1177 +  //
1178 +  //Loop over PF Candidates
1179 +  //
1180 +  for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1181 +
1182 +    if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1183 +    const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1184 +
1185 +    Double_t deta = (mu->Eta() - pf->Eta());
1186 +    Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
1187 +    Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
1188 +    if (dr > 0.4) continue;
1189 +
1190 +    if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
1191 +
1192 +    //
1193 +    // Lepton Footprint Removal
1194 +    //
1195 +    Bool_t IsLeptonFootprint = kFALSE;
1196 +    if (dr < 1.0) {
1197 +
1198 +      //
1199 +      // Check for electrons
1200 +      //
1201 +      for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1202 +        const mithep::Electron *tmpele = electronsToVeto[q];
1203 +        // 4l electron
1204 +        if( pf->HasTrackerTrk() ) {
1205 +          if( pf->TrackerTrk() == tmpele->TrackerTrk() )
1206 +            IsLeptonFootprint = kTRUE;
1207 +        }
1208 +        if( pf->HasGsfTrk() ) {
1209 +          if( pf->GsfTrk() == tmpele->GsfTrk() )
1210 +            IsLeptonFootprint = kTRUE;
1211 +        }
1212 +        // PF charged
1213 +        if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1214 +            && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
1215 +          IsLeptonFootprint = kTRUE;
1216 +        // PF gamma
1217 +        if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1218 +            && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
1219 +          IsLeptonFootprint = kTRUE;
1220 +      } // loop over electrons
1221  
1222 +      /* KH - comment for sync      
1223 +      //
1224 +      // Check for muons
1225 +      //
1226 +      for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1227 +        const mithep::Muon *tmpmu = muonsToVeto[q];
1228 +        // 4l muon
1229 +        if( pf->HasTrackerTrk() ) {
1230 +          if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
1231 +            IsLeptonFootprint = kTRUE;
1232 +        }
1233 +        // PF charged
1234 +        if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
1235 +          IsLeptonFootprint = kTRUE;
1236 +      } // loop over muons
1237 +      */
1238  
1239      if (IsLeptonFootprint)
1240        continue;
1241  
1242      //
1243 <    // Charged Iso Rings
1243 >    // Charged Iso
1244      //
1245      if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1246  
1247 <      if( dr < 0.01 ) continue; // only for muon iso mva?
1247 >      //if( dr < 0.01 ) continue; // only for muon iso mva?
1248        if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1249  
1250 <      if( pf->HasTrackerTrk() ) {
1251 <        if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1252 <        if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1253 <                              << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1254 <                              << dr << endl;
1255 <      }
1256 <      if( pf->HasGsfTrk() ) {
1257 <        if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1258 <        if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1259 <                              << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1260 <                              << dr << endl;
1261 <      }
1250 >
1251 > //       if( pf->HasTrackerTrk() ) {
1252 > //      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1253 > //      if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1254 > //                            << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1255 > //                            << dr << endl;
1256 > //       }
1257 > //       if( pf->HasGsfTrk() ) {
1258 > //      if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1259 > //      if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1260 > //                            << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1261 > //                            << dr << endl;
1262 > //       }
1263  
1264  
1265        fChargedIso += pf->Pt();
# Line 711 | Line 1269 | double  muonPFIso04(ControlFlags &ctrl,
1269      // Gamma Iso
1270      //
1271      else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1272 +      // KH, add to sync
1273 +      if( pf->Pt() > 0.5 )
1274        fGammaIso += pf->Pt();
1275      }
1276  
1277      //
1278 <    // Other Neutral Iso Rings
1278 >    // Other Neutrals
1279      //
1280      else {
1281 <      fNeutralHadronIso += pf->Pt();
1281 >      // KH, add to sync
1282 >      if( pf->Pt() > 0.5 )
1283 >        fNeutralHadronIso += pf->Pt();
1284      }
1285      
1286      }
1287      
1288    }
1289    
1290 <  double rho = 0;
1291 <  if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1292 <    rho = fPUEnergyDensity->At(0)->Rho();
1290 > //   double rho = 0;
1291 > //   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1292 > //     rho = fPUEnergyDensity->At(0)->Rho();
1293  
1294    // WARNING!!!!  
1295    // hardcode for sync ...
# Line 735 | Line 1297 | double  muonPFIso04(ControlFlags &ctrl,
1297    // WARNING!!!!  
1298  
1299  
1300 <  double pfIso = fChargedIso + max(0.0,(fGammaIso + fNeutralHadronIso
1300 >  double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1301                                          -rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
1302                                                                     mu->Eta(),EffectiveAreaVersion)));
1303 +  gChargedIso = fChargedIso;
1304 +  gGammaIso   = fGammaIso;
1305 +  gNeutralIso = fNeutralHadronIso;
1306    
1307    return pfIso;
1308   }
1309  
1310 +
1311   //--------------------------------------------------------------------------------------------------
1312   SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1313                                            const mithep::Muon * mu,
1314 <                                          const mithep::Vertex & vtx,
1314 >                                          const mithep::Vertex * vtx,
1315                                            const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1316                                            const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1317                                            mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
# Line 755 | Line 1321 | SelectionStatus muonReferenceIsoSelectio
1321   {
1322    
1323    SelectionStatus status;
1324 <  
1324 >
1325    double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, fPUEnergyDensity,
1326                                EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1327 +  //  cout << "--------------> setting muon isoPF04 to" << pfIso << endl;
1328 +  status.isoPF04 = pfIso;
1329 +  status.chisoPF04 = gChargedIso;
1330 +  status.gaisoPF04 = gGammaIso;
1331 +  status.neisoPF04 = gNeutralIso;
1332 +
1333 +  bool pass = false;
1334 +  if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1335 +  
1336 +  if( pass ) {
1337 +    status.orStatus(SelectionStatus::LOOSEISO);
1338 +    status.orStatus(SelectionStatus::TIGHTISO);
1339 +  }
1340 +  if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1341 +  return status;
1342 +  
1343 + }
1344 +
1345 +
1346 + //--------------------------------------------------------------------------------------------------
1347 + // hacked version
1348 + SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1349 +                                          const mithep::Muon * mu,
1350 +                                          const mithep::Vertex * vtx,
1351 +                                          const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1352 +                                          float rho,
1353 +                                          mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1354 +                                          vector<const mithep::Muon*> muonsToVeto,
1355 +                                          vector<const mithep::Electron*> electronsToVeto)
1356 + //--------------------------------------------------------------------------------------------------
1357 + {
1358 +  
1359 +  SelectionStatus status;
1360 +  
1361 +  double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, rho,
1362 +                              EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1363 +
1364 +  status.isoPF04 = pfIso;
1365 +  status.chisoPF04 = gChargedIso;
1366 +  status.gaisoPF04 = gGammaIso;
1367 +  status.neisoPF04 = gNeutralIso;
1368 +
1369    bool pass = false;
1370    if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1371    
# Line 772 | Line 1380 | SelectionStatus muonReferenceIsoSelectio
1380  
1381  
1382  
1383 +
1384   //--------------------------------------------------------------------------------------------------
1385   SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1386                                          const mithep::Electron * ele,
1387 <                                        const mithep::Vertex & vtx,
1387 >                                        const mithep::Vertex * vtx,
1388                                          const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1389                                          const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1390                                          mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
# Line 814 | Line 1423 | SelectionStatus electronIsoMVASelection(
1423    Double_t tmpChargedIso_DR0p2To0p3  = 0;
1424    Double_t tmpChargedIso_DR0p3To0p4  = 0;
1425    Double_t tmpChargedIso_DR0p4To0p5  = 0;
817 –  Double_t tmpChargedIso_DR0p5To0p7  = 0;
1426  
1427    Double_t tmpGammaIso_DR0p0To0p1  = 0;
1428    Double_t tmpGammaIso_DR0p1To0p2  = 0;
1429    Double_t tmpGammaIso_DR0p2To0p3  = 0;
1430    Double_t tmpGammaIso_DR0p3To0p4  = 0;
1431    Double_t tmpGammaIso_DR0p4To0p5  = 0;
1432 <  Double_t tmpGammaIso_DR0p5To0p7  = 0;
1432 >
1433  
1434    Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
1435    Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
1436    Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
1437    Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
1438    Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
831 –  Double_t tmpNeutralHadronIso_DR0p5To0p7  = 0;
1439  
1440          
1441  
# Line 858 | Line 1465 | SelectionStatus electronIsoMVASelection(
1465    //Loop over PF Candidates
1466    //
1467    for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1468 +
1469 +    if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1470 +
1471      const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1472      Double_t deta = (ele->Eta() - pf->Eta());
1473      Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1474      Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1475 <    if (dr >= 0.5) continue;
1475 >    if (dr > 1.0) continue;
1476 >
1477      if(ctrl.debug) {
1478        cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1479 <      if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
1479 >      if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx);
1480        cout << endl;
1481      }
1482  
# Line 880 | Line 1491 | SelectionStatus electronIsoMVASelection(
1491      Bool_t IsLeptonFootprint = kFALSE;
1492      if (dr < 1.0) {
1493  
1494 +
1495        //
1496        // Check for electrons
1497        //
1498 +
1499        for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1500          const mithep::Electron *tmpele = electronsToVeto[q];
1501 +        double tmpdr = mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1502 +
1503          // 4l electron
1504          if( pf->HasTrackerTrk()  ) {
1505            if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
# Line 899 | Line 1514 | SelectionStatus electronIsoMVASelection(
1514            }
1515          }
1516          // PF charged
1517 <        if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
903 <            && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
1517 >        if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1518            if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1519            IsLeptonFootprint = kTRUE;
1520          }
1521          // PF gamma
1522 <        if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1523 <            && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
1522 >        if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1523 >            && tmpdr < 0.08) {
1524            if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1525            IsLeptonFootprint = kTRUE;
1526          }
1527        } // loop over electrons
1528 <      
1528 >
1529 >
1530 >      /* KH - comment for sync            
1531        //
1532        // Check for muons
1533        //
# Line 930 | Line 1546 | SelectionStatus electronIsoMVASelection(
1546            IsLeptonFootprint = kTRUE;
1547          }
1548        } // loop over muons
1549 <
1549 >      */
1550  
1551      if (IsLeptonFootprint)
1552        continue;
# Line 940 | Line 1556 | SelectionStatus electronIsoMVASelection(
1556      //
1557      if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1558  
1559 <      if( pf->HasTrackerTrk() )
1560 <        if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1561 <      if( pf->HasGsfTrk() )
1562 <        if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1559 > //       if( pf->HasGsfTrk() ) {
1560 > //       if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1561 > //       } else if( pf->HasTrackerTrk() ){
1562 > //      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1563 > //       }
1564  
1565        // Veto any PFmuon, or PFEle
1566        if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
# Line 960 | Line 1577 | SelectionStatus electronIsoMVASelection(
1577        if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1578        if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1579        if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
963 –      if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
1580  
1581      }
1582  
# Line 969 | Line 1585 | SelectionStatus electronIsoMVASelection(
1585      //
1586      else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1587  
1588 <      if (fabs(ele->SCluster()->Eta()) > 1.479) {
973 <        if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
974 <      }
1588 >      if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
1589  
1590        if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1591                             << dr << endl;
# Line 981 | Line 1595 | SelectionStatus electronIsoMVASelection(
1595        if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1596        if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1597        if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
984 –      if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
985 –
1598      }
1599  
1600      //
# Line 996 | Line 1608 | SelectionStatus electronIsoMVASelection(
1608        if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1609        if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1610        if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
999 –      if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
1611      }
1612  
1613      }
1614  
1615    }
1616  
1617 <  fChargedIso_DR0p0To0p1   = min((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1618 <  fChargedIso_DR0p1To0p2   = min((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1619 <  fChargedIso_DR0p2To0p3   = min((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1620 <  fChargedIso_DR0p3To0p4   = min((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1621 <  fChargedIso_DR0p4To0p5   = min((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1617 >  fChargedIso_DR0p0To0p1   = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1618 >  fChargedIso_DR0p1To0p2   = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1619 >  fChargedIso_DR0p2To0p3   = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1620 >  fChargedIso_DR0p3To0p4   = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1621 >  fChargedIso_DR0p4To0p5   = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1622 >
1623 >  if(ctrl.debug) {
1624 >    cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1  << endl;
1625 >    cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2  << endl;
1626 >    cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3  << endl;
1627 >    cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4  << endl;
1628 >    cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5  << endl;
1629 >  }
1630 >
1631  
1632    double rho = 0;
1633    if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1634      rho = fPUEnergyDensity->At(0)->Rho();
1635 +  //   if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
1636 +  //     rho = fPUEnergyDensity->At(0)->RhoLowEta();
1637 +  
1638 +  // WARNING!!!!  
1639 +  // hardcode for sync ...
1640 +  EffectiveAreaVersion = eleT.kEleEAData2011;
1641 +  // WARNING!!!!  
1642  
1643    if( ctrl.debug) {
1644      cout << "RHO: " << rho << endl;
# Line 1035 | Line 1662 | SelectionStatus electronIsoMVASelection(
1662           << endl;
1663    }
1664  
1665 <  fGammaIso_DR0p0To0p1 = max(min((tmpGammaIso_DR0p0To0p1
1665 >  fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
1666                                    -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
1667                                                                ele->SCluster()->Eta(),
1668                                                                EffectiveAreaVersion))/ele->Pt()
1669                                   ,2.5)
1670                               ,0.0);
1671 <  fGammaIso_DR0p1To0p2 = max(min((tmpGammaIso_DR0p1To0p2
1671 >  fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
1672                                    -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
1673                                                                ele->SCluster()->Eta(),
1674                                                                EffectiveAreaVersion))/ele->Pt()
1675                                   ,2.5)
1676                               ,0.0);
1677 <  fGammaIso_DR0p2To0p3 = max(min((tmpGammaIso_DR0p2To0p3
1677 >  fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
1678                                    -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
1679                                                                ele->SCluster()->Eta()
1680                                                                ,EffectiveAreaVersion))/ele->Pt()
1681                                   ,2.5)
1682                               ,0.0);
1683 <  fGammaIso_DR0p3To0p4 = max(min((tmpGammaIso_DR0p3To0p4
1683 >  fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
1684                                    -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
1685                                                                ele->SCluster()->Eta(),
1686                                                                EffectiveAreaVersion))/ele->Pt()
1687                                   ,2.5)
1688                               ,0.0);
1689 <  fGammaIso_DR0p4To0p5 = max(min((tmpGammaIso_DR0p4To0p5
1689 >  fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
1690                                    -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
1691                                                                ele->SCluster()->Eta(),
1692                                                                EffectiveAreaVersion))/ele->Pt()
# Line 1067 | Line 1694 | SelectionStatus electronIsoMVASelection(
1694                               ,0.0);
1695  
1696  
1697 <  fNeutralHadronIso_DR0p0To0p1 = max(min((tmpNeutralHadronIso_DR0p0To0p1
1697 >  if( ctrl.debug) {
1698 >    cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
1699 >    cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
1700 >    cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
1701 >    cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
1702 >    cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
1703 >  }
1704 >
1705 >  fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
1706                                            -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1707                                                                   ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1708                                           , 2.5)
1709                                       , 0.0);
1710 <  fNeutralHadronIso_DR0p1To0p2 = max(min((tmpNeutralHadronIso_DR0p1To0p2
1710 >  fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
1711                                              -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1712                                                                     ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1713                                             , 2.5)
1714                                         , 0.0);
1715 <  fNeutralHadronIso_DR0p2To0p3 = max(min((tmpNeutralHadronIso_DR0p2To0p3
1715 >  fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
1716                                            -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1717                                                                   ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1718                                           , 2.5)
1719                                       , 0.0);
1720 <  fNeutralHadronIso_DR0p3To0p4 = max(min((tmpNeutralHadronIso_DR0p3To0p4
1720 >  fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
1721                                            -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1722                                                                   ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1723                                           , 2.5)
1724                                       , 0.0);
1725 <  fNeutralHadronIso_DR0p4To0p5 = max(min((tmpNeutralHadronIso_DR0p4To0p5
1725 >  fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
1726                                            -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
1727                                                                   ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1728                                           , 2.5)
1729                                       , 0.0);
1730  
1731 +  if( ctrl.debug) {
1732 +    cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
1733 +    cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
1734 +    cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
1735 +    cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
1736 +    cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
1737 +  }
1738 +
1739    double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
1740                                                  ele->SCluster()->Eta(),
1741                                                  fChargedIso_DR0p0To0p1,
# Line 1113 | Line 1756 | SelectionStatus electronIsoMVASelection(
1756                                                  ctrl.debug);
1757  
1758    SelectionStatus status;
1759 +  status.isoMVA = mvaval;
1760    bool pass = false;
1761  
1762    Int_t subdet = 0;
1763    if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
1764    else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
1765    else subdet = 2;
1766 +
1767    Int_t ptBin = 0;
1768 <  if (ele->Pt() > 10.0) ptBin = 1;
1768 >  if (ele->Pt() >= 10.0) ptBin = 1;
1769 >  
1770 >  Int_t MVABin = -1;
1771 >  if (subdet == 0 && ptBin == 0) MVABin = 0;
1772 >  if (subdet == 1 && ptBin == 0) MVABin = 1;
1773 >  if (subdet == 2 && ptBin == 0) MVABin = 2;
1774 >  if (subdet == 0 && ptBin == 1) MVABin = 3;
1775 >  if (subdet == 1 && ptBin == 1) MVABin = 4;
1776 >  if (subdet == 2 && ptBin == 1) MVABin = 5;
1777 >
1778 >  pass = false;
1779 >  if( MVABin == 0 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN0 ) pass = true;
1780 >  if( MVABin == 1 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN1 ) pass = true;
1781 >  if( MVABin == 2 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN2 ) pass = true;
1782 >  if( MVABin == 3 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN3 ) pass = true;
1783 >  if( MVABin == 4 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN4 ) pass = true;
1784 >  if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN5 ) pass = true;
1785 >  //  pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
1786 >  if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
1787 >
1788 > //   pass = false;
1789 > //   if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
1790 > //   if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
1791 > //   if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
1792 > //   if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
1793 > //   if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
1794 > //   if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
1795 > //   if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
1796 >
1797 >  if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1798 >  return status;
1799 >  
1800 > }
1801 >
1802 >
1803 > //--------------------------------------------------------------------------------------------------
1804 > SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1805 >                                        const mithep::Electron * ele,
1806 >                                        const mithep::Vertex * vtx,
1807 >                                        const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1808 >                                        float rho,
1809 >                                        //const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1810 >                                        mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1811 >                                        vector<const mithep::Muon*> muonsToVeto,
1812 >                                        vector<const mithep::Electron*> electronsToVeto)
1813 > //--------------------------------------------------------------------------------------------------
1814 > // hacked version
1815 > {
1816 >  if( ctrl.debug ) {
1817 >    cout << "================> hacked ele Iso MVA <======================" << endl;
1818 >  }
1819 >
1820 >  if( ctrl.debug ) {
1821 >    cout << "electronIsoMVASelection :: muons to veto " << endl;
1822 >    for( int i=0; i<muonsToVeto.size(); i++ ) {
1823 >      const mithep::Muon * vmu = muonsToVeto[i];
1824 >      cout << "\tpt: " << vmu->Pt()
1825 >           << "\teta: " << vmu->Eta()
1826 >           << "\tphi: " << vmu->Phi()
1827 >           << endl;
1828 >    }
1829 >    cout << "electronIsoMVASelection :: electrson to veto " << endl;
1830 >    for( int i=0; i<electronsToVeto.size(); i++ ) {
1831 >      const mithep::Electron * vel = electronsToVeto[i];
1832 >      cout << "\tpt: " << vel->Pt()
1833 >           << "\teta: " << vel->Eta()
1834 >           << "\tphi: " << vel->Phi()
1835 >           << "\ttrk: " << vel->TrackerTrk()
1836 >           << endl;
1837 >    }
1838 >  }
1839 >
1840 >  bool failiso=false;
1841 >
1842 >  //
1843 >  // tmp iso rings
1844 >  //
1845 >  Double_t tmpChargedIso_DR0p0To0p1  = 0;
1846 >  Double_t tmpChargedIso_DR0p1To0p2  = 0;
1847 >  Double_t tmpChargedIso_DR0p2To0p3  = 0;
1848 >  Double_t tmpChargedIso_DR0p3To0p4  = 0;
1849 >  Double_t tmpChargedIso_DR0p4To0p5  = 0;
1850 >
1851 >  Double_t tmpGammaIso_DR0p0To0p1  = 0;
1852 >  Double_t tmpGammaIso_DR0p1To0p2  = 0;
1853 >  Double_t tmpGammaIso_DR0p2To0p3  = 0;
1854 >  Double_t tmpGammaIso_DR0p3To0p4  = 0;
1855 >  Double_t tmpGammaIso_DR0p4To0p5  = 0;
1856 >
1857 >
1858 >  Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
1859 >  Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
1860 >  Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
1861 >  Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
1862 >  Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
1863 >
1864 >        
1865 >
1866 >  //
1867 >  // final rings for the MVA
1868 >  //
1869 >  Double_t fChargedIso_DR0p0To0p1;
1870 >  Double_t fChargedIso_DR0p1To0p2;
1871 >  Double_t fChargedIso_DR0p2To0p3;
1872 >  Double_t fChargedIso_DR0p3To0p4;
1873 >  Double_t fChargedIso_DR0p4To0p5;
1874 >
1875 >  Double_t fGammaIso_DR0p0To0p1;
1876 >  Double_t fGammaIso_DR0p1To0p2;
1877 >  Double_t fGammaIso_DR0p2To0p3;
1878 >  Double_t fGammaIso_DR0p3To0p4;
1879 >  Double_t fGammaIso_DR0p4To0p5;
1880 >
1881 >  Double_t fNeutralHadronIso_DR0p0To0p1;
1882 >  Double_t fNeutralHadronIso_DR0p1To0p2;
1883 >  Double_t fNeutralHadronIso_DR0p2To0p3;
1884 >  Double_t fNeutralHadronIso_DR0p3To0p4;
1885 >  Double_t fNeutralHadronIso_DR0p4To0p5;
1886 >
1887 >
1888 >  //
1889 >  //Loop over PF Candidates
1890 >  //
1891 >  for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1892 >
1893 >    if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1894 >
1895 >    const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1896 >    Double_t deta = (ele->Eta() - pf->Eta());
1897 >    Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1898 >    Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1899 >    if (dr > 1.0) continue;
1900 >
1901 >    if(ctrl.debug) {
1902 >      cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1903 >      if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx);
1904 >      cout << endl;
1905 >    }
1906 >
1907 >
1908 >    if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
1909 >         (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1910 >    
1911 >
1912 >    //
1913 >    // Lepton Footprint Removal
1914 >    //
1915 >    Bool_t IsLeptonFootprint = kFALSE;
1916 >    if (dr < 1.0) {
1917 >
1918 >
1919 >      //
1920 >      // Check for electrons
1921 >      //
1922 >
1923 >      for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1924 >        const mithep::Electron *tmpele = electronsToVeto[q];
1925 >        double tmpdr = mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1926 >
1927 >        // 4l electron
1928 >        if( pf->HasTrackerTrk()  ) {
1929 >          if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
1930 >            if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1931 >            IsLeptonFootprint = kTRUE;
1932 >          }
1933 >        }
1934 >        if( pf->HasGsfTrk()  ) {
1935 >          if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1936 >            if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1937 >            IsLeptonFootprint = kTRUE;
1938 >          }
1939 >        }
1940 >        // PF charged
1941 >        if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1942 >          if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1943 >          IsLeptonFootprint = kTRUE;
1944 >        }
1945 >        // PF gamma
1946 >        if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1947 >            && tmpdr < 0.08) {
1948 >          if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1949 >          IsLeptonFootprint = kTRUE;
1950 >        }
1951 >      } // loop over electrons
1952 >
1953 >
1954 >      /* KH - comment for sync            
1955 >      //
1956 >      // Check for muons
1957 >      //
1958 >      for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1959 >        const mithep::Muon *tmpmu = muonsToVeto[q];
1960 >        // 4l muon
1961 >        if( pf->HasTrackerTrk() ) {
1962 >          if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1963 >            if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1964 >            IsLeptonFootprint = kTRUE;
1965 >          }
1966 >        }
1967 >        // PF charged
1968 >        if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1969 >          if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1970 >          IsLeptonFootprint = kTRUE;
1971 >        }
1972 >      } // loop over muons
1973 >      */
1974 >
1975 >    if (IsLeptonFootprint)
1976 >      continue;
1977 >
1978 >    //
1979 >    // Charged Iso Rings
1980 >    //
1981 >    if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1982 >
1983 > //       if( pf->HasGsfTrk() ) {
1984 > //       if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1985 > //       } else if( pf->HasTrackerTrk() ){
1986 > //      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1987 > //       }
1988 >
1989 >      // Veto any PFmuon, or PFEle
1990 >      if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1991 >
1992 >      // Footprint Veto
1993 >      if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
1994 >
1995 >      if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
1996 >                           << "\ttype: " << pf->PFType()
1997 >                           << "\ttrk: " << pf->TrackerTrk() << endl;
1998 >
1999 >      if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
2000 >      if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
2001 >      if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
2002 >      if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
2003 >      if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
2004 >
2005 >    }
2006 >
2007 >    //
2008 >    // Gamma Iso Rings
2009 >    //
2010 >    else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2011 >
2012 >      if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
2013 >
2014 >      if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2015 >                           << dr << endl;
2016 >
2017 >      if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
2018 >      if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
2019 >      if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
2020 >      if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
2021 >      if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
2022 >    }
2023 >
2024 >    //
2025 >    // Other Neutral Iso Rings
2026 >    //
2027 >    else {
2028 >      if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2029 >                           << dr << endl;
2030 >      if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
2031 >      if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
2032 >      if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
2033 >      if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
2034 >      if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
2035 >    }
2036 >
2037 >    }
2038 >
2039 >  }
2040 >
2041 >  fChargedIso_DR0p0To0p1   = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
2042 >  fChargedIso_DR0p1To0p2   = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
2043 >  fChargedIso_DR0p2To0p3   = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
2044 >  fChargedIso_DR0p3To0p4   = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
2045 >  fChargedIso_DR0p4To0p5   = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
2046 >
2047 >  if(ctrl.debug) {
2048 >    cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1  << endl;
2049 >    cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2  << endl;
2050 >    cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3  << endl;
2051 >    cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4  << endl;
2052 >    cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5  << endl;
2053 >  }
2054 >
2055 >
2056 >  //  rho=0;
2057 >  //  double rho = 0;
2058 >  //   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
2059 >  //     rho = fPUEnergyDensity->At(0)->Rho();
2060 >  //   if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
2061 >  //     rho = fPUEnergyDensity->At(0)->RhoLowEta();
2062 >  
2063 >  // WARNING!!!!  
2064 >  // hardcode for sync ...
2065 >  EffectiveAreaVersion = eleT.kEleEAData2011;
2066 >  // WARNING!!!!  
2067 >
2068 >  if( ctrl.debug) {
2069 >    cout << "RHO: " << rho << endl;
2070 >    cout << "eta: " << ele->SCluster()->Eta() << endl;
2071 >    cout << "target: " << EffectiveAreaVersion << endl;
2072 >    cout << "effA 0-1: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
2073 >                                                       ele->SCluster()->Eta(),
2074 >                                                       EffectiveAreaVersion)
2075 >         << endl;
2076 >    cout << "effA 1-2: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
2077 >                                                       ele->SCluster()->Eta(),
2078 >                                                       EffectiveAreaVersion)
2079 >         << endl;
2080 >    cout << "effA 2-3: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
2081 >                                                       ele->SCluster()->Eta(),
2082 >                                                       EffectiveAreaVersion)
2083 >         << endl;
2084 >    cout << "effA 3-4: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
2085 >                                                       ele->SCluster()->Eta(),
2086 >                                                       EffectiveAreaVersion)
2087 >         << endl;
2088 >  }
2089 >
2090 >  fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
2091 >                                  -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
2092 >                                                              ele->SCluster()->Eta(),
2093 >                                                              EffectiveAreaVersion))/ele->Pt()
2094 >                                 ,2.5)
2095 >                             ,0.0);
2096 >  fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
2097 >                                  -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
2098 >                                                              ele->SCluster()->Eta(),
2099 >                                                              EffectiveAreaVersion))/ele->Pt()
2100 >                                 ,2.5)
2101 >                             ,0.0);
2102 >  fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
2103 >                                  -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
2104 >                                                              ele->SCluster()->Eta()
2105 >                                                              ,EffectiveAreaVersion))/ele->Pt()
2106 >                                 ,2.5)
2107 >                             ,0.0);
2108 >  fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
2109 >                                  -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
2110 >                                                              ele->SCluster()->Eta(),
2111 >                                                              EffectiveAreaVersion))/ele->Pt()
2112 >                                 ,2.5)
2113 >                             ,0.0);
2114 >  fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
2115 >                                  -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
2116 >                                                              ele->SCluster()->Eta(),
2117 >                                                              EffectiveAreaVersion))/ele->Pt()
2118 >                                 ,2.5)
2119 >                             ,0.0);
2120 >
2121 >
2122 >  if( ctrl.debug) {
2123 >    cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
2124 >    cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
2125 >    cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
2126 >    cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
2127 >    cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
2128 >  }
2129 >
2130 >  fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
2131 >                                          -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
2132 >                                                                 ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2133 >                                         , 2.5)
2134 >                                     , 0.0);
2135 >  fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
2136 >                                            -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
2137 >                                                                   ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2138 >                                           , 2.5)
2139 >                                       , 0.0);
2140 >  fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
2141 >                                          -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
2142 >                                                                 ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2143 >                                         , 2.5)
2144 >                                     , 0.0);
2145 >  fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
2146 >                                          -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
2147 >                                                                 ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
2148 >                                         , 2.5)
2149 >                                     , 0.0);
2150 >  fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
2151 >                                          -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
2152 >                                                                 ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
2153 >                                         , 2.5)
2154 >                                     , 0.0);
2155 >
2156 >  if( ctrl.debug) {
2157 >    cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
2158 >    cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
2159 >    cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
2160 >    cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
2161 >    cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
2162 >  }
2163 >
2164 >  double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
2165 >                                                ele->SCluster()->Eta(),
2166 >                                                fChargedIso_DR0p0To0p1,
2167 >                                                fChargedIso_DR0p1To0p2,
2168 >                                                fChargedIso_DR0p2To0p3,
2169 >                                                fChargedIso_DR0p3To0p4,
2170 >                                                fChargedIso_DR0p4To0p5,
2171 >                                                fGammaIso_DR0p0To0p1,
2172 >                                                fGammaIso_DR0p1To0p2,
2173 >                                                fGammaIso_DR0p2To0p3,
2174 >                                                fGammaIso_DR0p3To0p4,
2175 >                                                fGammaIso_DR0p4To0p5,
2176 >                                                fNeutralHadronIso_DR0p0To0p1,
2177 >                                                fNeutralHadronIso_DR0p1To0p2,
2178 >                                                fNeutralHadronIso_DR0p2To0p3,
2179 >                                                fNeutralHadronIso_DR0p3To0p4,
2180 >                                                fNeutralHadronIso_DR0p4To0p5,
2181 >                                                ctrl.debug);
2182 >
2183 >  SelectionStatus status;
2184 >  status.isoMVA = mvaval;
2185 >  bool pass = false;
2186 >
2187 >  Int_t subdet = 0;
2188 >  if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
2189 >  else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
2190 >  else subdet = 2;
2191 >
2192 >  Int_t ptBin = 0;
2193 >  if (ele->Pt() >= 10.0) ptBin = 1;
2194    
2195    Int_t MVABin = -1;
2196    if (subdet == 0 && ptBin == 0) MVABin = 0;
# Line 1139 | Line 2209 | SelectionStatus electronIsoMVASelection(
2209    if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN5 ) pass = true;
2210    if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
2211  
2212 <  pass = false;
2213 <  if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
2214 <  if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
2215 <  if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
2216 <  if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
2217 <  if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
2218 <  if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
2219 <  if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
2212 > //   pass = false;
2213 > //   if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
2214 > //   if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
2215 > //   if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
2216 > //   if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
2217 > //   if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
2218 > //   if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
2219 > //   if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
2220  
2221    if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2222    return status;
# Line 1170 | Line 2240 | void initElectronIsoMVA() {
2240  
2241  
2242  
2243 +
2244 + //--------------------------------------------------------------------------------------------------
2245 + float electronPFIso04(ControlFlags &ctrl,
2246 +                      const mithep::Electron * ele,
2247 +                      const mithep::Vertex * vtx,
2248 +                      const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2249 +                      const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2250 +                      mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2251 +                      vector<const mithep::Muon*> muonsToVeto,
2252 +                      vector<const mithep::Electron*> electronsToVeto)
2253 + //--------------------------------------------------------------------------------------------------
2254 + {
2255 +  /*
2256 +  if( ctrl.debug ) {
2257 +    cout << "electronIsoMVASelection :: muons to veto " << endl;
2258 +    for( int i=0; i<muonsToVeto.size(); i++ ) {
2259 +      const mithep::Muon * vmu = muonsToVeto[i];
2260 +      cout << "\tpt: " << vmu->Pt()
2261 +           << "\teta: " << vmu->Eta()
2262 +           << "\tphi: " << vmu->Phi()
2263 +           << endl;
2264 +    }
2265 +    cout << "electronIsoMVASelection :: electrons to veto " << endl;
2266 +    for( int i=0; i<electronsToVeto.size(); i++ ) {
2267 +      const mithep::Electron * vel = electronsToVeto[i];
2268 +      cout << "\tpt: " << vel->Pt()
2269 +           << "\teta: " << vel->Eta()
2270 +           << "\tphi: " << vel->Phi()
2271 +           << "\ttrk: " << vel->TrackerTrk()
2272 +           << endl;
2273 +    }
2274 +  }
2275 +  */
2276 +
2277 +  //
2278 +  // final iso
2279 +  //
2280 +  Double_t fChargedIso = 0.0;
2281 +  Double_t fGammaIso = 0.0;
2282 +  Double_t fNeutralHadronIso = 0.0;
2283 +
2284 +
2285 +  //
2286 +  //Loop over PF Candidates
2287 +  //
2288 +  for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2289 +
2290 +
2291 +    const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2292 +    Double_t deta = (ele->Eta() - pf->Eta());
2293 +    Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
2294 +    Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
2295 +
2296 +    if (dr > 0.4) continue;
2297 +    if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
2298 +
2299 +    if(ctrl.debug) {
2300 +      cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
2301 +      if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx)
2302 +                                     << "\ttrk: " << pf->HasTrackerTrk()
2303 +                                     << "\tgsf: " << pf->HasGsfTrk();
2304 +      
2305 +      cout << endl;
2306 +    }
2307 +
2308 +
2309 +    //
2310 +    // sync : I don't think theyre doing this ...
2311 +    //
2312 +    //     if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
2313 +    //   (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
2314 +    //       if( ctrl.debug ) cout << "\tskipping, matches to the electron ..."  << endl;
2315 +    //       continue;
2316 +    //     }
2317 +
2318 +
2319 +    //
2320 +    // Lepton Footprint Removal
2321 +    //
2322 +    Bool_t IsLeptonFootprint = kFALSE;
2323 +    if (dr < 1.0) {
2324 +
2325 +      //
2326 +      // Check for electrons
2327 +      //
2328 +      for (Int_t q=0; q < electronsToVeto.size(); ++q) {
2329 +        const mithep::Electron *tmpele = electronsToVeto[q];
2330 +        /*
2331 +        // 4l electron
2332 +        if( pf->HasTrackerTrk()  ) {
2333 +          if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
2334 +            if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
2335 +            IsLeptonFootprint = kTRUE;
2336 +          }
2337 +        }
2338 +        if( pf->HasGsfTrk()  ) {
2339 +          if( pf->GsfTrk() == tmpele->GsfTrk() ) {
2340 +            if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
2341 +            IsLeptonFootprint = kTRUE;
2342 +          }
2343 +        }
2344 +        */
2345 +        // PF charged
2346 +        if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
2347 +            && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
2348 +          if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
2349 +          IsLeptonFootprint = kTRUE;
2350 +        }
2351 +        // PF gamma
2352 +        if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
2353 +            && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
2354 +          if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
2355 +          IsLeptonFootprint = kTRUE;
2356 +        }
2357 +      } // loop over electrons
2358 +
2359 +      /* KH - comment for sync            
2360 +      //
2361 +      // Check for muons
2362 +      //
2363 +      for (Int_t q=0; q < muonsToVeto.size(); ++q) {
2364 +        const mithep::Muon *tmpmu = muonsToVeto[q];
2365 +        // 4l muon
2366 +        if( pf->HasTrackerTrk() ) {
2367 +          if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
2368 +            if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
2369 +            IsLeptonFootprint = kTRUE;
2370 +          }
2371 +        }
2372 +        // PF charged
2373 +        if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
2374 +          if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
2375 +          IsLeptonFootprint = kTRUE;
2376 +        }
2377 +      } // loop over muons
2378 +      */
2379 +
2380 +    if (IsLeptonFootprint)
2381 +      continue;
2382 +
2383 +    //
2384 +    // Charged Iso
2385 +    //
2386 +    if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
2387 +
2388 + //       if( pf->HasTrackerTrk() )
2389 + //      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2390 + //       if( pf->HasGsfTrk() )
2391 + //      if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2392 +
2393 +      // Veto any PFmuon, or PFEle
2394 +      if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) {
2395 +          if( ctrl.debug) cout << "\t skipping, pf is and ele or mu .." <<endl;
2396 +        continue;
2397 +      }
2398 +
2399 +      // Footprint Veto
2400 +      if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
2401 +
2402 +      if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
2403 +                           << "\ttype: " << pf->PFType()
2404 +                           << "\ttrk: " << pf->TrackerTrk() << endl;
2405 +
2406 +      fChargedIso += pf->Pt();
2407 +    }
2408 +
2409 +    //
2410 +    // Gamma Iso
2411 +    //
2412 +    else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2413 +
2414 +      if (fabs(ele->SCluster()->Eta()) > 1.479) {
2415 +        if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
2416 +      }
2417 +      if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2418 +                           << dr << endl;
2419 +      // KH, add to sync
2420 +      //      if( pf->Pt() > 0.5 )
2421 +        fGammaIso += pf->Pt();
2422 +    }
2423 +
2424 +    //
2425 +    // Neutral Iso
2426 +    //
2427 +    else {
2428 +      if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2429 +                           << dr << endl;
2430 +      // KH, add to sync
2431 +      //      if( pf->Pt() > 0.5 )
2432 +        fNeutralHadronIso += pf->Pt();
2433 +    }
2434 +
2435 +    }
2436 +
2437 +  }
2438 +
2439 +
2440 +  double rho=0;
2441 +  if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJets()) || isinf(fPUEnergyDensity->At(0)->RhoKt6PFJets())))
2442 +    rho = fPUEnergyDensity->At(0)->RhoKt6PFJets();
2443 +
2444 +
2445 +  double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2446 +                                        -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2447 +                                                                   ele->Eta(),EffectiveAreaVersion)));
2448 +
2449 +
2450 +  gChargedIso = fChargedIso;
2451 +  gGammaIso = fGammaIso;
2452 +  gNeutralIso = fNeutralHadronIso;  
2453 +  return pfIso;
2454 + }
2455 +
2456 +
2457 +
2458   //--------------------------------------------------------------------------------------------------
2459 + // hacked version
2460   float electronPFIso04(ControlFlags &ctrl,
2461 <                                const mithep::Electron * ele,
2462 <                                const mithep::Vertex & vtx,
2463 <                                const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2464 <                                const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2465 <                                mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2466 <                                vector<const mithep::Muon*> muonsToVeto,
2467 <                                vector<const mithep::Electron*> electronsToVeto)
2461 >                      const mithep::Electron * ele,
2462 >                      const mithep::Vertex * vtx,
2463 >                      const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2464 >                      float rho,
2465 >                      mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2466 >                      vector<const mithep::Muon*> muonsToVeto,
2467 >                      vector<const mithep::Electron*> electronsToVeto)
2468   //--------------------------------------------------------------------------------------------------
2469   {
2470  
# Line 1191 | Line 2477 | float electronPFIso04(ControlFlags &ctrl
2477             << "\tphi: " << vmu->Phi()
2478             << endl;
2479      }
2480 <    cout << "electronIsoMVASelection :: electrson to veto " << endl;
2480 >    cout << "electronIsoMVASelection :: electrons to veto " << endl;
2481      for( int i=0; i<electronsToVeto.size(); i++ ) {
2482        const mithep::Electron * vel = electronsToVeto[i];
2483        cout << "\tpt: " << vel->Pt()
# Line 1215 | Line 2501 | float electronPFIso04(ControlFlags &ctrl
2501    //Loop over PF Candidates
2502    //
2503    for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2504 +
2505 +
2506      const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2507      Double_t deta = (ele->Eta() - pf->Eta());
2508      Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
2509      Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
2510 <    if (dr >= 0.4) continue;
2510 >
2511 >    if (dr > 0.4) continue;
2512 >    if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
2513 >
2514      if(ctrl.debug) {
2515 <      cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
2516 <      if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
2515 >      cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
2516 >      if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx)
2517 >                                     << "\ttrk: " << pf->HasTrackerTrk()
2518 >                                     << "\tgsf: " << pf->HasGsfTrk();
2519 >      
2520        cout << endl;
2521      }
2522  
2523  
2524 <    if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
2525 <         (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
2526 <    
2524 >    //
2525 >    // sync : I don't think theyre doing this ...
2526 >    //
2527 >    //     if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
2528 >    //   (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
2529 >    //       if( ctrl.debug ) cout << "\tskipping, matches to the electron ..."  << endl;
2530 >    //       continue;
2531 >    //     }
2532 >
2533  
2534      //
2535      // Lepton Footprint Removal
# Line 1242 | Line 2542 | float electronPFIso04(ControlFlags &ctrl
2542        //
2543        for (Int_t q=0; q < electronsToVeto.size(); ++q) {
2544          const mithep::Electron *tmpele = electronsToVeto[q];
2545 +        /*
2546          // 4l electron
2547          if( pf->HasTrackerTrk()  ) {
2548            if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
# Line 1255 | Line 2556 | float electronPFIso04(ControlFlags &ctrl
2556              IsLeptonFootprint = kTRUE;
2557            }
2558          }
2559 +        */
2560          // PF charged
2561          if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
2562              && mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
# Line 1268 | Line 2570 | float electronPFIso04(ControlFlags &ctrl
2570            IsLeptonFootprint = kTRUE;
2571          }
2572        } // loop over electrons
2573 <      
2573 >
2574 >      /* KH - comment for sync            
2575        //
2576        // Check for muons
2577        //
# Line 1287 | Line 2590 | float electronPFIso04(ControlFlags &ctrl
2590            IsLeptonFootprint = kTRUE;
2591          }
2592        } // loop over muons
2593 <
2593 >      */
2594  
2595      if (IsLeptonFootprint)
2596        continue;
2597  
2598      //
2599 <    // Charged Iso Rings
2599 >    // Charged Iso
2600      //
2601      if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
2602  
2603 <      if( pf->HasTrackerTrk() )
2604 <        if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2605 <      if( pf->HasGsfTrk() )
2606 <        if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2603 > //       if( pf->HasTrackerTrk() )
2604 > //      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2605 > //       if( pf->HasGsfTrk() )
2606 > //      if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2607  
2608        // Veto any PFmuon, or PFEle
2609 <      if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
2609 >      if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) {
2610 >         cout << "\t skipping, pf is and ele or mu .." <<endl;
2611 >        continue;
2612 >      }
2613  
2614        // Footprint Veto
2615        if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
# Line 1325 | Line 2631 | float electronPFIso04(ControlFlags &ctrl
2631        }
2632        if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2633                             << dr << endl;
2634 <      fGammaIso += pf->Pt();
2634 >      // KH, add to sync
2635 >      //      if( pf->Pt() > 0.5 )
2636 >        fGammaIso += pf->Pt();
2637      }
2638  
2639      //
# Line 1334 | Line 2642 | float electronPFIso04(ControlFlags &ctrl
2642      else {
2643        if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2644                             << dr << endl;
2645 <      fNeutralHadronIso += pf->Pt();
2645 >      // KH, add to sync
2646 >      //      if( pf->Pt() > 0.5 )
2647 >        fNeutralHadronIso += pf->Pt();
2648      }
2649  
2650      }
2651  
2652    }
2653  
2654 <  double rho = 0;
2655 <  if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
2656 <    rho = fPUEnergyDensity->At(0)->Rho();
2654 > //   double rho = 0;
2655 > //   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
2656 > //     rho = fPUEnergyDensity->At(0)->Rho();
2657  
2658    // WARNING!!!!  
2659    // hardcode for sync ...
# Line 1351 | Line 2661 | float electronPFIso04(ControlFlags &ctrl
2661    // WARNING!!!!  
2662  
2663  
2664 <  double pfIso = fChargedIso +
2665 <    max(0.0,fGammaIso -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIso04,
2666 <                                                ele->Eta(),EffectiveAreaVersion)) +
2667 <    max(0.0,fNeutralHadronIso -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIso04,
2668 <                                                        ele->Eta(),EffectiveAreaVersion)) ;
2664 >  double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2665 >                                        -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2666 >                                                                   ele->Eta(),EffectiveAreaVersion)));
2667 >
2668 >
2669 >  gChargedIso = fChargedIso;
2670 >  gGammaIso = fGammaIso;
2671 >  gNeutralIso = fNeutralHadronIso;  
2672    return pfIso;
2673   }
2674  
2675 +
2676   //--------------------------------------------------------------------------------------------------
2677   SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2678                                                const mithep::Electron * ele,
2679 <                                              const mithep::Vertex & vtx,
2679 >                                              const mithep::Vertex * vtx,
2680                                                const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2681                                                const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2682                                                mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
# Line 1375 | Line 2689 | SelectionStatus electronReferenceIsoSele
2689  
2690    double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, fPUEnergyDensity,
2691                                    EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
2692 +  //  cout << "--------------> setting electron isoPF04 to " << pfIso << endl;
2693 +  status.isoPF04 = pfIso;
2694 +  status.chisoPF04 = gChargedIso;
2695 +  status.gaisoPF04 = gGammaIso;
2696 +  status.neisoPF04 = gNeutralIso;
2697 +
2698 +  bool pass = false;
2699 +  if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
2700 +
2701 +  if( pass ) {
2702 +    status.orStatus(SelectionStatus::LOOSEISO);
2703 +    status.orStatus(SelectionStatus::TIGHTISO);
2704 +  }
2705 +  if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2706 +  return status;
2707 +
2708 + }
2709 +
2710 +
2711 + //--------------------------------------------------------------------------------------------------
2712 + // hacked version
2713 + SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2714 +                                              const mithep::Electron * ele,
2715 +                                              const mithep::Vertex * vtx,
2716 +                                              const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2717 +                                              float rho,
2718 +                                              mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2719 +                                              vector<const mithep::Muon*> muonsToVeto,
2720 +                                              vector<const mithep::Electron*> electronsToVeto)
2721 + //--------------------------------------------------------------------------------------------------
2722 + {
2723 +
2724 +  SelectionStatus status;
2725 +
2726 +  double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, rho,
2727 +                                  EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
2728 +  status.isoPF04 = pfIso;
2729 +  status.chisoPF04 = gChargedIso;
2730 +  status.gaisoPF04 = gGammaIso;
2731 +  status.neisoPF04 = gNeutralIso;
2732    bool pass = false;
2733    if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
2734  

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines