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