python.MC23 Namespace Reference

Functions
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	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	MC23SimulationNoIoV (flags)
def	MC23SimulationLowMuRun (flags)
def	MC23Simulation2023HeavyIonRun (flags)
def	MC23Simulation2024ppRefRun (flags)
def	MC23Simulation2024HeavyIonRun (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

BeamspotSplitMC23a()

def python.MC23.BeamspotSplitMC23a

(

)

MC23a beamspot splitting configuration

Definition at line 440 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 448 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 456 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 466 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 474 of file MC23.py.

def BeamspotSplitMC23g():
    """MC23g beamspot splitting configuration."""
    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 6 of file MC23.py.

def MC23a(flags):
    """MC23a flags for MC to match 2022 Run 3 data"""
    flags.Input.MCCampaign = Campaign.MC23a
 
    flags.Beam.NumberOfCollisions = 60.
 
    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 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'
 
    if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
        # ensure better randomisation of high-pt minbias events
        flags.Digitization.PU.HighPtMinBiasInputColOffset = -1
 

MC23aNoPileUp()

def python.MC23.MC23aNoPileUp

(

flags

)

MC23a flags for MC without pile-up

Definition at line 372 of file MC23.py.

def MC23aNoPileUp(flags):
    """MC23a flags for MC without pile-up"""
    MC23NoPileUp(flags)
 
 

MC23aSimulationMultipleIoV()

def python.MC23.MC23aSimulationMultipleIoV

(

flags

)

MC23 flags for simulation

Definition at line 566 of file MC23.py.

def MC23aSimulationMultipleIoV(flags):
    """MC23 flags for simulation"""
    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 623 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 294 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 34 of file MC23.py.

def MC23c(flags):
    """MC23c flags for MC to match 2023 Run 3 data (initial pile-up profile estimate)"""
    flags.Input.MCCampaign = Campaign.MC23c
 
    flags.Beam.NumberOfCollisions = 60.
 
    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 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'
 
    if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
        # ensure better randomisation of high-pt minbias events
        flags.Digitization.PU.HighPtMinBiasInputColOffset = -1
 
 

MC23cSimulationMultipleIoV()

def python.MC23.MC23cSimulationMultipleIoV

(

flags

)

MC23 flags for simulation

Definition at line 578 of file MC23.py.

def MC23cSimulationMultipleIoV(flags):
    """MC23 flags for simulation"""
    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 631 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 302 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 63 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)"""
    flags.Input.MCCampaign = Campaign.MC23d
 
    flags.Beam.NumberOfCollisions = 60.
 
    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 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' 
 
    if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
        # ensure better randomisation of high-pt minbias events
        flags.Digitization.PU.HighPtMinBiasInputColOffset = -1
 
 

MC23dNoPileUp()

def python.MC23.MC23dNoPileUp

(

flags

)

MC23d flags for MC without pile-up

Definition at line 377 of file MC23.py.

def MC23dNoPileUp(flags):
    """MC23d flags for MC without pile-up"""
    flags.Input.MCCampaign = Campaign.MC23d
 
    flags.Beam.NumberOfCollisions = 0.
    flags.Input.ConditionsRunNumber = 450000
 
    from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
    LArConfigRun3NoPileUp(flags)
 
    # radiation damage
    from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
    flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
 
 

MC23dSimulationLowMuLowB()

def python.MC23.MC23dSimulationLowMuLowB

(

flags

)

MC23 flags for simulation of special run 460348

Definition at line 543 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 310 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 147 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 )"""
    flags.Input.MCCampaign = Campaign.MC23e
 
    flags.Beam.NumberOfCollisions = 60.
 
    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 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' 
 
    if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
        # ensure better randomisation of high-pt minbias events
        flags.Digitization.PU.HighPtMinBiasInputColOffset = -1
 
 

MC23eNoPileUp()

def python.MC23.MC23eNoPileUp

(

flags

)

MC23e flags for MC without pile-up

Definition at line 392 of file MC23.py.

def MC23eNoPileUp(flags):
    """MC23e flags for MC without pile-up"""
    flags.Input.MCCampaign = Campaign.MC23e
 
    flags.Beam.NumberOfCollisions = 0.
    flags.Input.ConditionsRunNumber = 470000
 
    from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
    LArConfigRun3NoPileUp(flags)
 
    # radiation damage
    from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
    flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
 
 

MC23eSimulationMultipleIoV()

def python.MC23.MC23eSimulationMultipleIoV

(

flags

)

MC23 flags for simulation

Definition at line 590 of file MC23.py.

def MC23eSimulationMultipleIoV(flags):
    """MC23 flags for simulation"""
    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 639 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 317 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 177 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 )"""
    flags.Input.MCCampaign = Campaign.MC23g
 
    flags.Beam.NumberOfCollisions = 60.
 
    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 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 profile
    flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run470000_MC23e_MultiBeamspot' 
 
    if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
        # ensure better randomisation of high-pt minbias events
        flags.Digitization.PU.HighPtMinBiasInputColOffset = -1
 
 

MC23gNoPileUp()

def python.MC23.MC23gNoPileUp

(

flags

)

MC23g flags for MC without pile-up

Definition at line 407 of file MC23.py.

def MC23gNoPileUp(flags):
    """MC23g flags for MC without pile-up"""
    flags.Input.MCCampaign = Campaign.MC23g
 
    flags.Beam.NumberOfCollisions = 0.
    # TODO: replace with the actual run number
    flags.Input.ConditionsRunNumber = 470000
 
    from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
    LArConfigRun3NoPileUp(flags)
 
    # radiation damage
    from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
    flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
 
 

MC23gSimulationMultipleIoV()

def python.MC23.MC23gSimulationMultipleIoV

(

flags

)

MC23 flags for simulation

Definition at line 602 of file MC23.py.

def MC23gSimulationMultipleIoV(flags):
    """MC23 flags for simulation"""
    MC23SimulationNoIoV(flags)
    flags.Input.MCCampaign = Campaign.MC23g
 
    flags.Input.OverrideRunNumber = True
 
    from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
    # TODO: replace with the actual profile
    generateRunAndLumiProfile(flags,
                              profile='RunDependentSimData.PileUpProfile_run470000_MC23e_MultiBeamspot')
 
 

MC23gSimulationMultipleIoVCalibrationHits()

def python.MC23.MC23gSimulationMultipleIoVCalibrationHits

(

flags

)

MC23g flags for simulation with CalibrationHits

Definition at line 647 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 324 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
    flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run470000_MC23e_SingleBeamspot'
 

MC23HeavyIons2023()

def python.MC23.MC23HeavyIons2023

(

flags

)

MC23 flags for the 2023 Heavy Ions run

Definition at line 116 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 92 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 263 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 239 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'
 
 

MC23LowMu()

def python.MC23.MC23LowMu

(

flags

)

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

Definition at line 332 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'
 
 

MC23NoPileUp()

def python.MC23.MC23NoPileUp

(

flags

)

MC23 flags for MC without pile-up

Definition at line 357 of file MC23.py.

def MC23NoPileUp(flags):
    """MC23 flags for MC without pile-up"""
    flags.Input.MCCampaign = Campaign.MC23a
 
    flags.Beam.NumberOfCollisions = 0.
    flags.Input.ConditionsRunNumber = 410000
 
    from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
    LArConfigRun3NoPileUp(flags)
 
    # radiation damage
    from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
    flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
 
 

MC23NoPileUpLowMuLowB()

def python.MC23.MC23NoPileUpLowMuLowB

(

flags

)

MC23d flags for MC to match special run 460348

Definition at line 429 of file MC23.py.

def MC23NoPileUpLowMuLowB(flags):
    """MC23d flags for MC to match special run 460348"""
    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

)

MC23a flags for MC to match 2002 Low Mu data

Definition at line 423 of file MC23.py.

def MC23NoPileUpLowMuRun(flags):
    """MC23a flags for MC to match 2002 Low Mu data"""
    MC23NoPileUp(flags)
    flags.Input.ConditionsRunNumber = 420000
 
    

MC23ppReferenceRun2024()

def python.MC23.MC23ppReferenceRun2024

(

flags

)

MC23 flags for the 2024 5.36 TeV pp reference run

Definition at line 208 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.
    flags.Input.ConditionsRunNumber = 488000
 
    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'
 
 

MC23Simulation2023HeavyIonRun()

def python.MC23.MC23Simulation2023HeavyIonRun

(

flags

)

MC23 flags for simulation simulation of the 2023 Heavy Ion run

Definition at line 513 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 533 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 523 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
 
 

MC23SimulationLowMuRun()

def python.MC23.MC23SimulationLowMuRun

(

flags

)

MC23 flags for low mu run simulation

Definition at line 504 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 482 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 556 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 615 of file MC23.py.

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