CP::EfficiencyScaleFactor Class Reference

#include <EfficiencyScaleFactor.h>

Inheritance diagram for CP::EfficiencyScaleFactor:

Public Member Functions
	EfficiencyScaleFactor (const MuonEfficiencyScaleFactors &ref_tool, const std::string &file, const std::string &time_unit)
	Nominal constructor to use having the measurement (Reco/TTVA/Iso/BadMuon) path to the scale-factor map & the time unit to consider.
	EfficiencyScaleFactor (std::shared_ptr< EfficiencyScaleFactor > nominal, const MuonEfficiencyScaleFactors &ref_tool, const std::string &file, const std::string &time_unit, const std::string &syst_name, int syst_type_bitmap)
	Constructor to use for systematic evaluations the nominal scale-factor is given as a fallback map in case the user want to activate uncorrelated systematic – a shared ptr is used to ensure that the map is always defined allthough the nominal container has been deleted somehow – the name of the systematic encodes the systematic to retrieve from the file.
	EfficiencyScaleFactor (const EfficiencyScaleFactor &)=delete
	Do not allow for copy constructors and other assignments of the class.
EfficiencyScaleFactor &	operator= (const EfficiencyScaleFactor &)=delete
bool	CheckConsistency ()
	check the consistency of the scale-factor map.
int	nBins () const
	How many bins does the scale-factor map have.
std::string	GetBinName (int bin) const
	Returns the name of the bin using the axis title from the scale-factor map.
int	nOverFlowBins () const
	Number of overflow bins in the map.
bool	isOverFlowBin (int b) const
	Check whether the bin is overflow or not.
int	FindBinSF (const xAOD::Muon &mu) const
	Finds the bin to which the muon corresponds to.
bool	SetSystematicBin (int bin)
	This function will let the world implode since it allows to decorrelate the sysstematics bin by bin.
bool	separateBinSyst () const
bool	IsUpVariation () const
CorrectionCode	ScaleFactor (const xAOD::Muon &mu, float &SF) const
	the important bits - extract SF info
CorrectionCode	ScaleFactor (columnar::MuonId mu, float &SF) const
CorrectionCode	ScaleFactorReplicas (const xAOD::Muon &mu, std::vector< float > &SF)
CorrectionCode	ApplyScaleFactor (const xAOD::Muon &mu) const
	or you can just decorate the scale-factor to the muon
CorrectionCode	ApplyScaleFactorReplicas (const xAOD::Muon &mu, int n_replicas)
CorrectionCode	DataEfficiency (const xAOD::Muon &mu, float &Eff) const
	... and absolute efficiencies
CorrectionCode	DataEfficiencyReplicas (const xAOD::Muon &mu, std::vector< float > &eff)
CorrectionCode	ApplyDataEfficiency (const xAOD::Muon &mu) const
	You can decorate the data efficiecny as well.
CorrectionCode	ApplyDataEfficiencyReplicas (const xAOD::Muon &mu, int n_replicas)
CorrectionCode	MCEfficiency (const xAOD::Muon &mu, float &Eff) const
	... mc efficiency
CorrectionCode	MCEfficiencyReplicas (const xAOD::Muon &mu, std::vector< float > &eff)
CorrectionCode	ApplyMCEfficiency (const xAOD::Muon &mu) const
	... or decorate them directly
CorrectionCode	ApplyMCEfficiencyReplicas (const xAOD::Muon &mu, int n_replicas)
void	DebugPrint () const
	debug method
std::string	sysname (bool with_direction=true) const
	A string having the full name of the systematic including the measurement.
unsigned int	firstRun () const
	First run to which the map belongs to.
unsigned int	lastRun () const
	Last run to which the map belongs to. The last run number is given exclusvely...
bool	coversRunNumber (unsigned int run) const
	Check if a run of data-taking is covered by this map.
void	setFirstLastRun (unsigned int first, unsigned int last)
	Set the run-number coverage.

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< double, float > >	phiAcc {*this, "phi"}
columnar::MuonAccessor< columnar::RetypeColumn< xAOD::Muon::MuonType, std::uint16_t > >	muonTypeAcc {*this, "muonType"}

Private Types
typedef std::vector< std::unique_ptr< HistHandler > >	SFReplicaVec
typedef SG::AuxElement::Decorator< float >	FloatDecorator
	Typedef to make the definition of the follow decorators a bit shorted.
typedef SG::AuxElement::Decorator< std::vector< float > >	FloatVectorDecorator

Private Member Functions
bool	ReadFromFile (const std::string &file, const std::string &time_unit)
	Read SF histrograms from a given input file.
std::unique_ptr< HistHandler >	ReadHistFromFile (columnar::ColumnarTool<> *parent, const std::string &name, TFile *f, const std::string &time_unit)
CorrectionCode	GetContentFromHist (const HistHandler *Hist, const xAOD::Muon &mu, float &SF, bool add_kine_syst) const
	read the content of the correct bin in one of my histos. MCefficiencies actually do not need a pt-dependet systematic
CorrectionCode	GetContentFromHist (const HistHandler *Hist, columnar::MuonId mu, float &SF, bool add_kine_syst) const
CorrectionCode	GetContentReplicasFromHist (EfficiencyScaleFactor::SFReplicaVec &replicas, const xAOD::Muon &mu, std::vector< float > &SF, bool add_kine_syst)
	read a vector of replica contents in the correct bin in one of my histos
std::unique_ptr< HistHandler >	package_histo (columnar::ColumnarTool<> *parent, TH1 *h)
void	GenerateReplicas (int nrep, int seed)
void	GenerateReplicasFromHist (HistHandler *h, int nrep, int seed, EfficiencyScaleFactor::SFReplicaVec &repVector)

Private Attributes
CP::MuonEfficiencyType	m_measurement
	Section of variables of the tool.
std::string	m_syst_name
bool	m_is_up
	Boolean whether the scale-factor is varying upwards or downwards Only relevant if the systname is not empty.
bool	m_is_lowpt
	states that this SF should respond to low pt systematics rather than high pt ones
bool	m_respond_to_kineDepSyst
	steers the pt dependent systematics
bool	m_separateBinSyst
	Can the systematic be decorrelated.
std::unique_ptr< HistHandler >	m_sf
	the histograms needed to run
std::unique_ptr< HistHandler >	m_eff
std::unique_ptr< HistHandler >	m_mc_eff
std::unique_ptr< FloatDecorator >	m_sf_decor
std::unique_ptr< FloatDecorator >	m_eff_decor
std::unique_ptr< FloatDecorator >	m_mc_eff_decor
std::unique_ptr< FloatVectorDecorator >	m_sf_rep_decor
std::unique_ptr< FloatVectorDecorator >	m_eff_rep_decor
std::unique_ptr< FloatVectorDecorator >	m_mc_eff_rep_decor
std::unique_ptr< IKinematicSystHandler >	m_sf_KineDepsys
SFReplicaVec	m_sf_replicas
	replicas, in case we use them
SFReplicaVec	m_eff_replicas
SFReplicaVec	m_mc_eff_replicas
std::shared_ptr< EfficiencyScaleFactor >	m_NominalFallBack
	Nominal fall-back scale-factor.
int	m_SystematicBin
float	m_default_eff
	default efficiency value (in case of OutOfValidityRange)
float	m_default_eff_ttva
	default TTVA efficiency value (in case of MuonStandAlone for |eta|>2.5)
std::atomic< unsigned int >	m_warnsPrinted
unsigned int	m_firstRun
unsigned int	m_lastRun

Static Private Attributes
static const unsigned int	m_warningLimit = 10

Detailed Description

Definition at line 40 of file EfficiencyScaleFactor.h.

Member Typedef Documentation

FloatDecorator

typedef SG::AuxElement::Decorator<float> CP::EfficiencyScaleFactor::FloatDecorator

private

Typedef to make the definition of the follow decorators a bit shorted.

Definition at line 191 of file EfficiencyScaleFactor.h.

FloatVectorDecorator

typedef SG::AuxElement::Decorator<std::vector<float> > CP::EfficiencyScaleFactor::FloatVectorDecorator

private

Definition at line 192 of file EfficiencyScaleFactor.h.

SFReplicaVec

typedef std::vector<std::unique_ptr<HistHandler> > CP::EfficiencyScaleFactor::SFReplicaVec

private

Definition at line 147 of file EfficiencyScaleFactor.h.

Constructor & Destructor Documentation

EfficiencyScaleFactor() [1/3]

EfficiencyScaleFactor::EfficiencyScaleFactor	(	const MuonEfficiencyScaleFactors &	ref_tool,
		const std::string &	file,
		const std::string &	time_unit )

Nominal constructor to use having the measurement (Reco/TTVA/Iso/BadMuon) path to the scale-factor map & the time unit to consider.

Definition at line 178 of file EfficiencyScaleFactor.cxx.

                                                             :
                                  EfficiencyScaleFactor(std::shared_ptr<EfficiencyScaleFactor>(),
                                                        ref_tool,file, time_unit, "",0){}

EfficiencyScaleFactor() [2/3]

EfficiencyScaleFactor::EfficiencyScaleFactor	(	std::shared_ptr< EfficiencyScaleFactor >	nominal,
		const MuonEfficiencyScaleFactors &	ref_tool,
		const std::string &	file,
		const std::string &	time_unit,
		const std::string &	syst_name,
		int	syst_type_bitmap )

Constructor to use for systematic evaluations the nominal scale-factor is given as a fallback map in case the user want to activate uncorrelated systematic – a shared ptr is used to ensure that the map is always defined allthough the nominal container has been deleted somehow – the name of the systematic encodes the systematic to retrieve from the file.

To ensure backwards compability with older files the names "STAT" and "SYS" refer to the total systematic

Nominal set loaded nothing needs to be done further

Asking for the total systematic... May be the current file does not support the asymmetric break-down yet. Let's try the good old approach and load the total sys histogram

Not even the old approach lead to something fruitful... Lets forget it and reset everything

Stat error can be retrieved from the nominal histogram itself

This systematic name is reserved for the kinematic histhandler

Some other systematic is asked for... Failure

Apply the systematic variations

Thus far there're no kinematic dependent systematics for low-pt

As well as for the high-eta range.

Load the pt_dependent systematics if needed

Old format of the pt-dependent systematic loaded

Now it comes to the new format

That one needs to be named properly in the future

Use the approach from the old sacle-factor file

Definition at line 12 of file EfficiencyScaleFactor.cxx.

                                                       :
            m_measurement(ref_tool.measurement()),
            m_syst_name(syst_name),
            m_is_up(syst_type_bitmap & EffiCollection::UpVariation),
            m_is_lowpt(syst_type_bitmap & EffiCollection::JPsiAnalysis),
            m_respond_to_kineDepSyst(syst_type_bitmap & EffiCollection::PtDependent),
            m_separateBinSyst(syst_type_bitmap & EffiCollection::UnCorrelated),
            m_sf(),
            m_eff(),
            m_mc_eff(),
                        
            m_sf_decor(std::make_unique<FloatDecorator>(ref_tool.sf_decoration()+ (m_syst_name.empty()? "" :"_"+ m_syst_name + (m_is_up? "_1UP": "_1DN")))),
            m_eff_decor(std::make_unique<FloatDecorator>(ref_tool.data_effi_decoration()+ (m_syst_name.empty()? "" :"_"+ m_syst_name + (m_is_up? "_1UP": "_1DN")))),          
            m_mc_eff_decor(std::make_unique<FloatDecorator>(ref_tool.mc_effi_decoration()+ (m_syst_name.empty()? "" :"_"+ m_syst_name + (m_is_up? "_1UP": "_1DN")))),
            m_sf_rep_decor(std::make_unique<FloatVectorDecorator>(ref_tool.sf_replica_decoration()+ (m_syst_name.empty()? "" :"_"+ m_syst_name + (m_is_up? "_1UP": "_1DN")))),
            m_eff_rep_decor(std::make_unique<FloatVectorDecorator>(ref_tool.data_effi_replica_decoration()+ (m_syst_name.empty()? "" :"_"+ m_syst_name + (m_is_up? "_1UP": "_1DN")))),
            m_mc_eff_rep_decor(std::make_unique<FloatVectorDecorator>(ref_tool.mc_effi_replica_deocration()+ (m_syst_name.empty()? "" :"_"+ m_syst_name + (m_is_up? "_1UP": "_1DN")))),
          
            m_sf_KineDepsys(),
            m_sf_replicas(),
            m_eff_replicas(),
            m_mc_eff_replicas(),
            m_NominalFallBack(nominal),
            m_SystematicBin(-1),
            m_default_eff(1.),
            m_default_eff_ttva(1.),
            m_warnsPrinted(0),
            m_firstRun(1),
            m_lastRun(999999){
    
        if (ref_tool.measurement() == CP::MuonEfficiencyType::Iso){
            dRJetAxisHandler::set_close_jet_decorator(ref_tool.close_by_jet_decoration());
            dRJetAxisHandler::set_use_2D_sf(ref_tool.use_2D_iso_corrections());
        }    
        // open the file
        std::unique_ptr<TFile> f (TFile::Open(file.c_str(), "READ"));
        if (!f || !f->IsOpen()) {
            Error("EfficiencyScaleFactor", "Unable to open file %s", file.c_str());
            return;
        }
        // now we can read our three mean histograms Histos
        m_eff = ReadHistFromFile(this, "Eff", f.get(), time_unit);
        m_mc_eff = ReadHistFromFile(this, "MC_Eff", f.get(), time_unit);
        m_sf = ReadHistFromFile(this, "SF", f.get(), time_unit);
        if (syst_name.empty()) return;
        
        
        if (IsUpVariation()){
            m_default_eff = 2.;
            m_default_eff_ttva = 1. + 1.e-9;
        } else {
            m_default_eff = 0.;
            m_default_eff_ttva = 1. - 1.e-9;            
        }
        std::function<void(std::unique_ptr<HistHandler>&, const std::string& )> syst_loader = [this, &f, &time_unit, &syst_type_bitmap] (std::unique_ptr<HistHandler>& nominal, const std::string& hist_type) {
            if(!nominal) return;
            std::unique_ptr<HistHandler> sys = ReadHistFromFile(this, Form("%s_%s_%s", hist_type.c_str() ,
                                                                                 m_syst_name.c_str(), 
                                                                                 (syst_type_bitmap & EffiCollection::Symmetric ? "SYM" : (m_is_up ? "1UP" : "1DN")) ), 
                                                                f.get(), time_unit);
            if (sys) {
                for (int i = 1; i <= nominal->nBins(); ++i) {
                    double content = nominal->GetBinContent(i);
                    double variation = (IsUpVariation() ? 1. : -1.)*sys->GetBinContent(i);
                    nominal->SetBinContent(i,content + variation);
                }
                return;
            }
            if (m_syst_name == "SYS"){
                std::unique_ptr<HistHandler> old_sys = ReadHistFromFile(this, hist_type +"_sys", f.get(), time_unit);
                if (!old_sys){
                    nominal.reset();
                    return;
                }
                
                for (int i = 1; i<= nominal->nBins(); ++i) {
                     nominal->SetBinContent(i, nominal->GetBinContent(i) + (IsUpVariation() ? 1. : -1.)*old_sys->GetBinContent(i));
                }
            } 
            else if (m_syst_name == "STAT") {
                for (int i = 1; i<= nominal->nBins(); ++i) {
                     nominal->SetBinContent(i, nominal->GetBinContent(i) + (IsUpVariation() ? 1. : -1.)*nominal->GetBinError(i));
                }
            } 
            else if (m_syst_name == "PTDEPENDENCY"){
                return;
            } 
            else{
                Error("EfficiencyScaleFactor()", "Failed to load sytstematic variation  %s for measurement %s and histo-type %s", sysname(true).c_str(), 
                                                                                                               EfficiencyTypeName(m_measurement).c_str(),
                                                                                                               hist_type.c_str());
                nominal.reset();
            }
        };
        syst_loader(m_sf,"SF");
        syst_loader(m_eff,"Eff");
        syst_loader(m_mc_eff,"MC_Eff");        
       
        if (m_is_lowpt || (file == ref_tool.filename_HighEta() && ref_tool.filename_HighEta() != ref_tool.filename_Central()) ||
        (file == ref_tool.filename_Calo() && ref_tool.filename_Calo() != ref_tool.filename_Central())) m_respond_to_kineDepSyst =false;
       
        if (!m_respond_to_kineDepSyst){
             return;
        }      
        // Load the systematic of the bad veto
        if (m_measurement == CP::MuonEfficiencyType::BadMuonVeto) {
            TDirectory* SystDir = nullptr;
            f->GetObject(("KinematicSystHandler_" + time_unit).c_str(), SystDir);
            if (SystDir) {
                m_sf_KineDepsys = std::make_unique<BadMuonVetoSystHandler>(SystDir);
            } else {
                f->GetObject("BadMuonVetoSyst_3Stations", SystDir);
                TDirectory* SystDir_2Stat = nullptr;
                f->GetObject("BadMuonVetoSyst_2Stations", SystDir_2Stat);
                m_sf_KineDepsys = std::make_unique<BadMuonVetoSystHandler>(SystDir, SystDir_2Stat);
            }           
            m_sf_KineDepsys->SetSystematicWeight( IsUpVariation() ? 1 : -1);
            if (!m_sf_KineDepsys->initialize()){
                Error("EfficiencyScaleFactor()", "Pt dependent systematic could not be loaded");
                m_sf_KineDepsys.reset();
            }           
            if (m_sf_KineDepsys)
                addSubtool (*m_sf_KineDepsys);
            return;
        } else if (m_measurement == CP::MuonEfficiencyType::TTVA){
            m_sf_KineDepsys = std::make_unique<TTVAClosureSysHandler>(ReadHistFromFile(this,"SF_NonClosure_sys",f.get(),time_unit));
            if (!m_sf_KineDepsys->initialize()){
                Error("EfficiencyScaleFactor()", "TTVA non closure systematic could not be loaded.");
                m_sf_KineDepsys.reset();
            }
            else
              m_sf_KineDepsys->SetSystematicWeight( IsUpVariation() ? 1 : -1);
            if (m_sf_KineDepsys)
                addSubtool (*m_sf_KineDepsys);
            return;
        
        }
        m_sf_KineDepsys = std::make_unique<PtKinematicSystHandler>(ReadHistFromFile(this, Form("SF_PtFlatness_1%s", m_is_up?"UP" :"DN"), f.get(), time_unit), ReadHistFromFile(this, "SF_PtDep_sys", f.get(), time_unit));
      
        if(!m_sf_KineDepsys->initialize()){    
            m_sf_KineDepsys = std::make_unique<PrimodialPtSystematic>(ReadHistFromFile(this, "SF_PtDep_sys", f.get(), time_unit));
        }
        m_sf_KineDepsys->SetSystematicWeight( IsUpVariation() ? 1 : -1);     
        addSubtool (*m_sf_KineDepsys);
    }

EfficiencyScaleFactor() [3/3]

CP::EfficiencyScaleFactor::EfficiencyScaleFactor ( const EfficiencyScaleFactor & )

delete

Do not allow for copy constructors and other assignments of the class.

Member Function Documentation

ApplyDataEfficiency()

CorrectionCode EfficiencyScaleFactor::ApplyDataEfficiency

(

const xAOD::Muon &

mu

)

const

You can decorate the data efficiecny as well.

Definition at line 390 of file EfficiencyScaleFactor.cxx.

                                                                                      {
        float effi = 0;
        CorrectionCode result = DataEfficiency(mu, effi);
        (*m_eff_decor)(mu) = effi;
        return result;  
    }

ApplyDataEfficiencyReplicas()

CorrectionCode EfficiencyScaleFactor::ApplyDataEfficiencyReplicas	(	const xAOD::Muon &	mu,
		int	n_replicas )

Definition at line 396 of file EfficiencyScaleFactor.cxx.

                                                                                                       {
        std::vector<float> replicas(n_replicas);
        CorrectionCode result = DataEfficiencyReplicas(mu, replicas);
        (*m_eff_rep_decor)(mu) = replicas;
        return result;
    }

ApplyMCEfficiency()

CorrectionCode EfficiencyScaleFactor::ApplyMCEfficiency

(

const xAOD::Muon &

mu

)

const

... or decorate them directly

Definition at line 402 of file EfficiencyScaleFactor.cxx.

                                                                                   {
        float effi = 0;
        CorrectionCode result = MCEfficiency(mu, effi);
        (*m_mc_eff_decor)(mu) = effi;
        return result;  
    }

ApplyMCEfficiencyReplicas()

CorrectionCode EfficiencyScaleFactor::ApplyMCEfficiencyReplicas	(	const xAOD::Muon &	mu,
		int	n_replicas )

Definition at line 408 of file EfficiencyScaleFactor.cxx.

                                                                                                     {
        std::vector<float> replicas(n_replicas);
        CorrectionCode result = MCEfficiencyReplicas(mu, replicas);
        (*m_mc_eff_rep_decor)(mu) = replicas;
        return result;
    } 

ApplyScaleFactor()

CorrectionCode EfficiencyScaleFactor::ApplyScaleFactor

(

const xAOD::Muon &

mu

)

const

or you can just decorate the scale-factor to the muon

Definition at line 377 of file EfficiencyScaleFactor.cxx.

                                                                                  {
        float sf = 0;
        CorrectionCode result = ScaleFactor(mu, sf);
        (*m_sf_decor)(mu) = sf;
        return result;  
    }

ApplyScaleFactorReplicas()

CorrectionCode EfficiencyScaleFactor::ApplyScaleFactorReplicas	(	const xAOD::Muon &	mu,
		int	n_replicas )

Definition at line 383 of file EfficiencyScaleFactor.cxx.

                                                                                                     {
        std::vector<float> replicas(n_replicas);
        CorrectionCode result = ScaleFactorReplicas(mu, replicas);
        (*m_sf_rep_decor)(mu)= replicas;
        return result;
    }

CheckConsistency()

bool EfficiencyScaleFactor::CheckConsistency

(

)

check the consistency of the scale-factor map.

Needed histograms should be defined and the nominal fall back map is assigned properly as well as the map has a valid run number range

The histogram is simply not loaded which is fine since only the scale-factor is required

Definition at line 206 of file EfficiencyScaleFactor.cxx.

                                                  {
        //Check whether  the SFs could be successfully loaded
        if (!m_sf) {
            Error("EfficiencyScaleFactor()", "Could not load the SF for  measurement %s and systematic %s",EfficiencyTypeName(m_measurement).c_str(), sysname().c_str());
            return false;
        }
        if (m_respond_to_kineDepSyst && !m_sf_KineDepsys->initialize()) {
            Error("EfficiencyScaleFactor()", "Could not load the SF pt-dependent systematic for %s and systematic %s", EfficiencyTypeName(m_measurement).c_str(), sysname().c_str() );
            return false;
        }
        if (m_NominalFallBack.get() == this) {
            Error("EfficiencyScaleFactor()", "The EfficiencyScaleFactor %s has itself as Nominal Fall back.", EfficiencyTypeName(m_measurement).c_str());
            m_NominalFallBack.reset();
            return false;
        }
        if (m_NominalFallBack) {
            if (!m_NominalFallBack->sysname().empty() || sysname().empty()){
                Error("EfficiencyScaleFactor()", "Either nominal is assigned with a fall back (%s) or the nominal fall back is invald(%s).", sysname().c_str(), m_NominalFallBack->sysname().c_str() );
                return false;
            }
        }
        if (firstRun() > lastRun()){
            Error("EfficiencyScaleFactor()", "Invalid run number range. Since the map is ranging from %u to %u.", firstRun(), lastRun());
            return false;
        }
        std::function<bool(const std::unique_ptr<HistHandler>&)> consistent_histo = [](const std::unique_ptr<HistHandler>& histo)->bool{
            if (!histo) return true;
            for ( int i = 1; i <= histo->nBins(); ++i){
                if (std::isnan(histo->GetBinContent(i)) || std::isinf(histo->GetBinContent(i))){
                    Error("EfficiencyScaleFactor()", "The %d-th bin %s has not a number (%f)",i, histo->GetBinName(i).c_str(), histo->GetBinContent(i));
                    return false;
                }
            }
            return true;
        };
        if (!consistent_histo(m_sf)){
            Error("EfficiencyScaleFactor()", "Invalid scalefactor in %s", sysname().c_str());
            return false;
        }
        if (!consistent_histo(m_eff)){
            Error("EfficiencyScaleFactor()", "Invalid data-efficiency in %s", sysname().c_str());
            return false;
        }
        if (!consistent_histo(m_mc_eff)){
            Error("EfficiencyScaleFactor()", "Invalid MC-efficiency in %s", sysname().c_str());
            return false;
        }
        return true;
    }

coversRunNumber()

bool EfficiencyScaleFactor::coversRunNumber

(

unsigned int

run

)

const

Check if a run of data-taking is covered by this map.

Definition at line 199 of file EfficiencyScaleFactor.cxx.

                                                                     {
        return m_firstRun <= run && run <= m_lastRun;
    }

DataEfficiency()

CorrectionCode EfficiencyScaleFactor::DataEfficiency	(	const xAOD::Muon &	mu,
		float &	Eff ) const

... and absolute efficiencies

Definition at line 316 of file EfficiencyScaleFactor.cxx.

                                                                                              {
        if (m_separateBinSyst && m_NominalFallBack && m_eff) {
            int bin = -1;
            CorrectionCode cc = m_eff->FindBin(mu, bin);
            if (cc == CP::CorrectionCode::Error) {
                return cc;
            }
            if (bin != m_SystematicBin) {
                return m_NominalFallBack->DataEfficiency(mu, Eff);
            }
        }
        CorrectionCode cc = GetContentFromHist(m_eff.get(), mu, Eff, true);
        if (cc == CorrectionCode::Error) Error("EfficiencyScaleFactor", "Could not apply the data efficiency");
        return cc;
    }

DataEfficiencyReplicas()

CorrectionCode EfficiencyScaleFactor::DataEfficiencyReplicas	(	const xAOD::Muon &	mu,
		std::vector< float > &	eff )

Definition at line 417 of file EfficiencyScaleFactor.cxx.

                                                                                                           {
        return GetContentReplicasFromHist(m_eff_replicas, mu, eff, true);
    }

DebugPrint()

void CP::EfficiencyScaleFactor::DebugPrint

(

)

const

debug method

FindBinSF()

int EfficiencyScaleFactor::FindBinSF

(

const xAOD::Muon &

mu

)

const

Finds the bin to which the muon corresponds to.

Definition at line 492 of file EfficiencyScaleFactor.cxx.

                                                                  {
        int bin = -1;
        CorrectionCode cc = m_sf->FindBin(mu, bin);
        if (cc == CP::CorrectionCode::Error) {
            return -1;
        }
        return bin;
    }

firstRun()

unsigned int EfficiencyScaleFactor::firstRun

(

)

const

First run to which the map belongs to.

If the measurement is not carried out in time then it's usally 1

Definition at line 193 of file EfficiencyScaleFactor.cxx.

                                                      {
        return m_firstRun;
    }

GenerateReplicas()

void EfficiencyScaleFactor::GenerateReplicas ( int nrep, int seed )

private

Definition at line 451 of file EfficiencyScaleFactor.cxx.

                                                                   {
        GenerateReplicasFromHist(m_eff.get(), nrep, seed, m_eff_replicas);
        GenerateReplicasFromHist(m_sf.get(), nrep, seed, m_sf_replicas);
        GenerateReplicasFromHist(m_mc_eff.get(), nrep, seed, m_mc_eff_replicas);
    }

GenerateReplicasFromHist()

void EfficiencyScaleFactor::GenerateReplicasFromHist ( HistHandler * h, int nrep, int seed, EfficiencyScaleFactor::SFReplicaVec & repVector )

private

Definition at line 456 of file EfficiencyScaleFactor.cxx.

                                                                                                                                        {
        if (!h) return;
        TRandom3 Rndm(seed);
        replicas.clear();
        replicas.reserve(nrep);
        int nBins = h->nBins();
        for (int t = 0; t < nrep; t++) {
            replicas.push_back(package_histo(this, h->GetHist()));
            HistHandler* replica = replicas.back().get();
            for (int bin = 0; bin < nBins; bin++) {
                replica->SetBinContent(bin, Rndm.Gaus(h->GetBinContent(bin), h->GetBinError(bin)));
            }            
        }
    }

GetBinName()

std::string EfficiencyScaleFactor::GetBinName

(

int

bin

)

const

Returns the name of the bin using the axis title from the scale-factor map.

Definition at line 484 of file EfficiencyScaleFactor.cxx.

                                                             {
        if (bin < 1 || bin > nBins()) {
            Error("EfficiencyScaleFactor::GetBinName()", "The current bin %i is out of the maximum range %u ", bin, nBins());
            return "Out of range";
        }
        return m_sf->GetBinName(bin);
    }

GetContentFromHist() [1/2]

CorrectionCode EfficiencyScaleFactor::GetContentFromHist ( const HistHandler * Hist, columnar::MuonId mu, float & SF, bool add_kine_syst ) const

private

Definition at line 350 of file EfficiencyScaleFactor.cxx.

                                                                                                                                              {
        Eff = m_default_eff;
        if (!Hist) {
            if (m_warnsPrinted < m_warningLimit){
                Warning("EfficiencyScaleFactor", "Could not find histogram for variation %s and muon with pt=%.4f, eta=%.2f and phi=%.2f, returning %.1f", sysname().c_str(), ptAcc(mu), etaAcc(mu), phiAcc(mu), m_default_eff);
                ++m_warnsPrinted;
            }
            return CorrectionCode::OutOfValidityRange;
        }
        if (m_measurement == CP::MuonEfficiencyType::TTVA && std::abs(etaAcc(mu)) > 2.5 && std::abs(etaAcc(mu)) <= 2.7 && muonTypeAcc(mu) == xAOD::Muon::MuonType::MuonStandAlone) {
            if (m_warnsPrinted < m_warningLimit){
                Info("EfficiencyScaleFactor", "No TTVA sf/efficiency provided for standalone muons with 2.5<|eta|<2.7 for variation %s and muon with pt=%.4f, eta=%.2f and phi=%.2f, returning %.1f", sysname().c_str(), ptAcc(mu), etaAcc(mu), phiAcc(mu), m_default_eff_ttva);
                ++m_warnsPrinted;
            }
            Eff = m_default_eff_ttva;
            return CorrectionCode::Ok;
        }
        int bin = -1;       
        CorrectionCode cc = Hist->FindBin(mu, bin);
        if (cc != CorrectionCode::Ok) return cc;
        else Eff = Hist->GetBinContent(bin);
       
        if (add_kine_syst && m_respond_to_kineDepSyst) {           
            return m_sf_KineDepsys->GetKineDependent(mu, Eff);
        }
        return CorrectionCode::Ok;
    }

GetContentFromHist() [2/2]

CorrectionCode EfficiencyScaleFactor::GetContentFromHist ( const HistHandler * Hist, const xAOD::Muon & mu, float & SF, bool add_kine_syst ) const

private

read the content of the correct bin in one of my histos. MCefficiencies actually do not need a pt-dependet systematic

Definition at line 347 of file EfficiencyScaleFactor.cxx.

                                                                                                                                               {
        return GetContentFromHist (Hist, columnar::MuonId (mu), Eff, add_kine_syst);
    }

GetContentReplicasFromHist()

CorrectionCode EfficiencyScaleFactor::GetContentReplicasFromHist ( EfficiencyScaleFactor::SFReplicaVec & replicas, const xAOD::Muon & mu, std::vector< float > & SF, bool add_kine_syst )

private

read a vector of replica contents in the correct bin in one of my histos

Definition at line 423 of file EfficiencyScaleFactor.cxx.

                                                                                                                                                                               {
        if (replicas.size() != SF.size()) GenerateReplicas(SF.size(), 1000. * mu.phi() + mu.eta());
        if (replicas.empty()) return CorrectionCode::OutOfValidityRange;
        if (m_measurement == CP::MuonEfficiencyType::TTVA && std::abs(mu.eta()) > 2.5 && std::abs(mu.eta()) <= 2.7 && mu.muonType() == xAOD::Muon::MuonType::MuonStandAlone) {
            if (m_warnsPrinted < m_warningLimit){
                Info("EfficiencyScaleFactor", "No TTVA sf/efficiency provided for standalone muons with 2.5<|eta|<2.7 for variation %s and muon with pt=%.4f, eta=%.2f and phi=%.2f, returning %.1f", sysname().c_str(), mu.pt(), mu.eta(), mu.phi(), m_default_eff_ttva);
                ++m_warnsPrinted;
            }
            for (auto& r : SF)
                r = m_default_eff_ttva;
            return CorrectionCode::Ok;
        }
        int bin = -1;
        float extra_sys = 1;
        if (add_kine_syst && m_respond_to_kineDepSyst) {
           CorrectionCode cc = m_sf_KineDepsys->GetKineDependent(mu, extra_sys);
            if (cc != CorrectionCode::Ok) {}
        }
        
        CorrectionCode res = (*replicas.begin())->FindBin(mu, bin);
        if (res != CorrectionCode::Ok) return res;
        else {
            for (size_t k = 0; k < SF.size(); k++) {
                SF[k] = replicas.at(k)->GetBinContent(bin) * extra_sys;
            }
        }
        return res;
    }

isOverFlowBin()

bool EfficiencyScaleFactor::isOverFlowBin

(

int

b

)

const

Check whether the bin is overflow or not.

Definition at line 294 of file EfficiencyScaleFactor.cxx.

                                                        {      
        return m_sf ? m_sf->isOverFlowBin(b) : true;
    }

IsUpVariation()

bool EfficiencyScaleFactor::IsUpVariation

(

)

const

Definition at line 190 of file EfficiencyScaleFactor.cxx.

                                                   {
        return m_is_up;
    }

lastRun()

unsigned int EfficiencyScaleFactor::lastRun

(

)

const

Last run to which the map belongs to. The last run number is given exclusvely...

Definition at line 196 of file EfficiencyScaleFactor.cxx.

                                                     {
        return m_lastRun;
    }

MCEfficiency()

CorrectionCode EfficiencyScaleFactor::MCEfficiency	(	const xAOD::Muon &	mu,
		float &	Eff ) const

... mc efficiency

Definition at line 331 of file EfficiencyScaleFactor.cxx.

                                                                                            {
        if (m_separateBinSyst && m_NominalFallBack && m_mc_eff) {
            int bin = -1;
            CorrectionCode cc = m_mc_eff->FindBin(mu, bin);
            if (cc == CP::CorrectionCode::Error) {
                return cc;
            }
            if (bin != m_SystematicBin) {
                return m_NominalFallBack->MCEfficiency(mu, Eff);
            }
        }
        CorrectionCode cc = GetContentFromHist(m_mc_eff.get(), mu, Eff, false);
        if (cc == CorrectionCode::Error) Error("EfficiencyScaleFactor", "Could not apply the Monte Carlo efficiency");
        return cc;
    }

MCEfficiencyReplicas()

CorrectionCode EfficiencyScaleFactor::MCEfficiencyReplicas	(	const xAOD::Muon &	mu,
		std::vector< float > &	eff )

Definition at line 420 of file EfficiencyScaleFactor.cxx.

                                                                                                         {
        return GetContentReplicasFromHist(m_mc_eff_replicas, mu, eff, false);
    }

nBins()

int EfficiencyScaleFactor::nBins

(

)

const

How many bins does the scale-factor map have.

Only the bins of the primary map are counted. If the map has an extra kinematic systematic on top, these bins cannot be resolved at the moment

Definition at line 288 of file EfficiencyScaleFactor.cxx.

                                           {
        return m_sf ? m_sf->nBins() : -1;
    }

nOverFlowBins()

int EfficiencyScaleFactor::nOverFlowBins

(

)

const

Number of overflow bins in the map.

Definition at line 291 of file EfficiencyScaleFactor.cxx.

                                                  {
        return m_sf ? m_sf->nOverFlowBins() : -1;
    }

operator=()

EfficiencyScaleFactor & CP::EfficiencyScaleFactor::operator= ( const EfficiencyScaleFactor & )

delete

package_histo()

std::unique_ptr< HistHandler > EfficiencyScaleFactor::package_histo ( columnar::ColumnarTool<> * parent, TH1 * h )

private

Definition at line 272 of file EfficiencyScaleFactor.cxx.

                                                                                                          {
        // make sure that the correct type of histo is used
        // Dynamic cast for TH2 Poly otherwise we can rely on the GetDimension() ,ethod
        if (!h) return std::unique_ptr<HistHandler>();
        if (dynamic_cast<TH2Poly*>(h)) {
            return std::make_unique<HistHandler_TH2Poly>(parent, dynamic_cast<TH2Poly*>(h));
        }else if (h->GetDimension() == 3) {
            return std::make_unique<HistHandler_TH3>(parent, h);
        }else if (h->GetDimension() == 2) {
            return std::make_unique<HistHandler_TH2>(parent, h);
        } else if (h->GetDimension() == 1) {
            return std::make_unique<HistHandler_TH1>(parent, h);
        } 
        Error("EfficiencyScaleFactor", "Unable to package histo %s (%s) in a known HistHandler", h->GetName(), h->IsA()->GetName());
        return std::unique_ptr<HistHandler>();
    }

ReadFromFile()

bool CP::EfficiencyScaleFactor::ReadFromFile ( const std::string & file, const std::string & time_unit )

private

Read SF histrograms from a given input file.

ReadHistFromFile()

std::unique_ptr< HistHandler > EfficiencyScaleFactor::ReadHistFromFile ( columnar::ColumnarTool<> * parent, const std::string & name, TFile * f, const std::string & time_unit )

private

Definition at line 257 of file EfficiencyScaleFactor.cxx.

                                                                                                                                                                  {
        
        TH1* hist_from_file =  nullptr;
        
        f->GetObject((name + std::string("_") + time_unit).c_str(), hist_from_file);
         // if no period weighting, the histo may also not have a time period in the name at all
           
        if (!hist_from_file && time_unit == "All") {
            f->GetObject(name.c_str(), hist_from_file);
        }
        if (!hist_from_file) {
            return std::unique_ptr<HistHandler>();
        }
        return package_histo(parent, hist_from_file);
    }

ScaleFactor() [1/2]

CorrectionCode EfficiencyScaleFactor::ScaleFactor	(	columnar::MuonId	mu,
		float &	SF ) const

Definition at line 300 of file EfficiencyScaleFactor.cxx.

                                                                                         {
        if (m_separateBinSyst && m_NominalFallBack) {
            int bin = -1;
            CorrectionCode cc = m_sf->FindBin(mu, bin);
            if (cc == CP::CorrectionCode::Error) {
                return cc;
            }
            if (bin != m_SystematicBin) {
                return m_NominalFallBack->ScaleFactor(mu, SF);
            }
        }       
        CorrectionCode cc = GetContentFromHist(m_sf.get(), mu, SF, true);
        if (cc == CorrectionCode::Error) Error("EfficiencyScaleFactor", "Could not apply the scale factor");
        return cc;
    }   

ScaleFactor() [2/2]

CorrectionCode EfficiencyScaleFactor::ScaleFactor	(	const xAOD::Muon &	mu,
		float &	SF ) const

the important bits - extract SF info

scale factors...

Definition at line 297 of file EfficiencyScaleFactor.cxx.

                                                                                          {
        return ScaleFactor (columnar::MuonId (mu), SF);
    }   

ScaleFactorReplicas()

CorrectionCode EfficiencyScaleFactor::ScaleFactorReplicas	(	const xAOD::Muon &	mu,
		std::vector< float > &	SF )

Definition at line 414 of file EfficiencyScaleFactor.cxx.

                                                                                                       {
        return GetContentReplicasFromHist(m_sf_replicas, mu, SF, true);
    }

separateBinSyst()

bool EfficiencyScaleFactor::separateBinSyst

(

)

const

Definition at line 187 of file EfficiencyScaleFactor.cxx.

                                                      {
        return m_separateBinSyst;
    }

setFirstLastRun()

void EfficiencyScaleFactor::setFirstLastRun	(	unsigned int	first,
		unsigned int	last )

Set the run-number coverage.

Definition at line 202 of file EfficiencyScaleFactor.cxx.

                                                                                    {
        m_firstRun = first;
        m_lastRun = last;
    }

SetSystematicBin()

bool EfficiencyScaleFactor::SetSystematicBin

(

int

bin

)

This function will let the world implode since it allows to decorrelate the sysstematics bin by bin.

Definition at line 471 of file EfficiencyScaleFactor.cxx.

                                                        {
        if (m_syst_name.empty()) return true;
        if (!m_NominalFallBack) {
            Error("EfficiencyScaleFactor::SetSystematicBin()", "No fallback has been given for %s", sysname().c_str());
            return false;
        }
        if (!m_separateBinSyst || bin < 1 || bin > nBins()) {
            Error("EfficiencyScaleFactor::SetSystematicBin()", "The current bin %i is out of the maximum range %u ", bin, nBins());
            return false;
        }
        m_SystematicBin = bin;
        return true;
    }

sysname()

std::string EfficiencyScaleFactor::sysname

(

bool

with_direction = true

)

const

A string having the full name of the systematic including the measurement.

If the systematic string is empty then an empty string is returned. The flag controls whether the suffix __1UP or __1DN is appended after the string.

Definition at line 184 of file EfficiencyScaleFactor.cxx.

                                                                      {
        return m_syst_name.empty() ? "" : EfficiencyTypeName(m_measurement) +  "_" + m_syst_name +(m_is_lowpt ? "_LOWPT" : "") + (with_direction ? (m_is_up ?"__1UP" : "__1DN") :"");  
    }

Member Data Documentation

etaAcc

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

Definition at line 232 of file EfficiencyScaleFactor.h.

{*this, "eta"};

m_default_eff

float CP::EfficiencyScaleFactor::m_default_eff

private

default efficiency value (in case of OutOfValidityRange)

Definition at line 218 of file EfficiencyScaleFactor.h.

m_default_eff_ttva

float CP::EfficiencyScaleFactor::m_default_eff_ttva

private

default TTVA efficiency value (in case of MuonStandAlone for |eta|>2.5)

Definition at line 220 of file EfficiencyScaleFactor.h.

m_eff

std::unique_ptr<HistHandler> CP::EfficiencyScaleFactor::m_eff

private

Definition at line 187 of file EfficiencyScaleFactor.h.

m_eff_decor

std::unique_ptr<FloatDecorator> CP::EfficiencyScaleFactor::m_eff_decor

private

Definition at line 195 of file EfficiencyScaleFactor.h.

m_eff_rep_decor

std::unique_ptr<FloatVectorDecorator> CP::EfficiencyScaleFactor::m_eff_rep_decor

private

Definition at line 199 of file EfficiencyScaleFactor.h.

m_eff_replicas

SFReplicaVec CP::EfficiencyScaleFactor::m_eff_replicas

private

Definition at line 209 of file EfficiencyScaleFactor.h.

m_firstRun

unsigned int CP::EfficiencyScaleFactor::m_firstRun

private

Definition at line 225 of file EfficiencyScaleFactor.h.

m_is_lowpt

bool CP::EfficiencyScaleFactor::m_is_lowpt

private

states that this SF should respond to low pt systematics rather than high pt ones

Definition at line 180 of file EfficiencyScaleFactor.h.

m_is_up

bool CP::EfficiencyScaleFactor::m_is_up

private

Boolean whether the scale-factor is varying upwards or downwards Only relevant if the systname is not empty.

Definition at line 178 of file EfficiencyScaleFactor.h.

m_lastRun

unsigned int CP::EfficiencyScaleFactor::m_lastRun

private

Definition at line 226 of file EfficiencyScaleFactor.h.

m_mc_eff

std::unique_ptr<HistHandler> CP::EfficiencyScaleFactor::m_mc_eff

private

Definition at line 188 of file EfficiencyScaleFactor.h.

m_mc_eff_decor

std::unique_ptr<FloatDecorator> CP::EfficiencyScaleFactor::m_mc_eff_decor

private

Definition at line 196 of file EfficiencyScaleFactor.h.

m_mc_eff_rep_decor

std::unique_ptr<FloatVectorDecorator> CP::EfficiencyScaleFactor::m_mc_eff_rep_decor

private

Definition at line 200 of file EfficiencyScaleFactor.h.

m_mc_eff_replicas

SFReplicaVec CP::EfficiencyScaleFactor::m_mc_eff_replicas

private

Definition at line 210 of file EfficiencyScaleFactor.h.

m_measurement

CP::MuonEfficiencyType CP::EfficiencyScaleFactor::m_measurement

private

Section of variables of the tool.

Definition at line 173 of file EfficiencyScaleFactor.h.

m_muons

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

Definition at line 230 of file EfficiencyScaleFactor.h.

{*this, "Muons"};

m_NominalFallBack

std::shared_ptr<EfficiencyScaleFactor> CP::EfficiencyScaleFactor::m_NominalFallBack

private

Nominal fall-back scale-factor.

Definition at line 213 of file EfficiencyScaleFactor.h.

m_respond_to_kineDepSyst

bool CP::EfficiencyScaleFactor::m_respond_to_kineDepSyst

private

steers the pt dependent systematics

Definition at line 182 of file EfficiencyScaleFactor.h.

m_separateBinSyst

bool CP::EfficiencyScaleFactor::m_separateBinSyst

private

Can the systematic be decorrelated.

Definition at line 184 of file EfficiencyScaleFactor.h.

m_sf

std::unique_ptr<HistHandler> CP::EfficiencyScaleFactor::m_sf

private

the histograms needed to run

Definition at line 186 of file EfficiencyScaleFactor.h.

m_sf_decor

std::unique_ptr<FloatDecorator> CP::EfficiencyScaleFactor::m_sf_decor

private

Definition at line 194 of file EfficiencyScaleFactor.h.

m_sf_KineDepsys

std::unique_ptr<IKinematicSystHandler> CP::EfficiencyScaleFactor::m_sf_KineDepsys

private

Definition at line 204 of file EfficiencyScaleFactor.h.

m_sf_rep_decor

std::unique_ptr<FloatVectorDecorator> CP::EfficiencyScaleFactor::m_sf_rep_decor

private

Definition at line 198 of file EfficiencyScaleFactor.h.

m_sf_replicas

SFReplicaVec CP::EfficiencyScaleFactor::m_sf_replicas

private

replicas, in case we use them

Definition at line 208 of file EfficiencyScaleFactor.h.

m_syst_name

std::string CP::EfficiencyScaleFactor::m_syst_name

private

Definition at line 174 of file EfficiencyScaleFactor.h.

m_SystematicBin

int CP::EfficiencyScaleFactor::m_SystematicBin

private

Definition at line 214 of file EfficiencyScaleFactor.h.

m_warningLimit

const unsigned int EfficiencyScaleFactor::m_warningLimit = 10

staticprivate

Definition at line 223 of file EfficiencyScaleFactor.h.

m_warnsPrinted

std::atomic<unsigned int> CP::EfficiencyScaleFactor::m_warnsPrinted

mutableprivate

Definition at line 222 of file EfficiencyScaleFactor.h.

muonTypeAcc

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

Definition at line 234 of file EfficiencyScaleFactor.h.

{*this, "muonType"};

phiAcc

columnar::MuonAccessor<columnar::RetypeColumn<double,float> > CP::EfficiencyScaleFactor::phiAcc {*this, "phi"}

Definition at line 233 of file EfficiencyScaleFactor.h.

{*this, "phi"};

ptAcc

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

Definition at line 231 of file EfficiencyScaleFactor.h.

{*this, "pt"};

---

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

• EfficiencyScaleFactor.h
• EfficiencyScaleFactor.cxx