IDApplier

Description

Guesses the selection from the histogram name in the maps, and applies it by setting the weights to 0 to muons that don't pass the selection.

Note: tuned for Run 2 UL

Inheritance diagram for IDApplier:

Collaboration diagram for IDApplier:

Public Member Functions
	IDApplier (const fs::path &filePath, TString name, int year, bool correction, bool uncertainties)
Public Member Functions inherited from CorrectionlibSFApplier< DAS::RecMuon >
	CorrectionlibSFApplier (const std::filesystem::path &filePath, const std::string &name, bool correction, bool uncertainties)
virtual	~CorrectionlibSFApplier () noexcept=default
void	operator() (DAS::RecMuon &object, const Context &... ctx) const
void	operator() (std::vector< DAS::RecMuon > &objects, const Context &... ctx) const
std::vector< std::string >	weightNames () const

Public Attributes
TString	name
TString	NUM
TString	DEN

Protected Member Functions
bool	passes (const RecMuon &muon) const override
void	inputs (std::vector< correction::Variable::Type > &inputs, const RecMuon &muon) const override
std::pair< double, double >	varied (std::vector< correction::Variable::Type > &inputs, double sf, const correction::Variable::Type &uncname) const override
int	binIndex (const RecMuon &muon) const override
Protected Member Functions inherited from CorrectionlibSFApplier< DAS::RecMuon >
void	addBinWiseUnc (const std::string &name, const correction::Variable::Type &input)
void	addGlobalUnc (const std::string &name, const correction::Variable::Type &input)
virtual bool	passes (const DAS::RecMuon &obj, const Context &... ctx) const=0
virtual void	inputs (std::vector< correction::Variable::Type > &inputs, const DAS::RecMuon &obj, const Context &... ctx) const=0
virtual int	binIndex (const DAS::RecMuon &obj, const Context &... ctx) const

Static Private Member Functions
static Selector	getMask (const string &s)

Private Attributes
TH2C	binning
Selector	num
Selector	den

Static Private Attributes
static constexpr std::array	eta_bins_run2
static constexpr std::array	eta_bins_run3
static constexpr std::array	pt_bins

Additional Inherited Members
Protected Attributes inherited from CorrectionlibSFApplier< DAS::RecMuon >
correction::Correction::Ref	m_cref

Constructor & Destructor Documentation

IDApplier()

IDApplier ( const fs::path &  filePath, TString  name, int  year, bool  correction, bool  uncertainties  )

inline

        : CorrectionlibSFApplier(filePath, name.Data(), correction,
                                 uncertainties)
        , name  ( name                     )
        , binning("", "",
                  year > 2018 ? eta_bins_run3.size() - 1: eta_bins_run2.size() - 1,
                  year > 2018 ? eta_bins_run3.data() : eta_bins_run3.data(),
                  pt_bins.size() - 1, pt_bins.data())
    {
        // CorrectionlibSFApplier does the Right Thing with the uncertainties
        // added below: they are just ignored if not requested in the flags.
        // This helps keep the code simple.
 
        auto uncname = name + "_stat";
        addBinWiseUnc(uncname.Data(), "stat");
 
        for (auto var : {"AltSig", "massBin", "massRange", "tagIso"}) {
            uncname = name + "_" + var;
            addGlobalUnc(uncname.Data(), var);
        }
 
        name.ReplaceAll("andIPCut", "");
 
        DEN = name(TRegexp("_DEN_.*"));
        name.ReplaceAll(DEN, "");
        DEN.ReplaceAll("_DEN_", "");
        den = getMask(DEN.Data());
 
        NUM = name;
        NUM.ReplaceAll("NUM_", "");
        num = getMask(NUM.Data());
 
        cout << "Initialisation of " << __func__ << " done" << endl;
    }

Member Function Documentation

binIndex()

int binIndex ( const RecMuon &  muon ) const

inlineoverrideprotected

Reimplemented from CorrectionlibSFApplier::binIndex.

Note

Muon scale factors are derived using the raw transverse momentum.

    {
        return binning.FindFixBin(muon.p4.Eta(), muon.p4.Pt());
    }

getMask()

static Selector getMask ( const string &  s )

inlinestaticprivate

Translate table name from Muon POG ROOT file into selector.

    {
        // RECO
        if (s == "TrackerMuons") return Selector::None;
        if (s == "genTracks"   ) return Selector::None;
 
        // Muon ID
        if (s ==        "LooseID") return Selector::CutBasedIdLoose       ;
        if (s ==       "MediumID") return Selector::CutBasedIdMedium      ;
        if (s == "MediumPromptID") return Selector::CutBasedIdMediumPrompt;
        if (s ==         "SoftID") return Selector::SoftCutBasedId        ;
        if (s ==        "TightID") return Selector::CutBasedIdTight       ; // andIPCut?
        if (s ==       "HighPtID") return Selector::CutBasedIdGlobalHighPt; // andIPCut?
        if (s ==    "TrkHighPtID") return Selector::CutBasedIdTrkHighPt   ; // andIPCut?
 
        // Muon ISO
        if (s ==     "VeryLooseRelIso") return Selector::PFIsoVeryLoose    ;
        if (s ==         "LooseRelIso") return Selector::PFIsoLoose        ;
        if (s ==        "MediumRelIso") return Selector::PFIsoMedium       ;
        if (s ==         "TightRelIso") return Selector::PFIsoTight        ;
        if (s ==     "VeryTightRelIso") return Selector::PFIsoVeryTight    ;
        if (s == "VeryVeryTightRelIso") return Selector::PFIsoVeryVeryTight;
        if (s ==       "LooseRelTkIso") return Selector::TkIsoLoose        ;
        if (s ==       "TightRelTkIso") return Selector::TkIsoTight        ;
 
        BOOST_THROW_EXCEPTION( invalid_argument(s + " is not recognised.") );
    }

inputs()

void inputs ( std::vector< correction::Variable::Type > &  inputs, const RecMuon &  muon  ) const

inlineoverrideprotected

    {
        inputs = {muon.p4.Eta(), muon.p4.Pt(), "nominal"};
    }

passes()

bool passes ( const RecMuon &  muon ) const

inlineoverrideprotected

Todo:

IPCut? (unless it's already included in IPCut?)

    {
        if (muon.p4.Pt() < pt_bins.front()) return false;
 
        return num == 0 // Non standard, tracker SF
            || (num & muon.selectors) == num;
    }

varied()

std::pair<double, double> varied ( std::vector< correction::Variable::Type > &  inputs, double  sf, const correction::Variable::Type &  uncname  ) const

inlineoverrideprotectedvirtual

Called to retrieve the up and down variations of a scale factor.

The value comes from addBinWiseUnc or addGlobalUnc.

Implements CorrectionlibSFApplier< DAS::RecMuon >.

    {
        inputs[2] = uncname;
        const auto unc = m_cref->evaluate(inputs);
        return {sf + unc, sf - unc};
    }

Member Data Documentation

binning

TH2C binning

private

Dummy histogram to compute bin numbers.

den

Selector den

private

DEN

TString DEN

eta_bins_run2

constexpr std::array eta_bins_run2

staticconstexprprivate

Initial value:

{
        -2.4, -2.1, -1.2, -0.9, 0.0, 0.9, 1.2, 2.1, 2.4}

eta binning used for MUO ID scale factors in Run 2

Todo:

Extract bins from correctionlib? See https://github.com/cms-nanoAOD/correctionlib/issues/286

eta_bins_run3

constexpr std::array eta_bins_run3

staticconstexprprivate

Initial value:

{
        -2.4, -2.1, -1.6, -1.2, -0.9, -0.3, -0.2, 0.2, 0.3, 0.9, 1.2, 1.6, 2.1, 2.4}

eta binning used for MUO ID scale factors in Run 3

Todo:

Extract bins from correctionlib? See https://github.com/cms-nanoAOD/correctionlib/issues/286

name

TString name

num

Selector num

private

NUM

TString NUM

pt_bins

constexpr std::array pt_bins

staticconstexprprivate

Initial value:

{
        15.0, 20.0, 25.0, 30.0, 40.0, 50.0, 60.0, 120.0, 1e5}

pT binning used for MUO ID scale factors

Todo:

Extract bins from correctionlib? See https://github.com/cms-nanoAOD/correctionlib/issues/286

---

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

• /builds/cms-analysis/general/DasAnalysisSystem/Core/Installer/Core/Muons/bin/applyMuonSelection.cc