python.MC23 Namespace Reference

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

Function Documentation

_MC23NoPileUp()

def python.MC23._MC23NoPileUp (   flags )

private

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

Definition at line 355 of file MC23.py.

def _MC23NoPileUp(flags):
    """
    Configure MC23 flags for Monte Carlo simulations without pile-up.
    This method is used in the Digi-Reco step only.
    """
    flags.Beam.NumberOfCollisions = 0.
 
    from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
    LArConfigRun3NoPileUp(flags)
 
    # radiation damage
    from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
    flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
 
 

_MC23PileUp()

def python.MC23._MC23PileUp (   flags )

private

MC23 flags for MC with pile-up

Definition at line 6 of file MC23.py.

def _MC23PileUp(flags):
    """MC23 flags for MC with pile-up"""
    flags.Beam.NumberOfCollisions = 60.
 
    from LArConfiguration.LArConfigRun3 import LArConfigRun3PileUp
    LArConfigRun3PileUp(flags)
 
    # radiation damage
    from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
    flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
 
    if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
        # ensure better randomisation of high-pt minbias events
        flags.Digitization.PU.HighPtMinBiasInputColOffset = -1
 
 

BeamspotSplitMC23a()

def python.MC23.BeamspotSplitMC23a

(

)

MC23a beamspot splitting configuration

Definition at line 439 of file MC23.py.

def BeamspotSplitMC23a():
    """MC23a beamspot splitting configuration"""
    substeps = 4
    event_fractions = [0.14, 0.14, 0.14, 0.58]
 
    return substeps, event_fractions
 
 

BeamspotSplitMC23c()

def python.MC23.BeamspotSplitMC23c

(

)

MC23c beamspot splitting configuration

Definition at line 447 of file MC23.py.

def BeamspotSplitMC23c():
    """MC23c beamspot splitting configuration"""
    substeps = 4
    event_fractions = [0.22, 0.22, 0.22, 0.34]
 
    return substeps, event_fractions
 
 

BeamspotSplitMC23d()

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

def BeamspotSplitMC23d():
    """MC23d beamspot splitting configuration, matches MC23c, but only the
    first two substep are considered levelling rather than the first
    three."""
    substeps = 4
    event_fractions = [0.22, 0.22, 0.22, 0.34]
 
    return substeps, event_fractions
 
 

BeamspotSplitMC23e()

def python.MC23.BeamspotSplitMC23e

(

)

MC23e beamspot splitting configuration.

Definition at line 465 of file MC23.py.

def BeamspotSplitMC23e():
    """MC23e beamspot splitting configuration."""
    substeps = 4
    event_fractions = [0.22, 0.22, 0.22, 0.34]
 
    return substeps, event_fractions
 
 

BeamspotSplitMC23g()

def python.MC23.BeamspotSplitMC23g

(

)

MC23g beamspot splitting configuration.

Definition at line 473 of file MC23.py.

def BeamspotSplitMC23g():
    """MC23g beamspot splitting configuration."""
    substeps = 4
    event_fractions = [0.3, 0.41, 0.09, 0.2]
 
    return substeps, event_fractions
 
 

BeamspotSplitMC23g_VALIDATION()

def python.MC23.BeamspotSplitMC23g_VALIDATION

(

)

MC23g beamspot splitting configuration for Validation purposes. The values are kept the same as BeamspotSplitMC23e

Definition at line 481 of file MC23.py.

def BeamspotSplitMC23g_VALIDATION():
    """MC23g beamspot splitting configuration for Validation purposes. The values are kept the same as BeamspotSplitMC23e"""
    substeps = 4
    event_fractions = [0.22, 0.22, 0.22, 0.34]
 
    return substeps, event_fractions
 

MC23a()

def python.MC23.MC23a

(

flags

)

MC23a flags for MC to match 2022 Run 3 data

Definition at line 22 of file MC23.py.

def MC23a(flags):
    """MC23a flags for MC to match 2022 Run 3 data"""
    _MC23PileUp(flags)
 
    flags.Input.MCCampaign = Campaign.MC23a
 
    # pile-up
    # These numbers are based upon a relative XS scaling of the high-pt slice
    # of 64%, which leads to a relative high-pt / low-pt sampling of
    # 0.001953314389 / 0.9980466856. Those numbers are then multiplied by 67.5
    # to follow pile-up profile. Only a relevant number of significant digits
    # are kept.
    flags.Digitization.PU.NumberOfLowPtMinBias = 67.369
    flags.Digitization.PU.NumberOfHighPtMinBias = 0.131
    flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructure_Fill7314_BCMSPattern_Flat'
    flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run410000_MC23a_MultiBeamspot'
 
 

MC23aNoPileUp()

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

def MC23aNoPileUp(flags):
    """
    Configure MC23a flags for Monte Carlo simulations without pile-up.
    This method is used in the Digi-Reco step only.
    """
    _MC23NoPileUp(flags)
 
    flags.Input.MCCampaign = Campaign.MC23a
    flags.Input.ConditionsRunNumber = 410000
 
 

MC23aSimulationMultipleIoV()

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

def MC23aSimulationMultipleIoV(flags):
    """
    Configure MC23a flags for simulation with multiple Intervals of Validity (IoV).
    This method is used in the Simulation step only.
    """
    MC23SimulationNoIoV(flags)
    flags.Input.MCCampaign = Campaign.MC23a
 
    flags.Input.OverrideRunNumber = True
 
    from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
    generateRunAndLumiProfile(flags,
                              profile='RunDependentSimData.PileUpProfile_run410000_MC23a_MultiBeamspot')
 
 

MC23aSimulationMultipleIoVCalibrationHits()

def python.MC23.MC23aSimulationMultipleIoVCalibrationHits

(

flags

)

MC23 flags for simulation with CalibrationHits

Definition at line 651 of file MC23.py.

def MC23aSimulationMultipleIoVCalibrationHits(flags):
    """MC23 flags for simulation with CalibrationHits"""
    MC23aSimulationMultipleIoV(flags)
    from SimuJobTransforms import CalHits, ParticleID
    CalHits(flags)
    ParticleID(flags)
 
 

MC23aSingleBeamspot()

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

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

MC23c()

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

def MC23c(flags):
    """MC23c flags for MC to match 2023 Run 3 data (initial pile-up profile estimate)"""
    _MC23PileUp(flags)
 
    flags.Input.MCCampaign = Campaign.MC23c
 
    # pile-up
    # These numbers are based upon a relative XS scaling of the high-pt slice
    # of 64%, which leads to a relative high-pt / low-pt sampling of
    # 0.001953314389 / 0.9980466856. Those numbers are then multiplied by 90.5
    # to follow pile-up profile. Only a relevant number of significant digits
    # are kept.
    flags.Digitization.PU.NumberOfLowPtMinBias = 90.323
    flags.Digitization.PU.NumberOfHighPtMinBias = 0.177
    flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructure_Fill7314_BCMSPattern_Flat'
    flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run450000_MC23c_MultiBeamspot'
 
 

MC23cSimulationMultipleIoV()

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

def MC23cSimulationMultipleIoV(flags):
    """
    Configure MC23c flags for simulation with multiple Intervals of Validity (IoV).
    This method is used in the Simulation step only.
    """
    MC23SimulationNoIoV(flags)
    flags.Input.MCCampaign = Campaign.MC23c
 
    flags.Input.OverrideRunNumber = True
 
    from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
    generateRunAndLumiProfile(flags,
                              profile='RunDependentSimData.PileUpProfile_run450000_MC23c_MultiBeamspot')
 
 

MC23cSimulationMultipleIoVCalibrationHits()

def python.MC23.MC23cSimulationMultipleIoVCalibrationHits

(

flags

)

MC23 flags for simulation with CalibrationHits

Definition at line 659 of file MC23.py.

def MC23cSimulationMultipleIoVCalibrationHits(flags):
    """MC23 flags for simulation with CalibrationHits"""
    MC23cSimulationMultipleIoV(flags)
    from SimuJobTransforms import CalHits, ParticleID
    CalHits(flags)
    ParticleID(flags)
 
 

MC23cSingleBeamspot()

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

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

MC23d()

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

def 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)"""
    _MC23PileUp(flags)
 
    flags.Input.MCCampaign = Campaign.MC23d
 
    # pile-up
    # These numbers are based upon a relative XS scaling of the high-pt slice
    # of 64%, which leads to a relative high-pt / low-pt sampling of
    # 0.001953314389 / 0.9980466856. Those numbers are then multiplied by 95.5
    # to follow pile-up profile. Only a relevant number of significant digits
    # are kept.
    flags.Digitization.PU.NumberOfLowPtMinBias = 95.313
    flags.Digitization.PU.NumberOfHighPtMinBias = 0.187
    flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructure_Fill7314_BCMSPattern_Flat'
    flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run450000_MC23d_MultiBeamspot' 
 
 

MC23dNoPileUp()

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

def MC23dNoPileUp(flags):
    """
    Configure MC23d flags for Monte Carlo simulations without pile-up.
    This method is used in the Digi-Reco step only.
    """
    _MC23NoPileUp(flags)
 
    flags.Input.MCCampaign = Campaign.MC23d
    flags.Input.ConditionsRunNumber = 450000
 
 

MC23dSimulationLowMuLowB()

def python.MC23.MC23dSimulationLowMuLowB

(

flags

)

MC23 flags for simulation of special run 460348

Definition at line 558 of file MC23.py.

def MC23dSimulationLowMuLowB(flags):
    """MC23 flags for simulation of special run 460348"""
    MC23SimulationNoIoV(flags)
    flags.Input.MCCampaign = Campaign.MC23d
 
    flags.Input.RunNumbers = [465000]
    flags.Input.OverrideRunNumber = True
    flags.Input.LumiBlockNumber = [1] # dummy value
 
    # B-field configuration
    flags.BField.configuredSolenoidFieldScale = 0.4
 
 

MC23dSingleBeamspot()

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

def 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)"""
    MC23d(flags)
 
    # override only pile-up profile
    flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run450000_MC23d_SingleBeamspot' 
 

MC23e()

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

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

MC23eNoPileUp()

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

def MC23eNoPileUp(flags):
    """
    Configure MC23e flags for Monte Carlo simulations without pile-up.
    This method is used in the Digi-Reco step only.
    """
    _MC23NoPileUp(flags)
 
    flags.Input.MCCampaign = Campaign.MC23e
    flags.Input.ConditionsRunNumber = 470000
 
 

MC23eSimulationMultipleIoV()

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

def MC23eSimulationMultipleIoV(flags):
    """
    Configure MC23e flags for simulation with multiple Intervals of Validity (IoV).
    This method is used in the Simulation step only.
    """
    MC23SimulationNoIoV(flags)
    flags.Input.MCCampaign = Campaign.MC23e
 
    flags.Input.OverrideRunNumber = True
 
    from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
    generateRunAndLumiProfile(flags,
                              profile='RunDependentSimData.PileUpProfile_run470000_MC23e_MultiBeamspot')
 
 

MC23eSimulationMultipleIoVCalibrationHits()

def python.MC23.MC23eSimulationMultipleIoVCalibrationHits

(

flags

)

MC23e flags for simulation with CalibrationHits

Definition at line 667 of file MC23.py.

def MC23eSimulationMultipleIoVCalibrationHits(flags):
    """MC23e flags for simulation with CalibrationHits"""
    MC23eSimulationMultipleIoV(flags)
    from SimuJobTransforms import CalHits, ParticleID
    CalHits(flags)
    ParticleID(flags)
 
 

MC23eSingleBeamspot()

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

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

MC23g()

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

def MC23g(flags):
    """MC23g flags for MC to match 2025 Run 3 data (initial pile-up estimate based on broadened 2024 data )"""
    _MC23PileUp(flags)
 
    flags.Input.MCCampaign = Campaign.MC23g
 
    # pile-up
    # These numbers are based upon a relative XS scaling of the high-pt slice
    # of 64%, which leads to a relative high-pt / low-pt sampling of
    # 0.001953314389 / 0.9980466856. Those numbers are then multiplied by 98.5
    # to follow pile-up profile. Only a relevant number of significant digits
    # are kept.
    flags.Digitization.PU.NumberOfLowPtMinBias = 98.308
    flags.Digitization.PU.NumberOfHighPtMinBias = 0.192
    # TODO new bunch structure?
    flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructure_Fill7314_BCMSPattern_Flat'
    # TODO: replace with the actual mc23g profile - this is a validation PileupProfile file taken from the mc23e pileup profile
    # NB: This is the pileup profile that is used in the Digi+Reco step
    flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run495000_MC23g_MultiBeamspot_VALIDATION' 
 
 

MC23gNoPileUp()

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

def MC23gNoPileUp(flags):
    """
    Configure MC23g flags for Monte Carlo simulations without pile-up.
    This method is used in the Digi-Reco step only.
    """
    _MC23NoPileUp(flags)
 
    flags.Input.MCCampaign = Campaign.MC23g
    flags.Input.ConditionsRunNumber = 495000
 
 

MC23gSimulationMultipleIoV()

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

def MC23gSimulationMultipleIoV(flags):
    """
    Configure MC23g flags for simulation with multiple Intervals of Validity (IoV).
    This method is used in the Simulation step only.
    """
    MC23SimulationNoIoV(flags)
    flags.Input.MCCampaign = Campaign.MC23g
 
    flags.Input.OverrideRunNumber = True
 
    from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
    # TODO: replace with the actual profile, this is a fake profile copied from mc23e and used for validation purposed
    # NB: This is the pileup profile used in the Simulation step only
    generateRunAndLumiProfile(flags,
                              profile='RunDependentSimData.PileUpProfile_run495000_MC23g_MultiBeamspot_VALIDATION')
 
 

MC23gSimulationMultipleIoVCalibrationHits()

def python.MC23.MC23gSimulationMultipleIoVCalibrationHits

(

flags

)

MC23g flags for simulation with CalibrationHits

Definition at line 675 of file MC23.py.

def MC23gSimulationMultipleIoVCalibrationHits(flags):
    """MC23g flags for simulation with CalibrationHits"""
    MC23gSimulationMultipleIoV(flags)
    from SimuJobTransforms import CalHits, ParticleID
    CalHits(flags)
    ParticleID(flags)

MC23gSingleBeamspot()

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

def MC23gSingleBeamspot(flags):
    """MC23g flags for MC to match 2025 Run 3 data (initial pile-up profile estimate, single beamspot version)"""
    MC23g(flags)
 
    # override only pile-up profile
    # TODO: replace with the actual profile, this is a fake one taken from the mc23e one
    flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run495000_MC23g_SingleBeamspot_VALIDATION'
 
 

MC23HeavyIons2023()

def python.MC23.MC23HeavyIons2023

(

flags

)

MC23 flags for the 2023 Heavy Ions run

Definition at line 100 of file MC23.py.

def MC23HeavyIons2023(flags):
    """MC23 flags for the 2023 Heavy Ions run"""
    flags.Input.MCCampaign = Campaign.MC23d
 
    flags.Beam.NumberOfCollisions = 0.
    flags.Input.ConditionsRunNumber = 460000
 
    from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
    LArConfigRun3NoPileUp(flags) # TO CHECK is this actually what we want c.f. LArConfigRun3PileUp
 
    # radiation damage
    from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
    flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
 
    # pile-up
    flags.Digitization.PileUp = True
    flags.Digitization.DoXingByXingPileUp = True
    flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructureHeavyIon2022'
    flags.Digitization.PU.InitialBunchCrossing = 0
    flags.Digitization.PU.FinalBunchCrossing = 0
    flags.Digitization.PU.NumberOfCavern = 1 # We are using the Cavern Background input for the Hijing HITS-level events
 
    from HIRecConfig.HIModeFlags import HImode
    HImode(flags) # TO CHECK is it an issue if this is set for RDOtoRDOTrigger?
    flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
 
    #all
    flags.Trigger.AODEDMSet = 'AODFULL'
    flags.Trigger.triggerMenuSetup = 'Dev_HI_run3_v1_TriggerValidation_prescale'
 
 

MC23HeavyIons2023NoPileUp()

def python.MC23.MC23HeavyIons2023NoPileUp

(

flags

)

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

Definition at line 76 of file MC23.py.

def MC23HeavyIons2023NoPileUp(flags):
    """MC23 flags for the 2023 Heavy Ions run (without pile-up)"""
    flags.Input.MCCampaign = Campaign.MC23d
 
    flags.Beam.BunchSpacing = 50
    flags.Beam.NumberOfCollisions = 0.
    flags.Input.ConditionsRunNumber = 460000
 
    from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
    LArConfigRun3NoPileUp(flags)
 
    # radiation damage
    from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
    flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
 
    from HIRecConfig.HIModeFlags import HImode
    HImode(flags) # TO CHECK is it an issue if this is set for RDOtoRDOTrigger?
    flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
 
    #all
    flags.Trigger.AODEDMSet = 'AODFULL'
    flags.Trigger.triggerMenuSetup = 'Dev_HI_run3_v1_TriggerValidation_prescale'
 
 

MC23HeavyIons2024()

def python.MC23.MC23HeavyIons2024

(

flags

)

MC23 flags for the 2024 Heavy Ions run

Definition at line 228 of file MC23.py.

def MC23HeavyIons2024(flags): # FIXME This configuration is a placeholder
    """MC23 flags for the 2024 Heavy Ions run"""
    flags.Input.MCCampaign = Campaign.MC23e
 
    flags.Beam.NumberOfCollisions = 0.
    flags.Input.ConditionsRunNumber = 488600
 
    from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
    LArConfigRun3NoPileUp(flags) # TO CHECK is this actually what we want c.f. LArConfigRun3PileUp
 
    # radiation damage
    from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
    flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
 
    # pile-up
    flags.Digitization.PileUp = True
    flags.Digitization.DoXingByXingPileUp = True
    flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructureHeavyIon2022'  # New file being prepared ATLGBLCONDTAGS-182
    flags.Digitization.PU.InitialBunchCrossing = 0
    flags.Digitization.PU.FinalBunchCrossing = 0
    flags.Digitization.PU.NumberOfCavern = 1 # We are using the Cavern Background input for the Hijing HITS-level events
 
    from HIRecConfig.HIModeFlags import HImode
    HImode(flags) # TO CHECK is it an issue if this is set for RDOtoRDOTrigger?
    flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
 
    #all
    flags.Trigger.AODEDMSet = 'AODFULL'
    flags.Trigger.triggerMenuSetup = 'Dev_HI_run3_v1_TriggerValidation_prescale'
 
 

MC23HeavyIons2024NoPileUp()

def python.MC23.MC23HeavyIons2024NoPileUp

(

flags

)

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

Definition at line 204 of file MC23.py.

def MC23HeavyIons2024NoPileUp(flags): # FIXME This configuration is a placeholder
    """MC23 flags for the 2024 Heavy Ions run (without pile-up)"""
    flags.Input.MCCampaign = Campaign.MC23e
 
    flags.Beam.BunchSpacing = 50
    flags.Beam.NumberOfCollisions = 0.
    flags.Input.ConditionsRunNumber = 488600
 
    from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
    LArConfigRun3NoPileUp(flags)
 
    # radiation damage
    from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
    flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
 
    from HIRecConfig.HIModeFlags import HImode
    HImode(flags) # TO CHECK is it an issue if this is set for RDOtoRDOTrigger?
    flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
 
    #all
    flags.Trigger.AODEDMSet = 'AODFULL'
    flags.Trigger.triggerMenuSetup = 'Dev_HI_run3_v1_TriggerValidation_prescale'
 
 

MC23HeavyIons2025OO()

def python.MC23.MC23HeavyIons2025OO

(

flags

)

MC23 flags for the 2025 Heavy Ions (Oxygen) run

Definition at line 259 of file MC23.py.

def MC23HeavyIons2025OO(flags):
    """MC23 flags for the 2025 Heavy Ions (Oxygen) run"""
    flags.Input.MCCampaign = Campaign.MC23g
 
    flags.Beam.BunchSpacing = 500
    flags.Beam.NumberOfCollisions = 0.0
    flags.Input.ConditionsRunNumber = 500700 
 
    from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
    LArConfigRun3NoPileUp(flags)
 
    # radiation damage
    from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
    flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
 
    # pile-up
    flags.Digitization.PileUp = False
    flags.Digitization.DoXingByXingPileUp = False
    flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructureHeavyIon2025OO'
    flags.Digitization.PU.InitialBunchCrossing = 0
    flags.Digitization.PU.FinalBunchCrossing = 0
    flags.Digitization.PU.NumberOfCavern = 1 # We are using the Cavern Background input for the Hijing HITS-level events
 
    from HIRecConfig.HIModeFlags import HIPmode
    HIPmode(flags)
    flags.Reco.EnableZDC = False
 
    #all
    flags.Trigger.AODEDMSet = 'AODFULL'
    flags.Trigger.triggerMenuSetup = 'Dev_pp_lowMu_run3_v1_TriggerValidation_prescale'
 
 

MC23LowMu()

def python.MC23.MC23LowMu

(

flags

)

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

Definition at line 330 of file MC23.py.

def MC23LowMu(flags):
    """MC23 flags for MC to match Run 3 data with low pile-up"""
    flags.Input.MCCampaign = Campaign.MC23a
 
    flags.Beam.NumberOfCollisions = 60.
    flags.Input.ConditionsRunNumber = 410000
 
    from LArConfiguration.LArConfigRun3 import LArConfigRun3PileUp
    LArConfigRun3PileUp(flags)
 
    # radiation damage
    from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
    flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
 
    # pile-up
    # These numbers are based upon a relative XS scaling of the high-pt slice
    # of 64%, which leads to a relative high-pt / low-pt sampling of
    # 0.001953314389 / 0.9980466856. Those numbers are then multiplied by 0.05
    # to simulate low pile-up. Only a relevant number of significant digits
    # are kept.
    flags.Digitization.PU.NumberOfLowPtMinBias = 0.0499
    flags.Digitization.PU.NumberOfHighPtMinBias = 0.0001
    flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructure_Fill7314_BCMSPattern_Flat'
 
 

MC23NoPileUpLowMuLowB()

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

def MC23NoPileUpLowMuLowB(flags):
    """
    Configure MC23d flags for Monte Carlo simulations to match special run 460348.
    This method is used in the Digi-Reco step only.
    """
    _MC23NoPileUp(flags)
 
    flags.Input.MCCampaign = Campaign.MC23d
    flags.Input.ConditionsRunNumber = 465000
 
    # B-field configuration
    flags.BField.configuredSolenoidFieldScale = 0.4
 
    

MC23NoPileUpLowMuRun()

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

def 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.
    """
    _MC23NoPileUp(flags)
 
    flags.Input.MCCampaign = Campaign.MC23a
    flags.Input.ConditionsRunNumber = 420000
 
    

MC23ppReferenceRun2024()

def python.MC23.MC23ppReferenceRun2024

(

flags

)

MC23 flags for the 2024 5.36 TeV pp reference run

Definition at line 171 of file MC23.py.

def MC23ppReferenceRun2024(flags): # FIXME This configuration is a placeholder
    """MC23 flags for the 2024 5.36 TeV pp reference run"""
    flags.Input.MCCampaign = Campaign.MC23e
 
    flags.Beam.NumberOfCollisions = 0.
 
    from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
    LArConfigRun3NoPileUp(flags) # TO CHECK is this actually what we want c.f. LArConfigRun3PileUp
 
    # radiation damage
    from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
    flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
 
    # pile-up
    # These numbers are based upon a relative XS scaling of the high-pt slice
    # of 64%, which leads to a relative high-pt / low-pt sampling of
    # 0.001953314389 / 0.9980466856. Those numbers are then multiplied by 7.5
    # to follow pile-up profile. Only a relevant number of significant digits
    # are kept.
    flags.Digitization.PU.NumberOfLowPtMinBias = 7.485
    flags.Digitization.PU.NumberOfHighPtMinBias = 0.015
    flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructure_Fill7314_BCMSPattern_Flat'
    flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run488000_MC23e_SingleBeamspot'
 
    from HIRecConfig.HIModeFlags import HIPmode
    HIPmode(flags) # TO CHECK is it an issue if this is set for RDOtoRDOTrigger?
    flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
 
    #all
    flags.Trigger.AODEDMSet = 'AODFULL'
    flags.Trigger.triggerMenuSetup = 'PhysicsP1_pp_lowMu_run3_v1_TriggerValidation_prescale'
 
 

MC23Simulation2023HeavyIonRun()

def python.MC23.MC23Simulation2023HeavyIonRun

(

flags

)

MC23 flags for simulation simulation of the 2023 Heavy Ion run

Definition at line 519 of file MC23.py.

def MC23Simulation2023HeavyIonRun(flags):
    """MC23 flags for simulation simulation of the 2023 Heavy Ion run"""
    MC23SimulationNoIoV(flags)
    flags.Input.MCCampaign = Campaign.MC23d
 
    flags.Input.RunNumbers = [460000]
    flags.Input.OverrideRunNumber = True
    flags.Input.LumiBlockNumbers = [1] # dummy value
 
 

MC23Simulation2024HeavyIonRun()

def python.MC23.MC23Simulation2024HeavyIonRun

(

flags

)

MC23 flags for simulation simulation of the 2024 Heavy Ion run

Definition at line 539 of file MC23.py.

def MC23Simulation2024HeavyIonRun(flags):
    """MC23 flags for simulation simulation of the 2024 Heavy Ion run"""
    MC23SimulationNoIoV(flags)
    flags.Input.MCCampaign = Campaign.MC23e
 
    flags.Input.RunNumbers = [488600]
    flags.Input.OverrideRunNumber = True
    flags.Input.LumiBlockNumbers = [1] # dummy value
 

MC23Simulation2024ppRefRun()

def python.MC23.MC23Simulation2024ppRefRun

(

flags

)

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

Definition at line 529 of file MC23.py.

def MC23Simulation2024ppRefRun(flags):
    """MC23 flags for simulation simulation of the 2024 5.36 TeV pp reference run"""
    MC23SimulationNoIoV(flags)
    flags.Input.MCCampaign = Campaign.MC23e
 
    flags.Input.RunNumbers = [488000]
    flags.Input.OverrideRunNumber = True
    flags.Input.LumiBlockNumbers = [1] # dummy value
 
 

MC23Simulation2025OORun()

def python.MC23.MC23Simulation2025OORun

(

flags

)

MC23 flags for simulation simulation of the 2025 Oxygen Oxygen run

Definition at line 548 of file MC23.py.

def MC23Simulation2025OORun(flags):
    """MC23 flags for simulation simulation of the 2025 Oxygen Oxygen run"""
    MC23SimulationNoIoV(flags)
    flags.Input.MCCampaign = Campaign.MC23g
 
    flags.Input.RunNumbers = [500700]
    flags.Input.OverrideRunNumber = True
    flags.Input.LumiBlockNumbers = [1] # dummy value
 
 

MC23SimulationLowMuRun()

def python.MC23.MC23SimulationLowMuRun

(

flags

)

MC23 flags for low mu run simulation

Definition at line 510 of file MC23.py.

def MC23SimulationLowMuRun(flags):
    """MC23 flags for low mu run simulation"""
    MC23SimulationNoIoV(flags)
 
    flags.Input.RunNumbers = [420000]
    flags.Input.OverrideRunNumber = True
    flags.Input.LumiBlockNumbers = [1] # dummy value
 
 

MC23SimulationNoIoV()

def python.MC23.MC23SimulationNoIoV

(

flags

)

MC23 base flags for simulation without specifying conditions IoVs

Definition at line 488 of file MC23.py.

def MC23SimulationNoIoV(flags):
    """MC23 base flags for simulation without specifying conditions IoVs"""
    flags.Input.MCCampaign = Campaign.MC23a
 
    from SimulationConfig.SimEnums import TruthStrategy
    flags.Sim.PhysicsList = 'FTFP_BERT_ATL'
    flags.Sim.TruthStrategy = TruthStrategy.MC15aPlus
 
    flags.Sim.TRTRangeCut = 30.0
    flags.Sim.TightMuonStepping = True
 
    from SimulationConfig.G4Optimizations import enableBeamPipeKill, enableFrozenShowersFCalOnly
    enableBeamPipeKill(flags)
    if flags.Sim.ISF.Simulator.isFullSim():
        enableFrozenShowersFCalOnly(flags)
 
    from SimulationConfig.G4Optimizations import enableG4Optimizations
    enableG4Optimizations(flags)
 
    flags.Sim.FastCalo.ParamsInputFilename = 'FastCaloSim/MC23/TFCSparam_dev_Hybrid_Ha_v5_all_baryons_0_500.root'
 
 

MC23SimulationSingleIoV()

def python.MC23.MC23SimulationSingleIoV

(

flags

)

MC23 flags for simulation

Definition at line 571 of file MC23.py.

def MC23SimulationSingleIoV(flags):
    """MC23 flags for simulation"""
    MC23SimulationNoIoV(flags)
    flags.Input.MCCampaign = Campaign.MC23a
 
    flags.Input.RunNumbers = [410000]
    flags.Input.OverrideRunNumber = True
    flags.Input.LumiBlockNumbers = [1] # dummy value
 
 

MC23SimulationSingleIoVCalibrationHits()

def python.MC23.MC23SimulationSingleIoVCalibrationHits

(

flags

)

MC23 flags for simulation with CalibrationHits

Definition at line 643 of file MC23.py.

def MC23SimulationSingleIoVCalibrationHits(flags):
    """MC23 flags for simulation with CalibrationHits"""
    MC23SimulationSingleIoV(flags)
    from SimuJobTransforms import CalHits, ParticleID
    CalHits(flags)
    ParticleID(flags)