ATLAS Offline Software
SUSYToolsAlg.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 // SUSYToolsAlg.cxx
6 // Base class
7 #include "SUSYTools/SUSYToolsAlg.h"
8 
9 // EDM includes
10 #include "xAODEventInfo/EventInfo.h"
11 #include "xAODMuon/MuonContainer.h"
12 #include "xAODEgamma/ElectronContainer.h"
13 #include "xAODEgamma/PhotonContainer.h"
14 #include "xAODJet/JetContainer.h"
15 #include "xAODTau/TauJetContainer.h"
16 #include "xAODMissingET/MissingETContainer.h"
17 #include "xAODMissingET/MissingETAuxContainer.h"
18 #include "xAODTrigger/TrigCompositeContainer.h"
19 
20 // For shallow copy containers
21 #include "xAODCore/ShallowCopy.h"
22 
23 // For the forcing of the tau truth container build
24 #include "TauAnalysisTools/ITauTruthMatchingTool.h"
25 
26 // GRL
27 #include "AsgAnalysisInterfaces/IGoodRunsListSelectionTool.h"
28 
29 // For handling systematics
30 #include "AsgMessaging/StatusCode.h"
31 #include "PATInterfaces/SystematicSet.h"
32 
33 // For finding calibration files
34 #include "PathResolver/PathResolver.h"
35 
36 // For CBK access
37 #include "xAODCutFlow/CutBookkeeper.h"
38 #include "xAODCutFlow/CutBookkeeperContainer.h"
39 #ifndef XAOD_STANDALONE // For now metadata is Athena-only
40 #include "AthAnalysisBaseComps/AthAnalysisHelper.h"
41 #include "EventInfo/EventStreamInfo.h"
42 #endif
43 
44 // Common accessors
45 #include "SUSYTools/SUSYObjDef_xAOD.h"
46 
47 // For output of histograms
48 #include "TH1.h"
49 #include "TH2.h"
50 #include "TFile.h"
51 #include "TEfficiency.h"
52 //#include <AnaAlgorithm/IHistogramWorker.h>
53 
54 // For configuration
55 #include "TString.h"
56 #include "TEnv.h"
57 #include "THashList.h"
58 
59 // For string manipulation
60 #include <regex>
61 #include <cmath>
62 #include <atomic>
63 
64 //====================================================================================================
65 namespace Cut {
66  const unsigned int NSel=5;
67  enum { all=0, baseline, passOR, signal, trigmatch };
68  static const TString SCut[] = {"All","Baseline","passOR","Signal","TrigM"};
69 }
70 
71 //====================================================================================================
72 std::string findInReg(SG::AuxTypeRegistry& reg, xAOD::IParticle* obj, const std::string& searchkey);
73 int getSize(std::map<std::string,std::vector<std::string>> &collection, const std::string& object);
74 
75 //====================================================================================================
76 // Constructor
77 SUSYToolsAlg::SUSYToolsAlg(const std::string& name,
78  ISvcLocator* pSvcLocator )
79  : EL::AnaAlgorithm (name, pSvcLocator)
80  , m_SUSYTools("ST::SUSYObjDef_xAOD/SUSYTools",this)
81  , m_tauTruthMatchingTool("TauAnalysisTools::TauTruthMatchingTool/TauTruthMatchingTool")
82  , m_Nevts(0)
83  , m_kernel("StreamDAOD")
84  , m_configFile("SUSYTools/SUSYTools_Default.conf")
85 {
86 
87  declareProperty( "DoSyst", m_doSyst = false );
88  declareProperty( "GRLFiles", m_GRLFiles );
89  declareProperty( "maxEvts", m_maxEvts = -999 );
90  declareProperty( "LumiBlockFilter", m_lbfilter = 90 );
91 
92 
93  // asg Tool Handles must be dealt with differently
94  m_tauTruthMatchingTool.declarePropertyFor( this, "TauTruthMatchingTool", "The TTMT" );
95  m_SUSYTools.declarePropertyFor( this, "SUSYTools", "The SUSYTools instance" );
96 }
97 
98 //====================================================================================================
99 // Destructor
100 SUSYToolsAlg::~SUSYToolsAlg() { }
101 
102 //====================================================================================================
103 // Initialize
104 StatusCode SUSYToolsAlg::initialize() {
105  ATH_MSG_INFO("Initializing " << name() << "...");
106 
107  ATH_CHECK(m_SUSYTools.retrieve());
108  ATH_MSG_INFO("Retrieved tool: " << m_SUSYTools->name() );
109 
110  // read some of the property values (may have been autoconfigured at this point)
111  m_mcCampaign = *(m_SUSYTools->getProperty<std::string>("mcCampaign"));
112  m_isPHYSLITE = *(m_SUSYTools->getProperty<bool>("IsPHYSLITE"));
113 
114 
115  // Need truth matching for tau CP tools
116  if( !m_SUSYTools->isData() ){
117  m_tauTruthMatchingTool.setTypeAndName("TauAnalysisTools::TauTruthMatchingTool/TauTruthMatchingTool");
118  ATH_CHECK( m_tauTruthMatchingTool.setProperty("TruthJetContainerName", "AntiKt4TruthDressedWZJets") );
119  ATH_CHECK( m_tauTruthMatchingTool.retrieve() );
120  ATH_MSG_INFO("Retrieved tool: " << m_tauTruthMatchingTool->name() );
121  }
122 
123  // GRL tool
124  if (m_SUSYTools->isData()) {
125  m_grl.setTypeAndName("GoodRunsListSelectionTool/grl");
126  m_grl.isUserConfigured();
127 
128  std::vector<std::string> myGRLs;
129  for ( const auto& x : m_GRLFiles ) myGRLs.push_back(x);
130 
131  ANA_CHECK( m_grl.setProperty("GoodRunsListVec", myGRLs) );
132  ANA_CHECK( m_grl.setProperty("PassThrough", (myGRLs.size()>0?false:true)) );
133  ANA_CHECK( m_grl.retrieve() );
134 
135  ATH_MSG_INFO("GRL tool retrieved & initialized: " << m_grl->name() );
136  }
137 
138  // Systematics
139  m_sysInfoList.clear();
140  // this is the nominal set
141  if (m_doSyst) {
142  m_sysInfoList = m_SUSYTools->getSystInfoList();
143  } else {
144  ST::SystInfo infodef;
145  infodef.affectsKinematics = false;
146  infodef.affectsWeights = false;
147  infodef.affectsType = ST::Unknown;
148  m_sysInfoList.push_back(infodef);
149  }
150  // order in object groups
151  groupSysts();
152 
153  // setup triggers to be checked
154  m_triggers.clear();
155  if(m_mcCampaign.find("mc20") != std::string::npos){
156  // Trigger for Run2
157  m_triggers["el"] = {};
158  m_triggers["el"].push_back("HLT_e24_lhtight_nod0_ivarloose");
159  m_triggers["el"].push_back("HLT_e60_lhmedium_nod0");
160  m_triggers["el"].push_back("HLT_e26_lhtight_nod0_ivarloose");
161  m_triggers["el"].push_back("HLT_e140_lhloose_nod0");
162  m_triggers["el"].push_back("HLT_e24_lhtight_ivarloose_L1EM22VHI");
163  m_triggers["el"].push_back("HLT_e24_lhtight_ivarloose_L1eEM26M");
164  m_triggers["el"].push_back("HLT_e26_lhtight_ivarloose_L1EM22VHI");
165  m_triggers["el"].push_back("HLT_e26_lhtight_ivarloose_L1eEM26M");
166  m_triggers["el"].push_back("HLT_e60_lhvloose_L1eEM26M");
167  m_triggers["el"].push_back("HLT_e60_lhvloose_L1EM22VHI");
168 
169  m_triggers["ph"] = {};
170  m_triggers["ph"].push_back("HLT_g120_loose");
171  m_triggers["ph"].push_back("HLT_g140_loose");
172  m_triggers["ph"].push_back("HLT_g120_loose_L1eEM26M");
173  m_triggers["ph"].push_back("HLT_g120_loose_L1EM22VHI");
174  m_triggers["ph"].push_back("HLT_g140_loose_L1eEM26M");
175  m_triggers["ph"].push_back("HLT_g140_loose_L1EM22VHI");
176 
177  m_triggers["mu"] = {};
178  m_triggers["mu"].push_back("HLT_mu24_ivarmedium");
179  m_triggers["mu"].push_back("HLT_mu26_ivarmedium");
180  m_triggers["mu"].push_back("HLT_mu50");
181  m_triggers["mu"].push_back("HLT_mu24_ivarmedium_L1MU14FCH");
182  m_triggers["mu"].push_back("HLT_mu24_ivarmedium_L1MU18VFCH");
183  m_triggers["mu"].push_back("HLT_mu26_ivarmedium_L1MU14FCH");
184  m_triggers["mu"].push_back("HLT_mu26_ivarmedium_L1MU18VFCH");
185  }
186  else{
187  // Trigger for Run3
188  m_triggers["el"] = {};
189  m_triggers["el"].push_back("HLT_e26_lhtight_ivarloose_L1EM22VHI");
190  m_triggers["el"].push_back("HLT_e60_lhmedium_L1EM22VHI");
191  m_triggers["el"].push_back("HLT_e140_lhloose_L1EM22VHI");
192 
193  m_triggers["ph"] = {};
194  m_triggers["ph"].push_back("HLT_g140_loose_L1EM22VHI");
195  m_triggers["ph"].push_back("HLT_g300_L1EM22VHI"); // HLT_g300_etcut_L1EM22VHI not working in mc21
196 
197  m_triggers["mu"] = {};
198  m_triggers["mu"].push_back("HLT_mu24_ivarmedium_L1MU14FCH");
199  m_triggers["mu"].push_back("HLT_mu50_L1MU14FCH");
200  m_triggers["mu"].push_back("HLT_mu60_0eta105_msonly_L1MU14FCH");
201  m_triggers["mu"].push_back("HLT_mu60_L1MU14FCH");
202  m_triggers["mu"].push_back("HLT_mu80_msonly_3layersEC_L1MU14FCH");
203 
204  }
205 
206 
207  // book histograms
208  ATH_CHECK( bookHistograms() );
209 
210  // retrieve SUSYTools config file
211  TEnv rEnv;
212  int success = -1;
213  m_configFile = (PathResolverFindCalibFile(m_configFile)).c_str();
214  success = rEnv.ReadFile(m_configFile.c_str(), kEnvAll);
215  if(success != 0){
216  ATH_MSG_ERROR( "Cannot open config file!");
217  return StatusCode::FAILURE;
218  }
219  ATH_MSG_INFO( "Config file opened" );
220 
221  m_configDict.clear();
222  m_configDict["Jet.LargeRcollection"] = rEnv.GetValue("Jet.LargeRcollection", "AntiKt10LCTopoTrimmedPtFrac5SmallR20Jets" );
223  m_configDict["TrackJet.Collection"] = rEnv.GetValue("TrackJet.Collection", "AntiKtVR30Rmax4Rmin02TrackJets" );
224  m_configDict["Jet.WtaggerConfig"] = rEnv.GetValue("Jet.WtaggerConfig", "None");
225  m_configDict["Jet.ZtaggerConfig"] = rEnv.GetValue("Jet.ZtaggerConfig", "None");
226  m_configDict["Jet.ToptaggerConfig"] = rEnv.GetValue("Jet.ToptaggerConfig", "None");
227 
228  // Trim comments and extra spaces from config entries
229  std::regex comment("#.*$");
230  std::regex trimspaces("^ +| +$|( ) +");
231  for (const auto& keyval : m_configDict) {
232  m_configDict[keyval.first] = regex_replace(m_configDict[keyval.first], comment, "");
233  m_configDict[keyval.first] = regex_replace(m_configDict[keyval.first], trimspaces, "$1");
234  ATH_MSG_DEBUG("config " << keyval.first << " : " << m_configDict[keyval.first]);
235  }
236  m_FatJetCollection = m_configDict["Jet.LargeRcollection"];
237  m_TrkJetCollection = m_configDict["TrackJet.Collection"];
238  if (m_configDict["TrackJet.Collection"].find("None")!=std::string::npos) m_TrkJetCollection = "";
239 
240  m_slices.clear();
241  m_slices["ele"] = bool(rEnv.GetValue("Slices.Ele", true));
242  m_slices["pho"] = bool(rEnv.GetValue("Slices.Pho", true));
243  m_slices["mu"] = bool(rEnv.GetValue("Slices.Mu", true));
244  m_slices["tau"] = bool(rEnv.GetValue("Slices.Tau", true));
245  m_slices["jet"] = bool(rEnv.GetValue("Slices.Jet", true));
246  m_slices["bjet"] = bool(rEnv.GetValue("Slices.BJet", true));
247  m_slices["fjet"] = bool(rEnv.GetValue("Slices.FJet", true));
248  m_slices["tjet"] = bool(rEnv.GetValue("Slices.TJet", true));
249  m_slices["met"] = bool(rEnv.GetValue("Slices.MET", true));
250  for (const auto& x : m_slices) { ATH_MSG_DEBUG( "Slice " << x.first << ": " << ((x.second)?"true":"false")); }
251 
252  return StatusCode::SUCCESS;
253 }
254 
255 //====================================================================================================
256 // Finalize
257 StatusCode SUSYToolsAlg::finalize() {
258  ATH_MSG_INFO ("Finalizing " << name() << "...");
259 
260  ATH_MSG_INFO("Time per event: (CPU / WALL)");
261  ATH_MSG_INFO(" Entire loop - " << m_clock0.CpuTime() * 1e3 / m_Nevts << " / " << m_clock0.RealTime() * 1e3 / m_Nevts << " ms");
262  ATH_MSG_INFO(" First event - " << m_clock1.CpuTime() * 1e3 << " / " << m_clock1.RealTime() * 1e3 << " ms");
263  ATH_MSG_INFO(" Excluding first event - " << m_clock2.CpuTime() * 1e3 / (m_Nevts - 1) << " / " << m_clock2.RealTime() * 1e3 / (m_Nevts - 1) << " ms");
264 
265 
266  // label cutflow histograms
267  for (std::string hname : {"el_n_flow_nominal", "ph_n_flow_nominal", "mu_n_flow_nominal", "jet_n_flow_nominal", "bjet_n_flow_nominal", "fatjet_n_flow_nominal", "trkjet_n_flow_nominal", "tau_n_flow_nominal"} ) {
268  TH1* h = hist("Cutflow/"+hname);
269  for (unsigned int i=1; i < Cut::NSel+1; i++){ h->GetXaxis()->SetBinLabel(i, Cut::SCut[i-1].Data()); }
270  h->GetXaxis()->SetLabelSize(0.05);
271  }
272 
273  // normalize and label efficiency histograms
274  for (std::string hname : {"el_trigmatch_eff_nominal", "ph_trigmatch_eff_nominal", "mu_trigmatch_eff_nominal"}) {
275  std::string obj = hname.substr(0,2);
276  TH1* h = hist("Trigger/"+hname);
277  for (unsigned int i=1; i < m_triggers[obj].size()+1; i++){ h->GetXaxis()->SetBinLabel(i, m_triggers[obj][i-1].substr(4,std::string::npos).c_str()); }
278  h->GetXaxis()->SetLabelSize(0.05);
279  if (m_obj_count[obj]["sig"]>0) h->Scale(1./static_cast<float>(m_obj_count[obj]["sig"]));
280  }
281 
282  // label weights histograms
283  std::map<std::string,std::string> mapweights = {{"event","EventWeight"},{"electrons","Electron"},{"photons","Photon"},{"muons","Muon"},{"taus","Tau"},{"jets","Jet"},{"btags","BTag"}};
284  for (const auto& weight : mapweights) {
285  TH1* h = hist("Syst/weight_"+weight.first);
286  std::vector syslist = m_syst_weights[weight.second];
287  for (unsigned int i=1; i < syslist.size()+1; i++) { h->GetXaxis()->SetBinLabel(i, syslist.at(i-1).c_str()); }
288  h->GetXaxis()->SetLabelSize(0.05);
289  // average weight
290  h->Scale(1./static_cast<float>(h->GetBinContent(1)));
291 
292  TH2* h2 = hist2d("Syst/syst_"+weight.first);
293  syslist = m_syst_all[weight.second];
294  for (unsigned int i=1; i < syslist.size()+1; i++) { h2->GetYaxis()->SetBinLabel(syslist.size()-i+1, syslist.at(i-1).c_str()); h2->Fill(0.5,syslist.size()-i,1.); }
295  h2->GetYaxis()->SetLabelSize(0.05);
296  }
297 
298  return StatusCode::SUCCESS;
299 }
300 
301 //====================================================================================================
302 // Execute
303 StatusCode SUSYToolsAlg::execute() {
304  // manual event limit
305  if (m_maxEvts>=0 && m_Nevts>=(unsigned int)m_maxEvts) return StatusCode::SUCCESS;
306 
307  ATH_MSG_VERBOSE("Executing " << name() << "...");
308  m_clock0.Start(false);
309  if (m_Nevts == 0) m_clock1.Start(false);
310  else m_clock2.Start(false);
311 
312  if (m_SUSYTools->resetSystematics() != StatusCode::SUCCESS) {
313  ATH_MSG_ERROR( "Cannot reset SUSYTools systematics" );
314  }
315 
316  // METMaker crashes if there's no PV, check that before anything,
317  // and skip to the next event if there isn't one
318  if (m_SUSYTools->GetPrimVtx() == nullptr) {
319  ATH_MSG_WARNING("No PV found for this event! Skipping...");
320  return StatusCode::SUCCESS;
321  }
322 
323  // call PRW tool to apply all relevant decorations
324  ATH_CHECK( m_SUSYTools->ApplyPRWTool());
325 
326  // get EventInfo
327  const xAOD::EventInfo* evtInfo(0);
328  ATH_CHECK( evtStore()->retrieve(evtInfo, "EventInfo") );
329  bool isData = m_SUSYTools->isData();
330 
331  // manual max events within lumiblock selection (on top of Nevts)
332  if (m_maxEvts>=-1 && (evtInfo->lumiBlock() != (unsigned int)m_lbfilter)) return StatusCode::SUCCESS;
333 
334  // get file/kernel info on first event
335  if ( m_Nevts==0 ) {
336  std::string stream;
337 #ifdef ROOTCORE
338  // Read the CutBookkeeper container on the first event
339  const xAOD::CutBookkeeperContainer* completeCBC = 0;
340  if (!evtStore()->event()->retrieveMetaInput(completeCBC, "CutBookkeepers").isSuccess()) {
341  ATH_MSG_ERROR("Failed to retrieve CutBookkeepers from MetaData! Exiting.");
342  }
343  std::string cbkname;
344  for ( const auto *cbk : *completeCBC ) {
345  cbkname = cbk->name();
346  stream = cbk->inputStream();
347  ATH_MSG_INFO("cbkname: " << cbkname << ", stream: " << stream);
348  if (cbkname.find("PHYSVAL")!=std::string::npos) m_kernel="PHYSVAL";
349  else if (cbkname.find("PHYSLITE")!=std::string::npos) m_kernel="PHYSLITE";
350  else if (cbkname.find("PHYS")!=std::string::npos) m_kernel="PHYS";
351  else if (stream.find("StreamDAOD")!=std::string::npos) m_kernel=stream.replace(stream.find("Stream"),6,"");
352  else m_kernel="other";
353  }
354 #else
355  // check the stream info
356  const EventStreamInfo* esi = 0;
357  CHECK( inputMetaStore()->retrieve(esi) );
358  for ( auto stream : esi->getProcessingTags() ) {
359  if (stream.find("PHYSVAL")!=std::string::npos) m_kernel="PHYSVAL";
360  else if (stream.find("PHYSLITE")!=std::string::npos) m_kernel="PHYSLITE";
361  else if (stream.find("PHYS")!=std::string::npos) m_kernel="PHYS";
362  else if (stream.find("StreamDAOD")!=std::string::npos) m_kernel=stream.replace(stream.find("Stream"),6,"");
363  else m_kernel="other";
364  }
365 #endif
366  ATH_MSG_INFO("Input file kernel type: " << m_kernel);
367  }
368 
369  int period = 100;
370  if (m_Nevts==0 || (m_Nevts % period == 99)) ATH_MSG_INFO("===>>> start processing event #" << evtInfo->eventNumber() << ", run #" << evtInfo->runNumber() << " | " << m_Nevts << " events processed so far <<<===");
371 
372  //==================================================
373  // General info
374  TH1* info_runNo = hist("EventInfo/info_runNo");
375  TH1* info_evtNo = hist("EventInfo/info_evtNo");
376  TH1* info_lumiBlock = hist("EventInfo/info_lumiBlock");
377  info_runNo->Fill(evtInfo->runNumber());
378  info_evtNo->Fill(evtInfo->eventNumber());
379  info_lumiBlock->Fill(evtInfo->lumiBlock());
380 
381  // First, create the nominal containers
382  // Only create them if slice active & configured
383  // Only create them freshly if affected by systematics
384 
385  xAOD::ElectronContainer* electrons_nominal(0);
386  xAOD::ShallowAuxContainer* electrons_nominal_aux(0);
387  if (m_slices["ele"]) {
388  ATH_CHECK( m_SUSYTools->GetElectrons(electrons_nominal, electrons_nominal_aux,true, m_isPHYSLITE?"AnalysisElectrons":"Electrons") );
389  ATH_MSG_DEBUG( "Number of electrons: " << electrons_nominal->size() );
390  }
391 
392  xAOD::PhotonContainer* photons_nominal(0);
393  xAOD::ShallowAuxContainer* photons_nominal_aux(0);
394  if (m_slices["pho"]) {
395  ATH_CHECK( m_SUSYTools->GetPhotons(photons_nominal, photons_nominal_aux, true, m_isPHYSLITE?"AnalysisPhotons":"Photons") );
396  ATH_MSG_DEBUG( "Number of photons: " << photons_nominal->size() );
397  }
398 
399  xAOD::MuonContainer* muons_nominal(0);
400  xAOD::ShallowAuxContainer* muons_nominal_aux(0);
401  if (m_slices["mu"]) {
402  ATH_CHECK( m_SUSYTools->GetMuons(muons_nominal, muons_nominal_aux, true, m_isPHYSLITE?"AnalysisMuons":"Muons") );
403  ATH_MSG_DEBUG( "Number of muons: " << muons_nominal->size() );
404  }
405 
406  xAOD::JetContainer* jets_nominal(0);
407  xAOD::ShallowAuxContainer* jets_nominal_aux(0);
408  if (m_slices["jet"]) {
409  ATH_CHECK( m_SUSYTools->GetJets(jets_nominal, jets_nominal_aux, true, m_isPHYSLITE?"AnalysisJets":"") );
410  ATH_MSG_DEBUG( "Number of jets: " << jets_nominal->size() );
411  }
412 
413  static std::atomic<bool> doFatJets = true; // only create if slice on && collection configured
414  if (m_FatJetCollection.empty()) doFatJets = false;
415  const xAOD::JetContainer* fatjets_test(0);
416  xAOD::JetContainer* fatjets_nominal(0);
417  xAOD::ShallowAuxContainer* fatjets_nominal_aux(0);
418  if( m_slices["fjet"] && doFatJets && evtStore()->contains<xAOD::JetContainer>( m_FatJetCollection ) ){
419  if( !evtStore()->retrieve( fatjets_test, m_FatJetCollection ).isSuccess() ){
420  ATH_MSG_ERROR("Failed to retrieve xAOD::JetContainer with name " << m_FatJetCollection );
421  return StatusCode::FAILURE;
422  } else {
423  ATH_CHECK( m_SUSYTools->GetFatJets(fatjets_nominal,fatjets_nominal_aux,true,m_FatJetCollection,true) );
424  ATH_MSG_DEBUG( "Number of Large Radius jets: " << fatjets_nominal->size() );
425  }
426  } else if( m_slices["jet"] && doFatJets) {
427  ATH_MSG_DEBUG("FatJets xAOD::JetContainer with name " << m_FatJetCollection <<" not found");
428  doFatJets=false;
429  }
430 
431  static std::atomic<bool> doTrkJets = true; // only create if slice on && collection configured
432  if (m_TrkJetCollection.empty()) doTrkJets = false;
433  const xAOD::JetContainer* trkjets_test(0);
434  xAOD::JetContainer* trkjets_nominal(0);
435  xAOD::ShallowAuxContainer* trkjets_nominal_aux(0);
436  if( m_slices["tjet"] && doTrkJets && evtStore()->contains<xAOD::JetContainer>( m_TrkJetCollection ) ){
437  if( !evtStore()->retrieve( trkjets_test, m_TrkJetCollection ).isSuccess() ){
438  ATH_MSG_ERROR("Failed to retrieve xAOD::JetContainer with name " << m_TrkJetCollection );
439  return StatusCode::FAILURE;
440  } else {
441  ATH_CHECK( m_SUSYTools->GetTrackJets(trkjets_nominal,trkjets_nominal_aux,true,m_TrkJetCollection) );
442  ATH_MSG_DEBUG( "Number of track jets: " << trkjets_nominal->size() );
443  }
444  } else if(m_slices["jet"] && doTrkJets) {
445  ATH_MSG_DEBUG("TrkJets xAOD::JetContainer with name " << m_TrkJetCollection <<" not found");
446  doTrkJets=false;
447  }
448 
450  //if( m_slices["tau"] && !isData) {
451  // const xAOD::TauJetContainer* p_TauJets = 0;
452  // ATH_CHECK( evtStore()->retrieve(p_TauJets, "TauJets") );
453  // //if( !evtStore()->contains<xAOD::TruthParticleContainer>("TruthTaus") && p_TauJets->size()==0 ){
454  // // // If there are no taus, then we need to force the building of the container
455  // // ATH_MSG_DEBUG("FIXME: TruthTaus hack for empty TauJets.");
456  // // xAOD::TruthParticleContainer* noTT = new xAOD::TruthParticleContainer;
457  // // xAOD::TruthParticleAuxContainer* noTTAux = new xAOD::TruthParticleAuxContainer;
458  // // noTT->setStore( noTTAux );
459  // // ATH_CHECK( evtStore()->record(noTT, "TruthTaus") );
460  // // ATH_CHECK( evtStore()->record(noTTAux, "TruthTausAux.") );
461  // // ATH_CHECK( m_tauTruthMatchingTool->retrieveTruthTaus() );
462  // //}
463  // for(const auto& tau : *p_TauJets) {
464  // const xAOD::TruthParticle* trueTau = 0;
465  // trueTau = m_tauTruthMatchingTool->getTruth(*tau);
466  // if( trueTau ){
467  // ATH_MSG_DEBUG("getTruth tau " <<tau->pt() <<" " <<tau->eta()
468  // <<" " <<tau->phi()
469  // <<" trueTau " <<trueTau->pt() <<" " <<trueTau->eta()
470  // <<" " <<trueTau->phi());
471  // } else {
472  // ATH_MSG_DEBUG("getTruth tau " <<tau->pt() <<" " <<tau->eta()
473  // <<" " <<tau->phi() << "trueTau not found");
474  // }
475  // }
476  //}
477 
478  const xAOD::TauJetContainer* taus_gettruth(0);
479  xAOD::TauJetContainer* taus_nominal(0);
480  xAOD::ShallowAuxContainer* taus_nominal_aux(0);
481  if (m_slices["tau"]) {
482  if (!isData && !m_isPHYSLITE) {
483  ATH_CHECK( evtStore()->retrieve(taus_gettruth,"TauJets") );
484  for(const auto tau : *taus_gettruth) {
485  m_tauTruthMatchingTool->getTruth(*tau);
486  }
487  }
488  ATH_CHECK( m_SUSYTools->GetTaus(taus_nominal, taus_nominal_aux, true, m_isPHYSLITE?"AnalysisTauJets":"TauJets") );
489  ATH_MSG_DEBUG( "Number of taus: " << taus_nominal->size() );
490  }
491 
492  m_metcst_nominal = new xAOD::MissingETContainer;
493  m_metcst_nominal_aux = new xAOD::MissingETAuxContainer;
494  m_metcst_nominal->setStore(m_metcst_nominal_aux);
495  m_metcst_nominal->reserve(10);
496  m_mettst_nominal = new xAOD::MissingETContainer;
497  m_mettst_nominal_aux = new xAOD::MissingETAuxContainer;
498  m_mettst_nominal->setStore(m_mettst_nominal_aux);
499  m_mettst_nominal->reserve(10);
500 
501  double metsig_cst(0.);
502  double metsig_tst(0.);
503  if (m_slices["met"]) {
504  // (met, jets, electrons, muons, photons, taus, doTST, doJVT)
505  ATH_CHECK( m_SUSYTools->GetMET(*m_metcst_nominal, jets_nominal, electrons_nominal, muons_nominal, photons_nominal, 0, false, false) );
506  ATH_MSG_DEBUG("RefFinal CST etx=" << (*m_metcst_nominal)["Final"]->mpx()
507  << ", ety=" << (*m_metcst_nominal)["Final"]->mpy()
508  << ", et=" << (*m_metcst_nominal)["Final"]->met()
509  << ", sumet=" << (*m_metcst_nominal)["Final"]->sumet());
510  ATH_CHECK( m_SUSYTools->GetMETSig(*m_metcst_nominal, metsig_cst, false, false) );
511  ATH_MSG_DEBUG("METSignificance = " << metsig_cst);
512 
513  ATH_CHECK( m_SUSYTools->GetMET(*m_mettst_nominal, jets_nominal, electrons_nominal, muons_nominal, photons_nominal, 0, true, true) ); // bugfix for PHYSLITE with p5511
514  ATH_MSG_DEBUG("RefFinal TST etx=" << (*m_mettst_nominal)["Final"]->mpx()
515  << ", ety=" << (*m_mettst_nominal)["Final"]->mpy()
516  << ", et=" << (*m_mettst_nominal)["Final"]->met()
517  << ", sumet=" << (*m_mettst_nominal)["Final"]->sumet());
518  ATH_CHECK( m_SUSYTools->GetMETSig(*m_mettst_nominal, metsig_tst, true, true) );
519  ATH_MSG_DEBUG("METSignificance = " << metsig_tst);
520 
521  hist("MET/met_et") ->Fill( (*m_mettst_nominal)["Final"]->met()*0.001 );
522  hist("MET/met_sumet") ->Fill( (*m_mettst_nominal)["Final"]->sumet()*0.001 );
523  hist("MET/met_phi") ->Fill( (*m_mettst_nominal)["Final"]->phi() );
524  hist("MET/met_et_tst")->Fill( (*m_mettst_nominal)["PVSoftTrk"]->met() *0.001 );
525  hist("MET/met_et_el") ->Fill( (*m_mettst_nominal)["RefEle"]->met() *0.001 );
526  hist("MET/met_et_ph") ->Fill( (*m_mettst_nominal)["RefGamma"]->met() *0.001 );
527  hist("MET/met_et_mu") ->Fill( (*m_mettst_nominal)["Muons"]->met() *0.001 );
528  hist("MET/met_et_jet")->Fill( (*m_mettst_nominal)["RefJet"]->met() *0.001 );
529  //hist("MET/met_et_tau")->Fill( (*m_mettst_nominal)["RefTau"]->met() *0.001 );
530 
531  hist("MET/met_significance")->Fill( metsig_tst );
532  }
533 
534  //--- Overlap Removal
535  ATH_CHECK( m_SUSYTools->OverlapRemoval(electrons_nominal, muons_nominal, jets_nominal, photons_nominal, taus_nominal) );
536 
537  //--- Trigger
538  bool isRun3Trig = false;
539  if (m_mcCampaign.find("mc21") != std::string::npos || m_mcCampaign.find("mc23") != std::string::npos) isRun3Trig = true;
540 
541  hist("Trigger/isMETTrigPassed")->Fill( double(m_SUSYTools->IsMETTrigPassed()) );
542 
543  //--- Monitoring
544  for (const auto& obj : m_objects) { for (const auto& lev : m_levels) { m_obj_count[obj][lev] = 0; } }
545 
546  //----- Electrons
547 
548  TH1* el_n_flow_nominal = hist("Cutflow/el_n_flow_nominal");
549  TH1* el_trigmatch_eff_nominal = hist("Trigger/el_trigmatch_eff_nominal");
550 
551  if (m_slices["ele"]) {
552  ATH_MSG_DEBUG("Processing electrons");
553  m_obj_count["el"]["nom"] = electrons_nominal->size();
554  for(auto el : *electrons_nominal) {
555  el_n_flow_nominal->Fill(Cut::all);
556  if ( ST::acc_baseline(*el) == 1 ){
557  el_n_flow_nominal->Fill(Cut::baseline);
558  stdHistsForObj(el,"el","bsl");
559  m_obj_count["el"]["bsl"] += 1;
560 
561  if ( ST::acc_passOR(*el) == 1 ){
562  el_n_flow_nominal->Fill(Cut::passOR);
563  if ( ST::acc_signal(*el) == 1 ){
564  el_n_flow_nominal->Fill(Cut::signal);
565  stdHistsForObj(el,"el","sig");
566  m_obj_count["el"]["sig"] += 1;
567 
568  bool passTM=false;
569  unsigned int idx=1;
570  for(const auto& t : m_triggers["el"]){
571  ATH_MSG_DEBUG( " Processing trigger " << t );
572  bool passit = ((isRun3Trig||t.find("_L1")==std::string::npos) ? m_SUSYTools->IsTrigMatched(el, t) : false);
573  passTM |= passit;
574  if(passit) el_trigmatch_eff_nominal->SetBinContent(idx, el_trigmatch_eff_nominal->GetBinContent(idx)+1);
575  #ifdef XAOD_STANDALONE
576  m_heffs["Trigger/el_pt_"+t]->Fill(passit,el->pt()/1000.);
577  m_heffs["Trigger/el_eta_"+t]->Fill(passit,el->eta());
578  m_heffs["Trigger/el_phi_"+t]->Fill(passit,el->phi());
579  #endif
580  idx++;
581  }
582  if(passTM) el_n_flow_nominal->Fill(Cut::trigmatch);
583  }
584  }
585  }
586  stdHistsForObj(el,"el","nom");
587  }
588  hist("Electron/el_nom_N")->Fill(m_obj_count["el"]["nom"]);
589  hist("Electron/el_bsl_N")->Fill(m_obj_count["el"]["bsl"]);
590  hist("Electron/el_sig_N")->Fill(m_obj_count["el"]["sig"]);
591  }
592 
593  //----- Photons
594 
595  TH1* ph_n_flow_nominal = hist("Cutflow/ph_n_flow_nominal");
596  TH1* ph_trigmatch_eff_nominal = hist("Trigger/ph_trigmatch_eff_nominal");
597 
598  if (m_slices["pho"]) {
599  ATH_MSG_DEBUG("Processing photons");
600  m_obj_count["ph"]["nom"] = photons_nominal->size();
601  for(auto ph : *photons_nominal) {
602  ph_n_flow_nominal->Fill(Cut::all);
603  if ( ST::acc_baseline(*ph) == 1 ){
604  ph_n_flow_nominal->Fill(Cut::baseline);
605  stdHistsForObj(ph,"ph","bsl");
606  m_obj_count["ph"]["bsl"] += 1;
607  if ( ST::acc_passOR(*ph) == 1 ){
608  ph_n_flow_nominal->Fill(Cut::passOR);
609  if ( ST::acc_signal(*ph) == 1 ){
610  ph_n_flow_nominal->Fill(Cut::signal);
611  stdHistsForObj(ph,"ph","sig");
612  m_obj_count["ph"]["sig"] += 1;
613 
614  bool passTM=false;
615  unsigned int idx=1;
616  for(const auto& t : m_triggers["ph"]){
617  bool passit = ((isRun3Trig||t.find("_L1")==std::string::npos) ? m_SUSYTools->IsTrigMatched(ph, t) : false);
618  passTM |= passit;
619  if(passit) ph_trigmatch_eff_nominal->SetBinContent(idx, ph_trigmatch_eff_nominal->GetBinContent(idx)+1);
620  #ifdef XAOD_STANDALONE
621  m_heffs["Trigger/ph_pt_"+t]->Fill(passit,ph->pt()/1000.);
622  m_heffs["Trigger/ph_eta_"+t]->Fill(passit,ph->eta());
623  m_heffs["Trigger/ph_phi_"+t]->Fill(passit,ph->phi());
624  #endif
625  idx++;
626  }
627  if (passTM) ph_n_flow_nominal->Fill(Cut::trigmatch);
628  }
629  }
630  }
631  stdHistsForObj(ph,"ph","nom");
632  }
633  hist("Photon/ph_nom_N")->Fill(m_obj_count["ph"]["nom"]);
634  hist("Photon/ph_bsl_N")->Fill(m_obj_count["ph"]["bsl"]);
635  hist("Photon/ph_sig_N")->Fill(m_obj_count["ph"]["sig"]);
636  }
637 
638  //----- Muons
639 
640  TH1* mu_n_flow_nominal = hist("Cutflow/mu_n_flow_nominal");
641  TH1* mu_trigmatch_eff_nominal = hist("Trigger/mu_trigmatch_eff_nominal");
642 
643  if (m_slices["mu"]) {
644  ATH_MSG_DEBUG("Processing muons");
645  m_obj_count["mu"]["nom"] = muons_nominal->size();
646  for(auto mu : *muons_nominal) {
647  mu_n_flow_nominal->Fill(Cut::all);
648  if ( ST::acc_baseline(*mu) == 1 ){
649  mu_n_flow_nominal->Fill(Cut::baseline);
650  stdHistsForObj(mu,"mu","bsl");
651  m_obj_count["mu"]["bsl"] += 1;
652  if ( ST::acc_passOR(*mu) == 1 ){
653  mu_n_flow_nominal->Fill(Cut::passOR);
654  if ( ST::acc_signal(*mu) == 1 ){
655  mu_n_flow_nominal->Fill(Cut::signal);
656  stdHistsForObj(mu,"mu","sig");
657  m_obj_count["mu"]["sig"] += 1;
658 
659  bool passTM=false;
660  unsigned int idx=1;
661  for(const auto& t : m_triggers["mu"]){
662  bool passit = ((isRun3Trig||t.find("_L1")==std::string::npos) ? m_SUSYTools->IsTrigMatched(mu, t) : false);
663  passTM |= passit;
664  if(passit) mu_trigmatch_eff_nominal->SetBinContent(idx, mu_trigmatch_eff_nominal->GetBinContent(idx)+1);
665  #ifdef XAOD_STANDALONE
666  m_heffs["Trigger/mu_pt_"+t]->Fill(passit,mu->pt()/1000.);
667  m_heffs["Trigger/mu_eta_"+t]->Fill(passit,mu->eta());
668  m_heffs["Trigger/mu_phi_"+t]->Fill(passit,mu->phi());
669  #endif
670  idx++;
671  }
672  if(passTM) mu_n_flow_nominal->Fill(Cut::trigmatch);
673  }
674  }
675  }
676  stdHistsForObj(mu,"mu","nom");
677  }
678  hist("Muon/mu_nom_N")->Fill(m_obj_count["mu"]["nom"]);
679  hist("Muon/mu_bsl_N")->Fill(m_obj_count["mu"]["bsl"]);
680  hist("Muon/mu_sig_N")->Fill(m_obj_count["mu"]["sig"]);
681  }
682 
683  //----- Jets
684 
685  TH1* jet_n_flow_nominal = hist("Cutflow/jet_n_flow_nominal");
686  TH1* bjet_n_flow_nominal = hist("Cutflow/bjet_n_flow_nominal");
687  bool bjet = false;
688 
689  if (m_slices["jet"]) {
690  m_obj_count["jet"]["nom"] = jets_nominal->size();
691  for(auto jet : *jets_nominal) {
692  ATH_MSG_DEBUG("Processing jets");
693  jet_n_flow_nominal->Fill(Cut::all);
694  bjet = false;
695  if ( ST::acc_bjet(*jet) >= 3 ) bjet = true;
696  if (bjet) bjet_n_flow_nominal->Fill(Cut::all);
697  //
698  if ( ST::acc_baseline(*jet) == 1 ){
699  jet_n_flow_nominal->Fill(Cut::baseline);
700  if (bjet) {
701  bjet_n_flow_nominal->Fill(Cut::baseline);
702  stdHistsForObj(jet,"bjet","bsl");
703  m_obj_count["bjet"]["bsl"] += 1;
704  }
705  stdHistsForObj(jet,"jet","bsl");
706  m_obj_count["jet"]["bsl"] += 1;
707 
708  if ( ST::acc_passOR(*jet) == 1 ){
709  jet_n_flow_nominal->Fill(Cut::passOR);
710  if (bjet) bjet_n_flow_nominal->Fill(Cut::passOR);
711  if ( ST::acc_signal(*jet) == 1 ){
712  jet_n_flow_nominal->Fill(Cut::signal);
713  jet_n_flow_nominal->Fill(Cut::trigmatch); //no trig matching for jets
714  if (bjet) {
715  bjet_n_flow_nominal->Fill(Cut::signal);
716  bjet_n_flow_nominal->Fill(Cut::trigmatch); //no trig matching for (b)jets
717  stdHistsForObj(jet,"bjet","sig");
718  m_obj_count["bjet"]["sig"] += 1;
719  }
720  stdHistsForObj(jet,"jet","sig");
721  m_obj_count["jet"]["sig"] += 1;
722  }
723  }
724  }
725  if (bjet) {
726  stdHistsForObj(jet,"bjet","nom");
727  }
728  stdHistsForObj(jet,"jet","nom");
729  }
730  hist("Jet/jet_nom_N")->Fill(m_obj_count["jet"]["nom"]);
731  hist("Jet/jet_bsl_N")->Fill(m_obj_count["jet"]["bsl"]);
732  hist("Jet/jet_sig_N")->Fill(m_obj_count["jet"]["sig"]);
733  }
734 
735  //----- Large R. Jets
736 
737  TH1* fatjet_n_flow_nominal = hist("Cutflow/fatjet_n_flow_nominal");
738 
739  if( m_slices["fjet"] && doFatJets ) {
740  ATH_MSG_DEBUG("Processing fatjets");
741  if (m_configDict.find("Jet.WtaggerConfig")!=m_configDict.end() && m_configDict.find("WtaggerKey")==m_configDict.end() && fatjets_nominal->size()>0) {
742  SG::AuxTypeRegistry& reg = SG::AuxTypeRegistry::instance();
743  std::string taggerKey;
744  taggerKey = findInReg(reg, (*fatjets_nominal)[0], "(SmoothW.*?)_.*");
745  if (!taggerKey.empty()) { m_configDict["WtaggerKey"] = taggerKey; }
746  }
747  if (m_configDict.find("Jet.ZtaggerConfig")!=m_configDict.end() && m_configDict.find("ZtaggerKey")==m_configDict.end() && fatjets_nominal->size()>0) {
748  SG::AuxTypeRegistry& reg = SG::AuxTypeRegistry::instance();
749  std::string taggerKey;
750  taggerKey = findInReg(reg, (*fatjets_nominal)[0], "(SmoothZ.*?)_.*");
751  if (!taggerKey.empty()) { m_configDict["ZtaggerKey"] = taggerKey; }
752  }
753  if (m_configDict.find("Jet.ToptaggerConfig")!=m_configDict.end() && m_configDict.find("ToptaggerKey")==m_configDict.end() && fatjets_nominal->size()>0) {
754  SG::AuxTypeRegistry& reg = SG::AuxTypeRegistry::instance();
755  std::string taggerKey;
756  taggerKey = findInReg(reg, (*fatjets_nominal)[0], "(.*Tag.*Top.*?)_.*");
757  if (!taggerKey.empty()) { m_configDict["ToptaggerKey"] = taggerKey; }
758  }
759  ATH_MSG_DEBUG("Tagger configuration retrieved.");
760  ATH_MSG_DEBUG("WTagger: " << m_configDict["WtaggerKey"]);
761  ATH_MSG_DEBUG("ZTagger: " << m_configDict["ZtaggerKey"]);
762  ATH_MSG_DEBUG("TopTagger: " << m_configDict["ToptaggerKey"]);
763 
764  m_obj_count["fatjet"]["nom"] = fatjets_nominal->size();
765  for(auto fatjet : *fatjets_nominal) {
766  fatjet_n_flow_nominal->Fill(Cut::all);
767  if ( ST::acc_baseline(*fatjet) == 1 ){
768  fatjet_n_flow_nominal->Fill(Cut::baseline);
769  stdHistsForObj(fatjet,"fatjet","bsl",m_configDict);
770  m_obj_count["fatjet"]["bsl"] += 1;
771  if ( ST::acc_passOR(*fatjet) == 1 ){
772  fatjet_n_flow_nominal->Fill(Cut::passOR);
773  if ( ST::acc_signal(*fatjet) == 1 ){
774  fatjet_n_flow_nominal->Fill(Cut::signal);
775  fatjet_n_flow_nominal->Fill(Cut::trigmatch); //no trig matching for jets
776  stdHistsForObj(fatjet,"fatjet","sig",m_configDict);
777  m_obj_count["fatjet"]["sig"] += 1;
778  }
779  }
780  }
781  stdHistsForObj(fatjet,"fatjet","nom",m_configDict);
782  }
783  hist("LargeRJet/fatjet_nom_N")->Fill(m_obj_count["fatjet"]["nom"]);
784  hist("LargeRJet/fatjet_bsl_N")->Fill(m_obj_count["fatjet"]["bsl"]);
785  hist("LargeRJet/fatjet_sig_N")->Fill(m_obj_count["fatjet"]["sig"]);
786  }
787 
788  //----- Track Jets
789 
790  TH1* trkjet_n_flow_nominal = hist("Cutflow/trkjet_n_flow_nominal");
791 
792  if( m_slices["tjet"] && doTrkJets ) {
793  m_obj_count["trkjet"]["nom"] = trkjets_nominal->size();
794  for(auto trkjet : *trkjets_nominal) {
795  trkjet_n_flow_nominal->Fill(Cut::all);
796  if ( ST::acc_baseline(*trkjet) == 1 ){
797  trkjet_n_flow_nominal->Fill(Cut::baseline);
798  stdHistsForObj(trkjet,"trkjet","bsl");
799  m_obj_count["trkjet"]["bsl"] += 1;
800  if ( ST::acc_passOR(*trkjet) == 1 ){
801  trkjet_n_flow_nominal->Fill(Cut::passOR);
802  if ( ST::acc_signal(*trkjet) == 1 ){
803  trkjet_n_flow_nominal->Fill(Cut::signal);
804  trkjet_n_flow_nominal->Fill(Cut::trigmatch); //no trig matching for jets
805  stdHistsForObj(trkjet,"trkjet","sig");
806  m_obj_count["trkjet"]["sig"] += 1;
807  }
808  }
809  }
810  stdHistsForObj(trkjet,"trkjet","nom");
811  }
812  hist("TrackJet/trkjet_nom_N")->Fill(m_obj_count["trkjet"]["nom"]);
813  hist("TrackJet/trkjet_bsl_N")->Fill(m_obj_count["trkjet"]["bsl"]);
814  hist("TrackJet/trkjet_sig_N")->Fill(m_obj_count["trkjet"]["sig"]);
815  }
816 
817  //----- Taus
818 
819  TH1* tau_n_flow_nominal = hist("Cutflow/tau_n_flow_nominal");
820 
821  if (m_slices["tau"]) {
822  m_obj_count["tau"]["nom"] = taus_nominal->size();
823  for(auto tau : *taus_nominal) {
824  tau_n_flow_nominal->Fill(Cut::all);
825  if ( ST::acc_baseline(*tau) == 1 ){
826  tau_n_flow_nominal->Fill(Cut::baseline);
827  stdHistsForObj(tau,"tau","bsl");
828  m_obj_count["tau"]["bsl"] += 1;
829  if ( ST::acc_passOR(*tau) == 1 ){
830  tau_n_flow_nominal->Fill(Cut::passOR);
831 
832  if ( ST::acc_signal(*tau) == 1 ){
833  tau_n_flow_nominal->Fill(Cut::signal);
834  tau_n_flow_nominal->Fill(Cut::trigmatch); //no trig matching for taus
835  stdHistsForObj(tau,"tau","sig");
836  m_obj_count["tau"]["sig"] += 1;
837  }
838  }
839  }
840  stdHistsForObj(tau,"tau","nom");
841  }
842  hist("Tau/tau_nom_N")->Fill(m_obj_count["tau"]["nom"]);
843  hist("Tau/tau_bsl_N")->Fill(m_obj_count["tau"]["bsl"]);
844  hist("Tau/tau_sig_N")->Fill(m_obj_count["tau"]["sig"]);
845  }
846 
847  // Set up the event weights
848  // Base should include all weights that do not depend on individual objects
849  double base_event_weight(1.);
850  if (!isData) {
851  base_event_weight *= evtInfo->mcEventWeight();
852 
853  if (m_slices["met"]) {
854  const xAOD::MissingETContainer* met_truth(0);
855  ATH_CHECK( evtStore()->retrieve(met_truth, "MET_Truth") );
856 
857  ATH_MSG_DEBUG("Truth MET etx=" << (*met_truth)["NonInt"]->mpx()
858  << ", ety=" << (*met_truth)["NonInt"]->mpy()
859  << ", et=" << (*met_truth)["NonInt"]->met()
860  << ", sumet=" << (*met_truth)["NonInt"]->sumet());
861  ATH_MSG_DEBUG("CST residuals: detx=" << (*m_metcst_nominal)["Final"]->mpx() - (*met_truth)["NonInt"]->mpx()
862  << ", dety=" << (*m_metcst_nominal)["Final"]->mpy() - (*met_truth)["NonInt"]->mpy());
863  ATH_MSG_DEBUG("TST residuals: detx=" << (*m_mettst_nominal)["Final"]->mpx() - (*met_truth)["NonInt"]->mpx()
864  << ", dety=" << (*m_mettst_nominal)["Final"]->mpy() - (*met_truth)["NonInt"]->mpy());
865  }
866  }
867 
868 
869  // Additionally define a nominal weight for each object type
870  double electrons_weight_nominal(1.);
871  double photons_weight_nominal(1.);
872  double muons_weight_nominal(1.);
873  double jets_weight_nominal(1.);
874  //double fatjets_weight_nominal(1.);
875  //double trkjets_weight_nominal(1.);
876  double btag_weight_nominal(1.);
877  double taus_weight_nominal(1.);
878  double event_weight_nominal(1.);
879  double prw_weight_nominal(1.);
880 
881  //--- Weights
882  TH1* weight_event = hist("Syst/weight_event");
883  TH1* weight_electrons = hist("Syst/weight_electrons");
884  TH1* weight_muons = hist("Syst/weight_muons");
885  TH1* weight_photons = hist("Syst/weight_photons");
886  TH1* weight_taus = hist("Syst/weight_taus");
887  TH1* weight_jets = hist("Syst/weight_jets");
888  TH1* weight_btags = hist("Syst/weight_btags");
889 
890  bool isNominal(true);
891  for (const auto& sysInfo : m_sysInfoList) {
892  CP::SystematicSet sys = sysInfo.systset;
893  if (m_SUSYTools->applySystematicVariation(sys) != StatusCode::SUCCESS) {
894  ATH_MSG_ERROR( "Cannot configure SUSYTools for systematic var. %s" << sys.name() );
895  } else {
896  ATH_MSG_VERBOSE( "Variation \"" << sys.name() << "\" configured..." );
897  }
898  if (isNominal && (sysInfo.affectsKinematics || sysInfo.affectsWeights)) {
899  ATH_MSG_ERROR("Expected nominal variation!");
900  return StatusCode::FAILURE;
901  }
902  if (sysInfo.affectsKinematics || sysInfo.affectsWeights) isNominal = false;
903 
904  double event_weight = base_event_weight;
905  bool syst_affectsEventWeight = (sysInfo.affectsType == ST::SystObjType::EventWeight);
906 
907  // If nominal, compute the nominal weight, otherwise recompute the weight
908 
909  double prw_weight=1.;
910  if(isNominal){
911  if(!isData) prw_weight_nominal = m_SUSYTools->GetPileupWeight();
912  event_weight *= prw_weight_nominal;
913  weight_event->SetBinContent(1, weight_event->GetBinContent(1)+event_weight);
914  }
915  else if (!syst_affectsEventWeight) {
916  event_weight *= prw_weight_nominal;
917  }
918  else {
919  if(!isData){
920  ATH_CHECK(m_SUSYTools->ApplyPRWTool());
921  prw_weight = m_SUSYTools->GetPileupWeight();
922  }
923  event_weight *= prw_weight;
924  size_t iwbin = find(m_syst_weights["EventWeight"].begin(), m_syst_weights["EventWeight"].end(), sys.name()) - m_syst_weights["EventWeight"].begin();
925  if(iwbin < m_syst_weights["EventWeight"].size()) { weight_event->SetBinContent(iwbin+1, weight_event->GetBinContent(iwbin+1)+event_weight); }
926  }
927 
928 
929  // Define the generic collection pointers
930  xAOD::ElectronContainer* electrons(electrons_nominal);
931  xAOD::PhotonContainer* photons(photons_nominal);
932  xAOD::MuonContainer* muons(muons_nominal);
933  xAOD::JetContainer* jets(jets_nominal);
934  xAOD::JetContainer* fatjets(fatjets_nominal);
935  xAOD::JetContainer* trkjets(trkjets_nominal);
936  xAOD::TauJetContainer* taus(taus_nominal);
937  xAOD::MissingETContainer *mettst(m_mettst_nominal), *metcst(m_metcst_nominal);
938  xAOD::MissingETAuxContainer *mettst_aux(m_mettst_nominal_aux), *metcst_aux(m_metcst_nominal_aux);
939 
940  bool syst_affectsElectrons = ST::testAffectsObject(xAOD::Type::Electron, sysInfo.affectsType);
941  bool syst_affectsMuons = ST::testAffectsObject(xAOD::Type::Muon, sysInfo.affectsType);
942  bool syst_affectsPhotons = ST::testAffectsObject(xAOD::Type::Photon, sysInfo.affectsType);
943  bool syst_affectsTaus = ST::testAffectsObject(xAOD::Type::Tau, sysInfo.affectsType);
944  bool syst_affectsJets = ST::testAffectsObject(xAOD::Type::Jet, sysInfo.affectsType);
945  bool syst_affectsBTag = ST::testAffectsObject(xAOD::Type::BTag, sysInfo.affectsType);
946  bool syst_affectsLRT = ST::testAffectsObject(sysInfo.affectsType) == "LRT_Objects";
947 
948  // Apply LRT uncertainty.
949  // Needs to be before retrieving leptons as they could be removed if the track is vetoed
950  if (syst_affectsLRT)
951  {
952  ATH_CHECK( m_SUSYTools->ApplyLRTUncertainty() );
953  }
954 
955  // If necessary (kinematics affected), make a shallow copy with the variation applied
956  // otherwise set the collection pointers to the nominal
957  if (sysInfo.affectsKinematics) {
958  if (m_slices["el"] && syst_affectsElectrons) {
959  ATH_MSG_DEBUG("Get systematics-varied electrons");
960  xAOD::ElectronContainer* electrons_syst(0);
961  xAOD::ShallowAuxContainer* electrons_syst_aux(0);
962  ATH_CHECK( m_SUSYTools->GetElectrons(electrons_syst, electrons_syst_aux, true , m_isPHYSLITE?"AnalysisElectrons":"Electrons") );
963  electrons = electrons_syst;
964  }
965 
966  if (m_slices["pho"] && syst_affectsPhotons) {
967  ATH_MSG_DEBUG("Get systematics-varied photons");
968  xAOD::PhotonContainer* photons_syst(0);
969  xAOD::ShallowAuxContainer* photons_syst_aux(0);
970  ATH_CHECK( m_SUSYTools->GetPhotons(photons_syst, photons_syst_aux, true, m_isPHYSLITE?"AnalysisPhotons":"Photons") );
971  photons = photons_syst;
972  }
973 
974  if (m_slices["mu"] && syst_affectsMuons) {
975  ATH_MSG_DEBUG("Get systematics-varied muons");
976  xAOD::MuonContainer* muons_syst(0);
977  xAOD::ShallowAuxContainer* muons_syst_aux(0);
978  ATH_CHECK( m_SUSYTools->GetMuons(muons_syst, muons_syst_aux, true, m_isPHYSLITE?"AnalysisMuons":"Muons") );
979  muons = muons_syst;
980  }
981 
982  if (syst_affectsJets) {
983  if (m_slices["jet"]) {
984  ATH_MSG_DEBUG("Get systematics-varied jets");
985  xAOD::JetContainer* jets_syst(0);
986  xAOD::ShallowAuxContainer* jets_syst_aux(0);
987  ATH_CHECK( m_SUSYTools->GetJetsSyst(*jets_nominal, jets_syst, jets_syst_aux, true, m_isPHYSLITE?"AnalysisJets":"") );
988  jets = jets_syst;
989  }
990  if (m_slices["fatjet"]) {
991  ATH_MSG_DEBUG("Get systematics-varied fatjets");
992  xAOD::JetContainer* fatjets_syst(0);
993  xAOD::ShallowAuxContainer* fatjets_syst_aux(0);
994  ATH_CHECK( m_SUSYTools->GetJetsSyst(*fatjets_nominal, fatjets_syst, fatjets_syst_aux) );
995  fatjets = fatjets_syst;
996  }
997  if (m_slices["trkjet"]) {
998  ATH_MSG_DEBUG("Get systematics-varied trkjets");
999  xAOD::JetContainer* trkjets_syst(0);
1000  xAOD::ShallowAuxContainer* trkjets_syst_aux(0);
1001  ATH_CHECK( m_SUSYTools->GetJetsSyst(*trkjets_nominal, trkjets_syst, trkjets_syst_aux) );
1002  trkjets = trkjets_syst;
1003  }
1004  }
1005 
1006  if (m_slices["tau"] && syst_affectsTaus) {
1007  ATH_MSG_DEBUG("Get systematics-varied taus");
1008  xAOD::TauJetContainer* taus_syst(0);
1009  xAOD::ShallowAuxContainer* taus_syst_aux(0);
1010  ATH_CHECK( m_SUSYTools->GetTaus(taus_syst, taus_syst_aux,true, m_isPHYSLITE?"AnalysisTauJets":"TauJets") );
1011  taus = taus_syst;
1012  }
1013 
1014  ATH_MSG_DEBUG("Get systematics-varied MET");
1015  m_mettst_syst = new xAOD::MissingETContainer;
1016  m_mettst_syst_aux = new xAOD::MissingETAuxContainer;
1017  m_metcst_syst = new xAOD::MissingETContainer;
1018  m_metcst_syst_aux = new xAOD::MissingETAuxContainer;
1019  m_mettst_syst->setStore(m_mettst_syst_aux);
1020  m_metcst_syst->setStore(m_metcst_syst_aux);
1021  m_mettst_syst->reserve(10);
1022  m_metcst_syst->reserve(10);
1023  //
1024  if (m_slices["met"]) {
1025  ATH_CHECK( m_SUSYTools->GetMET(*m_metcst_syst, jets, electrons, muons, photons, 0) );
1026  ATH_CHECK( m_SUSYTools->GetMET(*m_mettst_syst, jets, electrons, muons, photons, 0, true, true) );
1027  }
1028  //
1029  mettst = m_mettst_syst;
1030  mettst_aux = m_mettst_syst_aux;
1031  metcst = m_metcst_syst;
1032  metcst_aux = m_metcst_syst_aux;
1033  }
1034 
1035  //--- Overlap Removal
1036  ATH_CHECK( m_SUSYTools->OverlapRemoval(electrons, muons, jets, photons, taus) );
1037 
1038  //--- Electrons
1039  if (m_slices["ele"]) {
1040  ATH_MSG_DEBUG("Working on electrons");
1041  float electrons_weight(1.);
1042  for ( const auto el : *electrons ) {
1043  if( !isData ){
1044  if (isNominal || syst_affectsElectrons) {
1045  if ((ST::acc_signal(*el) == 1) && (isNominal || sysInfo.affectsWeights)) {
1046  //electrons_weight *= m_SUSYTools->GetSignalElecSF( *el ); // (*el, true, true, false, true) to switch off trigger SF
1047  electrons_weight *= m_SUSYTools->GetSignalElecSF(*el, true, true, false, true);
1048  }
1049  }
1050  }
1051  ATH_MSG_VERBOSE( " Electron passing baseline selection? " << static_cast<int>( ST::acc_baseline(*el)));
1052  ATH_MSG_VERBOSE( " Electron passing signal selection? " << static_cast<int>( ST::acc_signal(*el)));
1053  if (ST::acc_signal(*el) == 1)
1054  ATH_MSG_VERBOSE( " Electron weight " << ST::acc_effscalefact(*el) );
1055 
1056  }
1057  if (isNominal) {
1058  electrons_weight_nominal = electrons_weight;
1059  weight_electrons->SetBinContent(1, weight_electrons->GetBinContent(1)+electrons_weight);
1060  }
1061  else if (!syst_affectsElectrons) {
1062  electrons_weight = electrons_weight_nominal;
1063  }
1064  else if ( sysInfo.affectsWeights ){
1065  size_t iwbin = find(m_syst_weights["Electron"].begin(), m_syst_weights["Electron"].end(), sys.name()) - m_syst_weights["Electron"].begin();
1066  if(iwbin < m_syst_weights["Electron"].size()) { weight_electrons->SetBinContent(iwbin+1, weight_electrons->GetBinContent(iwbin+1)+electrons_weight); }
1067  }
1068 
1069  event_weight *= electrons_weight;
1070  ATH_MSG_DEBUG("Combined electron scale factor: " << electrons_weight);
1071  }
1072 
1073  //--- Photons
1074  if (m_slices["pho"]) {
1075  ATH_MSG_DEBUG("Working on photons");
1076  float photons_weight(1.);
1077  for ( const auto ph : *photons ) {
1078  if( !isData ){
1079  if (isNominal || syst_affectsPhotons) {
1080  if ((ST::acc_signal(*ph) == 1) && (isNominal || sysInfo.affectsWeights)) {
1081  photons_weight *= m_SUSYTools->GetSignalPhotonSF( *ph );
1082  }
1083  }
1084  }
1085  ATH_MSG_VERBOSE( " Photon passing baseline selection? " << static_cast<int>(ST::acc_baseline(*ph)));
1086  ATH_MSG_VERBOSE( " Photon passing signal selection? " << static_cast<int>(ST::acc_signal(*ph)));
1087  if (ST::acc_signal(*ph) == 1)
1088  ATH_MSG_VERBOSE( " Photon weight " << ST::acc_effscalefact(*ph) );
1089  }
1090  if (isNominal) {
1091  photons_weight_nominal = photons_weight;
1092  weight_photons->SetBinContent(1, weight_photons->GetBinContent(1)+photons_weight);
1093  }
1094  else if (!syst_affectsPhotons) {
1095  photons_weight = photons_weight_nominal;
1096  }
1097  else if ( sysInfo.affectsWeights ){
1098  size_t iwbin = find(m_syst_weights["Photon"].begin(), m_syst_weights["Photon"].end(), sys.name()) - m_syst_weights["Photon"].begin();
1099  if(iwbin < m_syst_weights["Photon"].size()) { weight_photons->SetBinContent(iwbin+1, weight_photons->GetBinContent(iwbin+1)+photons_weight); }
1100  }
1101 
1102  event_weight *= photons_weight;
1103  ATH_MSG_DEBUG("Combined photon scale factor: " << photons_weight);
1104  }
1105 
1106  //--- Muons
1107  if (m_slices["mu"]) {
1108  ATH_MSG_DEBUG("Working on muons");
1109  float muons_weight(1.);
1110  for ( const auto mu : *muons ) {
1111  if( !isData ){
1112  if (isNominal || syst_affectsMuons) {
1113  if ((ST::acc_signal(*mu) == 1) && (isNominal || sysInfo.affectsWeights)) {
1114  muons_weight *= m_SUSYTools->GetSignalMuonSF(*mu);;
1115  }
1116  }
1117  }
1118  ATH_MSG_VERBOSE( " Muon passing baseline selection? " << static_cast<int>(ST::acc_baseline(*mu)));
1119  ATH_MSG_VERBOSE( " Muon passing signal selection? " << static_cast<int>(ST::acc_signal(*mu)));
1120  ATH_MSG_VERBOSE( " Muon is a cosmic ray? " << static_cast<int>(ST::acc_cosmic(*mu)));
1121  if (ST::acc_signal(*mu) == 1)
1122  ATH_MSG_VERBOSE( " Muon weight " << ST::acc_effscalefact(*mu) );
1123  }
1124  if (isNominal) {
1125  muons_weight_nominal = muons_weight;
1126  weight_muons->SetBinContent(1, weight_muons->GetBinContent(1)+muons_weight);
1127  }
1128  else if (!syst_affectsMuons) {
1129  muons_weight = muons_weight_nominal;
1130  }
1131  else if ( sysInfo.affectsWeights ){
1132  size_t iwbin = find(m_syst_weights["Muon"].begin(), m_syst_weights["Muon"].end(), sys.name()) - m_syst_weights["Muon"].begin();
1133  if(iwbin < m_syst_weights["Muon"].size()) { weight_muons->SetBinContent(iwbin+1, weight_muons->GetBinContent(iwbin+1)+muons_weight); }
1134  }
1135 
1136  event_weight *= muons_weight;
1137  ATH_MSG_DEBUG("Combined muon scale factor: " << muons_weight);
1138  }
1139 
1140  //--- Jets
1141  if (m_slices["jet"]) {
1142  ATH_MSG_DEBUG("Working on jets");
1143  for ( const auto jet : *jets ) {
1144  ATH_MSG_VERBOSE( " Jet is bad? " << static_cast<int>(ST::acc_bad(*jet)));
1145  ATH_MSG_VERBOSE( " Jet is baseline ? " << static_cast<int>(ST::acc_baseline(*jet)));
1146  ATH_MSG_VERBOSE( " Jet passes OR ? " << static_cast<int>(ST::acc_passOR(*jet)));
1147  if (ST::acc_passOR(*jet)) {
1148  if (m_slices["bjet"] && (isNominal || syst_affectsJets || syst_affectsBTag)) {
1149  m_SUSYTools->IsBJetContinuous(*jet);
1150  }
1151  ATH_MSG_VERBOSE( " Jet is bjet ? " << static_cast<int>(ST::acc_bjet(*jet)));
1152  }
1153  }
1154 
1155  float jet_weight(1.);
1156  float btag_weight(1.);
1157  if( !isData ) { //isMC
1158  if (isNominal) { //btagging
1159  btag_weight_nominal = btag_weight = m_SUSYTools->BtagSF(jets);
1160  weight_btags->SetBinContent(1, weight_btags->GetBinContent(1)+btag_weight);
1161  }
1162  else if (!syst_affectsBTag){
1163  btag_weight = btag_weight_nominal;
1164  }
1165  else{
1166  btag_weight = m_SUSYTools->BtagSF(jets);
1167  size_t iwbin = find(m_syst_weights["BTag"].begin(), m_syst_weights["BTag"].end(), sys.name()) - m_syst_weights["BTag"].begin();
1168  if(iwbin < m_syst_weights["BTag"].size()) { weight_btags->SetBinContent(iwbin+1, weight_btags->GetBinContent(iwbin+1)+btag_weight); }
1169  }
1170 
1171  if(isNominal){ //JVT
1172  jet_weight = m_SUSYTools->JVT_SF(jets);
1173  jet_weight *= m_SUSYTools->FJVT_SF(jets);
1174  jets_weight_nominal = jet_weight;
1175  jets_weight_nominal *= m_SUSYTools->FJVT_SF(jets);
1176  weight_jets->SetBinContent(1, weight_jets->GetBinContent(1)+jet_weight);
1177  }
1178  else if (!syst_affectsJets || (syst_affectsJets && !sysInfo.affectsWeights)){
1179  jet_weight = jets_weight_nominal;
1180  }
1181  else if ( syst_affectsJets && sysInfo.affectsWeights ){
1182  jet_weight = m_SUSYTools->JVT_SF(jets);
1183  jet_weight *= m_SUSYTools->FJVT_SF(jets);
1184  size_t iwbin = find(m_syst_weights["Jet"].begin(), m_syst_weights["Jet"].end(), sys.name()) - m_syst_weights["Jet"].begin();
1185  if(iwbin < m_syst_weights["Jet"].size()) { weight_jets->SetBinContent(iwbin+1, weight_jets->GetBinContent(iwbin+1)+jet_weight); }
1186  }
1187  }
1188  else{ //data
1189  weight_jets->SetBinContent(1, 1.);
1190  weight_btags->SetBinContent(1, 1.);
1191  }
1192  event_weight *= jet_weight;
1193  event_weight *= btag_weight;
1194  ATH_MSG_DEBUG("Combined b-tagging scale factor: " << btag_weight);
1195  ATH_MSG_DEBUG("Combined jet scale factor: " << jet_weight);
1196  }
1197 
1198  //--- Large R. Jets
1199 
1200  if( m_slices["fjet"] && doFatJets ) {
1201  ATH_MSG_DEBUG("Working on fat jets");
1202  for ( const auto fatjet : *fatjets ) {
1203  ATH_MSG_VERBOSE( " Jet is bad? " << static_cast<int>(ST::acc_bad(*fatjet)));
1204  ATH_MSG_VERBOSE( " Jet is baseline ? " << static_cast<int>(ST::acc_baseline(*fatjet)));
1205  ATH_MSG_VERBOSE( " Jet passes OR ? " << static_cast<int>(ST::acc_passOR(*fatjet)));
1206  }
1207 
1208  float fatjet_weight(1.);
1209  //disable - noJVTforfatjets if( !isData ) { //isMC
1210  //disable - noJVTforfatjets if(isNominal){ //JVT - no JVT cuts for fat jets!
1211  //disable - noJVTforfatjets fatjets_weight_nominal = fatjet_weight = m_SUSYTools->JVT_SF(fatjets);
1212  //disable - noJVTforfatjets weight_fatjets->SetBinContent(1, weight_fatjets->GetBinContent(1)+fatjet_weight);
1213  //disable - noJVTforfatjets }
1214  //disable - noJVTforfatjets if (!syst_affectsJets || (syst_affectsJets && !sysInfo.affectsWeights)){
1215  //disable - noJVTforfatjets fatjet_weight = fatjets_weight_nominal;
1216  //disable - noJVTforfatjets }
1217  //disable - noJVTforfatjets else if ( syst_affectsJets && sysInfo.affectsWeights ){
1218  //disable - noJVTforfatjets fatjet_weight = m_SUSYTools->JVT_SF(fatjets);
1219  //disable - noJVTforfatjets size_t iwbin = find(m_syst_weights["Jet"].begin(), m_syst_weights["Jet"].end(), sys.name()) - m_syst_weights["Jet"].begin();
1220  //disable - noJVTforfatjets if(iwbin < m_syst_weights["Jet"].size()) { weight_fatjets->SetBinContent(iwbin+1, weight_fatjets->GetBinContent(iwbin+1)+fatjet_weight); }
1221  //disable - noJVTforfatjets }
1222  //disable - noJVTforfatjets }
1223 
1224  ATH_MSG_DEBUG("Combined large radius jet scale factor: " << fatjet_weight);
1225  }
1226 
1227  //--- Track Jets
1228 
1229  if( m_slices["tjet"] && doTrkJets ) {
1230  ATH_MSG_DEBUG("Working on trk jets");
1231  for ( const auto trkjet : *trkjets ) {
1232  ATH_MSG_VERBOSE( " Jet is bad? " << static_cast<int>(ST::acc_bad(*trkjet)));
1233  ATH_MSG_VERBOSE( " Jet is baseline ? " << static_cast<int>(ST::acc_baseline(*trkjet)));
1234  ATH_MSG_VERBOSE( " Jet passes OR ? " << static_cast<int>(ST::acc_passOR(*trkjet)));
1235  }
1236 
1237  float trkjet_weight(1.);
1238  //disable - noJVTfortrkjets if( !isData ) { //isMC
1239  //disable - noJVTfortrkjets if(isNominal){ //JVT - no JVT cuts for trk jets!
1240  //disable - noJVTfortrkjets trkjets_weight_nominal = trkjet_weight = 1;//m_SUSYTools->JVT_SF(trkjets);
1241  //disable - noJVTfortrkjets weight_trkjets->SetBinContent(1, weight_trkjets->GetBinContent(1)+trkjet_weight);
1242  //disable - noJVTfortrkjets }
1243  //disable - noJVTfortrkjets else if (!syst_affectsJets || (syst_affectsJets && !sysInfo.affectsWeights)){
1244  //disable - noJVTfortrkjets trkjet_weight = trkjets_weight_nominal;
1245  //disable - noJVTfortrkjets }
1246  //disable - noJVTfortrkjets else if ( syst_affectsJets && sysInfo.affectsWeights ){
1247  //disable - noJVTfortrkjets trkjet_weight = 1;//m_SUSYTools->JVT_SF(trkjets);
1248  //disable - noJVTfortrkjets size_t iwbin = find(m_syst_weights["Jet"].begin(), m_syst_weights["Jet"].end(), sys.name()) - m_syst_weights["Jet"].begin();
1249  //disable - noJVTfortrkjets if(iwbin < m_syst_weights["Jet"].size()) { weight_trkjets->SetBinContent(iwbin+1, weight_trkjets->GetBinContent(iwbin+1)+trkjet_weight); }
1250  //disable - noJVTfortrkjets }
1251  //disable - noJVTfortrkjets }
1252 
1253  ATH_MSG_DEBUG("Combined track jet scale factor: " << trkjet_weight);
1254  }
1255 
1256  //--- Taus
1257  if (m_slices["tau"]) {
1258  ATH_MSG_DEBUG("Working on taus");
1259  float taus_weight(1.);
1260  for ( const auto ta : *taus ) {
1261  if( !isData ){
1262  if (isNominal || syst_affectsTaus) {
1263  if ((ST::acc_signal(*ta) == 1) && (isNominal || sysInfo.affectsWeights)) {
1264  taus_weight *= m_SUSYTools->GetSignalTauSF(*ta, true, false); //true, "HLT_tau25_medium1_tracktwo");;
1265  }
1266  }
1267  }
1268  ATH_MSG_VERBOSE( " Tau passing baseline selection? " << static_cast<int>(ST::acc_baseline(*ta)));
1269  ATH_MSG_VERBOSE( " Tau passing signal selection? " << static_cast<int>(ST::acc_signal(*ta)));
1270  if (ST::acc_signal(*ta) == 1)
1271  ATH_MSG_VERBOSE( " Tau weight " << ST::acc_effscalefact(*ta) );
1272  }
1273 
1274  if (isNominal) {
1275  taus_weight_nominal = taus_weight;
1276  weight_taus->SetBinContent(1, weight_taus->GetBinContent(1)+taus_weight);
1277  }
1278  else if (!syst_affectsTaus) {
1279  taus_weight = taus_weight_nominal;
1280  }
1281  else if ( sysInfo.affectsWeights ){
1282  size_t iwbin = find(m_syst_weights["Tau"].begin(), m_syst_weights["Tau"].end(), sys.name()) - m_syst_weights["Tau"].begin();
1283  if(iwbin < m_syst_weights["Tau"].size()) { weight_taus->SetBinContent(iwbin+1, weight_taus->GetBinContent(iwbin+1)+taus_weight); }
1284  }
1285 
1286  event_weight *= taus_weight;
1287  }
1288 
1289 
1290  ATH_MSG_DEBUG("Full event weight: " << event_weight);
1291  if (isNominal) {event_weight_nominal = event_weight;}
1292  else if (sysInfo.affectsWeights) ATH_MSG_DEBUG("Difference with nominal weight: " << event_weight - event_weight_nominal);
1293 
1294  // Clean up the systematics copies
1295  if (sysInfo.affectsKinematics) {
1296  delete metcst;
1297  delete mettst;
1298  delete metcst_aux;
1299  delete mettst_aux;
1300  }
1301  isNominal = false;
1302  }
1303 
1304  m_clock0.Stop();
1305  if (m_Nevts == 0) {
1306  m_clock1.Stop();
1307  } else {
1308  m_clock2.Stop();
1309  }
1310  ++m_Nevts;
1311 
1312  delete m_metcst_nominal;
1313  delete m_metcst_nominal_aux;
1314  delete m_mettst_nominal;
1315  delete m_mettst_nominal_aux;
1316 
1317  return StatusCode::SUCCESS;
1318 }
1319 
1320 //====================================================================================================
1321 // Book histograms
1322 StatusCode SUSYToolsAlg::bookHistograms(void) {
1323  // General info
1324  ATH_CHECK( book(TH1D("EventInfo/info_runNo", ";RunNumber;N", 1500, 250000, 400000)) );
1325  ATH_CHECK( book(TH1D("EventInfo/info_evtNo", ";EventNumber;N", 600, 100000000, 400000000)) );
1326  ATH_CHECK( book(TH1D("EventInfo/info_lumiBlock", ";LumiBlock;N", 1000, 0, 1000)) );
1327 
1328  // Kinematic histograms
1329  m_objects = {"el", "ph", "mu", "tau", "jet", "bjet", "fatjet", "trkjet"};
1330  m_levels = {"nom", "bsl", "sig"};
1331  m_vars = {"pt", "eta", "phi", "e", "mass", "d0", "z0", "isolCalo", "isolTrack", "truthType", "truthOrigin", "N", "bweight", "bweightpb", "bweightpc", "bweightpu", "pid", "parentpid", "wtagged", "ztagged", "toptagged", "toptaggedscore","nTracks","nTracksCharged","nTracksIsolation","RNNJetScoreSigTrans"};
1332  std::map<std::string,std::vector<std::string>> cfg_hist_labels = {
1333  {"pt",{"p_{T} [GeV]","N"}}, {"eta",{"#eta","N"}}, {"phi",{"#phi","N"}}, {"e",{"energy","N"}}, {"mass",{"mass","N"}},
1334  {"d0",{"d0 significance","N"}}, {"z0",{"z0 * sin(#theta)","N"}}, {"isolCalo",{"isolation (calo) / pT","N"}}, {"isolTrack",{"isolation (track) / pT","N"}},
1335  {"truthType",{"truth type","N"}}, {"truthOrigin",{"truth origin","N"}}, {"N",{"count","N"}},
1336  {"bweight",{"b-weight","N"}}, {"bweightpb",{"b-weight (pb)","N"}}, {"bweightpc",{"b-weight (pc)","N"}}, {"bweightpu",{"b-weight (pu)","N"}},
1337  {"pid", {"pdg ID", "N"}}, {"parentpid", {"parent pdg ID","N"}},
1338  {"wtagged", {"W tagged", "N"}}, {"ztagged", {"Z tagged", "N"}}, {"toptagged", {"Top tagged", "N"}}, {"toptaggedscore", {"Top tagger score", "N"}},
1339  {"nTracks", {"N tracks", "N"}}, {"nTracksCharged", {"N tracks charged", "N"}}, {"nTracksIsolation", {"N tracks isolation", "N"}}, {"RNNJetScoreSigTrans", {"RNNJetScoreSigTrans","N"}} };
1340  std::map<std::string,int> cfg_hist_nbins = {
1341  {"pt",100}, {"eta",40}, {"phi",64}, {"e",100}, {"mass",100},
1342  {"d0",50}, {"z0",60}, {"isolCalo",70}, {"isolTrack",70},
1343  {"truthType",50}, {"truthOrigin",50}, {"N",16},
1344  {"bweight",200}, {"bweightpb",200}, {"bweightpc",200}, {"bweightpu",200},
1345  {"pid",61}, {"parentpid",61},
1346  {"wtagged",3}, {"ztagged",3}, {"toptagged",3}, {"toptaggedscore",50},
1347  {"nTracks",20}, {"nTracksCharged",20}, {"nTracksIsolation",5}, {"RNNJetScoreSigTrans",50} };
1348  std::map<std::string,std::vector<float>> cfg_hist_minmax = {
1349  {"pt",{0,200}}, {"eta",{-4,4}}, {"phi",{-3.2,3.2}}, {"e",{0,200}}, {"mass",{0,200}},
1350  {"d0",{-10,10}}, {"z0",{-1.5,1.5}}, {"isolCalo",{-0.2,0.5}}, {"isolTrack",{-0.2,0.5}},
1351  {"truthType",{0,50}}, {"truthOrigin",{0,50}}, {"N",{0,16}},
1352  {"bweight",{-10,10}}, {"bweightpb",{-0.5,1.5}}, {"bweightpc",{-0.5,1.5}}, {"bweightpu",{-0.5,1.5}},
1353  {"pid",{-30.5,30.5}}, {"parentpid",{-30.5,30.5}},
1354  {"wtagged", {-1,2}}, {"ztagged", {-1,2}}, {"toptagged", {-1,2}}, {"toptaggedscore", {0,1}},
1355  {"nTracks", {0,20}}, {"nTracksCharged", {0,20}}, {"nTracksIsolation", {0,5}}, {"RNNJetScoreSigTrans", {0,1}} };
1356  std::map<std::string,std::string> labels_objects = { {"el","Electron"}, {"ph","Photon"}, {"mu","Muon"}, {"jet","Jet"}, {"bjet","b-Jet"}, {"tau","Tau"}, {"fatjet","Large-R jet"}, {"trkjet","Track jet"} };
1357  std::map<std::string,std::string> labels_levels = { {"nom","Nominal"}, {"bsl","Baseline"}, {"sig","Signal"} };
1358  std::map<std::string,std::string> labels_dir = { {"el","Electron"}, {"ph","Photon"}, {"mu","Muon"}, {"jet","Jet"}, {"bjet","bJet"}, {"tau","Tau"}, {"fatjet","LargeRJet"}, {"trkjet","TrackJet"} };
1359 
1360  for (const auto& obj : m_objects) {
1361  m_obj_count[obj] = std::map<std::string,int>();
1362  for (const auto& lev : m_levels) {
1363  m_obj_count[obj][lev] = 0;
1364  }
1365  }
1366 
1367  for (const auto& obj : m_objects) {
1368  for (const auto& lev : m_levels) {
1369  for (const auto& var : m_vars) {
1370  if (var.find("bweight")!=std::string::npos && obj.compare("bjet")!=0) continue; // bweights only for bjets
1371  if (var.find("tagged")!=std::string::npos && obj.compare("fatjet")!=0) continue; // boson tagging only for fjets
1372  if ((var.find("nTracks")!=std::string::npos||var.find("RNNJetScore")!=std::string::npos) && obj.compare("tau")!=0) continue; // nTracks/RNN score only for taus
1373  if (var.find("isol")!=std::string::npos && !(obj.compare("el")==0||obj.compare("mu")==0||obj.compare("ph")==0)) continue; // isol only for e/ph/mu
1374  std::string key = labels_dir[obj] + "/" + obj + "_" + lev + "_" + var;
1375  std::string labels = ";"+labels_levels[lev]+" "+labels_objects[obj]+" "+cfg_hist_labels[var][0]+";"+cfg_hist_labels[var][1];
1376  ATH_CHECK( book(TH1D(key.c_str(), labels.c_str(), cfg_hist_nbins[var], cfg_hist_minmax[var][0], cfg_hist_minmax[var][1])) );
1377  m_hists[key] = hist(key);
1378  ATH_MSG_INFO("Defined histogram: " << key.c_str() << ", " << m_hists[key]);
1379  }
1380  }
1381  }
1382 
1384  #ifdef XAOD_STANDALONE
1385  for (std::string obj : {"el","mu","ph"}) {
1386  for (auto trg : m_triggers[obj]) {
1387  for (std::string var : {"pt","eta","phi"} ) {
1388  std::string key = "Trigger/"+obj+"_"+var+"_"+trg;
1389  std::string labels = ";"+labels_objects[obj]+" "+cfg_hist_labels[var][0]+";Efficiency "+trg;
1390  ATH_CHECK(book(TEfficiency(key.c_str(), labels.c_str(), cfg_hist_nbins[var], cfg_hist_minmax[var][0], cfg_hist_minmax[var][1])));
1391  m_heffs[key] = histeff(key);
1392  ATH_MSG_INFO("Defined histogram: " << key.c_str() << ", " << m_heffs[key]);
1393  }
1394  }
1395  }
1396  #endif
1397  ATH_CHECK( book(TH1D("Trigger/isMETTrigPassed", "isMETTrigPassed", 2, -0.5, 1.5)) );
1398 
1399  ATH_CHECK( book(TH1D("Trigger/el_trigmatch_eff_nominal", "Electron Trigger Matching Efficiency (Nominal);Electron Trigger Matching Efficiency (Nominal);N", getSize(m_triggers,"el"), 0, getSize(m_triggers,"el")) ) );
1400  ATH_CHECK( book(TH1D("Trigger/ph_trigmatch_eff_nominal", "Photon Trigger Matching Efficiency (Nominal);Photon Trigger Matching Efficiency (Nominal);N", getSize(m_triggers,"ph"), 0, getSize(m_triggers,"ph")) ) );
1401  ATH_CHECK( book(TH1D("Trigger/mu_trigmatch_eff_nominal", "Muon Trigger Matching Efficiency (Nominal);Muon Trigger Matching Efficiency (Nominal);N", getSize(m_triggers,"mu"), 0, getSize(m_triggers,"mu")) ) );
1402 
1403  // Extra histograms
1404  ATH_CHECK( book(TH1D("Cutflow/el_n_flow_nominal", "Electron Cutflow (Nominal);Electron Cutflow (Nominal);N", Cut::NSel, 0, Cut::NSel) ) );
1405  ATH_CHECK( book(TH1D("Cutflow/ph_n_flow_nominal", "Photon Cutflow (Nominal);Photon Cutflow (Nominal);N", Cut::NSel, 0, Cut::NSel) ) );
1406  ATH_CHECK( book(TH1D("Cutflow/mu_n_flow_nominal", "Muon Cutflow (Nominal);Muon Cutflow (Nominal);N", Cut::NSel, 0, Cut::NSel) ) );
1407  ATH_CHECK( book(TH1D("Cutflow/jet_n_flow_nominal", "Jet Cutflow (Nominal);Jet Cutflow (Nominal);N", Cut::NSel, 0, Cut::NSel) ) );
1408  ATH_CHECK( book(TH1D("Cutflow/bjet_n_flow_nominal", "b-jet Cutflow (Nominal);b-jet Cutflow (Nominal);N", Cut::NSel, 0, Cut::NSel) ) );
1409  ATH_CHECK( book(TH1D("Cutflow/fatjet_n_flow_nominal", "Large R. Jet Cutflow (Nominal);Large R. Jet Cutflow (Nominal);N", Cut::NSel, 0, Cut::NSel) ) );
1410  ATH_CHECK( book(TH1D("Cutflow/trkjet_n_flow_nominal", "Track Jet Cutflow (Nominal);Track Jet Cutflow (Nominal);N", Cut::NSel, 0, Cut::NSel) ) );
1411  ATH_CHECK( book(TH1D("Cutflow/tau_n_flow_nominal", "Tau Cutflow (Nominal);Tau Cutflow (Nominal);N", Cut::NSel, 0, Cut::NSel) ) );
1412 
1413  ATH_CHECK( book(TH1D("MET/met_et", "MET (Nominal);MET (Nominal) [GeV];N / [10 GeV]", 50, 0, 500) ) ); //MET (+Components)
1414  ATH_CHECK( book(TH1D("MET/met_phi", "MET_phi (Nominal);MET_phi (Nominal);N", 50, -5, 5) ) );
1415  ATH_CHECK( book(TH1D("MET/met_sumet", "MET_sumet (Nominal);MET_sumet (Nominal) [GeV];N / [10 GeV]", 50, 0, 500) ) );
1416  ATH_CHECK( book(TH1D("MET/met_et_tst", "MET [PVSoftTrk] (Nominal);MET [PVSoftTrk] (Nominal) [GeV];N / [10 GeV]", 50, 0, 500) ) );
1417  ATH_CHECK( book(TH1D("MET/met_et_el", "MET [RefEle] (Nominal);MET [RefEle] (Nominal) [GeV];N / [10 GeV]", 50, 0, 500) ) );
1418  ATH_CHECK( book(TH1D("MET/met_et_ph", "MET [RefGamma] (Nominal);MET [RefGamma] (Nominal) [GeV];N / [10 GeV]", 50, 0, 500) ) );
1419  ATH_CHECK( book(TH1D("MET/met_et_mu", "MET [Muons] (Nominal);MET [Muons] (Nominal) [GeV];N / [10 GeV]", 50, 0, 500) ) );
1420  ATH_CHECK( book(TH1D("MET/met_et_jet", "MET [RefJet] (Nominal);MET [RefJet] (Nominal) [GeV];N / [10 GeV]", 50, 0, 500) ) );
1421  //ATH_CHECK( book(TH1D("MET/met_et_tau", "MET [RefTau] (Nominal);MET [RefTau] (Nominal) [GeV];N / [10 GeV]", 50, 0, 500) ) );
1422  ATH_CHECK( book(TH1D("MET/met_significance", "MET Significance;MET Significance;N / [0.5]", 60, 0, 30) ) );
1423 
1424  ATH_CHECK( book(TH1D("Syst/weight_event", "Event weights (Nom+Systematics) [MC*PRW];Event weights (Nom+Systematics) [MC*PRW];weight", getSize(m_syst_weights,"EventWeight"), 0, getSize(m_syst_weights,"EventWeight"))) ); //weights
1425  ATH_CHECK( book(TH1D("Syst/weight_electrons", "Electron total weights (Nom+Systematics);Electron total weights (Nom+Systematics);weight", getSize(m_syst_weights,"Electron") , 0, getSize(m_syst_weights,"Electron") )) ); //weights
1426  ATH_CHECK( book(TH1D("Syst/weight_muons", "Muon total weights (Nom+Systematics);Muon total weights (Nom+Systematics);weight", getSize(m_syst_weights,"Muon") , 0, getSize(m_syst_weights,"Muon") )) ); //weights
1427  ATH_CHECK( book(TH1D("Syst/weight_photons", "Photon total weights (Nom+Systematics);Photon total weights (Nom+Systematics);weight", getSize(m_syst_weights,"Photon") , 0, getSize(m_syst_weights,"Photon") )) ); //weights
1428  ATH_CHECK( book(TH1D("Syst/weight_taus", "Tau total weights (Nom+Systematics);Tau total weights (Nom+Systematics);weight", getSize(m_syst_weights,"Tau") , 0, getSize(m_syst_weights,"Tau") )) ); //weights
1429  ATH_CHECK( book(TH1D("Syst/weight_jets", "Jet total weights (Nom+Systematics);Jet total weights (Nom+Systematics);weight", getSize(m_syst_weights,"Jet") , 0, getSize(m_syst_weights,"Jet") )) ); //weights
1430  //ATH_CHECK( book(TH1D("Syst/weight_fatjets", "Large R. jet total weights (Nom+Systematics);Large R. jet total weights (Nom+Systematics);weight", getSize(m_syst_weights,"Jet") , 0, getSize(m_syst_weights,"Jet") )) ); //weights
1431  //ATH_CHECK( book(TH1D("Syst/weight_trkjets", "Track jet total weights (Nom+Systematics);Track jet total weights (Nom+Systematics);weight", getSize(m_syst_weights,"Jet") , 0, getSize(m_syst_weights,"Jet") )) ); //weights
1432  ATH_CHECK( book(TH1D("Syst/weight_btags", "Btagging total weights (Nom+Systematics);Btagging total weights (Nom+Systematics);weight", getSize(m_syst_weights,"BTag") , 0, getSize(m_syst_weights,"BTag") )) ); //weights
1433 
1434  ATH_CHECK( book(TH2D("Syst/syst_event", "Systematics list [MC+PRW];;Syst name;", 1,0,1, static_cast<int>(std::ceil(1.2*getSize(m_syst_all,"EventWeight"))),0,static_cast<int>(std::ceil(1.2*getSize(m_syst_all,"EventWeight"))))) ); // syst names
1435  ATH_CHECK( book(TH2D("Syst/syst_electrons", "Systematics list [Electron];Syst name;", 1,0,1, static_cast<int>(std::ceil(1.2*getSize(m_syst_all,"Electron"))), 0,static_cast<int>(std::ceil(1.2*getSize(m_syst_all,"Electron"))))) ); // syst names
1436  ATH_CHECK( book(TH2D("Syst/syst_muons", "Systematics list [Muon];Syst name;", 1,0,1, static_cast<int>(std::ceil(1.2*getSize(m_syst_all,"Muon"))), 0,static_cast<int>(std::ceil(1.2*getSize(m_syst_all,"Muon"))))) ); // syst names
1437  ATH_CHECK( book(TH2D("Syst/syst_photons", "Systematics list [Photon];Syst name;", 1,0,1, static_cast<int>(std::ceil(1.2*getSize(m_syst_all,"Photon"))), 0,static_cast<int>(std::ceil(1.2*getSize(m_syst_all,"Photon"))))) ); // syst names
1438  ATH_CHECK( book(TH2D("Syst/syst_taus", "Systematics list [Tau];Syst name;", 1,0,1, static_cast<int>(std::ceil(1.2*getSize(m_syst_all,"Tau"))), 0,static_cast<int>(std::ceil(1.2*getSize(m_syst_all,"Tau"))))) ); // syst names
1439  ATH_CHECK( book(TH2D("Syst/syst_jets", "Systematics list [Jet];Syst name;", 1,0,1, static_cast<int>(std::ceil(1.2*getSize(m_syst_all,"Jet"))), 0,static_cast<int>(std::ceil(1.2*getSize(m_syst_all,"Jet"))))) ); // syst names
1440  ATH_CHECK( book(TH2D("Syst/syst_btags", "Systematics list [BTag];Syst name;", 1,0,1, static_cast<int>(std::ceil(1.2*getSize(m_syst_all,"BTag"))), 0,static_cast<int>(std::ceil(1.2*getSize(m_syst_all,"BTag"))))) ); // syst names
1441 
1442  return StatusCode::SUCCESS;
1443 }
1444 
1445 //====================================================================================================
1446 // collect systematics per object (all / weight-only)
1447 void SUSYToolsAlg::groupSysts(void) {
1448  m_syst_all.clear();
1449  m_syst_weights.clear();
1450  const std::vector<std::string> Nominal{"Nominal"};
1451  for (const auto& sysInfo : m_sysInfoList) {
1452  std::string sys_name = sysInfo.systset.name();
1453  std::string sys_affects = ST::testAffectsObject(sysInfo.affectsType);
1454  ATH_MSG_DEBUG("Syst " << sys_name << " affects " << sys_affects);
1455 
1456  bool sys_affects_weights = sysInfo.affectsWeights;
1457 
1458  // collect all syst names
1459  // per affected object
1460  const auto & [pairPtr, inserted] = m_syst_all.try_emplace(sys_affects, Nominal);
1461  pairPtr->second.push_back(sys_name);
1462 
1463  // weight related syst
1464  if (sys_affects_weights) {
1465  const auto & [pairPtr_w, inserted_w] = m_syst_weights.try_emplace(sys_affects, Nominal);
1466  pairPtr_w->second.push_back(sys_name);
1467  }
1468  }
1469 }
1470 
1471 //====================================================================================================
1472 // Fill object histograms consistently for different selection levels / object types
1473 void SUSYToolsAlg::stdHistsForObj(xAOD::IParticle *obj, const std::string& objtype, const std::string& objlevel, std::map<std::string,std::string> config) {
1474  std::map<std::string,std::string> labels_dir = { {"el","Electron"}, {"ph","Photon"}, {"mu","Muon"}, {"jet","Jet"}, {"bjet","bJet"}, {"tau","Tau"}, {"fatjet","LargeRJet"}, {"trkjet","TrackJet"} };
1475  std::string dir = labels_dir[objtype]+"/";
1476 
1477  ATH_MSG_VERBOSE("Filling histograms for " << obj->type() << ", " << objlevel);
1478  hist(dir+objtype+"_"+objlevel+"_pt")->Fill( obj->pt()/1000. );
1479  hist(dir+objtype+"_"+objlevel+"_eta")->Fill( obj->eta() );
1480  hist(dir+objtype+"_"+objlevel+"_phi")->Fill( obj->phi() );
1481  hist(dir+objtype+"_"+objlevel+"_e")->Fill( obj->e()/1000. );
1482  hist(dir+objtype+"_"+objlevel+"_mass")->Fill( obj->m()/1000. );
1483  //
1484  if (objtype=="el" || objtype=="mu" || objtype=="ph") {
1485  if (objtype=="el") {
1486  if (ST::acc_z0sinTheta.isAvailable(*obj))
1487  hist(dir+objtype+"_"+objlevel+"_z0")->Fill( ST::acc_z0sinTheta(*obj) );
1488  if (ST::acc_d0sig.isAvailable(*obj))
1489  hist(dir+objtype+"_"+objlevel+"_d0")->Fill( ST::acc_d0sig(*obj) );
1490  hist(dir+objtype+"_"+objlevel+"_isolCalo")->Fill( STAlg::acc_topoetcone20(*obj)/obj->pt() );
1491  hist(dir+objtype+"_"+objlevel+"_isolTrack")->Fill( STAlg::acc_ptvarcone30_TTVA_LooseCone(*obj)/obj->pt() );
1492  } else if (objtype=="mu") {
1493  if (ST::acc_z0sinTheta.isAvailable(*obj))
1494  hist(dir+objtype+"_"+objlevel+"_z0")->Fill( ST::acc_z0sinTheta(*obj) );
1495  if (ST::acc_d0sig.isAvailable(*obj))
1496  hist(dir+objtype+"_"+objlevel+"_d0")->Fill( ST::acc_d0sig(*obj) );
1497  hist(dir+objtype+"_"+objlevel+"_isolCalo")->Fill( STAlg::acc_topoetcone20(*obj)/obj->pt() );
1498  hist(dir+objtype+"_"+objlevel+"_isolTrack")->Fill( STAlg::acc_ptvarcone30_TTVA(*obj)/obj->pt() );
1499  } else if (objtype=="ph") {
1500  hist(dir+objtype+"_"+objlevel+"_isolCalo")->Fill( (STAlg::acc_topoetcone40(*obj)-2450)/obj->pt() );
1501  hist(dir+objtype+"_"+objlevel+"_isolTrack")->Fill( STAlg::acc_ptcone20(*obj)/obj->pt() );
1502  }
1503  }
1504  //
1505  if (objtype=="el" || objtype=="mu" || objtype=="ph" || objtype=="tau") {
1506  if ( objtype!="tau" ) {
1507  if (ST::acc_truthType.isAvailable(*obj) && ST::acc_truthOrigin.isAvailable(*obj)) {
1508  ATH_MSG_DEBUG(objtype << ", " << objlevel << ": " << ST::acc_truthType(*obj) << ", " << ST::acc_truthOrigin(*obj));
1509  hist(dir+objtype+"_"+objlevel+"_truthType")->Fill( ST::acc_truthType(*obj) );
1510  hist(dir+objtype+"_"+objlevel+"_truthOrigin")->Fill( ST::acc_truthOrigin(*obj) );
1511  }
1512  } else {
1513  if(!m_isPHYSLITE){
1514  bool istruthmatched = STAlg::acc_IsTruthMatched.isAvailable(*obj) ? (bool)STAlg::acc_IsTruthMatched(*obj) : false;
1515  int pid(0),ppid(0);
1516  if (istruthmatched && STAlg::acc_truthParticleLink.isAvailable(*obj)) {
1517  const auto *tp = *(STAlg::acc_truthParticleLink(*obj));
1518  if (tp) {
1519  pid = tp->pdgId();
1520  ppid = (tp->nParents()>0)?tp->parent(0)->pdgId():0;
1521  }
1522  }
1523  hist(dir+objtype+"_"+objlevel+"_pid")->Fill( pid );
1524  hist(dir+objtype+"_"+objlevel+"_parentpid")->Fill( ppid );
1525  }
1526  }
1527  }
1528 
1529  if (objtype=="tau") {
1530  hist(dir+objtype+"_"+objlevel+"_nTracks")->Fill( dynamic_cast<xAOD::TauJet*>(obj)->nTracks() );
1531  hist(dir+objtype+"_"+objlevel+"_nTracksCharged")->Fill( dynamic_cast<xAOD::TauJet*>(obj)->nTracksCharged() );
1532  hist(dir+objtype+"_"+objlevel+"_nTracksIsolation")->Fill( dynamic_cast<xAOD::TauJet*>(obj)->nTracksIsolation() );
1533  hist(dir+objtype+"_"+objlevel+"_RNNJetScoreSigTrans")->Fill( STAlg::acc_RNNJetScoreSigTrans(*obj) );
1534  }
1535  //
1536 
1537  if (objtype=="bjet") {
1538  hist(dir+objtype+"_"+objlevel+"_bweight")->Fill( ST::acc_btag_weight(*obj) );
1539  hist(dir+objtype+"_"+objlevel+"_bweightpb")->Fill( ST::acc_btag_dl1pb(*obj) );
1540  hist(dir+objtype+"_"+objlevel+"_bweightpc")->Fill( ST::acc_btag_dl1pc(*obj) );
1541  hist(dir+objtype+"_"+objlevel+"_bweightpu")->Fill( ST::acc_btag_dl1pu(*obj) );
1542  }
1543 
1544  //
1545  const static SG::ConstAccessor<bool> acc_topValidPtRangeLow(config["ToptaggerKey"]+"_ValidPtRangeLow");
1546  const static SG::ConstAccessor<bool> acc_topValidPtRangeHigh(config["ToptaggerKey"]+"_ValidPtRangeHigh");
1547  const static SG::ConstAccessor<bool> acc_topValidEtaRange(config["ToptaggerKey"]+"_ValidEtaRange");
1548  const static SG::ConstAccessor<bool> acc_wtagged(config["WtaggerKey"]+"_Tagged");
1549  const static SG::ConstAccessor<bool> acc_ztagged(config["ZtaggerKey"]+"_Tagged");
1550  const static SG::ConstAccessor<bool> acc_toptagged(config["ToptaggerKey"]+"_Tagged");
1551  const static SG::ConstAccessor<float> acc_topscore(config["ToptaggerKey"]+"_Score");
1552 
1553  if (objtype=="fatjet" && acc_topValidPtRangeLow.isAvailable(*obj) && acc_topValidPtRangeHigh.isAvailable(*obj) && acc_topValidEtaRange.isAvailable(*obj)) {
1554  bool kin = acc_topValidPtRangeLow(*obj) && acc_topValidPtRangeHigh(*obj) && acc_topValidEtaRange(*obj);
1555  if (config.find("WtaggerKey")!=config.end()) hist(dir+objtype+"_"+objlevel+"_wtagged") ->Fill( acc_wtagged.isAvailable(*obj) ? kin && acc_wtagged(*obj) : -1);
1556  if (config.find("ZtaggerKey")!=config.end()) hist(dir+objtype+"_"+objlevel+"_ztagged") ->Fill( acc_ztagged.isAvailable(*obj) ? kin && acc_ztagged(*obj) : -1);
1557  if (config.find("ToptaggerKey")!=config.end()) hist(dir+objtype+"_"+objlevel+"_toptagged")->Fill( acc_toptagged.isAvailable(*obj) ? kin && acc_toptagged(*obj) : -1);
1558  if (config.find("ToptaggerKey")!=config.end()) hist(dir+objtype+"_"+objlevel+"_toptaggedscore")->Fill( acc_topscore.isAvailable(*obj) ? acc_topscore(*obj) : -1);
1559  }
1560 }
1561 
1562 
1563 //====================================================================================================
1564 std::string findInReg(SG::AuxTypeRegistry& reg, xAOD::IParticle* obj, const std::string& searchkey) {
1565  std::regex re_tag(searchkey);
1566  std::smatch matches;
1567  for (auto x : obj->getAuxIDs()) {
1568  std::string xname = reg.getName(x);
1569  std::regex_search(xname, matches, re_tag);
1570  if (matches.size()>1 and !matches[1].str().empty()) {
1571  return matches[1].str();
1572  }
1573  }
1574  return "";
1575 }
1576 
1577 //====================================================================================================
1578 int getSize(std::map<std::string,std::vector<std::string>> &collection, const std::string& object) {
1579  if (collection.find(object) == collection.end()) return 1;
1580  return static_cast<int>(collection[object].size());
1581 }
DataVector::reserve
void reserve(size_type n)
Attempt to preallocate enough memory for a specified number of elements.
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
ST::ISUSYObjDef_xAODTool::JVT_SF
virtual double JVT_SF(const xAOD::JetContainer *jets)=0
ShallowCopy.h
ST::ISUSYObjDef_xAODTool::getSystInfoList
virtual std::vector< ST::SystInfo > getSystInfoList() const =0
SUSYToolsAlg::m_grl
asg::AnaToolHandle< IGoodRunsListSelectionTool > m_grl
Definition: SUSYToolsAlg.h:85
findInReg
std::string findInReg(SG::AuxTypeRegistry &reg, xAOD::IParticle *obj, const std::string &searchkey)
Definition: SUSYToolsAlg.cxx:1564
python.AtlRunQueryAMI.period
period
Definition: AtlRunQueryAMI.py:225
python.BuildSignatureFlags.bjet
AthConfigFlags bjet(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:338
ST::ISUSYObjDef_xAODTool::GetTrackJets
virtual StatusCode GetTrackJets(xAOD::JetContainer *&copy, xAOD::ShallowAuxContainer *&copyaux, const bool recordSG=true, const std::string &jetkey="", const xAOD::JetContainer *containerToBeCopied=nullptr)=0
AthHistogramming::hist2d
TH2 * hist2d(const std::string &histName, const std::string &tDir="", const std::string &stream="")
Simplify the retrieval of registered 2-d histograms.
Definition: AthHistogramming.h:369
beamspotnt.var
var
Definition: bin/beamspotnt.py:1394
IGoodRunsListSelectionTool.h
CutBookkeeper.h
asg::AnaToolHandle::isUserConfigured
bool isUserConfigured() const noexcept
whether this tool handle has been configured by the user
xAOD::Electron
Electron_v1 Electron
Definition of the current "egamma version".
Definition: Event/xAOD/xAODEgamma/xAODEgamma/Electron.h:17
ST::ISUSYObjDef_xAODTool::FJVT_SF
virtual double FJVT_SF(const xAOD::JetContainer *jets)=0
xAOD::MissingETAuxContainer
MissingETAuxContainer_v1 MissingETAuxContainer
Definition: MissingETAuxContainer.h:16
SUSYToolsAlg::stdHistsForObj
void stdHistsForObj(xAOD::IParticle *obj, const std::string &objtype, const std::string &objlevel, std::map< std::string, std::string > config=std::map< std::string, std::string >())
Definition: SUSYToolsAlg.cxx:1473
ST::ISUSYObjDef_xAODTool::GetPileupWeight
virtual float GetPileupWeight()=0
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
xAOD::EventInfo_v1::eventNumber
uint64_t eventNumber() const
The current event's event number.
SG::AuxTypeRegistry::instance
static AuxTypeRegistry & instance()
Return the singleton registry instance.
Definition: AuxTypeRegistry.cxx:639
AthHistogramming::book
StatusCode book(const TH1 &hist, const std::string &tDir="", const std::string &stream="")
Simplify the booking and registering (into THistSvc) of histograms.
Definition: AthHistogramming.h:303
asg::AnaToolHandle::retrieve
StatusCode retrieve()
initialize the tool
dqt_zlumi_pandas.hname
string hname
Definition: dqt_zlumi_pandas.py:279
SUSYToolsAlg::m_metcst_syst
xAOD::MissingETContainer * m_metcst_syst
Definition: SUSYToolsAlg.h:119
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
ST::EventWeight
@ EventWeight
Definition: ISUSYObjDef_xAODTool.h:84
EventStreamInfo::getProcessingTags
const std::set< std::string > & getProcessingTags() const
Definition: EventStreamInfo.cxx:35
Data
@ Data
Definition: BaseObject.h:11
SUSYToolsAlg::m_mettst_nominal
xAOD::MissingETContainer * m_mettst_nominal
Definition: SUSYToolsAlg.h:124
EL::AnaAlgorithm::inputMetaStore
ConstMetaStorePtr_t inputMetaStore() const
Definition: AnaAlgorithm.cxx:72
SG::AuxTypeRegistry::getName
std::string getName(SG::auxid_t auxid) const
Return the name of an aux data item.
Definition: AuxTypeRegistry.cxx:881
ST::ISUSYObjDef_xAODTool::resetSystematics
virtual StatusCode resetSystematics()=0
SUSYToolsAlg::m_FatJetCollection
std::string m_FatJetCollection
Definition: SUSYToolsAlg.h:94
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
asg::AnaToolHandle::setTypeAndName
void setTypeAndName(const std::string &val_typeAndName)
set the value of type and name
SystematicSet.h
xAOD::ShallowAuxContainer
Class creating a shallow copy of an existing auxiliary container.
Definition: ShallowAuxContainer.h:54
ST::ISUSYObjDef_xAODTool::ApplyPRWTool
virtual StatusCode ApplyPRWTool(bool muDependentRRN=true)=0
ST::ISUSYObjDef_xAODTool::GetMET
virtual StatusCode GetMET(xAOD::MissingETContainer &met, const xAOD::JetContainer *jet, const xAOD::ElectronContainer *elec=nullptr, const xAOD::MuonContainer *muon=nullptr, const xAOD::PhotonContainer *gamma=nullptr, const xAOD::TauJetContainer *taujet=nullptr, bool doTST=true, bool doJVTCut=true, const xAOD::IParticleContainer *invis=nullptr)=0
CP::SystematicSet
Class to wrap a set of SystematicVariations.
Definition: SystematicSet.h:31
ST::ISUSYObjDef_xAODTool::IsBJetContinuous
virtual int IsBJetContinuous(const xAOD::Jet &input) const =0
ParticleTest.tp
tp
Definition: ParticleTest.py:25
SUSYObjDef_xAOD.h
SUSYToolsAlg::m_clock0
TStopwatch m_clock0
Definition: SUSYToolsAlg.h:104
ANA_CHECK
#define ANA_CHECK(EXP)
check whether the given expression was successful
Definition: Control/AthToolSupport/AsgMessaging/AsgMessaging/MessageCheck.h:324
ST::ISUSYObjDef_xAODTool::GetMuons
virtual StatusCode GetMuons(xAOD::MuonContainer *&copy, xAOD::ShallowAuxContainer *&copyaux, const bool recordSG=true, const std::string &muonkey="Muons", const std::string &lrtmuonkey="MuonsLRT", const xAOD::MuonContainer *containerToBeCopied=nullptr)=0
xAOD::MissingETContainer
MissingETContainer_v1 MissingETContainer
Definition: Event/xAOD/xAODMissingET/xAODMissingET/MissingETContainer.h:16
SG::ConstAccessor
Helper class to provide constant type-safe access to aux data.
Definition: ConstAccessor.h:55
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
SUSYToolsAlg::m_mettst_nominal_aux
xAOD::MissingETAuxContainer * m_mettst_nominal_aux
Definition: SUSYToolsAlg.h:125
ST::ISUSYObjDef_xAODTool::GetTaus
virtual StatusCode GetTaus(xAOD::TauJetContainer *&copy, xAOD::ShallowAuxContainer *&copyaux, const bool recordSG=true, const std::string &taukey="TauJets", const xAOD::TauJetContainer *containerToBeCopied=nullptr)=0
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
xAOD::IParticle
Class providing the definition of the 4-vector interface.
Definition: Event/xAOD/xAODBase/xAODBase/IParticle.h:41
asg::AnaToolHandle::setProperty
StatusCode setProperty(const std::string &property, const T2 &value)
set the given property of the tool.
SUSYToolsAlg::m_sysInfoList
std::vector< ST::SystInfo > m_sysInfoList
Definition: SUSYToolsAlg.h:100
x
#define x
AthenaPoolTestWrite.stream
string stream
Definition: AthenaPoolTestWrite.py:12
SUSYToolsAlg::SUSYToolsAlg
SUSYToolsAlg()
mapkey::sys
@ sys
Definition: TElectronEfficiencyCorrectionTool.cxx:42
xAOD::EventInfo_v1::runNumber
uint32_t runNumber() const
The current event's run number.
asg::AnaToolHandle::declarePropertyFor
void declarePropertyFor(T2 *tool, const std::string &name, const std::string &description="")
declare as property on the given tool
SUSYToolsAlg::groupSysts
void groupSysts(void)
Definition: SUSYToolsAlg.cxx:1447
config
Definition: PhysicsAnalysis/AnalysisCommon/AssociationUtils/python/config.py:1
Cut
Definition: SUSYToolsAlg.cxx:65
EventStreamInfo.h
This file contains the class definition for the EventStreamInfo class.
SUSYToolsAlg::m_mcCampaign
std::string m_mcCampaign
Definition: SUSYToolsAlg.h:78
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
ExpressionParsing::isAvailable
bool isAvailable(const T_Aux &cont, SG::auxid_t auxid)
Cut::trigmatch
@ trigmatch
Definition: SUSYToolsAlg.cxx:67
dqt_zlumi_pandas.weight
int weight
Definition: dqt_zlumi_pandas.py:189
PrepareReferenceFile.regex
regex
Definition: PrepareReferenceFile.py:43
SG::AuxTypeRegistry
Handle mappings between names and auxid_t.
Definition: AuxTypeRegistry.h:61
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
SUSYToolsAlg::m_doSyst
bool m_doSyst
Definition: SUSYToolsAlg.h:99
Cut::signal
@ signal
Definition: SUSYToolsAlg.cxx:67
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
ST::ISUSYObjDef_xAODTool::isData
virtual bool isData() const =0
ST::ISUSYObjDef_xAODTool::GetJetsSyst
virtual StatusCode GetJetsSyst(const xAOD::JetContainer &calibjets, xAOD::JetContainer *&copy, xAOD::ShallowAuxContainer *&copyaux, const bool recordSG=true, const std::string &jetkey="")=0
ST::ISUSYObjDef_xAODTool::GetSignalPhotonSF
virtual double GetSignalPhotonSF(const xAOD::Photon &ph, const bool effSF=true, const bool isoSF=true, const bool triggerSF=false) const =0
ITauTruthMatchingTool.h
beamspotnt.labels
list labels
Definition: bin/beamspotnt.py:1447
SUSYToolsAlg::m_slices
std::map< std::string, bool > m_slices
Definition: SUSYToolsAlg.h:79
getSize
int getSize(std::map< std::string, std::vector< std::string >> &collection, const std::string &object)
Definition: SUSYToolsAlg.cxx:1578
met
Definition: IMETSignificance.h:24
SUSYToolsAlg::m_mettst_syst_aux
xAOD::MissingETAuxContainer * m_mettst_syst_aux
Definition: SUSYToolsAlg.h:118
jet
Definition: JetCalibTools_PlotJESFactors.cxx:23
SUSYToolsAlg::m_metcst_syst_aux
xAOD::MissingETAuxContainer * m_metcst_syst_aux
Definition: SUSYToolsAlg.h:120
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
CheckAppliedSFs.e3
e3
Definition: CheckAppliedSFs.py:264
ST::ISUSYObjDef_xAODTool::BtagSF
virtual float BtagSF(const xAOD::JetContainer *jets)=0
SUSYToolsAlg::m_syst_all
std::map< std::string, std::vector< std::string > > m_syst_all
Definition: SUSYToolsAlg.h:101
event
POOL::TEvent event(POOL::TEvent::kClassAccess)
ElectronContainer.h
ST::ISUSYObjDef_xAODTool::GetSignalTauSF
virtual double GetSignalTauSF(const xAOD::TauJet &tau, const bool idSF=true, const bool triggerSF=true, const std::string &trigExpr="tau25_medium1_tracktwo")=0
ST::ISUSYObjDef_xAODTool::GetJets
virtual StatusCode GetJets(xAOD::JetContainer *&copy, xAOD::ShallowAuxContainer *&copyaux, const bool recordSG=true, const std::string &jetkey="", const xAOD::JetContainer *containerToBeCopied=nullptr)=0
SUSYToolsAlg::m_vars
std::vector< std::string > m_vars
Definition: SUSYToolsAlg.h:114
lumiFormat.i
int i
Definition: lumiFormat.py:85
ST::ISUSYObjDef_xAODTool::GetSignalMuonSF
virtual float GetSignalMuonSF(const xAOD::Muon &mu, const bool recoSF=true, const bool isoSF=true, const bool doBadMuonHP=true, const bool warnOVR=true)=0
SUSYToolsAlg::m_metcst_nominal
xAOD::MissingETContainer * m_metcst_nominal
Definition: SUSYToolsAlg.h:122
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
Cut::NSel
const unsigned int NSel
Definition: SUSYToolsAlg.cxx:66
MissingETAuxContainer.h
SUSYToolsAlg::m_syst_weights
std::map< std::string, std::vector< std::string > > m_syst_weights
Definition: SUSYToolsAlg.h:101
xAOD::TauJet_v3
Class describing a tau jet.
Definition: TauJet_v3.h:41
SUSYToolsAlg::m_kernel
std::string m_kernel
Definition: SUSYToolsAlg.h:92
SUSYToolsAlg::finalize
StatusCode finalize()
Definition: SUSYToolsAlg.cxx:257
egEnergyCorr::Resolution::Nominal
@ Nominal
Definition: egammaEnergyCorrectionTool.h:62
Cut::baseline
@ baseline
Definition: SUSYToolsAlg.cxx:67
SUSYToolsAlg::m_tauTruthMatchingTool
asg::AnaToolHandle< TauAnalysisTools::ITauTruthMatchingTool > m_tauTruthMatchingTool
Definition: SUSYToolsAlg.h:86
ParticleGun_EoverP_Config.pid
pid
Definition: ParticleGun_EoverP_Config.py:62
plotIsoValidation.el
el
Definition: plotIsoValidation.py:197
ST::ISUSYObjDef_xAODTool::OverlapRemoval
virtual StatusCode OverlapRemoval(const xAOD::ElectronContainer *electrons, const xAOD::MuonContainer *muons, const xAOD::JetContainer *jets, const xAOD::PhotonContainer *gamma=nullptr, const xAOD::TauJetContainer *taujet=nullptr, const xAOD::JetContainer *fatjets=nullptr)=0
CutBookkeeperContainer.h
SUSYToolsAlg::m_Nevts
unsigned int m_Nevts
Definition: SUSYToolsAlg.h:88
SUSYToolsAlg::m_configFile
std::string m_configFile
Definition: SUSYToolsAlg.h:93
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
xAOD::MissingETAuxContainer_v1
Auxiliary data store for xAOD::MissingETContainer.
Definition: MissingETAuxContainer_v1.h:20
EL
This module defines the arguments passed from the BATCH driver to the BATCH worker.
Definition: AlgorithmWorkerData.h:24
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:422
SUSYToolsAlg::m_objects
std::vector< std::string > m_objects
Definition: SUSYToolsAlg.h:112
xAOD::CutBookkeeperContainer_v1
Container that holds the Container of all CutBookkeepers.
Definition: CutBookkeeperContainer_v1.h:27
SUSYToolsAlg.h
ST::SystInfo::affectsType
unsigned int affectsType
Definition: ISUSYObjDef_xAODTool.h:67
SUSYToolsAlg::m_obj_count
std::map< std::string, std::map< std::string, int > > m_obj_count
Definition: SUSYToolsAlg.h:115
TauJetContainer.h
SUSYToolsAlg::m_SUSYTools
asg::AnaToolHandle< ST::ISUSYObjDef_xAODTool > m_SUSYTools
Definition: SUSYToolsAlg.h:84
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
SUSYToolsAlg::execute
StatusCode execute()
Definition: SUSYToolsAlg.cxx:303
xAOD::EventInfo_v1::lumiBlock
uint32_t lumiBlock() const
The current event's luminosity block number.
TrigCompositeContainer.h
beamspotman.dir
string dir
Definition: beamspotman.py:623
StatusCode.h
ST::ISUSYObjDef_xAODTool::getProperty
const T * getProperty(const std::string &name)
Definition: ISUSYObjDef_xAODTool.h:237
CaloCondBlobAlgs_fillNoiseFromASCII.comment
string comment
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:27
SUSYToolsAlg::bookHistograms
StatusCode bookHistograms(void)
Definition: SUSYToolsAlg.cxx:1322
ST::SystInfo::affectsKinematics
bool affectsKinematics
Definition: ISUSYObjDef_xAODTool.h:65
SUSYToolsAlg::m_mettst_syst
xAOD::MissingETContainer * m_mettst_syst
Definition: SUSYToolsAlg.h:117
xAOD::MissingETContainer_v1
Container for xAOD::MissingET_v1 objects.
Definition: MissingETContainer_v1.h:21
SUSYToolsAlg::m_GRLFiles
std::vector< std::string > m_GRLFiles
Definition: SUSYToolsAlg.h:77
SUSYToolsAlg::m_maxEvts
int m_maxEvts
Definition: SUSYToolsAlg.h:89
PathResolver.h
SUSYToolsAlg::initialize
StatusCode initialize()
Definition: SUSYToolsAlg.cxx:104
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
Cut::passOR
@ passOR
Definition: SUSYToolsAlg.cxx:67
ST::SystInfo
Definition: ISUSYObjDef_xAODTool.h:63
ST::ISUSYObjDef_xAODTool::GetSignalElecSF
virtual float GetSignalElecSF(const xAOD::Electron &el, const bool recoSF=true, const bool idSF=true, const bool triggerSF=true, const bool isoSF=true, const std::string &trigExpr="singleLepton", const bool ecidsSF=false, const bool cidSF=false)=0
SUSYToolsAlg::m_triggers
std::map< std::string, std::vector< std::string > > m_triggers
Definition: SUSYToolsAlg.h:109
Cut::all
@ all
Definition: SUSYToolsAlg.cxx:67
EventInfo.h
SUSYToolsAlg::m_isPHYSLITE
bool m_isPHYSLITE
Definition: SUSYToolsAlg.h:91
xAOD::EventInfo_v1
Class describing the basic event information.
Definition: EventInfo_v1.h:43
MuonContainer.h
xAOD::Photon
Photon_v1 Photon
Definition of the current "egamma version".
Definition: Event/xAOD/xAODEgamma/xAODEgamma/Photon.h:17
TauAnalysisTools::ITauTruthMatchingTool::getTruth
virtual const xAOD::TruthParticle * getTruth(const xAOD::TauJet &xTau)=0
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:431
Muon
struct TBPatternUnitContext Muon
AthAnalysisHelper.h
FlavorTagDiscriminants::hbb_key::fatjet
const std::string fatjet
Definition: HbbConstants.h:19
ST::ISUSYObjDef_xAODTool::IsTrigMatched
virtual bool IsTrigMatched(const xAOD::IParticle *part, const std::string &tr_item)=0
ST::ISUSYObjDef_xAODTool::GetPrimVtx
virtual const xAOD::Vertex * GetPrimVtx() const =0
SUSYToolsAlg::m_configDict
std::map< std::string, std::string > m_configDict
Definition: SUSYToolsAlg.h:82
h
SUSYToolsAlg::m_TrkJetCollection
std::string m_TrkJetCollection
Definition: SUSYToolsAlg.h:95
JetContainer.h
EventStreamInfo
This class provides the summary information stored for data written as a Event Stream.
Definition: EventStreamInfo.h:28
SUSYToolsAlg::m_clock2
TStopwatch m_clock2
Definition: SUSYToolsAlg.h:106
SUSYToolsAlg::m_metcst_nominal_aux
xAOD::MissingETAuxContainer * m_metcst_nominal_aux
Definition: SUSYToolsAlg.h:123
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
ST::ISUSYObjDef_xAODTool::GetMETSig
virtual StatusCode GetMETSig(xAOD::MissingETContainer &met, double &metSignificance, bool doTST=true, bool doJVTCut=true)=0
SUSYToolsAlg::m_levels
std::vector< std::string > m_levels
Definition: SUSYToolsAlg.h:113
ST::ISUSYObjDef_xAODTool::GetElectrons
virtual StatusCode GetElectrons(xAOD::ElectronContainer *&copy, xAOD::ShallowAuxContainer *&copyaux, const bool recordSG=true, const std::string &elekey="Electrons", const std::string &lrtelekey="LRTElectrons", const xAOD::ElectronContainer *containerToBeCopied=nullptr)=0
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
SUSYToolsAlg::m_lbfilter
int m_lbfilter
Definition: SUSYToolsAlg.h:90
SUSYToolsAlg::m_hists
std::map< std::string, TH1 * > m_hists
Definition: SUSYToolsAlg.h:80
xAODType::Tau
@ Tau
The object is a tau (jet)
Definition: ObjectType.h:49
AthHistogramming::hist
TH1 * hist(const std::string &histName, const std::string &tDir="", const std::string &stream="")
Simplify the retrieval of registered histograms of any type.
Definition: AthHistogramming.cxx:198
SG::ConstAccessor::isAvailable
bool isAvailable(const ELT &e) const
Test to see if this variable exists in the store.
ST::SystInfo::affectsWeights
bool affectsWeights
Definition: ISUSYObjDef_xAODTool.h:66
pickleTool.object
object
Definition: pickleTool.py:30
defineDB.jets
list jets
Definition: JetTagCalibration/share/defineDB.py:24
ST::Unknown
@ Unknown
Definition: ISUSYObjDef_xAODTool.h:73
ST::ISUSYObjDef_xAODTool::ApplyLRTUncertainty
virtual StatusCode ApplyLRTUncertainty()=0
xAOD::EventInfo_v1::mcEventWeight
float mcEventWeight(size_t i=0) const
The weight of one specific MC event used in the simulation.
Definition: EventInfo_v1.cxx:203
ST::ISUSYObjDef_xAODTool::GetFatJets
virtual StatusCode GetFatJets(xAOD::JetContainer *&copy, xAOD::ShallowAuxContainer *&copyaux, const bool recordSG=false, const std::string &jetkey="", const bool doLargeRdecorations=false, const xAOD::JetContainer *containerToBeCopied=nullptr)=0
SUSYToolsAlg::~SUSYToolsAlg
~SUSYToolsAlg()
Definition: SUSYToolsAlg.cxx:100
ST::ISUSYObjDef_xAODTool::IsMETTrigPassed
virtual bool IsMETTrigPassed(unsigned int runnumber=0, bool j400_OR=false) const =0
xAODType::BTag
@ BTag
The object is a b-tagging object.
Definition: ObjectType.h:60
python.PyAthena.obj
obj
Definition: PyAthena.py:132
CaloNoise_fillDB.mu
mu
Definition: CaloNoise_fillDB.py:53
xAOD::bool
setBGCode setTAP setLVL2ErrorBits bool
Definition: TrigDecision_v1.cxx:60
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
SUSYToolsAlg::m_clock1
TStopwatch m_clock1
Definition: SUSYToolsAlg.h:105
PhotonContainer.h
MissingETContainer.h
xAOD::Jet
Jet_v1 Jet
Definition of the current "jet version".
Definition: Event/xAOD/xAODJet/xAODJet/Jet.h:17
SUSYToolsAlg::m_heffs
std::map< std::string, TEfficiency * > m_heffs
Definition: SUSYToolsAlg.h:81
InDetDD::electrons
@ electrons
Definition: InDetDD_Defs.h:17
ST::ISUSYObjDef_xAODTool::applySystematicVariation
virtual StatusCode applySystematicVariation(const CP::SystematicSet &systConfig)=0
ST::ISUSYObjDef_xAODTool::GetPhotons
virtual StatusCode GetPhotons(xAOD::PhotonContainer *&copy, xAOD::ShallowAuxContainer *&copyaux, const bool recordSG=true, const std::string &photonkey="Photons", const xAOD::PhotonContainer *containerToBeCopied=nullptr)=0
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
Generated on Wed Jan 15 2025 21:18:27 for ATLAS Offline Software by   doxygen 1.8.18