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 ((not flags.GeoModel.AtlasVersion.startswith('ATLAS-CTB')
210  and flags.GeoModel.Run < LHCPeriod.Run4 and 'LAr' in detectors) # built as part of LAr
211  or 'TileHitVector#MBTSHits' in flags.Input.TypedCollections
212  or 'TileTTL1Container#TileTTL1MBTS' in flags.Input.TypedCollections):
213  detectors.append('MBTS')
214 
215  if keep_beampipe and flags.Detector.GeometryBpipe:
216  detectors.append('Bpipe')
217 
218  return _parseDetectorsList(flags, detectors)
219 
220 
221 def _getDetectorFlagStatus(flags, list=None, geometry=False):
222  # load flags
223  flags._loadDynaFlags('Detector')
224 
225  values = []
226  for d in allDetectors:
227  # test whether each detector is on
228  name = f'Detector.Geometry{d}' if geometry else f'Detector.Enable{d}'
229  if flags.hasFlag(name):
230  if list is not None:
231  if d in list:
232  values.append('ON')
233  else:
234  values.append('--')
235  else:
236  if flags[name] is not False:
237  values.append('ON')
238  else:
239  values.append('--')
240  else:
241  values.append('n/a')
242  return values
243 
244 
245 def _printDetectorFlags(flags, info_dict):
246  # setup logging
247  from AthenaCommon.Logging import logging
248  log = logging.getLogger('DetectorConfigFlags')
249  # generate common formatting string
250  item_len = 7
251  # initial is always there
252  types = ['Initial']
253  subtypes = ['Geo.', 'Enbl.']
254  format_header = f'%-{item_len * 2}s'
255  if 'metadata_simulated' in info_dict.keys() or 'metadata_digitized' in info_dict.keys():
256  metadata_len = 0
257  if 'metadata_simulated' in info_dict.keys():
258  subtypes.append('Sim.')
259  metadata_len += item_len
260  if 'metadata_digitized' in info_dict.keys():
261  subtypes.append('Digi.')
262  metadata_len += item_len
263  types.append('Metadata' if item_len > 8 else 'Meta.')
264  format_header += f'%-{metadata_len}s'
265  if 'requested_geometry' in info_dict.keys():
266  types.append('Requested')
267  subtypes += ['Geo.', 'Enbl.']
268  format_header += f'%-{item_len * 2}s'
269  # final is always there ?
270  types.append('Final')
271  subtypes += ['Geo.', 'Enbl.']
272  format_header += f'%-{item_len * 2}s'
273 
274  detector_len = 7
275  for d in allDetectors:
276  detector_len = max(detector_len, len(d) + 2)
277 
278  format_header = f'%{detector_len}s ' + format_header
279  format_subheader = f'%{detector_len}s ' + len(subtypes) * f'%-{item_len}s'
280  format = f'%{detector_len}s : ' + len(subtypes) * f'%-{item_len}s'
281  data = [allDetectors] + [v for _, v in info_dict.items()]
282  data = list(map(list, zip(*data)))
283 
284  # print header rows
285  log.info(format_header, *([''] + types))
286  log.info(format_subheader, *([''] + subtypes))
287  # print data
288  for row in data:
289  log.info(format, *row)
290 
291 
292 def setupDetectorFlags(flags, custom_list=None, use_metadata=False, toggle_geometry=False, validate_only=False, keep_beampipe=False):
293  """Setup detector flags from metadata or a list"""
294  info_dict = {}
295  # setup logging
296  from AthenaCommon.Logging import logging
297  log = logging.getLogger('DetectorConfigFlags')
298 
299  initial_set = set(getEnabledDetectors(flags))
300 
301  info_dict['initial_geometry'] = _getDetectorFlagStatus(flags, geometry=True)
302  info_dict['initial_enable'] = _getDetectorFlagStatus(flags, geometry=False)
303 
304  final_set = initial_set
305  has_metadata = False
306  if use_metadata:
307  simulated_set = set(_loadDetectorsFromMetaData(flags, 'SimulatedDetectors', keep_beampipe=keep_beampipe))
308  digitized_set = set(_loadDetectorsFromMetaData(flags, 'DigitizedDetectors', keep_beampipe=keep_beampipe))
309  if simulated_set:
310  has_metadata = True
311  info_dict['metadata_simulated'] = _getDetectorFlagStatus(flags, list=simulated_set, geometry=False)
312  if digitized_set:
313  has_metadata = True
314  info_dict['metadata_digitized'] = _getDetectorFlagStatus(flags, list=digitized_set, geometry=False)
315 
316  if digitized_set and digitized_set != initial_set:
317  final_set = digitized_set
318  elif simulated_set and simulated_set != initial_set:
319  final_set = simulated_set
320 
321  requested_inconsistency_set = set()
322  if custom_list is not None and custom_list:
323  requested_set = set(_parseDetectorsList(flags, custom_list))
324  if toggle_geometry:
325  info_dict['requested_geometry'] = _getDetectorFlagStatus(flags, list=requested_set, geometry=True)
326  else:
327  info_dict['requested_geometry'] = info_dict['initial_geometry']
328  info_dict['requested_enable'] = _getDetectorFlagStatus(flags, list=requested_set, geometry=False)
329 
330  if has_metadata:
331  requested_inconsistency_set = requested_set.difference(final_set)
332  final_set = requested_set.intersection(final_set)
333  else:
334  final_set = requested_set
335 
336  info_dict['final_geometry'] = _getDetectorFlagStatus(flags, list=final_set, geometry=True)
337  info_dict['final_enable'] = _getDetectorFlagStatus(flags, list=final_set, geometry=False)
338 
339  _printDetectorFlags(flags, info_dict)
340 
341  if requested_inconsistency_set:
342  log.error('Requested detectors %s which are not enabled in the input file.', list(requested_inconsistency_set))
343  raise ValueError(list(requested_inconsistency_set))
344 
345  if initial_set != final_set:
346  diff_enable = final_set.difference(initial_set)
347  if 'Bpipe' in diff_enable and (keep_beampipe or flags.Detector.GeometryBpipe):
348  diff_enable.remove('Bpipe')
349  diff_disable = initial_set.difference(final_set)
350  if diff_enable:
351  log.info('Enabling detectors: %s', _parseDetectorsList(flags, diff_enable))
352  if diff_disable:
353  log.info('Disabling detectors: %s', _parseDetectorsList(flags, diff_disable))
354  setupDetectorsFromList(flags, final_set, toggle_geometry, validate_only)
355 
356 
357 def setupDetectorsFromList(flags, detectors, toggle_geometry=False, validate_only=False):
358  """Setup (toggle) detectors from a pre-defined list"""
359  changed = False
360  # setup logging
361  from AthenaCommon.Logging import logging
362  log = logging.getLogger('DetectorConfigFlags')
363  # parse the list
364  detectors = _parseDetectorsList(flags, detectors)
365 
366  # print summary
367  if validate_only:
368  log.info('Required detectors: %s', detectors)
369  else:
370  log.debug('Setting detectors to: %s', detectors)
371 
372  # go through all of the detectors and check what should happen
373  for d in allDetectors:
374  status = d in detectors
375  name = f'Detector.Enable{d}'
376  if flags.hasFlag(name):
377  if flags[name] != status:
378  changed = True
379  if validate_only:
380  log.warning("Flag '%s' should be %s but is set to %s", name, status, not status)
381  else:
382  log.debug("Toggling '%s' from %s to %s", name, not status, status)
383  flags._set(name, status)
384  if toggle_geometry:
385  name = f'Detector.Geometry{d}'
386  if flags.hasFlag(name):
387  if flags[name] != status:
388  changed = True
389  if validate_only:
390  log.warning("Flag '%s' should be %s but is set to %s", name, status, not status)
391  else:
392  log.debug("Toggling '%s' from %s to %s", name, not status, status)
393  flags._set(name, status)
394 
395  return changed
396 
397 
398 def enableDetectors(flags, detectors, toggle_geometry=False):
399  """Enable detectors from a list"""
400  changed = False
401  # setup logging
402  from AthenaCommon.Logging import logging
403  log = logging.getLogger('DetectorConfigFlags')
404  # parse the list
405  detectors = _parseDetectorsList(flags, detectors)
406 
407  # debugging
408  log.info('Enabling detectors: %s', detectors)
409 
410  # go through all of the detectors and enable them if needed
411  for d in detectors:
412  name = f'Detector.Enable{d}'
413  if flags.hasFlag(name):
414  if flags[name] is not True:
415  changed = True
416  log.info("Enabling '%s'", name)
417  flags._set(name, True)
418  if toggle_geometry:
419  name = f'Detector.Geometry{d}'
420  if flags.hasFlag(name):
421  if flags[name] is not True:
422  changed = True
423  log.info("Enabling '%s'", name)
424  flags._set(name, True)
425 
426  return changed
427 
428 
429 def disableDetectors(flags, detectors, toggle_geometry=False):
430  """Disable detectors from a list"""
431  changed = False
432  # setup logging
433  from AthenaCommon.Logging import logging
434  log = logging.getLogger('DetectorConfigFlags')
435  # parse the list
436  detectors = _parseDetectorsList(flags, detectors)
437 
438  # debugging
439  log.info('Disabling detectors: %s', detectors)
440 
441  # go through all of the detectors and disable them if needed
442  for d in detectors:
443  name = f'Detector.Enable{d}'
444  if flags.hasFlag(name):
445  if flags[name] is not False:
446  changed = True
447  log.info("Disabling '%s'", name)
448  flags._set(name, False)
449  if toggle_geometry:
450  name = f'Detector.Geometry{d}'
451  if flags.hasFlag(name):
452  if flags[name] is not False:
453  changed = True
454  log.info("Disabling '%s'", name)
455  flags._set(name, False)
456 
457  return changed
458 
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:221
python.DetectorConfigFlags.createDetectorConfigFlags
def createDetectorConfigFlags()
Definition: DetectorConfigFlags.py:26
python.DetectorConfigFlags.enableDetectors
def enableDetectors(flags, detectors, toggle_geometry=False)
Definition: DetectorConfigFlags.py:398
python.DetectorConfigFlags.setupDetectorsFromList
def setupDetectorsFromList(flags, detectors, toggle_geometry=False, validate_only=False)
Definition: DetectorConfigFlags.py:357
python.DetectorConfigFlags.disableDetectors
def disableDetectors(flags, detectors, toggle_geometry=False)
Definition: DetectorConfigFlags.py:429
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:292
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:245
Generated on Tue Sep 23 2025 21:08:54 for ATLAS Offline Software by   doxygen 1.8.18