Helper

#include <helper.h>

Collaboration diagram for Helper:

Public Member Functions
	Helper (DAS::Parameters &parameters)
DAS::GenJet	GetGenJet (const reco::JetFlavourInfoMatching &ijet)
DAS::GenJet	GetGenJet (const reco::Jet &ijet)
DAS::RecJet	GetRecJet (const pat::Jet &ijet)
bool	JetID (const pat::Jet &jet)
DAS::GenMuon	GetGenMu (const reco::Candidate &mu)
DAS::RecMuon	GetRecMu (const pat::Muon &mu)
DAS::GenPhoton	GetGenPhoton (const reco::GenParticle &photon, bool zAncestor)
DAS::RecPhoton	GetRecPhoton (const pat::Photon &photon)
std::vector< std::string >	CollectWeightIds (const tinyxml2::XMLDocument &doc, const std::string &scaleChoice, const std::string &pdfGroupName) const
std::string	BufferWeightGroupXML (const LHERunInfoProduct &runInfo) const
std::vector< std::string >	GetScaleVariations (const tinyxml2::XMLDocument &doc, const std::string &scaleChoice) const
int	CountPDFWeights (const tinyxml2::XMLDocument &doc, const std::string &pdfGroupName) const

Public Attributes
DAS::Parameters &	p

Constructor & Destructor Documentation

Helper()

Helper

(

DAS::Parameters &

parameters

)

Constructor

Only giving parameters in reference

: p(parameters) {}

Member Function Documentation

BufferWeightGroupXML()

string BufferWeightGroupXML

(

const LHERunInfoProduct &

runInfo

)

const

Extracts the XML fragment starting at <weightgroup> from LHE headers.

Parameters

runInfo

The LHERunInfoProduct containing header lines to scan.

Returns

A string with the buffered XML (empty if no <weightgroup> found).

{
    ostringstream buffer;
    bool startProcessing = false;
 
    for (auto iter = runInfo.headers_begin(); iter != runInfo.headers_end(); ++iter) {
        for (const string& line : iter->lines()) {
            string current = line;
 
            // strip comments after '#'
            auto cpos = current.find('#');
            if (cpos != string::npos)
                current.erase(cpos);
 
            // if we haven't hit <weightgroup> yet, look for it
            if (!startProcessing) {
                auto wpos = current.find("<weightgroup");
                if (wpos != string::npos) {
                    startProcessing = true;
                    buffer << current.substr(wpos) << "\n";
                }
            }
            else {
                // already in the XML region – keep every line
                buffer << current << "\n";
            }
        }
    }
    
    return buffer.str();
}

CollectWeightIds()

vector< string > CollectWeightIds	(	const tinyxml2::XMLDocument &	doc,
		const std::string &	scaleChoice,
		const std::string &	pdfGroupName
	)		const

Extracts HT/2 variation and PDF variation IDs from an XML document, skipping any off‐diagonal static scale combinations (FactorisationUpRenormalisationDown and FactorisationDownRenormalisationUp).

Parameters

doc	The XMLDocument containing <weightgroup> elements.
scaleChoice	The substring to match in the <weight> text, e.g. "HT/2".
pdfGroupName	The name of the PDF group to match, e.g. "NNPDF31_nlo_hessian_pdfas".

Returns

A vector which contains all matched weight IDs.

{
    vector<string> genweight_ids;
    const double nominal = 1.0;
    bool foundScale = false;
    bool foundPDF   = false;
 
    for (auto* wg = doc.FirstChildElement("weightgroup");
         wg;
         wg = wg->NextSiblingElement("weightgroup"))
    {
        const char* nameC = wg->Attribute("name");
        if (!nameC) continue;
        const string name{ nameC };
 
        if (name == "Central scale variation") {
            // collect dynamic-scale IDs
            for (auto* w = wg->FirstChildElement("weight");
                 w;
                 w = w->NextSiblingElement("weight"))
            {
                const char* txt = w->GetText();
                std::regex pat("dyn_scale_choice=" + scaleChoice + "(\\s|$)");
                if (!txt || !std::regex_search(txt, pat))
                    continue;
 
                foundScale = true;
 
                // parse static MUF/MUR
                double muf = stod(w->Attribute("MUF"));
                double mur = stod(w->Attribute("MUR"));
 
                // skip off-diagonals: one > nominal, one < nominal
                if ((muf > nominal && mur < nominal) ||
                    (muf < nominal && mur > nominal))
                {
                    continue;
                }
 
                if (const char* id = w->Attribute("id"))
                    genweight_ids.emplace_back(id);
            }
        }
        else if (name == pdfGroupName) {
            foundPDF = true;
            // collect *all* PDF-group IDs
            for (auto* w = wg->FirstChildElement("weight");
                 w;
                 w = w->NextSiblingElement("weight"))
            {
                if (const char* id = w->Attribute("id"))
                    genweight_ids.emplace_back(id);
            }
        }
    }
 
    if (!foundScale)
        throw cms::Exception("Ntupliser") << "No weights found for scale choice: " + scaleChoice;
    if (!foundPDF)
        throw cms::Exception("Ntupliser") << "No weights found for PDF group: " + pdfGroupName;
 
    return genweight_ids;
}

CountPDFWeights()

int CountPDFWeights	(	const tinyxml2::XMLDocument &	doc,
		const std::string &	pdfGroupName
	)		const

Counts the number of weights in the specified PDF group.

Parameters

doc	The XML document containing <weightgroup> elements.
pdfGroupName	The exact name attribute of the PDF group to count.

Returns

The total count of <weight> tags under that group.

{
    int pdfWeightCount = 0;
 
    for (const tinyxml2::XMLElement* group = doc.FirstChildElement("weightgroup");
         group;
         group = group->NextSiblingElement("weightgroup"))
    {
        const char* name = group->Attribute("name");
        if (!name)
            throw cms::Exception("Ntupliser") << "<weightgroup> element is missing required \"name\" attribute";
        
        if (pdfGroupName == name)
        {
            for (const tinyxml2::XMLElement* w = group->FirstChildElement("weight");
                 w;
                 w = w->NextSiblingElement("weight"))
            {
                    ++pdfWeightCount;
            }
        }
    }
 
    if (pdfWeightCount == 0)
        throw cms::Exception("Ntupliser") << "PDF group \"" << pdfGroupName << "\" not found or empty";
 
    return pdfWeightCount;
}

GetGenJet() [1/2]

DAS::GenJet GetGenJet

(

const reco::Jet &

ijet

)

Helper to get DAS::GenJet from MiniAOD without flavour.

{
    DAS::GenJet jjet;
 
    // kinematics
    jjet.p4 = DAS::FourVector(ijet.p4());
 
    return jjet;
}

GetGenJet() [2/2]

DAS::GenJet GetGenJet

(

const reco::JetFlavourInfoMatching &

ijet

)

Helper to get DAS::GenJet from MiniAOD with flavour.

{
    const reco::Jet& Jet = *(ijet.first.get());
    const reco::JetFlavourInfo& Info = ijet.second;
 
    DAS::GenJet jjet = GetGenJet(Jet);
 
    // parton flavour
    jjet.partonFlavour = Info.getPartonFlavour();
 
    // heavy-flavour hadrons
    jjet.nBHadrons = Info.getbHadrons().size();
    jjet.nCHadrons = Info.getcHadrons().size();
 
    return jjet;
}

GetGenMu()

DAS::GenMuon GetGenMu

(

const reco::Candidate &

mu

)

Helper to get DAS::GenMuon from MiniAOD.

{
    DAS::GenMuon Mu;
 
    // kinematics
    Mu.p4 = mu.p4();
 
    Mu.Q = mu.charge();
 
    return Mu;
}

GetGenPhoton()

DAS::GenPhoton GetGenPhoton	(	const reco::GenParticle &	photon,
		bool	zAncestor
	)

Helper to get DAS::GenPhoton from MiniAOD.

{
    DAS::GenPhoton dasPhoton;
 
    // kinematics
    dasPhoton.p4 = photon.p4();
    dasPhoton.zAncestor = zAncestor;
    dasPhoton.prompt = photon.isPromptFinalState();
 
    return dasPhoton;
}

GetRecJet()

DAS::RecJet GetRecJet

(

const pat::Jet &

ijet

)

Helper to get DAS::RecJet from MiniAOD.

General instructions DeepJet

{
    DAS::RecJet jjet;
 
    // kinematics
    jjet.p4      = ijet.correctedP4("Uncorrected");
 
    // JetMET business
    jjet.area    = ijet.jetArea();
    jjet.puID    = p.PUjetID ?  ijet.userFloat("pileupJetId:fullDiscriminant") : 1.;
 
    if (p.flavour) {
        // parton flavour
        jjet.partonFlavour = ijet.partonFlavour();
 
        // heavy-flavour hadrons
        jjet.nBHadrons = ijet.jetFlavourInfo().getbHadrons().size();
        jjet.nCHadrons = ijet.jetFlavourInfo().getcHadrons().size();
 
        // heavy-flavour tagging
        jjet.DeepJet.probb    = ijet.bDiscriminator("pfDeepFlavourJetTags:probb");
        jjet.DeepJet.probbb   = ijet.bDiscriminator("pfDeepFlavourJetTags:probbb"); 
        jjet.DeepJet.problepb = ijet.bDiscriminator("pfDeepFlavourJetTags:problepb"); 
        jjet.DeepJet.probc    = ijet.bDiscriminator("pfDeepFlavourJetTags:probc");
        //jjet.DeepJet.probcc   = ijet.bDiscriminator("pfDeepFlavourJetTags:probcc"); 
        jjet.DeepJet.probuds  = ijet.bDiscriminator("pfDeepFlavourJetTags:probuds"); 
        jjet.DeepJet.probg    = ijet.bDiscriminator("pfDeepFlavourJetTags:probg"); 
 
        static const auto eps = 10*numeric_limits<float>::epsilon();
        if (abs(jjet.DeepJet.probb + jjet.DeepJet.probbb + jjet.DeepJet.problepb + jjet.DeepJet.probc + /*jjet.DeepJet.probcc +*/ jjet.DeepJet.probuds + jjet.DeepJet.probg - 1) > eps)
            cerr << abs(jjet.DeepJet.probb + jjet.DeepJet.probbb + jjet.DeepJet.problepb + jjet.DeepJet.probc + /*jjet.DeepJet.probcc +*/ jjet.DeepJet.probuds + jjet.DeepJet.probg - 1) << ' '  << eps << endl;
    }
 
    jjet.scales.resize(1, 1.0);
 
    return jjet;
}

GetRecMu()

DAS::RecMuon GetRecMu

(

const pat::Muon &

mu

)

Helper to get DAS::RecMuon from MiniAOD.

{
    DAS::RecMuon Mu;
 
    // kinematics
    Mu.p4 = mu.p4();
 
    Mu.selectors = mu.selectors();
    Mu.Q = mu.charge();
 
    // tracking properties
    Mu.Dxy = mu.dB(pat::Muon::PV2D);
    Mu.Dz  = mu.dB(pat::Muon::PVDZ);
    if (mu.innerTrack().isNonnull())
        Mu.nTkHits = mu.innerTrack()->hitPattern().trackerLayersWithMeasurement();
 
    return Mu;
}

GetRecPhoton()

DAS::RecPhoton GetRecPhoton

(

const pat::Photon &

photon

)

Helper to get DAS::RecLep from MiniAOD.

{
    DAS::RecPhoton dasPhoton;
 
    // kinematics
    dasPhoton.p4 = photon.p4();
 
    if (photon.hasUserFloat("ecalEnergyPostCorr")) {
        // Only for MiniAODv2 (Run 2). In Run 3 we need to use correctionlib.
        const auto raw_energy = dasPhoton.p4.E();
        dasPhoton.scales = decltype(dasPhoton.scales){{
            photon.userFloat("ecalEnergyPostCorr") / raw_energy,
            photon.userFloat("energyScaleUp")      / raw_energy,
            photon.userFloat("energyScaleDown")    / raw_energy,
            photon.userFloat("energySigmaPhiUp")   / raw_energy,
            photon.userFloat("energySigmaPhiDown") / raw_energy,
            photon.userFloat("energySigmaRhoUp")   / raw_energy,
            photon.userFloat("energySigmaRhoDown") / raw_energy,
        }};
        dasPhoton.ecalEnergyErrPostCorr = photon.userFloat("ecalEnergyErrPostCorr");
    }
 
    // supercluster
    dasPhoton.r9 = photon.full5x5_r9();
    dasPhoton.scEta = photon.superCluster()->eta();
    dasPhoton.sigmaIEtaIEta = photon.full5x5_sigmaIetaIeta();
    dasPhoton.seedCrystalGain =
        photon.hasUserFloat("seedGain") ? photon.userInt("seedGain") : -1;
 
    // ID
    dasPhoton.hOverE = photon.hadronicOverEm();
 
    if (photon.photonID("cutBasedPhotonID-Fall17-94X-V2-loose"))
        dasPhoton.selectors |= DAS::RecPhoton::CutBasedLoose;
    if (photon.photonID("cutBasedPhotonID-Fall17-94X-V2-medium"))
        dasPhoton.selectors |= DAS::RecPhoton::CutBasedMedium;
    if (photon.photonID("cutBasedPhotonID-Fall17-94X-V2-tight"))
        dasPhoton.selectors |= DAS::RecPhoton::CutBasedTight;
    if (photon.photonID("mvaPhoID-RunIIFall17-v2-wp80"))
        dasPhoton.selectors |= DAS::RecPhoton::MVAWorkingPoint80;
    if (photon.photonID("mvaPhoID-RunIIFall17-v2-wp90"))
        dasPhoton.selectors |= DAS::RecPhoton::MVAWorkingPoint90;
    if (photon.passElectronVeto())
        dasPhoton.selectors |= DAS::RecPhoton::ConversionSafeElectronVeto;
    if (!photon.hasPixelSeed())
        dasPhoton.selectors |= DAS::RecPhoton::PixelSeedVeto;
 
    // Isolation
    dasPhoton.chargedIsolation       = photon.chargedHadronIso();
    dasPhoton.neutralHadronIsolation = photon.neutralHadronIso();
    dasPhoton.photonIsolation        = photon.photonIso();
    dasPhoton.worstChargedIsolation  = photon.chargedHadronWorstVtxIso();
 
    return dasPhoton;
}

GetScaleVariations()

vector< string > GetScaleVariations	(	const tinyxml2::XMLDocument &	doc,
		const std::string &	scaleChoice
	)		const

Extracts only the envelope scale variations (skipping nominal, off‐diagonals and placeholder scales) from the "Central scale variation" <weightgroup>, honoring the same dyn_scale_choice filter you use in CollectWeightIds.

Parameters

doc	The XMLDocument containing <weightgroup> elements.
scaleChoice	The substring to match in the <weight> text, e.g. "HT/2".

Returns

A vector of variation names in the order they appear.

{
    const double nominal = 1.0;
    vector<string> variations;
 
    // Exactly like CollectWeightIds: look for name="Central scale variation"
    for (auto* wg = doc.FirstChildElement("weightgroup");
         wg;
         wg = wg->NextSiblingElement("weightgroup"))
    {
        const char* nameC = wg->Attribute("name");
        if (!nameC) 
            continue;
 
        if (string{nameC} != "Central scale variation")
            continue;
 
        // Within that group, filter on dyn_scale_choice just as you do for IDs
        for (auto* w = wg->FirstChildElement("weight");
             w;
             w = w->NextSiblingElement("weight"))
        {
            const char* txt = w->GetText();
            std::regex pat("dyn_scale_choice=" + scaleChoice + "(\\s|$)");
            if (!txt || !std::regex_search(txt, pat))
                continue;
 
            // parse static MUF/MUR
            double muf = stod(w->Attribute("MUF"));
            double mur = stod(w->Attribute("MUR"));
 
            // skip off-diagonals: one > nominal, one < nominal
            if ((muf > nominal && mur < nominal) ||
                (muf < nominal && mur > nominal))
            {
                continue;
            }
 
            // skip the central nominal point
            if (muf == nominal && mur == nominal)
                continue;
 
            // build exactly the same variation names you want:
            if (muf == nominal) {
                variations.emplace_back(
                    mur > nominal
                    ? "RenormalisationScaleUp"
                    : "RenormalisationScaleDown"
                );
            }
            else if (mur == nominal) {
                variations.emplace_back(
                    muf > nominal
                    ? "FactorisationScaleUp"
                    : "FactorisationScaleDown"
                );
            }
            else {
                // both varied → only keep diagonal
                if (muf > nominal && mur > nominal)
                    variations.emplace_back("BothScaleUp");
                else if (muf < nominal && mur < nominal)
                    variations.emplace_back("BothScaleDown");
            }
        }
 
        // once we've processed the "Central scale variation" group, no need
        // to look at any further weightgroup elements:
        break;
    }
 
    if (variations.empty()) {
        throw cms::Exception("Ntupliser") << "No valid envelope variations found for scale choice: " << scaleChoice;
    }
 
    return variations;
}

JetID()

bool JetID

(

const pat::Jet &

jet

)

Testing tight ID lepton veto definition for jets (official from JetMET)

The values for Run 2 correspond to UL and are not expected to change. Instead, the values for Run 3 are only preliminary and are subject to changes.

Note

The formulae in blue from the original TWiki have been copied and their format adapted.

{
    const auto eta = jet.eta();
 
    auto NHF  = jet.neutralHadronEnergyFraction();
    auto NEMF = jet.photonEnergyFraction();
    auto MUF  = jet.muonEnergyFraction();
    auto NumConst = jet.neutralMultiplicity() + jet.chargedMultiplicity();
 
    auto CHF  = jet.chargedHadronEnergyFraction();
    auto CHM  = jet.chargedHadronMultiplicity();
    auto CEMF = jet.chargedEmEnergyFraction();
 
    auto NumNeutralParticle = jet.neutralMultiplicity();
 
    switch (p.year) {
        case 2016:
            return (abs(eta)<=2.4 && CEMF<0.8 && CHM>0 && CHF>0 && NumConst>1 && NEMF<0.9 && MUF <0.8 && NHF < 0.9)
                || (p.CHS && abs(eta)>2.4 && abs(eta)<=2.7 && NEMF<0.99 && NHF < 0.9)
                || (p.CHS && NEMF>0.0 && NEMF<0.99 && NHF<0.9 && NumNeutralParticle>1 && abs(eta)>2.7 && abs(eta)<=3.0)
                || (p.CHS && NEMF<0.90 && NHF>0.2 && NumNeutralParticle>10 && abs(eta)>3.0)
                || (p.PUPPI && abs(eta)>2.4 && abs(eta)<=2.7 && NEMF<0.99 && NHF < 0.98)
                || (p.PUPPI && NumNeutralParticle>=1 && abs(eta)>2.7 && abs(eta)<=3.0)
                || (p.PUPPI && NEMF<0.90 && NumNeutralParticle>2 && abs(eta)>3.0);
 
        case 2017:
        case 2018:
            return (abs(eta)<=2.6 && CEMF<0.8 && CHM>0 && CHF>0 && NumConst>1 && NEMF<0.9 && MUF <0.8 && NHF < 0.9)
                || (p.CHS && abs(eta)>2.6 && abs(eta)<=2.7 && CEMF<0.8 && CHM>0 && NEMF<0.99 && MUF <0.8 && NHF < 0.9)
                || (p.CHS && NEMF>0.01 && NEMF<0.99 && NumNeutralParticle>1 && abs(eta)>2.7 && abs(eta)<=3.0)
                || (p.CHS && NEMF<0.90 && NHF>0.2 && NumNeutralParticle>10 && abs(eta)>3.0)
                || (p.PUPPI && abs(eta)>2.6 && abs(eta)<=2.7 && CEMF<0.8 && NEMF<0.99 && MUF <0.8 && NHF < 0.9)
                || (p.PUPPI && NHF<0.9999 && abs(eta)>2.7 && abs(eta)<=3.0)
                || (p.PUPPI && NEMF<0.90 && NumNeutralParticle>2 && abs(eta)>3.0);
        case 2022:
        case 2023:
        case 2024:
            return (abs(eta)<=2.6 && CEMF<0.8 && CHM>0 && CHF>0.01 && NumConst>1 && NEMF<0.9 && MUF <0.8 && NHF < 0.99)
                || (p.PUPPI && abs(eta)>2.6 && abs(eta)<=2.7 && CEMF<0.8 && NEMF<0.99 && MUF <0.8 && NHF < 0.9)
                || (p.PUPPI && NHF<0.99 && abs(eta)>2.7 && abs(eta)<=3.0)
                || (p.PUPPI &&NEMF<0.40 && NumNeutralParticle>=2 && abs(eta)>3.0)
                || (p.CHS && abs(eta)>2.6 && abs(eta)<=2.7 && CEMF<0.8 && CHM>0 && NEMF<0.99 && MUF <0.8 && NHF < 0.9)
                || (p.CHS && NEMF<0.99 && NHF<0.99 && NumNeutralParticle>1 && abs(eta)>2.7 && abs(eta)<=3.0)
                || (p.CHS && NEMF<0.40 && NumNeutralParticle>10 && abs(eta)>3.0);
        default:
            auto err_msg = "\x1B[31m\x1B[1mThe JetID has not yet been imlemented in DAS for "s
                                           + to_string(p.year) + "\x1B[0m"s;
            throw cms::Exception("Ntupliser") << err_msg;
    }
}

Member Data Documentation

p

DAS::Parameters& p

---

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

• /builds/cms-analysis/general/DasAnalysisSystem/Core/Installer/Core/Ntupliser/plugins/helper.h
• /builds/cms-analysis/general/DasAnalysisSystem/Core/Installer/Core/Ntupliser/plugins/helper.cc