TrigGlobalEfficiencyCorrectionTool Class Reference

#include <TrigGlobalEfficiencyCorrectionTool.h>

Inheritance diagram for TrigGlobalEfficiencyCorrectionTool:

Classes
struct	Hierarchy
struct	TagDecorator
struct	CachedRanking
struct	ToolKey

Public Member Functions
virtual ASG_TOOL_CLASS(TrigGlobalEfficiencyCorrectionTool, ITrigGlobalEfficiencyCorrectionTool) TrigGlobalEfficiencyCorrectionTool(const std	~TrigGlobalEfficiencyCorrectionTool ()
virtual StatusCode	initialize () override
	Dummy implementation of the initialisation function.
virtual CP::CorrectionCode	getEfficiencyScaleFactor (const std::vector< const xAOD::IParticle * > &particles, double &efficiencyScaleFactor) override
virtual CP::CorrectionCode	getEfficiencyScaleFactor (unsigned runNumber, const std::vector< const xAOD::IParticle * > &particles, double &efficiencyScaleFactor) override
	These should in principle not be used (except by unit tests), as the CP tools require the EventInfo decoration "RandomRunNumber" to be present.
virtual CP::CorrectionCode	getEfficiency (const std::vector< const xAOD::IParticle * > &particles, double &efficiencyData, double &efficiencyMc) override
virtual CP::CorrectionCode	getEfficiency (unsigned runNumber, const std::vector< const xAOD::IParticle * > &particles, double &efficiencyData, double &efficiencyMc) override
virtual bool	isAffectedBySystematic (const CP::SystematicVariation &systematic) const override
	Declare the interface that this class provides.
virtual CP::SystematicSet	affectingSystematics () const override
	the list of all systematics this tool can be affected by
virtual CP::SystematicSet	recommendedSystematics () const override
	the list of all systematics this tool recommends to use
virtual StatusCode	applySystematicVariation (const CP::SystematicSet &systConfig) override
	effects: configure this tool for the given list of systematic variations.
virtual CP::CorrectionCode	checkTriggerMatching (bool &matched, const std::vector< const xAOD::IParticle * > &particles) override
virtual CP::CorrectionCode	checkTriggerMatching (std::unordered_map< std::string, bool > &matched_per_trigger, const std::vector< const xAOD::IParticle * > &particles) override
virtual CP::CorrectionCode	getRelevantTriggers (std::vector< std::string > &triggers) override
	This will fill the 'triggers' argument with the names of the triggers relevant for the current run number, among those specified in the tool configuration.
virtual CP::CorrectionCode	countTriggerLegs (const std::string &trigger, std::size_t &numberOfLegs) override
	This utility function provides the number of legs for the specified trigger.
template<class CPTool>
bool	enumerateTools (ImportData &data, ToolHandleArray< CPTool > &suppliedTools, std::map< ToolKey, std::size_t > &toolIndex, flat_set< std::size_t > &collectedTags)
virtual void	print () const
	Print the state of the tool.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const
template<typename... Args>
auto	getEfficiencyScaleFactor (Args &... args) -> std::enable_if_t< validArgs< Args... >(1), CP::CorrectionCode >
	Alternatively, the list of particles can be supplied via one or several vectors of xAOD::Electron*‍/Muon*‍/Photon* The generic signature is getEfficiencyScaleFactor((const) vector<(const)Type1*>&, ..., (const) vector<(const)TypeN*>&, double& efficiencyScaleFactor) e.g.
template<typename... Args>
auto	getEfficiency (Args &... args) -> std::enable_if_t< validArgs< Args... >(2), CP::CorrectionCode >
template<typename BoolOrMap, typename... Args>
auto	checkTriggerMatching (BoolOrMap &matched, Args &... args) -> std::enable_if_t< validArgs< Args... >(0), CP::CorrectionCode >
Additional helper functions, not directly mimicking Athena
template<class T>
const T *	getProperty (const std::string &name) const
	Get one of the tool's properties.
const std::string &	msg_level_name () const __attribute__((deprecated))
	A deprecated function for getting the message level's name.
const std::string &	getName (const void *ptr) const
	Get the name of an object that is / should be in the event store.
SG::sgkey_t	getKey (const void *ptr) const
	Get the (hashed) key of an object that is in the event store.

Static Public Member Functions
static CP::CorrectionCode	suggestElectronMapKeys (const std::map< std::string, std::string > &triggerCombination, const std::string &version, std::map< std::string, std::string > &legsPerKey)
static CP::CorrectionCode	suggestPhotonMapKeys (const std::map< std::string, std::string > &triggerCombination, const std::string &version, std::map< std::string, std::string > &legsPerKey)
static CP::CorrectionCode	suggestEgammaMapKeys (const std::map< std::string, std::string > &triggerCombination, const std::string &version, std::map< std::string, std::string > &legsPerKey, xAOD::Type::ObjectType type)
template<typename Arg>
static constexpr bool	validArgs (unsigned nTrailingDoubles)
template<typename Arg1, typename Arg2, typename... OtherArgs>
static constexpr bool	validArgs (unsigned nTrailingDoubles)
static std::string	toolnameForDefaultScaleFactor ()
	To be used with the ListOfLegsPerTool property:

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.
double *	handleArg (double &arg, std::vector< const xAOD::IParticle * > &)
template<typename P>
double *	handleArg (const std::vector< P > &arg, std::vector< const xAOD::IParticle * > &particles)

Private Types
enum	TLE_RESULT { TLE_OK , TLE_UNAVAILABLE , TLE_ERROR }
using	LeptonList = std::vector<TrigGlobEffCorr::Lepton>
template<typename Key>
using	flat_set = std::flat_set<Key>
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
bool	loadHierarchies ()
	Internal methods (I) – initialization of the tool.
template<class CPTool>
bool	enumerateTools (TrigGlobEffCorr::ImportData &data, ToolHandleArray< CPTool > &suppliedTools, std::map< ToolKey, std::size_t > &toolIndex, flat_set< std::size_t > &collectedTags)
flat_set< ToolKey >	parseListOfLegs (TrigGlobEffCorr::ImportData &data, const std::string &inputList, bool &success)
bool	parseTagString (const std::string &tagstring, flat_set< std::size_t > &tags)
bool	loadTriggerCombination (TrigGlobEffCorr::ImportData &data, bool useDefaultElectronTools, bool useDefaultPhotonTools)
bool	loadTagDecorators (const flat_set< std::size_t > &collectedElectronTags, const flat_set< std::size_t > &collectedMuonTags, const flat_set< std::size_t > &collectedPhotonTags)
bool	loadListOfLegsPerTag ()
bool	processDeprecatedProperties ()
bool	retrieveRunNumber (unsigned &runNumber)
	Internal methods (II) – core task.
bool	retrieveEventNumber (unsigned long &eventNumber)
bool	aboveThreshold (const TrigGlobEffCorr::Lepton &p, std::size_t leg) const
template<class... ListOfLegs>
unsigned long	getCachedTriggerLegsRanking (const TrigGlobEffCorr::Lepton &lepton, ListOfLegs... legs)
std::size_t	getLoosestLegAboveThreshold (const TrigGlobEffCorr::Lepton &lepton, const flat_set< std::size_t > &legs, bool &success)
std::size_t	getLoosestLeg (const TrigGlobEffCorr::Lepton &lepton, std::size_t leg1, std::size_t leg2, bool &success)
std::pair< std::size_t, std::size_t >	getTwoLoosestLegs (const TrigGlobEffCorr::Lepton &lepton, const flat_set< std::size_t > &legs, bool &success)
std::vector< std::size_t >	getSortedLegs (const TrigGlobEffCorr::Lepton &lepton, const flat_set< std::size_t > &legs, bool &success)
template<class Container>
CachedRanking	rankTriggerLegs (float pt, const Container &legs)
template<class Particle>
bool	updateLeptonList (LeptonList &leptons, const std::vector< const Particle * > &particles)
void	updateMuonTriggerNames (std::size_t leg, const std::string &name)
TLE_RESULT	getTriggerLegEfficiencies (const xAOD::Electron *p, unsigned runNumber, std::size_t leg, std::size_t tag, TrigGlobEffCorr::Efficiencies &efficiencies)
TLE_RESULT	getTriggerLegEfficiencies (const xAOD::Muon *p, unsigned runNumber, std::size_t leg, std::size_t tag, TrigGlobEffCorr::Efficiencies &efficiencies)
TLE_RESULT	getTriggerLegEfficiencies (const xAOD::Photon *p, unsigned runNumber, std::size_t leg, std::size_t tag, TrigGlobEffCorr::Efficiencies &efficiencies)
template<class ParticleType>
TLE_RESULT	getEgammaTriggerLegEfficiencies (const ParticleType *p, unsigned runNumber, std::size_t leg, std::size_t tag, TrigGlobEffCorr::Efficiencies &efficiencies)
decltype(m_electronSfToolIndex) &	GetScaleFactorToolIndex (const xAOD::Electron *)
decltype(m_photonSfToolIndex) &	GetScaleFactorToolIndex (const xAOD::Photon *)
decltype(m_electronEffToolIndex) &	GetEfficiencyToolIndex (const xAOD::Electron *)
decltype(m_photonEffToolIndex) &	GetEfficiencyToolIndex (const xAOD::Photon *)
IAsgElectronEfficiencyCorrectionTool &	GetScaleFactorTool (const xAOD::Electron *, std::size_t index)
IAsgPhotonEfficiencyCorrectionTool &	GetScaleFactorTool (const xAOD::Photon *, std::size_t index)
IAsgElectronEfficiencyCorrectionTool &	GetEfficiencyTool (const xAOD::Electron *, std::size_t index)
IAsgPhotonEfficiencyCorrectionTool &	GetEfficiencyTool (const xAOD::Photon *, std::size_t index)
std::size_t	getCombinedHash (const flat_set< std::size_t > &legs)
std::size_t	getCombinedHash (std::size_t leg1, std::size_t leg2)
bool	checkAndRecord (CP::CorrectionCode &&cc)
	Internal methods (III) – misc. helpers.
flat_set< std::size_t >	listNonOrderedCSValues (const std::string &s, bool &success)
	Parses the input string (comma-separated list) and returns a set of hashes Watch out: since a flat_set is returned, the order of the entries in the input list is not preserved, as hinted by the name of the function.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Static Private Member Functions
static constexpr const flat_set< std::size_t > &	forwardLegs (const flat_set< std::size_t > &legs)
static constexpr std::array< std::size_t, 2 >	forwardLegs (std::size_t leg1, std::size_t leg2)

Private Attributes
ToolHandleArray< IAsgElectronEfficiencyCorrectionTool >	m_suppliedElectronEfficiencyTools
	Properties:
ToolHandleArray< IAsgElectronEfficiencyCorrectionTool >	m_suppliedElectronScaleFactorTools
ToolHandleArray< IAsgPhotonEfficiencyCorrectionTool >	m_suppliedPhotonEfficiencyTools
ToolHandleArray< IAsgPhotonEfficiencyCorrectionTool >	m_suppliedPhotonScaleFactorTools
ToolHandleArray< CP::IMuonTriggerScaleFactors >	m_suppliedMuonTools
std::map< std::string, std::string >	m_legsPerTool
std::map< std::string, std::string >	m_triggerCb
std::map< std::string, std::string >	m_triggerCbPerYear
std::string	m_leptonTagDecorations
std::map< std::string, std::string >	m_tagsPerTool
std::map< std::string, std::string >	m_electronLegsPerTag
std::map< std::string, std::string >	m_muonLegsPerTag
	deprecated
std::map< std::string, std::string >	m_legsPerTag
	deprecated
std::map< std::string, std::string >	m_overrideThresholds
unsigned long	m_numberOfToys {}
bool	m_useInternalSeed {}
ToolHandle< Trig::IMatchingTool >	m_trigMatchTool
std::hash< std::string >	m_hasher
std::map< std::size_t, float >	m_thresholds
std::multimap< std::size_t, CachedRanking >	m_cachedLegRankings
std::map< ToolKey, std::size_t >	m_electronSfToolIndex
std::map< ToolKey, std::size_t >	m_electronEffToolIndex
std::map< ToolKey, std::size_t >	m_photonSfToolIndex
std::map< ToolKey, std::size_t >	m_photonEffToolIndex
std::map< ToolKey, std::size_t >	m_muonToolIndex
std::set< std::size_t >	m_validLegTagPairs
bool	m_checkElectronLegTag {}
bool	m_checkMuonLegTag {}
bool	m_checkPhotonLegTag {}
std::map< std::size_t, std::string >	m_dictionary
std::set< ToolKey >	m_unsupportedLegs
std::vector< Hierarchy >	m_hierarchyMeta
std::vector< std::size_t >	m_hierarchyData
bool	m_initialized = false
CP::CorrectionCode	m_cpCode = CP::CorrectionCode::Ok
unsigned long	m_seed {}
bool	m_validTrigMatchTool
std::vector< TagDecorator >	m_leptonTagDecorators
SG::AuxElement::ConstAccessor< unsigned int >	m_runNumberDecorator
std::unique_ptr< TrigGlobEffCorr::Calculator >	m_calculator
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Friends
class	TrigGlobEffCorr::ImportData
class	TrigGlobEffCorr::CheckConfig
class	TrigGlobEffCorr::Calculator

Detailed Description

Definition at line 35 of file TrigGlobalEfficiencyCorrectionTool.h.

Member Typedef Documentation

flat_set

template<typename Key>

using TrigGlobalEfficiencyCorrectionTool::flat_set = std::flat_set<Key>

private

Definition at line 196 of file TrigGlobalEfficiencyCorrectionTool.h.

LeptonList

using TrigGlobalEfficiencyCorrectionTool::LeptonList = std::vector<TrigGlobEffCorr::Lepton>

private

Definition at line 143 of file TrigGlobalEfficiencyCorrectionTool.h.

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

TLE_RESULT

enum TrigGlobalEfficiencyCorrectionTool::TLE_RESULT

private

Enumerator
TLE_OK
TLE_UNAVAILABLE
TLE_ERROR

Definition at line 243 of file TrigGlobalEfficiencyCorrectionTool.h.

{ TLE_OK, TLE_UNAVAILABLE, TLE_ERROR };

Constructor & Destructor Documentation

~TrigGlobalEfficiencyCorrectionTool()

TrigGlobalEfficiencyCorrectionTool::~TrigGlobalEfficiencyCorrectionTool ( )

virtual

Definition at line 106 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                                                        {
  m_cpCode.ignore();
}

Member Function Documentation

aboveThreshold()

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

private

Definition at line 1020 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                                                             {
  bool decision = (lepton.pt() >= m_thresholds.at(leg));
  if (m_validLegTagPairs.size()) {
    if ((lepton.type() == xAOD::Type::Electron && m_checkElectronLegTag) ||
        (lepton.type() == xAOD::Type::Muon && m_checkMuonLegTag) ||
        (lepton.type() == xAOD::Type::Photon && m_checkPhotonLegTag)) {
      decision = decision && (m_validLegTagPairs.find(leg ^ lepton.tag()) !=
                              m_validLegTagPairs.end());
    }
  }
  ATH_MSG_DEBUG("Lepton " << lepton.particle() << " (pt=" << lepton.pt()
                          << ") is " << (decision ? "" : "not ")
                          << "considered suitable for firing trigger leg "
                          << m_dictionary.at(leg));
  return decision;
}

affectingSystematics()

CP::SystematicSet TrigGlobalEfficiencyCorrectionTool::affectingSystematics ( ) const

overridevirtual

the list of all systematics this tool can be affected by

Implements CP::IReentrantSystematicsTool.

Definition at line 1232 of file TrigGlobalEfficiencyCorrectionTool.cxx.

          {
  return CP::SystematicSet();
}

applySystematicVariation()

StatusCode TrigGlobalEfficiencyCorrectionTool::applySystematicVariation ( const CP::SystematicSet & systConfig )

overridevirtual

effects: configure this tool for the given list of systematic variations.

any requested systematics that are not affecting this tool will be silently ignored (unless they cause other errors). failures: systematic unknown failures: requesting multiple variations on the same systematic (e.g. up & down) failures: requesting an unsupported variation on an otherwise supported systematic (e.g. a 2 sigma variation and the tool only supports 1 sigma variations) failures: unsupported combination of supported systematic failures: other tool specific errors

Implements CP::ISystematicsTool.

Definition at line 1242 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                       {
  for (auto&& t : m_suppliedElectronEfficiencyTools)
    ANA_CHECK(t->applySystematicVariation(systematic));
  for (auto&& t : m_suppliedElectronScaleFactorTools)
    ANA_CHECK(t->applySystematicVariation(systematic));
  for (auto&& t : m_suppliedPhotonEfficiencyTools)
    ANA_CHECK(t->applySystematicVariation(systematic));
  for (auto&& t : m_suppliedPhotonScaleFactorTools)
    ANA_CHECK(t->applySystematicVariation(systematic));
  for (auto&& t : m_suppliedMuonTools)
    ANA_CHECK(t->applySystematicVariation(systematic));
 
  return StatusCode::SUCCESS;
}

checkAndRecord()

bool TrigGlobalEfficiencyCorrectionTool::checkAndRecord ( CP::CorrectionCode && cc )

inlineprivate

Internal methods (III) – misc. helpers.

Definition at line 637 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                           {
  cc.setChecked();
  if (cc > m_cpCode)
    m_cpCode = cc;
  return cc == CP::CorrectionCode::Ok;
}

checkTriggerMatching() [1/3]

template<typename BoolOrMap, typename... Args>

auto ITrigGlobalEfficiencyCorrectionTool::checkTriggerMatching ( BoolOrMap & matched, Args &... args ) -> std::enable_if_t< validArgs< Args... >(0), CP::CorrectionCode >

inherited

Definition at line 111 of file ITrigGlobalEfficiencyCorrectionTool.h.

{
    std::vector<const xAOD::IParticle*> particles;
    double* eff[] __attribute__((unused)) = { nullptr, handleArg(args, particles)... };
    return checkTriggerMatching(matched, particles);
}

checkTriggerMatching() [2/3]

CP::CorrectionCode TrigGlobalEfficiencyCorrectionTool::checkTriggerMatching ( bool & matched, const std::vector< const xAOD::IParticle * > & particles )

overridevirtual

Implements ITrigGlobalEfficiencyCorrectionTool.

Definition at line 924 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                                      {
  unsigned runNumber;
  if (!retrieveRunNumber(runNumber)) {
    ATH_MSG_ERROR(
        "Unable to retrieve run number, aborting checkTriggerMatching()");
    return CP::CorrectionCode::Error;
  }
  if (!m_validTrigMatchTool) {
    ATH_MSG_ERROR(
        "A valid IMatchingTool instance should be provided via the property "
        "'TriggerMatchingTool'");
    return CP::CorrectionCode::Error;
  }
  LeptonList leptons;
  updateLeptonList(leptons, particles);
  return m_calculator->checkTriggerMatching(*this, matched, nullptr, leptons, runNumber)
             ? CP::CorrectionCode::Ok
             : CP::CorrectionCode::Error;
}

checkTriggerMatching() [3/3]

CP::CorrectionCode TrigGlobalEfficiencyCorrectionTool::checkTriggerMatching ( std::unordered_map< std::string, bool > & matched_per_trigger, const std::vector< const xAOD::IParticle * > & particles )

overridevirtual

Implements ITrigGlobalEfficiencyCorrectionTool.

Definition at line 946 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                                      {
  unsigned runNumber;
  if (!retrieveRunNumber(runNumber)) {
    ATH_MSG_ERROR(
        "Unable to retrieve run number, aborting checkTriggerMatching()");
    return CP::CorrectionCode::Error;
  }
  if (!m_validTrigMatchTool) {
    ATH_MSG_ERROR(
        "A valid IMatchingTool instance should be provided via the property "
        "'TriggerMatchingTool'");
    return CP::CorrectionCode::Error;
  }
  LeptonList leptons;
  updateLeptonList(leptons, particles);
  bool flag;
  return m_calculator->checkTriggerMatching(*this, flag, &matched_per_trigger, leptons, runNumber)
             ? CP::CorrectionCode::Ok
             : CP::CorrectionCode::Error;
}

countTriggerLegs()

CP::CorrectionCode TrigGlobalEfficiencyCorrectionTool::countTriggerLegs ( const std::string & trigger, std::size_t & numberOfLegs )

overridevirtual

This utility function provides the number of legs for the specified trigger.

this abuses a little the role of the dictionary to act as a cache: for the key chosen as the trigger name hash XORed with the magic number, the mapped value is not the name of the trigger, but a meaningless string whose size equals the number of legs

Implements ITrigGlobalEfficiencyCorrectionTool.

Definition at line 982 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                                       {
  numberOfLegs = 0;
  constexpr std::size_t magic = 0xa3bad03e613527c9;
  const std::size_t name = m_hasher(trigger), key = name ^ magic;
  std::string& value = m_dictionary[key];
  if (!value.length()) {
    ImportData data;
    if (!data.importTriggers())
      return CP::CorrectionCode::Error;
    auto itr = data.getTriggerDefs().find(name);
    if (itr == data.getTriggerDefs().end()) {
      m_dictionary.erase(key);
      ATH_MSG_ERROR("The trigger " << trigger << " is not recognized");
      return CP::CorrectionCode::Error;
    }
    auto type = itr->second.type;
    using TrigGlobEffCorr::TriggerType;
    if (type & TriggerType::TT_SINGLELEPTON_FLAG)
      value = "~";
    else if (type & TriggerType::TT_DILEPTON_FLAG)
      value = "~~";
    else if (type & TriggerType::TT_TRILEPTON_FLAG)
      value = "~~~";
    else {
      m_dictionary.erase(key);
      ATH_MSG_ERROR("Unrecognized trigger type, implementation must be fixed!");
      return CP::CorrectionCode::Error;
    }
  }
  numberOfLegs = value.length();
  return CP::CorrectionCode::Ok;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

enumerateTools() [1/2]

template<class CPTool>

bool TrigGlobalEfficiencyCorrectionTool::enumerateTools	(	ImportData &	data,
		ToolHandleArray< CPTool > &	suppliedTools,
		std::map< ToolKey, std::size_t > &	toolIndex,
		flat_set< std::size_t > &	collectedTags )

Find the legs associated to this tool ("ListOfLegsPerTool" property)

Find the tags associated to this tool ("ListOfTagsPerTool" property)

Store

Definition at line 250 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                        {
  bool success = true;
  for (unsigned index = 0; index < suppliedTools.size(); ++index) {
    auto& handle = suppliedTools[index];
    const std::string& name = handle.name();
    const std::string& altname = handle->name();  // athena: not always the same
    flat_set<ToolKey> listOfLegs;
    if (suppliedTools.size() != 1 || m_legsPerTool.size() != 0) {
      auto itrLegs = m_legsPerTool.find(name);
      if (itrLegs == m_legsPerTool.end())
        itrLegs = m_legsPerTool.find(altname);
      if (itrLegs != m_legsPerTool.end()) {
        listOfLegs = parseListOfLegs(data, itrLegs->second, success);
        if (!success) {
          ATH_MSG_ERROR(
              "The 'ListOfLegsPerTool' property has an invalid entry for the "
              "tool'"
              << name << "'");
          continue;
        }
      } else if (std::is_same<CPTool,
                              IAsgElectronEfficiencyCorrectionTool>::value ||
                 std::is_same<CPTool,
                              IAsgPhotonEfficiencyCorrectionTool>::value) {
        ATH_MSG_ERROR("Property 'ListOfLegsPerTool' empty for tool '" << name
                                                                      << "'");
        success = false;
        continue;
      } else {
        listOfLegs.emplace();
      }
    } else
      listOfLegs.emplace();
    flat_set<std::size_t> tags;
    auto itrTags = m_tagsPerTool.find(name);
    if (itrTags == m_tagsPerTool.end())
      itrTags = m_tagsPerTool.find(altname);
    if (itrTags != m_tagsPerTool.end()) {
      success = success && parseTagString(itrTags->second, tags);
      collectedTags.insert(tags.begin(), tags.end());
    } else
      tags.emplace(0);

    unsigned short nUncheckedLegs = 0;
    for (auto& key : listOfLegs) {
      std::size_t leg = key.hash;
      if (leg) {
        auto flavour = data.associatedLeptonFlavour(leg, success);
        if (!(flavour == xAOD::Type::Electron &&
              std::is_same<CPTool,
                           IAsgElectronEfficiencyCorrectionTool>::value) &&
            !(flavour == xAOD::Type::Photon &&
              std::is_same<CPTool,
                           IAsgPhotonEfficiencyCorrectionTool>::value)) {
          ATH_MSG_ERROR("Unexpected association of trigger leg '"
                        << m_dictionary[leg] << "' to tool '" << name << "'");
          success = false;
        }
      }
      for (std::size_t tag : tags) {
        if (!toolIndex.emplace(ToolKey(leg, tag, key.boundaries), index)
                 .second) {
          if (leg && tag)
            ATH_MSG_ERROR("Multiple tools associated to the selection tag '"
                          << m_dictionary[tag] << "' for the trigger leg '"
                          << m_dictionary[leg] << "'");
          else if (leg)
            ATH_MSG_ERROR("Multiple tools associated to the trigger leg '"
                          << m_dictionary[leg] << "'");
          else if (tag)
            ATH_MSG_ERROR("Multiple tools associated to the selection tag '"
                          << m_dictionary[tag] << "'");
          else
            ATH_MSG_ERROR(
                "Multiple tools not associated to any trigger leg / selection "
                "tag");
          success = false;
        }
      }
      ++nUncheckedLegs;
    }
    if (!nUncheckedLegs) {
      ATH_MSG_ERROR("Tool " << name
                            << " hasn't been associated to any trigger leg");
      success = false;
    }
  }
  return success;
}

enumerateTools() [2/2]

template<class CPTool>

bool TrigGlobalEfficiencyCorrectionTool::enumerateTools ( TrigGlobEffCorr::ImportData & data, ToolHandleArray< CPTool > & suppliedTools, std::map< ToolKey, std::size_t > & toolIndex, flat_set< std::size_t > & collectedTags )

private

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

forwardLegs() [1/2]

auto TrigGlobalEfficiencyCorrectionTool::forwardLegs ( const flat_set< std::size_t > & legs )

inlinestaticconstexprprivate

Definition at line 1054 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                                                   {
  return legs;
}

forwardLegs() [2/2]

std::array< std::size_t, 2 > TrigGlobalEfficiencyCorrectionTool::forwardLegs ( std::size_t leg1, std::size_t leg2 )

inlinestaticconstexprprivate

Definition at line 1060 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                                                {
  if (leg1 < leg2)
    return {leg1, leg2};
  else
    return {leg2, leg1};
}

getCachedTriggerLegsRanking()

template<class... ListOfLegs>

unsigned long TrigGlobalEfficiencyCorrectionTool::getCachedTriggerLegsRanking ( const TrigGlobEffCorr::Lepton & lepton, ListOfLegs... legs )

private

Definition at line 1069 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                              {
  auto combinedHash = getCombinedHash(legs...);
  if (!combinedHash)
    return 0xFEDCBA9876543210;  // only one (distinct) leg
  auto cachedRankings = m_cachedLegRankings.equal_range(combinedHash);
  auto rankingItr = cachedRankings.first;
  float pt = lepton.pt();
  while (rankingItr != cachedRankings.second &&
         (pt < rankingItr->second.minPt || pt >= rankingItr->second.maxPt))
    ++rankingItr;
  if (rankingItr == cachedRankings.second) {
    CachedRanking r = rankTriggerLegs(pt, forwardLegs(legs...));
    if (r)
      m_cachedLegRankings.emplace(combinedHash, r);
    return r.ranking;
  }
  return rankingItr->second.ranking;
}

getCombinedHash() [1/2]

std::size_t TrigGlobalEfficiencyCorrectionTool::getCombinedHash ( const flat_set< std::size_t > & legs )

private

Definition at line 1038 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                     {
  if (legs.size() < 2)
    return 0;
  std::size_t combinedHash = 0;
  for (auto& leg : legs)
    combinedHash ^= leg;
  return combinedHash;
}

getCombinedHash() [2/2]

std::size_t TrigGlobalEfficiencyCorrectionTool::getCombinedHash ( std::size_t leg1, std::size_t leg2 )

private

returns 0 if leg1 == leg2, which is the correct behaviour

Definition at line 1048 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                    {
  return leg1 ^
         leg2;  
}

getEfficiency() [1/3]

template<typename... Args>

auto ITrigGlobalEfficiencyCorrectionTool::getEfficiency ( Args &... args ) -> std::enable_if_t< validArgs< Args... >(2), CP::CorrectionCode >

inherited

Definition at line 102 of file ITrigGlobalEfficiencyCorrectionTool.h.

{
    std::vector<const xAOD::IParticle*> particles;
    double* eff[] = { nullptr, handleArg(args, particles)... };
    return getEfficiency(particles, *eff[sizeof...(Args)-1], *eff[sizeof...(Args)]);
}

getEfficiency() [2/3]

CP::CorrectionCode TrigGlobalEfficiencyCorrectionTool::getEfficiency ( const std::vector< const xAOD::IParticle * > & particles, double & efficiencyData, double & efficiencyMc )

overridevirtual

Implements ITrigGlobalEfficiencyCorrectionTool.

Definition at line 846 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                          {
  unsigned runNumber;
  if (!retrieveRunNumber(runNumber))
    return CP::CorrectionCode::Error;
  return getEfficiency(runNumber, leptons, efficiencyData, efficiencyMc);
}

getEfficiency() [3/3]

CP::CorrectionCode TrigGlobalEfficiencyCorrectionTool::getEfficiency ( unsigned runNumber, const std::vector< const xAOD::IParticle * > & particles, double & efficiencyData, double & efficiencyMc )

overridevirtual

ignores silently previous state + clears "checked" flag

Implements ITrigGlobalEfficiencyCorrectionTool.

Definition at line 880 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                                  {
  m_cpCode = CP::CorrectionCode::Ok;  
  efficiencyData = 0.;
  efficiencyMc = 0.;
 
  ATH_MSG_DEBUG("Computing global trigger efficiency for this event with  "
                << particles.size()
                << " lepton(s) as input; run number = " << runNumber);
 
#ifdef XAOD_STANDALONE
  if (!m_initialized) {
    ATH_MSG_WARNING("Tool hasn't been initialized, trying now");
    if (initialize() != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Giving up.");
      m_cpCode.ignore();
      return CP::CorrectionCode::Error;
    }
  }
#endif
 
  LeptonList leptons;
  updateLeptonList(leptons, particles);
 
  Efficiencies efficiencies;
  if (m_calculator->compute(*this, leptons, runNumber, efficiencies)) {
    efficiencyData = efficiencies.data();
    efficiencyMc = efficiencies.mc();
    if (std::isnan(efficiencies.data()) || efficiencies.data() <= 0. ||
        std::isnan(efficiencies.mc()) || efficiencies.mc() <= 0.) {
      ATH_MSG_WARNING("Efficiencies do not seem valid");
      m_cpCode.ignore();
      m_cpCode = CP::CorrectionCode::OutOfValidityRange;
    }
  } else {
    if (m_cpCode == CP::CorrectionCode::Ok) {
      m_cpCode = CP::CorrectionCode::Error;
    }
  }
  return m_cpCode;
}

getEfficiencyScaleFactor() [1/3]

template<typename... Args>

auto ITrigGlobalEfficiencyCorrectionTool::getEfficiencyScaleFactor ( Args &... args ) -> std::enable_if_t< validArgs< Args... >(1), CP::CorrectionCode >

inherited

Alternatively, the list of particles can be supplied via one or several vectors of xAOD::Electron*‍/Muon*‍/Photon* The generic signature is getEfficiencyScaleFactor((const) vector<(const)Type1*>&, ..., (const) vector<(const)TypeN*>&, double& efficiencyScaleFactor) e.g.

getEfficiencyScaleFactor(electrons, muons, sf); getEfficiencyScaleFactor(photons, sf); getEfficiencyScaleFactor(muons, electrons, photons, sf); don't forget the last argument(s)! (scale factor for getEfficiencyScaleFactor(), data and MC efficiencies for getEfficiency())

Definition at line 93 of file ITrigGlobalEfficiencyCorrectionTool.h.

{
    std::vector<const xAOD::IParticle*> particles;
    double* sf[] = { nullptr, handleArg(args, particles)... };
    return getEfficiencyScaleFactor(particles, *sf[sizeof...(Args)]);
}

getEfficiencyScaleFactor() [2/3]

CP::CorrectionCode TrigGlobalEfficiencyCorrectionTool::getEfficiencyScaleFactor ( const std::vector< const xAOD::IParticle * > & particles, double & efficiencyScaleFactor )

overridevirtual

Implements ITrigGlobalEfficiencyCorrectionTool.

Definition at line 837 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                   {
  unsigned runNumber;
  if (!retrieveRunNumber(runNumber))
    return CP::CorrectionCode::Error;
  return getEfficiencyScaleFactor(runNumber, leptons, efficiencyScaleFactor);
}

getEfficiencyScaleFactor() [3/3]

CP::CorrectionCode TrigGlobalEfficiencyCorrectionTool::getEfficiencyScaleFactor ( unsigned runNumber, const std::vector< const xAOD::IParticle * > & particles, double & efficiencyScaleFactor )

overridevirtual

These should in principle not be used (except by unit tests), as the CP tools require the EventInfo decoration "RandomRunNumber" to be present.

ignores silently previous state + clears "checked" flag

Implements ITrigGlobalEfficiencyCorrectionTool.

Definition at line 855 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                   {
  m_cpCode = CP::CorrectionCode::Ok;  
  efficiencyScaleFactor = 1.;
 
  Efficiencies efficiencies;
  auto cc = getEfficiency(runNumber, particles, efficiencies.data(),
                          efficiencies.mc());
  if (cc == CP::CorrectionCode::Ok) {
    if (efficiencies.data() > 0. && efficiencies.mc() > 0.) {
      efficiencyScaleFactor = efficiencies.data() / efficiencies.mc();
      return CP::CorrectionCode::Ok;
    } else {
      efficiencyScaleFactor = 1.;
      ATH_MSG_WARNING(
          "Efficiencies do not seem valid, forcing the scale factor to 1.");
      return CP::CorrectionCode::OutOfValidityRange;
    }
  }
  efficiencyScaleFactor = 1.;
  return cc;
}

GetEfficiencyTool() [1/2]

IAsgElectronEfficiencyCorrectionTool & TrigGlobalEfficiencyCorrectionTool::GetEfficiencyTool ( const xAOD::Electron * , std::size_t index )

inlineprivate

Definition at line 279 of file TrigGlobalEfficiencyCorrectionTool.h.

                                                                           {
    return *m_suppliedElectronEfficiencyTools[index];
  }

GetEfficiencyTool() [2/2]

IAsgPhotonEfficiencyCorrectionTool & TrigGlobalEfficiencyCorrectionTool::GetEfficiencyTool ( const xAOD::Photon * , std::size_t index )

inlineprivate

Definition at line 283 of file TrigGlobalEfficiencyCorrectionTool.h.

                                                                         {
    return *m_suppliedPhotonEfficiencyTools[index];
  }

GetEfficiencyToolIndex() [1/2]

decltype(m_electronEffToolIndex) & TrigGlobalEfficiencyCorrectionTool::GetEfficiencyToolIndex ( const xAOD::Electron * )

inlineprivate

Definition at line 264 of file TrigGlobalEfficiencyCorrectionTool.h.

                           {
    return m_electronEffToolIndex;
  }

GetEfficiencyToolIndex() [2/2]

decltype(m_photonEffToolIndex) & TrigGlobalEfficiencyCorrectionTool::GetEfficiencyToolIndex ( const xAOD::Photon * )

inlineprivate

Definition at line 268 of file TrigGlobalEfficiencyCorrectionTool.h.

                                                                            {
    return m_photonEffToolIndex;
  }

getEgammaTriggerLegEfficiencies()

template<class ParticleType>

auto TrigGlobalEfficiencyCorrectionTool::getEgammaTriggerLegEfficiencies ( const ParticleType * p, unsigned runNumber, std::size_t leg, std::size_t tag, TrigGlobEffCorr::Efficiencies & efficiencies ) -> TLE_RESULT

private

Common implementation for electrons and photons

Definition at line 677 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                              {
  auto ptype = []() {
    return std::is_same<ParticleType, xAOD::Electron>::value ? "electron"
           : std::is_same<ParticleType, xAOD::Photon>::value ? "photon"
                                                             : "<unknown type>";
  };
  auto pp = static_cast<const xAOD::IParticle*>(p);
  ATH_MSG_DEBUG("Retrieving efficiencies for "
                << ptype() << ' ' << p << " (pt=" << pp->pt()
                << ", eta=" << pp->eta() << ", tag='" << m_dictionary[tag]
                << "') for trigger leg " << m_dictionary[leg]);
  auto itrSf = GetScaleFactorToolIndex(p).find(ToolKey(leg, tag, runNumber));
  auto itrEff = GetEfficiencyToolIndex(p).find(ToolKey(leg, tag, runNumber));
  if (itrSf == GetScaleFactorToolIndex(p).end() ||
      itrEff == GetEfficiencyToolIndex(p).end()) {
    if (m_unsupportedLegs.count(ToolKey(leg, 0u, runNumber))) {
      efficiencies.data() = 0.5;
      efficiencies.mc() = 0.5;
      return TLE_UNAVAILABLE;
    }
    if (!tag)
      ATH_MSG_ERROR("Unable to find "
                    << ptype() << " tools needed for trigger leg "
                    << m_dictionary[leg] << " (run number = " << runNumber
                    << ")");
    else
      ATH_MSG_ERROR("Unable to find "
                    << ptype() << " tools needed for trigger leg "
                    << m_dictionary[leg] << " and selection tag "
                    << m_dictionary[tag] << " (run number = " << runNumber
                    << ")");
    return TLE_ERROR;
  }
  double sf;
  bool success =
      checkAndRecord(GetScaleFactorTool(p, itrSf->second)
                         .getEfficiencyScaleFactor(*p, sf)) &&
      checkAndRecord(GetEfficiencyTool(p, itrEff->second)
                         .getEfficiencyScaleFactor(*p, efficiencies.mc()));
  efficiencies.data() = sf * efficiencies.mc();
  ATH_MSG_DEBUG("found for that " << ptype()
                                  << " eff(data) = " << efficiencies.data()
                                  << " and eff(MC) = " << efficiencies.mc());
  return success ? TLE_OK : TLE_ERROR;
}

getKey()

SG::sgkey_t asg::AsgTool::getKey ( const void * ptr ) const

inherited

Get the (hashed) key of an object that is in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::Event both provide ways for getting the SG::sgkey_t key for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also

asg::AsgTool::getName

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The hashed key of the object in the store. If not found, an invalid (zero) key.

Definition at line 119 of file AsgTool.cxx.

                                                    {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::Event, we have a direct function call
      // for this.
      return evtStore()->event()->getKey( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      return ( proxy == nullptr ? 0 : proxy->sgkey() );
#endif // XAOD_STANDALONE
   }

getLoosestLeg()

std::size_t TrigGlobalEfficiencyCorrectionTool::getLoosestLeg ( const TrigGlobEffCorr::Lepton & lepton, std::size_t leg1, std::size_t leg2, bool & success )

private

Definition at line 1157 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                                                         {
  auto ranking = getCachedTriggerLegsRanking(lepton, leg1, leg2);
  if (CachedRanking::invalid(ranking)) {
    success = false;
    return -1;
  }
  return forwardLegs(leg1, leg2)[ranking & 0xF];
}

getLoosestLegAboveThreshold()

std::size_t TrigGlobalEfficiencyCorrectionTool::getLoosestLegAboveThreshold ( const TrigGlobEffCorr::Lepton & lepton, const flat_set< std::size_t > & legs, bool & success )

private

Definition at line 1182 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                                                          {
  flat_set<std::size_t> validLegs;
  for (auto leg : legs)
    if (aboveThreshold(lepton, leg))
      validLegs.insert(leg);
  if (validLegs.size() == 0)
    return 0;
  if (validLegs.size() == 1)
    return *validLegs.begin();
  auto ranking = getCachedTriggerLegsRanking(lepton, legs);
  if (CachedRanking::invalid(ranking)) {
    success = false;
    return 0;
  }
  return nth (legs, ranking & 0xF);
}

getName()

const std::string & asg::AsgTool::getName ( const void * ptr ) const

inherited

Get the name of an object that is / should be in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::Event both provide ways for getting the std::string name for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also

asg::AsgTool::getKey

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The string name of the object in the store. If not found, an empty string.

Definition at line 106 of file AsgTool.cxx.

                                                            {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::Event, we have a direct function call
      // for this.
      return evtStore()->event()->getName( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      static const std::string dummy = "";
      return ( proxy == nullptr ? dummy : proxy->name() );
#endif // XAOD_STANDALONE
   }

getProperty()

template<class T>

const T * asg::AsgTool::getProperty ( const std::string & name ) const

inherited

Get one of the tool's properties.

getRelevantTriggers()

CP::CorrectionCode TrigGlobalEfficiencyCorrectionTool::getRelevantTriggers ( std::vector< std::string > & triggers )

overridevirtual

This will fill the 'triggers' argument with the names of the triggers relevant for the current run number, among those specified in the tool configuration.

Implements ITrigGlobalEfficiencyCorrectionTool.

Definition at line 969 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                    {
  unsigned runNumber;
  if (!retrieveRunNumber(runNumber)) {
    ATH_MSG_ERROR(
        "Unable to retrieve run number, aborting getRelevantTriggers()");
    return CP::CorrectionCode::Error;
  }
  return m_calculator->getRelevantTriggersForUser(*this, triggers, runNumber)
             ? CP::CorrectionCode::Ok
             : CP::CorrectionCode::Error;
}

GetScaleFactorTool() [1/2]

IAsgElectronEfficiencyCorrectionTool & TrigGlobalEfficiencyCorrectionTool::GetScaleFactorTool ( const xAOD::Electron * , std::size_t index )

inlineprivate

Definition at line 271 of file TrigGlobalEfficiencyCorrectionTool.h.

                                            {
    return *m_suppliedElectronScaleFactorTools[index];
  }

GetScaleFactorTool() [2/2]

IAsgPhotonEfficiencyCorrectionTool & TrigGlobalEfficiencyCorrectionTool::GetScaleFactorTool ( const xAOD::Photon * , std::size_t index )

inlineprivate

Definition at line 275 of file TrigGlobalEfficiencyCorrectionTool.h.

                                                                          {
    return *m_suppliedPhotonScaleFactorTools[index];
  }

GetScaleFactorToolIndex() [1/2]

decltype(m_electronSfToolIndex) & TrigGlobalEfficiencyCorrectionTool::GetScaleFactorToolIndex ( const xAOD::Electron * )

inlineprivate

Definition at line 257 of file TrigGlobalEfficiencyCorrectionTool.h.

                           {
    return m_electronSfToolIndex;
  }

GetScaleFactorToolIndex() [2/2]

decltype(m_photonSfToolIndex) & TrigGlobalEfficiencyCorrectionTool::GetScaleFactorToolIndex ( const xAOD::Photon * )

inlineprivate

Definition at line 261 of file TrigGlobalEfficiencyCorrectionTool.h.

                                                                            {
    return m_photonSfToolIndex;
  }

getSortedLegs()

std::vector< std::size_t > TrigGlobalEfficiencyCorrectionTool::getSortedLegs ( const TrigGlobEffCorr::Lepton & lepton, const flat_set< std::size_t > & legs, bool & success )

private

Definition at line 1200 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                                                          {
  const int nLegs = legs.size();
  unsigned long ranking = getCachedTriggerLegsRanking(lepton, legs);
  if (CachedRanking::invalid(ranking)) {
    success = false;
    ranking = 0xFEDCBA9876543210;
  }
  std::vector<std::size_t> sorted_legs(nLegs);
  for (int i = 0; i < nLegs; ++i) {
    sorted_legs[i] = nth (legs, ranking & 0xF);
    ranking >>= 4;
  }
  return sorted_legs;
}

getTriggerLegEfficiencies() [1/3]

auto TrigGlobalEfficiencyCorrectionTool::getTriggerLegEfficiencies ( const xAOD::Electron * p, unsigned runNumber, std::size_t leg, std::size_t tag, TrigGlobEffCorr::Efficiencies & efficiencies )

private

Definition at line 726 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                                             {
  return getEgammaTriggerLegEfficiencies(p, runNumber, leg, tag, efficiencies);
}

getTriggerLegEfficiencies() [2/3]

auto TrigGlobalEfficiencyCorrectionTool::getTriggerLegEfficiencies ( const xAOD::Muon * p, unsigned runNumber, std::size_t leg, std::size_t tag, TrigGlobEffCorr::Efficiencies & efficiencies )

private

Definition at line 738 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                              {
  ATH_MSG_DEBUG("Retrieving efficiencies for muon "
                << p << " (pt=" << p->pt() << ", eta=" << p->eta() << ", tag='"
                << m_dictionary[tag] << "') for trigger leg "
                << m_dictionary[leg]);
  if (m_unsupportedLegs.size() &&
      m_unsupportedLegs.count(ToolKey(leg, 0u, runNumber))) {
    efficiencies.data() = 0.5;
    efficiencies.mc() = 0.5;
    return TLE_UNAVAILABLE;
  }
  auto itr = m_muonToolIndex.find(ToolKey(0, tag, 0));
  if (itr == m_muonToolIndex.end()) {
    if (!tag)
      ATH_MSG_ERROR("Unable to find muon tool");
    else
      ATH_MSG_ERROR("Unable to find muon tool needed for selection tag "
                    << m_dictionary[tag]);
    m_cpCode = CP::CorrectionCode::Error;
    return TLE_ERROR;
  }
  auto& tool = *m_suppliedMuonTools[itr->second];
  auto& hltTrig = m_dictionary[leg ^ 0xB0DDD56fF8E3250D];
  if (!hltTrig.size()) {
    hltTrig = "HLT_" + m_dictionary[leg];
    while (true) {
      std::size_t i = hltTrig.find("_OR_m");
      if (i == std::string::npos)
        break;
      hltTrig.insert(i + 4, "HLT_", 4);
    }
  }
  bool success = checkAndRecord(tool.getTriggerEfficiency(*p, efficiencies.mc(),
                                                          hltTrig, kFALSE)) &&
                 checkAndRecord(tool.getTriggerEfficiency(
                     *p, efficiencies.data(), hltTrig, kTRUE));
  ATH_MSG_DEBUG("found for that muon eff(data) = " << efficiencies.data()
                                                   << " and eff(MC) = "
                                                   << efficiencies.mc());
  return success ? TLE_OK : TLE_ERROR;
}

getTriggerLegEfficiencies() [3/3]

auto TrigGlobalEfficiencyCorrectionTool::getTriggerLegEfficiencies ( const xAOD::Photon * p, unsigned runNumber, std::size_t leg, std::size_t tag, TrigGlobEffCorr::Efficiencies & efficiencies )

private

Definition at line 732 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                              {
  return getEgammaTriggerLegEfficiencies(p, runNumber, leg, tag, efficiencies);
}

getTwoLoosestLegs()

std::pair< std::size_t, std::size_t > TrigGlobalEfficiencyCorrectionTool::getTwoLoosestLegs ( const TrigGlobEffCorr::Lepton & lepton, const flat_set< std::size_t > & legs, bool & success )

private

Definition at line 1168 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                                                          {
  auto ranking = getCachedTriggerLegsRanking(lepton, legs);
  if (CachedRanking::invalid(ranking)) {
    success = false;
    return {0, 0};
  }
  std::pair<std::size_t, std::size_t> looseLegs{0, 0};
  looseLegs.first = nth (legs, ranking & 0xF);
  if (legs.size() >= 2)
    looseLegs.second = nth (legs, (ranking >> 4) & 0xF);
  return looseLegs;
}

handleArg() [1/2]

template<typename P>

double * ITrigGlobalEfficiencyCorrectionTool::handleArg ( const std::vector< P > & arg, std::vector< const xAOD::IParticle * > & particles )

inlineprotectedinherited

Definition at line 60 of file ITrigGlobalEfficiencyCorrectionTool.h.

    {
        for(auto ptr : arg) particles.push_back(static_cast<const xAOD::IParticle*>(ptr));
        return nullptr;
    }

handleArg() [2/2]

double * ITrigGlobalEfficiencyCorrectionTool::handleArg ( double & arg, std::vector< const xAOD::IParticle * > &  )

inlineprotectedinherited

Definition at line 59 of file ITrigGlobalEfficiencyCorrectionTool.h.

{ return &arg; }

initialize()

StatusCode TrigGlobalEfficiencyCorrectionTool::initialize ( void )

overridevirtual

Dummy implementation of the initialisation function.

It's here to allow the dual-use tools to skip defining an initialisation function. Since many are doing so...

Copy the following variables from data as the latter is short-lived

Reimplemented from asg::AsgTool.

Definition at line 110 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                                          {
  if (m_initialized) {
    ATH_MSG_ERROR("Tool has already been initialized");
    return StatusCode::FAILURE;
  }
  ATH_MSG_INFO("Initializing " << name() << "...");
 
  m_dictionary.emplace(0, "");
 
  if (!processDeprecatedProperties())
    return StatusCode::FAILURE;
 
  ATH_MSG_DEBUG("Importing data from configuration files");
  ImportData data(*this);
  if (!data.importAll(m_overrideThresholds))
    return StatusCode::FAILURE;
  m_hierarchyMeta = data.getHierarchyMeta();
  m_hierarchyData = data.getHierarchyData();
  m_thresholds = data.getTriggerThresholds();
 
  ATH_MSG_DEBUG("Retrieving tools");
  if (m_suppliedElectronEfficiencyTools.retrieve() != StatusCode::SUCCESS ||
      m_suppliedElectronScaleFactorTools.retrieve() != StatusCode::SUCCESS ||
      m_suppliedMuonTools.retrieve() != StatusCode::SUCCESS ||
      m_suppliedPhotonEfficiencyTools.retrieve() != StatusCode::SUCCESS ||
      m_suppliedPhotonScaleFactorTools.retrieve() != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("Unable to retrieve CP tools");
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_DEBUG("Retrieving trigger matching tool (if provided)");
  m_validTrigMatchTool = false;
  if (m_trigMatchTool.name() != "") {
    if (m_trigMatchTool.retrieve() != StatusCode::SUCCESS) {
      ATH_MSG_ERROR("Unable to retrieve trigger matching tool");
      return StatusCode::FAILURE;
    }
    ATH_MSG_DEBUG("Trigger matching support enabled");
    m_validTrigMatchTool = true;
  }
 
  ATH_MSG_DEBUG("Basic checks");
  CheckConfig checks(*this);
  if (!checks.basicConfigChecks())
    return StatusCode::FAILURE;
 
  ATH_MSG_DEBUG("Enumerating tools");
  flat_set<std::size_t> collectedElectronTags, collectedMuonTags,
      collectedPhotonTags;
  if (!enumerateTools(data, m_suppliedElectronEfficiencyTools,
                      m_electronEffToolIndex, collectedElectronTags) ||
      !enumerateTools(data, m_suppliedElectronScaleFactorTools,
                      m_electronSfToolIndex, collectedElectronTags) ||
      !enumerateTools(data, m_suppliedMuonTools, m_muonToolIndex,
                      collectedMuonTags) ||
      !enumerateTools(data, m_suppliedPhotonEfficiencyTools,
                      m_photonEffToolIndex, collectedPhotonTags) ||
      !enumerateTools(data, m_suppliedPhotonScaleFactorTools,
                      m_photonSfToolIndex, collectedPhotonTags)) {
    return StatusCode::FAILURE;
  }
  // List legs (if any) for which a dummy scale factor should be returned.
  auto itr = m_legsPerTool.find(toolnameForDefaultScaleFactor());
  if (itr != m_legsPerTool.end()) {
    bool success = true;
    for (ToolKey leg : parseListOfLegs(data, itr->second, success)) {
      m_unsupportedLegs.insert(leg);
    }
  }
 
  ATH_MSG_DEBUG("Loading user-defined trigger combination");
  bool useDefaultElectronTools =
      (m_suppliedElectronEfficiencyTools.size() == 1) &&
      (m_suppliedElectronScaleFactorTools.size() == 1) &&
      (m_legsPerTool.size() == 0);
  bool useDefaultPhotonTools = (m_suppliedPhotonEfficiencyTools.size() == 1) &&
                               (m_suppliedPhotonScaleFactorTools.size() == 1) &&
                               (m_legsPerTool.size() == 0);
  if (!loadTriggerCombination(data, useDefaultElectronTools,
                              useDefaultPhotonTools))
    return StatusCode::FAILURE;
 
  ATH_MSG_DEBUG("Loading lepton selection tags decorators");
  if (!loadTagDecorators(collectedElectronTags, collectedMuonTags,
                         collectedPhotonTags))
    return StatusCode::FAILURE;
 
  ATH_MSG_DEBUG("Loading list of legs allowed for each tag");
  if (!loadListOfLegsPerTag())
    return StatusCode::FAILURE;
 
  ATH_MSG_DEBUG("Advanced checks");
  if (!checks.advancedConfigChecks())
    return StatusCode::FAILURE;
 
  ATH_MSG_INFO("Initialization successful");
  m_initialized = true;
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

isAffectedBySystematic()

bool TrigGlobalEfficiencyCorrectionTool::isAffectedBySystematic ( const CP::SystematicVariation & systematic ) const

overridevirtual

Declare the interface that this class provides.

returns: whether this tool is affected by the given systematics

Implements CP::ISystematicsTool.

Definition at line 1226 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                                   {
  auto sys = affectingSystematics();
  return !systematic.empty() && sys.find(systematic) != sys.end();
}

listNonOrderedCSValues()

auto TrigGlobalEfficiencyCorrectionTool::listNonOrderedCSValues ( const std::string & s, bool & success )

private

Parses the input string (comma-separated list) and returns a set of hashes Watch out: since a flat_set is returned, the order of the entries in the input list is not preserved, as hinted by the name of the function.

Definition at line 648 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                                              {
  std::stringstream ss(TrigGlobEffCorr::removeWhitespaces(s));
  flat_set<std::size_t> hashes;
  std::string token;
  while (std::getline(ss, token, ',')) {
    if (token.length()) {
      std::size_t h = m_hasher(token);
      if (hashes.insert(h).second) {
        m_dictionary.emplace(h, std::move(token));
      } else {
        success = false;
        ATH_MSG_ERROR(
            "Found duplicate entry while parsing comma-separated list '"
            << s << "'");
      }
    } else {
      success = false;
      ATH_MSG_ERROR(
          "Found null-length entry while parsing comma-separated list '"
          << s << "'");
    }
  }
  if (!success)
    hashes.clear();
  return hashes;
}

loadHierarchies()

bool TrigGlobalEfficiencyCorrectionTool::loadHierarchies ( )

private

Internal methods (I) – initialization of the tool.

loadListOfLegsPerTag()

bool TrigGlobalEfficiencyCorrectionTool::loadListOfLegsPerTag ( )

private

Create the hash list of legs allowed for each tag; check that a CP tool is available for each combination

Definition at line 572 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                                              {
  bool success = true;

  for (auto& kv : m_legsPerTag) {
    std::size_t tag;
    if (!kv.first.size() || kv.first == "*")
      tag = 0;
    else
      tag = m_hasher(kv.first);
    auto listOfLegs = listNonOrderedCSValues(kv.second, success);
    if (!success) {
      ATH_MSG_ERROR(
          "The property 'ListOfLegsPerTag' has an invalid entry for the tag '"
          << kv.first << "'");
      break;
    }
    for (std::size_t leg : listOfLegs) {
      auto type =
          ImportData::associatedLeptonFlavour(m_dictionary[leg], success);
      if (type == xAOD::Type::Electron &&
          m_electronSfToolIndex.find(ToolKey(leg, tag)) ==
              m_electronSfToolIndex.end()) {
        ATH_MSG_ERROR("No electron tool has been provided for trigger leg '"
                      << m_dictionary[leg] << "' and selection tag " << kv.first
                      << " mentioned in the property 'ListOfLegsPerTag'");
        success = false;
      } else if (type == xAOD::Type::Muon &&
                 m_muonToolIndex.find(ToolKey(0, tag)) ==
                     m_muonToolIndex.end()) {
        ATH_MSG_ERROR("No muon tool has been provided for selection tag "
                      << kv.first
                      << " mentioned in the property 'ListOfLegsPerTag'");
        success = false;
      } else if (type == xAOD::Type::Photon &&
                 m_photonSfToolIndex.find(ToolKey(leg, tag)) ==
                     m_photonSfToolIndex.end()) {
        ATH_MSG_ERROR("No photon tool has been provided for trigger leg '"
                      << m_dictionary[leg] << "' and selection tag " << kv.first
                      << " mentioned in the property 'ListOfLegsPerTag'");
        success = false;
      }
      if (m_validLegTagPairs.insert(leg ^ tag).second) {
        if (type == xAOD::Type::Electron)
          m_checkElectronLegTag = true;
        if (type == xAOD::Type::Muon)
          m_checkMuonLegTag = true;
        if (type == xAOD::Type::Photon)
          m_checkPhotonLegTag = true;
      } else {
        ATH_MSG_ERROR("The combination of trigger leg '"
                      << m_dictionary[leg] << "' and selection tag " << kv.first
                      << " is mentioned more than once in the property "
                         "'ListOfLegsPerTag'");
        success = false;
      }
    }
  }
  if (!success)
    return false;
 
  return success;
}

loadTagDecorators()

bool TrigGlobalEfficiencyCorrectionTool::loadTagDecorators ( const flat_set< std::size_t > & collectedElectronTags, const flat_set< std::size_t > & collectedMuonTags, const flat_set< std::size_t > & collectedPhotonTags )

private

Initialize decorators Note: can't use listNonOrderedCSValues() as the order in which decorations are listed must be preserved

tag = decorator name (considered tagged if decorated value != 0)

tag = decorator name (without '?') + decorated value

find a tag of the form <name><integer suffix>

Check there's a suitable decorator for all tags associated to CP tools via ListOfTagsPerTool

ok, there's a direct match

Definition at line 461 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                                    {
  bool success = true;
 
  flat_set<std::size_t> collectedTags(collectedElectronTags);
  collectedTags.insert(collectedMuonTags.begin(), collectedMuonTags.end());
  collectedTags.insert(collectedPhotonTags.begin(), collectedPhotonTags.end());
  flat_set<std::size_t> allTags = collectedTags;

  std::stringstream ss(
      TrigGlobEffCorr::removeWhitespaces(m_leptonTagDecorations));
  std::string decoration;
  flat_set<std::size_t> allDecorations;
  while (std::getline(ss, decoration, ',')) {
    if (!decoration.length() || decoration == "?") {
      ATH_MSG_ERROR(
          "Found an empty string in the 'LeptonTagDecorations' property");
      success = false;
      break;
    }
 
    bool found = false, suffixed = false;
    std::size_t h;
    if (decoration.back() != '?') {
      h = m_hasher(decoration);
      found = (allTags.find(h) != allTags.end());
    } else {
      decoration.pop_back();
      suffixed = true;
      for (std::size_t tag :
           allTags)  
      {
        auto& s = m_dictionary[tag];
        if (s.find(decoration) != 0)
          continue;
        if (std::all_of(s.begin() + decoration.length(), s.end(),
                        [](char c) { return std::isdigit(c); })) {
          found = true;
          break;
        }
      }
      h = m_hasher(decoration);
    }
    if (!allDecorations.insert(h).second) {
      ATH_MSG_ERROR(
          "The selection tag '"
          << decoration
          << "' is listed twice in the property 'LeptonTagDecorations'");
      success = false;
      continue;
    }
    if (!found) {
      ATH_MSG_ERROR(
          "the selection tag '"
          << decoration
          << "' is only referred to in the property 'LeptonTagDecorations'");
      success = false;
      continue;
    }
    m_leptonTagDecorators.emplace_back(decoration, h, suffixed);
    m_dictionary.emplace(h, decoration);
  }
  std::reverse(m_leptonTagDecorators.begin(), m_leptonTagDecorators.end());
  if (!success)
    return false;

  for (std::size_t tag : collectedTags) {
    if (!tag)
      continue;
    auto itr =
        std::find_if(m_leptonTagDecorators.begin(), m_leptonTagDecorators.end(),
                     [tag](const TagDecorator& ltd) {
                       return (!ltd.suffixed) && (ltd.hash == tag);
                     });
    if (itr != m_leptonTagDecorators.end())
      continue;  
    bool found = false;
    auto& s = m_dictionary[tag];
    for (auto& ltd : m_leptonTagDecorators) {
      auto& name = m_dictionary[ltd.hash];
      if (s.find(name) != 0)
        continue;
      if (std::all_of(s.begin() + name.length(), s.end(),
                      [](char c) { return std::isdigit(c); })) {
        found = true;
        break;
      }
    }
    if (!found) {
      ATH_MSG_ERROR("the selection tag '"
                    << m_dictionary[tag]
                    << "' hasn't been found in in 'LeptonTagDecorations'");
      success = false;
      continue;
    }
  }
  if (!success)
    return false;
 
  return success;
}

loadTriggerCombination()

bool TrigGlobalEfficiencyCorrectionTool::loadTriggerCombination ( TrigGlobEffCorr::ImportData & data, bool useDefaultElectronTools, bool useDefaultPhotonTools )

private

tools have not been associated with legs so far so the key hash is only the tag

Definition at line 394 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                {
  bool success = true, mustBeEmpty = m_triggerCb.size();
  for (auto& kv : m_triggerCbPerYear) {
    if (!kv.second.size())
      continue;
    if (mustBeEmpty) {
      ATH_MSG_ERROR(
          "You're not allowed to use simultaneously the 'TriggerCombination' "
          "and 'TriggerCombination"
          << kv.first << "' properties.");
      return false;
    }
    m_triggerCb.insert(kv);
  }
 
  m_calculator = std::make_unique<Calculator>(*this, m_triggerCb.size());
  std::set<std::size_t> allUniqueElectronLegs, allUniquePhotonLegs;
  for (auto& kv : m_triggerCb) {
    std::pair<unsigned, unsigned> boundaries;
    if (!data.getPeriodBoundaries(kv.first, boundaries)) {
      success = false;
      continue;
    }
    std::size_t uniqueElectronLeg = !useDefaultElectronTools,
                uniquePhotonLeg = !useDefaultPhotonTools;
    if (!m_calculator->addPeriod(data, boundaries, kv.second, m_numberOfToys,
                                 uniqueElectronLeg, uniquePhotonLeg)) {
      success = false;
      continue;
    }
    if (uniqueElectronLeg && useDefaultElectronTools)
      allUniqueElectronLegs.insert(uniqueElectronLeg);
    if (uniquePhotonLeg && useDefaultPhotonTools)
      allUniquePhotonLegs.insert(uniquePhotonLeg);
  }
  if (!success)
    return false;
 
  auto remapTools = [](auto& toolIndex, auto& allUniqueLegs) {
    typename std::remove_reference<decltype(toolIndex)>::type remappedToolIndex;
    for (std::size_t leg : allUniqueLegs) {
      if (!leg)
        continue;
      for (auto& kv : toolIndex) {
        const ToolKey& key = kv.first;
        remappedToolIndex.emplace(ToolKey(leg, key.hash, key.boundaries),
                                  kv.second);
      }
    }
    toolIndex.swap(remappedToolIndex);
  };
 
  if (useDefaultElectronTools && allUniqueElectronLegs.size()) {
    remapTools(m_electronSfToolIndex, allUniqueElectronLegs);
    remapTools(m_electronEffToolIndex, allUniqueElectronLegs);
  }
  if (useDefaultPhotonTools && allUniquePhotonLegs.size()) {
    remapTools(m_photonSfToolIndex, allUniquePhotonLegs);
    remapTools(m_photonEffToolIndex, allUniquePhotonLegs);
  }
  return success;
}

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg_level_name()

const std::string & asg::AsgTool::msg_level_name ( ) const

inherited

A deprecated function for getting the message level's name.

Instead of using this, weirdly named function, user code should get the string name of the current minimum message level (in case they really need it...), with:

MSG::name( msg().level() )

This function's name doesn't follow the ATLAS coding rules, and as such will be removed in the not too distant future.

Returns

The string name of the current minimum message level that's printed

Definition at line 101 of file AsgTool.cxx.

                                                  {
 
      return MSG::name( msg().level() );
   }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

parseListOfLegs()

auto TrigGlobalEfficiencyCorrectionTool::parseListOfLegs ( TrigGlobEffCorr::ImportData & data, const std::string & inputList, bool & success )

private

Definition at line 346 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                         {
  if (!inputList.length())
    return {};
  std::regex rx(
      "\\s*([[:alnum:]_]+)\\s*(?:\\[\\s*([^,\\[\\]]+)\\s*\\]\\s*)?(?:,|$)");
  flat_set<ToolKey> keys;
  std::smatch sm;
  auto itr = inputList.cbegin();
  do {
    if (sm.ready())
      itr += sm.length();
    if (!std::regex_search(itr, inputList.cend(), sm, rx) ||
        sm.prefix().length()) {
      ATH_MSG_ERROR("Invalid format for the property \"ListOfLegsPerTool\"");
      success = false;
      break;
    }
    std::size_t leg = m_hasher(sm[1].str());
    if (m_thresholds.find(leg) == m_thresholds.end()) {
      ATH_MSG_ERROR("Unknown trigger leg '"
                    << sm[1].str() << "' found in 'ListOfLegsPerTool'");
      success = false;
      continue;
    }
    ToolKey key(leg, 0);
    if (sm.length(2)) {
      if (!data.getPeriodBoundaries(sm[2].str(), key.boundaries)) {
        ATH_MSG_ERROR("Invalid period \""
                      << sm[2].str()
                      << "\"found in the property \"ListOfLegsPerTool\"");
        success = false;
        continue;
      }
    }
    if (!keys.emplace(key).second) {
      ATH_MSG_ERROR("Trigger leg '"
                    << sm[1].str()
                    << "' mentioned several times with overlapping time "
                       "periods in the property 'ListOfLegsPerTool'");
      success = false;
      continue;
    }
  } while (sm.suffix().length());
  return keys;
}

parseTagString()

bool TrigGlobalEfficiencyCorrectionTool::parseTagString ( const std::string & tagstring, flat_set< std::size_t > & tags )

private

Definition at line 235 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                                              {
  bool success = true;
  const std::size_t star = m_hasher("*");
  for (std::size_t tag : listNonOrderedCSValues(tagstring, success)) {
    allTags.insert((tag != star) ? tag : 0);
  }
  if (!success) {
    ATH_MSG_ERROR("List of tags \"" << tagstring
                                    << "\" is not provided in a valid format");
  }
  return success;
}

print()

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

Reimplemented in AsgHelloTool, HI::HIPileupTool, JetBottomUpSoftDrop, JetConstituentsRetriever, JetDumper, JetFinder, JetFromPseudojet, JetModifiedMassDrop, JetPileupLabelingTool, JetPruner, JetPseudojetRetriever, JetReclusterer, JetReclusteringTool, JetRecTool, JetRecursiveSoftDrop, JetSoftDrop, JetSplitter, JetSubStructureMomentToolsBase, JetToolRunner, JetTrimmer, JetTruthLabelingTool, and KtDeltaRTool.

Definition at line 131 of file AsgTool.cxx.

                             {
 
      ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
      return;
   }

processDeprecatedProperties()

bool TrigGlobalEfficiencyCorrectionTool::processDeprecatedProperties ( )

private

Definition at line 211 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                                                     {
  if (m_electronLegsPerTag.size()) {
    ATH_MSG_WARNING(
        "The property 'ElectronLegsPerTag' is deprecated, please use "
        "'ListOfLegsPerTag' instead");
    for (auto& kv : m_electronLegsPerTag) {
      auto insert = m_legsPerTag.insert(kv);
      if (!insert.second)
        insert.first->second += "," + kv.second;
    }
  }
  if (m_muonLegsPerTag.size()) {
    ATH_MSG_WARNING(
        "The property 'MuonLegsPerTag' is deprecated, please use "
        "'ListOfLegsPerTag' instead");
    for (auto& kv : m_muonLegsPerTag) {
      auto insert = m_legsPerTag.insert(kv);
      if (!insert.second)
        insert.first->second += "," + kv.second;
    }
  }
  return true;
}

rankTriggerLegs()

template<class Container>

auto TrigGlobalEfficiencyCorrectionTool::rankTriggerLegs ( float pt, const Container & legs ) -> CachedRanking

private

need not only to sort, but also to verify consistency for all pairs of legs (in case of configuration issue) for that, use a O(n^2) algorithm and count for each leg the number of legs tighter than itself

future: might search recursively whether some order can be found via transitivity through an intermediate leg

Definition at line 1090 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                     {
  const std::size_t nLegs = legs.size();
  CachedRanking r;
  r.ranking = std::numeric_limits<decltype(r.ranking)>::max();
  r.minPt = 0.f;
  r.maxPt = std::numeric_limits<float>::max();
  if (nLegs >= 2 * sizeof(r.ranking)) {
    ATH_MSG_ERROR(
        "Implementation currently doesn't support ranking of more than "
        << 2 * sizeof(r.ranking) << " trigger legs");
    return r;
  }
  std::vector<uint8_t> counts(nLegs);

  auto legI = legs.begin();
  for (unsigned i = 0; i < nLegs; ++i) {
    auto legJ = legI;
    for (unsigned j = i + 1; j < nLegs; ++j) {
      ++legJ;
      bool found = false;
      for (auto& meta : m_hierarchyMeta) {
        if (pt < meta.minPt || pt >= meta.maxPt)
          continue;
        auto data = m_hierarchyData.begin() + meta.offset;
        auto end = data + meta.nLegs;
        auto a = std::find(data, end, *legI);
        if (a == end)
          continue;
        auto b = std::find(data, end, *legJ);
        if (b == end)
          continue;
        r.minPt = std::max(r.minPt, meta.minPt);
        r.maxPt = std::min(r.maxPt, meta.maxPt);
        ++(counts[(a > b) ? i : j]);
        found = true;
        break;
      }
      if (!found) {
        ATH_MSG_ERROR("Unable to rank trigger legs "
                      << m_dictionary[*legI] << " and " << m_dictionary[*legJ]);
        return r;
      }
    }
    ++legI;
  }
  decltype(r.ranking) ranking = 0;
  for (unsigned i = 0; i < nLegs; ++i) {
    unsigned char index =
        std::find(counts.begin(), counts.end(), i) - counts.begin();
    if (index >= nLegs) {
      ATH_MSG_ERROR("Inconsistency found while trying to rank "
                    << nLegs << " trigger legs");
      return r;
    }
    ranking = (ranking << 4 | index);
  }
  r.ranking = ranking;
  return r;
}

recommendedSystematics()

CP::SystematicSet TrigGlobalEfficiencyCorrectionTool::recommendedSystematics ( ) const

overridevirtual

the list of all systematics this tool recommends to use

Implements CP::IReentrantSystematicsTool.

Definition at line 1237 of file TrigGlobalEfficiencyCorrectionTool.cxx.

          {
  return {};
}

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

retrieveEventNumber()

bool TrigGlobalEfficiencyCorrectionTool::retrieveEventNumber ( unsigned long & eventNumber )

private

Definition at line 801 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                {
  auto eventInfo = evtStore()->retrieve<const xAOD::EventInfo>("EventInfo");
  if (!eventInfo) {
    ATH_MSG_WARNING("Can't retrieve event number from evtStore()");
    eventNumber = 0;
    return false;
  }
  eventNumber = eventInfo->eventNumber();
  return true;
}

retrieveRunNumber()

bool TrigGlobalEfficiencyCorrectionTool::retrieveRunNumber ( unsigned & runNumber )

private

Internal methods (II) – core task.

Definition at line 782 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                         {
  runNumber = 0;
  auto eventInfo = evtStore()->retrieve<const xAOD::EventInfo>("EventInfo");
  if (!eventInfo) {
    ATH_MSG_ERROR("Can't retrieve 'EventInfo' from evtStore()");
    return false;
  }
  if (eventInfo->eventType(xAOD::EventInfo::IS_SIMULATION)) {
    if (!m_runNumberDecorator.isAvailable(*eventInfo)) {
      ATH_MSG_ERROR("Can't retrieve 'RandomRunNumber' from EventInfo");
      return false;
    }
    runNumber = m_runNumberDecorator(*eventInfo);
  } else
    runNumber = eventInfo->runNumber();
  return true;
}

suggestEgammaMapKeys()

CP::CorrectionCode TrigGlobalEfficiencyCorrectionTool::suggestEgammaMapKeys ( const std::map< std::string, std::string > & triggerCombination, const std::string & version, std::map< std::string, std::string > & legsPerKey, xAOD::Type::ObjectType type )

static

Definition at line 1216 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                             {
  ImportData data;
  bool success =
      data.suggestEgammaMapKeys(triggerCombination, version, legsPerKey, type);
  return success ? CP::CorrectionCode::Ok : CP::CorrectionCode::Error;
}

suggestElectronMapKeys()

CP::CorrectionCode TrigGlobalEfficiencyCorrectionTool::suggestElectronMapKeys ( const std::map< std::string, std::string > & triggerCombination, const std::string & version, std::map< std::string, std::string > & legsPerKey )

inlinestatic

Definition at line 78 of file TrigGlobalEfficiencyCorrectionTool.h.

                                                {
    return suggestEgammaMapKeys(triggerCombination, version, legsPerKey,
                                xAOD::Type::Electron);
  }

suggestPhotonMapKeys()

CP::CorrectionCode TrigGlobalEfficiencyCorrectionTool::suggestPhotonMapKeys ( const std::map< std::string, std::string > & triggerCombination, const std::string & version, std::map< std::string, std::string > & legsPerKey )

inlinestatic

Definition at line 85 of file TrigGlobalEfficiencyCorrectionTool.h.

                                                {
    return suggestEgammaMapKeys(triggerCombination, version, legsPerKey,
                                xAOD::Type::Photon);
  }

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, and AthCheckedComponent<::AthAlgTool >.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

toolnameForDefaultScaleFactor()

std::string ITrigGlobalEfficiencyCorrectionTool::toolnameForDefaultScaleFactor ( )

inlinestaticinherited

To be used with the ListOfLegsPerTool property:

Definition at line 57 of file ITrigGlobalEfficiencyCorrectionTool.h.

{ return "RETURN_DEFAULT_SCALE_FACTOR"; }

updateLeptonList()

template<class Particle>

bool TrigGlobalEfficiencyCorrectionTool::updateLeptonList ( LeptonList & leptons, const std::vector< const Particle * > & particles )

private

tag = <name>+

Definition at line 814 of file TrigGlobalEfficiencyCorrectionTool.cxx.

                                                                      {
  for (auto lep : particles) {
    std::size_t tag = 0;
    for (auto& ltd : m_leptonTagDecorators) {
      if (ltd.decorator.isAvailable(*lep)) {
        char v = ltd.decorator(*lep);
        if (v) {
          if (ltd.suffixed)  
          {
            std::string s = m_dictionary.at(ltd.hash) + std::to_string(v);
            tag = m_hasher(s);
            m_dictionary.emplace(tag, s);
          } else
            tag = ltd.hash;
        }
      }
    }
    leptons.emplace_back(lep, tag);
  }
  return true;
}

updateMuonTriggerNames()

void TrigGlobalEfficiencyCorrectionTool::updateMuonTriggerNames ( std::size_t leg, const std::string & name )

private

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

validArgs() [1/2]

template<typename Arg1, typename Arg2, typename... OtherArgs>

bool ITrigGlobalEfficiencyCorrectionTool::validArgs ( unsigned nTrailingDoubles )

staticconstexprinherited

Definition at line 81 of file ITrigGlobalEfficiencyCorrectionTool.h.

{
    bool xs [] = { std::is_same<OtherArgs, double>::value..., true };
    for(bool x : xs) if(!x) return validArgs<Arg1>(0) && validArgs<Arg2, OtherArgs...>(nTrailingDoubles);
    unsigned nTD = sizeof...(OtherArgs);
    if(nTD == nTrailingDoubles) return validArgs<Arg1>(0) && validArgs<Arg2>(0);
    if(nTD == nTrailingDoubles-1) return validArgs<Arg1>(0) && std::is_same<Arg2, double>::value;
    if(nTD == nTrailingDoubles-2) return std::is_same<Arg1, double>::value && std::is_same<Arg2, double>::value;
    return false;
}

validArgs() [2/2]

template<typename Arg>

bool ITrigGlobalEfficiencyCorrectionTool::validArgs ( unsigned nTrailingDoubles )

staticconstexprinherited

Definition at line 68 of file ITrigGlobalEfficiencyCorrectionTool.h.

{
    if(std::is_same<double, Arg>::value) return (nTrailingDoubles==1);
    using P = std::remove_cv_t<Arg>;
    return std::is_same<P, std::vector<xAOD::Electron*>>::value
        || std::is_same<P, std::vector<const xAOD::Electron*>>::value
        || std::is_same<P, std::vector<xAOD::Muon*>>::value
        || std::is_same<P, std::vector<const xAOD::Muon*>>::value
        || std::is_same<P, std::vector<xAOD::Photon*>>::value
        || std::is_same<P, std::vector<const xAOD::Photon*>>::value;
}

Friends And Related Symbol Documentation

TrigGlobEffCorr::Calculator

friend class TrigGlobEffCorr::Calculator

friend

Definition at line 301 of file TrigGlobalEfficiencyCorrectionTool.h.

TrigGlobEffCorr::CheckConfig

friend class TrigGlobEffCorr::CheckConfig

friend

Definition at line 300 of file TrigGlobalEfficiencyCorrectionTool.h.

TrigGlobEffCorr::ImportData

friend class TrigGlobEffCorr::ImportData

friend

Definition at line 299 of file TrigGlobalEfficiencyCorrectionTool.h.

Member Data Documentation

m_cachedLegRankings

std::multimap<std::size_t, CachedRanking> TrigGlobalEfficiencyCorrectionTool::m_cachedLegRankings

private

Definition at line 170 of file TrigGlobalEfficiencyCorrectionTool.h.

m_calculator

std::unique_ptr<TrigGlobEffCorr::Calculator> TrigGlobalEfficiencyCorrectionTool::m_calculator

private

Definition at line 193 of file TrigGlobalEfficiencyCorrectionTool.h.

m_checkElectronLegTag

bool TrigGlobalEfficiencyCorrectionTool::m_checkElectronLegTag {}

private

Definition at line 177 of file TrigGlobalEfficiencyCorrectionTool.h.

{};                                     

m_checkMuonLegTag

bool TrigGlobalEfficiencyCorrectionTool::m_checkMuonLegTag {}

private

Definition at line 178 of file TrigGlobalEfficiencyCorrectionTool.h.

{};                                         

m_checkPhotonLegTag

bool TrigGlobalEfficiencyCorrectionTool::m_checkPhotonLegTag {}

private

Definition at line 179 of file TrigGlobalEfficiencyCorrectionTool.h.

{};                                       

m_cpCode

CP::CorrectionCode TrigGlobalEfficiencyCorrectionTool::m_cpCode = CP::CorrectionCode::Ok

private

Definition at line 187 of file TrigGlobalEfficiencyCorrectionTool.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_dictionary

std::map<std::size_t, std::string> TrigGlobalEfficiencyCorrectionTool::m_dictionary

private

Definition at line 180 of file TrigGlobalEfficiencyCorrectionTool.h.

m_electronEffToolIndex

std::map<ToolKey, std::size_t> TrigGlobalEfficiencyCorrectionTool::m_electronEffToolIndex

private

Definition at line 172 of file TrigGlobalEfficiencyCorrectionTool.h.

m_electronLegsPerTag

std::map<std::string, std::string> TrigGlobalEfficiencyCorrectionTool::m_electronLegsPerTag

private

Definition at line 160 of file TrigGlobalEfficiencyCorrectionTool.h.

m_electronSfToolIndex

std::map<ToolKey, std::size_t> TrigGlobalEfficiencyCorrectionTool::m_electronSfToolIndex

private

Definition at line 171 of file TrigGlobalEfficiencyCorrectionTool.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

m_hasher

std::hash<std::string> TrigGlobalEfficiencyCorrectionTool::m_hasher

private

Definition at line 168 of file TrigGlobalEfficiencyCorrectionTool.h.

m_hierarchyData

std::vector<std::size_t> TrigGlobalEfficiencyCorrectionTool::m_hierarchyData

private

Definition at line 184 of file TrigGlobalEfficiencyCorrectionTool.h.

m_hierarchyMeta

std::vector<Hierarchy> TrigGlobalEfficiencyCorrectionTool::m_hierarchyMeta

private

Definition at line 183 of file TrigGlobalEfficiencyCorrectionTool.h.

m_initialized

bool TrigGlobalEfficiencyCorrectionTool::m_initialized = false

private

Definition at line 186 of file TrigGlobalEfficiencyCorrectionTool.h.

m_legsPerTag

std::map<std::string, std::string> TrigGlobalEfficiencyCorrectionTool::m_legsPerTag

private

deprecated

Definition at line 162 of file TrigGlobalEfficiencyCorrectionTool.h.

m_legsPerTool

std::map<std::string, std::string> TrigGlobalEfficiencyCorrectionTool::m_legsPerTool

private

Definition at line 155 of file TrigGlobalEfficiencyCorrectionTool.h.

m_leptonTagDecorations

std::string TrigGlobalEfficiencyCorrectionTool::m_leptonTagDecorations

private

Definition at line 158 of file TrigGlobalEfficiencyCorrectionTool.h.

m_leptonTagDecorators

std::vector<TagDecorator> TrigGlobalEfficiencyCorrectionTool::m_leptonTagDecorators

private

Definition at line 191 of file TrigGlobalEfficiencyCorrectionTool.h.

m_muonLegsPerTag

std::map<std::string, std::string> TrigGlobalEfficiencyCorrectionTool::m_muonLegsPerTag

private

deprecated

Definition at line 161 of file TrigGlobalEfficiencyCorrectionTool.h.

m_muonToolIndex

std::map<ToolKey, std::size_t> TrigGlobalEfficiencyCorrectionTool::m_muonToolIndex

private

Definition at line 175 of file TrigGlobalEfficiencyCorrectionTool.h.

m_numberOfToys

unsigned long TrigGlobalEfficiencyCorrectionTool::m_numberOfToys {}

private

Definition at line 164 of file TrigGlobalEfficiencyCorrectionTool.h.

{};

m_overrideThresholds

std::map<std::string, std::string> TrigGlobalEfficiencyCorrectionTool::m_overrideThresholds

private

Definition at line 163 of file TrigGlobalEfficiencyCorrectionTool.h.

m_photonEffToolIndex

std::map<ToolKey, std::size_t> TrigGlobalEfficiencyCorrectionTool::m_photonEffToolIndex

private

Definition at line 174 of file TrigGlobalEfficiencyCorrectionTool.h.

m_photonSfToolIndex

std::map<ToolKey, std::size_t> TrigGlobalEfficiencyCorrectionTool::m_photonSfToolIndex

private

Definition at line 173 of file TrigGlobalEfficiencyCorrectionTool.h.

m_runNumberDecorator

SG::AuxElement::ConstAccessor<unsigned int> TrigGlobalEfficiencyCorrectionTool::m_runNumberDecorator

private

Definition at line 192 of file TrigGlobalEfficiencyCorrectionTool.h.

m_seed

unsigned long TrigGlobalEfficiencyCorrectionTool::m_seed {}

private

Definition at line 188 of file TrigGlobalEfficiencyCorrectionTool.h.

{};

m_suppliedElectronEfficiencyTools

ToolHandleArray<IAsgElectronEfficiencyCorrectionTool> TrigGlobalEfficiencyCorrectionTool::m_suppliedElectronEfficiencyTools

private

Properties:

Definition at line 147 of file TrigGlobalEfficiencyCorrectionTool.h.

m_suppliedElectronScaleFactorTools

ToolHandleArray<IAsgElectronEfficiencyCorrectionTool> TrigGlobalEfficiencyCorrectionTool::m_suppliedElectronScaleFactorTools

private

Definition at line 149 of file TrigGlobalEfficiencyCorrectionTool.h.

m_suppliedMuonTools

ToolHandleArray<CP::IMuonTriggerScaleFactors> TrigGlobalEfficiencyCorrectionTool::m_suppliedMuonTools

private

Definition at line 154 of file TrigGlobalEfficiencyCorrectionTool.h.

m_suppliedPhotonEfficiencyTools

ToolHandleArray<IAsgPhotonEfficiencyCorrectionTool> TrigGlobalEfficiencyCorrectionTool::m_suppliedPhotonEfficiencyTools

private

Definition at line 151 of file TrigGlobalEfficiencyCorrectionTool.h.

m_suppliedPhotonScaleFactorTools

ToolHandleArray<IAsgPhotonEfficiencyCorrectionTool> TrigGlobalEfficiencyCorrectionTool::m_suppliedPhotonScaleFactorTools

private

Definition at line 153 of file TrigGlobalEfficiencyCorrectionTool.h.

m_tagsPerTool

std::map<std::string, std::string> TrigGlobalEfficiencyCorrectionTool::m_tagsPerTool

private

Definition at line 159 of file TrigGlobalEfficiencyCorrectionTool.h.

m_thresholds

std::map<std::size_t, float> TrigGlobalEfficiencyCorrectionTool::m_thresholds

private

Definition at line 169 of file TrigGlobalEfficiencyCorrectionTool.h.

m_triggerCb

std::map<std::string, std::string> TrigGlobalEfficiencyCorrectionTool::m_triggerCb

private

Definition at line 156 of file TrigGlobalEfficiencyCorrectionTool.h.

m_triggerCbPerYear

std::map<std::string, std::string> TrigGlobalEfficiencyCorrectionTool::m_triggerCbPerYear

private

Definition at line 157 of file TrigGlobalEfficiencyCorrectionTool.h.

m_trigMatchTool

ToolHandle<Trig::IMatchingTool> TrigGlobalEfficiencyCorrectionTool::m_trigMatchTool

private

Definition at line 166 of file TrigGlobalEfficiencyCorrectionTool.h.

m_unsupportedLegs

std::set<ToolKey> TrigGlobalEfficiencyCorrectionTool::m_unsupportedLegs

private

Definition at line 181 of file TrigGlobalEfficiencyCorrectionTool.h.

m_useInternalSeed

bool TrigGlobalEfficiencyCorrectionTool::m_useInternalSeed {}

private

Definition at line 165 of file TrigGlobalEfficiencyCorrectionTool.h.

{};

m_validLegTagPairs

std::set<std::size_t> TrigGlobalEfficiencyCorrectionTool::m_validLegTagPairs

private

Definition at line 176 of file TrigGlobalEfficiencyCorrectionTool.h.

m_validTrigMatchTool

bool TrigGlobalEfficiencyCorrectionTool::m_validTrigMatchTool

private

Definition at line 189 of file TrigGlobalEfficiencyCorrectionTool.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• TrigGlobalEfficiencyCorrectionTool.h
• TrigGlobalEfficiencyCorrectionTool.cxx