ATLAS Offline Software
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 mc23g profile - this is a validation PileupProfile file
167  flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run495000_MC23g_MultiBeamspot_VALIDATION'
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 
176  from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
177  LArConfigRun3NoPileUp(flags) # TO CHECK is this actually what we want c.f. LArConfigRun3PileUp
178 
179  # radiation damage
180  from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
181  flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
182 
183  # pile-up
184  # These numbers are based upon a relative XS scaling of the high-pt slice
185  # of 64%, which leads to a relative high-pt / low-pt sampling of
186  # 0.001953314389 / 0.9980466856. Those numbers are then multiplied by 7.5
187  # to follow pile-up profile. Only a relevant number of significant digits
188  # are kept.
189  flags.Digitization.PU.NumberOfLowPtMinBias = 7.485
190  flags.Digitization.PU.NumberOfHighPtMinBias = 0.015
191  flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructure_Fill7314_BCMSPattern_Flat'
192  flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run488000_MC23e_SingleBeamspot'
193 
194  from HIRecConfig.HIModeFlags import HIPmode
195  HIPmode(flags) # TO CHECK is it an issue if this is set for RDOtoRDOTrigger?
196  flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
197 
198  #all
199  flags.Trigger.AODEDMSet = 'AODFULL'
200  flags.Trigger.triggerMenuSetup = 'PhysicsP1_pp_lowMu_run3_v1_TriggerValidation_prescale'
201 
202 
203 def MC23HeavyIons2024NoPileUp(flags): # FIXME This configuration is a placeholder
204  """MC23 flags for the 2024 Heavy Ions run (without pile-up)"""
205  flags.Input.MCCampaign = Campaign.MC23e
206 
207  flags.Beam.BunchSpacing = 50
208  flags.Beam.NumberOfCollisions = 0.
209  flags.Input.ConditionsRunNumber = 488600
210 
211  from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
212  LArConfigRun3NoPileUp(flags)
213 
214  # radiation damage
215  from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
216  flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
217 
218  from HIRecConfig.HIModeFlags import HImode
219  HImode(flags) # TO CHECK is it an issue if this is set for RDOtoRDOTrigger?
220  flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
221 
222  #all
223  flags.Trigger.AODEDMSet = 'AODFULL'
224  flags.Trigger.triggerMenuSetup = 'Dev_HI_run3_v1_TriggerValidation_prescale'
225 
226 
227 def MC23HeavyIons2024(flags): # FIXME This configuration is a placeholder
228  """MC23 flags for the 2024 Heavy Ions run"""
229  flags.Input.MCCampaign = Campaign.MC23e
230 
231  flags.Beam.NumberOfCollisions = 0.
232  flags.Input.ConditionsRunNumber = 488600
233 
234  from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
235  LArConfigRun3NoPileUp(flags) # TO CHECK is this actually what we want c.f. LArConfigRun3PileUp
236 
237  # radiation damage
238  from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
239  flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
240 
241  # pile-up
242  flags.Digitization.PileUp = True
243  flags.Digitization.DoXingByXingPileUp = True
244  flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructureHeavyIon2022' # New file being prepared ATLGBLCONDTAGS-182
245  flags.Digitization.PU.InitialBunchCrossing = 0
246  flags.Digitization.PU.FinalBunchCrossing = 0
247  flags.Digitization.PU.NumberOfCavern = 1 # We are using the Cavern Background input for the Hijing HITS-level events
248 
249  from HIRecConfig.HIModeFlags import HImode
250  HImode(flags) # TO CHECK is it an issue if this is set for RDOtoRDOTrigger?
251  flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
252 
253  #all
254  flags.Trigger.AODEDMSet = 'AODFULL'
255  flags.Trigger.triggerMenuSetup = 'Dev_HI_run3_v1_TriggerValidation_prescale'
256 
257 
259  """MC23 flags for the 2025 Heavy Ions (Oxygen) run"""
260  flags.Input.MCCampaign = Campaign.MC23g
261 
262  flags.Beam.BunchSpacing = 500
263  flags.Beam.NumberOfCollisions = 0.0
264  flags.Input.ConditionsRunNumber = 500700
265 
266  from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
267  LArConfigRun3NoPileUp(flags)
268 
269  # radiation damage
270  from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
271  flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
272 
273  # pile-up
274  flags.Digitization.PileUp = False
275  flags.Digitization.DoXingByXingPileUp = False
276  flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructureHeavyIon2025OO'
277  flags.Digitization.PU.InitialBunchCrossing = 0
278  flags.Digitization.PU.FinalBunchCrossing = 0
279  flags.Digitization.PU.NumberOfCavern = 1 # We are using the Cavern Background input for the Hijing HITS-level events
280 
281  from HIRecConfig.HIModeFlags import HIPmode
282  HIPmode(flags)
283  flags.Reco.EnableZDC = False
284 
285  #all
286  flags.Trigger.AODEDMSet = 'AODFULL'
287  flags.Trigger.triggerMenuSetup = 'Dev_pp_lowMu_run3_v1_TriggerValidation_prescale'
288 
289 
291  """MC23a flags for MC to match 2022 Run 3 data (single beamspot version)"""
292  MC23a(flags)
293 
294  # override only pile-up profile
295  flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run410000_MC23a_SingleBeamspot'
296 
297 
299  """MC23c flags for MC to match 2023 Run 3 data (initial pile-up profile estimate, single beamspot version)"""
300  MC23c(flags)
301 
302  # override only pile-up profile
303  flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run450000_MC23c_SingleBeamspot'
304 
305 
307  """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)"""
308  MC23d(flags)
309 
310  # override only pile-up profile
311  flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run450000_MC23d_SingleBeamspot'
312 
314  """MC23e flags for MC to match 2024 Run 3 data (initial pile-up profile estimate, single beamspot version)"""
315  MC23e(flags)
316 
317  # override only pile-up profile
318  flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run470000_MC23e_SingleBeamspot'
319 
321  """MC23g flags for MC to match 2025 Run 3 data (initial pile-up profile estimate, single beamspot version)"""
322  MC23g(flags)
323 
324  # override only pile-up profile
325  # TODO: replace with the actual profile
326  flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run470000_MC23e_SingleBeamspot'
327 
328 
329 def MC23LowMu(flags):
330  """MC23 flags for MC to match Run 3 data with low pile-up"""
331  flags.Input.MCCampaign = Campaign.MC23a
332 
333  flags.Beam.NumberOfCollisions = 60.
334  flags.Input.ConditionsRunNumber = 410000
335 
336  from LArConfiguration.LArConfigRun3 import LArConfigRun3PileUp
337  LArConfigRun3PileUp(flags)
338 
339  # radiation damage
340  from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
341  flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
342 
343  # pile-up
344  # These numbers are based upon a relative XS scaling of the high-pt slice
345  # of 64%, which leads to a relative high-pt / low-pt sampling of
346  # 0.001953314389 / 0.9980466856. Those numbers are then multiplied by 0.05
347  # to simulate low pile-up. Only a relevant number of significant digits
348  # are kept.
349  flags.Digitization.PU.NumberOfLowPtMinBias = 0.0499
350  flags.Digitization.PU.NumberOfHighPtMinBias = 0.0001
351  flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructure_Fill7314_BCMSPattern_Flat'
352 
353 
354 def _MC23NoPileUp(flags):
355  """MC23 flags for MC without pile-up"""
356  flags.Beam.NumberOfCollisions = 0.
357 
358  from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
359  LArConfigRun3NoPileUp(flags)
360 
361  # radiation damage
362  from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
363  flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
364 
365 
366 def MC23aNoPileUp(flags):
367  """MC23a flags for MC without pile-up"""
368  _MC23NoPileUp(flags)
369 
370  flags.Input.MCCampaign = Campaign.MC23a
371  flags.Input.ConditionsRunNumber = 410000
372 
373 
374 def MC23dNoPileUp(flags):
375  """MC23d flags for MC without pile-up"""
376  _MC23NoPileUp(flags)
377 
378  flags.Input.MCCampaign = Campaign.MC23d
379  flags.Input.ConditionsRunNumber = 450000
380 
381 
382 def MC23eNoPileUp(flags):
383  """MC23e flags for MC without pile-up"""
384  _MC23NoPileUp(flags)
385 
386  flags.Input.MCCampaign = Campaign.MC23e
387  flags.Input.ConditionsRunNumber = 470000
388 
389 
390 def MC23gNoPileUp(flags):
391  """MC23g flags for MC without pile-up"""
392  _MC23NoPileUp(flags)
393 
394  flags.Input.MCCampaign = Campaign.MC23g
395  # TODO: replace with the actual run number
396  flags.Input.ConditionsRunNumber = 470000
397 
398 
400  """MC23a flags for MC to match 2002 Low Mu data"""
401  _MC23NoPileUp(flags)
402 
403  flags.Input.MCCampaign = Campaign.MC23a
404  flags.Input.ConditionsRunNumber = 420000
405 
406 
408  """MC23d flags for MC to match special run 460348"""
409  _MC23NoPileUp(flags)
410 
411  flags.Input.MCCampaign = Campaign.MC23d
412  flags.Input.ConditionsRunNumber = 465000
413 
414  # B-field configuration
415  flags.BField.configuredSolenoidFieldScale = 0.4
416 
417 
419  """MC23a beamspot splitting configuration"""
420  substeps = 4
421  event_fractions = [0.14, 0.14, 0.14, 0.58]
422 
423  return substeps, event_fractions
424 
425 
427  """MC23c beamspot splitting configuration"""
428  substeps = 4
429  event_fractions = [0.22, 0.22, 0.22, 0.34]
430 
431  return substeps, event_fractions
432 
433 
435  """MC23d beamspot splitting configuration, matches MC23c, but only the
436  first two substep are considered levelling rather than the first
437  three."""
438  substeps = 4
439  event_fractions = [0.22, 0.22, 0.22, 0.34]
440 
441  return substeps, event_fractions
442 
443 
445  """MC23e beamspot splitting configuration."""
446  substeps = 4
447  event_fractions = [0.22, 0.22, 0.22, 0.34]
448 
449  return substeps, event_fractions
450 
451 
453  """MC23g beamspot splitting configuration."""
454  substeps = 4
455  event_fractions = [0.3, 0.41, 0.09, 0.2]
456 
457  return substeps, event_fractions
458 
459 
461  """MC23g beamspot splitting configuration for Validation purposes. The values are kept the same as BeamspotSplitMC23e"""
462  substeps = 4
463  event_fractions = [0.22, 0.22, 0.22, 0.34]
464 
465  return substeps, event_fractions
466 
468  """MC23 base flags for simulation without specifying conditions IoVs"""
469  flags.Input.MCCampaign = Campaign.MC23a
470 
471  from SimulationConfig.SimEnums import TruthStrategy
472  flags.Sim.PhysicsList = 'FTFP_BERT_ATL'
473  flags.Sim.TruthStrategy = TruthStrategy.MC15aPlus
474 
475  flags.Sim.TRTRangeCut = 30.0
476  flags.Sim.TightMuonStepping = True
477 
478  from SimulationConfig.G4Optimizations import enableBeamPipeKill, enableFrozenShowersFCalOnly
479  enableBeamPipeKill(flags)
480  if flags.Sim.ISF.Simulator.isFullSim():
482 
483  from SimulationConfig.G4Optimizations import enableG4Optimizations
484  enableG4Optimizations(flags)
485 
486  flags.Sim.FastCalo.ParamsInputFilename = 'FastCaloSim/MC23/TFCSparam_dev_Hybrid_Ha_v5_all_baryons_0_500.root'
487 
488 
490  """MC23 flags for low mu run simulation"""
491  MC23SimulationNoIoV(flags)
492 
493  flags.Input.RunNumbers = [420000]
494  flags.Input.OverrideRunNumber = True
495  flags.Input.LumiBlockNumbers = [1] # dummy value
496 
497 
499  """MC23 flags for simulation simulation of the 2023 Heavy Ion run"""
500  MC23SimulationNoIoV(flags)
501  flags.Input.MCCampaign = Campaign.MC23d
502 
503  flags.Input.RunNumbers = [460000]
504  flags.Input.OverrideRunNumber = True
505  flags.Input.LumiBlockNumbers = [1] # dummy value
506 
507 
509  """MC23 flags for simulation simulation of the 2024 5.36 TeV pp reference run"""
510  MC23SimulationNoIoV(flags)
511  flags.Input.MCCampaign = Campaign.MC23e
512 
513  flags.Input.RunNumbers = [488000]
514  flags.Input.OverrideRunNumber = True
515  flags.Input.LumiBlockNumbers = [1] # dummy value
516 
517 
519  """MC23 flags for simulation simulation of the 2024 Heavy Ion run"""
520  MC23SimulationNoIoV(flags)
521  flags.Input.MCCampaign = Campaign.MC23e
522 
523  flags.Input.RunNumbers = [488600]
524  flags.Input.OverrideRunNumber = True
525  flags.Input.LumiBlockNumbers = [1] # dummy value
526 
528  """MC23 flags for simulation simulation of the 2025 Oxygen Oxygen run"""
529  MC23SimulationNoIoV(flags)
530  flags.Input.MCCampaign = Campaign.MC23g
531 
532  flags.Input.RunNumbers = [500700]
533  flags.Input.OverrideRunNumber = True
534  flags.Input.LumiBlockNumbers = [1] # dummy value
535 
536 
538  """MC23 flags for simulation of special run 460348"""
539  MC23SimulationNoIoV(flags)
540  flags.Input.MCCampaign = Campaign.MC23d
541 
542  flags.Input.RunNumbers = [465000]
543  flags.Input.OverrideRunNumber = True
544  flags.Input.LumiBlockNumber = [1] # dummy value
545 
546  # B-field configuration
547  flags.BField.configuredSolenoidFieldScale = 0.4
548 
549 
551  """MC23 flags for simulation"""
552  MC23SimulationNoIoV(flags)
553  flags.Input.MCCampaign = Campaign.MC23a
554 
555  flags.Input.RunNumbers = [410000]
556  flags.Input.OverrideRunNumber = True
557  flags.Input.LumiBlockNumbers = [1] # dummy value
558 
559 
561  """MC23 flags for simulation"""
562  MC23SimulationNoIoV(flags)
563  flags.Input.MCCampaign = Campaign.MC23a
564 
565  flags.Input.OverrideRunNumber = True
566 
567  from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
569  profile='RunDependentSimData.PileUpProfile_run410000_MC23a_MultiBeamspot')
570 
571 
573  """MC23 flags for simulation"""
574  MC23SimulationNoIoV(flags)
575  flags.Input.MCCampaign = Campaign.MC23c
576 
577  flags.Input.OverrideRunNumber = True
578 
579  from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
581  profile='RunDependentSimData.PileUpProfile_run450000_MC23c_MultiBeamspot')
582 
583 
585  """MC23 flags for simulation"""
586  MC23SimulationNoIoV(flags)
587  flags.Input.MCCampaign = Campaign.MC23e
588 
589  flags.Input.OverrideRunNumber = True
590 
591  from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
593  profile='RunDependentSimData.PileUpProfile_run470000_MC23e_MultiBeamspot')
594 
595 
597  """MC23 flags for simulation"""
598  MC23SimulationNoIoV(flags)
599  flags.Input.MCCampaign = Campaign.MC23g
600 
601  flags.Input.OverrideRunNumber = True
602 
603  from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
604  # TODO: replace with the actual profile
606  profile='RunDependentSimData.PileUpProfile_run470000_MC23e_MultiBeamspot')
607 
608 
610  """MC23 flags for simulation with CalibrationHits"""
612  from SimuJobTransforms import CalHits, ParticleID
613  CalHits(flags)
614  ParticleID(flags)
615 
616 
618  """MC23 flags for simulation with CalibrationHits"""
620  from SimuJobTransforms import CalHits, ParticleID
621  CalHits(flags)
622  ParticleID(flags)
623 
624 
626  """MC23 flags for simulation with CalibrationHits"""
628  from SimuJobTransforms import CalHits, ParticleID
629  CalHits(flags)
630  ParticleID(flags)
631 
632 
634  """MC23e flags for simulation with CalibrationHits"""
636  from SimuJobTransforms import CalHits, ParticleID
637  CalHits(flags)
638  ParticleID(flags)
639 
640 
642  """MC23g flags for simulation with CalibrationHits"""
644  from SimuJobTransforms import CalHits, ParticleID
645  CalHits(flags)
646  ParticleID(flags)
python.MC23.MC23Simulation2025OORun
def MC23Simulation2025OORun(flags)
Definition: MC23.py:527
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:366
python.MC23.MC23cSimulationMultipleIoV
def MC23cSimulationMultipleIoV(flags)
Definition: MC23.py:572
python.MC23.MC23aSingleBeamspot
def MC23aSingleBeamspot(flags)
Definition: MC23.py:290
python.MC23.MC23Simulation2023HeavyIonRun
def MC23Simulation2023HeavyIonRun(flags)
Definition: MC23.py:498
python.MC23.MC23NoPileUpLowMuRun
def MC23NoPileUpLowMuRun(flags)
Definition: MC23.py:399
python.LArConfigRun3.LArConfigRun3NoPileUp
def LArConfigRun3NoPileUp(flags)
Definition: LArConfigRun3.py:13
python.MC23.MC23cSimulationMultipleIoVCalibrationHits
def MC23cSimulationMultipleIoVCalibrationHits(flags)
Definition: MC23.py:625
python.MC23.MC23dSimulationLowMuLowB
def MC23dSimulationLowMuLowB(flags)
Definition: MC23.py:537
python.MC23.MC23dNoPileUp
def MC23dNoPileUp(flags)
Definition: MC23.py:374
python.MC23.MC23SimulationSingleIoV
def MC23SimulationSingleIoV(flags)
Definition: MC23.py:550
python.MC23.MC23eSimulationMultipleIoVCalibrationHits
def MC23eSimulationMultipleIoVCalibrationHits(flags)
Definition: MC23.py:633
python.LArConfigRun3.LArConfigRun3PileUp
def LArConfigRun3PileUp(flags)
Definition: LArConfigRun3.py:3
python.MC23.MC23Simulation2024ppRefRun
def MC23Simulation2024ppRefRun(flags)
Definition: MC23.py:508
python.MC23.MC23eSingleBeamspot
def MC23eSingleBeamspot(flags)
Definition: MC23.py:313
python.MC23.MC23gSimulationMultipleIoV
def MC23gSimulationMultipleIoV(flags)
Definition: MC23.py:596
python.MC23.BeamspotSplitMC23g
def BeamspotSplitMC23g()
Definition: MC23.py:452
python.MC23.MC23Simulation2024HeavyIonRun
def MC23Simulation2024HeavyIonRun(flags)
Definition: MC23.py:518
python.MC23.MC23eNoPileUp
def MC23eNoPileUp(flags)
Definition: MC23.py:382
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:489
python.MC23.BeamspotSplitMC23a
def BeamspotSplitMC23a()
Definition: MC23.py:418
python.MC23.MC23eSimulationMultipleIoV
def MC23eSimulationMultipleIoV(flags)
Definition: MC23.py:584
python.MC23.BeamspotSplitMC23g_VALIDATION
def BeamspotSplitMC23g_VALIDATION()
Definition: MC23.py:460
python.MC23.MC23gSimulationMultipleIoVCalibrationHits
def MC23gSimulationMultipleIoVCalibrationHits(flags)
Definition: MC23.py:641
python.MC23.MC23gSingleBeamspot
def MC23gSingleBeamspot(flags)
Definition: MC23.py:320
python.MC23._MC23NoPileUp
def _MC23NoPileUp(flags)
Definition: MC23.py:354
python.MC23.BeamspotSplitMC23e
def BeamspotSplitMC23e()
Definition: MC23.py:444
python.MC23.MC23LowMu
def MC23LowMu(flags)
Definition: MC23.py:329
python.G4Optimizations.enableFrozenShowersFCalOnly
def enableFrozenShowersFCalOnly(flags)
Definition: G4Optimizations.py:5
python.MC23.MC23aSimulationMultipleIoV
def MC23aSimulationMultipleIoV(flags)
Definition: MC23.py:560
python.MC23.MC23dSingleBeamspot
def MC23dSingleBeamspot(flags)
Definition: MC23.py:306
python.MC23.MC23SimulationNoIoV
def MC23SimulationNoIoV(flags)
Definition: MC23.py:467
python.MC23.BeamspotSplitMC23d
def BeamspotSplitMC23d()
Definition: MC23.py:434
python.MC23.MC23HeavyIons2024NoPileUp
def MC23HeavyIons2024NoPileUp(flags)
Definition: MC23.py:203
python.MC23.BeamspotSplitMC23c
def BeamspotSplitMC23c()
Definition: MC23.py:426
python.MC23.MC23SimulationSingleIoVCalibrationHits
def MC23SimulationSingleIoVCalibrationHits(flags)
Definition: MC23.py:609
python.MC23.MC23HeavyIons2024
def MC23HeavyIons2024(flags)
Definition: MC23.py:227
python.MC23.MC23cSingleBeamspot
def MC23cSingleBeamspot(flags)
Definition: MC23.py:298
python.MC23.MC23HeavyIons2025OO
def MC23HeavyIons2025OO(flags)
Definition: MC23.py:258
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:617
python.MC23.MC23gNoPileUp
def MC23gNoPileUp(flags)
Definition: MC23.py:390
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:407
python.MC23.MC23HeavyIons2023
def MC23HeavyIons2023(flags)
Definition: MC23.py:100