ATLAS Offline Software
ZdcRecConfig.py
Go to the documentation of this file.
1 #!/usr/bin/env python
2 #
3 # Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
4 #
5 
6 from AthenaConfiguration.ComponentFactory import CompFactory
7 from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
8 from AthenaConfiguration.Enums import Format
9 from AthenaConfiguration.Enums import LHCPeriod
10 
11 from OutputStreamAthenaPool.OutputStreamConfig import addToAOD
12 from OutputStreamAthenaPool.OutputStreamConfig import addToESD
13 
14 from TriggerJobOpts.TriggerByteStreamConfig import ByteStreamReadCfg
15 
16 from ZdcNtuple.ZdcNtupleConfig import ZdcNtupleCfg
17 
18 # FIXME: removing for MC
19 from TrigConfigSvc.TriggerConfigAccess import getL1MenuAccess
20 # added getRun3NavigationContainerFromInput as per Tim Martin's suggestions
21 from TrigDecisionTool.TrigDecisionToolConfig import TrigDecisionToolCfg, getRun3NavigationContainerFromInput
22 from AthenaConfiguration.TestDefaults import defaultGeometryTags, defaultConditionsTags
23 
24 from AthenaCommon.Logging import logging
25 log = logging.getLogger("ZdcRecConfig")
26 
27 zdcConfigMap = {}
28 
29 def zdcGeometry(flags):
30  projName = flags.Input.ProjectName
31  match projName:
32  case "data15_hi":
33  return defaultGeometryTags.RUN2_ZDC
34  case "data18_hi":
35  return defaultGeometryTags.RUN2_ZDC
36  case "data16_hi":
37  return defaultGeometryTags.RUN2_ZDC
38  case "data16_hip":
39  return defaultGeometryTags.RUN2_ZDC
40  case "data23_hi":
41  return defaultGeometryTags.RUN3_ZDC23
42  case "data24_hi":
43  return defaultGeometryTags.RUN3_ZDC24
44  case "data24_hicomm":
45  return defaultGeometryTags.RUN3_ZDC24
46  case "data25_hip":
47  return defaultGeometryTags.RUN3_ZDC24
48  case "data25_hi":
49  return defaultGeometryTags.RUN3_ZDC24
50  case "data25_hipcomm":
51  return defaultGeometryTags.RUN3_ZDC24
52  case "data25_hicomm":
53  return defaultGeometryTags.RUN3_ZDC24
54  case _:
55  run = flags.GeoModel.Run
56  if run == LHCPeriod.Run2:
57  return defaultGeometryTags.RUN2_ZDC
58  if run == LHCPeriod.Run3:
59  return defaultGeometryTags.RUN3_ZDC24
60  return ""
61 
62 def GenerateConfigTagDict():
63 
64  zdcConfigMap['data15_hi'] = {}
65  zdcConfigMap['data16_hip'] = {}
66  zdcConfigMap['data17_13TeV'] = {}
67  zdcConfigMap['data18_hi'] = {}
68  zdcConfigMap['data22_13p6TeV'] = {}
69  zdcConfigMap['data23_5p36TeV'] = {}
70  zdcConfigMap['data23_13p6TeV'] = {}
71  zdcConfigMap['data23_hi'] = {}
72  zdcConfigMap['data23_comm'] = {}
73  zdcConfigMap['data23_5p36TeV'] = {}
74  zdcConfigMap['data24_900GeV'] = {}
75 
76  zdcConfigMap['data24_13p6TeV'] = {}
77  zdcConfigMap['data24_13p6TeV']['default'] = 'pp2024'
78 
79  zdcConfigMap['data24_refcomm'] = {}
80  zdcConfigMap['data24_refcomm']['default'] = 'pp2024'
81  zdcConfigMap['data24_refcomm']['calibration_ZdcInjCalib'] = 'Injectorpp2024'
82 
83  zdcConfigMap['data24_hicomm'] = {}
84  zdcConfigMap['data24_hicomm']['default'] = 'PbPb2024'
85  zdcConfigMap['data24_hicomm']['calibration_ZdcInjCalib'] = 'InjectorPbPb2024'
86 
87  zdcConfigMap['data24_hi'] = {}
88  zdcConfigMap['data24_hi']['default']="PbPb2024"
89  zdcConfigMap['data24_hi']['calibration_ZdcInjCalib']="InjectorPbPb2024"
90 
91 def SetConfigTag(flags):
92 
93  # terrible kludge for early 2025
94  if flags.Input.ProjectName == "data25_comm" and flags.Input.TriggerStream == "calibration_ZDCCalib":
95  config = "InjectorpOOONeNe2025"
96 
97  elif flags.Input.TriggerStream == "calibration_ZDCInjCalib" or flags.Input.TriggerStream == "calibration_DcmDummyProcessor": # calibration_DcmDummyProcessor is the "trigger stream" in the data we record in the standalone partition that is NOT LED data
98  config = "InjectorpOOONeNe2025" # default config tag for injector pulse - suitable also for running in standalone partition (except for standalone data taken during pp reference run + its commissionging period)
99  if flags.Input.ProjectName == "data24_5p36TeV" or flags.Input.ProjectName == "data24_900GeV" or flags.Input.ProjectName == "data24_13p6TeV" or flags.Input.ProjectName == "data24_refcomm":
100  config = "Injectorpp2024"
101  if flags.Input.ProjectName in ["data24_hi","data24_hicomm"]:
102  config = "InjectorPbPb2024"
103  if flags.Input.ProjectName in ["data25_hi","data25_hicomm","data25_hip"] :
104  config = "InjectorpOOONeNe2025"
105 
106  else:
107  config = "PbPb2023" # default config tag
108 
109  run = flags.GeoModel.Run
110  if run == LHCPeriod.Run3:
111  if flags.Input.isMC:
112  config = "MonteCarloPbPb2023"
113  elif flags.Input.ProjectName == "data22_13p6TeV":
114  config = "LHCf2022"
115  elif flags.Input.ProjectName in ["data23_5p36TeV", "data23_900GeV", "data23_13p6TeV"]:
116  config = "pp2023"
117  elif flags.Input.ProjectName in ["data23_hi", "data23_comm"]:
118  config = "PbPb2023"
119  elif flags.Input.ProjectName in ["data24_5p36TeV", "data24_900GeV", "data24_13p6TeV", "data24_refcomm"]:
120  config = "pp2024"
121  elif flags.Input.ProjectName in ["data24_hi", "data24_hicomm"]:
122  config = "PbPb2024"
123  elif flags.Input.ProjectName in ["data25_hipcomm"]:
124  config = "pO2025"
125  elif flags.Input.ProjectName in ["data25_hip"]:
126  config = "pO2025B"
127  elif flags.Input.ProjectName in ["data25_hi","data25_hicomm"]:
128  config = "OONeNe2025"
129  elif run == LHCPeriod.Run2:
130  if flags.Input.ProjectName == "data15_hi":
131  config = "PbPb2015"
132  elif flags.Input.ProjectName == "data17_13TeV":
133  config = "PbPb2015"
134  elif flags.Input.ProjectName == "data16_hip":
135  config = "pPb2016"
136  elif flags.Input.ProjectName == "data18_hi":
137  config = "PbPb2018"
138 
139  return config
140 
141 
142 def ZdcGenericFlagSetting(flags): # pass flags object by reference: directly set flags in function
143  '''set generic flags needed for ZDC reconstruction that are independent of stream type
144  Also fills flags from input arguments'''
145 
146  flags.Scheduler.CheckDependencies = True
147  flags.Scheduler.ShowDataDeps = True
148  flags.Scheduler.ShowDataFlow = True
149  flags.Scheduler.ShowControlFlow = True
150  flags.Scheduler.EnableVerboseViews = True
151 
152  flags.Detector.GeometryZDC=True
153  flags.Detector.GeometryAFP=False
154  flags.Detector.GeometryALFA=False
155  flags.Detector.GeometryLucid=False
156  flags.Detector.GeometryMDT=False
157  flags.Detector.GeometryMM=False
158  flags.Detector.GeometryMuon=False
159 
160  flags.Trigger.decodeHLT=False
161  flags.Trigger.enableL1MuonPhase1=False
162  flags.Trigger.L1.doMuon=False
163  flags.Trigger.L1.doCalo=False
164  flags.Trigger.L1.doTopo=False
165 
166  # This does not work in this context
167  # run = flags.GeoModel.Run
168  # The EDM Version should be auto configured, but is not working at the moment, so is set by hand
169 
170  parser = flags.getArgumentParser()
171  parser.add_argument('--runInjForStandaloneData',default="Inj",help="indicate if we run inj/LED reconstruction for standalone data: inj (default) --> run injected-pulse reconstruction for injector-pulse events; LED --> run LED reconstruction for LED events")
172  flags.fillFromArgs(parser=parser)
173 
174 
175 def ZdcStreamDependentFlagSetting(flags):
176  '''Function that checks on data type from triggerstream tag
177  and sets run-type-and-year-dependent settings
178  Returns: a tuple of the following four values
179  isLED - bool, true if running on LED data
180  isInj - bool, true if running on Inj data
181  isCalib - bool, true if running on Calib data
182  pn - string, project name such as data24_hi
183  '''
184  # check for LED / calibration data running, and configure appropriately
185  isComm = (flags.Input.ProjectName == "data25_comm" and flags.Input.TriggerStream == "calibration_ZDCCalib")
186  isLED = (flags.Input.TriggerStream == "calibration_ZDCLEDCalib")
187  isInj = (flags.Input.TriggerStream == "calibration_ZDCInjCalib" or isComm)
188  isCalib = (flags.Input.TriggerStream == "calibration_ZDCCalib" or "physics_" in flags.Input.TriggerStream or flags.Input.TriggerStream == "express_express" and not isComm)
189 
190  if flags.Input.TriggerStream == "calibration_DcmDummyProcessor": # standalone data: do we want to run calibration or LED?
191  runInjForStandaloneDataArgValid = False
192 
193  if flags.hasFlag("runInjForStandaloneData"): # if passed as an argument, runInjForStandaloneData should have been dynamically loaded as a flag in fillFromArgs
194  if flags.runInjForStandaloneData.lower() == "inj":
195  isInj = True
196  runInjForStandaloneDataArgValid = True
197  elif flags.runInjForStandaloneData.lower() == "led":
198  isLED = True
199  runInjForStandaloneDataArgValid = True
200 
201  if not runInjForStandaloneDataArgValid: # runInjForStandaloneData is not a defined flag
202  log.warning("runInjForStandaloneData is either not a defined flag or has invalid value (value must be Inj / LED, case insensitive).")
203  log.warning("Running nominal reconstruction (injector-pulse) by default for standalone data")
204  log.warning("Could lead to undesired behavior if pulsing LED in standalone mode")
205  isInj = True
206 
207  if isLED:
208  log.info('ZdcRecConfig: Running LED data!')
209  if isInj:
210  log.info('ZdcRecConfig: Running Injected pulse data!')
211  if isCalib:
212  log.info('ZdcRecConfig: Running ZDC calibration data!')
213  if flags.Input.isMC:
214  log.info('ZdcRecConfig: Running over MC Samples')
215  flags.Input.ProjectName = "data23_hi"
216  flags.Reco.EnableTrigger = False
217 
218  # supply missing metadata based on project name
219  pn = flags.Input.ProjectName
220  if not pn:
221  raise ValueError('Unknown project name')
222 
223  if isLED or isInj or pn == 'data_test':
224  flags.Trigger.EDMVersion=3
225  flags.GeoModel.Run = LHCPeriod.Run3
226  flags.IOVDb.GlobalTag=defaultConditionsTags.RUN3_DATA
227  else:
228  year = int(pn.split('_')[0].split('data')[1])
229  if year < 20:
230  flags.Trigger.EDMVersion=2
231  flags.GeoModel.Run = LHCPeriod.Run2
232  flags.IOVDb.GlobalTag=defaultConditionsTags.RUN2_DATA
233  elif year > 20:
234  flags.Trigger.EDMVersion=3
235  flags.GeoModel.Run = LHCPeriod.Run3
236  flags.IOVDb.GlobalTag=defaultConditionsTags.RUN3_DATA
237 
238  if flags.Input.isMC:
239  log.info('ZdcRecConfig: Overriding MC run to be Run 3!')
240  flags.GeoModel.Run = LHCPeriod.Run3
241 
242  if (isInj
243  or flags.Input.TriggerStream == "calibration_DcmDummyProcessor"
244  or pn == "data22_13p6TeV"):
245  flags.Detector.EnableZDC_RPD = False # disable RPD for injector, LHCf
246 
247  if flags.Input.TriggerStream == "calibration_DcmDummyProcessor": # standalone data: no trigger info available
248  flags.DQ.useTrigger = False
249  flags.DQ.triggerDataAvailable = False
250 
251  flags.GeoModel.AtlasVersion=zdcGeometry(flags)
252 
253  return isLED, isInj, isCalib, pn # return a ntuple of stream and project-name info for further use
254 
255 
256 def ZdcRecOutputCfg(flags):
257 
258  acc = ComponentAccumulator()
259 
260  ZDC_ItemList=[]
261  if flags.Input.Format is Format.BS:
262  ZDC_ItemList.append("xAOD::ZdcModuleContainer#ZdcModules")
263  ZDC_ItemList.append("xAOD::ZdcModuleAuxContainer#ZdcModulesAux.")
264  ZDC_ItemList.append("xAOD::ZdcModuleContainer#ZdcSums")
265  ZDC_ItemList.append("xAOD::ZdcModuleAuxContainer#ZdcSumsAux.")
266 
267  acc.merge(addToESD(flags,ZDC_ItemList))
268  acc.merge(addToAOD(flags,ZDC_ItemList))
269 
270  if flags.Output.doWriteAOD:
271  from xAODMetaDataCnv.InfileMetaDataConfig import SetupMetaDataForStreamCfg
272  acc.merge(SetupMetaDataForStreamCfg(flags,streamName="AOD"))
273 
274  return acc
275 
276 
277 def ZdcAnalysisToolCfg(flags, run, config="PbPb2023", DoCalib=False, DoFADCCorr=False, DoNonLinCorr=False, DoTimeCalib=False, DoTrigEff=False, ForceCalibRun=-1, ForceCalibLB=814, AuxSuffix=""):
278  acc = ComponentAccumulator()
279 
280  log.info('ZdcAnalysisToolCfg: setting up ZdcAnalysisTool with config='+config)
281 
282  acc.setPrivateTools(CompFactory.ZDC.ZdcAnalysisTool(
283  name = 'ZdcAnalysisTool'+config,
284  Configuration = config,
285  DoCalib = DoCalib,
286  DoFADCCorr = DoFADCCorr,
287  DoNonLinCorr = DoNonLinCorr,
288  DoTimeCalib = DoTimeCalib,
289  DoTrigEff = DoTrigEff,
290  ForceCalibRun = ForceCalibRun,
291  ForceCalibLB = ForceCalibLB,
292  AuxSuffix = AuxSuffix,
293  LHCRun = run ))
294  return acc
295 
296 def ZdcLEDAnalysisToolCfg(flags, config = 'ppPbPb2023', DoFADCCorr = True):
297  acc = ComponentAccumulator()
298 
299  log.info('ZdcAnalysisToolCfg: setting up ZdcAnalysisTool with config='+config)
300  acc.setPrivateTools(CompFactory.ZDC.ZdcLEDAnalysisTool(name = 'ZdcLEDAnalysisTool'+config,
301  Configuration = config,
302  DoFADCCorr = DoFADCCorr))
303  return acc
304 
305 
306 def ZdcTrigValToolCfg(flags, config = 'PbPb2023'):
307  acc = ComponentAccumulator()
308 
309  acc.merge(TrigDecisionToolCfg(flags))
310 
311  trigValTool = CompFactory.ZDC.ZdcTrigValidTool(
312  name = 'ZdcTrigValTool',
313  WriteAux = True,
314  AuxSuffix = '',
315  filepath_LUT = 'TrigT1ZDC/zdc_json_PbPb5.36TeV_2023.json') # changed on Oct 13 to accomodate Zdc 1n peak shift
316 
317  trigValTool.TrigDecisionTool = acc.getPublicTool('TrigDecisionTool')
318 
319  trigValTool.triggerList = [c for c in getL1MenuAccess(flags) if 'L1_ZDC_BIT' in c]
320 
321  acc.setPrivateTools(trigValTool)
322 
323  return acc
324 
325 def RPDAnalysisToolCfg(flags, config: str, AuxSuffix=""):
326  acc = ComponentAccumulator()
327  acc.setPrivateTools(
328  CompFactory.ZDC.RPDAnalysisTool(
329  name="RPDAnalysisTool",
330  Configuration=config,
331  AuxSuffix = AuxSuffix
332  )
333  )
334  return acc
335 
336 def RpdSubtractCentroidToolCfg(flags, config: str, AuxSuffix=""):
337  acc = ComponentAccumulator()
338  acc.setPrivateTools(
339  CompFactory.ZDC.RpdSubtractCentroidTool(
340  name="RpdSubtractCentroidTool",
341  Configuration=config,
342  AuxSuffix = AuxSuffix
343  )
344  )
345  return acc
346 
347 def ZdcRecRun2Cfg(flags):
348  acc = ComponentAccumulator()
349  config = SetConfigTag(flags)
350  log.info ('ZdcRecConfig.py: Running with config tag%s', config)
351 
352  doCalib = False
353  doTimeCalib = False
354  doTrigEff = False
355  doNonLinCorr = False
356  doFADCCorr = False
357 
358  if flags.Input.ProjectName == "data15_hi":
359  doCalib = True
360  doTimeCalib = True
361  doTrigEff = True
362  elif flags.Input.ProjectName == "data17_13TeV":
363  doCalib = False
364  doTimeCalib = False
365  doTrigEff = False
366  elif flags.Input.ProjectName == "data16_hip":
367  doCalib = True
368  doTimeCalib = False
369  doTrigEff = False
370  elif flags.Input.ProjectName == "data18_hi":
371  doCalib = True
372  doTimeCalib = False
373  doTrigEff = False
374 
375  acc.merge(ByteStreamReadCfg(flags, type_names=['xAOD::TriggerTowerContainer/ZdcTriggerTowers',
376  'xAOD::TriggerTowerAuxContainer/ZdcTriggerTowersAux.']))
377 
378  acc.addEventAlgo(CompFactory.ZdcByteStreamRawDataV2())
379  acc.addEventAlgo(CompFactory.ZdcRecV3Decode())
380 
381  anaTool = acc.popToolsAndMerge(ZdcAnalysisToolCfg(flags,2,config,doCalib,doFADCCorr,doNonLinCorr,doTimeCalib,doTrigEff))
382 
383  acc.addEventAlgo(CompFactory.ZdcRecV3("ZdcRecV3",ZdcAnalysisTool=anaTool))
384 
385  return acc
386 
387 def ZdcRecRun3Cfg(flags):
388 
389  acc = ComponentAccumulator()
390  config = SetConfigTag(flags)
391  log.info ('ZdcRecConfig.py: Running with config tag %s', config)
392 
393  doCalib = False
394  doTimeCalib = False
395  doTrigEff = False
396  doFADCCorr = False
397  doNonLinCorr = True #default for 2023
398  ForceCalibRun = -1
399  ForceCalibLB = 814
400  AuxSuffix = ""
401 
402  if flags.Input.TriggerStream != "calibration_ZDCInjCalib" and flags.Input.TriggerStream != "calibration_DcmDummyProcessor":
403  if flags.Common.isOnline: # calibration file for ongoing run not available - copy calib file from eos & hard code the run + lb
404  doCalib = True
405  doTimeCalib = True
406  if flags.Input.ProjectName == "data24_5p36TeV" or flags.Input.ProjectName == "data24_refcomm":
407  ForceCalibRun = 488239
408  ForceCalibLB = 1
409  elif flags.Input.ProjectName == "data24_hi" or flags.Input.ProjectName == "data24_hicomm":
410  ForceCalibRun = 488980 # place holder available at point1 - replace with a 2024 run during data taking
411  ForceCalibLB = 80
412  else:
413  doCalib = False
414  doTimeCalib = False
415  elif flags.Input.ProjectName == "data23_comm":
416  doCalib = True
417  elif flags.Input.ProjectName == "data23_hi": # for "data24_hi" or "data24_5p36TeV," need to also check flags.Input.TriggerStream != "calibration_ZDCInjCalib"
418  doCalib = True
419  doTimeCalib = True
420  elif flags.Input.ProjectName == "data24_hi": # for "data24_hi" or "data24_5p36TeV," need to also check flags.Input.TriggerStream != "calibration_ZDCInjCalib"
421  doCalib = True
422  doTimeCalib = True
423  doFADCCorr = False
424  doNonLinCorr = False
425  elif flags.Input.ProjectName in ["data25_hip","data25_hipcomm"]: # for "data24_hi" or "data24_5p36TeV," need to also check flags.Input.TriggerStream != "calibration_ZDCInjCalib"
426  doCalib = True
427  doTimeCalib = False
428  doFADCCorr = False
429  doNonLinCorr = False
430  elif flags.Input.ProjectName in ["data25_hi","data25_hicomm"]: # for "data24_hi" or "data24_5p36TeV," need to also check flags.Input.TriggerStream != "calibration_ZDCInjCalib"
431  doCalib = True
432  doTimeCalib = False
433  doFADCCorr = False
434  doNonLinCorr = False
435 
436  # No calibration required (or exists) for MC
437  if flags.Input.isMC:
438  doCalib = False
439 
440  doRPD = flags.Detector.EnableZDC_RPD
441 
442  log.info('ZdcRecRun3Cfg: doCalib = '+str(doCalib)+' for project '+flags.Input.ProjectName)
443  log.info('RPD enable flag is '+str(doRPD))
444 
445  zdcReproc = False
446  if "ZdcModules" in flags.Input.Collections:
447  log.info('ZdcRecConfig.py: found ZdcModules in input, reprocessing mode set')
448  AuxSuffix="RP"
449  zdcReproc = True
450 
451  anaTool = acc.popToolsAndMerge(ZdcAnalysisToolCfg(flags,3,config,doCalib,doFADCCorr,doNonLinCorr,doTimeCalib,doTrigEff,ForceCalibRun,ForceCalibLB, AuxSuffix))
452 
453 
454  if (doRPD):
455  rpdAnaTool = acc.popToolsAndMerge(RPDAnalysisToolCfg(flags, config, AuxSuffix))
456  centroidTool = acc.popToolsAndMerge(RpdSubtractCentroidToolCfg(flags, config, AuxSuffix))
457 
458  if flags.Input.isMC :
459  zdcTools = [anaTool] # expand list as needed
460  if doRPD:
461  zdcTools += [rpdAnaTool,centroidTool]
462  elif flags.Trigger.doZDC : # if doZDC flag is true we are in a trigger reprocessing -> no TrigValidTool
463  zdcTools = [anaTool] # expand list as needed
464  elif flags.Input.TriggerStream == "calibration_ZDCInjCalib" or flags.Input.TriggerStream == "calibration_DcmDummyProcessor":
465  zdcTools = [anaTool] # no trigger / RPD / centroid - either online or offline
466  elif flags.Common.isOnline: # running online + NOT injector pulse: with RPD + centroid but no trigger validation for now; may add later
467  zdcTools = [anaTool] # expand list as needed
468  if doRPD:
469  zdcTools += [rpdAnaTool,centroidTool]
470  elif (zdcReproc): # ZDC reprocessing (will take work to make it work for RPD)
471  zdcTools = [anaTool]
472  if doRPD:
473  zdcTools += [rpdAnaTool,centroidTool]
474  else: # default (not MC, not trigger repoc, not injector pulse, not online)
475  trigTool = acc.popToolsAndMerge(ZdcTrigValToolCfg(flags,config))
476  zdcTools = [anaTool,trigTool] # expand list as needed
477  if doRPD:
478  zdcTools += [rpdAnaTool,centroidTool]
479 
480  if flags.Input.Format is Format.BS:
481  acc.addEventAlgo(CompFactory.ZdcByteStreamLucrodData())
482  acc.addEventAlgo(CompFactory.ZdcRecRun3Decode())
483  if flags.Input.isMC:
484  from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
485  acc.merge(PoolReadCfg(flags))
486  acc.addEventAlgo(CompFactory.ZdcMCTruthAlg())
487 
488  zdcAlg = CompFactory.ZdcRecRun3("ZdcRecRun3",ZdcAnalysisTools=zdcTools)
489  acc.addEventAlgo(zdcAlg, primary=True)
490 
491  return acc
492 
493 def ZdcNtupleLocalCfg(flags):
494 
495  acc = ComponentAccumulator()
496  run = flags.GeoModel.Run
497 
498  if run == LHCPeriod.Run2:
499  log.info ('ZdcRecConfig.py: setting up Run 2 ntuple!')
500  acc.merge(ZdcNtupleRun2Cfg(flags))
501  elif run == LHCPeriod.Run3:
502  log.info ('ZdcRecConfig.py: setting up Run 3 ntuples!')
503  acc.merge(ZdcNtupleRun3Cfg(flags))
504  else:
505  log.info ('ZdcRecConfig.py: setting up no ntuple!')
506 
507  return acc
508 
509 def ZdcNtupleRun2Cfg(flags,**kwargs):
510 
511  acc = ComponentAccumulator()
512  acc.merge(ZdcNtupleCfg(flags,
513  useGRL = False,
514  zdcOnly = True,
515  enableTrigger = False,
516  enableOutputSamples = True,
517  enableOutputTree = True,
518  writeOnlyTriggers = False,
519  nsamplesZdc = 7,
520  **kwargs))
521 
522  acc.addService(CompFactory.THistSvc(Output = ["ANALYSIS DATAFILE='zdctree.root' OPT='RECREATE'"]))
523  return acc
524 
525 def ZdcNtupleRun3Cfg(flags,**kwargs):
526 
527  acc = ComponentAccumulator()
528  acc.merge(ZdcNtupleCfg(flags,
529  useGRL = False,
530  zdcOnly = True,
531  lhcf2022 = False,
532  lhcf2022zdc = False,
533  lhcf2022afp = False,
534  isMC = flags.Input.isMC,
535  enableTrigger = not flags.Input.isMC,
536  enableOutputSamples = True,
537  enableOutputTree = True,
538  writeOnlyTriggers = False,
539  enableRPD = flags.Detector.EnableZDC_RPD,
540  enableCentroid = flags.Detector.EnableZDC_RPD,
541  reprocZdc = False,
542  **kwargs))
543 
544  acc.addService(CompFactory.THistSvc(Output = ["ANALYSIS DATAFILE='NTUP.root' OPT='RECREATE'"]))
545  #acc.setAppProperty("HistogramPersistency","ROOT")
546  return acc
547 
548 def ZdcInjNtupleCfg(flags,**kwargs):
549 
550  acc = ComponentAccumulator()
551  acc.merge(ZdcNtupleCfg(flags,
552  useGRL = False,
553  zdcOnly = True,
554  zdcInj = True,
555  lhcf2022 = False,
556  lhcf2022zdc = False,
557  lhcf2022afp = False,
558  enableTrigger = False,
559  enableOutputSamples = True,
560  enableOutputTree = True,
561  writeOnlyTriggers = False,
562  enableRPD = False,
563  enableCentroid = False,
564  reprocZdc = False,
565  **kwargs))
566 
567  acc.addService(CompFactory.THistSvc(Output = ["ANALYSIS DATAFILE='NTUP.root' OPT='RECREATE'"]))
568  #acc.setAppProperty("HistogramPersistency","ROOT")
569  return acc
570 
571 def ZdcLEDNtupleCfg(flags):
572  acc = ComponentAccumulator()
573  zdcLEDNtuple = CompFactory.ZdcLEDNtuple("ZdcLEDNtuple")
574  zdcLEDNtuple.enableOutputTree = True
575  acc.addEventAlgo(zdcLEDNtuple)
576  acc.addService(CompFactory.THistSvc(Output = ["ANALYSIS DATAFILE='NTUP.root' OPT='RECREATE'"]))
577  return acc
578 
579 def ZdcLEDRecCfg(flags):
580 
581  acc = ComponentAccumulator()
582 
583  if flags.Input.Format is Format.BS:
584  run = flags.GeoModel.Run
585 
586  # debugging message since the metadata isn't working for calibration files yet
587  log.info ("ZdcRecConfig.py: run = "+run.name)
588 
589  config = 'ppPbPb2023'
590  #config = 'ppALFA2023'
591  doFADCCorr = False
592 
593  if (flags.GeoModel.Run == LHCPeriod.Run3):
594  doFADCCorr = False
595 
596  acc.addEventAlgo(CompFactory.ZdcByteStreamLucrodData())
597  acc.addEventAlgo(CompFactory.ZdcRecRun3Decode())
598 
599  anaTool = acc.popToolsAndMerge(ZdcLEDAnalysisToolCfg(flags, config, DoFADCCorr = doFADCCorr)) #anatool for zdcLED calibration
600 
601  zdcTools = []
602  zdcTools += [anaTool] # add trigTool after deocration migration
603 
604  # FIXME these are dependent on !65768
605  zdcAlg = CompFactory.ZdcRecRun3("ZdcRecRun3",DAQMode=2, ForcedEventType=2, ZdcAnalysisTools=zdcTools) # DAQMode set to PhysicsPEB, event type set to ZdcEventLED
606  acc.addEventAlgo(zdcAlg, primary=True)
607 
608  if flags.Output.doWriteESD or flags.Output.doWriteAOD:
609  acc.merge(ZdcRecOutputCfg(flags))
610 
611  return acc
612 
613 def ZdcLEDTrigCfg(flags):
614 
615  acc = ComponentAccumulator()
616 
617  # suggested by Tim Martin
618  tdmv = CompFactory.TrigDec.TrigDecisionMakerValidator()
619  tdmv.errorOnFailure = True
620  tdmv.TrigDecisionTool = acc.getPrimaryAndMerge(TrigDecisionToolCfg(flags))
621  tdmv.NavigationKey = getRun3NavigationContainerFromInput(flags)
622  acc.addEventAlgo( tdmv )
623  # end of Tim's suggestions
624  return acc
625 
626 def ZdcRecCfg(flags):
627  """Configure Zdc analysis alg
628  Additional arguments are useful in calibration runs
629  """
630 
631  acc = ComponentAccumulator()
632 
633  run = flags.GeoModel.Run
634 
635  # debugging message since the metadata isn't working for calibration files yet
636  log.info ("ZdcRecConfig.py: run = "+run.name)
637 
638  if run == LHCPeriod.Run2:
639  log.info ('ZdcRecConfig.py: setting up Run 2!')
640  acc.merge(ZdcRecRun2Cfg(flags))
641  elif run == LHCPeriod.Run3:
642  log.info ('ZdcRecConfig.py: setting up Run 3!')
643  acc.merge(ZdcRecRun3Cfg(flags))
644  else:
645  log.warning ('ZdcRecConfig.py: setting up nothing (problem)!')
646 
647  if flags.Output.doWriteESD or flags.Output.doWriteAOD:
648  acc.merge(ZdcRecOutputCfg(flags))
649 
650  return acc
651 
652 
653 if __name__ == '__main__':
654 
655  """ This is selftest & ZDC calibration transform at the same time"""
656 
657  # Configure log level in main entry point
658  from AthenaCommon.Constants import INFO
659  log.setLevel(INFO)
660 
661  from AthenaConfiguration.AllConfigFlags import initConfigFlags
662  from AthenaConfiguration.MainServicesConfig import MainServicesCfg
663 
664  flags = initConfigFlags()
665 
666  ZdcGenericFlagSetting(flags) # set generic (stream-independent) ZDC flags
667 
668  flags.Output.AODFileName="AOD.pool.root"
669  flags.Output.HISTFileName="HIST.root"
670  flags.Output.doWriteAOD=True
671 
672  isLED, isInj, isCalib, pn = ZdcStreamDependentFlagSetting(flags) # set stream-dependent ZDC flags & get return values
673 
674  flags.lock()
675  # flags.dump(evaluate=True) # uncomment this line if needed for testing
676 
677  acc=MainServicesCfg(flags)
678 
679  from AtlasGeoModel.ForDetGeoModelConfig import ForDetGeometryCfg
680  acc.merge(ForDetGeometryCfg(flags))
681 
682  if not flags.Input.isMC and pn != 'data_test': # trigger reco config not existing for MC or standalone
683  from TriggerJobOpts.TriggerRecoConfig import TriggerRecoCfgData
684  acc.merge(TriggerRecoCfgData(flags))
685 
686  if isLED:
687  acc.merge(ZdcLEDRecCfg(flags))
688  if isCalib: # should be able to run both if in standalone data
689  acc.merge(ZdcRecCfg(flags))
690  if isInj: # should be able to run both if in standalone data
691  acc.merge(ZdcRecCfg(flags))
692 
693  if not flags.Input.isMC:
694  if isLED:
695  from ZdcMonitoring.ZdcLEDMonitorAlgorithm import ZdcLEDMonitoringConfig
696  acc.merge(ZdcLEDMonitoringConfig(flags,'ppPbPb2023'))
697  acc.merge(ZdcLEDNtupleCfg(flags))
698 
699  if isCalib:
700  from ZdcMonitoring.ZdcMonitorAlgorithm import ZdcMonitoringConfig
701  zdcMonitorAcc = ZdcMonitoringConfig(flags)
702  acc.merge(zdcMonitorAcc)
703  if flags.Input.TriggerStream != "calibration_DcmDummyProcessor": #after ntuple works for standalone data, take this line out
704  acc.merge(ZdcNtupleLocalCfg(flags))
705  if isInj:
706  from ZdcMonitoring.ZdcMonitorAlgorithm import ZdcMonitoringConfig
707  zdcMonitorAcc = ZdcMonitoringConfig(flags)
708  acc.merge(zdcMonitorAcc)
709  acc.merge(ZdcInjNtupleCfg(flags))
710  else:
711  acc.merge(ZdcRecCfg(flags))
712  acc.merge(ZdcNtupleLocalCfg(flags))
713 
714  acc.printConfig(withDetails=True)
715  # acc.foreach_component("*Zdc*").OutputLevel=DEBUG #uncomment to turn on DEBUG messages for ZDC applications
716 
717  with open("config.pkl", "wb") as f:
718  acc.store(f)
719  status = acc.run()
720  import sys
721  sys.exit(status.isFailure())
python.JetAnalysisCommon.ComponentAccumulator
ComponentAccumulator
Definition: JetAnalysisCommon.py:302
python.ZdcRecConfig.ZdcRecRun2Cfg
def ZdcRecRun2Cfg(flags)
Definition: ZdcRecConfig.py:347
ZdcLEDMonitorAlgorithm.ZdcLEDMonitoringConfig
def ZdcLEDMonitoringConfig(inputFlags, run_type)
Definition: ZdcLEDMonitorAlgorithm.py:14
python.ZdcRecConfig.ZdcGenericFlagSetting
def ZdcGenericFlagSetting(flags)
Definition: ZdcRecConfig.py:142
python.ZdcRecConfig.ZdcNtupleRun2Cfg
def ZdcNtupleRun2Cfg(flags, **kwargs)
Definition: ZdcRecConfig.py:509
python.ForDetGeoModelConfig.ForDetGeometryCfg
def ForDetGeometryCfg(flags)
Definition: ForDetGeoModelConfig.py:33
python.ZdcRecConfig.ZdcNtupleRun3Cfg
def ZdcNtupleRun3Cfg(flags, **kwargs)
Definition: ZdcRecConfig.py:525
python.ZdcRecConfig.ZdcTrigValToolCfg
def ZdcTrigValToolCfg(flags, config='PbPb2023')
Definition: ZdcRecConfig.py:306
python.TriggerRecoConfig.TriggerRecoCfgData
def TriggerRecoCfgData(flags)
Definition: TriggerRecoConfig.py:23
python.ByteStreamConfig.ByteStreamReadCfg
def ByteStreamReadCfg(flags, type_names=None)
Definition: Event/ByteStreamCnvSvc/python/ByteStreamConfig.py:25
python.ZdcRecConfig.ZdcInjNtupleCfg
def ZdcInjNtupleCfg(flags, **kwargs)
Definition: ZdcRecConfig.py:548
python.ZdcRecConfig.ZdcRecCfg
def ZdcRecCfg(flags)
Definition: ZdcRecConfig.py:626
python.ZdcRecConfig.zdcGeometry
def zdcGeometry(flags)
Definition: ZdcRecConfig.py:29
ZdcNtupleConfig.ZdcNtupleCfg
def ZdcNtupleCfg(flags, name="ZdcNtuple", **kwargs)
Definition: ZdcNtupleConfig.py:7
python.ZdcRecConfig.ZdcAnalysisToolCfg
def ZdcAnalysisToolCfg(flags, run, config="PbPb2023", DoCalib=False, DoFADCCorr=False, DoNonLinCorr=False, DoTimeCalib=False, DoTrigEff=False, ForceCalibRun=-1, ForceCalibLB=814, AuxSuffix="")
Definition: ZdcRecConfig.py:277
python.ZdcRecConfig.ZdcRecRun3Cfg
def ZdcRecRun3Cfg(flags)
Definition: ZdcRecConfig.py:387
python.TriggerConfigAccess.getL1MenuAccess
L1MenuAccess getL1MenuAccess(flags=None)
Definition: TriggerConfigAccess.py:129
python.ZdcRecConfig.GenerateConfigTagDict
def GenerateConfigTagDict()
Definition: ZdcRecConfig.py:62
python.TrigDecisionToolConfig.getRun3NavigationContainerFromInput
def getRun3NavigationContainerFromInput(flags)
Definition: TrigDecisionToolConfig.py:63
python.ZdcRecConfig.RPDAnalysisToolCfg
def RPDAnalysisToolCfg(flags, str config, AuxSuffix="")
Definition: ZdcRecConfig.py:325
python.ZdcRecConfig.ZdcLEDRecCfg
def ZdcLEDRecCfg(flags)
Definition: ZdcRecConfig.py:579
python.MainServicesConfig.MainServicesCfg
def MainServicesCfg(flags, LoopMgr='AthenaEventLoopMgr')
Definition: MainServicesConfig.py:310
Constants
some useful constants -------------------------------------------------—
python.ZdcRecConfig.RpdSubtractCentroidToolCfg
def RpdSubtractCentroidToolCfg(flags, str config, AuxSuffix="")
Definition: ZdcRecConfig.py:336
python.OutputStreamConfig.addToESD
def addToESD(flags, itemOrList, **kwargs)
Definition: OutputStreamConfig.py:187
python.TriggerInterface.TrigDecisionToolCfg
def TrigDecisionToolCfg(flags)
Definition: TriggerInterface.py:14
Trk::open
@ open
Definition: BinningType.h:40
python.ZdcRecConfig.ZdcLEDAnalysisToolCfg
def ZdcLEDAnalysisToolCfg(flags, config='ppPbPb2023', DoFADCCorr=True)
Definition: ZdcRecConfig.py:296
python.ZdcRecConfig.ZdcStreamDependentFlagSetting
def ZdcStreamDependentFlagSetting(flags)
Definition: ZdcRecConfig.py:175
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
python.AllConfigFlags.initConfigFlags
def initConfigFlags()
Definition: AllConfigFlags.py:19
python.OutputStreamConfig.addToAOD
def addToAOD(flags, itemOrList, **kwargs)
Definition: OutputStreamConfig.py:202
python.ZdcRecConfig.ZdcRecOutputCfg
def ZdcRecOutputCfg(flags)
Definition: ZdcRecConfig.py:256
ZdcMonitorAlgorithm.ZdcMonitoringConfig
def ZdcMonitoringConfig(inputFlags)
Definition: ZdcMonitorAlgorithm.py:83
python.ZdcRecConfig.ZdcLEDNtupleCfg
def ZdcLEDNtupleCfg(flags)
Definition: ZdcRecConfig.py:571
str
Definition: BTagTrackIpAccessor.cxx:11
python.ZdcRecConfig.ZdcLEDTrigCfg
def ZdcLEDTrigCfg(flags)
Definition: ZdcRecConfig.py:613
python.ZdcRecConfig.ZdcNtupleLocalCfg
def ZdcNtupleLocalCfg(flags)
Definition: ZdcRecConfig.py:493
python.ZdcRecConfig.SetConfigTag
def SetConfigTag(flags)
Definition: ZdcRecConfig.py:91
InfileMetaDataConfig.SetupMetaDataForStreamCfg
def SetupMetaDataForStreamCfg(flags, streamName="", AcceptAlgs=None, createMetadata=None, propagateMetadataFromInput=True, *args, **kwargs)
Definition: InfileMetaDataConfig.py:222
python.PoolReadConfig.PoolReadCfg
def PoolReadCfg(flags)
Definition: PoolReadConfig.py:71
Trk::split
@ split
Definition: LayerMaterialProperties.h:38
Generated on Thu Oct 30 2025 21:22:42 for ATLAS Offline Software by   doxygen 1.8.18