LArSuperCellMonAlg.py

Go to the documentation of this file.

#
#  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
#
 
def LArSuperCellMonConfig(flags, **kwargs):
    from AthenaCommon.Logging import logging
    from ByteStreamCnvSvc.ByteStreamConfig import ByteStreamReadCfg
    from AthenaConfiguration.ComponentFactory import CompFactory
    mlog = logging.getLogger( 'LArSuperCellMonConfig' )
    mask=True
 
    from AthenaMonitoring.AthMonitorCfgHelper import AthMonitorCfgHelper
    helper = AthMonitorCfgHelper(flags,'LArSuperCellMonAlgCfg')
 
    from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
    cfg=ComponentAccumulator()
 
    if not flags.DQ.enableLumiAccess and not flags.DQ.Environment == 'online':
       mlog.warning('This algo needs Lumi access, returning empty config')
       return cfg
 
    from LArGeoAlgsNV.LArGMConfig import LArGMCfg
    cfg.merge(LArGMCfg(flags))
    from TileGeoModel.TileGMConfig import TileGMCfg
    cfg.merge(TileGMCfg(flags))
 
    from DetDescrCnvSvc.DetDescrCnvSvcConfig import DetDescrCnvSvcCfg
    cfg.merge(DetDescrCnvSvcCfg(flags))
 
    if flags.Common.isOnline:
       cfg.addCondAlgo(CompFactory.CaloSuperCellAlignCondAlg('CaloSuperCellAlignCondAlg'))       
 
    from LumiBlockComps.BunchCrossingCondAlgConfig import BunchCrossingCondAlgCfg
    cfg.merge(BunchCrossingCondAlgCfg(flags))
 
    from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
    cfg.merge(CaloNoiseCondAlgCfg(flags))
    cfg.merge(CaloNoiseCondAlgCfg(flags,noisetype="electronicNoise"))
 
    cfg.merge(ByteStreamReadCfg(flags))
    from LArByteStream.LArRawSCDataReadingConfig import LArRawSCDataReadingCfg
    cfg.merge(LArRawSCDataReadingCfg(flags))
 
    from TrigT1CaloFexPerf.EmulationConfig import emulateSC_Cfg
    cfg.merge(emulateSC_Cfg(flags))
 
    from LArCellRec.LArRAWtoSuperCellConfig import LArRAWtoSuperCellCfg
 
    cfg.merge(LArRAWtoSuperCellCfg(flags,SCellContainerOut="EmulatedSuperCells",mask=mask) )
 
    # Reco SC:
    #get SC onl-offl mapping from DB    
    from LArCabling.LArCablingConfig import LArOnOffIdMappingSCCfg
    cfg.merge(LArOnOffIdMappingSCCfg(flags))
    
    # and elec. calib. coeffs
    from LArConfiguration.LArElecCalibDBConfig import LArElecCalibDBSCCfg
 
    larLATOMEBuilderAlg=CompFactory.LArLATOMEBuilderAlg("LArLATOMEBuilderAlg")
    from LArConditionsCommon.LArRunFormat import getLArDTInfoForRun
    try:
        runinfo=getLArDTInfoForRun(flags.Input.RunNumbers[0], connstring="COOLONL_LAR/CONDBR2")
        streamTypes=runinfo.streamTypes()
    except Exception as e:
        mlog.warning("Could not get DT run info, using defaults !")
        mlog.warning(e)
        streamTypes=["RawADC"]
    
    for i in range(0,len(streamTypes)):
        mlog.info("runinfo.streamTypes()[i]: "+str(streamTypes[i]))
        if streamTypes[i] ==  "RawADC":
            larLATOMEBuilderAlg.LArDigitKey = "SC"
            larLATOMEBuilderAlg.isADCBas = False
        if streamTypes[i] ==  "ADC":
            larLATOMEBuilderAlg.isADCBas = True
            larLATOMEBuilderAlg.LArDigitKey = "SC_ADC_BAS"
 
    cfg.addEventAlgo(larLATOMEBuilderAlg)
    cfg.merge(LArRAWtoSuperCellCfg(flags,name="LArRAWRecotoSuperCell",mask=mask,doReco=True,SCIn="SC_ET_RECO",SCellContainerOut="SCell_ET_RECO") )
 
 
    cfg.merge(LArElecCalibDBSCCfg(flags, condObjs=["Ramp","DAC2uA", "Pedestal", "uA2MeV", "MphysOverMcal", "OFC", "Shape", "HVScaleCorr"]))
 
    
    #return cfg
    algname='LArSuperCellMonAlg'
    lArCellMonAlg=CompFactory.LArSuperCellMonAlg(algname,CaloCellContainerReco="SCell_ET_RECO",CaloCellContainerRef=flags.Trigger.L1.L1CaloSuperCellContainerName,doSCReco=True,CaloCellContainer='EmulatedSuperCells')
 
    if flags.Input.isMC is False and not flags.Common.isOnline:
       from LumiBlockComps.LuminosityCondAlgConfig import  LuminosityCondAlgCfg
       cfg.merge(LuminosityCondAlgCfg(flags))
       from LumiBlockComps.LBDurationCondAlgConfig import  LBDurationCondAlgCfg
       cfg.merge(LBDurationCondAlgCfg(flags))
 
 
    from AthenaConfiguration.Enums import BeamType
    if flags.Beam.Type is BeamType.Cosmics:
        algname=algname+'Cosmics'
 
    LArSuperCellMonConfigCore(helper, lArCellMonAlg, flags,
                                     flags.Beam.Type is BeamType.Cosmics,
                                     flags.Input.isMC, algname, RemoveMasked=mask)
 
    cfg.merge(helper.result())
 
    return cfg
 
 
def LArSuperCellMonConfigCore(helper, algclass, flags, isCosmics=False, isMC=False, algname='LArSuperCellMonAlg', RemoveMasked=True):
 
 
 
    LArSuperCellMonAlg = helper.addAlgorithm(algclass, algname)
 
 
    GroupName="LArSuperCellMon"
    LArSuperCellMonAlg.MonGroupName = GroupName
 
    LArSuperCellMonAlg.EnableLumi = False
    LArSuperCellMonAlg.CaloCellContainer = 'EmulatedSuperCells'
    LArSuperCellMonAlg.CaloCellContainerRef = flags.Trigger.L1.L1CaloSuperCellContainerName
    LArSuperCellMonAlg.RemoveMasked = RemoveMasked
    LArSuperCellMonAlg.doDatabaseNoiseVsEtaPhi=True
    
 
    do2DOcc = True #TMP
    print(do2DOcc)
 
 
 
   #---single Group for non threshold histograms
    cellMonGroup = helper.addGroup(
        LArSuperCellMonAlg,
        GroupName,
        '/LAr/LArSuperCellMon_NoTrigSel/'
 
    )
    cellMonGroup=defineHistograms(cellMonGroup,LArSuperCellMonAlg.LayerNames,isHLT=False)
    return LArSuperCellMonAlg
 
def LArSuperCellMonConfigHLT(flags, name='LArSuperCellMonAlgHLT', RemoveMasked=True):
 
    from AthenaConfiguration.ComponentFactory import CompFactory
    from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
    from AthenaMonitoringKernel.GenericMonitoringTool import GenericMonitoringTool
    cfg=ComponentAccumulator()
    if flags.Common.isOnline:
       cfg.addCondAlgo(CompFactory.CaloSuperCellAlignCondAlg('CaloSuperCellAlignCondAlg'))
 
 
    from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
    cfg.merge(CaloNoiseCondAlgCfg(flags))
    cfg.merge(CaloNoiseCondAlgCfg(flags,noisetype="electronicNoise"))
 
    from TrigT1CaloFexPerf.EmulationConfig import emulateSC_Cfg
    cfg.merge(emulateSC_Cfg(flags,CellsOut="EmulatedSCells"))
 
    from LArCellRec.LArRAWtoSuperCellConfig import LArRAWtoSuperCellCfg
 
    # Reco SC:
    #get SC onl-offl mapping from DB
    from LArCabling.LArCablingConfig import LArOnOffIdMappingSCCfg
    cfg.merge(LArOnOffIdMappingSCCfg(flags))
 
    SCellsToCheck="SCellFromBS"
    if flags.Common.isOnline:
      from LArByteStream.LArRawSCDataReadingConfig import LArRawSCDataReadingCfg
      cfg.merge(LArRawSCDataReadingCfg(flags))
      mask=True
      cfg.merge(LArRAWtoSuperCellCfg(flags,name="LArRAWtoSuperCellFromBS",SCellContainerOut=SCellsToCheck,mask=mask) )
    else:
      SCellsToCheck="SCell"
 
    lArCellMonAlg=CompFactory.LArSuperCellMonAlg(name,CaloCellContainerReco="",CaloCellContainerRef="EmulatedSCells",doSCReco=False,CaloCellContainer=SCellsToCheck,TrigDecisionTool="",EnableLumi = False, RemoveMasked = RemoveMasked)
 
    if flags.Input.isMC is False and not flags.Common.isOnline:
       from LumiBlockComps.LuminosityCondAlgConfig import  LuminosityCondAlgCfg
       cfg.merge(LuminosityCondAlgCfg(flags))
       from LumiBlockComps.LBDurationCondAlgConfig import  LBDurationCondAlgCfg
       cfg.merge(LBDurationCondAlgCfg(flags))
 
 
    monTool = GenericMonitoringTool(flags, 'LArSuperCellMonTool')
    lArCellMonAlg.GMTools = [monTool]
    lArCellMonAlg.MonGroupName='LArSuperCellMonTool'
    lArCellMonAlg.BunchCrossingCondDataKey=""
 
    doDatabaseNoiseVsEtaPhi = False
    lArCellMonAlg.doDatabaseNoiseVsEtaPhi = doDatabaseNoiseVsEtaPhi
    monTool=defineHistograms(monTool,lArCellMonAlg.LayerNames,isHLT=True,isDatabaseNoise=doDatabaseNoiseVsEtaPhi,isReco=False,jumpHEC=True)
    cfg.addEventAlgo(lArCellMonAlg)
    return cfg
 
def defineHistograms(cellMonGroup,LayerNames,isHLT=False,isDatabaseNoise=True,isReco=True,jumpHEC=False):
 
 
    from LArMonitoring.GlobalVariables import lArDQGlobals
    #--define histograms
    sc_hist_path='SC/'
    if isHLT: sc_hist_path='EXPERT'
 
 
    cellMonGroup.defineHistogram('superCellEt;h_SuperCellEt',
                                 title='Super Cell E_T [MeV]; MeV; # entries',
                                 type='TH1F', path=sc_hist_path,
                                 xbins =  100,xmin=0,xmax=50000)
    cellMonGroup.defineHistogram('superCellEta;h_SuperCellEta',
                                 title='Super Cell eta; #eta; # entries',
                                 type='TH1F', path=sc_hist_path,
                                 xbins =  100,xmin=-5,xmax=5)
    cellMonGroup.defineHistogram('superCelltime;h_SuperCelltime',
                                 title='Super Cell time [ns]; ns; # entries',
                                 type='TH1F', path=sc_hist_path,
                                 xbins = 100, xmin=-400,xmax=400)
    cellMonGroup.defineHistogram('superCellprovenance;h_SuperCellprovenance',
                                 title='Super Cell provenance; bitmask ; # entries',
                                 type='TH1F', path=sc_hist_path,
                                 xbins = 700, xmin=0,xmax=700)
    cellMonGroup.defineHistogram('BCID,superCellEt;h_SuperCellEt_vs_BCID',
                                 title='Super Cell ET [MeV] vs BCID ; BCID from train front; %',
                                 type='TH2F', path=sc_hist_path,
                                 xbins = 100, xmin=0,xmax=100,
                                 ybins = 80, ymin=-1000,ymax=1000)
    cellMonGroup.defineHistogram('BCID,superCellEtRef;h_SuperCellEtRef_vs_BCID',
                                 title='Super Cell ET [MeV] vs BCID ; BCID from train front; %',
                                 type='TH2F', path=sc_hist_path,
                                 xbins = 100, xmin=0,xmax=100,
                                 ybins = 80, ymin=-1000,ymax=1000)
 
    cellMonGroup.defineHistogram('resolutionHET;h_SuperCellResolution',
                                 title='Super Cell reconstruction resolution ; %; # entries',
                                 type='TH1F', path=sc_hist_path,
                                 xbins = 70, xmin=-20,xmax=120)
    cellMonGroup.defineHistogram('resolutionPass;h_SuperCellResolutionPass',
                                 title='Super Cell reconstruction resolution for BCIDed ; %; # entries',
                                 type='TH1F', path=sc_hist_path,
                                 xbins = 70, xmin=-20,xmax=120)
    cellMonGroup.defineHistogram('superCellEt,resolution;h_SuperCellResolution_vs_ET',
                                 title='Super Cell reconstruction resolution vs ET ; [MeV]; %',
                                 type='TH2F', path=sc_hist_path,
                                 xbins = 100, xmin=0,xmax=50000,
                                 ybins = 70, ymin=-20,ymax=120)
    cellMonGroup.defineHistogram('superCellEta,resolutionHET;h_SuperCellResolution_vs_eta',
                                 title='Super Cell reconstruction resolution vs #eta ; #eta; %',
                                 type='TH2F', path=sc_hist_path,
                                 xbins = 100, xmin=-5,xmax=5,
                                 ybins = 40, ymin=-20,ymax=20)
    cellMonGroup.defineHistogram('BCID,resolution;h_SuperCellResolution_vs_BCID',
                                 title='Super Cell reconstruction resolution vs BCID ; BCID from train front; %',
                                 type='TH2F', path=sc_hist_path,
                                 xbins = 100, xmin=0,xmax=100,
                                 ybins = 80, ymin=-120,ymax=120)
 
    cellMonGroup.defineHistogram('superCellEtRef,superCellEt;h_SuperCellEtLin',
                                 title='Super Cell E_T Linearity; Ref SC E_T [MeV]; SC E_T [MeV]',
                                 type='TH2F', path=sc_hist_path,
                                 xbins =  100,xmin=0,xmax=50000,
                                 ybins =  100,ymin=0,ymax=50000)
    cellMonGroup.defineHistogram('superCellprovenanceRef,superCellprovenance;h_SuperCellprovenanceLin',
                                 title='Super Cell provenance Linearity; Ref SC bitmask ; SC bitmask',
                                 type='TH2F', path=sc_hist_path,
                                 xbins = 17, xmin=0,xmax=680,
                                 ybins = 17, ymin=0,ymax=680)
    cellMonGroup.defineHistogram('BCID;h_BCID',
                                 title='BCID from the front of the train; BCID ; # entries',
                                 type='TH1F', path=sc_hist_path,
                                 xbins = 120, xmin=0,xmax=120)
    if ( isReco ):
        cellMonGroup.defineHistogram('superCelltimeReco;h_SuperCelltimeReco',
                                 title='Reco Super Cell time [ns]; ns; # entries',
                                 type='TH1F', path=sc_hist_path,
                                 xbins = 100, xmin=-400,xmax=400)
        cellMonGroup.defineHistogram('superCelltimeRef,superCelltimeReco;h_SuperCelltimeLin',
                                 title='Super Cell time Linearity; Ref SC time [ns]; Reco SC time [ns]',
                                 type='TH2F', path=sc_hist_path,
                                 xbins = 100, xmin=-200,xmax=200,
                                 ybins = 100, ymin=-200,ymax=200)
 
 
    partxbins=lArDQGlobals.SuperCell_Variables["etaRange"]["All"]["All"]
    partybins=lArDQGlobals.SuperCell_Variables["phiRange"]["All"]["All"]
    cellMonGroup.defineHistogram('superCellEta,superCellPhi,superCellEtDiff;h_SuperCellCoverage_EtDiff',
                                 title='ET Diff: #phi vs #eta;#eta;#phi',
                                 type='TProfile2D', path=sc_hist_path,
                                 xbins = partxbins, ybins = partybins)
 
 
    sc_hist_path='SC_Layer/'
    if isHLT: sc_hist_path='EXPERT'
    for part in LayerNames:
           partp='('+part+')'
 
           Part = part[:-2]
           if Part == "FCAL": 
               Part = "FCal"
           Side = part[-1]
           Sampling = part[-2]
           if Sampling == "P": 
               Sampling = "0"
           if ( jumpHEC and ("HEC" in Part) and ( "0" not in Sampling ) ):
             continue
           partxbins=lArDQGlobals.SuperCell_Variables["etaRange"][Part][Side][Sampling]
           partybins=lArDQGlobals.SuperCell_Variables["phiRange"][Part][Side][Sampling]
           cellMonGroup.defineHistogram('superCellEta_'+part+',superCellPhi_'+part+',superCellEtDiff_'+part+';h_SuperCellCoverage_EtDiff_'+part,
                                         title='ET Diff '+part+': #phi vs #eta;#eta;#phi',
                                         type='TProfile2D', path=sc_hist_path,
                                         xbins = partxbins, ybins = partybins)
 
           
           cellMonGroup.defineHistogram('superCellEt_'+part+';h_SuperCellEt'+part,
                                        title='Super Cell E_T [MeV] '+partp+'; MeV; # entries',
                                        type='TH1F', path=sc_hist_path,
                                        xbins =  100,xmin=0,xmax=50000)
           cellMonGroup.defineHistogram('superCellEta_'+part+';h_SuperCellEta'+part,
                                        title='Super Cell eta '+partp+'; #eta; # entries',
                                        type='TH1F', path=sc_hist_path,
                                        xbins =  100,xmin=-5,xmax=5)
           cellMonGroup.defineHistogram('superCelltime_'+part+';h_SuperCelltime'+part,
                                        title='Super Cell time [ns] '+partp+'; ns; # entries',
                                        type='TH1F', path=sc_hist_path,
                                        xbins = 100, xmin=-400,xmax=400)
           cellMonGroup.defineHistogram('superCellprovenance_'+part+';h_SuperCellprovenance'+part,
                                        title='Super Cell provenance '+partp+'; bitmask ; # entries',
                                        type='TH1F', path=sc_hist_path,
                                        xbins = 700, xmin=0,xmax=700)
           cellMonGroup.defineHistogram('BCID,superCellEt_'+part+';h_SuperCellET_vs_BCID'+part,
                                        title='Super Cell ET [MeV] vs BCID '+partp+'; BCID from train front; %',
                                        type='TH2F', path=sc_hist_path,
                                        xbins = 100, xmin=0,xmax=100,
                                        ybins = 100, ymin=-1000,ymax=1000)
           cellMonGroup.defineHistogram('BCID,superCellEtRef_'+part+';h_SuperCellRefET_vs_BCID'+part,
                                        title='Super Cell ET [MeV] vs BCID '+partp+'; BCID from train front; %',
                                        type='TH2F', path=sc_hist_path,
                                        xbins = 100, xmin=0,xmax=100,
                                        ybins = 100, ymin=-1000,ymax=1000)
        
           cellMonGroup.defineHistogram('resolutionHET_'+part+';h_SuperCellResolution'+part,
                                        title='Super Cell reconstruction resolution '+partp+'; %; # entries',
                                        type='TH1F', path=sc_hist_path,
                                        xbins = 70, xmin=-20,xmax=120)
           cellMonGroup.defineHistogram('resolutionPass_'+part+';h_SuperCellResolutionPass'+part,
                                        title='Super Cell reconstruction resolution for BCIDed '+partp+'; %; # entries',
                                        type='TH1F', path=sc_hist_path,
                                        xbins = 70, xmin=-20,xmax=120)
           cellMonGroup.defineHistogram('superCellEt_'+part+',resolution_'+part+';h_SuperCellResolution_vs_ET'+part,
                                        title='Super Cell reconstruction resolution vs ET '+partp+'; [MeV]; %',
                                        type='TH2F', path=sc_hist_path,
                                        xbins = 100, xmin=0,xmax=50000,
                                        ybins = 70, ymin=-20,ymax=120)
           cellMonGroup.defineHistogram('superCellEta_'+part+',resolutionHET_'+part+';h_SuperCellResolution_vs_eta'+part,
                                        title='Super Cell reconstruction resolution vs #eta  '+partp+'; #eta; %',
                                        type='TH2F', path=sc_hist_path,
                                        xbins = 100, xmin=-5,xmax=5,
                                        ybins = 40, ymin=-20,ymax=20)
           cellMonGroup.defineHistogram('BCID,resolution_'+part+';h_SuperCellResolution_vs_BCID'+part,
                                        title='Super Cell reconstruction resolution vs BCID '+partp+'; BCID from train front; %',
                                        type='TH2F', path=sc_hist_path,
                                        xbins = 100, xmin=0,xmax=100,
                                        ybins = 80, ymin=-120,ymax=120)
        
           cellMonGroup.defineHistogram('superCellEtRef_'+part+',superCellEt_'+part+';h_SuperCellEtLin'+part,
                                        title='Super Cell E_T Linearity '+partp+'; Ref SC E_T [MeV]; SC E_T [MeV]',
                                        type='TH2F', path=sc_hist_path,
                                        xbins =  100,xmin=0,xmax=50000,
                                        ybins =  100,ymin=0,ymax=50000)
           cellMonGroup.defineHistogram('superCelltimeRef_'+part+',superCelltimeReco_'+part+';h_SuperCelltimeLin'+part,
                                        title='Super Cell time Linearity '+partp+'; Ref SC time [ns]; Reco SC time [ns]',
                                        type='TH2F', path=sc_hist_path,
                                        xbins = 100, xmin=-200,xmax=200,
                                        ybins = 100, ymin=-200,ymax=200)
           cellMonGroup.defineHistogram('superCellprovenanceRef_'+part+',superCellprovenance_'+part+';h_SuperCellprovenanceLin'+part,
                                        title='Super Cell provenance Linearity '+partp+'; Ref SC bitmask ; SC bitmask',
                                        type='TH2F', path=sc_hist_path,
                                        xbins = 17, xmin=0,xmax=680,
                                        ybins = 17, ymin=0,ymax=680)
           if isReco:
              cellMonGroup.defineHistogram('superCelltimeReco_'+part+';h_SuperCelltimeReco'+part,
                                        title='Reco Super Cell time [ns] '+partp+'; ns; # entries',
                                        type='TH1F', path=sc_hist_path,
                                        xbins = 100, xmin=-400,xmax=400)
 
 
    if ( isDatabaseNoise ):
      for part in LayerNames:        
        
        cellMonGroup.defineHistogram('cellEnergy_'+part+';CellEnergy_'+part,
                                        title='Cell Energy in ' +part+';Cell Energy [MeV];Cell Events',
                                        type='TH1F', path=sc_hist_path,
                                        xbins =  100,xmin=0,xmax=50000
                                        )
 
        cellMonGroup.defineHistogram('celleta_'+part+';NCellsActiveVsEta_'+part,
                                           title="No. of Active Cells in #eta for "+part+";cell #eta",
                                           type='TH1F', path=sc_hist_path,
                                           xbins = 100,xmin=-5,xmax=5
                                           )
        
        cellMonGroup.defineHistogram('cellphi_'+part+';NCellsActiveVsPhi_'+part,
                                           title="No. of Active Cells in #phi for "+part+";cell #phi",
                                           type='TH1F', path=sc_hist_path,
                                           xbins =  100,xmin=-5,xmax=5
                                           )
 
        cellMonGroup.defineHistogram('celleta_'+part+',cellphi_'+part+';DatabaseNoiseVsEtaPhi_'+part,
                                           title="Map of Noise Values from the Database vs (#eta,#phi) for "+part+";cell #eta;cell #phi",
                                           weight='cellnoisedb_'+part,
                                           cutmask='doDatabaseNoisePlot',
                                           type='TH2F', path=sc_hist_path, 
                                           xbins =  100,xmin=-5,xmax=5,
                                           ybins =  100,ymin=-5,ymax=5,
                                           merge='weightedAverage')
        
 
 
    return cellMonGroup
 
 
if __name__=='__main__':
 
    # Setup logs
    from AthenaCommon.Constants import DEBUG
    from AthenaCommon.Constants import WARNING
    from AthenaConfiguration.Enums import LHCPeriod, BunchStructureSource
    from AthenaConfiguration.TestDefaults import defaultGeometryTags
    from AthenaCommon.Logging import log
    log.setLevel(DEBUG)
 
    # Set the Athena configuration flags
    from AthenaConfiguration.AllConfigFlags import initConfigFlags
    flags = initConfigFlags()
    # this could be relevant later on
    #from AthenaConfiguration.TestDefaults import defaultTestFiles
    #flags.Input.Files = defaultTestFiles.ESD
    # to test tier0 workflow:
    flags.Input.Files = ['/cvmfs/atlas-nightlies.cern.ch/repo/data/data-art/TrigP1Test/data24_13p6TeV.00475321.physics_EnhancedBias.merge.RAW._lb0231._SFO-11._0001.1_200evt']
 
    flags.Output.HISTFileName = 'LArSuperCellMonOutput.root'
    flags.DQ.enableLumiAccess = True
    flags.DQ.useTrigger = False
    flags.DQ.Environment = 'tier0'
    #flags.DQ.Environment = 'online'
    flags.IOVDb.GlobalTag = "CONDBR2-ES1PA-2022-07"
    flags.Common.isOnline = True
    flags.GeoModel.Run=LHCPeriod.Run3
    flags.Exec.OutputLevel=WARNING
    flags.Beam.BunchStructureSource=BunchStructureSource.FILLPARAMS
    #flags.Beam.BunchStructureSource=BunchStructureSource.Lumi
    flags.GeoModel.AtlasVersion = defaultGeometryTags.RUN3
    import sys
    flags.fillFromArgs(sys.argv[1:])
    flags.lock()
 
    # Initialize configuration object, add accumulator, merge, and run.
    from AthenaConfiguration.MainServicesConfig import MainServicesCfg 
    cfg = MainServicesCfg(flags)
    #storeGateSvc = cfg.getService("StoreGateSvc")
    #storeGateSvc.Dump=True
 
    # in case of tier0 workflow:
    #from CaloRec.CaloRecoConfig import CaloRecoCfg
    #cfg.merge(CaloRecoCfg(flags))
 
    #from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
    #cfg.merge(PoolReadCfg(flags))
 
    if not flags.DQ.Environment == 'online':
       from LumiBlockComps.BunchCrossingCondAlgConfig import BunchCrossingCondAlgCfg
       # FillParamsFolderKey = /TDAQ/OLC/LHC/FILLPARAMS
       cfg.merge(BunchCrossingCondAlgCfg(flags))
 
    cfg.merge(LArSuperCellMonConfig(flags)) 
 
    f=open("LArSuperCellMon.pkl","wb")
    cfg.store(f)
    f.close()
 
    cfg.run()