CP::BadMuonVetoSystHandler Class Reference

#include <KinematicSystHandler.h>

Inheritance diagram for CP::BadMuonVetoSystHandler:

Collaboration diagram for CP::BadMuonVetoSystHandler:

Public Types
typedef float(IKinematicSystHandler::*	KinVariable) (const xAOD::Muon &mu) const
	Typedef to prepare function pointers to the muon. More...

Public Member Functions
CorrectionCode	GetKineDependent (const xAOD::Muon &mu, float &Eff) const override
	Add an additional uncertainty to the muon depending on its kinematics. More...
void	SetSystematicWeight (float SystWeight) override
	Set's the absolute scaling of the systematic. More...
bool	initialize () override
	Initialize method to load the inputs and check that everything will work as expected. More...
	BadMuonVetoSystHandler (TDirectory *InDir_3Stations, TDirectory *InDir_2Stations=nullptr)
virtual	~BadMuonVetoSystHandler ()
KinVariable	GetMuonVariableToUse (const std::string &name)
float	Eta (const xAOD::Muon &mu) const
float	Pt (const xAOD::Muon &mu) const
float	PtGeV (const xAOD::Muon &mu) const
float	AbsEta (const xAOD::Muon &mu) const

Private Types
typedef std::pair< float, float >	Ranges

Private Member Functions
CP::CorrectionCode	findAppropiatePolynomial (const xAOD::Muon &mu, TF1 *&Poly) const
std::string	getNextProperty (std::string &sstr) const
void	fillMap (TDirectory *InDir, std::map< Ranges, std::unique_ptr< TF1 >> &systPolynomials)

Private Attributes
std::map< Ranges, std::unique_ptr< TF1 > >	m_syst3Stations
std::map< Ranges, std::unique_ptr< TF1 > >	m_syst2Stations
KinVariable	m_uncertVar
KinVariable	m_polySelVar
float	m_SystWeight

Detailed Description

Definition at line 111 of file KinematicSystHandler.h.

Member Typedef Documentation

KinVariable

typedef float(IKinematicSystHandler::* CP::IKinematicSystHandler::KinVariable) (const xAOD::Muon &mu) const

inherited

Typedef to prepare function pointers to the muon.

Definition at line 45 of file KinematicSystHandler.h.

Ranges

typedef std::pair<float, float> CP::BadMuonVetoSystHandler::Ranges

private

Definition at line 121 of file KinematicSystHandler.h.

Constructor & Destructor Documentation

BadMuonVetoSystHandler()

CP::BadMuonVetoSystHandler::BadMuonVetoSystHandler	(	TDirectory *	InDir_3Stations,
		TDirectory *	InDir_2Stations = nullptr
	)

Definition at line 125 of file KinematicSystHandler.cxx.

                                                                                                           :
                    m_syst3Stations(),
                    m_syst2Stations(),
                    m_uncertVar(nullptr),
                    m_polySelVar(nullptr),
                    m_SystWeight(0.) {
        fillMap(InDir_3Stations, m_syst3Stations);
        if (InDir_2Stations && InDir_2Stations!= InDir_3Stations) {
            fillMap(InDir_2Stations,m_syst2Stations);            
        }
                        
    }

~BadMuonVetoSystHandler()

CP::BadMuonVetoSystHandler::~BadMuonVetoSystHandler ( )

virtual

Definition at line 210 of file KinematicSystHandler.cxx.

                                                    {
    }

Member Function Documentation

AbsEta()

float CP::IKinematicSystHandler::AbsEta ( const xAOD::Muon &  mu ) const

inherited

Definition at line 17 of file KinematicSystHandler.cxx.

                                                                {
        return std::abs(mu.eta());
    }

Eta()

float CP::IKinematicSystHandler::Eta ( const xAOD::Muon &  mu ) const

inherited

Definition at line 8 of file KinematicSystHandler.cxx.

                                                             {
        return mu.eta();
    }

fillMap()

void CP::BadMuonVetoSystHandler::fillMap ( TDirectory *  InDir, std::map< Ranges, std::unique_ptr< TF1 >> &  systPolynomials  )

private

Otherwise we need to get rid of the string

Definition at line 137 of file KinematicSystHandler.cxx.

                                                                                                              {
        if (!InDir) {
            Error("BadMuonSysVetoHandler()", "No TDirectory is given");
            return;
        }
        TIter next(InDir->GetListOfKeys());
        while (TObject* obj = next()) {
            std::string ObjName = obj->GetName();
            float lowRange(-1.e20), highRange(1.e20);
            if (ObjName.find("TF1") == std::string::npos) {
                continue;
            }
            TF1* TF = nullptr;
            InDir->GetObject(ObjName.c_str(), TF);
            if (!TF) {
                continue;
            }
            //Elimnate the TF1_
            getNextProperty(ObjName);
            if (!m_uncertVar) {m_uncertVar = GetMuonVariableToUse(getNextProperty(ObjName));}
            else {getNextProperty(ObjName);}        
            if (!m_polySelVar) {m_polySelVar = GetMuonVariableToUse(getNextProperty(ObjName));}
            else {getNextProperty(ObjName);}
           
            std::string LowRange_str = getNextProperty(ObjName);
            std::string HighRange_str = getNextProperty(ObjName);
            if (!LowRange_str.empty()) {
                lowRange = atof(LowRange_str.c_str()) / std::pow(10, LowRange_str.size() -1);
            }
            if (!HighRange_str.empty()) {
                highRange = atof(HighRange_str.c_str()) / std::pow(10, LowRange_str.size() -1);
            }
            systPolynomials.insert(std::pair<Ranges, std::unique_ptr<TF1>>(Ranges(lowRange, highRange), std::unique_ptr<TF1>(TF)));
        }
 
    }

findAppropiatePolynomial()

CP::CorrectionCode CP::BadMuonVetoSystHandler::findAppropiatePolynomial ( const xAOD::Muon &  mu, TF1 *&  Poly  ) const

private

Definition at line 213 of file KinematicSystHandler.cxx.

                                                                                                          {
        if (!m_polySelVar) {
            Error("BadMuonVetoSystHandler()", "Something went wrong with the initialization");
            return CorrectionCode::Error;
        }
        uint8_t nprecisionLayers=0;      
        if (!mu.summaryValue(nprecisionLayers, xAOD::SummaryType::numberOfPrecisionLayers)){
            Error("BadMuonSysVetoHandler()", "Precisionlayers unkown");
            return CorrectionCode::Error;
        } else if (nprecisionLayers >= 3) {
            for (const auto& BinnedPoly : m_syst3Stations) {
                if (BinnedPoly.first.first <= (this->*m_polySelVar)(mu) && (this->*m_polySelVar)(mu) < BinnedPoly.first.second) {
                    Poly = BinnedPoly.second.get();
                    return CorrectionCode::Ok;
                }
            }
        } else if (nprecisionLayers == 2) {
            for (const auto& BinnedPoly : m_syst2Stations) {
                if (BinnedPoly.first.first <= (this->*m_polySelVar)(mu) && (this->*m_polySelVar)(mu) < BinnedPoly.first.second) {
                    Poly = BinnedPoly.second.get();
                    return CorrectionCode::Ok;
                }
            }
        }       
        return CP::CorrectionCode::OutOfValidityRange;
    }

GetKineDependent()

CorrectionCode CP::BadMuonVetoSystHandler::GetKineDependent ( const xAOD::Muon &  mu, float &  Eff  ) const

overridevirtual

Add an additional uncertainty to the muon depending on its kinematics.

Implements CP::IKinematicSystHandler.

Definition at line 174 of file KinematicSystHandler.cxx.

                                                                                                {
        if (m_SystWeight == 0.) {           
            return CorrectionCode::Ok;
        }
        TF1* Poly = nullptr;
        // we know that Eff=(1+relative sys error), since SF==1
        float RelHighPtSys = 0.;
        if (mu.pt() >= 100.e3) {
            CorrectionCode cc = findAppropiatePolynomial(mu, Poly);
            if (cc != CorrectionCode::Ok) {
                return cc;
            }            
            RelHighPtSys = Poly->Eval((this->*m_uncertVar)(mu));           
 
        } else {
            //Apply flat 0.5% systematic
            RelHighPtSys = 0.005;
        }
        Eff = 1 + m_SystWeight * std::sqrt(std::pow(Eff - 1,2) + RelHighPtSys * RelHighPtSys);
 
        return CorrectionCode::Ok;
    }

GetMuonVariableToUse()

IKinematicSystHandler::KinVariable CP::IKinematicSystHandler::GetMuonVariableToUse ( const std::string &  name )

inherited

Definition at line 21 of file KinematicSystHandler.cxx.

                                                                                                      {
        if (name == "pt") return &IKinematicSystHandler::Pt;
        if (name == "ptGeV") return &IKinematicSystHandler::PtGeV;
        if (name == "eta") return &IKinematicSystHandler::Eta;
        if (name == "AbsEta") return &IKinematicSystHandler::AbsEta;
        return nullptr;
    }

getNextProperty()

std::string CP::BadMuonVetoSystHandler::getNextProperty ( std::string &  sstr ) const

private

Definition at line 239 of file KinematicSystHandler.cxx.

                                                                           {
        //Eliminate the beginning underscores
        while (!sstr.empty() && sstr[0] == '_') {
            sstr.erase(0, 1);
        }
        size_t pos = sstr.find("_");
        std::string Property = pos != std::string::npos ? sstr.substr(0, pos) : sstr;
        if (pos != std::string::npos) {
            sstr = sstr.substr(Property.size() + 1, sstr.size());
        }
        return Property;
    }

initialize()

bool CP::BadMuonVetoSystHandler::initialize ( )

overridevirtual

Initialize method to load the inputs and check that everything will work as expected.

Implements CP::IKinematicSystHandler.

Definition at line 200 of file KinematicSystHandler.cxx.

                                            {
        if (m_syst3Stations.empty()) {
            Error("BadMuonVetoSystHandler::initialize()", "No polynomials");
            return false;
        }
        if (!m_uncertVar || !m_polySelVar) {
            return false;
        }
        return true;
    }

Pt()

float CP::IKinematicSystHandler::Pt ( const xAOD::Muon &  mu ) const

inherited

Definition at line 11 of file KinematicSystHandler.cxx.

                                                            {
        return mu.pt();
    }

PtGeV()

float CP::IKinematicSystHandler::PtGeV ( const xAOD::Muon &  mu ) const

inherited

Definition at line 14 of file KinematicSystHandler.cxx.

                                                               {
        return mu.pt() / 1.e3;
    }

SetSystematicWeight()

void CP::BadMuonVetoSystHandler::SetSystematicWeight ( float  SystWeight )

overridevirtual

Set's the absolute scaling of the systematic.

For daily puposes it's usually either 1 or -1 indicating if the instance is an upwards or downwards variation.

Implements CP::IKinematicSystHandler.

Definition at line 196 of file KinematicSystHandler.cxx.

                                                                     {
        m_SystWeight = SystWeight;
    }

Member Data Documentation

m_polySelVar

KinVariable CP::BadMuonVetoSystHandler::m_polySelVar

private

Definition at line 132 of file KinematicSystHandler.h.

m_syst2Stations

std::map<Ranges, std::unique_ptr<TF1> > CP::BadMuonVetoSystHandler::m_syst2Stations

private

Definition at line 129 of file KinematicSystHandler.h.

m_syst3Stations

std::map<Ranges, std::unique_ptr<TF1> > CP::BadMuonVetoSystHandler::m_syst3Stations

private

Definition at line 128 of file KinematicSystHandler.h.

m_SystWeight

float CP::BadMuonVetoSystHandler::m_SystWeight

private

Definition at line 133 of file KinematicSystHandler.h.

m_uncertVar

KinVariable CP::BadMuonVetoSystHandler::m_uncertVar

private

Definition at line 131 of file KinematicSystHandler.h.

---

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

• KinematicSystHandler.h
• KinematicSystHandler.cxx