ATLAS Offline Software
SUSYToolsInit.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "SUSYTools/SUSYObjDef_xAOD.h"
6 
7 // For making the systematics list and looping through it
8 #include "PATInterfaces/SystematicsUtil.h"
9 #include "PATInterfaces/SystematicRegistry.h"
10 
11 // For the data types to be used in configuring tools
12 #include "PATCore/PATCoreEnums.h"
13 
14 // For the tau tool initialization
15 #include "TauAnalysisTools/Enums.h"
16 
17 // For the struct needed for OR init
18 #include "AssociationUtils/OverlapRemovalInit.h"
19 
20 // Abstract interface classes
21 #include "FTagAnalysisInterfaces/IBTaggingEfficiencyTool.h"
22 #include "FTagAnalysisInterfaces/IBTaggingSelectionTool.h"
23 
24 #include "JetInterface/IJetSelector.h"
25 #include "JetCalibTools/IJetCalibrationTool.h"
26 #include "JetCPInterfaces/ICPJetUncertaintiesTool.h"
27 #include "JetInterface/IJetUpdateJvt.h"
28 #include "JetInterface/IJetModifier.h"
29 #include "JetInterface/IJetDecorator.h"
30 
31 #include "AsgAnalysisInterfaces/IEfficiencyScaleFactorTool.h"
32 #include "EgammaAnalysisInterfaces/IEgammaCalibrationAndSmearingTool.h"
33 #include "EgammaAnalysisInterfaces/IAsgElectronEfficiencyCorrectionTool.h"
34 #include "EgammaAnalysisInterfaces/IAsgElectronIsEMSelector.h"
35 #include "EgammaAnalysisInterfaces/IAsgElectronLikelihoodTool.h"
36 #include "EgammaAnalysisInterfaces/IAsgDeadHVCellRemovalTool.h"
37 #include "EgammaAnalysisInterfaces/IEGammaAmbiguityTool.h"
38 #include "EgammaAnalysisInterfaces/IAsgPhotonEfficiencyCorrectionTool.h"
39 #include "EgammaAnalysisInterfaces/IAsgPhotonIsEMSelector.h"
40 #include "EgammaAnalysisInterfaces/IElectronLRTOverlapRemovalTool.h"
41 
42 #include "MuonAnalysisInterfaces/IMuonSelectionTool.h"
43 #include "MuonAnalysisInterfaces/IMuonCalibrationAndSmearingTool.h"
44 #include "MuonAnalysisInterfaces/IMuonEfficiencyScaleFactors.h"
45 #include "MuonAnalysisInterfaces/IMuonTriggerScaleFactors.h"
46 #include "MuonAnalysisInterfaces/IMuonLRTOverlapRemovalTool.h"
47 
48 #include "TauAnalysisTools/ITauSelectionTool.h"
49 #include "TauAnalysisTools/ITauSmearingTool.h"
50 #include "TauAnalysisTools/ITauTruthMatchingTool.h"
51 #include "TauAnalysisTools/ITauEfficiencyCorrectionsTool.h"
52 #include "tauRecTools/ITauToolBase.h"
53 
54 #include "IsolationSelection/IIsolationSelectionTool.h"
55 //disable #include "IsolationSelection/IIsolationLowPtPLVTool.h"
56 #include "IsolationCorrections/IIsolationCorrectionTool.h"
57 #include "IsolationSelection/IIsolationCloseByCorrectionTool.h"
58 
59 #include "METInterface/IMETMaker.h"
60 #include "METInterface/IMETSystematicsTool.h"
61 #include "METInterface/IMETSignificance.h"
62 
63 #include "TrigConfInterfaces/ITrigConfigTool.h"
64 #include "TriggerMatchingTool/IMatchingTool.h"
65 #include "TriggerMatchingTool/IMatchScoringTool.h"
66 #include "TriggerAnalysisInterfaces/ITrigGlobalEfficiencyCorrectionTool.h"
67 // Can't use the abstract interface for this one (see header comment)
68 #include "TrigDecisionTool/TrigDecisionTool.h"
69 
70 #include "PATInterfaces/IWeightTool.h"
71 #include "AsgAnalysisInterfaces/IPileupReweightingTool.h"
72 #include "PathResolver/PathResolver.h"
73 #include "AssociationUtils/IOverlapRemovalTool.h"
74 #include "BoostedJetTaggers/SmoothedWZTagger.h"
75 #include "BoostedJetTaggers/JSSWTopTaggerDNN.h"
76 #include "ParticleJetTools/JetTruthLabelingTool.h"
77 
78 #include "InDetTrackSystematicsTools/IInclusiveTrackFilterTool.h"
79 
80 #ifndef XAOD_STANDALONE
81 #include "AthAnalysisBaseComps/AthAnalysisHelper.h"
82 #endif
83 
84 using namespace ST;
85 
86 
87 
88 #define CONFIG_EG_EFF_TOOL( TOOLHANDLE, TOOLNAME, CORRFILE ) \
89  if( !TOOLHANDLE.isUserConfigured() ) { \
90  TOOLHANDLE.setTypeAndName("AsgElectronEfficiencyCorrectionTool/"+TOOLNAME); \
91  std::vector< std::string > corrFileNameList = {CORRFILE}; \
92  ATH_CHECK( TOOLHANDLE.setProperty("CorrectionFileNameList", corrFileNameList) ); \
93  if(!isData()) \
94  ATH_CHECK (TOOLHANDLE.setProperty("ForceDataType", static_cast<int>(data_type))); \
95  ATH_CHECK( TOOLHANDLE.setProperty("CorrelationModel", m_EG_corrModel) ); \
96  ATH_CHECK( TOOLHANDLE.setProperty("OutputLevel", this->msg().level()) ); \
97  ATH_CHECK( TOOLHANDLE.initialize() ); \
98  } else ATH_CHECK(TOOLHANDLE.retrieve());
99 
100 #define CONFIG_EG_EFF_TOOL_KEY( TOOLHANDLE, TOOLNAME, KEYNAME, KEY, MAP ) \
101  if( !TOOLHANDLE.isUserConfigured() ) { \
102  TOOLHANDLE.setTypeAndName("AsgElectronEfficiencyCorrectionTool/"+TOOLNAME); \
103  ATH_MSG_INFO( "Will now set key \"" << KEYNAME << "\" to value \"" << KEY << "\" when configuring an AsgElectronEfficiencyCorrectionTool" ); \
104  ATH_CHECK( TOOLHANDLE.setProperty(KEYNAME, KEY) ); \
105  if(!isData()) \
106  ATH_CHECK (TOOLHANDLE.setProperty("ForceDataType", static_cast<int>(data_type))); \
107  ATH_CHECK( TOOLHANDLE.setProperty("CorrelationModel", m_EG_corrModel) ); \
108  ATH_CHECK( TOOLHANDLE.setProperty("OutputLevel", this->msg().level()) ); \
109  ATH_CHECK( TOOLHANDLE.setProperty("MapFilePath", MAP) ); \
110  ATH_CHECK( TOOLHANDLE.initialize() ); \
111  } else if (!isData()) ATH_CHECK(TOOLHANDLE.retrieve());
112 
113 StatusCode SUSYObjDef_xAOD::SUSYToolsInit()
114 {
115  if (m_dataSource < 0) {
116  ATH_MSG_FATAL("Data source incorrectly configured!!");
117  ATH_MSG_FATAL("You must set the DataSource property to Data, FullSim or AtlfastII !!");
118  ATH_MSG_FATAL("Expect segfaults if you're not checking status codes, which you should be !!");
119  return StatusCode::FAILURE;
120  }
121 
122  if (m_subtool_init) {
123  ATH_MSG_INFO("SUSYTools subtools already created. Ignoring this call.");
124  ATH_MSG_INFO("Note: No longer necessary to explicitly call SUSYToolsInit. Will avoid creating tools again.");
125  return StatusCode::SUCCESS;
126  }
127 
128  // /////////////////////////////////////////////////////////////////////////////////////////
129  // Initialise PileupReweighting Tool
130 
131  if (!m_prwTool.isUserConfigured()) {
132  ATH_MSG_DEBUG("Will now init the PRW tool");
133  std::vector<std::string> file_conf;
134  for (UInt_t i = 0; i < m_prwConfFiles.size(); i++) {
135  ATH_MSG_INFO("Adding PRW file: " << m_prwConfFiles.at(i));
136  file_conf.push_back(m_prwConfFiles.at(i));
137  }
138 
139  std::vector<std::string> file_ilumi;
140  for (UInt_t i = 0; i < m_prwLcalcFiles.size(); i++) {
141  ATH_MSG_INFO("Adding ilumicalc file: " << m_prwLcalcFiles.at(i));
142  file_ilumi.push_back(m_prwLcalcFiles.at(i));
143  }
144 
145  m_prwTool.setTypeAndName("CP::PileupReweightingTool/PrwTool");
146  ATH_CHECK( m_prwTool.setProperty("ConfigFiles", file_conf) );
147  ATH_CHECK( m_prwTool.setProperty("LumiCalcFiles", file_ilumi) );
148  ATH_CHECK( m_prwTool.setProperty("DataScaleFactor", m_prwDataSF) ); // 1./1.03 -> default for mc16, see: https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/ExtendedPileupReweighting#Tool_Properties
149  ATH_CHECK( m_prwTool.setProperty("DataScaleFactorUP", m_prwDataSF_UP) ); // 1. -> old value (mc15), as the one for mc16 is still missing
150  ATH_CHECK( m_prwTool.setProperty("DataScaleFactorDOWN", m_prwDataSF_DW) ); // 1./1.18 -> old value (mc15), as the one for mc16 is still missing
151  ATH_CHECK( m_prwTool.setProperty("TrigDecisionTool", m_trigDecTool.getHandle()) );
152  ATH_CHECK( m_prwTool.setProperty("UseRunDependentPrescaleWeight", m_runDepPrescaleWeightPRW) );
153  ATH_CHECK( m_prwTool.setProperty("OutputLevel", MSG::WARNING) );
154  ATH_CHECK( m_prwTool.retrieve() );
155  } else {
156  ATH_MSG_INFO("Using user-configured PRW tool");
157  ATH_CHECK( m_prwTool.retrieve() );
158  }
159 
161  // Initialize LRT systematics tool
162  if (!m_LRTuncTool.isUserConfigured() && !isData())
163  {
164  ATH_MSG_INFO("Initializing LRT uncertainty tool");
165  m_LRTuncTool.setTypeAndName("InDet::InclusiveTrackFilterTool/LRTUncTool");
166  ATH_CHECK( m_LRTuncTool.setProperty("Seed", 1) );
167  if (m_isRun3) {
168  if (m_mcCampaign == "mc23d" || m_mcCampaign == "mc23e")
169  ATH_MSG_WARNING("Please note that current ID recommendations only cover mc23a and not (yet) mc23d/e!");
170  ATH_CHECK( m_LRTuncTool.setProperty("calibFileLRTEff", "InDetTrackSystematicsTools/CalibData_25.2_2025-v00/LargeD0TrackingRecommendations_mc23a.root") );
171  }
172  else
173  ATH_CHECK( m_LRTuncTool.setProperty("calibFileLRTEff", "InDetTrackSystematicsTools/CalibData_24.0_2023-v00/LargeD0TrackingRecommendations_20230824.root") );
174  ATH_CHECK(m_LRTuncTool.retrieve());
175  } else {
176  ATH_MSG_INFO("Using user-configured LRT uncertainty tool");
177  ATH_CHECK(m_LRTuncTool.retrieve());
178  }
179 
180  std::string toolName; // to be used for tool init below, keeping explicit string constants a minimum /CO
181 
182  std::string jetname,jetcoll,fatjetcoll;
183  if (m_slices["jet"]) {
185  // Initialise jet calibration tool
186 
187  // pick the right config file for the JES tool : https://twiki.cern.ch/twiki/bin/view/AtlasProtected/ApplyJetCalibrationR22
188  jetname = "AntiKt4" + xAOD::JetInput::typeName(xAOD::JetInput::Type(m_jetInputType));
189  jetcoll = jetname + "Jets";
190 
191  if (!m_jetCalibTool.isUserConfigured()) {
192  toolName = "JetCalibTool_" + jetname;
193  m_jetCalibTool.setTypeAndName("JetCalibrationTool/"+toolName);
194  std::string JES_config_file, calibseq;
195 
196  if (m_jetInputType != xAOD::JetInput::EMPFlow) {
197  ATH_MSG_ERROR("Unknown (unsupported) jet collection is used, (m_jetInputType = " << m_jetInputType << ")");
198  return StatusCode::FAILURE;
199  }
200 
201  std::string JESconfig = isAtlfast() ? m_jesConfigAFII : m_jesConfig;
202  if(isAtlfast() && m_isRun3) {
203  ATH_MSG_WARNING("Jet JES/JER recommendations currently not available for fast sim in Run 3, falling back to full sim version");
204  JESconfig = m_jesConfig;
205  }
206 
207  calibseq = m_jesCalibSeq;
208  JES_config_file = JESconfig;
209 
210  // remove Insitu if it's in the string if not data
211  if (!isData()) {
212  std::string insitu("_Insitu");
213  auto found = calibseq.find(insitu);
214  if(found != std::string::npos){
215  calibseq.erase(found, insitu.length());
216  }
217  }
218 
219  // JMS calibration (if requested)
220  if (m_JMScalib){
221  ATH_MSG_ERROR("JMS calibration is not supported yet for R22. Please modify your settings.");
222  return StatusCode::FAILURE;
223  }
224 
225  // now instantiate the tool
226  ATH_CHECK( m_jetCalibTool.setProperty("JetCollection", jetname) );
227  ATH_CHECK( m_jetCalibTool.setProperty("ConfigFile", JES_config_file) );
228  ATH_CHECK( m_jetCalibTool.setProperty("CalibSequence", calibseq) );
229  ATH_CHECK( m_jetCalibTool.setProperty("CalibArea", m_jesCalibArea) );
230  ATH_CHECK( m_jetCalibTool.setProperty("IsData", isData()) );
231  ATH_CHECK( m_jetCalibTool.setProperty("OutputLevel", this->msg().level()) );
232  ATH_CHECK( m_jetCalibTool.retrieve() );
233  } else ATH_CHECK(m_jetCalibTool.retrieve());
234  }
235 
236  if (m_slices["fjet"]) {
237  //same for fat groomed jets
238  fatjetcoll = m_fatJets;
239 
240  if(fatjetcoll == "AnalysisLargeRJets") {
241  ATH_MSG_DEBUG("Fall back to calibration for AntiKt10UFOCSSKSoftDropBeta100Zcut10Jets, original name for AnalysisLargeRJets");
242  fatjetcoll = "AntiKt10UFOCSSKSoftDropBeta100Zcut10Jets";
243  }
244  if (fatjetcoll.size()>3)fatjetcoll.erase(fatjetcoll.size()-4,4);
245  if (!m_jetFatCalibTool.isUserConfigured() && !m_fatJets.empty()) {
246  toolName = "JetFatCalibTool_" + m_fatJets;
247  m_jetFatCalibTool.setTypeAndName("JetCalibrationTool/"+toolName);
248 
249  std::string jesConfigFat = m_jesConfigFat;
250  std::string jesCalibSeqFat = m_jesCalibSeqFat;
251  // add Insitu if data
252  if(isData()) jesCalibSeqFat += "_Insitu";
253 
254  // now instantiate the tool
255  ATH_CHECK( m_jetFatCalibTool.setProperty("JetCollection", fatjetcoll) );
256  ATH_CHECK( m_jetFatCalibTool.setProperty("ConfigFile", jesConfigFat) );
257  ATH_CHECK( m_jetFatCalibTool.setProperty("CalibSequence", jesCalibSeqFat) );
258  // always set to false : https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/ApplyJetCalibrationR21
259  ATH_CHECK( m_jetFatCalibTool.setProperty("IsData", isData()) );
260  ATH_CHECK( m_jetFatCalibTool.setProperty("OutputLevel", this->msg().level()) );
261  ATH_CHECK( m_jetFatCalibTool.retrieve() );
262  } else if (m_jetFatCalibTool.isUserConfigured()) ATH_CHECK(m_jetFatCalibTool.retrieve());
263  }
264 
265  if (m_slices["fjet"]) {
267  // Initialise Boson taggers: https://twiki.cern.ch/twiki/bin/view/AtlasProtected/BoostedJetTaggingRecommendationFullRun2#Higgs_taggers
268  if (!m_WTaggerTool.isUserConfigured() && !m_WtagConfig.empty()) {
269  m_WTaggerTool.setTypeAndName("SmoothedWZTagger/WTagger");
270  ATH_CHECK( m_WTaggerTool.setProperty("ContainerName", m_fatJets) );
271  ATH_CHECK( m_WTaggerTool.setProperty("ConfigFile", m_WtagConfig) );
272  ATH_CHECK( m_WTaggerTool.setProperty("CalibArea", m_WZTaggerCalibArea) );
273  ATH_CHECK( m_WTaggerTool.setProperty("IsMC",!isData()));
274  ATH_CHECK( m_WTaggerTool.setProperty("TruthBosonContainerName", "TruthBoson") ); // Set this if you are using a TRUTH3 style truth boson container;
275  ATH_CHECK( m_WTaggerTool.setProperty("TruthTopQuarkContainerName", "TruthTop") ); // Set this if you are using a TRUTH3 style truth boson container;
276 #ifndef XAOD_STANDALONE
277  ATH_CHECK( m_WTaggerTool.setProperty("SuppressOutputDependence", true) );
278 #endif
279  ATH_CHECK( m_WTaggerTool.setProperty("OutputLevel", this->msg().level()) );
280  ATH_CHECK( m_WTaggerTool.retrieve() );
281 
282  // Retrieving DecorationName (needed to access tagging results downstream):
283  std::string WConfigPath = PathResolverFindCalibFile("BoostedJetTaggers/"+m_WZTaggerCalibArea+"/"+m_WtagConfig);
284  if ( m_WconfigReader.ReadFile( WConfigPath.c_str(), EEnvLevel(0) ) ) {
285  ATH_MSG_ERROR( "Error while reading large-R config file : " << WConfigPath );
286  return StatusCode::FAILURE;
287  }
288  else ATH_MSG_DEBUG( "Successfully read large-R config file : " << WConfigPath );
289 
290  m_WDecorName = m_WconfigReader.GetValue("DecorationName" ,"");
291  ANA_MSG_DEBUG( "Found DecorationName in large-R config file : " << m_WDecorName );
292 
293  } else if (m_WTaggerTool.isUserConfigured()) ATH_CHECK(m_WTaggerTool.retrieve());
294 
295  if (!m_ZTaggerTool.isUserConfigured() && !m_ZtagConfig.empty()) {
296  m_ZTaggerTool.setTypeAndName("SmoothedWZTagger/ZTagger");
297  ATH_CHECK( m_ZTaggerTool.setProperty("ContainerName", m_fatJets) );
298  ATH_CHECK( m_ZTaggerTool.setProperty("ConfigFile", m_ZtagConfig) );
299  ATH_CHECK( m_ZTaggerTool.setProperty("CalibArea", m_WZTaggerCalibArea) );
300  ATH_CHECK( m_ZTaggerTool.setProperty("IsMC",!isData()));
301  ATH_CHECK( m_ZTaggerTool.setProperty("TruthBosonContainerName", "TruthBoson") ); // Set this if you are using a TRUTH3 style truth boson container;
302  ATH_CHECK( m_ZTaggerTool.setProperty("TruthTopQuarkContainerName", "TruthTop") ); // Set this if you are using a TRUTH3 style truth boson container;
303 #ifndef XAOD_STANDALONE
304  ATH_CHECK( m_ZTaggerTool.setProperty("SuppressOutputDependence", true) );
305 #endif
306  ATH_CHECK( m_ZTaggerTool.setProperty("OutputLevel", this->msg().level()) );
307  ATH_CHECK( m_ZTaggerTool.retrieve() );
308 
309  // Retrieving DecorationName (needed to access tagging results downstream):
310  std::string ZConfigPath = PathResolverFindCalibFile("BoostedJetTaggers/"+m_WZTaggerCalibArea+"/"+m_ZtagConfig);
311  if ( m_ZconfigReader.ReadFile( ZConfigPath.c_str(), EEnvLevel(0) ) ) {
312  ATH_MSG_ERROR( "Error while reading large-R config file : " << ZConfigPath );
313  return StatusCode::FAILURE;
314  }
315  else ATH_MSG_DEBUG( "Successfully read large-R config file : " << ZConfigPath );
316 
317  m_ZDecorName = m_ZconfigReader.GetValue("DecorationName" ,"");
318  ANA_MSG_DEBUG( "Found DecorationName in large-R config file : " << m_ZDecorName );
319 
320  } else if (m_ZTaggerTool.isUserConfigured()) ATH_CHECK(m_ZTaggerTool.retrieve());
321 
322  if (!m_TopTaggerTool.isUserConfigured() && !m_ToptagConfig.empty()) {
323  m_TopTaggerTool.setTypeAndName("JSSWTopTaggerDNN/TopTagger");
324  ATH_CHECK( m_TopTaggerTool.setProperty("ContainerName", m_fatJets) );
325  ATH_CHECK( m_TopTaggerTool.setProperty("ConfigFile", m_ToptagConfig) );
326  ATH_CHECK( m_TopTaggerTool.setProperty("CalibArea", m_TopTaggerCalibArea) );
327  ATH_CHECK( m_TopTaggerTool.setProperty("IsMC",!isData()));
328  ATH_CHECK( m_TopTaggerTool.setProperty("TruthBosonContainerName", "TruthBoson") ); // Set this if you are using a TRUTH3 style truth boson container;
329  ATH_CHECK( m_TopTaggerTool.setProperty("TruthTopQuarkContainerName", "TruthTop") ); // Set this if you are using a TRUTH3 style truth boson container;
330 #ifndef XAOD_STANDALONE
331  ATH_CHECK( m_TopTaggerTool.setProperty("SuppressOutputDependence", true) );
332 #endif
333  ATH_CHECK( m_TopTaggerTool.setProperty("OutputLevel", this->msg().level()) );
334  ATH_CHECK( m_TopTaggerTool.retrieve() );
335 
336  // Retrieving DecorationName (needed to access tagging results downstream):
337  std::string TopConfigPath = PathResolverFindCalibFile("BoostedJetTaggers/"+m_TopTaggerCalibArea+"/"+m_ToptagConfig);
338  if ( m_TopconfigReader.ReadFile( TopConfigPath.c_str(), EEnvLevel(0) ) ) {
339  ATH_MSG_ERROR( "Error while reading large-R config file : " << TopConfigPath );
340  return StatusCode::FAILURE;
341  }
342  else ATH_MSG_DEBUG( "Successfully read large-R config file : " << TopConfigPath );
343 
344  m_TopDecorName = m_TopconfigReader.GetValue("DecorationName" ,"");
345  ANA_MSG_DEBUG( "Found DecorationName in large-R config file : " << m_TopDecorName );
346 
347  } else if (m_TopTaggerTool.isUserConfigured()) ATH_CHECK(m_TopTaggerTool.retrieve());
348 
350  // Initialise JetTruthLabelingTool: https://twiki.cern.ch/twiki/bin/view/AtlasProtected/JetUncertaintiesRel21Summer2019LargeR#AnalysisBase_21_2_114_and_newer
351  if(!isData()) {
352  m_label_truthKey = fatjetcoll+"."+m_JetTruthLabelName;
353  ATH_CHECK(m_label_truthKey.initialize());
354 
355  if (!m_jetTruthLabelingTool.isUserConfigured()) {
356  m_jetTruthLabelingTool.setTypeAndName("JetTruthLabelingTool/ST_JetTruthLabelingTool");
357  ATH_CHECK( m_jetTruthLabelingTool.setProperty("RecoJetContainer", m_fatJets) );
358  ATH_CHECK( m_jetTruthLabelingTool.setProperty("TruthLabelName", m_JetTruthLabelName) );
359  ATH_CHECK( m_jetTruthLabelingTool.setProperty("UseTRUTH3", m_useTRUTH3) ); // Set this to false only if you have the FULL !TruthParticles container in your input file
360  ATH_CHECK( m_jetTruthLabelingTool.setProperty("TruthParticleContainerName", "TruthParticles") );
361  ATH_CHECK( m_jetTruthLabelingTool.setProperty("TruthBosonContainerName", "TruthBoson") ); // Set this if you are using a TRUTH3 style truth boson container
362  ATH_CHECK( m_jetTruthLabelingTool.setProperty("TruthTopQuarkContainerName", "TruthTop") ); // Set this if you are using a TRUTH3 style truth top quark container
363  ATH_CHECK( m_jetTruthLabelingTool.setProperty("OutputLevel", this->msg().level()) );
364  ATH_CHECK( m_jetTruthLabelingTool.retrieve() );
365  } else if (m_jetTruthLabelingTool.isUserConfigured()) ATH_CHECK(m_jetTruthLabelingTool.retrieve());
366  }
367  }
368 
369  if (m_slices["jet"] || m_slices["fjet"]) {
370 
371 
373  // Initialise jet uncertainty tool
374  // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/JetUncertaintiesRel22
375  ATH_MSG_INFO("Set up Jet Uncertainty tool...");
376 
377  // if not set, derive the MCType from the simulation type and MC campaign
378  if (m_jetUncertaintiesMCType.empty()) m_jetUncertaintiesMCType = m_isRun3 ? (isAtlfast() ? "MC23AF3" : "MC23") : (isAtlfast() ? "AF3" : "MC20");
379 
380  // large-R jets use MC20AF3 instead of AF3
381  m_fatJetUncertaintiesMCType = m_jetUncertaintiesMCType;
382  if (m_fatJetUncertaintiesMCType == "AF3") {
383  m_fatJetUncertaintiesMCType = "MC20AF3";
384  }
385 
386  if (!m_jetUncertaintiesTool.isUserConfigured()) {
387  std::string jetdef("AntiKt4" + xAOD::JetInput::typeName(xAOD::JetInput::Type(m_jetInputType)));
388 
389  if(jetdef !="AntiKt4EMPFlow"){
390  ATH_MSG_WARNING("Jet Uncertaintes recommendations only exist for PFlow jets, falling back to AntiKt4EMPFlow");
391  jetdef = "AntiKt4EMPFlow";
392  }
393  toolName = "JetUncertaintiesTool_" + jetdef;
394 
395  m_jetUncertaintiesTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
396 
397  ATH_CHECK( m_jetUncertaintiesTool.setProperty("JetDefinition", jetdef) );
398  ATH_CHECK( m_jetUncertaintiesTool.setProperty("MCType", m_jetUncertaintiesMCType) );
399  ATH_CHECK( m_jetUncertaintiesTool.setProperty("IsData", false) ); // Never use the PDSmearing for the nominal tool.
400  ATH_CHECK( m_jetUncertaintiesTool.setProperty("ConfigFile", m_jetUncertaintiesConfig) );
401  if(m_jetUncertaintiesAnalysisFile!="default") ATH_CHECK( m_jetUncertaintiesTool.setProperty("AnalysisFile", m_jetUncertaintiesAnalysisFile) );
402  if (m_jetUncertaintiesCalibArea != "default") ATH_CHECK( m_jetUncertaintiesTool.setProperty("CalibArea", m_jetUncertaintiesCalibArea) );
403  ATH_CHECK( m_jetUncertaintiesTool.setProperty("OutputLevel", this->msg().level()) );
404  ATH_CHECK( m_jetUncertaintiesTool.retrieve() );
405  } else ATH_CHECK( m_jetUncertaintiesTool.retrieve() );
406 
407  ATH_MSG_INFO("Set up Jet PD Smear Uncertainty tool...");
408 
409  if (!m_jetUncertaintiesPDSmearTool.isUserConfigured() && m_jetUncertaintiesPDsmearing == true) {
410  std::string jetdef("AntiKt4" + xAOD::JetInput::typeName(xAOD::JetInput::Type(m_jetInputType)));
411 
412  if(jetdef !="AntiKt4EMPFlow"){
413  ATH_MSG_WARNING("Jet Uncertaintes recommendations only exist for PFlow jets, falling back to AntiKt4EMPFlow");
414  jetdef = "AntiKt4EMPFlow";
415  }
416  toolName = "JetUncertaintiesPDSmearTool_" + jetdef;
417 
418  m_jetUncertaintiesPDSmearTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
419 
420  // If, for some reason, you're trying to use the PDSmear, with the reduced set return an error (you shouldn't do this, you're just going to duplicate the SimpleJER results.
421  bool JERUncPDsmearing = isData() ? isData() : m_jetUncertaintiesPDsmearing;
422  if (m_jetUncertaintiesConfig.find("SimpleJER") != std::string::npos && JERUncPDsmearing){
423  ATH_MSG_ERROR("You are trying to use the SimpleJER set, with PDsmearing. There is no functionality for this. Please fix your config file. Either run with PDSmear set to false, or run with the AllJER or FullJER sets.");
424  return StatusCode::FAILURE;
425  }
426  ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("JetDefinition", jetdef) );
427  ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("MCType", m_jetUncertaintiesMCType) );
428  ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("IsData", true) ); // Set to True by default for PDSmear-named tool.
429  ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("PseudoDataJERsmearingMode", true) );
430  ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("ConfigFile", m_jetUncertaintiesConfig) );
431  if (m_jetUncertaintiesCalibArea != "default") ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("CalibArea", m_jetUncertaintiesCalibArea) );
432  ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("OutputLevel", this->msg().level()) );
433  ATH_CHECK( m_jetUncertaintiesPDSmearTool.retrieve() );
434  } else{
435  ATH_MSG_DEBUG("Do not retrieve the jet PD Smearing tool if it is not configured");
436  //ATH_CHECK( m_jetUncertaintiesPDSmearTool.retrieve() );
437  }
438  }
439 
440  if (m_slices["fjet"]) {
441 
442  // JetUncertaintiesTool handles JES, JER and JMS uncertainties for large-R jets
443  if (!m_fatjetUncertaintiesTool.isUserConfigured() && !m_fatJets.empty() && !m_fatJetUncConfig.empty()) {
444 
445  ATH_MSG_INFO("Set up Large-R Jet Uncertainty tool...");
446 
447  // Print warning about missing large-R jets uncertainties for FastSim in mc23
448  if (m_isRun3 && isAtlfast())
449  ATH_MSG_WARNING("Uncertainties for large-R jets in mc23 and fast simulation not yet available; be aware uncertainties might be not complete!");
450 
451  toolName = "JetUncertaintiesTool_" + m_fatJets;
452  m_fatjetUncertaintiesTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
453 
454  ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("JetDefinition", fatjetcoll) );
455  ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("MCType", m_fatJetUncertaintiesMCType) );
456  ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("IsData", isData()) );
457  ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("ConfigFile", m_fatJetUncConfig) );
458  if (m_jetUncertaintiesCalibArea != "default") ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("CalibArea", m_jetUncertaintiesCalibArea) );
459 
460  //Restrict variables to be shifted if (required)
461  if( m_fatJetUncVars != "default" ){
462  std::vector<std::string> shift_vars = {};
463 
464  std::string temp(m_fatJetUncVars);
465  do {
466  auto pos = temp.find(',');
467  shift_vars.push_back(temp.substr(0, pos));
468  if (pos == std::string::npos)
469  temp = "";
470  else
471  temp = temp.substr(pos + 1);
472 
473  }
474  while (!temp.empty() );
475 
476  ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("VariablesToShift", shift_vars) );
477  }
478 
479  ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("OutputLevel", this->msg().level()) );
480  ATH_CHECK( m_fatjetUncertaintiesTool.retrieve() );
481  } else if (m_fatjetUncertaintiesTool.isUserConfigured()) ATH_CHECK(m_fatjetUncertaintiesTool.retrieve());
482 
483 
484  if (!m_fatjetUncertaintiesPDSmearTool.isUserConfigured() && !m_fatJets.empty() && !m_fatJetUncConfig.empty() && m_fatJetUncertaintiesPDsmearing == true) {
485 
486  ATH_MSG_INFO("Set up Jet PD Smear Uncertainty tool...");
487 
488  toolName = "JetUncertaintiesPDSmearTool_" + m_fatJets;
489  m_fatjetUncertaintiesPDSmearTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
490 
491  // If, for some reason, you're trying to use the PDSmear, with the reduced set return an error (you shouldn't do this, you're just going to duplicate the SimpleJER results.
492  bool JERUncPDsmearing = isData() ? isData() : m_fatJetUncertaintiesPDsmearing;
493  if (m_fatJetUncConfig.find("SimpleJER") != std::string::npos && JERUncPDsmearing){
494  ATH_MSG_ERROR("You are trying to use the SimpleJER set, with PDsmearing. There is no functionality for this. Please fix your config file. Either run with PDSmear set to false, or run with the AllJER or FullJER sets.");
495  return StatusCode::FAILURE;
496  }
497  ATH_CHECK( m_fatjetUncertaintiesPDSmearTool.setProperty("JetDefinition", fatjetcoll) );
498  ATH_CHECK( m_fatjetUncertaintiesPDSmearTool.setProperty("MCType", m_fatJetUncertaintiesMCType) );
499  ATH_CHECK( m_fatjetUncertaintiesPDSmearTool.setProperty("IsData", true) ); // Set to True by default for PDSmear-named tool.
500  ATH_CHECK( m_fatjetUncertaintiesPDSmearTool.setProperty("PseudoDataJERsmearingMode", true) );
501  ATH_CHECK( m_fatjetUncertaintiesPDSmearTool.setProperty("ConfigFile", m_fatJetUncConfig) );
502  if (m_jetUncertaintiesCalibArea != "default") ATH_CHECK( m_fatjetUncertaintiesPDSmearTool.setProperty("CalibArea", m_jetUncertaintiesCalibArea) );
503  ATH_CHECK( m_fatjetUncertaintiesPDSmearTool.setProperty("OutputLevel", this->msg().level()) );
504  ATH_CHECK( m_fatjetUncertaintiesPDSmearTool.retrieve() );
505  } else{
506  ATH_MSG_DEBUG("Do not retrieve the jet PD Smearing tool if it is not configured");
507  }
508 
509 
510  // FFSmearingTool handles JMR uncertainties for large-R jets
511  if (!m_fatjetFFSmearingTool.isUserConfigured() && !m_fatJets.empty() && !m_fatJetUncConfig.empty()) {
512 
513  ATH_MSG_INFO("Set up Large-R FFJetSmearingTool ...");
514 
515  toolName = "FFJetSmearingTool_" + m_fatJets;
516  m_fatjetFFSmearingTool.setTypeAndName("CP::FFJetSmearingTool/"+toolName);
517 
518  ATH_CHECK( m_fatjetFFSmearingTool.setProperty("MassDef", "UFO") );
519  ATH_CHECK( m_fatjetFFSmearingTool.setProperty("MCType", m_fatJetUncertaintiesMCType) );
520  ATH_CHECK( m_fatjetFFSmearingTool.setProperty("ConfigFile", "rel22/Spring2025_PreRec/R10_FullJMR.config") );
521  ATH_CHECK( m_fatjetFFSmearingTool.setProperty("OutputLevel", this->msg().level()) );
522  ATH_CHECK( m_fatjetFFSmearingTool.retrieve() );
523  } else if (m_fatjetFFSmearingTool.isUserConfigured()) ATH_CHECK(m_fatjetFFSmearingTool.retrieve());
524 
525  // Need to keep track of systematics of FFJetSmearingTool
526  if (!m_fatJets.empty()) {
527  // m_fatjetFFSmearingSyst = CP::make_systematics_vector(m_fatjetFFSmearingTool->recommendedSystematics());
528  ATH_MSG_INFO("The following uncertainties have been defined for the m_fatjetFFSmearingTool");
529  for (auto & sysSet : m_fatjetFFSmearingTool->recommendedSystematics()){
530  m_fatjetFFSmearingSyst.push_back(CP::SystematicSet({sysSet}));
531  ATH_MSG_INFO(" - " << sysSet.name());
532  }
533  }
534 
535  ATH_MSG_INFO(" Won't initialise Wtagger uncertainty tool for fat jets until we get rec for UFO");
536  // Won't initialise Wtagger uncertainty tool for fat jets until we get rec for UFO
537  /*
538  if (!m_WTagjetUncertaintiesTool.isUserConfigured() && !m_fatJets.empty() && !m_WtagConfig.empty() && !m_WTagUncConfig.empty()) {
539 
540  toolName = "WTagJetUncertaintiesTool_" + m_fatJets;
541  m_WTagjetUncertaintiesTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
542  ATH_CHECK( m_WTagjetUncertaintiesTool.setProperty("JetDefinition", fatjetcoll) );
543  ATH_CHECK( m_WTagjetUncertaintiesTool.setProperty("MCType", "MC16") );
544  ATH_CHECK( m_WTagjetUncertaintiesTool.setProperty("IsData", isData()) );
545  ATH_CHECK( m_WTagjetUncertaintiesTool.setProperty("ConfigFile", "rel21/Fall2020/"+m_WTagUncConfig) );
546  ATH_CHECK( m_WTagjetUncertaintiesTool.setProperty("OutputLevel", this->msg().level()) );
547  ATH_CHECK( m_WTagjetUncertaintiesTool.retrieve() );
548  } else if (m_WTagjetUncertaintiesTool.isUserConfigured()) ATH_CHECK(m_WTagjetUncertaintiesTool.retrieve());
549  */
550  ATH_MSG_INFO(" Won't initialise Ztagger uncertainty tool for fat jets until we get rec for UFO");
551  // Won't initialise Ztagger uncertainty tool for fat jets until we get rec for UFO
552  /*
553  if (!m_ZTagjetUncertaintiesTool.isUserConfigured() && !m_fatJets.empty() && !m_ZtagConfig.empty() && !m_ZTagUncConfig.empty()) {
554 
555  toolName = "ZTagJetUncertaintiesTool_" + m_fatJets;
556  m_ZTagjetUncertaintiesTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
557  ATH_CHECK( m_ZTagjetUncertaintiesTool.setProperty("JetDefinition", fatjetcoll) );
558  ATH_CHECK( m_ZTagjetUncertaintiesTool.setProperty("ConfigFile", "rel21/Fall2020/"+m_ZTagUncConfig) );
559  ATH_CHECK( m_ZTagjetUncertaintiesTool.setProperty("MCType", "MC16") );
560  ATH_CHECK( m_ZTagjetUncertaintiesTool.setProperty("IsData", isData()) );
561  ATH_CHECK( m_ZTagjetUncertaintiesTool.setProperty("OutputLevel", this->msg().level()) );
562  ATH_CHECK( m_ZTagjetUncertaintiesTool.retrieve() );
563  } else if (m_ZTagjetUncertaintiesTool.isUserConfigured()) ATH_CHECK(m_ZTagjetUncertaintiesTool.retrieve());
564  */
565  ATH_MSG_INFO(" Won't initialise top-tagger uncertainty tool for fat jets until we get rec for UFO");
566  // Won't initialise top-tagger uncertainty tool for fat jets until we get rec for UFO
567  /*
568  if (!m_TopTagjetUncertaintiesTool.isUserConfigured() && !m_fatJets.empty() && !m_ToptagConfig.empty() && !m_TopTagUncConfig.empty()) {
569 
570  toolName = "TopTagJetUncertaintiesTool_" + m_fatJets;
571  m_TopTagjetUncertaintiesTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
572  ATH_CHECK( m_TopTagjetUncertaintiesTool.setProperty("JetDefinition", fatjetcoll) );
573  ATH_CHECK( m_TopTagjetUncertaintiesTool.setProperty("MCType", "MC16") );
574  ATH_CHECK( m_TopTagjetUncertaintiesTool.setProperty("IsData", isData()) );
575  ATH_CHECK( m_TopTagjetUncertaintiesTool.setProperty("ConfigFile", "rel21/Fall2020/"+m_TopTagUncConfig) );
576  ATH_CHECK( m_TopTagjetUncertaintiesTool.setProperty("OutputLevel", this->msg().level()) );
577  ATH_CHECK( m_TopTagjetUncertaintiesTool.retrieve() );
578  } else if (m_TopTagjetUncertaintiesTool.isUserConfigured()) ATH_CHECK(m_TopTagjetUncertaintiesTool.retrieve());
579  */
580  }
581 
582 
583  // tagger SF and uncertainties
584  // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/BoostedJetTaggingRecommendationFullRun2
585  // To be implemented here
586 
587  if (m_slices["jet"]) {
589  // Initialise jet cleaning tools
590 
591  // see https://twiki.cern.ch/twiki/bin/view/AtlasProtected/HowToCleanJetsR22
592  if (m_badJetCut!="" && !m_jetCleaningTool.isUserConfigured()) {
593  toolName = "JetCleaningTool";
594  m_jetCleaningTool.setTypeAndName("JetCleaningTool/"+toolName);
595  ATH_CHECK( m_jetCleaningTool.setProperty("CutLevel", m_badJetCut) );
596  ATH_CHECK( m_jetCleaningTool.setProperty("DoUgly", false) );
597  ATH_CHECK( m_jetCleaningTool.setProperty("OutputLevel", this->msg().level()) );
598  ATH_CHECK( m_jetCleaningTool.retrieve() );
599  } else if (m_jetCleaningTool.isUserConfigured()) ATH_CHECK( m_jetCleaningTool.retrieve() );
600 
602  // Initialise jet pileup labeling tool (required for labels used by JvtEfficiencyTools)
603 
604  if(!m_jetPileupLabelingTool.isUserConfigured() && !isData()) {
605  toolName = "PileupLabelingTool";
606  m_jetPileupLabelingTool.setTypeAndName("JetPileupLabelingTool/"+toolName);
607  ATH_CHECK( m_jetPileupLabelingTool.setProperty("RecoJetContainer", m_defaultJets) );
608  ATH_CHECK( m_jetPileupLabelingTool.setProperty("TruthJetContainer", m_defaultTruthJets) );
609  #ifndef XAOD_STANDALONE
610  ATH_CHECK( m_jetPileupLabelingTool.setProperty("SuppressInputDependence", true) );
611  ATH_CHECK( m_jetPileupLabelingTool.setProperty("SuppressOutputDependence", true) );
612  #endif
613  ATH_CHECK( m_jetPileupLabelingTool.setProperty("OutputLevel", this->msg().level()) );
614  ATH_CHECK( m_jetPileupLabelingTool.retrieve() );
615  } else if (m_jetPileupLabelingTool.isUserConfigured()) ATH_CHECK( m_jetPileupLabelingTool.retrieve() );
616 
618  // Initialise jet Jvt moment tool
619 
620  if (!m_jetJvtMomentTool.isUserConfigured()) {
621  toolName = "JvtMomentTool";
622  m_jetJvtMomentTool.setTypeAndName("JetVertexTaggerTool/"+toolName);
623  ATH_CHECK( m_jetJvtMomentTool.setProperty("JetContainer", m_defaultJets) );
624  #ifndef XAOD_STANDALONE
625  ATH_CHECK( m_jetJvtMomentTool.setProperty("SuppressInputDependence", true) );
626  ATH_CHECK( m_jetJvtMomentTool.setProperty("SuppressOutputDependence", true) );
627  #endif
628  ATH_CHECK( m_jetJvtMomentTool.setProperty("OutputLevel", this->msg().level()) );
629  ATH_CHECK( m_jetJvtMomentTool.retrieve() );
630  } else if (m_jetJvtMomentTool.isUserConfigured()) ATH_CHECK( m_jetJvtMomentTool.retrieve() );
631 
633  // Initialise jet NNJvt moment tool
634 
635  m_applyJVTCut = !m_JvtWP.empty();
636  if (!m_jetNNJvtMomentTool.isUserConfigured() && m_applyJVTCut) {
637  toolName = "NNJvtMomentTool";
638  m_jetNNJvtMomentTool.setTypeAndName("JetPileupTag::JetVertexNNTagger/"+toolName);
639  ATH_CHECK( m_jetNNJvtMomentTool.setProperty("JetContainer", m_defaultJets) );
640  #ifndef XAOD_STANDALONE
641  ATH_CHECK( m_jetNNJvtMomentTool.setProperty("SuppressInputDependence", true) );
642  ATH_CHECK( m_jetNNJvtMomentTool.setProperty("SuppressOutputDependence", true) );
643  #endif
644  ATH_CHECK( m_jetNNJvtMomentTool.setProperty("OutputLevel", this->msg().level()) );
645  ATH_CHECK( m_jetNNJvtMomentTool.retrieve() );
646  } else if (m_jetNNJvtMomentTool.isUserConfigured()) ATH_CHECK( m_jetNNJvtMomentTool.retrieve() );
647 
649  // Initialise jet NNJvt selection tool
650 
651  if (!m_jetNNJvtSelectionTool.isUserConfigured() && m_applyJVTCut) {
652  toolName = "NNJvtSelectionTool";
653  m_jetNNJvtSelectionTool.setTypeAndName("CP::NNJvtSelectionTool/"+toolName);
654  ATH_CHECK( m_jetNNJvtSelectionTool.setProperty("JetContainer", m_defaultJets) );
655  ATH_CHECK( m_jetNNJvtSelectionTool.setProperty("WorkingPoint", m_JvtWP) );
656  ATH_CHECK( m_jetNNJvtSelectionTool.setProperty("MaxPtForJvt", m_JvtPtMax) );
657  ATH_CHECK( m_jetNNJvtSelectionTool.setProperty("JvtMomentName", "NNJvt") );
658  ATH_CHECK( m_jetNNJvtSelectionTool.setProperty("OutputLevel", this->msg().level()) );
659  ATH_CHECK( m_jetNNJvtSelectionTool.retrieve() );
660  } else if (m_jetNNJvtSelectionTool.isUserConfigured()) ATH_CHECK( m_jetNNJvtSelectionTool.retrieve() );
661 
663  // Initialise jet NNJvt efficiency tool (scale factors)
664 
665  if (!m_jetNNJvtEfficiencyTool.isUserConfigured() && m_applyJVTCut) {
666  toolName = "NNJvtEfficiencyTool";
667  m_jetNNJvtEfficiencyTool.setTypeAndName("CP::NNJvtEfficiencyTool/"+toolName);
668  ATH_CHECK( m_jetNNJvtEfficiencyTool.setProperty("JetContainer", m_defaultJets) );
669  ATH_CHECK( m_jetNNJvtEfficiencyTool.setProperty("WorkingPoint", m_JvtWP) );
670  ATH_CHECK( m_jetNNJvtEfficiencyTool.setProperty("MaxPtForJvt", m_JvtPtMax) );
671  ATH_CHECK( m_jetNNJvtEfficiencyTool.setProperty("SFFile", m_isRun3 ? m_JvtConfigRun3 : m_JvtConfigRun2) );
672  ATH_CHECK( m_jetNNJvtEfficiencyTool.setProperty("OutputLevel", this->msg().level()) );
673  ATH_CHECK( m_jetNNJvtEfficiencyTool.retrieve() );
674  } else if (m_jetNNJvtEfficiencyTool.isUserConfigured()) ATH_CHECK( m_jetNNJvtEfficiencyTool.retrieve() );
675 
677  // Initialise jet fJvt selection tool
678 
679  if (!m_jetfJvtSelectionTool.isUserConfigured() && m_doFwdJVT) {
680  toolName = "fJvtSelectionTool";
681  m_jetfJvtSelectionTool.setTypeAndName("CP::FJvtSelectionTool/"+toolName);
682  ATH_CHECK( m_jetfJvtSelectionTool.setProperty("JetContainer", m_defaultJets) );
683  ATH_CHECK( m_jetfJvtSelectionTool.setProperty("WorkingPoint", m_fJvtWP) );
684  ATH_CHECK( m_jetfJvtSelectionTool.setProperty("MaxPtForJvt", m_fJvtPtMax) );
685  ATH_CHECK( m_jetfJvtSelectionTool.setProperty("JvtMomentName", "DFCommonJets_fJvt") );
686  ATH_CHECK( m_jetfJvtSelectionTool.setProperty("OutputLevel", this->msg().level()) );
687  ATH_CHECK( m_jetfJvtSelectionTool.retrieve() );
688  } else if (m_jetfJvtSelectionTool.isUserConfigured()) ATH_CHECK( m_jetfJvtSelectionTool.retrieve() );
689 
691  // Initialise jet fJvt efficiency tool for scale factors (scale factors)
692 
693  if (!m_jetfJvtEfficiencyTool.isUserConfigured() && m_doFwdJVT) {
694  toolName = "fJvtEfficiencyTool";
695  m_jetfJvtEfficiencyTool.setTypeAndName("CP::FJvtEfficiencyTool/"+toolName);
696  ATH_CHECK( m_jetfJvtEfficiencyTool.setProperty("JetContainer", m_defaultJets) );
697  ATH_CHECK( m_jetfJvtEfficiencyTool.setProperty("WorkingPoint", m_fJvtWP) );
698  ATH_CHECK( m_jetfJvtEfficiencyTool.setProperty("MaxPtForJvt", m_fJvtPtMax) );
699  ATH_CHECK( m_jetfJvtEfficiencyTool.setProperty("SFFile", m_isRun3 ? m_fJvtConfigRun3 : m_fJvtConfigRun2) );
700  ATH_CHECK( m_jetfJvtEfficiencyTool.setProperty("OutputLevel", this->msg().level()) );
701  ATH_CHECK( m_jetfJvtEfficiencyTool.retrieve() );
702  } else ATH_CHECK( m_jetfJvtEfficiencyTool.retrieve() );
703  }
704 
705 
706  if (m_slices["mu"]) {
708  // Check muon baseline ID
709 
710  std::string muQualBaseline = "";
711  switch (m_muIdBaseline) {
712  case xAOD::Muon::VeryLoose: muQualBaseline = "VeryLoose";
713  ATH_MSG_WARNING("No muon scale factors are available for VeryLoose working point.");
714  break;
715  case xAOD::Muon::Loose: muQualBaseline = "Loose"; break;
716  case xAOD::Muon::Medium: muQualBaseline = "Medium"; break;
717  case xAOD::Muon::Tight: muQualBaseline = "Tight"; break;
718  case 4: muQualBaseline = "HighPt"; break;
719  case 5: muQualBaseline = "LowPt"; break;
720  case 6: muQualBaseline = "LowPtMVA"; break;
721  case 7: muQualBaseline = "HighPt3Layers"; break;
722  default:
723  ATH_MSG_ERROR("Invalid muon working point provided: " << m_muIdBaseline << ". Cannot initialise!");
724  return StatusCode::FAILURE;
725  break;
726  }
727 
729  // Initialise muon calibration tool
730  // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/MuonMomentumCorrectionsSubgroup#CP_MuonCalibrationAndSmearingToo
731  // Please not that for AthAnalysis we need to configure the MuonCalibTool within METSignificance manually and just can't pass the handle
732  // Hence, any changes here should also be propagated to the METSignificance setup further below
733 
734  if (!m_muonCalibTool.isUserConfigured()) {
735  m_muonCalibTool.setTypeAndName("CP::MuonCalibTool/ST_MuonCalibrationTool");
736  if (m_isRun3) ATH_CHECK( m_muonCalibTool.setProperty("IsRun3Geo", true ));
737  ATH_CHECK( m_muonCalibTool.setProperty("calibMode", m_muCalibrationMode) );
738  ATH_CHECK( m_muonCalibTool.setProperty("OutputLevel", this->msg().level()) );
739  ATH_CHECK( m_muonCalibTool.setProperty("release", "Recs2025_03_26_Run2Run3" ));
740  int IdBaselineInt = m_muIdBaseline;
741  if (IdBaselineInt == 4) {
742  ATH_CHECK( m_muonCalibTool.setProperty("do2StationsHighPt", true) );
743  }
744  ATH_CHECK( m_muonCalibTool.setProperty("doExtraSmearing", m_muHighPtExtraSmear) );
745  ATH_CHECK( m_muonCalibTool.retrieve() );
746  } else ATH_CHECK( m_muonCalibTool.retrieve() );
747 
749  // Initialise muon selection tool
750 
751  if (!m_muonSelectionToolBaseline.isUserConfigured()) {
752  toolName = "MuonSelectionTool_Baseline_" + muQualBaseline;
753  m_muonSelectionToolBaseline.setTypeAndName("CP::MuonSelectionTool/"+toolName);
754  if (m_isRun3) ATH_CHECK( m_muonSelectionToolBaseline.setProperty("IsRun3Geo", true ));
755 
756  if (m_muBaselineEta<m_muEta){ // Test for inconsistent configuration
757  ATH_MSG_ERROR( "Requested a baseline eta cut for muons (" << m_muBaselineEta <<
758  ") that is tighter than the signal cut (" << m_muEta << "). Please check your config." );
759  return StatusCode::FAILURE;
760  }
761  int IdBaselineInt = m_muIdBaseline;
762  ATH_CHECK( m_muonSelectionToolBaseline.setProperty( "MaxEta", m_muBaselineEta) );
763  if (IdBaselineInt == 6){
764  ATH_CHECK( m_muonSelectionToolBaseline.setProperty( "MuQuality", 5 ) );
765  ATH_CHECK( m_muonSelectionToolBaseline.setProperty( "UseMVALowPt", true));
766  } else if (IdBaselineInt == 7){
767  ATH_CHECK( m_muonSelectionToolBaseline.setProperty( "MuQuality", 4 ) );
768  ATH_CHECK( m_muonSelectionToolBaseline.setProperty( "Use2stationMuonsHighPt", false));
769  } else ATH_CHECK(m_muonSelectionToolBaseline.setProperty( "MuQuality", m_muIdBaseline ));
770  ATH_CHECK( m_muonSelectionToolBaseline.setProperty("OutputLevel", this->msg().level()) );
771  ATH_CHECK( m_muonSelectionToolBaseline.retrieve() );
772  } else ATH_CHECK( m_muonSelectionToolBaseline.retrieve() );
773 
774 
775  std::string muQual = "";
776  switch (m_muId) {
777  case xAOD::Muon::VeryLoose: muQual = "VeryLoose";
778  ATH_MSG_WARNING("No muon scale factors are available for VeryLoose working point.");
779  break;
780  case xAOD::Muon::Loose: muQual = "Loose"; break;
781  case xAOD::Muon::Medium: muQual = "Medium"; break;
782  case xAOD::Muon::Tight: muQual = "Tight"; break;
783  case 4: muQual = "HighPt"; break;
784  case 5: muQual = "LowPt"; break;
785  case 6: muQual = "LowPtMVA"; break;
786  case 7: muQual = "HighPt3Layers"; break;
787  default:
788  ATH_MSG_ERROR("Invalid muon working point provided: " << m_muId << ". Cannot initialise!");
789  return StatusCode::FAILURE;
790  break;
791  }
792 
793  if (!m_muonSelectionTool.isUserConfigured()) {
794  toolName = "MuonSelectionTool_" + muQual;
795  m_muonSelectionTool.setTypeAndName("CP::MuonSelectionTool/"+toolName);
796  if (m_isRun3) ATH_CHECK( m_muonSelectionTool.setProperty("IsRun3Geo", true ));
797  ATH_CHECK( m_muonSelectionTool.setProperty( "MaxEta", m_muEta) );
798  int IdInt = m_muId;
799  if (IdInt == 6){
800  ATH_CHECK( m_muonSelectionTool.setProperty( "MuQuality", 5 ) );
801  ATH_CHECK( m_muonSelectionTool.setProperty( "UseMVALowPt", true));
802  } else if (IdInt == 7){
803  ATH_CHECK( m_muonSelectionTool.setProperty( "MuQuality", 4 ) );
804  ATH_CHECK( m_muonSelectionTool.setProperty( "Use2stationMuonsHighPt", false));
805  } else ATH_CHECK(m_muonSelectionTool.setProperty( "MuQuality", m_muId ));
806  ATH_CHECK( m_muonSelectionTool.setProperty("OutputLevel", this->msg().level()) );
807  ATH_CHECK( m_muonSelectionTool.retrieve() );
808  } else ATH_CHECK( m_muonSelectionTool.retrieve() );
809 
810 
811  if (!m_muonSelectionHighPtTool.isUserConfigured()) { //Fixed to HighPt WP
812  toolName = "MuonSelectionHighPtTool_" + muQual;
813  m_muonSelectionHighPtTool.setTypeAndName("CP::MuonSelectionTool/"+toolName);
814  if (m_isRun3) ATH_CHECK( m_muonSelectionHighPtTool.setProperty("IsRun3Geo", true ));
815  ATH_CHECK( m_muonSelectionHighPtTool.setProperty( "MaxEta", m_muEta) );
816  ATH_CHECK( m_muonSelectionHighPtTool.setProperty( "MuQuality", 4 ) );
817  ATH_CHECK( m_muonSelectionHighPtTool.setProperty("OutputLevel", this->msg().level()) );
818  ATH_CHECK( m_muonSelectionHighPtTool.retrieve() );
819  } else ATH_CHECK( m_muonSelectionHighPtTool.retrieve() );
820 
821 
823  // Initialise prompt/LRT muon OR tool
824  if (!m_muonLRTORTool.isUserConfigured()) {
825  toolName = "MuonLRTOverlapRemovalTool";
826  m_muonLRTORTool.setTypeAndName("CP::MuonLRTOverlapRemovalTool/"+toolName);
827  ATH_CHECK( m_muonLRTORTool.setProperty("overlapStrategy", CP::IMuonLRTOverlapRemovalTool::defaultStrategy) );
828  if (m_isRun3) ATH_CHECK( m_muonLRTORTool.setProperty("UseRun3WP", true ));
829  ATH_CHECK( m_muonLRTORTool.setProperty("OutputLevel", this->msg().level()) );
830  ATH_CHECK( m_muonLRTORTool.retrieve() );
831  } else ATH_CHECK( m_muonLRTORTool.retrieve() );
832 
834  // Initialise muon efficiency tools
835  if (!m_muonEfficiencySFTool.isUserConfigured() && m_muId != xAOD::Muon::VeryLoose && !isData()) {
836  toolName = "MuonEfficiencyScaleFactors_" + muQual;
837  m_muonEfficiencySFTool.setTypeAndName("CP::MuonEfficiencyScaleFactors/"+toolName);
838  ATH_CHECK( m_muonEfficiencySFTool.setProperty("WorkingPoint", muQual) );
839  ATH_CHECK( m_muonEfficiencySFTool.setProperty("CalibrationRelease", m_isRun3? "250418_Preliminary_r24run3":"230213_Preliminary_r22run2") );
840  ATH_CHECK( m_muonEfficiencySFTool.setProperty("OutputLevel", this->msg().level()) );
841  ATH_CHECK( m_muonEfficiencySFTool.retrieve() );
842  } else if (m_muonEfficiencySFTool.isUserConfigured()) ATH_CHECK( m_muonEfficiencySFTool.retrieve() );
843 
844 
845  if (!m_muonEfficiencyBMHighPtSFTool.isUserConfigured() && !isData()){
846  toolName = "MuonEfficiencyScaleFactorsBMHighPt_" + muQual;
847  m_muonEfficiencyBMHighPtSFTool.setTypeAndName("CP::MuonEfficiencyScaleFactors/"+toolName);
848  ATH_CHECK( m_muonEfficiencyBMHighPtSFTool.setProperty("WorkingPoint", "BadMuonVeto_HighPt") );
849  ATH_CHECK( m_muonEfficiencyBMHighPtSFTool.setProperty("CalibrationRelease", m_isRun3? "220817_Preliminary_r22run3":"230213_Preliminary_r22run2") ); //BadMuonVeto_HighPt currently not available for 240711_Preliminary_r24run3
850  ATH_CHECK( m_muonEfficiencyBMHighPtSFTool.setProperty("OutputLevel", this->msg().level()) );
851  ATH_CHECK( m_muonEfficiencyBMHighPtSFTool.retrieve() );
852  } else if (m_muonEfficiencyBMHighPtSFTool.isUserConfigured()) ATH_CHECK( m_muonEfficiencyBMHighPtSFTool.retrieve() );
853 
854 
855  if (m_doTTVAsf && m_mud0sig<0 && m_muz0<0){
856  ATH_MSG_WARNING("Requested TTVA SFs without d0sig and z0 cuts. Disabling scale factors as they will not make sense.");
857  m_doTTVAsf=false;
858  }
859 
860  if (m_doTTVAsf && !m_muonTTVAEfficiencySFTool.isUserConfigured() && !isData()) {
861  toolName = "MuonTTVAEfficiencyScaleFactors";
862  m_muonTTVAEfficiencySFTool.setTypeAndName("CP::MuonEfficiencyScaleFactors/"+toolName);
863  ATH_CHECK( m_muonTTVAEfficiencySFTool.setProperty("WorkingPoint", "TTVA") );
864  ATH_CHECK( m_muonTTVAEfficiencySFTool.setProperty("CalibrationRelease", m_isRun3? "250418_Preliminary_r24run3":"230213_Preliminary_r22run2") );
865  ATH_CHECK( m_muonTTVAEfficiencySFTool.setProperty("OutputLevel", this->msg().level()) );
866  ATH_CHECK( m_muonTTVAEfficiencySFTool.retrieve() );
867  } else if (m_muonTTVAEfficiencySFTool.isUserConfigured()) ATH_CHECK( m_muonTTVAEfficiencySFTool.retrieve() );
868 
869 
870 
872  // Initialise muon isolation tool
873  if (!m_muonIsolationSFTool.isUserConfigured() && !m_muIso_WP.empty() && !isData()) {
874  toolName = "MuonIsolationScaleFactors_" + m_muIso_WP;
875 
876  std::string tmp_muIso_WP = m_muIso_WP;
877  if ( !check_isOption(m_muIso_WP, m_mu_iso_support) ) { //check if supported
878  ATH_MSG_WARNING("Your selected muon Iso WP ("
879  << m_muIso_WP
880  << ") does not have SFs defined. Will try to find an appropriate fall-back.");
881  if (m_mu_iso_fallback.count(m_muIso_WP) > 0){
882  tmp_muIso_WP = m_mu_iso_fallback[m_muIso_WP];
883  ATH_MSG_WARNING("Your selected muon Iso WP ("
884  << m_muIso_WP
885  << " is not supported, and does not have SFs available. Falling back to "
886  << tmp_muIso_WP
887  << " for SF determination.");
888  } else {
889  ATH_MSG_ERROR("*** The muon isolation WP you selected (" << m_muIso_WP << ") is not currentely supported, and no known fall-back option for SFs exists. Sorry! ***");
890  return StatusCode::FAILURE;
891  }
892  }
893 
894  m_muonIsolationSFTool.setTypeAndName("CP::MuonEfficiencyScaleFactors/"+toolName);
895  ATH_CHECK( m_muonIsolationSFTool.setProperty("WorkingPoint", tmp_muIso_WP + "Iso") );
896  ATH_CHECK( m_muonIsolationSFTool.setProperty("CalibrationRelease", m_isRun3? "250418_Preliminary_r24run3":"230213_Preliminary_r22run2") );
897  ATH_CHECK( m_muonIsolationSFTool.setProperty("OutputLevel", this->msg().level()) );
898  ATH_CHECK( m_muonIsolationSFTool.retrieve() );
899 
900  } else if (m_muonIsolationSFTool.isUserConfigured()) ATH_CHECK( m_muonIsolationSFTool.retrieve() );
901 
902 
903  if (!m_muonHighPtIsolationSFTool.isUserConfigured() && !m_muIsoHighPt_WP.empty() && !isData()) {
904  toolName = "MuonHighPtIsolationScaleFactors_" + m_muIsoHighPt_WP;
905 
906  std::string tmp_muIsoHighPt_WP = m_muIsoHighPt_WP;
907  if ( !check_isOption(m_muIsoHighPt_WP, m_mu_iso_support) ) { //check if supported
908  ATH_MSG_WARNING("Your selected muon high-pt Iso WP ("
909  << m_muIsoHighPt_WP
910  << ") does not have SFs defined. Will try to find an appropriate fall-back.");
911  if (m_mu_iso_fallback.count(m_muIsoHighPt_WP) > 0){
912  tmp_muIsoHighPt_WP = m_mu_iso_fallback[m_muIsoHighPt_WP];
913  ATH_MSG_WARNING("Your selected muon high-pt Iso WP ("
914  << m_muIsoHighPt_WP
915  << " is not supported, and does not have SFs available. Falling back to "
916  << tmp_muIsoHighPt_WP
917  << " for SF determination.");
918  } else {
919  ATH_MSG_ERROR("*** The muon isolation WP you selected (" << m_muIsoHighPt_WP << ") is not currentely supported, and no known fall-back option for SFs exists. Sorry! ***");
920  return StatusCode::FAILURE;
921  }
922  }
923 
924  m_muonHighPtIsolationSFTool.setTypeAndName("CP::MuonEfficiencyScaleFactors/"+toolName);
925  // Use for the low-pt WP a dedicated set of isolation scale-factors having an extra uncertainty in place
926  ATH_CHECK( m_muonHighPtIsolationSFTool.setProperty("WorkingPoint", tmp_muIsoHighPt_WP + "Iso") );
927  ATH_CHECK( m_muonHighPtIsolationSFTool.setProperty("CalibrationRelease", m_isRun3? "250418_Preliminary_r24run3":"230213_Preliminary_r22run2") );
928  ATH_CHECK( m_muonHighPtIsolationSFTool.setProperty("OutputLevel", this->msg().level()) );
929  ATH_CHECK( m_muonHighPtIsolationSFTool.retrieve() );
930 
931  } else if (m_muonHighPtIsolationSFTool.isUserConfigured()) ATH_CHECK( m_muonHighPtIsolationSFTool.retrieve() );
932 
933 
935  // Initialise muon trigger scale factor tools
936 
937  if (!m_muonTriggerSFTool.isUserConfigured() && !isData()) {
938  toolName = "MuonTriggerScaleFactors_" + muQual;
939  m_muonTriggerSFTool.setTypeAndName("CP::MuonTriggerScaleFactors/"+toolName);
940  if ( muQual=="LowPt" ) {
941  ATH_MSG_WARNING("You're using the LowPt muon selection, which is not supported yet in terms of muon trigger scale facorts. TEMPORAIRLY configuring the muonTriggerSFTool for Medium muons. Beware!");
942  ATH_CHECK( m_muonTriggerSFTool.setProperty("MuonQuality", "Medium" ) );
943  }
944  else ATH_CHECK( m_muonTriggerSFTool.setProperty("MuonQuality", muQual) );
945  //ATH_CHECK( m_muonTriggerSFTool.setProperty("Isolation", m_muIso_WP)); This property has been depreacted long time ago
946  ATH_CHECK( m_muonTriggerSFTool.setProperty("AllowZeroSF", true) );
947  ATH_CHECK( m_muonTriggerSFTool.setProperty("OutputLevel", this->msg().level()) );
948  if(!m_muTriggerSFCalibRelease.empty() ) ATH_CHECK( m_muonTriggerSFTool.setProperty("CalibrationRelease",m_muTriggerSFCalibRelease) );
949  if(!m_muTriggerSFCalibFilename.empty()) ATH_CHECK( m_muonTriggerSFTool.setProperty("filename", m_muTriggerSFCalibFilename) );
950  ATH_CHECK( m_muonTriggerSFTool.retrieve() );
951  m_muonTrigSFTools.push_back(m_muonTriggerSFTool.getHandle());
952  } else if (m_muonTriggerSFTool.isUserConfigured()) {
953  ATH_CHECK( m_muonTriggerSFTool.retrieve() );
954  m_muonTrigSFTools.push_back(m_muonTriggerSFTool.getHandle());
955  }
956  }
957 
958  if (m_slices["ele"]) {
959  // /////////////////////////////////////////////////////////////////////////////////////////
960  // Initialise electron selector tools
961 
962  // Signal Electrons
963  if (!m_elecSelLikelihood.isUserConfigured()) {
964  toolName = "EleSelLikelihood_" + m_eleId;
965 
966  if (m_eleId.find("DNN") != std::string::npos) {
967  m_elecSelLikelihood.setTypeAndName("AsgElectronSelectorTool/"+toolName);
968  }
969  else {
970  m_elecSelLikelihood.setTypeAndName("AsgElectronLikelihoodTool/"+toolName);
971  }
972 
973  if (! m_eleConfig.empty() ){
974  ATH_MSG_INFO("Overriding specified Ele.Id working point in favour of configuration file");
975  ATH_CHECK( m_elecSelLikelihood.setProperty("ConfigFile", m_eleConfig) );
976  } else if ( !check_isOption(m_eleId, m_el_id_support) ) { //check if supported
977  ATH_MSG_ERROR("Invalid electron ID selected: " << m_eleId);
978  return StatusCode::FAILURE;
979  }
980  else if (m_eleId == "VeryLooseLLH" || m_eleId == "LooseLLH") {
981  ATH_MSG_WARNING(" ****************************************************************************");
982  ATH_MSG_WARNING(" CAUTION: Setting " << m_eleId << " as signal electron ID");
983  ATH_MSG_WARNING(" These may be used for loose electron CRs but no scale factors are provided.");
984  ATH_MSG_WARNING(" ****************************************************************************");
985  ATH_CHECK( m_elecSelLikelihood.setProperty("WorkingPoint", EG_WP(m_eleId) ));
986  } else {
987  ATH_CHECK( m_elecSelLikelihood.setProperty("WorkingPoint", EG_WP(m_eleId) ));
988  }
989 
990  ATH_CHECK( m_elecSelLikelihood.setProperty("OutputLevel", this->msg().level()) );
991  ATH_CHECK( m_elecSelLikelihood.retrieve() );
992  } else ATH_CHECK( m_elecSelLikelihood.retrieve() );
993 
994  // Baseline Electrons
995  if (!m_elecSelLikelihoodBaseline.isUserConfigured()) {
996  toolName = "EleSelLikelihoodBaseline_" + m_eleIdBaseline;
997 
998  if (m_eleIdBaseline.find("DNN") != std::string::npos) {
999  m_elecSelLikelihoodBaseline.setTypeAndName("AsgElectronSelectorTool/"+toolName);
1000  }
1001  else {
1002  m_elecSelLikelihoodBaseline.setTypeAndName("AsgElectronLikelihoodTool/"+toolName);
1003  }
1004 
1005  if (! m_eleConfigBaseline.empty() ){
1006  ATH_MSG_INFO("Overriding specified EleBaseline.Id working point in favour of configuration file");
1007  ATH_CHECK( m_elecSelLikelihoodBaseline.setProperty("ConfigFile", m_eleConfigBaseline ));
1008  } else if ( !check_isOption(m_eleIdBaseline, m_el_id_support) ) { //check if supported
1009  ATH_MSG_ERROR("Invalid electron ID selected: " << m_eleIdBaseline);
1010  return StatusCode::FAILURE;
1011  } else {
1012  ATH_CHECK( m_elecSelLikelihoodBaseline.setProperty("WorkingPoint", EG_WP(m_eleIdBaseline)) );
1013  }
1014 
1015  ATH_CHECK( m_elecSelLikelihoodBaseline.setProperty("OutputLevel", this->msg().level()) );
1016  ATH_CHECK( m_elecSelLikelihoodBaseline.retrieve() );
1017  } else ATH_CHECK( m_elecSelLikelihoodBaseline.retrieve() );
1018  }
1019 
1021  // Initialise prompt/LRT electron OR tool
1022  if (!m_elecLRTORTool.isUserConfigured()) {
1023  toolName = "ElectronLRTOverlapRemovalTool";
1024  m_elecLRTORTool.setTypeAndName("CP::ElectronLRTOverlapRemovalTool/"+toolName);
1025  ATH_MSG_DEBUG("Setting ElectronLRTOverlapRemovalTool strategy to "<<m_eleLRT_strat);
1026  ATH_CHECK( m_elecLRTORTool.setProperty("overlapStrategy", m_eleLRT_strat) );
1027  ATH_CHECK( m_elecLRTORTool.retrieve() );
1028  } else ATH_CHECK( m_elecLRTORTool.retrieve() );
1029 
1030  if (m_slices["pho"]) {
1031  // /////////////////////////////////////////////////////////////////////////////////////////
1032  // Initialise photon selector tools
1033 
1034  if (!m_photonSelIsEM.isUserConfigured()) {
1035  toolName = "PhotonSelIsEM_" + m_photonId;
1036  m_photonSelIsEM.setTypeAndName("AsgPhotonIsEMSelector/"+toolName);
1037 
1038  if (!check_isOption(m_photonId, m_ph_id_support)){ //check if supported
1039  ATH_MSG_ERROR("Invalid photon ID selected: " << m_photonId);
1040  return StatusCode::FAILURE;
1041  }
1042 
1043  ATH_CHECK( m_photonSelIsEM.setProperty("WorkingPoint", m_photonId+"Photon") );
1044  ATH_CHECK( m_photonSelIsEM.setProperty("OutputLevel", this->msg().level()) );
1045  ATH_CHECK( m_photonSelIsEM.retrieve() );
1046  } else ATH_CHECK( m_photonSelIsEM.retrieve() );
1047 
1048  if (!m_photonSelIsEMBaseline.isUserConfigured()) {
1049  toolName = "PhotonSelIsEMBaseline_" + m_photonIdBaseline;
1050  m_photonSelIsEMBaseline.setTypeAndName("AsgPhotonIsEMSelector/"+toolName);
1051 
1052  if(!check_isOption(m_photonIdBaseline, m_ph_id_support)){ //check if supported
1053  ATH_MSG_ERROR("Invalid photon ID selected: " << m_photonIdBaseline);
1054  return StatusCode::FAILURE;
1055  }
1056 
1057  ATH_CHECK( m_photonSelIsEMBaseline.setProperty("WorkingPoint", m_photonIdBaseline+"Photon") );
1058  ATH_CHECK( m_photonSelIsEMBaseline.setProperty("OutputLevel", this->msg().level()) );
1059  ATH_CHECK( m_photonSelIsEMBaseline.retrieve() );
1060  } else ATH_CHECK( m_photonSelIsEMBaseline.retrieve() );
1061  }
1062 
1063  if (m_slices["ele"]||m_slices["pho"]) {
1065  // Initialise DeadHVCellRemovalTool
1066  // https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/EGammaIdentificationRun2#Removal_of_Electron_Photon_clust
1067 
1068  ATH_MSG_DEBUG("Setup AsgDeadHVCellRemovalTool/deadHVTool");
1069  m_deadHVTool.setTypeAndName("AsgDeadHVCellRemovalTool/deadHVTool");
1070  ATH_CHECK(m_deadHVTool.retrieve());
1071  }
1072 
1073  if (m_slices["ele"]) {
1075  // Initialise electron efficiency tool
1076 
1077  PATCore::ParticleDataType::DataType data_type(PATCore::ParticleDataType::Data);
1078  if (!isData()) {
1079  if (isAtlfast()) data_type = PATCore::ParticleDataType::Fast;
1080  else data_type = PATCore::ParticleDataType::Full;
1081  ATH_MSG_DEBUG( "Setting data type to " << data_type);
1082  }
1083 
1084  m_eleEffMapFilePathRun2 = "ElectronEfficiencyCorrection/2015_2018/rel21.2/Precision_Summer2020_v1/map4.txt";
1085 
1086  if(!m_isRun3) {
1087  ATH_MSG_INFO( "Running on Run2 samples; Using egamma SF tools from R21 map ");
1088  ATH_MSG_INFO( m_eleEffMapFilePathRun2);
1089  }
1090 
1091  toolName = "AsgElectronEfficiencyCorrectionTool_reco";
1092  CONFIG_EG_EFF_TOOL_KEY(m_elecEfficiencySFTool_reco, toolName, "RecoKey", "Reconstruction", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2);
1093 
1094  //-- get KEYS supported by egamma SF tools
1095  std::vector<std::string> eSF_keys = getElSFkeys( m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2);
1096 
1097  if (m_eleId.find("NoPix") != std::string::npos || m_eleId == "VeryLooseLLH" || m_eleId == "LooseLLH" || m_eleId == "Medium") {
1098  ATH_MSG_WARNING("Not configuring electron ID and trigger scale factors for " << m_eleId);
1099  }
1100  else {
1101  // This needs to be formatted for the scale factors: no _Rel20, no LH label, etc.
1102  std::string eleId = TString(m_eleId).ReplaceAll("AndBLayer", "BLayer").ReplaceAll("LLH", "").Data();
1103 
1104  if (m_eleId.find("DNN") != std::string::npos) {
1105  eleId = TString(eleId).ReplaceAll("DNNnoCF", "").ReplaceAll("DNN", "").ReplaceAll("Loose", "LooseBLayer").Data();
1106  ATH_MSG_WARNING("Electron DNN ID working point " << m_eleId << " doesn't have SFs yet, fall back to " << eleId);
1107  }
1108 
1109  // electron id
1110  toolName = "AsgElectronEfficiencyCorrectionTool_id_" + m_eleId;
1111  CONFIG_EG_EFF_TOOL_KEY(m_elecEfficiencySFTool_id, toolName, "IdKey", eleId, m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2);
1112 
1113  // override map file use if correction file list is set for WP
1114  std::map<std::string,std::string> corrFNList;
1115  if ( !m_EG_corrFNList.empty() ) {
1116  for ( const auto& WP_fname : split( m_EG_corrFNList, "," ) ) {
1117  std::string WP = WP_fname.substr(0,WP_fname.find(":"));
1118  std::string fname = WP_fname.substr(WP_fname.find(":")+1);
1119  corrFNList[WP] = fname;
1120  ATH_MSG_WARNING( "Correction file list defined for WP " << WP << ": " << fname << "." );
1121  ATH_MSG_WARNING( "Will use correction file rather than central map file." );
1122  }
1123  }
1124 
1125  // electron iso
1126  std::string EleIso("");
1127  if (std::find(eSF_keys.begin(), eSF_keys.end(), eleId+"_"+m_eleIso_WP) != eSF_keys.end()){
1128  EleIso = m_eleIso_WP;
1129  } else if (std::find(eSF_keys.begin(), eSF_keys.end(), eleId+"_"+m_el_iso_fallback[m_eleIso_WP]) != eSF_keys.end()){
1130  //--- Check to see if the only issue is an unknown isolation working point
1131  EleIso = m_el_iso_fallback[m_eleIso_WP];
1132  ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool_iso_*) Your selected electron Iso WP ("
1133  << m_eleIso_WP
1134  << ") does not have iso SFs defined. Falling back to "
1135  << m_el_iso_fallback[m_eleIso_WP]
1136  << " for SF calculations");
1137  }
1138  else{
1139  ATH_MSG_ERROR("*** THE ELECTRON ISOLATION SF YOU SELECTED (" << m_eleIso_WP << ") GOT NO SUPPORT ***");
1140  return StatusCode::FAILURE;
1141  }
1142 
1143  toolName = "AsgElectronEfficiencyCorrectionTool_iso_" + m_eleId + EleIso;
1144 
1145  // if running with correction file list
1146  if ( (!m_EG_corrFNList.empty()) && corrFNList.find(EleIso)!=corrFNList.end() ) { // overriding central map file
1147  CONFIG_EG_EFF_TOOL( m_elecEfficiencySFTool_iso, toolName, corrFNList[EleIso] );
1148  }
1149  // can't do the iso tool via the macro, it needs two properties set
1150  else { // default: use map file
1151  if ( !m_elecEfficiencySFTool_iso.isUserConfigured() ) {
1152  if ( !check_isOption(EleIso, m_el_iso_support) ) { //check if supported
1153  ATH_MSG_WARNING( "(" << toolName << ") Your electron Iso WP: " << EleIso<< " is no longer supported. This will almost certainly cause a crash now.");
1154  }
1155 
1156  m_elecEfficiencySFTool_iso.setTypeAndName("AsgElectronEfficiencyCorrectionTool/"+toolName);
1157 
1158  if ( m_EG_corrFNList.empty() ) {
1159  ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
1160  } else {
1161  ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("CorrectionFileNameList", corrFNList) );
1162  }
1163  ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("IdKey", eleId) );
1164  ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("IsoKey", EleIso) );
1165  if (!isData() && ((EleIso.find("TightTrackOnly_VarRad")!=std::string::npos)||
1166  (EleIso.find("TightTrackOnly_FixedRad")!=std::string::npos)||
1167  (EleIso.find("Tight_VarRad")!=std::string::npos)||
1168  (EleIso.find("Loose_VarRad")!=std::string::npos))) {
1169  if (isAtlfast()) ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool/"+toolName+"). Your selected electron Iso WP (" + EleIso + ") don't have AFII SF. Falling back to FullSim");
1170  ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("ForceDataType", static_cast<int>(PATCore::ParticleDataType::Full)));
1171  }
1172  else if (!isData()){
1173  ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("ForceDataType", static_cast<int>(data_type)));
1174  }
1175  ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("CorrelationModel", m_EG_corrModel) );
1176  ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("OutputLevel", this->msg().level()) );
1177  ATH_CHECK( m_elecEfficiencySFTool_iso.initialize() );
1178  } else ATH_CHECK( m_elecEfficiencySFTool_iso.initialize() );
1179  }
1180 
1181  // electron iso high-pt
1182  std::string EleIsohighPt("");
1183  if (std::find(eSF_keys.begin(), eSF_keys.end(), eleId+"_"+m_eleIsoHighPt_WP) != eSF_keys.end()){
1184  EleIsohighPt = m_eleIsoHighPt_WP;
1185  } else if (std::find(eSF_keys.begin(), eSF_keys.end(), eleId+"_"+m_el_iso_fallback[m_eleIsoHighPt_WP]) != eSF_keys.end()){
1186  //--- Check to see if the only issue is an unknown isolation working point
1187  EleIsohighPt = m_el_iso_fallback[m_eleIsoHighPt_WP];
1188  ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool_iso_*) Your selected high-pT electron Iso WP ("
1189  << m_eleIsoHighPt_WP
1190  << ") does not have iso SFs defined. Falling back to "
1191  << m_el_iso_fallback[m_eleIsoHighPt_WP]
1192  << " for SF calculations");
1193  }
1194  else{
1195  ATH_MSG_ERROR("*** THE HIGH PT ELECTRON ISOLATION SF YOU SELECTED (" << m_eleIsoHighPt_WP << ") GOT NO SUPPORT");
1196  return StatusCode::FAILURE;
1197  }
1198 
1199  toolName = "AsgElectronEfficiencyCorrectionTool_isoHigPt_" + m_eleId + EleIsohighPt;
1200 
1201  // if running with correction file list
1202  if ( (!m_EG_corrFNList.empty()) && corrFNList.find(EleIsohighPt)!=corrFNList.end() ) { // overriding central map file
1203  CONFIG_EG_EFF_TOOL( m_elecEfficiencySFTool_isoHighPt, toolName, corrFNList[EleIsohighPt] );
1204  }
1205  // can't do the iso tool via the macro, it needs two properties set
1206  else { // default: use map file
1207  if ( !m_elecEfficiencySFTool_isoHighPt.isUserConfigured() ) {
1208 
1209  if ( !check_isOption(EleIsohighPt, m_el_iso_support) ) { //check if supported
1210  ATH_MSG_WARNING( "(" << toolName << ") Your electron high-pt Iso WP: " << EleIsohighPt << " is no longer supported. This will almost certainly cause a crash now.");
1211  }
1212 
1213  m_elecEfficiencySFTool_isoHighPt.setTypeAndName("AsgElectronEfficiencyCorrectionTool/"+toolName);
1214 
1215  ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
1216  ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.setProperty("IdKey", eleId) );
1217  ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.setProperty("IsoKey", EleIsohighPt) );
1218  if (!isData()) {
1219  ATH_CHECK (m_elecEfficiencySFTool_isoHighPt.setProperty("ForceDataType", (int) data_type) );
1220  }
1221  ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.setProperty("CorrelationModel", m_EG_corrModel) );
1222  ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.setProperty("OutputLevel", this->msg().level()) );
1223  ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.initialize() );
1224  } else ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.initialize() );
1225  }
1226 
1227  // electron triggers - first SFs (but we need to massage the id string since all combinations are not supported)
1228 
1229  //single lepton
1230 
1231  if(m_isRun3 && eleId.find("LooseBLayer") != std::string::npos) ATH_MSG_WARNING("Replacing 'LooseBLayer' with 'Loose' for Electron ID while configuring single-ele trigger SF using: " << m_eleEffMapFilePath);
1232  std::string triggerEleID = m_isRun3? TString(eleId).ReplaceAll("LooseBLayer", "Loose").Data() : eleId;
1233  std::string triggerEleIso= m_eleIso_WP;
1234 
1235  // This is an hack to work with ElectronEfficiencyCorrection/2015_2025/rel22.2/2022_Summer_Prerecom_v1/map4.txt to allow
1236 
1237  if(m_isRun3 && m_eleAllowRun3TrigSFFallback){
1238  bool pass_isRun3TrigSFFallback = true;
1239  if (triggerEleID.find("Medium") != std::string::npos && triggerEleIso.find("Loose") != std::string::npos) {triggerEleID = "Loose";}
1240  else if (triggerEleID.find("Medium") != std::string::npos && triggerEleIso.find("Tight") != std::string::npos) {triggerEleID = "Tight"; triggerEleIso = "Tight_VarRad";}
1241  else if (triggerEleID.find("Medium") != std::string::npos && triggerEleIso.find("HighPtCaloOnly") != std::string::npos) {triggerEleID = "Tight"; triggerEleIso = "Tight_VarRad";}
1242  else if (triggerEleID.find("Tight") != std::string::npos && triggerEleIso.find("Loose") != std::string::npos) {triggerEleID = "Loose";}
1243  else if (triggerEleID.find("Tight") != std::string::npos && triggerEleIso.find("Tight") != std::string::npos) {triggerEleIso= "Tight_VarRad";}
1244  else if (triggerEleID.find("Tight") != std::string::npos && triggerEleIso.find("HighPtCaloOnly") != std::string::npos) {triggerEleID = "Tight"; triggerEleIso = "Tight_VarRad";}
1245  else if (triggerEleID.find("Loose") != std::string::npos && triggerEleIso.find("Tight") != std::string::npos) {triggerEleID = "Loose"; triggerEleIso = "Loose_VarRad";}
1246  else if (triggerEleID.find("Loose") != std::string::npos && triggerEleIso.find("HighPtCaloOnly") != std::string::npos) {triggerEleID = "Loose"; triggerEleIso = "Loose_VarRad";}
1247  else {pass_isRun3TrigSFFallback=false;}
1248  if(pass_isRun3TrigSFFallback){
1249  ATH_MSG_INFO(" ************** This is only for testing/studying purpose! ************** ");
1250  ATH_MSG_INFO(" ************** For official recommendation, please get in contact with the SUSY Bkg Forum ************** ");
1251  ATH_MSG_INFO("In the current map ("<<m_eleEffMapFilePath<<"), the only supported Electron ID working-points supported for Electron Trigger Scale Factor are 'Loose_Loose_VarRad' and 'Tight_Tight_VarRad' ");
1252  ATH_MSG_INFO("Only for single-lepton trigger scale factor, fall back to Electron ID: -> "<< triggerEleID << " with Isolation: " << triggerEleIso);
1253  }
1254  }
1255 
1256  // The L1 seed changed from 2023 and beyond, so we need to adjust the trigger key accordingly, the SF are now derived by year so we need to change the year in the key as well.
1257 
1258  if(m_isRun3){
1259  // Find year positions (or npos if not present)
1260  size_t p22 = m_electronTriggerSFStringSingle.find("2022");
1261  size_t p23 = m_electronTriggerSFStringSingle.find("2023");
1262  size_t p24 = m_electronTriggerSFStringSingle.find("2024");
1263 
1264  auto next_pos = [&](size_t self) {
1265  size_t next = std::string::npos;
1266 
1267  if (self == p22) {
1268  if (p23 > self && p23 < next) next = p23;
1269  if (p24 > self && p24 < next) next = p24;
1270  }
1271  else if (self == p23) {
1272  if (p22 > self && p22 < next) next = p22;
1273  if (p24 > self && p24 < next) next = p24;
1274  }
1275  else if (self == p24) {
1276  if (p22 > self && p22 < next) next = p22;
1277  if (p23 > self && p23 < next) next = p23;
1278  }
1279 
1280  return next;
1281  };
1282  std::string SFStringSingle22="";
1283  std::string SFStringSingle23="";
1284  std::string SFStringSingle24="";
1285 
1286  // Extract 2022,2023,2025 block
1287  if (p22 != std::string::npos) {size_t end = next_pos(p22); SFStringSingle22 = m_electronTriggerSFStringSingle.substr(p22, end - p22);}
1288  if (p23 != std::string::npos) {size_t end = next_pos(p23); SFStringSingle23 = m_electronTriggerSFStringSingle.substr(p23, end - p23);}
1289  if (p24 != std::string::npos) {size_t end = next_pos(p24); SFStringSingle24 = m_electronTriggerSFStringSingle.substr(p24, end - p24);}
1290 
1291  // Remove trailing underscores from tokens if present
1292  std::string* toks[] = { &SFStringSingle22, &SFStringSingle23, &SFStringSingle24 };
1293  for (auto t : toks) {
1294  while (!t->empty() && t->back() == '_') t->pop_back();
1295  }
1296 
1297  if(m_mcCampaign == "mc23a") m_electronTriggerSFStringSingle = SFStringSingle22;
1298  else if(m_mcCampaign == "mc23d") m_electronTriggerSFStringSingle = SFStringSingle23;
1299  else if(m_mcCampaign == "mc23e") m_electronTriggerSFStringSingle = SFStringSingle24;
1300  else {
1301  ATH_MSG_WARNING("Unknown or unsupported mcCampaign for Run 3: " << m_mcCampaign << ". Please contact the SUSY Bkg Forum for assistance.");
1302  ATH_MSG_WARNING("Falling back to 2024 trigger SFs for single-electron triggers.");
1303  m_electronTriggerSFStringSingle = SFStringSingle24;
1304  }
1305  }
1306 
1307 
1308  ATH_MSG_INFO("eSF_keys: " << m_electronTriggerSFStringSingle<< "_"<<triggerEleID<<"_"<<triggerEleIso);
1309 
1310  if (std::find(eSF_keys.begin(), eSF_keys.end(), m_electronTriggerSFStringSingle+"_"+triggerEleID+"_"+triggerEleIso) != eSF_keys.end()){
1311  triggerEleIso = m_eleIso_WP;
1312  } else if (std::find(eSF_keys.begin(), eSF_keys.end(), m_electronTriggerSFStringSingle+"_"+triggerEleID+"_"+m_el_iso_fallback[triggerEleIso]) != eSF_keys.end()){
1313  //--- Check to see if the only issue is an unknown isolation working point
1314  triggerEleIso = m_el_iso_fallback[triggerEleIso];
1315  ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool_trig_singleLep_*) Your selected electron Iso WP ("
1316  << m_eleIso_WP
1317  << ") does not have trigger SFs defined. Falling back to "
1318  << triggerEleIso
1319  << " for SF calculations");
1320  }
1321  else{
1322  ATH_MSG_ERROR("*** THE SINGLE ELECTRON TRIGGER SF YOU SELECTED (" << m_electronTriggerSFStringSingle << ") GOT NO SUPPORT FOR YOUR ID+ISO WPs (" << m_eleId << "+" << m_eleIso_WP << ") ***");
1323  return StatusCode::FAILURE;
1324  }
1325 
1326  toolName = "AsgElectronEfficiencyCorrectionTool_trig_singleLep_" + triggerEleID;
1327  if ( !m_elecEfficiencySFTool_trig_singleLep.isUserConfigured() ) {
1328  m_elecEfficiencySFTool_trig_singleLep.setTypeAndName("AsgElectronEfficiencyCorrectionTool/"+toolName);
1329  ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
1330  ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("TriggerKey", m_electronTriggerSFStringSingle) );
1331  ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("IdKey", triggerEleID) );
1332  ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("IsoKey", triggerEleIso) );
1333  ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("CorrelationModel", m_EG_corrModel) );
1334  if (!isData()) {
1335  ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("ForceDataType", (int) (data_type==PATCore::ParticleDataType::Fast)? PATCore::ParticleDataType::Full : data_type) );
1336  }
1337  ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("OutputLevel", this->msg().level()) );
1338  ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.initialize() );
1339  } else ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.retrieve() );
1340 
1341 
1342  toolName = "AsgElectronEfficiencyCorrectionTool_trigEff_singleLep_" + triggerEleID;
1343  if ( !m_elecEfficiencySFTool_trigEff_singleLep.isUserConfigured() ) {
1344  m_elecEfficiencySFTool_trigEff_singleLep.setTypeAndName("AsgElectronEfficiencyCorrectionTool/"+toolName);
1345  ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
1346  ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("TriggerKey", "Eff_"+m_electronTriggerSFStringSingle) );
1347  ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("IdKey", triggerEleID) );
1348  ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("IsoKey", triggerEleIso) );
1349  ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("CorrelationModel", m_EG_corrModel) );
1350  if (!isData()) {
1351  ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("ForceDataType", (int) (data_type==PATCore::ParticleDataType::Fast)? PATCore::ParticleDataType::Full : data_type) );
1352  }
1353  ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("OutputLevel", this->msg().level()) );
1354  ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.initialize() );
1355  } else ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.retrieve() );
1356 
1357  if (!m_isRun3){
1358  //mixed-leptons
1359  std::map<std::string,std::string> electronTriggerSFMapMixedLepton {
1360  // legs, Trigger keys,
1361  {"e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose,e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0", m_electronTriggerSFStringSingle},
1362  {"e24_lhvloose_nod0_L1EM20VH,e17_lhvloose_nod0,e12_lhloose_L1EM10VH","DI_E_2015_e12_lhloose_L1EM10VH_2016_e17_lhvloose_nod0_2017_2018_e24_lhvloose_nod0_L1EM20VH"},
1363  {"e26_lhmedium_nod0_L1EM22VHI,e26_lhmedium_nod0","MULTI_L_2015_e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose_2016_e26_lhmedium_nod0_L1EM22VHI_2017_2018_e26_lhmedium_nod0"},
1364  {"e17_lhloose,e17_lhloose_nod0","MULTI_L_2015_e17_lhloose_2016_2018_e17_lhloose_nod0"},
1365  {"e12_lhloose,e12_lhloose_nod0","MULTI_L_2015_e12_lhloose_2016_2018_e12_lhloose_nod0"},
1366  {"e7_lhmedium,e7_lhmedium_nod0","MULTI_L_2015_e7_lhmedium_2016_2018_e7_lhmedium_nod0"},
1367  {"e9_lhloose,e9_lhloose_nod0,e12_lhvloose_nod0_L1EM10VH","TRI_E_2015_e9_lhloose_2016_e9_lhloose_nod0_2017_2018_e12_lhvloose_nod0_L1EM10VH"}
1368 
1369  };
1370 
1371  // 2e17 trigger is used in 2017 or 2018?
1372  std::string triglist_2017to2018 = m_trig2017combination_diLep + "_" + m_trig2018combination_diLep + "_" + m_trig2017combination_multiLep + "_" + m_trig2018combination_multiLep;
1373  if (triglist_2017to2018.find("2e17_lhvloose_nod0_L12EM15VHI") != std::string::npos) {
1374  electronTriggerSFMapMixedLepton["e17_lhvloose_nod0_L1EM15VHI"] = "DI_E_2015_e12_lhloose_L1EM10VH_2016_e17_lhvloose_nod0_2017_2018_e17_lhvloose_nod0_L1EM15VHI";
1375  }
1376 
1377  std::string triggerMixedEleIso("");
1378 
1379  for(auto const& item : electronTriggerSFMapMixedLepton){
1380 
1381  if (std::find(eSF_keys.begin(), eSF_keys.end(), item.second+"_"+eleId+"_"+m_eleIso_WP) != eSF_keys.end()){
1382  triggerMixedEleIso = m_eleIso_WP;
1383  } else if (std::find(eSF_keys.begin(), eSF_keys.end(), item.second+"_"+eleId+"_"+m_el_iso_fallback[m_eleIso_WP]) != eSF_keys.end()){
1384  //--- Check to see if the only issue is an unknown isolation working point
1385  triggerMixedEleIso = m_el_iso_fallback[m_eleIso_WP];
1386  ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool_trig_mixLep_*) Your selected electron Iso WP ("
1387  << m_eleIso_WP
1388  << ") does not have trigger SFs defined. Falling back to "
1389  << triggerMixedEleIso
1390  << " for SF calculations");
1391  } else {
1392  ATH_MSG_ERROR("*** THE MIXED ELECTRON TRIGGER SF YOU SELECTED (" << item.second << ") GOT NO SUPPORT FOR YOUR ID+ISO WPs (" << m_eleId << "+" << m_eleIso_WP << "). The fallback options failed as well sorry! ***");
1393  return StatusCode::FAILURE;
1394  }
1395 
1396  ATH_MSG_VERBOSE ("Selected WP: " << item.second << "_" << eleId << "_" << triggerMixedEleIso);
1397 
1398  toolName = "AsgElectronEfficiencyCorrectionTool_trig_mixLep_" + (item.first).substr(0,8) + m_eleId;
1399  auto t_sf = m_elecEfficiencySFTool_trig_mixLep.emplace(m_elecEfficiencySFTool_trig_mixLep.end(), "AsgElectronEfficiencyCorrectionTool/"+toolName);
1400  ATH_CHECK( t_sf->setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
1401  ATH_CHECK( t_sf->setProperty("TriggerKey", item.second) );
1402  ATH_CHECK( t_sf->setProperty("IdKey", eleId) );
1403  ATH_CHECK( t_sf->setProperty("IsoKey", triggerMixedEleIso) );
1404  ATH_CHECK( t_sf->setProperty("CorrelationModel", m_EG_corrModel) );
1405  if (!isData()) {
1406  ATH_CHECK( t_sf->setProperty("ForceDataType", (int) (data_type==PATCore::ParticleDataType::Fast)? PATCore::ParticleDataType::Full : data_type) );
1407  }
1408  ATH_CHECK( t_sf->setProperty("OutputLevel", this->msg().level()) );
1409  ATH_CHECK( t_sf->initialize() );
1410  m_elecTrigSFTools.push_back(t_sf->getHandle());
1411  #ifndef XAOD_STANDALONE
1412  m_legsPerTool[toolName] = item.first;
1413  #else
1414  m_legsPerTool["ToolSvc."+toolName] = item.first;
1415  #endif
1416 
1417  toolName = "AsgElectronEfficiencyCorrectionTool_trigEff_mixLep_" + (item.first).substr(0,8) + m_eleId;
1418  auto t_eff = m_elecEfficiencySFTool_trigEff_mixLep.emplace(m_elecEfficiencySFTool_trigEff_mixLep.end(), "AsgElectronEfficiencyCorrectionTool/"+toolName);
1419  ATH_CHECK( t_eff->setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
1420  ATH_CHECK( t_eff->setProperty("TriggerKey", "Eff_"+item.second) );
1421  ATH_CHECK( t_eff->setProperty("IdKey", eleId) );
1422  ATH_CHECK( t_eff->setProperty("IsoKey", triggerMixedEleIso) );
1423  ATH_CHECK( t_eff->setProperty("CorrelationModel", m_EG_corrModel) );
1424  if (!isData()) {
1425  ATH_CHECK( t_eff->setProperty("ForceDataType", (int) (data_type==PATCore::ParticleDataType::Fast)? PATCore::ParticleDataType::Full : data_type) );
1426  }
1427  ATH_CHECK( t_eff->setProperty("OutputLevel", this->msg().level()) );
1428  ATH_CHECK( t_eff->initialize() );
1429  m_elecTrigEffTools.push_back(t_eff->getHandle());
1430  #ifndef XAOD_STANDALONE
1431  m_legsPerTool[toolName] = item.first;
1432  #else
1433  m_legsPerTool["ToolSvc."+toolName] = item.first;
1434  #endif
1435 
1436  }
1437  }
1438  else ATH_MSG_WARNING("*** THE ELECTRON TRIGGER SF MIXED AND SF DILEP ARE CURRENTY NOT SUPPORTED IN RUN3 ***");
1439 
1440  ATH_MSG_WARNING("*** THE ELECTRON CHARGE FLIP SF ARE CURRENTY NOT SUPPORTED ***");
1441  // all the iinitialisation of the related tools have been cleaned up
1442 
1443  }
1444 
1445  if (m_slices["pho"]) {
1446  // /////////////////////////////////////////////////////////////////////////////////////////
1447  // Initialise photon efficiency tool
1448 
1449  if (!m_photonEfficiencySFTool.isUserConfigured() && !isData()) {
1450  m_photonEfficiencySFTool.setTypeAndName("AsgPhotonEfficiencyCorrectionTool/AsgPhotonEfficiencyCorrectionTool_" + m_photonId);
1451 
1452  if (m_photonId != "Tight" ) {
1453  ATH_MSG_WARNING( "No Photon efficiency available for " << m_photonId << ", using Tight instead..." );
1454  }
1455 
1456  ATH_CHECK( m_photonEfficiencySFTool.setProperty("MapFilePath", "PhotonEfficiencyCorrection/2015_2025/rel22.2/2024_FinalRun2_Recommendation_v1/map1.txt") );
1457  ATH_CHECK( m_photonEfficiencySFTool.setProperty("ForceDataType", isAtlfast()? (m_isRun3? 1: 3) : 1) ); // Set data type: 1 for FULLSIM, 3 for AtlFast. For Run3 pre-rec only FullSim SFs are available
1458  ATH_CHECK( m_photonEfficiencySFTool.setProperty("OutputLevel", this->msg().level()) );
1459  ATH_CHECK( m_photonEfficiencySFTool.retrieve() );
1460  } else if (m_photonEfficiencySFTool.isUserConfigured()) ATH_CHECK( m_photonEfficiencySFTool.retrieve() );
1461 
1462  if (!m_photonIsolationSFTool.isUserConfigured() && !isData()) {
1463  m_photonIsolationSFTool.setTypeAndName("AsgPhotonEfficiencyCorrectionTool/AsgPhotonEfficiencyCorrectionTool_isol" + m_photonIso_WP);
1464 
1465  if (m_photonIso_WP != "FixedCutTight" && m_photonIso_WP != "FixedCutLoose" && m_photonIso_WP != "TightCaloOnly") {
1466  ATH_MSG_WARNING( "No Photon efficiency available for " << m_photonIso_WP);
1467  }
1468 
1469  ATH_CHECK( m_photonIsolationSFTool.setProperty("MapFilePath", "PhotonEfficiencyCorrection/2015_2025/rel22.2/2022_Summer_Prerecom_v1/map1.txt") );
1470  ATH_CHECK( m_photonIsolationSFTool.setProperty("IsoKey", m_photonIso_WP != "TightCaloOnly" ? m_photonIso_WP.substr(8) : m_photonIso_WP )); // Set isolation WP: Loose,Tight,TightCaloOnly
1471  ATH_CHECK( m_photonIsolationSFTool.setProperty("ForceDataType", 1) ); // Set data type: 1 for FULLSIM, 3 for AF2
1472  ATH_CHECK( m_photonIsolationSFTool.setProperty("OutputLevel", this->msg().level()) );
1473  ATH_CHECK( m_photonIsolationSFTool.retrieve() );
1474  } else if (m_photonEfficiencySFTool.isUserConfigured()) ATH_CHECK( m_photonIsolationSFTool.retrieve() );
1475 
1476  // trigger scale factors
1477  if (!m_photonTriggerSFTool.isUserConfigured() && !isData()) {
1478  m_photonTriggerSFTool.setTypeAndName("AsgPhotonEfficiencyCorrectionTool/AsgPhotonEfficiencyCorrectionTool_trig" + m_photonTriggerName);
1479 
1480  // Fallback to TightCaloOnly if Tight is selected
1481  std::string photonIso_forTrigSF = m_photonIso_WP;
1482  if (m_photonIso_WP == "FixedCutTight") {
1483  ATH_MSG_WARNING( "No Photon trigger SF available for " << m_photonIso_WP << ", using TightCaloOnly instead... Use at your own risk" );
1484  photonIso_forTrigSF = "TightCaloOnly";
1485  } else { // isolation WP supported: Loose or TightCaloOnly, removing "FixedCut" suffix..
1486  photonIso_forTrigSF = TString(m_photonIso_WP).ReplaceAll("FixedCut","").Data();
1487  }
1488 
1489  // "symmetric" diphoton triggers (year dependent)
1490  ATH_CHECK( m_photonTriggerSFTool.setProperty("MapFilePath", "PhotonEfficiencyCorrection/2015_2018/rel21.2/Summer2020_Rec_v1/map3.txt") );
1491  ATH_CHECK( m_photonTriggerSFTool.setProperty("IsoKey", photonIso_forTrigSF )); // Set isolation WP: Loose,TightCaloOnly
1492  ATH_CHECK( m_photonTriggerSFTool.setProperty("TriggerKey", m_photonTriggerName ));
1493  ATH_CHECK( m_photonTriggerSFTool.setProperty("ForceDataType", 1) ); // Set data type: 1 for FULLSIM, 3 for AF2
1494  ATH_CHECK( m_photonTriggerSFTool.setProperty("OutputLevel", this->msg().level()) );
1495  ATH_CHECK( m_photonTriggerSFTool.retrieve() );
1496 
1497  // "asymmetric" diphoton triggers
1498  std::map<std::string,std::string> diphotonTriggerSFMapAsymmetric {
1499  // legs, Trigger keys,
1500  {"g25_loose,g25_medium_L1EM20VH", "DI_PH_2015_g25_loose_2016_g25_loose_2017_g25_medium_L1EM20VH_2018_g25_medium_L1EM20VH"},
1501  {"g35_loose,g35_medium_L1EM20VH", "DI_PH_2015_g35_loose_2016_g35_loose_2017_g35_medium_L1EM20VH_2018_g35_medium_L1EM20VH"},
1502  };
1503 
1504  for(auto const& item : diphotonTriggerSFMapAsymmetric){
1505 
1506  toolName = "AsgPhotonEfficiencyCorrectionTool_trigSF_asymm_diphoton_" + (item.first).substr(0,9) + photonIso_forTrigSF;
1507  auto ph_trigSF = m_photonEfficiencySFTool_trigSF_AsymDiphoton.emplace(m_photonEfficiencySFTool_trigSF_AsymDiphoton.end(), "AsgPhotonEfficiencyCorrectionTool/"+toolName);
1508  ATH_CHECK( ph_trigSF->setProperty("MapFilePath", "PhotonEfficiencyCorrection/2015_2018/rel21.2/Summer2020_Rec_v1/map3.txt") );
1509  ATH_CHECK( ph_trigSF->setProperty("IsoKey", photonIso_forTrigSF) );
1510  ATH_CHECK( ph_trigSF->setProperty("TriggerKey", item.second) );
1511  ATH_CHECK( ph_trigSF->setProperty("ForceDataType", 1) ); // Set DataType: 1 for FullSim and 3 for AFII
1512  ATH_CHECK( ph_trigSF->setProperty("OutputLevel", this->msg().level()) );
1513  ATH_CHECK( ph_trigSF->initialize() );
1514  m_photonTrigSFTools.push_back(ph_trigSF->getHandle());
1515  #ifndef XAOD_STANDALONE
1516  m_legsPerTool_ph[toolName] = item.first;
1517  #else
1518  m_legsPerTool_ph["ToolSvc."+toolName] = item.first;
1519  #endif
1520 
1521  toolName = "AsgPhotonEfficiencyCorrectionTool_trigEff_asymm_diphoton_" + (item.first).substr(0,9) + photonIso_forTrigSF;
1522  auto ph_trigEff = m_photonEfficiencySFTool_trigEff_AsymDiphoton.emplace(m_photonEfficiencySFTool_trigEff_AsymDiphoton.end(), "AsgPhotonEfficiencyCorrectionTool/"+toolName);
1523  ATH_CHECK( ph_trigEff->setProperty("MapFilePath", "PhotonEfficiencyCorrection/2015_2018/rel21.2/Summer2020_Rec_v1/map3.txt") );
1524  ATH_CHECK( ph_trigEff->setProperty("IsoKey", photonIso_forTrigSF) );
1525  ATH_CHECK( ph_trigEff->setProperty("TriggerKey", "Eff_"+item.second) );
1526  ATH_CHECK( ph_trigEff->setProperty("ForceDataType", 1) ); // Set DataType: 1 for FullSim and 3 for AFII
1527  ATH_CHECK( ph_trigEff->setProperty("OutputLevel", this->msg().level()) );
1528  ATH_CHECK( ph_trigEff->initialize() );
1529  m_photonTrigEffTools.push_back(ph_trigEff->getHandle());
1530  #ifndef XAOD_STANDALONE
1531  m_legsPerTool_ph[toolName] = item.first;
1532  #else
1533  m_legsPerTool_ph["ToolSvc."+toolName] = item.first;
1534  #endif
1535 
1536  }
1537  }
1538  }
1539 
1540  }
1541  if (m_slices["ele"] || m_slices["pho"]) {
1543  // Initialize the EgammaAmbiguityTool
1544 
1545  if (!m_egammaAmbiguityTool.isUserConfigured()) {
1546  m_egammaAmbiguityTool.setTypeAndName("EGammaAmbiguityTool/EGammaAmbiguityTool");
1547  ATH_CHECK( m_egammaAmbiguityTool.setProperty("OutputLevel", this->msg().level()) );
1548  ATH_CHECK( m_egammaAmbiguityTool.retrieve() );
1549  } else ATH_CHECK( m_egammaAmbiguityTool.retrieve() );
1550  }
1551 
1552 
1553  if (m_slices["ele"]) {
1554  //disable ///////////////////////////////////////////////////////////////////////////////////////////
1555  //disable // Initialize the AsgElectronChargeIDSelector
1556 
1557  //disable if (!m_elecChargeIDSelectorTool.isUserConfigured()) {
1558 
1559  //disable // For the selector, can use the nice function
1560  //disable std::string eleId = EG_WP(m_eleId);
1561  //disable m_elecChargeIDSelectorTool.setTypeAndName("AsgElectronChargeIDSelectorTool/ElectronChargeIDSelectorTool_"+eleId);
1562  //disable //default cut value for https://twiki.cern.ch/twiki/bin/view/AtlasProtected/ElectronChargeFlipTaggerTool
1563  //disable float BDTcut = -0.337671; // Loose 97%
1564  //disable if (m_eleChID_WP != "Loose" && !m_eleChID_WP.empty()) {
1565  //disable ATH_MSG_ERROR("Only Loose WP is supported in R21. Invalid ChargeIDSelector WP selected : " << m_eleChID_WP);
1566  //disable return StatusCode::FAILURE;
1567  //disable }
1568 
1569  //disable ATH_CHECK( m_elecChargeIDSelectorTool.setProperty("TrainingFile", "ElectronPhotonSelectorTools/ChargeID/ECIDS_20180731rel21Summer2018.root"));
1570  //disable ATH_CHECK( m_elecChargeIDSelectorTool.setProperty("CutOnBDT", BDTcut));
1571  //disable ATH_CHECK( m_elecChargeIDSelectorTool.setProperty("OutputLevel", this->msg().level()) );
1572  //disable ATH_CHECK( m_elecChargeIDSelectorTool.retrieve() );
1573  //disable } else ATH_CHECK( m_elecChargeIDSelectorTool.retrieve() );
1574 
1575 
1577  // Initialise egamma calibration tool
1578 
1579  if (!m_egammaCalibTool.isUserConfigured()) {
1580  m_egammaCalibTool.setTypeAndName("CP::EgammaCalibrationAndSmearingTool/EgammaCalibrationAndSmearingTool");
1581  ATH_MSG_DEBUG( "Initialising EgcalibTool " );
1582  ATH_CHECK( m_egammaCalibTool.setProperty("ESModel", m_isRun3 ? "es2024_Run3_v0" : "es2023_R22_Run2_v1") );
1583  ATH_CHECK( m_egammaCalibTool.setProperty("decorrelationModel", "1NP_v1") );
1584  // allows to bypass (intended) abort from of egamma calibration tool when configured for fastSim
1585  if (m_eleForceFullSimCalib) {
1586  ATH_MSG_WARNING( "Forcing EgcalibTool to use calibrations for full simulation" );
1587  ATH_CHECK( m_egammaCalibTool.setProperty("useFastSim", false) );
1588  }
1589  else {
1590  ATH_MSG_INFO("is Fast Sim:" << isAtlfast());
1591  ATH_CHECK( m_egammaCalibTool.setProperty("useFastSim", isAtlfast() ? 1 : 0) );
1592  }
1593  ATH_CHECK( m_egammaCalibTool.setProperty("OutputLevel", this->msg().level()) );
1594  ATH_CHECK( m_egammaCalibTool.retrieve() );
1595  } else ATH_CHECK( m_egammaCalibTool.retrieve() );
1596  }
1597 
1598 
1599  if (m_slices["tau"]) {
1601 
1603  // Initialise path to tau config file and config reader
1604 
1605  std::string inputfile = "";
1606  if (!m_tauConfigPath.empty() && (m_tauConfigPath!="default")) inputfile = m_tauConfigPath;
1607  else if (m_tauId == "rnn001") inputfile = "SUSYTools/tau_selection_rnn001.conf";
1608  else if (m_tauId == "VeryLoose") inputfile = "SUSYTools/tau_selection_veryloose.conf";
1609  else if (m_tauId == "Loose") inputfile = "SUSYTools/tau_selection_loose.conf";
1610  else if (m_tauId == "Medium") inputfile = "SUSYTools/tau_selection_medium.conf";
1611  else if (m_tauId == "Tight") inputfile = "SUSYTools/tau_selection_tight.conf";
1612  else {
1613  ATH_MSG_ERROR("Invalid tau ID selected: " << m_tauId);
1614  return StatusCode::FAILURE;
1615  }
1616 
1617  // Read in the config file so we can retrieve the fields later when configuring the efficiency tools
1618  if ( m_tauConfigReader.ReadFile( PathResolverFindCalibFile(inputfile).c_str(), EEnvLevel(0) ) ) {
1619  ATH_MSG_ERROR( "Error while reading tau config file : " << inputfile );
1620  return StatusCode::FAILURE;
1621  }
1622  else ATH_MSG_DEBUG( "Successfully read tau config file : " << inputfile );
1623 
1624 
1626  // Initialise tau selection tools
1627 
1628  if (!m_tauSelTool.isUserConfigured()) {
1629  toolName = "TauSelectionTool_" + m_tauId;
1630  m_tauSelTool.setTypeAndName("TauAnalysisTools::TauSelectionTool/"+toolName);
1631  ATH_CHECK( m_tauSelTool.setProperty("ConfigPath", inputfile) );
1632  ATH_CHECK( m_tauSelTool.setProperty("OutputLevel", this->msg().level()) );
1633  ATH_CHECK( m_tauSelTool.retrieve() );
1634  } else ATH_CHECK( m_tauSelTool.retrieve() );
1635 
1636 
1637  if (!m_tauSelToolBaseline.isUserConfigured()) {
1638  std::string inputfile = "";
1639  if (!m_tauConfigPathBaseline.empty() && (m_tauConfigPathBaseline!="default")) inputfile = m_tauConfigPathBaseline;
1640  else if (m_tauIdBaseline == "rnn001") inputfile = "SUSYTools/tau_selection_rnn001.conf";
1641  else if (m_tauIdBaseline == "VeryLoose") inputfile = "SUSYTools/tau_selection_veryloose.conf";
1642  else if (m_tauIdBaseline == "Loose") inputfile = "SUSYTools/tau_selection_loose.conf";
1643  else if (m_tauIdBaseline == "Medium") inputfile = "SUSYTools/tau_selection_medium.conf";
1644  else if (m_tauIdBaseline == "Tight") inputfile = "SUSYTools/tau_selection_tight.conf";
1645  else {
1646  ATH_MSG_ERROR("Invalid baseline tau ID selected: " << m_tauIdBaseline);
1647  return StatusCode::FAILURE;
1648  }
1649  toolName = "TauSelectionToolBaseline_" + m_tauIdBaseline;
1650  m_tauSelToolBaseline.setTypeAndName("TauAnalysisTools::TauSelectionTool/"+toolName);
1651  ATH_CHECK( m_tauSelToolBaseline.setProperty("ConfigPath", inputfile) );
1652 
1653  ATH_CHECK( m_tauSelToolBaseline.setProperty("OutputLevel", this->msg().level()) );
1654  ATH_CHECK( m_tauSelToolBaseline.retrieve() );
1655  } else ATH_CHECK( m_tauSelToolBaseline.retrieve() );
1656 
1657 
1659  // Initialise tau efficiency tool
1660 
1661  if (!m_tauEffTool.isUserConfigured() && !isData()) {
1662  toolName = "TauEffTool_" + m_tauId;
1663  m_tauEffTool.setTypeAndName("TauAnalysisTools::TauEfficiencyCorrectionsTool/"+toolName);
1664 
1665  std::vector<int> correction_types;
1666  // Read out the tau ID from the config file and map into the enum from tau CP
1667  std::string jetIDWP = m_tauConfigReader.GetValue("JetIDWP" ,"");
1668  ANA_MSG_DEBUG( "Found JetIDWP in tau config file : " << jetIDWP );
1669  int jet_id_lvl;
1670  if (jetIDWP == "JETIDNONE") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDNONE;
1671  else if (jetIDWP == "JETIDRNNVERYLOOSE") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDRNNVERYLOOSE;
1672  else if (jetIDWP == "JETIDRNNLOOSE") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDRNNLOOSE;
1673  else if (jetIDWP == "JETIDRNNMEDIUM") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDRNNMEDIUM;
1674  else if (jetIDWP == "JETIDRNNTIGHT") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDRNNTIGHT;
1675  else {
1676  ATH_MSG_ERROR("Invalid Tau ID in tau config file " << jetIDWP);
1677  return StatusCode::FAILURE;
1678  }
1679  // Add retrieval of reco and ID SFs
1680  correction_types.insert(correction_types.end(), {TauAnalysisTools::EfficiencyCorrectionType::SFRecoHadTau,
1681  TauAnalysisTools::EfficiencyCorrectionType::SFJetIDHadTau});
1682 
1683  // Read out the (optional) Ele OR from the config file and map into the enum from tau CP
1684  std::string eleIDWP = m_tauConfigReader.GetValue("EleIDWP" ,"");
1685  ANA_MSG_DEBUG( "Found EleIDWP in tau config file : " << eleIDWP );
1686  int ele_id_lvl = -1;
1687  if (eleIDWP == "ELEIDRNNLOOSE") ele_id_lvl = (int)TauAnalysisTools::EleID::ELEIDRNNLOOSE;
1688  else if (eleIDWP == "ELEIDRNNMEDIUM") ele_id_lvl = (int)TauAnalysisTools::EleID::ELEIDRNNMEDIUM;
1689  else if (eleIDWP == "ELEIDRNNTIGHT") ele_id_lvl = (int)TauAnalysisTools::EleID::ELEIDRNNTIGHT;
1690  else {
1691  ATH_MSG_INFO("No or invalid Ele OR in tau config file " << eleIDWP << " will not apply SFs for electro veto" );
1692  }
1693  // Add retrieval of electron veto SFs if its applied
1694  if (ele_id_lvl != -1 )
1695  correction_types.insert(correction_types.end(), {TauAnalysisTools::EfficiencyCorrectionType::SFEleIDHadTau,
1696  TauAnalysisTools::EfficiencyCorrectionType::SFEleIDElectron});
1697 
1698  ATH_CHECK( m_tauEffTool.setProperty("JetIDLevel", jet_id_lvl) );
1699  ATH_CHECK( m_tauEffTool.setProperty("EleIDLevel", ele_id_lvl) );
1700  ATH_CHECK( m_tauEffTool.setProperty("EfficiencyCorrectionTypes", correction_types) );
1701  ATH_CHECK( m_tauEffTool.setProperty("OutputLevel", this->msg().level()) );
1702  ATH_CHECK( m_tauEffTool.setProperty("useFastSim", isAtlfast()) );
1703  ATH_CHECK( m_tauEffTool.setProperty("RecommendationTag", m_tauEffToolRecommendationTag) );
1704  if (m_isRun3){ ATH_CHECK( m_tauEffTool.setProperty("Campaign", "mc23") );}
1705  else { ATH_CHECK( m_tauEffTool.setProperty("Campaign", "mc20") );}
1706  ATH_CHECK( m_tauEffTool.retrieve() );
1707  } else if (m_tauEffTool.isUserConfigured()) ATH_CHECK( m_tauEffTool.retrieve() );
1708 
1709 
1711  // Initialise tau trigger efficiency tool(s)
1712 
1713  if (!isData()) {
1714  int iTauID = (int) TauAnalysisTools::JETIDNONE;
1715  if (m_tauId == "rnn001") iTauID = (int) TauAnalysisTools::JETIDNONE;
1716  else if (m_tauId == "VeryLoose") iTauID = (int) TauAnalysisTools::JETIDRNNVERYLOOSE;
1717  else if (m_tauId == "Loose") iTauID = (int) TauAnalysisTools::JETIDRNNLOOSE;
1718  else if (m_tauId == "Medium") iTauID = (int) TauAnalysisTools::JETIDRNNMEDIUM;
1719  else if (m_tauId == "Tight") iTauID = (int) TauAnalysisTools::JETIDRNNTIGHT;
1720  else {
1721  ATH_MSG_ERROR("Invalid tau ID selected: " << m_tauId);
1722  return StatusCode::FAILURE;
1723  }
1724 
1725  // map format: SF file name, corresponding single-tau leg (comma-separated in case of OR)
1726  m_tau_trig_support = {
1727  {"HLT_tau25_medium1_tracktwo", "HLT_tau25_medium1_tracktwo"},
1728  {"HLT_tau35_medium1_tracktwo", "HLT_tau35_medium1_tracktwo"},
1729  {"HLT_tau50L1TAU12_medium1_tracktwo", "HLT_tau50_medium1_tracktwo_L1TAU12"},
1730  {"HLT_tau60_medium1_tracktwo", "HLT_tau60_medium1_tracktwo"},
1731  {"HLT_tau80L1TAU60_medium1_tracktwo", "HLT_tau80_medium1_tracktwo_L1TAU60"},
1732  {"HLT_tau125_medium1_tracktwo", "HLT_tau125_medium1_tracktwo"},
1733  {"HLT_tau160_medium1_tracktwo", "HLT_tau160_medium1_tracktwo"},
1734  {"HLT_tau160L1TAU100_medium1_tracktwo", "HLT_tau160_medium1_tracktwo_L1TAU100"},
1735  // whole 2018 data taking period
1736  {"HLT_tau25_medium1_tracktwoEF", "HLT_tau25_medium1_tracktwoEF"},
1737  {"HLT_tau35_medium1_tracktwoEF", "HLT_tau35_medium1_tracktwoEF"},
1738  {"HLT_tau60_medium1_tracktwoEF", "HLT_tau60_medium1_tracktwoEF"},
1739  {"HLT_tau80L1TAU60_medium1_tracktwoEF", "HLT_tau80_medium1_tracktwoEF_L1TAU60"},
1740  {"HLT_tau160L1TAU100_medium1_tracktwoEF", "HLT_tau160_medium1_tracktwoEF_L1TAU100"},
1741  };
1742 
1743  if (m_isRun3){
1744  m_tau_trig_support = {
1745  // 2022, 2023
1746  {"HLT_tau25_mediumRNN_tracktwoMVA", "HLT_tau25_mediumRNN_tracktwoMVA"},
1747  {"HLT_tau35_mediumRNN_tracktwoMVA", "HLT_tau35_mediumRNN_tracktwoMVA"},
1748  // 2022, 2023 75-1800 bunches
1749  {"HLT_tau160_mediumRNN_tracktwoMVA", "HLT_tau160_mediumRNN_tracktwoMVA_L1TAU100"},
1750  // 2023 from 400 bunches
1751  {"HLT_tau160_mediumRNN_tracktwoMVA", "HLT_tau160_mediumRNN_tracktwoMVA_L1eTAU140"}
1752  };
1753  }
1754 
1755  for(auto const& trigger : m_tau_trig_support) {
1756  toolName = "TauTrigEffTool_" + m_tauId + "_" + trigger.first;
1757  auto tau_trigSF = m_tauTrigEffTool.emplace(m_tauTrigEffTool.end(), "TauAnalysisTools::TauEfficiencyCorrectionsTool/"+toolName);
1758  ATH_CHECK( tau_trigSF->setProperty("EfficiencyCorrectionTypes", std::vector<int>({TauAnalysisTools::SFTriggerHadTau})) );
1759  ATH_CHECK( tau_trigSF->setProperty("TriggerName", trigger.first) );
1760  ATH_CHECK( tau_trigSF->setProperty("JetIDLevel", iTauID) );
1761  ATH_CHECK( tau_trigSF->setProperty("OutputLevel", this->msg().level()) );
1762  ATH_CHECK( tau_trigSF->setProperty("useFastSim", isAtlfast()) );
1763  ATH_CHECK( tau_trigSF->setProperty("RecommendationTag", m_tauEffToolRecommendationTag) );
1764  if (m_isRun3){ ATH_CHECK( tau_trigSF->setProperty("Campaign", m_mcCampaign) );}
1765  else { ATH_CHECK( tau_trigSF->setProperty("Campaign", "mc20") );}
1766  ATH_CHECK( tau_trigSF->initialize() );
1767  }
1768  }
1769 
1770 
1772  // Initialise tau smearing tool
1773 
1774  if (!m_tauSmearingTool.isUserConfigured()) {
1775  m_tauSmearingTool.setTypeAndName("TauAnalysisTools::TauSmearingTool/TauSmearingTool");
1776  ATH_CHECK( m_tauSmearingTool.setProperty("RecommendationTag", m_tauSmearingToolRecommendationTag) );
1777  if (m_isRun3){ ATH_CHECK( m_tauSmearingTool.setProperty("Campaign", "mc23") );}
1778  else { ATH_CHECK( m_tauSmearingTool.setProperty("Campaign", "mc20") );}
1779  ATH_CHECK( m_tauSmearingTool.setProperty("Generator", m_tauSmearingToolGenerator) );
1780  ATH_CHECK( m_tauSmearingTool.setProperty("MVATESQualityCheck", m_ApplyMVATESQualityCheck) );
1781  ATH_CHECK( m_tauSmearingTool.setProperty("useFastSim", isAtlfast()) );
1782  ATH_CHECK( m_tauSmearingTool.setProperty("OutputLevel", this->msg().level()) );
1783  ATH_CHECK( m_tauSmearingTool.retrieve() );
1784  } else ATH_CHECK( m_tauSmearingTool.retrieve() );
1785 
1786 
1788  // Initialise tau truth matching tool
1789 
1790  if (!m_tauTruthMatch.isUserConfigured() && m_tauDoTTM && !isData()) {
1791  m_tauTruthMatch.setTypeAndName("TauAnalysisTools::TauTruthMatchingTool/TauTruthMatch");
1792  ATH_CHECK( m_tauTruthMatch.setProperty("TruthJetContainerName", m_defaultTruthJets ) );
1793  ATH_CHECK( m_tauTruthMatch.setProperty("OutputLevel", this->msg().level()) );
1794  ATH_CHECK( m_tauTruthMatch.retrieve() );
1795  } else if (m_tauTruthMatch.isUserConfigured()) ATH_CHECK( m_tauTruthMatch.retrieve() );
1796 
1797 
1798  }
1799 
1800 
1801  if (m_slices["bjet"]) {
1803  // Initialise B-tagging tools
1804 
1805  // btagSelectionTool
1806  std::string jetcollBTag = jetcoll;
1807  if (jetcoll == "AntiKt4LCTopoJets") {
1808  ATH_MSG_WARNING(" *** HACK *** Treating LCTopoJets jets as EMTopo -- use at your own risk!");
1809  jetcollBTag = "AntiKt4EMTopoJets";
1810  }
1811 
1812  // print a warning if there is indication that the user supplied a CDI file not matching to the sample being processed
1813  // see --> https://twiki.cern.ch/twiki/bin/view/AtlasProtected/BTagRel22HighLevelSummary
1814  if( (m_bTaggingCalibrationFilePath.find(!m_isRun3 ? "MC20" : "MC23") == std::string::npos) && (m_bTaggingCalibrationFilePath.find(!m_isRun3 ? "MC20" : "MC21") == std::string::npos) ) {
1815  ATH_MSG_WARNING( "You are using a "<<(!m_isRun3 ? "Run3":"Run2")<<" CDI file while running on "<<(!m_isRun3 ? "Run2":"Run3")<<" sample; Please updates your CDI file to the correct version for "<<(!m_isRun3 ? "Run2":"Run3"));
1816  }
1817 
1818  if (m_useBtagging && !m_btagSelTool.isUserConfigured() && !m_BtagWP.empty()) {
1819  if (jetcollBTag.find("AntiKt4EMTopoJets") == std::string::npos && jetcollBTag.find("AntiKt4EMPFlowJets")==std::string::npos) {
1820  ATH_MSG_WARNING("** Only AntiKt4EMTopoJets and AntiKt4EMPFlowJets are supported with FTAG scale factors!");
1821  return StatusCode::FAILURE;
1822  }
1823 
1824  toolName = "BTagSel_" + jetcollBTag + m_BtagTagger + m_BtagWP;
1825 
1826  m_btagSelTool.setTypeAndName("BTaggingSelectionTool/"+toolName);
1827  ATH_CHECK( m_btagSelTool.setProperty("TaggerName", m_BtagTagger ) );
1828  ATH_CHECK( m_btagSelTool.setProperty("OperatingPoint", m_BtagWP ) );
1829  ATH_CHECK( m_btagSelTool.setProperty("JetAuthor", jetcollBTag ) );
1830  ATH_CHECK( m_btagSelTool.setProperty("MinPt", m_BtagMinPt ) );
1831  ATH_CHECK( m_btagSelTool.setProperty("FlvTagCutDefinitionsFileName", m_bTaggingCalibrationFilePath) );
1832  // Read from BTagging object. This will be needed until the input file is produced from
1833  // a derivation release that includes !80336.
1834  ATH_CHECK( m_btagSelTool.setProperty("readFromBTaggingObject", true ) );
1835  ATH_CHECK( m_btagSelTool.setProperty("OutputLevel", this->msg().level()) );
1836  ATH_CHECK( m_btagSelTool.retrieve() );
1837  } else if (m_btagSelTool.isUserConfigured()) ATH_CHECK( m_btagSelTool.retrieve() );
1838 
1839 
1840  if (m_useBtagging && !m_btagSelTool_OR.isUserConfigured() && !m_orBtagWP.empty()) {
1841  if (jetcoll != "AntiKt4EMTopoJets" && jetcoll != "AntiKt4EMPFlowJets") {
1842  ATH_MSG_WARNING("** Only AntiKt4EMTopoJets and AntiKt4EMPFlowJets are supported with FTAG scale factors!");
1843  return StatusCode::FAILURE;
1844  }
1845 
1846  toolName = "BTagSelOR_" + jetcollBTag + m_orBtagWP;
1847  m_btagSelTool_OR.setTypeAndName("BTaggingSelectionTool/"+toolName);
1848  ATH_CHECK( m_btagSelTool_OR.setProperty("TaggerName", m_BtagTagger ) );
1849  ATH_CHECK( m_btagSelTool_OR.setProperty("OperatingPoint", m_orBtagWP ) );
1850  ATH_CHECK( m_btagSelTool_OR.setProperty("JetAuthor", jetcollBTag ) );
1851  ATH_CHECK( m_btagSelTool_OR.setProperty("MinPt", m_BtagMinPt ) );
1852  ATH_CHECK( m_btagSelTool_OR.setProperty("FlvTagCutDefinitionsFileName", m_bTaggingCalibrationFilePath) );
1853  // Read from BTagging object. This will be needed until the input file is produced from
1854  // a derivation release that includes !80336.
1855  ATH_CHECK( m_btagSelTool_OR.setProperty("readFromBTaggingObject", true ) );
1856  ATH_CHECK( m_btagSelTool_OR.setProperty("OutputLevel", this->msg().level()) );
1857  ATH_CHECK( m_btagSelTool_OR.retrieve() );
1858  } else if (m_btagSelTool_OR.isUserConfigured()) ATH_CHECK( m_btagSelTool_OR.retrieve() );
1859 
1860 
1861  std::string trkjetcoll = m_defaultTrackJets;
1862  const std::string& BTagColl_TrkJet = trkjetcoll;
1863  if (m_slices["tjet"]) {
1864  if ( m_useBtagging_trkJet && m_defaultTrackJets.empty()) {
1865  m_useBtagging_trkJet = false;
1866  ATH_MSG_INFO("TrackJet collection set to None: disabling btagging for TrackJets.");
1867  }
1868 
1869  if (m_useBtagging_trkJet && !m_btagSelTool_trkJet.isUserConfigured() && !m_BtagWP_trkJet.empty()) {
1870  if (trkjetcoll.find("AntiKt2PV0TrackJets")==std::string::npos && trkjetcoll.find("AntiKtVR30Rmax4Rmin02TrackJets")==std::string::npos) {
1871  ATH_MSG_WARNING("** Only AntiKt2PV0TrackJets and AntiKtVR30Rmax4Rmin02TrackJets are supported with FTAG scale factors!");
1872  return StatusCode::FAILURE;
1873  }
1874 
1875  toolName = "BTagSel_" + trkjetcoll + m_BtagTagger_trkJet + m_BtagWP_trkJet;
1876 
1877  m_btagSelTool_trkJet.setTypeAndName("BTaggingSelectionTool/"+toolName);
1878  ATH_CHECK( m_btagSelTool_trkJet.setProperty("TaggerName", m_BtagTagger_trkJet ) );
1879  ATH_CHECK( m_btagSelTool_trkJet.setProperty("OperatingPoint", m_BtagWP_trkJet ) );
1880  ATH_CHECK( m_btagSelTool_trkJet.setProperty("MinPt", m_BtagMinPt_trkJet ) );
1881  ATH_CHECK( m_btagSelTool_trkJet.setProperty("JetAuthor", BTagColl_TrkJet ) );
1882  ATH_CHECK( m_btagSelTool_trkJet.setProperty("MinPt", m_BtagMinPt_trkJet ) );
1883  ATH_CHECK( m_btagSelTool_trkJet.setProperty("FlvTagCutDefinitionsFileName", m_bTaggingCalibrationFilePath) );
1884  // Read from BTagging object. This will be needed until the input file is produced from
1885  // a derivation release that includes !80336.
1886  ATH_CHECK( m_btagSelTool_trkJet.setProperty("readFromBTaggingObject", true ) );
1887  ATH_CHECK( m_btagSelTool_trkJet.setProperty("OutputLevel", this->msg().level()) );
1888  ATH_CHECK( m_btagSelTool_trkJet.retrieve() );
1889  } else if (m_btagSelTool_trkJet.isUserConfigured()) ATH_CHECK( m_btagSelTool_trkJet.retrieve() );
1890  }
1891 
1892  // Set MCshowerType for FTAG MC/MC SFs
1893  // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/BTagCalibrationRecommendationsRelease21#MC_MC_Scale_Factors_for_Analysis
1894  std::string MCshowerID;
1895  if(m_showerType==-1){
1896  ATH_MSG_ERROR( "Error! m_showerType=-1, which is an error case for FTAG MC/MC SFs." );
1897  return StatusCode::FAILURE;
1898  }
1899  if(m_BtagTagger=="DL1dv01"){
1900  if(!m_isRun3){
1901  MCshowerID= "default"; // Powheg+Pythia8 (410470) - PhPy8EG_A14
1902  if (m_showerType == 1) MCshowerID = "411233"; // PowhegHerwig7
1903  else if (m_showerType == 2) MCshowerID = "600666"; // PhH7EG_H7UE - 601414
1904  else if (m_showerType == 3) MCshowerID = "410250"; // Sherpa_221
1905  else if (m_showerType == 4) MCshowerID = "700122"; // Sh_2210
1906  else if (m_showerType == 5) MCshowerID = "700122"; // Sh_2211
1907  else if (m_showerType == 6) MCshowerID = "700660"; // Sh_2212 - 700660
1908  else if (m_showerType == 7) MCshowerID = "410464"; // aMcAtNloPy8
1909  else if (m_showerType == 8) MCshowerID = "412116"; // aMcAtNloHerwig7
1910  else if (m_showerType != 0){
1911  ATH_MSG_WARNING("Unknown ShowerID detected! Using default FTAG MC-MC SFs (Powheg+Pythia8). Please check if these are applicable for this sample!");
1912  }
1913  }
1914  else{
1915  MCshowerID= "default"; // Powheg+Pythia8 (601229) - PhPy8EG_A14
1916  if (m_showerType == 2) MCshowerID = "601414"; // POWHEG+Herwig721 - PhH7EG_A14
1917  else if (m_showerType == 6) MCshowerID = "700660"; // Sherpa 2.2.12 - Sh_2212
1918  else if (m_showerType != 0){
1919  ATH_MSG_WARNING("Unknown ShowerID detected! Using default FTAG MC-MC SFs (Powheg+Pythia8). Please check if these are applicable for this sample!");
1920  }
1921  }
1922  } else if (m_BtagTagger=="GN2v01"){
1923  if(!m_isRun3){
1924  MCshowerID= "default"; // PowhegPythia8EvtGen (410470)
1925  if (m_showerType == 2) MCshowerID = "411233"; // POWHEGHERWIG7 - 411233
1926  else if (m_showerType == 3) MCshowerID = "600666"; // PhH7EG_H7UE - 600666
1927  else if (m_showerType == 4) MCshowerID = "700660"; // Sh_2210 FTAGAnalysisConfig uses this, but docs say only 11-16 can be used
1928  else if (m_showerType == 5) MCshowerID = "700660"; // Sh_2211
1929  else if (m_showerType == 6) MCshowerID = "700660"; // Sh_2212
1930  else if (m_showerType == 7) MCshowerID = "700660"; // Sh_2214
1931  else if (m_showerType == 8) {
1932  ATH_MSG_WARNING("Unknown Sherpa version detected! Using FTAG MC-MC SFs for Sherpa 2.2.11-2.2.16. Please check if these are applicable for this sample!");
1933  MCshowerID = "700660"; // Unknown Sherpa Version. This is to handle Sh_blank (e.g. DSID 701050). The examples I've found are all 2.2.16, but that's not guaranteed.
1934  }
1935  else if (m_showerType != 0){
1936  ATH_MSG_WARNING("Unknown ShowerID detected! Using default FTAG MC-MC SFs (Powheg+Pythia8). Please check if these are applicable for this sample!");
1937  }
1938  }
1939  else {
1940  MCshowerID= "default"; // PowhegPythia8EvtGen (601229)
1941  if (m_showerType == 3) MCshowerID = "601414"; // PhH7EG_H7UE - 601414
1942  else if (m_showerType == 5) MCshowerID = "700808"; // Sh_2211
1943  else if (m_showerType == 6) MCshowerID = "700808"; // Sh_2212
1944  else if (m_showerType == 7) MCshowerID = "700808"; // Sh_2214
1945  else if (m_showerType == 8) {
1946  ATH_MSG_WARNING("Unknown Sherpa version detected! Using FTAG MC-MC SFs for Sherpa 2.2.11-2.2.16. Please check if these are applicable for this sample!");
1947  MCshowerID = "700660"; // Unknown Sherpa Version
1948  }
1949  else if (m_showerType != 0){
1950  ATH_MSG_WARNING("Unknown ShowerID detected! Using default FTAG MC-MC SFs (Powheg+Pythia8). Please check if these are applicable for this sample!");
1951  }
1952  }
1953  } else {
1954  ATH_MSG_WARNING("Unknown b-tagger detected! Only DL1dv01 and GN2v01 are supported. Falling back to default FTAG MC-MC SFs (Powheg+Pythia8). Please check if these are applicable for this sample!");
1955  MCshowerID= "default";
1956  }
1957 
1958  // btagEfficiencyTool
1959  if (m_useBtagging && !m_btagEffTool.isUserConfigured() && !m_BtagWP.empty()) {
1960  if (jetcoll != "AntiKt4EMTopoJets" && jetcoll != "AntiKt4EMPFlowJets") {
1961  ATH_MSG_WARNING("** Only AntiKt4EMTopoJets and AntiKt4EMPFlowJets are supported with FTAG scale factors!");
1962  return StatusCode::FAILURE;
1963  }
1964 
1965  toolName = "BTagSF_" + jetcollBTag + m_BtagTagger + m_BtagWP;
1966  m_btagEffTool.setTypeAndName("BTaggingEfficiencyTool/"+toolName);
1967  ATH_CHECK( m_btagEffTool.setProperty("TaggerName", m_BtagTagger ) );
1968  ATH_CHECK( m_btagEffTool.setProperty("ScaleFactorFileName", m_bTaggingCalibrationFilePath) );
1969  ATH_CHECK( m_btagEffTool.setProperty("OperatingPoint", m_BtagWP ) );
1970  ATH_CHECK( m_btagEffTool.setProperty("JetAuthor", jetcollBTag ) );
1971  // Read from BTagging object. This will be needed until the input file is produced from
1972  // a derivation release that includes !80336.
1973  ATH_CHECK( m_btagEffTool.setProperty("readFromBTaggingObject", true) );
1974  ATH_CHECK( m_btagEffTool.setProperty("MinPt", m_BtagMinPt ) );
1975  ATH_CHECK( m_btagEffTool.setProperty("SystematicsStrategy", m_BtagSystStrategy ) );
1976  ATH_CHECK( m_btagEffTool.setProperty("EfficiencyBCalibrations", MCshowerID ));
1977  ATH_CHECK( m_btagEffTool.setProperty("EfficiencyCCalibrations", MCshowerID ));
1978  ATH_CHECK( m_btagEffTool.setProperty("EfficiencyTCalibrations", MCshowerID ));
1979  ATH_CHECK( m_btagEffTool.setProperty("EfficiencyLightCalibrations", MCshowerID ));
1980  ATH_CHECK( m_btagEffTool.setProperty("EigenvectorReductionB", m_EigenvectorReductionB ));
1981  ATH_CHECK( m_btagEffTool.setProperty("EigenvectorReductionC", m_EigenvectorReductionC ));
1982  ATH_CHECK( m_btagEffTool.setProperty("EigenvectorReductionLight", m_EigenvectorReductionLight ));
1983  ATH_CHECK( m_btagEffTool.setProperty("OutputLevel", this->msg().level()) );
1984  ATH_CHECK( m_btagEffTool.retrieve() );
1985  } else ATH_CHECK( m_btagEffTool.retrieve() );
1986 
1987 
1988  if (m_slices["tjet"]) {
1989  if (m_useBtagging_trkJet && !m_btagEffTool_trkJet.isUserConfigured() && !m_BtagWP_trkJet.empty()) {
1990  if (trkjetcoll.find("AntiKt2PV0TrackJets")==std::string::npos && trkjetcoll.find("AntiKtVR30Rmax4Rmin02TrackJets")==std::string::npos) {
1991  ATH_MSG_WARNING("** Only AntiKt2PV0TrackJets and AntiKtVR30Rmax4Rmin02TrackJets are supported with FTAG scale factors!");
1992  return StatusCode::FAILURE;
1993  }
1994 
1995  toolName = "BTagSF_" + trkjetcoll;
1996  m_btagEffTool_trkJet.setTypeAndName("BTaggingEfficiencyTool/"+toolName);
1997  ATH_CHECK( m_btagEffTool_trkJet.setProperty("TaggerName", m_BtagTagger_trkJet ) );
1998  ATH_CHECK( m_btagEffTool_trkJet.setProperty("ScaleFactorFileName", m_bTaggingCalibrationFilePath) );
1999  ATH_CHECK( m_btagEffTool_trkJet.setProperty("OperatingPoint", m_BtagWP_trkJet ) );
2000  ATH_CHECK( m_btagEffTool_trkJet.setProperty("JetAuthor", BTagColl_TrkJet ) );
2001  ATH_CHECK( m_btagEffTool_trkJet.setProperty("MinPt", m_BtagMinPt_trkJet ) );
2002  ATH_CHECK( m_btagEffTool_trkJet.setProperty("SystematicsStrategy", m_BtagSystStrategy ) );
2003  ATH_CHECK( m_btagEffTool_trkJet.setProperty("EfficiencyBCalibrations", MCshowerID ));
2004  ATH_CHECK( m_btagEffTool_trkJet.setProperty("EfficiencyCCalibrations", MCshowerID ));
2005  ATH_CHECK( m_btagEffTool_trkJet.setProperty("EfficiencyTCalibrations", MCshowerID ));
2006  ATH_CHECK( m_btagEffTool_trkJet.setProperty("EfficiencyLightCalibrations", MCshowerID ));
2007  ATH_CHECK( m_btagEffTool_trkJet.setProperty("EigenvectorReductionB", m_EigenvectorReductionB ));
2008  ATH_CHECK( m_btagEffTool_trkJet.setProperty("EigenvectorReductionC", m_EigenvectorReductionC ));
2009  ATH_CHECK( m_btagEffTool_trkJet.setProperty("EigenvectorReductionLight", m_EigenvectorReductionLight ));
2010  ATH_CHECK( m_btagEffTool_trkJet.setProperty("OutputLevel", this->msg().level()) );
2011  ATH_CHECK( m_btagEffTool_trkJet.retrieve() );
2012  } else if (m_btagEffTool_trkJet.isUserConfigured()) ATH_CHECK( m_btagEffTool_trkJet.retrieve() );
2013  }
2014  }
2015 
2016 
2017  if (m_slices["met"]) {
2019  // Initialise MET tools
2020 
2021  if (!m_metMaker.isUserConfigured()) {
2022  toolName = m_doFwdJVT ? m_metJetSelection+"_fJVT" : m_metJetSelection+"_NOfJVT";
2023  m_metMaker.setTypeAndName("met::METMaker/METMaker_ST_"+toolName);
2024 
2025  ATH_CHECK( m_metMaker.setProperty("ORCaloTaggedMuons", m_metRemoveOverlappingCaloTaggedMuons) );
2026  ATH_CHECK( m_metMaker.setProperty("DoSetMuonJetEMScale", m_metDoSetMuonJetEMScale) );
2027  ATH_CHECK( m_metMaker.setProperty("DoRemoveMuonJets", m_metDoRemoveMuonJets) );
2028  ATH_CHECK( m_metMaker.setProperty("UseGhostMuons", m_metUseGhostMuons) );
2029  ATH_CHECK( m_metMaker.setProperty("DoMuonEloss", m_metDoMuonEloss) );
2030  ATH_CHECK( m_metMaker.setProperty("GreedyPhotons", m_metGreedyPhotons) );
2031  ATH_CHECK( m_metMaker.setProperty("VeryGreedyPhotons", m_metVeryGreedyPhotons) );
2032 
2033  // set the jet selection if default empty string is overridden through config file
2034  if (m_metJetSelection.size()) {
2035  ATH_CHECK( m_metMaker.setProperty("JetSelection", m_metJetSelection) );
2036  }
2037  if (m_jetInputType == xAOD::JetInput::EMPFlow) {
2038  ATH_CHECK( m_metMaker.setProperty("DoPFlow", true) );
2039  }
2040 
2041  ATH_CHECK( m_metMaker.setProperty("OutputLevel", this->msg().level()) );
2042  ATH_CHECK( m_metMaker.retrieve() );
2043  } else ATH_CHECK( m_metMaker.retrieve() );
2044 
2045 
2046  if (!m_metSystTool.isUserConfigured()) {
2047  m_metSystTool.setTypeAndName("met::METSystematicsTool/METSystTool");
2048  ATH_CHECK( m_metSystTool.setProperty("ConfigPrefix", m_metsysConfigPrefix) );
2049 
2050  if (m_trkMETsyst && m_caloMETsyst){
2051  ATH_MSG_ERROR( "Can only have CST *or* TST configured for MET maker. Please unset either METDoCaloSyst or METDoTrkSyst in your config file" );
2052  return StatusCode::FAILURE;
2053  }
2054 
2055  if (m_trkMETsyst) {
2056  ATH_CHECK( m_metSystTool.setProperty("ConfigSoftCaloFile", "") );
2057  ATH_CHECK( m_metSystTool.setProperty("ConfigSoftTrkFile", "TrackSoftTerms-pflow_Dec24.config") );
2058  }
2059 
2060  if (m_caloMETsyst) {
2061  ATH_MSG_WARNING( "CST is no longer recommended by Jet/MET group");
2062  ATH_CHECK( m_metSystTool.setProperty("ConfigSoftTrkFile", "") );
2063  }
2064 
2065  if (m_trkJetsyst) {
2066  ATH_CHECK( m_metSystTool.setProperty("ConfigJetTrkFile", "JetTrackSyst.config") );
2067  }
2068 
2069  ATH_CHECK( m_metSystTool.setProperty("OutputLevel", this->msg().level()) );
2070  ATH_CHECK( m_metSystTool.retrieve());
2071  } else ATH_CHECK( m_metSystTool.retrieve());
2072 
2073 
2074  if (!m_metSignif.isUserConfigured()) {
2075  // See https://twiki.cern.ch/twiki/bin/view/AtlasProtected/MetSignificance
2076  m_metSignif.setTypeAndName("met::METSignificance/metSignificance_"+jetname);
2077 #ifndef XAOD_STANDALONE // Athena and AthAnalysis; need to take into account that MuonCalibTool is private tool
2078  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "SoftTermParam", m_softTermParam));
2079  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "TreatPUJets", m_treatPUJets));
2080  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "DoPhiReso", m_doPhiReso));
2081  if(jetname != "AntiKt4EMPFlow")
2082  ATH_MSG_WARNING("METSignificance recommendations only exist for AntiKt4EMPFlow jets, falling back to this.");
2083  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "JetCollection", "AntiKt4EMPFlow"));
2084  // This is the only recommended set of jet resolutions for use with R22+ MET Significance until "Consolidated" recommendations are available
2085  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "JetCalibConfig", "JES_data2017_2016_2015_Recommendation_PFlow_Aug2018_rel21.config") );
2086  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "JetCalibSequence", "JetArea_Residual_EtaJES_GSC_Smear") );
2087  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "JetCalibArea", "00-04-81") );
2088  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "EgammaESModel", m_isRun3 ? "es2024_Run3_v0" : "es2023_R22_Run2_v1") );
2089  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "EgammaDecorrelationModel", "1NP_v1") );
2090  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "EgammaUseFastsim", isAtlfast()) );
2091  // setup a dedicated new muon calib tool for passing down to METSignificance
2092  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "MuonCalibTool", "CP::MuonCalibTool/calibTool"));
2093  if (m_isRun3)
2094  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.IsRun3Geo", true));
2095  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.calibMode", m_muCalibrationMode));
2096  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.OutputLevel",this->msg().level()));
2097  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.release", "Recs2025_03_26_Run2Run3"));
2098  int IdBaselineInt = m_muIdBaseline;
2099  if (IdBaselineInt == 4)
2100  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.do2StationsHighPt", true));
2101  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.doExtraSmearing", m_muHighPtExtraSmear));
2102  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "OutputLevel", this->msg().level()));
2103 #else // AnalysisBase; can just pass the jet/egamma/muon calib tools configured above
2104  ATH_CHECK( m_metSignif.setProperty("SoftTermParam", m_softTermParam) );
2105  ATH_CHECK( m_metSignif.setProperty("TreatPUJets", m_treatPUJets) );
2106  ATH_CHECK( m_metSignif.setProperty("DoPhiReso", m_doPhiReso) );
2107  if(jetname != "AntiKt4EMPFlow")
2108  ATH_MSG_WARNING("METSignificance recommendations only exist for AntiKt4EMPFlow jets, falling back to this.");
2109  ATH_CHECK( m_metSignif.setProperty( "JetCollection", "AntiKt4EMPFlow"));
2110  // This is the only recommended set of jet resolutions for use with R22+ MET Significance until "Consolidated" recommendations are available
2111  ATH_CHECK( m_metSignif.setProperty( "JetCalibConfig", "JES_data2017_2016_2015_Recommendation_PFlow_Aug2018_rel21.config") );
2112  ATH_CHECK( m_metSignif.setProperty( "JetCalibSequence", "JetArea_Residual_EtaJES_GSC_Smear") );
2113  ATH_CHECK( m_metSignif.setProperty( "JetCalibArea", "00-04-81") );
2114  ATH_CHECK( m_metSignif.setProperty("egammaCalibTool", m_egammaCalibTool.getHandle()) );
2115  // just pass the muon calib tool
2116  ATH_CHECK( m_metSignif.setProperty("MuonCalibTool",m_muonCalibTool.getHandle()));
2117  ATH_CHECK( m_metSignif.setProperty("OutputLevel", this->msg().level()) );
2118 #endif
2119  ATH_CHECK( m_metSignif.retrieve() );
2120  } else ATH_CHECK( m_metSignif.retrieve() );
2121  }
2122 
2123 
2125 // Initialise trigger tools
2126 
2127  if (!m_trigDecTool.isUserConfigured()) {
2128 
2129  // The decision tool
2130  m_trigDecTool.setTypeAndName("Trig::TrigDecisionTool/TrigDecisionTool");
2131  ATH_CHECK( m_trigDecTool.setProperty("TrigDecisionKey", "xTrigDecision") );
2132  if (m_isRun3) {
2133  ATH_CHECK( m_trigDecTool.setProperty("NavigationFormat", "TrigComposite") );
2134  ATH_CHECK( m_trigDecTool.setProperty("HLTSummary", "HLTNav_Summary_DAODSlimmed") );
2135  }
2136  ATH_CHECK( m_trigDecTool.setProperty("OutputLevel", this->msg().level()) );
2137 
2138 #ifndef XAOD_STANDALONE // Athena and AthAnalysis
2139  // Clear the default tool handle to cause a fallback on the config service
2140  ATH_CHECK( m_trigDecTool.setProperty("ConfigTool", ""));
2141 #else // AnalysisBase
2142  m_trigConfTool.setTypeAndName("TrigConf::xAODConfigTool/xAODConfigTool");
2143  ATH_CHECK(m_trigConfTool.retrieve() );
2144  ATH_CHECK( m_trigDecTool.setProperty("ConfigTool", m_trigConfTool.getHandle()) );
2145 #endif
2146 
2147  ATH_CHECK( m_trigDecTool.retrieve() );
2148 
2149  } else ATH_CHECK( m_trigDecTool.retrieve() );
2150 
2151  if (m_isRun3) {
2152  if (!m_trigDRScoringTool.isUserConfigured()) {
2153  m_trigDRScoringTool.setTypeAndName("Trig::DRScoringTool/TrigDRScoringTool");
2154  ATH_CHECK( m_trigDRScoringTool.setProperty("OutputLevel", this->msg().level()) );
2155  ATH_CHECK( m_trigDRScoringTool.retrieve() );
2156  } else ATH_CHECK( m_trigDRScoringTool.retrieve() );
2157  }
2158 
2159  if (!m_trigMatchingTool.isUserConfigured()) {
2160  if (m_upstreamTriggerMatching){
2161  m_trigMatchingTool.setTypeAndName("Trig::MatchFromCompositeTool/TrigMatchFromCompositeTool");
2162  ATH_CHECK( m_trigMatchingTool.setProperty("InputPrefix", m_trigMatchingPrefix) );
2163  ATH_CHECK( m_trigMatchingTool.setProperty("RemapBrokenLinks", true) );
2164  }
2165  else {
2166  if (m_isRun3){
2167  m_trigMatchingTool.setTypeAndName("Trig::R3MatchingTool/TrigR3MatchingTool");
2168  ATH_CHECK( m_trigMatchingTool.setProperty("ScoringTool", m_trigDRScoringTool.getHandle()) );
2169  ATH_CHECK( m_trigMatchingTool.setProperty("TrigDecisionTool", m_trigDecTool.getHandle()) );
2170  }
2171  else {
2172  m_trigMatchingTool.setTypeAndName("Trig::MatchingTool/TrigMatchingTool");
2173  ATH_CHECK( m_trigMatchingTool.setProperty("TrigDecisionTool", m_trigDecTool.getHandle()) );
2174  }
2175  }
2176  ATH_CHECK( m_trigMatchingTool.setProperty("OutputLevel", this->msg().level()) );
2177  ATH_CHECK( m_trigMatchingTool.retrieve() );
2178  } else ATH_CHECK( m_trigMatchingTool.retrieve() );
2179 
2181 // Initialise trigGlobalEfficiencyCorrection tool
2182 
2183  if (!m_trigGlobalEffCorrTool_diLep.isUserConfigured() && !isData()) {
2184 
2185  std::string no2e17("");
2186  if (m_trig2017combination_diLep.find("||2e17_lhvloose_nod0_L12EM15VHI") != std::string::npos) {
2187  auto pos_2e17 = m_trig2017combination_diLep.find("||2e17_lhvloose_nod0_L12EM15VHI");
2188  no2e17 = m_trig2017combination_diLep.substr(0, pos_2e17) + m_trig2017combination_diLep.substr(pos_2e17+31, m_trig2017combination_diLep.size());
2189  } else if (m_trig2017combination_diLep.find("2e17_lhvloose_nod0_L12EM15VHI||") != std::string::npos) {
2190  auto pos_2e17 = m_trig2017combination_diLep.find("2e17_lhvloose_nod0_L12EM15VHI||");
2191  no2e17 = m_trig2017combination_diLep.substr(0, pos_2e17) + m_trig2017combination_diLep.substr(pos_2e17+31, m_trig2017combination_diLep.size());
2192  } else {
2193  no2e17 = m_trig2017combination_diLep;
2194  }
2195  ATH_MSG_DEBUG( "TrigGlobalEfficiencyCorrectionTool/TrigGlobal_diLep: no2e17 trigger string: " << no2e17 );
2196 
2197  std::map<std::string,std::string> triggers_diLep;
2198  triggers_diLep["2015"] = m_trig2015combination_diLep;
2199  triggers_diLep["2016"] = m_trig2016combination_diLep;
2200  triggers_diLep["324320-326695"] = m_trig2017combination_diLep; // 2017 before accidental prescale of L12EM15VHI
2201  triggers_diLep["326834-328393"] = no2e17; // 2017 during accidental prescale
2202  triggers_diLep["329385-340453"] = m_trig2017combination_diLep; // 2017 after accidental prescale
2203  triggers_diLep["2018"] = m_trig2018combination_diLep;
2204 
2205  m_trigGlobalEffCorrTool_diLep.setTypeAndName("TrigGlobalEfficiencyCorrectionTool/TrigGlobal_diLep");
2206  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("ElectronEfficiencyTools", m_elecTrigEffTools) );
2207  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("ElectronScaleFactorTools", m_elecTrigSFTools) );
2208  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("MuonTools", m_muonTrigSFTools) );
2209  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("TriggerCombination", triggers_diLep) );
2210  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("TriggerMatchingTool", m_trigMatchingTool.getHandle()) );
2211  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("ListOfLegsPerTool", m_legsPerTool) );
2212  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("NumberOfToys", m_trigNToys_diLep) );
2213  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("OutputLevel", this->msg().level()) );
2214  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.initialize() );
2215  } else if (m_trigGlobalEffCorrTool_diLep.isUserConfigured()) ATH_CHECK( m_trigGlobalEffCorrTool_diLep.retrieve() );
2216 
2217 
2218  if (!m_trigGlobalEffCorrTool_multiLep.isUserConfigured() && !isData()) {
2219 
2220  std::string no2e17("");
2221  if (m_trig2017combination_multiLep.find("||2e17_lhvloose_nod0_L12EM15VHI") != std::string::npos) {
2222  auto pos_2e17 = m_trig2017combination_multiLep.find("||2e17_lhvloose_nod0_L12EM15VHI");
2223  no2e17 = m_trig2017combination_multiLep.substr(0, pos_2e17) + m_trig2017combination_multiLep.substr(pos_2e17+31, m_trig2017combination_multiLep.size());
2224  } else if (m_trig2017combination_multiLep.find("2e17_lhvloose_nod0_L12EM15VHI||") != std::string::npos) {
2225  auto pos_2e17 = m_trig2017combination_multiLep.find("2e17_lhvloose_nod0_L12EM15VHI||");
2226  no2e17 = m_trig2017combination_multiLep.substr(0, pos_2e17) + m_trig2017combination_multiLep.substr(pos_2e17+31, m_trig2017combination_multiLep.size());
2227  } else {
2228  no2e17 = m_trig2017combination_multiLep;
2229  }
2230  ATH_MSG_DEBUG( "TrigGlobalEfficiencyCorrectionTool/TrigGlobal_multiLep: no2e17 trigger string: " << no2e17 );
2231 
2232  std::map<std::string,std::string> triggers_multiLep;
2233  triggers_multiLep["2015"] = m_trig2015combination_multiLep;
2234  triggers_multiLep["2016"] = m_trig2016combination_multiLep;
2235  triggers_multiLep["324320-326695"] = m_trig2017combination_multiLep; // 2017 before accidental prescale of L12EM15VHI
2236  triggers_multiLep["326834-328393"] = no2e17; // 2017 during accidental prescale
2237  triggers_multiLep["329385-340453"] = m_trig2017combination_multiLep; // 2017 after accidental prescale
2238  triggers_multiLep["2018"] = m_trig2018combination_multiLep;
2239 
2240  m_trigGlobalEffCorrTool_multiLep.setTypeAndName("TrigGlobalEfficiencyCorrectionTool/TrigGlobal_multiLep");
2241  ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("ElectronEfficiencyTools", m_elecTrigEffTools) );
2242  ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("ElectronScaleFactorTools", m_elecTrigSFTools) );
2243  ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("MuonTools", m_muonTrigSFTools) );
2244  ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("TriggerCombination", triggers_multiLep) );
2245  ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("TriggerMatchingTool", m_trigMatchingTool.getHandle()) );
2246  ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("ListOfLegsPerTool", m_legsPerTool) );
2247  ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("NumberOfToys", m_trigNToys_multiLep) );
2248  ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("OutputLevel", this->msg().level()) );
2249  ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.initialize() );
2250  } else if (m_trigGlobalEffCorrTool_multiLep.isUserConfigured()) ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.retrieve() );
2251 
2252 
2253  if (!m_trigGlobalEffCorrTool_diPhoton.isUserConfigured() && !isData()) {
2254  m_trigGlobalEffCorrTool_diPhoton.setTypeAndName("TrigGlobalEfficiencyCorrectionTool/TrigGlobal_diPhoton");
2255  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("PhotonEfficiencyTools", m_photonTrigEffTools) );
2256  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("PhotonScaleFactorTools", m_photonTrigSFTools) );
2257  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("TriggerCombination2015", m_trig2015combination_diPhoton) );
2258  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("TriggerCombination2016", m_trig2016combination_diPhoton) );
2259  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("TriggerCombination2017", m_trig2017combination_diPhoton) );
2260  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("TriggerCombination2018", m_trig2018combination_diPhoton) );
2261  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("ListOfLegsPerTool", m_legsPerTool_ph) );
2262  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("NumberOfToys", m_trigNToys_diPhoton) );
2263  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("OutputLevel", this->msg().level()) );
2264  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.initialize() );
2265  } else if (m_trigGlobalEffCorrTool_diPhoton.isUserConfigured()) ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.retrieve() );
2266 
2267 
2268  if (m_slices["ele"] || m_slices["pho"] || m_slices["mu"]) {
2269  // /////////////////////////////////////////////////////////////////////////////////////////
2270  // Initialise Isolation Correction Tool
2271 
2272  if ( !m_isoCorrTool.isUserConfigured() ) {
2273  m_isoCorrTool.setTypeAndName("CP::IsolationCorrectionTool/IsoCorrTool");
2274  ATH_CHECK( m_isoCorrTool.setProperty( "ToolVer", "REL22") );
2275  ATH_CHECK( m_isoCorrTool.setProperty( "IsMC", !isData()) );
2276  ATH_CHECK( m_isoCorrTool.setProperty( "AFII_corr", isAtlfast()) );
2277  ATH_CHECK( m_isoCorrTool.setProperty( "Apply_SC_leakcorr", false) );
2278  ATH_CHECK( m_isoCorrTool.setProperty( "FixTimingIssueInCore", true) ); // Similar to https://gitlab.cern.ch/atlas/athena/-/merge_requests/83939
2279  ATH_CHECK( m_isoCorrTool.setProperty( "CorrFile", "IsolationCorrections/v6/isolation_ptcorrections_rel22_mc20.root") );
2280  ATH_CHECK( m_isoCorrTool.setProperty( "OutputLevel", this->msg().level()) );
2281  ATH_CHECK( m_isoCorrTool.retrieve() );
2282  } else ATH_CHECK( m_isoCorrTool.retrieve() );
2283 
2284 
2285  // /////////////////////////////////////////////////////////////////////////////////////////
2286  // Initialise Isolation Tool
2287  if (!m_isoTool.isUserConfigured()) {
2288  m_isoTool.setTypeAndName("CP::IsolationSelectionTool/IsoTool");
2289  ATH_CHECK( m_isoTool.setProperty("ElectronWP", m_eleIso_WP.empty() ? "Loose_VarRad" : m_eleIso_WP) );
2290  ATH_CHECK( m_isoTool.setProperty("MuonWP", m_muIso_WP.empty() ? "Loose_VarRad" : m_muIso_WP) );
2291  ATH_CHECK( m_isoTool.setProperty("PhotonWP", m_photonIso_WP.empty() ? "FixedCutTight" : m_photonIso_WP ) );
2292  ATH_CHECK( m_isoTool.setProperty("OutputLevel", this->msg().level()) );
2293  ATH_CHECK( m_isoTool.retrieve() );
2294  } else ATH_CHECK( m_isoTool.retrieve() );
2295 
2296  //disable if (!m_isoToolLowPtPLV.isUserConfigured()) {
2297  //disable m_isoToolLowPtPLV.setTypeAndName("CP::IsolationLowPtPLVTool/IsoToolLowPtPLV");
2298  //disable ATH_CHECK( m_isoToolLowPtPLV.setProperty("OutputLevel", this->msg().level()) );
2299  //disable ATH_CHECK( m_isoToolLowPtPLV.retrieve() );
2300  //disable } else ATH_CHECK( m_isoToolLowPtPLV.retrieve() );
2301 
2302 
2303  if (!m_isoBaselineTool.isUserConfigured()) {
2304  m_isoBaselineTool.setTypeAndName("CP::IsolationSelectionTool/IsoBaselineTool");
2305  ATH_CHECK( m_isoBaselineTool.setProperty("ElectronWP", m_eleBaselineIso_WP.empty() ? "Loose_VarRad" : m_eleBaselineIso_WP ) );
2306  ATH_CHECK( m_isoBaselineTool.setProperty("MuonWP", m_muBaselineIso_WP.empty() ? "Loose_VarRad" : m_muBaselineIso_WP ) );
2307  ATH_CHECK( m_isoBaselineTool.setProperty("PhotonWP", m_photonBaselineIso_WP.empty() ? "FixedCutTight" : m_photonBaselineIso_WP ) );
2308  ATH_CHECK( m_isoBaselineTool.setProperty("OutputLevel", this->msg().level()) );
2309  ATH_CHECK( m_isoBaselineTool.retrieve() );
2310  } else ATH_CHECK( m_isoBaselineTool.retrieve() );
2311 
2312 
2313  if (!m_isoHighPtTool.isUserConfigured()) {
2314  m_isoHighPtTool.setTypeAndName("CP::IsolationSelectionTool/IsoHighPtTool");
2315  ATH_CHECK( m_isoHighPtTool.setProperty("ElectronWP", m_eleIsoHighPt_WP.empty() ? "Loose_VarRad" : m_eleIsoHighPt_WP) );
2316  ATH_CHECK( m_isoHighPtTool.setProperty("MuonWP", m_muIsoHighPt_WP.empty() ? "Loose_VarRad" : m_muIsoHighPt_WP ) );
2317  ATH_CHECK( m_isoHighPtTool.setProperty("PhotonWP", m_photonIso_WP.empty() ? "FixedCutTight" : m_photonIso_WP ) );
2318  ATH_CHECK( m_isoHighPtTool.setProperty("OutputLevel", this->msg().level()) );
2319  ATH_CHECK( m_isoHighPtTool.retrieve() );
2320  } else ATH_CHECK( m_isoHighPtTool.retrieve() );
2321 
2322 
2323  // /////////////////////////////////////////////////////////////////////////////////////////
2324  // Initialise IsolationCloseByCorrectionTool Tool
2325  if (!m_isoCloseByTool.isUserConfigured()) {
2326  m_isoCloseByTool.setTypeAndName("CP::IsolationCloseByCorrectionTool/IsoCloseByTool");
2327  // Actually we could debate about what is the proper tool to choose if the users have different baseline & signal islation WP's
2328  ATH_CHECK( m_isoCloseByTool.setProperty("IsolationSelectionTool", m_useSigLepForIsoCloseByOR ? m_isoTool : m_isoBaselineTool));
2329  ATH_CHECK( m_isoCloseByTool.setProperty("PassoverlapDecorator", m_IsoCloseByORpassLabel) );
2330  ATH_CHECK( m_isoCloseByTool.setProperty("SelectionDecorator", m_useSigLepForIsoCloseByOR ? "signal" : "baseline") );
2331  // Make this propery configurable as well?
2332  ATH_CHECK( m_isoCloseByTool.setProperty("BackupPrefix", "ORIG") );
2333  // The isolation selection decorator is updated as well by the tool
2334  ATH_CHECK( m_isoCloseByTool.setProperty("IsolationSelectionDecorator", "isol") );
2335 
2336  ATH_CHECK( m_isoCloseByTool.setProperty("OutputLevel", this->msg().level()) );
2337 #ifndef XAOD_ANALYSIS
2338  ATH_CHECK( m_isoCloseByTool.setProperty("ParticleCaloExtensionTool", "") );
2339 #endif
2340  ATH_CHECK( m_isoCloseByTool.retrieve() );
2341  } else ATH_CHECK( m_isoCloseByTool.retrieve() );
2342  }
2343 
2344 
2345 // /////////////////////////////////////////////////////////////////////////////////////////
2346 // Initialise Overlap Removal Tool
2347  if ( m_orToolbox.masterTool.empty() ){
2348 
2349  // set up the master tool
2350  std::string suffix = "";
2351  if (m_orDoTau) suffix += "Tau";
2352  if (m_orDoPhoton) suffix += "Gamma";
2353  if (m_orDoBjet) suffix += "Bjet";
2354  std::string toolName = "ORTool" + suffix;
2355  ATH_MSG_INFO("SUSYTools: Autoconfiguring " << toolName);
2356 
2357  std::string bJetLabel = "";
2358  //overwrite lepton flags if the global is false (yes?)
2359  if (!m_orDoBjet || !m_useBtagging) {
2360  m_orDoElBjet = false;
2361  m_orDoMuBjet = false;
2362  m_orDoTauBjet = false;
2363  }
2364  if (m_orDoElBjet || m_orDoMuBjet || m_orDoTauBjet) {
2365  bJetLabel = "bjet_loose";
2366  }
2367 
2368  // Set the generic flags
2369  ORUtils::ORFlags orFlags(toolName, m_orInputLabel, "passOR");
2370  orFlags.bJetLabel = bJetLabel;
2371  orFlags.boostedLeptons = (m_orDoBoostedElectron || m_orDoBoostedMuon);
2372  orFlags.outputPassValue = true;
2373  orFlags.linkOverlapObjects = m_orLinkOverlapObjects;
2374  if (m_orDoElEl) {
2375  orFlags.doEleEleOR = true;
2376  } else orFlags.doEleEleOR = false;
2377  orFlags.doElectrons = true;
2378  orFlags.doMuons = true;
2379  orFlags.doJets = true;
2380  orFlags.doTaus = m_orDoTau;
2381  orFlags.doPhotons = m_orDoPhoton;
2382  orFlags.doFatJets = m_orDoFatjets;
2383 
2384  //set up all recommended tools
2385  ATH_CHECK( ORUtils::recommendedTools(orFlags, m_orToolbox));
2386 
2387  // We don't currently have a good way to determine here which object
2388  // definitions are disabled, so we currently just configure all overlap
2389  // tools and disable the pointer safety checks
2390  ATH_CHECK( m_orToolbox.setGlobalProperty("OutputLevel", this->msg().level()) );
2391  ATH_CHECK( m_orToolbox.masterTool.setProperty("RequireExpectedPointers", false) );
2392 
2393  // Override boosted OR sliding cone options
2394  ATH_CHECK( m_orToolbox.eleJetORT.setProperty("UseSlidingDR", m_orDoBoostedElectron) );
2395  ATH_CHECK( m_orToolbox.muJetORT.setProperty("UseSlidingDR", m_orDoBoostedMuon) );
2396 
2397  //add custom tau-jet OR tool
2398  if(m_orDoTau){
2399  m_orToolbox.tauJetORT.setTypeAndName("ORUtils::TauJetOverlapTool/" + orFlags.masterName + ".TauJetORT");
2400  ATH_CHECK( m_orToolbox.tauJetORT.setProperty("BJetLabel", m_orDoTauBjet?bJetLabel:"") );
2401  }
2402 
2403  // override sliding cone params if sliding dR is on and the user-provided parameter values are non-negative
2404  if (m_orDoBoostedElectron) {
2405  if (m_orBoostedElectronC1 > 0) ATH_CHECK( m_orToolbox.eleJetORT.setProperty("SlidingDRC1", m_orBoostedElectronC1) );
2406  if (m_orBoostedElectronC2 > 0) ATH_CHECK( m_orToolbox.eleJetORT.setProperty("SlidingDRC2", m_orBoostedElectronC2) );
2407  if (m_orBoostedElectronMaxConeSize > 0) ATH_CHECK( m_orToolbox.eleJetORT.setProperty("SlidingDRMaxCone", m_orBoostedElectronMaxConeSize) );
2408  }
2409  if (m_orDoBoostedMuon) {
2410  if (m_orBoostedMuonC1 > 0) ATH_CHECK( m_orToolbox.muJetORT.setProperty("SlidingDRC1", m_orBoostedMuonC1) );
2411  if (m_orBoostedMuonC2 > 0) ATH_CHECK( m_orToolbox.muJetORT.setProperty("SlidingDRC2", m_orBoostedMuonC2) );
2412  if (m_orBoostedMuonMaxConeSize > 0) ATH_CHECK( m_orToolbox.muJetORT.setProperty("SlidingDRMaxCone", m_orBoostedMuonMaxConeSize) );
2413  }
2414 
2415  // and switch off lep-bjet check if not requested
2416  if (!m_orDoElBjet) {
2417  ATH_CHECK(m_orToolbox.eleJetORT.setProperty("BJetLabel", ""));
2418  }
2419  if (!m_orDoMuBjet) {
2420  ATH_CHECK(m_orToolbox.muJetORT.setProperty("BJetLabel", ""));
2421  }
2422 
2423  // propagate the mu-jet ghost-association option which might be set by the user (default is true)
2424  ATH_CHECK(m_orToolbox.muJetORT.setProperty("UseGhostAssociation", m_orDoMuonJetGhostAssociation));
2425 
2426  // propagate mu-jet OR settings if requested
2427  ATH_CHECK(m_orToolbox.muJetORT.setProperty("ApplyRelPt", m_orApplyRelPt) );
2428  if(m_orApplyRelPt){
2429  if (m_orMuJetPtRatio > 0) ATH_CHECK(m_orToolbox.muJetORT.setProperty("MuJetPtRatio", m_orMuJetPtRatio) );
2430  if (m_orMuJetTrkPtRatio > 0) ATH_CHECK(m_orToolbox.muJetORT.setProperty("MuJetTrkPtRatio", m_orMuJetTrkPtRatio) );
2431  }
2432  if (m_orMuJetInnerDR > 0) ATH_CHECK(m_orToolbox.muJetORT.setProperty("InnerDR", m_orMuJetInnerDR) );
2433 
2434  // propagate the calo muon setting for EleMuORT
2435  ATH_CHECK(m_orToolbox.eleMuORT.setProperty("RemoveCaloMuons", m_orRemoveCaloMuons) );
2436 
2437  // Use electron-muon DR matching to remove electrons within DR < 0.01 of Muons.
2438  if (m_orDoElMu){
2439  ATH_CHECK(m_orToolbox.eleMuORT.setProperty("UseDRMatching", m_orDoElMu) );
2440  }
2441 
2442  // propagate the fatjets OR settings
2443  if(m_orDoFatjets){
2444  if(m_EleFatJetDR>0) ATH_CHECK(m_orToolbox.eleFatJetORT.setProperty("DR", m_EleFatJetDR));
2445  if(m_JetFatJetDR>0) ATH_CHECK(m_orToolbox.jetFatJetORT.setProperty("DR", m_JetFatJetDR));
2446  }
2447 
2448  // Make sure that we deal with prorities correctly
2449  ATH_CHECK(m_orToolbox.eleJetORT.setProperty("EnableUserPriority", true));
2450  ATH_CHECK(m_orToolbox.muJetORT.setProperty("EnableUserPriority", true));
2451  if (m_orDoTau) ATH_CHECK(m_orToolbox.tauJetORT.setProperty("EnableUserPriority", true));
2452  if (m_orDoPhoton) ATH_CHECK(m_orToolbox.phoJetORT.setProperty("EnableUserPriority", true));
2453 
2454  if ( m_orPhotonFavoured ) {
2455  ATH_CHECK(m_orToolbox.phoEleORT.setProperty("SwapContainerPrecedence", true));
2456  ATH_CHECK(m_orToolbox.phoMuORT.setProperty("SwapContainerPrecedence", true));
2457  }
2458 
2459  if (!m_orDoEleJet){
2460  // Disable the electron removal part of e-j overlap removal
2461  ATH_CHECK( m_orToolbox.eleJetORT.setProperty("OuterDR",-1.) );
2462  ATH_CHECK( m_orToolbox.eleJetORT.setProperty("SlidingDRMaxCone",-1.) );
2463  }
2464  if (!m_orDoMuonJet){
2465  // Disable the muon removal part of m-j overlap removal
2466  ATH_CHECK( m_orToolbox.muJetORT.setProperty("OuterDR",-1.) );
2467  ATH_CHECK( m_orToolbox.muJetORT.setProperty("SlidingDRMaxCone",-1.) );
2468  }
2469 
2470  ATH_CHECK( m_orToolbox.initialize() );
2471 
2472  }
2473  // Done with the OR toolbox setup!
2474 
2475 // /////////////////////////////////////////////////////////////////////////////////////////
2476 // Initialise PMG Tools
2477  if (!m_pmgSHnjetWeighter.isUserConfigured() && !isData()) {
2478  m_pmgSHnjetWeighter.setTypeAndName("PMGTools::PMGSherpa22VJetsWeightTool/PMGSHVjetReweighter");
2479  ATH_CHECK( m_pmgSHnjetWeighter.setProperty( "TruthJetContainer", "AntiKt4TruthJets"));
2480  ATH_CHECK( m_pmgSHnjetWeighter.setProperty("OutputLevel", this->msg().level()) );
2481  ATH_CHECK( m_pmgSHnjetWeighter.retrieve());
2482  } else if (m_pmgSHnjetWeighter.isUserConfigured()) ATH_CHECK( m_pmgSHnjetWeighter.retrieve());
2483 
2484 
2485  if (!m_pmgSHnjetWeighterWZ.isUserConfigured() && !isData()) {
2486  m_pmgSHnjetWeighterWZ.setTypeAndName("PMGTools::PMGSherpa22VJetsWeightTool/PMGSHVjetReweighterWZ");
2487  ATH_CHECK( m_pmgSHnjetWeighterWZ.setProperty( "TruthJetContainer", "AntiKt4TruthWZJets"));
2488  ATH_CHECK( m_pmgSHnjetWeighterWZ.setProperty("OutputLevel", this->msg().level()) );
2489  ATH_CHECK( m_pmgSHnjetWeighterWZ.retrieve() );
2490  } else if (m_pmgSHnjetWeighterWZ.isUserConfigured()) ATH_CHECK( m_pmgSHnjetWeighterWZ.retrieve() );
2491 
2492 
2493  // prevent these initialiation snippets from being run again
2494  m_subtool_init = true;
2495 
2496  ATH_MSG_INFO("Done initialising SUSYTools");
2497 
2498  return StatusCode::SUCCESS;
2499 }
ST::SUSYObjDef_xAOD::m_WDecorName
std::string m_WDecorName
Definition: SUSYObjDef_xAOD.h:553
ST::SUSYObjDef_xAOD::m_applyJVTCut
bool m_applyJVTCut
Definition: SUSYObjDef_xAOD.h:825
ST::SUSYObjDef_xAOD::m_orBoostedMuonC1
double m_orBoostedMuonC1
Definition: SUSYObjDef_xAOD.h:777
ST::SUSYObjDef_xAOD::m_muonEfficiencySFTool
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonEfficiencySFTool
Definition: SUSYObjDef_xAOD.h:875
asg::AnaToolHandle::initialize
StatusCode initialize()
initialize the tool
ST::SUSYObjDef_xAOD::m_badJetCut
std::string m_badJetCut
Definition: SUSYObjDef_xAOD.h:544
bJetLabel
const std::string bJetLabel
Definition: OverlapRemovalTester.cxx:70
ST::SUSYObjDef_xAOD::m_isoHighPtTool
asg::AnaToolHandle< CP::IIsolationSelectionTool > m_isoHighPtTool
Definition: SUSYObjDef_xAOD.h:979
ORUtils::ORFlags::outputPassValue
bool outputPassValue
Output value to assign passing objects.
Definition: OverlapRemovalInit.h:51
CP::IMuonLRTOverlapRemovalTool::defaultStrategy
@ defaultStrategy
Definition: IMuonLRTOverlapRemovalTool.h:38
ST::SUSYObjDef_xAOD::m_orBoostedElectronC1
double m_orBoostedElectronC1
Definition: SUSYObjDef_xAOD.h:773
ST::SUSYObjDef_xAOD::m_orBoostedMuonC2
double m_orBoostedMuonC2
Definition: SUSYObjDef_xAOD.h:778
LikeEnum::Loose
@ Loose
Definition: LikelihoodEnums.h:12
TrigJetMonitorAlgorithm.jetcoll
jetcoll
Definition: TrigJetMonitorAlgorithm.py:1225
temp
Definition: JetEventDict.h:21
ST::SUSYObjDef_xAOD::m_deadHVTool
asg::AnaToolHandle< IAsgDeadHVCellRemovalTool > m_deadHVTool
Definition: SUSYObjDef_xAOD.h:906
ORUtils::ORFlags::boostedLeptons
bool boostedLeptons
Activate boosted-lepton recommendations (sliding dR cones)
Definition: OverlapRemovalInit.h:48
ST::SUSYObjDef_xAOD::m_doPhiReso
bool m_doPhiReso
Definition: SUSYObjDef_xAOD.h:594
ST::SUSYObjDef_xAOD::m_jetfJvtEfficiencyTool
asg::AnaToolHandle< CP::IJvtEfficiencyTool > m_jetfJvtEfficiencyTool
Definition: SUSYObjDef_xAOD.h:847
ST::SUSYObjDef_xAOD::m_tauSelTool
asg::AnaToolHandle< TauAnalysisTools::ITauSelectionTool > m_tauSelTool
Definition: SUSYObjDef_xAOD.h:920
ST::SUSYObjDef_xAOD::m_ZconfigReader
TEnv m_ZconfigReader
Definition: SUSYObjDef_xAOD.h:551
ST::SUSYObjDef_xAOD::m_doTTVAsf
bool m_doTTVAsf
Definition: SUSYObjDef_xAOD.h:526
ST::SUSYObjDef_xAOD::m_fJvtWP
std::string m_fJvtWP
Definition: SUSYObjDef_xAOD.h:753
ST::SUSYObjDef_xAOD::m_metDoSetMuonJetEMScale
bool m_metDoSetMuonJetEMScale
Definition: SUSYObjDef_xAOD.h:580
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
ST::SUSYObjDef_xAOD::m_muBaselineEta
double m_muBaselineEta
Definition: SUSYObjDef_xAOD.h:707
ST::SUSYObjDef_xAOD::m_trigGlobalEffCorrTool_multiLep
asg::AnaToolHandle< ITrigGlobalEfficiencyCorrectionTool > m_trigGlobalEffCorrTool_multiLep
Definition: SUSYObjDef_xAOD.h:959
Enums.h
ST::SUSYObjDef_xAOD::m_trigNToys_diLep
int m_trigNToys_diLep
Definition: SUSYObjDef_xAOD.h:945
ST::SUSYObjDef_xAOD::m_jetUncertaintiesCalibArea
std::string m_jetUncertaintiesCalibArea
Definition: SUSYObjDef_xAOD.h:533
ST::SUSYObjDef_xAOD::m_jesConfigAFII
std::string m_jesConfigAFII
Definition: SUSYObjDef_xAOD.h:863
ST::SUSYObjDef_xAOD::m_BtagSystStrategy
std::string m_BtagSystStrategy
Definition: SUSYObjDef_xAOD.h:681
ST::SUSYObjDef_xAOD::m_tauEffToolRecommendationTag
std::string m_tauEffToolRecommendationTag
Definition: SUSYObjDef_xAOD.h:736
ST::SUSYObjDef_xAOD::m_tauIdBaseline
std::string m_tauIdBaseline
Definition: SUSYObjDef_xAOD.h:656
hotSpotInTAG.suffix
string suffix
Definition: hotSpotInTAG.py:185
LikeEnum::VeryLoose
@ VeryLoose
Definition: LikelihoodEnums.h:11
ST::SUSYObjDef_xAOD::m_showerType
int m_showerType
Definition: SUSYObjDef_xAOD.h:812
ST::SUSYObjDef_xAOD::m_photonTrigEffTools
ToolHandleArray< IAsgPhotonEfficiencyCorrectionTool > m_photonTrigEffTools
Definition: SUSYObjDef_xAOD.h:914
ORUtils::ToolBox::eleMuORT
OverlapHandle_t eleMuORT
Definition: ToolBox.h:70
ST::SUSYObjDef_xAOD::m_eleIsoHighPt_WP
std::string m_eleIsoHighPt_WP
Definition: SUSYObjDef_xAOD.h:658
ST::SUSYObjDef_xAOD::m_BtagWP
std::string m_BtagWP
Definition: SUSYObjDef_xAOD.h:677
ST::SUSYObjDef_xAOD::m_eleAllowRun3TrigSFFallback
bool m_eleAllowRun3TrigSFFallback
Definition: SUSYObjDef_xAOD.h:702
ST::SUSYObjDef_xAOD::m_egammaCalibTool
asg::AnaToolHandle< CP::IEgammaCalibrationAndSmearingTool > m_egammaCalibTool
Combined electron collection.
Definition: SUSYObjDef_xAOD.h:901
ST::SUSYObjDef_xAOD::m_trig2016combination_diPhoton
std::string m_trig2016combination_diPhoton
Definition: SUSYObjDef_xAOD.h:963
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
ST::SUSYObjDef_xAOD::split
const std::vector< std::string > split(const std::string &s, const std::string &delim) const
Definition: SUSYObjDef_xAOD.cxx:1811
ST::SUSYObjDef_xAOD::m_metDoRemoveMuonJets
bool m_metDoRemoveMuonJets
Definition: SUSYObjDef_xAOD.h:581
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:138
ST::SUSYObjDef_xAOD::m_label_truthKey
SG::ReadDecorHandleKey< xAOD::JetContainer > m_label_truthKey
Definition: SUSYObjDef_xAOD.h:857
ST::SUSYObjDef_xAOD::m_orMuJetInnerDR
double m_orMuJetInnerDR
Definition: SUSYObjDef_xAOD.h:783
ST::SUSYObjDef_xAOD::m_muonEfficiencyBMHighPtSFTool
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonEfficiencyBMHighPtSFTool
Definition: SUSYObjDef_xAOD.h:876
ST::SUSYObjDef_xAOD::m_pmgSHnjetWeighterWZ
asg::AnaToolHandle< IWeightTool > m_pmgSHnjetWeighterWZ
Definition: SUSYObjDef_xAOD.h:990
IAsgPhotonIsEMSelector.h
ST::SUSYObjDef_xAOD::m_legsPerTool
std::map< std::string, std::string > m_legsPerTool
Definition: SUSYObjDef_xAOD.h:829
ST::SUSYObjDef_xAOD::m_orDoElBjet
bool m_orDoElBjet
Definition: SUSYObjDef_xAOD.h:769
ST::SUSYObjDef_xAOD::m_tauSmearingToolGenerator
std::string m_tauSmearingToolGenerator
Definition: SUSYObjDef_xAOD.h:737
TauAnalysisTools::JETIDRNNTIGHT
@ JETIDRNNTIGHT
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:22
ST::SUSYObjDef_xAOD::m_trigGlobalEffCorrTool_diPhoton
asg::AnaToolHandle< ITrigGlobalEfficiencyCorrectionTool > m_trigGlobalEffCorrTool_diPhoton
Definition: SUSYObjDef_xAOD.h:967
asg::AnaToolHandle::retrieve
StatusCode retrieve()
initialize the tool
ST::SUSYObjDef_xAOD::m_fatJetUncertaintiesPDsmearing
bool m_fatJetUncertaintiesPDsmearing
Definition: SUSYObjDef_xAOD.h:547
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_reco
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_reco
Combined muon collection.
Definition: SUSYObjDef_xAOD.h:885
IAsgElectronEfficiencyCorrectionTool.h
ITrigConfigTool.h
ST::SUSYObjDef_xAOD::m_elecSelLikelihood
asg::AnaToolHandle< IAsgElectronLikelihoodTool > m_elecSelLikelihood
Definition: SUSYObjDef_xAOD.h:902
ITrigGlobalEfficiencyCorrectionTool.h
ST::SUSYObjDef_xAOD::m_orMuJetPtRatio
double m_orMuJetPtRatio
Definition: SUSYObjDef_xAOD.h:781
IIsolationCloseByCorrectionTool.h
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_trig_mixLep
std::vector< asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > > m_elecEfficiencySFTool_trig_mixLep
Definition: SUSYObjDef_xAOD.h:893
TauAnalysisTools::JETIDRNNMEDIUM
@ JETIDRNNMEDIUM
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:21
ORUtils::ORFlags::doEleEleOR
bool doEleEleOR
Do electron-electron overlap.
Definition: OverlapRemovalInit.h:55
IsoCloseByCorrectionTest.WP
WP
Definition: IsoCloseByCorrectionTest.py:56
ST::SUSYObjDef_xAOD::m_jetNNJvtMomentTool
asg::AnaToolHandle< JetPileupTag::JetVertexNNTagger > m_jetNNJvtMomentTool
Definition: SUSYObjDef_xAOD.h:843
ST::SUSYObjDef_xAOD::m_muTriggerSFCalibRelease
std::string m_muTriggerSFCalibRelease
Definition: SUSYObjDef_xAOD.h:675
ST::SUSYObjDef_xAOD::m_EigenvectorReductionC
std::string m_EigenvectorReductionC
Definition: SUSYObjDef_xAOD.h:683
ST::SUSYObjDef_xAOD::m_fJvtConfigRun2
std::string m_fJvtConfigRun2
Definition: SUSYObjDef_xAOD.h:756
ST
Definition: Electrons.cxx:41
PATCore::ParticleDataType::Fast
@ Fast
Definition: PATCoreEnums.h:22
ST::SUSYObjDef_xAOD::m_photonTriggerSFTool
asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > m_photonTriggerSFTool
Definition: SUSYObjDef_xAOD.h:909
ST::SUSYObjDef_xAOD::m_isoBaselineTool
asg::AnaToolHandle< CP::IIsolationSelectionTool > m_isoBaselineTool
Definition: SUSYObjDef_xAOD.h:978
ST::SUSYObjDef_xAOD::m_elecTrigEffTools
ToolHandleArray< IAsgElectronEfficiencyCorrectionTool > m_elecTrigEffTools
Definition: SUSYObjDef_xAOD.h:896
ST::SUSYObjDef_xAOD::m_JvtConfigRun2
std::string m_JvtConfigRun2
Definition: SUSYObjDef_xAOD.h:746
ST::SUSYObjDef_xAOD::m_tauSmearingTool
asg::AnaToolHandle< TauAnalysisTools::ITauSmearingTool > m_tauSmearingTool
Definition: SUSYObjDef_xAOD.h:922
ST::SUSYObjDef_xAOD::m_jetInputType
int m_jetInputType
Definition: SUSYObjDef_xAOD.h:520
ST::SUSYObjDef_xAOD::m_el_iso_support
std::vector< std::string > m_el_iso_support
Definition: SUSYObjDef_xAOD.h:633
ORUtils::ORFlags::doPhotons
bool doPhotons
Definition: OverlapRemovalInit.h:63
asg::AnaToolHandle::setTypeAndName
void setTypeAndName(const std::string &val_typeAndName)
set the value of type and name
ORUtils::recommendedTools
StatusCode recommendedTools(const ORFlags &flags, ToolBox &toolBox)
Pre-configured standard recommended OR tools.
Definition: OverlapRemovalInit.cxx:50
ST::SUSYObjDef_xAOD::m_metRemoveOverlappingCaloTaggedMuons
bool m_metRemoveOverlappingCaloTaggedMuons
Definition: SUSYObjDef_xAOD.h:579
ST::SUSYObjDef_xAOD::m_metMaker
asg::AnaToolHandle< IMETMaker > m_metMaker
Definition: SUSYObjDef_xAOD.h:933
ST::SUSYObjDef_xAOD::m_trig2018combination_diPhoton
std::string m_trig2018combination_diPhoton
Definition: SUSYObjDef_xAOD.h:965
ST::SUSYObjDef_xAOD::m_trigNToys_diPhoton
int m_trigNToys_diPhoton
Definition: SUSYObjDef_xAOD.h:961
CP::SystematicSet
Class to wrap a set of SystematicVariations.
Definition: SystematicSet.h:31
ST::SUSYObjDef_xAOD::m_TopTaggerTool
asg::AnaToolHandle< JSSWTopTaggerDNN > m_TopTaggerTool
Definition: SUSYObjDef_xAOD.h:851
ST::SUSYObjDef_xAOD::m_orBtagWP
std::string m_orBtagWP
Definition: SUSYObjDef_xAOD.h:786
TauAnalysisTools::JETIDRNNLOOSE
@ JETIDRNNLOOSE
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:20
ST::SUSYObjDef_xAOD::m_muId
int m_muId
Definition: SUSYObjDef_xAOD.h:651
ST::SUSYObjDef_xAOD::m_photonIso_WP
std::string m_photonIso_WP
Definition: SUSYObjDef_xAOD.h:667
ST::SUSYObjDef_xAOD::m_muonTTVAEfficiencySFTool
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonTTVAEfficiencySFTool
Definition: SUSYObjDef_xAOD.h:877
ST::SUSYObjDef_xAOD::m_el_iso_fallback
std::map< std::string, std::string > m_el_iso_fallback
Definition: SUSYObjDef_xAOD.h:637
SUSYObjDef_xAOD.h
ORUtils::ORFlags::doElectrons
bool doElectrons
Definition: OverlapRemovalInit.h:59
ST::SUSYObjDef_xAOD::m_BtagMinPt
double m_BtagMinPt
Definition: SUSYObjDef_xAOD.h:679
IMETMaker.h
TrigDecisionTool.h
ST::SUSYObjDef_xAOD::m_fatjetFFSmearingSyst
std::vector< CP::SystematicSet > m_fatjetFFSmearingSyst
Definition: SUSYObjDef_xAOD.h:821
ST::SUSYObjDef_xAOD::m_trkJetsyst
bool m_trkJetsyst
Definition: SUSYObjDef_xAOD.h:590
ST::SUSYObjDef_xAOD::m_orDoTau
bool m_orDoTau
Overlap removal options.
Definition: SUSYObjDef_xAOD.h:762
ST::SUSYObjDef_xAOD::m_prwTool
asg::AnaToolHandle< CP::IPileupReweightingTool > m_prwTool
Definition: SUSYObjDef_xAOD.h:982
ST::SUSYObjDef_xAOD::m_muBaselineIso_WP
std::string m_muBaselineIso_WP
Definition: SUSYObjDef_xAOD.h:669
ST::SUSYObjDef_xAOD::m_trig2016combination_multiLep
std::string m_trig2016combination_multiLep
Definition: SUSYObjDef_xAOD.h:955
ST::SUSYObjDef_xAOD::m_WTaggerTool
asg::AnaToolHandle< SmoothedWZTagger > m_WTaggerTool
Definition: SUSYObjDef_xAOD.h:849
ITauSelectionTool.h
ST::SUSYObjDef_xAOD::m_eleConfigBaseline
std::string m_eleConfigBaseline
Definition: SUSYObjDef_xAOD.h:648
IMETSignificance.h
ST::SUSYObjDef_xAOD::m_bTaggingCalibrationFilePath
std::string m_bTaggingCalibrationFilePath
Definition: SUSYObjDef_xAOD.h:827
IAsgPhotonEfficiencyCorrectionTool.h
ORUtils::ToolBox::eleFatJetORT
OverlapHandle_t eleFatJetORT
Definition: ToolBox.h:79
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
IMETSystematicsTool.h
ST::SUSYObjDef_xAOD::m_metDoMuonEloss
bool m_metDoMuonEloss
Definition: SUSYObjDef_xAOD.h:583
ST::SUSYObjDef_xAOD::m_photonTrigSFTools
ToolHandleArray< IAsgPhotonEfficiencyCorrectionTool > m_photonTrigSFTools
Definition: SUSYObjDef_xAOD.h:913
ST::SUSYObjDef_xAOD::m_orDoFatjets
bool m_orDoFatjets
Definition: SUSYObjDef_xAOD.h:792
ST::SUSYObjDef_xAOD::m_trigMatchingTool
asg::AnaToolHandle< Trig::IMatchingTool > m_trigMatchingTool
Definition: SUSYObjDef_xAOD.h:971
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
ST::SUSYObjDef_xAOD::m_jetUncertaintiesPDSmearTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_jetUncertaintiesPDSmearTool
Definition: SUSYObjDef_xAOD.h:835
IJetSelector.h
ORUtils::ORFlags::doFatJets
bool doFatJets
Definition: OverlapRemovalInit.h:64
ST::SUSYObjDef_xAOD::m_elecLRTORTool
asg::AnaToolHandle< CP::IElectronLRTOverlapRemovalTool > m_elecLRTORTool
Definition: SUSYObjDef_xAOD.h:897
TauAnalysisTools::JETIDNONE
@ JETIDNONE
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:14
asg::AnaToolHandle::setProperty
StatusCode setProperty(const std::string &property, const T2 &value)
set the given property of the tool.
xAOD::JetInput::typeName
const std::string & typeName(Type id)
Definition: JetContainerInfo.cxx:199
ST::SUSYObjDef_xAOD::m_trig2017combination_diPhoton
std::string m_trig2017combination_diPhoton
Definition: SUSYObjDef_xAOD.h:964
IJetModifier.h
IJetDecorator.h
ST::SUSYObjDef_xAOD::m_mu_iso_support
std::vector< std::string > m_mu_iso_support
Definition: SUSYObjDef_xAOD.h:634
PATCore::ParticleDataType::Data
@ Data
Definition: PATCoreEnums.h:22
ITauEfficiencyCorrectionsTool.h
ST::SUSYObjDef_xAOD::m_fatJetUncVars
std::string m_fatJetUncVars
Definition: SUSYObjDef_xAOD.h:548
ST::SUSYObjDef_xAOD::m_orDoBjet
bool m_orDoBjet
Definition: SUSYObjDef_xAOD.h:768
ST::SUSYObjDef_xAOD::m_eleEffMapFilePath
std::string m_eleEffMapFilePath
Definition: SUSYObjDef_xAOD.h:700
ST::SUSYObjDef_xAOD::m_orDoPhoton
bool m_orDoPhoton
Definition: SUSYObjDef_xAOD.h:763
ST::SUSYObjDef_xAOD::m_jetJvtMomentTool
asg::AnaToolHandle< JetVertexTaggerTool > m_jetJvtMomentTool
Definition: SUSYObjDef_xAOD.h:842
ST::SUSYObjDef_xAOD::m_eleIdBaseline
std::string m_eleIdBaseline
Definition: SUSYObjDef_xAOD.h:646
IJetCalibrationTool.h
PATCore::ParticleDataType::DataType
DataType
Definition: PATCoreEnums.h:22
ST::SUSYObjDef_xAOD::m_orToolbox
ORUtils::ToolBox m_orToolbox
Definition: SUSYObjDef_xAOD.h:987
ST::SUSYObjDef_xAOD::m_tauConfigPath
std::string m_tauConfigPath
Definition: SUSYObjDef_xAOD.h:732
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:92
TauAnalysisTools::ELEIDRNNLOOSE
@ ELEIDRNNLOOSE
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:42
ST::SUSYObjDef_xAOD::m_muonLRTORTool
asg::AnaToolHandle< CP::IMuonLRTOverlapRemovalTool > m_muonLRTORTool
Definition: SUSYObjDef_xAOD.h:882
ORUtils::ToolBox::setGlobalProperty
StatusCode setGlobalProperty(const std::string &property, const T &value)
Apply a global property to all tools.
Definition: ToolBox.h:104
ST::SUSYObjDef_xAOD::m_JvtPtMax
double m_JvtPtMax
Definition: SUSYObjDef_xAOD.h:745
IEGammaAmbiguityTool.h
ST::SUSYObjDef_xAOD::m_btagEffTool_trkJet
asg::AnaToolHandle< IBTaggingEfficiencyTool > m_btagEffTool_trkJet
Definition: SUSYObjDef_xAOD.h:930
ORUtils::ToolBox::muJetORT
OverlapHandle_t muJetORT
Definition: ToolBox.h:72
ST::SUSYObjDef_xAOD::m_slices
std::map< std::string, bool > m_slices
Definition: SUSYObjDef_xAOD.h:806
ST::SUSYObjDef_xAOD::m_orLinkOverlapObjects
bool m_orLinkOverlapObjects
Definition: SUSYObjDef_xAOD.h:790
IMuonSelectionTool.h
PATCore::ParticleDataType::Full
@ Full
Definition: PATCoreEnums.h:22
ST::SUSYObjDef_xAOD::m_eleEffMapFilePathRun2
std::string m_eleEffMapFilePathRun2
Definition: SUSYObjDef_xAOD.h:701
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_isoHighPt
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_isoHighPt
Definition: SUSYObjDef_xAOD.h:890
ST::SUSYObjDef_xAOD::m_orBoostedMuonMaxConeSize
double m_orBoostedMuonMaxConeSize
Definition: SUSYObjDef_xAOD.h:779
ST::SUSYObjDef_xAOD::m_photonEfficiencySFTool
asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > m_photonEfficiencySFTool
Definition: SUSYObjDef_xAOD.h:907
ORUtils::ToolBox::eleJetORT
OverlapHandle_t eleJetORT
Definition: ToolBox.h:71
PyPoolBrowser.item
item
Definition: PyPoolBrowser.py:129
ST::SUSYObjDef_xAOD::m_tau_trig_support
std::map< std::string, std::string > m_tau_trig_support
Definition: SUSYObjDef_xAOD.h:643
ST::SUSYObjDef_xAOD::m_trigGlobalEffCorrTool_diLep
asg::AnaToolHandle< ITrigGlobalEfficiencyCorrectionTool > m_trigGlobalEffCorrTool_diLep
Definition: SUSYObjDef_xAOD.h:951
ST::SUSYObjDef_xAOD::m_WZTaggerCalibArea
std::string m_WZTaggerCalibArea
Definition: SUSYObjDef_xAOD.h:559
IMuonEfficiencyScaleFactors.h
ST::SUSYObjDef_xAOD::m_prwLcalcFiles
std::vector< std::string > m_prwLcalcFiles
Definition: SUSYObjDef_xAOD.h:616
ST::SUSYObjDef_xAOD::m_prwDataSF_DW
double m_prwDataSF_DW
Definition: SUSYObjDef_xAOD.h:625
IBTaggingEfficiencyTool.h
ST::SUSYObjDef_xAOD::m_orDoBoostedMuon
bool m_orDoBoostedMuon
Definition: SUSYObjDef_xAOD.h:776
IEgammaCalibrationAndSmearingTool.h
ST::SUSYObjDef_xAOD::m_el_id_support
std::vector< std::string > m_el_id_support
Definition: SUSYObjDef_xAOD.h:629
ITauTruthMatchingTool.h
ST::SUSYObjDef_xAOD::m_defaultJets
std::string m_defaultJets
Definition: SUSYObjDef_xAOD.h:814
ST::SUSYObjDef_xAOD::m_useBtagging
bool m_useBtagging
Definition: SUSYObjDef_xAOD.h:538
ST::SUSYObjDef_xAOD::m_ph_id_support
std::vector< std::string > m_ph_id_support
Definition: SUSYObjDef_xAOD.h:630
IAsgElectronLikelihoodTool.h
ST::SUSYObjDef_xAOD::SUSYToolsInit
StatusCode SUSYToolsInit()
Definition: SUSYToolsInit.cxx:113
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_trigEff_mixLep
std::vector< asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > > m_elecEfficiencySFTool_trigEff_mixLep
Definition: SUSYObjDef_xAOD.h:894
IMatchScoringTool.h
ST::SUSYObjDef_xAOD::m_TopTaggerCalibArea
std::string m_TopTaggerCalibArea
Definition: SUSYObjDef_xAOD.h:560
IBTaggingSelectionTool.h
IIsolationCorrectionTool.h
ST::SUSYObjDef_xAOD::m_fatJetUncConfig
std::string m_fatJetUncConfig
Definition: SUSYObjDef_xAOD.h:546
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_id
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_id
Definition: SUSYObjDef_xAOD.h:886
IPileupReweightingTool.h
ST::SUSYObjDef_xAOD::m_tauConfigReader
TEnv m_tauConfigReader
Definition: SUSYObjDef_xAOD.h:739
ST::SUSYObjDef_xAOD::m_IsoCloseByORpassLabel
std::string m_IsoCloseByORpassLabel
Definition: SUSYObjDef_xAOD.h:802
ST::SUSYObjDef_xAOD::m_tauSmearingToolRecommendationTag
std::string m_tauSmearingToolRecommendationTag
Definition: SUSYObjDef_xAOD.h:735
ST::SUSYObjDef_xAOD::m_jetUncertaintiesConfig
std::string m_jetUncertaintiesConfig
Prefix for trigger matchiing container name.
Definition: SUSYObjDef_xAOD.h:531
ST::SUSYObjDef_xAOD::m_jetCalibTool
asg::AnaToolHandle< IJetCalibrationTool > m_jetCalibTool
Definition: SUSYObjDef_xAOD.h:832
fillPileUpNoiseLumi.next
next
Definition: fillPileUpNoiseLumi.py:52
ST::SUSYObjDef_xAOD::m_mu_iso_fallback
std::map< std::string, std::string > m_mu_iso_fallback
Definition: SUSYObjDef_xAOD.h:638
ST::SUSYObjDef_xAOD::m_photonEfficiencySFTool_trigEff_AsymDiphoton
std::vector< asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > > m_photonEfficiencySFTool_trigEff_AsymDiphoton
Definition: SUSYObjDef_xAOD.h:912
ST::SUSYObjDef_xAOD::m_trigNToys_multiLep
int m_trigNToys_multiLep
Definition: SUSYObjDef_xAOD.h:953
ST::SUSYObjDef_xAOD::m_BtagTagger
std::string m_BtagTagger
Definition: SUSYObjDef_xAOD.h:678
lumiFormat.i
int i
Definition: lumiFormat.py:85
ST::SUSYObjDef_xAOD::m_photonEfficiencySFTool_trigSF_AsymDiphoton
std::vector< asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > > m_photonEfficiencySFTool_trigSF_AsymDiphoton
Definition: SUSYObjDef_xAOD.h:911
SystematicRegistry.h
ST::SUSYObjDef_xAOD::m_orDoEleJet
bool m_orDoEleJet
Definition: SUSYObjDef_xAOD.h:764
ST::SUSYObjDef_xAOD::m_orPhotonFavoured
bool m_orPhotonFavoured
Definition: SUSYObjDef_xAOD.h:788
ST::SUSYObjDef_xAOD::m_jesCalibArea
std::string m_jesCalibArea
Definition: SUSYObjDef_xAOD.h:869
JSSWTopTaggerDNN.h
ORUtils::ToolBox::jetFatJetORT
OverlapHandle_t jetFatJetORT
Definition: ToolBox.h:80
ST::SUSYObjDef_xAOD::m_muonIsolationSFTool
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonIsolationSFTool
Definition: SUSYObjDef_xAOD.h:878
ST::SUSYObjDef_xAOD::m_jesCalibSeq
std::string m_jesCalibSeq
Definition: SUSYObjDef_xAOD.h:866
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
ST::SUSYObjDef_xAOD::m_muEta
double m_muEta
Definition: SUSYObjDef_xAOD.h:709
ST::SUSYObjDef_xAOD::m_jetUncertaintiesTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_jetUncertaintiesTool
Definition: SUSYObjDef_xAOD.h:834
CONFIG_EG_EFF_TOOL_KEY
#define CONFIG_EG_EFF_TOOL_KEY(TOOLHANDLE, TOOLNAME, KEYNAME, KEY, MAP)
Definition: SUSYToolsInit.cxx:100
ORUtils::ORFlags::bJetLabel
std::string bJetLabel
B-jet decoration.
Definition: OverlapRemovalInit.h:43
ST::SUSYObjDef_xAOD::m_orApplyRelPt
bool m_orApplyRelPt
Definition: SUSYObjDef_xAOD.h:780
ST::SUSYObjDef_xAOD::m_muTriggerSFCalibFilename
std::string m_muTriggerSFCalibFilename
Definition: SUSYObjDef_xAOD.h:676
ST::SUSYObjDef_xAOD::m_muonCalibTool
asg::AnaToolHandle< CP::IMuonCalibrationAndSmearingTool > m_muonCalibTool
Definition: SUSYObjDef_xAOD.h:874
ST::SUSYObjDef_xAOD::m_ZTaggerTool
asg::AnaToolHandle< SmoothedWZTagger > m_ZTaggerTool
Definition: SUSYObjDef_xAOD.h:850
ST::SUSYObjDef_xAOD::m_orDoMuBjet
bool m_orDoMuBjet
Definition: SUSYObjDef_xAOD.h:770
PATCoreEnums.h
ST::SUSYObjDef_xAOD::m_orRemoveCaloMuons
bool m_orRemoveCaloMuons
Definition: SUSYObjDef_xAOD.h:785
ST::SUSYObjDef_xAOD::m_trig2017combination_multiLep
std::string m_trig2017combination_multiLep
Definition: SUSYObjDef_xAOD.h:956
ST::SUSYObjDef_xAOD::m_prwDataSF
double m_prwDataSF
Definition: SUSYObjDef_xAOD.h:623
IMuonTriggerScaleFactors.h
ORUtils::ToolBox::initialize
StatusCode initialize()
Attach and initialize all tools.
Definition: ToolBox.cxx:35
ST::SUSYObjDef_xAOD::m_jetUncertaintiesMCType
std::string m_jetUncertaintiesMCType
Definition: SUSYObjDef_xAOD.h:534
AAH::setProperty
static StatusCode setProperty(const GaudiHandleBase &toolHandle, const std::string &property, const int &value, bool override=true)
Definition: AthAnalysisHelper.h:401
ST::SUSYObjDef_xAOD::m_jetUncertaintiesAnalysisFile
std::string m_jetUncertaintiesAnalysisFile
Definition: SUSYObjDef_xAOD.h:532
JetTruthLabelingTool.h
ST::SUSYObjDef_xAOD::m_legsPerTool_ph
std::map< std::string, std::string > m_legsPerTool_ph
Definition: SUSYObjDef_xAOD.h:830
ST::SUSYObjDef_xAOD::m_WconfigReader
TEnv m_WconfigReader
Definition: SUSYObjDef_xAOD.h:550
ST::SUSYObjDef_xAOD::m_jetfJvtSelectionTool
asg::AnaToolHandle< IAsgSelectionTool > m_jetfJvtSelectionTool
Definition: SUSYObjDef_xAOD.h:846
ST::SUSYObjDef_xAOD::m_photonSelIsEM
asg::AnaToolHandle< IAsgPhotonIsEMSelector > m_photonSelIsEM
Definition: SUSYObjDef_xAOD.h:904
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
ST::SUSYObjDef_xAOD::m_trig2016combination_diLep
std::string m_trig2016combination_diLep
Definition: SUSYObjDef_xAOD.h:947
ST::SUSYObjDef_xAOD::m_jetUncertaintiesPDsmearing
bool m_jetUncertaintiesPDsmearing
Definition: SUSYObjDef_xAOD.h:536
ST::SUSYObjDef_xAOD::m_metSystTool
asg::AnaToolHandle< IMETSystematicsTool > m_metSystTool
Definition: SUSYObjDef_xAOD.h:934
ST::SUSYObjDef_xAOD::m_BtagMinPt_trkJet
double m_BtagMinPt_trkJet
Definition: SUSYObjDef_xAOD.h:687
ST::SUSYObjDef_xAOD::m_orDoElEl
bool m_orDoElEl
Definition: SUSYObjDef_xAOD.h:765
ST::SUSYObjDef_xAOD::m_jetPileupLabelingTool
asg::AnaToolHandle< JetPileupLabelingTool > m_jetPileupLabelingTool
Definition: SUSYObjDef_xAOD.h:841
ST::SUSYObjDef_xAOD::m_trigMatchingPrefix
std::string m_trigMatchingPrefix
Use composite trigger matching tool if matching was done upstream.
Definition: SUSYObjDef_xAOD.h:529
ORUtils::ToolBox::tauJetORT
OverlapHandle_t tauJetORT
Definition: ToolBox.h:75
ST::SUSYObjDef_xAOD::m_metUseGhostMuons
bool m_metUseGhostMuons
Definition: SUSYObjDef_xAOD.h:582
ST::SUSYObjDef_xAOD::m_tauSelToolBaseline
asg::AnaToolHandle< TauAnalysisTools::ITauSelectionTool > m_tauSelToolBaseline
Definition: SUSYObjDef_xAOD.h:921
ST::SUSYObjDef_xAOD::isData
bool isData() const override final
Definition: SUSYObjDef_xAOD.h:157
ST::SUSYObjDef_xAOD::m_prwDataSF_UP
double m_prwDataSF_UP
Definition: SUSYObjDef_xAOD.h:624
ST::SUSYObjDef_xAOD::m_trig2018combination_diLep
std::string m_trig2018combination_diLep
Definition: SUSYObjDef_xAOD.h:949
ST::SUSYObjDef_xAOD::m_jesConfigFat
std::string m_jesConfigFat
Definition: SUSYObjDef_xAOD.h:864
ST::SUSYObjDef_xAOD::m_muIso_WP
std::string m_muIso_WP
Definition: SUSYObjDef_xAOD.h:670
ST::SUSYObjDef_xAOD::isAtlfast
bool isAtlfast() const override final
Definition: SUSYObjDef_xAOD.h:158
ST::SUSYObjDef_xAOD::m_trig2015combination_multiLep
std::string m_trig2015combination_multiLep
Definition: SUSYObjDef_xAOD.h:954
ST::SUSYObjDef_xAOD::m_btagSelTool_trkJet
asg::AnaToolHandle< IBTaggingSelectionTool > m_btagSelTool_trkJet
Definition: SUSYObjDef_xAOD.h:931
ST::SUSYObjDef_xAOD::m_fatjetUncertaintiesTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_fatjetUncertaintiesTool
Definition: SUSYObjDef_xAOD.h:836
TauAnalysisTools::ELEIDRNNMEDIUM
@ ELEIDRNNMEDIUM
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:43
ORUtils::ORFlags::doTaus
bool doTaus
Definition: OverlapRemovalInit.h:62
xAOD::JetInput::Type
Type
Definition: JetContainerInfo.h:54
IElectronLRTOverlapRemovalTool.h
xAOD::JetInput::EMPFlow
@ EMPFlow
Definition: JetContainerInfo.h:64
ST::SUSYObjDef_xAOD::m_runDepPrescaleWeightPRW
bool m_runDepPrescaleWeightPRW
Definition: SUSYObjDef_xAOD.h:626
IAsgDeadHVCellRemovalTool.h
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_trigEff_singleLep
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_trigEff_singleLep
Definition: SUSYObjDef_xAOD.h:888
ST::SUSYObjDef_xAOD::m_orDoElMu
bool m_orDoElMu
Definition: SUSYObjDef_xAOD.h:766
ST::SUSYObjDef_xAOD::m_photonBaselineIso_WP
std::string m_photonBaselineIso_WP
Definition: SUSYObjDef_xAOD.h:666
ST::SUSYObjDef_xAOD::m_eleId
std::string m_eleId
Definition: SUSYObjDef_xAOD.h:645
ST::SUSYObjDef_xAOD::m_muIdBaseline
int m_muIdBaseline
Definition: SUSYObjDef_xAOD.h:652
ST::SUSYObjDef_xAOD::m_eleIso_WP
std::string m_eleIso_WP
Definition: SUSYObjDef_xAOD.h:657
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_iso
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_iso
Definition: SUSYObjDef_xAOD.h:889
ST::SUSYObjDef_xAOD::m_prwConfFiles
std::vector< std::string > m_prwConfFiles
Definition: SUSYObjDef_xAOD.h:615
ST::SUSYObjDef_xAOD::m_metJetSelection
std::string m_metJetSelection
Definition: SUSYObjDef_xAOD.h:810
ORUtils::ToolBox::phoMuORT
OverlapHandle_t phoMuORT
Definition: ToolBox.h:77
CP::IReentrantSystematicsTool::recommendedSystematics
virtual SystematicSet recommendedSystematics() const =0
the list of all systematics this tool recommends to use
ST::SUSYObjDef_xAOD::m_tauTruthMatch
asg::AnaToolHandle< TauAnalysisTools::ITauTruthMatchingTool > m_tauTruthMatch
Definition: SUSYObjDef_xAOD.h:923
LikeEnum::Tight
@ Tight
Definition: LikelihoodEnums.h:15
ST::SUSYObjDef_xAOD::m_fJvtPtMax
double m_fJvtPtMax
Definition: SUSYObjDef_xAOD.h:754
ST::SUSYObjDef_xAOD::EG_WP
std::string EG_WP(const std::string &wp) const
Definition: SUSYObjDef_xAOD.cxx:1227
ORUtils::ToolBox::phoEleORT
OverlapHandle_t phoEleORT
Definition: ToolBox.h:76
ST::SUSYObjDef_xAOD::check_isOption
bool check_isOption(const std::string &wp, const std::vector< std::string > &list) const
Definition: SUSYObjDef_xAOD.cxx:1215
ST::SUSYObjDef_xAOD::m_eleForceFullSimCalib
bool m_eleForceFullSimCalib
Definition: SUSYObjDef_xAOD.h:703
ST::SUSYObjDef_xAOD::m_elecSelLikelihoodBaseline
asg::AnaToolHandle< IAsgElectronLikelihoodTool > m_elecSelLikelihoodBaseline
Definition: SUSYObjDef_xAOD.h:903
ST::SUSYObjDef_xAOD::m_subtool_init
bool m_subtool_init
Definition: SUSYObjDef_xAOD.h:567
ST::SUSYObjDef_xAOD::m_trigConfTool
asg::AnaToolHandle< TrigConf::ITrigConfigTool > m_trigConfTool
Definition: SUSYObjDef_xAOD.h:969
PathResolver.h
ST::SUSYObjDef_xAOD::m_EigenvectorReductionLight
std::string m_EigenvectorReductionLight
Definition: SUSYObjDef_xAOD.h:684
OverlapRemovalInit.h
Defines helper functions for initializing the OR tools in C++.
ST::SUSYObjDef_xAOD::m_ToptagConfig
std::string m_ToptagConfig
Definition: SUSYObjDef_xAOD.h:558
ST::SUSYObjDef_xAOD::m_tauEffTool
asg::AnaToolHandle< TauAnalysisTools::ITauEfficiencyCorrectionsTool > m_tauEffTool
Definition: SUSYObjDef_xAOD.h:924
TauAnalysisTools::ELEIDRNNTIGHT
@ ELEIDRNNTIGHT
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:44
IMuonLRTOverlapRemovalTool.h
ST::SUSYObjDef_xAOD::m_muonSelectionToolBaseline
asg::AnaToolHandle< CP::IMuonSelectionTool > m_muonSelectionToolBaseline
Definition: SUSYObjDef_xAOD.h:873
IOverlapRemovalTool.h
ST::SUSYObjDef_xAOD::m_trkMETsyst
bool m_trkMETsyst
Definition: SUSYObjDef_xAOD.h:588
ST::SUSYObjDef_xAOD::m_caloMETsyst
bool m_caloMETsyst
Definition: SUSYObjDef_xAOD.h:589
ST::SUSYObjDef_xAOD::m_JMScalib
bool m_JMScalib
Definition: SUSYObjDef_xAOD.h:759
ST::SUSYObjDef_xAOD::m_muz0
double m_muz0
Definition: SUSYObjDef_xAOD.h:711
ST::SUSYObjDef_xAOD::m_JvtWP
std::string m_JvtWP
Definition: SUSYObjDef_xAOD.h:744
IIsolationSelectionTool.h
ST::SUSYObjDef_xAOD::m_useBtagging_trkJet
bool m_useBtagging_trkJet
Definition: SUSYObjDef_xAOD.h:539
ST::SUSYObjDef_xAOD::m_doFwdJVT
bool m_doFwdJVT
Definition: SUSYObjDef_xAOD.h:752
ST::SUSYObjDef_xAOD::m_isoCloseByTool
asg::AnaToolHandle< CP::IIsolationCloseByCorrectionTool > m_isoCloseByTool
Definition: SUSYObjDef_xAOD.h:980
ICPJetUncertaintiesTool.h
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_trig_singleLep
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_trig_singleLep
Definition: SUSYObjDef_xAOD.h:887
ST::SUSYObjDef_xAOD::m_trig2018combination_multiLep
std::string m_trig2018combination_multiLep
Definition: SUSYObjDef_xAOD.h:957
ST::SUSYObjDef_xAOD::m_btagSelTool_OR
asg::AnaToolHandle< IBTaggingSelectionTool > m_btagSelTool_OR
Definition: SUSYObjDef_xAOD.h:929
IMuonCalibrationAndSmearingTool.h
checkTriggerxAOD.found
found
Definition: checkTriggerxAOD.py:328
ST::SUSYObjDef_xAOD::m_muonSelectionHighPtTool
asg::AnaToolHandle< CP::IMuonSelectionTool > m_muonSelectionHighPtTool
Definition: SUSYObjDef_xAOD.h:872
ST::SUSYObjDef_xAOD::m_photonId
std::string m_photonId
Definition: SUSYObjDef_xAOD.h:653
ST::SUSYObjDef_xAOD::m_fJvtConfigRun3
std::string m_fJvtConfigRun3
Definition: SUSYObjDef_xAOD.h:757
ST::SUSYObjDef_xAOD::m_ApplyMVATESQualityCheck
bool m_ApplyMVATESQualityCheck
Definition: SUSYObjDef_xAOD.h:738
ST::SUSYObjDef_xAOD::m_BtagWP_trkJet
std::string m_BtagWP_trkJet
Definition: SUSYObjDef_xAOD.h:685
SmoothedWZTagger.h
ST::SUSYObjDef_xAOD::m_fatjetUncertaintiesPDSmearTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_fatjetUncertaintiesPDSmearTool
Definition: SUSYObjDef_xAOD.h:837
ST::SUSYObjDef_xAOD::m_fatjetFFSmearingTool
asg::AnaToolHandle< ICPJetCorrectionTool > m_fatjetFFSmearingTool
Definition: SUSYObjDef_xAOD.h:838
ORUtils::ORFlags::linkOverlapObjects
bool linkOverlapObjects
Enable overlap object ElementLinks.
Definition: OverlapRemovalInit.h:53
ST::SUSYObjDef_xAOD::m_dataSource
int m_dataSource
Definition: SUSYObjDef_xAOD.h:519
ITauToolBase.h
IInclusiveTrackFilterTool.h
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:16
ST::SUSYObjDef_xAOD::m_EleFatJetDR
double m_EleFatJetDR
Definition: SUSYObjDef_xAOD.h:793
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:321
AthAnalysisHelper.h
ST::SUSYObjDef_xAOD::m_btagSelTool
asg::AnaToolHandle< IBTaggingSelectionTool > m_btagSelTool
Definition: SUSYObjDef_xAOD.h:928
ST::SUSYObjDef_xAOD::m_orDoTauBjet
bool m_orDoTauBjet
Definition: SUSYObjDef_xAOD.h:771
ST::SUSYObjDef_xAOD::m_jetNNJvtSelectionTool
asg::AnaToolHandle< IAsgSelectionTool > m_jetNNJvtSelectionTool
Definition: SUSYObjDef_xAOD.h:844
python.AthDsoLogger.fname
string fname
Definition: AthDsoLogger.py:66
ST::SUSYObjDef_xAOD::m_orMuJetTrkPtRatio
double m_orMuJetTrkPtRatio
Definition: SUSYObjDef_xAOD.h:782
ST::SUSYObjDef_xAOD::m_muonTriggerSFTool
asg::AnaToolHandle< CP::IMuonTriggerScaleFactors > m_muonTriggerSFTool
Definition: SUSYObjDef_xAOD.h:880
ORUtils::ToolBox::masterTool
MasterHandle_t masterTool
Master overlap removal tool handle.
Definition: ToolBox.h:64
IAsgElectronIsEMSelector.h
ST::SUSYObjDef_xAOD::getElSFkeys
std::vector< std::string > getElSFkeys(const std::string &mapFile) const
Definition: SUSYObjDef_xAOD.cxx:1239
ST::SUSYObjDef_xAOD::m_btagEffTool
asg::AnaToolHandle< IBTaggingEfficiencyTool > m_btagEffTool
Definition: SUSYObjDef_xAOD.h:927
IMatchingTool.h
ST::SUSYObjDef_xAOD::m_fatJets
std::string m_fatJets
Definition: SUSYObjDef_xAOD.h:816
ST::SUSYObjDef_xAOD::m_muCalibrationMode
int m_muCalibrationMode
Definition: SUSYObjDef_xAOD.h:718
asg::AnaToolHandle::getHandle
const ToolHandle< T > & getHandle() const noexcept
the tool handle we wrap
ST::SUSYObjDef_xAOD::m_softTermParam
int m_softTermParam
Definition: SUSYObjDef_xAOD.h:592
ST::SUSYObjDef_xAOD::m_orBoostedElectronMaxConeSize
double m_orBoostedElectronMaxConeSize
Definition: SUSYObjDef_xAOD.h:775
ST::SUSYObjDef_xAOD::m_eleBaselineIso_WP
std::string m_eleBaselineIso_WP
Definition: SUSYObjDef_xAOD.h:649
ST::SUSYObjDef_xAOD::m_BtagTagger_trkJet
std::string m_BtagTagger_trkJet
Definition: SUSYObjDef_xAOD.h:686
ST::SUSYObjDef_xAOD::m_tauId
std::string m_tauId
Definition: SUSYObjDef_xAOD.h:655
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
ST::SUSYObjDef_xAOD::m_EG_corrModel
std::string m_EG_corrModel
Definition: SUSYObjDef_xAOD.h:823
LikeEnum::Medium
@ Medium
Definition: LikelihoodEnums.h:14
ST::SUSYObjDef_xAOD::m_JetFatJetDR
double m_JetFatJetDR
Definition: SUSYObjDef_xAOD.h:794
ST::SUSYObjDef_xAOD::m_JetTruthLabelName
std::string m_JetTruthLabelName
Definition: SUSYObjDef_xAOD.h:564
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
ST::SUSYObjDef_xAOD::m_orDoBoostedElectron
bool m_orDoBoostedElectron
Definition: SUSYObjDef_xAOD.h:772
ST::SUSYObjDef_xAOD::m_photonSelIsEMBaseline
asg::AnaToolHandle< IAsgPhotonIsEMSelector > m_photonSelIsEMBaseline
Definition: SUSYObjDef_xAOD.h:905
ORUtils::ORFlags
A struct of global config options used to simplify the config helper interface.
Definition: OverlapRemovalInit.h:29
ST::SUSYObjDef_xAOD::m_metVeryGreedyPhotons
bool m_metVeryGreedyPhotons
Definition: SUSYObjDef_xAOD.h:585
ST::SUSYObjDef_xAOD::m_isRun3
bool m_isRun3
Definition: SUSYObjDef_xAOD.h:807
ST::SUSYObjDef_xAOD::m_trigDecTool
asg::AnaToolHandle< Trig::TrigDecisionTool > m_trigDecTool
Definition: SUSYObjDef_xAOD.h:970
ST::SUSYObjDef_xAOD::m_metsysConfigPrefix
std::string m_metsysConfigPrefix
Definition: SUSYObjDef_xAOD.h:586
ST::SUSYObjDef_xAOD::m_defaultTrackJets
std::string m_defaultTrackJets
Definition: SUSYObjDef_xAOD.h:815
FullCPAlgorithmsTest_CA.inputfile
dictionary inputfile
Definition: FullCPAlgorithmsTest_CA.py:62
ST::SUSYObjDef_xAOD::m_jesCalibSeqFat
std::string m_jesCalibSeqFat
Definition: SUSYObjDef_xAOD.h:868
IJetUpdateJvt.h
ST::SUSYObjDef_xAOD::m_treatPUJets
bool m_treatPUJets
Definition: SUSYObjDef_xAOD.h:593
ST::SUSYObjDef_xAOD::m_jesConfig
std::string m_jesConfig
Definition: SUSYObjDef_xAOD.h:860
ST::SUSYObjDef_xAOD::m_tauConfigPathBaseline
std::string m_tauConfigPathBaseline
Definition: SUSYObjDef_xAOD.h:733
ST::SUSYObjDef_xAOD::m_jetFatCalibTool
asg::AnaToolHandle< IJetCalibrationTool > m_jetFatCalibTool
Definition: SUSYObjDef_xAOD.h:833
ST::SUSYObjDef_xAOD::m_electronTriggerSFStringSingle
std::string m_electronTriggerSFStringSingle
Definition: SUSYObjDef_xAOD.h:641
ST::SUSYObjDef_xAOD::m_jetNNJvtEfficiencyTool
asg::AnaToolHandle< CP::IJvtEfficiencyTool > m_jetNNJvtEfficiencyTool
Definition: SUSYObjDef_xAOD.h:845
IWeightTool.h
ORUtils::ORFlags::masterName
std::string masterName
Master tool name.
Definition: OverlapRemovalInit.h:36
ST::SUSYObjDef_xAOD::m_trig2017combination_diLep
std::string m_trig2017combination_diLep
Definition: SUSYObjDef_xAOD.h:948
ST::SUSYObjDef_xAOD::m_trigDRScoringTool
asg::AnaToolHandle< Trig::IMatchScoringTool > m_trigDRScoringTool
Definition: SUSYObjDef_xAOD.h:973
ST::SUSYObjDef_xAOD::m_trig2015combination_diLep
std::string m_trig2015combination_diLep
Definition: SUSYObjDef_xAOD.h:946
ST::SUSYObjDef_xAOD::m_jetTruthLabelingTool
asg::AnaToolHandle< JetTruthLabelingTool > m_jetTruthLabelingTool
Definition: SUSYObjDef_xAOD.h:852
ST::SUSYObjDef_xAOD::m_eleLRT_strat
int m_eleLRT_strat
Definition: SUSYObjDef_xAOD.h:662
ORUtils::ToolBox::phoJetORT
OverlapHandle_t phoJetORT
Definition: ToolBox.h:78
ST::SUSYObjDef_xAOD::m_ZDecorName
std::string m_ZDecorName
Definition: SUSYObjDef_xAOD.h:554
ST::SUSYObjDef_xAOD::m_metSignif
asg::AnaToolHandle< IMETSignificance > m_metSignif
Definition: SUSYObjDef_xAOD.h:935
ST::SUSYObjDef_xAOD::m_eleConfig
std::string m_eleConfig
Definition: SUSYObjDef_xAOD.h:647
ORUtils::ORFlags::doMuons
bool doMuons
Definition: OverlapRemovalInit.h:60
TauAnalysisTools::JETIDRNNVERYLOOSE
@ JETIDRNNVERYLOOSE
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:19
ST::SUSYObjDef_xAOD::m_muHighPtExtraSmear
bool m_muHighPtExtraSmear
Definition: SUSYObjDef_xAOD.h:673
ST::SUSYObjDef_xAOD::m_photonTriggerName
std::string m_photonTriggerName
Definition: SUSYObjDef_xAOD.h:668
ST::SUSYObjDef_xAOD::m_EigenvectorReductionB
std::string m_EigenvectorReductionB
Definition: SUSYObjDef_xAOD.h:682
ST::SUSYObjDef_xAOD::m_orBoostedElectronC2
double m_orBoostedElectronC2
Definition: SUSYObjDef_xAOD.h:774
ST::SUSYObjDef_xAOD::m_orInputLabel
std::string m_orInputLabel
Definition: SUSYObjDef_xAOD.h:787
ST::SUSYObjDef_xAOD::m_ZtagConfig
std::string m_ZtagConfig
Definition: SUSYObjDef_xAOD.h:557
ORUtils::ORFlags::doJets
bool doJets
Definition: OverlapRemovalInit.h:61
ST::SUSYObjDef_xAOD::m_mud0sig
double m_mud0sig
Definition: SUSYObjDef_xAOD.h:710
ST::SUSYObjDef_xAOD::m_muIsoHighPt_WP
std::string m_muIsoHighPt_WP
Definition: SUSYObjDef_xAOD.h:671
ST::SUSYObjDef_xAOD::m_muonHighPtIsolationSFTool
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonHighPtIsolationSFTool
Definition: SUSYObjDef_xAOD.h:879
ST::SUSYObjDef_xAOD::m_photonIdBaseline
std::string m_photonIdBaseline
Definition: SUSYObjDef_xAOD.h:654
CONFIG_EG_EFF_TOOL
#define CONFIG_EG_EFF_TOOL(TOOLHANDLE, TOOLNAME, CORRFILE)
Definition: SUSYToolsInit.cxx:88
ST::SUSYObjDef_xAOD::m_metGreedyPhotons
bool m_metGreedyPhotons
Definition: SUSYObjDef_xAOD.h:584
ST::SUSYObjDef_xAOD::m_muonTrigSFTools
ToolHandleArray< CP::IMuonTriggerScaleFactors > m_muonTrigSFTools
Definition: SUSYObjDef_xAOD.h:881
ST::SUSYObjDef_xAOD::m_jetCleaningTool
asg::AnaToolHandle< IJetSelector > m_jetCleaningTool
Definition: SUSYObjDef_xAOD.h:839
asg::AnaToolHandle::empty
bool empty() const
whether this ToolHandle is completely empty, i.e.
ST::SUSYObjDef_xAOD::m_orDoMuonJetGhostAssociation
bool m_orDoMuonJetGhostAssociation
Definition: SUSYObjDef_xAOD.h:784
ST::SUSYObjDef_xAOD::m_isoCorrTool
asg::AnaToolHandle< CP::IIsolationCorrectionTool > m_isoCorrTool
Definition: SUSYObjDef_xAOD.h:975
ST::SUSYObjDef_xAOD::m_defaultTruthJets
std::string m_defaultTruthJets
Definition: SUSYObjDef_xAOD.h:817
ST::SUSYObjDef_xAOD::m_tauDoTTM
bool m_tauDoTTM
Definition: SUSYObjDef_xAOD.h:734
ST::SUSYObjDef_xAOD::m_elecTrigSFTools
ToolHandleArray< IAsgElectronEfficiencyCorrectionTool > m_elecTrigSFTools
Definition: SUSYObjDef_xAOD.h:895
ST::SUSYObjDef_xAOD::m_tauTrigEffTool
std::vector< asg::AnaToolHandle< TauAnalysisTools::ITauEfficiencyCorrectionsTool > > m_tauTrigEffTool
Definition: SUSYObjDef_xAOD.h:925
ST::SUSYObjDef_xAOD::m_mcCampaign
std::string m_mcCampaign
Definition: SUSYObjDef_xAOD.h:602
ST::SUSYObjDef_xAOD::m_TopDecorName
std::string m_TopDecorName
Definition: SUSYObjDef_xAOD.h:555
ST::SUSYObjDef_xAOD::m_orDoMuonJet
bool m_orDoMuonJet
Definition: SUSYObjDef_xAOD.h:767
ST::SUSYObjDef_xAOD::m_upstreamTriggerMatching
bool m_upstreamTriggerMatching
Definition: SUSYObjDef_xAOD.h:528
ST::SUSYObjDef_xAOD::m_fatJetUncertaintiesMCType
std::string m_fatJetUncertaintiesMCType
Definition: SUSYObjDef_xAOD.h:535
ITauSmearingTool.h
IEfficiencyScaleFactorTool.h
ST::SUSYObjDef_xAOD::m_LRTuncTool
asg::AnaToolHandle< InDet::IInclusiveTrackFilterTool > m_LRTuncTool
Definition: SUSYObjDef_xAOD.h:984
ST::SUSYObjDef_xAOD::m_WtagConfig
std::string m_WtagConfig
Definition: SUSYObjDef_xAOD.h:556
ST::SUSYObjDef_xAOD::m_useTRUTH3
bool m_useTRUTH3
Definition: SUSYObjDef_xAOD.h:804
ST::SUSYObjDef_xAOD::m_EG_corrFNList
std::string m_EG_corrFNList
Definition: SUSYObjDef_xAOD.h:824
ST::SUSYObjDef_xAOD::m_photonIsolationSFTool
asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > m_photonIsolationSFTool
Definition: SUSYObjDef_xAOD.h:908
ST::SUSYObjDef_xAOD::m_muonSelectionTool
asg::AnaToolHandle< CP::IMuonSelectionTool > m_muonSelectionTool
Definition: SUSYObjDef_xAOD.h:871
ST::SUSYObjDef_xAOD::m_useSigLepForIsoCloseByOR
bool m_useSigLepForIsoCloseByOR
Definition: SUSYObjDef_xAOD.h:801
ST::SUSYObjDef_xAOD::m_egammaAmbiguityTool
asg::AnaToolHandle< IEGammaAmbiguityTool > m_egammaAmbiguityTool
Definition: SUSYObjDef_xAOD.h:916
ST::SUSYObjDef_xAOD::m_TopconfigReader
TEnv m_TopconfigReader
Definition: SUSYObjDef_xAOD.h:552
SystematicsUtil.h
ANA_MSG_DEBUG
#define ANA_MSG_DEBUG(xmsg)
Macro printing debug messages.
Definition: Control/AthToolSupport/AsgMessaging/AsgMessaging/MessageCheck.h:288
ST::SUSYObjDef_xAOD::m_trig2015combination_diPhoton
std::string m_trig2015combination_diPhoton
Definition: SUSYObjDef_xAOD.h:962
ST::SUSYObjDef_xAOD::m_isoTool
asg::AnaToolHandle< CP::IIsolationSelectionTool > m_isoTool
Definition: SUSYObjDef_xAOD.h:976
ST::SUSYObjDef_xAOD::m_JvtConfigRun3
std::string m_JvtConfigRun3
Definition: SUSYObjDef_xAOD.h:747
asg::AnaToolHandle::isUserConfigured
bool isUserConfigured() const
whether this tool handle has been configured by the user
ST::SUSYObjDef_xAOD::m_pmgSHnjetWeighter
asg::AnaToolHandle< IWeightTool > m_pmgSHnjetWeighter
Definition: SUSYObjDef_xAOD.h:989
Generated on Thu Nov 20 2025 21:19:09 for ATLAS Offline Software by   doxygen 1.8.18