From 75d6518a854c77a189cff04a81e000a0938994e8 Mon Sep 17 00:00:00 2001 From: Brieuc Francois Date: Thu, 28 Jan 2016 14:03:05 +0100 Subject: [PATCH 1/2] First round for trigger efficiency --- interface/HHAnalyzer.h | 48 +++++++++++++++++++++++++++++++++++++++++ interface/Types.h | 3 +++ plugins/HHAnalyzer.cc | 3 +++ test/HHConfiguration.py | 8 ++++++- 4 files changed, 61 insertions(+), 1 deletion(-) diff --git a/interface/HHAnalyzer.h b/interface/HHAnalyzer.h index db7b6d1..d191f42 100644 --- a/interface/HHAnalyzer.h +++ b/interface/HHAnalyzer.h @@ -3,10 +3,12 @@ #include #include +#include #include #include +using namespace HH; using namespace HHAnalysis; class HHAnalyzer: public Framework::Analyzer { @@ -48,6 +50,16 @@ class HHAnalyzer: public Framework::Analyzer { m_hltDRCut = config.getUntrackedParameter("hltDRCut", std::numeric_limits::max()); m_hltDPtCut = config.getUntrackedParameter("hltDPtCut", std::numeric_limits::max()); + + if (config.exists("hlt_efficiencies")){ + const edm::ParameterSet& hlt_efficiencies = config.getUntrackedParameter("hlt_efficiencies"); + std::vector hlt_efficiencies_name = hlt_efficiencies.getParameterNames(); + for (const std::string& hlt_efficiency: hlt_efficiencies_name) { + std::cout << "Adding hlt efficiencies : " << hlt_efficiency << std::endl; + ScaleFactorParser parser(hlt_efficiencies.getUntrackedParameter(hlt_efficiency).fullPath()); + m_hlt_efficiencies.emplace(hlt_efficiency, std::move(parser.get_scale_factor())); + } + } } // leptons and dileptons stuff @@ -113,6 +125,41 @@ class HHAnalyzer: public Framework::Analyzer { return cos(ROOT::Math::VectorUtil::Angle(CSaxis.Unit(), newh1.Vect().Unit())); } + float getTriggerEfficiency(const Lepton & lep1, const Lepton & lep2) + { + float lep1_leg1 = 1., lep1_leg2 = 1., lep2_leg1 = 1., lep2_leg2 = 1.; + if (lep1.isMu && lep2.isMu) { + lep1_leg1 = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu17leg"].get({lep1.p4.Eta(), lep1.p4.Pt()})[0]; + lep1_leg2 = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu8leg"].get({lep1.p4.Eta(), lep1.p4.Pt()})[0]; + //lep1_tkLeg2 = m_hlt_efficiencies["DoubleIsoMu17Mu8_TkMu8leg"].get({lep1.p4.Eta(), lep1.p4.Pt()})[0]; + lep2_leg1 = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu17leg"].get({lep2.p4.Eta(), lep2.p4.Pt()})[0]; + lep2_leg2 = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu8leg"].get({lep2.p4.Eta(), lep2.p4.Pt()})[0]; + //lep2_tkLeg2 = m_hlt_efficiencies["DoubleIsoMu17Mu8_TkMu8leg"].get({lep2.p4.Eta(), lep2.p4.Pt()})[0]; + } + else if (lep1.isMu && lep2.isEl) { + lep1_leg1 = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu17leg"].get({lep1.p4.Eta(), lep1.p4.Pt()})[0]; + lep1_leg2 = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu8leg"].get({lep1.p4.Eta(), lep1.p4.Pt()})[0]; + lep2_leg1 = m_hlt_efficiencies["Ele17_12Leg1"].get({lep2.p4.Eta(), lep2.p4.Pt()})[0]; + lep2_leg2 = m_hlt_efficiencies["Ele17_12Leg2"].get({lep2.p4.Eta(), lep2.p4.Pt()})[0]; + } + else if (lep1.isEl && lep2.isMu) { + lep1_leg1 = m_hlt_efficiencies["Ele17_12Leg1"].get({lep1.p4.Eta(), lep1.p4.Pt()})[0]; + lep1_leg2 = m_hlt_efficiencies["Ele17_12Leg2"].get({lep1.p4.Eta(), lep1.p4.Pt()})[0]; + lep2_leg1 = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu17leg"].get({lep2.p4.Eta(), lep2.p4.Pt()})[0]; + lep2_leg2 = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu8leg"].get({lep2.p4.Eta(), lep2.p4.Pt()})[0]; + } + else if (lep1.isEl && lep2.isEl){ + lep1_leg1 = m_hlt_efficiencies["Ele17_12Leg1"].get({lep1.p4.Eta(), lep1.p4.Pt()})[0]; + lep1_leg2 = m_hlt_efficiencies["Ele17_12Leg2"].get({lep1.p4.Eta(), lep1.p4.Pt()})[0]; + lep2_leg1 = m_hlt_efficiencies["Ele17_12Leg1"].get({lep2.p4.Eta(), lep2.p4.Pt()})[0]; + lep2_leg2 = m_hlt_efficiencies["Ele17_12Leg2"].get({lep2.p4.Eta(), lep2.p4.Pt()})[0]; + } + float total_efficiency = lep1_leg1 * lep2_leg2 + lep1_leg2 * lep2_leg1 - lep1_leg1 * lep2_leg1; + return total_efficiency; + } + + + private: // Producers name std::string m_electrons_producer; @@ -129,6 +176,7 @@ class HHAnalyzer: public Framework::Analyzer { std::string m_electron_loose_wp_name; std::string m_electron_tight_wp_name; bool m_applyBJetRegression; + std::map m_hlt_efficiencies; }; diff --git a/interface/Types.h b/interface/Types.h index a00c177..58b5a5c 100644 --- a/interface/Types.h +++ b/interface/Types.h @@ -53,6 +53,9 @@ namespace HH { bool gen_matched; float gen_DR; float gen_DPtOverPt; + float trigger_efficiency; + float trigger_efficiency_downVariated; + float trigger_efficiency_upVariated; }; struct Met { LorentzVector p4; diff --git a/plugins/HHAnalyzer.cc b/plugins/HHAnalyzer.cc index 51264a7..92023c7 100644 --- a/plugins/HHAnalyzer.cc +++ b/plugins/HHAnalyzer.cc @@ -185,6 +185,9 @@ void HHAnalyzer::analyze(const edm::Event& event, const edm::EventSetup&, const dilep.gen_p4 = dilep.gen_matched ? leptons[ilep1].gen_p4 + leptons[ilep2].gen_p4 : null_p4; dilep.gen_DR = dilep.gen_matched ? ROOT::Math::VectorUtil::DeltaR(dilep.p4, dilep.gen_p4) : -1.; dilep.gen_DPtOverPt = dilep.gen_matched ? (dilep.p4.Pt() - dilep.gen_p4.Pt()) / dilep.p4.Pt() : -10.; + dilep.trigger_efficiency = event.isRealData() ? 1. : getTriggerEfficiency(leptons[ilep1], leptons[ilep2]); + dilep.trigger_efficiency_downVariated = event.isRealData() ? 0. : 0; // FIXME : implement trigger efficiency error + dilep.trigger_efficiency_upVariated = event.isRealData() ? 0. : 0; // FIXME : implement trigger efficiency error ll.push_back(dilep); } } diff --git a/test/HHConfiguration.py b/test/HHConfiguration.py index 4f19ae5..b4677d7 100644 --- a/test/HHConfiguration.py +++ b/test/HHConfiguration.py @@ -50,10 +50,16 @@ hltDRCut = cms.untracked.double(0.3), hltDPtCut = cms.untracked.double(0.5), # cut will be DPt/Pt < hltDPtCut applyBJetRegression = cms.untracked.bool(True) # BE SURE TO ACTIVATE computeRegression FLAG BELOW + hlt_efficiencies = cms.untracked.PSet( + Ele17_12Leg1 = cms.untracked.FileInPath('cp3_llbb/Framework/data/Efficiencies/Electron_HLT_Ele17_12Leg1_TightID.json'), + Ele17_12Leg2 = cms.untracked.FileInPath('cp3_llbb/Framework/data/Efficiencies/Electron_HLT_Ele17_12Leg2_TightID.json'), + DoubleIsoMu17Mu8_IsoMu17leg = cms.untracked.FileInPath('cp3_llbb/Framework/data/Efficiencies/Muon_TnP_DoubleIsoMu17Mu8_IsoMu17leg_Run2015D_25ns_PTvsETA_binBig_HWW_ID_M_ISO_T.json'), + DoubleIsoMu17Mu8_IsoMu8leg = cms.untracked.FileInPath('cp3_llbb/Framework/data/Efficiencies/Muon_TnP_DoubleIsoMu17Mu8_IsoMu8leg_Run2015D_25ns_PTvsETA_binBig_HWW_ID_M_ISO_T.json'), + DoubleIsoMu17Mu8_TkMu8leg = cms.untracked.FileInPath('cp3_llbb/Framework/data/Efficiencies/Muon_TnP_DoubleIsoMu17Mu8_TkMu8leg_Run2015D_25ns_PTvsETA_binBig_HWW_ID_M_ISO_T.json') ) ) ) - +) # Add PUPPI MET puppiCfg = cms.PSet(METProducer.default_configuration.clone()) puppiCfg.prefix = cms.string('puppimet_') From 9819ae49064b09791d66030920c00cf9865f0033 Mon Sep 17 00:00:00 2001 From: Brieuc Francois Date: Sat, 30 Jan 2016 18:28:00 +0100 Subject: [PATCH 2/2] Second round for trigger efficiencies --- interface/HHAnalyzer.h | 56 +------------ interface/Types.h | 2 + plugins/HHAnalyzer.cc | 186 ++++++++++++++++++++++++++++++++++++++++- 3 files changed, 189 insertions(+), 55 deletions(-) diff --git a/interface/HHAnalyzer.h b/interface/HHAnalyzer.h index d191f42..63701de 100644 --- a/interface/HHAnalyzer.h +++ b/interface/HHAnalyzer.h @@ -55,7 +55,6 @@ class HHAnalyzer: public Framework::Analyzer { const edm::ParameterSet& hlt_efficiencies = config.getUntrackedParameter("hlt_efficiencies"); std::vector hlt_efficiencies_name = hlt_efficiencies.getParameterNames(); for (const std::string& hlt_efficiency: hlt_efficiencies_name) { - std::cout << "Adding hlt efficiencies : " << hlt_efficiency << std::endl; ScaleFactorParser parser(hlt_efficiencies.getUntrackedParameter(hlt_efficiency).fullPath()); m_hlt_efficiencies.emplace(hlt_efficiency, std::move(parser.get_scale_factor())); } @@ -93,6 +92,10 @@ class HHAnalyzer: public Framework::Analyzer { virtual void analyze(const edm::Event&, const edm::EventSetup&, const ProducersManager&, const AnalyzersManager&, const CategoryManager&) override; virtual void registerCategories(CategoryManager& manager, const edm::ParameterSet& config) override; + float getCosThetaStar_CS(const LorentzVector & h1, const LorentzVector & h2, float ebeam = 6500); + + void fillTriggerEfficiencies(const Lepton & lep1, const Lepton & lep2, Dilepton & dilep); + // global event stuff (selected objects multiplicity) BRANCH(nJets, unsigned int); BRANCH(nJetsL, unsigned int); @@ -109,57 +112,6 @@ class HHAnalyzer: public Framework::Analyzer { BRANCH(nLeptonsL, unsigned int); BRANCH(nLeptonsT, unsigned int); - float getCosThetaStar_CS(const LorentzVector & h1, const LorentzVector & h2, float ebeam = 6500) - {// cos theta star angle in the Collins Soper frame - LorentzVector p1, p2; - p1.SetPxPyPzE(0, 0, ebeam, ebeam); - p2.SetPxPyPzE(0, 0, -ebeam, ebeam); - - LorentzVector hh = h1 + h2; - ROOT::Math::Boost boost(-hh.X() / hh.T(), -hh.Y() / hh.T(), -hh.Z() / hh.T()); - p1 = boost(p1); - p2 = boost(p2); - LorentzVector newh1 = boost(h1); - ROOT::Math::DisplacementVector3D> CSaxis(p1.Vect().Unit() - p2.Vect().Unit()); - - return cos(ROOT::Math::VectorUtil::Angle(CSaxis.Unit(), newh1.Vect().Unit())); - } - - float getTriggerEfficiency(const Lepton & lep1, const Lepton & lep2) - { - float lep1_leg1 = 1., lep1_leg2 = 1., lep2_leg1 = 1., lep2_leg2 = 1.; - if (lep1.isMu && lep2.isMu) { - lep1_leg1 = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu17leg"].get({lep1.p4.Eta(), lep1.p4.Pt()})[0]; - lep1_leg2 = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu8leg"].get({lep1.p4.Eta(), lep1.p4.Pt()})[0]; - //lep1_tkLeg2 = m_hlt_efficiencies["DoubleIsoMu17Mu8_TkMu8leg"].get({lep1.p4.Eta(), lep1.p4.Pt()})[0]; - lep2_leg1 = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu17leg"].get({lep2.p4.Eta(), lep2.p4.Pt()})[0]; - lep2_leg2 = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu8leg"].get({lep2.p4.Eta(), lep2.p4.Pt()})[0]; - //lep2_tkLeg2 = m_hlt_efficiencies["DoubleIsoMu17Mu8_TkMu8leg"].get({lep2.p4.Eta(), lep2.p4.Pt()})[0]; - } - else if (lep1.isMu && lep2.isEl) { - lep1_leg1 = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu17leg"].get({lep1.p4.Eta(), lep1.p4.Pt()})[0]; - lep1_leg2 = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu8leg"].get({lep1.p4.Eta(), lep1.p4.Pt()})[0]; - lep2_leg1 = m_hlt_efficiencies["Ele17_12Leg1"].get({lep2.p4.Eta(), lep2.p4.Pt()})[0]; - lep2_leg2 = m_hlt_efficiencies["Ele17_12Leg2"].get({lep2.p4.Eta(), lep2.p4.Pt()})[0]; - } - else if (lep1.isEl && lep2.isMu) { - lep1_leg1 = m_hlt_efficiencies["Ele17_12Leg1"].get({lep1.p4.Eta(), lep1.p4.Pt()})[0]; - lep1_leg2 = m_hlt_efficiencies["Ele17_12Leg2"].get({lep1.p4.Eta(), lep1.p4.Pt()})[0]; - lep2_leg1 = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu17leg"].get({lep2.p4.Eta(), lep2.p4.Pt()})[0]; - lep2_leg2 = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu8leg"].get({lep2.p4.Eta(), lep2.p4.Pt()})[0]; - } - else if (lep1.isEl && lep2.isEl){ - lep1_leg1 = m_hlt_efficiencies["Ele17_12Leg1"].get({lep1.p4.Eta(), lep1.p4.Pt()})[0]; - lep1_leg2 = m_hlt_efficiencies["Ele17_12Leg2"].get({lep1.p4.Eta(), lep1.p4.Pt()})[0]; - lep2_leg1 = m_hlt_efficiencies["Ele17_12Leg1"].get({lep2.p4.Eta(), lep2.p4.Pt()})[0]; - lep2_leg2 = m_hlt_efficiencies["Ele17_12Leg2"].get({lep2.p4.Eta(), lep2.p4.Pt()})[0]; - } - float total_efficiency = lep1_leg1 * lep2_leg2 + lep1_leg2 * lep2_leg1 - lep1_leg1 * lep2_leg1; - return total_efficiency; - } - - - private: // Producers name std::string m_electrons_producer; diff --git a/interface/Types.h b/interface/Types.h index 58b5a5c..de6b31a 100644 --- a/interface/Types.h +++ b/interface/Types.h @@ -55,7 +55,9 @@ namespace HH { float gen_DPtOverPt; float trigger_efficiency; float trigger_efficiency_downVariated; + float trigger_efficiency_downVariated_Arun; float trigger_efficiency_upVariated; + float trigger_efficiency_upVariated_Arun; }; struct Met { LorentzVector p4; diff --git a/plugins/HHAnalyzer.cc b/plugins/HHAnalyzer.cc index 92023c7..513783a 100644 --- a/plugins/HHAnalyzer.cc +++ b/plugins/HHAnalyzer.cc @@ -185,9 +185,16 @@ void HHAnalyzer::analyze(const edm::Event& event, const edm::EventSetup&, const dilep.gen_p4 = dilep.gen_matched ? leptons[ilep1].gen_p4 + leptons[ilep2].gen_p4 : null_p4; dilep.gen_DR = dilep.gen_matched ? ROOT::Math::VectorUtil::DeltaR(dilep.p4, dilep.gen_p4) : -1.; dilep.gen_DPtOverPt = dilep.gen_matched ? (dilep.p4.Pt() - dilep.gen_p4.Pt()) / dilep.p4.Pt() : -10.; - dilep.trigger_efficiency = event.isRealData() ? 1. : getTriggerEfficiency(leptons[ilep1], leptons[ilep2]); - dilep.trigger_efficiency_downVariated = event.isRealData() ? 0. : 0; // FIXME : implement trigger efficiency error - dilep.trigger_efficiency_upVariated = event.isRealData() ? 0. : 0; // FIXME : implement trigger efficiency error + if (event.isRealData()) { + dilep.trigger_efficiency = 1.; + dilep.trigger_efficiency_downVariated = 1.; + dilep.trigger_efficiency_downVariated_Arun = 1.; + dilep.trigger_efficiency_upVariated = 1.; + dilep.trigger_efficiency_upVariated_Arun = 1.; + } + else { + fillTriggerEfficiencies(leptons[ilep1], leptons[ilep2], dilep); + } ll.push_back(dilep); } } @@ -1341,3 +1348,176 @@ void HHAnalyzer::analyze(const edm::Event& event, const edm::EventSetup&, const } +float HHAnalyzer::getCosThetaStar_CS(const LorentzVector & h1, const LorentzVector & h2, float ebeam /*= 6500*/) +{// cos theta star angle in the Collins Soper frame + LorentzVector p1, p2; + p1.SetPxPyPzE(0, 0, ebeam, ebeam); + p2.SetPxPyPzE(0, 0, -ebeam, ebeam); + + LorentzVector hh = h1 + h2; + ROOT::Math::Boost boost(-hh.X() / hh.T(), -hh.Y() / hh.T(), -hh.Z() / hh.T()); + p1 = boost(p1); + p2 = boost(p2); + LorentzVector newh1 = boost(h1); + ROOT::Math::DisplacementVector3D> CSaxis(p1.Vect().Unit() - p2.Vect().Unit()); + + return cos(ROOT::Math::VectorUtil::Angle(CSaxis.Unit(), newh1.Vect().Unit())); +} + +void HHAnalyzer::fillTriggerEfficiencies(const Lepton & lep1, const Lepton & lep2, Dilepton & dilep) { + + float eff_lep1_leg1 = 1.; + float eff_lep1_leg2 = 1.; + float eff_lep1_tkleg2 = 0.; + float eff_lep2_leg1 = 1.; + float eff_lep2_leg2 = 1.; + float eff_lep2_tkleg2 = 0.; + + if (lep1.isMu && lep2.isMu) { + eff_lep1_leg1 = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu17leg"].get({lep1.p4.Eta(), lep1.p4.Pt()})[0]; + eff_lep1_leg2 = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu8leg"].get({lep1.p4.Eta(), lep1.p4.Pt()})[0]; + eff_lep1_tkleg2 = m_hlt_efficiencies["DoubleIsoMu17Mu8_TkMu8leg"].get({lep1.p4.Eta(), lep1.p4.Pt()})[0]; + eff_lep2_leg1 = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu17leg"].get({lep2.p4.Eta(), lep2.p4.Pt()})[0]; + eff_lep2_leg2 = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu8leg"].get({lep2.p4.Eta(), lep2.p4.Pt()})[0]; + eff_lep2_tkleg2 = m_hlt_efficiencies["DoubleIsoMu17Mu8_TkMu8leg"].get({lep2.p4.Eta(), lep2.p4.Pt()})[0]; + } + else if (lep1.isMu && lep2.isEl) { + eff_lep1_leg1 = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu17leg"].get({lep1.p4.Eta(), lep1.p4.Pt()})[0]; + eff_lep1_leg2 = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu8leg"].get({lep1.p4.Eta(), lep1.p4.Pt()})[0]; + eff_lep2_leg1 = m_hlt_efficiencies["Ele17_12Leg1"].get({lep2.p4.Eta(), lep2.p4.Pt()})[0]; + eff_lep2_leg2 = m_hlt_efficiencies["Ele17_12Leg2"].get({lep2.p4.Eta(), lep2.p4.Pt()})[0]; + } + else if (lep1.isEl && lep2.isMu) { + eff_lep1_leg1 = m_hlt_efficiencies["Ele17_12Leg1"].get({lep1.p4.Eta(), lep1.p4.Pt()})[0]; + eff_lep1_leg2 = m_hlt_efficiencies["Ele17_12Leg2"].get({lep1.p4.Eta(), lep1.p4.Pt()})[0]; + eff_lep2_leg1 = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu17leg"].get({lep2.p4.Eta(), lep2.p4.Pt()})[0]; + eff_lep2_leg2 = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu8leg"].get({lep2.p4.Eta(), lep2.p4.Pt()})[0]; + } + else if (lep1.isEl && lep2.isEl){ + eff_lep1_leg1 = m_hlt_efficiencies["Ele17_12Leg1"].get({lep1.p4.Eta(), lep1.p4.Pt()})[0]; + eff_lep1_leg2 = m_hlt_efficiencies["Ele17_12Leg2"].get({lep1.p4.Eta(), lep1.p4.Pt()})[0]; + eff_lep2_leg1 = m_hlt_efficiencies["Ele17_12Leg1"].get({lep2.p4.Eta(), lep2.p4.Pt()})[0]; + eff_lep2_leg2 = m_hlt_efficiencies["Ele17_12Leg2"].get({lep2.p4.Eta(), lep2.p4.Pt()})[0]; + } + else + std::cout << "We have something else then el or mu !!" << std::endl; + + float error_eff_lep1_leg1_up = 0.; + float error_eff_lep1_leg2_up = 0.; + float error_eff_lep1_tkleg2_up = 0.; + float error_eff_lep2_leg1_up = 0.; + float error_eff_lep2_leg2_up = 0.; + float error_eff_lep2_tkleg2_up = 0.; + + if (lep1.isMu && lep2.isMu) { + error_eff_lep1_leg1_up = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu17leg"].get({lep1.p4.Eta(), lep1.p4.Pt()})[2]; + error_eff_lep1_leg2_up = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu8leg"].get({lep1.p4.Eta(), lep1.p4.Pt()})[2]; + error_eff_lep1_tkleg2_up = m_hlt_efficiencies["DoubleIsoMu17Mu8_TkMu8leg"].get({lep1.p4.Eta(), lep1.p4.Pt()})[2]; + error_eff_lep2_leg1_up = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu17leg"].get({lep2.p4.Eta(), lep2.p4.Pt()})[2]; + error_eff_lep2_leg2_up = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu8leg"].get({lep2.p4.Eta(), lep2.p4.Pt()})[2]; + error_eff_lep2_tkleg2_up = m_hlt_efficiencies["DoubleIsoMu17Mu8_TkMu8leg"].get({lep2.p4.Eta(), lep2.p4.Pt()})[2]; + } + else if (lep1.isMu && lep2.isEl) { + error_eff_lep1_leg1_up = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu17leg"].get({lep1.p4.Eta(), lep1.p4.Pt()})[2]; + error_eff_lep1_leg2_up = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu8leg"].get({lep1.p4.Eta(), lep1.p4.Pt()})[2]; + error_eff_lep2_leg1_up = m_hlt_efficiencies["Ele17_12Leg1"].get({lep2.p4.Eta(), lep2.p4.Pt()})[2]; + error_eff_lep2_leg2_up = m_hlt_efficiencies["Ele17_12Leg2"].get({lep2.p4.Eta(), lep2.p4.Pt()})[2]; + } + else if (lep1.isEl && lep2.isMu) { + error_eff_lep1_leg1_up = m_hlt_efficiencies["Ele17_12Leg1"].get({lep1.p4.Eta(), lep1.p4.Pt()})[2]; + error_eff_lep1_leg2_up = m_hlt_efficiencies["Ele17_12Leg2"].get({lep1.p4.Eta(), lep1.p4.Pt()})[2]; + error_eff_lep2_leg1_up = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu17leg"].get({lep2.p4.Eta(), lep2.p4.Pt()})[2]; + error_eff_lep2_leg2_up = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu8leg"].get({lep2.p4.Eta(), lep2.p4.Pt()})[2]; + } + else if (lep1.isEl && lep2.isEl){ + error_eff_lep1_leg1_up = m_hlt_efficiencies["Ele17_12Leg1"].get({lep1.p4.Eta(), lep1.p4.Pt()})[2]; + error_eff_lep1_leg2_up = m_hlt_efficiencies["Ele17_12Leg2"].get({lep1.p4.Eta(), lep1.p4.Pt()})[2]; + error_eff_lep2_leg1_up = m_hlt_efficiencies["Ele17_12Leg1"].get({lep2.p4.Eta(), lep2.p4.Pt()})[2]; + error_eff_lep2_leg2_up = m_hlt_efficiencies["Ele17_12Leg2"].get({lep2.p4.Eta(), lep2.p4.Pt()})[2]; + } + + float error_eff_lep1_leg1_down = 0.; + float error_eff_lep1_leg2_down = 0.; + float error_eff_lep1_tkleg2_down = 0.; + float error_eff_lep2_leg1_down = 0.; + float error_eff_lep2_leg2_down = 0.; + float error_eff_lep2_tkleg2_down = 0.; + + if (lep1.isMu && lep2.isMu) { + error_eff_lep1_leg1_down = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu17leg"].get({lep1.p4.Eta(), lep1.p4.Pt()})[1]; + error_eff_lep1_leg2_down = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu8leg"].get({lep1.p4.Eta(), lep1.p4.Pt()})[1]; + error_eff_lep1_tkleg2_down = m_hlt_efficiencies["DoubleIsoMu17Mu8_TkMu8leg"].get({lep1.p4.Eta(), lep1.p4.Pt()})[1]; + error_eff_lep2_leg1_down = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu17leg"].get({lep2.p4.Eta(), lep2.p4.Pt()})[1]; + error_eff_lep2_leg2_down = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu8leg"].get({lep2.p4.Eta(), lep2.p4.Pt()})[1]; + error_eff_lep2_tkleg2_down = m_hlt_efficiencies["DoubleIsoMu17Mu8_TkMu8leg"].get({lep2.p4.Eta(), lep2.p4.Pt()})[1]; + } + else if (lep1.isMu && lep2.isEl) { + error_eff_lep1_leg1_down = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu17leg"].get({lep1.p4.Eta(), lep1.p4.Pt()})[1]; + error_eff_lep1_leg2_down = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu8leg"].get({lep1.p4.Eta(), lep1.p4.Pt()})[1]; + error_eff_lep2_leg1_down = m_hlt_efficiencies["Ele17_12Leg1"].get({lep2.p4.Eta(), lep2.p4.Pt()})[1]; + error_eff_lep2_leg2_down = m_hlt_efficiencies["Ele17_12Leg2"].get({lep2.p4.Eta(), lep2.p4.Pt()})[1]; + } + else if (lep1.isEl && lep2.isMu) { + error_eff_lep1_leg1_down = m_hlt_efficiencies["Ele17_12Leg1"].get({lep1.p4.Eta(), lep1.p4.Pt()})[1]; + error_eff_lep1_leg2_down = m_hlt_efficiencies["Ele17_12Leg2"].get({lep1.p4.Eta(), lep1.p4.Pt()})[1]; + error_eff_lep2_leg1_down = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu17leg"].get({lep2.p4.Eta(), lep2.p4.Pt()})[1]; + error_eff_lep2_leg2_down = m_hlt_efficiencies["DoubleIsoMu17Mu8_IsoMu8leg"].get({lep2.p4.Eta(), lep2.p4.Pt()})[1]; + } + else if (lep1.isEl && lep2.isEl){ + error_eff_lep1_leg1_down = m_hlt_efficiencies["Ele17_12Leg1"].get({lep1.p4.Eta(), lep1.p4.Pt()})[1]; + error_eff_lep1_leg2_down = m_hlt_efficiencies["Ele17_12Leg2"].get({lep1.p4.Eta(), lep1.p4.Pt()})[1]; + error_eff_lep2_leg1_down = m_hlt_efficiencies["Ele17_12Leg1"].get({lep2.p4.Eta(), lep2.p4.Pt()})[1]; + error_eff_lep2_leg2_down = m_hlt_efficiencies["Ele17_12Leg2"].get({lep2.p4.Eta(), lep2.p4.Pt()})[1]; + } + + + float nominal = -(eff_lep1_leg1 * eff_lep2_leg1) + + (1 - (1 - eff_lep1_leg2) * (1 - eff_lep1_tkleg2)) * eff_lep2_leg1 + + eff_lep1_leg1 * (1 - (1 - eff_lep2_leg2) * (1 - eff_lep2_tkleg2)); + + float error_squared_up = + std::pow(1 - eff_lep2_leg1 - (1 - eff_lep2_leg2) * (1 - eff_lep2_tkleg2), 2) * + std::pow(error_eff_lep1_leg1_up, 2) + + std::pow(1 - eff_lep1_tkleg2, 2) * std::pow(eff_lep2_leg1, 2) * + std::pow(error_eff_lep1_leg2_up, 2) + + std::pow(1 - eff_lep1_leg2, 2) * std::pow(eff_lep2_leg1, 2) * + std::pow(error_eff_lep1_tkleg2_up, 2) + + std::pow(1 - eff_lep1_leg1 - (1 - eff_lep1_leg2) * (1 - eff_lep1_tkleg2), 2) * + std::pow(error_eff_lep2_leg1_up, 2) + + std::pow(eff_lep1_leg1, 2) * std::pow(1 - eff_lep2_tkleg2, 2) * + std::pow(error_eff_lep2_leg2_up, 2) + + std::pow(eff_lep1_leg1, 2) * std::pow(1 - eff_lep2_leg2, 2) * + std::pow(error_eff_lep2_tkleg2_up, 2); + + float error_squared_down = + std::pow(1 - eff_lep2_leg1 - (1 - eff_lep2_leg2) * (1 - eff_lep2_tkleg2), 2) * + std::pow(error_eff_lep1_leg1_down, 2) + + std::pow(1 - eff_lep1_tkleg2, 2) * std::pow(eff_lep2_leg1, 2) * + std::pow(error_eff_lep1_leg2_down, 2) + + std::pow(1 - eff_lep1_leg2, 2) * std::pow(eff_lep2_leg1, 2) * + std::pow(error_eff_lep1_tkleg2_down, 2) + + std::pow(1 - eff_lep1_leg1 - (1 - eff_lep1_leg2) * (1 - eff_lep1_tkleg2), 2) * + std::pow(error_eff_lep2_leg1_down, 2) + + std::pow(eff_lep1_leg1, 2) * std::pow(1 - eff_lep2_tkleg2, 2) * + std::pow(error_eff_lep2_leg2_down, 2) + + std::pow(eff_lep1_leg1, 2) * std::pow(1 - eff_lep2_leg2, 2) * + std::pow(error_eff_lep2_tkleg2_down, 2); + + dilep.trigger_efficiency = nominal; + dilep.trigger_efficiency_upVariated = ((nominal + std::sqrt(error_squared_up)) > 1.)? 1. : nominal + std::sqrt(error_squared_up); + dilep.trigger_efficiency_downVariated = ((nominal - std::sqrt(error_squared_down)) < 0.)? 0. : nominal - std::sqrt(error_squared_down); + + // Arun's method (not using the proper derivative formula) + float X = eff_lep1_leg1 * eff_lep2_leg2 * std::sqrt((std::pow((error_eff_lep1_leg1_up/eff_lep1_leg1),2) + std::pow((error_eff_lep2_leg2_up/eff_lep2_leg2),2) )); + float Y = eff_lep2_leg1 * eff_lep1_leg2 * std::sqrt((std::pow((error_eff_lep2_leg1_up/eff_lep2_leg1),2) + std::pow((error_eff_lep1_leg2_up/eff_lep1_leg2),2) )); + float Z = eff_lep1_leg1 * eff_lep2_leg1 * std::sqrt((std::pow((error_eff_lep1_leg1_up/eff_lep1_leg1),2) + std::pow((error_eff_lep2_leg1_up/eff_lep2_leg1),2) )); + float error_squared_up_Arun = X*X + Y*Y + Z*Z ; + dilep.trigger_efficiency_upVariated_Arun = ((nominal + std::sqrt(error_squared_up_Arun)) > 1.)? 1. : nominal + std::sqrt(error_squared_up_Arun); + + X = eff_lep1_leg1 * eff_lep2_leg2 * std::sqrt((std::pow((error_eff_lep1_leg1_down/eff_lep1_leg1),2) + std::pow((error_eff_lep2_leg2_down/eff_lep2_leg2),2) )); + Y = eff_lep2_leg1 * eff_lep1_leg2 * std::sqrt((std::pow((error_eff_lep2_leg1_down/eff_lep2_leg1),2) + std::pow((error_eff_lep1_leg2_down/eff_lep1_leg2),2) )); + Z = eff_lep1_leg1 * eff_lep2_leg1 * std::sqrt((std::pow((error_eff_lep1_leg1_down/eff_lep1_leg1),2) + std::pow((error_eff_lep2_leg1_down/eff_lep2_leg1),2) )); + float error_squared_down_Arun = X*X + Y*Y + Z*Z ; + dilep.trigger_efficiency_downVariated_Arun = ((nominal - std::sqrt(error_squared_down_Arun)) < 0.)? 0. : nominal - std::sqrt(error_squared_down_Arun); + +}