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