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