ATLAS Offline Software
Functions
python.DigitizationConfigFlags Namespace Reference

Functions

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

Detailed Description

Construct ConfigFlags for Digitization

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

Function Documentation

◆ constBunchSpacingPattern()

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

Definition at line 11 of file DigitizationConfigFlags.py.

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

def python.DigitizationConfigFlags.createDigitizationCfgFlags ( ) 
Return an AthConfigFlags object with required flags

Definition at line 33 of file DigitizationConfigFlags.py.

33 def 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  # Use high-gain ElectroMagnetic EndCap Inner Wheel
60  flags.addFlag("Digitization.HighGainEMECIW", True)
61  # Do global pileup digitization
62  flags.addFlag("Digitization.PileUp",
63  lambda prevFlags: GetFileMD(prevFlags.Input.Files).get("pileUp", "False") != "False")
64  # Temporary TGC flag
65  flags.addFlag("Digitization.UseUpdatedTGCConditions", False)
66  # Write out truth information
67  flags.addFlag("Digitization.EnableTruth", True)
68  # Write out calorimeter digits
69  flags.addFlag("Digitization.AddCaloDigi", False)
70  # Write out thinned calorimeter digits
71  flags.addFlag("Digitization.AddCaloDigiThinned", False)
72  # Integer offset to random seed initialisation
73  flags.addFlag("Digitization.RandomSeedOffset", 0)
74  # Digitization extra input dependencies
75  flags.addFlag("Digitization.ExtraInputs", [("xAOD::EventInfo", "EventInfo")])
76  # Beam spot reweighting (-1 disables it)
77  flags.addFlag("Digitization.InputBeamSigmaZ", -1)
78 
79  # Set the type of the radiation damage simulation type for pixel planar sensors
80  flags.addFlag("Digitization.PixelPlanarRadiationDamageSimulationType",
81  PixelRadiationDamageSimulationType.NoRadiationDamage, type=PixelRadiationDamageSimulationType)
82  # Set the type of the radiation damage simulation type for 3D planar sensors
83  flags.addFlag("Digitization.Pixel3DRadiationDamageSimulationType",
84  PixelRadiationDamageSimulationType.NoRadiationDamage, type=PixelRadiationDamageSimulationType)
85  # Set the flag to tell the code to treat 3D sensors in in Pixel ITk as 3D sensors (instead of planar)
86  # Current default is False as this is what has been used so far for the ITk simulation (treating 3D as Planar)
87  # This is a temporary flag that will be eventually removed FIXME
88  flags.addFlag("Digitization.DigitizeITk3Das3D", False)
89 
90  # for PileUp digitization
91  # Bunch structure configuration
92  flags.addFlag("Digitization.PU.BunchStructureConfig", "")
93  # Pile-up profile configuration
94  flags.addFlag("Digitization.PU.ProfileConfig", "")
95  # Custom pile-up profile configuration - fully custom or for mu range
96  flags.addFlag("Digitization.PU.CustomProfile", "")
97  # Force sequential event numbers
98  flags.addFlag("Digitization.PU.ForceSequentialEventNumbers",
99  lambda prevFlags: prevFlags.Common.ProductionStep == ProductionStep.PileUpPresampling)
100  # Beam Halo input collections
101  flags.addFlag("Digitization.PU.BeamHaloInputCols", [])
102  # LHC Bunch Structure (list of non-negative floats)
103  flags.addFlag("Digitization.PU.BeamIntensityPattern",
104  lambda prevFlags: constBunchSpacingPattern(prevFlags.Beam.BunchSpacing))
105  # Beam Gas input collections
106  flags.addFlag("Digitization.PU.BeamGasInputCols", [])
107  # LHC bunch spacing, in ns, to use in pileup digitization. Only multiples of 25 allowed.
108  # Not necessarily equal to Beam.BunchSpacing
109  flags.addFlag("Digitization.PU.BunchSpacing",
110  lambda prevFlags: prevFlags.Beam.BunchSpacing)
111  # PileUp branch crossing parameters
112  flags.addFlag("Digitization.PU.InitialBunchCrossing", -32)
113  flags.addFlag("Digitization.PU.FinalBunchCrossing", 6)
114  # Add the cavern background every bunch, independent of any bunch structure?
115  flags.addFlag("Digitization.PU.CavernIgnoresBeamInt", False)
116  # Cavern input collections
117  flags.addFlag("Digitization.PU.CavernInputCols", [])
118  # Central bunch crossing location in the BeamIntensityPattern
119  flags.addFlag("Digitization.PU.FixedT0BunchCrossing", 0)
120  # Superimpose mixed high pt minimum bias events (pile-up) on signal events?
121  # If so, set this to a list of: High Pt Mixed ND, SD, DD minimum bias input collections
122  flags.addFlag("Digitization.PU.HighPtMinBiasInputCols", [])
123  # Offset into the input collections of high pt min-bias events
124  flags.addFlag("Digitization.PU.HighPtMinBiasInputColOffset", 0)
125  # Superimpose mixed low pt minimum bias events (pile-up) on signal events?
126  # If so, set this to a list of: Low Pt Mixed ND, SD, DD minimum bias input collections
127  flags.addFlag("Digitization.PU.LowPtMinBiasInputCols", [])
128  # Number of low pt min-bias events to superimpose per signal event per beam crossing
129  flags.addFlag("Digitization.PU.NumberOfLowPtMinBias", 0.0)
130  # Number of high pt min-bias events to superimpose per signal event per beam crossing
131  flags.addFlag("Digitization.PU.NumberOfHighPtMinBias", 0.0)
132  # Number of beam gas events to superimpose per signal event per beam crossing
133  flags.addFlag("Digitization.PU.NumberOfBeamGas", 0.0)
134  # Number of beam halo events to superimpose per signal event per beam crossing
135  flags.addFlag("Digitization.PU.NumberOfBeamHalo", 0.0)
136  # Number of mixed ND, SD, DD min-bias events to superimpose per signal event per beam crossing
137  flags.addFlag("Digitization.PU.NumberOfCollisions", 0.0)
138  # Number of cavern events to superimpose per signal event per beam crossing
139  flags.addFlag("Digitization.PU.NumberOfCavern", 0.0)
140  # Repeating pattern to determine which events to simulate when using Stepping Cache
141  flags.addFlag("Digitization.PU.SignalPatternForSteppingCache", [])
142  # Which sub-systems should use Fast Digitization
143  flags.addFlag("Digitization.DoFastDigi", [])
144  # Set the flag to True if the Common.ProductionStep is not one of the steps in the list
145  flags.addFlag("Digitization.ReadParametersFromDB", lambda prevFlags : prevFlags.Common.ProductionStep in [ProductionStep.Digitization, ProductionStep.PileUpPresampling, ProductionStep.Overlay, ProductionStep.FastChain])
146  # Do TRT high threshold overrides for heay ion runs
147  flags.addFlag("Digitization.TRT.HeavyIonHT", False)
148  return flags
149 
150 

◆ digitizationRunArgsToFlags()

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

Definition at line 151 of file DigitizationConfigFlags.py.

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

◆ pileupRunArgsToFlags()

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

Definition at line 190 of file DigitizationConfigFlags.py.

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

◆ setupDigitizationFlags()

def python.DigitizationConfigFlags.setupDigitizationFlags (   runArgs,
  flags 
) 
Setup common digitization flags.

Definition at line 258 of file DigitizationConfigFlags.py.

258 def setupDigitizationFlags(runArgs, flags):
259  """Setup common digitization flags."""
260  # autoconfigure pile-up if inputs are present
261  if (hasattr(runArgs, "inputLowPtMinbiasHitsFile")
262  or hasattr(runArgs, "inputHighPtMinbiasHitsFile")
263  or hasattr(runArgs, "inputCavernHitsFile")
264  or hasattr(runArgs, "inputBeamHaloHitsFile")
265  or hasattr(runArgs, "inputBeamGasHitsFile")):
266  flags.Digitization.PileUp = True
267 
268  if flags.Digitization.PileUp:
269  flags.Input.OverrideRunNumber = True
270  # Needs to be False for MT pileup
271  if flags.Concurrency.NumThreads > 0:
272  flags.Digitization.DoXingByXingPileUp = False
273  else:
274  flags.Digitization.DoXingByXingPileUp = True
275  else:
276  flags.Input.OverrideRunNumber = flags.Input.ConditionsRunNumber > 0
python.AutoConfigFlags.GetFileMD
def GetFileMD(filenames, allowEmpty=True, maxLevel='peeker')
Definition: AutoConfigFlags.py:65
python.DigitizationConfigFlags.digitizationRunArgsToFlags
def digitizationRunArgsToFlags(runArgs, flags)
Definition: DigitizationConfigFlags.py:151
python.PileUpUtils.generateBackgroundInputCollections
def generateBackgroundInputCollections(flags, initialList, nBkgEvtsPerCrossing, correctForEmptyBunchCrossings)
Definition: PileUpUtils.py:66
python.DigitizationConfigFlags.setupDigitizationFlags
def setupDigitizationFlags(runArgs, flags)
Definition: DigitizationConfigFlags.py:258
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
python.DigitizationConfigFlags.constBunchSpacingPattern
def constBunchSpacingPattern(constBunchSpacing)
Definition: DigitizationConfigFlags.py:11
python.DigitizationConfigFlags.pileupRunArgsToFlags
def pileupRunArgsToFlags(runArgs, flags)
Definition: DigitizationConfigFlags.py:190
python.DigitizationConfigFlags.createDigitizationCfgFlags
def createDigitizationCfgFlags()
Definition: DigitizationConfigFlags.py:33
python.PileUpUtils.getInputCollectionOffset
def getInputCollectionOffset(flags, initialList)
Definition: PileUpUtils.py:43
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
get
T * get(TKey *tobj)
get a TObject* from a TKey* (why can't a TObject be a TKey?)
Definition: hcg.cxx:127
Generated on Sat Oct 25 2025 22:00:57 for ATLAS Offline Software by   doxygen 1.8.18