CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
HcalDeadCellMonitor.cc
Go to the documentation of this file.
1 #include "DQM/HcalMonitorTasks/interface/HcalDeadCellMonitor.h"
2 #include "FWCore/Framework/interface/LuminosityBlock.h"
3 #include "CondFormats/HcalObjects/interface/HcalLogicalMap.h"
4 
5 HcalDeadCellMonitor::HcalDeadCellMonitor(const edm::ParameterSet& ps)
6 {
7  Online_ = ps.getUntrackedParameter<bool>("online",false);
8  mergeRuns_ = ps.getUntrackedParameter<bool>("mergeRuns",false);
9  enableCleanup_ = ps.getUntrackedParameter<bool>("enableCleanup",false);
10  debug_ = ps.getUntrackedParameter<int>("debug",0);
11  makeDiagnostics_ = ps.getUntrackedParameter<bool>("makeDiagnostics",false);
12  prefixME_ = ps.getUntrackedParameter<std::string>("subSystemFolder","Hcal/");
13  if (prefixME_.substr(prefixME_.size()-1,prefixME_.size())!="/")
14  prefixME_.append("/");
15  subdir_ = ps.getUntrackedParameter<std::string>("TaskFolder","DeadCellMonitor_Hcal"); // DeadCellMonitor_Hcal
16  if (subdir_.size()>0 && subdir_.substr(subdir_.size()-1,subdir_.size())!="/")
17  subdir_.append("/");
18  subdir_=prefixME_+subdir_;
19  AllowedCalibTypes_ = ps.getUntrackedParameter<std::vector<int> > ("AllowedCalibTypes");
20  skipOutOfOrderLS_ = ps.getUntrackedParameter<bool>("skipOutOfOrderLS",true);
21  NLumiBlocks_ = ps.getUntrackedParameter<int>("NLumiBlocks",4000);
22 
23  badChannelStatusMask_ = ps.getUntrackedParameter<int>("BadChannelStatusMask",
24  ps.getUntrackedParameter<int>("BadChannelStatusMask",
25  (1<<HcalChannelStatus::HcalCellDead))); // identify channel status values to mask
26  // DeadCell-specific parameters
27 
28  // Collection type info
29  digiLabel_ =ps.getUntrackedParameter<edm::InputTag>("digiLabel");
30  hbheRechitLabel_ = ps.getUntrackedParameter<edm::InputTag>("hbheRechitLabel");
31  hoRechitLabel_ = ps.getUntrackedParameter<edm::InputTag>("hoRechitLabel");
32  hfRechitLabel_ = ps.getUntrackedParameter<edm::InputTag>("hfRechitLabel");
33 
34  // minimum number of events required for lumi section-based dead cell checks
35  minDeadEventCount_ = ps.getUntrackedParameter<int>("minDeadEventCount",1000);
36  excludeHORing2_ = ps.getUntrackedParameter<bool>("excludeHORing2",false);
37  excludeHO1P02_ = ps.getUntrackedParameter<bool>("excludeHO1P02",false);
38  endLumiProcessed_ = false;
39 
40  // Set which dead cell checks will be performed
41  /* Dead cells can be defined in the following ways:
42  1) never present digi -- digi is never present in run
43  2) digis -- digi is absent for one or more lumi section
44  3) never present rechit -- rechit > threshold energy never present (NOT redundant, since it requires not just that a rechit be present, but that it be above threshold as well. )
45  4) rechits -- rechit is present, but rechit energy below threshold for one or more lumi sections
46 
47  Of these tests, never-present digis are always checked.
48  Occasional digis are checked only if deadmon_test_digis_ is true,
49  and both rechit tests are made only if deadmon_test_rechits_ is true
50  */
51 
52  deadmon_test_digis_ = ps.getUntrackedParameter<bool>("test_digis",true);
53  deadmon_test_rechits_ = ps.getUntrackedParameter<bool>("test_rechits",false);
54 
55  // rechit energy test -- cell must be below threshold value for a number of consecutive events to be considered dead
56  energyThreshold_ = ps.getUntrackedParameter<double>("MissingRechitEnergyThreshold",0);
57  HBenergyThreshold_ = ps.getUntrackedParameter<double>("HB_energyThreshold",energyThreshold_);
58  HEenergyThreshold_ = ps.getUntrackedParameter<double>("HE_energyThreshold",energyThreshold_);
59  HOenergyThreshold_ = ps.getUntrackedParameter<double>("HO_energyThreshold",energyThreshold_);
60  HFenergyThreshold_ = ps.getUntrackedParameter<double>("HF_energyThreshold",energyThreshold_);
61 
62  needLogicalMap_=true;
63  setupDone_=false;
64 } //constructor
65 
66 HcalDeadCellMonitor::~HcalDeadCellMonitor()
67 {
68 } //destructor
69 
70 
71 /* ------------------------------------ */
72 
73 void HcalDeadCellMonitor::setup()
74 {
75  if (setupDone_)
76  {
77  // Always do a zeroing/resetting so that empty histograms/counter
78  // will always appear.
79  zeroCounters(1); // make sure arrays are set up
80  this->reset();
81 
82  return;
83  }
84  else
85  setupDone_=true;
86 
87  HcalBaseDQMonitor::setup();
88  if (debug_>0)
89  std::cout <<"<HcalDeadCellMonitor::setup> Setting up histograms"<<std::endl;
90 
91  if (!dbe_) return;
92 
93  dbe_->setCurrentFolder(subdir_);
94  MonitorElement* excludeHO2=dbe_->bookInt("ExcludeHOring2");
95  // Fill with 0 if ring is not to be excluded; fill with 1 if it is to be excluded
96  if (excludeHO2) excludeHO2->Fill(excludeHORing2_==true ? 1 : 0);
97 
98  Nevents = dbe_->book1D("NumberOfDeadCellEvents","Number of Events Seen by DeadCellMonitor",2,0,2);
99  Nevents->setBinLabel(1,"allEvents");
100  Nevents->setBinLabel(2,"lumiCheck");
101  // 1D plots count number of bad cells vs. luminosity block
102  ProblemsVsLB=dbe_->bookProfile("TotalDeadCells_HCAL_vs_LS",
103  "Total Number of Dead Hcal Cells (excluding known problems) vs LS;Lumi Section;Dead Cells",
104  NLumiBlocks_,0.5,NLumiBlocks_+0.5,
105  100,0,10000);
106  ProblemsVsLB_HB=dbe_->bookProfile("TotalDeadCells_HB_vs_LS",
107  "Total Number of Dead HB Cells (excluding known problems) vs LS;Lumi Section;Dead Cells",
108  NLumiBlocks_,0.5,NLumiBlocks_+0.5,
109  100,0,10000);
110  ProblemsVsLB_HE=dbe_->bookProfile("TotalDeadCells_HE_vs_LS",
111  "Total Number of Dead HE Cells (excluding known problems) vs LS;Lumi Section;Dead Cells",
112  NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
113  ProblemsVsLB_HO=dbe_->bookProfile("TotalDeadCells_HO_vs_LS",
114  "Total Number of Dead HO Cells Ring 0,1 |ieta|<=10 (excluding known problems) vs LS;Lumi Section;Dead Cells",
115  NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
116  ProblemsVsLB_HO2=dbe_->bookProfile("TotalDeadCells_HO2_vs_LS",
117  "Total Number of Dead HO Cells Ring 2 |ieta|>10 (excluding known problems) vs LS;Lumi Section;Dead Cells",
118  NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
119  ProblemsVsLB_HF=dbe_->bookProfile("TotalDeadCells_HF_vs_LS",
120  "Total Number of Dead HF Cells (excluding known problems) vs LS;Lumi Section;Dead Cells",
121  NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
122  ProblemsVsLB_HBHEHF=dbe_->bookProfile("TotalDeadCells_HBHEHF_vs_LS",
123  "Total Number of Dead HBHEHF Cells (excluding known problems) vs LS;Lumi Section;Dead Cells",
124  NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
125 
126  (ProblemsVsLB->getTProfile())->SetMarkerStyle(20);
127  (ProblemsVsLB_HB->getTProfile())->SetMarkerStyle(20);
128  (ProblemsVsLB_HE->getTProfile())->SetMarkerStyle(20);
129  (ProblemsVsLB_HO->getTProfile())->SetMarkerStyle(20);
130  (ProblemsVsLB_HO2->getTProfile())->SetMarkerStyle(20);
131  (ProblemsVsLB_HF->getTProfile())->SetMarkerStyle(20);
132  (ProblemsVsLB_HBHEHF->getTProfile())->SetMarkerStyle(20);
133 
134  RBX_loss_VS_LB=dbe_->book2D("RBX_loss_VS_LB",
135  "RBX loss vs LS; Lumi Section; Index of lost RBX",
136  NLumiBlocks_,0.5,NLumiBlocks_+0.5,156,0,156);
137 
138  ProblemsInLastNLB_HBHEHF_alarm=dbe_->book1D("ProblemsInLastNLB_HBHEHF_alarm",
139  "Total Number of Dead HBHEHF Cells in last 10 LS. Last bin contains OverFlow",
140  100,0,100);
141  ProblemsInLastNLB_HO01_alarm=dbe_->book1D("ProblemsInLastNLB_HO01_alarm",
142  "Total Number of Dead Cells Ring 0,1 (abs(ieta)<=10) in last 10 LS. Last bin contains OverFlow",
143  100,0,100);
144 
145 
146  dbe_->setCurrentFolder(subdir_+"dead_cell_parameters");
147  MonitorElement* me=dbe_->bookInt("Test_NeverPresent_Digis");
148  me->Fill(1);
149  me=dbe_->bookInt("Test_DigiMissing_Periodic_Lumi_Check");
150  if (deadmon_test_digis_)
151  me->Fill(1);
152  else
153  me->Fill(0);
154  me=dbe_->bookInt("Min_Events_Required_Periodic_Lumi_Check");
155  me->Fill(minDeadEventCount_);
156  me=dbe_->bookInt("Test_NeverPresent_RecHits");
157  deadmon_test_rechits_>0 ? me->Fill(1) : me->Fill(0);
158  me=dbe_->bookFloat("HBMinimumRecHitEnergy");
159  me->Fill(HBenergyThreshold_);
160  me=dbe_->bookFloat("HEMinimumRecHitEnergy");
161  me->Fill(HEenergyThreshold_);
162  me=dbe_->bookFloat("HOMinimumRecHitEnergy");
163  me->Fill(HOenergyThreshold_);
164  me=dbe_->bookFloat("HFMinimumRecHitEnergy");
165  me->Fill(HFenergyThreshold_);
166  me=dbe_->bookInt("Test_RecHitsMissing_Periodic_Lumi_Check");
167  deadmon_test_rechits_>0 ? me->Fill(1) : me->Fill(0);
168 
169  // ProblemCells plots are in HcalDeadCellClient!
170 
171  // Set up plots for each failure mode of dead cells
172  std::stringstream units; // We'll need to set the titles individually, rather than passing units to SetupEtaPhiHists (since this also would affect the name of the histograms)
173  std::stringstream name;
174 
175  // Never-present test will always be called, by definition of dead cell
176 
177  dbe_->setCurrentFolder(subdir_+"dead_digi_never_present");
178  SetupEtaPhiHists(DigiPresentByDepth,
179  "Digi Present At Least Once","");
180  // 1D plots count number of bad cells
181  NumberOfNeverPresentDigis=dbe_->bookProfile("Problem_NeverPresentDigis_HCAL_vs_LS",
182  "Total Number of Never-Present Hcal Cells vs LS;Lumi Section;Dead Cells",
183  NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
184 
185  NumberOfNeverPresentDigisHB=dbe_->bookProfile("Problem_NeverPresentDigis_HB_vs_LS",
186  "Total Number of Never-Present HB Cells vs LS;Lumi Section;Dead Cells",
187  NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
188 
189  NumberOfNeverPresentDigisHE=dbe_->bookProfile("Problem_NeverPresentDigis_HE_vs_LS",
190  "Total Number of Never-Present HE Cells vs LS;Lumi Section;Dead Cells",
191  NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
192 
193  NumberOfNeverPresentDigisHO=dbe_->bookProfile("Problem_NeverPresentDigis_HO_vs_LS",
194  "Total Number of Never-Present HO Cells vs LS;Lumi Section;Dead Cells",
195  NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
196 
197  NumberOfNeverPresentDigisHF=dbe_->bookProfile("Problem_NeverPresentDigis_HF_vs_LS",
198  "Total Number of Never-Present HF Cells vs LS;Lumi Section;Dead Cells",
199  NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
200  (NumberOfNeverPresentDigis->getTProfile())->SetMarkerStyle(20);
201  (NumberOfNeverPresentDigisHB->getTProfile())->SetMarkerStyle(20);
202  (NumberOfNeverPresentDigisHE->getTProfile())->SetMarkerStyle(20);
203  (NumberOfNeverPresentDigisHO->getTProfile())->SetMarkerStyle(20);
204  (NumberOfNeverPresentDigisHF->getTProfile())->SetMarkerStyle(20);
205 
206  FillUnphysicalHEHFBins(DigiPresentByDepth);
207 
208  if (deadmon_test_digis_)
209  {
210  dbe_->setCurrentFolder(subdir_+"dead_digi_often_missing");
211  //units<<"("<<deadmon_checkNevents_<<" consec. events)";
212  name<<"Dead Cells with No Digis";
213  SetupEtaPhiHists(RecentMissingDigisByDepth,
214  name.str(),
215  "");
216  name.str("");
217  name<<"HB HE HF Depth 1 Dead Cells with No Digis for at least 1 Full Luminosity Block";
218  RecentMissingDigisByDepth.depth[0]->setTitle(name.str().c_str());
219 
220  name.str("");
221  name<<"HB HE HF Depth 2 Dead Cells with No Digis for at least 1 Full Luminosity Block";
222  RecentMissingDigisByDepth.depth[1]->setTitle(name.str().c_str());
223 
224  name.str("");
225  name<<"HE Depth 3 Dead Cells with No Digis for at least 1 Full Luminosity Block";
226  RecentMissingDigisByDepth.depth[2]->setTitle(name.str().c_str());
227 
228  name.str("");
229  name<<"HO Depth 4 Dead Cells with No Digis for at least 1 Full Luminosity Block";
230  RecentMissingDigisByDepth.depth[3]->setTitle(name.str().c_str());
231  name.str("");
232 
233  // 1D plots count number of bad cells
234  name<<"Total Number of Hcal Digis Unoccupied for at least 1 Full Luminosity Block";
235  NumberOfRecentMissingDigis=dbe_->bookProfile("Problem_RecentMissingDigis_HCAL_vs_LS",
236  name.str(),
237  NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
238  name.str("");
239  name<<"Total Number of HB Digis Unoccupied for at least 1 Full LS vs LS;Lumi Section; Dead Cells";
240  NumberOfRecentMissingDigisHB=dbe_->bookProfile("Problem_RecentMissingDigis_HB_vs_LS",
241  name.str(),
242  NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
243  name.str("");
244  name<<"Total Number of HE Digis Unoccupied for at least 1 Full LS vs LS;Lumi Section; Dead Cells";
245  NumberOfRecentMissingDigisHE=dbe_->bookProfile("Problem_RecentMissingDigis_HE_vs_LS",
246  name.str(),
247  NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
248  name.str("");
249  name<<"Total Number of HO Digis Unoccupied for at least 1 Full LS vs LS;Lumi Section; Dead Cells";
250  NumberOfRecentMissingDigisHO=dbe_->bookProfile("Problem_RecentMissingDigis_HO_vs_LS",
251  name.str(),
252  NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
253  name.str("");
254  name<<"Total Number of HF Digis Unoccupied for at least 1 Full LS vs LS;Lumi Section; Dead Cells";
255  NumberOfRecentMissingDigisHF=dbe_->bookProfile("Problem_RecentMissingDigis_HF_vs_LS",
256  name.str(),
257  NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
258  (NumberOfRecentMissingDigis->getTProfile())->SetMarkerStyle(20);
259  (NumberOfRecentMissingDigisHB->getTProfile())->SetMarkerStyle(20);
260  (NumberOfRecentMissingDigisHE->getTProfile())->SetMarkerStyle(20);
261  (NumberOfRecentMissingDigisHO->getTProfile())->SetMarkerStyle(20);
262  (NumberOfRecentMissingDigisHF->getTProfile())->SetMarkerStyle(20);
263 
264  }
265 
266  if (deadmon_test_rechits_)
267  {
268  // test 1: energy never above threshold
269  dbe_->setCurrentFolder(subdir_+"dead_rechit_neverpresent");
270  SetupEtaPhiHists(RecHitPresentByDepth,"RecHit Above Threshold At Least Once","");
271  // set more descriptive titles for threshold plots
272  units.str("");
273  units<<"Cells Above Energy Threshold At Least Once: Depth 1 -- HB >="<<HBenergyThreshold_<<" GeV, HE >= "<<HEenergyThreshold_<<", HF >="<<HFenergyThreshold_<<" GeV";
274  RecHitPresentByDepth.depth[0]->setTitle(units.str().c_str());
275  units.str("");
276  units<<"Cells Above Energy Threshold At Least Once: Depth 2 -- HB >="<<HBenergyThreshold_<<" GeV, HE >= "<<HEenergyThreshold_<<", HF >="<<HFenergyThreshold_<<" GeV";
277  RecHitPresentByDepth.depth[1]->setTitle(units.str().c_str());
278  units.str("");
279  units<<"Cells Above Energy Threshold At Least Once: Depth 3 -- HE >="<<HEenergyThreshold_<<" GeV";
280  RecHitPresentByDepth.depth[2]->setTitle(units.str().c_str());
281  units.str("");
282  units<<"Cells Above Energy Threshold At Least Once: Depth 4 -- HO >="<<HOenergyThreshold_<<" GeV";
283  RecHitPresentByDepth.depth[3]->setTitle(units.str().c_str());
284  units.str("");
285 
286  // 1D plots count number of bad cells
287  NumberOfNeverPresentRecHits=dbe_->bookProfile("Problem_RecHitsNeverPresent_HCAL_vs_LS",
288  "Total Number of Hcal Rechits with Low Energy;Lumi Section;Dead Cells",
289  NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
290  name.str("");
291  name<<"Total Number of HB RecHits with Energy Never >= "<<HBenergyThreshold_<<" GeV;Lumi Section;Dead Cells";
292  NumberOfNeverPresentRecHitsHB=dbe_->bookProfile("Problem_RecHitsNeverPresent_HB_vs_LS",
293  name.str(),
294  NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
295  name.str("");
296  name<<"Total Number of HE RecHits with Energy Never >= "<<HEenergyThreshold_<<" GeV;Lumi Section;Dead Cells";
297  NumberOfNeverPresentRecHitsHE=dbe_->bookProfile("Problem_RecHitsNeverPresent_HE_vs_LS",
298  name.str(),
299  NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
300  name.str("");
301  name<<"Total Number of HO RecHits with Energy Never >= "<<HOenergyThreshold_<<" GeV;Lumi Section;Dead Cells";
302  NumberOfNeverPresentRecHitsHO=dbe_->bookProfile("Problem_RecHitsNeverPresent_HO_vs_LS",
303  name.str(),
304  NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
305  name.str("");
306  name<<"Total Number of HF RecHits with Energy Never >= "<<HFenergyThreshold_<<" GeV;Lumi Section;Dead Cells";
307  NumberOfNeverPresentRecHitsHF=dbe_->bookProfile("Problem_RecHitsNeverPresent_HF_vs_LS",
308  name.str(),
309  NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
310  (NumberOfNeverPresentRecHits->getTProfile())->SetMarkerStyle(20);
311  (NumberOfNeverPresentRecHitsHB->getTProfile())->SetMarkerStyle(20);
312  (NumberOfNeverPresentRecHitsHE->getTProfile())->SetMarkerStyle(20);
313  (NumberOfNeverPresentRecHitsHO->getTProfile())->SetMarkerStyle(20);
314  (NumberOfNeverPresentRecHitsHF->getTProfile())->SetMarkerStyle(20);
315 
316  dbe_->setCurrentFolder(subdir_+"dead_rechit_often_missing");
317  SetupEtaPhiHists(RecentMissingRecHitsByDepth,"RecHits Failing Energy Threshold Test","");
318  // set more descriptive titles for threshold plots
319  units.str("");
320  units<<"RecHits with Consistent Low Energy Depth 1 -- HB <"<<HBenergyThreshold_<<" GeV, HE < "<<HEenergyThreshold_<<", HF <"<<HFenergyThreshold_<<" GeV";
321  RecentMissingRecHitsByDepth.depth[0]->setTitle(units.str().c_str());
322  units.str("");
323  units<<"RecHits with Consistent Low Energy Depth 2 -- HB <"<<HBenergyThreshold_<<" GeV, HE < "<<HEenergyThreshold_<<", HF <"<<HFenergyThreshold_<<" GeV";
324  RecentMissingRecHitsByDepth.depth[1]->setTitle(units.str().c_str());
325  units.str("");
326  units<<"RecHits with Consistent Low Energy Depth 3 -- HE <"<<HEenergyThreshold_<<" GeV";
327  RecentMissingRecHitsByDepth.depth[2]->setTitle(units.str().c_str());
328  units.str("");
329  units<<"RecHits with Consistent Low Energy Depth 4 -- HO <"<<HOenergyThreshold_<<" GeV";
330  RecentMissingRecHitsByDepth.depth[3]->setTitle(units.str().c_str());
331  units.str("");
332 
333 
334  // 1D plots count number of bad cells
335  name.str("");
336  name<<"Total Number of Hcal RecHits with Consistent Low Energy;Lumi Section;Dead Cells";
337  NumberOfRecentMissingRecHits=dbe_->bookProfile("Problem_BelowEnergyRecHits_HCAL_vs_LS",
338  name.str(),
339  NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
340  name.str("");
341  name<<"Total Number of HB RecHits with Consistent Low Energy < "<<HBenergyThreshold_<<" GeV;Lumi Section;Dead Cells";
342  NumberOfRecentMissingRecHitsHB=dbe_->bookProfile("Problem_BelowEnergyRecHits_HB_vs_LS",
343  name.str(),
344  NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
345  name.str("");
346  name<<"Total Number of HE RecHits with Consistent Low Energy < "<<HEenergyThreshold_<<" GeV;Lumi Section;Dead Cells";
347  NumberOfRecentMissingRecHitsHE=dbe_->bookProfile("Problem_BelowEnergyRecHits_HE_vs_LS",
348  name.str(),
349  NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
350  name.str("");
351  name<<"Total Number of HO RecHits with Consistent Low Energy < "<<HOenergyThreshold_<<" GeV;Lumi Section;Dead Cells";
352  NumberOfRecentMissingRecHitsHO=dbe_->bookProfile("Problem_BelowEnergyRecHits_HO_vs_LS",
353  name.str(),
354  NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
355  name.str("");
356  name<<"Total Number of HF RecHits with Consistent Low Energy < "<<HFenergyThreshold_<<" GeV;Lumi Section;Dead Cells";
357  NumberOfRecentMissingRecHitsHF=dbe_->bookProfile("Problem_BelowEnergyRecHits_HF_vs_LS",
358  name.str(),
359  NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
360  (NumberOfRecentMissingRecHits->getTProfile())->SetMarkerStyle(20);
361  (NumberOfRecentMissingRecHitsHB->getTProfile())->SetMarkerStyle(20);
362  (NumberOfRecentMissingRecHitsHE->getTProfile())->SetMarkerStyle(20);
363  (NumberOfRecentMissingRecHitsHO->getTProfile())->SetMarkerStyle(20);
364  (NumberOfRecentMissingRecHitsHF->getTProfile())->SetMarkerStyle(20);
365 
366  } // if (deadmon_test_rechits)
367 
368 
369  if (makeDiagnostics_)
370  {
371  dbe_->setCurrentFolder(subdir_+"DiagnosticPlots");
372  HBDeadVsEvent=dbe_->book1D("HBDeadVsEvent","HB Total Dead Cells Vs Event", NLumiBlocks_/10,-0.5,NLumiBlocks_-0.5);
373  HEDeadVsEvent=dbe_->book1D("HEDeadVsEvent","HE Total Dead Cells Vs Event", NLumiBlocks_/10,-0.5,NLumiBlocks_-0.5);
374  HODeadVsEvent=dbe_->book1D("HODeadVsEvent","HO Total Dead Cells Vs Event", NLumiBlocks_/10,-0.5,NLumiBlocks_-0.5);
375  HFDeadVsEvent=dbe_->book1D("HFDeadVsEvent","HF Total Dead Cells Vs Event", NLumiBlocks_/10,-0.5,NLumiBlocks_-0.5);
376  }
377 
378  return;
379 
380 } // void HcalDeadCellMonitor::setup(...)
381 
382 void HcalDeadCellMonitor::beginRun(const edm::Run& run, const edm::EventSetup& c)
383 {
384  if (debug_>1) std::cout <<"HcalDeadCellMonitor::beginRun"<<std::endl;
385  HcalBaseDQMonitor::beginRun(run,c);
386 
387  if (tevt_==0) this->setup(); // set up histograms if they have not been created before
388  if (mergeRuns_==false)
389  this->reset();
390 
391  doReset_ = true;
392 
393  // Get known dead cells for this run
394  KnownBadCells_.clear();
395  if (badChannelStatusMask_>0)
396  {
397  edm::ESHandle<HcalChannelQuality> p;
398  c.get<HcalChannelQualityRcd>().get(p);
399  HcalChannelQuality* chanquality= new HcalChannelQuality(*p.product());
400  std::vector<DetId> mydetids = chanquality->getAllChannels();
401  for (std::vector<DetId>::const_iterator i = mydetids.begin();
402  i!=mydetids.end();
403  ++i)
404  {
405  if (i->det()!=DetId::Hcal) continue; // not an hcal cell
406  HcalDetId id=HcalDetId(*i);
407  int status=(chanquality->getValues(id))->getValue();
408  if ((status & badChannelStatusMask_))
409  KnownBadCells_[id.rawId()]=status;
410  }
411  delete chanquality;
412  } // if (badChannelStatusMask_>0)
413  return;
414 } //void HcalDeadCellMonitor::beginRun(...)
415 
416 void HcalDeadCellMonitor::reset()
417 {
418  if (debug_>1) std::cout <<"HcalDeadCellMonitor::reset()"<<std::endl;
419  doReset_ = false;
420 
421  HcalBaseDQMonitor::reset();
422  zeroCounters();
423  deadevt_=0;
424  is_RBX_loss_ = 0;
425  beamMode_ = 0 ;
426  alarmer_counter_ = 0;
427  alarmer_counterHO01_ = 0;
428  is_stable_beam = true;
429  hbhedcsON = true; hfdcsON = true; hodcsON = true;
430  ProblemsVsLB->Reset(); ProblemsVsLB_HB->Reset(); ProblemsVsLB_HE->Reset(); ProblemsVsLB_HO->Reset(); ProblemsVsLB_HO2->Reset(); ProblemsVsLB_HF->Reset(); ProblemsVsLB_HBHEHF->Reset();
431  RBX_loss_VS_LB->Reset();
432  ProblemsInLastNLB_HBHEHF_alarm->Reset();
433  ProblemsInLastNLB_HO01_alarm->Reset();
434  NumberOfNeverPresentDigis->Reset(); NumberOfNeverPresentDigisHB->Reset(); NumberOfNeverPresentDigisHE->Reset(); NumberOfNeverPresentDigisHO->Reset(); NumberOfNeverPresentDigisHF->Reset();
435 
436  for (unsigned int depth=0;depth<DigiPresentByDepth.depth.size();++depth)
437  DigiPresentByDepth.depth[depth]->Reset();
438 
439  // Mark HORing2 channels as present (fill with a 2, rather than a 1, to distinguish between this setting and actual presence)
440  if (excludeHORing2_==true && DigiPresentByDepth.depth.size()>3)
441  {
442  for (int ieta=11;ieta<=15;++ieta)
443  for (int iphi=1;iphi<=72;++iphi)
444  {
445  // Don't fill ring2 SiPMs, since they will still be active even if the rest of HO is excluded.
446  if (isSiPM(ieta,iphi,4)==false)
447  DigiPresentByDepth.depth[3]->Fill(ieta,iphi,2);
448  //std::cout <<" FILLING ("<<-1*ieta<<", "<<iphi<<") with '2'"<<std::endl;
449  DigiPresentByDepth.depth[3]->Fill(-1*ieta,iphi,2);
450  }
451  }
452  FillUnphysicalHEHFBins(DigiPresentByDepth);
453 
454 
455  if (deadmon_test_digis_)
456  {
457  NumberOfRecentMissingDigis->Reset(); NumberOfRecentMissingDigisHB->Reset(); NumberOfRecentMissingDigisHE->Reset(); NumberOfRecentMissingDigisHO->Reset(); NumberOfRecentMissingDigisHF->Reset();
458  RecentMissingDigisByDepth.Reset();
459  }
460  if (deadmon_test_rechits_)
461  {
462  NumberOfRecentMissingRecHits->Reset();
463  NumberOfRecentMissingRecHitsHB->Reset();
464  NumberOfRecentMissingRecHitsHE->Reset();
465  NumberOfRecentMissingRecHitsHO->Reset();
466  NumberOfRecentMissingRecHitsHF->Reset();
467  NumberOfNeverPresentRecHits->Reset();
468  NumberOfNeverPresentRecHitsHB->Reset();
469  NumberOfNeverPresentRecHitsHE->Reset();
470  NumberOfNeverPresentRecHitsHO->Reset();
471  NumberOfNeverPresentRecHitsHF->Reset();
472  RecentMissingRecHitsByDepth.Reset();
473  RecHitPresentByDepth.Reset();
474 
475  // Mark HORing2 channels as present (fill with a 2, rather than a 1, to distinguish between this setting and actual presence)
476  if (excludeHORing2_==true && RecHitPresentByDepth.depth.size()>3)
477  {
478  for (int ieta=11;ieta<=15;++ieta)
479  for (int iphi=1;iphi<=72;++iphi)
480  {
481  RecHitPresentByDepth.depth[3]->Fill(ieta,iphi,2);
482  RecHitPresentByDepth.depth[3]->Fill(-1*ieta,iphi,2);
483  }
484  }
485  FillUnphysicalHEHFBins(RecHitPresentByDepth);
486  }
487 
488  Nevents->Reset();
489 } // reset function is empty for now
490 
491 /* ------------------------------------------------------------------------- */
492 
493 
494 void HcalDeadCellMonitor::cleanup()
495 {
496  if (!enableCleanup_) return;
497  if (dbe_)
498  {
499  dbe_->setCurrentFolder(subdir_);
500  dbe_->removeContents();
501  dbe_->setCurrentFolder(subdir_+"dead_digi_never_present");
502  dbe_->removeContents();
503  dbe_->setCurrentFolder(subdir_+"dead_digi_often_missing");
504  dbe_->removeContents();
505  dbe_->setCurrentFolder(subdir_+"dead_rechit_neverpresent");
506  dbe_->removeContents();
507  dbe_->setCurrentFolder(subdir_+"dead_rechit_often_missing");
508  dbe_->removeContents();
509  dbe_->setCurrentFolder(subdir_+"dead_cell_parameters");
510  dbe_->removeContents();
511  dbe_->setCurrentFolder(subdir_+"LSvalues");
512  dbe_->removeContents();
513  }
514  return;
515 } // void HcalDeadCellMonitor::cleanup()
516 
517 /* ------------------------------------------------------------------------- */
518 
519 void HcalDeadCellMonitor::endLuminosityBlock(const edm::LuminosityBlock& lumiSeg,
520  const edm::EventSetup& c)
521 {
522  // skip old lumi sections
523  if (this->LumiInOrder(lumiSeg.luminosityBlock())==false) return;
524 
525  // Reset current LS histogram
526  if (ProblemsCurrentLB)
527  ProblemsCurrentLB->Reset();
528 
529  ProblemsInLastNLB_HBHEHF_alarm->Reset();
530  ProblemsInLastNLB_HO01_alarm->Reset();
531 
532  //increase the number of LS counting, for alarmer. Only make alarms for HBHE
533  if(hbhedcsON == true && hfdcsON == true && HBpresent_ == 1 && HEpresent_ == 1 && HFpresent_ == 1)
534  ++alarmer_counter_;
535  else
536  alarmer_counter_ = 0;
537 
538  if(hodcsON==true && HOpresent_ == 1)
539  ++alarmer_counterHO01_;
540  else
541  alarmer_counterHO01_ = 0;
542 
543  if (!is_stable_beam)
544  {
545  alarmer_counter_ = 0;
546  alarmer_counterHO01_ = 0;
547  }
548 
549  // Here is where we determine whether or not to process an event
550  // Not enough events
551  // there are less than minDeadEventCount_ in this LS, but RBXloss is found
552 
553  if (deadevt_>=10 && deadevt_<minDeadEventCount_ && is_RBX_loss_==1)
554  {
555  fillNevents_problemCells();
556  fillNevents_recentrechits();
557  fillNevents_recentdigis();
558 
559  endLumiProcessed_=true;
560  is_RBX_loss_=0;
561 
562  for (unsigned int i=0;i<156;++i)
563  rbxlost[i] = 0;
564 
565  if (ProblemsCurrentLB)
566  {
567  ProblemsCurrentLB->setBinContent(0,0, levt_); // underflow bin contains number of events
568  ProblemsCurrentLB->setBinContent(1,1, NumBadHB*levt_);
569  ProblemsCurrentLB->setBinContent(2,1, NumBadHE*levt_);
570  ProblemsCurrentLB->setBinContent(3,1, NumBadHO*levt_);
571  ProblemsCurrentLB->setBinContent(4,1, NumBadHF*levt_);
572  ProblemsCurrentLB->setBinContent(5,1, NumBadHO0*levt_);
573  ProblemsCurrentLB->setBinContent(6,1, NumBadHO12*levt_);
574  ProblemsCurrentLB->setBinContent(7,1, NumBadHFLUMI*levt_);
575  }
576  }
577 
578  if (deadevt_<minDeadEventCount_) // perform normal tasks, since no RBX loss is detected in this lumisections
579  return;
580 
581  endLumiProcessed_=true;
582  // fillNevents_problemCells checks for never-present cells
583  fillNevents_problemCells();
584  fillNevents_recentdigis();
585  fillNevents_recentrechits();
586 
587  if (ProblemsCurrentLB)
588  {
589  ProblemsCurrentLB->setBinContent(0,0, levt_); // underflow bin contains number of events
590  ProblemsCurrentLB->setBinContent(1,1, NumBadHB*levt_);
591  ProblemsCurrentLB->setBinContent(2,1, NumBadHE*levt_);
592  ProblemsCurrentLB->setBinContent(3,1, NumBadHO*levt_);
593  ProblemsCurrentLB->setBinContent(4,1, NumBadHF*levt_);
594  ProblemsCurrentLB->setBinContent(5,1, NumBadHO0*levt_);
595  ProblemsCurrentLB->setBinContent(6,1, NumBadHO12*levt_);
596  ProblemsCurrentLB->setBinContent(7,1, NumBadHFLUMI*levt_);
597  }
598  zeroCounters();
599  deadevt_=0;
600  is_RBX_loss_=0;
601  beamMode_ = 0;
602  return;
603 } //endLuminosityBlock()
604 
605 void HcalDeadCellMonitor::endRun(const edm::Run& run, const edm::EventSetup& c)
606 {
607  // Always carry out overall occupancy test at endRun, regardless minimum number of events?
608  // Or should we require an absolute lower bound?
609  // We can always run this test; we'll use the summary client to implement a lower bound before calculating reportSummary values
610  if (endLumiProcessed_==false) fillNevents_problemCells(); // always check for never-present cells
611 
612  return;
613 }
614 
615 void HcalDeadCellMonitor::endJob()
616 {
617  if (debug_>0) std::cout <<"HcalDeadCellMonitor::endJob()"<<std::endl;
618  if (enableCleanup_) cleanup(); // when do we force cleanup?
619 }
620 
621 void HcalDeadCellMonitor::analyze(edm::Event const&e, edm::EventSetup const&s)
622 {
623  if (!IsAllowedCalibType()) return;
624  endLumiProcessed_=false;
625 
626  if(doReset_)
627  this->reset();
628 
629  Nevents->Fill(0,1); // count all events of allowed calibration type, even if their lumi block is not in the right order
630  if (LumiInOrder(e.luminosityBlock())==false) return;
631  // try to get rechits and digis
632  edm::Handle<HBHEDigiCollection> hbhe_digi;
633  edm::Handle<HODigiCollection> ho_digi;
634  edm::Handle<HFDigiCollection> hf_digi;
635 
636  edm::Handle<HBHERecHitCollection> hbhe_rechit;
637  edm::Handle<HORecHitCollection> ho_rechit;
638  edm::Handle<HFRecHitCollection> hf_rechit;
639 
640  edm::Handle<L1GlobalTriggerEvmReadoutRecord> gtEvm_handle;
641 
643  // check if detectors whether they were ON
644  edm::Handle<DcsStatusCollection> dcsStatus;
645  e.getByLabel("scalersRawToDigi", dcsStatus);
646 
647  if (dcsStatus.isValid() && dcsStatus->size() != 0)
648  {
649  if ((*dcsStatus)[0].ready(DcsStatus::HBHEa) &&
650  (*dcsStatus)[0].ready(DcsStatus::HBHEb) &&
651  (*dcsStatus)[0].ready(DcsStatus::HBHEc))
652  {
653  hbhedcsON = true;
654  if (debug_) std::cout << "hbhe on" << std::endl;
655  }
656  else hbhedcsON = false;
657 
658  if ((*dcsStatus)[0].ready(DcsStatus::HF))
659  {
660  hfdcsON = true;
661  if (debug_) std::cout << "hf on" << std::endl;
662  }
663  else hfdcsON = false;
664 
665  if ((*dcsStatus)[0].ready(DcsStatus::HO))
666  {
667  hodcsON = true;
668  if (debug_) std::cout << "ho on" << std::endl;
669  }
670  else hodcsON = false;
671  }
673 
674  if (!(e.getByLabel(digiLabel_,hbhe_digi)))
675  {
676  edm::LogWarning("HcalDeadCellMonitor")<< digiLabel_<<" hbhe_digi not available";
677  return;
678  }
679  if (!(e.getByLabel(digiLabel_,ho_digi)))
680  {
681  edm::LogWarning("HcalDeadCellMonitor")<< digiLabel_<<" ho_digi not available";
682  return;
683  }
684  if (!(e.getByLabel(digiLabel_,hf_digi)))
685  {
686  edm::LogWarning("HcalDeadCellMonitor")<< digiLabel_<<" hf_digi not available";
687  return;
688  }
689 
690  if (!(e.getByLabel(hbheRechitLabel_,hbhe_rechit)))
691  {
692  edm::LogWarning("HcalDeadCellMonitor")<< hbheRechitLabel_<<" hbhe_rechit not available";
693  return;
694  }
695 
696  if (!(e.getByLabel(hfRechitLabel_,hf_rechit)))
697  {
698  edm::LogWarning("HcalDeadCellMonitor")<< hfRechitLabel_<<" hf_rechit not available";
699  return;
700  }
701  if (!(e.getByLabel(hoRechitLabel_,ho_rechit)))
702  {
703  edm::LogWarning("HcalDeadCellMonitor")<< hoRechitLabel_<<" ho_rechit not available";
704  return;
705  }
706  if (!(e.getByLabel("gtEvmDigis", gtEvm_handle)))
707  {
708  edm::LogWarning("HcalDeadCellMonitor")<< "gtEvmDigis"<<" gtEvmDigis not available";
709  return;
710  }
711  L1GtfeExtWord gtfeEvmExtWord = gtEvm_handle.product()->gtfeWord();
712 
713  if (debug_>1) std::cout <<"\t<HcalDeadCellMonitor::analyze> Processing good event! event # = "<<ievt_<<std::endl;
714  // Good event found; increment counter (via base class analyze method)
715  // This also runs the allowed calibration /lumi in order tests again; remove?
716  HcalBaseDQMonitor::analyze(e,s);
717 
718  ++deadevt_; //increment local counter
719 
720  processEvent(*hbhe_rechit, *ho_rechit, *hf_rechit, *hbhe_digi, *ho_digi, *hf_digi);
721 
722  // check for presence of an RBX data loss
723  if(levt_>10 && tevt_ % 10 == 0 ) //levt_ counts events perLS, but excludes
724  { //"wrong", calibration-type events. Compare with tevt_ instead...
725  for(int i=71; i<132; i++)
726  {
727  // These RBXs in HO are excluded, set to 1 to ignore
728  // HO0: 96-107 (all)
729  // HO1: 85-95, 109-119 (all odd)
730  // HO2: 73, 75, 79, 81, 83, 121-131 (all odd)
731  if(i >= 72 && i < 95 && i%2==0)
732  occupancy_RBX[i] = 1;
733  if(i >=108 && i <= 131 && i%2==0)
734  occupancy_RBX[i] = 1;
735 
736  if(i==117 || i==131) // HO SiPMs have much less hits, 10 events not enough.
737  occupancy_RBX[i] = 1; // Also no RBX loss for SiPMs, so ignore for now.
738  if(i==77)
739  occupancy_RBX[i] = 1;
740  }
741 
742  // RBX loss detected
743  for (unsigned int i=0;i<132;++i)
744  if(occupancy_RBX[i] == 0)
745  {
746  is_RBX_loss_ = 1;
747  rbxlost[i] = 1;
748  }
749 
750  int intensity1_ = gtfeEvmExtWord.totalIntensityBeam1();
751  int intensity2_ = gtfeEvmExtWord.totalIntensityBeam2();
752 
753  is_stable_beam = gtfeEvmExtWord.beamMode() == 11 ? true : false;
754 
755  for (unsigned int i=132;i<156;++i)
756  if(occupancy_RBX[i] == 0 && gtfeEvmExtWord.beamMode() == 11)
757  if(intensity1_>100 && intensity2_>100) // only in stable beam mode (11) and with circulating beams, otherwise
758  { // this check is too sensitive in HF
759  is_RBX_loss_ = 1;
760  rbxlost[i] = 1;
761  }
762 
763  // no RBX loss, reset the counters
764  if (is_RBX_loss_ == 0)
765  for (unsigned int i=0;i<156;++i)
766  occupancy_RBX[i] = 0;
767  }
768 
769  // if RBX is lost any time during the LS, don't allow the counters to increment
770  if(is_RBX_loss_ == 1)
771  for (unsigned int i=0;i<156;++i)
772  if(rbxlost[i]==1) occupancy_RBX[i] = 0;
773 
774 } // void HcalDeadCellMonitor::analyze(...)
775 
776 /* --------------------------------------- */
777 
778 
779 void HcalDeadCellMonitor::processEvent(const HBHERecHitCollection& hbHits,
780  const HORecHitCollection& hoHits,
781  const HFRecHitCollection& hfHits,
782  const HBHEDigiCollection& hbhedigi,
783  const HODigiCollection& hodigi,
784  const HFDigiCollection& hfdigi)
785 {
786  if (debug_>1) std::cout <<"<HcalDeadCellMonitor::processEvent> Processing event..."<<std::endl;
787 
788  // Do Digi-Based dead cell searches
789 
790  // Make sure histograms update
791  for (unsigned int i=0;i<DigiPresentByDepth.depth.size();++i)
792  DigiPresentByDepth.depth[i]->update();
793 
794  NumberOfNeverPresentDigis->update();;
795  NumberOfNeverPresentDigisHB->update();
796  NumberOfNeverPresentDigisHE->update();
797  NumberOfNeverPresentDigisHO->update();
798  NumberOfNeverPresentDigisHF->update();
799 
800  if (deadmon_test_digis_)
801  {
802 
803  for (unsigned int i=0;i<RecentMissingDigisByDepth.depth.size();++i)
804  RecentMissingDigisByDepth.depth[i]->update();
805 
806  NumberOfRecentMissingDigis->update();
807  NumberOfRecentMissingDigisHB->update();
808  NumberOfRecentMissingDigisHE->update();
809  NumberOfRecentMissingDigisHO->update();
810  NumberOfRecentMissingDigisHF->update();
811  }
812 
813  for (HBHEDigiCollection::const_iterator j=hbhedigi.begin();
814  j!=hbhedigi.end(); ++j)
815  {
816  const HBHEDataFrame digi = (const HBHEDataFrame)(*j);
817  processEvent_HBHEdigi(digi);
818  }
819 
820  for (HODigiCollection::const_iterator j=hodigi.begin();
821  j!=hodigi.end(); ++j)
822  {
823  const HODataFrame digi = (const HODataFrame)(*j);
824  process_Digi(digi);
825  }
826  for (HFDigiCollection::const_iterator j=hfdigi.begin();
827  j!=hfdigi.end(); ++j)
828  {
829  const HFDataFrame digi = (const HFDataFrame)(*j);
830  process_Digi(digi);
831  }
832  FillUnphysicalHEHFBins(DigiPresentByDepth);
833 
834  // Search for "dead" cells below a certain energy
835  if (deadmon_test_rechits_)
836  {
837  // Normalization Fill
838  for (unsigned int i=0;i<RecentMissingRecHitsByDepth.depth.size();++i)
839  RecentMissingRecHitsByDepth.depth[i]->update();
840 
841  NumberOfRecentMissingRecHits->update();
842  NumberOfRecentMissingRecHitsHB->update();
843  NumberOfRecentMissingRecHitsHE->update();
844  NumberOfRecentMissingRecHitsHO->update();
845  NumberOfRecentMissingRecHitsHF->update();
846 
847  for (HBHERecHitCollection::const_iterator j=hbHits.begin();
848  j!=hbHits.end(); ++j)
849  process_RecHit(j);
850 
851  for (HORecHitCollection::const_iterator k=hoHits.begin();
852  k!=hoHits.end(); ++k)
853  process_RecHit(k);
854 
855  for (HFRecHitCollection::const_iterator j=hfHits.begin();
856  j!=hfHits.end(); ++j)
857  process_RecHit(j);
858 
859  } // if (deadmon_test_rechits)
860 
861  if (!makeDiagnostics_) return;
862  if (tevt_>=NLumiBlocks_) return;
863  // Diagnostic plots -- add number of missing channels vs event number
864  int hbpresent=0;
865  int hepresent=0;
866  int hopresent=0;
867  int hfpresent=0;
868  int ieta=0;
869  for (int d=0;d<4;++d)
870  {
871  for (int phi=0;phi<72;++phi)
872  {
873  for (int eta=0;eta<85;++eta)
874  {
875  if (!present_digi[eta][phi][d]) continue;
876  if (d==3) ++hopresent;
877  else if (d==2) ++hepresent;
878  else if (d==1)
879  {
880  ieta=binmapd2[eta];
881  //if (abs(ieta)>29) continue;
882  if (abs(ieta)>29) ++hfpresent;
883  else if (abs(ieta)<17) ++hbpresent; //depths 15&16
884  else ++hepresent;
885  }
886  else if (d==0)
887  {
888  ieta=eta-42;
889  if (abs(ieta)>29) ++hfpresent;
890  else if (abs(ieta)<17) ++hbpresent;
891  else ++hepresent;
892  }
893  }
894  }
895  } // for (int d=0;d<4;++d)
896  HBDeadVsEvent->Fill(tevt_,2592-hbpresent);
897  HEDeadVsEvent->Fill(tevt_,2592-hepresent);
898  HODeadVsEvent->Fill(tevt_,2160-hopresent);
899  HFDeadVsEvent->Fill(tevt_,1728-hfpresent);
900  return;
901 } // void HcalDeadCellMonitor::processEvent(...)
902 
903 /************************************/
904 
905 
906 // Digi-based dead cell checks
907 
908 void HcalDeadCellMonitor::processEvent_HBHEdigi(const HBHEDataFrame digi)
909 {
910  // Simply check whether a digi is present. If so, increment occupancy counter.
911  process_Digi(digi);
912  return;
913 } //void HcalDeadCellMonitor::processEvent_HBHEdigi(HBHEDigiCollection::const_iterator j)
914 
915 template<class DIGI>
916 void HcalDeadCellMonitor::process_Digi(DIGI& digi)
917 {
918  // Remove the validate check when we figure out how to access bad digis in digi monitor
919  //if (!digi.validate()) return; // digi must be good to be counted
920  int ieta=digi.id().ieta();
921  int iphi=digi.id().iphi();
922  int depth=digi.id().depth();
923 
924  // Fill occupancy counter
925  ++recentoccupancy_digi[CalcEtaBin(digi.id().subdet(),ieta,depth)][iphi-1][depth-1];
926 
927  // If previously-missing digi found, change boolean status and fill histogram
928  if (present_digi[CalcEtaBin(digi.id().subdet(),ieta,depth)][iphi-1][depth-1]==false)
929  {
930  if (DigiPresentByDepth.depth[depth-1])
931  {
932  DigiPresentByDepth.depth[depth-1]->setBinContent(CalcEtaBin(digi.id().subdet(),ieta,depth)+1,iphi,1);
933  }
934  present_digi[CalcEtaBin(digi.id().subdet(),ieta,depth)][iphi-1][depth-1]=true;
935  }
936  return;
937 }
938 
939 //RecHit-based dead cell checks
940 
941 template<class RECHIT>
942 void HcalDeadCellMonitor::process_RecHit(RECHIT& rechit)
943 {
944  float en = rechit->energy();
945  HcalDetId id(rechit->detid().rawId());
946  int ieta = id.ieta();
947  int iphi = id.iphi();
948  int depth = id.depth();
949 
950  if (id.subdet()==HcalBarrel)
951  {
952  if (en>=HBenergyThreshold_)
953  {
954  ++recentoccupancy_rechit[CalcEtaBin(id.subdet(),ieta,depth)][iphi-1][depth-1];
955  present_rechit[CalcEtaBin(id.subdet(),ieta,depth)][iphi-1][depth-1]=true;
956  if (RecHitPresentByDepth.depth[depth-1])
957  RecHitPresentByDepth.depth[depth-1]->setBinContent(CalcEtaBin(id.subdet(),ieta,depth)+1,iphi,1);
958  }
960  // RBX index, HB RBX indices are 0-35
961  int RBXindex = logicalMap_->getHcalFrontEndId(rechit->detid()).rbxIndex();
962 
963  occupancy_RBX[RBXindex]++;
965  }
966  else if (id.subdet()==HcalEndcap)
967  {
968  if (en>=HEenergyThreshold_)
969  {
970  ++recentoccupancy_rechit[CalcEtaBin(id.subdet(),ieta,depth)][iphi-1][depth-1];
971  present_rechit[CalcEtaBin(id.subdet(),ieta,depth)][iphi-1][depth-1]=true;
972  if (RecHitPresentByDepth.depth[depth-1])
973  RecHitPresentByDepth.depth[depth-1]->setBinContent(CalcEtaBin(id.subdet(),ieta,depth)+1,iphi,1);
974  }
976  // RBX index, HE RBX indices are 36-71
977  int RBXindex = logicalMap_->getHcalFrontEndId(rechit->detid()).rbxIndex();
978 
979  occupancy_RBX[RBXindex]++;
981  }
982  else if (id.subdet()==HcalForward)
983  {
984  if (en>=HFenergyThreshold_)
985  {
986  ++recentoccupancy_rechit[CalcEtaBin(id.subdet(),ieta,depth)][iphi-1][depth-1];
987 
988  present_rechit[CalcEtaBin(id.subdet(),ieta,depth)][iphi-1][depth-1]=true;
989  if (RecHitPresentByDepth.depth[depth-1])
990  RecHitPresentByDepth.depth[depth-1]->setBinContent(CalcEtaBin(id.subdet(),ieta,depth)+1,iphi,1);
991  }
993  // RBX index, HF RBX indices are 132-155
994  int RBXindex = logicalMap_->getHcalFrontEndId(rechit->detid()).rbxIndex();
995 
996  occupancy_RBX[RBXindex]++;
998  }
999  else if (id.subdet()==HcalOuter)
1000  {
1001  if (en>=HOenergyThreshold_)
1002  {
1003  ++recentoccupancy_rechit[CalcEtaBin(id.subdet(),ieta,depth)][iphi-1][depth-1];
1004  present_rechit[CalcEtaBin(id.subdet(),ieta,depth)][iphi-1][depth-1]=true;
1005  if (RecHitPresentByDepth.depth[depth-1])
1006  RecHitPresentByDepth.depth[depth-1]->setBinContent(CalcEtaBin(id.subdet(),ieta,depth)+1,iphi,1);
1007  }
1009  // RBX index, HO RBX indices are 73-95 (odd), 96-107 (all), 108-119 (odd), 120-130 (EXCL), 131
1010  int RBXindex = logicalMap_->getHcalFrontEndId(rechit->detid()).rbxIndex();
1011 
1012  occupancy_RBX[RBXindex]++;
1014  }
1015 }
1016 
1017 void HcalDeadCellMonitor::fillNevents_recentdigis()
1018 {
1019  // Fill Histograms showing digi cells with no occupancy for the past few lumiblocks
1020  if (!deadmon_test_digis_) return; // extra protection here against calling histograms than don't exist
1021 
1022  if (debug_>0)
1023  std::cout <<"<HcalDeadCellMonitor::fillNevents_recentdigis> CHECKING FOR RECENT MISSING DIGIS evtcount = "<<deadevt_<<std::endl;
1024 
1025  int ieta=0;
1026  int iphi=0;
1027 
1028  int etabins=0;
1029  int phibins=0;
1030 
1032  if ((deadevt_ >= 10 && deadevt_<minDeadEventCount_) || (deadevt_ >= 10 && is_RBX_loss_==1)) // maybe not enough events to run the standard test
1033  // if( is_RBX_loss_ == 1 ) // but enough to detect RBX loss
1034  for (unsigned int depth=0;depth<RecentMissingDigisByDepth.depth.size();++depth)
1035  {
1036  RecentMissingDigisByDepth.depth[depth]->setBinContent(0,0,ievt_);
1037  etabins=RecentMissingDigisByDepth.depth[depth]->getNbinsX();
1038  phibins=RecentMissingDigisByDepth.depth[depth]->getNbinsY();
1039  for (int eta=0;eta<etabins;++eta)
1040  for (int phi=0;phi<phibins;++phi)
1041  {
1042  iphi=phi+1;
1043  for (int subdet=1;subdet<=4;++subdet)
1044  {
1045  ieta=CalcIeta((HcalSubdetector)subdet,eta,depth+1);
1046  if (ieta==-9999) continue;
1047  if (!validDetId((HcalSubdetector)subdet, ieta, iphi, depth+1))
1048  continue;
1049  // now check which dead cell tests failed; increment counter if any failed
1050  HcalDetId TempID((HcalSubdetector)subdet, ieta, iphi, (int)depth+1);
1051 
1052  int index = logicalMap_->getHcalFrontEndId(TempID).rbxIndex();
1053  // if(subdet==HcalForward) continue;
1054 
1055  if(occupancy_RBX[index]==0)
1056  {
1057  recentoccupancy_digi[eta][phi][depth] = 0;
1058  RecentMissingDigisByDepth.depth[depth]->Fill(ieta,iphi,deadevt_);
1059  }
1060  }
1061  }
1062  }
1064 
1065  if (deadevt_ < minDeadEventCount_) return; // not enough entries to make a determination for this LS
1066 
1067  for (unsigned int depth=0;depth<RecentMissingDigisByDepth.depth.size();++depth)
1068  {
1069  RecentMissingDigisByDepth.depth[depth]->setBinContent(0,0,ievt_);
1070  etabins=RecentMissingDigisByDepth.depth[depth]->getNbinsX();
1071  phibins=RecentMissingDigisByDepth.depth[depth]->getNbinsY();
1072  for (int eta=0;eta<etabins;++eta)
1073  {
1074  for (int subdet=1;subdet<=4;++subdet)
1075  {
1076  ieta=CalcIeta((HcalSubdetector)subdet,eta,depth+1);
1077  if (ieta==-9999) continue;
1078  for (int phi=0;phi<phibins;++phi)
1079  {
1080  iphi=phi+1;
1081 
1082  if (!validDetId((HcalSubdetector)subdet, ieta, iphi, depth+1))
1083  continue;
1084 
1085  // Ignore subdetectors that weren't in run?
1086  /*
1087  if ((subdet==HcalBarrel && !HBpresent_) ||
1088  (subdet==HcalEndcap &&!HEpresent_) ||
1089  (subdet==HcalOuter &&!HOpresent_) ||
1090  (subdet==HcalForward &&!HFpresent_)) continue;
1091  */
1092  int zside=0;
1093  if (subdet==HcalForward) // shift HcalForward ieta
1094  ieta<0 ? zside=-1 : zside=+1;
1095 
1096  if (recentoccupancy_digi[eta][phi][depth]==0)
1097  {
1098  if (debug_>0)
1099  {
1100  std::cout <<"DEAD CELL; NO RECENT OCCUPANCY: subdet = "<<subdet<<", ieta = "<<ieta<<", iphi = "<<iphi<<" depth = "<<depth+1<<std::endl;
1101  std::cout <<"\t RAW COORDINATES: eta = "<<eta<< " phi = "<<phi<<" depth = "<<depth<<std::endl;
1102  std::cout <<"\t Present? "<<present_digi[eta][phi][depth]<<std::endl;
1103  }
1104 
1105  // Don't fill HORing2 if boolean enabled
1106  if (excludeHORing2_==true && abs(ieta)>10 && isSiPM(ieta,iphi,depth+1)==false)
1107  continue;
1108 
1109  // no digi was found for the N events; Fill cell as bad for all N events (N = checkN);
1110  if (RecentMissingDigisByDepth.depth[depth]) RecentMissingDigisByDepth.depth[depth]->Fill(ieta+zside,iphi,deadevt_);
1111  }
1112  } // for (int subdet=1;subdet<=4;++subdet)
1113  } // for (int phi=0;...)
1114  } // for (int eta=0;...)
1115  } //for (int depth=1;...)
1116  FillUnphysicalHEHFBins(RecentMissingDigisByDepth);
1117 
1118  return;
1119 
1120 } // void HcalDeadCellMonitor::fillNevents_recentdigis()
1121 
1122 
1123 
1124 /* ----------------------------------- */
1125 
1126 void HcalDeadCellMonitor::fillNevents_recentrechits()
1127 {
1128  // Fill Histograms showing unoccupied rechits, or rec hits with low energy
1129 
1130  // This test is a bit pointless, unless the energy threshold is greater than the ZS threshold.
1131  // If we require that cells are always < thresh to be flagged by this test, and if
1132  // thresh < ZS, then we will never catch any cells, since they'll show up as dead in the
1133  // neverpresent/occupancy test plots first.
1134  // Only exception is if something strange is going on between ZS ADC value an RecHit energy?
1135 
1136  if (!deadmon_test_rechits_) return;
1137  FillUnphysicalHEHFBins(RecHitPresentByDepth);
1138 
1139  if (debug_>0)
1140  std::cout <<"<HcalDeadCellMonitor::fillNevents_energy> BELOW-ENERGY-THRESHOLD PLOTS"<<std::endl;
1141 
1142  int ieta=0;
1143  int iphi=0;
1144 
1145  int etabins=0;
1146  int phibins=0;
1147 
1149  if ((deadevt_ >= 10 && deadevt_<minDeadEventCount_) || (deadevt_ >= 10 && is_RBX_loss_==1)) // maybe not enough events to run the standard test
1150  // if( is_RBX_loss_ == 1 ) // but enough to detect RBX loss
1151  for (unsigned int depth=0;depth<RecentMissingRecHitsByDepth.depth.size();++depth)
1152  {
1153  RecentMissingRecHitsByDepth.depth[depth]->setBinContent(0,0,ievt_);
1154  etabins=RecentMissingRecHitsByDepth.depth[depth]->getNbinsX();
1155  phibins=RecentMissingRecHitsByDepth.depth[depth]->getNbinsY();
1156  for (int eta=0;eta<etabins;++eta)
1157  for (int phi=0;phi<phibins;++phi)
1158  {
1159  iphi=phi+1;
1160  for (int subdet=1;subdet<=4;++subdet)
1161  {
1162  ieta=CalcIeta((HcalSubdetector)subdet,eta,depth+1);
1163  if (ieta==-9999) continue;
1164  if (!validDetId((HcalSubdetector)subdet, ieta, iphi, depth+1))
1165  continue;
1166  // now check which dead cell tests failed; increment counter if any failed
1167  HcalDetId TempID((HcalSubdetector)subdet, ieta, iphi, (int)depth+1);
1168 
1169  int index = logicalMap_->getHcalFrontEndId(TempID).rbxIndex();
1170  // if(subdet==HcalForward) continue;
1171 
1172  if(occupancy_RBX[index]==0)
1173  {
1174  recentoccupancy_rechit[eta][phi][depth] = 0;
1175  RecentMissingRecHitsByDepth.depth[depth]->Fill(ieta,iphi,deadevt_);
1176  }
1177  }
1178  }
1179  }
1181 
1182  if (deadevt_ < minDeadEventCount_) return; // not enough entries to make a determination for this LS
1183 
1184  for (unsigned int depth=0;depth<RecentMissingRecHitsByDepth.depth.size();++depth)
1185  {
1186  RecentMissingRecHitsByDepth.depth[depth]->setBinContent(0,0,ievt_);
1187  etabins=RecentMissingRecHitsByDepth.depth[depth]->getNbinsX();
1188  phibins=RecentMissingRecHitsByDepth.depth[depth]->getNbinsY();
1189  for (int eta=0;eta<etabins;++eta)
1190  {
1191  for (int subdet=1;subdet<=4;++subdet)
1192  {
1193  ieta=CalcIeta((HcalSubdetector)subdet,eta,depth+1);
1194  if (ieta==-9999) continue;
1195  for (int phi=0;phi<phibins;++phi)
1196  {
1197  iphi=phi+1;
1198  if (!validDetId((HcalSubdetector)subdet, ieta, iphi, depth+1))
1199  continue;
1200 
1201  if (recentoccupancy_rechit[eta][phi][depth]>0) continue; // cell exceeded energy at least once, so it's not dead
1202 
1203  // Ignore subdetectors that weren't in run?
1204  /*
1205  if ((subdet==HcalBarrel && !HBpresent_) ||
1206  (subdet==HcalEndcap &&!HEpresent_) ||
1207  (subdet==HcalOuter &&!HOpresent_) ||
1208  (subdet==HcalForward &&!HFpresent_)) continue;
1209  */
1210 
1211  int zside=0;
1212  if (subdet==HcalForward) // shift HcalForward ieta
1213  {
1214  ieta<0 ? zside=-1 : zside=+1;
1215  }
1216 
1217  if (debug_>2)
1218  std::cout <<"DEAD CELL; BELOW ENERGY THRESHOLD; subdet = "<<subdet<<" ieta = "<<ieta<<", phi = "<<iphi<<" depth = "<<depth+1<<std::endl;
1219  if (excludeHORing2_==true && abs(ieta)>10 && isSiPM(ieta,iphi,depth+1)==false)
1220  continue;
1221 
1222  if (RecentMissingRecHitsByDepth.depth[depth]) RecentMissingRecHitsByDepth.depth[depth]->Fill(ieta+zside,iphi,deadevt_);
1223  } // loop on phi bins
1224  } // for (unsigned int depth=1;depth<=4;++depth)
1225  } // // loop on subdetectors
1226  } // for (int eta=0;...)
1227 
1228  FillUnphysicalHEHFBins(RecentMissingRecHitsByDepth);
1229 
1230  return;
1231 } // void HcalDeadCellMonitor::fillNevents_recentrechits()
1232 
1233 
1234 void HcalDeadCellMonitor::fillNevents_problemCells()
1235 {
1236  //fillNevents_problemCells now only performs checks of never-present cells
1237 
1238  if (debug_>0)
1239  std::cout <<"<HcalDeadCellMonitor::fillNevents_problemCells> FILLING PROBLEM CELL PLOTS"<<std::endl;
1240 
1241  int ieta=0;
1242  int iphi=0;
1243 
1244  // Count problem cells in each subdetector
1245 
1246  NumBadHB=0;
1247  NumBadHE=0;
1248  NumBadHO=0;
1249  NumBadHF=0;
1250  NumBadHFLUMI=0;
1251  NumBadHO01=0;
1252  NumBadHO2=0;
1253  NumBadHO12=0;
1254  NumBadHO1P02=0;
1255 
1256  int knownBadHB=0;
1257  int knownBadHE=0;
1258  int knownBadHF=0;
1259  int knownBadHO=0;
1260  int knownBadHFLUMI=0;
1261  int knownBadHO01=0;
1262  int knownBadHO2=0;
1263  int knownBadHO12=0;
1264 
1265 
1266  unsigned int neverpresentHB=0;
1267  unsigned int neverpresentHE=0;
1268  unsigned int neverpresentHO=0;
1269  unsigned int neverpresentHF=0;
1270 
1271  unsigned int unoccupiedHB=0;
1272  unsigned int unoccupiedHE=0;
1273  unsigned int unoccupiedHO=0;
1274  unsigned int unoccupiedHF=0;
1275 
1276  unsigned int belowenergyHB=0;
1277  unsigned int belowenergyHE=0;
1278  unsigned int belowenergyHO=0;
1279  unsigned int belowenergyHF=0;
1280 
1281  unsigned int energyneverpresentHB=0;
1282  unsigned int energyneverpresentHE=0;
1283  unsigned int energyneverpresentHO=0;
1284  unsigned int energyneverpresentHF=0;
1285 
1286  if (deadevt_>=minDeadEventCount_)
1287  Nevents->Fill(1,deadevt_);
1288 
1289  int etabins=0;
1290  int phibins=0;
1291 
1292  // Store values for number of bad channels in each lumi section, for plots of ProblemsVsLS.
1293  // This is different than the NumBadHB, etc. values, which must included even known bad channels
1294  // in order to calculate reportSummaryByLS values correctly.
1295 
1297  //Check for RBX data loss
1298  unsigned int RBX_loss_HB=0;
1299  unsigned int RBX_loss_HE=0;
1300  unsigned int RBX_loss_HO01=0;
1301  unsigned int RBX_loss_HO2=0;
1302  unsigned int RBX_loss_HF=0;
1303 
1304  unsigned int counter_HB = 0;
1305  unsigned int counter_HE = 0;
1306  unsigned int counter_HO01 = 0;
1307  unsigned int counter_HO2 = 0;
1308  unsigned int counter_HF = 0;
1309 
1310  for(int i=0; i<156; i++)
1311  {
1312  if(occupancy_RBX[i]==0 && is_RBX_loss_ == 1)
1313  {
1314  if(i<=35) //HB
1315  { counter_HB ++ ; RBX_loss_HB = 72*(counter_HB); }
1316  if(i>=36 && i<=71) //HE
1317  { counter_HE ++ ; RBX_loss_HE = 72*(counter_HE); }
1318  if(i>=85 && i<=119) // HO Rings 0, 1
1319  { counter_HO01 ++ ; RBX_loss_HO01 = 72*(counter_HO01); }
1320  if(i>=121 || i<=83) // HO Ring 2
1321  { counter_HO2 ++ ; RBX_loss_HO2 = 72*(counter_HO2); }
1322  if(i>=132 && i<=155) //HF
1323  { counter_HF ++ ; RBX_loss_HF = 72*(counter_HF); }
1324 
1325  if(excludeHO1P02_==true && i==109) NumBadHO1P02 = 72; // exclude HO1P02
1326  }
1327  if(occupancy_RBX[i]>0)
1328  RBX_loss_VS_LB->Fill(currentLS, i, 0);
1329  if(occupancy_RBX[i]==0 && is_RBX_loss_ == 1)
1330  RBX_loss_VS_LB->Fill(currentLS, i, 1);
1331  }
1332 
1333  if (deadevt_ >= 10 && deadevt_<minDeadEventCount_) // maybe not enough events to run the standard test
1334  if( is_RBX_loss_ == 1 ) // but enough to detect RBX loss
1335  {
1336  NumBadHB+=RBX_loss_HB;
1337  NumBadHE+=RBX_loss_HE;
1338  NumBadHO+=RBX_loss_HO01+RBX_loss_HO2;
1339  NumBadHO01+=RBX_loss_HO01;
1340  NumBadHO2+=RBX_loss_HO2;
1341  NumBadHF+=RBX_loss_HF;
1342 
1343  belowenergyHB+=RBX_loss_HB;
1344  belowenergyHE+=RBX_loss_HE;
1345  belowenergyHO+=RBX_loss_HO01+RBX_loss_HO2;
1346  belowenergyHF+=RBX_loss_HF;
1347 
1348  unoccupiedHB+=RBX_loss_HB;
1349  unoccupiedHE+=RBX_loss_HE;
1350  unoccupiedHO+=RBX_loss_HO01+RBX_loss_HO2;
1351  unoccupiedHF+=RBX_loss_HF;
1352  }
1354 
1355  for (unsigned int depth=0;depth<DigiPresentByDepth.depth.size();++depth)
1356  {
1357  DigiPresentByDepth.depth[depth]->setBinContent(0,0,ievt_);
1358  etabins=DigiPresentByDepth.depth[depth]->getNbinsX();
1359  phibins=DigiPresentByDepth.depth[depth]->getNbinsY();
1360  for (int eta=0;eta<etabins;++eta)
1361  {
1362  for (int phi=0;phi<phibins;++phi)
1363  {
1364  iphi=phi+1;
1365  for (int subdet=1;subdet<=4;++subdet)
1366  {
1367  ieta=CalcIeta((HcalSubdetector)subdet,eta,depth+1);
1368  if (ieta==-9999) continue;
1369  if (!validDetId((HcalSubdetector)subdet, ieta, iphi, depth+1))
1370  continue;
1371  // Ignore subdetectors that weren't in run?
1372  /*
1373  if ((subdet==HcalBarrel && !HBpresent_) ||
1374  (subdet==HcalEndcap &&!HEpresent_) ||
1375  (subdet==HcalOuter &&!HOpresent_) ||
1376  (subdet==HcalForward &&!HFpresent_)) continue;
1377  */
1378 
1379  /*
1380  if ((!checkHB_ && subdet==HcalBarrel) ||
1381  (!checkHE_ && subdet==HcalEndcap) ||
1382  (!checkHO_ && subdet==HcalOuter) ||
1383  (!checkHF_ && subdet==HcalForward)) continue;
1384  */
1385 
1386  // now check which dead cell tests failed; increment counter if any failed
1387  if ((present_digi[eta][phi][depth]==0) ||
1388  (deadmon_test_digis_ && recentoccupancy_digi[eta][phi][depth]==0 && (deadevt_>=minDeadEventCount_)) ||
1389  (deadmon_test_rechits_ && recentoccupancy_rechit[eta][phi][depth]==0 && (deadevt_>=minDeadEventCount_))
1390  )
1391  {
1392  HcalDetId TempID((HcalSubdetector)subdet, ieta, iphi, (int)depth+1);
1393  if (subdet==HcalBarrel)
1394  {
1395  ++NumBadHB;
1396  if (KnownBadCells_.find(TempID.rawId())!=KnownBadCells_.end())
1397  ++knownBadHB;
1398  }
1399  else if (subdet==HcalEndcap)
1400  {
1401  ++NumBadHE;
1402  if (KnownBadCells_.find(TempID.rawId())!=KnownBadCells_.end())
1403  ++knownBadHE;
1404  }
1405 
1406  else if (subdet==HcalOuter)
1407  {
1408  ++NumBadHO;
1409  if (abs(ieta)<=10) ++NumBadHO01;
1410  else ++NumBadHO2;
1411  // Don't include HORing2 if boolean set; subtract away those counters
1412  if (excludeHORing2_==true && abs(ieta)>10 && isSiPM(ieta,iphi,depth+1)==false)
1413  {
1414  --NumBadHO;
1415  --NumBadHO2;
1416  --NumBadHO12;
1417  }
1418  // Don't include HO1P02 if boolean set, RBX does not repsond well to resets,; subtract away those counters
1419  if (excludeHO1P02_==true && ( (ieta>4 && ieta<10) && (iphi<=10 || iphi>70) ) )
1420  ++NumBadHO1P02;
1421 
1422  if (KnownBadCells_.find(TempID.rawId())!=KnownBadCells_.end())
1423  {
1424  ++knownBadHO;
1425  if (abs(ieta)<=10) ++knownBadHO01;
1426  else ++knownBadHO2;
1427  // Don't include HORing2 if boolean set; subtract away those counters
1428  if (excludeHORing2_==true && abs(ieta)>10 && isSiPM(ieta,iphi,depth+1)==false)
1429  {
1430  --knownBadHO;
1431  --knownBadHO12;
1432  }
1433  }
1434  }
1435  else if (subdet==HcalForward)
1436  {
1437  ++NumBadHF;
1438  if (depth==1 && (abs(ieta)==33 || abs(ieta)==34))
1439  ++NumBadHFLUMI;
1440  else if (depth==2 && (abs(ieta)==35 || abs(ieta)==36))
1441  ++NumBadHFLUMI;
1442  if (KnownBadCells_.find(TempID.rawId())!=KnownBadCells_.end())
1443  {
1444  ++knownBadHF;
1445  if (depth==1 && (abs(ieta)==33 || abs(ieta)==34))
1446  ++knownBadHFLUMI;
1447  else if (depth==2 && (abs(ieta)==35 || abs(ieta)==36))
1448  ++knownBadHFLUMI;
1449  }
1450  }
1451  }
1452  if (present_digi[eta][phi][depth]==0 )
1453  {
1454  if (subdet==HcalBarrel) ++neverpresentHB;
1455  else if (subdet==HcalEndcap) ++neverpresentHE;
1456  else if (subdet==HcalOuter)
1457  {
1458  ++neverpresentHO;
1459  if (excludeHORing2_==true && abs(ieta)>10 && isSiPM(ieta,iphi,depth+1)==false)
1460  --neverpresentHO;
1461  }
1462  else if (subdet==HcalForward) ++neverpresentHF;
1463  }
1464  // Count recent unoccupied digis if the total events in this lumi section is > minEvents_
1465  if (deadmon_test_digis_ && recentoccupancy_digi[eta][phi][depth]==0 && deadevt_>=minDeadEventCount_)
1466  {
1467  HcalDetId TempID((HcalSubdetector)subdet, ieta, iphi, (int)depth+1);
1468  if (subdet==HcalBarrel) ++unoccupiedHB;
1469  else if (subdet==HcalEndcap) ++unoccupiedHE;
1470  else if (subdet==HcalOuter)
1471  {
1472  ++unoccupiedHO;
1473  if (excludeHORing2_==true && abs(ieta)>10 && isSiPM(ieta,iphi,depth+1)==false)
1474  --unoccupiedHO;
1475  if (KnownBadCells_.find(TempID.rawId())!=KnownBadCells_.end() && abs(ieta)<=10)
1476  --unoccupiedHO;
1477  }
1478  else if (subdet==HcalForward) ++unoccupiedHF;
1479  }
1480  // Look at rechit checks
1481  if (deadmon_test_rechits_)
1482  {
1483  if (present_rechit[eta][phi][depth]==0)
1484  {
1485  if (subdet==HcalBarrel) ++energyneverpresentHB;
1486  else if (subdet==HcalEndcap) ++energyneverpresentHE;
1487  else if (subdet==HcalOuter)
1488  {
1489  ++energyneverpresentHO;
1490  if (excludeHORing2_==true && abs(ieta)>10 && isSiPM(ieta,iphi,depth+1)==false)
1491  --energyneverpresentHO;
1492  }
1493  else if (subdet==HcalForward) ++energyneverpresentHF;
1494  }
1495  if (recentoccupancy_rechit[eta][phi][depth]==0 && deadevt_>=minDeadEventCount_)
1496  {
1497  HcalDetId TempID((HcalSubdetector)subdet, ieta, iphi, (int)depth+1);
1498  if (subdet==HcalBarrel) ++belowenergyHB;
1499  else if (subdet==HcalEndcap) ++belowenergyHE;
1500  else if (subdet==HcalOuter)
1501  {
1502  ++belowenergyHO;
1503  if (excludeHORing2_==true && abs(ieta)>10 && isSiPM(ieta,iphi,depth+1)==false)
1504  --belowenergyHO;
1505  if (KnownBadCells_.find(TempID.rawId())!=KnownBadCells_.end() && abs(ieta)<=10)
1506  --belowenergyHO;
1507  }
1508  else if (subdet==HcalForward) ++belowenergyHF;
1509  }
1510  }
1511  } // subdet loop
1512  } // phi loop
1513  } //eta loop
1514  } // depth loop
1515 
1516  // Fill with number of problem cells found on this pass
1517  NumberOfNeverPresentDigisHB->Fill(currentLS,neverpresentHB);
1518  NumberOfNeverPresentDigisHE->Fill(currentLS,neverpresentHE);
1519  NumberOfNeverPresentDigisHO->Fill(currentLS,neverpresentHO);
1520  NumberOfNeverPresentDigisHF->Fill(currentLS,neverpresentHF);
1521  NumberOfNeverPresentDigis->Fill(currentLS,neverpresentHB+neverpresentHE+neverpresentHO+neverpresentHF);
1522 
1523  if (deadevt_>=minDeadEventCount_ && is_RBX_loss_ == 1 )
1524  {
1525  if( NumBadHB<RBX_loss_HB )
1526  NumBadHB+=RBX_loss_HB;
1527  if( NumBadHE<RBX_loss_HE )
1528  NumBadHE+=RBX_loss_HE;
1529  if( NumBadHO01<RBX_loss_HO01 )
1530  NumBadHO01+=RBX_loss_HO01;
1531  if( NumBadHO2<RBX_loss_HO2 )
1532  NumBadHO2+=RBX_loss_HO2;
1533  if( NumBadHF<RBX_loss_HF )
1534  NumBadHF+=RBX_loss_HF;
1535 
1536  if( belowenergyHB<RBX_loss_HB )
1537  belowenergyHB+=RBX_loss_HB;
1538  if( belowenergyHE<RBX_loss_HE )
1539  belowenergyHE+=RBX_loss_HE;
1540  if( belowenergyHO<RBX_loss_HO01+RBX_loss_HO2)
1541  belowenergyHO+=RBX_loss_HO01+RBX_loss_HO2;
1542  if( belowenergyHF<RBX_loss_HF )
1543  belowenergyHF+=RBX_loss_HF;
1544 
1545  if( unoccupiedHB<RBX_loss_HB )
1546  unoccupiedHB+=RBX_loss_HB;
1547  if( unoccupiedHE<RBX_loss_HE )
1548  unoccupiedHE+=RBX_loss_HE;
1549  if( unoccupiedHO<RBX_loss_HO01+RBX_loss_HO2 )
1550  unoccupiedHO+=RBX_loss_HO01+RBX_loss_HO2;
1551  if( unoccupiedHF<RBX_loss_HF )
1552  unoccupiedHF+=RBX_loss_HF;
1553 
1554  // is_RBX_loss_ = 0;
1555  }
1556 
1557  ProblemsVsLB_HB->Fill(currentLS,NumBadHB-knownBadHB+0.0001); // add a small offset, so that the histograms reset when no errors follow
1558  ProblemsVsLB_HE->Fill(currentLS,NumBadHE-knownBadHE+0.0001); // problematic LSs
1559  ProblemsVsLB_HO->Fill(currentLS,NumBadHO01-knownBadHO01+0.0001);
1560  ProblemsVsLB_HO2->Fill(currentLS,NumBadHO2-knownBadHO2+0.0001);
1561  ProblemsVsLB_HF->Fill(currentLS,NumBadHF-knownBadHF+0.0001);
1562  ProblemsVsLB_HBHEHF->Fill(currentLS,NumBadHB+NumBadHE+NumBadHF-knownBadHB-knownBadHE-knownBadHF+0.0001);
1563  ProblemsVsLB->Fill(currentLS,NumBadHB+NumBadHE+NumBadHO01+NumBadHO2+NumBadHF-knownBadHB-knownBadHE-knownBadHO01-knownBadHO2-knownBadHF+0.0001);
1564 
1565  if(excludeHO1P02_==true)
1566  ProblemsVsLB_HO->Fill(0, NumBadHO1P02);
1567 
1568  if( NumBadHB+NumBadHE+NumBadHF-knownBadHB-knownBadHE-knownBadHF < 30 )
1569  alarmer_counter_ = 0;
1570  if( NumBadHO01-knownBadHO01 < 30 )
1571  alarmer_counterHO01_ = 0;
1572 
1573  if( alarmer_counter_ >= 10 )
1574  ProblemsInLastNLB_HBHEHF_alarm->Fill( std::min(int(NumBadHB+NumBadHE+NumBadHF-knownBadHB-knownBadHE-knownBadHF), 99) );
1575  if( alarmer_counterHO01_ >= 10 )
1576  ProblemsInLastNLB_HO01_alarm->Fill( std::min(int(NumBadHO01-knownBadHO01), 99) );
1577 
1578  // if (deadevt_<minDeadEventCount_)
1579  // return;
1580 
1581  if (deadmon_test_digis_)
1582  {
1583  NumberOfRecentMissingDigisHB->Fill(currentLS,unoccupiedHB);
1584  NumberOfRecentMissingDigisHE->Fill(currentLS,unoccupiedHE);
1585  NumberOfRecentMissingDigisHO->Fill(currentLS,unoccupiedHO);
1586  NumberOfRecentMissingDigisHF->Fill(currentLS,unoccupiedHF);
1587  NumberOfRecentMissingDigis->Fill(currentLS,unoccupiedHB+unoccupiedHE+unoccupiedHO+unoccupiedHF);
1588  }
1589 
1590  if (deadmon_test_rechits_)
1591  {
1592  NumberOfNeverPresentRecHitsHB->Fill(currentLS,energyneverpresentHB);
1593  NumberOfNeverPresentRecHitsHE->Fill(currentLS,energyneverpresentHE);
1594  NumberOfNeverPresentRecHitsHO->Fill(currentLS,energyneverpresentHO);
1595  NumberOfNeverPresentRecHitsHF->Fill(currentLS,energyneverpresentHF);
1596  NumberOfNeverPresentRecHits->Fill(currentLS,energyneverpresentHB+energyneverpresentHE+energyneverpresentHO+energyneverpresentHF);
1597 
1598  NumberOfRecentMissingRecHitsHB->Fill(currentLS,belowenergyHB);
1599  NumberOfRecentMissingRecHitsHE->Fill(currentLS,belowenergyHE);
1600  NumberOfRecentMissingRecHitsHO->Fill(currentLS,belowenergyHO);
1601  NumberOfRecentMissingRecHitsHF->Fill(currentLS,belowenergyHF);
1602  NumberOfRecentMissingRecHits->Fill(currentLS,belowenergyHB+belowenergyHE+belowenergyHO+belowenergyHF);
1603  }
1604 
1605  return;
1606 } // void HcalDeadCellMonitor::fillNevents_problemCells(void)
1607 
1608 
1609 void HcalDeadCellMonitor::zeroCounters(bool resetpresent)
1610 {
1611 
1612  // zero all counters
1613 
1614  // 2D histogram counters
1615  for (unsigned int i=0;i<85;++i)
1616  {
1617  for (unsigned int j=0;j<72;++j)
1618  {
1619  for (unsigned int k=0;k<4;++k)
1620  {
1621  if (resetpresent) present_digi[i][j][k]=false; // keeps track of whether digi was ever present
1622  if (resetpresent) present_rechit[i][j][k]=false;
1623  recentoccupancy_digi[i][j][k]=0; // counts occupancy in last (checkNevents) events
1624  recentoccupancy_rechit[i][j][k]=0; // counts instances of cell above threshold energy in last (checkNevents)
1625  }
1626  }
1627  }
1628 
1629  for (unsigned int i=0;i<156;++i)
1630  {
1631  occupancy_RBX[i] = 0;
1632  rbxlost[i] = 0;
1633  }
1634 
1635  return;
1636 } // void HcalDeadCellMonitor::zeroCounters(bool resetpresent)
1637 
1638 DEFINE_FWK_MODULE(HcalDeadCellMonitor);
HcalDeadCellMonitor::hfRechitLabel_
edm::InputTag hfRechitLabel_
Definition: HcalDeadCellMonitor.h:116
HcalDeadCellMonitor::beginRun
void beginRun(const edm::Run &run, const edm::EventSetup &c)
Definition: HcalDeadCellMonitor.cc:382
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
i
int i
Definition: DBlmapReader.cc:9
HcalDeadCellMonitor::NumberOfNeverPresentRecHitsHO
MonitorElement * NumberOfNeverPresentRecHitsHO
Definition: HcalDeadCellMonitor.h:94
HcalBaseDQMonitor::LumiInOrder
bool LumiInOrder(int lumisec)
Definition: HcalBaseDQMonitor.cc:185
create_public_lumi_plots.units
tuple units
Definition: create_public_lumi_plots.py:954
HcalDeadCellMonitor::NumberOfRecentMissingRecHitsHF
MonitorElement * NumberOfRecentMissingRecHitsHF
Definition: HcalDeadCellMonitor.h:93
HcalDeadCellMonitor::NumberOfNeverPresentRecHits
MonitorElement * NumberOfNeverPresentRecHits
Definition: HcalDeadCellMonitor.h:94
MonitorElement::setBinContent
void setBinContent(int binx, double content)
set content of bin (1-D)
Definition: MonitorElement.cc:813
HcalBaseDQMonitor::ProblemsCurrentLB
MonitorElement * ProblemsCurrentLB
Definition: HcalBaseDQMonitor.h:115
HcalDeadCellMonitor::NumberOfNeverPresentDigisHB
MonitorElement * NumberOfNeverPresentDigisHB
Definition: HcalDeadCellMonitor.h:91
binmapd2
const int binmapd2[]
Definition: HcalEtaPhiHists.h:193
HcalDeadCellMonitor::analyze
void analyze(edm::Event const &e, edm::EventSetup const &s)
Definition: HcalDeadCellMonitor.cc:621
HcalBaseDQMonitor::analyze
virtual void analyze(const edm::Event &e, const edm::EventSetup &c)
Definition: HcalBaseDQMonitor.cc:231
HcalDeadCellMonitor::HEDeadVsEvent
MonitorElement * HEDeadVsEvent
Definition: HcalDeadCellMonitor.h:100
HcalDeadCellMonitor::NumberOfRecentMissingRecHits
MonitorElement * NumberOfRecentMissingRecHits
Definition: HcalDeadCellMonitor.h:93
DQMStore::book1D
MonitorElement * book1D(const char *name, const char *title, int nchX, double lowX, double highX)
Book 1D histogram.
Definition: DQMStore.cc:722
HcalDeadCellMonitor::zeroCounters
void zeroCounters(bool resetpresent=false)
Definition: HcalDeadCellMonitor.cc:1609
HcalDeadCellMonitor::present_digi
bool present_digi[85][72][4]
Definition: HcalDeadCellMonitor.h:101
HcalDeadCellMonitor::hbheRechitLabel_
edm::InputTag hbheRechitLabel_
Definition: HcalDeadCellMonitor.h:116
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:17
HcalBaseDQMonitor::KnownBadCells_
std::map< unsigned int, int > KnownBadCells_
Definition: HcalBaseDQMonitor.h:121
HcalDeadCellMonitor::NumberOfNeverPresentDigisHE
MonitorElement * NumberOfNeverPresentDigisHE
Definition: HcalDeadCellMonitor.h:91
HcalBaseDQMonitor::AllowedCalibTypes_
std::vector< int > AllowedCalibTypes_
Definition: HcalBaseDQMonitor.h:86
HcalDeadCellMonitor::endRun
void endRun(const edm::Run &run, const edm::EventSetup &c)
Definition: HcalDeadCellMonitor.cc:605
EtaPhiHists::Reset
void Reset(void)
Definition: HcalEtaPhiHists.h:179
edm::SortedCollection::const_iterator
std::vector< T >::const_iterator const_iterator
Definition: SortedCollection.h:80
HcalDeadCellMonitor::HcalDeadCellMonitor
HcalDeadCellMonitor(const edm::ParameterSet &ps)
Definition: HcalDeadCellMonitor.cc:5
MonitorElement::setBinLabel
void setBinLabel(int bin, const std::string &label, int axis=1)
set bin label for x, y or z axis (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:889
abs
#define abs(x)
Definition: mlp_lapack.h:159
edm::EventBase::luminosityBlock
edm::LuminosityBlockNumber_t luminosityBlock() const
Definition: EventBase.h:59
HcalDeadCellMonitor::NumberOfRecentMissingDigisHB
MonitorElement * NumberOfRecentMissingDigisHB
Definition: HcalDeadCellMonitor.h:92
min
#define min(a, b)
Definition: mlp_lapack.h:161
HcalCondObjectContainer::getValues
const Item * getValues(DetId fId, bool throwOnFail=true) const
Definition: HcalCondObjectContainer.h:123
MonitorElement::update
void update(void)
Mark the object updated.
Definition: MonitorElement.h:123
HcalDeadCellMonitor::process_RecHit
void process_RecHit(T &rechit)
eta
T eta() const
Definition: Basic3DVectorLD.h:179
HcalDeadCellMonitor::ProblemsInLastNLB_HO01_alarm
MonitorElement * ProblemsInLastNLB_HO01_alarm
Definition: HcalDeadCellMonitor.h:90
HcalDeadCellMonitor::NumberOfRecentMissingDigisHE
MonitorElement * NumberOfRecentMissingDigisHE
Definition: HcalDeadCellMonitor.h:92
HcalDeadCellMonitor::present_rechit
bool present_rechit[85][72][4]
Definition: HcalDeadCellMonitor.h:102
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
DQMStore::bookFloat
MonitorElement * bookFloat(const char *name)
Book float.
Definition: DQMStore.cc:659
MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:152
edm::LuminosityBlockBase::luminosityBlock
LuminosityBlockNumber_t luminosityBlock() const
Definition: LuminosityBlockBase.h:45
DetId::rawId
uint32_t rawId() const
get the raw id
Definition: DetId.h:45
isSiPM
bool isSiPM(int ieta, int iphi, int depth)
Definition: HcalEtaPhiHists.h:489
HcalDeadCellMonitor::RecHitPresentByDepth
EtaPhiHists RecHitPresentByDepth
Definition: HcalDeadCellMonitor.h:84
HcalDeadCellMonitor::RBX_loss_VS_LB
MonitorElement * RBX_loss_VS_LB
Definition: HcalDeadCellMonitor.h:88
EtaPhiHists::depth
std::vector< MonitorElement * > depth
Definition: HcalEtaPhiHists.h:183
HcalBaseDQMonitor::beginRun
virtual void beginRun(const edm::Run &run, const edm::EventSetup &c)
Definition: HcalBaseDQMonitor.cc:89
HcalObjRepresent::CalcIeta
int CalcIeta(int subdet, int eta, int depth)
Definition: HcalObjRepresent.h:200
HcalDeadCellMonitor::ProblemsVsLB
MonitorElement * ProblemsVsLB
Definition: HcalDeadCellMonitor.h:87
DQMStore::removeContents
void removeContents(void)
erase all monitoring elements in current directory (not including subfolders);
Definition: DQMStore.cc:2569
HcalDeadCellMonitor::NumberOfNeverPresentDigisHF
MonitorElement * NumberOfNeverPresentDigisHF
Definition: HcalDeadCellMonitor.h:91
HcalBaseDQMonitor::ProblemsVsLB_HBHEHF
MonitorElement * ProblemsVsLB_HBHEHF
Definition: HcalBaseDQMonitor.h:114
HcalDeadCellMonitor::hoRechitLabel_
edm::InputTag hoRechitLabel_
Definition: HcalDeadCellMonitor.h:116
HcalCondObjectContainer::getAllChannels
std::vector< DetId > getAllChannels() const
Definition: HcalCondObjectContainer.h:233
HcalDeadCellMonitor::occupancy_RBX
unsigned int occupancy_RBX[156]
Definition: HcalDeadCellMonitor.h:105
HcalBaseDQMonitor::logicalMap_
HcalLogicalMap * logicalMap_
Definition: HcalBaseDQMonitor.h:123
HcalDeadCellMonitor::NumberOfNeverPresentDigisHO
MonitorElement * NumberOfNeverPresentDigisHO
Definition: HcalDeadCellMonitor.h:91
HcalDeadCellMonitor::processEvent_HBHEdigi
void processEvent_HBHEdigi(const HBHEDataFrame digi)
Definition: HcalDeadCellMonitor.cc:908
HcalDetId::ieta
int ieta() const
get the cell ieta
Definition: HcalDetId.h:38
HcalDeadCellMonitor::NumberOfNeverPresentRecHitsHB
MonitorElement * NumberOfNeverPresentRecHitsHB
Definition: HcalDeadCellMonitor.h:94
HcalSubdetector
HcalSubdetector
Definition: HcalAssistant.h:32
j
int j
Definition: DBlmapReader.cc:9
HcalDeadCellMonitor::Nevents
MonitorElement * Nevents
Definition: HcalDeadCellMonitor.h:96
DQMStore::bookProfile
MonitorElement * bookProfile(const char *name, const char *title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, const char *option="s")
Definition: DQMStore.cc:1036
HcalDeadCellMonitor::recentoccupancy_rechit
unsigned int recentoccupancy_rechit[85][72][4]
Definition: HcalDeadCellMonitor.h:104
HcalDeadCellMonitor::NumberOfRecentMissingRecHitsHE
MonitorElement * NumberOfRecentMissingRecHitsHE
Definition: HcalDeadCellMonitor.h:93
HcalDeadCellMonitor::ProblemsVsLB_HF
MonitorElement * ProblemsVsLB_HF
Definition: HcalDeadCellMonitor.h:87
HcalDeadCellMonitor::NumberOfRecentMissingDigisHO
MonitorElement * NumberOfRecentMissingDigisHO
Definition: HcalDeadCellMonitor.h:92
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:76
HcalDeadCellMonitor::NumberOfNeverPresentRecHitsHF
MonitorElement * NumberOfNeverPresentRecHitsHF
Definition: HcalDeadCellMonitor.h:94
edm::Event::getByLabel
bool getByLabel(InputTag const &tag, Handle< PROD > &result) const
Definition: Event.h:361
HcalDeadCellMonitor::ProblemsVsLB_HB
MonitorElement * ProblemsVsLB_HB
Definition: HcalDeadCellMonitor.h:87
gen::k
int k[5][pyjets_maxn]
Definition: Cascade2Hadronizer.cc:81
L1GtfeExtWord::totalIntensityBeam2
const cms_uint32_t totalIntensityBeam2() const
Definition: L1GtfeExtWord.cc:376
edm::SortedCollection::end
const_iterator end() const
Definition: SortedCollection.h:301
HcalLogicalMap::getHcalFrontEndId
const HcalFrontEndId getHcalFrontEndId(const DetId &)
Definition: HcalLogicalMap.cc:262
L1GtfeExtWord::totalIntensityBeam1
const cms_uint32_t totalIntensityBeam1() const
Definition: L1GtfeExtWord.cc:351
HcalDeadCellMonitor::recentoccupancy_digi
unsigned int recentoccupancy_digi[85][72][4]
Definition: HcalDeadCellMonitor.h:103
HcalDeadCellMonitor::processEvent
void processEvent(const HBHERecHitCollection &hbHits, const HORecHitCollection &hoHits, const HFRecHitCollection &hfHits, const HBHEDigiCollection &hbhedigi, const HODigiCollection &hodigi, const HFDigiCollection &hfdigi)
Definition: HcalDeadCellMonitor.cc:779
HcalDeadCellMonitor::RecentMissingDigisByDepth
EtaPhiHists RecentMissingDigisByDepth
Definition: HcalDeadCellMonitor.h:81
HcalDeadCellMonitor::NumberOfRecentMissingRecHitsHO
MonitorElement * NumberOfRecentMissingRecHitsHO
Definition: HcalDeadCellMonitor.h:93
edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:55
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:62
HcalDeadCellMonitor::DigiPresentByDepth
EtaPhiHists DigiPresentByDepth
Definition: HcalDeadCellMonitor.h:82
HcalFrontEndId::rbxIndex
int rbxIndex() const
Definition: HcalFrontEndId.h:17
HcalBaseDQMonitor::reset
virtual void reset(void)
Definition: HcalBaseDQMonitor.cc:109
HcalObjRepresent::FillUnphysicalHEHFBins
void FillUnphysicalHEHFBins(std::vector< TH2F > &hh)
Definition: HcalObjRepresent.h:528
edm::Handle::product
T const * product() const
Definition: Handle.h:74
HcalDeadCellMonitor::RecentMissingRecHitsByDepth
EtaPhiHists RecentMissingRecHitsByDepth
Definition: HcalDeadCellMonitor.h:83
CalcEtaBin
int CalcEtaBin(int subdet, int ieta, int depth)
Definition: HcalEtaPhiHists.h:202
HcalBaseDQMonitor::SetupEtaPhiHists
void SetupEtaPhiHists(EtaPhiHists &hh, std::string Name, std::string Units)
Definition: HcalBaseDQMonitor.h:76
HcalDeadCellMonitor::HBDeadVsEvent
MonitorElement * HBDeadVsEvent
Definition: HcalDeadCellMonitor.h:100
AlCaHLTBitMon_ParallelJobs.p
tuple p
Definition: AlCaHLTBitMon_ParallelJobs.py:152
HcalDeadCellMonitor::NumberOfNeverPresentRecHitsHE
MonitorElement * NumberOfNeverPresentRecHitsHE
Definition: HcalDeadCellMonitor.h:94
HcalDeadCellMonitor::ProblemsVsLB_HE
MonitorElement * ProblemsVsLB_HE
Definition: HcalDeadCellMonitor.h:87
MonitorElement::getTProfile
TProfile * getTProfile(void) const
Definition: MonitorElement.cc:1542
HcalDeadCellMonitor::NumberOfNeverPresentDigis
MonitorElement * NumberOfNeverPresentDigis
Definition: HcalDeadCellMonitor.h:91
HcalDeadCellMonitor::NumberOfRecentMissingDigis
MonitorElement * NumberOfRecentMissingDigis
Definition: HcalDeadCellMonitor.h:92
reco::JetExtendedAssociation::getValue
const JetExtendedData & getValue(const Container &, const reco::JetBaseRef &)
get value for the association. Throw exception if no association found
Definition: JetExtendedAssociation.cc:51
HcalDeadCellMonitor::endLuminosityBlock
void endLuminosityBlock(const edm::LuminosityBlock &lumiSeg, const edm::EventSetup &c)
Definition: HcalDeadCellMonitor.cc:519
HcalDeadCellMonitor::NumberOfRecentMissingDigisHF
MonitorElement * NumberOfRecentMissingDigisHF
Definition: HcalDeadCellMonitor.h:92
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:121
HcalDeadCellMonitor::process_Digi
void process_Digi(T &digi)
ntuplemaker.status
tuple status
Definition: ntuplemaker.py:245
DQMStore::bookInt
MonitorElement * bookInt(const char *name)
Book int.
Definition: DQMStore.cc:629
HcalDeadCellMonitor::ProblemsInLastNLB_HBHEHF_alarm
MonitorElement * ProblemsInLastNLB_HBHEHF_alarm
Definition: HcalDeadCellMonitor.h:89
DQMStore::book2D
MonitorElement * book2D(const char *name, const char *title, int nchX, double lowX, double highX, int nchY, double lowY, double highY)
Book 2D histogram.
Definition: DQMStore.cc:850
HcalBaseDQMonitor::setup
virtual void setup(void)
Definition: HcalBaseDQMonitor.cc:133
HcalDeadCellMonitor::HFDeadVsEvent
MonitorElement * HFDeadVsEvent
Definition: HcalDeadCellMonitor.h:100
MonitorElement::Reset
void Reset(void)
reset ME (ie. contents, errors, etc)
Definition: MonitorElement.cc:422
L1GtfeExtWord::beamMode
const cms_uint16_t beamMode() const
Definition: L1GtfeExtWord.cc:254
HcalDeadCellMonitor::ProblemsVsLB_HO2
MonitorElement * ProblemsVsLB_HO2
Definition: HcalDeadCellMonitor.h:87
DQMStore::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:434
HcalDeadCellMonitor::HODeadVsEvent
MonitorElement * HODeadVsEvent
Definition: HcalDeadCellMonitor.h:100
edm::SortedCollection::begin
const_iterator begin() const
Definition: SortedCollection.h:294
edm::Run
Definition: Run.h:36
validDetId
bool validDetId(HcalSubdetector sd, int ies, int ip, int dp)
Definition: HcalEtaPhiHists.h:502
HcalDeadCellMonitor::NumberOfRecentMissingRecHitsHB
MonitorElement * NumberOfRecentMissingRecHitsHB
Definition: HcalDeadCellMonitor.h:93
HcalDeadCellMonitor::ProblemsVsLB_HO
MonitorElement * ProblemsVsLB_HO
Definition: HcalDeadCellMonitor.h:87
phi
Definition: DDAxes.h:10
Generated for CMSSW Reference Manual by doxygen 1.8.5