ATLAS Offline Software
Loading...
Searching...
No Matches
python.SimulationMetadata Namespace Reference

Functions

 collectSimulationMetadata (flags)
 fillAtlasMetadata (flags, dbFiller)
 writeSimulationParametersMetadata (flags)
 readSimulationParameters (flags)
 writeSimulationParameters (flags)

Variables

str folderName = "/Simulation/Parameters"

Function Documentation

◆ collectSimulationMetadata()

collectSimulationMetadata ( flags)
Collect simulation metadata parameters as a dictionary

Definition at line 11 of file SimulationMetadata.py.

11def collectSimulationMetadata(flags):
12 """Collect simulation metadata parameters as a dictionary"""
13 simMDlog = logging.getLogger('Sim_Metadata')
14 params = {}
15
16 #add all flags to the metadata
17 #todo - only add certain ones?
18 #in future this should be a ConfigFlags method...?
19 for flag in sorted(flags._flagdict): #only sim
20 if flag.startswith("Sim."):
21 if "GenerationConfiguration" in flag:
22 # This flag is only temporarily defined in the SimConfigFlags module
23 continue
24 if "Twiss" in flag and not flags.Detector.GeometryForward:
25 # The various Twiss flags should only be written out when Forward Detector simulation is enabled
26 continue
27 if "UseShadowEvent" in flag and not flags.Sim.UseShadowEvent:
28 # This flag is added temporarily to allow a new approach to quasi-stable particle simulation to be tested.
29 continue
30 if "VertexTimeWidth" in flag and not flags.Sim.VertexTimeSmearing:
31 # This flag is only written to metadata when vertex time smearing is enabled
32 continue
33 if "RunOnGPU" in flag and not flags.Sim.ISF.Simulator.usesFastCaloSim():
34 # This flag is only written to metadata when FastCaloSim/FastCaloGAN is enabled
35 continue
36 if "FastCalo.ParamsInputFilename" in flag and not flags.Sim.ISF.Simulator.usesFastCaloSim():
37 # This flag is only written to metadata when FastCaloSim/FastCaloGAN is enabled
38 continue
39 if "InDetParameterization" in flag and flags.Sim.InDetParameterization is not InDetParameterization.FatrasG4:
40 # This flag is only written to metadata when FatrasG4 is enabled
41 continue
42 if "InDetParameterization" in flag and flags.Sim.InDetParameterization is not InDetParameterization.AFatrasG4:
43 # This flag is only written to metadata when AFatrasG4 is enabled
44 continue
45 if "ActsFatrasG4.DebugInjectParticle" in flag and not flags.Sim.ActsFatrasG4.DebugInjectParticle:
46 # This flag is only written to metadata when DebugInjectParticle is enabled
47 continue
48 if flag.startswith("Sim.FatrasG4.") and flags.Sim.InDetParameterization is not InDetParameterization.FatrasG4:
49 # These flags are only written to metadata when FatrasG4 is enabled
50 continue
51 if "SimplifiedGeoPath" in flag and not flags.Sim.SimplifiedGeoPath:
52 # This flag is only written to metadata in case the FastCaloSim simplified geometry path is set
53 continue
54 if "FastCalo.doPunchThrough" in flag and not flags.Sim.FastCalo.doPunchThrough:
55 # This flag is only written to metadata in case PunchThroughG4Tool is set
56 continue
57 if "UseG4Workers" in flag:
58 # This flag is still experimental, and should not be recorded in metadata yet
59 continue
60
61 key = flag.split(".")[-1] #use final part of flag as the key
62 value = flags[flag]
63 if isinstance(value, FlagEnum):
64 value = value.value
65 if not isinstance(value, str):
66 value = str(value)
67 params[key] = value
68 simMDlog.info('SimulationMetaData: setting "%s" to be %s', key, value)
69
70 params['G4Version'] = flags.Sim.G4Version
71 params['RunType'] = 'atlas'
72 params['beamType'] = flags.Beam.Type.value
73 params['SimLayout'] = flags.GeoModel.AtlasVersion
74 params['MagneticField'] = 'AtlasFieldSvc' # TODO hard-coded for now for consistency with old-style configuration.
75
76 #---------
77
78 from AthenaConfiguration.DetectorConfigFlags import getEnabledDetectors
79 simDets = ['Truth'] + getEnabledDetectors(flags)
80 simMDlog.info("Setting 'SimulatedDetectors' = %r", simDets)
81 params['SimulatedDetectors'] = repr(simDets)
82
83
84 params['hitFileMagicNumber'] = '0'
85
86 if flags.Sim.ISFRun:
87 params['Simulator'] = flags.Sim.ISF.Simulator.value
88 params['SimulationFlavour'] = flags.Sim.ISF.Simulator.value.replace('MT', '') # used by egamma
89 else:
90 # TODO hard-code for now, but set flag properly later
91 params['Simulator'] = 'AtlasG4'
92 params['SimulationFlavour'] = 'AtlasG4'
93
94
95 if flags.Common.isOverlay and flags.Overlay.DataOverlay:
96 params['IsDataOverlay'] = 'True'
97
98 return params
99
100

◆ fillAtlasMetadata()

fillAtlasMetadata ( flags,
dbFiller )
Fill ParameterDbFiller with simulation metadata (sqlite mode interface)

Definition at line 101 of file SimulationMetadata.py.

101def fillAtlasMetadata(flags, dbFiller):
102 """Fill ParameterDbFiller with simulation metadata (sqlite mode interface)"""
103 params = collectSimulationMetadata(flags)
104 for key, value in params.items():
105 dbFiller.addSimParam(key, value)
106
107

◆ readSimulationParameters()

readSimulationParameters ( flags)
Read simulation parameters metadata

Definition at line 138 of file SimulationMetadata.py.

138def readSimulationParameters(flags):
139 """Read simulation parameters metadata"""
140 from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
141 from IOVDbSvc.IOVDbSvcConfig import addFolders
142
143 # Direct in-file metadata mode: IOVDbMetaDataTool populates ConditionStore from file metadata
144 # Exception: In overlay mode, always use IOVDbSvc since input files may not have parameters in metadata
145 if flags.IOVDb.WriteParametersAsMetaData and not flags.Common.isOverlay:
146 return ComponentAccumulator()
147
148 # Sqlite mode: use IOVDbSvc to read and populate ConditionStore
149 if flags.Common.ProductionStep in [ProductionStep.Simulation, ProductionStep.FastChain]:
150 # Reading from intermediate sqlite file SimParams.db (during simulation job)
151 return addFolders(flags, folderName, detDb="SimParams.db", db="SIMPARAM", className="AthenaAttributeList")
152 else:
153 # Reading from input file metadata via IOVDbSvc
154 return addFolders(flags, folderName, className="AthenaAttributeList", tag="HEAD")
155
156

◆ writeSimulationParameters()

writeSimulationParameters ( flags)
Write digitization parameters metadata

Definition at line 157 of file SimulationMetadata.py.

157def writeSimulationParameters(flags):
158 """Write digitization parameters metadata"""
159 from IOVDbSvc.IOVDbSvcConfig import IOVDbSvcCfg, addFolders
160 acc = IOVDbSvcCfg(flags, FoldersToMetaData=(folderName,))
161 acc.merge(addFolders(flags, folderName, detDb="SimParams.db", db="SIMPARAM"))
162 return acc

◆ writeSimulationParametersMetadata()

writeSimulationParametersMetadata ( flags)

Definition at line 108 of file SimulationMetadata.py.

108def writeSimulationParametersMetadata(flags):
109 simMDlog = logging.getLogger('Sim_Metadata')
110 myRunNumber, myEndRunNumber = getMinMaxRunNumbers(flags)
111 simMDlog.debug('Metadata BeginRun = %s', str(myRunNumber))
112 simMDlog.debug('Metadata EndRun = %s', str(myEndRunNumber))
113
114 if flags.IOVDb.WriteParametersAsMetaData:
115 # Direct in-file metadata mode: bypass intermediate sqlite files
116 from IOVDbMetaDataTools.ParameterWriterConfig import writeParametersToMetaData
117 simMDlog.info('Writing simulation parameters directly to in-file metadata (bypassing SimParams.db)')
118 params = collectSimulationMetadata(flags)
119 return writeParametersToMetaData(flags, folderName, params, myRunNumber, myEndRunNumber)
120 else:
121 # Sqlite mode: write to SimParams.db intermediate file
122 from IOVDbMetaDataTools import ParameterDbFiller
123 simMDlog.info('Writing simulation parameters to intermediate sqlite file (SimParams.db)')
124 dbFiller = ParameterDbFiller.ParameterDbFiller()
125 dbFiller.setBeginRun(myRunNumber)
126 dbFiller.setEndRun(myEndRunNumber)
127
128 fillAtlasMetadata(flags, dbFiller)
129
130 #-------------------------------------------------
131 # Make the MetaData Db
132 #-------------------------------------------------
133 dbFiller.genSimDb()
134
135 return writeSimulationParameters(flags)
136
137

Variable Documentation

◆ folderName

str python.SimulationMetadata.folderName = "/Simulation/Parameters"

Definition at line 8 of file SimulationMetadata.py.