Belle II Software development
SVDPerformanceModule.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#include <svd/modules/svdPerformance/SVDPerformanceModule.h>
9#include <framework/datastore/StoreObjPtr.h>
10#include <framework/datastore/RelationVector.h>
11#include <time.h>
12#include <mdst/dataobjects/MCParticle.h>
13#include <mdst/dataobjects/HitPatternVXD.h>
14#include <svd/dataobjects/SVDTrueHit.h>
15
16using namespace std;
17using namespace Belle2;
18
19REG_MODULE(SVDPerformance);
20
21SVDPerformanceModule::SVDPerformanceModule() : Module()
22 , m_nTracks(0), m_Pvalue(), m_mom(0), m_nSVDhits(0)
23{
24
25 setDescription("This module check performances of SVD reconstruction of VXD TB data");
26
27 addParam("outputFileName", m_rootFileName, "Name of output root file.", std::string("SVDPerformance_output.root"));
28 addParam("SVDEventInfo", m_svdEventInfoName, "Defines the name of the EventInfo", string(""));
29
30 addParam("is2017TBanalysis", m_is2017TBanalysis, "True if analyzing 2017 TB data.", bool(false));
31 addParam("isSimulation", m_isSimulation, "True if analyzing simulated data.", bool(false));
32
33 addParam("debugLowTime", m_debugLowTime, "Cluster Time below this number will produce a printout.", float(0.));
34
35 addParam("ShaperDigitsName", m_ShaperDigitName, "Name of ShaperDigit Store Array.", std::string(""));
36 addParam("RecoDigitsName", m_RecoDigitName, "Name of RecoDigit Store Array.", std::string(""));
37 addParam("ClustersName", m_ClusterName, "Name of Cluster Store Array.", std::string(""));
38 addParam("TrackListName", m_TrackName, "Name of Track Store Array.", std::string(""));
39 addParam("TrackFitResultListName", m_TrackFitResultName, "Name of TracksFitResult Store Array.", std::string(""));
40}
41
42
43void SVDPerformanceModule::initialize()
44{
45
46 m_svdShapers.isRequired(m_ShaperDigitName);
47 m_svdRecos.isOptional(m_RecoDigitName);
48 m_svdClusters.isRequired(m_ClusterName);
49 // m_Tracks.isRequired(m_TrackName);
50 // m_recoTracks.isRequired();
51 // m_tfr.isRequired(m_TrackFitResultName);
52
53 if (!m_storeSVDEvtInfo.isOptional(m_svdEventInfoName)) m_svdEventInfoName = "SVDEventInfoSim";
54 m_storeSVDEvtInfo.isRequired(m_svdEventInfoName);
55
56 B2INFO(" ShaperDigits: " << m_ShaperDigitName);
57 B2INFO(" RecoDigits: " << m_RecoDigitName);
58 B2INFO(" Clusters: " << m_ClusterName);
59 B2INFO(" Tracks: " << m_TrackName);
60 B2INFO(" TrackFitResults: " << m_TrackFitResultName);
61
62
63 //create list of histograms to be saved in the rootfile
64 m_histoList_track = new TList;
65 m_histoList_corr = new TList;
66
67 for (int i = 0; i < m_nLayers; i++) {
68 m_histoList_cluster[i] = new TList;
69 m_histoList_clTRK[i] = new TList;
70 m_histoList_reco[i] = new TList;
71 m_histoList_shaper[i] = new TList;
72 }
73
74 m_rootFilePtr = new TFile(m_rootFileName.c_str(), "RECREATE");
75
76 for (int s = 0; s < m_nLayers; s++)
77 if (m_is2017TBanalysis)
78 sensorsOnLayer[s] = 2;
79 else
80 sensorsOnLayer[s] = s + 2;
81
82 //create histograms
83 for (int i = 0; i < m_nLayers; i ++) //loop on Layers
84 for (int j = 0; j < (int)sensorsOnLayer[i]; j ++) { //loop on Sensors
85
86 TString nameLayer = "";
87 nameLayer += i + 3;
88
89 TString nameSensor = "";
90 if (m_is2017TBanalysis) {
91 if (i == 0)
92 nameSensor += j + 1;
93 else if (i == 1 || i == 2)
94 nameSensor += j + 2;
95 else if (i == 3)
96 nameSensor += j + 3;
97 } else
98 nameSensor += j + 1;
99
100 for (int k = 0; k < m_nSides; k ++) { //loop on Sides
101
102
103 TString nameSide = "";
104 if (k == 1)
105 nameSide = "U";
106 else if (k == 0)
107 nameSide = "V";
108
109 //SHAPER DIGITS
110 TString NameOfHisto = "shaper_N_L" + nameLayer + "S" + nameSensor + "" + nameSide;
111 TString TitleOfHisto = "number of ShaperDigits (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
112 h_nShaper[i][j][k] = createHistogram1D(NameOfHisto, TitleOfHisto, 100, 0, 100, "n ShaperDigits", m_histoList_shaper[i]);
113
114
115 //RECO DIGITS
116 NameOfHisto = "reco_N_L" + nameLayer + "S" + nameSensor + "" + nameSide;
117 TitleOfHisto = "number of RecoDigits (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
118 h_nReco[i][j][k] = createHistogram1D(NameOfHisto, TitleOfHisto, 100, 0, 100, "n RecoDigits", m_histoList_reco[i]);
119
120 NameOfHisto = "reco_charge_L" + nameLayer + "S" + nameSensor + "" + nameSide;
121 TitleOfHisto = "charge of RecoDigits (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
122 h_recoCharge[i][j][k] = createHistogram1D(NameOfHisto, TitleOfHisto, 100, 0, 100000, "charge (e-)", m_histoList_reco[i]);
123
124 NameOfHisto = "reco_energy_L" + nameLayer + "S" + nameSensor + "" + nameSide;
125 TitleOfHisto = "energy collected by RecoDigits (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
126 h_recoEnergy[i][j][k] = createHistogram1D(NameOfHisto, TitleOfHisto, 100, 0, 360, "energy (keV)", m_histoList_reco[i]);
127
128 NameOfHisto = "reco_noise_L" + nameLayer + "S" + nameSensor + "" + nameSide;
129 TitleOfHisto = "strip noise (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
130 h_stripNoise[i][j][k] = createHistogram1D(NameOfHisto, TitleOfHisto, 200, 300, 1800, "strip noise", m_histoList_reco[i]);
131
132 NameOfHisto = "reco_time_L" + nameLayer + "S" + nameSensor + "" + nameSide;
133 TitleOfHisto = "strip time (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
134 h_recoTime[i][j][k] = createHistogram1D(NameOfHisto, TitleOfHisto, 200, -100, 100, "strip time", m_histoList_reco[i]);
135
136
137 //CLUSTERS RELATED TO TRACKS
138 NameOfHisto = "clTRK_N_L" + nameLayer + "S" + nameSensor + "" + nameSide;
139 TitleOfHisto = "number of clusters related to Tracks (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
140 h_nCltrk[i][j][k] = createHistogram1D(NameOfHisto, TitleOfHisto, 50, 0, 50, "n clusters", m_histoList_clTRK[i]);
141
142 NameOfHisto = "clTRK_size_L" + nameLayer + "S" + nameSensor + "" + nameSide;
143 TitleOfHisto = "cluster size (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
144 h_cltrkSize[i][j][k] = createHistogram1D(NameOfHisto, TitleOfHisto, 15, 0, 15, "cluster size", m_histoList_clTRK[i]);
145
146 NameOfHisto = "clTRK_charge_L" + nameLayer + "S" + nameSensor + "" + nameSide;
147 TitleOfHisto = "cluster Charge (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
148 h_cltrkCharge[i][j][k] = createHistogram1D(NameOfHisto, TitleOfHisto, 500, 0, 100000, "charge(e-)", m_histoList_clTRK[i]);
149
150 NameOfHisto = "clTRK_energy_L" + nameLayer + "S" + nameSensor + "" + nameSide;
151 TitleOfHisto = "cluster Energy (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
152 h_cltrkEnergy[i][j][k] = createHistogram1D(NameOfHisto, TitleOfHisto, 360, 0, 360, "energy (keV)", m_histoList_clTRK[i]);
153
154 NameOfHisto = "clTRK_SN_L" + nameLayer + "S" + nameSensor + "" + nameSide;
155 TitleOfHisto = "cluster S/N (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
156 h_cltrkSN[i][j][k] = createHistogram1D(NameOfHisto, TitleOfHisto, 150, 0, 150, "S/N", m_histoList_clTRK[i]);
157
158 NameOfHisto = "clTRK_chrgVSsize_L" + nameLayer + "S" + nameSensor + "" + nameSide;
159 TitleOfHisto = "cluster charge VS size (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
160 h_cltrkChargeVSSize[i][j][k] = createHistogram2D(NameOfHisto, TitleOfHisto, 500, 0, 100000, "charge (e-)", 15, 0, 15, "cl size",
161 m_histoList_clTRK[i]);
162
163 NameOfHisto = "clTRK_SNVSsize_L" + nameLayer + "S" + nameSensor + "" + nameSide;
164 TitleOfHisto = "cluster SN ratio VS size (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
165 h_cltrkSNVSSize[i][j][k] = createHistogram2D(NameOfHisto, TitleOfHisto, 150, 0, 150, "S/N", 15, 0, 15, "cl size",
166 m_histoList_clTRK[i]);
167
168 NameOfHisto = "clTRK_TimeVSsize_L" + nameLayer + "S" + nameSensor + "" + nameSide;
169 TitleOfHisto = "cluster time VS size (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
170 h_cltrkTimeVSSize[i][j][k] = createHistogram2D(NameOfHisto, TitleOfHisto, 200, -100, 100, "cluster time (ns)", 15, 0, 15, "cl size",
171 m_histoList_clTRK[i]);
172
173 NameOfHisto = "clTRK_time_L" + nameLayer + "S" + nameSensor + "" + nameSide;
174 TitleOfHisto = "cluster time (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
175 h_cltrkTime[i][j][k] = createHistogram1D(NameOfHisto, TitleOfHisto, 200, -100, 100, "cluster time (ns)", m_histoList_clTRK[i]);
176
177 NameOfHisto = "clTRK_timeTB1_L" + nameLayer + "S" + nameSensor + "" + nameSide;
178 TitleOfHisto = "cluster time - TB = 1 (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
179 h_cltrkTime_TB1[i][j][k] = createHistogram1D(NameOfHisto, TitleOfHisto, 200, -100, 100, "cluster time (ns)", m_histoList_clTRK[i]);
180
181 NameOfHisto = "clTRK_timeTB2_L" + nameLayer + "S" + nameSensor + "" + nameSide;
182 TitleOfHisto = "cluster time - TB = 2 (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
183 h_cltrkTime_TB2[i][j][k] = createHistogram1D(NameOfHisto, TitleOfHisto, 200, -100, 100, "cluster time (ns)", m_histoList_clTRK[i]);
184
185 NameOfHisto = "clTRK_timeTB3_L" + nameLayer + "S" + nameSensor + "" + nameSide;
186 TitleOfHisto = "cluster time - TB = 3 (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
187 h_cltrkTime_TB3[i][j][k] = createHistogram1D(NameOfHisto, TitleOfHisto, 200, -100, 100, "cluster time (ns)", m_histoList_clTRK[i]);
188
189 NameOfHisto = "clTRK_timeTB4_L" + nameLayer + "S" + nameSensor + "" + nameSide;
190 TitleOfHisto = "cluster time - TB = 4 (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
191 h_cltrkTime_TB4[i][j][k] = createHistogram1D(NameOfHisto, TitleOfHisto, 200, -100, 100, "cluster time (ns)", m_histoList_clTRK[i]);
192
193 if (m_isSimulation) {
194 NameOfHisto = "clTRK_timeVStrueTime_L" + nameLayer + "S" + nameSensor + "" + nameSide;
195 TitleOfHisto = "cluster time VS true hit time (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
196 h_cltrkTimeVSTrueTime[i][j][k] = createHistogram2D(NameOfHisto, TitleOfHisto, 200, -100, 100, "cluster time", 60, -30, 30,
197 "true time", m_histoList_clTRK[i]);
198 }
199
200 //1 STRIP CLUSTERS RELATED TO TRACKS
201 NameOfHisto = "1clTRK_charge_L" + nameLayer + "S" + nameSensor + "" + nameSide;
202 TitleOfHisto = "1-strip cluster Charge (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
203 h_1cltrkCharge[i][j][k] = createHistogram1D(NameOfHisto, TitleOfHisto, 500, 0, 100000, "charge(e-)", m_histoList_clTRK[i]);
204
205
206 NameOfHisto = "1clTRK_SN_L" + nameLayer + "S" + nameSensor + "" + nameSide;
207 TitleOfHisto = "1-strip cluster S/N (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
208 h_1cltrkSN[i][j][k] = createHistogram1D(NameOfHisto, TitleOfHisto, 150, 0, 150, "S/N", m_histoList_clTRK[i]);
209
210 //2-STRIP CLUSTERS RELATED TO TRACKS
211 NameOfHisto = "2clTRK_charge_L" + nameLayer + "S" + nameSensor + "" + nameSide;
212 TitleOfHisto = "2-strip cluster Charge (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
213 h_2cltrkCharge[i][j][k] = createHistogram1D(NameOfHisto, TitleOfHisto, 500, 0, 100000, "charge(e-)", m_histoList_clTRK[i]);
214
215
216 NameOfHisto = "2clTRK_SN_L" + nameLayer + "S" + nameSensor + "" + nameSide;
217 TitleOfHisto = "2-strip cluster S/N (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
218 h_2cltrkSN[i][j][k] = createHistogram1D(NameOfHisto, TitleOfHisto, 150, 0, 150, "S/N", m_histoList_clTRK[i]);
219
220 //CLUSTERS NOT RELATED TO TRACKS
221 NameOfHisto = "clNOtrk_N_L" + nameLayer + "S" + nameSensor + "" + nameSide;
222 TitleOfHisto = "number of clusters NOT related to Tracks (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
223 h_nCl[i][j][k] = createHistogram1D(NameOfHisto, TitleOfHisto, 50, 0, 50, "n clusters", m_histoList_cluster[i]);
224
225 NameOfHisto = "clNOtrk_size_L" + nameLayer + "S" + nameSensor + "" + nameSide;
226 TitleOfHisto = "cluster size, NOT related to tracks (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
227 h_clSize[i][j][k] = createHistogram1D(NameOfHisto, TitleOfHisto, 15, 0, 15, "cluster size", m_histoList_cluster[i]);
228
229 NameOfHisto = "clNOtrk_charge_L" + nameLayer + "S" + nameSensor + "" + nameSide;
230 TitleOfHisto = "cluster Charge, NOT related to tracks (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
231 h_clCharge[i][j][k] = createHistogram1D(NameOfHisto, TitleOfHisto, 500, 0, 100000, "charge (e-)", m_histoList_cluster[i]);
232
233 NameOfHisto = "clNOtrk_energy_L" + nameLayer + "S" + nameSensor + "" + nameSide;
234 TitleOfHisto = "cluster Energy, NOT related to tracks (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
235 h_clEnergy[i][j][k] = createHistogram1D(NameOfHisto, TitleOfHisto, 360, 0, 360, "energy (keV)", m_histoList_cluster[i]);
236
237 NameOfHisto = "clNOtrk_maxbin_L" + nameLayer + "S" + nameSensor + "" + nameSide;
238 TitleOfHisto = "cluster Seed maxbin, NOT related to tracks (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
239 h_clSeedMaxbin[i][j][k] = createHistogram1D(NameOfHisto, TitleOfHisto, 6, 0, 6, "max bin", m_histoList_cluster[i]);
240
241 NameOfHisto = "clNOtrk_energyVSmaxbin_L" + nameLayer + "S" + nameSensor + "" + nameSide;
242 TitleOfHisto = "cluster Energy vs seed max bin U, NOT related to tracks (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide +
243 " side)";
244 h_clEnergyVSMaxbin[i][j][k] = createHistogram2D(NameOfHisto, TitleOfHisto, 360, 0, 360, "energy (keV)", 6, 0, 6, "seed max bin",
245 m_histoList_cluster[i]);
246
247
248 NameOfHisto = "clNOtrk_energyVSsizeMB12_L" + nameLayer + "S" + nameSensor + "" + nameSide;
249 TitleOfHisto = "cluster Energy vs Size, maxbin = 1,2 U, NOT related to tracks (L" + nameLayer + ", sensor" + nameSensor + "," +
250 nameSide +
251 " side)";
252 h_clEnergyVSSize_mb12[i][j][k] = createHistogram2D(NameOfHisto, TitleOfHisto, 360, 0, 360, "energy (keV)", 15, 0, 15, "cl size",
253 m_histoList_cluster[i]);
254
255 NameOfHisto = "clNOtrk_energyVSsizeMB345_L" + nameLayer + "S" + nameSensor + "" + nameSide;
256 TitleOfHisto = "cluster Energy vs Size, maxbin = 3,4,5 U, NOT related to tracks (L" + nameLayer + ", sensor" + nameSensor + "," +
257 nameSide +
258 " side)";
259 h_clEnergyVSSize_mb345[i][j][k] = createHistogram2D(NameOfHisto, TitleOfHisto, 360, 0, 360, "energy (keV)", 15, 0, 15, "cl size",
260 m_histoList_cluster[i]);
261
262 NameOfHisto = "clNOtrk_energyVSsizeMB6_L" + nameLayer + "S" + nameSensor + "" + nameSide;
263 TitleOfHisto = "cluster Energy vs Size, maxbin = 6 U, NOT related to tracks (L" + nameLayer + ", sensor" + nameSensor + "," +
264 nameSide +
265 " side)";
266 h_clEnergyVSSize_mb6[i][j][k] = createHistogram2D(NameOfHisto, TitleOfHisto, 360, 0, 360, "energy (keV)", 15, 0, 15, "cl size",
267 m_histoList_cluster[i]);
268
269 if (k == 1) {
270 NameOfHisto = "clNOtrk_energyVScoorU_L" + nameLayer + "S" + nameSensor + "" + nameSide;
271 TitleOfHisto = "cluster Energy vs coor U, TB=3,4,5 NOT related to tracks (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide
272 +
273 " side)";
274 h_clEnergyVSCoorU[i][j][1] = createHistogram2D(NameOfHisto, TitleOfHisto, 360, 0, 360, "energy (keV)", 200, -3, 3, "coor U (cm)",
275 m_histoList_cluster[i]);
276
277 NameOfHisto = "clNOtrk_coorU1VScoorU2_L" + nameLayer + "S" + nameSensor + "" + nameSide;
278 TitleOfHisto = "cluster coor1 U vs coor2 U, TB=3,4,5 NOT related to tracks (L" + nameLayer + ", sensor" + nameSensor + "," +
279 nameSide +
280 " side)";
281 h_clCoor1VSCoor2[i][j][1] = createHistogram1D(NameOfHisto, TitleOfHisto, 400, 0, 4, "delta U (cm)",
282 m_histoList_cluster[i]);
283
284 NameOfHisto = "clNOtrk_cellIDU1VScellIDU2_L" + nameLayer + "S" + nameSensor + "" + nameSide;
285 TitleOfHisto = "cluster cellID1 U vs cellID2 U, TB=3,4,5 NOT related to tracks (L" + nameLayer + ", sensor" + nameSensor + "," +
286 nameSide +
287 " side)";
288 h_clCellID1VSCellID2[i][j][1] = createHistogram1D(NameOfHisto, TitleOfHisto, 768, 0, 768, "delta U (# of cells)",
289 m_histoList_cluster[i]);
290
291 NameOfHisto = "clNOtrk_energy12VSdeltaU_L" + nameLayer + "S" + nameSensor + "" + nameSide;
292 TitleOfHisto = "cluster energy1+2 U vs delta U, TB=3,4,5 NOT related to tracks (L" + nameLayer + ", sensor" + nameSensor + "," +
293 nameSide +
294 " side)";
295 h_clEnergy12VSdelta[i][j][1] = createHistogram2D(NameOfHisto, TitleOfHisto, 360, 0, 360, "energy (keV)", 768, 0, 768,
296 "delta U (# of cells)",
297 m_histoList_cluster[i]);
298
299 } else {
300 NameOfHisto = "clNOtrk_energyVScoorV_L" + nameLayer + "S" + nameSensor + "" + nameSide;
301 TitleOfHisto = "cluster Energy vs coor V, TB=3,4,5 NOT related to tracks (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide
302 +
303 " side)";
304 h_clEnergyVSCoorV[i][j][0] = createHistogram2D(NameOfHisto, TitleOfHisto, 360, 0, 360, "energy (keV)", 200, -6.5, 6.5,
305 "coor V (cm)", m_histoList_cluster[i]);
306
307 NameOfHisto = "clNOtrk_coorV1VScoorV2_L" + nameLayer + "S" + nameSensor + "" + nameSide;
308 TitleOfHisto = "cluster coor1 V vs coor2 V, TB=3,4,5 NOT related to tracks (L" + nameLayer + ", sensor" + nameSensor + "," +
309 nameSide +
310 " side)";
311 h_clCoor1VSCoor2[i][j][0] = createHistogram1D(NameOfHisto, TitleOfHisto, 400, 0, 6, "delta V (cm)",
312 m_histoList_cluster[i]);
313 NameOfHisto = "clNOtrk_cellIDV1VScellIDV2_L" + nameLayer + "S" + nameSensor + "" + nameSide;
314 TitleOfHisto = "cluster cellID1 V vs cellID2 V, TB=3,4,5 NOT related to tracks (L" + nameLayer + ", sensor" + nameSensor + "," +
315 nameSide +
316 " side)";
317 h_clCellID1VSCellID2[i][j][0] = createHistogram1D(NameOfHisto, TitleOfHisto, 768, 0, 768, "delta V (# of cells)",
318 m_histoList_cluster[i]);
319
320 NameOfHisto = "clNOtrk_energy12VSdeltaV_L" + nameLayer + "S" + nameSensor + "" + nameSide;
321 TitleOfHisto = "cluster energy1+2 V vs delta V, TB=3,4,5 NOT related to tracks (L" + nameLayer + ", sensor" + nameSensor + "," +
322 nameSide +
323 " side)";
324 h_clEnergy12VSdelta[i][j][0] = createHistogram2D(NameOfHisto, TitleOfHisto, 360, 0, 360, "energy (keV)", 768, 0, 768,
325 "delta V (# of cells)",
326 m_histoList_cluster[i]);
327
328 }
329
330 NameOfHisto = "clNOtrk_SN_L" + nameLayer + "S" + nameSensor + "" + nameSide;
331 TitleOfHisto = "cluster S/N, NOT related to tracks (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
332 h_clSN[i][j][k] = createHistogram1D(NameOfHisto, TitleOfHisto, 150, 0, 150, "S/N", m_histoList_cluster[i]);
333
334 NameOfHisto = "clNOtrk_chrgVSsize_L" + nameLayer + "S" + nameSensor + "" + nameSide;
335 TitleOfHisto = "cluster charge VS size, NOT related to tracks (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
336 h_clChargeVSSize[i][j][k] = createHistogram2D(NameOfHisto, TitleOfHisto, 500, 0, 100000, "charge (e-)", 15, 0, 15, "cl size",
337 m_histoList_cluster[i]);
338 NameOfHisto = "clNOtrk_SNVSsize_L" + nameLayer + "S" + nameSensor + "" + nameSide;
339 TitleOfHisto = "cluster S/N ratio VS size, NOT related to tracks (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide +
340 " side)";
341 h_clSNVSSize[i][j][k] = createHistogram2D(NameOfHisto, TitleOfHisto, 150, 0, 150, "S/N", 15, 0, 15, "cl size",
342 m_histoList_cluster[i]);
343
344 NameOfHisto = "clNOtrk_TimeVSsize_L" + nameLayer + "S" + nameSensor + "" + nameSide;
345 TitleOfHisto = "cluster time VS size, NOT related to tracks (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
346 h_clTimeVSSize[i][j][k] = createHistogram2D(NameOfHisto, TitleOfHisto, 200, -100, 100, "cluster time (ns)", 15, 0, 15, "cl size",
347 m_histoList_cluster[i]);
348
349 NameOfHisto = "clNOtrk_time_L" + nameLayer + "S" + nameSensor + "" + nameSide;
350 TitleOfHisto = "cluster time (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
351 h_clTime[i][j][k] = createHistogram1D(NameOfHisto, TitleOfHisto, 200, -100, 100, "cluster time", m_histoList_cluster[i]);
352
353
354 if (m_isSimulation) {
355 NameOfHisto = "clNOtrk_timeVStrueTime_L" + nameLayer + "S" + nameSensor + "" + nameSide;
356 TitleOfHisto = "cluster time VS true hit time (L" + nameLayer + ", sensor" + nameSensor + "," + nameSide + " side)";
357 h_clTimeVSTrueTime[i][j][k] = createHistogram2D(NameOfHisto, TitleOfHisto, 200, -100, 100, "cluster time", 60, -30, 30, "true time",
358 m_histoList_cluster[i]);
359 }
360
361 }
362 TString NameOfHisto = "clNOtrk_nUVSnV_L" + nameLayer + "S" + nameSensor;
363 TString TitleOfHisto = "Number of U clusters VS number of V cluster, TB=3,4,5 (L" + nameLayer + ", sensor" + nameSensor + ")";
364 h_clNuVSNv[i][j] = createHistogram2D(NameOfHisto, TitleOfHisto, 50, 0, 50, "# V cluster", 50, 0, 50, "# U clusters",
365 m_histoList_cluster[i]);
366
367 NameOfHisto = "clNOtrk_coorUVScoorV_L" + nameLayer + "S" + nameSensor;
368 TitleOfHisto = "cluster coor U VS cluster coor V, TB=3,4,5 (L" + nameLayer + ", sensor" + nameSensor + ")";
369 h_clCoorUVSCoorV[i][j] = createHistogram2D(NameOfHisto, TitleOfHisto, 200, -6.5, 6.5, "coor V", 200, -3, 3, "coor U",
370 m_histoList_cluster[i]);
371
372 NameOfHisto = "clNOtrk_energyUVSenergyV_L" + nameLayer + "S" + nameSensor;
373 TitleOfHisto = "cluster energy U VS cluster energy V, TB=3,4,5 (L" + nameLayer + ", sensor" + nameSensor + ")";
374 h_clEnergyUVSEnergyV[i][j] = createHistogram2D(NameOfHisto, TitleOfHisto, 360, 0, 360, "energy V(keV)", 360, 0, 360,
375 "energy U (keV)",
376 m_histoList_cluster[i]);
377 //QUI
378 }
379
380 //correlations
381 h_cltrk_UU = createHistogram1D("clTRK_dt_UU", "track-related U-U clusters time difference", 200, -100, 100, "time difference (ns)",
382 m_histoList_corr);
383 h_cltrk_VV = createHistogram1D("clTRK_dt_VV", "track-related V-V clusters time difference", 200, -100, 100, "time difference (ns)",
384 m_histoList_corr);
385 h_cltrk_UV = createHistogram1D("clTRK_dt_UV", "track-related U-V clusters time difference", 200, -100, 100, "time difference (ns)",
386 m_histoList_corr);
387
388 h_cltrkTime_L4uL5u = createHistogram2D("clTRK_time_L4uL5u", "track-related cluster times on L4 and L5 U sides", 200, -100, 100,
389 "L4u cluster time", 200, -100, 100, "L5u cluster time",
390 m_histoList_corr);
391
392 h_cltrkTime_L4vL5v = createHistogram2D("clTRK_time_L4vL5v", "track-related cluster times on L4 and L5 V sides", 200, -100, 100,
393 "L4v cluster time", 200, -100, 100, "L5v cluster time",
394 m_histoList_corr);
395
396 h_cltrkTime_L5uL5v = createHistogram2D("clTRK_time_L5uL5v", "track-related cluster times on L5 U vs V sides", 200, -100, 100,
397 "L5u cluster time", 200, -100, 100, "L5v cluster time",
398 m_histoList_corr);
399
400
401
402 // //correlations
403 // h_cl_UU = createHistogram1D("clNOTRK_dt_UU", "track-related U-U clusters time difference", 200, -100, 100, "time difference (ns)",
404 // m_histoList_corr);
405 // h_cl_VV = createHistogram1D("clNOTRK_dt_VV", "track-related V-V clusters time difference", 200, -100, 100, "time difference (ns)",
406 // m_histoList_corr);
407 // h_cl_UV = createHistogram1D("clNOTRK_dt_UV", "track-related U-V clusters time difference", 200, -100, 100, "time difference (ns)",
408 // m_histoList_corr);
409
410 //tracks
411 m_nTracks = createHistogram1D("h1nTracks", "number of Tracks per event", 50, 0, 50, "n Tracks", m_histoList_track);
412 m_Pvalue = createHistogram1D("h1pValue", "Tracks p value", 100, 0, 1, "p value", m_histoList_track);
413 m_mom = createHistogram1D("h1momentum", " Tracks Momentum", 200, 0, 10, "p (GeV/c)", m_histoList_track);
414 m_nSVDhits = createHistogram1D("h1nSVDhits", "# SVD hits per track", 20, 0, 20, "# SVD hits", m_histoList_track);
415
416 m_ntracks = 0;
417}
418
419void SVDPerformanceModule::beginRun()
420{
421 m_nEvents = 0;
422}
423
424void SVDPerformanceModule::event()
425{
426
427 SVDModeByte modeByte = m_storeSVDEvtInfo->getModeByte();
428
429 m_nEvents++;
430 float c_eTOkeV = 3.6 / 1000; //keV = e * c_eTOkeV
431
432 // StoreObjPtr<EventMetaData> eventMetaDataPtr;
433
434 //ShaperDigits
435 int nShaperDigi[m_nLayers][m_nSensors][m_nSides];
436
437 //RecoDigits
438 int nRecoDigi[m_nLayers][m_nSensors][m_nSides];
439
440 // SVD clusters
441 int nCl[m_nLayers][m_nSensors][m_nSides];
442 int nCl345[m_nLayers][m_nSensors][m_nSides];
443 int nCltrk[m_nLayers][m_nSensors][m_nSides];
444
445 for (int i = 0; i < m_nLayers; i ++) //loop on Layers
446 for (int j = 0; j < m_nSensors; j ++) //loop on Sensors
447 for (int k = 0; k < m_nSides; k ++) { //loop on Sides
448 nShaperDigi[i][j][k] = 0;
449 nRecoDigi[i][j][k] = 0;
450 nCl[i][j][k] = 0;
451 nCl345[i][j][k] = 0;
452 nCltrk[i][j][k] = 0;
453 }
454
455 //tracks
456 if (m_Tracks) {
457 m_nTracks->Fill(m_Tracks.getEntries());
458 m_ntracks += m_Tracks.getEntries();
459 }
460
461 for (Track& track : m_Tracks) {
462
463 const TrackFitResult* tfr = nullptr;
464 if (m_is2017TBanalysis)
465 tfr = track.getTrackFitResultWithClosestMass(Const::electron);
466 else
467 tfr = track.getTrackFitResultWithClosestMass(Const::pion);
468 if (tfr) {
469 m_Pvalue->Fill(tfr->getPValue());
470 m_mom->Fill(tfr->getMomentum().R());
471 m_nSVDhits->Fill((tfr->getHitPatternVXD()).getNSVDHits());
472
473 if (m_is2017TBanalysis) {
474 if ((tfr->getPValue() < 0.001) || (tfr->getMomentum().R() < 1))
475 continue;
476 }
477 }
478 RelationVector<RecoTrack> theRC = DataStore::getRelationsWithObj<RecoTrack>(&track);
479 RelationVector<SVDCluster> svdClustersTrack = DataStore::getRelationsWithObj<SVDCluster>(theRC[0]);
480
481
482 for (int cl = 0 ; cl < (int)svdClustersTrack.size(); cl++) {
483
484 float clCharge = svdClustersTrack[cl]->getCharge();
485 float clEnergy = svdClustersTrack[cl]->getCharge() * c_eTOkeV;
486 int clSize = svdClustersTrack[cl]->getSize();
487 float clSN = svdClustersTrack[cl]->getSNR();
488 float clTime = svdClustersTrack[cl]->getClsTime();
489 VxdID::baseType theVxdID = (VxdID::baseType)svdClustersTrack[cl]->getSensorID();
490 int layer = VxdID(theVxdID).getLayerNumber() - 3;
491 int sensor = getSensor(layer, VxdID(theVxdID).getSensorNumber(), m_is2017TBanalysis);
492 int side = svdClustersTrack[cl]->isUCluster();
493
494 nCltrk[layer][sensor][side]++;
495 h_cltrkCharge[layer][sensor][side]->Fill(clCharge);
496 h_cltrkEnergy[layer][sensor][side]->Fill(clEnergy);
497 h_cltrkSize[layer][sensor][side]->Fill(clSize);
498 h_cltrkSN[layer][sensor][side]->Fill(clSN);
499 h_cltrkTime[layer][sensor][side]->Fill(clTime);
500
501 SVDModeByte::baseType tb = modeByte.getTriggerBin();
502 if ((int) tb == 0) h_cltrkTime_TB1[layer][sensor][side]->Fill(clTime);
503 if ((int) tb == 1) h_cltrkTime_TB2[layer][sensor][side]->Fill(clTime);
504 if ((int) tb == 2) h_cltrkTime_TB3[layer][sensor][side]->Fill(clTime);
505 if ((int) tb == 3) h_cltrkTime_TB4[layer][sensor][side]->Fill(clTime);
506
507 h_cltrkChargeVSSize[layer][sensor][side]->Fill(clCharge, clSize);
508 h_cltrkSNVSSize[layer][sensor][side]->Fill(clSN, clSize);
509 h_cltrkTimeVSSize[layer][sensor][side]->Fill(clTime, clSize);
510
511 if (layer == 2) //layer5
512 for (int cll = 0 ; cll < cl; cll++) {
513 VxdID::baseType theVxdID2 = (VxdID::baseType)svdClustersTrack[cll]->getSensorID();
514 int side2 = svdClustersTrack[cll]->isUCluster();
515
516 if ((VxdID(theVxdID2).getLayerNumber() == 5) && (side2 != side)) { //L5uL5v
517 if (side)
518 h_cltrkTime_L5uL5v->Fill(svdClustersTrack[cl]->getClsTime(), svdClustersTrack[cll]->getClsTime());
519 else
520 h_cltrkTime_L5uL5v->Fill(svdClustersTrack[cll]->getClsTime(), svdClustersTrack[cl]->getClsTime());
521 }
522
523 if (VxdID(theVxdID2).getLayerNumber() == 4) { //L4
524
525 if (side2 && side2 == side) //L4uL5u
526 h_cltrkTime_L4uL5u->Fill(svdClustersTrack[cl]->getClsTime(), svdClustersTrack[cll]->getClsTime());
527
528 if (!side2 && side2 == side) //L4vL5v
529 h_cltrkTime_L4vL5v->Fill(svdClustersTrack[cl]->getClsTime(), svdClustersTrack[cll]->getClsTime());
530
531 }
532 }
533
534 //fill time difference
535 for (int cl2 = 0 ; cl2 < cl ; cl2++) {
536
537 int layerDist = abs(VxdID(theVxdID).getLayerNumber() - svdClustersTrack[cl2]->getSensorID().getLayerNumber());
538
539 int side2 = svdClustersTrack[cl2]->isUCluster();
540
541 if (layerDist == 0) {
542 if ((side == 0) && (side2 == 1))
543 h_cltrk_UV -> Fill(svdClustersTrack[cl2]->getClsTime() - svdClustersTrack[cl]->getClsTime());
544
545 if ((side == 1) && (side2 == 0))
546 h_cltrk_UV -> Fill(svdClustersTrack[cl]->getClsTime() - svdClustersTrack[cl2]->getClsTime());
547 } else if (layerDist == 1) {
548 if ((side == 1) && (side2 == 1))
549 h_cltrk_UU -> Fill(svdClustersTrack[cl]->getClsTime() - svdClustersTrack[cl2]->getClsTime());
550
551 if ((side == 0) && (side2 == 0))
552 h_cltrk_VV -> Fill(svdClustersTrack[cl]->getClsTime() - svdClustersTrack[cl2]->getClsTime());
553 }
554
555
556
557 }
558
559 if (svdClustersTrack[cl]->getClsTime() < m_debugLowTime) {
560
561 B2DEBUG(10, "CLUSTER WITH A TIME BELOW " << m_debugLowTime << "ns");
562 B2DEBUG(10, "size = " << svdClustersTrack[cl]->getSize() << ", SNR = " << svdClustersTrack[cl]->getSNR() << " charge = " <<
563 svdClustersTrack[cl]->getCharge() << ", SeedCharge = " << svdClustersTrack[cl]->getSeedCharge() << ", time = " <<
564 svdClustersTrack[cl]->getClsTime());
565 }
566
567
568 if (m_isSimulation) {
569 RelationVector<SVDTrueHit> svdTrueHitsTrack = DataStore::getRelationsWithObj<SVDTrueHit>(svdClustersTrack[cl]);
570
571 for (int i = 0; i < (int)svdTrueHitsTrack.size(); i++) {
572 // if(svdTrueHitsTrack.size()>0){
573 h_cltrkTimeVSTrueTime[layer][sensor][side]->Fill(svdClustersTrack[cl]->getClsTime(), svdTrueHitsTrack[i]->getGlobalTime());
574 if (svdClustersTrack[cl]->getClsTime() < m_debugLowTime)
575 B2DEBUG(10, "True Hit Time = " << svdTrueHitsTrack[i]->getGlobalTime() << ", EnergyDep = " << svdTrueHitsTrack[i]->getEnergyDep() <<
576 ", size = " << svdTrueHitsTrack.size());
577 }
578
579
580 RelationVector<MCParticle> mcParticleTrack = DataStore::getRelationsWithObj<MCParticle>(svdClustersTrack[cl]);
581
582 if (svdClustersTrack[cl]->getClsTime() < m_debugLowTime)
583 if ((int)mcParticleTrack.size() > 0)
584 B2DEBUG(10, "MCParticle PDG = " << mcParticleTrack[0]->getPDG() << ", energy = " << mcParticleTrack[0]->getEnergy() << ", size = "
585 << mcParticleTrack.size());
586
587
588 }
589
590 if (clSize == 1) {
591 h_1cltrkCharge[layer][sensor][side]->Fill(clCharge);
592 h_1cltrkSN[layer][sensor][side]->Fill(svdClustersTrack[cl]->getSNR());
593 }
594
595 if (clSize == 2) {
596 h_2cltrkCharge[layer][sensor][side]->Fill(clCharge);
597 h_2cltrkSN[layer][sensor][side]->Fill(svdClustersTrack[cl]->getSNR());
598 }
599 }
600
601 }
602
603 if (m_Tracks)
604 B2DEBUG(1, "%%%%%%%% NEW EVENT, number of Tracks = " << m_Tracks.getEntries());
605
606 //shaper digits
607 for (int digi = 0 ; digi < m_svdShapers.getEntries(); digi++) {
608
609
610 VxdID::baseType theVxdID = (VxdID::baseType)m_svdShapers[digi]->getSensorID();
611 int layer = VxdID(theVxdID).getLayerNumber() - 3;
612 int sensor = getSensor(layer, VxdID(theVxdID).getSensorNumber(), m_is2017TBanalysis);
613 int side = m_svdShapers[digi]->isUStrip();
614 nShaperDigi[layer][sensor][side]++;
615
616
617 if (!m_svdShapers[digi]->isUStrip()) {
618 if (((layer == 0) && (m_svdShapers[digi]->getCellID() > 767)) ||
619 ((layer != 0) && (m_svdShapers[digi]->getCellID() > 511)))
620 B2WARNING(" SVDShaperDigits: unexpected cellID for Layer " << layer << " Ladder " << VxdID(theVxdID).getLadderNumber() <<
621 " Sensor " << VxdID(theVxdID).getSensorNumber() << " V side, strip = " << m_svdShapers[digi]->getCellID());
622 } else {
623 if (m_svdShapers[digi]->getCellID() > 767)
624 B2WARNING(" SVDShaperDigits: unexpected cellID for Layer " << layer << " Ladder " << VxdID(theVxdID).getLadderNumber() <<
625 " Sensor " << VxdID(theVxdID).getSensorNumber() << " U side, strip = " << m_svdShapers[digi]->getCellID());
626 }
627
628 }
629
630 //reco digits
631 if (m_svdRecos.isValid()) {
632 for (int digi = 0 ; digi < m_svdRecos.getEntries(); digi++) {
633
634 VxdID::baseType theVxdID = (VxdID::baseType)m_svdRecos[digi]->getSensorID();
635 int layer = VxdID(theVxdID).getLayerNumber() - 3;
636 int sensor = getSensor(layer, VxdID(theVxdID).getSensorNumber(), m_is2017TBanalysis);
637 int side = m_svdRecos[digi]->isUStrip();
638 int cellID = m_svdRecos[digi]->getCellID();
639
640 float thisNoise = m_NoiseCal.getNoiseInElectrons(theVxdID, side, cellID);
641
642 h_stripNoise[layer][sensor][side]->Fill(thisNoise);
643 h_recoCharge[layer][sensor][side]->Fill(m_svdRecos[digi]->getCharge());
644 h_recoEnergy[layer][sensor][side]->Fill(m_svdRecos[digi]->getCharge()*c_eTOkeV);
645 h_recoTime[layer][sensor][side]->Fill(m_svdRecos[digi]->getTime());
646 nRecoDigi[layer][sensor][side]++;
647 }
648 }
649
650 //clusters NOT related to tracks
651 for (int cl = 0 ; cl < m_svdClusters.getEntries(); cl++) {
652
653 float clCharge = m_svdClusters[cl]->getCharge();
654 float clEnergy = m_svdClusters[cl]->getCharge() * c_eTOkeV;
655 float clCoor = m_svdClusters[cl]->getPosition();
656 int clSize = m_svdClusters[cl]->getSize();
657 float clTime = m_svdClusters[cl]->getClsTime();
658 float clSN = m_svdClusters[cl]->getSNR();
659 float seed_maxbin = -1;
660
661 RelationVector<RecoTrack> theRC = DataStore::getRelationsWithObj<RecoTrack>(m_svdClusters[cl]);
662
663 if ((int)theRC.size() > 0)
664 continue;
665
666 //look for the max bin of the seed
667 RelationVector<SVDRecoDigit> theRecoDigits = DataStore::getRelationsWithObj<SVDRecoDigit>(m_svdClusters[cl]);
668 int index_seed = 0;
669 float charge = 0;
670 for (int r = 0; r < (int)theRecoDigits.size(); r++)
671 if (theRecoDigits.weight(r) > charge) {
672 index_seed = r;
673 charge = theRecoDigits[r]->getCharge();
674 }
675
676 if (index_seed > -1) {
677 RelationVector<SVDShaperDigit> theSeedShaperDigits = DataStore::getRelationsWithObj<SVDShaperDigit>(theRecoDigits[index_seed]);
678
679 Belle2::SVDShaperDigit::APVFloatSamples samples;
680 samples = theSeedShaperDigits[0]->getSamples();
681 float amplitude = 0;
682 const int nAPVSamples = 6;
683 for (int k = 0; k < nAPVSamples; k ++) {
684 if (samples[k] > amplitude) {
685 amplitude = samples[k];
686 seed_maxbin = k;
687 }
688 }
689 }
690
691 VxdID::baseType theVxdID = (VxdID::baseType)m_svdClusters[cl]->getSensorID();
692 int side = m_svdClusters[cl]->isUCluster();
693 int layer = VxdID(theVxdID).getLayerNumber() - 3;
694 int sensor = getSensor(layer, VxdID(theVxdID).getSensorNumber(), m_is2017TBanalysis);
695
696 for (int cl2 = 0 ; cl2 < cl; cl2++) {
697 if (clSize > 1)
698 break;
699
700 VxdID::baseType theVxdID2 = (VxdID::baseType)m_svdClusters[cl2]->getSensorID();
701 int side2 = m_svdClusters[cl2]->isUCluster();
702 int layer2 = VxdID(theVxdID2).getLayerNumber() - 3;
703 int sensor2 = getSensor(layer, VxdID(theVxdID2).getSensorNumber(), m_is2017TBanalysis);
704
705 float clCoor1 = m_svdClusters[cl]->getPosition();
706 float clCoor2 = m_svdClusters[cl2]->getPosition();
707 float clEnergy1 = m_svdClusters[cl]->getCharge() * c_eTOkeV;
708 float clEnergy2 = m_svdClusters[cl2]->getCharge() * c_eTOkeV;
709 if ((layer != layer2) || (sensor != sensor2))
710 continue;
711
712 if (seed_maxbin < 2 || seed_maxbin > 4)
713 continue;
714
715 int cellID1 = -1;
716 for (int r = 0; r < (int)theRecoDigits.size(); r++)
717 if (cellID1 < theRecoDigits[r]->getCellID())
718 cellID1 = theRecoDigits[r]->getCellID();
719
720 RelationVector<SVDRecoDigit> theRecoDigits2 = DataStore::getRelationsWithObj<SVDRecoDigit>(m_svdClusters[cl2]);
721 int dist = 768;
722 for (int r = 0; r < (int)theRecoDigits2.size(); r++)
723 if (cellID1 - theRecoDigits2[r]->getCellID() < dist)
724 dist = cellID1 - theRecoDigits2[r]->getCellID();
725
726 if (side == 1 && side2 == 1) {
727 h_clCoor1VSCoor2[layer][sensor][1]->Fill(clCoor1 - clCoor2); //
728 h_clCellID1VSCellID2[layer][sensor][1]->Fill(dist);
729 h_clEnergy12VSdelta[layer][sensor][1]->Fill(clEnergy1 + clEnergy2, dist); //
730 }
731 if (side == 0 && side2 == 0) {
732 h_clCoor1VSCoor2[layer][sensor][0]->Fill(clCoor1 - clCoor2); //
733 h_clCellID1VSCellID2[layer][sensor][0]->Fill(dist);
734 h_clEnergy12VSdelta[layer][sensor][0]->Fill(clEnergy1 + clEnergy2, dist); //
735 }
736
737 if (side == 1 && side2 == 0) {
738 h_clCoorUVSCoorV[layer][sensor]->Fill(clCoor2, clCoor1); //V, U
739 h_clEnergyUVSEnergyV[layer][sensor]->Fill(clEnergy2, clEnergy1); //V, U
740 }
741 if (side == 0 && side2 == 1) {
742 h_clCoorUVSCoorV[layer][sensor]->Fill(clCoor1, clCoor2);
743 h_clEnergyUVSEnergyV[layer][sensor]->Fill(clEnergy1, clEnergy2);
744 }
745 }
746
747 nCl[layer][sensor][side]++;
748
749
750 h_clCharge[layer][sensor][side]->Fill(clCharge);
751 h_clEnergy[layer][sensor][side]->Fill(clEnergy);
752 h_clSeedMaxbin[layer][sensor][side]->Fill(seed_maxbin);
753 h_clEnergyVSMaxbin[layer][sensor][side]->Fill(clEnergy, seed_maxbin);
754 if (seed_maxbin < 2)
755 h_clEnergyVSSize_mb12[layer][sensor][side]->Fill(clEnergy, clSize);
756 else if (seed_maxbin == 5)
757 h_clEnergyVSSize_mb6[layer][sensor][side]->Fill(clEnergy, clSize);
758 else {
759 h_clEnergyVSSize_mb345[layer][sensor][side]->Fill(clEnergy, clSize);
760 nCl345[layer][sensor][side]++;
761 if (m_svdClusters[cl]->isUCluster())
762 h_clEnergyVSCoorU[layer][sensor][side]->Fill(clEnergy, clCoor);
763 else
764 h_clEnergyVSCoorV[layer][sensor][side]->Fill(clEnergy, clCoor);
765 }
766 h_clSize[layer][sensor][side]->Fill(clSize);
767 h_clSN[layer][sensor][side]->Fill(clSN);
768 h_clTime[layer][sensor][side]->Fill(clTime);
769
770 h_clChargeVSSize[layer][sensor][side]->Fill(clCharge, clSize);
771 h_clSNVSSize[layer][sensor][side]->Fill(clSN, clSize);
772 h_clTimeVSSize[layer][sensor][side]->Fill(clTime, clSize);
773
774 if (m_isSimulation) {
775 RelationVector<SVDTrueHit> svdTrueHits = DataStore::getRelationsWithObj<SVDTrueHit>(m_svdClusters[cl]);
776 if (svdTrueHits.size() > 0)
777 h_clTimeVSTrueTime[layer][sensor][side]->Fill(m_svdClusters[cl]->getClsTime(), svdTrueHits[0]->getGlobalTime());
778 }
779
780 }
781
782 for (int i = 0; i < m_nLayers; i ++) //loop on Layers
783 for (int j = 0; j < (int)sensorsOnLayer[i]; j ++) //loop on Sensors
784 for (int k = 0; k < m_nSides; k ++) { //loop on Sides
785 h_nShaper[i][j][k]->Fill(nShaperDigi[i][j][k]);
786 h_nReco[i][j][k]->Fill(nRecoDigi[i][j][k]);
787 h_nCl[i][j][k]->Fill(nCl[i][j][k]);
788 h_clNuVSNv[i][j]->Fill(nCl345[i][j][0], nCl345[i][j][1]);
789 h_nCltrk[i][j][k]->Fill(nCltrk[i][j][k]);
790 }
791}
792
793
794
795void SVDPerformanceModule::endRun()
796{
797
798 /*
799 B2RESULT(" number tracks = " << m_ntracks);
800 B2RESULT(" average number of cluster per layer:");
801 B2RESULT(" Layer 3, u = " << h_nCl_L3u->GetMean() << ", v = " << h_nCl_L3v->GetMean());
802 B2RESULT(" Layer 4, u = " << h_nCl_L4u->GetMean() << ", v = " << h_nCl_L4v->GetMean());
803 B2RESULT(" Layer 5, u = " << h_nCl_L5u->GetMean() << ", v = " << h_nCl_L5v->GetMean());
804 B2RESULT(" Layer 6, u = " << h_nCl_L6u->GetMean() << ", v = " << h_nCl_L6v->GetMean());
805 B2RESULT(" average cluster size per layer:");
806 B2RESULT(" Layer 3, u = " << h_clSize_L3u->GetMean() << ", v = " << h_clSize_L3v->GetMean());
807 B2RESULT(" Layer 4, u = " << h_clSize_L4u->GetMean() << ", v = " << h_clSize_L4v->GetMean());
808 */
809 if (m_rootFilePtr != nullptr) {
810 m_rootFilePtr->cd();
811
812 TDirectory* oldDir = gDirectory;
813 TObject* obj;
814
815 TDirectory* dir_track = oldDir->mkdir("tracks");
816 dir_track->cd();
817 TIter nextH_track(m_histoList_track);
818 while ((obj = nextH_track())) {
819 if (obj->InheritsFrom("TH1F"))((TH1F*)obj)->Scale(1. / m_nEvents);
820 obj->Write();
821 }
822
823
824 TDirectory* dir_shaper = oldDir->mkdir("shaper");
825 dir_shaper->cd();
826 for (int i = 0; i < m_nLayers; i++) {
827 TString layerName = "shaperL";
828 layerName += i + 3;
829 TDirectory* dir_layer = dir_shaper->mkdir(layerName.Data());
830 dir_layer->cd();
831 TIter nextH_shaper(m_histoList_shaper[i]);
832 while ((obj = nextH_shaper())) {
833 if (obj->InheritsFrom("TH1F"))((TH1F*)obj)->Scale(1. / m_nEvents);
834 obj->Write();
835 }
836 }
837
838
839 TDirectory* dir_reco = oldDir->mkdir("reco");
840 dir_reco->cd();
841 for (int i = 0; i < m_nLayers; i++) {
842 TString layerName = "recoL";
843 layerName += i + 3;
844 TDirectory* dir_layer = dir_reco->mkdir(layerName.Data());
845 dir_layer->cd();
846 TIter nextH_reco(m_histoList_reco[i]);
847 while ((obj = nextH_reco())) {
848 if (obj->InheritsFrom("TH1F"))((TH1F*)obj)->Scale(1. / m_nEvents);
849 obj->Write();
850 }
851 }
852
853 TDirectory* dir_cluster = oldDir->mkdir("clusters");
854 dir_cluster->cd();
855 for (int i = 0; i < m_nLayers; i++) {
856 TString layerName = "clusterL";
857 layerName += i + 3;
858 TDirectory* dir_layer = dir_cluster->mkdir(layerName.Data());
859 dir_layer->cd();
860 TIter nextH_cluster(m_histoList_cluster[i]);
861 while ((obj = nextH_cluster())) {
862 if (obj->InheritsFrom("TH1F"))((TH1F*)obj)->Scale(1. / m_nEvents);
863 obj->Write();
864 }
865 }
866
867 TDirectory* dir_clTRK = oldDir->mkdir("clustersTrk");
868 dir_clTRK->cd();
869 for (int i = 0; i < m_nLayers; i++) {
870 TString layerName = "clstrkL";
871 layerName += i + 3;
872 TDirectory* dir_layer = dir_clTRK->mkdir(layerName.Data());
873 dir_layer->cd();
874 TIter nextH_clTRK(m_histoList_clTRK[i]);
875 while ((obj = nextH_clTRK())) {
876 if (obj->InheritsFrom("TH1F"))((TH1F*)obj)->Scale(1. / m_nEvents);
877 obj->Write();
878 }
879 }
880
881 oldDir->cd();
882 TIter nextH_corr(m_histoList_corr);
883 while ((obj = nextH_corr())) {
884 if (obj->InheritsFrom("TH1F"))
885 ((TH1F*)obj)->Scale(1. / m_nEvents);
886 obj->Write();
887 }
888
889 m_rootFilePtr->Close();
890
891
892 }
893
894
895
896}
897
898
899TH1F* SVDPerformanceModule::createHistogram1D(const char* name, const char* title,
900 Int_t nbins, Double_t min, Double_t max,
901 const char* xtitle, TList* histoList)
902{
903
904 TH1F* h = new TH1F(name, title, nbins, min, max);
905
906 h->GetXaxis()->SetTitle(xtitle);
907
908 if (histoList)
909 histoList->Add(h);
910
911 return h;
912}
913
914
915TH2F* SVDPerformanceModule::createHistogram2D(const char* name, const char* title,
916 Int_t nbinsX, Double_t minX, Double_t maxX,
917 const char* titleX,
918 Int_t nbinsY, Double_t minY, Double_t maxY,
919 const char* titleY, TList* histoList)
920{
921
922 TH2F* h = new TH2F(name, title, nbinsX, minX, maxX, nbinsY, minY, maxY);
923
924 h->GetXaxis()->SetTitle(titleX);
925 h->GetYaxis()->SetTitle(titleY);
926
927 if (histoList)
928 histoList->Add(h);
929
930 return h;
931}
932
933
Belle2::Const::pion
static const ChargedStable pion
charged pion particle
Definition: Const.h:661
Belle2::Const::electron
static const ChargedStable electron
electron particle
Definition: Const.h:659
Belle2::Module
Base class for Modules.
Definition: Module.h:72
Belle2::Module::setDescription
void setDescription(const std::string &description)
Sets the description of the module.
Definition: Module.cc:214
Belle2::RelationVector
Class for type safe access to objects that are referred to in relations.
Definition: RelationVector.h:67
Belle2::RelationVector::size
size_t size() const
Get number of relations.
Definition: RelationVector.h:88
Belle2::RelationVector::weight
float weight(int index) const
Get weight with index.
Definition: RelationVector.h:110
Belle2::SVDModeByte
Class to store SVD mode information.
Definition: SVDModeByte.h:69
Belle2::SVDModeByte::getTriggerBin
baseType getTriggerBin() const
Get the triggerBin id.
Definition: SVDModeByte.h:140
Belle2::SVDModeByte::baseType
uint8_t baseType
The base integer type for SVDModeByte.
Definition: SVDModeByte.h:72
Belle2::SVDNoiseCalibrations::getNoiseInElectrons
float getNoiseInElectrons(const VxdID &sensorID, const bool &isU, const unsigned short &strip) const
This method provides the correct noise conversion into electrons, taking into account that the noise ...
Definition: SVDNoiseCalibrations.h:83
Belle2::SVDPerformanceModule::m_rootFileName
std::string m_rootFileName
root file name
Definition: SVDPerformanceModule.h:68
Belle2::SVDPerformanceModule::h_cltrkTimeVSTrueTime
TH2F * h_cltrkTimeVSTrueTime[m_nLayers][m_nSensors][m_nSides]
time VS true time
Definition: SVDPerformanceModule.h:163
Belle2::SVDPerformanceModule::m_debugLowTime
float m_debugLowTime
cluster Time below this number will produce a printout
Definition: SVDPerformanceModule.h:64
Belle2::SVDPerformanceModule::h_cltrk_UU
TH1F * h_cltrk_UU
U time vs U time.
Definition: SVDPerformanceModule.h:174
Belle2::SVDPerformanceModule::h_recoTime
TH1F * h_recoTime[m_nLayers][m_nSensors][m_nSides]
time
Definition: SVDPerformanceModule.h:122
Belle2::SVDPerformanceModule::h_cltrkChargeVSSize
TH2F * h_cltrkChargeVSSize[m_nLayers][m_nSensors][m_nSides]
charge VS size
Definition: SVDPerformanceModule.h:160
Belle2::SVDPerformanceModule::createHistogram1D
TH1F * createHistogram1D(const char *name, const char *title, Int_t nbins, Double_t min, Double_t max, const char *xtitle, TList *histoList=nullptr)
Function returning a TH1F.
Definition: SVDPerformanceModule.cc:899
Belle2::SVDPerformanceModule::h_cltrkSNVSSize
TH2F * h_cltrkSNVSSize[m_nLayers][m_nSensors][m_nSides]
charge VS size
Definition: SVDPerformanceModule.h:161
Belle2::SVDPerformanceModule::h_clTime
TH1F * h_clTime[m_nLayers][m_nSensors][m_nSides]
time
Definition: SVDPerformanceModule.h:140
Belle2::SVDPerformanceModule::m_histoList_reco
TList * m_histoList_reco[m_nLayers]
histo list reco digits
Definition: SVDPerformanceModule.h:106
Belle2::SVDPerformanceModule::m_histoList_corr
TList * m_histoList_corr
histo list correlations
Definition: SVDPerformanceModule.h:102
Belle2::SVDPerformanceModule::h_clEnergyVSSize_mb6
TH2F * h_clEnergyVSSize_mb6[m_nLayers][m_nSensors][m_nSides]
energy VS size, max bin == 6
Definition: SVDPerformanceModule.h:144
Belle2::SVDPerformanceModule::h_clCoor1VSCoor2
TH1F * h_clCoor1VSCoor2[m_nLayers][m_nSensors][m_nSides]
coor1 VS coor2
Definition: SVDPerformanceModule.h:135
Belle2::SVDPerformanceModule::h_clEnergyUVSEnergyV
TH2F * h_clEnergyUVSEnergyV[m_nLayers][m_nSensors]
energy VS position
Definition: SVDPerformanceModule.h:138
Belle2::SVDPerformanceModule::h_cltrkEnergy
TH1F * h_cltrkEnergy[m_nLayers][m_nSensors][m_nSides]
energy
Definition: SVDPerformanceModule.h:153
Belle2::SVDPerformanceModule::h_clNuVSNv
TH2F * h_clNuVSNv[m_nLayers][m_nSensors]
N U culsters VS N V clusters.
Definition: SVDPerformanceModule.h:133
Belle2::SVDPerformanceModule::m_ShaperDigitName
std::string m_ShaperDigitName
ShaperDigits Store Array name.
Definition: SVDPerformanceModule.h:56
Belle2::SVDPerformanceModule::initialize
virtual void initialize() override
check StoreArrays & create rootfile
Definition: SVDPerformanceModule.cc:43
Belle2::SVDPerformanceModule::h_clEnergyVSCoorV
TH2F * h_clEnergyVSCoorV[m_nLayers][m_nSensors][m_nSides]
energy VS position V
Definition: SVDPerformanceModule.h:132
Belle2::SVDPerformanceModule::m_svdClusters
StoreArray< SVDCluster > m_svdClusters
SVDCluster store array.
Definition: SVDPerformanceModule.h:82
Belle2::SVDPerformanceModule::event
virtual void event() override
fill histograms
Definition: SVDPerformanceModule.cc:424
Belle2::SVDPerformanceModule::h_clCharge
TH1F * h_clCharge[m_nLayers][m_nSensors][m_nSides]
charge
Definition: SVDPerformanceModule.h:127
Belle2::SVDPerformanceModule::sensorsOnLayer
unsigned int sensorsOnLayer[4]
sensors on layer i
Definition: SVDPerformanceModule.h:99
Belle2::SVDPerformanceModule::h_clEnergyVSMaxbin
TH2F * h_clEnergyVSMaxbin[m_nLayers][m_nSensors][m_nSides]
energy VS maxbin seed
Definition: SVDPerformanceModule.h:130
Belle2::SVDPerformanceModule::h_nCltrk
TH1F * h_nCltrk[m_nLayers][m_nSensors][m_nSides]
number per event
Definition: SVDPerformanceModule.h:150
Belle2::SVDPerformanceModule::h_cltrk_VV
TH1F * h_cltrk_VV
V time vs V time.
Definition: SVDPerformanceModule.h:175
Belle2::SVDPerformanceModule::m_NoiseCal
SVDNoiseCalibrations m_NoiseCal
SVDNoise calibration db object.
Definition: SVDPerformanceModule.h:77
Belle2::SVDPerformanceModule::endRun
virtual void endRun() override
write histogrmas
Definition: SVDPerformanceModule.cc:795
Belle2::SVDPerformanceModule::h_cltrkCharge
TH1F * h_cltrkCharge[m_nLayers][m_nSensors][m_nSides]
charge
Definition: SVDPerformanceModule.h:152
Belle2::SVDPerformanceModule::h_recoCharge
TH1F * h_recoCharge[m_nLayers][m_nSensors][m_nSides]
charge
Definition: SVDPerformanceModule.h:119
Belle2::SVDPerformanceModule::m_nLayers
static const int m_nLayers
max number of layers
Definition: SVDPerformanceModule.h:95
Belle2::SVDPerformanceModule::h_cltrkTime_L4uL5u
TH2F * h_cltrkTime_L4uL5u
L4U time VS L5U time.
Definition: SVDPerformanceModule.h:178
Belle2::SVDPerformanceModule::h_cltrkTime_TB3
TH1F * h_cltrkTime_TB3[m_nLayers][m_nSensors][m_nSides]
time
Definition: SVDPerformanceModule.h:158
Belle2::SVDPerformanceModule::h_cltrkTimeVSSize
TH2F * h_cltrkTimeVSSize[m_nLayers][m_nSensors][m_nSides]
charge VS size
Definition: SVDPerformanceModule.h:162
Belle2::SVDPerformanceModule::h_clEnergyVSSize_mb12
TH2F * h_clEnergyVSSize_mb12[m_nLayers][m_nSensors][m_nSides]
energy VS size, maxbin == 1,2
Definition: SVDPerformanceModule.h:142
Belle2::SVDPerformanceModule::h_2cltrkCharge
TH1F * h_2cltrkCharge[m_nLayers][m_nSensors][m_nSides]
charge
Definition: SVDPerformanceModule.h:170
Belle2::SVDPerformanceModule::h_nShaper
TH1F * h_nShaper[m_nLayers][m_nSensors][m_nSides]
number per event
Definition: SVDPerformanceModule.h:115
Belle2::SVDPerformanceModule::m_nSides
static const int m_nSides
max number of sides
Definition: SVDPerformanceModule.h:97
Belle2::SVDPerformanceModule::h_cltrkTime_L5uL5v
TH2F * h_cltrkTime_L5uL5v
L5U time VS L5V time.
Definition: SVDPerformanceModule.h:180
Belle2::SVDPerformanceModule::h_cltrkTime_TB4
TH1F * h_cltrkTime_TB4[m_nLayers][m_nSensors][m_nSides]
time
Definition: SVDPerformanceModule.h:159
Belle2::SVDPerformanceModule::h_clTimeVSTrueTime
TH2F * h_clTimeVSTrueTime[m_nLayers][m_nSensors][m_nSides]
time VS true time
Definition: SVDPerformanceModule.h:147
Belle2::SVDPerformanceModule::h_1cltrkCharge
TH1F * h_1cltrkCharge[m_nLayers][m_nSensors][m_nSides]
charge
Definition: SVDPerformanceModule.h:166
Belle2::SVDPerformanceModule::m_TrackName
std::string m_TrackName
Track StoreArray name.
Definition: SVDPerformanceModule.h:60
Belle2::SVDPerformanceModule::m_RecoDigitName
std::string m_RecoDigitName
SVDRecoDigits Store Array name.
Definition: SVDPerformanceModule.h:57
Belle2::SVDPerformanceModule::h_clEnergyVSSize_mb345
TH2F * h_clEnergyVSSize_mb345[m_nLayers][m_nSensors][m_nSides]
energy VS size, maxbin == 3,4,5
Definition: SVDPerformanceModule.h:143
Belle2::SVDPerformanceModule::beginRun
virtual void beginRun() override
create histograms
Definition: SVDPerformanceModule.cc:419
Belle2::SVDPerformanceModule::h_nCl
TH1F * h_nCl[m_nLayers][m_nSensors][m_nSides]
number per event
Definition: SVDPerformanceModule.h:125
Belle2::SVDPerformanceModule::h_clEnergyVSCoorU
TH2F * h_clEnergyVSCoorU[m_nLayers][m_nSensors][m_nSides]
energy VS position U
Definition: SVDPerformanceModule.h:131
Belle2::SVDPerformanceModule::h_1cltrkSN
TH1F * h_1cltrkSN[m_nLayers][m_nSensors][m_nSides]
signal over noise
Definition: SVDPerformanceModule.h:167
Belle2::SVDPerformanceModule::h_clCellID1VSCellID2
TH1F * h_clCellID1VSCellID2[m_nLayers][m_nSensors][m_nSides]
coor1 VS coor2
Definition: SVDPerformanceModule.h:137
Belle2::SVDPerformanceModule::h_2cltrkSN
TH1F * h_2cltrkSN[m_nLayers][m_nSensors][m_nSides]
signal over noise
Definition: SVDPerformanceModule.h:171
Belle2::SVDPerformanceModule::h_cltrkTime_TB2
TH1F * h_cltrkTime_TB2[m_nLayers][m_nSensors][m_nSides]
time
Definition: SVDPerformanceModule.h:157
Belle2::SVDPerformanceModule::m_svdEventInfoName
std::string m_svdEventInfoName
Name of the SVDEventInfo object.
Definition: SVDPerformanceModule.h:91
Belle2::SVDPerformanceModule::m_histoList_track
TList * m_histoList_track
histo list tracks
Definition: SVDPerformanceModule.h:101
Belle2::SVDPerformanceModule::m_isSimulation
bool m_isSimulation
true if we analyze Simulated data
Definition: SVDPerformanceModule.h:62
Belle2::SVDPerformanceModule::h_cltrk_UV
TH1F * h_cltrk_UV
U time vs V time.
Definition: SVDPerformanceModule.h:176
Belle2::SVDPerformanceModule::m_TrackFitResultName
std::string m_TrackFitResultName
TrackFitResult StoreArray name.
Definition: SVDPerformanceModule.h:59
Belle2::SVDPerformanceModule::m_histoList_clTRK
TList * m_histoList_clTRK[m_nLayers]
histo list clusters related to tracks
Definition: SVDPerformanceModule.h:103
Belle2::SVDPerformanceModule::h_clEnergy12VSdelta
TH2F * h_clEnergy12VSdelta[m_nLayers][m_nSensors][m_nSides]
coor1 VS coor2
Definition: SVDPerformanceModule.h:136
Belle2::SVDPerformanceModule::m_nTracks
TH1F * m_nTracks
number of tracks
Definition: SVDPerformanceModule.h:109
Belle2::SVDPerformanceModule::h_clCoorUVSCoorV
TH2F * h_clCoorUVSCoorV[m_nLayers][m_nSensors]
energy VS position
Definition: SVDPerformanceModule.h:134
Belle2::SVDPerformanceModule::h_clEnergy
TH1F * h_clEnergy[m_nLayers][m_nSensors][m_nSides]
energy
Definition: SVDPerformanceModule.h:128
Belle2::SVDPerformanceModule::h_clSN
TH1F * h_clSN[m_nLayers][m_nSensors][m_nSides]
signal over noise
Definition: SVDPerformanceModule.h:139
Belle2::SVDPerformanceModule::m_nSensors
static const int m_nSensors
max number of sensors
Definition: SVDPerformanceModule.h:96
Belle2::SVDPerformanceModule::m_histoList_shaper
TList * m_histoList_shaper[m_nLayers]
histo list shaper digits
Definition: SVDPerformanceModule.h:105
Belle2::SVDPerformanceModule::h_clChargeVSSize
TH2F * h_clChargeVSSize[m_nLayers][m_nSensors][m_nSides]
charge VS size
Definition: SVDPerformanceModule.h:141
Belle2::SVDPerformanceModule::m_ClusterName
std::string m_ClusterName
SVDCluster StoreArray name.
Definition: SVDPerformanceModule.h:58
Belle2::SVDPerformanceModule::h_cltrkSize
TH1F * h_cltrkSize[m_nLayers][m_nSensors][m_nSides]
size
Definition: SVDPerformanceModule.h:151
Belle2::SVDPerformanceModule::h_stripNoise
TH1F * h_stripNoise[m_nLayers][m_nSensors][m_nSides]
strip noise
Definition: SVDPerformanceModule.h:121
Belle2::SVDPerformanceModule::h_clSeedMaxbin
TH1F * h_clSeedMaxbin[m_nLayers][m_nSensors][m_nSides]
maxbin seed
Definition: SVDPerformanceModule.h:129
Belle2::SVDPerformanceModule::h_nReco
TH1F * h_nReco[m_nLayers][m_nSensors][m_nSides]
number per event
Definition: SVDPerformanceModule.h:118
Belle2::SVDPerformanceModule::m_svdRecos
StoreArray< SVDRecoDigit > m_svdRecos
SVDRecoDigits store array.
Definition: SVDPerformanceModule.h:81
Belle2::SVDPerformanceModule::createHistogram2D
TH2F * createHistogram2D(const char *name, const char *title, Int_t nbinsX, Double_t minX, Double_t maxX, const char *titleX, Int_t nbinsY, Double_t minY, Double_t maxY, const char *titleY, TList *histoList=nullptr)
Function returning TH2F.
Definition: SVDPerformanceModule.cc:915
Belle2::SVDPerformanceModule::h_clSNVSSize
TH2F * h_clSNVSSize[m_nLayers][m_nSensors][m_nSides]
charge VS size
Definition: SVDPerformanceModule.h:145
Belle2::SVDPerformanceModule::h_clTimeVSSize
TH2F * h_clTimeVSSize[m_nLayers][m_nSensors][m_nSides]
charge VS size
Definition: SVDPerformanceModule.h:146
Belle2::SVDPerformanceModule::m_Tracks
StoreArray< Track > m_Tracks
Tracks store array.
Definition: SVDPerformanceModule.h:84
Belle2::SVDPerformanceModule::h_recoEnergy
TH1F * h_recoEnergy[m_nLayers][m_nSensors][m_nSides]
energy
Definition: SVDPerformanceModule.h:120
Belle2::SVDPerformanceModule::m_storeSVDEvtInfo
StoreObjPtr< SVDEventInfo > m_storeSVDEvtInfo
Storage for SVDEventInfo object.
Definition: SVDPerformanceModule.h:88
Belle2::SVDPerformanceModule::m_rootFilePtr
TFile * m_rootFilePtr
pointer at root file used for storing histograms
Definition: SVDPerformanceModule.h:71
Belle2::SVDPerformanceModule::h_cltrkTime_L4vL5v
TH2F * h_cltrkTime_L4vL5v
L4V time VS L5V time.
Definition: SVDPerformanceModule.h:179
Belle2::SVDPerformanceModule::getSensor
int getSensor(int layer, int sensor, bool isTB)
get sensor number
Definition: SVDPerformanceModule.h:183
Belle2::SVDPerformanceModule::m_is2017TBanalysis
bool m_is2017TBanalysis
true if we analyze 2017 TB data
Definition: SVDPerformanceModule.h:61
Belle2::SVDPerformanceModule::h_cltrkTime
TH1F * h_cltrkTime[m_nLayers][m_nSensors][m_nSides]
time
Definition: SVDPerformanceModule.h:155
Belle2::SVDPerformanceModule::m_histoList_cluster
TList * m_histoList_cluster[m_nLayers]
histo list clusters
Definition: SVDPerformanceModule.h:104
Belle2::SVDPerformanceModule::h_clSize
TH1F * h_clSize[m_nLayers][m_nSensors][m_nSides]
size
Definition: SVDPerformanceModule.h:126
Belle2::SVDPerformanceModule::m_svdShapers
StoreArray< SVDShaperDigit > m_svdShapers
SVDShaperDigit store array.
Definition: SVDPerformanceModule.h:80
Belle2::SVDPerformanceModule::h_cltrkTime_TB1
TH1F * h_cltrkTime_TB1[m_nLayers][m_nSensors][m_nSides]
time
Definition: SVDPerformanceModule.h:156
Belle2::SVDPerformanceModule::h_cltrkSN
TH1F * h_cltrkSN[m_nLayers][m_nSensors][m_nSides]
signal over noise
Definition: SVDPerformanceModule.h:154
Belle2::SVDShaperDigit::APVFloatSamples
std::array< APVFloatSampleType, c_nAPVSamples > APVFloatSamples
array of APVFloatSampleType objects
Definition: SVDShaperDigit.h:49
Belle2::StoreAccessorBase::isRequired
bool isRequired(const std::string &name="")
Ensure this array/object has been registered previously.
Definition: StoreAccessorBase.h:78
Belle2::StoreArray::getEntries
int getEntries() const
Get the number of objects in the array.
Definition: StoreArray.h:216
Belle2::TrackFitResult
Values of the result of a track fit with a given particle hypothesis.
Definition: TrackFitResult.h:49
Belle2::TrackFitResult::getPValue
double getPValue() const
Getter for Chi2 Probability of the track fit.
Definition: TrackFitResult.h:164
Belle2::TrackFitResult::getMomentum
ROOT::Math::XYZVector getMomentum() const
Getter for vector of momentum at closest approach of track in r/phi projection.
Definition: TrackFitResult.h:116
Belle2::TrackFitResult::getHitPatternVXD
HitPatternVXD getHitPatternVXD() const
Getter for the hit pattern in the VXD;.
Definition: TrackFitResult.cc:139
Belle2::Track
Class that bundles various TrackFitResults.
Definition: Track.h:25
Belle2::VxdID
Class to uniquely identify a any structure of the PXD and SVD.
Definition: VxdID.h:33
Belle2::VxdID::baseType
unsigned short baseType
The base integer type for VxdID.
Definition: VxdID.h:36
Belle2::VxdID::getLayerNumber
baseType getLayerNumber() const
Get the layer id.
Definition: VxdID.h:96
Belle2::Module::addParam
void addParam(const std::string &name, T &paramVariable, const std::string &description, const T &defaultValue)
Adds a new parameter to the module.
Definition: Module.h:559
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.