def generateFastSimulationList():
FastSimulationList=[]
from G4AtlasApps.SimFlags import simFlags
from AthenaCommon.DetFlags import DetFlags
if DetFlags.bpipe_on():
if simFlags.ForwardDetectors.statusOn and simFlags.ForwardDetectors() == 2:
FastSimulationList += ['ForwardTransportModel']
if hasattr(simFlags, 'BeamPipeSimMode') and simFlags.BeamPipeSimMode.statusOn and simFlags.BeamPipeSimMode() != "Normal":
FastSimulationList += [ 'SimpleFastKiller' ]
if DetFlags.geometry.LAr_on():
## Shower parameterization overrides the calibration hit flag
if simFlags.LArParameterization.statusOn and simFlags.LArParameterization() > 0 \
and simFlags.CalibrationRun.statusOn and simFlags.CalibrationRun.get_Value() in ['LAr','LAr+Tile','DeadLAr']:
print 'getFastSimulationMasterTool FATAL :: You requested both calibration hits and frozen showers / parameterization in the LAr.'
print ' Such a configuration is not allowed, and would give junk calibration hits where the showers are modified.'
print ' Please try again with a different value of simFlags.LArParameterization or simFlags.CalibrationRun '
raise RuntimeError('Configuration not allowed')
if simFlags.LArParameterization() > 0:
#FIXME If we're only using Frozen Showers in the FCAL do we really need to set up the EMB and EMEC as well?
FastSimulationList += ['EMBFastShower', 'EMECFastShower', 'FCALFastShower', 'FCAL2FastShower']
if simFlags.LArParameterization.get_Value() > 1:
FastSimulationList += ['DeadMaterialShower']
elif simFlags.LArParameterization() is None or simFlags.LArParameterization() == 0:
print "getFastSimulationMasterTool INFO No Frozen Showers"
if DetFlags.Muon_on():
if simFlags.CavernBG.statusOn and simFlags.CavernBG.get_Value() != 'Read':
FastSimulationList += ['NeutronFastSim']
return FastSimulationList
def generateSubDetectorList():
SubDetectorList = []
from G4AtlasApps.SimFlags import simFlags
from AthenaCommon.BeamFlags import jobproperties
if jobproperties.Beam.beamType() == 'cosmics' or \
(simFlags.CavernBG.statusOn and not 'Signal' in simFlags.CavernBG.get_Value() ):
if jobproperties.Beam.beamType() == 'cosmics' and hasattr(
simFlags, "ReadTR"):
SubDetectorList += ['CosmicShortCut']
from AthenaCommon.DetFlags import DetFlags
if DetFlags.Muon_on():
SubDetectorList += ['MUONQ02'] #FIXME rename to MUON when safe
if DetFlags.ID_on():
SubDetectorList += ['IDET']
if DetFlags.Calo_on():
SubDetectorList += ['CALO']
if DetFlags.ID_on(): #HACK
if DetFlags.bpipe_on(): #HACK
SubDetectorList += ['BeamPipe'] #HACK
if DetFlags.geometry.Lucid_on():
SubDetectorList += ['Lucid']
if simFlags.ForwardDetectors.statusOn:
SubDetectorList += ['ForwardRegion']
#if DetFlags.Muon_on(): #HACK
# SubDetectorList += ['MUONQ02'] #FIXME rename to MUON when safe #HACK
#SubDetectorList += generateFwdSubDetectorList() #FIXME Fwd Detectors not supported yet.
return SubDetectorList
def getATLAS_FieldMgrList():
fieldMgrList = []
from G4AtlasApps.SimFlags import simFlags
if not simFlags.TightMuonStepping.statusOn or\
not simFlags.TightMuonStepping():
fieldMgrList += ['ATLASFieldManager']
else:
fieldMgrList += ['TightMuonsATLASFieldManager']
from AthenaCommon.DetFlags import DetFlags
if DetFlags.bpipe_on():
fieldMgrList += ['BeamPipeFieldManager']
if DetFlags.ID_on():
fieldMgrList += ['InDetFieldManager']
if DetFlags.Calo_on(
) and simFlags.MuonFieldOnlyInCalo.statusOn and simFlags.MuonFieldOnlyInCalo(
):
fieldMgrList += ['MuonsOnlyInCaloFieldManager']
if DetFlags.Muon_on():
fieldMgrList += ['MuonFieldManager']
if simFlags.ForwardDetectors.statusOn:
if DetFlags.geometry.FwdRegion_on():
fieldMgrList += [
'Q1FwdFieldManager', 'Q2FwdFieldManager', 'Q3FwdFieldManager',
'D1FwdFieldManager', 'D2FwdFieldManager', 'Q4FwdFieldManager',
'Q5FwdFieldManager', 'Q6FwdFieldManager', 'Q7FwdFieldManager',
'Q1HKickFwdFieldManager', 'Q1VKickFwdFieldManager',
'Q2HKickFwdFieldManager', 'Q2VKickFwdFieldManager',
'Q3HKickFwdFieldManager', 'Q3VKickFwdFieldManager',
'Q4VKickAFwdFieldManager', 'Q4HKickFwdFieldManager',
'Q4VKickBFwdFieldManager', 'Q5HKickFwdFieldManager',
'Q6VKickFwdFieldManager', 'FwdRegionFieldManager'
]
return fieldMgrList
def generateTrackFastSimSensitiveDetectorList():
SensitiveDetectorList=[]
from AthenaCommon.DetFlags import DetFlags
from G4AtlasApps.SimFlags import simFlags
if (DetFlags.Muon_on() and simFlags.CavernBG.statusOn and simFlags.CavernBG.get_Value() != 'Read' and 'Write' in simFlags.CavernBG.get_Value()) or (hasattr(simFlags, 'StoppedParticleFile') and simFlags.StoppedParticleFile.statusOn):
SensitiveDetectorList += [ 'TrackFastSimSD' ]
return SensitiveDetectorList
def getParticlePositionFilterDynamic(name="ISF_ParticlePositionFilterDynamic", **kwargs):
# automatically choose the best fitting filter region
if DetFlags.Muon_on():
return getParticlePositionFilterWorld(name, **kwargs)
elif DetFlags.Calo_on():
return getParticlePositionFilterCalo(name, **kwargs)
elif DetFlags.ID_on():
return getParticlePositionFilterID(name, **kwargs)
else:
return getParticlePositionFilterWorld(name, **kwargs)
def getFatrasGeometryBuilder(name="ISF_FatrasGeometryBuilder", **kwargs):
# the geometry builder alg tool
# switch on the Detectors
#kwargs.setdefault("InDetTrackingGeometry" , DetFlags.ID_on())
#kwargs.setdefault("CaloTrackingGeometry" , DetFlags.Calo_on())
#kwargs.setdefault("MuonTrackingGeometry" , DetFlags.Muon_on())
if DetFlags.ID_on():
kwargs.setdefault("InDetTrackingGeometryBuilder",getPublicTool('ISF_InDetTrackingGeometryBuilder'))
if DetFlags.Calo_on():
kwargs.setdefault("CaloTrackingGeometryBuilder" ,getPublicTool('ISF_FatrasCaloTrackingGeometryBuilder'))
if DetFlags.Muon_on():
kwargs.setdefault("MuonTrackingGeometryBuilder" ,getPublicTool('ISF_FatrasMuonTrackingGeometryBuilder'))
from TrkDetDescrTools.TrkDetDescrToolsConf import Trk__GeometryBuilder
return Trk__GeometryBuilder(name, **kwargs )
def setupMuonCalib():
global topSequence, ToolSvc
if not rec.doMuon() or not DetFlags.Muon_on():
logMuon.warning(
"Not setting up requested Muon Calibration because Muons are off")
return
logMuon.info("Setting up Muon Calibration")
try:
from MuonCnvExample.MuonCalibFlags import muonCalibFlags
muonCalibFlags.setDefaults()
configs = getCalibConfigs()
#
# MuonSegmentToCalibSegment
#
calibConfig = muonRec.allConfigs()[0].getCalibConfig(
) #muonRec.getConfig(muonCalibFlags.EventTag()).getCalibConfig()
MuonSegmentToCalibSegment = getMuonSegmentToCalibSegment()
#
# MuonCalibAlg
#
MuonCalibAlg = getMuonCalibAlg(muonCalibFlags.EventTag())
from MdtCalibTools.MdtCalibToolsConf import MuonCalib__MdtCalibTool
MuonCalibTool = MuonCalib__MdtCalibTool()
calibMode = muonCalibFlags.Mode()
if calibMode == 'regionNtuple':
from MdtCalibTools.MdtCalibToolsConf import MuonCalib__MdtCalibNtupleMakerTool
MdtCalibTool = MuonCalib__MdtCalibNtupleMakerTool()
else:
raise RuntimeError("Unknown Muon Calibration Mode: %r" % calibMode)
ToolSvc += MdtCalibTool
MuonCalibTool.MdtCalibTool = MdtCalibTool
ToolSvc += MuonCalibTool
MuonCalibAlg.MuonCalibTool = MuonCalibTool
except:
from AthenaCommon.Resilience import treatException
treatException(
"Problem in MuonCalib - Muon Calibration configuration probably incomplete"
)
def getCTB_RegionCreatorList():
regionCreatorList = []
from G4AtlasApps.SimFlags import simFlags
from AthenaCommon.DetFlags import DetFlags
## FIXME _initPR never called for SCT??
#if DetFlags.ID_on():
# if DetFlags.geometry.SCT_on():
# regionCreatorList += ['SCTSiliconPhysicsRegionTool']
if DetFlags.Calo_on():
eta = simFlags.Eta.get_Value()
if eta >= 0 and eta < 1.201:
if DetFlags.em_on():
regionCreatorList += ['EMBPhysicsRegionTool']
if DetFlags.Muon_on():
regionCreatorList += [
'DriftWallPhysicsRegionTool', 'DriftWall1PhysicsRegionTool',
'DriftWall2PhysicsRegionTool'
]
return regionCreatorList
def getATLAS_RegionCreatorList():
regionCreatorList = []
from AtlasGeoModel.CommonGMJobProperties import CommonGeometryFlags as commonGeoFlags
from AtlasGeoModel.InDetGMJobProperties import InDetGeometryFlags as geoFlags
isUpgrade = commonGeoFlags.Run() == "RUN4" or (
commonGeoFlags.Run() == "UNDEFINED" and geoFlags.isSLHC())
isRUN2 = (commonGeoFlags.Run() in [
"RUN2", "RUN3"
]) or (commonGeoFlags.Run() == "UNDEFINED" and geoFlags.isIBL())
from G4AtlasApps.SimFlags import simFlags
from AthenaCommon.DetFlags import DetFlags
if simFlags.SimulateCavern.get_Value():
regionCreatorList += [
'SX1PhysicsRegionTool', 'BedrockPhysicsRegionTool',
'CavernShaftsConcretePhysicsRegionTool'
]
#regionCreatorList += ['CavernShaftsAirPhysicsRegionTool'] # Not used currently
if DetFlags.ID_on():
if DetFlags.pixel_on():
regionCreatorList += ['PixelPhysicsRegionTool']
if DetFlags.SCT_on():
regionCreatorList += ['SCTPhysicsRegionTool']
if DetFlags.TRT_on() and not isUpgrade:
regionCreatorList += ['TRTPhysicsRegionTool']
if isRUN2:
regionCreatorList += ['TRT_ArPhysicsRegionTool'
] #'TRT_KrPhysicsRegionTool'
# FIXME dislike the ordering here, but try to maintain the same ordering as in the old configuration.
if DetFlags.bpipe_on():
if simFlags.BeamPipeSimMode.statusOn and simFlags.BeamPipeSimMode(
) != "Normal":
regionCreatorList += ['BeampipeFwdCutPhysicsRegionTool']
if simFlags.ForwardDetectors.statusOn and simFlags.ForwardDetectors(
) == 2:
regionCreatorList += ['FWDBeamLinePhysicsRegionTool']
if DetFlags.Calo_on():
if DetFlags.geometry.LAr_on():
## Shower parameterization overrides the calibration hit flag
if simFlags.LArParameterization.statusOn and simFlags.LArParameterization() > 0 \
and simFlags.CalibrationRun.statusOn and simFlags.CalibrationRun.get_Value() in ['LAr','LAr+Tile','DeadLAr']:
print(
'You requested both calibration hits and frozen showers / parameterization in the LAr.'
)
print(
' Such a configuration is not allowed, and would give junk calibration hits where the showers are modified.'
)
print(
' Please try again with a different value of either simFlags.LArParameterization ('
+ str(simFlags.LArParameterization()) +
') or simFlags.CalibrationRun (' +
str(simFlags.CalibrationRun.get_Value()) + ')')
raise RuntimeError('Configuration not allowed')
if simFlags.LArParameterization() > 0:
regionCreatorList += [
'EMBPhysicsRegionTool', 'EMECPhysicsRegionTool',
'HECPhysicsRegionTool', 'FCALPhysicsRegionTool'
]
# FIXME 'EMBPhysicsRegionTool' used for parametrization also - do we need a second instance??
regionCreatorList += [
'EMECParaPhysicsRegionTool', 'FCALParaPhysicsRegionTool',
'FCAL2ParaPhysicsRegionTool'
]
if simFlags.LArParameterization.get_Value() > 1:
regionCreatorList += [
'PreSampLArPhysicsRegionTool',
'DeadMaterialPhysicsRegionTool'
]
elif simFlags.LArParameterization(
) is None or simFlags.LArParameterization() == 0:
regionCreatorList += [
'EMBPhysicsRegionTool', 'EMECPhysicsRegionTool',
'HECPhysicsRegionTool', 'FCALPhysicsRegionTool'
]
## FIXME _initPR never called for FwdRegion??
#if simFlags.ForwardDetectors.statusOn:
# if DetFlags.geometry.FwdRegion_on():
# regionCreatorList += ['FwdRegionPhysicsRegionTool']
if DetFlags.Muon_on():
regionCreatorList += [
'DriftWallPhysicsRegionTool', 'DriftWall1PhysicsRegionTool',
'DriftWall2PhysicsRegionTool'
]
if simFlags.CavernBG.statusOn and simFlags.CavernBG.get_Value(
) != 'Read' and not (simFlags.RecordFlux.statusOn
and simFlags.RecordFlux()):
regionCreatorList += ['MuonSystemFastPhysicsRegionTool']
return regionCreatorList
# and different Tag is used
#
#################################################################################
# import the DetFlags for the setting
from AthenaCommon.DetFlags import DetFlags
CoolDataBaseFolder = '/Indet/TrackingGeo/LayerMaterial'
AtlasMaterialTag = 'InDetLayerMat_v5_'
# set the CaloTrkGeo if not set --- Calorimeter in Beta Test
if not 'CaloTrkGeo' in dir():
CaloTrkGeo=DetFlags.Calo_on()
# set the MuonTrkGeo if not set --- Muon System in Prototype state
if not 'MuonTrkGeo' in dir():
MuonTrkGeo = DetFlags.Muon_on()
# the steering for the CaloEnergyLoss tool
if not 'doCaloTrkEloss' in dir():
doCaloTrkEloss = False
if CaloTrkGeo:
CoolDataBaseFolder = '/GLOBAL/TrackingGeo/LayerMaterial'
AtlasMaterialTag = 'AtlasLayerMat_v5_'
# load the right folders (preparation for calo inclusion)
from IOVDbSvc.CondDB import conddb
if DetFlags.ID_on() and not CaloTrkGeo:
conddb.addFolder('INDET',CoolDataBaseFolder +'<tag>TagInfo/'+AtlasMaterialTag+'/GeoAtlas</tag>')
if CaloTrkGeo :
conddb.addFolder('GLOBAL',CoolDataBaseFolder +'<tag>TagInfo/'+AtlasMaterialTag+'/GeoAtlas</tag>')
def __init__(self):
from AthenaCommon.Include import include
from AthenaCommon.AppMgr import ToolSvc
##################################################################################
# The FatrasTrackingGeometry Svc fragment
#
# usage:
# include('TrkDetDescrSvc/FatrasTrackingGeometrySvc.py')
#
# + for the navigator, set the TrackingGeometryName to:
# FatrasTrackingGeometrySvc.trackingGeometryName()
#
##################################################################################
# import the DetFlags for the setting
from AthenaCommon.DetFlags import DetFlags
#################################################################################
# Material for the Geometry
#
# if only ID is switched on different COOLDB Folders
# and different Tag is used
#
#################################################################################
from TrkDetDescrSvc.TrkDetDescrJobProperties import TrkDetFlags
if TrkDetFlags.ConfigurationOutputLevel() < 3 :
print '[ Configuration : start ] *** FatrasTrackingGeometry ********************************'
print '[ TrackingGeometrySvc ]'
# check whether the material retrieval is ment to be from COOL
if TrkDetFlags.MaterialFromCool() :
# the tag names
CoolDataBaseFolder = TrkDetFlags.MaterialStoreGateKey()
AtlasMaterialTag = TrkDetFlags.MaterialTagBase()+str(TrkDetFlags.MaterialVersion())+'_'
if TrkDetFlags.ConfigurationOutputLevel() < 3 :
print '[ TrackingGeometrySvc ] Associating DB folder : ',CoolDataBaseFolder
print '[ TrackingGeometrySvc ] base material tag : ',AtlasMaterialTag
# we need the conditions interface
from IOVDbSvc.CondDB import conddb
# use a local database
if TrkDetFlags.MaterialDatabaseLocal():
# specify the local database
DataBasePath = TrkDetFlags.MaterialDatabaseLocalPath()
DataBaseName = TrkDetFlags.MaterialDatabaseLocalName()
MagicTag = TrkDetFlags.MaterialMagicTag()
DataBaseConnection = '<dbConnection>sqlite://X;schema='+DataBasePath+DataBaseName+';dbname=OFLP200</dbConnection>'
conddb.blockFolder('/GLOBAL/TrackingGeo/LayerMaterial')
conddb.addFolderWithTag('',DataBaseConnection+CoolDataBaseFolder,AtlasMaterialTag+MagicTag,force=True)
if TrkDetFlags.ConfigurationOutputLevel() < 3 :
print '[ TrackingGeometrySvc ] Using Local Database: '+DataBaseConnection
# make sure that the pool files are in the catalog
#from PoolSvc.PoolSvcConf import PoolSvc
#PoolSvc.ReadCatalog += [ DataBasePath+'PoolFileCatalog.xml' ]
elif TrkDetFlags.SLHC_Geometry() :
# set the folder to the SLHC location
CoolDataBaseFolder = '/GLOBAL/TrackingGeo/SLHC_LayerMaterial'
ctag = AtlasMaterialTag+TrkDetFlags.MaterialMagicTag()
cfoldertag = CoolDataBaseFolder+' <tag>'+ctag+'</tag>'
conddb.addFolderSplitMC('GLOBAL',cfoldertag,cfoldertag)
else :
# load the right folders (preparation for calo inclusion)
cfolder = CoolDataBaseFolder +'<tag>TagInfoMajor/'+AtlasMaterialTag+'/GeoAtlas</tag>'
conddb.addFolderSplitMC('GLOBAL',cfolder,cfolder)
#################################################################################
# The Geometry Builder
#################################################################################
# the name to register the Geometry
FatrasTrackingGeometryName = 'FatrasTrackingGeometry'
# the geometry builder alg tool
from TrkDetDescrTools.TrkDetDescrToolsConf import Trk__GeometryBuilder
FatrasGeometryBuilder = Trk__GeometryBuilder(name = 'FatrasGeometryBuilder')
# switch on the Detectors
FatrasGeometryBuilder.InDetTrackingGeometry = DetFlags.ID_on()
FatrasGeometryBuilder.CaloTrackingGeometry = DetFlags.Calo_on()
FatrasGeometryBuilder.MuonTrackingGeometry = DetFlags.Muon_on() # avoid double building of MTG
# register it to tool svc
ToolSvc += FatrasGeometryBuilder
# (ID)
if DetFlags.ID_on() :
# get hand on the ID Tracking Geometry Builder
if not TrkDetFlags.SLHC_Geometry() :
from InDetTrackingGeometry.ConfiguredInDetTrackingGeometryBuilder import ConfiguredInDetTrackingGeometryBuilder as IDGeometryBuilder
else :
from InDetTrackingGeometry.ConfiguredSLHC_InDetTrackingGeometryBuilder import ConfiguredSLHC_InDetTrackingGeometryBuilder as IDGeometryBuilder
if not TrkDetFlags.SLHC_Geometry() :
self.__InDetTrackingGeometryBuilder__ = IDGeometryBuilder(name ='InDetTrackingGeometryBuilder',
namePrefix = 'Fatras',
setLayerAssociation = False,
buildTrtStrawLayers = True)
self.__InDetTrackingGeometryBuilder__.VolumeEnclosureOuterR = 1148.
else :
self.__InDetTrackingGeometryBuilder__ = IDGeometryBuilder(name ='InDetTrackingGeometryBuilder',
namePrefix = 'Fatras',
setLayerAssociation = False)
self.__InDetTrackingGeometryBuilder__.VolumeEnclosureOuterR = 1148.
# make a public tool out of it
ToolSvc += self.__InDetTrackingGeometryBuilder__
# and give it to the Geometry Builder
FatrasGeometryBuilder.InDetTrackingGeometryBuilder = self.__InDetTrackingGeometryBuilder__
#
# (Calo)
if DetFlags.Calo_on():
from CaloTrackingGeometry.ConfiguredCaloTrackingGeometryBuilder import ConfiguredCaloTrackingGeometryBuilder as ConfiguredCaloGeo
CaloTrackingGeometryBuilder = ConfiguredCaloGeo(name = 'FatrasCaloTrackingGeometryBuilder')
CaloTrackingGeometryBuilder.RecordLayerIndexCaloSampleMap = True
# make a publid tool
ToolSvc += CaloTrackingGeometryBuilder
# and give it to the Geometry Builder
FatrasGeometryBuilder.CaloTrackingGeometryBuilder = CaloTrackingGeometryBuilder
# (Muon)
if DetFlags.Muon_on():
from MuonTrackingGeometry.ConfiguredMuonTrackingGeometry import MuonTrackingGeometryBuilder
FatrasMuonTrackingGeometryBuilder = MuonTrackingGeometryBuilder(name = 'FatrasMuonTrackingGeometryBuilder')
FatrasMuonTrackingGeometryBuilder.BarrelZ = 6783.
FatrasMuonTrackingGeometryBuilder.InnerBarrelRadius = 4255.
ToolSvc += FatrasMuonTrackingGeometryBuilder
# and give it to the Geometry Builder
FatrasGeometryBuilder.MuonTrackingGeometryBuilder = FatrasMuonTrackingGeometryBuilder
# then get the tuning parameters
from FatrasExample.FatrasTuning import FatrasTuningFlags
if FatrasTuningFlags.MaterialDistortionsX0.statusOn and \
FatrasTuningFlags.MaterialDistortionsRho.statusOn :
from TrkDetDescrSvc.TrkDetDescrSvcConf import CalibrationTrackingGeometrySvc as GeometrySvc
else :
from TrkDetDescrSvc.TrkDetDescrSvcConf import TrackingGeometrySvc as GeometrySvc
FatrasTrackingGeometrySvc = GeometrySvc(name = 'FatrasTrackingGeometrySvc')
# register the Builder
FatrasTrackingGeometrySvc.GeometryBuilder = FatrasGeometryBuilder
# and register the name under which the geometry is registered
FatrasTrackingGeometrySvc.TrackingGeometryName = FatrasTrackingGeometryName
# global scaling of the material if necessary
FatrasTrackingGeometrySvc.GlobalScaleFactor = FatrasTuningFlags.MaterialScalor()
# some flags - only works when ID is on
FatrasTrackingGeometrySvc.AssignMaterialFromCOOL = True
FatrasTrackingGeometrySvc.BuildGeometryFromTagInfo = True
# Material scaling & distortion
if FatrasTuningFlags.MaterialDistortionsX0.statusOn and \
FatrasTuningFlags.MaterialDistortionsRho.statusOn :
FatrasTrackingGeometrySvc.RandomDistortions = True
FatrasTrackingGeometrySvc.DistortionsRadiationLength = FatrasTuningFlags.MaterialDistortionsX0()
FatrasTrackingGeometrySvc.DistortionsDensity = FatrasTuningFlags.MaterialDistortionsRho()
from FatrasExample.FatrasValidation import FatrasValidationFlags
FatrasTrackingGeometrySvc.RecordDistortions = FatrasValidationFlags.MaterialDistortions()
FatrasTrackingGeometrySvc.DistortionOutputFolder = '/'+FatrasValidationFlags.ValidationStream()+'/MaterialDistortions'
# switch to the rigth CoolDB folder
FatrasTrackingGeometrySvc.InputLayerMaterialSetName = CoolDataBaseFolder
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
svcMgr += FatrasTrackingGeometrySvc
print '* [ Configuration : start ] *** FatrasTrackingGeometry ********************************'
print '* [ FatrasTrackingGeometrySvc ]'
print FatrasTrackingGeometrySvc
print '* [ GeometryBuilder ]'
print FatrasGeometryBuilder
print '* [ Configuration : end ] *** FatrasTrackingGeometry ********************************'
##################################################################################
self.__geoSvc__ = FatrasTrackingGeometrySvc
def _do_external(self):
"""Place to handle the external services: GeoModel, IOVDb,
frozen showers, etc
"""
AtlasG4Eng.G4Eng.log.verbose(
'AtlasSimSkeleton._do_external :: starting')
from AthenaCommon.AppMgr import ToolSvc, ServiceMgr
from Geo2G4.Geo2G4Conf import Geo2G4Svc
geo2G4Svc = Geo2G4Svc()
theApp.CreateSvc += ["Geo2G4Svc"]
ServiceMgr += geo2G4Svc
## Enable top transforms for the ATLAS geometry
geo2G4Svc.GetTopTransform = True
## Configure access to the BeamCondSvc if necessary. Assuming
## it should be on always as BeamEffectTransformation is
## currently always switched on, else something like this will
## be required here.
from G4AtlasApps.SimFlags import simFlags
include("InDetBeamSpotService/BeamCondSvc.py")
## GeoModel stuff
## TODO: Tidy imports etc.
from GeoModelSvc.GeoModelSvcConf import GeoModelSvc
from AthenaCommon.GlobalFlags import jobproperties
from AtlasGeoModel import SetGeometryVersion
## Forward Region Twiss files - needed before geometry setup!
if simFlags.ForwardDetectors.statusOn:
if DetFlags.geometry.FwdRegion_on():
from AthenaCommon.CfgGetter import getPublicTool
from AthenaCommon.AppMgr import ToolSvc
ToolSvc += getPublicTool("ForwardRegionProperties")
from AtlasGeoModel import GeoModelInit
from AtlasGeoModel import SimEnvelopes
from GeoModelSvc.GeoModelSvcConf import GeoModelSvc
gms = GeoModelSvc()
## Cosmics GeoModel tweaks
if jobproperties.Beam.beamType() == 'cosmics' or \
(simFlags.CavernBG.statusOn and not 'Signal' in simFlags.CavernBG.get_Value() ):
from CavernInfraGeoModel.CavernInfraGeoModelConf import CavernInfraDetectorTool
gms.DetectorTools += [CavernInfraDetectorTool()]
## Protects GeoModelSvc in the simulation from the AlignCallbacks
gms.AlignCallbacks = False
## Muon GeoModel tweaks
if DetFlags.Muon_on():
## Turn off caching in the muon system
from MuonGeoModel.MuonGeoModelConf import MuonDetectorTool
MuonDetectorTool = MuonDetectorTool()
MuonDetectorTool.FillCacheInitTime = 0 # default is 1
## Additional material in the muon system
from AGDD2GeoSvc.AGDD2GeoSvcConf import AGDDtoGeoSvc
AGDD2Geo = AGDDtoGeoSvc()
from AthenaCommon import CfgGetter
if not "MuonAGDDTool/MuonSpectrometer" in AGDD2Geo.Builders:
ToolSvc += CfgGetter.getPublicTool("MuonSpectrometer",
checkType=True)
AGDD2Geo.Builders += ["MuonAGDDTool/MuonSpectrometer"]
from AtlasGeoModel.MuonGMJobProperties import MuonGeometryFlags
if (MuonGeometryFlags.hasSTGC() and MuonGeometryFlags.hasMM()):
if not "NSWAGDDTool/NewSmallWheel" in AGDD2Geo.Builders:
ToolSvc += CfgGetter.getPublicTool("NewSmallWheel",
checkType=True)
AGDD2Geo.Builders += ["NSWAGDDTool/NewSmallWheel"]
theApp.CreateSvc += ["AGDDtoGeoSvc"]
ServiceMgr += AGDD2Geo
## Add configured GeoModelSvc to service manager
ServiceMgr += gms
## Run the geometry envelope setup earlier than GeoSD
self._do_GeoEnv() #TODO remove
AtlasG4Eng.G4Eng.log.verbose('AtlasSimSkeleton._do_external :: done')
def getHITSStreamItemList():
hitsItemList=[]
## EventInfo & TruthEvent always written by default
hitsItemList = ["EventInfo#*",
"McEventCollection#TruthEvent",
"JetCollection#*"]
from G4AtlasApps.SimFlags import simFlags
if simFlags.SimulationFlavour() is not None and 'ongLived' in simFlags.SimulationFlavour(): # to catch LongLived and longLived
hitsItemList += ["McEventCollection#GEN_EVENT"]
from PyJobTransforms.trfUtils import releaseIsOlderThan
if releaseIsOlderThan(20,0):
#Hack to maintain compatibility of G4AtlasApps trunk with
#19.2.X.Y after EDM changes in release 20.0.0.
hitsItemList += ["xAOD::JetContainer_v1#*",
"xAOD::JetAuxContainer_v1#*"]
else:
hitsItemList += ["xAOD::JetContainer#*",
"xAOD::JetAuxContainer#*"]
## Detectors
from AthenaCommon.DetFlags import DetFlags
## Inner Detector
if DetFlags.ID_on():
hitsItemList += ["SiHitCollection#*",
"TRTUncompressedHitCollection#*",
"TrackRecordCollection#CaloEntryLayer"]
## Calo
if DetFlags.Calo_on():
hitsItemList += ["CaloCalibrationHitContainer#*",
"LArHitContainer#*",
"TileHitVector#*",
#"SimpleScintillatorHitCollection#*",
"TrackRecordCollection#MuonEntryLayer"]
## Muon
if DetFlags.Muon_on():
hitsItemList += ["RPCSimHitCollection#*",
"TGCSimHitCollection#*",
"CSCSimHitCollection#*",
"MDTSimHitCollection#*",
"TrackRecordCollection#MuonExitLayer"]
## FwdRegion
if DetFlags.FwdRegion_on():
hitsItemList += ["SimulationHitCollection#*"]
## Lucid
if DetFlags.Lucid_on():
hitsItemList += ["LUCID_SimHitCollection#*"]
## ZDC
if DetFlags.ZDC_on():
hitsItemList += ["ZDC_SimPixelHit_Collection#*",
"ZDC_SimStripHit_Collection#*"]
## ALFA
if DetFlags.ALFA_on():
hitsItemList += ["ALFA_HitCollection#*","ALFA_ODHitCollection#*"]
## AFP
if DetFlags.AFP_on():
hitsItemList += ["AFP_TDSimHitCollection#*","AFP_SIDSimHitCollection#*"]
## Ancillary scintillators
#hitsItemList += ["ScintillatorHitCollection#*"]
## TimingAlg
hitsItemList +=["RecoTimingObj#EVNTtoHITS_timings"]
if simFlags.RecordStepInfo.get_Value():
hitsItemList +=["ISF_FCS_Parametrization::FCS_StepInfoCollection#MergedEventSteps"]
## add xAOD::TrackParticles output collection Parametric Simulation
if simFlags.SimulationFlavour == "ParametricSimulation":
hitsItemList +=["xAOD::TrackParticleContainer#*",
"xAOD::TrackParticleAuxContainer#*"]
## Add cosmics and test beam configuration hit persistency if required cf. geom tag
layout = simFlags.SimLayout.get_Value()
if "tb" not in layout:
from AthenaCommon.BeamFlags import jobproperties
if jobproperties.Beam.beamType() == 'cosmics' or \
(hasattr(simFlags, "WriteTR") and simFlags.WriteTR.statusOn) or \
(hasattr(simFlags, "ReadTR") and simFlags.ReadTR.statusOn):
hitsItemList += ["TrackRecordCollection#CosmicRecord", "TrackRecordCollection#CosmicPerigee"]
else:
## CTB-specific
if layout.startswith("ctb"):
if simFlags.LArFarUpstreamMaterial.statusOn and simFlags.LArFarUpstreamMaterial.get_Value():
hitsItemList.append("TrackRecordCollection#LArFarUpstreamMaterialExitLayer")
## Persistency of test-beam layout
if layout.startswith('ctb') or layout.startswith('tb_Tile2000_'):
hitsItemList += ["TBElementContainer#*"]
return hitsItemList
def sync_DetFlags(self,technologies="MDT,RPC,CSC,TGC,sTGC,Micromegas"):
self.setDefaults()
global rec
from AthenaCommon.DetFlags import DetFlags
# if Muons off, then do nothing
if not DetFlags.Muon_on() or not rec.doMuon(): return
flagsOn = []
flagsOff = [ 'readRIOBS' ] # we don't store RIO (=PRD) on bytestream ???
# Reading RDO
if rec.readRDO():
if muonRecFlags.makePRDs():
flagsOn.append( 'makeRIO' )
else:
flagsOff.append( 'makeRIO' )
if globalflags.InputFormat == 'pool' :
flagsOn.append( 'readRDOPool' )
flagsOff.append( 'readRDOBS' )
elif globalflags.InputFormat == 'bytestream':
flagsOn.append( 'readRDOBS' )
flagsOff.append( 'readRDOPool' )
else: # not reading RDO
flagsOff.append( 'makeRIO' )
# Reading ESD
if rec.readESD():
flagsOn.append( 'readRIOPool' )
else:
flagsOff.append( 'readRIOPool' )
# Writing RDO Pool
if rec.doWriteRDO():
flagsOn.append( 'writeRDOPool' )
else:
flagsOff.append( 'writeRDOPool' )
# Writing RDO bystream
if rec.doWriteBS() :
flagsOn.append( 'writeBS' )
else:
flagsOff.append( 'writeBS' )
# Writing ESD
if rec.doWriteESD():
flagsOn.append( 'writeRIOPool' )
else:
flagsOff.append( 'writeRIOPool' )
# Digitization on-the-fly
if self.doDigitization():
flagsOn.append( 'digitize' )
try:
flagsOn.remove( 'readRDOPool' )
except ValueError: # not in list
pass
try:
flagsOn.remove( 'readRDOBS' )
except ValueError: # not in list
pass
flagsOff.append( 'readRDOPool' )
flagsOff.append( 'readRDOBS' )
# very special case for normal Rome production (inspired by RecExCommon_DetFlags.py)
if 'readRIOPool' not in flagsOn:
flagsOn.append( 'readRIOPool' )
try:
flagsOff.remove( 'readRIOPool' )
except ValueError: # not in list
pass
if not rec.doWriteRDO() and 'makeRIO' not in flagsOn:
flagsOn.append( 'makeRIO' )
try:
flagsOff.remove( 'makeRIO' )
except ValueError: #not in list
pass
else:
flagsOff.append( 'digitize')
# do sync per technology for selected flags
MDT_on = self.doMDTs()
RPC_on = self.doRPCs()
CSC_on = self.doCSCs()
TGC_on = self.doTGCs()
sTGC_on = self.dosTGCs()
Micromegas_on = self.doMicromegas()
techList = technologies.split(',')
for f in flagsOn:
for tech in techList:
setOn = eval(tech+'_on')
isOn = eval("DetFlags.%s.%s_on()" % (f,tech))
if setOn:
if not isOn:
cmd = "DetFlags.%s.%s_setOn()" % (f,tech)
logMuon.info(cmd)
exec(cmd)
else: # set off
if isOn:
cmd = "DetFlags.%s.%s_setOff()" % (f,tech)
logMuon.info(cmd)
exec(cmd)
# Turn off Muon flags (row in DetFlags printout)
for f in flagsOff:
isOn = eval("DetFlags.%s.Muon_on()" % f)
if isOn:
cmd = "DetFlags.%s.Muon_setOff()" % f
logMuon.info(cmd)
exec(cmd)
ToolSvc += getPublicTool("ForwardRegionProperties")
from AtlasGeoModel import GeoModelInit
from AtlasGeoModel import SimEnvelopes
from GeoModelSvc.GeoModelSvcConf import GeoModelSvc
gms = GeoModelSvc()
## Cosmics GeoModel tweaks
if jobproperties.Beam.beamType() == 'cosmics' or \
(simFlags.CavernBG.statusOn and not 'Signal' in simFlags.CavernBG.get_Value() ):
from CavernInfraGeoModel.CavernInfraGeoModelConf import CavernInfraDetectorTool
gms.DetectorTools += [CavernInfraDetectorTool()]
## Protects GeoModelSvc in the simulation from the AlignCallbacks
gms.AlignCallbacks = False
## Muon GeoModel tweaks
if DetFlags.Muon_on():
## Turn off caching in the muon system
from MuonGeoModel.MuonGeoModelConf import MuonDetectorTool
MuonDetectorTool = MuonDetectorTool()
MuonDetectorTool.FillCacheInitTime = 0 # default is 1
if hasattr(simFlags, 'SimulateNewSmallWheel'):
if simFlags.SimulateNewSmallWheel():
MuonDetectorTool.StationSelection = 2
MuonDetectorTool.SelectedStations = ["EIL1"]
MuonDetectorTool.SelectedStations += ["EIL2"]
MuonDetectorTool.SelectedStations += ["EIL6"]
MuonDetectorTool.SelectedStations += ["EIL7"]
MuonDetectorTool.SelectedStations += ["EIS*"]
MuonDetectorTool.SelectedStations += ["EIL10"]
MuonDetectorTool.SelectedStations += ["EIL11"]
MuonDetectorTool.SelectedStations += ["EIL12"]
def setupMuonCalibNtuple():
global topSequence, muonRecFlags, beamFlags, ToolSvc, rec, DetFlags
if not rec.doMuon() or not DetFlags.Muon_on():
logMuon.warning(
"Not setting up requested Muon Calibration Ntuple because Muons are off"
)
return
logMuon.info("Setting up Muon Calibration Ntuple")
try:
configs = getCalibConfigs()
# MuonSegmentToCalibSegment is only needed if we want segments
if muonRecFlags.calibNtupleSegments and muonRecFlags.calibMuonStandalone:
MuonSegmentToCalibSegment = getMuonSegmentToCalibSegment()
# MuonCalibAlg is always needed
eventTag = "UNKNOWN"
if (muonRecFlags.calibNtupleSegments or muonRecFlags.calibNtupleTracks
) and muonRecFlags.calibMuonStandalone:
if len(configs) >= 1:
eventTag = configs[0]["eventTag"]
elif muonRecFlags.calibNtupleTrigger:
eventTag = "TRIG"
else:
eventTag = "HITS"
MuonCalibAlg = getMuonCalibAlg(eventTag)
# configure for writing ntuple
from MuonCalibTools.MuonCalibToolsConf import MuonCalib__PatternNtupleMaker
MuonCalibTool = MuonCalib__PatternNtupleMaker(
"MuonCalibPatternNtupleMaker")
MuonCalibTool.FillTruth = rec.doTruth()
MuonCalibTool.DoRawTGC = (muonRecFlags.doTGCs()
and muonRecFlags.calibNtupleRawTGC())
ToolSvc += MuonCalibTool
MuonCalibAlg.MuonCalibTool = MuonCalibTool
# MuonCalibExtraTree only if we want to write tracks
if muonRecFlags.calibNtupleTracks:
MuonCalibTool.DelayFinish = True
from MuonCalibExtraTreeAlg.MuonCalibExtraTreeAlgConf import MuonCalib__MuonCalibExtraTreeAlg
MuonCalibExtraTreeAlg = MuonCalib__MuonCalibExtraTreeAlg(
"MuonCalibExtraTreeAlg",
NtupleName="PatternNtupleMaker",
)
segmentOnTrackSelector = None
if hasattr(topSequence, "MuonSegmentToCalibSegment"):
from MuonCalibExtraTreeAlg.MuonCalibExtraTreeAlgConf import MuonCalib__SegmentOnTrackSelector
segmentOnTrackSelector = MuonCalib__SegmentOnTrackSelector()
segmentOnTrackSelector.PattternLocation = "PatternsForCalibration"
ToolSvc += segmentOnTrackSelector
MuonCalibExtraTreeAlg.SegmentOnTrackSelector = segmentOnTrackSelector
if not rec.doMuonCombined():
tool_nr = 0
from MuonCalibExtraTreeAlg.MuonCalibExtraTreeAlgConf import MuonCalib__ExtraTreeTrackFillerTool
resPullCalc = getPublicTool("ResidualPullCalculator")
for config in configs:
trackDumpTool = MuonCalib__ExtraTreeTrackFillerTool(
"ExtraTreeTrackFillerTool" + str(tool_nr))
trackDumpTool.TrackCollectionKey = config['tracksKey']
trackDumpTool.SegmentAuthors = [config['segmentAuthor']]
trackDumpTool.TrackAuthor = config['trackAuthor']
trackDumpTool.PullCalculator = resPullCalc
ToolSvc += trackDumpTool
MuonCalibExtraTreeAlg.TrackFillerTools.append(
trackDumpTool)
tool_nr += 1
# configure needed tools
# add to topSequence
topSequence += MuonCalibExtraTreeAlg
# MuonCalibExtraTreeTriggerAlg only if trigger is available
if muonRecFlags.calibNtupleTrigger: # and DetFlags.detdescr.LVL1_on() and DetFlags.haveRDO.LVL1_on():
# protect against running without AtlasTrigger project
doMuCTPI = True
if doMuCTPI:
try:
from TrigT1RPCRecRoiSvc import TrigT1RPCRecRoiConfig
from TrigT1TGCRecRoiSvc import TrigT1TGCRecRoiConfig
except ImportError:
logMuon.warning(
"MuonCalibExtraTreeTriggerAlg.doMuCTPI = False because AtlasTrigger is not available"
)
doMuCTPI = False
# delay writing of MuonCalibAlg
MuonCalibTool.DelayFinish = True
# also delay MuonCalibExtraTreeAlg if it is running
try:
topSequence.MuonCalibExtraTreeAlg.DelayFinish = True
except AttributeError:
pass
from MuonCalibExtraTreeAlg.MuonCalibExtraTreeAlgConf import MuonCalib__MuonCalibExtraTreeTriggerAlg
topSequence += MuonCalib__MuonCalibExtraTreeTriggerAlg(
'MuonCalibExtraTreeTriggerAlg',
doMuCTPI=doMuCTPI,
doLVL1Calo=rec.doTile() or rec.doLArg()
or DetFlags.haveRDO.Calo_on(),
doMBTS=rec.doTile() or DetFlags.haveRDO.Tile_on())
except:
from AthenaCommon.Resilience import treatException
treatException(
"Problem in MuonCalib - Muon Calibration Ntuple configuration probably incomplete"
)
def getATLAS(name="Atlas", **kwargs):
kwargs.setdefault("DetectorName", "Atlas")
kwargs.setdefault("NSurfaces", 18)
from G4AtlasApps.SimFlags import simFlags
from AthenaCommon.BeamFlags import jobproperties
from AthenaCommon.DetFlags import DetFlags
## InnerRadii
innerRadii = [0.0] * 18
kwargs.setdefault("InnerRadii", innerRadii)
## Shrink the global ATLAS envelope to the activated detectors,
## except when running on special setups.
## OuterRadii
AtlasForwardOuterR = 2751.
AtlasOuterR1 = 14201.
AtlasOuterR2 = 14201.
AtlasOuterR3 = 1501.
if jobproperties.Beam.beamType() != 'cosmics' and not DetFlags.Muon_on() and not \
(simFlags.CavernBG.statusOn and not 'Signal' in simFlags.CavernBG.get_Value() ):
AtlasOuterR1 = 4251.
AtlasOuterR2 = 4251.
if not DetFlags.Calo_on():
AtlasOuterR1 = 1150.
AtlasOuterR2 = 1150.
outerRadii = [0.0] * 18
for i in (0, 1, 16, 17):
outerRadii[i] = 1501.
for i in (2, 3, 14, 15):
outerRadii[i] = AtlasForwardOuterR
for i in (4, 5, 12, 13):
outerRadii[i] = AtlasOuterR2
for i in xrange(6, 12):
outerRadii[i] = AtlasOuterR1
## World R range
if simFlags.WorldRRange.statusOn:
if simFlags.WorldRRange.get_Value() > max(AtlasOuterR1, AtlasOuterR2):
routValue = simFlags.WorldRRange.get_Value()
for i in xrange(4, 14):
outerRadii[i] = routValue
else:
raise RuntimeError(
'getATLASEnvelope: ERROR simFlags.WorldRRange must be > %f. Current value %f'
% max(AtlasOuterR1, AtlasOuterR2), routValue)
kwargs.setdefault("OuterRadii", outerRadii)
## ZSurfaces
zSurfaces = [
-26046., -23001., -23001., -22031., -22031., -12899., -12899., -6741.,
-6741., 6741., 6741., 12899., 12899., 22031., 22031., 23001., 23001.,
26046.
] # FIXME units mm??
if simFlags.ForwardDetectors.statusOn:
zSurfaces[0] = -400000.
zSurfaces[17] = 400000.
if simFlags.WorldZRange.statusOn:
if simFlags.WorldZRange.get_Value() < 26046.:
AtlasG4Eng.G4Eng.log.error('')
raise RuntimeError(
'getATLASEnvelope: ERROR simFlags.WorldZRange must be > 26046. Current value: %f'
% simFlags.WorldZRange.get_Value())
zSurfaces[17] = simFlags.WorldZRange.get_Value() + 100.
zSurfaces[16] = simFlags.WorldZRange.get_Value() + 50.
zSurfaces[15] = simFlags.WorldZRange.get_Value() + 50.
zSurfaces[14] = simFlags.WorldZRange.get_Value()
zSurfaces[13] = simFlags.WorldZRange.get_Value()
zSurfaces[0] = -simFlags.WorldZRange.get_Value() - 100.
zSurfaces[1] = -simFlags.WorldZRange.get_Value() - 50.
zSurfaces[2] = -simFlags.WorldZRange.get_Value() - 50.
zSurfaces[3] = -simFlags.WorldZRange.get_Value()
zSurfaces[4] = -simFlags.WorldZRange.get_Value()
kwargs.setdefault("ZSurfaces", zSurfaces)
kwargs.setdefault("SubDetectors", generateSubDetectorList())
return CfgMgr.PolyconicalEnvelope(name, **kwargs)
def __init__(self, name='AtlasTrackingGeometrySvc'):
if TrkDetFlags.ConfigurationOutputLevel() < 3:
print('[ Configuration : start ] *** ' + name +
' ********************************')
print('[ TrackingGeometrySvc ]')
from AthenaCommon.AppMgr import ToolSvc
#################################################################################
# The Geometry Builder
#################################################################################
# the name to register the Geometry
AtlasTrackingGeometryName = 'AtlasTrackingGeometry'
# the geometry builder alg tool
from TrkDetDescrTools.TrkDetDescrToolsConf import Trk__GeometryBuilder
AtlasGeometryBuilder = Trk__GeometryBuilder(
name='AtlasGeometryBuilder')
# switch the building outputlevel on
AtlasGeometryBuilder.OutputLevel = TrkDetFlags.ConfigurationOutputLevel(
)
# the envelope definition service
from AthenaCommon.CfgGetter import getPrivateTool,getPrivateToolClone,getPublicTool,getPublicToolClone,\
getService,getServiceClone,getAlgorithm,getAlgorithmClone
AtlasEnvelopeSvc = getService('AtlasGeometry_EnvelopeDefSvc')
# (ID)
if DetFlags.ID_on():
# get hand on the ID Tracking Geometry Builder
if TrkDetFlags.ISF_FatrasCustomGeometry():
if hasattr(ToolSvc,
TrkDetFlags.ISF_FatrasCustomGeometryBuilderName()):
InDetTrackingGeometryBuilder = getattr(
ToolSvc,
TrkDetFlags.ISF_FatrasCustomGeometryBuilderName())
elif TrkDetFlags.XMLFastCustomGeometry():
if hasattr(ToolSvc,
TrkDetFlags.InDetTrackingGeometryBuilderName()):
InDetTrackingGeometryBuilder = getattr(
ToolSvc,
TrkDetFlags.InDetTrackingGeometryBuilderName())
else:
if not TrkDetFlags.SLHC_Geometry(
) and not TrkDetFlags.InDetStagedGeometryBuilder():
from InDetTrackingGeometry.ConfiguredInDetTrackingGeometryBuilder import ConfiguredInDetTrackingGeometryBuilder as IDGeometryBuilder
elif not TrkDetFlags.SLHC_Geometry():
from InDetTrackingGeometry.ConfiguredStagedTrackingGeometryBuilder import ConfiguredStagedTrackingGeometryBuilder as IDGeometryBuilder
else:
from InDetTrackingGeometry.ConfiguredSLHC_InDetTrackingGeometryBuilder import ConfiguredSLHC_InDetTrackingGeometryBuilder as IDGeometryBuilder
InDetTrackingGeometryBuilder = IDGeometryBuilder(
name='InDetTrackingGeometryBuilder')
InDetTrackingGeometryBuilder.EnvelopeDefinitionSvc = AtlasEnvelopeSvc
InDetTrackingGeometryBuilder.OutputLevel = TrkDetFlags.InDetBuildingOutputLevel(
)
# and give it to the Geometry Builder
AtlasGeometryBuilder.InDetTrackingGeometryBuilder = InDetTrackingGeometryBuilder
#
# (Calo)
if DetFlags.Calo_on():
from TrkDetDescrTools.TrkDetDescrToolsConf import Trk__CylinderVolumeCreator
CaloVolumeCreator = Trk__CylinderVolumeCreator("CaloVolumeCreator")
CaloVolumeCreator.OutputLevel = TrkDetFlags.CaloBuildingOutputLevel(
)
ToolSvc += CaloVolumeCreator
from CaloTrackingGeometry.ConfiguredCaloTrackingGeometryBuilder import ConfiguredCaloTrackingGeometryBuilder as ConfiguredCaloGeo
CaloTrackingGeometryBuilder = ConfiguredCaloGeo(
name='CaloTrackingGeometryBuilder')
CaloTrackingGeometryBuilder.TrackingVolumeCreator = CaloVolumeCreator
CaloTrackingGeometryBuilder.EnvelopeDefinitionSvc = AtlasEnvelopeSvc
CaloTrackingGeometryBuilder.OutputLevel = TrkDetFlags.CaloBuildingOutputLevel(
)
CaloTrackingGeometryBuilder.GeometryName = 'Calo'
# and give it to the Geometry Builder
AtlasGeometryBuilder.CaloTrackingGeometryBuilder = CaloTrackingGeometryBuilder
# (Muon)
if DetFlags.Muon_on():
from MuonTrackingGeometry.ConfiguredMuonTrackingGeometry import MuonTrackingGeometryBuilder
MuonTrackingGeometryBuilder.EnvelopeDefinitionSvc = AtlasEnvelopeSvc
# and give it to the Geometry Builder
AtlasGeometryBuilder.MuonTrackingGeometryBuilder = MuonTrackingGeometryBuilder
# processors
AtlasGeometryProcessors = []
# check whether the material retrieval is ment to be from COOL
if TrkDetFlags.MaterialSource() is 'COOL':
# the material provider
from TrkDetDescrTools.TrkDetDescrToolsConf import Trk__LayerMaterialProvider as LayerMaterialProvider
AtlasMaterialProvider = LayerMaterialProvider(
'AtlasMaterialProvider')
AtlasMaterialProvider.OutputLevel = TrkDetFlags.ConfigurationOutputLevel(
)
AtlasMaterialProvider.LayerMaterialMapName = TrkDetFlags.MaterialStoreGateKey(
)
AtlasGeometryProcessors += [AtlasMaterialProvider]
# the tag names
CoolDataBaseFolder = TrkDetFlags.MaterialStoreGateKey()
AtlasMaterialTag = TrkDetFlags.MaterialTagBase() + str(
TrkDetFlags.MaterialVersion(
)) + TrkDetFlags.MaterialSubVersion() + '_'
if TrkDetFlags.ConfigurationOutputLevel() < 3:
print('[ TrackingGeometrySvc ] Associating DB folder : ',
CoolDataBaseFolder)
# we need the conditions interface
from IOVDbSvc.CondDB import conddb
# use a local database
if TrkDetFlags.MaterialDatabaseLocal():
# specify the local database
DataBasePath = TrkDetFlags.MaterialDatabaseLocalPath()
DataBaseName = TrkDetFlags.MaterialDatabaseLocalName()
MagicTag = TrkDetFlags.MaterialMagicTag()
DataBaseConnection = '<dbConnection>sqlite://X;schema=' + DataBasePath + DataBaseName + ';dbname=OFLP200</dbConnection>'
conddb.blockFolder('/GLOBAL/TrackingGeo/LayerMaterialV2')
conddb.addFolderWithTag('',
DataBaseConnection +
CoolDataBaseFolder,
AtlasMaterialTag + MagicTag,
force=True)
if TrkDetFlags.ConfigurationOutputLevel() < 3:
print('[ TrackingGeometrySvc ] Using Local Database: ' +
DataBaseConnection)
# make sure that the pool files are in the catalog
elif TrkDetFlags.SLHC_Geometry():
# set the folder to the SLHC location
CoolDataBaseFolder = '/GLOBAL/TrackingGeo/LayerMaterialITK'
ctag = AtlasMaterialTag + TrkDetFlags.MaterialMagicTag()
cfoldertag = CoolDataBaseFolder + ' <tag>' + ctag + '</tag>'
conddb.addFolderSplitMC('GLOBAL', cfoldertag, cfoldertag)
else:
print('[ TrackingGeometrySvc ] base material tag : ',
AtlasMaterialTag)
cfolder = CoolDataBaseFolder + '<tag>TagInfoMajor/' + AtlasMaterialTag + '/GeoAtlas</tag>'
print('[ TrackingGeometrySvc ] translated to COOL: ',
cfolder)
# load the right folders (preparation for calo inclusion)
conddb.addFolderSplitMC('GLOBAL', cfolder, cfolder)
elif TrkDetFlags.MaterialSource() is 'Input':
# the material provider
from TrkDetDescrTools.TrkDetDescrToolsConf import Trk__InputLayerMaterialProvider
AtlasMaterialProvider = Trk__InputLayerMaterialProvider(
'AtlasMaterialProvider')
AtlasMaterialProvider.OutputLevel = TrkDetFlags.ConfigurationOutputLevel(
)
AtlasGeometryProcessors += [AtlasMaterialProvider]
# material validation
if TrkDetFlags.MaterialValidation():
# load the material inspector
from TrkDetDescrTestTools.TrkDetDescrTestToolsConf import Trk__LayerMaterialInspector
AtlasLayerMaterialInspector = Trk__LayerMaterialInspector(
'AtlasLayerMaterialInspector')
AtlasLayerMaterialInspector.OutputLevel = TrkDetFlags.ConfigurationOutputLevel(
)
AtlasGeometryProcessors += [AtlasLayerMaterialInspector]
# call the base class constructor : sets the tools
Trk__TrackingGeometrySvc.__init__(self,name,\
GeometryBuilder = AtlasGeometryBuilder,\
TrackingGeometryName = AtlasTrackingGeometryName,\
GeometryProcessors = AtlasGeometryProcessors, \
BuildGeometryFromTagInfo = True,\
OutputLevel = TrkDetFlags.ConfigurationOutputLevel())
# screen output of the configuration
if TrkDetFlags.ConfigurationOutputLevel() < 3:
print(self)
print('* [ GeometryBuilder ]')
print(AtlasGeometryBuilder)
print('* [ Configuration : end ] ***' + name +
'********************************')
from AthenaCommon.DetFlags import DetFlags DetFlags.ID_setOn() # --- no TRT for SLHC DetFlags.TRT_setOff() DetFlags.detdescr.TRT_setOff() DetFlags.makeRIO.TRT_setOff() # Calo and Muon off for SLHC DetFlags.Calo_setOff() DetFlags.Muon_setOff() #from GeoModelSvc.GeoModelSvcConf import GeoModelSvc #GeoModelSvc.InDetVersionOverride="InnerDetector-SLHC-00" from FastSimulationConfig.FastSimulationFlags import jobproperties jobproperties.FastSimulation.doFatrasID = DetFlags.ID_on() jobproperties.FastSimulation.doFatrasMuon = DetFlags.Muon_on() # run additional fast calo sim FatrasFlags.FastCaloSim = False #-------------------------------------------------------------- # load Global Flags and set defaults (import the new jobProperty globalflags) #-------------------------------------------------------------- from AthenaCommon.GlobalFlags import globalflags # --- default is atlas geometry globalflags.DetGeo = 'atlas' # --- set defaults globalflags.DataSource = 'geant4' # --- input is pool for SLHC globalflags.InputFormat = 'pool'
def hits_persistency():
""" HITS POOL file persistency
"""
from G4AtlasApps.SimFlags import simFlags
from AthenaCommon.DetFlags import DetFlags
from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
## Not yet understood, but need to treat StreamHITS as alg in Hive.
## Seems to also work fine outside of Hive, but to be extra safe I'm
## only changing it in Hive.
from AthenaCommon.ConcurrencyFlags import jobproperties as concurrencyProps
if concurrencyProps.ConcurrencyFlags.NumThreads() > 0:
as_alg = True
else:
as_alg = False
## NB. Two-arg constructor is needed, since otherwise metadata writing fails!
stream1 = AthenaPoolOutputStream("StreamHITS",
athenaCommonFlags.PoolHitsOutput(),
asAlg=as_alg)
## Write geometry tag info - move to main method
#import EventInfoMgt.EventInfoMgtInit
## EventInfo & TruthEvent always written by default
stream1.ForceRead = True
stream1.ItemList = [
"EventInfo#*", "McEventCollection#TruthEvent", "JetCollection#*"
]
## If we are running quasi-stable particle simulation, include the original event record
if hasattr(
simFlags, 'IncludeParentsInG4Event'
) and simFlags.IncludeParentsInG4Event.statusOn and simFlags.IncludeParentsInG4Event(
):
stream1.ItemList += ["McEventCollection#GEN_EVENT"]
stream1.ItemList += ["xAOD::JetContainer#*", "xAOD::JetAuxContainer#*"]
## Make stream aware of aborted events
stream1.AcceptAlgs = ["G4AtlasAlg"]
## Detectors
## Inner Detector
if DetFlags.ID_on():
stream1.ItemList += [
"SiHitCollection#*", "TRTUncompressedHitCollection#*",
"TrackRecordCollection#CaloEntryLayer"
]
## Calo
if DetFlags.Calo_on():
stream1.ItemList += [
"CaloCalibrationHitContainer#*",
"LArHitContainer#*",
"TileHitVector#*",
#"SimpleScintillatorHitCollection#*",
"TrackRecordCollection#MuonEntryLayer"
]
## Muon
if DetFlags.Muon_on():
stream1.ItemList += [
"RPCSimHitCollection#*", "TGCSimHitCollection#*",
"CSCSimHitCollection#*", "MDTSimHitCollection#*",
"TrackRecordCollection#MuonExitLayer"
]
if hasattr(simFlags, 'SimulateNewSmallWheel'):
if simFlags.SimulateNewSmallWheel():
stream1.ItemList += ["GenericMuonSimHitCollection#*"]
## Lucid
if DetFlags.Lucid_on():
stream1.ItemList += ["LUCID_SimHitCollection#*"]
## FwdRegion
if DetFlags.FwdRegion_on():
stream1.ItemList += ["SimulationHitCollection#*"]
## ZDC
if DetFlags.ZDC_on():
stream1.ItemList += [
"ZDC_SimPixelHit_Collection#*", "ZDC_SimStripHit_Collection#*"
]
## ALFA
if DetFlags.ALFA_on():
stream1.ItemList += [
"ALFA_HitCollection#*", "ALFA_ODHitCollection#*"
]
## AFP
if DetFlags.AFP_on():
stream1.ItemList += [
"AFP_TDSimHitCollection#*", "AFP_SIDSimHitCollection#*"
]
### Ancillary scintillators
#stream1.ItemList += ["ScintillatorHitCollection#*"]
## TimingAlg
stream1.ItemList += ["RecoTimingObj#EVNTtoHITS_timings"]
## Add cosmics and test beam configuration hit persistency if required cf. geom tag
layout = simFlags.SimLayout.get_Value()
if "tb" not in layout:
from AthenaCommon.BeamFlags import jobproperties
if jobproperties.Beam.beamType() == 'cosmics' or \
(hasattr(simFlags, "WriteTR") and simFlags.WriteTR.statusOn) or \
(hasattr(simFlags, "ReadTR") and simFlags.ReadTR.statusOn):
stream1.ItemList += [
"TrackRecordCollection#CosmicRecord",
"TrackRecordCollection#CosmicPerigee"
]
else:
## CTB-specific
if layout.startswith("ctb"):
if simFlags.LArFarUpstreamMaterial.statusOn and simFlags.LArFarUpstreamMaterial.get_Value(
):
stream1.ItemList.append(
"TrackRecordCollection#LArFarUpstreamMaterialExitLayer"
)
## Persistency of test-beam layout
if layout.startswith('ctb') or layout.startswith('tb_Tile2000_'):
stream1.ItemList += ["TBElementContainer#*"]
def __init__(self, layout):
"""
Describes the geometry.
"""
self.AtlasForwardOuterR = 2751.
self.AtlasOuterR1 = 13911.
self.AtlasOuterR2 = 13911.
self.AtlasOuterR3 = 1501.
from G4AtlasApps.SimFlags import simFlags
from AthenaCommon.BeamFlags import jobproperties
from AthenaCommon.DetFlags import DetFlags
## Shrink the global ATLAS envelope to the activated detectors, except when running on special setups.
if jobproperties.Beam.beamType() != 'cosmics' and not DetFlags.Muon_on() and not \
(simFlags.CavernBG.statusOn and not 'Signal' in simFlags.CavernBG.get_Value() ):
self.AtlasOuterR1 = 4251.
self.AtlasOuterR2 = 4251.
if not DetFlags.Calo_on():
self.AtlasOuterR1 = 1150.
self.AtlasOuterR2 = 1150.
AtlasG4Eng.G4Eng.log.debug(
'Creating Atlas envelope with outer radii %d, %d' %
(self.AtlasOuterR1, self.AtlasOuterR2))
self.atlas = PyG4Atlas.DetFacility("GenericPCON", "Atlas")
self.atlas.df.SetPhiMin(math.radians(0))
self.atlas.df.SetDeltaPhi(math.radians(360))
self.atlas.df.SetNSurfaces(18)
self.atlas.df.SetZSurface(0, -26046.)
self.atlas.df.SetZSurface(1, -23001.)
self.atlas.df.SetZSurface(2, -23001.)
self.atlas.df.SetZSurface(3, -22031.)
self.atlas.df.SetZSurface(4, -22031.)
self.atlas.df.SetZSurface(5, -12899.)
self.atlas.df.SetZSurface(6, -12899.)
self.atlas.df.SetZSurface(7, -6741.)
self.atlas.df.SetZSurface(8, -6741.)
self.atlas.df.SetZSurface(9, 6741.)
self.atlas.df.SetZSurface(10, 6741.)
self.atlas.df.SetZSurface(11, 12899.)
self.atlas.df.SetZSurface(12, 12899.)
self.atlas.df.SetZSurface(13, 22031.)
self.atlas.df.SetZSurface(14, 22031.)
self.atlas.df.SetZSurface(15, 23001.)
self.atlas.df.SetZSurface(16, 23001.)
self.atlas.df.SetZSurface(17, 26046.)
if simFlags.ForwardDetectors.statusOn:
self.atlas.df.SetZSurface(0, -400000.)
self.atlas.df.SetZSurface(17, 400000.)
if simFlags.WorldZRange.statusOn:
if simFlags.WorldZRange.get_Value() < 26046.:
AtlasG4Eng.G4Eng.log.error('WorldZRange must be > 26046.')
raise RuntimeError(
'atlas_common: found problems with the Z World volume range: %f'
% simFlags.WorldZRange.get_Value())
self.atlas.df.SetZSurface(17,
simFlags.WorldZRange.get_Value() + 100.)
self.atlas.df.SetZSurface(16,
simFlags.WorldZRange.get_Value() + 50.)
self.atlas.df.SetZSurface(15,
simFlags.WorldZRange.get_Value() + 50.)
self.atlas.df.SetZSurface(14, simFlags.WorldZRange.get_Value())
self.atlas.df.SetZSurface(13, simFlags.WorldZRange.get_Value())
self.atlas.df.SetZSurface(0,
-simFlags.WorldZRange.get_Value() - 100.)
self.atlas.df.SetZSurface(1,
-simFlags.WorldZRange.get_Value() - 50.)
self.atlas.df.SetZSurface(2,
-simFlags.WorldZRange.get_Value() - 50.)
self.atlas.df.SetZSurface(3, -simFlags.WorldZRange.get_Value())
self.atlas.df.SetZSurface(4, -simFlags.WorldZRange.get_Value())
AtlasG4Eng.G4Eng.log.debug(
'Increasing the Z World ATLAS envelope to %f' %
simFlags.WorldZRange.get_Value())
## Set inner (all zero) and outer radii
for i in xrange(0, 18):
self.atlas.df.SetRinSurface(i, 0.0)
for i in (0, 1, 16, 17):
self.atlas.df.SetRouSurface(i, 1501.)
for i in (2, 3, 14, 15):
self.atlas.df.SetRouSurface(i, self.AtlasForwardOuterR)
for i in (4, 5, 12, 13):
self.atlas.df.SetRouSurface(i, self.AtlasOuterR2)
for i in xrange(6, 12):
self.atlas.df.SetRouSurface(i, self.AtlasOuterR1)
## World R range
if simFlags.WorldRRange.statusOn:
if simFlags.WorldRRange.get_Value() > max(self.AtlasOuterR1,
self.AtlasOuterR2):
routValue = simFlags.WorldRRange.get_Value()
for i in xrange(4, 14):
self.atlas.df.SetRouSurface(i, routValue)
AtlasG4Eng.G4Eng.log.debug(
'Increasing the ATLAS World envelope R value to %f' %
routValue)
else:
AtlasG4Eng.G4Eng.log.error(
'WorldRRange must be > %f' %
max(self.AtlasOuterR1, self.AtlasOuterR2))
raise RuntimeError(
'atlas_common: found problems with the R World volume range %f'
% routValue)
