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