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.25 by anlevin, Wed May 23 22:36:14 2012 UTC vs.
Revision 1.29 by khahn, Sun Jun 3 15:51:51 2012 UTC

# Line 468 | Line 468 | SelectionStatus muonIsoMVASelection(Cont
468    double rho = 0;
469    if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
470      rho = fPUEnergyDensity->At(0)->Rho();
471 +
472   //   if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
473   //     rho = fPUEnergyDensity->At(0)->RhoLowEta();
474    
# Line 1114 | Line 1115 | double  muonPFIso04(ControlFlags &ctrl,
1115    }
1116  
1117    double rho=0;
1118 <  if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral()) || isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral())))
1119 <    rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral();
1120 <
1118 >  if( (EffectiveAreaVersion == mithep::MuonTools::kMuEAFall11MC) ||
1119 >      (EffectiveAreaVersion == mithep::MuonTools::kMuEAData2011) ) {
1120 >    if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25()) ||
1121 >          isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25())))
1122 >      rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25();
1123 >    //rho = fPUEnergyDensity->At(0)->Rho();
1124 >    // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
1125 >    EffectiveAreaVersion  = mithep::MuonTools::kMuEAData2011;
1126 >    // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
1127 >  } else {
1128 >    if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral()) ||
1129 >          isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral())))
1130 >      rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral();
1131 >    // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
1132 >    EffectiveAreaVersion  = mithep::MuonTools::kMuEAData2012;
1133 >    // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
1134 >  }
1135 >  if(ctrl.debug) cout << "rho: " << rho << endl;
1136  
1137    double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1138                                          -rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
# Line 2392 | Line 2408 | float electronPFIso04(ControlFlags &ctrl
2408  
2409        // Veto any PFmuon, or PFEle
2410        if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) {
2411 <         cout << "\t skipping, pf is and ele or mu .." <<endl;
2411 >        if( ctrl.debug ) cout << "\t skipping, pf is and ele or mu .." <<endl;
2412          continue;
2413        }
2414  
# Line 2438 | Line 2454 | float electronPFIso04(ControlFlags &ctrl
2454  
2455  
2456    double rho=0;
2457 <  if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJets()) || isinf(fPUEnergyDensity->At(0)->RhoKt6PFJets())))
2458 <    rho = fPUEnergyDensity->At(0)->RhoKt6PFJets();
2459 <
2457 >  if( (EffectiveAreaVersion == mithep::ElectronTools::kEleEAFall11MC) ||
2458 >      (EffectiveAreaVersion == mithep::ElectronTools::kEleEAData2011) ) {
2459 >    if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25()) ||
2460 >          isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25())))
2461 >      rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25();
2462 >    // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2463 >    EffectiveAreaVersion  = mithep::ElectronTools::kEleEAData2011;
2464 >    // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2465 >  } else {
2466 >    if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJets()) ||
2467 >          isinf(fPUEnergyDensity->At(0)->RhoKt6PFJets())))
2468 >      rho = fPUEnergyDensity->At(0)->RhoKt6PFJets();
2469 >    // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2470 >    EffectiveAreaVersion  = mithep::ElectronTools::kEleEAData2012;
2471 >    // !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2472 >  }
2473 >  if(ctrl.debug) cout << "rho: " << rho << endl;
2474  
2475    double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2476                                          -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
# Line 2607 | Line 2637 | float electronPFIso04(ControlFlags &ctrl
2637  
2638        // Veto any PFmuon, or PFEle
2639        if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) {
2640 <         cout << "\t skipping, pf is and ele or mu .." <<endl;
2640 >        if( ctrl.debug ) cout << "\t skipping, pf is and ele or mu .." <<endl;
2641          continue;
2642        }
2643  
# Line 2740 | Line 2770 | SelectionStatus electronReferenceIsoSele
2770    return status;
2771  
2772   }
2773 +
2774 +
2775 +
2776 + //--------------------------------------------------------------------------------------------------
2777 + double  dbetaCorrectedIsoDr03(ControlFlags & ctrl,
2778 +                              const mithep::PFCandidate * photon,
2779 +                              const mithep::Muon * lepton,
2780 +                              const mithep::Array<mithep::PFCandidate> * fPFCandidates)
2781 + //--------------------------------------------------------------------------------------------------
2782 + {
2783 +
2784 +  //
2785 +  // final iso
2786 +  //
2787 +  Double_t fChargedIso  = 0.0;
2788 +  Double_t fGammaIso  = 0.0;
2789 +  Double_t fNeutralHadronIso  = 0.0;
2790 +  Double_t fpfPU  = 0.0;
2791 +
2792 +  //
2793 +  // Loop over PF Candidates
2794 +  //
2795 +  for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2796 +
2797 +    const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2798 +    
2799 +    Double_t deta = (photon->Eta() - pf->Eta());
2800 +    Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2801 +    Double_t dr = mithep::MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2802 +    if (dr > 0.3) continue;
2803 +
2804 +    if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2805 +      if( pf->Pt() >= 0.2 && dr > 0.01 )
2806 +        fpfPU += pf->Pt();
2807 +      continue;
2808 +    }
2809 +    
2810 +    //
2811 +    // skip this photon
2812 +    //
2813 +    if( abs(pf->PFType()) == mithep::PFCandidate::eGamma &&
2814 +        pf->Et() == photon->Et() ) continue;
2815 +    
2816 +      
2817 +    //
2818 +    // Charged Iso
2819 +    //
2820 +    if (pf->Charge() != 0 ) {
2821 +      if( dr > 0.01 && pf->Pt() >= 0.2 &&
2822 +          !(pf->TrackerTrk() == lepton->TrackerTrk()) )
2823 +        fChargedIso += pf->Pt();
2824 +    }
2825 +    
2826 +    //
2827 +    // Gamma Iso
2828 +    //
2829 +    else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
2830 +      if( pf->Pt() > 0.5 && dr > 0.01)
2831 +        fGammaIso += pf->Pt();
2832 +    }
2833 +    
2834 +    //
2835 +    // Other Neutrals
2836 +    //
2837 +    else {
2838 +      if( pf->Pt() > 0.5 && dr > 0.01)
2839 +        fNeutralHadronIso += pf->Pt();
2840 +    }
2841 +    
2842 +  }
2843 +  
2844 +  if( ctrl.debug ) {
2845 +    cout << "photon dbetaIso :: " << endl;
2846 +    cout << "\tfChargedIso: " << fChargedIso
2847 +         << "\tfGammaIso: " << fGammaIso
2848 +         << "\tfNeutralHadronIso: " << fNeutralHadronIso
2849 +         << "\tfpfPU: " << fpfPU
2850 +         << endl;
2851 +  }
2852 +  double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso - 0.5*fpfPU;
2853 +  return pfIso/photon->Pt();
2854 + }
2855 +
2856 +
2857 + //--------------------------------------------------------------------------------------------------
2858 + double  dbetaCorrectedIsoDr03(ControlFlags & ctrl,
2859 +                              const mithep::PFCandidate * photon,
2860 +                              const mithep::Electron * lepton,
2861 +                              const mithep::Array<mithep::PFCandidate> * fPFCandidates)
2862 + //--------------------------------------------------------------------------------------------------
2863 + {
2864 +
2865 +  //
2866 +  // final iso
2867 +  //
2868 +  Double_t fChargedIso  = 0.0;
2869 +  Double_t fGammaIso  = 0.0;
2870 +  Double_t fNeutralHadronIso  = 0.0;
2871 +  Double_t fpfPU  = 0.0;
2872 +
2873 +  //
2874 +  // Loop over PF Candidates
2875 +  //
2876 +  for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2877 +
2878 +    const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2879 +    
2880 +    Double_t deta = (photon->Eta() - pf->Eta());
2881 +    Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2882 +    Double_t dr = mithep::MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2883 +    if (dr > 0.3) continue;
2884 +
2885 +    if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2886 +      if( pf->Pt() >= 0.2 && dr > 0.01 )
2887 +        fpfPU += pf->Pt();
2888 +      continue;
2889 +    }
2890 +    
2891 +    //
2892 +    // skip this photon
2893 +    //
2894 +    if( abs(pf->PFType()) == mithep::PFCandidate::eGamma &&
2895 +        pf->Et() == photon->Et() ) continue;
2896 +    
2897 +      
2898 +    //
2899 +    // Charged Iso
2900 +    //
2901 +    if (pf->Charge() != 0 ) {
2902 +      if( dr > 0.01 && pf->Pt() >= 0.2 &&
2903 +          !(pf->TrackerTrk() == lepton->TrackerTrk()) )
2904 +        fChargedIso += pf->Pt();
2905 +    }
2906 +    
2907 +    //
2908 +    // Gamma Iso
2909 +    //
2910 +    else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
2911 +      if( pf->Pt() > 0.5 && dr > 0.01)
2912 +        fGammaIso += pf->Pt();
2913 +    }
2914 +    
2915 +    //
2916 +    // Other Neutrals
2917 +    //
2918 +    else {
2919 +      if( pf->Pt() > 0.5 && dr > 0.01)
2920 +        fNeutralHadronIso += pf->Pt();
2921 +    }
2922 +    
2923 +  }
2924 +  
2925 +  if( ctrl.debug ) {
2926 +    cout << "photon dbetaIso :: " << endl;
2927 +    cout << "\tfChargedIso: " << fChargedIso
2928 +         << "\tfGammaIso: " << fGammaIso
2929 +         << "\tfNeutralHadronIso: " << fNeutralHadronIso
2930 +         << "\tfpfPU: " << fpfPU
2931 +         << endl;
2932 +  }
2933 +  double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso - 0.5*fpfPU;
2934 +  return pfIso/photon->Pt();
2935 + }
2936 +
2937 +
2938 +
2939 +
2940 +
2941 + //--------------------------------------------------------------------------------------------------
2942 + double  betaCorrectedIsoDr03(ControlFlags & ctrl,
2943 +                             const mithep::PFCandidate * photon,
2944 +                             const mithep::Muon * lepton,
2945 +                             const mithep::Array<mithep::PFCandidate> * fPFCandidates)
2946 + //--------------------------------------------------------------------------------------------------
2947 + {
2948 +
2949 +  //
2950 +  // final iso
2951 +  //
2952 +  Double_t fChargedIso  = 0.0;
2953 +  Double_t fGammaIso  = 0.0;
2954 +  Double_t fNeutralHadronIso  = 0.0;
2955 +  Double_t fpfPU  = 0.0;
2956 +
2957 +  //
2958 +  // Loop over PF Candidates
2959 +  //
2960 +  for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2961 +
2962 +    const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2963 +    
2964 +    Double_t deta = (photon->Eta() - pf->Eta());
2965 +    Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2966 +    Double_t dr = mithep::MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2967 +    if (dr > 0.3) continue;
2968 +
2969 +    if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2970 +      if( pf->Pt() >= 0.2 && dr > 0.01 )
2971 +        fpfPU += pf->Pt();
2972 +      continue;
2973 +    }
2974 +    
2975 +    //
2976 +    // skip this photon
2977 +    //
2978 +    if( abs(pf->PFType()) == mithep::PFCandidate::eGamma &&
2979 +        pf->Et() == photon->Et() ) continue;
2980 +    
2981 +      
2982 +    //
2983 +    // Charged Iso
2984 +    //
2985 +    if (pf->Charge() != 0 ) {
2986 +      if( dr > 0.01 && pf->Pt() >= 0.2 &&
2987 +          !(pf->TrackerTrk() == lepton->TrackerTrk()) )
2988 +        fChargedIso += pf->Pt();
2989 +    }
2990 +    
2991 +    //
2992 +    // Gamma Iso
2993 +    //
2994 +    else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
2995 +      if( pf->Pt() > 0.5 && dr > 0.01)
2996 +        fGammaIso += pf->Pt();
2997 +    }
2998 +    
2999 +    //
3000 +    // Other Neutrals
3001 +    //
3002 +    else {
3003 +      if( pf->Pt() > 0.5 && dr > 0.01)
3004 +        fNeutralHadronIso += pf->Pt();
3005 +    }
3006 +    
3007 +  }
3008 +  
3009 +  if( ctrl.debug ) {
3010 +    cout << "photon dbetaIso :: " << endl;
3011 +    cout << "\tfChargedIso: " << fChargedIso
3012 +         << "\tfGammaIso: " << fGammaIso
3013 +         << "\tfNeutralHadronIso: " << fNeutralHadronIso
3014 +         << "\tfpfPU: " << fpfPU
3015 +         << endl;
3016 +  }
3017 +  double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso + fpfPU;
3018 +  return pfIso/photon->Pt();
3019 + }
3020 +
3021 +
3022 + //--------------------------------------------------------------------------------------------------
3023 + double  betaCorrectedIsoDr03(ControlFlags & ctrl,
3024 +                              const mithep::PFCandidate * photon,
3025 +                              const mithep::Electron * lepton,
3026 +                              const mithep::Array<mithep::PFCandidate> * fPFCandidates)
3027 + //--------------------------------------------------------------------------------------------------
3028 + {
3029 +
3030 +  //
3031 +  // final iso
3032 +  //
3033 +  Double_t fChargedIso  = 0.0;
3034 +  Double_t fGammaIso  = 0.0;
3035 +  Double_t fNeutralHadronIso  = 0.0;
3036 +  Double_t fpfPU  = 0.0;
3037 +
3038 +  //
3039 +  // Loop over PF Candidates
3040 +  //
3041 +  for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
3042 +
3043 +    const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
3044 +    
3045 +    Double_t deta = (photon->Eta() - pf->Eta());
3046 +    Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
3047 +    Double_t dr = mithep::MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
3048 +    if (dr > 0.3) continue;
3049 +
3050 +    if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
3051 +      if( pf->Pt() >= 0.2 && dr > 0.01 )
3052 +        fpfPU += pf->Pt();
3053 +      continue;
3054 +    }
3055 +    
3056 +    //
3057 +    // skip this photon
3058 +    //
3059 +    if( abs(pf->PFType()) == mithep::PFCandidate::eGamma &&
3060 +        pf->Et() == photon->Et() ) continue;
3061 +    
3062 +      
3063 +    //
3064 +    // Charged Iso
3065 +    //
3066 +    if (pf->Charge() != 0 ) {
3067 +      if( dr > 0.01 && pf->Pt() >= 0.2 &&
3068 +          !(pf->TrackerTrk() == lepton->TrackerTrk()) )
3069 +        fChargedIso += pf->Pt();
3070 +    }
3071 +    
3072 +    //
3073 +    // Gamma Iso
3074 +    //
3075 +    else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
3076 +      if( pf->Pt() > 0.5 && dr > 0.01)
3077 +        fGammaIso += pf->Pt();
3078 +    }
3079 +    
3080 +    //
3081 +    // Other Neutrals
3082 +    //
3083 +    else {
3084 +      if( pf->Pt() > 0.5 && dr > 0.01)
3085 +        fNeutralHadronIso += pf->Pt();
3086 +    }
3087 +    
3088 +  }
3089 +  
3090 +  if( ctrl.debug ) {
3091 +    cout << "photon dbetaIso :: " << endl;
3092 +    cout << "\tfChargedIso: " << fChargedIso
3093 +         << "\tfGammaIso: " << fGammaIso
3094 +         << "\tfNeutralHadronIso: " << fNeutralHadronIso
3095 +         << "\tfpfPU: " << fpfPU
3096 +         << endl;
3097 +  }
3098 +  double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso + fpfPU;
3099 +  return pfIso/photon->Pt();
3100 + }
3101 +
3102 +
3103 +

Diff Legend

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