EffiCollection.h

Go to the documentation of this file.

/*
 Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
 */
#ifndef EFFICOLLECTION_H_
#define EFFICOLLECTION_H_
 
// @class EffiCollection
 
 
#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>
 
namespace CP {
    class MuonEfficiencyScaleFactors;
    class EfficiencyScaleFactor;
    class SystematicSet;
    class SystematicVariation;
    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, 
                
                ZAnalysis = Central | Calo | Forward,
                JPsiAnalysis = CentralLowPt | CaloLowPt,                
               
               
            };
            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;
            
            
            SystematicSet* getSystSet() const;
            bool  isAffectedBySystematic(const SystematicVariation& variation) const;
            bool  isAffectedBySystematic(const 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<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;
            
            EffiCollection::CollectionType m_FileType;
            unsigned int m_binOffSet;
 
        public:
            void addSubtoolsTo (columnar::ColumnarTool<>& parentTool);
        
    };
 
}
#endif /* EFFICOLLECTION_H_ */