CMS 3D CMS Logo
HLTObjectMonitorProtonLead.cc
Go to the documentation of this file.
1 // -*- C++ -*-
2 //
3 // Package: QM/HLTObjectMonitorProtonLead
4 // Class: HLTObjectMonitorProtonLead
5 //
13 //
14 // Original Author: Varun Sharma
15 // Created: Fri, 21 Oct 2016 12:29:00 GMT
16 //
17 //
18 
19 // system include files
20 #include <memory>
21 #include <sys/time.h>
22 #include <cstdlib>
23 
24 // user include files
25 #include "DataFormats/Common/interface/TriggerResults.h"
26 #include "DataFormats/HLTReco/interface/TriggerObject.h"
27 #include "DataFormats/HLTReco/interface/TriggerEvent.h"
28 #include "DataFormats/HLTReco/interface/TriggerTypeDefs.h"
29 
30 #include "FWCore/Framework/interface/Frameworkfwd.h"
31 #include "FWCore/Framework/interface/EDAnalyzer.h"
32 #include "FWCore/Framework/interface/Event.h"
33 #include "FWCore/Framework/interface/MakerMacros.h"
34 #include "FWCore/ParameterSet/interface/ParameterSet.h"
35 #include "FWCore/ServiceRegistry/interface/Service.h"
36 #include "FWCore/MessageLogger/interface/MessageLogger.h"
37 
38 #include "HLTrigger/HLTcore/interface/HLTConfigProvider.h"
39 
40 //for collections
41 #include "HLTrigger/JetMET/interface/AlphaT.h"
42 #include "DataFormats/BeamSpot/interface/BeamSpot.h"
43 #include "DataFormats/METReco/interface/MET.h"
44 #include "DataFormats/RecoCandidate/interface/RecoChargedCandidate.h"
45 #include "DataFormats/BTauReco/interface/JetTag.h"
46 #include "DataFormats/RecoCandidate/interface/RecoChargedCandidateFwd.h"
47 #include "DataFormats/Math/interface/deltaR.h"
48 #include "DataFormats/JetReco/interface/PFJet.h"
49 #include "DataFormats/JetReco/interface/CaloJet.h"
50 
51 #include "DQMServices/Core/interface/DQMStore.h"
52 #include "DQMServices/Core/interface/DQMEDAnalyzer.h"
53 
54 #include "TMath.h"
55 #include "TStyle.h"
56 #include "TLorentzVector.h"
57 
58 #include <unordered_map>
59 //
60 // class declaration
61 //
62 
63 //using namespace edm;
64 using namespace trigger;
65 using std::string;
66 using std::unordered_map;
67 using std::vector;
68 
69 class HLTObjectMonitorProtonLead : public DQMEDAnalyzer {
70  struct hltPlot {
71  MonitorElement* ME;
72  string pathName;
73  string pathNameOR;
74  string moduleName;
75  string moduleNameOR;
76  int pathIndex = -99;
77  int pathIndexOR = -99;
78  string plotLabel;
79  string xAxisLabel;
80  int nBins;
81  double xMin;
82  double xMax;
83  bool displayInPrimary;
84  };
85 
86 public:
87  explicit HLTObjectMonitorProtonLead(const edm::ParameterSet&);
88  ~HLTObjectMonitorProtonLead() override;
89 
90  // static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
91 
92 private:
93  void analyze(const edm::Event&, const edm::EventSetup&) override;
94  void bookHistograms(DQMStore::IBooker& i, edm::Run const&, edm::EventSetup const&) override;
95  void dqmBeginRun(edm::Run const&, edm::EventSetup const&) override;
96  void dqmEndRun(edm::Run const&, edm::EventSetup const&) override;
97  vector<hltPlot*> plotList;
98  //virtual void beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) override;
99  //virtual void endLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) override;
100  double get_wall_time(void);
101  // ----------member data ---------------------------
102 
103  bool debugPrint;
104  HLTConfigProvider hltConfig_;
105  string topDirectoryName;
106  string mainShifterFolder;
107  string backupFolder;
108  unordered_map<string, bool> acceptMap;
109  unordered_map<hltPlot*, edm::ParameterSet*> plotMap;
110 
111  //set Token(-s)
112  edm::EDGetTokenT<edm::TriggerResults> triggerResultsToken_;
113  edm::EDGetTokenT<trigger::TriggerEvent> aodTriggerToken_;
114 
115  //declare params
116  //pPb run
117  edm::ParameterSet caloAK4JetPt_pset;
118  edm::ParameterSet caloAK4JetEta_pset;
119  edm::ParameterSet caloAK4JetPhi_pset;
120  edm::ParameterSet pfAK4JetPt_pset;
121  edm::ParameterSet pfAK4JetEta_pset;
122  edm::ParameterSet pfAK4JetPhi_pset;
123  edm::ParameterSet caloDiAK4JetPt_pset;
124  edm::ParameterSet caloDiAK4JetEta_pset;
125  edm::ParameterSet caloDiAK4JetPhi_pset;
126  edm::ParameterSet pfDiAK4JetPt_pset;
127  edm::ParameterSet pfDiAK4JetEta_pset;
128  edm::ParameterSet pfDiAK4JetPhi_pset;
129  edm::ParameterSet photonPt_pset;
130  edm::ParameterSet photonEta_pset;
131  edm::ParameterSet photonPhi_pset;
132  edm::ParameterSet photonPPPt_pset;
133  edm::ParameterSet photonPPEta_pset;
134  edm::ParameterSet photonPPPhi_pset;
135  edm::ParameterSet caloBJetPt_pset;
136  edm::ParameterSet caloBJetEta_pset;
137  edm::ParameterSet caloBJetPhi_pset;
138  edm::ParameterSet pfBJetPt_pset;
139  edm::ParameterSet pfBJetEta_pset;
140  edm::ParameterSet pfBJetPhi_pset;
141  edm::ParameterSet electronPt_pset;
142  edm::ParameterSet electronEta_pset;
143  edm::ParameterSet electronPhi_pset;
144  edm::ParameterSet l3muon3Pt_pset;
145  edm::ParameterSet l3muon3Eta_pset;
146  edm::ParameterSet l3muon3Phi_pset;
147  edm::ParameterSet l2muon12Pt_pset;
148  edm::ParameterSet l2muon12Eta_pset;
149  edm::ParameterSet l2muon12Phi_pset;
150  edm::ParameterSet l3muon12Pt_pset;
151  edm::ParameterSet l3muon12Eta_pset;
152  edm::ParameterSet l3muon12Phi_pset;
153  edm::ParameterSet pAL1DoubleMuZMass_pset;
154  edm::ParameterSet pAL2DoubleMuZMass_pset;
155  edm::ParameterSet pAL3DoubleMuZMass_pset;
156  edm::ParameterSet wallTime_pset;
157 
158  string processName_;
159 
160  hltPlot caloAK4JetPt_;
161  hltPlot caloAK4JetEta_;
162  hltPlot caloAK4JetPhi_;
163  hltPlot pfAK4JetPt_;
164  hltPlot pfAK4JetEta_;
165  hltPlot pfAK4JetPhi_;
166  hltPlot caloDiAK4JetPt_;
167  hltPlot caloDiAK4JetEta_;
168  hltPlot caloDiAK4JetPhi_;
169  hltPlot pfDiAK4JetPt_;
170  hltPlot pfDiAK4JetEta_;
171  hltPlot pfDiAK4JetPhi_;
172  hltPlot photonPt_;
173  hltPlot photonEta_;
174  hltPlot photonPhi_;
175  hltPlot photonPPPt_;
176  hltPlot photonPPEta_;
177  hltPlot photonPPPhi_;
178  hltPlot caloBJetPt_;
179  hltPlot caloBJetEta_;
180  hltPlot caloBJetPhi_;
181  hltPlot pfBJetPt_;
182  hltPlot pfBJetEta_;
183  hltPlot pfBJetPhi_;
184  hltPlot electronPt_;
185  hltPlot electronEta_;
186  hltPlot electronPhi_;
187  hltPlot l3muon3Pt_;
188  hltPlot l3muon3Eta_;
189  hltPlot l3muon3Phi_;
190  hltPlot l2muon12Pt_;
191  hltPlot l2muon12Eta_;
192  hltPlot l2muon12Phi_;
193  hltPlot l3muon12Pt_;
194  hltPlot l3muon12Eta_;
195  hltPlot l3muon12Phi_;
196  hltPlot pAL1DoubleMuZMass_;
197  hltPlot pAL2DoubleMuZMass_;
198  hltPlot pAL3DoubleMuZMass_;
199  hltPlot wallTime_;
200 };
201 
202 //
203 // constants, enums and typedefs
204 //
205 
206 //
207 // static data member definitions
208 //
209 
210 //
211 // constructors and destructor
212 //
213 HLTObjectMonitorProtonLead::HLTObjectMonitorProtonLead(const edm::ParameterSet& iConfig)
214 
215 {
216  //now do what ever initialization is needed
217  debugPrint = false;
218 
219  topDirectoryName = "HLT/ObjectMonitor";
220  mainShifterFolder = topDirectoryName + "/MainShifter";
221  backupFolder = topDirectoryName + "/Backup";
222 
223  //parse params
224  processName_ = iConfig.getParameter<string>("processName");
225 
226  caloAK4JetPt_pset = iConfig.getParameter<edm::ParameterSet>("caloAK4JetPt");
227  plotMap[&caloAK4JetPt_] = &caloAK4JetPt_pset;
228  caloAK4JetEta_pset = iConfig.getParameter<edm::ParameterSet>("caloAK4JetEta");
229  plotMap[&caloAK4JetEta_] = &caloAK4JetEta_pset;
230  caloAK4JetPhi_pset = iConfig.getParameter<edm::ParameterSet>("caloAK4JetPhi");
231  plotMap[&caloAK4JetPhi_] = &caloAK4JetPhi_pset;
232  pfAK4JetPt_pset = iConfig.getParameter<edm::ParameterSet>("pfAK4JetPt");
233  plotMap[&pfAK4JetPt_] = &pfAK4JetPt_pset;
234  pfAK4JetEta_pset = iConfig.getParameter<edm::ParameterSet>("pfAK4JetEta");
235  plotMap[&pfAK4JetEta_] = &pfAK4JetEta_pset;
236  pfAK4JetPhi_pset = iConfig.getParameter<edm::ParameterSet>("pfAK4JetPhi");
237  plotMap[&pfAK4JetPhi_] = &pfAK4JetPhi_pset;
238  caloDiAK4JetPt_pset = iConfig.getParameter<edm::ParameterSet>("caloDiAK4JetPt");
239  plotMap[&caloDiAK4JetPt_] = &caloDiAK4JetPt_pset;
240  caloDiAK4JetEta_pset = iConfig.getParameter<edm::ParameterSet>("caloDiAK4JetEta");
241  plotMap[&caloDiAK4JetEta_] = &caloDiAK4JetEta_pset;
242  caloDiAK4JetPhi_pset = iConfig.getParameter<edm::ParameterSet>("caloDiAK4JetPhi");
243  plotMap[&caloDiAK4JetPhi_] = &caloDiAK4JetPhi_pset;
244  pfDiAK4JetPt_pset = iConfig.getParameter<edm::ParameterSet>("pfDiAK4JetPt");
245  plotMap[&pfDiAK4JetPt_] = &pfDiAK4JetPt_pset;
246  pfDiAK4JetEta_pset = iConfig.getParameter<edm::ParameterSet>("pfDiAK4JetEta");
247  plotMap[&pfDiAK4JetEta_] = &pfDiAK4JetEta_pset;
248  pfDiAK4JetPhi_pset = iConfig.getParameter<edm::ParameterSet>("pfDiAK4JetPhi");
249  plotMap[&pfDiAK4JetPhi_] = &pfDiAK4JetPhi_pset;
250  photonPt_pset = iConfig.getParameter<edm::ParameterSet>("photonPt");
251  plotMap[&photonPt_] = &photonPt_pset;
252  photonEta_pset = iConfig.getParameter<edm::ParameterSet>("photonEta");
253  plotMap[&photonEta_] = &photonEta_pset;
254  photonPhi_pset = iConfig.getParameter<edm::ParameterSet>("photonPhi");
255  plotMap[&photonPhi_] = &photonPhi_pset;
256  photonPPPt_pset = iConfig.getParameter<edm::ParameterSet>("photonPPPt");
257  plotMap[&photonPPPt_] = &photonPPPt_pset;
258  photonPPEta_pset = iConfig.getParameter<edm::ParameterSet>("photonPPEta");
259  plotMap[&photonPPEta_] = &photonPPEta_pset;
260  photonPPPhi_pset = iConfig.getParameter<edm::ParameterSet>("photonPPPhi");
261  plotMap[&photonPPPhi_] = &photonPPPhi_pset;
262  caloBJetPt_pset = iConfig.getParameter<edm::ParameterSet>("caloBJetPt");
263  plotMap[&caloBJetPt_] = &caloBJetPt_pset;
264  caloBJetEta_pset = iConfig.getParameter<edm::ParameterSet>("caloBJetEta");
265  plotMap[&caloBJetEta_] = &caloBJetEta_pset;
266  caloBJetPhi_pset = iConfig.getParameter<edm::ParameterSet>("caloBJetPhi");
267  plotMap[&caloBJetPhi_] = &caloBJetPhi_pset;
268  pfBJetPt_pset = iConfig.getParameter<edm::ParameterSet>("pfBJetPt");
269  plotMap[&pfBJetPt_] = &pfBJetPt_pset;
270  pfBJetEta_pset = iConfig.getParameter<edm::ParameterSet>("pfBJetEta");
271  plotMap[&pfBJetEta_] = &pfBJetEta_pset;
272  pfBJetPhi_pset = iConfig.getParameter<edm::ParameterSet>("pfBJetPhi");
273  plotMap[&pfBJetPhi_] = &pfBJetPhi_pset;
274  electronPt_pset = iConfig.getParameter<edm::ParameterSet>("electronPt");
275  plotMap[&electronPt_] = &electronPt_pset;
276  electronEta_pset = iConfig.getParameter<edm::ParameterSet>("electronEta");
277  plotMap[&electronEta_] = &electronEta_pset;
278  electronPhi_pset = iConfig.getParameter<edm::ParameterSet>("electronPhi");
279  plotMap[&electronPhi_] = &electronPhi_pset;
280  l3muon3Pt_pset = iConfig.getParameter<edm::ParameterSet>("l3muon3Pt");
281  plotMap[&l3muon3Pt_] = &l3muon3Pt_pset;
282  l3muon3Eta_pset = iConfig.getParameter<edm::ParameterSet>("l3muon3Eta");
283  plotMap[&l3muon3Eta_] = &l3muon3Eta_pset;
284  l3muon3Phi_pset = iConfig.getParameter<edm::ParameterSet>("l3muon3Phi");
285  plotMap[&l3muon3Phi_] = &l3muon3Phi_pset;
286  l2muon12Pt_pset = iConfig.getParameter<edm::ParameterSet>("l2muon12Pt");
287  plotMap[&l2muon12Pt_] = &l2muon12Pt_pset;
288  l2muon12Eta_pset = iConfig.getParameter<edm::ParameterSet>("l2muon12Eta");
289  plotMap[&l2muon12Eta_] = &l2muon12Eta_pset;
290  l2muon12Phi_pset = iConfig.getParameter<edm::ParameterSet>("l2muon12Phi");
291  plotMap[&l2muon12Phi_] = &l2muon12Phi_pset;
292  l3muon12Pt_pset = iConfig.getParameter<edm::ParameterSet>("l3muon12Pt");
293  plotMap[&l3muon12Pt_] = &l3muon12Pt_pset;
294  l3muon12Eta_pset = iConfig.getParameter<edm::ParameterSet>("l3muon12Eta");
295  plotMap[&l3muon12Eta_] = &l3muon12Eta_pset;
296  l3muon12Phi_pset = iConfig.getParameter<edm::ParameterSet>("l3muon12Phi");
297  plotMap[&l3muon12Phi_] = &l3muon12Phi_pset;
298  pAL1DoubleMuZMass_pset = iConfig.getParameter<edm::ParameterSet>("pAL1DoubleMuZMass");
299  plotMap[&pAL1DoubleMuZMass_] = &pAL1DoubleMuZMass_pset;
300  pAL2DoubleMuZMass_pset = iConfig.getParameter<edm::ParameterSet>("pAL2DoubleMuZMass");
301  plotMap[&pAL2DoubleMuZMass_] = &pAL2DoubleMuZMass_pset;
302  pAL3DoubleMuZMass_pset = iConfig.getParameter<edm::ParameterSet>("pAL3DoubleMuZMass");
303  plotMap[&pAL3DoubleMuZMass_] = &pAL3DoubleMuZMass_pset;
304  wallTime_pset = iConfig.getParameter<edm::ParameterSet>("wallTime");
305  plotMap[&wallTime_] = &wallTime_pset;
306 
307  for (auto item = plotMap.begin(); item != plotMap.end(); item++) {
308  (*item->first).pathName = (*item->second).getParameter<string>("pathName");
309  (*item->first).moduleName = (*item->second).getParameter<string>("moduleName");
310  (*item->first).nBins = (*item->second).getParameter<int>("NbinsX");
311  (*item->first).xMin = (*item->second).getParameter<double>("Xmin");
312  (*item->first).xMax = (*item->second).getParameter<double>("Xmax");
313  (*item->first).xAxisLabel = (*item->second).getParameter<string>("axisLabel");
314  (*item->first).plotLabel = (*item->second).getParameter<string>("plotLabel");
315  (*item->first).displayInPrimary = (*item->second).getParameter<bool>("mainWorkspace");
316 
317  if ((*item->second).exists("pathName_OR")) {
318  (*item->first).pathNameOR = (*item->second).getParameter<string>("pathName_OR");
319  }
320  if ((*item->second).exists("moduleName_OR")) {
321  (*item->first).moduleNameOR = (*item->second).getParameter<string>("moduleName_OR");
322  }
323 
324  plotList.push_back(item->first);
325  }
326  plotMap.clear();
327 
328  //set Token(s)
329  triggerResultsToken_ = consumes<edm::TriggerResults>(iConfig.getParameter<edm::InputTag>("triggerResults"));
330  aodTriggerToken_ = consumes<trigger::TriggerEvent>(iConfig.getParameter<edm::InputTag>("triggerEvent"));
331 }
332 
333 HLTObjectMonitorProtonLead::~HLTObjectMonitorProtonLead() {
334  // do anything here that needs to be done at desctruction time
335  // (e.g. close files, deallocate resources etc.)
336 }
337 
338 //
339 // member functions
340 //
341 
342 // ------------ method called for each event ------------
343 void HLTObjectMonitorProtonLead::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
344  double start = get_wall_time();
345 
346  using namespace edm;
347 
348  if (debugPrint)
349  std::cout << "Inside analyze(). " << std::endl;
350 
351  // access trigger results
352  edm::Handle<edm::TriggerResults> triggerResults;
353  iEvent.getByToken(triggerResultsToken_, triggerResults);
354  if (!triggerResults.isValid())
355  return;
356 
357  edm::Handle<trigger::TriggerEvent> aodTriggerEvent;
358  iEvent.getByToken(aodTriggerToken_, aodTriggerEvent);
359  if (!aodTriggerEvent.isValid())
360  return;
361 
362  //reset everything to not accepted at beginning of each event
363  unordered_map<string, bool> firedMap = acceptMap;
364  for (auto plot : plotList) //loop over paths
365  {
366  if (firedMap[plot->pathName])
367  continue;
368  bool triggerAccept = false;
369  const TriggerObjectCollection objects = aodTriggerEvent->getObjects();
370  edm::InputTag moduleFilter;
371  std::string pathName;
372  if (plot->pathIndex > 0 && triggerResults->accept(plot->pathIndex) && hltConfig_.saveTags(plot->moduleName)) {
373  moduleFilter = edm::InputTag(plot->moduleName, "", processName_);
374  pathName = plot->pathName;
375  triggerAccept = true;
376  } else if (plot->pathIndexOR > 0 && triggerResults->accept(plot->pathIndexOR) &&
377  hltConfig_.saveTags(plot->moduleNameOR)) {
378  if (firedMap[plot->pathNameOR])
379  continue;
380  moduleFilter = edm::InputTag(plot->moduleNameOR, "", processName_);
381  pathName = plot->pathNameOR;
382  triggerAccept = true;
383  }
384 
385  if (triggerAccept) {
386  unsigned int moduleFilterIndex = aodTriggerEvent->filterIndex(moduleFilter);
387 
388  if (moduleFilterIndex + 1 > aodTriggerEvent->sizeFilters())
389  return;
390  const Keys& keys = aodTriggerEvent->filterKeys(moduleFilterIndex);
391 
397 
398  //calo AK4 jet pt + eta + phi
399  if (pathName == caloAK4JetPt_.pathName) {
400  for (const auto& key : keys) {
401  caloAK4JetPt_.ME->Fill(objects[key].pt());
402  caloAK4JetEta_.ME->Fill(objects[key].eta());
403  caloAK4JetPhi_.ME->Fill(objects[key].phi());
404  }
405  }
406  //pf AK4 jet pt + eta + phi
407  else if (pathName == pfAK4JetPt_.pathName) {
408  for (const auto& key : keys) {
409  pfAK4JetPt_.ME->Fill(objects[key].pt());
410  pfAK4JetEta_.ME->Fill(objects[key].eta());
411  pfAK4JetPhi_.ME->Fill(objects[key].phi());
412  }
413  }
414  //calo AK4 di jet pt + eta + phi
415  else if (pathName == caloDiAK4JetPt_.pathName) {
416  for (const auto& key : keys) {
417  caloDiAK4JetPt_.ME->Fill(objects[key].pt());
418  caloDiAK4JetEta_.ME->Fill(objects[key].eta());
419  caloDiAK4JetPhi_.ME->Fill(objects[key].phi());
420  }
421  }
422  //pf AK4 di jet pt + eta + phi
423  else if (pathName == pfDiAK4JetPt_.pathName) {
424  for (const auto& key : keys) {
425  pfDiAK4JetPt_.ME->Fill(objects[key].pt());
426  pfDiAK4JetEta_.ME->Fill(objects[key].eta());
427  pfDiAK4JetPhi_.ME->Fill(objects[key].phi());
428  }
429  }
430  //photon pt + eta + phi
431  else if (pathName == photonPt_.pathName) {
432  for (const auto& key : keys) {
433  photonPt_.ME->Fill(objects[key].pt());
434  photonEta_.ME->Fill(objects[key].eta());
435  photonPhi_.ME->Fill(objects[key].phi());
436  }
437  }
438  //photon PPStyle pt + eta + phi
439  else if (pathName == photonPPPt_.pathName) {
440  for (const auto& key : keys) {
441  photonPPPt_.ME->Fill(objects[key].pt());
442  photonPPEta_.ME->Fill(objects[key].eta());
443  photonPPPhi_.ME->Fill(objects[key].phi());
444  }
445  }
446  //calo Bjet pt + eta + phi
447  else if (pathName == caloBJetPt_.pathName) {
448  for (const auto& key : keys) {
449  caloBJetPt_.ME->Fill(objects[key].pt());
450  caloBJetEta_.ME->Fill(objects[key].eta());
451  caloBJetPhi_.ME->Fill(objects[key].phi());
452  }
453  }
454  //PF Bjet pt + eta + phi
455  else if (pathName == pfBJetPt_.pathName) {
456  for (const auto& key : keys) {
457  pfBJetPt_.ME->Fill(objects[key].pt());
458  pfBJetEta_.ME->Fill(objects[key].eta());
459  pfBJetPhi_.ME->Fill(objects[key].phi());
460  }
461  }
462  //electron pt + eta + phi
463  else if (pathName == electronPt_.pathName) {
464  for (const auto& key : keys) {
465  electronPt_.ME->Fill(objects[key].pt());
466  electronEta_.ME->Fill(objects[key].eta());
467  electronPhi_.ME->Fill(objects[key].phi());
468  }
469  } else if (pathName == l3muon3Pt_.pathName) {
470  for (const auto& key : keys) {
471  l3muon3Pt_.ME->Fill(objects[key].pt());
472  l3muon3Eta_.ME->Fill(objects[key].eta());
473  l3muon3Phi_.ME->Fill(objects[key].phi());
474  }
475  } else if (pathName == l2muon12Pt_.pathName) {
476  for (const auto& key : keys) {
477  l2muon12Pt_.ME->Fill(objects[key].pt());
478  l2muon12Eta_.ME->Fill(objects[key].eta());
479  l2muon12Phi_.ME->Fill(objects[key].phi());
480  }
481  } else if (pathName == l3muon12Pt_.pathName) {
482  for (const auto& key : keys) {
483  l3muon12Pt_.ME->Fill(objects[key].pt());
484  l3muon12Eta_.ME->Fill(objects[key].eta());
485  l3muon12Phi_.ME->Fill(objects[key].phi());
486  }
487  }
488 
489  // ////////////////////////////////
490  // ///
491  // /// double-object plots
492  // ///
493  // ////////////////////////////////
494 
495  else if (pathName == pAL1DoubleMuZMass_.pathName) {
496  const double mu_mass(.105658);
497  unsigned int kCnt0 = 0;
498  for (const auto& key0 : keys) {
499  unsigned int kCnt1 = 0;
500  for (const auto& key1 : keys) {
501  if (key0 != key1 &&
502  kCnt1 > kCnt0) { // avoid filling hists with same objs && avoid double counting separate objs
503  // if (abs(objects[key0].id()) == 13 && (objects[key0].id()+objects[key1].id()==0)) // id is not filled for l1 stage2 muons
504  TLorentzVector mu1, mu2, dimu;
505  mu1.SetPtEtaPhiM(objects[key0].pt(), objects[key0].eta(), objects[key0].phi(), mu_mass);
506  mu2.SetPtEtaPhiM(objects[key1].pt(), objects[key1].eta(), objects[key1].phi(), mu_mass);
507  dimu = mu1 + mu2;
508  if (dimu.M() > pAL1DoubleMuZMass_.xMin && dimu.M() < pAL1DoubleMuZMass_.xMax)
509  pAL1DoubleMuZMass_.ME->Fill(dimu.M());
510  }
511  kCnt1 += 1;
512  }
513  kCnt0 += 1;
514  }
515  } else if (pathName == pAL2DoubleMuZMass_.pathName) {
516  const double mu_mass(.105658);
517  unsigned int kCnt0 = 0;
518  for (const auto& key0 : keys) {
519  unsigned int kCnt1 = 0;
520  for (const auto& key1 : keys) {
521  if (key0 != key1 &&
522  kCnt1 > kCnt0) { // avoid filling hists with same objs && avoid double counting separate objs
523  if (abs(objects[key0].id()) == 13 &&
524  (objects[key0].id() + objects[key1].id() == 0)) { // check muon id and dimuon charge
525  TLorentzVector mu1, mu2, dimu;
526  mu1.SetPtEtaPhiM(objects[key0].pt(), objects[key0].eta(), objects[key0].phi(), mu_mass);
527  mu2.SetPtEtaPhiM(objects[key1].pt(), objects[key1].eta(), objects[key1].phi(), mu_mass);
528  dimu = mu1 + mu2;
529  if (dimu.M() > pAL2DoubleMuZMass_.xMin && dimu.M() < pAL2DoubleMuZMass_.xMax)
530  pAL2DoubleMuZMass_.ME->Fill(dimu.M());
531  }
532  }
533  kCnt1 += 1;
534  }
535  kCnt0 += 1;
536  }
537  } else if (pathName == pAL3DoubleMuZMass_.pathName) {
538  const double mu_mass(.105658);
539  unsigned int kCnt0 = 0;
540  for (const auto& key0 : keys) {
541  unsigned int kCnt1 = 0;
542  for (const auto& key1 : keys) {
543  if (key0 != key1 &&
544  kCnt1 > kCnt0) { // avoid filling hists with same objs && avoid double counting separate objs
545  if (abs(objects[key0].id()) == 13 &&
546  (objects[key0].id() + objects[key1].id() == 0)) { // check muon id and dimuon charge
547  TLorentzVector mu1, mu2, dimu;
548  mu1.SetPtEtaPhiM(objects[key0].pt(), objects[key0].eta(), objects[key0].phi(), mu_mass);
549  mu2.SetPtEtaPhiM(objects[key1].pt(), objects[key1].eta(), objects[key1].phi(), mu_mass);
550  dimu = mu1 + mu2;
551  if (dimu.M() > pAL3DoubleMuZMass_.xMin && dimu.M() < pAL3DoubleMuZMass_.xMax)
552  pAL3DoubleMuZMass_.ME->Fill(dimu.M());
553  }
554  }
555  kCnt1 += 1;
556  }
557  kCnt0 += 1;
558  }
559  }
560 
561  firedMap[pathName] = true;
562  } //end if trigger accept
563  } //end loop over plots/paths
564 
565  // sleep(1); //sleep for 1s, used to calibrate timing
566  double end = get_wall_time();
567  double wallTime = end - start;
568  wallTime_.ME->Fill(wallTime);
569 }
570 
571 // ------------ method called when starting to processes a run ------------
572 void HLTObjectMonitorProtonLead::dqmBeginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {
573  if (debugPrint)
574  std::cout << "Calling beginRun. " << std::endl;
575  bool changed = true;
576  if (hltConfig_.init(iRun, iSetup, processName_, changed)) {
577  if (debugPrint)
578  std::cout << "Extracting HLTconfig. " << std::endl;
579  }
580 
581  //get path indicies from menu
582  string pathName_noVersion;
583  vector<string> triggerPaths = hltConfig_.triggerNames();
584 
585  for (const auto& pathName : triggerPaths) {
586  pathName_noVersion = hltConfig_.removeVersion(pathName);
587  for (auto plot : plotList) {
588  if (plot->pathName == pathName_noVersion) {
589  (*plot).pathIndex = hltConfig_.triggerIndex(pathName);
590  } else if (plot->pathNameOR == pathName_noVersion) {
591  (*plot).pathIndexOR = hltConfig_.triggerIndex(pathName);
592  }
593  }
594  }
595  vector<hltPlot*> plotList_temp;
596  for (auto plot : plotList) {
597  if (plot->pathIndex > 0 || plot->pathIndexOR > 0) {
598  plotList_temp.push_back(plot);
599  acceptMap[plot->pathName] = false;
600  if (plot->pathIndexOR > 0)
601  acceptMap[plot->pathNameOR] = false;
602  }
603  }
604  //now re-assign plotList to contain only the plots with paths in the menu.
605  plotList = plotList_temp;
606  plotList_temp.clear();
607 }
608 
609 // ------------ method called when ending the processing of a run ------------
610 
611 void HLTObjectMonitorProtonLead::dqmEndRun(edm::Run const&, edm::EventSetup const&) {
612  if (debugPrint)
613  std::cout << "Calling endRun. " << std::endl;
614 }
615 
616 void HLTObjectMonitorProtonLead::bookHistograms(DQMStore::IBooker& ibooker,
617  edm::Run const& iRun,
618  edm::EventSetup const& iSetup) {
624 
625  //book wall time separately
626  ibooker.setCurrentFolder(mainShifterFolder);
627  wallTime_.ME =
628  ibooker.book1D(wallTime_.plotLabel, wallTime_.pathName, wallTime_.nBins, wallTime_.xMin, wallTime_.xMax);
629  wallTime_.ME->setAxisTitle(wallTime_.xAxisLabel);
630 
631  for (auto plot : plotList) {
632  std::string display_pathNames = plot->pathName;
633  if (!plot->pathNameOR.empty())
634  display_pathNames = plot->pathName + " OR " + plot->pathNameOR;
635 
636  if (plot->displayInPrimary) {
637  ibooker.setCurrentFolder(mainShifterFolder);
638  (*plot).ME = ibooker.book1D(plot->plotLabel, display_pathNames.c_str(), plot->nBins, plot->xMin, plot->xMax);
639  (*plot).ME->setAxisTitle(plot->xAxisLabel);
640  //need to add OR statement
641  } else {
642  ibooker.setCurrentFolder(backupFolder);
643  (*plot).ME = ibooker.book1D(plot->plotLabel, display_pathNames.c_str(), plot->nBins, plot->xMin, plot->xMax);
644  (*plot).ME->setAxisTitle(plot->xAxisLabel);
645  }
646  }
647 }
648 
649 double HLTObjectMonitorProtonLead::get_wall_time() {
650  struct timeval time;
651  if (gettimeofday(&time, nullptr))
652  return 0;
653  return (double)time.tv_sec + (double)time.tv_usec * .000001;
654 }
655 
656 // ------------ method called when starting to processes a luminosity block ------------
657 /*
658 void
659 HLTObjectMonitorProtonLead::beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&)
660 {
661 }
662 */
663 
664 // ------------ method called when ending the processing of a luminosity block ------------
665 /*
666 void
667 HLTObjectMonitorProtonLead::endLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&)
668 {
669 }
670 */
671 
672 // ------------ method fills 'descriptions' with the allowed parameters for the module ------------
673 // void
674 // HLTObjectMonitorProtonLead::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
675 // //The following says we do not know what parameters are allowed so do no validation
676 // // Please change this to state exactly what you do use, even if it is no parameters
677 // edm::ParameterSetDescription desc;
678 // desc.setUnknown();
679 // descriptions.addDefault(desc);
680 // }
681 
682 //define this as a plug-in
683 DEFINE_FWK_MODULE(HLTObjectMonitorProtonLead);
start
Definition: start.py:1
HLTObjectMonitorProtonLead::aodTriggerToken_
edm::EDGetTokenT< trigger::TriggerEvent > aodTriggerToken_
Definition: HLTObjectMonitorProtonLead.cc:113
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
HLT_2018_cff.InputTag
InputTag
Definition: HLT_2018_cff.py:78913
mps_fire.i
i
Definition: mps_fire.py:341
HLTObjectMonitor_cfi.wallTime
wallTime
Definition: HLTObjectMonitor_cfi.py:438
trigger::TriggerEvent::sizeFilters
trigger::size_type sizeFilters() const
Definition: TriggerEvent.h:146
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:525
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
HLTObjectMonitor_cfi.plotLabel
plotLabel
Definition: HLTObjectMonitor_cfi.py:46
edm::HLTGlobalStatus::accept
bool accept() const
Has at least one path accepted the event?
Definition: HLTGlobalStatus.h:49
trigger::TriggerEvent::filterKeys
const Keys & filterKeys(trigger::size_type index) const
Definition: TriggerEvent.h:118
trigger::TriggerEvent::filterIndex
trigger::size_type filterIndex(const edm::InputTag &filterTag) const
find index of filter in data-member vector from filter tag
Definition: TriggerEvent.h:132
multiplicitycorr_cfi.xMax
xMax
Definition: multiplicitycorr_cfi.py:5
HLTObjectMonitorProtonLead::acceptMap
unordered_map< string, bool > acceptMap
Definition: HLTObjectMonitorProtonLead.cc:108
B2GTnPMonitor_cfi.item
item
Definition: B2GTnPMonitor_cfi.py:147
HLTObjectMonitorProtonLead::triggerResultsToken_
edm::EDGetTokenT< edm::TriggerResults > triggerResultsToken_
Definition: HLTObjectMonitorProtonLead.cc:112
analyze
example_stream void analyze(const edm::Event &, const edm::EventSetup &) override
DiDispStaMuonMonitor_cfi.pt
pt
Definition: DiDispStaMuonMonitor_cfi.py:39
command_line.start
start
Definition: command_line.py:167
hltMonBTagIPClient_cfi.pathName
pathName
Definition: hltMonBTagIPClient_cfi.py:5
iEvent
int iEvent
Definition: GenABIO.cc:224
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
trigger::TriggerEvent::getObjects
const TriggerObjectCollection & getObjects() const
Definition: TriggerEvent.h:101
HLTObjectMonitorProtonLead::bookHistograms
void bookHistograms(DQMStore::IBooker &i, edm::Run const &, edm::EventSetup const &) override
Definition: HLTObjectMonitorProtonLead.cc:616
HigPhotonJetHLTOfflineSource_cfi.triggerAccept
triggerAccept
Definition: HigPhotonJetHLTOfflineSource_cfi.py:32
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
end
#define end
Definition: vmac.h:39
triggerResults
static std::string const triggerResults
Definition: EdmProvDump.cc:45
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
HLTObjectMonitorProtonLead::plotMap
unordered_map< hltPlot *, edm::ParameterSet * > plotMap
Definition: HLTObjectMonitorProtonLead.cc:109
photonAnalyzer_cfi.xMin
xMin
Definition: photonAnalyzer_cfi.py:82
trigger::TriggerObjectCollection
std::vector< TriggerObject > TriggerObjectCollection
collection of trigger physics objects (e.g., all isolated muons)
Definition: TriggerObject.h:75
EcalCalibMonitorClient_cfi.moduleName
moduleName
Definition: EcalCalibMonitorClient_cfi.py:17
trigger::Keys
std::vector< size_type > Keys
Definition: TriggerTypeDefs.h:19
HLTObjectMonitorProtonLead::HLTObjectMonitorProtonLead
HLTObjectMonitorProtonLead(const edm::ParameterSet &)
Definition: HLTObjectMonitorProtonLead.cc:213
bookHistograms
example_stream void bookHistograms(DQMStore::IBooker &,@example_stream edm::Run const &,@example_stream edm::EventSetup const &) override
edm
HLT enums.
Definition: AlignableModifier.h:19
HLTObjectMonitorProtonLead::dqmEndRun
void dqmEndRun(edm::Run const &, edm::EventSetup const &) override
Definition: HLTObjectMonitorProtonLead.cc:611
gather_cfg.cout
cout
Definition: gather_cfg.py:144
seedmultiplicitymonitor_newtracking_cfi.nBins
nBins
Definition: seedmultiplicitymonitor_newtracking_cfi.py:8
HLTObjectMonitorProtonLead::dqmBeginRun
void dqmBeginRun(edm::Run const &, edm::EventSetup const &) override
Definition: HLTObjectMonitorProtonLead.cc:572
triggerPaths
static std::string const triggerPaths
Definition: EdmProvDump.cc:46
edm::Run
Definition: Run.h:45
HLTObjectMonitorProtonLead::analyze
void analyze(const edm::Event &, const edm::EventSetup &) override
Definition: HLTObjectMonitorProtonLead.cc:343
Generated for CMSSW Reference Manual by doxygen 1.8.11