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 beffb3c556a9f..589212f117267 100644
--- a/DQMOffline/Configuration/python/autoDQM.py
+++ b/DQMOffline/Configuration/python/autoDQM.py
@@ -154,6 +154,10 @@
'PostDQMOffline',
'DQMHarvestL1TMuon'],
+ 'L1TMonPhase2': ['DQMOfflineL1TPhase2',
+ 'PostDQMOffline',
+ 'DQMHarvestL1TPhase2'],
+
'HLTMon': ['HLTMonitoring',
'PostDQMOffline',
'HLTMonitoringClient'],
@@ -233,7 +237,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..264749a0bb03d
--- /dev/null
+++ b/DQMOffline/L1Trigger/interface/L1TPhase2CorrelatorOffline.h
@@ -0,0 +1,349 @@
+#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::ESGetToken BFieldTag_;
+ 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/L1TPhase2OuterTrackerTkMET.h b/DQMOffline/L1Trigger/interface/L1TPhase2OuterTrackerTkMET.h
new file mode 100644
index 0000000000000..55aaf5c4279dc
--- /dev/null
+++ b/DQMOffline/L1Trigger/interface/L1TPhase2OuterTrackerTkMET.h
@@ -0,0 +1,60 @@
+#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_;
+ const edm::ESGetToken m_topoToken;
+ edm::EDGetTokenT 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/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..02be1e5a86ab4
--- /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"))),
+ BFieldTag_{esConsumes()},
+ 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;
+
+ bZ_ = iSetup.getData(BFieldTag_).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/L1TPhase2OuterTrackerTkMET.cc b/DQMOffline/L1Trigger/src/L1TPhase2OuterTrackerTkMET.cc
new file mode 100644
index 0000000000000..130126b4cc49c
--- /dev/null
+++ b/DQMOffline/L1Trigger/src/L1TPhase2OuterTrackerTkMET.cc
@@ -0,0 +1,297 @@
+// 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), 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() {
+ // 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 L1VertexHandle;
+ iEvent.getByToken(pvToken, L1VertexHandle);
+
+ edm::Handle > > TTTrackHandle;
+ iEvent.getByToken(ttTrackToken_, TTTrackHandle);
+
+ // for PS stubs
+ // Tracker Topology
+ const TrackerTopology* const tTopo = &iSetup.getData(m_topoToken);
+
+ // Adding protection
+ if (!TTTrackHandle.isValid()) {
+ edm::LogWarning("L1TPhase2OuterTrackerTkMET") << "cant find tracks" << std::endl;
+ return;
+ }
+ if (!L1VertexHandle.isValid()) {
+ edm::LogWarning("L1TPhase2OuterTrackerTkMET") << "cant find vertex" << std::endl;
+ return;
+ }
+ float sumPx = 0;
+ float sumPy = 0;
+ float etTot = 0;
+ double sumPx_PU = 0;
+ double sumPy_PU = 0;
+ double etTot_PU = 0;
+ int nTracks_counter = 0;
+
+ float zVTX = L1VertexHandle->begin()->zvertex();
+ unsigned int tkCnt = 0;
+ 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 >, 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
+ }
+
+ 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);