Belle II Software  release-05-01-25
DQMHistAnalysisPXDEff.cc
1 //+
2 // File : DQMHistAnalysisPXDEff.cc
3 // Description : DQM module, which gives histograms showing the efficiency of PXD sensors
4 //
5 // Author : Uwe Gebauer, Bjoern Spruck
6 //-
7 
8 
9 #include <dqm/analysis/modules/DQMHistAnalysisPXDEff.h>
10 #include <TROOT.h>
11 #include <TLatex.h>
12 #include <TGraphAsymmErrors.h>
13 #include <vxd/geometry/GeoCache.h>
14 
15 using namespace std;
16 using namespace Belle2;
17 
18 //-----------------------------------------------------------------
19 // Register the Module
20 //-----------------------------------------------------------------
21 REG_MODULE(DQMHistAnalysisPXDEff)
22 
23 //-----------------------------------------------------------------
24 // Implementation
25 //-----------------------------------------------------------------
26 
28 {
29  // This module CAN NOT be run in parallel!
30 
31  //Parameter definition
32 
33  //Would be much more elegant to get bin numbers from the saved histograms, but would need to retrieve at least one of them before the initialize function for this
34  //Or get one and clone it
35  addParam("binsU", m_u_bins, "histogram bins in u direction, needs to be the same as in PXDDQMEfficiency", int(4));
36  addParam("binsV", m_v_bins, "histogram bins in v direction, needs to be the same as in PXDDQMEfficiency", int(6));
37  addParam("histogramDirectoryName", m_histogramDirectoryName, "Name of the directory where histograms were placed",
38  std::string("PXDEFF"));
39  addParam("singleHists", m_singleHists, "Also plot one efficiency histogram per module", bool(false));
40  addParam("PVPrefix", m_pvPrefix, "PV Prefix", std::string("DQM:PXD:Eff:"));
41  addParam("useEpics", m_useEpics, "useEpics", true);
42  addParam("ConfidenceLevel", m_confidence, "Confidence Level for error bars and alarms", 0.9544);
43  addParam("WarnLevel", m_warnlevel, "Efficiency Warn Level for alarms", 0.92);
44  addParam("ErrorLevel", m_errorlevel, "Efficiency Level for alarms", 0.90);
45  addParam("minEntries", m_minEntries, "minimum number of new entries for last time slot", 1000);
46  B2DEBUG(1, "DQMHistAnalysisPXDEff: Constructor done.");
47 }
48 
49 DQMHistAnalysisPXDEffModule::~DQMHistAnalysisPXDEffModule()
50 {
51 #ifdef _BELLE2_EPICS
52  if (m_useEpics) {
53  if (ca_current_context()) ca_context_destroy();
54  }
55 #endif
56 }
57 
58 void DQMHistAnalysisPXDEffModule::initialize()
59 {
60  B2DEBUG(99, "DQMHistAnalysisPXDEffModule: initialized.");
61 
62  m_monObj = getMonitoringObject("pxd");
63  const VXD::GeoCache& geo = VXD::GeoCache::getInstance();
64 
65  // collect the list of all PXD Modules in the geometry here
66  std::vector<VxdID> sensors = geo.getListOfSensors();
67  for (VxdID& aVxdID : sensors) {
68  VXD::SensorInfoBase info = geo.getSensorInfo(aVxdID);
69  if (info.getType() != VXD::SensorInfoBase::PXD) continue;
70  m_PXDModules.push_back(aVxdID); // reorder, sort would be better
71  }
72  std::sort(m_PXDModules.begin(), m_PXDModules.end()); // back to natural order
73 
74  gROOT->cd(); // this seems to be important, or strange things happen
75 
76  int nu = 1;//If this does not get overwritten, the histograms will anyway never contain anything useful
77  int nv = 1;
78  //Have been promised that all modules have the same number of pixels, so just take from the first one
79  if (m_PXDModules.size() == 0) {
80  //This could as well be a B2FATAL, the module won't do anything useful if this happens
81  B2WARNING("No PXDModules in Geometry found! Use hard-coded setup.");
82  std::vector <string> mod = {
83  "1.1.1", "1.1.2", "1.2.1", "1.2.2", "1.3.1", "1.3.2", "1.4.1", "1.4.2",
84  "1.5.1", "1.5.2", "1.6.1", "1.6.2", "1.7.1", "1.7.2", "1.8.1", "1.8.2",
85  "2.4.1", "2.4.2", "2.5.1", "2.5.2"
86  };
87  for (auto& it : mod) m_PXDModules.push_back(VxdID(it));
88  // set some default size to nu, nv?
89  } else {
90  VXD::SensorInfoBase cellGetInfo = geo.getSensorInfo(m_PXDModules[0]);
91  nu = cellGetInfo.getUCells();
92  nv = cellGetInfo.getVCells();
93  }
94 
95 #ifdef _BELLE2_EPICS
96  if (m_useEpics) {
97  if (!ca_current_context()) SEVCHK(ca_context_create(ca_disable_preemptive_callback), "ca_context_create");
98  }
99 #endif
100 
101 
102  for (VxdID& aPXDModule : m_PXDModules) {
103  TString buff = (std::string)aPXDModule;
104  buff.ReplaceAll(".", "_");
105 #ifdef _BELLE2_EPICS
106  if (m_useEpics) {
107  auto& my = mychid_eff[aPXDModule];
108  SEVCHK(ca_create_channel((m_pvPrefix + buff).Data(), NULL, NULL, 10, &my), "ca_create_channel failure");
109  B2WARNING(m_pvPrefix + (std::string)aPXDModule);
110  }
111 #endif
112  TString histTitle = "Hit Efficiency on Module " + (std::string)aPXDModule + ";Pixel in U;Pixel in V";
113  if (m_singleHists) {
114  m_cEffModules[aPXDModule] = new TCanvas((m_histogramDirectoryName + "/c_Eff_").data() + buff);
115  m_hEffModules[aPXDModule] = new TEfficiency("HitEff_" + buff, histTitle,
116  m_u_bins, -0.5, nu - 0.5, m_v_bins, -0.5, nv - 0.5);
117  }
118  }
119 
120  //One bin for each module in the geometry, one histogram for each layer
121  m_cEffAll = new TCanvas((m_histogramDirectoryName + "/c_EffAll").data());
122  m_hEffAll = new TEfficiency("HitEffAll", "Integrated Efficiency of each module;PXD Module;",
123  m_PXDModules.size(), 0, m_PXDModules.size());
124  m_hEffAll->SetConfidenceLevel(m_confidence);
125  m_hEffAll->Paint("AP");
126  m_hEffAllLastTotal = m_hEffAll->GetCopyTotalHisto();
127  m_hEffAllLastPassed = m_hEffAll->GetCopyPassedHisto();
128 
129  {
130  auto gr = m_hEffAll->GetPaintedGraph();
131 
132  if (gr) {
133  auto ax = gr->GetXaxis();
134  if (ax) {
135  ax->Set(m_PXDModules.size(), 0, m_PXDModules.size());
136  for (unsigned int i = 0; i < m_PXDModules.size(); i++) {
137  TString ModuleName = (std::string)m_PXDModules[i];
138  ax->SetBinLabel(i + 1, ModuleName);
139  }
140  }
141  }
142  }
143 
144  m_cEffAllUpdate = new TCanvas((m_histogramDirectoryName + "/c_EffAllUp").data());
145  m_hEffAllUpdate = new TEfficiency("HitEffAllUpdate", "Integral and last-updated Efficiency per module;PXD Module;",
146  m_PXDModules.size(), 0, m_PXDModules.size());
147  m_hEffAllUpdate->SetConfidenceLevel(m_confidence);
148 
149  {
150  auto gr = m_hEffAllUpdate->GetPaintedGraph();
151 
152  if (gr) {
153  auto ax = gr->GetXaxis();
154  if (ax) {
155  ax->Set(m_PXDModules.size(), 0, m_PXDModules.size());
156  for (unsigned int i = 0; i < m_PXDModules.size(); i++) {
157  TString ModuleName = (std::string)m_PXDModules[i];
158  ax->SetBinLabel(i + 1, ModuleName);
159  }
160  }
161  }
162  }
163 
164  //Unfortunately this only changes the labels, but can't fill the bins by the VxdIDs
165  m_line_warn = new TLine(0, m_warnlevel, m_PXDModules.size(), m_warnlevel);
166  m_line_error = new TLine(0, m_errorlevel, m_PXDModules.size(), m_errorlevel);
167  m_line_warn->SetHorizontal(true);
168  m_line_warn->SetLineColor(kOrange - 3);
169  m_line_warn->SetLineWidth(3);
170  m_line_warn->SetLineStyle(4);
171  m_line_error->SetHorizontal(true);
172  m_line_error->SetLineColor(kRed + 3);
173  m_line_error->SetLineWidth(3);
174  m_line_error->SetLineStyle(7);
175 
176  m_monObj->addCanvas(m_cEffAll);
177  m_monObj->addCanvas(m_cEffAllUpdate);
178 
179 #ifdef _BELLE2_EPICS
180  if (m_useEpics) {
181  // values per module, see above
182  mychid_status.resize(2);
183  if (!ca_current_context()) SEVCHK(ca_context_create(ca_disable_preemptive_callback), "ca_context_create");
184  SEVCHK(ca_create_channel((m_pvPrefix + "Status").data(), NULL, NULL, 10, &mychid_status[0]), "ca_create_channel failure");
185  SEVCHK(ca_create_channel((m_pvPrefix + "Overall").data(), NULL, NULL, 10, &mychid_status[1]), "ca_create_channel failure");
186  SEVCHK(ca_pend_io(5.0), "ca_pend_io failure");
187  }
188 #endif
189  B2DEBUG(1, "DQMHistAnalysisPXDEff: initialized.");
190 }
191 
192 
193 void DQMHistAnalysisPXDEffModule::beginRun()
194 {
195  B2DEBUG(1, "DQMHistAnalysisPXDEff: beginRun called.");
196 
197  m_cEffAll->Clear();
198  m_cEffAllUpdate->Clear();
199 
200  // no way to reset TEfficiency, do it bin by bin
201  for (unsigned int i = 0; i < m_PXDModules.size(); i++) {
202  int j = i + 1;
203  m_hEffAll->SetPassedEvents(j, 0); // order, otherwise it might happen that SetTotalEvents is NOT filling the value!
204  m_hEffAll->SetTotalEvents(j, 0);
205  m_hEffAllUpdate->SetPassedEvents(j, 0); // otherwise it might happen that SetTotalEvents is NOT filling the value!
206  m_hEffAllUpdate->SetTotalEvents(j, 0);
207  }
208  // Thus histo will contain old content until first update
209  m_hEffAllLastTotal->Reset();
210  m_hEffAllLastPassed->Reset();
211 
212  for (auto single_cmap : m_cEffModules) {
213  if (single_cmap.second) single_cmap.second->Clear();
214  }
215 
216 }
217 
218 
219 void DQMHistAnalysisPXDEffModule::event()
220 {
221 
222  //Save the pointers to create the summary hists later
223  std::map<VxdID, TH1*> mapHits;
224  std::map<VxdID, TH1*> mapMatches;
225 
226  //Count how many of each type of histogram there are for the averaging
227  //std::map<std::string, int> typeCounter;
228 
229  for (unsigned int i = 1; i <= m_PXDModules.size(); i++) {
230  VxdID& aPXDModule = m_PXDModules[i - 1];
231 
232  TString buff = (std::string)aPXDModule;
233  buff.ReplaceAll(".", "_");
234 
235  TH1* Hits, *Matches;
236  TString locationHits = "track_hits_" + buff;
237  if (m_histogramDirectoryName != "") {
238  locationHits = m_histogramDirectoryName + "/" + locationHits;
239  }
240  Hits = (TH1*)findHist(locationHits.Data());
241  TString locationMatches = "matched_cluster_" + buff;
242  if (m_histogramDirectoryName != "") {
243  locationMatches = m_histogramDirectoryName + "/" + locationMatches;
244  }
245  Matches = (TH1*)findHist(locationMatches.Data());
246 
247  //Finding only one of them should only happen in very strange situations...
248  if (Hits == nullptr || Matches == nullptr) {
249  B2ERROR("Missing histogram for sensor " << aPXDModule);
250  mapHits[aPXDModule] = nullptr;
251  mapMatches[aPXDModule] = nullptr;
252  } else {
253  mapHits[aPXDModule] = Hits;
254  mapMatches[aPXDModule] = Matches;
255  if (m_singleHists) {
256  if (m_cEffModules[aPXDModule] && m_hEffModules[aPXDModule]) {// this check creates them with a nullptr ..bad
257  m_hEffModules[aPXDModule]->SetTotalHistogram(*Hits, "f");
258  m_hEffModules[aPXDModule]->SetPassedHistogram(*Matches, "f");
259 
260  m_cEffModules[aPXDModule]->cd();
261  m_hEffModules[aPXDModule]->Draw("colz");
262  m_cEffModules[aPXDModule]->Modified();
263  m_cEffModules[aPXDModule]->Update();
264  }
265  }
266  }
267  }//One-Module histos finished
268 
269  double stat_data = 0;
270  bool error_flag = false;
271  bool warn_flag = false;
272  double all = 0.0;
273 
274  double imatch = 0.0, ihit = 0.0;
275  int ieff = 0;
276 
277  std::map <VxdID, bool> updated{}; // init to false
278  for (unsigned int i = 0; i < m_PXDModules.size(); i++) {
279  VxdID& aModule = m_PXDModules[i];
280  int j = i + 1;
281 
282  if (mapHits[aModule] == nullptr || mapMatches[aModule] == nullptr) {
283  m_hEffAll->SetPassedEvents(j, 0); // order, otherwise it might happen that SetTotalEvents is NOT filling the value!
284  m_hEffAll->SetTotalEvents(j, 0);
285  } else {
286  double nmatch = mapMatches[aModule]->Integral(); // GetEntries()?
287  double nhit = mapHits[aModule]->Integral();
288  if (nmatch > 10 && nhit > 10) { // could be zero, too
289  imatch += nmatch;
290  ihit += nhit;
291  ieff++; // only count in modules working
292  double var_e = nmatch / nhit; // can never be zero
293  if (j == 6) continue; // workaround for 1.3.2 module
294  m_monObj->setVariable(Form("efficiency_%d_%d_%d", aModule.getLayerNumber(), aModule.getLadderNumber(), aModule.getSensorNumber()),
295  var_e);
296  }
297 
299  all += ihit;
300  m_hEffAll->SetPassedEvents(j, 0); // otherwise it might happen that SetTotalEvents is NOT filling the value!
301  m_hEffAll->SetTotalEvents(j, nhit);
302  m_hEffAll->SetPassedEvents(j, nmatch);
303 
304  if (nhit < m_minEntries) {
305  // update the first entries directly (short runs)
306  m_hEffAllUpdate->SetPassedEvents(j, 0); // otherwise it might happen that SetTotalEvents is NOT filling the value!
307  m_hEffAllUpdate->SetTotalEvents(j, nhit);
308  m_hEffAllUpdate->SetPassedEvents(j, nmatch);
309  m_hEffAllLastTotal->SetBinContent(j, nhit);
310  m_hEffAllLastPassed->SetBinContent(j, nmatch);
311  updated[aModule] = true;
312  } else if (nhit - m_hEffAllLastTotal->GetBinContent(j) > m_minEntries) {
313  m_hEffAllUpdate->SetPassedEvents(j, 0); // otherwise it might happen that SetTotalEvents is NOT filling the value!
314  m_hEffAllUpdate->SetTotalEvents(j, nhit - m_hEffAllLastTotal->GetBinContent(j));
315  m_hEffAllUpdate->SetPassedEvents(j, nmatch - m_hEffAllLastPassed->GetBinContent(j));
316  m_hEffAllLastTotal->SetBinContent(j, nhit);
317  m_hEffAllLastPassed->SetBinContent(j, nmatch);
318  updated[aModule] = true;
319  }
320 
321  if (j == 6) continue; // workaround for 1.3.2 module
322 
323  // get the errors and check for limits for each bin seperately ...
325 
326  error_flag |= (ihit > 10)
327  && (m_hEffAll->GetEfficiency(j) + m_hEffAll->GetEfficiencyErrorUp(j) < m_errorlevel); // error if upper error value is below limit
328  warn_flag |= (ihit > 10)
329  && (m_hEffAll->GetEfficiency(j) + m_hEffAll->GetEfficiencyErrorUp(j) < m_warnlevel); // (and not only the actual eff value)
330  }
331  }
332 
333  {
334  m_cEffAll->cd();
335  m_cEffAll->cd(0);
336  m_hEffAll->Paint("AP");
337  m_cEffAll->Clear();
338  m_cEffAll->cd(0);
339 
340  auto gr = m_hEffAll->GetPaintedGraph();
341  if (gr) {
342  double scale_min = 1.0;
343  for (int i = 0; i < gr->GetN(); i++) {
344  gr->SetPointEXhigh(i, 0.);
345  gr->SetPointEXlow(i, 0.);
346  // this has to be done first, as it will recalc Min/Max and destroy axis
347  Double_t x, y;
348  gr->GetPoint(i, x, y);
349  gr->SetPoint(i, x - 0.01, y); // workaround for jsroot bug (fixed upstream)
350  auto val = y - gr->GetErrorYlow(i); // Error is relative to value
351  if (i != 5) { // exclude 1.3.2
353  if (scale_min > val) scale_min = val;
354  }
355  }
356  if (scale_min == 1.0) scale_min = 0.0;
357  if (scale_min > 0.9) scale_min = 0.9;
358  gr->SetMinimum(0);
359  gr->SetMaximum(m_PXDModules.size());
360  auto ay = gr->GetYaxis();
361  if (ay) ay->SetRangeUser(scale_min, 1.0);
362  auto ax = gr->GetXaxis();
363  if (ax) {
364  ax->Set(m_PXDModules.size(), 0, m_PXDModules.size());
365  for (unsigned int i = 0; i < m_PXDModules.size(); i++) {
366  TString ModuleName = (std::string)m_PXDModules[i];
367  ax->SetBinLabel(i + 1, ModuleName);
368  }
369  }
370 
371  gr->SetLineColor(4);
372  gr->SetLineWidth(2);
373  gr->SetMarkerStyle(8);
374 
375  gr->Draw("AP");
376 
377  auto tt = new TLatex(5.5, scale_min, " 1.3.2 Module is excluded, please ignore");
378  tt->SetTextAngle(90);// Rotated
379  tt->SetTextAlign(12);// Centered
380  tt->Draw();
381 
382  if (all < 100.) {
383  m_cEffAll->Pad()->SetFillColor(kGray);// Magenta or Gray
384  } else {
385  if (error_flag) {
386  m_cEffAll->Pad()->SetFillColor(kRed);// Red
387  } else if (warn_flag) {
388  m_cEffAll->Pad()->SetFillColor(kYellow);// Yellow
389  } else {
390  m_cEffAll->Pad()->SetFillColor(kGreen);// Green
391  // m_cEffAll->Pad()->SetFillColor(kWhite);// White
392  }
393  }
394 
395  m_cEffAll->Pad()->SetFrameFillColor(kWhite - 1); // White
396  m_cEffAll->Pad()->SetFrameFillStyle(1001);// White
397  m_cEffAll->Pad()->Modified();
398  m_cEffAll->Pad()->Update();
399  m_line_warn->Draw();
400  m_line_error->Draw();
401  }
402 
403  m_cEffAll->Modified();
404  m_cEffAll->Update();
405  }
406 
407  {
408  m_cEffAllUpdate->cd();
409  m_hEffAllUpdate->Paint("AP");
410  m_cEffAllUpdate->Clear();
411  m_cEffAllUpdate->cd(0);
412 
413  auto gr = m_hEffAllUpdate->GetPaintedGraph();
414  auto gr3 = (TGraphAsymmErrors*) m_hEffAll->GetPaintedGraph()->Clone();
415  if (gr3) {
416  for (int i = 0; i < gr3->GetN(); i++) {
417  Double_t x, y;
418  gr3->GetPoint(i, x, y);
419  gr3->SetPoint(i, x + 0.2, y);
420  }
421  }
422 
423  double scale_min = 1.0;
424  if (gr) {
425  for (int i = 0; i < gr->GetN(); i++) {
426  gr->SetPointEXhigh(i, 0.);
427  gr->SetPointEXlow(i, 0.);
428  // this has to be done first, as it will recalc Min/Max and destroy axis
429  Double_t x, y;
430  gr->GetPoint(i, x, y);
431  gr->SetPoint(i, x - 0.2, y); // shift a bit if in same plot
432  auto val = y - gr->GetErrorYlow(i); // Error is relative to value
433  if (i != 5) { // exclude 1.3.2
435  if (scale_min > val) scale_min = val;
436  }
437  }
438  if (scale_min == 1.0) scale_min = 0.0;
439  if (scale_min > 0.9) scale_min = 0.9;
440  gr->SetMinimum(0);
441  gr->SetMaximum(m_PXDModules.size());
442  auto ay = gr->GetYaxis();
443  if (ay) ay->SetRangeUser(scale_min, 1.0);
444  auto ax = gr->GetXaxis();
445  if (ax) {
446  ax->Set(m_PXDModules.size() , 0, m_PXDModules.size());
447  for (unsigned int i = 0; i < m_PXDModules.size(); i++) {
448  TString ModuleName = (std::string)m_PXDModules[i];
449  ax->SetBinLabel(i + 1, ModuleName);
450  }
451  }
452 #ifdef _BELLE2_EPICS
453  if (m_useEpics) {
454  for (unsigned int i = 0; i < m_PXDModules.size(); i++) {
455  if (updated[m_PXDModules[i]]) {
456  Double_t x, y;// we assume that double and Double_t are same!
457  gr->GetPoint(i, x, y);
458  auto& my = mychid_eff[m_PXDModules[i]];// as the same array as above, we assume it exists
459  // we should only write if it was updated!
460  SEVCHK(ca_put(DBR_DOUBLE, my, (void*)&y), "ca_set failure");
461  }
462  }
463  }
464 #endif
465  gr->SetLineColor(kBlack);
466  gr->SetLineWidth(3);
467  gr->SetMarkerStyle(33);
468  } else scale_min = 0.0;
469  if (gr) gr->Draw("AP");
470  if (gr3) gr3->Draw("P");
471  auto tt = new TLatex(5.5, scale_min, "1.3.2 Module is excluded, please ignore");
472  tt->SetTextSize(0.035);
473  tt->SetTextAngle(90);// Rotated
474  tt->SetTextAlign(12);// Centered
475  tt->Draw();
476 
477  if (all < 100.) {
478  m_cEffAllUpdate->Pad()->SetFillColor(kGray);// Magenta or Gray
479  stat_data = 0.;
480  } else {
481  if (error_flag) {
482  m_cEffAllUpdate->Pad()->SetFillColor(kRed);// Red
483  stat_data = 4.;
484  } else if (warn_flag) {
485  m_cEffAllUpdate->Pad()->SetFillColor(kYellow);// Yellow
486  stat_data = 3.;
487  } else {
488  m_cEffAllUpdate->Pad()->SetFillColor(kGreen);// Green
489  stat_data = 2.;
491  // m_cEffAllUpdate->Pad()->SetFillColor(kWhite);// White
492  }
493  }
494  m_cEffAllUpdate->Pad()->SetFrameFillColor(kWhite - 1); // White
495  m_cEffAllUpdate->Pad()->SetFrameFillStyle(1001);// White
496  m_cEffAllUpdate->Pad()->Modified();
497  m_cEffAllUpdate->Pad()->Update();
498  m_line_warn->Draw();
499  m_line_error->Draw();
500  }
501  m_cEffAllUpdate->Modified();
502  m_cEffAllUpdate->Update();
503 
504 
505  double var_efficiency = ihit > 0 ? imatch / ihit : 0.0;
506  m_monObj->setVariable("efficiency", var_efficiency);
507  m_monObj->setVariable("nmodules", ieff);
508 
509 #ifdef _BELLE2_EPICS
510  if (m_useEpics) {
511  SEVCHK(ca_put(DBR_DOUBLE, mychid_status[0], (void*)&stat_data), "ca_set failure");
512  // only update if statistics is reasonable, we dont want "0" drops between runs!
513  if (stat_data != 0) SEVCHK(ca_put(DBR_DOUBLE, mychid_status[1], (void*)&var_efficiency), "ca_set failure");
514  SEVCHK(ca_pend_io(5.0), "ca_pend_io failure");
515  }
516 #endif
517 }
518 
519 void DQMHistAnalysisPXDEffModule::terminate()
520 {
521  B2DEBUG(1, "DQMHistAnalysisPXDEff: terminate called");
522 #ifdef _BELLE2_EPICS
523  if (m_useEpics) {
524  for (auto& m : mychid_status) SEVCHK(ca_clear_channel(m), "ca_clear_channel failure");
525  for (auto& m : mychid_eff) SEVCHK(ca_clear_channel(m.second), "ca_clear_channel failure");
526  SEVCHK(ca_pend_io(5.0), "ca_pend_io failure");
527  }
528 #endif
529 }
530 
Belle2::VXD::SensorInfoBase::getUCells
int getUCells() const
Return number of pixel/strips in u direction.
Definition: SensorInfoBase.h:223
Belle2::VxdID
Class to uniquely identify a any structure of the PXD and SVD.
Definition: VxdID.h:43
REG_MODULE
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition: Module.h:652
Belle2::VxdID::getLadderNumber
baseType getLadderNumber() const
Get the ladder id.
Definition: VxdID.h:108
Belle2::VXD::SensorInfoBase
Base class to provide Sensor Information for PXD and SVD.
Definition: SensorInfoBase.h:40
Belle2::VXD::GeoCache::getListOfSensors
const std::vector< VxdID > getListOfSensors() const
Get list of all sensors.
Definition: GeoCache.cc:60
Belle2::DQMHistAnalysisPXDEffModule
DQM Histogram Analysis for PXD Efficiency.
Definition: DQMHistAnalysisPXDEff.h:29
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::VXD::SensorInfoBase::getVCells
int getVCells() const
Return number of pixel/strips in v direction.
Definition: SensorInfoBase.h:225
Belle2::VxdID::getSensorNumber
baseType getSensorNumber() const
Get the sensor id.
Definition: VxdID.h:110
Belle2::VXD::GeoCache
Class to faciliate easy access to sensor information of the VXD like coordinate transformations or pi...
Definition: GeoCache.h:41
Belle2::VXD::GeoCache::getSensorInfo
const SensorInfoBase & getSensorInfo(Belle2::VxdID id) const
Return a referecne to the SensorInfo of a given SensorID.
Definition: GeoCache.cc:68
Belle2::VxdID::getLayerNumber
baseType getLayerNumber() const
Get the layer id.
Definition: VxdID.h:106
Belle2::DQMHistAnalysisModule
The base class for the histogram analysis module.
Definition: DQMHistAnalysis.h:27