From 1f37c7c3a8d56edd3d4bd3188eed58e612b9e940 Mon Sep 17 00:00:00 2001 From: Dylan Date: Wed, 20 Oct 2021 07:45:51 -0500 Subject: [PATCH 1/7] first version P2L1 DQM --- .../python/DQMOffline_SecondStep_cff.py | 4 + .../Configuration/python/DQMOffline_cff.py | 2 + DQMOffline/Configuration/python/autoDQM.py | 6 +- DQMOffline/L1Trigger/BuildFile.xml | 2 + .../interface/L1TPhase2CorrelatorOffline.h | 348 +++++++ .../interface/L1TPhase2OTTrackJetsandMHT.h | 93 ++ .../L1Trigger/python/L1TPhase2Offline_cfi.py | 140 +++ .../L1TriggerDqmOffline_SecondStep_cff.py | 5 + .../python/L1TriggerDqmOffline_cff.py | 37 + .../src/L1TPhase2CorrelatorOffline.cc | 971 ++++++++++++++++++ .../src/L1TPhase2OTTrackJetsandMHT.cc | 259 +++++ 11 files changed, 1866 insertions(+), 1 deletion(-) create mode 100644 DQMOffline/L1Trigger/interface/L1TPhase2CorrelatorOffline.h create mode 100644 DQMOffline/L1Trigger/interface/L1TPhase2OTTrackJetsandMHT.h create mode 100644 DQMOffline/L1Trigger/python/L1TPhase2Offline_cfi.py create mode 100644 DQMOffline/L1Trigger/src/L1TPhase2CorrelatorOffline.cc create mode 100644 DQMOffline/L1Trigger/src/L1TPhase2OTTrackJetsandMHT.cc diff --git a/DQMOffline/Configuration/python/DQMOffline_SecondStep_cff.py b/DQMOffline/Configuration/python/DQMOffline_SecondStep_cff.py index 29bf311c474d4..f16d0889589ce 100644 --- a/DQMOffline/Configuration/python/DQMOffline_SecondStep_cff.py +++ b/DQMOffline/Configuration/python/DQMOffline_SecondStep_cff.py @@ -43,6 +43,8 @@ DQMOffline_SecondStepL1T = cms.Sequence( l1TriggerDqmOfflineClient ) +DQMOffline_SecondStepL1TPhase2 = cms.Sequence( Phase2l1TriggerDqmOfflineClient ) + DQMOffline_SecondStep_PreDPG = cms.Sequence( DQMOffline_SecondStepEcal * DQMOffline_SecondStepTrackerStrip * @@ -145,6 +147,8 @@ DQMHarvestL1TMuon = cms.Sequence( l1TriggerMuonDqmOfflineClient ) +DQMHarvestL1TPhase2 = cms.Sequence( Phase2l1TriggerDqmOfflineClient ) + DQMHarvestCommon = cms.Sequence( DQMMessageLoggerClientSeq * DQMHarvestTrackerStrip * DQMHarvestTrack * diff --git a/DQMOffline/Configuration/python/DQMOffline_cff.py b/DQMOffline/Configuration/python/DQMOffline_cff.py index ac28700d4eaf4..70c2b24d6202c 100644 --- a/DQMOffline/Configuration/python/DQMOffline_cff.py +++ b/DQMOffline/Configuration/python/DQMOffline_cff.py @@ -34,6 +34,8 @@ DQMOfflineL1TMuon = cms.Sequence( l1TriggerMuonDqmOffline ) +DQMOfflineL1TPhase2 = cms.Sequence( Phase2l1TriggerDqmOffline ) + #DPGs DQMOfflineEcalOnly = cms.Sequence( ecalOnly_dqm_source_offline + diff --git a/DQMOffline/Configuration/python/autoDQM.py b/DQMOffline/Configuration/python/autoDQM.py index fd3af6eb6b4d4..8e67c9ca5922f 100644 --- a/DQMOffline/Configuration/python/autoDQM.py +++ b/DQMOffline/Configuration/python/autoDQM.py @@ -150,6 +150,10 @@ 'PostDQMOffline', 'DQMHarvestL1TMuon'], + 'L1TMonPhase2': ['DQMOfflineL1TPhase2', + 'PostDQMOffline', + 'DQMHarvestL1TPhase2'], + 'HLTMon': ['HLTMonitoring', 'PostDQMOffline', 'HLTMonitoringClient'], @@ -229,7 +233,7 @@ 'DQMNone'], } -_phase2_allowed = ['trackingOnlyDQM','outerTracker', 'trackerPhase2', 'muon','hcal','hcal2','egamma'] +_phase2_allowed = ['trackingOnlyDQM','outerTracker', 'trackerPhase2', 'muon','hcal','hcal2','egamma','L1TMonPhase2'] autoDQM['phase2'] = ['','',''] for i in [0,2]: autoDQM['phase2'][i] = '+'.join([autoDQM[m][i] for m in _phase2_allowed]) diff --git a/DQMOffline/L1Trigger/BuildFile.xml b/DQMOffline/L1Trigger/BuildFile.xml index 70b7e5b1fc211..ff1e4a7e7d51e 100644 --- a/DQMOffline/L1Trigger/BuildFile.xml +++ b/DQMOffline/L1Trigger/BuildFile.xml @@ -10,6 +10,8 @@ + + diff --git a/DQMOffline/L1Trigger/interface/L1TPhase2CorrelatorOffline.h b/DQMOffline/L1Trigger/interface/L1TPhase2CorrelatorOffline.h new file mode 100644 index 0000000000000..6e52e7ac10ef5 --- /dev/null +++ b/DQMOffline/L1Trigger/interface/L1TPhase2CorrelatorOffline.h @@ -0,0 +1,348 @@ +#ifndef DQMOFFLINE_L1TRIGGER_L1TPHASE2CORRELATOROFFLINE_H +#define DQMOFFLINE_L1TRIGGER_L1TPHASE2CORRELATOROFFLINE_H + +// DataFormats +#include "DataFormats/Common/interface/View.h" +#include "DataFormats/Candidate/interface/Candidate.h" +#include "DataFormats/HepMCCandidate/interface/GenParticle.h" +#include "DataFormats/JetReco/interface/GenJet.h" +#include "DataFormats/Math/interface/deltaR.h" +#include "DataFormats/L1TParticleFlow/interface/PFCandidate.h" + +// FWCore +#include "FWCore/Common/interface/Provenance.h" +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Framework/interface/ESHandle.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/LuminosityBlock.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/Framework/interface/ConsumesCollector.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "FWCore/ServiceRegistry/interface/Service.h" + +// DQMServices +#include "DQMServices/Core/interface/DQMOneEDAnalyzer.h" +#include "DQMServices/Core/interface/DQMStore.h" +#include "DQMOffline/L1Trigger/interface/HistDefinition.h" + +// MagneticField +#include "MagneticField/Engine/interface/MagneticField.h" +#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h" + +// HLTrigger +#include "HLTrigger/HLTcore/interface/HLTConfigProvider.h" + +// L1Trigger +#include "L1Trigger/Phase2L1ParticleFlow/interface/L1TPFUtils.h" + +// CommonTools +#include "CommonTools/Utils/interface/StringCutObjectSelector.h" + +#include +#include +#include +#include +#include +#include +#include + +class L1TPhase2CorrelatorOffline : public DQMOneEDAnalyzer<> { +public: + L1TPhase2CorrelatorOffline(const edm::ParameterSet& ps); + ~L1TPhase2CorrelatorOffline() override; + + enum PlotConfig { resVsPt, resVsEta, ptDist, etaDist }; + + static const std::map PlotConfigNames; + +protected: + void dqmBeginRun(const edm::Run& run, const edm::EventSetup& iSetup) override; + void bookHistograms(DQMStore::IBooker&, edm::Run const&, edm::EventSetup const&) override; + void analyze(edm::Event const& e, edm::EventSetup const& eSetup) override; + void dqmEndRun(const edm::Run& run, const edm::EventSetup& iSetup) override; + + // Cut and Matching + +private: + void bookPhase2CorrelatorHistos(DQMStore::IBooker&); + + // other functions + double Distance(const reco::Candidate& c1, const reco::Candidate& c2); + double DistancePhi(const reco::Candidate& c1, const reco::Candidate& c2); + double calcDeltaPhi(double phi1, double phi2); + + void computeResponseResolution(); + + void medianResponseCorrResolution(MonitorElement* in2D, MonitorElement* response, MonitorElement* resolution); + void medianResponse(MonitorElement* in2D, MonitorElement* response); + + struct SimpleObject { + float pt, eta, phi; + SimpleObject(float apt, float aneta, float aphi) : pt(apt), eta(aneta), phi(aphi) {} + bool operator<(const SimpleObject& other) const { return eta < other.eta; } + bool operator<(const float& other) const { return eta < other; } + }; + class MultiCollection { + public: + MultiCollection(const edm::ParameterSet& iConfig, const std::string& name, edm::ConsumesCollector&& coll) + : name_(name), prop_(false), sel_("") { + if (name.find("Ecal") != std::string::npos) + prop_ = true; + else if (name.find("Hcal") != std::string::npos) + prop_ = true; + else if (name.find("Calo") != std::string::npos) + prop_ = true; + const std::vector& tags = iConfig.getParameter>(name); + for (const auto& tag : tags) + tokens_.push_back(coll.consumes(tag)); + if (iConfig.existsAs(name + "_sel")) { + sel_ = StringCutObjectSelector(iConfig.getParameter(name + "_sel"), true); + } + } + const std::string& name() const { return name_; } + bool prop() const { return prop_; } + void get(const edm::Event& iEvent) { + edm::Handle handle; + for (const auto& token : tokens_) { + iEvent.getByToken(token, handle); + for (const reco::Candidate& c : *handle) { + if (sel_(c)) + objects_.emplace_back(c.pt(), c.eta(), c.phi()); + } + } + std::sort(objects_.begin(), objects_.end()); + } + const std::vector& objects() const { return objects_; } + void clear() { objects_.clear(); } + + private: + std::string name_; + bool prop_; + std::vector> tokens_; + StringCutObjectSelector sel_; + std::vector objects_; + }; + class InCone { + public: + InCone(const std::vector& objects, float eta, float phi, float dr) { + auto first = + std::lower_bound(objects.begin(), objects.end(), eta - dr - 0.01f); // small offset to avoid dealing with == + auto end = std::lower_bound(objects.begin(), objects.end(), eta + dr + 0.01f); + float dr2 = dr * dr; + sum04_ = 0; + for (auto it = first; it < end; ++it) { + float mydr2 = ::deltaR2(eta, phi, it->eta, it->phi); + if (mydr2 < dr2) + ptdr2_.emplace_back(it->pt, mydr2); + if (mydr2 < 0.16f) + sum04_ += it->pt; + } + } + float sum(float dr = 0.4) const { + if (dr == 0.4f) + return sum04_; + float dr2 = dr * dr; + float mysum = 0; + for (const auto& part : ptdr2_) { + if (part.second < dr2) + mysum += part.first; + } + return mysum; + } + int number(float dr, float threshold) const { + float dr2 = dr * dr, absthreshold = sum() * threshold; + int mysum = 0; + for (const auto& part : ptdr2_) { + if (part.second < dr2 && part.first > absthreshold) + mysum++; + } + return mysum; + } + float mindr(float threshold) const { + float best = 9999, absthreshold = sum() * threshold; + for (const auto& part : ptdr2_) { + if (part.second < best && part.first > absthreshold) + best = part.second; + } + return std::sqrt(best); + } + float nearest() const { + std::pair best(0, 9999); + for (const auto& part : ptdr2_) { + if (part.second < best.second) + best = part; + } + return best.first; + } + float max(float dr = 0.4) const { + float best = 0, dr2 = dr * dr; + for (const auto& part : ptdr2_) { + if (part.first > best && part.second < dr2) + best = part.first; + } + return best; + } + + private: + std::vector> ptdr2_; + float sum04_; + }; + + // variables from config file + edm::EDGetTokenT> genJetToken_; + edm::EDGetTokenT> genParticleToken_; + edm::ParameterSet objs_; + bool isParticleGun_; + std::string histFolder_; + std::string respresolFolder_; + dqmoffline::l1t::HistDefinitions histDefinitions_; + + std::vector>> phase2PFToken_; + std::vector>> phase2PuppiToken_; + + // config params + struct McVars { + float pt, pt02, eta, phi, iso02, iso04, iso08; + int charge; + float caloeta, calophi; + int id; + void fillP4(const reco::Candidate& cand) { + pt = cand.pt(); + eta = cand.eta(); + phi = cand.phi(); + caloeta = eta; + calophi = phi; + charge = 0; + } + void fillPropagated(const reco::Candidate& cand, float bz) { + if (cand.charge() != 0) { + math::XYZTLorentzVector vertex(cand.vx(), cand.vy(), cand.vz(), 0.); + auto caloetaphi = l1tpf::propagateToCalo(cand.p4(), vertex, cand.charge(), bz); + caloeta = caloetaphi.first; + calophi = caloetaphi.second; + } + } + + } mc_; + struct RecoVars { + float pt, pt02, pt08, ptbest, pthighest, mindr025; + int n025, n010; + void fill(const std::vector& objects, float eta, float phi) { + InCone incone(objects, eta, phi, 0.8); + pt = incone.sum(); + pt02 = incone.sum(0.2); + pt08 = incone.sum(0.8); + ptbest = incone.nearest(); + pthighest = incone.max(); + mindr025 = incone.mindr(0.25); + n025 = incone.number(0.2, 0.25); + n010 = incone.number(0.2, 0.10); + } + void clear() { + pt = 0.; + pt02 = 0.; + pt08 = 0.; + ptbest = 0.; + pthighest = 0.; + mindr025 = 0.; + n025 = -1; + n010 = -1; + } + }; + std::vector> reco_; + float bZ_; + + // Histograms + MonitorElement* h_L1PF_pt_; + MonitorElement* h_L1PF_eta_; + MonitorElement* h_L1Puppi_pt_; + MonitorElement* h_L1Puppi_eta_; + + MonitorElement* h_L1PF_pt_mu_; + MonitorElement* h_L1PF_eta_mu_; + MonitorElement* h_L1Puppi_pt_mu_; + MonitorElement* h_L1Puppi_eta_mu_; + + MonitorElement* h_L1PF_pt_el_; + MonitorElement* h_L1PF_eta_el_; + MonitorElement* h_L1Puppi_pt_el_; + MonitorElement* h_L1Puppi_eta_el_; + + MonitorElement* h_L1PF_pt_pho_; + MonitorElement* h_L1PF_eta_pho_; + MonitorElement* h_L1Puppi_pt_pho_; + MonitorElement* h_L1Puppi_eta_pho_; + + MonitorElement* h_L1PF_pt_ch_; + MonitorElement* h_L1PF_eta_ch_; + MonitorElement* h_L1Puppi_pt_ch_; + MonitorElement* h_L1Puppi_eta_ch_; + + MonitorElement* h_L1PF_pt_nh_; + MonitorElement* h_L1PF_eta_nh_; + MonitorElement* h_L1Puppi_pt_nh_; + MonitorElement* h_L1Puppi_eta_nh_; + + MonitorElement* h_L1PF_part_ptratio_0p2_vs_pt_barrel_; + MonitorElement* h_L1PF_part_ptratio_0p2_vs_pt_endcap_; + MonitorElement* h_L1PF_part_ptratio_0p2_vs_pt_ecnotk_; + MonitorElement* h_L1PF_part_ptratio_0p2_vs_pt_hf_; + MonitorElement* h_L1PF_part_ptratio_0p2_vs_eta_; + MonitorElement* h_L1Puppi_part_ptratio_0p2_vs_pt_barrel_; + MonitorElement* h_L1Puppi_part_ptratio_0p2_vs_pt_endcap_; + MonitorElement* h_L1Puppi_part_ptratio_0p2_vs_pt_ecnotk_; + MonitorElement* h_L1Puppi_part_ptratio_0p2_vs_pt_hf_; + MonitorElement* h_L1Puppi_part_ptratio_0p2_vs_eta_; + MonitorElement* h_L1PF_jet_ptratio_vs_pt_barrel_; + MonitorElement* h_L1PF_jet_ptratio_vs_pt_endcap_; + MonitorElement* h_L1PF_jet_ptratio_vs_pt_ecnotk_; + MonitorElement* h_L1PF_jet_ptratio_vs_pt_hf_; + MonitorElement* h_L1PF_jet_ptratio_vs_eta_; + MonitorElement* h_L1Puppi_jet_ptratio_vs_pt_barrel_; + MonitorElement* h_L1Puppi_jet_ptratio_vs_pt_endcap_; + MonitorElement* h_L1Puppi_jet_ptratio_vs_pt_ecnotk_; + MonitorElement* h_L1Puppi_jet_ptratio_vs_pt_hf_; + MonitorElement* h_L1Puppi_jet_ptratio_vs_eta_; + + MonitorElement* h_L1PF_part_response_0p2_pt_barrel_; + MonitorElement* h_L1PF_part_response_0p2_pt_endcap_; + MonitorElement* h_L1PF_part_response_0p2_pt_ecnotk_; + MonitorElement* h_L1PF_part_response_0p2_pt_hf_; + MonitorElement* h_L1PF_part_response_0p2_eta_; + MonitorElement* h_L1Puppi_part_response_0p2_pt_barrel_; + MonitorElement* h_L1Puppi_part_response_0p2_pt_endcap_; + MonitorElement* h_L1Puppi_part_response_0p2_pt_ecnotk_; + MonitorElement* h_L1Puppi_part_response_0p2_pt_hf_; + MonitorElement* h_L1Puppi_part_response_0p2_eta_; + MonitorElement* h_L1PF_jet_response_pt_barrel_; + MonitorElement* h_L1PF_jet_response_pt_endcap_; + MonitorElement* h_L1PF_jet_response_pt_ecnotk_; + MonitorElement* h_L1PF_jet_response_pt_hf_; + MonitorElement* h_L1PF_jet_response_eta_; + MonitorElement* h_L1Puppi_jet_response_pt_barrel_; + MonitorElement* h_L1Puppi_jet_response_pt_endcap_; + MonitorElement* h_L1Puppi_jet_response_pt_ecnotk_; + MonitorElement* h_L1Puppi_jet_response_pt_hf_; + MonitorElement* h_L1Puppi_jet_response_eta_; + + MonitorElement* h_L1PF_part_resolution_0p2_pt_barrel_; + MonitorElement* h_L1PF_part_resolution_0p2_pt_endcap_; + MonitorElement* h_L1PF_part_resolution_0p2_pt_ecnotk_; + MonitorElement* h_L1PF_part_resolution_0p2_pt_hf_; + MonitorElement* h_L1Puppi_part_resolution_0p2_pt_barrel_; + MonitorElement* h_L1Puppi_part_resolution_0p2_pt_endcap_; + MonitorElement* h_L1Puppi_part_resolution_0p2_pt_ecnotk_; + MonitorElement* h_L1Puppi_part_resolution_0p2_pt_hf_; + MonitorElement* h_L1PF_jet_resolution_pt_barrel_; + MonitorElement* h_L1PF_jet_resolution_pt_endcap_; + MonitorElement* h_L1PF_jet_resolution_pt_ecnotk_; + MonitorElement* h_L1PF_jet_resolution_pt_hf_; + MonitorElement* h_L1Puppi_jet_resolution_pt_barrel_; + MonitorElement* h_L1Puppi_jet_resolution_pt_endcap_; + MonitorElement* h_L1Puppi_jet_resolution_pt_ecnotk_; + MonitorElement* h_L1Puppi_jet_resolution_pt_hf_; +}; + +#endif diff --git a/DQMOffline/L1Trigger/interface/L1TPhase2OTTrackJetsandMHT.h b/DQMOffline/L1Trigger/interface/L1TPhase2OTTrackJetsandMHT.h new file mode 100644 index 0000000000000..6f451f2b80fd2 --- /dev/null +++ b/DQMOffline/L1Trigger/interface/L1TPhase2OTTrackJetsandMHT.h @@ -0,0 +1,93 @@ +#ifndef L1TPhase2_OTTrackJetsandMHT_h +#define L1TPhase2_OTTrackJetsandMHT_h + +#include +#include +#include +#include "FWCore/Utilities/interface/EDGetToken.h" +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "DQMServices/Core/interface/MonitorElement.h" +#include "DQMServices/Core/interface/DQMEDAnalyzer.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/Framework/interface/ESHandle.h" +#include "DataFormats/Common/interface/DetSetVectorNew.h" +#include "DataFormats/L1TrackTrigger/interface/TTTypes.h" +// #include "DataFormats/L1TVertex/interface/Vertex.h" +#include "DataFormats/L1TCorrelator/interface/TkPrimaryVertex.h" + +#include "DataFormats/L1TCorrelator/interface/TkJet.h" +#include "DataFormats/L1TCorrelator/interface/TkJetFwd.h" +#include "DataFormats/L1TCorrelator/interface/TkHTMiss.h" +#include "DataFormats/L1TCorrelator/interface/TkHTMissFwd.h" + + + +class DQMStore; + +class L1TPhase2OTTrackJetsandMHT : public DQMEDAnalyzer { + +public: + explicit L1TPhase2OTTrackJetsandMHT(const edm::ParameterSet&); + ~L1TPhase2OTTrackJetsandMHT() override; + void analyze(const edm::Event&, const edm::EventSetup&) override; + void bookHistograms(DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override; + + //All track jets + MonitorElement* allJets_pt = nullptr; // pt of jet + MonitorElement* allJets_eta = nullptr; // eta of jet + MonitorElement* allJets_phi = nullptr; // phi of jet + MonitorElement* allJets_vtx = nullptr; // vtx of jet + MonitorElement* allJets_nTracks = nullptr; // num of tracks that went into jet + MonitorElement* allJets_nTightTracks = nullptr; // num of tight tracks that went into jet + MonitorElement* allJets_nDisplacedTracks = nullptr; // num of displaced tracks that went into jet + MonitorElement* allJets_nTightDispTracks = nullptr; // num of tight displaced tracks that went into jet + + // m_2ltrkjet_vz->push_back(jetIter->jetVtx()); + // m_2ltrkjet_ntracks->push_back(jetIter->ntracks()); + // m_2ltrkjet_phi->push_back(jetIter->phi()); + // m_2ltrkjet_eta->push_back(jetIter->eta()); + // m_2ltrkjet_pt->push_back(jetIter->pt()); + // m_2ltrkjet_p->push_back(jetIter->p()); + // m_2ltrkjet_nDisplaced->push_back(jetIter->nDisptracks()); + // m_2ltrkjet_nTight->push_back(jetIter->nTighttracks()); + // m_2ltrkjet_nTightDisplaced->push_back(jetIter->nTightDisptracks()); + + + //Jets used in HT and MHT (pT, eta, and NTracks cuts) + MonitorElement* HTJets_pt = nullptr; // pt of jet + MonitorElement* HTJets_eta = nullptr; // eta of jet + MonitorElement* HTJets_phi = nullptr; // phi of jet + MonitorElement* HTJets_vtx = nullptr; // vtx of jet + MonitorElement* HTJets_nTracks = nullptr; // num of tracks that went into jet + MonitorElement* HTJets_nTightTracks = nullptr; // num of tight tracks that went into jet + MonitorElement* HTJets_nDisplacedTracks = nullptr; // num of displaced tracks that went into jet + MonitorElement* HTJets_nTightDispTracks = nullptr; // num of tight displaced tracks that went into jet + + //MHT + MonitorElement* h_MHT = nullptr; // MHT of event from track jets + + //HT + MonitorElement* h_HT = nullptr; // HT of event from track jets + + + private: + edm::ParameterSet conf_; + + float jet_minPt; // [GeV] + float jet_maxEta; // [rad] + //const edm::EDGetTokenT< L1TkPrimaryVertexCollection > pvToken; + edm::EDGetTokenT< l1t::TkJetCollection > jetToken; + + //const edm::EDGetTokenT< std::vector< l1t::L1TkJetParticle > > jetToken; + + + unsigned int minNtracksHighPt; + unsigned int minNtracksLowPt; + + + std::string topFolderName_; +}; +#endif diff --git a/DQMOffline/L1Trigger/python/L1TPhase2Offline_cfi.py b/DQMOffline/L1Trigger/python/L1TPhase2Offline_cfi.py new file mode 100644 index 0000000000000..ea17998d17ee3 --- /dev/null +++ b/DQMOffline/L1Trigger/python/L1TPhase2Offline_cfi.py @@ -0,0 +1,140 @@ +import FWCore.ParameterSet.Config as cms +import math + +from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer + +OuterTrackerTkMET = DQMEDAnalyzer('L1TPhase2OuterTrackerTkMET', + TopFolderName = cms.string('L1T/L1TPhase2/'), + TTTracksTag = cms.InputTag("TTTracksFromTrackletEmulation", "Level1TTTracks"), + L1VertexInputTag = cms.InputTag("L1TkPrimaryVertex"), + maxZ0 = cms.double ( 15. ) , # in cm + maxEta = cms.double ( 2.4 ) , + chi2dofMax = cms.double( 10. ), + bendchi2Max = cms.double( 2.2 ), + minPt = cms.double( 2. ), # in GeV + DeltaZ = cms.double( 3. ), # in cm + nStubsmin = cms.int32( 4 ), # min number of stubs for the tracks to enter in TrkMET calculation + nStubsPSmin = cms.int32( -1 ), # min number of stubs in the PS Modules + maxPt = cms.double( -10. ), # in GeV. When maxPt > 0, tracks with PT above maxPt are considered as + # mismeasured and are treated according to HighPtTracks below. + # When maxPt < 0, no special treatment is done for high PT tracks. + HighPtTracks = cms.int32( 1 ), # when = 0 : truncation. Tracks with PT above maxPt are ignored + # when = 1 : saturation. Tracks with PT above maxPt are set to PT=maxPt. + # When maxPt < 0, no special treatment is done for high PT tracks. + +# Number of TTTracks + TH1_NTracks = cms.PSet( + Nbinsx = cms.int32(100), + xmax = cms.double(99.5), + xmin = cms.double(-0.5) + ), + +#Pt of the track + TH1_Track_Pt = cms.PSet( + Nbinsx = cms.int32(50), + xmax = cms.double(100), + xmin = cms.double(0) + ), + +#Eta of the track + TH1_Track_Eta = cms.PSet( + Nbinsx = cms.int32(45), + xmax = cms.double(3.0), + xmin = cms.double(-3.0) + ), + +#VtxZ of the track + TH1_Track_VtxZ = cms.PSet( + Nbinsx = cms.int32(51), + xmax = cms.double(25), + xmin = cms.double(-25) + ), + +#Nstubs of the track + TH1_Track_NStubs = cms.PSet( + Nbinsx = cms.int32(6), + xmax = cms.double(9), + xmin = cms.double(3) + ), + +#N PS stubs of the track + TH1_Track_NPSstubs = cms.PSet( + Nbinsx = cms.int32(6), + xmax = cms.double(7), + xmin = cms.double(1) + ), + +#Chi2dof of the track + TH1_Track_Chi2Dof = cms.PSet( + Nbinsx = cms.int32(100), + xmax = cms.double(50), + xmin = cms.double(0) + ), + +#Bendchi2 of the track + TH1_Track_BendChi2 = cms.PSet( + Nbinsx = cms.int32(30), + xmax = cms.double(50), + xmin = cms.double(0) + ), + +#tkMET distribution + TH1_Track_TkMET = cms.PSet( + Nbinsx = cms.int32(100), + xmax = cms.double(500), + xmin = cms.double(0) + ), +) + +l1tPhase2CorrelatorOfflineDQM = DQMEDAnalyzer( + "L1TPhase2CorrelatorOffline", + verbose = cms.untracked.bool(False), + genJetsInputTag = cms.untracked.InputTag("ak4GenJetsNoNu"), + genParticlesInputTag = cms.untracked.InputTag("genParticles"), + isParticleGun = cms.bool(False), + objects = cms.PSet( + L1PF = cms.VInputTag("l1pfCandidates:PF",), + L1PF_sel = cms.string("pt > 0"), + L1Puppi = cms.VInputTag("l1pfCandidates:Puppi",), + L1Puppi_sel = cms.string("pt > 0"), + ), + + histFolder = cms.string('L1T/L1TPhase2/Correlator/'), + + histDefinitions=cms.PSet( + resVsPt=cms.PSet( + name=cms.untracked.string("resVsPt"), + title=cms.untracked.string("resVsPt"), + nbinsX=cms.untracked.uint32(10), + xmin=cms.untracked.double(0.), + xmax=cms.untracked.double(100.), + ), + resVsEta=cms.PSet( + name=cms.untracked.string("resVsEta"), + title=cms.untracked.string("resVsEta"), + nbinsX=cms.untracked.uint32(20), + xmin=cms.untracked.double(-5.), + xmax=cms.untracked.double(5.), + ), + ptDist=cms.PSet( + name=cms.untracked.string("ptDist"), + title=cms.untracked.string("ptDist"), + nbinsX=cms.untracked.uint32(20), + xmin=cms.untracked.double(0.), + xmax=cms.untracked.double(100.), + ), + etaDist=cms.PSet( + name=cms.untracked.string("etaDist"), + title=cms.untracked.string("etaDist"), + nbinsX=cms.untracked.uint32(20), + xmin=cms.untracked.double(-5.), + xmax=cms.untracked.double(5.), + ), + ), + +) + +l1tPhase2OfflineDQM = cms.Sequence( + l1tPhase2CorrelatorOfflineDQM + + OuterTrackerTkMET + ) diff --git a/DQMOffline/L1Trigger/python/L1TriggerDqmOffline_SecondStep_cff.py b/DQMOffline/L1Trigger/python/L1TriggerDqmOffline_SecondStep_cff.py index 7cb0fa37cec2e..ec3c8ddf765a1 100644 --- a/DQMOffline/L1Trigger/python/L1TriggerDqmOffline_SecondStep_cff.py +++ b/DQMOffline/L1Trigger/python/L1TriggerDqmOffline_SecondStep_cff.py @@ -50,3 +50,8 @@ * l1tMuonDQMEmuEfficiency ) +# harvesting sequence for phase 2 +DQMHarvestL1TPhase2 = cms.Sequence( + +) + diff --git a/DQMOffline/L1Trigger/python/L1TriggerDqmOffline_cff.py b/DQMOffline/L1Trigger/python/L1TriggerDqmOffline_cff.py index fb79a5f898d9d..ae8e3923beddd 100644 --- a/DQMOffline/L1Trigger/python/L1TriggerDqmOffline_cff.py +++ b/DQMOffline/L1Trigger/python/L1TriggerDqmOffline_cff.py @@ -431,3 +431,40 @@ stage2L1Trigger.toReplaceWith(l1TriggerMuonDqmOfflineClient, Stage2l1tMuonDqmOfflineClient) stage2L1Trigger.toReplaceWith(l1TriggerDqmOfflineCosmics, Stage2l1TriggerDqmOffline) stage2L1Trigger.toReplaceWith(l1TriggerDqmOfflineCosmicsClient, Stage2l1TriggerDqmOfflineClient) + +############################################################################## +#phase2 +############################################################################## + +from Configuration.Eras.Modifier_phase2_trigger_cff import phase2_trigger + +# +# define sequences +# +from DQMOffline.L1Trigger.L1TPhase2Offline_cfi import * + +############################################################################## +# sequence to run for all datasets +Phase2l1TriggerOffline = cms.Sequence( + dqmEnvL1T + ) + +############################################################################## +# DQM sequences for step 1 + +# DQM Offline sequence +Phase2l1TriggerDqmOffline = cms.Sequence( + l1tPhase2OfflineDQM + ) + +############################################################################## +# DQM sequences for step 2 + +# DQM Offline sequence +Phase2l1TriggerDqmOfflineClient = cms.Sequence( + DQMHarvestL1TPhase2 + ) +#replacements for phase2 +phase2_trigger.toReplaceWith(l1TriggerOffline, Phase2l1TriggerOffline) +phase2_trigger.toReplaceWith(l1TriggerDqmOffline, Phase2l1TriggerDqmOffline) +phase2_trigger.toReplaceWith(l1TriggerDqmOfflineClient, Phase2l1TriggerDqmOfflineClient) diff --git a/DQMOffline/L1Trigger/src/L1TPhase2CorrelatorOffline.cc b/DQMOffline/L1Trigger/src/L1TPhase2CorrelatorOffline.cc new file mode 100644 index 0000000000000..7d3532146dc07 --- /dev/null +++ b/DQMOffline/L1Trigger/src/L1TPhase2CorrelatorOffline.cc @@ -0,0 +1,971 @@ +/** + * @file L1TPhase2CorrelatorOffline.cc + * @authors Dylan Rankin (MIT) + * @date 20/10/2020 + * @version 0.1 + * + */ + +#include "DQMOffline/L1Trigger/interface/L1TPhase2CorrelatorOffline.h" + +#include "TLorentzVector.h" +#include "TGraph.h" + +#include +#include +#include +#include +#include +#include + +using namespace reco; +using namespace trigger; +using namespace edm; +using namespace std; + +const std::map L1TPhase2CorrelatorOffline::PlotConfigNames = { + {"resVsPt", PlotConfig::resVsPt}, + {"resVsEta", PlotConfig::resVsEta}, + {"ptDist", PlotConfig::ptDist}, + {"etaDist", PlotConfig::etaDist}}; + +// +// -------------------------------------- Constructor -------------------------------------------- +// +L1TPhase2CorrelatorOffline::L1TPhase2CorrelatorOffline(const edm::ParameterSet& ps) : + genJetToken_(consumes>(ps.getUntrackedParameter("genJetsInputTag"))), + genParticleToken_( + consumes>(ps.getUntrackedParameter("genParticlesInputTag"))), + objs_(ps.getParameter("objects")), + isParticleGun_(ps.getParameter("isParticleGun")), + histFolder_(ps.getParameter("histFolder")), + respresolFolder_(histFolder_ + "/respresol_raw"), + histDefinitions_(dqmoffline::l1t::readHistDefinitions(ps.getParameterSet("histDefinitions"), PlotConfigNames)), + h_L1PF_pt_(), + h_L1PF_eta_(), + h_L1Puppi_pt_(), + h_L1Puppi_eta_(), + h_L1PF_pt_mu_(), + h_L1PF_eta_mu_(), + h_L1Puppi_pt_mu_(), + h_L1Puppi_eta_mu_(), + h_L1PF_pt_el_(), + h_L1PF_eta_el_(), + h_L1Puppi_pt_el_(), + h_L1Puppi_eta_el_(), + h_L1PF_pt_pho_(), + h_L1PF_eta_pho_(), + h_L1Puppi_pt_pho_(), + h_L1Puppi_eta_pho_(), + h_L1PF_pt_ch_(), + h_L1PF_eta_ch_(), + h_L1Puppi_pt_ch_(), + h_L1Puppi_eta_ch_(), + h_L1PF_pt_nh_(), + h_L1PF_eta_nh_(), + h_L1Puppi_pt_nh_(), + h_L1Puppi_eta_nh_(), + h_L1PF_part_ptratio_0p2_vs_pt_barrel_(), + h_L1PF_part_ptratio_0p2_vs_pt_endcap_(), + h_L1PF_part_ptratio_0p2_vs_pt_ecnotk_(), + h_L1PF_part_ptratio_0p2_vs_pt_hf_(), + h_L1PF_part_ptratio_0p2_vs_eta_(), + h_L1Puppi_part_ptratio_0p2_vs_pt_barrel_(), + h_L1Puppi_part_ptratio_0p2_vs_pt_endcap_(), + h_L1Puppi_part_ptratio_0p2_vs_pt_ecnotk_(), + h_L1Puppi_part_ptratio_0p2_vs_pt_hf_(), + h_L1Puppi_part_ptratio_0p2_vs_eta_(), + h_L1PF_jet_ptratio_vs_pt_barrel_(), + h_L1PF_jet_ptratio_vs_pt_endcap_(), + h_L1PF_jet_ptratio_vs_pt_ecnotk_(), + h_L1PF_jet_ptratio_vs_pt_hf_(), + h_L1PF_jet_ptratio_vs_eta_(), + h_L1Puppi_jet_ptratio_vs_pt_barrel_(), + h_L1Puppi_jet_ptratio_vs_pt_endcap_(), + h_L1Puppi_jet_ptratio_vs_pt_ecnotk_(), + h_L1Puppi_jet_ptratio_vs_pt_hf_(), + h_L1Puppi_jet_ptratio_vs_eta_() { + edm::LogInfo("L1TPhase2CorrelatorOffline") << "Constructor " + << "L1TPhase2CorrelatorOffline::L1TPhase2CorrelatorOffline " << std::endl; + + auto reconames = objs_.getParameterNamesForType>(); + for (const std::string& name : reconames) { + reco_.emplace_back(L1TPhase2CorrelatorOffline::MultiCollection(objs_, name, consumesCollector()), RecoVars()); + } + for (auto &obj : objs_.getParameter>("L1PF")) { + phase2PFToken_.push_back(consumes>(obj)); + } + for (auto &obj : objs_.getParameter>("L1Puppi")) { + phase2PuppiToken_.push_back(consumes>(obj)); + } +} + +// +// -- Destructor +// +L1TPhase2CorrelatorOffline::~L1TPhase2CorrelatorOffline() { + edm::LogInfo("L1TPhase2CorrelatorOffline") + << "Destructor L1TPhase2CorrelatorOffline::~L1TPhase2CorrelatorOffline " << std::endl; +} + +// +// -------------------------------------- beginRun -------------------------------------------- +// +void L1TPhase2CorrelatorOffline::dqmBeginRun(const edm::Run& run, const edm::EventSetup& iSetup) +{ + edm::LogInfo("L1TPhase2CorrelatorOffline") << "L1TPhase2CorrelatorOffline::beginRun" << std::endl; + + edm::ESHandle magneticField; + iSetup.get().get(magneticField); + bZ_ = magneticField->inTesla(GlobalPoint(0, 0, 0)).z(); +} + +// +// -------------------------------------- bookHistos -------------------------------------------- +// +void L1TPhase2CorrelatorOffline::bookHistograms(DQMStore::IBooker& ibooker, edm::Run const&, edm::EventSetup const&) { + edm::LogInfo("L1TPhase2CorrelatorOffline") << "L1TPhase2CorrelatorOffline::bookHistograms" << std::endl; + + // book at beginRun + bookPhase2CorrelatorHistos(ibooker); +} + +// +// -------------------------------------- Analyze -------------------------------------------- +// +void L1TPhase2CorrelatorOffline::analyze(edm::Event const& e, edm::EventSetup const& eSetup) { + edm::Handle> genjets; + edm::Handle> genparticles; + e.getByToken(genJetToken_, genjets); + e.getByToken(genParticleToken_, genparticles); + + std::vector prompts, taus; + for (const reco::GenParticle& gen : *genparticles) { + if (isParticleGun_) { + if (gen.statusFlags().isPrompt() == 1) + prompts.push_back(&gen); + continue; + } + if ((gen.isPromptFinalState() || gen.isDirectPromptTauDecayProductFinalState()) && + (std::abs(gen.pdgId()) == 11 || std::abs(gen.pdgId()) == 13) && gen.pt() > 5) { + prompts.push_back(&gen); + } else if (gen.isPromptFinalState() && std::abs(gen.pdgId()) == 22 && gen.pt() > 10) { + prompts.push_back(&gen); + } else if (abs(gen.pdgId()) == 15 && gen.isPromptDecayed()) { + taus.push_back(&gen); + } + } + + for (auto& recopair : reco_) { + recopair.first.get(e); + } + + for (const reco::GenJet& j1 : *genjets) { + bool ok = true; + const reco::Candidate* match = nullptr; + for (const reco::GenParticle* gp : prompts) { + if (::deltaR2(*gp, j1) < 0.16f) { + if (match != nullptr) { + ok = false; + break; + } else { + match = gp; + } + } + } + if (!ok) + continue; + if (!match) { + // look for a tau + for (const reco::GenParticle* gp : taus) { + if (::deltaR2(*gp, j1) < 0.16f) { + if (match != nullptr) { + ok = false; + break; + } else { + match = gp; + } + } + } + if (!ok) + continue; + if (match != nullptr && match->numberOfDaughters() == 2 && + std::abs(match->daughter(0)->pdgId()) + std::abs(match->daughter(1)->pdgId()) == 211 + 16) { + // one-prong tau, consider it a pion + match = (std::abs(match->daughter(0)->pdgId()) == 211 ? match->daughter(0) : match->daughter(1)); + } + } + if (match != nullptr) { + if (std::abs(match->pdgId()) == 15) { + reco::Particle::LorentzVector pvis; + for (unsigned int i = 0, n = match->numberOfDaughters(); i < n; ++i) { + const reco::Candidate* dau = match->daughter(i); + if (std::abs(dau->pdgId()) == 12 || std::abs(dau->pdgId()) == 14 || std::abs(dau->pdgId()) == 16) { + continue; + } + pvis += dau->p4(); + } + mc_.pt = pvis.Pt(); + mc_.eta = pvis.Eta(); + mc_.phi = pvis.Phi(); + } else { + mc_.fillP4(*match); + mc_.fillPropagated(*match, bZ_); + } + mc_.id = std::abs(match->pdgId()); + mc_.iso04 = j1.pt() / mc_.pt - 1; + mc_.iso02 = 0; + for (const auto& dptr : j1.daughterPtrVector()) { + if (::deltaR2(*dptr, *match) < 0.04f) { + mc_.iso02 += dptr->pt(); + } + } + mc_.iso02 = mc_.iso02 / mc_.pt - 1; + } else { + if (j1.pt() < 20) + continue; + mc_.fillP4(j1); + mc_.id = 0; + mc_.iso02 = 0; + mc_.iso04 = 0; + } + mc_.iso08 = mc_.iso04; + for (const reco::GenJet& j2 : *genjets) { + if (&j2 == &j1) + continue; + if (::deltaR2(j1, j2) < 0.64f) + mc_.iso08 += j2.pt() / mc_.pt; + } + for (auto& recopair : reco_) { + recopair.second.fill(recopair.first.objects(), + recopair.first.prop() ? mc_.caloeta : mc_.eta, + recopair.first.prop() ? mc_.calophi : mc_.phi); + + if (abs(mc_.id) != 0 && fabs(mc_.iso04) < 0.05) { + if (recopair.first.name() == "L1PF") { + if (fabs(mc_.eta) < 1.5) { + h_L1PF_part_ptratio_0p2_vs_pt_barrel_->Fill(mc_.pt, recopair.second.pt02 / mc_.pt); + } else if (fabs(mc_.eta) < 2.5) { + h_L1PF_part_ptratio_0p2_vs_pt_endcap_->Fill(mc_.pt, recopair.second.pt02 / mc_.pt); + } else if (fabs(mc_.eta) < 3.) { + h_L1PF_part_ptratio_0p2_vs_pt_ecnotk_->Fill(mc_.pt, recopair.second.pt02 / mc_.pt); + } else if (fabs(mc_.eta) < 5.) { + h_L1PF_part_ptratio_0p2_vs_pt_hf_->Fill(mc_.pt, recopair.second.pt02 / mc_.pt); + } + h_L1PF_part_ptratio_0p2_vs_eta_->Fill(mc_.eta, recopair.second.pt02 / mc_.pt); + } + if (recopair.first.name() == "L1Puppi") { + if (fabs(mc_.eta) < 1.5) { + h_L1Puppi_part_ptratio_0p2_vs_pt_barrel_->Fill(mc_.pt, recopair.second.pt02 / mc_.pt); + } else if (fabs(mc_.eta) < 2.5) { + h_L1Puppi_part_ptratio_0p2_vs_pt_endcap_->Fill(mc_.pt, recopair.second.pt02 / mc_.pt); + } else if (fabs(mc_.eta) < 3.) { + h_L1Puppi_part_ptratio_0p2_vs_pt_ecnotk_->Fill(mc_.pt, recopair.second.pt02 / mc_.pt); + } else if (fabs(mc_.eta) < 5.) { + h_L1Puppi_part_ptratio_0p2_vs_pt_hf_->Fill(mc_.pt, recopair.second.pt02 / mc_.pt); + } + h_L1Puppi_part_ptratio_0p2_vs_eta_->Fill(mc_.eta, recopair.second.pt02 / mc_.pt); + } + } + if (abs(mc_.id) == 0) { + if (recopair.first.name() == "L1PF") { + if (fabs(mc_.eta) < 1.5) { + h_L1PF_jet_ptratio_vs_pt_barrel_->Fill(mc_.pt, recopair.second.pt / mc_.pt); + } else if (fabs(mc_.eta) < 2.5) { + h_L1PF_jet_ptratio_vs_pt_endcap_->Fill(mc_.pt, recopair.second.pt / mc_.pt); + } else if (fabs(mc_.eta) < 3.) { + h_L1PF_jet_ptratio_vs_pt_ecnotk_->Fill(mc_.pt, recopair.second.pt / mc_.pt); + } else if (fabs(mc_.eta) < 5.) { + h_L1PF_jet_ptratio_vs_pt_hf_->Fill(mc_.pt, recopair.second.pt / mc_.pt); + } + h_L1PF_jet_ptratio_vs_eta_->Fill(mc_.eta, recopair.second.pt / mc_.pt); + } + if (recopair.first.name() == "L1Puppi") { + if (fabs(mc_.eta) < 1.5) { + h_L1Puppi_jet_ptratio_vs_pt_barrel_->Fill(mc_.pt, recopair.second.pt / mc_.pt); + } else if (fabs(mc_.eta) < 2.5) { + h_L1Puppi_jet_ptratio_vs_pt_endcap_->Fill(mc_.pt, recopair.second.pt / mc_.pt); + } else if (fabs(mc_.eta) < 3.) { + h_L1Puppi_jet_ptratio_vs_pt_ecnotk_->Fill(mc_.pt, recopair.second.pt / mc_.pt); + } else if (fabs(mc_.eta) < 5.) { + h_L1Puppi_jet_ptratio_vs_pt_hf_->Fill(mc_.pt, recopair.second.pt / mc_.pt); + } + h_L1Puppi_jet_ptratio_vs_eta_->Fill(mc_.eta, recopair.second.pt / mc_.pt); + } + } + } + } + for (auto& recopair : reco_) { + recopair.first.clear(); + recopair.second.clear(); + } + + + for (auto& pfToken : phase2PFToken_) { + edm::Handle> l1pfs; + e.getByToken(pfToken, l1pfs); + + for (const auto& pfc : *l1pfs) { + h_L1PF_pt_->Fill(pfc.pt()); + h_L1PF_eta_->Fill(pfc.eta()); + if (abs(pfc.pdgId()) == 13) { + h_L1PF_pt_mu_->Fill(pfc.pt()); + h_L1PF_eta_mu_->Fill(pfc.eta()); + } else if (abs(pfc.pdgId()) == 11) { + h_L1PF_pt_el_->Fill(pfc.pt()); + h_L1PF_eta_el_->Fill(pfc.eta()); + } else if (abs(pfc.pdgId()) == 22) { + h_L1PF_pt_pho_->Fill(pfc.pt()); + h_L1PF_eta_pho_->Fill(pfc.eta()); + } else if (abs(pfc.pdgId()) == 211) { + h_L1PF_pt_ch_->Fill(pfc.pt()); + h_L1PF_eta_ch_->Fill(pfc.eta()); + } else if (abs(pfc.pdgId()) == 130) { + h_L1PF_pt_nh_->Fill(pfc.pt()); + h_L1PF_eta_nh_->Fill(pfc.eta()); + } + } // loop over L1 PF + } + for (auto& pupToken : phase2PuppiToken_) { + edm::Handle> l1pups; + e.getByToken(pupToken, l1pups); + for (const auto& pupc : *l1pups) { + h_L1Puppi_pt_->Fill(pupc.pt()); + h_L1Puppi_eta_->Fill(pupc.eta()); + if (abs(pupc.pdgId()) == 13) { + h_L1Puppi_pt_mu_->Fill(pupc.pt()); + h_L1Puppi_eta_mu_->Fill(pupc.eta()); + } else if (abs(pupc.pdgId()) == 11) { + h_L1Puppi_pt_el_->Fill(pupc.pt()); + h_L1Puppi_eta_el_->Fill(pupc.eta()); + } else if (abs(pupc.pdgId()) == 22) { + h_L1Puppi_pt_pho_->Fill(pupc.pt()); + h_L1Puppi_eta_pho_->Fill(pupc.eta()); + } else if (abs(pupc.pdgId()) == 211) { + h_L1Puppi_pt_ch_->Fill(pupc.pt()); + h_L1Puppi_eta_ch_->Fill(pupc.eta()); + } else if (abs(pupc.pdgId()) == 130) { + h_L1Puppi_pt_nh_->Fill(pupc.pt()); + h_L1Puppi_eta_nh_->Fill(pupc.eta()); + } + } // loop over L1 Puppi + } +} + +// +// -------------------------------------- endRun -------------------------------------------- +// +// +// -------------------------------------- book histograms -------------------------------------------- +// +void L1TPhase2CorrelatorOffline::bookPhase2CorrelatorHistos(DQMStore::IBooker& ibooker) { + ibooker.cd(); + ibooker.setCurrentFolder(histFolder_); + ibooker.setScope(MonitorElementData::Scope::RUN); + + dqmoffline::l1t::HistDefinition resVsPtDef = histDefinitions_[PlotConfig::resVsPt]; + dqmoffline::l1t::HistDefinition resVsEtaDef = histDefinitions_[PlotConfig::resVsEta]; + dqmoffline::l1t::HistDefinition ptDistDef = histDefinitions_[PlotConfig::ptDist]; + dqmoffline::l1t::HistDefinition etaDistDef = histDefinitions_[PlotConfig::etaDist]; + + int ptratio_nbins = 300; + float ptratio_lo = 0.; + float ptratio_hi = 3.; + + h_L1PF_pt_ = ibooker.book1D("PF_pt", "L1 PF p_{T}", ptDistDef.nbinsX, ptDistDef.xmin, ptDistDef.xmax); + h_L1PF_eta_ = ibooker.book1D("PF_eta", "L1 PF #eta", etaDistDef.nbinsX, etaDistDef.xmin, etaDistDef.xmax); + h_L1Puppi_pt_ = ibooker.book1D("Puppi_pt", "L1 PUPPI p_{T}", ptDistDef.nbinsX, ptDistDef.xmin, ptDistDef.xmax); + h_L1Puppi_eta_ = ibooker.book1D("Puppi_eta", "L1 PUPPI #eta", etaDistDef.nbinsX, etaDistDef.xmin, etaDistDef.xmax); + + h_L1PF_pt_mu_ = ibooker.book1D("PF_pt_mu", "L1 PF Muon p_{T}", ptDistDef.nbinsX, ptDistDef.xmin, ptDistDef.xmax); + h_L1PF_eta_mu_ = ibooker.book1D("PF_eta_mu", "L1 PF Muon #eta", etaDistDef.nbinsX, etaDistDef.xmin, etaDistDef.xmax); + h_L1Puppi_pt_mu_ = + ibooker.book1D("Puppi_pt_mu", "L1 PUPPI Muon p_{T}", ptDistDef.nbinsX, ptDistDef.xmin, ptDistDef.xmax); + h_L1Puppi_eta_mu_ = + ibooker.book1D("Puppi_eta_mu", "L1 PUPPI Muon #eta", etaDistDef.nbinsX, etaDistDef.xmin, etaDistDef.xmax); + + h_L1PF_pt_el_ = ibooker.book1D("PF_pt_el", "L1 PF Electron p_{T}", ptDistDef.nbinsX, ptDistDef.xmin, ptDistDef.xmax); + h_L1PF_eta_el_ = + ibooker.book1D("PF_eta_el", "L1 PF Electron #eta", etaDistDef.nbinsX, etaDistDef.xmin, etaDistDef.xmax); + h_L1Puppi_pt_el_ = + ibooker.book1D("Puppi_pt_el", "L1 PUPPI Electron p_{T}", ptDistDef.nbinsX, ptDistDef.xmin, ptDistDef.xmax); + h_L1Puppi_eta_el_ = + ibooker.book1D("Puppi_eta_el", "L1 PUPPI Electron #eta", etaDistDef.nbinsX, etaDistDef.xmin, etaDistDef.xmax); + + h_L1PF_pt_pho_ = ibooker.book1D("PF_pt_pho", "L1 PF Photon p_{T}", ptDistDef.nbinsX, ptDistDef.xmin, ptDistDef.xmax); + h_L1PF_eta_pho_ = + ibooker.book1D("PF_eta_pho", "L1 PF Photon #eta", etaDistDef.nbinsX, etaDistDef.xmin, etaDistDef.xmax); + h_L1Puppi_pt_pho_ = + ibooker.book1D("Puppi_pt_pho", "L1 PUPPI Photon p_{T}", ptDistDef.nbinsX, ptDistDef.xmin, ptDistDef.xmax); + h_L1Puppi_eta_pho_ = + ibooker.book1D("Puppi_eta_pho", "L1 PUPPI Photon #eta", etaDistDef.nbinsX, etaDistDef.xmin, etaDistDef.xmax); + + h_L1PF_pt_ch_ = + ibooker.book1D("PF_pt_ch", "L1 PF Charged Hadron p_{T}", ptDistDef.nbinsX, ptDistDef.xmin, ptDistDef.xmax); + h_L1PF_eta_ch_ = + ibooker.book1D("PF_eta_ch", "L1 PF Charged Hadron #eta", etaDistDef.nbinsX, etaDistDef.xmin, etaDistDef.xmax); + h_L1Puppi_pt_ch_ = + ibooker.book1D("Puppi_pt_ch", "L1 PUPPI Charged Hadron p_{T}", ptDistDef.nbinsX, ptDistDef.xmin, ptDistDef.xmax); + h_L1Puppi_eta_ch_ = ibooker.book1D( + "Puppi_eta_ch", "L1 PUPPI Charged Hadron #eta", etaDistDef.nbinsX, etaDistDef.xmin, etaDistDef.xmax); + + h_L1PF_pt_nh_ = + ibooker.book1D("PF_pt_nh", "L1 PF Neutral Hadron p_{T}", ptDistDef.nbinsX, ptDistDef.xmin, ptDistDef.xmax); + h_L1PF_eta_nh_ = + ibooker.book1D("PF_eta_nh", "L1 PF Neutral Hadron #eta", etaDistDef.nbinsX, etaDistDef.xmin, etaDistDef.xmax); + h_L1Puppi_pt_nh_ = + ibooker.book1D("Puppi_pt_nh", "L1 PUPPI Neutral Hadron p_{T}", ptDistDef.nbinsX, ptDistDef.xmin, ptDistDef.xmax); + h_L1Puppi_eta_nh_ = ibooker.book1D( + "Puppi_eta_nh", "L1 PUPPI Neutral Hadron #eta", etaDistDef.nbinsX, etaDistDef.xmin, etaDistDef.xmax); + + ibooker.setCurrentFolder(respresolFolder_); + + + h_L1PF_part_ptratio_0p2_vs_pt_barrel_ = ibooker.book2D("L1PFParticlePtRatio0p2VsPtBarrel", + "L1 PF Particle L1/Gen (#Delta R < 0.2) vs p_{T}, Barrel", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax, + ptratio_nbins, + ptratio_lo, + ptratio_hi); + + h_L1PF_part_ptratio_0p2_vs_pt_endcap_ = ibooker.book2D("L1PFParticlePtRatio0p2VsPtEndcap", + "L1 PF Particle L1/Gen (#Delta R < 0.2) vs p_{T}, Endcap", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax, + ptratio_nbins, + ptratio_lo, + ptratio_hi); + + h_L1PF_part_ptratio_0p2_vs_pt_ecnotk_ = ibooker.book2D("L1PFParticlePtRatio0p2VsPtEndcapNoTk", + "L1 PF Particle L1/Gen (#Delta R < 0.2) vs p_{T}, Endcap No Tk", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax, + ptratio_nbins, + ptratio_lo, + ptratio_hi); + + h_L1PF_part_ptratio_0p2_vs_pt_hf_ = ibooker.book2D("L1PFParticlePtRatio0p2VsPtHF", + "L1 PF Particle L1/Gen (#Delta R < 0.2) vs p_{T}, HF", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax, + ptratio_nbins, + ptratio_lo, + ptratio_hi); + + h_L1PF_part_ptratio_0p2_vs_eta_ = ibooker.book2D("L1PFParticlePtRatio0p2VsEta", + "L1 PF Particle L1/Gen (#Delta R < 0.2) vs #eta", + resVsEtaDef.nbinsX, + resVsEtaDef.xmin, + resVsEtaDef.xmax, + ptratio_nbins, + ptratio_lo, + ptratio_hi); + + h_L1Puppi_part_ptratio_0p2_vs_pt_barrel_ = ibooker.book2D("L1PUPPIParticlePtRatio0p2VsPtBarrel", + "L1 PUPPI Particle L1/Gen (#Delta R < 0.2) vs p_{T}, Barrel", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax, + ptratio_nbins, + ptratio_lo, + ptratio_hi); + + h_L1Puppi_part_ptratio_0p2_vs_pt_endcap_ = ibooker.book2D("L1PUPPIParticlePtRatio0p2VsPtEndcap", + "L1 PUPPI Particle L1/Gen (#Delta R < 0.2) vs p_{T}, Endcap", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax, + ptratio_nbins, + ptratio_lo, + ptratio_hi); + + h_L1Puppi_part_ptratio_0p2_vs_pt_ecnotk_ = + ibooker.book2D("L1PUPPIParticlePtRatio0p2VsPtEndcapNoTk", + "L1 PUPPI Particle L1/Gen (#Delta R < 0.2) vs p_{T}, Endcap No Tk", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax, + ptratio_nbins, + ptratio_lo, + ptratio_hi); + + h_L1Puppi_part_ptratio_0p2_vs_pt_hf_ = ibooker.book2D("L1PUPPIParticlePtRatio0p2VsPtHF", + "L1 PUPPI Particle L1/Gen (#Delta R < 0.2) vs p_{T}, HF", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax, + ptratio_nbins, + ptratio_lo, + ptratio_hi); + + h_L1Puppi_part_ptratio_0p2_vs_eta_ = ibooker.book2D("L1PUPPIParticlePtRatio0p2VsEta", + "L1 PUPPI Particle L1/Gen (#Delta R < 0.2) vs #eta", + resVsEtaDef.nbinsX, + resVsEtaDef.xmin, + resVsEtaDef.xmax, + ptratio_nbins, + ptratio_lo, + ptratio_hi); + + h_L1PF_jet_ptratio_vs_pt_barrel_ = ibooker.book2D("L1PFJetPtRatioVsPtBarrel", + "L1 PF Jet L1/Gen vs p_{T}, Barrel", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax, + ptratio_nbins, + ptratio_lo, + ptratio_hi); + + h_L1PF_jet_ptratio_vs_pt_endcap_ = ibooker.book2D("L1PFJetPtRatioVsPtEndcap", + "L1 PF Jet L1/Gen vs p_{T}, Endcap", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax, + ptratio_nbins, + ptratio_lo, + ptratio_hi); + + h_L1PF_jet_ptratio_vs_pt_ecnotk_ = ibooker.book2D("L1PFJetPtRatioVsPtEndcapNoTk", + "L1 PF Jet L1/Gen vs p_{T}, Endcap No Tk", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax, + ptratio_nbins, + ptratio_lo, + ptratio_hi); + + h_L1PF_jet_ptratio_vs_pt_hf_ = ibooker.book2D("L1PFJetPtRatioVsPtHF", + "L1 PF Jet L1/Gen vs p_{T}, HF", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax, + ptratio_nbins, + ptratio_lo, + ptratio_hi); + + h_L1PF_jet_ptratio_vs_eta_ = ibooker.book2D("L1PFJetPtRatioVsEta", + "L1 PF Jet L1/Gen vs #eta", + resVsEtaDef.nbinsX, + resVsEtaDef.xmin, + resVsEtaDef.xmax, + ptratio_nbins, + ptratio_lo, + ptratio_hi); + + h_L1Puppi_jet_ptratio_vs_pt_barrel_ = ibooker.book2D("L1PUPPIJetPtRatioVsPtBarrel", + "L1 PUPPI Jet L1/Gen vs p_{T}, Barrel", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax, + ptratio_nbins, + ptratio_lo, + ptratio_hi); + + h_L1Puppi_jet_ptratio_vs_pt_endcap_ = ibooker.book2D("L1PUPPIJetPtRatioVsPtEndcap", + "L1 PUPPI Jet L1/Gen vs p_{T}, Endcap", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax, + ptratio_nbins, + ptratio_lo, + ptratio_hi); + + h_L1Puppi_jet_ptratio_vs_pt_ecnotk_ = ibooker.book2D("L1PUPPIJetPtRatioVsPtEndcapNoTk", + "L1 PUPPI Jet L1/Gen vs p_{T}, EndcapNoTk", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax, + ptratio_nbins, + ptratio_lo, + ptratio_hi); + + h_L1Puppi_jet_ptratio_vs_pt_hf_ = ibooker.book2D("L1PUPPIJetPtRatioVsPtHF", + "L1 PUPPI Jet L1/Gen vs p_{T}, HF", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax, + ptratio_nbins, + ptratio_lo, + ptratio_hi); + + h_L1Puppi_jet_ptratio_vs_eta_ = ibooker.book2D("L1PUPPIJetPtRatioVsEta", + "L1 PUPPI Jet L1/Gen vs #eta", + resVsEtaDef.nbinsX, + resVsEtaDef.xmin, + resVsEtaDef.xmax, + ptratio_nbins, + ptratio_lo, + ptratio_hi); + + ibooker.setCurrentFolder(histFolder_); + //Response + + h_L1PF_part_response_0p2_pt_barrel_ = ibooker.book1D("L1PFParticleResponse0p2VsPtBarrel", + "L1 PF Particle Response (#Delta R < 0.2) vs p_{T}, Barrel", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1PF_part_response_0p2_pt_endcap_ = ibooker.book1D("L1PFParticleResponse0p2VsPtEndcap", + "L1 PF Particle Response (#Delta R < 0.2) vs p_{T}, Endcap", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1PF_part_response_0p2_pt_ecnotk_ = ibooker.book1D("L1PFParticleResponse0p2VsPtEndcapNoTk", + "L1 PF Particle Response (#Delta R < 0.2) vs p_{T}, Endcap No Tk", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1PF_part_response_0p2_pt_hf_ = ibooker.book1D("L1PFParticleResponse0p2VsPtHF", + "L1 PF Particle Response (#Delta R < 0.2) vs p_{T}, HF", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1PF_part_response_0p2_eta_ = ibooker.book1D("L1PFParticleResponse0p2VsEta", + "L1 PF Particle Response (#Delta R < 0.2) vs #eta", + resVsEtaDef.nbinsX, + resVsEtaDef.xmin, + resVsEtaDef.xmax); + + h_L1Puppi_part_response_0p2_pt_barrel_ = ibooker.book1D("L1PUPPIParticleResponse0p2VsPtBarrel", + "L1 PUPPI Particle Response (#Delta R < 0.2) vs p_{T}, Barrel", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1Puppi_part_response_0p2_pt_endcap_ = ibooker.book1D("L1PUPPIParticleResponse0p2VsPtEndcap", + "L1 PUPPI Particle Response (#Delta R < 0.2) vs p_{T}, Endcap", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1Puppi_part_response_0p2_pt_ecnotk_ = + ibooker.book1D("L1PUPPIParticleResponse0p2VsPtEndcapNoTk", + "L1 PUPPI Particle Response (#Delta R < 0.2) vs p_{T}, Endcap No Tk", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1Puppi_part_response_0p2_pt_hf_ = ibooker.book1D("L1PUPPIParticleResponse0p2VsPtHF", + "L1 PUPPI Particle Response (#Delta R < 0.2) vs p_{T}, HF", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1Puppi_part_response_0p2_eta_ = ibooker.book1D("L1PUPPIParticleResponse0p2VsEta", + "L1 PUPPI Particle Response (#Delta R < 0.2) vs #eta", + resVsEtaDef.nbinsX, + resVsEtaDef.xmin, + resVsEtaDef.xmax); + + h_L1PF_jet_response_pt_barrel_ = ibooker.book1D("L1PFJetResponseVsPtBarrel", + "L1 PF Jet Response vs p_{T}, Barrel", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1PF_jet_response_pt_endcap_ = ibooker.book1D("L1PFJetResponseVsPtEndcap", + "L1 PF Jet Response vs p_{T}, Endcap", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1PF_jet_response_pt_ecnotk_ = ibooker.book1D("L1PFJetResponseVsPtEndcapNoTk", + "L1 PF Jet Response vs p_{T}, Endcap No Tk", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1PF_jet_response_pt_hf_ = ibooker.book1D( + "L1PFJetResponseVsPtHF", "L1 PF Jet Response vs p_{T}, HF", resVsPtDef.nbinsX, resVsPtDef.xmin, resVsPtDef.xmax); + + h_L1PF_jet_response_eta_ = ibooker.book1D( + "L1PFJetResponseVsEta", "L1 PF Jet Response vs #eta", resVsEtaDef.nbinsX, resVsEtaDef.xmin, resVsEtaDef.xmax); + + h_L1Puppi_jet_response_pt_barrel_ = ibooker.book1D("L1PUPPIJetResponseVsPtBarrel", + "L1 PUPPI Jet Response vs p_{T}, Barrel", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1Puppi_jet_response_pt_endcap_ = ibooker.book1D("L1PUPPIJetResponseVsPtEndcap", + "L1 PUPPI Jet Response vs p_{T}, Endcap", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1Puppi_jet_response_pt_ecnotk_ = ibooker.book1D("L1PUPPIJetResponseVsPtEndcapNoTk", + "L1 PUPPI Jet Response vs p_{T}, EndcapNoTk", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1Puppi_jet_response_pt_hf_ = ibooker.book1D("L1PUPPIJetResponseVsPtHF", + "L1 PUPPI Jet Response vs p_{T}, HF", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1Puppi_jet_response_eta_ = ibooker.book1D("L1PUPPIJetResponseVsEta", + "L1 PUPPI Jet Response vs #eta", + resVsEtaDef.nbinsX, + resVsEtaDef.xmin, + resVsEtaDef.xmax); + + //Resolution + + h_L1PF_part_resolution_0p2_pt_barrel_ = ibooker.book1D("L1PFParticleResolution0p2VsPtBarrel", + "L1 PF Particle Resolution (#Delta R < 0.2) vs p_{T}, Barrel", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1PF_part_resolution_0p2_pt_endcap_ = ibooker.book1D("L1PFParticleResolution0p2VsPtEndcap", + "L1 PF Particle Resolution (#Delta R < 0.2) vs p_{T}, Endcap", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1PF_part_resolution_0p2_pt_ecnotk_ = + ibooker.book1D("L1PFParticleResolution0p2VsPtEndcapNoTk", + "L1 PF Particle Resolution (#Delta R < 0.2) vs p_{T}, Endcap No Tk", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1PF_part_resolution_0p2_pt_hf_ = ibooker.book1D("L1PFParticleResolution0p2VsPtHF", + "L1 PF Particle Resolution (#Delta R < 0.2) vs p_{T}, HF", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1Puppi_part_resolution_0p2_pt_barrel_ = + ibooker.book1D("L1PUPPIParticleResolution0p2VsPtBarrel", + "L1 PUPPI Particle Resolution (#Delta R < 0.2) vs p_{T}, Barrel", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1Puppi_part_resolution_0p2_pt_endcap_ = + ibooker.book1D("L1PUPPIParticleResolution0p2VsPtEndcap", + "L1 PUPPI Particle Resolution (#Delta R < 0.2) vs p_{T}, Endcap", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1Puppi_part_resolution_0p2_pt_ecnotk_ = + ibooker.book1D("L1PUPPIParticleResolution0p2VsPtEndcapNoTk", + "L1 PUPPI Particle Resolution (#Delta R < 0.2) vs p_{T}, Endcap No Tk", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1Puppi_part_resolution_0p2_pt_hf_ = ibooker.book1D("L1PUPPIParticleResolution0p2VsPtHF", + "L1 PUPPI Particle Resolution (#Delta R < 0.2) vs p_{T}, HF", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1PF_jet_resolution_pt_barrel_ = ibooker.book1D("L1PFJetResolutionVsPtBarrel", + "L1 PF Jet Resolution vs p_{T}, Barrel", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1PF_jet_resolution_pt_endcap_ = ibooker.book1D("L1PFJetResolutionVsPtEndcap", + "L1 PF Jet Resolution vs p_{T}, Endcap", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1PF_jet_resolution_pt_ecnotk_ = ibooker.book1D("L1PFJetResolutionVsPtEndcapNoTk", + "L1 PF Jet Resolution vs p_{T}, Endcap No Tk", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1PF_jet_resolution_pt_hf_ = ibooker.book1D("L1PFJetResolutionVsPtHF", + "L1 PF Jet Resolution vs p_{T}, HF", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1Puppi_jet_resolution_pt_barrel_ = ibooker.book1D("L1PUPPIJetResolutionVsPtBarrel", + "L1 PUPPI Jet Resolution vs p_{T}, Barrel", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1Puppi_jet_resolution_pt_endcap_ = ibooker.book1D("L1PUPPIJetResolutionVsPtEndcap", + "L1 PUPPI Jet Resolution vs p_{T}, Endcap", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1Puppi_jet_resolution_pt_ecnotk_ = ibooker.book1D("L1PUPPIJetResolutionVsPtEndcapNoTk", + "L1 PUPPI Jet Resolution vs p_{T}, EndcapNoTk", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + h_L1Puppi_jet_resolution_pt_hf_ = ibooker.book1D("L1PUPPIJetResolutionVsPtHF", + "L1 PUPPI Jet Resolution vs p_{T}, HF", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); + + ibooker.cd(); + + return; +} + +// +// -------------------------------------- endRun -------------------------------------------- +// +void L1TPhase2CorrelatorOffline::dqmEndRun(const edm::Run& run, const edm::EventSetup& iSetup) { + computeResponseResolution(); +} + +void L1TPhase2CorrelatorOffline::computeResponseResolution() { + std::vector monElementstoComputeIn = {h_L1PF_part_ptratio_0p2_vs_pt_barrel_, + h_L1PF_part_ptratio_0p2_vs_pt_endcap_, + h_L1PF_part_ptratio_0p2_vs_pt_ecnotk_, + h_L1PF_part_ptratio_0p2_vs_pt_hf_, + h_L1PF_part_ptratio_0p2_vs_eta_, + h_L1Puppi_part_ptratio_0p2_vs_pt_barrel_, + h_L1Puppi_part_ptratio_0p2_vs_pt_endcap_, + h_L1Puppi_part_ptratio_0p2_vs_pt_ecnotk_, + h_L1Puppi_part_ptratio_0p2_vs_pt_hf_, + h_L1Puppi_part_ptratio_0p2_vs_eta_, + h_L1PF_jet_ptratio_vs_pt_barrel_, + h_L1PF_jet_ptratio_vs_pt_endcap_, + h_L1PF_jet_ptratio_vs_pt_ecnotk_, + h_L1PF_jet_ptratio_vs_pt_hf_, + h_L1PF_jet_ptratio_vs_eta_, + h_L1Puppi_jet_ptratio_vs_pt_barrel_, + h_L1Puppi_jet_ptratio_vs_pt_endcap_, + h_L1Puppi_jet_ptratio_vs_pt_ecnotk_, + h_L1Puppi_jet_ptratio_vs_pt_hf_, + h_L1Puppi_jet_ptratio_vs_eta_}; + std::vector monElementstoComputeResp = {h_L1PF_part_response_0p2_pt_barrel_, + h_L1PF_part_response_0p2_pt_endcap_, + h_L1PF_part_response_0p2_pt_ecnotk_, + h_L1PF_part_response_0p2_pt_hf_, + h_L1PF_part_response_0p2_eta_, + h_L1Puppi_part_response_0p2_pt_barrel_, + h_L1Puppi_part_response_0p2_pt_endcap_, + h_L1Puppi_part_response_0p2_pt_ecnotk_, + h_L1Puppi_part_response_0p2_pt_hf_, + h_L1Puppi_part_response_0p2_eta_, + h_L1PF_jet_response_pt_barrel_, + h_L1PF_jet_response_pt_endcap_, + h_L1PF_jet_response_pt_ecnotk_, + h_L1PF_jet_response_pt_hf_, + h_L1PF_jet_response_eta_, + h_L1Puppi_jet_response_pt_barrel_, + h_L1Puppi_jet_response_pt_endcap_, + h_L1Puppi_jet_response_pt_ecnotk_, + h_L1Puppi_jet_response_pt_hf_, + h_L1Puppi_jet_response_eta_}; + std::vector monElementstoComputeResol = { + h_L1PF_part_resolution_0p2_pt_barrel_, + h_L1PF_part_resolution_0p2_pt_endcap_, + h_L1PF_part_resolution_0p2_pt_ecnotk_, + h_L1PF_part_resolution_0p2_pt_hf_, + nullptr, + h_L1Puppi_part_resolution_0p2_pt_barrel_, + h_L1Puppi_part_resolution_0p2_pt_endcap_, + h_L1Puppi_part_resolution_0p2_pt_ecnotk_, + h_L1Puppi_part_resolution_0p2_pt_hf_, + nullptr, + h_L1PF_jet_resolution_pt_barrel_, + h_L1PF_jet_resolution_pt_endcap_, + h_L1PF_jet_resolution_pt_ecnotk_, + h_L1PF_jet_resolution_pt_hf_, + nullptr, + h_L1Puppi_jet_resolution_pt_barrel_, + h_L1Puppi_jet_resolution_pt_endcap_, + h_L1Puppi_jet_resolution_pt_ecnotk_, + h_L1Puppi_jet_resolution_pt_hf_, + nullptr + }; + + for (unsigned int i = 0; i < monElementstoComputeIn.size(); i++) { + if (monElementstoComputeIn[i] != nullptr && monElementstoComputeResp[i] != nullptr && + monElementstoComputeResol[i] != nullptr) { + medianResponseCorrResolution( + monElementstoComputeIn[i], monElementstoComputeResp[i], monElementstoComputeResol[i]); + } else if (monElementstoComputeIn[i] != nullptr && monElementstoComputeResp[i] != nullptr) { + medianResponse(monElementstoComputeIn[i], monElementstoComputeResp[i]); + } + } +} + +void L1TPhase2CorrelatorOffline::medianResponse(MonitorElement* in2D, MonitorElement* response) { + auto hbase = in2D->getTH2F(); + auto hresp = response->getTH1F(); + if (hbase != nullptr && hresp != nullptr) { + if (hbase->GetNbinsX() == hresp->GetNbinsX() && hbase->GetNbinsX()) { + auto med = hbase->QuantilesX(0.5, "_qx"); + for (int ib = 0; ib < hbase->GetNbinsX() + 1; ib++) { + hresp->SetBinContent(ib, med->GetBinContent(ib)); + } + } + } +} + +void L1TPhase2CorrelatorOffline::medianResponseCorrResolution(MonitorElement* in2D, + MonitorElement* response, + MonitorElement* resolution) { + auto hbase = in2D->getTH2F(); + auto hresp = response->getTH1F(); + auto hresol = resolution->getTH1F(); + if (hbase != nullptr && hresp != nullptr && hresol != nullptr) { + if (hbase->GetNbinsX() == hresp->GetNbinsX() && hbase->GetNbinsX() == hresol->GetNbinsX()) { + auto med = hbase->QuantilesX(0.5, "_qx"); + TGraph* ptrecgen = new TGraph(hbase->GetNbinsX()); + for (int ib = 1; ib < hbase->GetNbinsX() + 1; ib++) { + float corr = med->GetBinContent(ib); + float xval = hbase->GetXaxis()->GetBinCenter(ib); + ptrecgen->SetPoint(ib - 1, xval * corr, xval); + hresp->SetBinContent(ib, corr); + } + delete med; + ptrecgen->Sort(); + TH2F* ch = new TH2F(*hbase); + ch->Reset("ICE"); + for (int ibx = 1; ibx < ch->GetNbinsX() + 1; ibx++) { + float xval = hbase->GetXaxis()->GetBinCenter(ibx); + for (int iby = 1; iby < ch->GetNbinsY() + 1; iby++) { + float yval = hbase->GetYaxis()->GetBinCenter(iby); + float newyval = ptrecgen->Eval(yval * xval) / xval; + int ycb = ch->FindBin(xval, newyval); + ch->SetBinContent(ycb, ch->GetBinContent(ycb) + hbase->GetBinContent(ibx, iby)); + } + } + delete ptrecgen; + auto qc = ch->QuantilesX(0.5, "_qc"); + auto qhi = ch->QuantilesX(0.84, "_qhi"); + auto qlo = ch->QuantilesX(0.16, "_qlo"); + delete ch; + for (int ibx = 1; ibx < hbase->GetNbinsX() + 1; ibx++) { + hresol->SetBinContent( + ibx, qc->GetBinContent(ibx) > 0.2 ? (qhi->GetBinContent(ibx) - qlo->GetBinContent(ibx)) / 2. : 0.); + } + delete qc; + delete qhi; + delete qlo; + } + } +} + +// define this as a plug-in +DEFINE_FWK_MODULE(L1TPhase2CorrelatorOffline); diff --git a/DQMOffline/L1Trigger/src/L1TPhase2OTTrackJetsandMHT.cc b/DQMOffline/L1Trigger/src/L1TPhase2OTTrackJetsandMHT.cc new file mode 100644 index 0000000000000..e7a8a48e8e1dc --- /dev/null +++ b/DQMOffline/L1Trigger/src/L1TPhase2OTTrackJetsandMHT.cc @@ -0,0 +1,259 @@ +// Package: SiOuterTracker +// Class: SiOuterTracker +// +// Author: Emily MacDonald (emily.kaelyn.macdonald@cern.ch) + +// system include files +#include +#include +#include +#include +#include +#include + +// user include files +#include "DataFormats/Common/interface/DetSetVector.h" +#include "DataFormats/Common/interface/DetSetVectorNew.h" +#include "DataFormats/Common/interface/Ptr.h" +#include "DataFormats/Common/interface/Ref.h" +#include "DataFormats/L1Trigger/interface/Jet.h" +#include "DataFormats/SiStripDetId/interface/StripSubdetector.h" +#include "DataFormats/TrackerCommon/interface/TrackerTopology.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "Geometry/Records/interface/TrackerDigiGeometryRecord.h" +#include "Geometry/CommonDetUnit/interface/GeomDet.h" +#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h" +#include "Geometry/TrackerGeometryBuilder/interface/StripGeomDetUnit.h" + +#include "DataFormats/L1TCorrelator/interface/TkJet.h" +#include "DataFormats/L1TCorrelator/interface/TkJetFwd.h" +#include "DataFormats/L1TCorrelator/interface/TkHTMiss.h" +#include "DataFormats/L1TCorrelator/interface/TkHTMissFwd.h" + +#include "DQMOffline/L1Trigger/interface/L1TPhase2OTTrackJetsandMHT.h" + + +// constructors and destructor +L1TPhase2OTTrackJetsandMHT::L1TPhase2OTTrackJetsandMHT(const edm::ParameterSet& iConfig) +:conf_(iConfig) +{ + topFolderName_ = conf_.getParameter("TopFolderName"); + jetToken = consumes< l1t::TkJetCollection > (conf_.getParameter("L1TkJetInputTag")); + jet_minPt = conf_.getParameter("jet_minPt"); + jet_maxEta = conf_.getParameter("jet_maxEta"); + minNtracksHighPt = conf_.getParameter("jet_minNtracksHighPt"); + minNtracksLowPt = conf_.getParameter("jet_minNtracksLowPt"); +} + +L1TPhase2OTTrackJetsandMHT::~L1TPhase2OTTrackJetsandMHT() +{ + // do anything here that needs to be done at desctruction time + // (e.g. close files, deallocate resources etc.) +} + +// member functions + +// ------------ method called for each event ------------ +void L1TPhase2OTTrackJetsandMHT::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { + edm::Handle< l1t::TkJetCollection > L1TkJetsHandle; + iEvent.getByToken(jetToken, L1TkJetsHandle); + std::vector< l1t::TkJet >::const_iterator jetIter; + + if ( ! L1TkJetsHandle.isValid() ) { + edm::LogWarning("DataNotFound")<< "\nWarning: L1TkJetParticleCollection not found in the event. Exit"<< std::endl; + return; + } + float sumPx = 0; + float sumPy = 0; + float tmp_HT = 0; + + // loop over jets + for (jetIter = L1TkJetsHandle->begin(); jetIter != L1TkJetsHandle->end(); ++jetIter) { + + float px = jetIter->px(); + float py = jetIter->py(); + float et = jetIter->et(); + float tmp_jet_pt = jetIter->pt(); + float tmp_jet_eta = jetIter->eta(); + float tmp_jet_phi = jetIter->phi(); + float tmp_jet_vtx = jetIter->jetVtx(); + float tmp_jet_ntracks = jetIter->ntracks(); + float tmp_jet_nTighttracks = jetIter->nTighttracks(); + float tmp_jet_nDisplacedtracks = jetIter->nDisptracks(); + float tmp_jet_nTightDisptracks = jetIter->nTightDisptracks(); + + allJets_pt->Fill(tmp_jet_pt); + allJets_eta->Fill(tmp_jet_eta); + allJets_phi->Fill(tmp_jet_phi); + allJets_vtx->Fill(tmp_jet_vtx); + allJets_nTracks->Fill(tmp_jet_ntracks); + allJets_nTightTracks->Fill(tmp_jet_nTighttracks); + allJets_nDisplacedTracks->Fill(tmp_jet_nDisplacedtracks); + allJets_nTightDispTracks->Fill(tmp_jet_nTightDisptracks); + + if (tmp_jet_pt < jet_minPt) continue; + if (fabs(tmp_jet_eta) > jet_maxEta) continue; + if(tmp_jet_ntracks50)continue; + if(tmp_jet_ntracks100)continue; + + HTJets_pt->Fill(tmp_jet_pt); + HTJets_eta->Fill(tmp_jet_eta); + HTJets_phi->Fill(tmp_jet_phi); + HTJets_vtx->Fill(tmp_jet_vtx); + HTJets_nTracks->Fill(tmp_jet_ntracks); + HTJets_nTightTracks->Fill(tmp_jet_nTighttracks); + HTJets_nDisplacedTracks->Fill(tmp_jet_nDisplacedtracks); + HTJets_nTightDispTracks->Fill(tmp_jet_nTightDisptracks); + + sumPx += px; + sumPy += py; + tmp_HT += tmp_jet_pt; + } // end jet loop + + // float tmp_MHT = sqrt(sumPx*sumPx + sumPy*sumPy); + // define missing HT + float et = sqrt(sumPx*sumPx + sumPy*sumPy); + math::XYZTLorentzVector missingEt(-sumPx, -sumPy, 0, et); + // edm::RefProd jetCollRef(L1TkJetsHandle); + // edm::Ref< l1t::TkPrimaryVertexCollection > L1VtxRef; // null reference + // l1t::TkHTMiss tkMHT(missingEt, tmp_HT, jetCollRef, L1VtxRef); + double MHT = missingEt.Pt(); + double HT = tmp_HT; + h_MHT->Fill(MHT); + h_HT->Fill(HT); + +} // end of method + +// ------------ method called once each job just before starting event loop ------------ +//Creating all histograms for DQM file output +void L1TPhase2OTTrackJetsandMHT::bookHistograms(DQMStore::IBooker &iBooker, edm::Run const & run, edm::EventSetup const & es) { + std::string HistoName; + + iBooker.setCurrentFolder(topFolderName_+"/TrackJets/AllJets"); + + // Num of tracks in track jet + HistoName = "NTracks"; + edm::ParameterSet psTrack_N = conf_.getParameter("TH1_NTracks"); + allJets_nTracks = iBooker.book1D(HistoName, HistoName, psTrack_N.getParameter("Nbinsx"), psTrack_N.getParameter("xmin"), psTrack_N.getParameter("xmax")); + allJets_nTracks->setAxisTitle("# Tracks per jet", 1); + allJets_nTracks->setAxisTitle("# Events", 2); + + // Num of tight tracks in track jet + HistoName = "NTightTracks"; + allJets_nTightTracks = iBooker.book1D(HistoName, HistoName, psTrack_N.getParameter("Nbinsx"), psTrack_N.getParameter("xmin"), psTrack_N.getParameter("xmax")); + allJets_nTightTracks->setAxisTitle("# Tight tracks per jet", 1); + allJets_nTightTracks->setAxisTitle("# Events", 2); + + // Num of displaced tracks in track jet + HistoName = "NDisplacedTracks"; + allJets_nDisplacedTracks = iBooker.book1D(HistoName, HistoName, psTrack_N.getParameter("Nbinsx"), psTrack_N.getParameter("xmin"), psTrack_N.getParameter("xmax")); + allJets_nDisplacedTracks->setAxisTitle("# Displaced tracks per jet", 1); + allJets_nDisplacedTracks->setAxisTitle("# Events", 2); + + // Num of tight displaced tracks in track jet + HistoName = "NTightDispTracks"; + allJets_nTightDispTracks = iBooker.book1D(HistoName, HistoName, psTrack_N.getParameter("Nbinsx"), psTrack_N.getParameter("xmin"), psTrack_N.getParameter("xmax")); + allJets_nTightDispTracks->setAxisTitle("# Tight displaced tracks per jet", 1); + allJets_nTightDispTracks->setAxisTitle("# Events", 2); + + //Pt of jets + edm::ParameterSet psJet_Pt = conf_.getParameter("TH1_Jet_Pt"); + HistoName = "Jet_Pt"; + allJets_pt = iBooker.book1D(HistoName, HistoName, psJet_Pt.getParameter("Nbinsx"), psJet_Pt.getParameter("xmin"), psJet_Pt.getParameter("xmax")); + allJets_pt->setAxisTitle("p_{T} [GeV]", 1); + allJets_pt->setAxisTitle("# Track Jets", 2); + + //Eta + edm::ParameterSet psJet_Eta = conf_.getParameter("TH1_Jet_Eta"); + HistoName = "Track_Eta"; + allJets_eta = iBooker.book1D(HistoName, HistoName, psJet_Eta.getParameter("Nbinsx"), psJet_Eta.getParameter("xmin"), psJet_Eta.getParameter("xmax")); + allJets_eta->setAxisTitle("#eta", 1); + allJets_eta->setAxisTitle("# Track Jets", 2); + + //Phi + edm::ParameterSet psJet_Phi = conf_.getParameter("TH1_Jet_Phi"); + HistoName = "Track_Phi"; + allJets_phi = iBooker.book1D(HistoName, HistoName, psJet_Phi.getParameter("Nbinsx"), psJet_Phi.getParameter("xmin"), psJet_Phi.getParameter("xmax")); + allJets_phi->setAxisTitle("#phi", 1); + allJets_phi->setAxisTitle("# Track Jets", 2); + + //Vtx + edm::ParameterSet psJet_Vtx = conf_.getParameter("TH1_Jet_Vtx"); + HistoName = "Jet_Vtx"; + allJets_vtx = iBooker.book1D(HistoName, HistoName, psJet_Vtx.getParameter("Nbinsx"), psJet_Vtx.getParameter("xmin"), psJet_Vtx.getParameter("xmax")); + allJets_vtx->setAxisTitle("Track Jet vertex position z [cm]", 1); + allJets_vtx->setAxisTitle("# Track Jets", 2); + + + + iBooker.setCurrentFolder(topFolderName_+"/TrackJets/HTJets"); + + // Num of tracks in track jet + HistoName = "NTracks"; + HTJets_nTracks = iBooker.book1D(HistoName, HistoName, psTrack_N.getParameter("Nbinsx"), psTrack_N.getParameter("xmin"), psTrack_N.getParameter("xmax")); + HTJets_nTracks->setAxisTitle("# Tracks per jet", 1); + HTJets_nTracks->setAxisTitle("# Events", 2); + + // Num of tight tracks in track jet + HistoName = "NTightTracks"; + HTJets_nTightTracks = iBooker.book1D(HistoName, HistoName, psTrack_N.getParameter("Nbinsx"), psTrack_N.getParameter("xmin"), psTrack_N.getParameter("xmax")); + HTJets_nTightTracks->setAxisTitle("# Tight tracks per jet", 1); + HTJets_nTightTracks->setAxisTitle("# Events", 2); + + // Num of displaced tracks in track jet + HistoName = "NDisplacedTracks"; + HTJets_nDisplacedTracks = iBooker.book1D(HistoName, HistoName, psTrack_N.getParameter("Nbinsx"), psTrack_N.getParameter("xmin"), psTrack_N.getParameter("xmax")); + HTJets_nDisplacedTracks->setAxisTitle("# Displaced tracks per jet", 1); + HTJets_nDisplacedTracks->setAxisTitle("# Events", 2); + + // Num of tight displaced tracks in track jet + HistoName = "NTightDispTracks"; + HTJets_nTightDispTracks = iBooker.book1D(HistoName, HistoName, psTrack_N.getParameter("Nbinsx"), psTrack_N.getParameter("xmin"), psTrack_N.getParameter("xmax")); + HTJets_nTightDispTracks->setAxisTitle("# Tight displaced tracks per jet", 1); + HTJets_nTightDispTracks->setAxisTitle("# Events", 2); + + //Pt of jets + HistoName = "Jet_Pt"; + HTJets_pt = iBooker.book1D(HistoName, HistoName, psJet_Pt.getParameter("Nbinsx"), psJet_Pt.getParameter("xmin"), psJet_Pt.getParameter("xmax")); + HTJets_pt->setAxisTitle("p_{T} [GeV]", 1); + HTJets_pt->setAxisTitle("# Track Jets", 2); + + //Eta + HistoName = "Track_Eta"; + HTJets_eta = iBooker.book1D(HistoName, HistoName, psJet_Eta.getParameter("Nbinsx"), psJet_Eta.getParameter("xmin"), psJet_Eta.getParameter("xmax")); + HTJets_eta->setAxisTitle("#eta", 1); + HTJets_eta->setAxisTitle("# Track Jets", 2); + + //Phi + HistoName = "Track_Phi"; + HTJets_phi = iBooker.book1D(HistoName, HistoName, psJet_Phi.getParameter("Nbinsx"), psJet_Phi.getParameter("xmin"), psJet_Phi.getParameter("xmax")); + HTJets_phi->setAxisTitle("#phi", 1); + HTJets_phi->setAxisTitle("# Track Jets", 2); + + //Vtx + HistoName = "Jet_Vtx"; + HTJets_vtx = iBooker.book1D(HistoName, HistoName, psJet_Vtx.getParameter("Nbinsx"), psJet_Vtx.getParameter("xmin"), psJet_Vtx.getParameter("xmax")); + HTJets_vtx->setAxisTitle("Track Jet vertex position z [cm]", 1); + HTJets_vtx->setAxisTitle("# Track Jets", 2); + + iBooker.setCurrentFolder(topFolderName_+"/TrackJets"); + + //MHT + HistoName = "MHT"; + edm::ParameterSet psMHT = conf_.getParameter("TH1_MHT"); + h_MHT = iBooker.book1D(HistoName, HistoName, psMHT.getParameter("Nbinsx"), psMHT.getParameter("xmin"), psMHT.getParameter("xmax")); + h_MHT->setAxisTitle("Track Jet MHT [GeV]", 1); + h_MHT->setAxisTitle("#Events", 2); + + //HT + HistoName = "HT"; + edm::ParameterSet psHT = conf_.getParameter("TH1_HT"); + h_HT = iBooker.book1D(HistoName, HistoName, psHT.getParameter("Nbinsx"), psHT.getParameter("xmin"), psHT.getParameter("xmax")); + h_HT->setAxisTitle("Track Jet HT [GeV]", 1); + h_HT->setAxisTitle("#Events", 2); + + +} //end of method + +DEFINE_FWK_MODULE(L1TPhase2OTTrackJetsandMHT); From 60a5cd69d94e8ac490203b3abcd9e3516f0ad711 Mon Sep 17 00:00:00 2001 From: Dylan Date: Wed, 20 Oct 2021 07:49:50 -0500 Subject: [PATCH 2/7] adding tkmet module --- .../interface/L1TPhase2OuterTrackerTkMET.h | 61 +++++ .../src/L1TPhase2OuterTrackerTkMET.cc | 252 ++++++++++++++++++ 2 files changed, 313 insertions(+) create mode 100644 DQMOffline/L1Trigger/interface/L1TPhase2OuterTrackerTkMET.h create mode 100644 DQMOffline/L1Trigger/src/L1TPhase2OuterTrackerTkMET.cc diff --git a/DQMOffline/L1Trigger/interface/L1TPhase2OuterTrackerTkMET.h b/DQMOffline/L1Trigger/interface/L1TPhase2OuterTrackerTkMET.h new file mode 100644 index 0000000000000..ec18b908bc27c --- /dev/null +++ b/DQMOffline/L1Trigger/interface/L1TPhase2OuterTrackerTkMET.h @@ -0,0 +1,61 @@ +#ifndef L1TPhase2_OuterTrackerTkMET_h +#define L1TPhase2_OuterTrackerTkMET_h + +#include +#include +#include +#include "FWCore/Utilities/interface/EDGetToken.h" +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "DQMServices/Core/interface/MonitorElement.h" +#include "DQMServices/Core/interface/DQMEDAnalyzer.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/Framework/interface/ESHandle.h" +#include "DataFormats/Common/interface/DetSetVectorNew.h" +#include "DataFormats/L1TrackTrigger/interface/TTTypes.h" +// #include "DataFormats/L1TVertex/interface/Vertex.h" +#include "DataFormats/L1TCorrelator/interface/TkPrimaryVertex.h" + +class DQMStore; +class L1TPhase2OuterTrackerTkMET : public DQMEDAnalyzer { +public: + explicit L1TPhase2OuterTrackerTkMET(const edm::ParameterSet&); + ~L1TPhase2OuterTrackerTkMET() override; + void analyze(const edm::Event&, const edm::EventSetup&) override; + void bookHistograms(DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override; + + MonitorElement* Track_N = nullptr; // Number of tracks per event + MonitorElement* Track_Pt = nullptr; // pT distrubtion for tracks + MonitorElement* Track_Eta = nullptr; // eta distrubtion for tracks + MonitorElement* Track_VtxZ = nullptr; // z0 distrubtion for tracks + MonitorElement* Track_Chi2Dof = nullptr; // chi2 distrubtion for tracks + MonitorElement* Track_BendChi2 = nullptr; // bend chi2 distrubtion for tracks + MonitorElement* Track_NStubs = nullptr; // nstubs distrubtion for tracks + MonitorElement* Track_NPSstubs = nullptr; // nPS stubs distrubtion for tracks + + MonitorElement* TkMET_QualityCuts = nullptr; //Matches the quality cuts in the producer + MonitorElement* TkMET_PU = nullptr; + + private: + edm::ParameterSet conf_; + // edm::EDGetTokenT< l1t::VertexCollection > pvToken; + edm::EDGetTokenT< l1t::TkPrimaryVertexCollection > pvToken; + edm::EDGetTokenT > > ttTrackToken_; + + float maxZ0; // in cm + float DeltaZ; // in cm + float maxEta; + float chi2dofMax; + float bendchi2Max; + float minPt; // in GeV + int nStubsmin; + int nStubsPSmin; // minimum number of stubs in PS modules + float maxPt; // in GeV + int HighPtTracks; // saturate or truncate + + std::string topFolderName_; +}; +#endif + diff --git a/DQMOffline/L1Trigger/src/L1TPhase2OuterTrackerTkMET.cc b/DQMOffline/L1Trigger/src/L1TPhase2OuterTrackerTkMET.cc new file mode 100644 index 0000000000000..d51c317443a84 --- /dev/null +++ b/DQMOffline/L1Trigger/src/L1TPhase2OuterTrackerTkMET.cc @@ -0,0 +1,252 @@ +// Package: SiOuterTracker +// Class: SiOuterTracker +// +// Author: Emily MacDonald (emily.kaelyn.macdonald@cern.ch) + +// system include files +#include +#include +#include +#include +#include +#include + +// user include files +#include "DataFormats/Common/interface/DetSetVector.h" +#include "DataFormats/Common/interface/DetSetVectorNew.h" +#include "DataFormats/Common/interface/Ptr.h" +#include "DataFormats/Common/interface/Ref.h" +#include "DataFormats/L1TrackTrigger/interface/TTCluster.h" +#include "DataFormats/L1TrackTrigger/interface/TTStub.h" +#include "DataFormats/L1TrackTrigger/interface/TTTrack.h" +#include "DataFormats/SiStripDetId/interface/StripSubdetector.h" +#include "DataFormats/TrackerCommon/interface/TrackerTopology.h" + +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "Geometry/Records/interface/TrackerDigiGeometryRecord.h" +#include "Geometry/CommonDetUnit/interface/GeomDet.h" +#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h" +#include "Geometry/TrackerGeometryBuilder/interface/StripGeomDetUnit.h" +#include "SimDataFormats/TrackingAnalysis/interface/TrackingParticle.h" +#include "SimTracker/TrackTriggerAssociation/interface/TTStubAssociationMap.h" +#include "SimTracker/TrackTriggerAssociation/interface/TTTrackAssociationMap.h" +#include "SimTracker/TrackTriggerAssociation/interface/TTClusterAssociationMap.h" + + +#include "DQMOffline/L1Trigger/interface/L1TPhase2OuterTrackerTkMET.h" + + +// constructors and destructor +L1TPhase2OuterTrackerTkMET::L1TPhase2OuterTrackerTkMET(const edm::ParameterSet& iConfig) +:conf_(iConfig) +{ + topFolderName_ = conf_.getParameter("TopFolderName"); + ttTrackToken_ = consumes< std::vector < TTTrack< Ref_Phase2TrackerDigi_ > > > (conf_.getParameter("TTTracksTag")); + // pvToken = consumes< l1t::VertexCollection > (conf_.getParameter("L1VertexInputTag")); + pvToken = consumes< l1t::TkPrimaryVertexCollection > (conf_.getParameter("L1VertexInputTag")); + + maxZ0 = conf_.getParameter("maxZ0"); + DeltaZ = conf_.getParameter("DeltaZ"); + chi2dofMax = conf_.getParameter("chi2dofMax"); + bendchi2Max = conf_.getParameter("bendchi2Max"); + minPt = conf_.getParameter("minPt"); + nStubsmin = iConfig.getParameter("nStubsmin"); + nStubsPSmin = iConfig.getParameter("nStubsPSmin"); + maxPt = conf_.getParameter("maxPt"); + maxEta = conf_.getParameter("maxEta"); + HighPtTracks = iConfig.getParameter("HighPtTracks"); +} + +L1TPhase2OuterTrackerTkMET::~L1TPhase2OuterTrackerTkMET() +{ + // do anything here that needs to be done at desctruction time + // (e.g. close files, deallocate resources etc.) +} + +// member functions + +// ------------ method called for each event ------------ +void L1TPhase2OuterTrackerTkMET::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { + // L1 Primaries + edm::Handle< l1t::TkPrimaryVertexCollection > L1VertexHandle; + iEvent.getByToken(pvToken,L1VertexHandle); + + edm::Handle< std::vector< TTTrack< Ref_Phase2TrackerDigi_ > > > TTTrackHandle; + iEvent.getByToken(ttTrackToken_, TTTrackHandle); + + // for PS stubs + // Tracker Topology + edm::ESHandle tTopoHandle_; + iSetup.get().get(tTopoHandle_); + const TrackerTopology* tTopo = tTopoHandle_.product(); + + // Adding protection + if ( !TTTrackHandle.isValid()) { + std::cout<<"cant find tracks"<begin()->z0(); + float zVTX = L1VertexHandle->begin()->zvertex(); + unsigned int tkCnt = 0; + for (auto trackIter: *TTTrackHandle) { + edm::Ptr< TTTrack< Ref_Phase2TrackerDigi_ > > tempTrackPtr(TTTrackHandle, tkCnt++); /// Make the pointer + float pt = tempTrackPtr->momentum().perp(); + float phi = tempTrackPtr->momentum().phi(); + float eta = tempTrackPtr->momentum().eta(); + std::vector< edm::Ref< edmNew::DetSetVector< TTStub< Ref_Phase2TrackerDigi_ > >, TTStub< Ref_Phase2TrackerDigi_ > > > theStubs = trackIter.getStubRefs() ; + int nstubs = (int) theStubs.size(); + + float chi2dof = tempTrackPtr->chi2Red(); + float bendchi2 = tempTrackPtr->stubPtConsistency(); + float z0 = tempTrackPtr->z0(); + + if (pt < minPt || fabs(z0) > maxZ0 || fabs(eta) > maxEta || chi2dof > chi2dofMax || bendchi2 > bendchi2Max) continue; + if ( maxPt > 0 && pt > maxPt) { + if (HighPtTracks == 0) continue; // ignore these very high PT tracks: truncate + if (HighPtTracks == 1) pt = maxPt; // saturate + } + + int nPS = 0.; // number of stubs in PS modules + // loop over the stubs + for (unsigned int istub=0; istub<(unsigned int)theStubs.size(); istub++) { + DetId detId( theStubs.at(istub)->getDetId() ); + if (detId.det() == DetId::Detector::Tracker) { + if ( (detId.subdetId() == StripSubdetector::TOB && tTopo->tobLayer(detId) <= 3) || (detId.subdetId() == StripSubdetector::TID && tTopo->tidRing(detId) <= 9) ) nPS++; + } + } + + if (nstubs < nStubsmin || nPS < nStubsPSmin) continue; + + // construct deltaZ cut to be based on track eta + if ( fabs(eta)>=0 && fabs(eta)<0.7) DeltaZ = 0.4; + else if ( fabs(eta)>=0.7 && fabs(eta)<1.0) DeltaZ = 0.6; + else if ( fabs(eta)>=1.0 && fabs(eta)<1.2) DeltaZ = 0.76; + else if ( fabs(eta)>=1.2 && fabs(eta)<1.6) DeltaZ = 1.0; + else if ( fabs(eta)>=1.6 && fabs(eta)<2.0) DeltaZ = 1.7; + else if ( fabs(eta)>=2.0 && fabs(eta)<=2.4) DeltaZ = 2.2; + + if ( fabs(z0 - zVTX) <= DeltaZ) { + nTracks_counter++; + Track_Pt->Fill(pt); + Track_NStubs->Fill(nstubs); + Track_NPSstubs->Fill(nPS); + Track_Eta->Fill(eta); + Track_VtxZ->Fill(z0); + Track_Chi2Dof->Fill(chi2dof); + Track_BendChi2->Fill(bendchi2); + + sumPx += pt*cos(phi); + sumPy += pt*sin(phi); + etTot += pt ; + } + else { // PU sums + sumPx_PU += pt*cos(phi); + sumPy_PU += pt*sin(phi); + etTot_PU += pt ; + } + } // end loop over tracks + + Track_N->Fill(nTracks_counter); + float et = sqrt( sumPx*sumPx + sumPy*sumPy ); + double etmiss_PU = sqrt( sumPx_PU*sumPx_PU + sumPy_PU*sumPy_PU ); + + math::XYZTLorentzVector missingEt( -sumPx, -sumPy, 0, et); + + TkMET_QualityCuts->Fill(missingEt.Pt()); + TkMET_PU->Fill(etmiss_PU); + +} // end of method + +// ------------ method called once each job just before starting event loop ------------ +//Creating all histograms for DQM file output +void L1TPhase2OuterTrackerTkMET::bookHistograms(DQMStore::IBooker &iBooker, edm::Run const & run, edm::EventSetup const & es) { + std::string HistoName; + iBooker.setCurrentFolder(topFolderName_+"/TkMET_Tracks/"); + + + // Num of L1Tracks in tkMET selection + HistoName = "Track_N"; + edm::ParameterSet psTrack_N = conf_.getParameter("TH1_NTracks"); + Track_N = iBooker.book1D(HistoName, HistoName, psTrack_N.getParameter("Nbinsx"), psTrack_N.getParameter("xmin"), psTrack_N.getParameter("xmax")); + Track_N->setAxisTitle("# L1 Tracks", 1); + Track_N->setAxisTitle("# Events", 2); + + //Pt of the tracks + edm::ParameterSet psTrack_Pt = conf_.getParameter("TH1_Track_Pt"); + HistoName = "Track_Pt"; + Track_Pt = iBooker.book1D(HistoName, HistoName, psTrack_Pt.getParameter("Nbinsx"), psTrack_Pt.getParameter("xmin"), psTrack_Pt.getParameter("xmax")); + Track_Pt->setAxisTitle("p_{T} [GeV]", 1); + Track_Pt->setAxisTitle("# L1 Tracks", 2); + + + //Eta + edm::ParameterSet psTrack_Eta = conf_.getParameter("TH1_Track_Eta"); + HistoName = "Track_Eta"; + Track_Eta = iBooker.book1D(HistoName, HistoName, psTrack_Eta.getParameter("Nbinsx"), psTrack_Eta.getParameter("xmin"), psTrack_Eta.getParameter("xmax")); + Track_Eta->setAxisTitle("#eta", 1); + Track_Eta->setAxisTitle("# L1 Tracks", 2); + + //VtxZ + edm::ParameterSet psTrack_VtxZ = conf_.getParameter("TH1_Track_VtxZ"); + HistoName = "Track_VtxZ"; + Track_VtxZ = iBooker.book1D(HistoName, HistoName, psTrack_VtxZ.getParameter("Nbinsx"), psTrack_VtxZ.getParameter("xmin"), psTrack_VtxZ.getParameter("xmax")); + Track_VtxZ->setAxisTitle("L1 Track vertex position z [cm]", 1); + Track_VtxZ->setAxisTitle("# L1 Tracks", 2); + + //chi2dof + edm::ParameterSet psTrack_Chi2Dof = conf_.getParameter("TH1_Track_Chi2Dof"); + HistoName = "Track_Chi2Dof"; + Track_Chi2Dof = iBooker.book1D(HistoName, HistoName, psTrack_Chi2Dof.getParameter("Nbinsx"), psTrack_Chi2Dof.getParameter("xmin"), psTrack_Chi2Dof.getParameter("xmax")); + Track_Chi2Dof->setAxisTitle("L1 Track #chi^{2}/D.O.F.", 1); + Track_Chi2Dof->setAxisTitle("# L1 Tracks", 2); + + //bend chi2 + edm::ParameterSet psTrack_BendChi2 = conf_.getParameter("TH1_Track_BendChi2"); + HistoName = "Track_BendChi2"; + Track_BendChi2 = iBooker.book1D(HistoName, HistoName, psTrack_BendChi2.getParameter("Nbinsx"), psTrack_BendChi2.getParameter("xmin"), psTrack_BendChi2.getParameter("xmax")); + Track_BendChi2->setAxisTitle("L1 Track Bend #chi^{2}", 1); + Track_BendChi2->setAxisTitle("# L1 Tracks", 2); + + //nstubs + edm::ParameterSet psTrack_NStubs = conf_.getParameter("TH1_Track_NStubs"); + HistoName = "Track_NStubs"; + Track_NStubs = iBooker.book1D(HistoName, HistoName, psTrack_NStubs.getParameter("Nbinsx"), psTrack_NStubs.getParameter("xmin"), psTrack_NStubs.getParameter("xmax")); + Track_NStubs->setAxisTitle("# L1 Stubs", 1); + Track_NStubs->setAxisTitle("# L1 Tracks", 2); + + //nPSstubs + edm::ParameterSet psTrack_NPSstubs = conf_.getParameter("TH1_Track_NPSstubs"); + HistoName = "Track_NPSstubs"; + Track_NPSstubs = iBooker.book1D(HistoName, HistoName, psTrack_NPSstubs.getParameter("Nbinsx"), psTrack_NPSstubs.getParameter("xmin"), psTrack_NPSstubs.getParameter("xmax")); + Track_NPSstubs->setAxisTitle("# PS Stubs", 1); + Track_NPSstubs->setAxisTitle("# L1 Tracks", 2); + + iBooker.setCurrentFolder(topFolderName_+"/TkMET"); + //loose tkMET + edm::ParameterSet psTrack_TkMET = conf_.getParameter("TH1_Track_TkMET"); + HistoName = "TkMET_QualityCuts"; + TkMET_QualityCuts = iBooker.book1D(HistoName, HistoName, psTrack_TkMET.getParameter("Nbinsx"), psTrack_TkMET.getParameter("xmin"), psTrack_TkMET.getParameter("xmax")); + TkMET_QualityCuts->setAxisTitle("L1 Track MET [GeV]", 1); + TkMET_QualityCuts->setAxisTitle("# Events", 2); + + //tkMET -- PU only + HistoName = "TkMET_PU"; + TkMET_PU = iBooker.book1D(HistoName, HistoName, psTrack_TkMET.getParameter("Nbinsx"), psTrack_TkMET.getParameter("xmin"), psTrack_TkMET.getParameter("xmax")); + TkMET_PU->setAxisTitle("L1 Track MET (PU only) [GeV]", 1); + TkMET_PU->setAxisTitle("# Events", 2); +} //end of method + +DEFINE_FWK_MODULE(L1TPhase2OuterTrackerTkMET); From c558f6ad8759af291b55059f88f049568051860c Mon Sep 17 00:00:00 2001 From: Dylan Date: Wed, 20 Oct 2021 07:51:15 -0500 Subject: [PATCH 3/7] removing extra files --- .../interface/L1TPhase2OTTrackJetsandMHT.h | 93 ------- .../src/L1TPhase2OTTrackJetsandMHT.cc | 259 ------------------ 2 files changed, 352 deletions(-) delete mode 100644 DQMOffline/L1Trigger/interface/L1TPhase2OTTrackJetsandMHT.h delete mode 100644 DQMOffline/L1Trigger/src/L1TPhase2OTTrackJetsandMHT.cc diff --git a/DQMOffline/L1Trigger/interface/L1TPhase2OTTrackJetsandMHT.h b/DQMOffline/L1Trigger/interface/L1TPhase2OTTrackJetsandMHT.h deleted file mode 100644 index 6f451f2b80fd2..0000000000000 --- a/DQMOffline/L1Trigger/interface/L1TPhase2OTTrackJetsandMHT.h +++ /dev/null @@ -1,93 +0,0 @@ -#ifndef L1TPhase2_OTTrackJetsandMHT_h -#define L1TPhase2_OTTrackJetsandMHT_h - -#include -#include -#include -#include "FWCore/Utilities/interface/EDGetToken.h" -#include "FWCore/Framework/interface/Frameworkfwd.h" -#include "FWCore/Framework/interface/EDAnalyzer.h" -#include "DQMServices/Core/interface/MonitorElement.h" -#include "DQMServices/Core/interface/DQMEDAnalyzer.h" -#include "FWCore/ParameterSet/interface/ParameterSet.h" -#include "FWCore/Framework/interface/Event.h" -#include "FWCore/Framework/interface/MakerMacros.h" -#include "FWCore/Framework/interface/ESHandle.h" -#include "DataFormats/Common/interface/DetSetVectorNew.h" -#include "DataFormats/L1TrackTrigger/interface/TTTypes.h" -// #include "DataFormats/L1TVertex/interface/Vertex.h" -#include "DataFormats/L1TCorrelator/interface/TkPrimaryVertex.h" - -#include "DataFormats/L1TCorrelator/interface/TkJet.h" -#include "DataFormats/L1TCorrelator/interface/TkJetFwd.h" -#include "DataFormats/L1TCorrelator/interface/TkHTMiss.h" -#include "DataFormats/L1TCorrelator/interface/TkHTMissFwd.h" - - - -class DQMStore; - -class L1TPhase2OTTrackJetsandMHT : public DQMEDAnalyzer { - -public: - explicit L1TPhase2OTTrackJetsandMHT(const edm::ParameterSet&); - ~L1TPhase2OTTrackJetsandMHT() override; - void analyze(const edm::Event&, const edm::EventSetup&) override; - void bookHistograms(DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override; - - //All track jets - MonitorElement* allJets_pt = nullptr; // pt of jet - MonitorElement* allJets_eta = nullptr; // eta of jet - MonitorElement* allJets_phi = nullptr; // phi of jet - MonitorElement* allJets_vtx = nullptr; // vtx of jet - MonitorElement* allJets_nTracks = nullptr; // num of tracks that went into jet - MonitorElement* allJets_nTightTracks = nullptr; // num of tight tracks that went into jet - MonitorElement* allJets_nDisplacedTracks = nullptr; // num of displaced tracks that went into jet - MonitorElement* allJets_nTightDispTracks = nullptr; // num of tight displaced tracks that went into jet - - // m_2ltrkjet_vz->push_back(jetIter->jetVtx()); - // m_2ltrkjet_ntracks->push_back(jetIter->ntracks()); - // m_2ltrkjet_phi->push_back(jetIter->phi()); - // m_2ltrkjet_eta->push_back(jetIter->eta()); - // m_2ltrkjet_pt->push_back(jetIter->pt()); - // m_2ltrkjet_p->push_back(jetIter->p()); - // m_2ltrkjet_nDisplaced->push_back(jetIter->nDisptracks()); - // m_2ltrkjet_nTight->push_back(jetIter->nTighttracks()); - // m_2ltrkjet_nTightDisplaced->push_back(jetIter->nTightDisptracks()); - - - //Jets used in HT and MHT (pT, eta, and NTracks cuts) - MonitorElement* HTJets_pt = nullptr; // pt of jet - MonitorElement* HTJets_eta = nullptr; // eta of jet - MonitorElement* HTJets_phi = nullptr; // phi of jet - MonitorElement* HTJets_vtx = nullptr; // vtx of jet - MonitorElement* HTJets_nTracks = nullptr; // num of tracks that went into jet - MonitorElement* HTJets_nTightTracks = nullptr; // num of tight tracks that went into jet - MonitorElement* HTJets_nDisplacedTracks = nullptr; // num of displaced tracks that went into jet - MonitorElement* HTJets_nTightDispTracks = nullptr; // num of tight displaced tracks that went into jet - - //MHT - MonitorElement* h_MHT = nullptr; // MHT of event from track jets - - //HT - MonitorElement* h_HT = nullptr; // HT of event from track jets - - - private: - edm::ParameterSet conf_; - - float jet_minPt; // [GeV] - float jet_maxEta; // [rad] - //const edm::EDGetTokenT< L1TkPrimaryVertexCollection > pvToken; - edm::EDGetTokenT< l1t::TkJetCollection > jetToken; - - //const edm::EDGetTokenT< std::vector< l1t::L1TkJetParticle > > jetToken; - - - unsigned int minNtracksHighPt; - unsigned int minNtracksLowPt; - - - std::string topFolderName_; -}; -#endif diff --git a/DQMOffline/L1Trigger/src/L1TPhase2OTTrackJetsandMHT.cc b/DQMOffline/L1Trigger/src/L1TPhase2OTTrackJetsandMHT.cc deleted file mode 100644 index e7a8a48e8e1dc..0000000000000 --- a/DQMOffline/L1Trigger/src/L1TPhase2OTTrackJetsandMHT.cc +++ /dev/null @@ -1,259 +0,0 @@ -// Package: SiOuterTracker -// Class: SiOuterTracker -// -// Author: Emily MacDonald (emily.kaelyn.macdonald@cern.ch) - -// system include files -#include -#include -#include -#include -#include -#include - -// user include files -#include "DataFormats/Common/interface/DetSetVector.h" -#include "DataFormats/Common/interface/DetSetVectorNew.h" -#include "DataFormats/Common/interface/Ptr.h" -#include "DataFormats/Common/interface/Ref.h" -#include "DataFormats/L1Trigger/interface/Jet.h" -#include "DataFormats/SiStripDetId/interface/StripSubdetector.h" -#include "DataFormats/TrackerCommon/interface/TrackerTopology.h" -#include "FWCore/MessageLogger/interface/MessageLogger.h" -#include "FWCore/ServiceRegistry/interface/Service.h" -#include "Geometry/Records/interface/TrackerDigiGeometryRecord.h" -#include "Geometry/CommonDetUnit/interface/GeomDet.h" -#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h" -#include "Geometry/TrackerGeometryBuilder/interface/StripGeomDetUnit.h" - -#include "DataFormats/L1TCorrelator/interface/TkJet.h" -#include "DataFormats/L1TCorrelator/interface/TkJetFwd.h" -#include "DataFormats/L1TCorrelator/interface/TkHTMiss.h" -#include "DataFormats/L1TCorrelator/interface/TkHTMissFwd.h" - -#include "DQMOffline/L1Trigger/interface/L1TPhase2OTTrackJetsandMHT.h" - - -// constructors and destructor -L1TPhase2OTTrackJetsandMHT::L1TPhase2OTTrackJetsandMHT(const edm::ParameterSet& iConfig) -:conf_(iConfig) -{ - topFolderName_ = conf_.getParameter("TopFolderName"); - jetToken = consumes< l1t::TkJetCollection > (conf_.getParameter("L1TkJetInputTag")); - jet_minPt = conf_.getParameter("jet_minPt"); - jet_maxEta = conf_.getParameter("jet_maxEta"); - minNtracksHighPt = conf_.getParameter("jet_minNtracksHighPt"); - minNtracksLowPt = conf_.getParameter("jet_minNtracksLowPt"); -} - -L1TPhase2OTTrackJetsandMHT::~L1TPhase2OTTrackJetsandMHT() -{ - // do anything here that needs to be done at desctruction time - // (e.g. close files, deallocate resources etc.) -} - -// member functions - -// ------------ method called for each event ------------ -void L1TPhase2OTTrackJetsandMHT::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { - edm::Handle< l1t::TkJetCollection > L1TkJetsHandle; - iEvent.getByToken(jetToken, L1TkJetsHandle); - std::vector< l1t::TkJet >::const_iterator jetIter; - - if ( ! L1TkJetsHandle.isValid() ) { - edm::LogWarning("DataNotFound")<< "\nWarning: L1TkJetParticleCollection not found in the event. Exit"<< std::endl; - return; - } - float sumPx = 0; - float sumPy = 0; - float tmp_HT = 0; - - // loop over jets - for (jetIter = L1TkJetsHandle->begin(); jetIter != L1TkJetsHandle->end(); ++jetIter) { - - float px = jetIter->px(); - float py = jetIter->py(); - float et = jetIter->et(); - float tmp_jet_pt = jetIter->pt(); - float tmp_jet_eta = jetIter->eta(); - float tmp_jet_phi = jetIter->phi(); - float tmp_jet_vtx = jetIter->jetVtx(); - float tmp_jet_ntracks = jetIter->ntracks(); - float tmp_jet_nTighttracks = jetIter->nTighttracks(); - float tmp_jet_nDisplacedtracks = jetIter->nDisptracks(); - float tmp_jet_nTightDisptracks = jetIter->nTightDisptracks(); - - allJets_pt->Fill(tmp_jet_pt); - allJets_eta->Fill(tmp_jet_eta); - allJets_phi->Fill(tmp_jet_phi); - allJets_vtx->Fill(tmp_jet_vtx); - allJets_nTracks->Fill(tmp_jet_ntracks); - allJets_nTightTracks->Fill(tmp_jet_nTighttracks); - allJets_nDisplacedTracks->Fill(tmp_jet_nDisplacedtracks); - allJets_nTightDispTracks->Fill(tmp_jet_nTightDisptracks); - - if (tmp_jet_pt < jet_minPt) continue; - if (fabs(tmp_jet_eta) > jet_maxEta) continue; - if(tmp_jet_ntracks50)continue; - if(tmp_jet_ntracks100)continue; - - HTJets_pt->Fill(tmp_jet_pt); - HTJets_eta->Fill(tmp_jet_eta); - HTJets_phi->Fill(tmp_jet_phi); - HTJets_vtx->Fill(tmp_jet_vtx); - HTJets_nTracks->Fill(tmp_jet_ntracks); - HTJets_nTightTracks->Fill(tmp_jet_nTighttracks); - HTJets_nDisplacedTracks->Fill(tmp_jet_nDisplacedtracks); - HTJets_nTightDispTracks->Fill(tmp_jet_nTightDisptracks); - - sumPx += px; - sumPy += py; - tmp_HT += tmp_jet_pt; - } // end jet loop - - // float tmp_MHT = sqrt(sumPx*sumPx + sumPy*sumPy); - // define missing HT - float et = sqrt(sumPx*sumPx + sumPy*sumPy); - math::XYZTLorentzVector missingEt(-sumPx, -sumPy, 0, et); - // edm::RefProd jetCollRef(L1TkJetsHandle); - // edm::Ref< l1t::TkPrimaryVertexCollection > L1VtxRef; // null reference - // l1t::TkHTMiss tkMHT(missingEt, tmp_HT, jetCollRef, L1VtxRef); - double MHT = missingEt.Pt(); - double HT = tmp_HT; - h_MHT->Fill(MHT); - h_HT->Fill(HT); - -} // end of method - -// ------------ method called once each job just before starting event loop ------------ -//Creating all histograms for DQM file output -void L1TPhase2OTTrackJetsandMHT::bookHistograms(DQMStore::IBooker &iBooker, edm::Run const & run, edm::EventSetup const & es) { - std::string HistoName; - - iBooker.setCurrentFolder(topFolderName_+"/TrackJets/AllJets"); - - // Num of tracks in track jet - HistoName = "NTracks"; - edm::ParameterSet psTrack_N = conf_.getParameter("TH1_NTracks"); - allJets_nTracks = iBooker.book1D(HistoName, HistoName, psTrack_N.getParameter("Nbinsx"), psTrack_N.getParameter("xmin"), psTrack_N.getParameter("xmax")); - allJets_nTracks->setAxisTitle("# Tracks per jet", 1); - allJets_nTracks->setAxisTitle("# Events", 2); - - // Num of tight tracks in track jet - HistoName = "NTightTracks"; - allJets_nTightTracks = iBooker.book1D(HistoName, HistoName, psTrack_N.getParameter("Nbinsx"), psTrack_N.getParameter("xmin"), psTrack_N.getParameter("xmax")); - allJets_nTightTracks->setAxisTitle("# Tight tracks per jet", 1); - allJets_nTightTracks->setAxisTitle("# Events", 2); - - // Num of displaced tracks in track jet - HistoName = "NDisplacedTracks"; - allJets_nDisplacedTracks = iBooker.book1D(HistoName, HistoName, psTrack_N.getParameter("Nbinsx"), psTrack_N.getParameter("xmin"), psTrack_N.getParameter("xmax")); - allJets_nDisplacedTracks->setAxisTitle("# Displaced tracks per jet", 1); - allJets_nDisplacedTracks->setAxisTitle("# Events", 2); - - // Num of tight displaced tracks in track jet - HistoName = "NTightDispTracks"; - allJets_nTightDispTracks = iBooker.book1D(HistoName, HistoName, psTrack_N.getParameter("Nbinsx"), psTrack_N.getParameter("xmin"), psTrack_N.getParameter("xmax")); - allJets_nTightDispTracks->setAxisTitle("# Tight displaced tracks per jet", 1); - allJets_nTightDispTracks->setAxisTitle("# Events", 2); - - //Pt of jets - edm::ParameterSet psJet_Pt = conf_.getParameter("TH1_Jet_Pt"); - HistoName = "Jet_Pt"; - allJets_pt = iBooker.book1D(HistoName, HistoName, psJet_Pt.getParameter("Nbinsx"), psJet_Pt.getParameter("xmin"), psJet_Pt.getParameter("xmax")); - allJets_pt->setAxisTitle("p_{T} [GeV]", 1); - allJets_pt->setAxisTitle("# Track Jets", 2); - - //Eta - edm::ParameterSet psJet_Eta = conf_.getParameter("TH1_Jet_Eta"); - HistoName = "Track_Eta"; - allJets_eta = iBooker.book1D(HistoName, HistoName, psJet_Eta.getParameter("Nbinsx"), psJet_Eta.getParameter("xmin"), psJet_Eta.getParameter("xmax")); - allJets_eta->setAxisTitle("#eta", 1); - allJets_eta->setAxisTitle("# Track Jets", 2); - - //Phi - edm::ParameterSet psJet_Phi = conf_.getParameter("TH1_Jet_Phi"); - HistoName = "Track_Phi"; - allJets_phi = iBooker.book1D(HistoName, HistoName, psJet_Phi.getParameter("Nbinsx"), psJet_Phi.getParameter("xmin"), psJet_Phi.getParameter("xmax")); - allJets_phi->setAxisTitle("#phi", 1); - allJets_phi->setAxisTitle("# Track Jets", 2); - - //Vtx - edm::ParameterSet psJet_Vtx = conf_.getParameter("TH1_Jet_Vtx"); - HistoName = "Jet_Vtx"; - allJets_vtx = iBooker.book1D(HistoName, HistoName, psJet_Vtx.getParameter("Nbinsx"), psJet_Vtx.getParameter("xmin"), psJet_Vtx.getParameter("xmax")); - allJets_vtx->setAxisTitle("Track Jet vertex position z [cm]", 1); - allJets_vtx->setAxisTitle("# Track Jets", 2); - - - - iBooker.setCurrentFolder(topFolderName_+"/TrackJets/HTJets"); - - // Num of tracks in track jet - HistoName = "NTracks"; - HTJets_nTracks = iBooker.book1D(HistoName, HistoName, psTrack_N.getParameter("Nbinsx"), psTrack_N.getParameter("xmin"), psTrack_N.getParameter("xmax")); - HTJets_nTracks->setAxisTitle("# Tracks per jet", 1); - HTJets_nTracks->setAxisTitle("# Events", 2); - - // Num of tight tracks in track jet - HistoName = "NTightTracks"; - HTJets_nTightTracks = iBooker.book1D(HistoName, HistoName, psTrack_N.getParameter("Nbinsx"), psTrack_N.getParameter("xmin"), psTrack_N.getParameter("xmax")); - HTJets_nTightTracks->setAxisTitle("# Tight tracks per jet", 1); - HTJets_nTightTracks->setAxisTitle("# Events", 2); - - // Num of displaced tracks in track jet - HistoName = "NDisplacedTracks"; - HTJets_nDisplacedTracks = iBooker.book1D(HistoName, HistoName, psTrack_N.getParameter("Nbinsx"), psTrack_N.getParameter("xmin"), psTrack_N.getParameter("xmax")); - HTJets_nDisplacedTracks->setAxisTitle("# Displaced tracks per jet", 1); - HTJets_nDisplacedTracks->setAxisTitle("# Events", 2); - - // Num of tight displaced tracks in track jet - HistoName = "NTightDispTracks"; - HTJets_nTightDispTracks = iBooker.book1D(HistoName, HistoName, psTrack_N.getParameter("Nbinsx"), psTrack_N.getParameter("xmin"), psTrack_N.getParameter("xmax")); - HTJets_nTightDispTracks->setAxisTitle("# Tight displaced tracks per jet", 1); - HTJets_nTightDispTracks->setAxisTitle("# Events", 2); - - //Pt of jets - HistoName = "Jet_Pt"; - HTJets_pt = iBooker.book1D(HistoName, HistoName, psJet_Pt.getParameter("Nbinsx"), psJet_Pt.getParameter("xmin"), psJet_Pt.getParameter("xmax")); - HTJets_pt->setAxisTitle("p_{T} [GeV]", 1); - HTJets_pt->setAxisTitle("# Track Jets", 2); - - //Eta - HistoName = "Track_Eta"; - HTJets_eta = iBooker.book1D(HistoName, HistoName, psJet_Eta.getParameter("Nbinsx"), psJet_Eta.getParameter("xmin"), psJet_Eta.getParameter("xmax")); - HTJets_eta->setAxisTitle("#eta", 1); - HTJets_eta->setAxisTitle("# Track Jets", 2); - - //Phi - HistoName = "Track_Phi"; - HTJets_phi = iBooker.book1D(HistoName, HistoName, psJet_Phi.getParameter("Nbinsx"), psJet_Phi.getParameter("xmin"), psJet_Phi.getParameter("xmax")); - HTJets_phi->setAxisTitle("#phi", 1); - HTJets_phi->setAxisTitle("# Track Jets", 2); - - //Vtx - HistoName = "Jet_Vtx"; - HTJets_vtx = iBooker.book1D(HistoName, HistoName, psJet_Vtx.getParameter("Nbinsx"), psJet_Vtx.getParameter("xmin"), psJet_Vtx.getParameter("xmax")); - HTJets_vtx->setAxisTitle("Track Jet vertex position z [cm]", 1); - HTJets_vtx->setAxisTitle("# Track Jets", 2); - - iBooker.setCurrentFolder(topFolderName_+"/TrackJets"); - - //MHT - HistoName = "MHT"; - edm::ParameterSet psMHT = conf_.getParameter("TH1_MHT"); - h_MHT = iBooker.book1D(HistoName, HistoName, psMHT.getParameter("Nbinsx"), psMHT.getParameter("xmin"), psMHT.getParameter("xmax")); - h_MHT->setAxisTitle("Track Jet MHT [GeV]", 1); - h_MHT->setAxisTitle("#Events", 2); - - //HT - HistoName = "HT"; - edm::ParameterSet psHT = conf_.getParameter("TH1_HT"); - h_HT = iBooker.book1D(HistoName, HistoName, psHT.getParameter("Nbinsx"), psHT.getParameter("xmin"), psHT.getParameter("xmax")); - h_HT->setAxisTitle("Track Jet HT [GeV]", 1); - h_HT->setAxisTitle("#Events", 2); - - -} //end of method - -DEFINE_FWK_MODULE(L1TPhase2OTTrackJetsandMHT); From 244e58460536d1bee902563f1e6428e553d3ed00 Mon Sep 17 00:00:00 2001 From: Dylan Date: Wed, 20 Oct 2021 08:07:41 -0500 Subject: [PATCH 4/7] code checks fixes --- .../interface/L1TPhase2OuterTrackerTkMET.h | 35 ++- .../src/L1TPhase2CorrelatorOffline.cc | 143 +++++++------ .../src/L1TPhase2OuterTrackerTkMET.cc | 202 +++++++++++------- 3 files changed, 214 insertions(+), 166 deletions(-) diff --git a/DQMOffline/L1Trigger/interface/L1TPhase2OuterTrackerTkMET.h b/DQMOffline/L1Trigger/interface/L1TPhase2OuterTrackerTkMET.h index ec18b908bc27c..b7b75b566296f 100644 --- a/DQMOffline/L1Trigger/interface/L1TPhase2OuterTrackerTkMET.h +++ b/DQMOffline/L1Trigger/interface/L1TPhase2OuterTrackerTkMET.h @@ -24,38 +24,37 @@ class L1TPhase2OuterTrackerTkMET : public DQMEDAnalyzer { explicit L1TPhase2OuterTrackerTkMET(const edm::ParameterSet&); ~L1TPhase2OuterTrackerTkMET() override; void analyze(const edm::Event&, const edm::EventSetup&) override; - void bookHistograms(DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override; + void bookHistograms(DQMStore::IBooker&, edm::Run const&, edm::EventSetup const&) override; - MonitorElement* Track_N = nullptr; // Number of tracks per event - MonitorElement* Track_Pt = nullptr; // pT distrubtion for tracks - MonitorElement* Track_Eta = nullptr; // eta distrubtion for tracks - MonitorElement* Track_VtxZ = nullptr; // z0 distrubtion for tracks - MonitorElement* Track_Chi2Dof = nullptr; // chi2 distrubtion for tracks + MonitorElement* Track_N = nullptr; // Number of tracks per event + MonitorElement* Track_Pt = nullptr; // pT distrubtion for tracks + MonitorElement* Track_Eta = nullptr; // eta distrubtion for tracks + MonitorElement* Track_VtxZ = nullptr; // z0 distrubtion for tracks + MonitorElement* Track_Chi2Dof = nullptr; // chi2 distrubtion for tracks MonitorElement* Track_BendChi2 = nullptr; // bend chi2 distrubtion for tracks - MonitorElement* Track_NStubs = nullptr; // nstubs distrubtion for tracks + MonitorElement* Track_NStubs = nullptr; // nstubs distrubtion for tracks MonitorElement* Track_NPSstubs = nullptr; // nPS stubs distrubtion for tracks - MonitorElement* TkMET_QualityCuts = nullptr; //Matches the quality cuts in the producer + MonitorElement* TkMET_QualityCuts = nullptr; //Matches the quality cuts in the producer MonitorElement* TkMET_PU = nullptr; - private: +private: edm::ParameterSet conf_; // edm::EDGetTokenT< l1t::VertexCollection > pvToken; - edm::EDGetTokenT< l1t::TkPrimaryVertexCollection > pvToken; - edm::EDGetTokenT > > ttTrackToken_; + edm::EDGetTokenT pvToken; + edm::EDGetTokenT > > ttTrackToken_; - float maxZ0; // in cm - float DeltaZ; // in cm + float maxZ0; // in cm + float DeltaZ; // in cm float maxEta; float chi2dofMax; float bendchi2Max; - float minPt; // in GeV + float minPt; // in GeV int nStubsmin; - int nStubsPSmin; // minimum number of stubs in PS modules - float maxPt; // in GeV - int HighPtTracks; // saturate or truncate + int nStubsPSmin; // minimum number of stubs in PS modules + float maxPt; // in GeV + int HighPtTracks; // saturate or truncate std::string topFolderName_; }; #endif - diff --git a/DQMOffline/L1Trigger/src/L1TPhase2CorrelatorOffline.cc b/DQMOffline/L1Trigger/src/L1TPhase2CorrelatorOffline.cc index 7d3532146dc07..0c27195724116 100644 --- a/DQMOffline/L1Trigger/src/L1TPhase2CorrelatorOffline.cc +++ b/DQMOffline/L1Trigger/src/L1TPhase2CorrelatorOffline.cc @@ -32,8 +32,8 @@ const std::map L1TPhase2CorrelatorOffline::PlotConfig // // -------------------------------------- Constructor -------------------------------------------- // -L1TPhase2CorrelatorOffline::L1TPhase2CorrelatorOffline(const edm::ParameterSet& ps) : - genJetToken_(consumes>(ps.getUntrackedParameter("genJetsInputTag"))), +L1TPhase2CorrelatorOffline::L1TPhase2CorrelatorOffline(const edm::ParameterSet& ps) + : genJetToken_(consumes>(ps.getUntrackedParameter("genJetsInputTag"))), genParticleToken_( consumes>(ps.getUntrackedParameter("genParticlesInputTag"))), objs_(ps.getParameter("objects")), @@ -92,10 +92,10 @@ L1TPhase2CorrelatorOffline::L1TPhase2CorrelatorOffline(const edm::ParameterSet& for (const std::string& name : reconames) { reco_.emplace_back(L1TPhase2CorrelatorOffline::MultiCollection(objs_, name, consumesCollector()), RecoVars()); } - for (auto &obj : objs_.getParameter>("L1PF")) { + for (auto& obj : objs_.getParameter>("L1PF")) { phase2PFToken_.push_back(consumes>(obj)); } - for (auto &obj : objs_.getParameter>("L1Puppi")) { + for (auto& obj : objs_.getParameter>("L1Puppi")) { phase2PuppiToken_.push_back(consumes>(obj)); } } @@ -111,8 +111,7 @@ L1TPhase2CorrelatorOffline::~L1TPhase2CorrelatorOffline() { // // -------------------------------------- beginRun -------------------------------------------- // -void L1TPhase2CorrelatorOffline::dqmBeginRun(const edm::Run& run, const edm::EventSetup& iSetup) -{ +void L1TPhase2CorrelatorOffline::dqmBeginRun(const edm::Run& run, const edm::EventSetup& iSetup) { edm::LogInfo("L1TPhase2CorrelatorOffline") << "L1TPhase2CorrelatorOffline::beginRun" << std::endl; edm::ESHandle magneticField; @@ -300,11 +299,10 @@ void L1TPhase2CorrelatorOffline::analyze(edm::Event const& e, edm::EventSetup co recopair.second.clear(); } - for (auto& pfToken : phase2PFToken_) { edm::Handle> l1pfs; e.getByToken(pfToken, l1pfs); - + for (const auto& pfc : *l1pfs) { h_L1PF_pt_->Fill(pfc.pt()); h_L1PF_eta_->Fill(pfc.eta()); @@ -420,7 +418,6 @@ void L1TPhase2CorrelatorOffline::bookPhase2CorrelatorHistos(DQMStore::IBooker& i ibooker.setCurrentFolder(respresolFolder_); - h_L1PF_part_ptratio_0p2_vs_pt_barrel_ = ibooker.book2D("L1PFParticlePtRatio0p2VsPtBarrel", "L1 PF Particle L1/Gen (#Delta R < 0.2) vs p_{T}, Barrel", resVsPtDef.nbinsX, @@ -439,14 +436,15 @@ void L1TPhase2CorrelatorOffline::bookPhase2CorrelatorHistos(DQMStore::IBooker& i ptratio_lo, ptratio_hi); - h_L1PF_part_ptratio_0p2_vs_pt_ecnotk_ = ibooker.book2D("L1PFParticlePtRatio0p2VsPtEndcapNoTk", - "L1 PF Particle L1/Gen (#Delta R < 0.2) vs p_{T}, Endcap No Tk", - resVsPtDef.nbinsX, - resVsPtDef.xmin, - resVsPtDef.xmax, - ptratio_nbins, - ptratio_lo, - ptratio_hi); + h_L1PF_part_ptratio_0p2_vs_pt_ecnotk_ = + ibooker.book2D("L1PFParticlePtRatio0p2VsPtEndcapNoTk", + "L1 PF Particle L1/Gen (#Delta R < 0.2) vs p_{T}, Endcap No Tk", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax, + ptratio_nbins, + ptratio_lo, + ptratio_hi); h_L1PF_part_ptratio_0p2_vs_pt_hf_ = ibooker.book2D("L1PFParticlePtRatio0p2VsPtHF", "L1 PF Particle L1/Gen (#Delta R < 0.2) vs p_{T}, HF", @@ -466,23 +464,25 @@ void L1TPhase2CorrelatorOffline::bookPhase2CorrelatorHistos(DQMStore::IBooker& i ptratio_lo, ptratio_hi); - h_L1Puppi_part_ptratio_0p2_vs_pt_barrel_ = ibooker.book2D("L1PUPPIParticlePtRatio0p2VsPtBarrel", - "L1 PUPPI Particle L1/Gen (#Delta R < 0.2) vs p_{T}, Barrel", - resVsPtDef.nbinsX, - resVsPtDef.xmin, - resVsPtDef.xmax, - ptratio_nbins, - ptratio_lo, - ptratio_hi); - - h_L1Puppi_part_ptratio_0p2_vs_pt_endcap_ = ibooker.book2D("L1PUPPIParticlePtRatio0p2VsPtEndcap", - "L1 PUPPI Particle L1/Gen (#Delta R < 0.2) vs p_{T}, Endcap", - resVsPtDef.nbinsX, - resVsPtDef.xmin, - resVsPtDef.xmax, - ptratio_nbins, - ptratio_lo, - ptratio_hi); + h_L1Puppi_part_ptratio_0p2_vs_pt_barrel_ = + ibooker.book2D("L1PUPPIParticlePtRatio0p2VsPtBarrel", + "L1 PUPPI Particle L1/Gen (#Delta R < 0.2) vs p_{T}, Barrel", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax, + ptratio_nbins, + ptratio_lo, + ptratio_hi); + + h_L1Puppi_part_ptratio_0p2_vs_pt_endcap_ = + ibooker.book2D("L1PUPPIParticlePtRatio0p2VsPtEndcap", + "L1 PUPPI Particle L1/Gen (#Delta R < 0.2) vs p_{T}, Endcap", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax, + ptratio_nbins, + ptratio_lo, + ptratio_hi); h_L1Puppi_part_ptratio_0p2_vs_pt_ecnotk_ = ibooker.book2D("L1PUPPIParticlePtRatio0p2VsPtEndcapNoTk", @@ -617,11 +617,12 @@ void L1TPhase2CorrelatorOffline::bookPhase2CorrelatorHistos(DQMStore::IBooker& i resVsPtDef.xmin, resVsPtDef.xmax); - h_L1PF_part_response_0p2_pt_ecnotk_ = ibooker.book1D("L1PFParticleResponse0p2VsPtEndcapNoTk", - "L1 PF Particle Response (#Delta R < 0.2) vs p_{T}, Endcap No Tk", - resVsPtDef.nbinsX, - resVsPtDef.xmin, - resVsPtDef.xmax); + h_L1PF_part_response_0p2_pt_ecnotk_ = + ibooker.book1D("L1PFParticleResponse0p2VsPtEndcapNoTk", + "L1 PF Particle Response (#Delta R < 0.2) vs p_{T}, Endcap No Tk", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); h_L1PF_part_response_0p2_pt_hf_ = ibooker.book1D("L1PFParticleResponse0p2VsPtHF", "L1 PF Particle Response (#Delta R < 0.2) vs p_{T}, HF", @@ -635,17 +636,19 @@ void L1TPhase2CorrelatorOffline::bookPhase2CorrelatorHistos(DQMStore::IBooker& i resVsEtaDef.xmin, resVsEtaDef.xmax); - h_L1Puppi_part_response_0p2_pt_barrel_ = ibooker.book1D("L1PUPPIParticleResponse0p2VsPtBarrel", - "L1 PUPPI Particle Response (#Delta R < 0.2) vs p_{T}, Barrel", - resVsPtDef.nbinsX, - resVsPtDef.xmin, - resVsPtDef.xmax); + h_L1Puppi_part_response_0p2_pt_barrel_ = + ibooker.book1D("L1PUPPIParticleResponse0p2VsPtBarrel", + "L1 PUPPI Particle Response (#Delta R < 0.2) vs p_{T}, Barrel", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); - h_L1Puppi_part_response_0p2_pt_endcap_ = ibooker.book1D("L1PUPPIParticleResponse0p2VsPtEndcap", - "L1 PUPPI Particle Response (#Delta R < 0.2) vs p_{T}, Endcap", - resVsPtDef.nbinsX, - resVsPtDef.xmin, - resVsPtDef.xmax); + h_L1Puppi_part_response_0p2_pt_endcap_ = + ibooker.book1D("L1PUPPIParticleResponse0p2VsPtEndcap", + "L1 PUPPI Particle Response (#Delta R < 0.2) vs p_{T}, Endcap", + resVsPtDef.nbinsX, + resVsPtDef.xmin, + resVsPtDef.xmax); h_L1Puppi_part_response_0p2_pt_ecnotk_ = ibooker.book1D("L1PUPPIParticleResponse0p2VsPtEndcapNoTk", @@ -875,28 +878,26 @@ void L1TPhase2CorrelatorOffline::computeResponseResolution() { h_L1Puppi_jet_response_pt_ecnotk_, h_L1Puppi_jet_response_pt_hf_, h_L1Puppi_jet_response_eta_}; - std::vector monElementstoComputeResol = { - h_L1PF_part_resolution_0p2_pt_barrel_, - h_L1PF_part_resolution_0p2_pt_endcap_, - h_L1PF_part_resolution_0p2_pt_ecnotk_, - h_L1PF_part_resolution_0p2_pt_hf_, - nullptr, - h_L1Puppi_part_resolution_0p2_pt_barrel_, - h_L1Puppi_part_resolution_0p2_pt_endcap_, - h_L1Puppi_part_resolution_0p2_pt_ecnotk_, - h_L1Puppi_part_resolution_0p2_pt_hf_, - nullptr, - h_L1PF_jet_resolution_pt_barrel_, - h_L1PF_jet_resolution_pt_endcap_, - h_L1PF_jet_resolution_pt_ecnotk_, - h_L1PF_jet_resolution_pt_hf_, - nullptr, - h_L1Puppi_jet_resolution_pt_barrel_, - h_L1Puppi_jet_resolution_pt_endcap_, - h_L1Puppi_jet_resolution_pt_ecnotk_, - h_L1Puppi_jet_resolution_pt_hf_, - nullptr - }; + std::vector monElementstoComputeResol = {h_L1PF_part_resolution_0p2_pt_barrel_, + h_L1PF_part_resolution_0p2_pt_endcap_, + h_L1PF_part_resolution_0p2_pt_ecnotk_, + h_L1PF_part_resolution_0p2_pt_hf_, + nullptr, + h_L1Puppi_part_resolution_0p2_pt_barrel_, + h_L1Puppi_part_resolution_0p2_pt_endcap_, + h_L1Puppi_part_resolution_0p2_pt_ecnotk_, + h_L1Puppi_part_resolution_0p2_pt_hf_, + nullptr, + h_L1PF_jet_resolution_pt_barrel_, + h_L1PF_jet_resolution_pt_endcap_, + h_L1PF_jet_resolution_pt_ecnotk_, + h_L1PF_jet_resolution_pt_hf_, + nullptr, + h_L1Puppi_jet_resolution_pt_barrel_, + h_L1Puppi_jet_resolution_pt_endcap_, + h_L1Puppi_jet_resolution_pt_ecnotk_, + h_L1Puppi_jet_resolution_pt_hf_, + nullptr}; for (unsigned int i = 0; i < monElementstoComputeIn.size(); i++) { if (monElementstoComputeIn[i] != nullptr && monElementstoComputeResp[i] != nullptr && diff --git a/DQMOffline/L1Trigger/src/L1TPhase2OuterTrackerTkMET.cc b/DQMOffline/L1Trigger/src/L1TPhase2OuterTrackerTkMET.cc index d51c317443a84..d30de32d7f785 100644 --- a/DQMOffline/L1Trigger/src/L1TPhase2OuterTrackerTkMET.cc +++ b/DQMOffline/L1Trigger/src/L1TPhase2OuterTrackerTkMET.cc @@ -33,18 +33,15 @@ #include "SimTracker/TrackTriggerAssociation/interface/TTTrackAssociationMap.h" #include "SimTracker/TrackTriggerAssociation/interface/TTClusterAssociationMap.h" - #include "DQMOffline/L1Trigger/interface/L1TPhase2OuterTrackerTkMET.h" - // constructors and destructor -L1TPhase2OuterTrackerTkMET::L1TPhase2OuterTrackerTkMET(const edm::ParameterSet& iConfig) -:conf_(iConfig) -{ +L1TPhase2OuterTrackerTkMET::L1TPhase2OuterTrackerTkMET(const edm::ParameterSet& iConfig) : conf_(iConfig) { topFolderName_ = conf_.getParameter("TopFolderName"); - ttTrackToken_ = consumes< std::vector < TTTrack< Ref_Phase2TrackerDigi_ > > > (conf_.getParameter("TTTracksTag")); + ttTrackToken_ = + consumes > >(conf_.getParameter("TTTracksTag")); // pvToken = consumes< l1t::VertexCollection > (conf_.getParameter("L1VertexInputTag")); - pvToken = consumes< l1t::TkPrimaryVertexCollection > (conf_.getParameter("L1VertexInputTag")); + pvToken = consumes(conf_.getParameter("L1VertexInputTag")); maxZ0 = conf_.getParameter("maxZ0"); DeltaZ = conf_.getParameter("DeltaZ"); @@ -58,8 +55,7 @@ L1TPhase2OuterTrackerTkMET::L1TPhase2OuterTrackerTkMET(const edm::ParameterSet& HighPtTracks = iConfig.getParameter("HighPtTracks"); } -L1TPhase2OuterTrackerTkMET::~L1TPhase2OuterTrackerTkMET() -{ +L1TPhase2OuterTrackerTkMET::~L1TPhase2OuterTrackerTkMET() { // do anything here that needs to be done at desctruction time // (e.g. close files, deallocate resources etc.) } @@ -69,10 +65,10 @@ L1TPhase2OuterTrackerTkMET::~L1TPhase2OuterTrackerTkMET() // ------------ method called for each event ------------ void L1TPhase2OuterTrackerTkMET::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { // L1 Primaries - edm::Handle< l1t::TkPrimaryVertexCollection > L1VertexHandle; - iEvent.getByToken(pvToken,L1VertexHandle); + edm::Handle L1VertexHandle; + iEvent.getByToken(pvToken, L1VertexHandle); - edm::Handle< std::vector< TTTrack< Ref_Phase2TrackerDigi_ > > > TTTrackHandle; + edm::Handle > > TTTrackHandle; iEvent.getByToken(ttTrackToken_, TTTrackHandle); // for PS stubs @@ -82,12 +78,12 @@ void L1TPhase2OuterTrackerTkMET::analyze(const edm::Event& iEvent, const edm::Ev const TrackerTopology* tTopo = tTopoHandle_.product(); // Adding protection - if ( !TTTrackHandle.isValid()) { - std::cout<<"cant find tracks"<begin()->z0(); float zVTX = L1VertexHandle->begin()->zvertex(); unsigned int tkCnt = 0; - for (auto trackIter: *TTTrackHandle) { - edm::Ptr< TTTrack< Ref_Phase2TrackerDigi_ > > tempTrackPtr(TTTrackHandle, tkCnt++); /// Make the pointer + for (const auto& trackIter : *TTTrackHandle) { + edm::Ptr > tempTrackPtr(TTTrackHandle, tkCnt++); /// Make the pointer float pt = tempTrackPtr->momentum().perp(); float phi = tempTrackPtr->momentum().phi(); float eta = tempTrackPtr->momentum().eta(); - std::vector< edm::Ref< edmNew::DetSetVector< TTStub< Ref_Phase2TrackerDigi_ > >, TTStub< Ref_Phase2TrackerDigi_ > > > theStubs = trackIter.getStubRefs() ; - int nstubs = (int) theStubs.size(); + std::vector >, TTStub > > + theStubs = trackIter.getStubRefs(); + int nstubs = (int)theStubs.size(); float chi2dof = tempTrackPtr->chi2Red(); float bendchi2 = tempTrackPtr->stubPtConsistency(); - float z0 = tempTrackPtr->z0(); - - if (pt < minPt || fabs(z0) > maxZ0 || fabs(eta) > maxEta || chi2dof > chi2dofMax || bendchi2 > bendchi2Max) continue; - if ( maxPt > 0 && pt > maxPt) { - if (HighPtTracks == 0) continue; // ignore these very high PT tracks: truncate - if (HighPtTracks == 1) pt = maxPt; // saturate + float z0 = tempTrackPtr->z0(); + + if (pt < minPt || fabs(z0) > maxZ0 || fabs(eta) > maxEta || chi2dof > chi2dofMax || bendchi2 > bendchi2Max) + continue; + if (maxPt > 0 && pt > maxPt) { + if (HighPtTracks == 0) + continue; // ignore these very high PT tracks: truncate + if (HighPtTracks == 1) + pt = maxPt; // saturate } - int nPS = 0.; // number of stubs in PS modules + int nPS = 0.; // number of stubs in PS modules // loop over the stubs - for (unsigned int istub=0; istub<(unsigned int)theStubs.size(); istub++) { - DetId detId( theStubs.at(istub)->getDetId() ); + for (unsigned int istub = 0; istub < (unsigned int)theStubs.size(); istub++) { + DetId detId(theStubs.at(istub)->getDetId()); if (detId.det() == DetId::Detector::Tracker) { - if ( (detId.subdetId() == StripSubdetector::TOB && tTopo->tobLayer(detId) <= 3) || (detId.subdetId() == StripSubdetector::TID && tTopo->tidRing(detId) <= 9) ) nPS++; + if ((detId.subdetId() == StripSubdetector::TOB && tTopo->tobLayer(detId) <= 3) || + (detId.subdetId() == StripSubdetector::TID && tTopo->tidRing(detId) <= 9)) + nPS++; } } - if (nstubs < nStubsmin || nPS < nStubsPSmin) continue; + if (nstubs < nStubsmin || nPS < nStubsPSmin) + continue; // construct deltaZ cut to be based on track eta - if ( fabs(eta)>=0 && fabs(eta)<0.7) DeltaZ = 0.4; - else if ( fabs(eta)>=0.7 && fabs(eta)<1.0) DeltaZ = 0.6; - else if ( fabs(eta)>=1.0 && fabs(eta)<1.2) DeltaZ = 0.76; - else if ( fabs(eta)>=1.2 && fabs(eta)<1.6) DeltaZ = 1.0; - else if ( fabs(eta)>=1.6 && fabs(eta)<2.0) DeltaZ = 1.7; - else if ( fabs(eta)>=2.0 && fabs(eta)<=2.4) DeltaZ = 2.2; - - if ( fabs(z0 - zVTX) <= DeltaZ) { + if (fabs(eta) >= 0 && fabs(eta) < 0.7) + DeltaZ = 0.4; + else if (fabs(eta) >= 0.7 && fabs(eta) < 1.0) + DeltaZ = 0.6; + else if (fabs(eta) >= 1.0 && fabs(eta) < 1.2) + DeltaZ = 0.76; + else if (fabs(eta) >= 1.2 && fabs(eta) < 1.6) + DeltaZ = 1.0; + else if (fabs(eta) >= 1.6 && fabs(eta) < 2.0) + DeltaZ = 1.7; + else if (fabs(eta) >= 2.0 && fabs(eta) <= 2.4) + DeltaZ = 2.2; + + if (fabs(z0 - zVTX) <= DeltaZ) { nTracks_counter++; Track_Pt->Fill(pt); Track_NStubs->Fill(nstubs); @@ -148,105 +157,144 @@ void L1TPhase2OuterTrackerTkMET::analyze(const edm::Event& iEvent, const edm::Ev Track_Chi2Dof->Fill(chi2dof); Track_BendChi2->Fill(bendchi2); - sumPx += pt*cos(phi); - sumPy += pt*sin(phi); - etTot += pt ; + sumPx += pt * cos(phi); + sumPy += pt * sin(phi); + etTot += pt; + } else { // PU sums + sumPx_PU += pt * cos(phi); + sumPy_PU += pt * sin(phi); + etTot_PU += pt; } - else { // PU sums - sumPx_PU += pt*cos(phi); - sumPy_PU += pt*sin(phi); - etTot_PU += pt ; - } - } // end loop over tracks + } // end loop over tracks Track_N->Fill(nTracks_counter); - float et = sqrt( sumPx*sumPx + sumPy*sumPy ); - double etmiss_PU = sqrt( sumPx_PU*sumPx_PU + sumPy_PU*sumPy_PU ); + float et = sqrt(sumPx * sumPx + sumPy * sumPy); + double etmiss_PU = sqrt(sumPx_PU * sumPx_PU + sumPy_PU * sumPy_PU); - math::XYZTLorentzVector missingEt( -sumPx, -sumPy, 0, et); + math::XYZTLorentzVector missingEt(-sumPx, -sumPy, 0, et); TkMET_QualityCuts->Fill(missingEt.Pt()); TkMET_PU->Fill(etmiss_PU); -} // end of method +} // end of method // ------------ method called once each job just before starting event loop ------------ //Creating all histograms for DQM file output -void L1TPhase2OuterTrackerTkMET::bookHistograms(DQMStore::IBooker &iBooker, edm::Run const & run, edm::EventSetup const & es) { +void L1TPhase2OuterTrackerTkMET::bookHistograms(DQMStore::IBooker& iBooker, + edm::Run const& run, + edm::EventSetup const& es) { std::string HistoName; - iBooker.setCurrentFolder(topFolderName_+"/TkMET_Tracks/"); - + iBooker.setCurrentFolder(topFolderName_ + "/TkMET_Tracks/"); // Num of L1Tracks in tkMET selection HistoName = "Track_N"; - edm::ParameterSet psTrack_N = conf_.getParameter("TH1_NTracks"); - Track_N = iBooker.book1D(HistoName, HistoName, psTrack_N.getParameter("Nbinsx"), psTrack_N.getParameter("xmin"), psTrack_N.getParameter("xmax")); + edm::ParameterSet psTrack_N = conf_.getParameter("TH1_NTracks"); + Track_N = iBooker.book1D(HistoName, + HistoName, + psTrack_N.getParameter("Nbinsx"), + psTrack_N.getParameter("xmin"), + psTrack_N.getParameter("xmax")); Track_N->setAxisTitle("# L1 Tracks", 1); Track_N->setAxisTitle("# Events", 2); //Pt of the tracks - edm::ParameterSet psTrack_Pt = conf_.getParameter("TH1_Track_Pt"); + edm::ParameterSet psTrack_Pt = conf_.getParameter("TH1_Track_Pt"); HistoName = "Track_Pt"; - Track_Pt = iBooker.book1D(HistoName, HistoName, psTrack_Pt.getParameter("Nbinsx"), psTrack_Pt.getParameter("xmin"), psTrack_Pt.getParameter("xmax")); + Track_Pt = iBooker.book1D(HistoName, + HistoName, + psTrack_Pt.getParameter("Nbinsx"), + psTrack_Pt.getParameter("xmin"), + psTrack_Pt.getParameter("xmax")); Track_Pt->setAxisTitle("p_{T} [GeV]", 1); Track_Pt->setAxisTitle("# L1 Tracks", 2); - //Eta - edm::ParameterSet psTrack_Eta = conf_.getParameter("TH1_Track_Eta"); + edm::ParameterSet psTrack_Eta = conf_.getParameter("TH1_Track_Eta"); HistoName = "Track_Eta"; - Track_Eta = iBooker.book1D(HistoName, HistoName, psTrack_Eta.getParameter("Nbinsx"), psTrack_Eta.getParameter("xmin"), psTrack_Eta.getParameter("xmax")); + Track_Eta = iBooker.book1D(HistoName, + HistoName, + psTrack_Eta.getParameter("Nbinsx"), + psTrack_Eta.getParameter("xmin"), + psTrack_Eta.getParameter("xmax")); Track_Eta->setAxisTitle("#eta", 1); Track_Eta->setAxisTitle("# L1 Tracks", 2); //VtxZ - edm::ParameterSet psTrack_VtxZ = conf_.getParameter("TH1_Track_VtxZ"); + edm::ParameterSet psTrack_VtxZ = conf_.getParameter("TH1_Track_VtxZ"); HistoName = "Track_VtxZ"; - Track_VtxZ = iBooker.book1D(HistoName, HistoName, psTrack_VtxZ.getParameter("Nbinsx"), psTrack_VtxZ.getParameter("xmin"), psTrack_VtxZ.getParameter("xmax")); + Track_VtxZ = iBooker.book1D(HistoName, + HistoName, + psTrack_VtxZ.getParameter("Nbinsx"), + psTrack_VtxZ.getParameter("xmin"), + psTrack_VtxZ.getParameter("xmax")); Track_VtxZ->setAxisTitle("L1 Track vertex position z [cm]", 1); Track_VtxZ->setAxisTitle("# L1 Tracks", 2); //chi2dof - edm::ParameterSet psTrack_Chi2Dof = conf_.getParameter("TH1_Track_Chi2Dof"); + edm::ParameterSet psTrack_Chi2Dof = conf_.getParameter("TH1_Track_Chi2Dof"); HistoName = "Track_Chi2Dof"; - Track_Chi2Dof = iBooker.book1D(HistoName, HistoName, psTrack_Chi2Dof.getParameter("Nbinsx"), psTrack_Chi2Dof.getParameter("xmin"), psTrack_Chi2Dof.getParameter("xmax")); + Track_Chi2Dof = iBooker.book1D(HistoName, + HistoName, + psTrack_Chi2Dof.getParameter("Nbinsx"), + psTrack_Chi2Dof.getParameter("xmin"), + psTrack_Chi2Dof.getParameter("xmax")); Track_Chi2Dof->setAxisTitle("L1 Track #chi^{2}/D.O.F.", 1); Track_Chi2Dof->setAxisTitle("# L1 Tracks", 2); //bend chi2 - edm::ParameterSet psTrack_BendChi2 = conf_.getParameter("TH1_Track_BendChi2"); + edm::ParameterSet psTrack_BendChi2 = conf_.getParameter("TH1_Track_BendChi2"); HistoName = "Track_BendChi2"; - Track_BendChi2 = iBooker.book1D(HistoName, HistoName, psTrack_BendChi2.getParameter("Nbinsx"), psTrack_BendChi2.getParameter("xmin"), psTrack_BendChi2.getParameter("xmax")); + Track_BendChi2 = iBooker.book1D(HistoName, + HistoName, + psTrack_BendChi2.getParameter("Nbinsx"), + psTrack_BendChi2.getParameter("xmin"), + psTrack_BendChi2.getParameter("xmax")); Track_BendChi2->setAxisTitle("L1 Track Bend #chi^{2}", 1); Track_BendChi2->setAxisTitle("# L1 Tracks", 2); //nstubs - edm::ParameterSet psTrack_NStubs = conf_.getParameter("TH1_Track_NStubs"); + edm::ParameterSet psTrack_NStubs = conf_.getParameter("TH1_Track_NStubs"); HistoName = "Track_NStubs"; - Track_NStubs = iBooker.book1D(HistoName, HistoName, psTrack_NStubs.getParameter("Nbinsx"), psTrack_NStubs.getParameter("xmin"), psTrack_NStubs.getParameter("xmax")); + Track_NStubs = iBooker.book1D(HistoName, + HistoName, + psTrack_NStubs.getParameter("Nbinsx"), + psTrack_NStubs.getParameter("xmin"), + psTrack_NStubs.getParameter("xmax")); Track_NStubs->setAxisTitle("# L1 Stubs", 1); Track_NStubs->setAxisTitle("# L1 Tracks", 2); //nPSstubs - edm::ParameterSet psTrack_NPSstubs = conf_.getParameter("TH1_Track_NPSstubs"); + edm::ParameterSet psTrack_NPSstubs = conf_.getParameter("TH1_Track_NPSstubs"); HistoName = "Track_NPSstubs"; - Track_NPSstubs = iBooker.book1D(HistoName, HistoName, psTrack_NPSstubs.getParameter("Nbinsx"), psTrack_NPSstubs.getParameter("xmin"), psTrack_NPSstubs.getParameter("xmax")); + Track_NPSstubs = iBooker.book1D(HistoName, + HistoName, + psTrack_NPSstubs.getParameter("Nbinsx"), + psTrack_NPSstubs.getParameter("xmin"), + psTrack_NPSstubs.getParameter("xmax")); Track_NPSstubs->setAxisTitle("# PS Stubs", 1); Track_NPSstubs->setAxisTitle("# L1 Tracks", 2); - iBooker.setCurrentFolder(topFolderName_+"/TkMET"); + iBooker.setCurrentFolder(topFolderName_ + "/TkMET"); //loose tkMET - edm::ParameterSet psTrack_TkMET = conf_.getParameter("TH1_Track_TkMET"); + edm::ParameterSet psTrack_TkMET = conf_.getParameter("TH1_Track_TkMET"); HistoName = "TkMET_QualityCuts"; - TkMET_QualityCuts = iBooker.book1D(HistoName, HistoName, psTrack_TkMET.getParameter("Nbinsx"), psTrack_TkMET.getParameter("xmin"), psTrack_TkMET.getParameter("xmax")); + TkMET_QualityCuts = iBooker.book1D(HistoName, + HistoName, + psTrack_TkMET.getParameter("Nbinsx"), + psTrack_TkMET.getParameter("xmin"), + psTrack_TkMET.getParameter("xmax")); TkMET_QualityCuts->setAxisTitle("L1 Track MET [GeV]", 1); TkMET_QualityCuts->setAxisTitle("# Events", 2); //tkMET -- PU only HistoName = "TkMET_PU"; - TkMET_PU = iBooker.book1D(HistoName, HistoName, psTrack_TkMET.getParameter("Nbinsx"), psTrack_TkMET.getParameter("xmin"), psTrack_TkMET.getParameter("xmax")); + TkMET_PU = iBooker.book1D(HistoName, + HistoName, + psTrack_TkMET.getParameter("Nbinsx"), + psTrack_TkMET.getParameter("xmin"), + psTrack_TkMET.getParameter("xmax")); TkMET_PU->setAxisTitle("L1 Track MET (PU only) [GeV]", 1); TkMET_PU->setAxisTitle("# Events", 2); -} //end of method +} //end of method DEFINE_FWK_MODULE(L1TPhase2OuterTrackerTkMET); From d57c56a17389bdfc3d6e0883e2be18657bf8e774 Mon Sep 17 00:00:00 2001 From: Dylan Date: Wed, 20 Oct 2021 09:28:47 -0500 Subject: [PATCH 5/7] changing cout to warning --- DQMOffline/L1Trigger/src/L1TPhase2OuterTrackerTkMET.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/DQMOffline/L1Trigger/src/L1TPhase2OuterTrackerTkMET.cc b/DQMOffline/L1Trigger/src/L1TPhase2OuterTrackerTkMET.cc index d30de32d7f785..9bf58d20a8393 100644 --- a/DQMOffline/L1Trigger/src/L1TPhase2OuterTrackerTkMET.cc +++ b/DQMOffline/L1Trigger/src/L1TPhase2OuterTrackerTkMET.cc @@ -79,11 +79,11 @@ void L1TPhase2OuterTrackerTkMET::analyze(const edm::Event& iEvent, const edm::Ev // Adding protection if (!TTTrackHandle.isValid()) { - std::cout << "cant find tracks" << std::endl; + edm::LogWarning("L1TPhase2OuterTrackerTkMET") << "cant find tracks" << std::endl; return; } if (!L1VertexHandle.isValid()) { - std::cout << "cant find vertex" << std::endl; + edm::LogWarning("L1TPhase2OuterTrackerTkMET") << "cant find vertex" << std::endl; return; } float sumPx = 0; From 915f51d5faa40ec45be61d14a6ff428024509670 Mon Sep 17 00:00:00 2001 From: Dylan Date: Mon, 25 Oct 2021 10:58:28 -0500 Subject: [PATCH 6/7] fixing ESSetup records access methods --- .../interface/L1TPhase2CorrelatorOffline.h | 1 + .../interface/L1TPhase2OuterTrackerTkMET.h | 2 +- .../src/L1TPhase2CorrelatorOffline.cc | 5 +-- .../src/L1TPhase2OuterTrackerTkMET.cc | 40 +++++++++---------- 4 files changed, 23 insertions(+), 25 deletions(-) diff --git a/DQMOffline/L1Trigger/interface/L1TPhase2CorrelatorOffline.h b/DQMOffline/L1Trigger/interface/L1TPhase2CorrelatorOffline.h index 6e52e7ac10ef5..264749a0bb03d 100644 --- a/DQMOffline/L1Trigger/interface/L1TPhase2CorrelatorOffline.h +++ b/DQMOffline/L1Trigger/interface/L1TPhase2CorrelatorOffline.h @@ -193,6 +193,7 @@ class L1TPhase2CorrelatorOffline : public DQMOneEDAnalyzer<> { // variables from config file edm::EDGetTokenT> genJetToken_; edm::EDGetTokenT> genParticleToken_; + edm::ESGetToken BFieldTag_; edm::ParameterSet objs_; bool isParticleGun_; std::string histFolder_; diff --git a/DQMOffline/L1Trigger/interface/L1TPhase2OuterTrackerTkMET.h b/DQMOffline/L1Trigger/interface/L1TPhase2OuterTrackerTkMET.h index b7b75b566296f..55aaf5c4279dc 100644 --- a/DQMOffline/L1Trigger/interface/L1TPhase2OuterTrackerTkMET.h +++ b/DQMOffline/L1Trigger/interface/L1TPhase2OuterTrackerTkMET.h @@ -40,7 +40,7 @@ class L1TPhase2OuterTrackerTkMET : public DQMEDAnalyzer { private: edm::ParameterSet conf_; - // edm::EDGetTokenT< l1t::VertexCollection > pvToken; + const edm::ESGetToken m_topoToken; edm::EDGetTokenT pvToken; edm::EDGetTokenT > > ttTrackToken_; diff --git a/DQMOffline/L1Trigger/src/L1TPhase2CorrelatorOffline.cc b/DQMOffline/L1Trigger/src/L1TPhase2CorrelatorOffline.cc index 0c27195724116..02be1e5a86ab4 100644 --- a/DQMOffline/L1Trigger/src/L1TPhase2CorrelatorOffline.cc +++ b/DQMOffline/L1Trigger/src/L1TPhase2CorrelatorOffline.cc @@ -36,6 +36,7 @@ L1TPhase2CorrelatorOffline::L1TPhase2CorrelatorOffline(const edm::ParameterSet& : genJetToken_(consumes>(ps.getUntrackedParameter("genJetsInputTag"))), genParticleToken_( consumes>(ps.getUntrackedParameter("genParticlesInputTag"))), + BFieldTag_{esConsumes()}, objs_(ps.getParameter("objects")), isParticleGun_(ps.getParameter("isParticleGun")), histFolder_(ps.getParameter("histFolder")), @@ -114,9 +115,7 @@ L1TPhase2CorrelatorOffline::~L1TPhase2CorrelatorOffline() { void L1TPhase2CorrelatorOffline::dqmBeginRun(const edm::Run& run, const edm::EventSetup& iSetup) { edm::LogInfo("L1TPhase2CorrelatorOffline") << "L1TPhase2CorrelatorOffline::beginRun" << std::endl; - edm::ESHandle magneticField; - iSetup.get().get(magneticField); - bZ_ = magneticField->inTesla(GlobalPoint(0, 0, 0)).z(); + bZ_ = iSetup.getData(BFieldTag_).inTesla(GlobalPoint(0, 0, 0)).z(); } // diff --git a/DQMOffline/L1Trigger/src/L1TPhase2OuterTrackerTkMET.cc b/DQMOffline/L1Trigger/src/L1TPhase2OuterTrackerTkMET.cc index 9bf58d20a8393..65c65d755c166 100644 --- a/DQMOffline/L1Trigger/src/L1TPhase2OuterTrackerTkMET.cc +++ b/DQMOffline/L1Trigger/src/L1TPhase2OuterTrackerTkMET.cc @@ -36,23 +36,24 @@ #include "DQMOffline/L1Trigger/interface/L1TPhase2OuterTrackerTkMET.h" // constructors and destructor -L1TPhase2OuterTrackerTkMET::L1TPhase2OuterTrackerTkMET(const edm::ParameterSet& iConfig) : conf_(iConfig) { - topFolderName_ = conf_.getParameter("TopFolderName"); - ttTrackToken_ = - consumes > >(conf_.getParameter("TTTracksTag")); - // pvToken = consumes< l1t::VertexCollection > (conf_.getParameter("L1VertexInputTag")); - pvToken = consumes(conf_.getParameter("L1VertexInputTag")); - - maxZ0 = conf_.getParameter("maxZ0"); - DeltaZ = conf_.getParameter("DeltaZ"); - chi2dofMax = conf_.getParameter("chi2dofMax"); - bendchi2Max = conf_.getParameter("bendchi2Max"); - minPt = conf_.getParameter("minPt"); - nStubsmin = iConfig.getParameter("nStubsmin"); - nStubsPSmin = iConfig.getParameter("nStubsPSmin"); - maxPt = conf_.getParameter("maxPt"); - maxEta = conf_.getParameter("maxEta"); - HighPtTracks = iConfig.getParameter("HighPtTracks"); +L1TPhase2OuterTrackerTkMET::L1TPhase2OuterTrackerTkMET(const edm::ParameterSet& iConfig) + : conf_(iConfig), + m_topoToken(esConsumes()) { + topFolderName_ = conf_.getParameter("TopFolderName"); + ttTrackToken_ = + consumes > >(conf_.getParameter("TTTracksTag")); + pvToken = consumes(conf_.getParameter("L1VertexInputTag")); + + maxZ0 = conf_.getParameter("maxZ0"); + DeltaZ = conf_.getParameter("DeltaZ"); + chi2dofMax = conf_.getParameter("chi2dofMax"); + bendchi2Max = conf_.getParameter("bendchi2Max"); + minPt = conf_.getParameter("minPt"); + nStubsmin = iConfig.getParameter("nStubsmin"); + nStubsPSmin = iConfig.getParameter("nStubsPSmin"); + maxPt = conf_.getParameter("maxPt"); + maxEta = conf_.getParameter("maxEta"); + HighPtTracks = iConfig.getParameter("HighPtTracks"); } L1TPhase2OuterTrackerTkMET::~L1TPhase2OuterTrackerTkMET() { @@ -73,9 +74,7 @@ void L1TPhase2OuterTrackerTkMET::analyze(const edm::Event& iEvent, const edm::Ev // for PS stubs // Tracker Topology - edm::ESHandle tTopoHandle_; - iSetup.get().get(tTopoHandle_); - const TrackerTopology* tTopo = tTopoHandle_.product(); + const TrackerTopology *const tTopo = &iSetup.getData(m_topoToken); // Adding protection if (!TTTrackHandle.isValid()) { @@ -94,7 +93,6 @@ void L1TPhase2OuterTrackerTkMET::analyze(const edm::Event& iEvent, const edm::Ev double etTot_PU = 0; int nTracks_counter = 0; - // float zVTX = L1VertexHandle->begin()->z0(); float zVTX = L1VertexHandle->begin()->zvertex(); unsigned int tkCnt = 0; for (const auto& trackIter : *TTTrackHandle) { From c15e0e689429f07e0a5b2ce25040066e5d56f3e0 Mon Sep 17 00:00:00 2001 From: Dylan Date: Mon, 25 Oct 2021 11:13:12 -0500 Subject: [PATCH 7/7] code formatting --- .../src/L1TPhase2OuterTrackerTkMET.cc | 35 +++++++++---------- 1 file changed, 17 insertions(+), 18 deletions(-) diff --git a/DQMOffline/L1Trigger/src/L1TPhase2OuterTrackerTkMET.cc b/DQMOffline/L1Trigger/src/L1TPhase2OuterTrackerTkMET.cc index 65c65d755c166..130126b4cc49c 100644 --- a/DQMOffline/L1Trigger/src/L1TPhase2OuterTrackerTkMET.cc +++ b/DQMOffline/L1Trigger/src/L1TPhase2OuterTrackerTkMET.cc @@ -37,23 +37,22 @@ // constructors and destructor L1TPhase2OuterTrackerTkMET::L1TPhase2OuterTrackerTkMET(const edm::ParameterSet& iConfig) - : conf_(iConfig), - m_topoToken(esConsumes()) { - topFolderName_ = conf_.getParameter("TopFolderName"); - ttTrackToken_ = - consumes > >(conf_.getParameter("TTTracksTag")); - pvToken = consumes(conf_.getParameter("L1VertexInputTag")); - - maxZ0 = conf_.getParameter("maxZ0"); - DeltaZ = conf_.getParameter("DeltaZ"); - chi2dofMax = conf_.getParameter("chi2dofMax"); - bendchi2Max = conf_.getParameter("bendchi2Max"); - minPt = conf_.getParameter("minPt"); - nStubsmin = iConfig.getParameter("nStubsmin"); - nStubsPSmin = iConfig.getParameter("nStubsPSmin"); - maxPt = conf_.getParameter("maxPt"); - maxEta = conf_.getParameter("maxEta"); - HighPtTracks = iConfig.getParameter("HighPtTracks"); + : conf_(iConfig), m_topoToken(esConsumes()) { + topFolderName_ = conf_.getParameter("TopFolderName"); + ttTrackToken_ = + consumes > >(conf_.getParameter("TTTracksTag")); + pvToken = consumes(conf_.getParameter("L1VertexInputTag")); + + maxZ0 = conf_.getParameter("maxZ0"); + DeltaZ = conf_.getParameter("DeltaZ"); + chi2dofMax = conf_.getParameter("chi2dofMax"); + bendchi2Max = conf_.getParameter("bendchi2Max"); + minPt = conf_.getParameter("minPt"); + nStubsmin = iConfig.getParameter("nStubsmin"); + nStubsPSmin = iConfig.getParameter("nStubsPSmin"); + maxPt = conf_.getParameter("maxPt"); + maxEta = conf_.getParameter("maxEta"); + HighPtTracks = iConfig.getParameter("HighPtTracks"); } L1TPhase2OuterTrackerTkMET::~L1TPhase2OuterTrackerTkMET() { @@ -74,7 +73,7 @@ void L1TPhase2OuterTrackerTkMET::analyze(const edm::Event& iEvent, const edm::Ev // for PS stubs // Tracker Topology - const TrackerTopology *const tTopo = &iSetup.getData(m_topoToken); + const TrackerTopology* const tTopo = &iSetup.getData(m_topoToken); // Adding protection if (!TTTrackHandle.isValid()) {