ATLAS Offline Software
Classes | Public Member Functions | Private Types | Private Member Functions | Private Attributes | Friends | List of all members
TrigGlobEffCorr::Calculator Class Reference

#include <Calculator.h>

Inheritance diagram for TrigGlobEffCorr::Calculator:
Collaboration diagram for TrigGlobEffCorr::Calculator:

Classes

class  Helper
 
struct  Period
 

Public Member Functions

 Calculator (TrigGlobalEfficiencyCorrectionTool &parent, unsigned nPeriodsToReserve)
 
bool addPeriod (ImportData &data, const std::pair< unsigned, unsigned > &boundaries, const std::string &combination, bool useToys, std::size_t &uniqueElectronLeg, std::size_t &uniquePhotonLeg)
 
bool compute (TrigGlobalEfficiencyCorrectionTool &parent, const LeptonList &leptons, unsigned runNumber, Efficiencies &efficiencies)
 
bool checkTriggerMatching (TrigGlobalEfficiencyCorrectionTool &parent, bool &matched, const LeptonList &leptons, unsigned runNumber)
 
bool getRelevantTriggersForUser (TrigGlobalEfficiencyCorrectionTool &parent, std::vector< std::string > &triggers, unsigned runNumber)
 
void setLevel (MSG::Level lvl)
 Change the current logging level. More...
 

Private Types

using LeptonList = TrigGlobalEfficiencyCorrectionTool::LeptonList
 
using TrigDef = TrigGlobEffCorr::ImportData::TrigDef
 
using GlobEffFunc = std::function< bool(Calculator *, const LeptonList &, unsigned, Efficiencies &)>
 

Private Member Functions

bool aboveThreshold (const Lepton &p, std::size_t leg) const
 
template<typename Trig1L >
auto getLoosestLegAboveThreshold (const Lepton &lepton, const flat_set< Trig1L > &trigs, bool &success) -> std::enable_if_t< Trig1L::is1L(), std::size_t >
 
Efficiencies getCachedTriggerLegEfficiencies (const Lepton &lepton, unsigned runNumber, std::size_t leg, bool &success)
 
bool fillListOfLegsFor (const Lepton &lepton, const std::vector< TrigDef > &triggers, flat_set< std::size_t > &validLegs) const
 
bool canTriggerBeFired (const TrigDef &trig, const std::vector< flat_set< std::size_t > > &firedLegs) const
 
const PeriodgetPeriod (unsigned runNumber) const
 
bool findUniqueLeg (xAOD::Type::ObjectType obj, std::size_t &uniqueLeg, const std::vector< TrigDef > &defs)
 
template<typename Trig1L >
auto globalEfficiency (const LeptonList &, unsigned, const Trig1L, Efficiencies &) -> std::enable_if_t< Trig1L::is1L(), bool >
 One single-lepton trigger. More...
 
template<typename Trig1L_obj1 , typename Trig1L_obj2 >
auto globalEfficiency (const LeptonList &, unsigned, const Trig1L_obj1 trig1, const Trig1L_obj2 trig2, Efficiencies &) -> std::enable_if_t< Trig1L_obj1::is1L() &&Trig1L_obj2::is1L() &&Trig1L_obj1::object() !=Trig1L_obj2::object(), bool >
 Two single-lepton triggers, two object types. More...
 
template<typename Trig1L >
auto globalEfficiency (const LeptonList &, unsigned, const flat_set< Trig1L > &, Efficiencies &) -> std::enable_if_t< Trig1L::is1L(), bool >
 Several single-lepton triggers, one object type. More...
 
template<typename Trig1L_obj1 , typename Trig1L_obj2 >
auto globalEfficiency (const LeptonList &, unsigned, const flat_set< Trig1L_obj1 > &trigs1, const flat_set< Trig1L_obj2 > &trigs2, Efficiencies &) -> std::enable_if_t< Trig1L_obj1::is1L() &&Trig1L_obj2::is1L() &&Trig1L_obj1::object() !=Trig1L_obj2::object(), bool >
 Several single-lepton triggers, two object types. More...
 
template<typename Trig2Lmix >
auto globalEfficiency (const LeptonList &, unsigned, const Trig2Lmix, Efficiencies &) -> std::enable_if_t< Trig2Lmix::is2Lmix(), bool >
 One mixed-flavour dilepton trigger. More...
 
template<typename Trig2Lsym >
auto globalEfficiency (const LeptonList &, unsigned, const Trig2Lsym, Efficiencies &) -> std::enable_if_t< Trig2Lsym::is2Lsym(), bool >
 One symmetric dilepton trigger. More...
 
template<typename Trig2Lasym >
auto globalEfficiency (const LeptonList &, unsigned, const Trig2Lasym, Efficiencies &) -> std::enable_if_t< Trig2Lasym::is2Lasym(), bool >
 One asymmetric dilepton trigger. More...
 
template<typename Trig2Lmix , typename Trig1L_obj1 , typename Trig1L_obj2 >
auto globalEfficiency (const LeptonList &, unsigned, const Trig2Lmix, const flat_set< Trig1L_obj1 > &, const flat_set< Trig1L_obj2 > &, Efficiencies &) -> std::enable_if_t< Trig2Lmix::is2Lmix() &&Trig1L_obj1::is1L() &&Trig2Lmix::object1()==Trig1L_obj1::object() &&Trig1L_obj2::is1L() &&Trig2Lmix::object2()==Trig1L_obj2::object(), bool >
 One mixed-flavour dilepton trigger + single-lepton triggers. More...
 
template<typename Trig2L , typename Trig1L >
auto globalEfficiency (const LeptonList &, unsigned, const Trig2L, const Trig1L, Efficiencies &) -> std::enable_if_t< Trig2L::is2Lnomix() &&Trig1L::is1L() &&Trig2L::object()==Trig1L::object(), bool >
 One dilepton trigger + one single-lepton trigger. More...
 
template<typename Trig2Lsym , typename Trig1L >
auto globalEfficiency (const LeptonList &, unsigned, const Trig2Lsym, const flat_set< Trig1L > &, Efficiencies &) -> std::enable_if_t< Trig2Lsym::is2Lsym() &&Trig1L::is1L() &&Trig1L::object()==Trig2Lsym::object(), bool >
 One symmetric dilepton trigger + several single-lepton triggers. More...
 
template<typename Trig2Lasym , typename Trig1L >
auto globalEfficiency (const LeptonList &, unsigned, const Trig2Lasym, const flat_set< Trig1L > &, Efficiencies &) -> std::enable_if_t< Trig2Lasym::is2Lasym() &&Trig1L::is1L() &&Trig1L::object()==Trig2Lasym::object(), bool >
 One asymmetric dilepton trigger + several single-lepton triggers. More...
 
template<typename Trig2Lsym , typename Trig1L >
auto globalEfficiency (const LeptonList &, unsigned, const Trig2Lsym, const Trig2Lsym, const flat_set< Trig1L > &, Efficiencies &) -> std::enable_if_t< Trig2Lsym::is2Lsym() &&Trig1L::is1L() &&Trig1L::object()==Trig2Lsym::object(), bool >
 Two symmetric dilepton triggers + several single-lepton triggers. More...
 
template<typename Trig2Lasym , typename Trig2Lsym , typename Trig1L >
auto globalEfficiency (const LeptonList &, unsigned, const Trig2Lasym, const Trig2Lsym, const flat_set< Trig1L > &, Efficiencies &) -> std::enable_if_t< Trig2Lasym::is2Lasym() &&Trig2Lsym::is2Lsym() &&Trig2Lsym::object()==Trig2Lasym::object() &&Trig1L::is1L() &&Trig1L::object()==Trig2Lasym::object(), bool >
 Two dilepton triggers (one asym., one sym.) + several single-lepton triggers. More...
 
template<typename Trig3Lsym >
auto globalEfficiency (const LeptonList &, unsigned, const Trig3Lsym, Efficiencies &) -> std::enable_if_t< Trig3Lsym::is3Lsym(), bool >
 One symmetric trilepton trigger. More...
 
template<typename Trig3Lhalfsym >
auto globalEfficiency (const LeptonList &, unsigned, const Trig3Lhalfsym, Efficiencies &) -> std::enable_if_t< Trig3Lhalfsym::is3Lhalfsym(), bool >
 One half-symmetric trilepton trigger. More...
 
template<typename Trig2L , typename Trig2Lmix >
auto globalEfficiency (const LeptonList &, unsigned, const Trig2L, const Trig2Lmix, Efficiencies &) -> std::enable_if_t< Trig2L::is2Lnomix() &&Trig2Lmix::is2Lmix() &&(Trig2Lmix::object1()==Trig2L::object()||Trig2Lmix::object2()==Trig2L::object()), bool >
 One dilepton trigger + one mixed-flavour dilepton trigger. More...
 
template<typename Trig2L_obj1 , typename Trig2L_obj2 , typename Trig2Lmix >
auto globalEfficiency (const LeptonList &, unsigned, const Trig2L_obj1, const Trig2L_obj2, const Trig2Lmix, Efficiencies &) -> std::enable_if_t< Trig2Lmix::is2Lmix() &&Trig2L_obj1::is2Lnomix() &&Trig2L_obj1::object()==Trig2Lmix::object1() &&Trig2L_obj2::is2Lnomix() &&Trig2L_obj2::object()==Trig2Lmix::object2(), bool >
 Combinaisons with 3 dilepton triggers including one mixed-flavour, and one sym. More...
 
template<typename Trig2L_obj1 , typename Trig2L_obj2 , typename Trig2Lmix , typename Trig1L_obj1 , typename Trig1L_obj2 >
auto globalEfficiency (const LeptonList &, unsigned, const Trig2L_obj1, const Trig2L_obj2, const Trig2Lmix, const flat_set< Trig1L_obj1 > &, const flat_set< Trig1L_obj2 > &, Efficiencies &) -> std::enable_if_t< Trig2Lmix::is2Lmix() &&Trig2L_obj1::is2Lnomix() &&Trig2L_obj1::object()==Trig2Lmix::object1() &&Trig2L_obj2::is2Lnomix() &&Trig2L_obj2::object()==Trig2Lmix::object2() &&Trig1L_obj1::is1L() &&Trig1L_obj1::object()==Trig2Lmix::object1() &&Trig1L_obj2::is1L() &&Trig1L_obj2::object()==Trig2Lmix::object2(), bool >
 Same combinaisons with 3 dilepton triggers, + single-lepton triggers. More...
 
template<typename Trig2L_obj1 , typename Trig2Lsym_obj1 , typename Trig2L_obj2 , typename Trig2Lsym_obj2 , typename Trig2Lmix , typename Trig1L_obj1 , typename Trig1L_obj2 >
auto globalEfficiency (const LeptonList &, unsigned, const Trig2L_obj1, const Trig2Lsym_obj1, const Trig2L_obj2, const Trig2Lsym_obj2, const Trig2Lmix, const Trig2Lmix, const flat_set< Trig1L_obj1 > &, const flat_set< Trig1L_obj2 > &, Efficiencies &) -> std::enable_if_t< Trig2Lmix::is2Lmix() &&Trig2L_obj1::is2Lnomix() &&Trig2L_obj1::object()==Trig2Lmix::object1() &&Trig2L_obj2::is2Lnomix() &&Trig2L_obj2::object()==Trig2Lmix::object2() &&Trig2Lsym_obj1::is2Lsym() &&Trig2Lsym_obj1::object()==Trig2Lmix::object1() &&Trig2Lsym_obj2::is2Lsym() &&Trig2Lsym_obj2::object()==Trig2Lmix::object2() &&Trig1L_obj1::is1L() &&Trig1L_obj1::object()==Trig2Lmix::object1() &&Trig1L_obj2::is1L() &&Trig1L_obj2::object()==Trig2Lmix::object2(), bool >
 Six dilepton triggers (two mixed-flavour, two sym., two asym. More...
 
template<typename Trig3Lmix >
auto globalEfficiency (const LeptonList &, unsigned, const Trig3Lmix, Efficiencies &) -> std::enable_if_t< Trig3Lmix::is3Lmix(), bool >
 One mixed-flavour trilepton trigger. More...
 
template<typename Trig3Lmix1 , typename Trig3Lmix2 >
auto globalEfficiency (const LeptonList &, unsigned, const Trig3Lmix1, const Trig3Lmix2, Efficiencies &) -> std::enable_if_t< Trig3Lmix1::is3Lmix() &&Trig3Lmix2::is3Lmix() &&Trig3Lmix1::object1()==Trig3Lmix2::object2() &&Trig3Lmix1::object2()==Trig3Lmix2::object1(), bool >
 Two complementary mixed-flavour trilepton triggers. More...
 
template<typename Trig4Lsym >
auto globalEfficiency (const LeptonList &, unsigned, const Trig4Lsym, Efficiencies &) -> std::enable_if_t< Trig4Lsym::is4Lsym(), bool >
 One symmetric tetralepton trigger. More...
 
bool globalEfficiency_Factorized2 (const LeptonList &leptons, unsigned runNumber, GlobEffFunc func1, GlobEffFunc func2, Efficiencies &globalEfficiencies)
 
bool globalEfficiency_Factorized3 (const LeptonList &leptons, unsigned runNumber, GlobEffFunc func1, GlobEffFunc func2, GlobEffFunc func3, Efficiencies &globalEfficiencies)
 
bool globalEfficiency_Toys (const LeptonList &, unsigned, const std::vector< TrigDef > &triggers, Efficiencies &)
 
void initMessaging () const
 Initialize our message level and MessageSvc. More...
 

Private Attributes

TrigGlobalEfficiencyCorrectionToolm_parent
 
std::vector< Periodm_periods
 pointer updated at each call to compute() because the parent tool might have been moved in-between More...
 
std::map< std::pair< const Lepton *, std::size_t >, Efficienciesm_cachedEfficiencies
 
bool m_forceUnitSF
 
std::string m_nm
 Message source name. More...
 
boost::thread_specific_ptr< MsgStream > m_msg_tls
 MsgStream instance (a std::cout like with print-out levels) More...
 
std::atomic< IMessageSvc * > m_imsg { nullptr }
 MessageSvc pointer. More...
 
std::atomic< MSG::Level > m_lvl { MSG::NIL }
 Current logging level. More...
 
std::atomic_flag m_initialized ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
 Messaging initialized (initMessaging) More...
 

Friends

class CheckConfig
 

Detailed Description

Definition at line 26 of file Calculator.h.

Member Typedef Documentation

◆ GlobEffFunc

using TrigGlobEffCorr::Calculator::GlobEffFunc = std::function<bool(Calculator*, const LeptonList&, unsigned, Efficiencies&)>
private

Definition at line 29 of file Calculator.h.

◆ LeptonList

Definition at line 27 of file Calculator.h.

◆ TrigDef

Definition at line 28 of file Calculator.h.

Constructor & Destructor Documentation

◆ Calculator()

Calculator::Calculator ( TrigGlobalEfficiencyCorrectionTool parent,
unsigned  nPeriodsToReserve 
)

Definition at line 22 of file Calculator.cxx.

25  msg().setLevel(parent.msg().level());
26  m_periods.reserve(nPeriodsToReserve);
27 }

Member Function Documentation

◆ aboveThreshold()

bool TrigGlobEffCorr::Calculator::aboveThreshold ( const Lepton p,
std::size_t  leg 
) const
inlineprivate

Definition at line 70 of file Calculator.h.

70  {
71  return m_parent->aboveThreshold(p, leg);
72  }

◆ addPeriod()

bool Calculator::addPeriod ( ImportData data,
const std::pair< unsigned, unsigned > &  boundaries,
const std::string &  combination,
bool  useToys,
std::size_t &  uniqueElectronLeg,
std::size_t &  uniquePhotonLeg 
)

Choose the appropriate function to compute efficiencies for this particular trigger combination

Definition at line 29 of file Calculator.cxx.

33  {
34  bool success = true;
35  m_parent = data.getParent();
36 
37  auto triggers = data.parseTriggerString(combination, success);
38  if (!success)
39  return false;
40  if (!triggers.size()) {
41  ATH_MSG_ERROR("The trigger combination is empty!");
42  return false;
43  }
44 
45  if (!findUniqueLeg(xAOD::Type::Electron, uniqueElectronLeg, triggers))
46  return false;
47  if (!findUniqueLeg(xAOD::Type::Photon, uniquePhotonLeg, triggers))
48  return false;
49 
53  if (helper.duplicates()) {
54  ATH_MSG_ERROR("The following combination of triggers contains duplicates: "
55  << combination);
56  return false;
57  }
58  if (!useToys) {
59  success = helper.findAndBindFunction();
60  if (!helper.m_formula) {
62  "This trigger combination is currently not supported with an "
63  "explicit formula (you may use toys instead, slower): "
64  << combination);
65  return false;
66  }
67  } else {
68  helper.m_formula = std::bind(&Calculator::globalEfficiency_Toys, ::_1, ::_2,
69  ::_3, triggers, ::_4);
70  }
71  if (success) {
72  if (data.adaptTriggerListForTriggerMatching(triggers)) {
73  m_periods.emplace_back(boundaries, std::move(helper.m_formula),
74  std::move(triggers));
75  } else {
77  return false;
78  m_periods.emplace_back(boundaries, std::move(helper.m_formula));
79  }
80  } else {
82  "Unspecified error occurred while trying to find the formula for the "
83  "trigger combination "
84  << combination);
85  }
86  return success;
87 }

◆ canTriggerBeFired()

bool Calculator::canTriggerBeFired ( const TrigDef trig,
const std::vector< flat_set< std::size_t > > &  firedLegs 
) const
private

Definition at line 1465 of file Calculator.cxx.

1467  {
1468  const int nLegs = static_cast<int>(std::count_if(
1469  trig.leg.begin(), trig.leg.end(), [](auto x) { return x != 0ul; }));
1470  const int sameLegs = static_cast<int>(
1471  std::count(trig.leg.begin(), trig.leg.end(), trig.leg[0]));
1472  if (sameLegs == nLegs) {
1473  // single-lepton and symmetric multilepton triggers
1474  return std::count_if(firedLegs.cbegin(), firedLegs.cend(), [&](auto& legs) {
1475  return legs.count(trig.leg[0]);
1476  }) >= nLegs;
1477  } else if (nLegs == 2) {
1478  // asymmetric or mixed-flavour dilepton triggers
1479  bool n0 = false, n1 = false;
1480  for (auto& legs : firedLegs) {
1481  if (n0 && legs.count(trig.leg[1]))
1482  return true;
1483  if (n1 && legs.count(trig.leg[0]))
1484  return true;
1485  n0 = n0 || legs.count(trig.leg[0]);
1486  n1 = n1 || legs.count(trig.leg[1]);
1487  }
1488  } else if (nLegs == 3) {
1489  // other trilepton triggers
1490  auto end = firedLegs.end();
1491  for (auto legs0 = firedLegs.begin(); legs0 != end; ++legs0) {
1492  for (int i = 0; i < 3; ++i) {
1493  if (!legs0->count(trig.leg[i]))
1494  continue;
1495  for (auto legs1 = legs0 + 1; legs1 != end; ++legs1) {
1496  for (int j = 1; j < 3; ++j) {
1497  if (!legs1->count(trig.leg[(i + j) % 3]))
1498  continue;
1499  for (auto legs2 = legs1 + 1; legs2 != end; ++legs2) {
1500  if (legs2->count(trig.leg[(i + 3 - j) % 3]))
1501  return true;
1502  }
1503  }
1504  }
1505  }
1506  }
1507  } else {
1508  ATH_MSG_ERROR("incomplete support of 4-lepton triggers.");
1509  }
1510  return false;
1511 }

◆ checkTriggerMatching()

bool Calculator::checkTriggerMatching ( TrigGlobalEfficiencyCorrectionTool parent,
bool &  matched,
const LeptonList leptons,
unsigned  runNumber 
)

First, for each lepton, list the trigger leg(s) it is allowed to fire (depends on pT and selection tags)

Then for each trigger, call trigger matching tool for all possible (valid) lepton combinations

Get trigger chain name with a "HLT_" prefix

borrow the set of legs that can be fired by that lepton

enough lepton(s) on trigger plateau?

return the set of legs back to the main container

Definition at line 144 of file Calculator.cxx.

146  {
147  matched = false;
148  m_parent = &parent;
149  auto period = getPeriod(runNumber);
150  if (!period)
151  return false;
152  if (!period->m_triggers.size()) {
153  ATH_MSG_ERROR("Empty list of triggers for run number " << runNumber);
154  return false;
155  }
156  auto& trigMatchTool = m_parent->m_trigMatchTool;
157 
160  const unsigned nLep = leptons.size();
161  std::vector<flat_set<std::size_t>> validLegs(leptons.size());
162  for (unsigned i = 0; i < nLep; ++i) {
163  if (!fillListOfLegsFor(leptons[i], period->m_triggers, validLegs[i]))
164  return false;
165  }
166 
169  std::vector<flat_set<std::size_t>> firedLegs;
170  std::vector<const xAOD::IParticle*> trigLeptons;
171  const std::size_t magicWordHLT = 0xf7b8b87ef2917d66;
172 
173  for (auto& trig : period->m_triggers) {
175  auto itr = m_parent->m_dictionary.find(trig.name ^ magicWordHLT);
176  if (itr == m_parent->m_dictionary.end()) {
177  itr = m_parent->m_dictionary
178  .emplace(trig.name ^ magicWordHLT,
179  "HLT_" + m_parent->m_dictionary.at(trig.name))
180  .first;
181  }
182  const std::string& chain = itr->second;
183 
184  unsigned nLegs = 0;
185  if (trig.type & TT_SINGLELEPTON_FLAG)
186  nLegs = 1;
187  else if (trig.type & TT_DILEPTON_FLAG)
188  nLegs = 2;
189  else if (trig.type & TT_TRILEPTON_FLAG)
190  nLegs = 3;
191  else {
192  ATH_MSG_ERROR("Unsupported trigger (type = "
193  << std::hex << trig.type << std::dec << ") " << chain);
194  return false;
195  }
196  firedLegs.resize(nLegs);
197  trigLeptons.resize(nLegs);
198  for (unsigned i0 = 0; i0 < nLep; ++i0) {
199  firedLegs[0].swap(validLegs[i0]);
200  trigLeptons[0] = leptons[i0].particle();
202  if (nLegs == 1) {
203  if (canTriggerBeFired(
204  trig, firedLegs)
205  && trigMatchTool->match(trigLeptons, chain))
206  return (matched = true);
207  } else
208  for (unsigned i1 = i0 + 1; i1 < nLep; ++i1) {
209  firedLegs[1].swap(validLegs[i1]);
210  trigLeptons[1] = leptons[i1].particle();
211  if (nLegs == 2) {
212  if (canTriggerBeFired(trig, firedLegs) &&
213  trigMatchTool->match(trigLeptons, chain))
214  return (matched = true);
215  } else
216  for (unsigned i2 = i1 + 1; i2 < nLep; ++i2) {
217  firedLegs[2].swap(validLegs[i2]);
218  trigLeptons[2] = leptons[i2].particle();
219  if (canTriggerBeFired(trig, firedLegs) &&
220  trigMatchTool->match(trigLeptons, chain))
221  return (matched = true);
222  firedLegs[2].swap(validLegs[i2]);
223  }
224  firedLegs[1].swap(validLegs[i1]);
225  }
226  firedLegs[0].swap(
227  validLegs[i0]);
228  }
229  }
230  return true;
231 }

◆ compute()

bool Calculator::compute ( TrigGlobalEfficiencyCorrectionTool parent,
const LeptonList leptons,
unsigned  runNumber,
Efficiencies efficiencies 
)

Definition at line 125 of file Calculator.cxx.

127  {
128  m_parent = &parent;
129  m_forceUnitSF = false;
130  auto period = getPeriod(runNumber);
131  if (!period)
132  return false;
133  m_cachedEfficiencies.clear();
134  bool success = period->m_formula &&
135  period->m_formula(this, leptons, runNumber, efficiencies);
136  if (m_forceUnitSF) {
137  efficiencies.data() = 1.;
138  efficiencies.mc() = 1.;
139  success = true;
140  }
141  return success;
142 }

◆ fillListOfLegsFor()

bool Calculator::fillListOfLegsFor ( const Lepton lepton,
const std::vector< TrigDef > &  triggers,
flat_set< std::size_t > &  validLegs 
) const
private

Definition at line 1447 of file Calculator.cxx.

1449  {
1450  validLegs.clear();
1451  for (auto& trig : triggers) {
1452  TriggerProperties tp(trig);
1453  if (!tp.valid()) {
1454  ATH_MSG_ERROR("Unrecognized trigger type " << trig.type);
1455  return false;
1456  }
1457  auto end = tp.cend(lepton.type());
1458  for (auto itr = tp.cbegin(lepton.type()); itr != end; ++itr)
1459  if (aboveThreshold(lepton, *itr))
1460  validLegs.emplace(*itr);
1461  }
1462  return true;
1463 }

◆ findUniqueLeg()

bool Calculator::findUniqueLeg ( xAOD::Type::ObjectType  obj,
std::size_t &  uniqueLeg,
const std::vector< TrigDef > &  defs 
)
private

initial non-zero value means that ListOfLegsPerTool is filled

Definition at line 89 of file Calculator.cxx.

91  {
92  if (uniqueLeg)
93  return true;
94  for (auto& def : defs) {
96  TriggerProperties tp(def);
97  for (auto itr = tp.cbegin(obj); itr != tp.cend(obj); ++itr) {
98  if (uniqueLeg && uniqueLeg != *itr) {
100  "The property 'ListOfLegsPerTool' needs to be filled as the "
101  "specified trigger combination involves several electron (or "
102  "photon) trigger legs");
103  return false;
104  }
105  uniqueLeg = *itr;
106  }
107  }
108  return true;
109 }

◆ getCachedTriggerLegEfficiencies()

Efficiencies Calculator::getCachedTriggerLegEfficiencies ( const Lepton lepton,
unsigned  runNumber,
std::size_t  leg,
bool &  success 
)
private

Definition at line 265 of file Calculator.cxx.

268  {
269  auto insertion = m_cachedEfficiencies.emplace(std::make_pair(&lepton, leg),
270  Efficiencies());
271  Efficiencies& efficiencies = insertion.first->second;
272  if (insertion.second) {
274  switch (lepton.type()) {
277  lepton.electron(), runNumber, leg, lepton.tag(), efficiencies);
278  break;
279  case xAOD::Type::Muon:
281  lepton.tag(), efficiencies);
282  break;
283  case xAOD::Type::Photon:
285  lepton.photon(), runNumber, leg, lepton.tag(), efficiencies);
286  break;
287  default:
288  ATH_MSG_ERROR("Unsupported particle type");
289  }
290  switch (res) {
292  break;
294  m_forceUnitSF = true;
295  break;
297  [[fallthrough]];
298  default:
299  success = false;
300  efficiencies.data() = -777.;
301  efficiencies.mc() = -777.;
302  }
303  }
304  if (efficiencies.mc() == -777. && !m_forceUnitSF)
305  success = false;
306  return efficiencies;
307 }

◆ getLoosestLegAboveThreshold()

template<typename Trig1L >
auto TrigGlobEffCorr::Calculator::getLoosestLegAboveThreshold ( const Lepton lepton,
const flat_set< Trig1L > &  trigs,
bool &  success 
) -> std::enable_if_t<Trig1L::is1L(), std::size_t>
inlineprivate

Definition at line 74 of file Calculator.h.

76  {
78  lepton, Trig1L::anonymize(trigs), success);
79  }

◆ getPeriod()

const Calculator::Period * Calculator::getPeriod ( unsigned  runNumber) const
private

Definition at line 111 of file Calculator.cxx.

111  {
112  auto period =
113  std::find_if(m_periods.cbegin(), m_periods.cend(), [=](const Period& p) {
114  return runNumber >= p.m_boundaries.first &&
115  runNumber <= p.m_boundaries.second;
116  });
117  if (period == m_periods.end()) {
118  ATH_MSG_ERROR("No trigger combination has been specified for run "
119  << runNumber);
120  return nullptr;
121  }
122  return &*period;
123 }

◆ getRelevantTriggersForUser()

bool Calculator::getRelevantTriggersForUser ( TrigGlobalEfficiencyCorrectionTool parent,
std::vector< std::string > &  triggers,
unsigned  runNumber 
)

Definition at line 233 of file Calculator.cxx.

235  {
236  triggers.clear();
237  m_parent = &parent;
238  auto period = getPeriod(runNumber);
239  if (!period)
240  return false;
241  if (!period->m_triggers.size()) {
242  ATH_MSG_ERROR("Empty list of triggers for run number "
243  << runNumber
244  << " (was there a configuration issue? please check for "
245  "warnings during initialization)");
246  return false;
247  }
248  bool success = true;
249  auto notfound = parent.m_dictionary.end();
250  for (auto& trig : period->m_triggers) {
251  auto itr = parent.m_dictionary.find(trig.name);
252  if (itr == notfound) {
253  ATH_MSG_ERROR("can't retrieve name of trigger with hash "
254  << trig.name
255  << " (shouldn't happen; contact tool developers!)");
256  success = false;
257  } else
258  triggers.push_back(itr->second);
259  }
260  if (!success)
261  triggers.clear();
262  return success;
263 }

◆ globalEfficiency() [1/22]

template<typename Trig1L >
auto Calculator::globalEfficiency ( const LeptonList leptons,
unsigned  runNumber,
const flat_set< Trig1L > &  trigs,
Efficiencies globalEfficiencies 
) -> std::enable_if_t<Trig1L::is1L(), bool>
private

Several single-lepton triggers, one object type.

Definition at line 377 of file Calculator.cxx.

380  {
381  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Several1L() at line "
382  << __LINE__);
383  if (trigs.size() == 1)
384  return globalEfficiency(leptons, runNumber, *trigs.cbegin(),
385  globalEfficiencies);
386  if (!trigs.size()) {
387  globalEfficiencies = {0.};
388  return true;
389  }
390  globalEfficiencies = {1.};
391  bool success = true;
392  for (auto& lepton : leptons) {
393  if (Trig1L::irrelevantFor(lepton))
394  continue;
395  std::size_t loosestLeg =
396  getLoosestLegAboveThreshold(lepton, trigs, success);
397  if (loosestLeg && success) {
399  loosestLeg, success);
400  globalEfficiencies *= ~efficiencies;
401  }
402  }
403  globalEfficiencies = ~globalEfficiencies;
404  return success;
405 }

◆ globalEfficiency() [2/22]

template<typename Trig1L_obj1 , typename Trig1L_obj2 >
auto Calculator::globalEfficiency ( const LeptonList leptons,
unsigned  runNumber,
const flat_set< Trig1L_obj1 > &  trigs1,
const flat_set< Trig1L_obj2 > &  trigs2,
Efficiencies globalEfficiencies 
) -> std::enable_if_t<Trig1L_obj1::is1L() && Trig1L_obj2::is1L() && Trig1L_obj1::object() != Trig1L_obj2::object(), bool>
private

Several single-lepton triggers, two object types.

Definition at line 411 of file Calculator.cxx.

417  {
418  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Several1L() at line "
419  << __LINE__);
420  if (trigs1.size() == 1 && trigs2.size() == 1) {
421  return globalEfficiency(leptons, runNumber, *trigs1.cbegin(),
422  *trigs2.cbegin(), globalEfficiencies);
423  }
424  if (!trigs1.size())
425  return globalEfficiency(leptons, runNumber, trigs2, globalEfficiencies);
426  if (!trigs2.size())
427  return globalEfficiency(leptons, runNumber, trigs1, globalEfficiencies);
428  globalEfficiencies = {1.};
429  bool success = true;
430  for (auto& lepton : leptons) {
431  std::size_t loosestLeg;
432  if (Trig1L_obj1::relevantFor(lepton))
433  loosestLeg = getLoosestLegAboveThreshold(lepton, trigs1, success);
434  else if (Trig1L_obj2::relevantFor(lepton))
435  loosestLeg = getLoosestLegAboveThreshold(lepton, trigs2, success);
436  else
437  continue;
438  if (loosestLeg && success) {
440  loosestLeg, success);
441  globalEfficiencies *= ~efficiencies;
442  }
443  }
444  globalEfficiencies = ~globalEfficiencies;
445  return success;
446 }

◆ globalEfficiency() [3/22]

template<typename Trig1L >
auto Calculator::globalEfficiency ( const LeptonList leptons,
unsigned  runNumber,
const Trig1L  trig,
Efficiencies globalEfficiencies 
) -> std::enable_if_t<Trig1L::is1L(), bool>
private

One single-lepton trigger.

Definition at line 313 of file Calculator.cxx.

316  {
317  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One1L() at line "
318  << __LINE__);
319  if (!trig) {
320  globalEfficiencies = {0.};
321  return true;
322  }
323  globalEfficiencies = {1.};
324  bool success = true;
325  for (auto& lepton : leptons) {
326  if (trig.irrelevantFor(lepton) || !aboveThreshold(lepton, trig()))
327  continue;
328  auto efficiencies =
329  getCachedTriggerLegEfficiencies(lepton, runNumber, trig(), success);
330  globalEfficiencies *= ~efficiencies;
331  }
332  globalEfficiencies = ~globalEfficiencies;
333  return success;
334 }

◆ globalEfficiency() [4/22]

template<typename Trig1L_obj1 , typename Trig1L_obj2 >
auto Calculator::globalEfficiency ( const LeptonList leptons,
unsigned  runNumber,
const Trig1L_obj1  trig1,
const Trig1L_obj2  trig2,
Efficiencies globalEfficiencies 
) -> std::enable_if_t<Trig1L_obj1::is1L() && Trig1L_obj2::is1L() && Trig1L_obj1::object() != Trig1L_obj2::object(), bool>
private

Two single-lepton triggers, two object types.

Definition at line 340 of file Calculator.cxx.

346  {
347  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Two1L() at line "
348  << __LINE__);
349  if (!trig1)
350  return globalEfficiency(leptons, runNumber, trig2, globalEfficiencies);
351  if (!trig2)
352  return globalEfficiency(leptons, runNumber, trig1, globalEfficiencies);
353  globalEfficiencies = {1.};
354  bool success = true;
355  for (auto& lepton : leptons) {
356  std::size_t leg;
357  if (trig1.relevantFor(lepton))
358  leg = trig1();
359  else if (trig2.relevantFor(lepton))
360  leg = trig2();
361  else
362  continue;
363  if (!aboveThreshold(lepton, leg))
364  continue;
365  auto efficiencies =
366  getCachedTriggerLegEfficiencies(lepton, runNumber, leg, success);
367  globalEfficiencies *= ~efficiencies;
368  }
369  globalEfficiencies = ~globalEfficiencies;
370  return success;
371 }

◆ globalEfficiency() [5/22]

template<typename Trig2L , typename Trig1L >
auto Calculator::globalEfficiency ( const LeptonList leptons,
unsigned  runNumber,
const Trig2L  trig2L,
const Trig1L  trig1L,
Efficiencies globalEfficiencies 
) -> std::enable_if_t<Trig2L::is2Lnomix() && Trig1L::is1L() && Trig2L::object() == Trig1L::object(), bool>
inlineprivate

One dilepton trigger + one single-lepton trigger.

Definition at line 590 of file Calculator.cxx.

597  {
598  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One2LSeveral1L() at line "
599  << __LINE__);
600  return globalEfficiency(leptons, runNumber, trig2L, flat_set<Trig1L>{trig1L},
601  globalEfficiencies);
602 }

◆ globalEfficiency() [6/22]

template<typename Trig2L , typename Trig2Lmix >
auto Calculator::globalEfficiency ( const LeptonList leptons,
unsigned  runNumber,
const Trig2L  trig2L,
const Trig2Lmix  trig2Lmix,
Efficiencies globalEfficiencies 
) -> std::enable_if_t<Trig2L::is2Lnomix() && Trig2Lmix::is2Lmix() && (Trig2Lmix::object1() == Trig2L::object() || Trig2Lmix::object2() == Trig2L::object()), bool>
private

One dilepton trigger + one mixed-flavour dilepton trigger.

Definition at line 1097 of file Calculator.cxx.

1104  {
1105  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Two2L() at line "
1106  << __LINE__);
1107  Efficiencies efficiencies1L, efficiencies2L, efficiencies2Lor1L;
1108  bool success =
1109  globalEfficiency(leptons, runNumber,
1110  trig2Lmix.template antiside<Trig2L>(), efficiencies1L);
1111  success =
1112  success && globalEfficiency(leptons, runNumber, trig2L, efficiencies2L);
1113  success = success && globalEfficiency(leptons, runNumber, trig2L,
1114  trig2Lmix.template side<Trig2L>(),
1115  efficiencies2Lor1L);
1116  globalEfficiencies =
1117  efficiencies2L * ~efficiencies1L + efficiencies1L * efficiencies2Lor1L;
1118  return success;
1119 }

◆ globalEfficiency() [7/22]

template<typename Trig2L_obj1 , typename Trig2L_obj2 , typename Trig2Lmix , typename Trig1L_obj1 , typename Trig1L_obj2 >
auto Calculator::globalEfficiency ( const LeptonList leptons,
unsigned  runNumber,
const Trig2L_obj1  trig2L_obj1,
const Trig2L_obj2  trig2L_obj2,
const Trig2Lmix  trig2Lmix,
const flat_set< Trig1L_obj1 > &  trigs1L_obj1,
const flat_set< Trig1L_obj2 > &  trigs1L_obj2,
Efficiencies globalEfficiencies 
) -> std::enable_if_t<Trig2Lmix::is2Lmix() && Trig2L_obj1::is2Lnomix() && Trig2L_obj1::object() == Trig2Lmix::object1() && Trig2L_obj2::is2Lnomix() && Trig2L_obj2::object() == Trig2Lmix::object2() && Trig1L_obj1::is1L() && Trig1L_obj1::object() == Trig2Lmix::object1() && Trig1L_obj2::is1L() && Trig1L_obj2::object() == Trig2Lmix::object2(), bool>
private

Same combinaisons with 3 dilepton triggers, + single-lepton triggers.

Definition at line 1183 of file Calculator.cxx.

1199  {
1200  ATH_MSG_DEBUG(
1201  "Entered Calculator::globalEfficiency_Three2LSeveral1L() at line "
1202  << __LINE__);
1204  bool success = true;
1205  if (trig2L_obj1)
1206  success = success && globalEfficiency(leptons, runNumber, trig2L_obj1,
1207  trigs1L_obj1, efficiencies[0]);
1208  else
1209  success = success && globalEfficiency(leptons, runNumber, trigs1L_obj1,
1210  efficiencies[0]);
1211  if (trig2L_obj2)
1212  success = success && globalEfficiency(leptons, runNumber, trig2L_obj2,
1213  trigs1L_obj2, efficiencies[1]);
1214  else
1215  success = success && globalEfficiency(leptons, runNumber, trigs1L_obj2,
1216  efficiencies[1]);
1217  if (trig2Lmix && !trig2Lmix.hiddenBy(trigs1L_obj1)) {
1218  auto t = trig2Lmix.addTo(trigs1L_obj1);
1219  if (trig2L_obj1)
1220  success = success && globalEfficiency(leptons, runNumber, trig2L_obj1, t,
1221  efficiencies[2]);
1222  else
1223  success =
1224  success && globalEfficiency(leptons, runNumber, t, efficiencies[2]);
1225  } else
1226  efficiencies[2] = efficiencies[0];
1227  if (trig2Lmix && !trig2Lmix.hiddenBy(trigs1L_obj2)) {
1228  auto t = trig2Lmix.addTo(trigs1L_obj2);
1229  if (trig2L_obj2)
1230  success = success && globalEfficiency(leptons, runNumber, trig2L_obj2, t,
1231  efficiencies[3]);
1232  else
1233  success =
1234  success && globalEfficiency(leptons, runNumber, t, efficiencies[3]);
1235  } else
1236  efficiencies[3] = efficiencies[1];
1237  globalEfficiencies =
1238  Efficiencies(1.) - ~efficiencies[0] * ~efficiencies[1] +
1239  (efficiencies[2] - efficiencies[0]) * (efficiencies[3] - efficiencies[1]);
1240  return success;
1241 }

◆ globalEfficiency() [8/22]

template<typename Trig2L_obj1 , typename Trig2L_obj2 , typename Trig2Lmix >
auto Calculator::globalEfficiency ( const LeptonList leptons,
unsigned  runNumber,
const Trig2L_obj1  trig2L_obj1,
const Trig2L_obj2  trig2L_obj2,
const Trig2Lmix  trig2Lmix,
Efficiencies globalEfficiencies 
) -> std::enable_if_t<Trig2Lmix::is2Lmix() && Trig2L_obj1::is2Lnomix() && Trig2L_obj1::object() == Trig2Lmix::object1() && Trig2L_obj2::is2Lnomix() && Trig2L_obj2::object() == Trig2Lmix::object2(), bool>
private

Combinaisons with 3 dilepton triggers including one mixed-flavour, and one sym.

/asym. dilepton for each flavour

Definition at line 1126 of file Calculator.cxx.

1136  {
1137  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Three2L() at line "
1138  << __LINE__);
1139  Efficiencies efficiencies2L[2] = {{0.}, {0.}},
1140  efficiencies2Lor1L[2] = {{0.}, {0.}};
1141  bool success = true;
1142  if (trig2L_obj1) {
1143  success = success && globalEfficiency(leptons, runNumber, trig2L_obj1,
1144  efficiencies2L[0]);
1145  if (trig2Lmix)
1146  success =
1147  success && globalEfficiency(leptons, runNumber, trig2L_obj1,
1148  trig2Lmix.template side<Trig2L_obj1>(),
1149  efficiencies2Lor1L[0]);
1150  else
1151  efficiencies2Lor1L[0] = efficiencies2L[0];
1152  } else if (trig2Lmix)
1153  success =
1154  success && globalEfficiency(leptons, runNumber,
1155  trig2Lmix.template side<Trig2L_obj1>(),
1156  efficiencies2Lor1L[0]);
1157  if (trig2L_obj2) {
1158  success = success && globalEfficiency(leptons, runNumber, trig2L_obj2,
1159  efficiencies2L[1]);
1160  if (trig2Lmix)
1161  success =
1162  success && globalEfficiency(leptons, runNumber, trig2L_obj2,
1163  trig2Lmix.template side<Trig2L_obj2>(),
1164  efficiencies2Lor1L[1]);
1165  else
1166  efficiencies2Lor1L[1] = efficiencies2L[1];
1167  } else if (trig2Lmix)
1168  success =
1169  success && globalEfficiency(leptons, runNumber,
1170  trig2Lmix.template side<Trig2L_obj2>(),
1171  efficiencies2Lor1L[1]);
1172  globalEfficiencies = efficiencies2L[0] * ~efficiencies2Lor1L[1] +
1173  efficiencies2L[1] * ~efficiencies2Lor1L[0] +
1174  efficiencies2Lor1L[0] * efficiencies2Lor1L[1];
1175  return success;
1176 }

◆ globalEfficiency() [9/22]

template<typename Trig2L_obj1 , typename Trig2Lsym_obj1 , typename Trig2L_obj2 , typename Trig2Lsym_obj2 , typename Trig2Lmix , typename Trig1L_obj1 , typename Trig1L_obj2 >
auto Calculator::globalEfficiency ( const LeptonList leptons,
unsigned  runNumber,
const Trig2L_obj1  trig2L_obj1,
const Trig2Lsym_obj1  trig2Lsym_obj1,
const Trig2L_obj2  trig2L_obj2,
const Trig2Lsym_obj2  trig2Lsym_obj2,
const Trig2Lmix  trig2Lmix1,
const Trig2Lmix  trig2Lmix2,
const flat_set< Trig1L_obj1 > &  trigs1L_obj1,
const flat_set< Trig1L_obj2 > &  trigs1L_obj2,
Efficiencies globalEfficiencies 
) -> std::enable_if_t< Trig2Lmix::is2Lmix() && Trig2L_obj1::is2Lnomix() && Trig2L_obj1::object() == Trig2Lmix::object1() && Trig2L_obj2::is2Lnomix() && Trig2L_obj2::object() == Trig2Lmix::object2() && Trig2Lsym_obj1::is2Lsym() && Trig2Lsym_obj1::object() == Trig2Lmix::object1() && Trig2Lsym_obj2::is2Lsym() && Trig2Lsym_obj2::object() == Trig2Lmix::object2() && Trig1L_obj1::is1L() && Trig1L_obj1::object() == Trig2Lmix::object1() && Trig1L_obj2::is1L() && Trig1L_obj2::object() == Trig2Lmix::object2(), bool>
private

Six dilepton triggers (two mixed-flavour, two sym., two asym.

/sym.) for two object types

Definition at line 1250 of file Calculator.cxx.

1269  {
1270  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Six2LSeveral1L() at line "
1271  << __LINE__);
1272 
1273  auto singleObjectFactor = [=](auto trig2L, auto trig2Lsym, auto& trigs1L,
1274  Efficiencies(&efficiencies)[4]) -> bool {
1275  auto eval_for = [=](const auto& trigs1L_extended,
1276  Efficiencies& eff) -> bool {
1277  if (trig2L && trig2Lsym)
1278  return this->globalEfficiency(leptons, runNumber, trig2L, trig2Lsym,
1279  trigs1L_extended, eff);
1280  else if (trig2L)
1281  return this->globalEfficiency(leptons, runNumber, trig2L,
1282  trigs1L_extended, eff);
1283  else if (trig2Lsym)
1284  return this->globalEfficiency(leptons, runNumber, trig2Lsym,
1285  trigs1L_extended, eff);
1286  else
1287  return this->globalEfficiency(leptons, runNumber, trigs1L_extended,
1288  eff);
1289  };
1290 
1291  bool success = eval_for(trigs1L, efficiencies[0]);
1292  if (trig2Lmix1)
1293  success = success && eval_for(trig2Lmix1.addTo(trigs1L), efficiencies[1]);
1294  else
1295  efficiencies[1] = efficiencies[0];
1296  if (trig2Lmix2) {
1297  auto t = trig2Lmix2.addTo(trigs1L);
1298  success = success && eval_for(t, efficiencies[2]);
1299  if (trig2Lmix1)
1300  success&& eval_for(trig2Lmix1.addTo(t), efficiencies[3]);
1301  else
1302  efficiencies[3] = efficiencies[2];
1303  } else {
1304  efficiencies[2] = efficiencies[0];
1305  efficiencies[3] = efficiencies[1];
1306  }
1307  return success;
1308  };
1309 
1310  Efficiencies efficiencies1[4], efficiencies2[4];
1311  bool success = singleObjectFactor(trig2L_obj1, trig2Lsym_obj1, trigs1L_obj1,
1312  efficiencies1) &&
1313  singleObjectFactor(trig2L_obj2, trig2Lsym_obj2, trigs1L_obj2,
1314  efficiencies2);
1315  globalEfficiencies = Efficiencies(1.) -
1316  ~efficiencies1[0] * ~efficiencies2[0] +
1317  (efficiencies1[1] - efficiencies1[0]) *
1318  (efficiencies2[1] - efficiencies2[0]) +
1319  (efficiencies1[2] - efficiencies1[0]) *
1320  (efficiencies2[2] - efficiencies2[0]) -
1321  (efficiencies1[0] - efficiencies1[1] - efficiencies1[2] +
1322  efficiencies1[3]) *
1323  (efficiencies2[0] - efficiencies2[1] -
1324  efficiencies2[2] + efficiencies2[3]);
1325  return success;
1326 }

◆ globalEfficiency() [10/22]

template<typename Trig2Lasym , typename Trig1L >
auto Calculator::globalEfficiency ( const LeptonList leptons,
unsigned  runNumber,
const Trig2Lasym  trig2L,
const flat_set< Trig1L > &  trigs1L,
Efficiencies globalEfficiencies 
) -> std::enable_if_t<Trig2Lasym::is2Lasym() && Trig1L::is1L() && Trig1L::object() == Trig2Lasym::object(), bool>
private

One asymmetric dilepton trigger + several single-lepton triggers.

S1 v S3

S2 v S3

Definition at line 664 of file Calculator.cxx.

670  {
671  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One2LSeveral1L() at line "
672  << __LINE__);
673  if (trig2L.symmetric())
674  return globalEfficiency(leptons, runNumber, trig2L.to_symmetric(), trigs1L,
675  globalEfficiencies);
676  if (!trigs1L.size())
677  return globalEfficiency(leptons, runNumber, trig2L, globalEfficiencies);
678  if (!trig2L || trig2L.hiddenBy(trigs1L))
679  return globalEfficiency(leptons, runNumber, trigs1L, globalEfficiencies);
680  globalEfficiencies = {0.};
681  Efficiencies twoSingleInefficiencies[2] = {{1.}, {1.}},
682  threeSingleInefficiencies = {1.};
683  bool success = true;
684  for (auto& lepton : leptons) {
685  if (trig2L.irrelevantFor(lepton))
686  continue;
687  flat_set<std::size_t> validLegs;
688  for (std::size_t leg : trig2L.legs)
689  if (aboveThreshold(lepton, leg))
690  validLegs.insert(leg);
691  Efficiencies efficiencies1L = {0.};
692  std::size_t loosest1lepLeg =
693  getLoosestLegAboveThreshold(lepton, trigs1L, success);
694  if (loosest1lepLeg) {
695  efficiencies1L = getCachedTriggerLegEfficiencies(lepton, runNumber,
696  loosest1lepLeg, success);
697  validLegs.insert(loosest1lepLeg);
698  }
699  if (!validLegs.size())
700  continue;
701  auto looseLegs = m_parent->getTwoLoosestLegs(lepton, validLegs, success);
702  auto efficienciesLoose =
703  (looseLegs.first == loosest1lepLeg)
704  ? efficiencies1L
706  looseLegs.first, success);
707  Efficiencies efficienciesMedium = {0.};
708  if (validLegs.size() >= 2)
709  efficienciesMedium =
710  (looseLegs.second == loosest1lepLeg)
711  ? efficiencies1L
713  looseLegs.second, success);
714  globalEfficiencies =
715  ~efficienciesLoose * globalEfficiencies + efficiencies1L;
716  if (loosest1lepLeg != looseLegs.first) {
717  globalEfficiencies +=
718  (efficienciesLoose - efficienciesMedium) *
719  ~twoSingleInefficiencies[looseLegs.first == trig2L.legs[0]];
720  if (loosest1lepLeg != looseLegs.second)
721  globalEfficiencies +=
722  (efficienciesMedium - efficiencies1L) * ~threeSingleInefficiencies;
723  }
724  threeSingleInefficiencies *= ~efficienciesLoose;
725  twoSingleInefficiencies[0] *= (looseLegs.first != trig2L.legs[1])
726  ? ~efficienciesLoose
727  : ~efficienciesMedium;
728  twoSingleInefficiencies[1] *= (looseLegs.first != trig2L.legs[0])
729  ? ~efficienciesLoose
730  : ~efficienciesMedium;
731  }
732  return success;
733 }

◆ globalEfficiency() [11/22]

template<typename Trig2Lasym , typename Trig2Lsym , typename Trig1L >
auto Calculator::globalEfficiency ( const LeptonList leptons,
unsigned  runNumber,
const Trig2Lasym  trig2Lasym,
const Trig2Lsym  trig2Lsym,
const flat_set< Trig1L > &  trigs1L,
Efficiencies globalEfficiencies 
) -> std::enable_if_t<Trig2Lasym::is2Lasym() && Trig2Lsym::is2Lsym() && Trig2Lsym::object() == Trig2Lasym::object() && Trig1L::is1L() && Trig1L::object() == Trig2Lasym::object(), bool>
private

Two dilepton triggers (one asym., one sym.) + several single-lepton triggers.

can't use tightestLeg==trig2Lsym because it might also be 0

this works because loosest1lepLeg is 0 if not on plateau...

note: secondLoosestLeg is valid because the loosest leg is either trig2Lasym(0) or trig2Lasym(1)

Definition at line 819 of file Calculator.cxx.

828  {
829  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Two2LSeveral1L() at line "
830  << __LINE__);
831  if (!trig2Lasym || trig2Lasym.hiddenBy(trigs1L))
832  return globalEfficiency(leptons, runNumber, trig2Lsym, trigs1L,
833  globalEfficiencies);
834  if (!trig2Lsym || trig2Lsym.hiddenBy(trigs1L))
835  return globalEfficiency(leptons, runNumber, trig2Lasym, trigs1L,
836  globalEfficiencies);
837  if (trig2Lasym(0) == trig2Lsym() || trig2Lasym(1) == trig2Lsym()) {
839  "implementation -- does this function work properly when the two 2L "
840  "triggers have one leg in common? Must be checked");
841  return false;
842  }
843  if (trig2Lasym.symmetric())
844  return globalEfficiency(leptons, runNumber, trig2Lasym.to_symmetric(),
845  trig2Lsym, trigs1L, globalEfficiencies);
846  globalEfficiencies = {0.};
847  Efficiencies singleInefficiencies[3] = {{1.}, {1.}, {1.}};
848  Efficiencies efficiencies2Lasym{0.},
849  efficiencies2Lsym[3] = {{0.}, {0.}, {0.}};
850 
851  bool success = true;
852  for (auto& lepton : leptons) {
853  if (trig2Lasym.irrelevantFor(lepton))
854  continue;
855  flat_set<std::size_t> validLegs;
856  std::map<std::size_t, Efficiencies> efficiencies{{0, 0.}};
857  std::size_t loosest1lepLeg =
858  getLoosestLegAboveThreshold(lepton, trigs1L, success);
859  for (std::size_t leg :
860  {trig2Lasym(0), trig2Lasym(1), trig2Lsym(), loosest1lepLeg}) {
861  if (leg && aboveThreshold(lepton, leg)) {
862  validLegs.insert(leg);
864  lepton, runNumber, leg, success));
865  } else
866  efficiencies.emplace(leg, 0.);
867  }
868  if (!validLegs.size())
869  continue;
870 
871  const auto sortedLegs = m_parent->getSortedLegs(lepton, validLegs, success);
872  if (!success)
873  return false;
874  std::size_t loosestLeg = sortedLegs[0];
875  std::size_t secondLoosestLeg = validLegs.size() >= 2 ? sortedLegs[1] : 0;
876  std::size_t secondTightestLeg = validLegs.size() >= 3 ? sortedLegs[2] : 0;
877  std::size_t tightestLeg = validLegs.size() >= 4 ? sortedLegs[3] : 0;
878  std::size_t lambda124 =
879  (loosestLeg != trig2Lasym(1)) ? loosestLeg : secondLoosestLeg;
880  std::size_t lambda134 =
881  (loosestLeg != trig2Lasym(0)) ? loosestLeg : secondLoosestLeg;
882  std::size_t lambda234 =
883  (loosestLeg != trig2Lsym()) ? loosestLeg : secondLoosestLeg;
884  std::size_t lambda14 = (lambda124 != trig2Lasym(0)) ? lambda124
885  : (lambda134 != trig2Lasym(1)) ? lambda134
886  : secondTightestLeg;
887  std::size_t lambda24 = (lambda124 != trig2Lsym()) ? lambda124
888  : (lambda234 != trig2Lasym(1)) ? lambda234
889  : secondTightestLeg;
890  std::size_t lambda34 = (lambda134 != trig2Lsym()) ? lambda134
891  : (lambda234 != trig2Lasym(0)) ? lambda234
892  : secondTightestLeg;
893  std::size_t tau13 = 0, tau12 = 0, tau23 = 0;
894  if (loosestLeg == trig2Lsym() || loosestLeg == trig2Lasym(0))
895  tau12 = (loosestLeg == trig2Lsym()) ? trig2Lasym(0) : trig2Lsym();
896  else if (secondLoosestLeg == trig2Lsym() ||
897  secondLoosestLeg == trig2Lasym(0))
898  tau12 = (secondLoosestLeg == trig2Lsym()) ? trig2Lasym(0) : trig2Lsym();
899  else if (secondTightestLeg == trig2Lsym() ||
900  secondTightestLeg == trig2Lasym(0))
901  tau12 = (secondTightestLeg == trig2Lsym()) ? trig2Lasym(0) : trig2Lsym();
902  else if (tightestLeg == trig2Lsym() || tightestLeg == trig2Lasym(0))
903  tau12 = (tightestLeg == trig2Lsym()) ? trig2Lasym(0) : trig2Lsym();
904  if (loosestLeg == trig2Lsym() || loosestLeg == trig2Lasym(1))
905  tau13 = (loosestLeg == trig2Lsym()) ? trig2Lasym(1) : trig2Lsym();
906  else if (secondLoosestLeg == trig2Lsym() ||
907  secondLoosestLeg == trig2Lasym(1))
908  tau13 = (secondLoosestLeg == trig2Lsym()) ? trig2Lasym(1) : trig2Lsym();
909  else if (secondTightestLeg == trig2Lsym() ||
910  secondTightestLeg == trig2Lasym(1))
911  tau13 = (secondTightestLeg == trig2Lsym()) ? trig2Lasym(1) : trig2Lsym();
912  else if (tightestLeg == trig2Lsym() || tightestLeg == trig2Lasym(1))
913  tau13 = (tightestLeg == trig2Lsym()) ? trig2Lasym(1) : trig2Lsym();
914  if (loosestLeg == trig2Lasym(0) || loosestLeg == trig2Lasym(1))
915  tau23 = (loosestLeg == trig2Lasym(0)) ? trig2Lasym(1) : trig2Lasym(0);
916  else if (secondLoosestLeg == trig2Lasym(0) ||
917  secondLoosestLeg == trig2Lasym(1))
918  tau23 =
919  (secondLoosestLeg == trig2Lasym(0)) ? trig2Lasym(1) : trig2Lasym(0);
920  else if (secondTightestLeg == trig2Lasym(0) ||
921  secondTightestLeg == trig2Lasym(1))
922  tau23 =
923  (secondTightestLeg == trig2Lasym(0)) ? trig2Lasym(1) : trig2Lasym(0);
924  else if (tightestLeg == trig2Lasym(0) || tightestLeg == trig2Lasym(1))
925  tau23 = (tightestLeg == trig2Lasym(0)) ? trig2Lasym(1) : trig2Lasym(0);
926 
928  globalEfficiencies =
929  globalEfficiencies * ~efficiencies[loosestLeg] +
930  efficiencies[loosest1lepLeg] +
931  (efficiencies[tau13] - efficiencies[secondTightestLeg]) *
932  ~singleInefficiencies[0] +
933  (efficiencies[tau12] - efficiencies[secondTightestLeg]) *
934  ~singleInefficiencies[1] +
935  (efficiencies[tau23] - efficiencies[secondTightestLeg]) *
936  efficiencies2Lsym[2];
937  if (loosestLeg == trig2Lsym())
938  globalEfficiencies +=
939  (efficiencies[trig2Lsym()] - efficiencies[secondLoosestLeg]) *
940  efficiencies2Lasym;
941  else if (loosestLeg == trig2Lasym(1))
942  globalEfficiencies +=
943  (efficiencies[trig2Lasym(1)] - efficiencies[secondLoosestLeg]) *
944  efficiencies2Lsym[0];
945  else if (loosestLeg == trig2Lasym(0))
946  globalEfficiencies +=
947  (efficiencies[trig2Lasym(0)] - efficiencies[secondLoosestLeg]) *
948  efficiencies2Lsym[1];
949  if (secondTightestLeg &&
950  tightestLeg == loosest1lepLeg)
951  globalEfficiencies +=
953  (efficiencies[secondTightestLeg] - efficiencies[tightestLeg]) *
954  ~singleInefficiencies[2];
955 
956  efficiencies2Lasym =
957  ~efficiencies[loosestLeg] * efficiencies2Lasym + efficiencies[lambda14];
958  if (loosestLeg == trig2Lasym(0) || loosestLeg == trig2Lasym(1)) {
961  efficiencies2Lasym +=
962  (efficiencies[loosestLeg] - efficiencies[secondLoosestLeg]) *
963  ~singleInefficiencies[loosestLeg == trig2Lasym(0)] +
964  (efficiencies[secondLoosestLeg] - efficiencies[lambda14]) *
965  ~singleInefficiencies[2];
966  }
967  efficiencies2Lsym[0] = ~efficiencies[lambda124] * efficiencies2Lsym[0] +
968  efficiencies[lambda24];
969  efficiencies2Lsym[1] = ~efficiencies[lambda134] * efficiencies2Lsym[1] +
970  efficiencies[lambda34];
971  efficiencies2Lsym[2] = ~efficiencies[loosestLeg] * efficiencies2Lsym[2] +
972  efficiencies[lambda234];
973  if (lambda124 == trig2Lsym())
974  efficiencies2Lsym[0] +=
975  (efficiencies[trig2Lsym()] - efficiencies[lambda24]) *
976  ~singleInefficiencies[0];
977  if (lambda134 == trig2Lsym())
978  efficiencies2Lsym[1] +=
979  (efficiencies[trig2Lsym()] - efficiencies[lambda34]) *
980  ~singleInefficiencies[1];
981  if (loosestLeg == trig2Lsym())
982  efficiencies2Lsym[2] +=
983  (efficiencies[trig2Lsym()] - efficiencies[lambda234]) *
984  ~singleInefficiencies[2];
985  singleInefficiencies[0] *= ~efficiencies[lambda124];
986  singleInefficiencies[1] *= ~efficiencies[lambda134];
987  singleInefficiencies[2] *= ~efficiencies[loosestLeg];
988  }
989  return success;
990 }

◆ globalEfficiency() [12/22]

template<typename Trig2Lasym >
auto Calculator::globalEfficiency ( const LeptonList leptons,
unsigned  runNumber,
const Trig2Lasym  trig,
Efficiencies globalEfficiencies 
) -> std::enable_if_t<Trig2Lasym::is2Lasym(), bool>
private

One asymmetric dilepton trigger.

Definition at line 500 of file Calculator.cxx.

503  {
504  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One2L() at line "
505  << __LINE__);
506  if (trig.symmetric())
507  return globalEfficiency(leptons, runNumber, trig.to_symmetric(),
508  globalEfficiencies);
509  globalEfficiencies = {0.};
510  if (!trig)
511  return true;
512  Efficiencies singleInefficiencies[2] = {{1.}, {1.}},
513  twoSingleInefficiencies = {1.};
514  bool success = true;
515  for (auto& lepton : leptons) {
516  if (trig.irrelevantFor(lepton))
517  continue;
518  Efficiencies efficiencies[2] = {{0.}, {0.}};
519  int loosest = 0;
520  if (aboveThreshold(lepton, trig(0))) {
521  efficiencies[0] =
522  getCachedTriggerLegEfficiencies(lepton, runNumber, trig(0), success);
523  if (aboveThreshold(lepton, trig(1))) {
525  trig(1), success);
526  loosest = m_parent->getLoosestLeg(lepton, trig(0), trig(1), success) ==
527  trig(1);
528  }
529  } else if (aboveThreshold(lepton, trig(1))) {
530  efficiencies[1] =
531  getCachedTriggerLegEfficiencies(lepton, runNumber, trig(1), success);
532  loosest = 1;
533  } else
534  continue;
535  const int tightest = 1 - loosest;
536  globalEfficiencies = ~efficiencies[loosest] * globalEfficiencies +
537  (efficiencies[loosest] - efficiencies[tightest]) *
538  ~singleInefficiencies[tightest] +
539  efficiencies[tightest] * ~twoSingleInefficiencies;
540  twoSingleInefficiencies *= ~efficiencies[loosest];
541  for (int i = 0; i < 2; ++i)
542  singleInefficiencies[i] *= ~efficiencies[i];
543  }
544  return success;
545 }

◆ globalEfficiency() [13/22]

template<typename Trig2Lmix , typename Trig1L_obj1 , typename Trig1L_obj2 >
auto Calculator::globalEfficiency ( const LeptonList leptons,
unsigned  runNumber,
const Trig2Lmix  trig2Lmix,
const flat_set< Trig1L_obj1 > &  trigs1L1,
const flat_set< Trig1L_obj2 > &  trigs1L2,
Efficiencies globalEfficiencies 
) -> std::enable_if_t<Trig2Lmix::is2Lmix() && Trig1L_obj1::is1L() && Trig2Lmix::object1() == Trig1L_obj1::object() && Trig1L_obj2::is1L() && Trig2Lmix::object2() == Trig1L_obj2::object(), bool>
private

One mixed-flavour dilepton trigger + single-lepton triggers.

Definition at line 551 of file Calculator.cxx.

560  {
561  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One2LSeveral1L() at line "
562  << __LINE__);
563  if (!(trigs1L1.size() + trigs1L2.size()))
564  return globalEfficiency(leptons, runNumber, trig2Lmix, globalEfficiencies);
565  if (trig2Lmix.hiddenBy(trigs1L1) || trig2Lmix.hiddenBy(trigs1L2))
566  return globalEfficiency(leptons, runNumber, trigs1L1, trigs1L2,
567  globalEfficiencies);
569  bool success =
570  globalEfficiency(leptons, runNumber, trigs1L1, efficiencies[0]) &&
571  globalEfficiency(leptons, runNumber, trigs1L2, efficiencies[1]) &&
572  globalEfficiency(leptons, runNumber, trig2Lmix.addTo(trigs1L1),
573  efficiencies[2]) &&
574  globalEfficiency(leptons, runNumber, trig2Lmix.addTo(trigs1L2),
575  efficiencies[3]);
576  if (success) {
577  globalEfficiencies = Efficiencies(1.) -
578  ~efficiencies[0] * ~efficiencies[1] +
579  (efficiencies[2] - efficiencies[0]) *
580  (efficiencies[3] - efficiencies[1]);
581  } else
582  globalEfficiencies = {0.};
583  return success;
584 }

◆ globalEfficiency() [14/22]

template<typename Trig2Lmix >
auto Calculator::globalEfficiency ( const LeptonList leptons,
unsigned  runNumber,
const Trig2Lmix  trig,
Efficiencies globalEfficiencies 
) -> std::enable_if_t<Trig2Lmix::is2Lmix(), bool>
private

One mixed-flavour dilepton trigger.

Definition at line 452 of file Calculator.cxx.

455  {
456  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One2L() at line "
457  << __LINE__);
459  bool success =
460  globalEfficiency(leptons, runNumber, trig.side1(), efficiencies[0]) &&
461  globalEfficiency(leptons, runNumber, trig.side2(), efficiencies[1]);
462  if (success)
463  globalEfficiencies = efficiencies[0] * efficiencies[1];
464  else
465  globalEfficiencies = {0.};
466  return success;
467 }

◆ globalEfficiency() [15/22]

template<typename Trig2Lsym , typename Trig1L >
auto Calculator::globalEfficiency ( const LeptonList leptons,
unsigned  runNumber,
const Trig2Lsym  trig2L,
const flat_set< Trig1L > &  trigs1L,
Efficiencies globalEfficiencies 
) -> std::enable_if_t<Trig2Lsym::is2Lsym() && Trig1L::is1L() && Trig1L::object() == Trig2Lsym::object(), bool>
private

One symmetric dilepton trigger + several single-lepton triggers.

Definition at line 608 of file Calculator.cxx.

614  {
615  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One2LSeveral1L() at line "
616  << __LINE__);
617  if (!trigs1L.size())
618  return globalEfficiency(leptons, runNumber, trig2L, globalEfficiencies);
619  if (!trig2L || trig2L.hiddenBy(trigs1L))
620  return globalEfficiency(leptons, runNumber, trigs1L, globalEfficiencies);
621  globalEfficiencies = {0.};
622  Efficiencies twoSingleInefficiencies = {1.};
623  bool success = true;
624  for (auto& lepton : leptons) {
625  if (trig2L.irrelevantFor(lepton))
626  continue;
627  Efficiencies efficiencies1L(0.), efficiencies2L(0.);
628  const Efficiencies* loosestLegEfficiency;
629  std::size_t loosest1lepLeg =
630  getLoosestLegAboveThreshold(lepton, trigs1L, success);
631  if (loosest1lepLeg) {
632  efficiencies1L = getCachedTriggerLegEfficiencies(lepton, runNumber,
633  loosest1lepLeg, success);
634  if (aboveThreshold(lepton, trig2L())) {
635  efficiencies2L = getCachedTriggerLegEfficiencies(lepton, runNumber,
636  trig2L(), success);
637  loosestLegEfficiency =
638  (m_parent->getLoosestLeg(lepton, trig2L(), loosest1lepLeg,
639  success) == trig2L())
640  ? &efficiencies2L
641  : &efficiencies1L;
642  } else
643  loosestLegEfficiency = &efficiencies1L;
644  } else if (aboveThreshold(lepton, trig2L())) {
645  efficiencies2L =
646  getCachedTriggerLegEfficiencies(lepton, runNumber, trig2L(), success);
647  loosestLegEfficiency = &efficiencies2L;
648  } else
649  continue;
650  globalEfficiencies =
651  ~(*loosestLegEfficiency) * globalEfficiencies + efficiencies1L;
652  if (loosestLegEfficiency == &efficiencies2L)
653  globalEfficiencies +=
654  ~twoSingleInefficiencies * (efficiencies2L - efficiencies1L);
655  twoSingleInefficiencies *= ~(*loosestLegEfficiency);
656  }
657  return success;
658 }

◆ globalEfficiency() [16/22]

template<typename Trig2Lsym , typename Trig1L >
auto Calculator::globalEfficiency ( const LeptonList leptons,
unsigned  runNumber,
const Trig2Lsym  trig2L1,
const Trig2Lsym  trig2L2,
const flat_set< Trig1L > &  trigs1L,
Efficiencies globalEfficiencies 
) -> std::enable_if_t<Trig2Lsym::is2Lsym() && Trig1L::is1L() && Trig1L::object() == Trig2Lsym::object(), bool>
private

Two symmetric dilepton triggers + several single-lepton triggers.

Definition at line 739 of file Calculator.cxx.

746  {
747  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Two2LSeveral1L() at line "
748  << __LINE__);
749  if (!trig2L1 || trig2L1 == trig2L2 || trig2L1.hiddenBy(trigs1L))
750  return globalEfficiency(leptons, runNumber, trig2L2, trigs1L,
751  globalEfficiencies);
752  if (!trig2L2 || trig2L2.hiddenBy(trigs1L))
753  return globalEfficiency(leptons, runNumber, trig2L1, trigs1L,
754  globalEfficiencies);
755  globalEfficiencies = {0.};
756  Efficiencies singleInefficiencies{1.};
757  Efficiencies efficiencies2Lsym[2] = {{0.}, {0.}};
758 
759  bool success = true;
760  for (auto& lepton : leptons) {
761  if (trig2L1.irrelevantFor(lepton))
762  continue;
763  flat_set<std::size_t> validLegs;
764  std::map<std::size_t, Efficiencies> efficiencies{{0, 0.}};
765  std::size_t loosest1lepLeg =
766  getLoosestLegAboveThreshold(lepton, trigs1L, success);
767  for (std::size_t leg : {loosest1lepLeg, trig2L1(), trig2L2()}) {
768  if (leg && aboveThreshold(lepton, leg)) {
769  validLegs.insert(leg);
771  lepton, runNumber, leg, success));
772  } else
773  efficiencies.emplace(leg, 0.);
774  }
775  if (!validLegs.size())
776  continue;
777  auto looseLegs = m_parent->getTwoLoosestLegs(lepton, validLegs, success);
778  std::size_t lambda13 =
779  (looseLegs.first != trig2L2()) ? looseLegs.first : looseLegs.second;
780  std::size_t lambda23 =
781  (looseLegs.first != trig2L1()) ? looseLegs.first : looseLegs.second;
782  globalEfficiencies = globalEfficiencies * ~efficiencies[looseLegs.first] +
783  efficiencies[loosest1lepLeg];
784  if (looseLegs.first == trig2L1())
785  globalEfficiencies +=
786  efficiencies2Lsym[1] *
787  (efficiencies[trig2L1()] - efficiencies[looseLegs.second]);
788  if (looseLegs.first == trig2L2())
789  globalEfficiencies +=
790  efficiencies2Lsym[0] *
791  (efficiencies[trig2L2()] - efficiencies[looseLegs.second]);
792  if (looseLegs.first != loosest1lepLeg)
793  globalEfficiencies +=
794  ~singleInefficiencies *
795  (efficiencies[looseLegs.second] - efficiencies[loosest1lepLeg]);
796  efficiencies2Lsym[0] =
797  ~efficiencies[looseLegs.first] * efficiencies2Lsym[0] +
798  efficiencies[lambda23];
799  efficiencies2Lsym[1] =
800  ~efficiencies[looseLegs.first] * efficiencies2Lsym[1] +
801  efficiencies[lambda13];
802  if (looseLegs.first == trig2L1())
803  efficiencies2Lsym[0] +=
804  (efficiencies[trig2L1()] - efficiencies[lambda23]) *
805  ~singleInefficiencies;
806  if (looseLegs.first == trig2L2())
807  efficiencies2Lsym[1] +=
808  (efficiencies[trig2L2()] - efficiencies[lambda13]) *
809  ~singleInefficiencies;
810  singleInefficiencies *= ~efficiencies[looseLegs.first];
811  }
812  return success;
813 }

◆ globalEfficiency() [17/22]

template<typename Trig2Lsym >
auto Calculator::globalEfficiency ( const LeptonList leptons,
unsigned  runNumber,
const Trig2Lsym  trig,
Efficiencies globalEfficiencies 
) -> std::enable_if_t<Trig2Lsym::is2Lsym(), bool>
private

One symmetric dilepton trigger.

Definition at line 473 of file Calculator.cxx.

476  {
477  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One2L() at line "
478  << __LINE__);
479  globalEfficiencies = {0.};
480  if (!trig)
481  return true;
482  Efficiencies singleInefficiencies(1.);
483  bool success = true;
484  for (auto& lepton : leptons) {
485  if (trig.irrelevantFor(lepton) || !aboveThreshold(lepton, trig()))
486  continue;
487  auto efficiencies =
488  getCachedTriggerLegEfficiencies(lepton, runNumber, trig(), success);
489  globalEfficiencies = ~efficiencies * globalEfficiencies +
490  efficiencies * ~singleInefficiencies;
491  singleInefficiencies *= ~efficiencies;
492  }
493  return success;
494 }

◆ globalEfficiency() [18/22]

template<typename Trig3Lhalfsym >
auto Calculator::globalEfficiency ( const LeptonList leptons,
unsigned  runNumber,
const Trig3Lhalfsym  trig,
Efficiencies globalEfficiencies 
) -> std::enable_if_t<Trig3Lhalfsym::is3Lhalfsym(), bool>
private

One half-symmetric trilepton trigger.

Definition at line 1023 of file Calculator.cxx.

1026  {
1027  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One3L() at line "
1028  << __LINE__);
1029  if (trig.symmetric())
1030  return globalEfficiency(leptons, runNumber, trig.to_symmetric(),
1031  globalEfficiencies);
1032  globalEfficiencies = {0.};
1033  Efficiencies singleInefficiencies[2] = {{1.}, {1.}},
1034  twoSingleInefficiencies{1.};
1035  Efficiencies efficiencies2Lsym{0.}, efficiencies2Lasym{0.},
1036  efficiencies2L2L{0.};
1037  bool success = true;
1038  for (auto& lepton : leptons) {
1039  if (trig.irrelevantFor(lepton))
1040  continue;
1041  Efficiencies efficiencies[2] = {{0.}, {0.}};
1042  const int asym = 0, sym = 1;
1043  int loosestLeg;
1044  if (aboveThreshold(lepton, trig.asymLeg())) {
1046  lepton, runNumber, trig.asymLeg(), success);
1047  if (aboveThreshold(lepton, trig.symLeg())) {
1049  lepton, runNumber, trig.symLeg(), success);
1050  loosestLeg =
1051  m_parent->getLoosestLeg(lepton, trig.asymLeg(), trig.symLeg(),
1052  success) == trig.asymLeg()
1053  ? asym
1054  : sym;
1055  } else
1056  loosestLeg = asym;
1057  } else if (aboveThreshold(lepton, trig.symLeg())) {
1059  lepton, runNumber, trig.symLeg(), success);
1060  loosestLeg = sym;
1061  } else
1062  continue;
1063  Efficiencies delta = efficiencies[asym] - efficiencies[sym];
1064  if (loosestLeg == asym) {
1065  globalEfficiencies = ~efficiencies[asym] * globalEfficiencies +
1066  efficiencies[sym] * efficiencies2L2L +
1067  delta * efficiencies2Lsym;
1068  efficiencies2L2L = ~efficiencies[asym] * efficiencies2L2L +
1069  efficiencies[sym] * ~twoSingleInefficiencies +
1070  delta * ~singleInefficiencies[sym];
1071  efficiencies2Lasym = ~efficiencies[asym] * efficiencies2Lasym +
1072  efficiencies[sym] * ~twoSingleInefficiencies +
1073  delta * ~singleInefficiencies[sym];
1074  } else {
1075  globalEfficiencies = ~efficiencies[sym] * globalEfficiencies +
1076  efficiencies[asym] * efficiencies2L2L -
1077  delta * efficiencies2Lasym;
1078  efficiencies2L2L = ~efficiencies[sym] * efficiencies2L2L +
1079  efficiencies[sym] * ~twoSingleInefficiencies;
1080  efficiencies2Lasym = ~efficiencies[sym] * efficiencies2Lasym +
1081  efficiencies[asym] * ~twoSingleInefficiencies -
1082  delta * ~singleInefficiencies[asym];
1083  }
1084  efficiencies2Lsym = ~efficiencies[sym] * efficiencies2Lsym +
1085  efficiencies[sym] * ~singleInefficiencies[sym];
1086  twoSingleInefficiencies *= ~efficiencies[loosestLeg];
1087  singleInefficiencies[sym] *= ~efficiencies[sym];
1088  singleInefficiencies[asym] *= ~efficiencies[asym];
1089  }
1090  return success;
1091 }

◆ globalEfficiency() [19/22]

template<typename Trig3Lmix >
auto Calculator::globalEfficiency ( const LeptonList leptons,
unsigned  runNumber,
const Trig3Lmix  trig,
Efficiencies globalEfficiencies 
) -> std::enable_if_t<Trig3Lmix::is3Lmix(), bool>
private

One mixed-flavour trilepton trigger.

Definition at line 1332 of file Calculator.cxx.

1335  {
1336  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One3L() at line "
1337  << __LINE__);
1338  Efficiencies efficiencies[2] = {{0.}, {0.}};
1339  bool success = globalEfficiency(leptons, runNumber,
1340  trig.template side<Trig3Lmix::object1()>(),
1341  efficiencies[0]) &&
1342  globalEfficiency(leptons, runNumber,
1343  trig.template side<Trig3Lmix::object2()>(),
1344  efficiencies[1]);
1345  globalEfficiencies = efficiencies[0] * efficiencies[1];
1346  return success;
1347 }

◆ globalEfficiency() [20/22]

template<typename Trig3Lmix1 , typename Trig3Lmix2 >
auto Calculator::globalEfficiency ( const LeptonList leptons,
unsigned  runNumber,
const Trig3Lmix1  trig1,
const Trig3Lmix2  trig2,
Efficiencies globalEfficiencies 
) -> std::enable_if_t<Trig3Lmix1::is3Lmix() && Trig3Lmix2::is3Lmix() && Trig3Lmix1::object1() == Trig3Lmix2::object2() && Trig3Lmix1::object2() == Trig3Lmix2::object1(), bool>
private

Two complementary mixed-flavour trilepton triggers.

Definition at line 1353 of file Calculator.cxx.

1360  {
1361  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Two3L() at line "
1362  << __LINE__);
1363  Efficiencies efficiencies[6] = {{0.}, {0.}, {0.}, {0.}, {0.}, {0.}};
1364  auto trig2La = trig1.template side<Trig3Lmix1::object1()>();
1365  auto trig1La = trig2.template side<Trig3Lmix2::object2()>();
1366  bool success =
1367  globalEfficiency(leptons, runNumber, trig1La, efficiencies[0]) &&
1368  globalEfficiency(leptons, runNumber, trig2La, efficiencies[1]);
1369  if (!trig2La.hiddenBy(trig1La))
1370  success = success && globalEfficiency(leptons, runNumber, trig2La, trig1La,
1371  efficiencies[2]);
1372  else
1373  efficiencies[2] = efficiencies[0];
1374  auto trig2Lb = trig2.template side<Trig3Lmix2::object1()>();
1375  auto trig1Lb = trig1.template side<Trig3Lmix1::object2()>();
1376  success = success &&
1377  globalEfficiency(leptons, runNumber, trig1Lb, efficiencies[3]) &&
1378  globalEfficiency(leptons, runNumber, trig2Lb, efficiencies[4]);
1379  if (!trig2Lb.hiddenBy(trig1Lb))
1380  success = success && globalEfficiency(leptons, runNumber, trig2Lb, trig1Lb,
1381  efficiencies[5]);
1382  else
1383  efficiencies[5] = efficiencies[3];
1384  globalEfficiencies =
1386  (efficiencies[2] - efficiencies[0] - efficiencies[1]) *
1387  (efficiencies[3] + efficiencies[4] - efficiencies[5]);
1388  return success;
1389 }

◆ globalEfficiency() [21/22]

template<typename Trig3Lsym >
auto Calculator::globalEfficiency ( const LeptonList leptons,
unsigned  runNumber,
const Trig3Lsym  trig,
Efficiencies globalEfficiencies 
) -> std::enable_if_t<Trig3Lsym::is3Lsym(), bool>
private

One symmetric trilepton trigger.

Definition at line 996 of file Calculator.cxx.

999  {
1000  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One3L() at line "
1001  << __LINE__);
1002  globalEfficiencies = {0.};
1003  Efficiencies singleInefficiencies{1.}, efficiencies2L{0.};
1004  bool success = true;
1005  for (auto& lepton : leptons) {
1006  if (trig.irrelevantFor(lepton) || !aboveThreshold(lepton, trig()))
1007  continue;
1008  auto efficiencies =
1009  getCachedTriggerLegEfficiencies(lepton, runNumber, trig(), success);
1010  globalEfficiencies =
1011  ~efficiencies * globalEfficiencies + efficiencies * efficiencies2L;
1012  efficiencies2L =
1013  ~efficiencies * efficiencies2L + efficiencies * ~singleInefficiencies;
1014  singleInefficiencies *= ~efficiencies;
1015  }
1016  return success;
1017 }

◆ globalEfficiency() [22/22]

template<typename Trig4Lsym >
auto Calculator::globalEfficiency ( const LeptonList leptons,
unsigned  runNumber,
const Trig4Lsym  trig,
Efficiencies globalEfficiencies 
) -> std::enable_if_t<Trig4Lsym::is4Lsym(), bool>
private

One symmetric tetralepton trigger.

Definition at line 1395 of file Calculator.cxx.

1398  {
1399  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One4L() at line "
1400  << __LINE__);
1401  globalEfficiencies = {0.};
1402  Efficiencies singleInefficiencies{1.}, efficiencies2L{0.}, efficiencies3L{0.};
1403  bool success = true;
1404  for (auto& lepton : leptons) {
1405  if (trig.irrelevantFor(lepton) || !aboveThreshold(lepton, trig()))
1406  continue;
1407  auto efficiencies =
1408  getCachedTriggerLegEfficiencies(lepton, runNumber, trig(), success);
1409  globalEfficiencies =
1410  ~efficiencies * globalEfficiencies + efficiencies * efficiencies3L;
1411  efficiencies3L =
1412  ~efficiencies * efficiencies3L + efficiencies * efficiencies2L;
1413  efficiencies2L =
1414  ~efficiencies * efficiencies2L + efficiencies * ~singleInefficiencies;
1415  singleInefficiencies *= ~efficiencies;
1416  }
1417  return success;
1418 }

◆ globalEfficiency_Factorized2()

bool Calculator::globalEfficiency_Factorized2 ( const LeptonList leptons,
unsigned  runNumber,
GlobEffFunc  func1,
GlobEffFunc  func2,
Efficiencies globalEfficiencies 
)
private

Definition at line 1420 of file Calculator.cxx.

1422  {
1424  if (!func1(this, leptons, runNumber, efficiencies[0]))
1425  return false;
1426  if (!func2(this, leptons, runNumber, efficiencies[1]))
1427  return false;
1428  globalEfficiencies = ~(~efficiencies[0] * ~efficiencies[1]);
1429  return true;
1430 }

◆ globalEfficiency_Factorized3()

bool Calculator::globalEfficiency_Factorized3 ( const LeptonList leptons,
unsigned  runNumber,
GlobEffFunc  func1,
GlobEffFunc  func2,
GlobEffFunc  func3,
Efficiencies globalEfficiencies 
)
private

Definition at line 1432 of file Calculator.cxx.

1434  {
1436  if (!func1(this, leptons, runNumber, efficiencies[0]))
1437  return false;
1438  if (!func2(this, leptons, runNumber, efficiencies[1]))
1439  return false;
1440  if (!func3(this, leptons, runNumber, efficiencies[2]))
1441  return false;
1442  globalEfficiencies =
1443  ~(~efficiencies[0] * ~efficiencies[1] * ~efficiencies[2]);
1444  return true;
1445 }

◆ globalEfficiency_Toys()

bool Calculator::globalEfficiency_Toys ( const LeptonList leptons,
unsigned  runNumber,
const std::vector< TrigDef > &  triggers,
Efficiencies globalEfficiencies 
)
private

0 = data, 1 = MC

Definition at line 1513 of file Calculator.cxx.

1516  {
1517  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Toys() at line "
1518  << __LINE__);
1519  globalEfficiencies = {0.};
1520  if (m_parent->m_numberOfToys <= 0) {
1521  ATH_MSG_ERROR("The specified number of toys is <= 0");
1522  return false;
1523  }
1524  std::map<const Lepton*, std::vector<std::pair<std::size_t, Efficiencies>>>
1525  leptonEfficiencies;
1526  for (auto& lepton : leptons) {
1527  flat_set<std::size_t> validLegs;
1528  if (!fillListOfLegsFor(lepton, triggers, validLegs))
1529  return false;
1530  auto& efficiencies = leptonEfficiencies[&lepton];
1531  const int nLegs = validLegs.size();
1532  if (nLegs) {
1533  bool success = true;
1534  for (std::size_t leg :
1535  m_parent->getSortedLegs(lepton, validLegs, success)) {
1537  lepton, runNumber, leg, success));
1538  }
1539  if (!success)
1540  return false;
1541  }
1542  }
1543  unsigned long seed;
1544  if (!m_parent->m_useInternalSeed) {
1545  if (!m_parent->retrieveEventNumber(seed)) {
1546  ATH_MSG_WARNING("Will use internal seed instead of event number");
1547  seed = m_parent->m_seed++;
1548  }
1549  } else
1550  seed = m_parent->m_seed++;
1551  std::mt19937_64 randomEngine(seed);
1552  std::uniform_real_distribution<double> uniformPdf(0., 1.);
1553  std::vector<flat_set<std::size_t>> firedLegs(leptonEfficiencies.size());
1554  unsigned long nPassed[2] = {0, 0};
1555  for (unsigned long toy = 0; toy < m_parent->m_numberOfToys; ++toy) {
1556  for (int step = 0; step < 2; ++step)
1557  {
1558  auto legs = firedLegs.begin();
1559  for (auto& kv : leptonEfficiencies) {
1560  legs->clear();
1561  double x = uniformPdf(randomEngine);
1562  for (auto& p : kv.second) {
1563  if (x < (step ? p.second.mc() : p.second.data()))
1564  legs->emplace(p.first);
1565  }
1566  ++legs;
1567  }
1568  for (auto& trig : triggers) {
1569  if (!canTriggerBeFired(trig, firedLegs))
1570  continue;
1571  ++nPassed[step];
1572  break;
1573  }
1574  }
1575  }
1576  globalEfficiencies.data() =
1577  double(nPassed[0]) / double(m_parent->m_numberOfToys);
1578  globalEfficiencies.mc() =
1579  double(nPassed[1]) / double(m_parent->m_numberOfToys);
1580  return true;
1581 }

◆ initMessaging()

void AthMessaging::initMessaging ( ) const
privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

40 {
42  m_lvl = m_imsg ?
43  static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
44  MSG::INFO;
45 }

◆ msg() [1/2]

MsgStream & asg::AsgMessaging::msg ( ) const
inherited

The standard message stream.

Returns
A reference to the default message stream of this object.

Definition at line 49 of file AsgMessaging.cxx.

49  {
50 #ifndef XAOD_STANDALONE
52 #else // not XAOD_STANDALONE
53  return m_msg;
54 #endif // not XAOD_STANDALONE
55  }

◆ msg() [2/2]

MsgStream & asg::AsgMessaging::msg ( const MSG::Level  lvl) const
inherited

The standard message stream.

Parameters
lvlThe message level to set the stream to
Returns
A reference to the default message stream, set to level "lvl"

Definition at line 57 of file AsgMessaging.cxx.

57  {
58 #ifndef XAOD_STANDALONE
60 #else // not XAOD_STANDALONE
61  m_msg << lvl;
62  return m_msg;
63 #endif // not XAOD_STANDALONE
64  }

◆ msgLvl()

bool asg::AsgMessaging::msgLvl ( const MSG::Level  lvl) const
inherited

Test the output level of the object.

Parameters
lvlThe message level to test against
Returns
boolean Indicting if messages at given level will be printed
true If messages at level "lvl" will be printed

Definition at line 41 of file AsgMessaging.cxx.

41  {
42 #ifndef XAOD_STANDALONE
43  return ::AthMessaging::msgLvl( lvl );
44 #else // not XAOD_STANDALONE
45  return m_msg.msgLevel( lvl );
46 #endif // not XAOD_STANDALONE
47  }

◆ setLevel()

void AthMessaging::setLevel ( MSG::Level  lvl)
inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

29 {
30  m_lvl = lvl;
31 }

Friends And Related Function Documentation

◆ CheckConfig

friend class CheckConfig
friend

Definition at line 316 of file Calculator.h.

Member Data Documentation

◆ ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

◆ m_cachedEfficiencies

std::map<std::pair<const Lepton*, std::size_t>, Efficiencies> TrigGlobEffCorr::Calculator::m_cachedEfficiencies
private

Definition at line 67 of file Calculator.h.

◆ m_forceUnitSF

bool TrigGlobEffCorr::Calculator::m_forceUnitSF
private

Definition at line 68 of file Calculator.h.

◆ m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }
mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

◆ m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }
mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

◆ m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls
mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

◆ m_nm

std::string AthMessaging::m_nm
privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

◆ m_parent

TrigGlobalEfficiencyCorrectionTool* TrigGlobEffCorr::Calculator::m_parent
private

Definition at line 62 of file Calculator.h.

◆ m_periods

std::vector<Period> TrigGlobEffCorr::Calculator::m_periods
private

pointer updated at each call to compute() because the parent tool might have been moved in-between

Definition at line 65 of file Calculator.h.


The documentation for this class was generated from the following files:
AthMessaging::m_lvl
std::atomic< MSG::Level > m_lvl
Current logging level.
Definition: AthMessaging.h:138
TrigGlobalEfficiencyCorrectionTool::getLoosestLegAboveThreshold
std::size_t getLoosestLegAboveThreshold(const TrigGlobEffCorr::Lepton &lepton, const flat_set< std::size_t > &legs, bool &success)
sTgcDigitEffiDump.efficiencies
list efficiencies
translate the station name indices into the string staiton name
Definition: sTgcDigitEffiDump.py:23
python.AtlRunQueryAMI.period
period
Definition: AtlRunQueryAMI.py:224
TrigGlobalEfficiencyCorrectionTool::getSortedLegs
std::vector< std::size_t > getSortedLegs(const TrigGlobEffCorr::Lepton &lepton, const flat_set< std::size_t > &legs, bool &success)
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
TrigGlobEffCorr::Calculator::m_forceUnitSF
bool m_forceUnitSF
Definition: Calculator.h:68
xAOD::Electron
Electron_v1 Electron
Definition of the current "egamma version".
Definition: Event/xAOD/xAODEgamma/xAODEgamma/Electron.h:17
runLayerRecalibration.chain
chain
Definition: runLayerRecalibration.py:175
AsgConfigHelper::Helper
std::vector< T > Helper(const std::string &input, TEnv &env)
Definition: AsgEGammaConfigHelper.cxx:83
athena_checkUpload.Period
int Period
--> Execution phase:
Definition: athena_checkUpload.py:179
TrigGlobEffCorr::Calculator::m_periods
std::vector< Period > m_periods
pointer updated at each call to compute() because the parent tool might have been moved in-between
Definition: Calculator.h:65
TrigGlobEffCorr::Calculator::findUniqueLeg
bool findUniqueLeg(xAOD::Type::ObjectType obj, std::size_t &uniqueLeg, const std::vector< TrigDef > &defs)
Definition: Calculator.cxx:89
TrigGlobEffCorr::Lepton::photon
const xAOD::Photon * photon() const
Definition: Lepton.h:37
Efficiencies
TrigGlobEffCorr::Efficiencies Efficiencies
Definition: TrigGlobalEfficiencyCorrectionTool.cxx:30
ParticleTest.tp
tp
Definition: ParticleTest.py:25
TrigGlobEffCorr::TT_SINGLELEPTON_FLAG
@ TT_SINGLELEPTON_FLAG
Definition: ImportData.h:35
TrigGlobalEfficiencyCorrectionTool::m_useInternalSeed
bool m_useInternalSeed
Definition: TrigGlobalEfficiencyCorrectionTool.h:162
TrigGlobEffCorr::Efficiencies
Definition: Efficiencies.h:14
TrigGlobalEfficiencyCorrectionTool::getTwoLoosestLegs
std::pair< std::size_t, std::size_t > getTwoLoosestLegs(const TrigGlobEffCorr::Lepton &lepton, const flat_set< std::size_t > &legs, bool &success)
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
python.TrigTLAMonitorAlgorithm.triggers
triggers
Definition: TrigTLAMonitorAlgorithm.py:196
CheckTagAssociation.notfound
notfound
Definition: CheckTagAssociation.py:105
TrigGlobEffCorr::Calculator::getLoosestLegAboveThreshold
auto getLoosestLegAboveThreshold(const Lepton &lepton, const flat_set< Trig1L > &trigs, bool &success) -> std::enable_if_t< Trig1L::is1L(), std::size_t >
Definition: Calculator.h:74
AthMessaging::m_imsg
std::atomic< IMessageSvc * > m_imsg
MessageSvc pointer.
Definition: AthMessaging.h:135
x
#define x
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition: getMessageSvc.cxx:20
XMLtoHeader.count
count
Definition: XMLtoHeader.py:84
flat_set
boost::container::flat_set< Key > flat_set
Definition: CheckConfig.cxx:14
TrigGlobEffCorr::Calculator::aboveThreshold
bool aboveThreshold(const Lepton &p, std::size_t leg) const
Definition: Calculator.h:70
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:92
TrigGlobalEfficiencyCorrectionTool::m_seed
unsigned long m_seed
Definition: TrigGlobalEfficiencyCorrectionTool.h:185
TrigGlobalEfficiencyCorrectionTool::getLoosestLeg
std::size_t getLoosestLeg(const TrigGlobEffCorr::Lepton &lepton, std::size_t leg1, std::size_t leg2, bool &success)
TRT::Hit::side
@ side
Definition: HitInfo.h:83
runBeamSpotCalibration.helper
helper
Definition: runBeamSpotCalibration.py:115
TrigGlobEffCorr::Lepton::tag
std::size_t tag() const
Definition: Lepton.h:30
TrigGlobalEfficiencyCorrectionTool::TLE_ERROR
@ TLE_ERROR
Definition: TrigGlobalEfficiencyCorrectionTool.h:240
TrigGlobEffCorr::Lepton::muon
const xAOD::Muon * muon() const
Definition: Lepton.h:34
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
Generate_dsid_ranseed.seed
seed
Definition: Generate_dsid_ranseed.py:10
TrigConf::MSGTC::Level
Level
Definition: Trigger/TrigConfiguration/TrigConfBase/TrigConfBase/MsgStream.h:21
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
lumiFormat.i
int i
Definition: lumiFormat.py:85
TrigGlobEffCorr::Calculator::m_cachedEfficiencies
std::map< std::pair< const Lepton *, std::size_t >, Efficiencies > m_cachedEfficiencies
Definition: Calculator.h:67
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TrigGlobalEfficiencyCorrectionTool::aboveThreshold
bool aboveThreshold(const TrigGlobEffCorr::Lepton &p, std::size_t leg) const
TrigGlobEffCorr::Calculator::m_parent
TrigGlobalEfficiencyCorrectionTool * m_parent
Definition: Calculator.h:62
res
std::pair< std::vector< unsigned int >, bool > res
Definition: JetGroupProductTest.cxx:11
asg::AsgMessaging::msg
MsgStream & msg() const
The standard message stream.
Definition: AsgMessaging.cxx:49
test_pyathena.parent
parent
Definition: test_pyathena.py:15
compute_lumi.leg
leg
Definition: compute_lumi.py:95
TrigGlobalEfficiencyCorrectionTool::m_validTrigMatchTool
bool m_validTrigMatchTool
Definition: TrigGlobalEfficiencyCorrectionTool.h:186
xAOD::double
double
Definition: CompositeParticle_v1.cxx:159
TrigGlobalEfficiencyCorrectionTool::TLE_OK
@ TLE_OK
Definition: TrigGlobalEfficiencyCorrectionTool.h:240
TrigGlobEffCorr::TT_TRILEPTON_FLAG
@ TT_TRILEPTON_FLAG
Definition: ImportData.h:53
TrigGlobalEfficiencyCorrectionTool::TLE_UNAVAILABLE
@ TLE_UNAVAILABLE
Definition: TrigGlobalEfficiencyCorrectionTool.h:240
TrigGlobEffCorr::Efficiencies::mc
double & mc()
Definition: Efficiencies.h:24
asg::AsgMessaging
Class mimicking the AthMessaging class from the offline software.
Definition: AsgMessaging.h:40
python.ElectronD3PDObject.matched
matched
Definition: ElectronD3PDObject.py:138
TrigGlobEffCorr::Lepton::type
xAOD::Type::ObjectType type() const
Definition: Lepton.h:29
xAOD::Photon
Photon_v1 Photon
Definition of the current "egamma version".
Definition: Event/xAOD/xAODEgamma/xAODEgamma/Photon.h:17
Muon
struct TBPatternUnitContext Muon
Rtt_histogram.n1
n1
Definition: Rtt_histogram.py:21
TrigGlobalEfficiencyCorrectionTool::getTriggerLegEfficiencies
TLE_RESULT getTriggerLegEfficiencies(const xAOD::Electron *p, unsigned runNumber, std::size_t leg, std::size_t tag, TrigGlobEffCorr::Efficiencies &efficiencies)
DeMoAtlasDataLoss.runNumber
string runNumber
Definition: DeMoAtlasDataLoss.py:64
TrigGlobEffCorr::Calculator::getCachedTriggerLegEfficiencies
Efficiencies getCachedTriggerLegEfficiencies(const Lepton &lepton, unsigned runNumber, std::size_t leg, bool &success)
Definition: Calculator.cxx:265
TrigGlobalEfficiencyCorrectionTool::m_trigMatchTool
ToolHandle< Trig::IMatchingTool > m_trigMatchTool
Definition: TrigGlobalEfficiencyCorrectionTool.h:163
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.Constants.INFO
int INFO
Definition: Control/AthenaCommon/python/Constants.py:15
AthMessaging::m_nm
std::string m_nm
Message source name.
Definition: AthMessaging.h:129
TrigGlobalEfficiencyCorrectionTool::m_numberOfToys
unsigned long m_numberOfToys
Definition: TrigGlobalEfficiencyCorrectionTool.h:161
if
if(febId1==febId2)
Definition: LArRodBlockPhysicsV0.cxx:567
TrigGlobEffCorr::TT_DILEPTON_FLAG
@ TT_DILEPTON_FLAG
Definition: ImportData.h:40
LArCellBinning.step
step
Definition: LArCellBinning.py:158
TrigGlobEffCorr::TriggerProperties
Definition: Trigger.h:27
TrigGlobEffCorr::Calculator::globalEfficiency
auto globalEfficiency(const LeptonList &, unsigned, const Trig1L, Efficiencies &) -> std::enable_if_t< Trig1L::is1L(), bool >
One single-lepton trigger.
Definition: Calculator.cxx:313
TrigGlobEffCorr::Calculator::fillListOfLegsFor
bool fillListOfLegsFor(const Lepton &lepton, const std::vector< TrigDef > &triggers, flat_set< std::size_t > &validLegs) const
Definition: Calculator.cxx:1447
dqt_zlumi_alleff_HIST.eff
int eff
Definition: dqt_zlumi_alleff_HIST.py:113
TrigGlobEffCorr::Calculator::canTriggerBeFired
bool canTriggerBeFired(const TrigDef &trig, const std::vector< flat_set< std::size_t > > &firedLegs) const
Definition: Calculator.cxx:1465
TrigGlobEffCorr::Efficiencies::data
double & data()
Definition: Efficiencies.h:23
TrigGlobalEfficiencyCorrectionTool::retrieveEventNumber
bool retrieveEventNumber(unsigned long &eventNumber)
TrigGlobEffCorr::Calculator::globalEfficiency_Toys
bool globalEfficiency_Toys(const LeptonList &, unsigned, const std::vector< TrigDef > &triggers, Efficiencies &)
Definition: Calculator.cxx:1513
python.PyAthena.obj
obj
Definition: PyAthena.py:132
TrigGlobalEfficiencyCorrectionTool::m_dictionary
std::map< std::size_t, std::string > m_dictionary
Definition: TrigGlobalEfficiencyCorrectionTool.h:177
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
TrigGlobEffCorr::Lepton::electron
const xAOD::Electron * electron() const
Definition: Lepton.h:31
TrigGlobEffCorr::Calculator::getPeriod
const Period * getPeriod(unsigned runNumber) const
Definition: Calculator.cxx:111