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