ATLAS Offline Software
Loading...
Searching...
No Matches
Functions
python.MC23 Namespace Reference

Functions

 _MC23PileUp (flags)
 MC23a (flags)
 MC23c (flags)
 MC23d (flags)
 MC23HeavyIons2023NoPileUp (flags)
 MC23HeavyIons2023 (flags)
 MC23e (flags)
 MC23g (flags)
 MC23ppReferenceRun2024 (flags)
 MC23HeavyIons2024NoPileUp (flags)
 MC23HeavyIons2024 (flags)
 MC23HeavyIons2025OO (flags)
 MC23aSingleBeamspot (flags)
 MC23cSingleBeamspot (flags)
 MC23dSingleBeamspot (flags)
 MC23eSingleBeamspot (flags)
 MC23gSingleBeamspot (flags)
 MC23LowMu (flags)
 _MC23NoPileUp (flags)
 MC23aNoPileUp (flags)
 MC23dNoPileUp (flags)
 MC23eNoPileUp (flags)
 MC23gNoPileUp (flags)
 MC23NoPileUpLowMuRun (flags)
 MC23NoPileUpLowMuLowB (flags)
 BeamspotSplitMC23a ()
 BeamspotSplitMC23c ()
 BeamspotSplitMC23d ()
 BeamspotSplitMC23e ()
 BeamspotSplitMC23g ()
 MC23SimulationNoIoV (flags)
 MC23SimulationLowMuRun (flags)
 MC23Simulation2023HeavyIonRun (flags)
 MC23Simulation2024ppRefRun (flags)
 MC23Simulation2024HeavyIonRun (flags)
 MC23Simulation2025OORun (flags)
 MC23dSimulationLowMuLowB (flags)
 MC23SimulationSingleIoV (flags)
 MC23aSimulationMultipleIoV (flags)
 MC23cSimulationMultipleIoV (flags)
 MC23eSimulationMultipleIoV (flags)
 MC23gSimulationMultipleIoV (flags)
 MC23SimulationSingleIoVCalibrationHits (flags)
 MC23aSimulationMultipleIoVCalibrationHits (flags)
 MC23cSimulationMultipleIoVCalibrationHits (flags)
 MC23eSimulationMultipleIoVCalibrationHits (flags)
 MC23gSimulationMultipleIoVCalibrationHits (flags)

Function Documentation

◆ _MC23NoPileUp()

python.MC23._MC23NoPileUp ( flags)
protected 
Configure MC23 flags for Monte Carlo simulations without pile-up.
This method is used in the Digi-Reco step only.

Definition at line 354 of file MC23.py.

354def _MC23NoPileUp(flags):
355 """
356 Configure MC23 flags for Monte Carlo simulations without pile-up.
357 This method is used in the Digi-Reco step only.
358 """
359 flags.Beam.NumberOfCollisions = 0.
360
361 from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
362 LArConfigRun3NoPileUp(flags)
363
364 # radiation damage
365 from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
366 flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
367
368

◆ _MC23PileUp()

python.MC23._MC23PileUp ( flags)
protected 
MC23 flags for MC with pile-up

Definition at line 6 of file MC23.py.

6def _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

◆ BeamspotSplitMC23a()

python.MC23.BeamspotSplitMC23a ( ) 
MC23a beamspot splitting configuration

Definition at line 438 of file MC23.py.

438def BeamspotSplitMC23a():
439 """MC23a beamspot splitting configuration"""
440 substeps = 4
441 event_fractions = [0.14, 0.14, 0.14, 0.58]
442
443 return substeps, event_fractions
444
445

◆ BeamspotSplitMC23c()

python.MC23.BeamspotSplitMC23c ( ) 
MC23c beamspot splitting configuration

Definition at line 446 of file MC23.py.

446def BeamspotSplitMC23c():
447 """MC23c beamspot splitting configuration"""
448 substeps = 4
449 event_fractions = [0.22, 0.22, 0.22, 0.34]
450
451 return substeps, event_fractions
452
453

◆ BeamspotSplitMC23d()

python.MC23.BeamspotSplitMC23d ( ) 
MC23d beamspot splitting configuration, matches MC23c, but only the
first two substep are considered levelling rather than the first
three.

Definition at line 454 of file MC23.py.

454def BeamspotSplitMC23d():
455 """MC23d beamspot splitting configuration, matches MC23c, but only the
456 first two substep are considered levelling rather than the first
457 three."""
458 substeps = 4
459 event_fractions = [0.22, 0.22, 0.22, 0.34]
460
461 return substeps, event_fractions
462
463

◆ BeamspotSplitMC23e()

python.MC23.BeamspotSplitMC23e ( ) 
MC23e beamspot splitting configuration.

Definition at line 464 of file MC23.py.

464def BeamspotSplitMC23e():
465 """MC23e beamspot splitting configuration."""
466 substeps = 4
467 event_fractions = [0.22, 0.22, 0.22, 0.34]
468
469 return substeps, event_fractions
470
471

◆ BeamspotSplitMC23g()

python.MC23.BeamspotSplitMC23g ( ) 
MC23g beamspot splitting configuration.

Definition at line 472 of file MC23.py.

472def BeamspotSplitMC23g():
473 """MC23g beamspot splitting configuration."""
474 substeps = 4
475 event_fractions = [0.3, 0.42, 0.08, 0.2]
476
477 return substeps, event_fractions
478
479

◆ MC23a()

python.MC23.MC23a ( flags) 
MC23a flags for MC to match 2022 Run 3 data

Definition at line 22 of file MC23.py.

22def 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

◆ MC23aNoPileUp()

python.MC23.MC23aNoPileUp ( flags) 
Configure MC23a flags for Monte Carlo simulations without pile-up.
This method is used in the Digi-Reco step only.

Definition at line 369 of file MC23.py.

369def MC23aNoPileUp(flags):
370 """
371 Configure MC23a flags for Monte Carlo simulations without pile-up.
372 This method is used in the Digi-Reco step only.
373 """
374 _MC23NoPileUp(flags)
375
376 flags.Input.MCCampaign = Campaign.MC23a
377 flags.Input.ConditionsRunNumber = 410000
378
379

◆ MC23aSimulationMultipleIoV()

python.MC23.MC23aSimulationMultipleIoV ( flags) 
Configure MC23a flags for simulation with multiple Intervals of Validity (IoV).
This method is used in the Simulation step only.

Definition at line 573 of file MC23.py.

573def MC23aSimulationMultipleIoV(flags):
574 """
575 Configure MC23a flags for simulation with multiple Intervals of Validity (IoV).
576 This method is used in the Simulation step only.
577 """
578 MC23SimulationNoIoV(flags)
579 flags.Input.MCCampaign = Campaign.MC23a
580
581 flags.Input.OverrideRunNumber = True
582
583 from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
584 generateRunAndLumiProfile(flags,
585 profile='RunDependentSimData.PileUpProfile_run410000_MC23a_MultiBeamspot')
586
587

◆ MC23aSimulationMultipleIoVCalibrationHits()

python.MC23.MC23aSimulationMultipleIoVCalibrationHits ( flags) 
MC23 flags for simulation with CalibrationHits

Definition at line 642 of file MC23.py.

642def MC23aSimulationMultipleIoVCalibrationHits(flags):
643 """MC23 flags for simulation with CalibrationHits"""
644 MC23aSimulationMultipleIoV(flags)
645 from SimuJobTransforms import CalHits, ParticleID
646 CalHits(flags)
647 ParticleID(flags)
648
649

◆ MC23aSingleBeamspot()

python.MC23.MC23aSingleBeamspot ( flags) 
MC23a flags for MC to match 2022 Run 3 data (single beamspot version)

Definition at line 291 of file MC23.py.

291def MC23aSingleBeamspot(flags):
292 """MC23a flags for MC to match 2022 Run 3 data (single beamspot version)"""
293 MC23a(flags)
294
295 # override only pile-up profile
296 flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run410000_MC23a_SingleBeamspot'
297
298

◆ MC23c()

python.MC23.MC23c ( flags) 
MC23c flags for MC to match 2023 Run 3 data (initial pile-up profile estimate)

Definition at line 40 of file MC23.py.

40def 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

◆ MC23cSimulationMultipleIoV()

python.MC23.MC23cSimulationMultipleIoV ( flags) 
Configure MC23c flags for simulation with multiple Intervals of Validity (IoV).
This method is used in the Simulation step only.

Definition at line 588 of file MC23.py.

588def MC23cSimulationMultipleIoV(flags):
589 """
590 Configure MC23c flags for simulation with multiple Intervals of Validity (IoV).
591 This method is used in the Simulation step only.
592 """
593 MC23SimulationNoIoV(flags)
594 flags.Input.MCCampaign = Campaign.MC23c
595
596 flags.Input.OverrideRunNumber = True
597
598 from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
599 generateRunAndLumiProfile(flags,
600 profile='RunDependentSimData.PileUpProfile_run450000_MC23c_MultiBeamspot')
601
602

◆ MC23cSimulationMultipleIoVCalibrationHits()

python.MC23.MC23cSimulationMultipleIoVCalibrationHits ( flags) 
MC23 flags for simulation with CalibrationHits

Definition at line 650 of file MC23.py.

650def MC23cSimulationMultipleIoVCalibrationHits(flags):
651 """MC23 flags for simulation with CalibrationHits"""
652 MC23cSimulationMultipleIoV(flags)
653 from SimuJobTransforms import CalHits, ParticleID
654 CalHits(flags)
655 ParticleID(flags)
656
657

◆ MC23cSingleBeamspot()

python.MC23.MC23cSingleBeamspot ( flags) 
MC23c flags for MC to match 2023 Run 3 data (initial pile-up profile estimate, single beamspot version)

Definition at line 299 of file MC23.py.

299def MC23cSingleBeamspot(flags):
300 """MC23c flags for MC to match 2023 Run 3 data (initial pile-up profile estimate, single beamspot version)"""
301 MC23c(flags)
302
303 # override only pile-up profile
304 flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run450000_MC23c_SingleBeamspot'
305
306

◆ MC23d()

python.MC23.MC23d ( flags) 
MC23d flags for MC to match 2023 Run 3 data (uses a pile-up profile based on the actual profile from 2023 data)

Definition at line 58 of file MC23.py.

58def 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

◆ MC23dNoPileUp()

python.MC23.MC23dNoPileUp ( flags) 
Configure MC23d flags for Monte Carlo simulations without pile-up.
This method is used in the Digi-Reco step only.

Definition at line 380 of file MC23.py.

380def MC23dNoPileUp(flags):
381 """
382 Configure MC23d flags for Monte Carlo simulations without pile-up.
383 This method is used in the Digi-Reco step only.
384 """
385 _MC23NoPileUp(flags)
386
387 flags.Input.MCCampaign = Campaign.MC23d
388 flags.Input.ConditionsRunNumber = 450000
389
390

◆ MC23dSimulationLowMuLowB()

python.MC23.MC23dSimulationLowMuLowB ( flags) 
MC23 flags for simulation of special run 460348

Definition at line 550 of file MC23.py.

550def MC23dSimulationLowMuLowB(flags):
551 """MC23 flags for simulation of special run 460348"""
552 MC23SimulationNoIoV(flags)
553 flags.Input.MCCampaign = Campaign.MC23d
554
555 flags.Input.RunNumbers = [465000]
556 flags.Input.OverrideRunNumber = True
557 flags.Input.LumiBlockNumber = [1] # dummy value
558
559 # B-field configuration
560 flags.BField.configuredSolenoidFieldScale = 0.4
561
562

◆ MC23dSingleBeamspot()

python.MC23.MC23dSingleBeamspot ( flags) 
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)

Definition at line 307 of file MC23.py.

307def MC23dSingleBeamspot(flags):
308 """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)"""
309 MC23d(flags)
310
311 # override only pile-up profile
312 flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run450000_MC23d_SingleBeamspot'
313

◆ MC23e()

python.MC23.MC23e ( flags) 
MC23e flags for MC to match 2024 Run 3 data (initial pile-up estimate based on broadened 2023 data )

Definition at line 131 of file MC23.py.

131def 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

◆ MC23eNoPileUp()

python.MC23.MC23eNoPileUp ( flags) 
Configure MC23e flags for Monte Carlo simulations without pile-up.
This method is used in the Digi-Reco step only.

Definition at line 391 of file MC23.py.

391def MC23eNoPileUp(flags):
392 """
393 Configure MC23e flags for Monte Carlo simulations without pile-up.
394 This method is used in the Digi-Reco step only.
395 """
396 _MC23NoPileUp(flags)
397
398 flags.Input.MCCampaign = Campaign.MC23e
399 flags.Input.ConditionsRunNumber = 470000
400
401

◆ MC23eSimulationMultipleIoV()

python.MC23.MC23eSimulationMultipleIoV ( flags) 
Configure MC23e flags for simulation with multiple Intervals of Validity (IoV).
This method is used in the Simulation step only.

Definition at line 603 of file MC23.py.

603def MC23eSimulationMultipleIoV(flags):
604 """
605 Configure MC23e flags for simulation with multiple Intervals of Validity (IoV).
606 This method is used in the Simulation step only.
607 """
608 MC23SimulationNoIoV(flags)
609 flags.Input.MCCampaign = Campaign.MC23e
610
611 flags.Input.OverrideRunNumber = True
612
613 from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
614 generateRunAndLumiProfile(flags,
615 profile='RunDependentSimData.PileUpProfile_run470000_MC23e_MultiBeamspot')
616
617

◆ MC23eSimulationMultipleIoVCalibrationHits()

python.MC23.MC23eSimulationMultipleIoVCalibrationHits ( flags) 
MC23e flags for simulation with CalibrationHits

Definition at line 658 of file MC23.py.

658def MC23eSimulationMultipleIoVCalibrationHits(flags):
659 """MC23e flags for simulation with CalibrationHits"""
660 MC23eSimulationMultipleIoV(flags)
661 from SimuJobTransforms import CalHits, ParticleID
662 CalHits(flags)
663 ParticleID(flags)
664
665

◆ MC23eSingleBeamspot()

python.MC23.MC23eSingleBeamspot ( flags) 
MC23e flags for MC to match 2024 Run 3 data (initial pile-up profile estimate, single beamspot version)

Definition at line 314 of file MC23.py.

314def MC23eSingleBeamspot(flags):
315 """MC23e flags for MC to match 2024 Run 3 data (initial pile-up profile estimate, single beamspot version)"""
316 MC23e(flags)
317
318 # override only pile-up profile
319 flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run470000_MC23e_SingleBeamspot'
320

◆ MC23g()

python.MC23.MC23g ( flags) 
MC23g flags for MC to match 2025 Run 3 data (initial pile-up estimate based on broadened 2024 data )

Definition at line 150 of file MC23.py.

150def 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 99.5
160 # to follow pile-up profile. Only a relevant number of significant digits
161 # are kept.
162 flags.Digitization.PU.NumberOfLowPtMinBias = 99.306
163 flags.Digitization.PU.NumberOfHighPtMinBias = 0.194
164 # TODO new bunch structure?
165 flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructure_Fill7314_BCMSPattern_Flat'
166
167 # NB: This is the pileup profile that is used in the Digi+Reco step
168 flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run495000_MC23g_MultiBeamspot'
169
170

◆ MC23gNoPileUp()

python.MC23.MC23gNoPileUp ( flags) 
Configure MC23g flags for Monte Carlo simulations without pile-up.
This method is used in the Digi-Reco step only.

Definition at line 402 of file MC23.py.

402def MC23gNoPileUp(flags):
403 """
404 Configure MC23g flags for Monte Carlo simulations without pile-up.
405 This method is used in the Digi-Reco step only.
406 """
407 _MC23NoPileUp(flags)
408
409 flags.Input.MCCampaign = Campaign.MC23g
410 flags.Input.ConditionsRunNumber = 495000
411
412

◆ MC23gSimulationMultipleIoV()

python.MC23.MC23gSimulationMultipleIoV ( flags) 
Configure MC23g flags for simulation with multiple Intervals of Validity (IoV).
This method is used in the Simulation step only.

Definition at line 618 of file MC23.py.

618def MC23gSimulationMultipleIoV(flags):
619 """
620 Configure MC23g flags for simulation with multiple Intervals of Validity (IoV).
621 This method is used in the Simulation step only.
622 """
623 MC23SimulationNoIoV(flags)
624 flags.Input.MCCampaign = Campaign.MC23g
625
626 flags.Input.OverrideRunNumber = True
627
628 from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
629 # NB: This is the pileup profile used in the Simulation step only
630 generateRunAndLumiProfile(flags,
631 profile='RunDependentSimData.PileUpProfile_run495000_MC23g_MultiBeamspot')
632
633

◆ MC23gSimulationMultipleIoVCalibrationHits()

python.MC23.MC23gSimulationMultipleIoVCalibrationHits ( flags) 
MC23g flags for simulation with CalibrationHits

Definition at line 666 of file MC23.py.

666def MC23gSimulationMultipleIoVCalibrationHits(flags):
667 """MC23g flags for simulation with CalibrationHits"""
668 MC23gSimulationMultipleIoV(flags)
669 from SimuJobTransforms import CalHits, ParticleID
670 CalHits(flags)
671 ParticleID(flags)

◆ MC23gSingleBeamspot()

python.MC23.MC23gSingleBeamspot ( flags) 
MC23g flags for MC to match 2025 Run 3 data (initial pile-up profile estimate, single beamspot version)

Definition at line 321 of file MC23.py.

321def MC23gSingleBeamspot(flags):
322 """MC23g flags for MC to match 2025 Run 3 data (initial pile-up profile estimate, single beamspot version)"""
323 MC23g(flags)
324
325 # override only pile-up profile
326 flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run495000_MC23g_SingleBeamspot'
327
328

◆ MC23HeavyIons2023()

python.MC23.MC23HeavyIons2023 ( flags) 
MC23 flags for the 2023 Heavy Ions run

Definition at line 100 of file MC23.py.

100def 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

◆ MC23HeavyIons2023NoPileUp()

python.MC23.MC23HeavyIons2023NoPileUp ( flags) 
MC23 flags for the 2023 Heavy Ions run (without pile-up)

Definition at line 76 of file MC23.py.

76def MC23HeavyIons2023NoPileUp(flags):
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
85 LArConfigRun3NoPileUp(flags)
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

◆ MC23HeavyIons2024()

python.MC23.MC23HeavyIons2024 ( flags) 
MC23 flags for the 2024 Heavy Ions run

Definition at line 228 of file MC23.py.

228def MC23HeavyIons2024(flags): # FIXME This configuration is a placeholder
229 """MC23 flags for the 2024 Heavy Ions run"""
230 flags.Input.MCCampaign = Campaign.MC23e
231
232 flags.Beam.NumberOfCollisions = 0.
233 flags.Input.ConditionsRunNumber = 488600
234
235 from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
236 LArConfigRun3NoPileUp(flags) # TO CHECK is this actually what we want c.f. LArConfigRun3PileUp
237
238 # radiation damage
239 from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
240 flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
241
242 # pile-up
243 flags.Digitization.PileUp = True
244 flags.Digitization.DoXingByXingPileUp = True
245 flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructureHeavyIon2022' # New file being prepared ATLGBLCONDTAGS-182
246 flags.Digitization.PU.InitialBunchCrossing = 0
247 flags.Digitization.PU.FinalBunchCrossing = 0
248 flags.Digitization.PU.NumberOfCavern = 1 # We are using the Cavern Background input for the Hijing HITS-level events
249
250 from HIRecConfig.HIModeFlags import HImode
251 HImode(flags) # TO CHECK is it an issue if this is set for RDOtoRDOTrigger?
252 flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
253
254 #all
255 flags.Trigger.AODEDMSet = 'AODFULL'
256 flags.Trigger.triggerMenuSetup = 'Dev_HI_run3_v1_TriggerValidation_prescale'
257
258

◆ MC23HeavyIons2024NoPileUp()

python.MC23.MC23HeavyIons2024NoPileUp ( flags) 
MC23 flags for the 2024 Heavy Ions run (without pile-up)

Definition at line 204 of file MC23.py.

204def MC23HeavyIons2024NoPileUp(flags): # FIXME This configuration is a placeholder
205 """MC23 flags for the 2024 Heavy Ions run (without pile-up)"""
206 flags.Input.MCCampaign = Campaign.MC23e
207
208 flags.Beam.BunchSpacing = 50
209 flags.Beam.NumberOfCollisions = 0.
210 flags.Input.ConditionsRunNumber = 488600
211
212 from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
213 LArConfigRun3NoPileUp(flags)
214
215 # radiation damage
216 from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
217 flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
218
219 from HIRecConfig.HIModeFlags import HImode
220 HImode(flags) # TO CHECK is it an issue if this is set for RDOtoRDOTrigger?
221 flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
222
223 #all
224 flags.Trigger.AODEDMSet = 'AODFULL'
225 flags.Trigger.triggerMenuSetup = 'Dev_HI_run3_v1_TriggerValidation_prescale'
226
227

◆ MC23HeavyIons2025OO()

python.MC23.MC23HeavyIons2025OO ( flags) 
MC23 flags for the 2025 Heavy Ions (Oxygen) run

Definition at line 259 of file MC23.py.

259def MC23HeavyIons2025OO(flags):
260 """MC23 flags for the 2025 Heavy Ions (Oxygen) run"""
261 flags.Input.MCCampaign = Campaign.MC23g
262
263 flags.Beam.BunchSpacing = 500
264 flags.Beam.NumberOfCollisions = 0.0
265 flags.Input.ConditionsRunNumber = 500700
266
267 from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
268 LArConfigRun3NoPileUp(flags)
269
270 # radiation damage
271 from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
272 flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
273
274 # pile-up
275 flags.Digitization.PileUp = False
276 flags.Digitization.DoXingByXingPileUp = False
277 flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructureHeavyIon2025OO'
278 flags.Digitization.PU.InitialBunchCrossing = 0
279 flags.Digitization.PU.FinalBunchCrossing = 0
280 flags.Digitization.PU.NumberOfCavern = 1 # We are using the Cavern Background input for the Hijing HITS-level events
281
282 from HIRecConfig.HIModeFlags import HIPmode
283 HIPmode(flags)
284 flags.Reco.EnableZDC = False
285
286 #all
287 flags.Trigger.AODEDMSet = 'AODFULL'
288 flags.Trigger.triggerMenuSetup = 'Dev_pp_lowMu_run3_v1_TriggerValidation_prescale'
289
290

◆ MC23LowMu()

python.MC23.MC23LowMu ( flags) 
MC23 flags for MC to match Run 3 data with low pile-up

Definition at line 329 of file MC23.py.

329def 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

◆ MC23NoPileUpLowMuLowB()

python.MC23.MC23NoPileUpLowMuLowB ( flags) 
Configure MC23d flags for Monte Carlo simulations to match special run 460348.
This method is used in the Digi-Reco step only.

Definition at line 424 of file MC23.py.

424def MC23NoPileUpLowMuLowB(flags):
425 """
426 Configure MC23d flags for Monte Carlo simulations to match special run 460348.
427 This method is used in the Digi-Reco step only.
428 """
429 _MC23NoPileUp(flags)
430
431 flags.Input.MCCampaign = Campaign.MC23d
432 flags.Input.ConditionsRunNumber = 465000
433
434 # B-field configuration
435 flags.BField.configuredSolenoidFieldScale = 0.4
436
437

◆ MC23NoPileUpLowMuRun()

python.MC23.MC23NoPileUpLowMuRun ( flags) 
Configure MC23a flags for Monte Carlo simulations to match 2022 Low Mu data.
This method is used in the Digi-Reco step only.

Definition at line 413 of file MC23.py.

413def MC23NoPileUpLowMuRun(flags):
414 """
415 Configure MC23a flags for Monte Carlo simulations to match 2022 Low Mu data.
416 This method is used in the Digi-Reco step only.
417 """
418 _MC23NoPileUp(flags)
419
420 flags.Input.MCCampaign = Campaign.MC23a
421 flags.Input.ConditionsRunNumber = 420000
422
423

◆ MC23ppReferenceRun2024()

python.MC23.MC23ppReferenceRun2024 ( flags) 
MC23 flags for the 2024 5.36 TeV pp reference run

Definition at line 171 of file MC23.py.

171def MC23ppReferenceRun2024(flags): # FIXME This configuration is a placeholder
172 """MC23 flags for the 2024 5.36 TeV pp reference run"""
173 flags.Input.MCCampaign = Campaign.MC23e
174
175 flags.Beam.NumberOfCollisions = 0.
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 # These numbers are based upon a relative XS scaling of the high-pt slice
186 # of 64%, which leads to a relative high-pt / low-pt sampling of
187 # 0.001953314389 / 0.9980466856. Those numbers are then multiplied by 7.5
188 # to follow pile-up profile. Only a relevant number of significant digits
189 # are kept.
190 flags.Digitization.PU.NumberOfLowPtMinBias = 7.485
191 flags.Digitization.PU.NumberOfHighPtMinBias = 0.015
192 flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructure_Fill7314_BCMSPattern_Flat'
193 flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run488000_MC23e_SingleBeamspot'
194
195 from HIRecConfig.HIModeFlags import HIPmode
196 HIPmode(flags) # TO CHECK is it an issue if this is set for RDOtoRDOTrigger?
197 flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
198
199 #all
200 flags.Trigger.AODEDMSet = 'AODFULL'
201 flags.Trigger.triggerMenuSetup = 'PhysicsP1_pp_lowMu_run3_v1_TriggerValidation_prescale'
202
203

◆ MC23Simulation2023HeavyIonRun()

python.MC23.MC23Simulation2023HeavyIonRun ( flags) 
MC23 flags for simulation simulation of the 2023 Heavy Ion run

Definition at line 511 of file MC23.py.

511def MC23Simulation2023HeavyIonRun(flags):
512 """MC23 flags for simulation simulation of the 2023 Heavy Ion run"""
513 MC23SimulationNoIoV(flags)
514 flags.Input.MCCampaign = Campaign.MC23d
515
516 flags.Input.RunNumbers = [460000]
517 flags.Input.OverrideRunNumber = True
518 flags.Input.LumiBlockNumbers = [1] # dummy value
519
520

◆ MC23Simulation2024HeavyIonRun()

python.MC23.MC23Simulation2024HeavyIonRun ( flags) 
MC23 flags for simulation simulation of the 2024 Heavy Ion run

Definition at line 531 of file MC23.py.

531def MC23Simulation2024HeavyIonRun(flags):
532 """MC23 flags for simulation simulation of the 2024 Heavy Ion run"""
533 MC23SimulationNoIoV(flags)
534 flags.Input.MCCampaign = Campaign.MC23e
535
536 flags.Input.RunNumbers = [488600]
537 flags.Input.OverrideRunNumber = True
538 flags.Input.LumiBlockNumbers = [1] # dummy value
539

◆ MC23Simulation2024ppRefRun()

python.MC23.MC23Simulation2024ppRefRun ( flags) 
MC23 flags for simulation simulation of the 2024 5.36 TeV pp reference run

Definition at line 521 of file MC23.py.

521def MC23Simulation2024ppRefRun(flags):
522 """MC23 flags for simulation simulation of the 2024 5.36 TeV pp reference run"""
523 MC23SimulationNoIoV(flags)
524 flags.Input.MCCampaign = Campaign.MC23e
525
526 flags.Input.RunNumbers = [488000]
527 flags.Input.OverrideRunNumber = True
528 flags.Input.LumiBlockNumbers = [1] # dummy value
529
530

◆ MC23Simulation2025OORun()

python.MC23.MC23Simulation2025OORun ( flags) 
MC23 flags for simulation simulation of the 2025 Oxygen Oxygen run

Definition at line 540 of file MC23.py.

540def MC23Simulation2025OORun(flags):
541 """MC23 flags for simulation simulation of the 2025 Oxygen Oxygen run"""
542 MC23SimulationNoIoV(flags)
543 flags.Input.MCCampaign = Campaign.MC23g
544
545 flags.Input.RunNumbers = [500700]
546 flags.Input.OverrideRunNumber = True
547 flags.Input.LumiBlockNumbers = [1] # dummy value
548
549

◆ MC23SimulationLowMuRun()

python.MC23.MC23SimulationLowMuRun ( flags) 
MC23 flags for low mu run simulation

Definition at line 502 of file MC23.py.

502def MC23SimulationLowMuRun(flags):
503 """MC23 flags for low mu run simulation"""
504 MC23SimulationNoIoV(flags)
505
506 flags.Input.RunNumbers = [420000]
507 flags.Input.OverrideRunNumber = True
508 flags.Input.LumiBlockNumbers = [1] # dummy value
509
510

◆ MC23SimulationNoIoV()

python.MC23.MC23SimulationNoIoV ( flags) 
MC23 base flags for simulation without specifying conditions IoVs

Definition at line 480 of file MC23.py.

480def MC23SimulationNoIoV(flags):
481 """MC23 base flags for simulation without specifying conditions IoVs"""
482 flags.Input.MCCampaign = Campaign.MC23a
483
484 from SimulationConfig.SimEnums import TruthStrategy
485 flags.Sim.PhysicsList = 'FTFP_BERT_ATL'
486 flags.Sim.TruthStrategy = TruthStrategy.MC15aPlus
487
488 flags.Sim.TRTRangeCut = 30.0
489 flags.Sim.TightMuonStepping = True
490
491 from SimulationConfig.G4Optimizations import enableBeamPipeKill, enableFrozenShowersFCalOnly
492 enableBeamPipeKill(flags)
493 if flags.Sim.ISF.Simulator.isFullSim():
494 enableFrozenShowersFCalOnly(flags)
495
496 from SimulationConfig.G4Optimizations import enableG4Optimizations
497 enableG4Optimizations(flags)
498
499 flags.Sim.FastCalo.ParamsInputFilename = 'FastCaloSim/MC23/TFCSparam_dev_Hybrid_Ha_v5_all_baryons_0_500.root'
500
501

◆ MC23SimulationSingleIoV()

python.MC23.MC23SimulationSingleIoV ( flags) 
MC23 flags for simulation

Definition at line 563 of file MC23.py.

563def MC23SimulationSingleIoV(flags):
564 """MC23 flags for simulation"""
565 MC23SimulationNoIoV(flags)
566 flags.Input.MCCampaign = Campaign.MC23a
567
568 flags.Input.RunNumbers = [410000]
569 flags.Input.OverrideRunNumber = True
570 flags.Input.LumiBlockNumbers = [1] # dummy value
571
572

◆ MC23SimulationSingleIoVCalibrationHits()

python.MC23.MC23SimulationSingleIoVCalibrationHits ( flags) 
MC23 flags for simulation with CalibrationHits

Definition at line 634 of file MC23.py.

634def MC23SimulationSingleIoVCalibrationHits(flags):
635 """MC23 flags for simulation with CalibrationHits"""
636 MC23SimulationSingleIoV(flags)
637 from SimuJobTransforms import CalHits, ParticleID
638 CalHits(flags)
639 ParticleID(flags)
640
641
Generated on for ATLAS Offline Software by doxygen 1.14.0