ATLAS Offline Software
Loading...
Searching...
No Matches
Functions
G4AtlasToolsConfig Namespace Reference

Functions

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

Function Documentation

◆ CaloCellContainerSensitiveDetectorListCfg()

G4AtlasToolsConfig.CaloCellContainerSensitiveDetectorListCfg ( flags)

Definition at line 196 of file G4AtlasToolsConfig.py.

196def 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()

G4AtlasToolsConfig.CaloSensitiveDetectorListCfg ( flags)

Definition at line 260 of file G4AtlasToolsConfig.py.

260def 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()

G4AtlasToolsConfig.CombinedTestBeamSensitiveDetectorListCfg ( flags)

Definition at line 451 of file G4AtlasToolsConfig.py.

451def 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()

G4AtlasToolsConfig.EmptyFastSimulationMasterToolCfg ( flags,
** kwargs )

Definition at line 81 of file G4AtlasToolsConfig.py.

81def 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()

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

Definition at line 500 of file G4AtlasToolsConfig.py.

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

◆ EnvelopeSensitiveDetectorListCfg()

G4AtlasToolsConfig.EnvelopeSensitiveDetectorListCfg ( flags)

Definition at line 306 of file G4AtlasToolsConfig.py.

306def 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()

G4AtlasToolsConfig.FastSimulationConstructorToolCfg ( flags,
** kwargs )

Definition at line 74 of file G4AtlasToolsConfig.py.

74def FastSimulationConstructorToolCfg(flags, **kwargs):
75 result = ComponentAccumulator()
76 FastSimulationConstructorTool = CompFactory.FastSimulationConstructorTool
77 result.setPrivateTools(FastSimulationConstructorTool(name="FastSimulationConstructorTool", **kwargs))
78 return result
79
80
FastSimulationConstructorTool
This tool creates a physics constructor to enable fast simulation for all particles.
Definition FastSimulationConstructorTool.h:21

◆ FastSimulationMasterToolCfg()

G4AtlasToolsConfig.FastSimulationMasterToolCfg ( flags,
** kwargs )

Definition at line 66 of file G4AtlasToolsConfig.py.

66def 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()

G4AtlasToolsConfig.FastSimulationToolListCfg ( flags)

Definition at line 10 of file G4AtlasToolsConfig.py.

10def 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()

G4AtlasToolsConfig.FwdSensitiveDetectorListCfg ( flags)

Definition at line 159 of file G4AtlasToolsConfig.py.

159def 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()

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

Definition at line 88 of file G4AtlasToolsConfig.py.

88def 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()

G4AtlasToolsConfig.G4ThreadPoolSvcCfg ( flags)

Definition at line 57 of file G4AtlasToolsConfig.py.

57def 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()

G4AtlasToolsConfig.HGTDSensitiveDetectorListCfg ( flags)

Definition at line 224 of file G4AtlasToolsConfig.py.

224def 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()

G4AtlasToolsConfig.InDetSensitiveDetectorListCfg ( flags)

Definition at line 237 of file G4AtlasToolsConfig.py.

237def 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()

G4AtlasToolsConfig.InputContainerListCfg ( flags)

Definition at line 406 of file G4AtlasToolsConfig.py.

406def 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()

G4AtlasToolsConfig.ITkSensitiveDetectorListCfg ( flags)

Definition at line 205 of file G4AtlasToolsConfig.py.

205def 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()

G4AtlasToolsConfig.MuonSensitiveDetectorListCfg ( flags)

Definition at line 299 of file G4AtlasToolsConfig.py.

299def 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()

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

Definition at line 109 of file G4AtlasToolsConfig.py.

109def 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()

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

Definition at line 120 of file G4AtlasToolsConfig.py.

120def 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()

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

Definition at line 145 of file G4AtlasToolsConfig.py.

145def 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()

G4AtlasToolsConfig.SensitiveDetectorListCfg ( flags)

Definition at line 417 of file G4AtlasToolsConfig.py.

417def 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()

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

Definition at line 484 of file G4AtlasToolsConfig.py.

484def 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()

G4AtlasToolsConfig.SimHitContainerListCfg ( flags)

Definition at line 316 of file G4AtlasToolsConfig.py.

316def 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()

G4AtlasToolsConfig.TileTestBeamSensitiveDetectorListCfg ( flags)

Definition at line 434 of file G4AtlasToolsConfig.py.

434def 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()

G4AtlasToolsConfig.TrackFastSimSensitiveDetectorListCfg ( flags)

Definition at line 187 of file G4AtlasToolsConfig.py.

187def 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
Generated on for ATLAS Offline Software by doxygen 1.14.0