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