ATLAS Offline Software
SUSYToolsInit.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "SUSYTools/SUSYObjDef_xAOD.h"
6 
7 // For 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
14 #include "AssociationUtils/OverlapRemovalInit.h"
15 
16 // Abstract interface classes
17 #include "FTagAnalysisInterfaces/IBTaggingEfficiencyTool.h"
18 #include "FTagAnalysisInterfaces/IBTaggingSelectionTool.h"
19 
20 #include "JetInterface/IJetSelector.h"
21 #include "JetCalibTools/IJetCalibrationTool.h"
22 #include "JetCPInterfaces/ICPJetUncertaintiesTool.h"
23 #include "JetInterface/IJetUpdateJvt.h"
24 #include "JetInterface/IJetModifier.h"
25 #include "JetInterface/IJetDecorator.h"
26 
27 #include "AsgAnalysisInterfaces/IEfficiencyScaleFactorTool.h"
28 #include "EgammaAnalysisInterfaces/IEgammaCalibrationAndSmearingTool.h"
29 #include "EgammaAnalysisInterfaces/IAsgElectronEfficiencyCorrectionTool.h"
30 #include "EgammaAnalysisInterfaces/IAsgElectronIsEMSelector.h"
31 #include "EgammaAnalysisInterfaces/IAsgElectronLikelihoodTool.h"
32 #include "EgammaAnalysisInterfaces/IAsgDeadHVCellRemovalTool.h"
33 #include "EgammaAnalysisInterfaces/IEGammaAmbiguityTool.h"
34 #include "EgammaAnalysisInterfaces/IAsgPhotonEfficiencyCorrectionTool.h"
35 #include "EgammaAnalysisInterfaces/IAsgPhotonIsEMSelector.h"
36 #include "EgammaAnalysisInterfaces/IElectronLRTOverlapRemovalTool.h"
37 
38 #include "MuonAnalysisInterfaces/IMuonSelectionTool.h"
39 #include "MuonAnalysisInterfaces/IMuonCalibrationAndSmearingTool.h"
40 #include "MuonAnalysisInterfaces/IMuonEfficiencyScaleFactors.h"
41 #include "MuonAnalysisInterfaces/IMuonTriggerScaleFactors.h"
42 #include "MuonAnalysisInterfaces/IMuonLRTOverlapRemovalTool.h"
43 
44 #include "TauAnalysisTools/ITauSelectionTool.h"
45 #include "TauAnalysisTools/ITauSmearingTool.h"
46 #include "TauAnalysisTools/ITauTruthMatchingTool.h"
47 #include "TauAnalysisTools/ITauEfficiencyCorrectionsTool.h"
48 #include "tauRecTools/ITauToolBase.h"
49 
50 #include "IsolationSelection/IIsolationSelectionTool.h"
51 //disable #include "IsolationSelection/IIsolationLowPtPLVTool.h"
52 #include "IsolationCorrections/IIsolationCorrectionTool.h"
53 #include "IsolationSelection/IIsolationCloseByCorrectionTool.h"
54 
55 #include "METInterface/IMETMaker.h"
56 #include "METInterface/IMETSystematicsTool.h"
57 #include "METInterface/IMETSignificance.h"
58 
59 #include "TrigConfInterfaces/ITrigConfigTool.h"
60 #include "TriggerMatchingTool/IMatchingTool.h"
61 #include "TriggerMatchingTool/IMatchScoringTool.h"
62 #include "TriggerAnalysisInterfaces/ITrigGlobalEfficiencyCorrectionTool.h"
63 // Can't use the abstract interface for this one (see header comment)
64 #include "TrigDecisionTool/TrigDecisionTool.h"
65 
66 #include "PATInterfaces/IWeightTool.h"
67 #include "AsgAnalysisInterfaces/IPileupReweightingTool.h"
68 #include "PathResolver/PathResolver.h"
69 #include "AssociationUtils/IOverlapRemovalTool.h"
70 #include "BoostedJetTaggers/SmoothedWZTagger.h"
71 #include "BoostedJetTaggers/JSSWTopTaggerDNN.h"
72 #include "ParticleJetTools/JetTruthLabelingTool.h"
73 
74 #include "InDetTrackSystematicsTools/IInclusiveTrackFilterTool.h"
75 
76 #ifndef XAOD_STANDALONE
77 #include "AthAnalysisBaseComps/AthAnalysisHelper.h"
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 
109 StatusCode SUSYObjDef_xAOD::SUSYToolsInit()
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) );
150  ATH_CHECK( m_prwTool.retrieve() );
151  } else {
152  ATH_MSG_INFO("Using user-configured PRW tool");
153  ATH_CHECK( m_prwTool.retrieve() );
154  }
155 
157  // Initialize LRT systematics tool
158  if (!m_LRTuncTool.isUserConfigured())
159  {
160  ATH_MSG_INFO("Initializing LRT uncertainty tool");
161  m_LRTuncTool.setTypeAndName("InDet::InclusiveTrackFilterTool/LRTUncTool");
162  ATH_CHECK( m_LRTuncTool.setProperty("Seed", 1) );
163  ATH_CHECK(m_LRTuncTool.retrieve());
164  } else {
165  ATH_MSG_INFO("Using user-configured LRT uncertainty tool");
166  ATH_CHECK(m_LRTuncTool.retrieve());
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
177  jetname = "AntiKt4" + xAOD::JetInput::typeName(xAOD::JetInput::Type(m_jetInputType));
178  jetcoll = jetname + "Jets";
179 
180  if (!m_jetCalibTool.isUserConfigured()) {
181  toolName = "JetCalibTool_" + jetname;
182  m_jetCalibTool.setTypeAndName("JetCalibrationTool/"+toolName);
183  std::string JES_config_file, calibseq;
184 
185  if (m_jetInputType != xAOD::JetInput::EMPFlow) {
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) );
218  ATH_CHECK( m_jetCalibTool.setProperty("CalibArea", m_jesCalibArea) );
219  ATH_CHECK( m_jetCalibTool.setProperty("IsData", isData()) );
220  ATH_CHECK( m_jetCalibTool.setProperty("OutputLevel", this->msg().level()) );
221  ATH_CHECK( m_jetCalibTool.retrieve() );
222  } else ATH_CHECK(m_jetCalibTool.retrieve());
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
248  ATH_CHECK( m_jetFatCalibTool.setProperty("IsData", isData()) );
249  ATH_CHECK( m_jetFatCalibTool.setProperty("OutputLevel", this->msg().level()) );
250  ATH_CHECK( m_jetFatCalibTool.retrieve() );
251  } else if (m_jetFatCalibTool.isUserConfigured()) ATH_CHECK(m_jetFatCalibTool.retrieve());
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) );
260  ATH_CHECK( m_WTaggerTool.setProperty("ConfigFile", m_WtagConfig) );
261  ATH_CHECK( m_WTaggerTool.setProperty("CalibArea", m_WZTaggerCalibArea) );
262  ATH_CHECK( m_WTaggerTool.setProperty("IsMC",!isData()));
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()) );
269  ATH_CHECK( m_WTaggerTool.retrieve() );
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 
282  } else if (m_WTaggerTool.isUserConfigured()) ATH_CHECK(m_WTaggerTool.retrieve());
283 
284  if (!m_ZTaggerTool.isUserConfigured() && !m_ZtagConfig.empty()) {
285  m_ZTaggerTool.setTypeAndName("SmoothedWZTagger/ZTagger");
286  ATH_CHECK( m_ZTaggerTool.setProperty("ContainerName", m_fatJets) );
287  ATH_CHECK( m_ZTaggerTool.setProperty("ConfigFile", m_ZtagConfig) );
288  ATH_CHECK( m_ZTaggerTool.setProperty("CalibArea", m_WZTaggerCalibArea) );
289  ATH_CHECK( m_ZTaggerTool.setProperty("IsMC",!isData()));
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()) );
296  ATH_CHECK( m_ZTaggerTool.retrieve() );
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 
309  } else if (m_ZTaggerTool.isUserConfigured()) ATH_CHECK(m_ZTaggerTool.retrieve());
310 
311  if (!m_TopTaggerTool.isUserConfigured() && !m_ToptagConfig.empty()) {
312  m_TopTaggerTool.setTypeAndName("JSSWTopTaggerDNN/TopTagger");
313  ATH_CHECK( m_TopTaggerTool.setProperty("ContainerName", m_fatJets) );
314  ATH_CHECK( m_TopTaggerTool.setProperty("ConfigFile", m_ToptagConfig) );
315  ATH_CHECK( m_TopTaggerTool.setProperty("CalibArea", m_TopTaggerCalibArea) );
316  ATH_CHECK( m_TopTaggerTool.setProperty("IsMC",!isData()));
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()) );
323  ATH_CHECK( m_TopTaggerTool.retrieve() );
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 
336  } else if (m_TopTaggerTool.isUserConfigured()) ATH_CHECK(m_TopTaggerTool.retrieve());
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  }
344 
345  if (!m_jetTruthLabelingTool.isUserConfigured()) {
346  m_jetTruthLabelingTool.setTypeAndName("JetTruthLabelingTool/ST_JetTruthLabelingTool");
347  ATH_CHECK( m_jetTruthLabelingTool.setProperty("RecoJetContainer", m_fatJets) );
348  ATH_CHECK( m_jetTruthLabelingTool.setProperty("TruthLabelName", m_JetTruthLabelName) );
349  ATH_CHECK( m_jetTruthLabelingTool.setProperty("UseTRUTH3", m_useTRUTH3) ); // Set this to false only if you have the FULL !TruthParticles container in your input file
350  ATH_CHECK( m_jetTruthLabelingTool.setProperty("TruthParticleContainerName", "TruthParticles") );
351  ATH_CHECK( m_jetTruthLabelingTool.setProperty("TruthBosonContainerName", "TruthBoson") ); // Set this if you are using a TRUTH3 style truth boson container
352  ATH_CHECK( m_jetTruthLabelingTool.setProperty("TruthTopQuarkContainerName", "TruthTop") ); // Set this if you are using a TRUTH3 style truth top quark container
353  ATH_CHECK( m_jetTruthLabelingTool.setProperty("OutputLevel", this->msg().level()) );
354  ATH_CHECK( m_jetTruthLabelingTool.retrieve() );
355  } else if (m_jetTruthLabelingTool.isUserConfigured()) ATH_CHECK(m_jetTruthLabelingTool.retrieve());
356 
357  }
358 
359  if (m_slices["jet"] || m_slices["fjet"]) {
360 
361 
363  // Initialise jet uncertainty tool
364  // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/JetUncertaintiesRel22
365  ATH_MSG_INFO("Set up Jet Uncertainty tool...");
366 
367  // if not set, derive the MCType from the simulation type and MC campaign
368  if (m_jetUncertaintiesMCType.empty()) m_jetUncertaintiesMCType = m_isRun3 ? "MC23" : (isAtlfast() ? "AF3" : "MC20");
369 
370  if (!m_jetUncertaintiesTool.isUserConfigured()) {
371  std::string jetdef("AntiKt4" + xAOD::JetInput::typeName(xAOD::JetInput::Type(m_jetInputType)));
372 
373  if(jetdef !="AntiKt4EMPFlow"){
374  ATH_MSG_WARNING("Jet Uncertaintes recommendations only exist for PFlow jets, falling back to AntiKt4EMPFlow");
375  jetdef = "AntiKt4EMPFlow";
376  }
377  toolName = "JetUncertaintiesTool_" + jetdef;
378 
379  if (m_isRun3 && isAtlfast()) {
380  ATH_MSG_WARNING("Jet Uncertaintes pre-recommendations for Run3 only exist for full sim");
381  }
382 
383  m_jetUncertaintiesTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
384 
385  ATH_CHECK( m_jetUncertaintiesTool.setProperty("JetDefinition", jetdef) );
386  ATH_CHECK( m_jetUncertaintiesTool.setProperty("MCType", m_jetUncertaintiesMCType) );
387  ATH_CHECK( m_jetUncertaintiesTool.setProperty("IsData", false) ); // Never use the PDSmearing for the nominal tool.
388  ATH_CHECK( m_jetUncertaintiesTool.setProperty("ConfigFile", m_jetUncertaintiesConfig) );
389  if(m_jetUncertaintiesAnalysisFile!="default") ATH_CHECK( m_jetUncertaintiesTool.setProperty("AnalysisFile", m_jetUncertaintiesAnalysisFile) );
390  if (m_jetUncertaintiesCalibArea != "default") ATH_CHECK( m_jetUncertaintiesTool.setProperty("CalibArea", m_jetUncertaintiesCalibArea) );
391  ATH_CHECK( m_jetUncertaintiesTool.setProperty("OutputLevel", this->msg().level()) );
392  ATH_CHECK( m_jetUncertaintiesTool.retrieve() );
393  } else ATH_CHECK( m_jetUncertaintiesTool.retrieve() );
394 
395  ATH_MSG_INFO("Set up Jet PD Smear Uncertainty tool...");
396 
397  if (!m_jetUncertaintiesPDSmearTool.isUserConfigured() && m_jetUncertaintiesPDsmearing == true) {
398  std::string jetdef("AntiKt4" + xAOD::JetInput::typeName(xAOD::JetInput::Type(m_jetInputType)));
399 
400  if(jetdef !="AntiKt4EMPFlow"){
401  ATH_MSG_WARNING("Jet Uncertaintes recommendations only exist for PFlow jets, falling back to AntiKt4EMPFlow");
402  jetdef = "AntiKt4EMPFlow";
403  }
404  toolName = "JetUncertaintiesPDSmearTool_" + jetdef;
405 
406  m_jetUncertaintiesPDSmearTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
407 
408  // 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.
409  bool JERUncPDsmearing = isData() ? isData() : m_jetUncertaintiesPDsmearing;
410  if (m_jetUncertaintiesConfig.find("SimpleJER") != std::string::npos && JERUncPDsmearing){
411  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.");
412  return StatusCode::FAILURE;
413  }
414  ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("JetDefinition", jetdef) );
415  ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("MCType", m_jetUncertaintiesMCType) );
416  ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("IsData", true) ); // Set to True by default for PDSmear-named tool.
417  ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("ConfigFile", m_jetUncertaintiesConfig) );
418  if (m_jetUncertaintiesCalibArea != "default") ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("CalibArea", m_jetUncertaintiesCalibArea) );
419  ATH_CHECK( m_jetUncertaintiesPDSmearTool.setProperty("OutputLevel", this->msg().level()) );
420  ATH_CHECK( m_jetUncertaintiesPDSmearTool.retrieve() );
421  } else{
422  ATH_MSG_DEBUG("Do not retrieve the jet PD Smearing tool if it is not configured");
423  //ATH_CHECK( m_jetUncertaintiesPDSmearTool.retrieve() );
424  }
425  }
426 
427  if (m_slices["fjet"]) {
428  ATH_MSG_INFO("Won't initialise jet uncertainty tool for fat jets until we get rec for UFO");
429  // Won't initialise jet uncertainty tool for fat jets until we get rec for UFO
430  /*
431  if (!m_fatjetUncertaintiesTool.isUserConfigured() && !m_fatJets.empty() && !m_fatJetUncConfig.empty()) {
432 
433  toolName = "JetUncertaintiesTool_" + m_fatJets;
434  m_fatjetUncertaintiesTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
435 
436  ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("JetDefinition", fatjetcoll) );
437  ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("MCType", "MC16") );
438  ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("IsData", isData()) );
439  ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("ConfigFile", m_fatJetUncConfig) );
440  if (m_jetUncertaintiesCalibArea != "default") ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("CalibArea", m_jetUncertaintiesCalibArea) );
441 
442  //Restrict variables to be shifted if (required)
443  if( m_fatJetUncVars != "default" ){
444  std::vector<std::string> shift_vars = {};
445 
446  std::string temp(m_fatJetUncVars);
447  do {
448  auto pos = temp.find(',');
449  shift_vars.push_back(temp.substr(0, pos));
450  if (pos == std::string::npos)
451  temp = "";
452  else
453  temp = temp.substr(pos + 1);
454 
455  }
456  while (!temp.empty() );
457 
458  ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("VariablesToShift", shift_vars) );
459  }
460 
461  ATH_CHECK( m_fatjetUncertaintiesTool.setProperty("OutputLevel", this->msg().level()) );
462  ATH_CHECK( m_fatjetUncertaintiesTool.retrieve() );
463  } else if (m_fatjetUncertaintiesTool.isUserConfigured()) ATH_CHECK(m_fatjetUncertaintiesTool.retrieve());
464  */
465  ATH_MSG_INFO(" Won't initialise Wtagger uncertainty tool for fat jets until we get rec for UFO");
466  // Won't initialise Wtagger uncertainty tool for fat jets until we get rec for UFO
467  /*
468  if (!m_WTagjetUncertaintiesTool.isUserConfigured() && !m_fatJets.empty() && !m_WtagConfig.empty() && !m_WTagUncConfig.empty()) {
469 
470  toolName = "WTagJetUncertaintiesTool_" + m_fatJets;
471  m_WTagjetUncertaintiesTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
472  ATH_CHECK( m_WTagjetUncertaintiesTool.setProperty("JetDefinition", fatjetcoll) );
473  ATH_CHECK( m_WTagjetUncertaintiesTool.setProperty("MCType", "MC16") );
474  ATH_CHECK( m_WTagjetUncertaintiesTool.setProperty("IsData", isData()) );
475  ATH_CHECK( m_WTagjetUncertaintiesTool.setProperty("ConfigFile", "rel21/Fall2020/"+m_WTagUncConfig) );
476  ATH_CHECK( m_WTagjetUncertaintiesTool.setProperty("OutputLevel", this->msg().level()) );
477  ATH_CHECK( m_WTagjetUncertaintiesTool.retrieve() );
478  } else if (m_WTagjetUncertaintiesTool.isUserConfigured()) ATH_CHECK(m_WTagjetUncertaintiesTool.retrieve());
479  */
480  ATH_MSG_INFO(" Won't initialise Ztagger uncertainty tool for fat jets until we get rec for UFO");
481  // Won't initialise Ztagger uncertainty tool for fat jets until we get rec for UFO
482  /*
483  if (!m_ZTagjetUncertaintiesTool.isUserConfigured() && !m_fatJets.empty() && !m_ZtagConfig.empty() && !m_ZTagUncConfig.empty()) {
484 
485  toolName = "ZTagJetUncertaintiesTool_" + m_fatJets;
486  m_ZTagjetUncertaintiesTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
487  ATH_CHECK( m_ZTagjetUncertaintiesTool.setProperty("JetDefinition", fatjetcoll) );
488  ATH_CHECK( m_ZTagjetUncertaintiesTool.setProperty("ConfigFile", "rel21/Fall2020/"+m_ZTagUncConfig) );
489  ATH_CHECK( m_ZTagjetUncertaintiesTool.setProperty("MCType", "MC16") );
490  ATH_CHECK( m_ZTagjetUncertaintiesTool.setProperty("IsData", isData()) );
491  ATH_CHECK( m_ZTagjetUncertaintiesTool.setProperty("OutputLevel", this->msg().level()) );
492  ATH_CHECK( m_ZTagjetUncertaintiesTool.retrieve() );
493  } else if (m_ZTagjetUncertaintiesTool.isUserConfigured()) ATH_CHECK(m_ZTagjetUncertaintiesTool.retrieve());
494  */
495  ATH_MSG_INFO(" Won't initialise top-tagger uncertainty tool for fat jets until we get rec for UFO");
496  // Won't initialise top-tagger uncertainty tool for fat jets until we get rec for UFO
497  /*
498  if (!m_TopTagjetUncertaintiesTool.isUserConfigured() && !m_fatJets.empty() && !m_ToptagConfig.empty() && !m_TopTagUncConfig.empty()) {
499 
500  toolName = "TopTagJetUncertaintiesTool_" + m_fatJets;
501  m_TopTagjetUncertaintiesTool.setTypeAndName("JetUncertaintiesTool/"+toolName);
502  ATH_CHECK( m_TopTagjetUncertaintiesTool.setProperty("JetDefinition", fatjetcoll) );
503  ATH_CHECK( m_TopTagjetUncertaintiesTool.setProperty("MCType", "MC16") );
504  ATH_CHECK( m_TopTagjetUncertaintiesTool.setProperty("IsData", isData()) );
505  ATH_CHECK( m_TopTagjetUncertaintiesTool.setProperty("ConfigFile", "rel21/Fall2020/"+m_TopTagUncConfig) );
506  ATH_CHECK( m_TopTagjetUncertaintiesTool.setProperty("OutputLevel", this->msg().level()) );
507  ATH_CHECK( m_TopTagjetUncertaintiesTool.retrieve() );
508  } else if (m_TopTagjetUncertaintiesTool.isUserConfigured()) ATH_CHECK(m_TopTagjetUncertaintiesTool.retrieve());
509  */
510  }
511 
512 
513  // tagger SF and uncertainties
514  // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/BoostedJetTaggingRecommendationFullRun2
515  // To be implemented here
516 
517  if (m_slices["jet"]) {
519  // Initialise jet cleaning tools
520 
521  // see https://twiki.cern.ch/twiki/bin/view/AtlasProtected/HowToCleanJetsR22
522  if (m_badJetCut!="" && !m_jetCleaningTool.isUserConfigured()) {
523  toolName = "JetCleaningTool";
524  m_jetCleaningTool.setTypeAndName("JetCleaningTool/"+toolName);
525  ATH_CHECK( m_jetCleaningTool.setProperty("CutLevel", m_badJetCut) );
526  ATH_CHECK( m_jetCleaningTool.setProperty("DoUgly", false) );
527  ATH_CHECK( m_jetCleaningTool.setProperty("OutputLevel", this->msg().level()) );
528  ATH_CHECK( m_jetCleaningTool.retrieve() );
529  } else if (m_jetCleaningTool.isUserConfigured()) ATH_CHECK( m_jetCleaningTool.retrieve() );
530 
532  // Initialise jet pileup labeling tool (required for labels used by JvtEfficiencyTools)
533 
534  if(!m_jetPileupLabelingTool.isUserConfigured()){
535  toolName = "PileupLabelingTool";
536  m_jetPileupLabelingTool.setTypeAndName("JetPileupLabelingTool/"+toolName);
537  ATH_CHECK( m_jetPileupLabelingTool.setProperty("RecoJetContainer", m_defaultJets) );
538  ATH_CHECK( m_jetPileupLabelingTool.setProperty("TruthJetContainer", m_defaultTruthJets) );
539  #ifndef XAOD_STANDALONE
540  ATH_CHECK( m_jetPileupLabelingTool.setProperty("SuppressInputDependence", true) );
541  ATH_CHECK( m_jetPileupLabelingTool.setProperty("SuppressOutputDependence", true) );
542  #endif
543  ATH_CHECK( m_jetPileupLabelingTool.setProperty("OutputLevel", this->msg().level()) );
544  ATH_CHECK( m_jetPileupLabelingTool.retrieve() );
545  } else if (m_jetPileupLabelingTool.isUserConfigured()) ATH_CHECK( m_jetPileupLabelingTool.retrieve() );
546 
548  // Initialise jet NNJvt moment tool
549 
550  m_applyJVTCut = !m_JvtWP.empty();
551  if (!m_jetNNJvtMomentTool.isUserConfigured() && m_applyJVTCut) {
552  toolName = "NNJvtMomentTool";
553  m_jetNNJvtMomentTool.setTypeAndName("JetPileupTag::JetVertexNNTagger/"+toolName);
554  ATH_CHECK( m_jetNNJvtMomentTool.setProperty("JetContainer", m_defaultJets) );
555  #ifndef XAOD_STANDALONE
556  ATH_CHECK( m_jetNNJvtMomentTool.setProperty("SuppressInputDependence", true) );
557  ATH_CHECK( m_jetNNJvtMomentTool.setProperty("SuppressOutputDependence", true) );
558  #endif
559  ATH_CHECK( m_jetNNJvtMomentTool.setProperty("OutputLevel", this->msg().level()) );
560  ATH_CHECK( m_jetNNJvtMomentTool.retrieve() );
561  } else if (m_jetNNJvtMomentTool.isUserConfigured()) ATH_CHECK( m_jetNNJvtMomentTool.retrieve() );
562 
564  // Initialise jet NNJvt selection tool
565 
566  if (!m_jetNNJvtSelectionTool.isUserConfigured() && m_applyJVTCut) {
567  toolName = "NNJvtSelectionTool";
568  m_jetNNJvtSelectionTool.setTypeAndName("CP::NNJvtSelectionTool/"+toolName);
569  ATH_CHECK( m_jetNNJvtSelectionTool.setProperty("JetContainer", m_defaultJets) );
570  ATH_CHECK( m_jetNNJvtSelectionTool.setProperty("WorkingPoint", m_JvtWP) );
571  ATH_CHECK( m_jetNNJvtSelectionTool.setProperty("MaxPtForJvt", m_JvtPtMax) );
572  ATH_CHECK( m_jetNNJvtSelectionTool.setProperty("JvtMomentName", "NNJvt") );
573  ATH_CHECK( m_jetNNJvtSelectionTool.setProperty("OutputLevel", this->msg().level()) );
574  ATH_CHECK( m_jetNNJvtSelectionTool.retrieve() );
575  } else if (m_jetNNJvtSelectionTool.isUserConfigured()) ATH_CHECK( m_jetNNJvtSelectionTool.retrieve() );
576 
578  // Initialise jet NNJvt efficiency tool (scale factors)
579 
580  if (!m_jetNNJvtEfficiencyTool.isUserConfigured() && m_applyJVTCut) {
581  toolName = "NNJvtEfficiencyTool";
582  m_jetNNJvtEfficiencyTool.setTypeAndName("CP::NNJvtEfficiencyTool/"+toolName);
583  ATH_CHECK( m_jetNNJvtEfficiencyTool.setProperty("JetContainer", m_defaultJets) );
584  ATH_CHECK( m_jetNNJvtEfficiencyTool.setProperty("WorkingPoint", m_JvtWP) );
585  ATH_CHECK( m_jetNNJvtEfficiencyTool.setProperty("MaxPtForJvt", m_JvtPtMax) );
586  ATH_CHECK( m_jetNNJvtEfficiencyTool.setProperty("SFFile", m_isRun3 ? m_JvtConfigRun3 : m_JvtConfigRun2) );
587  ATH_CHECK( m_jetNNJvtEfficiencyTool.setProperty("OutputLevel", this->msg().level()) );
588  ATH_CHECK( m_jetNNJvtEfficiencyTool.retrieve() );
589  } else if (m_jetNNJvtEfficiencyTool.isUserConfigured()) ATH_CHECK( m_jetNNJvtEfficiencyTool.retrieve() );
590 
592  // Initialise jet fJvt selection tool
593 
594  if (!m_jetfJvtSelectionTool.isUserConfigured() && m_doFwdJVT) {
595  toolName = "fJvtSelectionTool";
596  m_jetfJvtSelectionTool.setTypeAndName("CP::FJvtSelectionTool/"+toolName);
597  ATH_CHECK( m_jetfJvtSelectionTool.setProperty("JetContainer", m_defaultJets) );
598  ATH_CHECK( m_jetfJvtSelectionTool.setProperty("WorkingPoint", m_fJvtWP) );
599  ATH_CHECK( m_jetfJvtSelectionTool.setProperty("MaxPtForJvt", m_fJvtPtMax) );
600  ATH_CHECK( m_jetfJvtSelectionTool.setProperty("JvtMomentName", "DFCommonJets_fJvt") );
601  ATH_CHECK( m_jetfJvtSelectionTool.setProperty("OutputLevel", this->msg().level()) );
602  ATH_CHECK( m_jetfJvtSelectionTool.retrieve() );
603  } else if (m_jetfJvtSelectionTool.isUserConfigured()) ATH_CHECK( m_jetfJvtSelectionTool.retrieve() );
604 
606  // Initialise jet fJvt efficiency tool for scale factors (scale factors)
607 
608  if (!m_jetfJvtEfficiencyTool.isUserConfigured() && m_doFwdJVT) {
609  toolName = "fJvtEfficiencyTool";
610  m_jetfJvtEfficiencyTool.setTypeAndName("CP::FJvtEfficiencyTool/"+toolName);
611  ATH_CHECK( m_jetfJvtEfficiencyTool.setProperty("JetContainer", m_defaultJets) );
612  ATH_CHECK( m_jetfJvtEfficiencyTool.setProperty("WorkingPoint", m_fJvtWP) );
613  ATH_CHECK( m_jetfJvtEfficiencyTool.setProperty("MaxPtForJvt", m_fJvtPtMax) );
614  ATH_CHECK( m_jetfJvtEfficiencyTool.setProperty("SFFile", m_isRun3 ? m_fJvtConfigRun3 : m_fJvtConfigRun2) );
615  ATH_CHECK( m_jetfJvtEfficiencyTool.setProperty("OutputLevel", this->msg().level()) );
616  ATH_CHECK( m_jetfJvtEfficiencyTool.retrieve() );
617  } else ATH_CHECK( m_jetfJvtEfficiencyTool.retrieve() );
618  }
619 
620 
621  if (m_slices["mu"]) {
623  // Check muon baseline ID
624 
625  std::string muQualBaseline = "";
626  switch (m_muIdBaseline) {
627  case xAOD::Muon::VeryLoose: muQualBaseline = "VeryLoose";
628  ATH_MSG_WARNING("No muon scale factors are available for VeryLoose working point.");
629  break;
630  case xAOD::Muon::Loose: muQualBaseline = "Loose"; break;
631  case xAOD::Muon::Medium: muQualBaseline = "Medium"; break;
632  case xAOD::Muon::Tight: muQualBaseline = "Tight"; break;
633  case 4: muQualBaseline = "HighPt"; break;
634  case 5: muQualBaseline = "LowPt"; break;
635  case 6: muQualBaseline = "LowPtMVA"; break;
636  case 7: muQualBaseline = "HighPt3Layers"; break;
637  default:
638  ATH_MSG_ERROR("Invalid muon working point provided: " << m_muIdBaseline << ". Cannot initialise!");
639  return StatusCode::FAILURE;
640  break;
641  }
642 
644  // Initialise muon calibration tool
645  // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/MuonMomentumCorrectionsSubgroup#CP_MuonCalibrationAndSmearingToo
646  // Please not that for AthAnalysis we need to configure the MuonCalibTool within METSignificance manually and just can't pass the handle
647  // Hence, any changes here should also be propagated to the METSignificance setup further below
648 
649  if (!m_muonCalibTool.isUserConfigured()) {
650  m_muonCalibTool.setTypeAndName("CP::MuonCalibTool/ST_MuonCalibrationTool");
651  if (m_isRun3) ATH_CHECK( m_muonCalibTool.setProperty("IsRun3Geo", true ));
652  ATH_CHECK( m_muonCalibTool.setProperty("calibMode", m_muCalibrationMode) );
653  ATH_CHECK( m_muonCalibTool.setProperty("OutputLevel", this->msg().level()) );
654  ATH_CHECK( m_muonCalibTool.setProperty("release", "Recs2024_05_06_Run2Run3" ));
655  int IdBaselineInt = m_muIdBaseline;
656  if (IdBaselineInt == 4) {
657  ATH_CHECK( m_muonCalibTool.setProperty("do2StationsHighPt", true) );
658  }
659  ATH_CHECK( m_muonCalibTool.setProperty("doExtraSmearing", m_muHighPtExtraSmear) );
660  ATH_CHECK( m_muonCalibTool.retrieve() );
661  } else ATH_CHECK( m_muonCalibTool.retrieve() );
662 
664  // Initialise muon selection tool
665 
666  if (!m_muonSelectionToolBaseline.isUserConfigured()) {
667  toolName = "MuonSelectionTool_Baseline_" + muQualBaseline;
668  m_muonSelectionToolBaseline.setTypeAndName("CP::MuonSelectionTool/"+toolName);
669  if (m_isRun3) ATH_CHECK( m_muonSelectionToolBaseline.setProperty("IsRun3Geo", true ));
670 
671  if (m_muBaselineEta<m_muEta){ // Test for inconsistent configuration
672  ATH_MSG_ERROR( "Requested a baseline eta cut for muons (" << m_muBaselineEta <<
673  ") that is tighter than the signal cut (" << m_muEta << "). Please check your config." );
674  return StatusCode::FAILURE;
675  }
676  int IdBaselineInt = m_muIdBaseline;
677  ATH_CHECK( m_muonSelectionToolBaseline.setProperty( "MaxEta", m_muBaselineEta) );
678  if (IdBaselineInt == 6){
679  ATH_CHECK( m_muonSelectionToolBaseline.setProperty( "MuQuality", 5 ) );
680  ATH_CHECK( m_muonSelectionToolBaseline.setProperty( "UseMVALowPt", true));
681  } else if (IdBaselineInt == 7){
682  ATH_CHECK( m_muonSelectionToolBaseline.setProperty( "MuQuality", 4 ) );
683  ATH_CHECK( m_muonSelectionToolBaseline.setProperty( "Use2stationMuonsHighPt", false));
684  } else ATH_CHECK(m_muonSelectionToolBaseline.setProperty( "MuQuality", m_muIdBaseline ));
685  ATH_CHECK( m_muonSelectionToolBaseline.setProperty("OutputLevel", this->msg().level()) );
686  ATH_CHECK( m_muonSelectionToolBaseline.retrieve() );
687  } else ATH_CHECK( m_muonSelectionToolBaseline.retrieve() );
688 
689 
690  std::string muQual = "";
691  switch (m_muId) {
692  case xAOD::Muon::VeryLoose: muQual = "VeryLoose";
693  ATH_MSG_WARNING("No muon scale factors are available for VeryLoose working point.");
694  break;
695  case xAOD::Muon::Loose: muQual = "Loose"; break;
696  case xAOD::Muon::Medium: muQual = "Medium"; break;
697  case xAOD::Muon::Tight: muQual = "Tight"; break;
698  case 4: muQual = "HighPt"; break;
699  case 5: muQual = "LowPt"; break;
700  case 6: muQual = "LowPtMVA"; break;
701  case 7: muQual = "HighPt3Layers"; break;
702  default:
703  ATH_MSG_ERROR("Invalid muon working point provided: " << m_muId << ". Cannot initialise!");
704  return StatusCode::FAILURE;
705  break;
706  }
707 
708  if (!m_muonSelectionTool.isUserConfigured()) {
709  toolName = "MuonSelectionTool_" + muQual;
710  m_muonSelectionTool.setTypeAndName("CP::MuonSelectionTool/"+toolName);
711  if (m_isRun3) ATH_CHECK( m_muonSelectionTool.setProperty("IsRun3Geo", true ));
712  ATH_CHECK( m_muonSelectionTool.setProperty( "MaxEta", m_muEta) );
713  int IdInt = m_muId;
714  if (IdInt == 6){
715  ATH_CHECK( m_muonSelectionTool.setProperty( "MuQuality", 5 ) );
716  ATH_CHECK( m_muonSelectionTool.setProperty( "UseMVALowPt", true));
717  } else if (IdInt == 7){
718  ATH_CHECK( m_muonSelectionTool.setProperty( "MuQuality", 4 ) );
719  ATH_CHECK( m_muonSelectionTool.setProperty( "Use2stationMuonsHighPt", false));
720  } else ATH_CHECK(m_muonSelectionTool.setProperty( "MuQuality", m_muId ));
721  ATH_CHECK( m_muonSelectionTool.setProperty("OutputLevel", this->msg().level()) );
722  ATH_CHECK( m_muonSelectionTool.retrieve() );
723  } else ATH_CHECK( m_muonSelectionTool.retrieve() );
724 
725 
726  if (!m_muonSelectionHighPtTool.isUserConfigured()) { //Fixed to HighPt WP
727  toolName = "MuonSelectionHighPtTool_" + muQual;
728  m_muonSelectionHighPtTool.setTypeAndName("CP::MuonSelectionTool/"+toolName);
729  if (m_isRun3) ATH_CHECK( m_muonSelectionHighPtTool.setProperty("IsRun3Geo", true ));
730  ATH_CHECK( m_muonSelectionHighPtTool.setProperty( "MaxEta", m_muEta) );
731  ATH_CHECK( m_muonSelectionHighPtTool.setProperty( "MuQuality", 4 ) );
732  ATH_CHECK( m_muonSelectionHighPtTool.setProperty("OutputLevel", this->msg().level()) );
733  ATH_CHECK( m_muonSelectionHighPtTool.retrieve() );
734  } else ATH_CHECK( m_muonSelectionHighPtTool.retrieve() );
735 
736 
738  // Initialise prompt/LRT muon OR tool
739  if (!m_muonLRTORTool.isUserConfigured()) {
740  toolName = "MuonLRTOverlapRemovalTool";
741  m_muonLRTORTool.setTypeAndName("CP::MuonLRTOverlapRemovalTool/"+toolName);
742  ATH_CHECK( m_muonLRTORTool.setProperty("overlapStrategy", CP::IMuonLRTOverlapRemovalTool::defaultStrategy) );
743  if (m_isRun3) ATH_CHECK( m_muonLRTORTool.setProperty("UseRun3WP", true ));
744  ATH_CHECK( m_muonLRTORTool.setProperty("OutputLevel", this->msg().level()) );
745  ATH_CHECK( m_muonLRTORTool.retrieve() );
746  } else ATH_CHECK( m_muonLRTORTool.retrieve() );
747 
749  // Initialise muon efficiency tools
750  if (!m_muonEfficiencySFTool.isUserConfigured() && m_muId != xAOD::Muon::VeryLoose) {
751  toolName = "MuonEfficiencyScaleFactors_" + muQual;
752  m_muonEfficiencySFTool.setTypeAndName("CP::MuonEfficiencyScaleFactors/"+toolName);
753  ATH_CHECK( m_muonEfficiencySFTool.setProperty("WorkingPoint", muQual) );
754  ATH_CHECK( m_muonEfficiencySFTool.setProperty("CalibrationRelease", m_isRun3? "240711_Preliminary_r24run3":"230213_Preliminary_r22run2") );
755  ATH_CHECK( m_muonEfficiencySFTool.setProperty("OutputLevel", this->msg().level()) );
756  ATH_CHECK( m_muonEfficiencySFTool.retrieve() );
757  } else ATH_CHECK( m_muonEfficiencySFTool.retrieve() );
758 
759 
760  if (!m_muonEfficiencyBMHighPtSFTool.isUserConfigured()){
761  toolName = "MuonEfficiencyScaleFactorsBMHighPt_" + muQual;
762  m_muonEfficiencyBMHighPtSFTool.setTypeAndName("CP::MuonEfficiencyScaleFactors/"+toolName);
763  ATH_CHECK( m_muonEfficiencyBMHighPtSFTool.setProperty("WorkingPoint", "BadMuonVeto_HighPt") );
764  ATH_CHECK( m_muonEfficiencyBMHighPtSFTool.setProperty("CalibrationRelease", m_isRun3? "220817_Preliminary_r22run3":"230213_Preliminary_r22run2") ); //BadMuonVeto_HighPt currently not available for 240711_Preliminary_r24run3
765  ATH_CHECK( m_muonEfficiencyBMHighPtSFTool.setProperty("OutputLevel", this->msg().level()) );
766  ATH_CHECK( m_muonEfficiencyBMHighPtSFTool.retrieve() );
767  } else ATH_CHECK( m_muonEfficiencyBMHighPtSFTool.retrieve() );
768 
769 
770  if (m_doTTVAsf && m_mud0sig<0 && m_muz0<0){
771  ATH_MSG_WARNING("Requested TTVA SFs without d0sig and z0 cuts. Disabling scale factors as they will not make sense.");
772  m_doTTVAsf=false;
773  }
774 
775  if (m_doTTVAsf && !m_muonTTVAEfficiencySFTool.isUserConfigured()) {
776  toolName = "MuonTTVAEfficiencyScaleFactors";
777  m_muonTTVAEfficiencySFTool.setTypeAndName("CP::MuonEfficiencyScaleFactors/"+toolName);
778  ATH_CHECK( m_muonTTVAEfficiencySFTool.setProperty("WorkingPoint", "TTVA") );
779  ATH_CHECK( m_muonTTVAEfficiencySFTool.setProperty("CalibrationRelease", m_isRun3? "240711_Preliminary_r24run3":"230213_Preliminary_r22run2") );
780  ATH_CHECK( m_muonTTVAEfficiencySFTool.setProperty("OutputLevel", this->msg().level()) );
781  ATH_CHECK( m_muonTTVAEfficiencySFTool.retrieve() );
782  } else if (m_muonTTVAEfficiencySFTool.isUserConfigured()) ATH_CHECK( m_muonTTVAEfficiencySFTool.retrieve() );
783 
784 
785 
787  // Initialise muon isolation tool
788  if (!m_muonIsolationSFTool.isUserConfigured() && !m_muIso_WP.empty()) {
789  toolName = "MuonIsolationScaleFactors_" + m_muIso_WP;
790 
791  std::string tmp_muIso_WP = m_muIso_WP;
792  if ( !check_isOption(m_muIso_WP, m_mu_iso_support) ) { //check if supported
793  ATH_MSG_WARNING("Your selected muon Iso WP ("
794  << m_muIso_WP
795  << ") does not have SFs defined. Will try to find an appropriate fall-back.");
796  if (m_mu_iso_fallback.count(m_muIso_WP) > 0){
797  tmp_muIso_WP = m_mu_iso_fallback[m_muIso_WP];
798  ATH_MSG_WARNING("Your selected muon Iso WP ("
799  << m_muIso_WP
800  << " is not supported, and does not have SFs available. Falling back to "
801  << tmp_muIso_WP
802  << " for SF determination.");
803  } else {
804  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! ***");
805  return StatusCode::FAILURE;
806  }
807  }
808 
809  m_muonIsolationSFTool.setTypeAndName("CP::MuonEfficiencyScaleFactors/"+toolName);
810  ATH_CHECK( m_muonIsolationSFTool.setProperty("WorkingPoint", tmp_muIso_WP + "Iso") );
811  ATH_CHECK( m_muonIsolationSFTool.setProperty("CalibrationRelease", m_isRun3? "240711_Preliminary_r24run3":"230213_Preliminary_r22run2") );
812  ATH_CHECK( m_muonIsolationSFTool.setProperty("OutputLevel", this->msg().level()) );
813  ATH_CHECK( m_muonIsolationSFTool.retrieve() );
814 
815  } else if (m_muonIsolationSFTool.isUserConfigured()) ATH_CHECK( m_muonIsolationSFTool.retrieve() );
816 
817 
818  if (!m_muonHighPtIsolationSFTool.isUserConfigured() && !m_muIsoHighPt_WP.empty()) {
819  toolName = "MuonHighPtIsolationScaleFactors_" + m_muIsoHighPt_WP;
820 
821  std::string tmp_muIsoHighPt_WP = m_muIsoHighPt_WP;
822  if ( !check_isOption(m_muIsoHighPt_WP, m_mu_iso_support) ) { //check if supported
823  ATH_MSG_WARNING("Your selected muon high-pt Iso WP ("
824  << m_muIsoHighPt_WP
825  << ") does not have SFs defined. Will try to find an appropriate fall-back.");
826  if (m_mu_iso_fallback.count(m_muIsoHighPt_WP) > 0){
827  tmp_muIsoHighPt_WP = m_mu_iso_fallback[m_muIsoHighPt_WP];
828  ATH_MSG_WARNING("Your selected muon high-pt Iso WP ("
829  << m_muIsoHighPt_WP
830  << " is not supported, and does not have SFs available. Falling back to "
831  << tmp_muIsoHighPt_WP
832  << " for SF determination.");
833  } else {
834  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! ***");
835  return StatusCode::FAILURE;
836  }
837  }
838 
839  m_muonHighPtIsolationSFTool.setTypeAndName("CP::MuonEfficiencyScaleFactors/"+toolName);
840  // Use for the low-pt WP a dedicated set of isolation scale-factors having an extra uncertainty in place
841  ATH_CHECK( m_muonHighPtIsolationSFTool.setProperty("WorkingPoint", tmp_muIsoHighPt_WP + "Iso") );
842  ATH_CHECK( m_muonHighPtIsolationSFTool.setProperty("CalibrationRelease", m_isRun3? "240711_Preliminary_r24run3":"230213_Preliminary_r22run2") );
843  ATH_CHECK( m_muonHighPtIsolationSFTool.setProperty("OutputLevel", this->msg().level()) );
844  ATH_CHECK( m_muonHighPtIsolationSFTool.retrieve() );
845 
846  } else if (m_muonHighPtIsolationSFTool.isUserConfigured()) ATH_CHECK( m_muonHighPtIsolationSFTool.retrieve() );
847 
848 
850  // Initialise muon trigger scale factor tools
851 
852  if (!m_muonTriggerSFTool.isUserConfigured()) {
853  toolName = "MuonTriggerScaleFactors_" + muQual;
854  m_muonTriggerSFTool.setTypeAndName("CP::MuonTriggerScaleFactors/"+toolName);
855  if ( muQual=="LowPt" ) {
856  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!");
857  ATH_CHECK( m_muonTriggerSFTool.setProperty("MuonQuality", "Medium" ) );
858  }
859  else ATH_CHECK( m_muonTriggerSFTool.setProperty("MuonQuality", muQual) );
860  //ATH_CHECK( m_muonTriggerSFTool.setProperty("Isolation", m_muIso_WP)); This property has been depreacted long time ago
861  ATH_CHECK( m_muonTriggerSFTool.setProperty("AllowZeroSF", true) );
862  ATH_CHECK( m_muonTriggerSFTool.setProperty("OutputLevel", this->msg().level()) );
863  ATH_CHECK( m_muonTriggerSFTool.retrieve() );
864  m_muonTrigSFTools.push_back(m_muonTriggerSFTool.getHandle());
865  } else {
866  ATH_CHECK( m_muonTriggerSFTool.retrieve() );
867  m_muonTrigSFTools.push_back(m_muonTriggerSFTool.getHandle());
868  }
869  }
870 
871  if (m_slices["ele"]) {
872  // /////////////////////////////////////////////////////////////////////////////////////////
873  // Initialise electron selector tools
874 
875  // Signal Electrons
876  if (!m_elecSelLikelihood.isUserConfigured()) {
877  toolName = "EleSelLikelihood_" + m_eleId;
878 
879  if (m_eleId.find("DNN") != std::string::npos) {
880  m_elecSelLikelihood.setTypeAndName("AsgElectronSelectorTool/"+toolName);
881  }
882  else {
883  m_elecSelLikelihood.setTypeAndName("AsgElectronLikelihoodTool/"+toolName);
884  }
885 
886  if (! m_eleConfig.empty() ){
887  ATH_MSG_INFO("Overriding specified Ele.Id working point in favour of configuration file");
888  ATH_CHECK( m_elecSelLikelihood.setProperty("ConfigFile", m_eleConfig) );
889  } else if ( !check_isOption(m_eleId, m_el_id_support) ) { //check if supported
890  ATH_MSG_ERROR("Invalid electron ID selected: " << m_eleId);
891  return StatusCode::FAILURE;
892  }
893  else if (m_eleId == "VeryLooseLLH" || m_eleId == "LooseLLH") {
894  ATH_MSG_WARNING(" ****************************************************************************");
895  ATH_MSG_WARNING(" CAUTION: Setting " << m_eleId << " as signal electron ID");
896  ATH_MSG_WARNING(" These may be used for loose electron CRs but no scale factors are provided.");
897  ATH_MSG_WARNING(" ****************************************************************************");
898  ATH_CHECK( m_elecSelLikelihood.setProperty("WorkingPoint", EG_WP(m_eleId) ));
899  } else {
900  ATH_CHECK( m_elecSelLikelihood.setProperty("WorkingPoint", EG_WP(m_eleId) ));
901  }
902 
903  ATH_CHECK( m_elecSelLikelihood.setProperty("OutputLevel", this->msg().level()) );
904  ATH_CHECK( m_elecSelLikelihood.retrieve() );
905  } else ATH_CHECK( m_elecSelLikelihood.retrieve() );
906 
907  // Baseline Electrons
908  if (!m_elecSelLikelihoodBaseline.isUserConfigured()) {
909  toolName = "EleSelLikelihoodBaseline_" + m_eleIdBaseline;
910 
911  if (m_eleIdBaseline.find("DNN") != std::string::npos) {
912  m_elecSelLikelihoodBaseline.setTypeAndName("AsgElectronSelectorTool/"+toolName);
913  }
914  else {
915  m_elecSelLikelihoodBaseline.setTypeAndName("AsgElectronLikelihoodTool/"+toolName);
916  }
917 
918  if (! m_eleConfigBaseline.empty() ){
919  ATH_MSG_INFO("Overriding specified EleBaseline.Id working point in favour of configuration file");
920  ATH_CHECK( m_elecSelLikelihoodBaseline.setProperty("ConfigFile", m_eleConfigBaseline ));
921  } else if ( !check_isOption(m_eleIdBaseline, m_el_id_support) ) { //check if supported
922  ATH_MSG_ERROR("Invalid electron ID selected: " << m_eleIdBaseline);
923  return StatusCode::FAILURE;
924  } else {
925  ATH_CHECK( m_elecSelLikelihoodBaseline.setProperty("WorkingPoint", EG_WP(m_eleIdBaseline)) );
926  }
927 
928  ATH_CHECK( m_elecSelLikelihoodBaseline.setProperty("OutputLevel", this->msg().level()) );
929  ATH_CHECK( m_elecSelLikelihoodBaseline.retrieve() );
930  } else ATH_CHECK( m_elecSelLikelihoodBaseline.retrieve() );
931  }
932 
934  // Initialise prompt/LRT electron OR tool
935  if (!m_elecLRTORTool.isUserConfigured()) {
936  toolName = "ElectronLRTOverlapRemovalTool";
937  m_elecLRTORTool.setTypeAndName("CP::ElectronLRTOverlapRemovalTool/"+toolName);
938  ATH_MSG_DEBUG("Setting ElectronLRTOverlapRemovalTool strategy to "<<m_eleLRT_strat);
939  ATH_CHECK( m_elecLRTORTool.setProperty("overlapStrategy", m_eleLRT_strat) );
940  ATH_CHECK( m_elecLRTORTool.retrieve() );
941  } else ATH_CHECK( m_elecLRTORTool.retrieve() );
942 
943  if (m_slices["pho"]) {
944  // /////////////////////////////////////////////////////////////////////////////////////////
945  // Initialise photon selector tools
946 
947  if (!m_photonSelIsEM.isUserConfigured()) {
948  toolName = "PhotonSelIsEM_" + m_photonId;
949  m_photonSelIsEM.setTypeAndName("AsgPhotonIsEMSelector/"+toolName);
950 
951  if (!check_isOption(m_photonId, m_ph_id_support)){ //check if supported
952  ATH_MSG_ERROR("Invalid photon ID selected: " << m_photonId);
953  return StatusCode::FAILURE;
954  }
955 
956  ATH_CHECK( m_photonSelIsEM.setProperty("WorkingPoint", m_photonId+"Photon") );
957  ATH_CHECK( m_photonSelIsEM.setProperty("OutputLevel", this->msg().level()) );
958  ATH_CHECK( m_photonSelIsEM.retrieve() );
959  } else ATH_CHECK( m_photonSelIsEM.retrieve() );
960 
961  if (!m_photonSelIsEMBaseline.isUserConfigured()) {
962  toolName = "PhotonSelIsEMBaseline_" + m_photonIdBaseline;
963  m_photonSelIsEMBaseline.setTypeAndName("AsgPhotonIsEMSelector/"+toolName);
964 
965  if(!check_isOption(m_photonIdBaseline, m_ph_id_support)){ //check if supported
966  ATH_MSG_ERROR("Invalid photon ID selected: " << m_photonIdBaseline);
967  return StatusCode::FAILURE;
968  }
969 
970  ATH_CHECK( m_photonSelIsEMBaseline.setProperty("WorkingPoint", m_photonIdBaseline+"Photon") );
971  ATH_CHECK( m_photonSelIsEMBaseline.setProperty("OutputLevel", this->msg().level()) );
972  ATH_CHECK( m_photonSelIsEMBaseline.retrieve() );
973  } else ATH_CHECK( m_photonSelIsEMBaseline.retrieve() );
974  }
975 
976  if (m_slices["ele"]||m_slices["pho"]) {
978  // Initialise DeadHVCellRemovalTool
979  // https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/EGammaIdentificationRun2#Removal_of_Electron_Photon_clust
980 
981  ATH_MSG_DEBUG("Setup AsgDeadHVCellRemovalTool/deadHVTool");
982  m_deadHVTool.setTypeAndName("AsgDeadHVCellRemovalTool/deadHVTool");
983  ATH_CHECK(m_deadHVTool.retrieve());
984  }
985 
986  if (m_slices["ele"]) {
988  // Initialise electron efficiency tool
989 
990  PATCore::ParticleDataType::DataType data_type(PATCore::ParticleDataType::Data);
991  if (!isData()) {
992  if (isAtlfast()) data_type = PATCore::ParticleDataType::Fast;
993  else data_type = PATCore::ParticleDataType::Full;
994  ATH_MSG_DEBUG( "Setting data type to " << data_type);
995  }
996 
997  m_eleEffMapFilePathRun2 = "ElectronEfficiencyCorrection/2015_2018/rel21.2/Precision_Summer2020_v1/map4.txt";
998 
999  if(!m_isRun3) {
1000  ATH_MSG_INFO( "Running on Run2 samples; Using egamma SF tools from R21 map ");
1001  ATH_MSG_INFO( m_eleEffMapFilePathRun2);
1002  }
1003 
1004  toolName = "AsgElectronEfficiencyCorrectionTool_reco";
1005  CONFIG_EG_EFF_TOOL_KEY(m_elecEfficiencySFTool_reco, toolName, "RecoKey", "Reconstruction", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2);
1006 
1007  //-- get KEYS supported by egamma SF tools
1008  std::vector<std::string> eSF_keys = getElSFkeys( m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2);
1009 
1010  if (m_eleId.find("NoPix") != std::string::npos || m_eleId == "VeryLooseLLH" || m_eleId == "LooseLLH" || m_eleId == "Medium") {
1011  ATH_MSG_WARNING("Not configuring electron ID and trigger scale factors for " << m_eleId);
1012  }
1013  else {
1014  // This needs to be formatted for the scale factors: no _Rel20, no LH label, etc.
1015  std::string eleId = TString(m_eleId).ReplaceAll("AndBLayer", "BLayer").ReplaceAll("LLH", "").Data();
1016 
1017  if (m_eleId.find("DNN") != std::string::npos) {
1018  eleId = TString(eleId).ReplaceAll("DNNnoCF", "").ReplaceAll("DNN", "").ReplaceAll("Loose", "LooseBLayer").Data();
1019  ATH_MSG_WARNING("Electron DNN ID working point " << m_eleId << " doesn't have SFs yet, fall back to " << eleId);
1020  }
1021 
1022  // electron id
1023  toolName = "AsgElectronEfficiencyCorrectionTool_id_" + m_eleId;
1024  CONFIG_EG_EFF_TOOL_KEY(m_elecEfficiencySFTool_id, toolName, "IdKey", eleId, m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2);
1025 
1026  // override map file use if correction file list is set for WP
1027  std::map<std::string,std::string> corrFNList;
1028  if ( !m_EG_corrFNList.empty() ) {
1029  for ( const auto& WP_fname : split( m_EG_corrFNList, "," ) ) {
1030  std::string WP = WP_fname.substr(0,WP_fname.find(":"));
1031  std::string fname = WP_fname.substr(WP_fname.find(":")+1);
1032  corrFNList[WP] = fname;
1033  ATH_MSG_WARNING( "Correction file list defined for WP " << WP << ": " << fname << "." );
1034  ATH_MSG_WARNING( "Will use correction file rather than central map file." );
1035  }
1036  }
1037 
1038  // electron iso
1039  std::string EleIso("");
1040  if (std::find(eSF_keys.begin(), eSF_keys.end(), eleId+"_"+m_eleIso_WP) != eSF_keys.end()){
1041  EleIso = m_eleIso_WP;
1042  } else if (std::find(eSF_keys.begin(), eSF_keys.end(), eleId+"_"+m_el_iso_fallback[m_eleIso_WP]) != eSF_keys.end()){
1043  //--- Check to see if the only issue is an unknown isolation working point
1044  EleIso = m_el_iso_fallback[m_eleIso_WP];
1045  ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool_iso_*) Your selected electron Iso WP ("
1046  << m_eleIso_WP
1047  << ") does not have iso SFs defined. Falling back to "
1048  << m_el_iso_fallback[m_eleIso_WP]
1049  << " for SF calculations");
1050  }
1051  else{
1052  ATH_MSG_ERROR("*** THE ELECTRON ISOLATION SF YOU SELECTED (" << m_eleIso_WP << ") GOT NO SUPPORT ***");
1053  return StatusCode::FAILURE;
1054  }
1055 
1056  toolName = "AsgElectronEfficiencyCorrectionTool_iso_" + m_eleId + EleIso;
1057 
1058  // if running with correction file list
1059  if ( (!m_EG_corrFNList.empty()) && corrFNList.find(EleIso)!=corrFNList.end() ) { // overriding central map file
1060  CONFIG_EG_EFF_TOOL( m_elecEfficiencySFTool_iso, toolName, corrFNList[EleIso] );
1061  }
1062  // can't do the iso tool via the macro, it needs two properties set
1063  else { // default: use map file
1064  if ( !m_elecEfficiencySFTool_iso.isUserConfigured() ) {
1065  if ( !check_isOption(EleIso, m_el_iso_support) ) { //check if supported
1066  ATH_MSG_WARNING( "(" << toolName << ") Your electron Iso WP: " << EleIso<< " is no longer supported. This will almost certainly cause a crash now.");
1067  }
1068 
1069  m_elecEfficiencySFTool_iso.setTypeAndName("AsgElectronEfficiencyCorrectionTool/"+toolName);
1070 
1071  if ( m_EG_corrFNList.empty() ) {
1072  ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
1073  } else {
1074  ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("CorrectionFileNameList", corrFNList) );
1075  }
1076  ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("IdKey", eleId) );
1077  ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("IsoKey", EleIso) );
1078  if (!isData() && ((EleIso.find("TightTrackOnly_VarRad")!=std::string::npos)||
1079  (EleIso.find("TightTrackOnly_FixedRad")!=std::string::npos)||
1080  (EleIso.find("Tight_VarRad")!=std::string::npos)||
1081  (EleIso.find("Loose_VarRad")!=std::string::npos))) {
1082  if (isAtlfast()) ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool/"+toolName+"). Your selected electron Iso WP (" + EleIso + ") don't have AFII SF. Falling back to FullSim");
1083  ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("ForceDataType", static_cast<int>(PATCore::ParticleDataType::Full)));
1084  }
1085  else if (!isData()){
1086  ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("ForceDataType", static_cast<int>(data_type)));
1087  }
1088  ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("CorrelationModel", m_EG_corrModel) );
1089  ATH_CHECK( m_elecEfficiencySFTool_iso.setProperty("OutputLevel", this->msg().level()) );
1090  ATH_CHECK( m_elecEfficiencySFTool_iso.initialize() );
1091  } else ATH_CHECK( m_elecEfficiencySFTool_iso.initialize() );
1092  }
1093 
1094  // electron iso high-pt
1095  std::string EleIsohighPt("");
1096  if (std::find(eSF_keys.begin(), eSF_keys.end(), eleId+"_"+m_eleIsoHighPt_WP) != eSF_keys.end()){
1097  EleIsohighPt = m_eleIsoHighPt_WP;
1098  } else if (std::find(eSF_keys.begin(), eSF_keys.end(), eleId+"_"+m_el_iso_fallback[m_eleIsoHighPt_WP]) != eSF_keys.end()){
1099  //--- Check to see if the only issue is an unknown isolation working point
1100  EleIsohighPt = m_el_iso_fallback[m_eleIsoHighPt_WP];
1101  ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool_iso_*) Your selected high-pT electron Iso WP ("
1102  << m_eleIsoHighPt_WP
1103  << ") does not have iso SFs defined. Falling back to "
1104  << m_el_iso_fallback[m_eleIsoHighPt_WP]
1105  << " for SF calculations");
1106  }
1107  else{
1108  ATH_MSG_ERROR("*** THE HIGH PT ELECTRON ISOLATION SF YOU SELECTED (" << m_eleIsoHighPt_WP << ") GOT NO SUPPORT");
1109  return StatusCode::FAILURE;
1110  }
1111 
1112  toolName = "AsgElectronEfficiencyCorrectionTool_isoHigPt_" + m_eleId + EleIsohighPt;
1113 
1114  // if running with correction file list
1115  if ( (!m_EG_corrFNList.empty()) && corrFNList.find(EleIsohighPt)!=corrFNList.end() ) { // overriding central map file
1116  CONFIG_EG_EFF_TOOL( m_elecEfficiencySFTool_isoHighPt, toolName, corrFNList[EleIsohighPt] );
1117  }
1118  // can't do the iso tool via the macro, it needs two properties set
1119  else { // default: use map file
1120  if ( !m_elecEfficiencySFTool_isoHighPt.isUserConfigured() ) {
1121 
1122  if ( !check_isOption(EleIsohighPt, m_el_iso_support) ) { //check if supported
1123  ATH_MSG_WARNING( "(" << toolName << ") Your electron high-pt Iso WP: " << EleIsohighPt << " is no longer supported. This will almost certainly cause a crash now.");
1124  }
1125 
1126  m_elecEfficiencySFTool_isoHighPt.setTypeAndName("AsgElectronEfficiencyCorrectionTool/"+toolName);
1127 
1128  ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
1129  ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.setProperty("IdKey", eleId) );
1130  ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.setProperty("IsoKey", EleIsohighPt) );
1131  if (!isData()) {
1132  ATH_CHECK (m_elecEfficiencySFTool_isoHighPt.setProperty("ForceDataType", (int) data_type) );
1133  }
1134  ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.setProperty("CorrelationModel", m_EG_corrModel) );
1135  ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.setProperty("OutputLevel", this->msg().level()) );
1136  ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.initialize() );
1137  } else ATH_CHECK( m_elecEfficiencySFTool_isoHighPt.initialize() );
1138  }
1139 
1140  // electron triggers - first SFs (but we need to massage the id string since all combinations are not supported)
1141 
1142  //single lepton
1143 
1144  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);
1145  std::string triggerEleID = m_isRun3? TString(eleId).ReplaceAll("LooseBLayer", "Loose").Data() : eleId;
1146  std::string triggerEleIso= m_eleIso_WP;
1147 
1148  // This is an hack to work with ElectronEfficiencyCorrection/2015_2025/rel22.2/2022_Summer_Prerecom_v1/map4.txt to allow
1149 
1150  if(m_isRun3 && m_eleAllowRun3TrigSFFallback){
1151  bool pass_isRun3TrigSFFallback = true;
1152  if (triggerEleID.find("Medium") != std::string::npos && triggerEleIso.find("Loose") != std::string::npos) {triggerEleID = "Loose";}
1153  else if (triggerEleID.find("Medium") != std::string::npos && triggerEleIso.find("Tight") != std::string::npos) {triggerEleID = "Tight"; triggerEleIso = "Tight_VarRad";}
1154  else if (triggerEleID.find("Medium") != std::string::npos && triggerEleIso.find("HighPtCaloOnly") != std::string::npos) {triggerEleID = "Tight"; triggerEleIso = "Tight_VarRad";}
1155  else if (triggerEleID.find("Tight") != std::string::npos && triggerEleIso.find("Loose") != std::string::npos) {triggerEleID = "Loose";}
1156  else if (triggerEleID.find("Tight") != std::string::npos && triggerEleIso.find("Tight") != std::string::npos) {triggerEleIso= "Tight_VarRad";}
1157  else if (triggerEleID.find("Tight") != std::string::npos && triggerEleIso.find("HighPtCaloOnly") != std::string::npos) {triggerEleID = "Tight"; triggerEleIso = "Tight_VarRad";}
1158  else if (triggerEleID.find("Loose") != std::string::npos && triggerEleIso.find("Tight") != std::string::npos) {triggerEleID = "Loose"; triggerEleIso = "Loose_VarRad";}
1159  else if (triggerEleID.find("Loose") != std::string::npos && triggerEleIso.find("HighPtCaloOnly") != std::string::npos) {triggerEleID = "Loose"; triggerEleIso = "Loose_VarRad";}
1160  else {pass_isRun3TrigSFFallback=false;}
1161  if(pass_isRun3TrigSFFallback){
1162  ATH_MSG_INFO(" ************** This is only for testing/studying purpose! ************** ");
1163  ATH_MSG_INFO(" ************** For official recommendation, please get in contact with the SUSY Bkg Forum ************** ");
1164  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' ");
1165  ATH_MSG_INFO("Only for single-lepton trigger scale factor, fall back to Electron ID: -> "<< triggerEleID << " with Isolation: " << triggerEleIso);
1166  }
1167  }
1168 
1169 
1170  ATH_MSG_INFO("eSF_keys: " << m_electronTriggerSFStringSingle<< "_"<<triggerEleID<<"_"<<triggerEleIso);
1171 
1172  if (std::find(eSF_keys.begin(), eSF_keys.end(), m_electronTriggerSFStringSingle+"_"+triggerEleID+"_"+triggerEleIso) != eSF_keys.end()){
1173  triggerEleIso = m_eleIso_WP;
1174  } else if (std::find(eSF_keys.begin(), eSF_keys.end(), m_electronTriggerSFStringSingle+"_"+triggerEleID+"_"+m_el_iso_fallback[triggerEleIso]) != eSF_keys.end()){
1175  //--- Check to see if the only issue is an unknown isolation working point
1176  triggerEleIso = m_el_iso_fallback[triggerEleIso];
1177  ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool_trig_singleLep_*) Your selected electron Iso WP ("
1178  << m_eleIso_WP
1179  << ") does not have trigger SFs defined. Falling back to "
1180  << triggerEleIso
1181  << " for SF calculations");
1182  }
1183  else{
1184  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 << ") ***");
1185  return StatusCode::FAILURE;
1186  }
1187 
1188  toolName = "AsgElectronEfficiencyCorrectionTool_trig_singleLep_" + triggerEleID;
1189  if ( !m_elecEfficiencySFTool_trig_singleLep.isUserConfigured() ) {
1190  m_elecEfficiencySFTool_trig_singleLep.setTypeAndName("AsgElectronEfficiencyCorrectionTool/"+toolName);
1191  ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
1192  ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("TriggerKey", m_electronTriggerSFStringSingle) );
1193  ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("IdKey", triggerEleID) );
1194  ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("IsoKey", triggerEleIso) );
1195  ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("CorrelationModel", m_EG_corrModel) );
1196  if (!isData()) {
1197  ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("ForceDataType", (int) (data_type==PATCore::ParticleDataType::Fast)? PATCore::ParticleDataType::Full : data_type) );
1198  }
1199  ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.setProperty("OutputLevel", this->msg().level()) );
1200  ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.initialize() );
1201  } else ATH_CHECK( m_elecEfficiencySFTool_trig_singleLep.retrieve() );
1202 
1203 
1204  toolName = "AsgElectronEfficiencyCorrectionTool_trigEff_singleLep_" + triggerEleID;
1205  if ( !m_elecEfficiencySFTool_trigEff_singleLep.isUserConfigured() ) {
1206  m_elecEfficiencySFTool_trigEff_singleLep.setTypeAndName("AsgElectronEfficiencyCorrectionTool/"+toolName);
1207  ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
1208  ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("TriggerKey", "Eff_"+m_electronTriggerSFStringSingle) );
1209  ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("IdKey", triggerEleID) );
1210  ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("IsoKey", triggerEleIso) );
1211  ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("CorrelationModel", m_EG_corrModel) );
1212  if (!isData()) {
1213  ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("ForceDataType", (int) (data_type==PATCore::ParticleDataType::Fast)? PATCore::ParticleDataType::Full : data_type) );
1214  }
1215  ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.setProperty("OutputLevel", this->msg().level()) );
1216  ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.initialize() );
1217  } else ATH_CHECK( m_elecEfficiencySFTool_trigEff_singleLep.retrieve() );
1218 
1219  if (!m_isRun3){
1220  //mixed-leptons
1221  std::map<std::string,std::string> electronTriggerSFMapMixedLepton {
1222  // legs, Trigger keys,
1223  {"e24_lhmedium_L1EM20VH_OR_e60_lhmedium_OR_e120_lhloose,e26_lhtight_nod0_ivarloose_OR_e60_lhmedium_nod0_OR_e140_lhloose_nod0", m_electronTriggerSFStringSingle},
1224  {"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"},
1225  {"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"},
1226  {"e17_lhloose,e17_lhloose_nod0","MULTI_L_2015_e17_lhloose_2016_2018_e17_lhloose_nod0"},
1227  {"e12_lhloose,e12_lhloose_nod0","MULTI_L_2015_e12_lhloose_2016_2018_e12_lhloose_nod0"},
1228  {"e7_lhmedium,e7_lhmedium_nod0","MULTI_L_2015_e7_lhmedium_2016_2018_e7_lhmedium_nod0"},
1229  {"e9_lhloose,e9_lhloose_nod0,e12_lhvloose_nod0_L1EM10VH","TRI_E_2015_e9_lhloose_2016_e9_lhloose_nod0_2017_2018_e12_lhvloose_nod0_L1EM10VH"}
1230 
1231  };
1232 
1233  // 2e17 trigger is used in 2017 or 2018?
1234  std::string triglist_2017to2018 = m_trig2017combination_diLep + "_" + m_trig2018combination_diLep + "_" + m_trig2017combination_multiLep + "_" + m_trig2018combination_multiLep;
1235  if (triglist_2017to2018.find("2e17_lhvloose_nod0_L12EM15VHI") != std::string::npos) {
1236  electronTriggerSFMapMixedLepton["e17_lhvloose_nod0_L1EM15VHI"] = "DI_E_2015_e12_lhloose_L1EM10VH_2016_e17_lhvloose_nod0_2017_2018_e17_lhvloose_nod0_L1EM15VHI";
1237  }
1238 
1239  std::string triggerMixedEleIso("");
1240 
1241  for(auto const& item : electronTriggerSFMapMixedLepton){
1242 
1243  if (std::find(eSF_keys.begin(), eSF_keys.end(), item.second+"_"+eleId+"_"+m_eleIso_WP) != eSF_keys.end()){
1244  triggerMixedEleIso = m_eleIso_WP;
1245  } else if (std::find(eSF_keys.begin(), eSF_keys.end(), item.second+"_"+eleId+"_"+m_el_iso_fallback[m_eleIso_WP]) != eSF_keys.end()){
1246  //--- Check to see if the only issue is an unknown isolation working point
1247  triggerMixedEleIso = m_el_iso_fallback[m_eleIso_WP];
1248  ATH_MSG_WARNING("(AsgElectronEfficiencyCorrectionTool_trig_mixLep_*) Your selected electron Iso WP ("
1249  << m_eleIso_WP
1250  << ") does not have trigger SFs defined. Falling back to "
1251  << triggerMixedEleIso
1252  << " for SF calculations");
1253  } else {
1254  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! ***");
1255  return StatusCode::FAILURE;
1256  }
1257 
1258  ATH_MSG_VERBOSE ("Selected WP: " << item.second << "_" << eleId << "_" << triggerMixedEleIso);
1259 
1260  toolName = "AsgElectronEfficiencyCorrectionTool_trig_mixLep_" + (item.first).substr(0,8) + m_eleId;
1261  auto t_sf = m_elecEfficiencySFTool_trig_mixLep.emplace(m_elecEfficiencySFTool_trig_mixLep.end(), "AsgElectronEfficiencyCorrectionTool/"+toolName);
1262  ATH_CHECK( t_sf->setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
1263  ATH_CHECK( t_sf->setProperty("TriggerKey", item.second) );
1264  ATH_CHECK( t_sf->setProperty("IdKey", eleId) );
1265  ATH_CHECK( t_sf->setProperty("IsoKey", triggerMixedEleIso) );
1266  ATH_CHECK( t_sf->setProperty("CorrelationModel", m_EG_corrModel) );
1267  if (!isData()) {
1268  ATH_CHECK( t_sf->setProperty("ForceDataType", (int) (data_type==PATCore::ParticleDataType::Fast)? PATCore::ParticleDataType::Full : data_type) );
1269  }
1270  ATH_CHECK( t_sf->setProperty("OutputLevel", this->msg().level()) );
1271  ATH_CHECK( t_sf->initialize() );
1272  m_elecTrigSFTools.push_back(t_sf->getHandle());
1273  #ifndef XAOD_STANDALONE
1274  m_legsPerTool[toolName] = item.first;
1275  #else
1276  m_legsPerTool["ToolSvc."+toolName] = item.first;
1277  #endif
1278 
1279  toolName = "AsgElectronEfficiencyCorrectionTool_trigEff_mixLep_" + (item.first).substr(0,8) + m_eleId;
1280  auto t_eff = m_elecEfficiencySFTool_trigEff_mixLep.emplace(m_elecEfficiencySFTool_trigEff_mixLep.end(), "AsgElectronEfficiencyCorrectionTool/"+toolName);
1281  ATH_CHECK( t_eff->setProperty("MapFilePath", m_isRun3? m_eleEffMapFilePath : m_eleEffMapFilePathRun2) );
1282  ATH_CHECK( t_eff->setProperty("TriggerKey", "Eff_"+item.second) );
1283  ATH_CHECK( t_eff->setProperty("IdKey", eleId) );
1284  ATH_CHECK( t_eff->setProperty("IsoKey", triggerMixedEleIso) );
1285  ATH_CHECK( t_eff->setProperty("CorrelationModel", m_EG_corrModel) );
1286  if (!isData()) {
1287  ATH_CHECK( t_eff->setProperty("ForceDataType", (int) (data_type==PATCore::ParticleDataType::Fast)? PATCore::ParticleDataType::Full : data_type) );
1288  }
1289  ATH_CHECK( t_eff->setProperty("OutputLevel", this->msg().level()) );
1290  ATH_CHECK( t_eff->initialize() );
1291  m_elecTrigEffTools.push_back(t_eff->getHandle());
1292  #ifndef XAOD_STANDALONE
1293  m_legsPerTool[toolName] = item.first;
1294  #else
1295  m_legsPerTool["ToolSvc."+toolName] = item.first;
1296  #endif
1297 
1298  }
1299  }
1300  else ATH_MSG_WARNING("*** THE ELECTRON TRIGGER SF MIXED AND SF DILEP ARE CURRENTY NOT SUPPORTED IN RUN3 ***");
1301 
1302  ATH_MSG_WARNING("*** THE ELECTRON CHARGE FLIP SF ARE CURRENTY NOT SUPPORTED ***");
1303  // all the iinitialisation of the related tools have been cleaned up
1304 
1305  }
1306 
1307  if (m_slices["pho"]) {
1308  // /////////////////////////////////////////////////////////////////////////////////////////
1309  // Initialise photon efficiency tool
1310 
1311  if (!m_photonEfficiencySFTool.isUserConfigured() && !isData()) {
1312  m_photonEfficiencySFTool.setTypeAndName("AsgPhotonEfficiencyCorrectionTool/AsgPhotonEfficiencyCorrectionTool_" + m_photonId);
1313 
1314  if (m_photonId != "Tight" ) {
1315  ATH_MSG_WARNING( "No Photon efficiency available for " << m_photonId << ", using Tight instead..." );
1316  }
1317 
1318  ATH_CHECK( m_photonEfficiencySFTool.setProperty("MapFilePath", m_isRun3? "PhotonEfficiencyCorrection/2015_2025/rel22.2/2022_Summer_Prerecom_v1/map0.txt":"PhotonEfficiencyCorrection/2015_2018/rel21.2/Summer2020_Rec_v1/map1.txt") );
1319  ATH_CHECK( m_photonEfficiencySFTool.setProperty("ForceDataType", 1) ); // Set data type: 1 for FULLSIM, 3 for AF2
1320  ATH_CHECK( m_photonEfficiencySFTool.setProperty("OutputLevel", this->msg().level()) );
1321  ATH_CHECK( m_photonEfficiencySFTool.retrieve() );
1322  } else if (m_photonEfficiencySFTool.isUserConfigured()) ATH_CHECK( m_photonEfficiencySFTool.retrieve() );
1323 
1324  if (!m_photonIsolationSFTool.isUserConfigured() && !isData()) {
1325  m_photonIsolationSFTool.setTypeAndName("AsgPhotonEfficiencyCorrectionTool/AsgPhotonEfficiencyCorrectionTool_isol" + m_photonIso_WP);
1326 
1327  if (m_photonIso_WP != "FixedCutTight" && m_photonIso_WP != "FixedCutLoose" && m_photonIso_WP != "FixedCutTightCaloOnly") {
1328  ATH_MSG_WARNING( "No Photon efficiency available for " << m_photonIso_WP);
1329  }
1330 
1331  ATH_CHECK( m_photonIsolationSFTool.setProperty("MapFilePath", "PhotonEfficiencyCorrection/2015_2018/rel21.2/Summer2020_Rec_v1/map1.txt") );
1332  ATH_CHECK( m_photonIsolationSFTool.setProperty("IsoKey", m_photonIso_WP.substr(8) )); // Set isolation WP: Loose,Tight,TightCaloOnly
1333  ATH_CHECK( m_photonIsolationSFTool.setProperty("ForceDataType", 1) ); // Set data type: 1 for FULLSIM, 3 for AF2
1334  ATH_CHECK( m_photonIsolationSFTool.setProperty("OutputLevel", this->msg().level()) );
1335  ATH_CHECK( m_photonIsolationSFTool.retrieve() );
1336  } else if (m_photonEfficiencySFTool.isUserConfigured()) ATH_CHECK( m_photonIsolationSFTool.retrieve() );
1337 
1338  // trigger scale factors
1339  if (!m_photonTriggerSFTool.isUserConfigured() && !isData()) {
1340  m_photonTriggerSFTool.setTypeAndName("AsgPhotonEfficiencyCorrectionTool/AsgPhotonEfficiencyCorrectionTool_trig" + m_photonTriggerName);
1341 
1342  // Fallback to TightCaloOnly if Tight is selected
1343  std::string photonIso_forTrigSF = m_photonIso_WP;
1344  if (m_photonIso_WP == "FixedCutTight") {
1345  ATH_MSG_WARNING( "No Photon trigger SF available for " << m_photonIso_WP << ", using TightCaloOnly instead... Use at your own risk" );
1346  photonIso_forTrigSF = "TightCaloOnly";
1347  } else { // isolation WP supported: Loose or TightCaloOnly, removing "FixedCut" suffix..
1348  photonIso_forTrigSF = TString(m_photonIso_WP).ReplaceAll("FixedCut","").Data();
1349  }
1350 
1351  // "symmetric" diphoton triggers (year dependent)
1352  ATH_CHECK( m_photonTriggerSFTool.setProperty("MapFilePath", "PhotonEfficiencyCorrection/2015_2018/rel21.2/Summer2020_Rec_v1/map1.txt") );
1353  ATH_CHECK( m_photonTriggerSFTool.setProperty("IsoKey", photonIso_forTrigSF )); // Set isolation WP: Loose,TightCaloOnly
1354  ATH_CHECK( m_photonTriggerSFTool.setProperty("TriggerKey", m_photonTriggerName ));
1355  ATH_CHECK( m_photonTriggerSFTool.setProperty("ForceDataType", 1) ); // Set data type: 1 for FULLSIM, 3 for AF2
1356  ATH_CHECK( m_photonTriggerSFTool.setProperty("OutputLevel", this->msg().level()) );
1357  ATH_CHECK( m_photonTriggerSFTool.retrieve() );
1358 
1359  // "asymmetric" diphoton triggers
1360  std::map<std::string,std::string> diphotonTriggerSFMapAsymmetric {
1361  // legs, Trigger keys,
1362  {"g25_loose,g25_medium_L1EM20VH", "DI_PH_2015_g25_loose_2016_g25_loose_2017_g25_medium_L1EM20VH_2018_g25_medium_L1EM20VH"},
1363  {"g35_loose,g35_medium_L1EM20VH", "DI_PH_2015_g35_loose_2016_g35_loose_2017_g35_medium_L1EM20VH_2018_g35_medium_L1EM20VH"},
1364  };
1365 
1366  for(auto const& item : diphotonTriggerSFMapAsymmetric){
1367 
1368  toolName = "AsgPhotonEfficiencyCorrectionTool_trigSF_asymm_diphoton_" + (item.first).substr(0,9) + photonIso_forTrigSF;
1369  auto ph_trigSF = m_photonEfficiencySFTool_trigSF_AsymDiphoton.emplace(m_photonEfficiencySFTool_trigSF_AsymDiphoton.end(), "AsgPhotonEfficiencyCorrectionTool/"+toolName);
1370  ATH_CHECK( ph_trigSF->setProperty("MapFilePath", "PhotonEfficiencyCorrection/2015_2018/rel21.2/Summer2020_Rec_v1/map1.txt") );
1371  ATH_CHECK( ph_trigSF->setProperty("IsoKey", photonIso_forTrigSF) );
1372  ATH_CHECK( ph_trigSF->setProperty("TriggerKey", item.second) );
1373  ATH_CHECK( ph_trigSF->setProperty("ForceDataType", 1) ); // Set DataType: 1 for FullSim and 3 for AFII
1374  ATH_CHECK( ph_trigSF->setProperty("OutputLevel", this->msg().level()) );
1375  ATH_CHECK( ph_trigSF->initialize() );
1376  m_photonTrigSFTools.push_back(ph_trigSF->getHandle());
1377  #ifndef XAOD_STANDALONE
1378  m_legsPerTool_ph[toolName] = item.first;
1379  #else
1380  m_legsPerTool_ph["ToolSvc."+toolName] = item.first;
1381  #endif
1382 
1383  toolName = "AsgPhotonEfficiencyCorrectionTool_trigEff_asymm_diphoton_" + (item.first).substr(0,9) + photonIso_forTrigSF;
1384  auto ph_trigEff = m_photonEfficiencySFTool_trigEff_AsymDiphoton.emplace(m_photonEfficiencySFTool_trigEff_AsymDiphoton.end(), "AsgPhotonEfficiencyCorrectionTool/"+toolName);
1385  ATH_CHECK( ph_trigEff->setProperty("MapFilePath", "PhotonEfficiencyCorrection/2015_2018/rel21.2/Summer2020_Rec_v1/map1.txt") );
1386  ATH_CHECK( ph_trigEff->setProperty("IsoKey", photonIso_forTrigSF) );
1387  ATH_CHECK( ph_trigEff->setProperty("TriggerKey", "Eff_"+item.second) );
1388  ATH_CHECK( ph_trigEff->setProperty("ForceDataType", 1) ); // Set DataType: 1 for FullSim and 3 for AFII
1389  ATH_CHECK( ph_trigEff->setProperty("OutputLevel", this->msg().level()) );
1390  ATH_CHECK( ph_trigEff->initialize() );
1391  m_photonTrigEffTools.push_back(ph_trigEff->getHandle());
1392  #ifndef XAOD_STANDALONE
1393  m_legsPerTool_ph[toolName] = item.first;
1394  #else
1395  m_legsPerTool_ph["ToolSvc."+toolName] = item.first;
1396  #endif
1397 
1398  }
1399  }
1400  }
1401 
1402  }
1403  if (m_slices["ele"] || m_slices["pho"]) {
1405  // Initialize the EgammaAmbiguityTool
1406 
1407  if (!m_egammaAmbiguityTool.isUserConfigured()) {
1408  m_egammaAmbiguityTool.setTypeAndName("EGammaAmbiguityTool/EGammaAmbiguityTool");
1409  ATH_CHECK( m_egammaAmbiguityTool.setProperty("OutputLevel", this->msg().level()) );
1410  ATH_CHECK( m_egammaAmbiguityTool.retrieve() );
1411  } else ATH_CHECK( m_egammaAmbiguityTool.retrieve() );
1412  }
1413 
1414 
1415  if (m_slices["ele"]) {
1416  //disable ///////////////////////////////////////////////////////////////////////////////////////////
1417  //disable // Initialize the AsgElectronChargeIDSelector
1418 
1419  //disable if (!m_elecChargeIDSelectorTool.isUserConfigured()) {
1420 
1421  //disable // For the selector, can use the nice function
1422  //disable std::string eleId = EG_WP(m_eleId);
1423  //disable m_elecChargeIDSelectorTool.setTypeAndName("AsgElectronChargeIDSelectorTool/ElectronChargeIDSelectorTool_"+eleId);
1424  //disable //default cut value for https://twiki.cern.ch/twiki/bin/view/AtlasProtected/ElectronChargeFlipTaggerTool
1425  //disable float BDTcut = -0.337671; // Loose 97%
1426  //disable if (m_eleChID_WP != "Loose" && !m_eleChID_WP.empty()) {
1427  //disable ATH_MSG_ERROR("Only Loose WP is supported in R21. Invalid ChargeIDSelector WP selected : " << m_eleChID_WP);
1428  //disable return StatusCode::FAILURE;
1429  //disable }
1430 
1431  //disable ATH_CHECK( m_elecChargeIDSelectorTool.setProperty("TrainingFile", "ElectronPhotonSelectorTools/ChargeID/ECIDS_20180731rel21Summer2018.root"));
1432  //disable ATH_CHECK( m_elecChargeIDSelectorTool.setProperty("CutOnBDT", BDTcut));
1433  //disable ATH_CHECK( m_elecChargeIDSelectorTool.setProperty("OutputLevel", this->msg().level()) );
1434  //disable ATH_CHECK( m_elecChargeIDSelectorTool.retrieve() );
1435  //disable } else ATH_CHECK( m_elecChargeIDSelectorTool.retrieve() );
1436 
1437 
1439  // Initialise egamma calibration tool
1440 
1441  if (!m_egammaCalibTool.isUserConfigured()) {
1442  m_egammaCalibTool.setTypeAndName("CP::EgammaCalibrationAndSmearingTool/EgammaCalibrationAndSmearingTool");
1443  ATH_MSG_DEBUG( "Initialising EgcalibTool " );
1444  ATH_CHECK( m_egammaCalibTool.setProperty("ESModel", m_isRun3 ? "es2022_R22_PRE" : "es2023_R22_Run2_v0") );
1445  ATH_CHECK( m_egammaCalibTool.setProperty("decorrelationModel", "1NP_v1") );
1446  ATH_CHECK( m_egammaCalibTool.setProperty("useFastSim", isAtlfast()?1:0) );
1447  ATH_CHECK( m_egammaCalibTool.setProperty("OutputLevel", this->msg().level()) );
1448  ATH_CHECK( m_egammaCalibTool.retrieve() );
1449  } else ATH_CHECK( m_egammaCalibTool.retrieve() );
1450  }
1451 
1452 
1453  if (m_slices["tau"]) {
1455 
1457  // Initialise path to tau config file and config reader
1458 
1459  std::string inputfile = "";
1460  if (!m_tauConfigPath.empty() && (m_tauConfigPath!="default")) inputfile = m_tauConfigPath;
1461  else if (m_tauId == "rnn001") inputfile = "SUSYTools/tau_selection_rnn001.conf";
1462  else if (m_tauId == "VeryLoose") inputfile = "SUSYTools/tau_selection_veryloose.conf";
1463  else if (m_tauId == "Loose") inputfile = "SUSYTools/tau_selection_loose.conf";
1464  else if (m_tauId == "Medium") inputfile = "SUSYTools/tau_selection_medium.conf";
1465  else if (m_tauId == "Tight") inputfile = "SUSYTools/tau_selection_tight.conf";
1466  else {
1467  ATH_MSG_ERROR("Invalid tau ID selected: " << m_tauId);
1468  return StatusCode::FAILURE;
1469  }
1470 
1471  // Read in the config file so we can retrieve the fields later when configuring the efficiency tools
1472  if ( m_tauConfigReader.ReadFile( PathResolverFindCalibFile(inputfile).c_str(), EEnvLevel(0) ) ) {
1473  ATH_MSG_ERROR( "Error while reading tau config file : " << inputfile );
1474  return StatusCode::FAILURE;
1475  }
1476  else ATH_MSG_DEBUG( "Successfully read tau config file : " << inputfile );
1477 
1478 
1480  // Initialise tau selection tools
1481 
1482  if (!m_tauSelTool.isUserConfigured()) {
1483  toolName = "TauSelectionTool_" + m_tauId;
1484  m_tauSelTool.setTypeAndName("TauAnalysisTools::TauSelectionTool/"+toolName);
1485  ATH_CHECK( m_tauSelTool.setProperty("ConfigPath", inputfile) );
1486  ATH_CHECK( m_tauSelTool.setProperty("OutputLevel", this->msg().level()) );
1487  ATH_CHECK( m_tauSelTool.retrieve() );
1488  } else ATH_CHECK( m_tauSelTool.retrieve() );
1489 
1490 
1491  if (!m_tauSelToolBaseline.isUserConfigured()) {
1492  std::string inputfile = "";
1493  if (!m_tauConfigPathBaseline.empty() && (m_tauConfigPathBaseline!="default")) inputfile = m_tauConfigPathBaseline;
1494  else if (m_tauIdBaseline == "rnn001") inputfile = "SUSYTools/tau_selection_rnn001.conf";
1495  else if (m_tauIdBaseline == "VeryLoose") inputfile = "SUSYTools/tau_selection_veryloose.conf";
1496  else if (m_tauIdBaseline == "Loose") inputfile = "SUSYTools/tau_selection_loose.conf";
1497  else if (m_tauIdBaseline == "Medium") inputfile = "SUSYTools/tau_selection_medium.conf";
1498  else if (m_tauIdBaseline == "Tight") inputfile = "SUSYTools/tau_selection_tight.conf";
1499  else {
1500  ATH_MSG_ERROR("Invalid baseline tau ID selected: " << m_tauIdBaseline);
1501  return StatusCode::FAILURE;
1502  }
1503  toolName = "TauSelectionToolBaseline_" + m_tauIdBaseline;
1504  m_tauSelToolBaseline.setTypeAndName("TauAnalysisTools::TauSelectionTool/"+toolName);
1505  ATH_CHECK( m_tauSelToolBaseline.setProperty("ConfigPath", inputfile) );
1506 
1507  ATH_CHECK( m_tauSelToolBaseline.setProperty("OutputLevel", this->msg().level()) );
1508  ATH_CHECK( m_tauSelToolBaseline.retrieve() );
1509  } else ATH_CHECK( m_tauSelToolBaseline.retrieve() );
1510 
1511 
1513  // Initialise tau efficiency tool
1514 
1515  if (!m_tauEffTool.isUserConfigured()) {
1516  toolName = "TauEffTool_" + m_tauId;
1517  m_tauEffTool.setTypeAndName("TauAnalysisTools::TauEfficiencyCorrectionsTool/"+toolName);
1518  ATH_CHECK( m_tauEffTool.setProperty("PileupReweightingTool",m_prwTool.getHandle()) );
1519 
1520  std::vector<int> correction_types;
1521  // Read out the tau ID from the config file and map into the enum from tau CP
1522  std::string jetIDWP = m_tauConfigReader.GetValue("JetIDWP" ,"");
1523  ANA_MSG_DEBUG( "Found JetIDWP in tau config file : " << jetIDWP );
1524  int jet_id_lvl;
1525  if (jetIDWP == "JETIDNONE") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDNONE;
1526  else if (jetIDWP == "JETIDRNNVERYLOOSE") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDRNNVERYLOOSE;
1527  else if (jetIDWP == "JETIDRNNLOOSE") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDRNNLOOSE;
1528  else if (jetIDWP == "JETIDRNNMEDIUM") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDRNNMEDIUM;
1529  else if (jetIDWP == "JETIDRNNTIGHT") jet_id_lvl = (int)TauAnalysisTools::JetID::JETIDRNNTIGHT;
1530  else {
1531  ATH_MSG_ERROR("Invalid Tau ID in tau config file " << jetIDWP);
1532  return StatusCode::FAILURE;
1533  }
1534  // Add retrieval of reco and ID SFs
1535  correction_types.insert(correction_types.end(), {TauAnalysisTools::EfficiencyCorrectionType::SFRecoHadTau,
1536  TauAnalysisTools::EfficiencyCorrectionType::SFJetIDHadTau});
1537 
1538  // Read out the (optional) Ele OR from the config file and map into the enum from tau CP
1539  std::string eleIDWP = m_tauConfigReader.GetValue("EleIDWP" ,"");
1540  ANA_MSG_DEBUG( "Found EleIDWP in tau config file : " << eleIDWP );
1541  int ele_id_lvl = -1;
1542  if (eleIDWP == "ELEIDRNNLOOSE") ele_id_lvl = (int)TauAnalysisTools::EleID::ELEIDRNNLOOSE;
1543  else if (eleIDWP == "ELEIDRNNMEDIUM") ele_id_lvl = (int)TauAnalysisTools::EleID::ELEIDRNNMEDIUM;
1544  else if (eleIDWP == "ELEIDRNNTIGHT") ele_id_lvl = (int)TauAnalysisTools::EleID::ELEIDRNNTIGHT;
1545  else {
1546  ATH_MSG_INFO("No or invalid Ele OR in tau config file " << eleIDWP << " will not apply SFs for electro veto" );
1547  }
1548  // Add retrieval of electron veto SFs if its applied
1549  if (ele_id_lvl != -1 )
1550  correction_types.insert(correction_types.end(), {TauAnalysisTools::EfficiencyCorrectionType::SFEleIDHadTau,
1551  TauAnalysisTools::EfficiencyCorrectionType::SFEleIDElectron});
1552 
1553  ATH_CHECK( m_tauEffTool.setProperty("JetIDLevel", jet_id_lvl) );
1554  ATH_CHECK( m_tauEffTool.setProperty("EleIDLevel", ele_id_lvl) );
1555  ATH_CHECK( m_tauEffTool.setProperty("EfficiencyCorrectionTypes", correction_types) );
1556  ATH_CHECK( m_tauEffTool.setProperty("OutputLevel", this->msg().level()) );
1557  ATH_CHECK( m_tauEffTool.setProperty("useFastSim", isAtlfast()) );
1558  ATH_CHECK( m_tauEffTool.retrieve() );
1559  } else ATH_CHECK( m_tauEffTool.retrieve() );
1560 
1561 
1563  // Initialise tau trigger efficiency tool(s)
1564 
1565  if (!isData()) {
1566  int iTauID = (int) TauAnalysisTools::JETIDNONEUNCONFIGURED;
1567  if (m_tauId == "rnn001") iTauID = (int) TauAnalysisTools::JETIDNONE;
1568  else if (m_tauId == "VeryLoose") iTauID = (int) TauAnalysisTools::JETIDRNNVERYLOOSE;
1569  else if (m_tauId == "Loose") iTauID = (int) TauAnalysisTools::JETIDRNNLOOSE;
1570  else if (m_tauId == "Medium") iTauID = (int) TauAnalysisTools::JETIDRNNMEDIUM;
1571  else if (m_tauId == "Tight") iTauID = (int) TauAnalysisTools::JETIDRNNTIGHT;
1572  else {
1573  ATH_MSG_ERROR("Invalid tau ID selected: " << m_tauId);
1574  return StatusCode::FAILURE;
1575  }
1576 
1577  // map format: SF file name, corresponding single-tau leg (comma-separated in case of OR)
1578  m_tau_trig_support = {
1579  {"HLT_tau25_medium1_tracktwo", "HLT_tau25_medium1_tracktwo"},
1580  {"HLT_tau35_medium1_tracktwo", "HLT_tau35_medium1_tracktwo"},
1581  {"HLT_tau50L1TAU12_medium1_tracktwo", "HLT_tau50_medium1_tracktwo_L1TAU12"},
1582  {"HLT_tau60_medium1_tracktwo", "HLT_tau60_medium1_tracktwo"},
1583  {"HLT_tau80L1TAU60_medium1_tracktwo", "HLT_tau80_medium1_tracktwo_L1TAU60"},
1584  {"HLT_tau125_medium1_tracktwo", "HLT_tau125_medium1_tracktwo"},
1585  {"HLT_tau160_medium1_tracktwo", "HLT_tau160_medium1_tracktwo"},
1586  {"HLT_tau160L1TAU100_medium1_tracktwo", "HLT_tau160_medium1_tracktwo_L1TAU100"},
1587  // whole 2018 data taking period
1588  {"HLT_tau25_medium1_tracktwoEF", "HLT_tau25_medium1_tracktwoEF"},
1589  {"HLT_tau35L1TAU12IM_medium1_tracktwoEF", "HLT_tau35_medium1_tracktwoEF_L1TAU12IM"},
1590  {"HLT_tau35_medium1_tracktwoEF", "HLT_tau35_medium1_tracktwoEF"},
1591  {"HLT_tau60_medium1_tracktwoEF", "HLT_tau60_medium1_tracktwoEF"},
1592  {"HLT_tau80L1TAU60_medium1_tracktwoEF", "HLT_tau80_medium1_tracktwoEF_L1TAU60"},
1593  {"HLT_tau160L1TAU100_medium1_tracktwoEF", "HLT_tau160_medium1_tracktwoEF_L1TAU100"},
1594  // 2018 data after TS1, run >= 355261
1595  {"HLT_tau25_medium1_tracktwoEF_OR_mediumRNN_tracktwoMVA", "HLT_tau25_medium1_tracktwoEF,HLT_tau25_mediumRNN_tracktwoMVA"},
1596  {"HLT_tau35L1TAU12IM_medium1_tracktwoEF_OR_mediumRNN_tracktwoMVA", "HLT_tau35_medium1_tracktwoEF_L1TAU12IM,HLT_tau35_mediumRNN_tracktwoMVA_L1TAU12IM"},
1597  {"HLT_tau35_medium1_tracktwoEF_OR_mediumRNN_tracktwoMVA", "HLT_tau35_medium1_tracktwoEF,HLT_tau35_mediumRNN_tracktwoMVA"},
1598  {"HLT_tau60_medium1_tracktwoEF_OR_mediumRNN_tracktwoMVA", "HLT_tau60_medium1_tracktwoEF,HLT_tau60_mediumRNN_tracktwoMVA"},
1599  {"HLT_tau80L1TAU60_medium1_tracktwoEF_OR_mediumRNN_tracktwoMVA", "HLT_tau80_medium1_tracktwoEF_L1TAU60,HLT_tau80_mediumRNN_tracktwoMVA_L1TAU60"},
1600  {"HLT_tau160L1TAU100_medium1_tracktwoEF_OR_mediumRNN_tracktwoMVA", "HLT_tau160_medium1_tracktwoEF_L1TAU100,HLT_tau160_mediumRNN_tracktwoMVA_L1TAU100"}
1601  };
1602 
1603  for(auto const& trigger : m_tau_trig_support) {
1604  toolName = "TauTrigEffTool_" + m_tauId + "_" + trigger.first;
1605  auto tau_trigSF = m_tauTrigEffTool.emplace(m_tauTrigEffTool.end(), "TauAnalysisTools::TauEfficiencyCorrectionsTool/"+toolName);
1606  ATH_CHECK( tau_trigSF->setProperty("EfficiencyCorrectionTypes", std::vector<int>({TauAnalysisTools::SFTriggerHadTau})) );
1607  ATH_CHECK( tau_trigSF->setProperty("TriggerName", trigger.first) );
1608  ATH_CHECK( tau_trigSF->setProperty("JetIDLevel", iTauID) );
1609  ATH_CHECK( tau_trigSF->setProperty("PileupReweightingTool", m_prwTool.getHandle()) );
1610  ATH_CHECK( tau_trigSF->setProperty("OutputLevel", this->msg().level()) );
1611  ATH_CHECK( tau_trigSF->setProperty("useFastSim", isAtlfast()) );
1612  ATH_CHECK( tau_trigSF->initialize() );
1613  }
1614  }
1615 
1616 
1618  // Initialise tau smearing tool
1619 
1620  if (!m_tauSmearingTool.isUserConfigured()) {
1621  m_tauSmearingTool.setTypeAndName("TauAnalysisTools::TauSmearingTool/TauSmearingTool");
1622  ATH_CHECK( m_tauSmearingTool.setProperty("RecommendationTag", m_tauSmearingToolRecommendationTag) );
1623  if (m_isRun3){ ATH_CHECK( m_tauSmearingTool.setProperty("Campaign", "mc21") );}
1624  else { ATH_CHECK( m_tauSmearingTool.setProperty("Campaign", "mc20") );}
1625  ATH_CHECK( m_tauSmearingTool.setProperty("Generator", m_tauSmearingToolGenerator) );
1626  ATH_CHECK( m_tauSmearingTool.setProperty("useFastSim", isAtlfast()) );
1627  ATH_CHECK( m_tauSmearingTool.setProperty("OutputLevel", this->msg().level()) );
1628  ATH_CHECK( m_tauSmearingTool.retrieve() );
1629  } else ATH_CHECK( m_tauSmearingTool.retrieve() );
1630 
1631 
1633  // Initialise tau truth matching tool
1634 
1635  if (!m_tauTruthMatch.isUserConfigured() && m_tauDoTTM) {
1636  m_tauTruthMatch.setTypeAndName("TauAnalysisTools::TauTruthMatchingTool/TauTruthMatch");
1637  ATH_CHECK( m_tauTruthMatch.setProperty("TruthJetContainerName", m_defaultTruthJets ) );
1638  ATH_CHECK( m_tauTruthMatch.setProperty("OutputLevel", this->msg().level()) );
1639  ATH_CHECK( m_tauTruthMatch.retrieve() );
1640  } else if (m_tauTruthMatch.isUserConfigured()) ATH_CHECK( m_tauTruthMatch.retrieve() );
1641 
1642 
1643  }
1644 
1645 
1646  if (m_slices["bjet"]) {
1648  // Initialise B-tagging tools
1649 
1650  // btagSelectionTool
1651  std::string jetcollBTag = jetcoll;
1652  if (jetcoll == "AntiKt4LCTopoJets") {
1653  ATH_MSG_WARNING(" *** HACK *** Treating LCTopoJets jets as EMTopo -- use at your own risk!");
1654  jetcollBTag = "AntiKt4EMTopoJets";
1655  }
1656 
1657  // print a warning if there is indication that the user supplied a CDI file not matching to the sample being processed
1658  // for the GN2v00 tagger the Run 2 and Run 3 files are the same, so we skip this check
1659  // see --> https://twiki.cern.ch/twiki/bin/view/AtlasProtected/BTagRel22HighLevelSummary
1660  if( (m_bTaggingCalibrationFilePath.find(!m_isRun3 ? "MC20" : "MC21") == std::string::npos) && (m_BtagTagger.find("GN2v00") != std::string::npos) ) {
1661  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"));
1662  }
1663 
1664  if (m_useBtagging && !m_btagSelTool.isUserConfigured() && !m_BtagWP.empty()) {
1665  if (jetcollBTag.find("AntiKt4EMTopoJets") == std::string::npos && jetcollBTag.find("AntiKt4EMPFlowJets")==std::string::npos) {
1666  ATH_MSG_WARNING("** Only AntiKt4EMTopoJets and AntiKt4EMPFlowJets are supported with FTAG scale factors!");
1667  return StatusCode::FAILURE;
1668  }
1669 
1670  toolName = "BTagSel_" + jetcollBTag + m_BtagTagger + m_BtagWP;
1671 
1672  m_btagSelTool.setTypeAndName("BTaggingSelectionTool/"+toolName);
1673  ATH_CHECK( m_btagSelTool.setProperty("TaggerName", m_BtagTagger ) );
1674  ATH_CHECK( m_btagSelTool.setProperty("OperatingPoint", m_BtagWP ) );
1675  ATH_CHECK( m_btagSelTool.setProperty("JetAuthor", jetcollBTag ) );
1676  ATH_CHECK( m_btagSelTool.setProperty("MinPt", m_BtagMinPt ) );
1677  ATH_CHECK( m_btagSelTool.setProperty("FlvTagCutDefinitionsFileName", m_bTaggingCalibrationFilePath) );
1678  ATH_CHECK( m_btagSelTool.setProperty("OutputLevel", this->msg().level()) );
1679  ATH_CHECK( m_btagSelTool.retrieve() );
1680  } else if (m_btagSelTool.isUserConfigured()) ATH_CHECK( m_btagSelTool.retrieve() );
1681 
1682 
1683  if (m_useBtagging && !m_btagSelTool_OR.isUserConfigured() && !m_orBtagWP.empty()) {
1684  if (jetcoll != "AntiKt4EMTopoJets" && jetcoll != "AntiKt4EMPFlowJets") {
1685  ATH_MSG_WARNING("** Only AntiKt4EMTopoJets and AntiKt4EMPFlowJets are supported with FTAG scale factors!");
1686  return StatusCode::FAILURE;
1687  }
1688 
1689  toolName = "BTagSelOR_" + jetcollBTag + m_orBtagWP;
1690  m_btagSelTool_OR.setTypeAndName("BTaggingSelectionTool/"+toolName);
1691  ATH_CHECK( m_btagSelTool_OR.setProperty("TaggerName", m_BtagTagger ) );
1692  ATH_CHECK( m_btagSelTool_OR.setProperty("OperatingPoint", m_orBtagWP ) );
1693  ATH_CHECK( m_btagSelTool_OR.setProperty("JetAuthor", jetcollBTag ) );
1694  ATH_CHECK( m_btagSelTool_OR.setProperty("MinPt", m_BtagMinPt ) );
1695  ATH_CHECK( m_btagSelTool_OR.setProperty("FlvTagCutDefinitionsFileName", m_bTaggingCalibrationFilePath) );
1696  ATH_CHECK( m_btagSelTool_OR.setProperty("OutputLevel", this->msg().level()) );
1697  ATH_CHECK( m_btagSelTool_OR.retrieve() );
1698  } else if (m_btagSelTool_OR.isUserConfigured()) ATH_CHECK( m_btagSelTool_OR.retrieve() );
1699 
1700 
1701  std::string trkjetcoll = m_defaultTrackJets;
1702  const std::string& BTagColl_TrkJet = trkjetcoll;
1703  if (m_slices["tjet"]) {
1704  if ( m_useBtagging_trkJet && m_defaultTrackJets.empty()) {
1705  m_useBtagging_trkJet = false;
1706  ATH_MSG_INFO("TrackJet collection set to None: disabling btagging for TrackJets.");
1707  }
1708 
1709  if (m_useBtagging_trkJet && !m_btagSelTool_trkJet.isUserConfigured() && !m_BtagWP_trkJet.empty()) {
1710  if (trkjetcoll.find("AntiKt2PV0TrackJets")==std::string::npos && trkjetcoll.find("AntiKtVR30Rmax4Rmin02TrackJets")==std::string::npos) {
1711  ATH_MSG_WARNING("** Only AntiKt2PV0TrackJets and AntiKtVR30Rmax4Rmin02TrackJets are supported with FTAG scale factors!");
1712  return StatusCode::FAILURE;
1713  }
1714 
1715  toolName = "BTagSel_" + trkjetcoll + m_BtagTagger_trkJet + m_BtagWP_trkJet;
1716 
1717  m_btagSelTool_trkJet.setTypeAndName("BTaggingSelectionTool/"+toolName);
1718  ATH_CHECK( m_btagSelTool_trkJet.setProperty("TaggerName", m_BtagTagger_trkJet ) );
1719  ATH_CHECK( m_btagSelTool_trkJet.setProperty("OperatingPoint", m_BtagWP_trkJet ) );
1720  ATH_CHECK( m_btagSelTool_trkJet.setProperty("MinPt", m_BtagMinPt_trkJet ) );
1721  ATH_CHECK( m_btagSelTool_trkJet.setProperty("JetAuthor", BTagColl_TrkJet ) );
1722  ATH_CHECK( m_btagSelTool_trkJet.setProperty("MinPt", m_BtagMinPt_trkJet ) );
1723  ATH_CHECK( m_btagSelTool_trkJet.setProperty("FlvTagCutDefinitionsFileName", m_bTaggingCalibrationFilePath) );
1724  ATH_CHECK( m_btagSelTool_trkJet.setProperty("OutputLevel", this->msg().level()) );
1725  ATH_CHECK( m_btagSelTool_trkJet.retrieve() );
1726  } else if (m_btagSelTool_trkJet.isUserConfigured()) ATH_CHECK( m_btagSelTool_trkJet.retrieve() );
1727  }
1728 
1729  // Set MCshowerType for FTAG MC/MC SFs
1730  // https://twiki.cern.ch/twiki/bin/view/AtlasProtected/BTagCalibrationRecommendationsRelease21#MC_MC_Scale_Factors_for_Analysis
1731  std::string MCshowerID;
1732  if(!m_isRun3){
1733  MCshowerID= "default"; // Powheg+Pythia8 (410470) - PhPy8EG_A14
1734  if (m_showerType == 1) MCshowerID = "411233"; // PowhegHerwig7
1735  else if (m_showerType == 2) MCshowerID = "600666"; // PhH7EG_H7UE - 601414
1736  else if (m_showerType == 3) MCshowerID = "410250"; // Sherpa_221
1737  else if (m_showerType == 4) MCshowerID = "700122"; // Sh_2210
1738  else if (m_showerType == 5) MCshowerID = "700122"; // Sh_2211
1739  else if (m_showerType == 6) MCshowerID = "700660"; // Sh_2212 - 700660
1740  else if (m_showerType == 7) MCshowerID = "410464"; // aMcAtNloPy8
1741  else if (m_showerType == 8) MCshowerID = "412116"; // aMcAtNloHerwig7
1742  }
1743  else{
1744  MCshowerID= "default"; // Powheg+Pythia8 (601229) - PhPy8EG_A14
1745  if (m_showerType == 2) MCshowerID = "601414"; // POWHEG+Herwig721 - PhH7EG_A14
1746  else if (m_showerType == 6) MCshowerID = "700660"; // Sherpa 2.2.12 - Sh_2212
1747  }
1748 
1749  // btagEfficiencyTool
1750  if (m_useBtagging && !m_btagEffTool.isUserConfigured() && !m_BtagWP.empty()) {
1751  if (jetcoll != "AntiKt4EMTopoJets" && jetcoll != "AntiKt4EMPFlowJets") {
1752  ATH_MSG_WARNING("** Only AntiKt4EMTopoJets and AntiKt4EMPFlowJets are supported with FTAG scale factors!");
1753  return StatusCode::FAILURE;
1754  }
1755 
1756  toolName = "BTagSF_" + jetcollBTag + m_BtagTagger + m_BtagWP;
1757  m_btagEffTool.setTypeAndName("BTaggingEfficiencyTool/"+toolName);
1758  ATH_CHECK( m_btagEffTool.setProperty("TaggerName", m_BtagTagger ) );
1759  ATH_CHECK( m_btagEffTool.setProperty("ScaleFactorFileName", m_bTaggingCalibrationFilePath) );
1760  ATH_CHECK( m_btagEffTool.setProperty("OperatingPoint", m_BtagWP ) );
1761  ATH_CHECK( m_btagEffTool.setProperty("JetAuthor", jetcollBTag ) );
1762  ATH_CHECK( m_btagEffTool.setProperty("MinPt", m_BtagMinPt ) );
1763  ATH_CHECK( m_btagEffTool.setProperty("SystematicsStrategy", m_BtagSystStrategy ) );
1764  ATH_CHECK( m_btagEffTool.setProperty("EfficiencyBCalibrations", MCshowerID ));
1765  ATH_CHECK( m_btagEffTool.setProperty("EfficiencyCCalibrations", MCshowerID ));
1766  ATH_CHECK( m_btagEffTool.setProperty("EfficiencyTCalibrations", MCshowerID ));
1767  ATH_CHECK( m_btagEffTool.setProperty("EfficiencyLightCalibrations", MCshowerID ));
1768  ATH_CHECK( m_btagEffTool.setProperty("OutputLevel", this->msg().level()) );
1769  ATH_CHECK( m_btagEffTool.retrieve() );
1770  } else ATH_CHECK( m_btagEffTool.retrieve() );
1771 
1772 
1773  if (m_slices["tjet"]) {
1774  if (m_useBtagging_trkJet && !m_btagEffTool_trkJet.isUserConfigured() && !m_BtagWP_trkJet.empty()) {
1775  if (trkjetcoll.find("AntiKt2PV0TrackJets")==std::string::npos && trkjetcoll.find("AntiKtVR30Rmax4Rmin02TrackJets")==std::string::npos) {
1776  ATH_MSG_WARNING("** Only AntiKt2PV0TrackJets and AntiKtVR30Rmax4Rmin02TrackJets are supported with FTAG scale factors!");
1777  return StatusCode::FAILURE;
1778  }
1779 
1780  toolName = "BTagSF_" + trkjetcoll;
1781  m_btagEffTool_trkJet.setTypeAndName("BTaggingEfficiencyTool/"+toolName);
1782  ATH_CHECK( m_btagEffTool_trkJet.setProperty("TaggerName", m_BtagTagger_trkJet ) );
1783  ATH_CHECK( m_btagEffTool_trkJet.setProperty("ScaleFactorFileName", m_bTaggingCalibrationFilePath) );
1784  ATH_CHECK( m_btagEffTool_trkJet.setProperty("OperatingPoint", m_BtagWP_trkJet ) );
1785  ATH_CHECK( m_btagEffTool_trkJet.setProperty("JetAuthor", BTagColl_TrkJet ) );
1786  ATH_CHECK( m_btagEffTool_trkJet.setProperty("MinPt", m_BtagMinPt_trkJet ) );
1787  ATH_CHECK( m_btagEffTool_trkJet.setProperty("SystematicsStrategy", m_BtagSystStrategy ) );
1788  ATH_CHECK( m_btagEffTool_trkJet.setProperty("EfficiencyBCalibrations", MCshowerID ));
1789  ATH_CHECK( m_btagEffTool_trkJet.setProperty("EfficiencyCCalibrations", MCshowerID ));
1790  ATH_CHECK( m_btagEffTool_trkJet.setProperty("EfficiencyTCalibrations", MCshowerID ));
1791  ATH_CHECK( m_btagEffTool_trkJet.setProperty("EfficiencyLightCalibrations", MCshowerID ));
1792  ATH_CHECK( m_btagEffTool_trkJet.setProperty("OutputLevel", this->msg().level()) );
1793  ATH_CHECK( m_btagEffTool_trkJet.retrieve() );
1794  } else if (m_btagEffTool_trkJet.isUserConfigured()) ATH_CHECK( m_btagEffTool_trkJet.retrieve() );
1795  }
1796  }
1797 
1798 
1799  if (m_slices["met"]) {
1801  // Initialise MET tools
1802 
1803  if (!m_metMaker.isUserConfigured()) {
1804  toolName = m_doFwdJVT ? m_metJetSelection+"_fJVT" : m_metJetSelection+"_NOfJVT";
1805  m_metMaker.setTypeAndName("met::METMaker/METMaker_ST_"+toolName);
1806 
1807  ATH_CHECK( m_metMaker.setProperty("ORCaloTaggedMuons", m_metRemoveOverlappingCaloTaggedMuons) );
1808  ATH_CHECK( m_metMaker.setProperty("DoSetMuonJetEMScale", m_metDoSetMuonJetEMScale) );
1809  ATH_CHECK( m_metMaker.setProperty("DoRemoveMuonJets", m_metDoRemoveMuonJets) );
1810  ATH_CHECK( m_metMaker.setProperty("UseGhostMuons", m_metUseGhostMuons) );
1811  ATH_CHECK( m_metMaker.setProperty("DoMuonEloss", m_metDoMuonEloss) );
1812  ATH_CHECK( m_metMaker.setProperty("GreedyPhotons", m_metGreedyPhotons) );
1813  ATH_CHECK( m_metMaker.setProperty("VeryGreedyPhotons", m_metVeryGreedyPhotons) );
1814 
1815  // set the jet selection if default empty string is overridden through config file
1816  if (m_metJetSelection.size()) {
1817  ATH_CHECK( m_metMaker.setProperty("JetSelection", m_metJetSelection) );
1818  }
1819  if (m_jetInputType == xAOD::JetInput::EMPFlow) {
1820  ATH_CHECK( m_metMaker.setProperty("DoPFlow", true) );
1821  }
1822 
1823  ATH_CHECK( m_metMaker.setProperty("OutputLevel", this->msg().level()) );
1824  ATH_CHECK( m_metMaker.retrieve() );
1825  } else ATH_CHECK( m_metMaker.retrieve() );
1826 
1827 
1828  if (!m_metSystTool.isUserConfigured()) {
1829  m_metSystTool.setTypeAndName("met::METSystematicsTool/METSystTool");
1830  ATH_CHECK( m_metSystTool.setProperty("ConfigPrefix", m_metsysConfigPrefix) );
1831 
1832  if (m_trkMETsyst && m_caloMETsyst){
1833  ATH_MSG_ERROR( "Can only have CST *or* TST configured for MET maker. Please unset either METDoCaloSyst or METDoTrkSyst in your config file" );
1834  return StatusCode::FAILURE;
1835  }
1836 
1837  if (m_trkMETsyst) {
1838  ATH_CHECK( m_metSystTool.setProperty("ConfigSoftCaloFile", "") );
1839  ATH_CHECK( m_metSystTool.setProperty("ConfigSoftTrkFile", "TrackSoftTerms-pflow.config") );
1840  }
1841 
1842  if (m_caloMETsyst) {
1843  ATH_MSG_WARNING( "CST is no longer recommended by Jet/MET group");
1844  ATH_CHECK( m_metSystTool.setProperty("ConfigSoftTrkFile", "") );
1845  }
1846 
1847  if (m_trkJetsyst) {
1848  ATH_CHECK( m_metSystTool.setProperty("ConfigJetTrkFile", "JetTrackSyst.config") );
1849  }
1850 
1851  ATH_CHECK( m_metSystTool.setProperty("OutputLevel", this->msg().level()) );
1852  ATH_CHECK( m_metSystTool.retrieve());
1853  } else ATH_CHECK( m_metSystTool.retrieve());
1854 
1855 
1856  if (!m_metSignif.isUserConfigured()) {
1857  // See https://twiki.cern.ch/twiki/bin/view/AtlasProtected/MetSignificance
1858  m_metSignif.setTypeAndName("met::METSignificance/metSignificance_"+jetname);
1859 #ifndef XAOD_STANDALONE // Athena and AthAnalysis; need to take into account that MuonCalibTool is private tool
1860  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "SoftTermParam", m_softTermParam));
1861  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "TreatPUJets", m_treatPUJets));
1862  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "DoPhiReso", m_doPhiReso));
1863  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "IsAFII", isAtlfast()));
1864  if(jetname == "AntiKt4EMTopo" || jetname =="AntiKt4EMPFlow"){
1865  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "JetCollection", jetname) );
1866  } else {
1867  ATH_MSG_WARNING("Object-based METSignificance recommendations only exist for EMTopo and PFlow, falling back to AntiKt4EMTopo");
1868  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "JetCollection", "AntiKt4EMTopo") );
1869  }
1870  // setup a dedicated new muon calib tool for passing down to METSignificance
1871  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "MuonCalibTool", "CP::MuonCalibTool/calibTool"));
1872  if (m_isRun3)
1873  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.IsRun3Geo", true));
1874  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.calibMode", m_muCalibrationMode));
1875  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.OutputLevel",this->msg().level()));
1876  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.release", "Recs2024_05_06_Run2Run3"));
1877  int IdBaselineInt = m_muIdBaseline;
1878  if (IdBaselineInt == 4)
1879  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.do2StationsHighPt", true));
1880  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "calibTool.doExtraSmearing", m_muHighPtExtraSmear));
1881  ATH_CHECK( AAH::setProperty(m_metSignif.getHandle(), "OutputLevel", this->msg().level()));
1882 #else // AnalysisBase; can just pass the muon calib tool configured above
1883  ATH_CHECK( m_metSignif.setProperty("SoftTermParam", m_softTermParam) );
1884  ATH_CHECK( m_metSignif.setProperty("TreatPUJets", m_treatPUJets) );
1885  ATH_CHECK( m_metSignif.setProperty("DoPhiReso", m_doPhiReso) );
1886  ATH_CHECK( m_metSignif.setProperty("IsAFII", isAtlfast()) );
1887  if(jetname == "AntiKt4EMTopo" || jetname =="AntiKt4EMPFlow"){
1888  ATH_CHECK( m_metSignif.setProperty("JetCollection", jetname) );
1889  } else {
1890  ATH_MSG_WARNING("Object-based METSignificance recommendations only exist for EMTopo and PFlow, falling back to AntiKt4EMTopo");
1891  ATH_CHECK( m_metSignif.setProperty("JetCollection", "AntiKt4EMTopo") );
1892  }
1893  // just pass the muon calib tool
1894  ATH_CHECK( m_metSignif.setProperty("MuonCalibTool",m_muonCalibTool.getHandle()));
1895  ATH_CHECK( m_metSignif.setProperty("OutputLevel", this->msg().level()) );
1896 #endif
1897  ATH_CHECK( m_metSignif.retrieve() );
1898  } else ATH_CHECK( m_metSignif.retrieve() );
1899  }
1900 
1901 
1903 // Initialise trigger tools
1904 
1905  if (!m_trigDecTool.isUserConfigured()) {
1906 
1907  // The decision tool
1908  m_trigDecTool.setTypeAndName("Trig::TrigDecisionTool/TrigDecisionTool");
1909  ATH_CHECK( m_trigDecTool.setProperty("TrigDecisionKey", "xTrigDecision") );
1910  if (m_isRun3) {
1911  ATH_CHECK( m_trigDecTool.setProperty("NavigationFormat", "TrigComposite") );
1912  ATH_CHECK( m_trigDecTool.setProperty("HLTSummary", "HLTNav_Summary_DAODSlimmed") );
1913  }
1914  ATH_CHECK( m_trigDecTool.setProperty("OutputLevel", this->msg().level()) );
1915 
1916 #ifndef XAOD_STANDALONE // Athena and AthAnalysis
1917  // Clear the default tool handle to cause a fallback on the config service
1918  ATH_CHECK( m_trigDecTool.setProperty("ConfigTool", ""));
1919 #else // AnalysisBase
1920  m_trigConfTool.setTypeAndName("TrigConf::xAODConfigTool/xAODConfigTool");
1921  ATH_CHECK(m_trigConfTool.retrieve() );
1922  ATH_CHECK( m_trigDecTool.setProperty("ConfigTool", m_trigConfTool.getHandle()) );
1923 #endif
1924 
1925  ATH_CHECK( m_trigDecTool.retrieve() );
1926 
1927  } else ATH_CHECK( m_trigDecTool.retrieve() );
1928 
1929  if (m_isRun3) {
1930  if (!m_trigDRScoringTool.isUserConfigured()) {
1931  m_trigDRScoringTool.setTypeAndName("Trig::DRScoringTool/TrigDRScoringTool");
1932  ATH_CHECK( m_trigDRScoringTool.setProperty("OutputLevel", this->msg().level()) );
1933  ATH_CHECK( m_trigDRScoringTool.retrieve() );
1934  } else ATH_CHECK( m_trigDRScoringTool.retrieve() );
1935  }
1936 
1937  if (!m_trigMatchingTool.isUserConfigured()) {
1938  if (m_upstreamTriggerMatching){
1939  m_trigMatchingTool.setTypeAndName("Trig::MatchFromCompositeTool/TrigMatchFromCompositeTool");
1940  ATH_CHECK( m_trigMatchingTool.setProperty("InputPrefix", m_trigMatchingPrefix) );
1941  ATH_CHECK( m_trigMatchingTool.setProperty("RemapBrokenLinks", true) );
1942  }
1943  else {
1944  if (m_isRun3){
1945  m_trigMatchingTool.setTypeAndName("Trig::R3MatchingTool/TrigR3MatchingTool");
1946  ATH_CHECK( m_trigMatchingTool.setProperty("ScoringTool", m_trigDRScoringTool.getHandle()) );
1947  ATH_CHECK( m_trigMatchingTool.setProperty("TrigDecisionTool", m_trigDecTool.getHandle()) );
1948  }
1949  else {
1950  m_trigMatchingTool.setTypeAndName("Trig::MatchingTool/TrigMatchingTool");
1951  ATH_CHECK( m_trigMatchingTool.setProperty("TrigDecisionTool", m_trigDecTool.getHandle()) );
1952  }
1953  }
1954  ATH_CHECK( m_trigMatchingTool.setProperty("OutputLevel", this->msg().level()) );
1955  ATH_CHECK( m_trigMatchingTool.retrieve() );
1956  } else ATH_CHECK( m_trigMatchingTool.retrieve() );
1957 
1959 // Initialise trigGlobalEfficiencyCorrection tool
1960 
1961  if (!m_trigGlobalEffCorrTool_diLep.isUserConfigured()) {
1962 
1963  std::string no2e17("");
1964  if (m_trig2017combination_diLep.find("||2e17_lhvloose_nod0_L12EM15VHI") != std::string::npos) {
1965  auto pos_2e17 = m_trig2017combination_diLep.find("||2e17_lhvloose_nod0_L12EM15VHI");
1966  no2e17 = m_trig2017combination_diLep.substr(0, pos_2e17) + m_trig2017combination_diLep.substr(pos_2e17+31, m_trig2017combination_diLep.size());
1967  } else if (m_trig2017combination_diLep.find("2e17_lhvloose_nod0_L12EM15VHI||") != std::string::npos) {
1968  auto pos_2e17 = m_trig2017combination_diLep.find("2e17_lhvloose_nod0_L12EM15VHI||");
1969  no2e17 = m_trig2017combination_diLep.substr(0, pos_2e17) + m_trig2017combination_diLep.substr(pos_2e17+31, m_trig2017combination_diLep.size());
1970  } else {
1971  no2e17 = m_trig2017combination_diLep;
1972  }
1973  ATH_MSG_DEBUG( "TrigGlobalEfficiencyCorrectionTool/TrigGlobal_diLep: no2e17 trigger string: " << no2e17 );
1974 
1975  std::map<std::string,std::string> triggers_diLep;
1976  triggers_diLep["2015"] = m_trig2015combination_diLep;
1977  triggers_diLep["2016"] = m_trig2016combination_diLep;
1978  triggers_diLep["324320-326695"] = m_trig2017combination_diLep; // 2017 before accidental prescale of L12EM15VHI
1979  triggers_diLep["326834-328393"] = no2e17; // 2017 during accidental prescale
1980  triggers_diLep["329385-340453"] = m_trig2017combination_diLep; // 2017 after accidental prescale
1981  triggers_diLep["2018"] = m_trig2018combination_diLep;
1982 
1983  m_trigGlobalEffCorrTool_diLep.setTypeAndName("TrigGlobalEfficiencyCorrectionTool/TrigGlobal_diLep");
1984  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("ElectronEfficiencyTools", m_elecTrigEffTools) );
1985  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("ElectronScaleFactorTools", m_elecTrigSFTools) );
1986  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("MuonTools", m_muonTrigSFTools) );
1987  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("TriggerCombination", triggers_diLep) );
1988  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("TriggerMatchingTool", m_trigMatchingTool.getHandle()) );
1989  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("ListOfLegsPerTool", m_legsPerTool) );
1990  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("NumberOfToys", m_trigNToys_diLep) );
1991  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.setProperty("OutputLevel", this->msg().level()) );
1992  ATH_CHECK( m_trigGlobalEffCorrTool_diLep.initialize() );
1993  } else ATH_CHECK( m_trigGlobalEffCorrTool_diLep.initialize() );
1994 
1995 
1996  if (!m_trigGlobalEffCorrTool_multiLep.isUserConfigured()) {
1997 
1998  std::string no2e17("");
1999  if (m_trig2017combination_multiLep.find("||2e17_lhvloose_nod0_L12EM15VHI") != std::string::npos) {
2000  auto pos_2e17 = m_trig2017combination_multiLep.find("||2e17_lhvloose_nod0_L12EM15VHI");
2001  no2e17 = m_trig2017combination_multiLep.substr(0, pos_2e17) + m_trig2017combination_multiLep.substr(pos_2e17+31, m_trig2017combination_multiLep.size());
2002  } else if (m_trig2017combination_multiLep.find("2e17_lhvloose_nod0_L12EM15VHI||") != std::string::npos) {
2003  auto pos_2e17 = m_trig2017combination_multiLep.find("2e17_lhvloose_nod0_L12EM15VHI||");
2004  no2e17 = m_trig2017combination_multiLep.substr(0, pos_2e17) + m_trig2017combination_multiLep.substr(pos_2e17+31, m_trig2017combination_multiLep.size());
2005  } else {
2006  no2e17 = m_trig2017combination_multiLep;
2007  }
2008  ATH_MSG_DEBUG( "TrigGlobalEfficiencyCorrectionTool/TrigGlobal_multiLep: no2e17 trigger string: " << no2e17 );
2009 
2010  std::map<std::string,std::string> triggers_multiLep;
2011  triggers_multiLep["2015"] = m_trig2015combination_multiLep;
2012  triggers_multiLep["2016"] = m_trig2016combination_multiLep;
2013  triggers_multiLep["324320-326695"] = m_trig2017combination_multiLep; // 2017 before accidental prescale of L12EM15VHI
2014  triggers_multiLep["326834-328393"] = no2e17; // 2017 during accidental prescale
2015  triggers_multiLep["329385-340453"] = m_trig2017combination_multiLep; // 2017 after accidental prescale
2016  triggers_multiLep["2018"] = m_trig2018combination_multiLep;
2017 
2018  m_trigGlobalEffCorrTool_multiLep.setTypeAndName("TrigGlobalEfficiencyCorrectionTool/TrigGlobal_multiLep");
2019  ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("ElectronEfficiencyTools", m_elecTrigEffTools) );
2020  ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("ElectronScaleFactorTools", m_elecTrigSFTools) );
2021  ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("MuonTools", m_muonTrigSFTools) );
2022  ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("TriggerCombination", triggers_multiLep) );
2023  ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("TriggerMatchingTool", m_trigMatchingTool.getHandle()) );
2024  ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("ListOfLegsPerTool", m_legsPerTool) );
2025  ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("NumberOfToys", m_trigNToys_multiLep) );
2026  ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.setProperty("OutputLevel", this->msg().level()) );
2027  ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.initialize() );
2028  } else ATH_CHECK( m_trigGlobalEffCorrTool_multiLep.initialize() );
2029 
2030 
2031  if (!m_trigGlobalEffCorrTool_diPhoton.isUserConfigured()) {
2032  m_trigGlobalEffCorrTool_diPhoton.setTypeAndName("TrigGlobalEfficiencyCorrectionTool/TrigGlobal_diPhoton");
2033  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("PhotonEfficiencyTools", m_photonTrigEffTools) );
2034  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("PhotonScaleFactorTools", m_photonTrigSFTools) );
2035  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("TriggerCombination2015", m_trig2015combination_diPhoton) );
2036  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("TriggerCombination2016", m_trig2016combination_diPhoton) );
2037  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("TriggerCombination2017", m_trig2017combination_diPhoton) );
2038  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("TriggerCombination2018", m_trig2018combination_diPhoton) );
2039  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("ListOfLegsPerTool", m_legsPerTool_ph) );
2040  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("NumberOfToys", m_trigNToys_diPhoton) );
2041  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.setProperty("OutputLevel", this->msg().level()) );
2042  ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.initialize() );
2043  } else ATH_CHECK( m_trigGlobalEffCorrTool_diPhoton.initialize() );
2044 
2045 
2046  if (m_slices["ele"] || m_slices["pho"] || m_slices["mu"]) {
2047  // /////////////////////////////////////////////////////////////////////////////////////////
2048  // Initialise Isolation Correction Tool
2049 
2050  if ( !m_isoCorrTool.isUserConfigured() ) {
2051  m_isoCorrTool.setTypeAndName("CP::IsolationCorrectionTool/IsoCorrTool");
2052  ATH_CHECK( m_isoCorrTool.setProperty( "ToolVer", "REL22") );
2053  ATH_CHECK( m_isoCorrTool.setProperty( "IsMC", !isData()) );
2054  ATH_CHECK( m_isoCorrTool.setProperty( "AFII_corr", isAtlfast()) );
2055  ATH_CHECK( m_isoCorrTool.setProperty( "Apply_SC_leakcorr", false) );
2056  ATH_CHECK( m_isoCorrTool.setProperty( "CorrFile", "IsolationCorrections/v6/isolation_ptcorrections_rel22_mc20.root") );
2057  ATH_CHECK( m_isoCorrTool.setProperty( "OutputLevel", this->msg().level()) );
2058  ATH_CHECK( m_isoCorrTool.retrieve() );
2059  } else ATH_CHECK( m_isoCorrTool.retrieve() );
2060 
2061 
2062  // /////////////////////////////////////////////////////////////////////////////////////////
2063  // Initialise Isolation Tool
2064  if (!m_isoTool.isUserConfigured()) {
2065  m_isoTool.setTypeAndName("CP::IsolationSelectionTool/IsoTool");
2066  ATH_CHECK( m_isoTool.setProperty("ElectronWP", m_eleIso_WP.empty() ? "Loose_VarRad" : m_eleIso_WP) );
2067  ATH_CHECK( m_isoTool.setProperty("MuonWP", m_muIso_WP.empty() ? "Loose_VarRad" : m_muIso_WP) );
2068  ATH_CHECK( m_isoTool.setProperty("PhotonWP", m_photonIso_WP.empty() ? "FixedCutTight" : m_photonIso_WP ) );
2069  ATH_CHECK( m_isoTool.setProperty("OutputLevel", this->msg().level()) );
2070  ATH_CHECK( m_isoTool.retrieve() );
2071  } else ATH_CHECK( m_isoTool.retrieve() );
2072 
2073  //disable if (!m_isoToolLowPtPLV.isUserConfigured()) {
2074  //disable m_isoToolLowPtPLV.setTypeAndName("CP::IsolationLowPtPLVTool/IsoToolLowPtPLV");
2075  //disable ATH_CHECK( m_isoToolLowPtPLV.setProperty("OutputLevel", this->msg().level()) );
2076  //disable ATH_CHECK( m_isoToolLowPtPLV.retrieve() );
2077  //disable } else ATH_CHECK( m_isoToolLowPtPLV.retrieve() );
2078 
2079 
2080  if (!m_isoBaselineTool.isUserConfigured()) {
2081  m_isoBaselineTool.setTypeAndName("CP::IsolationSelectionTool/IsoBaselineTool");
2082  ATH_CHECK( m_isoBaselineTool.setProperty("ElectronWP", m_eleBaselineIso_WP.empty() ? "Loose_VarRad" : m_eleBaselineIso_WP ) );
2083  ATH_CHECK( m_isoBaselineTool.setProperty("MuonWP", m_muBaselineIso_WP.empty() ? "Loose_VarRad" : m_muBaselineIso_WP ) );
2084  ATH_CHECK( m_isoBaselineTool.setProperty("PhotonWP", m_photonBaselineIso_WP.empty() ? "FixedCutTight" : m_photonBaselineIso_WP ) );
2085  ATH_CHECK( m_isoBaselineTool.setProperty("OutputLevel", this->msg().level()) );
2086  ATH_CHECK( m_isoBaselineTool.retrieve() );
2087  } else ATH_CHECK( m_isoBaselineTool.retrieve() );
2088 
2089 
2090  if (!m_isoHighPtTool.isUserConfigured()) {
2091  m_isoHighPtTool.setTypeAndName("CP::IsolationSelectionTool/IsoHighPtTool");
2092  ATH_CHECK( m_isoHighPtTool.setProperty("ElectronWP", m_eleIsoHighPt_WP.empty() ? "Loose_VarRad" : m_eleIsoHighPt_WP) );
2093  ATH_CHECK( m_isoHighPtTool.setProperty("MuonWP", m_muIsoHighPt_WP.empty() ? "Loose_VarRad" : m_muIsoHighPt_WP ) );
2094  ATH_CHECK( m_isoHighPtTool.setProperty("PhotonWP", m_photonIso_WP.empty() ? "FixedCutTight" : m_photonIso_WP ) );
2095  ATH_CHECK( m_isoHighPtTool.setProperty("OutputLevel", this->msg().level()) );
2096  ATH_CHECK( m_isoHighPtTool.retrieve() );
2097  } else ATH_CHECK( m_isoHighPtTool.retrieve() );
2098 
2099 
2100  // /////////////////////////////////////////////////////////////////////////////////////////
2101  // Initialise IsolationCloseByCorrectionTool Tool
2102  if (!m_isoCloseByTool.isUserConfigured()) {
2103  m_isoCloseByTool.setTypeAndName("CP::IsolationCloseByCorrectionTool/IsoCloseByTool");
2104  // Actually we could debate about what is the proper tool to choose if the users have different baseline & signal islation WP's
2105  ATH_CHECK( m_isoCloseByTool.setProperty("IsolationSelectionTool", m_useSigLepForIsoCloseByOR ? m_isoTool : m_isoBaselineTool));
2106  ATH_CHECK( m_isoCloseByTool.setProperty("PassoverlapDecorator", m_IsoCloseByORpassLabel) );
2107  ATH_CHECK( m_isoCloseByTool.setProperty("SelectionDecorator", m_useSigLepForIsoCloseByOR ? "signal" : "baseline") );
2108  // Make this propery configurable as well?
2109  ATH_CHECK( m_isoCloseByTool.setProperty("BackupPrefix", "ORIG") );
2110  // The isolation selection decorator is updated as well by the tool
2111  ATH_CHECK( m_isoCloseByTool.setProperty("IsolationSelectionDecorator", "isol") );
2112 
2113  ATH_CHECK( m_isoCloseByTool.setProperty("OutputLevel", this->msg().level()) );
2114 #ifndef XAOD_ANALYSIS
2115  ATH_CHECK( m_isoCloseByTool.setProperty("ParticleCaloExtensionTool", "") );
2116 #endif
2117  ATH_CHECK( m_isoCloseByTool.retrieve() );
2118  } else ATH_CHECK( m_isoCloseByTool.retrieve() );
2119  }
2120 
2121 
2122 // /////////////////////////////////////////////////////////////////////////////////////////
2123 // Initialise Overlap Removal Tool
2124  if ( m_orToolbox.masterTool.empty() ){
2125 
2126  // set up the master tool
2127  std::string suffix = "";
2128  if (m_orDoTau) suffix += "Tau";
2129  if (m_orDoPhoton) suffix += "Gamma";
2130  if (m_orDoBjet) suffix += "Bjet";
2131  std::string toolName = "ORTool" + suffix;
2132  ATH_MSG_INFO("SUSYTools: Autoconfiguring " << toolName);
2133 
2134  std::string bJetLabel = "";
2135  //overwrite lepton flags if the global is false (yes?)
2136  if (!m_orDoBjet || !m_useBtagging) {
2137  m_orDoElBjet = false;
2138  m_orDoMuBjet = false;
2139  m_orDoTauBjet = false;
2140  }
2141  if (m_orDoElBjet || m_orDoMuBjet || m_orDoTauBjet) {
2142  bJetLabel = "bjet_loose";
2143  }
2144 
2145  // Set the generic flags
2146  ORUtils::ORFlags orFlags(toolName, m_orInputLabel, "passOR");
2147  orFlags.bJetLabel = bJetLabel;
2148  orFlags.boostedLeptons = (m_orDoBoostedElectron || m_orDoBoostedMuon);
2149  orFlags.outputPassValue = true;
2150  orFlags.linkOverlapObjects = m_orLinkOverlapObjects;
2151  if (m_orDoElEl) {
2152  orFlags.doEleEleOR = true;
2153  } else orFlags.doEleEleOR = false;
2154  orFlags.doElectrons = true;
2155  orFlags.doMuons = true;
2156  orFlags.doJets = true;
2157  orFlags.doTaus = m_orDoTau;
2158  orFlags.doPhotons = m_orDoPhoton;
2159  orFlags.doFatJets = m_orDoFatjets;
2160 
2161  //set up all recommended tools
2162  ATH_CHECK( ORUtils::recommendedTools(orFlags, m_orToolbox));
2163 
2164  // We don't currently have a good way to determine here which object
2165  // definitions are disabled, so we currently just configure all overlap
2166  // tools and disable the pointer safety checks
2167  ATH_CHECK( m_orToolbox.setGlobalProperty("OutputLevel", this->msg().level()) );
2168  ATH_CHECK( m_orToolbox.masterTool.setProperty("RequireExpectedPointers", false) );
2169 
2170  // Override boosted OR sliding cone options
2171  ATH_CHECK( m_orToolbox.eleJetORT.setProperty("UseSlidingDR", m_orDoBoostedElectron) );
2172  ATH_CHECK( m_orToolbox.muJetORT.setProperty("UseSlidingDR", m_orDoBoostedMuon) );
2173 
2174  //add custom tau-jet OR tool
2175  if(m_orDoTau){
2176  m_orToolbox.tauJetORT.setTypeAndName("ORUtils::TauJetOverlapTool/" + orFlags.masterName + ".TauJetORT");
2177  ATH_CHECK( m_orToolbox.tauJetORT.setProperty("BJetLabel", m_orDoTauBjet?bJetLabel:"") );
2178  }
2179 
2180  // override sliding cone params if sliding dR is on and the user-provided parameter values are non-negative
2181  if (m_orDoBoostedElectron) {
2182  if (m_orBoostedElectronC1 > 0) ATH_CHECK( m_orToolbox.eleJetORT.setProperty("SlidingDRC1", m_orBoostedElectronC1) );
2183  if (m_orBoostedElectronC2 > 0) ATH_CHECK( m_orToolbox.eleJetORT.setProperty("SlidingDRC2", m_orBoostedElectronC2) );
2184  if (m_orBoostedElectronMaxConeSize > 0) ATH_CHECK( m_orToolbox.eleJetORT.setProperty("SlidingDRMaxCone", m_orBoostedElectronMaxConeSize) );
2185  }
2186  if (m_orDoBoostedMuon) {
2187  if (m_orBoostedMuonC1 > 0) ATH_CHECK( m_orToolbox.muJetORT.setProperty("SlidingDRC1", m_orBoostedMuonC1) );
2188  if (m_orBoostedMuonC2 > 0) ATH_CHECK( m_orToolbox.muJetORT.setProperty("SlidingDRC2", m_orBoostedMuonC2) );
2189  if (m_orBoostedMuonMaxConeSize > 0) ATH_CHECK( m_orToolbox.muJetORT.setProperty("SlidingDRMaxCone", m_orBoostedMuonMaxConeSize) );
2190  }
2191 
2192  // and switch off lep-bjet check if not requested
2193  if (!m_orDoElBjet) {
2194  ATH_CHECK(m_orToolbox.eleJetORT.setProperty("BJetLabel", ""));
2195  }
2196  if (!m_orDoMuBjet) {
2197  ATH_CHECK(m_orToolbox.muJetORT.setProperty("BJetLabel", ""));
2198  }
2199 
2200  // propagate the mu-jet ghost-association option which might be set by the user (default is true)
2201  ATH_CHECK(m_orToolbox.muJetORT.setProperty("UseGhostAssociation", m_orDoMuonJetGhostAssociation));
2202 
2203  // propagate mu-jet OR settings if requested
2204  ATH_CHECK(m_orToolbox.muJetORT.setProperty("ApplyRelPt", m_orApplyRelPt) );
2205  if(m_orApplyRelPt){
2206  if (m_orMuJetPtRatio > 0) ATH_CHECK(m_orToolbox.muJetORT.setProperty("MuJetPtRatio", m_orMuJetPtRatio) );
2207  if (m_orMuJetTrkPtRatio > 0) ATH_CHECK(m_orToolbox.muJetORT.setProperty("MuJetTrkPtRatio", m_orMuJetTrkPtRatio) );
2208  }
2209  if (m_orMuJetInnerDR > 0) ATH_CHECK(m_orToolbox.muJetORT.setProperty("InnerDR", m_orMuJetInnerDR) );
2210 
2211  // propagate the calo muon setting for EleMuORT
2212  ATH_CHECK(m_orToolbox.eleMuORT.setProperty("RemoveCaloMuons", m_orRemoveCaloMuons) );
2213 
2214  // Use electron-muon DR matching to remove electrons within DR < 0.01 of Muons.
2215  if (m_orDoElMu){
2216  ATH_CHECK(m_orToolbox.eleMuORT.setProperty("UseDRMatching", m_orDoElMu) );
2217  }
2218 
2219  // propagate the fatjets OR settings
2220  if(m_orDoFatjets){
2221  if(m_EleFatJetDR>0) ATH_CHECK(m_orToolbox.eleFatJetORT.setProperty("DR", m_EleFatJetDR));
2222  if(m_JetFatJetDR>0) ATH_CHECK(m_orToolbox.jetFatJetORT.setProperty("DR", m_JetFatJetDR));
2223  }
2224 
2225  // Make sure that we deal with prorities correctly
2226  ATH_CHECK(m_orToolbox.eleJetORT.setProperty("EnableUserPriority", true));
2227  ATH_CHECK(m_orToolbox.muJetORT.setProperty("EnableUserPriority", true));
2228  if (m_orDoTau) ATH_CHECK(m_orToolbox.tauJetORT.setProperty("EnableUserPriority", true));
2229  if (m_orDoPhoton) ATH_CHECK(m_orToolbox.phoJetORT.setProperty("EnableUserPriority", true));
2230 
2231  if ( m_orPhotonFavoured ) {
2232  ATH_CHECK(m_orToolbox.phoEleORT.setProperty("SwapContainerPrecedence", true));
2233  ATH_CHECK(m_orToolbox.phoMuORT.setProperty("SwapContainerPrecedence", true));
2234  }
2235 
2236  if (!m_orDoEleJet){
2237  // Disable the electron removal part of e-j overlap removal
2238  ATH_CHECK( m_orToolbox.eleJetORT.setProperty("OuterDR",-1.) );
2239  ATH_CHECK( m_orToolbox.eleJetORT.setProperty("SlidingDRMaxCone",-1.) );
2240  }
2241  if (!m_orDoMuonJet){
2242  // Disable the muon removal part of m-j overlap removal
2243  ATH_CHECK( m_orToolbox.muJetORT.setProperty("OuterDR",-1.) );
2244  ATH_CHECK( m_orToolbox.muJetORT.setProperty("SlidingDRMaxCone",-1.) );
2245  }
2246 
2247  ATH_CHECK( m_orToolbox.initialize() );
2248 
2249  }
2250  // Done with the OR toolbox setup!
2251 
2252 // /////////////////////////////////////////////////////////////////////////////////////////
2253 // Initialise PMG Tools
2254  if (!m_pmgSHnjetWeighter.isUserConfigured()) {
2255  m_pmgSHnjetWeighter.setTypeAndName("PMGTools::PMGSherpa22VJetsWeightTool/PMGSHVjetReweighter");
2256  ATH_CHECK( m_pmgSHnjetWeighter.setProperty( "TruthJetContainer", "AntiKt4TruthJets"));
2257  ATH_CHECK( m_pmgSHnjetWeighter.setProperty("OutputLevel", this->msg().level()) );
2258  ATH_CHECK( m_pmgSHnjetWeighter.retrieve());
2259  } else ATH_CHECK( m_pmgSHnjetWeighter.retrieve());
2260 
2261 
2262  if (!m_pmgSHnjetWeighterWZ.isUserConfigured()) {
2263  m_pmgSHnjetWeighterWZ.setTypeAndName("PMGTools::PMGSherpa22VJetsWeightTool/PMGSHVjetReweighterWZ");
2264  ATH_CHECK( m_pmgSHnjetWeighterWZ.setProperty( "TruthJetContainer", "AntiKt4TruthWZJets"));
2265  ATH_CHECK( m_pmgSHnjetWeighterWZ.setProperty("OutputLevel", this->msg().level()) );
2266  ATH_CHECK( m_pmgSHnjetWeighterWZ.retrieve() );
2267  } else ATH_CHECK( m_pmgSHnjetWeighterWZ.retrieve() );
2268 
2269 
2270  // prevent these initialiation snippets from being run again
2271  m_subtool_init = true;
2272 
2273  ATH_MSG_INFO("Done initialising SUSYTools");
2274 
2275  return StatusCode::SUCCESS;
2276 }
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:808
ST::SUSYObjDef_xAOD::m_orBoostedMuonC1
double m_orBoostedMuonC1
Definition: SUSYObjDef_xAOD.h:761
ST::SUSYObjDef_xAOD::m_muonEfficiencySFTool
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonEfficiencySFTool
Definition: SUSYObjDef_xAOD.h:856
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:958
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:757
ST::SUSYObjDef_xAOD::m_orBoostedMuonC2
double m_orBoostedMuonC2
Definition: SUSYObjDef_xAOD.h:762
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:887
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:828
ST::SUSYObjDef_xAOD::m_tauSelTool
asg::AnaToolHandle< TauAnalysisTools::ITauSelectionTool > m_tauSelTool
Definition: SUSYObjDef_xAOD.h:901
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:737
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:693
ST::SUSYObjDef_xAOD::m_trigGlobalEffCorrTool_multiLep
asg::AnaToolHandle< ITrigGlobalEfficiencyCorrectionTool > m_trigGlobalEffCorrTool_multiLep
Definition: SUSYObjDef_xAOD.h:938
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:924
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:844
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:796
ST::SUSYObjDef_xAOD::m_photonTrigEffTools
ToolHandleArray< IAsgPhotonEfficiencyCorrectionTool > m_photonTrigEffTools
Definition: SUSYObjDef_xAOD.h:895
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:689
ST::SUSYObjDef_xAOD::m_egammaCalibTool
asg::AnaToolHandle< CP::IEgammaCalibrationAndSmearingTool > m_egammaCalibTool
Combined electron collection.
Definition: SUSYObjDef_xAOD.h:882
ST::SUSYObjDef_xAOD::m_trig2016combination_diPhoton
std::string m_trig2016combination_diPhoton
Definition: SUSYObjDef_xAOD.h:942
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:1779
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:838
ST::SUSYObjDef_xAOD::m_orMuJetInnerDR
double m_orMuJetInnerDR
Definition: SUSYObjDef_xAOD.h:767
ST::SUSYObjDef_xAOD::m_muonEfficiencyBMHighPtSFTool
asg::AnaToolHandle< CP::IMuonEfficiencyScaleFactors > m_muonEfficiencyBMHighPtSFTool
Definition: SUSYObjDef_xAOD.h:857
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
ST::SUSYObjDef_xAOD::m_pmgSHnjetWeighterWZ
asg::AnaToolHandle< IWeightTool > m_pmgSHnjetWeighterWZ
Definition: SUSYObjDef_xAOD.h:969
IAsgPhotonIsEMSelector.h
ST::SUSYObjDef_xAOD::m_legsPerTool
std::map< std::string, std::string > m_legsPerTool
Definition: SUSYObjDef_xAOD.h:812
ST::SUSYObjDef_xAOD::m_orDoElBjet
bool m_orDoElBjet
Definition: SUSYObjDef_xAOD.h:753
ST::SUSYObjDef_xAOD::m_tauSmearingToolGenerator
std::string m_tauSmearingToolGenerator
Definition: SUSYObjDef_xAOD.h:722
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:946
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:866
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:883
ITrigGlobalEfficiencyCorrectionTool.h
ST::SUSYObjDef_xAOD::m_orMuJetPtRatio
double m_orMuJetPtRatio
Definition: SUSYObjDef_xAOD.h:765
IIsolationCloseByCorrectionTool.h
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_trig_mixLep
std::vector< asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > > m_elecEfficiencySFTool_trig_mixLep
Definition: SUSYObjDef_xAOD.h:874
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:824
ST::SUSYObjDef_xAOD::m_fJvtConfigRun2
std::string m_fJvtConfigRun2
Definition: SUSYObjDef_xAOD.h:740
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:890
ST::SUSYObjDef_xAOD::m_isoBaselineTool
asg::AnaToolHandle< CP::IIsolationSelectionTool > m_isoBaselineTool
Definition: SUSYObjDef_xAOD.h:957
ST::SUSYObjDef_xAOD::m_elecTrigEffTools
ToolHandleArray< IAsgElectronEfficiencyCorrectionTool > m_elecTrigEffTools
Definition: SUSYObjDef_xAOD.h:877
ST::SUSYObjDef_xAOD::m_JvtConfigRun2
std::string m_JvtConfigRun2
Definition: SUSYObjDef_xAOD.h:730
ST::SUSYObjDef_xAOD::m_tauSmearingTool
asg::AnaToolHandle< TauAnalysisTools::ITauSmearingTool > m_tauSmearingTool
Definition: SUSYObjDef_xAOD.h:903
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:914
ST::SUSYObjDef_xAOD::m_trig2018combination_diPhoton
std::string m_trig2018combination_diPhoton
Definition: SUSYObjDef_xAOD.h:944
ST::SUSYObjDef_xAOD::m_trigNToys_diPhoton
int m_trigNToys_diPhoton
Definition: SUSYObjDef_xAOD.h:940
ST::SUSYObjDef_xAOD::m_TopTaggerTool
asg::AnaToolHandle< JSSWTopTaggerDNN > m_TopTaggerTool
Definition: SUSYObjDef_xAOD.h:832
ST::SUSYObjDef_xAOD::m_orBtagWP
std::string m_orBtagWP
Definition: SUSYObjDef_xAOD.h:770
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:858
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:746
ST::SUSYObjDef_xAOD::m_prwTool
asg::AnaToolHandle< CP::IPileupReweightingTool > m_prwTool
Definition: SUSYObjDef_xAOD.h:961
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:934
ST::SUSYObjDef_xAOD::m_WTaggerTool
asg::AnaToolHandle< SmoothedWZTagger > m_WTaggerTool
Definition: SUSYObjDef_xAOD.h:830
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:810
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:894
ST::SUSYObjDef_xAOD::m_orDoFatjets
bool m_orDoFatjets
Definition: SUSYObjDef_xAOD.h:776
ST::SUSYObjDef_xAOD::m_trigMatchingTool
asg::AnaToolHandle< Trig::IMatchingTool > m_trigMatchingTool
Definition: SUSYObjDef_xAOD.h:950
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:818
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:878
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:943
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:752
ST::SUSYObjDef_xAOD::m_eleEffMapFilePath
std::string m_eleEffMapFilePath
Definition: SUSYObjDef_xAOD.h:687
ST::SUSYObjDef_xAOD::m_orDoPhoton
bool m_orDoPhoton
Definition: SUSYObjDef_xAOD.h:747
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:966
ST::SUSYObjDef_xAOD::m_tauConfigPath
std::string m_tauConfigPath
Definition: SUSYObjDef_xAOD.h:718
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:863
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:729
IEGammaAmbiguityTool.h
ST::SUSYObjDef_xAOD::m_btagEffTool_trkJet
asg::AnaToolHandle< IBTaggingEfficiencyTool > m_btagEffTool_trkJet
Definition: SUSYObjDef_xAOD.h:911
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:790
ST::SUSYObjDef_xAOD::m_orLinkOverlapObjects
bool m_orLinkOverlapObjects
Definition: SUSYObjDef_xAOD.h:774
IMuonSelectionTool.h
PATCore::ParticleDataType::Full
@ Full
Definition: PATCoreEnums.h:22
ST::SUSYObjDef_xAOD::m_eleEffMapFilePathRun2
std::string m_eleEffMapFilePathRun2
Definition: SUSYObjDef_xAOD.h:688
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_isoHighPt
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_isoHighPt
Definition: SUSYObjDef_xAOD.h:871
ST::SUSYObjDef_xAOD::m_orBoostedMuonMaxConeSize
double m_orBoostedMuonMaxConeSize
Definition: SUSYObjDef_xAOD.h:763
ST::SUSYObjDef_xAOD::m_photonEfficiencySFTool
asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > m_photonEfficiencySFTool
Definition: SUSYObjDef_xAOD.h:888
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:930
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:760
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:798
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:875
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:867
IPileupReweightingTool.h
ST::SUSYObjDef_xAOD::m_tauConfigReader
TEnv m_tauConfigReader
Definition: SUSYObjDef_xAOD.h:723
ST::SUSYObjDef_xAOD::m_IsoCloseByORpassLabel
std::string m_IsoCloseByORpassLabel
Definition: SUSYObjDef_xAOD.h:786
ST::SUSYObjDef_xAOD::m_tauSmearingToolRecommendationTag
std::string m_tauSmearingToolRecommendationTag
Definition: SUSYObjDef_xAOD.h:721
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:815
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:893
ST::SUSYObjDef_xAOD::m_trigNToys_multiLep
int m_trigNToys_multiLep
Definition: SUSYObjDef_xAOD.h:932
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:892
ST::SUSYObjDef_xAOD::m_orDoEleJet
bool m_orDoEleJet
Definition: SUSYObjDef_xAOD.h:748
ST::SUSYObjDef_xAOD::m_orPhotonFavoured
bool m_orPhotonFavoured
Definition: SUSYObjDef_xAOD.h:772
ST::SUSYObjDef_xAOD::m_jesCalibArea
std::string m_jesCalibArea
Definition: SUSYObjDef_xAOD.h:850
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:859
ST::SUSYObjDef_xAOD::m_jesCalibSeq
std::string m_jesCalibSeq
Definition: SUSYObjDef_xAOD.h:847
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:695
ST::SUSYObjDef_xAOD::m_jetUncertaintiesTool
asg::AnaToolHandle< ICPJetUncertaintiesTool > m_jetUncertaintiesTool
Definition: SUSYObjDef_xAOD.h:817
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:764
ST::SUSYObjDef_xAOD::m_muonCalibTool
asg::AnaToolHandle< CP::IMuonCalibrationAndSmearingTool > m_muonCalibTool
Definition: SUSYObjDef_xAOD.h:855
ST::SUSYObjDef_xAOD::m_ZTaggerTool
asg::AnaToolHandle< SmoothedWZTagger > m_ZTaggerTool
Definition: SUSYObjDef_xAOD.h:831
ST::SUSYObjDef_xAOD::m_orDoMuBjet
bool m_orDoMuBjet
Definition: SUSYObjDef_xAOD.h:754
PATCoreEnums.h
ST::SUSYObjDef_xAOD::m_orRemoveCaloMuons
bool m_orRemoveCaloMuons
Definition: SUSYObjDef_xAOD.h:769
ST::SUSYObjDef_xAOD::m_trig2017combination_multiLep
std::string m_trig2017combination_multiLep
Definition: SUSYObjDef_xAOD.h:935
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:813
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:827
ST::SUSYObjDef_xAOD::m_photonSelIsEM
asg::AnaToolHandle< IAsgPhotonIsEMSelector > m_photonSelIsEM
Definition: SUSYObjDef_xAOD.h:885
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
ST::SUSYObjDef_xAOD::m_trig2016combination_diLep
std::string m_trig2016combination_diLep
Definition: SUSYObjDef_xAOD.h:926
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:915
ST::SUSYObjDef_xAOD::m_BtagMinPt_trkJet
double m_BtagMinPt_trkJet
Definition: SUSYObjDef_xAOD.h:674
ST::SUSYObjDef_xAOD::m_orDoElEl
bool m_orDoElEl
Definition: SUSYObjDef_xAOD.h:749
ST::SUSYObjDef_xAOD::m_jetPileupLabelingTool
asg::AnaToolHandle< JetPileupLabelingTool > m_jetPileupLabelingTool
Definition: SUSYObjDef_xAOD.h:823
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:902
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:928
ST::SUSYObjDef_xAOD::m_jesConfigFat
std::string m_jesConfigFat
Definition: SUSYObjDef_xAOD.h:845
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:933
ST::SUSYObjDef_xAOD::m_btagSelTool_trkJet
asg::AnaToolHandle< IBTaggingSelectionTool > m_btagSelTool_trkJet
Definition: SUSYObjDef_xAOD.h:912
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:869
ST::SUSYObjDef_xAOD::m_orDoElMu
bool m_orDoElMu
Definition: SUSYObjDef_xAOD.h:750
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:870
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:794
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:904
LikeEnum::Tight
@ Tight
Definition: LikelihoodEnums.h:15
ST::SUSYObjDef_xAOD::m_fJvtPtMax
double m_fJvtPtMax
Definition: SUSYObjDef_xAOD.h:738
ST::SUSYObjDef_xAOD::EG_WP
std::string EG_WP(const std::string &wp) const
Definition: SUSYObjDef_xAOD.cxx:1209
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:1197
ST::SUSYObjDef_xAOD::m_elecSelLikelihoodBaseline
asg::AnaToolHandle< IAsgElectronLikelihoodTool > m_elecSelLikelihoodBaseline
Definition: SUSYObjDef_xAOD.h:884
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:948
PathResolver.h
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:905
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:854
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:743
ST::SUSYObjDef_xAOD::m_muz0
double m_muz0
Definition: SUSYObjDef_xAOD.h:697
ST::SUSYObjDef_xAOD::m_JvtWP
std::string m_JvtWP
Definition: SUSYObjDef_xAOD.h:728
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:736
ST::SUSYObjDef_xAOD::m_isoCloseByTool
asg::AnaToolHandle< CP::IIsolationCloseByCorrectionTool > m_isoCloseByTool
Definition: SUSYObjDef_xAOD.h:959
ICPJetUncertaintiesTool.h
ST::SUSYObjDef_xAOD::m_elecEfficiencySFTool_trig_singleLep
asg::AnaToolHandle< IAsgElectronEfficiencyCorrectionTool > m_elecEfficiencySFTool_trig_singleLep
Definition: SUSYObjDef_xAOD.h:868
ST::SUSYObjDef_xAOD::m_trig2018combination_multiLep
std::string m_trig2018combination_multiLep
Definition: SUSYObjDef_xAOD.h:936
ST::SUSYObjDef_xAOD::m_btagSelTool_OR
asg::AnaToolHandle< IBTaggingSelectionTool > m_btagSelTool_OR
Definition: SUSYObjDef_xAOD.h:910
IMuonCalibrationAndSmearingTool.h
ST::SUSYObjDef_xAOD::m_muonSelectionHighPtTool
asg::AnaToolHandle< CP::IMuonSelectionTool > m_muonSelectionHighPtTool
Definition: SUSYObjDef_xAOD.h:853
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:741
ST::SUSYObjDef_xAOD::m_BtagWP_trkJet
std::string m_BtagWP_trkJet
Definition: SUSYObjDef_xAOD.h:672
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:777
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:909
ST::SUSYObjDef_xAOD::m_orDoTauBjet
bool m_orDoTauBjet
Definition: SUSYObjDef_xAOD.h:755
ST::SUSYObjDef_xAOD::m_jetNNJvtSelectionTool
asg::AnaToolHandle< IAsgSelectionTool > m_jetNNJvtSelectionTool
Definition: SUSYObjDef_xAOD.h:825
python.AthDsoLogger.fname
string fname
Definition: AthDsoLogger.py:67
ST::SUSYObjDef_xAOD::m_orMuJetTrkPtRatio
double m_orMuJetTrkPtRatio
Definition: SUSYObjDef_xAOD.h:766
ST::SUSYObjDef_xAOD::m_muonTriggerSFTool
asg::AnaToolHandle< CP::IMuonTriggerScaleFactors > m_muonTriggerSFTool
Definition: SUSYObjDef_xAOD.h:861
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:1221
ST::SUSYObjDef_xAOD::m_btagEffTool
asg::AnaToolHandle< IBTaggingEfficiencyTool > m_btagEffTool
Definition: SUSYObjDef_xAOD.h:908
IMatchingTool.h
ST::SUSYObjDef_xAOD::m_fatJets
std::string m_fatJets
Definition: SUSYObjDef_xAOD.h:800
ST::SUSYObjDef_xAOD::m_muCalibrationMode
int m_muCalibrationMode
Definition: SUSYObjDef_xAOD.h:704
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:759
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:673
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:806
LikeEnum::Medium
@ Medium
Definition: LikelihoodEnums.h:14
ST::SUSYObjDef_xAOD::m_JetFatJetDR
double m_JetFatJetDR
Definition: SUSYObjDef_xAOD.h:778
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:756
ST::SUSYObjDef_xAOD::m_photonSelIsEMBaseline
asg::AnaToolHandle< IAsgPhotonIsEMSelector > m_photonSelIsEMBaseline
Definition: SUSYObjDef_xAOD.h:886
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:791
ST::SUSYObjDef_xAOD::m_trigDecTool
asg::AnaToolHandle< Trig::TrigDecisionTool > m_trigDecTool
Definition: SUSYObjDef_xAOD.h:949
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:799
FullCPAlgorithmsTest_CA.inputfile
dictionary inputfile
Definition: FullCPAlgorithmsTest_CA.py:59
ST::SUSYObjDef_xAOD::m_jesCalibSeqFat
std::string m_jesCalibSeqFat
Definition: SUSYObjDef_xAOD.h:849
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:841
ST::SUSYObjDef_xAOD::m_tauConfigPathBaseline
std::string m_tauConfigPathBaseline
Definition: SUSYObjDef_xAOD.h:719
ST::SUSYObjDef_xAOD::m_jetFatCalibTool
asg::AnaToolHandle< IJetCalibrationTool > m_jetFatCalibTool
Definition: SUSYObjDef_xAOD.h:816
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:826
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:927
ST::SUSYObjDef_xAOD::m_trigDRScoringTool
asg::AnaToolHandle< Trig::IMatchScoringTool > m_trigDRScoringTool
Definition: SUSYObjDef_xAOD.h:952
ST::SUSYObjDef_xAOD::m_trig2015combination_diLep
std::string m_trig2015combination_diLep
Definition: SUSYObjDef_xAOD.h:925
ST::SUSYObjDef_xAOD::m_jetTruthLabelingTool
asg::AnaToolHandle< JetTruthLabelingTool > m_jetTruthLabelingTool
Definition: SUSYObjDef_xAOD.h:833
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:916
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_orBoostedElectronC2
double m_orBoostedElectronC2
Definition: SUSYObjDef_xAOD.h:758
TauAnalysisTools::JETIDNONEUNCONFIGURED
@ JETIDNONEUNCONFIGURED
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/TauAnalysisTools/Enums.h:13
ST::SUSYObjDef_xAOD::m_orInputLabel
std::string m_orInputLabel
Definition: SUSYObjDef_xAOD.h:771
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:696
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:860
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:862
ST::SUSYObjDef_xAOD::m_jetCleaningTool
asg::AnaToolHandle< IJetSelector > m_jetCleaningTool
Definition: SUSYObjDef_xAOD.h:820
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:768
ST::SUSYObjDef_xAOD::m_isoCorrTool
asg::AnaToolHandle< CP::IIsolationCorrectionTool > m_isoCorrTool
Definition: SUSYObjDef_xAOD.h:954
ST::SUSYObjDef_xAOD::m_defaultTruthJets
std::string m_defaultTruthJets
Definition: SUSYObjDef_xAOD.h:801
ST::SUSYObjDef_xAOD::m_tauDoTTM
bool m_tauDoTTM
Definition: SUSYObjDef_xAOD.h:720
ST::SUSYObjDef_xAOD::m_elecTrigSFTools
ToolHandleArray< IAsgElectronEfficiencyCorrectionTool > m_elecTrigSFTools
Definition: SUSYObjDef_xAOD.h:876
ST::SUSYObjDef_xAOD::m_tauTrigEffTool
std::vector< asg::AnaToolHandle< TauAnalysisTools::ITauEfficiencyCorrectionsTool > > m_tauTrigEffTool
Definition: SUSYObjDef_xAOD.h:906
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:751
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:963
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:788
ST::SUSYObjDef_xAOD::m_EG_corrFNList
std::string m_EG_corrFNList
Definition: SUSYObjDef_xAOD.h:807
ST::SUSYObjDef_xAOD::m_photonIsolationSFTool
asg::AnaToolHandle< IAsgPhotonEfficiencyCorrectionTool > m_photonIsolationSFTool
Definition: SUSYObjDef_xAOD.h:889
ST::SUSYObjDef_xAOD::m_muonSelectionTool
asg::AnaToolHandle< CP::IMuonSelectionTool > m_muonSelectionTool
Definition: SUSYObjDef_xAOD.h:852
ST::SUSYObjDef_xAOD::m_useSigLepForIsoCloseByOR
bool m_useSigLepForIsoCloseByOR
Definition: SUSYObjDef_xAOD.h:785
ST::SUSYObjDef_xAOD::m_egammaAmbiguityTool
asg::AnaToolHandle< IEGammaAmbiguityTool > m_egammaAmbiguityTool
Definition: SUSYObjDef_xAOD.h:897
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:941
ST::SUSYObjDef_xAOD::m_isoTool
asg::AnaToolHandle< CP::IIsolationSelectionTool > m_isoTool
Definition: SUSYObjDef_xAOD.h:955
ST::SUSYObjDef_xAOD::m_JvtConfigRun3
std::string m_JvtConfigRun3
Definition: SUSYObjDef_xAOD.h:731
ST::SUSYObjDef_xAOD::m_pmgSHnjetWeighter
asg::AnaToolHandle< IWeightTool > m_pmgSHnjetWeighter
Definition: SUSYObjDef_xAOD.h:968
Generated on Thu Nov 7 2024 21:26:47 for ATLAS Offline Software by   doxygen 1.8.18