Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2025-02-24 23:24:40 

0001 // -*- C++ -*-
0002 //
0003 // Package:    DQM/HLTObjectMonitor
0004 // Class:      HLTObjectMonitor
0005 //
0006 /**\class HLTObjectMonitor HLTObjectMonitor.cc DQM/HLTEvF/plugins/HLTObjectMonitor.cc
0007 
0008  Description: [one line class summary]
0009 
0010  Implementation:
0011      [Notes on implementation]
0012 */
0013 //
0014 // Original Author:  Charles Nicholas Mueller
0015 //         Created:  Sun, 22 Mar 2015 22:29:00 GMT
0016 //
0017 //
0018 
0019 // system include files
0020 #include <memory>
0021 #include <sys/time.h>
0022 #include <cstdlib>
0023 
0024 // user include files
0025 #include "DataFormats/Common/interface/TriggerResults.h"
0026 #include "DataFormats/HLTReco/interface/TriggerObject.h"
0027 #include "DataFormats/HLTReco/interface/TriggerEvent.h"
0028 #include "DataFormats/HLTReco/interface/TriggerTypeDefs.h"
0029 #include "DataFormats/Scalers/interface/LumiScalers.h"
0030 
0031 #include "FWCore/Framework/interface/Frameworkfwd.h"
0032 #include "FWCore/Framework/interface/Event.h"
0033 #include "FWCore/Framework/interface/MakerMacros.h"
0034 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0035 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0036 
0037 #include "HLTrigger/HLTcore/interface/HLTConfigProvider.h"
0038 
0039 //for collections
0040 #include "HLTrigger/JetMET/interface/AlphaT.h"
0041 #include "DataFormats/BeamSpot/interface/BeamSpot.h"
0042 #include "DataFormats/METReco/interface/MET.h"
0043 #include "DataFormats/RecoCandidate/interface/RecoChargedCandidate.h"
0044 #include "DataFormats/BTauReco/interface/JetTag.h"
0045 #include "DataFormats/RecoCandidate/interface/RecoChargedCandidateFwd.h"
0046 #include "DataFormats/Math/interface/deltaR.h"
0047 #include "DataFormats/JetReco/interface/PFJet.h"
0048 #include "DataFormats/JetReco/interface/CaloJet.h"
0049 
0050 #include "DQMServices/Core/interface/DQMStore.h"
0051 #include "DQMServices/Core/interface/DQMEDAnalyzer.h"
0052 
0053 #include "TMath.h"
0054 #include "TStyle.h"
0055 #include "TLorentzVector.h"
0056 
0057 #include <unordered_map>
0058 //
0059 // class declaration
0060 //
0061 
0062 //using namespace edm;
0063 using namespace trigger;
0064 using std::string;
0065 using std::unordered_map;
0066 using std::vector;
0067 
0068 class HLTObjectMonitor : public DQMEDAnalyzer {
0069   struct hltPlot {
0070     MonitorElement* ME;
0071     string pathName;
0072     string pathNameOR;
0073     string moduleName;
0074     string moduleNameOR;
0075     int pathIndex = -99;
0076     int pathIndexOR = -99;
0077     string plotLabel;
0078     string xAxisLabel;
0079     int nBins;
0080     double xMin;
0081     double xMax;
0082     bool displayInPrimary;
0083   };
0084 
0085 public:
0086   explicit HLTObjectMonitor(const edm::ParameterSet&);
0087   static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
0088 
0089 private:
0090   void analyze(const edm::Event&, const edm::EventSetup&) override;
0091   void bookHistograms(DQMStore::IBooker& i, edm::Run const&, edm::EventSetup const&) override;
0092   void dqmBeginRun(edm::Run const&, edm::EventSetup const&) override;
0093   vector<hltPlot*> plotList;
0094   double dxyFinder(double, double, edm::Handle<reco::RecoChargedCandidateCollection>, edm::Handle<reco::BeamSpot>);
0095   double dzFinder(double, double, edm::Handle<reco::RecoChargedCandidateCollection>, edm::Handle<reco::BeamSpot>);
0096   double get_wall_time(void);
0097   // ----------member data ---------------------------
0098 
0099   bool debugPrint;
0100   HLTConfigProvider hltConfig_;
0101   string topDirectoryName;
0102   string mainShifterFolder;
0103   string backupFolder;
0104   unordered_map<string, bool> acceptMap;
0105   unordered_map<hltPlot*, edm::ParameterSet*> plotMap;
0106 
0107   //set Token(-s)
0108   edm::EDGetTokenT<edm::TriggerResults> triggerResultsToken_;
0109   edm::EDGetTokenT<trigger::TriggerEvent> aodTriggerToken_;
0110   edm::EDGetTokenT<LumiScalersCollection> lumiScalersToken_;
0111   edm::EDGetTokenT<reco::BeamSpot> beamSpotToken_;
0112   edm::EDGetTokenT<reco::RecoChargedCandidateCollection> chargedCandToken_;
0113   edm::EDGetTokenT<reco::JetTagCollection> csvCaloTagsToken_;
0114   edm::EDGetTokenT<reco::JetTagCollection> csvPfTagsToken_;
0115   edm::EDGetTokenT<vector<reco::CaloJet>> csvCaloJetsToken_;
0116   edm::EDGetTokenT<vector<reco::PFJet>> csvPfJetsToken_;
0117 
0118   //declare params
0119   edm::ParameterSet rsq_pset;
0120   edm::ParameterSet mr_pset;
0121   edm::ParameterSet alphaT_pset;
0122   edm::ParameterSet photonPt_pset;
0123   edm::ParameterSet photonEta_pset;
0124   edm::ParameterSet photonPhi_pset;
0125   edm::ParameterSet muonPt_pset;
0126   edm::ParameterSet muonEta_pset;
0127   edm::ParameterSet muonPhi_pset;
0128   edm::ParameterSet l2muonPt_pset;
0129   edm::ParameterSet l2muonEta_pset;
0130   edm::ParameterSet l2muonPhi_pset;
0131   edm::ParameterSet l2NoBPTXmuonPt_pset;
0132   edm::ParameterSet l2NoBPTXmuonEta_pset;
0133   edm::ParameterSet l2NoBPTXmuonPhi_pset;
0134   edm::ParameterSet electronPt_pset;
0135   edm::ParameterSet electronEta_pset;
0136   edm::ParameterSet electronPhi_pset;
0137   edm::ParameterSet jetPt_pset;
0138   edm::ParameterSet jetAK8Pt_pset;
0139   edm::ParameterSet jetAK8Mass_pset;
0140   edm::ParameterSet tauPt_pset;
0141   edm::ParameterSet diMuonLowMass_pset;
0142   edm::ParameterSet caloMetPt_pset;
0143   edm::ParameterSet caloMetPhi_pset;
0144   edm::ParameterSet pfMetPt_pset;
0145   edm::ParameterSet pfMetPhi_pset;
0146   edm::ParameterSet caloHtPt_pset;
0147   edm::ParameterSet pfHtPt_pset;
0148   edm::ParameterSet bJetPhi_pset;
0149   edm::ParameterSet bJetEta_pset;
0150   edm::ParameterSet bJetCSVCalo_pset;
0151   edm::ParameterSet bJetCSVPF_pset;
0152   edm::ParameterSet diMuonMass_pset;
0153   edm::ParameterSet pAL1DoubleMuZMass_pset;
0154   edm::ParameterSet pAL2DoubleMuZMass_pset;
0155   edm::ParameterSet pAL3DoubleMuZMass_pset;
0156   edm::ParameterSet diElecMass_pset;
0157   edm::ParameterSet muonDxy_pset;
0158   edm::ParameterSet muonDz_pset;
0159   edm::ParameterSet wallTime_pset;
0160 
0161   string processName_;
0162 
0163   hltPlot rsq_;
0164   hltPlot mr_;
0165   hltPlot alphaT_;
0166   hltPlot photonPt_;
0167   hltPlot photonEta_;
0168   hltPlot photonPhi_;
0169   hltPlot muonPt_;
0170   hltPlot muonEta_;
0171   hltPlot muonPhi_;
0172   hltPlot l2muonPt_;
0173   hltPlot l2muonEta_;
0174   hltPlot l2muonPhi_;
0175   hltPlot l2NoBPTXmuonPt_;
0176   hltPlot l2NoBPTXmuonEta_;
0177   hltPlot l2NoBPTXmuonPhi_;
0178   hltPlot electronPt_;
0179   hltPlot electronEta_;
0180   hltPlot electronPhi_;
0181   hltPlot jetPt_;
0182   hltPlot jetAK8Pt_;
0183   hltPlot jetAK8Mass_;
0184   hltPlot tauPt_;
0185   hltPlot diMuonLowMass_;
0186   hltPlot caloMetPt_;
0187   hltPlot caloMetPhi_;
0188   hltPlot pfMetPt_;
0189   hltPlot pfMetPhi_;
0190   hltPlot caloHtPt_;
0191   hltPlot pfHtPt_;
0192   hltPlot bJetPhi_;
0193   hltPlot bJetEta_;
0194   hltPlot bJetCSVCalo_;
0195   hltPlot bJetCSVPF_;
0196   hltPlot diMuonMass_;
0197   hltPlot pAL1DoubleMuZMass_;
0198   hltPlot pAL2DoubleMuZMass_;
0199   hltPlot pAL3DoubleMuZMass_;
0200   hltPlot diElecMass_;
0201   hltPlot muonDxy_;
0202   hltPlot muonDz_;
0203   hltPlot wallTime_;
0204 };
0205 
0206 //
0207 // constants, enums and typedefs
0208 //
0209 
0210 //
0211 // static data member definitions
0212 //
0213 
0214 //
0215 // constructors and destructor
0216 //
0217 HLTObjectMonitor::HLTObjectMonitor(const edm::ParameterSet& iConfig)
0218 
0219 {
0220   //now do what ever initialization is needed
0221   debugPrint = false;
0222 
0223   topDirectoryName = "HLT/ObjectMonitor";
0224   mainShifterFolder = topDirectoryName + "/MainShifter";
0225   backupFolder = topDirectoryName + "/Backup";
0226 
0227   //parse params
0228   processName_ = iConfig.getParameter<string>("processName");
0229 
0230   rsq_pset = iConfig.getParameter<edm::ParameterSet>("rsq");
0231   plotMap[&rsq_] = &rsq_pset;
0232   mr_pset = iConfig.getParameter<edm::ParameterSet>("mr");
0233   plotMap[&mr_] = &mr_pset;
0234   alphaT_pset = iConfig.getParameter<edm::ParameterSet>("alphaT");
0235   plotMap[&alphaT_] = &alphaT_pset;
0236   photonPt_pset = iConfig.getParameter<edm::ParameterSet>("photonPt");
0237   plotMap[&photonPt_] = &photonPt_pset;
0238   photonEta_pset = iConfig.getParameter<edm::ParameterSet>("photonEta");
0239   plotMap[&photonEta_] = &photonEta_pset;
0240   photonPhi_pset = iConfig.getParameter<edm::ParameterSet>("photonPhi");
0241   plotMap[&photonPhi_] = &photonPhi_pset;
0242   muonPt_pset = iConfig.getParameter<edm::ParameterSet>("muonPt");
0243   plotMap[&muonPt_] = &muonPt_pset;
0244   muonEta_pset = iConfig.getParameter<edm::ParameterSet>("muonEta");
0245   plotMap[&muonEta_] = &muonEta_pset;
0246   muonPhi_pset = iConfig.getParameter<edm::ParameterSet>("muonPhi");
0247   plotMap[&muonPhi_] = &muonPhi_pset;
0248   l2muonPt_pset = iConfig.getParameter<edm::ParameterSet>("l2muonPt");
0249   plotMap[&l2muonPt_] = &l2muonPt_pset;
0250   l2muonEta_pset = iConfig.getParameter<edm::ParameterSet>("l2muonEta");
0251   plotMap[&l2muonEta_] = &l2muonEta_pset;
0252   l2muonPhi_pset = iConfig.getParameter<edm::ParameterSet>("l2muonPhi");
0253   plotMap[&l2muonPhi_] = &l2muonPhi_pset;
0254   l2NoBPTXmuonPt_pset = iConfig.getParameter<edm::ParameterSet>("l2NoBPTXmuonPt");
0255   plotMap[&l2NoBPTXmuonPt_] = &l2NoBPTXmuonPt_pset;
0256   l2NoBPTXmuonEta_pset = iConfig.getParameter<edm::ParameterSet>("l2NoBPTXmuonEta");
0257   plotMap[&l2NoBPTXmuonEta_] = &l2NoBPTXmuonEta_pset;
0258   l2NoBPTXmuonPhi_pset = iConfig.getParameter<edm::ParameterSet>("l2NoBPTXmuonPhi");
0259   plotMap[&l2NoBPTXmuonPhi_] = &l2NoBPTXmuonPhi_pset;
0260   electronPt_pset = iConfig.getParameter<edm::ParameterSet>("electronPt");
0261   plotMap[&electronPt_] = &electronPt_pset;
0262   electronEta_pset = iConfig.getParameter<edm::ParameterSet>("electronEta");
0263   plotMap[&electronEta_] = &electronEta_pset;
0264   electronPhi_pset = iConfig.getParameter<edm::ParameterSet>("electronPhi");
0265   plotMap[&electronPhi_] = &electronPhi_pset;
0266   jetPt_pset = iConfig.getParameter<edm::ParameterSet>("jetPt");
0267   plotMap[&jetPt_] = &jetPt_pset;
0268   jetAK8Mass_pset = iConfig.getParameter<edm::ParameterSet>("jetAK8Mass");
0269   plotMap[&jetAK8Mass_] = &jetAK8Mass_pset;
0270   diMuonLowMass_pset = iConfig.getParameter<edm::ParameterSet>("diMuonLowMass");
0271   plotMap[&diMuonLowMass_] = &diMuonLowMass_pset;
0272   caloMetPt_pset = iConfig.getParameter<edm::ParameterSet>("caloMetPt");
0273   plotMap[&caloMetPt_] = &caloMetPt_pset;
0274   caloMetPhi_pset = iConfig.getParameter<edm::ParameterSet>("caloMetPhi");
0275   plotMap[&caloMetPhi_] = &caloMetPhi_pset;
0276   pfMetPt_pset = iConfig.getParameter<edm::ParameterSet>("pfMetPt");
0277   plotMap[&pfMetPt_] = &pfMetPt_pset;
0278   pfMetPhi_pset = iConfig.getParameter<edm::ParameterSet>("pfMetPhi");
0279   plotMap[&pfMetPhi_] = &pfMetPhi_pset;
0280   caloHtPt_pset = iConfig.getParameter<edm::ParameterSet>("caloHtPt");
0281   plotMap[&caloHtPt_] = &caloHtPt_pset;
0282   pfHtPt_pset = iConfig.getParameter<edm::ParameterSet>("pfHtPt");
0283   plotMap[&pfHtPt_] = &pfHtPt_pset;
0284   bJetPhi_pset = iConfig.getParameter<edm::ParameterSet>("bJetPhi");
0285   plotMap[&bJetPhi_] = &bJetPhi_pset;
0286   bJetEta_pset = iConfig.getParameter<edm::ParameterSet>("bJetEta");
0287   plotMap[&bJetEta_] = &bJetEta_pset;
0288   bJetCSVCalo_pset = iConfig.getParameter<edm::ParameterSet>("bJetCSVCalo");
0289   plotMap[&bJetCSVCalo_] = &bJetCSVCalo_pset;
0290   bJetCSVPF_pset = iConfig.getParameter<edm::ParameterSet>("bJetCSVPF");
0291   plotMap[&bJetCSVPF_] = &bJetCSVPF_pset;
0292   diMuonMass_pset = iConfig.getParameter<edm::ParameterSet>("diMuonMass");
0293   plotMap[&diMuonMass_] = &diMuonMass_pset;
0294   pAL1DoubleMuZMass_pset = iConfig.getParameter<edm::ParameterSet>("pAL1DoubleMuZMass");
0295   plotMap[&pAL1DoubleMuZMass_] = &pAL1DoubleMuZMass_pset;
0296   pAL2DoubleMuZMass_pset = iConfig.getParameter<edm::ParameterSet>("pAL2DoubleMuZMass");
0297   plotMap[&pAL2DoubleMuZMass_] = &pAL2DoubleMuZMass_pset;
0298   pAL3DoubleMuZMass_pset = iConfig.getParameter<edm::ParameterSet>("pAL3DoubleMuZMass");
0299   plotMap[&pAL3DoubleMuZMass_] = &pAL3DoubleMuZMass_pset;
0300   diElecMass_pset = iConfig.getParameter<edm::ParameterSet>("diElecMass");
0301   plotMap[&diElecMass_] = &diElecMass_pset;
0302   muonDxy_pset = iConfig.getParameter<edm::ParameterSet>("muonDxy");
0303   plotMap[&muonDxy_] = &muonDxy_pset;
0304   muonDz_pset = iConfig.getParameter<edm::ParameterSet>("muonDz");
0305   plotMap[&muonDz_] = &muonDz_pset;
0306   jetAK8Pt_pset = iConfig.getParameter<edm::ParameterSet>("jetAK8Pt");
0307   plotMap[&jetAK8Pt_] = &jetAK8Pt_pset;
0308   tauPt_pset = iConfig.getParameter<edm::ParameterSet>("tauPt");
0309   plotMap[&tauPt_] = &tauPt_pset;
0310   wallTime_pset = iConfig.getParameter<edm::ParameterSet>("wallTime");
0311   plotMap[&wallTime_] = &wallTime_pset;
0312 
0313   for (auto& [key, value] : plotMap) {
0314     key->pathName = value->getParameter<std::string>("pathName");
0315     key->moduleName = value->getParameter<std::string>("moduleName");
0316     key->nBins = value->getParameter<int>("NbinsX");
0317     key->xMin = value->getParameter<double>("Xmin");
0318     key->xMax = value->getParameter<double>("Xmax");
0319     key->xAxisLabel = value->getParameter<std::string>("axisLabel");
0320     key->plotLabel = value->getParameter<std::string>("plotLabel");
0321     key->displayInPrimary = value->getParameter<bool>("mainWorkspace");
0322 
0323     if (value->exists("pathName_OR")) {
0324       key->pathNameOR = value->getParameter<std::string>("pathName_OR");
0325     }
0326     if (value->exists("moduleName_OR")) {
0327       key->moduleNameOR = value->getParameter<std::string>("moduleName_OR");
0328     }
0329     plotList.push_back(key);
0330   }
0331   plotMap.clear();
0332 
0333   //set Token(s)
0334   triggerResultsToken_ = consumes<edm::TriggerResults>(edm::InputTag("TriggerResults", "", processName_));
0335   aodTriggerToken_ = consumes<trigger::TriggerEvent>(edm::InputTag("hltTriggerSummaryAOD", "", processName_));
0336   lumiScalersToken_ = consumes<LumiScalersCollection>(edm::InputTag("hltScalersRawToDigi", "", ""));
0337   beamSpotToken_ = consumes<reco::BeamSpot>(edm::InputTag("hltOnlineBeamSpot", "", processName_));
0338   chargedCandToken_ = consumes<vector<reco::RecoChargedCandidate>>(
0339       edm::InputTag("hltL3NoFiltersNoVtxMuonCandidates", "", processName_));
0340   csvCaloTagsToken_ =
0341       consumes<reco::JetTagCollection>(edm::InputTag("hltCombinedSecondaryVertexBJetTagsCalo", "", processName_));
0342   csvPfTagsToken_ =
0343       consumes<reco::JetTagCollection>(edm::InputTag("hltCombinedSecondaryVertexBJetTagsPF", "", processName_));
0344   csvCaloJetsToken_ =
0345       consumes<vector<reco::CaloJet>>(edm::InputTag("hltSelector8CentralJetsL1FastJet", "", processName_));
0346   csvPfJetsToken_ = consumes<vector<reco::PFJet>>(edm::InputTag("hltPFJetForBtag", "", processName_));
0347 }
0348 
0349 //
0350 // member functions
0351 //
0352 
0353 // ------------ method called for each event  ------------
0354 void HLTObjectMonitor::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
0355   double start = get_wall_time();
0356 
0357   using namespace edm;
0358 
0359   if (debugPrint)
0360     std::cout << "Inside analyze(). " << std::endl;
0361 
0362   // access trigger results
0363   edm::Handle<edm::TriggerResults> triggerResults;
0364   iEvent.getByToken(triggerResultsToken_, triggerResults);
0365   if (!triggerResults.isValid())
0366     return;
0367 
0368   edm::Handle<trigger::TriggerEvent> aodTriggerEvent;
0369   iEvent.getByToken(aodTriggerToken_, aodTriggerEvent);
0370   if (!aodTriggerEvent.isValid())
0371     return;
0372 
0373   //reset everything to not accepted at beginning of each event
0374   unordered_map<string, bool> firedMap = acceptMap;
0375   for (auto plot : plotList)  //loop over paths
0376   {
0377     if (firedMap[plot->pathName])
0378       continue;
0379     bool triggerAccept = false;
0380     const TriggerObjectCollection objects = aodTriggerEvent->getObjects();
0381     edm::InputTag moduleFilter;
0382     std::string pathName;
0383     if (plot->pathIndex > 0 && triggerResults->accept(plot->pathIndex) && hltConfig_.saveTags(plot->moduleName)) {
0384       moduleFilter = edm::InputTag(plot->moduleName, "", processName_);
0385       pathName = plot->pathName;
0386       triggerAccept = true;
0387     } else if (plot->pathIndexOR > 0 && triggerResults->accept(plot->pathIndexOR) &&
0388                hltConfig_.saveTags(plot->moduleNameOR)) {
0389       if (firedMap[plot->pathNameOR])
0390         continue;
0391       moduleFilter = edm::InputTag(plot->moduleNameOR, "", processName_);
0392       pathName = plot->pathNameOR;
0393       triggerAccept = true;
0394     }
0395 
0396     if (triggerAccept) {
0397       unsigned int moduleFilterIndex = aodTriggerEvent->filterIndex(moduleFilter);
0398 
0399       if (moduleFilterIndex + 1 > aodTriggerEvent->sizeFilters())
0400         return;
0401       const Keys& keys = aodTriggerEvent->filterKeys(moduleFilterIndex);
0402 
0403       ////////////////////////////////
0404       ///
0405       /// single-object plots
0406       ///
0407       ////////////////////////////////
0408 
0409       //PFHT pt
0410       if (pathName == pfHtPt_.pathName) {
0411         for (const auto& key : keys)
0412           pfHtPt_.ME->Fill(objects[key].pt());
0413       }
0414 
0415       //jet pt
0416       else if (pathName == jetPt_.pathName) {
0417         for (const auto& key : keys)
0418           jetPt_.ME->Fill(objects[key].pt());
0419       }
0420 
0421       //photon pt + eta + phi (all use same path)
0422       else if (pathName == photonPt_.pathName) {
0423         for (const auto& key : keys) {
0424           photonPt_.ME->Fill(objects[key].pt());
0425           photonEta_.ME->Fill(objects[key].eta());
0426           photonPhi_.ME->Fill(objects[key].phi());
0427         }
0428       }
0429 
0430       //electron pt + eta + phi (all use same path)
0431       else if (pathName == electronPt_.pathName) {
0432         for (const auto& key : keys) {
0433           electronPt_.ME->Fill(objects[key].pt());
0434           electronEta_.ME->Fill(objects[key].eta());
0435           electronPhi_.ME->Fill(objects[key].phi());
0436         }
0437       }
0438 
0439       //muon pt + eta + phi (all use same path)
0440       else if (pathName == muonPt_.pathName) {
0441         for (const auto& key : keys) {
0442           muonPt_.ME->Fill(objects[key].pt());
0443           muonEta_.ME->Fill(objects[key].eta());
0444           muonPhi_.ME->Fill(objects[key].phi());
0445         }
0446       }
0447 
0448       //l2muon pt
0449       else if (pathName == l2muonPt_.pathName) {
0450         for (const auto& key : keys) {
0451           l2muonPt_.ME->Fill(objects[key].pt());
0452           l2muonEta_.ME->Fill(objects[key].eta());
0453           l2muonPhi_.ME->Fill(objects[key].phi());
0454         }
0455       }
0456 
0457       //l2NoBPTXmuon pt
0458       else if (pathName == l2NoBPTXmuonPt_.pathName) {
0459         for (const auto& key : keys) {
0460           l2NoBPTXmuonPt_.ME->Fill(objects[key].pt());
0461           l2NoBPTXmuonEta_.ME->Fill(objects[key].eta());
0462           l2NoBPTXmuonPhi_.ME->Fill(objects[key].phi());
0463         }
0464       }
0465 
0466       //Razor
0467       else if (pathName == mr_.pathName) {
0468         double onlineMR = 0, onlineRsq = 0;
0469         for (const auto& key : keys) {
0470           if (objects[key].id() == 0) {    //the MET object containing MR and Rsq will show up with ID = 0
0471             onlineMR = objects[key].px();  //razor variables stored in dummy reco::MET objects
0472             onlineRsq = objects[key].py();
0473           }
0474           mr_.ME->Fill(onlineMR);
0475           rsq_.ME->Fill(onlineRsq);
0476         }
0477       }
0478 
0479       //alphaT
0480       else if (pathName == alphaT_.pathName) {
0481         std::vector<ROOT::Math::LorentzVector<ROOT::Math::PtEtaPhiM4D<double>>> alphaT_jets;
0482         for (const auto& key : keys) {
0483           ROOT::Math::LorentzVector<ROOT::Math::PtEtaPhiM4D<double>> JetLVec(
0484               objects[key].pt(), objects[key].eta(), objects[key].phi(), objects[key].mass());
0485           alphaT_jets.push_back(JetLVec);
0486         }
0487 
0488         float alphaT = AlphaT(alphaT_jets, false).value();
0489         alphaT_.ME->Fill(alphaT);
0490       }
0491 
0492       //tau pt
0493       else if (pathName == tauPt_.pathName) {
0494         for (const auto& key : keys)
0495           tauPt_.ME->Fill(objects[key].pt());
0496       }
0497 
0498       //caloMET pt+phi
0499       else if (pathName == caloMetPt_.pathName) {
0500         for (const auto& key : keys) {
0501           caloMetPt_.ME->Fill(objects[key].pt());
0502           caloMetPhi_.ME->Fill(objects[key].phi());
0503         }
0504       }
0505 
0506       //caloHT pt
0507       else if (pathName == caloHtPt_.pathName) {
0508         for (const auto& key : keys) {
0509           if (objects[key].id() == 89)
0510             caloHtPt_.ME->Fill(objects[key].pt());
0511         }
0512       }
0513 
0514       //jetAK8 pt + mass
0515       else if (pathName == jetAK8Pt_.pathName) {
0516         for (const auto& key : keys) {
0517           jetAK8Pt_.ME->Fill(objects[key].pt());
0518           jetAK8Mass_.ME->Fill(objects[key].mass());
0519         }
0520       }
0521 
0522       //PFMET pt + phi
0523       else if (pathName == pfMetPt_.pathName) {
0524         for (const auto& key : keys) {
0525           pfMetPt_.ME->Fill(objects[key].pt());
0526           pfMetPhi_.ME->Fill(objects[key].phi());
0527         }
0528       }
0529 
0530       // bjet eta + phi
0531       else if (pathName == bJetEta_.pathName || pathName == bJetEta_.pathNameOR) {
0532         for (const auto& key : keys) {
0533           bJetEta_.ME->Fill(objects[key].eta());
0534           bJetPhi_.ME->Fill(objects[key].phi());
0535         }
0536       }
0537 
0538       //b-tagging CSV information
0539       if (pathName == bJetCSVPF_.pathName) {
0540         edm::Handle<reco::JetTagCollection> csvPfTags;
0541         iEvent.getByToken(csvPfTagsToken_, csvPfTags);
0542         edm::Handle<vector<reco::PFJet>> csvPfJets;
0543         iEvent.getByToken(csvPfJetsToken_, csvPfJets);
0544 
0545         if (csvPfTags.isValid() && csvPfJets.isValid()) {
0546           for (auto iter = csvPfTags->begin(); iter != csvPfTags->end(); iter++)
0547             bJetCSVPF_.ME->Fill(iter->second);
0548         }
0549       }
0550       if (pathName == bJetCSVCalo_.pathName) {
0551         edm::Handle<reco::JetTagCollection> csvCaloTags;
0552         iEvent.getByToken(csvCaloTagsToken_, csvCaloTags);
0553         edm::Handle<vector<reco::CaloJet>> csvCaloJets;
0554         iEvent.getByToken(csvCaloJetsToken_, csvCaloJets);
0555 
0556         if (csvCaloTags.isValid() && csvCaloJets.isValid()) {
0557           for (auto iter = csvCaloTags->begin(); iter != csvCaloTags->end(); iter++)
0558             bJetCSVCalo_.ME->Fill(iter->second);
0559         }
0560       }
0561 
0562       //muon dxy(use an unique path)
0563       else if (pathName == muonDxy_.pathName) {
0564         edm::Handle<vector<reco::RecoChargedCandidate>> recoChargedCands;
0565         iEvent.getByToken(chargedCandToken_, recoChargedCands);
0566         edm::Handle<reco::BeamSpot> recoBeamSpot;
0567         iEvent.getByToken(beamSpotToken_, recoBeamSpot);
0568         double muon_dxy, muon_dz;
0569 
0570         if (recoChargedCands.isValid() && recoBeamSpot.isValid()) {
0571           for (const auto& key : keys) {
0572             muon_dxy = dxyFinder(objects[key].eta(), objects[key].phi(), recoChargedCands, recoBeamSpot);
0573             if (muon_dxy != -99.) {
0574               muonDxy_.ME->Fill(muon_dxy);
0575             }
0576 
0577             muon_dz = dzFinder(objects[key].eta(), objects[key].phi(), recoChargedCands, recoBeamSpot);
0578             if (muon_dz != -99.) {
0579               muonDz_.ME->Fill(muon_dz);
0580             }
0581           }
0582         }
0583       }
0584 
0585       // ////////////////////////////////
0586       // ///
0587       // /// double-object plots
0588       // ///
0589       // ////////////////////////////////
0590 
0591       //double muon low mass
0592       else if (pathName == diMuonLowMass_.pathName) {
0593         const double mu_mass(.105658);
0594         unsigned int kCnt0 = 0;
0595         for (const auto& key0 : keys) {
0596           unsigned int kCnt1 = 0;
0597           for (const auto& key1 : keys) {
0598             if (key0 != key1 &&
0599                 kCnt1 > kCnt0)  // avoid filling hists with same objs && avoid double counting separate objs
0600             {
0601               if (abs(objects[key0].id()) == 13 &&
0602                   (objects[key0].id() + objects[key1].id() == 0))  // check muon id and dimuon charge
0603               {
0604                 TLorentzVector mu1, mu2, dimu;
0605                 mu1.SetPtEtaPhiM(objects[key0].pt(), objects[key0].eta(), objects[key0].phi(), mu_mass);
0606                 mu2.SetPtEtaPhiM(objects[key1].pt(), objects[key1].eta(), objects[key1].phi(), mu_mass);
0607                 dimu = mu1 + mu2;
0608                 diMuonLowMass_.ME->Fill(dimu.M());
0609               }
0610             }
0611             kCnt1 += 1;
0612           }
0613           kCnt0 += 1;
0614         }
0615       }  //end double object plot
0616 
0617       else if (pathName == diMuonMass_.pathName || pathName == diMuonMass_.pathNameOR) {
0618         const double mu_mass(.105658);
0619         unsigned int kCnt0 = 0;
0620         for (const auto& key0 : keys) {
0621           unsigned int kCnt1 = 0;
0622           for (const auto& key1 : keys) {
0623             if (key0 != key1 &&
0624                 kCnt1 > kCnt0)  // avoid filling hists with same objs && avoid double counting separate objs
0625             {
0626               if (abs(objects[key0].id()) == 13 &&
0627                   (objects[key0].id() + objects[key1].id() == 0))  // check muon id and dimuon charge
0628               {
0629                 TLorentzVector mu1, mu2, dimu;
0630                 mu1.SetPtEtaPhiM(objects[key0].pt(), objects[key0].eta(), objects[key0].phi(), mu_mass);
0631                 mu2.SetPtEtaPhiM(objects[key1].pt(), objects[key1].eta(), objects[key1].phi(), mu_mass);
0632                 dimu = mu1 + mu2;
0633                 diMuonMass_.ME->Fill(dimu.M());
0634               }
0635             }
0636             kCnt1 += 1;
0637           }
0638           kCnt0 += 1;
0639         }
0640       }
0641 
0642       else if (pathName == pAL1DoubleMuZMass_.pathName) {
0643         const double mu_mass(.105658);
0644         unsigned int kCnt0 = 0;
0645         for (const auto& key0 : keys) {
0646           unsigned int kCnt1 = 0;
0647           for (const auto& key1 : keys) {
0648             if (key0 != key1 &&
0649                 kCnt1 > kCnt0)  // avoid filling hists with same objs && avoid double counting separate objs
0650             {
0651               // if (abs(objects[key0].id()) == 13 && (objects[key0].id()+objects[key1].id()==0))  // id is not filled for l1 stage2 muons
0652               //  {
0653               TLorentzVector mu1, mu2, dimu;
0654               mu1.SetPtEtaPhiM(objects[key0].pt(), objects[key0].eta(), objects[key0].phi(), mu_mass);
0655               mu2.SetPtEtaPhiM(objects[key1].pt(), objects[key1].eta(), objects[key1].phi(), mu_mass);
0656               dimu = mu1 + mu2;
0657               if (dimu.M() > pAL1DoubleMuZMass_.xMin && dimu.M() < pAL1DoubleMuZMass_.xMax)
0658                 pAL1DoubleMuZMass_.ME->Fill(dimu.M());
0659               //  }
0660             }
0661             kCnt1 += 1;
0662           }
0663           kCnt0 += 1;
0664         }
0665       }
0666 
0667       else if (pathName == pAL2DoubleMuZMass_.pathName) {
0668         const double mu_mass(.105658);
0669         unsigned int kCnt0 = 0;
0670         for (const auto& key0 : keys) {
0671           unsigned int kCnt1 = 0;
0672           for (const auto& key1 : keys) {
0673             if (key0 != key1 &&
0674                 kCnt1 > kCnt0)  // avoid filling hists with same objs && avoid double counting separate objs
0675             {
0676               if (abs(objects[key0].id()) == 13 &&
0677                   (objects[key0].id() + objects[key1].id() == 0))  // check muon id and dimuon charge
0678               {
0679                 TLorentzVector mu1, mu2, dimu;
0680                 mu1.SetPtEtaPhiM(objects[key0].pt(), objects[key0].eta(), objects[key0].phi(), mu_mass);
0681                 mu2.SetPtEtaPhiM(objects[key1].pt(), objects[key1].eta(), objects[key1].phi(), mu_mass);
0682                 dimu = mu1 + mu2;
0683                 if (dimu.M() > pAL2DoubleMuZMass_.xMin && dimu.M() < pAL2DoubleMuZMass_.xMax)
0684                   pAL2DoubleMuZMass_.ME->Fill(dimu.M());
0685               }
0686             }
0687             kCnt1 += 1;
0688           }
0689           kCnt0 += 1;
0690         }
0691       }
0692 
0693       else if (pathName == pAL3DoubleMuZMass_.pathName) {
0694         const double mu_mass(.105658);
0695         unsigned int kCnt0 = 0;
0696         for (const auto& key0 : keys) {
0697           unsigned int kCnt1 = 0;
0698           for (const auto& key1 : keys) {
0699             if (key0 != key1 &&
0700                 kCnt1 > kCnt0)  // avoid filling hists with same objs && avoid double counting separate objs
0701             {
0702               if (abs(objects[key0].id()) == 13 &&
0703                   (objects[key0].id() + objects[key1].id() == 0))  // check muon id and dimuon charge
0704               {
0705                 TLorentzVector mu1, mu2, dimu;
0706                 mu1.SetPtEtaPhiM(objects[key0].pt(), objects[key0].eta(), objects[key0].phi(), mu_mass);
0707                 mu2.SetPtEtaPhiM(objects[key1].pt(), objects[key1].eta(), objects[key1].phi(), mu_mass);
0708                 dimu = mu1 + mu2;
0709                 if (dimu.M() > pAL3DoubleMuZMass_.xMin && dimu.M() < pAL3DoubleMuZMass_.xMax)
0710                   pAL3DoubleMuZMass_.ME->Fill(dimu.M());
0711               }
0712             }
0713             kCnt1 += 1;
0714           }
0715           kCnt0 += 1;
0716         }
0717       }
0718 
0719       else if (pathName == diElecMass_.pathName) {
0720         unsigned int kCnt0 = 0;
0721         for (const auto& key0 : keys) {
0722           unsigned int kCnt1 = 0;
0723           for (const auto& key1 : keys) {
0724             if (key0 != key1 &&
0725                 kCnt1 > kCnt0)  // avoid filling hists with same objs && avoid double counting separate objs
0726             {
0727               //                   if (abs(objects[key0].id()) == 11 && (objects[key0].id()+objects[key1].id()==0))  // id is not filled for electrons
0728               //                     {
0729               TLorentzVector el1, el2, diEl;
0730               el1.SetPtEtaPhiM(objects[key0].pt(), objects[key0].eta(), objects[key0].phi(), 0);
0731               el2.SetPtEtaPhiM(objects[key1].pt(), objects[key1].eta(), objects[key1].phi(), 0);
0732               diEl = el1 + el2;
0733               diElecMass_.ME->Fill(diEl.M());
0734               //                     }
0735             }
0736             kCnt1 += 1;
0737           }
0738           kCnt0 += 1;
0739         }
0740       }  //end double object plot
0741 
0742       firedMap[pathName] = true;
0743     }  //end if trigger accept
0744   }  //end loop over plots/paths
0745 
0746   //   sleep(1); //sleep for 1s, used to calibrate timing
0747   double end = get_wall_time();
0748   double wallTime = end - start;
0749   wallTime_.ME->Fill(wallTime);
0750 }
0751 
0752 // ------------ method called when starting to processes a run  ------------
0753 void HLTObjectMonitor::dqmBeginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {
0754   if (debugPrint)
0755     std::cout << "Calling beginRun. " << std::endl;
0756   bool changed = true;
0757   if (hltConfig_.init(iRun, iSetup, processName_, changed)) {
0758     if (debugPrint)
0759       std::cout << "Extracting HLTconfig. " << std::endl;
0760   }
0761 
0762   //get path indicies from menu
0763   string pathName_noVersion;
0764   vector<string> triggerPaths = hltConfig_.triggerNames();
0765 
0766   for (const auto& pathName : triggerPaths) {
0767     pathName_noVersion = hltConfig_.removeVersion(pathName);
0768     for (auto plot : plotList) {
0769       if (plot->pathName == pathName_noVersion) {
0770         (*plot).pathIndex = hltConfig_.triggerIndex(pathName);
0771       } else if (plot->pathNameOR == pathName_noVersion) {
0772         (*plot).pathIndexOR = hltConfig_.triggerIndex(pathName);
0773       }
0774     }
0775   }
0776   vector<hltPlot*> plotList_temp;
0777   for (auto plot : plotList) {
0778     if (plot->pathIndex > 0 || plot->pathIndexOR > 0) {
0779       plotList_temp.push_back(plot);
0780       acceptMap[plot->pathName] = false;
0781       if (plot->pathIndexOR > 0)
0782         acceptMap[plot->pathNameOR] = false;
0783     }
0784   }
0785   //now re-assign plotList to contain only the plots with paths in the menu.
0786   plotList = plotList_temp;
0787   plotList_temp.clear();
0788 }
0789 
0790 // ------------ method called when ending the processing of a run  ------------
0791 
0792 void HLTObjectMonitor::bookHistograms(DQMStore::IBooker& ibooker, edm::Run const& iRun, edm::EventSetup const& iSetup) {
0793   ////////////////////////////////
0794   ///
0795   /// Main shifter workspace plots
0796   ///
0797   ////////////////////////////////
0798 
0799   //book wall time separately
0800   ibooker.setCurrentFolder(mainShifterFolder);
0801   wallTime_.ME =
0802       ibooker.book1D(wallTime_.plotLabel, wallTime_.pathName, wallTime_.nBins, wallTime_.xMin, wallTime_.xMax);
0803   wallTime_.ME->setAxisTitle(wallTime_.xAxisLabel);
0804 
0805   for (auto plot : plotList) {
0806     std::string display_pathNames = plot->pathName;
0807     if (!plot->pathNameOR.empty())
0808       display_pathNames = plot->pathName + " OR " + plot->pathNameOR;
0809 
0810     if (plot->displayInPrimary) {
0811       ibooker.setCurrentFolder(mainShifterFolder);
0812       (*plot).ME = ibooker.book1D(plot->plotLabel, display_pathNames.c_str(), plot->nBins, plot->xMin, plot->xMax);
0813       (*plot).ME->setAxisTitle(plot->xAxisLabel);
0814       //need to add OR statement
0815     } else {
0816       ibooker.setCurrentFolder(backupFolder);
0817       (*plot).ME = ibooker.book1D(plot->plotLabel, display_pathNames.c_str(), plot->nBins, plot->xMin, plot->xMax);
0818       (*plot).ME->setAxisTitle(plot->xAxisLabel);
0819     }
0820   }
0821 }
0822 
0823 double HLTObjectMonitor::dxyFinder(double eta,
0824                                    double phi,
0825                                    edm::Handle<reco::RecoChargedCandidateCollection> recoChargedCands,
0826                                    edm::Handle<reco::BeamSpot> recoBeamSpot) {
0827   double dxy = -99.;
0828   for (reco::RecoChargedCandidateCollection::const_iterator l3Muon = recoChargedCands->begin();
0829        l3Muon != recoChargedCands->end();
0830        l3Muon++) {
0831     if (deltaR(eta, phi, l3Muon->eta(), l3Muon->phi()) < 0.1) {
0832       dxy = (-(l3Muon->vx() - recoBeamSpot->x0()) * l3Muon->py() + (l3Muon->vy() - recoBeamSpot->y0()) * l3Muon->px()) /
0833             l3Muon->pt();
0834       break;
0835     }
0836   }
0837   return dxy;
0838 }
0839 
0840 double HLTObjectMonitor::dzFinder(double eta,
0841                                   double phi,
0842                                   edm::Handle<reco::RecoChargedCandidateCollection> recoChargedCands,
0843                                   edm::Handle<reco::BeamSpot> recoBeamSpot) {
0844   double dz = -99.;
0845   for (reco::RecoChargedCandidateCollection::const_iterator l3Muon = recoChargedCands->begin();
0846        l3Muon != recoChargedCands->end();
0847        l3Muon++) {
0848     if (deltaR(eta, phi, l3Muon->eta(), l3Muon->phi()) < 0.1) {
0849       dz = (l3Muon->vz() - recoBeamSpot->z0()) -
0850            ((l3Muon->vx() - recoBeamSpot->x0()) * l3Muon->px() + (l3Muon->vy() - recoBeamSpot->y0()) * l3Muon->py()) /
0851                l3Muon->pt() * (l3Muon->pz() / l3Muon->pt());
0852       break;
0853     }
0854   }
0855   return dz;
0856 }
0857 
0858 double HLTObjectMonitor::get_wall_time() {
0859   struct timeval time;
0860   if (gettimeofday(&time, nullptr))
0861     return 0;
0862   return (double)time.tv_sec + (double)time.tv_usec * .000001;
0863 }
0864 
0865 // ------------ method fills 'descriptions' with the allowed parameters for the module  ------------
0866 void HLTObjectMonitor::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0867   edm::ParameterSetDescription desc;
0868   desc.add<std::string>("processName", "HLT");
0869 
0870   auto addPSet = [](edm::ParameterSetDescription& desc, const std::string& name) {
0871     edm::ParameterSetDescription pset;
0872     pset.add<std::string>("pathName", "");
0873     pset.add<std::string>("moduleName", "");
0874     pset.addOptional<std::string>("pathName_OR");
0875     pset.addOptional<std::string>("moduleName_OR");
0876     pset.add<std::string>("plotLabel", "");
0877     pset.add<std::string>("axisLabel", "");
0878     pset.add<bool>("mainWorkspace", false);
0879     pset.add<int>("NbinsX", 50);
0880     pset.add<double>("Xmin", 0.0);
0881     pset.add<double>("Xmax", 1.0);
0882     desc.add<edm::ParameterSetDescription>(name, pset);
0883   };
0884 
0885   addPSet(desc, "alphaT");
0886   addPSet(desc, "photonPt");
0887   addPSet(desc, "photonEta");
0888   addPSet(desc, "photonPhi");
0889   addPSet(desc, "muonPt");
0890   addPSet(desc, "muonEta");
0891   addPSet(desc, "muonPhi");
0892   addPSet(desc, "l2muonPt");
0893   addPSet(desc, "l2muonEta");
0894   addPSet(desc, "l2muonPhi");
0895   addPSet(desc, "l2NoBPTXmuonPt");
0896   addPSet(desc, "l2NoBPTXmuonEta");
0897   addPSet(desc, "l2NoBPTXmuonPhi");
0898   addPSet(desc, "electronPt");
0899   addPSet(desc, "electronEta");
0900   addPSet(desc, "electronPhi");
0901   addPSet(desc, "jetPt");
0902   addPSet(desc, "jetAK8Pt");
0903   addPSet(desc, "jetAK8Mass");
0904   addPSet(desc, "tauPt");
0905   addPSet(desc, "diMuonLowMass");
0906   addPSet(desc, "caloMetPt");
0907   addPSet(desc, "caloMetPhi");
0908   addPSet(desc, "pfMetPt");
0909   addPSet(desc, "pfMetPhi");
0910   addPSet(desc, "caloHtPt");
0911   addPSet(desc, "pfHtPt");
0912   addPSet(desc, "bJetEta");
0913   addPSet(desc, "bJetPhi");
0914   addPSet(desc, "bJetCSVCalo");
0915   addPSet(desc, "bJetCSVPF");
0916   addPSet(desc, "rsq");
0917   addPSet(desc, "mr");
0918   addPSet(desc, "diMuonMass");
0919   addPSet(desc, "pAL1DoubleMuZMass");
0920   addPSet(desc, "pAL2DoubleMuZMass");
0921   addPSet(desc, "pAL3DoubleMuZMass");
0922   addPSet(desc, "diElecMass");
0923   addPSet(desc, "muonDxy");
0924   addPSet(desc, "muonDz");
0925   addPSet(desc, "wallTime");
0926   descriptions.addWithDefaultLabel(desc);
0927 }
0928 
0929 //define this as a plug-in
0930 DEFINE_FWK_MODULE(HLTObjectMonitor);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!