From 0195e0f158aa8d17cc49243bc3c05267da15631d Mon Sep 17 00:00:00 2001 From: Charlie Mueller Date: Tue, 11 Aug 2015 16:04:40 +0200 Subject: [PATCH] adding HLT object monitoring to HLT online DQM --- DQM/HLTEvF/plugins/BuildFile.xml | 1 + DQM/HLTEvF/plugins/HLTObjectMonitor.cc | 845 ++++++++++++++++++ DQM/HLTEvF/python/HLTObjectMonitor_cff.py | 26 + DQM/HLTEvF/python/HLTObjectMonitor_cfi.py | 417 +++++++++ DQM/HLTEvF/python/HLTSiStripMonitoring_cff.py | 204 +++++ .../python/HLTTrackingMonitoring_cff.py | 15 + DQM/HLTEvF/test/HLTObjectMonitor_cfg.py | 20 + .../clients/hlt_dqm_sourceclient-live_cfg.py | 3 +- 8 files changed, 1530 insertions(+), 1 deletion(-) create mode 100644 DQM/HLTEvF/plugins/HLTObjectMonitor.cc create mode 100644 DQM/HLTEvF/python/HLTObjectMonitor_cff.py create mode 100644 DQM/HLTEvF/python/HLTObjectMonitor_cfi.py create mode 100644 DQM/HLTEvF/python/HLTSiStripMonitoring_cff.py create mode 100644 DQM/HLTEvF/python/HLTTrackingMonitoring_cff.py create mode 100644 DQM/HLTEvF/test/HLTObjectMonitor_cfg.py diff --git a/DQM/HLTEvF/plugins/BuildFile.xml b/DQM/HLTEvF/plugins/BuildFile.xml index bf5062e73c717..ba0a8948f54ae 100644 --- a/DQM/HLTEvF/plugins/BuildFile.xml +++ b/DQM/HLTEvF/plugins/BuildFile.xml @@ -1,6 +1,7 @@ + diff --git a/DQM/HLTEvF/plugins/HLTObjectMonitor.cc b/DQM/HLTEvF/plugins/HLTObjectMonitor.cc new file mode 100644 index 0000000000000..fade3c3d41508 --- /dev/null +++ b/DQM/HLTEvF/plugins/HLTObjectMonitor.cc @@ -0,0 +1,845 @@ +// -*- C++ -*- +// +// Package: DQM/HLTObjectMonitor +// Class: HLTObjectMonitor +// +/**\class HLTObjectMonitor HLTObjectMonitor.cc DQM/HLTEvF/plugins/HLTObjectMonitor.cc + + Description: [one line class summary] + + Implementation: + [Notes on implementation] +*/ +// +// Original Author: Charles Nicholas Mueller +// Created: Sun, 22 Mar 2015 22:29:00 GMT +// +// + + +// system include files +#include +#include +#include + +// user include files +#include "DataFormats/Common/interface/TriggerResults.h" +#include "DataFormats/HLTReco/interface/TriggerObject.h" +#include "DataFormats/HLTReco/interface/TriggerEvent.h" +#include "DataFormats/HLTReco/interface/TriggerTypeDefs.h" +#include "DataFormats/Scalers/interface/LumiScalers.h" + +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" + +#include "HLTrigger/HLTcore/interface/HLTConfigProvider.h" + +//for collections +#include "HLTrigger/JetMET/interface/AlphaT.h" +#include "DataFormats/BeamSpot/interface/BeamSpot.h" +#include "DataFormats/METReco/interface/MET.h" +#include "DataFormats/RecoCandidate/interface/RecoChargedCandidate.h" +#include "DataFormats/BTauReco/interface/JetTag.h" +#include "DataFormats/RecoCandidate/interface/RecoChargedCandidateFwd.h" +#include "DataFormats/Math/interface/deltaR.h" +#include "DataFormats/JetReco/interface/PFJet.h" +#include "DataFormats/JetReco/interface/CaloJet.h" + +#include "DQMServices/Core/interface/DQMStore.h" +#include "DQMServices/Core/interface/MonitorElement.h" +#include "DQMServices/Core/interface/DQMEDAnalyzer.h" + +#include "TMath.h" +#include "TStyle.h" +#include "TLorentzVector.h" + +#include +// +// class declaration +// + +//using namespace edm; +using namespace trigger; +using std::vector; +using std::string; +using std::unordered_map; + +class HLTObjectMonitor : public DQMEDAnalyzer { + struct hltPlot + { + + MonitorElement * ME; + string pathName; + string pathNameOR; + string moduleName; + string moduleNameOR; + int pathIndex = -99; + int pathIndexOR = -99; + string plotLabel; + string xAxisLabel; + int nBins; + double xMin; + double xMax; + bool displayInPrimary; + + }; + + public: + explicit HLTObjectMonitor(const edm::ParameterSet&); + ~HLTObjectMonitor(); + + // static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + + + private: + void analyze(const edm::Event&, const edm::EventSetup&) override; + virtual void bookHistograms(DQMStore::IBooker &i, edm::Run const&, edm::EventSetup const&) override; + void dqmBeginRun(edm::Run const&, edm::EventSetup const&) override; + void endRun(edm::Run const&, edm::EventSetup const&) override; + vector plotList; + //virtual void beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) override; + //virtual void endLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) override; + double dxyFinder(double, double, edm::Handle, edm::Handle); + double get_wall_time(void); + // ----------member data --------------------------- + + bool debugPrint; + HLTConfigProvider hltConfig_; + string topDirectoryName; + string mainShifterFolder; + string backupFolder; + unordered_map acceptMap; + unordered_map plotMap; + + //set Token(-s) + edm::EDGetTokenT triggerResultsToken_; + edm::EDGetTokenT aodTriggerToken_; + edm::EDGetTokenT lumiScalersToken_; + edm::EDGetTokenT beamSpotToken_; + edm::EDGetTokenT chargedCandToken_; + edm::EDGetTokenT csvCaloTagsToken_; + edm::EDGetTokenT csvPfTagsToken_; + edm::EDGetTokenT> csvCaloJetsToken_; + edm::EDGetTokenT> csvPfJetsToken_; + + //declare params + edm::ParameterSet rsq_pset; + edm::ParameterSet mr_pset; + edm::ParameterSet alphaT_pset; + edm::ParameterSet photonPt_pset; + edm::ParameterSet photonEta_pset; + edm::ParameterSet photonPhi_pset; + edm::ParameterSet muonPt_pset; + edm::ParameterSet muonEta_pset; + edm::ParameterSet muonPhi_pset; + edm::ParameterSet l2muonPt_pset; + edm::ParameterSet l2muonEta_pset; + edm::ParameterSet l2muonPhi_pset; + edm::ParameterSet l2NoBPTXmuonPt_pset; + edm::ParameterSet l2NoBPTXmuonEta_pset; + edm::ParameterSet l2NoBPTXmuonPhi_pset; + edm::ParameterSet electronPt_pset; + edm::ParameterSet electronEta_pset; + edm::ParameterSet electronPhi_pset; + edm::ParameterSet jetPt_pset; + edm::ParameterSet jetAK8Pt_pset; + edm::ParameterSet jetAK8Mass_pset; + edm::ParameterSet tauPt_pset; + edm::ParameterSet diMuonLowMass_pset; + edm::ParameterSet caloMetPt_pset; + edm::ParameterSet caloMetPhi_pset; + edm::ParameterSet pfMetPt_pset; + edm::ParameterSet pfMetPhi_pset; + edm::ParameterSet caloHtPt_pset; + edm::ParameterSet pfHtPt_pset; + edm::ParameterSet bJetPhi_pset; + edm::ParameterSet bJetEta_pset; + edm::ParameterSet bJetCSVCalo_pset; + edm::ParameterSet bJetCSVPF_pset; + edm::ParameterSet diMuonMass_pset; + edm::ParameterSet diElecMass_pset; + edm::ParameterSet muonDxy_pset; + edm::ParameterSet wallTime_pset; + + string processName_; + + hltPlot rsq_; + hltPlot mr_; + hltPlot alphaT_; + hltPlot photonPt_; + hltPlot photonEta_; + hltPlot photonPhi_; + hltPlot muonPt_; + hltPlot muonEta_; + hltPlot muonPhi_; + hltPlot l2muonPt_; + hltPlot l2muonEta_; + hltPlot l2muonPhi_; + hltPlot l2NoBPTXmuonPt_; + hltPlot l2NoBPTXmuonEta_; + hltPlot l2NoBPTXmuonPhi_; + hltPlot electronPt_; + hltPlot electronEta_; + hltPlot electronPhi_; + hltPlot jetPt_; + hltPlot jetAK8Pt_; + hltPlot jetAK8Mass_; + hltPlot tauPt_; + hltPlot diMuonLowMass_; + hltPlot caloMetPt_; + hltPlot caloMetPhi_; + hltPlot pfMetPt_; + hltPlot pfMetPhi_; + hltPlot caloHtPt_; + hltPlot pfHtPt_; + hltPlot bJetPhi_; + hltPlot bJetEta_; + hltPlot bJetCSVCalo_; + hltPlot bJetCSVPF_; + hltPlot diMuonMass_; + hltPlot diElecMass_; + hltPlot muonDxy_; + hltPlot wallTime_; + +}; + +// +// constants, enums and typedefs +// + +// +// static data member definitions +// + +// +// constructors and destructor +// +HLTObjectMonitor::HLTObjectMonitor(const edm::ParameterSet& iConfig) + +{ + //now do what ever initialization is needed + debugPrint = false; + + topDirectoryName = "HLT/ObjectMonitor"; + mainShifterFolder = topDirectoryName+"/MainShifter"; + backupFolder = topDirectoryName+"/Backup"; + + //parse params + processName_ = iConfig.getParameter("processName"); + + rsq_pset = iConfig.getParameter ("rsq"); + plotMap[&rsq_] = &rsq_pset; + mr_pset = iConfig.getParameter ("mr"); + plotMap[&mr_] = &mr_pset; + alphaT_pset = iConfig.getParameter ("alphaT"); + plotMap[&alphaT_] = &alphaT_pset; + photonPt_pset = iConfig.getParameter("photonPt"); + plotMap[&photonPt_] = &photonPt_pset; + photonEta_pset = iConfig.getParameter("photonEta"); + plotMap[&photonEta_] = &photonEta_pset; + photonPhi_pset = iConfig.getParameter("photonPhi"); + plotMap[&photonPhi_] = &photonPhi_pset; + muonPt_pset = iConfig.getParameter("muonPt"); + plotMap[&muonPt_] = &muonPt_pset; + muonEta_pset = iConfig.getParameter("muonEta"); + plotMap[&muonEta_] = &muonEta_pset; + muonPhi_pset = iConfig.getParameter("muonPhi"); + plotMap[&muonPhi_] = &muonPhi_pset; + l2muonPt_pset = iConfig.getParameter("l2muonPt"); + plotMap[&l2muonPt_] = &l2muonPt_pset; + l2muonEta_pset = iConfig.getParameter("l2muonEta"); + plotMap[&l2muonEta_] = &l2muonEta_pset; + l2muonPhi_pset = iConfig.getParameter("l2muonPhi"); + plotMap[&l2muonPhi_] = &l2muonPhi_pset; + l2NoBPTXmuonPt_pset = iConfig.getParameter("l2NoBPTXmuonPt"); + plotMap[&l2NoBPTXmuonPt_] = &l2NoBPTXmuonPt_pset; + l2NoBPTXmuonEta_pset = iConfig.getParameter("l2NoBPTXmuonEta"); + plotMap[&l2NoBPTXmuonEta_] = &l2NoBPTXmuonEta_pset; + l2NoBPTXmuonPhi_pset = iConfig.getParameter("l2NoBPTXmuonPhi"); + plotMap[&l2NoBPTXmuonPhi_] = &l2NoBPTXmuonPhi_pset; + electronPt_pset = iConfig.getParameter("electronPt"); + plotMap[&electronPt_] = &electronPt_pset; + electronEta_pset = iConfig.getParameter("electronEta"); + plotMap[&electronEta_] = &electronEta_pset; + electronPhi_pset = iConfig.getParameter("electronPhi"); + plotMap[&electronPhi_] = &electronPhi_pset; + jetPt_pset = iConfig.getParameter("jetPt"); + plotMap[&jetPt_] = &jetPt_pset; + jetAK8Mass_pset = iConfig.getParameter("jetAK8Mass"); + plotMap[&jetAK8Mass_] = &jetAK8Mass_pset; + diMuonLowMass_pset = iConfig.getParameter("diMuonLowMass"); + plotMap[&diMuonLowMass_] = &diMuonLowMass_pset; + caloMetPt_pset = iConfig.getParameter("caloMetPt"); + plotMap[&caloMetPt_] = &caloMetPt_pset; + caloMetPhi_pset = iConfig.getParameter("caloMetPhi"); + plotMap[&caloMetPhi_] = &caloMetPhi_pset; + pfMetPt_pset = iConfig.getParameter("pfMetPt"); + plotMap[&pfMetPt_] = &pfMetPt_pset; + pfMetPhi_pset = iConfig.getParameter("pfMetPhi"); + plotMap[&pfMetPhi_] = &pfMetPhi_pset; + caloHtPt_pset = iConfig.getParameter("caloHtPt"); + plotMap[&caloHtPt_] = &caloHtPt_pset; + pfHtPt_pset = iConfig.getParameter("pfHtPt"); + plotMap[&pfHtPt_] = &pfHtPt_pset; + bJetPhi_pset = iConfig.getParameter("bJetPhi"); + plotMap[&bJetPhi_] = &bJetPhi_pset; + bJetEta_pset = iConfig.getParameter("bJetEta"); + plotMap[&bJetEta_] = &bJetEta_pset; + bJetCSVCalo_pset = iConfig.getParameter("bJetCSVCalo"); + plotMap[&bJetCSVCalo_] = &bJetCSVCalo_pset; + bJetCSVPF_pset = iConfig.getParameter("bJetCSVPF"); + plotMap[&bJetCSVPF_] = &bJetCSVPF_pset; + diMuonMass_pset = iConfig.getParameter("diMuonMass"); + plotMap[&diMuonMass_] = &diMuonMass_pset; + diElecMass_pset = iConfig.getParameter("diElecMass"); + plotMap[&diElecMass_] = &diElecMass_pset; + muonDxy_pset = iConfig.getParameter("muonDxy"); + plotMap[&muonDxy_] = &muonDxy_pset; + jetAK8Pt_pset = iConfig.getParameter("jetAK8Pt"); + plotMap[&jetAK8Pt_] = &jetAK8Pt_pset; + tauPt_pset = iConfig.getParameter("tauPt"); + plotMap[&tauPt_] = &tauPt_pset; + wallTime_pset = iConfig.getParameter("wallTime"); + plotMap[&wallTime_] = &wallTime_pset; + + + for (auto item = plotMap.begin(); item != plotMap.end(); item++) + { + (*item->first).pathName = (*item->second).getParameter("pathName"); + (*item->first).moduleName = (*item->second).getParameter("moduleName"); + (*item->first).nBins = (*item->second).getParameter("NbinsX"); + (*item->first).xMin = (*item->second).getParameter("Xmin"); + (*item->first).xMax = (*item->second).getParameter("Xmax"); + (*item->first).xAxisLabel = (*item->second).getParameter("axisLabel"); + (*item->first).plotLabel = (*item->second).getParameter("plotLabel"); + (*item->first).displayInPrimary = (*item->second).getParameter("mainWorkspace"); + + if ((*item->second).exists("pathName_OR")) + { + (*item->first).pathNameOR = (*item->second).getParameter("pathName_OR"); + } + if ((*item->second).exists("moduleName_OR")) + { + (*item->first).moduleNameOR = (*item->second).getParameter("moduleName_OR"); + } + + plotList.push_back(item->first); + } + plotMap.clear(); + + //set Token(s) + triggerResultsToken_ = consumes(edm::InputTag("TriggerResults","", processName_)); + aodTriggerToken_ = consumes(edm::InputTag("hltTriggerSummaryAOD", "", processName_)); + lumiScalersToken_ = consumes(edm::InputTag("hltScalersRawToDigi","","")); + beamSpotToken_ = consumes(edm::InputTag("hltOnlineBeamSpot","",processName_)); + chargedCandToken_ = consumes>(edm::InputTag("hltL3NoFiltersNoVtxMuonCandidates","",processName_)); + csvCaloTagsToken_ = consumes(edm::InputTag("hltCombinedSecondaryVertexBJetTagsCalo","",processName_)); + csvPfTagsToken_ = consumes(edm::InputTag("hltCombinedSecondaryVertexBJetTagsPF","",processName_)); + csvCaloJetsToken_ = consumes>(edm::InputTag("hltSelector8CentralJetsL1FastJet","",processName_)); + csvPfJetsToken_ = consumes>(edm::InputTag("hltPFJetForBtag","",processName_)); + +} + + +HLTObjectMonitor::~HLTObjectMonitor() +{ + + // do anything here that needs to be done at desctruction time + // (e.g. close files, deallocate resources etc.) + +} + + +// +// member functions +// + +// ------------ method called for each event ------------ +void +HLTObjectMonitor::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) +{ + double start = get_wall_time(); + + using namespace edm; + + if (debugPrint) std::cout << "Inside analyze(). " << std::endl; + + // access trigger results + edm::Handle triggerResults; + iEvent.getByToken(triggerResultsToken_, triggerResults); + if (!triggerResults.isValid()) return; + + edm::Handle aodTriggerEvent; + iEvent.getByToken(aodTriggerToken_, aodTriggerEvent); + if (!aodTriggerEvent.isValid()) return; + + //reset everything to not accepted at beginning of each event + unordered_map firedMap = acceptMap; + for (auto plot: plotList) //loop over paths + { + if (firedMap[plot->pathName]) continue; + bool triggerAccept = false; + const TriggerObjectCollection objects = aodTriggerEvent->getObjects(); + edm::InputTag moduleFilter; + std::string pathName; + if(plot->pathIndex > 0 && triggerResults->accept(plot->pathIndex) && hltConfig_.saveTags(plot->moduleName)) + { + moduleFilter = edm::InputTag(plot->moduleName,"",processName_); + pathName = plot->pathName; + triggerAccept = true; + } + else if(plot->pathIndexOR > 0 && triggerResults->accept(plot->pathIndexOR) && hltConfig_.saveTags(plot->moduleNameOR)) + { + if (firedMap[plot->pathNameOR]) continue; + moduleFilter = edm::InputTag(plot->moduleNameOR,"",processName_); + pathName = plot->pathNameOR; + triggerAccept = true; + } + + if (triggerAccept) + { + unsigned int moduleFilterIndex = aodTriggerEvent->filterIndex(moduleFilter); + + if (moduleFilterIndex+1 > aodTriggerEvent->sizeFilters()) return; + const Keys &keys = aodTriggerEvent->filterKeys( moduleFilterIndex ); + + //////////////////////////////// + /// + /// single-object plots + /// + //////////////////////////////// + + //PFHT pt + if (pathName == pfHtPt_.pathName) + { + for (const auto & key : keys) pfHtPt_.ME->Fill(objects[key].pt()); + } + + //jet pt + else if (pathName == jetPt_.pathName) + { + for (const auto & key : keys) jetPt_.ME->Fill(objects[key].pt()); + } + + //photon pt + eta + phi (all use same path) + else if (pathName == photonPt_.pathName) + { + for (const auto & key : keys) + { + photonPt_.ME->Fill(objects[key].pt()); + photonEta_.ME->Fill(objects[key].eta()); + photonPhi_.ME->Fill(objects[key].phi()); + } + } + + //electron pt + eta + phi (all use same path) + else if (pathName == electronPt_.pathName) + { + for (const auto & key : keys) + { + electronPt_.ME->Fill(objects[key].pt()); + electronEta_.ME->Fill(objects[key].eta()); + electronPhi_.ME->Fill(objects[key].phi()); + } + } + + //muon pt + eta + phi (all use same path) + else if (pathName == muonPt_.pathName) + { + for (const auto & key : keys) + { + muonPt_.ME->Fill(objects[key].pt()); + muonEta_.ME->Fill(objects[key].eta()); + muonPhi_.ME->Fill(objects[key].phi()); + } + } + + //l2muon pt + else if (pathName == l2muonPt_.pathName) + { + for (const auto & key : keys) + { + l2muonPt_.ME->Fill(objects[key].pt()); + l2muonEta_.ME->Fill(objects[key].eta()); + l2muonPhi_.ME->Fill(objects[key].phi()); + } + } + + //l2NoBPTXmuon pt + else if (pathName == l2NoBPTXmuonPt_.pathName) + { + for (const auto & key : keys) + { + l2NoBPTXmuonPt_.ME->Fill(objects[key].pt()); + l2NoBPTXmuonEta_.ME->Fill(objects[key].eta()); + l2NoBPTXmuonPhi_.ME->Fill(objects[key].phi()); + } + } + + //Razor + else if (pathName == mr_.pathName) + { + double onlineMR = 0, onlineRsq = 0; + for (const auto & key : keys) + { + if(objects[key].id() == 0){ //the MET object containing MR and Rsq will show up with ID = 0 + onlineMR = objects[key].px(); //razor variables stored in dummy reco::MET objects + onlineRsq = objects[key].py(); + } + mr_.ME->Fill(onlineMR); + rsq_.ME->Fill(onlineRsq); + } + } + + //alphaT + else if (pathName == alphaT_.pathName) + { + std::vector>> alphaT_jets; + for (const auto & key : keys) + { + ROOT::Math::LorentzVector> JetLVec(objects[key].pt(),objects[key].eta(),objects[key].phi(),objects[key].mass()); + alphaT_jets.push_back(JetLVec); + } + + float alphaT = AlphaT(alphaT_jets,false).value(); + alphaT_.ME->Fill(alphaT); + } + + //tau pt + else if (pathName == tauPt_.pathName) + { + for (const auto & key : keys) tauPt_.ME->Fill(objects[key].pt()); + } + + //caloMET pt+phi + else if (pathName == caloMetPt_.pathName) + { + for (const auto & key : keys) + { + caloMetPt_.ME->Fill(objects[key].pt()); + caloMetPhi_.ME->Fill(objects[key].phi()); + } + } + + //caloHT pt + else if (pathName == caloHtPt_.pathName) + { + for (const auto & key : keys) + { + if(objects[key].id()==89) caloHtPt_.ME->Fill(objects[key].pt()); + } + } + + //jetAK8 pt + mass + else if (pathName == jetAK8Pt_.pathName) + { + for (const auto & key : keys) + { + jetAK8Pt_.ME->Fill(objects[key].pt()); + jetAK8Mass_.ME->Fill(objects[key].mass()); + } + } + + //PFMET pt + phi + else if (pathName == pfMetPt_.pathName) + { + for (const auto & key : keys) + { + pfMetPt_.ME->Fill(objects[key].pt()); + pfMetPhi_.ME->Fill(objects[key].phi()); + } + } + + // bjet eta + phi + else if (pathName == bJetEta_.pathName || pathName == bJetEta_.pathNameOR) + { + for (const auto & key : keys) + { + bJetEta_.ME->Fill(objects[key].eta()); + bJetPhi_.ME->Fill(objects[key].phi()); + } + } + + //b-tagging CSV information + if (pathName == bJetCSVPF_.pathNameOR) + { + edm::Handle csvPfTags; + iEvent.getByToken(csvPfTagsToken_, csvPfTags); + edm::Handle> csvPfJets; + iEvent.getByToken(csvPfJetsToken_, csvPfJets); + + if (csvPfTags.isValid() && csvPfJets.isValid()) + { + for (auto iter = csvPfTags->begin(); iter != csvPfTags->end(); iter++) bJetCSVPF_.ME->Fill(iter->second); + } + } + if (pathName == bJetCSVCalo_.pathName) + { + edm::Handle csvCaloTags; + iEvent.getByToken(csvCaloTagsToken_, csvCaloTags); + edm::Handle> csvCaloJets; + iEvent.getByToken(csvCaloJetsToken_, csvCaloJets); + + if (csvCaloTags.isValid() && csvCaloJets.isValid()) + { + for (auto iter = csvCaloTags->begin(); iter != csvCaloTags->end(); iter++) bJetCSVCalo_.ME->Fill(iter->second); + } + } + + //muon dxy(use an unique path) + else if (pathName == muonDxy_.pathName) + { + edm::Handle> recoChargedCands; + iEvent.getByToken(chargedCandToken_, recoChargedCands); + edm::Handle recoBeamSpot; + iEvent.getByToken(beamSpotToken_, recoBeamSpot); + double muon_dxy; + + if (recoChargedCands.isValid() && recoBeamSpot.isValid()) + { + for (const auto & key : keys) + { + muon_dxy = dxyFinder(objects[key].eta(), objects[key].phi(), recoChargedCands, recoBeamSpot); + if (muon_dxy != -99.) muonDxy_.ME->Fill(muon_dxy); + } + } + } + + // //////////////////////////////// + // /// + // /// double-object plots + // /// + // //////////////////////////////// + + //double muon low mass + else if (pathName == diMuonLowMass_.pathName) + { + const double mu_mass(.105658); + unsigned int kCnt0 = 0; + for (const auto & key0: keys) + { + unsigned int kCnt1 = 0; + for (const auto & key1: keys) + { + if (key0 != key1 && kCnt1 > kCnt0) // avoid filling hists with same objs && avoid double counting separate objs + { + if (abs(objects[key0].id()) == 13 && (objects[key0].id()+objects[key1].id()==0)) // check muon id and dimuon charge + { + TLorentzVector mu1, mu2, dimu; + mu1.SetPtEtaPhiM(objects[key0].pt(), objects[key0].eta(), objects[key0].phi(), mu_mass); + mu2.SetPtEtaPhiM(objects[key1].pt(), objects[key1].eta(), objects[key1].phi(), mu_mass); + dimu = mu1+mu2; + diMuonLowMass_.ME->Fill(dimu.M()); + } + } + kCnt1 +=1; + } + kCnt0 +=1; + } + } //end double object plot + + else if (pathName == diMuonMass_.pathName || pathName == diMuonMass_.pathNameOR) + { + const double mu_mass(.105658); + unsigned int kCnt0 = 0; + for (const auto & key0: keys) + { + unsigned int kCnt1 = 0; + for (const auto & key1: keys) + { + if (key0 != key1 && kCnt1 > kCnt0) // avoid filling hists with same objs && avoid double counting separate objs + { + if (abs(objects[key0].id()) == 13 && (objects[key0].id()+objects[key1].id()==0)) // check muon id and dimuon charge + { + TLorentzVector mu1, mu2, dimu; + mu1.SetPtEtaPhiM(objects[key0].pt(), objects[key0].eta(), objects[key0].phi(), mu_mass); + mu2.SetPtEtaPhiM(objects[key1].pt(), objects[key1].eta(), objects[key1].phi(), mu_mass); + dimu = mu1+mu2; + diMuonMass_.ME->Fill(dimu.M()); + } + } + kCnt1 +=1; + } + kCnt0 +=1; + } + } + + else if (pathName == diElecMass_.pathName) + { + unsigned int kCnt0 = 0; + for (const auto & key0: keys) + { + unsigned int kCnt1 = 0; + for (const auto & key1: keys) + { + if (key0 != key1 && kCnt1 > kCnt0) // avoid filling hists with same objs && avoid double counting separate objs + { + // if (abs(objects[key0].id()) == 11 && (objects[key0].id()+objects[key1].id()==0)) // id is not filled for electrons + // { + TLorentzVector el1, el2, diEl; + el1.SetPtEtaPhiM(objects[key0].pt(), objects[key0].eta(), objects[key0].phi(), 0); + el2.SetPtEtaPhiM(objects[key1].pt(), objects[key1].eta(), objects[key1].phi(), 0); + diEl = el1+el2; + diElecMass_.ME->Fill(diEl.M()); + // } + } + kCnt1 +=1; + } + kCnt0 +=1; + } + } //end double object plot + + firedMap[pathName] = true; + } //end if trigger accept + } //end loop over plots/paths + + // sleep(1); //sleep for 1s, used to calibrate timing + double end = get_wall_time(); + double wallTime = end - start; + wallTime_.ME->Fill(wallTime); +} + +// ------------ method called when starting to processes a run ------------ +void +HLTObjectMonitor::dqmBeginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) +{ + if (debugPrint) std::cout << "Calling beginRun. " << std::endl; + bool changed = true; + if (hltConfig_.init(iRun, iSetup, processName_, changed)) + { + if (debugPrint) std::cout << "Extracting HLTconfig. " << std::endl; + } + + //get path indicies from menu + string pathName_noVersion; + vector triggerPaths = hltConfig_.triggerNames(); + + for (const auto & pathName : triggerPaths) + { + pathName_noVersion = hltConfig_.removeVersion(pathName); + for (auto plot : plotList) + { + if (plot->pathName == pathName_noVersion) + { + (*plot).pathIndex = hltConfig_.triggerIndex(pathName); + } + else if (plot->pathNameOR == pathName_noVersion) + { + (*plot).pathIndexOR = hltConfig_.triggerIndex(pathName); + } + } + } + vector plotList_temp; + for (auto plot : plotList) + { + if (plot->pathIndex > 0 || plot->pathIndexOR > 0) + { + plotList_temp.push_back(plot); + acceptMap[plot->pathName] = false; + if (plot->pathIndexOR > 0) acceptMap[plot->pathNameOR] = false; + } + } + //now re-assign plotList to contain only the plots with paths in the menu. + plotList = plotList_temp; + plotList_temp.clear(); + +} + +// ------------ method called when ending the processing of a run ------------ + +void +HLTObjectMonitor::endRun(edm::Run const&, edm::EventSetup const&) +{ + if (debugPrint) std::cout << "Calling endRun. " << std::endl; +} + +void HLTObjectMonitor::bookHistograms(DQMStore::IBooker & ibooker, edm::Run const& iRun, edm::EventSetup const& iSetup) +{ + + //////////////////////////////// + /// + /// Main shifter workspace plots + /// + //////////////////////////////// + + //book wall time separately + ibooker.setCurrentFolder(mainShifterFolder); + wallTime_.ME = ibooker.book1D(wallTime_.plotLabel,wallTime_.pathName,wallTime_.nBins,wallTime_.xMin,wallTime_.xMax); + wallTime_.ME->setAxisTitle(wallTime_.xAxisLabel); + + for (auto plot : plotList) + { + std::string display_pathNames = plot->pathName; + if (!plot->pathNameOR.empty()) display_pathNames = plot->pathName + " OR " + plot->pathNameOR; + + if (plot->displayInPrimary) + { + ibooker.setCurrentFolder(mainShifterFolder); + (*plot).ME = ibooker.book1D(plot->plotLabel,display_pathNames.c_str(),plot->nBins,plot->xMin,plot->xMax); + (*plot).ME->setAxisTitle(plot->xAxisLabel); + //need to add OR statement + } + else + { + ibooker.setCurrentFolder(backupFolder); + (*plot).ME = ibooker.book1D(plot->plotLabel,display_pathNames.c_str(),plot->nBins,plot->xMin,plot->xMax); + (*plot).ME->setAxisTitle(plot->xAxisLabel); + } + } + +} + +double HLTObjectMonitor::dxyFinder(double eta, double phi, edm::Handle recoChargedCands, edm::Handle recoBeamSpot) +{ + double dxy = -99.; + for (reco::RecoChargedCandidateCollection::const_iterator l3Muon = recoChargedCands->begin(); l3Muon != recoChargedCands->end(); l3Muon++) + { + if (deltaR(eta,phi,l3Muon->eta(),l3Muon->phi()) < 0.1) + { + dxy = (-(l3Muon->vx()-recoBeamSpot->x0()) * l3Muon->py() + (l3Muon->vy()-recoBeamSpot->y0()) * l3Muon->px())/l3Muon->pt(); + break; + } + } + return dxy; +} + +double HLTObjectMonitor::get_wall_time() +{ + struct timeval time; + if (gettimeofday(&time,NULL)) return 0; + return (double)time.tv_sec + (double)time.tv_usec * .000001; +} + +// ------------ method called when starting to processes a luminosity block ------------ +/* +void +HLTObjectMonitor::beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) +{ +} +*/ + +// ------------ method called when ending the processing of a luminosity block ------------ +/* +void +HLTObjectMonitor::endLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) +{ +} +*/ + +// ------------ method fills 'descriptions' with the allowed parameters for the module ------------ +// void +// HLTObjectMonitor::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { +// //The following says we do not know what parameters are allowed so do no validation +// // Please change this to state exactly what you do use, even if it is no parameters +// edm::ParameterSetDescription desc; +// desc.setUnknown(); +// descriptions.addDefault(desc); +// } + +//define this as a plug-in +DEFINE_FWK_MODULE(HLTObjectMonitor); diff --git a/DQM/HLTEvF/python/HLTObjectMonitor_cff.py b/DQM/HLTEvF/python/HLTObjectMonitor_cff.py new file mode 100644 index 0000000000000..841c148de7e4f --- /dev/null +++ b/DQM/HLTEvF/python/HLTObjectMonitor_cff.py @@ -0,0 +1,26 @@ +import FWCore.ParameterSet.Config as cms + +#commented out in 74X +#from DQM.HLTEvF.FourVectorHLTOnline_cfi import * +#from DQM.HLTEvF.OccupancyPlotter_cfi import * + +from DQM.HLTEvF.HLTObjectMonitor_cfi import * +# strip monitoring@HLT needs track re-fitting (estimation of the crossing angle through the sensor) +# => some ESProducer modules have to be run +# one of those (hltESPStripCPEfromTrackAngle) depends on the strip APV gain +# and therefore it has different setting in 25ns and 50ns HLT menu +# current setting is coherent w/ 50ns menu +# DQM.HLTEvF.HLTSiStripMonitoring_cff has to be updated as soon as the 25ns menu will be in production +from DQM.HLTEvF.HLTSiStripMonitoring_cff import * +from DQM.HLTEvF.HLTTrackingMonitoring_cff import * + + +hlt4vector = cms.Path( + hltObjectMonitor +# * sistripOnlineMonitorHLTsequence # strip cluster monitoring + * trackingMonitoringHLTsequence # tracking monitoring +) + + +#hlt4vector = cms.Path(onlineOccPlot * hltObjectMonitor) +#hlt4vector = cms.Path(onlineOccPlot) diff --git a/DQM/HLTEvF/python/HLTObjectMonitor_cfi.py b/DQM/HLTEvF/python/HLTObjectMonitor_cfi.py new file mode 100644 index 0000000000000..769250c988ef3 --- /dev/null +++ b/DQM/HLTEvF/python/HLTObjectMonitor_cfi.py @@ -0,0 +1,417 @@ +import FWCore.ParameterSet.Config as cms + +#setup names for multiple plots that use the same paths+modules +photon_pathName = "HLT_Photon30_R9Id90_HE10_IsoM" +photon_moduleName ="hltEG30R9Id90HE10IsoMTrackIsoFilter" + +muon_pathName = "HLT_IsoMu27" +muon_moduleName = "hltL3crIsoL1sMu25L1f0L2f10QL3f27QL3trkIsoFiltered0p09" + +l2muon_pathName = "HLT_L2Mu10" +l2muon_moduleName = "hltL2fL1sMu16L1f0L2Filtered10Q" + +l2NoBPTXmuon_pathName = "HLT_L2Mu10_NoVertex_NoBPTX3BX_NoHalo" +l2NoBPTXmuon_moduleName = "hltL2fL1sMuOpenNotBptxORL1f0NoVtxCosmicSeedMeanTimerL2Filtered10" + +electron_pathName = "HLT_Ele23_WPLoose_Gsf" +electron_moduleName = "hltEle23WPLooseGsfTrackIsoFilter" + +caloMet_pathName = "HLT_MET60_IsoTrk35_Loose" +caloMet_moduleName = "hltMET60" + +pfMet_pathName = "HLT_PFMET120_PFMHT120_IDTight" +pfMet_moduleName = "hltPFMET120" + +jetAk8_pathName = "HLT_AK8PFJet360_TrimMass30" +jetAk8_moduleName = "hltAK8SinglePFJet360TrimModMass30" + +rsq_mr_pathName = "HLT_RsqMR240_Rsq0p09_MR200" +rsq_mr_moduleName = "hltRsqMR240Rsq0p09MR200" + +bJet_pathNameCalo = "HLT_PFMET120_JetIdCleaned_BTagCSV0p72" +bJet_moduleNameCalo = "hltBLifetimeL3FilterCSVsusy" +bJet_pathNamePF = "HLT_QuadPFJet_SingleBTagCSV_VBF_Mqq500" +bJet_moduleNamePF = "hltCSVPF0p78" + +#To avoid booking histogram, set pathName = cms.string("") + +hltObjectMonitor = cms.EDAnalyzer('HLTObjectMonitor', + processName = cms.string("HLT"), + alphaT = cms.PSet( + pathName = cms.string("HLT_PFHT200_DiPFJetAve90_PFAlphaT0p63"), + moduleName = cms.string("hltPFHT200PFAlphaT0p63"), + axisLabel = cms.string("Alpha_{T}"), + plotLabel = cms.string("alphaT"), + mainWorkspace = cms.bool(True), + NbinsX = cms.int32(30), + Xmin = cms.double(0), + Xmax = cms.double(5) + ), + photonPt = cms.PSet( + pathName = cms.string(photon_pathName), + moduleName = cms.string(photon_moduleName), + plotLabel = cms.string("Photon_pT"), + axisLabel = cms.string("photon p_{T} [GeV]"), + mainWorkspace = cms.bool(True), + NbinsX = cms.int32(100), + Xmin = cms.double(0), + Xmax = cms.double(200) + ), + photonEta = cms.PSet( + pathName = cms.string(photon_pathName), + moduleName = cms.string(photon_moduleName), + plotLabel = cms.string("Photon_eta"), + axisLabel = cms.string("photon eta"), + mainWorkspace = cms.bool(False), + NbinsX = cms.int32(50), + Xmin = cms.double(-3), + Xmax = cms.double(3) + ), + photonPhi = cms.PSet( + pathName = cms.string(photon_pathName), + moduleName = cms.string(photon_moduleName), + plotLabel = cms.string("Photon_phi"), + axisLabel = cms.string("photon phi"), + mainWorkspace = cms.bool(False), + NbinsX = cms.int32(50), + Xmin = cms.double(-3.4), + Xmax = cms.double(3.4) + ), + muonPt = cms.PSet( + pathName = cms.string(muon_pathName), + moduleName = cms.string(muon_moduleName), + plotLabel = cms.string("Muon_pT"), + axisLabel = cms.string("muon p_{T} [GeV]"), + mainWorkspace = cms.bool(True), + NbinsX = cms.int32(75), + Xmin = cms.double(0), + Xmax = cms.double(150) + ), + muonEta = cms.PSet( + pathName = cms.string(muon_pathName), + moduleName = cms.string(muon_moduleName), + plotLabel = cms.string("Muon_eta"), + axisLabel = cms.string("muon eta"), + mainWorkspace = cms.bool(False), + NbinsX = cms.int32(50), + Xmin = cms.double(-3), + Xmax = cms.double(3) + ), + muonPhi = cms.PSet( + pathName = cms.string(muon_pathName), + moduleName = cms.string(muon_moduleName), + plotLabel = cms.string("Muon_phi"), + axisLabel = cms.string("muon phi"), + mainWorkspace = cms.bool(False), + NbinsX = cms.int32(50), + Xmin = cms.double(-3.4), + Xmax = cms.double(3.4) + ), + l2muonPt = cms.PSet( + pathName = cms.string(l2muon_pathName), + moduleName = cms.string(l2muon_moduleName), + plotLabel = cms.string("L2Muon_pT"), + axisLabel = cms.string("L2 muon p_{T} [GeV]"), + mainWorkspace = cms.bool(True), + NbinsX = cms.int32(75), + Xmin = cms.double(0), + Xmax = cms.double(150) + ), + l2muonEta = cms.PSet( + pathName = cms.string(l2muon_pathName), + moduleName = cms.string(l2muon_moduleName), + plotLabel = cms.string("L2Muon_eta"), + axisLabel = cms.string("L2 muon eta"), + mainWorkspace = cms.bool(False), + NbinsX = cms.int32(50), + Xmin = cms.double(-3), + Xmax = cms.double(3) + ), + l2muonPhi = cms.PSet( + pathName = cms.string(l2muon_pathName), + moduleName = cms.string(l2muon_moduleName), + plotLabel = cms.string("L2Muon_phi"), + axisLabel = cms.string("L2 muon phi"), + mainWorkspace = cms.bool(False), + NbinsX = cms.int32(50), + Xmin = cms.double(-3.4), + Xmax = cms.double(3.4) + ), + l2NoBPTXmuonPt = cms.PSet( + pathName = cms.string(l2NoBPTXmuon_pathName), + moduleName = cms.string(l2NoBPTXmuon_moduleName), + plotLabel = cms.string("L2NoBPTXMuon_pT"), + axisLabel = cms.string("L2 No BPTX muon p_{T} [GeV]"), + mainWorkspace = cms.bool(True), + NbinsX = cms.int32(75), + Xmin = cms.double(0), + Xmax = cms.double(150) + ), + l2NoBPTXmuonEta = cms.PSet( + pathName = cms.string(l2NoBPTXmuon_pathName), + moduleName = cms.string(l2NoBPTXmuon_moduleName), + plotLabel = cms.string("L2NoBPTXMuon_eta"), + axisLabel = cms.string("L2 NoBPTX muon eta"), + mainWorkspace = cms.bool(False), + NbinsX = cms.int32(50), + Xmin = cms.double(-3), + Xmax = cms.double(3) + ), + l2NoBPTXmuonPhi = cms.PSet( + pathName = cms.string(l2NoBPTXmuon_pathName), + moduleName = cms.string(l2NoBPTXmuon_moduleName), + plotLabel = cms.string("L2NoBPTXMuon_phi"), + axisLabel = cms.string("L2 NoBPTX muon phi"), + mainWorkspace = cms.bool(False), + NbinsX = cms.int32(50), + Xmin = cms.double(-3.4), + Xmax = cms.double(3.4) + ), + electronPt = cms.PSet( + pathName = cms.string(electron_pathName), + moduleName = cms.string(electron_moduleName), + plotLabel = cms.string("Electron_pT"), + axisLabel = cms.string("electron p_{T} [GeV]"), + mainWorkspace = cms.bool(True), + NbinsX = cms.int32(75), + Xmin = cms.double(0), + Xmax = cms.double(150) + ), + electronEta = cms.PSet( + pathName = cms.string(electron_pathName), + moduleName = cms.string(electron_moduleName), + plotLabel = cms.string("Electron_eta"), + axisLabel = cms.string("electron eta"), + mainWorkspace = cms.bool(False), + NbinsX = cms.int32(50), + Xmin = cms.double(-3), + Xmax = cms.double(3) + ), + electronPhi = cms.PSet( + pathName = cms.string(electron_pathName), + moduleName = cms.string(electron_moduleName), + plotLabel = cms.string("Electron_phi"), + axisLabel = cms.string("electron phi"), + mainWorkspace = cms.bool(False), + NbinsX = cms.int32(50), + Xmin = cms.double(-3.4), + Xmax = cms.double(3.4) + ), + jetPt = cms.PSet( + pathName = cms.string("HLT_PFJet200"), + moduleName = cms.string("hltSinglePFJet200"), + plotLabel = cms.string("Jet_pT"), + axisLabel = cms.string("jet p_{T} [GeV]"), + mainWorkspace = cms.bool(True), + NbinsX = cms.int32(75), + Xmin = cms.double(150), + Xmax = cms.double(550) + ), + jetAK8Pt = cms.PSet( + pathName = cms.string(jetAk8_pathName), + moduleName = cms.string(jetAk8_moduleName), + axisLabel = cms.string("AK8 jet p_{T} [GeV]"), + plotLabel = cms.string("JetAK8_Pt"), + mainWorkspace = cms.bool(True), + NbinsX = cms.int32(75), + Xmin = cms.double(150), + Xmax = cms.double(550) + ), + jetAK8Mass = cms.PSet( + pathName = cms.string(jetAk8_pathName), + moduleName = cms.string(jetAk8_moduleName), + plotLabel = cms.string("JetAK8_mass"), + axisLabel = cms.string("AK8 jet mass [GeV]"), + mainWorkspace = cms.bool(True), + NbinsX = cms.int32(100), + Xmin = cms.double(0), + Xmax = cms.double(200) + ), + tauPt = cms.PSet( + pathName = cms.string("HLT_DoubleMediumIsoPFTau40_Trk1_eta2p1_Reg"), + moduleName = cms.string("hltDoublePFTau40TrackPt1MediumIsolationDz02Reg"), + axisLabel = cms.string("tau p_{T} [GeV]"), + plotLabel = cms.string("Tau_pT"), + mainWorkspace = cms.bool(True), + NbinsX = cms.int32(75), + Xmin = cms.double(30), + Xmax = cms.double(350) + ), + diMuonLowMass = cms.PSet( + pathName = cms.string("HLT_DoubleMu4_3_Jpsi_Displaced"), + moduleName = cms.string("hltDisplacedmumuFilterDoubleMu43Jpsi"), + plotLabel = cms.string("Dimuon_LowMass"), + axisLabel = cms.string("di-muon low mass [GeV]"), + mainWorkspace = cms.bool(True), + NbinsX = cms.int32(100), + Xmin = cms.double(2.5), + Xmax = cms.double(3.5) + ), + caloMetPt = cms.PSet( + pathName = cms.string(caloMet_pathName), + moduleName = cms.string(caloMet_moduleName), + plotLabel = cms.string("CaloMET_pT"), + axisLabel = cms.string("calo MET p_{T} [GeV]"), + mainWorkspace = cms.bool(True), + NbinsX = cms.int32(60), + Xmin = cms.double(50), + Xmax = cms.double(550) + ), + caloMetPhi = cms.PSet( + pathName = cms.string(caloMet_pathName), + moduleName = cms.string(caloMet_moduleName), + plotLabel = cms.string("CaloMET_phi"), + axisLabel = cms.string("calo MET phi"), + mainWorkspace = cms.bool(False), + NbinsX = cms.int32(50), + Xmin = cms.double(-3.4), + Xmax = cms.double(3.4) + ), + pfMetPt = cms.PSet( + pathName = cms.string(pfMet_pathName), + moduleName = cms.string(pfMet_moduleName), + plotLabel = cms.string("PFMET_pT"), + axisLabel = cms.string("PF MET p_{T} [GeV]"), + mainWorkspace = cms.bool(True), + NbinsX = cms.int32(60), + Xmin = cms.double(100), + Xmax = cms.double(500) + ), + pfMetPhi = cms.PSet( + pathName = cms.string(pfMet_pathName), + moduleName = cms.string(pfMet_moduleName), + plotLabel = cms.string("PFMET_phi"), + axisLabel = cms.string("PF MET phi"), + mainWorkspace = cms.bool(False), + NbinsX = cms.int32(50), + Xmin = cms.double(-3.4), + Xmax = cms.double(3.4) + ), + caloHtPt = cms.PSet( + pathName = cms.string("HLT_HT650_DisplacedDijet80_Inclusive"), + moduleName = cms.string("hltHT650"), + plotLabel = cms.string("CaloHT_pT"), + axisLabel = cms.string("calo HT p_{T} [GeV]"), + mainWorkspace = cms.bool(True), + NbinsX = cms.int32(200), + Xmin = cms.double(0), + Xmax = cms.double(2000) + ), + pfHtPt = cms.PSet( + pathName = cms.string("HLT_PFHT750_4JetPt50"), + moduleName = cms.string("hltPF4JetPt50HT750"), + plotLabel = cms.string("PFHT_pT"), + axisLabel = cms.string("PF HT p_{T} [GeV]"), + mainWorkspace = cms.bool(True), + NbinsX = cms.int32(200), + Xmin = cms.double(0), + Xmax = cms.double(2000) + ), + bJetEta = cms.PSet( + pathName = cms.string(bJet_pathNameCalo), + moduleName = cms.string(bJet_moduleNameCalo), + pathName_OR = cms.string(bJet_pathNamePF), + moduleName_OR = cms.string(bJet_moduleNamePF), + plotLabel = cms.string("bJet_eta"), + axisLabel = cms.string("b-jet eta"), + mainWorkspace = cms.bool(False), + NbinsX = cms.int32(50), + Xmin = cms.double(-3), + Xmax = cms.double(3) + ), + bJetPhi = cms.PSet( + pathName = cms.string(bJet_pathNameCalo), + moduleName = cms.string(bJet_moduleNameCalo), + pathName_OR = cms.string(bJet_pathNamePF), + moduleName_OR = cms.string(bJet_moduleNamePF), + plotLabel = cms.string("bJet_phi"), + axisLabel = cms.string("b-jet phi"), + mainWorkspace = cms.bool(False), + NbinsX = cms.int32(50), + Xmin = cms.double(-3.4), + Xmax = cms.double(3.4) + ), + bJetCSVCalo = cms.PSet( + pathName = cms.string(bJet_pathNameCalo), + moduleName = cms.string(bJet_moduleNameCalo), + plotLabel = cms.string("bJetCSVCalo"), + axisLabel = cms.string("calo b-jet CSV"), + mainWorkspace = cms.bool(True), + NbinsX = cms.int32(110), + Xmin = cms.double(0), + Xmax = cms.double(1) + ), + bJetCSVPF = cms.PSet( + pathName = cms.string(bJet_pathNamePF), + moduleName = cms.string(bJet_moduleNamePF), + plotLabel = cms.string("bJetCSVPF"), + axisLabel = cms.string("PF b-jet CSV"), + mainWorkspace = cms.bool(True), + NbinsX = cms.int32(110), + Xmin = cms.double(0), + Xmax = cms.double(1) + ), + rsq = cms.PSet( + pathName = cms.string(rsq_mr_pathName), + moduleName = cms.string(rsq_mr_moduleName), + plotLabel = cms.string("Rsq"), + axisLabel = cms.string("R^{2}"), + mainWorkspace = cms.bool(True), + NbinsX = cms.int32(30), + Xmin = cms.double(0), + Xmax = cms.double(2) + ), + mr = cms.PSet( + pathName = cms.string(rsq_mr_pathName), + moduleName = cms.string(rsq_mr_moduleName), + plotLabel = cms.string("mr"), + axisLabel = cms.string("M_{R} [GeV]"), + mainWorkspace = cms.bool(True), + NbinsX = cms.int32(50), + Xmin = cms.double(0), + Xmax = cms.double(2000) + ), + diMuonMass = cms.PSet( + pathName = cms.string("HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ"), + moduleName = cms.string("hltDiMuonGlb17Glb8RelTrkIsoFiltered0p4DzFiltered0p2"), + pathName_OR = cms.string("HLT_Mu17_TrkIsoVVL_TkMu8_TrkIsoVVL_DZ"), + moduleName_OR = cms.string("hltDiMuonGlb17Trk8RelTrkIsoFiltered0p4DzFiltered0p2"), + plotLabel = cms.string("diMuon_Mass"), + axisLabel = cms.string("dimuon mass [GeV]"), + mainWorkspace = cms.bool(True), + NbinsX = cms.int32(50), + Xmin = cms.double(60), + Xmax = cms.double(160) + ), + diElecMass = cms.PSet( + pathName = cms.string("HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_DZ"), + moduleName = cms.string("hltEle23Ele12CaloIdLTrackIdLIsoVLDZFilter"), + plotLabel = cms.string("di-Electron_Mass"), + axisLabel = cms.string("di-electron mass [GeV]"), + mainWorkspace = cms.bool(True), + NbinsX = cms.int32(50), + Xmin = cms.double(60), + Xmax = cms.double(160) + ), + muonDxy = cms.PSet( + pathName = cms.string("HLT_DoubleMu18NoFiltersNoVtx"), + moduleName = cms.string("hltL3fDimuonL1f0L2NVf10L3NoFiltersNoVtxFiltered18"), + plotLabel = cms.string("Muon_dxy"), + axisLabel = cms.string("muon d_{xy} [mm]"), + mainWorkspace = cms.bool(True), + NbinsX = cms.int32(2000), + Xmin = cms.double(-10), + Xmax = cms.double(10) + ), + wallTime = cms.PSet( + pathName = cms.string("wall time per event"), + moduleName = cms.string(""), + plotLabel = cms.string("wallTime"), + axisLabel = cms.string("wall time per event [seconds]"), + mainWorkspace = cms.bool(True), + NbinsX = cms.int32(1000), + Xmin = cms.double(0), + Xmax = cms.double(0.005) + ) + +) diff --git a/DQM/HLTEvF/python/HLTSiStripMonitoring_cff.py b/DQM/HLTEvF/python/HLTSiStripMonitoring_cff.py new file mode 100644 index 0000000000000..cc6f7b1a26fd2 --- /dev/null +++ b/DQM/HLTEvF/python/HLTSiStripMonitoring_cff.py @@ -0,0 +1,204 @@ +import FWCore.ParameterSet.Config as cms + +from TrackingTools.RecoGeometry.RecoGeometries_cff import * +hltESPDummyDetLayerGeometry = DummyDetLayerGeometry.clone( +#hltESPDummyDetLayerGeometry = GlobalDetLayerGeometry.clone( + ComponentName = cms.string( "hltESPDummyDetLayerGeometry" ) +) + +# strip cluster monitor +# in order to get the crossing angle through the sensor +# the track trajectory is needed +# => the track re-fit has to be performed +# => some ESProducer have to be defined +# hltESPStripCPEfromTrackAngle depends on APV gain +# => it has different setting in 25ns and 50ns HLT menu +# please, make sure it has the setting in synch w/ HLT menu +# current setting is for 50ns menu + +## NB: the following ESProducer should be the same used in the HLT menu +## make sure they are not already defined somewhereelse inthe final configuration +from RecoLocalTracker.SiPixelRecHits.PixelCPETemplateReco_cfi import templates +hltESPPixelCPETemplateReco = templates.clone( + DoCosmics = cms.bool( False ), + LoadTemplatesFromDB = cms.bool( True ), + ComponentName = cms.string( "hltESPPixelCPETemplateReco" ), + Alpha2Order = cms.bool( True ), + ClusterProbComputationFlag = cms.int32( 0 ), + speed = cms.int32( -2 ), + UseClusterSplitter = cms.bool( False ) +) + +from RecoLocalTracker.SiPixelRecHits.PixelCPEGeneric_cfi import PixelCPEGenericESProducer +hltESPPixelCPEGeneric = PixelCPEGenericESProducer.clone( + EdgeClusterErrorX = cms.double( 50.0 ), + DoCosmics = cms.bool( False ), + LoadTemplatesFromDB = cms.bool( True ), + UseErrorsFromTemplates = cms.bool( True ), + eff_charge_cut_highX = cms.double( 1.0 ), + TruncatePixelCharge = cms.bool( True ), + size_cutY = cms.double( 3.0 ), + size_cutX = cms.double( 3.0 ), + inflate_all_errors_no_trk_angle = cms.bool( False ), + IrradiationBiasCorrection = cms.bool( False ), + TanLorentzAnglePerTesla = cms.double( 0.106 ), + inflate_errors = cms.bool( False ), + eff_charge_cut_lowX = cms.double( 0.0 ), + eff_charge_cut_highY = cms.double( 1.0 ), + ClusterProbComputationFlag = cms.int32( 0 ), + EdgeClusterErrorY = cms.double( 85.0 ), + ComponentName = cms.string( "hltESPPixelCPEGeneric" ), + eff_charge_cut_lowY = cms.double( 0.0 ), + PixelErrorParametrization = cms.string( "NOTcmsim" ), + Alpha2Order = cms.bool( True ) +) + +from RecoTracker.TransientTrackingRecHit.TTRHBuilderWithTemplate_cfi import TTRHBuilderAngleAndTemplate +hltESPTTRHBuilderAngleAndTemplate = TTRHBuilderAngleAndTemplate.clone( + StripCPE = cms.string( "hltESPStripCPEfromTrackAngle" ), + Matcher = cms.string( "StandardMatcher" ), + ComputeCoarseLocalPositionFromDisk = cms.bool( False ), + PixelCPE = cms.string( "hltESPPixelCPETemplateReco" ), + ComponentName = cms.string( "hltESPTTRHBuilderAngleAndTemplate" ) +) + +hltESPTTRHBWithTrackAngle = TTRHBuilderAngleAndTemplate.clone( + StripCPE = cms.string( "hltESPStripCPEfromTrackAngle" ), + Matcher = cms.string( "StandardMatcher" ), + ComputeCoarseLocalPositionFromDisk = cms.bool( False ), + PixelCPE = cms.string( "hltESPPixelCPEGeneric" ), + ComponentName = cms.string( "hltESPTTRHBWithTrackAngle" ) +) + +from RecoLocalTracker.SiStripRecHitConverter.StripCPEESProducer_cfi import stripCPEESProducer +hltESPStripCPEfromTrackAngle = stripCPEESProducer.clone( + ComponentType = cms.string( "StripCPEfromTrackAngle" ), + ComponentName = cms.string( "hltESPStripCPEfromTrackAngle" ), + parameters = cms.PSet( + mLC_P2 = cms.double( 0.3 ), + mLC_P1 = cms.double( 0.618 ), + mLC_P0 = cms.double( -0.326 ), + useLegacyError = cms.bool( True ), # 50ns menu + maxChgOneMIP = cms.double( -6000.0 ), # 50ns menu +# useLegacyError = cms.bool( False ), # 25ns menu +# maxChgOneMIP = cms.double( 6000.0 ), #25ns menu + mTEC_P1 = cms.double( 0.471 ), + mTEC_P0 = cms.double( -1.885 ), + mTOB_P0 = cms.double( -1.026 ), + mTOB_P1 = cms.double( 0.253 ), + mTIB_P0 = cms.double( -0.742 ), + mTIB_P1 = cms.double( 0.202 ), + mTID_P0 = cms.double( -1.427 ), + mTID_P1 = cms.double( 0.433 ) + ) +) + +from RecoTracker.TkNavigation.NavigationSchoolESProducer_cfi import navigationSchoolESProducer +navigationSchoolESProducer = navigationSchoolESProducer.clone( + ComponentName = cms.string( "SimpleNavigationSchool" ), + SimpleMagneticField = cms.string( "ParabolicMf" ) +) + +from RecoTracker.MeasurementDet.MeasurementTrackerESProducer_cfi import MeasurementTracker +hltESPMeasurementTracker = MeasurementTracker.clone( + UseStripStripQualityDB = cms.bool( True ), + StripCPE = cms.string( "hltESPStripCPEfromTrackAngle" ), + UsePixelROCQualityDB = cms.bool( True ), + DebugPixelROCQualityDB = cms.untracked.bool( False ), + UseStripAPVFiberQualityDB = cms.bool( True ), + badStripCuts = cms.PSet( + TOB = cms.PSet( + maxConsecutiveBad = cms.uint32( 9999 ), + maxBad = cms.uint32( 9999 ) + ), + TID = cms.PSet( + maxConsecutiveBad = cms.uint32( 9999 ), + maxBad = cms.uint32( 9999 ) + ), + TEC = cms.PSet( + maxConsecutiveBad = cms.uint32( 9999 ), + maxBad = cms.uint32( 9999 ) + ), + TIB = cms.PSet( + maxConsecutiveBad = cms.uint32( 9999 ), + maxBad = cms.uint32( 9999 ) + ) + ), + DebugStripModuleQualityDB = cms.untracked.bool( False ), + ComponentName = cms.string( "hltESPMeasurementTracker" ), + DebugPixelModuleQualityDB = cms.untracked.bool( False ), + UsePixelModuleQualityDB = cms.bool( True ), + DebugStripAPVFiberQualityDB = cms.untracked.bool( False ), + HitMatcher = cms.string( "StandardMatcher" ), + DebugStripStripQualityDB = cms.untracked.bool( False ), + PixelCPE = cms.string( "hltESPPixelCPEGeneric" ), + SiStripQualityLabel = cms.string( "" ), + UseStripModuleQualityDB = cms.bool( True ), + MaskBadAPVFibers = cms.bool( True ) +) + +hltESPRungeKuttaTrackerPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + SimpleMagneticField = cms.string( "" ), + PropagationDirection = cms.string( "alongMomentum" ), + ComponentName = cms.string( "hltESPRungeKuttaTrackerPropagator" ), + Mass = cms.double( 0.105 ), + ptMin = cms.double( -1.0 ), + MaxDPhi = cms.double( 1.6 ), + useRungeKutta = cms.bool( True ) +) + +from TrackingTools.KalmanUpdators.KFUpdatorESProducer_cfi import KFUpdatorESProducer +hltESPKFUpdator = KFUpdatorESProducer.clone( + ComponentName = cms.string( "hltESPKFUpdator" ) +) + +hltESPChi2MeasurementEstimator30 = cms.ESProducer( "Chi2MeasurementEstimatorESProducer", + MaxChi2 = cms.double( 30.0 ), + nSigma = cms.double( 3.0 ), + ComponentName = cms.string( "hltESPChi2MeasurementEstimator30" ) +) + +from TrackingTools.TrackFitters.KFTrajectoryFitterESProducer_cfi import KFTrajectoryFitter +hltESPTrajectoryFitterRK = KFTrajectoryFitter.clone( + minHits = cms.int32( 3 ), + ComponentName = cms.string( "hltESPTrajectoryFitterRK" ), + Estimator = cms.string( "hltESPChi2MeasurementEstimator30" ), + Updator = cms.string( "hltESPKFUpdator" ), + Propagator = cms.string( "hltESPRungeKuttaTrackerPropagator" ), +# RecoGeometry = cms.string( "hltESPDummyDetLayerGeometry" ) + RecoGeometry = cms.string( "hltESPDummyDetLayerGeometry" ) +) + +hltMeasurementTrackerEvent = cms.EDProducer( "MeasurementTrackerEventProducer", + inactivePixelDetectorLabels = cms.VInputTag( ), + stripClusterProducer = cms.string( "hltSiStripRawToClustersFacility" ), + pixelClusterProducer = cms.string( "hltSiPixelClusters" ), + switchOffPixelsIfEmpty = cms.bool( True ), + inactiveStripDetectorLabels = cms.VInputTag( ), + skipClusters = cms.InputTag( "" ), + measurementTracker = cms.string( "hltESPMeasurementTracker" ) +) + +from DQMOffline.Trigger.SiStrip_OfflineMonitoring_cff import * +hltTrackRefitterForSiStripMonitorTrack.TTRHBuilder = cms.string('hltESPTTRHBWithTrackAngle') +hltTrackRefitterForSiStripMonitorTrack.Propagator = cms.string('hltESPRungeKuttaTrackerPropagator') +hltTrackRefitterForSiStripMonitorTrack.Fitter = cms.string('hltESPTrajectoryFitterRK') +hltTrackRefitterForSiStripMonitorTrack.MeasurementTracker = cms.string('hltESPMeasurementTracker') +hltTrackRefitterForSiStripMonitorTrack.MeasurementTrackerEvent = cms.InputTag('hltMeasurementTrackerEvent') +hltTrackRefitterForSiStripMonitorTrack.NavigationSchool = cms.string('') + +HLTSiStripMonitorTrack.TopFolderName = cms.string('HLT/SiStrip') +HLTSiStripMonitorTrack.TrackProducer = 'hltTrackRefitterForSiStripMonitorTrack' +HLTSiStripMonitorTrack.TrackLabel = '' +HLTSiStripMonitorTrack.Cluster_src = cms.InputTag('hltSiStripRawToClustersFacility') +HLTSiStripMonitorTrack.AlgoName = cms.string("HLT") +HLTSiStripMonitorTrack.Trend_On = cms.bool(True) +HLTSiStripMonitorTrack.Mod_On = cms.bool(False) +HLTSiStripMonitorTrack.OffHisto_On = cms.bool(True) +HLTSiStripMonitorTrack.HistoFlag_On = cms.bool(False) +HLTSiStripMonitorTrack.TkHistoMap_On = cms.bool(False) + +sistripOnlineMonitorHLTsequence = cms.Sequence( + hltMeasurementTrackerEvent + * sistripMonitorHLTsequence # strip cluster monitoring +) diff --git a/DQM/HLTEvF/python/HLTTrackingMonitoring_cff.py b/DQM/HLTEvF/python/HLTTrackingMonitoring_cff.py new file mode 100644 index 0000000000000..e2be5e8ef1947 --- /dev/null +++ b/DQM/HLTEvF/python/HLTTrackingMonitoring_cff.py @@ -0,0 +1,15 @@ +import FWCore.ParameterSet.Config as cms + +# tracking monitor +from DQMOffline.Trigger.TrackingMonitoring_cff import * +iterHLTTracksMonitoringHLT.doProfilesVsLS = cms.bool(True) +iterHLTTracksMonitoringHLT.beamSpot = cms.InputTag("hltOnlineBeamSpot") +pixelTracksMonitoringHLT.beamSpot = cms.InputTag("hltOnlineBeamSpot") + +from TrackingTools.TrackFitters.KFTrajectoryFitterESProducer_cfi import * +from TrackingTools.TransientTrack.TransientTrackBuilder_cfi import * + +trackingMonitoringHLTsequence = cms.Sequence( + pixelTracksMonitoringHLT # hltPixel tracks monitoring + * iterHLTTracksMonitoringHLT # hltIter2Merged tracks monitoring +) diff --git a/DQM/HLTEvF/test/HLTObjectMonitor_cfg.py b/DQM/HLTEvF/test/HLTObjectMonitor_cfg.py new file mode 100644 index 0000000000000..d77b87349c11a --- /dev/null +++ b/DQM/HLTEvF/test/HLTObjectMonitor_cfg.py @@ -0,0 +1,20 @@ +import FWCore.ParameterSet.Config as cms + +process = cms.Process("Demo") + +process.load("FWCore.MessageService.MessageLogger_cfi") + +process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(-1) ) + +process.source = cms.Source("PoolSource", + # replace 'myfile.root' with the source file you want to use + fileNames = cms.untracked.vstring( + 'file:myfile.root' + ) +) + +process.demo = cms.EDAnalyzer('HLTObjectMonitor' +) + + +process.p = cms.Path(process.demo) diff --git a/DQM/Integration/python/clients/hlt_dqm_sourceclient-live_cfg.py b/DQM/Integration/python/clients/hlt_dqm_sourceclient-live_cfg.py index 0075ae36aa9fe..b6e633350c9bc 100644 --- a/DQM/Integration/python/clients/hlt_dqm_sourceclient-live_cfg.py +++ b/DQM/Integration/python/clients/hlt_dqm_sourceclient-live_cfg.py @@ -15,7 +15,7 @@ process.dqmEnv.subSystemFolder = 'HLT' process.dqmSaver.tag = 'HLT' -process.load("Configuration.StandardSequences.GeometryPilot2_cff") +process.load("Configuration.StandardSequences.GeometryRecoDB_cff") process.load("Configuration.StandardSequences.MagneticField_cff") process.GlobalTrackingGeometryESProducer = cms.ESProducer( "GlobalTrackingGeometryESProducer" ) # for muon hlt dqm #SiStrip Local Reco @@ -27,6 +27,7 @@ # Condition for lxplus #process.load("DQM.Integration.config.FrontierCondition_GT_Offline_cfi") +process.load("DQM.HLTEvF.HLTObjectMonitor_cff") # added for hlt scalars process.load("DQM.TrigXMonitor.HLTSeedL1LogicScalers_cfi") # added for hlt scalars