Belle II Software  release-05-02-19
validatePhase2Cosmics.py
1 #!/usr/bin/env python3
2 # -*- coding: utf-8 -*-
3 
4 # *****************************************************************************
5 
6 # title : 3_ValidationCosmics.py
7 # description : Validation of cosmic tracks in phase II
8 # author : Jakub Kandra (jakub.kandra@karlov.mff.cuni.cz)
9 # date : 8. 2. 2018
10 
11 # *****************************************************************************
12 
13 from modularAnalysis import *
14 import math
15 from basf2 import *
16 
17 import ROOT
18 from ROOT import Belle2
19 from ROOT import gROOT, AddressOf
20 from ROOT import TrackData, DEDXData
21 import reconstruction as reco
22 
23 gROOT.ProcessLine('struct TrackData {\
24  float chi2;\
25  float ndf;\
26  float chiSquaredOverNdf;\
27  float momentum;\
28 };')
29 
30 gROOT.ProcessLine('struct DEDXData {\
31  float acdCount;\
32  float dE;\
33  float path;\
34  float momentumCDC;\
35  int numberOfHits;\
36  float distanceKLM;\
37 };')
38 
39 
40 class CosmicAnalysis(Module):
41 
42  """A module to analyse residuals in overlaps of ladders."""
43 
44  def __init__(self):
45  """Initialize the module"""
46 
47  super(CosmicAnalysis, self).__init__()
48 
49 
50  self.rootfile = ROOT.TFile('cosmicAnalysis.root', 'recreate')
51 
52  self.tree_track = ROOT.TTree('track', '')
53 
54  self.tree_DEDX = ROOT.TTree('dedx', '')
55 
56  ROOT.gStyle.Reset()
57  ROOT.gStyle.SetCanvasColor(0)
58  ROOT.gStyle.SetStatBorderSize(1)
59  ROOT.gStyle.SetStatColor(0)
60  ROOT.gStyle.SetTitleColor(1)
61  ROOT.gStyle.SetCanvasColor(0)
62  ROOT.gStyle.SetPadColor(0)
63  ROOT.gStyle.SetPadBorderMode(0)
64  ROOT.gStyle.SetCanvasBorderMode(0)
65  ROOT.gStyle.SetFrameBorderMode(0)
66  ROOT.gStyle.SetOptStat(0)
67 
68 
69  self.trackData = TrackData()
70  # Declare tree branches
71  for key in TrackData.__dict__:
72  if '__' not in key:
73  formstring = '/F'
74  if isinstance(self.trackData.__getattribute__(key), int):
75  formstring = '/I'
76  self.tree_track.Branch(key, AddressOf(self.trackData, key), key + formstring)
77 
78  self.dedxData = DEDXData()
79  # Declare tree branches
80  for key in DEDXData.__dict__:
81  if '__' not in key:
82  formstring = '/F'
83  if isinstance(self.dedxData.__getattribute__(key), int):
84  formstring = '/I'
85  self.tree_DEDX.Branch(key, AddressOf(self.dedxData, key), key + formstring)
86 
87  self.TotalNumberOfHits = ROOT.TH1F('TotalNumberOfHits', '', 6, 0.5, 6.5)
88 
89  self.HitsVsLayer = ROOT.TH2F('HitsVsLayer', '', 6, 0.5, 6.5, 6, 0.5, 6.5)
90 
91  self.HitsVsSensor = ROOT.TH2F('HitsVsSensor', '', 6, 0.5, 6.5, 5, 0.5, 5.5)
92 
93  self.LayerVsSensor = ROOT.TH2F('LayerVsSensor', '', 6, 0.5, 6.5, 5, 0.5, 5.5)
94 
95  self.PXDClusterSize = ROOT.TH1F('PXDClusterSize', '', 20, 0.5, 20.5)
96 
97  self.Chi2 = ROOT.TH1F('Chi2', '', 300, 0.0, 500)
98 
99  self.NDF = ROOT.TH1F('NDF', '', 200, 0.0, 200)
100 
101  self.Chi2OverNDF = ROOT.TH1F('Chi2OverNDF', '', 300, 0.0, 5)
102 
103  self.Momentum = ROOT.TH1F('Momentum', '', 500, 0.0, 1000)
104 
105  self.ADCCountOverNumberOfHitsInCDC = ROOT.TH1F('ADCCountOverNumberOfHitsInCDC', '', 200, 0.0, 300)
106 
107  self.ADCCountOverNumberOfHitsInCDCVsMomentum = ROOT.TProfile(
108  'ADCCountOverNumberOfHitsInCDCVsMomentum', '', 200, 0.0, 300, 0.0, 1000)
109 
110  self.MomentumVsADCCountOverNumberOfHitsInCDC = ROOT.TProfile(
111  'MomentumVsADCCountOverNumberOfHitsInCDC', '', 100, 0.0, 100, 0.0, 1000)
112 
113  def beginRun(self):
114  """Do nothing"""
115 
116  def event(self):
117  """ Fill histograms """
118 
119  # Study dEdx (CDC) as prediction of momentum
120  cdcDedxTracks = Belle2.PyStoreArray('CDCDedxTracks')
121  nCDCDedxTracks = cdcDedxTracks.getEntries()
122  for DEDXTrack_index in range(nCDCDedxTracks):
123  dedxTrack = cdcDedxTracks[DEDXTrack_index]
124  self.dedxData.momentumCDC = dedxTrack.getMomentum()
125  self.dedxData.acdCount = 0
126  self.dedxData.dE = 0
127  self.dedxData.path = 0
128  self.dedxData.numberOfHits = dedxTrack.size()
129  KLMClusters = Belle2.PyStoreArray('KLMClusters')
130  nKLMClusters = KLMClusters.getEntries()
131  if nKLMClusters == 2:
132  for nHit in range(dedxTrack.size()):
133  self.dedxData.acdCount = self.dedxData.acdCount + dedxTrack.getADCCount(nHit)
134  self.dedxData.dE = self.dedxData.dE + dedxTrack.getDE(nHit)
135  self.dedxData.path = self.dedxData.path + dedxTrack.getPath(nHit)
136  self.dedxData.distanceKLM = math.sqrt(
137  math.pow(
138  KLMClusters[0].getClusterPosition().Z() -
139  KLMClusters[1].getClusterPosition().Z(),
140  2))
141 
142  self.ADCCountOverNumberOfHitsInCDC.Fill(self.dedxData.acdCount / dedxTrack.size())
143  self.MomentumVsADCCountOverNumberOfHitsInCDC.Fill(
144  self.dedxData.momentumCDC, self.dedxData.acdCount / dedxTrack.size())
145  self.ADCCountOverNumberOfHitsInCDCVsMomentum.Fill(
146  self.dedxData.acdCount / dedxTrack.size(), self.dedxData.momentumCDC)
147 
148  self.rootfile.cd()
149  self.tree_DEDX.Fill()
150 
151  # We are using RecoTracks to finding overlaps.
152  RecoTracks = Belle2.PyStoreArray('RecoTracks')
153  nRecoTracks = RecoTracks.getEntries()
154  geoCache = Belle2.VXD.GeoCache.getInstance()
155  for track_index in range(nRecoTracks):
156  track = RecoTracks[track_index]
157 
158  if track.wasFitSuccessful():
159 
160  TrackFitResults = Belle2.PyStoreArray('TrackFitResults')
161  nTrackFitResults = TrackFitResults.getEntries()
162  if nTrackFitResults == 1:
163  self.trackData.momentum = TrackFitResults[0].getMomentum().Mag()
164  self.Momentum.Fill(TrackFitResults[0].getMomentum().Mag())
165 
166  if track.hasPXDHits() or track.hasSVDHits():
167 
168  if track.getNumberOfSVDHits() % 2 == 0:
169  totalNumberOfHits = track.getNumberOfPXDHits() + track.getNumberOfSVDHits() / 2
170  else:
171  totalNumberOfHits = track.getNumberOfPXDHits() + (track.getNumberOfSVDHits() - 1) / 2
172 
173  self.TotalNumberOfHits.Fill(totalNumberOfHits)
174  # print('Total number of hits:', totalNumberOfHits)
175 
176  self.Chi2.Fill(track.getTrackFitStatus().getChi2())
177  self.NDF.Fill(track.getTrackFitStatus().getNdf())
178  self.Chi2OverNDF.Fill(track.getTrackFitStatus().getChi2() / track.getTrackFitStatus().getNdf())
179 
180  self.trackData.chi2 = track.getTrackFitStatus().getChi2()
181  self.trackData.ndf = track.getTrackFitStatus().getNdf()
182  self.trackData.chiSquaredOverNdf = track.getTrackFitStatus().getChi2() / track.getTrackFitStatus().getNdf()
183  # print('Chi2/NDF:', self.trackData.chiSquaredOverNdf, 'Chi2:', self.trackData.chi2)
184  self.rootfile.cd()
185  self.tree_track.Fill()
186 
187  # Check overlaps in PXD ladders & Check track in RecoTracks
188  if track.hasPXDHits():
189 
190  # Print number of PXD hits
191  # EventMetaData = Belle2.PyStoreObj('EventMetaData')
192  # event = EventMetaData.getEvent()
193  # nPxdHits = track.getNumberOfPXDHits()
194  # print('Event', event, 'has PXD', nPxdHits, 'hit(s):')
195 
196  # First loop over PXD Hits
197  for n in range(0, len(track.getPXDHitList())):
198  pxdHit = track.getPXDHitList()[n]
199  sensorID = Belle2.VxdID(pxdHit.getSensorID())
200  info = geoCache.get(sensorID)
201  layer = sensorID.getLayerNumber()
202  sensor = sensorID.getSensorNumber()
203  # print('Hit information: #hit:', n, 'sensor information:', layer, ladder, sensor)
204  self.HitsVsLayer.Fill(totalNumberOfHits, layer)
205  self.HitsVsSensor.Fill(totalNumberOfHits, sensor)
206  self.LayerVsSensor.Fill(layer, sensor)
207  self.PXDClusterSize.Fill(track.getPXDHitList()[n].getSize())
208 
209  # Check overlaps in SVD ladders
210  if track.hasSVDHits():
211 
212  # Print number of SVD hits
213  # EventMetaData = Belle2.PyStoreObj('EventMetaData')
214  # event = EventMetaData.getEvent()
215  # nSvdHits = track.getNumberOfSVDHits()
216  # print('Event', event, 'has SVD', nSvdHits, 'hit(s):')
217 
218  # First loop over SVD Hits
219  for n in range(0, len(track.getSVDHitList())):
220  svdHit = track.getSVDHitList()[n]
221  sensorID = Belle2.VxdID(svdHit.getSensorID())
222  info = geoCache.get(sensorID)
223  layer = sensorID.getLayerNumber()
224  sensor = sensorID.getSensorNumber()
225 
226  if svdHit.isUCluster():
227  # print('Hit information: #hit:', n, 'sensor information:', layer, ladder, sensor, 'isU')
228  for lst in range(0, len(track.getSVDHitList())):
229  svdHitA = track.getSVDHitList()[lst]
230  sensorIDA = Belle2.VxdID(svdHitA.getSensorID())
231  if info == geoCache.get(sensorIDA):
232  if svdHitA.isUCluster() == 0:
233  # print('Hit information: #hit:', n, 'sensor information:', layer, ladder, sensor)
234  self.HitsVsLayer.Fill(totalNumberOfHits, layer)
235  self.HitsVsSensor.Fill(totalNumberOfHits, sensor)
236  self.LayerVsSensor.Fill(layer, sensor)
237  # else:
238  # print('Hit information: #hit:', n, 'sensor information:', layer, ladder, sensor, 'isNotU')
239  else:
240  print('Fit was not successful')
241 
242  def terminate(self):
243  """Close & write output files"""
244  self.rootfile.cd()
245 
246  labelHits = ('', 'One', 'Two', 'Three', 'Four', 'Five', 'Six')
247  labelLayers = ('', 'First', 'Second', 'Third', 'Fourth', 'Fifth', 'Sixth')
248  labelSensors = ('', 'First', 'Second', 'Third', 'Fourth', 'Fifth')
249 
250  for i in range(1, 7):
251  self.TotalNumberOfHits.GetXaxis().SetBinLabel(i, labelHits[i])
252  self.TotalNumberOfHits.GetXaxis().SetLabelSize(0.05)
253  self.TotalNumberOfHits.GetYaxis().SetTitle("Number of tracks in VXD")
254  self.TotalNumberOfHits.GetXaxis().SetTitle("Number of hits in VXD")
255  self.TotalNumberOfHits.GetYaxis().CenterTitle()
256  self.TotalNumberOfHits.GetXaxis().CenterTitle()
257  self.TotalNumberOfHits.GetYaxis().SetTitleOffset(1.3)
258  self.TotalNumberOfHits.GetXaxis().SetTitleOffset(1.3)
259  self.TotalNumberOfHits.SetFillStyle(3365)
260  self.TotalNumberOfHits.SetFillColor(9)
261  self.TotalNumberOfHits.SetLineColor(9)
262  self.TotalNumberOfHits.Draw()
263  # self.TotalNumberOfHits.Write()
264 
265  for i in range(1, 7):
266  self.HitsVsLayer.GetXaxis().SetBinLabel(i, labelHits[i])
267  self.HitsVsLayer.GetYaxis().SetBinLabel(i, labelLayers[i])
268  self.HitsVsLayer.GetXaxis().SetLabelSize(0.05)
269  self.HitsVsLayer.GetYaxis().SetLabelSize(0.05)
270  self.HitsVsLayer.GetXaxis().SetTitle("Number hits in VXD")
271  self.HitsVsLayer.GetYaxis().SetTitle("Layer")
272  self.HitsVsLayer.GetYaxis().CenterTitle()
273  self.HitsVsLayer.GetXaxis().CenterTitle()
274  self.HitsVsLayer.GetYaxis().SetTitleOffset(1.6)
275  self.HitsVsLayer.GetXaxis().SetTitleOffset(1.3)
276  ROOT.gPad.SetMargin(0.11, 0.11, 0.1, 0.1)
277  self.HitsVsLayer.Draw()
278  # self.HitsVsLayer.Write()
279 
280  for i in range(1, 7):
281  self.HitsVsSensor.GetXaxis().SetBinLabel(i, labelHits[i])
282  for i in range(1, 6):
283  self.HitsVsSensor.GetYaxis().SetBinLabel(i, labelSensors[i])
284  self.HitsVsSensor.GetXaxis().SetLabelSize(0.05)
285  self.HitsVsSensor.GetYaxis().SetLabelSize(0.05)
286  self.HitsVsSensor.GetXaxis().SetTitle("Number hits in VXD")
287  self.HitsVsSensor.GetYaxis().SetTitle("Sensor")
288  self.HitsVsSensor.GetYaxis().CenterTitle()
289  self.HitsVsSensor.GetXaxis().CenterTitle()
290  self.HitsVsSensor.GetYaxis().SetTitleOffset(1.6)
291  self.HitsVsSensor.GetXaxis().SetTitleOffset(1.3)
292  ROOT.gPad.SetMargin(0.11, 0.11, 0.1, 0.1)
293  self.HitsVsSensor.Draw()
294  # self.HitsVsSensor.Write()
295 
296  for i in range(1, 7):
297  self.LayerVsSensor.GetXaxis().SetBinLabel(i, labelLayers[i])
298  for i in range(1, 6):
299  self.LayerVsSensor.GetYaxis().SetBinLabel(i, labelSensors[i])
300  self.LayerVsSensor.GetXaxis().SetLabelSize(0.05)
301  self.LayerVsSensor.GetYaxis().SetLabelSize(0.05)
302  self.LayerVsSensor.GetXaxis().SetTitle("Layer")
303  self.LayerVsSensor.GetYaxis().SetTitle("Sensor")
304  self.LayerVsSensor.GetYaxis().CenterTitle()
305  self.LayerVsSensor.GetXaxis().CenterTitle()
306  self.LayerVsSensor.GetYaxis().SetTitleOffset(1.6)
307  self.LayerVsSensor.GetXaxis().SetTitleOffset(1.3)
308  ROOT.gPad.SetMargin(0.11, 0.11, 0.1, 0.1)
309  self.LayerVsSensor.Draw()
310  # self.LayerVsSensor.Write()
311 
312  self.Chi2.GetXaxis().SetTitle("#Chi^{2}")
313  self.Chi2.GetYaxis().SetTitle("Number of tracks")
314  self.Chi2.GetYaxis().CenterTitle()
315  self.Chi2.GetXaxis().CenterTitle()
316  self.Chi2.GetYaxis().SetTitleOffset(1.3)
317  self.Chi2.GetXaxis().SetTitleOffset(1.3)
318  self.Chi2.SetFillStyle(3365)
319  self.Chi2.SetFillColor(9)
320  self.Chi2.SetLineColor(9)
321  self.Chi2.Draw()
322  # self.Chi2.Write()
323 
324  self.NDF.GetXaxis().SetTitle("Degrees of freedom")
325  self.NDF.GetYaxis().SetTitle("Number of tracks")
326  self.NDF.GetYaxis().CenterTitle()
327  self.NDF.GetXaxis().CenterTitle()
328  self.NDF.GetYaxis().SetTitleOffset(1.3)
329  self.NDF.GetXaxis().SetTitleOffset(1.3)
330  self.NDF.SetFillStyle(3365)
331  self.NDF.SetFillColor(9)
332  self.NDF.SetLineColor(9)
333  self.NDF.Draw()
334  # self.NDF.Write()
335 
336  self.Chi2OverNDF.SetTitle("#Chi^{2}/Degrees of freedom")
337  self.Chi2OverNDF.GetYaxis().SetTitle("Number of tracks")
338  self.Chi2OverNDF.GetYaxis().CenterTitle()
339  self.Chi2OverNDF.GetXaxis().CenterTitle()
340  self.Chi2OverNDF.GetYaxis().SetTitleOffset(1.3)
341  self.Chi2OverNDF.GetXaxis().SetTitleOffset(1.3)
342  self.Chi2OverNDF.SetFillStyle(3365)
343  self.Chi2OverNDF.SetFillColor(9)
344  self.Chi2OverNDF.SetLineColor(9)
345  self.Chi2OverNDF.Draw()
346  # self.Chi2OverNDF.Write()
347 
348  self.Momentum.GetXaxis().SetTitle("Momentum [GeVc^{-1}]")
349  self.Momentum.GetYaxis().SetTitle("Number of tracks")
350  self.Momentum.GetYaxis().CenterTitle()
351  self.Momentum.GetXaxis().CenterTitle()
352  self.Momentum.GetYaxis().SetTitleOffset(1.3)
353  self.Momentum.GetXaxis().SetTitleOffset(1.3)
354  self.Momentum.SetFillStyle(3365)
355  self.Momentum.SetFillColor(9)
356  self.Momentum.SetLineColor(9)
357  self.Momentum.Draw()
358  # self.Momentum.Write()
359 
360  self.ADCCountOverNumberOfHitsInCDC.GetXaxis().SetTitle("ADC Count [ADC] / number of hit")
361  self.ADCCountOverNumberOfHitsInCDC.GetYaxis().SetTitle("Number of tracks")
362  self.ADCCountOverNumberOfHitsInCDC.GetYaxis().CenterTitle()
363  self.ADCCountOverNumberOfHitsInCDC.GetXaxis().CenterTitle()
364  self.ADCCountOverNumberOfHitsInCDC.GetYaxis().SetTitleOffset(1.3)
365  self.ADCCountOverNumberOfHitsInCDC.GetXaxis().SetTitleOffset(1.3)
366  self.ADCCountOverNumberOfHitsInCDC.SetFillStyle(3365)
367  self.ADCCountOverNumberOfHitsInCDC.SetFillColor(9)
368  self.ADCCountOverNumberOfHitsInCDC.SetLineColor(9)
369  self.ADCCountOverNumberOfHitsInCDC.Draw()
370  # self.ADCCountOverNumberOfHitsInCDC.Write()
371 
372  function = ROOT.TF1("function", "[0]+[1]*log(x)")
373  function.SetParameters(0.0, 0.0)
374  self.MomentumVsADCCountOverNumberOfHitsInCDC.GetYaxis().SetTitle("ADC Count [ADC] / number of hit")
375  self.MomentumVsADCCountOverNumberOfHitsInCDC.GetXaxis().SetTitle("Momentum [GeVc^{-1}]")
376  self.MomentumVsADCCountOverNumberOfHitsInCDC.GetYaxis().CenterTitle()
377  self.MomentumVsADCCountOverNumberOfHitsInCDC.GetXaxis().CenterTitle()
378  self.MomentumVsADCCountOverNumberOfHitsInCDC.GetYaxis().SetTitleOffset(1.3)
379  self.MomentumVsADCCountOverNumberOfHitsInCDC.GetXaxis().SetTitleOffset(1.3)
380  self.MomentumVsADCCountOverNumberOfHitsInCDC.Fit(function)
381  self.MomentumVsADCCountOverNumberOfHitsInCDC.Draw()
382  # self.MomentumVsADCCountOverNumberOfHitsInCDC.Write()
383 
384  inverse_function = ROOT.TF1("inverse_function", "exp((-[0]+x)/[1])", 0, 115)
385  inverse_function.SetParameter(0, function.GetParameter(0))
386  inverse_function.SetParameter(1, function.GetParameter(1))
387  constant = ROOT.TF1("constant", "[0]", 115, 300)
388  constant.SetParameter(0, 20)
389  self.ADCCountOverNumberOfHitsInCDCVsMomentum.Fit(inverse_function, "R+")
390  self.ADCCountOverNumberOfHitsInCDCVsMomentum.Fit(constant, "R+")
391  self.ADCCountOverNumberOfHitsInCDCVsMomentum.GetXaxis().SetTitle("ADC Count [ADC] / number of hit")
392  self.ADCCountOverNumberOfHitsInCDCVsMomentum.GetYaxis().SetTitle("Momentum [GeVc^{-1}]")
393  self.ADCCountOverNumberOfHitsInCDCVsMomentum.GetYaxis().CenterTitle()
394  self.ADCCountOverNumberOfHitsInCDCVsMomentum.GetXaxis().CenterTitle()
395  self.ADCCountOverNumberOfHitsInCDCVsMomentum.GetYaxis().SetTitleOffset(1.3)
396  self.ADCCountOverNumberOfHitsInCDCVsMomentum.GetXaxis().SetTitleOffset(1.3)
397  self.ADCCountOverNumberOfHitsInCDCVsMomentum.Draw()
398  # self.ADCCountOverNumberOfHitsInCDCVsMomentum.Write()
399 
400  print('Parameters of fitted function y = exp((-p0+x)/p1) + p2, where x ~ ADCCounts/NumberOfCDCHits, y ~ momentum')
401  print('p0 =', inverse_function.GetParameter(0), 'p1 =', inverse_function.GetParameter(1), 'p2 =', constant.GetParameter(0))
402 
403  self.PXDClusterSize.GetXaxis().SetTitle("Size of PXD Clusters")
404  self.PXDClusterSize.GetYaxis().SetTitle("Number of tracks")
405  self.PXDClusterSize.GetYaxis().CenterTitle()
406  self.PXDClusterSize.GetXaxis().CenterTitle()
407  self.PXDClusterSize.GetYaxis().SetTitleOffset(1.3)
408  self.PXDClusterSize.GetXaxis().SetTitleOffset(1.3)
409  self.PXDClusterSize.SetFillStyle(3365)
410  self.PXDClusterSize.SetFillColor(9)
411  self.PXDClusterSize.SetLineColor(9)
412  self.PXDClusterSize.Draw()
413 
414  self.rootfile.Write()
415  self.rootfile.Close()
416 
417 
418 main = create_path()
419 
420 main.add_module('RootInput')
421 main.add_module('Gearbox')
422 main.add_module('Geometry')
423 
424 reco.add_cosmics_reconstruction(main, pruneTracks=False, merge_tracks=True)
425 main.add_module('DAFRecoFitter', pdgCodesToUseForFitting=[13])
426 main.add_module("CDCDedxPID")
427 
428 CosmicAnalysis = CosmicAnalysis()
429 main.add_module(CosmicAnalysis)
430 
431 progress = register_module('ProgressBar')
432 main.add_module(progress)
433 
434 process(main)
435 
436 # Print call statistics
437 print(statistics)
validatePhase2Cosmics.CosmicAnalysis.__init__
def __init__(self)
Definition: validatePhase2Cosmics.py:44
validatePhase2Cosmics.CosmicAnalysis.Chi2OverNDF
Chi2OverNDF
Histogram with track Chi2/NDF.
Definition: validatePhase2Cosmics.py:101
validatePhase2Cosmics.CosmicAnalysis.HitsVsLayer
HitsVsLayer
Histogram with number of hits vs.
Definition: validatePhase2Cosmics.py:89
Belle2::VxdID
Class to uniquely identify a any structure of the PXD and SVD.
Definition: VxdID.h:43
validatePhase2Cosmics.CosmicAnalysis.Chi2
Chi2
Histogram with track Chi2.
Definition: validatePhase2Cosmics.py:97
validatePhase2Cosmics.CosmicAnalysis
Definition: validatePhase2Cosmics.py:40
validatePhase2Cosmics.CosmicAnalysis.PXDClusterSize
PXDClusterSize
Histogram with PXD cluster size.
Definition: validatePhase2Cosmics.py:95
validatePhase2Cosmics.CosmicAnalysis.ADCCountOverNumberOfHitsInCDCVsMomentum
ADCCountOverNumberOfHitsInCDCVsMomentum
Profile with ADC count vs.
Definition: validatePhase2Cosmics.py:107
validatePhase2Cosmics.CosmicAnalysis.tree_DEDX
tree_DEDX
Tree with dE/dx data.
Definition: validatePhase2Cosmics.py:54
validatePhase2Cosmics.CosmicAnalysis.terminate
def terminate(self)
Definition: validatePhase2Cosmics.py:242
validatePhase2Cosmics.CosmicAnalysis.MomentumVsADCCountOverNumberOfHitsInCDC
MomentumVsADCCountOverNumberOfHitsInCDC
Profile with ADC count vs.
Definition: validatePhase2Cosmics.py:110
validatePhase2Cosmics.CosmicAnalysis.TotalNumberOfHits
TotalNumberOfHits
Histogram with total number of hits on track.
Definition: validatePhase2Cosmics.py:87
Belle2::VXD::GeoCache::getInstance
static GeoCache & getInstance()
Return a reference to the singleton instance.
Definition: GeoCache.cc:215
validatePhase2Cosmics.CosmicAnalysis.LayerVsSensor
LayerVsSensor
Histogram with hitted layer vs.
Definition: validatePhase2Cosmics.py:93
validatePhase2Cosmics.CosmicAnalysis.NDF
NDF
Histogram with track NDF.
Definition: validatePhase2Cosmics.py:99
validatePhase2Cosmics.CosmicAnalysis.rootfile
rootfile
Input root file.
Definition: validatePhase2Cosmics.py:50
validatePhase2Cosmics.CosmicAnalysis.Momentum
Momentum
Histogram with track momentum.
Definition: validatePhase2Cosmics.py:103
validatePhase2Cosmics.CosmicAnalysis.HitsVsSensor
HitsVsSensor
Histogram with number of hits vs.
Definition: validatePhase2Cosmics.py:91
validatePhase2Cosmics.CosmicAnalysis.ADCCountOverNumberOfHitsInCDC
ADCCountOverNumberOfHitsInCDC
Histogram with ADC count vs.
Definition: validatePhase2Cosmics.py:105
validatePhase2Cosmics.CosmicAnalysis.dedxData
dedxData
struct with dE/dx data
Definition: validatePhase2Cosmics.py:78
validatePhase2Cosmics.CosmicAnalysis.event
def event(self)
Definition: validatePhase2Cosmics.py:116
validatePhase2Cosmics.CosmicAnalysis.trackData
trackData
struct with track data
Definition: validatePhase2Cosmics.py:69
Belle2::PyStoreArray
a (simplified) python wrapper for StoreArray.
Definition: PyStoreArray.h:58
validatePhase2Cosmics.CosmicAnalysis.beginRun
def beginRun(self)
Definition: validatePhase2Cosmics.py:113
validatePhase2Cosmics.CosmicAnalysis.tree_track
tree_track
Tree with track data.
Definition: validatePhase2Cosmics.py:52