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

468def _MC23NoPileUp(flags):
469 """
470 Configure MC23 flags for Monte Carlo simulations without pile-up.
471 This method is used in the Digi-Reco step only.
472 """
473 flags.Beam.NumberOfCollisions = 0.
474
475 from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
476 LArConfigRun3NoPileUp(flags)
477
478 # radiation damage
479 from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
480 flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
481
482

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

552def BeamspotSplitMC23a():
553 """MC23a beamspot splitting configuration"""
554 substeps = 4
555 event_fractions = [0.14, 0.14, 0.14, 0.58]
556
557 return substeps, event_fractions
558
559

◆ BeamspotSplitMC23c()

BeamspotSplitMC23c ( ) 
MC23c beamspot splitting configuration

Definition at line 560 of file MC23.py.

560def BeamspotSplitMC23c():
561 """MC23c beamspot splitting configuration"""
562 substeps = 4
563 event_fractions = [0.22, 0.22, 0.22, 0.34]
564
565 return substeps, event_fractions
566
567

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

568def BeamspotSplitMC23d():
569 """MC23d beamspot splitting configuration, matches MC23c, but only the
570 first two substep are considered levelling rather than the first
571 three."""
572 substeps = 4
573 event_fractions = [0.22, 0.22, 0.22, 0.34]
574
575 return substeps, event_fractions
576
577

◆ BeamspotSplitMC23e()

BeamspotSplitMC23e ( ) 
MC23e beamspot splitting configuration.

Definition at line 578 of file MC23.py.

578def BeamspotSplitMC23e():
579 """MC23e beamspot splitting configuration."""
580 substeps = 4
581 event_fractions = [0.22, 0.22, 0.22, 0.34]
582
583 return substeps, event_fractions
584
585

◆ BeamspotSplitMC23g()

BeamspotSplitMC23g ( ) 
MC23g beamspot splitting configuration.

Definition at line 586 of file MC23.py.

586def BeamspotSplitMC23g():
587 """MC23g beamspot splitting configuration."""
588 substeps = 4
589 event_fractions = [0.3, 0.42, 0.08, 0.2]
590
591 return substeps, event_fractions
592
593

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

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

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

687def MC23aSimulationMultipleIoV(flags):
688 """
689 Configure MC23a flags for simulation with multiple Intervals of Validity (IoV).
690 This method is used in the Simulation step only.
691 """
692 MC23SimulationNoIoV(flags)
693 flags.Input.MCCampaign = Campaign.MC23a
694
695 flags.Input.OverrideRunNumber = True
696
697 from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
698 generateRunAndLumiProfile(flags,
699 profile='RunDependentSimData.PileUpProfile_run410000_MC23a_MultiBeamspot')
700
701

◆ MC23aSimulationMultipleIoVCalibrationHits()

MC23aSimulationMultipleIoVCalibrationHits ( flags) 
MC23 flags for simulation with CalibrationHits

Definition at line 756 of file MC23.py.

756def MC23aSimulationMultipleIoVCalibrationHits(flags):
757 """MC23 flags for simulation with CalibrationHits"""
758 MC23aSimulationMultipleIoV(flags)
759 from SimuJobTransforms import CalHits, ParticleID
760 CalHits(flags)
761 ParticleID(flags)
762
763

◆ MC23aSingleBeamspot()

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

Definition at line 405 of file MC23.py.

405def MC23aSingleBeamspot(flags):
406 """MC23a flags for MC to match 2022 Run 3 data (single beamspot version)"""
407 MC23a(flags)
408
409 # override only pile-up profile
410 flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run410000_MC23a_SingleBeamspot'
411
412

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

702def MC23cSimulationMultipleIoV(flags):
703 """
704 Configure MC23c flags for simulation with multiple Intervals of Validity (IoV).
705 This method is used in the Simulation step only.
706 """
707 MC23SimulationNoIoV(flags)
708 flags.Input.MCCampaign = Campaign.MC23c
709
710 flags.Input.OverrideRunNumber = True
711
712 from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
713 generateRunAndLumiProfile(flags,
714 profile='RunDependentSimData.PileUpProfile_run450000_MC23c_MultiBeamspot')
715
716

◆ MC23cSimulationMultipleIoVCalibrationHits()

MC23cSimulationMultipleIoVCalibrationHits ( flags) 
MC23 flags for simulation with CalibrationHits

Definition at line 764 of file MC23.py.

764def MC23cSimulationMultipleIoVCalibrationHits(flags):
765 """MC23 flags for simulation with CalibrationHits"""
766 MC23cSimulationMultipleIoV(flags)
767 from SimuJobTransforms import CalHits, ParticleID
768 CalHits(flags)
769 ParticleID(flags)
770
771

◆ MC23cSingleBeamspot()

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

Definition at line 413 of file MC23.py.

413def MC23cSingleBeamspot(flags):
414 """MC23c flags for MC to match 2023 Run 3 data (initial pile-up profile estimate, single beamspot version)"""
415 MC23c(flags)
416
417 # override only pile-up profile
418 flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run450000_MC23c_SingleBeamspot'
419
420

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

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

◆ MC23dSimulationLowMuLowB()

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

Definition at line 664 of file MC23.py.

664def MC23dSimulationLowMuLowB(flags):
665 """MC23 flags for simulation of special run 460348"""
666 MC23SimulationNoIoV(flags)
667 flags.Input.MCCampaign = Campaign.MC23d
668
669 flags.Input.RunNumbers = [465000]
670 flags.Input.OverrideRunNumber = True
671 flags.Input.LumiBlockNumber = [1] # dummy value
672
673 # B-field configuration
674 flags.BField.configuredSolenoidFieldScale = 0.4
675
676

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

421def MC23dSingleBeamspot(flags):
422 """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)"""
423 MC23d(flags)
424
425 # override only pile-up profile
426 flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run450000_MC23d_SingleBeamspot'
427

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

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

505def MC23eNoPileUp(flags):
506 """
507 Configure MC23e flags for Monte Carlo simulations without pile-up.
508 This method is used in the Digi-Reco step only.
509 """
510 _MC23NoPileUp(flags)
511
512 flags.Input.MCCampaign = Campaign.MC23e
513 flags.Input.ConditionsRunNumber = 470000
514
515

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

717def MC23eSimulationMultipleIoV(flags):
718 """
719 Configure MC23e flags for simulation with multiple Intervals of Validity (IoV).
720 This method is used in the Simulation step only.
721 """
722 MC23SimulationNoIoV(flags)
723 flags.Input.MCCampaign = Campaign.MC23e
724
725 flags.Input.OverrideRunNumber = True
726
727 from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
728 generateRunAndLumiProfile(flags,
729 profile='RunDependentSimData.PileUpProfile_run470000_MC23e_MultiBeamspot')
730
731

◆ MC23eSimulationMultipleIoVCalibrationHits()

MC23eSimulationMultipleIoVCalibrationHits ( flags) 
MC23e flags for simulation with CalibrationHits

Definition at line 772 of file MC23.py.

772def MC23eSimulationMultipleIoVCalibrationHits(flags):
773 """MC23e flags for simulation with CalibrationHits"""
774 MC23eSimulationMultipleIoV(flags)
775 from SimuJobTransforms import CalHits, ParticleID
776 CalHits(flags)
777 ParticleID(flags)
778
779

◆ MC23eSingleBeamspot()

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

Definition at line 428 of file MC23.py.

428def MC23eSingleBeamspot(flags):
429 """MC23e flags for MC to match 2024 Run 3 data (initial pile-up profile estimate, single beamspot version)"""
430 MC23e(flags)
431
432 # override only pile-up profile
433 flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run470000_MC23e_SingleBeamspot'
434

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

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

516def MC23gNoPileUp(flags):
517 """
518 Configure MC23g flags for Monte Carlo simulations without pile-up.
519 This method is used in the Digi-Reco step only.
520 """
521 _MC23NoPileUp(flags)
522
523 flags.Input.MCCampaign = Campaign.MC23g
524 flags.Input.ConditionsRunNumber = 495000
525
526

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

732def MC23gSimulationMultipleIoV(flags):
733 """
734 Configure MC23g flags for simulation with multiple Intervals of Validity (IoV).
735 This method is used in the Simulation step only.
736 """
737 MC23SimulationNoIoV(flags)
738 flags.Input.MCCampaign = Campaign.MC23g
739
740 flags.Input.OverrideRunNumber = True
741
742 from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
743 # NB: This is the pileup profile used in the Simulation step only
744 generateRunAndLumiProfile(flags,
745 profile='RunDependentSimData.PileUpProfile_run495000_MC23g_MultiBeamspot')
746
747

◆ MC23gSimulationMultipleIoVCalibrationHits()

MC23gSimulationMultipleIoVCalibrationHits ( flags) 
MC23g flags for simulation with CalibrationHits

Definition at line 780 of file MC23.py.

780def MC23gSimulationMultipleIoVCalibrationHits(flags):
781 """MC23g flags for simulation with CalibrationHits"""
782 MC23gSimulationMultipleIoV(flags)
783 from SimuJobTransforms import CalHits, ParticleID
784 CalHits(flags)
785 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 435 of file MC23.py.

435def MC23gSingleBeamspot(flags):
436 """MC23g flags for MC to match 2025 Run 3 data (initial pile-up profile estimate, single beamspot version)"""
437 MC23g(flags)
438
439 # override only pile-up profile
440 flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run495000_MC23g_SingleBeamspot'
441
442

◆ MC23HeavyIons2023()

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

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

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

Definition at line 232 of file MC23.py.

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

◆ MC23HeavyIons2024NoPileUp()

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

Definition at line 208 of file MC23.py.

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

◆ MC23HeavyIons2025()

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

Definition at line 319 of file MC23.py.

319def MC23HeavyIons2025(flags):
320 """MC23 flags for the 2025 Heavy Ions run"""
321 flags.Input.MCCampaign = Campaign.MC23g
322
323 flags.Beam.NumberOfCollisions = 0.
324 flags.Input.ConditionsRunNumber = 510000
325
326 from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
327 LArConfigRun3NoPileUp(flags) # TO CHECK is this actually what we want c.f. LArConfigRun3PileUp
328
329 # radiation damage
330 from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
331 flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
332
333 # pile-up
334 flags.Digitization.PileUp = True
335 flags.Digitization.DoXingByXingPileUp = True
336 flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructureHeavyIon2022' # is this suitable for all Run3 PbPb runs ?
337 flags.Digitization.PU.InitialBunchCrossing = 0
338 flags.Digitization.PU.FinalBunchCrossing = 0
339 flags.Digitization.PU.NumberOfCavern = 1 # We are using the Cavern Background input for the Hijing HITS-level events
340
341 from HIRecConfig.HIModeFlags import HImode
342 HImode(flags)
343 flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
344
345 #all
346 flags.Trigger.AODEDMSet = 'AODFULL'
347 flags.Trigger.triggerMenuSetup = 'Dev_HI_run3_v1_TriggerValidation_prescale'
348
349

◆ MC23HeavyIons2025NoPileUp()

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

Definition at line 295 of file MC23.py.

295def MC23HeavyIons2025NoPileUp(flags):
296 """MC23 flags for the 2025 Heavy Ions run (without pile-up)"""
297 flags.Input.MCCampaign = Campaign.MC23g
298
299 flags.Beam.BunchSpacing = 50
300 flags.Beam.NumberOfCollisions = 0.
301 flags.Input.ConditionsRunNumber = 510000
302
303 from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
304 LArConfigRun3NoPileUp(flags)
305
306 # radiation damage
307 from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
308 flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
309
310 from HIRecConfig.HIModeFlags import HImode
311 HImode(flags)
312 flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
313
314 #all
315 flags.Trigger.AODEDMSet = 'AODFULL'
316 flags.Trigger.triggerMenuSetup = 'Dev_HI_run3_v1_TriggerValidation_prescale'
317
318

◆ MC23HeavyIons2025OO()

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

Definition at line 263 of file MC23.py.

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

◆ MC23HeavyIons2026()

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

Definition at line 374 of file MC23.py.

374def MC23HeavyIons2026(flags):
375 """MC23 flags for the 2026 Heavy Ions run"""
376 flags.Input.MCCampaign = Campaign.MC23g
377
378 flags.Beam.NumberOfCollisions = 0.
379 flags.Input.ConditionsRunNumber = 520900
380
381 from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
382 LArConfigRun3NoPileUp(flags) # TO CHECK is this actually what we want c.f. LArConfigRun3PileUp
383
384 # radiation damage
385 from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
386 flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
387
388 # pile-up
389 flags.Digitization.PileUp = True
390 flags.Digitization.DoXingByXingPileUp = True
391 flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructureHeavyIon2022' # is this suitable for all Run3 PbPb runs ?
392 flags.Digitization.PU.InitialBunchCrossing = 0
393 flags.Digitization.PU.FinalBunchCrossing = 0
394 flags.Digitization.PU.NumberOfCavern = 1 # We are using the Cavern Background input for the Hijing HITS-level events
395
396 from HIRecConfig.HIModeFlags import HImode
397 HImode(flags)
398 flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
399
400 #all
401 flags.Trigger.AODEDMSet = 'AODFULL'
402 flags.Trigger.triggerMenuSetup = 'Dev_HI_run3_v1_TriggerValidation_prescale'
403
404

◆ MC23HeavyIons2026NoPileUp()

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

Definition at line 350 of file MC23.py.

350def MC23HeavyIons2026NoPileUp(flags):
351 """MC23 flags for the 2026 Heavy Ions run (without pile-up)"""
352 flags.Input.MCCampaign = Campaign.MC23g
353
354 flags.Beam.BunchSpacing = 50
355 flags.Beam.NumberOfCollisions = 0.
356 flags.Input.ConditionsRunNumber = 520900
357
358 from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
359 LArConfigRun3NoPileUp(flags)
360
361 # radiation damage
362 from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
363 flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
364
365 from HIRecConfig.HIModeFlags import HImode
366 HImode(flags)
367 flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
368
369 #all
370 flags.Trigger.AODEDMSet = 'AODFULL'
371 flags.Trigger.triggerMenuSetup = 'Dev_HI_run3_v1_TriggerValidation_prescale'
372
373

◆ MC23LowMu()

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

Definition at line 443 of file MC23.py.

443def MC23LowMu(flags):
444 """MC23 flags for MC to match Run 3 data with low pile-up"""
445 flags.Input.MCCampaign = Campaign.MC23a
446
447 flags.Beam.NumberOfCollisions = 60.
448 flags.Input.ConditionsRunNumber = 410000
449
450 from LArConfiguration.LArConfigRun3 import LArConfigRun3PileUp
451 LArConfigRun3PileUp(flags)
452
453 # radiation damage
454 from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
455 flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
456
457 # pile-up
458 # These numbers are based upon a relative XS scaling of the high-pt slice
459 # of 64%, which leads to a relative high-pt / low-pt sampling of
460 # 0.001953314389 / 0.9980466856. Those numbers are then multiplied by 0.05
461 # to simulate low pile-up. Only a relevant number of significant digits
462 # are kept.
463 flags.Digitization.PU.NumberOfLowPtMinBias = 0.0499
464 flags.Digitization.PU.NumberOfHighPtMinBias = 0.0001
465 flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructure_Fill7314_BCMSPattern_Flat'
466
467

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

538def MC23NoPileUpLowMuLowB(flags):
539 """
540 Configure MC23d flags for Monte Carlo simulations to match special run 460348.
541 This method is used in the Digi-Reco step only.
542 """
543 _MC23NoPileUp(flags)
544
545 flags.Input.MCCampaign = Campaign.MC23d
546 flags.Input.ConditionsRunNumber = 465000
547
548 # B-field configuration
549 flags.BField.configuredSolenoidFieldScale = 0.4
550
551

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

527def MC23NoPileUpLowMuRun(flags):
528 """
529 Configure MC23a flags for Monte Carlo simulations to match 2022 Low Mu data.
530 This method is used in the Digi-Reco step only.
531 """
532 _MC23NoPileUp(flags)
533
534 flags.Input.MCCampaign = Campaign.MC23a
535 flags.Input.ConditionsRunNumber = 420000
536
537

◆ MC23ppReferenceRun2024()

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 # The beam number of collisions flag is used in algorithm configuration. Setting it to zero
176 # assumes we want to keep the configuration of reconstruction algorithms aligned with that
177 # used for the HI reconstruction (i.e. no pileup)
178 flags.Beam.NumberOfCollisions = 0.
179 flags.Input.ConditionsRunNumber = 488000 # better to set it explicitly
180 # Again, using the no-pileup configuration (see the comment three lines above)
181 from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
182 LArConfigRun3NoPileUp(flags)
183
184 # radiation damage
185 from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
186 flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
187
188 # pile-up
189 # These numbers are based upon a relative XS scaling of the high-pt slice
190 # of 64%, which leads to a relative high-pt / low-pt sampling of
191 # 0.001953314389 / 0.9980466856. Those numbers are then multiplied by 7.5
192 # to follow pile-up profile. Only a relevant number of significant digits
193 # are kept.
194 flags.Digitization.PU.NumberOfLowPtMinBias = 7.485
195 flags.Digitization.PU.NumberOfHighPtMinBias = 0.015
196 flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructure_Fill7314_BCMSPattern_Flat'
197 flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run488000_MC23e_SingleBeamspot'
198
199 from HIRecConfig.HIModeFlags import HIPmode
200 HIPmode(flags)
201 flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
202
203 #all
204 flags.Trigger.AODEDMSet = 'AODFULL'
205 flags.Trigger.triggerMenuSetup = 'PhysicsP1_pp_lowMu_run3_v1_TriggerValidation_prescale'
206
207

◆ MC23Simulation2023HeavyIonRun()

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

Definition at line 625 of file MC23.py.

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

◆ MC23Simulation2024HeavyIonRun()

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

Definition at line 645 of file MC23.py.

645def MC23Simulation2024HeavyIonRun(flags):
646 """MC23 flags for simulation simulation of the 2024 Heavy Ion run"""
647 MC23SimulationNoIoV(flags)
648 flags.Input.MCCampaign = Campaign.MC23e
649
650 flags.Input.RunNumbers = [488600]
651 flags.Input.OverrideRunNumber = True
652 flags.Input.LumiBlockNumbers = [1] # dummy value
653

◆ MC23Simulation2024ppRefRun()

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

Definition at line 635 of file MC23.py.

635def MC23Simulation2024ppRefRun(flags):
636 """MC23 flags for simulation simulation of the 2024 5.36 TeV pp reference run"""
637 MC23SimulationNoIoV(flags)
638 flags.Input.MCCampaign = Campaign.MC23e
639
640 flags.Input.RunNumbers = [488000]
641 flags.Input.OverrideRunNumber = True
642 flags.Input.LumiBlockNumbers = [1] # dummy value
643
644

◆ MC23Simulation2025OORun()

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

Definition at line 654 of file MC23.py.

654def MC23Simulation2025OORun(flags):
655 """MC23 flags for simulation simulation of the 2025 Oxygen Oxygen run"""
656 MC23SimulationNoIoV(flags)
657 flags.Input.MCCampaign = Campaign.MC23g
658
659 flags.Input.RunNumbers = [500700]
660 flags.Input.OverrideRunNumber = True
661 flags.Input.LumiBlockNumbers = [1] # dummy value
662
663

◆ MC23SimulationLowMuRun()

MC23SimulationLowMuRun ( flags) 
MC23 flags for low mu run simulation

Definition at line 616 of file MC23.py.

616def MC23SimulationLowMuRun(flags):
617 """MC23 flags for low mu run simulation"""
618 MC23SimulationNoIoV(flags)
619
620 flags.Input.RunNumbers = [420000]
621 flags.Input.OverrideRunNumber = True
622 flags.Input.LumiBlockNumbers = [1] # dummy value
623
624

◆ MC23SimulationNoIoV()

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

Definition at line 594 of file MC23.py.

594def MC23SimulationNoIoV(flags):
595 """MC23 base flags for simulation without specifying conditions IoVs"""
596 flags.Input.MCCampaign = Campaign.MC23a
597
598 from SimulationConfig.SimEnums import TruthStrategy
599 flags.Sim.PhysicsList = 'FTFP_BERT_ATL'
600 flags.Sim.TruthStrategy = TruthStrategy.MC15aPlus
601
602 flags.Sim.TRTRangeCut = 30.0
603 flags.Sim.TightMuonStepping = True
604
605 from SimulationConfig.G4Optimizations import enableBeamPipeKill, enableFrozenShowersFCalOnly
606 enableBeamPipeKill(flags)
607 if flags.Sim.ISF.Simulator.isFullSim():
608 enableFrozenShowersFCalOnly(flags)
609
610 from SimulationConfig.G4Optimizations import enableG4Optimizations
611 enableG4Optimizations(flags)
612
613 flags.Sim.FastCalo.ParamsInputFilename = 'FastCaloSim/MC23/TFCSparam_dev_Hybrid_Ha_v5_all_baryons_0_500.root'
614
615

◆ MC23SimulationSingleIoV()

MC23SimulationSingleIoV ( flags) 
MC23 flags for simulation

Definition at line 677 of file MC23.py.

677def MC23SimulationSingleIoV(flags):
678 """MC23 flags for simulation"""
679 MC23SimulationNoIoV(flags)
680 flags.Input.MCCampaign = Campaign.MC23a
681
682 flags.Input.RunNumbers = [410000]
683 flags.Input.OverrideRunNumber = True
684 flags.Input.LumiBlockNumbers = [1] # dummy value
685
686

◆ MC23SimulationSingleIoVCalibrationHits()

MC23SimulationSingleIoVCalibrationHits ( flags) 
MC23 flags for simulation with CalibrationHits

Definition at line 748 of file MC23.py.

748def MC23SimulationSingleIoVCalibrationHits(flags):
749 """MC23 flags for simulation with CalibrationHits"""
750 MC23SimulationSingleIoV(flags)
751 from SimuJobTransforms import CalHits, ParticleID
752 CalHits(flags)
753 ParticleID(flags)
754
755
Generated on for ATLAS Offline Software by doxygen 1.17.0