Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
Functions
G4AtlasToolsConfig Namespace Reference

Functions

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

Function Documentation

◆ CaloCellContainerSensitiveDetectorListCfg()

def G4AtlasToolsConfig.CaloCellContainerSensitiveDetectorListCfg (   flags)

Definition at line 176 of file G4AtlasToolsConfig.py.

176 def CaloCellContainerSensitiveDetectorListCfg(flags):
177  result = ComponentAccumulator()
178  tools = []
179  if flags.Sim.LArParameterization is LArParameterization.FastCaloSim:
180  from ISF_FastCaloSimParametrization.ISF_FastCaloSimParametrizationConfig import CaloCellContainerSDCfg
181  tools += [ result.popToolsAndMerge(CaloCellContainerSDCfg(flags)) ]
182  result.setPrivateTools(tools)
183  return result
184 

◆ CaloSensitiveDetectorListCfg()

def G4AtlasToolsConfig.CaloSensitiveDetectorListCfg (   flags)

Definition at line 240 of file G4AtlasToolsConfig.py.

240 def CaloSensitiveDetectorListCfg(flags):
241  result = ComponentAccumulator()
242  tools = []
243 
244  if flags.Detector.EnableLAr:
245  from LArG4SD.LArG4SDToolConfig import LArEMBSensitiveDetectorCfg, LArEMECSensitiveDetectorCfg, LArFCALSensitiveDetectorCfg, LArHECSensitiveDetectorCfg
246  tools += [ result.popToolsAndMerge(LArEMBSensitiveDetectorCfg(flags)) ]
247  tools += [ result.popToolsAndMerge(LArEMECSensitiveDetectorCfg(flags)) ]
248  tools += [ result.popToolsAndMerge(LArFCALSensitiveDetectorCfg(flags)) ]
249  tools += [ result.popToolsAndMerge(LArHECSensitiveDetectorCfg(flags)) ]
250 
251  if flags.Detector.EnableMBTS:
252  from MinBiasScintillator.MinBiasScintillatorToolConfig import MinBiasScintillatorSDCfg
253  tools += [ result.popToolsAndMerge(MinBiasScintillatorSDCfg(flags)) ]
254 
255  if flags.Sim.CalibrationRun in [CalibrationRun.LAr, CalibrationRun.LArTile, CalibrationRun.LArTileZDC]:
256  from LArG4SD.LArG4SDToolConfig import LArDeadSensitiveDetectorToolCfg, LArActiveSensitiveDetectorToolCfg, LArInactiveSensitiveDetectorToolCfg
257  tools += [ result.popToolsAndMerge(LArDeadSensitiveDetectorToolCfg(flags)) ]
258  tools += [ result.popToolsAndMerge(LArInactiveSensitiveDetectorToolCfg(flags)) ]
259  tools += [ result.popToolsAndMerge(LArActiveSensitiveDetectorToolCfg(flags)) ]
260  elif flags.Sim.CalibrationRun is CalibrationRun.DeadLAr:
261  from LArG4SD.LArG4SDToolConfig import LArDeadSensitiveDetectorToolCfg
262  tools += [ result.popToolsAndMerge(LArDeadSensitiveDetectorToolCfg(flags)) ]
263 
264  if flags.Detector.EnableTile:
265  if flags.Sim.CalibrationRun in [CalibrationRun.Tile, CalibrationRun.LArTile, CalibrationRun.LArTileZDC]:
266  from TileGeoG4Calib.TileGeoG4CalibConfig import TileGeoG4CalibSDCfg
267  tools += [ result.popToolsAndMerge(TileGeoG4CalibSDCfg(flags)) ] # mode 1 : With CaloCalibrationHits
268  else:
269  from TileGeoG4SD.TileGeoG4SDToolConfig import TileGeoG4SDCfg
270  tools += [ result.popToolsAndMerge(TileGeoG4SDCfg(flags)) ] # mode 0 : No CaloCalibrationHits
271  if flags.Sim.RecordStepInfo:
272  from ISF_FastCaloSimSD.ISF_FastCaloSimSDToolConfig import FCS_StepInfoSDToolCfg
273  tools += [ result.popToolsAndMerge(FCS_StepInfoSDToolCfg(flags)) ]
274 
275  result.setPrivateTools(tools)
276  return result
277 
278 

◆ CombinedTestBeamSensitiveDetectorListCfg()

def G4AtlasToolsConfig.CombinedTestBeamSensitiveDetectorListCfg (   flags)

Definition at line 431 of file G4AtlasToolsConfig.py.

431 def CombinedTestBeamSensitiveDetectorListCfg(flags):
432  result = ComponentAccumulator()
433  tools = []
434  if flags.Detector.EnablePixel:
435  from PixelG4_SD.PixelG4_SDToolConfig import PixelSensor_CTBCfg
436  tools += [ result.popToolsAndMerge(PixelSensor_CTBCfg(flags)) ]
437  if flags.Detector.EnableSCT:
438  from SCT_G4_SD.SCT_G4_SDToolConfig import SctSensor_CTBCfg
439  tools += [ result.popToolsAndMerge(SctSensor_CTBCfg(flags)) ]
440  if flags.Detector.EnableTRT:
441  from TRT_G4_SD.TRT_G4_SDToolConfig import TRTSensitiveDetector_CTBCfg
442  tools += [ result.popToolsAndMerge(TRTSensitiveDetector_CTBCfg(flags)) ]
443  if flags.Detector.EnableLAr:
444  from LArG4SD.LArG4SDToolConfig import LArEMBSensitiveDetectorCfg
445  tools += [ result.popToolsAndMerge(LArEMBSensitiveDetectorCfg(flags)) ]
446  if flags.Sim.CalibrationRun in [CalibrationRun.LAr, CalibrationRun.LArTile, CalibrationRun.LArTileZDC, CalibrationRun.DeadLAr]:
447  tools += [ 'LArH8CalibSensitiveDetector' ] # mode 1 : With CaloCalibrationHits
448  if flags.Detector.EnableTile:
449  if flags.Sim.CalibrationRun in [CalibrationRun.Tile, CalibrationRun.LArTile, CalibrationRun.LArTileZDC]:
450  from TileGeoG4Calib.TileGeoG4CalibConfig import TileCTBGeoG4CalibSDCfg
451  tools += [ result.popToolsAndMerge(TileCTBGeoG4CalibSDCfg(flags)) ] # mode 1 : With CaloCalibrationHits
452  else:
453  from TileGeoG4SD.TileGeoG4SDToolConfig import TileCTBGeoG4SDCfg
454  tools += [ result.popToolsAndMerge(TileCTBGeoG4SDCfg(flags)) ] # mode 0 : No CaloCalibrationHits
455  tools += [ 'MuonWallSD' ]
456  if flags.Detector.EnableMuon:
457  tools += [ 'MuonEntryRecord' ]
458  tools += result.popToolsAndMerge(MuonSensitiveDetectorListCfg(flags))
459 
460  result.setPrivateTools(tools)
461  return result
462 
463 

◆ EmptyFastSimulationMasterToolCfg()

def G4AtlasToolsConfig.EmptyFastSimulationMasterToolCfg (   flags,
**  kwargs 
)

Definition at line 61 of file G4AtlasToolsConfig.py.

61 def EmptyFastSimulationMasterToolCfg(flags, **kwargs):
62  result = ComponentAccumulator()
63  FastSimulationMasterTool = CompFactory.FastSimulationMasterTool
64  tool = result.popToolsAndMerge(FastSimulationMasterTool(name="EmptyFastSimulationMasterTool", **kwargs))
65  result.setPrivateTools(tool)
66  return result
67 

◆ EmptySensitiveDetectorMasterToolCfg()

def G4AtlasToolsConfig.EmptySensitiveDetectorMasterToolCfg (   name = "EmptySensitiveDetectorMasterTool",
**  kwargs 
)

Definition at line 480 of file G4AtlasToolsConfig.py.

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

◆ EnvelopeSensitiveDetectorListCfg()

def G4AtlasToolsConfig.EnvelopeSensitiveDetectorListCfg (   flags)

Definition at line 286 of file G4AtlasToolsConfig.py.

286 def EnvelopeSensitiveDetectorListCfg(flags):
287  result = ComponentAccumulator()
288  tools = []
289  if flags.Beam.Type is BeamType.Cosmics and not flags.Sim.ReadTR:
290  from TrackWriteFastSim.TrackWriteFastSimConfig import CosmicTRSDCfg
291  tools += [ result.popToolsAndMerge(CosmicTRSDCfg(flags)) ]
292  result.setPrivateTools(tools)
293  return result
294 
295 

◆ FastSimulationMasterToolCfg()

def G4AtlasToolsConfig.FastSimulationMasterToolCfg (   flags,
**  kwargs 
)

Definition at line 53 of file G4AtlasToolsConfig.py.

53 def FastSimulationMasterToolCfg(flags, **kwargs):
54  result = ComponentAccumulator()
55  kwargs.setdefault("FastSimulations", result.popToolsAndMerge(FastSimulationToolListCfg(flags)))
56  FastSimulationMasterTool = CompFactory.FastSimulationMasterTool
57  result.setPrivateTools(FastSimulationMasterTool(name="FastSimulationMasterTool", **kwargs))
58  return result
59 
60 

◆ FastSimulationToolListCfg()

def G4AtlasToolsConfig.FastSimulationToolListCfg (   flags)

Definition at line 10 of file G4AtlasToolsConfig.py.

10 def FastSimulationToolListCfg(flags):
11  result = ComponentAccumulator()
12  tools = []
13  if flags.Sim.LArParameterization is LArParameterization.FastCaloSim:
14  from G4FastSimulation.G4FastSimulationConfig import FastCaloSimCfg
15  tools += [ result.popToolsAndMerge(FastCaloSimCfg(flags)) ]
16 
17  if flags.Detector.GeometryBpipe:
18  if not flags.Detector.GeometryFwdRegion and (flags.Detector.GeometryAFP or flags.Detector.GeometryALFA or flags.Detector.GeometryZDC):
19  # equivalent of simFlags.ForwardDetectors() == 2:
20  from ForwardTransport.ForwardTransportConfig import ForwardTransportModelCfg
21  tools += [ result.popToolsAndMerge(ForwardTransportModelCfg(flags)) ]
22  if flags.Sim.BeamPipeSimMode is not BeamPipeSimMode.Normal:
23  from G4FastSimulation.G4FastSimulationConfig import SimpleFastKillerCfg
24  tools += [ result.popToolsAndMerge(SimpleFastKillerCfg(flags)) ]
25  if flags.Detector.GeometryLAr:
26  if flags.Sim.LArParameterization is LArParameterization.NoFrozenShowers:
27  from AthenaCommon.Logging import logging
28  msg = logging.getLogger("FastSimulationToolListCfg")
29  msg.info( "Not using Frozen Showers" )
30  else:
31  from LArG4FastSimulation.LArG4FastSimulationConfig import EMBFastShowerCfg, EMECFastShowerCfg, FCALFastShowerCfg, FCAL2FastShowerCfg
32  # We run production with LArParameterization.FrozenShowersFCalOnly, so the EMB and EMEC tools are not required
33  if flags.Sim.LArParameterization is LArParameterization.FrozenShowers:
34  tools += [ result.popToolsAndMerge(EMBFastShowerCfg(flags)) ]
35  tools += [ result.popToolsAndMerge(EMECFastShowerCfg(flags)) ]
36  tools += [ result.popToolsAndMerge(FCALFastShowerCfg(flags)) ]
37  tools += [ result.popToolsAndMerge(FCAL2FastShowerCfg(flags)) ]
38  if flags.Sim.LArParameterization in [LArParameterization.DeadMaterialFrozenShowers, LArParameterization.FrozenShowersFCalOnly, LArParameterization.FastCaloSim]: # TODO Check this makes sense.
39  from G4FastSimulation.G4FastSimulationConfig import DeadMaterialShowerCfg
40  tools += [ result.popToolsAndMerge(DeadMaterialShowerCfg(flags)) ]
41  # Enable fast simulation of the calorimeter with FastCaloSim
42  if flags.Sim.LArParameterization is LArParameterization.FastCaloSim:
43  from G4FastSimulation.G4FastSimulationConfig import FastCaloSimCfg
44  tools += [ result.popToolsAndMerge(FastCaloSimCfg(flags)) ]
45  if flags.Detector.GeometryMuon:
46  if flags.Sim.CavernBackground not in [CavernBackground.Off, CavernBackground.Read] and not flags.Sim.RecordFlux:
47  from TrackWriteFastSim.TrackWriteFastSimConfig import NeutronFastSimCfg
48  tools += [ result.popToolsAndMerge(NeutronFastSimCfg(flags)) ]
49  result.setPrivateTools(tools)
50  return result
51 
52 

◆ FwdSensitiveDetectorListCfg()

def G4AtlasToolsConfig.FwdSensitiveDetectorListCfg (   flags)

Definition at line 139 of file G4AtlasToolsConfig.py.

139 def FwdSensitiveDetectorListCfg(flags):
140  # TODO: migrate to CA
141  result = ComponentAccumulator()
142  tools = []
143  if flags.Detector.EnableLucid:
144  from LUCID_G4_SD.LUCID_G4_SDConfig import LUCID_SensitiveDetectorCfg
145  tools += [ result.popToolsAndMerge(LUCID_SensitiveDetectorCfg(flags)) ]
146  if flags.Detector.EnableForward:
147  if flags.Detector.EnableZDC:
148  from ZDC_SD.ZDC_SDConfig import ZDC_FiberSDCfg
149  tools += [ result.popToolsAndMerge(ZDC_FiberSDCfg(flags)) ]
150  if flags.Sim.CalibrationRun in [CalibrationRun.ZDC, CalibrationRun.LArTileZDC]:
151  from ZDC_SD.ZDC_SDConfig import ZDC_G4CalibSDCfg
152  tools += [ result.popToolsAndMerge(ZDC_G4CalibSDCfg(flags)) ]
153  if flags.Detector.EnableALFA:
154  from ALFA_G4_SD.ALFA_G4_SDConfig import ALFA_SensitiveDetectorCfg
155  tools += [ result.popToolsAndMerge(ALFA_SensitiveDetectorCfg(flags)) ]
156  if flags.Detector.EnableAFP:
157  from AFP_G4_SD.AFP_G4_SDConfig import AFP_SensitiveDetectorCfg
158  tools += [ result.popToolsAndMerge(AFP_SensitiveDetectorCfg(flags)) ]
159  # Alternative implementations
160  # from AFP_G4_SD.AFP_G4_SDConfig import AFP_SiDSensitiveDetectorCfg, AFP_TDSensitiveDetectorCfg
161  # tools += [ result.popToolsAndMerge(AFP_SiDSensitiveDetectorCfg(flags)) ]
162  # tools += [ result.popToolsAndMerge(AFP_TDSensitiveDetectorCfg(flags)) ]
163  result.setPrivateTools(tools)
164  return result
165 
166 

◆ G4CaloTransportToolCfg()

def G4AtlasToolsConfig.G4CaloTransportToolCfg (   flags,
  name = 'G4CaloTransportTool',
**  kwargs 
)

Definition at line 68 of file G4AtlasToolsConfig.py.

68 def G4CaloTransportToolCfg(flags, name='G4CaloTransportTool', **kwargs):
69  result = ComponentAccumulator()
70  # Use simplified calorimeter geometry if path to simplified geometry is provided
71  # Otherwise, use the full geometry for the transport (Note that this will be very slow)
72  kwargs.setdefault("UseSimplifiedGeo", bool(flags.Sim.SimplifiedGeoPath))
73  if flags.Sim.SimplifiedGeoPath:
74  # What is the name of the logical world volume of the simplified geometry?
75  kwargs.setdefault('SimplifiedWorldLogName', "WorldLog")
76  # At what volume will we stop the transport?
77  kwargs.setdefault('TransportLimitVolume', "Envelope")
78  # What is the maximum number of Geant4 steps taken in the transport?
79  kwargs.setdefault('MaxSteps', 100)
80  else:
81  # At what volume will be stop the transport?
82  kwargs.setdefault('TransportLimitVolume', "MuonSys")
83  # What is the maximum number of Geant4 steps taken in the transport?
84  kwargs.setdefault('MaxSteps', 5000)
85 
86  result.setPrivateTools(CompFactory.G4CaloTransportTool(name, **kwargs))
87  return result
88 

◆ HGTDSensitiveDetectorListCfg()

def G4AtlasToolsConfig.HGTDSensitiveDetectorListCfg (   flags)

Definition at line 204 of file G4AtlasToolsConfig.py.

204 def HGTDSensitiveDetectorListCfg(flags):
205  result = ComponentAccumulator()
206  tools = []
207 
208  if flags.Detector.EnableHGTD:
209  from HGTD_G4_SD.HGTD_G4_SDToolConfig import HgtdSensorSDCfg
210  tools += [ result.popToolsAndMerge(HgtdSensorSDCfg(flags)) ]
211  pass
212 
213  result.setPrivateTools(tools)
214  return result
215 
216 

◆ InDetSensitiveDetectorListCfg()

def G4AtlasToolsConfig.InDetSensitiveDetectorListCfg (   flags)

Definition at line 217 of file G4AtlasToolsConfig.py.

217 def InDetSensitiveDetectorListCfg(flags):
218  result = ComponentAccumulator()
219  tools = []
220 
221  if flags.Detector.EnablePixel:
222  from PixelG4_SD.PixelG4_SDToolConfig import PixelSensorSDCfg
223  tools += [ result.popToolsAndMerge(PixelSensorSDCfg(flags)) ]
224  if flags.Detector.EnableSCT:
225  from SCT_G4_SD.SCT_G4_SDToolConfig import SctSensorSDCfg
226  tools += [ result.popToolsAndMerge(SctSensorSDCfg(flags)) ]
227  if flags.Detector.EnableTRT:
228  from TRT_G4_SD.TRT_G4_SDToolConfig import TRTSensitiveDetectorCfg
229  tools += [ result.popToolsAndMerge(TRTSensitiveDetectorCfg(flags)) ]
230  if flags.Detector.EnableBCM:
231  from BCM_G4_SD.BCM_G4_SDToolConfig import BCMSensorSDCfg
232  tools += [ result.popToolsAndMerge(BCMSensorSDCfg(flags)) ]
233  from BLM_G4_SD.BLM_G4_SDToolConfig import BLMSensorSDCfg
234  tools += [ result.popToolsAndMerge(BLMSensorSDCfg(flags)) ]
235 
236  result.setPrivateTools(tools)
237  return result
238 
239 

◆ InputContainerListCfg()

def G4AtlasToolsConfig.InputContainerListCfg (   flags)

Definition at line 386 of file G4AtlasToolsConfig.py.

386 def InputContainerListCfg(flags):
387  dependencies = []
388  from SimulationConfig.SimEnums import LArParameterization
389  if flags.Sim.LArParameterization is LArParameterization.FastCaloSim:
390  dependencies+=[('CaloDetDescrManager', 'ConditionStore+CaloDetDescrManager'),
391  ('LArfSamplSym', 'ConditionStore+LArfSamplSym'),
392  ('TileSamplingFraction', 'ConditionStore+TileSamplingFraction')]
393  from MuonSensitiveDetectorsR4.SensitiveDetectorsCfg import MuonDependenciesCfg
394  dependencies += MuonDependenciesCfg(flags)
395  return dependencies
396 

◆ ITkSensitiveDetectorListCfg()

def G4AtlasToolsConfig.ITkSensitiveDetectorListCfg (   flags)

Definition at line 185 of file G4AtlasToolsConfig.py.

185 def ITkSensitiveDetectorListCfg(flags):
186  result = ComponentAccumulator()
187  tools = []
188 
189  if flags.Detector.EnableITkPixel:
190  from PixelG4_SD.PixelG4_SDToolConfig import ITkPixelSensorSDCfg
191  tools += [ result.popToolsAndMerge(ITkPixelSensorSDCfg(flags)) ]
192  pass
193  if flags.Detector.EnableITkStrip:
194  from SCT_G4_SD.SCT_G4_SDToolConfig import ITkStripSensorSDCfg
195  tools += [ result.popToolsAndMerge(ITkStripSensorSDCfg(flags)) ]
196  if flags.Detector.EnablePLR:
197  from PixelG4_SD.PixelG4_SDToolConfig import PLRSensorSDCfg
198  tools += [ result.popToolsAndMerge(PLRSensorSDCfg(flags)) ]
199 
200  result.setPrivateTools(tools)
201  return result
202 
203 

◆ MuonSensitiveDetectorListCfg()

def G4AtlasToolsConfig.MuonSensitiveDetectorListCfg (   flags)

Definition at line 279 of file G4AtlasToolsConfig.py.

279 def MuonSensitiveDetectorListCfg(flags):
280  if flags.Muon.usePhaseIIGeoSetup:
281  from MuonSensitiveDetectorsR4.SensitiveDetectorsCfg import SetupSensitiveDetectorsCfg
282  return SetupSensitiveDetectorsCfg(flags)
283  from MuonG4SD.MuonG4SDConfig import SetupSensitiveDetectorsCfg
284  return SetupSensitiveDetectorsCfg(flags)
285 

◆ PunchThroughG4ClassifierCfg()

def G4AtlasToolsConfig.PunchThroughG4ClassifierCfg (   flags,
  name = "PunchThroughG4Classifier",
**  kwargs 
)

Definition at line 89 of file G4AtlasToolsConfig.py.

89 def PunchThroughG4ClassifierCfg(flags, name="PunchThroughG4Classifier", **kwargs):
90  # declare component accumulator
91  result = ComponentAccumulator()
92  # other arguments
93  kwargs.setdefault("ScalerConfigFileName" , "FastCaloSim/MC23/TFCSparam_mpt_classScaler_v04.xml" )
94  kwargs.setdefault("NetworkConfigFileName" , "FastCaloSim/MC23/TFCSparam_mpt_classNet_v04.json" )
95  kwargs.setdefault("CalibratorConfigFileName" , "FastCaloSim/MC23/TFCSparam_mpt_classCalib_v04.xml")
96  # set as private tool
97  result.setPrivateTools(CompFactory.PunchThroughG4Classifier(name, **kwargs))
98  return result
99 

◆ PunchThroughG4ToolCfg()

def G4AtlasToolsConfig.PunchThroughG4ToolCfg (   flags,
  name = 'PunchThroughG4Tool',
**  kwargs 
)

Definition at line 100 of file G4AtlasToolsConfig.py.

100 def PunchThroughG4ToolCfg(flags, name='PunchThroughG4Tool', **kwargs):
101  # get the envelope config
102  from SubDetectorEnvelopes.SubDetectorEnvelopesConfig import EnvelopeDefSvcCfg
103  # declare component accumulator
104  result = ComponentAccumulator()
105  # other arguments
106  kwargs.setdefault("FilenameLookupTable" , "FastCaloSim/MC23/TFCSparam_mpt_v07.root")
107  kwargs.setdefault("FilenameInverseCdf" , "FastCaloSim/MC23/TFCSparam_mpt_inverseCdf_v07.xml")
108  kwargs.setdefault("FilenameInversePca" , "FastCaloSim/MC23/TFCSparam_mpt_inversePca_v07.xml")
109  kwargs.setdefault("EnergyFactor" , [ 0.98, 0.831, 0.896, 0.652, 0.717, 1., 0.877, 0.858, 0.919 ] )
110  kwargs.setdefault("DoAntiParticles" , [ 0, 1, 0, 1, 1, 0, 0, 0, 0 ] )
111  kwargs.setdefault("PunchThroughInitiators" , [ 211, 321, 311, 310, 130, 2212, 2112] )
112  kwargs.setdefault("InitiatorsMinEnergy" , [ 65536, 65536, 65536, 65536, 65536, 65536, 65536] )
113  kwargs.setdefault("InitiatorsEtaRange" , [ -3.2, 3.2 ] )
114  kwargs.setdefault("PunchThroughParticles" , [ 2212, 211, 22, 11, 13, 2112, 321, 310, 130 ] )
115  kwargs.setdefault("CorrelatedParticle" , [] )
116  kwargs.setdefault("FullCorrelationEnergy" , [ 100000., 100000., 100000., 100000., 0., 100000., 100000., 100000., 100000.] )
117  kwargs.setdefault("MinEnergy" , [ 938.3, 135.6, 50., 50., 105.7, 939.6, 493.7, 497.6, 497.6 ] )
118  kwargs.setdefault("MaxNumParticles" , [ -1, -1, -1, -1, -1, -1, -1, -1, -1 ] )
119  kwargs.setdefault("EnvelopeDefSvc", result.getPrimaryAndMerge(EnvelopeDefSvcCfg(flags)).name)
120  kwargs.setdefault("BeamPipeRadius", 500.)
121  # set as private tool
122  result.setPrivateTools(CompFactory.PunchThroughG4Tool(name, **kwargs))
123  return result
124 

◆ PunchThroughSimWrapperCfg()

def G4AtlasToolsConfig.PunchThroughSimWrapperCfg (   flags,
  name = 'PunchThroughSimWrapper',
**  kwargs 
)

Definition at line 125 of file G4AtlasToolsConfig.py.

125 def PunchThroughSimWrapperCfg(flags, name='PunchThroughSimWrapper', **kwargs):
126  result = ComponentAccumulator()
127 
128  # Set the PunchThroughG4Classifier
129  if "PunchThroughG4Classifier" not in kwargs:
130  kwargs.setdefault("PunchThroughG4Classifier", result.addPublicTool(result.popToolsAndMerge(PunchThroughG4ClassifierCfg(flags))))
131 
132  # Set the PunchThroughG4Tool
133  if "PunchThroughG4Tool" not in kwargs:
134  kwargs.setdefault("PunchThroughG4Tool", result.addPublicTool(result.popToolsAndMerge(PunchThroughG4ToolCfg(flags))))
135 
136  result.setPrivateTools(CompFactory.PunchThroughSimWrapper(name, **kwargs))
137  return result
138 

◆ SensitiveDetectorListCfg()

def G4AtlasToolsConfig.SensitiveDetectorListCfg (   flags)

Definition at line 397 of file G4AtlasToolsConfig.py.

397 def SensitiveDetectorListCfg(flags):
398  result = ComponentAccumulator()
399  tools = []
400  tools += result.popToolsAndMerge(EnvelopeSensitiveDetectorListCfg(flags))
401  tools += result.popToolsAndMerge(InDetSensitiveDetectorListCfg(flags))
402  tools += result.popToolsAndMerge(ITkSensitiveDetectorListCfg(flags))
403  tools += result.popToolsAndMerge(HGTDSensitiveDetectorListCfg(flags))
404  tools += result.popToolsAndMerge(CaloSensitiveDetectorListCfg(flags))
405  tools += result.popToolsAndMerge(MuonSensitiveDetectorListCfg(flags))
406  tools += result.popToolsAndMerge(TrackFastSimSensitiveDetectorListCfg(flags))
407  tools += result.popToolsAndMerge(FwdSensitiveDetectorListCfg(flags))
408  tools += result.popToolsAndMerge(CaloCellContainerSensitiveDetectorListCfg(flags))
409 
410  result.setPrivateTools(tools)
411  return result
412 
413 

◆ SensitiveDetectorMasterToolCfg()

def G4AtlasToolsConfig.SensitiveDetectorMasterToolCfg (   flags,
  name = "SensitiveDetectorMasterTool",
**  kwargs 
)

Definition at line 464 of file G4AtlasToolsConfig.py.

464 def SensitiveDetectorMasterToolCfg(flags, name="SensitiveDetectorMasterTool", **kwargs):
465  result = ComponentAccumulator()
466  # NB Currently only supporting the standard ATLAS dector and the Tile Test Beam
467  if flags.Beam.Type is BeamType.TestBeam:
468  kwargs.setdefault("SensitiveDetectors", result.popToolsAndMerge(TileTestBeamSensitiveDetectorListCfg(flags)))
469  elif "tb_LArH6" in flags.GeoModel.AtlasVersion:
470  pass
471  elif "ctbh8" in flags.GeoModel.AtlasVersion:
472  kwargs.setdefault("SensitiveDetectors", result.popToolsAndMerge(CombinedTestBeamSensitiveDetectorListCfg(flags)))
473  else:
474  kwargs.setdefault("SensitiveDetectors", result.popToolsAndMerge(SensitiveDetectorListCfg(flags)))
475 
476  result.setPrivateTools(CompFactory.SensitiveDetectorMasterTool(name, **kwargs))
477  return result
478 
479 

◆ SimHitContainerListCfg()

def G4AtlasToolsConfig.SimHitContainerListCfg (   flags)

Definition at line 296 of file G4AtlasToolsConfig.py.

296 def SimHitContainerListCfg(flags):
297  from SimulationConfig.SimEnums import LArParameterization
298  writtenContainers =[]
299  if flags.Detector.GeometryMuon:
300  if flags.Muon.usePhaseIIGeoSetup:
301  from MuonSensitiveDetectorsR4.SensitiveDetectorsCfg import SimHitContainerListCfg
302  writtenContainers+= SimHitContainerListCfg(flags)
303  else:
304  from MuonG4SD.MuonG4SDConfig import SimHitContainerListCfg
305  writtenContainers += SimHitContainerListCfg(flags)
306  if flags.Detector.GeometryLAr:
307  if (flags.Sim.ISFRun and flags.Sim.ISF.HITSMergingRequired.get('CALO', True)) or flags.Sim.LArParameterization is LArParameterization.FastCaloSim:
308  writtenContainers += [("LArHitContainer", "LArHitEMB_G4")]
309  writtenContainers += [("LArHitContainer", "LArHitEMEC_G4")]
310  writtenContainers += [("LArHitContainer", "LArHitFCAL_G4")]
311  writtenContainers += [("LArHitContainer", "LArHitHEC_G4")]
312  if flags.Sim.LArParameterization is LArParameterization.FastCaloSim:
313  writtenContainers += [("LArHitContainer" , "LArHitHEC_FastCaloSim")]
314  writtenContainers += [("LArHitContainer" , "LArHitFCAL_FastCaloSim")]
315  writtenContainers += [("LArHitContainer" , "LArHitEMEC_FastCaloSim")]
316  writtenContainers += [("LArHitContainer" , "LArHitEMB_FastCaloSim")]
317  else:
318  writtenContainers += [("LArHitContainer", "LArHitEMB")]
319  writtenContainers += [("LArHitContainer", "LArHitEMEC")]
320  writtenContainers += [("LArHitContainer", "LArHitFCAL")]
321  writtenContainers += [("LArHitContainer", "LArHitHEC")]
322  if flags.Detector.GeometryTile:
323  if (flags.Sim.ISFRun and flags.Sim.ISF.HITSMergingRequired.get('CALO', True)) or flags.Sim.LArParameterization is LArParameterization.FastCaloSim:
324  writtenContainers += [("TileHitVector", "MBTSHits_G4")]
325  writtenContainers += [("TileHitVector", "TileHitVec_G4")]
326  if flags.Sim.LArParameterization is LArParameterization.FastCaloSim:
327  writtenContainers += [("TileHitVector" , "TileHitVec_FastCaloSim")]
328  writtenContainers += [("TileHitVector" , "MBTSHits_FastCaloSim")]
329  else:
330  writtenContainers += [("TileHitVector", "MBTSHits")]
331  writtenContainers += [("TileHitVector", "TileHitVec")]
332  if flags.Detector.GeometryTRT:
333  if (flags.Sim.ISFRun and flags.Sim.ISF.HITSMergingRequired.get('ID', True)):
334  writtenContainers += [("TRTUncompressedHitCollection", "TRTUncompressedHits_G4")]
335  else:
336  writtenContainers += [("TRTUncompressedHitCollection", "TRTUncompressedHits")]
337  if flags.Detector.EnableBCM:
338  if (flags.Sim.ISFRun and flags.Sim.ISF.HITSMergingRequired.get('ID', True)):
339  writtenContainers += [("SiHitCollection", "BCMHits_G4")]
340  writtenContainers += [("SiHitCollection", "BLMHits_G4")]
341  else:
342  writtenContainers += [("SiHitCollection", "BCMHits")]
343  writtenContainers += [("SiHitCollection", "BLMHits")]
344  if flags.Detector.EnablePixel:
345  if (flags.Sim.ISFRun and flags.Sim.ISF.HITSMergingRequired.get('ID', True)):
346  writtenContainers += [("SiHitCollection", "PixelHits_G4")]
347  else:
348  writtenContainers += [("SiHitCollection", "PixelHits")]
349  if flags.Detector.EnableSCT:
350  if (flags.Sim.ISFRun and flags.Sim.ISF.HITSMergingRequired.get('ID', True)):
351  writtenContainers += [("SiHitCollection", "SCT_Hits_G4")]
352  else:
353  writtenContainers += [("SiHitCollection", "SCT_Hits")]
354  if flags.Detector.EnableITkPixel:
355  if (flags.Sim.ISFRun and flags.Sim.ISF.HITSMergingRequired.get('ITk', True)):
356  writtenContainers += [("SiHitCollection", "ITkPixelHits_G4")]
357  else:
358  writtenContainers += [("SiHitCollection", "ITkPixelHits")]
359  if flags.Detector.EnableITkStrip:
360  if (flags.Sim.ISFRun and flags.Sim.ISF.HITSMergingRequired.get('ITk', True)):
361  writtenContainers += [("SiHitCollection", "ITkStripHits_G4")]
362  else:
363  writtenContainers += [("SiHitCollection", "ITkStripHits")]
364  if flags.Detector.EnablePLR:
365  if (flags.Sim.ISFRun and flags.Sim.ISF.HITSMergingRequired.get('ITk', True)):
366  writtenContainers += [("SiHitCollection", "PLR_Hits_G4")]
367  else:
368  writtenContainers += [("SiHitCollection", "PLR_Hits")]
369  if flags.Detector.EnableHGTD:
370  if (flags.Sim.ISFRun and flags.Sim.ISF.HITSMergingRequired.get('ITk', True)):
371  writtenContainers += [("SiHitCollection", "HGTDHits_G4")]
372  else:
373  writtenContainers += [("SiHitCollection", "HGTDHits")]
374  from SimulationConfig.SimEnums import CalibrationRun
375  if flags.Sim.CalibrationRun in [CalibrationRun.LAr, CalibrationRun.LArTile, CalibrationRun.LArTileZDC]:
376  # Needed to ensure that DeadMaterialCalibrationHitsMerger is scheduled correctly.
377  writtenContainers += [
378  ( 'CaloCalibrationHitContainer' , 'StoreGateSvc+LArCalibrationHitActive_DEAD' ),
379  ( 'CaloCalibrationHitContainer' , 'StoreGateSvc+LArCalibrationHitDeadMaterial_DEAD' ),
380  ( 'CaloCalibrationHitContainer' , 'StoreGateSvc+LArCalibrationHitInactive_DEAD' )
381  ]
382 
383  return writtenContainers
384 
385 

◆ TileTestBeamSensitiveDetectorListCfg()

def G4AtlasToolsConfig.TileTestBeamSensitiveDetectorListCfg (   flags)

Definition at line 414 of file G4AtlasToolsConfig.py.

414 def TileTestBeamSensitiveDetectorListCfg(flags):
415  result = ComponentAccumulator()
416  tools = []
417 
418  if flags.Detector.EnableTile:
419  if flags.Sim.CalibrationRun in [CalibrationRun.Tile, CalibrationRun.LArTile, CalibrationRun.LArTileZDC]:
420  from TileGeoG4Calib.TileGeoG4CalibConfig import TileCTBGeoG4CalibSDCfg
421  tools += [ result.popToolsAndMerge(TileCTBGeoG4CalibSDCfg(flags)) ] # mode 1 : With CaloCalibrationHits
422  else:
423  from TileGeoG4SD.TileGeoG4SDToolConfig import TileCTBGeoG4SDCfg
424  tools += [ result.popToolsAndMerge(TileCTBGeoG4SDCfg(flags)) ] # mode 0 : No CaloCalibrationHits
425  from MuonWall.MuonWallConfig import MuonWallSDCfg
426  tools += [ result.popToolsAndMerge(MuonWallSDCfg(flags)) ]
427  result.setPrivateTools(tools)
428  return result
429 
430 

◆ TrackFastSimSensitiveDetectorListCfg()

def G4AtlasToolsConfig.TrackFastSimSensitiveDetectorListCfg (   flags)

Definition at line 167 of file G4AtlasToolsConfig.py.

167 def TrackFastSimSensitiveDetectorListCfg(flags):
168  result = ComponentAccumulator()
169  tools = []
170  if (flags.Detector.EnableMuon and flags.Sim.CavernBackground in [CavernBackground.Write, CavernBackground.WriteWorld]) or flags.Sim.StoppedParticleFile:
171  from TrackWriteFastSim.TrackWriteFastSimConfig import TrackFastSimSDCfg
172  tools += [ result.popToolsAndMerge(TrackFastSimSDCfg(flags)) ]
173  result.setPrivateTools(tools)
174  return result
175 
SCT_G4_SDToolConfig.SctSensor_CTBCfg
def SctSensor_CTBCfg(ConfigFlags, name="SctSensor_CTB", **kwargs)
Definition: SCT_G4_SDToolConfig.py:29
G4AtlasToolsConfig.SimHitContainerListCfg
def SimHitContainerListCfg(flags)
Definition: G4AtlasToolsConfig.py:296
LUCID_G4_SDConfig.LUCID_SensitiveDetectorCfg
def LUCID_SensitiveDetectorCfg(flags, name="LUCID_SensitiveDetector", **kwargs)
Definition: LUCID_G4_SDConfig.py:6
BCM_G4_SDToolConfig.BCMSensorSDCfg
def BCMSensorSDCfg(ConfigFlags, name="BCMSensorSD", **kwargs)
Definition: BCM_G4_SDToolConfig.py:8
python.JetAnalysisCommon.ComponentAccumulator
ComponentAccumulator
Definition: JetAnalysisCommon.py:302
TrackWriteFastSimConfig.NeutronFastSimCfg
def NeutronFastSimCfg(flags, name='NeutronFastSim', **kwargs)
Definition: TrackWriteFastSimConfig.py:19
LArG4SDToolConfig.LArEMBSensitiveDetectorCfg
def LArEMBSensitiveDetectorCfg(flags, name="LArEMBSensitiveDetector", **kwargs)
Definition: LArG4SDToolConfig.py:187
G4AtlasToolsConfig.MuonSensitiveDetectorListCfg
def MuonSensitiveDetectorListCfg(flags)
Definition: G4AtlasToolsConfig.py:279
G4AtlasToolsConfig.SensitiveDetectorListCfg
def SensitiveDetectorListCfg(flags)
Definition: G4AtlasToolsConfig.py:397
LArG4SDToolConfig.LArActiveSensitiveDetectorToolCfg
def LArActiveSensitiveDetectorToolCfg(flags, name="LArActiveSensitiveDetector", **kwargs)
Definition: LArG4SDToolConfig.py:10
TileGeoG4CalibConfig.TileCTBGeoG4CalibSDCfg
def TileCTBGeoG4CalibSDCfg(flags, name="TileCTBGeoG4CalibSD", **kwargs)
Definition: TileGeoG4CalibConfig.py:19
TileGeoG4SDToolConfig.TileCTBGeoG4SDCfg
def TileCTBGeoG4SDCfg(flags, name="TileCTBGeoG4SD", **kwargs)
Definition: TileGeoG4SDToolConfig.py:25
LArG4FastSimulationConfig.EMBFastShowerCfg
def EMBFastShowerCfg(flags, **kwargs)
Definition: LArG4FastSimulationConfig.py:23
SCT_G4_SDToolConfig.SctSensorSDCfg
def SctSensorSDCfg(ConfigFlags, name="SctSensorSD", **kwargs)
Definition: SCT_G4_SDToolConfig.py:8
G4AtlasToolsConfig.InDetSensitiveDetectorListCfg
def InDetSensitiveDetectorListCfg(flags)
Definition: G4AtlasToolsConfig.py:217
TrackWriteFastSimConfig.CosmicTRSDCfg
def CosmicTRSDCfg(flags, name="CosmicRecord", **kwargs)
Definition: TrackWriteFastSimConfig.py:33
G4AtlasToolsConfig.EmptySensitiveDetectorMasterToolCfg
def EmptySensitiveDetectorMasterToolCfg(name="EmptySensitiveDetectorMasterTool", **kwargs)
Definition: G4AtlasToolsConfig.py:480
HGTD_G4_SDToolConfig.HgtdSensorSDCfg
def HgtdSensorSDCfg(flags, name="HgtdSensorSD", **kwargs)
Definition: HGTD_G4_SDToolConfig.py:8
ISF_FastCaloSimSDToolConfig.FCS_StepInfoSDToolCfg
def FCS_StepInfoSDToolCfg(flags, name="FCS_StepInfoSensitiveDetector", **kwargs)
Definition: ISF_FastCaloSimSDToolConfig.py:7
G4AtlasToolsConfig.CombinedTestBeamSensitiveDetectorListCfg
def CombinedTestBeamSensitiveDetectorListCfg(flags)
Definition: G4AtlasToolsConfig.py:431
LArG4SDToolConfig.LArEMECSensitiveDetectorCfg
def LArEMECSensitiveDetectorCfg(flags, name="LArEMECSensitiveDetector", **kwargs)
Definition: LArG4SDToolConfig.py:216
PixelG4_SDToolConfig.PixelSensor_CTBCfg
def PixelSensor_CTBCfg(ConfigFlags, name="PixelSensor_CTB", **kwargs)
Definition: PixelG4_SDToolConfig.py:28
SensitiveDetectorsCfg.MuonDependenciesCfg
def MuonDependenciesCfg(flags)
Definition: SensitiveDetectorsCfg.py:129
LArG4SDToolConfig.LArInactiveSensitiveDetectorToolCfg
def LArInactiveSensitiveDetectorToolCfg(flags, name="LArInactiveSensitiveDetector", **kwargs)
Definition: LArG4SDToolConfig.py:314
FastSimulationMasterTool
Definition: FastSimulationMasterTool.h:16
SCT_G4_SDToolConfig.ITkStripSensorSDCfg
def ITkStripSensorSDCfg(ConfigFlags, name="ITkStripSensorSD", **kwargs)
Definition: SCT_G4_SDToolConfig.py:37
BLM_G4_SDToolConfig.BLMSensorSDCfg
def BLMSensorSDCfg(ConfigFlags, name="BLMSensorSD", **kwargs)
Definition: BLM_G4_SDToolConfig.py:8
G4AtlasToolsConfig.FastSimulationMasterToolCfg
def FastSimulationMasterToolCfg(flags, **kwargs)
Definition: G4AtlasToolsConfig.py:53
LArG4FastSimulationConfig.EMECFastShowerCfg
def EMECFastShowerCfg(flags, **kwargs)
Definition: LArG4FastSimulationConfig.py:45
TRT_G4_SDToolConfig.TRTSensitiveDetectorCfg
def TRTSensitiveDetectorCfg(flags, name="TRTSensitiveDetector", **kwargs)
Definition: TRT_G4_SDToolConfig.py:9
LArG4FastSimulationConfig.FCALFastShowerCfg
def FCALFastShowerCfg(flags, **kwargs)
Definition: LArG4FastSimulationConfig.py:67
G4AtlasToolsConfig.TileTestBeamSensitiveDetectorListCfg
def TileTestBeamSensitiveDetectorListCfg(flags)
Definition: G4AtlasToolsConfig.py:414
G4FastSimulationConfig.FastCaloSimCfg
def FastCaloSimCfg(flags, **kwargs)
Definition: G4FastSimulationConfig.py:20
PixelG4_SDToolConfig.PixelSensorSDCfg
def PixelSensorSDCfg(ConfigFlags, name="PixelSensorSD", **kwargs)
Definition: PixelG4_SDToolConfig.py:8
ZDC_SDConfig.ZDC_G4CalibSDCfg
def ZDC_G4CalibSDCfg(flags, name="ZDC_G4CalibSD", **kwargs)
Definition: ZDC_SDConfig.py:20
G4AtlasToolsConfig.ITkSensitiveDetectorListCfg
def ITkSensitiveDetectorListCfg(flags)
Definition: G4AtlasToolsConfig.py:185
ForwardTransportConfig.ForwardTransportModelCfg
def ForwardTransportModelCfg(flags, name="ForwardTransportModel", **kwargs)
Definition: ForwardTransportConfig.py:6
G4FastSimulationConfig.DeadMaterialShowerCfg
def DeadMaterialShowerCfg(flags, **kwargs)
Definition: G4FastSimulationConfig.py:14
G4AtlasToolsConfig.PunchThroughG4ClassifierCfg
def PunchThroughG4ClassifierCfg(flags, name="PunchThroughG4Classifier", **kwargs)
Definition: G4AtlasToolsConfig.py:89
PixelG4_SDToolConfig.PLRSensorSDCfg
def PLRSensorSDCfg(ConfigFlags, name="PLRSensorSD", **kwargs)
Definition: PixelG4_SDToolConfig.py:73
G4AtlasToolsConfig.G4CaloTransportToolCfg
def G4CaloTransportToolCfg(flags, name='G4CaloTransportTool', **kwargs)
Definition: G4AtlasToolsConfig.py:68
TRT_G4_SDToolConfig.TRTSensitiveDetector_CTBCfg
def TRTSensitiveDetector_CTBCfg(flags, name="TRTSensitiveDetector_CTB", **kwargs)
Definition: TRT_G4_SDToolConfig.py:37
G4AtlasToolsConfig.FastSimulationToolListCfg
def FastSimulationToolListCfg(flags)
Definition: G4AtlasToolsConfig.py:10
AFP_G4_SDConfig.AFP_SensitiveDetectorCfg
def AFP_SensitiveDetectorCfg(flags, name="AFP_SensitiveDetector", **kwargs)
Definition: AFP_G4_SDConfig.py:6
MuonG4SDConfig.SetupSensitiveDetectorsCfg
def SetupSensitiveDetectorsCfg(flags)
Definition: MuonG4SDConfig.py:5
G4AtlasToolsConfig.EmptyFastSimulationMasterToolCfg
def EmptyFastSimulationMasterToolCfg(flags, **kwargs)
Definition: G4AtlasToolsConfig.py:61
TileGeoG4SDToolConfig.TileGeoG4SDCfg
def TileGeoG4SDCfg(flags, name="TileGeoG4SD", **kwargs)
Definition: TileGeoG4SDToolConfig.py:9
PixelG4_SDToolConfig.ITkPixelSensorSDCfg
def ITkPixelSensorSDCfg(ConfigFlags, name="ITkPixelSensorSD", **kwargs)
Definition: PixelG4_SDToolConfig.py:44
TrackWriteFastSimConfig.TrackFastSimSDCfg
def TrackFastSimSDCfg(flags, name='TrackFastSimSD', **kwargs)
Definition: TrackWriteFastSimConfig.py:8
G4AtlasToolsConfig.CaloSensitiveDetectorListCfg
def CaloSensitiveDetectorListCfg(flags)
Definition: G4AtlasToolsConfig.py:240
G4AtlasToolsConfig.PunchThroughG4ToolCfg
def PunchThroughG4ToolCfg(flags, name='PunchThroughG4Tool', **kwargs)
Definition: G4AtlasToolsConfig.py:100
G4AtlasToolsConfig.CaloCellContainerSensitiveDetectorListCfg
def CaloCellContainerSensitiveDetectorListCfg(flags)
Definition: G4AtlasToolsConfig.py:176
G4AtlasToolsConfig.FwdSensitiveDetectorListCfg
def FwdSensitiveDetectorListCfg(flags)
Definition: G4AtlasToolsConfig.py:139
ZDC_SDConfig.ZDC_FiberSDCfg
def ZDC_FiberSDCfg(flags, name="ZDC_FiberSD", **kwargs)
Definition: ZDC_SDConfig.py:6
G4AtlasToolsConfig.InputContainerListCfg
def InputContainerListCfg(flags)
Definition: G4AtlasToolsConfig.py:386
LArG4FastSimulationConfig.FCAL2FastShowerCfg
def FCAL2FastShowerCfg(flags, **kwargs)
Definition: LArG4FastSimulationConfig.py:86
G4AtlasToolsConfig.EnvelopeSensitiveDetectorListCfg
def EnvelopeSensitiveDetectorListCfg(flags)
Definition: G4AtlasToolsConfig.py:286
TileGeoG4CalibConfig.TileGeoG4CalibSDCfg
def TileGeoG4CalibSDCfg(flags, name="TileGeoG4CalibSD", **kwargs)
Definition: TileGeoG4CalibConfig.py:8
SubDetectorEnvelopesConfig.EnvelopeDefSvcCfg
def EnvelopeDefSvcCfg(flags, name="AtlasGeometry_EnvelopeDefSvc", **kwargs)
Definition: SubDetectorEnvelopesConfig.py:15
G4AtlasToolsConfig.HGTDSensitiveDetectorListCfg
def HGTDSensitiveDetectorListCfg(flags)
Definition: G4AtlasToolsConfig.py:204
LArG4SDToolConfig.LArFCALSensitiveDetectorCfg
def LArFCALSensitiveDetectorCfg(flags, name="LArFCALSensitiveDetector", **kwargs)
Definition: LArG4SDToolConfig.py:256
G4FastSimulationConfig.SimpleFastKillerCfg
def SimpleFastKillerCfg(flags, **kwargs)
Definition: G4FastSimulationConfig.py:7
LArG4SDToolConfig.LArDeadSensitiveDetectorToolCfg
def LArDeadSensitiveDetectorToolCfg(flags, name="LArDeadSensitiveDetector", **kwargs)
Definition: LArG4SDToolConfig.py:74
G4AtlasToolsConfig.PunchThroughSimWrapperCfg
def PunchThroughSimWrapperCfg(flags, name='PunchThroughSimWrapper', **kwargs)
Definition: G4AtlasToolsConfig.py:125
MinBiasScintillatorToolConfig.MinBiasScintillatorSDCfg
def MinBiasScintillatorSDCfg(flags, name="MinBiasScintillatorSD", **kwargs)
Definition: MinBiasScintillatorToolConfig.py:8
ISF_FastCaloSimParametrizationConfig.CaloCellContainerSDCfg
def CaloCellContainerSDCfg(flags, name='CaloCellContainerSD', **kwargs)
Definition: ISF_FastCaloSimParametrizationConfig.py:80
xAOD::bool
setBGCode setTAP setLVL2ErrorBits bool
Definition: TrigDecision_v1.cxx:60
MuonWallConfig.MuonWallSDCfg
def MuonWallSDCfg(flags, name="MuonWallSD", **kwargs)
Definition: MuonWallConfig.py:7
G4AtlasToolsConfig.TrackFastSimSensitiveDetectorListCfg
def TrackFastSimSensitiveDetectorListCfg(flags)
Definition: G4AtlasToolsConfig.py:167
ALFA_G4_SDConfig.ALFA_SensitiveDetectorCfg
def ALFA_SensitiveDetectorCfg(flags, name="ALFA_SensitiveDetector", **kwargs)
Definition: ALFA_G4_SDConfig.py:6
LArG4SDToolConfig.LArHECSensitiveDetectorCfg
def LArHECSensitiveDetectorCfg(flags, name="LArHECSensitiveDetector", **kwargs)
Definition: LArG4SDToolConfig.py:287
G4AtlasToolsConfig.SensitiveDetectorMasterToolCfg
def SensitiveDetectorMasterToolCfg(flags, name="SensitiveDetectorMasterTool", **kwargs)
Definition: G4AtlasToolsConfig.py:464
Generated on Tue Mar 25 2025 21:58:51 for ATLAS Offline Software by   doxygen 1.8.18