EffiCollection.h File Reference

#include <MuonEfficiencyCorrections/MuonEfficiencyType.h>
#include <MuonEfficiencyCorrections/EfficiencyScaleFactor.h>
#include <xAODMuon/Muon.h>
#include <map>
#include <string>
#include <iostream>
#include <ColumnarCore/ColumnAccessor.h>
#include <ColumnarCore/ColumnarTool.h>
#include <ColumnarCore/ObjectColumn.h>
#include <ColumnarMuon/MuonDef.h>

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

Go to the source code of this file.

Namespaces
namespace	CP
	Select isolated Photons, Electrons and Muons.

Functions
namespace	ADD_CMODE (CP)

Function Documentation

ADD_CMODE()

namespace ADD_CMODE

(

CP

)

The EffiCollection class handles the 5 different scale-factor maps binned in time. Each muon is piped to the correct map based whether it's a calo-tag muon, belongs to the high-eta region or has low-pt. There exists one instance of the EffiCollection foreach systematic variation and nominal. Scale-factor maps which are not affected by a systematic, especially in the case of common vs. low-pt, are taken from the Nominal maps.

Constructor with nominal as fallback..

return the correct SF type to provide, depending on eta and the author

The five different scale-factor maps

Bits 6-9 are already reserved for the systematic enum below

Distinguish these two because the systematics are named with an extra LOWPT

a consistency check of the scale-factor maps. All scale-factor maps must be present and there must no overlapping periods to pass this test.

Get the number of all bins in the scale-factor maps including the overflow & underflow bins

If systematic decorrelation is activated then the user needs to loop manually over the syst bins. This method activates the i-th bin to be active. For the remaining bins the nominal scale-factor is returned instead.

Checks whether the i-th bin belongs to the low-pt map...

Checks whether the i-th bin belongs to the forward map

Returns the global bin name conststucted from the axis titles and the bin borders

Returns the bin number from which the scale-factor of the muon is going to be retrieved...

Returns the systematic set affecting this collection.

Returns whether the given set has variations affecting this Collection

Method to retrieve a container from the class ordered by a collection type This method is mainly used to propagate the nominal maps to the variations as fallback maps if no variation has been defined in this situation

Make the collection container shared ptr to allow that a systematic EffiCollection can use the same container as the nominal one if the current systematic has no effect on that particular container....

The systematic set is returned back to the MuonEfficiencyScaleFactors instance to register The known systematics to the global service

The collection container manages the time binning of a particular scale-factor map. For a given runNumber, it pipes the right map to the upstream tools.

Nominal constructor... Only needs to know about it's type and the file to load

Retrieve the scale-factor map belonging to that particular run of data-taking

Checks if the global bin number belongs to this map

Consistency check of all scale-factor maps managed by the container instance

Returns MUON_EFF_<sysname()>

Activate this bin to run in the uncorrelated systematic mode

Sets the global offset to align the order in the map into a global numbering scheme

Number of bins of the map itself

Number of overflow bins in the map

Check whether the bin is overflow or not

Global offset of the bin numbers

Name of the i-th bin

Returns the global bin number corresponding to the muon kinematics. In case of failures -1 is returned

File type of the map

Offset to translate between the bin-numbers in the bin numbers of each file against the global bin-number

Definition at line 1 of file EffiCollection.h.

                        {
    class MuonEfficiencyScaleFactors;
    class EfficiencyScaleFactor;
    class CollectionContainer;
    class EffiCollection final : public columnar::ColumnarTool<> {
        public:
            explicit EffiCollection(MuonEfficiencyScaleFactors& ref_tool);
            EffiCollection(const EffiCollection* Nominal, MuonEfficiencyScaleFactors& ref_tool, const std::string& syst, int syst_bit_map, bool is_up);
          
            EfficiencyScaleFactor* retrieveSF(const xAOD::Muon & mu, unsigned int RunNumber) const;
            EfficiencyScaleFactor* retrieveSF(columnar::MuonId mu, unsigned int RunNumber) const;
            enum CollectionType {
                Central = 1, 
                Calo   = 1<<1, 
                Forward = 1<<2, 
                CentralLowPt = 1<<3, 
                CaloLowPt = 1<<4, 
                LRTCentral = 1<<10,
                LRTCentralLowPt = 1<<11,
                
                ZAnalysis = Central | Calo | Forward | LRTCentral,
                JPsiAnalysis = CentralLowPt | CaloLowPt | LRTCentralLowPt,                
               
               
            };
            enum Systematic{
                Symmetric = 1<<6,
                PtDependent = 1<<7,
                UnCorrelated = 1<<8,
                UpVariation = 1<<9,
            };
            static std::string FileTypeName(EffiCollection::CollectionType T);
            
            
            bool CheckConsistency();

            unsigned int nBins() const;
            
            bool SetSystematicBin(unsigned int Bin);
            
            bool IsLowPtBin(unsigned int Bin) const;
            bool IsForwardBin(unsigned int Bin) const;

            std::string GetBinName(unsigned int bin) const;
            
            int getUnCorrelatedSystBin(const xAOD::Muon& mu) const;
            
            
            CP::SystematicSet* getSystSet() const;
            bool  isAffectedBySystematic(const CP::SystematicVariation& variation) const;
            bool  isAffectedBySystematic(const CP::SystematicSet& set) const;
            

            std::shared_ptr<CollectionContainer> retrieveContainer(CollectionType Type) const;
 
        private:
            CollectionContainer* FindContainer(unsigned int bin) const;
            CollectionContainer* FindContainer(columnar::MuonId mu) const;
            CollectionContainer* FindLRTContainer(columnar::MuonId mu) const;
            
            const MuonEfficiencyScaleFactors& m_ref_tool;
            
            std::shared_ptr<CollectionContainer> m_central_eff;
            std::shared_ptr<CollectionContainer> m_calo_eff;
            std::shared_ptr<CollectionContainer> m_forward_eff;
            std::shared_ptr<CollectionContainer> m_lowpt_central_eff;
            std::shared_ptr<CollectionContainer> m_lowpt_calo_eff;
            std::shared_ptr<CollectionContainer> m_lrt_central_eff;
            std::shared_ptr<CollectionContainer> m_lrt_lowpt_central_eff;

            std::unique_ptr<CP::SystematicSet> m_syst_set;        
 
        public:
 
            columnar::MuonAccessor<columnar::ObjectColumn> m_muons {*this, "Muons"};
            columnar::MuonAccessor<columnar::RetypeColumn<double,float>> ptAcc {*this, "pt"};
            columnar::MuonAccessor<columnar::RetypeColumn<double,float>> etaAcc {*this, "eta"};
            columnar::MuonAccessor<columnar::RetypeColumn<xAOD::Muon::MuonType,std::uint16_t>> muonTypeAcc {*this, "muonType"};
            columnar::MuonAccessor<char> isLRTmuon {*this, "isLRT", {.isOptional = true}};
    };
    
    class CollectionContainer final {
        public:
            CollectionContainer(const MuonEfficiencyScaleFactors& ref_tool, EffiCollection::CollectionType FileType);
            CollectionContainer(const MuonEfficiencyScaleFactors& ref_tool, CollectionContainer* Nominal, const std::string& syst_name, unsigned int syst_bit_map);
          
            EfficiencyScaleFactor* retrieve(unsigned int RunNumer);
            
            bool isBinInMap (unsigned int bin) const;
            bool CheckConsistency();
            
            std::string sysname() const;
            
            bool SetSystematicBin(unsigned int Bin);
            
            void SetGlobalOffSet(unsigned int OffSet);
            
            unsigned int nBins() const;
            unsigned int nOverFlowBins() const;
            bool isOverFlowBin(int b) const;
 
            
            unsigned int globalOffSet() const;
           
            std::string GetBinName(unsigned int Bin) const;                    
            
            int FindBinSF(const xAOD::Muon &mu) const;
            
            EffiCollection::CollectionType type() const;
            
            bool isNominal() const;
            bool isUpVariation() const;
            bool separateBinSyst() const;
            
        private:
            std::map<std::string, std::pair<unsigned int, unsigned int>> findPeriods(const MuonEfficiencyScaleFactors& ref_tool) const;
            std::string fileName(const MuonEfficiencyScaleFactors& ref_tool) const;
          
            bool LoadPeriod(unsigned int RunNumber);
           
            std::vector<std::shared_ptr<EfficiencyScaleFactor>> m_SF;
            EfficiencyScaleFactor* m_currentSF;
            std::unordered_set<unsigned int> m_warnedForRunNumber;
            
            EffiCollection::CollectionType m_FileType;
            unsigned int m_binOffSet;
 
        public:
            void addSubtoolsTo (columnar::ColumnarTool<>& parentTool);
        
    };
 
}