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" , ISF_Flags.ParticleBroker())
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 getParticleBrokerSvcNoOrdering(name="ISF_ParticleBrokerSvcNoOrdering", **kwargs):
kwargs.setdefault('EntryLayerTool', 'ISF_EntryLayerTool')
kwargs.setdefault('GeoIDSvc', 'ISF_GeoIDSvc')
kwargs.setdefault('AlwaysUseGeoIDSvc', False)
from ISF_Config.ISF_jobProperties import ISF_Flags
kwargs.setdefault('ValidateGeoIDs', ISF_Flags.ValidationMode())
kwargs.setdefault('ValidationOutput', ISF_Flags.ValidationMode())
kwargs.setdefault('ValidationStreamName', "ParticleBroker")
from G4AtlasApps.SimFlags import simFlags
kwargs.setdefault('BarcodeService', simFlags.TruthStrategy.BarcodeServiceName())
return CfgMgr.ISF__ParticleBrokerDynamicOnReadIn(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" , ISF_Flags.ParticleBroker())
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 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" , ISF_Flags.ParticleBroker())
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 getStackFiller(name="ISF_StackFiller", **kwargs):
kwargs.setdefault("InputMcEventCollection" , 'GEN_EVENT' )
kwargs.setdefault("OutputMcEventCollection" , 'TruthEvent' )
kwargs.setdefault("PurgeOutputCollectionToSimulatedParticlesOnly" , False )
kwargs.setdefault("UseGeneratedParticleMass" , False )
from AthenaCommon.BeamFlags import jobproperties
if jobproperties.Beam.beamType() == "cosmics":
kwargs.setdefault("GenEventManipulators" , [
'ISF_GenEventValidityChecker',
])
kwargs.setdefault("GenParticleFilters" , [
'ISF_ParticleFinalStateFilter',
'ISF_GenParticleInteractingFilter',
])
else:
kwargs.setdefault("GenEventManipulators" , [
'ISF_GenEventValidityChecker',
'ISF_GenEventVertexPositioner',
])
kwargs.setdefault("GenParticleFilters" , [
'ISF_ParticleFinalStateFilter',
'ISF_ParticlePositionFilterDynamic',
'ISF_EtaPhiFilter',
'ISF_GenParticleInteractingFilter',
])
kwargs.setdefault("BarcodeService" , ISF_Flags.BarcodeService() )
from ISF_HepMC_Tools.ISF_HepMC_ToolsConf import ISF__GenEventStackFiller
return ISF__GenEventStackFiller(name, **kwargs)
def getGeant4SimSvc(name="ISF_Geant4SimSvc", **kwargs):
from ISF_Config.ISF_jobProperties import ISF_Flags
kwargs.setdefault('FullGeant4', False)
kwargs.setdefault('SimulationTool', 'ISFG4TransportTool')
kwargs.setdefault('Identifier', "Geant4")
kwargs.setdefault('PrintTimingInfo', ISF_Flags.DoTimeMonitoring())
return getIGeant4(**kwargs).getSimSvc()
def getGeant4Tool(name="ISF_Geant4Tool", **kwargs):
from G4AtlasApps.SimFlags import simFlags
kwargs.setdefault('RandomNumberService', simFlags.RandomSvcMT())
kwargs.setdefault('InputConverter', 'ISF_InputConverter')
kwargs.setdefault('UserActionSvc','G4UA::ISFUserActionSvc')
if hasattr(simFlags, 'RecordFlux') and simFlags.RecordFlux.statusOn:
kwargs.setdefault('RecordFlux',simFlags.RecordFlux())
# Multi-threading settinggs
from AthenaCommon.ConcurrencyFlags import jobproperties as concurrencyProps
if concurrencyProps.ConcurrencyFlags.NumThreads() > 0:
is_hive = True
else:
is_hive = False
kwargs.setdefault('MultiThreading', is_hive)
# Set commands for the G4AtlasAlg
kwargs.setdefault("G4Commands", simFlags.G4Commands.get_Value())
from ISF_Config.ISF_jobProperties import ISF_Flags
kwargs.setdefault('PrintTimingInfo' , ISF_Flags.DoTimeMonitoring() )
kwargs.setdefault('SenDetMasterTool', 'SensitiveDetectorMasterTool')
kwargs.setdefault('FastSimMasterTool', 'FastSimulationMasterTool')
from AthenaCommon import CfgMgr
# Workaround to keep other simulation flavours working while we migrate everything to be AthenaMT-compatible.
if ISF_Flags.Simulator.get_Value() in ['FullG4', 'FullG4MT', 'PassBackG4', 'PassBackG4MT', 'G4FastCalo', 'G4FastCaloMT']:
return CfgMgr.iGeant4__G4TransportTool(name, **kwargs)
else:
return CfgMgr.iGeant4__G4LegacyTransportTool(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' , ISF_Flags.ParticleBroker())
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 generate_mergeable_collection_name(bare_collection_name,
mergeable_collection_suffix,
merger_input_property):
"""
Generates and returns a collection name that is also registered to
the ISF CollectionMerger algorithm.
:param bare_collection_name: name of the collection if no merging
is taking place.
:param mergeable_collection_suffix: suffix to the collection in
case merging is taking place.
:param merger_input_property: name of the Input* property in the
CollectionMerger algorithm to add the mergeable collection to.
"""
if simFlags.ISFRun() and ISF_Flags.HITSMergingRequired():
mergeable_collection = '{bare}{suffix}'.format(
bare=bare_collection_name,
suffix=mergeable_collection_suffix
)
collection_merger = getAlgorithm('ISF_CollectionMerger')
input_attribute_name = 'Input{merger_input_property}'.format(
merger_input_property=merger_input_property)
merger_input_collections = getattr(collection_merger,
input_attribute_name)
merger_input_collections.append(mergeable_collection)
else:
mergeable_collection = bare_collection_name
return mergeable_collection
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" , ISF_Flags.ParticleBroker())
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 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" , ISF_Flags.ParticleBroker())
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 getGenEventVertexPositioner(name="ISF_GenEventVertexPositioner", **kwargs):
# GenEventVertexPositioner
from ISF_Config.ISF_jobProperties import ISF_Flags
if ISF_Flags.VertexPositionFromFile():
kwargs.setdefault("VertexShifters" , [ 'ISF_VertexPositionFromFile' ])
else:
# TODO At this point there should be the option of using the
# ISF_LongBeamspotVertexPositioner too.
kwargs.setdefault("VertexShifters" , [ 'ISF_VertexBeamCondPositioner' ])
from ISF_HepMC_Tools.ISF_HepMC_ToolsConf import ISF__GenEventVertexPositioner
return ISF__GenEventVertexPositioner(name, **kwargs)
def getKernel_GenericSimulator(name="ISF_Kernel_GenericSimulator", **kwargs):
kwargs.setdefault("InputHardScatterCollection", "BeamTruthEvent")
kwargs.setdefault("OutputHardScatterTruthCollection", "TruthEvent")
kwargs.setdefault("InputConverter", "ISF_InputConverter")
kwargs.setdefault("ParticleBroker", "ISF_ParticleBrokerSvc")
from G4AtlasApps.SimFlags import simFlags
kwargs.setdefault("TruthRecordService", simFlags.TruthStrategy.TruthServiceName())
kwargs.setdefault("SimHitService", "ISF_SimHitService")
kwargs.setdefault("MemoryMonitoringTool", "ISF_MemoryMonitor")
kwargs.setdefault("DoCPUMonitoring", ISF_Flags.DoTimeMonitoring())
kwargs.setdefault("DoMemoryMonitoring", ISF_Flags.DoMemoryMonitoring())
from ISF_Algorithms.ISF_AlgorithmsConf import ISF__SimKernel
SimKernel = ISF__SimKernel(name, **kwargs)
##FIXME shouldn't really be doing this here
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
topSequence += SimKernel
return SimKernel
def getGenericTruthService(name="ISF_TruthService", **kwargs):
from G4AtlasApps.SimFlags import simFlags
kwargs.setdefault('BarcodeSvc', simFlags.TruthStrategy.BarcodeServiceName())
kwargs.setdefault('SkipIfNoChildren', True)
kwargs.setdefault('SkipIfNoParentBarcode', True)
kwargs.setdefault('ForceEndVtxInRegions', [])
long_lived_simulators = ['LongLived', 'longLived', 'QS']
from ISF_Config.ISF_jobProperties import ISF_Flags
is_long_lived_simulation = any(x in ISF_Flags.Simulator() for x in long_lived_simulators) #FIXME this should be set in a nicer way.
if is_long_lived_simulation:
kwargs.setdefault('QuasiStableParticlesIncluded', True)
return CfgMgr.ISF__TruthSvc(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" , ISF_Flags.ParticleBroker())
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 )
def getFatrasProcessSamplingTool(name="ISF_FatrasProcessSamplingTool", **kwargs):
# random number service
from G4AtlasApps.SimFlags import simFlags
kwargs.setdefault( "RandomNumberService", simFlags.RandomSvc())
# truth record
kwargs.setdefault("TruthRecordSvc" , simFlags.TruthStrategy.TruthServiceName())
# decays
kwargs.setdefault("ParticleDecayHelper" , getPublicTool('ISF_FatrasParticleDecayHelper'))
# photon conversion
kwargs.setdefault("PhotonConversionTool" , getPublicTool('ISF_FatrasConversionCreator'))
# hadronic interactions
kwargs.setdefault("HadronicInteraction" , True)
#kwargs.setdefault("HadronicInteractionProcessor", getPublicTool('ISF_FatrasParametricHadIntProcessor'))
kwargs.setdefault("HadronicInteractionProcessor", getPublicTool('ISF_FatrasG4HadIntProcessor'))
# the validation output
kwargs.setdefault("ValidationMode" , ISF_Flags.ValidationMode())
kwargs.setdefault("PhysicsValidationTool" , getPublicTool('ISF_FatrasPhysicsValidationTool'))
from ISF_FatrasTools.ISF_FatrasToolsConf import iFatras__ProcessSamplingTool
return iFatras__ProcessSamplingTool(name, **kwargs)
def getFatrasSimEngine(name="ISF_FatrasSimEngine", **kwargs):
kwargs.setdefault("SimHitCreatorID" , getPublicTool('ISF_FatrasSimHitCreatorID'))
# TODO: G4 Tools can not be used at the same time as Geant4 inside ISF
kwargs.setdefault("ParticleDecayHelper" , getPublicTool('ISF_FatrasParticleDecayHelper'))
# the filter setup
kwargs.setdefault("TrackFilter" , getPublicTool('ISF_FatrasKinematicFilter'))
kwargs.setdefault("NeutralFilter" , getPublicTool('ISF_FatrasKinematicFilter'))
kwargs.setdefault("PhotonFilter" , getPublicTool('ISF_FatrasKinematicFilter'))
# extrapolator - test setup
kwargs.setdefault("Extrapolator" , getPublicTool('ISF_FatrasExEngine'))
#
kwargs.setdefault("ProcessSamplingTool" , getPublicTool('ISF_FatrasProcessSamplingTool'))
# set the output level
# kwargs.setdefault("OutputLevel" , ISF_FatrasFlags.OutputLevelGeneral())
# the validation
kwargs.setdefault("ValidationMode" , ISF_Flags.ValidationMode())
kwargs.setdefault("PhysicsValidationTool" , getPublicTool('ISF_FatrasPhysicsValidationTool'))
# random number service
from G4AtlasApps.SimFlags import simFlags
kwargs.setdefault( "RandomNumberService", simFlags.RandomSvc())
from ISF_FatrasTools.ISF_FatrasToolsConf import iFatras__TransportEngine
return iFatras__TransportEngine(name, **kwargs )
def configureFlagsBase():
from AthenaCommon.DetFlags import DetFlags
if not DetFlags.any_on():
# If you configure some of the DetFlags then you're
# responsible for configuring all of them.
DetFlags.all_setOn()
DetFlags.Truth_setOn() # FIXME redundant?
DetFlags.LVL1_setOff() # LVL1 is not part of G4 sim
DetFlags.Forward_setOff() # Forward dets are off by default
DetFlags.geometry.DBM_setOff()
DetFlags.geometry.sTGC_setOff()
DetFlags.geometry.Micromegas_setOff()
## Configure tasks
DetFlags.digitize.all_setOff()
DetFlags.makeRIO.all_setOff()
from G4AtlasApps.SimFlags import simFlags
if not (hasattr(simFlags, 'IsEventOverlayInputSim')
and simFlags.IsEventOverlayInputSim()):
# Unless this is an Overlay input simulation job switch off
# the overlay DetFlags.
DetFlags.overlay.all_setOff()
DetFlags.pileup.all_setOff()
DetFlags.readRDOBS.all_setOff()
DetFlags.readRDOPool.all_setOff()
DetFlags.readRIOBS.all_setOff()
DetFlags.readRIOPool.all_setOff()
DetFlags.simulateLVL1.all_setOff()
DetFlags.writeBS.all_setOff()
DetFlags.writeRDOPool.all_setOff()
DetFlags.writeRIOPool.all_setOff()
if "G4" in ISF_Flags.Simulator():
# Short-cut: if G4 is in the simulator name, then it's a pretty
# safe assumption that the configuration uses Geant4.
ISF_Flags.UsingGeant4 = True
return
#--------------------------------------------------------------
# Job setup
#--------------------------------------------------------------
theApp.EvtMax = athenaCommonFlags.EvtMax()
# all det description
include('ISF_Config/AllDet_detDescr.py')
DetFlags.Print()
if len(globalflags.ConditionsTag()):
from IOVDbSvc.CondDB import conddb
conddb.setGlobalTag(globalflags.ConditionsTag())
# Temporary work-around - see ATLASSIM-2351
if ISF_Flags.UsingGeant4():
include("G4AtlasApps/G4Atlas.flat.configuration.py") #HACK
#--------------------------------------------------------------
# Setup the ISF Services
#--------------------------------------------------------------
# --- load AuditorSvc
from AthenaCommon.ConfigurableDb import getConfigurable
# --- write out summary of the memory usage
# | number of events to be skip to detect memory leak
# | 20 is default. May need to be made larger for complete jobs.
ServiceMgr.AuditorSvc += getConfigurable("ChronoAuditor")()
# --- write out a short message upon entering or leaving each algorithm
# ServiceMgr.AuditorSvc += getConfigurable("NameAuditor")()
#
theApp.AuditAlgorithms = True
def getTrackProcessorUserActionTool(name="ISFG4TrackProcessorUserActionTool", **kwargs):
from ISF_Config.ISF_jobProperties import ISF_Flags
kwargs.setdefault('ParticleBroker' , ISF_Flags.ParticleBroker())
kwargs.setdefault('GeoIDSvc', 'ISF_GeoIDSvc' )
from ISF_Geant4Tools.ISF_Geant4ToolsConf import G4UA__iGeant4__TrackProcessorUserActionPassBackTool
return G4UA__iGeant4__TrackProcessorUserActionPassBackTool(name, **kwargs)
def TileHitsTestTool(name="TileHitsTestTool", **kwargs):
from ISF_Config.ISF_jobProperties import ISF_Flags
kwargs.setdefault("TestMBTS", ISF_Flags.UsingGeant4())
return CfgMgr.TileHitsTestTool(name, **kwargs)
def fillISFMetadata(dbFiller):
from ISF_Config.ISF_jobProperties import ISF_Flags
dbFiller.addSimParam('Simulator', ISF_Flags.Simulator())
def getSimHitService(name="ISF_SimHitService", **kwargs):
from ISF_Config.ISF_jobProperties import ISF_Flags
kwargs.setdefault('ValidationOutput', ISF_Flags.ValidationMode())
return CfgMgr.ISF__SimHitSvc(name, **kwargs)
def getTruthService(name="ISF_TruthService", **kwargs):
from ISF_Config.ISF_jobProperties import ISF_Flags
if ISF_Flags.ValidationMode():
return getValidationTruthService(name, **kwargs)
else:
return getMC12TruthService(name, **kwargs)