CP::EffiCollection Class Reference

The EffiCollection class handles the 5 different scale-factor maps binned in time. More...

#include <EffiCollection.h>

Collaboration diagram for CP::EffiCollection:

Public Types
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 }

Public Member Functions
	EffiCollection (const MuonEfficiencyScaleFactors &ref_tool)
	EffiCollection (const EffiCollection *Nominal, const MuonEfficiencyScaleFactors &ref_tool, const std::string &syst, int syst_bit_map, bool is_up)
	Constructor with nominal as fallback.. More...
EfficiencyScaleFactor *	retrieveSF (const xAOD::Muon &mu, unsigned int RunNumber) const
	return the correct SF type to provide, depending on eta and the author More...
bool	CheckConsistency ()
	a consistency check of the scale-factor maps. More...
unsigned int	nBins () const
	Get the number of all bins in the scale-factor maps including the overflow & underflow bins. More...
bool	SetSystematicBin (unsigned int Bin)
	If systematic decorrelation is activated then the user needs to loop manually over the syst bins. More...
bool	IsLowPtBin (unsigned int Bin) const
	Checks whether the i-th bin belongs to the low-pt map... More...
bool	IsForwardBin (unsigned int Bin) const
	Checks whether the i-th bin belongs to the forward map. More...
std::string	GetBinName (unsigned int bin) const
	Returns the global bin name conststucted from the axis titles and the bin borders. More...
int	getUnCorrelatedSystBin (const xAOD::Muon &mu) const
	Returns the bin number from which the scale-factor of the muon is going to be retrieved... More...
SystematicSet *	getSystSet () const
	Returns the systematic set affecting this collection. More...
bool	isAffectedBySystematic (const SystematicVariation &variation) const
	Returns whether the given set has variations affecting this Collection. More...
bool	isAffectedBySystematic (const SystematicSet &set) const
std::shared_ptr< CollectionContainer >	retrieveContainer (CollectionType Type) const
	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. More...

Static Public Member Functions
static std::string	FileTypeName (EffiCollection::CollectionType T)

Private Member Functions
CollectionContainer *	FindContainer (unsigned int bin) const
CollectionContainer *	FindContainer (const xAOD::Muon &mu) const
CollectionContainer *	FindLRTContainer (const xAOD::Muon &mu) const

Private Attributes
const MuonEfficiencyScaleFactors &	m_ref_tool
std::shared_ptr< CollectionContainer >	m_central_eff
	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.... More...
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
	The systematic set is returned back to the MuonEfficiencyScaleFactors instance to register The known systematics to the global service. More...

Detailed Description

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.

Definition at line 29 of file EffiCollection.h.

Member Enumeration Documentation

CollectionType

enum CP::EffiCollection::CollectionType

Enumerator
Central	The five different scale-factor maps.
Calo
Forward
CentralLowPt
CaloLowPt
ZAnalysis
JPsiAnalysis	Distinguish these two because the systematics are named with an extra LOWPT.

Definition at line 37 of file EffiCollection.h.

                                {
                Central = 1, 
                Calo   = 1<<1, 
                Forward = 1<<2, 
                CentralLowPt = 1<<3, 
                CaloLowPt = 1<<4, 
                
                ZAnalysis = Central | Calo | Forward,
                JPsiAnalysis = CentralLowPt | CaloLowPt,                
               
               
            };

Systematic

enum CP::EffiCollection::Systematic

Enumerator
Symmetric
PtDependent
UnCorrelated
UpVariation

Definition at line 52 of file EffiCollection.h.

                           {
                Symmetric = 1<<6,
                PtDependent = 1<<7,
                UnCorrelated = 1<<8,
                UpVariation = 1<<9,
            };

Constructor & Destructor Documentation

EffiCollection() [1/2]

CP::EffiCollection::EffiCollection ( const MuonEfficiencyScaleFactors &  ref_tool )

explicit

Definition at line 17 of file EffiCollection.cxx.

                                                                             :
            m_ref_tool(ref_tool),
            m_central_eff(),
            m_calo_eff(),
            m_forward_eff(),
            m_lowpt_central_eff(),
            m_lowpt_calo_eff(),
            m_lrt_central_eff(),
            m_lrt_lowpt_central_eff(),
            m_syst_set(std::make_unique<SystematicSet>()){
 
        m_central_eff = std::make_shared<CollectionContainer>(m_ref_tool, CollectionType::Central);
        if (m_ref_tool.filename_Calo() != m_ref_tool.filename_Central()){
            m_calo_eff = std::make_shared<CollectionContainer>(m_ref_tool,CollectionType::Calo);
        } else m_calo_eff = m_central_eff;
        
        if (m_ref_tool.filename_HighEta() != m_ref_tool.filename_Central()){
            m_forward_eff = std::make_shared<CollectionContainer>(m_ref_tool,CollectionType::Forward);
        } else m_forward_eff = m_central_eff;
        
        if (m_ref_tool.lowPtTransition() > 0  && m_ref_tool.filename_LowPt() != m_ref_tool.filename_Central()){
            m_lowpt_central_eff = std::make_shared<CollectionContainer>(m_ref_tool,CollectionType::CentralLowPt);
        } else m_lowpt_central_eff = m_central_eff;
       
         if (m_ref_tool.lowPtTransition() > 0  && m_ref_tool.filename_LowPtCalo() != m_ref_tool.filename_Central()){
            m_lowpt_calo_eff = std::make_shared<CollectionContainer>(m_ref_tool, CollectionType::CaloLowPt);
        } else m_lowpt_calo_eff = m_central_eff;
 
        if(m_ref_tool.use_lrt()) {
            if (m_ref_tool.filename_LRTCentral() != m_ref_tool.filename_Central()) {
                m_lrt_central_eff = std::make_shared<CollectionContainer>(m_ref_tool,CollectionType::Central);
            }
            else {
                m_lrt_central_eff = m_central_eff;
            }
            if (m_ref_tool.lowPtTransition() > 0 ) {
                if (m_ref_tool.filename_LRTLowPt() == m_ref_tool.filename_LowPt()) {
                    m_lrt_lowpt_central_eff = m_lowpt_central_eff;
                }
                else if (m_ref_tool.filename_LRTLowPt() == m_ref_tool.filename_Central()) {
                    m_lrt_lowpt_central_eff = m_central_eff;
                }
                else {
                    m_lrt_lowpt_central_eff = std::make_shared<CollectionContainer>(m_ref_tool,CollectionType::CentralLowPt);
                }
            }
            else {
                m_lrt_lowpt_central_eff = m_central_eff;
            }
        }
    }

EffiCollection() [2/2]

CP::EffiCollection::EffiCollection	(	const EffiCollection *	Nominal,
		const MuonEfficiencyScaleFactors &	ref_tool,
		const std::string &	syst,
		int	syst_bit_map,
		bool	is_up
	)

Constructor with nominal as fallback..

Use a lambda function to assign the maps easily

Only the Z reconstruction analysis has different files for bulk / calo-tag / low-pt and forward eta

Definition at line 69 of file EffiCollection.cxx.

                                                                                                                                                                :
            m_ref_tool(ref_tool),
            m_central_eff(),
            m_calo_eff(),
            m_forward_eff(),
            m_lowpt_central_eff(),
            m_lowpt_calo_eff(),
            m_lrt_central_eff(),
            m_lrt_lowpt_central_eff(),
            m_syst_set() {
    
        if (is_up) syst_bit_map |= EffiCollection::UpVariation;
        std::function< std::shared_ptr<CollectionContainer>(CollectionType)>  make_variation = [this,&ref_tool, Nominal, syst_bit_map, syst](CollectionType type){
                if (syst_bit_map & type) {
                    return std::make_shared<CollectionContainer>(ref_tool,
                                                                 Nominal->retrieveContainer(type).get(),
                                                                 syst, syst_bit_map);                                                                             }
                if (ref_tool.measurement() != MuonEfficiencyType::Reco) return m_central_eff;
                return Nominal->retrieveContainer(type);
            };
        m_central_eff = make_variation(CollectionType::Central);
        m_forward_eff = make_variation(CollectionType::Forward);
        m_calo_eff = make_variation(CollectionType::Calo);
        m_lowpt_central_eff = make_variation(CollectionType::CentralLowPt);
        m_lowpt_calo_eff = make_variation(CollectionType::CaloLowPt);
        if (m_ref_tool.use_lrt()) {
            m_lrt_central_eff = make_variation(CollectionType::Central);
            m_lrt_lowpt_central_eff = make_variation(CollectionType::CentralLowPt);
        }
        
        
    }

Member Function Documentation

CheckConsistency()

bool CP::EffiCollection::CheckConsistency

(

)

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.

At this stage we know that all efficiencies have been loaded successfully. We need to now to order the maps to make global bin numbers

Systematic constructor has been called. We can now assemble the systematic variations

Let the world implode... Yeaha register foreach bin a systematic variation

Definition at line 112 of file EffiCollection.cxx.

                                           {
        if (!m_central_eff || !m_central_eff->CheckConsistency()) {
            Error("EffiCollection()", "Consistency check for central file failed");
            return false;
        }
        if (!m_calo_eff || !m_calo_eff->CheckConsistency()) {
            Error("EffiCollection()", "Consistency check for calo file failed");            
            return false;
        }
        if (!m_forward_eff || !m_forward_eff->CheckConsistency()) {
             Error("EffiCollection()", "Consistency check for forward file failed");            
            return false;
        }
        if (!m_lowpt_central_eff || !m_lowpt_central_eff->CheckConsistency()) {
            Error("EffiCollection()", "Consistency check for low-pt file failed");    
            return false;
        }
        if (!m_lowpt_calo_eff || !m_lowpt_calo_eff->CheckConsistency()) {
            Error("EffiCollection()", "Consistency check for low-pt calo file failed"); 
            return false;
        }
        if (m_ref_tool.use_lrt()) {
            if (!m_lrt_central_eff || !m_lrt_central_eff->CheckConsistency()) {
                Error("EffiCollection()", "Consistency check for LRT central file failed");
                return false;
            }
            if (!m_lrt_lowpt_central_eff || !m_lrt_lowpt_central_eff->CheckConsistency()) {
                Error("EffiCollection()", "Consistency check for LRT low-pt file failed");    
                return false;
            }
        }
        unsigned int n = m_central_eff->nBins();
        std::function<void (CollectionContainer*)> assign_mapping =  [this, &n](CollectionContainer* container){
                if (container != m_central_eff.get() && container->separateBinSyst()){
                    container->SetGlobalOffSet(n);
                    n += container->nBins();
                };
        };
        assign_mapping(m_calo_eff.get());
        assign_mapping(m_calo_eff.get());
        assign_mapping(m_lowpt_central_eff.get());
        assign_mapping(m_lowpt_calo_eff.get());
     
        assign_mapping(m_forward_eff.get());
       
        if (m_ref_tool.use_lrt()) {
            assign_mapping(m_lrt_central_eff.get());
            assign_mapping(m_lrt_lowpt_central_eff.get());
        }
        if (!m_syst_set){
            m_syst_set = std::make_unique<CP::SystematicSet>();
            size_t glob_sys = m_ref_tool.getPosition(this);
            if (glob_sys > m_ref_tool.getNCollections()){
                Error("EffiCollection()", "Invalid position in the list of systematics. It seems that I'm not part of the referring ScaleFactorTool.");
                return false;
            }
            for (const EffiCollection::CollectionType& file_type: {EffiCollection::Central, EffiCollection::Calo, EffiCollection::Forward,  
                                         EffiCollection::CentralLowPt, EffiCollection::CaloLowPt}){
                    
                std::shared_ptr<CollectionContainer> container = retrieveContainer(file_type);
                if (container->isNominal()) continue;
                if (container->separateBinSyst()){
                    for (unsigned int b = container->nBins() - 1; b > 0  ; --b){
                        unsigned int bin = b + container->globalOffSet();
                        if (container->isOverFlowBin(bin)) continue;
                        m_syst_set->insert(CP::SystematicVariation::makeToyVariation("MUON_EFF_" + container->sysname()  + GetBinName(bin) , bin, glob_sys));
                    }
                } else {
                    m_syst_set->insert( SystematicVariation("MUON_EFF_" + container->sysname(), container->isUpVariation() ? 1  : -1));
                }
             }
        }
        return true;
    }

FileTypeName()

std::string CP::EffiCollection::FileTypeName ( EffiCollection::CollectionType  T )

static

Definition at line 291 of file EffiCollection.cxx.

                                                                         {
        if (T == CollectionType::Central) return "Central";
        if (T == CollectionType::Calo) return "Calo";
        if (T == CollectionType::Forward) return "Forward";
        if (T == CollectionType::CentralLowPt) return "CentralLowPt";
        if (T == CollectionType::CaloLowPt) return "CaloLowPt";
        return "EffiCollection::FileTypeName() - WARNING: Unknown EffiCollection::CollectionType!";
    }

FindContainer() [1/2]

CollectionContainer * CP::EffiCollection::FindContainer ( const xAOD::Muon &  mu ) const

private

If the isLRT decor is not available, try to see if patternRecoInfo is available for the corresponding ID track.

All LRT muons should have ID tracks. The muons without ID tracks have to come from the standard muon container.

Definition at line 194 of file EffiCollection.cxx.

                                                                               {
        if (m_ref_tool.use_lrt()) {
            static const SG::AuxElement::Accessor<char> isLRTmuon("isLRT");
            if (isLRTmuon.isAvailable(mu)) {
                if (isLRTmuon(mu)) return FindLRTContainer(mu);
            }
            else { 
                static const SG::AuxElement::Accessor<uint64_t> patternAcc("patternRecoInfo");
                const xAOD::TrackParticle* idtrack = mu.trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
                if(idtrack) { 
                    if(!patternAcc.isAvailable(*idtrack)) {
                        Error("CollectionContainer", "No information available to tell if the muon is LRT or standard. Either run MuonLRTMergingAlg to decorate with `isLRT` flag, or supply the patternRecoInfo for the original ID track.");
                    }
                    std::bitset<xAOD::NumberOfTrackRecoInfo> patternBitSet(patternAcc(*idtrack));
                    if (patternBitSet.test(xAOD::SiSpacePointsSeedMaker_LargeD0)) return FindLRTContainer(mu);
                }
            }
        }
        if (mu.pt() <  m_ref_tool.lowPtTransition()) {
            if (std::abs(mu.eta()) >= 2.5) {
                return m_forward_eff.get();
            }
            if (mu.muonType() == xAOD::Muon::CaloTagged) {
                return m_lowpt_calo_eff.get();
            }
            return m_lowpt_central_eff.get();
        }
        if (mu.muonType() == xAOD::Muon::CaloTagged) {
            return m_calo_eff.get();
        } else if (std::abs(mu.eta()) < 2.5) {
            return m_central_eff.get();
        } else {
            return m_forward_eff.get();
        }
    }

FindContainer() [2/2]

CollectionContainer * CP::EffiCollection::FindContainer ( unsigned int  bin ) const

private

Definition at line 229 of file EffiCollection.cxx.

                                                                            {
        if (m_central_eff->isBinInMap(bin)) return m_central_eff.get();
        if (m_forward_eff->isBinInMap(bin)) return m_forward_eff.get();
        if (m_calo_eff->isBinInMap(bin)) return m_calo_eff.get();
        if (m_lowpt_central_eff->isBinInMap(bin)) return m_lowpt_central_eff.get();
        if (m_lowpt_calo_eff->isBinInMap(bin)) return m_lowpt_calo_eff.get();
        if (m_ref_tool.use_lrt()) {
            if (m_lrt_central_eff->isBinInMap(bin)) return m_lrt_central_eff.get();
            if (m_lrt_lowpt_central_eff->isBinInMap(bin)) return m_lrt_lowpt_central_eff.get();
        }
        return nullptr;
    }

FindLRTContainer()

CollectionContainer * CP::EffiCollection::FindLRTContainer ( const xAOD::Muon &  mu ) const

private

Definition at line 241 of file EffiCollection.cxx.

                                                                                  {
        if (mu.pt() <  m_ref_tool.lowPtTransition()) return m_lrt_lowpt_central_eff.get();
        else return m_lrt_central_eff.get();
    }

GetBinName()

std::string CP::EffiCollection::GetBinName

(

unsigned int

bin

)

const

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

Definition at line 300 of file EffiCollection.cxx.

                                                               {
        CollectionContainer* Cont = FindContainer(bin);
        if (Cont) {
            std::string BinName = FileTypeName(Cont->type()) +"_"+ Cont->GetBinName(bin);
            for (const std::string& R : ToRemove) {
                BinName = ReplaceExpInString(BinName, R, "");
            }
            for (const stringpair& R : ToReplace) {
                BinName = ReplaceExpInString(BinName, R.first, R.second);
            }
            return BinName;
        }
        Warning("EffiCollection::GetBinName()", "Unknown bin %u", bin);
        
        return "UNKNOWN_BIN";
    }

getSystSet()

SystematicSet * CP::EffiCollection::getSystSet

(

)

const

Returns the systematic set affecting this collection.

Definition at line 321 of file EffiCollection.cxx.

                                                   {
        return m_syst_set.get();
    }

getUnCorrelatedSystBin()

int CP::EffiCollection::getUnCorrelatedSystBin

(

const xAOD::Muon &

mu

)

const

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

Definition at line 316 of file EffiCollection.cxx.

                                                                       {
        CollectionContainer* container = FindContainer(mu);
        if (container) return container->FindBinSF(mu); 
        return -1;
    }

isAffectedBySystematic() [1/2]

bool CP::EffiCollection::isAffectedBySystematic

(

const SystematicSet &

set

)

const

Definition at line 327 of file EffiCollection.cxx.

                                                                              {
        if (set.empty()) return m_syst_set->empty();
        for (const SystematicVariation& variation: set){
            if (isAffectedBySystematic(variation)) return true;
        }
        return false;
    }            

isAffectedBySystematic() [2/2]

bool CP::EffiCollection::isAffectedBySystematic

(

const SystematicVariation &

variation

)

const

Returns whether the given set has variations affecting this Collection.

Definition at line 324 of file EffiCollection.cxx.

                                                                                           {
        return m_syst_set->find(variation) != m_syst_set->end();
    }

IsForwardBin()

bool CP::EffiCollection::IsForwardBin

(

unsigned int

Bin

)

const

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

Definition at line 287 of file EffiCollection.cxx.

                                                            {
        return m_forward_eff != m_central_eff && m_forward_eff->isBinInMap(Bin);
    }

IsLowPtBin()

bool CP::EffiCollection::IsLowPtBin

(

unsigned int

Bin

)

const

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

Definition at line 283 of file EffiCollection.cxx.

                                                          {
        return (m_central_eff != m_lowpt_central_eff && m_lowpt_central_eff->isBinInMap(Bin)) ||
               (m_central_eff != m_lowpt_calo_eff && m_lowpt_calo_eff->isBinInMap(Bin));
    }

nBins()

unsigned int CP::EffiCollection::nBins

(

)

const

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

Definition at line 251 of file EffiCollection.cxx.

                                             {
        unsigned int Nbins = 0;
        if (m_central_eff) {
            Nbins += m_central_eff->nBins();
        }
        if (m_central_eff != m_calo_eff) {
            Nbins += m_calo_eff->nBins();
        }
        if (m_forward_eff != m_central_eff) {
            Nbins += m_forward_eff->nBins();
        }
        if (m_lowpt_central_eff != m_central_eff) {
            Nbins += m_lowpt_central_eff->nBins();
        }
        if (m_lowpt_calo_eff != m_central_eff) {
            Nbins += m_lowpt_calo_eff->nBins();
        }
        if (m_ref_tool.use_lrt()) {
            if (m_lrt_central_eff) {
                Nbins += m_lrt_central_eff->nBins();
            }
            if (m_lrt_lowpt_central_eff) {
                Nbins += m_lrt_lowpt_central_eff->nBins();
            }
        }
        return Nbins;
    }

retrieveContainer()

std::shared_ptr< CollectionContainer > CP::EffiCollection::retrieveContainer

(

CollectionType

Type

)

const

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.

Definition at line 104 of file EffiCollection.cxx.

                                                                                                  {
        if (Type == CollectionType::Central) return m_central_eff;
        if (Type == CollectionType::Forward) return m_forward_eff;
        if (Type == CollectionType::Calo) return m_calo_eff;
        if (Type == CollectionType::CentralLowPt) return m_lowpt_central_eff;
        if (Type == CollectionType::CaloLowPt) return m_lowpt_calo_eff;
        return std::shared_ptr<CollectionContainer>();
    }

retrieveSF()

EfficiencyScaleFactor * CP::EffiCollection::retrieveSF	(	const xAOD::Muon &	mu,
		unsigned int	RunNumber
	)		const

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

Definition at line 245 of file EffiCollection.cxx.

                                                                                                      {
        CollectionContainer* Cont = FindContainer(mu);
        if (Cont != nullptr) return Cont->retrieve(RunNumber);
        Warning("EffiCollection::retrieveSF()", "Invalid muon");
        return nullptr;
    }

SetSystematicBin()

bool CP::EffiCollection::SetSystematicBin

(

unsigned int

Bin

)

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.

Definition at line 278 of file EffiCollection.cxx.

                                                          {
        CollectionContainer* Cont = FindContainer(Bin);
        if (!Cont) return false;
        return Cont->SetSystematicBin(Bin);
    }

Member Data Documentation

m_calo_eff

std::shared_ptr<CollectionContainer> CP::EffiCollection::m_calo_eff

private

Definition at line 112 of file EffiCollection.h.

m_central_eff

std::shared_ptr<CollectionContainer> CP::EffiCollection::m_central_eff

private

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

Definition at line 111 of file EffiCollection.h.

m_forward_eff

std::shared_ptr<CollectionContainer> CP::EffiCollection::m_forward_eff

private

Definition at line 113 of file EffiCollection.h.

m_lowpt_calo_eff

std::shared_ptr<CollectionContainer> CP::EffiCollection::m_lowpt_calo_eff

private

Definition at line 115 of file EffiCollection.h.

m_lowpt_central_eff

std::shared_ptr<CollectionContainer> CP::EffiCollection::m_lowpt_central_eff

private

Definition at line 114 of file EffiCollection.h.

m_lrt_central_eff

std::shared_ptr<CollectionContainer> CP::EffiCollection::m_lrt_central_eff

private

Definition at line 116 of file EffiCollection.h.

m_lrt_lowpt_central_eff

std::shared_ptr<CollectionContainer> CP::EffiCollection::m_lrt_lowpt_central_eff

private

Definition at line 117 of file EffiCollection.h.

m_ref_tool

const MuonEfficiencyScaleFactors& CP::EffiCollection::m_ref_tool

private

Definition at line 106 of file EffiCollection.h.

m_syst_set

std::unique_ptr<SystematicSet> CP::EffiCollection::m_syst_set

private

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

Definition at line 121 of file EffiCollection.h.

---

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

• EffiCollection.h
• EffiCollection.cxx