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