CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
TriggerValidator.cc
Go to the documentation of this file.
1 // -*- C++ -*-
2 //
3 // Package: TriggerValidator
4 // Class: TriggerValidator
5 //
13 //
14 // Original Author: Massimiliano Chiorboli
15 // Maurizio Pierini
16 // Maria Spiropulu
17 // Created: Wed Aug 29 15:10:56 CEST 2007
18 // Philip Hebda, July 2009
19 // $Id: TriggerValidator.cc,v 1.24 2010/12/14 17:20:35 vlimant Exp $
20 //
21 //
22 
23 
24 // system include files
25 #include <memory>
26 #include <stdio.h>
27 #include <iomanip>
28 
29 #include "HLTriggerOffline/SUSYBSM/interface/TriggerValidator.h"
30 #include "FWCore/MessageLogger/interface/MessageLogger.h"
31 
32 
33 // user include files
34 #include "FWCore/Framework/interface/Frameworkfwd.h"
35 #include "FWCore/Framework/interface/EDAnalyzer.h"
36 #include "FWCore/Framework/interface/Event.h"
37 #include "FWCore/Framework/interface/MakerMacros.h"
38 #include "FWCore/Common/interface/TriggerNames.h"
39 #include "DataFormats/Common/interface/Handle.h"
40 
41 
42 #include "FWCore/ParameterSet/interface/ParameterSet.h"
43 
44 //Added by Max for the Trigger
45 #include "DataFormats/HLTReco/interface/TriggerEventWithRefs.h"
46 #include "DataFormats/Common/interface/TriggerResults.h"
47 //#include "DataFormats/L1Trigger/interface/L1ParticleMap.h"
48 #include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutRecord.h"
49 
50 #include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutRecord.h"
51 #include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerObjectMapRecord.h"
52 #include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerObjectMap.h"
53 
54 
55 //Added for the DQM
56 #include "DQMServices/Core/interface/MonitorElement.h"
57 #include "FWCore/Framework/interface/Run.h"
58 
59 #include "TFile.h"
60 #include "TDirectory.h"
61 #include "TH1.h"
62 #include "TH2.h"
63 #include "TList.h"
64 #include "TObjString.h"
65 #include "TString.h"
66 #include "TObject.h"
67 
68 //
69 // constants, enums and typedefs
70 //
71 
72 //
73 // static data member definitions
74 //
75 
76 
77 
78 //
79 // constructors and destructor
80 //
81 
82 using namespace edm;
83 using namespace std;
84 
85 TriggerValidator::TriggerValidator(const edm::ParameterSet& iConfig):
86  dirname_(iConfig.getUntrackedParameter("dirname",
87  std::string("HLT/SusyExo"))),
88  HistoFileName(iConfig.getUntrackedParameter("histoFileName",
89  std::string("SusyBsmTriggerValidation.root"))),
90  StatFileName(iConfig.getUntrackedParameter("statFileName",
91  std::string("SusyBsmTriggerValidation.stat"))),
92  l1Label(iConfig.getParameter<edm::InputTag>("L1Label")),
93  hltLabel(iConfig.getParameter<edm::InputTag>("HltLabel")),
94  mcFlag(iConfig.getUntrackedParameter<bool>("mc_flag",false)),
95  l1Flag(iConfig.getUntrackedParameter<bool>("l1_flag",false)),
96  reco_parametersets(iConfig.getParameter<VParameterSet>("reco_parametersets")),
97  mc_parametersets(iConfig.getParameter<VParameterSet>("mc_parametersets")),
98  turnOn_params(iConfig.getParameter<ParameterSet>("TurnOnParams")),
99  plotMakerL1Input(iConfig.getParameter<ParameterSet>("PlotMakerL1Input")),
100  plotMakerRecoInput(iConfig.getParameter<ParameterSet>("PlotMakerRecoInput")),
101  muonTag_(iConfig.getParameter<edm::InputTag>("muonTag")),
102  triggerTag_(iConfig.getParameter<edm::InputTag>("triggerTag")),
103  processName_(iConfig.getParameter<std::string>("hltConfigName")),
104  triggerName_(iConfig.getParameter<std::string>("triggerName"))
105 {
106  //now do what ever initialization is needed
107  theHistoFile = 0;
108  nEvTot = 0;
109  for(unsigned int i=0; i<reco_parametersets.size(); ++i) nEvRecoSelected.push_back(0);
110  for(unsigned int i=0; i<mc_parametersets.size(); ++i) nEvMcSelected.push_back(0);
111 
112  nHltPaths = 0;
113  nL1Bits = 0;
114 
115 
116  // --- set the names in the dbe folders ---
117  triggerBitsDir = "/TriggerBits";
118  recoSelBitsDir = "/RecoSelection";
119  mcSelBitsDir = "/McSelection";
120 
121 
122  LogDebug("TriggerValidator") << "constructor...." ;
123 
124  dbe_ = Service < DQMStore > ().operator->();
125  if ( ! dbe_ ) {
126  LogInfo("TriggerValidator") << "unabel to get DQMStore service?";
127  }
128  if (iConfig.getUntrackedParameter < bool > ("DQMStore", false)) {
129  dbe_->setVerbose(0);
130  }
131 
132 
133 
134 
135  if (dbe_ != 0 ) {
136  dbe_->setCurrentFolder(dirname_);
137  }
138 
139 
140  plotMakerL1Input.addParameter<std::string>("dirname",dirname_);
141  plotMakerRecoInput.addParameter<std::string>("dirname",dirname_);
142 
143 }
144 
145 
146 TriggerValidator::~TriggerValidator()
147 {
148 
149  // do anything here that needs to be done at desctruction time
150  // (e.g. close files, deallocate resources etc.)
151 
152 }
153 
154 
155 //
156 // member functions
157 //
158 
159 // ------------ method called to for each event ------------
160 void
161 TriggerValidator::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup)
162 {
163 
164  using namespace edm;
165 
166  nEvTot++;
167 
168  vector<bool> eventRecoSelected, eventMcSelected;
169  eventRecoSelected.resize(reco_parametersets.size());
170  eventMcSelected.resize(mc_parametersets.size());
171  for(unsigned int i=0; i<eventRecoSelected.size(); ++i) eventRecoSelected[i] = myRecoSelector[i]->isSelected(iEvent);
172  for(unsigned int i=0; i<eventMcSelected.size(); ++i) eventMcSelected[i] = mcFlag ? myMcSelector[i]->isSelected(iEvent) : false;
173 
174  for(unsigned int i=0; i<nEvRecoSelected.size(); ++i) if(eventRecoSelected[i]) nEvRecoSelected[i]++;
175  for(unsigned int i=0; i<nEvMcSelected.size(); ++i) if(eventMcSelected[i]) nEvMcSelected[i]++;
176 
177 
178  // ********************************************************
179  // Get the L1 Info
180  // ********************************************************
181  Handle<L1GlobalTriggerReadoutRecord> L1GTRR;
182  // try {iEvent.getByType(L1GTRR);} catch (...) {;}
183  iEvent.getByLabel("gtDigis",L1GTRR);
184  if (!L1GTRR.isValid()) {edm::LogWarning("Readout Error|L1") << "L1ParticleMapCollection Not Valid!";}
185  int nL1size = L1GTRR->decisionWord().size();
186  if(firstEvent) {
187 
188  //this piece of code concerns efficiencies
189  //it must be moved to the client
190 
191 // //resize the eff and overlap vectors ccording to the number of L1 paths
192 // effL1BeforeCuts.resize(L1GTRR->decisionWord().size()+1);
193 // effL1AfterRecoCuts.resize(L1GTRR->decisionWord().size()+1);
194 // effL1AfterMcCuts.resize(L1GTRR->decisionWord().size()+1);
195  vCorrL1.resize(L1GTRR->decisionWord().size());
196  for(unsigned int i=0; i<L1GTRR->decisionWord().size(); i++) {vCorrL1[i].resize(L1GTRR->decisionWord().size());}
197  vCorrNormL1.resize(L1GTRR->decisionWord().size());
198  for(unsigned int i=0; i<L1GTRR->decisionWord().size(); i++) {vCorrNormL1[i].resize(L1GTRR->decisionWord().size());}
199 
200 
201  //Get the names of the L1 paths
202  //for the moment the names are not included in L1GlobalTriggerReadoutRecord
203  //we need to use L1GlobalTriggerObjectMapRecord
204  edm::Handle<L1GlobalTriggerObjectMapRecord> gtObjectMapRecord;
205  // iEvent.getByLabel("l1GtEmulDigis", gtObjectMapRecord);
206  // iEvent.getByLabel("hltL1GtObjectMap", gtObjectMapRecord);
207  iEvent.getByLabel(l1Label, gtObjectMapRecord);
208  const std::vector<L1GlobalTriggerObjectMap>& objMapVec =
209  gtObjectMapRecord->gtObjectMap();
210  for (std::vector<L1GlobalTriggerObjectMap>::const_iterator itMap = objMapVec.begin();
211  itMap != objMapVec.end(); ++itMap) {
212  int algoBit = (*itMap).algoBitNumber();
213  std::string algoNameStr = (*itMap).algoName();
214  l1NameMap[algoBit] = algoNameStr;
215  }
216  //resize the name vector and get the names
217  l1Names_.resize(L1GTRR->decisionWord().size()+1);
218  for (unsigned int i=0; i!=L1GTRR->decisionWord().size(); i++) {
219  l1Names_[i]=l1NameMap[i];
220  }
221  l1Names_[L1GTRR->decisionWord().size()] = "Total";
222 
223  //set the names of the bins for the "path" histos
224  for(unsigned int i=0; i<l1Names_.size(); ++i) {
225  hL1PathsBeforeCuts->setBinLabel(i+1,l1Names_[i].c_str(),1);
226  for(unsigned int j=0; j<hL1PathsAfterRecoCuts.size(); ++j) hL1PathsAfterRecoCuts[j]->setBinLabel(i+1,l1Names_[i].c_str(),1);
227  for(unsigned int j=0; j<hL1PathsAfterMcCuts.size(); ++j) hL1PathsAfterMcCuts[j]->setBinLabel(i+1,l1Names_[i].c_str(),1);
228  }
229  }
230 
231  //fill the eff vectors and histos for L1
232  for (int i=0; i<nL1size; ++i) {
233  l1bits.push_back(L1GTRR->decisionWord()[i]);
234  if(L1GTRR->decisionWord()[i]) {
235  numTotL1BitsBeforeCuts[i]++;
236  hL1BitsBeforeCuts->Fill(i);
237  hL1PathsBeforeCuts->Fill(i);
238  for(unsigned int j=0; j<eventRecoSelected.size(); ++j)
239  if(eventRecoSelected[j]) {
240  numTotL1BitsAfterRecoCuts[j][i]++;
241  hL1BitsAfterRecoCuts[j]->Fill(i);
242  hL1PathsAfterRecoCuts[j]->Fill(i);
243  }
244  for(unsigned int j=0; j<eventMcSelected.size(); ++j)
245  if(eventMcSelected[j]) {
246  numTotL1BitsAfterMcCuts[j][i]++;
247  hL1BitsAfterMcCuts[j]->Fill(i);
248  hL1PathsAfterMcCuts[j]->Fill(i);
249  }
250  }
251  }
252 
253  //Calculate the overlap among l1 bits
254  for(int i=0; i<nL1size; ++i) {
255  for(int j=0; j<nL1size; ++j) {
256  if(l1bits[i]*l1bits[j]) vCorrL1[i][j]++;
257  }
258  }
259 
260  //fill the last bin with the total of events
261  numTotL1BitsBeforeCuts[nL1size]++;
262  hL1BitsBeforeCuts->Fill(nL1size);
263  hL1PathsBeforeCuts->Fill(nL1size);
264  for(unsigned int i=0; i<eventRecoSelected.size(); ++i)
265  if(eventRecoSelected[i]) {
266  numTotL1BitsAfterRecoCuts[i][nL1size]++;
267  hL1BitsAfterRecoCuts[i]->Fill(nL1size);
268  hL1PathsAfterRecoCuts[i]->Fill(nL1size);
269  }
270  for(unsigned int i=0; i<eventMcSelected.size(); ++i)
271  if(eventMcSelected[i]) {
272  numTotL1BitsAfterMcCuts[i][nL1size]++;
273  hL1BitsAfterMcCuts[i]->Fill(nL1size);
274  hL1PathsAfterMcCuts[i]->Fill(nL1size);
275  }
276 
277 
278  // ********************************************************
279  // Get the HLT Info
280  // ********************************************************
281  edm::Handle<TriggerResults> trhv;
282  iEvent.getByLabel(hltLabel,trhv);
283  if( ! trhv.isValid() ) {
284  LogDebug("") << "HL TriggerResults with label ["+hltLabel.encode()+"] not found!";
285  return;
286  }
287 
288 
289 // if(!trhv.isValid()) {
290 // std::cout << "invalid handle for HLT TriggerResults" << std::endl;
291 // }
292 
293 
294  if(firstEvent) {
295 
296 
297 
298  //
299  // The following piece of code concerns efficiencies and so must be moved to the client
300  //
301 
302 
303 // //resize the eff and overlap vectors ccording to the number of L1 paths
304 // effHltBeforeCuts.resize(trhv->size()+1);
305 // effHltAfterRecoCuts.resize(trhv->size()+1);
306 // effHltAfterMcCuts.resize(trhv->size()+1);
307  vCorrHlt.resize(trhv->size());
308  for(unsigned int i=0; i<trhv->size(); i++) {vCorrHlt[i].resize(trhv->size());}
309  vCorrNormHlt.resize(trhv->size());
310  for(unsigned int i=0; i<trhv->size(); i++) {vCorrNormHlt[i].resize(trhv->size());}
311 
312 
313  //resize the name vector and get the names
314  const edm::TriggerNames & triggerNames = iEvent.triggerNames(*trhv);
315  hlNames_=triggerNames.triggerNames();
316  hlNames_.push_back("Total");
317 
318  //set the bin names for the "path" histos
319  for (unsigned int i=0; i<hlNames_.size(); ++i) {
320  hHltPathsBeforeCuts->setBinLabel(i+1,hlNames_[i].c_str(),1);
321  for(unsigned int j=0; j<hHltPathsAfterRecoCuts.size(); ++j) hHltPathsAfterRecoCuts[j]->setBinLabel(i+1,hlNames_[i].c_str(),1);
322  for(unsigned int j=0; j<hHltPathsAfterMcCuts.size(); ++j) hHltPathsAfterMcCuts[j]->setBinLabel(i+1,hlNames_[i].c_str(),1);
323  }
324  }
325 
326  //fill the eff vectors and histos for HLT
327  for(unsigned int i=0; i< trhv->size(); i++) {
328  hltbits.push_back(trhv->at(i).accept());
329  if(trhv->at(i).accept()) {
330  numTotHltBitsBeforeCuts[i]++;
331  hHltBitsBeforeCuts->Fill(i);
332  hHltPathsBeforeCuts->Fill(i);
333  for(unsigned int j=0; j<eventRecoSelected.size(); ++j)
334  if(eventRecoSelected[j]) {
335  numTotHltBitsAfterRecoCuts[j][i]++;
336  hHltBitsAfterRecoCuts[j]->Fill(i);
337  hHltPathsAfterRecoCuts[j]->Fill(i);
338  }
339  for(unsigned int j=0; j<eventMcSelected.size(); ++j)
340  if(eventMcSelected[j]) {
341  numTotHltBitsAfterMcCuts[j][i]++;
342  hHltBitsAfterMcCuts[j]->Fill(i);
343  hHltPathsAfterMcCuts[j]->Fill(i);
344  }
345  }
346  }
347 
348  //Calculate the overlap among HLT paths
349  for(unsigned int i=0; i< trhv->size(); i++) {
350  for(unsigned int j=0; j< trhv->size(); j++) {
351 // cout << "trhv->size() = " << trhv->size() << endl;
352 // cout << "hltbits["<< i << "] = " << hltbits[i] << endl;
353 // cout << "hltbits["<< j << "] = " << hltbits[j] << endl;
354  if(hltbits[i]*hltbits[j]) vCorrHlt[i][j]++;
355  }
356  }
357 
358 
359  //The overlap histos are filled in the endJob() method
360 
361  //fill the last bin with the total of events
362  numTotHltBitsBeforeCuts[trhv->size()]++;
363  hHltBitsBeforeCuts->Fill(trhv->size());
364  hHltPathsBeforeCuts->Fill(trhv->size());
365  for(unsigned int i=0; i<eventRecoSelected.size(); ++i)
366  if(eventRecoSelected[i]) {
367  numTotHltBitsAfterRecoCuts[i][trhv->size()]++;
368  hHltBitsAfterRecoCuts[i]->Fill(trhv->size());
369  hHltPathsAfterRecoCuts[i]->Fill(trhv->size());
370  }
371  for(unsigned int i=0; i<eventMcSelected.size(); ++i)
372  if(eventMcSelected[i]) {
373  numTotHltBitsAfterMcCuts[i][trhv->size()]++;
374  hHltBitsAfterMcCuts[i]->Fill(trhv->size());
375  hHltPathsAfterMcCuts[i]->Fill(trhv->size());
376  }
377 
378 
379 
380  if(firstEvent) {
381  if(l1Flag) myPlotMakerL1->bookHistos(dbe_,&l1bits,&hltbits,&l1Names_,&hlNames_);
382  myPlotMakerReco->bookHistos(dbe_,&l1bits,&hltbits,&l1Names_,&hlNames_);
383  // myTurnOnMaker->bookHistos();
384  }
385  if(l1Flag) myPlotMakerL1->fillPlots(iEvent);
386  myPlotMakerReco->fillPlots(iEvent);
387  // myTurnOnMaker->fillPlots(iEvent);
388 
389  firstEvent = false;
390 
391  myMuonAnalyzer->FillPlots(iEvent, iSetup);
392  l1bits.clear();
393  hltbits.clear();
394 }
395 
396 
397 void TriggerValidator::beginJob(){
398 }
399 
400 
401 
402 // ------------ method called once each job just before starting event loop ------------
403 void TriggerValidator::beginRun(const edm::Run& run, const edm::EventSetup& c)
404 {
405 
406 
407  DQMStore *dbe_ = 0;
408  dbe_ = Service<DQMStore>().operator->();
409 
410  if (dbe_) {
411  dbe_->setCurrentFolder(dirname_);
412  dbe_->rmdir(dirname_);
413  }
414 
415  if (dbe_) {
416  dbe_->setCurrentFolder(dirname_);
417  }
418 
419 
420  bool changed(true);
421  // cout << "hltConfig_.init(run,c,processName_,changed) = " << (int) hltConfig_.init(run,c,processName_,changed) << endl;
422  // cout << "changed = " << (int) changed << endl;
423  if (hltConfig_.init(run,c,processName_,changed)) {
424  // cout << "AAAA" << endl;
425  if (changed) {
426  // cout << "BBBBBBB" << endl;
427  // check if trigger name in (new) config
428  if (triggerName_!="@") { // "@" means: analyze all triggers in config
429  // cout << "hltConfig_.size() = " << hltConfig_.size() << endl;
430  nHltPaths = hltConfig_.size();
431  const unsigned int triggerIndex(hltConfig_.triggerIndex(triggerName_));
432  if (triggerIndex>=nHltPaths) {
433 // cout << "HLTriggerOffline/SUSYBSM"
434 // << " TriggerName " << triggerName_
435 // << " not available in (new) config!" << endl;
436 // cout << "Available TriggerNames are: " << endl;
437  hltConfig_.dump("Triggers");
438  }
439  }
440  else {
441  // cout << "CCCCCCCC" << endl;
442  nHltPaths = hltConfig_.size();
443  }
444  }
445  } else {
446 // cout << "HLTriggerOffline/SUSYBSM"
447 // << " config extraction failure with process name "
448 // << processName_ << endl;
449  }
450 
451  // cout << "nHltPaths = " << nHltPaths << endl;
452  nL1Bits = 128;
453 
454 
455 
456  for(unsigned int i=0; i<reco_parametersets.size(); ++i) myRecoSelector.push_back(new RecoSelector(reco_parametersets[i]));
457  if(mcFlag) for(unsigned int i=0; i<mc_parametersets.size(); ++i) myMcSelector.push_back(new McSelector(mc_parametersets[i]));
458  if(l1Flag) myPlotMakerL1 = new PlotMakerL1(plotMakerL1Input);
459  myPlotMakerReco = new PlotMakerReco(plotMakerRecoInput);
460 // myTurnOnMaker = new TurnOnMaker(turnOn_params);
461  firstEvent = true;
462 
463  //resize the vectors ccording to the number of L1 paths
464  numTotL1BitsBeforeCuts.resize(nL1Bits+1);
465  numTotL1BitsAfterRecoCuts.resize(reco_parametersets.size());
466  for(unsigned int i=0; i<numTotL1BitsAfterRecoCuts.size(); ++i) numTotL1BitsAfterRecoCuts[i].resize(nL1Bits+1);
467  numTotL1BitsAfterMcCuts.resize(mc_parametersets.size());
468  for(unsigned int i=0; i<numTotL1BitsAfterMcCuts.size(); ++i) numTotL1BitsAfterMcCuts[i].resize(nL1Bits+1);
469 
470  //resize the vectors ccording to the number of HLT paths
471  numTotHltBitsBeforeCuts.resize(nHltPaths+1);
472  numTotHltBitsAfterRecoCuts.resize(reco_parametersets.size());
473  for(unsigned int i=0; i<numTotHltBitsAfterRecoCuts.size(); ++i) numTotHltBitsAfterRecoCuts[i].resize(nHltPaths+1);
474  numTotHltBitsAfterMcCuts.resize(mc_parametersets.size());
475  for(unsigned int i=0; i<numTotHltBitsAfterMcCuts.size(); ++i) numTotHltBitsAfterMcCuts[i].resize(nHltPaths+1);
476 
477  if (dbe_) {
478  dbe_->setCurrentFolder(dirname_);
479  dbe_->rmdir(dirname_);
480  }
481 
482 
483  if (dbe_) {
484  dbe_->setCurrentFolder(dirname_);
485  }
486 
487  dbe_->setCurrentFolder(dirname_+triggerBitsDir);
488  //add 1 bin for the Total
489  hL1BitsBeforeCuts = dbe_->book1D("L1Bits", "L1 Trigger Bits",nL1Bits+1, 0, nL1Bits+1);
490  hHltBitsBeforeCuts = dbe_->book1D("HltBits","HL Trigger Bits",nHltPaths+1, 0, nHltPaths+1);
491 // hL1OverlapNormToTotal = dbe_->book2D("L1OverlapNormToTotal" ,"Overlap among L1 paths, norm to the Total number of Events", 1, 0, 1, 1, 0, 1);
492 // hHltOverlapNormToTotal = dbe_->book2D("HltOverlapNormToTotal" ,"Overlap among Hlt paths, norm to the Total number of Events ", 1, 0, 1, 1, 0, 1);
493 // hL1OverlapNormToLargestPath = dbe_->book2D("L1OverlapNormToLargestPath" ,"Overlap among L1 paths, norm to the Largest of the couple ", 1, 0, 1, 1, 0, 1);
494 // hHltOverlapNormToLargestPath = dbe_->book2D("HltOverlapNormToLargestPath","Overlap among Hlt paths, norm to the Largest of the couple ", 1, 0, 1, 1, 0, 1);
495 
496  for(unsigned int i=0; i<myRecoSelector.size(); ++i)
497  {
498  string path_name = myRecoSelector[i]->GetName();
499  char histo_name[256], histo_title[256];
500  //sprintf(histo_name, "L1Bits");
501  sprintf(histo_name, "L1Bits_%s", path_name.c_str());
502  sprintf(histo_title, "L1 Trigger Bits for %s Selection", path_name.c_str());
503  dbe_->setCurrentFolder(dirname_+recoSelBitsDir+"/"+path_name);
504  hL1BitsAfterRecoCuts.push_back(dbe_->book1D(histo_name, histo_title, nL1Bits+1, 0, nL1Bits+1));
505  //sprintf(histo_name, "HltBits");
506  sprintf(histo_name, "HltBits_%s", path_name.c_str());
507  sprintf(histo_title, "HL Trigger Bits for %s Selection", path_name.c_str());
508  hHltBitsAfterRecoCuts.push_back(dbe_->book1D(histo_name, histo_title, nHltPaths+1, 0, nHltPaths+1));
509  }
510  for(unsigned int i=0; i<myMcSelector.size(); ++i)
511  {
512  string path_name = myMcSelector[i]->GetName();
513  char histo_name[256], histo_title[256];
514  //sprintf(histo_name, "L1Bits");
515  sprintf(histo_name, "L1Bits_%s", path_name.c_str());
516  sprintf(histo_title, "L1 Trigger Bits for %s Selection", path_name.c_str());
517  dbe_->setCurrentFolder(dirname_+mcSelBitsDir+"/"+path_name);
518  hL1BitsAfterMcCuts.push_back(dbe_->book1D(histo_name, histo_title, nL1Bits+1, 0, nL1Bits+1));
519  //sprintf(histo_name, "HltBits");
520  sprintf(histo_name, "HltBits_%s", path_name.c_str());
521  sprintf(histo_title, "HL Trigger Bits for %s Selection", path_name.c_str());
522  hHltBitsAfterMcCuts.push_back(dbe_->book1D(histo_name, histo_title, nHltPaths+1, 0, nHltPaths+1));
523  }
524 
525  //create the histos with paths
526  //identical to the ones with "bits"
527  //but with the names in the x axis
528  //instead of the numbers
529 
530  dbe_->setCurrentFolder(dirname_+triggerBitsDir);
531  TH1F* hTemp = (TH1F*) (hL1BitsBeforeCuts->getTH1F())->Clone("L1Paths");
532  hL1PathsBeforeCuts = dbe_->book1D("L1Paths", hTemp);
533  // hL1PathsBeforeCuts = dbe_->book1D("L1Paths", hL1BitsBeforeCuts->getTH1F());
534  hTemp = (TH1F*) (hHltBitsBeforeCuts->getTH1F())->Clone("HltPaths");
535  hHltPathsBeforeCuts = dbe_->book1D("HltPaths", hTemp);
536 
537  for(unsigned int i=0; i<myRecoSelector.size(); ++i)
538  {
539  string path_name = myRecoSelector[i]->GetName();
540  char histo_name[256];
541  //sprintf(histo_name, "L1Paths");
542  sprintf(histo_name, "L1Paths_%s", path_name.c_str());
543  dbe_->setCurrentFolder(dirname_+recoSelBitsDir+"/"+path_name);
544  hTemp = (TH1F*) (hL1BitsAfterRecoCuts[i]->getTH1F())->Clone(histo_name);
545  hL1PathsAfterRecoCuts.push_back(dbe_->book1D(histo_name, hTemp));
546  //sprintf(histo_name, "HltPaths");
547  sprintf(histo_name, "HltPaths_%s", path_name.c_str());
548  hTemp = (TH1F*) (hHltBitsAfterRecoCuts[i]->getTH1F())->Clone(histo_name);
549  hHltPathsAfterRecoCuts.push_back(dbe_->book1D(histo_name, hTemp));
550  }
551 
552  for(unsigned int i=0; i<myMcSelector.size(); ++i)
553  {
554  string path_name = myMcSelector[i]->GetName();
555  char histo_name[256];
556  //sprintf(histo_name, "L1Paths");
557  sprintf(histo_name, "L1Paths_%s", path_name.c_str());
558  dbe_->setCurrentFolder(dirname_+mcSelBitsDir+"/"+path_name);
559  hTemp = (TH1F*) (hL1BitsAfterMcCuts[i]->getTH1F())->Clone(histo_name);
560  hL1PathsAfterMcCuts.push_back(dbe_->book1D(histo_name, hTemp));
561  //sprintf(histo_name, "HltPaths");
562  sprintf(histo_name, "HltPaths_%s", path_name.c_str());
563  hTemp = (TH1F*) (hHltBitsAfterMcCuts[i]->getTH1F())->Clone(histo_name);
564  hHltPathsAfterMcCuts.push_back(dbe_->book1D(histo_name, hTemp));
565  }
566 
567  myMuonAnalyzer = new MuonAnalyzerSBSM(triggerTag_, muonTag_);
568  myMuonAnalyzer->InitializePlots(dbe_, dirname_);
569 }
570 
571 
572 
573 
574 // ------------ method called once each job just after ending the event loop ------------
575 void
576 TriggerValidator::endRun(const edm::Run& run, const edm::EventSetup& c)
577 {
578 
579  // myTurnOnMaker->finalOperations();
580 
581  //This piece of code concerns efficiencies
582  //it must be moved to the client
583 
584 
585 
586 // //calculate the final efficiencies and the normalizations
587 // for(unsigned int i=0; i<numTotL1BitsBeforeCuts.size()-1; i++) {
588 // effL1BeforeCuts[i] = (double)numTotL1BitsBeforeCuts[i]/(double)nEvTot;
589 // for(unsigned int j=0; j<numTotL1BitsBeforeCuts.size()-1; j++) {
590 // vCorrNormL1[i][j] = (double)vCorrL1[i][j]/(double)nEvTot;
591 // }
592 // }
593 
594 // for(unsigned int i=0; i<numTotHltBitsBeforeCuts.size()-1; i++) {
595 // effHltBeforeCuts[i] = (double)numTotHltBitsBeforeCuts[i]/(double)nEvTot;
596 // for(unsigned int j=0; j<numTotHltBitsBeforeCuts.size()-1; j++) {
597 // vCorrNormHlt[i][j] = (double)vCorrHlt[i][j]/(double)nEvTot;
598 // }
599 // }
600 
601 // //after the reco cuts
602 
603 // if(nEvRecoSelected) {
604 // for(unsigned int i=0; i<numTotL1BitsAfterRecoCuts.size()-1; i++) {
605 // effL1AfterRecoCuts[i] = (double)numTotL1BitsAfterRecoCuts[i]/(double)nEvRecoSelected;
606 // }
607 
608 // for(unsigned int i=0; i<numTotHltBitsAfterRecoCuts.size()-1; i++) {
609 // effHltAfterRecoCuts[i] = (double)numTotHltBitsAfterRecoCuts[i]/(double)nEvRecoSelected;
610 // }
611 // } else {
612 
613 // for(unsigned int i=0; i<numTotL1BitsAfterRecoCuts.size()-1; i++) {
614 // effL1AfterRecoCuts[i] = -1;
615 // }
616 
617 // for(unsigned int i=0; i<numTotHltBitsAfterRecoCuts.size()-1; i++) {
618 // effHltAfterRecoCuts[i] = -1;
619 // }
620 // }
621 
622 
623 // //after the mc cuts
624 // if(nEvMcSelected) {
625 // for(unsigned int i=0; i<numTotL1BitsAfterMcCuts.size()-1; i++) {
626 // effL1AfterMcCuts[i] = (double)numTotL1BitsAfterMcCuts[i]/(double)nEvMcSelected;
627 // }
628 
629 // for(unsigned int i=0; i<numTotHltBitsAfterMcCuts.size()-1; i++) {
630 // effHltAfterMcCuts[i] = (double)numTotHltBitsAfterMcCuts[i]/(double)nEvMcSelected;
631 // }
632 // } else {
633 // for(unsigned int i=0; i<numTotL1BitsAfterMcCuts.size()-1; i++) {
634 // effL1AfterMcCuts[i] = -1;
635 // }
636 
637 // for(unsigned int i=0; i<numTotHltBitsAfterMcCuts.size()-1; i++) {
638 // effHltAfterMcCuts[i] = -1;
639 // }
640 // }
641 
642 
643 
644 
645 
646 
647 
648 
649 // myPlotMaker->writeHistos();
650 // myTurnOnMaker->writeHistos();
651 
652 
653  // using namespace std;
654 
655  unsigned int n(l1Names_.size());
656 
657  n = l1Names_.size();
658  edm::LogInfo("L1TableSummary") << endl;
659  edm::LogVerbatim("L1TableSummary") << "L1T-Table "
660  << right << setw(10) << "L1T Bit#" << " "
661  << "Name" << "\n";
662  for (unsigned int i=0; i!=n; i++) {
663  edm::LogVerbatim("L1TableSummary") << right << setw(20) << i << " "
664  << l1Names_[i] << "\n";
665  }
666 
667 
668  n = hlNames_.size();
669  edm::LogInfo("HltTableSummary") << endl;
670  edm::LogVerbatim("HltTableSummary") << "HLT-Table "
671  << right << setw(10) << "HLT Bit#" << " "
672  << "Name" << "\n";
673 
674  for (unsigned int i=0; i!=n; i++) {
675  edm::LogVerbatim("HltTableSummary") << right << setw(20) << i << " "
676  << hlNames_[i] << "\n";
677  }
678 
679  edm::LogVerbatim("HltTableSummary") << endl;
680  edm::LogVerbatim("HltTableSummary") << "HLT-Table end!" << endl;
681  edm::LogVerbatim("HltTableSummary") << endl;
682 
683 
684 
685  //the stat file with the efficiecies has to be moved to the client
686 
687 
688 
689 // //Print in a stat file the efficiencies and the overlaps
690 
691 
692 // ofstream statFile(StatFileName.c_str(),ios::out);
693 
694 
695 // statFile << "*********************************************************************************" << endl;
696 // statFile << "*********************************************************************************" << endl;
697 // statFile << " L1 Efficiencies " << endl;
698 // statFile << "*********************************************************************************" << endl;
699 // statFile << "*********************************************************************************" << endl;
700 // statFile << endl;
701 // statFile << "---------------------------------------------------------------------------------" << endl;
702 // statFile << "---------------------------------------------------------------------------------" << endl;
703 // statFile << "| L1 Path | eff (Tot) | eff (Reco Sel)| eff (Mc Sel) |" << endl;
704 // statFile << "---------------------------------------------------------------------------------" << endl;
705 // statFile << "---------------------------------------------------------------------------------" << endl;
706 // for(unsigned int i=0; i<numTotL1BitsBeforeCuts.size()-1; i++) {
707 // statFile << "| " << left << setw(29) << l1Names_[i] << "|" << setprecision(3) << showpoint << right << setw(13) << effL1BeforeCuts[i] << " |" <<
708 // setw(13) << effL1AfterRecoCuts[i] << " |" <<
709 // setw(13) << effL1AfterMcCuts[i] << " |" << endl;
710 // }
711 // statFile << "---------------------------------------------------------------------------------" << endl;
712 // statFile << "---------------------------------------------------------------------------------" << endl;
713 // statFile << endl;
714 // statFile << endl;
715 // statFile << endl;
716 // statFile << endl;
717 // statFile << endl;
718 // statFile << endl;
719 
720 
721 
722 // statFile << "**********************************************************************************" << endl;
723 // statFile << "**********************************************************************************" << endl;
724 // statFile << " Hlt Efficiencies " << endl;
725 // statFile << "**********************************************************************************" << endl;
726 // statFile << "**********************************************************************************" << endl;
727 // statFile << endl;
728 // statFile << "----------------------------------------------------------------------------------" << endl;
729 // statFile << "----------------------------------------------------------------------------------" << endl;
730 // statFile << "| Hlt Path | eff (Tot) | eff (Reco Sel)| eff (Mc Sel) |" << endl;
731 // statFile << "----------------------------------------------------------------------------------" << endl;
732 // statFile << "----------------------------------------------------------------------------------" << endl;
733 // for(unsigned int i=0; i<numTotHltBitsBeforeCuts.size()-1; i++) {
734 // statFile << "| " << left << setw(29) << hlNames_[i] << "|" << setprecision(3) << showpoint << right << setw(13) << effHltBeforeCuts[i] << " |" <<
735 // setw(13) << effHltAfterRecoCuts[i] << " |" <<
736 // setw(13) << effHltAfterMcCuts[i] << " |" <<endl;
737 // }
738 // statFile << "----------------------------------------------------------------------------------" << endl;
739 // statFile << "----------------------------------------------------------------------------------" << endl;
740 // statFile << endl;
741 // statFile << endl;
742 // statFile << endl;
743 // statFile << endl;
744 // statFile << endl;
745 // statFile << endl;
746 
747 
748 
749 
750 
751 // statFile << "****************************************************************************************************************************************************" << endl;
752 // statFile << "****************************************************************************************************************************************************" << endl;
753 // statFile << " L1 Correlations (only overlaps >5% are shown, and only without any selection) " << endl;
754 // statFile << "****************************************************************************************************************************************************" << endl;
755 // statFile << "****************************************************************************************************************************************************" << endl;
756 // statFile << endl;
757 // statFile << "----------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
758 // statFile << "----------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
759 // statFile << "| L1 Path 1 | L1 Path 2 | Overlap Norm to Total | Overlap Norm to Path | Path of Norm |" << endl;
760 // statFile << "----------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
761 // statFile << "----------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
762 // statFile << endl;
763 // for(unsigned int i=0; i<numTotL1BitsBeforeCuts.size()-1; i++) {
764 // for(unsigned int j=0; j<numTotL1BitsBeforeCuts.size()-1; j++) {
765 // if(vCorrNormL1[i][j]>0.05) {
766 // int iNorm = 0;
767 // if(effL1BeforeCuts[i] > effL1BeforeCuts[j]) {iNorm = i;}
768 // else {iNorm = j;}
769 // double effNorm = vCorrNormL1[i][j] / effL1BeforeCuts[iNorm];
770 // statFile << "| " << left << setw(29) << l1Names_[i] << "| " << setw(29) << left << l1Names_[j] << "|"
771 // << setprecision(3) << showpoint << right << setw(22) << vCorrNormL1[i][j] << " |"
772 // << setprecision(3) << showpoint << right << setw(21) << effNorm << " | "
773 // << left << setw(29) << l1Names_[iNorm] << "|" << endl;
774 // }
775 // }
776 // statFile << "----------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
777 // }
778 // statFile << "----------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
779 // statFile << "----------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
780 // statFile << endl;
781 // statFile << endl;
782 // statFile << endl;
783 // statFile << endl;
784 // statFile << endl;
785 // statFile << endl;
786 
787 
788 // statFile << "****************************************************************************************************************************************************" << endl;
789 // statFile << "****************************************************************************************************************************************************" << endl;
790 // statFile << " Hlt Correlations (only overlaps >5% are shown, and only without any selection) " << endl;
791 // statFile << "****************************************************************************************************************************************************" << endl;
792 // statFile << "****************************************************************************************************************************************************" << endl;
793 // statFile << endl;
794 // statFile << "----------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
795 // statFile << "----------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
796 // statFile << "| Hlt Path 1 | Hlt Path 2 | Overlap Norm to Total | Overlap Norm to Path | Path of Norm |" << endl;
797 // statFile << "----------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
798 // statFile << "----------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
799 // statFile << endl;
800 // for(unsigned int i=0; i<numTotHltBitsBeforeCuts.size()-1; i++) {
801 // for(unsigned int j=0; j<numTotHltBitsBeforeCuts.size()-1; j++) {
802 // if(vCorrNormHlt[i][j]>0.05) {
803 // int iNorm = 0;
804 // if(effHltBeforeCuts[i] > effHltBeforeCuts[j]) {iNorm = i;}
805 // else {iNorm = j;}
806 // double effNorm = vCorrNormHlt[i][j]/effHltBeforeCuts[iNorm];
807 // statFile << "| " << left << setw(29) << hlNames_[i] << "| " << setw(29) << left << hlNames_[j] << "|"
808 // << setprecision(3) << showpoint << right << setw(22) << vCorrNormHlt[i][j] << " |"
809 // << setprecision(3) << showpoint << right << setw(21) << effNorm << " | "
810 // << left << setw(29) << hlNames_[iNorm] << "|" << endl;
811 // }
812 // }
813 // statFile << "----------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
814 // }
815 // statFile << "----------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
816 // statFile << "----------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
817 // statFile << endl;
818 // statFile << endl;
819 // statFile << endl;
820 // statFile << endl;
821 // statFile << endl;
822 // statFile << endl;
823 
824 
825 
826 
827 // statFile.close();
828 
829 
830  for(unsigned int i=0; i<myRecoSelector.size(); ++i) delete myRecoSelector[i];
831  myRecoSelector.clear();
832  if(mcFlag)
833  {
834  for(unsigned int i=0; i<myMcSelector.size(); ++i) delete myMcSelector[i];
835  myMcSelector.clear();
836  }
837 
838  if(l1Flag) delete myPlotMakerL1;
839  delete myPlotMakerReco;
840 // delete myTurnOnMaker;
841  return;
842 }
843 
844 
845 // - method called once each job just after ending the event loop ------------
846 void
847 TriggerValidator::endJob()
848 {
849  LogInfo("TriggerValidator") << "endJob";
850  return;
851 }
852 
853 
854 
855 
856 
857 
858 //define this as a plug-in
859 DEFINE_FWK_MODULE(TriggerValidator);
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:501
HLTConfigProvider::size
unsigned int size() const
number of trigger paths in trigger table
Definition: HLTConfigProvider.h:90
TriggerValidator::hHltBitsAfterRecoCuts
std::vector< MonitorElement * > hHltBitsAfterRecoCuts
Definition: TriggerValidator.h:156
HLTConfigProvider::dump
void dump(const std::string &what) const
Dumping config info to cout.
Definition: HLTConfigProvider.h:59
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
i
int i
Definition: DBlmapReader.cc:9
TriggerValidator::vCorrNormL1
std::vector< std::vector< double > > vCorrNormL1
Definition: TriggerValidator.h:142
edm::Event::triggerNames
virtual edm::TriggerNames const & triggerNames(edm::TriggerResults const &triggerResults) const
Definition: Event.cc:199
TriggerValidator::dirname_
std::string dirname_
Definition: TriggerValidator.h:74
TriggerValidator::myMcSelector
std::vector< McSelector * > myMcSelector
Definition: TriggerValidator.h:89
DQMStore::book1D
MonitorElement * book1D(const char *name, const char *title, int nchX, double lowX, double highX)
Book 1D histogram.
Definition: DQMStore.cc:717
DQMStore::rmdir
void rmdir(const std::string &fullpath)
Definition: DQMStore.cc:2530
TriggerValidator::hL1PathsAfterRecoCuts
std::vector< MonitorElement * > hL1PathsAfterRecoCuts
Definition: TriggerValidator.h:162
TriggerValidator::endRun
void endRun(const edm::Run &run, const edm::EventSetup &c)
Definition: TriggerValidator.cc:576
TriggerValidator::hHltPathsAfterRecoCuts
std::vector< MonitorElement * > hHltPathsAfterRecoCuts
Definition: TriggerValidator.h:163
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:17
TriggerValidator::nHltPaths
unsigned int nHltPaths
Definition: TriggerValidator.h:83
edm::VParameterSet
std::vector< ParameterSet > VParameterSet
Definition: ParameterSet.h:33
TriggerValidator::numTotHltBitsBeforeCuts
std::vector< int > numTotHltBitsBeforeCuts
Definition: TriggerValidator.h:125
TriggerValidator::hHltPathsAfterMcCuts
std::vector< MonitorElement * > hHltPathsAfterMcCuts
Definition: TriggerValidator.h:165
MonitorElement::setBinLabel
void setBinLabel(int bin, const std::string &label, int axis=1)
set bin label for x, y or z axis (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:889
TriggerValidator::myMuonAnalyzer
MuonAnalyzerSBSM * myMuonAnalyzer
Definition: TriggerValidator.h:179
PlotMakerL1::fillPlots
void fillPlots(const edm::Event &)
Definition: PlotMakerL1.cc:33
TriggerValidator::myPlotMakerReco
PlotMakerReco * myPlotMakerReco
Definition: TriggerValidator.h:93
TriggerValidator::l1Names_
std::vector< std::string > l1Names_
Definition: TriggerValidator.h:118
MuonAnalyzerSBSM::FillPlots
void FillPlots(const edm::Event &, const edm::EventSetup &)
Definition: MuonAnalyzer.cc:59
edm::TriggerNames::triggerNames
Strings const & triggerNames() const
Definition: TriggerNames.cc:24
edm::InputTag::encode
std::string encode() const
Definition: InputTag.cc:72
TriggerValidator::hL1BitsAfterMcCuts
std::vector< MonitorElement * > hL1BitsAfterMcCuts
Definition: TriggerValidator.h:157
TriggerValidator::vCorrL1
std::vector< std::vector< int > > vCorrL1
Definition: TriggerValidator.h:140
TriggerValidator::nEvRecoSelected
std::vector< int > nEvRecoSelected
Definition: TriggerValidator.h:146
TriggerValidator::numTotHltBitsAfterMcCuts
std::vector< std::vector< int > > numTotHltBitsAfterMcCuts
Definition: TriggerValidator.h:129
MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:152
TriggerValidator::hL1PathsAfterMcCuts
std::vector< MonitorElement * > hL1PathsAfterMcCuts
Definition: TriggerValidator.h:164
HLTConfigProvider::triggerIndex
unsigned int triggerIndex(const std::string &triggerName) const
slot position of trigger path in trigger table (0 to size-1)
Definition: HLTConfigProvider.h:110
TriggerValidator::hL1BitsAfterRecoCuts
std::vector< MonitorElement * > hL1BitsAfterRecoCuts
Definition: TriggerValidator.h:155
TriggerValidator::nEvMcSelected
std::vector< int > nEvMcSelected
Definition: TriggerValidator.h:147
TriggerValidator::myRecoSelector
std::vector< RecoSelector * > myRecoSelector
Definition: TriggerValidator.h:88
iEvent
int iEvent
Definition: GenABIO.cc:243
TriggerValidator::triggerName_
std::string triggerName_
Definition: TriggerValidator.h:116
TriggerValidator::hHltPathsBeforeCuts
MonitorElement * hHltPathsBeforeCuts
Definition: TriggerValidator.h:161
PlotMakerL1::bookHistos
void bookHistos(DQMStore *, std::vector< int > *, std::vector< int > *, std::vector< std::string > *, std::vector< std::string > *)
Definition: PlotMakerL1.cc:359
edm::ParameterSet::addParameter
void addParameter(std::string const &name, T const &value)
Definition: ParameterSet.h:145
PlotMakerReco::fillPlots
void fillPlots(const edm::Event &)
Definition: PlotMakerReco.cc:53
j
int j
Definition: DBlmapReader.cc:9
TriggerValidator::beginRun
void beginRun(const edm::Run &run, const edm::EventSetup &c)
Definition: TriggerValidator.cc:403
TriggerValidator::recoSelBitsDir
std::string recoSelBitsDir
Definition: TriggerValidator.h:78
TriggerValidator::beginJob
virtual void beginJob()
Definition: TriggerValidator.cc:397
getTH1F
TH1F * getTH1F(std::string name, std::string process, std::string rootfolder, DQMStore *dbe_, bool verb, bool clone)
Definition: HcalHistoUtils.h:57
TriggerValidator::triggerTag_
edm::InputTag triggerTag_
Definition: TriggerValidator.h:114
DQMStore::setVerbose
void setVerbose(unsigned level)
Definition: DQMStore.cc:393
TriggerValidator::myPlotMakerL1
PlotMakerL1 * myPlotMakerL1
Definition: TriggerValidator.h:92
TriggerValidator::mcSelBitsDir
std::string mcSelBitsDir
Definition: TriggerValidator.h:79
TriggerValidator::hL1PathsBeforeCuts
MonitorElement * hL1PathsBeforeCuts
Definition: TriggerValidator.h:160
edm::Event::getByLabel
bool getByLabel(InputTag const &tag, Handle< PROD > &result) const
Definition: Event.h:356
TriggerValidator::triggerBitsDir
std::string triggerBitsDir
Definition: TriggerValidator.h:77
TriggerValidator::hlNames_
std::vector< std::string > hlNames_
Definition: TriggerValidator.h:120
TriggerValidator::hltLabel
edm::InputTag hltLabel
Definition: TriggerValidator.h:100
TriggerValidator::vCorrNormHlt
std::vector< std::vector< double > > vCorrNormHlt
Definition: TriggerValidator.h:143
TriggerValidator::numTotL1BitsBeforeCuts
std::vector< int > numTotL1BitsBeforeCuts
Definition: TriggerValidator.h:124
PlotMakerReco::bookHistos
void bookHistos(DQMStore *, std::vector< int > *, std::vector< int > *, std::vector< std::string > *, std::vector< std::string > *)
Definition: PlotMakerReco.cc:357
TriggerValidator::l1bits
std::vector< int > l1bits
Definition: TriggerValidator.h:174
create_public_lumi_plots.path_name
tuple path_name
Definition: create_public_lumi_plots.py:615
HLTConfigProvider::init
bool init(const edm::Run &iRun, const edm::EventSetup &iSetup, const std::string &processName, bool &changed)
d&#39;tor
Definition: HLTConfigProvider.cc:67
MonitorElement::getTH1F
TH1F * getTH1F(void) const
Definition: MonitorElement.cc:1486
TriggerValidator::hHltBitsAfterMcCuts
std::vector< MonitorElement * > hHltBitsAfterMcCuts
Definition: TriggerValidator.h:158
TriggerValidator::hltbits
std::vector< int > hltbits
Definition: TriggerValidator.h:175
TriggerValidator::processName_
std::string processName_
Definition: TriggerValidator.h:115
TriggerValidator::numTotHltBitsAfterRecoCuts
std::vector< std::vector< int > > numTotHltBitsAfterRecoCuts
Definition: TriggerValidator.h:127
TriggerValidator::reco_parametersets
std::vector< edm::ParameterSet > reco_parametersets
Definition: TriggerValidator.h:107
TriggerValidator::plotMakerRecoInput
edm::ParameterSet plotMakerRecoInput
Definition: TriggerValidator.h:111
TriggerValidator::analyze
virtual void analyze(const edm::Event &, const edm::EventSetup &)
Definition: TriggerValidator.cc:161
TriggerValidator::numTotL1BitsAfterRecoCuts
std::vector< std::vector< int > > numTotL1BitsAfterRecoCuts
Definition: TriggerValidator.h:126
TriggerValidator::hltConfig_
HLTConfigProvider hltConfig_
Definition: TriggerValidator.h:75
TriggerValidator::endJob
virtual void endJob()
Definition: TriggerValidator.cc:847
TriggerValidator::vCorrHlt
std::vector< std::vector< int > > vCorrHlt
Definition: TriggerValidator.h:141
TriggerValidator::plotMakerL1Input
edm::ParameterSet plotMakerL1Input
Definition: TriggerValidator.h:110
MuonAnalyzerSBSM::InitializePlots
void InitializePlots(DQMStore *, const std::string)
Definition: MuonAnalyzer.cc:257
TriggerValidator::hL1BitsBeforeCuts
MonitorElement * hL1BitsBeforeCuts
Definition: TriggerValidator.h:153
TriggerValidator::numTotL1BitsAfterMcCuts
std::vector< std::vector< int > > numTotL1BitsAfterMcCuts
Definition: TriggerValidator.h:128
TriggerValidator::TriggerValidator
TriggerValidator(const edm::ParameterSet &)
Definition: TriggerValidator.cc:85
TriggerValidator::muonTag_
edm::InputTag muonTag_
Definition: TriggerValidator.h:113
DQMStore::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:429
TriggerValidator::hHltBitsBeforeCuts
MonitorElement * hHltBitsBeforeCuts
Definition: TriggerValidator.h:154
TriggerValidator::l1Label
edm::InputTag l1Label
Definition: TriggerValidator.h:99
edm::Run
Definition: Run.h:33
TriggerValidator::l1NameMap
std::map< int, std::string > l1NameMap
Definition: TriggerValidator.h:71
TriggerValidator::mc_parametersets
std::vector< edm::ParameterSet > mc_parametersets
Definition: TriggerValidator.h:108
Generated for CMSSW Reference Manual by doxygen 1.8.5