Functions
def	zdcGeometry (flags)

def	GenerateConfigTagDict ()

def	SetConfigTag (flags)

def	ZdcGenericFlagSetting (flags)

def	ZdcStreamDependentFlagSetting (flags)

def	ZdcRecOutputCfg (flags)

def	ZdcAnalysisToolCfg (flags, run, config="PbPb2023", DoCalib=False, DoFADCCorr=False, DoNonLinCorr=False, DoTimeCalib=False, DoTrigEff=False, ForceCalibRun=-1, ForceCalibLB=814, AuxSuffix="")

def	ZdcLEDAnalysisToolCfg (flags, config='ppPbPb2023', DoFADCCorr=True)

def	ZdcTrigValToolCfg (flags, config='PbPb2023')

def	RPDAnalysisToolCfg (flags, str config, AuxSuffix="")

def	RpdSubtractCentroidToolCfg (flags, str config, AuxSuffix="")

def	ZdcRecRun2Cfg (flags)

def	ZdcRecRun3Cfg (flags)

def	ZdcNtupleLocalCfg (flags)

def	ZdcNtupleRun2Cfg (flags, **kwargs)

def	ZdcNtupleRun3Cfg (flags, **kwargs)

def	ZdcInjNtupleCfg (flags, **kwargs)

def	ZdcLEDNtupleCfg (flags)

def	ZdcLEDRecCfg (flags)

def	ZdcLEDTrigCfg (flags)

def	ZdcRecCfg (flags)

Variables
	log = logging.getLogger("ZdcRecConfig")

dictionary	zdcConfigMap = {}

	flags = initConfigFlags()

	AODFileName

	HISTFileName

	doWriteAOD

	isLED

	isInj

	isCalib

	pn

	acc = MainServicesCfg(flags)

	zdcMonitorAcc = ZdcMonitoringConfig(flags)

	withDetails

	status = acc.run()

Function Documentation

◆ GenerateConfigTagDict()

def python.ZdcRecConfig.GenerateConfigTagDict ( )

Definition at line 62 of file ZdcRecConfig.py.

 def GenerateConfigTagDict():
  
     zdcConfigMap['data15_hi'] = {}
     zdcConfigMap['data16_hip'] = {}
     zdcConfigMap['data17_13TeV'] = {}
     zdcConfigMap['data18_hi'] = {}
     zdcConfigMap['data22_13p6TeV'] = {}
     zdcConfigMap['data23_5p36TeV'] = {}
     zdcConfigMap['data23_13p6TeV'] = {}
     zdcConfigMap['data23_hi'] = {}
     zdcConfigMap['data23_comm'] = {}
     zdcConfigMap['data23_5p36TeV'] = {}
     zdcConfigMap['data24_900GeV'] = {}
  
     zdcConfigMap['data24_13p6TeV'] = {}
     zdcConfigMap['data24_13p6TeV']['default'] = 'pp2024'
     
     zdcConfigMap['data24_refcomm'] = {}
     zdcConfigMap['data24_refcomm']['default'] = 'pp2024'
     zdcConfigMap['data24_refcomm']['calibration_ZdcInjCalib'] = 'Injectorpp2024'
  
     zdcConfigMap['data24_hicomm'] = {}
     zdcConfigMap['data24_hicomm']['default'] = 'PbPb2024'
     zdcConfigMap['data24_hicomm']['calibration_ZdcInjCalib'] = 'InjectorPbPb2024'
  
     zdcConfigMap['data24_hi'] = {}
     zdcConfigMap['data24_hi']['default']="PbPb2024"
     zdcConfigMap['data24_hi']['calibration_ZdcInjCalib']="InjectorPbPb2024"
     

◆ RPDAnalysisToolCfg()

def python.ZdcRecConfig.RPDAnalysisToolCfg	(		flags,
		str	config,
			AuxSuffix = `""`
	)

Definition at line 325 of file ZdcRecConfig.py.

 def RPDAnalysisToolCfg(flags, config: str, AuxSuffix=""):
     acc = ComponentAccumulator()
     acc.setPrivateTools(
         CompFactory.ZDC.RPDAnalysisTool(
             name="RPDAnalysisTool",
             Configuration=config,
             AuxSuffix = AuxSuffix
         )
     )
     return acc
  

◆ RpdSubtractCentroidToolCfg()

def python.ZdcRecConfig.RpdSubtractCentroidToolCfg	(		flags,
		str	config,
			AuxSuffix = `""`
	)

Definition at line 336 of file ZdcRecConfig.py.

 def RpdSubtractCentroidToolCfg(flags, config: str, AuxSuffix=""):
     acc = ComponentAccumulator()
     acc.setPrivateTools(
         CompFactory.ZDC.RpdSubtractCentroidTool(
             name="RpdSubtractCentroidTool",
             Configuration=config,
             AuxSuffix = AuxSuffix
         )
     )
     return acc
  

◆ SetConfigTag()

def python.ZdcRecConfig.SetConfigTag ( flags )

Definition at line 91 of file ZdcRecConfig.py.

 def SetConfigTag(flags):
  
     # terrible kludge for early 2025
     if flags.Input.ProjectName == "data25_comm" and flags.Input.TriggerStream == "calibration_ZDCCalib":
         config = "InjectorpOOONeNe2025"
     
     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                
         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)
         if flags.Input.ProjectName == "data24_5p36TeV" or flags.Input.ProjectName == "data24_900GeV" or flags.Input.ProjectName == "data24_13p6TeV" or flags.Input.ProjectName == "data24_refcomm":
             config = "Injectorpp2024"
         if flags.Input.ProjectName in ["data24_hi","data24_hicomm"]:
             config = "InjectorPbPb2024"
         if flags.Input.ProjectName in ["data25_hi","data25_hicomm","data25_hip"] :
             config = "InjectorpOOONeNe2025"
  
     else:
         config = "PbPb2023" # default config tag
         
         run = flags.GeoModel.Run
         if run == LHCPeriod.Run3:
             if flags.Input.isMC:
                 config = "MonteCarloPbPb2023"
             elif flags.Input.ProjectName == "data22_13p6TeV":
                 config = "LHCf2022"
             elif flags.Input.ProjectName in ["data23_5p36TeV", "data23_900GeV", "data23_13p6TeV"]:
                 config = "pp2023"
             elif flags.Input.ProjectName in ["data23_hi", "data23_comm"]:
                 config = "PbPb2023"
             elif flags.Input.ProjectName in ["data24_5p36TeV", "data24_900GeV", "data24_13p6TeV", "data24_refcomm"]:
                 config = "pp2024"
             elif flags.Input.ProjectName in ["data24_hi", "data24_hicomm"]:
                 config = "PbPb2024" 
             elif flags.Input.ProjectName in ["data25_hipcomm"]:
                 config = "pO2025"
             elif flags.Input.ProjectName in ["data25_hip"]:
                 config = "pO2025B"
             elif flags.Input.ProjectName in ["data25_hi","data25_hicomm"]:
                 config = "OONeNe2025"
         elif run == LHCPeriod.Run2:
             if flags.Input.ProjectName == "data15_hi":
                 config = "PbPb2015"
             elif flags.Input.ProjectName == "data17_13TeV":
                 config = "PbPb2015"
             elif flags.Input.ProjectName == "data16_hip":
                 config = "pPb2016"
             elif flags.Input.ProjectName == "data18_hi":
                 config = "PbPb2018"
  
     return config
  
  

◆ ZdcAnalysisToolCfg()

def python.ZdcRecConfig.ZdcAnalysisToolCfg	(	flags,
		run,
		config = `"PbPb2023"`,
		DoCalib = `False`,
		DoFADCCorr = `False`,
		DoNonLinCorr = `False`,
		DoTimeCalib = `False`,
		DoTrigEff = `False`,
		ForceCalibRun = `-1`,
		ForceCalibLB = `814`,
		AuxSuffix = `""`
	)

Definition at line 277 of file ZdcRecConfig.py.

 def ZdcAnalysisToolCfg(flags, run, config="PbPb2023", DoCalib=False, DoFADCCorr=False, DoNonLinCorr=False, DoTimeCalib=False, DoTrigEff=False, ForceCalibRun=-1, ForceCalibLB=814, AuxSuffix=""):
     acc = ComponentAccumulator()
  
     log.info('ZdcAnalysisToolCfg: setting up ZdcAnalysisTool with config='+config)
  
     acc.setPrivateTools(CompFactory.ZDC.ZdcAnalysisTool(
         name = 'ZdcAnalysisTool'+config, 
         Configuration = config,
         DoCalib = DoCalib,
         DoFADCCorr = DoFADCCorr,
         DoNonLinCorr = DoNonLinCorr,
         DoTimeCalib = DoTimeCalib,
         DoTrigEff = DoTrigEff,
         ForceCalibRun = ForceCalibRun,
         ForceCalibLB = ForceCalibLB,
         AuxSuffix = AuxSuffix,
         LHCRun = run ))
     return acc
  

◆ ZdcGenericFlagSetting()

def python.ZdcRecConfig.ZdcGenericFlagSetting ( flags )

set generic flags needed for ZDC reconstruction that are independent of stream type
Also fills flags from input arguments

Definition at line 142 of file ZdcRecConfig.py.

 def ZdcGenericFlagSetting(flags): # pass flags object by reference: directly set flags in function
     '''set generic flags needed for ZDC reconstruction that are independent of stream type
     Also fills flags from input arguments'''
  
     flags.Scheduler.CheckDependencies = True
     flags.Scheduler.ShowDataDeps = True
     flags.Scheduler.ShowDataFlow = True
     flags.Scheduler.ShowControlFlow = True
     flags.Scheduler.EnableVerboseViews = True
  
     flags.Detector.GeometryZDC=True
     flags.Detector.GeometryAFP=False
     flags.Detector.GeometryALFA=False
     flags.Detector.GeometryLucid=False
     flags.Detector.GeometryMDT=False
     flags.Detector.GeometryMM=False
     flags.Detector.GeometryMuon=False
  
     flags.Trigger.decodeHLT=False
     flags.Trigger.enableL1MuonPhase1=False
     flags.Trigger.L1.doMuon=False
     flags.Trigger.L1.doCalo=False
     flags.Trigger.L1.doTopo=False
  
     # This does not work in this context
     # run = flags.GeoModel.Run
     # The EDM Version should be auto configured, but is not working at the moment, so is set by hand
  
     parser = flags.getArgumentParser()
     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")
     flags.fillFromArgs(parser=parser)
  
  

◆ zdcGeometry()

def python.ZdcRecConfig.zdcGeometry ( flags )

Definition at line 29 of file ZdcRecConfig.py.

 def zdcGeometry(flags):
     projName = flags.Input.ProjectName
     match projName:
         case "data15_hi":
             return defaultGeometryTags.RUN2_ZDC
         case "data18_hi":
             return defaultGeometryTags.RUN2_ZDC
         case "data16_hi":
             return defaultGeometryTags.RUN2_ZDC
         case "data16_hip":
             return defaultGeometryTags.RUN2_ZDC
         case "data23_hi":
             return defaultGeometryTags.RUN3_ZDC23
         case "data24_hi":
             return defaultGeometryTags.RUN3_ZDC24
         case "data24_hicomm":
             return defaultGeometryTags.RUN3_ZDC24
         case "data25_hip":
             return defaultGeometryTags.RUN3_ZDC24
         case "data25_hi":
             return defaultGeometryTags.RUN3_ZDC24
         case "data25_hipcomm":
             return defaultGeometryTags.RUN3_ZDC24
         case "data25_hicomm":
             return defaultGeometryTags.RUN3_ZDC24
         case _:
             run = flags.GeoModel.Run
             if run == LHCPeriod.Run2:
                 return defaultGeometryTags.RUN2_ZDC
             if run == LHCPeriod.Run3:
                 return defaultGeometryTags.RUN3_ZDC24
             return ""
         

◆ ZdcInjNtupleCfg()

def python.ZdcRecConfig.ZdcInjNtupleCfg	(		flags,
		**	kwargs
	)

Definition at line 548 of file ZdcRecConfig.py.

 def ZdcInjNtupleCfg(flags,**kwargs):
     
     acc = ComponentAccumulator()
     acc.merge(ZdcNtupleCfg(flags,
                            useGRL = False,
                            zdcOnly = True,
                            zdcInj = True,
                            lhcf2022 = False,
                            lhcf2022zdc = False,
                            lhcf2022afp = False,
                            enableTrigger = False,
                            enableOutputSamples = True,
                            enableOutputTree = True,
                            writeOnlyTriggers = False,
                            enableRPD = False,
                            enableCentroid = False,
                            reprocZdc = False,
                            **kwargs))
  
     acc.addService(CompFactory.THistSvc(Output = ["ANALYSIS DATAFILE='NTUP.root' OPT='RECREATE'"]))
     #acc.setAppProperty("HistogramPersistency","ROOT")
     return acc
  

◆ ZdcLEDAnalysisToolCfg()

def python.ZdcRecConfig.ZdcLEDAnalysisToolCfg	(	flags,
		config = `'ppPbPb2023'`,
		DoFADCCorr = `True`
	)

Definition at line 296 of file ZdcRecConfig.py.

 def ZdcLEDAnalysisToolCfg(flags, config = 'ppPbPb2023', DoFADCCorr = True):  
     acc = ComponentAccumulator()
  
     log.info('ZdcAnalysisToolCfg: setting up ZdcAnalysisTool with config='+config)
     acc.setPrivateTools(CompFactory.ZDC.ZdcLEDAnalysisTool(name = 'ZdcLEDAnalysisTool'+config, 
                                                            Configuration = config,
                                                            DoFADCCorr = DoFADCCorr))
     return acc
  
  

◆ ZdcLEDNtupleCfg()

def python.ZdcRecConfig.ZdcLEDNtupleCfg ( flags )

Definition at line 571 of file ZdcRecConfig.py.

 def ZdcLEDNtupleCfg(flags):
     acc = ComponentAccumulator()
     zdcLEDNtuple = CompFactory.ZdcLEDNtuple("ZdcLEDNtuple")
     zdcLEDNtuple.enableOutputTree = True
     acc.addEventAlgo(zdcLEDNtuple)
     acc.addService(CompFactory.THistSvc(Output = ["ANALYSIS DATAFILE='NTUP.root' OPT='RECREATE'"]))    
     return acc
  

◆ ZdcLEDRecCfg()

def python.ZdcRecConfig.ZdcLEDRecCfg ( flags )

Definition at line 579 of file ZdcRecConfig.py.

 def ZdcLEDRecCfg(flags):
  
     acc = ComponentAccumulator()
     
     if flags.Input.Format is Format.BS:
         run = flags.GeoModel.Run
         
         # debugging message since the metadata isn't working for calibration files yet
         log.info ("ZdcRecConfig.py: run = "+run.name)
         
         config = 'ppPbPb2023'
         #config = 'ppALFA2023'
         doFADCCorr = False
  
         if (flags.GeoModel.Run == LHCPeriod.Run3):
             doFADCCorr = False
         
         acc.addEventAlgo(CompFactory.ZdcByteStreamLucrodData())
         acc.addEventAlgo(CompFactory.ZdcRecRun3Decode())
  
         anaTool = acc.popToolsAndMerge(ZdcLEDAnalysisToolCfg(flags, config, DoFADCCorr = doFADCCorr)) #anatool for zdcLED calibration  
     
         zdcTools = []
         zdcTools += [anaTool] # add trigTool after deocration migration
     
         # FIXME these are dependent on !65768
         zdcAlg = CompFactory.ZdcRecRun3("ZdcRecRun3",DAQMode=2, ForcedEventType=2, ZdcAnalysisTools=zdcTools) # DAQMode set to PhysicsPEB, event type set to ZdcEventLED
         acc.addEventAlgo(zdcAlg, primary=True)
  
     if flags.Output.doWriteESD or flags.Output.doWriteAOD:
         acc.merge(ZdcRecOutputCfg(flags))
         
     return acc
  

◆ ZdcLEDTrigCfg()

def python.ZdcRecConfig.ZdcLEDTrigCfg ( flags )

Definition at line 613 of file ZdcRecConfig.py.

 def ZdcLEDTrigCfg(flags):
  
     acc = ComponentAccumulator()
  
     # suggested by Tim Martin
     tdmv = CompFactory.TrigDec.TrigDecisionMakerValidator()          
     tdmv.errorOnFailure = True
     tdmv.TrigDecisionTool = acc.getPrimaryAndMerge(TrigDecisionToolCfg(flags))
     tdmv.NavigationKey = getRun3NavigationContainerFromInput(flags)
     acc.addEventAlgo( tdmv )
     # end of Tim's suggestions
     return acc
  

◆ ZdcNtupleLocalCfg()

def python.ZdcRecConfig.ZdcNtupleLocalCfg ( flags )

Definition at line 493 of file ZdcRecConfig.py.

 def ZdcNtupleLocalCfg(flags):
     
     acc = ComponentAccumulator()
     run = flags.GeoModel.Run
  
     if run == LHCPeriod.Run2:
         log.info ('ZdcRecConfig.py: setting up Run 2 ntuple!')
         acc.merge(ZdcNtupleRun2Cfg(flags))
     elif run == LHCPeriod.Run3:
         log.info ('ZdcRecConfig.py: setting up Run 3 ntuples!')
         acc.merge(ZdcNtupleRun3Cfg(flags))
     else:
         log.info ('ZdcRecConfig.py: setting up no ntuple!')
  
     return acc
  

◆ ZdcNtupleRun2Cfg()

def python.ZdcRecConfig.ZdcNtupleRun2Cfg	(		flags,
		**	kwargs
	)

Definition at line 509 of file ZdcRecConfig.py.

 def ZdcNtupleRun2Cfg(flags,**kwargs):
  
     acc = ComponentAccumulator()
     acc.merge(ZdcNtupleCfg(flags,
                            useGRL = False,
                            zdcOnly = True,
                            enableTrigger = False,
                            enableOutputSamples = True,
                            enableOutputTree = True,
                            writeOnlyTriggers = False,
                            nsamplesZdc = 7,
                            **kwargs))
  
     acc.addService(CompFactory.THistSvc(Output = ["ANALYSIS DATAFILE='zdctree.root' OPT='RECREATE'"]))
     return acc
  

◆ ZdcNtupleRun3Cfg()

def python.ZdcRecConfig.ZdcNtupleRun3Cfg	(		flags,
		**	kwargs
	)

Definition at line 525 of file ZdcRecConfig.py.

 def ZdcNtupleRun3Cfg(flags,**kwargs):
     
     acc = ComponentAccumulator()
     acc.merge(ZdcNtupleCfg(flags,
                            useGRL = False,
                            zdcOnly = True,
                            lhcf2022 = False,
                            lhcf2022zdc = False,
                            lhcf2022afp = False,
                            isMC = flags.Input.isMC,
                            enableTrigger = not flags.Input.isMC,
                            enableOutputSamples = True,
                            enableOutputTree = True,
                            writeOnlyTriggers = False,
                            enableRPD = flags.Detector.EnableZDC_RPD,
                            enableCentroid = flags.Detector.EnableZDC_RPD,
                            reprocZdc = False,
                            **kwargs))
  
     acc.addService(CompFactory.THistSvc(Output = ["ANALYSIS DATAFILE='NTUP.root' OPT='RECREATE'"]))
     #acc.setAppProperty("HistogramPersistency","ROOT")
     return acc
  

◆ ZdcRecCfg()

def python.ZdcRecConfig.ZdcRecCfg ( flags )

Configure Zdc analysis alg
Additional arguments are useful in calibration runs

Definition at line 626 of file ZdcRecConfig.py.

 def ZdcRecCfg(flags):    
     """Configure Zdc analysis alg
     Additional arguments are useful in calibration runs
     """
  
     acc = ComponentAccumulator()
  
     run = flags.GeoModel.Run
  
     # debugging message since the metadata isn't working for calibration files yet
     log.info ("ZdcRecConfig.py: run = "+run.name)
  
     if run == LHCPeriod.Run2:
         log.info ('ZdcRecConfig.py: setting up Run 2!')
         acc.merge(ZdcRecRun2Cfg(flags))
     elif run == LHCPeriod.Run3:
         log.info ('ZdcRecConfig.py: setting up Run 3!')
         acc.merge(ZdcRecRun3Cfg(flags))
     else:
         log.warning ('ZdcRecConfig.py: setting up nothing (problem)!')
  
     if flags.Output.doWriteESD or flags.Output.doWriteAOD:
         acc.merge(ZdcRecOutputCfg(flags))
  
     return acc
  
  

◆ ZdcRecOutputCfg()

def python.ZdcRecConfig.ZdcRecOutputCfg ( flags )

Definition at line 256 of file ZdcRecConfig.py.

 def ZdcRecOutputCfg(flags):
  
     acc = ComponentAccumulator()
  
     ZDC_ItemList=[]
     if flags.Input.Format is Format.BS:
         ZDC_ItemList.append("xAOD::ZdcModuleContainer#ZdcModules")
         ZDC_ItemList.append("xAOD::ZdcModuleAuxContainer#ZdcModulesAux.")
         ZDC_ItemList.append("xAOD::ZdcModuleContainer#ZdcSums")
         ZDC_ItemList.append("xAOD::ZdcModuleAuxContainer#ZdcSumsAux.")
  
     acc.merge(addToESD(flags,ZDC_ItemList))
     acc.merge(addToAOD(flags,ZDC_ItemList))
  
     if flags.Output.doWriteAOD:
         from xAODMetaDataCnv.InfileMetaDataConfig import SetupMetaDataForStreamCfg
         acc.merge(SetupMetaDataForStreamCfg(flags,streamName="AOD"))    
  
     return acc
  
  

◆ ZdcRecRun2Cfg()

def python.ZdcRecConfig.ZdcRecRun2Cfg ( flags )

Definition at line 347 of file ZdcRecConfig.py.

 def ZdcRecRun2Cfg(flags):        
     acc = ComponentAccumulator()
     config = SetConfigTag(flags)
     log.info ('ZdcRecConfig.py: Running with config tag%s', config)
  
     doCalib = False
     doTimeCalib = False
     doTrigEff = False
     doNonLinCorr = False
     doFADCCorr = False
  
     if flags.Input.ProjectName == "data15_hi":
         doCalib = True
         doTimeCalib = True
         doTrigEff = True
     elif flags.Input.ProjectName == "data17_13TeV":
         doCalib = False
         doTimeCalib = False
         doTrigEff = False
     elif flags.Input.ProjectName == "data16_hip":
         doCalib = True
         doTimeCalib = False
         doTrigEff = False
     elif flags.Input.ProjectName == "data18_hi":
         doCalib = True
         doTimeCalib = False
         doTrigEff = False
  
     acc.merge(ByteStreamReadCfg(flags, type_names=['xAOD::TriggerTowerContainer/ZdcTriggerTowers',
                                          'xAOD::TriggerTowerAuxContainer/ZdcTriggerTowersAux.']))
  
     acc.addEventAlgo(CompFactory.ZdcByteStreamRawDataV2())
     acc.addEventAlgo(CompFactory.ZdcRecV3Decode())
  
     anaTool = acc.popToolsAndMerge(ZdcAnalysisToolCfg(flags,2,config,doCalib,doFADCCorr,doNonLinCorr,doTimeCalib,doTrigEff))
  
     acc.addEventAlgo(CompFactory.ZdcRecV3("ZdcRecV3",ZdcAnalysisTool=anaTool))
  
     return acc
  

◆ ZdcRecRun3Cfg()

def python.ZdcRecConfig.ZdcRecRun3Cfg ( flags )

Definition at line 387 of file ZdcRecConfig.py.

 def ZdcRecRun3Cfg(flags):
  
     acc = ComponentAccumulator()
     config = SetConfigTag(flags)
     log.info ('ZdcRecConfig.py: Running with config tag %s', config)
  
     doCalib = False
     doTimeCalib = False
     doTrigEff = False
     doFADCCorr = False
     doNonLinCorr = True #default for 2023
     ForceCalibRun = -1
     ForceCalibLB = 814
     AuxSuffix = ""
     
     if flags.Input.TriggerStream != "calibration_ZDCInjCalib" and flags.Input.TriggerStream != "calibration_DcmDummyProcessor":
         if flags.Common.isOnline: # calibration file for ongoing run not available - copy calib file from eos & hard code the run + lb
             doCalib = True
             doTimeCalib = True
             if flags.Input.ProjectName == "data24_5p36TeV" or flags.Input.ProjectName == "data24_refcomm":
                 ForceCalibRun = 488239
                 ForceCalibLB = 1
             elif flags.Input.ProjectName == "data24_hi" or flags.Input.ProjectName == "data24_hicomm":
                 ForceCalibRun = 488980 # place holder available at point1 - replace with a 2024 run during data taking
                 ForceCalibLB = 80
             else:
                 doCalib = False
                 doTimeCalib = False
         elif flags.Input.ProjectName == "data23_comm":
             doCalib = True
         elif flags.Input.ProjectName == "data23_hi": # for "data24_hi" or "data24_5p36TeV," need to also check flags.Input.TriggerStream != "calibration_ZDCInjCalib"
             doCalib = True
             doTimeCalib = True
         elif flags.Input.ProjectName == "data24_hi": # for "data24_hi" or "data24_5p36TeV," need to also check flags.Input.TriggerStream != "calibration_ZDCInjCalib"
             doCalib = True
             doTimeCalib = True
             doFADCCorr = False
             doNonLinCorr = False
         elif flags.Input.ProjectName in ["data25_hip","data25_hipcomm"]: # for "data24_hi" or "data24_5p36TeV," need to also check flags.Input.TriggerStream != "calibration_ZDCInjCalib"
             doCalib = True
             doTimeCalib = False
             doFADCCorr = False
             doNonLinCorr = False
         elif flags.Input.ProjectName in ["data25_hi","data25_hicomm"]: # for "data24_hi" or "data24_5p36TeV," need to also check flags.Input.TriggerStream != "calibration_ZDCInjCalib"
             doCalib = True
             doTimeCalib = False
             doFADCCorr = False
             doNonLinCorr = False
  
     # No calibration required (or exists) for MC
     if flags.Input.isMC:
             doCalib = False
  
     doRPD = flags.Detector.EnableZDC_RPD
  
     log.info('ZdcRecRun3Cfg: doCalib = '+str(doCalib)+' for project '+flags.Input.ProjectName)
     log.info('RPD enable flag is '+str(doRPD))
  
     zdcReproc = False
     if "ZdcModules" in flags.Input.Collections:
         log.info('ZdcRecConfig.py: found ZdcModules in input, reprocessing mode set')
         AuxSuffix="RP"
         zdcReproc = True
         
     anaTool = acc.popToolsAndMerge(ZdcAnalysisToolCfg(flags,3,config,doCalib,doFADCCorr,doNonLinCorr,doTimeCalib,doTrigEff,ForceCalibRun,ForceCalibLB, AuxSuffix))
  
         
     if (doRPD):
         rpdAnaTool = acc.popToolsAndMerge(RPDAnalysisToolCfg(flags, config, AuxSuffix))
         centroidTool = acc.popToolsAndMerge(RpdSubtractCentroidToolCfg(flags, config, AuxSuffix))
  
     if  flags.Input.isMC :
         zdcTools = [anaTool] # expand list as needed
         if doRPD:
             zdcTools += [rpdAnaTool,centroidTool]
     elif  flags.Trigger.doZDC : # if doZDC flag is true we are in a trigger reprocessing -> no TrigValidTool
         zdcTools = [anaTool] # expand list as needed
     elif flags.Input.TriggerStream == "calibration_ZDCInjCalib" or flags.Input.TriggerStream == "calibration_DcmDummyProcessor":
         zdcTools = [anaTool] # no trigger / RPD / centroid - either online or offline
     elif flags.Common.isOnline: # running online + NOT injector pulse: with RPD + centroid but no trigger validation for now; may add later
         zdcTools = [anaTool] # expand list as needed
         if doRPD:
             zdcTools += [rpdAnaTool,centroidTool]
     elif (zdcReproc): # ZDC reprocessing (will take work to make it work for RPD)
         zdcTools = [anaTool]
         if doRPD:
             zdcTools += [rpdAnaTool,centroidTool]
     else: # default (not MC, not trigger repoc, not injector pulse, not online)
         trigTool = acc.popToolsAndMerge(ZdcTrigValToolCfg(flags,config))  
         zdcTools = [anaTool,trigTool] # expand list as needed
         if doRPD:
             zdcTools += [rpdAnaTool,centroidTool]
     
     if flags.Input.Format is Format.BS:
         acc.addEventAlgo(CompFactory.ZdcByteStreamLucrodData())
         acc.addEventAlgo(CompFactory.ZdcRecRun3Decode())
     if flags.Input.isMC:
         from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
         acc.merge(PoolReadCfg(flags))
         acc.addEventAlgo(CompFactory.ZdcMCTruthAlg())
  
     zdcAlg = CompFactory.ZdcRecRun3("ZdcRecRun3",ZdcAnalysisTools=zdcTools)
     acc.addEventAlgo(zdcAlg, primary=True)
  
     return acc
  

◆ ZdcStreamDependentFlagSetting()

def python.ZdcRecConfig.ZdcStreamDependentFlagSetting ( flags )

Function that checks on data type from triggerstream tag
and sets run-type-and-year-dependent settings
Returns: a tuple of the following four values
    isLED - bool, true if running on LED data
    isInj - bool, true if running on Inj data
    isCalib - bool, true if running on Calib data
    pn - string, project name such as data24_hi

Definition at line 175 of file ZdcRecConfig.py.

 def ZdcStreamDependentFlagSetting(flags): 
     '''Function that checks on data type from triggerstream tag
     and sets run-type-and-year-dependent settings
     Returns: a tuple of the following four values
         isLED - bool, true if running on LED data
         isInj - bool, true if running on Inj data
         isCalib - bool, true if running on Calib data
         pn - string, project name such as data24_hi
     '''
     # check for LED / calibration data running, and configure appropriately
     isComm = (flags.Input.ProjectName == "data25_comm" and flags.Input.TriggerStream == "calibration_ZDCCalib")
     isLED = (flags.Input.TriggerStream == "calibration_ZDCLEDCalib")
     isInj = (flags.Input.TriggerStream == "calibration_ZDCInjCalib" or isComm)
     isCalib = (flags.Input.TriggerStream == "calibration_ZDCCalib" or "physics_" in flags.Input.TriggerStream or flags.Input.TriggerStream == "express_express" and not isComm)
     
     if flags.Input.TriggerStream == "calibration_DcmDummyProcessor": # standalone data: do we want to run calibration or LED?
         runInjForStandaloneDataArgValid = False
         
         if flags.hasFlag("runInjForStandaloneData"): # if passed as an argument, runInjForStandaloneData should have been dynamically loaded as a flag in fillFromArgs
             if flags.runInjForStandaloneData.lower() == "inj":
                 isInj = True
                 runInjForStandaloneDataArgValid = True
             elif flags.runInjForStandaloneData.lower() == "led":
                 isLED = True
                 runInjForStandaloneDataArgValid = True
  
         if not runInjForStandaloneDataArgValid: # runInjForStandaloneData is not a defined flag
             log.warning("runInjForStandaloneData is either not a defined flag or has invalid value (value must be Inj / LED, case insensitive).")
             log.warning("Running nominal reconstruction (injector-pulse) by default for standalone data")
             log.warning("Could lead to undesired behavior if pulsing LED in standalone mode")
             isInj = True
  
     if isLED:
         log.info('ZdcRecConfig: Running LED data!')
     if isInj:
         log.info('ZdcRecConfig: Running Injected pulse data!')
     if isCalib:
         log.info('ZdcRecConfig: Running ZDC calibration data!')
     if flags.Input.isMC:
         log.info('ZdcRecConfig: Running over MC Samples')
         flags.Input.ProjectName = "data23_hi"
         flags.Reco.EnableTrigger = False
  
     # supply missing metadata based on project name
     pn = flags.Input.ProjectName
     if not pn:
         raise ValueError('Unknown project name')
     
     if isLED or isInj or pn == 'data_test':
         flags.Trigger.EDMVersion=3
         flags.GeoModel.Run = LHCPeriod.Run3
         flags.IOVDb.GlobalTag=defaultConditionsTags.RUN3_DATA
     else:
         year = int(pn.split('_')[0].split('data')[1])
         if year < 20:
             flags.Trigger.EDMVersion=2
             flags.GeoModel.Run = LHCPeriod.Run2
             flags.IOVDb.GlobalTag=defaultConditionsTags.RUN2_DATA
         elif year > 20:
             flags.Trigger.EDMVersion=3
             flags.GeoModel.Run = LHCPeriod.Run3
             flags.IOVDb.GlobalTag=defaultConditionsTags.RUN3_DATA
  
     if flags.Input.isMC:
         log.info('ZdcRecConfig: Overriding MC run to be Run 3!')
         flags.GeoModel.Run = LHCPeriod.Run3
  
     if (isInj
         or flags.Input.TriggerStream == "calibration_DcmDummyProcessor"
         or pn == "data22_13p6TeV"):
         flags.Detector.EnableZDC_RPD = False # disable RPD for injector, LHCf
  
     if flags.Input.TriggerStream == "calibration_DcmDummyProcessor": # standalone data: no trigger info available
         flags.DQ.useTrigger = False
         flags.DQ.triggerDataAvailable = False 
  
     flags.GeoModel.AtlasVersion=zdcGeometry(flags)
  
     return isLED, isInj, isCalib, pn # return a ntuple of stream and project-name info for further use
  
  

◆ ZdcTrigValToolCfg()

def python.ZdcRecConfig.ZdcTrigValToolCfg	(	flags,
		config = `'PbPb2023'`
	)

Definition at line 306 of file ZdcRecConfig.py.

 def ZdcTrigValToolCfg(flags, config = 'PbPb2023'):
     acc = ComponentAccumulator()
     
     acc.merge(TrigDecisionToolCfg(flags))
     
     trigValTool = CompFactory.ZDC.ZdcTrigValidTool(
         name = 'ZdcTrigValTool',
         WriteAux = True,
         AuxSuffix = '',
         filepath_LUT = 'TrigT1ZDC/zdc_json_PbPb5.36TeV_2023.json') # changed on Oct 13 to accomodate Zdc 1n peak shift
         
     trigValTool.TrigDecisionTool = acc.getPublicTool('TrigDecisionTool')
     
     trigValTool.triggerList = [c for c in getL1MenuAccess(flags) if 'L1_ZDC_BIT' in c]
     
     acc.setPrivateTools(trigValTool)
       
     return acc
  

Variable Documentation

◆ acc

python.ZdcRecConfig.acc = MainServicesCfg(flags)

Definition at line 677 of file ZdcRecConfig.py.

◆ AODFileName

python.ZdcRecConfig.AODFileName

Definition at line 668 of file ZdcRecConfig.py.

◆ doWriteAOD

python.ZdcRecConfig.doWriteAOD

Definition at line 670 of file ZdcRecConfig.py.

◆ flags

python.ZdcRecConfig.flags = initConfigFlags()

Definition at line 664 of file ZdcRecConfig.py.

◆ HISTFileName

python.ZdcRecConfig.HISTFileName

Definition at line 669 of file ZdcRecConfig.py.

◆ isCalib

python.ZdcRecConfig.isCalib

Definition at line 672 of file ZdcRecConfig.py.

◆ isInj

python.ZdcRecConfig.isInj

Definition at line 672 of file ZdcRecConfig.py.

◆ isLED

python.ZdcRecConfig.isLED

Definition at line 672 of file ZdcRecConfig.py.

◆ log

python.ZdcRecConfig.log = logging.getLogger("ZdcRecConfig")

Definition at line 25 of file ZdcRecConfig.py.

◆ pn

python.ZdcRecConfig.pn

Definition at line 672 of file ZdcRecConfig.py.

◆ status

python.ZdcRecConfig.status = acc.run()

Definition at line 719 of file ZdcRecConfig.py.

◆ withDetails

python.ZdcRecConfig.withDetails

Definition at line 714 of file ZdcRecConfig.py.

◆ zdcConfigMap

dictionary python.ZdcRecConfig.zdcConfigMap = {}

Definition at line 27 of file ZdcRecConfig.py.

◆ zdcMonitorAcc

python.ZdcRecConfig.zdcMonitorAcc = ZdcMonitoringConfig(flags)

Definition at line 701 of file ZdcRecConfig.py.

Functions

Variables

Function Documentation

◆ GenerateConfigTagDict()

◆ RPDAnalysisToolCfg()

◆ RpdSubtractCentroidToolCfg()

◆ SetConfigTag()

◆ ZdcAnalysisToolCfg()

◆ ZdcGenericFlagSetting()

◆ zdcGeometry()

◆ ZdcInjNtupleCfg()

◆ ZdcLEDAnalysisToolCfg()

◆ ZdcLEDNtupleCfg()

◆ ZdcLEDRecCfg()

◆ ZdcLEDTrigCfg()

◆ ZdcNtupleLocalCfg()

◆ ZdcNtupleRun2Cfg()

◆ ZdcNtupleRun3Cfg()

◆ ZdcRecCfg()

◆ ZdcRecOutputCfg()

◆ ZdcRecRun2Cfg()

◆ ZdcRecRun3Cfg()

◆ ZdcStreamDependentFlagSetting()

◆ ZdcTrigValToolCfg()

Variable Documentation

◆ acc

◆ AODFileName

◆ doWriteAOD

◆ flags

◆ HISTFileName

◆ isCalib

◆ isInj

◆ isLED

◆ log

◆ pn

◆ status

◆ withDetails

◆ zdcConfigMap

◆ zdcMonitorAcc