#include <MuonEfficiencyScaleFactors.h>

Inheritance diagram for CP::MuonEfficiencyScaleFactors:

Classes
struct	Accessors

Public Member Functions
	MuonEfficiencyScaleFactors (const std::string &name)
virtual	~MuonEfficiencyScaleFactors ()
virtual StatusCode	initialize () override
	initialize the tool once all settings are in place!
virtual CorrectionCode	getEfficiencyScaleFactor (const xAOD::Muon &mu, float &sf, const xAOD::EventInfo *info=0) const override
	Retrieve the Scale factor and decorate the muon.
CorrectionCode	getEfficiencyScaleFactor (columnar::MuonId mu, float &sf, columnar::EventInfoId info) const
virtual CorrectionCode	applyEfficiencyScaleFactor (const xAOD::Muon &mu, const xAOD::EventInfo *info=0) const override
	decorate the muon with scale factor information
virtual CorrectionCode	getEfficiencyScaleFactorReplicas (const xAOD::Muon &mu, std::vector< float > &sf_err, const xAOD::EventInfo *info=0) const override
	replica generation
virtual CorrectionCode	applyEfficiencyScaleFactorReplicas (const xAOD::Muon &mu, int nreplicas=50, const xAOD::EventInfo *info=0) const override
	decorate the muon with a set of SF replica weights.
virtual bool	isAffectedBySystematic (const SystematicVariation &systematic) const override
	returns: whether this tool is affected by the given systematis
virtual SystematicSet	affectingSystematics () const override
	returns: the list of all systematics this tool can be affected by
virtual SystematicSet	recommendedSystematics () const override
	returns: the list of all systematics this tool recommends to use
virtual StatusCode	applySystematicVariation (const SystematicSet &systConfig) override
	effects: configure this tool for the given list of systematic variations.
virtual CorrectionCode	getDataEfficiency (const xAOD::Muon &mu, float &eff, const xAOD::EventInfo *info=0) const override
	Obtain the muon efficiency measured using the data.
virtual CorrectionCode	applyDataEfficiency (const xAOD::Muon &mu, const xAOD::EventInfo *info=0) const override
	decorate a muon with the efficiency information
virtual CorrectionCode	getDataEfficiencyReplicas (const xAOD::Muon &mu, std::vector< float > &sf_err, const xAOD::EventInfo *info=0) const
virtual CorrectionCode	applyDataEfficiencyReplicas (const xAOD::Muon &mu, int nreplicas=50, const xAOD::EventInfo *info=0) const
virtual CorrectionCode	getMCEfficiency (const xAOD::Muon &mu, float &eff, const xAOD::EventInfo *info=0) const override
	Obtain the muon efficiency measured using the MC.
virtual CorrectionCode	applyMCEfficiency (const xAOD::Muon &mu, const xAOD::EventInfo *info=0) const override
virtual CorrectionCode	getMCEfficiencyReplicas (const xAOD::Muon &mu, std::vector< float > &sf_err, const xAOD::EventInfo *info=0) const
virtual CorrectionCode	applyMCEfficiencyReplicas (const xAOD::Muon &mu, int nreplicas=50, const xAOD::EventInfo *info=0) const
virtual int	getUnCorrelatedSystBin (const xAOD::Muon &mu) const override
virtual std::string	getUncorrelatedSysBinName (unsigned int Bin) const override
virtual std::string	getUncorrelatedSysBinName (const SystematicSet &systConfig) const override
std::string	filename_Central () const
	The following methods are meant to propagate information from the central tool to the subtool managing the individual scale-factor maps to keep their constructors small in number of arguments.
std::string	filename_Calo () const
	Reconstruction scale-factors have a dedicated map for calo-tag muons around \|\eta\|<0.1.
std::string	filename_HighEta () const
	High-eta reconstruction scale-factors are not obtained by the means of are not obtained by the means of tag & probe, but rather by building the double ratio.
std::string	filename_LowPt () const
	Returns the scale-factor maps from a complementary scale-factor measurement using the J/Psi or Upsilon resonance.
std::string	filename_LowPtCalo () const
std::string	filename_LRTCentral () const
	LRT muons have their own efficiency maps.
std::string	filename_LRTLowPt () const
float	lowPtTransition () const
	If the pt of the muon is below that threshold the J/Psi or Upsilon map is used given that it's available.
CP::MuonEfficiencyType	measurement () const
	Returns the type of the measurement to be carried out... E.g. Reco/TTVA/Iso.
std::string	sf_decoration () const
	The apply<Blah> methods decorate their result directly to the muon.
std::string	data_effi_decoration () const
std::string	mc_effi_decoration () const
std::string	sf_replica_decoration () const
std::string	data_effi_replica_decoration () const
std::string	mc_effi_replica_deocration () const
size_t	getPosition (const EffiCollection *coll) const
	Returns the position of the collection in the syst set vector.
size_t	getNCollections () const
	Returns the number of EffiCollections stored in this class.
bool	uncorrelate_sys () const
	Returns a boolean whether the uncorrelation of systematics has been switched on.
const std::string &	close_by_jet_decoration () const
	Returns the string telling the tool in which float AuxElement the information of the separation to the closest jet is stored.
bool	use_2D_iso_corrections () const
	option to set if we want to use 1D or 2D isolation SFs
bool	use_lrt () const
	option to set if we want to use LRT muons
void	callSingleEvent (columnar::MuonRange muons, columnar::EventInfoId event) const
virtual void	callEvents (columnar::EventContextRange events) const override
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
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.

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.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
unsigned int	getRandomRunNumber (const xAOD::EventInfo *info) const
unsigned int	getRandomRunNumber (columnar::EventInfoId info) const
StatusCode	LoadInputs ()
	load the SF histos
std::map< std::string, unsigned int >	lookUpSystematics ()
	Scale-factor files since Moriond2019 contain the breakdown of systematics into their individual components.
std::string	resolve_file_location (const std::string &filename) const
	utility method to 'dress' a filename using the path resolver
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfo {this, "EventInfoContName", "EventInfo", "event info key"}
std::string	m_wp
	the working point to operate on
std::vector< std::unique_ptr< EffiCollection > >	m_sf_sets
	This vector stores all scale-factor maps.
EffiCollection *	m_current_sf
	Pointer to the current active map in terms of systematics.
std::string	m_custom_dir
std::string	m_custom_file_Combined
std::string	m_custom_file_Calo
std::string	m_custom_file_HighEta
std::string	m_custom_file_LowPt
std::string	m_custom_file_LowPtCalo
std::string	m_custom_file_LRTCombined
std::string	m_custom_file_LRTLowPt
std::string	m_efficiency_decoration_name_data
std::string	m_efficiency_decoration_name_mc
std::string	m_sf_decoration_name
std::string	m_calibration_version
	subfolder to load from the calibration db
float	m_lowpt_threshold
	threshold below which low-pt SF (i.e. from JPsi) should be used
std::string	m_iso_jet_dR
	Name of the decoration to catch up the close by jets.
bool	m_use2DIsoCorr
CP::SystematicSet	m_affectingSys
std::unordered_map< CP::SystematicSet, EffiCollection * >	m_filtered_sys_sets
	It turned out that the code spends a large time in the look up of the systematics.
bool	m_init
bool	m_seperateSystBins
bool	m_breakDownSyst
bool	m_applyKineDepSys
bool	m_useLRT
	Turn on if using LRT objects.
CP::MuonEfficiencyType	m_Type
std::unique_ptr< Accessors >	m_accessors
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

Detailed Description

Definition at line 29 of file MuonEfficiencyScaleFactors.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ MuonEfficiencyScaleFactors()

CP::MuonEfficiencyScaleFactors::MuonEfficiencyScaleFactors ( const std::string & name )

Name of the decorator carrying the information the distance to the next what ever jet (AntiKt4EMTopo,....)

Turn on if using LRT muons

Definition at line 33 of file MuonEfficiencyScaleFactors.cxx.

                                                                                :
                asg::AsgTool(name),
                m_wp("Medium"),
                m_sf_sets(),
                m_current_sf(),
                m_custom_dir(),
                m_custom_file_Combined(),
                m_custom_file_Calo(),
                m_custom_file_HighEta(),
                m_custom_file_LowPt(),
                m_custom_file_LowPtCalo(),
                m_custom_file_LRTCombined(),
                m_custom_file_LRTLowPt(),
                m_efficiency_decoration_name_data(),
                m_efficiency_decoration_name_mc(),
                m_sf_decoration_name(),
                m_calibration_version("230213_Preliminary_r22run2"),
                m_lowpt_threshold(-1.),
                m_iso_jet_dR("dRJet"),
                m_use2DIsoCorr(false),
                m_affectingSys(),
                m_filtered_sys_sets(),
                m_init(false),
                m_seperateSystBins(false),
                m_breakDownSyst(false),
                m_applyKineDepSys(true),
                m_useLRT(false),
                m_Type(CP::MuonEfficiencyType::Undefined) {
 
        m_accessors = std::make_unique<Accessors>(this);
 
        declareProperty("WorkingPoint", m_wp);
 
        // these are for debugging / testing, *not* for general use!
        declareProperty("CustomInputFolder", m_custom_dir);
        declareProperty("CustomFileCaloTag", m_custom_file_Calo);
        declareProperty("CustomFileCombined", m_custom_file_Combined);
        declareProperty("CustomFileHighEta", m_custom_file_HighEta);
        declareProperty("CustomFileLowPt", m_custom_file_LowPt);
        declareProperty("CustomFileLowPtCalo", m_custom_file_LowPtCalo);
        declareProperty("CustomFileLRTCombined", m_custom_file_LRTCombined);
        declareProperty("CustomFileLRTLowPt", m_custom_file_LRTLowPt);
        
        // Apply additional systematics to account for negelected pt dependency
        // in the maps themselves or for non-closure
        declareProperty("ApplyKinematicSystematic", m_applyKineDepSys);
 
        // Set specific names for the decorations of the scale-factors to the muon
        declareProperty("DataEfficiencyDecorationName", m_efficiency_decoration_name_data);
        declareProperty("MCEfficiencyDecorationName", m_efficiency_decoration_name_mc);
        declareProperty("ScaleFactorDecorationName", m_sf_decoration_name);
      
        declareProperty("CalibrationRelease", m_calibration_version);
        // Set this property to -1 if you do not want to use the JPsi
        // reconstruction scale-factors
        declareProperty("LowPtThreshold", m_lowpt_threshold);
        declareProperty("UncorrelateSystematics", m_seperateSystBins);
        declareProperty("BreakDownSystematics", m_breakDownSyst);
        declareProperty("CloseJetDRDecorator", m_iso_jet_dR);
        declareProperty("Use2DIsoCorrections", m_use2DIsoCorr);
        declareProperty("UseLRT", m_useLRT);
    }

◆ ~MuonEfficiencyScaleFactors()

CP::MuonEfficiencyScaleFactors::~MuonEfficiencyScaleFactors ( )

virtualdefault

Member Function Documentation

◆ affectingSystematics()

SystematicSet CP::MuonEfficiencyScaleFactors::affectingSystematics ( ) const

overridevirtual

returns: the list of all systematics this tool can be affected by

Implements CP::IReentrantSystematicsTool.

Definition at line 591 of file MuonEfficiencyScaleFactors.cxx.

                                                                         {
        if (!m_affectingSys.empty()) return m_affectingSys;
        SystematicSet result;
        for (auto& collection : m_sf_sets){
            if (!collection->getSystSet()){
                ATH_MSG_FATAL("No systematic defined for scale-factor map. ");
                return SystematicSet();
            }
            result.insert(*collection->getSystSet());
        }        
        return result;
    }

◆ applyDataEfficiency()

CorrectionCode CP::MuonEfficiencyScaleFactors::applyDataEfficiency	(	const xAOD::Muon &	mu,
		const xAOD::EventInfo *	info = 0 ) const

overridevirtual

decorate a muon with the efficiency information

Implements CP::IMuonEfficiencyScaleFactors.

Definition at line 318 of file MuonEfficiencyScaleFactors.cxx.

                                                                                                                      {
        if (!m_init) {
            ATH_MSG_ERROR("The tool has not been initialized yet");
            return CorrectionCode::Error;
        }
        unsigned int RunNumber = getRandomRunNumber(info);
        return m_current_sf->retrieveSF(mu, RunNumber)->ApplyDataEfficiency(mu);
    }

◆ applyDataEfficiencyReplicas()

CorrectionCode CP::MuonEfficiencyScaleFactors::applyDataEfficiencyReplicas	(	const xAOD::Muon &	mu,
		int	nreplicas = 50,
		const xAOD::EventInfo *	info = 0 ) const

virtual

Definition at line 334 of file MuonEfficiencyScaleFactors.cxx.

                                                                                                                                             {
        if (!m_init) {
            ATH_MSG_ERROR("The tool has not been initialized yet");
            return CorrectionCode::Error;
        }
        unsigned int RunNumber = getRandomRunNumber(info);
        return m_current_sf->retrieveSF(mu, RunNumber)->ApplyDataEfficiencyReplicas(mu, nreplicas);
    }

◆ applyEfficiencyScaleFactor()

CorrectionCode CP::MuonEfficiencyScaleFactors::applyEfficiencyScaleFactor	(	const xAOD::Muon &	mu,
		const xAOD::EventInfo *	info = 0 ) const

overridevirtual

decorate the muon with scale factor information

Implements CP::IMuonEfficiencyScaleFactors.

Definition at line 285 of file MuonEfficiencyScaleFactors.cxx.

                                                                                                                             {
        if (!m_init) {
            ATH_MSG_ERROR("The tool has not been initialized yet");
            return CorrectionCode::Error;
        }
        unsigned int RunNumber = getRandomRunNumber(info);
        return m_current_sf->retrieveSF(mu, RunNumber)->ApplyScaleFactor(mu);
    }

◆ applyEfficiencyScaleFactorReplicas()

CorrectionCode CP::MuonEfficiencyScaleFactors::applyEfficiencyScaleFactorReplicas	(	const xAOD::Muon &	mu,
		int	nreplicas = 50,
		const xAOD::EventInfo *	info = 0 ) const

overridevirtual

decorate the muon with a set of SF replica weights.

Implements CP::IMuonEfficiencyScaleFactors.

Definition at line 302 of file MuonEfficiencyScaleFactors.cxx.

                                                                                                                                                    {
        if (!m_init) {
            ATH_MSG_ERROR("The tool has not been initialized yet");
            return CorrectionCode::Error;
        }
        unsigned int RunNumber = getRandomRunNumber(info);
        return m_current_sf->retrieveSF(mu, RunNumber)->ApplyScaleFactorReplicas(mu, nreplicas);
    }

◆ applyMCEfficiency()

CorrectionCode CP::MuonEfficiencyScaleFactors::applyMCEfficiency	(	const xAOD::Muon &	mu,
		const xAOD::EventInfo *	info = 0 ) const

overridevirtual

Implements CP::IMuonEfficiencyScaleFactors.

Definition at line 350 of file MuonEfficiencyScaleFactors.cxx.

                                                                                                                    {
        if (!m_init) {
            ATH_MSG_ERROR("The tool has not been initialized yet");
            return CorrectionCode::Error;
        }
        unsigned int RunNumber = getRandomRunNumber(info);
        return m_current_sf->retrieveSF(mu, RunNumber)->ApplyMCEfficiency(mu);
    }

◆ applyMCEfficiencyReplicas()

CorrectionCode CP::MuonEfficiencyScaleFactors::applyMCEfficiencyReplicas	(	const xAOD::Muon &	mu,
		int	nreplicas = 50,
		const xAOD::EventInfo *	info = 0 ) const

virtual

Definition at line 366 of file MuonEfficiencyScaleFactors.cxx.

                                                                                                                                           {
        if (!m_init) {
            ATH_MSG_ERROR("The tool has not been initialized yet");
            return CorrectionCode::Error;
        }
        unsigned int RunNumber = getRandomRunNumber(info);
        return m_current_sf->retrieveSF(mu, RunNumber)->ApplyMCEfficiencyReplicas(mu, nreplicas);
       }

◆ applySystematicVariation()

StatusCode CP::MuonEfficiencyScaleFactors::applySystematicVariation ( const 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 612 of file MuonEfficiencyScaleFactors.cxx.

                                                                                                   {
        if (!m_init) {
            ATH_MSG_ERROR("Initialize first the tool!");
            return StatusCode::FAILURE;
        }
        
        //check if systematics is cached
        std::unordered_map<CP::SystematicSet, EffiCollection*>::const_iterator itr  = m_filtered_sys_sets.find (systConfig);
        
        SystematicSet mySysConf(systConfig);
        
        if (itr == m_filtered_sys_sets.end()) {
             if (!SystematicSet::filterForAffectingSystematics(systConfig, m_affectingSys, mySysConf)) {
                ATH_MSG_ERROR("Unsupported combination of systematics passed to the tool! ");
                return StatusCode::FAILURE;
            }
            itr = m_filtered_sys_sets.find(mySysConf);
        }
        
        // No cache is available 
        if (itr == m_filtered_sys_sets.end()){
            std::vector<std::unique_ptr<EffiCollection>>::const_iterator coll_itr = std::find_if(m_sf_sets.begin(), m_sf_sets.end(),[&mySysConf](const std::unique_ptr<EffiCollection>& a){return a->isAffectedBySystematic(mySysConf);});
            if (coll_itr == m_sf_sets.end()){
                ATH_MSG_WARNING("Invalid systematic given.");
                return StatusCode::FAILURE;
            }
            m_filtered_sys_sets.insert(std::pair<SystematicSet, EffiCollection*>(systConfig, coll_itr->get()));
            itr = m_filtered_sys_sets.find(systConfig);
        }
        m_current_sf = itr->second;
        
        if (m_seperateSystBins && !itr->first.name().empty()){
            for (std::set<SystematicVariation>::const_iterator t = mySysConf.begin(); t != mySysConf.end(); ++t) {
                if ((*t).isToyVariation()) {
                    // First entry corresponds to the bin number and
                    // the second entry to the position in which the map is ordered
                    // into the m_sf_sets container
                    std::pair<unsigned, float> pair = (*t).getToyVariation();
                    if (pair.first != 0 && !m_current_sf->SetSystematicBin(pair.first)){
                        ATH_MSG_WARNING("Could not apply systematic " << (*t).name() << " for bin " << pair.first);
                            return StatusCode::FAILURE;
                    }
                    return StatusCode::SUCCESS; 
                }
            }
        }
        return StatusCode::SUCCESS;
    }

◆ callEvents()

void CP::MuonEfficiencyScaleFactors::callEvents ( columnar::EventContextRange events ) const

overridevirtual

Definition at line 708 of file MuonEfficiencyScaleFactors.cxx.

                                                                                       {
        const auto& acc = *m_accessors;
        for (columnar::EventContextId event : events)
        {
            auto eventInfo = acc.eventInfoCol(event);
            callSingleEvent (acc.muons(event), eventInfo);
        }
    }

◆ callSingleEvent()

void CP::MuonEfficiencyScaleFactors::callSingleEvent	(	columnar::MuonRange	muons,
		columnar::EventInfoId	event ) const

Definition at line 686 of file MuonEfficiencyScaleFactors.cxx.

    {
        const auto& acc = *m_accessors;
        for (columnar::MuonId muon : muons)
        {
            float sf = 0;
            switch (getEfficiencyScaleFactor(muon, sf, event).code())
            {
            case CP::CorrectionCode::Ok:
                acc.sfDec(muon) = sf;
                acc.validDec(muon) = true;
                break;
            case CP::CorrectionCode::OutOfValidityRange:
                acc.sfDec(muon) = sf;
                acc.validDec(muon) = false;
                break;
            default:
                throw std::runtime_error("Error in getEfficiencyScaleFactor");
            }
        }
    }

◆ close_by_jet_decoration()

const std::string & CP::MuonEfficiencyScaleFactors::close_by_jet_decoration ( ) const

Returns the string telling the tool in which float AuxElement the information of the separation to the closest jet is stored.

Definition at line 99 of file MuonEfficiencyScaleFactors.cxx.

                                                                              {
        return m_iso_jet_dR;
    }

◆ data_effi_decoration()

std::string CP::MuonEfficiencyScaleFactors::data_effi_decoration ( ) const

Definition at line 115 of file MuonEfficiencyScaleFactors.cxx.

                                                                    {
        return m_efficiency_decoration_name_data.empty() ? std::string("DataEffi") + m_wp : m_efficiency_decoration_name_data;
    }

◆ data_effi_replica_decoration()

std::string CP::MuonEfficiencyScaleFactors::data_effi_replica_decoration ( ) const

Definition at line 124 of file MuonEfficiencyScaleFactors.cxx.

                                                                            {
        return std::string("Replica") + data_effi_decoration();
    }

◆ 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.

95{ return m_detStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ 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.

85{ return m_evtStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ 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

◆ filename_Calo()

std::string CP::MuonEfficiencyScaleFactors::filename_Calo ( ) const

Reconstruction scale-factors have a dedicated map for calo-tag muons around |\eta|<0.1.

If the scale-factor is isolation/TTVA then the central file name is returned

Definition at line 416 of file MuonEfficiencyScaleFactors.cxx.

                                                             {
 
        if (!m_custom_file_Calo.empty()) return resolve_file_location(m_custom_file_Calo);
        else if (m_Type != CP::MuonEfficiencyType::Reco) {
            return filename_Central();
        } else return resolve_file_location("Reco_CaloTag_Z.root"); //note that in rel22 we switched from CaloTag to CaloScore. Now, we're not updating the filename yet to ensure backward compatibility, but it must be clear that in rel22 calibration areas this file will actually contain the CaloScore SFs. 
    }

◆ filename_Central()

std::string CP::MuonEfficiencyScaleFactors::filename_Central ( ) const

The following methods are meant to propagate information from the central tool to the subtool managing the individual scale-factor maps to keep their constructors small in number of arguments.

The users do not have to call them. Construct the name of the input files from the configuration Make these methods public such that they can be used by the scale-factor managing EffiCollection class without piping All arguments to the constructor again

Definition at line 385 of file MuonEfficiencyScaleFactors.cxx.

                                                                {
        if (!m_custom_file_Combined.empty()) return (resolve_file_location(m_custom_file_Combined));
        else if (m_Type == CP::MuonEfficiencyType::Iso) {
            return resolve_file_location(Form("Iso_%s_Z.root", m_wp.c_str()));
        } else if (m_Type == CP::MuonEfficiencyType::TTVA) {
            return resolve_file_location("TTVA_Z.root");
        } else if (m_Type == CP::MuonEfficiencyType::BadMuonVeto) {
            return resolve_file_location("BadMuonVeto_HighPt_Z.root");
        } else if (m_Type == CP::MuonEfficiencyType::Reco) {
            return resolve_file_location(Form("Reco_%s_Z.root", m_wp.c_str()));
        }
        ATH_MSG_ERROR("What?");
        return "";
    }

◆ filename_HighEta()

std::string CP::MuonEfficiencyScaleFactors::filename_HighEta ( ) const

High-eta reconstruction scale-factors are not obtained by the means of are not obtained by the means of tag & probe, but rather by building the double ratio.

The map is delivered in a dedicated file whose path is returned here

Definition at line 423 of file MuonEfficiencyScaleFactors.cxx.

                                                                {
 
        if (!m_custom_file_HighEta.empty()) return resolve_file_location(m_custom_file_HighEta);
        else if (m_Type != CP::MuonEfficiencyType::Reco) {
            return filename_Central();
        } else return resolve_file_location("Reco_HighEta_Z.root");
    }

◆ filename_LowPt()

std::string CP::MuonEfficiencyScaleFactors::filename_LowPt ( ) const

Returns the scale-factor maps from a complementary scale-factor measurement using the J/Psi or Upsilon resonance.

Definition at line 430 of file MuonEfficiencyScaleFactors.cxx.

                                                              {
 
        if (!m_custom_file_LowPt.empty()) return resolve_file_location(m_custom_file_LowPt);
        // for the no reco WPs, we currently use the existing Z SF also for the low pt regime
        else if (m_Type != CP::MuonEfficiencyType::Reco || m_lowpt_threshold < 0) {
            return filename_Central();
        } else return resolve_file_location(Form("Reco_%s_JPsi.root", m_wp.c_str()));
    }

◆ filename_LowPtCalo()

std::string CP::MuonEfficiencyScaleFactors::filename_LowPtCalo ( ) const

Definition at line 446 of file MuonEfficiencyScaleFactors.cxx.

                                                                  {
 
        if (!m_custom_file_LowPtCalo.empty()) return resolve_file_location(m_custom_file_LowPtCalo);
        // for the no reco WPs, we currently use the existing Z SF also for the low pt regime
        else if (m_Type != CP::MuonEfficiencyType::Reco || m_lowpt_threshold < 0) {
            return filename_Central();
        } else return resolve_file_location("Reco_CaloTag_JPsi.root"); //note that in rel22 we switched from CaloTag to CaloScore. Now, we're not updating the filename yet to ensure backward compatibility, but it must be clear that in rel22 calibration areas this file will actually contain the CaloScore SFs. 
    }

◆ filename_LRTCentral()

std::string CP::MuonEfficiencyScaleFactors::filename_LRTCentral ( ) const

LRT muons have their own efficiency maps.

Definition at line 399 of file MuonEfficiencyScaleFactors.cxx.

                                                                   {
        if (!m_custom_file_LRTCombined.empty()) return (resolve_file_location(m_custom_file_LRTCombined));
        else if (m_Type == CP::MuonEfficiencyType::Iso) {
            ATH_MSG_WARNING("Using standard isolation SF for LRT muons");
            return resolve_file_location(Form("Iso_%s_Z.root", m_wp.c_str()));
        } else if (m_Type == CP::MuonEfficiencyType::TTVA) {
            ATH_MSG_WARNING("Using standard TTVA SF for LRT muons");
            return resolve_file_location("TTVA_Z.root");
        } else if (m_Type == CP::MuonEfficiencyType::BadMuonVeto) {
            ATH_MSG_WARNING("Using standard BadMuonVeto SF for LRT muons");
            return resolve_file_location("BadMuonVeto_HighPt_Z.root");
        } else if (m_Type == CP::MuonEfficiencyType::Reco) {
            return resolve_file_location(Form("Reco_%sLRT_Z.root", m_wp.c_str()));
        }
        ATH_MSG_ERROR("What?");
        return "";
    }

◆ filename_LRTLowPt()

std::string CP::MuonEfficiencyScaleFactors::filename_LRTLowPt ( ) const

Definition at line 438 of file MuonEfficiencyScaleFactors.cxx.

                                                                 {
 
        if (!m_custom_file_LRTLowPt.empty()) return resolve_file_location(m_custom_file_LRTLowPt);
        // we use the Z SF for the low pt regime for Run-3
        else if (m_Type != CP::MuonEfficiencyType::Reco || m_lowpt_threshold < 0 || m_calibration_version.find("run3") != std::string::npos) {
            return filename_LRTCentral();
        } else return resolve_file_location(Form("Reco_%sLRT_JPsi.root", m_wp.c_str()));
    }

◆ getDataEfficiency()

CorrectionCode CP::MuonEfficiencyScaleFactors::getDataEfficiency	(	const xAOD::Muon &	mu,
		float &	eff,
		const xAOD::EventInfo *	info = 0 ) const

overridevirtual

Obtain the muon efficiency measured using the data.

Implements CP::IMuonEfficiencyScaleFactors.

Definition at line 310 of file MuonEfficiencyScaleFactors.cxx.

                                                                                                                                {
        if (!m_init) {
            ATH_MSG_ERROR("The tool has not been initialized yet");
            return CorrectionCode::Error;
        }
        unsigned int RunNumber = getRandomRunNumber(info);
        return m_current_sf->retrieveSF(mu, RunNumber)->DataEfficiency(mu, eff);
    }

◆ getDataEfficiencyReplicas()

CorrectionCode CP::MuonEfficiencyScaleFactors::getDataEfficiencyReplicas	(	const xAOD::Muon &	mu,
		std::vector< float > &	sf_err,
		const xAOD::EventInfo *	info = 0 ) const

virtual

Definition at line 326 of file MuonEfficiencyScaleFactors.cxx.

                                                                                                                                                       {
        if (!m_init) {
            ATH_MSG_ERROR("The tool has not been initialized yet");
            return CorrectionCode::Error;
        }
        unsigned int RunNumber = getRandomRunNumber(info);
        return m_current_sf->retrieveSF(mu, RunNumber)->DataEfficiencyReplicas(mu, sf_err);
    }

◆ getEfficiencyScaleFactor() [1/2]

CorrectionCode CP::MuonEfficiencyScaleFactors::getEfficiencyScaleFactor	(	columnar::MuonId	mu,
		float &	sf,
		columnar::EventInfoId	info ) const

Definition at line 277 of file MuonEfficiencyScaleFactors.cxx.

                                                                                                                                    {
        if (!m_init) {
            ATH_MSG_ERROR("The tool has not been initialized yet.");
            return CorrectionCode::Error;
        }
        unsigned int RunNumber = getRandomRunNumber(info);
        return m_current_sf->retrieveSF(mu, RunNumber)->ScaleFactor(mu, sf);
    }

◆ getEfficiencyScaleFactor() [2/2]

CorrectionCode CP::MuonEfficiencyScaleFactors::getEfficiencyScaleFactor	(	const xAOD::Muon &	mu,
		float &	sf,
		const xAOD::EventInfo *	info = 0 ) const

overridevirtual

Retrieve the Scale factor and decorate the muon.

Implements CP::IMuonEfficiencyScaleFactors.

Definition at line 262 of file MuonEfficiencyScaleFactors.cxx.

                                                                                                                                      {
        if (!m_init) {
            ATH_MSG_ERROR("The tool has not been initialized yet.");
            return CorrectionCode::Error;
        }
        if (!info) {
            SG::ReadHandle<xAOD::EventInfo> evtInfo(m_eventInfo);
            info = evtInfo.operator->();
            if (!info) {
                ATH_MSG_ERROR("Could not retrieve the xAOD::EventInfo. Return 999999");
                return CorrectionCode::Error;
            }
        }
        return getEfficiencyScaleFactor (columnar::MuonId (mu), sf, columnar::EventInfoId(*info));
    }

◆ getEfficiencyScaleFactorReplicas()

CorrectionCode CP::MuonEfficiencyScaleFactors::getEfficiencyScaleFactorReplicas	(	const xAOD::Muon &	mu,
		std::vector< float > &	sf_err,
		const xAOD::EventInfo *	info = 0 ) const

overridevirtual

replica generation

Implements CP::IMuonEfficiencyScaleFactors.

Definition at line 294 of file MuonEfficiencyScaleFactors.cxx.

                                                                                                                                                           {
        if (!m_init) {
            ATH_MSG_ERROR("The tool has not been initialized yet");
            return CorrectionCode::Error;
        }
        unsigned int RunNumber = getRandomRunNumber(info);
        return m_current_sf->retrieveSF(mu, RunNumber)->ScaleFactorReplicas(mu, sfs);
    }

◆ 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::TEvent 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::TEvent, 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
   }

◆ getMCEfficiency()

CorrectionCode CP::MuonEfficiencyScaleFactors::getMCEfficiency	(	const xAOD::Muon &	mu,
		float &	eff,
		const xAOD::EventInfo *	info = 0 ) const

overridevirtual

Obtain the muon efficiency measured using the MC.

Implements CP::IMuonEfficiencyScaleFactors.

Definition at line 342 of file MuonEfficiencyScaleFactors.cxx.

                                                                                                                              {
        if (!m_init) {
            ATH_MSG_ERROR("The tool has not been initialized yet");
            return CorrectionCode::Error;
        }
        unsigned int RunNumber = getRandomRunNumber(info);
        return m_current_sf->retrieveSF(mu, RunNumber)->MCEfficiency(mu, eff);
    }

◆ getMCEfficiencyReplicas()

CorrectionCode CP::MuonEfficiencyScaleFactors::getMCEfficiencyReplicas	(	const xAOD::Muon &	mu,
		std::vector< float > &	sf_err,
		const xAOD::EventInfo *	info = 0 ) const

virtual

Definition at line 358 of file MuonEfficiencyScaleFactors.cxx.

                                                                                                                                                     {
        if (!m_init) {
            ATH_MSG_ERROR("The tool has not been initialized yet");
            return CorrectionCode::Error;
        }
        unsigned int RunNumber = getRandomRunNumber(info);
        return m_current_sf->retrieveSF(mu, RunNumber)->MCEfficiencyReplicas(mu, sf_err);
    }

◆ 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::TEvent 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::TEvent, 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
   }

◆ getNCollections()

size_t CP::MuonEfficiencyScaleFactors::getNCollections ( ) const

Returns the number of EffiCollections stored in this class.

Definition at line 138 of file MuonEfficiencyScaleFactors.cxx.

                                                            {
        return m_sf_sets.size();
    }

◆ getPosition()

size_t CP::MuonEfficiencyScaleFactors::getPosition ( const EffiCollection * coll ) const

Returns the position of the collection in the syst set vector.

If the collection is not part of this class -1 is returned

Definition at line 130 of file MuonEfficiencyScaleFactors.cxx.

                                                                                   {
        size_t i = 0;
        for (const auto& sf: m_sf_sets) {
            if (sf.get() == coll) return i;
            ++i;
        }
        return  i;
    }               

◆ getProperty()

template<class T>

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

inherited

Get one of the tool's properties.

◆ getRandomRunNumber() [1/2]

unsigned int CP::MuonEfficiencyScaleFactors::getRandomRunNumber ( columnar::EventInfoId info ) const

private

Definition at line 247 of file MuonEfficiencyScaleFactors.cxx.

                                                                                              {
        const auto& acc = *m_accessors;
        if (!acc.eventTypeAcc(info,xAOD::EventInfo::IS_SIMULATION)) {
            ATH_MSG_DEBUG("The current event is a data event. Return runNumber instead.");
            return acc.runNumberAcc (info);
        }
        if (!acc.acc_rnd.isAvailable(info)) {
            ATH_MSG_WARNING("Failed to find the RandomRunNumber decoration. Please call the apply() method from the PileupReweightingTool before hand in order to get period dependent SFs. You'll receive SFs from the most recent period.");
            return 999999;
        } else if (acc.acc_rnd(info) == 0) {
            ATH_MSG_DEBUG("Pile up tool has given runNumber 0. Return SF from latest period.");
            return 999999;
        }
        return acc.acc_rnd(info);
    }

◆ getRandomRunNumber() [2/2]

unsigned int CP::MuonEfficiencyScaleFactors::getRandomRunNumber ( const xAOD::EventInfo * info ) const

private

Definition at line 236 of file MuonEfficiencyScaleFactors.cxx.

                                                                                               {
        if (!info) {
            SG::ReadHandle<xAOD::EventInfo> evtInfo(m_eventInfo);
            info = evtInfo.operator->();
            if (!info) {
                ATH_MSG_ERROR("Could not retrieve the xAOD::EventInfo. Return 999999");
                return 999999;
            }
        }
        return getRandomRunNumber (columnar::EventInfoId (*info));
    }

◆ getUncorrelatedSysBinName() [1/2]

std::string CP::MuonEfficiencyScaleFactors::getUncorrelatedSysBinName ( const SystematicSet & systConfig ) const

overridevirtual

Implements CP::IMuonEfficiencyScaleFactors.

Definition at line 675 of file MuonEfficiencyScaleFactors.cxx.

                                                                                                         {
        for (std::set<SystematicVariation>::const_iterator t = systConfig.begin(); t != systConfig.end(); ++t) {
             if ((*t).isToyVariation()) {
                 std::pair<unsigned, float> pair = (*t).getToyVariation();
                 return getUncorrelatedSysBinName(pair.first);
            }
      }
      ATH_MSG_ERROR("The given systematic " << systConfig.name() << " is not an unfolded one. Return  unknown bin ");
      return "unknown bin";
    }

◆ getUncorrelatedSysBinName() [2/2]

std::string CP::MuonEfficiencyScaleFactors::getUncorrelatedSysBinName ( unsigned int Bin ) const

overridevirtual

Implements CP::IMuonEfficiencyScaleFactors.

Definition at line 660 of file MuonEfficiencyScaleFactors.cxx.

                                                                                          {
        if (!m_current_sf){
           throw std::runtime_error("No systematic has been loaded. Cannot return any syst-bin") ;
           ATH_MSG_FATAL("No systematic has been loaded. Cannot return any syst-bin");
          
        }        
        return m_current_sf->GetBinName(Bin);
    }

◆ getUnCorrelatedSystBin()

int CP::MuonEfficiencyScaleFactors::getUnCorrelatedSystBin ( const xAOD::Muon & mu ) const

overridevirtual

Implements CP::IMuonEfficiencyScaleFactors.

Definition at line 668 of file MuonEfficiencyScaleFactors.cxx.

                                                                                   {
        if (!m_current_sf){
               ATH_MSG_WARNING("No systematic has been loaded. Cannot return any syst-bin");
               return -1;
        }
        return m_current_sf->getUnCorrelatedSystBin(mu);
    }

◆ initialize()

StatusCode CP::MuonEfficiencyScaleFactors::initialize ( void )

overridevirtual

initialize the tool once all settings are in place!

Overwrite the property in case of the bad muon veto

for isolation efficiencies, we don't use a low pt component for now - set the low pt threshold to -1 same holds for TTVA SF, and for the HighPt WP

Reimplemented from asg::AsgTool.

Definition at line 144 of file MuonEfficiencyScaleFactors.cxx.

                                                      {
        if (m_init) {
            ATH_MSG_INFO("The tool using working point " << m_wp << " is already initialized.");
            return StatusCode::SUCCESS;
        }
        if (m_wp.find("Iso") != std::string::npos) {
            m_Type = CP::MuonEfficiencyType::Iso;
 
        } else if (m_wp.find("BadMuon") != std::string::npos) {
            m_Type = CP::MuonEfficiencyType::BadMuonVeto;
            m_applyKineDepSys = true;
        } else if (m_wp.find("TTVA") != std::string::npos) {
            m_Type = CP::MuonEfficiencyType::TTVA;
        } else {
            m_Type = CP::MuonEfficiencyType::Reco;
            if (m_useLRT && m_wp!="Medium") {
                ATH_MSG_FATAL(Form("Only Medium identification WP is supported for LRT muons. You chose %s.", m_wp.c_str()));
                return StatusCode::FAILURE;
            }
        }
        ATH_MSG_INFO("Efficiency type is = " << EfficiencyTypeName(m_Type));
 
        // temporary workaround to avoid bad Jpsi scale factors
        if (m_lowpt_threshold < 0) { // not set by the user, use default values
            if (m_calibration_version.find("run3") != std::string::npos) {
                m_lowpt_threshold = 1e4;
            } else {
                m_lowpt_threshold = 15e3;
            }
        }
        if (m_Type == CP::MuonEfficiencyType::Iso || m_Type == CP::MuonEfficiencyType::TTVA || m_Type == MuonEfficiencyType::BadMuonVeto || (m_Type == CP::MuonEfficiencyType::Reco && m_wp.find("HighPt") != std::string::npos)) {
            ATH_MSG_DEBUG("We are running Isolation or TTVA or High Pt reco SF, so we use Zmumu based SF for the whole pt range!");
            m_lowpt_threshold = -1;
        } else if (m_lowpt_threshold <= 0) {
            ATH_MSG_INFO("Low pt SF turned off as crossover threshold is negative! Using Zmumu based SF for all pt values.");
        } else {
            ATH_MSG_INFO("JPsi based low pt SF will start to rock below " << m_lowpt_threshold / 1000. << " GeV!");
        }
       
        std::set<std::string> decorations{
            sf_decoration() ,
            data_effi_decoration(),
            mc_effi_decoration() ,
            sf_replica_decoration(),
            data_effi_replica_decoration(),
            mc_effi_replica_deocration()
        };
        if (decorations.size() != 6){
            ATH_MSG_FATAL("At least one of the decoration names for scale-factor/ data-efficiency / mc-efficiency is not uniquely defined... Please check your properties");
            return StatusCode::FAILURE;
        }
 
        ATH_CHECK(m_eventInfo.initialize());
        
        if (!m_custom_dir.empty()) ATH_MSG_WARNING("Note: setting up with user specified input file location " << m_custom_dir << " - this is not encouraged!");
        if (!m_custom_file_Calo.empty()) ATH_MSG_WARNING("Note: setting up with user specified CaloTag input file " << m_custom_file_Calo << " - this is not encouraged!");
        if (!m_custom_file_Combined.empty()) ATH_MSG_WARNING("Note: setting up with user specified Central muon input file " << m_custom_file_Combined << " - this is not encouraged! ");
        if (!m_custom_file_HighEta.empty()) ATH_MSG_WARNING("Note: setting up with user specified High Eta input file " << m_custom_file_HighEta << " - this is not encouraged! ");
        if (!m_custom_file_LowPt.empty()) ATH_MSG_WARNING("Note: setting up with user specified Low Pt input file " << m_custom_file_LowPt << " - this is not encouraged! ");
        if (!m_custom_file_LowPtCalo.empty()) ATH_MSG_WARNING("Note: setting up with user specified Low Pt CaloTag input file " << m_custom_file_LowPtCalo << " - this is not encouraged! ");
        if (!m_custom_file_LRTCombined.empty()) ATH_MSG_WARNING("Note: setting up with user specified Central LRT muon input file " << m_custom_file_LRTCombined << " - this is not encouraged! ");
        if (!m_custom_file_LRTLowPt.empty()) ATH_MSG_WARNING("Note: setting up with user specified Low Pt LRT muon input file " << m_custom_file_LowPt << " - this is not encouraged! ");
        if (m_custom_dir.empty()) ATH_MSG_INFO("Trying to initialize, with working point " << m_wp << ", using calibration release " << m_calibration_version);
 
        ATH_CHECK(LoadInputs());
        
        // m_init has to be true for affectingSystematics()
        m_init = true;
        m_affectingSys = affectingSystematics();
        // set up for default running without systematics
        if (!applySystematicVariation(SystematicSet())) {
            ATH_MSG_ERROR("loading the central value systematic set failed");
            return StatusCode::FAILURE;
        }
 
        // Add the affecting systematics to the global registry
        SystematicRegistry& registry = SystematicRegistry::getInstance();
        if (!registry.registerSystematics(*this)) {
            ATH_MSG_ERROR("unable to register the systematics");
            return StatusCode::FAILURE;
        }
        ATH_MSG_INFO("Successfully initialized! ");
 
        for (auto& sf_set : m_sf_sets)
            addSubtool (*sf_set);
        ATH_CHECK (initializeColumns());
        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 CP::MuonEfficiencyScaleFactors::isAffectedBySystematic ( const SystematicVariation & systematic ) const

overridevirtual

returns: whether this tool is affected by the given systematis

Implements CP::ISystematicsTool.

Definition at line 587 of file MuonEfficiencyScaleFactors.cxx.

                                                                                                       {
        return m_affectingSys.find(systematic) != m_affectingSys.end();
    }

◆ LoadInputs()

StatusCode CP::MuonEfficiencyScaleFactors::LoadInputs ( )

private

load the SF histos

We've at least the stat and sys errors and nothing went wrong during loading the files

Push back the nominal options

Now we can fill the map with the individual sets

Filter the bits which are not assigning the files

J-psi stream... Kick all bits from the Z

...and the Z stream. Kick all bits from the JPsi

Definition at line 456 of file MuonEfficiencyScaleFactors.cxx.

                                                      {
        if (!m_sf_sets.empty()){
            ATH_MSG_DEBUG("Input already loaded will not do it again");
            return StatusCode::SUCCESS;
        }
        std::map<std::string, unsigned int> systematics = lookUpSystematics();
        if (systematics.empty()){
            ATH_MSG_FATAL("No valid systematic could be loaded. Not even the statistical uncertainties");
            return StatusCode::FAILURE;
        }
        
        m_sf_sets.push_back( std::make_unique<EffiCollection>(*this));
        EffiCollection* nominal = m_sf_sets.back().get();
        
        std::function<unsigned int(unsigned int, unsigned int)> not_inB = [](unsigned int a , unsigned int b){
                unsigned int b_flipped = ~b;
                return a & b_flipped;
        };
        for (const auto& syst: systematics){
            if ((syst.second & EffiCollection::ZAnalysis) && (syst.second & EffiCollection::JPsiAnalysis)) {
                m_sf_sets.push_back(std::make_unique < EffiCollection > (nominal, *this, syst.first, not_inB(syst.second, EffiCollection::ZAnalysis), false));
                m_sf_sets.push_back(std::make_unique < EffiCollection > (nominal, *this, syst.first, not_inB(syst.second, EffiCollection::ZAnalysis), true));
                m_sf_sets.push_back(std::make_unique < EffiCollection > (nominal, *this, syst.first, not_inB(syst.second, EffiCollection::JPsiAnalysis), true));
                m_sf_sets.push_back(std::make_unique < EffiCollection > (nominal, *this, syst.first, not_inB(syst.second, EffiCollection::JPsiAnalysis), false));
            } else {
                m_sf_sets.push_back(std::make_unique < EffiCollection > (nominal, *this, syst.first, syst.second, false));
                m_sf_sets.push_back(std::make_unique < EffiCollection > (nominal, *this, syst.first, syst.second, true));
            }
        }
        for(auto& sf: m_sf_sets){
            if (!sf->CheckConsistency()) {
                ATH_MSG_FATAL("Inconsistent scalefactor maps have been found for "<<(sf->getSystSet() ?sf->getSystSet()->name() : "UNKOWN"));
                return StatusCode::FAILURE;
            }
        }
        for (auto& sf_set : m_sf_sets)
            addSubtool (*sf_set);
        return StatusCode::SUCCESS;
    }

◆ lookUpSystematics()

std::map< std::string, unsigned int > CP::MuonEfficiencyScaleFactors::lookUpSystematics ( )

private

Scale-factor files since Moriond2019 contain the breakdown of systematics into their individual components.

This method loads all systematics and looks their systematics up and returns them in a map together with a bitmask which files are affected by the systematic

All file_name methods return the central filename if there is no proper map for that component use a set to sort out all non-defined maps

The bad muon veto measurement only provides a combined systematic uncertainty of the bad-muon veto. No stat error needed in this case

If the systematics shall be split into bins

At the moment the systematic break down is not part of all files ignore if there is no break down

Activate the pt-dependent systematic for the old calibration files by hand

Read out the systematic tree from the scale-factor files

Definition at line 502 of file MuonEfficiencyScaleFactors.cxx.

                                                                                 {
        std::map<std::string, unsigned int> syst_map;
        std::set<std::string>  files_to_look_up{
            filename_Central(),
            filename_Calo(),
            filename_HighEta(),
            filename_LowPt(),
            filename_LowPtCalo()
        };
        if (m_useLRT) { 
            files_to_look_up.insert(filename_LRTCentral());
            files_to_look_up.insert(filename_LRTLowPt());
        }
        std::function<int(const std::string&)> get_bit = [this](const std::string& file_name){
                if (file_name == filename_Central()) return EffiCollection::Central;
                if (file_name == filename_LowPt()) return EffiCollection::CentralLowPt;
                if (file_name == filename_Calo()) return EffiCollection::Calo;
                if (file_name == filename_LowPtCalo()) return EffiCollection::CaloLowPt;
                if (this->use_lrt()) {
                    if (file_name == filename_LRTCentral()) return EffiCollection::Central;
                    if (file_name == filename_LRTLowPt()) return EffiCollection::CentralLowPt;
                }
                // last file which remains is forward
                return EffiCollection::Forward;
        };
        
        std::function<void(const std::string&,int)> insert_bit =[&syst_map](const std::string& key, unsigned int bit){
            if (syst_map.find(key) == syst_map.end()) syst_map.insert(std::pair<std::string, unsigned int>(key,bit));
            else syst_map[key] = syst_map[key] | bit;
        }; 
        for (const auto& look_up : files_to_look_up){
            std::unique_ptr<TFile> root_file(TFile::Open(look_up.c_str(), "READ"));
            if (!root_file || !root_file->IsOpen()){
                ATH_MSG_FATAL("Could not open file "<<look_up);
                syst_map.clear();
                break;
            }
            if (measurement() !=  MuonEfficiencyType::BadMuonVeto){
                insert_bit("STAT", get_bit(look_up));
            }
            if (m_seperateSystBins) insert_bit("STAT", EffiCollection::UnCorrelated);
                          
            TTree* syst_tree = nullptr;
            root_file->GetObject("Systematics", syst_tree);
             
            if (!m_breakDownSyst || syst_tree == nullptr){
                ATH_MSG_DEBUG("The file "<<look_up<<" does not contain any systematic tree. No break down for that one will be considered");
                insert_bit("SYS",get_bit(look_up));
                if (m_applyKineDepSys && (measurement() == MuonEfficiencyType::Reco || measurement() == MuonEfficiencyType::BadMuonVeto)){
                    insert_bit("SYS",  EffiCollection::PtDependent);
                }
                continue;
            }
            std::string* syst_name = nullptr;
            bool is_symmetric(0), has_pt_sys(0), uncorrelated(0);
            if (syst_tree->SetBranchAddress("Name", &syst_name) != 0 || 
                syst_tree->SetBranchAddress("IsSymmetric", &is_symmetric) != 0 || 
                syst_tree->SetBranchAddress("HasPtDependentSys", &has_pt_sys) !=0 ||
                syst_tree->SetBranchAddress("CanBeUncorrelated", &uncorrelated) !=0){
                
            
                ATH_MSG_FATAL("Although "<<look_up<<" has a systematic tree. There is no proper connection to the branches");
                syst_map.clear();
                break;
            }
            for (int i =0; syst_tree->GetEntry(i); ++i){
                insert_bit( *syst_name, get_bit(look_up));
                if (is_symmetric) insert_bit(*syst_name, EffiCollection::Symmetric);
                
                if (m_applyKineDepSys && has_pt_sys)   {
                    insert_bit(*syst_name, EffiCollection::PtDependent);
                }if (m_seperateSystBins && uncorrelated) insert_bit(*syst_name, EffiCollection::UnCorrelated);                
            }
        }
        return syst_map;
    }

◆ lowPtTransition()

float CP::MuonEfficiencyScaleFactors::lowPtTransition ( ) const

If the pt of the muon is below that threshold the J/Psi or Upsilon map is used given that it's available.

Definition at line 105 of file MuonEfficiencyScaleFactors.cxx.

                                                           {
        return m_lowpt_threshold;
    }

◆ mc_effi_decoration()

std::string CP::MuonEfficiencyScaleFactors::mc_effi_decoration ( ) const

Definition at line 118 of file MuonEfficiencyScaleFactors.cxx.

                                                                  {
        return m_efficiency_decoration_name_mc.empty() ? std::string("MCEffi") + m_wp : m_efficiency_decoration_name_mc;
    }    

◆ mc_effi_replica_deocration()

std::string CP::MuonEfficiencyScaleFactors::mc_effi_replica_deocration ( ) const

Definition at line 127 of file MuonEfficiencyScaleFactors.cxx.

                                                                          {
        return std::string("Replica") + mc_effi_decoration();
    }

◆ measurement()

CP::MuonEfficiencyType CP::MuonEfficiencyScaleFactors::measurement ( ) const

Returns the type of the measurement to be carried out... E.g. Reco/TTVA/Iso.

Definition at line 109 of file MuonEfficiencyScaleFactors.cxx.

                                                                      {
        return m_Type;
    }

◆ 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.

◆ 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, KtDeltaRTool, and LundVariablesTool.

Definition at line 131 of file AsgTool.cxx.

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

◆ recommendedSystematics()

SystematicSet CP::MuonEfficiencyScaleFactors::recommendedSystematics ( ) const

overridevirtual

returns: the list of all systematics this tool recommends to use

Implements CP::IReentrantSystematicsTool.

Definition at line 605 of file MuonEfficiencyScaleFactors.cxx.

                                                                           {
        if (!m_init) {
            ATH_MSG_ERROR("The tool has not been initialized yet");
            return CP::SystematicSet();
        }
        return affectingSystematics();
    }

◆ 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();
  }

◆ resolve_file_location()

std::string CP::MuonEfficiencyScaleFactors::resolve_file_location ( const std::string & filename ) const

private

utility method to 'dress' a filename using the path resolver

Definition at line 375 of file MuonEfficiencyScaleFactors.cxx.

                                                                                              {
        if (!m_custom_dir.empty()) {
            return m_custom_dir + "/" + filename;
        }
        std::string fullPathToFile = PathResolverFindCalibFile(Form("MuonEfficiencyCorrections/%s/%s", m_calibration_version.c_str(), filename.c_str()));
        if (fullPathToFile.empty()) {
            ATH_MSG_ERROR("Unable to resolve the input file " << m_calibration_version << "/" << filename << " via the PathResolver!");
        }
        return fullPathToFile;
    }

◆ sf_decoration()

std::string CP::MuonEfficiencyScaleFactors::sf_decoration ( ) const

The apply<Blah> methods decorate their result directly to the muon.

The name of the decorators can be set by the users themselves using several properties. To avoid that systmatics overwrite each other and the nominal the final maps are decorating the muon following the logic <decoration>__<syst_name> The following methods propagate the basic decoration names to the maps

Definition at line 112 of file MuonEfficiencyScaleFactors.cxx.

                                                              {
        return m_sf_decoration_name.empty() ? std::string("SF") + m_wp : m_sf_decoration_name;
    }

◆ sf_replica_decoration()

std::string CP::MuonEfficiencyScaleFactors::sf_replica_decoration ( ) const

Definition at line 121 of file MuonEfficiencyScaleFactors.cxx.

                                                                      {
        return std::string("Replica") + sf_decoration();
    }

◆ 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 >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

◆ 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.

◆ uncorrelate_sys()

bool CP::MuonEfficiencyScaleFactors::uncorrelate_sys ( ) const

Returns a boolean whether the uncorrelation of systematics has been switched on.

Definition at line 108 of file MuonEfficiencyScaleFactors.cxx.

108{ return m_seperateSystBins; }

◆ 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);
      }
    }
  }

◆ use_2D_iso_corrections()

bool CP::MuonEfficiencyScaleFactors::use_2D_iso_corrections ( ) const

option to set if we want to use 1D or 2D isolation SFs

Definition at line 102 of file MuonEfficiencyScaleFactors.cxx.

                                                                 {
        return m_use2DIsoCorr;
    }

◆ use_lrt()

bool CP::MuonEfficiencyScaleFactors::use_lrt ( ) const

option to set if we want to use LRT muons

Definition at line 141 of file MuonEfficiencyScaleFactors.cxx.

                                                  {
        return m_useLRT;
    }

Member Data Documentation

◆ m_accessors

std::unique_ptr<Accessors> CP::MuonEfficiencyScaleFactors::m_accessors

private

Definition at line 217 of file MuonEfficiencyScaleFactors.h.

◆ m_affectingSys

CP::SystematicSet CP::MuonEfficiencyScaleFactors::m_affectingSys

private

Definition at line 200 of file MuonEfficiencyScaleFactors.h.

◆ m_applyKineDepSys

bool CP::MuonEfficiencyScaleFactors::m_applyKineDepSys

private

Definition at line 208 of file MuonEfficiencyScaleFactors.h.

◆ m_breakDownSyst

bool CP::MuonEfficiencyScaleFactors::m_breakDownSyst

private

Definition at line 207 of file MuonEfficiencyScaleFactors.h.

◆ m_calibration_version

std::string CP::MuonEfficiencyScaleFactors::m_calibration_version

private

subfolder to load from the calibration db

Definition at line 192 of file MuonEfficiencyScaleFactors.h.

◆ m_current_sf

EffiCollection* CP::MuonEfficiencyScaleFactors::m_current_sf

private

Pointer to the current active map in terms of systematics.

Definition at line 174 of file MuonEfficiencyScaleFactors.h.

◆ m_custom_dir

std::string CP::MuonEfficiencyScaleFactors::m_custom_dir

private

Definition at line 176 of file MuonEfficiencyScaleFactors.h.

◆ m_custom_file_Calo

std::string CP::MuonEfficiencyScaleFactors::m_custom_file_Calo

private

Definition at line 178 of file MuonEfficiencyScaleFactors.h.

◆ m_custom_file_Combined

std::string CP::MuonEfficiencyScaleFactors::m_custom_file_Combined

private

Definition at line 177 of file MuonEfficiencyScaleFactors.h.

◆ m_custom_file_HighEta

std::string CP::MuonEfficiencyScaleFactors::m_custom_file_HighEta

private

Definition at line 179 of file MuonEfficiencyScaleFactors.h.

◆ m_custom_file_LowPt

std::string CP::MuonEfficiencyScaleFactors::m_custom_file_LowPt

private

Definition at line 180 of file MuonEfficiencyScaleFactors.h.

◆ m_custom_file_LowPtCalo

std::string CP::MuonEfficiencyScaleFactors::m_custom_file_LowPtCalo

private

Definition at line 181 of file MuonEfficiencyScaleFactors.h.

◆ m_custom_file_LRTCombined

std::string CP::MuonEfficiencyScaleFactors::m_custom_file_LRTCombined

private

Definition at line 182 of file MuonEfficiencyScaleFactors.h.

◆ m_custom_file_LRTLowPt

std::string CP::MuonEfficiencyScaleFactors::m_custom_file_LRTLowPt

private

Definition at line 183 of file MuonEfficiencyScaleFactors.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_efficiency_decoration_name_data

std::string CP::MuonEfficiencyScaleFactors::m_efficiency_decoration_name_data

private

Definition at line 187 of file MuonEfficiencyScaleFactors.h.

◆ m_efficiency_decoration_name_mc

std::string CP::MuonEfficiencyScaleFactors::m_efficiency_decoration_name_mc

private

Definition at line 188 of file MuonEfficiencyScaleFactors.h.

◆ m_eventInfo

SG::ReadHandleKey<xAOD::EventInfo> CP::MuonEfficiencyScaleFactors::m_eventInfo {this, "EventInfoContName", "EventInfo", "event info key"}

private

Definition at line 85 of file MuonEfficiencyScaleFactors.h.

85{this, "EventInfoContName", "EventInfo", "event info key"};

◆ 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_filtered_sys_sets

std::unordered_map<CP::SystematicSet, EffiCollection*> CP::MuonEfficiencyScaleFactors::m_filtered_sys_sets

private

It turned out that the code spends a large time in the look up of the systematics.

This map tries to mitigate this issue.

Definition at line 203 of file MuonEfficiencyScaleFactors.h.

◆ m_init

bool CP::MuonEfficiencyScaleFactors::m_init

private

Definition at line 205 of file MuonEfficiencyScaleFactors.h.

◆ m_iso_jet_dR

std::string CP::MuonEfficiencyScaleFactors::m_iso_jet_dR

private

Name of the decoration to catch up the close by jets.

Definition at line 198 of file MuonEfficiencyScaleFactors.h.

◆ m_lowpt_threshold

float CP::MuonEfficiencyScaleFactors::m_lowpt_threshold

private

threshold below which low-pt SF (i.e. from JPsi) should be used

Definition at line 196 of file MuonEfficiencyScaleFactors.h.

◆ m_seperateSystBins

bool CP::MuonEfficiencyScaleFactors::m_seperateSystBins

private

Definition at line 206 of file MuonEfficiencyScaleFactors.h.

◆ m_sf_decoration_name

std::string CP::MuonEfficiencyScaleFactors::m_sf_decoration_name

private

Definition at line 189 of file MuonEfficiencyScaleFactors.h.

◆ m_sf_sets

std::vector<std::unique_ptr<EffiCollection> > CP::MuonEfficiencyScaleFactors::m_sf_sets

private

This vector stores all scale-factor maps.

Definition at line 171 of file MuonEfficiencyScaleFactors.h.

◆ m_Type

CP::MuonEfficiencyType CP::MuonEfficiencyScaleFactors::m_Type

private

Definition at line 212 of file MuonEfficiencyScaleFactors.h.

◆ m_use2DIsoCorr

bool CP::MuonEfficiencyScaleFactors::m_use2DIsoCorr

private

Definition at line 199 of file MuonEfficiencyScaleFactors.h.

◆ m_useLRT

bool CP::MuonEfficiencyScaleFactors::m_useLRT

private

Turn on if using LRT objects.

Definition at line 210 of file MuonEfficiencyScaleFactors.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.

◆ m_wp

std::string CP::MuonEfficiencyScaleFactors::m_wp

private

the working point to operate on

Definition at line 168 of file MuonEfficiencyScaleFactors.h.

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

Classes

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ MuonEfficiencyScaleFactors()

◆ ~MuonEfficiencyScaleFactors()

Member Function Documentation

◆ affectingSystematics()

◆ applyDataEfficiency()

◆ applyDataEfficiencyReplicas()

◆ applyEfficiencyScaleFactor()

◆ applyEfficiencyScaleFactorReplicas()

◆ applyMCEfficiency()

◆ applyMCEfficiencyReplicas()

◆ applySystematicVariation()

◆ callEvents()

◆ callSingleEvent()

◆ close_by_jet_decoration()

◆ data_effi_decoration()

◆ data_effi_replica_decoration()

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ extraDeps_update_handler()

◆ filename_Calo()

◆ filename_Central()

◆ filename_HighEta()

◆ filename_LowPt()

◆ filename_LowPtCalo()

◆ filename_LRTCentral()

◆ filename_LRTLowPt()

◆ getDataEfficiency()

◆ getDataEfficiencyReplicas()

◆ getEfficiencyScaleFactor() [1/2]

◆ getEfficiencyScaleFactor() [2/2]

◆ getEfficiencyScaleFactorReplicas()

◆ getKey()

◆ getMCEfficiency()

◆ getMCEfficiencyReplicas()

◆ getName()

◆ getNCollections()

◆ getPosition()

◆ getProperty()

◆ getRandomRunNumber() [1/2]

◆ getRandomRunNumber() [2/2]

◆ getUncorrelatedSysBinName() [1/2]

◆ getUncorrelatedSysBinName() [2/2]

◆ getUnCorrelatedSystBin()

◆ initialize()

◆ inputHandles()

◆ isAffectedBySystematic()

◆ LoadInputs()

◆ lookUpSystematics()

◆ lowPtTransition()

◆ mc_effi_decoration()

◆ mc_effi_replica_deocration()

◆ measurement()

◆ msg()

◆ msg_level_name()

◆ msgLvl()

◆ outputHandles()

◆ print()

◆ recommendedSystematics()

◆ renounce()

◆ renounceArray()

◆ resolve_file_location()

◆ sf_decoration()

◆ sf_replica_decoration()

◆ sysInitialize()

◆ sysStart()

◆ uncorrelate_sys()

◆ updateVHKA()

◆ use_2D_iso_corrections()