ATLAS Offline Software
Functions
G4AtlasToolsConfig Namespace Reference

Functions

def FastSimulationToolListCfg (flags)
 
def G4ThreadPoolSvcCfg (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 184 of file G4AtlasToolsConfig.py.

184 def CaloCellContainerSensitiveDetectorListCfg(flags):
185  result = ComponentAccumulator()
186  tools = []
187  if flags.Sim.LArParameterization is LArParameterization.FastCaloSim:
188  from ISF_FastCaloSimParametrization.ISF_FastCaloSimParametrizationConfig import CaloCellContainerSDCfg
189  tools += [ result.popToolsAndMerge(CaloCellContainerSDCfg(flags)) ]
190  result.setPrivateTools(tools)
191  return result
192 

◆ CaloSensitiveDetectorListCfg()

def G4AtlasToolsConfig.CaloSensitiveDetectorListCfg (   flags)

Definition at line 248 of file G4AtlasToolsConfig.py.

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

◆ CombinedTestBeamSensitiveDetectorListCfg()

def G4AtlasToolsConfig.CombinedTestBeamSensitiveDetectorListCfg (   flags)

Definition at line 439 of file G4AtlasToolsConfig.py.

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

◆ EmptyFastSimulationMasterToolCfg()

def G4AtlasToolsConfig.EmptyFastSimulationMasterToolCfg (   flags,
**  kwargs 
)

Definition at line 69 of file G4AtlasToolsConfig.py.

69 def EmptyFastSimulationMasterToolCfg(flags, **kwargs):
70  result = ComponentAccumulator()
71  FastSimulationMasterTool = CompFactory.FastSimulationMasterTool
72  tool = result.popToolsAndMerge(FastSimulationMasterTool(name="EmptyFastSimulationMasterTool", **kwargs))
73  result.setPrivateTools(tool)
74  return result
75 

◆ EmptySensitiveDetectorMasterToolCfg()

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

Definition at line 488 of file G4AtlasToolsConfig.py.

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

◆ EnvelopeSensitiveDetectorListCfg()

def G4AtlasToolsConfig.EnvelopeSensitiveDetectorListCfg (   flags)

Definition at line 294 of file G4AtlasToolsConfig.py.

294 def EnvelopeSensitiveDetectorListCfg(flags):
295  result = ComponentAccumulator()
296  tools = []
297  if flags.Beam.Type is BeamType.Cosmics and not flags.Sim.ReadTR:
298  from TrackWriteFastSim.TrackWriteFastSimConfig import CosmicTRSDCfg
299  tools += [ result.popToolsAndMerge(CosmicTRSDCfg(flags)) ]
300  result.setPrivateTools(tools)
301  return result
302 
303 

◆ FastSimulationMasterToolCfg()

def G4AtlasToolsConfig.FastSimulationMasterToolCfg (   flags,
**  kwargs 
)

Definition at line 61 of file G4AtlasToolsConfig.py.

61 def FastSimulationMasterToolCfg(flags, **kwargs):
62  result = ComponentAccumulator()
63  kwargs.setdefault("FastSimulations", result.popToolsAndMerge(FastSimulationToolListCfg(flags)))
64  FastSimulationMasterTool = CompFactory.FastSimulationMasterTool
65  result.setPrivateTools(FastSimulationMasterTool(name="FastSimulationMasterTool", **kwargs))
66  return result
67 
68 

◆ 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 

◆ FwdSensitiveDetectorListCfg()

def G4AtlasToolsConfig.FwdSensitiveDetectorListCfg (   flags)

Definition at line 147 of file G4AtlasToolsConfig.py.

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

◆ G4CaloTransportToolCfg()

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

Definition at line 76 of file G4AtlasToolsConfig.py.

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

◆ G4ThreadPoolSvcCfg()

def G4AtlasToolsConfig.G4ThreadPoolSvcCfg (   flags)

Definition at line 52 of file G4AtlasToolsConfig.py.

52 def G4ThreadPoolSvcCfg(flags):
53  acc = ComponentAccumulator()
54 
55  svc = CompFactory.ThreadPoolSvc(name="ThreadPoolSvc")
56  svc.ThreadInitTools += [CompFactory.G4ThreadInitTool()]
57 
58  acc.addService(svc)
59  return acc
60 

◆ HGTDSensitiveDetectorListCfg()

def G4AtlasToolsConfig.HGTDSensitiveDetectorListCfg (   flags)

Definition at line 212 of file G4AtlasToolsConfig.py.

212 def HGTDSensitiveDetectorListCfg(flags):
213  result = ComponentAccumulator()
214  tools = []
215 
216  if flags.Detector.EnableHGTD:
217  from HGTD_G4_SD.HGTD_G4_SDToolConfig import HgtdSensorSDCfg
218  tools += [ result.popToolsAndMerge(HgtdSensorSDCfg(flags)) ]
219  pass
220 
221  result.setPrivateTools(tools)
222  return result
223 
224 

◆ InDetSensitiveDetectorListCfg()

def G4AtlasToolsConfig.InDetSensitiveDetectorListCfg (   flags)

Definition at line 225 of file G4AtlasToolsConfig.py.

225 def InDetSensitiveDetectorListCfg(flags):
226  result = ComponentAccumulator()
227  tools = []
228 
229  if flags.Detector.EnablePixel:
230  from PixelG4_SD.PixelG4_SDToolConfig import PixelSensorSDCfg
231  tools += [ result.popToolsAndMerge(PixelSensorSDCfg(flags)) ]
232  if flags.Detector.EnableSCT:
233  from SCT_G4_SD.SCT_G4_SDToolConfig import SctSensorSDCfg
234  tools += [ result.popToolsAndMerge(SctSensorSDCfg(flags)) ]
235  if flags.Detector.EnableTRT:
236  from TRT_G4_SD.TRT_G4_SDToolConfig import TRTSensitiveDetectorCfg
237  tools += [ result.popToolsAndMerge(TRTSensitiveDetectorCfg(flags)) ]
238  if flags.Detector.EnableBCM:
239  from BCM_G4_SD.BCM_G4_SDToolConfig import BCMSensorSDCfg
240  tools += [ result.popToolsAndMerge(BCMSensorSDCfg(flags)) ]
241  from BLM_G4_SD.BLM_G4_SDToolConfig import BLMSensorSDCfg
242  tools += [ result.popToolsAndMerge(BLMSensorSDCfg(flags)) ]
243 
244  result.setPrivateTools(tools)
245  return result
246 
247 

◆ InputContainerListCfg()

def G4AtlasToolsConfig.InputContainerListCfg (   flags)

Definition at line 394 of file G4AtlasToolsConfig.py.

394 def InputContainerListCfg(flags):
395  dependencies = []
396  from SimulationConfig.SimEnums import LArParameterization
397  if flags.Sim.LArParameterization is LArParameterization.FastCaloSim:
398  dependencies+=[('CaloDetDescrManager', 'ConditionStore+CaloDetDescrManager'),
399  ('LArfSamplSym', 'ConditionStore+LArfSamplSym'),
400  ('TileSamplingFraction', 'ConditionStore+TileSamplingFraction')]
401  from MuonSensitiveDetectorsR4.SensitiveDetectorsCfg import MuonDependenciesCfg
402  dependencies += MuonDependenciesCfg(flags)
403  return dependencies
404 

◆ ITkSensitiveDetectorListCfg()

def G4AtlasToolsConfig.ITkSensitiveDetectorListCfg (   flags)

Definition at line 193 of file G4AtlasToolsConfig.py.

193 def ITkSensitiveDetectorListCfg(flags):
194  result = ComponentAccumulator()
195  tools = []
196 
197  if flags.Detector.EnableITkPixel:
198  from PixelG4_SD.PixelG4_SDToolConfig import ITkPixelSensorSDCfg
199  tools += [ result.popToolsAndMerge(ITkPixelSensorSDCfg(flags)) ]
200  pass
201  if flags.Detector.EnableITkStrip:
202  from SCT_G4_SD.SCT_G4_SDToolConfig import ITkStripSensorSDCfg
203  tools += [ result.popToolsAndMerge(ITkStripSensorSDCfg(flags)) ]
204  if flags.Detector.EnablePLR:
205  from PixelG4_SD.PixelG4_SDToolConfig import PLRSensorSDCfg
206  tools += [ result.popToolsAndMerge(PLRSensorSDCfg(flags)) ]
207 
208  result.setPrivateTools(tools)
209  return result
210 
211 

◆ MuonSensitiveDetectorListCfg()

def G4AtlasToolsConfig.MuonSensitiveDetectorListCfg (   flags)

Definition at line 287 of file G4AtlasToolsConfig.py.

287 def MuonSensitiveDetectorListCfg(flags):
288  if flags.Muon.usePhaseIIGeoSetup:
289  from MuonSensitiveDetectorsR4.SensitiveDetectorsCfg import SetupSensitiveDetectorsCfg
290  return SetupSensitiveDetectorsCfg(flags)
291  from MuonG4SD.MuonG4SDConfig import SetupSensitiveDetectorsCfg
292  return SetupSensitiveDetectorsCfg(flags)
293 

◆ PunchThroughG4ClassifierCfg()

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

Definition at line 97 of file G4AtlasToolsConfig.py.

97 def PunchThroughG4ClassifierCfg(flags, name="PunchThroughG4Classifier", **kwargs):
98  # declare component accumulator
99  result = ComponentAccumulator()
100  # other arguments
101  kwargs.setdefault("ScalerConfigFileName" , "FastCaloSim/MC23/TFCSparam_mpt_classScaler_v04.xml" )
102  kwargs.setdefault("NetworkConfigFileName" , "FastCaloSim/MC23/TFCSparam_mpt_classNet_v04.json" )
103  kwargs.setdefault("CalibratorConfigFileName" , "FastCaloSim/MC23/TFCSparam_mpt_classCalib_v04.xml")
104  # set as private tool
105  result.setPrivateTools(CompFactory.PunchThroughG4Classifier(name, **kwargs))
106  return result
107 

◆ PunchThroughG4ToolCfg()

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

Definition at line 108 of file G4AtlasToolsConfig.py.

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

◆ PunchThroughSimWrapperCfg()

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

Definition at line 133 of file G4AtlasToolsConfig.py.

133 def PunchThroughSimWrapperCfg(flags, name='PunchThroughSimWrapper', **kwargs):
134  result = ComponentAccumulator()
135 
136  # Set the PunchThroughG4Classifier
137  if "PunchThroughG4Classifier" not in kwargs:
138  kwargs.setdefault("PunchThroughG4Classifier", result.addPublicTool(result.popToolsAndMerge(PunchThroughG4ClassifierCfg(flags))))
139 
140  # Set the PunchThroughG4Tool
141  if "PunchThroughG4Tool" not in kwargs:
142  kwargs.setdefault("PunchThroughG4Tool", result.addPublicTool(result.popToolsAndMerge(PunchThroughG4ToolCfg(flags))))
143 
144  result.setPrivateTools(CompFactory.PunchThroughSimWrapper(name, **kwargs))
145  return result
146 

◆ SensitiveDetectorListCfg()

def G4AtlasToolsConfig.SensitiveDetectorListCfg (   flags)

Definition at line 405 of file G4AtlasToolsConfig.py.

405 def SensitiveDetectorListCfg(flags):
406  result = ComponentAccumulator()
407  tools = []
408  tools += result.popToolsAndMerge(EnvelopeSensitiveDetectorListCfg(flags))
409  tools += result.popToolsAndMerge(InDetSensitiveDetectorListCfg(flags))
410  tools += result.popToolsAndMerge(ITkSensitiveDetectorListCfg(flags))
411  tools += result.popToolsAndMerge(HGTDSensitiveDetectorListCfg(flags))
412  tools += result.popToolsAndMerge(CaloSensitiveDetectorListCfg(flags))
413  tools += result.popToolsAndMerge(MuonSensitiveDetectorListCfg(flags))
414  tools += result.popToolsAndMerge(TrackFastSimSensitiveDetectorListCfg(flags))
415  tools += result.popToolsAndMerge(FwdSensitiveDetectorListCfg(flags))
416  tools += result.popToolsAndMerge(CaloCellContainerSensitiveDetectorListCfg(flags))
417 
418  result.setPrivateTools(tools)
419  return result
420 
421 

◆ SensitiveDetectorMasterToolCfg()

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

Definition at line 472 of file G4AtlasToolsConfig.py.

472 def SensitiveDetectorMasterToolCfg(flags, name="SensitiveDetectorMasterTool", **kwargs):
473  result = ComponentAccumulator()
474  # NB Currently only supporting the standard ATLAS dector and the Tile Test Beam
475  if flags.Beam.Type is BeamType.TestBeam:
476  kwargs.setdefault("SensitiveDetectors", result.popToolsAndMerge(TileTestBeamSensitiveDetectorListCfg(flags)))
477  elif "tb_LArH6" in flags.GeoModel.AtlasVersion:
478  pass
479  elif "ctbh8" in flags.GeoModel.AtlasVersion:
480  kwargs.setdefault("SensitiveDetectors", result.popToolsAndMerge(CombinedTestBeamSensitiveDetectorListCfg(flags)))
481  else:
482  kwargs.setdefault("SensitiveDetectors", result.popToolsAndMerge(SensitiveDetectorListCfg(flags)))
483 
484  result.setPrivateTools(CompFactory.SensitiveDetectorMasterTool(name, **kwargs))
485  return result
486 
487 

◆ SimHitContainerListCfg()

def G4AtlasToolsConfig.SimHitContainerListCfg (   flags)

Definition at line 304 of file G4AtlasToolsConfig.py.

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

◆ TileTestBeamSensitiveDetectorListCfg()

def G4AtlasToolsConfig.TileTestBeamSensitiveDetectorListCfg (   flags)

Definition at line 422 of file G4AtlasToolsConfig.py.

422 def TileTestBeamSensitiveDetectorListCfg(flags):
423  result = ComponentAccumulator()
424  tools = []
425 
426  if flags.Detector.EnableTile:
427  if flags.Sim.CalibrationRun in [CalibrationRun.Tile, CalibrationRun.LArTile, CalibrationRun.LArTileZDC]:
428  from TileGeoG4Calib.TileGeoG4CalibConfig import TileCTBGeoG4CalibSDCfg
429  tools += [ result.popToolsAndMerge(TileCTBGeoG4CalibSDCfg(flags)) ] # mode 1 : With CaloCalibrationHits
430  else:
431  from TileGeoG4SD.TileGeoG4SDToolConfig import TileCTBGeoG4SDCfg
432  tools += [ result.popToolsAndMerge(TileCTBGeoG4SDCfg(flags)) ] # mode 0 : No CaloCalibrationHits
433  from MuonWall.MuonWallConfig import MuonWallSDCfg
434  tools += [ result.popToolsAndMerge(MuonWallSDCfg(flags)) ]
435  result.setPrivateTools(tools)
436  return result
437 
438 

◆ TrackFastSimSensitiveDetectorListCfg()

def G4AtlasToolsConfig.TrackFastSimSensitiveDetectorListCfg (   flags)

Definition at line 175 of file G4AtlasToolsConfig.py.

175 def TrackFastSimSensitiveDetectorListCfg(flags):
176  result = ComponentAccumulator()
177  tools = []
178  if (flags.Detector.EnableMuon and flags.Sim.CavernBackground in [CavernBackground.Write, CavernBackground.WriteWorld]) or flags.Sim.StoppedParticleFile:
179  from TrackWriteFastSim.TrackWriteFastSimConfig import TrackFastSimSDCfg
180  tools += [ result.popToolsAndMerge(TrackFastSimSDCfg(flags)) ]
181  result.setPrivateTools(tools)
182  return result
183 
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:304
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:287
G4AtlasToolsConfig.SensitiveDetectorListCfg
def SensitiveDetectorListCfg(flags)
Definition: G4AtlasToolsConfig.py:405
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:225
TrackWriteFastSimConfig.CosmicTRSDCfg
def CosmicTRSDCfg(flags, name="CosmicRecord", **kwargs)
Definition: TrackWriteFastSimConfig.py:33
G4AtlasToolsConfig.EmptySensitiveDetectorMasterToolCfg
def EmptySensitiveDetectorMasterToolCfg(name="EmptySensitiveDetectorMasterTool", **kwargs)
Definition: G4AtlasToolsConfig.py:488
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:439
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:61
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:422
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:193
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:97
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:76
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:69
TileGeoG4SDToolConfig.TileGeoG4SDCfg
def TileGeoG4SDCfg(flags, name="TileGeoG4SD", **kwargs)
Definition: TileGeoG4SDToolConfig.py:9
G4AtlasToolsConfig.G4ThreadPoolSvcCfg
def G4ThreadPoolSvcCfg(flags)
Definition: G4AtlasToolsConfig.py:52
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:248
G4AtlasToolsConfig.PunchThroughG4ToolCfg
def PunchThroughG4ToolCfg(flags, name='PunchThroughG4Tool', **kwargs)
Definition: G4AtlasToolsConfig.py:108
G4AtlasToolsConfig.CaloCellContainerSensitiveDetectorListCfg
def CaloCellContainerSensitiveDetectorListCfg(flags)
Definition: G4AtlasToolsConfig.py:184
G4AtlasToolsConfig.FwdSensitiveDetectorListCfg
def FwdSensitiveDetectorListCfg(flags)
Definition: G4AtlasToolsConfig.py:147
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:394
LArG4FastSimulationConfig.FCAL2FastShowerCfg
def FCAL2FastShowerCfg(flags, **kwargs)
Definition: LArG4FastSimulationConfig.py:86
G4AtlasToolsConfig.EnvelopeSensitiveDetectorListCfg
def EnvelopeSensitiveDetectorListCfg(flags)
Definition: G4AtlasToolsConfig.py:294
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:212
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:133
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:175
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:472
Generated on Mon Sep 1 2025 22:00:05 for ATLAS Offline Software by   doxygen 1.8.18