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)
 MC23HeavyIons2025NoPileUp (flags)
 MC23HeavyIons2025 (flags)
 MC23HeavyIons2026NoPileUp (flags)
 MC23HeavyIons2026 (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()

_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 448 of file MC23.py.

448def _MC23NoPileUp(flags):
449 """
450 Configure MC23 flags for Monte Carlo simulations without pile-up.
451 This method is used in the Digi-Reco step only.
452 """
453 flags.Beam.NumberOfCollisions = 0.
454
455 from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
456 LArConfigRun3NoPileUp(flags)
457
458 # radiation damage
459 from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
460 flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
461
462

◆ _MC23PileUp()

_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()

BeamspotSplitMC23a ( ) 
MC23a beamspot splitting configuration

Definition at line 532 of file MC23.py.

532def BeamspotSplitMC23a():
533 """MC23a beamspot splitting configuration"""
534 substeps = 4
535 event_fractions = [0.14, 0.14, 0.14, 0.58]
536
537 return substeps, event_fractions
538
539

◆ BeamspotSplitMC23c()

BeamspotSplitMC23c ( ) 
MC23c beamspot splitting configuration

Definition at line 540 of file MC23.py.

540def BeamspotSplitMC23c():
541 """MC23c beamspot splitting configuration"""
542 substeps = 4
543 event_fractions = [0.22, 0.22, 0.22, 0.34]
544
545 return substeps, event_fractions
546
547

◆ BeamspotSplitMC23d()

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

Definition at line 548 of file MC23.py.

548def BeamspotSplitMC23d():
549 """MC23d beamspot splitting configuration, matches MC23c, but only the
550 first two substep are considered levelling rather than the first
551 three."""
552 substeps = 4
553 event_fractions = [0.22, 0.22, 0.22, 0.34]
554
555 return substeps, event_fractions
556
557

◆ BeamspotSplitMC23e()

BeamspotSplitMC23e ( ) 
MC23e beamspot splitting configuration.

Definition at line 558 of file MC23.py.

558def BeamspotSplitMC23e():
559 """MC23e beamspot splitting configuration."""
560 substeps = 4
561 event_fractions = [0.22, 0.22, 0.22, 0.34]
562
563 return substeps, event_fractions
564
565

◆ BeamspotSplitMC23g()

BeamspotSplitMC23g ( ) 
MC23g beamspot splitting configuration.

Definition at line 566 of file MC23.py.

566def BeamspotSplitMC23g():
567 """MC23g beamspot splitting configuration."""
568 substeps = 4
569 event_fractions = [0.3, 0.42, 0.08, 0.2]
570
571 return substeps, event_fractions
572
573

◆ MC23a()

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

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 463 of file MC23.py.

463def MC23aNoPileUp(flags):
464 """
465 Configure MC23a flags for Monte Carlo simulations without pile-up.
466 This method is used in the Digi-Reco step only.
467 """
468 _MC23NoPileUp(flags)
469
470 flags.Input.MCCampaign = Campaign.MC23a
471 flags.Input.ConditionsRunNumber = 410000
472
473

◆ MC23aSimulationMultipleIoV()

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 667 of file MC23.py.

667def MC23aSimulationMultipleIoV(flags):
668 """
669 Configure MC23a flags for simulation with multiple Intervals of Validity (IoV).
670 This method is used in the Simulation step only.
671 """
672 MC23SimulationNoIoV(flags)
673 flags.Input.MCCampaign = Campaign.MC23a
674
675 flags.Input.OverrideRunNumber = True
676
677 from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
678 generateRunAndLumiProfile(flags,
679 profile='RunDependentSimData.PileUpProfile_run410000_MC23a_MultiBeamspot')
680
681

◆ MC23aSimulationMultipleIoVCalibrationHits()

MC23aSimulationMultipleIoVCalibrationHits ( flags) 
MC23 flags for simulation with CalibrationHits

Definition at line 736 of file MC23.py.

736def MC23aSimulationMultipleIoVCalibrationHits(flags):
737 """MC23 flags for simulation with CalibrationHits"""
738 MC23aSimulationMultipleIoV(flags)
739 from SimuJobTransforms import CalHits, ParticleID
740 CalHits(flags)
741 ParticleID(flags)
742
743

◆ MC23aSingleBeamspot()

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

Definition at line 385 of file MC23.py.

385def MC23aSingleBeamspot(flags):
386 """MC23a flags for MC to match 2022 Run 3 data (single beamspot version)"""
387 MC23a(flags)
388
389 # override only pile-up profile
390 flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run410000_MC23a_SingleBeamspot'
391
392

◆ MC23c()

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

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 682 of file MC23.py.

682def MC23cSimulationMultipleIoV(flags):
683 """
684 Configure MC23c flags for simulation with multiple Intervals of Validity (IoV).
685 This method is used in the Simulation step only.
686 """
687 MC23SimulationNoIoV(flags)
688 flags.Input.MCCampaign = Campaign.MC23c
689
690 flags.Input.OverrideRunNumber = True
691
692 from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
693 generateRunAndLumiProfile(flags,
694 profile='RunDependentSimData.PileUpProfile_run450000_MC23c_MultiBeamspot')
695
696

◆ MC23cSimulationMultipleIoVCalibrationHits()

MC23cSimulationMultipleIoVCalibrationHits ( flags) 
MC23 flags for simulation with CalibrationHits

Definition at line 744 of file MC23.py.

744def MC23cSimulationMultipleIoVCalibrationHits(flags):
745 """MC23 flags for simulation with CalibrationHits"""
746 MC23cSimulationMultipleIoV(flags)
747 from SimuJobTransforms import CalHits, ParticleID
748 CalHits(flags)
749 ParticleID(flags)
750
751

◆ MC23cSingleBeamspot()

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

Definition at line 393 of file MC23.py.

393def MC23cSingleBeamspot(flags):
394 """MC23c flags for MC to match 2023 Run 3 data (initial pile-up profile estimate, single beamspot version)"""
395 MC23c(flags)
396
397 # override only pile-up profile
398 flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run450000_MC23c_SingleBeamspot'
399
400

◆ MC23d()

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

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 474 of file MC23.py.

474def MC23dNoPileUp(flags):
475 """
476 Configure MC23d flags for Monte Carlo simulations without pile-up.
477 This method is used in the Digi-Reco step only.
478 """
479 _MC23NoPileUp(flags)
480
481 flags.Input.MCCampaign = Campaign.MC23d
482 flags.Input.ConditionsRunNumber = 450000
483
484

◆ MC23dSimulationLowMuLowB()

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

Definition at line 644 of file MC23.py.

644def MC23dSimulationLowMuLowB(flags):
645 """MC23 flags for simulation of special run 460348"""
646 MC23SimulationNoIoV(flags)
647 flags.Input.MCCampaign = Campaign.MC23d
648
649 flags.Input.RunNumbers = [465000]
650 flags.Input.OverrideRunNumber = True
651 flags.Input.LumiBlockNumber = [1] # dummy value
652
653 # B-field configuration
654 flags.BField.configuredSolenoidFieldScale = 0.4
655
656

◆ MC23dSingleBeamspot()

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 401 of file MC23.py.

401def MC23dSingleBeamspot(flags):
402 """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)"""
403 MC23d(flags)
404
405 # override only pile-up profile
406 flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run450000_MC23d_SingleBeamspot'
407

◆ MC23e()

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

Definition at line 127 of file MC23.py.

127def MC23e(flags):
128 """MC23e flags for MC to match 2024 Run 3 data (initial pile-up estimate based on broadened 2023 data )"""
129 _MC23PileUp(flags)
130
131 flags.Input.MCCampaign = Campaign.MC23e
132
133 # pile-up
134 # These numbers are based upon a relative XS scaling of the high-pt slice
135 # of 64%, which leads to a relative high-pt / low-pt sampling of
136 # 0.001953314389 / 0.9980466856. Those numbers are then multiplied by 98.5
137 # to follow pile-up profile. Only a relevant number of significant digits
138 # are kept.
139 flags.Digitization.PU.NumberOfLowPtMinBias = 98.308
140 flags.Digitization.PU.NumberOfHighPtMinBias = 0.192
141 # TODO new bunch structure?
142 flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructure_Fill7314_BCMSPattern_Flat'
143 flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run470000_MC23e_MultiBeamspot'
144
145

◆ MC23eNoPileUp()

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 485 of file MC23.py.

485def MC23eNoPileUp(flags):
486 """
487 Configure MC23e flags for Monte Carlo simulations without pile-up.
488 This method is used in the Digi-Reco step only.
489 """
490 _MC23NoPileUp(flags)
491
492 flags.Input.MCCampaign = Campaign.MC23e
493 flags.Input.ConditionsRunNumber = 470000
494
495

◆ MC23eSimulationMultipleIoV()

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 697 of file MC23.py.

697def MC23eSimulationMultipleIoV(flags):
698 """
699 Configure MC23e flags for simulation with multiple Intervals of Validity (IoV).
700 This method is used in the Simulation step only.
701 """
702 MC23SimulationNoIoV(flags)
703 flags.Input.MCCampaign = Campaign.MC23e
704
705 flags.Input.OverrideRunNumber = True
706
707 from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
708 generateRunAndLumiProfile(flags,
709 profile='RunDependentSimData.PileUpProfile_run470000_MC23e_MultiBeamspot')
710
711

◆ MC23eSimulationMultipleIoVCalibrationHits()

MC23eSimulationMultipleIoVCalibrationHits ( flags) 
MC23e flags for simulation with CalibrationHits

Definition at line 752 of file MC23.py.

752def MC23eSimulationMultipleIoVCalibrationHits(flags):
753 """MC23e flags for simulation with CalibrationHits"""
754 MC23eSimulationMultipleIoV(flags)
755 from SimuJobTransforms import CalHits, ParticleID
756 CalHits(flags)
757 ParticleID(flags)
758
759

◆ MC23eSingleBeamspot()

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

Definition at line 408 of file MC23.py.

408def MC23eSingleBeamspot(flags):
409 """MC23e flags for MC to match 2024 Run 3 data (initial pile-up profile estimate, single beamspot version)"""
410 MC23e(flags)
411
412 # override only pile-up profile
413 flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run470000_MC23e_SingleBeamspot'
414

◆ MC23g()

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

Definition at line 146 of file MC23.py.

146def MC23g(flags):
147 """MC23g flags for MC to match 2025 Run 3 data (initial pile-up estimate based on broadened 2024 data )"""
148 _MC23PileUp(flags)
149
150 flags.Input.MCCampaign = Campaign.MC23g
151
152 # pile-up
153 # These numbers are based upon a relative XS scaling of the high-pt slice
154 # of 64%, which leads to a relative high-pt / low-pt sampling of
155 # 0.001953314389 / 0.9980466856. Those numbers are then multiplied by 99.5
156 # to follow pile-up profile. Only a relevant number of significant digits
157 # are kept.
158 flags.Digitization.PU.NumberOfLowPtMinBias = 99.306
159 flags.Digitization.PU.NumberOfHighPtMinBias = 0.194
160 # TODO new bunch structure?
161 flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructure_Fill7314_BCMSPattern_Flat'
162
163 # NB: This is the pileup profile that is used in the Digi+Reco step
164 flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run495000_MC23g_MultiBeamspot'
165
166

◆ MC23gNoPileUp()

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 496 of file MC23.py.

496def MC23gNoPileUp(flags):
497 """
498 Configure MC23g flags for Monte Carlo simulations without pile-up.
499 This method is used in the Digi-Reco step only.
500 """
501 _MC23NoPileUp(flags)
502
503 flags.Input.MCCampaign = Campaign.MC23g
504 flags.Input.ConditionsRunNumber = 495000
505
506

◆ MC23gSimulationMultipleIoV()

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 712 of file MC23.py.

712def MC23gSimulationMultipleIoV(flags):
713 """
714 Configure MC23g flags for simulation with multiple Intervals of Validity (IoV).
715 This method is used in the Simulation step only.
716 """
717 MC23SimulationNoIoV(flags)
718 flags.Input.MCCampaign = Campaign.MC23g
719
720 flags.Input.OverrideRunNumber = True
721
722 from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
723 # NB: This is the pileup profile used in the Simulation step only
724 generateRunAndLumiProfile(flags,
725 profile='RunDependentSimData.PileUpProfile_run495000_MC23g_MultiBeamspot')
726
727

◆ MC23gSimulationMultipleIoVCalibrationHits()

MC23gSimulationMultipleIoVCalibrationHits ( flags) 
MC23g flags for simulation with CalibrationHits

Definition at line 760 of file MC23.py.

760def MC23gSimulationMultipleIoVCalibrationHits(flags):
761 """MC23g flags for simulation with CalibrationHits"""
762 MC23gSimulationMultipleIoV(flags)
763 from SimuJobTransforms import CalHits, ParticleID
764 CalHits(flags)
765 ParticleID(flags)

◆ MC23gSingleBeamspot()

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

Definition at line 415 of file MC23.py.

415def MC23gSingleBeamspot(flags):
416 """MC23g flags for MC to match 2025 Run 3 data (initial pile-up profile estimate, single beamspot version)"""
417 MC23g(flags)
418
419 # override only pile-up profile
420 flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run495000_MC23g_SingleBeamspot'
421
422

◆ MC23HeavyIons2023()

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

Definition at line 98 of file MC23.py.

98def MC23HeavyIons2023(flags):
99 """MC23 flags for the 2023 Heavy Ions run"""
100 flags.Input.MCCampaign = Campaign.MC23d
101
102 flags.Beam.NumberOfCollisions = 0.
103 flags.Input.ConditionsRunNumber = 460000
104
105 from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
106 LArConfigRun3NoPileUp(flags) # TO CHECK is this actually what we want c.f. LArConfigRun3PileUp
107
108 # radiation damage
109 from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
110 flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
111
112 # pile-up
113 flags.Digitization.PileUp = True
114 flags.Digitization.DoXingByXingPileUp = True
115 flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructureHeavyIon2022'
116 flags.Digitization.PU.InitialBunchCrossing = 0
117 flags.Digitization.PU.FinalBunchCrossing = 0
118 flags.Digitization.PU.NumberOfCavern = 1 # We are using the Cavern Background input for the Hijing HITS-level events
119
120 flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
121
122 #all
123 flags.Trigger.AODEDMSet = 'AODFULL'
124 flags.Trigger.triggerMenuSetup = 'Dev_HI_run3_v1_TriggerValidation_prescale'
125
126

◆ MC23HeavyIons2023NoPileUp()

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 flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
92
93 #all
94 flags.Trigger.AODEDMSet = 'AODFULL'
95 flags.Trigger.triggerMenuSetup = 'Dev_HI_run3_v1_TriggerValidation_prescale'
96
97

◆ MC23HeavyIons2024()

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

Definition at line 224 of file MC23.py.

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

◆ MC23HeavyIons2024NoPileUp()

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

Definition at line 202 of file MC23.py.

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

◆ MC23HeavyIons2025()

MC23HeavyIons2025 ( flags) 
MC23 flags for the 2025 Heavy Ions run

Definition at line 305 of file MC23.py.

305def MC23HeavyIons2025(flags):
306 """MC23 flags for the 2025 Heavy Ions run"""
307 flags.Input.MCCampaign = Campaign.MC23g
308
309 flags.Beam.NumberOfCollisions = 0.
310 flags.Input.ConditionsRunNumber = 510000
311
312 from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
313 LArConfigRun3NoPileUp(flags) # TO CHECK is this actually what we want c.f. LArConfigRun3PileUp
314
315 # radiation damage
316 from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
317 flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
318
319 # pile-up
320 flags.Digitization.PileUp = True
321 flags.Digitization.DoXingByXingPileUp = True
322 flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructureHeavyIon2022' # is this suitable for all Run3 PbPb runs ?
323 flags.Digitization.PU.InitialBunchCrossing = 0
324 flags.Digitization.PU.FinalBunchCrossing = 0
325 flags.Digitization.PU.NumberOfCavern = 1 # We are using the Cavern Background input for the Hijing HITS-level events
326
327 flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
328
329 #all
330 flags.Trigger.AODEDMSet = 'AODFULL'
331 flags.Trigger.triggerMenuSetup = 'Dev_HI_run3_v1_TriggerValidation_prescale'
332
333

◆ MC23HeavyIons2025NoPileUp()

MC23HeavyIons2025NoPileUp ( flags) 
MC23 flags for the 2025 Heavy Ions run (without pile-up)

Definition at line 283 of file MC23.py.

283def MC23HeavyIons2025NoPileUp(flags):
284 """MC23 flags for the 2025 Heavy Ions run (without pile-up)"""
285 flags.Input.MCCampaign = Campaign.MC23g
286
287 flags.Beam.BunchSpacing = 50
288 flags.Beam.NumberOfCollisions = 0.
289 flags.Input.ConditionsRunNumber = 510000
290
291 from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
292 LArConfigRun3NoPileUp(flags)
293
294 # radiation damage
295 from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
296 flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
297
298 flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
299
300 #all
301 flags.Trigger.AODEDMSet = 'AODFULL'
302 flags.Trigger.triggerMenuSetup = 'Dev_HI_run3_v1_TriggerValidation_prescale'
303
304

◆ MC23HeavyIons2025OO()

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

Definition at line 253 of file MC23.py.

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

◆ MC23HeavyIons2026()

MC23HeavyIons2026 ( flags) 
MC23 flags for the 2026 Heavy Ions run

Definition at line 356 of file MC23.py.

356def MC23HeavyIons2026(flags):
357 """MC23 flags for the 2026 Heavy Ions run"""
358 flags.Input.MCCampaign = Campaign.MC23g
359
360 flags.Beam.NumberOfCollisions = 0.
361 flags.Input.ConditionsRunNumber = 520900
362
363 from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
364 LArConfigRun3NoPileUp(flags) # TO CHECK is this actually what we want c.f. LArConfigRun3PileUp
365
366 # radiation damage
367 from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
368 flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
369
370 # pile-up
371 flags.Digitization.PileUp = True
372 flags.Digitization.DoXingByXingPileUp = True
373 flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructureHeavyIon2022' # is this suitable for all Run3 PbPb runs ?
374 flags.Digitization.PU.InitialBunchCrossing = 0
375 flags.Digitization.PU.FinalBunchCrossing = 0
376 flags.Digitization.PU.NumberOfCavern = 1 # We are using the Cavern Background input for the Hijing HITS-level events
377
378 flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
379
380 #all
381 flags.Trigger.AODEDMSet = 'AODFULL'
382 flags.Trigger.triggerMenuSetup = 'Dev_HI_run3_v1_TriggerValidation_prescale'
383
384

◆ MC23HeavyIons2026NoPileUp()

MC23HeavyIons2026NoPileUp ( flags) 
MC23 flags for the 2026 Heavy Ions run (without pile-up)

Definition at line 334 of file MC23.py.

334def MC23HeavyIons2026NoPileUp(flags):
335 """MC23 flags for the 2026 Heavy Ions run (without pile-up)"""
336 flags.Input.MCCampaign = Campaign.MC23g
337
338 flags.Beam.BunchSpacing = 50
339 flags.Beam.NumberOfCollisions = 0.
340 flags.Input.ConditionsRunNumber = 520900
341
342 from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
343 LArConfigRun3NoPileUp(flags)
344
345 # radiation damage
346 from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
347 flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
348
349 flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
350
351 #all
352 flags.Trigger.AODEDMSet = 'AODFULL'
353 flags.Trigger.triggerMenuSetup = 'Dev_HI_run3_v1_TriggerValidation_prescale'
354
355

◆ MC23LowMu()

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

Definition at line 423 of file MC23.py.

423def MC23LowMu(flags):
424 """MC23 flags for MC to match Run 3 data with low pile-up"""
425 flags.Input.MCCampaign = Campaign.MC23a
426
427 flags.Beam.NumberOfCollisions = 60.
428 flags.Input.ConditionsRunNumber = 410000
429
430 from LArConfiguration.LArConfigRun3 import LArConfigRun3PileUp
431 LArConfigRun3PileUp(flags)
432
433 # radiation damage
434 from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
435 flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
436
437 # pile-up
438 # These numbers are based upon a relative XS scaling of the high-pt slice
439 # of 64%, which leads to a relative high-pt / low-pt sampling of
440 # 0.001953314389 / 0.9980466856. Those numbers are then multiplied by 0.05
441 # to simulate low pile-up. Only a relevant number of significant digits
442 # are kept.
443 flags.Digitization.PU.NumberOfLowPtMinBias = 0.0499
444 flags.Digitization.PU.NumberOfHighPtMinBias = 0.0001
445 flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructure_Fill7314_BCMSPattern_Flat'
446
447

◆ MC23NoPileUpLowMuLowB()

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 518 of file MC23.py.

518def MC23NoPileUpLowMuLowB(flags):
519 """
520 Configure MC23d flags for Monte Carlo simulations to match special run 460348.
521 This method is used in the Digi-Reco step only.
522 """
523 _MC23NoPileUp(flags)
524
525 flags.Input.MCCampaign = Campaign.MC23d
526 flags.Input.ConditionsRunNumber = 465000
527
528 # B-field configuration
529 flags.BField.configuredSolenoidFieldScale = 0.4
530
531

◆ MC23NoPileUpLowMuRun()

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 507 of file MC23.py.

507def MC23NoPileUpLowMuRun(flags):
508 """
509 Configure MC23a flags for Monte Carlo simulations to match 2022 Low Mu data.
510 This method is used in the Digi-Reco step only.
511 """
512 _MC23NoPileUp(flags)
513
514 flags.Input.MCCampaign = Campaign.MC23a
515 flags.Input.ConditionsRunNumber = 420000
516
517

◆ MC23ppReferenceRun2024()

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

Definition at line 167 of file MC23.py.

167def MC23ppReferenceRun2024(flags): # FIXME This configuration is a placeholder
168 """MC23 flags for the 2024 5.36 TeV pp reference run"""
169 flags.Input.MCCampaign = Campaign.MC23e
170
171 # The beam number of collisions flag is used in algorithm configuration. Setting it to zero
172 # assumes we want to keep the configuration of reconstruction algorithms aligned with that
173 # used for the HI reconstruction (i.e. no pileup)
174 flags.Beam.NumberOfCollisions = 0.
175 flags.Input.ConditionsRunNumber = 488000 # better to set it explicitly
176 # Again, using the no-pileup configuration (see the comment three lines above)
177 from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
178 LArConfigRun3NoPileUp(flags)
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 flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
196
197 #all
198 flags.Trigger.AODEDMSet = 'AODFULL'
199 flags.Trigger.triggerMenuSetup = 'PhysicsP1_pp_lowMu_run3_v1_TriggerValidation_prescale'
200
201

◆ MC23Simulation2023HeavyIonRun()

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

Definition at line 605 of file MC23.py.

605def MC23Simulation2023HeavyIonRun(flags):
606 """MC23 flags for simulation simulation of the 2023 Heavy Ion run"""
607 MC23SimulationNoIoV(flags)
608 flags.Input.MCCampaign = Campaign.MC23d
609
610 flags.Input.RunNumbers = [460000]
611 flags.Input.OverrideRunNumber = True
612 flags.Input.LumiBlockNumbers = [1] # dummy value
613
614

◆ MC23Simulation2024HeavyIonRun()

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

Definition at line 625 of file MC23.py.

625def MC23Simulation2024HeavyIonRun(flags):
626 """MC23 flags for simulation simulation of the 2024 Heavy Ion run"""
627 MC23SimulationNoIoV(flags)
628 flags.Input.MCCampaign = Campaign.MC23e
629
630 flags.Input.RunNumbers = [488600]
631 flags.Input.OverrideRunNumber = True
632 flags.Input.LumiBlockNumbers = [1] # dummy value
633

◆ MC23Simulation2024ppRefRun()

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

Definition at line 615 of file MC23.py.

615def MC23Simulation2024ppRefRun(flags):
616 """MC23 flags for simulation simulation of the 2024 5.36 TeV pp reference run"""
617 MC23SimulationNoIoV(flags)
618 flags.Input.MCCampaign = Campaign.MC23e
619
620 flags.Input.RunNumbers = [488000]
621 flags.Input.OverrideRunNumber = True
622 flags.Input.LumiBlockNumbers = [1] # dummy value
623
624

◆ MC23Simulation2025OORun()

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

Definition at line 634 of file MC23.py.

634def MC23Simulation2025OORun(flags):
635 """MC23 flags for simulation simulation of the 2025 Oxygen Oxygen run"""
636 MC23SimulationNoIoV(flags)
637 flags.Input.MCCampaign = Campaign.MC23g
638
639 flags.Input.RunNumbers = [500700]
640 flags.Input.OverrideRunNumber = True
641 flags.Input.LumiBlockNumbers = [1] # dummy value
642
643

◆ MC23SimulationLowMuRun()

MC23SimulationLowMuRun ( flags) 
MC23 flags for low mu run simulation

Definition at line 596 of file MC23.py.

596def MC23SimulationLowMuRun(flags):
597 """MC23 flags for low mu run simulation"""
598 MC23SimulationNoIoV(flags)
599
600 flags.Input.RunNumbers = [420000]
601 flags.Input.OverrideRunNumber = True
602 flags.Input.LumiBlockNumbers = [1] # dummy value
603
604

◆ MC23SimulationNoIoV()

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

Definition at line 574 of file MC23.py.

574def MC23SimulationNoIoV(flags):
575 """MC23 base flags for simulation without specifying conditions IoVs"""
576 flags.Input.MCCampaign = Campaign.MC23a
577
578 from SimulationConfig.SimEnums import TruthStrategy
579 flags.Sim.PhysicsList = 'FTFP_BERT_ATL'
580 flags.Sim.TruthStrategy = TruthStrategy.MC15aPlus
581
582 flags.Sim.TRTRangeCut = 30.0
583 flags.Sim.TightMuonStepping = True
584
585 from SimulationConfig.G4Optimizations import enableBeamPipeKill, enableFrozenShowersFCalOnly
586 enableBeamPipeKill(flags)
587 if flags.Sim.ISF.Simulator.isFullSim():
588 enableFrozenShowersFCalOnly(flags)
589
590 from SimulationConfig.G4Optimizations import enableG4Optimizations
591 enableG4Optimizations(flags)
592
593 flags.Sim.FastCalo.ParamsInputFilename = 'FastCaloSim/MC23/TFCSparam_dev_Hybrid_Ha_v5_all_baryons_0_500.root'
594
595

◆ MC23SimulationSingleIoV()

MC23SimulationSingleIoV ( flags) 
MC23 flags for simulation

Definition at line 657 of file MC23.py.

657def MC23SimulationSingleIoV(flags):
658 """MC23 flags for simulation"""
659 MC23SimulationNoIoV(flags)
660 flags.Input.MCCampaign = Campaign.MC23a
661
662 flags.Input.RunNumbers = [410000]
663 flags.Input.OverrideRunNumber = True
664 flags.Input.LumiBlockNumbers = [1] # dummy value
665
666

◆ MC23SimulationSingleIoVCalibrationHits()

MC23SimulationSingleIoVCalibrationHits ( flags) 
MC23 flags for simulation with CalibrationHits

Definition at line 728 of file MC23.py.

728def MC23SimulationSingleIoVCalibrationHits(flags):
729 """MC23 flags for simulation with CalibrationHits"""
730 MC23SimulationSingleIoV(flags)
731 from SimuJobTransforms import CalHits, ParticleID
732 CalHits(flags)
733 ParticleID(flags)
734
735
Generated on for ATLAS Offline Software by doxygen 1.17.0