From d7b5954506d0c3320a37e62c7669ce0fd1aca134 Mon Sep 17 00:00:00 2001 From: Marco Musich Date: Fri, 12 Sep 2025 11:32:29 +0200 Subject: [PATCH 01/15] add multiplicities for objects --- .../plugins/ScoutingCollectionMonitor.cc | 38 +++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/DQM/HLTEvF/plugins/ScoutingCollectionMonitor.cc b/DQM/HLTEvF/plugins/ScoutingCollectionMonitor.cc index 9133358a32b32..05d9e7282c7e1 100644 --- a/DQM/HLTEvF/plugins/ScoutingCollectionMonitor.cc +++ b/DQM/HLTEvF/plugins/ScoutingCollectionMonitor.cc @@ -126,6 +126,18 @@ class ScoutingCollectionMonitor : public DQMEDAnalyzer { edm::EDGetTokenT eeCleanedRecHitsToken_; edm::EDGetTokenT hbheRecHitsToken_; + // Multiplicity histograms + dqm::reco::MonitorElement* nTracks_hist; + dqm::reco::MonitorElement* nPrimaryVertices_hist; + dqm::reco::MonitorElement* nDisplacedVertices_hist; + dqm::reco::MonitorElement* nDisplacedVerticesNoVtx_hist; + dqm::reco::MonitorElement* nMuons_hist; + dqm::reco::MonitorElement* nMuonsVtx_hist; + dqm::reco::MonitorElement* nElectrons_hist; + dqm::reco::MonitorElement* nPhotons_hist; + dqm::reco::MonitorElement* nPFJets_hist; + dqm::reco::MonitorElement* nPFCands_hist; + // pv vs PU and rho vs PU plots int primaryVertex_counter = 0; float avgPileUp; @@ -521,6 +533,18 @@ void ScoutingCollectionMonitor::analyze(const edm::Event& iEvent, const edm::Eve pfMetPhi_hist->Fill(*pfMetPhiH); pfMetPt_hist->Fill(*pfMetPtH); + // --- Fill multiplicity histograms --- + nTracks_hist->Fill(tracksH->size()); + nPrimaryVertices_hist->Fill(primaryVerticesH->size()); + nDisplacedVertices_hist->Fill(verticesH->size()); + nDisplacedVerticesNoVtx_hist->Fill(verticesNoVtxH->size()); + nMuons_hist->Fill(muonsH->size()); + nMuonsVtx_hist->Fill(muonsVtxH->size()); + nElectrons_hist->Fill(electronsH->size()); + nPhotons_hist->Fill(photonsH->size()); + nPFJets_hist->Fill(PFjetsH->size()); + nPFCands_hist->Fill(pfcandsH->size()); + // fill the PF candidate histograms (no electrons!) for (const auto& cand : *pfcandsH) { @@ -943,6 +967,20 @@ void ScoutingCollectionMonitor::bookHistograms(DQMStore::IBooker& ibook, edm::EventSetup const& iSetup) { ibook.setCurrentFolder(topfoldername_); + // Book multiplicity histograms in the topfolder + nTracks_hist = ibook.book1D("nTracks", "Number of Tracks;N_{tracks};Entries", 101, 0, 100); + nPrimaryVertices_hist = ibook.book1D("nPrimaryVertices", "Number of Primary Vertices;N_{PV};Entries", 51, 0, 50); + nDisplacedVertices_hist = + ibook.book1D("nDisplacedVertices", "Number of Displaced Vertices (Vtx);N_{DV};Entries", 51, 0, 50); + nDisplacedVerticesNoVtx_hist = + ibook.book1D("nDisplacedVerticesNoVtx", "Number of Displaced Vertices (NoVtx);N_{DV}^{NoVtx};Entries", 51, 0, 50); + nMuons_hist = ibook.book1D("nMuons", "Number of Muons (NoVtx);N_{muons};Entries", 51, 0, 50); + nMuonsVtx_hist = ibook.book1D("nMuonsVtx", "Number of Muons (Vtx);N_{muons}^{Vtx};Entries", 51, 0, 50); + nElectrons_hist = ibook.book1D("nElectrons", "Number of Electrons;N_{ele};Entries", 51, 0, 50); + nPhotons_hist = ibook.book1D("nPhotons", "Number of Photons;N_{photon};Entries", 51, 0, 50); + nPFJets_hist = ibook.book1D("nPFJets", "Number of PF Jets;N_{jet};Entries", 101, 0, 100); + nPFCands_hist = ibook.book1D("nPFCands", "Number of PF Candidates;N_{pfcand};Entries", 1001, 0, 1000); + rho_hist = ibook.book1D("rho", "#rho; #rho; Entries", 100, 0.0, 60.0); pfMetPhi_hist = ibook.book1D("pfMetPhi", "pf MET #phi; #phi ;Entries", 100, -3.14, 3.14); pfMetPt_hist = ibook.book1D("pfMetPt", "pf MET pT;p_{T} [GeV];Entries", 100, 0.0, 250.0); From 660f192b86791784771ce06134f1a86df1dafdd5 Mon Sep 17 00:00:00 2001 From: Marco Musich Date: Fri, 12 Sep 2025 14:20:04 +0200 Subject: [PATCH 02/15] add plots for IP vs beamspot and supply online beamspot in the scouting online DQM client --- .../plugins/ScoutingCollectionMonitor.cc | 26 ++++++++++++++++++- .../scouting_dqm_sourceclient-live_cfg.py | 10 ++++++- 2 files changed, 34 insertions(+), 2 deletions(-) diff --git a/DQM/HLTEvF/plugins/ScoutingCollectionMonitor.cc b/DQM/HLTEvF/plugins/ScoutingCollectionMonitor.cc index 05d9e7282c7e1..c8f391130a5d7 100644 --- a/DQM/HLTEvF/plugins/ScoutingCollectionMonitor.cc +++ b/DQM/HLTEvF/plugins/ScoutingCollectionMonitor.cc @@ -24,6 +24,7 @@ It is based on the preexisting work of the scouting group and can be found at gi // user include files #include "DQMServices/Core/interface/DQMEDAnalyzer.h" +#include "DataFormats/BeamSpot/interface/BeamSpot.h" #include "DataFormats/EcalDetId/interface/EBDetId.h" #include "DataFormats/EcalDetId/interface/EEDetId.h" #include "DataFormats/HcalDetId/interface/HcalDetId.h" @@ -72,7 +73,7 @@ class ScoutingCollectionMonitor : public DQMEDAnalyzer { void setToken(edm::EDGetTokenT& token, const edm::ParameterSet& iConfig, std::string name) { const auto inputTag = iConfig.getParameter(name); if (!inputTag.encode().empty()) { - token = consumes(inputTag); + token = mayConsume(inputTag); } } @@ -117,6 +118,7 @@ class ScoutingCollectionMonitor : public DQMEDAnalyzer { const edm::EDGetTokenT> pfjetsToken_; const edm::EDGetTokenT> tracksToken_; const edm::EDGetTokenT onlineMetaDataDigisToken_; + const edm::EDGetTokenT beamSpotToken_; const std::string topfoldername_; // calo rechits (only 2025 V1.3 onwards, see https://its.cern.ch/jira/browse/CMSHLT-3607) @@ -417,6 +419,8 @@ class ScoutingCollectionMonitor : public DQMEDAnalyzer { dqm::reco::MonitorElement* tk_chi2_prob_hist; dqm::reco::MonitorElement* tk_PV_dxy_hist; dqm::reco::MonitorElement* tk_PV_dz_hist; + dqm::reco::MonitorElement* tk_BS_dxy_hist; + dqm::reco::MonitorElement* tk_BS_dz_hist; // calo rechits histrograms (ECAL has two version, cleaned and unclean) dqm::reco::MonitorElement* ebRecHitsNumber_hist[2]; @@ -457,6 +461,7 @@ ScoutingCollectionMonitor::ScoutingCollectionMonitor(const edm::ParameterSet& iC pfjetsToken_(consumes>(iConfig.getParameter("pfjets"))), tracksToken_(consumes>(iConfig.getParameter("tracks"))), onlineMetaDataDigisToken_(consumes(iConfig.getParameter("onlineMetaDataDigis"))), + beamSpotToken_(consumes(iConfig.getParameter("beamSpot"))), topfoldername_(iConfig.getParameter("topfoldername")) { setToken(ebRecHitsToken_, iConfig, "pfRecHitsEB"); setToken(eeRecHitsToken_, iConfig, "pfRecHitsEE"); @@ -822,6 +827,15 @@ void ScoutingCollectionMonitor::analyze(const edm::Event& iEvent, const edm::Eve for (const auto& vtx : *verticesNoVtxH) fillVtxHistograms(vtx, 1); + // determine the beamspot position (if it exists in the event) + std::unique_ptr beamspotVertex{nullptr}; + edm::Handle beamSpotH; + if (getValidHandle(iEvent, beamSpotToken_, beamSpotH, "beamSpot")) { + const auto& beamspot = *beamSpotH; + beamspotVertex = std::make_unique( + beamspot.x0(), beamspot.y0(), beamspot.z0(), 0., 0., 0., 0., 0., true, 0., 0., 0., 0); + } + // fill tracks histograms for (const auto& tk : *tracksH) { tk_pt_tk_hist->Fill(tk.tk_pt()); @@ -864,6 +878,13 @@ void ScoutingCollectionMonitor::analyze(const edm::Event& iEvent, const edm::Eve tk_PV_dxy_hist->Fill(best_offset.first); tk_PV_dz_hist->Fill(best_offset.second); + + // skip beamspot-based plots if not valid + if (beamspotVertex) { + auto bs_offset = trk_vtx_offSet(tk, *beamspotVertex); + tk_BS_dxy_hist->Fill(bs_offset.first); + tk_BS_dz_hist->Fill(bs_offset.second); + } } // Define helper lambdas for EB and EE rechits @@ -1379,6 +1400,8 @@ void ScoutingCollectionMonitor::bookHistograms(DQMStore::IBooker& ibook, tk_chi2_prob_hist = ibook.book1DD("tk_chi2_prob_hist", "p(#chi^{2}, NDOF); p(#chi^{2}, NDOF); Entries", 100, 0, 1); tk_PV_dz_hist = ibook.book1DD("tk_PV_dz", "Track dz w.r.t. PV; Track dz w.r.t. PV; Entries", 100, -0.35, 0.35); tk_PV_dxy_hist = ibook.book1DD("tk_PV_dxy", "Track dxy w.r.t. PV; Track dxy w.r.t. PV; Entries", 100, -0.15, 0.15); + tk_BS_dxy_hist = ibook.book1D("tk_BS_dxy", "Track dxy w.r.t. BeamSpot;dxy_{BS} (cm);Entries", 100, -0.5, 0.5); + tk_BS_dz_hist = ibook.book1D("tk_BS_dz", "Track dz w.r.t. BeamSpot;dz_{BS} (cm);Entries", 100, -20.0, 20.0); // book the calo rechits histograms const std::array caloLabels = {{"All", "Cleaned"}}; @@ -1486,6 +1509,7 @@ void ScoutingCollectionMonitor::fillDescriptions(edm::ConfigurationDescriptions& desc.add("pfMetPhi", edm::InputTag("hltScoutingPFPacker", "pfMetPhi")); desc.add("rho", edm::InputTag("hltScoutingPFPacker", "rho")); desc.add("onlineMetaDataDigis", edm::InputTag("onlineMetaDataDigis")); + desc.add("beamSpot", edm::InputTag("hltOnlineBeamSpot")); desc.add("pfRecHitsEB", edm::InputTag("hltScoutingRecHitPacker", "EB")); desc.add("pfRecHitsEE", edm::InputTag("hltScoutingRecHitPacker", "EE")); desc.add("pfRecHitsHBHE", edm::InputTag("hltScoutingRecHitPacker", "HBHE")); diff --git a/DQM/Integration/python/clients/scouting_dqm_sourceclient-live_cfg.py b/DQM/Integration/python/clients/scouting_dqm_sourceclient-live_cfg.py index 05e474ab33f5b..a5f5e1ddf609e 100644 --- a/DQM/Integration/python/clients/scouting_dqm_sourceclient-live_cfg.py +++ b/DQM/Integration/python/clients/scouting_dqm_sourceclient-live_cfg.py @@ -40,6 +40,9 @@ #from Configuration.AlCa.GlobalTag import GlobalTag as gtCustomise #process.GlobalTag = gtCustomise(process.GlobalTag, 'auto:run3_data', '') +# import beamspot +from RecoVertex.BeamSpotProducer.BeamSpotOnline_cfi import onlineBeamSpotProducer as _onlineBeamSpotProducer +process.hltOnlineBeamSpot = _onlineBeamSpotProducer.clone() ### for pp collisions process.load("DQM.HLTEvF.ScoutingCollectionMonitor_cfi") @@ -61,7 +64,12 @@ ) ) -process.p = cms.Path(process.dqmcommon * process.scoutingCollectionMonitor * process.ScoutingMuonMonitoring * process.ScoutingJetMonitoring * process.ScoutingElectronMonitoring) +process.p = cms.Path(process.dqmcommon * + process.hltOnlineBeamSpot * + process.scoutingCollectionMonitor * + process.ScoutingMuonMonitoring * + process.ScoutingJetMonitoring * + process.ScoutingElectronMonitoring) ### process customizations included here from DQM.Integration.config.online_customizations_cfi import * From c8538951a73c0131d288d000ce79c700d514a792 Mon Sep 17 00:00:00 2001 From: Marco Musich Date: Mon, 6 Oct 2025 12:03:17 +0200 Subject: [PATCH 03/15] Implement ScoutingMuonPropertiesAnalyzer to monitor peformance of scouting muons vertexing --- .../ScoutingMuonPropertiesMonitoring_cff.py | 11 + .../Scouting/plugins/BuildFile.xml | 18 +- .../plugins/ScoutingMuonPropertiesAnalyzer.cc | 681 ++++++++++++++++++ 3 files changed, 702 insertions(+), 8 deletions(-) create mode 100644 DQM/HLTEvF/python/ScoutingMuonPropertiesMonitoring_cff.py create mode 100644 HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc diff --git a/DQM/HLTEvF/python/ScoutingMuonPropertiesMonitoring_cff.py b/DQM/HLTEvF/python/ScoutingMuonPropertiesMonitoring_cff.py new file mode 100644 index 0000000000000..d2bb79ef142a4 --- /dev/null +++ b/DQM/HLTEvF/python/ScoutingMuonPropertiesMonitoring_cff.py @@ -0,0 +1,11 @@ +import FWCore.ParameterSet.Config as cms +from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer + +scoutingMuonPropertiesMonitor = DQMEDAnalyzer('ScoutingMuonPropertiesAnalyzer', + triggerResults = cms.InputTag("TriggerResults", "", "HLT"), + muonsNoVtx = cms.InputTag("hltScoutingMuonPackerNoVtx", "", "HLT"), + muonsVtx = cms.InputTag("hltScoutingMuonPackerVtx", "", "HLT"), + PV = cms.InputTag("hltScoutingPrimaryVertexPacker", "primaryVtx", "HLT"), + SVNoVtx = cms.InputTag("hltScoutingMuonPackerNoVtx", "displacedVtx", "HLT"), + SVVtx = cms.InputTag("hltScoutingMuonPackerVtx", "displacedVtx", "HLT")) + diff --git a/HLTriggerOffline/Scouting/plugins/BuildFile.xml b/HLTriggerOffline/Scouting/plugins/BuildFile.xml index fd0a9ca9fe98b..33c30efd27eaa 100644 --- a/HLTriggerOffline/Scouting/plugins/BuildFile.xml +++ b/HLTriggerOffline/Scouting/plugins/BuildFile.xml @@ -1,14 +1,16 @@ - - - - + + + - - + + + - - + + + + diff --git a/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc b/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc new file mode 100644 index 0000000000000..f06e9ff4c0b9a --- /dev/null +++ b/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc @@ -0,0 +1,681 @@ +// -*- C++ -*- +// +// Package: HLTriggerOffline/Scouting +// Class: ScoutingMuonPropertiesAnalyzer +// +/**\class HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer + + Description: DQMEDAnalyzer module for monitoring scouting muon properties + + Original Author: Prijith Pradeep, refactored by Copilot + Created: Wed, 05 Jun 2024 21:53:24 GMT +*/ + +// system includes +#include +#include +#include +#include +#include +#include "TLorentzVector.h" + +// user includes +#include "DQMServices/Core/interface/DQMEDAnalyzer.h" +#include "DQMServices/Core/interface/DQMStore.h" +#include "DQMServices/Core/interface/MonitorElement.h" +#include "DataFormats/Common/interface/TriggerResults.h" +#include "DataFormats/Math/interface/Error.h" +#include "DataFormats/Math/interface/Point3D.h" +#include "DataFormats/Scouting/interface/Run3ScoutingMuon.h" +#include "DataFormats/Scouting/interface/Run3ScoutingVertex.h" +#include "FWCore/Common/interface/TriggerNames.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "RecoVertex/VertexTools/interface/VertexDistance3D.h" +#include "RecoVertex/VertexTools/interface/VertexDistanceXY.h" +#include "TrackingTools/Records/interface/TransientTrackRecord.h" +#include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h" + +typedef math::XYZPoint Point; +typedef math::Error<3>::type Error3; + +class ScoutingMuonPropertiesAnalyzer : public DQMEDAnalyzer { +public: + explicit ScoutingMuonPropertiesAnalyzer(const edm::ParameterSet&); + ~ScoutingMuonPropertiesAnalyzer() override = default; + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + +protected: + void analyze(const edm::Event&, const edm::EventSetup&) override; + void bookHistograms(DQMStore::IBooker&, edm::Run const&, edm::EventSetup const&) override; + +private: + // Tokens + const edm::EDGetTokenT triggerResultsToken_; + const edm::EDGetTokenT> muonsNoVtxToken_; + const edm::EDGetTokenT> muonsVtxToken_; + const edm::EDGetTokenT> PVToken_; + const edm::EDGetTokenT> SVNoVtxToken_; + const edm::EDGetTokenT> SVVtxToken_; + const edm::ESGetToken ttbESToken_; + + // Triggers + std::vector triggerPathsVector; + std::map triggerPathsMap; + std::map triggerMEMap_; + bool triggersMapped_ = false; + + // Scalar event ME + MonitorElement* h_run_; + MonitorElement* h_event_; + MonitorElement* h_lumi_; + + // ScoutingMuonNoVtx MEs + MonitorElement* h_nScoutingMuonNoVtx_; + MonitorElement* h_ScoutingMuonNoVtx_pt_; + MonitorElement* h_ScoutingMuonNoVtx_eta_; + MonitorElement* h_ScoutingMuonNoVtx_phi_; + MonitorElement* h_ScoutingMuonNoVtx_phiCorr_; + MonitorElement* h_ScoutingMuonNoVtx_m_; + MonitorElement* h_ScoutingMuonNoVtx_charge_; + MonitorElement* h_ScoutingMuonNoVtx_trkchi2_; + MonitorElement* h_ScoutingMuonNoVtx_trkndof_; + MonitorElement* h_ScoutingMuonNoVtx_trkdxy_; + MonitorElement* h_ScoutingMuonNoVtx_trkdz_; + MonitorElement* h_ScoutingMuonNoVtx_trkqoverp_; + MonitorElement* h_ScoutingMuonNoVtx_trklambda_; + MonitorElement* h_ScoutingMuonNoVtx_trkpt_; + MonitorElement* h_ScoutingMuonNoVtx_trkphi_; + MonitorElement* h_ScoutingMuonNoVtx_trketa_; + MonitorElement* h_ScoutingMuonNoVtx_trkqoverpError_; + MonitorElement* h_ScoutingMuonNoVtx_trklambdaError_; + MonitorElement* h_ScoutingMuonNoVtx_trkdxyError_; + MonitorElement* h_ScoutingMuonNoVtx_trkdzError_; + MonitorElement* h_ScoutingMuonNoVtx_trkphiError_; + MonitorElement* h_ScoutingMuonNoVtx_trkdsz_; + MonitorElement* h_ScoutingMuonNoVtx_trkdszError_; + MonitorElement* h_ScoutingMuonNoVtx_trkvx_; + MonitorElement* h_ScoutingMuonNoVtx_trkvy_; + MonitorElement* h_ScoutingMuonNoVtx_trkvz_; + MonitorElement* h_ScoutingMuonNoVtx_vtxIndx_; // as multiplicity per muon + + // ScoutingMuonVtx MEs + MonitorElement* h_nScoutingMuonVtx_; + MonitorElement* h_ScoutingMuonVtx_pt_; + MonitorElement* h_ScoutingMuonVtx_eta_; + MonitorElement* h_ScoutingMuonVtx_phi_; + MonitorElement* h_ScoutingMuonVtx_phiCorr_; + MonitorElement* h_ScoutingMuonVtx_m_; + MonitorElement* h_ScoutingMuonVtx_charge_; + MonitorElement* h_ScoutingMuonVtx_trkchi2_; + MonitorElement* h_ScoutingMuonVtx_trkndof_; + MonitorElement* h_ScoutingMuonVtx_trkdxy_; + MonitorElement* h_ScoutingMuonVtx_trkdz_; + MonitorElement* h_ScoutingMuonVtx_trkqoverp_; + MonitorElement* h_ScoutingMuonVtx_trklambda_; + MonitorElement* h_ScoutingMuonVtx_trkpt_; + MonitorElement* h_ScoutingMuonVtx_trkphi_; + MonitorElement* h_ScoutingMuonVtx_trketa_; + MonitorElement* h_ScoutingMuonVtx_trkqoverpError_; + MonitorElement* h_ScoutingMuonVtx_trklambdaError_; + MonitorElement* h_ScoutingMuonVtx_trkdxyError_; + MonitorElement* h_ScoutingMuonVtx_trkdzError_; + MonitorElement* h_ScoutingMuonVtx_trkphiError_; + MonitorElement* h_ScoutingMuonVtx_trkdsz_; + MonitorElement* h_ScoutingMuonVtx_trkdszError_; + MonitorElement* h_ScoutingMuonVtx_trkvx_; + MonitorElement* h_ScoutingMuonVtx_trkvy_; + MonitorElement* h_ScoutingMuonVtx_trkvz_; + MonitorElement* h_ScoutingMuonVtx_vtxIndx_; // as multiplicity per muon + + // PV MEs + MonitorElement* h_nPV_; + MonitorElement* h_PV_x_; + MonitorElement* h_PV_y_; + MonitorElement* h_PV_z_; + MonitorElement* h_PV_xError_; + MonitorElement* h_PV_yError_; + MonitorElement* h_PV_zError_; + MonitorElement* h_PV_trksize_; + MonitorElement* h_PV_chi2_; + MonitorElement* h_PV_ndof_; + MonitorElement* h_PV_isvalidvtx_; + + // SVNoVtx MEs + MonitorElement* h_nSVNoVtx_; + MonitorElement* h_SVNoVtx_x_; + MonitorElement* h_SVNoVtx_y_; + MonitorElement* h_SVNoVtx_z_; + MonitorElement* h_SVNoVtx_xError_; + MonitorElement* h_SVNoVtx_yError_; + MonitorElement* h_SVNoVtx_zError_; + MonitorElement* h_SVNoVtx_trksize_; + MonitorElement* h_SVNoVtx_chi2_; + MonitorElement* h_SVNoVtx_ndof_; + MonitorElement* h_SVNoVtx_isvalidvtx_; + MonitorElement* h_SVNoVtx_dxy_; + MonitorElement* h_SVNoVtx_dxySig_; + MonitorElement* h_SVNoVtx_dlen_; + MonitorElement* h_SVNoVtx_dlenSig_; + MonitorElement* h_SVNoVtx_mass_; + MonitorElement* h_SVNoVtx_nMuon_; + + // SVVtx MEs + MonitorElement* h_nSVVtx_; + MonitorElement* h_SVVtx_x_; + MonitorElement* h_SVVtx_y_; + MonitorElement* h_SVVtx_z_; + MonitorElement* h_SVVtx_xError_; + MonitorElement* h_SVVtx_yError_; + MonitorElement* h_SVVtx_zError_; + MonitorElement* h_SVVtx_trksize_; + MonitorElement* h_SVVtx_chi2_; + MonitorElement* h_SVVtx_ndof_; + MonitorElement* h_SVVtx_isvalidvtx_; + MonitorElement* h_SVVtx_dxy_; + MonitorElement* h_SVVtx_dxySig_; + MonitorElement* h_SVVtx_dlen_; + MonitorElement* h_SVVtx_dlenSig_; + MonitorElement* h_SVVtx_mass_; + MonitorElement* h_SVVtx_nMuon_; +}; + +ScoutingMuonPropertiesAnalyzer::ScoutingMuonPropertiesAnalyzer(const edm::ParameterSet& iConfig) + : triggerResultsToken_(consumes(iConfig.getParameter("triggerResults"))), + muonsNoVtxToken_(consumes>(iConfig.getParameter("muonsNoVtx"))), + muonsVtxToken_(consumes>(iConfig.getParameter("muonsVtx"))), + PVToken_(consumes>(iConfig.getParameter("PV"))), + SVNoVtxToken_(consumes>(iConfig.getParameter("SVNoVtx"))), + SVVtxToken_(consumes>(iConfig.getParameter("SVVtx"))), + ttbESToken_( + esConsumes(edm::ESInputTag("", "TransientTrackBuilder"))) { + triggerPathsVector = { + "DST_PFScouting_SingleMuon_v", + "DST_PFScouting_DoubleMuonNoVtx_v", + "DST_PFScouting_DoubleMuonVtx_v", + "DST_PFScouting_DoubleMuonVtxMonitorJPsi_v", + "DST_PFScouting_DoubleMuonVtxMonitorZ_v", + "DST_PFScouting_DoubleEG_v", + "DST_PFScouting_JetHT_v", + "DST_PFScouting_AXOMedium_v", + "DST_PFScouting_AXOTight_v", + "DST_PFScouting_AXOVTight_v", + "DST_PFScouting_ZeroBias_v", + "DST_PFScouting_SinglePhotonEB_v", + "DST_PFScouting_CICADALoose_v", + "DST_PFScouting_CICADAMedium_v", + "DST_PFScouting_CICADATight_v", + "DST_PFScouting_CICADAVTight_v", + "DST_PFScouting_SingleMuonMonitorJPsi_v", + "DST_PFScouting_SingleMuonMonitorZ_v", + }; +} + +void ScoutingMuonPropertiesAnalyzer::bookHistograms(DQMStore::IBooker& ibooker, + edm::Run const&, + edm::EventSetup const&) { + ibooker.setCurrentFolder("HLTScoutingAnalyzer/Ntuplizer"); + + for (const auto& trig : triggerPathsVector) + triggerMEMap_[trig] = ibooker.book1D(trig, trig + " fired", 2, 0, 2); + + h_run_ = ibooker.book1D("run", "Run number", 1000, 0, 1000000); + h_event_ = ibooker.book1D("event", "Event number", 1000, 0, 10000000); + h_lumi_ = ibooker.book1D("lumi", "Luminosity block", 1000, 0, 100000); + + // ScoutingMuonNoVtx + h_nScoutingMuonNoVtx_ = ibooker.book1D("nScoutingMuonNoVtx", "Number of ScoutingMuonNoVtx", 20, 0, 20); + h_ScoutingMuonNoVtx_pt_ = ibooker.book1D("ScoutingMuonNoVtx_pt", "MuonNoVtx p_{T}", 100, 0, 100); + h_ScoutingMuonNoVtx_eta_ = ibooker.book1D("ScoutingMuonNoVtx_eta", "MuonNoVtx #eta", 80, -4, 4); + h_ScoutingMuonNoVtx_phi_ = ibooker.book1D("ScoutingMuonNoVtx_phi", "MuonNoVtx #phi", 64, -3.2, 3.2); + h_ScoutingMuonNoVtx_phiCorr_ = + ibooker.book1D("ScoutingMuonNoVtx_phiCorr", "MuonNoVtx #phi extrapolated", 64, -3.2, 3.2); + h_ScoutingMuonNoVtx_m_ = ibooker.book1D("ScoutingMuonNoVtx_m", "MuonNoVtx mass", 50, 0, 10); + h_ScoutingMuonNoVtx_charge_ = ibooker.book1D("ScoutingMuonNoVtx_charge", "MuonNoVtx charge", 7, -3, 4); + h_ScoutingMuonNoVtx_trkchi2_ = ibooker.book1D("ScoutingMuonNoVtx_trkchi2", "MuonNoVtx track #chi^{2}", 100, 0, 100); + h_ScoutingMuonNoVtx_trkndof_ = ibooker.book1D("ScoutingMuonNoVtx_trkndof", "MuonNoVtx track ndof", 40, 0, 40); + h_ScoutingMuonNoVtx_trkdxy_ = ibooker.book1D("ScoutingMuonNoVtx_trkdxy", "MuonNoVtx track dxy", 100, -0.5, 0.5); + h_ScoutingMuonNoVtx_trkdz_ = ibooker.book1D("ScoutingMuonNoVtx_trkdz", "MuonNoVtx track dz", 100, -20, 20); + h_ScoutingMuonNoVtx_trkqoverp_ = ibooker.book1D("ScoutingMuonNoVtx_trkqoverp", "MuonNoVtx track q/p", 100, -0.1, 0.1); + h_ScoutingMuonNoVtx_trklambda_ = ibooker.book1D("ScoutingMuonNoVtx_trklambda", "MuonNoVtx track lambda", 100, -2, 2); + h_ScoutingMuonNoVtx_trkpt_ = ibooker.book1D("ScoutingMuonNoVtx_trkpt", "MuonNoVtx track pt", 100, 0, 100); + h_ScoutingMuonNoVtx_trkphi_ = ibooker.book1D("ScoutingMuonNoVtx_trkphi", "MuonNoVtx track phi", 64, -3.2, 3.2); + h_ScoutingMuonNoVtx_trketa_ = ibooker.book1D("ScoutingMuonNoVtx_trketa", "MuonNoVtx track eta", 80, -4, 4); + h_ScoutingMuonNoVtx_trkqoverpError_ = + ibooker.book1D("ScoutingMuonNoVtx_trkqoverpError", "MuonNoVtx track q/p error", 100, 0, 0.01); + h_ScoutingMuonNoVtx_trklambdaError_ = + ibooker.book1D("ScoutingMuonNoVtx_trklambdaError", "MuonNoVtx track lambda error", 100, 0, 0.1); + h_ScoutingMuonNoVtx_trkdxyError_ = + ibooker.book1D("ScoutingMuonNoVtx_trkdxyError", "MuonNoVtx track dxy error", 100, 0, 0.1); + h_ScoutingMuonNoVtx_trkdzError_ = + ibooker.book1D("ScoutingMuonNoVtx_trkdzError", "MuonNoVtx track dz error", 100, 0, 1); + h_ScoutingMuonNoVtx_trkphiError_ = + ibooker.book1D("ScoutingMuonNoVtx_trkphiError", "MuonNoVtx track phi error", 100, 0, 0.1); + h_ScoutingMuonNoVtx_trkdsz_ = ibooker.book1D("ScoutingMuonNoVtx_trkdsz", "MuonNoVtx track dsz", 100, -20, 20); + h_ScoutingMuonNoVtx_trkdszError_ = + ibooker.book1D("ScoutingMuonNoVtx_trkdszError", "MuonNoVtx track dsz error", 100, 0, 1); + h_ScoutingMuonNoVtx_trkvx_ = ibooker.book1D("ScoutingMuonNoVtx_trkvx", "MuonNoVtx track vx", 100, -0.5, 0.5); + h_ScoutingMuonNoVtx_trkvy_ = ibooker.book1D("ScoutingMuonNoVtx_trkvy", "MuonNoVtx track vy", 100, -0.5, 0.5); + h_ScoutingMuonNoVtx_trkvz_ = ibooker.book1D("ScoutingMuonNoVtx_trkvz", "MuonNoVtx track vz", 100, -20, 20); + h_ScoutingMuonNoVtx_vtxIndx_ = + ibooker.book1D("ScoutingMuonNoVtx_vtxIndx", "MuonNoVtx SV multiplicity per muon", 10, 0, 10); + + // ScoutingMuonVtx + h_nScoutingMuonVtx_ = ibooker.book1D("nScoutingMuonVtx", "Number of ScoutingMuonVtx", 20, 0, 20); + h_ScoutingMuonVtx_pt_ = ibooker.book1D("ScoutingMuonVtx_pt", "MuonVtx p_{T}", 100, 0, 100); + h_ScoutingMuonVtx_eta_ = ibooker.book1D("ScoutingMuonVtx_eta", "MuonVtx #eta", 80, -4, 4); + h_ScoutingMuonVtx_phi_ = ibooker.book1D("ScoutingMuonVtx_phi", "MuonVtx #phi", 64, -3.2, 3.2); + h_ScoutingMuonVtx_phiCorr_ = ibooker.book1D("ScoutingMuonVtx_phiCorr", "MuonVtx #phi extrapolated", 64, -3.2, 3.2); + h_ScoutingMuonVtx_m_ = ibooker.book1D("ScoutingMuonVtx_m", "MuonVtx mass", 50, 0, 10); + h_ScoutingMuonVtx_charge_ = ibooker.book1D("ScoutingMuonVtx_charge", "MuonVtx charge", 7, -3, 4); + h_ScoutingMuonVtx_trkchi2_ = ibooker.book1D("ScoutingMuonVtx_trkchi2", "MuonVtx track #chi^{2}", 100, 0, 100); + h_ScoutingMuonVtx_trkndof_ = ibooker.book1D("ScoutingMuonVtx_trkndof", "MuonVtx track ndof", 40, 0, 40); + h_ScoutingMuonVtx_trkdxy_ = ibooker.book1D("ScoutingMuonVtx_trkdxy", "MuonVtx track dxy", 100, -0.5, 0.5); + h_ScoutingMuonVtx_trkdz_ = ibooker.book1D("ScoutingMuonVtx_trkdz", "MuonVtx track dz", 100, -20, 20); + h_ScoutingMuonVtx_trkqoverp_ = ibooker.book1D("ScoutingMuonVtx_trkqoverp", "MuonVtx track q/p", 100, -0.1, 0.1); + h_ScoutingMuonVtx_trklambda_ = ibooker.book1D("ScoutingMuonVtx_trklambda", "MuonVtx track lambda", 100, -2, 2); + h_ScoutingMuonVtx_trkpt_ = ibooker.book1D("ScoutingMuonVtx_trkpt", "MuonVtx track pt", 100, 0, 100); + h_ScoutingMuonVtx_trkphi_ = ibooker.book1D("ScoutingMuonVtx_trkphi", "MuonVtx track phi", 64, -3.2, 3.2); + h_ScoutingMuonVtx_trketa_ = ibooker.book1D("ScoutingMuonVtx_trketa", "MuonVtx track eta", 80, -4, 4); + h_ScoutingMuonVtx_trkqoverpError_ = + ibooker.book1D("ScoutingMuonVtx_trkqoverpError", "MuonVtx track q/p error", 100, 0, 0.01); + h_ScoutingMuonVtx_trklambdaError_ = + ibooker.book1D("ScoutingMuonVtx_trklambdaError", "MuonVtx track lambda error", 100, 0, 0.1); + h_ScoutingMuonVtx_trkdxyError_ = + ibooker.book1D("ScoutingMuonVtx_trkdxyError", "MuonVtx track dxy error", 100, 0, 0.1); + h_ScoutingMuonVtx_trkdzError_ = ibooker.book1D("ScoutingMuonVtx_trkdzError", "MuonVtx track dz error", 100, 0, 1); + h_ScoutingMuonVtx_trkphiError_ = + ibooker.book1D("ScoutingMuonVtx_trkphiError", "MuonVtx track phi error", 100, 0, 0.1); + h_ScoutingMuonVtx_trkdsz_ = ibooker.book1D("ScoutingMuonVtx_trkdsz", "MuonVtx track dsz", 100, -20, 20); + h_ScoutingMuonVtx_trkdszError_ = ibooker.book1D("ScoutingMuonVtx_trkdszError", "MuonVtx track dsz error", 100, 0, 1); + h_ScoutingMuonVtx_trkvx_ = ibooker.book1D("ScoutingMuonVtx_trkvx", "MuonVtx track vx", 100, -0.5, 0.5); + h_ScoutingMuonVtx_trkvy_ = ibooker.book1D("ScoutingMuonVtx_trkvy", "MuonVtx track vy", 100, -0.5, 0.5); + h_ScoutingMuonVtx_trkvz_ = ibooker.book1D("ScoutingMuonVtx_trkvz", "MuonVtx track vz", 100, -20, 20); + h_ScoutingMuonVtx_vtxIndx_ = ibooker.book1D("ScoutingMuonVtx_vtxIndx", "MuonVtx SV multiplicity per muon", 10, 0, 10); + + // PV + h_nPV_ = ibooker.book1D("nPV", "Number of PVs", 10, 0, 10); + h_PV_x_ = ibooker.book1D("PV_x", "PV x", 100, -0.5, 0.5); + h_PV_y_ = ibooker.book1D("PV_y", "PV y", 100, -0.5, 0.5); + h_PV_z_ = ibooker.book1D("PV_z", "PV z", 100, -20, 20); + h_PV_xError_ = ibooker.book1D("PV_xError", "PV x error", 100, 0, 0.01); + h_PV_yError_ = ibooker.book1D("PV_yError", "PV y error", 100, 0, 0.01); + h_PV_zError_ = ibooker.book1D("PV_zError", "PV z error", 100, 0, 0.01); + h_PV_trksize_ = ibooker.book1D("PV_trksize", "PV tracks size", 40, 0, 40); + h_PV_chi2_ = ibooker.book1D("PV_chi2", "PV chi2", 100, 0, 100); + h_PV_ndof_ = ibooker.book1D("PV_ndof", "PV ndof", 40, 0, 40); + h_PV_isvalidvtx_ = ibooker.book1D("PV_isvalidvtx", "PV is valid vtx", 2, 0, 2); + + // SVNoVtx + h_nSVNoVtx_ = ibooker.book1D("nSVNoVtx", "Number of SVNoVtx", 20, 0, 20); + h_SVNoVtx_x_ = ibooker.book1D("SVNoVtx_x", "SVNoVtx x", 100, -0.5, 0.5); + h_SVNoVtx_y_ = ibooker.book1D("SVNoVtx_y", "SVNoVtx y", 100, -0.5, 0.5); + h_SVNoVtx_z_ = ibooker.book1D("SVNoVtx_z", "SVNoVtx z", 100, -20, 20); + h_SVNoVtx_xError_ = ibooker.book1D("SVNoVtx_xError", "SVNoVtx x error", 100, 0, 0.01); + h_SVNoVtx_yError_ = ibooker.book1D("SVNoVtx_yError", "SVNoVtx y error", 100, 0, 0.01); + h_SVNoVtx_zError_ = ibooker.book1D("SVNoVtx_zError", "SVNoVtx z error", 100, 0, 0.01); + h_SVNoVtx_trksize_ = ibooker.book1D("SVNoVtx_trksize", "SVNoVtx tracks size", 40, 0, 40); + h_SVNoVtx_chi2_ = ibooker.book1D("SVNoVtx_chi2", "SVNoVtx chi2", 100, 0, 100); + h_SVNoVtx_ndof_ = ibooker.book1D("SVNoVtx_ndof", "SVNoVtx ndof", 40, 0, 40); + h_SVNoVtx_isvalidvtx_ = ibooker.book1D("SVNoVtx_isvalidvtx", "SVNoVtx is valid vtx", 2, 0, 2); + h_SVNoVtx_dxy_ = ibooker.book1D("SVNoVtx_dxy", "SVNoVtx dxy", 100, 0, 0.5); + h_SVNoVtx_dxySig_ = ibooker.book1D("SVNoVtx_dxySig", "SVNoVtx dxy significance", 100, 0, 10); + h_SVNoVtx_dlen_ = ibooker.book1D("SVNoVtx_dlen", "SVNoVtx dlen", 100, 0, 20); + h_SVNoVtx_dlenSig_ = ibooker.book1D("SVNoVtx_dlenSig", "SVNoVtx dlen significance", 100, 0, 10); + h_SVNoVtx_mass_ = ibooker.book1D("SVNoVtx_mass", "SVNoVtx mass", 50, 0, 10); + h_SVNoVtx_nMuon_ = ibooker.book1D("SVNoVtx_nMuon", "SVNoVtx nMuon", 10, 0, 10); + + // SVVtx + h_nSVVtx_ = ibooker.book1D("nSVVtx", "Number of SVVtx", 20, 0, 20); + h_SVVtx_x_ = ibooker.book1D("SVVtx_x", "SVVtx x", 100, -0.5, 0.5); + h_SVVtx_y_ = ibooker.book1D("SVVtx_y", "SVVtx y", 100, -0.5, 0.5); + h_SVVtx_z_ = ibooker.book1D("SVVtx_z", "SVVtx z", 100, -20, 20); + h_SVVtx_xError_ = ibooker.book1D("SVVtx_xError", "SVVtx x error", 100, 0, 0.01); + h_SVVtx_yError_ = ibooker.book1D("SVVtx_yError", "SVVtx y error", 100, 0, 0.01); + h_SVVtx_zError_ = ibooker.book1D("SVVtx_zError", "SVVtx z error", 100, 0, 0.01); + h_SVVtx_trksize_ = ibooker.book1D("SVVtx_trksize", "SVVtx tracks size", 40, 0, 40); + h_SVVtx_chi2_ = ibooker.book1D("SVVtx_chi2", "SVVtx chi2", 100, 0, 100); + h_SVVtx_ndof_ = ibooker.book1D("SVVtx_ndof", "SVVtx ndof", 40, 0, 40); + h_SVVtx_isvalidvtx_ = ibooker.book1D("SVVtx_isvalidvtx", "SVVtx is valid vtx", 2, 0, 2); + h_SVVtx_dxy_ = ibooker.book1D("SVVtx_dxy", "SVVtx dxy", 100, 0, 0.5); + h_SVVtx_dxySig_ = ibooker.book1D("SVVtx_dxySig", "SVVtx dxy significance", 100, 0, 10); + h_SVVtx_dlen_ = ibooker.book1D("SVVtx_dlen", "SVVtx dlen", 100, 0, 20); + h_SVVtx_dlenSig_ = ibooker.book1D("SVVtx_dlenSig", "SVVtx dlen significance", 100, 0, 10); + h_SVVtx_mass_ = ibooker.book1D("SVVtx_mass", "SVVtx mass", 50, 0, 10); + h_SVVtx_nMuon_ = ibooker.book1D("SVVtx_nMuon", "SVVtx nMuon", 10, 0, 10); + + triggersMapped_ = false; +} + +void ScoutingMuonPropertiesAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { + using namespace edm; + + edm::Handle triggerResults; + iEvent.getByToken(triggerResultsToken_, triggerResults); + + edm::Handle> muonsNoVtx; + iEvent.getByToken(muonsNoVtxToken_, muonsNoVtx); + + edm::Handle> muonsVtx; + iEvent.getByToken(muonsVtxToken_, muonsVtx); + + edm::Handle> PV; + iEvent.getByToken(PVToken_, PV); + + edm::Handle> SVNoVtx; + iEvent.getByToken(SVNoVtxToken_, SVNoVtx); + + edm::Handle> SVVtx; + iEvent.getByToken(SVVtxToken_, SVVtx); + + const TransientTrackBuilder* theB = &iSetup.getData(ttbESToken_); + + h_run_->Fill(iEvent.eventAuxiliary().run()); + h_event_->Fill(iEvent.eventAuxiliary().event()); + h_lumi_->Fill(iEvent.eventAuxiliary().luminosityBlock()); + + // Trigger logic (same as before) + if (!triggersMapped_ && triggerResults.isValid()) { + const edm::TriggerNames& triggerNames = iEvent.triggerNames(*triggerResults); + for (size_t i = 0; i < triggerPathsVector.size(); ++i) { + triggerPathsMap[triggerPathsVector[i]] = -1; + for (size_t j = 0; j < triggerNames.size(); ++j) { + if (triggerNames.triggerName(j).find(triggerPathsVector[i]) != std::string::npos) { + triggerPathsMap[triggerPathsVector[i]] = j; + } + } + } + triggersMapped_ = true; + } + if (triggerResults.isValid()) { + for (const auto& trig : triggerPathsVector) { + int idx = triggerPathsMap[trig]; + if (idx >= 0) { + bool fired = triggerResults->accept(idx); + triggerMEMap_[trig]->Fill(fired ? 1 : 0); + } + } + } + + // Prepare PV0 for SV calculations, if available + reco::Vertex PV0; + bool pvAvailable = false; + if (PV.isValid() && !PV->empty()) { + const auto& PV0Ptr = PV->front(); + Point PV0_pos(PV0Ptr.x(), PV0Ptr.y(), PV0Ptr.z()); + Error3 PV0_err; + PV0_err(0, 0) = std::pow(PV0Ptr.xError(), 2); + PV0_err(1, 1) = std::pow(PV0Ptr.yError(), 2); + PV0_err(2, 2) = std::pow(PV0Ptr.zError(), 2); + PV0 = reco::Vertex(PV0_pos, PV0_err, PV0Ptr.chi2(), PV0Ptr.ndof(), PV0Ptr.tracksSize()); + pvAvailable = true; + h_PV_x_->Fill(PV0Ptr.x()); + h_PV_y_->Fill(PV0Ptr.y()); + h_PV_z_->Fill(PV0Ptr.z()); + h_PV_xError_->Fill(PV0Ptr.xError()); + h_PV_yError_->Fill(PV0Ptr.yError()); + h_PV_zError_->Fill(PV0Ptr.zError()); + h_PV_trksize_->Fill(PV0Ptr.tracksSize()); + h_PV_chi2_->Fill(PV0Ptr.chi2()); + h_PV_ndof_->Fill(PV0Ptr.ndof()); + h_PV_isvalidvtx_->Fill(PV0Ptr.isValidVtx()); + h_nPV_->Fill(PV->size()); + } + + // Fill ScoutingMuonNoVtx block, including phiCorr logic + std::vector muonNoVtx_phiCorr; + std::vector> muonNoVtx_vtxIndx; + if (muonsNoVtx.isValid()) { + h_nScoutingMuonNoVtx_->Fill(muonsNoVtx->size()); + for (size_t i = 0; i < muonsNoVtx->size(); ++i) { + const auto& mu = muonsNoVtx->at(i); + h_ScoutingMuonNoVtx_pt_->Fill(mu.pt()); + h_ScoutingMuonNoVtx_eta_->Fill(mu.eta()); + h_ScoutingMuonNoVtx_phi_->Fill(mu.phi()); + h_ScoutingMuonNoVtx_m_->Fill(mu.m()); + h_ScoutingMuonNoVtx_charge_->Fill(mu.charge()); + h_ScoutingMuonNoVtx_trkchi2_->Fill(mu.trk_chi2()); + h_ScoutingMuonNoVtx_trkndof_->Fill(mu.trk_ndof()); + h_ScoutingMuonNoVtx_trkdxy_->Fill(mu.trk_dxy()); + h_ScoutingMuonNoVtx_trkdz_->Fill(mu.trk_dz()); + h_ScoutingMuonNoVtx_trkqoverp_->Fill(mu.trk_qoverp()); + h_ScoutingMuonNoVtx_trklambda_->Fill(mu.trk_lambda()); + h_ScoutingMuonNoVtx_trkpt_->Fill(mu.trk_pt()); + h_ScoutingMuonNoVtx_trkphi_->Fill(mu.trk_phi()); + h_ScoutingMuonNoVtx_trketa_->Fill(mu.trk_eta()); + h_ScoutingMuonNoVtx_trkqoverpError_->Fill(mu.trk_qoverpError()); + h_ScoutingMuonNoVtx_trklambdaError_->Fill(mu.trk_lambdaError()); + h_ScoutingMuonNoVtx_trkdxyError_->Fill(mu.trk_dxyError()); + h_ScoutingMuonNoVtx_trkdzError_->Fill(mu.trk_dzError()); + h_ScoutingMuonNoVtx_trkphiError_->Fill(mu.trk_phiError()); + h_ScoutingMuonNoVtx_trkdsz_->Fill(mu.trk_dsz()); + h_ScoutingMuonNoVtx_trkdszError_->Fill(mu.trk_dszError()); + h_ScoutingMuonNoVtx_trkvx_->Fill(mu.trk_vx()); + h_ScoutingMuonNoVtx_trkvy_->Fill(mu.trk_vy()); + h_ScoutingMuonNoVtx_trkvz_->Fill(mu.trk_vz()); + h_ScoutingMuonNoVtx_vtxIndx_->Fill(mu.vtxIndx().size()); + muonNoVtx_vtxIndx.push_back(mu.vtxIndx()); + // Extrapolated phiCorr logic + float phiCorr = mu.phi(); + if (SVNoVtx.isValid() && mu.vtxIndx().size() > 0 && theB) { + int vtxIndx = mu.vtxIndx()[0]; + if (vtxIndx >= 0 && vtxIndx < int(SVNoVtx->size())) { + const auto& sv = SVNoVtx->at(vtxIndx); + reco::Track::Point v(mu.trk_vx(), mu.trk_vy(), mu.trk_vz()); + reco::Track::Vector p(mu.trk_pt() * std::cos(mu.trk_phi()), + mu.trk_pt() * std::sin(mu.trk_phi()), + mu.trk_pt() * std::sinh(mu.trk_eta())); + double vec[15]; + for (int k = 0; k < 15; k++) + vec[k] = 1.; + reco::TrackBase::CovarianceMatrix cov(vec, vec + 15); + cov(0, 0) = std::pow(mu.trk_qoverpError(), 2); + cov(1, 1) = std::pow(mu.trk_lambdaError(), 2); + cov(2, 2) = std::pow(mu.trk_phiError(), 2); + cov(3, 3) = std::pow(mu.trk_dxyError(), 2); + cov(4, 4) = std::pow(mu.trk_dszError(), 2); + reco::Track trk(mu.trk_chi2(), mu.trk_ndof(), v, p, mu.charge(), cov); + reco::TransientTrack trans = theB->build(trk); + GlobalPoint svPos(sv.x(), sv.y(), sv.z()); + auto traj = trans.trajectoryStateClosestToPoint(svPos); + phiCorr = traj.momentum().phi(); + } + } + muonNoVtx_phiCorr.push_back(phiCorr); + h_ScoutingMuonNoVtx_phiCorr_->Fill(phiCorr); + } + } + + // Fill ScoutingMuonVtx block, including phiCorr logic + std::vector muonVtx_phiCorr; + std::vector> muonVtx_vtxIndx; + if (muonsVtx.isValid()) { + h_nScoutingMuonVtx_->Fill(muonsVtx->size()); + for (size_t i = 0; i < muonsVtx->size(); ++i) { + const auto& mu = muonsVtx->at(i); + h_ScoutingMuonVtx_pt_->Fill(mu.pt()); + h_ScoutingMuonVtx_eta_->Fill(mu.eta()); + h_ScoutingMuonVtx_phi_->Fill(mu.phi()); + h_ScoutingMuonVtx_m_->Fill(mu.m()); + h_ScoutingMuonVtx_charge_->Fill(mu.charge()); + h_ScoutingMuonVtx_trkchi2_->Fill(mu.trk_chi2()); + h_ScoutingMuonVtx_trkndof_->Fill(mu.trk_ndof()); + h_ScoutingMuonVtx_trkdxy_->Fill(mu.trk_dxy()); + h_ScoutingMuonVtx_trkdz_->Fill(mu.trk_dz()); + h_ScoutingMuonVtx_trkqoverp_->Fill(mu.trk_qoverp()); + h_ScoutingMuonVtx_trklambda_->Fill(mu.trk_lambda()); + h_ScoutingMuonVtx_trkpt_->Fill(mu.trk_pt()); + h_ScoutingMuonVtx_trkphi_->Fill(mu.trk_phi()); + h_ScoutingMuonVtx_trketa_->Fill(mu.trk_eta()); + h_ScoutingMuonVtx_trkqoverpError_->Fill(mu.trk_qoverpError()); + h_ScoutingMuonVtx_trklambdaError_->Fill(mu.trk_lambdaError()); + h_ScoutingMuonVtx_trkdxyError_->Fill(mu.trk_dxyError()); + h_ScoutingMuonVtx_trkdzError_->Fill(mu.trk_dzError()); + h_ScoutingMuonVtx_trkphiError_->Fill(mu.trk_phiError()); + h_ScoutingMuonVtx_trkdsz_->Fill(mu.trk_dsz()); + h_ScoutingMuonVtx_trkdszError_->Fill(mu.trk_dszError()); + h_ScoutingMuonVtx_trkvx_->Fill(mu.trk_vx()); + h_ScoutingMuonVtx_trkvy_->Fill(mu.trk_vy()); + h_ScoutingMuonVtx_trkvz_->Fill(mu.trk_vz()); + h_ScoutingMuonVtx_vtxIndx_->Fill(mu.vtxIndx().size()); + muonVtx_vtxIndx.push_back(mu.vtxIndx()); + // Extrapolated phiCorr logic + float phiCorr = mu.phi(); + if (SVVtx.isValid() && mu.vtxIndx().size() > 0 && theB) { + int vtxIndx = mu.vtxIndx()[0]; + if (vtxIndx >= 0 && vtxIndx < int(SVVtx->size())) { + const auto& sv = SVVtx->at(vtxIndx); + reco::Track::Point v(mu.trk_vx(), mu.trk_vy(), mu.trk_vz()); + reco::Track::Vector p(mu.trk_pt() * std::cos(mu.trk_phi()), + mu.trk_pt() * std::sin(mu.trk_phi()), + mu.trk_pt() * std::sinh(mu.trk_eta())); + double vec[15]; + for (int k = 0; k < 15; k++) + vec[k] = 1.; + reco::TrackBase::CovarianceMatrix cov(vec, vec + 15); + cov(0, 0) = std::pow(mu.trk_qoverpError(), 2); + cov(1, 1) = std::pow(mu.trk_lambdaError(), 2); + cov(2, 2) = std::pow(mu.trk_phiError(), 2); + cov(3, 3) = std::pow(mu.trk_dxyError(), 2); + cov(4, 4) = std::pow(mu.trk_dszError(), 2); + reco::Track trk(mu.trk_chi2(), mu.trk_ndof(), v, p, mu.charge(), cov); + reco::TransientTrack trans = theB->build(trk); + GlobalPoint svPos(sv.x(), sv.y(), sv.z()); + auto traj = trans.trajectoryStateClosestToPoint(svPos); + phiCorr = traj.momentum().phi(); + } + } + muonVtx_phiCorr.push_back(phiCorr); + h_ScoutingMuonVtx_phiCorr_->Fill(phiCorr); + } + } + + // SVNoVtx block w/ matching and calculations + VertexDistance3D vdist; + VertexDistanceXY vdistXY; + if (SVNoVtx.isValid()) { + h_nSVNoVtx_->Fill(SVNoVtx->size()); + for (size_t i = 0; i < SVNoVtx->size(); ++i) { + const auto& sv = SVNoVtx->at(i); + h_SVNoVtx_x_->Fill(sv.x()); + h_SVNoVtx_y_->Fill(sv.y()); + h_SVNoVtx_z_->Fill(sv.z()); + h_SVNoVtx_xError_->Fill(sv.xError()); + h_SVNoVtx_yError_->Fill(sv.yError()); + h_SVNoVtx_zError_->Fill(sv.zError()); + h_SVNoVtx_trksize_->Fill(sv.tracksSize()); + h_SVNoVtx_chi2_->Fill(sv.chi2()); + h_SVNoVtx_ndof_->Fill(sv.ndof()); + h_SVNoVtx_isvalidvtx_->Fill(sv.isValidVtx()); + // Calculated for PV0: + if (pvAvailable) { + Point svPos(sv.x(), sv.y(), sv.z()); + Error3 svErr; + svErr(0, 0) = std::pow(sv.xError(), 2); + svErr(1, 1) = std::pow(sv.yError(), 2); + svErr(2, 2) = std::pow(sv.zError(), 2); + reco::Vertex svCand(svPos, svErr, sv.chi2(), sv.ndof(), sv.tracksSize()); + Measurement1D dxy = vdistXY.distance(PV0, svCand); + Measurement1D dlen = vdist.distance(PV0, svCand); + h_SVNoVtx_dxy_->Fill(dxy.value()); + h_SVNoVtx_dxySig_->Fill(dxy.significance()); + h_SVNoVtx_dlen_->Fill(dlen.value()); + h_SVNoVtx_dlenSig_->Fill(dlen.significance()); + } + + // SV/muon matching for mass/nMuon (NoVtx) + int nMuonMatch = 0; + float sv_mass = -1.; + TLorentzVector sv_p4; + if (muonsNoVtx.isValid()) { + for (size_t j = 0; j < muonsNoVtx->size(); ++j) { + const auto& mu = muonsNoVtx->at(j); + const auto& vtxIndx = mu.vtxIndx(); + if (std::find(vtxIndx.begin(), vtxIndx.end(), int(i)) != vtxIndx.end()) { + nMuonMatch++; + TLorentzVector mu_p4; + mu_p4.SetPtEtaPhiM(mu.pt(), mu.eta(), muonNoVtx_phiCorr[j], mu.m()); + sv_p4 += mu_p4; + } + } + } + if (nMuonMatch > 0) + sv_mass = sv_p4.M(); + h_SVNoVtx_mass_->Fill(sv_mass); + h_SVNoVtx_nMuon_->Fill(nMuonMatch); + } + } + + // SVVtx block w/ matching and calculations + if (SVVtx.isValid()) { + h_nSVVtx_->Fill(SVVtx->size()); + for (size_t i = 0; i < SVVtx->size(); ++i) { + const auto& sv = SVVtx->at(i); + h_SVVtx_x_->Fill(sv.x()); + h_SVVtx_y_->Fill(sv.y()); + h_SVVtx_z_->Fill(sv.z()); + h_SVVtx_xError_->Fill(sv.xError()); + h_SVVtx_yError_->Fill(sv.yError()); + h_SVVtx_zError_->Fill(sv.zError()); + h_SVVtx_trksize_->Fill(sv.tracksSize()); + h_SVVtx_chi2_->Fill(sv.chi2()); + h_SVVtx_ndof_->Fill(sv.ndof()); + h_SVVtx_isvalidvtx_->Fill(sv.isValidVtx()); + // Calculated for PV0: + if (pvAvailable) { + Point svPos(sv.x(), sv.y(), sv.z()); + Error3 svErr; + svErr(0, 0) = std::pow(sv.xError(), 2); + svErr(1, 1) = std::pow(sv.yError(), 2); + svErr(2, 2) = std::pow(sv.zError(), 2); + reco::Vertex svCand(svPos, svErr, sv.chi2(), sv.ndof(), sv.tracksSize()); + Measurement1D dxy = vdistXY.distance(PV0, svCand); + Measurement1D dlen = vdist.distance(PV0, svCand); + h_SVVtx_dxy_->Fill(dxy.value()); + h_SVVtx_dxySig_->Fill(dxy.significance()); + h_SVVtx_dlen_->Fill(dlen.value()); + h_SVVtx_dlenSig_->Fill(dlen.significance()); + } + + // SV/muon matching for mass/nMuon (Vtx) + int nMuonMatch = 0; + float sv_mass = -1.; + TLorentzVector sv_p4; + if (muonsVtx.isValid()) { + for (size_t j = 0; j < muonsVtx->size(); ++j) { + const auto& mu = muonsVtx->at(j); + const auto& vtxIndx = mu.vtxIndx(); + if (std::find(vtxIndx.begin(), vtxIndx.end(), int(i)) != vtxIndx.end()) { + nMuonMatch++; + TLorentzVector mu_p4; + mu_p4.SetPtEtaPhiM(mu.pt(), mu.eta(), muonVtx_phiCorr[j], mu.m()); + sv_p4 += mu_p4; + } + } + } + if (nMuonMatch > 0) + sv_mass = sv_p4.M(); + h_SVVtx_mass_->Fill(sv_mass); + h_SVVtx_nMuon_->Fill(nMuonMatch); + } + } +} + +void ScoutingMuonPropertiesAnalyzer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("triggerResults", edm::InputTag("TriggerResults", "", "HLTX")); + desc.add("muonsNoVtx", edm::InputTag("hltScoutingMuonPackerNoVtx", "", "HLTX")); + desc.add("muonsVtx", edm::InputTag("hltScoutingMuonPackerVtx", "", "HLTX")); + desc.add("PV", edm::InputTag("hltScoutingPrimaryVertexPacker", "primaryVtx", "HLTX")); + desc.add("SVNoVtx", edm::InputTag("hltScoutingMuonPackerNoVtx", "displacedVtx", "HLTX")); + desc.add("SVVtx", edm::InputTag("hltScoutingMuonPackerVtx", "displacedVtx", "HLTX")); + descriptions.addWithDefaultLabel(desc); +} + +DEFINE_FWK_MODULE(ScoutingMuonPropertiesAnalyzer); From 08f83cc98d9c5ab91d4533255a37ba1404e418f8 Mon Sep 17 00:00:00 2001 From: Marco Musich Date: Mon, 6 Oct 2025 19:00:20 +0200 Subject: [PATCH 04/15] deploy ScoutingMuonPropertiesAnalyzer in online and offline DQM sequences --- .../python/ScoutingMuonMonitoring_cff.py | 8 ++++++- .../python/HLTScoutingDqmOffline_cff.py | 13 ++++++++---- .../plugins/ScoutingMuonPropertiesAnalyzer.cc | 21 ++++++++++++------- .../ScoutingMuonPropertiesMonitoring_cfi.py | 3 ++- 4 files changed, 31 insertions(+), 14 deletions(-) rename DQM/HLTEvF/python/ScoutingMuonPropertiesMonitoring_cff.py => HLTriggerOffline/Scouting/python/ScoutingMuonPropertiesMonitoring_cfi.py (79%) diff --git a/DQM/HLTEvF/python/ScoutingMuonMonitoring_cff.py b/DQM/HLTEvF/python/ScoutingMuonMonitoring_cff.py index 5a1fb18cc163c..80c74c6249cbe 100644 --- a/DQM/HLTEvF/python/ScoutingMuonMonitoring_cff.py +++ b/DQM/HLTEvF/python/ScoutingMuonMonitoring_cff.py @@ -4,10 +4,16 @@ from HLTriggerOffline.Scouting.ScoutingMuonTriggerAnalyzer_cfi import ScoutingMuonTriggerAnalysis_DoubleMu, ScoutingMuonTriggerAnalysis_SingleMu from HLTriggerOffline.Scouting.ScoutingMuonTagProbeAnalyzer_cfi import ScoutingMuonTagProbeAnalysisNoVtx, ScoutingMuonTagProbeAnalysisVtx +from HLTriggerOffline.Scouting.ScoutingMuonPropertiesMonitoring_cfi import ScoutingMuonPropertiesMonitor ScoutingMuonTagProbeAnalysisNoVtxOnline = ScoutingMuonTagProbeAnalysisNoVtx.clone(OutputInternalPath = "/HLT/ScoutingOnline/Muons/NoVtx") ScoutingMuonTagProbeAnalysisVtxOnline = ScoutingMuonTagProbeAnalysisVtx.clone(OutputInternalPath = "/HLT/ScoutingOnline/Muons/Vtx") ScoutingMuonTriggerAnalysis_DoubleMu = ScoutingMuonTriggerAnalysis_DoubleMu.clone(OutputInternalPath = "/HLT/ScoutingOnline/Muons/L1Efficiency/DoubleMu") ScoutingMuonTriggerAnalysis_SingleMu = ScoutingMuonTriggerAnalysis_SingleMu.clone(OutputInternalPath = "/HLT/ScoutingOnline/Muons/L1Efficiency/SingleMu") +ScoutingMuonPropertiesMonitorOnline = ScoutingMuonPropertiesMonitor.clone(OutputInternalPath = "/HLT/ScoutingOnline/Muons/Properties") -ScoutingMuonMonitoring = cms.Sequence( ScoutingMuonTagProbeAnalysisNoVtxOnline + ScoutingMuonTagProbeAnalysisVtxOnline + ScoutingMuonTriggerAnalysis_DoubleMu + ScoutingMuonTriggerAnalysis_SingleMu ) +ScoutingMuonMonitoring = cms.Sequence(ScoutingMuonTagProbeAnalysisNoVtxOnline + + ScoutingMuonTagProbeAnalysisVtxOnline + + ScoutingMuonTriggerAnalysis_DoubleMu + + ScoutingMuonTriggerAnalysis_SingleMu + + ScoutingMuonPropertiesMonitorOnline) diff --git a/DQMOffline/HLTScouting/python/HLTScoutingDqmOffline_cff.py b/DQMOffline/HLTScouting/python/HLTScoutingDqmOffline_cff.py index 36ff8a2d6ff2a..90864f3352cce 100644 --- a/DQMOffline/HLTScouting/python/HLTScoutingDqmOffline_cff.py +++ b/DQMOffline/HLTScouting/python/HLTScoutingDqmOffline_cff.py @@ -7,20 +7,25 @@ import FWCore.ParameterSet.Config as cms from DQMServices.Core.DQMEDHarvester import DQMEDHarvester +### Muons monitoring from HLTriggerOffline.Scouting.ScoutingMuonTriggerAnalyzer_cfi import * from HLTriggerOffline.Scouting.ScoutingMuonTagProbeAnalyzer_cfi import * -from HLTriggerOffline.Scouting.ScoutingMuonMonitoring_Client_cff import * +from HLTriggerOffline.Scouting.ScoutingMuonPropertiesMonitoring_cfi import * +### Egamma monitoring from HLTriggerOffline.Scouting.HLTScoutingEGammaDqmOffline_cff import * -from DQM.HLTEvF.ScoutingCollectionMonitor_cfi import * - +### Jets Monitoring from DQMOffline.JetMET.jetMETDQMOfflineSource_cff import * +### Miscellaneous monitoring +from DQM.HLTEvF.ScoutingCollectionMonitor_cfi import * + hltScoutingMuonDqmOffline = cms.Sequence(scoutingMonitoringTagProbeMuonNoVtx * scoutingMonitoringTagProbeMuonVtx * scoutingMonitoringTriggerMuon_DoubleMu * - scoutingMonitoringTriggerMuon_SingleMu ) + scoutingMonitoringTriggerMuon_SingleMu * + ScoutingMuonPropertiesMonitor ) hltScoutingJetDqmOffline = cms.Sequence(jetMETDQMOfflineSourceScouting) diff --git a/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc b/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc index f06e9ff4c0b9a..d8791198aa551 100644 --- a/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc +++ b/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc @@ -56,6 +56,9 @@ class ScoutingMuonPropertiesAnalyzer : public DQMEDAnalyzer { void bookHistograms(DQMStore::IBooker&, edm::Run const&, edm::EventSetup const&) override; private: + // Output Folder + const std::string outputInternalPath_; + // Tokens const edm::EDGetTokenT triggerResultsToken_; const edm::EDGetTokenT> muonsNoVtxToken_; @@ -187,7 +190,8 @@ class ScoutingMuonPropertiesAnalyzer : public DQMEDAnalyzer { }; ScoutingMuonPropertiesAnalyzer::ScoutingMuonPropertiesAnalyzer(const edm::ParameterSet& iConfig) - : triggerResultsToken_(consumes(iConfig.getParameter("triggerResults"))), + : outputInternalPath_{iConfig.getParameter("OutputInternalPath")}, + triggerResultsToken_(consumes(iConfig.getParameter("triggerResults"))), muonsNoVtxToken_(consumes>(iConfig.getParameter("muonsNoVtx"))), muonsVtxToken_(consumes>(iConfig.getParameter("muonsVtx"))), PVToken_(consumes>(iConfig.getParameter("PV"))), @@ -220,7 +224,7 @@ ScoutingMuonPropertiesAnalyzer::ScoutingMuonPropertiesAnalyzer(const edm::Parame void ScoutingMuonPropertiesAnalyzer::bookHistograms(DQMStore::IBooker& ibooker, edm::Run const&, edm::EventSetup const&) { - ibooker.setCurrentFolder("HLTScoutingAnalyzer/Ntuplizer"); + ibooker.setCurrentFolder(outputInternalPath_); for (const auto& trig : triggerPathsVector) triggerMEMap_[trig] = ibooker.book1D(trig, trig + " fired", 2, 0, 2); @@ -669,12 +673,13 @@ void ScoutingMuonPropertiesAnalyzer::analyze(const edm::Event& iEvent, const edm void ScoutingMuonPropertiesAnalyzer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { edm::ParameterSetDescription desc; - desc.add("triggerResults", edm::InputTag("TriggerResults", "", "HLTX")); - desc.add("muonsNoVtx", edm::InputTag("hltScoutingMuonPackerNoVtx", "", "HLTX")); - desc.add("muonsVtx", edm::InputTag("hltScoutingMuonPackerVtx", "", "HLTX")); - desc.add("PV", edm::InputTag("hltScoutingPrimaryVertexPacker", "primaryVtx", "HLTX")); - desc.add("SVNoVtx", edm::InputTag("hltScoutingMuonPackerNoVtx", "displacedVtx", "HLTX")); - desc.add("SVVtx", edm::InputTag("hltScoutingMuonPackerVtx", "displacedVtx", "HLTX")); + desc.add("OutputInternalPath", "HLT/ScoutingOffline/Muons/Properties"); + desc.add("triggerResults", edm::InputTag("TriggerResults", "", "HLT")); + desc.add("muonsNoVtx", edm::InputTag("hltScoutingMuonPackerNoVtx", "", "HLT")); + desc.add("muonsVtx", edm::InputTag("hltScoutingMuonPackerVtx", "", "HLT")); + desc.add("PV", edm::InputTag("hltScoutingPrimaryVertexPacker", "primaryVtx", "HLT")); + desc.add("SVNoVtx", edm::InputTag("hltScoutingMuonPackerNoVtx", "displacedVtx", "HLT")); + desc.add("SVVtx", edm::InputTag("hltScoutingMuonPackerVtx", "displacedVtx", "HLT")); descriptions.addWithDefaultLabel(desc); } diff --git a/DQM/HLTEvF/python/ScoutingMuonPropertiesMonitoring_cff.py b/HLTriggerOffline/Scouting/python/ScoutingMuonPropertiesMonitoring_cfi.py similarity index 79% rename from DQM/HLTEvF/python/ScoutingMuonPropertiesMonitoring_cff.py rename to HLTriggerOffline/Scouting/python/ScoutingMuonPropertiesMonitoring_cfi.py index d2bb79ef142a4..74de2bcd6c996 100644 --- a/DQM/HLTEvF/python/ScoutingMuonPropertiesMonitoring_cff.py +++ b/HLTriggerOffline/Scouting/python/ScoutingMuonPropertiesMonitoring_cfi.py @@ -1,7 +1,8 @@ import FWCore.ParameterSet.Config as cms from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer -scoutingMuonPropertiesMonitor = DQMEDAnalyzer('ScoutingMuonPropertiesAnalyzer', +ScoutingMuonPropertiesMonitor = DQMEDAnalyzer('ScoutingMuonPropertiesAnalyzer', + OutputInternalPath = cms.string('/HLT/ScoutingOffline/Muons/Properties'), #Output of the root file triggerResults = cms.InputTag("TriggerResults", "", "HLT"), muonsNoVtx = cms.InputTag("hltScoutingMuonPackerNoVtx", "", "HLT"), muonsVtx = cms.InputTag("hltScoutingMuonPackerVtx", "", "HLT"), From 7c60b2aa14a8dc21c13013e82770c8b8fc5929a4 Mon Sep 17 00:00:00 2001 From: Jessica Prendi Date: Thu, 9 Oct 2025 10:49:02 +0200 Subject: [PATCH 05/15] adapting ranges of multiplicity plots --- DQM/HLTEvF/plugins/ScoutingCollectionMonitor.cc | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/DQM/HLTEvF/plugins/ScoutingCollectionMonitor.cc b/DQM/HLTEvF/plugins/ScoutingCollectionMonitor.cc index c8f391130a5d7..eb80531f81aa6 100644 --- a/DQM/HLTEvF/plugins/ScoutingCollectionMonitor.cc +++ b/DQM/HLTEvF/plugins/ScoutingCollectionMonitor.cc @@ -989,16 +989,16 @@ void ScoutingCollectionMonitor::bookHistograms(DQMStore::IBooker& ibook, ibook.setCurrentFolder(topfoldername_); // Book multiplicity histograms in the topfolder - nTracks_hist = ibook.book1D("nTracks", "Number of Tracks;N_{tracks};Entries", 101, 0, 100); + nTracks_hist = ibook.book1D("nTracks", "Number of Tracks;N_{tracks};Entries", 101, 0, 115); nPrimaryVertices_hist = ibook.book1D("nPrimaryVertices", "Number of Primary Vertices;N_{PV};Entries", 51, 0, 50); nDisplacedVertices_hist = - ibook.book1D("nDisplacedVertices", "Number of Displaced Vertices (Vtx);N_{DV};Entries", 51, 0, 50); + ibook.book1D("nDisplacedVertices", "Number of Displaced Vertices (Vtx);N_{DV};Entries", 51, 0, 10); nDisplacedVerticesNoVtx_hist = - ibook.book1D("nDisplacedVerticesNoVtx", "Number of Displaced Vertices (NoVtx);N_{DV}^{NoVtx};Entries", 51, 0, 50); - nMuons_hist = ibook.book1D("nMuons", "Number of Muons (NoVtx);N_{muons};Entries", 51, 0, 50); - nMuonsVtx_hist = ibook.book1D("nMuonsVtx", "Number of Muons (Vtx);N_{muons}^{Vtx};Entries", 51, 0, 50); - nElectrons_hist = ibook.book1D("nElectrons", "Number of Electrons;N_{ele};Entries", 51, 0, 50); - nPhotons_hist = ibook.book1D("nPhotons", "Number of Photons;N_{photon};Entries", 51, 0, 50); + ibook.book1D("nDisplacedVerticesNoVtx", "Number of Displaced Vertices (NoVtx);N_{DV}^{NoVtx};Entries", 51, 0, 10); + nMuons_hist = ibook.book1D("nMuons", "Number of Muons (NoVtx);N_{muons};Entries", 51, 0, 10); + nMuonsVtx_hist = ibook.book1D("nMuonsVtx", "Number of Muons (Vtx);N_{muons}^{Vtx};Entries", 51, 0, 10); + nElectrons_hist = ibook.book1D("nElectrons", "Number of Electrons;N_{ele};Entries", 51, 0, 10); + nPhotons_hist = ibook.book1D("nPhotons", "Number of Photons;N_{photon};Entries", 51, 0, 25); nPFJets_hist = ibook.book1D("nPFJets", "Number of PF Jets;N_{jet};Entries", 101, 0, 100); nPFCands_hist = ibook.book1D("nPFCands", "Number of PF Candidates;N_{pfcand};Entries", 1001, 0, 1000); From eeca9ebea55d3d752a333e929a4c85d0eb84b6bf Mon Sep 17 00:00:00 2001 From: Jessica Prendi Date: Thu, 9 Oct 2025 11:57:58 +0200 Subject: [PATCH 06/15] changing histogram ranges in ScoutingMuonPropertiesAnalyzer.cc --- .../plugins/ScoutingMuonPropertiesAnalyzer.cc | 60 +++++++++---------- 1 file changed, 30 insertions(+), 30 deletions(-) diff --git a/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc b/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc index d8791198aa551..f5eade0325064 100644 --- a/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc +++ b/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc @@ -229,27 +229,27 @@ void ScoutingMuonPropertiesAnalyzer::bookHistograms(DQMStore::IBooker& ibooker, for (const auto& trig : triggerPathsVector) triggerMEMap_[trig] = ibooker.book1D(trig, trig + " fired", 2, 0, 2); - h_run_ = ibooker.book1D("run", "Run number", 1000, 0, 1000000); - h_event_ = ibooker.book1D("event", "Event number", 1000, 0, 10000000); - h_lumi_ = ibooker.book1D("lumi", "Luminosity block", 1000, 0, 100000); + h_run_ = ibooker.book1D("run", "Run number", 1000, 200000, 600000); + h_event_ = ibooker.book1D("event", "Event number", 1000, 0, 100000000000); + h_lumi_ = ibooker.book1D("lumi", "Luminosity block", 1000, 0, 5000); // ScoutingMuonNoVtx - h_nScoutingMuonNoVtx_ = ibooker.book1D("nScoutingMuonNoVtx", "Number of ScoutingMuonNoVtx", 20, 0, 20); + h_nScoutingMuonNoVtx_ = ibooker.book1D("nScoutingMuonNoVtx", "Number of ScoutingMuonNoVtx", 20, 0, 10); h_ScoutingMuonNoVtx_pt_ = ibooker.book1D("ScoutingMuonNoVtx_pt", "MuonNoVtx p_{T}", 100, 0, 100); - h_ScoutingMuonNoVtx_eta_ = ibooker.book1D("ScoutingMuonNoVtx_eta", "MuonNoVtx #eta", 80, -4, 4); - h_ScoutingMuonNoVtx_phi_ = ibooker.book1D("ScoutingMuonNoVtx_phi", "MuonNoVtx #phi", 64, -3.2, 3.2); + h_ScoutingMuonNoVtx_eta_ = ibooker.book1D("ScoutingMuonNoVtx_eta", "MuonNoVtx #eta", 80, -3, 3); + h_ScoutingMuonNoVtx_phi_ = ibooker.book1D("ScoutingMuonNoVtx_phi", "MuonNoVtx #phi", 64, -3.5, 3.5); h_ScoutingMuonNoVtx_phiCorr_ = - ibooker.book1D("ScoutingMuonNoVtx_phiCorr", "MuonNoVtx #phi extrapolated", 64, -3.2, 3.2); + ibooker.book1D("ScoutingMuonNoVtx_phiCorr", "MuonNoVtx #phi extrapolated", 64, -3.5, 3.5); h_ScoutingMuonNoVtx_m_ = ibooker.book1D("ScoutingMuonNoVtx_m", "MuonNoVtx mass", 50, 0, 10); - h_ScoutingMuonNoVtx_charge_ = ibooker.book1D("ScoutingMuonNoVtx_charge", "MuonNoVtx charge", 7, -3, 4); + h_ScoutingMuonNoVtx_charge_ = ibooker.book1D("ScoutingMuonNoVtx_charge", "MuonNoVtx charge", 2, -1, 1); h_ScoutingMuonNoVtx_trkchi2_ = ibooker.book1D("ScoutingMuonNoVtx_trkchi2", "MuonNoVtx track #chi^{2}", 100, 0, 100); - h_ScoutingMuonNoVtx_trkndof_ = ibooker.book1D("ScoutingMuonNoVtx_trkndof", "MuonNoVtx track ndof", 40, 0, 40); - h_ScoutingMuonNoVtx_trkdxy_ = ibooker.book1D("ScoutingMuonNoVtx_trkdxy", "MuonNoVtx track dxy", 100, -0.5, 0.5); - h_ScoutingMuonNoVtx_trkdz_ = ibooker.book1D("ScoutingMuonNoVtx_trkdz", "MuonNoVtx track dz", 100, -20, 20); - h_ScoutingMuonNoVtx_trkqoverp_ = ibooker.book1D("ScoutingMuonNoVtx_trkqoverp", "MuonNoVtx track q/p", 100, -0.1, 0.1); + h_ScoutingMuonNoVtx_trkndof_ = ibooker.book1D("ScoutingMuonNoVtx_trkndof", "MuonNoVtx track ndof", 40, 0, 50); + h_ScoutingMuonNoVtx_trkdxy_ = ibooker.book1D("ScoutingMuonNoVtx_trkdxy", "MuonNoVtx track dxy", 100, -0.7, 0.7); + h_ScoutingMuonNoVtx_trkdz_ = ibooker.book1D("ScoutingMuonNoVtx_trkdz", "MuonNoVtx track dz", 100, -40, 40); + h_ScoutingMuonNoVtx_trkqoverp_ = ibooker.book1D("ScoutingMuonNoVtx_trkqoverp", "MuonNoVtx track q/p", 100, -1, 1); h_ScoutingMuonNoVtx_trklambda_ = ibooker.book1D("ScoutingMuonNoVtx_trklambda", "MuonNoVtx track lambda", 100, -2, 2); h_ScoutingMuonNoVtx_trkpt_ = ibooker.book1D("ScoutingMuonNoVtx_trkpt", "MuonNoVtx track pt", 100, 0, 100); - h_ScoutingMuonNoVtx_trkphi_ = ibooker.book1D("ScoutingMuonNoVtx_trkphi", "MuonNoVtx track phi", 64, -3.2, 3.2); + h_ScoutingMuonNoVtx_trkphi_ = ibooker.book1D("ScoutingMuonNoVtx_trkphi", "MuonNoVtx track phi", 64, -3.4, 3.4); h_ScoutingMuonNoVtx_trketa_ = ibooker.book1D("ScoutingMuonNoVtx_trketa", "MuonNoVtx track eta", 80, -4, 4); h_ScoutingMuonNoVtx_trkqoverpError_ = ibooker.book1D("ScoutingMuonNoVtx_trkqoverpError", "MuonNoVtx track q/p error", 100, 0, 0.01); @@ -261,31 +261,31 @@ void ScoutingMuonPropertiesAnalyzer::bookHistograms(DQMStore::IBooker& ibooker, ibooker.book1D("ScoutingMuonNoVtx_trkdzError", "MuonNoVtx track dz error", 100, 0, 1); h_ScoutingMuonNoVtx_trkphiError_ = ibooker.book1D("ScoutingMuonNoVtx_trkphiError", "MuonNoVtx track phi error", 100, 0, 0.1); - h_ScoutingMuonNoVtx_trkdsz_ = ibooker.book1D("ScoutingMuonNoVtx_trkdsz", "MuonNoVtx track dsz", 100, -20, 20); + h_ScoutingMuonNoVtx_trkdsz_ = ibooker.book1D("ScoutingMuonNoVtx_trkdsz", "MuonNoVtx track dsz", 100, -50, 50); h_ScoutingMuonNoVtx_trkdszError_ = ibooker.book1D("ScoutingMuonNoVtx_trkdszError", "MuonNoVtx track dsz error", 100, 0, 1); h_ScoutingMuonNoVtx_trkvx_ = ibooker.book1D("ScoutingMuonNoVtx_trkvx", "MuonNoVtx track vx", 100, -0.5, 0.5); h_ScoutingMuonNoVtx_trkvy_ = ibooker.book1D("ScoutingMuonNoVtx_trkvy", "MuonNoVtx track vy", 100, -0.5, 0.5); - h_ScoutingMuonNoVtx_trkvz_ = ibooker.book1D("ScoutingMuonNoVtx_trkvz", "MuonNoVtx track vz", 100, -20, 20); + h_ScoutingMuonNoVtx_trkvz_ = ibooker.book1D("ScoutingMuonNoVtx_trkvz", "MuonNoVtx track vz", 100, -50, 50); h_ScoutingMuonNoVtx_vtxIndx_ = - ibooker.book1D("ScoutingMuonNoVtx_vtxIndx", "MuonNoVtx SV multiplicity per muon", 10, 0, 10); + ibooker.book1D("ScoutingMuonNoVtx_vtxIndx", "MuonNoVtx SV multiplicity per muon", 10, 0, 5); // ScoutingMuonVtx h_nScoutingMuonVtx_ = ibooker.book1D("nScoutingMuonVtx", "Number of ScoutingMuonVtx", 20, 0, 20); h_ScoutingMuonVtx_pt_ = ibooker.book1D("ScoutingMuonVtx_pt", "MuonVtx p_{T}", 100, 0, 100); h_ScoutingMuonVtx_eta_ = ibooker.book1D("ScoutingMuonVtx_eta", "MuonVtx #eta", 80, -4, 4); - h_ScoutingMuonVtx_phi_ = ibooker.book1D("ScoutingMuonVtx_phi", "MuonVtx #phi", 64, -3.2, 3.2); - h_ScoutingMuonVtx_phiCorr_ = ibooker.book1D("ScoutingMuonVtx_phiCorr", "MuonVtx #phi extrapolated", 64, -3.2, 3.2); + h_ScoutingMuonVtx_phi_ = ibooker.book1D("ScoutingMuonVtx_phi", "MuonVtx #phi", 64, -3.4, 3.4); + h_ScoutingMuonVtx_phiCorr_ = ibooker.book1D("ScoutingMuonVtx_phiCorr", "MuonVtx #phi extrapolated", 64, -3.4, 3.4); h_ScoutingMuonVtx_m_ = ibooker.book1D("ScoutingMuonVtx_m", "MuonVtx mass", 50, 0, 10); - h_ScoutingMuonVtx_charge_ = ibooker.book1D("ScoutingMuonVtx_charge", "MuonVtx charge", 7, -3, 4); + h_ScoutingMuonVtx_charge_ = ibooker.book1D("ScoutingMuonVtx_charge", "MuonVtx charge", 2, -1, 1); h_ScoutingMuonVtx_trkchi2_ = ibooker.book1D("ScoutingMuonVtx_trkchi2", "MuonVtx track #chi^{2}", 100, 0, 100); - h_ScoutingMuonVtx_trkndof_ = ibooker.book1D("ScoutingMuonVtx_trkndof", "MuonVtx track ndof", 40, 0, 40); + h_ScoutingMuonVtx_trkndof_ = ibooker.book1D("ScoutingMuonVtx_trkndof", "MuonVtx track ndof", 40, 0, 60); h_ScoutingMuonVtx_trkdxy_ = ibooker.book1D("ScoutingMuonVtx_trkdxy", "MuonVtx track dxy", 100, -0.5, 0.5); h_ScoutingMuonVtx_trkdz_ = ibooker.book1D("ScoutingMuonVtx_trkdz", "MuonVtx track dz", 100, -20, 20); - h_ScoutingMuonVtx_trkqoverp_ = ibooker.book1D("ScoutingMuonVtx_trkqoverp", "MuonVtx track q/p", 100, -0.1, 0.1); + h_ScoutingMuonVtx_trkqoverp_ = ibooker.book1D("ScoutingMuonVtx_trkqoverp", "MuonVtx track q/p", 100, -0.4, 0.4); h_ScoutingMuonVtx_trklambda_ = ibooker.book1D("ScoutingMuonVtx_trklambda", "MuonVtx track lambda", 100, -2, 2); h_ScoutingMuonVtx_trkpt_ = ibooker.book1D("ScoutingMuonVtx_trkpt", "MuonVtx track pt", 100, 0, 100); - h_ScoutingMuonVtx_trkphi_ = ibooker.book1D("ScoutingMuonVtx_trkphi", "MuonVtx track phi", 64, -3.2, 3.2); + h_ScoutingMuonVtx_trkphi_ = ibooker.book1D("ScoutingMuonVtx_trkphi", "MuonVtx track phi", 64, -3.4, 3.4); h_ScoutingMuonVtx_trketa_ = ibooker.book1D("ScoutingMuonVtx_trketa", "MuonVtx track eta", 80, -4, 4); h_ScoutingMuonVtx_trkqoverpError_ = ibooker.book1D("ScoutingMuonVtx_trkqoverpError", "MuonVtx track q/p error", 100, 0, 0.01); @@ -304,16 +304,16 @@ void ScoutingMuonPropertiesAnalyzer::bookHistograms(DQMStore::IBooker& ibooker, h_ScoutingMuonVtx_vtxIndx_ = ibooker.book1D("ScoutingMuonVtx_vtxIndx", "MuonVtx SV multiplicity per muon", 10, 0, 10); // PV - h_nPV_ = ibooker.book1D("nPV", "Number of PVs", 10, 0, 10); + h_nPV_ = ibooker.book1D("nPV", "Number of PVs", 10, 0, 70); h_PV_x_ = ibooker.book1D("PV_x", "PV x", 100, -0.5, 0.5); h_PV_y_ = ibooker.book1D("PV_y", "PV y", 100, -0.5, 0.5); h_PV_z_ = ibooker.book1D("PV_z", "PV z", 100, -20, 20); h_PV_xError_ = ibooker.book1D("PV_xError", "PV x error", 100, 0, 0.01); h_PV_yError_ = ibooker.book1D("PV_yError", "PV y error", 100, 0, 0.01); - h_PV_zError_ = ibooker.book1D("PV_zError", "PV z error", 100, 0, 0.01); - h_PV_trksize_ = ibooker.book1D("PV_trksize", "PV tracks size", 40, 0, 40); - h_PV_chi2_ = ibooker.book1D("PV_chi2", "PV chi2", 100, 0, 100); - h_PV_ndof_ = ibooker.book1D("PV_ndof", "PV ndof", 40, 0, 40); + h_PV_zError_ = ibooker.book1D("PV_zError", "PV z error", 100, 0, 0.1); + h_PV_trksize_ = ibooker.book1D("PV_trksize", "PV tracks size", 40, 0, 200); + h_PV_chi2_ = ibooker.book1D("PV_chi2", "PV #chi^2", 100, 0, 300); + h_PV_ndof_ = ibooker.book1D("PV_ndof", "PV ndof", 40, 0, 100); h_PV_isvalidvtx_ = ibooker.book1D("PV_isvalidvtx", "PV is valid vtx", 2, 0, 2); // SVNoVtx @@ -325,13 +325,13 @@ void ScoutingMuonPropertiesAnalyzer::bookHistograms(DQMStore::IBooker& ibooker, h_SVNoVtx_yError_ = ibooker.book1D("SVNoVtx_yError", "SVNoVtx y error", 100, 0, 0.01); h_SVNoVtx_zError_ = ibooker.book1D("SVNoVtx_zError", "SVNoVtx z error", 100, 0, 0.01); h_SVNoVtx_trksize_ = ibooker.book1D("SVNoVtx_trksize", "SVNoVtx tracks size", 40, 0, 40); - h_SVNoVtx_chi2_ = ibooker.book1D("SVNoVtx_chi2", "SVNoVtx chi2", 100, 0, 100); + h_SVNoVtx_chi2_ = ibooker.book1D("SVNoVtx_chi2", "SVNoVtx #chi^2", 100, 0, 50); h_SVNoVtx_ndof_ = ibooker.book1D("SVNoVtx_ndof", "SVNoVtx ndof", 40, 0, 40); h_SVNoVtx_isvalidvtx_ = ibooker.book1D("SVNoVtx_isvalidvtx", "SVNoVtx is valid vtx", 2, 0, 2); h_SVNoVtx_dxy_ = ibooker.book1D("SVNoVtx_dxy", "SVNoVtx dxy", 100, 0, 0.5); h_SVNoVtx_dxySig_ = ibooker.book1D("SVNoVtx_dxySig", "SVNoVtx dxy significance", 100, 0, 10); h_SVNoVtx_dlen_ = ibooker.book1D("SVNoVtx_dlen", "SVNoVtx dlen", 100, 0, 20); - h_SVNoVtx_dlenSig_ = ibooker.book1D("SVNoVtx_dlenSig", "SVNoVtx dlen significance", 100, 0, 10); + h_SVNoVtx_dlenSig_ = ibooker.book1D("SVNoVtx_dlenSig", "SVNoVtx dlen significance", 100, 0, 50); h_SVNoVtx_mass_ = ibooker.book1D("SVNoVtx_mass", "SVNoVtx mass", 50, 0, 10); h_SVNoVtx_nMuon_ = ibooker.book1D("SVNoVtx_nMuon", "SVNoVtx nMuon", 10, 0, 10); @@ -344,7 +344,7 @@ void ScoutingMuonPropertiesAnalyzer::bookHistograms(DQMStore::IBooker& ibooker, h_SVVtx_yError_ = ibooker.book1D("SVVtx_yError", "SVVtx y error", 100, 0, 0.01); h_SVVtx_zError_ = ibooker.book1D("SVVtx_zError", "SVVtx z error", 100, 0, 0.01); h_SVVtx_trksize_ = ibooker.book1D("SVVtx_trksize", "SVVtx tracks size", 40, 0, 40); - h_SVVtx_chi2_ = ibooker.book1D("SVVtx_chi2", "SVVtx chi2", 100, 0, 100); + h_SVVtx_chi2_ = ibooker.book1D("SVVtx_chi2", "SVVtx #chi^2", 100, 0, 20); h_SVVtx_ndof_ = ibooker.book1D("SVVtx_ndof", "SVVtx ndof", 40, 0, 40); h_SVVtx_isvalidvtx_ = ibooker.book1D("SVVtx_isvalidvtx", "SVVtx is valid vtx", 2, 0, 2); h_SVVtx_dxy_ = ibooker.book1D("SVVtx_dxy", "SVVtx dxy", 100, 0, 0.5); From 09aee2556f9e48ffb291069aabcd0b09b44f08dc Mon Sep 17 00:00:00 2001 From: Jessica Prendi Date: Thu, 9 Oct 2025 17:28:23 +0200 Subject: [PATCH 07/15] applying scram b code-format & scram b code-checks --- .../Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc b/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc index f5eade0325064..01449c8f41b42 100644 --- a/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc +++ b/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc @@ -467,7 +467,7 @@ void ScoutingMuonPropertiesAnalyzer::analyze(const edm::Event& iEvent, const edm muonNoVtx_vtxIndx.push_back(mu.vtxIndx()); // Extrapolated phiCorr logic float phiCorr = mu.phi(); - if (SVNoVtx.isValid() && mu.vtxIndx().size() > 0 && theB) { + if (SVNoVtx.isValid() && !mu.vtxIndx().empty() && theB) { int vtxIndx = mu.vtxIndx()[0]; if (vtxIndx >= 0 && vtxIndx < int(SVNoVtx->size())) { const auto& sv = SVNoVtx->at(vtxIndx); @@ -531,7 +531,7 @@ void ScoutingMuonPropertiesAnalyzer::analyze(const edm::Event& iEvent, const edm muonVtx_vtxIndx.push_back(mu.vtxIndx()); // Extrapolated phiCorr logic float phiCorr = mu.phi(); - if (SVVtx.isValid() && mu.vtxIndx().size() > 0 && theB) { + if (SVVtx.isValid() && !mu.vtxIndx().empty() && theB) { int vtxIndx = mu.vtxIndx()[0]; if (vtxIndx >= 0 && vtxIndx < int(SVVtx->size())) { const auto& sv = SVVtx->at(vtxIndx); From fd9f4959b91a1d88d7ffc21d43645c9a00afdfca Mon Sep 17 00:00:00 2001 From: Marco Musich Date: Thu, 9 Oct 2025 17:30:53 +0200 Subject: [PATCH 08/15] disable calo rechits in ScoutingCollectionMonitor pre 2025 --- .../python/ScoutingCollectionMonitor_cfi.py | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/DQM/HLTEvF/python/ScoutingCollectionMonitor_cfi.py b/DQM/HLTEvF/python/ScoutingCollectionMonitor_cfi.py index 24dfc2750d762..a4092a741e98a 100644 --- a/DQM/HLTEvF/python/ScoutingCollectionMonitor_cfi.py +++ b/DQM/HLTEvF/python/ScoutingCollectionMonitor_cfi.py @@ -18,9 +18,18 @@ pfMetPt = cms.InputTag("hltScoutingPFPacker","pfMetPt"), pfMetPhi = cms.InputTag("hltScoutingPFPacker","pfMetPhi"), rho = cms.InputTag("hltScoutingPFPacker","rho"), - pfRecHitsEB = cms.InputTag("hltScoutingRecHitPacker", "EB"), - pfRecHitsEE = cms.InputTag("hltScoutingRecHitPacker", "EE"), - pfCleanedRecHitsEB = cms.InputTag("hltScoutingRecHitPacker", "EBCleaned"), - pfCleanedRecHitsEE = cms.InputTag("hltScoutingRecHitPacker", "EECleaned"), - pfRecHitsHBHE = cms.InputTag("hltScoutingRecHitPacker", "HBHE")) + pfRecHitsEB = cms.InputTag(""), + pfRecHitsEE = cms.InputTag(""), + pfCleanedRecHitsEB = cms.InputTag(""), + pfCleanedRecHitsEE = cms.InputTag(""), + pfRecHitsHBHE = cms.InputTag("")) +## Add the scouting rechits monitoring (only for 2025, integrated in menu GRun 2025 V1.3) +## See https://its.cern.ch/jira/browse/CMSHLT-3607 +from Configuration.Eras.Modifier_run3_scouting_2025_cff import run3_scouting_2025 +run3_scouting_2025.toModify(scoutingCollectionMonitor, + pfRecHitsEB = ("hltScoutingRecHitPacker", "EB"), + pfRecHitsEE = ("hltScoutingRecHitPacker", "EE"), + pfCleanedRecHitsEB = ("hltScoutingRecHitPacker", "EBCleaned"), + pfCleanedRecHitsEE = ("hltScoutingRecHitPacker", "EECleaned"), + pfRecHitsHBHE = ("hltScoutingRecHitPacker", "HBHE")) From 2ac20cf7a451d51deb684a54f8345f5ebad3e1c0 Mon Sep 17 00:00:00 2001 From: Jessica Prendi Date: Fri, 10 Oct 2025 15:59:09 +0200 Subject: [PATCH 09/15] adding the option of fillAllHistograms or not for the ScoutingMuonPropertiesAnalyzer/Monitoring --- .../plugins/ScoutingMuonPropertiesAnalyzer.cc | 391 ++++++++++-------- .../ScoutingMuonPropertiesMonitoring_cfi.py | 4 +- 2 files changed, 218 insertions(+), 177 deletions(-) diff --git a/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc b/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc index 01449c8f41b42..599247b9369a8 100644 --- a/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc +++ b/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc @@ -58,6 +58,8 @@ class ScoutingMuonPropertiesAnalyzer : public DQMEDAnalyzer { private: // Output Folder const std::string outputInternalPath_; + // do to some histogram duplicates with the ScoutingCollectionMonitor.cc module, we added the option to just fill the unique plots w.r.t the aforementioned module, if this bool is set to false + const bool fillAllHistograms_; // Tokens const edm::EDGetTokenT triggerResultsToken_; @@ -191,6 +193,7 @@ class ScoutingMuonPropertiesAnalyzer : public DQMEDAnalyzer { ScoutingMuonPropertiesAnalyzer::ScoutingMuonPropertiesAnalyzer(const edm::ParameterSet& iConfig) : outputInternalPath_{iConfig.getParameter("OutputInternalPath")}, + fillAllHistograms_{iConfig.getParameter("fillAllHistograms")}, triggerResultsToken_(consumes(iConfig.getParameter("triggerResults"))), muonsNoVtxToken_(consumes>(iConfig.getParameter("muonsNoVtx"))), muonsVtxToken_(consumes>(iConfig.getParameter("muonsVtx"))), @@ -234,100 +237,128 @@ void ScoutingMuonPropertiesAnalyzer::bookHistograms(DQMStore::IBooker& ibooker, h_lumi_ = ibooker.book1D("lumi", "Luminosity block", 1000, 0, 5000); // ScoutingMuonNoVtx - h_nScoutingMuonNoVtx_ = ibooker.book1D("nScoutingMuonNoVtx", "Number of ScoutingMuonNoVtx", 20, 0, 10); - h_ScoutingMuonNoVtx_pt_ = ibooker.book1D("ScoutingMuonNoVtx_pt", "MuonNoVtx p_{T}", 100, 0, 100); - h_ScoutingMuonNoVtx_eta_ = ibooker.book1D("ScoutingMuonNoVtx_eta", "MuonNoVtx #eta", 80, -3, 3); - h_ScoutingMuonNoVtx_phi_ = ibooker.book1D("ScoutingMuonNoVtx_phi", "MuonNoVtx #phi", 64, -3.5, 3.5); + + if (fillAllHistograms_) { + // ScoutingMuonNoVtx + h_nScoutingMuonNoVtx_ = ibooker.book1D("nScoutingMuonNoVtx", "Number of ScoutingMuonNoVtx", 20, 0, 10); + h_ScoutingMuonNoVtx_pt_ = ibooker.book1D("ScoutingMuonNoVtx_pt", "MuonNoVtx p_{T}", 100, 0, 100); + h_ScoutingMuonNoVtx_eta_ = ibooker.book1D("ScoutingMuonNoVtx_eta", "MuonNoVtx #eta", 80, -3, 3); + h_ScoutingMuonNoVtx_phi_ = ibooker.book1D("ScoutingMuonNoVtx_phi", "MuonNoVtx #phi", 64, -3.5, 3.5); + h_ScoutingMuonNoVtx_charge_ = ibooker.book1D("ScoutingMuonNoVtx_charge", "MuonNoVtx charge", 2, -1, 1); + h_ScoutingMuonNoVtx_trkchi2_ = ibooker.book1D("ScoutingMuonNoVtx_trkchi2", "MuonNoVtx track #chi^{2}", 100, 0, 100); + h_ScoutingMuonNoVtx_trkndof_ = ibooker.book1D("ScoutingMuonNoVtx_trkndof", "MuonNoVtx track ndof", 40, 0, 50); + h_ScoutingMuonNoVtx_trkdxy_ = ibooker.book1D("ScoutingMuonNoVtx_trkdxy", "MuonNoVtx track dxy", 100, -0.7, 0.7); + h_ScoutingMuonNoVtx_trkdz_ = ibooker.book1D("ScoutingMuonNoVtx_trkdz", "MuonNoVtx track dz", 100, -40, 40); + h_ScoutingMuonNoVtx_trkqoverp_ = ibooker.book1D("ScoutingMuonNoVtx_trkqoverp", "MuonNoVtx track q/p", 100, -1, 1); + h_ScoutingMuonNoVtx_trklambda_ = + ibooker.book1D("ScoutingMuonNoVtx_trklambda", "MuonNoVtx track lambda", 100, -2, 2); + h_ScoutingMuonNoVtx_trkpt_ = ibooker.book1D("ScoutingMuonNoVtx_trkpt", "MuonNoVtx track pt", 100, 0, 100); + h_ScoutingMuonNoVtx_trkphi_ = ibooker.book1D("ScoutingMuonNoVtx_trkphi", "MuonNoVtx track phi", 64, -3.4, 3.4); + h_ScoutingMuonNoVtx_trketa_ = ibooker.book1D("ScoutingMuonNoVtx_trketa", "MuonNoVtx track eta", 80, -4, 4); + h_ScoutingMuonNoVtx_trkqoverpError_ = + ibooker.book1D("ScoutingMuonNoVtx_trkqoverpError", "MuonNoVtx track q/p error", 100, 0, 0.01); + h_ScoutingMuonNoVtx_trklambdaError_ = + ibooker.book1D("ScoutingMuonNoVtx_trklambdaError", "MuonNoVtx track lambda error", 100, 0, 0.1); + h_ScoutingMuonNoVtx_trkdxyError_ = + ibooker.book1D("ScoutingMuonNoVtx_trkdxyError", "MuonNoVtx track dxy error", 100, 0, 0.1); + h_ScoutingMuonNoVtx_trkdzError_ = + ibooker.book1D("ScoutingMuonNoVtx_trkdzError", "MuonNoVtx track dz error", 100, 0, 1); + h_ScoutingMuonNoVtx_trkphiError_ = + ibooker.book1D("ScoutingMuonNoVtx_trkphiError", "MuonNoVtx track phi error", 100, 0, 0.1); + h_ScoutingMuonNoVtx_trkdsz_ = ibooker.book1D("ScoutingMuonNoVtx_trkdsz", "MuonNoVtx track dsz", 100, -50, 50); + h_ScoutingMuonNoVtx_trkdszError_ = + ibooker.book1D("ScoutingMuonNoVtx_trkdszError", "MuonNoVtx track dsz error", 100, 0, 1); + h_ScoutingMuonNoVtx_trkvx_ = ibooker.book1D("ScoutingMuonNoVtx_trkvx", "MuonNoVtx track vx", 100, -0.5, 0.5); + h_ScoutingMuonNoVtx_trkvy_ = ibooker.book1D("ScoutingMuonNoVtx_trkvy", "MuonNoVtx track vy", 100, -0.5, 0.5); + h_ScoutingMuonNoVtx_trkvz_ = ibooker.book1D("ScoutingMuonNoVtx_trkvz", "MuonNoVtx track vz", 100, -50, 50); + + // ScoutingMuonVtx + h_nScoutingMuonVtx_ = ibooker.book1D("nScoutingMuonVtx", "Number of ScoutingMuonVtx", 20, 0, 20); + h_ScoutingMuonVtx_pt_ = ibooker.book1D("ScoutingMuonVtx_pt", "MuonVtx p_{T}", 100, 0, 100); + h_ScoutingMuonVtx_eta_ = ibooker.book1D("ScoutingMuonVtx_eta", "MuonVtx #eta", 80, -4, 4); + h_ScoutingMuonVtx_phi_ = ibooker.book1D("ScoutingMuonVtx_phi", "MuonVtx #phi", 64, -3.4, 3.4); + h_ScoutingMuonVtx_charge_ = ibooker.book1D("ScoutingMuonVtx_charge", "MuonVtx charge", 2, -1, 1); + h_ScoutingMuonVtx_trkchi2_ = ibooker.book1D("ScoutingMuonVtx_trkchi2", "MuonVtx track #chi^{2}", 100, 0, 100); + h_ScoutingMuonVtx_trkndof_ = ibooker.book1D("ScoutingMuonVtx_trkndof", "MuonVtx track ndof", 40, 0, 60); + h_ScoutingMuonVtx_trkdxy_ = ibooker.book1D("ScoutingMuonVtx_trkdxy", "MuonVtx track dxy", 100, -0.5, 0.5); + h_ScoutingMuonVtx_trkdz_ = ibooker.book1D("ScoutingMuonVtx_trkdz", "MuonVtx track dz", 100, -20, 20); + h_ScoutingMuonVtx_trkqoverp_ = ibooker.book1D("ScoutingMuonVtx_trkqoverp", "MuonVtx track q/p", 100, -0.4, 0.4); + h_ScoutingMuonVtx_trklambda_ = ibooker.book1D("ScoutingMuonVtx_trklambda", "MuonVtx track lambda", 100, -2, 2); + h_ScoutingMuonVtx_trkpt_ = ibooker.book1D("ScoutingMuonVtx_trkpt", "MuonVtx track pt", 100, 0, 100); + h_ScoutingMuonVtx_trkphi_ = ibooker.book1D("ScoutingMuonVtx_trkphi", "MuonVtx track phi", 64, -3.4, 3.4); + h_ScoutingMuonVtx_trketa_ = ibooker.book1D("ScoutingMuonVtx_trketa", "MuonVtx track eta", 80, -4, 4); + h_ScoutingMuonVtx_trkqoverpError_ = + ibooker.book1D("ScoutingMuonVtx_trkqoverpError", "MuonVtx track q/p error", 100, 0, 0.01); + h_ScoutingMuonVtx_trklambdaError_ = + ibooker.book1D("ScoutingMuonVtx_trklambdaError", "MuonVtx track lambda error", 100, 0, 0.1); + h_ScoutingMuonVtx_trkdxyError_ = + ibooker.book1D("ScoutingMuonVtx_trkdxyError", "MuonVtx track dxy error", 100, 0, 0.1); + h_ScoutingMuonVtx_trkdzError_ = ibooker.book1D("ScoutingMuonVtx_trkdzError", "MuonVtx track dz error", 100, 0, 1); + h_ScoutingMuonVtx_trkphiError_ = + ibooker.book1D("ScoutingMuonVtx_trkphiError", "MuonVtx track phi error", 100, 0, 0.1); + h_ScoutingMuonVtx_trkdsz_ = ibooker.book1D("ScoutingMuonVtx_trkdsz", "MuonVtx track dsz", 100, -20, 20); + h_ScoutingMuonVtx_trkdszError_ = + ibooker.book1D("ScoutingMuonVtx_trkdszError", "MuonVtx track dsz error", 100, 0, 1); + h_ScoutingMuonVtx_trkvx_ = ibooker.book1D("ScoutingMuonVtx_trkvx", "MuonVtx track vx", 100, -0.5, 0.5); + h_ScoutingMuonVtx_trkvy_ = ibooker.book1D("ScoutingMuonVtx_trkvy", "MuonVtx track vy", 100, -0.5, 0.5); + h_ScoutingMuonVtx_trkvz_ = ibooker.book1D("ScoutingMuonVtx_trkvz", "MuonVtx track vz", 100, -20, 20); + + // PV + h_nPV_ = ibooker.book1D("nPV", "Number of PVs", 10, 0, 70); + h_PV_x_ = ibooker.book1D("PV_x", "PV x", 100, -0.5, 0.5); + h_PV_y_ = ibooker.book1D("PV_y", "PV y", 100, -0.5, 0.5); + h_PV_z_ = ibooker.book1D("PV_z", "PV z", 100, -20, 20); + h_PV_xError_ = ibooker.book1D("PV_xError", "PV x error", 100, 0, 0.01); + h_PV_yError_ = ibooker.book1D("PV_yError", "PV y error", 100, 0, 0.01); + h_PV_zError_ = ibooker.book1D("PV_zError", "PV z error", 100, 0, 0.1); + h_PV_trksize_ = ibooker.book1D("PV_trksize", "PV tracks size", 40, 0, 200); + h_PV_chi2_ = ibooker.book1D("PV_chi2", "PV #chi^2", 100, 0, 300); + h_PV_ndof_ = ibooker.book1D("PV_ndof", "PV ndof", 40, 0, 100); + h_PV_isvalidvtx_ = ibooker.book1D("PV_isvalidvtx", "PV is valid vtx", 2, 0, 2); + + // SVNoVtx + h_nSVNoVtx_ = ibooker.book1D("nSVNoVtx", "Number of SVNoVtx", 20, 0, 20); + h_SVNoVtx_x_ = ibooker.book1D("SVNoVtx_x", "SVNoVtx x", 100, -0.5, 0.5); + h_SVNoVtx_y_ = ibooker.book1D("SVNoVtx_y", "SVNoVtx y", 100, -0.5, 0.5); + h_SVNoVtx_z_ = ibooker.book1D("SVNoVtx_z", "SVNoVtx z", 100, -20, 20); + h_SVNoVtx_xError_ = ibooker.book1D("SVNoVtx_xError", "SVNoVtx x error", 100, 0, 0.01); + h_SVNoVtx_yError_ = ibooker.book1D("SVNoVtx_yError", "SVNoVtx y error", 100, 0, 0.01); + h_SVNoVtx_zError_ = ibooker.book1D("SVNoVtx_zError", "SVNoVtx z error", 100, 0, 0.01); + h_SVNoVtx_trksize_ = ibooker.book1D("SVNoVtx_trksize", "SVNoVtx tracks size", 40, 0, 40); + h_SVNoVtx_chi2_ = ibooker.book1D("SVNoVtx_chi2", "SVNoVtx #chi^2", 100, 0, 50); + h_SVNoVtx_ndof_ = ibooker.book1D("SVNoVtx_ndof", "SVNoVtx ndof", 40, 0, 40); + h_SVNoVtx_isvalidvtx_ = ibooker.book1D("SVNoVtx_isvalidvtx", "SVNoVtx is valid vtx", 2, 0, 2); + + // SVVtx + h_nSVVtx_ = ibooker.book1D("nSVVtx", "Number of SVVtx", 20, 0, 20); + h_SVVtx_x_ = ibooker.book1D("SVVtx_x", "SVVtx x", 100, -0.5, 0.5); + h_SVVtx_y_ = ibooker.book1D("SVVtx_y", "SVVtx y", 100, -0.5, 0.5); + h_SVVtx_z_ = ibooker.book1D("SVVtx_z", "SVVtx z", 100, -20, 20); + h_SVVtx_xError_ = ibooker.book1D("SVVtx_xError", "SVVtx x error", 100, 0, 0.01); + h_SVVtx_yError_ = ibooker.book1D("SVVtx_yError", "SVVtx y error", 100, 0, 0.01); + h_SVVtx_zError_ = ibooker.book1D("SVVtx_zError", "SVVtx z error", 100, 0, 0.01); + h_SVVtx_trksize_ = ibooker.book1D("SVVtx_trksize", "SVVtx tracks size", 40, 0, 40); + h_SVVtx_chi2_ = ibooker.book1D("SVVtx_chi2", "SVVtx #chi^2", 100, 0, 20); + h_SVVtx_ndof_ = ibooker.book1D("SVVtx_ndof", "SVVtx ndof", 40, 0, 40); + h_SVVtx_isvalidvtx_ = ibooker.book1D("SVVtx_isvalidvtx", "SVVtx is valid vtx", 2, 0, 2); + } + + // ScoutingMuonNoVtx + h_ScoutingMuonNoVtx_phiCorr_ = ibooker.book1D("ScoutingMuonNoVtx_phiCorr", "MuonNoVtx #phi extrapolated", 64, -3.5, 3.5); h_ScoutingMuonNoVtx_m_ = ibooker.book1D("ScoutingMuonNoVtx_m", "MuonNoVtx mass", 50, 0, 10); - h_ScoutingMuonNoVtx_charge_ = ibooker.book1D("ScoutingMuonNoVtx_charge", "MuonNoVtx charge", 2, -1, 1); - h_ScoutingMuonNoVtx_trkchi2_ = ibooker.book1D("ScoutingMuonNoVtx_trkchi2", "MuonNoVtx track #chi^{2}", 100, 0, 100); - h_ScoutingMuonNoVtx_trkndof_ = ibooker.book1D("ScoutingMuonNoVtx_trkndof", "MuonNoVtx track ndof", 40, 0, 50); - h_ScoutingMuonNoVtx_trkdxy_ = ibooker.book1D("ScoutingMuonNoVtx_trkdxy", "MuonNoVtx track dxy", 100, -0.7, 0.7); - h_ScoutingMuonNoVtx_trkdz_ = ibooker.book1D("ScoutingMuonNoVtx_trkdz", "MuonNoVtx track dz", 100, -40, 40); - h_ScoutingMuonNoVtx_trkqoverp_ = ibooker.book1D("ScoutingMuonNoVtx_trkqoverp", "MuonNoVtx track q/p", 100, -1, 1); - h_ScoutingMuonNoVtx_trklambda_ = ibooker.book1D("ScoutingMuonNoVtx_trklambda", "MuonNoVtx track lambda", 100, -2, 2); - h_ScoutingMuonNoVtx_trkpt_ = ibooker.book1D("ScoutingMuonNoVtx_trkpt", "MuonNoVtx track pt", 100, 0, 100); - h_ScoutingMuonNoVtx_trkphi_ = ibooker.book1D("ScoutingMuonNoVtx_trkphi", "MuonNoVtx track phi", 64, -3.4, 3.4); - h_ScoutingMuonNoVtx_trketa_ = ibooker.book1D("ScoutingMuonNoVtx_trketa", "MuonNoVtx track eta", 80, -4, 4); - h_ScoutingMuonNoVtx_trkqoverpError_ = - ibooker.book1D("ScoutingMuonNoVtx_trkqoverpError", "MuonNoVtx track q/p error", 100, 0, 0.01); - h_ScoutingMuonNoVtx_trklambdaError_ = - ibooker.book1D("ScoutingMuonNoVtx_trklambdaError", "MuonNoVtx track lambda error", 100, 0, 0.1); - h_ScoutingMuonNoVtx_trkdxyError_ = - ibooker.book1D("ScoutingMuonNoVtx_trkdxyError", "MuonNoVtx track dxy error", 100, 0, 0.1); - h_ScoutingMuonNoVtx_trkdzError_ = - ibooker.book1D("ScoutingMuonNoVtx_trkdzError", "MuonNoVtx track dz error", 100, 0, 1); - h_ScoutingMuonNoVtx_trkphiError_ = - ibooker.book1D("ScoutingMuonNoVtx_trkphiError", "MuonNoVtx track phi error", 100, 0, 0.1); - h_ScoutingMuonNoVtx_trkdsz_ = ibooker.book1D("ScoutingMuonNoVtx_trkdsz", "MuonNoVtx track dsz", 100, -50, 50); - h_ScoutingMuonNoVtx_trkdszError_ = - ibooker.book1D("ScoutingMuonNoVtx_trkdszError", "MuonNoVtx track dsz error", 100, 0, 1); - h_ScoutingMuonNoVtx_trkvx_ = ibooker.book1D("ScoutingMuonNoVtx_trkvx", "MuonNoVtx track vx", 100, -0.5, 0.5); - h_ScoutingMuonNoVtx_trkvy_ = ibooker.book1D("ScoutingMuonNoVtx_trkvy", "MuonNoVtx track vy", 100, -0.5, 0.5); - h_ScoutingMuonNoVtx_trkvz_ = ibooker.book1D("ScoutingMuonNoVtx_trkvz", "MuonNoVtx track vz", 100, -50, 50); h_ScoutingMuonNoVtx_vtxIndx_ = ibooker.book1D("ScoutingMuonNoVtx_vtxIndx", "MuonNoVtx SV multiplicity per muon", 10, 0, 5); // ScoutingMuonVtx - h_nScoutingMuonVtx_ = ibooker.book1D("nScoutingMuonVtx", "Number of ScoutingMuonVtx", 20, 0, 20); - h_ScoutingMuonVtx_pt_ = ibooker.book1D("ScoutingMuonVtx_pt", "MuonVtx p_{T}", 100, 0, 100); - h_ScoutingMuonVtx_eta_ = ibooker.book1D("ScoutingMuonVtx_eta", "MuonVtx #eta", 80, -4, 4); - h_ScoutingMuonVtx_phi_ = ibooker.book1D("ScoutingMuonVtx_phi", "MuonVtx #phi", 64, -3.4, 3.4); + + h_ScoutingMuonVtx_vtxIndx_ = ibooker.book1D("ScoutingMuonVtx_vtxIndx", "MuonVtx SV multiplicity per muon", 10, 0, 10); h_ScoutingMuonVtx_phiCorr_ = ibooker.book1D("ScoutingMuonVtx_phiCorr", "MuonVtx #phi extrapolated", 64, -3.4, 3.4); h_ScoutingMuonVtx_m_ = ibooker.book1D("ScoutingMuonVtx_m", "MuonVtx mass", 50, 0, 10); - h_ScoutingMuonVtx_charge_ = ibooker.book1D("ScoutingMuonVtx_charge", "MuonVtx charge", 2, -1, 1); - h_ScoutingMuonVtx_trkchi2_ = ibooker.book1D("ScoutingMuonVtx_trkchi2", "MuonVtx track #chi^{2}", 100, 0, 100); - h_ScoutingMuonVtx_trkndof_ = ibooker.book1D("ScoutingMuonVtx_trkndof", "MuonVtx track ndof", 40, 0, 60); - h_ScoutingMuonVtx_trkdxy_ = ibooker.book1D("ScoutingMuonVtx_trkdxy", "MuonVtx track dxy", 100, -0.5, 0.5); - h_ScoutingMuonVtx_trkdz_ = ibooker.book1D("ScoutingMuonVtx_trkdz", "MuonVtx track dz", 100, -20, 20); - h_ScoutingMuonVtx_trkqoverp_ = ibooker.book1D("ScoutingMuonVtx_trkqoverp", "MuonVtx track q/p", 100, -0.4, 0.4); - h_ScoutingMuonVtx_trklambda_ = ibooker.book1D("ScoutingMuonVtx_trklambda", "MuonVtx track lambda", 100, -2, 2); - h_ScoutingMuonVtx_trkpt_ = ibooker.book1D("ScoutingMuonVtx_trkpt", "MuonVtx track pt", 100, 0, 100); - h_ScoutingMuonVtx_trkphi_ = ibooker.book1D("ScoutingMuonVtx_trkphi", "MuonVtx track phi", 64, -3.4, 3.4); - h_ScoutingMuonVtx_trketa_ = ibooker.book1D("ScoutingMuonVtx_trketa", "MuonVtx track eta", 80, -4, 4); - h_ScoutingMuonVtx_trkqoverpError_ = - ibooker.book1D("ScoutingMuonVtx_trkqoverpError", "MuonVtx track q/p error", 100, 0, 0.01); - h_ScoutingMuonVtx_trklambdaError_ = - ibooker.book1D("ScoutingMuonVtx_trklambdaError", "MuonVtx track lambda error", 100, 0, 0.1); - h_ScoutingMuonVtx_trkdxyError_ = - ibooker.book1D("ScoutingMuonVtx_trkdxyError", "MuonVtx track dxy error", 100, 0, 0.1); - h_ScoutingMuonVtx_trkdzError_ = ibooker.book1D("ScoutingMuonVtx_trkdzError", "MuonVtx track dz error", 100, 0, 1); - h_ScoutingMuonVtx_trkphiError_ = - ibooker.book1D("ScoutingMuonVtx_trkphiError", "MuonVtx track phi error", 100, 0, 0.1); - h_ScoutingMuonVtx_trkdsz_ = ibooker.book1D("ScoutingMuonVtx_trkdsz", "MuonVtx track dsz", 100, -20, 20); - h_ScoutingMuonVtx_trkdszError_ = ibooker.book1D("ScoutingMuonVtx_trkdszError", "MuonVtx track dsz error", 100, 0, 1); - h_ScoutingMuonVtx_trkvx_ = ibooker.book1D("ScoutingMuonVtx_trkvx", "MuonVtx track vx", 100, -0.5, 0.5); - h_ScoutingMuonVtx_trkvy_ = ibooker.book1D("ScoutingMuonVtx_trkvy", "MuonVtx track vy", 100, -0.5, 0.5); - h_ScoutingMuonVtx_trkvz_ = ibooker.book1D("ScoutingMuonVtx_trkvz", "MuonVtx track vz", 100, -20, 20); - h_ScoutingMuonVtx_vtxIndx_ = ibooker.book1D("ScoutingMuonVtx_vtxIndx", "MuonVtx SV multiplicity per muon", 10, 0, 10); - - // PV - h_nPV_ = ibooker.book1D("nPV", "Number of PVs", 10, 0, 70); - h_PV_x_ = ibooker.book1D("PV_x", "PV x", 100, -0.5, 0.5); - h_PV_y_ = ibooker.book1D("PV_y", "PV y", 100, -0.5, 0.5); - h_PV_z_ = ibooker.book1D("PV_z", "PV z", 100, -20, 20); - h_PV_xError_ = ibooker.book1D("PV_xError", "PV x error", 100, 0, 0.01); - h_PV_yError_ = ibooker.book1D("PV_yError", "PV y error", 100, 0, 0.01); - h_PV_zError_ = ibooker.book1D("PV_zError", "PV z error", 100, 0, 0.1); - h_PV_trksize_ = ibooker.book1D("PV_trksize", "PV tracks size", 40, 0, 200); - h_PV_chi2_ = ibooker.book1D("PV_chi2", "PV #chi^2", 100, 0, 300); - h_PV_ndof_ = ibooker.book1D("PV_ndof", "PV ndof", 40, 0, 100); - h_PV_isvalidvtx_ = ibooker.book1D("PV_isvalidvtx", "PV is valid vtx", 2, 0, 2); // SVNoVtx - h_nSVNoVtx_ = ibooker.book1D("nSVNoVtx", "Number of SVNoVtx", 20, 0, 20); - h_SVNoVtx_x_ = ibooker.book1D("SVNoVtx_x", "SVNoVtx x", 100, -0.5, 0.5); - h_SVNoVtx_y_ = ibooker.book1D("SVNoVtx_y", "SVNoVtx y", 100, -0.5, 0.5); - h_SVNoVtx_z_ = ibooker.book1D("SVNoVtx_z", "SVNoVtx z", 100, -20, 20); - h_SVNoVtx_xError_ = ibooker.book1D("SVNoVtx_xError", "SVNoVtx x error", 100, 0, 0.01); - h_SVNoVtx_yError_ = ibooker.book1D("SVNoVtx_yError", "SVNoVtx y error", 100, 0, 0.01); - h_SVNoVtx_zError_ = ibooker.book1D("SVNoVtx_zError", "SVNoVtx z error", 100, 0, 0.01); - h_SVNoVtx_trksize_ = ibooker.book1D("SVNoVtx_trksize", "SVNoVtx tracks size", 40, 0, 40); - h_SVNoVtx_chi2_ = ibooker.book1D("SVNoVtx_chi2", "SVNoVtx #chi^2", 100, 0, 50); - h_SVNoVtx_ndof_ = ibooker.book1D("SVNoVtx_ndof", "SVNoVtx ndof", 40, 0, 40); - h_SVNoVtx_isvalidvtx_ = ibooker.book1D("SVNoVtx_isvalidvtx", "SVNoVtx is valid vtx", 2, 0, 2); + h_SVNoVtx_dxy_ = ibooker.book1D("SVNoVtx_dxy", "SVNoVtx dxy", 100, 0, 0.5); h_SVNoVtx_dxySig_ = ibooker.book1D("SVNoVtx_dxySig", "SVNoVtx dxy significance", 100, 0, 10); h_SVNoVtx_dlen_ = ibooker.book1D("SVNoVtx_dlen", "SVNoVtx dlen", 100, 0, 20); @@ -336,17 +367,6 @@ void ScoutingMuonPropertiesAnalyzer::bookHistograms(DQMStore::IBooker& ibooker, h_SVNoVtx_nMuon_ = ibooker.book1D("SVNoVtx_nMuon", "SVNoVtx nMuon", 10, 0, 10); // SVVtx - h_nSVVtx_ = ibooker.book1D("nSVVtx", "Number of SVVtx", 20, 0, 20); - h_SVVtx_x_ = ibooker.book1D("SVVtx_x", "SVVtx x", 100, -0.5, 0.5); - h_SVVtx_y_ = ibooker.book1D("SVVtx_y", "SVVtx y", 100, -0.5, 0.5); - h_SVVtx_z_ = ibooker.book1D("SVVtx_z", "SVVtx z", 100, -20, 20); - h_SVVtx_xError_ = ibooker.book1D("SVVtx_xError", "SVVtx x error", 100, 0, 0.01); - h_SVVtx_yError_ = ibooker.book1D("SVVtx_yError", "SVVtx y error", 100, 0, 0.01); - h_SVVtx_zError_ = ibooker.book1D("SVVtx_zError", "SVVtx z error", 100, 0, 0.01); - h_SVVtx_trksize_ = ibooker.book1D("SVVtx_trksize", "SVVtx tracks size", 40, 0, 40); - h_SVVtx_chi2_ = ibooker.book1D("SVVtx_chi2", "SVVtx #chi^2", 100, 0, 20); - h_SVVtx_ndof_ = ibooker.book1D("SVVtx_ndof", "SVVtx ndof", 40, 0, 40); - h_SVVtx_isvalidvtx_ = ibooker.book1D("SVVtx_isvalidvtx", "SVVtx is valid vtx", 2, 0, 2); h_SVVtx_dxy_ = ibooker.book1D("SVVtx_dxy", "SVVtx dxy", 100, 0, 0.5); h_SVVtx_dxySig_ = ibooker.book1D("SVVtx_dxySig", "SVVtx dxy significance", 100, 0, 10); h_SVVtx_dlen_ = ibooker.book1D("SVVtx_dlen", "SVVtx dlen", 100, 0, 20); @@ -419,50 +439,57 @@ void ScoutingMuonPropertiesAnalyzer::analyze(const edm::Event& iEvent, const edm PV0_err(2, 2) = std::pow(PV0Ptr.zError(), 2); PV0 = reco::Vertex(PV0_pos, PV0_err, PV0Ptr.chi2(), PV0Ptr.ndof(), PV0Ptr.tracksSize()); pvAvailable = true; - h_PV_x_->Fill(PV0Ptr.x()); - h_PV_y_->Fill(PV0Ptr.y()); - h_PV_z_->Fill(PV0Ptr.z()); - h_PV_xError_->Fill(PV0Ptr.xError()); - h_PV_yError_->Fill(PV0Ptr.yError()); - h_PV_zError_->Fill(PV0Ptr.zError()); - h_PV_trksize_->Fill(PV0Ptr.tracksSize()); - h_PV_chi2_->Fill(PV0Ptr.chi2()); - h_PV_ndof_->Fill(PV0Ptr.ndof()); - h_PV_isvalidvtx_->Fill(PV0Ptr.isValidVtx()); - h_nPV_->Fill(PV->size()); + if (fillAllHistograms_) { + h_PV_x_->Fill(PV0Ptr.x()); + h_PV_y_->Fill(PV0Ptr.y()); + h_PV_z_->Fill(PV0Ptr.z()); + h_PV_xError_->Fill(PV0Ptr.xError()); + h_PV_yError_->Fill(PV0Ptr.yError()); + h_PV_zError_->Fill(PV0Ptr.zError()); + h_PV_trksize_->Fill(PV0Ptr.tracksSize()); + h_PV_chi2_->Fill(PV0Ptr.chi2()); + h_PV_ndof_->Fill(PV0Ptr.ndof()); + h_PV_isvalidvtx_->Fill(PV0Ptr.isValidVtx()); + h_nPV_->Fill(PV->size()); + } } // Fill ScoutingMuonNoVtx block, including phiCorr logic std::vector muonNoVtx_phiCorr; std::vector> muonNoVtx_vtxIndx; if (muonsNoVtx.isValid()) { - h_nScoutingMuonNoVtx_->Fill(muonsNoVtx->size()); + if (fillAllHistograms_) { + h_nScoutingMuonNoVtx_->Fill(muonsNoVtx->size()); + } for (size_t i = 0; i < muonsNoVtx->size(); ++i) { const auto& mu = muonsNoVtx->at(i); - h_ScoutingMuonNoVtx_pt_->Fill(mu.pt()); - h_ScoutingMuonNoVtx_eta_->Fill(mu.eta()); - h_ScoutingMuonNoVtx_phi_->Fill(mu.phi()); + if (fillAllHistograms_) { + h_ScoutingMuonNoVtx_pt_->Fill(mu.pt()); + h_ScoutingMuonNoVtx_eta_->Fill(mu.eta()); + h_ScoutingMuonNoVtx_phi_->Fill(mu.phi()); + h_ScoutingMuonNoVtx_charge_->Fill(mu.charge()); + h_ScoutingMuonNoVtx_trkchi2_->Fill(mu.trk_chi2()); + h_ScoutingMuonNoVtx_trkndof_->Fill(mu.trk_ndof()); + h_ScoutingMuonNoVtx_trkdxy_->Fill(mu.trk_dxy()); + h_ScoutingMuonNoVtx_trkdz_->Fill(mu.trk_dz()); + h_ScoutingMuonNoVtx_trkqoverp_->Fill(mu.trk_qoverp()); + h_ScoutingMuonNoVtx_trklambda_->Fill(mu.trk_lambda()); + h_ScoutingMuonNoVtx_trkpt_->Fill(mu.trk_pt()); + h_ScoutingMuonNoVtx_trkphi_->Fill(mu.trk_phi()); + h_ScoutingMuonNoVtx_trketa_->Fill(mu.trk_eta()); + h_ScoutingMuonNoVtx_trkqoverpError_->Fill(mu.trk_qoverpError()); + h_ScoutingMuonNoVtx_trklambdaError_->Fill(mu.trk_lambdaError()); + h_ScoutingMuonNoVtx_trkdxyError_->Fill(mu.trk_dxyError()); + h_ScoutingMuonNoVtx_trkdzError_->Fill(mu.trk_dzError()); + h_ScoutingMuonNoVtx_trkphiError_->Fill(mu.trk_phiError()); + h_ScoutingMuonNoVtx_trkdsz_->Fill(mu.trk_dsz()); + h_ScoutingMuonNoVtx_trkdszError_->Fill(mu.trk_dszError()); + h_ScoutingMuonNoVtx_trkvx_->Fill(mu.trk_vx()); + h_ScoutingMuonNoVtx_trkvy_->Fill(mu.trk_vy()); + h_ScoutingMuonNoVtx_trkvz_->Fill(mu.trk_vz()); + } + h_ScoutingMuonNoVtx_m_->Fill(mu.m()); - h_ScoutingMuonNoVtx_charge_->Fill(mu.charge()); - h_ScoutingMuonNoVtx_trkchi2_->Fill(mu.trk_chi2()); - h_ScoutingMuonNoVtx_trkndof_->Fill(mu.trk_ndof()); - h_ScoutingMuonNoVtx_trkdxy_->Fill(mu.trk_dxy()); - h_ScoutingMuonNoVtx_trkdz_->Fill(mu.trk_dz()); - h_ScoutingMuonNoVtx_trkqoverp_->Fill(mu.trk_qoverp()); - h_ScoutingMuonNoVtx_trklambda_->Fill(mu.trk_lambda()); - h_ScoutingMuonNoVtx_trkpt_->Fill(mu.trk_pt()); - h_ScoutingMuonNoVtx_trkphi_->Fill(mu.trk_phi()); - h_ScoutingMuonNoVtx_trketa_->Fill(mu.trk_eta()); - h_ScoutingMuonNoVtx_trkqoverpError_->Fill(mu.trk_qoverpError()); - h_ScoutingMuonNoVtx_trklambdaError_->Fill(mu.trk_lambdaError()); - h_ScoutingMuonNoVtx_trkdxyError_->Fill(mu.trk_dxyError()); - h_ScoutingMuonNoVtx_trkdzError_->Fill(mu.trk_dzError()); - h_ScoutingMuonNoVtx_trkphiError_->Fill(mu.trk_phiError()); - h_ScoutingMuonNoVtx_trkdsz_->Fill(mu.trk_dsz()); - h_ScoutingMuonNoVtx_trkdszError_->Fill(mu.trk_dszError()); - h_ScoutingMuonNoVtx_trkvx_->Fill(mu.trk_vx()); - h_ScoutingMuonNoVtx_trkvy_->Fill(mu.trk_vy()); - h_ScoutingMuonNoVtx_trkvz_->Fill(mu.trk_vz()); h_ScoutingMuonNoVtx_vtxIndx_->Fill(mu.vtxIndx().size()); muonNoVtx_vtxIndx.push_back(mu.vtxIndx()); // Extrapolated phiCorr logic @@ -500,33 +527,38 @@ void ScoutingMuonPropertiesAnalyzer::analyze(const edm::Event& iEvent, const edm std::vector muonVtx_phiCorr; std::vector> muonVtx_vtxIndx; if (muonsVtx.isValid()) { - h_nScoutingMuonVtx_->Fill(muonsVtx->size()); + if (fillAllHistograms_) { + h_nScoutingMuonVtx_->Fill(muonsVtx->size()); + } for (size_t i = 0; i < muonsVtx->size(); ++i) { const auto& mu = muonsVtx->at(i); - h_ScoutingMuonVtx_pt_->Fill(mu.pt()); - h_ScoutingMuonVtx_eta_->Fill(mu.eta()); - h_ScoutingMuonVtx_phi_->Fill(mu.phi()); + if (fillAllHistograms_) { + h_ScoutingMuonVtx_pt_->Fill(mu.pt()); + h_ScoutingMuonVtx_eta_->Fill(mu.eta()); + h_ScoutingMuonVtx_phi_->Fill(mu.phi()); + h_ScoutingMuonVtx_charge_->Fill(mu.charge()); + h_ScoutingMuonVtx_trkchi2_->Fill(mu.trk_chi2()); + h_ScoutingMuonVtx_trkndof_->Fill(mu.trk_ndof()); + h_ScoutingMuonVtx_trkdxy_->Fill(mu.trk_dxy()); + h_ScoutingMuonVtx_trkdz_->Fill(mu.trk_dz()); + h_ScoutingMuonVtx_trkqoverp_->Fill(mu.trk_qoverp()); + h_ScoutingMuonVtx_trklambda_->Fill(mu.trk_lambda()); + h_ScoutingMuonVtx_trkpt_->Fill(mu.trk_pt()); + h_ScoutingMuonVtx_trkphi_->Fill(mu.trk_phi()); + h_ScoutingMuonVtx_trketa_->Fill(mu.trk_eta()); + h_ScoutingMuonVtx_trkqoverpError_->Fill(mu.trk_qoverpError()); + h_ScoutingMuonVtx_trklambdaError_->Fill(mu.trk_lambdaError()); + h_ScoutingMuonVtx_trkdxyError_->Fill(mu.trk_dxyError()); + h_ScoutingMuonVtx_trkdzError_->Fill(mu.trk_dzError()); + h_ScoutingMuonVtx_trkphiError_->Fill(mu.trk_phiError()); + h_ScoutingMuonVtx_trkdsz_->Fill(mu.trk_dsz()); + h_ScoutingMuonVtx_trkdszError_->Fill(mu.trk_dszError()); + h_ScoutingMuonVtx_trkvx_->Fill(mu.trk_vx()); + h_ScoutingMuonVtx_trkvy_->Fill(mu.trk_vy()); + h_ScoutingMuonVtx_trkvz_->Fill(mu.trk_vz()); + } + h_ScoutingMuonVtx_m_->Fill(mu.m()); - h_ScoutingMuonVtx_charge_->Fill(mu.charge()); - h_ScoutingMuonVtx_trkchi2_->Fill(mu.trk_chi2()); - h_ScoutingMuonVtx_trkndof_->Fill(mu.trk_ndof()); - h_ScoutingMuonVtx_trkdxy_->Fill(mu.trk_dxy()); - h_ScoutingMuonVtx_trkdz_->Fill(mu.trk_dz()); - h_ScoutingMuonVtx_trkqoverp_->Fill(mu.trk_qoverp()); - h_ScoutingMuonVtx_trklambda_->Fill(mu.trk_lambda()); - h_ScoutingMuonVtx_trkpt_->Fill(mu.trk_pt()); - h_ScoutingMuonVtx_trkphi_->Fill(mu.trk_phi()); - h_ScoutingMuonVtx_trketa_->Fill(mu.trk_eta()); - h_ScoutingMuonVtx_trkqoverpError_->Fill(mu.trk_qoverpError()); - h_ScoutingMuonVtx_trklambdaError_->Fill(mu.trk_lambdaError()); - h_ScoutingMuonVtx_trkdxyError_->Fill(mu.trk_dxyError()); - h_ScoutingMuonVtx_trkdzError_->Fill(mu.trk_dzError()); - h_ScoutingMuonVtx_trkphiError_->Fill(mu.trk_phiError()); - h_ScoutingMuonVtx_trkdsz_->Fill(mu.trk_dsz()); - h_ScoutingMuonVtx_trkdszError_->Fill(mu.trk_dszError()); - h_ScoutingMuonVtx_trkvx_->Fill(mu.trk_vx()); - h_ScoutingMuonVtx_trkvy_->Fill(mu.trk_vy()); - h_ScoutingMuonVtx_trkvz_->Fill(mu.trk_vz()); h_ScoutingMuonVtx_vtxIndx_->Fill(mu.vtxIndx().size()); muonVtx_vtxIndx.push_back(mu.vtxIndx()); // Extrapolated phiCorr logic @@ -564,19 +596,23 @@ void ScoutingMuonPropertiesAnalyzer::analyze(const edm::Event& iEvent, const edm VertexDistance3D vdist; VertexDistanceXY vdistXY; if (SVNoVtx.isValid()) { - h_nSVNoVtx_->Fill(SVNoVtx->size()); + if (fillAllHistograms_) { + h_nSVNoVtx_->Fill(SVNoVtx->size()); + } for (size_t i = 0; i < SVNoVtx->size(); ++i) { const auto& sv = SVNoVtx->at(i); - h_SVNoVtx_x_->Fill(sv.x()); - h_SVNoVtx_y_->Fill(sv.y()); - h_SVNoVtx_z_->Fill(sv.z()); - h_SVNoVtx_xError_->Fill(sv.xError()); - h_SVNoVtx_yError_->Fill(sv.yError()); - h_SVNoVtx_zError_->Fill(sv.zError()); - h_SVNoVtx_trksize_->Fill(sv.tracksSize()); - h_SVNoVtx_chi2_->Fill(sv.chi2()); - h_SVNoVtx_ndof_->Fill(sv.ndof()); - h_SVNoVtx_isvalidvtx_->Fill(sv.isValidVtx()); + if (fillAllHistograms_) { + h_SVNoVtx_x_->Fill(sv.x()); + h_SVNoVtx_y_->Fill(sv.y()); + h_SVNoVtx_z_->Fill(sv.z()); + h_SVNoVtx_xError_->Fill(sv.xError()); + h_SVNoVtx_yError_->Fill(sv.yError()); + h_SVNoVtx_zError_->Fill(sv.zError()); + h_SVNoVtx_trksize_->Fill(sv.tracksSize()); + h_SVNoVtx_chi2_->Fill(sv.chi2()); + h_SVNoVtx_ndof_->Fill(sv.ndof()); + h_SVNoVtx_isvalidvtx_->Fill(sv.isValidVtx()); + } // Calculated for PV0: if (pvAvailable) { Point svPos(sv.x(), sv.y(), sv.z()); @@ -618,19 +654,23 @@ void ScoutingMuonPropertiesAnalyzer::analyze(const edm::Event& iEvent, const edm // SVVtx block w/ matching and calculations if (SVVtx.isValid()) { - h_nSVVtx_->Fill(SVVtx->size()); + if (fillAllHistograms_) { + h_nSVVtx_->Fill(SVVtx->size()); + } for (size_t i = 0; i < SVVtx->size(); ++i) { const auto& sv = SVVtx->at(i); - h_SVVtx_x_->Fill(sv.x()); - h_SVVtx_y_->Fill(sv.y()); - h_SVVtx_z_->Fill(sv.z()); - h_SVVtx_xError_->Fill(sv.xError()); - h_SVVtx_yError_->Fill(sv.yError()); - h_SVVtx_zError_->Fill(sv.zError()); - h_SVVtx_trksize_->Fill(sv.tracksSize()); - h_SVVtx_chi2_->Fill(sv.chi2()); - h_SVVtx_ndof_->Fill(sv.ndof()); - h_SVVtx_isvalidvtx_->Fill(sv.isValidVtx()); + if (fillAllHistograms_) { + h_SVVtx_x_->Fill(sv.x()); + h_SVVtx_y_->Fill(sv.y()); + h_SVVtx_z_->Fill(sv.z()); + h_SVVtx_xError_->Fill(sv.xError()); + h_SVVtx_yError_->Fill(sv.yError()); + h_SVVtx_zError_->Fill(sv.zError()); + h_SVVtx_trksize_->Fill(sv.tracksSize()); + h_SVVtx_chi2_->Fill(sv.chi2()); + h_SVVtx_ndof_->Fill(sv.ndof()); + h_SVVtx_isvalidvtx_->Fill(sv.isValidVtx()); + } // Calculated for PV0: if (pvAvailable) { Point svPos(sv.x(), sv.y(), sv.z()); @@ -674,6 +714,7 @@ void ScoutingMuonPropertiesAnalyzer::analyze(const edm::Event& iEvent, const edm void ScoutingMuonPropertiesAnalyzer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { edm::ParameterSetDescription desc; desc.add("OutputInternalPath", "HLT/ScoutingOffline/Muons/Properties"); + desc.add("fillAllHistograms", false); desc.add("triggerResults", edm::InputTag("TriggerResults", "", "HLT")); desc.add("muonsNoVtx", edm::InputTag("hltScoutingMuonPackerNoVtx", "", "HLT")); desc.add("muonsVtx", edm::InputTag("hltScoutingMuonPackerVtx", "", "HLT")); diff --git a/HLTriggerOffline/Scouting/python/ScoutingMuonPropertiesMonitoring_cfi.py b/HLTriggerOffline/Scouting/python/ScoutingMuonPropertiesMonitoring_cfi.py index 74de2bcd6c996..1f4192490c71b 100644 --- a/HLTriggerOffline/Scouting/python/ScoutingMuonPropertiesMonitoring_cfi.py +++ b/HLTriggerOffline/Scouting/python/ScoutingMuonPropertiesMonitoring_cfi.py @@ -3,10 +3,10 @@ ScoutingMuonPropertiesMonitor = DQMEDAnalyzer('ScoutingMuonPropertiesAnalyzer', OutputInternalPath = cms.string('/HLT/ScoutingOffline/Muons/Properties'), #Output of the root file + fillAllHistograms = cms.bool(False), triggerResults = cms.InputTag("TriggerResults", "", "HLT"), muonsNoVtx = cms.InputTag("hltScoutingMuonPackerNoVtx", "", "HLT"), muonsVtx = cms.InputTag("hltScoutingMuonPackerVtx", "", "HLT"), PV = cms.InputTag("hltScoutingPrimaryVertexPacker", "primaryVtx", "HLT"), SVNoVtx = cms.InputTag("hltScoutingMuonPackerNoVtx", "displacedVtx", "HLT"), - SVVtx = cms.InputTag("hltScoutingMuonPackerVtx", "displacedVtx", "HLT")) - + SVVtx = cms.InputTag("hltScoutingMuonPackerVtx", "displacedVtx", "HLT")) From 9306c52150706da369d9740217d0f9ddff617b50 Mon Sep 17 00:00:00 2001 From: Marco Musich Date: Sat, 11 Oct 2025 11:34:30 +0200 Subject: [PATCH 10/15] add axes labels to ScoutingMuonPropertiesAnalyzer --- .../plugins/ScoutingMuonPropertiesAnalyzer.cc | 299 +++++++++++++++++- 1 file changed, 297 insertions(+), 2 deletions(-) diff --git a/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc b/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc index 599247b9369a8..7114846a23d4f 100644 --- a/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc +++ b/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc @@ -233,146 +233,441 @@ void ScoutingMuonPropertiesAnalyzer::bookHistograms(DQMStore::IBooker& ibooker, triggerMEMap_[trig] = ibooker.book1D(trig, trig + " fired", 2, 0, 2); h_run_ = ibooker.book1D("run", "Run number", 1000, 200000, 600000); + h_run_->setAxisTitle("Run Number", 1); + h_run_->setAxisTitle("Events", 2); + h_event_ = ibooker.book1D("event", "Event number", 1000, 0, 100000000000); - h_lumi_ = ibooker.book1D("lumi", "Luminosity block", 1000, 0, 5000); + h_event_->setAxisTitle("Event Number", 1); + h_event_->setAxisTitle("Events", 2); - // ScoutingMuonNoVtx + h_lumi_ = ibooker.book1D("lumi", "Luminosity block", 1000, 0, 5000); + h_lumi_->setAxisTitle("Luminosity Block", 1); + h_lumi_->setAxisTitle("Events", 2); if (fillAllHistograms_) { // ScoutingMuonNoVtx h_nScoutingMuonNoVtx_ = ibooker.book1D("nScoutingMuonNoVtx", "Number of ScoutingMuonNoVtx", 20, 0, 10); + h_nScoutingMuonNoVtx_->setAxisTitle("Number of Muons", 1); + h_nScoutingMuonNoVtx_->setAxisTitle("Events", 2); + h_ScoutingMuonNoVtx_pt_ = ibooker.book1D("ScoutingMuonNoVtx_pt", "MuonNoVtx p_{T}", 100, 0, 100); + h_ScoutingMuonNoVtx_pt_->setAxisTitle("p_{T} [GeV]", 1); + h_ScoutingMuonNoVtx_pt_->setAxisTitle("Muons", 2); + h_ScoutingMuonNoVtx_eta_ = ibooker.book1D("ScoutingMuonNoVtx_eta", "MuonNoVtx #eta", 80, -3, 3); + h_ScoutingMuonNoVtx_eta_->setAxisTitle("#eta", 1); + h_ScoutingMuonNoVtx_eta_->setAxisTitle("Muons", 2); + h_ScoutingMuonNoVtx_phi_ = ibooker.book1D("ScoutingMuonNoVtx_phi", "MuonNoVtx #phi", 64, -3.5, 3.5); + h_ScoutingMuonNoVtx_phi_->setAxisTitle("#phi [rad]", 1); + h_ScoutingMuonNoVtx_phi_->setAxisTitle("Muons", 2); + h_ScoutingMuonNoVtx_charge_ = ibooker.book1D("ScoutingMuonNoVtx_charge", "MuonNoVtx charge", 2, -1, 1); + h_ScoutingMuonNoVtx_charge_->setAxisTitle("Charge", 1); + h_ScoutingMuonNoVtx_charge_->setAxisTitle("Muons", 2); + h_ScoutingMuonNoVtx_trkchi2_ = ibooker.book1D("ScoutingMuonNoVtx_trkchi2", "MuonNoVtx track #chi^{2}", 100, 0, 100); + h_ScoutingMuonNoVtx_trkchi2_->setAxisTitle("Track #chi^{2}", 1); + h_ScoutingMuonNoVtx_trkchi2_->setAxisTitle("Muons", 2); + h_ScoutingMuonNoVtx_trkndof_ = ibooker.book1D("ScoutingMuonNoVtx_trkndof", "MuonNoVtx track ndof", 40, 0, 50); + h_ScoutingMuonNoVtx_trkndof_->setAxisTitle("Track ndof", 1); + h_ScoutingMuonNoVtx_trkndof_->setAxisTitle("Muons", 2); + h_ScoutingMuonNoVtx_trkdxy_ = ibooker.book1D("ScoutingMuonNoVtx_trkdxy", "MuonNoVtx track dxy", 100, -0.7, 0.7); + h_ScoutingMuonNoVtx_trkdxy_->setAxisTitle("Track dxy [cm]", 1); + h_ScoutingMuonNoVtx_trkdxy_->setAxisTitle("Muons", 2); + h_ScoutingMuonNoVtx_trkdz_ = ibooker.book1D("ScoutingMuonNoVtx_trkdz", "MuonNoVtx track dz", 100, -40, 40); + h_ScoutingMuonNoVtx_trkdz_->setAxisTitle("Track dz [cm]", 1); + h_ScoutingMuonNoVtx_trkdz_->setAxisTitle("Muons", 2); + h_ScoutingMuonNoVtx_trkqoverp_ = ibooker.book1D("ScoutingMuonNoVtx_trkqoverp", "MuonNoVtx track q/p", 100, -1, 1); + h_ScoutingMuonNoVtx_trkqoverp_->setAxisTitle("Track q/p [1/GeV]", 1); + h_ScoutingMuonNoVtx_trkqoverp_->setAxisTitle("Muons", 2); + h_ScoutingMuonNoVtx_trklambda_ = ibooker.book1D("ScoutingMuonNoVtx_trklambda", "MuonNoVtx track lambda", 100, -2, 2); + h_ScoutingMuonNoVtx_trklambda_->setAxisTitle("Track #lambda [rad]", 1); + h_ScoutingMuonNoVtx_trklambda_->setAxisTitle("Muons", 2); + h_ScoutingMuonNoVtx_trkpt_ = ibooker.book1D("ScoutingMuonNoVtx_trkpt", "MuonNoVtx track pt", 100, 0, 100); + h_ScoutingMuonNoVtx_trkpt_->setAxisTitle("Track p_{T} [GeV]", 1); + h_ScoutingMuonNoVtx_trkpt_->setAxisTitle("Muons", 2); + h_ScoutingMuonNoVtx_trkphi_ = ibooker.book1D("ScoutingMuonNoVtx_trkphi", "MuonNoVtx track phi", 64, -3.4, 3.4); + h_ScoutingMuonNoVtx_trkphi_->setAxisTitle("Track #phi [rad]", 1); + h_ScoutingMuonNoVtx_trkphi_->setAxisTitle("Muons", 2); + h_ScoutingMuonNoVtx_trketa_ = ibooker.book1D("ScoutingMuonNoVtx_trketa", "MuonNoVtx track eta", 80, -4, 4); + h_ScoutingMuonNoVtx_trketa_->setAxisTitle("Track #eta", 1); + h_ScoutingMuonNoVtx_trketa_->setAxisTitle("Muons", 2); + h_ScoutingMuonNoVtx_trkqoverpError_ = ibooker.book1D("ScoutingMuonNoVtx_trkqoverpError", "MuonNoVtx track q/p error", 100, 0, 0.01); + h_ScoutingMuonNoVtx_trkqoverpError_->setAxisTitle("Track q/p Error", 1); + h_ScoutingMuonNoVtx_trkqoverpError_->setAxisTitle("Muons", 2); + h_ScoutingMuonNoVtx_trklambdaError_ = ibooker.book1D("ScoutingMuonNoVtx_trklambdaError", "MuonNoVtx track lambda error", 100, 0, 0.1); + h_ScoutingMuonNoVtx_trklambdaError_->setAxisTitle("Track #lambda Error", 1); + h_ScoutingMuonNoVtx_trklambdaError_->setAxisTitle("Muons", 2); + h_ScoutingMuonNoVtx_trkdxyError_ = ibooker.book1D("ScoutingMuonNoVtx_trkdxyError", "MuonNoVtx track dxy error", 100, 0, 0.1); + h_ScoutingMuonNoVtx_trkdxyError_->setAxisTitle("Track dxy Error [cm]", 1); + h_ScoutingMuonNoVtx_trkdxyError_->setAxisTitle("Muons", 2); + h_ScoutingMuonNoVtx_trkdzError_ = ibooker.book1D("ScoutingMuonNoVtx_trkdzError", "MuonNoVtx track dz error", 100, 0, 1); + h_ScoutingMuonNoVtx_trkdzError_->setAxisTitle("Track dz Error [cm]", 1); + h_ScoutingMuonNoVtx_trkdzError_->setAxisTitle("Muons", 2); + h_ScoutingMuonNoVtx_trkphiError_ = ibooker.book1D("ScoutingMuonNoVtx_trkphiError", "MuonNoVtx track phi error", 100, 0, 0.1); + h_ScoutingMuonNoVtx_trkphiError_->setAxisTitle("Track #phi Error [rad]", 1); + h_ScoutingMuonNoVtx_trkphiError_->setAxisTitle("Muons", 2); + h_ScoutingMuonNoVtx_trkdsz_ = ibooker.book1D("ScoutingMuonNoVtx_trkdsz", "MuonNoVtx track dsz", 100, -50, 50); + h_ScoutingMuonNoVtx_trkdsz_->setAxisTitle("Track dsz [cm]", 1); + h_ScoutingMuonNoVtx_trkdsz_->setAxisTitle("Muons", 2); + h_ScoutingMuonNoVtx_trkdszError_ = ibooker.book1D("ScoutingMuonNoVtx_trkdszError", "MuonNoVtx track dsz error", 100, 0, 1); + h_ScoutingMuonNoVtx_trkdszError_->setAxisTitle("Track dsz Error [cm]", 1); + h_ScoutingMuonNoVtx_trkdszError_->setAxisTitle("Muons", 2); + h_ScoutingMuonNoVtx_trkvx_ = ibooker.book1D("ScoutingMuonNoVtx_trkvx", "MuonNoVtx track vx", 100, -0.5, 0.5); + h_ScoutingMuonNoVtx_trkvx_->setAxisTitle("Track vx [cm]", 1); + h_ScoutingMuonNoVtx_trkvx_->setAxisTitle("Muons", 2); + h_ScoutingMuonNoVtx_trkvy_ = ibooker.book1D("ScoutingMuonNoVtx_trkvy", "MuonNoVtx track vy", 100, -0.5, 0.5); + h_ScoutingMuonNoVtx_trkvy_->setAxisTitle("Track vy [cm]", 1); + h_ScoutingMuonNoVtx_trkvy_->setAxisTitle("Muons", 2); + h_ScoutingMuonNoVtx_trkvz_ = ibooker.book1D("ScoutingMuonNoVtx_trkvz", "MuonNoVtx track vz", 100, -50, 50); + h_ScoutingMuonNoVtx_trkvz_->setAxisTitle("Track vz [cm]", 1); + h_ScoutingMuonNoVtx_trkvz_->setAxisTitle("Muons", 2); // ScoutingMuonVtx h_nScoutingMuonVtx_ = ibooker.book1D("nScoutingMuonVtx", "Number of ScoutingMuonVtx", 20, 0, 20); + h_nScoutingMuonVtx_->setAxisTitle("Number of Muons", 1); + h_nScoutingMuonVtx_->setAxisTitle("Events", 2); + h_ScoutingMuonVtx_pt_ = ibooker.book1D("ScoutingMuonVtx_pt", "MuonVtx p_{T}", 100, 0, 100); + h_ScoutingMuonVtx_pt_->setAxisTitle("p_{T} [GeV]", 1); + h_ScoutingMuonVtx_pt_->setAxisTitle("Muons", 2); + h_ScoutingMuonVtx_eta_ = ibooker.book1D("ScoutingMuonVtx_eta", "MuonVtx #eta", 80, -4, 4); + h_ScoutingMuonVtx_eta_->setAxisTitle("#eta", 1); + h_ScoutingMuonVtx_eta_->setAxisTitle("Muons", 2); + h_ScoutingMuonVtx_phi_ = ibooker.book1D("ScoutingMuonVtx_phi", "MuonVtx #phi", 64, -3.4, 3.4); + h_ScoutingMuonVtx_phi_->setAxisTitle("#phi [rad]", 1); + h_ScoutingMuonVtx_phi_->setAxisTitle("Muons", 2); + h_ScoutingMuonVtx_charge_ = ibooker.book1D("ScoutingMuonVtx_charge", "MuonVtx charge", 2, -1, 1); + h_ScoutingMuonVtx_charge_->setAxisTitle("Charge", 1); + h_ScoutingMuonVtx_charge_->setAxisTitle("Muons", 2); + h_ScoutingMuonVtx_trkchi2_ = ibooker.book1D("ScoutingMuonVtx_trkchi2", "MuonVtx track #chi^{2}", 100, 0, 100); + h_ScoutingMuonVtx_trkchi2_->setAxisTitle("Track #chi^{2}", 1); + h_ScoutingMuonVtx_trkchi2_->setAxisTitle("Muons", 2); + h_ScoutingMuonVtx_trkndof_ = ibooker.book1D("ScoutingMuonVtx_trkndof", "MuonVtx track ndof", 40, 0, 60); + h_ScoutingMuonVtx_trkndof_->setAxisTitle("Track ndof", 1); + h_ScoutingMuonVtx_trkndof_->setAxisTitle("Muons", 2); + h_ScoutingMuonVtx_trkdxy_ = ibooker.book1D("ScoutingMuonVtx_trkdxy", "MuonVtx track dxy", 100, -0.5, 0.5); + h_ScoutingMuonVtx_trkdxy_->setAxisTitle("Track dxy [cm]", 1); + h_ScoutingMuonVtx_trkdxy_->setAxisTitle("Muons", 2); + h_ScoutingMuonVtx_trkdz_ = ibooker.book1D("ScoutingMuonVtx_trkdz", "MuonVtx track dz", 100, -20, 20); + h_ScoutingMuonVtx_trkdz_->setAxisTitle("Track dz [cm]", 1); + h_ScoutingMuonVtx_trkdz_->setAxisTitle("Muons", 2); + h_ScoutingMuonVtx_trkqoverp_ = ibooker.book1D("ScoutingMuonVtx_trkqoverp", "MuonVtx track q/p", 100, -0.4, 0.4); + h_ScoutingMuonVtx_trkqoverp_->setAxisTitle("Track q/p [1/GeV]", 1); + h_ScoutingMuonVtx_trkqoverp_->setAxisTitle("Muons", 2); + h_ScoutingMuonVtx_trklambda_ = ibooker.book1D("ScoutingMuonVtx_trklambda", "MuonVtx track lambda", 100, -2, 2); + h_ScoutingMuonVtx_trklambda_->setAxisTitle("Track #lambda [rad]", 1); + h_ScoutingMuonVtx_trklambda_->setAxisTitle("Muons", 2); + h_ScoutingMuonVtx_trkpt_ = ibooker.book1D("ScoutingMuonVtx_trkpt", "MuonVtx track pt", 100, 0, 100); + h_ScoutingMuonVtx_trkpt_->setAxisTitle("Track p_{T} [GeV]", 1); + h_ScoutingMuonVtx_trkpt_->setAxisTitle("Muons", 2); + h_ScoutingMuonVtx_trkphi_ = ibooker.book1D("ScoutingMuonVtx_trkphi", "MuonVtx track phi", 64, -3.4, 3.4); + h_ScoutingMuonVtx_trkphi_->setAxisTitle("Track #phi [rad]", 1); + h_ScoutingMuonVtx_trkphi_->setAxisTitle("Muons", 2); + h_ScoutingMuonVtx_trketa_ = ibooker.book1D("ScoutingMuonVtx_trketa", "MuonVtx track eta", 80, -4, 4); + h_ScoutingMuonVtx_trketa_->setAxisTitle("Track #eta", 1); + h_ScoutingMuonVtx_trketa_->setAxisTitle("Muons", 2); + h_ScoutingMuonVtx_trkqoverpError_ = ibooker.book1D("ScoutingMuonVtx_trkqoverpError", "MuonVtx track q/p error", 100, 0, 0.01); + h_ScoutingMuonVtx_trkqoverpError_->setAxisTitle("Track q/p Error", 1); + h_ScoutingMuonVtx_trkqoverpError_->setAxisTitle("Muons", 2); + h_ScoutingMuonVtx_trklambdaError_ = ibooker.book1D("ScoutingMuonVtx_trklambdaError", "MuonVtx track lambda error", 100, 0, 0.1); + h_ScoutingMuonVtx_trklambdaError_->setAxisTitle("Track #lambda Error", 1); + h_ScoutingMuonVtx_trklambdaError_->setAxisTitle("Muons", 2); + h_ScoutingMuonVtx_trkdxyError_ = ibooker.book1D("ScoutingMuonVtx_trkdxyError", "MuonVtx track dxy error", 100, 0, 0.1); + h_ScoutingMuonVtx_trkdxyError_->setAxisTitle("Track dxy Error [cm]", 1); + h_ScoutingMuonVtx_trkdxyError_->setAxisTitle("Muons", 2); + h_ScoutingMuonVtx_trkdzError_ = ibooker.book1D("ScoutingMuonVtx_trkdzError", "MuonVtx track dz error", 100, 0, 1); + h_ScoutingMuonVtx_trkdzError_->setAxisTitle("Track dz Error [cm]", 1); + h_ScoutingMuonVtx_trkdzError_->setAxisTitle("Muons", 2); + h_ScoutingMuonVtx_trkphiError_ = ibooker.book1D("ScoutingMuonVtx_trkphiError", "MuonVtx track phi error", 100, 0, 0.1); + h_ScoutingMuonVtx_trkphiError_->setAxisTitle("Track #phi Error [rad]", 1); + h_ScoutingMuonVtx_trkphiError_->setAxisTitle("Muons", 2); + h_ScoutingMuonVtx_trkdsz_ = ibooker.book1D("ScoutingMuonVtx_trkdsz", "MuonVtx track dsz", 100, -20, 20); + h_ScoutingMuonVtx_trkdsz_->setAxisTitle("Track dsz [cm]", 1); + h_ScoutingMuonVtx_trkdsz_->setAxisTitle("Muons", 2); + h_ScoutingMuonVtx_trkdszError_ = ibooker.book1D("ScoutingMuonVtx_trkdszError", "MuonVtx track dsz error", 100, 0, 1); + h_ScoutingMuonVtx_trkdszError_->setAxisTitle("Track dsz Error [cm]", 1); + h_ScoutingMuonVtx_trkdszError_->setAxisTitle("Muons", 2); + h_ScoutingMuonVtx_trkvx_ = ibooker.book1D("ScoutingMuonVtx_trkvx", "MuonVtx track vx", 100, -0.5, 0.5); + h_ScoutingMuonVtx_trkvx_->setAxisTitle("Track vx [cm]", 1); + h_ScoutingMuonVtx_trkvx_->setAxisTitle("Muons", 2); + h_ScoutingMuonVtx_trkvy_ = ibooker.book1D("ScoutingMuonVtx_trkvy", "MuonVtx track vy", 100, -0.5, 0.5); + h_ScoutingMuonVtx_trkvy_->setAxisTitle("Track vy [cm]", 1); + h_ScoutingMuonVtx_trkvy_->setAxisTitle("Muons", 2); + h_ScoutingMuonVtx_trkvz_ = ibooker.book1D("ScoutingMuonVtx_trkvz", "MuonVtx track vz", 100, -20, 20); + h_ScoutingMuonVtx_trkvz_->setAxisTitle("Track vz [cm]", 1); + h_ScoutingMuonVtx_trkvz_->setAxisTitle("Muons", 2); // PV h_nPV_ = ibooker.book1D("nPV", "Number of PVs", 10, 0, 70); + h_nPV_->setAxisTitle("Number of PVs", 1); + h_nPV_->setAxisTitle("Events", 2); + h_PV_x_ = ibooker.book1D("PV_x", "PV x", 100, -0.5, 0.5); + h_PV_x_->setAxisTitle("x [cm]", 1); + h_PV_x_->setAxisTitle("Vertices", 2); + h_PV_y_ = ibooker.book1D("PV_y", "PV y", 100, -0.5, 0.5); + h_PV_y_->setAxisTitle("y [cm]", 1); + h_PV_y_->setAxisTitle("Vertices", 2); + h_PV_z_ = ibooker.book1D("PV_z", "PV z", 100, -20, 20); + h_PV_z_->setAxisTitle("z [cm]", 1); + h_PV_z_->setAxisTitle("Vertices", 2); + h_PV_xError_ = ibooker.book1D("PV_xError", "PV x error", 100, 0, 0.01); + h_PV_xError_->setAxisTitle("x Error [cm]", 1); + h_PV_xError_->setAxisTitle("Vertices", 2); + h_PV_yError_ = ibooker.book1D("PV_yError", "PV y error", 100, 0, 0.01); + h_PV_yError_->setAxisTitle("y Error [cm]", 1); + h_PV_yError_->setAxisTitle("Vertices", 2); + h_PV_zError_ = ibooker.book1D("PV_zError", "PV z error", 100, 0, 0.1); + h_PV_zError_->setAxisTitle("z Error [cm]", 1); + h_PV_zError_->setAxisTitle("Vertices", 2); + h_PV_trksize_ = ibooker.book1D("PV_trksize", "PV tracks size", 40, 0, 200); + h_PV_trksize_->setAxisTitle("PV Track Size", 1); + h_PV_trksize_->setAxisTitle("Vertices", 2); + h_PV_chi2_ = ibooker.book1D("PV_chi2", "PV #chi^2", 100, 0, 300); + h_PV_chi2_->setAxisTitle("PV #chi^{2}", 1); + h_PV_chi2_->setAxisTitle("Vertices", 2); + h_PV_ndof_ = ibooker.book1D("PV_ndof", "PV ndof", 40, 0, 100); + h_PV_ndof_->setAxisTitle("PV ndof", 1); + h_PV_ndof_->setAxisTitle("Vertices", 2); + h_PV_isvalidvtx_ = ibooker.book1D("PV_isvalidvtx", "PV is valid vtx", 2, 0, 2); + h_PV_isvalidvtx_->setAxisTitle("Is Valid Vertex", 1); + h_PV_isvalidvtx_->setAxisTitle("Vertices", 2); // SVNoVtx h_nSVNoVtx_ = ibooker.book1D("nSVNoVtx", "Number of SVNoVtx", 20, 0, 20); + h_nSVNoVtx_->setAxisTitle("Number of SVNoVtx", 1); + h_nSVNoVtx_->setAxisTitle("Events", 2); + h_SVNoVtx_x_ = ibooker.book1D("SVNoVtx_x", "SVNoVtx x", 100, -0.5, 0.5); + h_SVNoVtx_x_->setAxisTitle("x [cm]", 1); + h_SVNoVtx_x_->setAxisTitle("Vertices", 2); + h_SVNoVtx_y_ = ibooker.book1D("SVNoVtx_y", "SVNoVtx y", 100, -0.5, 0.5); + h_SVNoVtx_y_->setAxisTitle("y [cm]", 1); + h_SVNoVtx_y_->setAxisTitle("Vertices", 2); + h_SVNoVtx_z_ = ibooker.book1D("SVNoVtx_z", "SVNoVtx z", 100, -20, 20); + h_SVNoVtx_z_->setAxisTitle("z [cm]", 1); + h_SVNoVtx_z_->setAxisTitle("Vertices", 2); + h_SVNoVtx_xError_ = ibooker.book1D("SVNoVtx_xError", "SVNoVtx x error", 100, 0, 0.01); + h_SVNoVtx_xError_->setAxisTitle("x Error [cm]", 1); + h_SVNoVtx_xError_->setAxisTitle("Vertices", 2); + h_SVNoVtx_yError_ = ibooker.book1D("SVNoVtx_yError", "SVNoVtx y error", 100, 0, 0.01); + h_SVNoVtx_yError_->setAxisTitle("y Error [cm]", 1); + h_SVNoVtx_yError_->setAxisTitle("Vertices", 2); + h_SVNoVtx_zError_ = ibooker.book1D("SVNoVtx_zError", "SVNoVtx z error", 100, 0, 0.01); + h_SVNoVtx_zError_->setAxisTitle("z Error [cm]", 1); + h_SVNoVtx_zError_->setAxisTitle("Vertices", 2); + h_SVNoVtx_trksize_ = ibooker.book1D("SVNoVtx_trksize", "SVNoVtx tracks size", 40, 0, 40); + h_SVNoVtx_trksize_->setAxisTitle("SVNoVtx Track Size", 1); + h_SVNoVtx_trksize_->setAxisTitle("Vertices", 2); + h_SVNoVtx_chi2_ = ibooker.book1D("SVNoVtx_chi2", "SVNoVtx #chi^2", 100, 0, 50); + h_SVNoVtx_chi2_->setAxisTitle("SVNoVtx #chi^{2}", 1); + h_SVNoVtx_chi2_->setAxisTitle("Vertices", 2); + h_SVNoVtx_ndof_ = ibooker.book1D("SVNoVtx_ndof", "SVNoVtx ndof", 40, 0, 40); + h_SVNoVtx_ndof_->setAxisTitle("SVNoVtx ndof", 1); + h_SVNoVtx_ndof_->setAxisTitle("Vertices", 2); + h_SVNoVtx_isvalidvtx_ = ibooker.book1D("SVNoVtx_isvalidvtx", "SVNoVtx is valid vtx", 2, 0, 2); + h_SVNoVtx_isvalidvtx_->setAxisTitle("Is Valid Vertex", 1); + h_SVNoVtx_isvalidvtx_->setAxisTitle("Vertices", 2); // SVVtx h_nSVVtx_ = ibooker.book1D("nSVVtx", "Number of SVVtx", 20, 0, 20); + h_nSVVtx_->setAxisTitle("Number of SVVtx", 1); + h_nSVVtx_->setAxisTitle("Events", 2); + h_SVVtx_x_ = ibooker.book1D("SVVtx_x", "SVVtx x", 100, -0.5, 0.5); + h_SVVtx_x_->setAxisTitle("x [cm]", 1); + h_SVVtx_x_->setAxisTitle("Vertices", 2); + h_SVVtx_y_ = ibooker.book1D("SVVtx_y", "SVVtx y", 100, -0.5, 0.5); + h_SVVtx_y_->setAxisTitle("y [cm]", 1); + h_SVVtx_y_->setAxisTitle("Vertices", 2); + h_SVVtx_z_ = ibooker.book1D("SVVtx_z", "SVVtx z", 100, -20, 20); + h_SVVtx_z_->setAxisTitle("z [cm]", 1); + h_SVVtx_z_->setAxisTitle("Vertices", 2); + h_SVVtx_xError_ = ibooker.book1D("SVVtx_xError", "SVVtx x error", 100, 0, 0.01); + h_SVVtx_xError_->setAxisTitle("x Error [cm]", 1); + h_SVVtx_xError_->setAxisTitle("Vertices", 2); + h_SVVtx_yError_ = ibooker.book1D("SVVtx_yError", "SVVtx y error", 100, 0, 0.01); + h_SVVtx_yError_->setAxisTitle("y Error [cm]", 1); + h_SVVtx_yError_->setAxisTitle("Vertices", 2); + h_SVVtx_zError_ = ibooker.book1D("SVVtx_zError", "SVVtx z error", 100, 0, 0.01); + h_SVVtx_zError_->setAxisTitle("z Error [cm]", 1); + h_SVVtx_zError_->setAxisTitle("Vertices", 2); + h_SVVtx_trksize_ = ibooker.book1D("SVVtx_trksize", "SVVtx tracks size", 40, 0, 40); + h_SVVtx_trksize_->setAxisTitle("SVVtx Track Size", 1); + h_SVVtx_trksize_->setAxisTitle("Vertices", 2); + h_SVVtx_chi2_ = ibooker.book1D("SVVtx_chi2", "SVVtx #chi^2", 100, 0, 20); + h_SVVtx_chi2_->setAxisTitle("SVVtx #chi^{2}", 1); + h_SVVtx_chi2_->setAxisTitle("Vertices", 2); + h_SVVtx_ndof_ = ibooker.book1D("SVVtx_ndof", "SVVtx ndof", 40, 0, 40); + h_SVVtx_ndof_->setAxisTitle("SVVtx ndof", 1); + h_SVVtx_ndof_->setAxisTitle("Vertices", 2); + h_SVVtx_isvalidvtx_ = ibooker.book1D("SVVtx_isvalidvtx", "SVVtx is valid vtx", 2, 0, 2); + h_SVVtx_isvalidvtx_->setAxisTitle("Is Valid Vertex", 1); + h_SVVtx_isvalidvtx_->setAxisTitle("Vertices", 2); } // ScoutingMuonNoVtx h_ScoutingMuonNoVtx_phiCorr_ = ibooker.book1D("ScoutingMuonNoVtx_phiCorr", "MuonNoVtx #phi extrapolated", 64, -3.5, 3.5); + h_ScoutingMuonNoVtx_phiCorr_->setAxisTitle("#phi extrapolated [rad]", 1); + h_ScoutingMuonNoVtx_phiCorr_->setAxisTitle("Muons", 2); + h_ScoutingMuonNoVtx_m_ = ibooker.book1D("ScoutingMuonNoVtx_m", "MuonNoVtx mass", 50, 0, 10); + h_ScoutingMuonNoVtx_m_->setAxisTitle("Mass [GeV]", 1); + h_ScoutingMuonNoVtx_m_->setAxisTitle("Muons", 2); + h_ScoutingMuonNoVtx_vtxIndx_ = ibooker.book1D("ScoutingMuonNoVtx_vtxIndx", "MuonNoVtx SV multiplicity per muon", 10, 0, 5); + h_ScoutingMuonNoVtx_vtxIndx_->setAxisTitle("SV Multiplicity per Muon", 1); + h_ScoutingMuonNoVtx_vtxIndx_->setAxisTitle("Muons", 2); // ScoutingMuonVtx h_ScoutingMuonVtx_vtxIndx_ = ibooker.book1D("ScoutingMuonVtx_vtxIndx", "MuonVtx SV multiplicity per muon", 10, 0, 10); + h_ScoutingMuonVtx_vtxIndx_->setAxisTitle("SV Multiplicity per Muon", 1); + h_ScoutingMuonVtx_vtxIndx_->setAxisTitle("Muons", 2); + h_ScoutingMuonVtx_phiCorr_ = ibooker.book1D("ScoutingMuonVtx_phiCorr", "MuonVtx #phi extrapolated", 64, -3.4, 3.4); + h_ScoutingMuonVtx_phiCorr_->setAxisTitle("#phi extrapolated [rad]", 1); + h_ScoutingMuonVtx_phiCorr_->setAxisTitle("Muons", 2); + h_ScoutingMuonVtx_m_ = ibooker.book1D("ScoutingMuonVtx_m", "MuonVtx mass", 50, 0, 10); + h_ScoutingMuonVtx_m_->setAxisTitle("Mass [GeV]", 1); + h_ScoutingMuonVtx_m_->setAxisTitle("Muons", 2); // SVNoVtx h_SVNoVtx_dxy_ = ibooker.book1D("SVNoVtx_dxy", "SVNoVtx dxy", 100, 0, 0.5); + h_SVNoVtx_dxy_->setAxisTitle("dxy [cm]", 1); + h_SVNoVtx_dxy_->setAxisTitle("Vertices", 2); + h_SVNoVtx_dxySig_ = ibooker.book1D("SVNoVtx_dxySig", "SVNoVtx dxy significance", 100, 0, 10); + h_SVNoVtx_dxySig_->setAxisTitle("dxy Significance", 1); + h_SVNoVtx_dxySig_->setAxisTitle("Vertices", 2); + h_SVNoVtx_dlen_ = ibooker.book1D("SVNoVtx_dlen", "SVNoVtx dlen", 100, 0, 20); + h_SVNoVtx_dlen_->setAxisTitle("Decay Length [cm]", 1); + h_SVNoVtx_dlen_->setAxisTitle("Vertices", 2); + h_SVNoVtx_dlenSig_ = ibooker.book1D("SVNoVtx_dlenSig", "SVNoVtx dlen significance", 100, 0, 50); + h_SVNoVtx_dlenSig_->setAxisTitle("Decay Length Significance", 1); + h_SVNoVtx_dlenSig_->setAxisTitle("Vertices", 2); + h_SVNoVtx_mass_ = ibooker.book1D("SVNoVtx_mass", "SVNoVtx mass", 50, 0, 10); + h_SVNoVtx_mass_->setAxisTitle("Mass [GeV]", 1); + h_SVNoVtx_mass_->setAxisTitle("Vertices", 2); + h_SVNoVtx_nMuon_ = ibooker.book1D("SVNoVtx_nMuon", "SVNoVtx nMuon", 10, 0, 10); + h_SVNoVtx_nMuon_->setAxisTitle("Number of Muons", 1); + h_SVNoVtx_nMuon_->setAxisTitle("Vertices", 2); // SVVtx + h_SVVtx_dxy_ = ibooker.book1D("SVVtx_dxy", "SVVtx dxy", 100, 0, 0.5); + h_SVVtx_dxy_->setAxisTitle("dxy [cm]", 1); + h_SVVtx_dxy_->setAxisTitle("Vertices", 2); + h_SVVtx_dxySig_ = ibooker.book1D("SVVtx_dxySig", "SVVtx dxy significance", 100, 0, 10); + h_SVVtx_dxySig_->setAxisTitle("dxy Significance", 1); + h_SVVtx_dxySig_->setAxisTitle("Vertices", 2); + h_SVVtx_dlen_ = ibooker.book1D("SVVtx_dlen", "SVVtx dlen", 100, 0, 20); + h_SVVtx_dlen_->setAxisTitle("Decay Length [cm]", 1); + h_SVVtx_dlen_->setAxisTitle("Vertices", 2); + h_SVVtx_dlenSig_ = ibooker.book1D("SVVtx_dlenSig", "SVVtx dlen significance", 100, 0, 10); + h_SVVtx_dlenSig_->setAxisTitle("Decay Length Significance", 1); + h_SVVtx_dlenSig_->setAxisTitle("Vertices", 2); + h_SVVtx_mass_ = ibooker.book1D("SVVtx_mass", "SVVtx mass", 50, 0, 10); + h_SVVtx_mass_->setAxisTitle("Mass [GeV]", 1); + h_SVVtx_mass_->setAxisTitle("Vertices", 2); + h_SVVtx_nMuon_ = ibooker.book1D("SVVtx_nMuon", "SVVtx nMuon", 10, 0, 10); + h_SVVtx_nMuon_->setAxisTitle("Number of Muons", 1); + h_SVVtx_nMuon_->setAxisTitle("Vertices", 2); triggersMapped_ = false; } From fda4cd20f7ba9d8aa19b33636c3da11a9206f343 Mon Sep 17 00:00:00 2001 From: Jessica Prendi Date: Mon, 13 Oct 2025 17:14:56 +0200 Subject: [PATCH 11/15] added mass plots to the scouting muon properties analyzer and removed the HLT tag from its config file --- .../plugins/ScoutingMuonPropertiesAnalyzer.cc | 35 ++++++++++++++++--- .../ScoutingMuonPropertiesMonitoring_cfi.py | 10 +++--- 2 files changed, 35 insertions(+), 10 deletions(-) diff --git a/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc b/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc index 7114846a23d4f..04016f390a7e2 100644 --- a/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc +++ b/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc @@ -87,8 +87,8 @@ class ScoutingMuonPropertiesAnalyzer : public DQMEDAnalyzer { MonitorElement* h_ScoutingMuonNoVtx_eta_; MonitorElement* h_ScoutingMuonNoVtx_phi_; MonitorElement* h_ScoutingMuonNoVtx_phiCorr_; - MonitorElement* h_ScoutingMuonNoVtx_m_; MonitorElement* h_ScoutingMuonNoVtx_charge_; + MonitorElement* h_ScoutingMuonNoVtx_m_; MonitorElement* h_ScoutingMuonNoVtx_trkchi2_; MonitorElement* h_ScoutingMuonNoVtx_trkndof_; MonitorElement* h_ScoutingMuonNoVtx_trkdxy_; @@ -116,8 +116,8 @@ class ScoutingMuonPropertiesAnalyzer : public DQMEDAnalyzer { MonitorElement* h_ScoutingMuonVtx_eta_; MonitorElement* h_ScoutingMuonVtx_phi_; MonitorElement* h_ScoutingMuonVtx_phiCorr_; - MonitorElement* h_ScoutingMuonVtx_m_; MonitorElement* h_ScoutingMuonVtx_charge_; + MonitorElement* h_ScoutingMuonVtx_m_; MonitorElement* h_ScoutingMuonVtx_trkchi2_; MonitorElement* h_ScoutingMuonVtx_trkndof_; MonitorElement* h_ScoutingMuonVtx_trkdxy_; @@ -169,6 +169,8 @@ class ScoutingMuonPropertiesAnalyzer : public DQMEDAnalyzer { MonitorElement* h_SVNoVtx_dlen_; MonitorElement* h_SVNoVtx_dlenSig_; MonitorElement* h_SVNoVtx_mass_; + MonitorElement* h_SVNoVtx_mass_JPsi_; + MonitorElement* h_SVNoVtx_mass_Z_; MonitorElement* h_SVNoVtx_nMuon_; // SVVtx MEs @@ -188,6 +190,8 @@ class ScoutingMuonPropertiesAnalyzer : public DQMEDAnalyzer { MonitorElement* h_SVVtx_dlen_; MonitorElement* h_SVVtx_dlenSig_; MonitorElement* h_SVVtx_mass_; + MonitorElement* h_SVVtx_mass_Z_; + MonitorElement* h_SVVtx_mass_JPsi_; MonitorElement* h_SVVtx_nMuon_; }; @@ -635,10 +639,18 @@ void ScoutingMuonPropertiesAnalyzer::bookHistograms(DQMStore::IBooker& ibooker, h_SVNoVtx_dlenSig_->setAxisTitle("Decay Length Significance", 1); h_SVNoVtx_dlenSig_->setAxisTitle("Vertices", 2); - h_SVNoVtx_mass_ = ibooker.book1D("SVNoVtx_mass", "SVNoVtx mass", 50, 0, 10); + h_SVNoVtx_mass_ = ibooker.book1D("SVNoVtx_mass", "SVNoVtx mass", 50, 0, 100); h_SVNoVtx_mass_->setAxisTitle("Mass [GeV]", 1); h_SVNoVtx_mass_->setAxisTitle("Vertices", 2); + h_SVNoVtx_mass_JPsi_ = ibooker.book1D("SVNoVtx_mass_JPsi", "SVNoVtx mass J/Psi", 50, 0, 10); + h_SVNoVtx_mass_JPsi_->setAxisTitle("Mass [GeV]", 1); + h_SVNoVtx_mass_JPsi_->setAxisTitle("Vertices", 2); + + h_SVNoVtx_mass_Z_ = ibooker.book1D("SVNoVtx_mass", "SVNoVtx mass Z", 50, 80, 100); + h_SVNoVtx_mass_Z_->setAxisTitle("Mass [GeV]", 1); + h_SVNoVtx_mass_Z_->setAxisTitle("Vertices", 2); + h_SVNoVtx_nMuon_ = ibooker.book1D("SVNoVtx_nMuon", "SVNoVtx nMuon", 10, 0, 10); h_SVNoVtx_nMuon_->setAxisTitle("Number of Muons", 1); h_SVNoVtx_nMuon_->setAxisTitle("Vertices", 2); @@ -661,10 +673,18 @@ void ScoutingMuonPropertiesAnalyzer::bookHistograms(DQMStore::IBooker& ibooker, h_SVVtx_dlenSig_->setAxisTitle("Decay Length Significance", 1); h_SVVtx_dlenSig_->setAxisTitle("Vertices", 2); - h_SVVtx_mass_ = ibooker.book1D("SVVtx_mass", "SVVtx mass", 50, 0, 10); + h_SVVtx_mass_ = ibooker.book1D("SVVtx_mass", "SVVtx mass", 50, 0, 100); h_SVVtx_mass_->setAxisTitle("Mass [GeV]", 1); h_SVVtx_mass_->setAxisTitle("Vertices", 2); + h_SVVtx_mass_JPsi_ = ibooker.book1D("SVVtx_mass_JPsi", "SVVtx mass J/Psi", 50, 0, 10); + h_SVVtx_mass_JPsi_->setAxisTitle("Mass [GeV]", 1); + h_SVVtx_mass_JPsi_->setAxisTitle("Vertices", 2); + + h_SVVtx_mass_Z_ = ibooker.book1D("SVVtx_mass_Z", "SVVtx mass Z", 50, 80, 100); + h_SVVtx_mass_Z_->setAxisTitle("Mass [GeV]", 1); + h_SVVtx_mass_Z_->setAxisTitle("Vertices", 2); + h_SVVtx_nMuon_ = ibooker.book1D("SVVtx_nMuon", "SVVtx nMuon", 10, 0, 10); h_SVVtx_nMuon_->setAxisTitle("Number of Muons", 1); h_SVVtx_nMuon_->setAxisTitle("Vertices", 2); @@ -942,7 +962,10 @@ void ScoutingMuonPropertiesAnalyzer::analyze(const edm::Event& iEvent, const edm } if (nMuonMatch > 0) sv_mass = sv_p4.M(); + h_SVNoVtx_mass_->Fill(sv_mass); + h_SVNoVtx_mass_JPsi_->Fill(sv_mass); + h_SVNoVtx_mass_Z_->Fill(sv_mass); h_SVNoVtx_nMuon_->Fill(nMuonMatch); } } @@ -1001,6 +1024,8 @@ void ScoutingMuonPropertiesAnalyzer::analyze(const edm::Event& iEvent, const edm if (nMuonMatch > 0) sv_mass = sv_p4.M(); h_SVVtx_mass_->Fill(sv_mass); + h_SVVtx_mass_JPsi_->Fill(sv_mass); + h_SVVtx_mass_Z_->Fill(sv_mass); h_SVVtx_nMuon_->Fill(nMuonMatch); } } @@ -1009,7 +1034,7 @@ void ScoutingMuonPropertiesAnalyzer::analyze(const edm::Event& iEvent, const edm void ScoutingMuonPropertiesAnalyzer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { edm::ParameterSetDescription desc; desc.add("OutputInternalPath", "HLT/ScoutingOffline/Muons/Properties"); - desc.add("fillAllHistograms", false); + desc.add("fillAllHistograms", true); desc.add("triggerResults", edm::InputTag("TriggerResults", "", "HLT")); desc.add("muonsNoVtx", edm::InputTag("hltScoutingMuonPackerNoVtx", "", "HLT")); desc.add("muonsVtx", edm::InputTag("hltScoutingMuonPackerVtx", "", "HLT")); diff --git a/HLTriggerOffline/Scouting/python/ScoutingMuonPropertiesMonitoring_cfi.py b/HLTriggerOffline/Scouting/python/ScoutingMuonPropertiesMonitoring_cfi.py index 1f4192490c71b..1505007e5e6f0 100644 --- a/HLTriggerOffline/Scouting/python/ScoutingMuonPropertiesMonitoring_cfi.py +++ b/HLTriggerOffline/Scouting/python/ScoutingMuonPropertiesMonitoring_cfi.py @@ -5,8 +5,8 @@ OutputInternalPath = cms.string('/HLT/ScoutingOffline/Muons/Properties'), #Output of the root file fillAllHistograms = cms.bool(False), triggerResults = cms.InputTag("TriggerResults", "", "HLT"), - muonsNoVtx = cms.InputTag("hltScoutingMuonPackerNoVtx", "", "HLT"), - muonsVtx = cms.InputTag("hltScoutingMuonPackerVtx", "", "HLT"), - PV = cms.InputTag("hltScoutingPrimaryVertexPacker", "primaryVtx", "HLT"), - SVNoVtx = cms.InputTag("hltScoutingMuonPackerNoVtx", "displacedVtx", "HLT"), - SVVtx = cms.InputTag("hltScoutingMuonPackerVtx", "displacedVtx", "HLT")) + muonsNoVtx = cms.InputTag("hltScoutingMuonPackerNoVtx"), + muonsVtx = cms.InputTag("hltScoutingMuonPackerVtx"), + PV = cms.InputTag("hltScoutingPrimaryVertexPacker", "primaryVtx"), + SVNoVtx = cms.InputTag("hltScoutingMuonPackerNoVtx", "displacedVtx"), + SVVtx = cms.InputTag("hltScoutingMuonPackerVtx", "displacedVtx")) From 7d78c76b52af475ce0c384af15b6ec94578f97e9 Mon Sep 17 00:00:00 2001 From: Jessica Prendi Date: Mon, 13 Oct 2025 17:18:06 +0200 Subject: [PATCH 12/15] change bin sizing for multiplicity plots --- DQM/HLTEvF/plugins/ScoutingCollectionMonitor.cc | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/DQM/HLTEvF/plugins/ScoutingCollectionMonitor.cc b/DQM/HLTEvF/plugins/ScoutingCollectionMonitor.cc index eb80531f81aa6..dcf0a5340e78f 100644 --- a/DQM/HLTEvF/plugins/ScoutingCollectionMonitor.cc +++ b/DQM/HLTEvF/plugins/ScoutingCollectionMonitor.cc @@ -989,16 +989,16 @@ void ScoutingCollectionMonitor::bookHistograms(DQMStore::IBooker& ibook, ibook.setCurrentFolder(topfoldername_); // Book multiplicity histograms in the topfolder - nTracks_hist = ibook.book1D("nTracks", "Number of Tracks;N_{tracks};Entries", 101, 0, 115); + nTracks_hist = ibook.book1D("nTracks", "Number of Tracks;N_{tracks};Entries", 115, 0, 115); nPrimaryVertices_hist = ibook.book1D("nPrimaryVertices", "Number of Primary Vertices;N_{PV};Entries", 51, 0, 50); nDisplacedVertices_hist = - ibook.book1D("nDisplacedVertices", "Number of Displaced Vertices (Vtx);N_{DV};Entries", 51, 0, 10); + ibook.book1D("nDisplacedVertices", "Number of Displaced Vertices (Vtx);N_{DV};Entries", 10, 0, 10); nDisplacedVerticesNoVtx_hist = - ibook.book1D("nDisplacedVerticesNoVtx", "Number of Displaced Vertices (NoVtx);N_{DV}^{NoVtx};Entries", 51, 0, 10); - nMuons_hist = ibook.book1D("nMuons", "Number of Muons (NoVtx);N_{muons};Entries", 51, 0, 10); - nMuonsVtx_hist = ibook.book1D("nMuonsVtx", "Number of Muons (Vtx);N_{muons}^{Vtx};Entries", 51, 0, 10); - nElectrons_hist = ibook.book1D("nElectrons", "Number of Electrons;N_{ele};Entries", 51, 0, 10); - nPhotons_hist = ibook.book1D("nPhotons", "Number of Photons;N_{photon};Entries", 51, 0, 25); + ibook.book1D("nDisplacedVerticesNoVtx", "Number of Displaced Vertices (NoVtx);N_{DV}^{NoVtx};Entries", 10, 0, 10); + nMuons_hist = ibook.book1D("nMuons", "Number of Muons (NoVtx);N_{muons};Entries", 10, 0, 10); + nMuonsVtx_hist = ibook.book1D("nMuonsVtx", "Number of Muons (Vtx);N_{muons}^{Vtx};Entries", 10, 0, 10); + nElectrons_hist = ibook.book1D("nElectrons", "Number of Electrons;N_{ele};Entries", 10, 0, 10); + nPhotons_hist = ibook.book1D("nPhotons", "Number of Photons;N_{photon};Entries", 25, 0, 25); nPFJets_hist = ibook.book1D("nPFJets", "Number of PF Jets;N_{jet};Entries", 101, 0, 100); nPFCands_hist = ibook.book1D("nPFCands", "Number of PF Candidates;N_{pfcand};Entries", 1001, 0, 1000); @@ -1494,7 +1494,7 @@ void ScoutingCollectionMonitor::bookHistograms(DQMStore::IBooker& ibook, void ScoutingCollectionMonitor::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { edm::ParameterSetDescription desc; - desc.add("onlyScouting", false); + desc.add("onlyScouting", true); desc.add("electrons", edm::InputTag("hltScoutingEgammaPacker")); desc.add("muons", edm::InputTag("hltScoutingMuonPackerNoVtx")); desc.add("muonsVtx", edm::InputTag("hltScoutingMuonPackerVtx")); From 4689422b1dee0c819a965696a63f357ac533411c Mon Sep 17 00:00:00 2001 From: Jessica Prendi Date: Mon, 13 Oct 2025 17:31:17 +0200 Subject: [PATCH 13/15] set onlyScouting back to false in ScoutingCollectionMonitor and removed the HLT tag in the fillDescription of ScoutingMuonPropertiesAnalyzer --- DQM/HLTEvF/plugins/ScoutingCollectionMonitor.cc | 2 +- .../plugins/ScoutingMuonPropertiesAnalyzer.cc | 12 ++++++------ 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/DQM/HLTEvF/plugins/ScoutingCollectionMonitor.cc b/DQM/HLTEvF/plugins/ScoutingCollectionMonitor.cc index dcf0a5340e78f..e5d387f002d1d 100644 --- a/DQM/HLTEvF/plugins/ScoutingCollectionMonitor.cc +++ b/DQM/HLTEvF/plugins/ScoutingCollectionMonitor.cc @@ -1494,7 +1494,7 @@ void ScoutingCollectionMonitor::bookHistograms(DQMStore::IBooker& ibook, void ScoutingCollectionMonitor::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { edm::ParameterSetDescription desc; - desc.add("onlyScouting", true); + desc.add("onlyScouting", false); desc.add("electrons", edm::InputTag("hltScoutingEgammaPacker")); desc.add("muons", edm::InputTag("hltScoutingMuonPackerNoVtx")); desc.add("muonsVtx", edm::InputTag("hltScoutingMuonPackerVtx")); diff --git a/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc b/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc index 04016f390a7e2..5a212aa671026 100644 --- a/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc +++ b/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc @@ -1034,13 +1034,13 @@ void ScoutingMuonPropertiesAnalyzer::analyze(const edm::Event& iEvent, const edm void ScoutingMuonPropertiesAnalyzer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { edm::ParameterSetDescription desc; desc.add("OutputInternalPath", "HLT/ScoutingOffline/Muons/Properties"); - desc.add("fillAllHistograms", true); + desc.add("fillAllHistograms", false); desc.add("triggerResults", edm::InputTag("TriggerResults", "", "HLT")); - desc.add("muonsNoVtx", edm::InputTag("hltScoutingMuonPackerNoVtx", "", "HLT")); - desc.add("muonsVtx", edm::InputTag("hltScoutingMuonPackerVtx", "", "HLT")); - desc.add("PV", edm::InputTag("hltScoutingPrimaryVertexPacker", "primaryVtx", "HLT")); - desc.add("SVNoVtx", edm::InputTag("hltScoutingMuonPackerNoVtx", "displacedVtx", "HLT")); - desc.add("SVVtx", edm::InputTag("hltScoutingMuonPackerVtx", "displacedVtx", "HLT")); + desc.add("muonsNoVtx", edm::InputTag("hltScoutingMuonPackerNoVtx")); + desc.add("muonsVtx", edm::InputTag("hltScoutingMuonPackerVtx")); + desc.add("PV", edm::InputTag("hltScoutingPrimaryVertexPacker", "primaryVtx")); + desc.add("SVNoVtx", edm::InputTag("hltScoutingMuonPackerNoVtx", "displacedVtx")); + desc.add("SVVtx", edm::InputTag("hltScoutingMuonPackerVtx", "displacedVtx")); descriptions.addWithDefaultLabel(desc); } From d7e4781b2d035184e54e994cddce550b127553ee Mon Sep 17 00:00:00 2001 From: Jessica Prendi Date: Mon, 13 Oct 2025 18:27:34 +0200 Subject: [PATCH 14/15] added protections to ScoutingMuonPropertiesAnalyzer in case of invalid handle --- .../plugins/ScoutingMuonPropertiesAnalyzer.cc | 40 ++++++++++++++----- 1 file changed, 29 insertions(+), 11 deletions(-) diff --git a/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc b/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc index 5a212aa671026..3810b8c882e89 100644 --- a/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc +++ b/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc @@ -56,6 +56,12 @@ class ScoutingMuonPropertiesAnalyzer : public DQMEDAnalyzer { void bookHistograms(DQMStore::IBooker&, edm::Run const&, edm::EventSetup const&) override; private: + template + bool getValidHandle(const edm::Event& iEvent, + const edm::EDGetTokenT& token, + edm::Handle& handle, + const std::string& label); + // Output Folder const std::string outputInternalPath_; // do to some histogram duplicates with the ScoutingCollectionMonitor.cc module, we added the option to just fill the unique plots w.r.t the aforementioned module, if this bool is set to false @@ -228,6 +234,19 @@ ScoutingMuonPropertiesAnalyzer::ScoutingMuonPropertiesAnalyzer(const edm::Parame }; } +template +bool ScoutingMuonPropertiesAnalyzer::getValidHandle(const edm::Event& iEvent, + const edm::EDGetTokenT& token, + edm::Handle& handle, + const std::string& label) { + iEvent.getByToken(token, handle); + if (!handle.isValid()) { + edm::LogWarning("ScoutingMuonPropertiesAnalyzer") << "Invalid handle for " << label << "! Skipping event."; + return false; + } + return true; +} + void ScoutingMuonPropertiesAnalyzer::bookHistograms(DQMStore::IBooker& ibooker, edm::Run const&, edm::EventSetup const&) { @@ -696,23 +715,22 @@ void ScoutingMuonPropertiesAnalyzer::analyze(const edm::Event& iEvent, const edm using namespace edm; edm::Handle triggerResults; - iEvent.getByToken(triggerResultsToken_, triggerResults); - edm::Handle> muonsNoVtx; - iEvent.getByToken(muonsNoVtxToken_, muonsNoVtx); - edm::Handle> muonsVtx; - iEvent.getByToken(muonsVtxToken_, muonsVtx); + edm::Handle> SVNoVtx; + edm::Handle> SVVtx; + + if (!getValidHandle(iEvent, triggerResultsToken_, triggerResults, "TriggerResults") || + !getValidHandle(iEvent, muonsNoVtxToken_, muonsNoVtx, "muonsNoVtx") || + !getValidHandle(iEvent, muonsVtxToken_, muonsVtx, "muonsVtx") || + !getValidHandle(iEvent, SVNoVtxToken_, SVNoVtx, "SVNoVtx") || + !getValidHandle(iEvent, SVVtxToken_, SVVtx, "SVVtx")) { + return; + } edm::Handle> PV; iEvent.getByToken(PVToken_, PV); - edm::Handle> SVNoVtx; - iEvent.getByToken(SVNoVtxToken_, SVNoVtx); - - edm::Handle> SVVtx; - iEvent.getByToken(SVVtxToken_, SVVtx); - const TransientTrackBuilder* theB = &iSetup.getData(ttbESToken_); h_run_->Fill(iEvent.eventAuxiliary().run()); From ea5f0e55a33040de956cbeae395fcfde7476995e Mon Sep 17 00:00:00 2001 From: Jessica Prendi Date: Tue, 14 Oct 2025 11:39:30 +0200 Subject: [PATCH 15/15] fixing ranges for the muliplicity of tracks histogram and fixing the SVNoVtx_mass_Z plot --- DQM/HLTEvF/plugins/ScoutingCollectionMonitor.cc | 2 +- .../Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/DQM/HLTEvF/plugins/ScoutingCollectionMonitor.cc b/DQM/HLTEvF/plugins/ScoutingCollectionMonitor.cc index e5d387f002d1d..7e651089b08e9 100644 --- a/DQM/HLTEvF/plugins/ScoutingCollectionMonitor.cc +++ b/DQM/HLTEvF/plugins/ScoutingCollectionMonitor.cc @@ -989,7 +989,7 @@ void ScoutingCollectionMonitor::bookHistograms(DQMStore::IBooker& ibook, ibook.setCurrentFolder(topfoldername_); // Book multiplicity histograms in the topfolder - nTracks_hist = ibook.book1D("nTracks", "Number of Tracks;N_{tracks};Entries", 115, 0, 115); + nTracks_hist = ibook.book1D("nTracks", "Number of Tracks;N_{tracks};Entries", 400, 0, 400); nPrimaryVertices_hist = ibook.book1D("nPrimaryVertices", "Number of Primary Vertices;N_{PV};Entries", 51, 0, 50); nDisplacedVertices_hist = ibook.book1D("nDisplacedVertices", "Number of Displaced Vertices (Vtx);N_{DV};Entries", 10, 0, 10); diff --git a/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc b/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc index 3810b8c882e89..dd0f656c744bf 100644 --- a/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc +++ b/HLTriggerOffline/Scouting/plugins/ScoutingMuonPropertiesAnalyzer.cc @@ -666,7 +666,7 @@ void ScoutingMuonPropertiesAnalyzer::bookHistograms(DQMStore::IBooker& ibooker, h_SVNoVtx_mass_JPsi_->setAxisTitle("Mass [GeV]", 1); h_SVNoVtx_mass_JPsi_->setAxisTitle("Vertices", 2); - h_SVNoVtx_mass_Z_ = ibooker.book1D("SVNoVtx_mass", "SVNoVtx mass Z", 50, 80, 100); + h_SVNoVtx_mass_Z_ = ibooker.book1D("SVNoVtx_mass_Z", "SVNoVtx mass Z", 50, 80, 100); h_SVNoVtx_mass_Z_->setAxisTitle("Mass [GeV]", 1); h_SVNoVtx_mass_Z_->setAxisTitle("Vertices", 2);