Belle II Software  release-05-01-25
test_geotools.py
1 import basf2
2 import ROOT
3 from ROOT import Belle2
4 import b2test_utils
5 
6 # ====================================================================
7 # This test checks the numberingg schemes used in VXD DQM utility class.
8 # It builds a single event to have geometry in place, and only checks
9 # that ID->list index->ID works for sensor and chip lists.
10 # ====================================================================
11 
12 
13 class CheckNumbering(basf2.Module):
14  """This module creates a DQMCommonUtils object and tests sensor
15  and chip numbering schemes."""
16 
17  def __init__(self):
18  """ constructor """
19  super().__init__()
20 
21  def initialize(self):
22  """ Initialize the DQMCommonUtils class here. It builds
23  its lookup arrrays, so we want to do it only once."""
24 
25  self.gTools = Belle2.VXD.GeoCache.getInstance().getGeoTools()
26  if not self.gTools:
27  basf2.B2FATAL("GeoTools not available!")
28 
29  def event(self):
30  """ We test sensor and chip numbering by going from ID to
31  list number to ID."""
32  #
33  # 0. General parameters
34  #
35  # 0a. Layer counts
36  if (self.gTools.getNumberOfLayers() != 6):
37  basf2.B2ERROR('Layer count failure: \n {0} layers reported, 6 actually.'.format(self.gTools.getNumberOfLayers()))
38  if (self.gTools.getNumberOfPXDLayers() != 2):
39  basf2.B2ERROR('PXD layer count failure: \n {0} layers reported, 2 actually.'.format(self.gTools.getNumberOfPXDLayers()))
40  if (self.gTools.getNumberOfSVDLayers() != 4):
41  basf2.B2ERROR('SVD layer count failure: \n {0} layers reported, 4 actually.'.format(self.gTools.getNumberOfSVDLayers()))
42  # 0b. Layer numbers
43  layers = self.gTools.getLayers()
44  expected_layers = [1, 2, 3, 4, 5, 6]
45  match = True
46  for l1, l2 in zip(layers, expected_layers):
47  if l1 != l2:
48  match = False
49  break
50  if not match:
51  l1_string = ' '.join([str(x) for x in layers])
52  l2_string = ' '.join([str(x) for x in expected_layers])
53  basf2.B2ERROR('Layer numbers do not match, expected {0}, got {1}!'.format(l2_string, l1_string))
54 
55  layers = self.gTools.getPXDLayers()
56  expected_layers = [1, 2]
57  match = True
58  for l1, l2 in zip(layers, expected_layers):
59  if l1 != l2:
60  match = False
61  break
62  if not match:
63  l1_string = ' '.join([str(x) for x in layers])
64  l2_string = ' '.join([str(x) for x in expected_layers])
65  basf2.B2ERROR('PXD layer numbers do not match, expected {0}, got {1}!'.format(l2_string, l1_string))
66 
67  layers = self.gTools.getSVDLayers()
68  expected_layers = [3, 4, 5, 6]
69  match = True
70  for l1, l2 in zip(layers, expected_layers):
71  if l1 != l2:
72  match = False
73  break
74  if not match:
75  l1_string = ' '.join([str(x) for x in layers])
76  l2_string = ' '.join([str(x) for x in expected_layers])
77  basf2.B2ERROR('SVD layer numbers do not match, expected {0}, got {1}!'.format(l2_string, l1_string))
78 
79  # 0c. Layer ranges
80  if (self.gTools.getFirstLayer() != 1):
81  basf2.B2ERROR('First layer number is 1, reported {0}.'.format(self.gTools.getFirstLayer()))
82  if (self.gTools.getLastLayer() != 6):
83  basf2.B2ERROR('Last layer number is 6, reported {0}.'.format(self.gTools.getLastLayer()))
84  if (self.gTools.getFirstPXDLayer() != 1):
85  basf2.B2ERROR('First PXD layer number is 1, reported {0}.'.format(self.gTools.getFirstPXDLayer()))
86  if (self.gTools.getLastPXDLayer() != 2):
87  basf2.B2ERROR('Last PXD layer number is 2, reported {0}.'.format(self.gTools.getLastPXDLayer()))
88  if (self.gTools.getFirstSVDLayer() != 3):
89  basf2.B2ERROR('First SVD layer number is 3, reported {0}.'.format(self.gTools.getFirstSVDLayer()))
90  if (self.gTools.getLastSVDLayer() != 6):
91  basf2.B2ERROR('Last SVD layer number is 6, reported {0}.'.format(self.gTools.getLastSVDLayer()))
92  # 0d. Sensor indexing range
93  # PXD
94  # First PXD sensor should be (first PXD layer)/1/1,
95  idOfFirstPXDSensor = self.gTools.getSensorIDFromPXDIndex(0)
96  layer = idOfFirstPXDSensor.getLayerNumber()
97  ladder = idOfFirstPXDSensor.getLadderNumber()
98  sensor = idOfFirstPXDSensor.getSensorNumber()
99  if layer != self.gTools.getFirstPXDLayer() or ladder != 1 or sensor != 1:
100  basf2.B2ERROR('Mismatch in first PXD sensor placement:\n' +
101  'Expected {0}/{1}/{2}\nGot: {3|/{4}/{5}'.format(
102  layer, ladder, sensor,
103  self.gTools.getFirstPXDLayer(), 1, 1))
104  idOfLastPXDSensor = self.gTools.getSensorIDFromPXDIndex(self.gTools.getNumberOfPXDSensors() - 1)
105  layer = idOfLastPXDSensor.getLayerNumber()
106  if layer != self.gTools.getLastPXDLayer():
107  basf2.B2ERROR('Mismatch in last PXD sensor placement:\n' +
108  'Expected layer {0} got layer {1|'.format(
109  layer, self.gTools.getLastPXDLayer()))
110  # SVD
111  # First SVD sensor should be (first PXD layer)/1/1,
112  idOfFirstSVDSensor = self.gTools.getSensorIDFromSVDIndex(0)
113  layer = idOfFirstSVDSensor.getLayerNumber()
114  ladder = idOfFirstSVDSensor.getLadderNumber()
115  sensor = idOfFirstSVDSensor.getSensorNumber()
116  if layer != self.gTools.getFirstSVDLayer() or ladder != 1 or sensor != 1:
117  basf2.B2ERROR('Mismatch in first SVD sensor placement:\n' +
118  'Expected {0}/{1}/{2}\nGot: {3}/{4}/{5}'.format(
119  layer, ladder, sensor,
120  self.gTools.getFirstSVDLayer(), 1, 1))
121  idOfLastSVDSensor = self.gTools.getSensorIDFromSVDIndex(self.gTools.getNumberOfSVDSensors() - 1)
122  layer = idOfLastSVDSensor.getLayerNumber()
123  if layer != self.gTools.getLastSVDLayer():
124  basf2.B2ERROR('Mismatch in last SVD sensor placement:\n' +
125  'Expected layer {0} got layer {1}'.format(
126  layer, self.gTools.getLastSVDLayer()))
127  #
128  # 1. General sensor indexing
129  #
130  # 1a. Basic loop
131  init_sensorID = Belle2.VxdID(3, 1, 1)
132  init_sensor_index = self.gTools.getSensorIndex(init_sensorID)
133  ret_sensorID = self.gTools.getSensorIDFromIndex(init_sensor_index)
134  if init_sensorID.getID() != ret_sensorID.getID():
135  basf2.B2ERROR(
136  "Sensor index failure: \n Initial id: {0} \n VXD index: {1} \n Retrieved id: {2}.".format(
137  init_sensorID, init_sensor_index, ret_sensorID))
138  # 1b. Neighbourhood test
139  next_sensorID = self.gTools.getSensorIDFromIndex(init_sensor_index + 1)
140  next_expected_sensorID = Belle2.VxdID(init_sensorID)
141  next_expected_sensorID.setSensorNumber(init_sensorID.getSensorNumber() + 1)
142  if next_expected_sensorID.getID() != next_sensorID.getID():
143  basf2.B2ERROR('Sensor index neighbourhood test failure: \n' +
144  'Initial id: {0} \n Expected id: {1} \n Actaul id: {2} \n Index: {3}.'.format(
145  init_sensorID, next_expected_sensorID,
146  next_sensorID, init_sensor_index + 1
147  ))
148 
149  # 1c. Sensor counting
150  num_sensors_expected = 212
151  if (self.gTools.getNumberOfSensors() != num_sensors_expected):
152  basf2.B2ERROR('Number of sensors mismatch: \n' +
153  'Expected: {0}, got {1}.'.format(
154  num_sensors_expected, self.gTools.getNumberOfSensors()
155  ))
156  #
157  # 2. PXD sensor indexing
158  #
159  # 2a. Basic loop
160  init_sensorID = Belle2.VxdID(1, 2, 1)
161  init_sensor_index = self.gTools.getPXDSensorIndex(
162  init_sensorID.getLayerNumber(),
163  init_sensorID.getLadderNumber(),
164  init_sensorID.getSensorNumber())
165  ret_sensorID = self.gTools.getSensorIDFromPXDIndex(init_sensor_index)
166  if init_sensorID.getID() != ret_sensorID.getID():
167  basf2.B2ERROR(
168  "PXD sensor index failure: \n Initial id: {0} \n VXD index: {1} \n Retrieved id: {2}.".format(
169  init_sensorID, init_sensor_index, ret_sensorID))
170  # 2b. Neighbourhood test
171  next_sensorID = self.gTools.getSensorIDFromPXDIndex(init_sensor_index + 1)
172  next_expected_sensorID = Belle2.VxdID(init_sensorID)
173  next_expected_sensorID.setSensorNumber(init_sensorID.getSensorNumber() + 1)
174  if next_expected_sensorID.getID() != next_sensorID.getID():
175  basf2.B2ERROR(
176  'PXD sensor index neighbourhood test failure: \n' +
177  'Initial id: {0} \n Expected id: {1} \n Actaul id: {2} \n ' +
178  'Index: {3}.'.format(init_sensorID, next_expected_sensorID,
179  next_sensorID, init_sensor_index + 1))
180  # 2c. Sensor counting
181  num_sensors_expected = 40
182  if (self.gTools.getNumberOfPXDSensors() != num_sensors_expected):
183  basf2.B2ERROR('Number of PXD sensors mismatch: \n' +
184  'Expected: {0}, got {1}.'.format(
185  num_sensors_expected, self.gTools.getNumberOfPXDSensors()
186  ))
187  #
188  # 3. SVD sensor indexing
189  #
190  # 2a. Basic loop
191  init_sensorID = Belle2.VxdID(4, 2, 1)
192  init_sensor_index = self.gTools.getSVDSensorIndex(
193  init_sensorID.getLayerNumber(),
194  init_sensorID.getLadderNumber(),
195  init_sensorID.getSensorNumber())
196  ret_sensorID = self.gTools.getSensorIDFromSVDIndex(init_sensor_index)
197  if init_sensorID.getID() != ret_sensorID.getID():
198  basf2.B2ERROR(
199  "SVD sensor index failure: \n Initial id: {0} \n VXD index: {1} \n Retrieved id: {2}.".format(
200  init_sensorID, init_sensor_index, ret_sensorID))
201  # 2b. Neighbourhood test
202  next_sensorID = self.gTools.getSensorIDFromSVDIndex(init_sensor_index + 1)
203  next_expected_sensorID = Belle2.VxdID(init_sensorID)
204  next_expected_sensorID.setSensorNumber(init_sensorID.getSensorNumber() + 1)
205  if next_expected_sensorID.getID() != next_sensorID.getID():
206  basf2.B2ERROR(
207  'SVD sensor index neighbourhood test failure: \n' +
208  'Initial id: {0} \n Expected id: {1} \n Actaul id: {2} \n ' +
209  'Index: {3}.'.format(init_sensorID, next_expected_sensorID,
210  next_sensorID, init_sensor_index + 1))
211  # 3c. Sensor counting
212  num_sensors_expected = 172
213  if (self.gTools.getNumberOfSVDSensors() != num_sensors_expected):
214  basf2.B2ERROR('Number of SVD sensors mismatch: \n' +
215  'Expected: {0}, got {1}.'.format(
216  num_sensors_expected, self.gTools.getNumberOfSVDSensors()
217  ))
218  #
219  # 4. Layer indexing
220  #
221  # 4a. Basic loop
222  init_layer = 4
223  init_layer_index = self.gTools.getLayerIndex(init_layer)
224  ret_layer = self.gTools.getLayerNumberFromLayerIndex(init_layer_index)
225  if init_layer != ret_layer:
226  basf2.B2ERROR(
227  "Layer index failure: \n Initial: {0} \n Index: {1} \n Retrieved: {2}.".format(
228  init_layer, init_layer_index, ret_layer))
229  # 2b. Neighbourhood test
230  next_layer = self.gTools.getLayerNumberFromLayerIndex(init_layer_index + 1)
231  next_expected_layer = init_layer + 1
232  if next_layer != next_expected_layer:
233  basf2.B2ERROR(
234  "Layer index neighbourhood test failure: \n Initial id: {0} \n Expected: {1} \n Actaul: {2} \n Index: {3}.".format(
235  init_layer,
236  next_expected_layer,
237  next_layer,
238  init_layer_index +
239  1))
240  #
241  # 5. PXD chip indexing
242  #
243  # 5a. Chip-on-sensor counts
244  if self.gTools.getTotalPXDChips() != 400:
245  basf2.B2ERROR('PXD chip count mismatch: \n' +
246  'Expected: {0}, got {1}.'.format(
247  2120, self.gTools.getTotalPXDChips())
248  )
249  if self.gTools.getNumberOfPXDUSideChips() != 4:
250  basf2.B2ERROR('PXD u-side chip count mismatch: \n' +
251  'Expected: {0}, got {1}.'.format(
252  4, self.gTools.getNumberOfPXDUSideChips())
253  )
254  if self.gTools.getNumberOfPXDVSideChips() != 6:
255  basf2.B2ERROR('PXD v-side chip count mismatch: \n' +
256  'Expected: {0}, got {1}.'.format(
257  6, self.gTools.getNumberOfPXDVSideChips())
258  )
259  if self.gTools.getTotalSVDChips() != 1748:
260  basf2.B2ERROR('SVD chip count mismatch: \n' +
261  'Expected: {0}, got {1}.'.format(
262  2148, self.gTools.getTotalSVDChips())
263  )
264  if self.gTools.getNumberOfSVDUSideChips() != 6:
265  basf2.B2ERROR('SVD u-side chip count mismatch: \n' +
266  'Expected: {0}, got {1}.'.format(
267  6, self.gTools.getNumberOfSVDUSideChips())
268  )
269  if self.gTools.getNumberOfSVDVSideChips(3) != 6:
270  basf2.B2ERROR('SVD v-side chip count mismatch: \n' +
271  'Expected: {0}, got {1}.'.format(
272  6, self.gTools.getNumberOfSVDVSideChips(3))
273  )
274  if self.gTools.getNumberOfSVDVSideChips(4) != 4:
275  basf2.B2ERROR('SVD v-side chip count mismatch: \n' +
276  'Expected: {0}, got {1}.'.format(
277  4, self.gTools.getNumberOfSVDVSideChips(4))
278  )
279  # 5b. PXD chip indexing - loop
280  init_layer = 1
281  init_ladder = 2
282  init_sensor = 1
283  init_uSide = True
284  init_chipNo = 4
285  index_with_vxdid = self.gTools.getPXDChipIndex(Belle2.VxdID(init_layer, init_ladder, init_sensor), init_uSide, init_chipNo)
286  index_with_llss = self.gTools.getPXDChipIndex(init_layer, init_ladder, init_sensor, init_uSide, init_chipNo)
287  if index_with_vxdid != index_with_llss:
288  basf2.B2ERROR('Mismatch between VxdID-based and layer-ladder-sensor based index:\n' +
289  'VxdID-based: {0}\nlayer-ladder-sensor: {1}'.format(
290  index_with_vxdid, index_with_llss)
291  )
292  returned_chipID = self.gTools.getChipIDFromPXDIndex(index_with_vxdid)
293  returned_layer = returned_chipID.getLayerNumber()
294  returned_ladder = returned_chipID.getLadderNumber()
295  returned_sensor = returned_chipID.getSensorNumber()
296  returned_uSide = self.gTools.isPXDSideU(returned_chipID)
297  returned_chipNo = self.gTools.getPXDChipNumber(returned_chipID)
298  match = (init_layer == returned_layer) and \
299  (init_ladder == returned_ladder) and \
300  (init_sensor == returned_sensor) and \
301  (init_uSide == returned_uSide) and \
302  (init_chipNo == returned_chipNo)
303  if not match:
304  basf2.B2ERROR('Mismatch in PXD chip indexing:\n' +
305  'Initial: {0} {1} {2} {3} {4}\n'.format(
306  init_layer, init_ladder, init_sensor, init_uSide, init_chipNo) +
307  'Final: {0} {1} {2} {3} {4}.'.format(
308  returned_layer, returned_ladder, returned_sensor, returned_uSide, returned_chipNo)
309  )
310  # 5c. PXD chip indexing - neighbourhood
311  # We are expecting same sensor, v-side, chip 0
312  expected_layer = init_layer
313  expected_ladder = init_ladder
314  expected_sensor = init_sensor
315  expected_uSide = False
316  expected_chipNo = 1
317  neighbour_chipID = self.gTools.getChipIDFromPXDIndex(index_with_vxdid + 1)
318  neighbour_layer = neighbour_chipID.getLayerNumber()
319  neighbour_ladder = neighbour_chipID.getLadderNumber()
320  neighbour_sensor = neighbour_chipID.getSensorNumber()
321  neighbour_uSide = self.gTools.isPXDSideU(neighbour_chipID)
322  neighbour_chipNo = self.gTools.getPXDChipNumber(neighbour_chipID)
323  match = (expected_layer == neighbour_layer) and \
324  (expected_ladder == neighbour_ladder) and \
325  (expected_sensor == neighbour_sensor) and \
326  (expected_uSide == neighbour_uSide) and \
327  (expected_chipNo == neighbour_chipNo)
328  if not match:
329  basf2.B2ERROR('Mismatch in PXD chip index neighbourship:\n' +
330  'Expected: {0} {1} {2} {3} {4}\n'.format(
331  expected_layer, expected_ladder, expected_sensor, expected_uSide, expected_chipNo) +
332  'Obtained: {0} {1} {2} {3} {4}.'.format(
333  neighbour_layer, neighbour_ladder, neighbour_sensor, neighbour_uSide, neighbour_chipNo)
334  )
335 
336  # 5d. SVD chip indexing - loop
337  init_layer = 3
338  init_ladder = 2
339  init_sensor = 1
340  init_uSide = True
341  init_chipNo = 6
342  index_with_vxdid = self.gTools.getSVDChipIndex(Belle2.VxdID(init_layer, init_ladder, init_sensor), init_uSide, init_chipNo)
343  index_with_llss = self.gTools.getSVDChipIndex(init_layer, init_ladder, init_sensor, init_uSide, init_chipNo)
344  if index_with_vxdid != index_with_llss:
345  basf2.B2ERROR('Mismatch between VxdID-based and layer-ladder-sensor based index:\n' +
346  'VxdID-based: {0}\nlayer-ladder-sensor: {1}'.format(
347  index_with_vxdid, index_with_llss)
348  )
349  returned_chipID = self.gTools.getChipIDFromSVDIndex(index_with_vxdid)
350  returned_layer = returned_chipID.getLayerNumber()
351  returned_ladder = returned_chipID.getLadderNumber()
352  returned_sensor = returned_chipID.getSensorNumber()
353  returned_uSide = self.gTools.isSVDSideU(returned_chipID)
354  returned_chipNo = self.gTools.getSVDChipNumber(returned_chipID)
355  match = (init_layer == returned_layer) and \
356  (init_ladder == returned_ladder) and \
357  (init_sensor == returned_sensor) and \
358  (init_uSide == returned_uSide) and \
359  (init_chipNo == returned_chipNo)
360  if not match:
361  basf2.B2ERROR('Mismatch in SVD chip indexing:\n' +
362  'Initial: {0} {1} {2} {3} {4}\n'.format(
363  init_layer, init_ladder, init_sensor, init_uSide, init_chipNo) +
364  'Final: {0} {1} {2} {3} {4}.'.format(
365  returned_layer, returned_ladder, returned_sensor, returned_uSide, returned_chipNo)
366  )
367  # 5e. SVD chip indexing - neighbourhood
368  # We are expecting same sensor, v-side, chip 0
369  expected_layer = init_layer
370  expected_ladder = init_ladder
371  expected_sensor = init_sensor
372  expected_uSide = False
373  expected_chipNo = 1
374  neighbour_chipID = self.gTools.getChipIDFromSVDIndex(index_with_vxdid + 1)
375  neighbour_layer = neighbour_chipID.getLayerNumber()
376  neighbour_ladder = neighbour_chipID.getLadderNumber()
377  neighbour_sensor = neighbour_chipID.getSensorNumber()
378  neighbour_uSide = self.gTools.isSVDSideU(neighbour_chipID)
379  neighbour_chipNo = self.gTools.getSVDChipNumber(neighbour_chipID)
380  match = (expected_layer == neighbour_layer) and \
381  (expected_ladder == neighbour_ladder) and \
382  (expected_sensor == neighbour_sensor) and \
383  (expected_uSide == neighbour_uSide) and \
384  (expected_chipNo == neighbour_chipNo)
385  if not match:
386  basf2.B2ERROR('Mismatch in SVD chip index neighbourship:\n' +
387  'Expected: {0} {1} {2} {3} {4}\n'.format(
388  expected_layer, expected_ladder, expected_sensor, expected_uSide, expected_chipNo) +
389  'Obtained: {0} {1} {2} {3} {4}.'.format(
390  neighbour_layer, neighbour_ladder, neighbour_sensor, neighbour_uSide, neighbour_chipNo)
391  )
392  # 5f. Test of PXD chip assignment
393  # We want to see that the first and last chips have correct placement.
394  indexOfFirstPXDChip = 0
395  # First chip must be on first PXD layer, 1st ladder, 1st sensor, u-sie,
396  # chip 0.
397  idOfFirstPXDChip = self.gTools.getChipIDFromPXDIndex(indexOfFirstPXDChip)
398  firstChipLayer = idOfFirstPXDChip.getLayerNumber()
399  firstChipLadder = idOfFirstPXDChip.getLadderNumber()
400  firstChipSensor = idOfFirstPXDChip.getSensorNumber()
401  firstChipUSide = self.gTools.isPXDSideU(idOfFirstPXDChip)
402  firstChipNo = self.gTools.getPXDChipNumber(idOfFirstPXDChip)
403  if (firstChipLayer != self.gTools.getFirstPXDLayer() or
404  firstChipLadder != 1 or
405  firstChipSensor != 1 or
406  not firstChipUSide or
407  firstChipNo != 1):
408  basf2.B2ERROR(
409  'Wrong 1st PXD chip assignment:\nExpected {0}/{1}/{2} side {3} chip {4},\nGot {5}/{6}/{7} side {8} chip {9}'.format(
410  self.gTools.getFirstPXDLayer(),
411  1,
412  1,
413  'u',
414  1,
415  firstChipLayer,
416  firstChipLadder,
417  firstChipSensor,
418  'u' if firstChipUSide else 'v',
419  firstChipNo))
420  indexOfLastPXDChip = self.gTools.getTotalPXDChips() - 1
421  # Last chip must be on last PXD layer, v-sie, chip 6.
422  idOfLastPXDChip = self.gTools.getChipIDFromPXDIndex(indexOfLastPXDChip)
423  lastChipLayer = idOfLastPXDChip.getLayerNumber()
424  lastChipUSide = self.gTools.isPXDSideU(idOfLastPXDChip)
425  lastChipNo = self.gTools.getPXDChipNumber(idOfLastPXDChip)
426  expectedLastChipNo = self.gTools.getNumberOfPXDVSideChips(self.gTools.getLastPXDLayer())
427  if (lastChipLayer != self.gTools.getLastPXDLayer() or
428  lastChipUSide or
429  lastChipNo != expectedLastChipNo):
430  basf2.B2ERROR(
431  'Wrong last PXD chip assignment:\n' +
432  'Expected layer {0} side {1} chip {2},\nGot layer {3} side {4} chip {5}'.format(
433  self.gTools.getLastPXDLayer(),
434  'v',
435  expectedLastChipNo,
436  lastChipLayer,
437  'u' if lastChipUSide else 'v',
438  lastChipNo))
439  # 5g. Test of SVD chip assignment
440  # We want to see that the first and last chips have correct placement.
441  indexOfFirstSVDChip = 0
442  # First chip must be on first SVD layer, 1st ladder, 1st sensor, u-sie,
443  # chip 0.
444  idOfFirstSVDChip = self.gTools.getChipIDFromSVDIndex(indexOfFirstSVDChip)
445  firstChipLayer = idOfFirstSVDChip.getLayerNumber()
446  firstChipLadder = idOfFirstSVDChip.getLadderNumber()
447  firstChipSensor = idOfFirstSVDChip.getSensorNumber()
448  firstChipUSide = self.gTools.isSVDSideU(idOfFirstSVDChip)
449  firstChipNo = self.gTools.getSVDChipNumber(idOfFirstSVDChip)
450  if (firstChipLayer != self.gTools.getFirstSVDLayer() or
451  firstChipLadder != 1 or
452  firstChipSensor != 1 or
453  not firstChipUSide or
454  firstChipNo != 1):
455  basf2.B2ERROR(
456  'Wrong 1st SVD chip assignment:\nExpected {0}/{1}/{2} side {3} chip {4},\nGot {5}/{6}/{7} side {8} chip {9}'.format(
457  self.gTools.getFirstSVDLayer(),
458  1,
459  1,
460  'u',
461  1,
462  firstChipLayer,
463  firstChipLadder,
464  firstChipSensor,
465  'u' if firstChipUSide else 'v',
466  firstChipNo))
467  indexOfLastSVDChip = self.gTools.getTotalSVDChips() - 1
468  # Last chip must be on last SVD layer, v-sie, chip 6.
469  idOfLastSVDChip = self.gTools.getChipIDFromSVDIndex(indexOfLastSVDChip)
470  lastChipLayer = idOfLastSVDChip.getLayerNumber()
471  lastChipUSide = self.gTools.isSVDSideU(idOfLastSVDChip)
472  lastChipNo = self.gTools.getSVDChipNumber(idOfLastSVDChip)
473  expectedLastChipNo = self.gTools.getNumberOfSVDVSideChips(self.gTools.getLastSVDLayer())
474  if (lastChipLayer != self.gTools.getLastSVDLayer() or
475  lastChipUSide or
476  lastChipNo != expectedLastChipNo):
477  basf2.B2ERROR(
478  'Wrong last SVD chip assignment:\n' +
479  'Expected layer {0} side {1} chip {2},\nGot layer {3} side {4} chip {5}'.format(
480  self.gTools.getLastSVDLayer(),
481  'v',
482  expectedLastChipNo,
483  lastChipLayer,
484  'u' if lastChipUSide else 'v',
485  lastChipNo))
486 
487  # END OF TESTS
488 
489 
490 if __name__ == "__main__":
491 
492  with b2test_utils.clean_working_directory():
493 
494  basf2.B2INFO('Setting up a basf2 run...')
495 
496  check_numbering = basf2.create_path()
497  check_numbering.add_module('EventInfoSetter', expList=[0], runList=[0], evtNumList=[1])
498  check_numbering.add_module('Gearbox')
499  check_numbering.add_module('Geometry', components=['MagneticField', 'PXD', 'SVD'])
500  check_numbering.add_module(CheckNumbering())
501  # with b2test_utils.show_only_errors():
502  b2test_utils.safe_process(check_numbering)
503 
504  basf2.B2INFO('Test complete.')
test_geotools.CheckNumbering.__init__
def __init__(self)
Definition: test_geotools.py:17
test_geotools.CheckNumbering
Definition: test_geotools.py:13
Belle2::VxdID
Class to uniquely identify a any structure of the PXD and SVD.
Definition: VxdID.h:43
test_geotools.CheckNumbering.initialize
def initialize(self)
Definition: test_geotools.py:21
test_geotools.CheckNumbering.gTools
gTools
Reference to GeoTools class.
Definition: test_geotools.py:25
Belle2::VXD::GeoCache::getInstance
static GeoCache & getInstance()
Return a reference to the singleton instance.
Definition: GeoCache.cc:215
b2test_utils.clean_working_directory
def clean_working_directory()
Definition: __init__.py:176
b2test_utils.safe_process
def safe_process(*args, **kwargs)
Definition: __init__.py:224
test_geotools.CheckNumbering.event
def event(self)
Definition: test_geotools.py:29