Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
MC23.py
Go to the documentation of this file.
1 # Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
2 from AthenaConfiguration.Enums import ProductionStep
3 from Campaigns.Utils import Campaign
4 
5 
6 def _MC23PileUp(flags):
7  """MC23 flags for MC with pile-up"""
8  flags.Beam.NumberOfCollisions = 60.
9 
10  from LArConfiguration.LArConfigRun3 import LArConfigRun3PileUp
11  LArConfigRun3PileUp(flags)
12 
13  # radiation damage
14  from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
15  flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
16 
17  if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
18  # ensure better randomisation of high-pt minbias events
19  flags.Digitization.PU.HighPtMinBiasInputColOffset = -1
20 
21 
22 def MC23a(flags):
23  """MC23a flags for MC to match 2022 Run 3 data"""
24  _MC23PileUp(flags)
25 
26  flags.Input.MCCampaign = Campaign.MC23a
27 
28  # pile-up
29  # These numbers are based upon a relative XS scaling of the high-pt slice
30  # of 64%, which leads to a relative high-pt / low-pt sampling of
31  # 0.001953314389 / 0.9980466856. Those numbers are then multiplied by 67.5
32  # to follow pile-up profile. Only a relevant number of significant digits
33  # are kept.
34  flags.Digitization.PU.NumberOfLowPtMinBias = 67.369
35  flags.Digitization.PU.NumberOfHighPtMinBias = 0.131
36  flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructure_Fill7314_BCMSPattern_Flat'
37  flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run410000_MC23a_MultiBeamspot'
38 
39 
40 def MC23c(flags):
41  """MC23c flags for MC to match 2023 Run 3 data (initial pile-up profile estimate)"""
42  _MC23PileUp(flags)
43 
44  flags.Input.MCCampaign = Campaign.MC23c
45 
46  # pile-up
47  # These numbers are based upon a relative XS scaling of the high-pt slice
48  # of 64%, which leads to a relative high-pt / low-pt sampling of
49  # 0.001953314389 / 0.9980466856. Those numbers are then multiplied by 90.5
50  # to follow pile-up profile. Only a relevant number of significant digits
51  # are kept.
52  flags.Digitization.PU.NumberOfLowPtMinBias = 90.323
53  flags.Digitization.PU.NumberOfHighPtMinBias = 0.177
54  flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructure_Fill7314_BCMSPattern_Flat'
55  flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run450000_MC23c_MultiBeamspot'
56 
57 
58 def MC23d(flags):
59  """MC23d flags for MC to match 2023 Run 3 data (uses a pile-up profile based on the actual profile from 2023 data)"""
60  _MC23PileUp(flags)
61 
62  flags.Input.MCCampaign = Campaign.MC23d
63 
64  # pile-up
65  # These numbers are based upon a relative XS scaling of the high-pt slice
66  # of 64%, which leads to a relative high-pt / low-pt sampling of
67  # 0.001953314389 / 0.9980466856. Those numbers are then multiplied by 95.5
68  # to follow pile-up profile. Only a relevant number of significant digits
69  # are kept.
70  flags.Digitization.PU.NumberOfLowPtMinBias = 95.313
71  flags.Digitization.PU.NumberOfHighPtMinBias = 0.187
72  flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructure_Fill7314_BCMSPattern_Flat'
73  flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run450000_MC23d_MultiBeamspot'
74 
75 
77  """MC23 flags for the 2023 Heavy Ions run (without pile-up)"""
78  flags.Input.MCCampaign = Campaign.MC23d
79 
80  flags.Beam.BunchSpacing = 50
81  flags.Beam.NumberOfCollisions = 0.
82  flags.Input.ConditionsRunNumber = 460000
83 
84  from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
86 
87  # radiation damage
88  from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
89  flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
90 
91  from HIRecConfig.HIModeFlags import HImode
92  HImode(flags) # TO CHECK is it an issue if this is set for RDOtoRDOTrigger?
93  flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
94 
95  #all
96  flags.Trigger.AODEDMSet = 'AODFULL'
97  flags.Trigger.triggerMenuSetup = 'Dev_HI_run3_v1_TriggerValidation_prescale'
98 
99 
100 def MC23HeavyIons2023(flags):
101  """MC23 flags for the 2023 Heavy Ions run"""
102  flags.Input.MCCampaign = Campaign.MC23d
103 
104  flags.Beam.NumberOfCollisions = 0.
105  flags.Input.ConditionsRunNumber = 460000
106 
107  from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
108  LArConfigRun3NoPileUp(flags) # TO CHECK is this actually what we want c.f. LArConfigRun3PileUp
109 
110  # radiation damage
111  from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
112  flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
113 
114  # pile-up
115  flags.Digitization.PileUp = True
116  flags.Digitization.DoXingByXingPileUp = True
117  flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructureHeavyIon2022'
118  flags.Digitization.PU.InitialBunchCrossing = 0
119  flags.Digitization.PU.FinalBunchCrossing = 0
120  flags.Digitization.PU.NumberOfCavern = 1 # We are using the Cavern Background input for the Hijing HITS-level events
121 
122  from HIRecConfig.HIModeFlags import HImode
123  HImode(flags) # TO CHECK is it an issue if this is set for RDOtoRDOTrigger?
124  flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
125 
126  #all
127  flags.Trigger.AODEDMSet = 'AODFULL'
128  flags.Trigger.triggerMenuSetup = 'Dev_HI_run3_v1_TriggerValidation_prescale'
129 
130 
131 def MC23e(flags):
132  """MC23e flags for MC to match 2024 Run 3 data (initial pile-up estimate based on broadened 2023 data )"""
133  _MC23PileUp(flags)
134 
135  flags.Input.MCCampaign = Campaign.MC23e
136 
137  # pile-up
138  # These numbers are based upon a relative XS scaling of the high-pt slice
139  # of 64%, which leads to a relative high-pt / low-pt sampling of
140  # 0.001953314389 / 0.9980466856. Those numbers are then multiplied by 98.5
141  # to follow pile-up profile. Only a relevant number of significant digits
142  # are kept.
143  flags.Digitization.PU.NumberOfLowPtMinBias = 98.308
144  flags.Digitization.PU.NumberOfHighPtMinBias = 0.192
145  # TODO new bunch structure?
146  flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructure_Fill7314_BCMSPattern_Flat'
147  flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run470000_MC23e_MultiBeamspot'
148 
149 
150 def MC23g(flags):
151  """MC23g flags for MC to match 2025 Run 3 data (initial pile-up estimate based on broadened 2024 data )"""
152  _MC23PileUp(flags)
153 
154  flags.Input.MCCampaign = Campaign.MC23g
155 
156  # pile-up
157  # These numbers are based upon a relative XS scaling of the high-pt slice
158  # of 64%, which leads to a relative high-pt / low-pt sampling of
159  # 0.001953314389 / 0.9980466856. Those numbers are then multiplied by 98.5
160  # to follow pile-up profile. Only a relevant number of significant digits
161  # are kept.
162  flags.Digitization.PU.NumberOfLowPtMinBias = 98.308
163  flags.Digitization.PU.NumberOfHighPtMinBias = 0.192
164  # TODO new bunch structure?
165  flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructure_Fill7314_BCMSPattern_Flat'
166  # TODO: replace with the actual profile
167  flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run470000_MC23e_MultiBeamspot'
168 
169 
170 def MC23ppReferenceRun2024(flags): # FIXME This configuration is a placeholder
171  """MC23 flags for the 2024 5.36 TeV pp reference run"""
172  flags.Input.MCCampaign = Campaign.MC23e
173 
174  flags.Beam.NumberOfCollisions = 0.
175  flags.Input.ConditionsRunNumber = 488000
176 
177  from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
178  LArConfigRun3NoPileUp(flags) # TO CHECK is this actually what we want c.f. LArConfigRun3PileUp
179 
180  # radiation damage
181  from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
182  flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
183 
184  # pile-up
185  flags.Digitization.PileUp = True
186  flags.Digitization.DoXingByXingPileUp = True
187  flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructureHeavyIon2022' # New file being prepared ATLGBLCONDTAGS-182
188  flags.Digitization.PU.InitialBunchCrossing = 0
189  flags.Digitization.PU.FinalBunchCrossing = 0
190  flags.Digitization.PU.NumberOfCavern = 1 # We are using the Cavern Background input for the Hijing HITS-level events
191 
192  from HIRecConfig.HIModeFlags import HIPmode
193  HIPmode(flags) # TO CHECK is it an issue if this is set for RDOtoRDOTrigger?
194  flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
195 
196  #all
197  flags.Trigger.AODEDMSet = 'AODFULL'
198  flags.Trigger.triggerMenuSetup = 'PhysicsP1_pp_lowMu_run3_v1_TriggerValidation_prescale'
199 
200 
201 def MC23HeavyIons2024NoPileUp(flags): # FIXME This configuration is a placeholder
202  """MC23 flags for the 2024 Heavy Ions run (without pile-up)"""
203  flags.Input.MCCampaign = Campaign.MC23e
204 
205  flags.Beam.BunchSpacing = 50
206  flags.Beam.NumberOfCollisions = 0.
207  flags.Input.ConditionsRunNumber = 488600
208 
209  from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
210  LArConfigRun3NoPileUp(flags)
211 
212  # radiation damage
213  from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
214  flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
215 
216  from HIRecConfig.HIModeFlags import HImode
217  HImode(flags) # TO CHECK is it an issue if this is set for RDOtoRDOTrigger?
218  flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
219 
220  #all
221  flags.Trigger.AODEDMSet = 'AODFULL'
222  flags.Trigger.triggerMenuSetup = 'Dev_HI_run3_v1_TriggerValidation_prescale'
223 
224 
225 def MC23HeavyIons2024(flags): # FIXME This configuration is a placeholder
226  """MC23 flags for the 2024 Heavy Ions run"""
227  flags.Input.MCCampaign = Campaign.MC23e
228 
229  flags.Beam.NumberOfCollisions = 0.
230  flags.Input.ConditionsRunNumber = 488600
231 
232  from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
233  LArConfigRun3NoPileUp(flags) # TO CHECK is this actually what we want c.f. LArConfigRun3PileUp
234 
235  # radiation damage
236  from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
237  flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
238 
239  # pile-up
240  flags.Digitization.PileUp = True
241  flags.Digitization.DoXingByXingPileUp = True
242  flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructureHeavyIon2022' # New file being prepared ATLGBLCONDTAGS-182
243  flags.Digitization.PU.InitialBunchCrossing = 0
244  flags.Digitization.PU.FinalBunchCrossing = 0
245  flags.Digitization.PU.NumberOfCavern = 1 # We are using the Cavern Background input for the Hijing HITS-level events
246 
247  from HIRecConfig.HIModeFlags import HImode
248  HImode(flags) # TO CHECK is it an issue if this is set for RDOtoRDOTrigger?
249  flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
250 
251  #all
252  flags.Trigger.AODEDMSet = 'AODFULL'
253  flags.Trigger.triggerMenuSetup = 'Dev_HI_run3_v1_TriggerValidation_prescale'
254 
255 
256 def MC23HeavyIons2025OO(flags): # FIXME This configuration is a placeholder
257  """MC23 flags for the 2025 Heavy Ions (Oxygen) run"""
258  flags.Input.MCCampaign = Campaign.MC23g
259 
260  flags.Beam.BunchSpacing = 500
261  flags.Beam.NumberOfCollisions = 0.0 # TODO: change once we have
262  flags.Input.ConditionsRunNumber = 488000 # TODO: replace with the actual run number once we have the conditions
263 
264  from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
265  LArConfigRun3NoPileUp(flags) # TO CHECK is this actually what we want c.f. LArConfigRun3PileUp
266 
267  # radiation damage
268  from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
269  flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
270 
271  # pile-up
272  flags.Digitization.PileUp = False #TODO: change once we have the conditions
273  flags.Digitization.DoXingByXingPileUp = False #TODO: as above
274  flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructureHeavyIon2022' # New file being prepared ATLGBLCONDTAGS-182
275  flags.Digitization.PU.InitialBunchCrossing = 0
276  flags.Digitization.PU.FinalBunchCrossing = 0
277  flags.Digitization.PU.NumberOfCavern = 1 # We are using the Cavern Background input for the Hijing HITS-level events
278 
279  from HIRecConfig.HIModeFlags import HIPmode
280  HIPmode(flags)
281  flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
282 
283  #all
284  flags.Trigger.AODEDMSet = 'AODFULL'
285  flags.Trigger.triggerMenuSetup = 'Dev_pp_lowMu_run3_v1_TriggerValidation_prescale'
286 
287 
289  """MC23a flags for MC to match 2022 Run 3 data (single beamspot version)"""
290  MC23a(flags)
291 
292  # override only pile-up profile
293  flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run410000_MC23a_SingleBeamspot'
294 
295 
297  """MC23c flags for MC to match 2023 Run 3 data (initial pile-up profile estimate, single beamspot version)"""
298  MC23c(flags)
299 
300  # override only pile-up profile
301  flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run450000_MC23c_SingleBeamspot'
302 
303 
305  """MC23d flags for MC to match 2023 Run 3 data (uses a pile-up profile based on the actual profile from 2023 data, single beamspot version)"""
306  MC23d(flags)
307 
308  # override only pile-up profile
309  flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run450000_MC23d_SingleBeamspot'
310 
312  """MC23e flags for MC to match 2024 Run 3 data (initial pile-up profile estimate, single beamspot version)"""
313  MC23e(flags)
314 
315  # override only pile-up profile
316  flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run470000_MC23e_SingleBeamspot'
317 
319  """MC23g flags for MC to match 2025 Run 3 data (initial pile-up profile estimate, single beamspot version)"""
320  MC23g(flags)
321 
322  # override only pile-up profile
323  # TODO: replace with the actual profile
324  flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run470000_MC23e_SingleBeamspot'
325 
326 
327 def MC23LowMu(flags):
328  """MC23 flags for MC to match Run 3 data with low pile-up"""
329  flags.Input.MCCampaign = Campaign.MC23a
330 
331  flags.Beam.NumberOfCollisions = 60.
332  flags.Input.ConditionsRunNumber = 410000
333 
334  from LArConfiguration.LArConfigRun3 import LArConfigRun3PileUp
335  LArConfigRun3PileUp(flags)
336 
337  # radiation damage
338  from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
339  flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
340 
341  # pile-up
342  # These numbers are based upon a relative XS scaling of the high-pt slice
343  # of 64%, which leads to a relative high-pt / low-pt sampling of
344  # 0.001953314389 / 0.9980466856. Those numbers are then multiplied by 0.05
345  # to simulate low pile-up. Only a relevant number of significant digits
346  # are kept.
347  flags.Digitization.PU.NumberOfLowPtMinBias = 0.0499
348  flags.Digitization.PU.NumberOfHighPtMinBias = 0.0001
349  flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructure_Fill7314_BCMSPattern_Flat'
350 
351 
352 def _MC23NoPileUp(flags):
353  """MC23 flags for MC without pile-up"""
354  flags.Beam.NumberOfCollisions = 0.
355 
356  from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
357  LArConfigRun3NoPileUp(flags)
358 
359  # radiation damage
360  from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
361  flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
362 
363 
364 def MC23aNoPileUp(flags):
365  """MC23a flags for MC without pile-up"""
366  _MC23NoPileUp(flags)
367 
368  flags.Input.MCCampaign = Campaign.MC23a
369  flags.Input.ConditionsRunNumber = 410000
370 
371 
372 def MC23dNoPileUp(flags):
373  """MC23d flags for MC without pile-up"""
374  _MC23NoPileUp(flags)
375 
376  flags.Input.MCCampaign = Campaign.MC23d
377  flags.Input.ConditionsRunNumber = 450000
378 
379 
380 def MC23eNoPileUp(flags):
381  """MC23e flags for MC without pile-up"""
382  _MC23NoPileUp(flags)
383 
384  flags.Input.MCCampaign = Campaign.MC23e
385  flags.Input.ConditionsRunNumber = 470000
386 
387 
388 def MC23gNoPileUp(flags):
389  """MC23g flags for MC without pile-up"""
390  _MC23NoPileUp(flags)
391 
392  flags.Input.MCCampaign = Campaign.MC23g
393  # TODO: replace with the actual run number
394  flags.Input.ConditionsRunNumber = 470000
395 
396 
398  """MC23a flags for MC to match 2002 Low Mu data"""
399  _MC23NoPileUp(flags)
400 
401  flags.Input.MCCampaign = Campaign.MC23a
402  flags.Input.ConditionsRunNumber = 420000
403 
404 
406  """MC23d flags for MC to match special run 460348"""
407  _MC23NoPileUp(flags)
408 
409  flags.Input.MCCampaign = Campaign.MC23d
410  flags.Input.ConditionsRunNumber = 465000
411 
412  # B-field configuration
413  flags.BField.configuredSolenoidFieldScale = 0.4
414 
415 
417  """MC23a beamspot splitting configuration"""
418  substeps = 4
419  event_fractions = [0.14, 0.14, 0.14, 0.58]
420 
421  return substeps, event_fractions
422 
423 
425  """MC23c beamspot splitting configuration"""
426  substeps = 4
427  event_fractions = [0.22, 0.22, 0.22, 0.34]
428 
429  return substeps, event_fractions
430 
431 
433  """MC23d beamspot splitting configuration, matches MC23c, but only the
434  first two substep are considered levelling rather than the first
435  three."""
436  substeps = 4
437  event_fractions = [0.22, 0.22, 0.22, 0.34]
438 
439  return substeps, event_fractions
440 
441 
443  """MC23e beamspot splitting configuration."""
444  substeps = 4
445  event_fractions = [0.22, 0.22, 0.22, 0.34]
446 
447  return substeps, event_fractions
448 
449 
451  """MC23g beamspot splitting configuration."""
452  substeps = 4
453  event_fractions = [0.22, 0.22, 0.22, 0.34]
454 
455  return substeps, event_fractions
456 
457 
459  """MC23 base flags for simulation without specifying conditions IoVs"""
460  flags.Input.MCCampaign = Campaign.MC23a
461 
462  from SimulationConfig.SimEnums import TruthStrategy
463  flags.Sim.PhysicsList = 'FTFP_BERT_ATL'
464  flags.Sim.TruthStrategy = TruthStrategy.MC15aPlus
465 
466  flags.Sim.TRTRangeCut = 30.0
467  flags.Sim.TightMuonStepping = True
468 
469  from SimulationConfig.G4Optimizations import enableBeamPipeKill, enableFrozenShowersFCalOnly
470  enableBeamPipeKill(flags)
471  if flags.Sim.ISF.Simulator.isFullSim():
473 
474  from SimulationConfig.G4Optimizations import enableG4Optimizations
475  enableG4Optimizations(flags)
476 
477  flags.Sim.FastCalo.ParamsInputFilename = 'FastCaloSim/MC23/TFCSparam_dev_Hybrid_Ha_v5_all_baryons_0_500.root'
478 
479 
481  """MC23 flags for low mu run simulation"""
482  MC23SimulationNoIoV(flags)
483 
484  flags.Input.RunNumbers = [420000]
485  flags.Input.OverrideRunNumber = True
486  flags.Input.LumiBlockNumbers = [1] # dummy value
487 
488 
490  """MC23 flags for simulation simulation of the 2023 Heavy Ion run"""
491  MC23SimulationNoIoV(flags)
492  flags.Input.MCCampaign = Campaign.MC23d
493 
494  flags.Input.RunNumbers = [460000]
495  flags.Input.OverrideRunNumber = True
496  flags.Input.LumiBlockNumbers = [1] # dummy value
497 
498 
500  """MC23 flags for simulation simulation of the 2024 5.36 TeV pp reference run"""
501  MC23SimulationNoIoV(flags)
502  flags.Input.MCCampaign = Campaign.MC23e
503 
504  flags.Input.RunNumbers = [488000]
505  flags.Input.OverrideRunNumber = True
506  flags.Input.LumiBlockNumbers = [1] # dummy value
507 
508 
510  """MC23 flags for simulation simulation of the 2024 Heavy Ion run"""
511  MC23SimulationNoIoV(flags)
512  flags.Input.MCCampaign = Campaign.MC23e
513 
514  flags.Input.RunNumbers = [488600]
515  flags.Input.OverrideRunNumber = True
516  flags.Input.LumiBlockNumbers = [1] # dummy value
517 
519  """MC23 flags for simulation simulation of the 2025 Oxygen Oxygen run"""
520  MC23SimulationNoIoV(flags)
521  flags.Input.MCCampaign = Campaign.MC23g
522 
523  flags.Input.RunNumbers = [488000]
524  flags.Input.OverrideRunNumber = True
525  flags.Input.LumiBlockNumbers = [1] # dummy value
526 
527 
529  """MC23 flags for simulation of special run 460348"""
530  MC23SimulationNoIoV(flags)
531  flags.Input.MCCampaign = Campaign.MC23d
532 
533  flags.Input.RunNumbers = [465000]
534  flags.Input.OverrideRunNumber = True
535  flags.Input.LumiBlockNumber = [1] # dummy value
536 
537  # B-field configuration
538  flags.BField.configuredSolenoidFieldScale = 0.4
539 
540 
542  """MC23 flags for simulation"""
543  MC23SimulationNoIoV(flags)
544  flags.Input.MCCampaign = Campaign.MC23a
545 
546  flags.Input.RunNumbers = [410000]
547  flags.Input.OverrideRunNumber = True
548  flags.Input.LumiBlockNumbers = [1] # dummy value
549 
550 
552  """MC23 flags for simulation"""
553  MC23SimulationNoIoV(flags)
554  flags.Input.MCCampaign = Campaign.MC23a
555 
556  flags.Input.OverrideRunNumber = True
557 
558  from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
560  profile='RunDependentSimData.PileUpProfile_run410000_MC23a_MultiBeamspot')
561 
562 
564  """MC23 flags for simulation"""
565  MC23SimulationNoIoV(flags)
566  flags.Input.MCCampaign = Campaign.MC23c
567 
568  flags.Input.OverrideRunNumber = True
569 
570  from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
572  profile='RunDependentSimData.PileUpProfile_run450000_MC23c_MultiBeamspot')
573 
574 
576  """MC23 flags for simulation"""
577  MC23SimulationNoIoV(flags)
578  flags.Input.MCCampaign = Campaign.MC23e
579 
580  flags.Input.OverrideRunNumber = True
581 
582  from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
584  profile='RunDependentSimData.PileUpProfile_run470000_MC23e_MultiBeamspot')
585 
586 
588  """MC23 flags for simulation"""
589  MC23SimulationNoIoV(flags)
590  flags.Input.MCCampaign = Campaign.MC23g
591 
592  flags.Input.OverrideRunNumber = True
593 
594  from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
595  # TODO: replace with the actual profile
597  profile='RunDependentSimData.PileUpProfile_run470000_MC23e_MultiBeamspot')
598 
599 
601  """MC23 flags for simulation with CalibrationHits"""
603  from SimuJobTransforms import CalHits, ParticleID
604  CalHits(flags)
605  ParticleID(flags)
606 
607 
609  """MC23 flags for simulation with CalibrationHits"""
611  from SimuJobTransforms import CalHits, ParticleID
612  CalHits(flags)
613  ParticleID(flags)
614 
615 
617  """MC23 flags for simulation with CalibrationHits"""
619  from SimuJobTransforms import CalHits, ParticleID
620  CalHits(flags)
621  ParticleID(flags)
622 
623 
625  """MC23e flags for simulation with CalibrationHits"""
627  from SimuJobTransforms import CalHits, ParticleID
628  CalHits(flags)
629  ParticleID(flags)
630 
631 
633  """MC23g flags for simulation with CalibrationHits"""
635  from SimuJobTransforms import CalHits, ParticleID
636  CalHits(flags)
637  ParticleID(flags)
python.MC23.MC23Simulation2025OORun
def MC23Simulation2025OORun(flags)
Definition: MC23.py:518
python.G4Optimizations.enableBeamPipeKill
def enableBeamPipeKill(flags)
Definition: G4Optimizations.py:16
python.MC23.MC23a
def MC23a(flags)
Definition: MC23.py:22
python.MC23.MC23g
def MC23g(flags)
Definition: MC23.py:150
python.G4Optimizations.enableG4Optimizations
def enableG4Optimizations(flags)
Definition: G4Optimizations.py:114
python.MC23.MC23aNoPileUp
def MC23aNoPileUp(flags)
Definition: MC23.py:364
python.MC23.MC23cSimulationMultipleIoV
def MC23cSimulationMultipleIoV(flags)
Definition: MC23.py:563
python.MC23.MC23aSingleBeamspot
def MC23aSingleBeamspot(flags)
Definition: MC23.py:288
python.MC23.MC23Simulation2023HeavyIonRun
def MC23Simulation2023HeavyIonRun(flags)
Definition: MC23.py:489
python.MC23.MC23NoPileUpLowMuRun
def MC23NoPileUpLowMuRun(flags)
Definition: MC23.py:397
python.LArConfigRun3.LArConfigRun3NoPileUp
def LArConfigRun3NoPileUp(flags)
Definition: LArConfigRun3.py:13
python.MC23.MC23cSimulationMultipleIoVCalibrationHits
def MC23cSimulationMultipleIoVCalibrationHits(flags)
Definition: MC23.py:616
python.MC23.MC23dSimulationLowMuLowB
def MC23dSimulationLowMuLowB(flags)
Definition: MC23.py:528
python.MC23.MC23dNoPileUp
def MC23dNoPileUp(flags)
Definition: MC23.py:372
python.MC23.MC23SimulationSingleIoV
def MC23SimulationSingleIoV(flags)
Definition: MC23.py:541
python.MC23.MC23eSimulationMultipleIoVCalibrationHits
def MC23eSimulationMultipleIoVCalibrationHits(flags)
Definition: MC23.py:624
python.LArConfigRun3.LArConfigRun3PileUp
def LArConfigRun3PileUp(flags)
Definition: LArConfigRun3.py:3
python.MC23.MC23Simulation2024ppRefRun
def MC23Simulation2024ppRefRun(flags)
Definition: MC23.py:499
python.MC23.MC23eSingleBeamspot
def MC23eSingleBeamspot(flags)
Definition: MC23.py:311
python.MC23.MC23gSimulationMultipleIoV
def MC23gSimulationMultipleIoV(flags)
Definition: MC23.py:587
python.MC23.BeamspotSplitMC23g
def BeamspotSplitMC23g()
Definition: MC23.py:450
python.MC23.MC23Simulation2024HeavyIonRun
def MC23Simulation2024HeavyIonRun(flags)
Definition: MC23.py:509
python.MC23.MC23eNoPileUp
def MC23eNoPileUp(flags)
Definition: MC23.py:380
python.MC23.MC23ppReferenceRun2024
def MC23ppReferenceRun2024(flags)
Definition: MC23.py:170
python.MC23.MC23e
def MC23e(flags)
Definition: MC23.py:131
python.HIModeFlags.HImode
def HImode(flags)
Definition: HIModeFlags.py:5
jobOptions.ParticleID
ParticleID
Definition: jobOptions.decayer.py:85
python.MC23.MC23HeavyIons2023NoPileUp
def MC23HeavyIons2023NoPileUp(flags)
Definition: MC23.py:76
python.MC23._MC23PileUp
def _MC23PileUp(flags)
Definition: MC23.py:6
python.MC23.MC23SimulationLowMuRun
def MC23SimulationLowMuRun(flags)
Definition: MC23.py:480
python.MC23.BeamspotSplitMC23a
def BeamspotSplitMC23a()
Definition: MC23.py:416
python.MC23.MC23eSimulationMultipleIoV
def MC23eSimulationMultipleIoV(flags)
Definition: MC23.py:575
python.MC23.MC23gSimulationMultipleIoVCalibrationHits
def MC23gSimulationMultipleIoVCalibrationHits(flags)
Definition: MC23.py:632
python.MC23.MC23gSingleBeamspot
def MC23gSingleBeamspot(flags)
Definition: MC23.py:318
python.MC23._MC23NoPileUp
def _MC23NoPileUp(flags)
Definition: MC23.py:352
python.MC23.BeamspotSplitMC23e
def BeamspotSplitMC23e()
Definition: MC23.py:442
python.MC23.MC23LowMu
def MC23LowMu(flags)
Definition: MC23.py:327
python.G4Optimizations.enableFrozenShowersFCalOnly
def enableFrozenShowersFCalOnly(flags)
Definition: G4Optimizations.py:5
python.MC23.MC23aSimulationMultipleIoV
def MC23aSimulationMultipleIoV(flags)
Definition: MC23.py:551
python.MC23.MC23dSingleBeamspot
def MC23dSingleBeamspot(flags)
Definition: MC23.py:304
python.MC23.MC23SimulationNoIoV
def MC23SimulationNoIoV(flags)
Definition: MC23.py:458
python.MC23.BeamspotSplitMC23d
def BeamspotSplitMC23d()
Definition: MC23.py:432
python.MC23.MC23HeavyIons2024NoPileUp
def MC23HeavyIons2024NoPileUp(flags)
Definition: MC23.py:201
python.MC23.BeamspotSplitMC23c
def BeamspotSplitMC23c()
Definition: MC23.py:424
python.MC23.MC23SimulationSingleIoVCalibrationHits
def MC23SimulationSingleIoVCalibrationHits(flags)
Definition: MC23.py:600
python.MC23.MC23HeavyIons2024
def MC23HeavyIons2024(flags)
Definition: MC23.py:225
python.MC23.MC23cSingleBeamspot
def MC23cSingleBeamspot(flags)
Definition: MC23.py:296
python.MC23.MC23HeavyIons2025OO
def MC23HeavyIons2025OO(flags)
Definition: MC23.py:256
python.MC23.MC23d
def MC23d(flags)
Definition: MC23.py:58
python.PileUpUtils.generateRunAndLumiProfile
def generateRunAndLumiProfile(flags, profile, sequentialEventNumbers=False, doNotCorrectMaxEvents=False)
Definition: PileUpUtils.py:211
python.MC23.MC23aSimulationMultipleIoVCalibrationHits
def MC23aSimulationMultipleIoVCalibrationHits(flags)
Definition: MC23.py:608
python.MC23.MC23gNoPileUp
def MC23gNoPileUp(flags)
Definition: MC23.py:388
python.HIModeFlags.HIPmode
def HIPmode(flags)
Definition: HIModeFlags.py:10
python.MC23.MC23c
def MC23c(flags)
Definition: MC23.py:40
python.MC23.MC23NoPileUpLowMuLowB
def MC23NoPileUpLowMuLowB(flags)
Definition: MC23.py:405
python.MC23.MC23HeavyIons2023
def MC23HeavyIons2023(flags)
Definition: MC23.py:100