ATLAS Offline Software
DetectorConfigFlags.py
Go to the documentation of this file.
1 # Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
2 
3 from AthenaConfiguration.AthConfigFlags import AthConfigFlags
4 from AthenaConfiguration.AutoConfigFlags import getDefaultDetectors
5 
6 # all detectors - used in helper functions
7 allDetectors = [
8  'Bpipe',
9  'BCM', 'Pixel', 'SCT', 'TRT',
10  'BCMPrime', 'PLR', 'ITkPixel', 'ITkStrip', 'HGTD',
11  'LAr', 'Tile', 'MBTS',
12  'CSC', 'MDT', 'RPC', 'TGC', 'sTGC', 'MM',
13  'Lucid', 'ZDC', 'ALFA', 'AFP', 'FwdRegion',
14  'Cavern',
15 ]
16 # all detector groups - used in helper functions
17 allGroups = {
18  'ID': ['BCM', 'Pixel', 'SCT', 'TRT'],
19  'ITk': ['BCMPrime', 'ITkPixel', 'ITkStrip', 'PLR'],
20  'Calo': ['LAr', 'Tile', 'MBTS'],
21  'Muon': ['CSC', 'MDT', 'RPC', 'TGC', 'sTGC', 'MM'],
22  'Forward': ['Lucid', 'ZDC', 'ALFA', 'AFP', 'FwdRegion'],
23 }
24 
25 
26 def createDetectorConfigFlags():
27  dcf = AthConfigFlags()
28 
29 
31  dcf.addFlag('Detector.GeometryBpipe', True) # always enabled by default
32 
33  # Inner Detector
34  dcf.addFlag('Detector.GeometryBCM', lambda prevFlags : 'BCM' in getDefaultDetectors(prevFlags.GeoModel.AtlasVersion,prevFlags.GeoModel.SQLiteDB,prevFlags.GeoModel.SQLiteDBFullPath))
35  dcf.addFlag('Detector.GeometryPixel', lambda prevFlags : 'Pixel' in getDefaultDetectors(prevFlags.GeoModel.AtlasVersion,prevFlags.GeoModel.SQLiteDB,prevFlags.GeoModel.SQLiteDBFullPath))
36  dcf.addFlag('Detector.GeometrySCT', lambda prevFlags : 'SCT' in getDefaultDetectors(prevFlags.GeoModel.AtlasVersion,prevFlags.GeoModel.SQLiteDB,prevFlags.GeoModel.SQLiteDBFullPath))
37  dcf.addFlag('Detector.GeometryTRT', lambda prevFlags : 'TRT' in getDefaultDetectors(prevFlags.GeoModel.AtlasVersion,prevFlags.GeoModel.SQLiteDB,prevFlags.GeoModel.SQLiteDBFullPath))
38  dcf.addFlag('Detector.GeometryID', lambda prevFlags : (prevFlags.Detector.GeometryBCM
39  or prevFlags.Detector.GeometryPixel or prevFlags.Detector.GeometrySCT
40  or prevFlags.Detector.GeometryTRT))
41 
42  # Upgrade ITk Inner Tracker is a separate and parallel detector
43  dcf.addFlag('Detector.GeometryPLR', lambda prevFlags : 'PLR' in getDefaultDetectors(prevFlags.GeoModel.AtlasVersion,prevFlags.GeoModel.SQLiteDB,prevFlags.GeoModel.SQLiteDBFullPath))
44  dcf.addFlag('Detector.GeometryBCMPrime', lambda prevFlags : 'BCMPrime' in getDefaultDetectors(prevFlags.GeoModel.AtlasVersion,prevFlags.GeoModel.SQLiteDB,prevFlags.GeoModel.SQLiteDBFullPath))
45  dcf.addFlag('Detector.GeometryITkPixel', lambda prevFlags : 'ITkPixel' in getDefaultDetectors(prevFlags.GeoModel.AtlasVersion,prevFlags.GeoModel.SQLiteDB,prevFlags.GeoModel.SQLiteDBFullPath))
46  dcf.addFlag('Detector.GeometryITkStrip', lambda prevFlags : 'ITkStrip' in getDefaultDetectors(prevFlags.GeoModel.AtlasVersion,prevFlags.GeoModel.SQLiteDB,prevFlags.GeoModel.SQLiteDBFullPath))
47  dcf.addFlag('Detector.GeometryITk', lambda prevFlags : (prevFlags.Detector.GeometryBCMPrime
48  or prevFlags.Detector.GeometryITkPixel
49  or prevFlags.Detector.GeometryITkStrip
50  or prevFlags.Detector.GeometryPLR))
51  # HGTD
52  dcf.addFlag('Detector.GeometryHGTD', lambda prevFlags : 'HGTD' in getDefaultDetectors(prevFlags.GeoModel.AtlasVersion,prevFlags.GeoModel.SQLiteDB,prevFlags.GeoModel.SQLiteDBFullPath))
53 
54  # Calorimeters
55  dcf.addFlag('Detector.GeometryLAr', lambda prevFlags : 'LAr' in getDefaultDetectors(prevFlags.GeoModel.AtlasVersion,prevFlags.GeoModel.SQLiteDB,prevFlags.GeoModel.SQLiteDBFullPath)) # Add separate em HEC and FCAL flags?
56  dcf.addFlag('Detector.GeometryTile', lambda prevFlags : 'Tile' in getDefaultDetectors(prevFlags.GeoModel.AtlasVersion,prevFlags.GeoModel.SQLiteDB,prevFlags.GeoModel.SQLiteDBFullPath))
57  dcf.addFlag('Detector.GeometryMBTS', lambda prevFlags : (prevFlags.Detector.GeometryLAr and 'MBTS' in getDefaultDetectors(prevFlags.GeoModel.AtlasVersion,prevFlags.GeoModel.SQLiteDB,prevFlags.GeoModel.SQLiteDBFullPath)))
58  dcf.addFlag('Detector.GeometryCalo', lambda prevFlags : (prevFlags.Detector.GeometryLAr or prevFlags.Detector.GeometryTile))
59 
60  # Muon Spectrometer
61  dcf.addFlag('Detector.GeometryCSC', lambda prevFlags : 'CSC' in getDefaultDetectors(prevFlags.GeoModel.AtlasVersion,prevFlags.GeoModel.SQLiteDB,prevFlags.GeoModel.SQLiteDBFullPath))
62  dcf.addFlag('Detector.GeometryMDT', lambda prevFlags : 'MDT' in getDefaultDetectors(prevFlags.GeoModel.AtlasVersion,prevFlags.GeoModel.SQLiteDB,prevFlags.GeoModel.SQLiteDBFullPath))
63  dcf.addFlag('Detector.GeometryRPC', lambda prevFlags : 'RPC' in getDefaultDetectors(prevFlags.GeoModel.AtlasVersion,prevFlags.GeoModel.SQLiteDB,prevFlags.GeoModel.SQLiteDBFullPath))
64  dcf.addFlag('Detector.GeometryTGC', lambda prevFlags : 'TGC' in getDefaultDetectors(prevFlags.GeoModel.AtlasVersion,prevFlags.GeoModel.SQLiteDB,prevFlags.GeoModel.SQLiteDBFullPath))
65  dcf.addFlag('Detector.GeometrysTGC', lambda prevFlags : 'sTGC' in getDefaultDetectors(prevFlags.GeoModel.AtlasVersion,prevFlags.GeoModel.SQLiteDB,prevFlags.GeoModel.SQLiteDBFullPath))
66  dcf.addFlag('Detector.GeometryMM', lambda prevFlags : 'MM' in getDefaultDetectors(prevFlags.GeoModel.AtlasVersion,prevFlags.GeoModel.SQLiteDB,prevFlags.GeoModel.SQLiteDBFullPath))
67  dcf.addFlag('Detector.GeometryMuon', lambda prevFlags : (prevFlags.Detector.GeometryCSC or prevFlags.Detector.GeometryMDT
68  or prevFlags.Detector.GeometryRPC or prevFlags.Detector.GeometryTGC
69  or prevFlags.Detector.GeometrysTGC or prevFlags.Detector.GeometryMM))
70 
71  # Forward detectors (disabled by default)
72  dcf.addFlag('Detector.GeometryLucid', lambda prevFlags : 'Lucid' in getDefaultDetectors(prevFlags.GeoModel.AtlasVersion,prevFlags.GeoModel.SQLiteDB, prevFlags.GeoModel.SQLiteDBFullPath, includeForward=not prevFlags.Input.isMC))
73  dcf.addFlag('Detector.GeometryZDC', lambda prevFlags : 'ZDC' in getDefaultDetectors(prevFlags.GeoModel.AtlasVersion,prevFlags.GeoModel.SQLiteDB, prevFlags.GeoModel.SQLiteDBFullPath, includeForward=not prevFlags.Input.isMC))
74  dcf.addFlag('Detector.GeometryALFA', lambda prevFlags : 'ALFA' in getDefaultDetectors(prevFlags.GeoModel.AtlasVersion,prevFlags.GeoModel.SQLiteDB, prevFlags.GeoModel.SQLiteDBFullPath, includeForward=not prevFlags.Input.isMC))
75  dcf.addFlag('Detector.GeometryAFP', lambda prevFlags : 'AFP' in getDefaultDetectors(prevFlags.GeoModel.AtlasVersion,prevFlags.GeoModel.SQLiteDB, prevFlags.GeoModel.SQLiteDBFullPath, includeForward=not prevFlags.Input.isMC))
76  dcf.addFlag('Detector.GeometryFwdRegion', lambda prevFlags : 'FwdRegion' in getDefaultDetectors(prevFlags.GeoModel.AtlasVersion,prevFlags.GeoModel.SQLiteDB, prevFlags.GeoModel.SQLiteDBFullPath, includeForward=not prevFlags.Input.isMC))
77  dcf.addFlag('Detector.GeometryForward', lambda prevFlags : (prevFlags.Detector.GeometryLucid or prevFlags.Detector.GeometryZDC
78  or prevFlags.Detector.GeometryALFA or prevFlags.Detector.GeometryAFP
79  or prevFlags.Detector.GeometryFwdRegion))
80 
81  # Cavern (disabled by default)
82  dcf.addFlag('Detector.GeometryCavern', False)
83 
84 
85 
88  dcf.addFlag('Detector.EnableBCM', lambda prevFlags : prevFlags.Detector.GeometryBCM)
89  dcf.addFlag('Detector.EnablePixel', lambda prevFlags : prevFlags.Detector.GeometryPixel)
90  dcf.addFlag('Detector.EnableSCT', lambda prevFlags : prevFlags.Detector.GeometrySCT)
91  dcf.addFlag('Detector.EnableTRT', lambda prevFlags : prevFlags.Detector.GeometryTRT)
92  dcf.addFlag('Detector.EnableID', lambda prevFlags : prevFlags.Detector.GeometryID and
93  (prevFlags.Detector.EnableBCM
94  or prevFlags.Detector.EnablePixel or prevFlags.Detector.EnableSCT
95  or prevFlags.Detector.EnableTRT))
96 
97  # Upgrade ITk Inner Tracker is a separate and parallel detector
98  dcf.addFlag('Detector.EnablePLR', lambda prevFlags : prevFlags.Detector.GeometryPLR)
99  dcf.addFlag('Detector.EnableBCMPrime', lambda prevFlags : prevFlags.Detector.GeometryBCMPrime)
100  dcf.addFlag('Detector.EnableITkPixel', lambda prevFlags : prevFlags.Detector.GeometryITkPixel)
101  dcf.addFlag('Detector.EnableITkStrip', lambda prevFlags : prevFlags.Detector.GeometryITkStrip)
102  dcf.addFlag('Detector.EnableITk', lambda prevFlags : prevFlags.Detector.GeometryITk and
103  (prevFlags.Detector.EnableBCMPrime
104  or prevFlags.Detector.EnableITkPixel
105  or prevFlags.Detector.EnableITkStrip
106  or prevFlags.Detector.EnablePLR))
107  # HGTD
108  dcf.addFlag('Detector.EnableHGTD', lambda prevFlags : prevFlags.Detector.GeometryHGTD)
109 
110  # Calorimeters
111  dcf.addFlag('Detector.EnableLAr', lambda prevFlags : prevFlags.Detector.GeometryLAr)
112  dcf.addFlag('Detector.EnableTile', lambda prevFlags : prevFlags.Detector.GeometryTile)
113  dcf.addFlag('Detector.EnableMBTS', lambda prevFlags : prevFlags.Detector.GeometryMBTS)
114  dcf.addFlag('Detector.EnableL1Calo', lambda prevFlags : (prevFlags.Detector.EnableLAr or prevFlags.Detector.EnableTile))
115  dcf.addFlag('Detector.EnableCalo', lambda prevFlags : prevFlags.Detector.GeometryCalo and
116  (prevFlags.Detector.EnableLAr or prevFlags.Detector.EnableTile))
117 
118  # Muon Spectrometer
119  dcf.addFlag('Detector.EnableCSC', lambda prevFlags : prevFlags.Detector.GeometryCSC)
120  dcf.addFlag('Detector.EnableMDT', lambda prevFlags : prevFlags.Detector.GeometryMDT)
121  dcf.addFlag('Detector.EnableRPC', lambda prevFlags : prevFlags.Detector.GeometryRPC)
122  dcf.addFlag('Detector.EnableTGC', lambda prevFlags : prevFlags.Detector.GeometryTGC)
123  dcf.addFlag('Detector.EnablesTGC', lambda prevFlags : prevFlags.Detector.GeometrysTGC)
124  dcf.addFlag('Detector.EnableMM', lambda prevFlags : prevFlags.Detector.GeometryMM)
125  dcf.addFlag('Detector.EnableMuon', lambda prevFlags : prevFlags.Detector.GeometryMuon and
126  (prevFlags.Detector.EnableCSC or prevFlags.Detector.EnableMDT
127  or prevFlags.Detector.EnableRPC or prevFlags.Detector.EnableTGC
128  or prevFlags.Detector.EnablesTGC or prevFlags.Detector.EnableMM))
129 
130  # Forward detectors (disabled by default)
131  dcf.addFlag('Detector.EnableLucid', lambda prevFlags : prevFlags.Detector.GeometryLucid)
132  # EnableZDC enables the overall ZDC system, while _ZDC and _RPD refer to the subsystems, which are now independent
133  dcf.addFlag('Detector.EnableZDC', lambda prevFlags : prevFlags.Detector.GeometryZDC)
134  dcf.addFlag('Detector.EnableZDC_ZDC', lambda prevFlags : prevFlags.Detector.GeometryZDC)
135  dcf.addFlag('Detector.EnableZDC_RPD', lambda prevFlags : prevFlags.Detector.GeometryZDC)
136  dcf.addFlag('Detector.EnableALFA', lambda prevFlags : prevFlags.Detector.GeometryALFA)
137  dcf.addFlag('Detector.EnableAFP', lambda prevFlags : prevFlags.Detector.GeometryAFP)
138  dcf.addFlag('Detector.EnableFwdRegion', lambda prevFlags : prevFlags.Detector.GeometryFwdRegion)
139  dcf.addFlag('Detector.EnableForward', lambda prevFlags : prevFlags.Detector.GeometryForward and
140  (prevFlags.Detector.EnableLucid or prevFlags.Detector.EnableZDC
141  or prevFlags.Detector.EnableALFA or prevFlags.Detector.EnableAFP
142  or prevFlags.Detector.EnableFwdRegion))
143 
144  return dcf
145 
146 
147 def getEnabledDetectors(flags, geometry=False):
148  # load flags
149  flags._loadDynaFlags('Detector')
150  values = []
151  for d in allDetectors:
152  # test whether each detector is on
153  name = f'Detector.Geometry{d}' if geometry else f'Detector.Enable{d}'
154  if flags.hasFlag(name):
155  if flags[name] is not False:
156  values.append(d)
157  return values
158 
159 
160 def _parseDetectorsList(flags, detectors):
161  # setup logging
162  from AthenaCommon.Logging import logging
163  log = logging.getLogger('DetectorConfigFlags')
164  # load flags
165  flags._loadDynaFlags('Detector')
166  # compatibility
167  ignored_detectors = ['None', 'Truth', 'DBM']
168  def compatibility_layer(detector):
169  if detector == 'pixel':
170  return 'Pixel'
171  if detector == 'Micromegas':
172  return 'MM'
173  return detector
174 
175  # first check if we have groups
176  groups = {d for d in detectors if d in allGroups.keys()}
177  detectors = {compatibility_layer(d) for d in detectors if d not in allGroups.keys()}
178  for g in groups:
179  log.debug("Evaluating detector group '%s'", g)
180  if g == 'Forward':
181  # forward detectors are special
182  for d in allGroups[g]:
183  log.debug("Appending detector '%s'", d)
184  detectors.add(d)
185  else:
186  # in case of groups only enable defaults
187  for d in allGroups[g]:
188  if d in getDefaultDetectors(flags.GeoModel.AtlasVersion,flags.GeoModel.SQLiteDB,flags.GeoModel.SQLiteDBFullPath):
189  log.debug("Appending detector '%s'", d)
190  detectors.add(d)
191 
192  # check if valid detectors are required
193  for d in detectors:
194  if d not in allDetectors and d not in ignored_detectors:
195  log.warning("Unknown detector '%s'", d)
196 
197  # sort the detectors
198  return [d for d in allDetectors if d in detectors]
199 
200 
201 def _loadDetectorsFromMetaData(flags, key, keep_beampipe=False):
202  from AthenaConfiguration.AutoConfigFlags import GetFileMD
203  detectors = eval(GetFileMD(flags.Input.Files).get(key, '[]'))
204  if not detectors:
205  return []
206 
207  # MBTS compatibility check
208  from AthenaConfiguration.Enums import LHCPeriod
209  if (flags.GeoModel.Run < LHCPeriod.Run4 and 'LAr' in detectors # built as part of LAr
210  or 'TileHitVector#MBTSHits' in flags.Input.TypedCollections
211  or 'TileTTL1Container#TileTTL1MBTS' in flags.Input.TypedCollections):
212  detectors.append('MBTS')
213 
214  if keep_beampipe and flags.Detector.GeometryBpipe:
215  detectors.append('Bpipe')
216 
217  return _parseDetectorsList(flags, detectors)
218 
219 
220 def _getDetectorFlagStatus(flags, list=None, geometry=False):
221  # load flags
222  flags._loadDynaFlags('Detector')
223 
224  values = []
225  for d in allDetectors:
226  # test whether each detector is on
227  name = f'Detector.Geometry{d}' if geometry else f'Detector.Enable{d}'
228  if flags.hasFlag(name):
229  if list is not None:
230  if d in list:
231  values.append('ON')
232  else:
233  values.append('--')
234  else:
235  if flags[name] is not False:
236  values.append('ON')
237  else:
238  values.append('--')
239  else:
240  values.append('n/a')
241  return values
242 
243 
244 def _printDetectorFlags(flags, info_dict):
245  # setup logging
246  from AthenaCommon.Logging import logging
247  log = logging.getLogger('DetectorConfigFlags')
248  # generate common formatting string
249  item_len = 7
250  # initial is always there
251  types = ['Initial']
252  subtypes = ['Geo.', 'Enbl.']
253  format_header = f'%-{item_len * 2}s'
254  if 'metadata_simulated' in info_dict.keys() or 'metadata_digitized' in info_dict.keys():
255  metadata_len = 0
256  if 'metadata_simulated' in info_dict.keys():
257  subtypes.append('Sim.')
258  metadata_len += item_len
259  if 'metadata_digitized' in info_dict.keys():
260  subtypes.append('Digi.')
261  metadata_len += item_len
262  types.append('Metadata' if item_len > 8 else 'Meta.')
263  format_header += f'%-{metadata_len}s'
264  if 'requested_geometry' in info_dict.keys():
265  types.append('Requested')
266  subtypes += ['Geo.', 'Enbl.']
267  format_header += f'%-{item_len * 2}s'
268  # final is always there ?
269  types.append('Final')
270  subtypes += ['Geo.', 'Enbl.']
271  format_header += f'%-{item_len * 2}s'
272 
273  detector_len = 7
274  for d in allDetectors:
275  detector_len = max(detector_len, len(d) + 2)
276 
277  format_header = f'%{detector_len}s ' + format_header
278  format_subheader = f'%{detector_len}s ' + len(subtypes) * f'%-{item_len}s'
279  format = f'%{detector_len}s : ' + len(subtypes) * f'%-{item_len}s'
280  data = [allDetectors] + [v for _, v in info_dict.items()]
281  data = list(map(list, zip(*data)))
282 
283  # print header rows
284  log.info(format_header, *([''] + types))
285  log.info(format_subheader, *([''] + subtypes))
286  # print data
287  for row in data:
288  log.info(format, *row)
289 
290 
291 def setupDetectorFlags(flags, custom_list=None, use_metadata=False, toggle_geometry=False, validate_only=False, keep_beampipe=False):
292  """Setup detector flags from metadata or a list"""
293  info_dict = {}
294  # setup logging
295  from AthenaCommon.Logging import logging
296  log = logging.getLogger('DetectorConfigFlags')
297 
298  initial_set = set(getEnabledDetectors(flags))
299 
300  info_dict['initial_geometry'] = _getDetectorFlagStatus(flags, geometry=True)
301  info_dict['initial_enable'] = _getDetectorFlagStatus(flags, geometry=False)
302 
303  final_set = initial_set
304  has_metadata = False
305  if use_metadata:
306  simulated_set = set(_loadDetectorsFromMetaData(flags, 'SimulatedDetectors', keep_beampipe=keep_beampipe))
307  digitized_set = set(_loadDetectorsFromMetaData(flags, 'DigitizedDetectors', keep_beampipe=keep_beampipe))
308  if simulated_set:
309  has_metadata = True
310  info_dict['metadata_simulated'] = _getDetectorFlagStatus(flags, list=simulated_set, geometry=False)
311  if digitized_set:
312  has_metadata = True
313  info_dict['metadata_digitized'] = _getDetectorFlagStatus(flags, list=digitized_set, geometry=False)
314 
315  if digitized_set and digitized_set != initial_set:
316  final_set = digitized_set
317  elif simulated_set and simulated_set != initial_set:
318  final_set = simulated_set
319 
320  requested_inconsistency_set = set()
321  if custom_list is not None and custom_list:
322  requested_set = set(_parseDetectorsList(flags, custom_list))
323  if toggle_geometry:
324  info_dict['requested_geometry'] = _getDetectorFlagStatus(flags, list=requested_set, geometry=True)
325  else:
326  info_dict['requested_geometry'] = info_dict['initial_geometry']
327  info_dict['requested_enable'] = _getDetectorFlagStatus(flags, list=requested_set, geometry=False)
328 
329  if has_metadata:
330  requested_inconsistency_set = requested_set.difference(final_set)
331  final_set = requested_set.intersection(final_set)
332  else:
333  final_set = requested_set
334 
335  info_dict['final_geometry'] = _getDetectorFlagStatus(flags, list=final_set, geometry=True)
336  info_dict['final_enable'] = _getDetectorFlagStatus(flags, list=final_set, geometry=False)
337 
338  _printDetectorFlags(flags, info_dict)
339 
340  if requested_inconsistency_set:
341  log.error('Requested detectors %s which are not enabled in the input file.', list(requested_inconsistency_set))
342  raise ValueError(list(requested_inconsistency_set))
343 
344  if initial_set != final_set:
345  diff_enable = final_set.difference(initial_set)
346  if 'Bpipe' in diff_enable and (keep_beampipe or flags.Detector.GeometryBpipe):
347  diff_enable.remove('Bpipe')
348  diff_disable = initial_set.difference(final_set)
349  if diff_enable:
350  log.info('Enabling detectors: %s', _parseDetectorsList(flags, diff_enable))
351  if diff_disable:
352  log.info('Disabling detectors: %s', _parseDetectorsList(flags, diff_disable))
353  setupDetectorsFromList(flags, final_set, toggle_geometry, validate_only)
354 
355 
356 def setupDetectorsFromList(flags, detectors, toggle_geometry=False, validate_only=False):
357  """Setup (toggle) detectors from a pre-defined list"""
358  changed = False
359  # setup logging
360  from AthenaCommon.Logging import logging
361  log = logging.getLogger('DetectorConfigFlags')
362  # parse the list
363  detectors = _parseDetectorsList(flags, detectors)
364 
365  # print summary
366  if validate_only:
367  log.info('Required detectors: %s', detectors)
368  else:
369  log.debug('Setting detectors to: %s', detectors)
370 
371  # go through all of the detectors and check what should happen
372  for d in allDetectors:
373  status = d in detectors
374  name = f'Detector.Enable{d}'
375  if flags.hasFlag(name):
376  if flags[name] != status:
377  changed = True
378  if validate_only:
379  log.warning("Flag '%s' should be %s but is set to %s", name, status, not status)
380  else:
381  log.debug("Toggling '%s' from %s to %s", name, not status, status)
382  flags._set(name, status)
383  if toggle_geometry:
384  name = f'Detector.Geometry{d}'
385  if flags.hasFlag(name):
386  if flags[name] != status:
387  changed = True
388  if validate_only:
389  log.warning("Flag '%s' should be %s but is set to %s", name, status, not status)
390  else:
391  log.debug("Toggling '%s' from %s to %s", name, not status, status)
392  flags._set(name, status)
393 
394  return changed
395 
396 
397 def enableDetectors(flags, detectors, toggle_geometry=False):
398  """Enable detectors from a list"""
399  changed = False
400  # setup logging
401  from AthenaCommon.Logging import logging
402  log = logging.getLogger('DetectorConfigFlags')
403  # parse the list
404  detectors = _parseDetectorsList(flags, detectors)
405 
406  # debugging
407  log.info('Enabling detectors: %s', detectors)
408 
409  # go through all of the detectors and enable them if needed
410  for d in detectors:
411  name = f'Detector.Enable{d}'
412  if flags.hasFlag(name):
413  if flags[name] is not True:
414  changed = True
415  log.info("Enabling '%s'", name)
416  flags._set(name, True)
417  if toggle_geometry:
418  name = f'Detector.Geometry{d}'
419  if flags.hasFlag(name):
420  if flags[name] is not True:
421  changed = True
422  log.info("Enabling '%s'", name)
423  flags._set(name, True)
424 
425  return changed
426 
427 
428 def disableDetectors(flags, detectors, toggle_geometry=False):
429  """Disable detectors from a list"""
430  changed = False
431  # setup logging
432  from AthenaCommon.Logging import logging
433  log = logging.getLogger('DetectorConfigFlags')
434  # parse the list
435  detectors = _parseDetectorsList(flags, detectors)
436 
437  # debugging
438  log.info('Disabling detectors: %s', detectors)
439 
440  # go through all of the detectors and disable them if needed
441  for d in detectors:
442  name = f'Detector.Enable{d}'
443  if flags.hasFlag(name):
444  if flags[name] is not False:
445  changed = True
446  log.info("Disabling '%s'", name)
447  flags._set(name, False)
448  if toggle_geometry:
449  name = f'Detector.Geometry{d}'
450  if flags.hasFlag(name):
451  if flags[name] is not False:
452  changed = True
453  log.info("Disabling '%s'", name)
454  flags._set(name, False)
455 
456  return changed
457 
python.AutoConfigFlags.GetFileMD
def GetFileMD(filenames, allowEmpty=True, maxLevel='peeker')
Definition: AutoConfigFlags.py:65
python.DetectorConfigFlags._parseDetectorsList
def _parseDetectorsList(flags, detectors)
Definition: DetectorConfigFlags.py:160
python.AutoConfigFlags.getDefaultDetectors
def getDefaultDetectors(geoTag, sqliteDB, sqliteDBFullPath, includeForward=False)
Definition: AutoConfigFlags.py:148
python.DetectorConfigFlags.getEnabledDetectors
def getEnabledDetectors(flags, geometry=False)
Definition: DetectorConfigFlags.py:147
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
python.DetectorConfigFlags._loadDetectorsFromMetaData
def _loadDetectorsFromMetaData(flags, key, keep_beampipe=False)
Definition: DetectorConfigFlags.py:201
python.DetectorConfigFlags._getDetectorFlagStatus
def _getDetectorFlagStatus(flags, list=None, geometry=False)
Definition: DetectorConfigFlags.py:220
python.DetectorConfigFlags.createDetectorConfigFlags
def createDetectorConfigFlags()
Definition: DetectorConfigFlags.py:26
python.DetectorConfigFlags.enableDetectors
def enableDetectors(flags, detectors, toggle_geometry=False)
Definition: DetectorConfigFlags.py:397
python.DetectorConfigFlags.setupDetectorsFromList
def setupDetectorsFromList(flags, detectors, toggle_geometry=False, validate_only=False)
Definition: DetectorConfigFlags.py:356
python.DetectorConfigFlags.disableDetectors
def disableDetectors(flags, detectors, toggle_geometry=False)
Definition: DetectorConfigFlags.py:428
histSizes.list
def list(name, path='/')
Definition: histSizes.py:38
CxxUtils::set
constexpr std::enable_if_t< is_bitmask_v< E >, E & > set(E &lhs, E rhs)
Convenience function to set bits in a class enum bitmask.
Definition: bitmask.h:232
python.DetectorConfigFlags.setupDetectorFlags
def setupDetectorFlags(flags, custom_list=None, use_metadata=False, toggle_geometry=False, validate_only=False, keep_beampipe=False)
Definition: DetectorConfigFlags.py:291
get
T * get(TKey *tobj)
get a TObject* from a TKey* (why can't a TObject be a TKey?)
Definition: hcg.cxx:127
python.DetectorConfigFlags._printDetectorFlags
def _printDetectorFlags(flags, info_dict)
Definition: DetectorConfigFlags.py:244
Generated on Wed Mar 12 2025 21:09:40 for ATLAS Offline Software by   doxygen 1.8.18