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 
257  """MC23a flags for MC to match 2022 Run 3 data (single beamspot version)"""
258  MC23a(flags)
259 
260  # override only pile-up profile
261  flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run410000_MC23a_SingleBeamspot'
262 
263 
265  """MC23c flags for MC to match 2023 Run 3 data (initial pile-up profile estimate, single beamspot version)"""
266  MC23c(flags)
267 
268  # override only pile-up profile
269  flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run450000_MC23c_SingleBeamspot'
270 
271 
273  """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)"""
274  MC23d(flags)
275 
276  # override only pile-up profile
277  flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run450000_MC23d_SingleBeamspot'
278 
280  """MC23e flags for MC to match 2024 Run 3 data (initial pile-up profile estimate, single beamspot version)"""
281  MC23e(flags)
282 
283  # override only pile-up profile
284  flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run470000_MC23e_SingleBeamspot'
285 
287  """MC23g flags for MC to match 2025 Run 3 data (initial pile-up profile estimate, single beamspot version)"""
288  MC23g(flags)
289 
290  # override only pile-up profile
291  # TODO: replace with the actual profile
292  flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run470000_MC23e_SingleBeamspot'
293 
294 
295 def MC23LowMu(flags):
296  """MC23 flags for MC to match Run 3 data with low pile-up"""
297  flags.Input.MCCampaign = Campaign.MC23a
298 
299  flags.Beam.NumberOfCollisions = 60.
300  flags.Input.ConditionsRunNumber = 410000
301 
302  from LArConfiguration.LArConfigRun3 import LArConfigRun3PileUp
303  LArConfigRun3PileUp(flags)
304 
305  # radiation damage
306  from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
307  flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
308 
309  # pile-up
310  # These numbers are based upon a relative XS scaling of the high-pt slice
311  # of 64%, which leads to a relative high-pt / low-pt sampling of
312  # 0.001953314389 / 0.9980466856. Those numbers are then multiplied by 0.05
313  # to simulate low pile-up. Only a relevant number of significant digits
314  # are kept.
315  flags.Digitization.PU.NumberOfLowPtMinBias = 0.0499
316  flags.Digitization.PU.NumberOfHighPtMinBias = 0.0001
317  flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructure_Fill7314_BCMSPattern_Flat'
318 
319 
320 def _MC23NoPileUp(flags):
321  """MC23 flags for MC without pile-up"""
322  flags.Beam.NumberOfCollisions = 0.
323 
324  from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
325  LArConfigRun3NoPileUp(flags)
326 
327  # radiation damage
328  from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
329  flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
330 
331 
332 def MC23aNoPileUp(flags):
333  """MC23a flags for MC without pile-up"""
334  _MC23NoPileUp(flags)
335 
336  flags.Input.MCCampaign = Campaign.MC23a
337  flags.Input.ConditionsRunNumber = 410000
338 
339 
340 def MC23dNoPileUp(flags):
341  """MC23d flags for MC without pile-up"""
342  _MC23NoPileUp(flags)
343 
344  flags.Input.MCCampaign = Campaign.MC23d
345  flags.Input.ConditionsRunNumber = 450000
346 
347 
348 def MC23eNoPileUp(flags):
349  """MC23e flags for MC without pile-up"""
350  _MC23NoPileUp(flags)
351 
352  flags.Input.MCCampaign = Campaign.MC23e
353  flags.Input.ConditionsRunNumber = 470000
354 
355 
356 def MC23gNoPileUp(flags):
357  """MC23g flags for MC without pile-up"""
358  _MC23NoPileUp(flags)
359 
360  flags.Input.MCCampaign = Campaign.MC23g
361  # TODO: replace with the actual run number
362  flags.Input.ConditionsRunNumber = 470000
363 
364 
366  """MC23a flags for MC to match 2002 Low Mu data"""
367  _MC23NoPileUp(flags)
368 
369  flags.Input.MCCampaign = Campaign.MC23a
370  flags.Input.ConditionsRunNumber = 420000
371 
372 
374  """MC23d flags for MC to match special run 460348"""
375  _MC23NoPileUp(flags)
376 
377  flags.Input.MCCampaign = Campaign.MC23d
378  flags.Input.ConditionsRunNumber = 465000
379 
380  # B-field configuration
381  flags.BField.configuredSolenoidFieldScale = 0.4
382 
383 
385  """MC23a beamspot splitting configuration"""
386  substeps = 4
387  event_fractions = [0.14, 0.14, 0.14, 0.58]
388 
389  return substeps, event_fractions
390 
391 
393  """MC23c beamspot splitting configuration"""
394  substeps = 4
395  event_fractions = [0.22, 0.22, 0.22, 0.34]
396 
397  return substeps, event_fractions
398 
399 
401  """MC23d beamspot splitting configuration, matches MC23c, but only the
402  first two substep are considered levelling rather than the first
403  three."""
404  substeps = 4
405  event_fractions = [0.22, 0.22, 0.22, 0.34]
406 
407  return substeps, event_fractions
408 
409 
411  """MC23e beamspot splitting configuration."""
412  substeps = 4
413  event_fractions = [0.22, 0.22, 0.22, 0.34]
414 
415  return substeps, event_fractions
416 
417 
419  """MC23g beamspot splitting configuration."""
420  substeps = 4
421  event_fractions = [0.22, 0.22, 0.22, 0.34]
422 
423  return substeps, event_fractions
424 
425 
427  """MC23 base flags for simulation without specifying conditions IoVs"""
428  flags.Input.MCCampaign = Campaign.MC23a
429 
430  from SimulationConfig.SimEnums import TruthStrategy
431  flags.Sim.PhysicsList = 'FTFP_BERT_ATL'
432  flags.Sim.TruthStrategy = TruthStrategy.MC15aPlus
433 
434  flags.Sim.TRTRangeCut = 30.0
435  flags.Sim.TightMuonStepping = True
436 
437  from SimulationConfig.G4Optimizations import enableBeamPipeKill, enableFrozenShowersFCalOnly
438  enableBeamPipeKill(flags)
439  if flags.Sim.ISF.Simulator.isFullSim():
441 
442  from SimulationConfig.G4Optimizations import enableG4Optimizations
443  enableG4Optimizations(flags)
444 
445  flags.Sim.FastCalo.ParamsInputFilename = 'FastCaloSim/MC23/TFCSparam_dev_Hybrid_Ha_v5_all_baryons_0_500.root'
446 
447 
449  """MC23 flags for low mu run simulation"""
450  MC23SimulationNoIoV(flags)
451 
452  flags.Input.RunNumbers = [420000]
453  flags.Input.OverrideRunNumber = True
454  flags.Input.LumiBlockNumbers = [1] # dummy value
455 
456 
458  """MC23 flags for simulation simulation of the 2023 Heavy Ion run"""
459  MC23SimulationNoIoV(flags)
460  flags.Input.MCCampaign = Campaign.MC23d
461 
462  flags.Input.RunNumbers = [460000]
463  flags.Input.OverrideRunNumber = True
464  flags.Input.LumiBlockNumbers = [1] # dummy value
465 
466 
468  """MC23 flags for simulation simulation of the 2024 5.36 TeV pp reference run"""
469  MC23SimulationNoIoV(flags)
470  flags.Input.MCCampaign = Campaign.MC23e
471 
472  flags.Input.RunNumbers = [488000]
473  flags.Input.OverrideRunNumber = True
474  flags.Input.LumiBlockNumbers = [1] # dummy value
475 
476 
478  """MC23 flags for simulation simulation of the 2024 Heavy Ion run"""
479  MC23SimulationNoIoV(flags)
480  flags.Input.MCCampaign = Campaign.MC23e
481 
482  flags.Input.RunNumbers = [488600]
483  flags.Input.OverrideRunNumber = True
484  flags.Input.LumiBlockNumbers = [1] # dummy value
485 
486 
488  """MC23 flags for simulation of special run 460348"""
489  MC23SimulationNoIoV(flags)
490  flags.Input.MCCampaign = Campaign.MC23d
491 
492  flags.Input.RunNumbers = [465000]
493  flags.Input.OverrideRunNumber = True
494  flags.Input.LumiBlockNumber = [1] # dummy value
495 
496  # B-field configuration
497  flags.BField.configuredSolenoidFieldScale = 0.4
498 
499 
501  """MC23 flags for simulation"""
502  MC23SimulationNoIoV(flags)
503  flags.Input.MCCampaign = Campaign.MC23a
504 
505  flags.Input.RunNumbers = [410000]
506  flags.Input.OverrideRunNumber = True
507  flags.Input.LumiBlockNumbers = [1] # dummy value
508 
509 
511  """MC23 flags for simulation"""
512  MC23SimulationNoIoV(flags)
513  flags.Input.MCCampaign = Campaign.MC23a
514 
515  flags.Input.OverrideRunNumber = True
516 
517  from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
519  profile='RunDependentSimData.PileUpProfile_run410000_MC23a_MultiBeamspot')
520 
521 
523  """MC23 flags for simulation"""
524  MC23SimulationNoIoV(flags)
525  flags.Input.MCCampaign = Campaign.MC23c
526 
527  flags.Input.OverrideRunNumber = True
528 
529  from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
531  profile='RunDependentSimData.PileUpProfile_run450000_MC23c_MultiBeamspot')
532 
533 
535  """MC23 flags for simulation"""
536  MC23SimulationNoIoV(flags)
537  flags.Input.MCCampaign = Campaign.MC23e
538 
539  flags.Input.OverrideRunNumber = True
540 
541  from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
543  profile='RunDependentSimData.PileUpProfile_run470000_MC23e_MultiBeamspot')
544 
545 
547  """MC23 flags for simulation"""
548  MC23SimulationNoIoV(flags)
549  flags.Input.MCCampaign = Campaign.MC23g
550 
551  flags.Input.OverrideRunNumber = True
552 
553  from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
554  # TODO: replace with the actual profile
556  profile='RunDependentSimData.PileUpProfile_run470000_MC23e_MultiBeamspot')
557 
558 
560  """MC23 flags for simulation with CalibrationHits"""
562  from SimuJobTransforms import CalHits, ParticleID
563  CalHits(flags)
564  ParticleID(flags)
565 
566 
568  """MC23 flags for simulation with CalibrationHits"""
570  from SimuJobTransforms import CalHits, ParticleID
571  CalHits(flags)
572  ParticleID(flags)
573 
574 
576  """MC23 flags for simulation with CalibrationHits"""
578  from SimuJobTransforms import CalHits, ParticleID
579  CalHits(flags)
580  ParticleID(flags)
581 
582 
584  """MC23e flags for simulation with CalibrationHits"""
586  from SimuJobTransforms import CalHits, ParticleID
587  CalHits(flags)
588  ParticleID(flags)
589 
590 
592  """MC23g flags for simulation with CalibrationHits"""
594  from SimuJobTransforms import CalHits, ParticleID
595  CalHits(flags)
596  ParticleID(flags)
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:332
python.MC23.MC23cSimulationMultipleIoV
def MC23cSimulationMultipleIoV(flags)
Definition: MC23.py:522
python.MC23.MC23aSingleBeamspot
def MC23aSingleBeamspot(flags)
Definition: MC23.py:256
python.MC23.MC23Simulation2023HeavyIonRun
def MC23Simulation2023HeavyIonRun(flags)
Definition: MC23.py:457
python.MC23.MC23NoPileUpLowMuRun
def MC23NoPileUpLowMuRun(flags)
Definition: MC23.py:365
python.LArConfigRun3.LArConfigRun3NoPileUp
def LArConfigRun3NoPileUp(flags)
Definition: LArConfigRun3.py:13
python.MC23.MC23cSimulationMultipleIoVCalibrationHits
def MC23cSimulationMultipleIoVCalibrationHits(flags)
Definition: MC23.py:575
python.MC23.MC23dSimulationLowMuLowB
def MC23dSimulationLowMuLowB(flags)
Definition: MC23.py:487
python.MC23.MC23dNoPileUp
def MC23dNoPileUp(flags)
Definition: MC23.py:340
python.MC23.MC23SimulationSingleIoV
def MC23SimulationSingleIoV(flags)
Definition: MC23.py:500
python.MC23.MC23eSimulationMultipleIoVCalibrationHits
def MC23eSimulationMultipleIoVCalibrationHits(flags)
Definition: MC23.py:583
python.LArConfigRun3.LArConfigRun3PileUp
def LArConfigRun3PileUp(flags)
Definition: LArConfigRun3.py:3
python.MC23.MC23Simulation2024ppRefRun
def MC23Simulation2024ppRefRun(flags)
Definition: MC23.py:467
python.MC23.MC23eSingleBeamspot
def MC23eSingleBeamspot(flags)
Definition: MC23.py:279
python.MC23.MC23gSimulationMultipleIoV
def MC23gSimulationMultipleIoV(flags)
Definition: MC23.py:546
python.MC23.BeamspotSplitMC23g
def BeamspotSplitMC23g()
Definition: MC23.py:418
python.MC23.MC23Simulation2024HeavyIonRun
def MC23Simulation2024HeavyIonRun(flags)
Definition: MC23.py:477
python.MC23.MC23eNoPileUp
def MC23eNoPileUp(flags)
Definition: MC23.py:348
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:448
python.MC23.BeamspotSplitMC23a
def BeamspotSplitMC23a()
Definition: MC23.py:384
python.MC23.MC23eSimulationMultipleIoV
def MC23eSimulationMultipleIoV(flags)
Definition: MC23.py:534
python.MC23.MC23gSimulationMultipleIoVCalibrationHits
def MC23gSimulationMultipleIoVCalibrationHits(flags)
Definition: MC23.py:591
python.MC23.MC23gSingleBeamspot
def MC23gSingleBeamspot(flags)
Definition: MC23.py:286
python.MC23._MC23NoPileUp
def _MC23NoPileUp(flags)
Definition: MC23.py:320
python.MC23.BeamspotSplitMC23e
def BeamspotSplitMC23e()
Definition: MC23.py:410
python.MC23.MC23LowMu
def MC23LowMu(flags)
Definition: MC23.py:295
python.G4Optimizations.enableFrozenShowersFCalOnly
def enableFrozenShowersFCalOnly(flags)
Definition: G4Optimizations.py:5
python.MC23.MC23aSimulationMultipleIoV
def MC23aSimulationMultipleIoV(flags)
Definition: MC23.py:510
python.MC23.MC23dSingleBeamspot
def MC23dSingleBeamspot(flags)
Definition: MC23.py:272
python.MC23.MC23SimulationNoIoV
def MC23SimulationNoIoV(flags)
Definition: MC23.py:426
python.MC23.BeamspotSplitMC23d
def BeamspotSplitMC23d()
Definition: MC23.py:400
python.MC23.MC23HeavyIons2024NoPileUp
def MC23HeavyIons2024NoPileUp(flags)
Definition: MC23.py:201
python.MC23.BeamspotSplitMC23c
def BeamspotSplitMC23c()
Definition: MC23.py:392
python.MC23.MC23SimulationSingleIoVCalibrationHits
def MC23SimulationSingleIoVCalibrationHits(flags)
Definition: MC23.py:559
python.MC23.MC23HeavyIons2024
def MC23HeavyIons2024(flags)
Definition: MC23.py:225
python.MC23.MC23cSingleBeamspot
def MC23cSingleBeamspot(flags)
Definition: MC23.py:264
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:567
python.MC23.MC23gNoPileUp
def MC23gNoPileUp(flags)
Definition: MC23.py:356
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:373
python.MC23.MC23HeavyIons2023
def MC23HeavyIons2023(flags)
Definition: MC23.py:100