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 
1257  ATH_MSG_INFO("eSF_keys: " << m_electronTriggerSFStringSingle<< "_"<<triggerEleID<<"_"<<triggerEleIso);
1258 
1259  if (std::find(eSF_keys.begin(), eSF_keys.end(), m_electronTriggerSFStringSingle+"_"+triggerEleID+"_"+triggerEleIso) != eSF_keys.end()){
1260  triggerEleIso = m_eleIso_WP;
1261  } else if (std::find(eSF_keys.begin(), eSF_keys.end(), m_electronTriggerSFStringSingle+"_"+triggerEleID+"_"+m_el_iso_fallback[triggerEleIso]) != eSF_keys.end()){
1262  //--- Check to see if the only issue is an unknown isolation working point
1263  triggerEleIso = m_el_iso_fallback[triggerEleIso];
1264  ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool_trig_singleLep_*) Your selected electron Iso WP ("
1265  << m_eleIso_WP
1266  << ") does not have trigger SFs defined. Falling back to "
1267  << triggerEleIso
1268  << " for SF calculations");
1269  }
1270  else{
1271  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 << ") ***");
1272  return StatusCode::FAILURE;
1273  }
1274 
1275  toolName = "AsgElectronEfficiencyCorrectionTool_trig_singleLep_" + triggerEleID;
1276  if ( !m_elecEfficiencySFTool_trig_singleLep.isUserConfigured() ) {
1277  m_elecEfficiencySFTool_trig_singleLep.setTypeAndName("AsgElectronEfficiencyCorrectionTool/"+toolName);
1278  ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
1279  ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("TriggerKey", m_electronTriggerSFStringSingle) );
1280  ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("IdKey", triggerEleID) );
1281  ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("IsoKey", triggerEleIso) );
1282  ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("CorrelationModel", m_EG_corrModel) );
1283  if (!isData()) {
1284  ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("ForceDataType", (int) (data_type==PATCore::ParticleDataType::Fast)? PATCore::ParticleDataType::Full : data_type) );
1285  }
1286  ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("OutputLevel", this->msg().level()) );
1287  ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.initialize() );
1288  } else ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.retrieve() );
1289 
1290 
1291  toolName = "AsgElectronEfficiencyCorrectionTool_trigEff_singleLep_" + triggerEleID;
1292  if ( !m_elecEfficiencySFTool_trigEff_singleLep.isUserConfigured() ) {
1293  m_elecEfficiencySFTool_trigEff_singleLep.setTypeAndName("AsgElectronEfficiencyCorrectionTool/"+toolName);
1294  ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
1295  ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("TriggerKey", "Eff_"+m_electronTriggerSFStringSingle) );
1296  ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("IdKey", triggerEleID) );
1297  ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("IsoKey", triggerEleIso) );
1298  ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("CorrelationModel", m_EG_corrModel) );
1299  if (!isData()) {
1300  ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("ForceDataType", (int) (data_type==PATCore::ParticleDataType::Fast)? PATCore::ParticleDataType::Full : data_type) );
1301  }
1302  ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("OutputLevel", this->msg().level()) );
1303  ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.initialize() );
1304  } else ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.retrieve() );
1305 
1306  if (!m_isRun3){
1307  //mixed-leptons
1308  std::map<std::string,std::string> electronTriggerSFMapMixedLepton {
1309  // legs, Trigger keys,
1310  {"e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose,e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0", m_electronTriggerSFStringSingle},
1311  {"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"},
1312  {"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"},
1313  {"e17_lhloose,e17_lhloose_nod0","MULTI_L_2015_e17_lhloose_2016_2018_e17_lhloose_nod0"},
1314  {"e12_lhloose,e12_lhloose_nod0","MULTI_L_2015_e12_lhloose_2016_2018_e12_lhloose_nod0"},
1315  {"e7_lhmedium,e7_lhmedium_nod0","MULTI_L_2015_e7_lhmedium_2016_2018_e7_lhmedium_nod0"},
1316  {"e9_lhloose,e9_lhloose_nod0,e12_lhvloose_nod0_L1EM10VH","TRI_E_2015_e9_lhloose_2016_e9_lhloose_nod0_2017_2018_e12_lhvloose_nod0_L1EM10VH"}
1317 
1318  };
1319 
1320  // 2e17 trigger is used in 2017 or 2018?
1321  std::string triglist_2017to2018 = m_trig2017combination_diLep + "_" + m_trig2018combination_diLep + "_" + m_trig2017combination_multiLep + "_" + m_trig2018combination_multiLep;
1322  if (triglist_2017to2018.find("2e17_lhvloose_nod0_L12EM15VHI") != std::string::npos) {
1323  electronTriggerSFMapMixedLepton["e17_lhvloose_nod0_L1EM15VHI"] = "DI_E_2015_e12_lhloose_L1EM10VH_2016_e17_lhvloose_nod0_2017_2018_e17_lhvloose_nod0_L1EM15VHI";
1324  }
1325 
1326  std::string triggerMixedEleIso("");
1327 
1328  for(auto const& item : electronTriggerSFMapMixedLepton){
1329 
1330  if (std::find(eSF_keys.begin(), eSF_keys.end(), item.second+"_"+eleId+"_"+m_eleIso_WP) != eSF_keys.end()){
1331  triggerMixedEleIso = m_eleIso_WP;
1332  } else if (std::find(eSF_keys.begin(), eSF_keys.end(), item.second+"_"+eleId+"_"+m_el_iso_fallback[m_eleIso_WP]) != eSF_keys.end()){
1333  //--- Check to see if the only issue is an unknown isolation working point
1334  triggerMixedEleIso = m_el_iso_fallback[m_eleIso_WP];
1335  ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool_trig_mixLep_*) Your selected electron Iso WP ("
1336  << m_eleIso_WP
1337  << ") does not have trigger SFs defined. Falling back to "
1338  << triggerMixedEleIso
1339  << " for SF calculations");
1340  } else {
1341  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! ***");
1342  return StatusCode::FAILURE;
1343  }
1344 
1345  ATH_MSG_VERBOSE ("Selected WP: " << item.second << "_" << eleId << "_" << triggerMixedEleIso);
1346 
1347  toolName = "AsgElectronEfficiencyCorrectionTool_trig_mixLep_" + (item.first).substr(0,8) + m_eleId;
1348  auto t_sf = m_elecEfficiencySFTool_trig_mixLep.emplace(m_elecEfficiencySFTool_trig_mixLep.end(), "AsgElectronEfficiencyCorrectionTool/"+toolName);
1349  ATH_CHECK( t_sf->setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
1350  ATH_CHECK( t_sf->setProperty("TriggerKey", item.second) );
1351  ATH_CHECK( t_sf->setProperty("IdKey", eleId) );
1352  ATH_CHECK( t_sf->setProperty("IsoKey", triggerMixedEleIso) );
1353  ATH_CHECK( t_sf->setProperty("CorrelationModel", m_EG_corrModel) );
1354  if (!isData()) {
1355  ATH_CHECK( t_sf->setProperty("ForceDataType", (int) (data_type==PATCore::ParticleDataType::Fast)? PATCore::ParticleDataType::Full : data_type) );
1356  }
1357  ATH_CHECK( t_sf->setProperty("OutputLevel", this->msg().level()) );
1358  ATH_CHECK( t_sf->initialize() );
1359  m_elecTrigSFTools.push_back(t_sf->getHandle());
1360  #ifndef XAOD_STANDALONE
1361  m_legsPerTool[toolName] = item.first;
1362  #else
1363  m_legsPerTool["ToolSvc."+toolName] = item.first;
1364  #endif
1365 
1366  toolName = "AsgElectronEfficiencyCorrectionTool_trigEff_mixLep_" + (item.first).substr(0,8) + m_eleId;
1367  auto t_eff = m_elecEfficiencySFTool_trigEff_mixLep.emplace(m_elecEfficiencySFTool_trigEff_mixLep.end(), "AsgElectronEfficiencyCorrectionTool/"+toolName);
1368  ATH_CHECK( t_eff->setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
1369  ATH_CHECK( t_eff->setProperty("TriggerKey", "Eff_"+item.second) );
1370  ATH_CHECK( t_eff->setProperty("IdKey", eleId) );
1371  ATH_CHECK( t_eff->setProperty("IsoKey", triggerMixedEleIso) );
1372  ATH_CHECK( t_eff->setProperty("CorrelationModel", m_EG_corrModel) );
1373  if (!isData()) {
1374  ATH_CHECK( t_eff->setProperty("ForceDataType", (int) (data_type==PATCore::ParticleDataType::Fast)? PATCore::ParticleDataType::Full : data_type) );
1375  }
1376  ATH_CHECK( t_eff->setProperty("OutputLevel", this->msg().level()) );
1377  ATH_CHECK( t_eff->initialize() );
1378  m_elecTrigEffTools.push_back(t_eff->getHandle());
1379  #ifndef XAOD_STANDALONE
1380  m_legsPerTool[toolName] = item.first;
1381  #else
1382  m_legsPerTool["ToolSvc."+toolName] = item.first;
1383  #endif
1384 
1385  }
1386  }
1387  else ATH_MSG_WARNING("*** THE ELECTRON TRIGGER SF MIXED AND SF DILEP ARE CURRENTY NOT SUPPORTED IN RUN3 ***");
1388 
1389  ATH_MSG_WARNING("*** THE ELECTRON CHARGE FLIP SF ARE CURRENTY NOT SUPPORTED ***");
1390  // all the iinitialisation of the related tools have been cleaned up
1391 
1392  }
1393 
1394  if (m_slices["pho"]) {
1395  // /////////////////////////////////////////////////////////////////////////////////////////
1396  // Initialise photon efficiency tool
1397 
1398  if (!m_photonEfficiencySFTool.isUserConfigured() && !isData()) {
1399  m_photonEfficiencySFTool.setTypeAndName("AsgPhotonEfficiencyCorrectionTool/AsgPhotonEfficiencyCorrectionTool_" + m_photonId);
1400 
1401  if (m_photonId != "Tight" ) {
1402  ATH_MSG_WARNING( "No Photon efficiency available for " << m_photonId << ", using Tight instead..." );
1403  }
1404 
1405  ATH_CHECK( m_photonEfficiencySFTool.setProperty("MapFilePath", "PhotonEfficiencyCorrection/2015_2025/rel22.2/2024_FinalRun2_Recommendation_v1/map1.txt") );
1406  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
1407  ATH_CHECK( m_photonEfficiencySFTool.setProperty("OutputLevel", this->msg().level()) );
1408  ATH_CHECK( m_photonEfficiencySFTool.retrieve() );
1409  } else if (m_photonEfficiencySFTool.isUserConfigured()) ATH_CHECK( m_photonEfficiencySFTool.retrieve() );
1410 
1411  if (!m_photonIsolationSFTool.isUserConfigured() && !isData()) {
1412  m_photonIsolationSFTool.setTypeAndName("AsgPhotonEfficiencyCorrectionTool/AsgPhotonEfficiencyCorrectionTool_isol" + m_photonIso_WP);
1413 
1414  if (m_photonIso_WP != "FixedCutTight" && m_photonIso_WP != "FixedCutLoose" && m_photonIso_WP != "TightCaloOnly") {
1415  ATH_MSG_WARNING( "No Photon efficiency available for " << m_photonIso_WP);
1416  }
1417 
1418  ATH_CHECK( m_photonIsolationSFTool.setProperty("MapFilePath", "PhotonEfficiencyCorrection/2015_2025/rel22.2/2022_Summer_Prerecom_v1/map1.txt") );
1419  ATH_CHECK( m_photonIsolationSFTool.setProperty("IsoKey", m_photonIso_WP != "TightCaloOnly" ? m_photonIso_WP.substr(8) : m_photonIso_WP )); // Set isolation WP: Loose,Tight,TightCaloOnly
1420  ATH_CHECK( m_photonIsolationSFTool.setProperty("ForceDataType", 1) ); // Set data type: 1 for FULLSIM, 3 for AF2
1421  ATH_CHECK( m_photonIsolationSFTool.setProperty("OutputLevel", this->msg().level()) );
1422  ATH_CHECK( m_photonIsolationSFTool.retrieve() );
1423  } else if (m_photonEfficiencySFTool.isUserConfigured()) ATH_CHECK( m_photonIsolationSFTool.retrieve() );
1424 
1425  // trigger scale factors
1426  if (!m_photonTriggerSFTool.isUserConfigured() && !isData()) {
1427  m_photonTriggerSFTool.setTypeAndName("AsgPhotonEfficiencyCorrectionTool/AsgPhotonEfficiencyCorrectionTool_trig" + m_photonTriggerName);
1428 
1429  // Fallback to TightCaloOnly if Tight is selected
1430  std::string photonIso_forTrigSF = m_photonIso_WP;
1431  if (m_photonIso_WP == "FixedCutTight") {
1432  ATH_MSG_WARNING( "No Photon trigger SF available for " << m_photonIso_WP << ", using TightCaloOnly instead... Use at your own risk" );
1433  photonIso_forTrigSF = "TightCaloOnly";
1434  } else { // isolation WP supported: Loose or TightCaloOnly, removing "FixedCut" suffix..
1435  photonIso_forTrigSF = TString(m_photonIso_WP).ReplaceAll("FixedCut","").Data();
1436  }
1437 
1438  // "symmetric" diphoton triggers (year dependent)
1439  ATH_CHECK( m_photonTriggerSFTool.setProperty("MapFilePath", "PhotonEfficiencyCorrection/2015_2018/rel21.2/Summer2020_Rec_v1/map3.txt") );
1440  ATH_CHECK( m_photonTriggerSFTool.setProperty("IsoKey", photonIso_forTrigSF )); // Set isolation WP: Loose,TightCaloOnly
1441  ATH_CHECK( m_photonTriggerSFTool.setProperty("TriggerKey", m_photonTriggerName ));
1442  ATH_CHECK( m_photonTriggerSFTool.setProperty("ForceDataType", 1) ); // Set data type: 1 for FULLSIM, 3 for AF2
1443  ATH_CHECK( m_photonTriggerSFTool.setProperty("OutputLevel", this->msg().level()) );
1444  ATH_CHECK( m_photonTriggerSFTool.retrieve() );
1445 
1446  // "asymmetric" diphoton triggers
1447  std::map<std::string,std::string> diphotonTriggerSFMapAsymmetric {
1448  // legs, Trigger keys,
1449  {"g25_loose,g25_medium_L1EM20VH", "DI_PH_2015_g25_loose_2016_g25_loose_2017_g25_medium_L1EM20VH_2018_g25_medium_L1EM20VH"},
1450  {"g35_loose,g35_medium_L1EM20VH", "DI_PH_2015_g35_loose_2016_g35_loose_2017_g35_medium_L1EM20VH_2018_g35_medium_L1EM20VH"},
1451  };
1452 
1453  for(auto const& item : diphotonTriggerSFMapAsymmetric){
1454 
1455  toolName = "AsgPhotonEfficiencyCorrectionTool_trigSF_asymm_diphoton_" + (item.first).substr(0,9) + photonIso_forTrigSF;
1456  auto ph_trigSF = m_photonEfficiencySFTool_trigSF_AsymDiphoton.emplace(m_photonEfficiencySFTool_trigSF_AsymDiphoton.end(), "AsgPhotonEfficiencyCorrectionTool/"+toolName);
1457  ATH_CHECK( ph_trigSF->setProperty("MapFilePath", "PhotonEfficiencyCorrection/2015_2018/rel21.2/Summer2020_Rec_v1/map3.txt") );
1458  ATH_CHECK( ph_trigSF->setProperty("IsoKey", photonIso_forTrigSF) );
1459  ATH_CHECK( ph_trigSF->setProperty("TriggerKey", item.second) );
1460  ATH_CHECK( ph_trigSF->setProperty("ForceDataType", 1) ); // Set DataType: 1 for FullSim and 3 for AFII
1461  ATH_CHECK( ph_trigSF->setProperty("OutputLevel", this->msg().level()) );
1462  ATH_CHECK( ph_trigSF->initialize() );
1463  m_photonTrigSFTools.push_back(ph_trigSF->getHandle());
1464  #ifndef XAOD_STANDALONE
1465  m_legsPerTool_ph[toolName] = item.first;
1466  #else
1467  m_legsPerTool_ph["ToolSvc."+toolName] = item.first;
1468  #endif
1469 
1470  toolName = "AsgPhotonEfficiencyCorrectionTool_trigEff_asymm_diphoton_" + (item.first).substr(0,9) + photonIso_forTrigSF;
1471  auto ph_trigEff = m_photonEfficiencySFTool_trigEff_AsymDiphoton.emplace(m_photonEfficiencySFTool_trigEff_AsymDiphoton.end(), "AsgPhotonEfficiencyCorrectionTool/"+toolName);
1472  ATH_CHECK( ph_trigEff->setProperty("MapFilePath", "PhotonEfficiencyCorrection/2015_2018/rel21.2/Summer2020_Rec_v1/map3.txt") );
1473  ATH_CHECK( ph_trigEff->setProperty("IsoKey", photonIso_forTrigSF) );
1474  ATH_CHECK( ph_trigEff->setProperty("TriggerKey", "Eff_"+item.second) );
1475  ATH_CHECK( ph_trigEff->setProperty("ForceDataType", 1) ); // Set DataType: 1 for FullSim and 3 for AFII
1476  ATH_CHECK( ph_trigEff->setProperty("OutputLevel", this->msg().level()) );
1477  ATH_CHECK( ph_trigEff->initialize() );
1478  m_photonTrigEffTools.push_back(ph_trigEff->getHandle());
1479  #ifndef XAOD_STANDALONE
1480  m_legsPerTool_ph[toolName] = item.first;
1481  #else
1482  m_legsPerTool_ph["ToolSvc."+toolName] = item.first;
1483  #endif
1484 
1485  }
1486  }
1487  }
1488 
1489  }
1490  if (m_slices["ele"] || m_slices["pho"]) {
1492  // Initialize the EgammaAmbiguityTool
1493 
1494  if (!m_egammaAmbiguityTool.isUserConfigured()) {
1495  m_egammaAmbiguityTool.setTypeAndName("EGammaAmbiguityTool/EGammaAmbiguityTool");
1496  ATH_CHECK( m_egammaAmbiguityTool.setProperty("OutputLevel", this->msg().level()) );
1497  ATH_CHECK( m_egammaAmbiguityTool.retrieve() );
1498  } else ATH_CHECK( m_egammaAmbiguityTool.retrieve() );
1499  }
1500 
1501 
1502  if (m_slices["ele"]) {
1503  //disable ///////////////////////////////////////////////////////////////////////////////////////////
1504  //disable // Initialize the AsgElectronChargeIDSelector
1505 
1506  //disable if (!m_elecChargeIDSelectorTool.isUserConfigured()) {
1507 
1508  //disable // For the selector, can use the nice function
1509  //disable std::string eleId = EG_WP(m_eleId);
1510  //disable m_elecChargeIDSelectorTool.setTypeAndName("AsgElectronChargeIDSelectorTool/ElectronChargeIDSelectorTool_"+eleId);
1511  //disable //default cut value for https://twiki.cern.ch/twiki/bin/view/AtlasProtected/ElectronChargeFlipTaggerTool
1512  //disable float BDTcut = -0.337671; // Loose 97%
1513  //disable if (m_eleChID_WP != "Loose" && !m_eleChID_WP.empty()) {
1514  //disable ATH_MSG_ERROR("Only Loose WP is supported in R21. Invalid ChargeIDSelector WP selected : " << m_eleChID_WP);
1515  //disable return StatusCode::FAILURE;
1516  //disable }
1517 
1518  //disable ATH_CHECK( m_elecChargeIDSelectorTool.setProperty("TrainingFile", "ElectronPhotonSelectorTools/ChargeID/ECIDS_20180731rel21Summer2018.root"));
1519  //disable ATH_CHECK( m_elecChargeIDSelectorTool.setProperty("CutOnBDT", BDTcut));
1520  //disable ATH_CHECK( m_elecChargeIDSelectorTool.setProperty("OutputLevel", this->msg().level()) );
1521  //disable ATH_CHECK( m_elecChargeIDSelectorTool.retrieve() );
1522  //disable } else ATH_CHECK( m_elecChargeIDSelectorTool.retrieve() );
1523 
1524 
1526  // Initialise egamma calibration tool
1527 
1528  if (!m_egammaCalibTool.isUserConfigured()) {
1529  m_egammaCalibTool.setTypeAndName("CP::EgammaCalibrationAndSmearingTool/EgammaCalibrationAndSmearingTool");
1530  ATH_MSG_DEBUG( "Initialising EgcalibTool " );
1531  ATH_CHECK( m_egammaCalibTool.setProperty("ESModel", m_isRun3 ? "es2024_Run3_v0" : "es2023_R22_Run2_v1") );
1532  ATH_CHECK( m_egammaCalibTool.setProperty("decorrelationModel", "1NP_v1") );
1533  // allows to bypass (intended) abort from of egamma calibration tool when configured for fastSim
1534  if (m_eleForceFullSimCalib) {
1535  ATH_MSG_WARNING( "Forcing EgcalibTool to use calibrations for full simulation" );
1536  ATH_CHECK( m_egammaCalibTool.setProperty("useFastSim", false) );
1537  }
1538  else {
1539  ATH_MSG_INFO("is Fast Sim:" << isAtlfast());
1540  ATH_CHECK( m_egammaCalibTool.setProperty("useFastSim", isAtlfast() ? 1 : 0) );
1541  }
1542  ATH_CHECK( m_egammaCalibTool.setProperty("OutputLevel", this->msg().level()) );
1543  ATH_CHECK( m_egammaCalibTool.retrieve() );
1544  } else ATH_CHECK( m_egammaCalibTool.retrieve() );
1545  }
1546 
1547 
1548  if (m_slices["tau"]) {
1550 
1552  // Initialise path to tau config file and config reader
1553 
1554  std::string inputfile = "";
1555  if (!m_tauConfigPath.empty() && (m_tauConfigPath!="default")) inputfile = m_tauConfigPath;
1556  else if (m_tauId == "rnn001") inputfile = "SUSYTools/tau_selection_rnn001.conf";
1557  else if (m_tauId == "VeryLoose") inputfile = "SUSYTools/tau_selection_veryloose.conf";
1558  else if (m_tauId == "Loose") inputfile = "SUSYTools/tau_selection_loose.conf";
1559  else if (m_tauId == "Medium") inputfile = "SUSYTools/tau_selection_medium.conf";
1560  else if (m_tauId == "Tight") inputfile = "SUSYTools/tau_selection_tight.conf";
1561  else {
1562  ATH_MSG_ERROR("Invalid tau ID selected: " << m_tauId);
1563  return StatusCode::FAILURE;
1564  }
1565 
1566  // Read in the config file so we can retrieve the fields later when configuring the efficiency tools
1567  if ( m_tauConfigReader.ReadFile( PathResolverFindCalibFile(inputfile).c_str(), EEnvLevel(0) ) ) {
1568  ATH_MSG_ERROR( "Error while reading tau config file : " << inputfile );
1569  return StatusCode::FAILURE;
1570  }
1571  else ATH_MSG_DEBUG( "Successfully read tau config file : " << inputfile );
1572 
1573 
1575  // Initialise tau selection tools
1576 
1577  if (!m_tauSelTool.isUserConfigured()) {
1578  toolName = "TauSelectionTool_" + m_tauId;
1579  m_tauSelTool.setTypeAndName("TauAnalysisTools::TauSelectionTool/"+toolName);
1580  ATH_CHECK( m_tauSelTool.setProperty("ConfigPath", inputfile) );
1581  ATH_CHECK( m_tauSelTool.setProperty("OutputLevel", this->msg().level()) );
1582  ATH_CHECK( m_tauSelTool.retrieve() );
1583  } else ATH_CHECK( m_tauSelTool.retrieve() );
1584 
1585 
1586  if (!m_tauSelToolBaseline.isUserConfigured()) {
1587  std::string inputfile = "";
1588  if (!m_tauConfigPathBaseline.empty() && (m_tauConfigPathBaseline!="default")) inputfile = m_tauConfigPathBaseline;
1589  else if (m_tauIdBaseline == "rnn001") inputfile = "SUSYTools/tau_selection_rnn001.conf";
1590  else if (m_tauIdBaseline == "VeryLoose") inputfile = "SUSYTools/tau_selection_veryloose.conf";
1591  else if (m_tauIdBaseline == "Loose") inputfile = "SUSYTools/tau_selection_loose.conf";
1592  else if (m_tauIdBaseline == "Medium") inputfile = "SUSYTools/tau_selection_medium.conf";
1593  else if (m_tauIdBaseline == "Tight") inputfile = "SUSYTools/tau_selection_tight.conf";
1594  else {
1595  ATH_MSG_ERROR("Invalid baseline tau ID selected: " << m_tauIdBaseline);
1596  return StatusCode::FAILURE;
1597  }
1598  toolName = "TauSelectionToolBaseline_" + m_tauIdBaseline;
1599  m_tauSelToolBaseline.setTypeAndName("TauAnalysisTools::TauSelectionTool/"+toolName);
1600  ATH_CHECK( m_tauSelToolBaseline.setProperty("ConfigPath", inputfile) );
1601 
1602  ATH_CHECK( m_tauSelToolBaseline.setProperty("OutputLevel", this->msg().level()) );
1603  ATH_CHECK( m_tauSelToolBaseline.retrieve() );
1604  } else ATH_CHECK( m_tauSelToolBaseline.retrieve() );
1605 
1606 
1608  // Initialise tau efficiency tool
1609 
1610  if (!m_tauEffTool.isUserConfigured() && !isData()) {
1611  toolName = "TauEffTool_" + m_tauId;
1612  m_tauEffTool.setTypeAndName("TauAnalysisTools::TauEfficiencyCorrectionsTool/"+toolName);
1613 
1614  std::vector<int> correction_types;
1615  // Read out the tau ID from the config file and map into the enum from tau CP
1616  std::string jetIDWP = m_tauConfigReader.GetValue("JetIDWP" ,"");
1617  ANA_MSG_DEBUG( "Found JetIDWP in tau config file : " << jetIDWP );
1618  int jet_id_lvl;
1619  if (jetIDWP == "JETIDNONE") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDNONE;
1620  else if (jetIDWP == "JETIDRNNVERYLOOSE") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDRNNVERYLOOSE;
1621  else if (jetIDWP == "JETIDRNNLOOSE") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDRNNLOOSE;
1622  else if (jetIDWP == "JETIDRNNMEDIUM") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDRNNMEDIUM;
1623  else if (jetIDWP == "JETIDRNNTIGHT") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDRNNTIGHT;
1624  else {
1625  ATH_MSG_ERROR("Invalid Tau ID in tau config file " << jetIDWP);
1626  return StatusCode::FAILURE;
1627  }
1628  // Add retrieval of reco and ID SFs
1629  correction_types.insert(correction_types.end(), {TauAnalysisTools::EfficiencyCorrectionType::SFRecoHadTau,
1630  TauAnalysisTools::EfficiencyCorrectionType::SFJetIDHadTau});
1631 
1632  // Read out the (optional) Ele OR from the config file and map into the enum from tau CP
1633  std::string eleIDWP = m_tauConfigReader.GetValue("EleIDWP" ,"");
1634  ANA_MSG_DEBUG( "Found EleIDWP in tau config file : " << eleIDWP );
1635  int ele_id_lvl = -1;
1636  if (eleIDWP == "ELEIDRNNLOOSE") ele_id_lvl = (int)TauAnalysisTools::EleID::ELEIDRNNLOOSE;
1637  else if (eleIDWP == "ELEIDRNNMEDIUM") ele_id_lvl = (int)TauAnalysisTools::EleID::ELEIDRNNMEDIUM;
1638  else if (eleIDWP == "ELEIDRNNTIGHT") ele_id_lvl = (int)TauAnalysisTools::EleID::ELEIDRNNTIGHT;
1639  else {
1640  ATH_MSG_INFO("No or invalid Ele OR in tau config file " << eleIDWP << " will not apply SFs for electro veto" );
1641  }
1642  // Add retrieval of electron veto SFs if its applied
1643  if (ele_id_lvl != -1 )
1644  correction_types.insert(correction_types.end(), {TauAnalysisTools::EfficiencyCorrectionType::SFEleIDHadTau,
1645  TauAnalysisTools::EfficiencyCorrectionType::SFEleIDElectron});
1646 
1647  ATH_CHECK( m_tauEffTool.setProperty("JetIDLevel", jet_id_lvl) );
1648  ATH_CHECK( m_tauEffTool.setProperty("EleIDLevel", ele_id_lvl) );
1649  ATH_CHECK( m_tauEffTool.setProperty("EfficiencyCorrectionTypes", correction_types) );
1650  ATH_CHECK( m_tauEffTool.setProperty("OutputLevel", this->msg().level()) );
1651  ATH_CHECK( m_tauEffTool.setProperty("useFastSim", isAtlfast()) );
1652  ATH_CHECK( m_tauEffTool.setProperty("RecommendationTag", m_tauEffToolRecommendationTag) );
1653  if (m_isRun3){ ATH_CHECK( m_tauEffTool.setProperty("Campaign", "mc23") );}
1654  else { ATH_CHECK( m_tauEffTool.setProperty("Campaign", "mc20") );}
1655  ATH_CHECK( m_tauEffTool.retrieve() );
1656  } else if (m_tauEffTool.isUserConfigured()) ATH_CHECK( m_tauEffTool.retrieve() );
1657 
1658 
1660  // Initialise tau trigger efficiency tool(s)
1661 
1662  if (!isData()) {
1663  int iTauID = (int) TauAnalysisTools::JETIDNONEUNCONFIGURED;
1664  if (m_tauId == "rnn001") iTauID = (int) TauAnalysisTools::JETIDNONE;
1665  else if (m_tauId == "VeryLoose") iTauID = (int) TauAnalysisTools::JETIDRNNVERYLOOSE;
1666  else if (m_tauId == "Loose") iTauID = (int) TauAnalysisTools::JETIDRNNLOOSE;
1667  else if (m_tauId == "Medium") iTauID = (int) TauAnalysisTools::JETIDRNNMEDIUM;
1668  else if (m_tauId == "Tight") iTauID = (int) TauAnalysisTools::JETIDRNNTIGHT;
1669  else {
1670  ATH_MSG_ERROR("Invalid tau ID selected: " << m_tauId);
1671  return StatusCode::FAILURE;
1672  }
1673 
1674  // map format: SF file name, corresponding single-tau leg (comma-separated in case of OR)
1675  m_tau_trig_support = {
1676  {"HLT_tau25_medium1_tracktwo", "HLT_tau25_medium1_tracktwo"},
1677  {"HLT_tau35_medium1_tracktwo", "HLT_tau35_medium1_tracktwo"},
1678  {"HLT_tau50L1TAU12_medium1_tracktwo", "HLT_tau50_medium1_tracktwo_L1TAU12"},
1679  {"HLT_tau60_medium1_tracktwo", "HLT_tau60_medium1_tracktwo"},
1680  {"HLT_tau80L1TAU60_medium1_tracktwo", "HLT_tau80_medium1_tracktwo_L1TAU60"},
1681  {"HLT_tau125_medium1_tracktwo", "HLT_tau125_medium1_tracktwo"},
1682  {"HLT_tau160_medium1_tracktwo", "HLT_tau160_medium1_tracktwo"},
1683  {"HLT_tau160L1TAU100_medium1_tracktwo", "HLT_tau160_medium1_tracktwo_L1TAU100"},
1684  // whole 2018 data taking period
1685  {"HLT_tau25_medium1_tracktwoEF", "HLT_tau25_medium1_tracktwoEF"},
1686  {"HLT_tau35_medium1_tracktwoEF", "HLT_tau35_medium1_tracktwoEF"},
1687  {"HLT_tau60_medium1_tracktwoEF", "HLT_tau60_medium1_tracktwoEF"},
1688  {"HLT_tau80L1TAU60_medium1_tracktwoEF", "HLT_tau80_medium1_tracktwoEF_L1TAU60"},
1689  {"HLT_tau160L1TAU100_medium1_tracktwoEF", "HLT_tau160_medium1_tracktwoEF_L1TAU100"},
1690  };
1691 
1692  if (m_isRun3){
1693  m_tau_trig_support = {
1694  // 2022, 2023
1695  {"HLT_tau25_mediumRNN_tracktwoMVA", "HLT_tau25_mediumRNN_tracktwoMVA"},
1696  {"HLT_tau35_mediumRNN_tracktwoMVA", "HLT_tau35_mediumRNN_tracktwoMVA"},
1697  // 2022, 2023 75-1800 bunches
1698  {"HLT_tau160_mediumRNN_tracktwoMVA", "HLT_tau160_mediumRNN_tracktwoMVA_L1TAU100"},
1699  // 2023 from 400 bunches
1700  {"HLT_tau160_mediumRNN_tracktwoMVA", "HLT_tau160_mediumRNN_tracktwoMVA_L1eTAU140"}
1701  };
1702  }
1703 
1704  for(auto const& trigger : m_tau_trig_support) {
1705  toolName = "TauTrigEffTool_" + m_tauId + "_" + trigger.first;
1706  auto tau_trigSF = m_tauTrigEffTool.emplace(m_tauTrigEffTool.end(), "TauAnalysisTools::TauEfficiencyCorrectionsTool/"+toolName);
1707  ATH_CHECK( tau_trigSF->setProperty("EfficiencyCorrectionTypes", std::vector<int>({TauAnalysisTools::SFTriggerHadTau})) );
1708  ATH_CHECK( tau_trigSF->setProperty("TriggerName", trigger.first) );
1709  ATH_CHECK( tau_trigSF->setProperty("JetIDLevel", iTauID) );
1710  ATH_CHECK( tau_trigSF->setProperty("OutputLevel", this->msg().level()) );
1711  ATH_CHECK( tau_trigSF->setProperty("useFastSim", isAtlfast()) );
1712  ATH_CHECK( tau_trigSF->setProperty("RecommendationTag", m_tauEffToolRecommendationTag) );
1713  if (m_isRun3){ ATH_CHECK( tau_trigSF->setProperty("Campaign", m_mcCampaign) );}
1714  else { ATH_CHECK( tau_trigSF->setProperty("Campaign", "mc20") );}
1715  ATH_CHECK( tau_trigSF->initialize() );
1716  }
1717  }
1718 
1719 
1721  // Initialise tau smearing tool
1722 
1723  if (!m_tauSmearingTool.isUserConfigured()) {
1724  m_tauSmearingTool.setTypeAndName("TauAnalysisTools::TauSmearingTool/TauSmearingTool");
1725  ATH_CHECK( m_tauSmearingTool.setProperty("RecommendationTag", m_tauSmearingToolRecommendationTag) );
1726  if (m_isRun3){ ATH_CHECK( m_tauSmearingTool.setProperty("Campaign", "mc23") );}
1727  else { ATH_CHECK( m_tauSmearingTool.setProperty("Campaign", "mc20") );}
1728  ATH_CHECK( m_tauSmearingTool.setProperty("Generator", m_tauSmearingToolGenerator) );
1729  ATH_CHECK( m_tauSmearingTool.setProperty("MVATESQualityCheck", m_ApplyMVATESQualityCheck) );
1730  ATH_CHECK( m_tauSmearingTool.setProperty("useFastSim", isAtlfast()) );
1731  ATH_CHECK( m_tauSmearingTool.setProperty("OutputLevel", this->msg().level()) );
1732  ATH_CHECK( m_tauSmearingTool.retrieve() );
1733  } else ATH_CHECK( m_tauSmearingTool.retrieve() );
1734 
1735 
1737  // Initialise tau truth matching tool
1738 
1739  if (!m_tauTruthMatch.isUserConfigured() && m_tauDoTTM && !isData()) {
1740  m_tauTruthMatch.setTypeAndName("TauAnalysisTools::TauTruthMatchingTool/TauTruthMatch");
1741  ATH_CHECK( m_tauTruthMatch.setProperty("TruthJetContainerName", m_defaultTruthJets ) );
1742  ATH_CHECK( m_tauTruthMatch.setProperty("OutputLevel", this->msg().level()) );
1743  ATH_CHECK( m_tauTruthMatch.retrieve() );
1744  } else if (m_tauTruthMatch.isUserConfigured()) ATH_CHECK( m_tauTruthMatch.retrieve() );
1745 
1746 
1747  }
1748 
1749 
1750  if (m_slices["bjet"]) {
1752  // Initialise B-tagging tools
1753 
1754  // btagSelectionTool
1755  std::string jetcollBTag = jetcoll;
1756  if (jetcoll == "AntiKt4LCTopoJets") {
1757  ATH_MSG_WARNING(" *** HACK *** Treating LCTopoJets jets as EMTopo -- use at your own risk!");
1758  jetcollBTag = "AntiKt4EMTopoJets";
1759  }
1760 
1761  // print a warning if there is indication that the user supplied a CDI file not matching to the sample being processed
1762  // see --> https://twiki.cern.ch/twiki/bin/view/AtlasProtected/BTagRel22HighLevelSummary
1763  if( (m_bTaggingCalibrationFilePath.find(!m_isRun3 ? "MC20" : "MC23") == std::string::npos) && (m_bTaggingCalibrationFilePath.find(!m_isRun3 ? "MC20" : "MC21") == std::string::npos) ) {
1764  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"));
1765  }
1766 
1767  if (m_useBtagging && !m_btagSelTool.isUserConfigured() && !m_BtagWP.empty()) {
1768  if (jetcollBTag.find("AntiKt4EMTopoJets") == std::string::npos && jetcollBTag.find("AntiKt4EMPFlowJets")==std::string::npos) {
1769  ATH_MSG_WARNING("** Only AntiKt4EMTopoJets and AntiKt4EMPFlowJets are supported with FTAG scale factors!");
1770  return StatusCode::FAILURE;
1771  }
1772 
1773  toolName = "BTagSel_" + jetcollBTag + m_BtagTagger + m_BtagWP;
1774 
1775  m_btagSelTool.setTypeAndName("BTaggingSelectionTool/"+toolName);
1776  ATH_CHECK( m_btagSelTool.setProperty("TaggerName", m_BtagTagger ) );
1777  ATH_CHECK( m_btagSelTool.setProperty("OperatingPoint", m_BtagWP ) );
1778  ATH_CHECK( m_btagSelTool.setProperty("JetAuthor", jetcollBTag ) );
1779  ATH_CHECK( m_btagSelTool.setProperty("MinPt", m_BtagMinPt ) );
1780  ATH_CHECK( m_btagSelTool.setProperty("FlvTagCutDefinitionsFileName", m_bTaggingCalibrationFilePath) );
1781  // Read from BTagging object. This will be needed until the input file is produced from
1782  // a derivation release that includes !80336.
1783  ATH_CHECK( m_btagSelTool.setProperty("readFromBTaggingObject", true ) );
1784  ATH_CHECK( m_btagSelTool.setProperty("OutputLevel", this->msg().level()) );
1785  ATH_CHECK( m_btagSelTool.retrieve() );
1786  } else if (m_btagSelTool.isUserConfigured()) ATH_CHECK( m_btagSelTool.retrieve() );
1787 
1788 
1789  if (m_useBtagging && !m_btagSelTool_OR.isUserConfigured() && !m_orBtagWP.empty()) {
1790  if (jetcoll != "AntiKt4EMTopoJets" && jetcoll != "AntiKt4EMPFlowJets") {
1791  ATH_MSG_WARNING("** Only AntiKt4EMTopoJets and AntiKt4EMPFlowJets are supported with FTAG scale factors!");
1792  return StatusCode::FAILURE;
1793  }
1794 
1795  toolName = "BTagSelOR_" + jetcollBTag + m_orBtagWP;
1796  m_btagSelTool_OR.setTypeAndName("BTaggingSelectionTool/"+toolName);
1797  ATH_CHECK( m_btagSelTool_OR.setProperty("TaggerName", m_BtagTagger ) );
1798  ATH_CHECK( m_btagSelTool_OR.setProperty("OperatingPoint", m_orBtagWP ) );
1799  ATH_CHECK( m_btagSelTool_OR.setProperty("JetAuthor", jetcollBTag ) );
1800  ATH_CHECK( m_btagSelTool_OR.setProperty("MinPt", m_BtagMinPt ) );
1801  ATH_CHECK( m_btagSelTool_OR.setProperty("FlvTagCutDefinitionsFileName", m_bTaggingCalibrationFilePath) );
1802  // Read from BTagging object. This will be needed until the input file is produced from
1803  // a derivation release that includes !80336.
1804  ATH_CHECK( m_btagSelTool_OR.setProperty("readFromBTaggingObject", true ) );
1805  ATH_CHECK( m_btagSelTool_OR.setProperty("OutputLevel", this->msg().level()) );
1806  ATH_CHECK( m_btagSelTool_OR.retrieve() );
1807  } else if (m_btagSelTool_OR.isUserConfigured()) ATH_CHECK( m_btagSelTool_OR.retrieve() );
1808 
1809 
1810  std::string trkjetcoll = m_defaultTrackJets;
1811  const std::string& BTagColl_TrkJet = trkjetcoll;
1812  if (m_slices["tjet"]) {
1813  if ( m_useBtagging_trkJet && m_defaultTrackJets.empty()) {
1814  m_useBtagging_trkJet = false;
1815  ATH_MSG_INFO("TrackJet collection set to None: disabling btagging for TrackJets.");
1816  }
1817 
1818  if (m_useBtagging_trkJet && !m_btagSelTool_trkJet.isUserConfigured() && !m_BtagWP_trkJet.empty()) {
1819  if (trkjetcoll.find("AntiKt2PV0TrackJets")==std::string::npos && trkjetcoll.find("AntiKtVR30Rmax4Rmin02TrackJets")==std::string::npos) {
1820  ATH_MSG_WARNING("** Only AntiKt2PV0TrackJets and AntiKtVR30Rmax4Rmin02TrackJets are supported with FTAG scale factors!");
1821  return StatusCode::FAILURE;
1822  }
1823 
1824  toolName = "BTagSel_" + trkjetcoll + m_BtagTagger_trkJet + m_BtagWP_trkJet;
1825 
1826  m_btagSelTool_trkJet.setTypeAndName("BTaggingSelectionTool/"+toolName);
1827  ATH_CHECK( m_btagSelTool_trkJet.setProperty("TaggerName", m_BtagTagger_trkJet ) );
1828  ATH_CHECK( m_btagSelTool_trkJet.setProperty("OperatingPoint", m_BtagWP_trkJet ) );
1829  ATH_CHECK( m_btagSelTool_trkJet.setProperty("MinPt", m_BtagMinPt_trkJet ) );
1830  ATH_CHECK( m_btagSelTool_trkJet.setProperty("JetAuthor", BTagColl_TrkJet ) );
1831  ATH_CHECK( m_btagSelTool_trkJet.setProperty("MinPt", m_BtagMinPt_trkJet ) );
1832  ATH_CHECK( m_btagSelTool_trkJet.setProperty("FlvTagCutDefinitionsFileName", m_bTaggingCalibrationFilePath) );
1833  // Read from BTagging object. This will be needed until the input file is produced from
1834  // a derivation release that includes !80336.
1835  ATH_CHECK( m_btagSelTool_trkJet.setProperty("readFromBTaggingObject", true ) );
1836  ATH_CHECK( m_btagSelTool_trkJet.setProperty("OutputLevel", this->msg().level()) );
1837  ATH_CHECK( m_btagSelTool_trkJet.retrieve() );
1838  } else if (m_btagSelTool_trkJet.isUserConfigured()) ATH_CHECK( m_btagSelTool_trkJet.retrieve() );
1839  }
1840 
1841  // Set MCshowerType for FTAG MC/MC SFs
1842  // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/BTagCalibrationRecommendationsRelease21#MC_MC_Scale_Factors_for_Analysis
1843  std::string MCshowerID;
1844  if(m_showerType==-1){
1845  ATH_MSG_ERROR( "Error! m_showerType=-1, which is an error case for FTAG MC/MC SFs." );
1846  return StatusCode::FAILURE;
1847  }
1848  if(m_BtagTagger=="DL1dv01"){
1849  if(!m_isRun3){
1850  MCshowerID= "default"; // Powheg+Pythia8 (410470) - PhPy8EG_A14
1851  if (m_showerType == 1) MCshowerID = "411233"; // PowhegHerwig7
1852  else if (m_showerType == 2) MCshowerID = "600666"; // PhH7EG_H7UE - 601414
1853  else if (m_showerType == 3) MCshowerID = "410250"; // Sherpa_221
1854  else if (m_showerType == 4) MCshowerID = "700122"; // Sh_2210
1855  else if (m_showerType == 5) MCshowerID = "700122"; // Sh_2211
1856  else if (m_showerType == 6) MCshowerID = "700660"; // Sh_2212 - 700660
1857  else if (m_showerType == 7) MCshowerID = "410464"; // aMcAtNloPy8
1858  else if (m_showerType == 8) MCshowerID = "412116"; // aMcAtNloHerwig7
1859  else if (m_showerType != 0){
1860  ATH_MSG_WARNING("Unknown ShowerID detected! Using default FTAG MC-MC SFs (Powheg+Pythia8). Please check if these are applicable for this sample!");
1861  }
1862  }
1863  else{
1864  MCshowerID= "default"; // Powheg+Pythia8 (601229) - PhPy8EG_A14
1865  if (m_showerType == 2) MCshowerID = "601414"; // POWHEG+Herwig721 - PhH7EG_A14
1866  else if (m_showerType == 6) MCshowerID = "700660"; // Sherpa 2.2.12 - Sh_2212
1867  else if (m_showerType != 0){
1868  ATH_MSG_WARNING("Unknown ShowerID detected! Using default FTAG MC-MC SFs (Powheg+Pythia8). Please check if these are applicable for this sample!");
1869  }
1870  }
1871  } else if (m_BtagTagger=="GN2v01"){
1872  if(!m_isRun3){
1873  MCshowerID= "default"; // PowhegPythia8EvtGen (410470)
1874  if (m_showerType == 2) MCshowerID = "411233"; // POWHEGHERWIG7 - 411233
1875  else if (m_showerType == 3) MCshowerID = "600666"; // PhH7EG_H7UE - 600666
1876  else if (m_showerType == 4) MCshowerID = "700660"; // Sh_2210 FTAGAnalysisConfig uses this, but docs say only 11-16 can be used
1877  else if (m_showerType == 5) MCshowerID = "700660"; // Sh_2211
1878  else if (m_showerType == 6) MCshowerID = "700660"; // Sh_2212
1879  else if (m_showerType == 7) MCshowerID = "700660"; // Sh_2214
1880  else if (m_showerType == 8) {
1881  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!");
1882  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.
1883  }
1884  else if (m_showerType != 0){
1885  ATH_MSG_WARNING("Unknown ShowerID detected! Using default FTAG MC-MC SFs (Powheg+Pythia8). Please check if these are applicable for this sample!");
1886  }
1887  }
1888  else {
1889  MCshowerID= "default"; // PowhegPythia8EvtGen (601229)
1890  if (m_showerType == 3) MCshowerID = "601414"; // PhH7EG_H7UE - 601414
1891  else if (m_showerType == 5) MCshowerID = "700808"; // Sh_2211
1892  else if (m_showerType == 6) MCshowerID = "700808"; // Sh_2212
1893  else if (m_showerType == 7) MCshowerID = "700808"; // Sh_2214
1894  else if (m_showerType == 8) {
1895  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!");
1896  MCshowerID = "700660"; // Unknown Sherpa Version
1897  }
1898  else if (m_showerType != 0){
1899  ATH_MSG_WARNING("Unknown ShowerID detected! Using default FTAG MC-MC SFs (Powheg+Pythia8). Please check if these are applicable for this sample!");
1900  }
1901  }
1902  } else {
1903  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!");
1904  MCshowerID= "default";
1905  }
1906 
1907  // btagEfficiencyTool
1908  if (m_useBtagging && !m_btagEffTool.isUserConfigured() && !m_BtagWP.empty()) {
1909  if (jetcoll != "AntiKt4EMTopoJets" && jetcoll != "AntiKt4EMPFlowJets") {
1910  ATH_MSG_WARNING("** Only AntiKt4EMTopoJets and AntiKt4EMPFlowJets are supported with FTAG scale factors!");
1911  return StatusCode::FAILURE;
1912  }
1913 
1914  toolName = "BTagSF_" + jetcollBTag + m_BtagTagger + m_BtagWP;
1915  m_btagEffTool.setTypeAndName("BTaggingEfficiencyTool/"+toolName);
1916  ATH_CHECK( m_btagEffTool.setProperty("TaggerName", m_BtagTagger ) );
1917  ATH_CHECK( m_btagEffTool.setProperty("ScaleFactorFileName", m_bTaggingCalibrationFilePath) );
1918  ATH_CHECK( m_btagEffTool.setProperty("OperatingPoint", m_BtagWP ) );
1919  ATH_CHECK( m_btagEffTool.setProperty("JetAuthor", jetcollBTag ) );
1920  // Read from BTagging object. This will be needed until the input file is produced from
1921  // a derivation release that includes !80336.
1922  ATH_CHECK( m_btagEffTool.setProperty("readFromBTaggingObject", true) );
1923  ATH_CHECK( m_btagEffTool.setProperty("MinPt", m_BtagMinPt ) );
1924  ATH_CHECK( m_btagEffTool.setProperty("SystematicsStrategy", m_BtagSystStrategy ) );
1925  ATH_CHECK( m_btagEffTool.setProperty("EfficiencyBCalibrations", MCshowerID ));
1926  ATH_CHECK( m_btagEffTool.setProperty("EfficiencyCCalibrations", MCshowerID ));
1927  ATH_CHECK( m_btagEffTool.setProperty("EfficiencyTCalibrations", MCshowerID ));
1928  ATH_CHECK( m_btagEffTool.setProperty("EfficiencyLightCalibrations", MCshowerID ));
1929  ATH_CHECK( m_btagEffTool.setProperty("EigenvectorReductionB", m_EigenvectorReductionB ));
1930  ATH_CHECK( m_btagEffTool.setProperty("EigenvectorReductionC", m_EigenvectorReductionC ));
1931  ATH_CHECK( m_btagEffTool.setProperty("EigenvectorReductionLight", m_EigenvectorReductionLight ));
1932  ATH_CHECK( m_btagEffTool.setProperty("OutputLevel", this->msg().level()) );
1933  ATH_CHECK( m_btagEffTool.retrieve() );
1934  } else ATH_CHECK( m_btagEffTool.retrieve() );
1935 
1936 
1937  if (m_slices["tjet"]) {
1938  if (m_useBtagging_trkJet && !m_btagEffTool_trkJet.isUserConfigured() && !m_BtagWP_trkJet.empty()) {
1939  if (trkjetcoll.find("AntiKt2PV0TrackJets")==std::string::npos && trkjetcoll.find("AntiKtVR30Rmax4Rmin02TrackJets")==std::string::npos) {
1940  ATH_MSG_WARNING("** Only AntiKt2PV0TrackJets and AntiKtVR30Rmax4Rmin02TrackJets are supported with FTAG scale factors!");
1941  return StatusCode::FAILURE;
1942  }
1943 
1944  toolName = "BTagSF_" + trkjetcoll;
1945  m_btagEffTool_trkJet.setTypeAndName("BTaggingEfficiencyTool/"+toolName);
1946  ATH_CHECK( m_btagEffTool_trkJet.setProperty("TaggerName", m_BtagTagger_trkJet ) );
1947  ATH_CHECK( m_btagEffTool_trkJet.setProperty("ScaleFactorFileName", m_bTaggingCalibrationFilePath) );
1948  ATH_CHECK( m_btagEffTool_trkJet.setProperty("OperatingPoint", m_BtagWP_trkJet ) );
1949  ATH_CHECK( m_btagEffTool_trkJet.setProperty("JetAuthor", BTagColl_TrkJet ) );
1950  ATH_CHECK( m_btagEffTool_trkJet.setProperty("MinPt", m_BtagMinPt_trkJet ) );
1951  ATH_CHECK( m_btagEffTool_trkJet.setProperty("SystematicsStrategy", m_BtagSystStrategy ) );
1952  ATH_CHECK( m_btagEffTool_trkJet.setProperty("EfficiencyBCalibrations", MCshowerID ));
1953  ATH_CHECK( m_btagEffTool_trkJet.setProperty("EfficiencyCCalibrations", MCshowerID ));
1954  ATH_CHECK( m_btagEffTool_trkJet.setProperty("EfficiencyTCalibrations", MCshowerID ));
1955  ATH_CHECK( m_btagEffTool_trkJet.setProperty("EfficiencyLightCalibrations", MCshowerID ));
1956  ATH_CHECK( m_btagEffTool_trkJet.setProperty("EigenvectorReductionB", m_EigenvectorReductionB ));
1957  ATH_CHECK( m_btagEffTool_trkJet.setProperty("EigenvectorReductionC", m_EigenvectorReductionC ));
1958  ATH_CHECK( m_btagEffTool_trkJet.setProperty("EigenvectorReductionLight", m_EigenvectorReductionLight ));
1959  ATH_CHECK( m_btagEffTool_trkJet.setProperty("OutputLevel", this->msg().level()) );
1960  ATH_CHECK( m_btagEffTool_trkJet.retrieve() );
1961  } else if (m_btagEffTool_trkJet.isUserConfigured()) ATH_CHECK( m_btagEffTool_trkJet.retrieve() );
1962  }
1963  }
1964 
1965 
1966  if (m_slices["met"]) {
1968  // Initialise MET tools
1969 
1970  if (!m_metMaker.isUserConfigured()) {
1971  toolName = m_doFwdJVT ? m_metJetSelection+"_fJVT" : m_metJetSelection+"_NOfJVT";
1972  m_metMaker.setTypeAndName("met::METMaker/METMaker_ST_"+toolName);
1973 
1974  ATH_CHECK( m_metMaker.setProperty("ORCaloTaggedMuons", m_metRemoveOverlappingCaloTaggedMuons) );
1975  ATH_CHECK( m_metMaker.setProperty("DoSetMuonJetEMScale", m_metDoSetMuonJetEMScale) );
1976  ATH_CHECK( m_metMaker.setProperty("DoRemoveMuonJets", m_metDoRemoveMuonJets) );
1977  ATH_CHECK( m_metMaker.setProperty("UseGhostMuons", m_metUseGhostMuons) );
1978  ATH_CHECK( m_metMaker.setProperty("DoMuonEloss", m_metDoMuonEloss) );
1979  ATH_CHECK( m_metMaker.setProperty("GreedyPhotons", m_metGreedyPhotons) );
1980  ATH_CHECK( m_metMaker.setProperty("VeryGreedyPhotons", m_metVeryGreedyPhotons) );
1981 
1982  // set the jet selection if default empty string is overridden through config file
1983  if (m_metJetSelection.size()) {
1984  ATH_CHECK( m_metMaker.setProperty("JetSelection", m_metJetSelection) );
1985  }
1986  if (m_jetInputType == xAOD::JetInput::EMPFlow) {
1987  ATH_CHECK( m_metMaker.setProperty("DoPFlow", true) );
1988  }
1989 
1990  ATH_CHECK( m_metMaker.setProperty("OutputLevel", this->msg().level()) );
1991  ATH_CHECK( m_metMaker.retrieve() );
1992  } else ATH_CHECK( m_metMaker.retrieve() );
1993 
1994 
1995  if (!m_metSystTool.isUserConfigured()) {
1996  m_metSystTool.setTypeAndName("met::METSystematicsTool/METSystTool");
1997  ATH_CHECK( m_metSystTool.setProperty("ConfigPrefix", m_metsysConfigPrefix) );
1998 
1999  if (m_trkMETsyst && m_caloMETsyst){
2000  ATH_MSG_ERROR( "Can only have CST *or* TST configured for MET maker. Please unset either METDoCaloSyst or METDoTrkSyst in your config file" );
2001  return StatusCode::FAILURE;
2002  }
2003 
2004  if (m_trkMETsyst) {
2005  ATH_CHECK( m_metSystTool.setProperty("ConfigSoftCaloFile", "") );
2006  ATH_CHECK( m_metSystTool.setProperty("ConfigSoftTrkFile", "TrackSoftTerms-pflow_Dec24.config") );
2007  }
2008 
2009  if (m_caloMETsyst) {
2010  ATH_MSG_WARNING( "CST is no longer recommended by Jet/MET group");
2011  ATH_CHECK( m_metSystTool.setProperty("ConfigSoftTrkFile", "") );
2012  }
2013 
2014  if (m_trkJetsyst) {
2015  ATH_CHECK( m_metSystTool.setProperty("ConfigJetTrkFile", "JetTrackSyst.config") );
2016  }
2017 
2018  ATH_CHECK( m_metSystTool.setProperty("OutputLevel", this->msg().level()) );
2019  ATH_CHECK( m_metSystTool.retrieve());
2020  } else ATH_CHECK( m_metSystTool.retrieve());
2021 
2022 
2023  if (!m_metSignif.isUserConfigured()) {
2024  // See https://twiki.cern.ch/twiki/bin/view/AtlasProtected/MetSignificance
2025  m_metSignif.setTypeAndName("met::METSignificance/metSignificance_"+jetname);
2026 #ifndef XAOD_STANDALONE // Athena and AthAnalysis; need to take into account that MuonCalibTool is private tool
2027  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "SoftTermParam", m_softTermParam));
2028  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "TreatPUJets", m_treatPUJets));
2029  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "DoPhiReso", m_doPhiReso));
2030  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "IsAFII", isAtlfast()));
2031  if(jetname == "AntiKt4EMTopo" || jetname =="AntiKt4EMPFlow"){
2032  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "JetCollection", jetname) );
2033  } else {
2034  ATH_MSG_WARNING("Object-based METSignificance recommendations only exist for EMTopo and PFlow, falling back to AntiKt4EMTopo");
2035  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "JetCollection", "AntiKt4EMTopo") );
2036  }
2037  // setup a dedicated new muon calib tool for passing down to METSignificance
2038  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "MuonCalibTool", "CP::MuonCalibTool/calibTool"));
2039  if (m_isRun3)
2040  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.IsRun3Geo", true));
2041  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.calibMode", m_muCalibrationMode));
2042  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.OutputLevel",this->msg().level()));
2043  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.release", "Recs2025_03_26_Run2Run3"));
2044  int IdBaselineInt = m_muIdBaseline;
2045  if (IdBaselineInt == 4)
2046  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.do2StationsHighPt", true));
2047  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.doExtraSmearing", m_muHighPtExtraSmear));
2048  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "OutputLevel", this->msg().level()));
2049 #else // AnalysisBase; can just pass the muon calib tool configured above
2050  ATH_CHECK( m_metSignif.setProperty("SoftTermParam", m_softTermParam) );
2051  ATH_CHECK( m_metSignif.setProperty("TreatPUJets", m_treatPUJets) );
2052  ATH_CHECK( m_metSignif.setProperty("DoPhiReso", m_doPhiReso) );
2053  ATH_CHECK( m_metSignif.setProperty("IsAFII", isAtlfast()) );
2054  if(jetname == "AntiKt4EMTopo" || jetname =="AntiKt4EMPFlow"){
2055  ATH_CHECK( m_metSignif.setProperty("JetCollection", jetname) );
2056  } else {
2057  ATH_MSG_WARNING("Object-based METSignificance recommendations only exist for EMTopo and PFlow, falling back to AntiKt4EMTopo");
2058  ATH_CHECK( m_metSignif.setProperty("JetCollection", "AntiKt4EMTopo") );
2059  }
2060  // just pass the muon calib tool
2061  ATH_CHECK( m_metSignif.setProperty("MuonCalibTool",m_muonCalibTool.getHandle()));
2062  ATH_CHECK( m_metSignif.setProperty("OutputLevel", this->msg().level()) );
2063 #endif
2064  ATH_CHECK( m_metSignif.retrieve() );
2065  } else ATH_CHECK( m_metSignif.retrieve() );
2066  }
2067 
2068 
2070 // Initialise trigger tools
2071 
2072  if (!m_trigDecTool.isUserConfigured()) {
2073 
2074  // The decision tool
2075  m_trigDecTool.setTypeAndName("Trig::TrigDecisionTool/TrigDecisionTool");
2076  ATH_CHECK( m_trigDecTool.setProperty("TrigDecisionKey", "xTrigDecision") );
2077  if (m_isRun3) {
2078  ATH_CHECK( m_trigDecTool.setProperty("NavigationFormat", "TrigComposite") );
2079  ATH_CHECK( m_trigDecTool.setProperty("HLTSummary", "HLTNav_Summary_DAODSlimmed") );
2080  }
2081  ATH_CHECK( m_trigDecTool.setProperty("OutputLevel", this->msg().level()) );
2082 
2083 #ifndef XAOD_STANDALONE // Athena and AthAnalysis
2084  // Clear the default tool handle to cause a fallback on the config service
2085  ATH_CHECK( m_trigDecTool.setProperty("ConfigTool", ""));
2086 #else // AnalysisBase
2087  m_trigConfTool.setTypeAndName("TrigConf::xAODConfigTool/xAODConfigTool");
2088  ATH_CHECK(m_trigConfTool.retrieve() );
2089  ATH_CHECK( m_trigDecTool.setProperty("ConfigTool", m_trigConfTool.getHandle()) );
2090 #endif
2091 
2092  ATH_CHECK( m_trigDecTool.retrieve() );
2093 
2094  } else ATH_CHECK( m_trigDecTool.retrieve() );
2095 
2096  if (m_isRun3) {
2097  if (!m_trigDRScoringTool.isUserConfigured()) {
2098  m_trigDRScoringTool.setTypeAndName("Trig::DRScoringTool/TrigDRScoringTool");
2099  ATH_CHECK( m_trigDRScoringTool.setProperty("OutputLevel", this->msg().level()) );
2100  ATH_CHECK( m_trigDRScoringTool.retrieve() );
2101  } else ATH_CHECK( m_trigDRScoringTool.retrieve() );
2102  }
2103 
2104  if (!m_trigMatchingTool.isUserConfigured()) {
2105  if (m_upstreamTriggerMatching){
2106  m_trigMatchingTool.setTypeAndName("Trig::MatchFromCompositeTool/TrigMatchFromCompositeTool");
2107  ATH_CHECK( m_trigMatchingTool.setProperty("InputPrefix", m_trigMatchingPrefix) );
2108  ATH_CHECK( m_trigMatchingTool.setProperty("RemapBrokenLinks", true) );
2109  }
2110  else {
2111  if (m_isRun3){
2112  m_trigMatchingTool.setTypeAndName("Trig::R3MatchingTool/TrigR3MatchingTool");
2113  ATH_CHECK( m_trigMatchingTool.setProperty("ScoringTool", m_trigDRScoringTool.getHandle()) );
2114  ATH_CHECK( m_trigMatchingTool.setProperty("TrigDecisionTool", m_trigDecTool.getHandle()) );
2115  }
2116  else {
2117  m_trigMatchingTool.setTypeAndName("Trig::MatchingTool/TrigMatchingTool");
2118  ATH_CHECK( m_trigMatchingTool.setProperty("TrigDecisionTool", m_trigDecTool.getHandle()) );
2119  }
2120  }
2121  ATH_CHECK( m_trigMatchingTool.setProperty("OutputLevel", this->msg().level()) );
2122  ATH_CHECK( m_trigMatchingTool.retrieve() );
2123  } else ATH_CHECK( m_trigMatchingTool.retrieve() );
2124 
2126 // Initialise trigGlobalEfficiencyCorrection tool
2127 
2128  if (!m_trigGlobalEffCorrTool_diLep.isUserConfigured() && !isData()) {
2129 
2130  std::string no2e17("");
2131  if (m_trig2017combination_diLep.find("||2e17_lhvloose_nod0_L12EM15VHI") != std::string::npos) {
2132  auto pos_2e17 = m_trig2017combination_diLep.find("||2e17_lhvloose_nod0_L12EM15VHI");
2133  no2e17 = m_trig2017combination_diLep.substr(0, pos_2e17) + m_trig2017combination_diLep.substr(pos_2e17+31, m_trig2017combination_diLep.size());
2134  } else if (m_trig2017combination_diLep.find("2e17_lhvloose_nod0_L12EM15VHI||") != std::string::npos) {
2135  auto pos_2e17 = m_trig2017combination_diLep.find("2e17_lhvloose_nod0_L12EM15VHI||");
2136  no2e17 = m_trig2017combination_diLep.substr(0, pos_2e17) + m_trig2017combination_diLep.substr(pos_2e17+31, m_trig2017combination_diLep.size());
2137  } else {
2138  no2e17 = m_trig2017combination_diLep;
2139  }
2140  ATH_MSG_DEBUG( "TrigGlobalEfficiencyCorrectionTool/TrigGlobal_diLep: no2e17 trigger string: " << no2e17 );
2141 
2142  std::map<std::string,std::string> triggers_diLep;
2143  triggers_diLep["2015"] = m_trig2015combination_diLep;
2144  triggers_diLep["2016"] = m_trig2016combination_diLep;
2145  triggers_diLep["324320-326695"] = m_trig2017combination_diLep; // 2017 before accidental prescale of L12EM15VHI
2146  triggers_diLep["326834-328393"] = no2e17; // 2017 during accidental prescale
2147  triggers_diLep["329385-340453"] = m_trig2017combination_diLep; // 2017 after accidental prescale
2148  triggers_diLep["2018"] = m_trig2018combination_diLep;
2149 
2150  m_trigGlobalEffCorrTool_diLep.setTypeAndName("TrigGlobalEfficiencyCorrectionTool/TrigGlobal_diLep");
2151  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("ElectronEfficiencyTools", m_elecTrigEffTools) );
2152  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("ElectronScaleFactorTools", m_elecTrigSFTools) );
2153  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("MuonTools", m_muonTrigSFTools) );
2154  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("TriggerCombination", triggers_diLep) );
2155  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("TriggerMatchingTool", m_trigMatchingTool.getHandle()) );
2156  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("ListOfLegsPerTool", m_legsPerTool) );
2157  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("NumberOfToys", m_trigNToys_diLep) );
2158  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("OutputLevel", this->msg().level()) );
2159  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.initialize() );
2160  } else if (m_trigGlobalEffCorrTool_diLep.isUserConfigured()) ATH_CHECK( m_trigGlobalEffCorrTool_diLep.retrieve() );
2161 
2162 
2163  if (!m_trigGlobalEffCorrTool_multiLep.isUserConfigured() && !isData()) {
2164 
2165  std::string no2e17("");
2166  if (m_trig2017combination_multiLep.find("||2e17_lhvloose_nod0_L12EM15VHI") != std::string::npos) {
2167  auto pos_2e17 = m_trig2017combination_multiLep.find("||2e17_lhvloose_nod0_L12EM15VHI");
2168  no2e17 = m_trig2017combination_multiLep.substr(0, pos_2e17) + m_trig2017combination_multiLep.substr(pos_2e17+31, m_trig2017combination_multiLep.size());
2169  } else if (m_trig2017combination_multiLep.find("2e17_lhvloose_nod0_L12EM15VHI||") != std::string::npos) {
2170  auto pos_2e17 = m_trig2017combination_multiLep.find("2e17_lhvloose_nod0_L12EM15VHI||");
2171  no2e17 = m_trig2017combination_multiLep.substr(0, pos_2e17) + m_trig2017combination_multiLep.substr(pos_2e17+31, m_trig2017combination_multiLep.size());
2172  } else {
2173  no2e17 = m_trig2017combination_multiLep;
2174  }
2175  ATH_MSG_DEBUG( "TrigGlobalEfficiencyCorrectionTool/TrigGlobal_multiLep: no2e17 trigger string: " << no2e17 );
2176 
2177  std::map<std::string,std::string> triggers_multiLep;
2178  triggers_multiLep["2015"] = m_trig2015combination_multiLep;
2179  triggers_multiLep["2016"] = m_trig2016combination_multiLep;
2180  triggers_multiLep["324320-326695"] = m_trig2017combination_multiLep; // 2017 before accidental prescale of L12EM15VHI
2181  triggers_multiLep["326834-328393"] = no2e17; // 2017 during accidental prescale
2182  triggers_multiLep["329385-340453"] = m_trig2017combination_multiLep; // 2017 after accidental prescale
2183  triggers_multiLep["2018"] = m_trig2018combination_multiLep;
2184 
2185  m_trigGlobalEffCorrTool_multiLep.setTypeAndName("TrigGlobalEfficiencyCorrectionTool/TrigGlobal_multiLep");
2186  ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("ElectronEfficiencyTools", m_elecTrigEffTools) );
2187  ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("ElectronScaleFactorTools", m_elecTrigSFTools) );
2188  ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("MuonTools", m_muonTrigSFTools) );
2189  ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("TriggerCombination", triggers_multiLep) );
2190  ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("TriggerMatchingTool", m_trigMatchingTool.getHandle()) );
2191  ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("ListOfLegsPerTool", m_legsPerTool) );
2192  ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("NumberOfToys", m_trigNToys_multiLep) );
2193  ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("OutputLevel", this->msg().level()) );
2194  ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.initialize() );
2195  } else if (m_trigGlobalEffCorrTool_multiLep.isUserConfigured()) ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.retrieve() );
2196 
2197 
2198  if (!m_trigGlobalEffCorrTool_diPhoton.isUserConfigured() && !isData()) {
2199  m_trigGlobalEffCorrTool_diPhoton.setTypeAndName("TrigGlobalEfficiencyCorrectionTool/TrigGlobal_diPhoton");
2200  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("PhotonEfficiencyTools", m_photonTrigEffTools) );
2201  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("PhotonScaleFactorTools", m_photonTrigSFTools) );
2202  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("TriggerCombination2015", m_trig2015combination_diPhoton) );
2203  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("TriggerCombination2016", m_trig2016combination_diPhoton) );
2204  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("TriggerCombination2017", m_trig2017combination_diPhoton) );
2205  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("TriggerCombination2018", m_trig2018combination_diPhoton) );
2206  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("ListOfLegsPerTool", m_legsPerTool_ph) );
2207  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("NumberOfToys", m_trigNToys_diPhoton) );
2208  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("OutputLevel", this->msg().level()) );
2209  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.initialize() );
2210  } else if (m_trigGlobalEffCorrTool_diPhoton.isUserConfigured()) ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.retrieve() );
2211 
2212 
2213  if (m_slices["ele"] || m_slices["pho"] || m_slices["mu"]) {
2214  // /////////////////////////////////////////////////////////////////////////////////////////
2215  // Initialise Isolation Correction Tool
2216 
2217  if ( !m_isoCorrTool.isUserConfigured() ) {
2218  m_isoCorrTool.setTypeAndName("CP::IsolationCorrectionTool/IsoCorrTool");
2219  ATH_CHECK( m_isoCorrTool.setProperty( "ToolVer", "REL22") );
2220  ATH_CHECK( m_isoCorrTool.setProperty( "IsMC", !isData()) );
2221  ATH_CHECK( m_isoCorrTool.setProperty( "AFII_corr", isAtlfast()) );
2222  ATH_CHECK( m_isoCorrTool.setProperty( "Apply_SC_leakcorr", false) );
2223  ATH_CHECK( m_isoCorrTool.setProperty( "CorrFile", "IsolationCorrections/v6/isolation_ptcorrections_rel22_mc20.root") );
2224  ATH_CHECK( m_isoCorrTool.setProperty( "OutputLevel", this->msg().level()) );
2225  ATH_CHECK( m_isoCorrTool.retrieve() );
2226  } else ATH_CHECK( m_isoCorrTool.retrieve() );
2227 
2228 
2229  // /////////////////////////////////////////////////////////////////////////////////////////
2230  // Initialise Isolation Tool
2231  if (!m_isoTool.isUserConfigured()) {
2232  m_isoTool.setTypeAndName("CP::IsolationSelectionTool/IsoTool");
2233  ATH_CHECK( m_isoTool.setProperty("ElectronWP", m_eleIso_WP.empty() ? "Loose_VarRad" : m_eleIso_WP) );
2234  ATH_CHECK( m_isoTool.setProperty("MuonWP", m_muIso_WP.empty() ? "Loose_VarRad" : m_muIso_WP) );
2235  ATH_CHECK( m_isoTool.setProperty("PhotonWP", m_photonIso_WP.empty() ? "FixedCutTight" : m_photonIso_WP ) );
2236  ATH_CHECK( m_isoTool.setProperty("OutputLevel", this->msg().level()) );
2237  ATH_CHECK( m_isoTool.retrieve() );
2238  } else ATH_CHECK( m_isoTool.retrieve() );
2239 
2240  //disable if (!m_isoToolLowPtPLV.isUserConfigured()) {
2241  //disable m_isoToolLowPtPLV.setTypeAndName("CP::IsolationLowPtPLVTool/IsoToolLowPtPLV");
2242  //disable ATH_CHECK( m_isoToolLowPtPLV.setProperty("OutputLevel", this->msg().level()) );
2243  //disable ATH_CHECK( m_isoToolLowPtPLV.retrieve() );
2244  //disable } else ATH_CHECK( m_isoToolLowPtPLV.retrieve() );
2245 
2246 
2247  if (!m_isoBaselineTool.isUserConfigured()) {
2248  m_isoBaselineTool.setTypeAndName("CP::IsolationSelectionTool/IsoBaselineTool");
2249  ATH_CHECK( m_isoBaselineTool.setProperty("ElectronWP", m_eleBaselineIso_WP.empty() ? "Loose_VarRad" : m_eleBaselineIso_WP ) );
2250  ATH_CHECK( m_isoBaselineTool.setProperty("MuonWP", m_muBaselineIso_WP.empty() ? "Loose_VarRad" : m_muBaselineIso_WP ) );
2251  ATH_CHECK( m_isoBaselineTool.setProperty("PhotonWP", m_photonBaselineIso_WP.empty() ? "FixedCutTight" : m_photonBaselineIso_WP ) );
2252  ATH_CHECK( m_isoBaselineTool.setProperty("OutputLevel", this->msg().level()) );
2253  ATH_CHECK( m_isoBaselineTool.retrieve() );
2254  } else ATH_CHECK( m_isoBaselineTool.retrieve() );
2255 
2256 
2257  if (!m_isoHighPtTool.isUserConfigured()) {
2258  m_isoHighPtTool.setTypeAndName("CP::IsolationSelectionTool/IsoHighPtTool");
2259  ATH_CHECK( m_isoHighPtTool.setProperty("ElectronWP", m_eleIsoHighPt_WP.empty() ? "Loose_VarRad" : m_eleIsoHighPt_WP) );
2260  ATH_CHECK( m_isoHighPtTool.setProperty("MuonWP", m_muIsoHighPt_WP.empty() ? "Loose_VarRad" : m_muIsoHighPt_WP ) );
2261  ATH_CHECK( m_isoHighPtTool.setProperty("PhotonWP", m_photonIso_WP.empty() ? "FixedCutTight" : m_photonIso_WP ) );
2262  ATH_CHECK( m_isoHighPtTool.setProperty("OutputLevel", this->msg().level()) );
2263  ATH_CHECK( m_isoHighPtTool.retrieve() );
2264  } else ATH_CHECK( m_isoHighPtTool.retrieve() );
2265 
2266 
2267  // /////////////////////////////////////////////////////////////////////////////////////////
2268  // Initialise IsolationCloseByCorrectionTool Tool
2269  if (!m_isoCloseByTool.isUserConfigured()) {
2270  m_isoCloseByTool.setTypeAndName("CP::IsolationCloseByCorrectionTool/IsoCloseByTool");
2271  // Actually we could debate about what is the proper tool to choose if the users have different baseline & signal islation WP's
2272  ATH_CHECK( m_isoCloseByTool.setProperty("IsolationSelectionTool", m_useSigLepForIsoCloseByOR ? m_isoTool : m_isoBaselineTool));
2273  ATH_CHECK( m_isoCloseByTool.setProperty("PassoverlapDecorator", m_IsoCloseByORpassLabel) );
2274  ATH_CHECK( m_isoCloseByTool.setProperty("SelectionDecorator", m_useSigLepForIsoCloseByOR ? "signal" : "baseline") );
2275  // Make this propery configurable as well?
2276  ATH_CHECK( m_isoCloseByTool.setProperty("BackupPrefix", "ORIG") );
2277  // The isolation selection decorator is updated as well by the tool
2278  ATH_CHECK( m_isoCloseByTool.setProperty("IsolationSelectionDecorator", "isol") );
2279 
2280  ATH_CHECK( m_isoCloseByTool.setProperty("OutputLevel", this->msg().level()) );
2281 #ifndef XAOD_ANALYSIS
2282  ATH_CHECK( m_isoCloseByTool.setProperty("ParticleCaloExtensionTool", "") );
2283 #endif
2284  ATH_CHECK( m_isoCloseByTool.retrieve() );
2285  } else ATH_CHECK( m_isoCloseByTool.retrieve() );
2286  }
2287 
2288 
2289 // /////////////////////////////////////////////////////////////////////////////////////////
2290 // Initialise Overlap Removal Tool
2291  if ( m_orToolbox.masterTool.empty() ){
2292 
2293  // set up the master tool
2294  std::string suffix = "";
2295  if (m_orDoTau) suffix += "Tau";
2296  if (m_orDoPhoton) suffix += "Gamma";
2297  if (m_orDoBjet) suffix += "Bjet";
2298  std::string toolName = "ORTool" + suffix;
2299  ATH_MSG_INFO("SUSYTools: Autoconfiguring " << toolName);
2300 
2301  std::string bJetLabel = "";
2302  //overwrite lepton flags if the global is false (yes?)
2303  if (!m_orDoBjet || !m_useBtagging) {
2304  m_orDoElBjet = false;
2305  m_orDoMuBjet = false;
2306  m_orDoTauBjet = false;
2307  }
2308  if (m_orDoElBjet || m_orDoMuBjet || m_orDoTauBjet) {
2309  bJetLabel = "bjet_loose";
2310  }
2311 
2312  // Set the generic flags
2313  ORUtils::ORFlags orFlags(toolName, m_orInputLabel, "passOR");
2314  orFlags.bJetLabel = bJetLabel;
2315  orFlags.boostedLeptons = (m_orDoBoostedElectron || m_orDoBoostedMuon);
2316  orFlags.outputPassValue = true;
2317  orFlags.linkOverlapObjects = m_orLinkOverlapObjects;
2318  if (m_orDoElEl) {
2319  orFlags.doEleEleOR = true;
2320  } else orFlags.doEleEleOR = false;
2321  orFlags.doElectrons = true;
2322  orFlags.doMuons = true;
2323  orFlags.doJets = true;
2324  orFlags.doTaus = m_orDoTau;
2325  orFlags.doPhotons = m_orDoPhoton;
2326  orFlags.doFatJets = m_orDoFatjets;
2327 
2328  //set up all recommended tools
2329  ATH_CHECK( ORUtils::recommendedTools(orFlags, m_orToolbox));
2330 
2331  // We don't currently have a good way to determine here which object
2332  // definitions are disabled, so we currently just configure all overlap
2333  // tools and disable the pointer safety checks
2334  ATH_CHECK( m_orToolbox.setGlobalProperty("OutputLevel", this->msg().level()) );
2335  ATH_CHECK( m_orToolbox.masterTool.setProperty("RequireExpectedPointers", false) );
2336 
2337  // Override boosted OR sliding cone options
2338  ATH_CHECK( m_orToolbox.eleJetORT.setProperty("UseSlidingDR", m_orDoBoostedElectron) );
2339  ATH_CHECK( m_orToolbox.muJetORT.setProperty("UseSlidingDR", m_orDoBoostedMuon) );
2340 
2341  //add custom tau-jet OR tool
2342  if(m_orDoTau){
2343  m_orToolbox.tauJetORT.setTypeAndName("ORUtils::TauJetOverlapTool/" + orFlags.masterName + ".TauJetORT");
2344  ATH_CHECK( m_orToolbox.tauJetORT.setProperty("BJetLabel", m_orDoTauBjet?bJetLabel:"") );
2345  }
2346 
2347  // override sliding cone params if sliding dR is on and the user-provided parameter values are non-negative
2348  if (m_orDoBoostedElectron) {
2349  if (m_orBoostedElectronC1 > 0) ATH_CHECK( m_orToolbox.eleJetORT.setProperty("SlidingDRC1", m_orBoostedElectronC1) );
2350  if (m_orBoostedElectronC2 > 0) ATH_CHECK( m_orToolbox.eleJetORT.setProperty("SlidingDRC2", m_orBoostedElectronC2) );
2351  if (m_orBoostedElectronMaxConeSize > 0) ATH_CHECK( m_orToolbox.eleJetORT.setProperty("SlidingDRMaxCone", m_orBoostedElectronMaxConeSize) );
2352  }
2353  if (m_orDoBoostedMuon) {
2354  if (m_orBoostedMuonC1 > 0) ATH_CHECK( m_orToolbox.muJetORT.setProperty("SlidingDRC1", m_orBoostedMuonC1) );
2355  if (m_orBoostedMuonC2 > 0) ATH_CHECK( m_orToolbox.muJetORT.setProperty("SlidingDRC2", m_orBoostedMuonC2) );
2356  if (m_orBoostedMuonMaxConeSize > 0) ATH_CHECK( m_orToolbox.muJetORT.setProperty("SlidingDRMaxCone", m_orBoostedMuonMaxConeSize) );
2357  }
2358 
2359  // and switch off lep-bjet check if not requested
2360  if (!m_orDoElBjet) {
2361  ATH_CHECK(m_orToolbox.eleJetORT.setProperty("BJetLabel", ""));
2362  }
2363  if (!m_orDoMuBjet) {
2364  ATH_CHECK(m_orToolbox.muJetORT.setProperty("BJetLabel", ""));
2365  }
2366 
2367  // propagate the mu-jet ghost-association option which might be set by the user (default is true)
2368  ATH_CHECK(m_orToolbox.muJetORT.setProperty("UseGhostAssociation", m_orDoMuonJetGhostAssociation));
2369 
2370  // propagate mu-jet OR settings if requested
2371  ATH_CHECK(m_orToolbox.muJetORT.setProperty("ApplyRelPt", m_orApplyRelPt) );
2372  if(m_orApplyRelPt){
2373  if (m_orMuJetPtRatio > 0) ATH_CHECK(m_orToolbox.muJetORT.setProperty("MuJetPtRatio", m_orMuJetPtRatio) );
2374  if (m_orMuJetTrkPtRatio > 0) ATH_CHECK(m_orToolbox.muJetORT.setProperty("MuJetTrkPtRatio", m_orMuJetTrkPtRatio) );
2375  }
2376  if (m_orMuJetInnerDR > 0) ATH_CHECK(m_orToolbox.muJetORT.setProperty("InnerDR", m_orMuJetInnerDR) );
2377 
2378  // propagate the calo muon setting for EleMuORT
2379  ATH_CHECK(m_orToolbox.eleMuORT.setProperty("RemoveCaloMuons", m_orRemoveCaloMuons) );
2380 
2381  // Use electron-muon DR matching to remove electrons within DR < 0.01 of Muons.
2382  if (m_orDoElMu){
2383  ATH_CHECK(m_orToolbox.eleMuORT.setProperty("UseDRMatching", m_orDoElMu) );
2384  }
2385 
2386  // propagate the fatjets OR settings
2387  if(m_orDoFatjets){
2388  if(m_EleFatJetDR>0) ATH_CHECK(m_orToolbox.eleFatJetORT.setProperty("DR", m_EleFatJetDR));
2389  if(m_JetFatJetDR>0) ATH_CHECK(m_orToolbox.jetFatJetORT.setProperty("DR", m_JetFatJetDR));
2390  }
2391 
2392  // Make sure that we deal with prorities correctly
2393  ATH_CHECK(m_orToolbox.eleJetORT.setProperty("EnableUserPriority", true));
2394  ATH_CHECK(m_orToolbox.muJetORT.setProperty("EnableUserPriority", true));
2395  if (m_orDoTau) ATH_CHECK(m_orToolbox.tauJetORT.setProperty("EnableUserPriority", true));
2396  if (m_orDoPhoton) ATH_CHECK(m_orToolbox.phoJetORT.setProperty("EnableUserPriority", true));
2397 
2398  if ( m_orPhotonFavoured ) {
2399  ATH_CHECK(m_orToolbox.phoEleORT.setProperty("SwapContainerPrecedence", true));
2400  ATH_CHECK(m_orToolbox.phoMuORT.setProperty("SwapContainerPrecedence", true));
2401  }
2402 
2403  if (!m_orDoEleJet){
2404  // Disable the electron removal part of e-j overlap removal
2405  ATH_CHECK( m_orToolbox.eleJetORT.setProperty("OuterDR",-1.) );
2406  ATH_CHECK( m_orToolbox.eleJetORT.setProperty("SlidingDRMaxCone",-1.) );
2407  }
2408  if (!m_orDoMuonJet){
2409  // Disable the muon removal part of m-j overlap removal
2410  ATH_CHECK( m_orToolbox.muJetORT.setProperty("OuterDR",-1.) );
2411  ATH_CHECK( m_orToolbox.muJetORT.setProperty("SlidingDRMaxCone",-1.) );
2412  }
2413 
2414  ATH_CHECK( m_orToolbox.initialize() );
2415 
2416  }
2417  // Done with the OR toolbox setup!
2418 
2419 // /////////////////////////////////////////////////////////////////////////////////////////
2420 // Initialise PMG Tools
2421  if (!m_pmgSHnjetWeighter.isUserConfigured() && !isData()) {
2422  m_pmgSHnjetWeighter.setTypeAndName("PMGTools::PMGSherpa22VJetsWeightTool/PMGSHVjetReweighter");
2423  ATH_CHECK( m_pmgSHnjetWeighter.setProperty( "TruthJetContainer", "AntiKt4TruthJets"));
2424  ATH_CHECK( m_pmgSHnjetWeighter.setProperty("OutputLevel", this->msg().level()) );
2425  ATH_CHECK( m_pmgSHnjetWeighter.retrieve());
2426  } else if (m_pmgSHnjetWeighter.isUserConfigured()) ATH_CHECK( m_pmgSHnjetWeighter.retrieve());
2427 
2428 
2429  if (!m_pmgSHnjetWeighterWZ.isUserConfigured() && !isData()) {
2430  m_pmgSHnjetWeighterWZ.setTypeAndName("PMGTools::PMGSherpa22VJetsWeightTool/PMGSHVjetReweighterWZ");
2431  ATH_CHECK( m_pmgSHnjetWeighterWZ.setProperty( "TruthJetContainer", "AntiKt4TruthWZJets"));
2432  ATH_CHECK( m_pmgSHnjetWeighterWZ.setProperty("OutputLevel", this->msg().level()) );
2433  ATH_CHECK( m_pmgSHnjetWeighterWZ.retrieve() );
2434  } else if (m_pmgSHnjetWeighterWZ.isUserConfigured()) ATH_CHECK( m_pmgSHnjetWeighterWZ.retrieve() );
2435 
2436 
2437  // prevent these initialiation snippets from being run again
2438  m_subtool_init = true;
2439 
2440  ATH_MSG_INFO("Done initialising SUSYTools");
2441 
2442  return StatusCode::SUCCESS;
2443 }
ST::SUSYObjDef_xAOD::m_WDecorName
std::string m_WDecorName
Definition: SUSYObjDef_xAOD.h:549
ST::SUSYObjDef_xAOD::m_applyJVTCut
bool m_applyJVTCut
Definition: SUSYObjDef_xAOD.h:821
ST::SUSYObjDef_xAOD::m_orBoostedMuonC1
double m_orBoostedMuonC1
Definition: SUSYObjDef_xAOD.h:773
ST::SUSYObjDef_xAOD::m_muonEfficiencySFTool
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonEfficiencySFTool
Definition: SUSYObjDef_xAOD.h:871
asg::AnaToolHandle::initialize
StatusCode initialize()
initialize the tool
ST::SUSYObjDef_xAOD::m_badJetCut
std::string m_badJetCut
Definition: SUSYObjDef_xAOD.h:540
bJetLabel
const std::string bJetLabel
Definition: OverlapRemovalTester.cxx:70
ST::SUSYObjDef_xAOD::m_isoHighPtTool
asg::AnaToolHandle< CP::IIsolationSelectionTool > m_isoHighPtTool
Definition: SUSYObjDef_xAOD.h:973
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:769
ST::SUSYObjDef_xAOD::m_orBoostedMuonC2
double m_orBoostedMuonC2
Definition: SUSYObjDef_xAOD.h:774
LikeEnum::Loose
@ Loose
Definition: LikelihoodEnums.h:12
TrigJetMonitorAlgorithm.jetcoll
jetcoll
Definition: TrigJetMonitorAlgorithm.py:1245
temp
Definition: JetEventDict.h:21
ST::SUSYObjDef_xAOD::m_deadHVTool
asg::AnaToolHandle< IAsgDeadHVCellRemovalTool > m_deadHVTool
Definition: SUSYObjDef_xAOD.h:902
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:590
ST::SUSYObjDef_xAOD::m_jetfJvtEfficiencyTool
asg::AnaToolHandle< CP::IJvtEfficiencyTool > m_jetfJvtEfficiencyTool
Definition: SUSYObjDef_xAOD.h:843
ST::SUSYObjDef_xAOD::m_tauSelTool
asg::AnaToolHandle< TauAnalysisTools::ITauSelectionTool > m_tauSelTool
Definition: SUSYObjDef_xAOD.h:916
ST::SUSYObjDef_xAOD::m_ZconfigReader
TEnv m_ZconfigReader
Definition: SUSYObjDef_xAOD.h:547
ST::SUSYObjDef_xAOD::m_doTTVAsf
bool m_doTTVAsf
Definition: SUSYObjDef_xAOD.h:522
ST::SUSYObjDef_xAOD::m_fJvtWP
std::string m_fJvtWP
Definition: SUSYObjDef_xAOD.h:749
ST::SUSYObjDef_xAOD::m_metDoSetMuonJetEMScale
bool m_metDoSetMuonJetEMScale
Definition: SUSYObjDef_xAOD.h:576
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
ST::SUSYObjDef_xAOD::m_muBaselineEta
double m_muBaselineEta
Definition: SUSYObjDef_xAOD.h:703
ST::SUSYObjDef_xAOD::m_trigGlobalEffCorrTool_multiLep
asg::AnaToolHandle< ITrigGlobalEfficiencyCorrectionTool > m_trigGlobalEffCorrTool_multiLep
Definition: SUSYObjDef_xAOD.h:953
Enums.h
ST::SUSYObjDef_xAOD::m_trigNToys_diLep
int m_trigNToys_diLep
Definition: SUSYObjDef_xAOD.h:939
ST::SUSYObjDef_xAOD::m_jetUncertaintiesCalibArea
std::string m_jetUncertaintiesCalibArea
Definition: SUSYObjDef_xAOD.h:529
ST::SUSYObjDef_xAOD::m_jesConfigAFII
std::string m_jesConfigAFII
Definition: SUSYObjDef_xAOD.h:859
ST::SUSYObjDef_xAOD::m_BtagSystStrategy
std::string m_BtagSystStrategy
Definition: SUSYObjDef_xAOD.h:677
ST::SUSYObjDef_xAOD::m_tauEffToolRecommendationTag
std::string m_tauEffToolRecommendationTag
Definition: SUSYObjDef_xAOD.h:732
ST::SUSYObjDef_xAOD::m_tauIdBaseline
std::string m_tauIdBaseline
Definition: SUSYObjDef_xAOD.h:652
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:808
ST::SUSYObjDef_xAOD::m_photonTrigEffTools
ToolHandleArray< IAsgPhotonEfficiencyCorrectionTool > m_photonTrigEffTools
Definition: SUSYObjDef_xAOD.h:910
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:654
ST::SUSYObjDef_xAOD::m_BtagWP
std::string m_BtagWP
Definition: SUSYObjDef_xAOD.h:673
ST::SUSYObjDef_xAOD::m_eleAllowRun3TrigSFFallback
bool m_eleAllowRun3TrigSFFallback
Definition: SUSYObjDef_xAOD.h:698
ST::SUSYObjDef_xAOD::m_egammaCalibTool
asg::AnaToolHandle< CP::IEgammaCalibrationAndSmearingTool > m_egammaCalibTool
Combined electron collection.
Definition: SUSYObjDef_xAOD.h:897
ST::SUSYObjDef_xAOD::m_trig2016combination_diPhoton
std::string m_trig2016combination_diPhoton
Definition: SUSYObjDef_xAOD.h:957
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:1805
ST::SUSYObjDef_xAOD::m_metDoRemoveMuonJets
bool m_metDoRemoveMuonJets
Definition: SUSYObjDef_xAOD.h:577
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
ST::SUSYObjDef_xAOD::m_label_truthKey
SG::ReadDecorHandleKey< xAOD::JetContainer > m_label_truthKey
Definition: SUSYObjDef_xAOD.h:853
ST::SUSYObjDef_xAOD::m_orMuJetInnerDR
double m_orMuJetInnerDR
Definition: SUSYObjDef_xAOD.h:779
ST::SUSYObjDef_xAOD::m_muonEfficiencyBMHighPtSFTool
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonEfficiencyBMHighPtSFTool
Definition: SUSYObjDef_xAOD.h:872
ST::SUSYObjDef_xAOD::m_pmgSHnjetWeighterWZ
asg::AnaToolHandle< IWeightTool > m_pmgSHnjetWeighterWZ
Definition: SUSYObjDef_xAOD.h:984
IAsgPhotonIsEMSelector.h
ST::SUSYObjDef_xAOD::m_legsPerTool
std::map< std::string, std::string > m_legsPerTool
Definition: SUSYObjDef_xAOD.h:825
ST::SUSYObjDef_xAOD::m_orDoElBjet
bool m_orDoElBjet
Definition: SUSYObjDef_xAOD.h:765
ST::SUSYObjDef_xAOD::m_tauSmearingToolGenerator
std::string m_tauSmearingToolGenerator
Definition: SUSYObjDef_xAOD.h:733
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:961
asg::AnaToolHandle::retrieve
StatusCode retrieve()
initialize the tool
ST::SUSYObjDef_xAOD::m_fatJetUncertaintiesPDsmearing
bool m_fatJetUncertaintiesPDsmearing
Definition: SUSYObjDef_xAOD.h:543
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_reco
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_reco
Combined muon collection.
Definition: SUSYObjDef_xAOD.h:881
IAsgElectronEfficiencyCorrectionTool.h
ITrigConfigTool.h
ST::SUSYObjDef_xAOD::m_elecSelLikelihood
asg::AnaToolHandle< IAsgElectronLikelihoodTool > m_elecSelLikelihood
Definition: SUSYObjDef_xAOD.h:898
ITrigGlobalEfficiencyCorrectionTool.h
ST::SUSYObjDef_xAOD::m_orMuJetPtRatio
double m_orMuJetPtRatio
Definition: SUSYObjDef_xAOD.h:777
IIsolationCloseByCorrectionTool.h
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_trig_mixLep
std::vector< asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > > m_elecEfficiencySFTool_trig_mixLep
Definition: SUSYObjDef_xAOD.h:889
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:839
ST::SUSYObjDef_xAOD::m_muTriggerSFCalibRelease
std::string m_muTriggerSFCalibRelease
Definition: SUSYObjDef_xAOD.h:671
ST::SUSYObjDef_xAOD::m_EigenvectorReductionC
std::string m_EigenvectorReductionC
Definition: SUSYObjDef_xAOD.h:679
ST::SUSYObjDef_xAOD::m_fJvtConfigRun2
std::string m_fJvtConfigRun2
Definition: SUSYObjDef_xAOD.h:752
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:905
ST::SUSYObjDef_xAOD::m_isoBaselineTool
asg::AnaToolHandle< CP::IIsolationSelectionTool > m_isoBaselineTool
Definition: SUSYObjDef_xAOD.h:972
ST::SUSYObjDef_xAOD::m_elecTrigEffTools
ToolHandleArray< IAsgElectronEfficiencyCorrectionTool > m_elecTrigEffTools
Definition: SUSYObjDef_xAOD.h:892
ST::SUSYObjDef_xAOD::m_JvtConfigRun2
std::string m_JvtConfigRun2
Definition: SUSYObjDef_xAOD.h:742
ST::SUSYObjDef_xAOD::m_tauSmearingTool
asg::AnaToolHandle< TauAnalysisTools::ITauSmearingTool > m_tauSmearingTool
Definition: SUSYObjDef_xAOD.h:918
ST::SUSYObjDef_xAOD::m_jetInputType
int m_jetInputType
Definition: SUSYObjDef_xAOD.h:516
ST::SUSYObjDef_xAOD::m_el_iso_support
std::vector< std::string > m_el_iso_support
Definition: SUSYObjDef_xAOD.h:629
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:575
ST::SUSYObjDef_xAOD::m_metMaker
asg::AnaToolHandle< IMETMaker > m_metMaker
Definition: SUSYObjDef_xAOD.h:929
ST::SUSYObjDef_xAOD::m_trig2018combination_diPhoton
std::string m_trig2018combination_diPhoton
Definition: SUSYObjDef_xAOD.h:959
ST::SUSYObjDef_xAOD::m_trigNToys_diPhoton
int m_trigNToys_diPhoton
Definition: SUSYObjDef_xAOD.h:955
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:847
ST::SUSYObjDef_xAOD::m_orBtagWP
std::string m_orBtagWP
Definition: SUSYObjDef_xAOD.h:782
TauAnalysisTools::JETIDRNNLOOSE
@ JETIDRNNLOOSE
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:20
ST::SUSYObjDef_xAOD::m_muId
int m_muId
Definition: SUSYObjDef_xAOD.h:647
ST::SUSYObjDef_xAOD::m_photonIso_WP
std::string m_photonIso_WP
Definition: SUSYObjDef_xAOD.h:663
ST::SUSYObjDef_xAOD::m_muonTTVAEfficiencySFTool
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonTTVAEfficiencySFTool
Definition: SUSYObjDef_xAOD.h:873
ST::SUSYObjDef_xAOD::m_el_iso_fallback
std::map< std::string, std::string > m_el_iso_fallback
Definition: SUSYObjDef_xAOD.h:633
SUSYObjDef_xAOD.h
ORUtils::ORFlags::doElectrons
bool doElectrons
Definition: OverlapRemovalInit.h:59
ST::SUSYObjDef_xAOD::m_BtagMinPt
double m_BtagMinPt
Definition: SUSYObjDef_xAOD.h:675
IMETMaker.h
TrigDecisionTool.h
ST::SUSYObjDef_xAOD::m_fatjetFFSmearingSyst
std::vector< CP::SystematicSet > m_fatjetFFSmearingSyst
Definition: SUSYObjDef_xAOD.h:817
ST::SUSYObjDef_xAOD::m_trkJetsyst
bool m_trkJetsyst
Definition: SUSYObjDef_xAOD.h:586
ST::SUSYObjDef_xAOD::m_orDoTau
bool m_orDoTau
Overlap removal options.
Definition: SUSYObjDef_xAOD.h:758
ST::SUSYObjDef_xAOD::m_prwTool
asg::AnaToolHandle< CP::IPileupReweightingTool > m_prwTool
Definition: SUSYObjDef_xAOD.h:976
ST::SUSYObjDef_xAOD::m_muBaselineIso_WP
std::string m_muBaselineIso_WP
Definition: SUSYObjDef_xAOD.h:665
ST::SUSYObjDef_xAOD::m_trig2016combination_multiLep
std::string m_trig2016combination_multiLep
Definition: SUSYObjDef_xAOD.h:949
ST::SUSYObjDef_xAOD::m_WTaggerTool
asg::AnaToolHandle< SmoothedWZTagger > m_WTaggerTool
Definition: SUSYObjDef_xAOD.h:845
ITauSelectionTool.h
ST::SUSYObjDef_xAOD::m_eleConfigBaseline
std::string m_eleConfigBaseline
Definition: SUSYObjDef_xAOD.h:644
IMETSignificance.h
ST::SUSYObjDef_xAOD::m_bTaggingCalibrationFilePath
std::string m_bTaggingCalibrationFilePath
Definition: SUSYObjDef_xAOD.h:823
IAsgPhotonEfficiencyCorrectionTool.h
ORUtils::ToolBox::eleFatJetORT
OverlapHandle_t eleFatJetORT
Definition: ToolBox.h:79
IMETSystematicsTool.h
ST::SUSYObjDef_xAOD::m_metDoMuonEloss
bool m_metDoMuonEloss
Definition: SUSYObjDef_xAOD.h:579
ST::SUSYObjDef_xAOD::m_photonTrigSFTools
ToolHandleArray< IAsgPhotonEfficiencyCorrectionTool > m_photonTrigSFTools
Definition: SUSYObjDef_xAOD.h:909
ST::SUSYObjDef_xAOD::m_orDoFatjets
bool m_orDoFatjets
Definition: SUSYObjDef_xAOD.h:788
ST::SUSYObjDef_xAOD::m_trigMatchingTool
asg::AnaToolHandle< Trig::IMatchingTool > m_trigMatchingTool
Definition: SUSYObjDef_xAOD.h:965
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:831
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:893
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:958
IJetModifier.h
IJetDecorator.h
ST::SUSYObjDef_xAOD::m_mu_iso_support
std::vector< std::string > m_mu_iso_support
Definition: SUSYObjDef_xAOD.h:630
PATCore::ParticleDataType::Data
@ Data
Definition: PATCoreEnums.h:22
ITauEfficiencyCorrectionsTool.h
ST::SUSYObjDef_xAOD::m_fatJetUncVars
std::string m_fatJetUncVars
Definition: SUSYObjDef_xAOD.h:544
ST::SUSYObjDef_xAOD::m_orDoBjet
bool m_orDoBjet
Definition: SUSYObjDef_xAOD.h:764
ST::SUSYObjDef_xAOD::m_eleEffMapFilePath
std::string m_eleEffMapFilePath
Definition: SUSYObjDef_xAOD.h:696
ST::SUSYObjDef_xAOD::m_orDoPhoton
bool m_orDoPhoton
Definition: SUSYObjDef_xAOD.h:759
ST::SUSYObjDef_xAOD::m_jetJvtMomentTool
asg::AnaToolHandle< JetVertexTaggerTool > m_jetJvtMomentTool
Definition: SUSYObjDef_xAOD.h:838
ST::SUSYObjDef_xAOD::m_eleIdBaseline
std::string m_eleIdBaseline
Definition: SUSYObjDef_xAOD.h:642
IJetCalibrationTool.h
PATCore::ParticleDataType::DataType
DataType
Definition: PATCoreEnums.h:22
ST::SUSYObjDef_xAOD::m_orToolbox
ORUtils::ToolBox m_orToolbox
Definition: SUSYObjDef_xAOD.h:981
ST::SUSYObjDef_xAOD::m_tauConfigPath
std::string m_tauConfigPath
Definition: SUSYObjDef_xAOD.h:728
TauAnalysisTools::ELEIDRNNLOOSE
@ ELEIDRNNLOOSE
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:33
ST::SUSYObjDef_xAOD::m_muonLRTORTool
asg::AnaToolHandle< CP::IMuonLRTOverlapRemovalTool > m_muonLRTORTool
Definition: SUSYObjDef_xAOD.h:878
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:741
IEGammaAmbiguityTool.h
ST::SUSYObjDef_xAOD::m_btagEffTool_trkJet
asg::AnaToolHandle< IBTaggingEfficiencyTool > m_btagEffTool_trkJet
Definition: SUSYObjDef_xAOD.h:926
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:802
ST::SUSYObjDef_xAOD::m_orLinkOverlapObjects
bool m_orLinkOverlapObjects
Definition: SUSYObjDef_xAOD.h:786
IMuonSelectionTool.h
PATCore::ParticleDataType::Full
@ Full
Definition: PATCoreEnums.h:22
ST::SUSYObjDef_xAOD::m_eleEffMapFilePathRun2
std::string m_eleEffMapFilePathRun2
Definition: SUSYObjDef_xAOD.h:697
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_isoHighPt
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_isoHighPt
Definition: SUSYObjDef_xAOD.h:886
ST::SUSYObjDef_xAOD::m_orBoostedMuonMaxConeSize
double m_orBoostedMuonMaxConeSize
Definition: SUSYObjDef_xAOD.h:775
ST::SUSYObjDef_xAOD::m_photonEfficiencySFTool
asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > m_photonEfficiencySFTool
Definition: SUSYObjDef_xAOD.h:903
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:639
ST::SUSYObjDef_xAOD::m_trigGlobalEffCorrTool_diLep
asg::AnaToolHandle< ITrigGlobalEfficiencyCorrectionTool > m_trigGlobalEffCorrTool_diLep
Definition: SUSYObjDef_xAOD.h:945
ST::SUSYObjDef_xAOD::m_WZTaggerCalibArea
std::string m_WZTaggerCalibArea
Definition: SUSYObjDef_xAOD.h:555
IMuonEfficiencyScaleFactors.h
ST::SUSYObjDef_xAOD::m_prwLcalcFiles
std::vector< std::string > m_prwLcalcFiles
Definition: SUSYObjDef_xAOD.h:612
ST::SUSYObjDef_xAOD::m_prwDataSF_DW
double m_prwDataSF_DW
Definition: SUSYObjDef_xAOD.h:621
IBTaggingEfficiencyTool.h
ST::SUSYObjDef_xAOD::m_orDoBoostedMuon
bool m_orDoBoostedMuon
Definition: SUSYObjDef_xAOD.h:772
IEgammaCalibrationAndSmearingTool.h
ST::SUSYObjDef_xAOD::m_el_id_support
std::vector< std::string > m_el_id_support
Definition: SUSYObjDef_xAOD.h:625
ITauTruthMatchingTool.h
ST::SUSYObjDef_xAOD::m_defaultJets
std::string m_defaultJets
Definition: SUSYObjDef_xAOD.h:810
ST::SUSYObjDef_xAOD::m_useBtagging
bool m_useBtagging
Definition: SUSYObjDef_xAOD.h:534
ST::SUSYObjDef_xAOD::m_ph_id_support
std::vector< std::string > m_ph_id_support
Definition: SUSYObjDef_xAOD.h:626
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:890
IMatchScoringTool.h
ST::SUSYObjDef_xAOD::m_TopTaggerCalibArea
std::string m_TopTaggerCalibArea
Definition: SUSYObjDef_xAOD.h:556
IBTaggingSelectionTool.h
IIsolationCorrectionTool.h
ST::SUSYObjDef_xAOD::m_fatJetUncConfig
std::string m_fatJetUncConfig
Definition: SUSYObjDef_xAOD.h:542
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:882
IPileupReweightingTool.h
ST::SUSYObjDef_xAOD::m_tauConfigReader
TEnv m_tauConfigReader
Definition: SUSYObjDef_xAOD.h:735
ST::SUSYObjDef_xAOD::m_IsoCloseByORpassLabel
std::string m_IsoCloseByORpassLabel
Definition: SUSYObjDef_xAOD.h:798
ST::SUSYObjDef_xAOD::m_tauSmearingToolRecommendationTag
std::string m_tauSmearingToolRecommendationTag
Definition: SUSYObjDef_xAOD.h:731
ST::SUSYObjDef_xAOD::m_jetUncertaintiesConfig
std::string m_jetUncertaintiesConfig
Prefix for trigger matchiing container name.
Definition: SUSYObjDef_xAOD.h:527
ST::SUSYObjDef_xAOD::m_jetCalibTool
asg::AnaToolHandle< IJetCalibrationTool > m_jetCalibTool
Definition: SUSYObjDef_xAOD.h:828
ST::SUSYObjDef_xAOD::m_mu_iso_fallback
std::map< std::string, std::string > m_mu_iso_fallback
Definition: SUSYObjDef_xAOD.h:634
ST::SUSYObjDef_xAOD::m_photonEfficiencySFTool_trigEff_AsymDiphoton
std::vector< asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > > m_photonEfficiencySFTool_trigEff_AsymDiphoton
Definition: SUSYObjDef_xAOD.h:908
ST::SUSYObjDef_xAOD::m_trigNToys_multiLep
int m_trigNToys_multiLep
Definition: SUSYObjDef_xAOD.h:947
ST::SUSYObjDef_xAOD::m_BtagTagger
std::string m_BtagTagger
Definition: SUSYObjDef_xAOD.h:674
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:907
SystematicRegistry.h
ST::SUSYObjDef_xAOD::m_orDoEleJet
bool m_orDoEleJet
Definition: SUSYObjDef_xAOD.h:760
ST::SUSYObjDef_xAOD::m_orPhotonFavoured
bool m_orPhotonFavoured
Definition: SUSYObjDef_xAOD.h:784
ST::SUSYObjDef_xAOD::m_jesCalibArea
std::string m_jesCalibArea
Definition: SUSYObjDef_xAOD.h:865
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:874
ST::SUSYObjDef_xAOD::m_jesCalibSeq
std::string m_jesCalibSeq
Definition: SUSYObjDef_xAOD.h:862
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:705
ST::SUSYObjDef_xAOD::m_jetUncertaintiesTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_jetUncertaintiesTool
Definition: SUSYObjDef_xAOD.h:830
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:776
ST::SUSYObjDef_xAOD::m_muTriggerSFCalibFilename
std::string m_muTriggerSFCalibFilename
Definition: SUSYObjDef_xAOD.h:672
ST::SUSYObjDef_xAOD::m_muonCalibTool
asg::AnaToolHandle< CP::IMuonCalibrationAndSmearingTool > m_muonCalibTool
Definition: SUSYObjDef_xAOD.h:870
ST::SUSYObjDef_xAOD::m_ZTaggerTool
asg::AnaToolHandle< SmoothedWZTagger > m_ZTaggerTool
Definition: SUSYObjDef_xAOD.h:846
ST::SUSYObjDef_xAOD::m_orDoMuBjet
bool m_orDoMuBjet
Definition: SUSYObjDef_xAOD.h:766
PATCoreEnums.h
ST::SUSYObjDef_xAOD::m_orRemoveCaloMuons
bool m_orRemoveCaloMuons
Definition: SUSYObjDef_xAOD.h:781
ST::SUSYObjDef_xAOD::m_trig2017combination_multiLep
std::string m_trig2017combination_multiLep
Definition: SUSYObjDef_xAOD.h:950
ST::SUSYObjDef_xAOD::m_prwDataSF
double m_prwDataSF
Definition: SUSYObjDef_xAOD.h:619
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:530
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:528
JetTruthLabelingTool.h
ST::SUSYObjDef_xAOD::m_legsPerTool_ph
std::map< std::string, std::string > m_legsPerTool_ph
Definition: SUSYObjDef_xAOD.h:826
ST::SUSYObjDef_xAOD::m_WconfigReader
TEnv m_WconfigReader
Definition: SUSYObjDef_xAOD.h:546
ST::SUSYObjDef_xAOD::m_jetfJvtSelectionTool
asg::AnaToolHandle< IAsgSelectionTool > m_jetfJvtSelectionTool
Definition: SUSYObjDef_xAOD.h:842
ST::SUSYObjDef_xAOD::m_photonSelIsEM
asg::AnaToolHandle< IAsgPhotonIsEMSelector > m_photonSelIsEM
Definition: SUSYObjDef_xAOD.h:900
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
ST::SUSYObjDef_xAOD::m_trig2016combination_diLep
std::string m_trig2016combination_diLep
Definition: SUSYObjDef_xAOD.h:941
ST::SUSYObjDef_xAOD::m_jetUncertaintiesPDsmearing
bool m_jetUncertaintiesPDsmearing
Definition: SUSYObjDef_xAOD.h:532
ST::SUSYObjDef_xAOD::m_metSystTool
asg::AnaToolHandle< IMETSystematicsTool > m_metSystTool
Definition: SUSYObjDef_xAOD.h:930
ST::SUSYObjDef_xAOD::m_BtagMinPt_trkJet
double m_BtagMinPt_trkJet
Definition: SUSYObjDef_xAOD.h:683
ST::SUSYObjDef_xAOD::m_orDoElEl
bool m_orDoElEl
Definition: SUSYObjDef_xAOD.h:761
ST::SUSYObjDef_xAOD::m_jetPileupLabelingTool
asg::AnaToolHandle< JetPileupLabelingTool > m_jetPileupLabelingTool
Definition: SUSYObjDef_xAOD.h:837
ST::SUSYObjDef_xAOD::m_trigMatchingPrefix
std::string m_trigMatchingPrefix
Use composite trigger matching tool if matching was done upstream.
Definition: SUSYObjDef_xAOD.h:525
ORUtils::ToolBox::tauJetORT
OverlapHandle_t tauJetORT
Definition: ToolBox.h:75
ST::SUSYObjDef_xAOD::m_metUseGhostMuons
bool m_metUseGhostMuons
Definition: SUSYObjDef_xAOD.h:578
ST::SUSYObjDef_xAOD::m_tauSelToolBaseline
asg::AnaToolHandle< TauAnalysisTools::ITauSelectionTool > m_tauSelToolBaseline
Definition: SUSYObjDef_xAOD.h:917
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:620
ST::SUSYObjDef_xAOD::m_trig2018combination_diLep
std::string m_trig2018combination_diLep
Definition: SUSYObjDef_xAOD.h:943
ST::SUSYObjDef_xAOD::m_jesConfigFat
std::string m_jesConfigFat
Definition: SUSYObjDef_xAOD.h:860
ST::SUSYObjDef_xAOD::m_muIso_WP
std::string m_muIso_WP
Definition: SUSYObjDef_xAOD.h:666
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:948
ST::SUSYObjDef_xAOD::m_btagSelTool_trkJet
asg::AnaToolHandle< IBTaggingSelectionTool > m_btagSelTool_trkJet
Definition: SUSYObjDef_xAOD.h:927
ST::SUSYObjDef_xAOD::m_fatjetUncertaintiesTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_fatjetUncertaintiesTool
Definition: SUSYObjDef_xAOD.h:832
TauAnalysisTools::ELEIDRNNMEDIUM
@ ELEIDRNNMEDIUM
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:34
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:622
IAsgDeadHVCellRemovalTool.h
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_trigEff_singleLep
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_trigEff_singleLep
Definition: SUSYObjDef_xAOD.h:884
ST::SUSYObjDef_xAOD::m_orDoElMu
bool m_orDoElMu
Definition: SUSYObjDef_xAOD.h:762
ST::SUSYObjDef_xAOD::m_photonBaselineIso_WP
std::string m_photonBaselineIso_WP
Definition: SUSYObjDef_xAOD.h:662
ST::SUSYObjDef_xAOD::m_eleId
std::string m_eleId
Definition: SUSYObjDef_xAOD.h:641
ST::SUSYObjDef_xAOD::m_muIdBaseline
int m_muIdBaseline
Definition: SUSYObjDef_xAOD.h:648
ST::SUSYObjDef_xAOD::m_eleIso_WP
std::string m_eleIso_WP
Definition: SUSYObjDef_xAOD.h:653
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_iso
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_iso
Definition: SUSYObjDef_xAOD.h:885
ST::SUSYObjDef_xAOD::m_prwConfFiles
std::vector< std::string > m_prwConfFiles
Definition: SUSYObjDef_xAOD.h:611
ST::SUSYObjDef_xAOD::m_metJetSelection
std::string m_metJetSelection
Definition: SUSYObjDef_xAOD.h:806
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:919
LikeEnum::Tight
@ Tight
Definition: LikelihoodEnums.h:15
ST::SUSYObjDef_xAOD::m_fJvtPtMax
double m_fJvtPtMax
Definition: SUSYObjDef_xAOD.h:750
ST::SUSYObjDef_xAOD::EG_WP
std::string EG_WP(const std::string &wp) const
Definition: SUSYObjDef_xAOD.cxx:1225
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:1213
ST::SUSYObjDef_xAOD::m_eleForceFullSimCalib
bool m_eleForceFullSimCalib
Definition: SUSYObjDef_xAOD.h:699
ST::SUSYObjDef_xAOD::m_elecSelLikelihoodBaseline
asg::AnaToolHandle< IAsgElectronLikelihoodTool > m_elecSelLikelihoodBaseline
Definition: SUSYObjDef_xAOD.h:899
ST::SUSYObjDef_xAOD::m_subtool_init
bool m_subtool_init
Definition: SUSYObjDef_xAOD.h:563
ST::SUSYObjDef_xAOD::m_trigConfTool
asg::AnaToolHandle< TrigConf::ITrigConfigTool > m_trigConfTool
Definition: SUSYObjDef_xAOD.h:963
PathResolver.h
ST::SUSYObjDef_xAOD::m_EigenvectorReductionLight
std::string m_EigenvectorReductionLight
Definition: SUSYObjDef_xAOD.h:680
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:554
ST::SUSYObjDef_xAOD::m_tauEffTool
asg::AnaToolHandle< TauAnalysisTools::ITauEfficiencyCorrectionsTool > m_tauEffTool
Definition: SUSYObjDef_xAOD.h:920
TauAnalysisTools::ELEIDRNNTIGHT
@ ELEIDRNNTIGHT
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:35
IMuonLRTOverlapRemovalTool.h
ST::SUSYObjDef_xAOD::m_muonSelectionToolBaseline
asg::AnaToolHandle< CP::IMuonSelectionTool > m_muonSelectionToolBaseline
Definition: SUSYObjDef_xAOD.h:869
IOverlapRemovalTool.h
ST::SUSYObjDef_xAOD::m_trkMETsyst
bool m_trkMETsyst
Definition: SUSYObjDef_xAOD.h:584
ST::SUSYObjDef_xAOD::m_caloMETsyst
bool m_caloMETsyst
Definition: SUSYObjDef_xAOD.h:585
ST::SUSYObjDef_xAOD::m_JMScalib
bool m_JMScalib
Definition: SUSYObjDef_xAOD.h:755
ST::SUSYObjDef_xAOD::m_muz0
double m_muz0
Definition: SUSYObjDef_xAOD.h:707
ST::SUSYObjDef_xAOD::m_JvtWP
std::string m_JvtWP
Definition: SUSYObjDef_xAOD.h:740
IIsolationSelectionTool.h
ST::SUSYObjDef_xAOD::m_useBtagging_trkJet
bool m_useBtagging_trkJet
Definition: SUSYObjDef_xAOD.h:535
ST::SUSYObjDef_xAOD::m_doFwdJVT
bool m_doFwdJVT
Definition: SUSYObjDef_xAOD.h:748
ST::SUSYObjDef_xAOD::m_isoCloseByTool
asg::AnaToolHandle< CP::IIsolationCloseByCorrectionTool > m_isoCloseByTool
Definition: SUSYObjDef_xAOD.h:974
ICPJetUncertaintiesTool.h
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_trig_singleLep
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_trig_singleLep
Definition: SUSYObjDef_xAOD.h:883
ST::SUSYObjDef_xAOD::m_trig2018combination_multiLep
std::string m_trig2018combination_multiLep
Definition: SUSYObjDef_xAOD.h:951
ST::SUSYObjDef_xAOD::m_btagSelTool_OR
asg::AnaToolHandle< IBTaggingSelectionTool > m_btagSelTool_OR
Definition: SUSYObjDef_xAOD.h:925
IMuonCalibrationAndSmearingTool.h
checkTriggerxAOD.found
found
Definition: checkTriggerxAOD.py:328
ST::SUSYObjDef_xAOD::m_muonSelectionHighPtTool
asg::AnaToolHandle< CP::IMuonSelectionTool > m_muonSelectionHighPtTool
Definition: SUSYObjDef_xAOD.h:868
ST::SUSYObjDef_xAOD::m_photonId
std::string m_photonId
Definition: SUSYObjDef_xAOD.h:649
ST::SUSYObjDef_xAOD::m_fJvtConfigRun3
std::string m_fJvtConfigRun3
Definition: SUSYObjDef_xAOD.h:753
ST::SUSYObjDef_xAOD::m_ApplyMVATESQualityCheck
bool m_ApplyMVATESQualityCheck
Definition: SUSYObjDef_xAOD.h:734
ST::SUSYObjDef_xAOD::m_BtagWP_trkJet
std::string m_BtagWP_trkJet
Definition: SUSYObjDef_xAOD.h:681
SmoothedWZTagger.h
ST::SUSYObjDef_xAOD::m_fatjetUncertaintiesPDSmearTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_fatjetUncertaintiesPDSmearTool
Definition: SUSYObjDef_xAOD.h:833
ST::SUSYObjDef_xAOD::m_fatjetFFSmearingTool
asg::AnaToolHandle< ICPJetCorrectionTool > m_fatjetFFSmearingTool
Definition: SUSYObjDef_xAOD.h:834
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:515
ITauToolBase.h
IInclusiveTrackFilterTool.h
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:16
ST::SUSYObjDef_xAOD::m_EleFatJetDR
double m_EleFatJetDR
Definition: SUSYObjDef_xAOD.h:789
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:283
AthAnalysisHelper.h
ST::SUSYObjDef_xAOD::m_btagSelTool
asg::AnaToolHandle< IBTaggingSelectionTool > m_btagSelTool
Definition: SUSYObjDef_xAOD.h:924
ST::SUSYObjDef_xAOD::m_orDoTauBjet
bool m_orDoTauBjet
Definition: SUSYObjDef_xAOD.h:767
ST::SUSYObjDef_xAOD::m_jetNNJvtSelectionTool
asg::AnaToolHandle< IAsgSelectionTool > m_jetNNJvtSelectionTool
Definition: SUSYObjDef_xAOD.h:840
python.AthDsoLogger.fname
string fname
Definition: AthDsoLogger.py:66
ST::SUSYObjDef_xAOD::m_orMuJetTrkPtRatio
double m_orMuJetTrkPtRatio
Definition: SUSYObjDef_xAOD.h:778
ST::SUSYObjDef_xAOD::m_muonTriggerSFTool
asg::AnaToolHandle< CP::IMuonTriggerScaleFactors > m_muonTriggerSFTool
Definition: SUSYObjDef_xAOD.h:876
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:1237
ST::SUSYObjDef_xAOD::m_btagEffTool
asg::AnaToolHandle< IBTaggingEfficiencyTool > m_btagEffTool
Definition: SUSYObjDef_xAOD.h:923
IMatchingTool.h
ST::SUSYObjDef_xAOD::m_fatJets
std::string m_fatJets
Definition: SUSYObjDef_xAOD.h:812
ST::SUSYObjDef_xAOD::m_muCalibrationMode
int m_muCalibrationMode
Definition: SUSYObjDef_xAOD.h:714
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:588
ST::SUSYObjDef_xAOD::m_orBoostedElectronMaxConeSize
double m_orBoostedElectronMaxConeSize
Definition: SUSYObjDef_xAOD.h:771
ST::SUSYObjDef_xAOD::m_eleBaselineIso_WP
std::string m_eleBaselineIso_WP
Definition: SUSYObjDef_xAOD.h:645
ST::SUSYObjDef_xAOD::m_BtagTagger_trkJet
std::string m_BtagTagger_trkJet
Definition: SUSYObjDef_xAOD.h:682
ST::SUSYObjDef_xAOD::m_tauId
std::string m_tauId
Definition: SUSYObjDef_xAOD.h:651
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
ST::SUSYObjDef_xAOD::m_EG_corrModel
std::string m_EG_corrModel
Definition: SUSYObjDef_xAOD.h:819
LikeEnum::Medium
@ Medium
Definition: LikelihoodEnums.h:14
ST::SUSYObjDef_xAOD::m_JetFatJetDR
double m_JetFatJetDR
Definition: SUSYObjDef_xAOD.h:790
ST::SUSYObjDef_xAOD::m_JetTruthLabelName
std::string m_JetTruthLabelName
Definition: SUSYObjDef_xAOD.h:560
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
ST::SUSYObjDef_xAOD::m_orDoBoostedElectron
bool m_orDoBoostedElectron
Definition: SUSYObjDef_xAOD.h:768
ST::SUSYObjDef_xAOD::m_photonSelIsEMBaseline
asg::AnaToolHandle< IAsgPhotonIsEMSelector > m_photonSelIsEMBaseline
Definition: SUSYObjDef_xAOD.h:901
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:581
ST::SUSYObjDef_xAOD::m_isRun3
bool m_isRun3
Definition: SUSYObjDef_xAOD.h:803
ST::SUSYObjDef_xAOD::m_trigDecTool
asg::AnaToolHandle< Trig::TrigDecisionTool > m_trigDecTool
Definition: SUSYObjDef_xAOD.h:964
ST::SUSYObjDef_xAOD::m_metsysConfigPrefix
std::string m_metsysConfigPrefix
Definition: SUSYObjDef_xAOD.h:582
ST::SUSYObjDef_xAOD::m_defaultTrackJets
std::string m_defaultTrackJets
Definition: SUSYObjDef_xAOD.h:811
FullCPAlgorithmsTest_CA.inputfile
dictionary inputfile
Definition: FullCPAlgorithmsTest_CA.py:62
ST::SUSYObjDef_xAOD::m_jesCalibSeqFat
std::string m_jesCalibSeqFat
Definition: SUSYObjDef_xAOD.h:864
IJetUpdateJvt.h
ST::SUSYObjDef_xAOD::m_treatPUJets
bool m_treatPUJets
Definition: SUSYObjDef_xAOD.h:589
ST::SUSYObjDef_xAOD::m_jesConfig
std::string m_jesConfig
Definition: SUSYObjDef_xAOD.h:856
ST::SUSYObjDef_xAOD::m_tauConfigPathBaseline
std::string m_tauConfigPathBaseline
Definition: SUSYObjDef_xAOD.h:729
ST::SUSYObjDef_xAOD::m_jetFatCalibTool
asg::AnaToolHandle< IJetCalibrationTool > m_jetFatCalibTool
Definition: SUSYObjDef_xAOD.h:829
ST::SUSYObjDef_xAOD::m_electronTriggerSFStringSingle
std::string m_electronTriggerSFStringSingle
Definition: SUSYObjDef_xAOD.h:637
ST::SUSYObjDef_xAOD::m_jetNNJvtEfficiencyTool
asg::AnaToolHandle< CP::IJvtEfficiencyTool > m_jetNNJvtEfficiencyTool
Definition: SUSYObjDef_xAOD.h:841
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:942
ST::SUSYObjDef_xAOD::m_trigDRScoringTool
asg::AnaToolHandle< Trig::IMatchScoringTool > m_trigDRScoringTool
Definition: SUSYObjDef_xAOD.h:967
ST::SUSYObjDef_xAOD::m_trig2015combination_diLep
std::string m_trig2015combination_diLep
Definition: SUSYObjDef_xAOD.h:940
ST::SUSYObjDef_xAOD::m_jetTruthLabelingTool
asg::AnaToolHandle< JetTruthLabelingTool > m_jetTruthLabelingTool
Definition: SUSYObjDef_xAOD.h:848
ST::SUSYObjDef_xAOD::m_eleLRT_strat
int m_eleLRT_strat
Definition: SUSYObjDef_xAOD.h:658
ORUtils::ToolBox::phoJetORT
OverlapHandle_t phoJetORT
Definition: ToolBox.h:78
ST::SUSYObjDef_xAOD::m_ZDecorName
std::string m_ZDecorName
Definition: SUSYObjDef_xAOD.h:550
ST::SUSYObjDef_xAOD::m_metSignif
asg::AnaToolHandle< IMETSignificance > m_metSignif
Definition: SUSYObjDef_xAOD.h:931
ST::SUSYObjDef_xAOD::m_eleConfig
std::string m_eleConfig
Definition: SUSYObjDef_xAOD.h:643
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:669
ST::SUSYObjDef_xAOD::m_photonTriggerName
std::string m_photonTriggerName
Definition: SUSYObjDef_xAOD.h:664
ST::SUSYObjDef_xAOD::m_EigenvectorReductionB
std::string m_EigenvectorReductionB
Definition: SUSYObjDef_xAOD.h:678
ST::SUSYObjDef_xAOD::m_orBoostedElectronC2
double m_orBoostedElectronC2
Definition: SUSYObjDef_xAOD.h:770
TauAnalysisTools::JETIDNONEUNCONFIGURED
@ JETIDNONEUNCONFIGURED
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:13
ST::SUSYObjDef_xAOD::m_orInputLabel
std::string m_orInputLabel
Definition: SUSYObjDef_xAOD.h:783
ST::SUSYObjDef_xAOD::m_ZtagConfig
std::string m_ZtagConfig
Definition: SUSYObjDef_xAOD.h:553
ORUtils::ORFlags::doJets
bool doJets
Definition: OverlapRemovalInit.h:61
ST::SUSYObjDef_xAOD::m_mud0sig
double m_mud0sig
Definition: SUSYObjDef_xAOD.h:706
ST::SUSYObjDef_xAOD::m_muIsoHighPt_WP
std::string m_muIsoHighPt_WP
Definition: SUSYObjDef_xAOD.h:667
ST::SUSYObjDef_xAOD::m_muonHighPtIsolationSFTool
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonHighPtIsolationSFTool
Definition: SUSYObjDef_xAOD.h:875
ST::SUSYObjDef_xAOD::m_photonIdBaseline
std::string m_photonIdBaseline
Definition: SUSYObjDef_xAOD.h:650
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:580
ST::SUSYObjDef_xAOD::m_muonTrigSFTools
ToolHandleArray< CP::IMuonTriggerScaleFactors > m_muonTrigSFTools
Definition: SUSYObjDef_xAOD.h:877
ST::SUSYObjDef_xAOD::m_jetCleaningTool
asg::AnaToolHandle< IJetSelector > m_jetCleaningTool
Definition: SUSYObjDef_xAOD.h:835
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:780
ST::SUSYObjDef_xAOD::m_isoCorrTool
asg::AnaToolHandle< CP::IIsolationCorrectionTool > m_isoCorrTool
Definition: SUSYObjDef_xAOD.h:969
ST::SUSYObjDef_xAOD::m_defaultTruthJets
std::string m_defaultTruthJets
Definition: SUSYObjDef_xAOD.h:813
ST::SUSYObjDef_xAOD::m_tauDoTTM
bool m_tauDoTTM
Definition: SUSYObjDef_xAOD.h:730
ST::SUSYObjDef_xAOD::m_elecTrigSFTools
ToolHandleArray< IAsgElectronEfficiencyCorrectionTool > m_elecTrigSFTools
Definition: SUSYObjDef_xAOD.h:891
ST::SUSYObjDef_xAOD::m_tauTrigEffTool
std::vector< asg::AnaToolHandle< TauAnalysisTools::ITauEfficiencyCorrectionsTool > > m_tauTrigEffTool
Definition: SUSYObjDef_xAOD.h:921
ST::SUSYObjDef_xAOD::m_mcCampaign
std::string m_mcCampaign
Definition: SUSYObjDef_xAOD.h:598
ST::SUSYObjDef_xAOD::m_TopDecorName
std::string m_TopDecorName
Definition: SUSYObjDef_xAOD.h:551
ST::SUSYObjDef_xAOD::m_orDoMuonJet
bool m_orDoMuonJet
Definition: SUSYObjDef_xAOD.h:763
ST::SUSYObjDef_xAOD::m_upstreamTriggerMatching
bool m_upstreamTriggerMatching
Definition: SUSYObjDef_xAOD.h:524
ST::SUSYObjDef_xAOD::m_fatJetUncertaintiesMCType
std::string m_fatJetUncertaintiesMCType
Definition: SUSYObjDef_xAOD.h:531
ITauSmearingTool.h
IEfficiencyScaleFactorTool.h
ST::SUSYObjDef_xAOD::m_LRTuncTool
asg::AnaToolHandle< InDet::IInclusiveTrackFilterTool > m_LRTuncTool
Definition: SUSYObjDef_xAOD.h:978
ST::SUSYObjDef_xAOD::m_WtagConfig
std::string m_WtagConfig
Definition: SUSYObjDef_xAOD.h:552
ST::SUSYObjDef_xAOD::m_useTRUTH3
bool m_useTRUTH3
Definition: SUSYObjDef_xAOD.h:800
ST::SUSYObjDef_xAOD::m_EG_corrFNList
std::string m_EG_corrFNList
Definition: SUSYObjDef_xAOD.h:820
ST::SUSYObjDef_xAOD::m_photonIsolationSFTool
asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > m_photonIsolationSFTool
Definition: SUSYObjDef_xAOD.h:904
ST::SUSYObjDef_xAOD::m_muonSelectionTool
asg::AnaToolHandle< CP::IMuonSelectionTool > m_muonSelectionTool
Definition: SUSYObjDef_xAOD.h:867
ST::SUSYObjDef_xAOD::m_useSigLepForIsoCloseByOR
bool m_useSigLepForIsoCloseByOR
Definition: SUSYObjDef_xAOD.h:797
ST::SUSYObjDef_xAOD::m_egammaAmbiguityTool
asg::AnaToolHandle< IEGammaAmbiguityTool > m_egammaAmbiguityTool
Definition: SUSYObjDef_xAOD.h:912
ST::SUSYObjDef_xAOD::m_TopconfigReader
TEnv m_TopconfigReader
Definition: SUSYObjDef_xAOD.h:548
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:956
ST::SUSYObjDef_xAOD::m_isoTool
asg::AnaToolHandle< CP::IIsolationSelectionTool > m_isoTool
Definition: SUSYObjDef_xAOD.h:970
ST::SUSYObjDef_xAOD::m_JvtConfigRun3
std::string m_JvtConfigRun3
Definition: SUSYObjDef_xAOD.h:743
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:983
Generated on Mon Sep 29 2025 21:19:21 for ATLAS Offline Software by   doxygen 1.8.18