ATLAS Offline Software
Macros | Functions
TrigGlobEffCorrExample3a.cxx File Reference
#include <TFile.h>
#include <TError.h>
#include "AthAnalysisBaseComps/AthAnalysisHelper.h"
#include "POOLRootAccess/TEvent.h"
#include "AsgMessaging/MessageCheck.h"
#include "AsgTools/AnaToolHandle.h"
#include "EgammaAnalysisInterfaces/IAsgElectronEfficiencyCorrectionTool.h"
#include "MuonAnalysisInterfaces/IMuonTriggerScaleFactors.h"
#include "TriggerAnalysisInterfaces/ITrigGlobalEfficiencyCorrectionTool.h"
#include "xAODEventInfo/EventInfo.h"
#include "xAODEgamma/ElectronContainer.h"
#include "xAODMuon/MuonContainer.h"
#include "PATCore/PATCoreEnums.h"
#include "AthContainers/AuxElement.h"
#include "AthContainers/ConstAccessor.h"
#include "AthContainers/Decorator.h"
#include <sstream>
#include <random>
#include <vector>
#include <array>

Go to the source code of this file.

Macros

#define MSGSOURCE   "Example 3a"
 

Functions

int main (int argc, char *argv[])
 

Macro Definition Documentation

◆ MSGSOURCE

#define MSGSOURCE   "Example 3a"

Definition at line 100 of file TrigGlobEffCorrExample3a.cxx.

Function Documentation

◆ main()

int main ( int  argc,
char *  argv[] 
)

For property 'ElectronEfficiencyTools':

For property 'ElectronScaleFactorTools':

For property 'ListOfLegsPerTool':

For property 'ListOfTagsPerTool':

For property 'ElectronLegsPerTag':

To tag the leading electron as 'Signal'

RAII on-the-fly creation of electron CP tools:

<key in map file>, <PID WP>, <iso WP> For leading electron:

For subleading electron(s):

one instance per trigger leg x working point

two instances: 0 -> MC efficiencies, 1 -> SFs

Safer to retrieve the name from the final ToolHandle, it might be prefixed (by the parent tool name) when the handle is copied

Uniform random run number generation spanning the target dataset. In real life, use the PileupReweightingTool instead!

2015 periods D-H, J

Get a random run number, and decorate the event info

electron must be above softest trigger threshold (e12 here)

Events must contain at least two lepton above trigger threshold

Let's pretend that the leading electron passes TightLH+isolation, thus the event passes the selection; now we tag the electrons:

Leading electron tagged as 'Signal' -> decorated value set to 1 Subleading electron(s) not tagged -> decorated value set to 0

Finally retrieve the global trigger scale factor

Definition at line 104 of file TrigGlobEffCorrExample3a.cxx.

105 {
106  ANA_CHECK_SET_TYPE(bool)
107  const char* filename = nullptr;
108  bool debug = false, cmdline_error = false, toys = false;
109  for(int i=1;i<argc;++i)
110  {
111  if(string(argv[i]) == "--debug") debug = true;
112  else if(string(argv[i]) == "--toys") toys = true;
113  else if(!filename && *argv[i]!='-') filename = argv[i];
114  else cmdline_error = true;
115  }
116  if(!filename || cmdline_error)
117  {
118  Error(MSGSOURCE, "No file name received!");
119  Error(MSGSOURCE, " Usage: %s [--debug] [--toys] [DxAOD file name]", argv[0]);
120  return 1;
121  }
122  #ifdef XAOD_STANDALONE
123  xAOD::Init(MSGSOURCE).ignore();
124  TFile* file = TFile::Open(filename, "READ");
125  if(!file)
126  {
127  Error(MSGSOURCE, "Unable to open file!");
128  return 2;
129  }
132  StatusCode::enableFailure();
133  #else
134  IAppMgrUI* app = POOL::Init();
136  TString file(filename);
137  #endif
138  event.readFrom(file).ignore();
139  Long64_t entries = event.getEntries();
140  Info(MSGSOURCE, "Number of events in the file: %lli", entries);
141 
142  /* ********************************************************************** */
143 
144  Info(MSGSOURCE, "Configuring the electron CP tools");
146  ToolHandleArray<IAsgElectronEfficiencyCorrectionTool> electronEffTools;
148  ToolHandleArray<IAsgElectronEfficiencyCorrectionTool> electronSFTools;
150  std::map<std::string,std::string> legsPerTool;
152  std::map<std::string,std::string> tagsPerTool;
154  std::map<std::string,std::string> legsPerTag;
156  static const SG::Decorator<char> dec_signal("Signal");
157 
159  vector<asg::AnaToolHandle<IAsgElectronEfficiencyCorrectionTool>> factory;
160  enum{ cLEGS, cTAG, cKEY, cPID, cISO };
161  std::vector<std::array<std::string,5> > toolConfigs = {
164  {"e12_lhloose_L1EM10VH", "Signal", "2015_e12_lhloose_L1EM10VH", "Tight", "FixedCutTightTrackOnly"},
166  {"e12_lhloose_L1EM10VH", "*", "2015_e12_lhloose_L1EM10VH", "LooseBLayer", ""}
167  };
168 
169  const char* mapPath = "ElectronEfficiencyCorrection/2015_2017/"
170  "rel21.2/Moriond_February2018_v2/map6.txt";
171  for(auto& cfg : toolConfigs)
172  for(int j=0;j<2;++j)
173  {
174  string name = "AsgElectronEfficiencyCorrectionTool/"
175  + ((j? "ElTrigEff_" : "ElTrigSF_")
176  + std::to_string(factory.size()/2));
177  auto t = factory.emplace(factory.end(), name);
178  t->setProperty("MapFilePath", mapPath).ignore();
179  t->setProperty("TriggerKey", string(j?"":"Eff_") + cfg[cKEY]).ignore();
180  t->setProperty("IdKey", cfg[cPID]).ignore();
181  t->setProperty("IsoKey", cfg[cISO]).ignore();
182 
183  t->setProperty("CorrelationModel", "TOTAL").ignore();
184  t->setProperty("ForceDataType", (int)PATCore::ParticleDataType::Full).ignore();
185  if(t->initialize() != StatusCode::SUCCESS)
186  {
187  Error(MSGSOURCE, "Unable to initialize the electron CP tool <%s>!",
188  t->name().c_str());
189  return 3;
190  }
191  auto& handles = (j? electronSFTools : electronEffTools);
192  handles.push_back(t->getHandle());
195  name = handles[handles.size()-1].name();
196  legsPerTool[name] = cfg[cLEGS];
197  tagsPerTool[name] = cfg[cTAG];
198  if(!j)
199  {
200  for(auto& tag : ::split_comma_delimited(cfg[cTAG]))
201  {
202  if(legsPerTag[tag]=="") legsPerTag[tag] = cfg[cLEGS];
203  else legsPerTag[tag] += "," + cfg[cLEGS];
204  }
205  }
206 
207  }
208 
209  /* ********************************************************************** */
210 
211  Info(MSGSOURCE, "Configuring the global trigger SF tool");
212  asg::AnaToolHandle<ITrigGlobalEfficiencyCorrectionTool> myTool("TrigGlobalEfficiencyCorrectionTool/TrigGlobal");
213  myTool.setProperty("ElectronEfficiencyTools", electronEffTools).ignore();
214  myTool.setProperty("ElectronScaleFactorTools", electronSFTools).ignore();
215  const char* triggers2015 = "2e12_lhloose_L12EM10VH";
216  myTool.setProperty("TriggerCombination2015", triggers2015).ignore();
217  myTool.setProperty("LeptonTagDecorations", "Signal").ignore();
218  myTool.setProperty("ListOfLegsPerTool", legsPerTool).ignore();
219  myTool.setProperty("ListOfTagsPerTool", tagsPerTool).ignore();
220  myTool.setProperty("ListOfLegsPerTag", legsPerTag).ignore();
221 
222  if(debug) myTool.setProperty("OutputLevel", MSG::DEBUG).ignore();
223  if(toys) myTool.setProperty("NumberOfToys", 1000).ignore();
224  if(myTool.initialize() != StatusCode::SUCCESS)
225  {
226  Error(MSGSOURCE, "Unable to initialize the TrigGlob tool!");
227  return 3;
228  }
229 
232  const unsigned periodRuns[] = {
234  276073, 278727, 279932, 280423, 281130, 282625
235  };
236  std::uniform_int_distribution<unsigned> uniformPdf(0,
237  sizeof(periodRuns)/sizeof(*periodRuns) - 1);
238  std::default_random_engine randomEngine;
239 
240  static const SG::ConstAccessor<int> truthType("truthType");
241  static const SG::ConstAccessor<int> truthOrigin("truthOrigin");
242 
243  /* ********************************************************************** */
244 
245  Info(MSGSOURCE, "Starting the event loop");
246  unsigned errors = 0;
247  double nSuitableEvents = 0., sumW = 0.;
248  static const SG::Decorator<unsigned> RandomRunNumberDec("RandomRunNumber");
249  for(Long64_t entry = 0; entry < entries; ++entry)
250  {
251  event.getEntry(entry);
252 
254  const xAOD::EventInfo* eventInfo = nullptr;
255  event.retrieve(eventInfo,"EventInfo").ignore();
256  unsigned runNumber = periodRuns[uniformPdf(randomEngine)];
257  RandomRunNumberDec(*eventInfo) = runNumber;
258  vector<const xAOD::Electron*> myTriggeringElectrons;
259  const xAOD::ElectronContainer* electrons = nullptr;
260  event.retrieve(electrons,"Electrons").ignore();
261  for(auto electron : *electrons)
262  {
263  if(!electron->caloCluster()) continue;
264  float eta = fabs(electron->caloCluster()->etaBE(2));
265  float pt = electron->pt();
266  if(pt<10e3f || eta>=2.47) continue;
267  if(!truthType.isAvailable(*electron)) continue;
268  if(!truthOrigin.isAvailable(*electron)) continue;
269  int t = truthType(*electron), o = truthOrigin(*electron);
270  if(t!=2 || !(o==10 || (o>=12 && o<=22) || o==43)) continue;
272  if(pt < 13e3f) continue;
273 
274  myTriggeringElectrons.push_back(electron);
275  }
276 
277  vector<const xAOD::Muon*> myTriggeringMuons;
278 
280  if(myTriggeringElectrons.size() < 2) continue;
281 
284  auto compareByPt = [](const xAOD::Electron*e1, const xAOD::Electron*e2)
285  { return e1->pt() < e2->pt(); };
286  auto leadingElectron = *std::max_element(myTriggeringElectrons.begin(),
287  myTriggeringElectrons.end(), compareByPt);
288  for(auto electron : myTriggeringElectrons)
289  {
292  dec_signal(*electron) = (electron==leadingElectron)? 1 : 0;
293  }
294 
295 
297  double sf = 1.;
298  auto cc = myTool->getEfficiencyScaleFactor(myTriggeringElectrons,
299  myTriggeringMuons, sf);
301  {
302  nSuitableEvents += 1;
303  sumW += sf;
304  }
305  else
306  {
307  Warning(MSGSOURCE, "Scale factor evaluation failed");
308  ++errors;
309  }
310  if(errors>10)
311  {
312  Error(MSGSOURCE, "Too many errors reported!");
313  break;
314  }
315  }
316  Info(MSGSOURCE, "Average scale factor: %f (over %ld events)",
317  sumW / nSuitableEvents, long(nSuitableEvents));
318  #ifndef XAOD_STANDALONE
319  ANA_CHECK(app->finalize())
320  #endif
321  return errors? 4 : 0;
322 }
SGTest::store
TestStore store
Definition: TestStore.cxx:23
asg::AnaToolHandle< ITrigGlobalEfficiencyCorrectionTool >
egammaEnergyPositionAllSamples::e1
double e1(const xAOD::CaloCluster &cluster)
return the uncorrected cluster energy in 1st sampling
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
test_pyathena.pt
pt
Definition: test_pyathena.py:11
ANA_CHECK
#define ANA_CHECK(EXP)
check whether the given expression was successful
Definition: Control/AthToolSupport/AsgMessaging/AsgMessaging/MessageCheck.h:324
SG::ConstAccessor< int >
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
xAOD::TEvent::kClassAccess
@ kClassAccess
Access auxiliary data using the aux containers.
Definition: Control/xAODRootAccess/xAODRootAccess/TEvent.h:100
ZDCMsg::Info
@ Info
Definition: ZDCMsg.h:20
IDTPM::truthType
int truthType(const U &p)
Definition: TrackParametersHelper.h:274
POOL::Init
IAppMgrUI * Init(const char *options="POOLRootAccess/basic.opts")
Bootstraps (creates and configures) the Gaudi Application with the provided options file.
Definition: PhysicsAnalysis/POOLRootAccess/src/TEvent.cxx:29
POOL::TEvent::kClassAccess
@ kClassAccess
Definition: PhysicsAnalysis/POOLRootAccess/POOLRootAccess/TEvent.h:46
IDTPM::truthOrigin
int truthOrigin(const U &p)
Definition: TrackParametersHelper.h:283
PATCore::ParticleDataType::Full
@ Full
Definition: PATCoreEnums.h:22
DiTauMassTools::ignore
void ignore(T &&)
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:58
MSGSOURCE
#define MSGSOURCE
Definition: TrigGlobEffCorrExample3a.cxx:99
event
POOL::TEvent event(POOL::TEvent::kClassAccess)
SG::Decorator< char >
lumiFormat.i
int i
Definition: lumiFormat.py:85
LArCellNtuple.argv
argv
Definition: LArCellNtuple.py:152
file
TFile * file
Definition: tile_monitor.h:29
DQHistogramMergeRegExp.argc
argc
Definition: DQHistogramMergeRegExp.py:20
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
mergePhysValFiles.errors
list errors
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:43
GetAllXsec.entry
list entry
Definition: GetAllXsec.py:132
POOL::TEvent
Definition: PhysicsAnalysis/POOLRootAccess/POOLRootAccess/TEvent.h:40
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
debug
const bool debug
Definition: MakeUncertaintyPlots.cxx:53
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
WriteCaloSwCorrections.cfg
cfg
Definition: WriteCaloSwCorrections.py:23
xAOD::Electron_v1
Definition: Electron_v1.h:34
xAOD::EventInfo_v1
Class describing the basic event information.
Definition: EventInfo_v1.h:43
DeMoAtlasDataLoss.runNumber
string runNumber
Definition: DeMoAtlasDataLoss.py:64
CP::CorrectionCode::Ok
@ Ok
The correction was done successfully.
Definition: CorrectionCode.h:38
xAOD::TStore
A relatively simple transient store for objects created in analysis.
Definition: TStore.h:44
mapkey::sf
@ sf
Definition: TElectronEfficiencyCorrectionTool.cxx:38
egammaEnergyPositionAllSamples::e2
double e2(const xAOD::CaloCluster &cluster)
return the uncorrected cluster energy in 2nd sampling
ANA_CHECK_SET_TYPE
#define ANA_CHECK_SET_TYPE(TYPE)
set the type for ANA_CHECK to report failures
Definition: Control/AthToolSupport/AsgMessaging/AsgMessaging/MessageCheck.h:314
DEBUG
#define DEBUG
Definition: page_access.h:11
xAOD::EgammaParameters::electron
@ electron
Definition: EgammaEnums.h:18
CaloCellTimeCorrFiller.filename
filename
Definition: CaloCellTimeCorrFiller.py:24
entries
double entries
Definition: listroot.cxx:49
L1Topo::Error
Error
The different types of error that can be flagged in the L1TopoRDO.
Definition: Error.h:16
CaloCondBlobAlgs_fillNoiseFromASCII.tag
string tag
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:24
InDetDD::electrons
@ electrons
Definition: InDetDD_Defs.h:17
xAOD::TEvent
Tool for accessing xAOD files outside of Athena.
Definition: Control/xAODRootAccess/xAODRootAccess/TEvent.h:84
python.handimod.cc
int cc
Definition: handimod.py:523
xAOD::Init
StatusCode Init(const char *appname)
Function initialising ROOT/PyROOT for using the ATLAS EDM.
Definition: Init.cxx:31