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	checkTriggerMatching (TrigGlobalEfficiencyCorrectionTool &parent, bool &matched, std::unordered_map< std::string, bool > *matched_per_trigger, 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.
Functions providing the same interface as AthMessaging
bool	msgLvl (const MSG::Level lvl) const
	Test the output level of the object.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.

Private Types
using	LeptonList = TrigGlobalEfficiencyCorrectionTool::LeptonList
using	TrigDef = TrigGlobEffCorr::ImportData::TrigDef
using	GlobEffFunc

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 Period *	getPeriod (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.
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.
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.
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.
template<typename Trig2Lmix>
auto	globalEfficiency (const LeptonList &, unsigned, const Trig2Lmix, Efficiencies &) -> std::enable_if_t< Trig2Lmix::is2Lmix(), bool >
	One mixed-flavour dilepton trigger.
template<typename Trig2Lsym>
auto	globalEfficiency (const LeptonList &, unsigned, const Trig2Lsym, Efficiencies &) -> std::enable_if_t< Trig2Lsym::is2Lsym(), bool >
	One symmetric dilepton trigger.
template<typename Trig2Lasym>
auto	globalEfficiency (const LeptonList &, unsigned, const Trig2Lasym, Efficiencies &) -> std::enable_if_t< Trig2Lasym::is2Lasym(), bool >
	One asymmetric dilepton trigger.
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.
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.
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.
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.
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.
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.
template<typename Trig3Lsym>
auto	globalEfficiency (const LeptonList &, unsigned, const Trig3Lsym, Efficiencies &) -> std::enable_if_t< Trig3Lsym::is3Lsym(), bool >
	One symmetric trilepton trigger.
template<typename Trig3Lhalfsym>
auto	globalEfficiency (const LeptonList &, unsigned, const Trig3Lhalfsym, Efficiencies &) -> std::enable_if_t< Trig3Lhalfsym::is3Lhalfsym(), bool >
	One half-symmetric trilepton trigger.
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.
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.
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.
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.
template<typename Trig3Lmix>
auto	globalEfficiency (const LeptonList &, unsigned, const Trig3Lmix, Efficiencies &) -> std::enable_if_t< Trig3Lmix::is3Lmix(), bool >
	One mixed-flavour trilepton trigger.
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.
template<typename Trig4Lsym>
auto	globalEfficiency (const LeptonList &, unsigned, const Trig4Lsym, Efficiencies &) -> std::enable_if_t< Trig4Lsym::is4Lsym(), bool >
	One symmetric tetralepton trigger.
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.

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

Friends
class	CheckConfig

Detailed Description

Definition at line 26 of file Calculator.h.

Member Typedef Documentation

GlobEffFunc

using TrigGlobEffCorr::Calculator::GlobEffFunc

private

Initial value:

 std::function<bool(Calculator*, const LeptonList&,
                                         unsigned, Efficiencies&)>

Definition at line 29 of file Calculator.h.

LeptonList

using TrigGlobEffCorr::Calculator::LeptonList = TrigGlobalEfficiencyCorrectionTool::LeptonList

private

Definition at line 27 of file Calculator.h.

TrigDef

using TrigGlobEffCorr::Calculator::TrigDef = TrigGlobEffCorr::ImportData::TrigDef

private

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.

    : asg::AsgMessaging(&parent), m_parent(&parent) {
  msg().setLevel(parent.msg().level());
  m_periods.reserve(nPeriodsToReserve);
}

Member Function Documentation

aboveThreshold()

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

inlineprivate

Definition at line 74 of file Calculator.h.

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

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.

                                                       {
  bool success = true;
  m_parent = data.getParent();
 
  auto triggers = data.parseTriggerString(combination, success);
  if (!success)
    return false;
  if (!triggers.size()) {
    ATH_MSG_ERROR("The trigger combination is empty!");
    return false;
  }
 
  if (!findUniqueLeg(xAOD::Type::Electron, uniqueElectronLeg, triggers))
    return false;
  if (!findUniqueLeg(xAOD::Type::Photon, uniquePhotonLeg, triggers))
    return false;

  Helper helper(triggers);
  if (helper.duplicates()) {
    ATH_MSG_ERROR("The following combination of triggers contains duplicates: "
                  << combination);
    return false;
  }
  if (!useToys) {
    success = helper.findAndBindFunction();
    if (!helper.m_formula) {
      ATH_MSG_ERROR(
          "This trigger combination is currently not supported with an "
          "explicit formula (you may use toys instead, slower): "
          << combination);
      return false;
    }
  } else {
    helper.m_formula = std::bind(&Calculator::globalEfficiency_Toys, ::_1, ::_2,
                                 ::_3, triggers, ::_4);
  }
  if (success) {
    if (data.adaptTriggerListForTriggerMatching(triggers)) {
      m_periods.emplace_back(boundaries, std::move(helper.m_formula),
                             std::move(triggers));
    } else {
      if (m_parent->m_validTrigMatchTool)
        return false;
      m_periods.emplace_back(boundaries, std::move(helper.m_formula));
    }
  } else {
    ATH_MSG_ERROR(
        "Unspecified error occurred while trying to find the formula for the "
        "trigger combination "
        << combination);
  }
  return success;
}

canTriggerBeFired()

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

private

Definition at line 1476 of file Calculator.cxx.

                                                           {
  const int nLegs = static_cast<int>(std::count_if(
      trig.leg.begin(), trig.leg.end(), [](auto x) { return x != 0ul; }));
  const int sameLegs = static_cast<int>(
      std::count(trig.leg.begin(), trig.leg.end(), trig.leg[0]));
  if (sameLegs == nLegs) {
    // single-lepton and symmetric multilepton triggers
    return std::count_if(firedLegs.cbegin(), firedLegs.cend(), [&](auto& legs) {
             return legs.count(trig.leg[0]);
           }) >= nLegs;
  } else if (nLegs == 2) {
    // asymmetric or mixed-flavour dilepton triggers
    bool n0 = false, n1 = false;
    for (auto& legs : firedLegs) {
      if (n0 && legs.count(trig.leg[1]))
        return true;
      if (n1 && legs.count(trig.leg[0]))
        return true;
      n0 = n0 || legs.count(trig.leg[0]);
      n1 = n1 || legs.count(trig.leg[1]);
    }
  } else if (nLegs == 3) {
    // other trilepton triggers
    auto end = firedLegs.end();
    for (auto legs0 = firedLegs.begin(); legs0 != end; ++legs0) {
      for (int i = 0; i < 3; ++i) {
        if (!legs0->count(trig.leg[i]))
          continue;
        for (auto legs1 = legs0 + 1; legs1 != end; ++legs1) {
          for (int j = 1; j < 3; ++j) {
            if (!legs1->count(trig.leg[(i + j) % 3]))
              continue;
            for (auto legs2 = legs1 + 1; legs2 != end; ++legs2) {
              if (legs2->count(trig.leg[(i + 3 - j) % 3]))
                return true;
            }
          }
        }
      }
    }
  } else {
    ATH_MSG_ERROR("incomplete support of 4-lepton triggers.");
  }
  return false;
}

checkTriggerMatching() [1/2]

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

checkTriggerMatching() [2/2]

bool Calculator::checkTriggerMatching	(	TrigGlobalEfficiencyCorrectionTool &	parent,
		bool &	matched,
		std::unordered_map< std::string, bool > *	matched_per_trigger,
		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

return the set of legs back to the main container

Definition at line 144 of file Calculator.cxx.

                                                   {
  matched = false;
  if(matched_per_trigger) {
    for(auto& [key, flag] : *matched_per_trigger) flag = false;
  }
 
  m_parent = &parent;
  auto period = getPeriod(runNumber);
  if (!period)
    return false;
  if (!period->m_triggers.size()) {
    ATH_MSG_ERROR("Empty list of triggers for run number " << runNumber);
    return false;
  }
  auto& trigMatchTool = m_parent->m_trigMatchTool;

  const unsigned nLep = leptons.size();
  std::vector<flat_set<std::size_t>> validLegs(leptons.size());
  for (unsigned i = 0; i < nLep; ++i) {
    if (!fillListOfLegsFor(leptons[i], period->m_triggers, validLegs[i]))
      return false;
  }

  std::vector<flat_set<std::size_t>> firedLegs;
  std::vector<const xAOD::IParticle*> trigLeptons;
  const std::size_t magicWordHLT = 0xf7b8b87ef2917d66;
 
  for (auto& trig : period->m_triggers) {
    auto itr = m_parent->m_dictionary.find(trig.name ^ magicWordHLT);
    if (itr == m_parent->m_dictionary.end()) {
      itr = m_parent->m_dictionary
                .emplace(trig.name ^ magicWordHLT,
                         "HLT_" + m_parent->m_dictionary.at(trig.name))
                .first;
    }
    const std::string& chain = itr->second;
 
    unsigned nLegs = 0;
    if (trig.type & TT_SINGLELEPTON_FLAG)
      nLegs = 1;
    else if (trig.type & TT_DILEPTON_FLAG)
      nLegs = 2;
    else if (trig.type & TT_TRILEPTON_FLAG)
      nLegs = 3;
    else {
      ATH_MSG_ERROR("Unsupported trigger (type = "
                    << std::hex << trig.type << std::dec << ") " << chain);
      return false;
    }
    firedLegs.resize(nLegs);
    trigLeptons.resize(nLegs);
    for (unsigned i0 = 0; i0 < nLep; ++i0) {
      firedLegs[0].swap(validLegs[i0]);  
      trigLeptons[0] = leptons[i0].particle();
      if (nLegs == 1) {
        // Check we have enough lepton(s) on trigger plateau and test the trigger matching
        if(canTriggerBeFired(trig, firedLegs) && trigMatchTool->match(trigLeptons, chain)) {
          matched = true;
          if(!matched_per_trigger) return true;
          if(matched_per_trigger->count(chain)) matched_per_trigger->at(chain) = true;
        }
      } else
        for (unsigned i1 = i0 + 1; i1 < nLep; ++i1) {
          firedLegs[1].swap(validLegs[i1]);
          trigLeptons[1] = leptons[i1].particle();
          if (nLegs == 2) {
            if(canTriggerBeFired(trig, firedLegs) && trigMatchTool->match(trigLeptons, chain)) {
              matched = true;
              if(!matched_per_trigger) return true;
              if(matched_per_trigger->count(chain)) matched_per_trigger->at(chain) = true;
            }
          } else
            for (unsigned i2 = i1 + 1; i2 < nLep; ++i2) {
              firedLegs[2].swap(validLegs[i2]);
              trigLeptons[2] = leptons[i2].particle();
              if(canTriggerBeFired(trig, firedLegs) && trigMatchTool->match(trigLeptons, chain)) {
                matched = true;
                if(!matched_per_trigger) return true;
                if(matched_per_trigger->count(chain)) matched_per_trigger->at(chain) = true;
              }
              firedLegs[2].swap(validLegs[i2]);
            }
          firedLegs[1].swap(validLegs[i1]);
        }
      firedLegs[0].swap(
          validLegs[i0]);  
    }
  }
  return true;
}

compute()

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

Definition at line 125 of file Calculator.cxx.

                                                     {
  m_parent = &parent;
  m_forceUnitSF = false;
  auto period = getPeriod(runNumber);
  if (!period)
    return false;
  m_cachedEfficiencies.clear();
  bool success = period->m_formula &&
                 period->m_formula(this, leptons, runNumber, efficiencies);
  if (m_forceUnitSF) {
    efficiencies.data() = 1.;
    efficiencies.mc() = 1.;
    success = true;
  }
  return success;
}

fillListOfLegsFor()

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

private

Definition at line 1458 of file Calculator.cxx.

                                                                         {
  validLegs.clear();
  for (auto& trig : triggers) {
    TriggerProperties tp(trig);
    if (!tp.valid()) {
      ATH_MSG_ERROR("Unrecognized trigger type " << trig.type);
      return false;
    }
    auto end = tp.cend(lepton.type());
    for (auto itr = tp.cbegin(lepton.type()); itr != end; ++itr)
      if (aboveThreshold(lepton, *itr))
        validLegs.emplace(*itr);
  }
  return true;
}

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.

                                                               {
  if (uniqueLeg)
    return true;  
  for (auto& def : defs) {
    TriggerProperties tp(def);
    for (auto itr = tp.cbegin(obj); itr != tp.cend(obj); ++itr) {
      if (uniqueLeg && uniqueLeg != *itr) {
        ATH_MSG_ERROR(
            "The property 'ListOfLegsPerTool' needs to be filled as the "
            "specified trigger combination involves several electron (or "
            "photon) trigger legs");
        return false;
      }
      uniqueLeg = *itr;
    }
  }
  return true;
}

getCachedTriggerLegEfficiencies()

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

private

Definition at line 276 of file Calculator.cxx.

                                                                        {
  auto insertion = m_cachedEfficiencies.emplace(std::make_pair(&lepton, leg),
                                                Efficiencies());
  Efficiencies& efficiencies = insertion.first->second;
  if (insertion.second) {
    auto res = TrigGlobalEfficiencyCorrectionTool::TLE_ERROR;
    switch (lepton.type()) {
      case xAOD::Type::Electron:
        res = m_parent->getTriggerLegEfficiencies(
            lepton.electron(), runNumber, leg, lepton.tag(), efficiencies);
        break;
      case xAOD::Type::Muon:
        res = m_parent->getTriggerLegEfficiencies(lepton.muon(), runNumber, leg,
                                                  lepton.tag(), efficiencies);
        break;
      case xAOD::Type::Photon:
        res = m_parent->getTriggerLegEfficiencies(
            lepton.photon(), runNumber, leg, lepton.tag(), efficiencies);
        break;
      default:
        ATH_MSG_ERROR("Unsupported particle type");
    }
    switch (res) {
      case TrigGlobalEfficiencyCorrectionTool::TLE_OK:
        break;
      case TrigGlobalEfficiencyCorrectionTool::TLE_UNAVAILABLE:
        m_forceUnitSF = true;
        break;
      case TrigGlobalEfficiencyCorrectionTool::TLE_ERROR:
        [[fallthrough]];
      default:
        success = false;
        efficiencies.data() = -777.;
        efficiencies.mc() = -777.;
    }
  }
  if (efficiencies.mc() == -777. && !m_forceUnitSF)
    success = false;
  return efficiencies;
}

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 78 of file Calculator.h.

                                                 {
    return m_parent->getLoosestLegAboveThreshold(
        lepton, Trig1L::anonymize(trigs), success);
  }

getPeriod()

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

private

Definition at line 111 of file Calculator.cxx.

                                                                      {
  auto period =
      std::find_if(m_periods.cbegin(), m_periods.cend(), [=](const Period& p) {
        return runNumber >= p.m_boundaries.first &&
               runNumber <= p.m_boundaries.second;
      });
  if (period == m_periods.end()) {
    ATH_MSG_ERROR("No trigger combination has been specified for run "
                  << runNumber);
    return nullptr;
  }
  return &*period;
}

getRelevantTriggersForUser()

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

Definition at line 244 of file Calculator.cxx.

                                                        {
  triggers.clear();
  m_parent = &parent;
  auto period = getPeriod(runNumber);
  if (!period)
    return false;
  if (!period->m_triggers.size()) {
    ATH_MSG_ERROR("Empty list of triggers for run number "
                  << runNumber
                  << " (was there a configuration issue? please check for "
                     "warnings during initialization)");
    return false;
  }
  bool success = true;
  auto notfound = parent.m_dictionary.end();
  for (auto& trig : period->m_triggers) {
    auto itr = parent.m_dictionary.find(trig.name);
    if (itr == notfound) {
      ATH_MSG_ERROR("can't retrieve name of trigger with hash "
                    << trig.name
                    << " (shouldn't happen; contact tool developers!)");
      success = false;
    } else
      triggers.push_back(itr->second);
  }
  if (!success)
    triggers.clear();
  return success;
}

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 388 of file Calculator.cxx.

                                          {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Several1L() at line "
                << __LINE__);
  if (trigs.size() == 1)
    return globalEfficiency(leptons, runNumber, *trigs.cbegin(),
                            globalEfficiencies);
  if (!trigs.size()) {
    globalEfficiencies = {0.};
    return true;
  }
  globalEfficiencies = {1.};
  bool success = true;
  for (auto& lepton : leptons) {
    if (Trig1L::irrelevantFor(lepton))
      continue;
    std::size_t loosestLeg =
        getLoosestLegAboveThreshold(lepton, trigs, success);
    if (loosestLeg && success) {
      auto efficiencies = getCachedTriggerLegEfficiencies(lepton, runNumber,
                                                          loosestLeg, success);
      globalEfficiencies *= ~efficiencies;
    }
  }
  globalEfficiencies = ~globalEfficiencies;
  return success;
}

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 422 of file Calculator.cxx.

                              {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Several1L() at line "
                << __LINE__);
  if (trigs1.size() == 1 && trigs2.size() == 1) {
    return globalEfficiency(leptons, runNumber, *trigs1.cbegin(),
                            *trigs2.cbegin(), globalEfficiencies);
  }
  if (!trigs1.size())
    return globalEfficiency(leptons, runNumber, trigs2, globalEfficiencies);
  if (!trigs2.size())
    return globalEfficiency(leptons, runNumber, trigs1, globalEfficiencies);
  globalEfficiencies = {1.};
  bool success = true;
  for (auto& lepton : leptons) {
    std::size_t loosestLeg;
    if (Trig1L_obj1::relevantFor(lepton))
      loosestLeg = getLoosestLegAboveThreshold(lepton, trigs1, success);
    else if (Trig1L_obj2::relevantFor(lepton))
      loosestLeg = getLoosestLegAboveThreshold(lepton, trigs2, success);
    else
      continue;
    if (loosestLeg && success) {
      auto efficiencies = getCachedTriggerLegEfficiencies(lepton, runNumber,
                                                          loosestLeg, success);
      globalEfficiencies *= ~efficiencies;
    }
  }
  globalEfficiencies = ~globalEfficiencies;
  return success;
}

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 324 of file Calculator.cxx.

                                          {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One1L() at line "
                << __LINE__);
  if (!trig) {
    globalEfficiencies = {0.};
    return true;
  }
  globalEfficiencies = {1.};
  bool success = true;
  for (auto& lepton : leptons) {
    if (trig.irrelevantFor(lepton) || !aboveThreshold(lepton, trig()))
      continue;
    auto efficiencies =
        getCachedTriggerLegEfficiencies(lepton, runNumber, trig(), success);
    globalEfficiencies *= ~efficiencies;
  }
  globalEfficiencies = ~globalEfficiencies;
  return success;
}

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 351 of file Calculator.cxx.

                              {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Two1L() at line "
                << __LINE__);
  if (!trig1)
    return globalEfficiency(leptons, runNumber, trig2, globalEfficiencies);
  if (!trig2)
    return globalEfficiency(leptons, runNumber, trig1, globalEfficiencies);
  globalEfficiencies = {1.};
  bool success = true;
  for (auto& lepton : leptons) {
    std::size_t leg;
    if (trig1.relevantFor(lepton))
      leg = trig1();
    else if (trig2.relevantFor(lepton))
      leg = trig2();
    else
      continue;
    if (!aboveThreshold(lepton, leg))
      continue;
    auto efficiencies =
        getCachedTriggerLegEfficiencies(lepton, runNumber, leg, success);
    globalEfficiencies *= ~efficiencies;
  }
  globalEfficiencies = ~globalEfficiencies;
  return success;
}

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 601 of file Calculator.cxx.

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

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 1108 of file Calculator.cxx.

                              {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Two2L() at line "
                << __LINE__);
  Efficiencies efficiencies1L, efficiencies2L, efficiencies2Lor1L;
  bool success =
      globalEfficiency(leptons, runNumber,
                       trig2Lmix.template antiside<Trig2L>(), efficiencies1L);
  success =
      success && globalEfficiency(leptons, runNumber, trig2L, efficiencies2L);
  success = success && globalEfficiency(leptons, runNumber, trig2L,
                                        trig2Lmix.template side<Trig2L>(),
                                        efficiencies2Lor1L);
  globalEfficiencies =
      efficiencies2L * ~efficiencies1L + efficiencies1L * efficiencies2Lor1L;
  return success;
}

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 1194 of file Calculator.cxx.

                              {
  ATH_MSG_DEBUG(
      "Entered Calculator::globalEfficiency_Three2LSeveral1L() at line "
      << __LINE__);
  Efficiencies efficiencies[4];
  bool success = true;
  if (trig2L_obj1)
    success = success && globalEfficiency(leptons, runNumber, trig2L_obj1,
                                          trigs1L_obj1, efficiencies[0]);
  else
    success = success && globalEfficiency(leptons, runNumber, trigs1L_obj1,
                                          efficiencies[0]);
  if (trig2L_obj2)
    success = success && globalEfficiency(leptons, runNumber, trig2L_obj2,
                                          trigs1L_obj2, efficiencies[1]);
  else
    success = success && globalEfficiency(leptons, runNumber, trigs1L_obj2,
                                          efficiencies[1]);
  if (trig2Lmix && !trig2Lmix.hiddenBy(trigs1L_obj1)) {
    auto t = trig2Lmix.addTo(trigs1L_obj1);
    if (trig2L_obj1)
      success = success && globalEfficiency(leptons, runNumber, trig2L_obj1, t,
                                            efficiencies[2]);
    else
      success =
          success && globalEfficiency(leptons, runNumber, t, efficiencies[2]);
  } else
    efficiencies[2] = efficiencies[0];
  if (trig2Lmix && !trig2Lmix.hiddenBy(trigs1L_obj2)) {
    auto t = trig2Lmix.addTo(trigs1L_obj2);
    if (trig2L_obj2)
      success = success && globalEfficiency(leptons, runNumber, trig2L_obj2, t,
                                            efficiencies[3]);
    else
      success =
          success && globalEfficiency(leptons, runNumber, t, efficiencies[3]);
  } else
    efficiencies[3] = efficiencies[1];
  globalEfficiencies =
      Efficiencies(1.) - ~efficiencies[0] * ~efficiencies[1] +
      (efficiencies[2] - efficiencies[0]) * (efficiencies[3] - efficiencies[1]);
  return success;
}

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 1137 of file Calculator.cxx.

                              {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Three2L() at line "
                << __LINE__);
  Efficiencies efficiencies2L[2] = {{0.}, {0.}},
               efficiencies2Lor1L[2] = {{0.}, {0.}};
  bool success = true;
  if (trig2L_obj1) {
    success = success && globalEfficiency(leptons, runNumber, trig2L_obj1,
                                          efficiencies2L[0]);
    if (trig2Lmix)
      success =
          success && globalEfficiency(leptons, runNumber, trig2L_obj1,
                                      trig2Lmix.template side<Trig2L_obj1>(),
                                      efficiencies2Lor1L[0]);
    else
      efficiencies2Lor1L[0] = efficiencies2L[0];
  } else if (trig2Lmix)
    success =
        success && globalEfficiency(leptons, runNumber,
                                    trig2Lmix.template side<Trig2L_obj1>(),
                                    efficiencies2Lor1L[0]);
  if (trig2L_obj2) {
    success = success && globalEfficiency(leptons, runNumber, trig2L_obj2,
                                          efficiencies2L[1]);
    if (trig2Lmix)
      success =
          success && globalEfficiency(leptons, runNumber, trig2L_obj2,
                                      trig2Lmix.template side<Trig2L_obj2>(),
                                      efficiencies2Lor1L[1]);
    else
      efficiencies2Lor1L[1] = efficiencies2L[1];
  } else if (trig2Lmix)
    success =
        success && globalEfficiency(leptons, runNumber,
                                    trig2Lmix.template side<Trig2L_obj2>(),
                                    efficiencies2Lor1L[1]);
  globalEfficiencies = efficiencies2L[0] * ~efficiencies2Lor1L[1] +
                       efficiencies2L[1] * ~efficiencies2Lor1L[0] +
                       efficiencies2Lor1L[0] * efficiencies2Lor1L[1];
  return success;
}

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 1261 of file Calculator.cxx.

                              {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Six2LSeveral1L() at line "
                << __LINE__);
 
  auto singleObjectFactor = [=](auto trig2L, auto trig2Lsym, auto& trigs1L,
                                Efficiencies(&efficiencies)[4]) -> bool {
    auto eval_for = [=](const auto& trigs1L_extended,
                        Efficiencies& eff) -> bool {
      if (trig2L && trig2Lsym)
        return this->globalEfficiency(leptons, runNumber, trig2L, trig2Lsym,
                                      trigs1L_extended, eff);
      else if (trig2L)
        return this->globalEfficiency(leptons, runNumber, trig2L,
                                      trigs1L_extended, eff);
      else if (trig2Lsym)
        return this->globalEfficiency(leptons, runNumber, trig2Lsym,
                                      trigs1L_extended, eff);
      else
        return this->globalEfficiency(leptons, runNumber, trigs1L_extended,
                                      eff);
    };
 
    bool success = eval_for(trigs1L, efficiencies[0]);
    if (trig2Lmix1)
      success = success && eval_for(trig2Lmix1.addTo(trigs1L), efficiencies[1]);
    else
      efficiencies[1] = efficiencies[0];
    if (trig2Lmix2) {
      auto t = trig2Lmix2.addTo(trigs1L);
      success = success && eval_for(t, efficiencies[2]);
      if (trig2Lmix1)
        success&& eval_for(trig2Lmix1.addTo(t), efficiencies[3]);
      else
        efficiencies[3] = efficiencies[2];
    } else {
      efficiencies[2] = efficiencies[0];
      efficiencies[3] = efficiencies[1];
    }
    return success;
  };
 
  Efficiencies efficiencies1[4], efficiencies2[4];
  bool success = singleObjectFactor(trig2L_obj1, trig2Lsym_obj1, trigs1L_obj1,
                                    efficiencies1) &&
                 singleObjectFactor(trig2L_obj2, trig2Lsym_obj2, trigs1L_obj2,
                                    efficiencies2);
  globalEfficiencies = Efficiencies(1.) -
                       ~efficiencies1[0] * ~efficiencies2[0] +
                       (efficiencies1[1] - efficiencies1[0]) *
                           (efficiencies2[1] - efficiencies2[0]) +
                       (efficiencies1[2] - efficiencies1[0]) *
                           (efficiencies2[2] - efficiencies2[0]) -
                       (efficiencies1[0] - efficiencies1[1] - efficiencies1[2] +
                        efficiencies1[3]) *
                           (efficiencies2[0] - efficiencies2[1] -
                            efficiencies2[2] + efficiencies2[3]);
  return success;
}

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 675 of file Calculator.cxx.

                              {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One2LSeveral1L() at line "
                << __LINE__);
  if (trig2L.symmetric())
    return globalEfficiency(leptons, runNumber, trig2L.to_symmetric(), trigs1L,
                            globalEfficiencies);
  if (!trigs1L.size())
    return globalEfficiency(leptons, runNumber, trig2L, globalEfficiencies);
  if (!trig2L || trig2L.hiddenBy(trigs1L))
    return globalEfficiency(leptons, runNumber, trigs1L, globalEfficiencies);
  globalEfficiencies = {0.};
  Efficiencies twoSingleInefficiencies[2] = {{1.}, {1.}},
               threeSingleInefficiencies = {1.};
  bool success = true;
  for (auto& lepton : leptons) {
    if (trig2L.irrelevantFor(lepton))
      continue;
    flat_set<std::size_t> validLegs;
    for (std::size_t leg : trig2L.legs)
      if (aboveThreshold(lepton, leg))
        validLegs.insert(leg);
    Efficiencies efficiencies1L = {0.};
    std::size_t loosest1lepLeg =
        getLoosestLegAboveThreshold(lepton, trigs1L, success);
    if (loosest1lepLeg) {
      efficiencies1L = getCachedTriggerLegEfficiencies(lepton, runNumber,
                                                       loosest1lepLeg, success);
      validLegs.insert(loosest1lepLeg);
    }
    if (!validLegs.size())
      continue;
    auto looseLegs = m_parent->getTwoLoosestLegs(lepton, validLegs, success);
    auto efficienciesLoose =
        (looseLegs.first == loosest1lepLeg)
            ? efficiencies1L
            : getCachedTriggerLegEfficiencies(lepton, runNumber,
                                              looseLegs.first, success);
    Efficiencies efficienciesMedium = {0.};
    if (validLegs.size() >= 2)
      efficienciesMedium =
          (looseLegs.second == loosest1lepLeg)
              ? efficiencies1L
              : getCachedTriggerLegEfficiencies(lepton, runNumber,
                                                looseLegs.second, success);
    globalEfficiencies =
        ~efficienciesLoose * globalEfficiencies + efficiencies1L;
    if (loosest1lepLeg != looseLegs.first) {
      globalEfficiencies +=
          (efficienciesLoose - efficienciesMedium) *
          ~twoSingleInefficiencies[looseLegs.first == trig2L.legs[0]];
      if (loosest1lepLeg != looseLegs.second)
        globalEfficiencies +=
            (efficienciesMedium - efficiencies1L) * ~threeSingleInefficiencies;
    }
    threeSingleInefficiencies *= ~efficienciesLoose;
    twoSingleInefficiencies[0] *= (looseLegs.first != trig2L.legs[1])
                                      ? ~efficienciesLoose
                                      : ~efficienciesMedium;  
    twoSingleInefficiencies[1] *= (looseLegs.first != trig2L.legs[0])
                                      ? ~efficienciesLoose
                                      : ~efficienciesMedium;  
  }
  return success;
}

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 830 of file Calculator.cxx.

                              {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Two2LSeveral1L() at line "
                << __LINE__);
  if (!trig2Lasym || trig2Lasym.hiddenBy(trigs1L))
    return globalEfficiency(leptons, runNumber, trig2Lsym, trigs1L,
                            globalEfficiencies);
  if (!trig2Lsym || trig2Lsym.hiddenBy(trigs1L))
    return globalEfficiency(leptons, runNumber, trig2Lasym, trigs1L,
                            globalEfficiencies);
  if (trig2Lasym(0) == trig2Lsym() || trig2Lasym(1) == trig2Lsym()) {
    ATH_MSG_ERROR(
        "implementation -- does this function work properly when the two 2L "
        "triggers have one leg in common? Must be checked");
    return false;
  }
  if (trig2Lasym.symmetric())
    return globalEfficiency(leptons, runNumber, trig2Lasym.to_symmetric(),
                            trig2Lsym, trigs1L, globalEfficiencies);
  globalEfficiencies = {0.};
  Efficiencies singleInefficiencies[3] = {{1.}, {1.}, {1.}};
  Efficiencies efficiencies2Lasym{0.},
      efficiencies2Lsym[3] = {{0.}, {0.}, {0.}};
 
  bool success = true;
  for (auto& lepton : leptons) {
    if (trig2Lasym.irrelevantFor(lepton))
      continue;
    flat_set<std::size_t> validLegs;
    std::map<std::size_t, Efficiencies> efficiencies{{0, 0.}};
    std::size_t loosest1lepLeg =
        getLoosestLegAboveThreshold(lepton, trigs1L, success);
    for (std::size_t leg :
         {trig2Lasym(0), trig2Lasym(1), trig2Lsym(), loosest1lepLeg}) {
      if (leg && aboveThreshold(lepton, leg)) {
        validLegs.insert(leg);
        efficiencies.emplace(leg, getCachedTriggerLegEfficiencies(
                                      lepton, runNumber, leg, success));
      } else
        efficiencies.emplace(leg, 0.);
    }
    if (!validLegs.size())
      continue;
 
    const auto sortedLegs = m_parent->getSortedLegs(lepton, validLegs, success);
    if (!success)
      return false;
    std::size_t loosestLeg = sortedLegs[0];
    std::size_t secondLoosestLeg = validLegs.size() >= 2 ? sortedLegs[1] : 0;
    std::size_t secondTightestLeg = validLegs.size() >= 3 ? sortedLegs[2] : 0;
    std::size_t tightestLeg = validLegs.size() >= 4 ? sortedLegs[3] : 0;
    std::size_t lambda124 =
        (loosestLeg != trig2Lasym(1)) ? loosestLeg : secondLoosestLeg;
    std::size_t lambda134 =
        (loosestLeg != trig2Lasym(0)) ? loosestLeg : secondLoosestLeg;
    std::size_t lambda234 =
        (loosestLeg != trig2Lsym()) ? loosestLeg : secondLoosestLeg;
    std::size_t lambda14 = (lambda124 != trig2Lasym(0))   ? lambda124
                           : (lambda134 != trig2Lasym(1)) ? lambda134
                                                          : secondTightestLeg;
    std::size_t lambda24 = (lambda124 != trig2Lsym())     ? lambda124
                           : (lambda234 != trig2Lasym(1)) ? lambda234
                                                          : secondTightestLeg;
    std::size_t lambda34 = (lambda134 != trig2Lsym())     ? lambda134
                           : (lambda234 != trig2Lasym(0)) ? lambda234
                                                          : secondTightestLeg;
    std::size_t tau13 = 0, tau12 = 0, tau23 = 0;
    if (loosestLeg == trig2Lsym() || loosestLeg == trig2Lasym(0))
      tau12 = (loosestLeg == trig2Lsym()) ? trig2Lasym(0) : trig2Lsym();
    else if (secondLoosestLeg == trig2Lsym() ||
             secondLoosestLeg == trig2Lasym(0))
      tau12 = (secondLoosestLeg == trig2Lsym()) ? trig2Lasym(0) : trig2Lsym();
    else if (secondTightestLeg == trig2Lsym() ||
             secondTightestLeg == trig2Lasym(0))
      tau12 = (secondTightestLeg == trig2Lsym()) ? trig2Lasym(0) : trig2Lsym();
    else if (tightestLeg == trig2Lsym() || tightestLeg == trig2Lasym(0))
      tau12 = (tightestLeg == trig2Lsym()) ? trig2Lasym(0) : trig2Lsym();
    if (loosestLeg == trig2Lsym() || loosestLeg == trig2Lasym(1))
      tau13 = (loosestLeg == trig2Lsym()) ? trig2Lasym(1) : trig2Lsym();
    else if (secondLoosestLeg == trig2Lsym() ||
             secondLoosestLeg == trig2Lasym(1))
      tau13 = (secondLoosestLeg == trig2Lsym()) ? trig2Lasym(1) : trig2Lsym();
    else if (secondTightestLeg == trig2Lsym() ||
             secondTightestLeg == trig2Lasym(1))
      tau13 = (secondTightestLeg == trig2Lsym()) ? trig2Lasym(1) : trig2Lsym();
    else if (tightestLeg == trig2Lsym() || tightestLeg == trig2Lasym(1))
      tau13 = (tightestLeg == trig2Lsym()) ? trig2Lasym(1) : trig2Lsym();
    if (loosestLeg == trig2Lasym(0) || loosestLeg == trig2Lasym(1))
      tau23 = (loosestLeg == trig2Lasym(0)) ? trig2Lasym(1) : trig2Lasym(0);
    else if (secondLoosestLeg == trig2Lasym(0) ||
             secondLoosestLeg == trig2Lasym(1))
      tau23 =
          (secondLoosestLeg == trig2Lasym(0)) ? trig2Lasym(1) : trig2Lasym(0);
    else if (secondTightestLeg == trig2Lasym(0) ||
             secondTightestLeg == trig2Lasym(1))
      tau23 =
          (secondTightestLeg == trig2Lasym(0)) ? trig2Lasym(1) : trig2Lasym(0);
    else if (tightestLeg == trig2Lasym(0) || tightestLeg == trig2Lasym(1))
      tau23 = (tightestLeg == trig2Lasym(0)) ? trig2Lasym(1) : trig2Lasym(0);

    globalEfficiencies =
        globalEfficiencies * ~efficiencies[loosestLeg] +
        efficiencies[loosest1lepLeg] +
        (efficiencies[tau13] - efficiencies[secondTightestLeg]) *
            ~singleInefficiencies[0] +
        (efficiencies[tau12] - efficiencies[secondTightestLeg]) *
            ~singleInefficiencies[1] +
        (efficiencies[tau23] - efficiencies[secondTightestLeg]) *
            efficiencies2Lsym[2];
    if (loosestLeg == trig2Lsym())
      globalEfficiencies +=
          (efficiencies[trig2Lsym()] - efficiencies[secondLoosestLeg]) *
          efficiencies2Lasym;
    else if (loosestLeg == trig2Lasym(1))
      globalEfficiencies +=
          (efficiencies[trig2Lasym(1)] - efficiencies[secondLoosestLeg]) *
          efficiencies2Lsym[0];
    else if (loosestLeg == trig2Lasym(0))
      globalEfficiencies +=
          (efficiencies[trig2Lasym(0)] - efficiencies[secondLoosestLeg]) *
          efficiencies2Lsym[1];
    if (secondTightestLeg &&
        tightestLeg == loosest1lepLeg)  
      globalEfficiencies +=
          (efficiencies[secondTightestLeg] - efficiencies[tightestLeg]) *
          ~singleInefficiencies[2];
 
    efficiencies2Lasym =
        ~efficiencies[loosestLeg] * efficiencies2Lasym + efficiencies[lambda14];
    if (loosestLeg == trig2Lasym(0) || loosestLeg == trig2Lasym(1)) {
      efficiencies2Lasym +=
          (efficiencies[loosestLeg] - efficiencies[secondLoosestLeg]) *
              ~singleInefficiencies[loosestLeg == trig2Lasym(0)] +
          (efficiencies[secondLoosestLeg] - efficiencies[lambda14]) *
              ~singleInefficiencies[2];
    }
    efficiencies2Lsym[0] = ~efficiencies[lambda124] * efficiencies2Lsym[0] +
                           efficiencies[lambda24];
    efficiencies2Lsym[1] = ~efficiencies[lambda134] * efficiencies2Lsym[1] +
                           efficiencies[lambda34];
    efficiencies2Lsym[2] = ~efficiencies[loosestLeg] * efficiencies2Lsym[2] +
                           efficiencies[lambda234];
    if (lambda124 == trig2Lsym())
      efficiencies2Lsym[0] +=
          (efficiencies[trig2Lsym()] - efficiencies[lambda24]) *
          ~singleInefficiencies[0];
    if (lambda134 == trig2Lsym())
      efficiencies2Lsym[1] +=
          (efficiencies[trig2Lsym()] - efficiencies[lambda34]) *
          ~singleInefficiencies[1];
    if (loosestLeg == trig2Lsym())
      efficiencies2Lsym[2] +=
          (efficiencies[trig2Lsym()] - efficiencies[lambda234]) *
          ~singleInefficiencies[2];
    singleInefficiencies[0] *= ~efficiencies[lambda124];
    singleInefficiencies[1] *= ~efficiencies[lambda134];
    singleInefficiencies[2] *= ~efficiencies[loosestLeg];
  }
  return success;
}

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 511 of file Calculator.cxx.

                                                  {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One2L() at line "
                << __LINE__);
  if (trig.symmetric())
    return globalEfficiency(leptons, runNumber, trig.to_symmetric(),
                            globalEfficiencies);
  globalEfficiencies = {0.};
  if (!trig)
    return true;
  Efficiencies singleInefficiencies[2] = {{1.}, {1.}},
               twoSingleInefficiencies = {1.};
  bool success = true;
  for (auto& lepton : leptons) {
    if (trig.irrelevantFor(lepton))
      continue;
    Efficiencies efficiencies[2] = {{0.}, {0.}};
    int loosest = 0;
    if (aboveThreshold(lepton, trig(0))) {
      efficiencies[0] =
          getCachedTriggerLegEfficiencies(lepton, runNumber, trig(0), success);
      if (aboveThreshold(lepton, trig(1))) {
        efficiencies[1] = getCachedTriggerLegEfficiencies(lepton, runNumber,
                                                          trig(1), success);
        loosest = m_parent->getLoosestLeg(lepton, trig(0), trig(1), success) ==
                  trig(1);
      }
    } else if (aboveThreshold(lepton, trig(1))) {
      efficiencies[1] =
          getCachedTriggerLegEfficiencies(lepton, runNumber, trig(1), success);
      loosest = 1;
    } else
      continue;
    const int tightest = 1 - loosest;
    globalEfficiencies = ~efficiencies[loosest] * globalEfficiencies +
                         (efficiencies[loosest] - efficiencies[tightest]) *
                             ~singleInefficiencies[tightest] +
                         efficiencies[tightest] * ~twoSingleInefficiencies;
    twoSingleInefficiencies *= ~efficiencies[loosest];
    for (int i = 0; i < 2; ++i)
      singleInefficiencies[i] *= ~efficiencies[i];
  }
  return success;
}

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 562 of file Calculator.cxx.

                              {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One2LSeveral1L() at line "
                << __LINE__);
  if (!(trigs1L1.size() + trigs1L2.size()))
    return globalEfficiency(leptons, runNumber, trig2Lmix, globalEfficiencies);
  if (trig2Lmix.hiddenBy(trigs1L1) || trig2Lmix.hiddenBy(trigs1L2))
    return globalEfficiency(leptons, runNumber, trigs1L1, trigs1L2,
                            globalEfficiencies);
  Efficiencies efficiencies[4];
  bool success =
      globalEfficiency(leptons, runNumber, trigs1L1, efficiencies[0]) &&
      globalEfficiency(leptons, runNumber, trigs1L2, efficiencies[1]) &&
      globalEfficiency(leptons, runNumber, trig2Lmix.addTo(trigs1L1),
                       efficiencies[2]) &&
      globalEfficiency(leptons, runNumber, trig2Lmix.addTo(trigs1L2),
                       efficiencies[3]);
  if (success) {
    globalEfficiencies = Efficiencies(1.) -
                         ~efficiencies[0] * ~efficiencies[1] +
                         (efficiencies[2] - efficiencies[0]) *
                             (efficiencies[3] - efficiencies[1]);
  } else
    globalEfficiencies = {0.};
  return success;
}

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 463 of file Calculator.cxx.

                                                {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One2L() at line "
                << __LINE__);
  Efficiencies efficiencies[2];
  bool success =
      globalEfficiency(leptons, runNumber, trig.side1(), efficiencies[0]) &&
      globalEfficiency(leptons, runNumber, trig.side2(), efficiencies[1]);
  if (success)
    globalEfficiencies = efficiencies[0] * efficiencies[1];
  else
    globalEfficiencies = {0.};
  return success;
}

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 619 of file Calculator.cxx.

                              {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One2LSeveral1L() at line "
                << __LINE__);
  if (!trigs1L.size())
    return globalEfficiency(leptons, runNumber, trig2L, globalEfficiencies);
  if (!trig2L || trig2L.hiddenBy(trigs1L))
    return globalEfficiency(leptons, runNumber, trigs1L, globalEfficiencies);
  globalEfficiencies = {0.};
  Efficiencies twoSingleInefficiencies = {1.};
  bool success = true;
  for (auto& lepton : leptons) {
    if (trig2L.irrelevantFor(lepton))
      continue;
    Efficiencies efficiencies1L(0.), efficiencies2L(0.);
    const Efficiencies* loosestLegEfficiency;
    std::size_t loosest1lepLeg =
        getLoosestLegAboveThreshold(lepton, trigs1L, success);
    if (loosest1lepLeg) {
      efficiencies1L = getCachedTriggerLegEfficiencies(lepton, runNumber,
                                                       loosest1lepLeg, success);
      if (aboveThreshold(lepton, trig2L())) {
        efficiencies2L = getCachedTriggerLegEfficiencies(lepton, runNumber,
                                                         trig2L(), success);
        loosestLegEfficiency =
            (m_parent->getLoosestLeg(lepton, trig2L(), loosest1lepLeg,
                                     success) == trig2L())
                ? &efficiencies2L
                : &efficiencies1L;
      } else
        loosestLegEfficiency = &efficiencies1L;
    } else if (aboveThreshold(lepton, trig2L())) {
      efficiencies2L =
          getCachedTriggerLegEfficiencies(lepton, runNumber, trig2L(), success);
      loosestLegEfficiency = &efficiencies2L;
    } else
      continue;
    globalEfficiencies =
        ~(*loosestLegEfficiency) * globalEfficiencies + efficiencies1L;
    if (loosestLegEfficiency == &efficiencies2L)
      globalEfficiencies +=
          ~twoSingleInefficiencies * (efficiencies2L - efficiencies1L);
    twoSingleInefficiencies *= ~(*loosestLegEfficiency);
  }
  return success;
}

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 750 of file Calculator.cxx.

                              {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Two2LSeveral1L() at line "
                << __LINE__);
  if (!trig2L1 || trig2L1 == trig2L2 || trig2L1.hiddenBy(trigs1L))
    return globalEfficiency(leptons, runNumber, trig2L2, trigs1L,
                            globalEfficiencies);
  if (!trig2L2 || trig2L2.hiddenBy(trigs1L))
    return globalEfficiency(leptons, runNumber, trig2L1, trigs1L,
                            globalEfficiencies);
  globalEfficiencies = {0.};
  Efficiencies singleInefficiencies{1.};
  Efficiencies efficiencies2Lsym[2] = {{0.}, {0.}};
 
  bool success = true;
  for (auto& lepton : leptons) {
    if (trig2L1.irrelevantFor(lepton))
      continue;
    flat_set<std::size_t> validLegs;
    std::map<std::size_t, Efficiencies> efficiencies{{0, 0.}};
    std::size_t loosest1lepLeg =
        getLoosestLegAboveThreshold(lepton, trigs1L, success);
    for (std::size_t leg : {loosest1lepLeg, trig2L1(), trig2L2()}) {
      if (leg && aboveThreshold(lepton, leg)) {
        validLegs.insert(leg);
        efficiencies.emplace(leg, getCachedTriggerLegEfficiencies(
                                      lepton, runNumber, leg, success));
      } else
        efficiencies.emplace(leg, 0.);
    }
    if (!validLegs.size())
      continue;
    auto looseLegs = m_parent->getTwoLoosestLegs(lepton, validLegs, success);
    std::size_t lambda13 =
        (looseLegs.first != trig2L2()) ? looseLegs.first : looseLegs.second;
    std::size_t lambda23 =
        (looseLegs.first != trig2L1()) ? looseLegs.first : looseLegs.second;
    globalEfficiencies = globalEfficiencies * ~efficiencies[looseLegs.first] +
                         efficiencies[loosest1lepLeg];
    if (looseLegs.first == trig2L1())
      globalEfficiencies +=
          efficiencies2Lsym[1] *
          (efficiencies[trig2L1()] - efficiencies[looseLegs.second]);
    if (looseLegs.first == trig2L2())
      globalEfficiencies +=
          efficiencies2Lsym[0] *
          (efficiencies[trig2L2()] - efficiencies[looseLegs.second]);
    if (looseLegs.first != loosest1lepLeg)
      globalEfficiencies +=
          ~singleInefficiencies *
          (efficiencies[looseLegs.second] - efficiencies[loosest1lepLeg]);
    efficiencies2Lsym[0] =
        ~efficiencies[looseLegs.first] * efficiencies2Lsym[0] +
        efficiencies[lambda23];
    efficiencies2Lsym[1] =
        ~efficiencies[looseLegs.first] * efficiencies2Lsym[1] +
        efficiencies[lambda13];
    if (looseLegs.first == trig2L1())
      efficiencies2Lsym[0] +=
          (efficiencies[trig2L1()] - efficiencies[lambda23]) *
          ~singleInefficiencies;
    if (looseLegs.first == trig2L2())
      efficiencies2Lsym[1] +=
          (efficiencies[trig2L2()] - efficiencies[lambda13]) *
          ~singleInefficiencies;
    singleInefficiencies *= ~efficiencies[looseLegs.first];
  }
  return success;
}

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 484 of file Calculator.cxx.

                                                {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One2L() at line "
                << __LINE__);
  globalEfficiencies = {0.};
  if (!trig)
    return true;
  Efficiencies singleInefficiencies(1.);
  bool success = true;
  for (auto& lepton : leptons) {
    if (trig.irrelevantFor(lepton) || !aboveThreshold(lepton, trig()))
      continue;
    auto efficiencies =
        getCachedTriggerLegEfficiencies(lepton, runNumber, trig(), success);
    globalEfficiencies = ~efficiencies * globalEfficiencies +
                         efficiencies * ~singleInefficiencies;
    singleInefficiencies *= ~efficiencies;
  }
  return success;
}

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 1034 of file Calculator.cxx.

                                                        {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One3L() at line "
                << __LINE__);
  if (trig.symmetric())
    return globalEfficiency(leptons, runNumber, trig.to_symmetric(),
                            globalEfficiencies);
  globalEfficiencies = {0.};
  Efficiencies singleInefficiencies[2] = {{1.}, {1.}},
               twoSingleInefficiencies{1.};
  Efficiencies efficiencies2Lsym{0.}, efficiencies2Lasym{0.},
      efficiencies2L2L{0.};
  bool success = true;
  for (auto& lepton : leptons) {
    if (trig.irrelevantFor(lepton))
      continue;
    Efficiencies efficiencies[2] = {{0.}, {0.}};
    const int asym = 0, sym = 1;
    int loosestLeg;
    if (aboveThreshold(lepton, trig.asymLeg())) {
      efficiencies[asym] = getCachedTriggerLegEfficiencies(
          lepton, runNumber, trig.asymLeg(), success);
      if (aboveThreshold(lepton, trig.symLeg())) {
        efficiencies[sym] = getCachedTriggerLegEfficiencies(
            lepton, runNumber, trig.symLeg(), success);
        loosestLeg =
            m_parent->getLoosestLeg(lepton, trig.asymLeg(), trig.symLeg(),
                                    success) == trig.asymLeg()
                ? asym
                : sym;
      } else
        loosestLeg = asym;
    } else if (aboveThreshold(lepton, trig.symLeg())) {
      efficiencies[sym] = getCachedTriggerLegEfficiencies(
          lepton, runNumber, trig.symLeg(), success);
      loosestLeg = sym;
    } else
      continue;
    Efficiencies delta = efficiencies[asym] - efficiencies[sym];
    if (loosestLeg == asym) {
      globalEfficiencies = ~efficiencies[asym] * globalEfficiencies +
                           efficiencies[sym] * efficiencies2L2L +
                           delta * efficiencies2Lsym;
      efficiencies2L2L = ~efficiencies[asym] * efficiencies2L2L +
                         efficiencies[sym] * ~twoSingleInefficiencies +
                         delta * ~singleInefficiencies[sym];
      efficiencies2Lasym = ~efficiencies[asym] * efficiencies2Lasym +
                           efficiencies[sym] * ~twoSingleInefficiencies +
                           delta * ~singleInefficiencies[sym];
    } else {
      globalEfficiencies = ~efficiencies[sym] * globalEfficiencies +
                           efficiencies[asym] * efficiencies2L2L -
                           delta * efficiencies2Lasym;
      efficiencies2L2L = ~efficiencies[sym] * efficiencies2L2L +
                         efficiencies[sym] * ~twoSingleInefficiencies;
      efficiencies2Lasym = ~efficiencies[sym] * efficiencies2Lasym +
                           efficiencies[asym] * ~twoSingleInefficiencies -
                           delta * ~singleInefficiencies[asym];
    }
    efficiencies2Lsym = ~efficiencies[sym] * efficiencies2Lsym +
                        efficiencies[sym] * ~singleInefficiencies[sym];
    twoSingleInefficiencies *= ~efficiencies[loosestLeg];
    singleInefficiencies[sym] *= ~efficiencies[sym];
    singleInefficiencies[asym] *= ~efficiencies[asym];
  }
  return success;
}

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 1343 of file Calculator.cxx.

                                                {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One3L() at line "
                << __LINE__);
  Efficiencies efficiencies[2] = {{0.}, {0.}};
  bool success = globalEfficiency(leptons, runNumber,
                                  trig.template side<Trig3Lmix::object1()>(),
                                  efficiencies[0]) &&
                 globalEfficiency(leptons, runNumber,
                                  trig.template side<Trig3Lmix::object2()>(),
                                  efficiencies[1]);
  globalEfficiencies = efficiencies[0] * efficiencies[1];
  return success;
}

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 1364 of file Calculator.cxx.

                              {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Two3L() at line "
                << __LINE__);
  Efficiencies efficiencies[6] = {{0.}, {0.}, {0.}, {0.}, {0.}, {0.}};
  auto trig2La = trig1.template side<Trig3Lmix1::object1()>();
  auto trig1La = trig2.template side<Trig3Lmix2::object2()>();
  bool success =
      globalEfficiency(leptons, runNumber, trig1La, efficiencies[0]) &&
      globalEfficiency(leptons, runNumber, trig2La, efficiencies[1]);
  if (!trig2La.hiddenBy(trig1La))
    success = success && globalEfficiency(leptons, runNumber, trig2La, trig1La,
                                          efficiencies[2]);
  else
    efficiencies[2] = efficiencies[0];
  auto trig2Lb = trig2.template side<Trig3Lmix2::object1()>();
  auto trig1Lb = trig1.template side<Trig3Lmix1::object2()>();
  success = success &&
            globalEfficiency(leptons, runNumber, trig1Lb, efficiencies[3]) &&
            globalEfficiency(leptons, runNumber, trig2Lb, efficiencies[4]);
  if (!trig2Lb.hiddenBy(trig1Lb))
    success = success && globalEfficiency(leptons, runNumber, trig2Lb, trig1Lb,
                                          efficiencies[5]);
  else
    efficiencies[5] = efficiencies[3];
  globalEfficiencies =
      efficiencies[0] * efficiencies[4] + efficiencies[3] * efficiencies[1] +
      (efficiencies[2] - efficiencies[0] - efficiencies[1]) *
          (efficiencies[3] + efficiencies[4] - efficiencies[5]);
  return success;
}

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 1007 of file Calculator.cxx.

                                                {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One3L() at line "
                << __LINE__);
  globalEfficiencies = {0.};
  Efficiencies singleInefficiencies{1.}, efficiencies2L{0.};
  bool success = true;
  for (auto& lepton : leptons) {
    if (trig.irrelevantFor(lepton) || !aboveThreshold(lepton, trig()))
      continue;
    auto efficiencies =
        getCachedTriggerLegEfficiencies(lepton, runNumber, trig(), success);
    globalEfficiencies =
        ~efficiencies * globalEfficiencies + efficiencies * efficiencies2L;
    efficiencies2L =
        ~efficiencies * efficiencies2L + efficiencies * ~singleInefficiencies;
    singleInefficiencies *= ~efficiencies;
  }
  return success;
}

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 1406 of file Calculator.cxx.

                                                {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_One4L() at line "
                << __LINE__);
  globalEfficiencies = {0.};
  Efficiencies singleInefficiencies{1.}, efficiencies2L{0.}, efficiencies3L{0.};
  bool success = true;
  for (auto& lepton : leptons) {
    if (trig.irrelevantFor(lepton) || !aboveThreshold(lepton, trig()))
      continue;
    auto efficiencies =
        getCachedTriggerLegEfficiencies(lepton, runNumber, trig(), success);
    globalEfficiencies =
        ~efficiencies * globalEfficiencies + efficiencies * efficiencies3L;
    efficiencies3L =
        ~efficiencies * efficiencies3L + efficiencies * efficiencies2L;
    efficiencies2L =
        ~efficiencies * efficiencies2L + efficiencies * ~singleInefficiencies;
    singleInefficiencies *= ~efficiencies;
  }
  return success;
}

globalEfficiency_Factorized2()

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

private

Definition at line 1431 of file Calculator.cxx.

                                                         {
  Efficiencies efficiencies[2];
  if (!func1(this, leptons, runNumber, efficiencies[0]))
    return false;
  if (!func2(this, leptons, runNumber, efficiencies[1]))
    return false;
  globalEfficiencies = ~(~efficiencies[0] * ~efficiencies[1]);
  return true;
}

globalEfficiency_Factorized3()

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

private

Definition at line 1443 of file Calculator.cxx.

                                                                            {
  Efficiencies efficiencies[3];
  if (!func1(this, leptons, runNumber, efficiencies[0]))
    return false;
  if (!func2(this, leptons, runNumber, efficiencies[1]))
    return false;
  if (!func3(this, leptons, runNumber, efficiencies[2]))
    return false;
  globalEfficiencies =
      ~(~efficiencies[0] * ~efficiencies[1] * ~efficiencies[2]);
  return true;
}

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 1524 of file Calculator.cxx.

                                                                         {
  ATH_MSG_DEBUG("Entered Calculator::globalEfficiency_Toys() at line "
                << __LINE__);
  globalEfficiencies = {0.};
  if (m_parent->m_numberOfToys <= 0) {
    ATH_MSG_ERROR("The specified number of toys is <= 0");
    return false;
  }
  std::map<const Lepton*, std::vector<std::pair<std::size_t, Efficiencies>>>
      leptonEfficiencies;
  for (auto& lepton : leptons) {
    flat_set<std::size_t> validLegs;
    if (!fillListOfLegsFor(lepton, triggers, validLegs))
      return false;
    auto& efficiencies = leptonEfficiencies[&lepton];
    const int nLegs = validLegs.size();
    if (nLegs) {
      bool success = true;
      for (std::size_t leg :
           m_parent->getSortedLegs(lepton, validLegs, success)) {
        efficiencies.emplace_back(leg, getCachedTriggerLegEfficiencies(
                                           lepton, runNumber, leg, success));
      }
      if (!success)
        return false;
    }
  }
  unsigned long seed;
  if (!m_parent->m_useInternalSeed) {
    if (!m_parent->retrieveEventNumber(seed)) {
      ATH_MSG_WARNING("Will use internal seed instead of event number");
      seed = m_parent->m_seed++;
    }
  } else
    seed = m_parent->m_seed++;
  std::mt19937_64 randomEngine(seed);
  std::uniform_real_distribution<double> uniformPdf(0., 1.);
  std::vector<flat_set<std::size_t>> firedLegs(leptonEfficiencies.size());
  unsigned long nPassed[2] = {0, 0};
  for (unsigned long toy = 0; toy < m_parent->m_numberOfToys; ++toy) {
    for (int step = 0; step < 2; ++step)  
    {
      auto legs = firedLegs.begin();
      for (auto& kv : leptonEfficiencies) {
        legs->clear();
        double x = uniformPdf(randomEngine);
        for (auto& p : kv.second) {
          if (x < (step ? p.second.mc() : p.second.data()))
            legs->emplace(p.first);
        }
        ++legs;
      }
      for (auto& trig : triggers) {
        if (!canTriggerBeFired(trig, firedLegs))
          continue;
        ++nPassed[step];
        break;
      }
    }
  }
  globalEfficiencies.data() =
      double(nPassed[0]) / double(m_parent->m_numberOfToys);
  globalEfficiencies.mc() =
      double(nPassed[1]) / double(m_parent->m_numberOfToys);
  return true;
}

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.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

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.

                                      {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg();
#else // not XAOD_STANDALONE
      return m_msg;
#endif // not XAOD_STANDALONE
   }

msg() [2/2]

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

inherited

The standard message stream.

Parameters

lvl	The 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.

                                                          {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg( lvl );
#else // not XAOD_STANDALONE
      m_msg << lvl;
      return m_msg;
#endif // not XAOD_STANDALONE
   }

msgLvl()

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

inherited

Test the output level of the object.

Parameters

lvl	The 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.

                                                       {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msgLvl( lvl );
#else // not XAOD_STANDALONE
      return m_msg.msgLevel( lvl );
#endif // not XAOD_STANDALONE
   }

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.

{
  m_lvl = lvl;
}

Friends And Related Symbol Documentation

CheckConfig

friend class CheckConfig

friend

Definition at line 320 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 71 of file Calculator.h.

m_forceUnitSF

bool TrigGlobEffCorr::Calculator::m_forceUnitSF

private

Definition at line 72 of file Calculator.h.

m_imsg

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

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_lvl

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

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

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 66 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 69 of file Calculator.h.

---

The documentation for this class was generated from the following files:

• Calculator.h
• Calculator.cxx