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

Functions

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

Function Documentation

◆ _MC23NoPileUp()

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

Definition at line 355 of file MC23.py.

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

◆ _MC23PileUp()

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

Definition at line 6 of file MC23.py.

6def _MC23PileUp(flags):
7 """MC23 flags for MC with pile-up"""
8 flags.Beam.NumberOfCollisions = 60.
9
10 from LArConfiguration.LArConfigRun3 import LArConfigRun3PileUp
11 LArConfigRun3PileUp(flags)
12
13 # radiation damage
14 from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
15 flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
16
17 if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
18 # ensure better randomisation of high-pt minbias events
19 flags.Digitization.PU.HighPtMinBiasInputColOffset = -1
20
21

◆ BeamspotSplitMC23a()

python.MC23.BeamspotSplitMC23a ( ) 
MC23a beamspot splitting configuration

Definition at line 439 of file MC23.py.

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

◆ BeamspotSplitMC23c()

python.MC23.BeamspotSplitMC23c ( ) 
MC23c beamspot splitting configuration

Definition at line 447 of file MC23.py.

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

◆ BeamspotSplitMC23d()

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

Definition at line 455 of file MC23.py.

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

◆ BeamspotSplitMC23e()

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

Definition at line 465 of file MC23.py.

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

◆ BeamspotSplitMC23g()

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

Definition at line 473 of file MC23.py.

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

◆ BeamspotSplitMC23g_VALIDATION()

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.

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

◆ MC23a()

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

Definition at line 22 of file MC23.py.

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

◆ MC23aNoPileUp()

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

Definition at line 370 of file MC23.py.

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

◆ MC23aSimulationMultipleIoV()

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

Definition at line 581 of file MC23.py.

581def MC23aSimulationMultipleIoV(flags):
582 """
583 Configure MC23a flags for simulation with multiple Intervals of Validity (IoV).
584 This method is used in the Simulation step only.
585 """
586 MC23SimulationNoIoV(flags)
587 flags.Input.MCCampaign = Campaign.MC23a
588
589 flags.Input.OverrideRunNumber = True
590
591 from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
592 generateRunAndLumiProfile(flags,
593 profile='RunDependentSimData.PileUpProfile_run410000_MC23a_MultiBeamspot')
594
595

◆ MC23aSimulationMultipleIoVCalibrationHits()

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

Definition at line 651 of file MC23.py.

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

◆ MC23aSingleBeamspot()

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

Definition at line 291 of file MC23.py.

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

◆ MC23c()

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

Definition at line 40 of file MC23.py.

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

◆ MC23cSimulationMultipleIoV()

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

Definition at line 596 of file MC23.py.

596def MC23cSimulationMultipleIoV(flags):
597 """
598 Configure MC23c flags for simulation with multiple Intervals of Validity (IoV).
599 This method is used in the Simulation step only.
600 """
601 MC23SimulationNoIoV(flags)
602 flags.Input.MCCampaign = Campaign.MC23c
603
604 flags.Input.OverrideRunNumber = True
605
606 from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
607 generateRunAndLumiProfile(flags,
608 profile='RunDependentSimData.PileUpProfile_run450000_MC23c_MultiBeamspot')
609
610

◆ MC23cSimulationMultipleIoVCalibrationHits()

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

Definition at line 659 of file MC23.py.

659def MC23cSimulationMultipleIoVCalibrationHits(flags):
660 """MC23 flags for simulation with CalibrationHits"""
661 MC23cSimulationMultipleIoV(flags)
662 from SimuJobTransforms import CalHits, ParticleID
663 CalHits(flags)
664 ParticleID(flags)
665
666

◆ MC23cSingleBeamspot()

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

Definition at line 299 of file MC23.py.

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

◆ MC23d()

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

Definition at line 58 of file MC23.py.

58def MC23d(flags):
59 """MC23d flags for MC to match 2023 Run 3 data (uses a pile-up profile based on the actual profile from 2023 data)"""
60 _MC23PileUp(flags)
61
62 flags.Input.MCCampaign = Campaign.MC23d
63
64 # pile-up
65 # These numbers are based upon a relative XS scaling of the high-pt slice
66 # of 64%, which leads to a relative high-pt / low-pt sampling of
67 # 0.001953314389 / 0.9980466856. Those numbers are then multiplied by 95.5
68 # to follow pile-up profile. Only a relevant number of significant digits
69 # are kept.
70 flags.Digitization.PU.NumberOfLowPtMinBias = 95.313
71 flags.Digitization.PU.NumberOfHighPtMinBias = 0.187
72 flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructure_Fill7314_BCMSPattern_Flat'
73 flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run450000_MC23d_MultiBeamspot'
74
75

◆ MC23dNoPileUp()

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

Definition at line 381 of file MC23.py.

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

◆ MC23dSimulationLowMuLowB()

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

Definition at line 558 of file MC23.py.

558def MC23dSimulationLowMuLowB(flags):
559 """MC23 flags for simulation of special run 460348"""
560 MC23SimulationNoIoV(flags)
561 flags.Input.MCCampaign = Campaign.MC23d
562
563 flags.Input.RunNumbers = [465000]
564 flags.Input.OverrideRunNumber = True
565 flags.Input.LumiBlockNumber = [1] # dummy value
566
567 # B-field configuration
568 flags.BField.configuredSolenoidFieldScale = 0.4
569
570

◆ MC23dSingleBeamspot()

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

Definition at line 307 of file MC23.py.

307def MC23dSingleBeamspot(flags):
308 """MC23d flags for MC to match 2023 Run 3 data (uses a pile-up profile based on the actual profile from 2023 data, single beamspot version)"""
309 MC23d(flags)
310
311 # override only pile-up profile
312 flags.Digitization.PU.ProfileConfig = 'RunDependentSimData.PileUpProfile_run450000_MC23d_SingleBeamspot'
313

◆ MC23e()

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

Definition at line 131 of file MC23.py.

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

◆ MC23eNoPileUp()

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

Definition at line 392 of file MC23.py.

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

◆ MC23eSimulationMultipleIoV()

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

Definition at line 611 of file MC23.py.

611def MC23eSimulationMultipleIoV(flags):
612 """
613 Configure MC23e flags for simulation with multiple Intervals of Validity (IoV).
614 This method is used in the Simulation step only.
615 """
616 MC23SimulationNoIoV(flags)
617 flags.Input.MCCampaign = Campaign.MC23e
618
619 flags.Input.OverrideRunNumber = True
620
621 from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
622 generateRunAndLumiProfile(flags,
623 profile='RunDependentSimData.PileUpProfile_run470000_MC23e_MultiBeamspot')
624
625

◆ MC23eSimulationMultipleIoVCalibrationHits()

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

Definition at line 667 of file MC23.py.

667def MC23eSimulationMultipleIoVCalibrationHits(flags):
668 """MC23e flags for simulation with CalibrationHits"""
669 MC23eSimulationMultipleIoV(flags)
670 from SimuJobTransforms import CalHits, ParticleID
671 CalHits(flags)
672 ParticleID(flags)
673
674

◆ MC23eSingleBeamspot()

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

Definition at line 314 of file MC23.py.

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

◆ MC23g()

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

Definition at line 150 of file MC23.py.

150def MC23g(flags):
151 """MC23g flags for MC to match 2025 Run 3 data (initial pile-up estimate based on broadened 2024 data )"""
152 _MC23PileUp(flags)
153
154 flags.Input.MCCampaign = Campaign.MC23g
155
156 # pile-up
157 # These numbers are based upon a relative XS scaling of the high-pt slice
158 # of 64%, which leads to a relative high-pt / low-pt sampling of
159 # 0.001953314389 / 0.9980466856. Those numbers are then multiplied by 98.5
160 # to follow pile-up profile. Only a relevant number of significant digits
161 # are kept.
162 flags.Digitization.PU.NumberOfLowPtMinBias = 98.308
163 flags.Digitization.PU.NumberOfHighPtMinBias = 0.192
164 # TODO new bunch structure?
165 flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructure_Fill7314_BCMSPattern_Flat'
166 # TODO: replace with the actual mc23g profile - this is a validation PileupProfile file taken from the mc23e pileup profile
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_VALIDATION'
169
170

◆ MC23gNoPileUp()

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

Definition at line 403 of file MC23.py.

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

◆ MC23gSimulationMultipleIoV()

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

Definition at line 626 of file MC23.py.

626def MC23gSimulationMultipleIoV(flags):
627 """
628 Configure MC23g flags for simulation with multiple Intervals of Validity (IoV).
629 This method is used in the Simulation step only.
630 """
631 MC23SimulationNoIoV(flags)
632 flags.Input.MCCampaign = Campaign.MC23g
633
634 flags.Input.OverrideRunNumber = True
635
636 from RunDependentSimComps.PileUpUtils import generateRunAndLumiProfile
637 # TODO: replace with the actual profile, this is a fake profile copied from mc23e and used for validation purposed
638 # NB: This is the pileup profile used in the Simulation step only
639 generateRunAndLumiProfile(flags,
640 profile='RunDependentSimData.PileUpProfile_run495000_MC23g_MultiBeamspot_VALIDATION')
641
642

◆ MC23gSimulationMultipleIoVCalibrationHits()

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

Definition at line 675 of file MC23.py.

675def MC23gSimulationMultipleIoVCalibrationHits(flags):
676 """MC23g flags for simulation with CalibrationHits"""
677 MC23gSimulationMultipleIoV(flags)
678 from SimuJobTransforms import CalHits, ParticleID
679 CalHits(flags)
680 ParticleID(flags)

◆ MC23gSingleBeamspot()

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

Definition at line 321 of file MC23.py.

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

◆ MC23HeavyIons2023()

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

Definition at line 100 of file MC23.py.

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

◆ MC23HeavyIons2023NoPileUp()

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

Definition at line 76 of file MC23.py.

76def MC23HeavyIons2023NoPileUp(flags):
77 """MC23 flags for the 2023 Heavy Ions run (without pile-up)"""
78 flags.Input.MCCampaign = Campaign.MC23d
79
80 flags.Beam.BunchSpacing = 50
81 flags.Beam.NumberOfCollisions = 0.
82 flags.Input.ConditionsRunNumber = 460000
83
84 from LArConfiguration.LArConfigRun3 import LArConfigRun3NoPileUp
85 LArConfigRun3NoPileUp(flags)
86
87 # radiation damage
88 from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
89 flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
90
91 from HIRecConfig.HIModeFlags import HImode
92 HImode(flags) # TO CHECK is it an issue if this is set for RDOtoRDOTrigger?
93 flags.Reco.EnableZDC = False # TO CHECK is this actually needed? I think it should be False by default
94
95 #all
96 flags.Trigger.AODEDMSet = 'AODFULL'
97 flags.Trigger.triggerMenuSetup = 'Dev_HI_run3_v1_TriggerValidation_prescale'
98
99

◆ MC23HeavyIons2024()

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

Definition at line 228 of file MC23.py.

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

◆ MC23HeavyIons2024NoPileUp()

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

Definition at line 204 of file MC23.py.

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

◆ MC23HeavyIons2025OO()

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

Definition at line 259 of file MC23.py.

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

◆ MC23LowMu()

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

Definition at line 330 of file MC23.py.

330def MC23LowMu(flags):
331 """MC23 flags for MC to match Run 3 data with low pile-up"""
332 flags.Input.MCCampaign = Campaign.MC23a
333
334 flags.Beam.NumberOfCollisions = 60.
335 flags.Input.ConditionsRunNumber = 410000
336
337 from LArConfiguration.LArConfigRun3 import LArConfigRun3PileUp
338 LArConfigRun3PileUp(flags)
339
340 # radiation damage
341 from SimulationConfig.SimEnums import PixelRadiationDamageSimulationType
342 flags.Digitization.PixelPlanarRadiationDamageSimulationType = PixelRadiationDamageSimulationType.RamoPotential
343
344 # pile-up
345 # These numbers are based upon a relative XS scaling of the high-pt slice
346 # of 64%, which leads to a relative high-pt / low-pt sampling of
347 # 0.001953314389 / 0.9980466856. Those numbers are then multiplied by 0.05
348 # to simulate low pile-up. Only a relevant number of significant digits
349 # are kept.
350 flags.Digitization.PU.NumberOfLowPtMinBias = 0.0499
351 flags.Digitization.PU.NumberOfHighPtMinBias = 0.0001
352 flags.Digitization.PU.BunchStructureConfig = 'RunDependentSimData.BunchStructure_Fill7314_BCMSPattern_Flat'
353
354

◆ MC23NoPileUpLowMuLowB()

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

Definition at line 425 of file MC23.py.

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

◆ MC23NoPileUpLowMuRun()

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

Definition at line 414 of file MC23.py.

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

◆ MC23ppReferenceRun2024()

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

Definition at line 171 of file MC23.py.

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

◆ MC23Simulation2023HeavyIonRun()

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

Definition at line 519 of file MC23.py.

519def MC23Simulation2023HeavyIonRun(flags):
520 """MC23 flags for simulation simulation of the 2023 Heavy Ion run"""
521 MC23SimulationNoIoV(flags)
522 flags.Input.MCCampaign = Campaign.MC23d
523
524 flags.Input.RunNumbers = [460000]
525 flags.Input.OverrideRunNumber = True
526 flags.Input.LumiBlockNumbers = [1] # dummy value
527
528

◆ MC23Simulation2024HeavyIonRun()

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

Definition at line 539 of file MC23.py.

539def MC23Simulation2024HeavyIonRun(flags):
540 """MC23 flags for simulation simulation of the 2024 Heavy Ion run"""
541 MC23SimulationNoIoV(flags)
542 flags.Input.MCCampaign = Campaign.MC23e
543
544 flags.Input.RunNumbers = [488600]
545 flags.Input.OverrideRunNumber = True
546 flags.Input.LumiBlockNumbers = [1] # dummy value
547

◆ MC23Simulation2024ppRefRun()

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.

529def MC23Simulation2024ppRefRun(flags):
530 """MC23 flags for simulation simulation of the 2024 5.36 TeV pp reference run"""
531 MC23SimulationNoIoV(flags)
532 flags.Input.MCCampaign = Campaign.MC23e
533
534 flags.Input.RunNumbers = [488000]
535 flags.Input.OverrideRunNumber = True
536 flags.Input.LumiBlockNumbers = [1] # dummy value
537
538

◆ MC23Simulation2025OORun()

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

Definition at line 548 of file MC23.py.

548def MC23Simulation2025OORun(flags):
549 """MC23 flags for simulation simulation of the 2025 Oxygen Oxygen run"""
550 MC23SimulationNoIoV(flags)
551 flags.Input.MCCampaign = Campaign.MC23g
552
553 flags.Input.RunNumbers = [500700]
554 flags.Input.OverrideRunNumber = True
555 flags.Input.LumiBlockNumbers = [1] # dummy value
556
557

◆ MC23SimulationLowMuRun()

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

Definition at line 510 of file MC23.py.

510def MC23SimulationLowMuRun(flags):
511 """MC23 flags for low mu run simulation"""
512 MC23SimulationNoIoV(flags)
513
514 flags.Input.RunNumbers = [420000]
515 flags.Input.OverrideRunNumber = True
516 flags.Input.LumiBlockNumbers = [1] # dummy value
517
518

◆ MC23SimulationNoIoV()

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

Definition at line 488 of file MC23.py.

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

◆ MC23SimulationSingleIoV()

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

Definition at line 571 of file MC23.py.

571def MC23SimulationSingleIoV(flags):
572 """MC23 flags for simulation"""
573 MC23SimulationNoIoV(flags)
574 flags.Input.MCCampaign = Campaign.MC23a
575
576 flags.Input.RunNumbers = [410000]
577 flags.Input.OverrideRunNumber = True
578 flags.Input.LumiBlockNumbers = [1] # dummy value
579
580

◆ MC23SimulationSingleIoVCalibrationHits()

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

Definition at line 643 of file MC23.py.

643def MC23SimulationSingleIoVCalibrationHits(flags):
644 """MC23 flags for simulation with CalibrationHits"""
645 MC23SimulationSingleIoV(flags)
646 from SimuJobTransforms import CalHits, ParticleID
647 CalHits(flags)
648 ParticleID(flags)
649
650
Generated on for ATLAS Offline Software by doxygen 1.14.0