def MdtCalibrationSvc(name="MdtCalibrationSvc", **kwargs):
# call dependent tools. TODO: fix in C++ (move to ServiceHandle + declareProperty)
from AthenaCommon.CfgGetter import getService
getService("MdtCalibrationDbSvc")
kwargs.setdefault("DoSlewingCorrection",
mdtCalibFlags.correctMdtRtForTimeSlewing())
# Hack to use DoTemperatureCorrection for applyRtScaling; but applyRtScaling should not be used anyway, since MLRT can be used
kwargs.setdefault("DoTemperatureCorrection",
mdtCalibFlags.applyRtScaling())
kwargs.setdefault("DoWireSagCorrection",
mdtCalibFlags.correctMdtRtWireSag())
if beamFlags.beamType() == 'collisions':
kwargs.setdefault("DoTofCorrection", True)
if globalflags.DataSource() == 'geant4':
# for collisions cut away hits that are far outside of the MDT time window
kwargs.setdefault("TimeWindowSetting",
mdtCalibWindowNumber('Collision_G4'))
elif globalflags.DataSource() == 'data':
# for collisions cut away hits that are far outside of the MDT time window
kwargs.setdefault("TimeWindowSetting",
mdtCalibWindowNumber('Collision_G4'))
else: # cosmics or single beam
kwargs.setdefault("DoTofCorrection", False)
return CfgMgr.MdtCalibrationSvc(name, **kwargs)
def MdtDriftCircleOnTrackCreator(name="MdtDriftCircleOnTrackCreator",**kwargs):
# setup dependencies missing in C++. TODO: fix in C++
getService("MdtCalibrationSvc")
getService("MdtCalibrationDbSvc")
kwargs.setdefault("DoMagneticFieldCorrection", mdtCalibFlags.correctMdtRtForBField())
kwargs.setdefault("DoWireSag", muonRecFlags.useWireSagCorrections())
kwargs.setdefault("DoSlewingCorrection", mdtCalibFlags.correctMdtRtForTimeSlewing())
if beamFlags.beamType() == 'cosmics' or beamFlags.beamType() == 'singlebeam' :
kwargs.setdefault("DoTofCorrection", False)
kwargs.setdefault("DoFixedError", True)
kwargs.setdefault("TimingMode", 1)
kwargs.setdefault("UseParametrisedError", True)
else: # collisions simulation/data settings
kwargs.setdefault("DoTofCorrection", True)
kwargs.setdefault("DoFixedError", False)
kwargs.setdefault("DoErrorScaling", False)
kwargs.setdefault("MuonTofTool", None)
kwargs.setdefault("TimeWindowSetting", mdtCalibWindowNumber('Collision_data')) # MJW: should this be Collision_G4 ???
kwargs.setdefault("UseParametrisedError", False)
if globalflags.DataSource() == 'data': # collisions real data or simulated first data
kwargs.setdefault("CreateTubeHit", True) # BroadErrors
kwargs.setdefault("UseLooseErrors", muonRecFlags.useLooseErrorTuning()) # LooseErrors on data
if globalflags.DataSource() == 'data':
kwargs.setdefault("IsMC", False)
else:
kwargs.setdefault("IsMC", True)
return CfgMgr.Muon__MdtDriftCircleOnTrackCreator(name,**kwargs)
def MuonEDMHelperSvc(name='MuonEDMHelperSvc', **kwargs):
# configure some tools that are used but are not declared as properties (they should be!)
getService("MuonIdHelperSvc")
getPublicTool("AtlasExtrapolator")
from MuonRecHelperTools.MuonRecHelperToolsConf import Muon__MuonEDMHelperSvc
return Muon__MuonEDMHelperSvc(name, **kwargs)
def getMuonSegmentToCalibSegment():
global topSequence, muonRecFlags
try:
return topSequence.MuonSegmentToCalibSegment
except AttributeError:
from MuonCalibPatRec.MuonCalibPatRecConf import MuonCalib__MuonSegmentToCalibSegment
MuonSegmentToCalibSegment = MuonCalib__MuonSegmentToCalibSegment(
"MuonSegmentToCalibSegment")
# set consistent time-of-flight correction with MdtDriftCircleOnTrackCreator
mdtCreator = getPublicTool("MdtDriftCircleOnTrackCreator")
MuonSegmentToCalibSegment.DoTOF = getProperty(mdtCreator,
"DoTofCorrection")
# when doing segment fits with floating t0's
MuonSegmentToCalibSegment.UpdateForT0Shift = type(
MuonSegmentToCalibSegment.getDefaultProperty("UpdateForT0Shift"))(
muonRecFlags.doSegmentT0Fit())
MuonSegmentToCalibSegment.UseCscSegments = False
MuonSegmentToCalibSegment.SegmentLocations = ["MuonSegments"]
MuonSegmentToCalibSegment.SegmentAuthors = [4, 8]
MuonSegmentToCalibSegment.ReadSegments = True # rather than SegmentCombinations
getService("MdtCalibrationSvc")
# finally add it to topSequence
topSequence += MuonSegmentToCalibSegment
return topSequence.MuonSegmentToCalibSegment
def getMinBiasCache(name="MinBiasCache", **kwargs):
from Digitization.DigitizationFlags import digitizationFlags
from AthenaCommon.BeamFlags import jobproperties
kwargs.setdefault('CollPerXing',
(digitizationFlags.numberOfLowPtMinBias() +
digitizationFlags.numberOfHighPtMinBias()))
kwargs.setdefault('FractionOfCache1Collisions',
(digitizationFlags.numberOfLowPtMinBias() /
(digitizationFlags.numberOfLowPtMinBias() +
digitizationFlags.numberOfHighPtMinBias())))
from Digitization import PileUpEventType
kwargs.setdefault('PileUpEventType', PileUpEventType.MinimumBias
) # may need to have a separate type in the future
if (digitizationFlags.doXingByXingPileUp()
or digitizationFlags.SignalPatternForSteppingCache.statusOn):
kwargs.setdefault('Cache1ReadDownscaleFactor', 1)
kwargs.setdefault('Cache1EventSelector',
getService('LowPtMinBiasEventSelector'))
kwargs.setdefault('Cache2ReadDownscaleFactor', 1)
kwargs.setdefault('Cache2EventSelector',
getService('HighPtMinBiasEventSelector'))
kwargs.setdefault(
'OccupationFraction',
float(digitizationFlags.bunchSpacing.get_Value()) /
float(jobproperties.Beam.bunchSpacing.get_Value()))
kwargs.setdefault('RndmGenSvc', digitizationFlags.rndmSvc())
kwargs.setdefault('RndmStreamName', "PileUpCollXingStream")
return CfgMgr.SplitBkgStreamsCache(name, **kwargs)
def getFatrasMaterialEffectsEngine(name="ISF_FatrasMaterialEffectsEngine", **kwargs):
from G4AtlasApps.SimFlags import simFlags
kwargs.setdefault("RandomNumberService" , simFlags.RandomSvc() )
kwargs.setdefault("RandomStreamName" , ISF_FatrasFlags.RandomStreamName())
kwargs.setdefault("ParticleBroker" , getService('ISF_ParticleBrokerSvc'))
kwargs.setdefault("TruthRecordSvc" , simFlags.TruthStrategy.TruthServiceName())
kwargs.setdefault("ProcessSamplingTool" , getPublicTool('ISF_FatrasProcessSamplingTool'))
kwargs.setdefault("ParticleDecayHelper" , getPublicTool('ISF_FatrasParticleDecayHelper'))
# energy loss
kwargs.setdefault("EnergyLoss" , True)
kwargs.setdefault("EnergyLossSampler" , getPublicTool('ISF_FatrasEnergyLossUpdator'))
kwargs.setdefault("UseElectronSampler" , True)
kwargs.setdefault("ElectronEnergyLossSampler" , getPublicTool('ISF_FatrasEnergyLossSamplerBetheHeitler'))
kwargs.setdefault("CreateBremPhotons" , True)
# multiple scattering
kwargs.setdefault("MultipleScattering" , True)
kwargs.setdefault("MultipleScatteringSampler" , getPublicTool('ISF_FatrasMultipleScatteringSamplerHighland'))
# the properties given throuth the JobProperties interface
kwargs.setdefault("MomentumCut" , FatrasTuningFlags.MomCutOffSec())
kwargs.setdefault("MinimumBremPhotonMomentum" , FatrasTuningFlags.MomCutOffSec())
# MCTruth Process Code
kwargs.setdefault("BremProcessCode" , 3) # TODO: to be taken from central definition
# the validation output
kwargs.setdefault("ValidationMode" , ISF_Flags.ValidationMode())
kwargs.setdefault("PhysicsValidationTool" , getPublicTool('ISF_FatrasPhysicsValidationTool'))
kwargs.setdefault("OutputPrefix", '[McME] - ')
kwargs.setdefault("OutputPostfix", ' - ')
kwargs.setdefault("OutputLevel", ISF_FatrasFlags.OutputLevelGeneral())
from ISF_FatrasTools.ISF_FatrasToolsConf import iFatras__McMaterialEffectsEngine
return iFatras__McMaterialEffectsEngine(name, **kwargs )
def MuidMaterialAllocator( name='MuidMaterialAllocator', **kwargs):
kwargs.setdefault("AggregateMaterial",True)
kwargs.setdefault("AllowReordering",False)
kwargs.setdefault("Extrapolator", getPublicTool('AtlasExtrapolator') )
kwargs.setdefault("SpectrometerExtrapolator", getPublicTool('AtlasExtrapolator'))
kwargs.setdefault("TrackingGeometrySvc", getService("AtlasTrackingGeometrySvc") )
return CfgMgr.Trk__MaterialAllocator(name,**kwargs)
def getNativeFastCaloSimSvc(name="ISF_NativeFastCaloSimSvc", **kwargs):
from ISF_FastCaloSimParametrization.ISF_NativeFastCaloSimJobProperties import ISF_NativeFastCaloSimFlags
kwargs.setdefault("BatchProcessMcTruth", False)
kwargs.setdefault("SimulateUndefinedBarcodeParticles", False)
kwargs.setdefault("Identifier", 'NativeFastCaloSim')
kwargs.setdefault("CaloCellsOutputName",
ISF_NativeFastCaloSimFlags.CaloCellsName())
kwargs.setdefault("PunchThroughTool",
getPublicTool('ISF_PunchThroughTool'))
kwargs.setdefault("DoPunchThroughSimulation", False)
kwargs.setdefault("ParticleBroker", getService('ISF_ParticleBrokerSvc'))
kwargs.setdefault("CaloCellMakerTools_setup", [
getPublicTool('ISF_EmptyCellBuilderTool'),
])
kwargs.setdefault(
"CaloCellMakerTools_release",
[
#getPublicTool('ISF_AddNoiseCellBuilderTool'),
getPublicTool('ISF_CaloCellContainerFinalizerTool'),
getPublicTool('ISF_FastHitConvertTool')
])
# let the ISF FCS flags know that FCS is being used
ISF_NativeFastCaloSimFlags.NativeFastCaloSimIsActive.set_Value_and_Lock(
True)
# register the FastCaloSim random number streams
from G4AtlasApps.SimFlags import SimFlags, simFlags
simFlags.RandomSeedList.addSeed(
ISF_NativeFastCaloSimFlags.RandomStreamName(), 98346412, 12461240)
from ISF_FastCaloSimParametrization.ISF_FastCaloSimParametrizationConf import ISF__NativeFastCaloSimSvc
return ISF__NativeFastCaloSimSvc(name, **kwargs)
def __init__(self):
from AthenaCommon import Logging
from AthenaCommon.CfgGetter import getService
self.systemActions = []
self.log = Logging.logging.getLogger('G4UAStore')
from AthenaCommon.AppMgr import ServiceMgr
##hack to allow for different named Configurations of the UserActionSvc
basename = 'UserActionSvc'
serviceName = ''
for s in ServiceMgr.getAllChildren():
if basename in s.getName():
serviceName = s.getName()
break
if '' == serviceName:
self.log.error('G4AtlasUAStore: Could not find ' + basename +
' instance in ServiceMgr!')
raise AttributeError('G4AtlasUAStore: Could not find ' + basename +
' instance in ServiceMgr!')
else:
self.log.info('G4AtlasUAStore: Found a ' + basename +
' instance called ' + serviceName)
self.theSvc = getService(serviceName)
# map roles to attributes
self.roleMap = {
'BeginOfRun': 'BeginOfRunActions',
'EndOfRun': 'EndOfRunActions',
'BeginOfEvent': 'BeginOfEventActions',
'EndOfEvent': 'EndOfEventActions',
'BeginOfTracking': 'PreTrackingActions',
'EndOfTracking': 'PostTrackingActions',
'Step': 'SteppingActions',
'Classification': 'StackingActionsClassification',
'PrepareNewEvent': 'StackingActionsPrepareNewEvent',
'NewStage': 'StackingActionsNewStage'
}
def getCavernCache(name="CavernCache", **kwargs):
from Digitization.DigitizationFlags import digitizationFlags
from AthenaCommon.BeamFlags import jobproperties
kwargs.setdefault('CollPerXing', digitizationFlags.numberOfCavern())
kwargs.setdefault('CollDistribution', "Fixed")
from Digitization import PileUpEventType
kwargs.setdefault('PileUpEventType', PileUpEventType.Cavern)
if (digitizationFlags.doXingByXingPileUp()
or digitizationFlags.SignalPatternForSteppingCache.statusOn):
kwargs.setdefault('ReadDownscaleFactor', 1)
# Cavern Background Cache Should Ignore Bunch Structure
OccupationFraction = float(
digitizationFlags.bunchSpacing.get_Value()) / float(
jobproperties.Beam.bunchSpacing.get_Value())
if digitizationFlags.BeamIntensityPattern.statusOn:
kwargs.setdefault('IgnoreBeamInt',
digitizationFlags.cavernIgnoresBeamInt.get_Value())
if digitizationFlags.cavernIgnoresBeamInt.get_Value():
OccupationFraction = 1.0
kwargs.setdefault('OccupationFraction', OccupationFraction)
kwargs.setdefault('EventSelector', getService('cavernEventSelector'))
kwargs.setdefault('RndmGenSvc', digitizationFlags.rndmSvc())
kwargs.setdefault('RndmStreamName', "PileUpCollXingStream")
#Use BkgStreamsStepCaches when using the StepArrayBM and BkgStreamsCache otherwise
if digitizationFlags.SignalPatternForSteppingCache.statusOn:
return CfgMgr.BkgStreamsStepCache(name, **kwargs)
else:
return CfgMgr.BkgStreamsCache(name, **kwargs)
def MuonTrackSummaryHelper(name="MuonTrackSummaryHelper",**kwargs):
AtlasTrackingGeometrySvc = getService("AtlasTrackingGeometrySvc")
kwargs.setdefault("TrackingGeometryName", AtlasTrackingGeometrySvc.TrackingGeometryName)
kwargs.setdefault("DoHolesOnTrack", False)
kwargs.setdefault("CalculateCloseHits", True)
from MuonTrackSummaryHelperTool.MuonTrackSummaryHelperToolConf import Muon__MuonTrackSummaryHelperTool
return Muon__MuonTrackSummaryHelperTool(name,**kwargs)
def getPunchThroughTool(name="ISF_PunchThroughTool", **kwargs):
from G4AtlasApps.SimFlags import SimFlags,simFlags
kwargs.setdefault("RandomNumberService" , simFlags.RandomSvc() )
kwargs.setdefault("RandomStreamName" , ISF_FastCaloSimFlags.RandomStreamName() )
kwargs.setdefault("FilenameLookupTable" , "CaloPunchThroughParametrisation.root" )
kwargs.setdefault("PunchThroughInitiators" , [ 211 ] )
kwargs.setdefault("PunchThroughParticles" , [ 2212, 211, 22, 11, 13 ] )
kwargs.setdefault("DoAntiParticles" , [ False, True, False, True, True ] )
kwargs.setdefault("CorrelatedParticle" , [ 211, 2212, 11, 22, 0 ] )
kwargs.setdefault("FullCorrelationEnergy" , [ 100000., 100000., 100000., 100000., 0. ] )
kwargs.setdefault("MinEnergy" , [ 938.3, 135.6, 50., 50., 105.7 ] )
kwargs.setdefault("MaxNumParticles" , [ -1, -1, -1, -1, -1 ] )
kwargs.setdefault("EnergyFactor" , [ 1., 1., 1., 1., 1. ] )
kwargs.setdefault("BarcodeSvc" , getService('ISF_LegacyBarcodeService') )
kwargs.setdefault("EnvelopeDefSvc" , getService('AtlasGeometry_EnvelopeDefSvc') )
kwargs.setdefault("BeamPipeRadius" , 500. )
from ISF_PunchThroughTools.ISF_PunchThroughToolsConf import ISF__PunchThroughTool
return ISF__PunchThroughTool(name, **kwargs )
def getParametricSimServiceID(name="ISF_ParametricSimSvc", **kwargs):
kwargs.setdefault("Identifier", "ParametricSim")
kwargs.setdefault("OutputLevel", ISF_ParSimFlags.OutputLevelGeneral())
kwargs.setdefault("ParticleSmearers",
[getPublicTool('ISF_TrackParticleSmearer')])
kwargs.setdefault("TrackingGeometrySvc",
getService("AtlasTrackingGeometrySvc"))
from ISF_ParSimServices.ISF_ParSimServicesConf import iParSim__ParametricSimSvc
return iParSim__ParametricSimSvc(name, **kwargs)
def CaloMuonScoreTool(name='CaloMuonScoreTool', **kwargs):
from TrackToCalo.TrackToCaloConf import Rec__ParticleCaloCellAssociationTool
caloCellAssociationTool = Rec__ParticleCaloCellAssociationTool(
ParticleCaloExtensionTool=getPublicTool(
"MuonParticleCaloExtensionTool"))
kwargs.setdefault("ParticleCaloCellAssociationTool",
caloCellAssociationTool)
kwargs.setdefault("CaloMuonScoreONNXRuntimeSvc",
getService("CaloMuonScoreONNXRuntimeSvc"))
return CfgMgr.CaloMuonScoreTool(name, **kwargs)
def getCaloEntryTrkExtrapolator(name="ISF_CaloEntryTrkExtrapolator", **kwargs):
kwargs.setdefault('TrackingVolumeName', 'InDet::Containers::EntryVolume')
kwargs.setdefault('TrackingGeometrySvc',
getService('AtlasTrackingGeometrySvc'))
atlasExtrapolator = getPublicTool('AtlasExtrapolator')
atlasExtrapolator.ApplyMaterialEffects = False
kwargs.setdefault('Extrapolator', atlasExtrapolator)
from ISF_TrackingTools.ISF_TrackingToolsConf import ISF__TrkExtrapolator
return ISF__TrkExtrapolator(name, **kwargs)
def _do_external(self):
""" Place to handle the external services: GeoModel, CondDB, etc.
"""
AtlasG4Eng.G4Eng.log.info('SimSkeleton :: _do_external '+\
'starting')
#from LArH6Detectors import Det_Layouts
from tbLArH6_calo import Det_Layouts
from AthenaCommon.AppMgr import ServiceMgr
from Geo2G4.Geo2G4Conf import Geo2G4Svc
Geo2G4Svc = Geo2G4Svc()
theApp.CreateSvc += ["Geo2G4Svc"]
ServiceMgr += Geo2G4Svc
# We do not use top transforms for the CTB geometry
Geo2G4Svc.GetTopTransform = False
#--- GeoModel stuff ----------------------------------------------------
from AtlasGeoModel import SetGeometryVersion
from AtlasGeoModel import GeoModelInit
from AthenaCommon.Configurable import Configurable
if Configurable.allConfigurables.get('GeoModelSvc'):
GeoModelSvc = Configurable.allConfigurables.get('GeoModelSvc')
else:
GeoModelSvc = theApp.service('GeoModelSvc')
GeoModelSvc.AlignCallbacks = False
if (DetFlags.Calo_on()):
# Common for the Calo
include(
"CaloDetMgrDetDescrCnv/CaloDetMgrDetDescrCnv_joboptions.py")
include("CaloIdCnv/CaloIdCnv_joboptions.py")
## Explicitly create DetectorGeometrySvc - temporary fix
from AthenaCommon.CfgGetter import getService
from AthenaCommon.AppMgr import ServiceMgr
ServiceMgr += getService('DetectorGeometrySvc')
ServiceMgr += getService('PhysicsListSvc')
AtlasG4Eng.G4Eng.log.info('SimSkeleton :: _do_external '+\
'done')
def MdtPrepDataProviderTool(name="MdtPrepDataProviderTool", **kwargs):
global source, include, getService
# setup dependencies which are not yet in C++
import MuonCnvExample.MuonCablingConfig
getService("MdtCalibrationSvc")
include("AmdcAth/AmdcAth_jobOptions.py")
# If we run trigger from BS, then the RDO to PRD tools need to automatically run BS to RDO tools
kwargs.setdefault("useBStoRdoTool",
DetFlags.readRDOBS.MDT_on() and recAlgs.doTrigger())
kwargs.setdefault("RawDataProviderTool", "MdtRawDataProviderTool")
### TODO: in C++ do not retrieve tool if useBStoRdoTool==False
## if not kwargs["useBStoRdoTool"]:
## kwargs["RawDataProviderTool"] = None # empty tool
if source == 'data':
kwargs.setdefault("UseTwin", True)
from MuonMDT_CnvTools.MuonMDT_CnvToolsConf import Muon__MdtRdoToPrepDataTool
return Muon__MdtRdoToPrepDataTool(name, **kwargs)
def getFatrasG4HadIntProcessor(name="ISF_FatrasG4HadIntProcessor", **kwargs):
from G4AtlasApps.SimFlags import simFlags
kwargs.setdefault("RandomNumberService" , simFlags.RandomSvc() )
kwargs.setdefault("RandomStreamName" , ISF_FatrasFlags.RandomStreamName())
kwargs.setdefault("ParticleBroker" , getService('ISF_ParticleBrokerSvc'))
kwargs.setdefault("TruthRecordSvc" , simFlags.TruthStrategy.TruthServiceName())
kwargs.setdefault("PhysicsValidationTool" , getPublicTool('ISF_FatrasPhysicsValidationTool'))
kwargs.setdefault('ValidationMode' , ISF_Flags.ValidationMode())
kwargs.setdefault("MomentumCut" , FatrasTuningFlags.MomCutOffSec())
from ISF_FatrasToolsG4.ISF_FatrasToolsG4Conf import iFatras__G4HadIntProcessor
return iFatras__G4HadIntProcessor(name, **kwargs )
def BasicPixelDigitizationTool(name="PixelDigitizationTool", **kwargs):
from AthenaCommon import CfgGetter
kwargs.setdefault("RndmSvc", digitizationFlags.rndmSvc())
streamName = kwargs.setdefault("RndmEngine", "PixelDigitization")
if not digitizationFlags.rndmSeedList.checkForExistingSeed(streamName):
digitizationFlags.rndmSeedList.addSeed(streamName, 10513239, 492615104 )
from AthenaCommon.BeamFlags import jobproperties
from AthenaCommon.Resilience import protectedInclude
from AthenaCommon.Include import include
from AthenaCommon.AppMgr import ServiceMgr
from AthenaCommon.CfgGetter import getService
protectedInclude( "PixelConditionsServices/SpecialPixelMapSvc_jobOptions.py" )
include.block( "PixelConditionsServices/SpecialPixelMapSvc_jobOptions.py" )
protectedInclude( "PixelConditionsServices/PixelDCSSvc_jobOptions.py" )
include.block( "PixelConditionsServices/PixelDCSSvc_jobOptions.py" )
protectedInclude("PixelConditionsServices/PixelCalibSvc_jobOptions.py")
from IOVDbSvc.CondDB import conddb
conddb.addFolderSplitMC("PIXEL","/PIXEL/ReadoutSpeed","/PIXEL/ReadoutSpeed")
PixelCablingSvc = getService("PixelCablingSvc")
ServiceMgr += PixelCablingSvc
print PixelCablingSvc
if not hasattr(ServiceMgr, "PixelSiPropertiesSvc"):
from SiLorentzAngleSvc.LorentzAngleSvcSetup import lorentzAngleSvc
from SiPropertiesSvc.SiPropertiesSvcConf import SiPropertiesSvc
pixelSiPropertiesSvc = SiPropertiesSvc(name = "PixelSiPropertiesSvc",DetectorName="Pixel",SiConditionsServices = lorentzAngleSvc.pixelSiliconConditionsSvc)
ServiceMgr += pixelSiPropertiesSvc
kwargs.setdefault("InputObjectName", "PixelHits")
procTools = []
chargeTools = [] #Tools in array for flexibility
feSimTools = []
if GeometryFlags.isSLHC():
procTools += ['PixelRadDamDiodeCrossTalkGenerator']
chargeTools += ['RadDamSensorSimPlanarTool']
feSimTools += ['RadDamRD53SimTool']
else:
procTools += ['PixelRadDamDiodeCrossTalkGenerator']
procTools += ['PixelRadDamChargeSmearer']
procTools += ['PixelRadDamNoisyCellGenerator']
procTools += ['PixelRadDamRandomDisabledCellGenerator']
chargeTools += ['RadDamSensorSimPlanarTool']
chargeTools += ['RadDamSensorSim3DTool']
feSimTools += ['RadDamFEI4SimTool']
feSimTools += ['RadDamFEI3SimTool']
kwargs.setdefault("PixelProcessorTools", procTools)
kwargs.setdefault("ChargeTools", chargeTools)
kwargs.setdefault("FrontEndSimTools", feSimTools)
kwargs.setdefault("EnergyDepositionTool", "RadDamEnergyDepositionTool")
if digitizationFlags.doXingByXingPileUp(): # PileUpTool approach
kwargs.setdefault("FirstXing", Pixel_FirstXing() )
kwargs.setdefault("LastXing", Pixel_LastXing() )
return CfgMgr.RadDam__PixelDigitizationTool(name, **kwargs)
def addAction(actionTool, roles, systemAction=False):
"""
Add an action tool to the list for a requested role.
This should only be used in very special cases, by experts. Normally, you
should use the getter for one of the specialized UASvc versions listed
above to add an action. If systemAction=True, the action is prepended to
the list. Otherwise, it is appended.
"""
from AthenaCommon.AppMgr import theApp, AthAppMgr, ServiceMgr
roleMap={'Run': 'RunActionTools',
'Event': 'EventActionTools',
'Tracking': 'TrackingActionTools',
'Step': 'SteppingActionTools',
'Stack': 'StackingActionTools'}
##hack to allow for different named Configurations of the UserActionSvc
basename='UserActionSvc'
serviceName=''
for s in ServiceMgr.getAllChildren():
if basename in s.getName():
serviceName = s.getName()
break
if ''==serviceName:
Logging.logging.getLogger('G4UASvc').error('addAction: Could not find ' + basename + ' instance in ServiceMgr!')
raise AttributeError('addAction: Could not find ' + basename + ' instance in ServiceMgr!')
else:
Logging.logging.getLogger('G4UASvc').info('addAction: Found a ' + basename + ' instance called ' + serviceName)
from AthenaCommon.CfgGetter import getService
theSvc=getService(serviceName)
if theApp.state() > AthAppMgr.State.CONFIGURED:
Logging.logging.getLogger('G4UASvc').fatal('Attempt to add a User Action when athena is ' +
'already initialized. Check your configuration')
return
for role in roles:
roleAttr = roleMap[role]
if not role in roleMap.keys():
Logging.logging.getLogger('G4UASvc').fatal('Unkown role '+role+' requested for action ')
else:
currentActionList = getattr(theSvc, roleAttr)
if not actionTool in currentActionList:
# Add to beginning of list if system, otherwise the end
if systemAction:
setattr(theSvc, roleAttr, [actionTool] + currentActionList)
else:
setattr(theSvc, roleAttr, currentActionList + [actionTool])
def getFatrasConversionCreator(name="ISF_FatrasConversionCreator", **kwargs):
# Fatras Hadronic Interaction Processor
# hadronic interaction creator
from G4AtlasApps.SimFlags import simFlags
kwargs.setdefault("RandomNumberService" , simFlags.RandomSvc() )
kwargs.setdefault("RandomStreamName" , ISF_FatrasFlags.RandomStreamName())
kwargs.setdefault("ParticleBroker" , getService('ISF_ParticleBrokerSvc'))
kwargs.setdefault("TruthRecordSvc" , simFlags.TruthStrategy.TruthServiceName())
kwargs.setdefault("PhysicsValidationTool" , getPublicTool('ISF_FatrasPhysicsValidationTool'))
kwargs.setdefault("PhysicsProcessCode" , 14) # TODO: to be taken from central definition
kwargs.setdefault('ValidationMode' , ISF_Flags.ValidationMode())
from ISF_FatrasTools.ISF_FatrasToolsConf import iFatras__PhotonConversionTool
return iFatras__PhotonConversionTool(name, **kwargs )
def getFatrasParticleDecayHelper(name="ISF_FatrasParticleDecayHelper", **kwargs):
from G4AtlasApps.SimFlags import simFlags
if not simFlags.RandomSeedList.checkForExistingSeed( "FatrasG4" ):
simFlags.RandomSeedList.addSeed( "FatrasG4" , 23491234, 23470291 )
kwargs.setdefault("RandomNumberService" , simFlags.RandomSvc() )
kwargs.setdefault("RandomStreamName" , ISF_FatrasFlags.RandomStreamName())
kwargs.setdefault("G4RandomStreamName" , "FatrasG4") # TODO: read stream name "FatrasG4" from Fatras jobProperties
kwargs.setdefault("ParticleBroker" , getService('ISF_ParticleBrokerSvc'))
kwargs.setdefault("ParticleTruthSvc", simFlags.TruthStrategy.TruthServiceName())
kwargs.setdefault("PDGToG4ParticleConverter", getPublicTool('ISF_FatrasPdgG4Particle'))
# the validation output
kwargs.setdefault("ValidationMode" , ISF_Flags.ValidationMode())
kwargs.setdefault("PhysicsValidationTool" , getPublicTool('ISF_FatrasPhysicsValidationTool'))
#kwargs.setdefault("G4RunManagerHelper" , getPublicTool('ISF_G4RunManagerHelper'))
from ISF_FatrasToolsG4.ISF_FatrasToolsG4Conf import iFatras__G4ParticleDecayHelper
return iFatras__G4ParticleDecayHelper(name, **kwargs )
def getHighPtMinBiasCache(name="HighPtMinBiasCache", **kwargs):
from Digitization.DigitizationFlags import digitizationFlags
from AthenaCommon.BeamFlags import beamFlags
kwargs.setdefault('CollPerXing', digitizationFlags.numberOfHighPtMinBias() )
from Digitization import PileUpEventType
kwargs.setdefault('PileUpEventType', PileUpEventType.HighPtMinimumBias ) # may need to have a separate type in the future
kwargs.setdefault('ReadDownscaleFactor', 1 )
kwargs.setdefault('EventSelector', getService('HighPtMinBiasEventSelector') )
kwargs.setdefault('OccupationFraction', float(digitizationFlags.bunchSpacing.get_Value())/float(beamFlags.bunchSpacing.get_Value()) )
kwargs.setdefault('RndmGenSvc', digitizationFlags.rndmSvc() )
kwargs.setdefault('RndmStreamName', "PileUpCollXingStream" )
#Use BkgStreamsStepCaches when using the StepArrayBM and BkgStreamsCache otherwise
if digitizationFlags.SignalPatternForSteppingCache.statusOn:
return CfgMgr.BkgStreamsStepCache(name, **kwargs)
else:
return CfgMgr.BkgStreamsCache(name, **kwargs)
def getFatrasParametricHadIntProcessor(name="ISF_FatrasParametricHadIntProcessor", **kwargs):
from G4AtlasApps.SimFlags import simFlags
# Fatras Hadronic Interaction Processor
# hadronic interaction creator
kwargs.setdefault("RandomNumberService" , simFlags.RandomSvc() )
kwargs.setdefault("RandomStreamName" , ISF_FatrasFlags.RandomStreamName())
kwargs.setdefault("ParticleBroker" , getService('ISF_ParticleBrokerSvc'))
kwargs.setdefault("TruthRecordSvc" , simFlags.TruthStrategy.TruthServiceName())
kwargs.setdefault("HadronicInteractionScaleFactor" , FatrasTuningFlags.HadronicInteractionProbabilityScalor())
kwargs.setdefault("MinimumHadronicInitialEnergy" , FatrasTuningFlags.MomCutOffSec())
kwargs.setdefault("MinimumHadronicOutEnergy" , FatrasTuningFlags.MomCutOffSec())
kwargs.setdefault("HadronicInteractionValidation" , False)
kwargs.setdefault("PhysicsProcessCode" , 121) # TODO: to be taken from central definition
kwargs.setdefault("PhysicsValidationTool" , getPublicTool('ISF_FatrasPhysicsValidationTool'))
kwargs.setdefault('ValidationMode' , ISF_Flags.ValidationMode())
from ISF_FatrasTools.ISF_FatrasToolsConf import iFatras__HadIntProcessorParametric
return iFatras__HadIntProcessorParametric(name, **kwargs )
def MuonCombinedTrackFitter( name="MuonCombinedTrackFitter", **kwargs ):
kwargs.setdefault("ExtrapolationTool" , getPublicTool("AtlasExtrapolator") )
kwargs.setdefault("NavigatorTool" , getPublicTool("MuonNavigator") )
kwargs.setdefault("PropagatorTool" , getPublicTool("MuonCombinedPropagator") )
kwargs.setdefault("RotCreatorTool" , getPublicTool("MuonRotCreator") )
kwargs.setdefault("MeasurementUpdateTool" , getPublicTool("MuonMeasUpdator") )
kwargs.setdefault("TrackingGeometrySvc" , getService("AtlasTrackingGeometrySvc") )
kwargs.setdefault("ExtrapolatorMaterial" , True )
kwargs.setdefault("MuidTool" , getPublicTool("MuidMaterialEffectsOnTrackProvider") )
kwargs.setdefault("MuidToolParam" , None )
if jobproperties.Beam.beamType()=='collisions':
kwargs.setdefault("MuidToolParam" , getPublicTool("MuidMaterialEffectsOnTrackProviderParam" ) )
kwargs.setdefault("MuidMat" , True )
kwargs.setdefault("StraightLine" , not jobproperties.BField.solenoidOn() and not jobproperties.BField.allToroidOn() )
kwargs.setdefault("MaxIterations" , 50 )
kwargs.setdefault("GetMaterialFromTrack" , jobproperties.BField.solenoidOn() and jobproperties.BField.allToroidOn() )
kwargs.setdefault("RecalculateDerivatives", False)
kwargs.setdefault("UseCaloTG" , True) #
return CfgMgr.Trk__GlobalChi2Fitter(name,**kwargs)
def getFatrasMaterialUpdator(name="ISF_FatrasMaterialUpdator", **kwargs):
from G4AtlasApps.SimFlags import simFlags
from TrkDetDescrSvc.AtlasTrackingGeometrySvc import AtlasTrackingGeometrySvc
kwargs.setdefault("RandomNumberService" , simFlags.RandomSvc() )
kwargs.setdefault("RandomStreamName" , ISF_FatrasFlags.RandomStreamName())
kwargs.setdefault("ParticleBroker" , getService('ISF_ParticleBrokerSvc'))
kwargs.setdefault("TruthRecordSvc" , simFlags.TruthStrategy.TruthServiceName())
# hadronic interactions
kwargs.setdefault("HadronicInteraction" , True)
#kwargs.setdefault("HadronicInteractionProcessor", getPublicTool('ISF_FatrasParametricHadIntProcessor'))
kwargs.setdefault("HadronicInteractionProcessor", getPublicTool('ISF_FatrasG4HadIntProcessor'))
# enrgy loss
kwargs.setdefault("EnergyLoss" , True)
kwargs.setdefault("EnergyLossUpdator" , getPublicTool('ISF_FatrasEnergyLossUpdator'))
# mutiple scattering
kwargs.setdefault("MultipleScattering" , True)
kwargs.setdefault("MultipleScatteringUpdator" , getPublicTool('ISF_FatrasMultipleScatteringUpdator'))
# photon conversion
kwargs.setdefault("PhotonConversionTool" , getPublicTool('ISF_FatrasConversionCreator'))
# the validation output
kwargs.setdefault("ValidationMode" , ISF_Flags.ValidationMode())
kwargs.setdefault("BremPhotonValidation" , False)
kwargs.setdefault("EnergyDepositValidation" , False)
# the properties given throuth the JobProperties interface
kwargs.setdefault("MomentumCut" , FatrasTuningFlags.MomCutOffSec())
kwargs.setdefault("MinimumBremPhotonMomentum" , FatrasTuningFlags.MomCutOffSec())
#
kwargs.setdefault("PhysicsValidationTool" , getPublicTool('ISF_FatrasPhysicsValidationTool'))
kwargs.setdefault("ProcessSamplingTool" , getPublicTool('ISF_FatrasProcessSamplingTool'))
kwargs.setdefault("ParticleDecayHelper" , getPublicTool('ISF_FatrasParticleDecayHelper'))
# MCTruth Process Code
kwargs.setdefault("BremProcessCode" , 3) # TODO: to be taken from central definition
kwargs.setdefault("TrackingGeometrySvc" , AtlasTrackingGeometrySvc)
from ISF_FatrasTools.ISF_FatrasToolsConf import iFatras__McMaterialEffectsUpdator
return iFatras__McMaterialEffectsUpdator(name, **kwargs )
# block include this file, many package will want to setup cabling
include.block('InDetRecExample/InDetRecCabling.py')
from InDetRecExample.InDetJobProperties import InDetFlags
if not ('conddb' in dir()):
IOVDbSvc = Service("IOVDbSvc")
from IOVDbSvc.CondDB import conddb
#
# --- Pixel cabling
#
if DetFlags.detdescr.pixel_on() and not 'PixelCabling' in dir():
from AthenaCommon.CfgGetter import getService
PixelCablingSvc = getService("PixelCablingSvc")
ServiceMgr += PixelCablingSvc
if (InDetFlags.doPrintConfigurables()):
print PixelCablingSvc
#
# --- SCT cabling
#
if DetFlags.detdescr.SCT_on() and not 'SCT_CablingSvc' in dir():
SCTCablingDataSource = 'CORACOOL'
SCTConfigurationFolderPath = '/SCT/DAQ/Config/'
#if its COMP200, use old folders...
if (conddb.dbdata == "COMP200"):
SCTConfigurationFolderPath = '/SCT/DAQ/Configuration/'
#...but now check if we want to override that decision with explicit flag (if there is one)
try:
if InDetFlags.ForceCoraCool():
import re
if re.match("DC1|DC2|Rome|ATLAS-DC3-01|ATLAS-DC3-02",
globalflags.DetDescrVersion()):
topSequence.TrackRecordFilter.inputName = "MuonEntryRecord"
if muonRecFlags.writeMuonExitLayer():
topSequence += TrackRecordFilter("TrackRecordFilterMuonExitLayer",
inputName="MuonExitLayer",
outputName="MuonExitLayerFilter")
# only do PRD truth if PRD's are being made
if rec.doTruth() and DetFlags.makeRIO.Muon_on():
from MuonTruthAlgs.MuonTruthAlgsConf import MuonPRD_MultiTruthMaker
topSequence += MuonPRD_MultiTruthMaker()
from AthenaCommon.CfgGetter import getService
getService("AtlasTrackingGeometrySvc")
from MuonTruthAlgs.MuonTruthAlgsConf import Muon__MuonTruthDecorationAlg
topSequence += Muon__MuonTruthDecorationAlg("MuonTruthDecorationAlg")
from AthenaCommon import CfgGetter
topSequence.MuonTruthDecorationAlg.MCTruthClassifier = CfgGetter.getPublicTool(
"MCTruthClassifier")
try:
from RecExConfig.InputFilePeeker import inputFileSummary
truthStrategy = inputFileSummary['metadata']['/Simulation/Parameters'][
'TruthStrategy']
if truthStrategy in ['MC15', 'MC18', 'MC18LLP']:
topSequence.MuonTruthDecorationAlg.BarcodeOffset = 10000000
except:
print "Failed to read /Simulation/Parameters/ metadata"
pass
#########################################################
#
# SimulationJobOptions/postInitOptions.SCTCuts5.py
# Pat Ward - adapted from postInitOptions.PixelCuts5.py by Zach Marshall
#
# For a special production to evaluate the effect of low
# energy secondaries on SCT Clustering.
#
#########################################################
atlasG4log.info("G4 SCT Config: Setting SCT cut")
from AthenaCommon.CfgGetter import getService
sctRegionTool = getService(
'DetectorGeometrySvc').RegionCreators['SCTPhysicsRegionTool']
sctRegionTool.ElectronCut = 0.005
sctRegionTool.PositronCut = 0.005
sctRegionTool.GammaCut = 0.005
#########################################################
#
# SimulationJobOptions/postInitOptions.PixelCuts100.py
# Zach Marshall
#
# For a special production to evaluate the effect of low
# energy secondaries on Pixel Clustering.
#
#########################################################
atlasG4log.info("G4 PIX Config: Setting PIX cut")
from AthenaCommon.CfgGetter import getService
pixelRegionTool = getService(
'DetectorGeometrySvc').RegionCreators['PixelPhysicsRegionTool']
pixelRegionTool.ElectronCut = 0.1
pixelRegionTool.PositronCut = 0.1
pixelRegionTool.GammaCut = 0.1
# block include this file, many package will want to setup cabling
include.block ('InDetRecExample/InDetRecCabling.py')
from InDetRecExample.InDetJobProperties import InDetFlags
if not ('conddb' in dir()):
IOVDbSvc = Service("IOVDbSvc")
from IOVDbSvc.CondDB import conddb
#
# --- Pixel cabling
#
if DetFlags.detdescr.pixel_on() and not 'PixelCabling' in dir():
from AthenaCommon.CfgGetter import getService
PixelCablingSvc = getService("PixelCablingSvc")
ServiceMgr += PixelCablingSvc
if (InDetFlags.doPrintConfigurables()):
print PixelCablingSvc
#
# --- SCT cabling
#
if DetFlags.detdescr.SCT_on() and not 'SCT_CablingSvc' in dir():
SCTCablingDataSource='CORACOOL'
SCTConfigurationFolderPath='/SCT/DAQ/Config/'
#if its COMP200, use old folders...
if (conddb.dbdata == "COMP200"):
SCTConfigurationFolderPath='/SCT/DAQ/Configuration/'
#...but now check if we want to override that decision with explicit flag (if there is one)
try:
if InDetFlags.ForceCoraCool():
