Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2024-09-07 04:36:02 

0001 // -*- C++ -*-
0002 //
0003 // Package:    QM/HLTObjectMonitorProtonLead
0004 // Class:      HLTObjectMonitorProtonLead
0005 //
0006 /**\class HLTObjectMonitorProtonLead HLTObjectMonitorProtonLead.cc DQM/HLTEvF/plugins/HLTObjectMonitorProtonLead.cc 
0007 
0008  Description: [one line class summary]
0009 
0010  Implementation:
0011      [Notes on implementation]
0012 */
0013 //
0014 // Original Author:  Varun Sharma
0015 //         Created:  Fri, 21 Oct 2016 12: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 
0030 #include "FWCore/Framework/interface/Frameworkfwd.h"
0031 #include "FWCore/Framework/interface/Event.h"
0032 #include "FWCore/Framework/interface/MakerMacros.h"
0033 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0034 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0035 
0036 #include "HLTrigger/HLTcore/interface/HLTConfigProvider.h"
0037 
0038 //for collections
0039 #include "HLTrigger/JetMET/interface/AlphaT.h"
0040 #include "DataFormats/BeamSpot/interface/BeamSpot.h"
0041 #include "DataFormats/METReco/interface/MET.h"
0042 #include "DataFormats/RecoCandidate/interface/RecoChargedCandidate.h"
0043 #include "DataFormats/BTauReco/interface/JetTag.h"
0044 #include "DataFormats/RecoCandidate/interface/RecoChargedCandidateFwd.h"
0045 #include "DataFormats/Math/interface/deltaR.h"
0046 #include "DataFormats/JetReco/interface/PFJet.h"
0047 #include "DataFormats/JetReco/interface/CaloJet.h"
0048 
0049 #include "DQMServices/Core/interface/DQMStore.h"
0050 #include "DQMServices/Core/interface/DQMEDAnalyzer.h"
0051 
0052 #include "TMath.h"
0053 #include "TStyle.h"
0054 #include "TLorentzVector.h"
0055 
0056 #include <unordered_map>
0057 //
0058 // class declaration
0059 //
0060 
0061 //using namespace edm;
0062 using namespace trigger;
0063 using std::string;
0064 using std::unordered_map;
0065 using std::vector;
0066 
0067 class HLTObjectMonitorProtonLead : public DQMEDAnalyzer {
0068   struct hltPlot {
0069     MonitorElement* ME;
0070     string pathName;
0071     string pathNameOR;
0072     string moduleName;
0073     string moduleNameOR;
0074     int pathIndex = -99;
0075     int pathIndexOR = -99;
0076     string plotLabel;
0077     string xAxisLabel;
0078     int nBins;
0079     double xMin;
0080     double xMax;
0081     bool displayInPrimary;
0082   };
0083 
0084 public:
0085   explicit HLTObjectMonitorProtonLead(const edm::ParameterSet&);
0086 
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 get_wall_time(void);
0095   // ----------member data ---------------------------
0096 
0097   bool debugPrint;
0098   HLTConfigProvider hltConfig_;
0099   string topDirectoryName;
0100   string mainShifterFolder;
0101   string backupFolder;
0102   unordered_map<string, bool> acceptMap;
0103   unordered_map<hltPlot*, edm::ParameterSet*> plotMap;
0104 
0105   //set Token(-s)
0106   edm::EDGetTokenT<edm::TriggerResults> triggerResultsToken_;
0107   edm::EDGetTokenT<trigger::TriggerEvent> aodTriggerToken_;
0108 
0109   //declare params
0110   //pPb run
0111   edm::ParameterSet caloAK4JetPt_pset;
0112   edm::ParameterSet caloAK4JetEta_pset;
0113   edm::ParameterSet caloAK4JetPhi_pset;
0114   edm::ParameterSet pfAK4JetPt_pset;
0115   edm::ParameterSet pfAK4JetEta_pset;
0116   edm::ParameterSet pfAK4JetPhi_pset;
0117   edm::ParameterSet caloDiAK4JetPt_pset;
0118   edm::ParameterSet caloDiAK4JetEta_pset;
0119   edm::ParameterSet caloDiAK4JetPhi_pset;
0120   edm::ParameterSet pfDiAK4JetPt_pset;
0121   edm::ParameterSet pfDiAK4JetEta_pset;
0122   edm::ParameterSet pfDiAK4JetPhi_pset;
0123   edm::ParameterSet photonPt_pset;
0124   edm::ParameterSet photonEta_pset;
0125   edm::ParameterSet photonPhi_pset;
0126   edm::ParameterSet photonPPPt_pset;
0127   edm::ParameterSet photonPPEta_pset;
0128   edm::ParameterSet photonPPPhi_pset;
0129   edm::ParameterSet caloBJetPt_pset;
0130   edm::ParameterSet caloBJetEta_pset;
0131   edm::ParameterSet caloBJetPhi_pset;
0132   edm::ParameterSet pfBJetPt_pset;
0133   edm::ParameterSet pfBJetEta_pset;
0134   edm::ParameterSet pfBJetPhi_pset;
0135   edm::ParameterSet electronPt_pset;
0136   edm::ParameterSet electronEta_pset;
0137   edm::ParameterSet electronPhi_pset;
0138   edm::ParameterSet l3muon3Pt_pset;
0139   edm::ParameterSet l3muon3Eta_pset;
0140   edm::ParameterSet l3muon3Phi_pset;
0141   edm::ParameterSet l2muon12Pt_pset;
0142   edm::ParameterSet l2muon12Eta_pset;
0143   edm::ParameterSet l2muon12Phi_pset;
0144   edm::ParameterSet l3muon12Pt_pset;
0145   edm::ParameterSet l3muon12Eta_pset;
0146   edm::ParameterSet l3muon12Phi_pset;
0147   edm::ParameterSet pAL1DoubleMuZMass_pset;
0148   edm::ParameterSet pAL2DoubleMuZMass_pset;
0149   edm::ParameterSet pAL3DoubleMuZMass_pset;
0150   edm::ParameterSet wallTime_pset;
0151 
0152   string processName_;
0153 
0154   hltPlot caloAK4JetPt_;
0155   hltPlot caloAK4JetEta_;
0156   hltPlot caloAK4JetPhi_;
0157   hltPlot pfAK4JetPt_;
0158   hltPlot pfAK4JetEta_;
0159   hltPlot pfAK4JetPhi_;
0160   hltPlot caloDiAK4JetPt_;
0161   hltPlot caloDiAK4JetEta_;
0162   hltPlot caloDiAK4JetPhi_;
0163   hltPlot pfDiAK4JetPt_;
0164   hltPlot pfDiAK4JetEta_;
0165   hltPlot pfDiAK4JetPhi_;
0166   hltPlot photonPt_;
0167   hltPlot photonEta_;
0168   hltPlot photonPhi_;
0169   hltPlot photonPPPt_;
0170   hltPlot photonPPEta_;
0171   hltPlot photonPPPhi_;
0172   hltPlot caloBJetPt_;
0173   hltPlot caloBJetEta_;
0174   hltPlot caloBJetPhi_;
0175   hltPlot pfBJetPt_;
0176   hltPlot pfBJetEta_;
0177   hltPlot pfBJetPhi_;
0178   hltPlot electronPt_;
0179   hltPlot electronEta_;
0180   hltPlot electronPhi_;
0181   hltPlot l3muon3Pt_;
0182   hltPlot l3muon3Eta_;
0183   hltPlot l3muon3Phi_;
0184   hltPlot l2muon12Pt_;
0185   hltPlot l2muon12Eta_;
0186   hltPlot l2muon12Phi_;
0187   hltPlot l3muon12Pt_;
0188   hltPlot l3muon12Eta_;
0189   hltPlot l3muon12Phi_;
0190   hltPlot pAL1DoubleMuZMass_;
0191   hltPlot pAL2DoubleMuZMass_;
0192   hltPlot pAL3DoubleMuZMass_;
0193   hltPlot wallTime_;
0194 };
0195 
0196 //
0197 // constants, enums and typedefs
0198 //
0199 
0200 //
0201 // static data member definitions
0202 //
0203 
0204 //
0205 // constructors and destructor
0206 //
0207 HLTObjectMonitorProtonLead::HLTObjectMonitorProtonLead(const edm::ParameterSet& iConfig)
0208 
0209 {
0210   //now do what ever initialization is needed
0211   debugPrint = false;
0212 
0213   topDirectoryName = "HLT/ObjectMonitor";
0214   mainShifterFolder = topDirectoryName + "/MainShifter";
0215   backupFolder = topDirectoryName + "/Backup";
0216 
0217   //parse params
0218   processName_ = iConfig.getParameter<string>("processName");
0219 
0220   caloAK4JetPt_pset = iConfig.getParameter<edm::ParameterSet>("caloAK4JetPt");
0221   plotMap[&caloAK4JetPt_] = &caloAK4JetPt_pset;
0222   caloAK4JetEta_pset = iConfig.getParameter<edm::ParameterSet>("caloAK4JetEta");
0223   plotMap[&caloAK4JetEta_] = &caloAK4JetEta_pset;
0224   caloAK4JetPhi_pset = iConfig.getParameter<edm::ParameterSet>("caloAK4JetPhi");
0225   plotMap[&caloAK4JetPhi_] = &caloAK4JetPhi_pset;
0226   pfAK4JetPt_pset = iConfig.getParameter<edm::ParameterSet>("pfAK4JetPt");
0227   plotMap[&pfAK4JetPt_] = &pfAK4JetPt_pset;
0228   pfAK4JetEta_pset = iConfig.getParameter<edm::ParameterSet>("pfAK4JetEta");
0229   plotMap[&pfAK4JetEta_] = &pfAK4JetEta_pset;
0230   pfAK4JetPhi_pset = iConfig.getParameter<edm::ParameterSet>("pfAK4JetPhi");
0231   plotMap[&pfAK4JetPhi_] = &pfAK4JetPhi_pset;
0232   caloDiAK4JetPt_pset = iConfig.getParameter<edm::ParameterSet>("caloDiAK4JetPt");
0233   plotMap[&caloDiAK4JetPt_] = &caloDiAK4JetPt_pset;
0234   caloDiAK4JetEta_pset = iConfig.getParameter<edm::ParameterSet>("caloDiAK4JetEta");
0235   plotMap[&caloDiAK4JetEta_] = &caloDiAK4JetEta_pset;
0236   caloDiAK4JetPhi_pset = iConfig.getParameter<edm::ParameterSet>("caloDiAK4JetPhi");
0237   plotMap[&caloDiAK4JetPhi_] = &caloDiAK4JetPhi_pset;
0238   pfDiAK4JetPt_pset = iConfig.getParameter<edm::ParameterSet>("pfDiAK4JetPt");
0239   plotMap[&pfDiAK4JetPt_] = &pfDiAK4JetPt_pset;
0240   pfDiAK4JetEta_pset = iConfig.getParameter<edm::ParameterSet>("pfDiAK4JetEta");
0241   plotMap[&pfDiAK4JetEta_] = &pfDiAK4JetEta_pset;
0242   pfDiAK4JetPhi_pset = iConfig.getParameter<edm::ParameterSet>("pfDiAK4JetPhi");
0243   plotMap[&pfDiAK4JetPhi_] = &pfDiAK4JetPhi_pset;
0244   photonPt_pset = iConfig.getParameter<edm::ParameterSet>("photonPt");
0245   plotMap[&photonPt_] = &photonPt_pset;
0246   photonEta_pset = iConfig.getParameter<edm::ParameterSet>("photonEta");
0247   plotMap[&photonEta_] = &photonEta_pset;
0248   photonPhi_pset = iConfig.getParameter<edm::ParameterSet>("photonPhi");
0249   plotMap[&photonPhi_] = &photonPhi_pset;
0250   photonPPPt_pset = iConfig.getParameter<edm::ParameterSet>("photonPPPt");
0251   plotMap[&photonPPPt_] = &photonPPPt_pset;
0252   photonPPEta_pset = iConfig.getParameter<edm::ParameterSet>("photonPPEta");
0253   plotMap[&photonPPEta_] = &photonPPEta_pset;
0254   photonPPPhi_pset = iConfig.getParameter<edm::ParameterSet>("photonPPPhi");
0255   plotMap[&photonPPPhi_] = &photonPPPhi_pset;
0256   caloBJetPt_pset = iConfig.getParameter<edm::ParameterSet>("caloBJetPt");
0257   plotMap[&caloBJetPt_] = &caloBJetPt_pset;
0258   caloBJetEta_pset = iConfig.getParameter<edm::ParameterSet>("caloBJetEta");
0259   plotMap[&caloBJetEta_] = &caloBJetEta_pset;
0260   caloBJetPhi_pset = iConfig.getParameter<edm::ParameterSet>("caloBJetPhi");
0261   plotMap[&caloBJetPhi_] = &caloBJetPhi_pset;
0262   pfBJetPt_pset = iConfig.getParameter<edm::ParameterSet>("pfBJetPt");
0263   plotMap[&pfBJetPt_] = &pfBJetPt_pset;
0264   pfBJetEta_pset = iConfig.getParameter<edm::ParameterSet>("pfBJetEta");
0265   plotMap[&pfBJetEta_] = &pfBJetEta_pset;
0266   pfBJetPhi_pset = iConfig.getParameter<edm::ParameterSet>("pfBJetPhi");
0267   plotMap[&pfBJetPhi_] = &pfBJetPhi_pset;
0268   electronPt_pset = iConfig.getParameter<edm::ParameterSet>("electronPt");
0269   plotMap[&electronPt_] = &electronPt_pset;
0270   electronEta_pset = iConfig.getParameter<edm::ParameterSet>("electronEta");
0271   plotMap[&electronEta_] = &electronEta_pset;
0272   electronPhi_pset = iConfig.getParameter<edm::ParameterSet>("electronPhi");
0273   plotMap[&electronPhi_] = &electronPhi_pset;
0274   l3muon3Pt_pset = iConfig.getParameter<edm::ParameterSet>("l3muon3Pt");
0275   plotMap[&l3muon3Pt_] = &l3muon3Pt_pset;
0276   l3muon3Eta_pset = iConfig.getParameter<edm::ParameterSet>("l3muon3Eta");
0277   plotMap[&l3muon3Eta_] = &l3muon3Eta_pset;
0278   l3muon3Phi_pset = iConfig.getParameter<edm::ParameterSet>("l3muon3Phi");
0279   plotMap[&l3muon3Phi_] = &l3muon3Phi_pset;
0280   l2muon12Pt_pset = iConfig.getParameter<edm::ParameterSet>("l2muon12Pt");
0281   plotMap[&l2muon12Pt_] = &l2muon12Pt_pset;
0282   l2muon12Eta_pset = iConfig.getParameter<edm::ParameterSet>("l2muon12Eta");
0283   plotMap[&l2muon12Eta_] = &l2muon12Eta_pset;
0284   l2muon12Phi_pset = iConfig.getParameter<edm::ParameterSet>("l2muon12Phi");
0285   plotMap[&l2muon12Phi_] = &l2muon12Phi_pset;
0286   l3muon12Pt_pset = iConfig.getParameter<edm::ParameterSet>("l3muon12Pt");
0287   plotMap[&l3muon12Pt_] = &l3muon12Pt_pset;
0288   l3muon12Eta_pset = iConfig.getParameter<edm::ParameterSet>("l3muon12Eta");
0289   plotMap[&l3muon12Eta_] = &l3muon12Eta_pset;
0290   l3muon12Phi_pset = iConfig.getParameter<edm::ParameterSet>("l3muon12Phi");
0291   plotMap[&l3muon12Phi_] = &l3muon12Phi_pset;
0292   pAL1DoubleMuZMass_pset = iConfig.getParameter<edm::ParameterSet>("pAL1DoubleMuZMass");
0293   plotMap[&pAL1DoubleMuZMass_] = &pAL1DoubleMuZMass_pset;
0294   pAL2DoubleMuZMass_pset = iConfig.getParameter<edm::ParameterSet>("pAL2DoubleMuZMass");
0295   plotMap[&pAL2DoubleMuZMass_] = &pAL2DoubleMuZMass_pset;
0296   pAL3DoubleMuZMass_pset = iConfig.getParameter<edm::ParameterSet>("pAL3DoubleMuZMass");
0297   plotMap[&pAL3DoubleMuZMass_] = &pAL3DoubleMuZMass_pset;
0298   wallTime_pset = iConfig.getParameter<edm::ParameterSet>("wallTime");
0299   plotMap[&wallTime_] = &wallTime_pset;
0300 
0301   for (auto item = plotMap.begin(); item != plotMap.end(); item++) {
0302     (*item->first).pathName = (*item->second).getParameter<string>("pathName");
0303     (*item->first).moduleName = (*item->second).getParameter<string>("moduleName");
0304     (*item->first).nBins = (*item->second).getParameter<int>("NbinsX");
0305     (*item->first).xMin = (*item->second).getParameter<double>("Xmin");
0306     (*item->first).xMax = (*item->second).getParameter<double>("Xmax");
0307     (*item->first).xAxisLabel = (*item->second).getParameter<string>("axisLabel");
0308     (*item->first).plotLabel = (*item->second).getParameter<string>("plotLabel");
0309     (*item->first).displayInPrimary = (*item->second).getParameter<bool>("mainWorkspace");
0310 
0311     if ((*item->second).exists("pathName_OR")) {
0312       (*item->first).pathNameOR = (*item->second).getParameter<string>("pathName_OR");
0313     }
0314     if ((*item->second).exists("moduleName_OR")) {
0315       (*item->first).moduleNameOR = (*item->second).getParameter<string>("moduleName_OR");
0316     }
0317 
0318     plotList.push_back(item->first);
0319   }
0320   plotMap.clear();
0321 
0322   //set Token(s)
0323   triggerResultsToken_ = consumes<edm::TriggerResults>(iConfig.getParameter<edm::InputTag>("triggerResults"));
0324   aodTriggerToken_ = consumes<trigger::TriggerEvent>(iConfig.getParameter<edm::InputTag>("triggerEvent"));
0325 }
0326 
0327 //
0328 // member functions
0329 //
0330 
0331 // ------------ method called for each event  ------------
0332 void HLTObjectMonitorProtonLead::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
0333   double start = get_wall_time();
0334 
0335   using namespace edm;
0336 
0337   if (debugPrint)
0338     std::cout << "Inside analyze(). " << std::endl;
0339 
0340   // access trigger results
0341   edm::Handle<edm::TriggerResults> triggerResults;
0342   iEvent.getByToken(triggerResultsToken_, triggerResults);
0343   if (!triggerResults.isValid())
0344     return;
0345 
0346   edm::Handle<trigger::TriggerEvent> aodTriggerEvent;
0347   iEvent.getByToken(aodTriggerToken_, aodTriggerEvent);
0348   if (!aodTriggerEvent.isValid())
0349     return;
0350 
0351   //reset everything to not accepted at beginning of each event
0352   unordered_map<string, bool> firedMap = acceptMap;
0353   for (auto plot : plotList)  //loop over paths
0354   {
0355     if (firedMap[plot->pathName])
0356       continue;
0357     bool triggerAccept = false;
0358     const TriggerObjectCollection objects = aodTriggerEvent->getObjects();
0359     edm::InputTag moduleFilter;
0360     std::string pathName;
0361     if (plot->pathIndex > 0 && triggerResults->accept(plot->pathIndex) && hltConfig_.saveTags(plot->moduleName)) {
0362       moduleFilter = edm::InputTag(plot->moduleName, "", processName_);
0363       pathName = plot->pathName;
0364       triggerAccept = true;
0365     } else if (plot->pathIndexOR > 0 && triggerResults->accept(plot->pathIndexOR) &&
0366                hltConfig_.saveTags(plot->moduleNameOR)) {
0367       if (firedMap[plot->pathNameOR])
0368         continue;
0369       moduleFilter = edm::InputTag(plot->moduleNameOR, "", processName_);
0370       pathName = plot->pathNameOR;
0371       triggerAccept = true;
0372     }
0373 
0374     if (triggerAccept) {
0375       unsigned int moduleFilterIndex = aodTriggerEvent->filterIndex(moduleFilter);
0376 
0377       if (moduleFilterIndex + 1 > aodTriggerEvent->sizeFilters())
0378         return;
0379       const Keys& keys = aodTriggerEvent->filterKeys(moduleFilterIndex);
0380 
0381       ////////////////////////////////
0382       ///
0383       /// single-object plots
0384       ///
0385       ////////////////////////////////
0386 
0387       //calo AK4 jet pt + eta + phi
0388       if (pathName == caloAK4JetPt_.pathName) {
0389         for (const auto& key : keys) {
0390           caloAK4JetPt_.ME->Fill(objects[key].pt());
0391           caloAK4JetEta_.ME->Fill(objects[key].eta());
0392           caloAK4JetPhi_.ME->Fill(objects[key].phi());
0393         }
0394       }
0395       //pf AK4 jet pt + eta + phi
0396       else if (pathName == pfAK4JetPt_.pathName) {
0397         for (const auto& key : keys) {
0398           pfAK4JetPt_.ME->Fill(objects[key].pt());
0399           pfAK4JetEta_.ME->Fill(objects[key].eta());
0400           pfAK4JetPhi_.ME->Fill(objects[key].phi());
0401         }
0402       }
0403       //calo AK4 di jet pt + eta + phi
0404       else if (pathName == caloDiAK4JetPt_.pathName) {
0405         for (const auto& key : keys) {
0406           caloDiAK4JetPt_.ME->Fill(objects[key].pt());
0407           caloDiAK4JetEta_.ME->Fill(objects[key].eta());
0408           caloDiAK4JetPhi_.ME->Fill(objects[key].phi());
0409         }
0410       }
0411       //pf AK4 di jet pt + eta + phi
0412       else if (pathName == pfDiAK4JetPt_.pathName) {
0413         for (const auto& key : keys) {
0414           pfDiAK4JetPt_.ME->Fill(objects[key].pt());
0415           pfDiAK4JetEta_.ME->Fill(objects[key].eta());
0416           pfDiAK4JetPhi_.ME->Fill(objects[key].phi());
0417         }
0418       }
0419       //photon pt + eta + phi
0420       else if (pathName == photonPt_.pathName) {
0421         for (const auto& key : keys) {
0422           photonPt_.ME->Fill(objects[key].pt());
0423           photonEta_.ME->Fill(objects[key].eta());
0424           photonPhi_.ME->Fill(objects[key].phi());
0425         }
0426       }
0427       //photon PPStyle pt + eta + phi
0428       else if (pathName == photonPPPt_.pathName) {
0429         for (const auto& key : keys) {
0430           photonPPPt_.ME->Fill(objects[key].pt());
0431           photonPPEta_.ME->Fill(objects[key].eta());
0432           photonPPPhi_.ME->Fill(objects[key].phi());
0433         }
0434       }
0435       //calo Bjet pt + eta + phi
0436       else if (pathName == caloBJetPt_.pathName) {
0437         for (const auto& key : keys) {
0438           caloBJetPt_.ME->Fill(objects[key].pt());
0439           caloBJetEta_.ME->Fill(objects[key].eta());
0440           caloBJetPhi_.ME->Fill(objects[key].phi());
0441         }
0442       }
0443       //PF Bjet pt + eta + phi
0444       else if (pathName == pfBJetPt_.pathName) {
0445         for (const auto& key : keys) {
0446           pfBJetPt_.ME->Fill(objects[key].pt());
0447           pfBJetEta_.ME->Fill(objects[key].eta());
0448           pfBJetPhi_.ME->Fill(objects[key].phi());
0449         }
0450       }
0451       //electron pt + eta + phi
0452       else if (pathName == electronPt_.pathName) {
0453         for (const auto& key : keys) {
0454           electronPt_.ME->Fill(objects[key].pt());
0455           electronEta_.ME->Fill(objects[key].eta());
0456           electronPhi_.ME->Fill(objects[key].phi());
0457         }
0458       } else if (pathName == l3muon3Pt_.pathName) {
0459         for (const auto& key : keys) {
0460           l3muon3Pt_.ME->Fill(objects[key].pt());
0461           l3muon3Eta_.ME->Fill(objects[key].eta());
0462           l3muon3Phi_.ME->Fill(objects[key].phi());
0463         }
0464       } else if (pathName == l2muon12Pt_.pathName) {
0465         for (const auto& key : keys) {
0466           l2muon12Pt_.ME->Fill(objects[key].pt());
0467           l2muon12Eta_.ME->Fill(objects[key].eta());
0468           l2muon12Phi_.ME->Fill(objects[key].phi());
0469         }
0470       } else if (pathName == l3muon12Pt_.pathName) {
0471         for (const auto& key : keys) {
0472           l3muon12Pt_.ME->Fill(objects[key].pt());
0473           l3muon12Eta_.ME->Fill(objects[key].eta());
0474           l3muon12Phi_.ME->Fill(objects[key].phi());
0475         }
0476       }
0477 
0478       // ////////////////////////////////
0479       // ///
0480       // /// double-object plots
0481       // ///
0482       // ////////////////////////////////
0483 
0484       else if (pathName == pAL1DoubleMuZMass_.pathName) {
0485         const double mu_mass(.105658);
0486         unsigned int kCnt0 = 0;
0487         for (const auto& key0 : keys) {
0488           unsigned int kCnt1 = 0;
0489           for (const auto& key1 : keys) {
0490             if (key0 != key1 &&
0491                 kCnt1 > kCnt0) {  // avoid filling hists with same objs && avoid double counting separate objs
0492               // if (abs(objects[key0].id()) == 13 && (objects[key0].id()+objects[key1].id()==0))  // id is not filled for l1 stage2 muons
0493               TLorentzVector mu1, mu2, dimu;
0494               mu1.SetPtEtaPhiM(objects[key0].pt(), objects[key0].eta(), objects[key0].phi(), mu_mass);
0495               mu2.SetPtEtaPhiM(objects[key1].pt(), objects[key1].eta(), objects[key1].phi(), mu_mass);
0496               dimu = mu1 + mu2;
0497               if (dimu.M() > pAL1DoubleMuZMass_.xMin && dimu.M() < pAL1DoubleMuZMass_.xMax)
0498                 pAL1DoubleMuZMass_.ME->Fill(dimu.M());
0499             }
0500             kCnt1 += 1;
0501           }
0502           kCnt0 += 1;
0503         }
0504       } else if (pathName == pAL2DoubleMuZMass_.pathName) {
0505         const double mu_mass(.105658);
0506         unsigned int kCnt0 = 0;
0507         for (const auto& key0 : keys) {
0508           unsigned int kCnt1 = 0;
0509           for (const auto& key1 : keys) {
0510             if (key0 != key1 &&
0511                 kCnt1 > kCnt0) {  // avoid filling hists with same objs && avoid double counting separate objs
0512               if (abs(objects[key0].id()) == 13 &&
0513                   (objects[key0].id() + objects[key1].id() == 0)) {  // check muon id and dimuon charge
0514                 TLorentzVector mu1, mu2, dimu;
0515                 mu1.SetPtEtaPhiM(objects[key0].pt(), objects[key0].eta(), objects[key0].phi(), mu_mass);
0516                 mu2.SetPtEtaPhiM(objects[key1].pt(), objects[key1].eta(), objects[key1].phi(), mu_mass);
0517                 dimu = mu1 + mu2;
0518                 if (dimu.M() > pAL2DoubleMuZMass_.xMin && dimu.M() < pAL2DoubleMuZMass_.xMax)
0519                   pAL2DoubleMuZMass_.ME->Fill(dimu.M());
0520               }
0521             }
0522             kCnt1 += 1;
0523           }
0524           kCnt0 += 1;
0525         }
0526       } else if (pathName == pAL3DoubleMuZMass_.pathName) {
0527         const double mu_mass(.105658);
0528         unsigned int kCnt0 = 0;
0529         for (const auto& key0 : keys) {
0530           unsigned int kCnt1 = 0;
0531           for (const auto& key1 : keys) {
0532             if (key0 != key1 &&
0533                 kCnt1 > kCnt0) {  // avoid filling hists with same objs && avoid double counting separate objs
0534               if (abs(objects[key0].id()) == 13 &&
0535                   (objects[key0].id() + objects[key1].id() == 0)) {  // check muon id and dimuon charge
0536                 TLorentzVector mu1, mu2, dimu;
0537                 mu1.SetPtEtaPhiM(objects[key0].pt(), objects[key0].eta(), objects[key0].phi(), mu_mass);
0538                 mu2.SetPtEtaPhiM(objects[key1].pt(), objects[key1].eta(), objects[key1].phi(), mu_mass);
0539                 dimu = mu1 + mu2;
0540                 if (dimu.M() > pAL3DoubleMuZMass_.xMin && dimu.M() < pAL3DoubleMuZMass_.xMax)
0541                   pAL3DoubleMuZMass_.ME->Fill(dimu.M());
0542               }
0543             }
0544             kCnt1 += 1;
0545           }
0546           kCnt0 += 1;
0547         }
0548       }
0549 
0550       firedMap[pathName] = true;
0551     }  //end if trigger accept
0552   }  //end loop over plots/paths
0553 
0554   //   sleep(1); //sleep for 1s, used to calibrate timing
0555   double end = get_wall_time();
0556   double wallTime = end - start;
0557   wallTime_.ME->Fill(wallTime);
0558 }
0559 
0560 // ------------ method called when starting to processes a run  ------------
0561 void HLTObjectMonitorProtonLead::dqmBeginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {
0562   if (debugPrint)
0563     std::cout << "Calling beginRun. " << std::endl;
0564   bool changed = true;
0565   if (hltConfig_.init(iRun, iSetup, processName_, changed)) {
0566     if (debugPrint)
0567       std::cout << "Extracting HLTconfig. " << std::endl;
0568   }
0569 
0570   //get path indicies from menu
0571   string pathName_noVersion;
0572   vector<string> triggerPaths = hltConfig_.triggerNames();
0573 
0574   for (const auto& pathName : triggerPaths) {
0575     pathName_noVersion = hltConfig_.removeVersion(pathName);
0576     for (auto plot : plotList) {
0577       if (plot->pathName == pathName_noVersion) {
0578         (*plot).pathIndex = hltConfig_.triggerIndex(pathName);
0579       } else if (plot->pathNameOR == pathName_noVersion) {
0580         (*plot).pathIndexOR = hltConfig_.triggerIndex(pathName);
0581       }
0582     }
0583   }
0584   vector<hltPlot*> plotList_temp;
0585   for (auto plot : plotList) {
0586     if (plot->pathIndex > 0 || plot->pathIndexOR > 0) {
0587       plotList_temp.push_back(plot);
0588       acceptMap[plot->pathName] = false;
0589       if (plot->pathIndexOR > 0)
0590         acceptMap[plot->pathNameOR] = false;
0591     }
0592   }
0593   //now re-assign plotList to contain only the plots with paths in the menu.
0594   plotList = plotList_temp;
0595   plotList_temp.clear();
0596 }
0597 
0598 // ------------ method called when ending the processing of a run  ------------
0599 
0600 void HLTObjectMonitorProtonLead::bookHistograms(DQMStore::IBooker& ibooker,
0601                                                 edm::Run const& iRun,
0602                                                 edm::EventSetup const& iSetup) {
0603   ////////////////////////////////
0604   ///
0605   /// Main shifter workspace plots
0606   ///
0607   ////////////////////////////////
0608 
0609   //book wall time separately
0610   ibooker.setCurrentFolder(mainShifterFolder);
0611   wallTime_.ME =
0612       ibooker.book1D(wallTime_.plotLabel, wallTime_.pathName, wallTime_.nBins, wallTime_.xMin, wallTime_.xMax);
0613   wallTime_.ME->setAxisTitle(wallTime_.xAxisLabel);
0614 
0615   for (auto plot : plotList) {
0616     std::string display_pathNames = plot->pathName;
0617     if (!plot->pathNameOR.empty())
0618       display_pathNames = plot->pathName + " OR " + plot->pathNameOR;
0619 
0620     if (plot->displayInPrimary) {
0621       ibooker.setCurrentFolder(mainShifterFolder);
0622       (*plot).ME = ibooker.book1D(plot->plotLabel, display_pathNames.c_str(), plot->nBins, plot->xMin, plot->xMax);
0623       (*plot).ME->setAxisTitle(plot->xAxisLabel);
0624       //need to add OR statement
0625     } else {
0626       ibooker.setCurrentFolder(backupFolder);
0627       (*plot).ME = ibooker.book1D(plot->plotLabel, display_pathNames.c_str(), plot->nBins, plot->xMin, plot->xMax);
0628       (*plot).ME->setAxisTitle(plot->xAxisLabel);
0629     }
0630   }
0631 }
0632 
0633 double HLTObjectMonitorProtonLead::get_wall_time() {
0634   struct timeval time;
0635   if (gettimeofday(&time, nullptr))
0636     return 0;
0637   return (double)time.tv_sec + (double)time.tv_usec * .000001;
0638 }
0639 
0640 // ------------ method called when starting to processes a luminosity block  ------------
0641 /*
0642 void
0643 HLTObjectMonitorProtonLead::beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&)
0644 {
0645 }
0646 */
0647 
0648 // ------------ method called when ending the processing of a luminosity block  ------------
0649 /*
0650 void
0651 HLTObjectMonitorProtonLead::endLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&)
0652 {
0653 }
0654 */
0655 
0656 // ------------ method fills 'descriptions' with the allowed parameters for the module  ------------
0657 // void
0658 // HLTObjectMonitorProtonLead::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0659 //   //The following says we do not know what parameters are allowed so do no validation
0660 //   // Please change this to state exactly what you do use, even if it is no parameters
0661 //   edm::ParameterSetDescription desc;
0662 //   desc.setUnknown();
0663 //   descriptions.addDefault(desc);
0664 // }
0665 
0666 //define this as a plug-in
0667 DEFINE_FWK_MODULE(HLTObjectMonitorProtonLead);
[ 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!