MuonEfficiencyScaleFactors.h File Reference

#include "MuonAnalysisInterfaces/IMuonEfficiencyScaleFactors.h"
#include "MuonEfficiencyCorrections/MuonEfficiencyType.h"
#include "MuonEfficiencyCorrections/EfficiencyScaleFactor.h"
#include "MuonEfficiencyCorrections/EffiCollection.h"
#include "AsgTools/ToolHandle.h"
#include "AsgTools/AsgTool.h"
#include "AsgDataHandles/ReadHandleKey.h"
#include "xAODEventInfo/EventInfo.h"
#include "ColumnarCore/ColumnarTool.h"
#include "ColumnarCore/ColumnAccessor.h"
#include "ColumnarCore/ObjectColumn.h"
#include "ColumnarEventInfo/EventInfoHelpers.h"
#include "ColumnarMuon/MuonDef.h"
#include <string>
#include <memory>
#include <map>
#include <unordered_map>

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
namespace	ADD_CMODE (CP)

Function Documentation

ADD_CMODE()

namespace ADD_CMODE

(

CP

)

initialize the tool once all settings are in place!

Retrieve the Scale factor and decorate the muon

replica generation

returns: whether this tool is affected by the given systematis

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

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

Obtain the muon efficiency measured using the data

Obtain the muon efficiency measured using the MC

load the SF histos

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

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

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

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

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

LRT muons have their own efficiency maps

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

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

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

Returns the position of the collection in the syst set vector. If the collection is not part of this class -1 is returned

Returns the number of EffiCollections stored in this class

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

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

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

option to set if we want to use LRT muons

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

the working point to operate on

This vector stores all scale-factor maps

Pointer to the current active map in terms of systematics

subfolder to load from the calibration db

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

Name of the decoration to catch up the close by jets

It turned out that the code spends a large time in the look up of the systematics. This map tries to mitigate this issue.

Turn on if using LRT objects

Definition at line 1 of file MuonEfficiencyScaleFactors.h.

                        {
    class MuonEfficiencyScaleFactors: virtual public CP::IMuonEfficiencyScaleFactors, public asg::AsgTool, public columnar::ColumnarTool<>{
 
        public:
            MuonEfficiencyScaleFactors(const std::string& name);
 
            virtual ~MuonEfficiencyScaleFactors();
            //Proper constructor for Athena
            ASG_TOOL_CLASS3( MuonEfficiencyScaleFactors, CP::IMuonEfficiencyScaleFactors, CP::ISystematicsTool, CP::IReentrantSystematicsTool )
 
            
            virtual StatusCode initialize() override;

            virtual CP::CorrectionCode getEfficiencyScaleFactor(const xAOD::Muon& mu, float& sf, const xAOD::EventInfo* info = 0) const override;
            CP::CorrectionCode getEfficiencyScaleFactor(columnar::MuonId mu, float& sf, columnar::EventInfoId info) const;
            virtual CP::CorrectionCode applyEfficiencyScaleFactor(const xAOD::Muon& mu, const xAOD::EventInfo* info = 0) const override;
            virtual CP::CorrectionCode getEfficiencyScaleFactorReplicas(const xAOD::Muon& mu, std::vector<float> & sf_err, const xAOD::EventInfo* info = 0) const override;
            virtual CP::CorrectionCode applyEfficiencyScaleFactorReplicas(const xAOD::Muon& mu, int nreplicas = 50, const xAOD::EventInfo* info = 0) const override;

            virtual bool isAffectedBySystematic(const CP::SystematicVariation& systematic) const override;

            virtual CP::SystematicSet affectingSystematics() const override;

            virtual CP::SystematicSet recommendedSystematics() const override;
 
            virtual StatusCode applySystematicVariation(const CP::SystematicSet& systConfig) override;

            virtual CP::CorrectionCode getDataEfficiency(const xAOD::Muon& mu, float& eff, const xAOD::EventInfo* info = 0) const override;
            virtual CP::CorrectionCode applyDataEfficiency(const xAOD::Muon& mu, const xAOD::EventInfo* info = 0) const override;
 
            virtual CP::CorrectionCode getDataEfficiencyReplicas(const xAOD::Muon& mu, std::vector<float> & sf_err, const xAOD::EventInfo* info = 0) const;
            virtual CP::CorrectionCode applyDataEfficiencyReplicas(const xAOD::Muon& mu, int nreplicas = 50, const xAOD::EventInfo* info = 0) const;

            virtual CP::CorrectionCode getMCEfficiency(const xAOD::Muon& mu, float& eff, const xAOD::EventInfo* info = 0) const override;
            virtual CP::CorrectionCode applyMCEfficiency(const xAOD::Muon& mu, const xAOD::EventInfo* info = 0) const override;
 
            virtual CP::CorrectionCode getMCEfficiencyReplicas(const xAOD::Muon& mu, std::vector<float> & sf_err, const xAOD::EventInfo* info = 0) const;
            virtual CP::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 CP::SystematicSet& systConfig) const override;
 
 
        private:
            unsigned int getRandomRunNumber(const xAOD::EventInfo* info) const;
            unsigned int getRandomRunNumber(columnar::EventInfoId info) const;
            StatusCode LoadInputs();
 
            SG::ReadHandleKey<xAOD::EventInfo> m_eventInfo{this, "EventInfoContName", "EventInfo", "event info key"};
           
            std::map<std::string, unsigned int> lookUpSystematics();
        public:
            
            
            std::string filename_Central()const;
            std::string filename_Calo()const;
            std::string filename_HighEta()const;
 
            std::string filename_LowPt()const;
            std::string filename_LowPtCalo()const;
            std::string filename_LRTCentral() const;
            std::string filename_LRTLowPt() const;
            
            float lowPtTransition() const;
            
            MuonEfficiencyType measurement() const; 
            
            
            std::string sf_decoration() const;
            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;
            
            size_t getNCollections() const;
            bool uncorrelate_sys() const;
            
            const std::string& close_by_jet_decoration() const;
            bool use_2D_iso_corrections() const;
            bool use_lrt() const;
            
       
    private:
            std::string resolve_file_location(const std::string &filename)const;
           
           
            std::string m_wp;
           
            std::vector<std::unique_ptr<EffiCollection>> m_sf_sets;
            
            EffiCollection* m_current_sf;
 
            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;
   
            // Decorate the data-monteCarlo & scale-factors
            // to the muon. Decoration names can be set flexile
            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;
            

            float m_lowpt_threshold;
            std::string m_iso_jet_dR;
            bool m_use2DIsoCorr;
            CP::SystematicSet m_affectingSys;
            std::unordered_map<CP::SystematicSet, EffiCollection*> m_filtered_sys_sets;
   
            bool m_init;
            bool m_seperateSystBins;
            bool m_breakDownSyst;
            bool m_applyKineDepSys;
            bool m_useLRT;
 
            MuonEfficiencyType m_Type;
 
            // a struct holding all columnar accessors, as those interfere
            // with the root dictionaries.
            struct Accessors;
            std::unique_ptr<Accessors> m_accessors;
 
    public:
 
            void callSingleEvent (columnar::MuonRange muons, columnar::EventInfoId event) const;
            virtual void callEvents (columnar::EventContextRange events) const override;
    };
 
} /* namespace ADD_CMODE(CP) */