G4AtlasToolsConfig Namespace Reference

Functions
	FastSimulationToolListCfg (flags)
	G4ThreadPoolSvcCfg (flags)
	FastSimulationMasterToolCfg (flags, **kwargs)
	FastSimulationConstructorToolCfg (flags, **kwargs)
	EmptyFastSimulationMasterToolCfg (flags, **kwargs)
	G4CaloTransportToolCfg (flags, name='G4CaloTransportTool', **kwargs)
	ActsFatrasG4ToolCfg (flags, name="ActsFatrasG4Tool", **kwargs)
	PunchThroughG4ClassifierCfg (flags, name="PunchThroughG4Classifier", **kwargs)
	PunchThroughG4ToolCfg (flags, name='PunchThroughG4Tool', **kwargs)
	PunchThroughSimWrapperCfg (flags, name='PunchThroughSimWrapper', **kwargs)
	FwdSensitiveDetectorListCfg (flags)
	TrackFastSimSensitiveDetectorListCfg (flags)
	CaloCellContainerSensitiveDetectorListCfg (flags)
	ITkSensitiveDetectorListCfg (flags)
	HGTDSensitiveDetectorListCfg (flags)
	InDetSensitiveDetectorListCfg (flags)
	CaloSensitiveDetectorListCfg (flags)
	MuonSensitiveDetectorListCfg (flags)
	EnvelopeSensitiveDetectorListCfg (flags)
	SimHitContainerListCfg (flags)
	InputContainerListCfg (flags)
	SensitiveDetectorListCfg (flags)
	TileTestBeamSensitiveDetectorListCfg (flags)
	CombinedTestBeamSensitiveDetectorListCfg (flags)
	SensitiveDetectorMasterToolCfg (flags, name="SensitiveDetectorMasterTool", **kwargs)
	EmptySensitiveDetectorMasterToolCfg (name="EmptySensitiveDetectorMasterTool", **kwargs)

Function Documentation

ActsFatrasG4ToolCfg()

ActsFatrasG4ToolCfg	(		flags,
			name = "ActsFatrasG4Tool",
		**	kwargs )

Definition at line 118 of file G4AtlasToolsConfig.py.

def ActsFatrasG4ToolCfg(flags, name="ActsFatrasG4Tool", **kwargs):
    # Use rules below to decide how to retrieve dependencies for this tool:
    # Private tool              popToolsAndMerge()
    # Primary component         getPrimaryAndMerge()
    # Plain alg/service/cond alg    merge()
 
    # declare component accumulator
    result = ComponentAccumulator()
    from AthenaCommon.Logging import logging
    mlog = logging.getLogger(name)
    mlog.info('Start configuration of ActsFatrasG4Tool')
 
    # other arguments
    # see: ActsExtrapolationToolCfg in ActsConfig/python/ActsGeometryConfig.py for example 
    # --- Schedule magnetic field conditions alg properly ---
    from MagFieldServices.MagFieldServicesConfig import AtlasFieldCacheCondAlgCfg
    result.merge(AtlasFieldCacheCondAlgCfg(flags))
    
    # Tracking geometry
    from ActsConfig.ActsGeometryConfig import ActsTrackingGeometrySvcCfg
    result.merge(ActsTrackingGeometrySvcCfg(flags))
 
    from ActsAlignmentAlgs.AlignmentAlgsConfig import ActsGeometryContextAlgCfg
    result.merge(ActsGeometryContextAlgCfg(flags)) 
 
    kwargs.setdefault("MaxSteps", 2000)
    # always set to false, only for debugging purpose
    kwargs.setdefault("DebugInjectParticle", flags.Sim.ActsFatrasG4.DebugInjectParticle)
 
    # RNG service
    from RngComps.RngCompsConfig import AthRNGSvcCfg
    kwargs.setdefault(
        "RNGService",
        result.getPrimaryAndMerge(AthRNGSvcCfg(flags))
    )
 
    # create the tool 
    tool = CompFactory.ActsFatrasG4Tool(name, **kwargs)
    # set as private tool
    result.setPrivateTools(tool)
 
    return result
 

CaloCellContainerSensitiveDetectorListCfg()

CaloCellContainerSensitiveDetectorListCfg

(

flags

)

Definition at line 248 of file G4AtlasToolsConfig.py.

def CaloCellContainerSensitiveDetectorListCfg(flags):
    result = ComponentAccumulator()
    tools = []
    if flags.Sim.LArParameterization is LArParameterization.FastCaloSim:
        from ISF_FastCaloSimParametrization.ISF_FastCaloSimParametrizationConfig import CaloCellContainerSDCfg
        tools += [ result.popToolsAndMerge(CaloCellContainerSDCfg(flags)) ]
    result.setPrivateTools(tools)
    return result
 

CaloSensitiveDetectorListCfg()

CaloSensitiveDetectorListCfg

(

flags

)

Definition at line 312 of file G4AtlasToolsConfig.py.

def CaloSensitiveDetectorListCfg(flags):
    result = ComponentAccumulator()
    tools = []
 
    if flags.Detector.EnableLAr:
        from LArG4SD.LArG4SDToolConfig import LArEMBSensitiveDetectorCfg, LArEMECSensitiveDetectorCfg, LArFCALSensitiveDetectorCfg, LArHECSensitiveDetectorCfg
        tools += [ result.popToolsAndMerge(LArEMBSensitiveDetectorCfg(flags)) ]
        tools += [ result.popToolsAndMerge(LArEMECSensitiveDetectorCfg(flags)) ]
        tools += [ result.popToolsAndMerge(LArFCALSensitiveDetectorCfg(flags)) ]
        tools += [ result.popToolsAndMerge(LArHECSensitiveDetectorCfg(flags)) ]
        
        if flags.Detector.EnableMBTS:
            from MinBiasScintillator.MinBiasScintillatorToolConfig import MinBiasScintillatorSDCfg
            tools += [ result.popToolsAndMerge(MinBiasScintillatorSDCfg(flags)) ]
 
        if flags.Sim.CalibrationRun in [CalibrationRun.LAr, CalibrationRun.LArTile, CalibrationRun.LArTileZDC]:
            from LArG4SD.LArG4SDToolConfig import LArDeadSensitiveDetectorToolCfg, LArActiveSensitiveDetectorToolCfg, LArInactiveSensitiveDetectorToolCfg
            tools += [ result.popToolsAndMerge(LArDeadSensitiveDetectorToolCfg(flags)) ]
            tools += [ result.popToolsAndMerge(LArInactiveSensitiveDetectorToolCfg(flags)) ]
            tools += [ result.popToolsAndMerge(LArActiveSensitiveDetectorToolCfg(flags)) ]
        elif flags.Sim.CalibrationRun is CalibrationRun.DeadLAr:
            from LArG4SD.LArG4SDToolConfig import LArDeadSensitiveDetectorToolCfg
            tools += [ result.popToolsAndMerge(LArDeadSensitiveDetectorToolCfg(flags)) ]
 
    if flags.Detector.EnableTile:
        if flags.Sim.CalibrationRun in [CalibrationRun.Tile, CalibrationRun.LArTile, CalibrationRun.LArTileZDC]:
            from TileGeoG4Calib.TileGeoG4CalibConfig import TileGeoG4CalibSDCfg
            tools += [ result.popToolsAndMerge(TileGeoG4CalibSDCfg(flags)) ]  # mode 1 : With CaloCalibrationHits
        else:
            from TileGeoG4SD.TileGeoG4SDToolConfig import TileGeoG4SDCfg
            tools += [ result.popToolsAndMerge(TileGeoG4SDCfg(flags)) ]       # mode 0 : No CaloCalibrationHits
    if flags.Sim.RecordStepInfo:
        from ISF_FastCaloSimSD.ISF_FastCaloSimSDToolConfig import FCS_StepInfoSDToolCfg
        tools += [ result.popToolsAndMerge(FCS_StepInfoSDToolCfg(flags)) ]
 
    result.setPrivateTools(tools)
    return result
 
 

CombinedTestBeamSensitiveDetectorListCfg()

CombinedTestBeamSensitiveDetectorListCfg

(

flags

)

Definition at line 513 of file G4AtlasToolsConfig.py.

def CombinedTestBeamSensitiveDetectorListCfg(flags):
    result = ComponentAccumulator()
    tools = []
    if flags.Detector.EnablePixel:
        from PixelG4_SD.PixelG4_SDToolConfig import PixelSensor_CTBCfg
        tools += [ result.popToolsAndMerge(PixelSensor_CTBCfg(flags)) ]
    if flags.Detector.EnableSCT:
        from SCT_G4_SD.SCT_G4_SDToolConfig import SctSensor_CTBCfg
        tools += [ result.popToolsAndMerge(SctSensor_CTBCfg(flags)) ]
    if flags.Detector.EnableTRT:
        from TRT_G4_SD.TRT_G4_SDToolConfig import TRTSensitiveDetector_CTBCfg
        tools += [ result.popToolsAndMerge(TRTSensitiveDetector_CTBCfg(flags)) ]
    if flags.Detector.EnableLAr:
        from LArG4SD.LArG4SDToolConfig import LArEMBSensitiveDetectorCfg
        tools += [ result.popToolsAndMerge(LArEMBSensitiveDetectorCfg(flags)) ]
        if flags.Sim.CalibrationRun in [CalibrationRun.LAr, CalibrationRun.LArTile, CalibrationRun.LArTileZDC, CalibrationRun.DeadLAr]:
            tools += [ 'LArH8CalibSensitiveDetector' ] # mode 1 : With CaloCalibrationHits
    if flags.Detector.EnableTile:
        if flags.Sim.CalibrationRun in [CalibrationRun.Tile, CalibrationRun.LArTile, CalibrationRun.LArTileZDC]:
            from TileGeoG4Calib.TileGeoG4CalibConfig import TileCTBGeoG4CalibSDCfg
            tools += [ result.popToolsAndMerge(TileCTBGeoG4CalibSDCfg(flags)) ] # mode 1 : With CaloCalibrationHits
        else:
            from TileGeoG4SD.TileGeoG4SDToolConfig import TileCTBGeoG4SDCfg
            tools += [ result.popToolsAndMerge(TileCTBGeoG4SDCfg(flags)) ]      # mode 0 : No CaloCalibrationHits
            tools += [ 'MuonWallSD' ]
    if flags.Detector.EnableMuon:
        tools += [ 'MuonEntryRecord' ]
    tools += result.popToolsAndMerge(MuonSensitiveDetectorListCfg(flags))
 
    result.setPrivateTools(tools)
    return result
 
 

EmptyFastSimulationMasterToolCfg()

EmptyFastSimulationMasterToolCfg	(		flags,
		**	kwargs )

Definition at line 90 of file G4AtlasToolsConfig.py.

def EmptyFastSimulationMasterToolCfg(flags, **kwargs):
    result = ComponentAccumulator()
    FastSimulationMasterTool = CompFactory.FastSimulationMasterTool
    tool = result.popToolsAndMerge(FastSimulationMasterTool(name="EmptyFastSimulationMasterTool", **kwargs))
    result.setPrivateTools(tool)
    return result
 

EmptySensitiveDetectorMasterToolCfg()

EmptySensitiveDetectorMasterToolCfg	(		name = "EmptySensitiveDetectorMasterTool",
		**	kwargs )

Definition at line 562 of file G4AtlasToolsConfig.py.

def EmptySensitiveDetectorMasterToolCfg(name="EmptySensitiveDetectorMasterTool", **kwargs):
    result = ComponentAccumulator()
    tool = result.popToolsAndMerge(CompFactory.SensitiveDetectorMasterTool(name, **kwargs))
    result.setPrivateTools(tool)
    return result

EnvelopeSensitiveDetectorListCfg()

EnvelopeSensitiveDetectorListCfg

(

flags

)

Definition at line 358 of file G4AtlasToolsConfig.py.

def EnvelopeSensitiveDetectorListCfg(flags):
    result = ComponentAccumulator()
    tools = []
    if flags.Beam.Type is BeamType.Cosmics and not flags.Sim.ReadTR:
        from TrackWriteFastSim.TrackWriteFastSimConfig import CosmicTRSDCfg
        tools += [ result.popToolsAndMerge(CosmicTRSDCfg(flags)) ]
    result.setPrivateTools(tools)
    return result
 
 

FastSimulationConstructorToolCfg()

FastSimulationConstructorToolCfg	(		flags,
		**	kwargs )

Definition at line 83 of file G4AtlasToolsConfig.py.

def FastSimulationConstructorToolCfg(flags, **kwargs):
    result = ComponentAccumulator()
    FastSimulationConstructorTool = CompFactory.FastSimulationConstructorTool
    result.setPrivateTools(FastSimulationConstructorTool(name="FastSimulationConstructorTool", **kwargs))
    return result
 
 

FastSimulationMasterToolCfg()

FastSimulationMasterToolCfg	(		flags,
		**	kwargs )

Definition at line 75 of file G4AtlasToolsConfig.py.

def FastSimulationMasterToolCfg(flags, **kwargs):
    result = ComponentAccumulator()
    kwargs.setdefault("FastSimulations", result.popToolsAndMerge(FastSimulationToolListCfg(flags)))
    FastSimulationMasterTool = CompFactory.FastSimulationMasterTool
    result.setPrivateTools(FastSimulationMasterTool(name="FastSimulationMasterTool", **kwargs))
    return result
 
 

FastSimulationToolListCfg()

FastSimulationToolListCfg

(

flags

)

Definition at line 11 of file G4AtlasToolsConfig.py.

def FastSimulationToolListCfg(flags):
    result = ComponentAccumulator()
    tools = []
    if flags.Sim.LArParameterization is LArParameterization.FastCaloSim:
        from G4FastSimulation.G4FastSimulationConfig import FastCaloSimCfg
        tools += [ result.popToolsAndMerge(FastCaloSimCfg(flags)) ]
 
    if flags.Sim.InDetParameterization is InDetParameterization.FatrasG4:
        from G4FastSimulation.G4FastSimulationConfig import FatrasG4Cfg
        tools += [ result.popToolsAndMerge(FatrasG4Cfg(flags)) ]
 
    if flags.Sim.InDetParameterization is InDetParameterization.AFatrasG4:
        from G4FastSimulation.G4FastSimulationConfig import AFatrasG4Cfg
        tools += [ result.popToolsAndMerge(AFatrasG4Cfg(flags)) ]    
 
    if flags.Detector.GeometryBpipe:
        if  not flags.Detector.GeometryFwdRegion and (flags.Detector.GeometryAFP or flags.Detector.GeometryALFA or flags.Detector.GeometryZDC):
            # equivalent of simFlags.ForwardDetectors() == 2:
            from ForwardTransport.ForwardTransportConfig import ForwardTransportModelCfg
            tools += [ result.popToolsAndMerge(ForwardTransportModelCfg(flags)) ]
        if flags.Sim.BeamPipeSimMode is not BeamPipeSimMode.Normal:
            from G4FastSimulation.G4FastSimulationConfig import SimpleFastKillerCfg
            tools += [ result.popToolsAndMerge(SimpleFastKillerCfg(flags)) ]
    if flags.Detector.GeometryLAr:
        if flags.Sim.LArParameterization is LArParameterization.NoFrozenShowers:
            from AthenaCommon.Logging import logging
            msg = logging.getLogger("FastSimulationToolListCfg")
            msg.info( "Not using Frozen Showers" )
        else:
            from LArG4FastSimulation.LArG4FastSimulationConfig import EMBFastShowerCfg, EMECFastShowerCfg, FCALFastShowerCfg, FCAL2FastShowerCfg
            # We run production with LArParameterization.FrozenShowersFCalOnly, so the EMB and EMEC tools are not required
            if flags.Sim.LArParameterization is LArParameterization.FrozenShowers:
                tools += [ result.popToolsAndMerge(EMBFastShowerCfg(flags)) ]
                tools += [ result.popToolsAndMerge(EMECFastShowerCfg(flags)) ]
            tools += [ result.popToolsAndMerge(FCALFastShowerCfg(flags)) ]
            tools += [ result.popToolsAndMerge(FCAL2FastShowerCfg(flags)) ]
            if flags.Sim.LArParameterization in [LArParameterization.DeadMaterialFrozenShowers, LArParameterization.FrozenShowersFCalOnly, LArParameterization.FastCaloSim]: # TODO Check this makes sense.
                from G4FastSimulation.G4FastSimulationConfig import DeadMaterialShowerCfg
                tools += [ result.popToolsAndMerge(DeadMaterialShowerCfg(flags)) ]
            # Enable fast simulation of the calorimeter with FastCaloSim
            if flags.Sim.LArParameterization is LArParameterization.FastCaloSim:
                from G4FastSimulation.G4FastSimulationConfig import FastCaloSimCfg
                tools += [ result.popToolsAndMerge(FastCaloSimCfg(flags)) ]
    if flags.Detector.GeometryMuon:
        if flags.Sim.CavernBackground not in [CavernBackground.Off, CavernBackground.Read] and not flags.Sim.RecordFlux:
            from TrackWriteFastSim.TrackWriteFastSimConfig import NeutronFastSimCfg
            tools += [ result.popToolsAndMerge(NeutronFastSimCfg(flags)) ]
 
    from G4AtlasServices.G4AtlasServicesConfig import PhysicsListSvcCfg
    result.merge(PhysicsListSvcCfg(flags))
    result.getService("PhysicsListSvc").FastSimConstructor.InitializeFastSimulation = len(tools) > 0
 
    result.setPrivateTools(tools)
    return result
 

FwdSensitiveDetectorListCfg()

FwdSensitiveDetectorListCfg

(

flags

)

Definition at line 211 of file G4AtlasToolsConfig.py.

def FwdSensitiveDetectorListCfg(flags):
    # TODO: migrate to CA
    result = ComponentAccumulator()
    tools = []
    if flags.Detector.EnableLucid:
        from LUCID_G4_SD.LUCID_G4_SDConfig import LUCID_SensitiveDetectorCfg
        tools += [ result.popToolsAndMerge(LUCID_SensitiveDetectorCfg(flags)) ]
    if flags.Detector.EnableForward:
        if flags.Detector.EnableZDC:
            from ZDC_SD.ZDC_SDConfig import ZDC_FiberSDCfg
            tools += [ result.popToolsAndMerge(ZDC_FiberSDCfg(flags)) ]
            if flags.Sim.CalibrationRun in [CalibrationRun.ZDC, CalibrationRun.LArTileZDC]:
                from ZDC_SD.ZDC_SDConfig import ZDC_G4CalibSDCfg
                tools += [ result.popToolsAndMerge(ZDC_G4CalibSDCfg(flags)) ]
        if flags.Detector.EnableALFA:
            from ALFA_G4_SD.ALFA_G4_SDConfig import ALFA_SensitiveDetectorCfg
            tools += [ result.popToolsAndMerge(ALFA_SensitiveDetectorCfg(flags)) ]
        if flags.Detector.EnableAFP:
            from AFP_G4_SD.AFP_G4_SDConfig import AFP_SensitiveDetectorCfg
            tools += [ result.popToolsAndMerge(AFP_SensitiveDetectorCfg(flags)) ]
            # Alternative implementations
            # from AFP_G4_SD.AFP_G4_SDConfig import AFP_SiDSensitiveDetectorCfg, AFP_TDSensitiveDetectorCfg
            # tools += [ result.popToolsAndMerge(AFP_SiDSensitiveDetectorCfg(flags)) ]
            # tools += [ result.popToolsAndMerge(AFP_TDSensitiveDetectorCfg(flags)) ]
    result.setPrivateTools(tools)
    return result
 
 

G4CaloTransportToolCfg()

G4CaloTransportToolCfg	(		flags,
			name = 'G4CaloTransportTool',
		**	kwargs )

Definition at line 97 of file G4AtlasToolsConfig.py.

def G4CaloTransportToolCfg(flags, name='G4CaloTransportTool', **kwargs):
    result = ComponentAccumulator()
    # Use simplified calorimeter geometry if path to simplified geometry is provided
    # Otherwise, use the full geometry for the transport (Note that this will be very slow) 
    kwargs.setdefault("UseSimplifiedGeo", bool(flags.Sim.SimplifiedGeoPath))
    if flags.Sim.SimplifiedGeoPath:
        # What is the name of the logical world volume of the simplified geometry?
        kwargs.setdefault('SimplifiedWorldLogName', "WorldLog")
        # At what volume will we stop the transport?
        kwargs.setdefault('TransportLimitVolume', "Envelope")
        # What is the maximum number of Geant4 steps taken in the transport?
        kwargs.setdefault('MaxSteps', 100)
    else:
        # At what volume will be stop the transport? 
        kwargs.setdefault('TransportLimitVolume', "MuonSys")
        # What is the maximum number of Geant4 steps taken in the transport?
        kwargs.setdefault('MaxSteps', 5000)
    
    result.setPrivateTools(CompFactory.G4CaloTransportTool(name, **kwargs))
    return result
 

G4ThreadPoolSvcCfg()

G4ThreadPoolSvcCfg

(

flags

)

Definition at line 66 of file G4AtlasToolsConfig.py.

def G4ThreadPoolSvcCfg(flags):
    acc = ComponentAccumulator()
 
    svc = CompFactory.ThreadPoolSvc(name="ThreadPoolSvc")
    svc.ThreadInitTools += [CompFactory.G4ThreadInitTool()]
 
    acc.addService(svc)
    return acc
 

HGTDSensitiveDetectorListCfg()

HGTDSensitiveDetectorListCfg

(

flags

)

Definition at line 276 of file G4AtlasToolsConfig.py.

def HGTDSensitiveDetectorListCfg(flags):
    result = ComponentAccumulator()
    tools = []
 
    if flags.Detector.EnableHGTD:
        from HGTD_G4_SD.HGTD_G4_SDToolConfig import HgtdSensorSDCfg
        tools += [ result.popToolsAndMerge(HgtdSensorSDCfg(flags)) ]
        pass
 
    result.setPrivateTools(tools)
    return result
 
 

InDetSensitiveDetectorListCfg()

InDetSensitiveDetectorListCfg

(

flags

)

Definition at line 289 of file G4AtlasToolsConfig.py.

def InDetSensitiveDetectorListCfg(flags):
    result = ComponentAccumulator()
    tools = []
 
    if flags.Detector.EnablePixel:
        from PixelG4_SD.PixelG4_SDToolConfig import PixelSensorSDCfg
        tools += [ result.popToolsAndMerge(PixelSensorSDCfg(flags)) ]
    if flags.Detector.EnableSCT:
        from SCT_G4_SD.SCT_G4_SDToolConfig import SctSensorSDCfg
        tools += [ result.popToolsAndMerge(SctSensorSDCfg(flags)) ]
    if flags.Detector.EnableTRT:
        from TRT_G4_SD.TRT_G4_SDToolConfig import TRTSensitiveDetectorCfg
        tools += [ result.popToolsAndMerge(TRTSensitiveDetectorCfg(flags)) ]
    if flags.Detector.EnableBCM:
        from BCM_G4_SD.BCM_G4_SDToolConfig import BCMSensorSDCfg
        tools += [ result.popToolsAndMerge(BCMSensorSDCfg(flags)) ]
        from BLM_G4_SD.BLM_G4_SDToolConfig import BLMSensorSDCfg
        tools += [ result.popToolsAndMerge(BLMSensorSDCfg(flags)) ]
 
    result.setPrivateTools(tools)
    return result
 
 

InputContainerListCfg()

InputContainerListCfg

(

flags

)

Definition at line 468 of file G4AtlasToolsConfig.py.

def InputContainerListCfg(flags):
    dependencies = []
    from SimulationConfig.SimEnums import LArParameterization
    if flags.Sim.LArParameterization is LArParameterization.FastCaloSim:
        dependencies+=[('CaloDetDescrManager', 'ConditionStore+CaloDetDescrManager'),
                       ('LArfSamplSym', 'ConditionStore+LArfSamplSym'),
                       ('TileSamplingFraction', 'ConditionStore+TileSamplingFraction')]
    from MuonSensitiveDetectorsR4.SensitiveDetectorsCfg import MuonDependenciesCfg
    dependencies += MuonDependenciesCfg(flags)
    return dependencies
 

ITkSensitiveDetectorListCfg()

ITkSensitiveDetectorListCfg

(

flags

)

Definition at line 257 of file G4AtlasToolsConfig.py.

def ITkSensitiveDetectorListCfg(flags):
    result = ComponentAccumulator()
    tools = []
 
    if flags.Detector.EnableITkPixel:
        from PixelG4_SD.PixelG4_SDToolConfig import ITkPixelSensorSDCfg
        tools += [ result.popToolsAndMerge(ITkPixelSensorSDCfg(flags)) ]
        pass
    if flags.Detector.EnableITkStrip:
        from SCT_G4_SD.SCT_G4_SDToolConfig import ITkStripSensorSDCfg
        tools += [ result.popToolsAndMerge(ITkStripSensorSDCfg(flags)) ]
    if flags.Detector.EnablePLR:
        from PixelG4_SD.PixelG4_SDToolConfig import PLRSensorSDCfg
        tools += [ result.popToolsAndMerge(PLRSensorSDCfg(flags)) ]
    
    result.setPrivateTools(tools)
    return result
 
 

MuonSensitiveDetectorListCfg()

MuonSensitiveDetectorListCfg

(

flags

)

Definition at line 351 of file G4AtlasToolsConfig.py.

def MuonSensitiveDetectorListCfg(flags):
    if flags.Muon.usePhaseIIGeoSetup:
        from MuonSensitiveDetectorsR4.SensitiveDetectorsCfg import SetupSensitiveDetectorsCfg
        return SetupSensitiveDetectorsCfg(flags)
    from MuonG4SD.MuonG4SDConfig import SetupSensitiveDetectorsCfg
    return SetupSensitiveDetectorsCfg(flags)   
 

PunchThroughG4ClassifierCfg()

PunchThroughG4ClassifierCfg	(		flags,
			name = "PunchThroughG4Classifier",
		**	kwargs )

Definition at line 161 of file G4AtlasToolsConfig.py.

def PunchThroughG4ClassifierCfg(flags, name="PunchThroughG4Classifier", **kwargs):
    # declare component accumulator
    result = ComponentAccumulator()
    # other arguments
    kwargs.setdefault("ScalerConfigFileName"        , "FastCaloSim/MC23/TFCSparam_mpt_classScaler_v04.xml" )
    kwargs.setdefault("NetworkConfigFileName"       , "FastCaloSim/MC23/TFCSparam_mpt_classNet_v04.json" )
    kwargs.setdefault("CalibratorConfigFileName"    , "FastCaloSim/MC23/TFCSparam_mpt_classCalib_v04.xml")
    # set as private tool
    result.setPrivateTools(CompFactory.PunchThroughG4Classifier(name, **kwargs))
    return result
 

PunchThroughG4ToolCfg()

PunchThroughG4ToolCfg	(		flags,
			name = 'PunchThroughG4Tool',
		**	kwargs )

Definition at line 172 of file G4AtlasToolsConfig.py.

def PunchThroughG4ToolCfg(flags, name='PunchThroughG4Tool', **kwargs):
    # get the envelope config
    from SubDetectorEnvelopes.SubDetectorEnvelopesConfig import EnvelopeDefSvcCfg
    # declare component accumulator
    result = ComponentAccumulator()
    # other arguments
    kwargs.setdefault("FilenameLookupTable"     , "FastCaloSim/MC23/TFCSparam_mpt_v07.root")
    kwargs.setdefault("FilenameInverseCdf"      , "FastCaloSim/MC23/TFCSparam_mpt_inverseCdf_v07.xml")
    kwargs.setdefault("FilenameInversePca"      , "FastCaloSim/MC23/TFCSparam_mpt_inversePca_v07.xml")
    kwargs.setdefault("EnergyFactor"            , [ 0.98,  0.831, 0.896, 0.652, 0.717, 1., 0.877, 0.858, 0.919 ]    )
    kwargs.setdefault("DoAntiParticles"         , [ 0,   1,    0,     1,     1,     0,   0,    0,    0 ]    )
    kwargs.setdefault("PunchThroughInitiators"  , [ 211, 321, 311, 310, 130, 2212, 2112]        )
    kwargs.setdefault("InitiatorsMinEnergy"     , [ 65536, 65536, 65536, 65536, 65536, 65536, 65536]                                         )
    kwargs.setdefault("InitiatorsEtaRange"      , [ -3.2,   3.2 ]                               )
    kwargs.setdefault("PunchThroughParticles"   , [ 2212,   211,    22,     11,     13,     2112,   321,    310,    130 ]    )
    kwargs.setdefault("CorrelatedParticle"      , []    )
    kwargs.setdefault("FullCorrelationEnergy"   , [ 100000., 100000., 100000., 100000.,      0., 100000., 100000., 100000., 100000.]    )
    kwargs.setdefault("MinEnergy"               , [   938.3,   135.6,     50.,     50.,   105.7,   939.6, 493.7,   497.6,   497.6 ]    )
    kwargs.setdefault("MaxNumParticles"         , [      -1,      -1,      -1,      -1,      -1,    -1,     -1,     -1,     -1 ]    )
    kwargs.setdefault("EnvelopeDefSvc",         result.getPrimaryAndMerge(EnvelopeDefSvcCfg(flags)))
    kwargs.setdefault("BeamPipeRadius", 500.)
    # set as private tool
    result.setPrivateTools(CompFactory.PunchThroughG4Tool(name, **kwargs))
    return result
    

PunchThroughSimWrapperCfg()

PunchThroughSimWrapperCfg	(		flags,
			name = 'PunchThroughSimWrapper',
		**	kwargs )

Definition at line 197 of file G4AtlasToolsConfig.py.

def PunchThroughSimWrapperCfg(flags, name='PunchThroughSimWrapper', **kwargs):
    result = ComponentAccumulator()
 
    # Set the PunchThroughG4Classifier
    if "PunchThroughG4Classifier" not in kwargs:
        kwargs.setdefault("PunchThroughG4Classifier", result.addPublicTool(result.popToolsAndMerge(PunchThroughG4ClassifierCfg(flags))))
    
    # Set the PunchThroughG4Tool
    if "PunchThroughG4Tool" not in kwargs:
        kwargs.setdefault("PunchThroughG4Tool", result.addPublicTool(result.popToolsAndMerge(PunchThroughG4ToolCfg(flags))))
 
    result.setPrivateTools(CompFactory.PunchThroughSimWrapper(name, **kwargs))
    return result
 

SensitiveDetectorListCfg()

SensitiveDetectorListCfg

(

flags

)

Definition at line 479 of file G4AtlasToolsConfig.py.

def SensitiveDetectorListCfg(flags):
    result = ComponentAccumulator()
    tools = []
    tools += result.popToolsAndMerge(EnvelopeSensitiveDetectorListCfg(flags))
    tools += result.popToolsAndMerge(InDetSensitiveDetectorListCfg(flags))
    tools += result.popToolsAndMerge(ITkSensitiveDetectorListCfg(flags))
    tools += result.popToolsAndMerge(HGTDSensitiveDetectorListCfg(flags))
    tools += result.popToolsAndMerge(CaloSensitiveDetectorListCfg(flags))
    tools += result.popToolsAndMerge(MuonSensitiveDetectorListCfg(flags))
    tools += result.popToolsAndMerge(TrackFastSimSensitiveDetectorListCfg(flags))
    tools += result.popToolsAndMerge(FwdSensitiveDetectorListCfg(flags))
    tools += result.popToolsAndMerge(CaloCellContainerSensitiveDetectorListCfg(flags))
 
    result.setPrivateTools(tools)
    return result
 
 

SensitiveDetectorMasterToolCfg()

SensitiveDetectorMasterToolCfg	(		flags,
			name = "SensitiveDetectorMasterTool",
		**	kwargs )

Definition at line 546 of file G4AtlasToolsConfig.py.

def SensitiveDetectorMasterToolCfg(flags, name="SensitiveDetectorMasterTool", **kwargs):
    result = ComponentAccumulator()
    # NB Currently only supporting the standard ATLAS dector and the Tile Test Beam
    if flags.Beam.Type is BeamType.TestBeam:
        kwargs.setdefault("SensitiveDetectors", result.popToolsAndMerge(TileTestBeamSensitiveDetectorListCfg(flags)))
    elif "tb_LArH6" in flags.GeoModel.AtlasVersion:
        pass
    elif "ctbh8" in flags.GeoModel.AtlasVersion:
        kwargs.setdefault("SensitiveDetectors", result.popToolsAndMerge(CombinedTestBeamSensitiveDetectorListCfg(flags)))
    else:
        kwargs.setdefault("SensitiveDetectors", result.popToolsAndMerge(SensitiveDetectorListCfg(flags)))
 
    result.setPrivateTools(CompFactory.SensitiveDetectorMasterTool(name, **kwargs))
    return result
 
 

SimHitContainerListCfg()

SimHitContainerListCfg

(

flags

)

Definition at line 368 of file G4AtlasToolsConfig.py.

def SimHitContainerListCfg(flags):
    from SimulationConfig.SimEnums import LArParameterization
    writtenContainers =[]
    if flags.Detector.GeometryMuon:
        if flags.Muon.usePhaseIIGeoSetup:
            from MuonSensitiveDetectorsR4.SensitiveDetectorsCfg import SimHitContainerListCfg
            writtenContainers+= SimHitContainerListCfg(flags)
        else:
            from MuonG4SD.MuonG4SDConfig import SimHitContainerListCfg
            writtenContainers += SimHitContainerListCfg(flags)
    if flags.Detector.GeometryLAr:
        if (flags.Sim.ISFRun and flags.Sim.ISF.HITSMergingRequired.get('CALO', True)) or flags.Sim.LArParameterization is LArParameterization.FastCaloSim:
            writtenContainers += [("LArHitContainer", "LArHitEMB_G4")]
            writtenContainers += [("LArHitContainer", "LArHitEMEC_G4")]
            writtenContainers += [("LArHitContainer", "LArHitFCAL_G4")]
            writtenContainers += [("LArHitContainer", "LArHitHEC_G4")]
            if flags.Sim.LArParameterization is LArParameterization.FastCaloSim:
                writtenContainers += [("LArHitContainer" , "LArHitHEC_FastCaloSim")]
                writtenContainers += [("LArHitContainer" , "LArHitFCAL_FastCaloSim")]
                writtenContainers += [("LArHitContainer" , "LArHitEMEC_FastCaloSim")]
                writtenContainers += [("LArHitContainer" , "LArHitEMB_FastCaloSim")]
        else:
            writtenContainers += [("LArHitContainer", "LArHitEMB")]
            writtenContainers += [("LArHitContainer", "LArHitEMEC")]
            writtenContainers += [("LArHitContainer", "LArHitFCAL")]
            writtenContainers += [("LArHitContainer", "LArHitHEC")]
    if flags.Detector.GeometryTile:
        if (flags.Sim.ISFRun and flags.Sim.ISF.HITSMergingRequired.get('CALO', True)) or flags.Sim.LArParameterization is LArParameterization.FastCaloSim:
            writtenContainers += [("TileHitVector", "MBTSHits_G4")]
            writtenContainers += [("TileHitVector", "TileHitVec_G4")]
            if flags.Sim.LArParameterization is LArParameterization.FastCaloSim:
                writtenContainers += [("TileHitVector" , "TileHitVec_FastCaloSim")]
                writtenContainers += [("TileHitVector" , "MBTSHits_FastCaloSim")]
        else:
            writtenContainers += [("TileHitVector", "MBTSHits")]
            writtenContainers += [("TileHitVector", "TileHitVec")]
    if flags.Detector.GeometryTRT:
        if (flags.Sim.ISFRun and flags.Sim.ISF.HITSMergingRequired.get('ID', True)):
            writtenContainers += [("TRTUncompressedHitCollection", "TRTUncompressedHits_G4")]
        else:
            writtenContainers += [("TRTUncompressedHitCollection", "TRTUncompressedHits")]
    if flags.Detector.EnableBCM:
        if (flags.Sim.ISFRun and flags.Sim.ISF.HITSMergingRequired.get('ID', True)):
            writtenContainers += [("SiHitCollection", "BCMHits_G4")]
            writtenContainers += [("SiHitCollection", "BLMHits_G4")]
        else:
            writtenContainers += [("SiHitCollection", "BCMHits")]
            writtenContainers += [("SiHitCollection", "BLMHits")]
    if flags.Detector.EnablePixel:
        if (flags.Sim.ISFRun and flags.Sim.ISF.HITSMergingRequired.get('ID', True)):
            writtenContainers += [("SiHitCollection", "PixelHits_G4")]
            if flags.Sim.InDetParameterization in (
               InDetParameterization.FatrasG4,
               InDetParameterization.AFatrasG4,
            ):
             writtenContainers += [("SiHitCollection", "PixelHits_ActsFatrasG4")]
        else:
            writtenContainers += [("SiHitCollection", "PixelHits")]
    if flags.Detector.EnableSCT:
        if (flags.Sim.ISFRun and flags.Sim.ISF.HITSMergingRequired.get('ID', True)):
            writtenContainers += [("SiHitCollection", "SCT_Hits_G4")]
            if flags.Sim.InDetParameterization in (
               InDetParameterization.FatrasG4,
               InDetParameterization.AFatrasG4,
            ):
              writtenContainers += [("SiHitCollection" , "SCT_Hits_ActsFatrasG4")]
        else:
            writtenContainers += [("SiHitCollection", "SCT_Hits")]
    if flags.Detector.EnableITkPixel:
        if (flags.Sim.ISFRun and flags.Sim.ISF.HITSMergingRequired.get('ITk', True)):
            writtenContainers += [("SiHitCollection", "ITkPixelHits_G4")]
        else:
            writtenContainers += [("SiHitCollection", "ITkPixelHits")]
    if flags.Detector.EnableITkStrip:
        if (flags.Sim.ISFRun and flags.Sim.ISF.HITSMergingRequired.get('ITk', True)):
           writtenContainers += [("SiHitCollection", "ITkStripHits_G4")]
        else:
            writtenContainers += [("SiHitCollection", "ITkStripHits")]
    if flags.Detector.EnablePLR:
        if (flags.Sim.ISFRun and flags.Sim.ISF.HITSMergingRequired.get('ITk', True)):
            writtenContainers += [("SiHitCollection", "PLR_Hits_G4")]
        else:
            writtenContainers += [("SiHitCollection", "PLR_Hits")]
    if flags.Detector.EnableHGTD:
        if (flags.Sim.ISFRun and flags.Sim.ISF.HITSMergingRequired.get('ITk', True)):
            writtenContainers += [("SiHitCollection", "HGTDHits_G4")]
        else:
            writtenContainers += [("SiHitCollection", "HGTDHits")]
    from SimulationConfig.SimEnums import CalibrationRun
    if flags.Sim.CalibrationRun in [CalibrationRun.LAr, CalibrationRun.LArTile, CalibrationRun.LArTileZDC]:
        # Needed to ensure that DeadMaterialCalibrationHitsMerger is scheduled correctly.
        writtenContainers += [
            ( 'CaloCalibrationHitContainer' , 'StoreGateSvc+LArCalibrationHitActive_DEAD' ),
            ( 'CaloCalibrationHitContainer' , 'StoreGateSvc+LArCalibrationHitDeadMaterial_DEAD' ),
            ( 'CaloCalibrationHitContainer' , 'StoreGateSvc+LArCalibrationHitInactive_DEAD' )
        ]
 
    return writtenContainers
 
 

TileTestBeamSensitiveDetectorListCfg()

TileTestBeamSensitiveDetectorListCfg

(

flags

)

Definition at line 496 of file G4AtlasToolsConfig.py.

def TileTestBeamSensitiveDetectorListCfg(flags):
    result = ComponentAccumulator()
    tools = []
 
    if flags.Detector.EnableTile:
        if flags.Sim.CalibrationRun in [CalibrationRun.Tile, CalibrationRun.LArTile, CalibrationRun.LArTileZDC]:
            from TileGeoG4Calib.TileGeoG4CalibConfig import TileCTBGeoG4CalibSDCfg
            tools += [ result.popToolsAndMerge(TileCTBGeoG4CalibSDCfg(flags)) ] # mode 1 : With CaloCalibrationHits
        else:
            from TileGeoG4SD.TileGeoG4SDToolConfig import TileCTBGeoG4SDCfg
            tools += [ result.popToolsAndMerge(TileCTBGeoG4SDCfg(flags)) ]      # mode 0 : No CaloCalibrationHits
            from MuonWall.MuonWallConfig import MuonWallSDCfg
            tools += [ result.popToolsAndMerge(MuonWallSDCfg(flags)) ]
    result.setPrivateTools(tools)
    return result
 
 

TrackFastSimSensitiveDetectorListCfg()

TrackFastSimSensitiveDetectorListCfg

(

flags

)

Definition at line 239 of file G4AtlasToolsConfig.py.

def TrackFastSimSensitiveDetectorListCfg(flags):
    result = ComponentAccumulator()
    tools = []
    if (flags.Detector.EnableMuon and flags.Sim.CavernBackground in [CavernBackground.Write, CavernBackground.WriteWorld]) or flags.Sim.StoppedParticleFile:
        from TrackWriteFastSim.TrackWriteFastSimConfig import TrackFastSimSDCfg
        tools += [ result.popToolsAndMerge(TrackFastSimSDCfg(flags)) ]
    result.setPrivateTools(tools)
    return result