Ntupliser

#include <Ntupliser.h>

Inheritance diagram for Ntupliser:

Collaboration diagram for Ntupliser:

Public Types
typedef reco::Particle::LorentzVector	LorentzVector

Public Member Functions
	Ntupliser (edm::ParameterSet const &cfg)
virtual void	beginJob () override
virtual void	analyze (edm::Event const &iEvent, edm::EventSetup const &iSetup) override
virtual void	endJob () override
virtual void	beginRun (edm::Run const &iRun, edm::EventSetup const &) override
virtual void	endRun (edm::Run const &iRun, edm::EventSetup const &) override
virtual	~Ntupliser () override

Private Member Functions
void	reset ()
void	initialise (edm::Event const &iEvent)
bool	trigger (edm::Event const &iEvent)
void	fillMET (edm::Event const &iEvent)
void	getHLTjets (edm::Event const &iEvent)
template<typename MyJetCollection >
void	getGenJets (edm::Handle< MyJetCollection > &mygenjets)
void	getRecJets ()
void	getGenMuons ()
void	getRecMuons ()
void	getGenPhotons ()
void	getRecPhotons ()
void	getSecVertices ()
void	getEventVariables (edm::Event const &iEvent)
void	getGenEventWeights ()

Private Attributes
DAS::Parameters	p
DAS::Helper	h
edm::Handle< reco::GenJetCollection >	genjets
edm::Handle< pat::JetCollection >	recjets
edm::Handle< edm::View< reco::Candidate > >	genLeptons
edm::Handle< pat::MuonCollection >	recmuons
edm::Handle< pat::PhotonCollection >	recphotons
edm::Handle< pat::METCollection >	met
edm::Handle< double >	rho
edm::Handle< reco::VertexCollection >	recVtxs
edm::Handle< edm::TriggerResults >	triggerResults
edm::Handle< edm::TriggerResults >	metResults
edm::Handle< pat::PackedTriggerPrescales >	triggerPrescales
edm::Handle< pat::PackedTriggerPrescales >	triggerPrescalesl1min
edm::Handle< pat::PackedTriggerPrescales >	triggerPrescalesl1max
edm::Handle< pat::TriggerObjectStandAloneCollection >	triggerObjects
edm::Handle< GenEventInfoProduct >	genEvtInfo
edm::Handle< reco::GenParticleCollection >	genParticles
edm::Handle< reco::JetFlavourInfoMatchingCollection >	theJetFlavourInfos
edm::Handle< std::vector< reco::VertexCompositePtrCandidate > >	SVs
edm::Handle< std::vector< PileupSummaryInfo > >	pileupInfo
edm::Handle< LHEEventProduct >	lheEvent
edm::Service< TFileService >	fs_
TTree *	tree
Darwin::Tools::UserInfo	metainfo
std::vector< DAS::RecJet > *	recJets_
std::vector< DAS::FourVector > *	HLTjets_
std::vector< DAS::GenJet > *	genJets_
std::vector< DAS::RecMuon > *	recMuons_
std::vector< DAS::GenMuon > *	genMuons_
std::vector< DAS::RecPhoton > *	recPhotons_
std::vector< DAS::GenPhoton > *	genPhotons_
DAS::Trigger *	jetTrigger_
DAS::Trigger *	muonTrigger_
DAS::Trigger *	zbTrigger_
DAS::GenEvent *	genEvent_
DAS::RecEvent *	recEvent_
DAS::MET *	met_
DAS::PileUp *	pileup_
DAS::PrimaryVertex *	primaryvertex_
std::vector< DAS::PrimaryVertex > *	recPVs_
std::vector< DAS::PrimaryVertex > *	genPVs_
boost::property_tree::ptree	pileup_json
std::vector< std::string >	genweight_ids

Member Typedef Documentation

LorentzVector

typedef reco::Particle::LorentzVector LorentzVector

Constructor & Destructor Documentation

Ntupliser()

Ntupliser ( edm::ParameterSet const &  cfg )

explicit

Constructor, only initialising the members.

    :
    p(cfg, consumesCollector()), h(p),
    tree(fs_->make<TTree>("events","events")),
    metainfo(tree, p.config),
    // jets
    recJets_(p.jets               ? new vector<DAS::RecJet>     : nullptr),
    HLTjets_(p.jets && p.triggers ? new vector<DAS::FourVector> : nullptr),
    genJets_(p.jets && p.isMC     ? new vector<DAS::GenJet>     : nullptr),
    // muons
    recMuons_(           p.muons ? new vector<DAS::RecMuon> : nullptr),
    genMuons_(p.isMC  && p.muons ? new vector<DAS::GenMuon> : nullptr),
    // photons
    recPhotons_(           p.photons ? new vector<DAS::RecPhoton> : nullptr),
    genPhotons_(p.isMC  && p.photons ? new vector<DAS::GenPhoton> : nullptr),
    // event variables
    jetTrigger_    (p.triggers ? new DAS::Trigger : nullptr),
    muonTrigger_   (p.triggers ? new DAS::Trigger : nullptr),
    zbTrigger_     (p.triggers ? new DAS::Trigger : nullptr),
    genEvent_      (p.isMC ? new DAS::GenEvent : nullptr),
    recEvent_      (         new DAS::RecEvent          ),
    met_           (new DAS::MET          ),
    pileup_        (new DAS::PileUp       ),
    primaryvertex_ (new DAS::PrimaryVertex), 
    recPVs_         (new vector<DAS::PrimaryVertex>),
    genPVs_         (new vector<DAS::PrimaryVertex>)
{
    cout << __FILE__ << ':' << __func__ << endl;
 
    using namespace DAS;
 
    if (p.photons) // photon variations
    for (TString source: RecPhoton::uncs) {
        metainfo.Set<TString>("variations", RecPhoton::ScaleVar, source + SysDown);
        metainfo.Set<TString>("variations", RecPhoton::ScaleVar, source + SysUp);
    }
}
catch (boost::exception& e) {
    throw cms::Exception("Ntupliser") << boost::diagnostic_information(e);
}

~Ntupliser()

~Ntupliser ( )

overridevirtual

{
    cout << __FILE__ << ':' << __func__ << endl;
}

Member Function Documentation

analyze()

void analyze ( edm::Event const &  iEvent, edm::EventSetup const &  iSetup  )

overridevirtual

{
    // reset and initialise member variables (filled to the tree)
    reset();
    initialise(iEvent);
 
    // check trigger
    if (p.triggers) {
        bool passTrigger = trigger(iEvent);
        if (!p.isMC && !passTrigger) return;
        if (p.jets)
            getHLTjets(iEvent); //Fill High-Level-Trigger jets
    }
    fillMET(iEvent);
 
    // event variables
    getEventVariables(iEvent);
    if (p.isMC)
        getGenEventWeights();
 
    // jet variables
    if (p.jets) {
        getRecJets();
        if (p.isMC) {
            if (p.flavour)
                getGenJets(theJetFlavourInfos);
            else
                getGenJets(genjets);
        }
    }
 
    // muon variables
    if (p.muons) {
        getRecMuons();
        if (p.isMC)
            getGenMuons();
    }
 
    // photon variables
    if (p.photons) {
        getRecPhotons();
        if (p.isMC)
            getGenPhotons();
    }
 
    tree->Fill();
}

beginJob()

void beginJob ( )

overridevirtual

Called before looping over the events.

Basically, it set up the branches.

{
    cout << __FILE__ << ':' << __func__ << endl;
 
    if (!p.isMC) {
        const auto luminosity = p.config.get_child_optional("luminosity");
        if (luminosity && luminosity->count("pileup")) {
            auto pileup = luminosity->get<fs::path>("pileup");
            cout << "Extracting pileup normalisation from " << pileup << endl;
            if (p.sandbox) pileup = pileup.filename();
            if (!fs::exists(pileup))
                throw cms::Exception("Ntupliser") << pileup << " could not be found";
            pt::read_json(pileup.string(), pileup_json);
        }
        else cout << "\x1B[33mNo input pileup normalisation\x1B[0m" << endl;
    }
 
    // event
    if (p.isMC)
        tree->Branch("genEvent",&genEvent_);
    tree->Branch("recEvent",&recEvent_);
    if (p.triggers) {
        tree->Branch("jetTrigger",&jetTrigger_);
        tree->Branch("muonTrigger",&muonTrigger_);
        tree->Branch("zbTrigger",&zbTrigger_);
    }
 
    tree->Branch("pileup",&pileup_);
    tree->Branch("primaryvertex",&primaryvertex_);
    tree->Branch("recPVs",&recPVs_);
    tree->Branch("genPVs",&genPVs_);
    tree->Branch("met",&met_);
 
    // jets
    if (p.jets) {
        tree->Branch("recJets",&recJets_);
        if (p.triggers)
            tree->Branch("hltJets", &HLTjets_);
        if (p.isMC)
            tree->Branch("genJets", &genJets_);
    }
 
    // muons
    if (p.muons) {
        tree->Branch("recMuons",&recMuons_);
        if (p.isMC)
            tree->Branch("genMuons", &genMuons_);
    }
 
    // photons
    if (p.photons) {
        tree->Branch("recPhotons", &recPhotons_);
        if (p.isMC)
            tree->Branch("genPhotons", &genPhotons_);
    }
}

beginRun()

void beginRun ( edm::Run const &  iRun, edm::EventSetup const &    )

overridevirtual

{ 
    cout <<  __FILE__ << ':' <<  __func__ << endl;
 
    if (!p.genWgts)
        return;
 
    // The usual way would be to use a token, but apparently,
    // it does not work in `beginRun` (whereas it would in `endRun`).
    //iRun.getByToken(p.lheRunInfoToken, lheRunInfo);
    edm::Handle<LHERunInfoProduct> lheRunInfo;
    iRun.getByLabel(p.lheLabel, lheRunInfo);
 
    // Extract the XML fragment starting at <weightgroup> from the LHE headers
    string xmlText = h.BufferWeightGroupXML(*lheRunInfo);
 
    // If we never saw "<weightgroup", bail out
    if (xmlText.empty())
        throw cms::Exception("Ntupliser") << "<weightgroup> tag not found in headers";
 
    // Parse the buffered XML directly
    tinyxml2::XMLDocument doc;
    tinyxml2::XMLError err = doc.Parse(xmlText.c_str());
    if (err != tinyxml2::XML_SUCCESS) 
        throw cms::Exception("Ntupliser") << "XML parse error: " << doc.ErrorStr();
 
    // Scan the XML document and fill scale_ids/pdf_ids based on scaleChoice and PDF group
    genweight_ids = h.CollectWeightIds(doc, p.scale_choice_, p.pdf_);
 
    // Scale variations (skip if empty)
    if (!p.scale_choice_.empty()) {
        const auto scale_variations = h.GetScaleVariations(doc, p.scale_choice_);
        for (const auto& name : scale_variations) {
            metainfo.Set<int>("variations", DAS::GenEvent::WeightVar, name.c_str(), 1);
        }
    }
 
    // PDF variations (skip if empty)
    if (!p.pdf_.empty()) {
        const auto pdfCount = h.CountPDFWeights(doc, p.pdf_);
          metainfo.Set<int>("variations", DAS::GenEvent::WeightVar, p.pdf_.c_str(), pdfCount);
    }
}

endJob()

void endJob ( )

overridevirtual

{
    cout << __FILE__ << ':' << __func__ << endl;
    metainfo.Set<bool>("git", "complete", true);
}

endRun()

void endRun ( edm::Run const &  iRun, edm::EventSetup const &    )

overridevirtual

{
    cout <<  __FILE__ << ':' <<  __func__ << endl;
}

fillMET()

void fillMET ( edm::Event const &  iEvent )

private

Fill the MET flags to the array.

{
    const edm::TriggerNames &namesMet = iEvent.triggerNames(*metResults);
    for(unsigned int k=0; k < p.metNames_.size(); ++k) {
        bool bit(false);
        for(unsigned int itrig=0; itrig<metResults->size(); ++itrig) {
            string met_name = string(namesMet.triggerName(itrig));
            if (met_name == p.metNames_[k]) {
                bit = metResults->accept(itrig);
                break;
            }
        }
        met_->Bit.push_back(bit);
    }
}

getEventVariables()

void getEventVariables ( edm::Event const &  iEvent )

private

Gets information about the event (run number, etc.), the pile-up, the MET and the primary vertex.

Todo:

check out-of-time pileup

Todo:

compare to (*met)[0].pt() to (*met)[0].uncorPt()

{
    // event
    recEvent_->runNo = iEvent.id().run(); // note: always 1 for MC
    recEvent_->evtNo = iEvent.id().event();
    recEvent_->lumi = iEvent.id().luminosityBlock();
 
    recEvent_->weights.resize(1);
    recEvent_->weights.front() = 1;
 
    // pile-up
    // https://cmsdoxygen.web.cern.ch/cmsdoxygen/CMSSW_12_4_0/doc/html/d9/d53/classPileupSummaryInfo.html
    pileup_->rho  = *rho;
    pileup_->nVtx = recVtxs->size();
    if (p.isMC)
    for(const auto& PUI: *pileupInfo) {
        if (PUI.getBunchCrossing() != 0) continue; 
 
        // for pile-up profile correction
        // Adapted from [TWiki](https://twiki.cern.ch/twiki/bin/viewauth/CMS/PileupJSONFileforData):
        // In order to do reasonable comparisons between data and MC, it is necessary to understand exactly what the histogram produced by pileupCalc.py means so that it can be compared with the correct quantity in MC.
        // The way that pileup events are generated in MC, given an input pileup distribution, is as follows:
        pileup_->trpu = PUI.getTrueNumInteractions(); // average pileup conditions under which the event is generated
        pileup_->intpu = PUI.getPU_NumInteractions(); // the number of pileup events for the in-time bunch crossing is selected from a Poisson distribution with a mean equal to the "true" pileup
 
        // for pile-up staub cleaning
        pileup_->pthats = PUI.getPU_pT_hats();
 
        const vector<edm::EventID>& evtIDs = PUI.getPU_EventID();
        for (const auto& evtID: evtIDs)
            pileup_->MBevents.push_back(evtID.event());
    }
    else if (pileup_json.size() > 0) {
        auto runNo = to_string(iEvent.id().run());
        auto run = pileup_json.get_child_optional(runNo);
        if (!run)
            throw cms::Exception("Ntupliser") << runNo << " could not be found in the pileup latest file";
        for (auto& LS: *run) {
            auto it = LS.second.begin();  // ["LS", "inst lumi", "xsec RMS", "av xsec"]
            auto LSno = it->second.get_value<unsigned int>(); // LS
            if (LSno != iEvent.id().luminosityBlock()) continue;
            ++it; //auto instLumi = it->second.get_value<float>(); // inst lumi
            ++it; //auto xsecRMS = it->second.get_value<float>(); // xsec RMS
            ++it; auto avXsec = it->second.get_value<float>(); // av xsec
            pileup_->trpu = avXsec * DAS::PileUp::MBxsec;
            break;
        }
    }
 
    // primary vertex
    const auto& PV = (*recVtxs)[0];
    primaryvertex_->Rho  = PV.position().Rho();
    primaryvertex_->z    = PV.z();
    primaryvertex_->ndof     = PV.ndof();
    primaryvertex_->chi2     = PV.chi2();
    primaryvertex_->fake     = PV.isFake();
    for (const auto& PV: *recVtxs){
        recPVs_->emplace_back(PV.position().Rho(), PV.z(), PV.chi2(), PV.ndof(), PV.isFake());
    }
    if (p.isMC) {
        const auto& gv = (*genParticles)[0].daughter(0)->vertex();
        genPVs_->emplace_back(gv.Rho(), gv.z(), 0, 0, false);
    }
 
    // MET
    met_->Et = (*met)[0].et();
    met_->SumEt = (*met)[0].sumEt();
    met_->Pt = (*met)[0].pt(); 
    met_->Phi = (*met)[0].phi();
    // https://twiki.cern.ch/twiki/bin/viewauth/CMS/MissingETRun2Corrections#Type_I_Correction_Propagation_of
    // https://twiki.cern.ch/twiki/bin/view/CMS/MissingETUncertaintyPrescription
}

getGenEventWeights()

void getGenEventWeights ( )

private

Get gen-level event weights.

{
    genEvent_->hard_scale = genEvtInfo->qScale();
 
    // Always store the dataset nominal weight first
    const double w0 = genEvtInfo->weight();
    genEvent_->weights.clear();
    genEvent_->weights.emplace_back(DAS::Weight{w0, 0});
 
    // Only proceed if LHE/gen weights are requested
    if (!p.genWgts)
        return;
 
    // LHE model variations
    const auto& wgt_infos  = lheEvent->weights();
    const auto& nominal_id = genweight_ids.front(); // assumed nominal
 
    // Find nominal LHE weight; throw if not found
    const auto itNom = find_if(
        wgt_infos.begin(), wgt_infos.end(),
        [&](const gen::WeightsInfo& wi){ return wi.id == nominal_id; }
        );
 
    if (itNom == wgt_infos.end())
        throw cms::Exception("Ntupliser") << "Nominal LHE weight id '" << nominal_id << "' not found in LHE weights.";
 
    const double wN = itNom->wgt;
    // Keep your is-normal check semantics
    if (!isnormal(wN))
        throw cms::Exception("Ntupliser") << "Nominal LHE weight is zero or non-finite (wN=" << wN << ").";
 
    // Ratio of dataset nominal to LHE nominal (kept as you wrote)
    const double relNomWgt = w0 / wN;
 
    // Push each selected LHE variation, but NEVER push the LHE nominal
    for (const auto& wi : wgt_infos) {
        // hard guard: skip LHE nominal unconditionally
        if (wi.id == nominal_id)
            continue;
 
        // keep only ids we care about
        if (find(genweight_ids.begin(), genweight_ids.end(), wi.id) == genweight_ids.end())
            continue;
 
        const double abs_weight = wi.wgt * relNomWgt;
        genEvent_->weights.emplace_back(DAS::Weight{abs_weight, 0});
    }
}

getGenJets()

void getGenJets ( edm::Handle< MyJetCollection > &  mygenjets )

private

Finds the reconstructed jets, and applies some hard cuts on the phase space.

MyJetCollection is expected to be either JetCollection or JetFlavourInfoMatchingCollection (according to the flavour flag)

Todo:

externalize option for phase space cut

Note

slimmedJets are only defined from 10 GeV

{
    //for ((typename MyJetCollection)::const_iterator itJet = mygenjets->begin();
    for (auto itJet = mygenjets->begin();
            itJet != mygenjets->end(); ++itJet) {
 
        // we convert the complicated CMSSW object to our simple DAS object
        DAS::GenJet genjet = h.GetGenJet(*itJet);
 
        // we keep only jet with pt > 20 GeV and in the tracker acceptance
        //if (genjet.p4.Pt() < 10 /* GeV */ || abs(genjet.p4.Eta()) > 5.0) continue;
 
        genJets_->push_back(genjet);
    }
 
    Sort<DAS::GenJet>(genJets_);
}

getGenMuons()

void getGenMuons ( )

private

Finds the generated muons, and applies some hard cuts on the phase space.

{
    for (const reco::Candidate &lepton: *genLeptons) {
        if (abs(lepton.pdgId()) != 13) continue;
 
        // we convert the complicated CMSSW object to our simple DAS object
        DAS::GenMuon genmu = h.GetGenMu(lepton);
 
        // we keep only get with pt > 15 GeV and |eta| < 3.0 (to have a margin
        // w.r.t. tracker acceptance and treat migrations)
        if (genmu.p4.Pt() < 10 /* GeV */ || abs(genmu.p4.Eta()) > 3.0) continue;
 
        genMuons_->push_back(genmu);
    }
 
    Sort<DAS::GenMuon>(genMuons_);
}

getGenPhotons()

void getGenPhotons ( )

private

Finds the generated photons and applies some hard cuts to the phase space.

{
    // Collect charged leptons that would be dressed
    vector<const reco::GenParticle *> charged_leptons;
    for (const reco::GenParticle &gp: *genParticles) {
        auto id = abs(gp.pdgId());
        if (gp.status() == 1 && (id == 11 || id == 13))
            charged_leptons.push_back(&gp);
    }
 
    for (const reco::GenParticle &gp: *genParticles) {
        // Consider stable (status 1) photons
        if (gp.status() != 1 || gp.pdgId() != 22) continue;
 
        // Phase space cuts
        const bool zAncestor = hasZAncestor(gp);
        if (zAncestor && gp.pt() < 1) continue;
        if (!zAncestor && (gp.pt() < 10 || abs(gp.eta()) > 3.0)) continue;
 
        // We store dressed leptons. Remove any photon falling within the
        // dressing cones, since we'd have no way of removing them afterwards.
        if (any_of(charged_leptons.begin(), charged_leptons.end(),
                   [gp](auto lep) { return reco::deltaR(lep->p4(), gp.p4()) < 0.1; }))
            continue;
 
        genPhotons_->push_back(h.GetGenPhoton(gp, zAncestor));
    }
 
    Sort<DAS::GenPhoton>(genPhotons_);
}

getHLTjets()

void getHLTjets ( edm::Event const &  iEvent )

private

Finds HLT jets and simply stores them in a FourVector.

{
    const auto &names = iEvent.triggerNames(*triggerResults);
 
    // loop over all possible triggers and only keep object from the PFJet
    // triggers
    for (pat::TriggerObjectStandAlone obj: *triggerObjects){
        obj.unpackPathNames(names);
        //vector<string> pathNamesAll  = obj.pathNames(false);
        vector<string> pathNamesLast = obj.pathNames(true);
 
        // first, look if the HLT object is a HLT jet
        bool isHLTjet = false;
        string sNow;
        for (auto s: pathNamesLast) {
            s = DelLastDigits(s); // remove the version of the trigger (i.e. HLT_PFJetXX_v*)
            if (p.HLTjet_triggerNames.count(s) == 0) continue; // typically ignore mu triggers
            isHLTjet = true;
            sNow = s;
            break;
        }
 
        // then add it unless it has already been added
        if(isHLTjet) {
            DAS::FourVector P4(obj.pt(), obj.eta(), obj.phi(), obj.mass());
            bool isIn = false;
            for(const auto &v : *HLTjets_)
                if(v == P4) {isIn = true; break;}
            if(!isIn)
                HLTjets_->push_back(P4);
        }
    }
 
    Sort<DAS::FourVector>(HLTjets_);
}

getRecJets()

void getRecJets ( )

private

Finds the reconstructed jets, and applies some hard cuts on the phase space.

Todo:

externalize option for phase space cut

{
    for(pat::JetCollection::const_iterator itJet = recjets->begin();
            itJet != recjets->end(); ++itJet) {
 
        // we convert the complicated CMSSW object to our simple DAS object
        DAS::RecJet recjet = h.GetRecJet(*itJet);
 
        // we keep all jets and give set the weight to 0 for jets not fullfiling the quality criterion
        if (!h.JetID(*itJet)) recjet.weights.front() = 0.;
 
        // we keep only jet with pt > 20 GeV and in the tracker acceptance
        //if (recjet.p4.Pt() < 10 /* GeV */ || abs(recjet.p4.Eta()) > 5.0) continue;
        // (note: slimmedJets are only defined from 10 GeV)
 
        recJets_->push_back(recjet);
    }
 
    Sort<DAS::RecJet>(recJets_);
}

getRecMuons()

void getRecMuons ( )

private

Finds the reconstructed muons, and applies some hard cuts on the phase space.

{
    for(pat::MuonCollection::const_iterator itMu = recmuons->begin();
            itMu != recmuons->end(); ++itMu) {
 
        // we convert the complicated CMSSW object to our simple DAS object
        DAS::RecMuon recmu = h.GetRecMu(*itMu);
 
        // we keep only muons with pt > 10 GeV and in the muon chamber acceptance
        if (recmu.p4.Pt() < 10 /* GeV */ || abs(recmu.p4.Eta()) > 2.4) continue;
 
        recMuons_->push_back(recmu);
    }
 
    Sort<DAS::RecMuon>(recMuons_);
}

getRecPhotons()

void getRecPhotons ( )

private

Finds the reconstructed photons, and applies some hard cuts on the phase space.

{
    for (pat::PhotonCollection::const_iterator it = recphotons->begin();
         it != recphotons->end(); ++it) {
 
        // we convert the complicated CMSSW object to our simple DAS object
        DAS::RecPhoton recphoton = h.GetRecPhoton(*it);
 
        // we keep only photons with pt > 5 GeV
        if (recphoton.p4.Pt() < 5 /* GeV */) continue;
 
        recPhotons_->push_back(recphoton);
    }
 
    Sort<DAS::RecPhoton>(recPhotons_);
}

getSecVertices()

void getSecVertices ( )

private

initialise()

void initialise ( edm::Event const &  iEvent )

private

Called at the beginning of each new event.

{
    // jets
    if (p.isMC) {
        iEvent.getByToken(p.lheEventToken, lheEvent);
        iEvent.getByToken(p.genEvtInfoToken, genEvtInfo);
        if (p.jets) {
            iEvent.getByToken(p.genjetsToken, genjets);
            if (p.flavour)
                iEvent.getByToken(p.jetFlavourInfosToken, theJetFlavourInfos );
        }
        iEvent.getByToken(p.genParticlesToken, genParticles);
    }
    if (p.jets)
        iEvent.getByToken(p.recjetsToken, recjets);
 
    // muons
    if (p.muons) {
        if (p.isMC)
            iEvent.getByToken(p.genLeptonsToken, genLeptons);
        iEvent.getByToken(p.recmuonsToken, recmuons);
    }
 
    // photons
    if (p.photons)
        iEvent.getByToken(p.recphotonsToken, recphotons);
 
    // pile-up
    if (p.isMC)
        iEvent.getByToken(p.pileupInfoToken, pileupInfo);
    iEvent.getByToken(p.rhoToken,rho);
 
    // vertex
    iEvent.getByToken(p.recVtxsToken,recVtxs);
 
    // trigger
    if (p.triggers) {
        iEvent.getByToken(p.triggerResultsToken, triggerResults);
        iEvent.getByToken(p.triggerObjectsToken, triggerObjects);
 
        // HLT
        iEvent.getByToken(p.triggerPrescalesToken,triggerPrescales);
 
        // L1
        iEvent.getByToken(p.triggerPrescalesl1minToken, triggerPrescalesl1min);
        iEvent.getByToken(p.triggerPrescalesl1maxToken, triggerPrescalesl1max);
    }
 
    // MET
    iEvent.getByToken(p.metToken,met);
    iEvent.getByToken(p.metResultsToken, metResults);
}

reset()

void reset ( )

private

Just a common method to reset all branches at each new event.

{
    if (p.isMC)
        genEvent_->clear();
    recEvent_->clear();
 
    if (p.triggers) {
        jetTrigger_->clear();
        muonTrigger_->clear();
        zbTrigger_->clear();
    }
    pileup_->clear();
    primaryvertex_->clear();
    recPVs_->clear();
    genPVs_->clear();
    met_->clear();
 
    if (p.jets) {
        if (p.isMC)
            genJets_->clear();
        if (p.triggers)
            HLTjets_->clear();
        recJets_->clear();
    }
 
    if (p.muons) {
        recMuons_->clear();
        if (p.isMC)
            genMuons_->clear();
    }
 
    if (p.photons) {
        recPhotons_->clear();
        if (genPhotons_)
            genPhotons_->clear();
    }
}

trigger()

bool trigger ( edm::Event const &  iEvent )

private

Finds the bits corresponding to the HLT jet pt triggers.

{
    const auto &names = iEvent.triggerNames(*triggerResults);
 
    bool passTrigger(false);
    for (unsigned int k = 0; k < p.triggerNames_.size(); ++k) {
        bool bit(false);
        int preHLT(1), preL1min(1), preL1max(1);
        string name;
 
        for (unsigned int itrig = 0; itrig < triggerResults->size(); ++itrig) {
            name = names.triggerName(itrig);
 
            //--- erase the the version number----
            name = DelLastDigits(name);
            if (name != p.triggerNames_[k]) continue;
 
            bit = triggerResults->accept(itrig);
            // indirect way of testing the CMSSW version is to check the GCC version
#if __GNUC__ < 12 // Run 2 (CMSSW_12, GCC 10)
            preHLT = triggerPrescales->getPrescaleForIndex(itrig);
            preL1min = triggerPrescalesl1min->getPrescaleForIndex(itrig);
            preL1max = triggerPrescalesl1max->getPrescaleForIndex(itrig);
#else // Run 3 (CMSSW_13, GCC 12)
            preHLT = triggerPrescales->getPrescaleForIndex<double>(itrig);
            preL1min = triggerPrescalesl1min->getPrescaleForIndex<double>(itrig);
            preL1max = triggerPrescalesl1max->getPrescaleForIndex<double>(itrig);
#endif
            break;
        }
        if (name == "HLTriggerFinalPath"){
            string triggermenu;
            for (unsigned int itrig = 0; itrig < triggerResults->size(); ++itrig) triggermenu += names.triggerName(itrig) + " ";
            throw cms::Exception("Ntupliser") << p.triggerNames_[k] << " could not be found in the trigger menu:\n" << triggermenu;
        }  
        //--- if at least one monitored trigger has fired passTrigger becomes true
        passTrigger += bit;
 
        // Identify trigger collection
        regex jetTriggerpattern("HLT_(AK4|AK8|HI|HIAK4|HIAK8|Di)?PFJet");
        regex muonTriggerpattern("HLT_(Mu|HIMu|IsoMu|TkMu)");
        regex zbTriggerpattern("HLT_ZeroBias");
        // example for Run18A (both low & high pt jets)
        // HLT_PFJet40_v    153 153
        // HLT_PFJet60_v    154 154
        // HLT_PFJet80_v    155 155
        // HLT_PFJet140_v   156 156
        // HLT_PFJet200_v   157 157
        // HLT_PFJet260_v   158 158
        // HLT_PFJet320_v   159 159
        // HLT_PFJet400_v   160 160
        // HLT_PFJet450_v   161 161
        // HLT_PFJet500_v   162 162
        // HLT_PFJet550_v   163 163
        if (regex_search(name, jetTriggerpattern)) {
            jetTrigger_->Bit.push_back(bit);
            jetTrigger_->PreHLT.push_back(preHLT);
            jetTrigger_->PreL1min.push_back(preL1min);
            jetTrigger_->PreL1max.push_back(preL1max);
        }
        // HLT_IsoMu24_eta2p1_v
        // HLT_IsoMu24_v
        // HLT_IsoMu27_v
        // HLT_IsoMu30_v
        // HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_v
        // HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_v
        // HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_DZ_v
        // HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_v
        else if (regex_search(name, muonTriggerpattern)) {
            muonTrigger_->Bit.push_back(bit);
            muonTrigger_->PreHLT.push_back(preHLT);
            muonTrigger_->PreL1min.push_back(preL1min);
            muonTrigger_->PreL1max.push_back(preL1max);
        }
        else if (regex_search(name, zbTriggerpattern)) {
            zbTrigger_->Bit.push_back(bit);
            zbTrigger_->PreHLT.push_back(preHLT);
            zbTrigger_->PreL1min.push_back(preL1min);
            zbTrigger_->PreL1max.push_back(preL1max);
        }
        else throw cms::Exception("Ntupliser") << "No dedicated collection in the n-tupliser exists for " << name;
    }
    return passTrigger;
}

Member Data Documentation

fs_

edm::Service<TFileService> fs_

private

genEvent_

DAS::GenEvent* genEvent_

private

genEvtInfo

edm::Handle<GenEventInfoProduct> genEvtInfo

private

genjets

edm::Handle<reco::GenJetCollection> genjets

private

genJets_

std::vector<DAS::GenJet>* genJets_

private

genLeptons

edm::Handle<edm::View<reco::Candidate> > genLeptons

private

genMuons_

std::vector<DAS::GenMuon>* genMuons_

private

genParticles

edm::Handle<reco::GenParticleCollection> genParticles

private

genPhotons_

std::vector<DAS::GenPhoton>* genPhotons_

private

genPVs_

std::vector<DAS::PrimaryVertex>* genPVs_

private

genweight_ids

std::vector<std::string> genweight_ids

private

h

DAS::Helper h

private

HLTjets_

std::vector<DAS::FourVector>* HLTjets_

private

jetTrigger_

DAS::Trigger* jetTrigger_

private

lheEvent

edm::Handle<LHEEventProduct> lheEvent

private

met

edm::Handle<pat::METCollection> met

private

met_

DAS::MET* met_

private

metainfo

Darwin::Tools::UserInfo metainfo

private

metResults

edm::Handle<edm::TriggerResults> metResults

private

muonTrigger_

DAS::Trigger * muonTrigger_

private

p

DAS::Parameters p

private

pileup_

DAS::PileUp* pileup_

private

pileup_json

boost::property_tree::ptree pileup_json

private

pileup "latest"

pileupInfo

edm::Handle<std::vector<PileupSummaryInfo> > pileupInfo

private

primaryvertex_

DAS::PrimaryVertex* primaryvertex_

private

recEvent_

DAS::RecEvent* recEvent_

private

recjets

edm::Handle<pat::JetCollection> recjets

private

recJets_

std::vector<DAS::RecJet>* recJets_

private

recmuons

edm::Handle<pat::MuonCollection> recmuons

private

recMuons_

std::vector<DAS::RecMuon>* recMuons_

private

recphotons

edm::Handle<pat::PhotonCollection> recphotons

private

recPhotons_

std::vector<DAS::RecPhoton>* recPhotons_

private

recPVs_

std::vector<DAS::PrimaryVertex>* recPVs_

private

recVtxs

edm::Handle<reco::VertexCollection> recVtxs

private

rho

edm::Handle<double> rho

private

SVs

edm::Handle<std::vector<reco::VertexCompositePtrCandidate> > SVs

private

theJetFlavourInfos

edm::Handle<reco::JetFlavourInfoMatchingCollection> theJetFlavourInfos

private

tree

TTree* tree

private

triggerObjects

edm::Handle<pat::TriggerObjectStandAloneCollection> triggerObjects

private

triggerPrescales

edm::Handle<pat::PackedTriggerPrescales> triggerPrescales

private

triggerPrescalesl1max

edm::Handle<pat::PackedTriggerPrescales> triggerPrescalesl1max

private

triggerPrescalesl1min

edm::Handle<pat::PackedTriggerPrescales> triggerPrescalesl1min

private

triggerResults

edm::Handle<edm::TriggerResults> triggerResults

private

zbTrigger_

DAS::Trigger * zbTrigger_

private

---

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

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