AtlasGeometryCommon/SubDetectorEnvelopes/python/SubDetectorEnvelopesConfigDb.py

-# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-
-"""
-Configuration database for SubDetectorEnvelopes
-Elmar Ritsch, 27/09/2013
-"""
-
-from AthenaCommon.CfgGetter import addService
-
-# Common tools, services and algorithms used by jobs:
-addService("SubDetectorEnvelopes.SubDetectorEnvelopesConfigLegacy.getEnvelopeDefSvc", "AtlasGeometry_EnvelopeDefSvc")

AtlasGeometryCommon/SubDetectorEnvelopes/python/SubDetectorEnvelopesConfigLegacy.py

-# Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
-
-"""
-SubDetectorEnvelopes configurations for AtlasGeometryCommon
-Elmar Ritsch, 27/09/2013
-"""
-
-def getEnvelopeDefSvcProperties(**kwargs) : 
-    kwargs.setdefault("DBInDetNode"       , 'InDetEnvelope'    )
-    kwargs.setdefault("DBBeamPipeNode"    , 'BeamPipeEnvelope' )
-    kwargs.setdefault("DBCaloNode"        , 'CaloEnvelope'     )
-    kwargs.setdefault("DBMSNode"          , 'MuonEnvelope'     )
-    kwargs.setdefault("DBCavernNode"      , 'CavernEnvelope'   )
-
-    # allow for python-based envelope definitions (see below)
-    #  -> TODO: set this to False once the envelope definitions are tagged in the DDDB
-    kwargs.setdefault("EnableFallback"  , True             )
-
-    # setup fallback BeamPipeEnvelope
-    BeamPipe = Volume()
-    BeamPipe.addRZ(   34.3,   3475.0 )
-    from AthenaCommon.DetFlags import DetFlags
-    if hasattr(DetFlags.simulate, 'HGTD_on') and DetFlags.simulate.HGTD_on():
-        BeamPipe.addRZ(   47.0,   3475.0 )
-        BeamPipe.addRZ(   47.0,   3535.0 )
-        BeamPipe.addRZ(  120.0,   3535.0 )
-    else:
-        BeamPipe.addRZ(  120.0,   3475.0 )
-    BeamPipe.addRZ(  120.0,   4185.0 )
-    BeamPipe.addRZ(   41.0,   4185.0 )
-    BeamPipe.addRZ(   41.0,   6783.0 )
-    BeamPipe.addRZ(   70.0,   6783.0 )
-    BeamPipe.addRZ(   70.0,  12900.0 )
-    BeamPipe.addRZ(  279.0,  12900.0 )
-    BeamPipe.addRZ(  279.0,  18650.0 )
-    BeamPipe.addRZ(  436.0,  18650.0 )
-    BeamPipe.addRZ(  436.0,  22030.0 )
-    BeamPipe.addRZ( 1050.0,  22030.0 )
-    BeamPipe.addRZ( 1050.0,  26046.0 )
-    BeamPipe.addRZ(    0.0,  26046.0 )
-
-    kwargs.setdefault("FallbackBeamPipeR"    ,  BeamPipe.getRs()        )
-    kwargs.setdefault("FallbackBeamPipeZ"    ,  BeamPipe.getZs()        )
-
-
-    # setup fallback IDEnvelope
-    InDet = Volume()
-    InDet.addRZ( 1148.,  3475. )
-    InDet.addRZ(  34.3,  3475. )
-    kwargs.setdefault("FallbackInDetR"  , InDet.getRs()        )
-    kwargs.setdefault("FallbackInDetZ"  , InDet.getZs()        )
-
-
-    # setup fallback CaloEnvelope
-    Calo = Volume()
-    Calo.addRZ( 1148.0,  3475.0 )
-    from AthenaCommon.DetFlags import DetFlags
-    if hasattr(DetFlags.simulate, 'HGTD_on') and DetFlags.simulate.HGTD_on():
-        Calo.addRZ(   47.0,  3475.0 )
-        Calo.addRZ(   47.0,  3535.0 )
-        Calo.addRZ(  120.0,  3535.0 )
-    else:
-        Calo.addRZ(  120.0,  3475.0 )
-    Calo.addRZ(  120.0,  4185.0 )
-    Calo.addRZ(   41.0,  4185.0 )
-    Calo.addRZ(   41.0,  6783.0 )
-    Calo.addRZ(  420.0,  6783.0 )
-    Calo.addRZ(  420.0,  6736.0 )
-    Calo.addRZ( 3800.0,  6736.0 )
-    Calo.addRZ( 3800.0,  6550.0 )
-    Calo.addRZ( 4255.0,  6550.0 )
-
-    kwargs.setdefault("FallbackCaloR"   , Calo.getRs()        )
-    kwargs.setdefault("FallbackCaloZ"   , Calo.getZs()        )
-
-
-    # setup fallback MuonEnvelope
-    Muon = Volume()
-    Muon.addRZ(  4255.0 ,  4000.0 )
-    Muon.addRZ(  4255.0 ,  6550.0 )
-    Muon.addRZ(  3800.0 ,  6550.0 )
-    Muon.addRZ(  3800.0 ,  6736.0 )
-    Muon.addRZ(   420.0 ,  6736.0 )
-    Muon.addRZ(   420.0 ,  6783.0 )
-    Muon.addRZ(    70.0 ,  6783.0 )
-    Muon.addRZ(    70.0 , 12900.0 )
-    Muon.addRZ(   279.0 , 12900.0 )
-    Muon.addRZ(   279.0 , 18650.0 )
-    Muon.addRZ(   436.7 , 18650.0 )
-    Muon.addRZ(   436.7 , 22030.0 )
-    Muon.addRZ(  1050.0 , 22030.0 )
-    Muon.addRZ(  1050.0 , 26046.0 )
-    Muon.addRZ(  1500.0 , 26046.0 )
-    Muon.addRZ(  1500.0 , 23001.0 )
-    Muon.addRZ(  2750.0 , 23001.0 )
-    Muon.addRZ(  2750.0 , 22030.0 )
-    Muon.addRZ( 12650.0 , 22030.0 )
-    Muon.addRZ( 12650.0 , 18650.0 )
-    Muon.addRZ( 13400.0 , 18650.0 )
-    Muon.addRZ( 13400.0 , 12900.0 )
-    Muon.addRZ( 14200.0 , 12900.0 )
-    Muon.addRZ( 14200.0 ,  4000.0 )
-    Muon.addRZ( 13000.0 ,  4000.0 )
-    kwargs.setdefault("FallbackMuonR"   , Muon.getRs()        )
-    kwargs.setdefault("FallbackMuonZ"   , Muon.getZs()        )
-
-
-    # setup fallback CavernEnvelope
-    Cavern = Volume()
-    Cavern.addRZ( 13000.0 , 4000.0 )
-    Cavern.addRZ( 14200.0 , 4000.0 )
-    Cavern.addRZ( 14200.0 , 12900.0 ) # boundary with MS
-    Cavern.addRZ( 13400.0 , 12900.0 ) # boundary with MS
-    Cavern.addRZ( 13400.0 , 18650.0 ) # boundary with MS
-    Cavern.addRZ( 12650.0 , 18650.0 ) # boundary with MS
-    Cavern.addRZ( 12650.0 , 22030.0 ) # boundary with MS
-    Cavern.addRZ(  2750.0 , 22030.0 ) # boundary with MS
-    Cavern.addRZ(  2750.0 , 23001.0 ) # boundary with MS
-    Cavern.addRZ(  1500.0 , 23001.0 ) # boundary with MS
-    Cavern.addRZ(  1500.0 , 26046.0 ) # boundary with MS
-    Cavern.addRZ(     0.0 , 26046.0 ) #
-
-    # the outer dimesions differ between collision and cosmics jobs
-    from AthenaCommon.BeamFlags import jobproperties
-    if jobproperties.Beam.beamType() != 'cosmics':
-      #  -> for collision jobs the 'cavern' envelope is much smaller
-      Cavern.addRZ(      0.0 , 500000.0 ) # z= +500m
-      Cavern.addRZ( 500000.0  , 500000.0 ) # r=  500m
-    else:
-      #  -> for cosmics simulation the 'cavern' envelope spans much further
-      kwargs.setdefault("DBCavernNode"    , 'CavernEnvelopeNONE'   )
-      kwargs.setdefault("EnableFallback"  , True                   )
-      Cavern.addRZ(       0.0 , 3000000.0 ) # z= +3km
-      Cavern.addRZ( 3000000.0 , 3000000.0 ) # r=  3km
-    kwargs.setdefault("FallbackCavernR"   , Cavern.getRs()        )
-    kwargs.setdefault("FallbackCavernZ"   , Cavern.getZs()        )
-    return kwargs
-
-def getEnvelopeDefSvc(name="AtlasGeometry_EnvelopeDefSvc", **kwargs):
-    from SubDetectorEnvelopes.SubDetectorEnvelopesConf import DetDescrDBEnvelopeSvc
-    return DetDescrDBEnvelopeSvc(name, **getEnvelopeDefSvcProperties(**kwargs))
-
-def getEnvelopeDefSvcCfg(flags, name="AtlasGeometry_EnvelopeDefSvc", **kwargs):
-    from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
-    from AthenaConfiguration.ComponentFactory import CompFactory
-    result = ComponentAccumulator()
-    result.addService( CompFactory.DetDescrDBEnvelopeSvc(name, **getEnvelopeDefSvcProperties(**kwargs)), primary=True)
-    return result
-
-# class used for more readable definitions of envelope volumes
-#  -> create new volume boundary definitions
-#  -> return the coordinate vectors in R and Z and VolumeID
-class Volume:
-  # initialize empy
-  def __init__(self):
-    self.r  = [ ]
-    self.z  = [ ]
-
-  def addRZ(self, r, z):
-    self.r  += [ r  ]
-    self.z  += [ z  ]
-
-  def getRs(self):
-    return self.r
-
-  def getZs(self):
-    return self.z

AtlasGeometryCommon/SubDetectorEnvelopes/share/postInclude.showEnvelopesGUI.py

-"""
-Visualize envelopes as defined in EnvelopeDefSvc
-Elmar Ritsch, 13/05/2016
-"""
-
-from AthenaCommon.CfgGetter import getService
-
-
-def draw_envelope(ax, rlist_half, zlist_half, color, label):
-
-    # mirror the given (r,z) values in the x-y plane
-    rlist = rlist_half[:]
-    zlist = zlist_half[:]
-    for r in reversed(rlist_half):
-        rlist.append(r)
-    for z in reversed(zlist_half):
-        zlist.append(-z)
-    rlist.append(rlist[0])
-    zlist.append(zlist[0])
-
-    area = Polygon(zip(zlist, rlist), alpha=0.5, closed=True, color=color, label=label, linewidth=0.)
-    ax.add_patch(area)
-
-
-if __name__ == "__main__":
-    import matplotlib
-    matplotlib.use('Qt4Agg') # use backend that supports GUI (rather than file output only)
-    import matplotlib.pyplot as plt
-    from matplotlib.patches import Polygon
-
-    svc = getService('AtlasGeometry_EnvelopeDefSvc')
-
-    fig, ax = plt.subplots(figsize=(20,10))
-
-    draw_envelope(ax, svc.FallbackBeamPipeR, svc.FallbackBeamPipeZ, 'r', label='BeamPipe')
-    draw_envelope(ax, svc.FallbackInDetR, svc.FallbackInDetZ, 'b', label='InDet')
-    draw_envelope(ax, svc.FallbackCaloR, svc.FallbackCaloZ, 'c', label='Calo')
-    draw_envelope(ax, svc.FallbackMuonR, svc.FallbackMuonZ, 'm', label='MS')
-    draw_envelope(ax, svc.FallbackCavernR, svc.FallbackCavernZ, 'k', label='Cavern')
-
-    ax.autoscale_view()
-    plt.ylabel('r  (mm)')
-    plt.xlabel('z  (mm)')
-    plt.legend()
-    plt.show(block=True)
-    exit(1)

AtlasTest/CITest/Athena.cmake

@@ -132,6 +132,10 @@ atlas_add_citest( DerivationRun3Data_PHYSLITE
    SCRIPT RunWorkflowTests_Run3.py --CI -d -w Derivation --tag data_PHYSLITE --threads 4
    PROPERTIES PROCESSORS 4 )
 
+atlas_add_citest( DerivationRun3Data_Train
+   SCRIPT RunWorkflowTests_Run3.py --CI -d -w Derivation --tag data_PHYS_PHYSLITE --threads 4 --no-output-checks
+   PROPERTIES PROCESSORS 4 )
+
 atlas_add_citest( DerivationRun3MC_PHYS
    SCRIPT RunWorkflowTests_Run3.py --CI -d -w Derivation --tag mc_PHYS --threads 4
    PROPERTIES PROCESSORS 4 )
@@ -140,6 +144,14 @@ atlas_add_citest( DerivationRun3MC_PHYSLITE
    SCRIPT RunWorkflowTests_Run3.py --CI -d -w Derivation --tag mc_PHYSLITE --threads 4
    PROPERTIES PROCESSORS 4 )
 
+atlas_add_citest( DerivationRun3MCAF3_PHYS
+   SCRIPT RunWorkflowTests_Run3.py --CI -d -w Derivation --tag af3_PHYS --threads 4
+   PROPERTIES PROCESSORS 4 )
+
+atlas_add_citest( DerivationRun3MCAF3_PHYSLITE
+   SCRIPT RunWorkflowTests_Run3.py --CI -d -w Derivation --tag af3_PHYSLITE --threads 4
+   PROPERTIES PROCESSORS 4 )
+
 atlas_add_citest( RecoRun4MC_DAODPHYS
    SCRIPT RunWorkflowTests_Run4.py --CI -d -w Derivation -e '--maxEvents 5 --inputAODFile=../../RecoRun4MC/run_q447/myAOD.pool.root' --no-output-checks  # go two levels up as the test runs in a subfolder
    DEPENDS_SUCCESS RecoRun4MC )

AtlasTest/DatabaseTest/IOVDbTestAlg/python/IOVDbTestAlgConfig.py

@@ -46,7 +46,8 @@ def IOVDbTestAlgWriteCfg(flags, registerIOV = False):
 
    from AthenaPoolCnvSvc.PoolCommonConfig import AthenaPoolCnvSvcCfg
    acc.merge( AthenaPoolCnvSvcCfg(flags,
-                                  PoolContainerPrefix = "ROOTTREE:CollectionTree",
+                                  PoolContainerPrefix = "CollectionTree",
+                                  StorageTechnology = "ROOTTREE",
                                   TopLevelContainerName = "<type>",
                                   SubLevelBranchName = "") )
 

Calorimeter/CaloRec/python/CaloConfigFlags.py

@@ -51,7 +51,10 @@ def createCaloConfigFlags():
     ccf.addFlag("Calo.TopoCluster.addCPData",False)
     ccf.addFlag("Calo.TopoCluster.skipWriteList", lambda prevFlags:
                 ["CaloCalTopoClusters", "CaloTopoClusters"] if prevFlags.Reco.HIMode is HIMode.HI else [])
-
+    ccf.addFlag("Calo.TopoCluster.UseGPUCompatibleCriteria", False)
+    
+    ccf.addFlag("Calo.TopoCluster.xtalkInfoDumper", False) # dump raw energy, digits and some calibration for xtalk studies
+    
     #### Cluster correction flags:
     # If true, then reweight cells to prevent double-counting between clusters.
     ccf.addFlag ('Calo.ClusterCorrection.doSlidingWindowCellWeights', False)

Calorimeter/CaloRec/python/CaloRecoConfig.py

@@ -62,7 +62,7 @@ def CaloRecoCfg(flags, clustersname=None):
         #Configure LArDigitsThinner:
         from LArROD.LArDigitThinnerConfig import LArDigitThinnerCfg
         result.merge(LArDigitThinnerCfg(flags))
-
+        
     #Configure MBTSTimeDiff
     #Clients are BackgroundWordFiller and (deprecated?) DQTBackgroundMonTool
     #Consider moving to BackgroundWordFiller config
@@ -74,7 +74,11 @@ def CaloRecoCfg(flags, clustersname=None):
     #Configure AOD Cell-Thinning based on samplings:
     from CaloRec.CaloThinCellsBySamplingAlgConfig import CaloThinCellsBySamplingAlgCfg
     result.merge(CaloThinCellsBySamplingAlgCfg(flags,'StreamAOD', ['TileGap3']))
-    
+        
+    # Optional: AOD Cell, rawCh, digits thinning, based on clusters, for XTalk studies
+    if flags.Calo.TopoCluster.xtalkInfoDumper and not flags.Overlay.DataOverlay:
+        from LArClusterCellDumper.CaloThinCellsInAODAlgConfig import CaloThinCellsInAODAlgCfg
+        result.merge(CaloThinCellsInAODAlgCfg(flags))
 
     return result
 

Calorimeter/CaloRec/python/CaloTopoClusterConfig.py

@@ -151,6 +151,9 @@ def getTopoMoments(flags):
         TopoMoments.MomentsNames += ["ENG_BAD_HV_CELLS"
                                      ,"N_BAD_HV_CELLS"
                                      ]
+    
+    TopoMoments.UseGPUCriteria = flags.Calo.TopoCluster.UseGPUCompatibleCriteria
+    
     result.setPrivateTools(TopoMoments)
     return result
 
@@ -269,13 +272,17 @@ def CaloTopoClusterToolCfg(flags, cellsname):
     
     # note E or AbsE
     #
-    # the following property must be set to TRUE in order to make double
+    # the following properties must be set to TRUE in order to make double
     # sided cuts on the seed and the cluster level
     #
     TopoMaker.SeedCutsInAbsE                 = True
+    TopoMaker.ClusterCutsInAbsEt             = True
     TopoMaker.ClusterEtorAbsEtCut            = 0.0*MeV
     # use 2-gaussian or single gaussian noise for TileCal
     TopoMaker.TwoGaussianNoise = flags.Calo.TopoCluster.doTwoGaussianNoise
+    
+    TopoMaker.UseGPUCriteria = flags.Calo.TopoCluster.UseGPUCompatibleCriteria
+    
     result.setPrivateTools(TopoMaker)
     return result
 
@@ -302,6 +309,9 @@ def CaloTopoClusterSplitterToolCfg(flags):
     TopoSplitter.ShareBorderCells = True
     TopoSplitter.RestrictHECIWandFCalNeighbors  = False
     TopoSplitter.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
+    
+    TopoSplitter.UseGPUCriteria = flags.Calo.TopoCluster.UseGPUCompatibleCriteria
+    
     result.setPrivateTools(TopoSplitter)
     return result
 
@@ -319,7 +329,7 @@ def CaloTopoClusterCfg(flags, cellsname="AllCalo", clustersname=None, clustersna
 
 
     if clustersname=="CaloTopoClusters" and doLCCalib is True: 
-        raise RuntimeError("Inconistent arguments: Name must not be 'CaloTopoClusters' if doLCCalib is True")
+        raise RuntimeError("Inconsistent arguments: Name must not be 'CaloTopoClusters' if doLCCalib is True")
 
     result=ComponentAccumulator()
 
@@ -364,11 +374,9 @@ def CaloTopoClusterCfg(flags, cellsname="AllCalo", clustersname=None, clustersna
     if flags.Calo.TopoCluster.doCalibHitMoments:
         calibHitsMomentsMaker=getTopoCalibMoments(flags)
         CaloTopoCluster.ClusterCorrectionTools += [calibHitsMomentsMaker]
-
-    CaloTopoCluster.ClustersOutputName=clustersname
     
     if doLCCalib:
-        theCaloClusterSnapshot=CaloClusterSnapshot(OutputName=clustersnapname,SetCrossLinks=True)        
+        theCaloClusterSnapshot=CaloClusterSnapshot(OutputName=clustersnapname,SetCrossLinks=True,FinalClusterContainerName=clustersname)        
         CaloTopoCluster.ClusterCorrectionTools += [theCaloClusterSnapshot]
         #if not clustersname:
         CaloTopoCluster.ClusterCorrectionTools += getTopoClusterLocalCalibTools(flags)
@@ -468,7 +476,7 @@ def addSnapshot(topomaker, corrName,contName):
     for t in corrTools:
         newCorrTools.append(t)
         if (t.getName()==corrName):
-            newSnapshot=CompFactory.CaloClusterSnapshot("Snapshot_"+corrName,OutputName=contName)
+            newSnapshot=CompFactory.CaloClusterSnapshot("Snapshot_"+corrName,OutputName=contName,FinalClusterContainerName=topomaker.ClustersOutputName)
             newCorrTools.append(newSnapshot)
             found=True
     if not found:

Calorimeter/CaloRec/share/CaloRecOutputItemList_jobOptions.py

-#**************   ESD list  ************************************************
-from CaloRec.CaloRecFlags import jobproperties
-from AthenaCommon.JobProperties import jobproperties
-from AthenaCommon.Logging import logging
-
-CaloESDList = []
-
-CaloESDList += [ "CaloCellContainer#AllCalo" ]
-
-# add explicitly E4', MBTS cells and trigger output to ESD
-CaloESDList += [ "TileCellContainer#E4prContainer" ]
-CaloESDList += [ "TileCellContainer#MBTSContainer" ]
-CaloESDList += [ "TileTTL1Container#TileTTL1MBTS" ]
-
-# explicitly list of CaloCluster related keys
-CaloClusterItemList=[]
-CaloClusterKeys=[]
-
-from RecExConfig.AutoConfiguration import IsInInputFile
-
-storedFwdTowersInESD = IsInInputFile("xAOD::CaloClusterContainer","CaloCalFwdTopoTowers")
-
-CaloClusterKeys+=["CaloCalTopoClusters"]
-if jobproperties.CaloRecFlags.doCaloTopoTower.get_Value():
-    CaloClusterKeys+=["CaloCalTopoTowers"]
-if jobproperties.CaloRecFlags.doCaloTopoSignal.get_Value():
-    CaloClusterKeys+=["CaloCalTopoSignals"]
-if jobproperties.CaloRecFlags.doCaloFwdTopoTower.get_Value() or storedFwdTowersInESD:
-    CaloClusterKeys+=["CaloCalFwdTopoTowers"]
-
-CaloClusterKeys+=["CombinedCluster"]
-#CaloClusterKeys+=["EMTopoCluster430"]
-CaloClusterKeys+=["EMTopoSW35"]
-
-# reshuffl em 
-#CaloClusterKeys+=["LArClusterEM"]
-
-#CaloClusterKeys+=["LArClusterEM7_11Nocorr"]
-#CaloClusterKeys+=["egClusterCollection"] Move to eg output list
-#CaloClusterKeys+=["LArClusterEMSofte"]
-
-if rec.Commissioning():
-    # CaloClusterKeys += ["LArMuClusterCandidates","CaloTopoClusters","EMTopoCluster420","TileTopoCluster","MuonClusterCollection"]
-    CaloClusterKeys += ["MuonClusterCollection"]    
-
-for theKey in CaloClusterKeys:
-    CaloClusterItemList+=["xAOD::CaloClusterContainer#"+theKey]
-    CaloClusterItemList+=["xAOD::CaloClusterAuxContainer#"+theKey+"Aux."]
-    CaloClusterItemList+=["CaloClusterCellLinkContainer#"+theKey+"_links"]
-
-CaloESDList+=CaloClusterItemList
-logRecoOutputItemList_jobOptions.info('CaloClusterItemList = ')
-printfunc (CaloClusterItemList)
-
-#CaloTowerContainer needed for jet->cell
-#FIXME
-CaloESDList += [ "CaloTowerContainer#CombinedTower" ]
-
-# LAr thinned digits
-CaloESDList += ["LArDigitContainer#LArDigitContainer_Thinned"]
-
-# LAr FEB error summary data 
-CaloESDList += ["LArFebErrorSummary#LArFebErrorSummary"]
-
-# LAr thinned digits for LArMuId
-if jobproperties.Beam.beamType() == "cosmics" :
-    CaloESDList += ["LArDigitContainer#LArDigitContainer_IIC"]
-# LAr thinned digits from EM clusters
-CaloESDList += ["LArDigitContainer#LArDigitContainer_EMClust"]
-
-# LAr noisy Feb/PA summary
-CaloESDList += ["LArNoisyROSummary#LArNoisyROSummary"]
-
-# Tile filtered digits, muons reconstructed offline or inside ROD
-CaloESDList += ["TileDigitsContainer#TileDigitsFlt"]
-CaloESDList += ["TileRawChannelContainer#TileRawChannelFlt"]
-CaloESDList += ["TileMuContainer#TileMuObj"]
-CaloESDList += ["TileL2Container#TileL2Cnt"]
-
-# Tile TMDB output
-CaloESDList += ["TileDigitsContainer#MuRcvDigitsCnt"]
-CaloESDList += ["TileRawChannelContainer#MuRcvRawChCnt"]
-CaloESDList += ["TileMuonReceiverContainer#TileMuRcvCnt"]
-
-# Cosmic muons reconstructed with Tile muon fitter
-if jobproperties.Beam.beamType() == 'cosmics' or jobproperties.Beam.beamType() == 'singlebeam' :
-    CaloESDList +=["TileCosmicMuonContainer#TileCosmicMuonHT","TileCosmicMuonContainer#TileCosmicMuonMF"]
-
-
-#**************   AOD list  ************************************************
-
-#List of AOD moments: (copied from CaloClusterTopoGetter)
-
-AODMoments=[ "SECOND_R" 
-            ,"SECOND_LAMBDA"
-            ,"CENTER_MAG"
-            ,"CENTER_LAMBDA"
-            ,"FIRST_ENG_DENS"
-            ,"ENG_FRAC_MAX" 
-            ,"ISOLATION"
-            ,"ENG_BAD_CELLS"
-            ,"N_BAD_CELLS"
-            ,"BADLARQ_FRAC"
-            ,"ENG_POS"
-            ,"SIGNIFICANCE"
-            ,"AVG_LAR_Q"
-            ,"AVG_TILE_Q"
-            ,"EM_PROBABILITY"
-            ,"BadChannelList"
-            ,"SECOND_TIME"
-            ,"NCELL_SAMPLING" 
-            ]
-
-if jobproperties.CaloRecFlags.doExtendedClusterMoments.get_Value():
-    AODMoments += ["LATERAL"
-                   ,"LONGITUDINAL"
-                   ,"CELL_SIGNIFICANCE"
-                   ,"PTD"
-                   ,"MASS"
-                   ]
-
-    if jobproperties.Rec.doHeavyIon() or jobproperties.Rec.doHIP():
-        AODMoments += ["CELL_SIG_SAMPLING"]
-
-try:
-    from Digitization.DigitizationFlags import digitizationFlags
-    if digitizationFlags.doDigiTruth():
-
-      AODMoments+=["SECOND_R_DigiHSTruth"
-                ,"SECOND_LAMBDA_DigiHSTruth"
-                ,"CENTER_MAG_DigiHSTruth"
-                ,"CENTER_LAMBDA_DigiHSTruth"
-                ,"FIRST_ENG_DENS_DigiHSTruth"
-                ,"ISOLATION_DigiHSTruth"
-                ,"ENG_POS_DigiHSTruth"
-                ,"AVG_LAR_Q_DigiHSTruth"
-                ,"AVG_TILE_Q_DigiHSTruth"
-                ,"ENERGY_DigiHSTruth"
-                ,"ETA_DigiHSTruth"
-                ,"PHI_DigiHSTruth"
-                ]
-      if jobproperties.CaloRecFlags.doExtendedClusterMoments.get_Value():
-            AODMoments+=[ "SIGNIFICANCE_Truth"
-                         ,"CELL_SIGNIFICANCE_Truth"
-                         ,"PTD_Truth"
-                 ]
-            if jobproperties.Rec.doHeavyIon() or jobproperties.Rec.doHIP():
-                AODMoments += ["CELL_SIG_SAMPLING"]
-
-except:
-    log = logging.getLogger('CaloRecOutputItemList')
-    log.info('Unable to import DigitizationFlags in CaloRecOutputItemList_jobOptions. Expected in AthenaP1')
-
-
-CaloAODList = []
-
-# cells 
-CaloAODList+=["CaloCellContainer#AODCellContainer"]
-
-# CaloClusters 
-CaloClusterItemList=[]
-CaloClusterKeys=[]
-
-
-CaloClusterKeys+=["CaloCalTopoClusters"]
-if jobproperties.CaloRecFlags.doCaloTopoTower.get_Value():
-    CaloClusterKeys+=["CaloCalTopoTowers"]
-if jobproperties.CaloRecFlags.doCaloTopoSignal.get_Value():
-    CaloClusterKeys+=["CaloCalTopoSignals"]
-
-
-CaloClusterKeys+=["CombinedCluster"]
-#CaloClusterKeys+=["EMTopoCluster430"]
-CaloClusterKeys+=["EMTopoSW35"]
-
-#CaloClusterKeys+=["egClusterCollection"] Moved to eg output item list
-#CaloClusterKeys+=["LArClusterEMSofte"]
-
-
-
-for theKey in CaloClusterKeys: #Fixme .. Apply this only to TopoClusters?
-     CaloClusterItemList+=["xAOD::CaloClusterContainer#"+theKey]
-     AuxListItem="xAOD::CaloClusterAuxContainer#"+theKey+"Aux"
-     for moment in AODMoments:
-         AuxListItem+="."+moment
-     # for tau clusters
-     if theKey == "CaloCalTopoClusters":
-         AuxListItem += ".CellLink"
-     if len(AODMoments)==0: AuxListItem+="." 
-     CaloClusterItemList+=[AuxListItem]
-
-# write the link only for egClusterColl
-#CaloClusterItemList+=["CaloClusterCellLinkContainer#egClusterCollection_links"]
-
-# for tau clusters (CaloCalTopoClusters within 0.2 of the tau axis)
-CaloClusterItemList += ["CaloClusterCellLinkContainer#CaloCalTopoClusters_links"]
-
-#CaloCalFwdTopoClusters are also clusters but with a dedicated sliming:
-if jobproperties.CaloRecFlags.doCaloFwdTopoTower.get_Value() or storedFwdTowersInESD:
-    theKey="CaloCalFwdTopoTowers"
-    CaloClusterItemList+=["xAOD::CaloClusterContainer#"+theKey]
-    AuxListItem="xAOD::CaloClusterAuxContainer#"+theKey+"Aux"
-    for moment in ("CENTER_LAMBDA", 
-                   #"CENTER_MAG",
-                   "LONGITUDINAL",
-                   #"FIRST_ENG_DENS",
-                   #"ENG_FRAC_MAX",
-                   "ENG_FRAC_EM",
-                   #"PTD",
-                   "SIGNIFICANCE",
-                   "ENG_POS"):
-         AuxListItem+="."+moment
-    CaloClusterItemList+=[AuxListItem]
-
-CaloAODList+=CaloClusterItemList
-
-# E4' cells
-CaloAODList+=["TileCellContainer#E4prContainer"]
-
-# MBTS cells
-CaloAODList+=["TileCellContainer#MBTSContainer"]
-
-# muons in Tile
-CaloAODList+=["TileMuContainer#TileMuObj"]
-
-# LAr noisy Feb/PA summary
-CaloAODList +=  ["LArNoisyROSummary#LArNoisyROSummary"]
-

Calorimeter/CaloRec/share/CaloTopoCluster_jobOptions.py

-#
-# $Id: CaloTopoCluster_jobOptions.py,v 1.48 2008-09-12 09:08:56 menke Exp $
-#
-# File: CaloRec/share/CaloTopoCluster_jobOptions.py
-# Created: June 2007, S.Menke
-# Purpose: Define default calibrated topo cluster algo and corrections
-#
-
-try:
-    from CaloRec.CaloClusterTopoGetter import CaloClusterTopoGetter
-    CaloClusterTopoGetter()
-    #from CaloRec.CaloCell2ClusterMapperGetters import CaloCell2TopoClusterMapperGetter
-    #CaloCell2TopoClusterMapperGetter()
-except Exception:
-    from AthenaCommon.Resilience import treatException
-    treatException("Problem with CaloTopoCluster. Switched off")
-

Calorimeter/CaloRec/src/CaloClusterSnapshot.cxx

 /*
-  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
 #include "CaloUtils/CaloClusterStoreHelper.h"
@@ -15,13 +15,13 @@ CaloClusterSnapshot::CaloClusterSnapshot(const std::string& type,
 				   const std::string& name,
 				   const IInterface* parent):
   AthAlgTool(type, name, parent),
-  m_outputKey(""),
-  m_finalContName(nullptr)
+  m_outputKey("")
 { 
   declareInterface<CaloClusterCollectionProcessor> (this);
   declareProperty("OutputName",m_outputKey);
   declareProperty("CellLinkName",m_cellLinkOutputKey);
   declareProperty("SetCrossLinks",m_setCrossLinks=false);
+  declareProperty("FinalClusterContainerName", m_finalContName);
   
 }
 
@@ -32,15 +32,6 @@ CaloClusterSnapshot::~CaloClusterSnapshot()
 = default;
 
 StatusCode CaloClusterSnapshot::initialize() {
-
-  if (m_setCrossLinks) {
-    const CaloClusterMaker* parentAlgo=dynamic_cast<const CaloClusterMaker*>(parent());
-    if (!parentAlgo) {
-      ATH_MSG_ERROR( "Configuration problem. Parent is not CaloClusterMaker. Can't set ElementLink to final cluster."  );
-      return StatusCode::FAILURE;
-    }
-    m_finalContName=&(parentAlgo->getOutputContainerName());
-  }
   ATH_CHECK(m_outputKey.initialize());
   if (m_cellLinkOutputKey.key().empty()) {
     m_cellLinkOutputKey = m_outputKey.key() + "_links";
@@ -78,15 +69,18 @@ CaloClusterSnapshot::execute(const EventContext& ctx,
     }
 
     //From snapshot to final cluster
-    if (m_finalContName) {
-       ClusterLink_t finalEL (*m_finalContName, 0, ctx);
-       for (size_t i=0;i<nClusters;++i) {
-	 (*outputColl)[i]->setSisterClusterLink(ClusterLink_t(finalEL, i));
-	 //	 std::cout << "Setting link to " << *m_finalContName << ", index "<< i <<std::endl;
+    if (m_setCrossLinks) {
+       ClusterLink_t finalEL (m_finalContName, 0, ctx);
+       if (finalEL.isValid()) {
+	 for (size_t i=0;i<nClusters;++i) {
+	   (*outputColl)[i]->setSisterClusterLink(ClusterLink_t(finalEL, i));
+	   //	 std::cout << "Setting link to " << m_finalContName << ", index "<< i <<std::endl;
+	 }
+       }
+       else {
+	 ATH_MSG_DEBUG("Can't set element link from snapshot to final cluster, likely mismatch in the FinalClusterContainerName");	 
        }
     }
-    else
-      ATH_MSG_DEBUG("Can't set element link from snapshot to final cluster, see warning above");
   }
 
   

Calorimeter/CaloRec/src/CaloClusterSnapshot.h

 /*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 */
 
 //Dear emacs, this is -*-c++-*-
@@ -31,7 +31,7 @@ class CaloClusterSnapshot : public AthAlgTool, virtual public CaloClusterCollect
 
   bool m_setCrossLinks;
 
-  const std::string* m_finalContName;
+  std::string m_finalContName;
   
 };
 

Calorimeter/CaloRec/src/CaloTopoClusterMaker.cxx

@@ -74,6 +74,7 @@ CaloTopoClusterMaker::CaloTopoClusterMaker(const std::string& type,
     m_seedCutsInAbsE                   (false),
     m_neighborCutsInAbsE               (true),
     m_cellCutsInAbsE                   (true),
+    m_clusterCutsInAbsE                (true),
     m_clusterEtorAbsEtCut              (    0.*MeV),
     m_twogaussiannoise                 (false),
     m_treatL1PredictedCellsAsGood      (true),
@@ -162,6 +163,9 @@ CaloTopoClusterMaker::CaloTopoClusterMaker(const std::string& type,
   // Restrict PS Neighbors
   declareProperty("RestrictPSNeighbors",m_restrictPSNeighbors);
 
+  //Cluster cuts are in E_t or Abs E_t 
+  declareProperty("ClusterCutsInAbsEt",m_clusterCutsInAbsE);
+  
   // Cluster E_t or Abs E_t cut
   declareProperty("ClusterEtorAbsEtCut",m_clusterEtorAbsEtCut);
 
@@ -326,7 +330,7 @@ StatusCode CaloTopoClusterMaker::initialize()
   
   ATH_CHECK(m_noiseCDOKey.initialize());
 
-  ATH_MSG_INFO( (m_seedCutsInAbsE?"ClusterAbsEtCut= ":"ClusterEtCut= ")
+  ATH_MSG_INFO( (m_clusterCutsInAbsE?"ClusterAbsEtCut= ":"ClusterEtCut= ")
                 << m_clusterEtorAbsEtCut << " MeV"  );
 
   m_hashMin = 999999;
@@ -654,7 +658,7 @@ CaloTopoClusterMaker::execute(const EventContext& ctx,
 	myCluster->addCell(iCell,1.);
       }
       const float cl_et = myCluster->et();
-      if ( (m_seedCutsInAbsE ? std::abs(cl_et) : cl_et) > m_clusterEtorAbsEtCut ) {
+      if ( (m_clusterCutsInAbsE ? std::abs(cl_et) : cl_et) > m_clusterEtorAbsEtCut ) {
 	sortClusters.push_back(std::move(myCluster));
       } 
     }

Calorimeter/CaloRec/src/CaloTopoClusterMaker.h

@@ -242,6 +242,14 @@ private:
    * on energy and transverse energy instead.  */
   bool m_cellCutsInAbsE;                         
                                                  
+  /**
+   * @brief if set to true final cluster cuts are on \f$|E|_\perp\f$. 
+   *
+   * The final cluster cuts will be on absolute transverse energy
+   * if this is set to true. If set to false the cuts will be on
+   * transverse energy instead.  */
+  bool m_clusterCutsInAbsE;
+  
   /**
    * @brief \f$E_\perp\f$ cut on the final cluster. 
    *

Calorimeter/CaloRecGPU/CMakeLists.txt

@@ -20,7 +20,7 @@ find_package( Boost COMPONENTS chrono )
 atlas_add_library( CaloRecGPULib
    CaloRecGPU/*.h src/*.cxx src/*.cu src/*.h
    PUBLIC_HEADERS CaloRecGPU
-   LINK_LIBRARIES AthenaBaseComps CaloEvent CaloInterfaceLib CxxUtils GaudiKernel TileEvent TrigT2CaloCommonLib
+   LINK_LIBRARIES AthenaBaseComps CaloEvent CaloInterfaceLib CxxUtils GaudiKernel TileEvent TrigT2CaloCommonLib xAODTrigCalo
    PRIVATE_INCLUDE_DIRS ${Boost_INCLUDE_DIRS} )
 
 atlas_add_component( CaloRecGPU

Calorimeter/CaloRecGPU/CaloRecGPU/EventInfoDefinitions.h

@@ -275,7 +275,7 @@ namespace CaloRecGPU
           if (qp.provenance() & mask)
             {
               const float this_time = time[cell];
-              if (fabsf(this_time) < threshold)
+              if (fabsf(this_time) >= threshold)
                 {
                   if (use_crosstalk)
                     {

Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h

@@ -109,16 +109,15 @@ namespace CaloRecGPU
     {
       void * ptr = nullptr;
 
-
-      operator void * () const
+      template <class T = const void>
+      constexpr operator T * () const
       {
-        return ptr;
+        return (T *) ptr;
       }
-
-      template <class T>
-      operator T * () const
+      
+      constexpr operator bool() const
       {
-        return (T *) ptr;
+        return ptr != nullptr;
       }
 
       template <class T>
@@ -310,7 +309,7 @@ namespace CaloRecGPU
   inline constexpr T pi = std::numbers::pi_v<T>;
 
   template <class T>
-  inline constexpr T sqrt2 = std::numbers::sqrt2_v<T>
+  inline constexpr T sqrt2 = std::numbers::sqrt2_v<T>;
 #else
   template <class T>
   inline constexpr T pi = T(3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624L);

Calorimeter/CaloRecGPU/python/CaloRecGPUFlags.py

@@ -17,28 +17,93 @@ def createFlagsCaloRecGPU():
     """
 
     flags = AthConfigFlags()
+    flags.addFlagsCategory('CaloRecGPU.GlobalFlags', _createGlobalFlagsCaloRecGPU, prefix=True)
     flags.addFlagsCategory('CaloRecGPU.Default', _createDefaultSubFlagsCaloRecGPU, prefix=True)
-    flags.addFlagsCategory('CaloRecGPU.LocalCalibration', _createLCSubFlagsCaloRec, prefix=True)
-    flags.addFlagsCategory('CaloRecGPU.HLT', _createHLTSubFlagsCaloRec, prefix=True)
+    flags.addFlagsCategory('Trigger.CaloRecGPU.Default', _createTriggerSubFlagsCaloRecGPU, prefix=True)
+    #flags.addFlagsCategory('Trigger.CaloRecGPU.LC', _createTriggerSubFlagsCaloRecGPUWithLC, prefix=True)
+    flags.addFlagsCategory('CaloRecGPU.ActiveConfig', _createActiveConfigFlagsCaloRecGPU, prefix=True)
+    return flags
+    
+def _createGlobalFlagsCaloRecGPU():
+    """
+    Generate top-level flags for CaloRecGPU that are meant to be global
+    and independent of the ActiveConfig.
+    """
+    flags = AthConfigFlags()
+    
+    flags.addFlag('UseCaloRecGPU', False)
+    flags.addFlag('UseCPUToolsInstead', False)
+    
+    return flags
+    
+def _createActiveConfigFlagsCaloRecGPU():
+    """
+    Generate top-level flags for CaloRecGPU that are meant to be global
+    and independent of the ActiveConfig.
+    """
+    flags = AthConfigFlags()
+    
+    flags.addFlag('MeasureTimes', False)
+    
     return flags
 
-def _createLCSubFlagsCaloRec():
+def _createTriggerSubFlagsCaloRecGPU():
     """
-    Generate CaloRecGPU flags for a particular flag subdomain
+    Generate CaloRecGPU flags for a particular flag subdomain (the trigger in this case)
  
-    Calls the function to generate a new set of default CaloRecGPU flags, and then updates the defaults as required for this specific subdomain "LocalCalibration".
-    This _createLCSubFlagsCaloRec is provided as an example of a subdomain with an updated default value for the ClustersOutputName flag. 
+    Calls the function to generate a new set of default CaloRecGPU flags, and then updates the defaults as required for this specific subdomain.
     """
     flags = _createDefaultSubFlagsCaloRecGPU()
-    flags.ClustersOutputName = "CaloTopoClusters"
-    return flags 
-
-def _createHLTSubFlagsCaloRec():
-    flags = _createDefaultSubFlagsCaloRecGPU()
-    flags.CellsName = "CaloCellsFS"
-    flags.ClustersOutputName = "HLT_TopoCaloClustersFS"
+    flags.UseOriginalCriteria = False
+    flags.GrowingRestrictPSNeighbors = False
+    flags.GPUSplittingRestrictPSNeighbors = False
+    flags.doTimeCut = lambda prevFlags: prevFlags.Trigger.Calo.TopoCluster.doTimeCut
+    flags.extendTimeCut = lambda prevFlags: prevFlags.Trigger.Calo.TopoCluster.extendTimeCut
+    flags.useUpperLimitForTimeCut = lambda prevFlags: prevFlags.Trigger.Calo.TopoCluster.useUpperLimitForTimeCut
+    flags.timeCutUpperLimit = lambda prevFlags: prevFlags.Trigger.Calo.TopoCluster.timeCutUpperLimit
+    flags.MomentsToCalculate = ['FIRST_PHI',
+                                'FIRST_ETA',
+                                'SECOND_R' ,
+                                'SECOND_LAMBDA',
+                                'DELTA_PHI',
+                                'DELTA_THETA',
+                                'DELTA_ALPHA' ,
+                                'CENTER_X',
+                                'CENTER_Y',
+                                'CENTER_Z',
+                                'CENTER_MAG',
+                                'CENTER_LAMBDA',
+                                'LATERAL',
+                                'LONGITUDINAL',
+                                'FIRST_ENG_DENS',
+                                'ENG_FRAC_EM',
+                                'ENG_FRAC_MAX',
+                                'ENG_FRAC_CORE' ,
+                                'FIRST_ENG_DENS',
+                                'SECOND_ENG_DENS',
+                                'ISOLATION',
+                                'ENG_BAD_CELLS',
+                                'N_BAD_CELLS',
+                                'N_BAD_CELLS_CORR',
+                                'BAD_CELLS_CORR_E',
+                                'BADLARQ_FRAC',
+                                'ENG_POS',
+                                'SIGNIFICANCE',
+                                'CELL_SIGNIFICANCE',
+                                'CELL_SIG_SAMPLING',
+                                'AVG_LAR_Q',
+                                'AVG_TILE_Q'
+                                ]
+    flags.MomentsUseAbsEnergy = False
+    flags.doTopoClusterLocalCalib = False
     return flags
 
+
+#def _createTriggerSubFlagsCaloRecGPUWithLC():
+#    flags = _createTriggerSubFlagsCaloRecGPU()
+#    flags.doTopoClusterLocalCalib = True
+#    return flags
+
 def _createDefaultSubFlagsCaloRecGPU():
     """
     Generate a new default CaloRecGPU flags domain
@@ -47,42 +112,75 @@ def _createDefaultSubFlagsCaloRecGPU():
     Sets the most generic default parameters or default parameter lambda function logic for each flag, this can be overridden if needed by specific subdomains. 
     """
     flags = AthConfigFlags()
-    flags.addFlag('MeasureTimes', True)
-    flags.addFlag('CellsName', "AllCalo")
-    flags.addFlag('ClustersOutputName', "CaloCalTopoClusters")
+    
+    #GPU SPECIFIC FLAGS WITH NO CPU EQUIVALENT
+    
+    flags.addFlag('MeasureTimes', False)
+    #Output timing measurements,
+    #including the breakdown
+    #within the algorithms themselves.
+    
     flags.addFlag('FillMissingCells', False)
     flags.addFlag('MissingCellsToFill', [])
+    
+    flags.addFlag('NumPreAllocatedDataHolders', 0)
+    
+    flags.addFlag('UseOriginalCriteria', lambda prevFlags: not prevFlags.Calo.TopoCluster.UseGPUCompatibleCriteria)
+    #Restore instantiated CPU tools to their original, GPU-disagreeing criteria.
+    
+    #FLAGS THAT ENCAPSULATE CPU CONFIGURATION OPTIONS THAT ARE NOT FLAGS IN CPU CONFIGURATION
+    #(Most of them aren't strictly necessary and could be hard-coded in the Cfg,
+    # but CPU vs GPU testing benefits from having all this granularity.)
+    
+    flags.addFlag('SeedThreshold',4.0)
+    flags.addFlag('GrowThreshold',2.0)
+    flags.addFlag('TermThreshold',0.0)
+    flags.addFlag('UseAbsSeedThreshold',True)
+    flags.addFlag('UseAbsGrowThreshold',True)
+    flags.addFlag('UseAbsTermThreshold',True)
     flags.addFlag('ClusterSize', 'Topo_420')
-    flags.addFlag('ClusterEtorAbsEtCut', -1e-16*MeV)
-    flags.addFlag('CalorimeterNames', ["LAREM", "LARHEC", "LARFCAL", "TILE"])
-    flags.addFlag('TopoClusterSeedSamplingNames', ["PreSamplerB", "EMB1", "EMB2", "EMB3", "PreSamplerE", "EME1", "EME2", "EME3", "HEC0", "HEC1","HEC2", "HEC3", "TileBar0", "TileBar1", "TileBar2", "TileExt0", "TileExt1", "TileExt2", "TileGap1", "TileGap2", "TileGap3", "FCAL0", "FCAL1", "FCAL2"])
-    flags.addFlag('TopoClusterSNRSeedThreshold',4.0)
-    flags.addFlag('TopoClusterSNRGrowThreshold',2.0)
-    flags.addFlag('TopoClusterSNRCellThreshold',0.0)
-    flags.addFlag('TopoClusterSeedCutsInAbsE',True)
-    flags.addFlag('TopoClusterNeighborCutsInAbsE',True)
-    flags.addFlag('TopoClusterCellCutsInAbsE',True)
-    flags.addFlag('NeighborOption',"super3D")
-    flags.addFlag('RestrictHECIWandFCalNeighbors',False)
-    flags.addFlag('RestrictPSNeighbors',True)
-    flags.addFlag('AlsoRestrictPSOnGPUSplitter',False)
-    flags.addFlag('TwoGaussianNoise', lambda prevFlags: prevFlags.Calo.TopoCluster.doTwoGaussianNoise)
-    flags.addFlag('SeedCutsInT', lambda prevFlags: prevFlags.Calo.TopoCluster.doTimeCut)
-    flags.addFlag('CutOOTseed', lambda prevFlags: prevFlags.Calo.TopoCluster.extendTimeCut and prevFlags.Calo.TopoCluster.doTimeCut)
-    flags.addFlag('UseTimeCutUpperLimit', lambda prevFlags: prevFlags.Calo.TopoCluster.useUpperLimitForTimeCut)
-    flags.addFlag('TimeCutUpperLimit',20.0)
-    flags.addFlag('TreatL1PredictedCellsAsGood',True)
-    flags.addFlag('UseEM2CrossTalk',False)
-    flags.addFlag('CrossTalkDeltaT',15*ns)
-    flags.addFlag('SeedThresholdOnTAbs',12.5*ns)
-    flags.addFlag('SplitterNumberOfCellsCut',4)
-    flags.addFlag('SplitterEnergyCut',500*MeV)
-    flags.addFlag('SplitterSamplingNames',["EMB2", "EMB3", "EME2", "EME3", "FCAL0"])
-    flags.addFlag('SplitterSecondarySamplingNames',["EMB1","EME1", "TileBar0","TileBar1","TileBar2", "TileExt0","TileExt1","TileExt2", "HEC0","HEC1","HEC2","HEC3", "FCAL1","FCAL2"])
-    flags.addFlag('SplitterShareBorderCells',True)
-    flags.addFlag('EMShowerScale',5.0*cm)
-    flags.addFlag('SplitterUseNegativeClusters', lambda prevFlags: prevFlags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute)
-    flags.addFlag('UseAbsEnergyMoments', lambda prevFlags: prevFlags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute)
+    #There is the "getClusterSize" function on the C++ code
+    #that tries to guess based on the thresholds,
+    #we could either rely on that or do it also in Python?
+    
+    flags.addFlag('GrowingCalorimeterNames', ["LAREM", "LARHEC", "LARFCAL", "TILE"])
+    flags.addFlag('GrowingSeedSamplingNames', ["PreSamplerB", "EMB1", "EMB2", "EMB3", "PreSamplerE", "EME1", "EME2", "EME3", "HEC0", "HEC1","HEC2", "HEC3", "TileBar0", "TileBar1", "TileBar2", "TileExt0", "TileExt1", "TileExt2", "TileGap1", "TileGap2", "TileGap3", "FCAL0", "FCAL1", "FCAL2"])
+    flags.addFlag('GrowingNeighborOption',"super3D")
+    flags.addFlag('GrowingRestrictHECIWandFCalNeighbors',False)
+    flags.addFlag('GrowingRestrictPSNeighbors',True)
+    flags.addFlag('GrowingTreatL1PredictedCellsAsGood',True)
+    
+    flags.addFlag('GrowingTimeCutSeedThreshold',12.5*ns)
+    
+    flags.addFlag('PostGrowingClusterCutClustersInAbsEt', True)
+    flags.addFlag('PostGrowingClusterEnergyCut', -1e-16*MeV)
+    #CPU has default 0, but since the comparison is not inclusive,
+    #it's better if we consider a negative value so that both CPU and GPU
+    #agree 100% when doing the comparison in absolute energy,
+    #because otherwise floating point making clusters have zero energy 
+    #in one implementation and a tiny non-zero energy on another
+    #would mean different cuts, thus different cluster numbers,
+    #thus different splitting, and so on.
+    #This problem will remain for non-zero energy cuts,
+    #like other floating point agreement issues elsewhere.
+    
+    
+    flags.addFlag('SplittingNeighborOption',"super3D")
+    flags.addFlag('SplittingRestrictHECIWandFCalNeighbors',False)
+    flags.addFlag('SplittingTreatL1PredictedCellsAsGood',True)
+    
+    flags.addFlag('SplittingNumberOfCellsCut', 4)
+    flags.addFlag('SplittingEnergyCut', 500 * MeV)
+    flags.addFlag('SplittingSamplingNames',["EMB2", "EMB3", "EME2", "EME3", "FCAL0"])
+    flags.addFlag('SplittingSecondarySamplingNames',["EMB1","EME1", "TileBar0","TileBar1","TileBar2", "TileExt0","TileExt1","TileExt2", "HEC0","HEC1","HEC2","HEC3", "FCAL1","FCAL2"])
+    flags.addFlag('SplittingShareBorderCells',True)
+    flags.addFlag('SplittingEMShowerScale',5.0*cm)
+    flags.addFlag('SplittingUseNegativeClusters', lambda prevFlags: prevFlags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute)
+    
+    flags.addFlag('GPUSplittingRestrictPSNeighbors',False)
+    #The CPU code does not apply this restriction, mostly for testing purposes
+    
+    flags.addFlag('MomentsUseAbsEnergy', lambda prevFlags: prevFlags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute)
     flags.addFlag('MomentsMaxAxisAngle',20*deg)
     flags.addFlag('MomentsMinBadLArQuality',4000)
     MomentsToCalculateOnline=[ "FIRST_PHI",
@@ -124,11 +222,41 @@ def _createDefaultSubFlagsCaloRecGPU():
     flags.addFlag('MomentsToCalculate', lambda prevFlags: MomentsToCalculateOnline if prevFlags.Common.isOnline else MomentsToCalculateOffline )
     flags.addFlag('MomentsMinRLateral',4*cm)
     flags.addFlag('MomentsMinLLongitudinal',10*cm)
-    flags.addFlag('OutputCountsToFile',False)
-    flags.addFlag('OutputClustersToFile',True)
-    flags.addFlag('DoMonitoring',False)
-    flags.addFlag('NumPreAllocatedDataHolders', lambda prevFlags: max(prevFlags.Concurrency.NumThreads, 1)) # Avoids 0 when running serial athena
-    #If True, use the original criteria
-    #(which disagree with the GPU implementation)
-    flags.addFlag('UseOriginalCriteria',False)
+    
+    
+    #FLAGS THAT MIRROR CPU OPTIONS
+    
+    flags.addFlag('doTwoGaussianNoise', lambda prevFlags: prevFlags.Calo.TopoCluster.doTwoGaussianNoise)
+    
+    
+    flags.addFlag('doTimeCut', lambda prevFlags: prevFlags.Calo.TopoCluster.doTimeCut)
+    flags.addFlag('extendTimeCut', lambda prevFlags: prevFlags.Calo.TopoCluster.extendTimeCut)
+    
+    flags.addFlag('useUpperLimitForTimeCut', lambda prevFlags: prevFlags.Calo.TopoCluster.useUpperLimitForTimeCut)
+    
+    flags.addFlag('timeCutUpperLimit', lambda prevFlags: prevFlags.Calo.TopoCluster.timeCutUpperLimit)
+    
+    flags.addFlag('xtalkEM2', lambda prevFlags: prevFlags.Calo.TopoCluster.xtalkEM2)
+    flags.addFlag('xtalkEM2D', lambda prevFlags: prevFlags.Calo.TopoCluster.xtalkEM2D)
+    flags.addFlag('xtalkEM2n', lambda prevFlags: prevFlags.Calo.TopoCluster.xtalkEM2n)
+    flags.addFlag('xtalkEM3', lambda prevFlags: prevFlags.Calo.TopoCluster.xtalkEM3)
+    flags.addFlag('xtalkEMEta', lambda prevFlags: prevFlags.Calo.TopoCluster.xtalkEMEta)
+    flags.addFlag('xtalkDeltaT', lambda prevFlags: prevFlags.Calo.TopoCluster.xtalkDeltaT)
+    flags.addFlag('xtalk2Eratio1', lambda prevFlags: prevFlags.Calo.TopoCluster.xtalk2Eratio1)
+    flags.addFlag('xtalk2Eratio2', lambda prevFlags: prevFlags.Calo.TopoCluster.xtalk2Eratio2)
+    flags.addFlag('xtalk3Eratio', lambda prevFlags: prevFlags.Calo.TopoCluster.xtalk3Eratio)
+    flags.addFlag('xtalkEtaEratio', lambda prevFlags: prevFlags.Calo.TopoCluster.xtalkEtaEratio)
+    flags.addFlag('xtalk2DEratio', lambda prevFlags: prevFlags.Calo.TopoCluster.xtalk2DEratio)
+    
+    flags.addFlag('doTopoClusterLocalCalib', lambda prevFlags: prevFlags.Calo.TopoCluster.doTopoClusterLocalCalib)
+    flags.addFlag('doCalibHitMoments', lambda prevFlags: prevFlags.Calo.TopoCluster.doCalibHitMoments)
+    
+    flags.addFlag('skipWriteList', lambda prevFlags: prevFlags.Calo.TopoCluster.skipWriteList)
+    flags.addFlag('writeExtendedClusterMoments', lambda prevFlags: prevFlags.Calo.TopoCluster.writeExtendedClusterMoments)
+    flags.addFlag('writeCalibHitClusterMoments', lambda prevFlags: prevFlags.Calo.TopoCluster.writeCalibHitClusterMoments)
+    
+    flags.addFlag('addCalibrationHitDecoration', lambda prevFlags: prevFlags.Calo.TopoCluster.addCalibrationHitDecoration)
+    flags.addFlag('CalibrationHitDecorationName', lambda prevFlags: prevFlags.Calo.TopoCluster.CalibrationHitDecorationName)
+    flags.addFlag('addCPData', lambda prevFlags: prevFlags.Calo.TopoCluster.addCPData)
+    
     return flags