From c92b58661433b170153a87e5902646182db35e06 Mon Sep 17 00:00:00 2001 From: Oliver Majersky Date: Wed, 30 Mar 2022 12:51:45 +0200 Subject: [PATCH 1/8] Sweep small bugfix for soft muons configuration. --- .../TopPhys/xAOD/TopAnalysis/Root/ObjectLoaderStandardCuts.cxx | 2 +- .../xAOD/TopObjectSelectionTools/Root/TopObjectSelection.cxx | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopAnalysis/Root/ObjectLoaderStandardCuts.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopAnalysis/Root/ObjectLoaderStandardCuts.cxx index 8619fb37131..2ed5dfa3c88 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/TopObjectSelectionTools/Root/TopObjectSelection.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopObjectSelectionTools/Root/TopObjectSelection.cxx index 1a81858504e..92875f9db13 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"); } -- GitLab From 125ad9267a86926547280ed886ef6121e6eecab1 Mon Sep 17 00:00:00 2001 From: Nils Erik Krumnack Date: Mon, 19 Apr 2021 13:50:47 +0000 Subject: [PATCH 2/8] Merge branch '21.2-CustomEID' into '21.2' AT: Adding configurable parameter for testing custom electron ID SF files See merge request atlas/athena!42635 --- .../TopPhys/xAOD/TopAnalysis/util/top-xaod.cxx | 9 +++++++++ .../xAOD/TopCPTools/Root/TopEgammaCPTools.cxx | 16 ++++++++++++++-- .../Root/ConfigurationSettings.cxx | 3 +++ .../xAOD/TopConfiguration/Root/TopConfig.cxx | 2 ++ .../TopConfiguration/TopConfig.h | 11 +++++++++++ 5 files changed, 39 insertions(+), 2 deletions(-) diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopAnalysis/util/top-xaod.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopAnalysis/util/top-xaod.cxx index 640b1fac2a9..63e0bae2805 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 263bd784227..417716f50d5 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/Root/TopEgammaCPTools.cxx +++ b/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/Root/TopEgammaCPTools.cxx @@ -273,6 +273,11 @@ namespace top { 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,8 +322,9 @@ 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 @@ -371,11 +377,15 @@ namespace top { 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->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, @@ -681,6 +691,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"); } diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/ConfigurationSettings.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/ConfigurationSettings.cxx index b7799696a6e..fdbd717e2ed 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/ConfigurationSettings.cxx +++ b/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/ConfigurationSettings.cxx @@ -62,6 +62,9 @@ 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("ElectronEfficiencySystematicModel", diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/TopConfig.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/TopConfig.cxx index c809042558d..282a8b28218 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/TopConfig.cxx +++ b/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/TopConfig.cxx @@ -1161,6 +1161,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"))); diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/TopConfiguration/TopConfig.h b/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/TopConfiguration/TopConfig.h index a5da88b34c4..6ab98ce38ea 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/TopConfiguration/TopConfig.h +++ b/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/TopConfiguration/TopConfig.h @@ -869,6 +869,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) { @@ -2285,6 +2292,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; -- GitLab From db766e8309e92e675703e14065860a9d1cfffae6 Mon Sep 17 00:00:00 2001 From: Nils Erik Krumnack Date: Wed, 19 May 2021 14:07:23 +0000 Subject: [PATCH 3/8] Merge branch '21.2-Merve' into '21.2' AnalysisTop:adding ElectronEfficiencyCorrelationModel "COMBMCTOYS" See merge request atlas/athena!43480 --- .../xAOD/TopCPTools/Root/TopEgammaCPTools.cxx | 109 ++++++- .../TopCPTools/TopCPTools/TopEgammaCPTools.h | 28 ++ .../Root/ConfigurationSettings.cxx | 6 +- .../xAOD/TopConfiguration/Root/TopConfig.cxx | 4 + .../TopConfiguration/ConfigurationSettings.h | 1 + .../TopConfiguration/TopConfig.h | 24 ++ .../Root/ElectronScaleFactorCalculator.cxx | 294 +++++++++++++++++- 7 files changed, 461 insertions(+), 5 deletions(-) diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/Root/TopEgammaCPTools.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/Root/TopEgammaCPTools.cxx index 417716f50d5..24260d47a8f 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/Root/TopEgammaCPTools.cxx +++ b/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/Root/TopEgammaCPTools.cxx @@ -365,20 +365,25 @@ 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 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()); @@ -386,9 +391,12 @@ namespace top { 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()); @@ -396,6 +404,8 @@ namespace top { m_electronEffSFTriggerCorrModel = setupElectronSFToolWithMap(elSFPrefixCorrModel + "TriggerSF", m_electronEffSFTriggerFile, "", electronID, electronIsolation, trigger_string, dataType, + m_config->electronEfficiencySystematicModelNToys(), + m_config->electronEfficiencySystematicModelToySeed(), m_config->electronEfficiencySystematicModel(), m_config->electronEfficiencySystematicModelEtaBinning(), m_config->electronEfficiencySystematicModelEtBinning()); @@ -403,6 +413,8 @@ namespace top { m_electronEffSFTriggerLooseFile, "", electronIDLoose, electronIsolationLoose, trigger_string, dataType, + m_config->electronEfficiencySystematicModelNToys(), + m_config->electronEfficiencySystematicModelToySeed(), m_config->electronEfficiencySystematicModel(), m_config->electronEfficiencySystematicModelEtaBinning(), m_config->electronEfficiencySystematicModelEtBinning()); @@ -410,6 +422,8 @@ namespace top { m_electronEffTriggerCorrModel = setupElectronSFToolWithMap(elSFPrefixCorrModel + "Trigger", m_electronEffTriggerFile, "", electronID, electronIsolation, "Eff_" + trigger_string, dataType, + m_config->electronEfficiencySystematicModelNToys(), + m_config->electronEfficiencySystematicModelToySeed(), m_config->electronEfficiencySystematicModel(), m_config->electronEfficiencySystematicModelEtaBinning(), m_config->electronEfficiencySystematicModelEtBinning()); @@ -417,6 +431,8 @@ namespace top { m_electronEffTriggerLooseFile, "", electronIDLoose, electronIsolationLoose, "Eff_" + trigger_string, dataType, + m_config->electronEfficiencySystematicModelNToys(), + m_config->electronEfficiencySystematicModelToySeed(), m_config->electronEfficiencySystematicModel(), m_config->electronEfficiencySystematicModelEtaBinning(), m_config->electronEfficiencySystematicModelEtBinning()); @@ -432,6 +448,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()); @@ -449,6 +467,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()); @@ -571,13 +591,98 @@ namespace top { bins), "Failed to set correlation model " + binningName + " binning to " + binning); } + 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 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. + if (iso_key == "PLVTight" || iso_key == "PLVLoose") iso_key = ""; + + 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); + + //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); + 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); + } + // 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 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. diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/TopCPTools/TopEgammaCPTools.h b/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/TopCPTools/TopEgammaCPTools.h index 9f0146e73b5..15108f5a94e 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/TopConfiguration/Root/ConfigurationSettings.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/ConfigurationSettings.cxx index fdbd717e2ed..e01d7d87edd 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/ConfigurationSettings.cxx +++ b/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/ConfigurationSettings.cxx @@ -67,8 +67,12 @@ namespace top { "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"); diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/TopConfig.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/TopConfig.cxx index 282a8b28218..7d84fa873c3 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/TopConfig.cxx +++ b/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/TopConfig.cxx @@ -187,6 +187,8 @@ namespace top { // Electron configuration m_egammaSystematicModel("1NP_v1"), m_electronEfficiencySystematicModel("TOTAL"), + m_electronEfficiencySystematicModelNToys(40), + m_electronEfficiencySystematicModelToySeed(12345), m_electronEfficiencySystematicModelEtaBinning(""), m_electronEfficiencySystematicModelEtBinning(""), m_electronID("SetMe"), @@ -1073,6 +1075,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")); { diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/TopConfiguration/ConfigurationSettings.h b/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/TopConfiguration/ConfigurationSettings.h index b84c0b07954..db1f51ac3ae 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 6ab98ce38ea..563c5f937cc 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/TopConfiguration/TopConfig.h +++ b/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/TopConfiguration/TopConfig.h @@ -709,6 +709,20 @@ 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 electronID(const std::string& s) { if (!m_configFixed) { m_electronID = s; @@ -801,6 +815,14 @@ 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 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;} @@ -2271,6 +2293,8 @@ namespace top { // Electron configuration std::string m_egammaSystematicModel; std::string m_electronEfficiencySystematicModel; + int m_electronEfficiencySystematicModelNToys; + int m_electronEfficiencySystematicModelToySeed; std::string m_electronEfficiencySystematicModelEtaBinning; std::string m_electronEfficiencySystematicModelEtBinning; std::string m_electronID; diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/Root/ElectronScaleFactorCalculator.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/Root/ElectronScaleFactorCalculator.cxx index 6f4861284c0..37c72d77142 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 @@ -243,6 +244,68 @@ namespace top { } } + + 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++; + } + 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++; + } + 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_decor_triggerEff = "EL_EFF_Trigger_" + m_config->electronID(); m_decor_triggerEff_loose = "EL_LOOSE_EFF_Trigger_" + m_config->electronIDLoose(); m_decor_triggerSF = "EL_SF_Trigger_" + m_config->electronID(); @@ -640,7 +703,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 +957,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 } -- GitLab From 715b65f74bedc274ecc1a373d6106ca0c483afab Mon Sep 17 00:00:00 2001 From: Nils Erik Krumnack Date: Fri, 21 May 2021 14:27:50 +0000 Subject: [PATCH 4/8] Merge branch '21.2-FixSys' into '21.2' AnalysisTop:fix for empty electronSF variation vectors See merge request atlas/athena!43679 --- .../TopAnalysis/Root/EventSaverFlatNtuple.cxx | 12 +++---- .../xAOD/TopConfiguration/Root/TopConfig.cxx | 3 ++ .../TopConfiguration/TopConfig.h | 34 +++++++++++++++++++ .../Root/ElectronScaleFactorCalculator.cxx | 23 +++++++++++++ .../Root/ScaleFactorRetriever.cxx | 3 +- .../TopCorrections/ScaleFactorRetriever.h | 3 ++ 6 files changed, 71 insertions(+), 7 deletions(-) diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopAnalysis/Root/EventSaverFlatNtuple.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopAnalysis/Root/EventSaverFlatNtuple.cxx index 245d0e61751..d08f2308cd9 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopAnalysis/Root/EventSaverFlatNtuple.cxx +++ b/PhysicsAnalysis/TopPhys/xAOD/TopAnalysis/Root/EventSaverFlatNtuple.cxx @@ -1771,12 +1771,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); diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/TopConfig.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/TopConfig.cxx index 7d84fa873c3..b6fe475259d 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/TopConfig.cxx +++ b/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/TopConfig.cxx @@ -189,6 +189,9 @@ namespace top { 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"), diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/TopConfiguration/TopConfig.h b/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/TopConfiguration/TopConfig.h index 563c5f937cc..c36032e1315 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/TopConfiguration/TopConfig.h +++ b/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/TopConfiguration/TopConfig.h @@ -723,6 +723,23 @@ namespace top { } + 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; @@ -823,6 +840,20 @@ namespace top { 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;} @@ -2295,6 +2326,9 @@ namespace top { 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; diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/Root/ElectronScaleFactorCalculator.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/Root/ElectronScaleFactorCalculator.cxx index 37c72d77142..43b130e1533 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/Root/ElectronScaleFactorCalculator.cxx +++ b/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/Root/ElectronScaleFactorCalculator.cxx @@ -220,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) { @@ -231,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) { @@ -242,6 +251,10 @@ namespace top { "--->electron ISO " << m_config->electronEfficiencySystematicModel() << " component " << (count2++) << " is " << name); } + + m_config->electronEfficiencySystematicModelIsoSize(count2); + + } @@ -288,6 +301,9 @@ namespace top { name); count++; } + m_config->electronEfficiencySystematicModelRecoSize(count); + + count = 0; for (const CP::SystematicSet& isyst : m_systIDCorrModel) { TString name = isyst.name(); @@ -296,6 +312,9 @@ namespace top { name); count++; } + m_config->electronEfficiencySystematicModelIdSize(count); + + count = 0; for (const CP::SystematicSet& isyst : m_systIsoCorrModel) { TString name = isyst.name(); @@ -304,6 +323,10 @@ namespace top { name); count++; } + m_config->electronEfficiencySystematicModelIsoSize(count); + + + } m_decor_triggerEff = "EL_EFF_Trigger_" + m_config->electronID(); diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/Root/ScaleFactorRetriever.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/Root/ScaleFactorRetriever.cxx index 876b61cd82a..1c787ef357b 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; } diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/TopCorrections/ScaleFactorRetriever.h b/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/TopCorrections/ScaleFactorRetriever.h index 09cf432f63d..9332c75eed8 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/TopCorrections/ScaleFactorRetriever.h +++ b/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/TopCorrections/ScaleFactorRetriever.h @@ -216,6 +216,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, -- GitLab From 479e1444f42478bd9b323ad9557a607123122884 Mon Sep 17 00:00:00 2001 From: Nils Erik Krumnack Date: Wed, 22 Sep 2021 17:42:54 +0200 Subject: [PATCH 5/8] Merge branch '21.2-AnalysisTopMuonSFs' into '21.2' AnalysisTop: Adding more complex muon ID and TTVA uncertainty scheme See merge request atlas/athena!46511 --- .../TopAnalysis/Root/EventSaverFlatNtuple.cxx | 206 +++++- .../TopAnalysis/EventSaverFlatNtuple.h | 36 ++ .../xAOD/TopCPTools/Root/TopMuonCPTools.cxx | 30 +- .../TopCPTools/TopCPTools/TopMuonCPTools.h | 3 +- .../Root/ConfigurationSettings.cxx | 8 + .../xAOD/TopConfiguration/Root/TopConfig.cxx | 10 + .../TopConfiguration/TopConfig.h | 12 + .../Root/MuonScaleFactorCalculator.cxx | 588 +++++++++++++++--- .../Root/ScaleFactorRetriever.cxx | 147 ++++- .../MuonScaleFactorCalculator.h | 40 ++ .../TopCorrections/ScaleFactorRetriever.h | 19 + 11 files changed, 969 insertions(+), 130 deletions(-) diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopAnalysis/Root/EventSaverFlatNtuple.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopAnalysis/Root/EventSaverFlatNtuple.cxx index d08f2308cd9..fec74244bfb 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 @@ -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/TopAnalysis/EventSaverFlatNtuple.h b/PhysicsAnalysis/TopPhys/xAOD/TopAnalysis/TopAnalysis/EventSaverFlatNtuple.h index e5cafbb4199..4ce3b8edbbc 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/TopCPTools/Root/TopMuonCPTools.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/Root/TopMuonCPTools.cxx index 9c44cabc99a..9f11816d07f 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/TopMuonCPTools.h b/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/TopCPTools/TopMuonCPTools.h index 95381e9c6d6..a85c0d9bc54 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 e01d7d87edd..209895ffd3a 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/ConfigurationSettings.cxx +++ b/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/ConfigurationSettings.cxx @@ -173,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 b6fe475259d..84422f51865 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/TopConfig.cxx +++ b/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/Root/TopConfig.cxx @@ -236,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.), @@ -1255,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/TopConfig.h b/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/TopConfiguration/TopConfig.h index c36032e1315..e98ecdb8d05 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/TopConfiguration/TopConfig.h +++ b/PhysicsAnalysis/TopPhys/xAOD/TopConfiguration/TopConfiguration/TopConfig.h @@ -1095,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) { @@ -2384,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/MuonScaleFactorCalculator.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/Root/MuonScaleFactorCalculator.cxx index 7f39d8101ef..d65953c3e45 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 1c787ef357b..0af3589f988 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/Root/ScaleFactorRetriever.cxx +++ b/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/Root/ScaleFactorRetriever.cxx @@ -883,12 +883,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); @@ -1030,13 +1135,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 e0ef1594aaf..3aaa0a3c2ee 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 9332c75eed8..47926bd6521 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 -- GitLab From 24b620da4508ee1a43d09c66bb1b2627b69204c0 Mon Sep 17 00:00:00 2001 From: Nils Erik Krumnack Date: Fri, 19 Nov 2021 17:17:11 +0100 Subject: [PATCH 6/8] Merge branch '21.2-AnalysisTop-ElectronChargeMisIDSF' into '21.2' AnalysisTop: Do not setup the ChargeMisID tool when unsupported WPs are requested See merge request atlas/athena!48267 --- .../xAOD/TopCPTools/Root/TopEgammaCPTools.cxx | 37 ++++++++++--------- .../Root/ScaleFactorRetriever.cxx | 6 +-- 2 files changed, 22 insertions(+), 21 deletions(-) diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/Root/TopEgammaCPTools.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/Root/TopEgammaCPTools.cxx index 24260d47a8f..fbf33047071 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/Root/TopEgammaCPTools.cxx +++ b/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/Root/TopEgammaCPTools.cxx @@ -495,10 +495,10 @@ 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 + && electronIsolation != "PLVTight" + && electronIsolation != "PLVLoose" + && electronIsolationLoose != "PLVTight" + && electronIsolationLoose != "PLVLoose" ) { // We need to update the implementation according to new // recommendations ATH_MSG_INFO("Setting up Electrons ChargeID SF tool"); // Charge ID file (no maps) @@ -517,19 +517,22 @@ 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" && + electronIsolationLoose != "PLVTight" && electronIsolationLoose != "PLVLoose") { + // 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"); + } return StatusCode::SUCCESS; } diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/Root/ScaleFactorRetriever.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/Root/ScaleFactorRetriever.cxx index 0af3589f988..e35aa18cf85 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/Root/ScaleFactorRetriever.cxx +++ b/PhysicsAnalysis/TopPhys/xAOD/TopCorrections/Root/ScaleFactorRetriever.cxx @@ -338,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 -- GitLab From d7039802d514b4fc774faaa90d15710c18252ce7 Mon Sep 17 00:00:00 2001 From: Nils Erik Krumnack Date: Fri, 3 Dec 2021 21:31:06 +0100 Subject: [PATCH 7/8] Merge branch '21.2-electronPLIVscaleFactors' into '21.2' AnalysisTop: Adding preliminary support for electron PLIV SFs See merge request atlas/athena!48722 --- .../xAOD/TopCPTools/Root/TopEgammaCPTools.cxx | 67 ++++++++++++++----- 1 file changed, 51 insertions(+), 16 deletions(-) diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/Root/TopEgammaCPTools.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/Root/TopEgammaCPTools.cxx index fbf33047071..d6bbbbe940c 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,6 +269,22 @@ namespace top { // hopefully remove the map soon! std::string electronIsolationLoose = mapWorkingPoints(m_config->electronIsolationSFLoose()); + if(electronIsolation == "PLImprovedTight" || electronIsolation == "PLImprovedVeryTight" || electronIsolationLoose == "PLImprovedTight" || electronIsolationLoose == "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(!(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(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 @@ -329,18 +345,23 @@ namespace top { 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" || @@ -403,7 +424,8 @@ namespace top { // 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(), @@ -411,7 +433,8 @@ namespace top { 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(), @@ -421,7 +444,8 @@ namespace top { // 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(), @@ -429,7 +453,8 @@ namespace top { 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(), @@ -518,7 +543,9 @@ namespace top { m_electronEffSFChargeIDLoose = setupElectronSFTool(elSFPrefix + "ChargeIDLoose", inChargeIDLoose, dataType); } if (electronIsolation != "PLVTight" && electronIsolation != "PLVLoose" && - electronIsolationLoose != "PLVTight" && electronIsolationLoose != "PLVLoose") { + electronIsolationLoose != "PLVTight" && electronIsolationLoose != "PLVLoose" && + electronIsolation != "PLImprovedTight" && electronIsolation != "PLImprovedVeryTight" && + electronIsolationLoose != "PLImprovedTight" && electronIsolation != "PLImprovedVeryTight") { // Charge flip correction: https://twiki.cern.ch/twiki/bin/view/AtlasProtected/EgammaChargeMisIdentificationTool CP::ElectronChargeEfficiencyCorrectionTool* ChargeMisIDCorrections = new CP::ElectronChargeEfficiencyCorrectionTool( "ElectronChargeEfficiencyCorrection"); @@ -742,7 +769,10 @@ IAsgElectronEfficiencyCorrectionTool* 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; @@ -758,12 +788,13 @@ IAsgElectronEfficiencyCorrectionTool* 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") @@ -791,7 +822,11 @@ IAsgElectronEfficiencyCorrectionTool* 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."); @@ -854,7 +889,7 @@ IAsgElectronEfficiencyCorrectionTool* 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; } -- GitLab From 1381351c177daa32aa3fc3f7c19b9b702c0b5901 Mon Sep 17 00:00:00 2001 From: Nils Erik Krumnack Date: Wed, 29 Dec 2021 16:18:04 +0100 Subject: [PATCH 8/8] Merge branch '21.2-AT-PLIVcheck' into '21.2' Fixing some problems in the setup of the ElectronEfficiencyCorrectionTool for PLIV WPs See merge request atlas/athena!49349 --- .../xAOD/TopCPTools/Root/TopEgammaCPTools.cxx | 50 +++++++++++-------- 1 file changed, 28 insertions(+), 22 deletions(-) diff --git a/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/Root/TopEgammaCPTools.cxx b/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/Root/TopEgammaCPTools.cxx index d6bbbbe940c..618e7c142bc 100644 --- a/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/Root/TopEgammaCPTools.cxx +++ b/PhysicsAnalysis/TopPhys/xAOD/TopCPTools/Root/TopEgammaCPTools.cxx @@ -269,15 +269,19 @@ namespace top { // hopefully remove the map soon! std::string electronIsolationLoose = mapWorkingPoints(m_config->electronIsolationSFLoose()); - if(electronIsolation == "PLImprovedTight" || electronIsolation == "PLImprovedVeryTight" || electronIsolationLoose == "PLImprovedTight" || electronIsolationLoose == "PLImprovedVeryTight"){ + 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; @@ -520,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); @@ -542,25 +546,20 @@ namespace top { m_electronEffSFChargeID = setupElectronSFTool(elSFPrefix + "ChargeID", inChargeID, dataType); m_electronEffSFChargeIDLoose = setupElectronSFTool(elSFPrefix + "ChargeIDLoose", inChargeIDLoose, dataType); } - if (electronIsolation != "PLVTight" && electronIsolation != "PLVLoose" && - electronIsolationLoose != "PLVTight" && electronIsolationLoose != "PLVLoose" && - electronIsolation != "PLImprovedTight" && electronIsolation != "PLImprovedVeryTight" && - electronIsolationLoose != "PLImprovedTight" && electronIsolation != "PLImprovedVeryTight") { - // 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"); + if(electronIsolation != "PLVTight" && electronIsolation != "PLVLoose" && + electronIsolation != "PLImprovedTight" && electronIsolation != "PLImprovedVeryTight"){ + CP::ElectronChargeEfficiencyCorrectionTool* ChargeMisIDCorrections = new CP::ElectronChargeEfficiencyCorrectionTool("ElectronChargeEfficiencyCorrection"); 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->setProperty("CorrectionFileName", m_electronEffSFChargeMisIDFile), "Failed to setProperty"); top::check(ChargeMisIDCorrections->initialize(), "Failed to setProperty"); - top::check(ChargeMisIDCorrectionsLoose->setProperty("CorrectionFileName", - m_electronEffSFChargeMisIDLooseFile), "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; } @@ -585,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); } } @@ -718,6 +719,11 @@ IAsgElectronEfficiencyCorrectionTool* // 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) + @@ -761,7 +767,7 @@ IAsgElectronEfficiencyCorrectionTool* ATH_MSG_INFO(" Adding TriggerKey : " + trigger_key); top::check(asg::setProperty(tool, "TriggerKey", trigger_key), "Failed to set TriggerKey to " + name); } - // Initialise this tool + top::check(asg::setProperty(tool, "OutputLevel", MSG::INFO), "Failed to set OutputLevel to " + name); top::check(tool->initialize(), "Failed to initialize " + name); } return tool; -- GitLab