Belle II Software development
DQMHistAnalysisSVDOnMiraBelle.cc
1/**************************************************************************
2 * basf2 (Belle II Analysis Software Framework) *
3 * Author: The Belle II Collaboration *
4 * *
5 * See git log for contributors and copyright holders. *
6 * This file is licensed under LGPL-3.0, see LICENSE.md. *
7 **************************************************************************/
8
9#include <numeric>
10#include <limits>
11#include <vxd/geometry/GeoCache.h>
12#include <vxd/dataobjects/VxdID.h>
13#include <svd/geometry/SensorInfo.h>
14#include <vxd/geometry/SensorInfoBase.h>
15#include <vxd/geometry/GeoTools.h>
16#include <framework/datastore/StoreObjPtr.h>
17#include <framework/datastore/StoreArray.h>
18
19
20#include <dqm/analysis/modules/DQMHistAnalysisSVDOnMiraBelle.h>
21
22using namespace std;
23using namespace Belle2;
24
25//-----------------------------------------------------------------
26// Register the Module
27//-----------------------------------------------------------------
28REG_MODULE(DQMHistAnalysisSVDOnMiraBelle);
29
30//-----------------------------------------------------------------
31// Implementation
32//-----------------------------------------------------------------
33
34DQMHistAnalysisSVDOnMiraBelleModule::DQMHistAnalysisSVDOnMiraBelleModule()
35 : DQMHistAnalysisModule()
36{
37 setDescription("DQM Analysis Module that extracts monitoring variables from SVD DQM histograms and provides input to MiraBelle.");
38 setPropertyFlags(c_ParallelProcessingCertified);
39 B2DEBUG(20, "DQMHistAnalysisSVDOnMiraBelle: Constructor done.");
40}
41
42DQMHistAnalysisSVDOnMiraBelleModule::~DQMHistAnalysisSVDOnMiraBelleModule() { }
43
44void DQMHistAnalysisSVDOnMiraBelleModule::initialize()
45{
46 gROOT->cd();
47
48 m_gTools = VXD::GeoCache::getInstance().getGeoTools();
49
50 // add MonitoringObject
51 m_monObj = getMonitoringObject("svd");
52
53 // list of canvases to be added to MonitoringObject
54 m_c_avgEfficiency = new TCanvas("svd_avgEfficiency", "matched clusters and found tracks", 0, 0, 800, 600);
55 m_c_avgOffOccupancy = new TCanvas("svd_avgOffOccupancy", "strips", 0, 0, 800, 600);
56 m_c_MPVChargeClusterOnTrack = new TCanvas("svd_MPVChargeClusterOnTrack", "charge from Clusters on Track Charge", 0, 0, 400, 400);
57 m_c_MPVSNRClusterOnTrack = new TCanvas("svd_MPVSNRClusterOnTrack", "SNR from Clusters on Track Charge", 0, 0, 400, 400);
58 m_c_MPVTimeClusterOnTrack = new TCanvas("svd_MPVTimeClusterOnTrack", "time from Clusters on Track Charge", 0, 0, 400, 400);
59 m_c_avgMaxBinClusterOnTrack = new TCanvas("svd_avgMaxBin", "average MaxBin", 0, 0, 800, 600);
60 m_c_MeanSVDEventT0 = new TCanvas("svd_MeanSVDEventT0", "Mean Event T0 from SVD for all samples", 0, 0, 400, 400);
61
62 // add canvases used to create monitoring variables to MonitoringObject
63 m_monObj->addCanvas(m_c_avgEfficiency);
64 m_monObj->addCanvas(m_c_avgOffOccupancy);
65 m_monObj->addCanvas(m_c_MPVChargeClusterOnTrack);
66 m_monObj->addCanvas(m_c_MPVSNRClusterOnTrack);
67 m_monObj->addCanvas(m_c_MPVTimeClusterOnTrack);
68 m_monObj->addCanvas(m_c_avgMaxBinClusterOnTrack);
69 m_monObj->addCanvas(m_c_MeanSVDEventT0);
70
71 const VXD::GeoCache& geo = VXD::GeoCache::getInstance();
72
73 //collect the list of all SVD Modules in the geometry here
74 std::vector<VxdID> sensors = geo.getListOfSensors();
75 for (VxdID& aVxdID : sensors) {
76 VXD::SensorInfoBase info = geo.getSensorInfo(aVxdID);
77 // B2INFO("VXD " << aVxdID);
78 if (info.getType() != VXD::SensorInfoBase::SVD) continue;
79 m_SVDModules.push_back(aVxdID); // reorder, sort would be better
80 }
81 std::sort(m_SVDModules.begin(), m_SVDModules.end()); // back to natural order
82
83 if (!m_svdPlotsConfig.isValid())
84 B2FATAL("no valid configuration found for SVD reconstruction");
85 else {
86 B2DEBUG(20, "SVDRecoConfiguration: from now on we are using " << m_svdPlotsConfig->get_uniqueID());
87 //read back from payload
88 m_listOfSensorsToMonitor = m_svdPlotsConfig->getListOfSensors();
89 }
90
91 B2DEBUG(20, "DQMHistAnalysisSVDOnMiraBelle: initialized.");
92}
93
94void DQMHistAnalysisSVDOnMiraBelleModule::beginRun()
95{
96 B2DEBUG(20, "DQMHistAnalysisSVDOnMiraBelle: beginRun called.");
97}
98
99void DQMHistAnalysisSVDOnMiraBelleModule::event()
100{
101 B2DEBUG(20, "DQMHistAnalysisSVDOnMiraBelle: event called.");
102}
103
104void DQMHistAnalysisSVDOnMiraBelleModule::endRun()
105{
106 float nan = numeric_limits<float>::quiet_NaN();
107
108 // ladder label
109 std::vector<string> ladderLabel = {"L3.X.1", "L3.X.2", "L4.X.1", "L4.X.2", "L4.X.3", "L5.X.1", "L5.X.2", "L5.X.3", "L5.X.4",
110 "L6.X.1", "L6.X.2", "L6.X.3", "L6.X.4", "L6.X.5"
111 };
112
113 // sensors to monitored from GT
114 // "3.1.1", "3.1.2", "3.2.1", "3.2.2", "4.1.1", "4.3.3", "4.6.1", "4.6.2", "4.9.2", "4.10.2", "5.1.3", "5.1.4", "5.8.1",
115 // "5.8.2", "5.9.2", "5.9.4", "6.4.3", "6.6.4", "6.10.1", "6.10.2", "6.10.3", "6.11.5", "6.12.4"
116
117
118 // offline occupancy - integrated number of ZS5 fired strips
119 TH1F* h_zs5countsU = (TH1F*)findHist("SVDExpReco/SVDDQM_StripCountsU"); // made by SVDDQMExperssRecoModule
120 TH1F* h_zs5countsV = (TH1F*)findHist("SVDExpReco/SVDDQM_StripCountsV");
121 TH1F* h_events = (TH1F*)findHist("SVDExpReco/SVDDQM_nEvents");
122
123 // adding histograms to canvas
124 m_c_avgOffOccupancy->Clear();
125 m_c_avgOffOccupancy->Divide(2, 2);
126 m_c_avgOffOccupancy->cd(1);
127 if (h_zs5countsU) h_zs5countsU->Draw("colz");
128 m_c_avgOffOccupancy->cd(2);
129 if (h_zs5countsV) h_zs5countsV->Draw("colz");
130 m_c_avgOffOccupancy->cd(3);
131 if (h_events) h_events->Draw("colz");
132
133 int nE = 0;
134 if (h_events) nE = h_events->GetEntries(); // number of events for all "clusters on track" histograms
135
136 // setting monitoring variables
137 if (h_zs5countsU == NULL || h_zs5countsV == NULL || h_events == NULL) {
138 if (h_zs5countsU == NULL) {
139 B2INFO("Histograms needed for Average Offline Occupancy on U side are not found");
140 }
141 if (h_zs5countsV == NULL) {
142 B2INFO("Histograms needed for Average Offline Occupancy on V side are not found");
143 }
144 } else {
145 // average occupancy for each layer
146 std::pair<float, float> avgOffOccL3UV = avgOccupancyUV(h_zs5countsU, h_zs5countsV, nE, 3);
147 SetVariable(avgOffOccL3UV);
148
149 std::pair<float, float> avgOffOccL4UV = avgOccupancyUV(h_zs5countsU, h_zs5countsV, nE, 4);
150 SetVariable(avgOffOccL4UV);
151
152 std::pair<float, float> avgOffOccL5UV = avgOccupancyUV(h_zs5countsU, h_zs5countsV, nE, 5);
153 SetVariable(avgOffOccL5UV);
154
155 std::pair<float, float> avgOffOccL6UV = avgOccupancyUV(h_zs5countsU, h_zs5countsV, nE, 6);
156 SetVariable(avgOffOccL6UV);
157
158 // average occupancy for each layer for group Id0
159 std::pair<float, float> avgOffGrpId0OccL3UV = avgOccupancyGrpId0UV(3, nE);
160 SetVariable(avgOffGrpId0OccL3UV);
161
162 std::pair<float, float> avgOffGrpId0OccL4UV = avgOccupancyGrpId0UV(4, nE);
163 SetVariable(avgOffGrpId0OccL4UV);
164
165 std::pair<float, float> avgOffGrpId0OccL5UV = avgOccupancyGrpId0UV(5, nE);
166 SetVariable(avgOffGrpId0OccL5UV);
167
168 std::pair<float, float> avgOffGrpId0OccL6UV = avgOccupancyGrpId0UV(6, nE);
169 SetVariable(avgOffGrpId0OccL6UV);
170
171 // occupancy averaged over ladders
172 for (const auto& it : ladderLabel) {
173 string sensorDescr = it;
174 int layer = 0;
175 int sensor = 0;
176 sscanf(it.c_str(), "L%d.X.%d", &layer, &sensor);
177 std::pair<float, float> avgOffOccL = avgOccupancyUV(h_zs5countsU, h_zs5countsV, nE, layer, -1, sensor);
178 addVariable(Form("avgOffOccL%dX%dUV", layer, sensor), avgOffOccL);
179 }
180
181 // average occupancy for high occupancy sensors
182 for (const auto& it : m_listOfSensorsToMonitor) {
183 string sensorDescr = it;
184 int layer = 0;
185 int ladder = 0;
186 int sensor = 0;
187 sscanf(it.c_str(), "%d.%d.%d", &layer, &ladder, &sensor);
188 std::pair<float, float> avgOffOccL = avgOccupancyUV(h_zs5countsU, h_zs5countsV, nE, layer, ladder, sensor);
189 addVariable(Form("avgOffOccL%d%d%dUV", layer, ladder, sensor), avgOffOccL);
190 }
191 }
192
193
194 // efficiency of cluster reconstruction for U and V side
195 TH2F* h_found_tracksU = (TH2F*)findHist("SVDEfficiency/TrackHitsU");
196 TH2F* h_matched_clusU = (TH2F*)findHist("SVDEfficiency/MatchedHitsU");
197 TH2F* h_found_tracksV = (TH2F*)findHist("SVDEfficiency/TrackHitsV");
198 TH2F* h_matched_clusV = (TH2F*)findHist("SVDEfficiency/MatchedHitsV");
199
200 m_c_avgEfficiency->Clear();
201 m_c_avgEfficiency->Divide(2, 2);
202 m_c_avgEfficiency->cd(1);
203 if (h_found_tracksU) h_found_tracksU->Draw("colz");
204 m_c_avgEfficiency->cd(2);
205 if (h_found_tracksV) h_found_tracksV->Draw("colz");
206 m_c_avgEfficiency->cd(3);
207 if (h_matched_clusU) h_matched_clusU->Draw("colz");
208 m_c_avgEfficiency->cd(4);
209 if (h_matched_clusV) h_matched_clusV->Draw("colz");
210
211 // setting monitoring variables
212 if (h_matched_clusU == NULL || h_matched_clusV == NULL || h_found_tracksU == NULL) {
213 if (h_matched_clusU == NULL) {
214 B2INFO("Histograms needed for Average Efficiency on U side are not found");
215 }
216 if (h_matched_clusV == NULL) {
217 B2INFO("Histograms needed for Average Efficiency on V side are not found");
218 }
219 } else {
220 // average efficiency in each layer for both side (U, V)
221 std::pair<float, float> avgEffL3 = avgEfficiencyUV(h_matched_clusU, h_matched_clusV, h_found_tracksU, h_found_tracksV, 3);
222 SetVariable(avgEffL3);
223
224 std::pair<float, float> avgEffL4 = avgEfficiencyUV(h_matched_clusU, h_matched_clusV, h_found_tracksU, h_found_tracksV, 4);
225 SetVariable(avgEffL4);
226
227 std::pair<float, float> avgEffL5 = avgEfficiencyUV(h_matched_clusU, h_matched_clusV, h_found_tracksU, h_found_tracksV, 5);
228 SetVariable(avgEffL5);
229
230 std::pair<float, float> avgEffL6 = avgEfficiencyUV(h_matched_clusU, h_matched_clusV, h_found_tracksU, h_found_tracksV, 6);
231 SetVariable(avgEffL6);
232
233 // average efficiency for all layers
234 std::pair<float, float> avgEffL3456 = avgEfficiencyUV(h_matched_clusU, h_matched_clusV, h_found_tracksU, h_found_tracksV);
235 SetVariable(avgEffL3456);
236
237 // efficiency averaged over ladders
238 for (const auto& it : ladderLabel) {
239 string sensorDescr = it;
240 int layer = 0;
241 int sensor = 0;
242 sscanf(it.c_str(), "L%d.X.%d", &layer, &sensor);
243 std::pair<float, float> avgEffL = avgEfficiencyUV(h_matched_clusU, h_matched_clusV, h_found_tracksU, h_found_tracksV, layer, -1,
244 sensor);
245 addVariable(Form("avgEffL%dX%dUV", layer, sensor), avgEffL);
246 }
247
248 // average efficiency for high occupancy sensors and
249 // average efficiency for low DCDC
250 for (const auto& it : m_listOfSensorsToMonitor) {
251 string sensorDescr = it;
252 int layer = 0;
253 int ladder = 0;
254 int sensor = 0;
255 sscanf(it.c_str(), "%d.%d.%d", &layer, &ladder, &sensor);
256 std::pair<float, float> avgEffL = avgEfficiencyUV(h_matched_clusU, h_matched_clusV, h_found_tracksU, h_found_tracksV, layer, ladder,
257 sensor);
258 addVariable(Form("avgEffL%d%d%dUV", layer, ladder, sensor), avgEffL);
259 }
260 }
261
262 // MPV cluster charge for clusters on track
263 TH1F* h_clusterCharge_L3U = (TH1F*)findHist("SVDClsTrk/SVDTRK_ClusterChargeU3");
264 TH1F* h_clusterCharge_L3V = (TH1F*)findHist("SVDClsTrk/SVDTRK_ClusterChargeV3");
265 TH1F* h_clusterCharge_L456U = (TH1F*)findHist("SVDClsTrk/SVDTRK_ClusterChargeU456");
266 TH1F* h_clusterCharge_L456V = (TH1F*)findHist("SVDClsTrk/SVDTRK_ClusterChargeV456");
267
268 m_c_MPVChargeClusterOnTrack->Clear();
269 m_c_MPVChargeClusterOnTrack->Divide(2, 2);
270 m_c_MPVChargeClusterOnTrack->cd(1);
271 if (h_clusterCharge_L3U) h_clusterCharge_L3U->Draw();
272 m_c_MPVChargeClusterOnTrack->cd(2);
273 if (h_clusterCharge_L3V) h_clusterCharge_L3V->Draw();
274 m_c_MPVChargeClusterOnTrack->cd(3);
275 if (h_clusterCharge_L456U) h_clusterCharge_L456U->Draw();
276 m_c_MPVChargeClusterOnTrack->cd(4);
277 if (h_clusterCharge_L456U) h_clusterCharge_L456U->Draw();
278
279 // find abscissa of max Y in histograms
280 float MPVClusterChargeL3U = nan;
281 if (h_clusterCharge_L3U)
282 if (h_clusterCharge_L3U->GetEntries() != 0)
283 MPVClusterChargeL3U = xForMaxY(h_clusterCharge_L3U);
284 float MPVClusterChargeL3V = nan;
285 if (h_clusterCharge_L3V)
286 if (h_clusterCharge_L3V->GetEntries() != 0)
287 MPVClusterChargeL3V = xForMaxY(h_clusterCharge_L3V);
288 float MPVClusterChargeL456U = nan;
289 if (h_clusterCharge_L456U)
290 if (h_clusterCharge_L456U->GetEntries() != 0)
291 MPVClusterChargeL456U = xForMaxY(h_clusterCharge_L456U);
292 float MPVClusterChargeL456V = nan;
293 if (h_clusterCharge_L456V)
294 if (h_clusterCharge_L456V->GetEntries() != 0)
295 MPVClusterChargeL456V = xForMaxY(h_clusterCharge_L456V);
296
297 if (h_clusterCharge_L3U == NULL || h_clusterCharge_L456U == NULL) {
298 B2INFO("Histograms needed for MPV cluster charge on U side are not found");
299 } else {
300 m_monObj->setVariable("MPVClusterChargeL3U", MPVClusterChargeL3U);
301 m_monObj->setVariable("MPVClusterChargeL456U", MPVClusterChargeL456U);
302 }
303
304 if (h_clusterCharge_L3V == NULL || h_clusterCharge_L456V == NULL) {
305 B2INFO("Histograms needed for MPV cluster charge on V side are not found");
306 } else {
307 m_monObj->setVariable("MPVClusterChargeL3V", MPVClusterChargeL3V);
308 m_monObj->setVariable("MPVClusterChargeL456V", MPVClusterChargeL456V);
309 }
310
311
312 // MPV SNR for the clusters on track
313 TH1F* h_clusterSNR_L3U = (TH1F*)findHist("SVDClsTrk/SVDTRK_ClusterSNRU3");
314 TH1F* h_clusterSNR_L3V = (TH1F*)findHist("SVDClsTrk/SVDTRK_ClusterSNRV3");
315 TH1F* h_clusterSNR_L456U = (TH1F*)findHist("SVDClsTrk/SVDTRK_ClusterSNRU456");
316 TH1F* h_clusterSNR_L456V = (TH1F*)findHist("SVDClsTrk/SVDTRK_ClusterSNRV456");
317
318 m_c_MPVSNRClusterOnTrack->Clear();
319 m_c_MPVSNRClusterOnTrack->Divide(2, 2);
320 m_c_MPVSNRClusterOnTrack->cd(1);
321 if (h_clusterSNR_L3U) h_clusterSNR_L3U->Draw();
322 m_c_MPVSNRClusterOnTrack->cd(2);
323 if (h_clusterSNR_L3V) h_clusterSNR_L3V->Draw();
324 m_c_MPVSNRClusterOnTrack->cd(3);
325 if (h_clusterSNR_L456U) h_clusterSNR_L456U->Draw();
326 m_c_MPVSNRClusterOnTrack->cd(4);
327 if (h_clusterSNR_L456V) h_clusterSNR_L456V->Draw();
328
329 float MPVClusterSNRL3U = nan;
330 if (h_clusterSNR_L3U)
331 if (h_clusterSNR_L3U->GetEntries() != 0)
332 MPVClusterSNRL3U = xForMaxY(h_clusterSNR_L3U);
333 float MPVClusterSNRL3V = nan;
334 if (h_clusterSNR_L3V)
335 if (h_clusterSNR_L3V->GetEntries() != 0)
336 MPVClusterSNRL3V = xForMaxY(h_clusterSNR_L3V);
337 float MPVClusterSNRL456U = nan;
338 if (h_clusterSNR_L456U)
339 if (h_clusterSNR_L456U->GetEntries() != 0)
340 MPVClusterSNRL456U = xForMaxY(h_clusterSNR_L456U);
341 float MPVClusterSNRL456V = nan;
342 if (h_clusterSNR_L456V)
343 if (h_clusterSNR_L456V->GetEntries() != 0)
344 MPVClusterSNRL456V = xForMaxY(h_clusterSNR_L456V);
345
346 if (h_clusterSNR_L3U == NULL || h_clusterSNR_L456U == NULL) {
347 B2INFO("Histograms needed for MPV cluster SNR on U side are not found");
348 } else {
349 m_monObj->setVariable("MPVClusterSNRL3U", MPVClusterSNRL3U);
350 m_monObj->setVariable("MPVClusterSNRL456U", MPVClusterSNRL456U);
351 }
352
353 if (h_clusterSNR_L3V == NULL || h_clusterSNR_L456V == NULL) {
354 B2INFO("Histograms needed for MPV cluster SNR on V side are not found");
355 } else {
356 m_monObj->setVariable("MPVClusterSNRL3V", MPVClusterSNRL3V);
357 m_monObj->setVariable("MPVClusterSNRL456V", MPVClusterSNRL456V);
358 }
359
360
361 // MPV SVD cluster time for the clusters on track
362 TH1F* h_clusterTime_L3U = (TH1F*)findHist("SVDClsTrk/SVDTRK_ClusterTimeU3");
363 TH1F* h_clusterTime_L3V = (TH1F*)findHist("SVDClsTrk/SVDTRK_ClusterTimeV3");
364 TH1F* h_clusterTime_L456U = (TH1F*)findHist("SVDClsTrk/SVDTRK_ClusterTimeU456");
365 TH1F* h_clusterTime_L456V = (TH1F*)findHist("SVDClsTrk/SVDTRK_ClusterTimeV456");
366 TH1F* h_MeanSVD3EventT0 = (TH1F*)findHist("SVDHitTime/SVD3EventT0");
367 TH1F* h_MeanSVD6EventT0 = (TH1F*)findHist("SVDHitTime/SVD6EventT0");
368 TH1F* h_MeanSVDEventT0 = 0x0;
369
370 if (h_MeanSVD3EventT0)
371 h_MeanSVDEventT0 = (TH1F*)h_MeanSVD3EventT0->Clone();
372
373 m_c_MPVTimeClusterOnTrack->Clear();
374 m_c_MPVTimeClusterOnTrack->Divide(2, 2);
375 m_c_MPVTimeClusterOnTrack->cd(1);
376 if (h_clusterTime_L3U) h_clusterTime_L3U->Draw();
377 m_c_MPVTimeClusterOnTrack->cd(2);
378 if (h_clusterTime_L3V) h_clusterTime_L3V->Draw();
379 m_c_MPVTimeClusterOnTrack->cd(3);
380 if (h_clusterTime_L456U) h_clusterTime_L456U->Draw();
381 m_c_MPVTimeClusterOnTrack->cd(4);
382 if (h_clusterTime_L456V) h_clusterTime_L456V->Draw();
383
384 m_c_MeanSVDEventT0->Clear();
385 m_c_MeanSVDEventT0->Divide(2, 2);
386 m_c_MeanSVDEventT0->cd(1);
387 if (h_MeanSVD3EventT0) h_MeanSVD3EventT0->Draw();
388 m_c_MeanSVDEventT0->cd(2);
389 if (h_MeanSVD6EventT0) h_MeanSVD6EventT0->Draw();
390 m_c_MeanSVDEventT0->cd(3);
391 if (h_MeanSVDEventT0) {
392 if (h_MeanSVD6EventT0)
393 h_MeanSVDEventT0->Add(h_MeanSVD6EventT0);
394 h_MeanSVDEventT0->Draw();
395 }
396
397 float MPVClusterTimeL3U = nan;
398 if (h_clusterTime_L3U)
399 if (h_clusterTime_L3U->GetEntries() != 0)
400 MPVClusterTimeL3U = xForMaxY(h_clusterTime_L3U);
401 float MPVClusterTimeL3V = nan;
402 if (h_clusterTime_L3V)
403 if (h_clusterTime_L3V->GetEntries() != 0)
404 MPVClusterTimeL3V = xForMaxY(h_clusterTime_L3V);
405 float MPVClusterTimeL456U = nan;
406 if (h_clusterTime_L456U)
407 if (h_clusterTime_L456U->GetEntries() != 0)
408 MPVClusterTimeL456U = xForMaxY(h_clusterTime_L456U);
409 float MPVClusterTimeL456V = nan;
410 if (h_clusterTime_L456V)
411 if (h_clusterTime_L456V->GetEntries() != 0)
412 MPVClusterTimeL456V = xForMaxY(h_clusterTime_L456V);
413 float FWHMClusterTimeL3U = nan;
414 if (h_clusterTime_L3U)
415 if (h_clusterTime_L3U->GetEntries() != 0)
416 FWHMClusterTimeL3U = histFWHM(h_clusterTime_L3U);
417 float FWHMClusterTimeL3V = nan;
418 if (h_clusterTime_L3V)
419 if (h_clusterTime_L3V->GetEntries() != 0)
420 FWHMClusterTimeL3V = histFWHM(h_clusterTime_L3V);
421 float FWHMClusterTimeL456U = nan;
422 if (h_clusterTime_L456U)
423 if (h_clusterTime_L456U->GetEntries() != 0)
424 FWHMClusterTimeL456U = histFWHM(h_clusterTime_L456U);
425 float FWHMClusterTimeL456V = nan;
426 if (h_clusterTime_L456V)
427 if (h_clusterTime_L456V->GetEntries() != 0)
428 FWHMClusterTimeL456V = histFWHM(h_clusterTime_L456V);
429
430 float MeanSVD3EventT0 = nan;
431 if (h_MeanSVD3EventT0)
432 if (h_MeanSVD3EventT0->GetEntries() != 0)
433 MeanSVD3EventT0 = xForMaxY(h_MeanSVD3EventT0);
434
435 float MeanSVD6EventT0 = nan;
436 if (h_MeanSVD6EventT0)
437 if (h_MeanSVD6EventT0->GetEntries() != 0)
438 MeanSVD6EventT0 = xForMaxY(h_MeanSVD6EventT0);
439
440 float MeanSVDEventT0 = nan;
441 if (h_MeanSVDEventT0)
442 if (h_MeanSVDEventT0->GetEntries() != 0)
443 MeanSVDEventT0 = xForMaxY(h_MeanSVDEventT0);
444
445 if (h_clusterTime_L3U == NULL || h_clusterTime_L456U == NULL) {
446 B2INFO("Histograms needed for MPV cluster time on U side are not found");
447 } else {
448 m_monObj->setVariable("MPVClusterTimeL3U", MPVClusterTimeL3U);
449 m_monObj->setVariable("MPVClusterTimeL456U", MPVClusterTimeL456U);
450 m_monObj->setVariable("FWHMClusterTimeL3U", FWHMClusterTimeL3U);
451 m_monObj->setVariable("FWHMClusterTimeL456U", FWHMClusterTimeL456U);
452 }
453
454 if (h_clusterTime_L3V == NULL || h_clusterTime_L456V == NULL) {
455 B2INFO("Histograms needed for MPV cluster time on V side are not found");
456 } else {
457 m_monObj->setVariable("MPVClusterTimeL3V", MPVClusterTimeL3V);
458 m_monObj->setVariable("MPVClusterTimeL456V", MPVClusterTimeL456V);
459 m_monObj->setVariable("FWHMClusterTimeL3V", FWHMClusterTimeL3V);
460 m_monObj->setVariable("FWHMClusterTimeL456V", FWHMClusterTimeL456V);
461 }
462
463 if (h_MeanSVD3EventT0 == NULL) {
464 B2INFO("Histograms needed for SVD Event T0 (3 samples) not found");
465 } else {
466 m_monObj->setVariable("MeanSVD3EventT0", MeanSVD3EventT0);
467 }
468
469 if (h_MeanSVD6EventT0 == NULL) {
470 B2INFO("Histograms needed for SVD Event T0 (6 samples) not found");
471 } else {
472 m_monObj->setVariable("MeanSVD6EventT0", MeanSVD6EventT0);
473 }
474
475 if (h_MeanSVDEventT0 == NULL) {
476 B2INFO("Histograms needed for SVD Event T0 (all samples) not found");
477 } else {
478 m_monObj->setVariable("MeanSVDEventT0", MeanSVDEventT0);
479 }
480
481 // average maxBin for clusters on track
482 TH1F* h_maxBinU = (TH1F*)findHist("SVDClsTrk/SVDTRK_StripMaxBinUAll");
483 TH1F* h_maxBinV = (TH1F*)findHist("SVDClsTrk/SVDTRK_StripMaxBinVAll");
484
485 m_c_avgMaxBinClusterOnTrack->Clear();
486 m_c_avgMaxBinClusterOnTrack->Divide(2, 1);
487 m_c_avgMaxBinClusterOnTrack->cd(1);
488 if (h_maxBinU) h_maxBinU->Draw();
489 m_c_avgMaxBinClusterOnTrack->cd(2);
490 if (h_maxBinV) h_maxBinV->Draw();
491
492 if (h_maxBinU == NULL) {
493 B2INFO("Histogram needed for Average MaxBin on U side is not found");
494 } else {
495 float avgMaxBinU = h_maxBinU->GetMean();
496 m_monObj->setVariable("avgMaxBinU", avgMaxBinU);
497 }
498
499 if (h_maxBinV == NULL) {
500 B2INFO("Histogram needed for Average MaxBin on V side is not found");
501 } else {
502 float avgMaxBinV = h_maxBinV->GetMean();
503 m_monObj->setVariable("avgMaxBinV", avgMaxBinV);
504 }
505
506 // Cluster on track ladder
507 for (const auto& it : ladderLabel) {
508 string sensorDescr = it;
509 int layer = 0;
510 int sensor = 0;
511 sscanf(it.c_str(), "L%d.X.%d", &layer, &sensor);
512
513 TString name = Form("SVDClsTrk/SVDTRK_ClusterCharge_L%d.x.%d", layer, sensor);
514 TString title = Form("MPVClusterCharge_L%d.x.%d", layer, sensor);
515 TH1F* h_clusterCharge = (TH1F*)findHist(name.Data());
516 float MPVClusterCharge = nan;
517 if (h_clusterCharge)
518 if (h_clusterCharge->GetEntries() != 0)
519 MPVClusterCharge = xForMaxY(h_clusterCharge);
520
521 if (h_clusterCharge == NULL) {
522 B2INFO("Histograms needed for cluster charge not found");
523 } else {
524 m_monObj->setVariable(title.Data(), MPVClusterCharge);
525 }
526
527 name = Form("SVDClsTrk/SVDTRK_ClusterSNR_L%d.x.%d", layer, sensor);
528 title = Form("MPVClusterSNR_L%d.x.%d", layer, sensor);
529 TH1F* h_clusterSNR = (TH1F*)findHist(name.Data());
530 float MPVClusterSNR = nan;
531 if (h_clusterSNR)
532 if (h_clusterSNR->GetEntries() != 0)
533 MPVClusterSNR = xForMaxY(h_clusterSNR);
534
535 if (h_clusterSNR == NULL) {
536 B2INFO("Histograms needed for cluster SNR not found");
537 } else {
538 m_monObj->setVariable(title.Data(), MPVClusterSNR);
539 }
540 }
541
542 // Cluster on track peculiar sensors
543 for (const auto& it : m_listOfSensorsToMonitor) {
544 string sensorDescr = it;
545 string valueLabel = it;
546 replace(sensorDescr.begin(), sensorDescr.end(), '.', '_');
547 valueLabel.erase(remove(valueLabel.begin(), valueLabel.end(), '.'), valueLabel.end());
548
549 TString name = Form("SVDClsTrk/SVDTRK_%s_ClusterChargeU", sensorDescr.c_str());
550 TString title = Form("MPVClusterChargeL%sU", valueLabel.c_str());
551 TString title1 = "";
552 TH1F* h_clusterCharge = (TH1F*)findHist(name.Data());
553 float MPVClusterCharge = nan;
554 if (h_clusterCharge)
555 if (h_clusterCharge->GetEntries() != 0)
556 MPVClusterCharge = xForMaxY(h_clusterCharge);
557
558 if (h_clusterCharge == NULL) {
559 B2INFO("Histograms needed for clusterU charge not found");
560 } else {
561 m_monObj->setVariable(title.Data(), MPVClusterCharge);
562 }
563
564 name = Form("SVDClsTrk/SVDTRK_%s_ClusterChargeV", sensorDescr.c_str());
565 title = Form("MPVClusterChargeL%sV", valueLabel.c_str());
566 h_clusterCharge = (TH1F*)findHist(name.Data());
567 MPVClusterCharge = nan;
568 if (h_clusterCharge)
569 if (h_clusterCharge->GetEntries() != 0)
570 MPVClusterCharge = xForMaxY(h_clusterCharge);
571
572 if (h_clusterCharge == NULL) {
573 B2INFO("Histograms needed for clusterV charge not found");
574 } else {
575 m_monObj->setVariable(title.Data(), MPVClusterCharge);
576 }
577
578 name = Form("SVDClsTrk/SVDTRK_%s_ClusterSNRU", sensorDescr.c_str());
579 title = Form("MPVClusterSNRL%sU", valueLabel.c_str());
580 TH1F* h_clusterSNR = (TH1F*)findHist(name.Data());
581 float MPVClusterSNR = nan;
582 if (h_clusterSNR)
583 if (h_clusterSNR->GetEntries() != 0)
584 MPVClusterSNR = xForMaxY(h_clusterSNR);
585
586 if (h_clusterSNR == NULL) {
587 B2INFO("Histograms needed for clusterU SNR not found");
588 } else {
589 m_monObj->setVariable(title.Data(), MPVClusterSNR);
590 }
591
592 name = Form("SVDClsTrk/SVDTRK_%s_ClusterSNRV", sensorDescr.c_str());
593 title = Form("MPVClusterSNRL%sV", valueLabel.c_str());
594 h_clusterSNR = (TH1F*)findHist(name.Data());
595 MPVClusterSNR = nan;
596 if (h_clusterSNR)
597 if (h_clusterSNR->GetEntries() != 0)
598 MPVClusterSNR = xForMaxY(h_clusterSNR);
599
600 if (h_clusterSNR == NULL) {
601 B2INFO("Histograms needed for clusterV SNR not found");
602 } else {
603 m_monObj->setVariable(title.Data(), MPVClusterSNR);
604 }
605
606 name = Form("SVDClsTrk/SVDTRK_%s_ClusterTimeU", sensorDescr.c_str());
607 title = Form("MPVClusterTimeL%sU", valueLabel.c_str());
608 title1 = Form("FWHMClusterTimeL%sU", valueLabel.c_str());
609 TH1F* h_clusterTime = (TH1F*)findHist(name.Data());
610 float MPVClusterTime = nan;
611 float FWHMClusterTime = nan;
612 if (h_clusterTime)
613 if (h_clusterTime->GetEntries() != 0) {
614 MPVClusterTime = xForMaxY(h_clusterTime);
615 FWHMClusterTime = histFWHM(h_clusterTime);
616 }
617
618 if (h_clusterTime == NULL) {
619 B2INFO("Histograms needed for clusterU time not found");
620 } else {
621 m_monObj->setVariable(title.Data(), MPVClusterTime);
622 m_monObj->setVariable(title1.Data(), FWHMClusterTime);
623 }
624
625 name = Form("SVDClsTrk/SVDTRK_%s_ClusterTimeV", sensorDescr.c_str());
626 title = Form("MPVClusterTimeL%sV", valueLabel.c_str());
627 title1 = Form("FWHMClusterTimeL%sV", valueLabel.c_str());
628 h_clusterTime = (TH1F*)findHist(name.Data());
629 MPVClusterTime = nan;
630 FWHMClusterTime = nan;
631 if (h_clusterTime)
632 if (h_clusterTime->GetEntries() != 0) {
633 MPVClusterTime = xForMaxY(h_clusterTime);
634 FWHMClusterTime = histFWHM(h_clusterTime);
635 }
636
637 if (h_clusterTime == NULL) {
638 B2INFO("Histograms needed for clusterU time not found");
639 } else {
640 m_monObj->setVariable(title.Data(), MPVClusterTime);
641 m_monObj->setVariable(title1.Data(), FWHMClusterTime);
642 }
643 }
644
645 B2INFO("DQMHistAnalysisSVDGeneral: endRun called");
646}
647
648
649void DQMHistAnalysisSVDOnMiraBelleModule::terminate()
650{
651 B2INFO("DQMHistAnalysisSVDOnMiraBelle: terminate called");
652}
653
654std::pair<float, float> DQMHistAnalysisSVDOnMiraBelleModule::avgOccupancyUV(TH1F* hU, TH1F* hV, int nEvents,
655 int layer, int ladder, int sensor) const
656{
657 int nStripsV = -1;
658 if (layer == 3) {
659 nStripsV = 768;
660 } else if (layer >= 4 && layer <= 6) {
661 nStripsV = 512;
662 } else {
663 B2DEBUG(20, "Layer out of range [3,6].");
664 }
665 std::pair<float, float> avgOffOccUV(0.0, 0.0);
666
667 int minLayer = (layer != -1) ? layer : m_gTools->getFirstSVDLayer();
668 int maxLayer = (layer != -1) ? layer : m_gTools->getLastSVDLayer();
669 int sensorsN = 0;
670
671 if (ladder == 0) ladder = -1;
672
673 for (int layerId = minLayer; layerId < maxLayer + 1; ++layerId) {
674 int minLadder = (ladder != -1) ? ladder : 1;
675 int maxLadder = (ladder != -1) ? ladder : getNumberOfLadders(layerId);
676
677 int minSensor = (sensor != -1) ? sensor : 1;
678 int maxSensor = (sensor != -1) ? sensor : getNumberOfSensors(layerId);
679
680 for (int sensorId = minSensor; sensorId < maxSensor + 1; ++sensorId) {
681
682 for (int ladderId = minLadder; ladderId < maxLadder + 1; ++ladderId) {
683 int bin = m_gTools->getSVDSensorIndex(layerId, ladderId, sensorId) + 1;
684
685 avgOffOccUV.first += hU->GetBinContent(bin) / 768 * 100;
686 avgOffOccUV.second += hV->GetBinContent(bin) / nStripsV * 100;
687 sensorsN++;
688 }
689 }
690 }
691
692 avgOffOccUV.first /= (sensorsN * nEvents);
693 avgOffOccUV.second /= (sensorsN * nEvents);
694
695 return avgOffOccUV;
696}
697
698std::pair<float, float> DQMHistAnalysisSVDOnMiraBelleModule::avgOccupancyGrpId0UV(int iLayer, int nEvents) const
699{
700 int nStripsV = -1;
701 if (iLayer == 3) {
702 nStripsV = 768;
703 } else if (iLayer >= 4 && iLayer <= 6) {
704 nStripsV = 512;
705 } else {
706 B2DEBUG(20, "Layer out of range [3,6].");
707 }
708
709 Int_t nStripsU = 768;
710
711 std::vector<float> avgOffOccU;
712 std::vector<float> avgOffOccV;
713
714 for (unsigned int i = 0; i < m_SVDModules.size(); i++) {
715 int tmp_layer = m_SVDModules[i].getLayerNumber();
716 int tmp_ladder = m_SVDModules[i].getLadderNumber();
717 int tmp_sensor = m_SVDModules[i].getSensorNumber();
718
719 TString tmpnameGrpId0U = Form("SVDExpReco/SVDDQM_%d_%d_%d_StripCountGroupId0U", tmp_layer, tmp_ladder, tmp_sensor);
720 TH1F* htmpU = (TH1F*)findHist(tmpnameGrpId0U.Data());
721 if (htmpU == NULL) {
722 B2INFO("Occupancy U histogram for group Id0 not found");
723 } else {
724 if (tmp_layer == iLayer)
725 avgOffOccU.push_back(htmpU->GetEntries() / nStripsU / nEvents * 100);
726 }
727
728 TString tmpnameGrpId0V = Form("SVDExpReco/SVDDQM_%d_%d_%d_StripCountGroupId0V", tmp_layer, tmp_ladder, tmp_sensor);
729 TH1F* htmpV = (TH1F*)findHist(tmpnameGrpId0V.Data());
730 if (htmpV == NULL) {
731 B2INFO("Occupancy V histogram for group Id0 not found");
732 } else {
733 if (tmp_layer == iLayer)
734 avgOffOccV.push_back(htmpV->GetEntries() / nStripsV / nEvents * 100);
735 }
736 }
737
738 std::pair<float, float> avgOffOccUV(0., 0.);
739
740 avgOffOccUV.first = accumulate(avgOffOccU.begin(), avgOffOccU.end(), 0.0);
741 avgOffOccUV.first /= float(avgOffOccU.size());
742
743 avgOffOccUV.second = accumulate(avgOffOccV.begin(), avgOffOccV.end(), 0.0);
744 avgOffOccUV.second /= float(avgOffOccV.size());
745
746 return avgOffOccUV;
747}
748
749std::pair<float, float> DQMHistAnalysisSVDOnMiraBelleModule::avgEfficiencyUV(TH2F* hMCU, TH2F* hMCV, TH2F* hFTU, TH2F* hFTV,
750 int layer,
751 int ladder, int sensor) const
752{
753 float nan = numeric_limits<float>::quiet_NaN();
754 std::pair<float, float> avgEffUV(0.0, 0.0);
755 std::pair<float, float> sumMatchedClustersUV(0.0, 0.0);
756 std::pair<float, float> sumFoundTracksUV(0.0, 0.0);
757
758 int minLayer = (layer != -1) ? layer : m_gTools->getFirstSVDLayer();
759 int maxLayer = (layer != -1) ? layer : m_gTools->getLastSVDLayer();
760
761 if (ladder == 0) ladder = -1;
762
763 for (int layerId = minLayer; layerId < maxLayer + 1; ++layerId) {
764 int minLadder = (ladder != -1) ? ladder : 1;
765 int maxLadder = (ladder != -1) ? ladder : getNumberOfLadders(layerId);
766
767 int minSensor = (sensor != -1) ? sensor : 1;
768 int maxSensor = (sensor != -1) ? sensor : getNumberOfSensors(layerId);
769
770 for (int sensorId = minSensor; sensorId < maxSensor + 1; ++sensorId) {
771
772 for (int ladderId = minLadder; ladderId < maxLadder + 1; ++ladderId) {
773 int binY = findBinY(layerId, sensorId);
774 int binXY = hMCV->FindBin(ladderId, binY);
775
776 sumMatchedClustersUV.first += hMCU->GetBinContent(binXY);
777 sumMatchedClustersUV.second += hMCV->GetBinContent(binXY);
778 sumFoundTracksUV.first += hFTU->GetBinContent(binXY);
779 sumFoundTracksUV.second += hFTV->GetBinContent(binXY);
780 }
781 }
782 }
783
784 if (sumFoundTracksUV.first > 0) {
785 avgEffUV.first = sumMatchedClustersUV.first / sumFoundTracksUV.first * 100;
786 } else {
787 avgEffUV.first = nan;
788 }
789
790 if (sumFoundTracksUV.second > 0) {
791 avgEffUV.second = sumMatchedClustersUV.second / sumFoundTracksUV.second * 100;
792 } else {
793 avgEffUV.second = nan;
794 }
795
796 return avgEffUV;
797}
798
799
800void DQMHistAnalysisSVDOnMiraBelleModule::addVariable(string name, pair<float, float>& varUV)
801{
802 size_t pos = name.find("UV");
803
804 if (pos != string::npos)
805 name.replace(pos, 2, "");
806
807 m_monObj->setVariable(Form("%sU", name.c_str()), varUV.first);
808 m_monObj->setVariable(Form("%sV", name.c_str()), varUV.second);
809}
810
811float DQMHistAnalysisSVDOnMiraBelleModule::xForMaxY(TH1F* h) const
812{
813 int maxY = h->GetMaximumBin();
814 float xMaxY = h->GetXaxis()->GetBinCenter(maxY);
815 return xMaxY;
816}
817
818float DQMHistAnalysisSVDOnMiraBelleModule::histFWHM(TH1F* h) const
819{
820 int bin1 = h->FindFirstBinAbove(h->GetMaximum() / 2);
821 int bin2 = h->FindLastBinAbove(h->GetMaximum() / 2);
822 float fwhm = h->GetBinCenter(bin2) - h->GetBinCenter(bin1);
823 return fwhm;
824}
Belle2::DQMHistAnalysisModule::getMonitoringObject
static MonitoringObject * getMonitoringObject(const std::string &name)
Get MonitoringObject with given name (new object is created if non-existing)
Definition DQMHistAnalysis.cc:139
Belle2::DQMHistAnalysisModule::findHist
static TH1 * findHist(const std::string &histname, bool onlyIfUpdated=false)
Get histogram from list (no other search).
Definition DQMHistAnalysis.cc:160
Belle2::DQMHistAnalysisModule::DQMHistAnalysisModule
DQMHistAnalysisModule()
Constructor / Destructor.
Definition DQMHistAnalysis.cc:44
Belle2::DQMHistAnalysisSVDOnMiraBelleModule::initialize
void initialize() override final
Module function initialize.
Definition DQMHistAnalysisSVDOnMiraBelle.cc:44
Belle2::DQMHistAnalysisSVDOnMiraBelleModule::histFWHM
float histFWHM(TH1F *h) const
Calculate full width at half maximum of histogram.
Definition DQMHistAnalysisSVDOnMiraBelle.cc:818
Belle2::DQMHistAnalysisSVDOnMiraBelleModule::m_c_MPVTimeClusterOnTrack
TCanvas * m_c_MPVTimeClusterOnTrack
time for clusters on track
Definition DQMHistAnalysisSVDOnMiraBelle.h:57
Belle2::DQMHistAnalysisSVDOnMiraBelleModule::m_SVDModules
std::vector< VxdID > m_SVDModules
IDs of all SVD Modules to iterate over.
Definition DQMHistAnalysisSVDOnMiraBelle.h:68
Belle2::DQMHistAnalysisSVDOnMiraBelleModule::m_gTools
const VXD::GeoTools * m_gTools
geometrical tool pointer
Definition DQMHistAnalysisSVDOnMiraBelle.h:71
Belle2::DQMHistAnalysisSVDOnMiraBelleModule::addVariable
void addVariable(std::string name, std::pair< float, float > &varUV)
Add variable to object monitoring.
Definition DQMHistAnalysisSVDOnMiraBelle.cc:800
Belle2::DQMHistAnalysisSVDOnMiraBelleModule::m_c_MPVChargeClusterOnTrack
TCanvas * m_c_MPVChargeClusterOnTrack
charge for clusters on track
Definition DQMHistAnalysisSVDOnMiraBelle.h:55
Belle2::DQMHistAnalysisSVDOnMiraBelleModule::m_svdPlotsConfig
DBObjPtr< SVDDQMPlotsConfiguration > m_svdPlotsConfig
SVD DQM plots configuration.
Definition DQMHistAnalysisSVDOnMiraBelle.h:62
Belle2::DQMHistAnalysisSVDOnMiraBelleModule::m_monObj
MonitoringObject * m_monObj
Monitoring Object to be produced by this module, which contain defined canvases and monitoring variab...
Definition DQMHistAnalysisSVDOnMiraBelle.h:65
Belle2::DQMHistAnalysisSVDOnMiraBelleModule::m_c_avgEfficiency
TCanvas * m_c_avgEfficiency
List of canvases to be added to MonitoringObject.
Definition DQMHistAnalysisSVDOnMiraBelle.h:53
Belle2::DQMHistAnalysisSVDOnMiraBelleModule::terminate
void terminate() override final
Module function terminate.
Definition DQMHistAnalysisSVDOnMiraBelle.cc:649
Belle2::DQMHistAnalysisSVDOnMiraBelleModule::findBinY
Int_t findBinY(Int_t layer, Int_t sensor) const
find the Y bin given the layer and sensor number
Definition DQMHistAnalysisSVDOnMiraBelle.h:127
Belle2::DQMHistAnalysisSVDOnMiraBelleModule::event
void event() override final
Module function event.
Definition DQMHistAnalysisSVDOnMiraBelle.cc:99
Belle2::DQMHistAnalysisSVDOnMiraBelleModule::avgOccupancyGrpId0UV
std::pair< float, float > avgOccupancyGrpId0UV(int iLayer, int nEvents) const
Calculate avg offline occupancy for specified layer for time group id = 0.
Definition DQMHistAnalysisSVDOnMiraBelle.cc:698
Belle2::DQMHistAnalysisSVDOnMiraBelleModule::avgOccupancyUV
std::pair< float, float > avgOccupancyUV(TH1F *hU, TH1F *hV, int nEvents, int layer=-1, int ladder=-1, int sensor=-1) const
Calculate avg offline occupancy for one specific sensor, especially.
Definition DQMHistAnalysisSVDOnMiraBelle.cc:654
Belle2::DQMHistAnalysisSVDOnMiraBelleModule::avgEfficiencyUV
std::pair< float, float > avgEfficiencyUV(TH2F *hMCU, TH2F *hMCV, TH2F *hFTU, TH2F *hFTV, int layer=-1, int ladder=-1, int sensor=-1) const
Calculate avg efficiency for specified sensors.
Definition DQMHistAnalysisSVDOnMiraBelle.cc:749
Belle2::DQMHistAnalysisSVDOnMiraBelleModule::m_c_MPVSNRClusterOnTrack
TCanvas * m_c_MPVSNRClusterOnTrack
SNR for clusters on track.
Definition DQMHistAnalysisSVDOnMiraBelle.h:56
Belle2::DQMHistAnalysisSVDOnMiraBelleModule::getNumberOfLadders
Int_t getNumberOfLadders(Int_t layer) const
get number of ladders per layer
Definition DQMHistAnalysisSVDOnMiraBelle.h:143
Belle2::DQMHistAnalysisSVDOnMiraBelleModule::endRun
void endRun() override final
Module function endRun.
Definition DQMHistAnalysisSVDOnMiraBelle.cc:104
Belle2::DQMHistAnalysisSVDOnMiraBelleModule::xForMaxY
float xForMaxY(TH1F *h) const
Calculate abscissa of max Y bin.
Definition DQMHistAnalysisSVDOnMiraBelle.cc:811
Belle2::DQMHistAnalysisSVDOnMiraBelleModule::m_c_avgOffOccupancy
TCanvas * m_c_avgOffOccupancy
number of ZS5 fired strips
Definition DQMHistAnalysisSVDOnMiraBelle.h:54
Belle2::DQMHistAnalysisSVDOnMiraBelleModule::beginRun
void beginRun() override final
Module function beginRun.
Definition DQMHistAnalysisSVDOnMiraBelle.cc:94
Belle2::DQMHistAnalysisSVDOnMiraBelleModule::m_c_avgMaxBinClusterOnTrack
TCanvas * m_c_avgMaxBinClusterOnTrack
average number of the APV sample which corresponds to the maximum amplitude for clusters on track
Definition DQMHistAnalysisSVDOnMiraBelle.h:58
Belle2::DQMHistAnalysisSVDOnMiraBelleModule::m_listOfSensorsToMonitor
std::vector< std::string > m_listOfSensorsToMonitor
list of sensor to monitor (Charge, SNR, time; U/V) taken from DB (payload)
Definition DQMHistAnalysisSVDOnMiraBelle.h:74
Belle2::DQMHistAnalysisSVDOnMiraBelleModule::getNumberOfSensors
Int_t getNumberOfSensors(Int_t layer) const
get number of sensors per layer
Definition DQMHistAnalysisSVDOnMiraBelle.h:158
Belle2::Module::setDescription
void setDescription(const std::string &description)
Sets the description of the module.
Definition Module.cc:214
Belle2::Module::setPropertyFlags
void setPropertyFlags(unsigned int propertyFlags)
Sets the flags for the module properties.
Definition Module.cc:208
Belle2::Module::c_ParallelProcessingCertified
@ c_ParallelProcessingCertified
This module can be run in parallel processing mode safely (All I/O must be done through the data stor...
Definition Module.h:80
Belle2::VXD::GeoCache
Class to facilitate easy access to sensor information of the VXD like coordinate transformations or p...
Definition GeoCache.h:38
Belle2::VXD::GeoCache::getListOfSensors
const std::vector< VxdID > getListOfSensors() const
Get list of all sensors.
Definition GeoCache.cc:59
Belle2::VXD::GeoCache::getSensorInfo
const SensorInfoBase & getSensorInfo(Belle2::VxdID id) const
Return a reference to the SensorInfo of a given SensorID.
Definition GeoCache.cc:67
Belle2::VXD::GeoCache::getInstance
static GeoCache & getInstance()
Return a reference to the singleton instance.
Definition GeoCache.cc:214
Belle2::VXD::GeoCache::getGeoTools
const GeoTools * getGeoTools()
Return a raw pointer to a GeoTools object.
Definition GeoCache.h:141
Belle2::VXD::SensorInfoBase
Base class to provide Sensor Information for PXD and SVD.
Definition SensorInfoBase.h:29
Belle2::VxdID
Class to uniquely identify a any structure of the PXD and SVD.
Definition VxdID.h:32
SetVariable
#define SetVariable(x)
set variable to mirabelle for a given member
Definition DQMHistAnalysisSVDOnMiraBelle.h:177
REG_MODULE
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition Module.h:649
Belle2
Abstract base class for different kinds of events.
Definition MillepedeAlgorithm.h:17
std
STL namespace.