ATLAS Offline Software
Functions
G4AtlasToolsConfig Namespace Reference

Functions

def FastSimulationToolListCfg (flags)
 
def G4ThreadPoolSvcCfg (flags)
 
def FastSimulationMasterToolCfg (flags, **kwargs)
 
def FastSimulationConstructorToolCfg (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 196 of file G4AtlasToolsConfig.py.

196 def CaloCellContainerSensitiveDetectorListCfg(flags):
197  result = ComponentAccumulator()
198  tools = []
199  if flags.Sim.LArParameterization is LArParameterization.FastCaloSim:
200  from ISF_FastCaloSimParametrization.ISF_FastCaloSimParametrizationConfig import CaloCellContainerSDCfg
201  tools += [ result.popToolsAndMerge(CaloCellContainerSDCfg(flags)) ]
202  result.setPrivateTools(tools)
203  return result
204 

◆ CaloSensitiveDetectorListCfg()

def G4AtlasToolsConfig.CaloSensitiveDetectorListCfg (   flags)

Definition at line 260 of file G4AtlasToolsConfig.py.

260 def CaloSensitiveDetectorListCfg(flags):
261  result = ComponentAccumulator()
262  tools = []
263 
264  if flags.Detector.EnableLAr:
265  from LArG4SD.LArG4SDToolConfig import LArEMBSensitiveDetectorCfg, LArEMECSensitiveDetectorCfg, LArFCALSensitiveDetectorCfg, LArHECSensitiveDetectorCfg
266  tools += [ result.popToolsAndMerge(LArEMBSensitiveDetectorCfg(flags)) ]
267  tools += [ result.popToolsAndMerge(LArEMECSensitiveDetectorCfg(flags)) ]
268  tools += [ result.popToolsAndMerge(LArFCALSensitiveDetectorCfg(flags)) ]
269  tools += [ result.popToolsAndMerge(LArHECSensitiveDetectorCfg(flags)) ]
270 
271  if flags.Detector.EnableMBTS:
272  from MinBiasScintillator.MinBiasScintillatorToolConfig import MinBiasScintillatorSDCfg
273  tools += [ result.popToolsAndMerge(MinBiasScintillatorSDCfg(flags)) ]
274 
275  if flags.Sim.CalibrationRun in [CalibrationRun.LAr, CalibrationRun.LArTile, CalibrationRun.LArTileZDC]:
276  from LArG4SD.LArG4SDToolConfig import LArDeadSensitiveDetectorToolCfg, LArActiveSensitiveDetectorToolCfg, LArInactiveSensitiveDetectorToolCfg
277  tools += [ result.popToolsAndMerge(LArDeadSensitiveDetectorToolCfg(flags)) ]
278  tools += [ result.popToolsAndMerge(LArInactiveSensitiveDetectorToolCfg(flags)) ]
279  tools += [ result.popToolsAndMerge(LArActiveSensitiveDetectorToolCfg(flags)) ]
280  elif flags.Sim.CalibrationRun is CalibrationRun.DeadLAr:
281  from LArG4SD.LArG4SDToolConfig import LArDeadSensitiveDetectorToolCfg
282  tools += [ result.popToolsAndMerge(LArDeadSensitiveDetectorToolCfg(flags)) ]
283 
284  if flags.Detector.EnableTile:
285  if flags.Sim.CalibrationRun in [CalibrationRun.Tile, CalibrationRun.LArTile, CalibrationRun.LArTileZDC]:
286  from TileGeoG4Calib.TileGeoG4CalibConfig import TileGeoG4CalibSDCfg
287  tools += [ result.popToolsAndMerge(TileGeoG4CalibSDCfg(flags)) ] # mode 1 : With CaloCalibrationHits
288  else:
289  from TileGeoG4SD.TileGeoG4SDToolConfig import TileGeoG4SDCfg
290  tools += [ result.popToolsAndMerge(TileGeoG4SDCfg(flags)) ] # mode 0 : No CaloCalibrationHits
291  if flags.Sim.RecordStepInfo:
292  from ISF_FastCaloSimSD.ISF_FastCaloSimSDToolConfig import FCS_StepInfoSDToolCfg
293  tools += [ result.popToolsAndMerge(FCS_StepInfoSDToolCfg(flags)) ]
294 
295  result.setPrivateTools(tools)
296  return result
297 
298 

◆ CombinedTestBeamSensitiveDetectorListCfg()

def G4AtlasToolsConfig.CombinedTestBeamSensitiveDetectorListCfg (   flags)

Definition at line 451 of file G4AtlasToolsConfig.py.

451 def CombinedTestBeamSensitiveDetectorListCfg(flags):
452  result = ComponentAccumulator()
453  tools = []
454  if flags.Detector.EnablePixel:
455  from PixelG4_SD.PixelG4_SDToolConfig import PixelSensor_CTBCfg
456  tools += [ result.popToolsAndMerge(PixelSensor_CTBCfg(flags)) ]
457  if flags.Detector.EnableSCT:
458  from SCT_G4_SD.SCT_G4_SDToolConfig import SctSensor_CTBCfg
459  tools += [ result.popToolsAndMerge(SctSensor_CTBCfg(flags)) ]
460  if flags.Detector.EnableTRT:
461  from TRT_G4_SD.TRT_G4_SDToolConfig import TRTSensitiveDetector_CTBCfg
462  tools += [ result.popToolsAndMerge(TRTSensitiveDetector_CTBCfg(flags)) ]
463  if flags.Detector.EnableLAr:
464  from LArG4SD.LArG4SDToolConfig import LArEMBSensitiveDetectorCfg
465  tools += [ result.popToolsAndMerge(LArEMBSensitiveDetectorCfg(flags)) ]
466  if flags.Sim.CalibrationRun in [CalibrationRun.LAr, CalibrationRun.LArTile, CalibrationRun.LArTileZDC, CalibrationRun.DeadLAr]:
467  tools += [ 'LArH8CalibSensitiveDetector' ] # mode 1 : With CaloCalibrationHits
468  if flags.Detector.EnableTile:
469  if flags.Sim.CalibrationRun in [CalibrationRun.Tile, CalibrationRun.LArTile, CalibrationRun.LArTileZDC]:
470  from TileGeoG4Calib.TileGeoG4CalibConfig import TileCTBGeoG4CalibSDCfg
471  tools += [ result.popToolsAndMerge(TileCTBGeoG4CalibSDCfg(flags)) ] # mode 1 : With CaloCalibrationHits
472  else:
473  from TileGeoG4SD.TileGeoG4SDToolConfig import TileCTBGeoG4SDCfg
474  tools += [ result.popToolsAndMerge(TileCTBGeoG4SDCfg(flags)) ] # mode 0 : No CaloCalibrationHits
475  tools += [ 'MuonWallSD' ]
476  if flags.Detector.EnableMuon:
477  tools += [ 'MuonEntryRecord' ]
478  tools += result.popToolsAndMerge(MuonSensitiveDetectorListCfg(flags))
479 
480  result.setPrivateTools(tools)
481  return result
482 
483 

◆ EmptyFastSimulationMasterToolCfg()

def G4AtlasToolsConfig.EmptyFastSimulationMasterToolCfg (   flags,
**  kwargs 
)

Definition at line 81 of file G4AtlasToolsConfig.py.

81 def EmptyFastSimulationMasterToolCfg(flags, **kwargs):
82  result = ComponentAccumulator()
83  FastSimulationMasterTool = CompFactory.FastSimulationMasterTool
84  tool = result.popToolsAndMerge(FastSimulationMasterTool(name="EmptyFastSimulationMasterTool", **kwargs))
85  result.setPrivateTools(tool)
86  return result
87 

◆ EmptySensitiveDetectorMasterToolCfg()

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

Definition at line 500 of file G4AtlasToolsConfig.py.

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

◆ EnvelopeSensitiveDetectorListCfg()

def G4AtlasToolsConfig.EnvelopeSensitiveDetectorListCfg (   flags)

Definition at line 306 of file G4AtlasToolsConfig.py.

306 def EnvelopeSensitiveDetectorListCfg(flags):
307  result = ComponentAccumulator()
308  tools = []
309  if flags.Beam.Type is BeamType.Cosmics and not flags.Sim.ReadTR:
310  from TrackWriteFastSim.TrackWriteFastSimConfig import CosmicTRSDCfg
311  tools += [ result.popToolsAndMerge(CosmicTRSDCfg(flags)) ]
312  result.setPrivateTools(tools)
313  return result
314 
315 

◆ FastSimulationConstructorToolCfg()

def G4AtlasToolsConfig.FastSimulationConstructorToolCfg (   flags,
**  kwargs 
)

Definition at line 74 of file G4AtlasToolsConfig.py.

74 def FastSimulationConstructorToolCfg(flags, **kwargs):
75  result = ComponentAccumulator()
76  FastSimulationConstructorTool = CompFactory.FastSimulationConstructorTool
77  result.setPrivateTools(FastSimulationConstructorTool(name="FastSimulationConstructorTool", **kwargs))
78  return result
79 
80 

◆ FastSimulationMasterToolCfg()

def G4AtlasToolsConfig.FastSimulationMasterToolCfg (   flags,
**  kwargs 
)

Definition at line 66 of file G4AtlasToolsConfig.py.

66 def FastSimulationMasterToolCfg(flags, **kwargs):
67  result = ComponentAccumulator()
68  kwargs.setdefault("FastSimulations", result.popToolsAndMerge(FastSimulationToolListCfg(flags)))
69  FastSimulationMasterTool = CompFactory.FastSimulationMasterTool
70  result.setPrivateTools(FastSimulationMasterTool(name="FastSimulationMasterTool", **kwargs))
71  return result
72 
73 

◆ 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 
50  from G4AtlasServices.G4AtlasServicesConfig import PhysicsListSvcCfg
51  result.merge(PhysicsListSvcCfg(flags))
52  result.getService("PhysicsListSvc").FastSimConstructor.InitializeFastSimulation = len(tools) > 0
53 
54  result.setPrivateTools(tools)
55  return result
56 

◆ FwdSensitiveDetectorListCfg()

def G4AtlasToolsConfig.FwdSensitiveDetectorListCfg (   flags)

Definition at line 159 of file G4AtlasToolsConfig.py.

159 def FwdSensitiveDetectorListCfg(flags):
160  # TODO: migrate to CA
161  result = ComponentAccumulator()
162  tools = []
163  if flags.Detector.EnableLucid:
164  from LUCID_G4_SD.LUCID_G4_SDConfig import LUCID_SensitiveDetectorCfg
165  tools += [ result.popToolsAndMerge(LUCID_SensitiveDetectorCfg(flags)) ]
166  if flags.Detector.EnableForward:
167  if flags.Detector.EnableZDC:
168  from ZDC_SD.ZDC_SDConfig import ZDC_FiberSDCfg
169  tools += [ result.popToolsAndMerge(ZDC_FiberSDCfg(flags)) ]
170  if flags.Sim.CalibrationRun in [CalibrationRun.ZDC, CalibrationRun.LArTileZDC]:
171  from ZDC_SD.ZDC_SDConfig import ZDC_G4CalibSDCfg
172  tools += [ result.popToolsAndMerge(ZDC_G4CalibSDCfg(flags)) ]
173  if flags.Detector.EnableALFA:
174  from ALFA_G4_SD.ALFA_G4_SDConfig import ALFA_SensitiveDetectorCfg
175  tools += [ result.popToolsAndMerge(ALFA_SensitiveDetectorCfg(flags)) ]
176  if flags.Detector.EnableAFP:
177  from AFP_G4_SD.AFP_G4_SDConfig import AFP_SensitiveDetectorCfg
178  tools += [ result.popToolsAndMerge(AFP_SensitiveDetectorCfg(flags)) ]
179  # Alternative implementations
180  # from AFP_G4_SD.AFP_G4_SDConfig import AFP_SiDSensitiveDetectorCfg, AFP_TDSensitiveDetectorCfg
181  # tools += [ result.popToolsAndMerge(AFP_SiDSensitiveDetectorCfg(flags)) ]
182  # tools += [ result.popToolsAndMerge(AFP_TDSensitiveDetectorCfg(flags)) ]
183  result.setPrivateTools(tools)
184  return result
185 
186 

◆ G4CaloTransportToolCfg()

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

Definition at line 88 of file G4AtlasToolsConfig.py.

88 def G4CaloTransportToolCfg(flags, name='G4CaloTransportTool', **kwargs):
89  result = ComponentAccumulator()
90  # Use simplified calorimeter geometry if path to simplified geometry is provided
91  # Otherwise, use the full geometry for the transport (Note that this will be very slow)
92  kwargs.setdefault("UseSimplifiedGeo", bool(flags.Sim.SimplifiedGeoPath))
93  if flags.Sim.SimplifiedGeoPath:
94  # What is the name of the logical world volume of the simplified geometry?
95  kwargs.setdefault('SimplifiedWorldLogName', "WorldLog")
96  # At what volume will we stop the transport?
97  kwargs.setdefault('TransportLimitVolume', "Envelope")
98  # What is the maximum number of Geant4 steps taken in the transport?
99  kwargs.setdefault('MaxSteps', 100)
100  else:
101  # At what volume will be stop the transport?
102  kwargs.setdefault('TransportLimitVolume', "MuonSys")
103  # What is the maximum number of Geant4 steps taken in the transport?
104  kwargs.setdefault('MaxSteps', 5000)
105 
106  result.setPrivateTools(CompFactory.G4CaloTransportTool(name, **kwargs))
107  return result
108 

◆ G4ThreadPoolSvcCfg()

def G4AtlasToolsConfig.G4ThreadPoolSvcCfg (   flags)

Definition at line 57 of file G4AtlasToolsConfig.py.

57 def G4ThreadPoolSvcCfg(flags):
58  acc = ComponentAccumulator()
59 
60  svc = CompFactory.ThreadPoolSvc(name="ThreadPoolSvc")
61  svc.ThreadInitTools += [CompFactory.G4ThreadInitTool()]
62 
63  acc.addService(svc)
64  return acc
65 

◆ HGTDSensitiveDetectorListCfg()

def G4AtlasToolsConfig.HGTDSensitiveDetectorListCfg (   flags)

Definition at line 224 of file G4AtlasToolsConfig.py.

224 def HGTDSensitiveDetectorListCfg(flags):
225  result = ComponentAccumulator()
226  tools = []
227 
228  if flags.Detector.EnableHGTD:
229  from HGTD_G4_SD.HGTD_G4_SDToolConfig import HgtdSensorSDCfg
230  tools += [ result.popToolsAndMerge(HgtdSensorSDCfg(flags)) ]
231  pass
232 
233  result.setPrivateTools(tools)
234  return result
235 
236 

◆ InDetSensitiveDetectorListCfg()

def G4AtlasToolsConfig.InDetSensitiveDetectorListCfg (   flags)

Definition at line 237 of file G4AtlasToolsConfig.py.

237 def InDetSensitiveDetectorListCfg(flags):
238  result = ComponentAccumulator()
239  tools = []
240 
241  if flags.Detector.EnablePixel:
242  from PixelG4_SD.PixelG4_SDToolConfig import PixelSensorSDCfg
243  tools += [ result.popToolsAndMerge(PixelSensorSDCfg(flags)) ]
244  if flags.Detector.EnableSCT:
245  from SCT_G4_SD.SCT_G4_SDToolConfig import SctSensorSDCfg
246  tools += [ result.popToolsAndMerge(SctSensorSDCfg(flags)) ]
247  if flags.Detector.EnableTRT:
248  from TRT_G4_SD.TRT_G4_SDToolConfig import TRTSensitiveDetectorCfg
249  tools += [ result.popToolsAndMerge(TRTSensitiveDetectorCfg(flags)) ]
250  if flags.Detector.EnableBCM:
251  from BCM_G4_SD.BCM_G4_SDToolConfig import BCMSensorSDCfg
252  tools += [ result.popToolsAndMerge(BCMSensorSDCfg(flags)) ]
253  from BLM_G4_SD.BLM_G4_SDToolConfig import BLMSensorSDCfg
254  tools += [ result.popToolsAndMerge(BLMSensorSDCfg(flags)) ]
255 
256  result.setPrivateTools(tools)
257  return result
258 
259 

◆ InputContainerListCfg()

def G4AtlasToolsConfig.InputContainerListCfg (   flags)

Definition at line 406 of file G4AtlasToolsConfig.py.

406 def InputContainerListCfg(flags):
407  dependencies = []
408  from SimulationConfig.SimEnums import LArParameterization
409  if flags.Sim.LArParameterization is LArParameterization.FastCaloSim:
410  dependencies+=[('CaloDetDescrManager', 'ConditionStore+CaloDetDescrManager'),
411  ('LArfSamplSym', 'ConditionStore+LArfSamplSym'),
412  ('TileSamplingFraction', 'ConditionStore+TileSamplingFraction')]
413  from MuonSensitiveDetectorsR4.SensitiveDetectorsCfg import MuonDependenciesCfg
414  dependencies += MuonDependenciesCfg(flags)
415  return dependencies
416 

◆ ITkSensitiveDetectorListCfg()

def G4AtlasToolsConfig.ITkSensitiveDetectorListCfg (   flags)

Definition at line 205 of file G4AtlasToolsConfig.py.

205 def ITkSensitiveDetectorListCfg(flags):
206  result = ComponentAccumulator()
207  tools = []
208 
209  if flags.Detector.EnableITkPixel:
210  from PixelG4_SD.PixelG4_SDToolConfig import ITkPixelSensorSDCfg
211  tools += [ result.popToolsAndMerge(ITkPixelSensorSDCfg(flags)) ]
212  pass
213  if flags.Detector.EnableITkStrip:
214  from SCT_G4_SD.SCT_G4_SDToolConfig import ITkStripSensorSDCfg
215  tools += [ result.popToolsAndMerge(ITkStripSensorSDCfg(flags)) ]
216  if flags.Detector.EnablePLR:
217  from PixelG4_SD.PixelG4_SDToolConfig import PLRSensorSDCfg
218  tools += [ result.popToolsAndMerge(PLRSensorSDCfg(flags)) ]
219 
220  result.setPrivateTools(tools)
221  return result
222 
223 

◆ MuonSensitiveDetectorListCfg()

def G4AtlasToolsConfig.MuonSensitiveDetectorListCfg (   flags)

Definition at line 299 of file G4AtlasToolsConfig.py.

299 def MuonSensitiveDetectorListCfg(flags):
300  if flags.Muon.usePhaseIIGeoSetup:
301  from MuonSensitiveDetectorsR4.SensitiveDetectorsCfg import SetupSensitiveDetectorsCfg
302  return SetupSensitiveDetectorsCfg(flags)
303  from MuonG4SD.MuonG4SDConfig import SetupSensitiveDetectorsCfg
304  return SetupSensitiveDetectorsCfg(flags)
305 

◆ PunchThroughG4ClassifierCfg()

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

Definition at line 109 of file G4AtlasToolsConfig.py.

109 def PunchThroughG4ClassifierCfg(flags, name="PunchThroughG4Classifier", **kwargs):
110  # declare component accumulator
111  result = ComponentAccumulator()
112  # other arguments
113  kwargs.setdefault("ScalerConfigFileName" , "FastCaloSim/MC23/TFCSparam_mpt_classScaler_v04.xml" )
114  kwargs.setdefault("NetworkConfigFileName" , "FastCaloSim/MC23/TFCSparam_mpt_classNet_v04.json" )
115  kwargs.setdefault("CalibratorConfigFileName" , "FastCaloSim/MC23/TFCSparam_mpt_classCalib_v04.xml")
116  # set as private tool
117  result.setPrivateTools(CompFactory.PunchThroughG4Classifier(name, **kwargs))
118  return result
119 

◆ PunchThroughG4ToolCfg()

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

Definition at line 120 of file G4AtlasToolsConfig.py.

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

◆ PunchThroughSimWrapperCfg()

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

Definition at line 145 of file G4AtlasToolsConfig.py.

145 def PunchThroughSimWrapperCfg(flags, name='PunchThroughSimWrapper', **kwargs):
146  result = ComponentAccumulator()
147 
148  # Set the PunchThroughG4Classifier
149  if "PunchThroughG4Classifier" not in kwargs:
150  kwargs.setdefault("PunchThroughG4Classifier", result.addPublicTool(result.popToolsAndMerge(PunchThroughG4ClassifierCfg(flags))))
151 
152  # Set the PunchThroughG4Tool
153  if "PunchThroughG4Tool" not in kwargs:
154  kwargs.setdefault("PunchThroughG4Tool", result.addPublicTool(result.popToolsAndMerge(PunchThroughG4ToolCfg(flags))))
155 
156  result.setPrivateTools(CompFactory.PunchThroughSimWrapper(name, **kwargs))
157  return result
158 

◆ SensitiveDetectorListCfg()

def G4AtlasToolsConfig.SensitiveDetectorListCfg (   flags)

Definition at line 417 of file G4AtlasToolsConfig.py.

417 def SensitiveDetectorListCfg(flags):
418  result = ComponentAccumulator()
419  tools = []
420  tools += result.popToolsAndMerge(EnvelopeSensitiveDetectorListCfg(flags))
421  tools += result.popToolsAndMerge(InDetSensitiveDetectorListCfg(flags))
422  tools += result.popToolsAndMerge(ITkSensitiveDetectorListCfg(flags))
423  tools += result.popToolsAndMerge(HGTDSensitiveDetectorListCfg(flags))
424  tools += result.popToolsAndMerge(CaloSensitiveDetectorListCfg(flags))
425  tools += result.popToolsAndMerge(MuonSensitiveDetectorListCfg(flags))
426  tools += result.popToolsAndMerge(TrackFastSimSensitiveDetectorListCfg(flags))
427  tools += result.popToolsAndMerge(FwdSensitiveDetectorListCfg(flags))
428  tools += result.popToolsAndMerge(CaloCellContainerSensitiveDetectorListCfg(flags))
429 
430  result.setPrivateTools(tools)
431  return result
432 
433 

◆ SensitiveDetectorMasterToolCfg()

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

Definition at line 484 of file G4AtlasToolsConfig.py.

484 def SensitiveDetectorMasterToolCfg(flags, name="SensitiveDetectorMasterTool", **kwargs):
485  result = ComponentAccumulator()
486  # NB Currently only supporting the standard ATLAS dector and the Tile Test Beam
487  if flags.Beam.Type is BeamType.TestBeam:
488  kwargs.setdefault("SensitiveDetectors", result.popToolsAndMerge(TileTestBeamSensitiveDetectorListCfg(flags)))
489  elif "tb_LArH6" in flags.GeoModel.AtlasVersion:
490  pass
491  elif "ctbh8" in flags.GeoModel.AtlasVersion:
492  kwargs.setdefault("SensitiveDetectors", result.popToolsAndMerge(CombinedTestBeamSensitiveDetectorListCfg(flags)))
493  else:
494  kwargs.setdefault("SensitiveDetectors", result.popToolsAndMerge(SensitiveDetectorListCfg(flags)))
495 
496  result.setPrivateTools(CompFactory.SensitiveDetectorMasterTool(name, **kwargs))
497  return result
498 
499 

◆ SimHitContainerListCfg()

def G4AtlasToolsConfig.SimHitContainerListCfg (   flags)

Definition at line 316 of file G4AtlasToolsConfig.py.

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

◆ TileTestBeamSensitiveDetectorListCfg()

def G4AtlasToolsConfig.TileTestBeamSensitiveDetectorListCfg (   flags)

Definition at line 434 of file G4AtlasToolsConfig.py.

434 def TileTestBeamSensitiveDetectorListCfg(flags):
435  result = ComponentAccumulator()
436  tools = []
437 
438  if flags.Detector.EnableTile:
439  if flags.Sim.CalibrationRun in [CalibrationRun.Tile, CalibrationRun.LArTile, CalibrationRun.LArTileZDC]:
440  from TileGeoG4Calib.TileGeoG4CalibConfig import TileCTBGeoG4CalibSDCfg
441  tools += [ result.popToolsAndMerge(TileCTBGeoG4CalibSDCfg(flags)) ] # mode 1 : With CaloCalibrationHits
442  else:
443  from TileGeoG4SD.TileGeoG4SDToolConfig import TileCTBGeoG4SDCfg
444  tools += [ result.popToolsAndMerge(TileCTBGeoG4SDCfg(flags)) ] # mode 0 : No CaloCalibrationHits
445  from MuonWall.MuonWallConfig import MuonWallSDCfg
446  tools += [ result.popToolsAndMerge(MuonWallSDCfg(flags)) ]
447  result.setPrivateTools(tools)
448  return result
449 
450 

◆ TrackFastSimSensitiveDetectorListCfg()

def G4AtlasToolsConfig.TrackFastSimSensitiveDetectorListCfg (   flags)

Definition at line 187 of file G4AtlasToolsConfig.py.

187 def TrackFastSimSensitiveDetectorListCfg(flags):
188  result = ComponentAccumulator()
189  tools = []
190  if (flags.Detector.EnableMuon and flags.Sim.CavernBackground in [CavernBackground.Write, CavernBackground.WriteWorld]) or flags.Sim.StoppedParticleFile:
191  from TrackWriteFastSim.TrackWriteFastSimConfig import TrackFastSimSDCfg
192  tools += [ result.popToolsAndMerge(TrackFastSimSDCfg(flags)) ]
193  result.setPrivateTools(tools)
194  return result
195 
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:316
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:299
G4AtlasToolsConfig.SensitiveDetectorListCfg
def SensitiveDetectorListCfg(flags)
Definition: G4AtlasToolsConfig.py:417
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:237
TrackWriteFastSimConfig.CosmicTRSDCfg
def CosmicTRSDCfg(flags, name="CosmicRecord", **kwargs)
Definition: TrackWriteFastSimConfig.py:33
G4AtlasToolsConfig.EmptySensitiveDetectorMasterToolCfg
def EmptySensitiveDetectorMasterToolCfg(name="EmptySensitiveDetectorMasterTool", **kwargs)
Definition: G4AtlasToolsConfig.py:500
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:451
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:134
LArG4SDToolConfig.LArInactiveSensitiveDetectorToolCfg
def LArInactiveSensitiveDetectorToolCfg(flags, name="LArInactiveSensitiveDetector", **kwargs)
Definition: LArG4SDToolConfig.py:331
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:66
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:434
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:205
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:109
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:88
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:81
TileGeoG4SDToolConfig.TileGeoG4SDCfg
def TileGeoG4SDCfg(flags, name="TileGeoG4SD", **kwargs)
Definition: TileGeoG4SDToolConfig.py:9
G4AtlasToolsConfig.G4ThreadPoolSvcCfg
def G4ThreadPoolSvcCfg(flags)
Definition: G4AtlasToolsConfig.py:57
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:260
G4AtlasToolsConfig.PunchThroughG4ToolCfg
def PunchThroughG4ToolCfg(flags, name='PunchThroughG4Tool', **kwargs)
Definition: G4AtlasToolsConfig.py:120
G4AtlasToolsConfig.CaloCellContainerSensitiveDetectorListCfg
def CaloCellContainerSensitiveDetectorListCfg(flags)
Definition: G4AtlasToolsConfig.py:196
G4AtlasToolsConfig.FwdSensitiveDetectorListCfg
def FwdSensitiveDetectorListCfg(flags)
Definition: G4AtlasToolsConfig.py:159
G4AtlasServicesConfig.PhysicsListSvcCfg
def PhysicsListSvcCfg(flags, name="PhysicsListSvc", **kwargs)
Definition: G4AtlasServicesConfig.py:15
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:406
LArG4FastSimulationConfig.FCAL2FastShowerCfg
def FCAL2FastShowerCfg(flags, **kwargs)
Definition: LArG4FastSimulationConfig.py:86
G4AtlasToolsConfig.EnvelopeSensitiveDetectorListCfg
def EnvelopeSensitiveDetectorListCfg(flags)
Definition: G4AtlasToolsConfig.py:306
G4AtlasToolsConfig.FastSimulationConstructorToolCfg
def FastSimulationConstructorToolCfg(flags, **kwargs)
Definition: G4AtlasToolsConfig.py:74
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:224
LArG4SDToolConfig.LArFCALSensitiveDetectorCfg
def LArFCALSensitiveDetectorCfg(flags, name="LArFCALSensitiveDetector", **kwargs)
Definition: LArG4SDToolConfig.py:273
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:145
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:187
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:304
G4AtlasToolsConfig.SensitiveDetectorMasterToolCfg
def SensitiveDetectorMasterToolCfg(flags, name="SensitiveDetectorMasterTool", **kwargs)
Definition: G4AtlasToolsConfig.py:484
FastSimulationConstructorTool
Definition: FastSimulationConstructorTool.h:21
Generated on Wed Oct 29 2025 22:01:33 for ATLAS Offline Software by   doxygen 1.8.18