Merge branch 'ISFtestrun2' into 'master'

Teach ISF new config test to run

See merge request atlas/athena!35967

Simulation/FastShower/FastCaloSim/python/FastCaloSimFactoryNew.py

@@ -62,14 +62,14 @@ def FastShowerCellBuilderToolBaseCfg(flags, name, **kwargs):
     #theFastShowerCellBuilderTool.Invisibles=[12, 14, 16, 1000022]
     #########################################################################################################
 
-    acc.setPrivateTools(CompFactory.FastShowerCellBuilderTool(name, **kwargs))
+    acc.addPublicTool(CompFactory.FastShowerCellBuilderTool(name, **kwargs))
     return acc
 
 
 def FastShowerCellBuilderToolCfg(flags, **kwargs):
 
     acc = FastShowerCellBuilderToolBaseCfg(flags, name="ISF_FastShowerCellBuilderTool", **kwargs)
-    tool = acc.popPrivateTools()
+    tool = acc.getPublicTool("ISF_FastShowerCellBuilderTool")
 
     try:
         ParticleParametrizationFileName = tool.ParticleParametrizationFileName
@@ -87,5 +87,4 @@ def FastShowerCellBuilderToolCfg(flags, **kwargs):
     mlog.verbose("all values:")
     mlog.verbose(tool)
 
-    acc.setPrivateTools(tool)
     return acc

Simulation/G4Atlas/G4AtlasApps/python/SimConfigFlags.py

@@ -77,11 +77,31 @@ def createSimConfigFlags():
 
     # For ISF
     scf.addFlag("Sim.ISFRun",False)
-    scf.addFlag("Sim.ISF.HITSMergingRequired", {'ID':True, 'CALO':True, 'MUON':True})
     scf.addFlag("Sim.ISF.Simulator", "ATLFASTII")
     scf.addFlag("Sim.ISF.DoTimeMonitoring", True) # bool: run time monitoring
     scf.addFlag("Sim.ISF.DoMemoryMonitoring", True) # bool: run time monitoring
     scf.addFlag("Sim.ISF.ValidationMode", False) # bool: run ISF internal validation checks
+    
+    def decideHITSMerging(prevFlags):
+        simstr = prevFlags.Sim.ISF.Simulator
+        if simstr.endswith("MT"):
+            simstr = simstr[:-2]
+        # Further specialsation possible in future
+        if simstr in ("FullG4", "PassBackG4"):
+            doID = False
+            doCALO = False
+            doMUON = False
+        elif simstr in ("ATLFASTII", "G4FastCalo"):
+            doID = False
+            doCALO = True
+            doMUON = False
+        else:
+            doID = True
+            doCALO = True
+            doMUON = True
+        return {"ID": doID, "CALO": doCALO, "MUON": doMUON}
+
+    scf.addFlag("Sim.ISF.HITSMergingRequired", decideHITSMerging)
 
     scf.addFlag("Sim.FastCalo.ParamsInputFilename", "FastCaloSim/MC16/TFCSparam_v011.root") # filename of the input parametrizations file
     scf.addFlag("Sim.FastCalo.CaloCellsName", "AllCalo") # StoreGate collection name for FastCaloSim hits

Simulation/G4Atlas/G4AtlasServices/python/G4AtlasUserActionConfigNew.py

@@ -22,9 +22,11 @@ from ISF_Geant4CommonTools.ISF_Geant4CommonToolsConfigNew import EntryLayerToolC
 def FullG4TrackProcessorUserActionToolCfg(flags, name="FullG4TrackProcessorUserActionTool", **kwargs):
     result = ComponentAccumulator()
     if flags.Sim.ISF.Simulator in ["FullG4MT"]:
-        tool = result.popToolsAndMerge(EntryLayerToolMTCfg(flags))
+        result.merge(EntryLayerToolMTCfg(flags))
+        tool = result.getPublicTool("ISF_EntryLayerToolMT")
     else:
-        tool = result.popToolsAndMerge(EntryLayerToolCfg(flags))
+        result.merge(EntryLayerToolCfg(flags))
+        tool = result.getPublicTool("ISF_EntryLayerTool")
     kwargs.setdefault("EntryLayerTool", tool)
     result.merge(GeoIDSvcCfg(flags))
     kwargs.setdefault("GeoIDSvc", result.getService("ISF_GeoIDSvc"))
@@ -59,7 +61,7 @@ def TrackProcessorUserActionToolCfg(flags, name="ISFG4TrackProcessorUserActionTo
 
 
 def PassBackG4TrackProcessorUserActionToolCfg(flags, name="PassBackG4TrackProcessorUserActionTool", **kwargs):
-    return TrackProcessorUserActionToolCfg(name, **kwargs)
+    return TrackProcessorUserActionToolCfg(flags, name, **kwargs)
 
 
 def AFII_G4TrackProcessorUserActionToolCfg(flags, name="AFII_G4TrackProcessorUserActionTool", **kwargs):

Simulation/ISF/ISF_Config/python/ISF_MainConfigNew.py

@@ -14,29 +14,38 @@ from ISF_Tools.ISF_ToolsConfigNew import (
     EnergyParticleOrderingToolCfg,
 )
 from ISF_SimulationSelectors.ISF_SimulationSelectorsConfigNew import (
-    FullGeant4SelectorCfg,
+    DefaultAFIIGeant4SelectorCfg,
+    DefaultLegacyAFIIFastCaloSimSelectorCfg,
     DefaultParticleKillerSelectorCfg,
+    EtaGreater5ParticleKillerSimSelectorCfg,
+    FullGeant4SelectorCfg,
+    MuonAFIIGeant4SelectorCfg,
     PassBackGeant4SelectorCfg,
 )
 from ISF_Geant4Tools.ISF_Geant4ToolsConfigNew import (
-    FullGeant4ToolCfg, LongLivedGeant4ToolCfg,
+    AFIIGeant4ToolCfg,
+    FullGeant4ToolCfg,
+    LongLivedGeant4ToolCfg,
     PassBackGeant4ToolCfg,
 )
 from ISF_FastCaloSimServices.ISF_FastCaloSimServicesConfigNew import (
     FastCaloToolBaseCfg,
+    LegacyAFIIFastCaloToolCfg,
 )
+from ISF_FatrasServices.ISF_FatrasConfig import fatrasSimToolCfg
 
 # MT
 def Kernel_GenericSimulatorMTCfg(flags, name="ISF_Kernel_GenericSimulatorMT", **kwargs):
     acc = ComponentAccumulator()
 
-    tool = acc.popToolsAndMerge(ParticleKillerToolCfg(flags))
+    acc.merge(ParticleKillerToolCfg(flags))
+    tool = acc.getPublicTool("ISF_ParticleKillerTool")
     kwargs.setdefault("ParticleKillerTool", tool)
 
     acc.merge(GeoIDSvcCfg(flags))
     kwargs.setdefault("GeoIDSvc", acc.getService("ISF_GeoIDSvc"))
-    acc.merge(InputConverterCfg(flags))
 
+    acc.merge(InputConverterCfg(flags))
     kwargs.setdefault("InputConverter", acc.getService("ISF_InputConverter"))
 
     truthacc = TruthServiceCfg(flags)
@@ -59,13 +68,15 @@ def Kernel_GenericSimulatorNoG4MTCfg(flags, name="ISF_Kernel_GenericSimulatorNoG
 def Kernel_GenericG4OnlyMTCfg(flags, name="ISF_Kernel_GenericG4OnlyMT", **kwargs):
     acc = ComponentAccumulator()
 
-    tool = acc.popToolsAndMerge(FullGeant4SelectorCfg(flags))
+    acc.merge(FullGeant4SelectorCfg(flags))
+    tool = acc.getPublicTool("ISF_FullGeant4Selector")
     kwargs.setdefault("BeamPipeSimulationSelectors", [tool])
     kwargs.setdefault("IDSimulationSelectors", [tool])
     kwargs.setdefault("CaloSimulationSelectors", [tool])
     kwargs.setdefault("MSSimulationSelectors", [tool])
 
-    tool = acc.popToolsAndMerge(DefaultParticleKillerSelectorCfg(flags))
+    acc.merge(DefaultParticleKillerSelectorCfg(flags))
+    tool = acc.getPublicTool("ISF_DefaultParticleKillerSelector")
     kwargs.setdefault("CavernSimulationSelectors", [tool])
 
     acc.merge(Kernel_GenericSimulatorMTCfg(flags, name, **kwargs))
@@ -75,8 +86,10 @@ def Kernel_GenericG4OnlyMTCfg(flags, name="ISF_Kernel_GenericG4OnlyMT", **kwargs
 def Kernel_FullG4MTCfg(flags, name="ISF_Kernel_FullG4MT", **kwargs):
     acc = ComponentAccumulator()
 
-    PKtool = acc.popToolsAndMerge(ParticleKillerToolCfg(flags))
-    Fulltool = acc.popToolsAndMerge(FullGeant4ToolCfg(flags))
+    acc.merge(ParticleKillerToolCfg(flags))
+    acc.merge(FullGeant4ToolCfg(flags))
+    PKtool = acc.getPublicTool("ISF_ParticleKillerTool")
+    Fulltool = acc.getPublicTool("ISF_FullGeant4Tool")
     kwargs.setdefault("SimulationTools", [PKtool, Fulltool])
 
     acc.merge(Kernel_GenericG4OnlyMTCfg(flags, name, **kwargs))
@@ -86,8 +99,10 @@ def Kernel_FullG4MTCfg(flags, name="ISF_Kernel_FullG4MT", **kwargs):
 def Kernel_FullG4MT_LongLivedCfg(flags, name="ISF_Kernel_FullG4MT_LongLived", **kwargs):
     acc = ComponentAccumulator()
 
-    PKtool = acc.popToolsAndMerge(ParticleKillerToolCfg(flags))
-    LLtool = acc.popToolsAndMerge(LongLivedGeant4ToolCfg(flags))
+    acc.merge(ParticleKillerToolCfg(flags))
+    acc.merge(LongLivedGeant4ToolCfg(flags))
+    PKtool = acc.getPublicTool("ISF_ParticleKillerTool")
+    LLtool = acc.getPublicTool("ISF_LongLivedGeant4Tool")
     kwargs.setdefault("SimulationTools", [PKtool, LLtool])
 
     acc.merge(LongLivedInputConverterCfg(flags))
@@ -101,22 +116,65 @@ def Kernel_FullG4MT_LongLivedCfg(flags, name="ISF_Kernel_FullG4MT_LongLived", **
 def Kernel_PassBackG4MTCfg(flags, name="ISF_Kernel_PassBackG4MT", **kwargs):
     acc = ComponentAccumulator()
 
-    tool = acc.popToolsAndMerge(PassBackGeant4SelectorCfg(flags))
+    acc.merge(PassBackGeant4SelectorCfg(flags))
+    tool = acc.getPublicTool("ISF_PassBackGeant4Selector")
     kwargs.setdefault("BeamPipeSimulationSelectors", [tool])
     kwargs.setdefault("IDSimulationSelectors", [tool])
     kwargs.setdefault("CaloSimulationSelectors", [tool])
     kwargs.setdefault("MSSimulationSelectors", [tool])
 
-    tool = acc.popToolsAndMerge(DefaultParticleKillerSelectorCfg(flags))
+    acc.merge(DefaultParticleKillerSelectorCfg(flags))
+    tool = acc.getPublicTool("ISF_DefaultParticleKillerSelector")
     kwargs.setdefault("CavernSimulationSelectors", [tool])
 
-    PKtool = acc.popToolsAndMerge(ParticleKillerToolCfg(flags))
-    PBtool = acc.popToolsAndMerge(PassBackGeant4ToolCfg(flags))
+    acc.merge(ParticleKillerToolCfg(flags))
+    acc.merge(PassBackGeant4ToolCfg(flags))
+    PKtool = acc.getPublicTool("ISF_ParticleKillerTool")
+    PBtool = acc.getPublicTool("ISF_PassBackGeant4Tool")
     kwargs.setdefault("SimulationTools", [PKtool, PBtool])
 
-    tool = acc.popToolsAndMerge(EnergyParticleOrderingToolCfg(flags))
+    acc.merge(EnergyParticleOrderingToolCfg(flags))
+    tool = acc.getPublicTool("ISF_EnergyParticleOrderingTool")
+    kwargs.setdefault("ParticleOrderingTool", tool)
+
+    acc.merge(Kernel_GenericSimulatorMTCfg(flags, name, **kwargs))
+    return acc
+
+
+def Kernel_ATLFASTIIMTCfg(flags, name="ISF_Kernel_ATLFASTIIMT", **kwargs):
+    acc = ComponentAccumulator()
+
+    acc.merge(DefaultAFIIGeant4SelectorCfg(flags))
+    tool = acc.getPublicTool("ISF_DefaultAFIIGeant4Selector")
+    kwargs.setdefault("BeamPipeSimulationSelectors", [tool])
+    kwargs.setdefault("IDSimulationSelectors", [tool])
+    kwargs.setdefault("MSSimulationSelectors", [tool])
+
+    acc.merge(MuonAFIIGeant4SelectorCfg(flags))
+    acc.merge(EtaGreater5ParticleKillerSimSelectorCfg(flags))
+    acc.merge(DefaultLegacyAFIIFastCaloSimSelectorCfg(flags))
+    Mutool = acc.getPublicTool("ISF_MuonAFIIGeant4Selector")
+    EtaGtool = acc.getPublicTool("ISF_EtaGreater5ParticleKillerSimSelector")
+    DefLegtool = acc.getPublicTool("ISF_DefaultLegacyAFIIFastCaloSimSelector")
+    kwargs.setdefault("CaloSimulationSelectors", [Mutool, EtaGtool, DefLegtool])
+
+    acc.merge(DefaultParticleKillerSelectorCfg(flags))
+    tool = acc.getPublicTool("ISF_DefaultParticleKillerSelector")
+    kwargs.setdefault("CavernSimulationSelectors", [tool])
+
+    acc.merge(ParticleKillerToolCfg(flags))
+    acc.merge(LegacyAFIIFastCaloToolCfg(flags))
+    acc.merge(AFIIGeant4ToolCfg(flags))
+    PKtool = acc.getPublicTool("ISF_ParticleKillerTool")
+    Legtool = acc.getPublicTool("ISF_LegacyAFIIFastCaloTool")
+    AFIItool = acc.getPublicTool("ISF_AFIIGeant4Tool")
+    kwargs.setdefault("SimulationTools", [PKtool, Legtool, AFIItool])
+
+    acc.merge(EnergyParticleOrderingToolCfg(flags))
+    tool = acc.getPublicTool("ISF_EnergyParticleOrderingTool")
     kwargs.setdefault("ParticleOrderingTool", tool)
 
+    # not migrated simFlags.SimulationFlavour = "ATLFASTII"
     acc.merge(Kernel_GenericSimulatorMTCfg(flags, name, **kwargs))
     return acc
 
@@ -124,12 +182,12 @@ def Kernel_PassBackG4MTCfg(flags, name="ISF_Kernel_PassBackG4MT", **kwargs):
 def Kernel_ATLFASTIIFMTCfg(flags, name="ISF_Kernel_ATLFASTIIFMT", **kwargs):
     acc = ComponentAccumulator()
 
-    PKtool = acc.popToolsAndMerge(ParticleKillerToolCfg(flags))
-    FastCalotool = acc.popToolsAndMerge(FastCaloToolBaseCfg(flags))
-    # TODO resolve this missing config
-    raise NotImplementedError("No configuration for \"ISF_FatrasTool\"")
-    Fatrastool = None
-    # Fatrastool = acc.popToolsAndMerge(FatrasToolCfg(flags))
+    acc.merge(ParticleKillerToolCfg(flags))
+    acc.merge(FastCaloToolBaseCfg(flags))
+    acc.merge(fatrasSimToolCfg(flags))
+    PKtool = acc.getPublicTool("ISF_ParticleKillerTool")
+    FastCalotool = acc.getPublicTool("ISF_FastCaloTool")
+    Fatrastool = acc.getPublicTool("ISF_FatrasSimTool")
     kwargs.setdefault("SimulationTools", [PKtool, FastCalotool, Fatrastool])
 
     # not migrated 'simFlags.SimulationFlavour = "ATLFASTIIF"'

Simulation/ISF/ISF_Config/test/ISF_MainConfigNew_Test.py

@@ -65,7 +65,7 @@ if __name__ == '__main__':
     inputDir = defaultTestFiles.d
     ConfigFlags.Input.Files = ['/cvmfs/atlas-nightlies.cern.ch/repo/data/data-art/SimCoreTests/valid1.410000.PowhegPythiaEvtGen_P2012_ttbar_hdamp172p5_nonallhad.evgen.EVNT.e4993.EVNT.08166201._000012.pool.root.1'] #defaultTestFiles.EVNT
     ConfigFlags.Output.HITSFileName = "myHITSnew1106_2.pool.root"
-
+    
     #Sim ConfigFlags
     #ConfigFlags.Sim.WorldRRange = 15000
     #ConfigFlags.Sim.WorldZRange = 27000 #change defaults?
@@ -190,7 +190,7 @@ if __name__ == '__main__':
     ConfigFlags.dump()
 
     # Execute and finish
-    #sc = cfg.run(maxEvents=evtMax)
+    sc = cfg.run(maxEvents=evtMax)
 
     b = time.time()
     log.info("Run G4AtlasAlg in " + str(b-a) + " seconds")

Simulation/ISF/ISF_Core/ISF_Algorithms/python/CollectionMergerConfig.py

@@ -25,7 +25,7 @@ def ISFCollectionMergerCfg(flags,name="ISF_CollectionMerger", **kwargs):
     kwargs.setdefault( "InputTGCHits",              [ ] )
     hardscatterSG=""
     try:
-        if flags.Digitization.Pileup is True:
+        if flags.Sim.DoFullChain and (flags.Digitization.Pileup is True):
             hardscatterSG = "OriginalEvent_SG+"
     except RuntimeError as err:
         msg = logging.getLogger(name)

Simulation/ISF/ISF_Core/ISF_Services/python/ISF_ServicesConfigNew.py

@@ -70,13 +70,14 @@ def LongLivedInputConverterCfg(ConfigFlags, name="ISF_LongLivedInputConverter",
 def ParticleBrokerSvcNoOrderingCfg(ConfigFlags, name="ISF_ParticleBrokerSvcNoOrdering", **kwargs):
     result = ComponentAccumulator()
     if "EntryLayerTool" not in kwargs:
-        tool = result.popToolsAndMerge(EntryLayerToolCfg(ConfigFlags))
+        result.merge(EntryLayerToolCfg(ConfigFlags))
+        tool = result.getPublicTool("ISF_EntryLayerTool")
         kwargs.setdefault("EntryLayerTool", tool)
         kwargs.setdefault("GeoIDSvc", result.getService("ISF_GeoIDSvc"))
     # assume "GeoIDSvc" has been set alongside "EntryLayerTool"
     kwargs.setdefault("AlwaysUseGeoIDSvc", False)
-    kwargs.setdefault("ValidateGeoIDs", ConfigFlags.ISF.ValidationMode)
-    kwargs.setdefault("ValidationOutput", ConfigFlags.ISF.ValidationMode)
+    kwargs.setdefault("ValidateGeoIDs", ConfigFlags.Sim.ISF.ValidationMode)
+    kwargs.setdefault("ValidationOutput", ConfigFlags.Sim.ISF.ValidationMode)
     kwargs.setdefault("ValidationStreamName", "ParticleBroker")
 
     baracc = BarcodeSvcCfg(ConfigFlags)
@@ -98,7 +99,8 @@ def ParticleBrokerSvcCfg(ConfigFlags, name="ISF_ParticleBrokerSvc", **kwargs):
 
 def AFIIParticleBrokerSvcCfg(ConfigFlags, name="ISF_AFIIParticleBrokerSvc", **kwargs):
     result = AFIIEntryLayerToolCfg(ConfigFlags)
-    kwargs.setdefault("EntryLayerTool", result.popPrivateTools())
+    tool = result.getPublicTool("ISF_AFIIEntryLayerTool")
+    kwargs.setdefault("EntryLayerTool", tool)
     kwargs.setdefault("GeoIDSvc", result.getService("ISF_AFIIGeoIDSvc"))
     result.merge(ParticleBrokerSvcCfg(ConfigFlags, name, **kwargs))
     return result

Simulation/ISF/ISF_Core/ISF_Tools/python/ISF_ToolsConfigNew.py

@@ -162,5 +162,5 @@ def EnergyParticleOrderingToolCfg(flags, name="ISF_EnergyParticleOrderingTool",
 
 def ParticleKillerToolCfg(flags, name="ISF_ParticleKillerTool", **kwargs):
     acc = ComponentAccumulator()
-    acc.setPrivateTools(CompFactory.ISF.ParticleKillerSimTool(name, **kwargs))
+    acc.addPublicTool(CompFactory.ISF.ParticleKillerSimTool(name, **kwargs))
     return acc

Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimServices/python/ISF_FastCaloSimServicesConfigNew.py

@@ -12,6 +12,7 @@ from RngComps.RandomServices import RNG
 from ISF_FastCaloSimParametrization.ISF_FastCaloSimParametrizationConfigNew import FastCaloSimCaloExtrapolationCfg
 from FastCaloSim.FastCaloSimFactoryNew import (NITimedExtrapolatorCfg,
                                                FastShowerCellBuilderToolCfg)
+from FastCaloSim.AddNoiseCellBuilderToolConfig import AddNoiseCellBuilderToolCfg
 
 
 def PunchThroughToolCfg(flags, name="ISF_PunchThroughTool", **kwargs):
@@ -21,7 +22,7 @@ def PunchThroughToolCfg(flags, name="ISF_PunchThroughTool", **kwargs):
 
     acc = RNG(flags.Random.Engine)
     kwargs.setdefault("RandomNumberService", acc.getService("AthRNGSvc"))
-    kwargs.setdefault("RandomStreamName", "AthRNGSvc") # TODO check
+    kwargs.setdefault("RandomStreamName", "AthRNGSvc")
     kwargs.setdefault("FilenameLookupTable", "CaloPunchThroughParametrisation.root")
     kwargs.setdefault("PunchThroughInitiators", [211])
     kwargs.setdefault("PunchThroughParticles", [   2212,     211,      22,      11,      13])
@@ -37,19 +38,20 @@ def PunchThroughToolCfg(flags, name="ISF_PunchThroughTool", **kwargs):
     acc.merge(EnvelopeDefSvcCfg(flags))
     kwargs.setdefault("EnvelopeDefSvc", acc.getService("AtlasGeometry_EnvelopeDefSvc"))
     kwargs.setdefault("BeamPipeRadius", 500.)
-    acc.setPrivateTools(CompFactory.ISF.PunchThroughTool(name, **kwargs))
+    acc.addPublicTool(CompFactory.ISF.PunchThroughTool(name, **kwargs))
     return acc
 
 
 def EmptyCellBuilderToolCfg(flags, name="ISF_EmptyCellBuilderTool", **kwargs):
-    return CompFactory.EmptyCellBuilderTool(name, **kwargs)
+    acc = ComponentAccumulator()
+    acc.addPublicTool(CompFactory.EmptyCellBuilderTool(name, **kwargs))
+    return acc
 
 
 def LegacyFastShowerCellBuilderToolCfg(flags, name="ISF_LegacyFastShowerCellBuilderTool", **kwargs):
     acc = FastShowerCellBuilderToolCfg(flags, name, **kwargs)
-    FastShowerCellBuilderTool = acc.popPrivateTools()
+    FastShowerCellBuilderTool = acc.getPublicTool("ISF_FastShowerCellBuilderTool")
     FastShowerCellBuilderTool.Invisibles += [13]
-    acc.setPrivateTools(FastShowerCellBuilderTool)
     return acc
 
 def PileupFastShowerCellBuilderToolCfg(flags, name="ISF_PileupFastShowerCellBuilderTool", **kwargs):
@@ -169,7 +171,7 @@ def FastHitConvertToolCfg(flags, name="ISF_FastHitConvertTool", **kwargs):
     kwargs.setdefault("hecHitContainername", HEC_hits_collection_name)
     kwargs.setdefault("tileHitContainername", tile_hits_collection_name)
 
-    acc.setPrivateTools(CompFactory.FastHitConvertTool(name, **kwargs))
+    acc.addPublicTool(CompFactory.FastHitConvertTool(name, **kwargs))
     return acc
 
 # TODO: do we need this - nowhere called?
@@ -177,18 +179,23 @@ def FastHitConvertToolCfg(flags, name="ISF_FastHitConvertTool", **kwargs):
 #     from CaloTools.CaloNoiseToolDefault import CaloNoiseToolDefault
 #     return CaloNoiseToolDefault(name, **kwargs)
 
-
-def AddNoiseCellBuilderToolCfg(flags, name="ISF_AddNoiseCellBuilderTool", **kwargs):
-    from FastCaloSim.AddNoiseCellBuilderToolConfig import AddNoiseCellBuilderToolCfg
-    return AddNoiseCellBuilderToolCfg(flags)
+def AddNoiseCellBuilderPublicToolCfg(flags, name="ISF_AddNoiseCellBuilderTool", **kwargs):
+    acc = AddNoiseCellBuilderToolCfg(flags)
+    tool = acc.popPrivateTools()
+    acc.addPublicTool(tool)
+    return acc
 
 
 def CaloCellContainerFinalizerToolCfg(flags, name="ISF_CaloCellContainerFinalizerTool", **kwargs):
-    return CompFactory.CaloCellContainerFinalizerTool(name, **kwargs)
+    acc = ComponentAccumulator()
+    acc.addPublicTool(CompFactory.CaloCellContainerFinalizerTool(name, **kwargs))
+    return acc
 
 
 def CaloCellContainerFCSFinalizerToolCfg(flags, name="ISF_CaloCellContainerFCSFinalizerTool", **kwargs):
-    return CompFactory.CaloCellContainerFCSFinalizerTool(name, **kwargs)
+    acc = ComponentAccumulator()
+    acc.addPublicTool(CompFactory.CaloCellContainerFCSFinalizerTool(name, **kwargs))
+    return acc
 
 
 def FastHitConvAlgCfg(flags, name="ISF_FastHitConvAlg", **kwargs):
@@ -206,23 +213,28 @@ def FastHitConvAlgCfg(flags, name="ISF_FastHitConvAlg", **kwargs):
 
 def FastCaloToolBaseCfg(flags, name="ISF_FastCaloTool", **kwargs):
     acc = ComponentAccumulator()
+    
+    acc.merge(PunchThroughToolCfg(flags))
+    acc.merge(FastShowerCellBuilderToolCfg(flags))
+    acc.merge(FastHitConvertToolCfg(flags))
+    acc.merge(EmptyCellBuilderToolCfg(flags))
+    acc.merge(CaloCellContainerFinalizerToolCfg(flags))
     kwargs.setdefault("BatchProcessMcTruth"              , False)
     kwargs.setdefault("SimulateUndefinedBarcodeParticles", False)
-    kwargs.setdefault("CaloCellsOutputName"              , flags.Sim.FastCalo.CaloCellsName)
-    kwargs.setdefault("PunchThroughTool"                 , acc.popToolsAndMerge(PunchThroughToolCfg(flags)))
-    kwargs.setdefault("DoPunchThroughSimulation"         , False)
-    kwargs.setdefault("CaloCellMakerTools_setup"         , [EmptyCellBuilderToolCfg(flags)])
-    kwargs.setdefault("CaloCellMakerTools_simulate"      , [acc.popToolsAndMerge(FastShowerCellBuilderToolCfg(flags))])
-    kwargs.setdefault("CaloCellMakerTools_release"       , [# AddNoiseCellBuilderToolCfg(flags)",
-                                                            CaloCellContainerFinalizerToolCfg(flags),
-                                                            acc.popToolsAndMerge(FastHitConvertToolCfg(flags))])
+    kwargs.setdefault("CaloCellsOutputName"        , flags.Sim.FastCalo.CaloCellsName)
+    kwargs.setdefault("PunchThroughTool"           , acc.getPublicTool("ISF_PunchThroughTool"))
+    kwargs.setdefault("DoPunchThroughSimulation"   , False)
+    kwargs.setdefault("CaloCellMakerTools_setup"   , [acc.getPublicTool("ISF_EmptyCellBuilderTool")])
+    kwargs.setdefault("CaloCellMakerTools_simulate", [acc.getPublicTool("ISF_FastShowerCellBuilderTool")])
+    kwargs.setdefault("CaloCellMakerTools_release" , [acc.getPublicTool("ISF_CaloCellContainerFinalizerTool"),
+                                                      acc.getPublicTool("ISF_FastHitConvertTool")])
     kwargs.setdefault("Extrapolator", NITimedExtrapolatorCfg(flags))
     # FIXME not migrated. Remove or replace
     # register the FastCaloSim random number streams
     #from G4AtlasApps.SimFlags import simFlags
     #if not simFlags.RandomSeedList.checkForExistingSeed(ISF_FastCaloSimFlags.RandomStreamName()):
         #simFlags.RandomSeedList.addSeed( ISF_FastCaloSimFlags.RandomStreamName(), 98346412, 12461240)
-    acc.setPrivateTools(CompFactory.ISF.FastCaloTool(name, **kwargs))
+    acc.addPublicTool(CompFactory.ISF.FastCaloTool(name, **kwargs))
     return acc
 
 # TODO: Do we need this - can we only call FastCaloToolBaseCfg?
@@ -232,7 +244,8 @@ def FastCaloToolBaseCfg(flags, name="ISF_FastCaloTool", **kwargs):
 def FastCaloPileupToolCfg(flags, name="ISF_FastCaloPileupTool", **kwargs):
     acc = ComponentAccumulator()
     kwargs.setdefault("CaloCellsOutputName", flags.Sim.FastCalo.CaloCellsName + "PileUp")
-    tool = acc.popToolsAndMerge(PileupFastShowerCellBuilderToolCfg(flags))
+    acc.merge(PileupFastShowerCellBuilderToolCfg(flags))
+    tool = acc.getPublicTool("ISF_PileupFastShowerCellBuilderTool")
     kwargs.setdefault("CaloCellMakerTools_simulate", [tool])
     acc.merge(FastCaloToolBaseCfg(name, **kwargs))
     return acc
@@ -240,23 +253,28 @@ def FastCaloPileupToolCfg(flags, name="ISF_FastCaloPileupTool", **kwargs):
 def LegacyAFIIFastCaloToolCfg(flags, name="ISF_LegacyAFIIFastCaloTool", **kwargs):
     acc = ComponentAccumulator()
     kwargs.setdefault("BatchProcessMcTruth", True)
-    tool = acc.popToolsAndMerge(LegacyFastShowerCellBuilderToolCfg(flags))
+    acc.merge(LegacyFastShowerCellBuilderToolCfg(flags))
+    tool = acc.getPublicTool("ISF_LegacyFastShowerCellBuilderTool")
     kwargs.setdefault("CaloCellMakerTools_simulate", [tool])
     acc.merge(FastCaloToolBaseCfg(name, **kwargs))
     return acc
 
 def FastCaloSimV2ToolCfg(flags, name="ISF_FastCaloSimV2Tool", **kwargs):
     acc = ComponentAccumulator()
+    
+    acc.merge(FastHitConvertToolCfg(flags))
+    acc.merge(EmptyCellBuilderToolCfg(flags))
+    acc.merge(CaloCellContainerFCSFinalizerToolCfg(flags))
     kwargs.setdefault("CaloCellsOutputName", flags.Sim.FastCalo.CaloCellsName)
-    kwargs.setdefault("CaloCellMakerTools_setup", [EmptyCellBuilderToolCfg(flags)] )
-    kwargs.setdefault("CaloCellMakerTools_release", [CaloCellContainerFCSFinalizerToolCfg(flags),
-                                                     acc.popToolsAndMerge(FastHitConvertToolCfg(flags))])
+    kwargs.setdefault("CaloCellMakerTools_setup", [acc.getPublicTool("ISF_EmptyCellBuilderTool")])
+    kwargs.setdefault("CaloCellMakerTools_release", [acc.getPublicTool("ISF_CaloCellContainerFCSFinalizerTool"),
+                                                     acc.getPublicTool("ISF_FastHitConvertTool")])
     kwargs.setdefault("FastCaloSimCaloExtrapolation", FastCaloSimCaloExtrapolationCfg(flags))
     kwargs.setdefault("ParamSvc", acc.popToolsAndMerge(FastCaloSimV2ParamSvcCfg(flags)))
     acc.merge(RNG(flags.Random.Engine))
     kwargs.setdefault("RandomSvc", acc.getService("AthRNGSvc"))
-    kwargs.setdefault("RandomStream", "AthRNGSvc") # TODO check
-    kwargs.setdefault("PunchThroughTool", acc.popToolsAndMerge(PunchThroughToolCfg(flags)))
+    kwargs.setdefault("RandomStream", "AthRNGSvc")
+    kwargs.setdefault("PunchThroughTool", acc.merge(PunchThroughToolCfg(flags)))
 
     acc.setPrivateTools(CompFactory.ISF.FastCaloSimV2Tool(name, **kwargs))
     return acc
@@ -266,38 +284,38 @@ def FastCaloSimV2ToolCfg(flags, name="ISF_FastCaloSimV2Tool", **kwargs):
 
 def FastCaloSimSvcCfg(flags, name="ISF_FastCaloSimSvc", **kwargs):
     acc = ComponentAccumulator()
+    
     if "SimulatorTool" not in kwargs:
-        tool = acc.popToolsAndMerge(FastCaloToolBaseCfg(flags))
-        kwargs.setdefault("SimulatorTool", tool)
+        acc.merge(FastCaloToolBaseCfg(flags))
+        kwargs.setdefault("SimulatorTool", acc.getPublicTool("ISF_FastCaloTool"))
     kwargs.setdefault("Identifier", "FastCaloSim")
     acc.addService(CompFactory.ISF.LegacySimSvc(name, **kwargs))
     return acc
 
 
 def FastCaloSimPileupSvcCfg(flags, name="ISF_FastCaloSimPileupSvc", **kwargs):
-    acc1 = FastCaloPileupToolCfg(flags)
-    kwargs.setdefault("SimulatorTool", acc1.popPrivateTools())
-    acc = FastCaloSimSvcCfg(flags, name, **kwargs)
-    acc.merge(acc1)
+    acc = FastCaloPileupToolCfg(flags)
+    kwargs.setdefault("SimulatorTool", acc.getPublicTool("ISF_FastCaloTool"))
+    acc.merge(FastCaloSimSvcCfg(flags, name, **kwargs))
     return acc
 
 
 def LegacyAFIIFastCaloSimSvcCfg(flags, name="ISF_LegacyAFIIFastCaloSimSvc", **kwargs):
-    acc1 = LegacyAFIIFastCaloToolCfg(flags)
-    kwargs.setdefault("SimulatorTool", acc1.popPrivateTools())
-    acc = FastCaloSimSvcCfg(flags, name, **kwargs)
-    acc.merge(acc1)
+    acc = LegacyAFIIFastCaloToolCfg(flags)
+    kwargs.setdefault("SimulatorTool", acc.getPublicTool("ISF_FastCaloTool"))
+    acc.merge(FastCaloSimSvcCfg(flags, name, **kwargs))
     return acc
 
 
 def FastHitConvAlgFastCaloSimSvcCfg(flags, name="ISF_FastHitConvAlgFastCaloSimSvc",**kwargs):
-    acc1 = FastHitConvAlgCfg(flags)
-    kwargs.setdefault("CaloCellMakerTools_release", [AddNoiseCellBuilderToolCfg(flags),
-                                                     CaloCellContainerFCSFinalizerToolCfg(flags)])
+    acc = FastHitConvAlgCfg(flags)
+    acc.merge(AddNoiseCellBuilderPublicToolCfg(flags))
+    acc.merge(CaloCellContainerFCSFinalizerToolCfg(flags))
+    kwargs.setdefault("CaloCellMakerTools_release", [acc.getPublicTool("AddNoiseCellBuilderTool"),
+                                                     acc.getPublicTool("ISF_CaloCellContainerFCSFinalizerTool")])
     # setup FastCaloSim hit converter and add it to the alg sequence:
     # -> creates HITS from reco cells
-    acc = FastCaloSimSvcCfg(flags, name, **kwargs)
-    acc.merge(acc1)
+    acc.merge(FastCaloSimSvcCfg(flags, name, **kwargs))
     return acc
 
 
@@ -308,21 +326,26 @@ def FastHitConvAlgLegacyAFIIFastCaloSimSvcCfg(flags, name="ISF_FastHitConvAlgLeg
 
 def FastCaloSimPileupOTSvcCfg(flags, name="ISF_FastCaloSimPileupOTSvc", **kwargs):
     acc = ComponentAccumulator()
+    
+    acc.merge(PunchThroughToolCfg(flags))
+    acc.merge(FastShowerCellBuilderToolCfg(flags))
+    acc.merge(FastHitConvertToolCfg(flags))
+    acc.merge(EmptyCellBuilderToolCfg(flags))
+    acc.merge(CaloCellContainerFCSFinalizerToolCfg(flags))
     kwargs.setdefault("BatchProcessMcTruth", False)
     kwargs.setdefault("SimulateUndefinedBarcodeParticles", False)
     kwargs.setdefault("Identifier", "FastCaloSim")
     kwargs.setdefault("CaloCellsOutputName", flags.Sim.FastCalo.CaloCellsName + "PileUp")
-    kwargs.setdefault("PunchThroughTool", acc.popToolsAndMerge(PunchThroughToolCfg(flags)))
+    kwargs.setdefault("PunchThroughTool", acc.getPublicTool("ISF_PunchThroughTool"))
     kwargs.setdefault("DoPunchThroughSimulation", False)
     kwargs.setdefault("PUWeights_lar_bapre", flags.Sim.FastChain.PUWeights_lar_bapre)
     kwargs.setdefault("PUWeights_lar_hec", flags.Sim.FastChain.PUWeights_lar_hec)
     kwargs.setdefault("PUWeights_lar_em", flags.Sim.FastChain.PUWeights_lar_em)
     kwargs.setdefault("PUWeights_tile", flags.Sim.FastChain.PUWeights_tile)
-    kwargs.setdefault("CaloCellMakerTools_setup", [EmptyCellBuilderToolCfg(flags)])
-    kwargs.setdefault("CaloCellMakerTools_simulate", [acc.popToolsAndMerge(FastShowerCellBuilderToolCfg(flags))])
-    kwargs.setdefault("CaloCellMakerTools_release", [ # AddNoiseCellBuilderToolCfg(flags),
-                                                     CaloCellContainerFCSFinalizerToolCfg(flags),
-                                                     acc.popToolsAndMerge(FastHitConvertToolCfg(flags))])
+    kwargs.setdefault("CaloCellMakerTools_setup", [acc.getPublicTool("ISF_EmptyCellBuilderTool")])
+    kwargs.setdefault("CaloCellMakerTools_simulate", [acc.getPublicTool("ISF_FastShowerCellBuilderTool")])
+    kwargs.setdefault("CaloCellMakerTools_release", [acc.getPublicTool("ISF_CaloCellContainerFCSFinalizerTool"),
+                                                     acc.getPublicTool("ISF_FastHitConvertTool")])
     kwargs.setdefault("Extrapolator", NITimedExtrapolatorCfg(flags))
     # FIXME not migrated. Remove or replace
     # register the FastCaloSim random number streams
@@ -351,10 +374,14 @@ def FastCaloSimV2SvcCfg(flags, name="ISF_FastCaloSimSvcV2", **kwargs):
 
 def DNNCaloSimSvcCfg(flags, name="ISF_DNNCaloSimSvc", **kwargs):
     acc = ComponentAccumulator()
+    
+    acc.merge(FastHitConvertToolCfg(flags))
+    acc.merge(EmptyCellBuilderToolCfg(flags))
+    acc.merge(CaloCellContainerFinalizerToolCfg(flags))
     kwargs.setdefault("CaloCellsOutputName", flags.Sim.FastCalo.CaloCellsName)
-    kwargs.setdefault("CaloCellMakerTools_setup", [EmptyCellBuilderToolCfg(flags)])
-    kwargs.setdefault("CaloCellMakerTools_release", [CaloCellContainerFinalizerToolCfg(flags),
-                                                     acc.popToolsAndMerge(FastHitConvertToolCfg(flags))]) #DR needed ?
+    kwargs.setdefault("CaloCellMakerTools_setup", [acc.getPublicTool("ISF_EmptyCellBuilderTool")])
+    kwargs.setdefault("CaloCellMakerTools_release", [acc.getPublicTool("ISF_CaloCellContainerFinalizerTool"),
+                                                     acc.getPublicTool("ISF_FastHitConvertTool")]) #DR needed ?
     kwargs.setdefault("ParamsInputFilename", flags.Sim.FastCalo.ParamsInputFilename)
     kwargs.setdefault("FastCaloSimCaloExtrapolation", FastCaloSimCaloExtrapolationCfg(flags))
 

Simulation/ISF/ISF_Geant4/ISF_Geant4CommonTools/python/ISF_Geant4CommonToolsConfigNew.py

@@ -10,45 +10,71 @@ from ISF_Tools.ISF_ToolsConfigNew import EntryLayerFilterCfg
 
 def EntryLayerToolCfg(flags, name="ISF_EntryLayerTool", **kwargs):
     acc = ComponentAccumulator()
-    if "GeoIDSvc" not in kwargs:
-        acc.merge(GeoIDSvcCfg(flags))
-        kwargs["GeoIDSvc"] = acc.getService("ISF_GeoIDSvc")
+
+    acc.merge(GeoIDSvcCfg(flags))
+    kwargs["GeoIDSvc"] = acc.getService("ISF_GeoIDSvc")
+
     filt = acc.popToolsAndMerge(EntryLayerFilterCfg(flags))
     kwargs.setdefault("ParticleFilters", [filt])
-    if flags.Sim.DoFullChain: # TODO and DetFlags.pileup.any_on():
-        kwargs.setdefault("EvtStore", "OriginalEvent_SG") # For Fast Chain
-    acc.setPrivateTools(CompFactory.ISF.EntryLayerTool(name, **kwargs))
+
+    if flags.Sim.DoFullChain:
+        OEsvc = CompFactory.StoreGateSvc("OriginalEvent_SG")
+        acc.addService(OEsvc)
+        kwargs.setdefault("EvtStore", OEsvc) # For Fast Chain
+
+    acc.addPublicTool(CompFactory.ISF.EntryLayerTool(name, **kwargs))
     return acc
 
 
 def EntryLayerToolMTCfg(flags, name="ISF_EntryLayerToolMT", **kwargs):
     acc = ComponentAccumulator()
-    if "GeoIDSvc" not in kwargs:
-        acc.merge(GeoIDSvcCfg(flags))
-        kwargs["GeoIDSvc"] = acc.getService("ISF_GeoIDSvc")
+
+    acc.merge(GeoIDSvcCfg(flags))
+    kwargs["GeoIDSvc"] = acc.getService("ISF_GeoIDSvc")
+
     filt = acc.popToolsAndMerge(EntryLayerFilterCfg(flags))
     kwargs.setdefault("ParticleFilters", [filt])
-    if flags.Sim.DoFullChain: # TODO and DetFlags.pileup.any_on():
-        kwargs.setdefault("EvtStore", "OriginalEvent_SG") # For Fast Chain
-    acc.setPrivateTools(CompFactory.ISF.EntryLayerToolMT(name, **kwargs))
+
+    if flags.Sim.DoFullChain:
+        OEsvc = CompFactory.StoreGateSvc("OriginalEvent_SG")
+        acc.addService(OEsvc)
+        kwargs.setdefault("EvtStore", OEsvc) # For Fast Chain
+
+    acc.addPublicTool(CompFactory.ISF.EntryLayerToolMT(name, **kwargs))
     return acc
 
 
 def AFIIEntryLayerToolCfg(flags, name="ISF_AFIIEntryLayerTool", **kwargs):
     acc = ComponentAccumulator()
-    if "GeoIDSvc" not in kwargs:
-        acc.merge(AFIIGeoIDSvcCfg(flags))
-        kwargs["GeoIDSvc"] = acc.getService("ISF_AFIIGeoIDSvc")
-    tool = acc.popToolsAndMerge(EntryLayerToolCfg(name, **kwargs))
-    acc.setPrivateTools(tool)
+
+    acc.merge(AFIIGeoIDSvcCfg(flags))
+    kwargs["GeoIDSvc"] = acc.getService("ISF_AFIIGeoIDSvc")
+
+    filt = acc.popToolsAndMerge(EntryLayerFilterCfg(flags))
+    kwargs.setdefault("ParticleFilters", [filt])
+
+    if flags.Sim.DoFullChain:
+        OEsvc = CompFactory.StoreGateSvc("OriginalEvent_SG")
+        acc.addService(OEsvc)
+        kwargs.setdefault("EvtStore", OEsvc) # For Fast Chain
+
+    acc.addPublicTool(CompFactory.ISF.EntryLayerTool(name, **kwargs))
     return acc
 
 
 def AFIIEntryLayerToolMTCfg(flags, name="ISF_AFIIEntryLayerToolMT", **kwargs):
     acc = ComponentAccumulator()
-    if "GeoIDSvc" not in kwargs:
-        acc.merge(AFIIGeoIDSvcCfg(flags))
-        kwargs["GeoIDSvc"] = acc.getService("ISF_AFIIGeoIDSvc")
-    tool = acc.popToolsAndMerge(EntryLayerToolMTCfg(name, **kwargs))
-    acc.setPrivateTools(tool)
+
+    acc.merge(AFIIGeoIDSvcCfg(flags))
+    kwargs["GeoIDSvc"] = acc.getService("ISF_AFIIGeoIDSvc")
+
+    filt = acc.popToolsAndMerge(EntryLayerFilterCfg(flags))
+    kwargs.setdefault("ParticleFilters", [filt])
+
+    if flags.Sim.DoFullChain:
+        OEsvc = CompFactory.StoreGateSvc("OriginalEvent_SG")
+        acc.addService(OEsvc)
+        kwargs.setdefault("EvtStore", OEsvc) # For Fast Chain
+
+    acc.addPublicTool(CompFactory.ISF.EntryLayerToolMT(name, **kwargs))
     return acc

Simulation/ISF/ISF_Geant4/ISF_Geant4Services/python/ISF_Geant4ServicesConfigNew.py

@@ -22,8 +22,8 @@ def Geant4SimCfg(flags, name="ISFG4SimSvc", **kwargs):
     acc.addService(G4_DDDBEnvelopeDefSvc)
 
     if "SimulatorTool" not in kwargs:
-        tool = acc.popToolsAndMerge(Geant4ToolCfg(flags))
-        kwargs.setdefault("SimulatorTool", tool)
+        acc.merge(Geant4ToolCfg(flags))
+        kwargs.setdefault("SimulatorTool", acc.getPublicTool("ISF_Geant4Tool"))
     kwargs.setdefault("Identifier", "Geant4")
     Geant4SimService = CompFactory.iGeant4.Geant4SimSvc(name, **kwargs)
     acc.addService(Geant4SimService)
@@ -32,34 +32,34 @@ def Geant4SimCfg(flags, name="ISFG4SimSvc", **kwargs):
 
 def FullGeant4SimCfg(flags, name="ISF_FullGeant4SimSvc", **kwargs):
     acc = FullGeant4ToolCfg(flags)
-    kwargs.setdefault("SimulatorTool", acc.popPrivateTools())
-    acc.merge(Geant4SimCfg(name, **kwargs))
+    kwargs.setdefault("SimulatorTool", acc.getPublicTool("ISF_FullGeant4Tool"))
+    acc.merge(Geant4SimCfg(flags, name, **kwargs))
     return acc
 
 
 def LongLivedGeant4SimCfg(flags, name="ISF_LongLivedGeant4SimSvc", **kwargs):
     acc = LongLivedGeant4ToolCfg(flags)
-    kwargs.setdefault("SimulatorTool", acc.popPrivateTools())
-    acc.merge(FullGeant4SimCfg(name, **kwargs))
+    kwargs.setdefault("SimulatorTool", acc.getPublicTool("ISF_LongLivedGeant4Tool"))
+    acc.merge(FullGeant4SimCfg(flags, name, **kwargs))
     return acc
 
 
 def PassBackGeant4SimCfg(flags, name="ISF_PassBackGeant4SimSvc", **kwargs):
     acc = PassBackGeant4ToolCfg(flags)
-    kwargs.setdefault("SimulatorTool", acc.popPrivateTools())
-    acc.merge(Geant4SimCfg(name, **kwargs))
+    kwargs.setdefault("SimulatorTool", acc.getPublicTool("ISF_PassBackGeant4Tool"))
+    acc.merge(Geant4SimCfg(flags, name, **kwargs))
     return acc
 
 
 def AFIIGeant4SimCfg(flags, name="ISF_AFIIGeant4SimSvc", **kwargs):
     acc = AFIIGeant4ToolCfg(flags)
-    kwargs.setdefault("SimulatorTool", acc.popPrivateTools())
-    acc.merge(PassBackGeant4SimCfg(name, **kwargs))
+    kwargs.setdefault("SimulatorTool", acc.getPublicTool("ISF_AFIIGeant4Tool"))
+    acc.merge(PassBackGeant4SimCfg(flags, name, **kwargs))
     return acc
 
 
 def AFII_QS_Geant4SimCfg(flags, name="ISF_AFII_QS_Geant4SimSvc", **kwargs):
     acc = AFII_QS_Geant4ToolCfg(flags)
-    kwargs.setdefault("SimulatorTool", acc.popPrivateTools())
-    acc.merge(PassBackGeant4SimCfg(name, **kwargs))
+    kwargs.setdefault("SimulatorTool", acc.getPublicTool("AFII_QS_Geant4Tool"))
+    acc.merge(PassBackGeant4SimCfg(flags, name, **kwargs))
     return acc

Simulation/ISF/ISF_Geant4/ISF_Geant4Tools/python/ISF_Geant4ToolsConfigNew.py

@@ -15,19 +15,19 @@ from G4AtlasTools.G4AtlasToolsConfigNew import (
 from ISF_Services.ISF_ServicesConfigNew import (
     InputConverterCfg, LongLivedInputConverterCfg
 )
-
+from ISF_FatrasServices.ISF_FatrasConfig import G4RunManagerHelperCfg
 
 
 def Geant4ToolCfg(flags, name="ISF_Geant4Tool", **kwargs):
     acc = RNG(flags.Random.Engine)
     kwargs.setdefault("RandomNumberService", acc.getService("AthRNGSvc"))
-    
+
     acc.merge(DetectorGeometrySvcCfg(flags))
     kwargs.setdefault("DetGeoSvc", acc.getService("DetectorGeometrySvc"))
-    
+
     acc.merge(InputConverterCfg(flags))
     kwargs.setdefault("InputConverter", acc.getService("ISF_InputConverter"))
-    
+
     acc.merge(ISFUserActionSvcCfg(flags))
     kwargs.setdefault("UserActionSvc", acc.getService("G4UA::ISFUserActionSvc"))
     kwargs.setdefault("RecordFlux", flags.Sim.RecordFlux)
@@ -36,56 +36,52 @@ def Geant4ToolCfg(flags, name="ISF_Geant4Tool", **kwargs):
     # Set commands for the G4AtlasAlg
     kwargs.setdefault("G4Commands", flags.Sim.G4Commands)
     kwargs.setdefault("PrintTimingInfo", flags.Sim.ISF.DoTimeMonitoring)
-    tool = acc.popToolsAndMerge(SensitiveDetectorMasterToolCfg(flags))
+    acc.merge(SensitiveDetectorMasterToolCfg(flags))
+    tool = acc.getPublicTool("SensitiveDetectorMasterTool")
     kwargs.setdefault("SenDetMasterTool", tool)
-    tool = acc.popToolsAndMerge(FastSimulationMasterToolCfg(flags))
+    acc.merge(FastSimulationMasterToolCfg(flags))
+    tool = acc.getPublicTool("FastSimulationMasterTool")
     kwargs.setdefault("FastSimMasterTool", tool)
     # Workaround to keep other simulation flavours working while we migrate everything to be AthenaMT-compatible.
     if flags.Sim.ISF.Simulator in ["FullG4", "FullG4MT", "PassBackG4", "PassBackG4MT", "G4FastCalo", "G4FastCaloMT"]:
-        acc.setPrivateTools(CompFactory.iGeant4.G4TransportTool(name, **kwargs))
+        acc.addPublicTool(CompFactory.iGeant4.G4TransportTool(name, **kwargs))
     else:
-        from ISF_FatrasServices.ISF_FatrasConfig import G4RunManagerHelperCfg
         acc.merge(G4RunManagerHelperCfg(flags))
         kwargs.setdefault("G4RunManagerHelper", acc.getPublicTool("ISF_G4RunManagerHelper"))
-        acc.setPrivateTools(CompFactory.iGeant4.G4LegacyTransportTool(name, **kwargs))
+        acc.addPublicTool(CompFactory.iGeant4.G4LegacyTransportTool(name, **kwargs))
     return acc
 
 
 def FullGeant4ToolCfg(flags, name="ISF_FullGeant4Tool", **kwargs):
     acc = ISFFullUserActionSvcCfg(flags)
     kwargs.setdefault("UserActionSvc", acc.getService("G4UA::ISFFullUserActionSvc"))
-    tool = acc.popToolsAndMerge(Geant4ToolCfg(flags, name, **kwargs))
-    acc.setPrivateTools(tool)
+    acc.merge(Geant4ToolCfg(flags, name, **kwargs))
     return acc
 
 
 def PassBackGeant4ToolCfg(flags, name="ISF_PassBackGeant4Tool", **kwargs):
     acc = ISFPassBackUserActionSvcCfg(flags)
     kwargs.setdefault("UserActionSvc", acc.getService("G4UA::ISFPassBackUserActionSvc"))
-    tool = acc.popToolsAndMerge(Geant4ToolCfg(flags, name, **kwargs))
-    acc.setPrivateTools(tool)
+    acc.merge(Geant4ToolCfg(flags, name, **kwargs))
     return acc
 
 
 def AFIIGeant4ToolCfg(flags, name="ISF_AFIIGeant4Tool", **kwargs):
     acc = ISF_AFIIUserActionSvcCfg(flags)
     kwargs.setdefault("UserActionSvc", acc.getService("G4UA::ISF_AFIIUserActionSvc"))
-    tool = acc.popToolsAndMerge(PassBackGeant4ToolCfg(flags, name, **kwargs))
-    acc.setPrivateTools(tool)
+    acc.merge(PassBackGeant4ToolCfg(flags, name, **kwargs))
     return acc
 
 
 def LongLivedGeant4ToolCfg(flags, name="ISF_LongLivedGeant4Tool", **kwargs):
     acc = LongLivedInputConverterCfg(flags)
     kwargs.setdefault("InputConverter", acc.getService("ISF_LongLivedInputConverter"))
-    tool = acc.popToolsAndMerge(FullGeant4ToolCfg(flags, name, **kwargs))
-    acc.setPrivateTools(tool)
+    acc.merge(FullGeant4ToolCfg(flags, name, **kwargs))
     return acc
 
 
 def AFII_QS_Geant4ToolCfg(flags, name="AFII_QS_Geant4Tool", **kwargs):
     acc = LongLivedInputConverterCfg(flags)
     kwargs.setdefault("InputConverter", acc.getService("ISF_LongLivedInputConverter"))
-    tool = acc.popToolsAndMerge(AFIIGeant4ToolCfg(flags, name, **kwargs))
-    acc.setPrivateTools(tool)
+    acc.merge(AFIIGeant4ToolCfg(flags, name, **kwargs))
     return acc

Simulation/ISF/ISF_SimulationSelectors/src/BaseSimulationSelector.cxx

@@ -11,7 +11,7 @@
 /** Constructor with parameters */
 ISF::BaseSimulationSelector::BaseSimulationSelector(const std::string& type, const std::string& name, const IInterface* parent) :
   base_class(type, name, parent),
-  m_simulator("DefaultSimulator", name),
+  m_simulator("", name),
   m_isDynamic(false),
   m_invertCuts(false)
 {
@@ -44,7 +44,10 @@ void ISF::BaseSimulationSelector::SimulationFlavorHandler(Gaudi::Details::Proper
 StatusCode ISF::BaseSimulationSelector::sysInitialize()
 {
   ATH_CHECK( AthAlgTool::sysInitialize() );
-  ATH_CHECK( m_simulator.retrieve() );
+
+  if (!m_simulator.empty()) {
+    ATH_CHECK( m_simulator.retrieve() );
+  }
 
   return StatusCode::SUCCESS;
 }