diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopAnalysis/Root/EventSaverFlatNtuple.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopAnalysis/Root/EventSaverFlatNtuple.cxx index 245d0e61751871ba7bd753360f4c9e587e873cb3..fec74244bfbaa92f7193fb4c0754c40d5a0c55a5 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopAnalysis/Root/EventSaverFlatNtuple.cxx +++ b/PhysicsAnalysis/TopPhys/xAOD/TopAnalysis/Root/EventSaverFlatNtuple.cxx @@ -64,6 +64,32 @@ namespace top { m_weight_leptonSF_MU_SF_ID_STAT_LOWPT_DOWN(0.), m_weight_leptonSF_MU_SF_ID_SYST_LOWPT_UP(0.), m_weight_leptonSF_MU_SF_ID_SYST_LOWPT_DOWN(0.), + m_weight_leptonSF_MU_SF_ID_BKG_FRACTION_UP(0.), + m_weight_leptonSF_MU_SF_ID_BKG_FRACTION_DOWN(0.), + m_weight_leptonSF_MU_SF_ID_FIT_MODEL_LOWPT_UP(0.), + m_weight_leptonSF_MU_SF_ID_FIT_MODEL_LOWPT_DOWN(0.), + m_weight_leptonSF_MU_SF_ID_LUMI_UNCERT_UP(0.), + m_weight_leptonSF_MU_SF_ID_LUMI_UNCERT_DOWN(0.), + m_weight_leptonSF_MU_SF_ID_MATCHING_UP(0.), + m_weight_leptonSF_MU_SF_ID_MATCHING_DOWN(0.), + m_weight_leptonSF_MU_SF_ID_MATCHING_LOWPT_UP(0.), + m_weight_leptonSF_MU_SF_ID_MATCHING_LOWPT_DOWN(0.), + m_weight_leptonSF_MU_SF_ID_MC_XSEC_UP(0.), + m_weight_leptonSF_MU_SF_ID_MC_XSEC_DOWN(0.), + m_weight_leptonSF_MU_SF_ID_PT_DEPENDENCY_UP(0.), + m_weight_leptonSF_MU_SF_ID_PT_DEPENDENCY_DOWN(0.), + m_weight_leptonSF_MU_SF_ID_QCD_TEMPLATE_UP(0.), + m_weight_leptonSF_MU_SF_ID_QCD_TEMPLATE_DOWN(0.), + m_weight_leptonSF_MU_SF_ID_SUPRESSION_SCALE_UP(0.), + m_weight_leptonSF_MU_SF_ID_SUPRESSION_SCALE_DOWN(0.), + m_weight_leptonSF_MU_SF_ID_SYS_UP(0.), + m_weight_leptonSF_MU_SF_ID_SYS_DOWN(0.), + m_weight_leptonSF_MU_SF_ID_TRUTH_UP(0.), + m_weight_leptonSF_MU_SF_ID_TRUTH_DOWN(0.), + m_weight_leptonSF_MU_SF_ID_TRUTH_LOWPT_UP(0.), + m_weight_leptonSF_MU_SF_ID_TRUTH_LOWPT_DOWN(0.), + m_weight_leptonSF_MU_SF_ID_BAD_MUON_VETO_UP(0.), + m_weight_leptonSF_MU_SF_ID_BAD_MUON_VETO_DOWN(0.), // Muon isolation SF systematics m_weight_leptonSF_MU_SF_Isol_STAT_UP(0.), m_weight_leptonSF_MU_SF_Isol_STAT_DOWN(0.), @@ -73,6 +99,16 @@ namespace top { m_weight_leptonSF_MU_SF_TTVA_STAT_DOWN(0.), m_weight_leptonSF_MU_SF_TTVA_SYST_UP(0.), m_weight_leptonSF_MU_SF_TTVA_SYST_DOWN(0.), + m_weight_leptonSF_MU_SF_TTVA_BKG_FRACTION_UP(0.), + m_weight_leptonSF_MU_SF_TTVA_BKG_FRACTION_DOWN(0.), + m_weight_leptonSF_MU_SF_TTVA_LUMI_UNCERT_UP(0.), + m_weight_leptonSF_MU_SF_TTVA_LUMI_UNCERT_DOWN(0.), + m_weight_leptonSF_MU_SF_TTVA_MC_XSEC_UP(0.), + m_weight_leptonSF_MU_SF_TTVA_MC_XSEC_DOWN(0.), + m_weight_leptonSF_MU_SF_TTVA_QCD_TEMPLATE_UP(0.), + m_weight_leptonSF_MU_SF_TTVA_QCD_TEMPLATE_DOWN(0.), + m_weight_leptonSF_MU_SF_TTVA_SUPRESSION_SCALE_UP(0.), + m_weight_leptonSF_MU_SF_TTVA_SUPRESSION_SCALE_DOWN(0.), // triggers m_weight_trigger(0.), @@ -511,18 +547,80 @@ namespace top { systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_STAT_UP, "weight_leptonSF_MU_SF_ID_STAT_UP"); systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_STAT_DOWN, "weight_leptonSF_MU_SF_ID_STAT_DOWN"); - systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_SYST_UP, "weight_leptonSF_MU_SF_ID_SYST_UP"); - systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_SYST_DOWN, - "weight_leptonSF_MU_SF_ID_SYST_DOWN"); - // Muon ID SF systematics (low pt) systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_STAT_LOWPT_UP, "weight_leptonSF_MU_SF_ID_STAT_LOWPT_UP"); systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_STAT_LOWPT_DOWN, "weight_leptonSF_MU_SF_ID_STAT_LOWPT_DOWN"); - systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_SYST_LOWPT_UP, - "weight_leptonSF_MU_SF_ID_SYST_LOWPT_UP"); - systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_SYST_LOWPT_DOWN, - "weight_leptonSF_MU_SF_ID_SYST_LOWPT_DOWN"); + if (m_config->muonBreakDownSystematics()) { + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_BKG_FRACTION_UP, + "weight_leptonSF_MU_SF_ID_BKG_FRACTION_UP"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_BKG_FRACTION_DOWN, + "weight_leptonSF_MU_SF_ID_BKG_FRACTION_DOWN"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_FIT_MODEL_LOWPT_UP, + "weight_leptonSF_MU_SF_ID_FIT_MODEL_LOWPT_UP"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_FIT_MODEL_LOWPT_DOWN, + "weight_leptonSF_MU_SF_ID_FIT_MODEL_LOWPT_DOWN"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_LUMI_UNCERT_UP, + "weight_leptonSF_MU_SF_ID_LUMI_UNCERT_UP"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_LUMI_UNCERT_DOWN, + "weight_leptonSF_MU_SF_ID_LUMI_UNCERT_DOWN"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_MATCHING_UP, + "weight_leptonSF_MU_SF_ID_MATCHING_UP"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_MATCHING_DOWN, + "weight_leptonSF_MU_SF_ID_MATCHING_DOWN"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_MATCHING_LOWPT_UP, + "weight_leptonSF_MU_SF_ID_MATCHING_LOWPT_UP"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_MATCHING_LOWPT_DOWN, + "weight_leptonSF_MU_SF_ID_MATCHING_LOWPT_DOWN"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_MC_XSEC_UP, + "weight_leptonSF_MU_SF_ID_MC_XSEC_UP"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_MC_XSEC_DOWN, + "weight_leptonSF_MU_SF_ID_MC_XSEC_DOWN"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_PT_DEPENDENCY_UP, + "weight_leptonSF_MU_SF_ID_PT_DEPENDENCY_UP"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_PT_DEPENDENCY_DOWN, + "weight_leptonSF_MU_SF_ID_PT_DEPENDENCY_DOWN"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_QCD_TEMPLATE_UP, + "weight_leptonSF_MU_SF_ID_QCD_TEMPLATE_UP"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_QCD_TEMPLATE_DOWN, + "weight_leptonSF_MU_SF_ID_QCD_TEMPLATE_DOWN"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_SUPRESSION_SCALE_UP, + "weight_leptonSF_MU_SF_ID_SUPRESSION_SCALE_UP"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_SUPRESSION_SCALE_DOWN, + "weight_leptonSF_MU_SF_ID_SUPRESSION_SCALE_DOWN"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_SYS_UP, + "weight_leptonSF_MU_SF_ID_SYS_UP"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_SYS_DOWN, + "weight_leptonSF_MU_SF_ID_SYS_DOWN"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_TRUTH_UP, + "weight_leptonSF_MU_SF_ID_TRUTH_UP"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_TRUTH_DOWN, + "weight_leptonSF_MU_SF_ID_TRUTH_DOWN"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_TRUTH_LOWPT_UP, + "weight_leptonSF_MU_SF_ID_TRUTH_LOWPT_UP"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_TRUTH_LOWPT_DOWN, + "weight_leptonSF_MU_SF_ID_TRUTH_LOWPT_DOWN"); + } else { + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_SYST_LOWPT_UP, + "weight_leptonSF_MU_SF_ID_SYST_LOWPT_UP"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_SYST_LOWPT_DOWN, + "weight_leptonSF_MU_SF_ID_SYST_LOWPT_DOWN"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_SYST_UP, "weight_leptonSF_MU_SF_ID_SYST_UP"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_SYST_DOWN, + "weight_leptonSF_MU_SF_ID_SYST_DOWN"); + } + if (systematicTree->name() == nominalTTreeName && m_config->muonQuality() == "HighPt") { + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_BAD_MUON_VETO_UP, + "weight_leptonSF_MU_SF_ID_BAD_MUON_VETO_UP"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_BAD_MUON_VETO_DOWN, + "weight_leptonSF_MU_SF_ID_BAD_MUON_VETO_DOWN"); + } + if (systematicTree->name() == nominalLooseTTreeName && m_config->muonQualityLoose() == "HighPt") { + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_BAD_MUON_VETO_UP, + "weight_leptonSF_MU_SF_ID_BAD_MUON_VETO_UP"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_ID_BAD_MUON_VETO_DOWN, + "weight_leptonSF_MU_SF_ID_BAD_MUON_VETO_DOWN"); + } // Muon isolation SF systematics systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_Isol_STAT_UP, "weight_leptonSF_MU_SF_Isol_STAT_UP"); @@ -536,10 +634,33 @@ namespace top { "weight_leptonSF_MU_SF_TTVA_STAT_UP"); systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_TTVA_STAT_DOWN, "weight_leptonSF_MU_SF_TTVA_STAT_DOWN"); - systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_TTVA_SYST_UP, - "weight_leptonSF_MU_SF_TTVA_SYST_UP"); - systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_TTVA_SYST_DOWN, - "weight_leptonSF_MU_SF_TTVA_SYST_DOWN"); + if (m_config->muonBreakDownSystematics()) { + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_TTVA_BKG_FRACTION_UP, + "weight_leptonSF_MU_SF_TTVA_BKG_FRACTION_UP"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_TTVA_BKG_FRACTION_DOWN, + "weight_leptonSF_MU_SF_TTVA_BKG_FRACTION_DOWN"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_TTVA_LUMI_UNCERT_UP, + "weight_leptonSF_MU_SF_TTVA_LUMI_UNCERT_UP"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_TTVA_LUMI_UNCERT_DOWN, + "weight_leptonSF_MU_SF_TTVA_LUMI_UNCERT_DOWN"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_TTVA_MC_XSEC_UP, + "weight_leptonSF_MU_SF_TTVA_MC_XSEC_UP"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_TTVA_MC_XSEC_DOWN, + "weight_leptonSF_MU_SF_TTVA_MC_XSEC_DOWN"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_TTVA_QCD_TEMPLATE_UP, + "weight_leptonSF_MU_SF_TTVA_QCD_TEMPLATE_UP"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_TTVA_QCD_TEMPLATE_DOWN, + "weight_leptonSF_MU_SF_TTVA_QCD_TEMPLATE_DOWN"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_TTVA_SUPRESSION_SCALE_UP, + "weight_leptonSF_MU_SF_TTVA_SUPRESSION_SCALE_UP"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_TTVA_SUPRESSION_SCALE_DOWN, + "weight_leptonSF_MU_SF_TTVA_SUPRESSION_SCALE_DOWN"); + } else { + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_TTVA_SYST_UP, + "weight_leptonSF_MU_SF_TTVA_SYST_UP"); + systematicTree->makeOutputVariable(m_weight_leptonSF_MU_SF_TTVA_SYST_DOWN, + "weight_leptonSF_MU_SF_TTVA_SYST_DOWN"); + } if (m_config->useTaus()) { // Tau-electron overlap removal @@ -1771,12 +1892,12 @@ namespace top { m_weight_leptonSF_EL_SF_Isol_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::EL_SF_Isol_DOWN); if (m_config->electronEfficiencySystematicModel() != "TOTAL") { - m_weight_leptonSF_EL_SF_CorrModel_Reco_UP = m_sfRetriever->electronSFSystVariationVector(event, top::topSFComp::RECO, 1); - m_weight_leptonSF_EL_SF_CorrModel_Reco_DOWN = m_sfRetriever->electronSFSystVariationVector(event, top::topSFComp::RECO, -1); - m_weight_leptonSF_EL_SF_CorrModel_ID_UP = m_sfRetriever->electronSFSystVariationVector(event, top::topSFComp::ID, 1); - m_weight_leptonSF_EL_SF_CorrModel_ID_DOWN = m_sfRetriever->electronSFSystVariationVector(event, top::topSFComp::ID, -1); - m_weight_leptonSF_EL_SF_CorrModel_Iso_UP = m_sfRetriever->electronSFSystVariationVector(event, top::topSFComp::ISOLATION, 1); - m_weight_leptonSF_EL_SF_CorrModel_Iso_DOWN = m_sfRetriever->electronSFSystVariationVector(event, top::topSFComp::ISOLATION, -1); + m_weight_leptonSF_EL_SF_CorrModel_Reco_UP = m_sfRetriever->electronSFSystVariationVector(event, top::topSFComp::RECO, 1, m_config->electronEfficiencySystematicModelRecoSize()); + m_weight_leptonSF_EL_SF_CorrModel_Reco_DOWN = m_sfRetriever->electronSFSystVariationVector(event, top::topSFComp::RECO, -1,m_config->electronEfficiencySystematicModelRecoSize() ); + m_weight_leptonSF_EL_SF_CorrModel_ID_UP = m_sfRetriever->electronSFSystVariationVector(event, top::topSFComp::ID, 1,m_config->electronEfficiencySystematicModelIdSize() ); + m_weight_leptonSF_EL_SF_CorrModel_ID_DOWN = m_sfRetriever->electronSFSystVariationVector(event, top::topSFComp::ID, -1,m_config->electronEfficiencySystematicModelIdSize() ); + m_weight_leptonSF_EL_SF_CorrModel_Iso_UP = m_sfRetriever->electronSFSystVariationVector(event, top::topSFComp::ISOLATION, 1,m_config->electronEfficiencySystematicModelIsoSize() ); + m_weight_leptonSF_EL_SF_CorrModel_Iso_DOWN = m_sfRetriever->electronSFSystVariationVector(event, top::topSFComp::ISOLATION, -1,m_config->electronEfficiencySystematicModelIsoSize() ); } m_weight_trigger_MU_SF_STAT_UP = m_sfRetriever->triggerSF(event, top::topSFSyst::MU_SF_Trigger_STAT_UP); m_weight_trigger_MU_SF_STAT_DOWN = m_sfRetriever->triggerSF(event, top::topSFSyst::MU_SF_Trigger_STAT_DOWN); @@ -1785,13 +1906,47 @@ namespace top { // Muon ID SF systematics (regular) m_weight_leptonSF_MU_SF_ID_STAT_UP = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_STAT_UP); m_weight_leptonSF_MU_SF_ID_STAT_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_STAT_DOWN); - m_weight_leptonSF_MU_SF_ID_SYST_UP = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_SYST_UP); - m_weight_leptonSF_MU_SF_ID_SYST_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_SYST_DOWN); - // Muon ID SF systematics (regular) m_weight_leptonSF_MU_SF_ID_STAT_LOWPT_UP = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_STAT_LOWPT_UP); m_weight_leptonSF_MU_SF_ID_STAT_LOWPT_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_STAT_LOWPT_DOWN); - m_weight_leptonSF_MU_SF_ID_SYST_LOWPT_UP = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_SYST_LOWPT_UP); - m_weight_leptonSF_MU_SF_ID_SYST_LOWPT_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_SYST_LOWPT_DOWN); + if (m_config->muonBreakDownSystematics()) { + m_weight_leptonSF_MU_SF_ID_BKG_FRACTION_UP = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_BKG_FRACTION_UP); + m_weight_leptonSF_MU_SF_ID_BKG_FRACTION_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_BKG_FRACTION_DOWN); + m_weight_leptonSF_MU_SF_ID_FIT_MODEL_LOWPT_UP = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_FIT_MODEL_LOWPT_UP); + m_weight_leptonSF_MU_SF_ID_FIT_MODEL_LOWPT_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_FIT_MODEL_LOWPT_DOWN); + m_weight_leptonSF_MU_SF_ID_LUMI_UNCERT_UP = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_LUMI_UNCERT_UP); + m_weight_leptonSF_MU_SF_ID_LUMI_UNCERT_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_LUMI_UNCERT_DOWN); + m_weight_leptonSF_MU_SF_ID_MATCHING_UP = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_MATCHING_UP); + m_weight_leptonSF_MU_SF_ID_MATCHING_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_MATCHING_DOWN); + m_weight_leptonSF_MU_SF_ID_MATCHING_LOWPT_UP = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_MATCHING_LOWPT_UP); + m_weight_leptonSF_MU_SF_ID_MATCHING_LOWPT_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_MATCHING_LOWPT_DOWN); + m_weight_leptonSF_MU_SF_ID_MC_XSEC_UP = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_MC_XSEC_UP); + m_weight_leptonSF_MU_SF_ID_MC_XSEC_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_MC_XSEC_DOWN); + m_weight_leptonSF_MU_SF_ID_PT_DEPENDENCY_UP = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_PT_DEPENDENCY_UP); + m_weight_leptonSF_MU_SF_ID_PT_DEPENDENCY_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_PT_DEPENDENCY_DOWN); + m_weight_leptonSF_MU_SF_ID_QCD_TEMPLATE_UP = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_QCD_TEMPLATE_UP); + m_weight_leptonSF_MU_SF_ID_QCD_TEMPLATE_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_QCD_TEMPLATE_DOWN); + m_weight_leptonSF_MU_SF_ID_SUPRESSION_SCALE_UP = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_SUPRESSION_SCALE_UP); + m_weight_leptonSF_MU_SF_ID_SUPRESSION_SCALE_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_SUPRESSION_SCALE_DOWN); + m_weight_leptonSF_MU_SF_ID_SYS_UP = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_SYS_UP); + m_weight_leptonSF_MU_SF_ID_SYS_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_SYS_DOWN); + m_weight_leptonSF_MU_SF_ID_TRUTH_UP = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_TRUTH_UP); + m_weight_leptonSF_MU_SF_ID_TRUTH_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_TRUTH_DOWN); + m_weight_leptonSF_MU_SF_ID_TRUTH_LOWPT_UP = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_TRUTH_LOWPT_UP); + m_weight_leptonSF_MU_SF_ID_TRUTH_LOWPT_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_TRUTH_LOWPT_DOWN); + } else { + m_weight_leptonSF_MU_SF_ID_SYST_LOWPT_UP = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_SYST_LOWPT_UP); + m_weight_leptonSF_MU_SF_ID_SYST_LOWPT_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_SYST_LOWPT_DOWN); + m_weight_leptonSF_MU_SF_ID_SYST_UP = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_SYST_UP); + m_weight_leptonSF_MU_SF_ID_SYST_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_SYST_DOWN); + } + if (m_config->doTightEvents() && m_config->muonQuality() == "HighPt") { + m_weight_leptonSF_MU_SF_ID_BAD_MUON_VETO_UP = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_BAD_MUON_VETO_UP); + m_weight_leptonSF_MU_SF_ID_BAD_MUON_VETO_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_BAD_MUON_VETO_DOWN); + } + if (m_config->doLooseEvents() && m_config->muonQualityLoose() == "HighPt") { + m_weight_leptonSF_MU_SF_ID_BAD_MUON_VETO_UP = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_BAD_MUON_VETO_UP); + m_weight_leptonSF_MU_SF_ID_BAD_MUON_VETO_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_ID_BAD_MUON_VETO_DOWN); + } // Muon isolation SF systematics m_weight_leptonSF_MU_SF_Isol_STAT_UP = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_Isol_STAT_UP); m_weight_leptonSF_MU_SF_Isol_STAT_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_Isol_STAT_DOWN); @@ -1799,8 +1954,21 @@ namespace top { m_weight_leptonSF_MU_SF_Isol_SYST_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_Isol_SYST_DOWN); m_weight_leptonSF_MU_SF_TTVA_STAT_UP = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_TTVA_STAT_UP); m_weight_leptonSF_MU_SF_TTVA_STAT_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_TTVA_STAT_DOWN); - m_weight_leptonSF_MU_SF_TTVA_SYST_UP = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_TTVA_SYST_UP); - m_weight_leptonSF_MU_SF_TTVA_SYST_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_TTVA_SYST_DOWN); + if (m_config->muonBreakDownSystematics()) { + m_weight_leptonSF_MU_SF_TTVA_BKG_FRACTION_UP = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_TTVA_BKG_FRACTION_UP); + m_weight_leptonSF_MU_SF_TTVA_BKG_FRACTION_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_TTVA_BKG_FRACTION_DOWN); + m_weight_leptonSF_MU_SF_TTVA_LUMI_UNCERT_UP = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_TTVA_LUMI_UNCERT_UP); + m_weight_leptonSF_MU_SF_TTVA_LUMI_UNCERT_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_TTVA_LUMI_UNCERT_DOWN); + m_weight_leptonSF_MU_SF_TTVA_MC_XSEC_UP = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_TTVA_MC_XSEC_UP); + m_weight_leptonSF_MU_SF_TTVA_MC_XSEC_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_TTVA_MC_XSEC_DOWN); + m_weight_leptonSF_MU_SF_TTVA_QCD_TEMPLATE_UP = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_TTVA_QCD_TEMPLATE_UP); + m_weight_leptonSF_MU_SF_TTVA_QCD_TEMPLATE_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_TTVA_QCD_TEMPLATE_DOWN); + m_weight_leptonSF_MU_SF_TTVA_SUPRESSION_SCALE_UP = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_TTVA_SUPRESSION_SCALE_UP); + m_weight_leptonSF_MU_SF_TTVA_SUPRESSION_SCALE_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_TTVA_SUPRESSION_SCALE_DOWN); + } else { + m_weight_leptonSF_MU_SF_TTVA_SYST_UP = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_TTVA_SYST_UP); + m_weight_leptonSF_MU_SF_TTVA_SYST_DOWN = m_sfRetriever->leptonSF(event, top::topSFSyst::MU_SF_TTVA_SYST_DOWN); + } if (m_config->useTaus()) { // Tau-electron overlap removal diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopAnalysis/Root/ObjectLoaderStandardCuts.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopAnalysis/Root/ObjectLoaderStandardCuts.cxx index 8619fb371318e95b34902a55f891d879baf4049b..2ed5dfa3c880772e9b7b16c4599d7d8a5bd94f49 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopAnalysis/Root/ObjectLoaderStandardCuts.cxx +++ b/PhysicsAnalysis/TopPhys/xAOD/TopAnalysis/Root/ObjectLoaderStandardCuts.cxx @@ -91,7 +91,7 @@ namespace top { } ///-- Soft Muons --/// - if (topConfig->useSoftMuons()) { + if (topConfig->useMuons() && topConfig->useSoftMuons()) { objectSelection->softmuonSelection(new top::SoftMuon(topConfig->softmuonPtcut())); } diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopAnalysis/TopAnalysis/EventSaverFlatNtuple.h b/PhysicsAnalysis/TopPhys/xAOD/TopAnalysis/TopAnalysis/EventSaverFlatNtuple.h index e5cafbb419922f55ea4ffbbc4468825516764644..4ce3b8edbbcab6b011d603a0a4ec50a24f46c42f 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopAnalysis/TopAnalysis/EventSaverFlatNtuple.h +++ b/PhysicsAnalysis/TopPhys/xAOD/TopAnalysis/TopAnalysis/EventSaverFlatNtuple.h @@ -285,6 +285,32 @@ namespace top { float m_weight_leptonSF_MU_SF_ID_STAT_LOWPT_DOWN; float m_weight_leptonSF_MU_SF_ID_SYST_LOWPT_UP; float m_weight_leptonSF_MU_SF_ID_SYST_LOWPT_DOWN; + float m_weight_leptonSF_MU_SF_ID_BKG_FRACTION_UP; + float m_weight_leptonSF_MU_SF_ID_BKG_FRACTION_DOWN; + float m_weight_leptonSF_MU_SF_ID_FIT_MODEL_LOWPT_UP; + float m_weight_leptonSF_MU_SF_ID_FIT_MODEL_LOWPT_DOWN; + float m_weight_leptonSF_MU_SF_ID_LUMI_UNCERT_UP; + float m_weight_leptonSF_MU_SF_ID_LUMI_UNCERT_DOWN; + float m_weight_leptonSF_MU_SF_ID_MATCHING_UP; + float m_weight_leptonSF_MU_SF_ID_MATCHING_DOWN; + float m_weight_leptonSF_MU_SF_ID_MATCHING_LOWPT_UP; + float m_weight_leptonSF_MU_SF_ID_MATCHING_LOWPT_DOWN; + float m_weight_leptonSF_MU_SF_ID_MC_XSEC_UP; + float m_weight_leptonSF_MU_SF_ID_MC_XSEC_DOWN; + float m_weight_leptonSF_MU_SF_ID_PT_DEPENDENCY_UP; + float m_weight_leptonSF_MU_SF_ID_PT_DEPENDENCY_DOWN; + float m_weight_leptonSF_MU_SF_ID_QCD_TEMPLATE_UP; + float m_weight_leptonSF_MU_SF_ID_QCD_TEMPLATE_DOWN; + float m_weight_leptonSF_MU_SF_ID_SUPRESSION_SCALE_UP; + float m_weight_leptonSF_MU_SF_ID_SUPRESSION_SCALE_DOWN; + float m_weight_leptonSF_MU_SF_ID_SYS_UP; + float m_weight_leptonSF_MU_SF_ID_SYS_DOWN; + float m_weight_leptonSF_MU_SF_ID_TRUTH_UP; + float m_weight_leptonSF_MU_SF_ID_TRUTH_DOWN; + float m_weight_leptonSF_MU_SF_ID_TRUTH_LOWPT_UP; + float m_weight_leptonSF_MU_SF_ID_TRUTH_LOWPT_DOWN; + float m_weight_leptonSF_MU_SF_ID_BAD_MUON_VETO_UP; + float m_weight_leptonSF_MU_SF_ID_BAD_MUON_VETO_DOWN; // Muon isolation SF systematics float m_weight_leptonSF_MU_SF_Isol_STAT_UP; float m_weight_leptonSF_MU_SF_Isol_STAT_DOWN; @@ -294,6 +320,16 @@ namespace top { float m_weight_leptonSF_MU_SF_TTVA_STAT_DOWN; float m_weight_leptonSF_MU_SF_TTVA_SYST_UP; float m_weight_leptonSF_MU_SF_TTVA_SYST_DOWN; + float m_weight_leptonSF_MU_SF_TTVA_BKG_FRACTION_UP; + float m_weight_leptonSF_MU_SF_TTVA_BKG_FRACTION_DOWN; + float m_weight_leptonSF_MU_SF_TTVA_LUMI_UNCERT_UP; + float m_weight_leptonSF_MU_SF_TTVA_LUMI_UNCERT_DOWN; + float m_weight_leptonSF_MU_SF_TTVA_MC_XSEC_UP; + float m_weight_leptonSF_MU_SF_TTVA_MC_XSEC_DOWN; + float m_weight_leptonSF_MU_SF_TTVA_QCD_TEMPLATE_UP; + float m_weight_leptonSF_MU_SF_TTVA_QCD_TEMPLATE_DOWN; + float m_weight_leptonSF_MU_SF_TTVA_SUPRESSION_SCALE_UP; + float m_weight_leptonSF_MU_SF_TTVA_SUPRESSION_SCALE_DOWN; ///-- triggers --/// float m_weight_trigger; diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopAnalysis/util/top-xaod.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopAnalysis/util/top-xaod.cxx index 640b1fac2a928caaf2b0251d42b0e80adcd84c37..63e0bae28055bd6405771a000ed54b7930598bc4 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopAnalysis/util/top-xaod.cxx +++ b/PhysicsAnalysis/TopPhys/xAOD/TopAnalysis/util/top-xaod.cxx @@ -596,6 +596,15 @@ int main(int argc, char** argv) { << " TO USE DEFAULT MODEL, REMOVE 'EGammaCalibrationModel' FROM CONFIG FILE \n" << "*************************************************************************\n\n"); } + if (topConfig->printEIDFileWarning()) { + ATH_MSG_WARNING( + "\n*************************************************************************\n" + << " YOU ARE USING THIS CUSTOM PATH TO THE ELECTRON ID SF FILE: \n\n" + << topConfig->electronIDSFFilePath() << "\n\n" + << " INSTEAD OF THE MOST RECENT RECOMMENDED MAP \n" + << " YOU MANY NOT BE USING THE LATEST ELECTRON ID RECOMMENDATIONS \n" + << "*************************************************************************\n\n"); + } const unsigned int entries = xaodEvent.getEntries(); totalEventsInFiles += entries; diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/Root/TopEgammaCPTools.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/Root/TopEgammaCPTools.cxx index 263bd784227609fb63b89104a9ed8cdcf4e0da6a..618e7c142bc2b3fedcc6cc1df3df5b99f69eb82b 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/Root/TopEgammaCPTools.cxx +++ b/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/Root/TopEgammaCPTools.cxx @@ -1,5 +1,5 @@ /* - Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration + Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration */ #include "TopCPTools/TopEgammaCPTools.h" @@ -269,10 +269,35 @@ namespace top { // hopefully remove the map soon! std::string electronIsolationLoose = mapWorkingPoints(m_config->electronIsolationSFLoose()); + if(electronIsolation == "PLImprovedTight" || electronIsolation == "PLImprovedVeryTight"){ + if(!(electronID == "TightLLH" || electronID == "MediumLLH")){ + ATH_MSG_ERROR("Combination of electron PLIV WP and ID WP not available. Try MediumLH or TightLH."); + return StatusCode::FAILURE; + } + } + if(electronIsolationLoose == "PLImprovedTight" || electronIsolationLoose == "PLImprovedVeryTight"){ + if(!(electronIDLoose == "TightLLH" || electronIDLoose == "MediumLLH")){ + ATH_MSG_ERROR("Combination of loose electron PLIV WP and ID WP not available. Try MediumLH or TightLH."); + return StatusCode::FAILURE; + } + } + if(electronIsolation == "PLImprovedTight" || electronIsolation == "PLImprovedVeryTight" || electronIsolationLoose == "PLImprovedTight" || electronIsolationLoose == "PLImprovedVeryTight"){ + if(dataType == 3){ + ATH_MSG_ERROR("electron PLIV WPs are only available for FullSim."); + return StatusCode::FAILURE; + } + ATH_MSG_WARNING("Trigger SFs for PLIV isolation unavailable. Proceeding without online Isolation."); + } + // Retrieve full path to maps for different types of tool m_electronEffSFRecoFile = electronSFMapFilePath("reco"); // - Tight m_electronEffSFIDFile = electronSFMapFilePath("ID"); + std::vector inExpID; + if(m_config->electronIDSFFilePath() !="Default"){ + m_config->setPrintEIDFileWarning(true); + inExpID.push_back(electronSFFilePath("EXPID", electronID, electronIsolation)); + } m_electronEffSFTriggerFile = electronSFMapFilePath("trigger"); m_electronEffTriggerFile = electronSFMapFilePath("trigger"); std::vector inPLViso; @@ -317,24 +342,30 @@ namespace top { m_electronEffSFReco = setupElectronSFToolWithMap(elSFPrefix + "Reco", m_electronEffSFRecoFile, "Reconstruction", "", "", "", dataType, "TOTAL", "", ""); // ID SFs - m_electronEffSFID = setupElectronSFToolWithMap(elSFPrefix + "ID", m_electronEffSFIDFile, "", electronID, "", "", + if(m_config->electronIDSFFilePath() =="Default") m_electronEffSFID = setupElectronSFToolWithMap(elSFPrefix + "ID", m_electronEffSFIDFile, "", electronID, "", "", dataType, "TOTAL", "", ""); + else m_electronEffSFID = setupElectronSFTool(elSFPrefix + "ID", inExpID, dataType); m_electronEffSFIDLoose = setupElectronSFToolWithMap(elSFPrefix + "IDLoose", m_electronEffSFIDLooseFile, "", electronIDLoose, "", "", dataType, "TOTAL", "", ""); // Trigger SFs m_electronEffSFTrigger = setupElectronSFToolWithMap(elSFPrefix + "TriggerSF", m_electronEffSFTriggerFile, "", - electronID, electronIsolation, trigger_string, dataType, + electronID, + (!(electronIsolation == "PLImprovedTight" || electronIsolation == "PLImprovedVeryTight")) ? electronIsolation : "", + trigger_string, dataType, "TOTAL", "", ""); m_electronEffSFTriggerLoose = setupElectronSFToolWithMap(elSFPrefix + "TriggerSFLoose", m_electronEffSFTriggerLooseFile, "", electronIDLoose, - electronIsolationLoose, trigger_string, dataType, "TOTAL", + (!(electronIsolationLoose == "PLImprovedTight" || electronIsolationLoose == "PLImprovedVeryTight")) ? electronIsolationLoose : "", + trigger_string, dataType, "TOTAL", "", ""); // Trigger Efficiencies m_electronEffTrigger = setupElectronSFToolWithMap(elSFPrefix + "Trigger", m_electronEffTriggerFile, "", electronID, - electronIsolation, "Eff_" + trigger_string, dataType, "TOTAL", "", + (!(electronIsolation == "PLImprovedTight" || electronIsolation == "PLImprovedVeryTight")) ? electronIsolation : "", + "Eff_" + trigger_string, dataType, "TOTAL", "", ""); m_electronEffTriggerLoose = setupElectronSFToolWithMap(elSFPrefix + "TriggerLoose", m_electronEffTriggerLooseFile, - "", electronIDLoose, electronIsolationLoose, + "", electronIDLoose, + (!(electronIsolationLoose == "PLImprovedTight" || electronIsolationLoose == "PLImprovedVeryTight")) ? electronIsolationLoose : "", "Eff_" + trigger_string, dataType, "TOTAL", "", ""); // Isolation SFs if (electronIsolation == "PLVTight" || @@ -359,54 +390,78 @@ namespace top { ATH_MSG_INFO( "Requested Electrons SF tool for " << m_config->electronEfficiencySystematicModel() << " correlation model"); - + if (m_config->electronEfficiencySystematicModel() != "TOTAL") { ATH_MSG_INFO( "Setting up Electrons SF tool for " << m_config->electronEfficiencySystematicModel() << " correlation model"); + const std::string elSFPrefixCorrModel = elSFPrefix + "CorrModel_"; // Reco SFs m_electronEffSFRecoCorrModel = setupElectronSFToolWithMap(elSFPrefixCorrModel + "Reco", m_electronEffSFRecoFile, "Reconstruction", "", "", "", dataType, + m_config->electronEfficiencySystematicModelNToys(), + m_config->electronEfficiencySystematicModelToySeed(), m_config->electronEfficiencySystematicModel(), m_config->electronEfficiencySystematicModelEtaBinning(), m_config->electronEfficiencySystematicModelEtBinning()); // ID SFs - m_electronEffSFIDCorrModel = setupElectronSFToolWithMap(elSFPrefixCorrModel + "ID", m_electronEffSFIDFile, "", + if(m_config->electronIDSFFilePath() =="Default") m_electronEffSFIDCorrModel = setupElectronSFToolWithMap(elSFPrefixCorrModel + "ID", m_electronEffSFIDFile, "", electronID, "", "", dataType, + m_config->electronEfficiencySystematicModelNToys(), + m_config->electronEfficiencySystematicModelToySeed(), m_config->electronEfficiencySystematicModel(), m_config->electronEfficiencySystematicModelEtaBinning(), m_config->electronEfficiencySystematicModelEtBinning()); + else m_electronEffSFIDCorrModel = setupElectronSFTool(elSFPrefixCorrModel + "ID", inExpID, dataType, + m_config->electronEfficiencySystematicModel(), + m_config->electronEfficiencySystematicModelEtaBinning(), + m_config->electronEfficiencySystematicModelEtBinning()); + m_electronEffSFIDLooseCorrModel = setupElectronSFToolWithMap(elSFPrefixCorrModel + "IDLoose", m_electronEffSFIDLooseFile, "", electronIDLoose, "", "", dataType, + m_config->electronEfficiencySystematicModelNToys(), + m_config->electronEfficiencySystematicModelToySeed(), m_config->electronEfficiencySystematicModel(), m_config->electronEfficiencySystematicModelEtaBinning(), m_config->electronEfficiencySystematicModelEtBinning()); // Trigger SFs m_electronEffSFTriggerCorrModel = setupElectronSFToolWithMap(elSFPrefixCorrModel + "TriggerSF", m_electronEffSFTriggerFile, "", electronID, - electronIsolation, trigger_string, dataType, + (!(electronIsolation == "PLImprovedTight" || electronIsolation == "PLImprovedVeryTight")) ? electronIsolation : "", + trigger_string, dataType, + m_config->electronEfficiencySystematicModelNToys(), + m_config->electronEfficiencySystematicModelToySeed(), m_config->electronEfficiencySystematicModel(), m_config->electronEfficiencySystematicModelEtaBinning(), m_config->electronEfficiencySystematicModelEtBinning()); m_electronEffSFTriggerLooseCorrModel = setupElectronSFToolWithMap(elSFPrefixCorrModel + "TriggerSFLoose", m_electronEffSFTriggerLooseFile, "", - electronIDLoose, electronIsolationLoose, + electronIDLoose, + (!(electronIsolationLoose == "PLImprovedTight" || electronIsolationLoose == "PLImprovedVeryTight")) ? electronIsolationLoose : "", trigger_string, dataType, + m_config->electronEfficiencySystematicModelNToys(), + m_config->electronEfficiencySystematicModelToySeed(), m_config->electronEfficiencySystematicModel(), m_config->electronEfficiencySystematicModelEtaBinning(), m_config->electronEfficiencySystematicModelEtBinning()); // Trigger Efficiencies m_electronEffTriggerCorrModel = setupElectronSFToolWithMap(elSFPrefixCorrModel + "Trigger", m_electronEffTriggerFile, "", electronID, - electronIsolation, "Eff_" + trigger_string, dataType, + (!(electronIsolation == "PLImprovedTight" || electronIsolation == "PLImprovedVeryTight")) ? electronIsolation : "", + "Eff_" + trigger_string, dataType, + m_config->electronEfficiencySystematicModelNToys(), + m_config->electronEfficiencySystematicModelToySeed(), m_config->electronEfficiencySystematicModel(), m_config->electronEfficiencySystematicModelEtaBinning(), m_config->electronEfficiencySystematicModelEtBinning()); m_electronEffTriggerLooseCorrModel = setupElectronSFToolWithMap(elSFPrefixCorrModel + "TriggerLoose", m_electronEffTriggerLooseFile, "", - electronIDLoose, electronIsolationLoose, + electronIDLoose, + (!(electronIsolationLoose == "PLImprovedTight" || electronIsolationLoose == "PLImprovedVeryTight")) ? electronIsolationLoose : "", "Eff_" + trigger_string, dataType, + m_config->electronEfficiencySystematicModelNToys(), + m_config->electronEfficiencySystematicModelToySeed(), m_config->electronEfficiencySystematicModel(), m_config->electronEfficiencySystematicModelEtaBinning(), m_config->electronEfficiencySystematicModelEtBinning()); @@ -422,6 +477,8 @@ namespace top { else { m_electronEffSFIsoCorrModel = setupElectronSFToolWithMap(elSFPrefixCorrModel + "Iso", m_electronEffSFIsoFile, "", electronID, electronIsolation, "", dataType, + m_config->electronEfficiencySystematicModelNToys(), + m_config->electronEfficiencySystematicModelToySeed(), m_config->electronEfficiencySystematicModel(), m_config->electronEfficiencySystematicModelEtaBinning(), m_config->electronEfficiencySystematicModelEtBinning()); @@ -439,6 +496,8 @@ namespace top { m_electronEffSFIsoLooseCorrModel = setupElectronSFToolWithMap(elSFPrefixCorrModel + "IsoLoose", m_electronEffSFIsoLooseFile, "", electronIDLoose, electronIsolationLoose, "", dataType, + m_config->electronEfficiencySystematicModelNToys(), + m_config->electronEfficiencySystematicModelToySeed(), m_config->electronEfficiencySystematicModel(), m_config->electronEfficiencySystematicModelEtaBinning(), m_config->electronEfficiencySystematicModelEtBinning()); @@ -465,11 +524,11 @@ namespace top { // Charge ID cannot use maps at the moment so we default to the old method if (m_config->useElectronChargeIDSelection() - && electronIsolation != "PLVTight" - && electronIsolation != "PLVLoose" - && electronIsolationLoose != "PLVTight" - && electronIsolationLoose != "PLVLoose" ) { // We need to update the implementation according to new - // recommendations + && electronIsolation != "PLVTight" && electronIsolation != "PLVLoose" + && electronIsolationLoose != "PLVTight" && electronIsolationLoose != "PLVLoose" + && electronIsolation != "PLImprovedTight" && electronIsolation != "PLImprovedVeryTight" + && electronIsolationLoose != "PLImprovedTight" && electronIsolationLoose != "PLImprovedVeryTight") { // We need to update the implementation according to new recommendations + ATH_MSG_INFO("Setting up Electrons ChargeID SF tool"); // Charge ID file (no maps) m_electronEffSFChargeIDFile = electronSFFilePath("ChargeID", electronID, electronIsolation); @@ -487,20 +546,20 @@ namespace top { m_electronEffSFChargeID = setupElectronSFTool(elSFPrefix + "ChargeID", inChargeID, dataType); m_electronEffSFChargeIDLoose = setupElectronSFTool(elSFPrefix + "ChargeIDLoose", inChargeIDLoose, dataType); } - // Charge flip correction: https://twiki.cern.ch/twiki/bin/view/AtlasProtected/EgammaChargeMisIdentificationTool - CP::ElectronChargeEfficiencyCorrectionTool* ChargeMisIDCorrections = new CP::ElectronChargeEfficiencyCorrectionTool( - "ElectronChargeEfficiencyCorrection"); - CP::ElectronChargeEfficiencyCorrectionTool* ChargeMisIDCorrectionsLoose = - new CP::ElectronChargeEfficiencyCorrectionTool("ElectronChargeEfficiencyCorrectionLoose"); - m_electronEffSFChargeMisIDFile = electronSFFilePath("ChargeMisID", electronID, electronIsolation); - m_electronEffSFChargeMisIDLooseFile = electronSFFilePath("ChargeMisID", electronIDLoose, electronIsolationLoose); - top::check(ChargeMisIDCorrections->setProperty("CorrectionFileName", - m_electronEffSFChargeMisIDFile), "Failed to setProperty"); - top::check(ChargeMisIDCorrections->initialize(), "Failed to setProperty"); - top::check(ChargeMisIDCorrectionsLoose->setProperty("CorrectionFileName", - m_electronEffSFChargeMisIDLooseFile), "Failed to setProperty"); - top::check(ChargeMisIDCorrectionsLoose->initialize(), "Failed to setProperty"); - + if(electronIsolation != "PLVTight" && electronIsolation != "PLVLoose" && + electronIsolation != "PLImprovedTight" && electronIsolation != "PLImprovedVeryTight"){ + CP::ElectronChargeEfficiencyCorrectionTool* ChargeMisIDCorrections = new CP::ElectronChargeEfficiencyCorrectionTool("ElectronChargeEfficiencyCorrection"); + m_electronEffSFChargeMisIDFile = electronSFFilePath("ChargeMisID", electronID, electronIsolation); + top::check(ChargeMisIDCorrections->setProperty("CorrectionFileName", m_electronEffSFChargeMisIDFile), "Failed to setProperty"); + top::check(ChargeMisIDCorrections->initialize(), "Failed to setProperty"); + } + if(electronIsolationLoose != "PLVTight" && electronIsolationLoose != "PLVLoose" && + electronIsolationLoose != "PLImprovedTight" && electronIsolationLoose != "PLImprovedVeryTight"){ + CP::ElectronChargeEfficiencyCorrectionTool* ChargeMisIDCorrectionsLoose = new CP::ElectronChargeEfficiencyCorrectionTool("ElectronChargeEfficiencyCorrectionLoose"); + m_electronEffSFChargeMisIDLooseFile = electronSFFilePath("ChargeMisID", electronIDLoose, electronIsolationLoose); + top::check(ChargeMisIDCorrectionsLoose->setProperty("CorrectionFileName", m_electronEffSFChargeMisIDLooseFile), "Failed to setProperty"); + top::check(ChargeMisIDCorrectionsLoose->initialize(), "Failed to setProperty"); + } return StatusCode::SUCCESS; } @@ -525,6 +584,8 @@ namespace top { "Failed to set CorrelationModel to " + name); if (correlationModelEtaBinning != "" && correlationModelEtaBinning != "default") this->setCorrelationModelBinning(tool, "UncorrEtaBinsUser", correlationModelEtaBinning); if (correlationModelEtBinning != "" && correlationModelEtBinning != "default") this->setCorrelationModelBinning(tool, "UncorrEtBinsUser", correlationModelEtBinning); + + top::check(asg::setProperty(tool, "OutputLevel", MSG::INFO), "Failed to set OutputLevel to " + name); top::check(tool->initialize(), "Failed to initialize " + name); } } @@ -561,13 +622,25 @@ namespace top { bins), "Failed to set correlation model " + binningName + " binning to " + binning); } - IAsgElectronEfficiencyCorrectionTool* + void EgammaCPTools::setCorrelationModelToys(IAsgElectronEfficiencyCorrectionTool* tool, + const std::string& ToysName, const int& number) { + ATH_MSG_INFO(" ---> electron SF tools will use " << ToysName << " :"<< number); + top::check(asg::setProperty(tool, ToysName, + number), "Failed to set correlation model " + ToysName ); + } + + +IAsgElectronEfficiencyCorrectionTool* EgammaCPTools::setupElectronSFToolWithMap(const std::string& name, const std::string& map_path, const std::string& reco_key, const std::string& ID_key, const std::string& ISO_key, const std::string& trigger_key, - const int& data_type, const std::string& correlation_model, + const int& data_type, + const int& correlationModelNToys, + const int& correlationModelToySeed, + const std::string& correlation_model, const std::string& correlationModelEtaBinning, const std::string& correlationModelEtBinning) { + std::string iso_key = ISO_key; // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/LatestRecommendationsElectronIDRun2#PLV_scale_factors_for_central_el // If isolation WP is PLVTight or PLVLoose, switch to no isolation to trick this function. @@ -598,6 +671,14 @@ namespace top { if (correlationModelEtBinning != "" && correlationModelEtBinning != "default") this->setCorrelationModelBinning( tool, "UncorrEtBinsUser", correlationModelEtBinning); + //MC Toy model variables + if (correlationModelNToys != 0 ) this->setCorrelationModelToys( + tool, "NumberOfToys", correlationModelNToys); + + if (correlationModelToySeed != 0) this->setCorrelationModelToys( + tool, "MCToySeed", correlationModelToySeed); + + // Set the keys which configure the tool options (empty string means we do not include this key) if (reco_key != "" && reco_key != "None") { ATH_MSG_INFO(" Adding RecoKey : " + reco_key); @@ -617,6 +698,76 @@ namespace top { top::check(asg::setProperty(tool, "TriggerKey", trigger_key), "Failed to set TriggerKey to " + name); } // Initialise this tool + + top::check(tool->initialize(), "Failed to initialize " + name); + } + return tool; +} + + + IAsgElectronEfficiencyCorrectionTool* + EgammaCPTools::setupElectronSFToolWithMap(const std::string& name, const std::string& map_path, + const std::string& reco_key, const std::string& ID_key, + const std::string& ISO_key, const std::string& trigger_key, + const int& data_type, + const std::string& correlation_model, + const std::string& correlationModelEtaBinning, + const std::string& correlationModelEtBinning) { + + std::string iso_key = ISO_key; + // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/LatestRecommendationsElectronIDRun2#PLV_scale_factors_for_central_el + // If isolation WP is PLVTight or PLVLoose, switch to no isolation to trick this function. + if (iso_key == "PLVTight" || iso_key == "PLVLoose") iso_key = ""; + + if( (iso_key == "PLImprovedTight" || iso_key == "PLImprovedVeryTight") && m_config->useElectronChargeIDSelection() ){ + ATH_MSG_INFO( "ECIDS tool and PLImproved* isolation detected, switching to combined isolation SFs."); + iso_key += "ECIDS"; + } + + std::string infoStr = "Configuring : name=" + name + " map=" + map_path + " reco_key=" + reco_key + " ID_key=" + + ID_key + " iso_key=" + iso_key + " trigger_key=" + trigger_key + "data_type=" + + std::to_string(data_type) + + " correlation_model=" + correlation_model + " etaBinning=" + correlationModelEtaBinning + + " etBinning=" + + correlationModelEtBinning; + ATH_MSG_INFO(infoStr); + IAsgElectronEfficiencyCorrectionTool* tool = nullptr; + if (asg::ToolStore::contains(name)) { + tool = asg::ToolStore::get(name); + } else { + tool = new AsgElectronEfficiencyCorrectionTool(name); + // Give the full map path + top::check(asg::setProperty(tool, "MapFilePath", map_path), "Failed to set MapFilePath to " + name); + // Set the data type for all tools + top::check(asg::setProperty(tool, "ForceDataType", data_type), "Failed to set ForceDataType to " + name); + // Set the correlation model for all tools + top::check(asg::setProperty(tool, "CorrelationModel", + correlation_model), "Failed to set CorrelationModel to " + name); + + if (correlationModelEtaBinning != "" && correlationModelEtaBinning != "default") this->setCorrelationModelBinning( + tool, "UncorrEtaBinsUser", correlationModelEtaBinning); + if (correlationModelEtBinning != "" && correlationModelEtBinning != "default") this->setCorrelationModelBinning( + tool, "UncorrEtBinsUser", correlationModelEtBinning); + + // Set the keys which configure the tool options (empty string means we do not include this key) + if (reco_key != "" && reco_key != "None") { + ATH_MSG_INFO(" Adding RecoKey : " + reco_key); + top::check(asg::setProperty(tool, "RecoKey", reco_key), "Failed to set RecoKey to " + name); + } + if (ID_key != "" && ID_key != "None") { + std::string id_key = mapWorkingPoints(ID_key); + ATH_MSG_INFO(" Adding IDKey : " + id_key); + top::check(asg::setProperty(tool, "IdKey", id_key), "Failed to set IdKey to " + name); + } + if (iso_key != "" && iso_key != "None") { + ATH_MSG_INFO(" Adding IsoKey : " + iso_key); + top::check(asg::setProperty(tool, "IsoKey", iso_key), "Failed to set IsoKey to " + name); + } + if (trigger_key != "" && trigger_key != "None") { + ATH_MSG_INFO(" Adding TriggerKey : " + trigger_key); + top::check(asg::setProperty(tool, "TriggerKey", trigger_key), "Failed to set TriggerKey to " + name); + } + top::check(asg::setProperty(tool, "OutputLevel", MSG::INFO), "Failed to set OutputLevel to " + name); top::check(tool->initialize(), "Failed to initialize " + name); } return tool; @@ -624,7 +775,10 @@ namespace top { std::string EgammaCPTools::electronSFFilePath(const std::string& type, const std::string& ID, const std::string& ISO) { - const std::string el_calib_path = "ElectronEfficiencyCorrection/2015_2017/rel21.2/Consolidation_September2018_v1/"; + bool isPliv = (ISO == "PLImprovedTight" || ISO == "PLImprovedVeryTight"); + const std::string el_calib_path = (type == "ChargeID" && isPliv) ? + "ElectronEfficiencyCorrection/2015_2018/rel21.2/Precision_Summer2020_v1/" + : "ElectronEfficiencyCorrection/2015_2017/rel21.2/Consolidation_September2018_v1/"; std::string file_path; @@ -640,12 +794,13 @@ namespace top { if (ID != "MediumLLH" && ID != "TightLLH") ATH_MSG_ERROR( "The requested ID WP (" + ID + ") is not supported for electron ChargeID SFs! Try TightLH or MediumLH instead."); - if (ISO != "FCTight" && ISO != "Gradient") ATH_MSG_ERROR("The requested ISO WP (" + ISO + ") is not supported for electron ChargeID SFs! Try FCTight or Gradient instead."); - file_path += "additional/efficiencySF.ChargeID."; + if (ISO != "FCTight" && ISO != "Gradient" && ISO != "PLImprovedTight" && ISO != "PLImprovedVeryTight") ATH_MSG_ERROR("The requested ISO WP (" + ISO + ") is not supported for electron ChargeID SFs! Try FCTight, Gradient, or PLImproved(Very)Tight instead."); + file_path += (isPliv) ? "isolation/efficiencySF.Isolation." : "additional/efficiencySF.ChargeID."; file_path += ID; file_path += "_d0z0_v13_"; + if(isPliv) file_path += "isol"; file_path += ISO; - file_path += "_ECIDSloose.root"; + file_path += (isPliv) ? "ECIDS.root" : "_ECIDSloose.root"; file_path = el_calib_path + file_path; } else if (type == "PLV") { if (ID != "MediumLLH" && ID != "TightLLH") @@ -673,7 +828,11 @@ namespace top { file_path += "chargeEfficiencySF."; file_path += ID; file_path += "_d0z0_v13"; - if (iso != "" && iso != "PLVTight" && iso != "PLVLoose") file_path += "_" + iso; + if (iso != "" && iso != "PLVTight" && iso != "PLVLoose" && iso != "PLImprovedTight" && iso != "PLImprovedVeryTight") file_path += "_" + iso; + if (iso == "PLVTight" || iso == "PLVLoose" || iso == "PLImprovedTight" || iso == "PLImprovedVeryTight") { + // not supported for now! -> set up a dummy tool and return 1 as SF + ATH_MSG_WARNING("The requested ISO WP (" + iso + ") is not supported for electron ChargeMisID SFs! Will set up a dummy tool and set the SFs to one."); + } if (m_config->useElectronChargeIDSelection()) { if (ID != "MediumLLH" && ID != "TightLLH") ATH_MSG_WARNING("The requested ID WP (" + ID + ") is not supported for electron ECIDS+ChargeMisID SFs! Try TightLH or MediumLH instead. Will now switch to regular ChargeMisID SFs."); else if (iso != "FCTight" && iso != "Gradient") ATH_MSG_WARNING("The requested ISO WP (" + iso + ") is not supported for electron ECIDS+ChargeMisID SFs! Try FCTight or Gradient instead. Will now switch to regular ChargeMisID SFs."); @@ -681,6 +840,8 @@ namespace top { } file_path += ".root"; file_path = el_calib_path + file_path; + } else if (type == "EXPID"){ + file_path = m_config->electronIDSFFilePath(); } else { ATH_MSG_ERROR("Unknown electron SF type"); } @@ -734,7 +895,7 @@ namespace top { ATH_MSG_WARNING("You selected the TightTrackOnly_FixedRad isolation WP for at least one of your electron collections - BE WARNED THAT THESE ARE NOT YET READY TO BE RELEASED FOR USE IN PHYSICS ANALYSES AND OF COURSE DON'T HAVE ASSOCIATED SCALE FACTORS YET!!! Setting to \"Gradient\" SFs to allow the code to run"); working_point = "Gradient"; } - if (type == "FCTight" || type == "FCLoose" || type == "FCHighPtCaloOnly" || type == "Gradient" || type == "PLVTight" || type == "PLVLoose") working_point = type; + if (type == "FCTight" || type == "FCLoose" || type == "FCHighPtCaloOnly" || type == "Gradient" || type == "PLVTight" || type == "PLVLoose" || type == "PLImprovedTight" || type == "PLImprovedVeryTight") working_point = type; return working_point; } diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/Root/TopMuonCPTools.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/Root/TopMuonCPTools.cxx index 9c44cabc99ae8af0200085195884c7ecf54d6c80..9f11816d07fb137c0d5bd963b9d5296b5f2344d8 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/Root/TopMuonCPTools.cxx +++ b/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/Root/TopMuonCPTools.cxx @@ -35,6 +35,7 @@ namespace top { declareProperty("MuonEfficiencyCorrectionsToolLoose", m_muonEfficiencyCorrectionsToolLoose); declareProperty("MuonEfficiencyCorrectionsToolIso", m_muonEfficiencyCorrectionsToolIso); declareProperty("MuonEfficiencyCorrectionsToolLooseIso", m_muonEfficiencyCorrectionsToolLooseIso); + declareProperty("MuonEfficiencyCorrectionsToolBadMuonVeto", m_muonEfficiencyCorrectionsToolBadMuonVeto); declareProperty("SoftMuonSelectionTool", m_softmuonSelectionTool); declareProperty("SoftMuonEfficiencyCorrectionsTool", m_softmuonEfficiencyCorrectionsTool); @@ -154,14 +155,20 @@ namespace top { if (m_config->muonQuality() == "LowPt" && m_config->muonUseMVALowPt()) muonQuality_name = "LowPtMVA"; m_muonEfficiencyCorrectionsTool = setupMuonSFTool("MuonEfficiencyScaleFactorsTool", - muonQuality_name); + muonQuality_name, false); std::string muonQualityLoose_name = m_config->muonQualityLoose(); if (m_config->muonQualityLoose() == "HighPt" && !(m_config->muonUse2stationMuonsHighPtLoose()) ) muonQualityLoose_name = "HighPt3Layers"; if (m_config->muonQualityLoose() == "LowPt" && m_config->muonUseMVALowPtLoose()) muonQualityLoose_name = "LowPtMVA"; m_muonEfficiencyCorrectionsToolLoose = setupMuonSFTool("MuonEfficiencyScaleFactorsToolLoose", - muonQualityLoose_name); + muonQualityLoose_name, false); + + if (m_config->muonQuality() == "HighPt" || m_config->muonQualityLoose() == "HighPt") { + m_muonEfficiencyCorrectionsToolLoose + = setupMuonSFTool("MuonEfficiencyScaleFactorsToolBadMuonVeto", + "BadMuonVeto_HighPt", false); + } //now the soft muon part std::string softmuonQuality_name = m_config->softmuonQuality(); @@ -169,7 +176,7 @@ namespace top { if (m_config->useSoftMuons()) { m_softmuonEfficiencyCorrectionsTool = setupMuonSFTool("SoftMuonEfficiencyScaleFactorsTool", - softmuonQuality_name); + softmuonQuality_name, false); } /************************************************************ @@ -185,7 +192,7 @@ namespace top { std::string muon_isolation = m_config->muonIsolationSF() + "Iso"; m_muonEfficiencyCorrectionsToolIso = setupMuonSFTool("MuonEfficiencyScaleFactorsToolIso", - muon_isolation); + muon_isolation, true); } // Do we have isolation on our loose muons? If not no need for the tool... @@ -194,7 +201,7 @@ namespace top { std::string muon_isolation = m_config->muonIsolationSFLoose() + "Iso"; m_muonEfficiencyCorrectionsToolLooseIso = setupMuonSFTool("MuonEfficiencyScaleFactorsToolLooseIso", - muon_isolation); + muon_isolation, true); } /************************************************************ @@ -205,7 +212,7 @@ namespace top { ************************************************************/ m_muonEfficiencyCorrectionsToolTTVA = setupMuonSFTool("MuonEfficiencyScaleFactorsToolTTVA", - "TTVA"); + "TTVA", false); // WARNING - The PromptLeptonIsolation scale factors are only derived with respect to the loose PID // - Hence we need to fail if this has occured @@ -275,7 +282,7 @@ namespace top { } CP::IMuonEfficiencyScaleFactors* - MuonCPTools::setupMuonSFTool(const std::string& name, const std::string& WP) { + MuonCPTools::setupMuonSFTool(const std::string& name, const std::string& WP, const bool isIso) { CP::IMuonEfficiencyScaleFactors* tool = nullptr; if (asg::ToolStore::contains(name)) { tool = asg::ToolStore::get(name); @@ -285,6 +292,15 @@ namespace top { "Failed to set WP for " + name + " tool"); top::check(asg::setProperty(tool, "CloseJetDRDecorator", "dRMuJet_AT_usingWeirdNameToAvoidUsingOnTheFlyCalculation"), "Failed to set WP for " + name + " tool"); //in this way we'll only read the dR(mu,jet) from the derivation, IF the variable is there, but we'll not use on-the-fly calculation, which is tricky in AT + if (m_config->muonSFCustomInputFolder() != " ") { + top::check(asg::setProperty(tool, "CustomInputFolder", m_config->muonSFCustomInputFolder()), + "Failed to set CustomInputFolder property for MuonEfficiencyScaleFactors tool"); + } + + if (!isIso) { + top::check(asg::setProperty(tool, "BreakDownSystematics", m_config->muonBreakDownSystematics()), + "Failed to set BreakDownSystematics for " + name + " tool"); + } top::check(tool->initialize(), "Failed to set initialize " + name); } diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/TopCPTools/TopEgammaCPTools.h b/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/TopCPTools/TopEgammaCPTools.h index 9f0146e73b54debac5753f84dd0624b47a36b7ac..15108f5a94e8c0018249dfc48d58b2ad501e3bc1 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/TopCPTools/TopEgammaCPTools.h +++ b/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/TopCPTools/TopEgammaCPTools.h @@ -103,6 +103,9 @@ namespace top { const std::string& correlationModelEtaBinning="", const std::string& correlationModelEtBinning=""); + + + // Helper function to deal with path resolving the // egamma groups very long file names for SFs and efficiencies. std::string electronSFFilePath(const std::string& type, const std::string& ID, const std::string& ISO); @@ -119,10 +122,35 @@ namespace top { const std::string& correlationModelEtaBinning, const std::string& correlationModelEtBinning); + + + + IAsgElectronEfficiencyCorrectionTool* setupElectronSFToolWithMap(const std::string& name, + const std::string& map_path, + const std::string& reco_key, + const std::string& ID_key, + const std::string& iso_key, + const std::string& trigger_key, + const int& data_type, + const int& correlationModelNtoys, + const int& correlationToySeed, + const std::string& correlationModel, + const std::string& correlationModelEtaBinning, + const std::string& correlationModelEtBinning); + + + std::string electronSFMapFilePath(const std::string& type); void setCorrelationModelBinning(IAsgElectronEfficiencyCorrectionTool* tool, const std::string& binningName, const std::string& binning); + + + void setCorrelationModelToys(IAsgElectronEfficiencyCorrectionTool* tool, const std::string& ToysName, + const int& number); + + + std::string mapWorkingPoints(const std::string& type); }; } // namespace top diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/TopCPTools/TopMuonCPTools.h b/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/TopCPTools/TopMuonCPTools.h index 95381e9c6d6813111d5e015608eeb730b2d89c1d..a85c0d9bc54a8aa01bce57d6ee2016bb8e892dc3 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/TopCPTools/TopMuonCPTools.h +++ b/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/TopCPTools/TopMuonCPTools.h @@ -54,6 +54,7 @@ namespace top { ToolHandle m_muonEfficiencyCorrectionsToolLooseIso; ToolHandle m_muonEfficiencyCorrectionsToolPromptLeptonIso; ToolHandle m_muonEfficiencyCorrectionsToolTTVA; + ToolHandle m_muonEfficiencyCorrectionsToolBadMuonVeto; ToolHandle m_softmuonSelectionTool; ToolHandle m_softmuonEfficiencyCorrectionsTool; @@ -70,7 +71,7 @@ namespace top { setupMuonTrigSFTool(const std::string& name, const std::string& quality); CP::IMuonEfficiencyScaleFactors* - setupMuonSFTool(const std::string& name, const std::string& WP); + setupMuonSFTool(const std::string& name, const std::string& WP, const bool isIso); CP::IMuonCalibrationAndSmearingTool* setupMuonCalibrationAndSmearingTool(const std::string& name, const bool& doExtraSmearingHighPt, const bool& do2StationsHighPt); diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/ConfigurationSettings.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/ConfigurationSettings.cxx index b7799696a6e713214aabba7f274b2eab5c575889..209895ffd3aa75842e096c1aac01a5bc6ccac5f5 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/ConfigurationSettings.cxx +++ b/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/ConfigurationSettings.cxx @@ -62,10 +62,17 @@ namespace top { registerParameter("ElectronPt", "Electron pT cut for object selection (in MeV). Default 25 GeV.", "25000."); registerParameter("Electrond0Sig", "Electron d0 significance cut for object selection. Default 5", "5."); registerParameter("Electrondeltaz0", "Electron delta z0 cut for object selection. Default 0.5 mm", "0.5"); + registerParameter("ElectronIDSFFilePath", "EXPERIMENTAL! Path to a root file containing custom electron ID SFs, e.g. " + "dev/ElectronEfficiencyCorrection/2015_2018/rel21.2/Precision_Summer2020_v1/offline/efficiencySF.offline.TightLLH_d0z0_v13.root." + "This should only be used by experts for testing SFs! Default: Using the most recent recommended map.", "Default"); registerParameter("EgammaSystematicModel", "Egamma Calibration Systematic model : FULL_v1 , 1NP_v1 (default)", "1NP_v1"); + registerParameter("ElectronEfficiencySystematicModelNToys", + "Electron Efficiency Toy Systematics Number of Toys: ","40"); + registerParameter("ElectronEfficiencySystematicModelToySeed", + "Electron Efficiency Toy Systematics Seed of Toys: ","12345"); registerParameter("ElectronEfficiencySystematicModel", - "Electron Efficiency Systematic model : FULL, SIMPLIFIED, TOTAL (default)", "TOTAL"); + "Electron Efficiency Systematic model : FULL, SIMPLIFIED, TOTAL (default), COMBMCTOYS", "TOTAL"); registerParameter("ElectronEfficiencySystematicModelEtaBinning", "Electron Efficiency Systematic model eta binning (option for SIMPLIFIED model, do not specify to use default; format XXX:YYY:ZZZ, e.g. 0.0:1.37:4.9)", "default"); @@ -166,6 +173,14 @@ namespace top { "Debug output for soft muon additional truth-level information: True or False (default)", "False"); + registerParameter("MuonSFCustomInputFolder", + "EXPERT OPTION! Tells the MuonEfficiencyScaleFactors tools to use a custom input folder path. If set to \" \" will use the default", + " "); + + registerParameter("MuonBreakDownSystematics", + "Tells the MuonEfficiencyScaleFactors tools to use a more complex systematic model, if set to True. Default is False", + "False", {"True", "False"}); + registerParameter("JetPt", "Jet pT cut for object selection (in MeV). Default 25 GeV.", "25000."); registerParameter("JetEta", "Absolute Jet eta cut for object selection. Default 2.5.", "2.5"); diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/TopConfig.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/TopConfig.cxx index c809042558da6a414041c59eaee05fc77a5380e5..84422f518651281ff68aed4ef2f59128ad339306 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/TopConfig.cxx +++ b/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/TopConfig.cxx @@ -187,6 +187,11 @@ namespace top { // Electron configuration m_egammaSystematicModel("1NP_v1"), m_electronEfficiencySystematicModel("TOTAL"), + m_electronEfficiencySystematicModelNToys(40), + m_electronEfficiencySystematicModelToySeed(12345), + m_electronEfficiencySystematicModelRecoSize(400), + m_electronEfficiencySystematicModelIdSize(400), + m_electronEfficiencySystematicModelIsoSize(400), m_electronEfficiencySystematicModelEtaBinning(""), m_electronEfficiencySystematicModelEtBinning(""), m_electronID("SetMe"), @@ -231,6 +236,8 @@ namespace top { m_muonIsolationSFLoose("SetMe"), m_muonMuonDoSmearing2stationHighPt(true), m_muonMuonDoExtraSmearingHighPt(false), + m_muonBreakDownSystematics(false), + m_muonSFCustomInputFolder(" "), // Soft Muon configuration m_softmuonPtcut(4000.), @@ -1073,6 +1080,8 @@ namespace top { this->electronEfficiencySystematicModel(settings->value("ElectronEfficiencySystematicModel")); this->electronEfficiencySystematicModelEtaBinning(settings->value("ElectronEfficiencySystematicModelEtaBinning")); this->electronEfficiencySystematicModelEtBinning(settings->value("ElectronEfficiencySystematicModelEtBinning")); + this->electronEfficiencySystematicModelNToys(std::stof(settings->value("ElectronEfficiencySystematicModelNToys"))); + this->electronEfficiencySystematicModelToySeed(std::stof(settings->value("ElectronEfficiencySystematicModelToySeed"))); this->electronID(settings->value("ElectronID")); this->electronIDLoose(settings->value("ElectronIDLoose")); { @@ -1161,6 +1170,8 @@ namespace top { this->fwdElectronBCIDCleaningMinRun(fwdElectronBCIDCleaningMinRun); this->fwdElectronBCIDCleaningMaxRun(fwdElectronBCIDCleaningMaxRun); + m_electronIDSFFile_path = settings->value("ElectronIDSFFilePath"); + // Photon configuration this->photonPtcut(std::stof(settings->value("PhotonPt"))); this->photonEtacut(std::stof(settings->value("PhotonEta"))); @@ -1246,6 +1257,14 @@ namespace top { } this->muonMuonDoExtraSmearingHighPt( muonDoExtraSmearingHighPt ); + bool muonBreakDownSystematics(false); + settings->retrieve("MuonBreakDownSystematics", muonBreakDownSystematics); + this->muonBreakDownSystematics(muonBreakDownSystematics); + { + std::string const& customMuonSF = settings->value("MuonSFCustomInputFolder"); + this->muonSFCustomInputFolder(customMuonSF); + } + if (settings->value("UseAntiMuons") == "True") this->m_useAntiMuons = true; // Soft Muon configuration diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/TopConfiguration/ConfigurationSettings.h b/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/TopConfiguration/ConfigurationSettings.h index b84c0b0795445d8083d3a21e1cc01c7d9c88dcb1..db1f51ac3ae4c58acc85d828e95423ce399dc23f 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/TopConfiguration/ConfigurationSettings.h +++ b/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/TopConfiguration/ConfigurationSettings.h @@ -125,6 +125,7 @@ namespace top { std::ostream& operator << (std::ostream& os, const ConfigurationSettings& settings); std::ostream& operator << (std::ostream& os, const SelectionConfigurationData& data); + } diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/TopConfiguration/TopConfig.h b/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/TopConfiguration/TopConfig.h index a5da88b34c4eea6f6dc106207d123279a2eafd6d..e98ecdb8d0576e9253c4d6cf14e155b0b60e5eee 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/TopConfiguration/TopConfig.h +++ b/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/TopConfiguration/TopConfig.h @@ -709,6 +709,37 @@ namespace top { } } + inline virtual void electronEfficiencySystematicModelNToys(const int& s) { + if (!m_configFixed) { + m_electronEfficiencySystematicModelNToys = s; + } + } + + + inline virtual void electronEfficiencySystematicModelToySeed(const int& s) { + if (!m_configFixed) { + m_electronEfficiencySystematicModelToySeed = s; + } + } + + + inline virtual void electronEfficiencySystematicModelRecoSize(const int& s) { + m_electronEfficiencySystematicModelRecoSize = s; + } + + + inline virtual void electronEfficiencySystematicModelIdSize(const int& s) { + m_electronEfficiencySystematicModelIdSize = s; + } + + + + inline virtual void electronEfficiencySystematicModelIsoSize(const int& s) { + m_electronEfficiencySystematicModelIsoSize = s; + } + + + inline virtual void electronID(const std::string& s) { if (!m_configFixed) { m_electronID = s; @@ -801,6 +832,28 @@ namespace top { inline virtual const std::string& electronEfficiencySystematicModelEtBinning() { return m_electronEfficiencySystematicModelEtBinning; } + inline virtual const int& electronEfficiencySystematicModelNToys() { + return m_electronEfficiencySystematicModelNToys; + } + + inline virtual const int& electronEfficiencySystematicModelToySeed() { + return m_electronEfficiencySystematicModelToySeed; + } + + + inline virtual const int& electronEfficiencySystematicModelRecoSize() { + return m_electronEfficiencySystematicModelRecoSize; + } + + inline virtual const int& electronEfficiencySystematicModelIdSize() { + return m_electronEfficiencySystematicModelIdSize; + } + + + inline virtual const int& electronEfficiencySystematicModelIsoSize() { + return m_electronEfficiencySystematicModelIsoSize; + } + inline virtual const std::string& electronID() const {return m_electronID;} inline virtual const std::string& electronIDLoose() const {return m_electronIDLoose;} inline virtual bool electronVetoLArCrack() const {return m_electronVetoLArCrack;} @@ -869,6 +922,13 @@ namespace top { inline virtual int fwdElectronBCIDCleaningMinRun() const {return m_fwdElectronBCIDCleaningMinRun;} inline virtual int fwdElectronBCIDCleaningMaxRun() const {return m_fwdElectronBCIDCleaningMaxRun;} + const std::string electronIDSFFilePath() const + {return m_electronIDSFFile_path;} + bool printEIDFileWarning() const + {return m_eid_path_warning;} + void setPrintEIDFileWarning(bool flag) + {m_eid_path_warning = flag;} + // Photon configuration inline virtual void photonPtcut(const float pt) { if (!m_configFixed) { @@ -1035,6 +1095,16 @@ namespace top { inline virtual bool muonMuonDoSmearing2stationHighPt() const {return m_muonMuonDoSmearing2stationHighPt;} inline virtual bool muonMuonDoExtraSmearingHighPt() const {return m_muonMuonDoExtraSmearingHighPt;} + inline virtual void muonBreakDownSystematics(const bool flag) {m_muonBreakDownSystematics = flag;} + inline virtual bool muonBreakDownSystematics() {return m_muonBreakDownSystematics;} + + std::string const& muonSFCustomInputFolder() const {return m_muonSFCustomInputFolder;} + void muonSFCustomInputFolder(const std::string& s) { + if (!m_configFixed) { + m_muonSFCustomInputFolder = s; + } + } + // Soft Muon configuration inline virtual void softmuonPtcut(const float pt) { if (!m_configFixed) { @@ -2264,6 +2334,11 @@ namespace top { // Electron configuration std::string m_egammaSystematicModel; std::string m_electronEfficiencySystematicModel; + int m_electronEfficiencySystematicModelNToys; + int m_electronEfficiencySystematicModelToySeed; + int m_electronEfficiencySystematicModelRecoSize; + int m_electronEfficiencySystematicModelIdSize; + int m_electronEfficiencySystematicModelIsoSize; std::string m_electronEfficiencySystematicModelEtaBinning; std::string m_electronEfficiencySystematicModelEtBinning; std::string m_electronID; @@ -2285,6 +2360,10 @@ namespace top { bool m_useEgammaLeakageCorrection; bool m_enablePromptLeptonImprovedVetoStudies; + // experimental electronID map path + std::string m_electronIDSFFile_path = "Default"; + bool m_eid_path_warning = false; + //Fwd electron configuration float m_fwdElectronPtcut; float m_fwdElectronMinEtacut; @@ -2315,6 +2394,8 @@ namespace top { float m_muon_delta_z0; bool m_muonMuonDoSmearing2stationHighPt; //to turn on/off special correction for the reco with 2-station muons with missing inner MS station allowed for abs(eta)<1.3, only HighPt WP bool m_muonMuonDoExtraSmearingHighPt; //to turn on/off a special correction for the muon with high momenta. + bool m_muonBreakDownSystematics; //to turn on/off a more complex systematic model + std::string m_muonSFCustomInputFolder; //Soft muon configuration float m_softmuonPtcut; // soft muon object selection pT cut diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/Root/ElectronScaleFactorCalculator.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/Root/ElectronScaleFactorCalculator.cxx index 6f4861284c0351f8f190b340e2fd8efd2d92b478..43b130e15330a38a329b20ac2b5bf46ba4daca70 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/Root/ElectronScaleFactorCalculator.cxx +++ b/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/Root/ElectronScaleFactorCalculator.cxx @@ -7,6 +7,7 @@ #include "TopConfiguration/TopConfig.h" #include "TopEvent/EventTools.h" +#include "PATInterfaces/MakeSystematicsVector.h" #include "xAODEgamma/ElectronContainer.h" #include "TString.h" @@ -192,7 +193,7 @@ namespace top { m_systChargeMisID_SYST_UP.insert(CP::SystematicVariation("EL_CHARGEID_SYStotal", 1)); m_systChargeMisID_SYST_DOWN.insert(CP::SystematicVariation("EL_CHARGEID_SYStotal", -1)); - if (m_config->electronEfficiencySystematicModel() != "TOTAL") { + if (m_config->electronEfficiencySystematicModel() != "TOTAL" && m_config->electronEfficiencySystematicModel() != "COMBMCTOYS") { CP::SystematicSet triggerSet = m_electronEffSFTrigger->recommendedSystematics(); //currently we have only the // TOTAL model implemented for // trigger SF, it's useless to @@ -219,6 +220,10 @@ namespace top { "--->electron RECO " << m_config->electronEfficiencySystematicModel() << " component " << (count2++) << " is " << name); } + + m_config->electronEfficiencySystematicModelRecoSize(count2); + + count = 0; count2 = 0; for (const CP::SystematicSet& isyst : m_systIDCorrModel) { @@ -230,6 +235,11 @@ namespace top { "--->electron ID " << m_config->electronEfficiencySystematicModel() << " component " << (count2++) << " is " << name); } + + m_config->electronEfficiencySystematicModelIdSize(count2); + + + count = 0; count2 = 0; for (const CP::SystematicSet& isyst : m_systIsoCorrModel) { @@ -241,6 +251,82 @@ namespace top { "--->electron ISO " << m_config->electronEfficiencySystematicModel() << " component " << (count2++) << " is " << name); } + + m_config->electronEfficiencySystematicModelIsoSize(count2); + + + } + + + if (m_config->electronEfficiencySystematicModel() == "COMBMCTOYS") { + CP::SystematicSet triggerSet = m_electronEffSFTrigger->recommendedSystematics(); //currently we have only the + // TOTAL model implemented for + // trigger SF, it's useless to + // use an advanced model here + CP::SystematicSet recoSet = m_electronEffSFRecoCorrModel->recommendedSystematics(); + CP::SystematicSet idSet = m_electronEffSFIDCorrModel->recommendedSystematics(); + CP::SystematicSet isoSet = m_electronEffSFIsoCorrModel->recommendedSystematics(); + + + CP::MakeSystematicsVector recosysVecToys; + CP::MakeSystematicsVector idsysVecToys; + CP::MakeSystematicsVector isosysVecToys; + + recosysVecToys.addGroup("toys"); + idsysVecToys.addGroup("toys"); + isosysVecToys.addGroup("toys"); + + recosysVecToys.setToys( m_config->electronEfficiencySystematicModelNToys() ); + idsysVecToys.setToys( m_config->electronEfficiencySystematicModelNToys() ); + isosysVecToys.setToys( m_config->electronEfficiencySystematicModelNToys() ); + + recosysVecToys.calc(recoSet); + idsysVecToys.calc(idSet); + isosysVecToys.calc(isoSet); + + m_systRecoCorrModel=recosysVecToys.result("toys"); + m_systIDCorrModel =idsysVecToys.result("toys"); + m_systIsoCorrModel =isosysVecToys.result("toys"); + + m_systTriggerCorrModel = CP::make_systematics_vector(triggerSet); + + ATH_MSG_INFO( + "For electron RECO, ID, ISOLATION using the correlation model " << + m_config->electronEfficiencySystematicModel()); + int count = 0; + for (const CP::SystematicSet& isyst : m_systRecoCorrModel) { + TString name = isyst.name(); + ATH_MSG_INFO( + "--->electron RECO " << m_config->electronEfficiencySystematicModel() << " component " << count << " is " << + name); + count++; + } + m_config->electronEfficiencySystematicModelRecoSize(count); + + + count = 0; + for (const CP::SystematicSet& isyst : m_systIDCorrModel) { + TString name = isyst.name(); + ATH_MSG_INFO( + "--->electron ID " << m_config->electronEfficiencySystematicModel() << " component " << count << " is " << + name); + count++; + } + m_config->electronEfficiencySystematicModelIdSize(count); + + + count = 0; + for (const CP::SystematicSet& isyst : m_systIsoCorrModel) { + TString name = isyst.name(); + ATH_MSG_INFO( + "--->electron ISO " << m_config->electronEfficiencySystematicModel() << " component " << count << " is " << + name); + count++; + } + m_config->electronEfficiencySystematicModelIsoSize(count); + + + } m_decor_triggerEff = "EL_EFF_Trigger_" + m_config->electronID(); @@ -640,7 +726,7 @@ namespace top { /////now taking care of additional systematic model if needed - if (m_config->electronEfficiencySystematicModel() != "TOTAL") { + if ((m_config->electronEfficiencySystematicModel() != "TOTAL") && (m_config->electronEfficiencySystematicModel() != "COMBMCTOYS")){ std::vector vec_Eff_Trigger_UP, vec_Eff_Trigger_DOWN, vec_Eff_TriggerLoose_UP, vec_Eff_TriggerLoose_DOWN; std::vector vec_SF_Trigger_UP, vec_SF_Trigger_DOWN, vec_SF_TriggerLoose_UP, @@ -894,6 +980,233 @@ namespace top { }//end of saving additional systematic model + + if (m_config->electronEfficiencySystematicModel() == "COMBMCTOYS"){ + std::vector vec_Eff_Trigger_UP, vec_Eff_Trigger_DOWN, vec_Eff_TriggerLoose_UP, + vec_Eff_TriggerLoose_DOWN; + std::vector vec_SF_Trigger_UP, vec_SF_Trigger_DOWN, vec_SF_TriggerLoose_UP, + vec_SF_TriggerLoose_DOWN; + std::vector vec_SF_Reco_UP, vec_SF_Reco_DOWN; + std::vector vec_SF_ID_UP, vec_SF_ID_DOWN, vec_SF_IDLoose_UP, vec_SF_IDLoose_DOWN; + std::vector vec_SF_Isol_UP, vec_SF_Isol_DOWN, vec_SF_IsolLoose_UP, vec_SF_IsolLoose_DOWN; + std::vector vec_SF_ChargeID_UP, vec_SF_ChargeID_DOWN, vec_SF_ChargeIDLoose_UP, + vec_SF_ChargeIDLoose_DOWN; + std::vector vec_SF_ChargeMisID_UP, vec_SF_ChargeMisID_DOWN, vec_SF_ChargeMisIDLoose_UP, + vec_SF_ChargeMisIDLoose_DOWN; + + double EFF_Trigger(1.), EFF_TriggerLoose(1.); + double SF_Trigger(1.), SF_TriggerLoose(1.); + double SF_Reco(1.); + double SF_ID(1.), SF_IDLoose(1.); + double SF_Isol(1.), SF_IsolLoose(1.); + + /// --Trigger-- /// + int count = 0; + for (const CP::SystematicSet& isyst : m_systTriggerCorrModel) { + + top::check(m_electronEffSFTriggerCorrModel->applySystematicVariation(isyst), + "Failed to set systematic"); + top::check(m_electronEffSFTriggerLooseCorrModel->applySystematicVariation( + isyst), "Failed to set systematic"); + top::check(m_electronEffSFTriggerCorrModel->getEfficiencyScaleFactor(*electronPtr, + SF_Trigger), "Failed to get SF"); + top::check(m_electronEffSFTriggerLooseCorrModel->getEfficiencyScaleFactor(*electronPtr, + SF_TriggerLoose), + "Failed to get SF"); + top::check(m_electronEffTriggerCorrModel->applySystematicVariation(isyst), "Failed to set systematic"); + top::check(m_electronEffTriggerLooseCorrModel->applySystematicVariation( + isyst), "Failed to set systematic"); + top::check(m_electronEffTriggerCorrModel->getEfficiencyScaleFactor(*electronPtr, + EFF_Trigger), "Failed to get SF"); + top::check(m_electronEffTriggerLooseCorrModel->getEfficiencyScaleFactor(*electronPtr, + EFF_TriggerLoose), + "Failed to get SF"); + + vec_SF_Trigger_DOWN.emplace_back(SF_Trigger); + vec_SF_TriggerLoose_DOWN.emplace_back(SF_TriggerLoose); + vec_Eff_Trigger_DOWN.emplace_back(EFF_Trigger); + vec_Eff_TriggerLoose_DOWN.emplace_back(EFF_TriggerLoose); + vec_SF_Trigger_UP.emplace_back(SF_Trigger); + vec_SF_TriggerLoose_UP.emplace_back(SF_TriggerLoose); + vec_Eff_Trigger_UP.emplace_back(EFF_Trigger); + vec_Eff_TriggerLoose_UP.emplace_back(EFF_TriggerLoose); + + count++; + } + + // Do some sanity check + if (vec_SF_Trigger_DOWN.size() != vec_SF_Trigger_UP.size()) { + throw std::runtime_error { + "ElectronScaleFactorCalculator::execute: Sizes of trigger SF for up and down are different" + }; + } + if (vec_SF_TriggerLoose_DOWN.size() != vec_SF_TriggerLoose_UP.size()) { + throw std::runtime_error { + "ElectronScaleFactorCalculator::execute: Sizes of triggerLoose SF for up and down are different" + }; + } + if (vec_Eff_Trigger_DOWN.size() != vec_Eff_Trigger_UP.size()) { + throw std::runtime_error { + "ElectronScaleFactorCalculator::execute: Sizes of trigger Eff for up and down are different" + }; + } + if (vec_Eff_TriggerLoose_DOWN.size() != vec_Eff_TriggerLoose_UP.size()) { + throw std::runtime_error { + "ElectronScaleFactorCalculator::execute: Sizes of triggerLoose Eff for up and down are different" + }; + } + + ///-- Trigger reset to nominal --/// + top::check(m_electronEffSFTriggerCorrModel->applySystematicVariation( + m_systNominal), "Failed to set systematic"); + top::check(m_electronEffSFTriggerLooseCorrModel->applySystematicVariation( + m_systNominal), "Failed to set systematic"); + top::check(m_electronEffTriggerCorrModel->applySystematicVariation( + m_systNominal), "Failed to set systematic"); + top::check(m_electronEffTriggerLooseCorrModel->applySystematicVariation( + m_systNominal), "Failed to set systematic"); + + /// --Reco-- /// + count = 0; + for (const CP::SystematicSet& isyst : m_systRecoCorrModel) { + + top::check(m_electronEffSFRecoCorrModel->applySystematicVariation(isyst), "Failed to set systematic"); + top::check(m_electronEffSFRecoCorrModel->getEfficiencyScaleFactor(*electronPtr, + SF_Reco), "Failed to get SF"); + + vec_SF_Reco_DOWN.emplace_back(SF_Reco); + vec_SF_Reco_UP.emplace_back(SF_Reco); + ++count; + } + if (vec_SF_Reco_DOWN.size() != vec_SF_Reco_UP.size()) { + throw std::runtime_error { + "ElectronScaleFactorCalculator::execute: Sizes of Reco SF for up and down are different" + }; + } + + ///-- Reco reset to nominal --/// + top::check(m_electronEffSFRecoCorrModel->applySystematicVariation( + m_systNominal), "Failed to set systematic"); + + /// --ID-- /// + count = 0; + for (const CP::SystematicSet& isyst : m_systIDCorrModel) { + + top::check(m_electronEffSFIDCorrModel->applySystematicVariation(isyst), "Failed to set systematic"); + top::check(m_electronEffSFIDLooseCorrModel->applySystematicVariation(isyst), + "Failed to set systematic"); + top::check(m_electronEffSFIDCorrModel->getEfficiencyScaleFactor(*electronPtr, SF_ID), + "Failed to get SF"); + top::check(m_electronEffSFIDLooseCorrModel->getEfficiencyScaleFactor(*electronPtr, + SF_IDLoose), "Failed to get SF"); + + vec_SF_ID_DOWN.emplace_back(SF_ID); + vec_SF_IDLoose_DOWN.emplace_back(SF_IDLoose); + vec_SF_ID_UP.emplace_back(SF_ID); + vec_SF_IDLoose_UP.emplace_back(SF_IDLoose); + ++count; + } + if (vec_SF_ID_DOWN.size() != vec_SF_ID_UP.size()) { + throw std::runtime_error { + "ElectronScaleFactorCalculator::execute: Sizes of ID SF for up and down are different" + }; + } + if (vec_SF_IDLoose_DOWN.size() != vec_SF_IDLoose_UP.size()) { + throw std::runtime_error { + "ElectronScaleFactorCalculator::execute: Sizes of IDLoose SF for up and down are different" + }; + } + + ///-- ID reset to nominal --/// + top::check(m_electronEffSFIDCorrModel->applySystematicVariation(m_systNominal), + "Failed to set systematic"); + top::check(m_electronEffSFIDLooseCorrModel->applySystematicVariation( + m_systNominal), "Failed to set systematic"); + + ///-- Iso --/// + count = 0; + for (const CP::SystematicSet& isyst : m_systIsoCorrModel) { + + if (m_electronEffIso_exists) { + top::check(m_electronEffSFIsoCorrModel->applySystematicVariation(isyst), "Failed to set systematic"); + top::check(m_electronEffSFIsoCorrModel->getEfficiencyScaleFactor(*electronPtr, + SF_Isol), "Failed to get SF"); + ///-- Iso reset to nominal --/// + top::check(m_electronEffSFIsoCorrModel->applySystematicVariation( + m_systNominal), "Failed to set systematic"); + } + if (m_electronEffIsoLoose_exists) { + top::check(m_electronEffSFIsoLooseCorrModel->applySystematicVariation( + isyst), "Failed to set systematic"); + top::check(m_electronEffSFIsoLooseCorrModel->getEfficiencyScaleFactor(*electronPtr, + SF_IsolLoose), + "Failed to get SF"); + ///-- Iso reset to nominal --/// + top::check(m_electronEffSFIsoLooseCorrModel->applySystematicVariation( + m_systNominal), "Failed to set systematic"); + } + vec_SF_Isol_DOWN.emplace_back(SF_Isol); + vec_SF_IsolLoose_DOWN.emplace_back(SF_IsolLoose); + vec_SF_Isol_UP.emplace_back(SF_Isol); + vec_SF_IsolLoose_UP.emplace_back(SF_IsolLoose); + ++count; + } + if (vec_SF_Isol_DOWN.size() != vec_SF_Isol_UP.size()) { + throw std::runtime_error { + "ElectronScaleFactorCalculator::execute: Sizes of Isol SF for up and down are different" + }; + } + if (vec_SF_IsolLoose_DOWN.size() != vec_SF_IsolLoose_UP.size()) { + throw std::runtime_error { + "ElectronScaleFactorCalculator::execute: Sizes of IsolLoose SF for up and down are different" + }; + } + + + ///-- Decorate --/// + + electronPtr->auxdecor >(m_decor_triggerEff + "_CorrModel_UP") = vec_Eff_Trigger_UP; + electronPtr->auxdecor >(m_decor_triggerEff_loose + + "_CorrModel_UP") = vec_Eff_TriggerLoose_UP; + electronPtr->auxdecor >(m_decor_triggerSF + "_CorrModel_UP") = vec_SF_Trigger_UP; + electronPtr->auxdecor >(m_decor_triggerSF_loose + + "_CorrModel_UP") = vec_SF_TriggerLoose_UP; + electronPtr->auxdecor >(m_decor_recoSF + "_CorrModel_UP") = vec_SF_Reco_UP; + electronPtr->auxdecor >(m_decor_idSF + "_CorrModel_UP") = vec_SF_ID_UP; + electronPtr->auxdecor >(m_decor_idSF_loose + "_CorrModel_UP") = vec_SF_IDLoose_UP; + electronPtr->auxdecor >(m_decor_isoSF + "_CorrModel_UP") = vec_SF_Isol_UP; + electronPtr->auxdecor >(m_decor_isoSF_loose + "_CorrModel_UP") = vec_SF_IsolLoose_UP; + electronPtr->auxdecor >(m_decor_chargeidSF + "_CorrModel_UP") = vec_SF_ChargeID_UP; + electronPtr->auxdecor >(m_decor_chargeidSF_loose + + "_CorrModel_UP") = vec_SF_ChargeIDLoose_UP; + electronPtr->auxdecor >(m_decor_chargemisidSF + + "_CorrModel_UP") = vec_SF_ChargeMisID_UP; + electronPtr->auxdecor >(m_decor_chargemisidSF_loose + + "_CorrModel_UP") = vec_SF_ChargeMisIDLoose_UP; + + electronPtr->auxdecor >(m_decor_triggerEff + "_CorrModel_DOWN") = vec_Eff_Trigger_DOWN; + electronPtr->auxdecor >(m_decor_triggerEff_loose + + "_CorrModel_DOWN") = vec_Eff_TriggerLoose_DOWN; + electronPtr->auxdecor >(m_decor_triggerSF + "_CorrModel_DOWN") = vec_SF_Trigger_DOWN; + electronPtr->auxdecor >(m_decor_triggerSF_loose + + "_CorrModel_DOWN") = vec_SF_TriggerLoose_DOWN; + electronPtr->auxdecor >(m_decor_recoSF + "_CorrModel_DOWN") = vec_SF_Reco_DOWN; + electronPtr->auxdecor >(m_decor_idSF + "_CorrModel_DOWN") = vec_SF_ID_DOWN; + electronPtr->auxdecor >(m_decor_idSF_loose + "_CorrModel_DOWN") = vec_SF_IDLoose_DOWN; + electronPtr->auxdecor >(m_decor_isoSF + "_CorrModel_DOWN") = vec_SF_Isol_DOWN; + electronPtr->auxdecor >(m_decor_isoSF_loose + + "_CorrModel_DOWN") = vec_SF_IsolLoose_DOWN; + electronPtr->auxdecor >(m_decor_chargeidSF + "_CorrModel_DOWN") = vec_SF_ChargeID_DOWN; + electronPtr->auxdecor >(m_decor_chargeidSF_loose + + "_CorrModel_DOWN") = vec_SF_ChargeIDLoose_DOWN; + electronPtr->auxdecor >(m_decor_chargemisidSF + + "_CorrModel_DOWN") = vec_SF_ChargeMisID_DOWN; + electronPtr->auxdecor >(m_decor_chargemisidSF_loose + + "_CorrModel_DOWN") = vec_SF_ChargeMisIDLoose_DOWN; + }//end of saving COMBMCTOYS systematic model + + + ///////////////////////////////////////// } // Calibration systematic is nominal, so calculate SF systematics } diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/Root/MuonScaleFactorCalculator.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/Root/MuonScaleFactorCalculator.cxx index 7f39d8101efa1a3092357116150d89d5cfaeeb38..d65953c3e455517b4b3c334f60d43d10aaedbbc4 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/Root/MuonScaleFactorCalculator.cxx +++ b/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/Root/MuonScaleFactorCalculator.cxx @@ -27,6 +27,7 @@ namespace top { m_muonEfficiencyCorrectionsToolIso("MuonEfficiencyScaleFactorsToolIso"), m_muonEfficiencyCorrectionsToolLooseIso("MuonEfficiencyScaleFactorsToolLooseIso"), m_muonEfficiencyCorrectionsToolTTVA("MuonEfficiencyScaleFactorsToolTTVA"), + m_muonEfficiencyCorrectionsToolBadMuonVeto("MuonEfficiencyScaleFactorsToolBadMuonVeto"), m_decor_triggerEff("SetMe"), m_decor_triggerEff_loose("SetMe"), m_decor_triggerSF("SetMe"), m_decor_triggerSF_loose("SetMe"), @@ -49,10 +50,37 @@ namespace top { m_reco_syst_UP("MUON_EFF_RECO_SYS__1up"), m_reco_syst_DOWN("MUON_EFF_RECO_SYS__1down"), + m_reco_bkg_fraction_UP("MUON_EFF_RECO_BKGFRACTION__1up"), + m_reco_bkg_fraction_DOWN("UON_EFF_RECO_BKGFRACTION__1down"), + m_reco_fit_model_lowpt_UP("MUON_EFF_RECO_FITMODEL_LOWPT__1up"), + m_reco_fit_model_lowpt_DOWN("MUON_EFF_RECO_FITMODEL_LOWPT__1down"), + m_reco_lumi_uncert_UP("MUON_EFF_RECO_LUMIUNCERT__1up"), + m_reco_lumi_uncert_DOWN("MUON_EFF_RECO_LUMIUNCERT__1down"), + m_reco_matching_UP("MUON_EFF_RECO_MATCHING__1up"), + m_reco_matching_DOWN("MUON_EFF_RECO_MATCHING__1down"), + m_reco_matching_lowpt_UP("MUON_EFF_RECO_MATCHING_LOWPT__1up"), + m_reco_matching_lowpt_DOWN("MUON_EFF_RECO_MATCHING_LOWPT__1down"), + m_reco_mc_xsec_UP("MUON_EFF_RECO_MCXSEC__1up"), + m_reco_mc_xsec_DOWN("MUON_EFF_RECO_MCXSEC__1down"), + m_reco_pt_dependency_UP("MUON_EFF_RECO_PTDEPENDENCY__1up"), + m_reco_pt_dependency_DOWN("MUON_EFF_RECO_PTDEPENDENCY__1down"), + m_reco_qcd_template_UP("MUON_EFF_RECO_QCDTEMPLATE__1up"), + m_reco_qcd_template_DOWN("MUON_EFF_RECO_QCDTEMPLATE__1down"), + m_reco_supression_scale_UP("MUON_EFF_RECO_SUPRESSIONSCALE__1up"), + m_reco_supression_scale_DOWN("MUON_EFF_RECO_SUPRESSIONSCALE__1down"), + m_reco_sys_UP("MUON_EFF_RECO_SYS__1up"), + m_reco_sys_DOWN("MUON_EFF_RECO_SYS__1down"), + m_reco_truth_UP("MUON_EFF_RECO_TRUTH__1up"), + m_reco_truth_DOWN("MUON_EFF_RECO_TRUTH__1down"), + m_reco_truth_lowpt_UP("MUON_EFF_RECO_TRUTH_LOWPT__1up"), + m_reco_truth_lowpt_DOWN("MUON_EFF_RECO_TRUTH_LOWPT__1down"), + m_reco_stat_lowpt_UP("MUON_EFF_RECO_STAT_LOWPT__1up"), m_reco_stat_lowpt_DOWN("MUON_EFF_RECO_STAT_LOWPT__1down"), m_reco_syst_lowpt_UP("MUON_EFF_RECO_SYS_LOWPT__1up"), m_reco_syst_lowpt_DOWN("MUON_EFF_RECO_SYS_LOWPT__1down"), + m_reco_bad_muon_veto_UP("MUON_EFF_BADMUON_SYS__1up"), + m_reco_bad_muon_veto_DOWN("MUON_EFF_BADMUON_SYS__1down"), m_iso_stat_UP("MUON_EFF_ISO_STAT__1up"), m_iso_stat_DOWN("MUON_EFF_ISO_STAT__1down"), @@ -62,7 +90,18 @@ namespace top { m_TTVA_stat_UP("MUON_EFF_TTVA_STAT__1up"), m_TTVA_stat_DOWN("MUON_EFF_TTVA_STAT__1down"), m_TTVA_syst_UP("MUON_EFF_TTVA_SYS__1up"), - m_TTVA_syst_DOWN("MUON_EFF_TTVA_SYS__1down") { + m_TTVA_syst_DOWN("MUON_EFF_TTVA_SYS__1down"), + + m_TTVA_bkg_fraction_UP("MUON_EFF_TTVA_BKGFRACTION__1up"), + m_TTVA_bkg_fraction_DOWN("MUON_EFF_TTVA_BKGFRACTION__1down"), + m_TTVA_lumi_uncert_UP("MUON_EFF_TTVA_LUMIUNCERT__1up"), + m_TTVA_lumi_uncert_DOWN("MUON_EFF_TTVA_LUMIUNCERT__1down"), + m_TTVA_mc_xsec_UP("MUON_EFF_TTVA_MCXSEC__1up"), + m_TTVA_mc_xsec_DOWN("MUON_EFF_TTVA_MCXSEC__1down"), + m_TTVA_qcd_template_UP("MUON_EFF_TTVA_QCDTEMPLATE__1up"), + m_TTVA_qcd_template_DOWN("MUON_EFF_TTVA_QCDTEMPLATE__1down"), + m_TTVA_supression_scale_UP("MUON_EFF_TTVA_SUPRESSIONSCALE__1up"), + m_TTVA_supression_scale_DOWN("MUON_EFF_TTVA_SUPRESSIONSCALE__1down") { declareProperty("config", m_config); } @@ -74,18 +113,55 @@ namespace top { ToolHandle("MuonTriggerScaleFactorsLoose_R21"); std::set implemented_systematics; - implemented_systematics = { - "MUON_EFF_RECO_STAT", - "MUON_EFF_RECO_STAT_LOWPT", - "MUON_EFF_RECO_SYS", - "MUON_EFF_RECO_SYS_LOWPT", - "MUON_EFF_TrigStatUncertainty", - "MUON_EFF_TrigSystUncertainty", - "MUON_EFF_ISO_STAT", - "MUON_EFF_ISO_SYS", - "MUON_EFF_TTVA_STAT", - "MUON_EFF_TTVA_SYS" - }; + if (m_config->muonBreakDownSystematics()) { + implemented_systematics = { + "MUON_EFF_ISO_STAT", + "MUON_EFF_ISO_SYS", + "MUON_EFF_RECO_BKGFRACTION", + "MUON_EFF_RECO_FITMODEL_LOWPT", + "MUON_EFF_RECO_LUMIUNCERT", + "MUON_EFF_RECO_MATCHING", + "MUON_EFF_RECO_MATCHING_LOWPT", + "MUON_EFF_RECO_MCXSEC", + "MUON_EFF_RECO_PTDEPENDENCY", + "MUON_EFF_RECO_QCDTEMPLATE", + "MUON_EFF_RECO_STAT", + "MUON_EFF_RECO_STAT_LOWPT", + "MUON_EFF_RECO_SUPRESSIONSCALE", + "MUON_EFF_RECO_SYS", + "MUON_EFF_RECO_TRUTH", + "MUON_EFF_RECO_TRUTH_LOWPT", + "MUON_EFF_TTVA_BKGFRACTION", + "MUON_EFF_TTVA_LUMIUNCERT", + "MUON_EFF_TTVA_MCXSEC", + "MUON_EFF_TTVA_QCDTEMPLATE", + "MUON_EFF_TTVA_STAT", + "MUON_EFF_TTVA_SUPRESSIONSCALE", + "MUON_EFF_TrigStatUncertainty", + "MUON_EFF_TrigSystUncertainty", + }; + if (m_config->muonQuality() == "HighPt" || m_config->muonQualityLoose() == "HighPt") { + implemented_systematics.insert("MUON_EFF_BADMUON_PTDEPENDENCY"); + m_reco_bad_muon_veto_UP = CP::SystematicSet("MUON_EFF_BADMUON_PTDEPENDENCY__1up"); + m_reco_bad_muon_veto_DOWN = CP::SystematicSet("MUON_EFF_BADMUON_PTDEPENDENCY__1down"); + } + } else { + implemented_systematics = { + "MUON_EFF_RECO_STAT", + "MUON_EFF_RECO_STAT_LOWPT", + "MUON_EFF_RECO_SYS", + "MUON_EFF_RECO_SYS_LOWPT", + "MUON_EFF_TrigStatUncertainty", + "MUON_EFF_TrigSystUncertainty", + "MUON_EFF_ISO_STAT", + "MUON_EFF_ISO_SYS", + "MUON_EFF_TTVA_STAT", + "MUON_EFF_TTVA_SYS" + }; + if (m_config->muonQuality() == "HighPt" || m_config->muonQualityLoose() == "HighPt") { + implemented_systematics.insert("MUON_EFF_BADMUON_SYS"); + } + } std::set recommended_systematics; @@ -106,6 +182,10 @@ namespace top { this->retrieveSystematicTool(m_muonEfficiencyCorrectionsToolLoose, recommended_systematics); + if (m_config->muonQuality() == "HighPt" || m_config->muonQualityLoose() == "HighPt") { + this->retrieveSystematicTool(m_muonEfficiencyCorrectionsToolBadMuonVeto, + recommended_systematics); + } if (asg::ToolStore::contains("MuonEfficiencyScaleFactorsToolIso")) { this->retrieveSystematicTool(m_muonEfficiencyCorrectionsToolIso, @@ -233,6 +313,9 @@ namespace top { this->applySystematicVariation(m_muonEfficiencyCorrectionsTool, m_systNominal); this->applySystematicVariation(m_muonEfficiencyCorrectionsToolLoose, m_systNominal); this->applySystematicVariation(m_muonEfficiencyCorrectionsToolTTVA, m_systNominal); + if (m_config->muonQuality() == "HighPt" || m_config->muonQualityLoose() == "HighPt") { + this->applySystematicVariation(m_muonEfficiencyCorrectionsToolBadMuonVeto, m_systNominal); + } //-- Only do isolation if we actually get the tools --// if (m_do_muon_isolation_SFs) this->applySystematicVariation(m_muonEfficiencyCorrectionsToolIso, m_systNominal); @@ -607,15 +690,52 @@ namespace top { static SG::AuxElement::Decorator TTVA_decor_stat_down(m_decor_TTVA + "_STAT_DOWN"); static SG::AuxElement::Decorator TTVA_decor_syst_up(m_decor_TTVA + "_SYST_UP"); static SG::AuxElement::Decorator TTVA_decor_syst_down(m_decor_TTVA + "_SYST_DOWN"); - - this->decorateEfficiencySF(m_muonEfficiencyCorrectionsToolTTVA, - m_TTVA_stat_UP, muon, TTVA_decor_stat_up); - this->decorateEfficiencySF(m_muonEfficiencyCorrectionsToolTTVA, - m_TTVA_stat_DOWN, muon, TTVA_decor_stat_down); - this->decorateEfficiencySF(m_muonEfficiencyCorrectionsToolTTVA, - m_TTVA_syst_UP, muon, TTVA_decor_syst_up); - this->decorateEfficiencySF(m_muonEfficiencyCorrectionsToolTTVA, - m_TTVA_syst_DOWN, muon, TTVA_decor_syst_down); + static SG::AuxElement::Decorator TTVA_decor_lumi_uncert_up(m_decor_TTVA + "_LUMI_UNCERT_UP"); + static SG::AuxElement::Decorator TTVA_decor_lumi_uncert_down(m_decor_TTVA + "_LUMI_UNCERT_DOWN"); + static SG::AuxElement::Decorator TTVA_decor_bkg_fraction_up(m_decor_TTVA + "_BKG_FRACTION_UP"); + static SG::AuxElement::Decorator TTVA_decor_bkg_fraction_down(m_decor_TTVA + "_BKG_FRACTION_DOWN"); + static SG::AuxElement::Decorator TTVA_decor_mc_xsec_up(m_decor_TTVA + "_MC_XSEC_UP"); + static SG::AuxElement::Decorator TTVA_decor_mc_xsec_down(m_decor_TTVA + "_MC_XSEC_DOWN"); + static SG::AuxElement::Decorator TTVA_decor_qcd_template_up(m_decor_TTVA + "_QCD_TEMPLATE_UP"); + static SG::AuxElement::Decorator TTVA_decor_qcd_template_down(m_decor_TTVA + "_QCD_TEMPLATE_DOWN"); + static SG::AuxElement::Decorator TTVA_decor_supression_scale_up(m_decor_TTVA + "_SUPRESSION_SCALE_UP"); + static SG::AuxElement::Decorator TTVA_decor_supression_scale_down(m_decor_TTVA + "_SUPRESSION_SCALE_DOWN"); + + if (m_config->muonBreakDownSystematics()) { + this->decorateEfficiencySF(m_muonEfficiencyCorrectionsToolTTVA, + m_TTVA_stat_UP, muon, TTVA_decor_stat_up); + this->decorateEfficiencySF(m_muonEfficiencyCorrectionsToolTTVA, + m_TTVA_stat_DOWN, muon, TTVA_decor_stat_down); + this->decorateEfficiencySF(m_muonEfficiencyCorrectionsToolTTVA, + m_TTVA_bkg_fraction_UP, muon, TTVA_decor_bkg_fraction_up); + this->decorateEfficiencySF(m_muonEfficiencyCorrectionsToolTTVA, + m_TTVA_bkg_fraction_DOWN, muon, TTVA_decor_bkg_fraction_down); + this->decorateEfficiencySF(m_muonEfficiencyCorrectionsToolTTVA, + m_TTVA_lumi_uncert_UP, muon, TTVA_decor_lumi_uncert_up); + this->decorateEfficiencySF(m_muonEfficiencyCorrectionsToolTTVA, + m_TTVA_lumi_uncert_DOWN, muon, TTVA_decor_lumi_uncert_down); + this->decorateEfficiencySF(m_muonEfficiencyCorrectionsToolTTVA, + m_TTVA_mc_xsec_UP, muon, TTVA_decor_mc_xsec_up); + this->decorateEfficiencySF(m_muonEfficiencyCorrectionsToolTTVA, + m_TTVA_mc_xsec_DOWN, muon, TTVA_decor_mc_xsec_down); + this->decorateEfficiencySF(m_muonEfficiencyCorrectionsToolTTVA, + m_TTVA_qcd_template_UP, muon, TTVA_decor_qcd_template_up); + this->decorateEfficiencySF(m_muonEfficiencyCorrectionsToolTTVA, + m_TTVA_qcd_template_DOWN, muon, TTVA_decor_qcd_template_down); + this->decorateEfficiencySF(m_muonEfficiencyCorrectionsToolTTVA, + m_TTVA_supression_scale_UP, muon, TTVA_decor_supression_scale_up); + this->decorateEfficiencySF(m_muonEfficiencyCorrectionsToolTTVA, + m_TTVA_supression_scale_DOWN, muon, TTVA_decor_supression_scale_down); + } else { + this->decorateEfficiencySF(m_muonEfficiencyCorrectionsToolTTVA, + m_TTVA_stat_UP, muon, TTVA_decor_stat_up); + this->decorateEfficiencySF(m_muonEfficiencyCorrectionsToolTTVA, + m_TTVA_stat_DOWN, muon, TTVA_decor_stat_down); + this->decorateEfficiencySF(m_muonEfficiencyCorrectionsToolTTVA, + m_TTVA_syst_UP, muon, TTVA_decor_syst_up); + this->decorateEfficiencySF(m_muonEfficiencyCorrectionsToolTTVA, + m_TTVA_syst_DOWN, muon, TTVA_decor_syst_down); + } } void MuonScaleFactorCalculator::decorateIDSFandRecoEff(ToolHandle& tool, @@ -629,92 +749,356 @@ namespace top { } void MuonScaleFactorCalculator::decorateIDSFandRecoEffSystematics(const xAOD::Muon& muon) { - static SG::AuxElement::Decorator id_sf_decor_stat_up(m_decor_idSF + "_STAT_UP"); - static SG::AuxElement::Decorator id_sf_loose_decor_stat_up(m_decor_idSF_loose + "_STAT_UP"); - - static SG::AuxElement::Decorator id_sf_decor_stat_down(m_decor_idSF + "_STAT_DOWN"); - static SG::AuxElement::Decorator id_sf_loose_decor_stat_down(m_decor_idSF_loose + "_STAT_DOWN"); - - static SG::AuxElement::Decorator id_sf_decor_syst_up(m_decor_idSF + "_SYST_UP"); - static SG::AuxElement::Decorator id_sf_loose_decor_syst_up(m_decor_idSF_loose + "_SYST_UP"); - - static SG::AuxElement::Decorator id_sf_decor_syst_down(m_decor_idSF + "_SYST_DOWN"); - static SG::AuxElement::Decorator id_sf_loose_decor_syst_down(m_decor_idSF_loose + "_SYST_DOWN"); - - - ///-- Stat UP --/// - this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, - m_reco_stat_UP, muon, - id_sf_decor_stat_up); - this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, - m_reco_stat_UP, muon, - id_sf_loose_decor_stat_up); - - ///-- Stat DOWN --/// - this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, - m_reco_stat_DOWN, muon, - id_sf_decor_stat_down); - this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, - m_reco_stat_DOWN, muon, - id_sf_loose_decor_stat_down); - ///-- Syst UP --/// - this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, - m_reco_syst_UP, muon, - id_sf_decor_syst_up); - this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, - m_reco_syst_UP, muon, - id_sf_loose_decor_syst_up); - - ///-- Syst DOWN --/// - this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, - m_reco_syst_DOWN, muon, - id_sf_decor_syst_down); - this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, - m_reco_syst_DOWN, muon, - id_sf_loose_decor_syst_down); - - static SG::AuxElement::Decorator id_sf_decor_stat_lowpt_up(m_decor_idSF + "_STAT_LOWPT_UP"); - static SG::AuxElement::Decorator id_sf_loose_decor_stat_lowpt_up(m_decor_idSF_loose + "_STAT_LOWPT_UP"); + const static SG::AuxElement::Decorator id_sf_decor_stat_up(m_decor_idSF + "_STAT_UP"); + const static SG::AuxElement::Decorator id_sf_loose_decor_stat_up(m_decor_idSF_loose + "_STAT_UP"); + + const static SG::AuxElement::Decorator id_sf_decor_stat_down(m_decor_idSF + "_STAT_DOWN"); + const static SG::AuxElement::Decorator id_sf_loose_decor_stat_down(m_decor_idSF_loose + "_STAT_DOWN"); + + const static SG::AuxElement::Decorator id_sf_decor_syst_up(m_decor_idSF + "_SYST_UP"); + const static SG::AuxElement::Decorator id_sf_loose_decor_syst_up(m_decor_idSF_loose + "_SYST_UP"); + + const static SG::AuxElement::Decorator id_sf_decor_syst_down(m_decor_idSF + "_SYST_DOWN"); + const static SG::AuxElement::Decorator id_sf_loose_decor_syst_down(m_decor_idSF_loose + "_SYST_DOWN"); + + const static SG::AuxElement::Decorator id_sf_decor_stat_lowpt_up(m_decor_idSF + "_STAT_LOWPT_UP"); + const static SG::AuxElement::Decorator id_sf_loose_decor_stat_lowpt_up(m_decor_idSF_loose + "_STAT_LOWPT_UP"); + + const static SG::AuxElement::Decorator id_sf_decor_stat_lowpt_down(m_decor_idSF + "_STAT_LOWPT_DOWN"); + const static SG::AuxElement::Decorator id_sf_loose_decor_stat_lowpt_down(m_decor_idSF_loose + "_STAT_LOWPT_DOWN"); + + const static SG::AuxElement::Decorator id_sf_decor_syst_lowpt_up(m_decor_idSF + "_SYST_LOWPT_UP"); + const static SG::AuxElement::Decorator id_sf_loose_decor_syst_lowpt_up(m_decor_idSF_loose + "_SYST_LOWPT_UP"); + + const static SG::AuxElement::Decorator id_sf_decor_syst_lowpt_down(m_decor_idSF + "_SYST_LOWPT_DOWN"); + const static SG::AuxElement::Decorator id_sf_loose_decor_syst_lowpt_down(m_decor_idSF_loose + "_SYST_LOWPT_DOWN"); + + const static SG::AuxElement::Decorator id_sf_decor_bkg_fraction_up(m_decor_idSF + "_BKG_FRACTION_UP"); + const static SG::AuxElement::Decorator id_sf_loose_decor_bkg_fraction_up(m_decor_idSF_loose + "_BKG_FRACTION_UP"); + const static SG::AuxElement::Decorator id_sf_decor_bkg_fraction_down(m_decor_idSF + "_BKG_FRACTION_DOWN"); + const static SG::AuxElement::Decorator id_sf_loose_decor_bkg_fraction_down(m_decor_idSF_loose + "_BKG_FRACTION_DOWN"); + + const static SG::AuxElement::Decorator id_sf_decor_fit_model_lowpt_up(m_decor_idSF + "_FIT_MODEL_LOWPT_UP"); + const static SG::AuxElement::Decorator id_sf_loose_decor_fit_model_lowpt_up(m_decor_idSF_loose + "_FIT_MODEL_LOWPT_UP"); + const static SG::AuxElement::Decorator id_sf_decor_fit_model_lowpt_down(m_decor_idSF + "_FIT_MODEL_LOWPT_DOWN"); + const static SG::AuxElement::Decorator id_sf_loose_decor_fit_model_lowpt_down(m_decor_idSF_loose + "_FIT_MODEL_LOWPT_DOWN"); + + const static SG::AuxElement::Decorator id_sf_decor_lumi_uncert_up(m_decor_idSF + "_LUMI_UNCERT_UP"); + const static SG::AuxElement::Decorator id_sf_loose_decor_lumi_uncert_up(m_decor_idSF_loose + "_LUMI_UNCERT_UP"); + const static SG::AuxElement::Decorator id_sf_decor_lumi_uncert_down(m_decor_idSF + "_LUMI_UNCERT_DOWN"); + const static SG::AuxElement::Decorator id_sf_loose_decor_lumi_uncert_down(m_decor_idSF_loose + "_LUMI_UNCERT_DOWN"); + + const static SG::AuxElement::Decorator id_sf_decor_matching_up(m_decor_idSF + "_MATCHING_UP"); + const static SG::AuxElement::Decorator id_sf_loose_decor_matching_up(m_decor_idSF_loose + "_MATCHING_UP"); + const static SG::AuxElement::Decorator id_sf_decor_matching_down(m_decor_idSF + "_MATCHING_DOWN"); + const static SG::AuxElement::Decorator id_sf_loose_decor_matching_down(m_decor_idSF_loose + "_MATCHING_DOWN"); + + const static SG::AuxElement::Decorator id_sf_decor_matching_lowpt_up(m_decor_idSF + "_MATCHING_LOWPT_UP"); + const static SG::AuxElement::Decorator id_sf_loose_decor_matching_lowpt_up(m_decor_idSF_loose + "_MATCHING_LOWPT_UP"); + const static SG::AuxElement::Decorator id_sf_decor_matching_lowpt_down(m_decor_idSF + "_MATCHING_LOWPT_DOWN"); + const static SG::AuxElement::Decorator id_sf_loose_decor_matching_lowpt_down(m_decor_idSF_loose + "_MATCHING_LOWPT_DOWN"); + + const static SG::AuxElement::Decorator id_sf_decor_mc_xsec_up(m_decor_idSF + "_MC_XSEC_UP"); + const static SG::AuxElement::Decorator id_sf_loose_decor_mc_xsec_up(m_decor_idSF_loose + "_MC_XSEC_UP"); + const static SG::AuxElement::Decorator id_sf_decor_mc_xsec_down(m_decor_idSF + "_MC_XSEC_DOWN"); + const static SG::AuxElement::Decorator id_sf_loose_decor_mc_xsec_down(m_decor_idSF_loose + "_MC_XSEC_DOWN"); + + const static SG::AuxElement::Decorator id_sf_decor_pt_dependency_up(m_decor_idSF + "_PT_DEPENDENCY_UP"); + const static SG::AuxElement::Decorator id_sf_loose_decor_pt_dependency_up(m_decor_idSF_loose + "_PT_DEPENDENCY_UP"); + const static SG::AuxElement::Decorator id_sf_decor_pt_dependency_down(m_decor_idSF + "_PT_DEPENDENCY_DOWN"); + const static SG::AuxElement::Decorator id_sf_loose_decor_pt_dependency_down(m_decor_idSF_loose + "_PT_DEPENDENCY_DOWN"); + + const static SG::AuxElement::Decorator id_sf_decor_qcd_template_up(m_decor_idSF + "_QCD_TEMPLATE_UP"); + const static SG::AuxElement::Decorator id_sf_loose_decor_qcd_template_up(m_decor_idSF_loose + "_QCD_TEMPLATE_UP"); + const static SG::AuxElement::Decorator id_sf_decor_qcd_template_down(m_decor_idSF + "_QCD_TEMPLATE_DOWN"); + const static SG::AuxElement::Decorator id_sf_loose_decor_qcd_template_down(m_decor_idSF_loose + "_QCD_TEMPLATE_DOWN"); + + const static SG::AuxElement::Decorator id_sf_decor_supression_scale_up(m_decor_idSF + "_SUPRESSION_SCALE_UP"); + const static SG::AuxElement::Decorator id_sf_loose_decor_supression_scale_up(m_decor_idSF_loose + "_SUPRESSION_SCALE_UP"); + const static SG::AuxElement::Decorator id_sf_decor_supression_scale_down(m_decor_idSF + "_SUPRESSION_SCALE_DOWN"); + const static SG::AuxElement::Decorator id_sf_loose_decor_supression_scale_down(m_decor_idSF_loose + "_SUPRESSION_SCALE_DOWN"); + + const static SG::AuxElement::Decorator id_sf_decor_sys_up(m_decor_idSF + "_SYS_UP"); + const static SG::AuxElement::Decorator id_sf_loose_decor_sys_up(m_decor_idSF_loose + "_SYS_UP"); + const static SG::AuxElement::Decorator id_sf_decor_sys_down(m_decor_idSF + "_SYS_DOWN"); + const static SG::AuxElement::Decorator id_sf_loose_decor_sys_down(m_decor_idSF_loose + "_SYS_DOWN"); + + const static SG::AuxElement::Decorator id_sf_decor_truth_up(m_decor_idSF + "_TRUTH_UP"); + const static SG::AuxElement::Decorator id_sf_loose_decor_truth_up(m_decor_idSF_loose + "_TRUTH_UP"); + const static SG::AuxElement::Decorator id_sf_decor_truth_down(m_decor_idSF + "_TRUTH_DOWN"); + const static SG::AuxElement::Decorator id_sf_loose_decor_truth_down(m_decor_idSF_loose + "_TRUTH_DOWN"); + + const static SG::AuxElement::Decorator id_sf_decor_truth_lowpt_up(m_decor_idSF + "_TRUTH_LOWPT_UP"); + const static SG::AuxElement::Decorator id_sf_loose_decor_truth_lowpt_up(m_decor_idSF_loose + "_TRUTH_LOWPT_UP"); + const static SG::AuxElement::Decorator id_sf_decor_truth_lowpt_down(m_decor_idSF + "_TRUTH_LOWPT_DOWN"); + const static SG::AuxElement::Decorator id_sf_loose_decor_truth_lowpt_down(m_decor_idSF_loose + "_TRUTH_LOWPT_DOWN"); + + const static SG::AuxElement::Decorator id_sf_decor_bad_muon_veto_up(m_decor_idSF + "_BAD_MUON_VETO_UP"); + const static SG::AuxElement::Decorator id_sf_decor_bad_muon_veto_down(m_decor_idSF + "_BAD_MUON_VETO_DOWN"); + const static SG::AuxElement::Decorator id_sf_loose_decor_bad_muon_veto_up(m_decor_idSF_loose + "_BAD_MUON_VETO_UP"); + const static SG::AuxElement::Decorator id_sf_loose_decor_bad_muon_veto_down(m_decor_idSF_loose + "_BAD_MUON_VETO_DOWN"); + + + if (m_config->muonBreakDownSystematics()) { + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_stat_UP, muon, + id_sf_decor_stat_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_stat_UP, muon, + id_sf_loose_decor_stat_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_stat_DOWN, muon, + id_sf_decor_stat_down); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_stat_DOWN, muon, + id_sf_loose_decor_stat_down); + + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_stat_lowpt_UP, muon, + id_sf_decor_stat_lowpt_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_stat_lowpt_UP, muon, + id_sf_loose_decor_stat_lowpt_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_stat_lowpt_DOWN, muon, + id_sf_decor_stat_lowpt_down); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_stat_lowpt_DOWN, muon, + id_sf_loose_decor_stat_lowpt_down); + + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_bkg_fraction_UP, muon, + id_sf_decor_bkg_fraction_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_bkg_fraction_UP, muon, + id_sf_loose_decor_bkg_fraction_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_bkg_fraction_DOWN, muon, + id_sf_decor_bkg_fraction_down); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_bkg_fraction_DOWN, muon, + id_sf_loose_decor_bkg_fraction_down); + + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_fit_model_lowpt_UP, muon, + id_sf_decor_fit_model_lowpt_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_fit_model_lowpt_UP, muon, + id_sf_loose_decor_fit_model_lowpt_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_fit_model_lowpt_DOWN, muon, + id_sf_decor_fit_model_lowpt_down); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_fit_model_lowpt_DOWN, muon, + id_sf_loose_decor_fit_model_lowpt_down); + + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_lumi_uncert_UP, muon, + id_sf_decor_lumi_uncert_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_lumi_uncert_UP, muon, + id_sf_loose_decor_lumi_uncert_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_lumi_uncert_DOWN, muon, + id_sf_decor_lumi_uncert_down); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_lumi_uncert_DOWN, muon, + id_sf_loose_decor_lumi_uncert_down); + + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_matching_UP, muon, + id_sf_decor_matching_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_matching_UP, muon, + id_sf_loose_decor_matching_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_matching_DOWN, muon, + id_sf_decor_matching_down); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_matching_DOWN, muon, + id_sf_loose_decor_matching_down); + + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_matching_lowpt_UP, muon, + id_sf_decor_matching_lowpt_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_matching_lowpt_UP, muon, + id_sf_loose_decor_matching_lowpt_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_matching_lowpt_DOWN, muon, + id_sf_decor_matching_lowpt_down); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_matching_lowpt_DOWN, muon, + id_sf_loose_decor_matching_lowpt_down); + + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_mc_xsec_UP, muon, + id_sf_decor_mc_xsec_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_mc_xsec_UP, muon, + id_sf_loose_decor_mc_xsec_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_mc_xsec_DOWN, muon, + id_sf_decor_mc_xsec_down); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_mc_xsec_DOWN, muon, + id_sf_loose_decor_mc_xsec_down); + + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_pt_dependency_UP, muon, + id_sf_decor_pt_dependency_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_pt_dependency_UP, muon, + id_sf_loose_decor_pt_dependency_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_pt_dependency_DOWN, muon, + id_sf_decor_pt_dependency_down); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_pt_dependency_DOWN, muon, + id_sf_loose_decor_pt_dependency_down); + + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_qcd_template_UP, muon, + id_sf_decor_qcd_template_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_qcd_template_UP, muon, + id_sf_loose_decor_qcd_template_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_qcd_template_DOWN, muon, + id_sf_decor_qcd_template_down); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_qcd_template_DOWN, muon, + id_sf_loose_decor_qcd_template_down); + + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_supression_scale_UP, muon, + id_sf_decor_supression_scale_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_supression_scale_UP, muon, + id_sf_loose_decor_supression_scale_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_supression_scale_DOWN, muon, + id_sf_decor_supression_scale_down); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_supression_scale_DOWN, muon, + id_sf_loose_decor_supression_scale_down); + + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_sys_UP, muon, + id_sf_decor_sys_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_sys_UP, muon, + id_sf_loose_decor_sys_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_sys_DOWN, muon, + id_sf_decor_sys_down); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_sys_DOWN, muon, + id_sf_loose_decor_sys_down); + + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_truth_UP, muon, + id_sf_decor_truth_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_truth_UP, muon, + id_sf_loose_decor_truth_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_truth_DOWN, muon, + id_sf_decor_truth_down); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_truth_DOWN, muon, + id_sf_loose_decor_truth_down); + + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_truth_lowpt_UP, muon, + id_sf_decor_truth_lowpt_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_truth_lowpt_UP, muon, + id_sf_loose_decor_truth_lowpt_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_truth_lowpt_DOWN, muon, + id_sf_decor_truth_lowpt_down); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_truth_lowpt_DOWN, muon, + id_sf_loose_decor_truth_lowpt_down); - static SG::AuxElement::Decorator id_sf_decor_stat_lowpt_down(m_decor_idSF + "_STAT_LOWPT_DOWN"); - static SG::AuxElement::Decorator id_sf_loose_decor_stat_lowpt_down(m_decor_idSF_loose + "_STAT_LOWPT_DOWN"); + } else { + ///-- Stat UP --/// + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_stat_UP, muon, + id_sf_decor_stat_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_stat_UP, muon, + id_sf_loose_decor_stat_up); - static SG::AuxElement::Decorator id_sf_decor_syst_lowpt_up(m_decor_idSF + "_SYST_LOWPT_UP"); - static SG::AuxElement::Decorator id_sf_loose_decor_syst_lowpt_up(m_decor_idSF_loose + "_SYST_LOWPT_UP"); + ///-- Stat DOWN --/// + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_stat_DOWN, muon, + id_sf_decor_stat_down); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_stat_DOWN, muon, + id_sf_loose_decor_stat_down); + ///-- Syst UP --/// + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_syst_UP, muon, + id_sf_decor_syst_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_syst_UP, muon, + id_sf_loose_decor_syst_up); - static SG::AuxElement::Decorator id_sf_decor_syst_lowpt_down(m_decor_idSF + "_SYST_LOWPT_DOWN"); - static SG::AuxElement::Decorator id_sf_loose_decor_syst_lowpt_down(m_decor_idSF_loose + "_SYST_LOWPT_DOWN"); + ///-- Syst DOWN --/// + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_syst_DOWN, muon, + id_sf_decor_syst_down); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_syst_DOWN, muon, + id_sf_loose_decor_syst_down); - ///-- Stat UP --/// - this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, - m_reco_stat_lowpt_UP, muon, - id_sf_decor_stat_lowpt_up); - this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, - m_reco_stat_lowpt_UP, muon, - id_sf_loose_decor_stat_lowpt_up); + ///-- Stat UP --/// + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_stat_lowpt_UP, muon, + id_sf_decor_stat_lowpt_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_stat_lowpt_UP, muon, + id_sf_loose_decor_stat_lowpt_up); - ///-- Stat DOWN --/// - this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, - m_reco_stat_lowpt_DOWN, muon, - id_sf_decor_stat_lowpt_down); - this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, - m_reco_stat_lowpt_DOWN, muon, - id_sf_loose_decor_stat_lowpt_down); - ///-- Syst UP --/// - this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, - m_reco_syst_lowpt_UP, muon, - id_sf_decor_syst_lowpt_up); - this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, - m_reco_syst_lowpt_UP, muon, - id_sf_loose_decor_syst_lowpt_up); + ///-- Stat DOWN --/// + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_stat_lowpt_DOWN, muon, + id_sf_decor_stat_lowpt_down); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_stat_lowpt_DOWN, muon, + id_sf_loose_decor_stat_lowpt_down); + ///-- Syst UP --/// + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_syst_lowpt_UP, muon, + id_sf_decor_syst_lowpt_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_syst_lowpt_UP, muon, + id_sf_loose_decor_syst_lowpt_up); - ///-- Syst DOWN --/// - this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, - m_reco_syst_lowpt_DOWN, muon, - id_sf_decor_syst_lowpt_down); - this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, - m_reco_syst_lowpt_DOWN, muon, - id_sf_loose_decor_syst_lowpt_down); + ///-- Syst DOWN --/// + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsTool, + m_reco_syst_lowpt_DOWN, muon, + id_sf_decor_syst_lowpt_down); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolLoose, + m_reco_syst_lowpt_DOWN, muon, + id_sf_loose_decor_syst_lowpt_down); + } + if (m_config->muonQuality() == "HighPt" || m_config->muonQualityLoose() == "HighPt") { + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolBadMuonVeto, + m_reco_bad_muon_veto_UP, muon, + id_sf_decor_bad_muon_veto_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolBadMuonVeto, + m_reco_bad_muon_veto_DOWN, muon, + id_sf_decor_bad_muon_veto_down); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolBadMuonVeto, + m_reco_bad_muon_veto_UP, muon, + id_sf_loose_decor_bad_muon_veto_up); + this->decorateIDSFandRecoEff(m_muonEfficiencyCorrectionsToolBadMuonVeto, + m_reco_bad_muon_veto_DOWN, muon, + id_sf_loose_decor_bad_muon_veto_down); + } } void MuonScaleFactorCalculator::decorateIDSFandRecoEffSystematicsSoftMuon(const xAOD::Muon& muon) { diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/Root/ScaleFactorRetriever.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/Root/ScaleFactorRetriever.cxx index 876b61cd82ac97d3aebf5f181deb5d36db688ae4..e35aa18cf85c228e7aa4eb909afd3b4e8ec013fd 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/Root/ScaleFactorRetriever.cxx +++ b/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/Root/ScaleFactorRetriever.cxx @@ -239,7 +239,7 @@ namespace top { } std::vector ScaleFactorRetriever::electronSFSystVariationVector(const top::Event& event, - const top::topSFComp SFComp, int var) const { + const top::topSFComp SFComp, int var, int sysSize) const { std::vector sf; if (abs(var) != 1) { @@ -302,6 +302,7 @@ namespace top { } }//end of loop on electrons + if (sf.size() == 0) sf = std::vector(sysSize, leptonSF(event, top::topSFSyst::nominal)); return sf; } @@ -337,10 +338,8 @@ namespace top { id *= electronSF_ID(*elPtr, electronID, SFSyst, retrieveLoose); isol *= electronSF_Isol(*elPtr, electronIso, SFSyst, retrieveLoose); chargeid *= electronSF_ChargeID(*elPtr, electronID, electronIso, SFSyst, retrieveLoose); - // Charge MisID is not supported for PLVTight/Loose, we already printed a warning message in TopEgammaCPTools - if (electronIso != "PLVTight" && electronIso != "PLVLoose") { - chargemisid *= electronSF_ChargeMisID(*elPtr, electronID, electronIso, SFSyst, retrieveLoose); - } + // we can add charge misID SF since it defaults to 1. for the unsupported WPs + chargemisid *= electronSF_ChargeMisID(*elPtr, electronID, electronIso, SFSyst, retrieveLoose); } sf = reco * id * isol; // *chargeid*chargemisid; // let the charge id scale factors out until further tested by @@ -882,12 +881,117 @@ namespace top { decoration += "_SYST_LOWPT_DOWN"; break; + case top::topSFSyst::MU_SF_ID_BKG_FRACTION_UP: + decoration += "_BKG_FRACTION_UP"; + break; + + case top::topSFSyst::MU_SF_ID_BKG_FRACTION_DOWN: + decoration += "_BKG_FRACTION_DOWN"; + break; + + case top::topSFSyst::MU_SF_ID_FIT_MODEL_LOWPT_UP: + decoration += "_FIT_MODEL_LOWPT_UP"; + break; + + case top::topSFSyst::MU_SF_ID_FIT_MODEL_LOWPT_DOWN: + decoration += "_FIT_MODEL_LOWPT_DOWN"; + break; + + case top::topSFSyst::MU_SF_ID_LUMI_UNCERT_UP: + decoration += "_LUMI_UNCERT_UP"; + break; + + case top::topSFSyst::MU_SF_ID_LUMI_UNCERT_DOWN: + decoration += "_LUMI_UNCERT_DOWN"; + break; + + case top::topSFSyst::MU_SF_ID_MATCHING_UP: + decoration += "_MATCHING_UP"; + break; + + case top::topSFSyst::MU_SF_ID_MATCHING_DOWN: + decoration += "_MATCHING_DOWN"; + break; + + case top::topSFSyst::MU_SF_ID_MATCHING_LOWPT_UP: + decoration += "_MATCHING_LOWPT_UP"; + break; + + case top::topSFSyst::MU_SF_ID_MATCHING_LOWPT_DOWN: + decoration += "_MATCHING_LOWPT_DOWN"; + break; + + case top::topSFSyst::MU_SF_ID_MC_XSEC_UP: + decoration += "_MC_XSEC_UP"; + break; + + case top::topSFSyst::MU_SF_ID_MC_XSEC_DOWN: + decoration += "_MC_XSEC_DOWN"; + break; + + case top::topSFSyst::MU_SF_ID_PT_DEPENDENCY_UP: + decoration += "_PT_DEPENDENCY_UP"; + break; + + case top::topSFSyst::MU_SF_ID_PT_DEPENDENCY_DOWN: + decoration += "_PT_DEPENDENCY_DOWN"; + break; + + case top::topSFSyst::MU_SF_ID_QCD_TEMPLATE_UP: + decoration += "_QCD_TEMPLATE_UP"; + break; + + case top::topSFSyst::MU_SF_ID_QCD_TEMPLATE_DOWN: + decoration += "_QCD_TEMPLATE_DOWN"; + break; + + case top::topSFSyst::MU_SF_ID_SUPRESSION_SCALE_UP: + decoration += "_SUPRESSION_SCALE_UP"; + break; + + case top::topSFSyst::MU_SF_ID_SUPRESSION_SCALE_DOWN: + decoration += "_SUPRESSION_SCALE_DOWN"; + break; + + case top::topSFSyst::MU_SF_ID_SYS_UP: + decoration += "_SYS_UP"; + break; + + case top::topSFSyst::MU_SF_ID_SYS_DOWN: + decoration += "_SYS_DOWN"; + break; + + case top::topSFSyst::MU_SF_ID_TRUTH_UP: + decoration += "_TRUTH_UP"; + break; + + case top::topSFSyst::MU_SF_ID_TRUTH_DOWN: + decoration += "_TRUTH_DOWN"; + break; + + case top::topSFSyst::MU_SF_ID_TRUTH_LOWPT_UP: + decoration += "_TRUTH_LOWPT_UP"; + break; + + case top::topSFSyst::MU_SF_ID_TRUTH_LOWPT_DOWN: + decoration += "_TRUTH_LOWPT_DOWN"; + break; + + case top::topSFSyst::MU_SF_ID_BAD_MUON_VETO_UP: + decoration += "_BAD_MUON_VETO_UP"; + break; + + case top::topSFSyst::MU_SF_ID_BAD_MUON_VETO_DOWN: + decoration += "_BAD_MUON_VETO_DOWN"; + break; + default: // Do nothing, we have the decoration already break; } if (!x.isAvailable(decoration)) { + ATH_MSG_INFO("Muon is not decorated with requested ID SF: " << decoration << ". 1.0 will be returned."); return 1.0; } else { return x.auxdataConst(decoration); @@ -1029,13 +1133,53 @@ namespace top { decoration += "_SYST_DOWN"; break; + case top::topSFSyst::MU_SF_TTVA_LUMI_UNCERT_UP: + decoration += "_LUMI_UNCERT_UP"; + break; + + case top::topSFSyst::MU_SF_TTVA_LUMI_UNCERT_DOWN: + decoration += "_LUMI_UNCERT_DOWN"; + break; + + case top::topSFSyst::MU_SF_TTVA_BKG_FRACTION_UP: + decoration += "_BKG_FRACTION_UP"; + break; + + case top::topSFSyst::MU_SF_TTVA_BKG_FRACTION_DOWN: + decoration += "_BKG_FRACTION_DOWN"; + break; + + case top::topSFSyst::MU_SF_TTVA_MC_XSEC_UP: + decoration += "_MC_XSEC_UP"; + break; + + case top::topSFSyst::MU_SF_TTVA_MC_XSEC_DOWN: + decoration += "_MC_XSEC_DOWN"; + break; + + case top::topSFSyst::MU_SF_TTVA_QCD_TEMPLATE_UP: + decoration += "_QCD_TEMPLATE_UP"; + break; + + case top::topSFSyst::MU_SF_TTVA_QCD_TEMPLATE_DOWN: + decoration += "_QCD_TEMPLATE_DOWN"; + break; + + case top::topSFSyst::MU_SF_TTVA_SUPRESSION_SCALE_UP: + decoration += "_SUPRESSION_SCALE_UP"; + break; + + case top::topSFSyst::MU_SF_TTVA_SUPRESSION_SCALE_DOWN: + decoration += "_SUPRESSION_SCALE_DOWN"; + break; + default: // Do nothing, we have the decoration already break; } if (!(x.isAvailable(decoration))) { - ATH_MSG_INFO("Muon is not decorated with requested TTVA SF. 1.0 will be returned."); + ATH_MSG_INFO("Muon is not decorated with requested TTVA SF: " << decoration << ". 1.0 will be returned."); return 1.0; } diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/TopCorrections/MuonScaleFactorCalculator.h b/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/TopCorrections/MuonScaleFactorCalculator.h index e0ef1594aaf8cb41924ad768d9ab124809bde35e..3aaa0a3c2eebef37a7a9ed02f7ddc04a3cf67927 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/TopCorrections/MuonScaleFactorCalculator.h +++ b/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/TopCorrections/MuonScaleFactorCalculator.h @@ -165,6 +165,7 @@ namespace top { ToolHandle m_muonEfficiencyCorrectionsToolIso; ToolHandle m_muonEfficiencyCorrectionsToolLooseIso; ToolHandle m_muonEfficiencyCorrectionsToolTTVA; + ToolHandle m_muonEfficiencyCorrectionsToolBadMuonVeto; std::string m_decor_triggerEff; std::string m_decor_triggerEff_loose; @@ -190,11 +191,39 @@ namespace top { CP::SystematicSet m_reco_stat_DOWN; CP::SystematicSet m_reco_syst_UP; CP::SystematicSet m_reco_syst_DOWN; + + CP::SystematicSet m_reco_bkg_fraction_UP; + CP::SystematicSet m_reco_bkg_fraction_DOWN; + CP::SystematicSet m_reco_fit_model_lowpt_UP; + CP::SystematicSet m_reco_fit_model_lowpt_DOWN; + CP::SystematicSet m_reco_lumi_uncert_UP; + CP::SystematicSet m_reco_lumi_uncert_DOWN; + CP::SystematicSet m_reco_matching_UP; + CP::SystematicSet m_reco_matching_DOWN; + CP::SystematicSet m_reco_matching_lowpt_UP; + CP::SystematicSet m_reco_matching_lowpt_DOWN; + CP::SystematicSet m_reco_mc_xsec_UP; + CP::SystematicSet m_reco_mc_xsec_DOWN; + CP::SystematicSet m_reco_pt_dependency_UP; + CP::SystematicSet m_reco_pt_dependency_DOWN; + CP::SystematicSet m_reco_qcd_template_UP; + CP::SystematicSet m_reco_qcd_template_DOWN; + CP::SystematicSet m_reco_supression_scale_UP; + CP::SystematicSet m_reco_supression_scale_DOWN; + CP::SystematicSet m_reco_sys_UP; + CP::SystematicSet m_reco_sys_DOWN; + CP::SystematicSet m_reco_truth_UP; + CP::SystematicSet m_reco_truth_DOWN; + CP::SystematicSet m_reco_truth_lowpt_UP; + CP::SystematicSet m_reco_truth_lowpt_DOWN; CP::SystematicSet m_reco_stat_lowpt_UP; CP::SystematicSet m_reco_stat_lowpt_DOWN; CP::SystematicSet m_reco_syst_lowpt_UP; CP::SystematicSet m_reco_syst_lowpt_DOWN; + + CP::SystematicSet m_reco_bad_muon_veto_UP; + CP::SystematicSet m_reco_bad_muon_veto_DOWN; CP::SystematicSet m_iso_stat_UP; CP::SystematicSet m_iso_stat_DOWN; @@ -206,6 +235,17 @@ namespace top { CP::SystematicSet m_TTVA_syst_UP; CP::SystematicSet m_TTVA_syst_DOWN; + CP::SystematicSet m_TTVA_bkg_fraction_UP; + CP::SystematicSet m_TTVA_bkg_fraction_DOWN; + CP::SystematicSet m_TTVA_lumi_uncert_UP; + CP::SystematicSet m_TTVA_lumi_uncert_DOWN; + CP::SystematicSet m_TTVA_mc_xsec_UP; + CP::SystematicSet m_TTVA_mc_xsec_DOWN; + CP::SystematicSet m_TTVA_qcd_template_UP; + CP::SystematicSet m_TTVA_qcd_template_DOWN; + CP::SystematicSet m_TTVA_supression_scale_UP; + CP::SystematicSet m_TTVA_supression_scale_DOWN; + std::string m_muon_trigger_sf_config = ""; }; } // namespace top diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/TopCorrections/ScaleFactorRetriever.h b/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/TopCorrections/ScaleFactorRetriever.h index 09cf432f63db77e4691b62cc2cae0a8248163027..47926bd6521b86b742a74a7af8dc6e46d4db26e3 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/TopCorrections/ScaleFactorRetriever.h +++ b/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/TopCorrections/ScaleFactorRetriever.h @@ -55,6 +55,25 @@ namespace top { // Muon TTVA SFs MU_SF_TTVA_STAT_UP, MU_SF_TTVA_STAT_DOWN, MU_SF_TTVA_SYST_UP, MU_SF_TTVA_SYST_DOWN, + // For more complex systematics + MU_SF_ID_BKG_FRACTION_UP, MU_SF_ID_BKG_FRACTION_DOWN, + MU_SF_ID_FIT_MODEL_LOWPT_UP, MU_SF_ID_FIT_MODEL_LOWPT_DOWN, + MU_SF_ID_LUMI_UNCERT_UP, MU_SF_ID_LUMI_UNCERT_DOWN, + MU_SF_ID_MATCHING_UP, MU_SF_ID_MATCHING_DOWN, + MU_SF_ID_MATCHING_LOWPT_UP, MU_SF_ID_MATCHING_LOWPT_DOWN, + MU_SF_ID_MC_XSEC_UP, MU_SF_ID_MC_XSEC_DOWN, + MU_SF_ID_PT_DEPENDENCY_UP, MU_SF_ID_PT_DEPENDENCY_DOWN, + MU_SF_ID_QCD_TEMPLATE_UP, MU_SF_ID_QCD_TEMPLATE_DOWN, + MU_SF_ID_SUPRESSION_SCALE_UP, MU_SF_ID_SUPRESSION_SCALE_DOWN, + MU_SF_ID_SYS_UP, MU_SF_ID_SYS_DOWN, + MU_SF_ID_TRUTH_UP, MU_SF_ID_TRUTH_DOWN, + MU_SF_ID_TRUTH_LOWPT_UP, MU_SF_ID_TRUTH_LOWPT_DOWN, + MU_SF_ID_BAD_MUON_VETO_UP, MU_SF_ID_BAD_MUON_VETO_DOWN, + MU_SF_TTVA_BKG_FRACTION_UP, MU_SF_TTVA_BKG_FRACTION_DOWN, + MU_SF_TTVA_LUMI_UNCERT_UP, MU_SF_TTVA_LUMI_UNCERT_DOWN, + MU_SF_TTVA_MC_XSEC_UP, MU_SF_TTVA_MC_XSEC_DOWN, + MU_SF_TTVA_QCD_TEMPLATE_UP, MU_SF_TTVA_QCD_TEMPLATE_DOWN, + MU_SF_TTVA_SUPRESSION_SCALE_UP, MU_SF_TTVA_SUPRESSION_SCALE_DOWN, TAU_SF_NOMINAL, // Tau EleOLR SFs @@ -216,6 +235,9 @@ namespace top { //get vector of systematic variations of electron SFs, var=1 for up, var=-1 for down std::vector electronSFSystVariationVector(const top::Event& event, const top::topSFComp SFComp, int var = 1) const; + //get vector of systematic variations of electron SFs, var=1 for up, var=-1 for down and size of systematic variations + std::vector electronSFSystVariationVector(const top::Event& event, const top::topSFComp SFComp, int var = 1, int size=50) const; + // Obtain the fwd electron SF float fwdElectronSF(const top::Event& event, const top::topSFSyst SFSyst, diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopObjectSelectionTools/Root/TopObjectSelection.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopObjectSelectionTools/Root/TopObjectSelection.cxx index 1a81858504e803b377949ac93ee1aa02c0f8290d..92875f9db1331b929ab439dea10752e58282714e 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopObjectSelectionTools/Root/TopObjectSelection.cxx +++ b/PhysicsAnalysis/TopPhys/xAOD/TopObjectSelectionTools/Root/TopObjectSelection.cxx @@ -74,7 +74,7 @@ namespace top { // (3) Determination of Fakes control regions in MC - expert fakes mode // - if (m_config->useSoftMuons()) { + if (m_config->useSoftMuons() && m_config->useMuons()) { top::check(m_overlapRemovalTool_softMuons_PFjets.retrieve(), "Failed to retrieve overlap removal tool for soft muons - PF jets"); top::check(m_overlapRemovalTool_softMuons_Alljets.retrieve(), "Failed to retrieve overlap removal tool for soft muons - all jets"); }