CP::MuonTriggerScaleFactors Class Reference

#include <MuonTriggerScaleFactors.h>

Inheritance diagram for CP::MuonTriggerScaleFactors:

Collaboration diagram for CP::MuonTriggerScaleFactors:

Public Member Functions
	MuonTriggerScaleFactors (const std::string &name)
virtual	~MuonTriggerScaleFactors ()
virtual StatusCode	initialize (void)
virtual CorrectionCode	getTriggerScaleFactor (const xAOD::MuonContainer &mucont, Double_t &triggersf, const std::string &trigger) const
virtual CorrectionCode	getTriggerScaleFactor (const xAOD::Muon &muon, Double_t &triggersf, const std::string &trigger) const
virtual CorrectionCode	getTriggerEfficiency (const xAOD::Muon &mu, Double_t &efficiency, const std::string &trigger, Bool_t dataType) const
virtual bool	isAffectedBySystematic (const CP::SystematicVariation &systematic) const
	Declare the interface that this class provides.
virtual CP::SystematicSet	affectingSystematics () const
	returns: the list of all systematics this tool can be affected by
virtual CP::SystematicSet	recommendedSystematics () const
	returns: the list of all systematics this tool recommends to use
virtual StatusCode	applySystematicVariation (const CP::SystematicSet &systConfig)
	effects: configure this tool for the given list of systematic variations.
virtual int	getBinNumber (const xAOD::Muon &muon, const std::string &trigger) const
virtual int	getReplica_index (const std::string &sysBaseName, const std::string &trigStr) const
virtual bool	isTriggerSupported (const std::string &trigger) const
	Returns whether the trigger is supported by the tool or not. The decision depends on the present (random)RunNumber.
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
virtual std::shared_ptr< TH1 >	getEfficiencyHistogram (unsigned int year, const std::string &period, const std::string &trigger, bool isData, const std::string &Systematic, bool isBarrel=true) const
virtual std::shared_ptr< TH1 >	getEfficiencyHistogram (const std::string &trigger, bool isData, const std::string &Systematic, bool isBarrel=true) const
std::string	getDataPeriod () const
unsigned int	getRunNumber () const
unsigned int	getYear (unsigned int run) const
std::string	getDataPeriod (unsigned int run) const
std::string	getDataPeriod (unsigned int runNumber, unsigned int year) const
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 std::pair< unsigned int, std::string >	YearPeriod
typedef std::pair< YearPeriod, unsigned int >	EffiHistoIdent
typedef std::map< EffiHistoIdent, TH1_Ptr >	EfficiencyMap
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
virtual CorrectionCode	getMuonEfficiency (Double_t &eff, const TrigMuonEff::Configuration &configuration, const xAOD::Muon &muon, const std::string &trigger, const std::string &systematic) const
virtual CorrectionCode	GetTriggerSF_dimu (Double_t &TriggerSF, TrigMuonEff::Configuration &configuration, const xAOD::MuonContainer &mucont, const std::string &trigger) const
virtual CorrectionCode	GetTriggerSF (Double_t &TriggerSF, TrigMuonEff::Configuration &configuration, const xAOD::MuonContainer &mucont, const std::string &trigger) const
virtual CorrectionCode	GetTriggerSF (Double_t &TriggerSF, TrigMuonEff::Configuration &configuration, const xAOD::Muon &muon, const std::string &trigger) const
virtual CorrectionCode	getDimuonEfficiency (Double_t &eff, const TrigMuonEff::Configuration &configuration, const xAOD::MuonContainer &mucont, const std::string &chain, const std::string &systematic) const
const CP::SystematicSet &	appliedSystematics () const
StatusCode	registerSystematics ()
StatusCode	LoadTriggerMap (unsigned int year)
unsigned int	encodeHistoName (const std::string &period, const std::string &Trigger, bool isData, const std::string &Systematic, bool isBarrel=true) const
unsigned int	encodeHistoName (const std::string &Trigger, const TrigMuonEff::Configuration &configuration, const std::string &Systematic, bool isBarrel=true) const
CorrectionCode	getThreshold (Int_t &threshold, const std::string &trigger) const
std::string	getTriggerCorrespondingToDimuonTrigger (const std::string &trigger) const
TDirectory *	getTemporaryDirectory (void) const
std::vector< TH1_Ptr >	generateReplicas (TH1_Ptr h, int nrep, int seed) const
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::unordered_map< CP::SystematicSet, CP::SystematicSet >	m_systFilter
CP::SystematicSet *	m_appliedSystematics {}
EfficiencyMap	m_efficiencyMap
std::map< EffiHistoIdent, std::vector< TH1_Ptr > >	m_efficiencyMapReplicaArray
Gaudi::Property< std::string >	m_muonQuality {this, "MuonQuality", "Medium", "the muon quality to get the scale factors for"}
Gaudi::Property< std::string >	m_campaign {this, "Campaign", "", "the MC campaign to get the scale factors for"}
Gaudi::Property< std::string >	m_calibrationVersion {this, "CalibrationVersion", "250731_SummerUpdate", "the calibration version to use"}
Gaudi::Property< std::string >	m_customInputFolder {this, "CustomInputFolder", "", "the custom input folder to use (debugging only)"}
Gaudi::Property< std::map< unsigned int, std::string > >	m_customInputFilePerYear {this, "CustomInputFilePerYear", {}, "the custom input file to use per year (debugging only)"}
Gaudi::Property< std::string >	m_binning {this, "Binning", "fine", "the binning to use"}
Gaudi::Property< bool >	m_allowZeroSF {this, "AllowZeroSF", false, "if a trigger is not available will return 0 instead of throwing an error. More difficult to spot configuration issues. Use at own risk"}
Gaudi::Property< bool >	m_experimental {this, "UseExperimental", false, "enable experimental features like single muon SF"}
Gaudi::Property< int >	m_forceYear {this, "ForceYear", -1, "Only for developers. Never use this in any analysis!!!!!!"}
Gaudi::Property< std::string >	m_forcePeriod {this, "ForcePeriod", "", "Only for developers. Never use this in any analysis!!!!!!"}
Gaudi::Property< std::vector< std::string > >	m_replicaTriggerList {this, "ReplicaTriggerList", {}, "List of triggers on which we want to generate stat. uncertainty toy replicas."}
std::set< std::string >	m_replicaSet
Gaudi::Property< int >	m_nReplicas {this, "NReplicas", 100, "Number of generated toy replicas, if replicas are required."}
Gaudi::Property< int >	m_ReplicaRandomSeed {this, "ReplicaRandomSeed", 12345, "Random seed for toy replica generation."}
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

Static Private Attributes
static const std::map< unsigned int, int >	m_runNumber_year

Detailed Description

Definition at line 26 of file MuonTriggerScaleFactors.h.

Member Typedef Documentation

EfficiencyMap

typedef std::map<EffiHistoIdent, TH1_Ptr> CP::MuonTriggerScaleFactors::EfficiencyMap

private

Definition at line 88 of file MuonTriggerScaleFactors.h.

EffiHistoIdent

typedef std::pair<YearPeriod, unsigned int> CP::MuonTriggerScaleFactors::EffiHistoIdent

private

Definition at line 87 of file MuonTriggerScaleFactors.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

YearPeriod

typedef std::pair<unsigned int, std::string> CP::MuonTriggerScaleFactors::YearPeriod

private

Definition at line 86 of file MuonTriggerScaleFactors.h.

Constructor & Destructor Documentation

MuonTriggerScaleFactors()

CP::MuonTriggerScaleFactors::MuonTriggerScaleFactors

(

const std::string &

name

)

Definition at line 40 of file MuonTriggerScaleFactors.cxx.

                                                                          :
        asg::AsgTool(name) {}

~MuonTriggerScaleFactors()

CP::MuonTriggerScaleFactors::~MuonTriggerScaleFactors ( )

virtual

Definition at line 43 of file MuonTriggerScaleFactors.cxx.

{ }

Member Function Documentation

affectingSystematics()

CP::SystematicSet CP::MuonTriggerScaleFactors::affectingSystematics ( ) const

virtual

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

Implements CP::IReentrantSystematicsTool.

Definition at line 871 of file MuonTriggerScaleFactors.cxx.

                                                                        {
        CP::SystematicSet mySysSet;
 
        mySysSet.insert(CP::SystematicVariation("MUON_EFF_TrigSystUncertainty", 1));
        mySysSet.insert(CP::SystematicVariation("MUON_EFF_TrigSystUncertainty", -1));
 
        //Consider full statUncertainty if  TOY replicas are not used
        if (m_replicaTriggerList.size() == 0) {
            mySysSet.insert(CP::SystematicVariation("MUON_EFF_TrigStatUncertainty", 1));
            mySysSet.insert(CP::SystematicVariation("MUON_EFF_TrigStatUncertainty", -1));
        } else {
            for (int i = 0; i < m_nReplicas; ++i) { //TOFIX Hack with just up variations! needs ASG reserved words for a clean handling//+++++++
                mySysSet.insert(CP::SystematicVariation(Form("MUON_EFF_Trig_MCTOY%03d", i), 1));
            }
        }
 
        return mySysSet;
    }

appliedSystematics()

const CP::SystematicSet & CP::MuonTriggerScaleFactors::appliedSystematics ( ) const

inlineprivate

Definition at line 70 of file MuonTriggerScaleFactors.h.

                                                              {
                return *m_appliedSystematics;
            }

applySystematicVariation()

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

virtual

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 905 of file MuonTriggerScaleFactors.cxx.

                                                                                                 {
        // First, check if we already know this systematic configuration
        auto itr = m_systFilter.find(systConfig);
 
        // If it's a new input set, we need to filter it
        if (itr == m_systFilter.end()) {
 
            // New systematic. We need to parse it.
            static const CP::SystematicSet affectingSys = affectingSystematics();
            CP::SystematicSet filteredSys;
            if (!CP::SystematicSet::filterForAffectingSystematics(systConfig, affectingSys, filteredSys)) {
                ATH_MSG_ERROR("Unsupported combination of systematics passed to the tool!");
                return StatusCode::FAILURE;
            }
 
            // Insert filtered set into the map
            itr = m_systFilter.insert(std::make_pair(systConfig, filteredSys)).first;
        }
 
        CP::SystematicSet& mySysConf = itr->second;
 
        // Check to see if the set of variations tries to add in the uncertainty up and down. Since the errors
        // are symetric this would result in 0 and so should not be done.
        static const CP::SystematicVariation stat_up("MUON_EFF_TrigStatUncertainty", 1);
        static const CP::SystematicVariation stat_down("MUON_EFF_TrigStatUncertainty", -1);
        static const CP::SystematicVariation syst_up("MUON_EFF_TrigSystUncertainty", 1);
        static const CP::SystematicVariation syst_down("MUON_EFF_TrigSystUncertainty", -1);
 
        if ((mySysConf.matchSystematic(stat_up) && mySysConf.matchSystematic(stat_down)) || (mySysConf.matchSystematic(syst_up) && mySysConf.matchSystematic(syst_down))) {
            return StatusCode::FAILURE;
        }
 
        m_appliedSystematics = &mySysConf;
        return StatusCode::SUCCESS;
    }

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

encodeHistoName() [1/2]

unsigned int CP::MuonTriggerScaleFactors::encodeHistoName ( const std::string & period, const std::string & Trigger, bool isData, const std::string & Systematic, bool isBarrel = true ) const

private

Definition at line 383 of file MuonTriggerScaleFactors.cxx.

                                                                                                                                                                          {
        //keep the string as short as possible
        const std::string histName = period + "_" + Trigger + "_" + (isBarrel ? "b" : "e") + "_" + (isData ? "data" : "mc") + Systematic;
        return std::hash<std::string>()(histName);
    }

encodeHistoName() [2/2]

unsigned int CP::MuonTriggerScaleFactors::encodeHistoName ( const std::string & Trigger, const TrigMuonEff::Configuration & configuration, const std::string & Systematic, bool isBarrel = true ) const

private

Definition at line 389 of file MuonTriggerScaleFactors.cxx.

                                                                                                                                                                                   {
        //keep the string as short as possible
        return encodeHistoName(getDataPeriod(), Trigger, configuration.isData, Systematic, isBarrel);
 
    }

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

generateReplicas()

std::vector< TH1_Ptr > CP::MuonTriggerScaleFactors::generateReplicas ( TH1_Ptr h, int nrep, int seed ) const

private

Definition at line 338 of file MuonTriggerScaleFactors.cxx.

                                                                                                    {
        TRandom3 Rndm(seed);
        std::vector<TH1_Ptr> replica_v;
        const int xbins = h->GetNbinsX(), ybins = h->GetNbinsY();
 
        for (int t = 0; t < nrep; ++t) {
            TH2* replica = dynamic_cast<TH2*>(h->Clone(Form("rep%d_%s", t, h->GetName())));
 
            for (int x_i = 0; x_i <= xbins; ++x_i) {
                for (int y_i = 0; y_i <= ybins; ++y_i) {
                    replica->SetBinContent(x_i, y_i, Rndm.Gaus(h->GetBinContent(x_i, y_i), h->GetBinError(x_i, y_i)));
                }
            }
            replica_v.push_back(TH1_Ptr(replica));
        }
        return replica_v;
    }

getBinNumber()

int CP::MuonTriggerScaleFactors::getBinNumber ( const xAOD::Muon & muon, const std::string & trigger ) const

virtual

Implements CP::IMuonTriggerScaleFactors.

Definition at line 361 of file MuonTriggerScaleFactors.cxx.

                                                                                               {
    if(!m_experimental){
      ATH_MSG_ERROR("MuonTriggerScaleFactors::getTriggerScaleFactor This is an experimental function. If you really know what you are doing set UseExperimental property.");
      return CorrectionCode::Error;
    }
 
    const double mu_eta = muon.eta();
    const double mu_phi = muon.phi();
    bool isBarrel = std::abs(mu_eta) < muon_barrel_endcap_boundary;
    TH1_Ptr cit = getEfficiencyHistogram(trigger, true, "nominal", isBarrel);
    if(!cit.get()){
      if(!m_allowZeroSF)
    ATH_MSG_ERROR("Could not find efficiency map for muon with eta: " << mu_eta << " and phi: " << mu_phi << ". Something is inconsistent. Please check your settings for year, mc and trigger." );
      return -1;
    }
    auto eff_h2 = cit;
    double mu_phi_corr = mu_phi;
    if (mu_phi_corr < eff_h2->GetYaxis()->GetXmin()) mu_phi_corr += 2.0 * M_PI;
    if (mu_phi_corr > eff_h2->GetYaxis()->GetXmax()) mu_phi_corr -= 2.0 * M_PI;
    return eff_h2->FindFixBin(mu_eta, mu_phi_corr);
  }

getDataPeriod() [1/3]

std::string CP::MuonTriggerScaleFactors::getDataPeriod ( ) const

protected

Definition at line 728 of file MuonTriggerScaleFactors.cxx.

                                                           {
      return getDataPeriod(getRunNumber());
    }

getDataPeriod() [2/3]

std::string CP::MuonTriggerScaleFactors::getDataPeriod ( unsigned int run ) const

protected

Definition at line 732 of file MuonTriggerScaleFactors.cxx.

                                                                           {
        return getDataPeriod(run, getYear(run));
    }

getDataPeriod() [3/3]

std::string CP::MuonTriggerScaleFactors::getDataPeriod ( unsigned int runNumber, unsigned int year ) const

protected

getDimuonEfficiency()

CorrectionCode CP::MuonTriggerScaleFactors::getDimuonEfficiency ( Double_t & eff, const TrigMuonEff::Configuration & configuration, const xAOD::MuonContainer & mucont, const std::string & chain, const std::string & systematic ) const

privatevirtual

Definition at line 669 of file MuonTriggerScaleFactors.cxx.

                                                                                                                                                                                                                       {
 
        std::string trigger = getTriggerCorrespondingToDimuonTrigger(chain);
        Int_t threshold;
        CorrectionCode result = getThreshold(threshold, trigger);
        if (result != CorrectionCode::Ok) return result;
 
        xAOD::MuonContainer::const_iterator mu1 = mucont.begin();
        xAOD::MuonContainer::const_iterator mu2 = mucont.begin() + 1;
 
        Double_t eff1 = 0;
        if ((**mu1).pt() > threshold) {
            CorrectionCode result1 = getMuonEfficiency(eff1, configuration, (**mu1), trigger, systematic);
            if (result1 != CorrectionCode::Ok) return result1;
        }
        Double_t eff2 = 0;
        if ((**mu2).pt() > threshold) {
            CorrectionCode result2 = getMuonEfficiency(eff2, configuration, (**mu2), trigger, systematic);
            if (result2 != CorrectionCode::Ok) return result2;
        }
 
        eff = eff1 * eff2;
        return CorrectionCode::Ok;
    }

getEfficiencyHistogram() [1/2]

TH1_Ptr CP::MuonTriggerScaleFactors::getEfficiencyHistogram ( const std::string & trigger, bool isData, const std::string & Systematic, bool isBarrel = true ) const

protectedvirtual

Definition at line 403 of file MuonTriggerScaleFactors.cxx.

                                                                                                                                                   {
        unsigned int run = getRunNumber();
        return getEfficiencyHistogram(getYear(run), getDataPeriod(run), trigger, isData, Systematic, isBarrel);
    }

getEfficiencyHistogram() [2/2]

TH1_Ptr CP::MuonTriggerScaleFactors::getEfficiencyHistogram ( unsigned int year, const std::string & period, const std::string & trigger, bool isData, const std::string & Systematic, bool isBarrel = true ) const

protectedvirtual

Definition at line 394 of file MuonTriggerScaleFactors.cxx.

                                                                                                                                                                                               {
        EffiHistoIdent Ident = EffiHistoIdent(YearPeriod(year, period), encodeHistoName(period, trigger, isData, Systematic, isBarrel));
        EfficiencyMap::const_iterator Itr = m_efficiencyMap.find(Ident);
 
        if (Itr == m_efficiencyMap.end()) {
            return TH1_Ptr();
        }
        return Itr->second;
    }

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
   }

getMuonEfficiency()

CorrectionCode CP::MuonTriggerScaleFactors::getMuonEfficiency ( Double_t & eff, const TrigMuonEff::Configuration & configuration, const xAOD::Muon & muon, const std::string & trigger, const std::string & systematic ) const

privatevirtual

Definition at line 408 of file MuonTriggerScaleFactors.cxx.

                                                                                                                                                                                                            {
        const double mu_eta = muon.eta();
        const double mu_phi = muon.phi();
        bool isBarrel = std::abs(mu_eta) < muon_barrel_endcap_boundary;
 
        TH1_Ptr eff_h2 = nullptr;
        if (configuration.replicaIndex >= 0) { //Only look into the replicas if asking for them
 
            unsigned int run = getRunNumber();
            EffiHistoIdent Ident = EffiHistoIdent(YearPeriod(getYear(run), getDataPeriod(run)), encodeHistoName(getDataPeriod(run), trigger, configuration.isData, "repl", isBarrel));
            std::map<EffiHistoIdent, std::vector<TH1_Ptr> >::const_iterator cit = m_efficiencyMapReplicaArray.find(Ident);
            if (cit == m_efficiencyMapReplicaArray.end()) {
                if (m_allowZeroSF) {
                    ATH_MSG_WARNING("Could not find what you are looking for in the efficiency map. The trigger you are looking for, year and mc are not consistent, or the trigger is unavailable in this data period. Returning efficiency = 0.");
                    eff = 0.;
                    return CorrectionCode::Ok;
                }
 
                else {
                    ATH_MSG_ERROR("Could not find what you are looking for in the efficiency map. The trigger you are looking for, year and mc are not consistent, or the trigger is unavailable in this data period. Please check how you set up the tool.");
                    return CorrectionCode::OutOfValidityRange;
                }
            }
 
            if (configuration.replicaIndex >= (int) cit->second.size()) {
                ATH_MSG_ERROR("MuonTriggerScaleFactors::getMuonEfficiency ; index for replicated histograms is out of range.");
                return CorrectionCode::OutOfValidityRange;
            }
 
            eff_h2 = cit->second[configuration.replicaIndex];
        } else { //Standard case, look into the usual eff map
            TH1_Ptr cit = getEfficiencyHistogram(trigger, configuration.isData, systematic, isBarrel);
            if (cit.get() == nullptr) {
                if (m_allowZeroSF) {
                    ATH_MSG_WARNING("Could not find what you are looking for in the efficiency map. The trigger you are looking for, year and mc are not consistent, or the trigger is unavailable in this data period. Returning efficiency = 0.");
                    eff = 0.;
                    return CorrectionCode::Ok;
                } else {
                    ATH_MSG_ERROR("Could not find what you are looking for in the efficiency map. The trigger you are looking for, year and mc are not consistent, or the trigger is unavailable in this data period. Please check how you set up the tool.");
                    return CorrectionCode::OutOfValidityRange;
                }
            }
            eff_h2 = cit;
        }
 
        double mu_phi_corr = mu_phi;
        if (mu_phi_corr < eff_h2->GetYaxis()->GetXmin()) mu_phi_corr += 2.0 * M_PI;
        if (mu_phi_corr > eff_h2->GetYaxis()->GetXmax()) mu_phi_corr -= 2.0 * M_PI;
 
        const int bin = eff_h2->FindFixBin(mu_eta, mu_phi_corr);
        const double efficiency = eff_h2->GetBinContent(bin);
 
        eff = efficiency;
 
        ATH_MSG_DEBUG("getMuonEfficiency [eta,phi,phi_corr]=[" << mu_eta << "," << mu_phi << "," << mu_phi_corr << "], ibin=" << bin << " eff=" << eff);
 
        return CorrectionCode::Ok;
 
    }

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
   }

getProperty()

template<class T>

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

inherited

Get one of the tool's properties.

getReplica_index()

int CP::MuonTriggerScaleFactors::getReplica_index ( const std::string & sysBaseName, const std::string & trigStr ) const

virtual

Definition at line 274 of file MuonTriggerScaleFactors.cxx.

                                                                                                             {
        if (m_replicaSet.find(trigStr) == m_replicaSet.end()) return -1; //No toys for this trigger
        std::size_t pos = sysBaseName.find("MCTOY");
        if (pos == std::string::npos) return -1; //sys variation not affected by TOYS
        return atoi(sysBaseName.substr(pos + 5, pos + 8).c_str()); //toys for this trigger are around get the 3-digit number
    }

getRunNumber()

unsigned int CP::MuonTriggerScaleFactors::getRunNumber ( ) const

protected

Definition at line 816 of file MuonTriggerScaleFactors.cxx.

                                                             {
        static const SG::AuxElement::ConstAccessor<unsigned int> acc_rnd("RandomRunNumber");
        SG::ReadHandle<xAOD::EventInfo> info(m_eventInfo);
        if (info.operator->()==nullptr) {
            ATH_MSG_FATAL("Could not retrieve the xAOD::EventInfo with name: " << m_eventInfo.key() << ". Exiting the code.");
            throw std::invalid_argument{""};
        }
        if (!info->eventType(xAOD::EventInfo::IS_SIMULATION)) {
            ATH_MSG_DEBUG("The current event is a data event. Return runNumber instead.");
            return info->runNumber();
        }
        if (!acc_rnd.isAvailable(*info)) {
            if(m_forceYear == -1 && m_forcePeriod == "")
            ATH_MSG_FATAL("Failed to find the RandomRunNumber decoration. Please call the apply() method from the PileupReweightingTool beforehand in order to get period dependent SFs");
            throw std::invalid_argument{""};
        } else if (acc_rnd(*info) == 0) {
            ATH_MSG_FATAL("Pile up tool has given runNumber 0. Exiting the code.");
            throw std::invalid_argument{""};
        }
 
        // standard behaviour for MC, get the random RunNumber
        return acc_rnd(*info);
    }

getTemporaryDirectory()

TDirectory * CP::MuonTriggerScaleFactors::getTemporaryDirectory ( void ) const

private

Definition at line 840 of file MuonTriggerScaleFactors.cxx.

                                                                         {
        gROOT->cd();
        TDirectory* tempDir = 0;
        int counter = 0;
        while (not tempDir) {
            std::stringstream dirname;
            dirname << "MuonTriggerScaleFactorsTempDir_%i" << counter;
            if (gROOT->GetDirectory((dirname.str()).c_str())) {
                ++counter;
                continue;
            }
            tempDir = gROOT->mkdir((dirname.str()).c_str());
            if (not tempDir) {
                ATH_MSG_ERROR("getTemporaryDirectory::Temporary directory could not be created");
            }
        }
        return tempDir;
    }

getThreshold()

CorrectionCode CP::MuonTriggerScaleFactors::getThreshold ( Int_t & threshold, const std::string & trigger ) const

private

Definition at line 700 of file MuonTriggerScaleFactors.cxx.

                                                                                                        {
        std::size_t index = trigger.find("HLT_mu");
        if (index != std::string::npos) {
            std::string rawNumber = trigger.substr(index + 6);
            if (!rawNumber.empty() && isdigit(rawNumber[0])) {
                std::stringstream(rawNumber) >> threshold;
                if (threshold < 10) threshold = 10000;
                else threshold = (threshold + 1) * 1000;
                return CorrectionCode::Ok;
            }
        }
        ATH_MSG_ERROR("MuonTriggerScaleFactors::getThreshold Could not extract threshold for trigger " << trigger);
        return CorrectionCode::Error;
    }

getTriggerCorrespondingToDimuonTrigger()

std::string CP::MuonTriggerScaleFactors::getTriggerCorrespondingToDimuonTrigger ( const std::string & trigger ) const

private

Definition at line 694 of file MuonTriggerScaleFactors.cxx.

                                                                                                            {
        if (trigger.find("2mu10") != std::string::npos) return "HLT_mu10";
        if (trigger.find("2mu14") != std::string::npos) return "HLT_mu14";
        throw std::runtime_error("Unknown dimuon trigger");
    }

getTriggerEfficiency()

CorrectionCode CP::MuonTriggerScaleFactors::getTriggerEfficiency ( const xAOD::Muon & mu, Double_t & efficiency, const std::string & trigger, Bool_t dataType ) const

virtual

Implements CP::IMuonTriggerScaleFactors.

Definition at line 281 of file MuonTriggerScaleFactors.cxx.

                                                                                                                                                         {
        if (trigger.empty()) {
            ATH_MSG_ERROR("MuonTriggerScaleFactors::getTriggerEfficiency Trigger must have value.");
            return CorrectionCode::Error;
        }
        TrigMuonEff::Configuration configuration;
        configuration.isData = dataType;
        configuration.replicaIndex = -1;
        Int_t threshold;
        CorrectionCode result = getThreshold(threshold, trigger);
        if (result != CorrectionCode::Ok) return result;
        if (mu.pt() < threshold) {
            efficiency = 0;
            return CorrectionCode::Ok;
        }
 
        // Pre-define uncertainty variations
        static const CP::SystematicVariation stat_up("MUON_EFF_TrigStatUncertainty", 1);
        static const CP::SystematicVariation stat_down("MUON_EFF_TrigStatUncertainty", -1);
        static const CP::SystematicVariation syst_up("MUON_EFF_TrigSystUncertainty", 1);
        static const CP::SystematicVariation syst_down("MUON_EFF_TrigSystUncertainty", -1);
 
        std::string systype = "";
        if (appliedSystematics().matchSystematic(syst_down) && !dataType) {
            systype = "syst_down";
        } else if (appliedSystematics().matchSystematic(syst_up) && !dataType) {
            systype = "syst_up";
        } else if (appliedSystematics().matchSystematic(stat_down)) {
            systype = "stat_down";
        } else if (appliedSystematics().matchSystematic(stat_up)) {
            systype = "stat_up";
        } else {
            systype = "nominal";
        }
 
        // Toys, if found, will overwrite the data hists stat with the generated toy
        //+++++++++++++
        // The best way is the use of filterByName with the 000MCTOY at the end. See:
        // if( !(appliedSystematics().filterByBaseName("MUON_EFF_Trig_MCTOY000")).empty()){//The following is a hack!!!
        //++++++++++THE FOLLOWING IS A PARTIAL HACK!!!
        if (!appliedSystematics().empty() && configuration.isData == true) {
            configuration.replicaIndex = getReplica_index(appliedSystematics().begin()->basename(), trigger);
            if (configuration.replicaIndex != -1) systype = "replicas";
        }
        CorrectionCode cc = getMuonEfficiency(efficiency, configuration, mu, trigger, systype);
        return cc;
    }

getTriggerScaleFactor() [1/2]

CorrectionCode CP::MuonTriggerScaleFactors::getTriggerScaleFactor ( const xAOD::Muon & muon, Double_t & triggersf, const std::string & trigger ) const

virtual

Implements CP::IMuonTriggerScaleFactors.

Definition at line 226 of file MuonTriggerScaleFactors.cxx.

                                                                                                                                           {
      if(!m_experimental){
    ATH_MSG_ERROR("MuonTriggerScaleFactors::getTriggerScaleFactor This is an experimental function. If you really know what you are doing set UseExperimental property.");
      return CorrectionCode::Error;
      }
 
      if (trigger.empty()) {
    ATH_MSG_ERROR("MuonTriggerScaleFactors::getTriggerScaleFactor Trigger must have value.");
    return CorrectionCode::Error;
      }
 
      TrigMuonEff::Configuration configuration;
 
      if (trigger == "HLT_mu8noL1")
    ATH_MSG_WARNING("What you are trying to do is not correct. For di-muon triggers you should get the efficiency with getTriggerEfficiency and compute the SF by yourself.");
      else if (trigger.find("HLT_2mu10") != std::string::npos || trigger.find("HLT_2mu14") != std::string::npos)
    ATH_MSG_WARNING("Di-muon trigger scale factors for single reco muons are not supported!");
      else
    return GetTriggerSF(triggersf, configuration, muon, trigger);
      return CorrectionCode::Ok;
    }

getTriggerScaleFactor() [2/2]

CorrectionCode CP::MuonTriggerScaleFactors::getTriggerScaleFactor ( const xAOD::MuonContainer & mucont, Double_t & triggersf, const std::string & trigger ) const

virtual

Implements CP::IMuonTriggerScaleFactors.

Definition at line 248 of file MuonTriggerScaleFactors.cxx.

                                                                                                                                                     {
        if (trigger.empty()) {
            ATH_MSG_ERROR("MuonTriggerScaleFactors::getTriggerScaleFactor Trigger must have value.");
            return CorrectionCode::Error;
        }
 
        TrigMuonEff::Configuration configuration;
 
        if (trigger == "HLT_mu8noL1") {
            ATH_MSG_WARNING("What you are trying to do is not correct. For di-muon triggers you should get the efficiency with getTriggerEfficiency and compute the SF by yourself.");
        } else if (trigger.find("HLT_2mu10") != std::string::npos || trigger.find("HLT_2mu14") != std::string::npos) {
            CorrectionCode cc = GetTriggerSF_dimu(triggersf, configuration, mucont, trigger);
            return cc;
        } else {
            CorrectionCode cc = GetTriggerSF(triggersf, configuration, mucont, trigger);
            return cc;
        }
        return CorrectionCode::Ok;
    }

GetTriggerSF() [1/2]

CorrectionCode CP::MuonTriggerScaleFactors::GetTriggerSF ( Double_t & TriggerSF, TrigMuonEff::Configuration & configuration, const xAOD::Muon & muon, const std::string & trigger ) const

privatevirtual

Definition at line 606 of file MuonTriggerScaleFactors.cxx.

                                                                                                                                                                      {
        Int_t threshold;
        CorrectionCode result = getThreshold(threshold, trigger);
        if (result != CorrectionCode::Ok)
      return result;
 
    double eff_data = 0., eff_mc = 0.;
 
    if (mu.pt() < threshold) {
      eff_data = 0.;
      eff_mc = 0.;
      TriggerSF = 1.;
      return CorrectionCode::Ok;
    }
 
    std::string muon_trigger_name = trigger;
    std::string data_err = "";
    std::string mc_err = "";
 
    // Pre-define uncertainty variations
    static const CP::SystematicVariation stat_up("MUON_EFF_TrigStatUncertainty", 1);
    static const CP::SystematicVariation stat_down("MUON_EFF_TrigStatUncertainty", -1);
    static const CP::SystematicVariation syst_up("MUON_EFF_TrigSystUncertainty", 1);
    static const CP::SystematicVariation syst_down("MUON_EFF_TrigSystUncertainty", -1);
 
    if (appliedSystematics().matchSystematic(syst_down)) {
      data_err = "nominal";
      mc_err = "syst_up";
    } else if (appliedSystematics().matchSystematic(syst_up)) {
      data_err = "nominal";
      mc_err = "syst_down";
    } else if (appliedSystematics().matchSystematic(stat_down)) {
      data_err = "stat_down";
      mc_err = "nominal";
    } else if (appliedSystematics().matchSystematic(stat_up)) {
      data_err = "stat_up";
      mc_err = "nominal";
    } else {
      data_err = "nominal";
      mc_err = "nominal";
    }
 
    if (!appliedSystematics().empty()) {
      configuration.replicaIndex = getReplica_index(appliedSystematics().begin()->basename(), trigger);
      if (configuration.replicaIndex != -1) data_err = "replicas";
    }
 
    configuration.isData = true;
    CorrectionCode result_data = getMuonEfficiency(eff_data, configuration, mu, muon_trigger_name, data_err);
    if (result_data != CorrectionCode::Ok)
      return result_data;
    configuration.isData = false;
    configuration.replicaIndex = -1;
    CorrectionCode result_mc = getMuonEfficiency(eff_mc, configuration, mu, muon_trigger_name, mc_err);
    if (result_mc != CorrectionCode::Ok)
      return result_mc;
    if (eff_data == 0)
      TriggerSF =  0;
        if (std::abs(eff_mc) > 0.0001)
      TriggerSF = eff_data / eff_mc;
        return CorrectionCode::Ok;
  }

GetTriggerSF() [2/2]

CorrectionCode CP::MuonTriggerScaleFactors::GetTriggerSF ( Double_t & TriggerSF, TrigMuonEff::Configuration & configuration, const xAOD::MuonContainer & mucont, const std::string & trigger ) const

privatevirtual

Definition at line 527 of file MuonTriggerScaleFactors.cxx.

                                                                                                                                                                                     {
        Int_t threshold;
        CorrectionCode result = getThreshold(threshold, trigger);
        if (result != CorrectionCode::Ok) return result;
 
        double rate_not_fired_data = 1.;
        double rate_not_fired_mc = 1.;
 
        for (const auto mu : mucont) {
 
            double eff_data = 0., eff_mc = 0.;
 
            if (mu->pt() < threshold) {
 
                eff_data = 0.;
                eff_mc = 0.;
 
            } else {
 
                std::string muon_trigger_name = trigger;
                std::string data_err = "";
                std::string mc_err = "";
 
                // Pre-define uncertainty variations
                static const CP::SystematicVariation stat_up("MUON_EFF_TrigStatUncertainty", 1);
                static const CP::SystematicVariation stat_down("MUON_EFF_TrigStatUncertainty", -1);
                static const CP::SystematicVariation syst_up("MUON_EFF_TrigSystUncertainty", 1);
                static const CP::SystematicVariation syst_down("MUON_EFF_TrigSystUncertainty", -1);
 
                if (appliedSystematics().matchSystematic(syst_down)) {
                    data_err = "nominal";
                    mc_err = "syst_up";
                } else if (appliedSystematics().matchSystematic(syst_up)) {
                    data_err = "nominal";
                    mc_err = "syst_down";
                } else if (appliedSystematics().matchSystematic(stat_down)) {
                    data_err = "stat_down";
                    mc_err = "nominal";
                } else if (appliedSystematics().matchSystematic(stat_up)) {
                    data_err = "stat_up";
                    mc_err = "nominal";
                } else {
                    data_err = "nominal";
                    mc_err = "nominal";
                }
 
                //Toys, if found, will overwrite the data hists, on which toys for stat uncertainty have been generated
                //+++++++++++++
                //The best way is the use of filterByName with the 000MCTOY at the end. See:
                // if( !(appliedSystematics().filterByBaseName("MUON_EFF_Trig_MCTOY000")).empty()){//The following is a hack!!!
                //++++++++++The following is a hack!!!
                if (!appliedSystematics().empty()) {
                    configuration.replicaIndex = getReplica_index(appliedSystematics().begin()->basename(), trigger);
                    if (configuration.replicaIndex != -1) data_err = "replicas";
                }
 
                configuration.isData = true;
                CorrectionCode result_data = getMuonEfficiency(eff_data, configuration, *mu, muon_trigger_name, data_err);
                if (result_data != CorrectionCode::Ok) return result_data;
                configuration.isData = false;
                configuration.replicaIndex = -1;
                CorrectionCode result_mc = getMuonEfficiency(eff_mc, configuration, *mu, muon_trigger_name, mc_err);
                if (result_mc != CorrectionCode::Ok) return result_mc;
            }
            rate_not_fired_data *= (1. - eff_data);
            rate_not_fired_mc *= (1. - eff_mc);
        }
 
        double event_SF = 1.;
        if (1 - rate_not_fired_data == 0) event_SF = 0;
        if ((mucont.size()) and (std::abs(1. - rate_not_fired_mc) > 0.0001)) {
 
            event_SF = (1. - rate_not_fired_data) / (1. - rate_not_fired_mc);
        }
        TriggerSF = event_SF;
 
        return CorrectionCode::Ok;
    }

GetTriggerSF_dimu()

CorrectionCode CP::MuonTriggerScaleFactors::GetTriggerSF_dimu ( Double_t & TriggerSF, TrigMuonEff::Configuration & configuration, const xAOD::MuonContainer & mucont, const std::string & trigger ) const

privatevirtual

Definition at line 468 of file MuonTriggerScaleFactors.cxx.

                                                                                                                                                                                          {
 
        if (mucont.size() != 2) {
            ATH_MSG_FATAL("MuonTriggerScaleFactors::GetTriggerSF;Currently dimuon trigger chains only implemented for events with exactly 2 muons.");
        }
        ATH_MSG_DEBUG("The trigger that you choose : " << trigger);
 
        Double_t eff_data = 0;
        Double_t eff_mc = 0;
 
        std::string data_err = "";
        std::string mc_err = "";
 
        if (appliedSystematics().matchSystematic(CP::SystematicVariation("MUON_EFF_TrigSystUncertainty", -1))) {
            data_err = "nominal";
            mc_err = "syst_up";
        } else if (appliedSystematics().matchSystematic(CP::SystematicVariation("MUON_EFF_TrigSystUncertainty", 1))) {
            data_err = "nominal";
            mc_err = "syst_down";
        } else if (appliedSystematics().matchSystematic(CP::SystematicVariation("MUON_EFF_TrigStatUncertainty", -1))) {
            data_err = "stat_down";
            mc_err = "nominal";
        } else if (appliedSystematics().matchSystematic(CP::SystematicVariation("MUON_EFF_TrigStatUncertainty", 1))) {
            data_err = "stat_up";
            mc_err = "nominal";
        } else {
            data_err = "nominal";
            mc_err = "nominal";
        }
 
        //Toys, if found, will overwrite the data hists with the sys generated with one toy
        //+++++++++++++
        //The best way is the use of filterByName with the 000MCTOY at the end. See:
        // if( !(appliedSystematics().filterByBaseName("MUON_EFF_Trig_MCTOY000")).empty()){//The following is a hack!!!
        //++++++++++THE FOLLOWING IS A PARTIAL HACK!!!
        if (!appliedSystematics().empty()) {
            configuration.replicaIndex = getReplica_index(appliedSystematics().begin()->basename(), trigger);
            if (configuration.replicaIndex != -1) data_err = "replicas";
        }
 
        configuration.isData = true;
        CorrectionCode result = getDimuonEfficiency(eff_data, configuration, mucont, trigger, data_err);
        if (result != CorrectionCode::Ok) return result;
 
        configuration.isData = false;
        configuration.replicaIndex = -1;
        result = getDimuonEfficiency(eff_mc, configuration, mucont, trigger, mc_err);
        if (result != CorrectionCode::Ok) return result;
 
        double event_SF = 1.;
 
        if (std::abs(1. - eff_mc) > 0.0001) {
            event_SF = eff_data / eff_mc;
        }
 
        TriggerSF = event_SF;
        return CorrectionCode::Ok;
    }

getYear()

unsigned int CP::MuonTriggerScaleFactors::getYear ( unsigned int run ) const

protected

Definition at line 715 of file MuonTriggerScaleFactors.cxx.

                                                                        {
      if(m_forceYear != -1){
        return m_forceYear;
      }
 
      int year=2050;
      auto lower = m_runNumber_year.lower_bound(run);
      if (lower != m_runNumber_year.end()){
        year=lower->second;
      }
      return year;
    }

initialize()

StatusCode CP::MuonTriggerScaleFactors::initialize ( void )

virtual

Implements CP::IMuonTriggerScaleFactors.

Definition at line 177 of file MuonTriggerScaleFactors.cxx.

                                                   {
 
        ATH_MSG_INFO("MuonQuality = '" << m_muonQuality.value() << "'");
        ATH_MSG_INFO("Binning = '" << m_binning << "'");
        ATH_MSG_INFO("Campaign = '" << m_campaign << "'");
        ATH_MSG_INFO("CalibrationRelease = '" << m_calibrationVersion.value() << "'");
        ATH_MSG_INFO("CustomInputFolder = '" << m_customInputFolder.value() << "'");
        ATH_MSG_INFO("AllowZeroSF = " << m_allowZeroSF);
        ATH_MSG_INFO("experimental = " << m_experimental);
 
        ATH_CHECK(m_eventInfo.initialize());
 
        if (registerSystematics() != StatusCode::SUCCESS) {
            return StatusCode::FAILURE;
        }
 
        if (applySystematicVariation(CP::SystematicSet()) != StatusCode::SUCCESS) {
            ATH_MSG_ERROR("Could not configure for nominal settings");
            return StatusCode::FAILURE;
        }
        // Initialize indexes of replicas for trigges which are asked
        for (auto trigToy : m_replicaTriggerList)
            m_replicaSet.insert(trigToy);
 
 
        if (m_campaign.empty()) {
            constexpr auto years_to_run = std::to_array<int>({2015, 2016, 2017, 2018, 2022, 2023, 2024});
            for (const int &year: years_to_run) {
                ATH_CHECK(LoadTriggerMap(year));
            }
        } else if (m_campaign.value() == "mc20a") {
            ATH_CHECK(LoadTriggerMap(2015));
            ATH_CHECK(LoadTriggerMap(2016));
        } else if (m_campaign.value() == "mc20d") {
            ATH_CHECK(LoadTriggerMap(2017));
        } else if (m_campaign.value() == "mc20e") {
            ATH_CHECK(LoadTriggerMap(2018));
        } else if (m_campaign.value() == "mc23a") {
            ATH_CHECK(LoadTriggerMap(2022));
        } else if (m_campaign.value() == "mc23d") {
            ATH_CHECK(LoadTriggerMap(2023));
        } else if (m_campaign.value() == "mc23e") {
            ATH_CHECK(LoadTriggerMap(2024));
        } else {
            ATH_MSG_ERROR("Campaign " << m_campaign.value() << " is not supported. Please choose a valid campaign or leave empty to load all years.");
        }
        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::MuonTriggerScaleFactors::isAffectedBySystematic ( const CP::SystematicVariation & systematic ) const

virtual

Declare the interface that this class provides.

returns: whether this tool is affected by the given systematics

Implements CP::ISystematicsTool.

Definition at line 862 of file MuonTriggerScaleFactors.cxx.

                                                                                                      {
        if (!systematic.empty()) {
            CP::SystematicSet sys = affectingSystematics();
            return sys.find(systematic) != sys.end();
        }
        return true;
    }

isTriggerSupported()

bool CP::MuonTriggerScaleFactors::isTriggerSupported ( const std::string & trigger ) const

virtual

Returns whether the trigger is supported by the tool or not. The decision depends on the present (random)RunNumber.

Implements CP::IMuonTriggerScaleFactors.

Definition at line 356 of file MuonTriggerScaleFactors.cxx.

                                                                                 {
       TH1_Ptr H1 = getEfficiencyHistogram(trigger, true, "nominal");
       return H1.get() != nullptr;
    }

LoadTriggerMap()

StatusCode CP::MuonTriggerScaleFactors::LoadTriggerMap ( unsigned int year )

private

Definition at line 45 of file MuonTriggerScaleFactors.cxx.

                                                                      {
        std::string fileName;
        if (m_customInputFilePerYear.value().contains(year)) {
            fileName = m_customInputFilePerYear.value().at(year);
            if (fileName.empty()) {
                ANA_MSG_INFO("Skipping loading trigger SF for year " << year << " since the provided file name is empty");
                return StatusCode::SUCCESS;
            } else {
                ATH_MSG_INFO("Loading trigger SF from user specified file " << fileName << " for year " << year);
            }
        }
 
        if (fileName.empty()) {
          if (year == 2015) fileName = "muontrigger_sf_2015_mc20a_v3.root";
          else if (year == 2016) fileName = "muontrigger_sf_2016_mc20a_v3.root";
          else if (year == 2017) fileName = "muontrigger_sf_2017_mc20d_v3.root";
          else if (year == 2018) fileName = "muontrigger_sf_2018_mc20e_v3.root";
          else if (year == 2022) fileName = "muontrigger_sf_2022_mc23a_v3.root";
          else if (year == 2023) fileName = "muontrigger_sf_2023_mc23d_v3.root";
          else if (year == 2024) fileName = "muontrigger_sf_2024_mc23e_v1.root";
          else {
            ATH_MSG_WARNING("There is no SF file for year " << year << " yet");
            return StatusCode::SUCCESS;
          }
        }
 
        TDirectory* origDir = gDirectory;
 
        std::string filePath;
 
        if (m_customInputFolder.empty()) {
            filePath = PathResolverFindCalibFile(Form("MuonEfficiencyCorrections/%s/%s", m_calibrationVersion.value().c_str(), fileName.c_str()));
            if (filePath.empty()) {
                ATH_MSG_ERROR("Unable to resolve the input file " << fileName << " via PathResolver.");
            }
        }
        else {
            ATH_MSG_INFO("Note: setting up with user specified input file location " << m_customInputFolder.value() << " - this is not encouraged!");
            filePath = PathResolverFindCalibFile(Form("%s/%s", m_customInputFolder.value().c_str(), fileName.c_str()));
        }
 
        TFile* file = TFile::Open(filePath.c_str());
 
        if (file == nullptr || !file->IsOpen()) {
            ATH_MSG_FATAL("MuonTriggerScaleFactors::initialize Couldn't open file " << filePath);
            return StatusCode::FAILURE;
        }
        TDirectory* tempDir = getTemporaryDirectory();
        tempDir->cd();
 
        static const std::vector<std::string> type { "data", "mc" };
        static const std::vector<std::string> region { "barrel", "endcap" };
        static const std::vector<std::string> systematic { "nominal", "stat_up", "stat_down", "syst_up", "syst_down" };
        if (m_muonQuality.value().compare("LowPt") == 0) {
          m_muonQuality = "Medium";
        }
        TDirectory* qualityDirectory = file->GetDirectory(m_muonQuality.value().c_str());
        if (qualityDirectory == nullptr) {
            ATH_MSG_FATAL("MuonTriggerScaleFactors::initialize cannot find directory with selected quality");
            return StatusCode::FAILURE;
        }
        TKey* periodKey;
        TIter nextPeriod(qualityDirectory->GetListOfKeys());
        while ((periodKey = (TKey*) nextPeriod())) {
            if (not periodKey->IsFolder()) continue;
            TDirectory* periodDirectory = qualityDirectory->GetDirectory(periodKey->GetName());
            std::string periodName = std::string(periodKey->GetName());
            std::string periodName_InMap = periodName.substr(std::string("Period").size(), periodName.size());
            YearPeriod period = YearPeriod(year, periodName_InMap);
            TKey* triggerKey;
            TIter nextTrigger(periodDirectory->GetListOfKeys());
            while ((triggerKey = (TKey*) nextTrigger())) {
                if (not triggerKey->IsFolder()) continue;
                TDirectory* triggerDirectory = periodDirectory->GetDirectory(triggerKey->GetName());
                std::string triggerName = std::string(triggerKey->GetName());
                if(!std::set<std::string>{"HLT_mu26_ivarmedium", "HLT_mu50", "HLT_mu26_ivarmedium_OR_HLT_mu50"}.count(triggerName) && m_binning == "coarse"){
                  ATH_MSG_DEBUG("Coarse binning not supported for di-muon trigger legs at the moment");
                  continue;
                }
                for (const auto& iregion : region) {
                    bool isBarrel = iregion.find("barrel") != std::string::npos;
                    for (const auto& itype : type) {
                        bool isData = itype.find("data") != std::string::npos;
                        std::string histname = ("_MuonTrigEff_" + periodName + "_" + triggerName + "_" + m_muonQuality.value() + "_" + "_EtaPhi_" + m_binning + "_" + iregion + "_" + itype);
                        for (const auto& isys : systematic) {
                            if (itype.find("data") != std::string::npos && isys.find("syst") != std::string::npos) continue;
                            std::string path = "eff_etaphi_" + m_binning + "_" + iregion + "_" + itype + "_" + isys;
                            TH2* hist = dynamic_cast<TH2*>(triggerDirectory->Get(path.c_str()));
                            if (not hist) {
 
                                ATH_MSG_FATAL("MuonTriggerScaleFactors::initialize " << path << " not found under trigger " << triggerName << " and period " << periodName << " for year: " << year);
                                continue;
                            }
                            hist->SetDirectory(0);
 
                            EffiHistoIdent HistoId = EffiHistoIdent(period, encodeHistoName(periodName_InMap, triggerName, isData, isys, isBarrel));
                            if (m_efficiencyMap.find(HistoId) != m_efficiencyMap.end()) {
                                ATH_MSG_FATAL("MuonTriggerScaleFactors::initialize(): histogram " << path << " is duplicated for year" << year << " in period " << periodName);
                                return StatusCode::FAILURE;
                            }
                            m_efficiencyMap.insert(std::pair<EffiHistoIdent, TH1_Ptr>(HistoId, std::shared_ptr < TH1 > (hist)));
 
                        }
                        //If the trigger is chosen for toy evaluation, generate all the replicas from
                        // NOMINAL with STAT variations stored in the data hist, load them in corresponding vector
                        if (m_replicaSet.find(triggerName) != m_replicaSet.end() && itype.find("data") != std::string::npos) {
 
                            TH1_Ptr Nominal_H = getEfficiencyHistogram(year, periodName, triggerName, isData, "nominal", isBarrel);
                            TH1_Ptr StatUp_H = getEfficiencyHistogram(year, periodName, triggerName, isData, "stat_up", isBarrel);
 
                            TH1_Ptr tmp_h2 = TH1_Ptr(dynamic_cast<TH2F*>(Nominal_H->Clone(Form("tmp_h2_%s", Nominal_H->GetName()))));
                            const int xbins = tmp_h2->GetNbinsX(), ybins = tmp_h2->GetNbinsY();
                            for (int x_i = 0; x_i <= xbins; ++x_i) {
                                for (int y_i = 0; y_i <= ybins; ++y_i) {
                                    double statErr = std::abs(tmp_h2->GetBinContent(x_i, y_i) - StatUp_H->GetBinContent(x_i, y_i));
                                    tmp_h2->SetBinError(x_i, y_i, statErr);
                                }
                            }
                            m_efficiencyMapReplicaArray[EffiHistoIdent(period, encodeHistoName(periodName, triggerName, isData, "repl", isBarrel))] = generateReplicas(tmp_h2, m_nReplicas, m_ReplicaRandomSeed);
                        }
                    }
                }
            }
        }
        file->Close();
        delete file;
        origDir->cd();
        return StatusCode::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.

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

recommendedSystematics()

CP::SystematicSet CP::MuonTriggerScaleFactors::recommendedSystematics ( ) const

virtual

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

Implements CP::IReentrantSystematicsTool.

Definition at line 901 of file MuonTriggerScaleFactors.cxx.

                                                                          {
        return affectingSystematics();
    }

registerSystematics()

StatusCode CP::MuonTriggerScaleFactors::registerSystematics ( )

private

Definition at line 891 of file MuonTriggerScaleFactors.cxx.

                                                            {
        CP::SystematicRegistry& registry = CP::SystematicRegistry::getInstance();
        if (registry.registerSystematics(*this) != StatusCode::SUCCESS) {
            ATH_MSG_ERROR("Failed to add systematic to list of recommended systematics.");
            return StatusCode::FAILURE;
        }
        return StatusCode::SUCCESS;
    }

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

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.

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

Member Data Documentation

m_allowZeroSF

Gaudi::Property<bool> CP::MuonTriggerScaleFactors::m_allowZeroSF {this, "AllowZeroSF", false, "if a trigger is not available will return 0 instead of throwing an error. More difficult to spot configuration issues. Use at own risk"}

private

Definition at line 124 of file MuonTriggerScaleFactors.h.

{this, "AllowZeroSF", false, "if a trigger is not available will return 0 instead of throwing an error. More difficult to spot configuration issues. Use at own risk"};

m_appliedSystematics

CP::SystematicSet* CP::MuonTriggerScaleFactors::m_appliedSystematics {}

private

Definition at line 111 of file MuonTriggerScaleFactors.h.

{};

m_binning

Gaudi::Property<std::string> CP::MuonTriggerScaleFactors::m_binning {this, "Binning", "fine", "the binning to use"}

private

Definition at line 122 of file MuonTriggerScaleFactors.h.

{this, "Binning", "fine", "the binning to use"};

m_calibrationVersion

Gaudi::Property<std::string> CP::MuonTriggerScaleFactors::m_calibrationVersion {this, "CalibrationVersion", "250731_SummerUpdate", "the calibration version to use"}

private

Definition at line 119 of file MuonTriggerScaleFactors.h.

{this, "CalibrationVersion", "250731_SummerUpdate", "the calibration version to use"};

m_campaign

Gaudi::Property<std::string> CP::MuonTriggerScaleFactors::m_campaign {this, "Campaign", "", "the MC campaign to get the scale factors for"}

private

Definition at line 116 of file MuonTriggerScaleFactors.h.

{this, "Campaign", "", "the MC campaign to get the scale factors for"};

m_customInputFilePerYear

Gaudi::Property<std::map<unsigned int, std::string> > CP::MuonTriggerScaleFactors::m_customInputFilePerYear {this, "CustomInputFilePerYear", {}, "the custom input file to use per year (debugging only)"}

private

Definition at line 121 of file MuonTriggerScaleFactors.h.

{this, "CustomInputFilePerYear", {}, "the custom input file to use per year (debugging only)"};

m_customInputFolder

Gaudi::Property<std::string> CP::MuonTriggerScaleFactors::m_customInputFolder {this, "CustomInputFolder", "", "the custom input folder to use (debugging only)"}

private

Definition at line 120 of file MuonTriggerScaleFactors.h.

{this, "CustomInputFolder", "", "the custom input folder to use (debugging only)"};

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_efficiencyMap

EfficiencyMap CP::MuonTriggerScaleFactors::m_efficiencyMap

private

Definition at line 112 of file MuonTriggerScaleFactors.h.

m_efficiencyMapReplicaArray

std::map<EffiHistoIdent, std::vector<TH1_Ptr> > CP::MuonTriggerScaleFactors::m_efficiencyMapReplicaArray

private

Definition at line 113 of file MuonTriggerScaleFactors.h.

m_eventInfo

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

private

Definition at line 101 of file MuonTriggerScaleFactors.h.

{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_experimental

Gaudi::Property<bool> CP::MuonTriggerScaleFactors::m_experimental {this, "UseExperimental", false, "enable experimental features like single muon SF"}

private

Definition at line 125 of file MuonTriggerScaleFactors.h.

{this, "UseExperimental", false, "enable experimental features like single muon SF"};

m_forcePeriod

Gaudi::Property<std::string> CP::MuonTriggerScaleFactors::m_forcePeriod {this, "ForcePeriod", "", "Only for developers. Never use this in any analysis!!!!!!"}

private

Definition at line 127 of file MuonTriggerScaleFactors.h.

{this, "ForcePeriod", "", "Only for developers. Never use this in any analysis!!!!!!"};

m_forceYear

Gaudi::Property<int> CP::MuonTriggerScaleFactors::m_forceYear {this, "ForceYear", -1, "Only for developers. Never use this in any analysis!!!!!!"}

private

Definition at line 126 of file MuonTriggerScaleFactors.h.

{this, "ForceYear", -1, "Only for developers. Never use this in any analysis!!!!!!"};

m_muonQuality

Gaudi::Property<std::string> CP::MuonTriggerScaleFactors::m_muonQuality {this, "MuonQuality", "Medium", "the muon quality to get the scale factors for"}

private

Definition at line 115 of file MuonTriggerScaleFactors.h.

{this, "MuonQuality", "Medium", "the muon quality to get the scale factors for"};

m_nReplicas

Gaudi::Property<int> CP::MuonTriggerScaleFactors::m_nReplicas {this, "NReplicas", 100, "Number of generated toy replicas, if replicas are required."}

private

Definition at line 132 of file MuonTriggerScaleFactors.h.

{this, "NReplicas", 100, "Number of generated toy replicas, if replicas are required."};

m_ReplicaRandomSeed

Gaudi::Property<int> CP::MuonTriggerScaleFactors::m_ReplicaRandomSeed {this, "ReplicaRandomSeed", 12345, "Random seed for toy replica generation."}

private

Definition at line 133 of file MuonTriggerScaleFactors.h.

{this, "ReplicaRandomSeed", 12345, "Random seed for toy replica generation."};

m_replicaSet

std::set<std::string> CP::MuonTriggerScaleFactors::m_replicaSet

private

Definition at line 131 of file MuonTriggerScaleFactors.h.

m_replicaTriggerList

Gaudi::Property<std::vector<std::string> > CP::MuonTriggerScaleFactors::m_replicaTriggerList {this, "ReplicaTriggerList", {}, "List of triggers on which we want to generate stat. uncertainty toy replicas."}

private

Definition at line 130 of file MuonTriggerScaleFactors.h.

{this, "ReplicaTriggerList", {}, "List of triggers on which we want to generate stat. uncertainty toy replicas."};

m_runNumber_year

const std::map< unsigned int, int > CP::MuonTriggerScaleFactors::m_runNumber_year

staticprivate

Initial value:

= {
        {284484,2015},
        {311481,2016},
        {340453,2017},
        {364292,2018},
        {440613,2022},
        {456749,2023},
        {486706,2024}
    }

Definition at line 136 of file MuonTriggerScaleFactors.h.

m_systFilter

std::unordered_map<CP::SystematicSet, CP::SystematicSet> CP::MuonTriggerScaleFactors::m_systFilter

private

Definition at line 109 of file MuonTriggerScaleFactors.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:

• MuonTriggerScaleFactors.h
• MuonTriggerScaleFactors.cxx