CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
L1TdeRCT.cc
Go to the documentation of this file.
1 /*
2  * \file L1TdeRCT.cc
3  *
4  * version 0.0 A.Savin 2008/04/26
5  * version 1.0 A.Savin 2008/05/05
6  * this version contains single channel histos and 1D efficiencies
7  */
8 
9 
10 
11 
12 
13 #include "DQM/L1TMonitor/interface/L1TdeRCT.h"
14 
15 #include "FWCore/Framework/interface/ESHandle.h"
16 #include "DataFormats/Provenance/interface/EventAuxiliary.h"
17 
18 #include "TF2.h"
19 
20 #include <iostream>
21 #include <bitset>
22 
23 #include "CondFormats/RunInfo/interface/RunInfo.h"
24 #include "CondFormats/DataRecord/interface/RunSummaryRcd.h"
25 
26 
27 using namespace edm;
28 using namespace std;
29 
30 const unsigned int PHIBINS = 18;
31 const float PHIMIN = -0.5;
32 const float PHIMAX = 17.5;
33 
34 const unsigned int ETABINS = 22;
35 const float ETAMIN = -0.5;
36 const float ETAMAX = 21.5;
37 
38 const unsigned int BITETABINS = 44;
39 const float BITETAMIN = 0;
40 const float BITETAMAX = 22;
41 
42 const unsigned int BITPHIBINS = 72;
43 const float BITPHIMIN = 0;
44 const float BITPHIMAX = 18;
45 
46 const unsigned int BITRPHIBINS = 90;
47 const float BITRPHIMIN = 0;
48 const float BITRPHIMAX = 18;
49 
50 const unsigned int TPGPHIBINS = 72;
51 const float TPGPHIMIN = -0.5;
52 const float TPGPHIMAX = 71.5;
53 
54 const unsigned int TPGETABINS = 64;
55 const float TPGETAMIN = -32.;
56 const float TPGETAMAX = 32.;
57 
58 const unsigned int TPGRANK = 256;
59 const float TPGRANKMIN = -.5;
60 const float TPGRANKMAX = 255.5;
61 
62 const unsigned int DEBINS = 127;
63 const float DEMIN = -63.5;
64 const float DEMAX = 63.5;
65 
66 const unsigned int ELBINS = 64;
67 const float ELMIN = -.5;
68 const float ELMAX = 63.5;
69 
70 const unsigned int PhiEtaMax = 396;
71 const unsigned int CHNLBINS = 396;
72 const float CHNLMIN = -0.5;
73 const float CHNLMAX = 395.5;
74 
75 bool first = true ;
76 
77 
78 const int L1TdeRCT::crateFED[90]=
79  {613, 614, 603, 702, 718,
80  611, 612, 602, 700, 718,
81  627, 610, 601,716, 722,
82  625, 626, 609, 714, 722,
83  623, 624, 608, 712, 722,
84  621, 622, 607, 710, 720,
85  619, 620, 606, 708, 720,
86  617, 618, 605, 706, 720,
87  615, 616, 604, 704, 718,
88  631, 632, 648, 703, 719,
89  629, 630, 647, 701, 719,
90  645, 628, 646, 717, 723,
91  643, 644, 654, 715, 723,
92  641, 642, 653, 713, 723,
93  639, 640, 652, 711, 721,
94  637, 638, 651, 709, 721,
95  635, 636, 650, 707, 721,
96  633, 634, 649, 705, 719
97 };
98 
99 
100 
101 L1TdeRCT::L1TdeRCT(const ParameterSet & ps) :
102  rctSourceEmul_rgnEmul_( consumes<L1CaloRegionCollection>(ps.getParameter< InputTag >("rctSourceEmul") )),
103  rctSourceEmul_emEmul_( consumes<L1CaloEmCollection>(ps.getParameter< InputTag >("rctSourceEmul") )),
104  rctSourceData_rgnData_( consumes<L1CaloRegionCollection>(ps.getParameter< InputTag >("rctSourceData") )),
105  rctSourceData_emData_( consumes<L1CaloEmCollection>(ps.getParameter< InputTag >("rctSourceData") )),
106  ecalTPGData_( consumes<EcalTrigPrimDigiCollection>(ps.getParameter< InputTag >("ecalTPGData") )),
107  hcalTPGData_( consumes<HcalTrigPrimDigiCollection>(ps.getParameter< InputTag >("hcalTPGData") )),
108  gtDigisLabel_( consumes<L1GlobalTriggerReadoutRecord>(ps.getParameter< InputTag >("gtDigisLabel") )),
109  gtEGAlgoName_ ( ps.getParameter< std::string >("gtEGAlgoName") ),
110  doubleThreshold_ ( ps.getParameter< int >("doubleThreshold") ),
111  filterTriggerType_ (ps.getParameter< int >("filterTriggerType") )
112 {
113 
114 
115 
116  singlechannelhistos_ = ps.getUntrackedParameter < bool > ("singlechannelhistos", false);
117 
118  if (singlechannelhistos_)
119  if(verbose_) std::cout << "L1TdeRCT: single channels histos ON" << std::endl;
120 
121  // verbosity switch
122  verbose_ = ps.getUntrackedParameter < bool > ("verbose", false);
123 
124  if (verbose_)
125  std::cout << "L1TdeRCT: constructor...." << std::endl;
126 
127 
128  dbe = NULL;
129  if (ps.getUntrackedParameter < bool > ("DQMStore", false)) {
130  dbe = Service < DQMStore > ().operator->();
131  dbe->setVerbose(0);
132  }
133 
134  outputFile_ =
135  ps.getUntrackedParameter < std::string > ("outputFile", "");
136  if (outputFile_.size() != 0) {
137  if(verbose_) std::
138  cout << "L1T Monitoring histograms will be saved to " <<
139  outputFile_.c_str() << std::endl;
140  }
141 
142  bool disable =
143  ps.getUntrackedParameter < bool > ("disableROOToutput", false);
144  if (disable) {
145  outputFile_ = "";
146  }
147 
148  histFolder_
149  = ps.getUntrackedParameter<std::string>("HistFolder", "L1TEMU/L1TdeRCT");
150 
151  if (dbe != NULL) {
152  dbe->setCurrentFolder(histFolder_);
153  }
154 
155 
156 
157 }
158 
159 L1TdeRCT::~L1TdeRCT()
160 {
161 }
162 
163 void L1TdeRCT::beginJob(void)
164 {
165  nev_ = 0;
166 }
167 
168 
169 void L1TdeRCT::endJob(void)
170 {
171  if (verbose_)
172  std::cout << "L1TdeRCT: end job...." << std::endl;
173  LogInfo("EndJob") << "analyzed " << nev_ << " events";
174 
175  if (outputFile_.size() != 0 && dbe)
176  dbe->save(outputFile_);
177 
178  //std::cout << "trig count is " << trigCount << std::endl;
179  //std::cout << "no trig count is " << notrigCount << std::endl;
180 
181 
182  return;
183 }
184 
185 void L1TdeRCT::analyze(const Event & e, const EventSetup & c)
186 {
187  nev_++;
188  if (verbose_) {
189  std::cout << "L1TdeRCT: analyze...." << std::endl;
190  }
191 
192  // filter according trigger type
193  // enum ExperimentType {
194  // Undefined = 0,
195  // PhysicsTrigger = 1,
196  // CalibrationTrigger = 2,
197  // RandomTrigger = 3,
198  // Reserved = 4,
199  // TracedEvent = 5,
200  // TestTrigger = 6,
201  // ErrorTrigger = 15
202 
203  // fill a histogram with the trigger type, for normalization fill also last bin
204  // ErrorTrigger + 1
205  double triggerType = static_cast<double> (e.experimentType()) + 0.001;
206  double triggerTypeLast = static_cast<double> (edm::EventAuxiliary::ExperimentType::ErrorTrigger)
207  + 0.001;
208  triggerType_->Fill(triggerType);
209  triggerType_->Fill(triggerTypeLast + 1);
210 
211  // filter only if trigger type is greater than 0, negative values disable filtering
212  if (filterTriggerType_ >= 0) {
213 
214  // now filter, for real data only
215  if (e.isRealData()) {
216  if (!(e.experimentType() == filterTriggerType_)) {
217 
218  edm::LogInfo("L1TdeRCT") << "\n Event of TriggerType "
219  << e.experimentType() << " rejected" << std::endl;
220  return;
221 
222  }
223  }
224 
225  }
226 
227  // for GT decision word
228  edm::Handle< L1GlobalTriggerReadoutRecord > gtRecord;
229 
230  // get GT decision word
231  e.getByToken( gtDigisLabel_ , gtRecord );
232  const DecisionWord dWord = gtRecord->decisionWord(); // this will get the decision word *before* masking disabled bits
233  int effEGThresholdBitNumber = 999;
234  if (gtEGAlgoName_ == "L1_SingleEG1")
235  {
236  effEGThresholdBitNumber = 46;
237  }
238  if (gtEGAlgoName_ == "L1_SingleEG5_0001")
239  {
240  effEGThresholdBitNumber = 47;
241  }
242  if (gtEGAlgoName_ == "L1_SingleEG8_0001")
243  {
244  effEGThresholdBitNumber = 48;
245  }
246  if (gtEGAlgoName_ == "L1_SingleEG10_0001")
247  {
248  effEGThresholdBitNumber = 49;
249  }
250  if (gtEGAlgoName_ == "L1_SingleEG12_0001")
251  {
252  effEGThresholdBitNumber = 50;
253  }
254  if (gtEGAlgoName_ == "L1_SingleEG15_0001")
255  {
256  effEGThresholdBitNumber = 51;
257  }
258  if (gtEGAlgoName_ == "L1_SingleEG20_0001")
259  {
260  effEGThresholdBitNumber = 52;
261  }
262 
263  int algoBitNumber = 0;
264  bool triggered = false;
265  bool independent_triggered = false;
266  DecisionWord::const_iterator algoItr;
267  for (algoItr = dWord.begin(); algoItr != dWord.end(); algoItr++)
268  {
269  if (*algoItr)
270  {
271  triggerAlgoNumbers_->Fill(algoBitNumber);
272  if (algoBitNumber == effEGThresholdBitNumber)
273  {
274  triggered = true;// Fill triggered events (numerator) here!
275  }
276  if (algoBitNumber <= 45 || algoBitNumber >= 53)
277  {
278  independent_triggered = true;// use the muon path only !
279  }
280  }
281  algoBitNumber++;
282  }
283 
284 
285  if(triggered)
286  trigCount++;
287  else
288  notrigCount++;
289 
290  // get TPGs
291  edm::Handle<EcalTrigPrimDigiCollection> ecalTpData;
292  edm::Handle<HcalTrigPrimDigiCollection> hcalTpData;
293 
294  // Get the RCT digis
295  edm::Handle < L1CaloEmCollection > emData;
296  edm::Handle < L1CaloRegionCollection > rgnData;
297 
298  // Get the RCT digis
299  edm::Handle < L1CaloEmCollection > emEmul;
300  edm::Handle < L1CaloRegionCollection > rgnEmul;
301 
302  // bool doEm = true; FIXME gcc461: variable 'doEm' set but not used
303  // bool doHd = true; FIXME gcc461: variable 'doHd' set but not used
304  bool doEcal = true;
305  bool doHcal = true;
306 
307  // TPG, first try:
308  e.getByToken(ecalTPGData_,ecalTpData);
309  e.getByToken(hcalTPGData_,hcalTpData);
310 
311  if (!ecalTpData.isValid()) {
312  edm::LogInfo("TPG DataNotFound") << "can't find EcalTrigPrimDigiCollection";
313  if (verbose_)std::cout << "Can not find ecalTpData!" << std::endl ;
314 
315  doEcal = false ;
316  }
317 
318  if(doEcal)
319  {
320  for(EcalTrigPrimDigiCollection::const_iterator iEcalTp = ecalTpData->begin(); iEcalTp != ecalTpData->end(); iEcalTp++)
321  if(iEcalTp->compressedEt() > 0)
322  {
323 
324  rctInputTPGEcalRank_ -> Fill(1.*(iEcalTp->compressedEt())) ;
325 
326  if(iEcalTp->id().ieta() > 0)
327  {
328  rctInputTPGEcalOccNoCut_ -> Fill(1.*(iEcalTp->id().ieta())-0.5,iEcalTp->id().iphi()) ;
329  if(iEcalTp->compressedEt() > 3) rctInputTPGEcalOcc_ -> Fill(1.*(iEcalTp->id().ieta())-0.5,iEcalTp->id().iphi()) ;
330  }
331  else
332  {
333  rctInputTPGEcalOccNoCut_ -> Fill(1.*(iEcalTp->id().ieta())+0.5,iEcalTp->id().iphi()) ;
334  if(iEcalTp->compressedEt() > 3) rctInputTPGEcalOcc_ -> Fill(1.*(iEcalTp->id().ieta())+0.5,iEcalTp->id().iphi()) ;
335  }
336 
337 if(verbose_) std::cout << " ECAL data: Energy: " << iEcalTp->compressedEt() << " eta " << iEcalTp->id().ieta() << " phi " << iEcalTp->id().iphi() << std::endl ;
338  }
339  }
340 
341  if (!hcalTpData.isValid()) {
342  edm::LogInfo("TPG DataNotFound") << "can't find HcalTrigPrimDigiCollection";
343  if (verbose_)std::cout << "Can not find hcalTpData!" << std::endl ;
344 
345  doHcal = false ;
346  }
347 
348 
349  if(doHcal)
350  {
351 
352  for(HcalTrigPrimDigiCollection::const_iterator iHcalTp = hcalTpData->begin(); iHcalTp != hcalTpData->end(); iHcalTp++)
353  {
354  int highSample=0;
355  int highEt=0;
356 
357  for (int nSample = 0; nSample < 10; nSample++)
358  {
359  if (iHcalTp->sample(nSample).compressedEt() != 0)
360  {
361  if(verbose_) std::cout << "HCAL data: Et "
362  << iHcalTp->sample(nSample).compressedEt()
363  << " fg "
364  << iHcalTp->sample(nSample).fineGrain()
365  << " ieta " << iHcalTp->id().ieta()
366  << " iphi " << iHcalTp->id().iphi()
367  << " sample " << nSample
368  << std::endl ;
369  if (iHcalTp->sample(nSample).compressedEt() > highEt)
370  {
371  highSample = nSample;
372  highEt = iHcalTp->sample(nSample).compressedEt() ;
373  }
374  }
375 
376  }
377 
378  if(highEt != 0)
379  {
380  if(iHcalTp->id().ieta() > 0)
381  rctInputTPGHcalOcc_ -> Fill(1.*(iHcalTp->id().ieta())-0.5,iHcalTp->id().iphi()) ;
382  else
383  rctInputTPGHcalOcc_ -> Fill(1.*(iHcalTp->id().ieta())+0.5,iHcalTp->id().iphi()) ;
384  rctInputTPGHcalSample_ -> Fill(highSample,highEt) ;
385  rctInputTPGHcalRank_ -> Fill(highEt) ;
386  }
387 
388  }
389  }
390 
391 
392  e.getByToken(rctSourceData_rgnData_,rgnData);
393  e.getByToken(rctSourceEmul_rgnEmul_,rgnEmul);
394 
395  if (!rgnData.isValid()) {
396  edm::LogInfo("DataNotFound") << "can't find L1CaloRegionCollection";
397  if (verbose_)std::cout << "Can not find rgnData!" << std::endl ;
398  // doHd = false;
399  }
400 
401 // if ( doHd ) {
402  if (!rgnEmul.isValid()) {
403  edm::LogInfo("DataNotFound") << "can't find L1CaloRegionCollection";
404  // doHd = false;
405  if (verbose_)std::cout << "Can not find rgnEmul!" << std::endl ;
406  }
407 // }
408 
409 
410  e.getByToken(rctSourceData_emData_,emData);
411  e.getByToken(rctSourceEmul_emEmul_,emEmul);
412 
413  if (!emData.isValid()) {
414  edm::LogInfo("DataNotFound") << "can't find L1CaloEmCollection";
415  if (verbose_)std::cout << "Can not find emData!" << std::endl ;
416  // doEm = false;
417  }
418 
419 // if ( doEm ) {
420 
421  if (!emEmul.isValid()) {
422  edm::LogInfo("DataNotFound") << "can't find L1CaloEmCollection";
423  if (verbose_)std::cout << "Can not find emEmul!" << std::endl ;
424  // doEm = false;
425  return ;
426  }
427 
428 // }
429 
430 
431  // Isolated and non-isolated EM
432 
433  // StepI: Reset
434 
435  int nelectrIsoData = 0;
436  int nelectrNisoData = 0;
437  int nelectrIsoEmul = 0;
438  int nelectrNisoEmul = 0;
439 
440  int electronDataRank[2][PhiEtaMax]={{0}};
441  int electronDataEta[2][PhiEtaMax]={{0}};
442  int electronDataPhi[2][PhiEtaMax]={{0}};
443  int electronEmulRank[2][PhiEtaMax]={{0}};
444  int electronEmulEta[2][PhiEtaMax]={{0}};
445  int electronEmulPhi[2][PhiEtaMax]={{0}};
446 
447  // region/bit arrays
448  int nRegionData = 0;
449  int nRegionEmul = 0;
450 
451  int regionDataRank[PhiEtaMax] = {0};
452  int regionDataEta [PhiEtaMax] = {0};
453  int regionDataPhi [PhiEtaMax] = {0};
454 
455  bool regionDataOverFlow [PhiEtaMax] = {false};
456  bool regionDataTauVeto [PhiEtaMax] = {false};
457  bool regionDataMip [PhiEtaMax] = {false};
458  bool regionDataQuiet [PhiEtaMax] = {false};
459  bool regionDataHfPlusTau[PhiEtaMax] = {false};
460 
461  int regionEmulRank[PhiEtaMax] = {0};
462  int regionEmulEta [PhiEtaMax] = {0};
463  int regionEmulPhi [PhiEtaMax] = {0};
464 
465  bool regionEmulOverFlow [PhiEtaMax] = {false};
466  bool regionEmulTauVeto [PhiEtaMax] = {false};
467  bool regionEmulMip [PhiEtaMax] = {false};
468  bool regionEmulQuiet [PhiEtaMax] = {false};
469  bool regionEmulHfPlusTau[PhiEtaMax] = {false};
470 
471 if(first)
472 {
473  first = false ;
474 }
475 
476 
477  // StepII: fill variables
478 
479  for (L1CaloEmCollection::const_iterator iem = emEmul->begin();
480  iem != emEmul->end();
481  iem++)
482  {
483  if(iem->rank() >= 1)
484  {
485  if(iem->isolated())
486  {
487  rctIsoEmEmulOcc_->Fill(iem->regionId().ieta(), iem->regionId().iphi());
488 
489  // to show bad channles in the 2D efficiency plots
490  rctIsoEmIneffOcc_->Fill (iem->regionId().ieta(), iem->regionId().iphi(), 0.01);
491  rctIsoEmEff1Occ_->Fill (iem->regionId().ieta(), iem->regionId().iphi(), 0.01);
492 
493  int channel;
494 
495  channel=PHIBINS*iem->regionId().ieta()+iem->regionId().iphi();
496  rctIsoEmEmulOcc1D_->Fill(channel);
497  electronEmulRank[0][nelectrIsoEmul]=iem->rank() ;
498  electronEmulEta[0][nelectrIsoEmul]=iem->regionId().ieta();
499  electronEmulPhi[0][nelectrIsoEmul]=iem->regionId().iphi();
500  nelectrIsoEmul++ ;
501  }
502 
503  else
504  {
505  rctNisoEmEmulOcc_->Fill(iem->regionId().ieta(), iem->regionId().iphi());
506 
507  // to show bad channles in the 2D efficiency plots
508  rctNisoEmIneffOcc_->Fill (iem->regionId().ieta(), iem->regionId().iphi(), 0.01);
509  rctNisoEmEff1Occ_->Fill (iem->regionId().ieta(), iem->regionId().iphi(), 0.01);
510 
511  int channel;
512 //
513 
514  channel=PHIBINS*iem->regionId().ieta()+iem->regionId().iphi();
515  rctNisoEmEmulOcc1D_->Fill(channel);
516  electronEmulRank[1][nelectrNisoEmul]=iem->rank() ;
517  electronEmulEta[1][nelectrNisoEmul]=iem->regionId().ieta();
518  electronEmulPhi[1][nelectrNisoEmul]=iem->regionId().iphi();
519  nelectrNisoEmul++ ;
520  }
521  }
522  }
523 
524  for (L1CaloEmCollection::const_iterator iem = emData->begin();
525  iem != emData->end();
526  iem++)
527  {
528  if(iem->rank() >= 1)
529  {
530  if (iem->isolated())
531  {
532  rctIsoEmDataOcc_->Fill(iem->regionId().ieta(), iem->regionId().iphi());
533 
534  // new stuff to avoid 0's in emulator 2D //
535  // rctIsoEmEmulOcc_->Fill(iem->regionId().ieta(), iem->regionId().iphi(),0.01);
536  rctIsoEmOvereffOcc_->Fill (iem->regionId().ieta(),
537  iem->regionId().iphi(), 0.01);
538 
539  int channel;
540 
541  channel=PHIBINS*iem->regionId().ieta()+iem->regionId().iphi();
542  rctIsoEmDataOcc1D_->Fill(channel);
543 
544  // new stuff to avoid 0's
545  // rctIsoEmEmulOcc1D_->Fill(channel);
546 
547  electronDataRank[0][nelectrIsoData]=iem->rank() ;
548  electronDataEta[0][nelectrIsoData]=iem->regionId().ieta();
549  electronDataPhi[0][nelectrIsoData]=iem->regionId().iphi();
550  nelectrIsoData++ ;
551  }
552 
553  else
554  {
555  rctNisoEmDataOcc_->Fill(iem->regionId().ieta(), iem->regionId().iphi());
556 
557  // new stuff to avoid 0's in emulator 2D //
558  // rctNisoEmEmulOcc_->Fill(iem->regionId().ieta(), iem->regionId().iphi(),0.01);
559  rctNisoEmOvereffOcc_->Fill (iem->regionId().ieta(),
560  iem->regionId().iphi(), 0.01);
561 
562  int channel;
563 
564  channel=PHIBINS*iem->regionId().ieta()+iem->regionId().iphi();
565  rctNisoEmDataOcc1D_->Fill(channel);
566 
567  // new stuff to avoid 0's
568  // rctNisoEmEmulOcc1D_->Fill(channel);
569 
570  electronDataRank[1][nelectrNisoData]=iem->rank() ;
571  electronDataEta[1][nelectrNisoData]=iem->regionId().ieta();
572  electronDataPhi[1][nelectrNisoData]=iem->regionId().iphi();
573  nelectrNisoData++ ;
574  }
575  }
576  }
577 
578  // fill region/bit arrays for emulator
579  for(L1CaloRegionCollection::const_iterator ireg = rgnEmul->begin();
580  ireg != rgnEmul->end();
581  ireg++)
582  {
583 // std::cout << "Emul: " << nRegionEmul << " " << ireg->gctEta() << " " << ireg->gctPhi() << std::endl;
584  if(ireg->overFlow()) rctBitEmulOverFlow2D_ ->Fill(ireg->gctEta(), ireg->gctPhi());
585  if(ireg->tauVeto()) rctBitEmulTauVeto2D_ ->Fill(ireg->gctEta(), ireg->gctPhi());
586  if(ireg->mip()) rctBitEmulMip2D_ ->Fill(ireg->gctEta(), ireg->gctPhi());
587  if(ireg->quiet()) rctBitEmulQuiet2D_ ->Fill(ireg->gctEta(), ireg->gctPhi());
588  if(ireg->fineGrain()) rctBitEmulHfPlusTau2D_->Fill(ireg->gctEta(), ireg->gctPhi());
589  if(ireg->et() > 0)
590  {
591  rctRegEmulOcc1D_->Fill(PHIBINS*ireg->gctEta() + ireg->gctPhi());
592  rctRegEmulOcc2D_->Fill(ireg->gctEta(), ireg->gctPhi());
593  }
594 
595  // to show bad channels in 2D efficiency plots:
596  if(ireg->overFlow()) {
597  rctBitUnmatchedEmulOverFlow2D_->Fill (ireg->gctEta(), ireg->gctPhi(), 0.01);
598  rctBitMatchedOverFlow2D_->Fill (ireg->gctEta(), ireg->gctPhi(), 0.01);
599  }
600 
601  if(ireg->tauVeto()) {
602  rctBitUnmatchedEmulTauVeto2D_->Fill (ireg->gctEta(), ireg->gctPhi(), 0.01);
603  rctBitMatchedTauVeto2D_->Fill (ireg->gctEta(), ireg->gctPhi(), 0.01);
604  }
605 
606  if(ireg->mip()) {
607  rctBitUnmatchedEmulMip2D_->Fill (ireg->gctEta(), ireg->gctPhi(), 0.01);
608  rctBitMatchedMip2D_->Fill (ireg->gctEta(), ireg->gctPhi(), 0.01);
609  }
610 
611  if(ireg->quiet()) {
612  rctBitUnmatchedEmulQuiet2D_->Fill (ireg->gctEta(), ireg->gctPhi(), 0.01);
613  rctBitMatchedQuiet2D_->Fill (ireg->gctEta(), ireg->gctPhi(), 0.01);
614  }
615 
616  if(ireg->fineGrain()) {
617  rctBitUnmatchedEmulHfPlusTau2D_->Fill (ireg->gctEta(), ireg->gctPhi(), 0.01);
618  rctBitMatchedHfPlusTau2D_->Fill (ireg->gctEta(), ireg->gctPhi(), 0.01);
619  }
620 
621  if(ireg->et() > 0) {
622  rctRegUnmatchedEmulOcc2D_->Fill (ireg->gctEta(), ireg->gctPhi(), 0.01);
623  rctRegMatchedOcc2D_->Fill (ireg->gctEta(), ireg->gctPhi(), 0.01);
624 /* rctRegDeltaEtOcc2D_->Fill (ireg->gctEta(), ireg->gctPhi(), 0.01); */
625  }
626 
627  nRegionEmul = PHIBINS * ireg->gctEta() + ireg->gctPhi();
628 
629  regionEmulRank [nRegionEmul] = ireg->et() ;
630  regionEmulEta [nRegionEmul] = ireg->gctEta();
631  regionEmulPhi [nRegionEmul] = ireg->gctPhi();
632  regionEmulOverFlow [nRegionEmul] = ireg->overFlow();
633  regionEmulTauVeto [nRegionEmul] = ireg->tauVeto();
634  regionEmulMip [nRegionEmul] = ireg->mip();
635  regionEmulQuiet [nRegionEmul] = ireg->quiet();
636  regionEmulHfPlusTau[nRegionEmul] = ireg->fineGrain();
637  }
638  // fill region/bit arrays for hardware
639  for(L1CaloRegionCollection::const_iterator ireg = rgnData->begin();
640  ireg != rgnData->end();
641  ireg++)
642  {
643 // std::cout << "Data: " << nRegionData << " " << ireg->gctEta() << " " << ireg->gctPhi() << std::endl;
644  if(ireg->overFlow()) rctBitDataOverFlow2D_ ->Fill(ireg->gctEta(), ireg->gctPhi());
645  if(ireg->tauVeto()) rctBitDataTauVeto2D_ ->Fill(ireg->gctEta(), ireg->gctPhi());
646  if(ireg->mip()) rctBitDataMip2D_ ->Fill(ireg->gctEta(), ireg->gctPhi());
647  if(ireg->quiet()) rctBitDataQuiet2D_ ->Fill(ireg->gctEta(), ireg->gctPhi());
648  if(ireg->fineGrain()) rctBitDataHfPlusTau2D_->Fill(ireg->gctEta(), ireg->gctPhi());
649  if(ireg->et() > 0)
650  {
651  rctRegDataOcc1D_ ->Fill(PHIBINS*ireg->gctEta() + ireg->gctPhi());
652  rctRegDataOcc2D_ ->Fill(ireg->gctEta(), ireg->gctPhi());
653  }
654  // to show bad channels in 2D inefficiency:
655  // if(ireg->overFlow()) rctBitEmulOverFlow2D_ ->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
656  // if(ireg->tauVeto()) rctBitEmulTauVeto2D_ ->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
657  // if(ireg->mip()) rctBitEmulMip2D_ ->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
658  // if(ireg->quiet()) rctBitEmulQuiet2D_ ->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
659  // if(ireg->fineGrain()) rctBitEmulHfPlusTau2D_->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
660  // if(ireg->et() > 0) rctRegEmulOcc2D_ ->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
661  if(ireg->overFlow()) rctBitUnmatchedDataOverFlow2D_ ->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
662  if(ireg->tauVeto()) rctBitUnmatchedDataTauVeto2D_ ->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
663  if(ireg->mip()) rctBitUnmatchedDataMip2D_ ->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
664  if(ireg->quiet()) rctBitUnmatchedDataQuiet2D_ ->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
665  if(ireg->fineGrain()) rctBitUnmatchedDataHfPlusTau2D_->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
666  if(ireg->et() > 0) rctRegUnmatchedDataOcc2D_ ->Fill(ireg->gctEta(), ireg->gctPhi(), 0.01);
667 
668  nRegionData = PHIBINS * ireg->gctEta() + ireg->gctPhi();
669 
670  regionDataRank [nRegionData] = ireg->et() ;
671  regionDataEta [nRegionData] = ireg->gctEta();
672  regionDataPhi [nRegionData] = ireg->gctPhi();
673  regionDataOverFlow [nRegionData] = ireg->overFlow();
674  regionDataTauVeto [nRegionData] = ireg->tauVeto();
675  regionDataMip [nRegionData] = ireg->mip();
676  regionDataQuiet [nRegionData] = ireg->quiet();
677  regionDataHfPlusTau[nRegionData] = ireg->fineGrain();
678  }
679 
680  if(verbose_)
681 {
682  std::cout << "I found Data! Iso: " << nelectrIsoData << " Niso: " << nelectrNisoData << std::endl ;
683  for(int i=0; i<nelectrIsoData; i++)
684  std::cout << " Iso Energy " << electronDataRank[0][i] << " eta " << electronDataEta[0][i] << " phi " << electronDataPhi[0][i] << std::endl ;
685  for(int i=0; i<nelectrNisoData; i++)
686  std::cout << " Niso Energy " << electronDataRank[1][i] << " eta " << electronDataEta[1][i] << " phi " << electronDataPhi[1][i] << std::endl ;
687 
688  std::cout << "I found Emul! Iso: " << nelectrIsoEmul << " Niso: " << nelectrNisoEmul << std::endl ;
689  for(int i=0; i<nelectrIsoEmul; i++)
690  std::cout << " Iso Energy " << electronEmulRank[0][i] << " eta " << electronEmulEta[0][i] << " phi " << electronEmulPhi[0][i] << std::endl ;
691  for(int i=0; i<nelectrNisoEmul; i++)
692  std::cout << " Niso Energy " << electronEmulRank[1][i] << " eta " << electronEmulEta[1][i] << " phi " << electronEmulPhi[1][i] << std::endl ;
693 
694  std::cout << "I found Data! Regions: " << PhiEtaMax << std::endl ;
695  for(int i=0; i<(int)PhiEtaMax; i++)
696  if(regionDataRank[i] !=0 ) std::cout << " Energy " << regionDataRank[i] << " eta " << regionDataEta[i] << " phi " << regionDataPhi[i] << std::endl ;
697 
698  std::cout << "I found Emul! Regions: " << PhiEtaMax << std::endl ;
699  for(int i=0; i<(int)PhiEtaMax; i++)
700  if(regionEmulRank[i] !=0 ) std::cout << " Energy " << regionEmulRank[i] << " eta " << regionEmulEta[i] << " phi " << regionEmulPhi[i] << std::endl ;
701 }
702 
703  // StepIII: calculate and fill
704 
705  for(int k=0; k<2; k++)
706  {
707  int nelectrE, nelectrD;
708 
709  if(k==0)
710  {
711  nelectrE=nelectrIsoEmul;
712  nelectrD=nelectrIsoData;
713  }
714 
715  else
716  {
717  nelectrE=nelectrNisoEmul;
718  nelectrD=nelectrNisoData;
719  }
720 
721  for(int i = 0; i < nelectrE; i++)
722  {
723  //bool triggered = l1SingleEG2; //false; //HACK until true trigger implimented
724  double trigThresh = doubleThreshold_; //ditto
725  if(singlechannelhistos_) {
726  int chnl=PHIBINS*electronEmulEta[k][i]+electronEmulPhi[k][i];
727  if(k==1 && independent_triggered) { //non-iso
728  //std::cout << "eta " << electronEmulEta[k][i] << " phi " << electronEmulPhi[k][i] << " with rank " << electronEmulRank[k][i] << std::endl;
729  trigEffOcc_[chnl]->Fill(electronEmulRank[k][i]);
730 // }
731  if(triggered)
732  trigEffTriggOcc_[chnl]->Fill(electronEmulRank[k][i]); }
733  }
734  //find number of objects with rank above 2x trigger threshold
735  //and number after requiring a trigger too
736  if(electronEmulRank[k][i]>=trigThresh){
737  if(k==1 && independent_triggered) { //non-iso
738  trigEffThreshOcc_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i]);
739  trigEffTriggThreshOcc_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.01);
740 // }
741  if(triggered)
742  trigEffTriggThreshOcc_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.98001); }
743  }
744 
745 
746 
747  Bool_t found = kFALSE;
748 
749  for(int j = 0; j < nelectrD; j++)
750  {
751  if(electronEmulEta[k][i]==electronDataEta[k][j] &&
752  electronEmulPhi[k][i]==electronDataPhi[k][j])
753  {
754  if(k==0)
755  {
756  rctIsoEmEff1Occ_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.98001);
757  // Weight is for ROOT; when added to initial weight of 0.01, should just exceed 0.99
758 
759  int chnl;
760 
761  chnl=PHIBINS*electronEmulEta[k][i]+electronEmulPhi[k][i];
762  rctIsoEmEff1Occ1D_->Fill(chnl);
763  if(singlechannelhistos_)
764  {
765  int energy_difference;
766 
767  energy_difference=(electronEmulRank[k][i] - electronDataRank[k][j]);
768  rctIsoEffChannel_[chnl]->Fill(energy_difference);
769  }
770 
771  if(electronEmulRank[k][i]==electronDataRank[k][j])
772  {
773  rctIsoEmEff2Occ1D_->Fill(chnl);
774  rctIsoEmEff2Occ_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.98012);
775  // Weight is for ROOT; should just exceed 0.99
776  // NOTE: Weight is different for eff 2 because this isn't filled initially
777  // for current definition of Eff2 and Ineff2 we need to add additional
778  // factor 0.99 since we divide over eff1 which is 0.99001 e.g. we use 0.99001**2 !
779  rctIsoEmIneff2Occ_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.0099);
780  }
781  else
782  {
783  rctIsoEmIneff2Occ1D_->Fill(chnl);
784  rctIsoEmIneff2Occ_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.9801);
785  //Check for the bit that is different and store it
786  bitset<8> bitDifference( electronEmulRank[k][i]^electronDataRank[k][j] );
787  for( size_t n=0; n < bitDifference.size(); n++){
788  if( n < 4 ){ rctIsoEmBitDiff_->Fill( electronEmulEta[k][i], electronEmulPhi[k][i]+n*0.25, bitDifference[n] ); }
789  if( n >= 4 ){ rctIsoEmBitDiff_->Fill( electronEmulEta[k][i]+0.5, electronEmulPhi[k][i]+(n-4)*0.25, bitDifference[n] ); }
790  }
791  }
792  }
793 
794  else
795  {
796  rctNisoEmEff1Occ_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.98001);
797  // Weight is for ROOT; when added to initial weight of 0.01, should just exceed 0.99
798 
799  int chnl;
800 
801  chnl=PHIBINS*electronEmulEta[k][i]+electronEmulPhi[k][i];
802  rctNisoEmEff1Occ1D_->Fill(chnl);
803  if(singlechannelhistos_)
804  {
805  int energy_difference;
806 
807  energy_difference=(electronEmulRank[k][i] - electronDataRank[k][j]) ;
808  rctNisoEffChannel_[chnl]->Fill(energy_difference) ;
809  }
810 
811 
812  if(electronEmulRank[k][i]==electronDataRank[k][j])
813  {
814  rctNisoEmEff2Occ1D_->Fill(chnl);
815  rctNisoEmEff2Occ_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.98012);
816  // Weight is for ROOT; should just exceed 0.99
817  // NOTE: Weight is different for eff 2 because this isn't filled initially
818  // see comments fo Iso
819  rctNisoEmIneff2Occ_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.0099);
820  }
821  else
822  {
823  rctNisoEmIneff2Occ1D_->Fill(chnl);
824  rctNisoEmIneff2Occ_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.9801);
825  //Check for the bit that is different and store it
826  bitset<8> bitDifference( electronEmulRank[k][i]^electronDataRank[k][j] );
827  for( size_t n=0; n < bitDifference.size(); n++){
828  if( n < 4 ){ rctNIsoEmBitDiff_->Fill( electronEmulEta[k][i], electronEmulPhi[k][i]+n*0.25, bitDifference[n] ); }
829  if( n >= 4 ){ rctNIsoEmBitDiff_->Fill( electronEmulEta[k][i]+0.5, electronEmulPhi[k][i]+(n-4)*0.25, bitDifference[n] ); }
830  }
831  }
832  }
833 
834  found = kTRUE;
835  }
836  }
837 
838  if(found == kFALSE)
839  {
840  if(k==0)
841  {
842  rctIsoEmIneffOcc_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.98);
843  // Weight is for ROOT; when added to initial weight of 0.01, should equal 0.99
844 
845  int chnl;
846 
847  //Store the bit map for the emulator
848  bitset<8> bit( electronEmulRank[k][i] );
849  for( size_t n=0; n < bit.size(); n++){
850  if( n < 4 ){ rctIsoEmBitOff_->Fill( electronEmulEta[k][i], electronEmulPhi[k][i]+n*0.25, bit[n] ); }
851  if( n >= 4 ){ rctIsoEmBitOff_->Fill( electronEmulEta[k][i]+0.5, electronEmulPhi[k][i]+(n-4)*0.25, bit[n] ); }
852  }
853 
854  chnl=PHIBINS*electronEmulEta[k][i]+electronEmulPhi[k][i];
855  rctIsoEmIneffOcc1D_->Fill(chnl);
856  if(singlechannelhistos_)
857  {
858  rctIsoIneffChannel_[chnl]->Fill(electronEmulRank[k][i]);
859  }
860  }
861 
862  else
863  {
864  rctNisoEmIneffOcc_->Fill(electronEmulEta[k][i], electronEmulPhi[k][i], 0.98);
865  // Weight is for ROOT; when added to initial weight of 0.01, should equal 0.99
866 
867  int chnl;
868 
869  chnl=PHIBINS*electronEmulEta[k][i]+electronEmulPhi[k][i];
870  rctNisoEmIneffOcc1D_->Fill(chnl);
871 
872  //Store the bit map for the emulator
873  bitset<8> bit( electronEmulRank[k][i] );
874  for( size_t n=0; n < bit.size(); n++){
875  if( n < 4 ){ rctNIsoEmBitOff_->Fill( electronEmulEta[k][i], electronEmulPhi[k][i]+n*0.25, bit[n] ); }
876  if( n >= 4 ){ rctNIsoEmBitOff_->Fill( electronEmulEta[k][i]+0.5, electronEmulPhi[k][i]+(n-4)*0.25, bit[n] ); }
877  }
878 
879  if(singlechannelhistos_)
880  {
881  rctNisoIneffChannel_[chnl]->Fill(electronEmulRank[k][i]);
882  }
883  }
884  }
885 
886  }
887 
888  DivideME1D(rctIsoEmEff1Occ1D_, rctIsoEmEmulOcc1D_, rctIsoEmEff1oneD_);
889  DivideME2D(rctIsoEmEff1Occ_, rctIsoEmEmulOcc_, rctIsoEmEff1_) ;
890 // DivideME1D(rctIsoEmEff2Occ1D_, rctIsoEmEmulOcc1D_, rctIsoEmEff2oneD_);
891 // DivideME2D(rctIsoEmEff2Occ_, rctIsoEmEmulOcc_, rctIsoEmEff2_) ;
892  DivideME1D(rctIsoEmEff2Occ1D_, rctIsoEmEff1Occ1D_, rctIsoEmEff2oneD_);
893  DivideME2D(rctIsoEmEff2Occ_, rctIsoEmEff1Occ_, rctIsoEmEff2_) ;
894 // DivideME1D(rctIsoEmIneff2Occ1D_, rctIsoEmEmulOcc1D_, rctIsoEmIneff2oneD_);
895 // DivideME2D(rctIsoEmIneff2Occ_, rctIsoEmEmulOcc_, rctIsoEmIneff2_) ;
896  DivideME1D(rctIsoEmIneff2Occ1D_, rctIsoEmEff1Occ1D_, rctIsoEmIneff2oneD_);
897  DivideME2D(rctIsoEmIneff2Occ_, rctIsoEmEff1Occ_, rctIsoEmIneff2_) ;
898 
899  DivideME1D(rctNisoEmEff1Occ1D_, rctNisoEmEmulOcc1D_, rctNisoEmEff1oneD_);
900  DivideME2D(rctNisoEmEff1Occ_, rctNisoEmEmulOcc_, rctNisoEmEff1_);
901 // DivideME1D(rctNisoEmEff2Occ1D_, rctNisoEmEmulOcc1D_, rctNisoEmEff2oneD_);
902 // DivideME2D(rctNisoEmEff2Occ_, rctNisoEmEmulOcc_, rctNisoEmEff2_);
903  DivideME1D(rctNisoEmEff2Occ1D_, rctNisoEmEff1Occ1D_, rctNisoEmEff2oneD_);
904  DivideME2D(rctNisoEmEff2Occ_, rctNisoEmEff1Occ_, rctNisoEmEff2_);
905 // DivideME1D(rctNisoEmIneff2Occ1D_, rctNisoEmEmulOcc1D_, rctNisoEmIneff2oneD_);
906 // DivideME2D(rctNisoEmIneff2Occ_, rctNisoEmEmulOcc_, rctNisoEmIneff2_);
907  DivideME1D(rctNisoEmIneff2Occ1D_, rctNisoEmEff1Occ1D_, rctNisoEmIneff2oneD_);
908  DivideME2D(rctNisoEmIneff2Occ_, rctNisoEmEff1Occ_, rctNisoEmIneff2_);
909 
910  DivideME1D(rctIsoEmIneffOcc1D_, rctIsoEmEmulOcc1D_, rctIsoEmIneff1D_);
911  DivideME2D(rctIsoEmIneffOcc_, rctIsoEmEmulOcc_, rctIsoEmIneff_);
912  DivideME1D(rctNisoEmIneffOcc1D_, rctNisoEmEmulOcc1D_, rctNisoEmIneff1D_);
913  DivideME2D(rctNisoEmIneffOcc_, rctNisoEmEmulOcc_, rctNisoEmIneff_);
914 
915  DivideME2D(trigEffTriggThreshOcc_, trigEffThreshOcc_, trigEffThresh_);
916  if(singlechannelhistos_) {
917  for(int i = 0; i < nelectrE; i++)
918  {
919  int chnl=PHIBINS*electronEmulEta[k][i]+electronEmulPhi[k][i];
920  DivideME1D(trigEffTriggOcc_[chnl], trigEffOcc_[chnl], trigEff_[chnl]);
921  }
922  }
923 
924  for(int i = 0; i < nelectrD; i++)
925  {
926  Bool_t found = kFALSE;
927 
928  for(int j = 0; j < nelectrE; j++)
929  {
930  if(electronEmulEta[k][j]==electronDataEta[k][i] &&
931  electronEmulPhi[k][j]==electronDataPhi[k][i])
932  {
933  found = kTRUE;
934  }
935  }
936 
937  if(found == kFALSE)
938  {
939  if(k==0)
940  {
941  rctIsoEmOvereffOcc_->Fill(electronDataEta[k][i], electronDataPhi[k][i], 0.98);
942  // Weight is for ROOT; when added to initial weight of 0.01, should equal 0.99
943 
944  int chnl;
945 
946  //Store the bit map for the emulator
947  bitset<8> bit( electronDataRank[k][i] );
948  for( size_t n=0; n < bit.size(); n++){
949  if( n < 4 ){ rctIsoEmBitOn_->Fill( electronDataEta[k][i], electronDataPhi[k][i]+n*0.25, bit[n] ); }
950  if( n >= 4 ){ rctIsoEmBitOn_->Fill( electronDataEta[k][i]+0.5, electronDataPhi[k][i]+(n-4)*0.25, bit[n] ); }
951  }
952 
953  chnl=PHIBINS*electronDataEta[k][i]+electronDataPhi[k][i];
954  rctIsoEmOvereffOcc1D_->Fill(chnl);
955 
956  if(singlechannelhistos_)
957  {
958  rctIsoOvereffChannel_[chnl]->Fill(electronDataRank[k][i]);
959  }
960  }
961 
962  else
963  {
964  rctNisoEmOvereffOcc_->Fill(electronDataEta[k][i], electronDataPhi[k][i], 0.98);
965  // Weight is for ROOT; when added to initial weight of 0.01, should equal 0.99
966 
967  int chnl;
968 
969  //Store the bit map for the emulator
970  bitset<8> bit( electronDataRank[k][i] );
971  for( size_t n=0; n < bit.size(); n++){
972  if( n < 4 ){ rctNIsoEmBitOn_->Fill( electronDataEta[k][i], electronDataPhi[k][i]+n*0.25, bit[n] ); }
973  if( n >= 4 ){ rctNIsoEmBitOn_->Fill( electronDataEta[k][i]+0.5, electronDataPhi[k][i]+(n-4)*0.25, bit[n] ); }
974  }
975 
976  chnl=PHIBINS*electronDataEta[k][i]+electronDataPhi[k][i];
977  rctNisoEmOvereffOcc1D_->Fill(chnl) ;
978 
979  if(singlechannelhistos_)
980  {
981  rctNisoOvereffChannel_[chnl]->Fill(electronDataRank[k][i]);
982  }
983  }
984  }
985  }
986 
987  }
988 
989  // we try new definition of overefficiency:
990  DivideME1D(rctIsoEmOvereffOcc1D_, rctIsoEmDataOcc1D_, rctIsoEmOvereff1D_);
991  DivideME2D(rctIsoEmOvereffOcc_, rctIsoEmDataOcc_, rctIsoEmOvereff_);
992  DivideME1D(rctNisoEmOvereffOcc1D_, rctNisoEmDataOcc1D_, rctNisoEmOvereff1D_);
993  DivideME2D(rctNisoEmOvereffOcc_, rctNisoEmDataOcc_, rctNisoEmOvereff_);
994 
995 
996  // calculate region/bit information
997  for(unsigned int i = 0; i < (int)PhiEtaMax; i++)
998 {
999  Bool_t regFound = kFALSE;
1000  Bool_t overFlowFound = kFALSE;
1001  Bool_t tauVetoFound = kFALSE;
1002  Bool_t mipFound = kFALSE;
1003  Bool_t quietFound = kFALSE;
1004  Bool_t hfPlusTauFound = kFALSE;
1005 
1006 // for(int j = 0; j < nRegionData; j++)
1007 // {
1008 // if(regionEmulEta[i] == regionDataEta[j] &&
1009 // regionEmulPhi[i] == regionDataPhi[j])
1010 // {
1011  if(regionDataRank[i] >= 1 && regionEmulRank[i] >= 1)
1012  {
1013  int chnl;
1014 
1015  chnl = PHIBINS*regionEmulEta[i] + regionEmulPhi[i];
1016  rctRegMatchedOcc1D_->Fill(chnl);
1017  rctRegMatchedOcc2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.98001);
1018  // Weight is for ROOT; when added to initial weight of 0.01, should just exceed 0.99
1019 
1020  if(singlechannelhistos_) rctRegEffChannel_[chnl]->Fill(regionEmulRank[i] - regionDataRank[i]);
1021 
1022  // see comments for Iso Eff2
1023 
1024  if(regionEmulRank[i] == regionDataRank[i])
1025  {
1026  rctRegSpEffOcc1D_->Fill(chnl);
1027 // rctRegSpEffOcc2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.99001);
1028  rctRegSpEffOcc2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.98012);
1029  rctRegSpIneffOcc2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.0099);
1030  }
1031  else
1032  {
1033  rctRegSpIneffOcc1D_->Fill(chnl);
1034  rctRegSpIneffOcc2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.9801);
1035 
1036  bitset<10> bitDifference( regionEmulRank[i]^regionDataRank[i] );
1037  for( size_t n=0; n < bitDifference.size(); n++){
1038  if( n < 5 ){ rctRegBitDiff_->Fill( regionEmulEta[i], regionEmulPhi[i]+n*0.2, bitDifference[n] ); }
1039  if( n >= 5 ){ rctRegBitDiff_->Fill( regionEmulEta[i]+0.5, regionEmulPhi[i]+(n-5)*0.2, bitDifference[n] ); }
1040  }
1041 
1042  }
1043  // Weight is for ROOT; should just exceed 0.99
1044  // NOTE: Weight is different for eff 2 because this isn't filled initially
1045 
1046  regFound = kTRUE;
1047  }
1048 
1049  if(regionEmulOverFlow[i] == true &&
1050  regionDataOverFlow[i] == true)
1051  {
1052  rctBitMatchedOverFlow2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.98001);
1053  overFlowFound = kTRUE;
1054  }
1055 
1056  if(regionEmulTauVeto[i] == true &&
1057  regionDataTauVeto[i] == true)
1058  {
1059  rctBitMatchedTauVeto2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.98001);
1060  tauVetoFound = kTRUE;
1061  }
1062 
1063  if (regionEmulMip[i] == true && regionDataMip[i] == true) {
1064  rctBitMatchedMip2D_->Fill (regionEmulEta[i], regionEmulPhi[i], 0.98001);
1065  mipFound = kTRUE;
1066  }
1067 
1068  if (regionEmulQuiet[i] == true && regionDataQuiet[i] == true) {
1069  rctBitMatchedQuiet2D_->Fill (regionEmulEta[i], regionEmulPhi[i], 0.98001);
1070  quietFound = kTRUE;
1071  }
1072 
1073  if (regionEmulHfPlusTau[i] == true && regionDataHfPlusTau[i] == true) {
1074  rctBitMatchedHfPlusTau2D_->Fill (regionEmulEta[i], regionEmulPhi[i], 0.98001);
1075  hfPlusTauFound = kTRUE;
1076  }
1077 
1078 
1079 // }
1080 // }
1081 
1082 
1083 
1084  if(regFound == kFALSE && regionEmulRank[i] >= 1 )
1085  {
1086  int chnl;
1087 
1088  bitset<10> bit( regionEmulRank[i] );
1089  for( size_t n=0; n < bit.size(); n++){
1090  if( n < 5 ){ rctRegBitOff_->Fill( regionEmulEta[i], regionEmulPhi[i]+n*0.2, bit[n] ); }
1091  if( n >= 5 ){ rctRegBitOff_->Fill( regionEmulEta[i]+0.5, regionEmulPhi[i]+(n-5)*0.2, bit[n] ); }
1092  }
1093 
1094  chnl = PHIBINS*regionEmulEta[i] + regionEmulPhi[i];
1095  rctRegUnmatchedEmulOcc1D_->Fill(chnl);
1096  rctRegUnmatchedEmulOcc2D_->Fill(regionEmulEta[i], regionEmulPhi[i],0.98);
1097  // Weight is for ROOT; when added to initial weight of 0.01, should equal 0.99
1098 
1099  if(singlechannelhistos_) rctRegIneffChannel_[chnl]->Fill(regionEmulRank[i]);
1100  }
1101 
1102  if(overFlowFound == kFALSE && regionEmulOverFlow[i] == true)
1103  {
1104  rctBitUnmatchedEmulOverFlow2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.98);
1105  }
1106 
1107  if(tauVetoFound == kFALSE && regionEmulTauVeto[i] == true)
1108  {
1109  rctBitUnmatchedEmulTauVeto2D_->Fill(regionEmulEta[i], regionEmulPhi[i], 0.98);
1110  }
1111 
1112  if (mipFound == kFALSE && regionEmulMip[i] == true) {
1113  rctBitUnmatchedEmulMip2D_->Fill (regionEmulEta[i], regionEmulPhi[i], 0.98);
1114  }
1115 
1116  if (quietFound == kFALSE && regionEmulQuiet[i] == true) {
1117  rctBitUnmatchedEmulQuiet2D_->Fill (regionEmulEta[i], regionEmulPhi[i], 0.98);
1118  }
1119 
1120  if (hfPlusTauFound == kFALSE && regionEmulHfPlusTau[i] == true ) {
1121  rctBitUnmatchedEmulHfPlusTau2D_->Fill (regionEmulEta[i], regionEmulPhi[i], 0.98);
1122  }
1123 
1124 
1125 }
1126 
1127 
1128  DivideME1D(rctRegMatchedOcc1D_, rctRegEmulOcc1D_, rctRegEff1D_);
1129  DivideME2D(rctRegMatchedOcc2D_, rctRegEmulOcc2D_, rctRegEff2D_);
1130 // DivideME1D(rctRegSpEffOcc1D_, rctRegEmulOcc1D_, rctRegSpEff1D_);
1131 // DivideME2D(rctRegSpEffOcc2D_, rctRegEmulOcc2D_, rctRegSpEff2D_);
1132  DivideME1D(rctRegSpEffOcc1D_, rctRegMatchedOcc1D_, rctRegSpEff1D_);
1133  DivideME2D(rctRegSpEffOcc2D_, rctRegMatchedOcc2D_, rctRegSpEff2D_);
1134 // DivideME1D(rctRegSpIneffOcc1D_, rctRegEmulOcc1D_, rctRegSpIneff1D_);
1135 // DivideME2D(rctRegSpIneffOcc2D_, rctRegEmulOcc2D_, rctRegSpIneff2D_);
1136  DivideME1D(rctRegSpIneffOcc1D_, rctRegMatchedOcc1D_, rctRegSpIneff1D_);
1137  DivideME2D(rctRegSpIneffOcc2D_, rctRegMatchedOcc2D_, rctRegSpIneff2D_);
1138  DivideME2D(rctBitMatchedOverFlow2D_, rctBitEmulOverFlow2D_, rctBitOverFlowEff2D_);
1139  DivideME2D(rctBitMatchedTauVeto2D_, rctBitEmulTauVeto2D_, rctBitTauVetoEff2D_);
1140  DivideME2D (rctBitMatchedMip2D_, rctBitEmulMip2D_, rctBitMipEff2D_);
1141  // QUIETBIT: To add quiet bit information, uncomment following line:
1142  // DivideME2D (rctBitMatchedQuiet2D_, rctBitEmulQuiet2D_, rctBitQuietEff2D_);
1143  DivideME2D (rctBitMatchedHfPlusTau2D_, rctBitEmulHfPlusTau2D_, rctBitHfPlusTauEff2D_);
1144 
1145  DivideME1D (rctRegUnmatchedEmulOcc1D_, rctRegEmulOcc1D_, rctRegIneff1D_);
1146  DivideME2D (rctRegUnmatchedEmulOcc2D_, rctRegEmulOcc2D_, rctRegIneff2D_);
1147  DivideME2D (rctBitUnmatchedEmulOverFlow2D_, rctBitEmulOverFlow2D_, rctBitOverFlowIneff2D_);
1148  DivideME2D (rctBitUnmatchedEmulTauVeto2D_, rctBitEmulTauVeto2D_, rctBitTauVetoIneff2D_);
1149  DivideME2D (rctBitUnmatchedEmulMip2D_, rctBitEmulMip2D_, rctBitMipIneff2D_);
1150  // QUIETBIT: To add quiet bit information, uncomment the following line:
1151  // DivideME2D (rctBitUnmatchedEmulQuiet2D_, rctBitEmulQuiet2D_, rctBitQuietIneff2D_);
1152  DivideME2D (rctBitUnmatchedEmulHfPlusTau2D_, rctBitEmulHfPlusTau2D_, rctBitHfPlusTauIneff2D_);
1153 
1154 
1155  // for(int i = 0; i < nRegionData; i++)
1156  for (int i = 0; i < (int)PhiEtaMax; i++)
1157 {
1158  Bool_t regFound = kFALSE;
1159  Bool_t overFlowFound = kFALSE;
1160  Bool_t tauVetoFound = kFALSE;
1161  Bool_t mipFound = kFALSE;
1162  Bool_t quietFound = kFALSE;
1163  Bool_t hfPlusTauFound = kFALSE;
1164 
1165 // for(int j = 0; j < nRegionEmul; j++)
1166 // {
1167 // if(regionEmulEta[j] == regionDataEta[i] &&
1168 // regionEmulPhi[j] == regionDataPhi[i])
1169 // {
1170 
1171  if(regionEmulRank[i] >= 1 && regionDataRank[i] >= 1)
1172  regFound = kTRUE;
1173 
1174  if(regionDataOverFlow[i] == true &&
1175  regionEmulOverFlow[i] == true)
1176  overFlowFound = kTRUE;
1177 
1178  if(regionDataTauVeto[i] == true &&
1179  regionEmulTauVeto[i] == true)
1180  tauVetoFound = kTRUE;
1181 
1182  if (regionDataMip[i] == true && regionEmulMip[i] == true)
1183  mipFound = kTRUE;
1184 
1185  if (regionDataQuiet[i] == true && regionEmulQuiet[i] == true)
1186  quietFound = kTRUE;
1187 
1188  if (regionDataHfPlusTau[i] == true && regionEmulHfPlusTau[i] == true)
1189  hfPlusTauFound = kTRUE;
1190 // }
1191 // }
1192 
1193  if(regFound == kFALSE && regionDataRank[i] >= 1)
1194  {
1195  int chnl;
1196 
1197  bitset<10> bit( regionDataRank[i] );
1198  for( size_t n=0; n < bit.size(); n++){
1199  if( n < 5 ){ rctRegBitOn_->Fill( regionDataEta[i], regionDataPhi[i]+n*0.2, bit[n] ); }
1200  if( n >= 5 ){ rctRegBitOn_->Fill( regionDataEta[i]+0.5, regionDataPhi[i]+(n-5)*0.2, bit[n] ); }
1201  }
1202 
1203 
1204  chnl = PHIBINS*regionDataEta[i] + regionDataPhi[i];
1205  rctRegUnmatchedDataOcc1D_->Fill(chnl);
1206  rctRegUnmatchedDataOcc2D_->Fill(regionDataEta[i], regionDataPhi[i], 0.98);
1207  // Weight is for ROOT; when added to initial weight of 0.01, should equal 0.99
1208 
1209  // we try a new definition of overefficiency:
1210  // DivideME1D(rctRegUnmatchedDataOcc1D_, rctRegDataOcc1D_, rctRegOvereff1D_);
1211  // DivideME2D(rctRegUnmatchedDataOcc2D_, rctRegDataOcc2D_, rctRegOvereff2D_);
1212 
1213  if(singlechannelhistos_) rctRegOvereffChannel_[chnl]->Fill(regionDataRank[i]);
1214  }
1215 
1216  if(overFlowFound == kFALSE && regionDataOverFlow[i] == true )
1217  {
1218  rctBitUnmatchedDataOverFlow2D_->Fill(regionDataEta[i], regionDataPhi[i], 0.98);
1219  }
1220 
1221  if(tauVetoFound == kFALSE && regionDataTauVeto[i] == true )
1222  {
1223  rctBitUnmatchedDataTauVeto2D_->Fill(regionDataEta[i], regionDataPhi[i], 0.98);
1224  }
1225 
1226  if (mipFound == kFALSE && regionDataMip[i] == true ) {
1227  rctBitUnmatchedDataMip2D_->Fill (regionDataEta[i], regionDataPhi[i], 0.98);
1228  }
1229 
1230  if (quietFound == kFALSE && regionDataQuiet[i] == true ) {
1231  rctBitUnmatchedDataQuiet2D_->Fill (regionDataEta[i], regionDataPhi[i], 0.98);
1232  }
1233 
1234  if (hfPlusTauFound == kFALSE && regionDataHfPlusTau[i] == true ) {
1235  rctBitUnmatchedDataHfPlusTau2D_->Fill (regionDataEta[i], regionDataPhi[i], 0.98);
1236  }
1237 
1238 }
1239 
1240  // we try a new definition of overefficiency:
1241  DivideME1D(rctRegUnmatchedDataOcc1D_, rctRegDataOcc1D_, rctRegOvereff1D_);
1242  DivideME2D(rctRegUnmatchedDataOcc2D_, rctRegDataOcc2D_, rctRegOvereff2D_);
1243  DivideME2D(rctBitUnmatchedDataOverFlow2D_, rctBitDataOverFlow2D_, rctBitOverFlowOvereff2D_);
1244  DivideME2D(rctBitUnmatchedDataTauVeto2D_, rctBitDataTauVeto2D_, rctBitTauVetoOvereff2D_);
1245  DivideME2D (rctBitUnmatchedDataMip2D_, rctBitDataMip2D_,
1246  rctBitMipOvereff2D_);
1247  // QUIETBIT: To add quiet bit information, uncomment following 2 lines:
1248  // DivideME2D (rctBitUnmatchedDataQuiet2D_, rctBitDataQuiet2D_,
1249  // rctBitQuietOvereff2D_);
1250  DivideME2D (rctBitUnmatchedDataHfPlusTau2D_, rctBitDataHfPlusTau2D_,
1251  rctBitHfPlusTauOvereff2D_);
1252 
1253 }
1254 
1255 void L1TdeRCT::DivideME2D(MonitorElement* numerator, MonitorElement* denominator, MonitorElement* result){
1256 
1257  TH2F* num = numerator->getTH2F();
1258  TH2F* den = denominator->getTH2F();
1259  TH2F* res = result->getTH2F();
1260 
1261  res->Divide(num,den,1,1,"");
1262 
1263 }
1264 
1265 void L1TdeRCT::DivideME1D(MonitorElement* numerator, MonitorElement* denominator, MonitorElement* result){
1266 
1267  TH1F* num = numerator->getTH1F();
1268  TH1F* den = denominator->getTH1F();
1269  TH1F* res = result->getTH1F();
1270 
1271  res->Divide(num,den,1,1,"");
1272 
1273 }
1274 
1275 
1276 void L1TdeRCT::beginRun(const edm::Run& run , const edm::EventSetup& es)
1277 {
1278  // get hold of back-end interface
1279  DQMStore *dbe = 0;
1280  dbe = Service < DQMStore > ().operator->();
1281 
1282  if (dbe) {
1283  dbe->setCurrentFolder(histFolder_);
1284  dbe->rmdir(histFolder_);
1285  }
1286 
1287 
1288  if (dbe) {
1289 
1290  dbe->setCurrentFolder(histFolder_);
1291 
1292  triggerType_ =
1293  dbe->book1D("TriggerType", "TriggerType", 17, -0.5, 16.5);
1294 
1295  triggerAlgoNumbers_ =
1296  dbe->book1D("gtTriggerAlgoNumbers", "gtTriggerAlgoNumbers", 128, -0.5, 127.5);
1297 
1298  rctInputTPGEcalOcc_ =
1299  dbe->book2D("rctInputTPGEcalOcc", "rctInputTPGEcalOcc", TPGETABINS, TPGETAMIN,
1300  TPGETAMAX, TPGPHIBINS, TPGPHIMIN, TPGPHIMAX);
1301 
1302  rctInputTPGEcalOccNoCut_ =
1303  dbe->book2D("rctInputTPGEcalOccNoCut", "rctInputTPGEcalOccNoCut", TPGETABINS, TPGETAMIN,
1304  TPGETAMAX, TPGPHIBINS, TPGPHIMIN, TPGPHIMAX);
1305 
1306  rctInputTPGEcalRank_ =
1307  dbe->book1D("rctInputTPGEcalRank", "rctInputTPGEcalRank", TPGRANK, TPGRANKMIN, TPGRANKMAX) ;
1308 
1309  rctInputTPGHcalOcc_ =
1310  dbe->book2D("rctInputTPGHcalOcc", "rctInputTPGHcalOcc", TPGETABINS, TPGETAMIN,
1311  TPGETAMAX, TPGPHIBINS, TPGPHIMIN, TPGPHIMAX);
1312 
1313  rctInputTPGHcalSample_ =
1314  dbe->book1D("rctInputTPGHcalSample", "rctInputTPGHcalSample", 10, -0.5, 9.5) ;
1315 
1316  rctInputTPGHcalRank_ =
1317  dbe->book1D("rctInputTPGHcalRank", "rctInputTPGHcalRank", TPGRANK, TPGRANKMIN, TPGRANKMAX) ;
1318 
1319  dbe->setCurrentFolder(histFolder_+"/EffCurves/NisoEm/");
1320 
1321  trigEffThresh_ =
1322  dbe->book2D("trigEffThresh", "Rank occupancy >= 2x trig thresh",
1323  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1324 
1325  dbe->setCurrentFolder(histFolder_+"/EffCurves/NisoEm/ServiceData");
1326 
1327  trigEffThreshOcc_ =
1328  dbe->book2D("trigEffThreshOcc", "Rank occupancy >= 2x trig thresh",
1329  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1330  trigEffTriggThreshOcc_ =
1331  dbe->book2D("trigEffTriggThreshOcc", "Rank occupancy >= 2x trig thresh, triggered",
1332  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1333 
1334  dbe->setCurrentFolder(histFolder_+"/IsoEm");
1335 
1336  rctIsoEmEff1_ =
1337  dbe->book2D("rctIsoEmEff1", "rctIsoEmEff1", ETABINS, ETAMIN,
1338  ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1339 
1340  rctIsoEmEff1oneD_ =
1341  dbe->book1D("rctIsoEmEff1oneD", "rctIsoEmEff1oneD",
1342  CHNLBINS, CHNLMIN, CHNLMAX);
1343 
1344  rctIsoEmEff2_ =
1345  dbe->book2D("rctIsoEmEff2", "rctIsoEmEff2, energy matching required", ETABINS, ETAMIN,
1346  ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1347 
1348  rctIsoEmEff2oneD_ =
1349  dbe->book1D("rctIsoEmEff2oneD", "rctIsoEmEff2oneD, energy matching required",
1350  CHNLBINS, CHNLMIN, CHNLMAX);
1351 
1352  rctIsoEmIneff2_ =
1353  dbe->book2D("rctIsoEmIneff2", "rctIsoEmIneff2, energy matching required", ETABINS, ETAMIN,
1354  ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1355 
1356  rctIsoEmIneff2oneD_ =
1357  dbe->book1D("rctIsoEmIneff2oneD", "rctIsoEmIneff2oneD, energy matching required",
1358  CHNLBINS, CHNLMIN, CHNLMAX);
1359 
1360 
1361  rctIsoEmIneff_ =
1362  dbe->book2D("rctIsoEmIneff", "rctIsoEmIneff", ETABINS, ETAMIN,
1363  ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1364 
1365  rctIsoEmIneff1D_ =
1366  dbe->book1D("rctIsoEmIneff1D", "rctIsoEmIneff1D",
1367  CHNLBINS, CHNLMIN, CHNLMAX);
1368 
1369  rctIsoEmOvereff_ =
1370  dbe->book2D("rctIsoEmOvereff", "rctIsoEmOvereff", ETABINS, ETAMIN,
1371  ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1372 
1373  rctIsoEmOvereff1D_ =
1374  dbe->book1D("rctIsoEmOvereff1D", "rctIsoEmOvereff1D",
1375  CHNLBINS, CHNLMIN, CHNLMAX);
1376 
1377  dbe->setCurrentFolder(histFolder_+"/IsoEm/ServiceData");
1378 
1379  rctIsoEmDataOcc_ =
1380  dbe->book2D("rctIsoEmDataOcc", "rctIsoEmDataOcc", ETABINS, ETAMIN,
1381  ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1382 
1383  rctIsoEmDataOcc1D_ =
1384  dbe->book1D("rctIsoEmDataOcc1D", "rctIsoEmDataOcc1D",
1385  CHNLBINS, CHNLMIN, CHNLMAX);
1386 
1387  rctIsoEmEmulOcc_ =
1388  dbe->book2D("rctIsoEmEmulOcc", "rctIsoEmEmulOcc", ETABINS, ETAMIN,
1389  ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1390 
1391  rctIsoEmEmulOcc1D_ =
1392  dbe->book1D("rctIsoEmEmulOcc1D", "rctIsoEmEmulOcc1D",
1393  CHNLBINS, CHNLMIN, CHNLMAX);
1394 
1395  rctIsoEmEff1Occ_ =
1396  dbe->book2D("rctIsoEmEff1Occ", "rctIsoEmEff1Occ", ETABINS, ETAMIN,
1397  ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1398 
1399  rctIsoEmEff1Occ1D_ =
1400  dbe->book1D("rctIsoEmEff1Occ1D", "rctIsoEmEff1Occ1D",
1401  CHNLBINS, CHNLMIN, CHNLMAX);
1402 
1403  rctIsoEmEff2Occ_ =
1404  dbe->book2D("rctIsoEmEff2Occ", "rctIsoEmEff2Occ", ETABINS, ETAMIN,
1405  ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1406 
1407  rctIsoEmEff2Occ1D_ =
1408  dbe->book1D("rctIsoEmEff2Occ1D", "rctIsoEmEff2Occ1D",
1409  CHNLBINS, CHNLMIN, CHNLMAX);
1410 
1411  rctIsoEmIneff2Occ_ =
1412  dbe->book2D("rctIsoEmIneff2Occ", "rctIsoEmIneff2Occ", ETABINS, ETAMIN,
1413  ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1414 
1415  rctIsoEmIneff2Occ1D_ =
1416  dbe->book1D("rctIsoEmIneff2Occ1D", "rctIsoEmIneff2Occ1D",
1417  CHNLBINS, CHNLMIN, CHNLMAX);
1418 
1419  rctIsoEmIneffOcc_ =
1420  dbe->book2D("rctIsoEmIneffOcc", "rctIsoEmIneffOcc", ETABINS, ETAMIN,
1421  ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1422 
1423  rctIsoEmIneffOcc1D_ =
1424  dbe->book1D("rctIsoEmIneffOcc1D", "rctIsoEmIneffOcc1D",
1425  CHNLBINS, CHNLMIN, CHNLMAX);
1426 
1427  rctIsoEmOvereffOcc_ =
1428  dbe->book2D("rctIsoEmOvereffOcc", "rctIsoEmOvereffOcc", ETABINS, ETAMIN,
1429  ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1430 
1431  rctIsoEmOvereffOcc1D_ =
1432  dbe->book1D("rctIsoEmOvereffOcc1D", "rctIsoEmOvereffOcc1D",
1433  CHNLBINS, CHNLMIN, CHNLMAX);
1434 
1435 
1436  dbe->setCurrentFolder(histFolder_+"/NisoEm");
1437  rctNisoEmEff1_ =
1438  dbe->book2D("rctNisoEmEff1", "rctNisoEmEff1", ETABINS, ETAMIN,
1439  ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1440 
1441  rctNisoEmEff1oneD_ =
1442  dbe->book1D("rctNisoEmEff1oneD", "rctNisoEmEff1oneD",
1443  CHNLBINS, CHNLMIN, CHNLMAX);
1444 
1445  rctNisoEmEff2_ =
1446  dbe->book2D("rctNisoEmEff2", "rctNisoEmEff2, energy matching required", ETABINS, ETAMIN,
1447  ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1448 
1449  rctNisoEmEff2oneD_ =
1450  dbe->book1D("rctNisoEmEff2oneD", "rctNisoEmEff2oneD, energy matching required",
1451  CHNLBINS, CHNLMIN, CHNLMAX);
1452 
1453  rctNisoEmIneff2_ =
1454  dbe->book2D("rctNisoEmIneff2", "rctNisoEmIneff2, energy matching required", ETABINS, ETAMIN,
1455  ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1456 
1457  rctNisoEmIneff2oneD_ =
1458  dbe->book1D("rctNisoEmIneff2oneD", "rctNisoEmIneff2oneD, energy matching required",
1459  CHNLBINS, CHNLMIN, CHNLMAX);
1460 
1461 
1462  rctNisoEmIneff_ =
1463  dbe->book2D("rctNisoEmIneff", "rctNisoEmIneff", ETABINS, ETAMIN,
1464  ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1465 
1466  rctNisoEmIneff1D_ =
1467  dbe->book1D("rctNisoEmIneff1D", "rctNisoEmIneff1D",
1468  CHNLBINS, CHNLMIN, CHNLMAX);
1469 
1470  rctNisoEmOvereff_ =
1471  dbe->book2D("rctNisoEmOvereff", "rctNisoEmOvereff", ETABINS, ETAMIN,
1472  ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1473 
1474  rctNisoEmOvereff1D_ =
1475  dbe->book1D("rctNisoEmOvereff1D", "rctNisoEmOvereff1D",
1476  CHNLBINS, CHNLMIN, CHNLMAX);
1477 
1478  dbe->setCurrentFolder(histFolder_+"/NisoEm/ServiceData");
1479 
1480  rctNisoEmDataOcc_ =
1481  dbe->book2D("rctNisoEmDataOcc", "rctNisoEmDataOcc", ETABINS, ETAMIN,
1482  ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1483 
1484  rctNisoEmDataOcc1D_ =
1485  dbe->book1D("rctNisoEmDataOcc1D", "rctNisoEmDataOcc1D",
1486  CHNLBINS, CHNLMIN, CHNLMAX);
1487 
1488  rctNisoEmEmulOcc_ =
1489  dbe->book2D("rctNisoEmEmulOcc", "rctNisoEmEmulOcc", ETABINS, ETAMIN,
1490  ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1491 
1492  rctNisoEmEmulOcc1D_ =
1493  dbe->book1D("rctNisoEmEmulOcc1D", "rctNisoEmEmulOcc1D",
1494  CHNLBINS, CHNLMIN, CHNLMAX);
1495 
1496  rctNisoEmEff1Occ_ =
1497  dbe->book2D("rctNisoEmEff1Occ", "rctNisoEmEff1Occ", ETABINS, ETAMIN,
1498  ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1499 
1500  rctNisoEmEff1Occ1D_ =
1501  dbe->book1D("rctNisoEmEff1Occ1D", "rctNisoEmEff1Occ1D",
1502  CHNLBINS, CHNLMIN, CHNLMAX);
1503 
1504  rctNisoEmEff2Occ_ =
1505  dbe->book2D("rctNisoEmEff2Occ", "rctNisoEmEff2Occ", ETABINS, ETAMIN,
1506  ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1507 
1508  rctNisoEmEff2Occ1D_ =
1509  dbe->book1D("rctNisoEmEff2Occ1D", "rctNisoEmEff2Occ1D",
1510  CHNLBINS, CHNLMIN, CHNLMAX);
1511 
1512  rctNisoEmIneff2Occ_ =
1513  dbe->book2D("rctNisoEmIneff2Occ", "rctNisoEmIneff2Occ", ETABINS, ETAMIN,
1514  ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1515 
1516  rctNisoEmIneff2Occ1D_ =
1517  dbe->book1D("rctNisoEmIneff2Occ1D", "rctNisoEmIneff2Occ1D",
1518  CHNLBINS, CHNLMIN, CHNLMAX);
1519 
1520  rctNisoEmIneffOcc_ =
1521  dbe->book2D("rctNisoEmIneffOcc", "rctNisoEmIneffOcc", ETABINS, ETAMIN,
1522  ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1523 
1524  rctNisoEmIneffOcc1D_ =
1525  dbe->book1D("rctNisoEmIneffOcc1D", "rctNisoEmIneffOcc1D",
1526  CHNLBINS, CHNLMIN, CHNLMAX);
1527 
1528  rctNisoEmOvereffOcc_ =
1529  dbe->book2D("rctNisoEmOvereffOcc", "rctNisoEmOvereffOcc", ETABINS, ETAMIN,
1530  ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1531 
1532  rctNisoEmOvereffOcc1D_ =
1533  dbe->book1D("rctNisoEmOvereffOcc1D", "rctNisoEmOvereffOcc1D",
1534  CHNLBINS, CHNLMIN, CHNLMAX);
1535 
1536  // region information
1537  dbe->setCurrentFolder(histFolder_+"/RegionData");
1538 
1539  rctRegEff1D_ =
1540  dbe->book1D("rctRegEff1D", "1D region efficiency",
1541  CHNLBINS, CHNLMIN, CHNLMAX);
1542 
1543  rctRegIneff1D_ =
1544  dbe->book1D("rctRegIneff1D", "1D region inefficiency",
1545  CHNLBINS, CHNLMIN, CHNLMAX);
1546 
1547  rctRegOvereff1D_ =
1548  dbe->book1D("rctRegOvereff1D", "1D region overefficiency",
1549  CHNLBINS, CHNLMIN, CHNLMAX);
1550 
1551  rctRegSpEff1D_ =
1552  dbe->book1D("rctRegSpEff1D", "1D region efficiency, energy matching required",
1553  CHNLBINS, CHNLMIN, CHNLMAX);
1554 
1555  rctRegSpIneff1D_ =
1556  dbe->book1D("rctRegSpIneff1D", "1D region inefficiency, energy matching required",
1557  CHNLBINS, CHNLMIN, CHNLMAX);
1558 
1559  rctRegEff2D_ =
1560  dbe->book2D("rctRegEff2D", "2D region efficiency",
1561  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1562 
1563  rctRegIneff2D_ =
1564  dbe->book2D("rctRegIneff2D", "2D region inefficiency",
1565  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1566 
1567  rctRegOvereff2D_ =
1568  dbe->book2D("rctRegOvereff2D", "2D region overefficiency",
1569  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1570 
1571  rctRegSpEff2D_ =
1572  dbe->book2D("rctRegSpEff2D", "2D region efficiency, energy matching required",
1573  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1574 
1575  rctRegSpIneff2D_ =
1576  dbe->book2D("rctRegSpIneff2D", "2D region inefficiency, energy matching required",
1577  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1578 
1579  dbe->setCurrentFolder(histFolder_+"/RegionData/ServiceData");
1580 
1581  rctRegDataOcc1D_ =
1582  dbe->book1D("rctRegDataOcc1D", "1D region occupancy from data",
1583  CHNLBINS, CHNLMIN, CHNLMAX);
1584 
1585  rctRegEmulOcc1D_ =
1586  dbe->book1D("rctRegEmulOcc1D", "1D region occupancy from emulator",
1587  CHNLBINS, CHNLMIN, CHNLMAX);
1588 
1589  rctRegMatchedOcc1D_ =
1590  dbe->book1D("rctRegMatchedOcc1D", "1D region occupancy for matched hits",
1591  CHNLBINS, CHNLMIN, CHNLMAX);
1592 
1593  rctRegUnmatchedDataOcc1D_ =
1594  dbe->book1D("rctRegUnmatchedDataOcc1D", "1D region occupancy for unmatched hardware hits",
1595  CHNLBINS, CHNLMIN, CHNLMAX);
1596 
1597  rctRegUnmatchedEmulOcc1D_ =
1598  dbe->book1D("rctRegUnmatchedEmulOcc1D", "1D region occupancy for unmatched emulator hits",
1599  CHNLBINS, CHNLMIN, CHNLMAX);
1600 
1601  rctRegSpEffOcc1D_ =
1602  dbe->book1D("rctRegSpEffOcc1D", "1D region occupancy for \\Delta E_{T} efficiency",
1603  CHNLBINS, CHNLMIN, CHNLMAX);
1604 
1605  rctRegSpIneffOcc1D_ =
1606  dbe->book1D("rctRegSpIneffOcc1D", "1D region occupancy for \\Delta E_{T} efficiency ",
1607  CHNLBINS, CHNLMIN, CHNLMAX);
1608 
1609  rctRegDataOcc2D_ =
1610  dbe->book2D("rctRegDataOcc2D", "2D region occupancy from hardware",
1611  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1612 
1613  rctRegEmulOcc2D_ =
1614  dbe->book2D("rctRegEmulOcc2D", "2D region occupancy from emulator",
1615  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1616 
1617  rctRegMatchedOcc2D_ =
1618  dbe->book2D("rctRegMatchedOcc2D", "2D region occupancy for matched hits",
1619  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1620 
1621  rctRegUnmatchedDataOcc2D_ =
1622  dbe->book2D("rctRegUnmatchedDataOcc2D", "2D region occupancy for unmatched hardware hits",
1623  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1624 
1625  rctRegUnmatchedEmulOcc2D_ =
1626  dbe->book2D("rctRegUnmatchedEmulOcc2D", "2D region occupancy for unmatched emulator hits",
1627  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1628 
1629 // rctRegDeltaEt2D_ =
1630 // dbe->book2D("rctRegDeltaEt2D", " \\Delta E_{T} for each channel",
1631 // CHNLBINS, CHNLMIN, CHNLMAX, 100, -50., 50.);
1632 
1633  rctRegSpEffOcc2D_ =
1634  dbe->book2D("rctRegSpEffOcc2D", "2D region occupancy for \\Delta E_{T} efficiency",
1635  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1636 
1637  rctRegSpIneffOcc2D_ =
1638  dbe->book2D("rctRegSpIneffOcc2D", "2D region occupancy for \\Delta E_{T} inefficiency",
1639  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1640 
1641  // bit information
1642  dbe->setCurrentFolder(histFolder_+"/BitData");
1643 
1644  rctBitOverFlowEff2D_ =
1645  dbe->book2D("rctBitOverFlowEff2D", "2D overflow bit efficiency",
1646  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1647 
1648  rctBitOverFlowIneff2D_ =
1649  dbe->book2D("rctBitOverFlowIneff2D", "2D overflow bit inefficiency",
1650  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1651 
1652  rctBitOverFlowOvereff2D_ =
1653  dbe->book2D("rctBitOverFlowOvereff2D", "2D overflow bit overefficiency",
1654  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1655 
1656  rctBitTauVetoEff2D_ =
1657  dbe->book2D("rctBitTauVetoEff2D", "2D tau veto bit efficiency",
1658  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1659 
1660  rctBitTauVetoIneff2D_ =
1661  dbe->book2D("rctBitTauVetoIneff2D", "2D tau veto bit inefficiency",
1662  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1663 
1664  rctBitTauVetoOvereff2D_ =
1665  dbe->book2D("rctBitTauVetoOvereff2D", "2D tau veto bit overefficiency",
1666  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1667 
1668  rctBitMipEff2D_ =
1669  dbe->book2D("rctBitMipEff2D", "2D mip bit efficiency",
1670  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1671 
1672  rctBitMipIneff2D_ =
1673  dbe->book2D("rctBitMipIneff2D", "2D mip bit inefficiency",
1674  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1675 
1676  rctBitMipOvereff2D_ =
1677  dbe->book2D("rctBitMipOvereff2D", "2D mip bit overefficiency",
1678  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1679 
1680  // QUIETBIT: To add quiet bit information, uncomment following 11 lines:
1681  // rctBitQuietEff2D_ =
1682  // dbe->book2D("rctBitQuietEff2D", "2D quiet bit efficiency",
1683  // ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1684 
1685  // rctBitQuietIneff2D_ =
1686  // dbe->book2D("rctBitQuietIneff2D", "2D quiet bit inefficiency",
1687  // ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1688 
1689  // rctBitQuietOvereff2D_ =
1690  // dbe->book2D("rctBitQuietOvereff2D", "2D quiet bit overefficiency",
1691  // ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1692 
1693  rctBitHfPlusTauEff2D_ =
1694  dbe->book2D("rctBitHfPlusTauEff2D", "2D HfPlusTau bit efficiency",
1695  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1696 
1697  rctBitHfPlusTauIneff2D_ =
1698  dbe->book2D("rctBitHfPlusTauIneff2D", "2D HfPlusTau bit inefficiency",
1699  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1700 
1701  rctBitHfPlusTauOvereff2D_ =
1702  dbe->book2D("rctBitHfPlusTauOvereff2D", "2D HfPlusTau bit overefficiency",
1703  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1704 
1705  dbe->setCurrentFolder(histFolder_+"/BitData/ServiceData");
1706 
1707  rctBitEmulOverFlow2D_ =
1708  dbe->book2D("rctBitEmulOverFlow2D", "2D overflow bit from emulator",
1709  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1710 
1711  rctBitDataOverFlow2D_ =
1712  dbe->book2D("rctBitDataOverFlow2D", "2D overflow bit from hardware",
1713  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1714 
1715  rctBitMatchedOverFlow2D_ =
1716  dbe->book2D("rctBitMatchedOverFlow2D", "2D overflow bit for matched hits",
1717  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1718 
1719  rctBitUnmatchedEmulOverFlow2D_ =
1720  dbe->book2D("rctBitUnmatchedEmulOverFlow2D", "2D overflow bit for unmatched emulator hits",
1721  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1722 
1723  rctBitUnmatchedDataOverFlow2D_ =
1724  dbe->book2D("rctBitUnmatchedDataOverFlow2D", "2D overflow bit for unmatched hardware hits",
1725  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1726 
1727  rctBitEmulTauVeto2D_ =
1728  dbe->book2D("rctBitEmulTauVeto2D", "2D tau veto bit from emulator",
1729  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1730 
1731  rctBitDataTauVeto2D_ =
1732  dbe->book2D("rctBitDataTauVeto2D", "2D tau veto bit from hardware",
1733  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1734 
1735  rctBitMatchedTauVeto2D_ =
1736  dbe->book2D("rctBitMatchedTauVeto2D", "2D tau veto bit for matched hits",
1737  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1738 
1739  rctBitUnmatchedEmulTauVeto2D_ =
1740  dbe->book2D("rctBitUnmatchedEmulTauVeto2D", "2D tau veto bit for unmatched emulator hits",
1741  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1742 
1743  rctBitUnmatchedDataTauVeto2D_ =
1744  dbe->book2D("rctBitUnmatchedDataTauVeto2D", "2D tau veto bit for unmatched hardware hits",
1745  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1746 
1747  rctBitEmulMip2D_ =
1748  dbe->book2D("rctBitEmulMip2D", "2D mip bit from emulator",
1749  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1750 
1751  rctBitDataMip2D_ =
1752  dbe->book2D("rctBitDataMip2D", "2D mip bit from hardware",
1753  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1754 
1755  rctBitMatchedMip2D_ =
1756  dbe->book2D("rctBitMatchedMip2D", "2D mip bit for matched hits",
1757  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1758 
1759  rctBitUnmatchedEmulMip2D_ =
1760  dbe->book2D("rctBitUnmatchedEmulMip2D", "2D mip bit for unmatched emulator hits",
1761  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1762 
1763  rctBitUnmatchedDataMip2D_ =
1764  dbe->book2D("rctBitUnmatchedDataMip2D", "2D mip bit for unmatched hardware hits",
1765  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1766 
1767  rctBitEmulQuiet2D_ =
1768  dbe->book2D("rctBitEmulQuiet2D", "2D quiet bit from emulator",
1769  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1770 
1771  rctBitDataQuiet2D_ =
1772  dbe->book2D("rctBitDataQuiet2D", "2D quiet bit from hardware",
1773  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1774 
1775  rctBitMatchedQuiet2D_ =
1776  dbe->book2D("rctBitMatchedQuiet2D", "2D quiet bit for matched hits",
1777  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1778 
1779  rctBitUnmatchedEmulQuiet2D_ =
1780  dbe->book2D("rctBitUnmatchedEmulQuiet2D", "2D quiet bit for unmatched emulator hits",
1781  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1782 
1783  rctBitUnmatchedDataQuiet2D_ =
1784  dbe->book2D("rctBitUnmatchedDataQuiet2D", "2D quiet bit for unmatched hardware hits",
1785  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1786 
1787  rctBitEmulHfPlusTau2D_ =
1788  dbe->book2D("rctBitEmulHfPlusTau2D", "2D HfPlusTau bit from emulator",
1789  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1790 
1791  rctBitDataHfPlusTau2D_ =
1792  dbe->book2D("rctBitDataHfPlusTau2D", "2D HfPlusTau bit from hardware",
1793  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1794 
1795  rctBitMatchedHfPlusTau2D_ =
1796  dbe->book2D("rctBitMatchedHfPlusTau2D", "2D HfPlusTau bit for matched hits",
1797  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1798 
1799  rctBitUnmatchedEmulHfPlusTau2D_ =
1800  dbe->book2D("rctBitUnmatchedEmulHfPlusTau2D", "2D HfPlusTau bit for unmatched emulator hits",
1801  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1802 
1803  rctBitUnmatchedDataHfPlusTau2D_ =
1804  dbe->book2D("rctBitUnmatchedDataHfPlusTau2D", "2D HfPlusTau bit for unmatched hardware hits",
1805  ETABINS, ETAMIN, ETAMAX, PHIBINS, PHIMIN, PHIMAX);
1806 
1807  dbe->setCurrentFolder(histFolder_+"/BitMon");
1808  rctRegBitOn_ =
1809  dbe->book2D("rctRegBitOn", "Monitoring for Bits Stuck On",
1810  BITETABINS, BITETAMIN, BITETAMAX, BITRPHIBINS, BITRPHIMIN, BITRPHIMAX);
1811 
1812  rctRegBitOff_ =
1813  dbe->book2D("rctRegBitOff", "Monitoring for Bits Stuck Off",
1814  BITETABINS, BITETAMIN, BITETAMAX, BITRPHIBINS, BITRPHIMIN, BITRPHIMAX);
1815 
1816  rctRegBitDiff_ =
1817  dbe->book2D("rctRegBitDiff", "Monitoring for Bits Difference",
1818  BITETABINS, BITETAMIN, BITETAMAX, BITRPHIBINS, BITRPHIMIN, BITRPHIMAX);
1819 
1820  rctIsoEmBitOn_ =
1821  dbe->book2D("rctIsoEmBitOn", "Monitoring for Bits Stuck On",
1822  BITETABINS, BITETAMIN, BITETAMAX, BITPHIBINS, BITPHIMIN, BITPHIMAX);
1823 
1824  rctIsoEmBitOff_ =
1825  dbe->book2D("rctIsoEmBitOff", "Monitoring for Bits Stuck Off",
1826  BITETABINS, BITETAMIN, BITETAMAX, BITPHIBINS, BITPHIMIN, BITPHIMAX);
1827 
1828  rctIsoEmBitDiff_ =
1829  dbe->book2D("rctIsoEmBitDiff", "Monitoring for Bits Difference",
1830  BITETABINS, BITETAMIN, BITETAMAX, BITPHIBINS, BITPHIMIN, BITPHIMAX);
1831 
1832  rctNIsoEmBitOn_ =
1833  dbe->book2D("rctNIsoEmBitOn", "Monitoring for Bits Stuck On",
1834  BITETABINS, BITETAMIN, BITETAMAX, BITPHIBINS, BITPHIMIN, BITPHIMAX);
1835 
1836  rctNIsoEmBitOff_ =
1837  dbe->book2D("rctNIsoEmBitOff", "Monitoring for Bits Stuck Off",
1838  BITETABINS, BITETAMIN, BITETAMAX, BITPHIBINS, BITPHIMIN, BITPHIMAX);
1839 
1840  rctNIsoEmBitDiff_ =
1841  dbe->book2D("rctNIsoEmBitDiff", "Monitoring for Bits Difference",
1842  BITETABINS, BITETAMIN, BITETAMAX, BITPHIBINS, BITPHIMIN, BITPHIMAX);
1843 
1844 
1845  dbe->setCurrentFolder(histFolder_+"/DBData");
1846  fedVectorMonitorRUN_ = dbe->book2D("rctFedVectorMonitorRUN", "FED Vector Monitor Per Run",90,0,90,2,0,2);
1847  fedVectorMonitorLS_ = dbe->book2D("rctFedVectorMonitorLS", "FED Vector Monitor Per LS",90,0,90,2,0,2);
1848 
1849  for(unsigned int i=0;i<90;++i) {
1850  char fed[10];
1851  sprintf(fed,"%d",crateFED[i]);
1852  fedVectorMonitorRUN_->getTH2F()->GetXaxis()->SetBinLabel(i+1,fed);
1853  fedVectorMonitorLS_->getTH2F()->GetXaxis()->SetBinLabel(i+1,fed);
1854  }
1855  fedVectorMonitorRUN_->getTH2F()->GetYaxis()->SetBinLabel(1,"OUT");
1856  fedVectorMonitorRUN_->getTH2F()->GetYaxis()->SetBinLabel(2,"IN");
1857  fedVectorMonitorLS_->getTH2F()->GetYaxis()->SetBinLabel(1,"OUT");
1858  fedVectorMonitorLS_->getTH2F()->GetYaxis()->SetBinLabel(2,"IN");
1859 
1860 
1861 
1862 // for single channels
1863 
1864  if(singlechannelhistos_)
1865  {
1866  for(int m=0; m<12; m++)
1867  {
1868  if(m==0) dbe->setCurrentFolder(histFolder_+"/IsoEm/ServiceData/Eff1SnglChnls");
1869  if(m==1) dbe->setCurrentFolder(histFolder_+"/NisoEm/ServiceData/Eff1SnglChnls");
1870  if(m==2) dbe->setCurrentFolder(histFolder_+"/RegionData/ServiceData/EffSnglChnls");
1871  if(m==3) dbe->setCurrentFolder(histFolder_+"/IsoEm/ServiceData/IneffSnglChnls");
1872  if(m==4) dbe->setCurrentFolder(histFolder_+"/NisoEm/ServiceData/IneffSnglChnls");
1873  if(m==5) dbe->setCurrentFolder(histFolder_+"/RegionData/ServiceData/IneffSnglChnls");
1874  if(m==6) dbe->setCurrentFolder(histFolder_+"/IsoEm/ServiceData/OvereffSnglChnls");
1875  if(m==7) dbe->setCurrentFolder(histFolder_+"/NisoEm/ServiceData/OvereffSnglChnls");
1876  if(m==8) dbe->setCurrentFolder(histFolder_+"/RegionData/ServiceData/OvereffSnglChnls");
1877  if(m==9) dbe->setCurrentFolder(histFolder_+"/EffCurves/NisoEm/ServiceData/SingleChannels");
1878  if(m==10) dbe->setCurrentFolder(histFolder_+"/EffCurves/NisoEm/ServiceData/SingleChannels");
1879  if(m==11) dbe->setCurrentFolder(histFolder_+"/EffCurves/NisoEm/ServiceData/SingleChannels");
1880 
1881  for(int i=0; i<ETAMAX; i++)
1882  {
1883  for(int j=0; j<PHIMAX; j++)
1884  {
1885  char name[80], channel[80]={""} ;
1886 
1887  if(m==0) strcpy(name,"(Eemul-Edata)Chnl") ;
1888  if(m==1) strcpy(name,"(Eemul-Edata)Chnl") ;
1889  if(m==2) strcpy(name,"(Eemul-Edata)Chnl") ;
1890  if(m==3) strcpy(name,"EemulChnl") ;
1891  if(m==4) strcpy(name,"EemulChnl") ;
1892  if(m==5) strcpy(name,"EemulChnl") ;
1893  if(m==6) strcpy(name,"EdataChnl") ;
1894  if(m==7) strcpy(name,"EdataChnl") ;
1895  if(m==8) strcpy(name,"EdataChnl") ;
1896  if(m==9) strcpy(name,"EemulChnlEff") ;
1897  if(m==10) strcpy(name,"EemulChnlTrig") ;
1898  if(m==11) strcpy(name,"EemulChnl") ;
1899 
1900  if(i<10 && j<10) sprintf(channel,"_0%d0%d",i,j);
1901  else if(i<10) sprintf(channel,"_0%d%d",i,j);
1902  else if(j<10) sprintf(channel,"_%d0%d",i,j);
1903  else sprintf(channel,"_%d%d",i,j);
1904  strcat(name,channel);
1905 
1906  int chnl=PHIBINS*i+j;
1907 
1908  if(m==0) rctIsoEffChannel_[chnl] =
1909  dbe->book1D(name, name, DEBINS, DEMIN, DEMAX);
1910  if(m==1) rctNisoEffChannel_[chnl] =
1911  dbe->book1D(name, name, DEBINS, DEMIN, DEMAX);
1912  if(m==2) rctRegEffChannel_[chnl] =
1913  dbe->book1D(name, name, DEBINS, DEMIN, DEMAX);
1914  if(m==3) rctIsoIneffChannel_[chnl] =
1915  dbe->book1D(name, name, DEBINS, DEMIN, DEMAX);
1916  if(m==4) rctNisoIneffChannel_[chnl] =
1917  dbe->book1D(name, name, DEBINS, DEMIN, DEMAX);
1918  if(m==5) rctRegIneffChannel_[chnl] =
1919  dbe->book1D(name, name, DEBINS, DEMIN, DEMAX);
1920  if(m==6) rctIsoOvereffChannel_[chnl] =
1921  dbe->book1D(name, name, DEBINS, DEMIN, DEMAX);
1922  if(m==7) rctNisoOvereffChannel_[chnl] =
1923  dbe->book1D(name, name, DEBINS, DEMIN, DEMAX);
1924  if(m==8) rctRegOvereffChannel_[chnl] =
1925  dbe->book1D(name, name, DEBINS, DEMIN, DEMAX);
1926  if(m==9) trigEff_[chnl] =
1927  dbe->book1D(name, name, ELBINS, ELMIN, ELMAX);
1928  if(m==10) trigEffOcc_[chnl] =
1929  dbe->book1D(name, name, ELBINS, ELMIN, ELMAX);
1930  if(m==11) trigEffTriggOcc_[chnl] =
1931  dbe->book1D(name, name, ELBINS, ELMIN, ELMAX);
1932  }
1933  }
1934  }
1935  }
1936 
1937 //end of single channels
1938 
1939 
1940  }
1941  notrigCount=0;
1942  trigCount=0;
1943 
1944  readFEDVector(fedVectorMonitorRUN_,es);
1945 }
1946 
1947 void L1TdeRCT::beginLuminosityBlock(const edm::LuminosityBlock& ls,const edm::EventSetup& es)
1948 {
1949  readFEDVector(fedVectorMonitorLS_,es);
1950 }
1951 
1952 void L1TdeRCT::readFEDVector(MonitorElement* histogram,const edm::EventSetup& es)
1953 {
1954  // adding fed mask into channel mask
1955  edm::ESHandle<RunInfo> sum;
1956  es.get<RunInfoRcd>().get(sum);
1957  const RunInfo* summary=sum.product();
1958 
1959  std::vector<int> caloFeds; // pare down the feds to the intresting ones
1960 
1961  const std::vector<int> Feds = summary->m_fed_in;
1962  for(std::vector<int>::const_iterator cf = Feds.begin(); cf != Feds.end(); ++cf){
1963  int fedNum = *cf;
1964  if(fedNum > 600 && fedNum <724)
1965  caloFeds.push_back(fedNum);
1966  }
1967 
1968  for(unsigned int i=0;i<90;++i) {
1969  std::vector<int>::iterator fv = std::find(caloFeds.begin(),caloFeds.end(),crateFED[i]);
1970  if(fv!=caloFeds.end()) {
1971  histogram->setBinContent(i+1,2,1);
1972  histogram->setBinContent(i+1,1,0);
1973  }
1974  else
1975  {
1976  histogram->setBinContent(i+1,2,0);
1977  histogram->setBinContent(i+1,1,1);
1978 
1979  }
1980 
1981  }
1982 
1983 }
L1TdeRCT::rctBitUnmatchedDataTauVeto2D_
MonitorElement * rctBitUnmatchedDataTauVeto2D_
Definition: L1TdeRCT.h:140
L1TdeRCT::DivideME2D
void DivideME2D(MonitorElement *numerator, MonitorElement *denominator, MonitorElement *result)
Definition: L1TdeRCT.cc:1255
L1TdeRCT::rctRegUnmatchedDataOcc1D_
MonitorElement * rctRegUnmatchedDataOcc1D_
Definition: L1TdeRCT.h:95
L1TdeRCT::rctIsoEmBitDiff_
MonitorElement * rctIsoEmBitDiff_
Definition: L1TdeRCT.h:207
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
BITRPHIMAX
const float BITRPHIMAX
Definition: L1TdeRCT.cc:48
PHIMAX
#define PHIMAX
Definition: HcalBaseMonitor.cc:6
i
int i
Definition: DBlmapReader.cc:9
L1TdeRCT::rctRegMatchedOcc1D_
MonitorElement * rctRegMatchedOcc1D_
Definition: L1TdeRCT.h:94
L1TdeRCT::rctNisoEmEmulOcc1D_
MonitorElement * rctNisoEmEmulOcc1D_
Definition: L1TdeRCT.h:223
L1TdeRCT::rctNisoEmIneff2oneD_
MonitorElement * rctNisoEmIneff2oneD_
Definition: L1TdeRCT.h:231
L1CaloEmCollection
std::vector< L1CaloEmCand > L1CaloEmCollection
Definition: L1CaloCollections.h:10
L1TdeRCT::rctNisoEmIneff1D_
MonitorElement * rctNisoEmIneff1D_
Definition: L1TdeRCT.h:232
BITRPHIMIN
const float BITRPHIMIN
Definition: L1TdeRCT.cc:47
L1TdeRCT::dbe
DQMStore * dbe
Definition: L1TdeRCT.h:83
MonitorElement::setBinContent
void setBinContent(int binx, double content)
set content of bin (1-D)
Definition: MonitorElement.cc:854
L1TdeRCT::rctNisoEmEff2Occ1D_
MonitorElement * rctNisoEmEff2Occ1D_
Definition: L1TdeRCT.h:225
L1TdeRCT::beginRun
void beginRun(const edm::Run &, const edm::EventSetup &)
Definition: L1TdeRCT.cc:1276
L1TdeRCT::rctInputTPGHcalOcc_
MonitorElement * rctInputTPGHcalOcc_
Definition: L1TdeRCT.h:175
TPGETABINS
const unsigned int TPGETABINS
Definition: L1TdeRCT.cc:54
L1TdeRCT::rctNisoEmEff2oneD_
MonitorElement * rctNisoEmEff2oneD_
Definition: L1TdeRCT.h:230
L1TdeRCT::~L1TdeRCT
virtual ~L1TdeRCT()
Definition: L1TdeRCT.cc:159
L1TdeRCT::rctNisoEmIneff2Occ1D_
MonitorElement * rctNisoEmIneff2Occ1D_
Definition: L1TdeRCT.h:226
cuy.numerator
list numerator
Definition: cuy.py:483
ELMIN
const float ELMIN
Definition: L1TdeRCT.cc:67
L1TdeRCT::rctBitMatchedTauVeto2D_
MonitorElement * rctBitMatchedTauVeto2D_
Definition: L1TdeRCT.h:138
ELBINS
const unsigned int ELBINS
Definition: L1TdeRCT.cc:66
L1TdeRCT::rctBitDataMip2D_
MonitorElement * rctBitDataMip2D_
Definition: L1TdeRCT.h:145
L1TdeRCT::rctBitUnmatchedDataHfPlusTau2D_
MonitorElement * rctBitUnmatchedDataHfPlusTau2D_
Definition: L1TdeRCT.h:165
L1TdeRCT::nev_
int nev_
Definition: L1TdeRCT.h:271
L1TdeRCT::rctBitEmulTauVeto2D_
MonitorElement * rctBitEmulTauVeto2D_
Definition: L1TdeRCT.h:136
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:446
L1TdeRCT::rctIsoEmIneff2Occ_
MonitorElement * rctIsoEmIneff2Occ_
Definition: L1TdeRCT.h:183
L1TdeRCT::readFEDVector
void readFEDVector(MonitorElement *, const edm::EventSetup &)
Definition: L1TdeRCT.cc:1952
L1TdeRCT::trigEffThresh_
MonitorElement * trigEffThresh_
Definition: L1TdeRCT.h:253
L1TdeRCT::rctBitHfPlusTauIneff2D_
MonitorElement * rctBitHfPlusTauIneff2D_
Definition: L1TdeRCT.h:167
L1TdeRCT::verbose_
bool verbose_
Definition: L1TdeRCT.h:274
L1TdeRCT::analyze
void analyze(const edm::Event &e, const edm::EventSetup &c)
Definition: L1TdeRCT.cc:185
L1TdeRCT::rctIsoEmIneff2Occ1D_
MonitorElement * rctIsoEmIneff2Occ1D_
Definition: L1TdeRCT.h:196
L1TdeRCT::rctIsoEmEmulOcc1D_
MonitorElement * rctIsoEmEmulOcc1D_
Definition: L1TdeRCT.h:193
L1TdeRCT::rctBitUnmatchedEmulTauVeto2D_
MonitorElement * rctBitUnmatchedEmulTauVeto2D_
Definition: L1TdeRCT.h:139
L1TdeRCT::rctSourceData_emData_
edm::EDGetTokenT< L1CaloEmCollection > rctSourceData_emData_
Definition: L1TdeRCT.h:282
L1TdeRCT::rctBitUnmatchedEmulQuiet2D_
MonitorElement * rctBitUnmatchedEmulQuiet2D_
Definition: L1TdeRCT.h:155
L1TdeRCT::outputFile_
std::string outputFile_
Definition: L1TdeRCT.h:272
L1TdeRCT::trigEffThreshOcc_
MonitorElement * trigEffThreshOcc_
Definition: L1TdeRCT.h:254
L1TdeRCT::rctNisoEffChannel_
MonitorElement * rctNisoEffChannel_[396]
Definition: L1TdeRCT.h:243
L1TdeRCT::rctRegOvereff1D_
MonitorElement * rctRegOvereff1D_
Definition: L1TdeRCT.h:102
edm::SortedCollection< EcalTriggerPrimitiveDigi >::const_iterator
std::vector< EcalTriggerPrimitiveDigi >::const_iterator const_iterator
Definition: SortedCollection.h:82
L1TdeRCT::doubleThreshold_
int doubleThreshold_
Definition: L1TdeRCT.h:287
L1TdeRCT::rctIsoEmEff2_
MonitorElement * rctIsoEmEff2_
Definition: L1TdeRCT.h:187
TPGETAMAX
const float TPGETAMAX
Definition: L1TdeRCT.cc:56
L1TdeRCT::rctNisoEmOvereffOcc1D_
MonitorElement * rctNisoEmOvereffOcc1D_
Definition: L1TdeRCT.h:228
L1TdeRCT::trigEffOcc_
MonitorElement * trigEffOcc_[396]
Definition: L1TdeRCT.h:257
L1TdeRCT::crateFED
static const int crateFED[90]
Definition: L1TdeRCT.h:264
L1TdeRCT::rctRegOvereff2D_
MonitorElement * rctRegOvereff2D_
Definition: L1TdeRCT.h:117
NULL
#define NULL
Definition: scimark2.h:8
L1TdeRCT::rctIsoEmOvereffOcc1D_
MonitorElement * rctIsoEmOvereffOcc1D_
Definition: L1TdeRCT.h:198
L1TdeRCT::triggerType_
MonitorElement * triggerType_
Definition: L1TdeRCT.h:89
L1TdeRCT::rctBitTauVetoEff2D_
MonitorElement * rctBitTauVetoEff2D_
Definition: L1TdeRCT.h:141
L1TdeRCT::rctBitMatchedQuiet2D_
MonitorElement * rctBitMatchedQuiet2D_
Definition: L1TdeRCT.h:154
L1TdeRCT::rctBitTauVetoOvereff2D_
MonitorElement * rctBitTauVetoOvereff2D_
Definition: L1TdeRCT.h:143
L1TdeRCT::rctRegDataOcc1D_
MonitorElement * rctRegDataOcc1D_
Definition: L1TdeRCT.h:92
L1TdeRCT::rctIsoEmIneffOcc_
MonitorElement * rctIsoEmIneffOcc_
Definition: L1TdeRCT.h:184
L1TdeRCT::rctBitDataQuiet2D_
MonitorElement * rctBitDataQuiet2D_
Definition: L1TdeRCT.h:153
L1TdeRCT::rctBitMatchedHfPlusTau2D_
MonitorElement * rctBitMatchedHfPlusTau2D_
Definition: L1TdeRCT.h:163
L1TdeRCT::rctIsoEmEff2Occ_
MonitorElement * rctIsoEmEff2Occ_
Definition: L1TdeRCT.h:182
spr::find
void find(edm::Handle< EcalRecHitCollection > &hits, DetId thisDet, std::vector< EcalRecHitCollection::const_iterator > &hit, bool debug=false)
Definition: FindCaloHit.cc:7
L1TdeRCT::rctRegEmulOcc2D_
MonitorElement * rctRegEmulOcc2D_
Definition: L1TdeRCT.h:107
L1TdeRCT::rctRegUnmatchedEmulOcc2D_
MonitorElement * rctRegUnmatchedEmulOcc2D_
Definition: L1TdeRCT.h:110
L1TdeRCT::gtDigisLabel_
edm::EDGetTokenT< L1GlobalTriggerReadoutRecord > gtDigisLabel_
Definition: L1TdeRCT.h:285
L1TdeRCT::rctRegSpEff2D_
MonitorElement * rctRegSpEff2D_
Definition: L1TdeRCT.h:118
L1TdeRCT::histFolder_
std::string histFolder_
Definition: L1TdeRCT.h:273
edm::EventBase::isRealData
bool isRealData() const
Definition: EventBase.h:60
L1TdeRCT::rctBitUnmatchedEmulOverFlow2D_
MonitorElement * rctBitUnmatchedEmulOverFlow2D_
Definition: L1TdeRCT.h:131
L1TdeRCT::endJob
void endJob(void)
Definition: L1TdeRCT.cc:169
L1TdeRCT::rctIsoEmBitOn_
MonitorElement * rctIsoEmBitOn_
Definition: L1TdeRCT.h:205
L1TdeRCT::rctRegIneff2D_
MonitorElement * rctRegIneff2D_
Definition: L1TdeRCT.h:116
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
L1TdeRCT::rctIsoEmEff2Occ1D_
MonitorElement * rctIsoEmEff2Occ1D_
Definition: L1TdeRCT.h:195
L1TdeRCT::singlechannelhistos_
bool singlechannelhistos_
Definition: L1TdeRCT.h:275
L1TdeRCT::rctBitMipIneff2D_
MonitorElement * rctBitMipIneff2D_
Definition: L1TdeRCT.h:150
TPGPHIMIN
const float TPGPHIMIN
Definition: L1TdeRCT.cc:51
L1TdeRCT::rctBitOverFlowOvereff2D_
MonitorElement * rctBitOverFlowOvereff2D_
Definition: L1TdeRCT.h:135
mathSSE::return
return((rh^lh)&mask)
MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:164
L1TdeRCT::rctInputTPGHcalSample_
MonitorElement * rctInputTPGHcalSample_
Definition: L1TdeRCT.h:177
L1TdeRCT::rctIsoEmOvereff_
MonitorElement * rctIsoEmOvereff_
Definition: L1TdeRCT.h:190
ETAMAX
#define ETAMAX
Definition: HcalBaseMonitor.cc:4
L1TdeRCT::rctBitDataOverFlow2D_
MonitorElement * rctBitDataOverFlow2D_
Definition: L1TdeRCT.h:129
L1TdeRCT::rctIsoEmDataOcc_
MonitorElement * rctIsoEmDataOcc_
Definition: L1TdeRCT.h:179
L1TdeRCT::fedVectorMonitorLS_
MonitorElement * fedVectorMonitorLS_
Definition: L1TdeRCT.h:266
CHNLMIN
const float CHNLMIN
Definition: L1TdeRCT.cc:72
L1TdeRCT::rctNisoEmEff1oneD_
MonitorElement * rctNisoEmEff1oneD_
Definition: L1TdeRCT.h:229
L1TdeRCT::hcalTPGData_
edm::EDGetTokenT< HcalTrigPrimDigiCollection > hcalTPGData_
Definition: L1TdeRCT.h:284
L1TdeRCT::rctNisoEmIneff2Occ_
MonitorElement * rctNisoEmIneff2Occ_
Definition: L1TdeRCT.h:213
L1TdeRCT::rctNisoEmOvereffOcc_
MonitorElement * rctNisoEmOvereffOcc_
Definition: L1TdeRCT.h:215
CHNLMAX
const float CHNLMAX
Definition: L1TdeRCT.cc:73
L1TdeRCT::rctRegBitOn_
MonitorElement * rctRegBitOn_
Definition: L1TdeRCT.h:121
L1TdeRCT::rctRegBitDiff_
MonitorElement * rctRegBitDiff_
Definition: L1TdeRCT.h:123
L1TdeRCT::rctNisoEmDataOcc_
MonitorElement * rctNisoEmDataOcc_
Definition: L1TdeRCT.h:209
L1TdeRCT::rctNisoEmIneff2_
MonitorElement * rctNisoEmIneff2_
Definition: L1TdeRCT.h:218
roll_playback.k
tuple k
Definition: roll_playback.py:138
DEMIN
const float DEMIN
Definition: L1TdeRCT.cc:63
L1TdeRCT::rctBitDataHfPlusTau2D_
MonitorElement * rctBitDataHfPlusTau2D_
Definition: L1TdeRCT.h:162
cuy.denominator
list denominator
Definition: cuy.py:484
L1TdeRCT::gtEGAlgoName_
std::string gtEGAlgoName_
Definition: L1TdeRCT.h:286
L1TdeRCT::DivideME1D
void DivideME1D(MonitorElement *numerator, MonitorElement *denominator, MonitorElement *result)
Definition: L1TdeRCT.cc:1265
ETAMIN
#define ETAMIN
Definition: HcalBaseMonitor.cc:5
L1TdeRCT::rctRegIneffChannel_
MonitorElement * rctRegIneffChannel_[396]
Definition: L1TdeRCT.h:249
L1TdeRCT::rctInputTPGEcalOcc_
MonitorElement * rctInputTPGEcalOcc_
Definition: L1TdeRCT.h:172
L1TdeRCT::rctRegDataOcc2D_
MonitorElement * rctRegDataOcc2D_
Definition: L1TdeRCT.h:106
L1TdeRCT::rctInputTPGEcalRank_
MonitorElement * rctInputTPGEcalRank_
Definition: L1TdeRCT.h:174
L1TdeRCT::rctIsoEmIneff1D_
MonitorElement * rctIsoEmIneff1D_
Definition: L1TdeRCT.h:202
HcalObjRepresent::Fill
void Fill(HcalDetId &id, double val, std::vector< TH2F > &depth)
Definition: HcalObjRepresent.h:611
BITPHIBINS
const unsigned int BITPHIBINS
Definition: L1TdeRCT.cc:42
DecisionWord
std::vector< bool > DecisionWord
typedefs
Definition: L1GlobalTriggerReadoutSetupFwd.h:34
RunInfo::m_fed_in
std::vector< int > m_fed_in
Definition: RunInfo.h:26
L1TdeRCT::rctBitMipOvereff2D_
MonitorElement * rctBitMipOvereff2D_
Definition: L1TdeRCT.h:151
query.result
tuple result
Definition: query.py:137
L1TdeRCT::trigEff_
MonitorElement * trigEff_[396]
Definition: L1TdeRCT.h:256
DEBINS
const unsigned int DEBINS
Definition: L1TdeRCT.cc:62
BITETAMAX
const float BITETAMAX
Definition: L1TdeRCT.cc:40
L1TdeRCT::rctBitMatchedOverFlow2D_
MonitorElement * rctBitMatchedOverFlow2D_
Definition: L1TdeRCT.h:130
CHNLBINS
const unsigned int CHNLBINS
Definition: L1TdeRCT.cc:71
L1TdeRCT::rctBitEmulOverFlow2D_
MonitorElement * rctBitEmulOverFlow2D_
Definition: L1TdeRCT.h:128
L1TdeRCT::rctRegEmulOcc1D_
MonitorElement * rctRegEmulOcc1D_
Definition: L1TdeRCT.h:93
L1TdeRCT::ecalTPGData_
edm::EDGetTokenT< EcalTrigPrimDigiCollection > ecalTPGData_
Definition: L1TdeRCT.h:283
L1TdeRCT::rctIsoEmBitOff_
MonitorElement * rctIsoEmBitOff_
Definition: L1TdeRCT.h:206
L1TdeRCT::fedVectorMonitorRUN_
MonitorElement * fedVectorMonitorRUN_
Definition: L1TdeRCT.h:265
L1TdeRCT::rctBitEmulMip2D_
MonitorElement * rctBitEmulMip2D_
Definition: L1TdeRCT.h:144
L1TdeRCT::rctIsoEmIneff2_
MonitorElement * rctIsoEmIneff2_
Definition: L1TdeRCT.h:188
L1TdeRCT::rctBitEmulQuiet2D_
MonitorElement * rctBitEmulQuiet2D_
Definition: L1TdeRCT.h:152
j
int j
Definition: DBlmapReader.cc:9
L1TdeRCT::rctNisoEmEmulOcc_
MonitorElement * rctNisoEmEmulOcc_
Definition: L1TdeRCT.h:210
L1TdeRCT::rctBitEmulHfPlusTau2D_
MonitorElement * rctBitEmulHfPlusTau2D_
Definition: L1TdeRCT.h:161
BITETAMIN
const float BITETAMIN
Definition: L1TdeRCT.cc:39
TPGRANKMAX
const float TPGRANKMAX
Definition: L1TdeRCT.cc:60
L1TdeRCT::triggerAlgoNumbers_
MonitorElement * triggerAlgoNumbers_
Definition: L1TdeRCT.h:86
BITPHIMIN
const float BITPHIMIN
Definition: L1TdeRCT.cc:43
L1TdeRCT::rctNisoIneffChannel_
MonitorElement * rctNisoIneffChannel_[396]
Definition: L1TdeRCT.h:244
L1TdeRCT::rctRegSpIneff2D_
MonitorElement * rctRegSpIneff2D_
Definition: L1TdeRCT.h:119
ELMAX
const float ELMAX
Definition: L1TdeRCT.cc:68
first
bool first
Definition: L1TdeRCT.cc:75
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:76
L1TdeRCT::rctIsoEmEmulOcc_
MonitorElement * rctIsoEmEmulOcc_
Definition: L1TdeRCT.h:180
PHIMIN
#define PHIMIN
Definition: HcalBaseMonitor.cc:7
L1TdeRCT::rctIsoEmEff1Occ_
MonitorElement * rctIsoEmEff1Occ_
Definition: L1TdeRCT.h:181
L1TdeRCT::rctNisoEmOvereff1D_
MonitorElement * rctNisoEmOvereff1D_
Definition: L1TdeRCT.h:233
L1TdeRCT::rctNisoEmEff2Occ_
MonitorElement * rctNisoEmEff2Occ_
Definition: L1TdeRCT.h:212
L1TdeRCT::rctBitUnmatchedEmulHfPlusTau2D_
MonitorElement * rctBitUnmatchedEmulHfPlusTau2D_
Definition: L1TdeRCT.h:164
L1TdeRCT::beginJob
void beginJob(void)
Definition: L1TdeRCT.cc:163
L1TdeRCT::rctRegEff1D_
MonitorElement * rctRegEff1D_
Definition: L1TdeRCT.h:100
L1TdeRCT::rctBitMatchedMip2D_
MonitorElement * rctBitMatchedMip2D_
Definition: L1TdeRCT.h:146
L1TdeRCT::rctNisoEmEff2_
MonitorElement * rctNisoEmEff2_
Definition: L1TdeRCT.h:217
L1TdeRCT::rctRegSpEff1D_
MonitorElement * rctRegSpEff1D_
Definition: L1TdeRCT.h:103
L1TdeRCT::rctIsoEmEff1Occ1D_
MonitorElement * rctIsoEmEff1Occ1D_
Definition: L1TdeRCT.h:194
L1TdeRCT::rctIsoEmEff1oneD_
MonitorElement * rctIsoEmEff1oneD_
Definition: L1TdeRCT.h:199
BITPHIMAX
const float BITPHIMAX
Definition: L1TdeRCT.cc:44
L1TdeRCT::notrigCount
int notrigCount
Definition: L1TdeRCT.h:293
L1TdeRCT::rctNisoEmIneff_
MonitorElement * rctNisoEmIneff_
Definition: L1TdeRCT.h:219
L1TdeRCT::rctRegSpEffOcc1D_
MonitorElement * rctRegSpEffOcc1D_
Definition: L1TdeRCT.h:97
L1TdeRCT::rctRegMatchedOcc2D_
MonitorElement * rctRegMatchedOcc2D_
Definition: L1TdeRCT.h:108
L1TdeRCT::rctNIsoEmBitDiff_
MonitorElement * rctNIsoEmBitDiff_
Definition: L1TdeRCT.h:237
L1TdeRCT::rctBitHfPlusTauOvereff2D_
MonitorElement * rctBitHfPlusTauOvereff2D_
Definition: L1TdeRCT.h:168
L1TdeRCT::rctNisoEmEff1Occ_
MonitorElement * rctNisoEmEff1Occ_
Definition: L1TdeRCT.h:211
L1TdeRCT::rctIsoEmOvereff1D_
MonitorElement * rctIsoEmOvereff1D_
Definition: L1TdeRCT.h:203
L1TdeRCT::rctIsoEmEff1_
MonitorElement * rctIsoEmEff1_
Definition: L1TdeRCT.h:186
L1TdeRCT::rctBitTauVetoIneff2D_
MonitorElement * rctBitTauVetoIneff2D_
Definition: L1TdeRCT.h:142
edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:55
ETABINS
#define ETABINS
Definition: HcalBaseMonitor.h:5
TPGRANK
const unsigned int TPGRANK
Definition: L1TdeRCT.cc:58
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
MonitorElement::getTH1F
TH1F * getTH1F(void) const
Definition: MonitorElement.cc:1527
L1TdeRCT::rctInputTPGHcalRank_
MonitorElement * rctInputTPGHcalRank_
Definition: L1TdeRCT.h:176
PhiEtaMax
const unsigned int PhiEtaMax
Definition: L1TdeRCT.cc:70
L1TdeRCT::trigEffTriggThreshOcc_
MonitorElement * trigEffTriggThreshOcc_
Definition: L1TdeRCT.h:255
L1TdeRCT::rctIsoEmIneffOcc1D_
MonitorElement * rctIsoEmIneffOcc1D_
Definition: L1TdeRCT.h:197
L1TdeRCT::rctRegEffChannel_
MonitorElement * rctRegEffChannel_[396]
Definition: L1TdeRCT.h:248
L1TdeRCT::rctBitHfPlusTauEff2D_
MonitorElement * rctBitHfPlusTauEff2D_
Definition: L1TdeRCT.h:166
L1TdeRCT::rctNisoEmIneffOcc1D_
MonitorElement * rctNisoEmIneffOcc1D_
Definition: L1TdeRCT.h:227
L1TdeRCT::rctRegOvereffChannel_
MonitorElement * rctRegOvereffChannel_[396]
Definition: L1TdeRCT.h:250
DEMAX
const float DEMAX
Definition: L1TdeRCT.cc:64
L1TdeRCT::rctBitOverFlowIneff2D_
MonitorElement * rctBitOverFlowIneff2D_
Definition: L1TdeRCT.h:134
L1TdeRCT::rctRegSpIneffOcc1D_
MonitorElement * rctRegSpIneffOcc1D_
Definition: L1TdeRCT.h:98
L1TdeRCT::rctBitUnmatchedDataMip2D_
MonitorElement * rctBitUnmatchedDataMip2D_
Definition: L1TdeRCT.h:148
L1TdeRCT::L1TdeRCT
L1TdeRCT(const edm::ParameterSet &ps)
Definition: L1TdeRCT.cc:101
L1TdeRCT::trigEffTriggOcc_
MonitorElement * trigEffTriggOcc_[396]
Definition: L1TdeRCT.h:258
TPGPHIBINS
const unsigned int TPGPHIBINS
Definition: L1TdeRCT.cc:50
L1TdeRCT::rctBitMipEff2D_
MonitorElement * rctBitMipEff2D_
Definition: L1TdeRCT.h:149
L1TdeRCT::rctIsoEmIneff2oneD_
MonitorElement * rctIsoEmIneff2oneD_
Definition: L1TdeRCT.h:201
L1TdeRCT::rctRegUnmatchedDataOcc2D_
MonitorElement * rctRegUnmatchedDataOcc2D_
Definition: L1TdeRCT.h:109
L1TdeRCT::rctBitUnmatchedEmulMip2D_
MonitorElement * rctBitUnmatchedEmulMip2D_
Definition: L1TdeRCT.h:147
L1TdeRCT::rctBitOverFlowEff2D_
MonitorElement * rctBitOverFlowEff2D_
Definition: L1TdeRCT.h:133
L1TdeRCT::rctNIsoEmBitOff_
MonitorElement * rctNIsoEmBitOff_
Definition: L1TdeRCT.h:236
L1TdeRCT::rctSourceEmul_rgnEmul_
edm::EDGetTokenT< L1CaloRegionCollection > rctSourceEmul_rgnEmul_
Definition: L1TdeRCT.h:279
L1TdeRCT::rctIsoIneffChannel_
MonitorElement * rctIsoIneffChannel_[396]
Definition: L1TdeRCT.h:240
L1TdeRCT::rctRegSpEffOcc2D_
MonitorElement * rctRegSpEffOcc2D_
Definition: L1TdeRCT.h:112
edm::EventBase::experimentType
edm::EventAuxiliary::ExperimentType experimentType() const
Definition: EventBase.h:61
PHIBINS
#define PHIBINS
Definition: HcalBaseMonitor.h:6
BITRPHIBINS
const unsigned int BITRPHIBINS
Definition: L1TdeRCT.cc:46
L1TdeRCT::rctIsoEmOvereffOcc_
MonitorElement * rctIsoEmOvereffOcc_
Definition: L1TdeRCT.h:185
L1TdeRCT::rctNisoEmDataOcc1D_
MonitorElement * rctNisoEmDataOcc1D_
Definition: L1TdeRCT.h:222
BITETABINS
const unsigned int BITETABINS
Definition: L1TdeRCT.cc:38
L1TdeRCT::rctSourceData_rgnData_
edm::EDGetTokenT< L1CaloRegionCollection > rctSourceData_rgnData_
Definition: L1TdeRCT.h:281
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:121
L1TdeRCT::rctNIsoEmBitOn_
MonitorElement * rctNIsoEmBitOn_
Definition: L1TdeRCT.h:235
L1TdeRCT::rctRegIneff1D_
MonitorElement * rctRegIneff1D_
Definition: L1TdeRCT.h:101
L1TdeRCT::rctNisoEmEff1Occ1D_
MonitorElement * rctNisoEmEff1Occ1D_
Definition: L1TdeRCT.h:224
L1TdeRCT::rctIsoEmDataOcc1D_
MonitorElement * rctIsoEmDataOcc1D_
Definition: L1TdeRCT.h:192
TPGRANKMIN
const float TPGRANKMIN
Definition: L1TdeRCT.cc:59
L1CaloRegionCollection
std::vector< L1CaloRegion > L1CaloRegionCollection
Definition: L1CaloCollections.h:11
edm::false
volatile std::atomic< bool > shutdown_flag false
Definition: UnixSignalHandlers.cc:22
L1TdeRCT::rctBitDataTauVeto2D_
MonitorElement * rctBitDataTauVeto2D_
Definition: L1TdeRCT.h:137
L1TdeRCT::rctIsoEffChannel_
MonitorElement * rctIsoEffChannel_[396]
Definition: L1TdeRCT.h:239
MonitorElement::getTH2F
TH2F * getTH2F(void) const
Definition: MonitorElement.cc:1551
edm::first
T first(std::pair< T, U > const &p)
Definition: ParameterSet.cc:244
TPGETAMIN
const float TPGETAMIN
Definition: L1TdeRCT.cc:55
L1TdeRCT::beginLuminosityBlock
void beginLuminosityBlock(const edm::LuminosityBlock &, const edm::EventSetup &)
Definition: L1TdeRCT.cc:1947
L1TdeRCT::rctNisoEmOvereff_
MonitorElement * rctNisoEmOvereff_
Definition: L1TdeRCT.h:220
L1TdeRCT::rctRegEff2D_
MonitorElement * rctRegEff2D_
Definition: L1TdeRCT.h:115
L1TdeRCT::filterTriggerType_
int filterTriggerType_
filter TriggerType
Definition: L1TdeRCT.h:290
L1TdeRCT::rctInputTPGEcalOccNoCut_
MonitorElement * rctInputTPGEcalOccNoCut_
Definition: L1TdeRCT.h:173
L1TdeRCT::rctNisoOvereffChannel_
MonitorElement * rctNisoOvereffChannel_[396]
Definition: L1TdeRCT.h:245
L1TdeRCT::rctNisoEmIneffOcc_
MonitorElement * rctNisoEmIneffOcc_
Definition: L1TdeRCT.h:214
L1TdeRCT::rctIsoEmEff2oneD_
MonitorElement * rctIsoEmEff2oneD_
Definition: L1TdeRCT.h:200
L1TdeRCT::rctSourceEmul_emEmul_
edm::EDGetTokenT< L1CaloEmCollection > rctSourceEmul_emEmul_
Definition: L1TdeRCT.h:280
L1TdeRCT::rctBitUnmatchedDataQuiet2D_
MonitorElement * rctBitUnmatchedDataQuiet2D_
Definition: L1TdeRCT.h:156
edm::Run
Definition: Run.h:41
L1TdeRCT::trigCount
int trigCount
Definition: L1TdeRCT.h:293
L1TdeRCT::rctRegSpIneff1D_
MonitorElement * rctRegSpIneff1D_
Definition: L1TdeRCT.h:104
L1TdeRCT::rctRegSpIneffOcc2D_
MonitorElement * rctRegSpIneffOcc2D_
Definition: L1TdeRCT.h:113
TPGPHIMAX
const float TPGPHIMAX
Definition: L1TdeRCT.cc:52
L1TdeRCT::rctRegBitOff_
MonitorElement * rctRegBitOff_
Definition: L1TdeRCT.h:122
L1TdeRCT::rctIsoEmIneff_
MonitorElement * rctIsoEmIneff_
Definition: L1TdeRCT.h:189
L1TdeRCT::rctRegUnmatchedEmulOcc1D_
MonitorElement * rctRegUnmatchedEmulOcc1D_
Definition: L1TdeRCT.h:96
L1TdeRCT::rctBitUnmatchedDataOverFlow2D_
MonitorElement * rctBitUnmatchedDataOverFlow2D_
Definition: L1TdeRCT.h:132
L1TdeRCT::rctIsoOvereffChannel_
MonitorElement * rctIsoOvereffChannel_[396]
Definition: L1TdeRCT.h:241
L1TdeRCT::rctNisoEmEff1_
MonitorElement * rctNisoEmEff1_
Definition: L1TdeRCT.h:216
AlcaSiStripGainsHarvester_cff.DQMStore
tuple DQMStore
Definition: AlcaSiStripGainsHarvester_cff.py:10
Generated for CMSSW Reference Manual by doxygen 1.8.5