ATLAS Offline Software
Functions
G4AtlasToolsConfig Namespace Reference

Functions

def FastSimulationToolListCfg (flags)
 
def FastSimulationMasterToolCfg (flags, **kwargs)
 
def EmptyFastSimulationMasterToolCfg (flags, **kwargs)
 
def G4CaloTransportToolCfg (flags, name='G4CaloTransportTool', **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 126 of file G4AtlasToolsConfig.py.

126 def CaloCellContainerSensitiveDetectorListCfg(flags):
127  result = ComponentAccumulator()
128  tools = []
129  if flags.Sim.LArParameterization is LArParameterization.FastCaloSim:
130  from ISF_FastCaloSimParametrization.ISF_FastCaloSimParametrizationConfig import CaloCellContainerSDCfg
131  tools += [ result.popToolsAndMerge(CaloCellContainerSDCfg(flags)) ]
132  result.setPrivateTools(tools)
133  return result
134 

◆ CaloSensitiveDetectorListCfg()

def G4AtlasToolsConfig.CaloSensitiveDetectorListCfg (   flags)

Definition at line 190 of file G4AtlasToolsConfig.py.

190 def CaloSensitiveDetectorListCfg(flags):
191  result = ComponentAccumulator()
192  tools = []
193 
194  if flags.Detector.EnableLAr:
195  from LArG4SD.LArG4SDToolConfig import LArEMBSensitiveDetectorCfg, LArEMECSensitiveDetectorCfg, LArFCALSensitiveDetectorCfg, LArHECSensitiveDetectorCfg
196  tools += [ result.popToolsAndMerge(LArEMBSensitiveDetectorCfg(flags)) ]
197  tools += [ result.popToolsAndMerge(LArEMECSensitiveDetectorCfg(flags)) ]
198  tools += [ result.popToolsAndMerge(LArFCALSensitiveDetectorCfg(flags)) ]
199  tools += [ result.popToolsAndMerge(LArHECSensitiveDetectorCfg(flags)) ]
200 
201  if flags.Detector.EnableMBTS:
202  from MinBiasScintillator.MinBiasScintillatorToolConfig import MinBiasScintillatorSDCfg
203  tools += [ result.popToolsAndMerge(MinBiasScintillatorSDCfg(flags)) ]
204 
205  if flags.Sim.CalibrationRun in [CalibrationRun.LAr, CalibrationRun.LArTile, CalibrationRun.LArTileZDC]:
206  from LArG4SD.LArG4SDToolConfig import LArDeadSensitiveDetectorToolCfg, LArActiveSensitiveDetectorToolCfg, LArInactiveSensitiveDetectorToolCfg
207  tools += [ result.popToolsAndMerge(LArDeadSensitiveDetectorToolCfg(flags)) ]
208  tools += [ result.popToolsAndMerge(LArInactiveSensitiveDetectorToolCfg(flags)) ]
209  tools += [ result.popToolsAndMerge(LArActiveSensitiveDetectorToolCfg(flags)) ]
210  elif flags.Sim.CalibrationRun is CalibrationRun.DeadLAr:
211  from LArG4SD.LArG4SDToolConfig import LArDeadSensitiveDetectorToolCfg
212  tools += [ result.popToolsAndMerge(LArDeadSensitiveDetectorToolCfg(flags)) ]
213 
214  if flags.Detector.EnableTile:
215  if flags.Sim.CalibrationRun in [CalibrationRun.Tile, CalibrationRun.LArTile, CalibrationRun.LArTileZDC]:
216  from TileGeoG4Calib.TileGeoG4CalibConfig import TileGeoG4CalibSDCfg
217  tools += [ result.popToolsAndMerge(TileGeoG4CalibSDCfg(flags)) ] # mode 1 : With CaloCalibrationHits
218  else:
219  from TileGeoG4SD.TileGeoG4SDToolConfig import TileGeoG4SDCfg
220  tools += [ result.popToolsAndMerge(TileGeoG4SDCfg(flags)) ] # mode 0 : No CaloCalibrationHits
221  if flags.Sim.RecordStepInfo:
222  from ISF_FastCaloSimSD.ISF_FastCaloSimSDToolConfig import FCS_StepInfoSDToolCfg
223  tools += [ result.popToolsAndMerge(FCS_StepInfoSDToolCfg(flags)) ]
224 
225  result.setPrivateTools(tools)
226  return result
227 
228 

◆ CombinedTestBeamSensitiveDetectorListCfg()

def G4AtlasToolsConfig.CombinedTestBeamSensitiveDetectorListCfg (   flags)

Definition at line 339 of file G4AtlasToolsConfig.py.

339 def CombinedTestBeamSensitiveDetectorListCfg(flags):
340  result = ComponentAccumulator()
341  tools = []
342  if flags.Detector.EnablePixel:
343  from PixelG4_SD.PixelG4_SDToolConfig import PixelSensor_CTBCfg
344  tools += [ result.popToolsAndMerge(PixelSensor_CTBCfg(flags)) ]
345  if flags.Detector.EnableSCT:
346  from SCT_G4_SD.SCT_G4_SDToolConfig import SctSensor_CTBCfg
347  tools += [ result.popToolsAndMerge(SctSensor_CTBCfg(flags)) ]
348  if flags.Detector.EnableTRT:
349  from TRT_G4_SD.TRT_G4_SDToolConfig import TRTSensitiveDetector_CTBCfg
350  tools += [ result.popToolsAndMerge(TRTSensitiveDetector_CTBCfg(flags)) ]
351  if flags.Detector.EnableLAr:
352  from LArG4SD.LArG4SDToolConfig import LArEMBSensitiveDetectorCfg
353  tools += [ result.popToolsAndMerge(LArEMBSensitiveDetectorCfg(flags)) ]
354  if flags.Sim.CalibrationRun in [CalibrationRun.LAr, CalibrationRun.LArTile, CalibrationRun.LArTileZDC, CalibrationRun.DeadLAr]:
355  tools += [ 'LArH8CalibSensitiveDetector' ] # mode 1 : With CaloCalibrationHits
356  if flags.Detector.EnableTile:
357  if flags.Sim.CalibrationRun in [CalibrationRun.Tile, CalibrationRun.LArTile, CalibrationRun.LArTileZDC]:
358  from TileGeoG4Calib.TileGeoG4CalibConfig import TileCTBGeoG4CalibSDCfg
359  tools += [ result.popToolsAndMerge(TileCTBGeoG4CalibSDCfg(flags)) ] # mode 1 : With CaloCalibrationHits
360  else:
361  from TileGeoG4SD.TileGeoG4SDToolConfig import TileCTBGeoG4SDCfg
362  tools += [ result.popToolsAndMerge(TileCTBGeoG4SDCfg(flags)) ] # mode 0 : No CaloCalibrationHits
363  tools += [ 'MuonWallSD' ]
364  if flags.Detector.EnableMuon:
365  tools += [ 'MuonEntryRecord' ]
366  tools += result.popToolsAndMerge(MuonSensitiveDetectorListCfg(flags))
367 
368  result.setPrivateTools(tools)
369  return result
370 
371 

◆ EmptyFastSimulationMasterToolCfg()

def G4AtlasToolsConfig.EmptyFastSimulationMasterToolCfg (   flags,
**  kwargs 
)

Definition at line 61 of file G4AtlasToolsConfig.py.

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

◆ EmptySensitiveDetectorMasterToolCfg()

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

Definition at line 388 of file G4AtlasToolsConfig.py.

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

◆ EnvelopeSensitiveDetectorListCfg()

def G4AtlasToolsConfig.EnvelopeSensitiveDetectorListCfg (   flags)

Definition at line 236 of file G4AtlasToolsConfig.py.

236 def EnvelopeSensitiveDetectorListCfg(flags):
237  result = ComponentAccumulator()
238  tools = []
239  if flags.Beam.Type is BeamType.Cosmics and not flags.Sim.ReadTR:
240  from TrackWriteFastSim.TrackWriteFastSimConfig import CosmicTRSDCfg
241  tools += [ result.popToolsAndMerge(CosmicTRSDCfg(flags)) ]
242  result.setPrivateTools(tools)
243  return result
244 
245 

◆ FastSimulationMasterToolCfg()

def G4AtlasToolsConfig.FastSimulationMasterToolCfg (   flags,
**  kwargs 
)

Definition at line 53 of file G4AtlasToolsConfig.py.

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

◆ FastSimulationToolListCfg()

def G4AtlasToolsConfig.FastSimulationToolListCfg (   flags)

Definition at line 10 of file G4AtlasToolsConfig.py.

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

◆ FwdSensitiveDetectorListCfg()

def G4AtlasToolsConfig.FwdSensitiveDetectorListCfg (   flags)

Definition at line 89 of file G4AtlasToolsConfig.py.

89 def FwdSensitiveDetectorListCfg(flags):
90  # TODO: migrate to CA
91  result = ComponentAccumulator()
92  tools = []
93  if flags.Detector.EnableLucid:
94  from LUCID_G4_SD.LUCID_G4_SDConfig import LUCID_SensitiveDetectorCfg
95  tools += [ result.popToolsAndMerge(LUCID_SensitiveDetectorCfg(flags)) ]
96  if flags.Detector.EnableForward:
97  if flags.Detector.EnableZDC:
98  from ZDC_SD.ZDC_SDConfig import ZDC_FiberSDCfg
99  tools += [ result.popToolsAndMerge(ZDC_FiberSDCfg(flags)) ]
100  if flags.Sim.CalibrationRun in [CalibrationRun.ZDC, CalibrationRun.LArTileZDC]:
101  from ZDC_SD.ZDC_SDConfig import ZDC_G4CalibSDCfg
102  tools += [ result.popToolsAndMerge(ZDC_G4CalibSDCfg(flags)) ]
103  if flags.Detector.EnableALFA:
104  from ALFA_G4_SD.ALFA_G4_SDConfig import ALFA_SensitiveDetectorCfg
105  tools += [ result.popToolsAndMerge(ALFA_SensitiveDetectorCfg(flags)) ]
106  if flags.Detector.EnableAFP:
107  from AFP_G4_SD.AFP_G4_SDConfig import AFP_SensitiveDetectorCfg
108  tools += [ result.popToolsAndMerge(AFP_SensitiveDetectorCfg(flags)) ]
109  # Alternative implementations
110  # from AFP_G4_SD.AFP_G4_SDConfig import AFP_SiDSensitiveDetectorCfg, AFP_TDSensitiveDetectorCfg
111  # tools += [ result.popToolsAndMerge(AFP_SiDSensitiveDetectorCfg(flags)) ]
112  # tools += [ result.popToolsAndMerge(AFP_TDSensitiveDetectorCfg(flags)) ]
113  result.setPrivateTools(tools)
114  return result
115 
116 

◆ G4CaloTransportToolCfg()

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

Definition at line 68 of file G4AtlasToolsConfig.py.

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

◆ HGTDSensitiveDetectorListCfg()

def G4AtlasToolsConfig.HGTDSensitiveDetectorListCfg (   flags)

Definition at line 154 of file G4AtlasToolsConfig.py.

154 def HGTDSensitiveDetectorListCfg(flags):
155  result = ComponentAccumulator()
156  tools = []
157 
158  if flags.Detector.EnableHGTD:
159  from HGTD_G4_SD.HGTD_G4_SDToolConfig import HgtdSensorSDCfg
160  tools += [ result.popToolsAndMerge(HgtdSensorSDCfg(flags)) ]
161  pass
162 
163  result.setPrivateTools(tools)
164  return result
165 
166 

◆ InDetSensitiveDetectorListCfg()

def G4AtlasToolsConfig.InDetSensitiveDetectorListCfg (   flags)

Definition at line 167 of file G4AtlasToolsConfig.py.

167 def InDetSensitiveDetectorListCfg(flags):
168  result = ComponentAccumulator()
169  tools = []
170 
171  if flags.Detector.EnablePixel:
172  from PixelG4_SD.PixelG4_SDToolConfig import PixelSensorSDCfg
173  tools += [ result.popToolsAndMerge(PixelSensorSDCfg(flags)) ]
174  if flags.Detector.EnableSCT:
175  from SCT_G4_SD.SCT_G4_SDToolConfig import SctSensorSDCfg
176  tools += [ result.popToolsAndMerge(SctSensorSDCfg(flags)) ]
177  if flags.Detector.EnableTRT:
178  from TRT_G4_SD.TRT_G4_SDToolConfig import TRTSensitiveDetectorCfg
179  tools += [ result.popToolsAndMerge(TRTSensitiveDetectorCfg(flags)) ]
180  if flags.Detector.EnableBCM:
181  from BCM_G4_SD.BCM_G4_SDToolConfig import BCMSensorSDCfg
182  tools += [ result.popToolsAndMerge(BCMSensorSDCfg(flags)) ]
183  from BLM_G4_SD.BLM_G4_SDToolConfig import BLMSensorSDCfg
184  tools += [ result.popToolsAndMerge(BLMSensorSDCfg(flags)) ]
185 
186  result.setPrivateTools(tools)
187  return result
188 
189 

◆ InputContainerListCfg()

def G4AtlasToolsConfig.InputContainerListCfg (   flags)

Definition at line 294 of file G4AtlasToolsConfig.py.

294 def InputContainerListCfg(flags):
295  dependencies = []
296  from SimulationConfig.SimEnums import LArParameterization
297  if flags.Sim.LArParameterization is LArParameterization.FastCaloSim:
298  dependencies+=[('CaloDetDescrManager', 'ConditionStore+CaloDetDescrManager'),
299  ('LArfSamplSym', 'ConditionStore+LArfSamplSym'),
300  ('TileSamplingFraction', 'ConditionStore+TileSamplingFraction')]
301  from MuonSensitiveDetectorsR4.SensitiveDetectorsCfg import MuonDependenciesCfg
302  dependencies += MuonDependenciesCfg(flags)
303  return dependencies
304 

◆ ITkSensitiveDetectorListCfg()

def G4AtlasToolsConfig.ITkSensitiveDetectorListCfg (   flags)

Definition at line 135 of file G4AtlasToolsConfig.py.

135 def ITkSensitiveDetectorListCfg(flags):
136  result = ComponentAccumulator()
137  tools = []
138 
139  if flags.Detector.EnableITkPixel:
140  from PixelG4_SD.PixelG4_SDToolConfig import ITkPixelSensorSDCfg
141  tools += [ result.popToolsAndMerge(ITkPixelSensorSDCfg(flags)) ]
142  pass
143  if flags.Detector.EnableITkStrip:
144  from SCT_G4_SD.SCT_G4_SDToolConfig import ITkStripSensorSDCfg
145  tools += [ result.popToolsAndMerge(ITkStripSensorSDCfg(flags)) ]
146  if flags.Detector.EnablePLR:
147  from PixelG4_SD.PixelG4_SDToolConfig import PLRSensorSDCfg
148  tools += [ result.popToolsAndMerge(PLRSensorSDCfg(flags)) ]
149 
150  result.setPrivateTools(tools)
151  return result
152 
153 

◆ MuonSensitiveDetectorListCfg()

def G4AtlasToolsConfig.MuonSensitiveDetectorListCfg (   flags)

Definition at line 229 of file G4AtlasToolsConfig.py.

229 def MuonSensitiveDetectorListCfg(flags):
230  if flags.Muon.usePhaseIIGeoSetup:
231  from MuonSensitiveDetectorsR4.SensitiveDetectorsCfg import SetupSensitiveDetectorsCfg
232  return SetupSensitiveDetectorsCfg(flags)
233  from MuonG4SD.MuonG4SDConfig import SetupSensitiveDetectorsCfg
234  return SetupSensitiveDetectorsCfg(flags)
235 

◆ SensitiveDetectorListCfg()

def G4AtlasToolsConfig.SensitiveDetectorListCfg (   flags)

Definition at line 305 of file G4AtlasToolsConfig.py.

305 def SensitiveDetectorListCfg(flags):
306  result = ComponentAccumulator()
307  tools = []
308  tools += result.popToolsAndMerge(EnvelopeSensitiveDetectorListCfg(flags))
309  tools += result.popToolsAndMerge(InDetSensitiveDetectorListCfg(flags))
310  tools += result.popToolsAndMerge(ITkSensitiveDetectorListCfg(flags))
311  tools += result.popToolsAndMerge(HGTDSensitiveDetectorListCfg(flags))
312  tools += result.popToolsAndMerge(CaloSensitiveDetectorListCfg(flags))
313  tools += result.popToolsAndMerge(MuonSensitiveDetectorListCfg(flags))
314  tools += result.popToolsAndMerge(TrackFastSimSensitiveDetectorListCfg(flags))
315  tools += result.popToolsAndMerge(FwdSensitiveDetectorListCfg(flags))
316  tools += result.popToolsAndMerge(CaloCellContainerSensitiveDetectorListCfg(flags))
317 
318  result.setPrivateTools(tools)
319  return result
320 
321 

◆ SensitiveDetectorMasterToolCfg()

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

Definition at line 372 of file G4AtlasToolsConfig.py.

372 def SensitiveDetectorMasterToolCfg(flags, name="SensitiveDetectorMasterTool", **kwargs):
373  result = ComponentAccumulator()
374  # NB Currently only supporting the standard ATLAS dector and the Tile Test Beam
375  if flags.Beam.Type is BeamType.TestBeam:
376  kwargs.setdefault("SensitiveDetectors", result.popToolsAndMerge(TileTestBeamSensitiveDetectorListCfg(flags)))
377  elif "tb_LArH6" in flags.GeoModel.AtlasVersion:
378  pass
379  elif "ctbh8" in flags.GeoModel.AtlasVersion:
380  kwargs.setdefault("SensitiveDetectors", result.popToolsAndMerge(CombinedTestBeamSensitiveDetectorListCfg(flags)))
381  else:
382  kwargs.setdefault("SensitiveDetectors", result.popToolsAndMerge(SensitiveDetectorListCfg(flags)))
383 
384  result.setPrivateTools(CompFactory.SensitiveDetectorMasterTool(name, **kwargs))
385  return result
386 
387 

◆ SimHitContainerListCfg()

def G4AtlasToolsConfig.SimHitContainerListCfg (   flags)

Definition at line 246 of file G4AtlasToolsConfig.py.

246 def SimHitContainerListCfg(flags):
247  from SimulationConfig.SimEnums import LArParameterization
248  writtenContainers =[]
249  if flags.Detector.GeometryMuon:
250  if flags.Muon.usePhaseIIGeoSetup:
251  from MuonSensitiveDetectorsR4.SensitiveDetectorsCfg import SimHitContainerListCfg
252  writtenContainers+= SimHitContainerListCfg(flags)
253  else:
254  from MuonG4SD.MuonG4SDConfig import SimHitContainerListCfg
255  writtenContainers += SimHitContainerListCfg(flags)
256  if flags.Detector.GeometryLAr:
257  if flags.Sim.LArParameterization is LArParameterization.FastCaloSim:
258  writtenContainers += [("LArHitContainer", "LArHitEMB_G4")]
259  writtenContainers += [("LArHitContainer", "LArHitEMEC_G4")]
260  writtenContainers += [("LArHitContainer", "LArHitFCAL_G4")]
261  writtenContainers += [("LArHitContainer", "LArHitHEC_G4")]
262  else:
263  writtenContainers += [("LArHitContainer", "LArHitEMB")]
264  writtenContainers += [("LArHitContainer", "LArHitEMEC")]
265  writtenContainers += [("LArHitContainer", "LArHitFCAL")]
266  writtenContainers += [("LArHitContainer", "LArHitHEC")]
267  if flags.Detector.GeometryTile:
268  if flags.Sim.LArParameterization is LArParameterization.FastCaloSim:
269  writtenContainers += [("TileHitVector", "MBTSHits_G4")]
270  writtenContainers += [("TileHitVector", "TileHitVec_G4")]
271  else:
272  writtenContainers += [("TileHitVector", "MBTSHits")]
273  writtenContainers += [("TileHitVector", "TileHitVec")]
274  if flags.Detector.GeometryTRT:
275  writtenContainers += [("TRTUncompressedHitCollection", "TRTUncompressedHits")]
276  if flags.Detector.EnableBCM:
277  writtenContainers += [("SiHitCollection", "BCMHits")]
278  writtenContainers += [("SiHitCollection", "BLMHits")]
279  if flags.Detector.EnablePixel:
280  writtenContainers += [("SiHitCollection", "PixelHits")]
281  if flags.Detector.EnableSCT:
282  writtenContainers += [("SiHitCollection", "SCT_Hits")]
283  from SimulationConfig.SimEnums import CalibrationRun
284  if flags.Sim.CalibrationRun in [CalibrationRun.LAr, CalibrationRun.LArTile]:
285  # Needed to ensure that DeadMaterialCalibrationHitsMerger is scheduled correctly.
286  writtenContainers += [
287  ( 'CaloCalibrationHitContainer' , 'StoreGateSvc+LArCalibrationHitActive_DEAD' ),
288  ( 'CaloCalibrationHitContainer' , 'StoreGateSvc+LArCalibrationHitDeadMaterial_DEAD' ),
289  ( 'CaloCalibrationHitContainer' , 'StoreGateSvc+LArCalibrationHitInactive_DEAD' )
290  ]
291 
292  return writtenContainers
293 

◆ TileTestBeamSensitiveDetectorListCfg()

def G4AtlasToolsConfig.TileTestBeamSensitiveDetectorListCfg (   flags)

Definition at line 322 of file G4AtlasToolsConfig.py.

322 def TileTestBeamSensitiveDetectorListCfg(flags):
323  result = ComponentAccumulator()
324  tools = []
325 
326  if flags.Detector.EnableTile:
327  if flags.Sim.CalibrationRun in [CalibrationRun.Tile, CalibrationRun.LArTile, CalibrationRun.LArTileZDC]:
328  from TileGeoG4Calib.TileGeoG4CalibConfig import TileCTBGeoG4CalibSDCfg
329  tools += [ result.popToolsAndMerge(TileCTBGeoG4CalibSDCfg(flags)) ] # mode 1 : With CaloCalibrationHits
330  else:
331  from TileGeoG4SD.TileGeoG4SDToolConfig import TileCTBGeoG4SDCfg
332  tools += [ result.popToolsAndMerge(TileCTBGeoG4SDCfg(flags)) ] # mode 0 : No CaloCalibrationHits
333  from MuonWall.MuonWallConfig import MuonWallSDCfg
334  tools += [ result.popToolsAndMerge(MuonWallSDCfg(flags)) ]
335  result.setPrivateTools(tools)
336  return result
337 
338 

◆ TrackFastSimSensitiveDetectorListCfg()

def G4AtlasToolsConfig.TrackFastSimSensitiveDetectorListCfg (   flags)

Definition at line 117 of file G4AtlasToolsConfig.py.

117 def TrackFastSimSensitiveDetectorListCfg(flags):
118  result = ComponentAccumulator()
119  tools = []
120  if (flags.Detector.EnableMuon and flags.Sim.CavernBackground in [CavernBackground.Write, CavernBackground.WriteWorld]) or flags.Sim.StoppedParticleFile:
121  from TrackWriteFastSim.TrackWriteFastSimConfig import TrackFastSimSDCfg
122  tools += [ result.popToolsAndMerge(TrackFastSimSDCfg(flags)) ]
123  result.setPrivateTools(tools)
124  return result
125 
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:246
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:229
G4AtlasToolsConfig.SensitiveDetectorListCfg
def SensitiveDetectorListCfg(flags)
Definition: G4AtlasToolsConfig.py:305
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:167
TrackWriteFastSimConfig.CosmicTRSDCfg
def CosmicTRSDCfg(flags, name="CosmicRecord", **kwargs)
Definition: TrackWriteFastSimConfig.py:33
G4AtlasToolsConfig.EmptySensitiveDetectorMasterToolCfg
def EmptySensitiveDetectorMasterToolCfg(name="EmptySensitiveDetectorMasterTool", **kwargs)
Definition: G4AtlasToolsConfig.py:388
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:339
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:113
LArG4SDToolConfig.LArInactiveSensitiveDetectorToolCfg
def LArInactiveSensitiveDetectorToolCfg(flags, name="LArInactiveSensitiveDetector", **kwargs)
Definition: LArG4SDToolConfig.py:314
FastSimulationMasterTool
Definition: FastSimulationMasterTool.h:16
SCT_G4_SDToolConfig.ITkStripSensorSDCfg
def ITkStripSensorSDCfg(ConfigFlags, name="ITkStripSensorSD", **kwargs)
Definition: SCT_G4_SDToolConfig.py:37
BLM_G4_SDToolConfig.BLMSensorSDCfg
def BLMSensorSDCfg(ConfigFlags, name="BLMSensorSD", **kwargs)
Definition: BLM_G4_SDToolConfig.py:8
G4AtlasToolsConfig.FastSimulationMasterToolCfg
def FastSimulationMasterToolCfg(flags, **kwargs)
Definition: G4AtlasToolsConfig.py:53
LArG4FastSimulationConfig.EMECFastShowerCfg
def EMECFastShowerCfg(flags, **kwargs)
Definition: LArG4FastSimulationConfig.py:45
TRT_G4_SDToolConfig.TRTSensitiveDetectorCfg
def TRTSensitiveDetectorCfg(flags, name="TRTSensitiveDetector", **kwargs)
Definition: TRT_G4_SDToolConfig.py:9
LArG4FastSimulationConfig.FCALFastShowerCfg
def FCALFastShowerCfg(flags, **kwargs)
Definition: LArG4FastSimulationConfig.py:67
G4AtlasToolsConfig.TileTestBeamSensitiveDetectorListCfg
def TileTestBeamSensitiveDetectorListCfg(flags)
Definition: G4AtlasToolsConfig.py:322
G4FastSimulationConfig.FastCaloSimCfg
def FastCaloSimCfg(flags, **kwargs)
Definition: G4FastSimulationConfig.py:21
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:135
ForwardTransportConfig.ForwardTransportModelCfg
def ForwardTransportModelCfg(flags, name="ForwardTransportModel", **kwargs)
Definition: ForwardTransportConfig.py:6
G4FastSimulationConfig.DeadMaterialShowerCfg
def DeadMaterialShowerCfg(flags, **kwargs)
Definition: G4FastSimulationConfig.py:14
PixelG4_SDToolConfig.PLRSensorSDCfg
def PLRSensorSDCfg(ConfigFlags, name="PLRSensorSD", **kwargs)
Definition: PixelG4_SDToolConfig.py:73
G4AtlasToolsConfig.G4CaloTransportToolCfg
def G4CaloTransportToolCfg(flags, name='G4CaloTransportTool', **kwargs)
Definition: G4AtlasToolsConfig.py:68
TRT_G4_SDToolConfig.TRTSensitiveDetector_CTBCfg
def TRTSensitiveDetector_CTBCfg(flags, name="TRTSensitiveDetector_CTB", **kwargs)
Definition: TRT_G4_SDToolConfig.py:37
G4AtlasToolsConfig.FastSimulationToolListCfg
def FastSimulationToolListCfg(flags)
Definition: G4AtlasToolsConfig.py:10
AFP_G4_SDConfig.AFP_SensitiveDetectorCfg
def AFP_SensitiveDetectorCfg(flags, name="AFP_SensitiveDetector", **kwargs)
Definition: AFP_G4_SDConfig.py:6
MuonG4SDConfig.SetupSensitiveDetectorsCfg
def SetupSensitiveDetectorsCfg(flags)
Definition: MuonG4SDConfig.py:5
G4AtlasToolsConfig.EmptyFastSimulationMasterToolCfg
def EmptyFastSimulationMasterToolCfg(flags, **kwargs)
Definition: G4AtlasToolsConfig.py:61
TileGeoG4SDToolConfig.TileGeoG4SDCfg
def TileGeoG4SDCfg(flags, name="TileGeoG4SD", **kwargs)
Definition: TileGeoG4SDToolConfig.py:9
PixelG4_SDToolConfig.ITkPixelSensorSDCfg
def ITkPixelSensorSDCfg(ConfigFlags, name="ITkPixelSensorSD", **kwargs)
Definition: PixelG4_SDToolConfig.py:44
TrackWriteFastSimConfig.TrackFastSimSDCfg
def TrackFastSimSDCfg(flags, name='TrackFastSimSD', **kwargs)
Definition: TrackWriteFastSimConfig.py:8
G4AtlasToolsConfig.CaloSensitiveDetectorListCfg
def CaloSensitiveDetectorListCfg(flags)
Definition: G4AtlasToolsConfig.py:190
G4AtlasToolsConfig.CaloCellContainerSensitiveDetectorListCfg
def CaloCellContainerSensitiveDetectorListCfg(flags)
Definition: G4AtlasToolsConfig.py:126
G4AtlasToolsConfig.FwdSensitiveDetectorListCfg
def FwdSensitiveDetectorListCfg(flags)
Definition: G4AtlasToolsConfig.py:89
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:294
LArG4FastSimulationConfig.FCAL2FastShowerCfg
def FCAL2FastShowerCfg(flags, **kwargs)
Definition: LArG4FastSimulationConfig.py:86
G4AtlasToolsConfig.EnvelopeSensitiveDetectorListCfg
def EnvelopeSensitiveDetectorListCfg(flags)
Definition: G4AtlasToolsConfig.py:236
TileGeoG4CalibConfig.TileGeoG4CalibSDCfg
def TileGeoG4CalibSDCfg(flags, name="TileGeoG4CalibSD", **kwargs)
Definition: TileGeoG4CalibConfig.py:8
G4AtlasToolsConfig.HGTDSensitiveDetectorListCfg
def HGTDSensitiveDetectorListCfg(flags)
Definition: G4AtlasToolsConfig.py:154
LArG4SDToolConfig.LArFCALSensitiveDetectorCfg
def LArFCALSensitiveDetectorCfg(flags, name="LArFCALSensitiveDetector", **kwargs)
Definition: LArG4SDToolConfig.py:256
G4FastSimulationConfig.SimpleFastKillerCfg
def SimpleFastKillerCfg(flags, **kwargs)
Definition: G4FastSimulationConfig.py:7
LArG4SDToolConfig.LArDeadSensitiveDetectorToolCfg
def LArDeadSensitiveDetectorToolCfg(flags, name="LArDeadSensitiveDetector", **kwargs)
Definition: LArG4SDToolConfig.py:74
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:79
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:117
ALFA_G4_SDConfig.ALFA_SensitiveDetectorCfg
def ALFA_SensitiveDetectorCfg(flags, name="ALFA_SensitiveDetector", **kwargs)
Definition: ALFA_G4_SDConfig.py:6
LArG4SDToolConfig.LArHECSensitiveDetectorCfg
def LArHECSensitiveDetectorCfg(flags, name="LArHECSensitiveDetector", **kwargs)
Definition: LArG4SDToolConfig.py:287
G4AtlasToolsConfig.SensitiveDetectorMasterToolCfg
def SensitiveDetectorMasterToolCfg(flags, name="SensitiveDetectorMasterTool", **kwargs)
Definition: G4AtlasToolsConfig.py:372
Generated on Thu Nov 7 2024 22:14:37 for ATLAS Offline Software by   doxygen 1.8.18