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

#include <EffiCollection.h>

Inheritance diagram for CP::EffiCollection:

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 (MuonEfficiencyScaleFactors &ref_tool)

	EffiCollection (const EffiCollection *Nominal, 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...

EfficiencyScaleFactor *	retrieveSF (columnar::MuonId mu, unsigned int RunNumber) const

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)

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

Private Member Functions
CollectionContainer *	FindContainer (unsigned int bin) const

CollectionContainer *	FindContainer (columnar::MuonId mu) const

CollectionContainer *	FindLRTContainer (columnar::MuonId 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 34 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 43 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 58 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 ( 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>()){
  
         ref_tool.addSubtool (*this);
  
         m_central_eff = std::make_shared<CollectionContainer>(m_ref_tool, CollectionType::Central);
         m_central_eff->addSubtoolsTo(*this);
         if (m_ref_tool.filename_Calo() != m_ref_tool.filename_Central()){
             m_calo_eff = std::make_shared<CollectionContainer>(m_ref_tool,CollectionType::Calo);
             m_calo_eff->addSubtoolsTo(*this);
         } 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);
             m_forward_eff->addSubtoolsTo(*this);
         } 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);
             m_lowpt_central_eff->addSubtoolsTo(*this);
         } 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);
             m_lowpt_calo_eff->addSubtoolsTo(*this);
         } 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,
		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 76 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() {
  
         ref_tool.addSubtool (*this);
  
         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_central_eff->addSubtoolsTo (*this);
         m_forward_eff = make_variation(CollectionType::Forward);
         m_forward_eff->addSubtoolsTo (*this);
         m_calo_eff = make_variation(CollectionType::Calo);
         m_calo_eff->addSubtoolsTo (*this);
         m_lowpt_central_eff = make_variation(CollectionType::CentralLowPt);
         m_lowpt_central_eff->addSubtoolsTo (*this);
         m_lowpt_calo_eff = make_variation(CollectionType::CaloLowPt);
         m_lowpt_calo_eff->addSubtoolsTo (*this);
  
         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 125 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 306 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 ( columnar::MuonId 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 207 of file EffiCollection.cxx.

                                                                               {
         if (m_ref_tool.use_lrt()) {
             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.getXAODObject().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 (ptAcc(mu) <  m_ref_tool.lowPtTransition()) {
             if (std::abs(etaAcc(mu)) >= 2.5) {
                 return m_forward_eff.get();
             }
             if (muonTypeAcc(mu) == xAOD::Muon::CaloTagged) {
                 return m_lowpt_calo_eff.get();
             }
             return m_lowpt_central_eff.get();
         }
         if (muonTypeAcc(mu) == xAOD::Muon::CaloTagged) {
             return m_calo_eff.get();
         } else if (std::abs(etaAcc(mu)) < 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 241 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 ( columnar::MuonId mu ) const

private

Definition at line 253 of file EffiCollection.cxx.

                                                                                  {
         if (ptAcc(mu) <  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 315 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 336 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 331 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 342 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 339 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 302 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 298 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 266 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 117 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() [1/2]

EfficiencyScaleFactor * CP::EffiCollection::retrieveSF	(	columnar::MuonId	mu,
		unsigned int	RunNumber
	)		const

Definition at line 260 of file EffiCollection.cxx.

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

◆ retrieveSF() [2/2]

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 257 of file EffiCollection.cxx.

                                                                                                       {
         return retrieveSF (columnar::MuonId (mu), RunNumber);
     }

◆ 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 293 of file EffiCollection.cxx.

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

Member Data Documentation

◆ etaAcc

columnar::MuonAccessor<columnar::RetypeColumn<double,float> > CP::EffiCollection::etaAcc {*this, "eta"}

Definition at line 133 of file EffiCollection.h.

◆ isLRTmuon

columnar::MuonAccessor<char> CP::EffiCollection::isLRTmuon {*this, "isLRT", {.isOptional = true}}

Definition at line 135 of file EffiCollection.h.

◆ m_calo_eff

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

private

Definition at line 118 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 117 of file EffiCollection.h.

◆ m_forward_eff

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

private

Definition at line 119 of file EffiCollection.h.

◆ m_lowpt_calo_eff

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

private

Definition at line 121 of file EffiCollection.h.

◆ m_lowpt_central_eff

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

private

Definition at line 120 of file EffiCollection.h.

◆ m_lrt_central_eff

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

private

Definition at line 122 of file EffiCollection.h.

◆ m_lrt_lowpt_central_eff

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

private

Definition at line 123 of file EffiCollection.h.

◆ m_muons

columnar::MuonAccessor<columnar::ObjectColumn> CP::EffiCollection::m_muons {*this, "Muons"}

Definition at line 131 of file EffiCollection.h.

◆ m_ref_tool

const MuonEfficiencyScaleFactors& CP::EffiCollection::m_ref_tool

private

Definition at line 112 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 127 of file EffiCollection.h.

◆ muonTypeAcc

columnar::MuonAccessor<columnar::RetypeColumn<xAOD::Muon::MuonType,std::uint16_t> > CP::EffiCollection::muonTypeAcc {*this, "muonType"}

Definition at line 134 of file EffiCollection.h.

◆ ptAcc

columnar::MuonAccessor<columnar::RetypeColumn<double,float> > CP::EffiCollection::ptAcc {*this, "pt"}

Definition at line 132 of file EffiCollection.h.

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

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ CollectionType

◆ Systematic

Constructor & Destructor Documentation

◆ EffiCollection() [1/2]

◆ EffiCollection() [2/2]

Member Function Documentation

◆ CheckConsistency()

◆ FileTypeName()

◆ FindContainer() [1/2]

◆ FindContainer() [2/2]

◆ FindLRTContainer()

◆ GetBinName()

◆ getSystSet()

◆ getUnCorrelatedSystBin()

◆ isAffectedBySystematic() [1/2]

◆ isAffectedBySystematic() [2/2]

◆ IsForwardBin()

◆ IsLowPtBin()

◆ nBins()

◆ retrieveContainer()

◆ retrieveSF() [1/2]

◆ retrieveSF() [2/2]

◆ SetSystematicBin()

Member Data Documentation

◆ etaAcc

◆ isLRTmuon

◆ m_calo_eff

◆ m_central_eff

◆ m_forward_eff

◆ m_lowpt_calo_eff

◆ m_lowpt_central_eff

◆ m_lrt_central_eff

◆ m_lrt_lowpt_central_eff

◆ m_muons

◆ m_ref_tool

◆ m_syst_set

◆ muonTypeAcc

◆ ptAcc