Functions
	zdcGeometry (flags)
	GenerateConfigTagDict ()
	SetConfigTag (flags)
	ZdcGenericFlagSetting (flags)
	ZdcStreamDependentFlagSetting (flags)
	ZdcRecOutputCfg (flags)
	ZdcAnalysisToolCfg (flags, run, config="PbPb2023", DoCalib=False, DoFADCCorr=False, DoNonLinCorr=False, DoTimeCalib=False, DoTrigEff=False, ForceCalibRun=-1, ForceCalibLB=814, AuxSuffix="")
	ZdcLEDAnalysisToolCfg (flags, config='ppPbPb2023', DoFADCCorr=True)
	ZdcTrigValToolCfg (flags, config='PbPb2023')
	RPDAnalysisToolCfg (flags, str config, AuxSuffix="")
	RpdSubtractCentroidToolCfg (flags, str config, AuxSuffix="")
	LISAnalysisToolCfg (flags, str config)
	ZdcLisNtupleCfg (flags, lisInj=False, lisLED=False, enableTrigger=True)
	ZdcRecRun2Cfg (flags)
	ZdcRecRun3Cfg (flags)
	ZdcNtupleLocalCfg (flags)
	ZdcNtupleRun2Cfg (flags, **kwargs)
	ZdcNtupleRun3Cfg (flags, **kwargs)
	ZdcInjNtupleCfg (flags, **kwargs)
	ZdcLEDNtupleCfg (flags)
	ZdcLEDRecCfg (flags)
	ZdcLEDTrigCfg (flags)
	LisRecCfg (flags)
	ZdcRecCfg (flags)

Variables
	log = logging.getLogger("ZdcRecConfig")
dict	zdcConfigMap = {}
	flags = initConfigFlags()
list	ProjectNamesLIS = ["data26_cos", "data26_900GeV", "data26_13p6TeV","data26_comm", "data_test"]
	AODFileName
	HISTFileName
	doWriteAOD
	isLED
	isInj
	isCalib
	pn
	acc = MainServicesCfg(flags)
	zdcMonitorAcc = ZdcMonitoringConfig(flags)
	withDetails
	status = acc.run()

Function Documentation

◆ GenerateConfigTagDict()

python.ZdcRecConfig.GenerateConfigTagDict ( )

Definition at line 64 of file ZdcRecConfig.py.

def GenerateConfigTagDict():
 
    zdcConfigMap['data15_hi'] = {}
    zdcConfigMap['data16_hip5TeV'] = {}
    zdcConfigMap['data16_hip8TeV'] = {}
    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"
    

◆ LISAnalysisToolCfg()

python.ZdcRecConfig.LISAnalysisToolCfg	(		flags,
		str	config )

Definition at line 381 of file ZdcRecConfig.py.

def LISAnalysisToolCfg(flags, config: str):
    acc = ComponentAccumulator()
    acc.setPrivateTools(
        CompFactory.ZDC.LISAnalysisTool(
            name="LISAnalysisTool",
            Configuration=config,
            BaselineStart=0,
            BaselineEnd=5,
            PulseStart=6,
            PulseEnd=12,
            ChannelPedestals=[100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0]
        )
    )
    return acc
 

◆ LisRecCfg()

python.ZdcRecConfig.LisRecCfg ( flags )

Definition at line 696 of file ZdcRecConfig.py.

def LisRecCfg(flags):
 
    acc = ComponentAccumulator()
 
    run = flags.GeoModel.Run
 
    # debugging message since the metadata isn't working for calibration files yet
    log.info ("LisRecConfig.py: run = "+run.name)
    config = SetConfigTag(flags)
 
    DecodeRunMode = 1 # LIS run mode
 
    if flags.Input.ProjectName in ["data26_comm", "data26_900GeV", "data26_13p6TeV", "data26_cos"]:
        DecodeRunMode = 1 # LIS run mode
    elif flags.Input.ProjectName in []: #special run mode for 7 lucrod - not currently used
        DecodeRunMode = 2 # 7 lucrod run mode, 2026 jan M week
 
    # LIS processing
    
    isLED = (flags.Input.TriggerStream == "calibration_ZDCLEDCalib")
 
    anaTool = acc.popToolsAndMerge(LISAnalysisToolCfg(flags,config)) 
    zdcTools = [anaTool]
 
    if flags.Input.Format is Format.BS:
        acc.merge(ByteStreamReadCfg(flags))
        acc.addEventAlgo(CompFactory.ZdcByteStreamLucrodData())
        acc.addEventAlgo(CompFactory.ZdcRecRun3Decode( DecodeRunMode = DecodeRunMode ))
 
    evtType = 2 if isLED else 1 # event type set to ZdcEventLED for LED, otherwise default to normal data/MC event type
    DAQMode = 2 if isLED else 3 # DAQMode set to PhysicsPEB for LED, otherwise default to normal data/MC run mode
 
    zdcAlg = CompFactory.ZdcRecRun3("ZdcRecRun3",DAQMode=DAQMode, ForcedEventType=evtType, 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
 

◆ RPDAnalysisToolCfg()

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

Definition at line 359 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()

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

Definition at line 370 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()

python.ZdcRecConfig.SetConfigTag ( flags )

Definition at line 94 of file ZdcRecConfig.py.

def SetConfigTag(flags):
 
    aa_type = 82 # default to Pb+Pb unless a run number is provided
    if flags.Input.RunNumbers:
        run_num = flags.Input.RunNumbers[0]
        aa = getTypeForRun(run_num)
        if aa is not None:
            aa_type = aa.getBeam1Type()
    print('ZdcRecConfig::SetConfigTag(): Getting config for type %d' % (aa_type))    
    # terrible kludge for early 2025
    if flags.Input.ProjectName == "data25_comm" and flags.Input.TriggerStream == "calibration_ZDCCalib":
        config = "InjectorPbPb2024"
    
    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"] :
            if (aa_type == 8 or aa_type == 10):
                config = "InjectorpOOONeNe2025"
            if (aa_type == 82):
                config = "configZDC_PbPb2025.inj.v1.json"
 
    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 = "configZDC_PbPb2024.v5.json" 
            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"]:
                if (aa_type == 8 or aa_type == 10):
                    config = "OONeNe2025"
                if (aa_type == 82):
                    config = "configZDC_PbPb2025.v1.json"
            elif flags.Input.ProjectName in ["data26_comm", "data26_cos", "data26_900GeV", "data26_13p6TeV"]:
                config = "configZDC_PbPb2025.v1.json" # assume same config for 2026 pp as for PbPb for 2025 run
            
        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_hip5TeV":
                config = "pPb2016"
            elif flags.Input.ProjectName == "data16_hip8TeV":
                if(aa_type == 1):
                    config = "configZDC_pPb2016.v1.json"
                if(aa_type == 82):
                    config = "configZDC_Pbp2016.v1.json"
            elif flags.Input.ProjectName == "data18_hi":
                config = "PbPb2018"
 
    return config
 
 

◆ ZdcAnalysisToolCfg()

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 301 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)
 
    jsonFile = ''
    
    if (config[-5:]=='.json'):
        jsonFile = config
        config = "JSON"
        log.info('ZdcAnalysisToolCfg: setting up with JSON file '+jsonFile)
        
    acc.setPrivateTools(CompFactory.ZDC.ZdcAnalysisTool(
        name = 'ZdcAnalysisTool'+config, 
        Configuration = config,
        DoCalib = DoCalib,
        DoFADCCorr = DoFADCCorr,
        DoFADCCorrPerSample = True,
        DoNonLinCorr = DoNonLinCorr,
        DoTimeCalib = DoTimeCalib,
        DoTrigEff = DoTrigEff,
        ForceCalibRun = ForceCalibRun,
        ForceCalibLB = ForceCalibLB,
        AuxSuffix = AuxSuffix,
        JSONConfigurationFile=jsonFile,
        LHCRun = run,
        CombineDelay = True if flags.Input.ProjectName == "data16_hip8TeV" else False))
    return acc
 

◆ ZdcGenericFlagSetting()

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 166 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()

python.ZdcRecConfig.zdcGeometry ( flags )

Definition at line 31 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_hip5TeV":
            return defaultGeometryTags.RUN2_ZDC
        case "data16_hip8TeV":
            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()

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

Definition at line 618 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()

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

Definition at line 330 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()

python.ZdcRecConfig.ZdcLEDNtupleCfg ( flags )

Definition at line 641 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()

python.ZdcRecConfig.ZdcLEDRecCfg ( flags )

Definition at line 649 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.Input.ProjectName in ["data24_hi","data25_hip","data25_hi"]:
            doFADCCorr = True
    
        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()

python.ZdcRecConfig.ZdcLEDTrigCfg ( flags )

Definition at line 683 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
 

◆ ZdcLisNtupleCfg()

python.ZdcRecConfig.ZdcLisNtupleCfg	(	flags,
		lisInj = False,
		lisLED = False,
		enableTrigger = True )

Definition at line 396 of file ZdcRecConfig.py.

def ZdcLisNtupleCfg(flags, lisInj=False, lisLED=False, enableTrigger=True):
    acc = ComponentAccumulator()
    LisNtuple = CompFactory.LisNtuple("LisNtuple")
    LisNtuple.enableOutputTree = True
    LisNtuple.lisInj = lisInj
    LisNtuple.lisLED = lisLED
    LisNtuple.enableTrigger = enableTrigger
    acc.addEventAlgo(LisNtuple)
    acc.addService(CompFactory.THistSvc(Output = ["ANALYSIS DATAFILE='NTUP.root' OPT='RECREATE'"]))    
    return acc
 

◆ ZdcNtupleLocalCfg()

python.ZdcRecConfig.ZdcNtupleLocalCfg ( flags )

Definition at line 563 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()

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

Definition at line 579 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='NTUP.root' OPT='RECREATE'"]))
    return acc
 

◆ ZdcNtupleRun3Cfg()

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

Definition at line 595 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()

python.ZdcRecConfig.ZdcRecCfg ( flags )

Configure Zdc analysis alg
Additional arguments are useful in calibration runs

Definition at line 736 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()

python.ZdcRecConfig.ZdcRecOutputCfg ( flags )

Definition at line 280 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()

python.ZdcRecConfig.ZdcRecRun2Cfg ( flags )

Definition at line 407 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_hip5TeV":
        doCalib = True
        doTimeCalib = False
        doTrigEff = False
    elif flags.Input.ProjectName == "data16_hip8TeV":
        doCalib = True
        doTimeCalib = True
        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()

python.ZdcRecConfig.ZdcRecRun3Cfg ( flags )

Definition at line 451 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": 
            doCalib = True
            doTimeCalib = True
        elif flags.Input.ProjectName == "data24_hi": 
            doCalib = True
            doTimeCalib = True
            doFADCCorr = True
            doNonLinCorr = False
        elif flags.Input.ProjectName in ["data25_hip","data25_hipcomm"]:
            doCalib = True
            doTimeCalib = False
            doFADCCorr = False
            doNonLinCorr = False
        elif flags.Input.ProjectName in ["data25_hicomm"]:
            doCalib = False
            doTimeCalib = False
            doFADCCorr = False
            doNonLinCorr = False            
        elif flags.Input.ProjectName in ["data25_hi"]: 
            doCalib = True
            doTimeCalib = True
            doFADCCorr = True
            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()

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 199 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 in ["calibration_ZDCCalib","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()

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

Definition at line 340 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 792 of file ZdcRecConfig.py.

◆ AODFileName

python.ZdcRecConfig.AODFileName

Definition at line 782 of file ZdcRecConfig.py.

◆ doWriteAOD

python.ZdcRecConfig.doWriteAOD

Definition at line 784 of file ZdcRecConfig.py.

◆ flags

python.ZdcRecConfig.flags = initConfigFlags()

Definition at line 774 of file ZdcRecConfig.py.

◆ HISTFileName

python.ZdcRecConfig.HISTFileName

Definition at line 783 of file ZdcRecConfig.py.

◆ isCalib

python.ZdcRecConfig.isCalib

Definition at line 786 of file ZdcRecConfig.py.

◆ isInj

python.ZdcRecConfig.isInj

Definition at line 786 of file ZdcRecConfig.py.

◆ isLED

python.ZdcRecConfig.isLED

Definition at line 786 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 786 of file ZdcRecConfig.py.

◆ ProjectNamesLIS

list python.ZdcRecConfig.ProjectNamesLIS = ["data26_cos", "data26_900GeV", "data26_13p6TeV","data26_comm", "data_test"]

Definition at line 778 of file ZdcRecConfig.py.

◆ status

python.ZdcRecConfig.status = acc.run()

Definition at line 841 of file ZdcRecConfig.py.

◆ withDetails

python.ZdcRecConfig.withDetails

Definition at line 836 of file ZdcRecConfig.py.

◆ zdcConfigMap

dict python.ZdcRecConfig.zdcConfigMap = {}

Definition at line 29 of file ZdcRecConfig.py.

◆ zdcMonitorAcc

python.ZdcRecConfig.zdcMonitorAcc = ZdcMonitoringConfig(flags)

Definition at line 825 of file ZdcRecConfig.py.

Functions

Variables

Function Documentation

◆ GenerateConfigTagDict()

◆ LISAnalysisToolCfg()

◆ LisRecCfg()

◆ RPDAnalysisToolCfg()

◆ RpdSubtractCentroidToolCfg()

◆ SetConfigTag()

◆ ZdcAnalysisToolCfg()

◆ ZdcGenericFlagSetting()

◆ zdcGeometry()

◆ ZdcInjNtupleCfg()

◆ ZdcLEDAnalysisToolCfg()

◆ ZdcLEDNtupleCfg()

◆ ZdcLEDRecCfg()

◆ ZdcLEDTrigCfg()

◆ ZdcLisNtupleCfg()

◆ ZdcNtupleLocalCfg()

◆ ZdcNtupleRun2Cfg()

◆ ZdcNtupleRun3Cfg()

◆ ZdcRecCfg()

◆ ZdcRecOutputCfg()

◆ ZdcRecRun2Cfg()

◆ ZdcRecRun3Cfg()

◆ ZdcStreamDependentFlagSetting()

◆ ZdcTrigValToolCfg()

Variable Documentation

◆ acc

◆ AODFileName

◆ doWriteAOD

◆ flags

◆ HISTFileName

◆ isCalib

◆ isInj

◆ isLED

◆ log

◆ pn

◆ ProjectNamesLIS

◆ status

◆ withDetails

◆ zdcConfigMap

◆ zdcMonitorAcc