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