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

Functions

 constBunchSpacingPattern (constBunchSpacing)
 createDigitizationCfgFlags ()
 digitizationRunArgsToFlags (runArgs, flags)
 pileupRunArgsToFlags (runArgs, flags)
 setupDigitizationFlags (runArgs, flags)

Detailed Description

Construct ConfigFlags for Digitization

Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration

Function Documentation

◆ constBunchSpacingPattern()

constBunchSpacingPattern ( constBunchSpacing)
Return a valid value for Digitization.BeamIntensity, which
matches the specified constBunchSpacing

Definition at line 11 of file DigitizationConfigFlags.py.

11def constBunchSpacingPattern(constBunchSpacing):
12 """Return a valid value for Digitization.BeamIntensity, which
13 matches the specified constBunchSpacing
14 """
15 if type(constBunchSpacing) is not int:
16 raise TypeError("constBunchSpacing must be int, "
17 "not %s" % type(constBunchSpacing).__name__)
18 if constBunchSpacing % 25 != 0:
19 raise ValueError("constBunchSpacing must be a multiple of 25, "
20 "not %s" % constBunchSpacing)
21
22 # special case
23 if constBunchSpacing == 25:
24 return [1.0]
25
26 # general case
27 pattern = [0.0, 1.0]
28 nBunches = (constBunchSpacing//25) - 2
29 pattern += nBunches*[0.0]
30 return pattern
31
32

◆ createDigitizationCfgFlags()

createDigitizationCfgFlags ( )
Return an AthConfigFlags object with required flags

Definition at line 33 of file DigitizationConfigFlags.py.

33def createDigitizationCfgFlags():
34 """Return an AthConfigFlags object with required flags"""
35 flags = AthConfigFlags()
36 # Digitization Steering - needed for easy comparison with the
37 # old-style configuration, but can potentially drop
38 def _checkDigiSteeringConf(prevFlags):
39 digiSteeringConf = "StandardPileUpToolsAlg"
40 if prevFlags.Input.Files:
41 digiSteeringConf = GetFileMD(prevFlags.Input.Files).get("digiSteeringConf", "StandardPileUpToolsAlg")
42 return digiSteeringConf
43
44 flags.addFlag("Digitization.DigiSteeringConf", _checkDigiSteeringConf)
45 # Run Inner Detector noise simulation
46 flags.addFlag("Digitization.DoInnerDetectorNoise", lambda prevFlags: not prevFlags.Common.isOverlay)
47 # Run Pixel Detector noise simulation
48 flags.addFlag("Digitization.DoITkPixelDetectorNoise", lambda prevFlags: prevFlags.Digitization.DoInnerDetectorNoise)
49 # Run Strip Detector noise simulation
50 flags.addFlag("Digitization.DoITkStripDetectorNoise", lambda prevFlags: prevFlags.Digitization.DoInnerDetectorNoise)
51 # Run pile-up digitization on one bunch crossing at a time?
52 flags.addFlag("Digitization.DoXingByXingPileUp", False)
53 # Run Calorimeter noise simulation
54 flags.addFlag("Digitization.DoCaloNoise", lambda prevFlags: not prevFlags.Common.isOverlay)
55 # Produce inputs for Calorimeter hard scatter truth reconstruction
56 flags.addFlag("Digitization.EnableCaloHSTruthRecoInputs", False)
57 # Use high-gain Forward Calorimeters
58 flags.addFlag("Digitization.HighGainFCal", False)
59 # Model FCal signal degradation (HL-LHC ion build-up) in LAr digitization
60 flags.addFlag("Digitization.DoFCalSignalDegradation", False)
61 # Use high-gain ElectroMagnetic EndCap Inner Wheel
62 flags.addFlag("Digitization.HighGainEMECIW", True)
63 # Do global pileup digitization
64 flags.addFlag("Digitization.PileUp",
65 lambda prevFlags: GetFileMD(prevFlags.Input.Files).get("pileUp", "False") != "False")
66 # Temporary TGC flag
67 flags.addFlag("Digitization.UseUpdatedTGCConditions", False)
68 # Write out truth information
69 flags.addFlag("Digitization.EnableTruth", True)
70 # Write out calorimeter digits
71 flags.addFlag("Digitization.AddCaloDigi", False)
72 # Write out thinned calorimeter digits
73 flags.addFlag("Digitization.AddCaloDigiThinned", False)
74 # Integer offset to random seed initialisation
75 flags.addFlag("Digitization.RandomSeedOffset", 0)
76 # Digitization extra input dependencies
77 flags.addFlag("Digitization.ExtraInputs", [("xAOD::EventInfo", "EventInfo")])
78 # Beam spot reweighting (-1 disables it)
79 flags.addFlag("Digitization.InputBeamSigmaZ", -1)
80
81 # Set the type of the radiation damage simulation type for pixel planar sensors
82 flags.addFlag("Digitization.PixelPlanarRadiationDamageSimulationType",
83 PixelRadiationDamageSimulationType.NoRadiationDamage, type=PixelRadiationDamageSimulationType)
84 # Set the type of the radiation damage simulation type for 3D planar sensors
85 flags.addFlag("Digitization.Pixel3DRadiationDamageSimulationType",
86 PixelRadiationDamageSimulationType.NoRadiationDamage, type=PixelRadiationDamageSimulationType)
87 # Set the flag to tell the code to treat 3D sensors in in Pixel ITk as 3D sensors (instead of planar)
88 # Current default is False as this is what has been used so far for the ITk simulation (treating 3D as Planar)
89 # This is a temporary flag that will be eventually removed FIXME
90 flags.addFlag("Digitization.DigitizeITk3Das3D", False)
91 # Flag to use 2D CCE lookup tables for radiation damage simulation of ITk Strip
92 flags.addFlag("Digitization.ITkStripRadDamageLUT", False)
93 # Flag to set the integrated luminosity experienced by ITKStrip detector, to interpolate the 2D CCE LUTs to requested level of radiation damage
94 flags.addFlag("Digitization.ITkStripRadDamageLuminosity", 0.0)
95
96 # for PileUp digitization
97 # Bunch structure configuration
98 flags.addFlag("Digitization.PU.BunchStructureConfig", "")
99 # Pile-up profile configuration
100 flags.addFlag("Digitization.PU.ProfileConfig", "")
101 # Custom pile-up profile configuration - fully custom or for mu range
102 flags.addFlag("Digitization.PU.CustomProfile", "")
103 # Force sequential event numbers
104 flags.addFlag("Digitization.PU.ForceSequentialEventNumbers",
105 lambda prevFlags: prevFlags.Common.ProductionStep == ProductionStep.PileUpPresampling)
106 # Beam Halo input collections
107 flags.addFlag("Digitization.PU.BeamHaloInputCols", [])
108 # LHC Bunch Structure (list of non-negative floats)
109 flags.addFlag("Digitization.PU.BeamIntensityPattern",
110 lambda prevFlags: constBunchSpacingPattern(prevFlags.Beam.BunchSpacing))
111 # Beam Gas input collections
112 flags.addFlag("Digitization.PU.BeamGasInputCols", [])
113 # LHC bunch spacing, in ns, to use in pileup digitization. Only multiples of 25 allowed.
114 # Not necessarily equal to Beam.BunchSpacing
115 flags.addFlag("Digitization.PU.BunchSpacing",
116 lambda prevFlags: prevFlags.Beam.BunchSpacing)
117 # PileUp branch crossing parameters
118 flags.addFlag("Digitization.PU.InitialBunchCrossing", -32)
119 flags.addFlag("Digitization.PU.FinalBunchCrossing", 6)
120 # Add the cavern background every bunch, independent of any bunch structure?
121 flags.addFlag("Digitization.PU.CavernIgnoresBeamInt", False)
122 # Cavern input collections
123 flags.addFlag("Digitization.PU.CavernInputCols", [])
124 # Central bunch crossing location in the BeamIntensityPattern
125 flags.addFlag("Digitization.PU.FixedT0BunchCrossing", 0)
126 # Superimpose mixed high pt minimum bias events (pile-up) on signal events?
127 # If so, set this to a list of: High Pt Mixed ND, SD, DD minimum bias input collections
128 flags.addFlag("Digitization.PU.HighPtMinBiasInputCols", [])
129 # Offset into the input collections of high pt min-bias events
130 flags.addFlag("Digitization.PU.HighPtMinBiasInputColOffset", 0)
131 # Superimpose mixed low pt minimum bias events (pile-up) on signal events?
132 # If so, set this to a list of: Low Pt Mixed ND, SD, DD minimum bias input collections
133 flags.addFlag("Digitization.PU.LowPtMinBiasInputCols", [])
134 # Number of low pt min-bias events to superimpose per signal event per beam crossing
135 flags.addFlag("Digitization.PU.NumberOfLowPtMinBias", 0.0)
136 # Number of high pt min-bias events to superimpose per signal event per beam crossing
137 flags.addFlag("Digitization.PU.NumberOfHighPtMinBias", 0.0)
138 # Number of beam gas events to superimpose per signal event per beam crossing
139 flags.addFlag("Digitization.PU.NumberOfBeamGas", 0.0)
140 # Number of beam halo events to superimpose per signal event per beam crossing
141 flags.addFlag("Digitization.PU.NumberOfBeamHalo", 0.0)
142 # Number of mixed ND, SD, DD min-bias events to superimpose per signal event per beam crossing
143 flags.addFlag("Digitization.PU.NumberOfCollisions", 0.0)
144 # Number of cavern events to superimpose per signal event per beam crossing
145 flags.addFlag("Digitization.PU.NumberOfCavern", 0.0)
146 # Repeating pattern to determine which events to simulate when using Stepping Cache
147 flags.addFlag("Digitization.PU.SignalPatternForSteppingCache", [])
148 # Which sub-systems should use Fast Digitization
149 flags.addFlag("Digitization.DoFastDigi", [])
150 # Set the flag to True if the Common.ProductionStep is not one of the steps in the list
151 flags.addFlag("Digitization.ReadParametersFromDB", lambda prevFlags : prevFlags.Common.ProductionStep in [ProductionStep.Digitization, ProductionStep.PileUpPresampling, ProductionStep.Overlay, ProductionStep.FastChain])
152 # Do TRT high threshold overrides for heay ion runs
153 flags.addFlag("Digitization.TRT.HeavyIonHT", False)
154 return flags
155
156
T * get(TKey *tobj)
get a TObject* from a TKey* (why can't a TObject be a TKey?)
Definition hcg.cxx:132

◆ digitizationRunArgsToFlags()

digitizationRunArgsToFlags ( runArgs,
flags )
Fill digitization configuration flags from run arguments.

Definition at line 157 of file DigitizationConfigFlags.py.

157def digitizationRunArgsToFlags(runArgs, flags):
158 """Fill digitization configuration flags from run arguments."""
159 # from SimDigi
160 if hasattr(runArgs, "DataRunNumber"):
161 flags.Input.ConditionsRunNumber = runArgs.DataRunNumber
162
163 # from SimDigi
164 if hasattr(runArgs, "jobNumber"):
165 flags.Input.JobNumber = runArgs.jobNumber
166
167 if hasattr(runArgs, "PileUpPresampling"):
168 flags.Common.ProductionStep = ProductionStep.PileUpPresampling
169 elif flags.Common.ProductionStep == ProductionStep.Default: # Do not override previous settings
170 flags.Common.ProductionStep = ProductionStep.Digitization
171
172 if hasattr(runArgs, "doAllNoise"):
173 flags.Digitization.DoInnerDetectorNoise = runArgs.doAllNoise
174 flags.Digitization.DoCaloNoise = runArgs.doAllNoise
175
176 if hasattr(runArgs, "AddCaloDigi"):
177 flags.Digitization.AddCaloDigi = runArgs.AddCaloDigi
178
179 if hasattr(runArgs, "digiSeedOffset1") or hasattr(runArgs, "digiSeedOffset2"):
180 flags.Digitization.RandomSeedOffset = 0
181 if hasattr(runArgs, "digiSeedOffset1"):
182 flags.Digitization.RandomSeedOffset += int(runArgs.digiSeedOffset1)
183 if hasattr(runArgs, "digiSeedOffset2"):
184 flags.Digitization.RandomSeedOffset += int(runArgs.digiSeedOffset2)
185 else:
186 flags.Digitization.RandomSeedOffset = 3 # for legacy compatibility
187
188 if hasattr(runArgs, "digiSteeringConf"):
189 flags.Digitization.DigiSteeringConf = runArgs.digiSteeringConf + "PileUpToolsAlg"
190
191 # TODO: Not covered yet as no flag equivalents exist yet
192 # '--digiRndmSvc'
193 # '--samplingFractionDbTag'
194
195

◆ pileupRunArgsToFlags()

pileupRunArgsToFlags ( runArgs,
flags )
Fill pile-up digitization configuration flags from run arguments.

Definition at line 196 of file DigitizationConfigFlags.py.

196def pileupRunArgsToFlags(runArgs, flags):
197 """Fill pile-up digitization configuration flags from run arguments."""
198 if hasattr(runArgs, "numberOfLowPtMinBias"):
199 flags.Digitization.PU.NumberOfLowPtMinBias = runArgs.numberOfLowPtMinBias
200
201 if hasattr(runArgs, "numberOfHighPtMinBias"):
202 flags.Digitization.PU.NumberOfHighPtMinBias = runArgs.numberOfHighPtMinBias
203
204 if hasattr(runArgs, "numberOfBeamHalo"):
205 flags.Digitization.PU.NumberOfBeamHalo = runArgs.numberOfBeamHalo
206
207 if hasattr(runArgs, "numberOfBeamGas"):
208 flags.Digitization.PU.NumberOfBeamGas = runArgs.numberOfBeamGas
209
210 if hasattr(runArgs, "numberOfCavernBkg"):
211 flags.Digitization.PU.NumberOfCavern = runArgs.numberOfCavernBkg
212
213 if hasattr(runArgs, "bunchSpacing"):
214 flags.Digitization.PU.BunchSpacing = runArgs.bunchSpacing
215
216 if hasattr(runArgs, "pileupInitialBunch"):
217 flags.Digitization.PU.InitialBunchCrossing = runArgs.pileupInitialBunch
218
219 if hasattr(runArgs, "pileupFinalBunch"):
220 flags.Digitization.PU.FinalBunchCrossing = runArgs.pileupFinalBunch
221
222 # sanity check
223 if flags.Digitization.PU.InitialBunchCrossing > flags.Digitization.PU.FinalBunchCrossing:
224 raise ValueError("Initial bunch crossing should not be larger than the final one")
225
226 if hasattr(runArgs, "inputLowPtMinbiasHitsFile"):
227 from RunDependentSimComps.PileUpUtils import generateBackgroundInputCollections
228 flags.Digitization.PU.LowPtMinBiasInputCols = \
229 generateBackgroundInputCollections(flags, runArgs.inputLowPtMinbiasHitsFile,
230 flags.Digitization.PU.NumberOfLowPtMinBias, True)
231
232 if hasattr(runArgs, "inputHighPtMinbiasHitsFile"):
233 from RunDependentSimComps.PileUpUtils import getInputCollectionOffset, generateBackgroundInputCollections
234 if flags.Digitization.PU.HighPtMinBiasInputColOffset < 0:
235 # Calculate a pseudo random offset into the collection from the jobNumber
236 flags.Digitization.PU.HighPtMinBiasInputColOffset = getInputCollectionOffset(flags, runArgs.inputHighPtMinbiasHitsFile)
237
238 flags.Digitization.PU.HighPtMinBiasInputCols = \
239 generateBackgroundInputCollections(flags, runArgs.inputHighPtMinbiasHitsFile,
240 flags.Digitization.PU.NumberOfHighPtMinBias, True)
241
242 if hasattr(runArgs, "inputCavernHitsFile"):
243 from RunDependentSimComps.PileUpUtils import generateBackgroundInputCollections
244 flags.Digitization.PU.CavernInputCols = \
245 generateBackgroundInputCollections(flags, runArgs.inputCavernHitsFile,
246 flags.Digitization.PU.NumberOfCavern, True) # TODO: ignore?
247
248 if hasattr(runArgs, "inputBeamHaloHitsFile"):
249 from RunDependentSimComps.PileUpUtils import generateBackgroundInputCollections
250 flags.Digitization.PU.BeamHaloInputCols = \
251 generateBackgroundInputCollections(flags, runArgs.inputBeamHaloHitsFile,
252 flags.Digitization.PU.NumberOfBeamHalo, True)
253
254 if hasattr(runArgs, "inputBeamGasHitsFile"):
255 from RunDependentSimComps.PileUpUtils import generateBackgroundInputCollections
256 flags.Digitization.PU.BeamGasInputCols = \
257 generateBackgroundInputCollections(flags, runArgs.inputBeamGasHitsFile,
258 flags.Digitization.PU.NumberOfBeamGas, True)
259
260 # TODO: Not covered yet as no flag equivalents exist yet
261 # '--testPileUpConfig'
262
263

◆ setupDigitizationFlags()

setupDigitizationFlags ( runArgs,
flags )
Setup common digitization flags.

Definition at line 264 of file DigitizationConfigFlags.py.

264def setupDigitizationFlags(runArgs, flags):
265 """Setup common digitization flags."""
266 # autoconfigure pile-up if inputs are present
267 if (hasattr(runArgs, "inputLowPtMinbiasHitsFile")
268 or hasattr(runArgs, "inputHighPtMinbiasHitsFile")
269 or hasattr(runArgs, "inputCavernHitsFile")
270 or hasattr(runArgs, "inputBeamHaloHitsFile")
271 or hasattr(runArgs, "inputBeamGasHitsFile")):
272 flags.Digitization.PileUp = True
273
274 if flags.Digitization.PileUp:
275 flags.Input.OverrideRunNumber = True
276 # Needs to be False for MT pileup
277 if flags.Concurrency.NumThreads > 0:
278 flags.Digitization.DoXingByXingPileUp = False
279 else:
280 flags.Digitization.DoXingByXingPileUp = True
281 else:
282 flags.Input.OverrideRunNumber = flags.Input.ConditionsRunNumber > 0