def generateMuonSensitiveDetectorList():
SensitiveDetectorList = []
from AthenaCommon.DetFlags import DetFlags
if DetFlags.simulate.Muon_on():
from AthenaCommon.BeamFlags import jobproperties
if jobproperties.Beam.beamType() == 'cosmics':
if DetFlags.simulate.MDT_on():
SensitiveDetectorList += ['MDTSensitiveDetectorCosmics']
if DetFlags.simulate.RPC_on():
SensitiveDetectorList += ['RPCSensitiveDetectorCosmics']
if DetFlags.simulate.TGC_on():
SensitiveDetectorList += ['TGCSensitiveDetectorCosmics']
if MuonGeometryFlags.hasCSC() and DetFlags.simulate.CSC_on():
SensitiveDetectorList += ['CSCSensitiveDetectorCosmics']
else:
if DetFlags.simulate.MDT_on():
SensitiveDetectorList += ['MDTSensitiveDetector']
if DetFlags.simulate.RPC_on():
SensitiveDetectorList += ['RPCSensitiveDetector']
if DetFlags.simulate.TGC_on():
SensitiveDetectorList += ['TGCSensitiveDetector']
if MuonGeometryFlags.hasCSC() and DetFlags.simulate.CSC_on():
SensitiveDetectorList += ['CSCSensitiveDetector']
if MuonGeometryFlags.hasSTGC() and DetFlags.simulate.sTGC_on():
SensitiveDetectorList += ['sTGCSensitiveDetector']
if MuonGeometryFlags.hasMM() and DetFlags.simulate.Micromegas_on():
SensitiveDetectorList += ['MicromegasSensitiveDetector']
return SensitiveDetectorList
def MuidSegmentRegionRecoveryTool( name ='MuidSegmentRegionRecoveryTool', **kwargs ):
kwargs.setdefault("Builder", getPublicTool("CombinedMuonTrackBuilderFit") )
import MuonCombinedRecExample.CombinedMuonTrackSummary
from AthenaCommon.AppMgr import ToolSvc
kwargs.setdefault("TrackSummaryTool", ToolSvc.CombinedMuonTrackSummary)
from RegionSelector.RegSelToolConfig import makeRegSelTool_MDT, makeRegSelTool_RPC, makeRegSelTool_TGC
kwargs.setdefault("MDTRegionSelector", makeRegSelTool_MDT())
kwargs.setdefault("RPCRegionSelector", makeRegSelTool_RPC())
kwargs.setdefault("TGCRegionSelector", makeRegSelTool_TGC())
if MuonGeometryFlags.hasCSC():
from RegionSelector.RegSelToolConfig import makeRegSelTool_CSC
kwargs.setdefault("CSCRegionSelector", makeRegSelTool_CSC())
else:
kwargs.setdefault("CSCRegionSelector", "")
if MuonGeometryFlags.hasSTGC():
from RegionSelector.RegSelToolConfig import makeRegSelTool_sTGC
kwargs.setdefault("STGCRegionSelector", makeRegSelTool_sTGC())
else:
kwargs.setdefault("STGCRegionSelector", "")
if MuonGeometryFlags.hasMM():
from RegionSelector.RegSelToolConfig import makeRegSelTool_MM
kwargs.setdefault("MMRegionSelector", makeRegSelTool_MM())
else:
kwargs.setdefault("MMRegionSelector", "")
return CfgMgr.Muon__MuonSegmentRegionRecoveryTool(name,**kwargs)
def __init__(self, name="MuonSegmentRegionRecoveryTool", **kwargs):
#MDT conditions information not available online
if (athenaCommonFlags.isOnline):
kwargs.setdefault("MdtCondKey", "")
from RegionSelector.RegSelToolConfig import makeRegSelTool_MDT, makeRegSelTool_RPC, makeRegSelTool_TGC
kwargs.setdefault("MDTRegionSelector", makeRegSelTool_MDT())
kwargs.setdefault("RPCRegionSelector", makeRegSelTool_RPC())
kwargs.setdefault("TGCRegionSelector", makeRegSelTool_TGC())
if MuonGeometryFlags.hasCSC():
from RegionSelector.RegSelToolConfig import makeRegSelTool_CSC
kwargs.setdefault("CSCRegionSelector", makeRegSelTool_CSC())
else:
kwargs.setdefault("CSCRegionSelector", "")
if MuonGeometryFlags.hasSTGC():
from RegionSelector.RegSelToolConfig import makeRegSelTool_sTGC
kwargs.setdefault("STGCRegionSelector", makeRegSelTool_sTGC())
else:
kwargs.setdefault("STGCRegionSelector", "")
if MuonGeometryFlags.hasMM():
from RegionSelector.RegSelToolConfig import makeRegSelTool_MM
kwargs.setdefault("MMRegionSelector", makeRegSelTool_MM())
else:
kwargs.setdefault("MMRegionSelector", "")
self.applyUserDefaults(kwargs, name)
super(MuonSegmentRegionRecoveryTool, self).__init__(name, **kwargs)
def MuonPrdCacheCfg():
# Use MuonGeometryFlags to identify which configuration is being used
from AtlasGeoModel.MuonGMJobProperties import MuonGeometryFlags
acc = ComponentAccumulator()
MuonPRDCacheCreator = CompFactory.MuonPRDCacheCreator
cacheCreator = MuonPRDCacheCreator(
CscStripCacheKey=(MuonPrdCacheNames.CscStripCache
if MuonGeometryFlags.hasCSC() else ""),
MdtCacheKey=MuonPrdCacheNames.MdtCache,
CscCacheKey=(MuonPrdCacheNames.CscCache
if MuonGeometryFlags.hasCSC() else ""),
RpcCacheKey=MuonPrdCacheNames.RpcCache,
TgcCacheKey=MuonPrdCacheNames.TgcCache,
sTgcCacheKey=(MuonPrdCacheNames.sTgcCache
if MuonGeometryFlags.hasSTGC() else ""),
MmCacheKey=(MuonPrdCacheNames.MmCache
if MuonGeometryFlags.hasMM() else ""),
TgcCoinCacheKey=MuonPrdCacheNames.TgcCoinCache,
RpcCoinCacheKey=MuonPrdCacheNames.RpcCoinCache,
)
acc.addEventAlgo(cacheCreator, primary=True)
return acc
def MuonSeededSegmentFinder(name="MuonSeededSegmentFinder", **kwargs):
if "SegmentMaker" not in kwargs or "SegmentMakerNoHoles" not in kwargs:
if beamFlags.beamType() == 'collisions':
segMaker = getPublicToolClone(
"MCTBDCMathSegmentMaker",
"DCMathSegmentMaker",
MdtSegmentFinder="MCTBMdtMathSegmentFinder",
SinAngleCut=0.04,
DoGeometry=True)
else: # cosmics or singlebeam
segMaker = getPublicToolClone(
"MCTBDCMathSegmentMaker",
"DCMathSegmentMaker",
MdtSegmentFinder="MCTBMdtMathSegmentFinder",
SinAngleCut=0.1,
DoGeometry=False,
AddUnassociatedPhiHits=True)
kwargs.setdefault("SegmentMaker", segMaker)
kwargs.setdefault("SegmentMakerNoHoles", segMaker)
if not MuonGeometryFlags.hasCSC():
kwargs.setdefault("CscPrepDataContainer", "")
if not MuonGeometryFlags.hasSTGC():
kwargs.setdefault("sTgcPrepDataContainer", "")
if not MuonGeometryFlags.hasMM():
kwargs.setdefault("MMPrepDataContainer", "")
return CfgMgr.Muon__MuonSeededSegmentFinder(name, **kwargs)
def MuonChamberHoleRecoveryTool(name="MuonChamberHoleRecoveryTool",
extraFlags=None,
**kwargs):
doSegmentT0Fit = getattr(extraFlags, "doSegmentT0Fit",
muonRecFlags.doSegmentT0Fit())
kwargs.setdefault("Extrapolator", "MuonExtrapolator")
if doSegmentT0Fit:
kwargs.setdefault("AddMeasurements", False)
if muonRecFlags.doCSCs():
if muonRecFlags.enableErrorTuning() or globalflags.DataSource(
) == 'data':
kwargs.setdefault("CscRotCreator", "CscBroadClusterOnTrackCreator")
else:
kwargs.setdefault("CscRotCreator", "CscClusterOnTrackCreator")
else: # no CSCs
# switch off whatever is set
kwargs["CscRotCreator"] = ""
kwargs["CscPrepDataContainer"] = ""
# add in missing C++ dependency. TODO: fix in C++
getPublicTool("ResidualPullCalculator")
if not MuonGeometryFlags.hasSTGC():
kwargs.setdefault("sTgcPrepDataContainer", "")
if not MuonGeometryFlags.hasMM():
kwargs.setdefault("MMPrepDataContainer", "")
#MDT conditions information not available online
if (athenaCommonFlags.isOnline):
kwargs.setdefault("MdtCondKey", "")
return CfgMgr.Muon__MuonChamberHoleRecoveryTool(name, **kwargs)
def MuonStauSeededSegmentFinder( name="MuonStauSeededSegmentFinder", **kwargs ):
kwargs.setdefault("MdtRotCreator", getPublicTool("MdtDriftCircleOnTrackCreatorStau") )
kwargs.setdefault("SegmentMaker", getPublicTool("DCMathStauSegmentMaker") )
kwargs.setdefault("SegmentMakerNoHoles", getPublicTool("DCMathStauSegmentMaker") )
if not MuonGeometryFlags.hasCSC(): kwargs.setdefault("CscPrepDataContainer","")
if not MuonGeometryFlags.hasSTGC(): kwargs.setdefault("sTgcPrepDataContainer","")
if not MuonGeometryFlags.hasMM(): kwargs.setdefault("MMPrepDataContainer","")
return MuonSeededSegmentFinder(name,**kwargs)
def MuGirlStauAlg(name="MuGirlStauAlg", **kwargs):
tools = [getPublicTool("MuonStauRecoTool")]
kwargs.setdefault("MuonCombinedInDetExtensionTools", tools)
kwargs.setdefault("TagMap", "stauTagMap")
kwargs.setdefault("HasCSC", MuonGeometryFlags.hasCSC())
kwargs.setdefault("HasSTgc", MuonGeometryFlags.hasSTGC())
kwargs.setdefault("HasMM", MuonGeometryFlags.hasMM())
kwargs.setdefault("CombinedTrackCollection", "MuGirlStauCombinedTracks")
kwargs.setdefault("METrackCollection", "")
kwargs.setdefault("SegmentCollection", "MuGirlStauSegments")
return CfgMgr.MuonCombinedInDetExtensionAlg(name, **kwargs)
def MuonCombinedInDetExtensionAlg(name="MuonCombinedInDetExtensionAlg",
**kwargs):
tools = []
if muonCombinedRecFlags.doCaloTrkMuId():
tools.append(getTool("MuonCaloTagTool"))
kwargs.setdefault("TagMap", "caloTagMap")
kwargs.setdefault("MuonCombinedInDetExtensionTools", tools)
kwargs.setdefault("HasCSC", MuonGeometryFlags.hasCSC())
kwargs.setdefault("HasSTgc", MuonGeometryFlags.hasSTGC())
kwargs.setdefault("HasMM", MuonGeometryFlags.hasMM())
return CfgMgr.MuonCombinedInDetExtensionAlg(name, **kwargs)
def TMEF_MuonLayerSegmentFinderTool(name="TMEF_MuonLayerSegmentFinderTool",
**kwargs):
kwargs.setdefault('MuonRecoValidationTool', '')
kwargs.setdefault('MuonPRDSelectionTool', 'TMEF_MuonPRDSelectionTool')
kwargs.setdefault('MuonClusterSegmentFinder',
'TMEF_MuonClusterSegmentFinder')
if not MuonGeometryFlags.hasCSC():
kwargs.setdefault('Csc2DSegmentMaker', '')
kwargs.setdefault('Csc4DSegmentMaker', '')
if (MuonGeometryFlags.hasSTGC() and MuonGeometryFlags.hasMM()):
kwargs.setdefault('NSWMuonClusterSegmentFinderTool',
'TMEF_MuonClusterSegmentFinderTool')
return CfgMgr.Muon__MuonLayerSegmentFinderTool(name, **kwargs)
def makeRegSelTool_sTGC():
from AtlasGeoModel.MuonGMJobProperties import MuonGeometryFlags
from AthenaCommon.DetFlags import DetFlags
enabled = False
if MuonGeometryFlags.hasSTGC():
enabled = DetFlags.detdescr.sTGC_on()
from MuonRegionSelector.MuonRegionSelectorConf import sTGC_RegSelCondAlg
return _makeRegSelTool("sTGC", enabled, sTGC_RegSelCondAlg)
def makeRegSelTool_MM():
from AtlasGeoModel.MuonGMJobProperties import MuonGeometryFlags
from AthenaCommon.DetFlags import DetFlags
enabled = False
if MuonGeometryFlags.hasMM():
enabled = DetFlags.detdescr.Micromegas_on()
from MuonRegionSelector.MuonRegionSelectorConf import MM_RegSelCondAlg
return _makeRegSelTool("MM", enabled, MM_RegSelCondAlg)
def MuonInsideOutRecoAlg(name="MuonInsideOutRecoAlg", **kwargs):
tools = [getPublicTool("MuonInsideOutRecoTool")]
from MuonLayerSegmentMakerTools.MuonLayerSegmentMakerToolsConf import Muon__MuonLayerSegmentFinderTool
from AthenaCommon.AppMgr import ToolSvc
MuonLayerSegmentFinderTool = Muon__MuonLayerSegmentFinderTool(
"MuonLayerSegmentFinderTool",
Csc2DSegmentMaker=(getPublicTool("Csc2dSegmentMaker")
if MuonGeometryFlags.hasCSC() else ""),
Csc4DSegmentMaker=(getPublicTool("Csc4dSegmentMaker")
if MuonGeometryFlags.hasCSC() else ""))
ToolSvc += MuonLayerSegmentFinderTool
tools[0].MuonLayerSegmentFinderTool = MuonLayerSegmentFinderTool
kwargs.setdefault("MuonCombinedInDetExtensionTools", tools)
kwargs.setdefault("usePRDs", True)
kwargs.setdefault("HasCSC", MuonGeometryFlags.hasCSC())
kwargs.setdefault("HasSTgc", MuonGeometryFlags.hasSTGC())
kwargs.setdefault("HasMM", MuonGeometryFlags.hasMM())
kwargs.setdefault("TagMap", "muGirlTagMap")
return CfgMgr.MuonCombinedInDetExtensionAlg(name, **kwargs)
#### MDT ####
if DetFlags.detdescr.MDT_on():
from MuonRegionSelector.MuonRegionSelectorConf import MDT_RegionSelectorTable
MDT_RegionSelectorTable = MDT_RegionSelectorTable(
name="MDT_RegionSelectorTable")
ToolSvc += MDT_RegionSelectorTable
print MDT_RegionSelectorTable
else:
MDT_RegionSelectorTable = None
#### CSC ####
# could avoid first check in case DetFlags.detdescr.CSC_on() would take into account MuonGeometryFlags already
if MuonGeometryFlags.hasCSC() and DetFlags.detdescr.CSC_on():
from MuonRegionSelector.MuonRegionSelectorConf import CSC_RegionSelectorTable
CSC_RegionSelectorTable = CSC_RegionSelectorTable(
name="CSC_RegionSelectorTable")
ToolSvc += CSC_RegionSelectorTable
print CSC_RegionSelectorTable
else:
CSC_RegionSelectorTable = None
#### TGC ####
if DetFlags.detdescr.TGC_on():
from MuonRegionSelector.MuonRegionSelectorConf import TGC_RegionSelectorTable
TGC_RegionSelectorTable = TGC_RegionSelectorTable(
name="TGC_RegionSelectorTable")
def MuonStauChamberHoleRecoveryTool(name="MuonStauChamberHoleRecoveryTool",**kwargs):
kwargs.setdefault("MdtRotCreator", getPublicTool("MdtDriftCircleOnTrackCreatorStau") )
if not MuonGeometryFlags.hasCSC():
kwargs.setdefault("CscRotCreator", "" )
kwargs.setdefault("CscPrepDataContainer", "" )
return MuonChamberHoleRecoveryTool(name,**kwargs)
def MooSegmentFinderNCBAlg( name="MuonSegmentMaker_NCB",**kwargs ):
kwargs.setdefault("SegmentFinder",getPublicToolClone("MooSegmentFinder_NCB","MuonSegmentFinder",
DoSummary=False,
Csc2dSegmentMaker = (getPublicToolClone("Csc2dSegmentMaker_NCB","Csc2dSegmentMaker",
segmentTool = getPublicToolClone("CscSegmentUtilTool_NCB",
"CscSegmentUtilTool",
TightenChi2 = False,
IPconstraint=False)) if MuonGeometryFlags.hasCSC() else ""),
Csc4dSegmentMaker = (getPublicToolClone("Csc4dSegmentMaker_NCB","Csc4dSegmentMaker",
segmentTool = getPublicTool("CscSegmentUtilTool_NCB")) if MuonGeometryFlags.hasCSC() else ""),
DoMdtSegments=False,DoSegmentCombinations=False,DoSegmentCombinationCleaning=False))
kwargs.setdefault("MuonPatternCombinationLocation", "NCB_MuonHoughPatternCombinations")
kwargs.setdefault("MuonSegmentOutputLocation", "NCB_MuonSegments")
kwargs.setdefault("MuonSegmentOutputLocation", "NCB_MuonSegments")
kwargs.setdefault("UseCSC", muonRecFlags.doCSCs())
kwargs.setdefault("UseMDT", False)
kwargs.setdefault("UseRPC", False)
kwargs.setdefault("UseTGC", False)
kwargs.setdefault("UseTGCPriorBC", False)
kwargs.setdefault("UseTGCNextBC", False)
kwargs.setdefault("doTGCClust", False)
kwargs.setdefault("doRPCClust", False)
return CfgMgr.MooSegmentFinderAlg(name,**kwargs)
def configure(self,keys=None):
super(MuonStandalone,self).configure(keys)
if not self.isEnabled(): return
from AthenaCommon.BeamFlags import jobproperties
beamFlags = jobproperties.Beam
SegmentLocation = "MuonSegments"
if muonStandaloneFlags.segmentOrigin == 'TruthTracking':
SegmentLocation = "ThirdChainSegments"
# do the following in case of (at least one) NSW
if (MuonGeometryFlags.hasSTGC() and MuonGeometryFlags.hasMM()):
getPublicTool("MuonLayerHoughTool")
self.addAlg( CfgMgr.MuonLayerHoughAlg( "MuonLayerHoughAlg",
PrintSummary = muonStandaloneFlags.printSummary(),
CscPrepDataContainer = ("CSC_Clusters" if MuonGeometryFlags.hasCSC() else ""),
sTgcPrepDataContainer = ("STGC_Measurements" if MuonGeometryFlags.hasSTGC() else ""),
MMPrepDataContainer = ("MM_Measurements" if MuonGeometryFlags.hasMM() else "") ) )
if not muonStandaloneFlags.patternsOnly():
SegmentFinder = getPublicTool("MuonClusterSegmentFinderTool")
Cleaner = getPublicToolClone("MuonTrackCleaner_seg","MuonTrackCleaner")
Cleaner.Extrapolator = getPublicTool("MuonStraightLineExtrapolator")
Cleaner.Fitter = getPublicTool("MCTBSLFitterMaterialFromTrack")
Cleaner.PullCut = 3
Cleaner.PullCutPhi = 3
Cleaner.UseSLFit = True
SegmentFinder.TrackCleaner = Cleaner
# for test purposes allow parallel running of truth segment finding and new segment finder
MuonSegmentFinderAlg = CfgMgr.MuonSegmentFinderAlg( "MuonSegmentMaker",SegmentCollectionName=SegmentLocation,
MuonPatternCalibration = getPublicTool("MuonPatternCalibration"),
MuonPatternSegmentMaker = getPublicTool("MuonPatternSegmentMaker"),
MuonTruthSummaryTool = None,
PrintSummary = muonStandaloneFlags.printSummary() )
# we check whether the layout contains any CSC chamber and if yes, we check that the user also wants to use the CSCs in reconstruction
if MuonGeometryFlags.hasCSC() and muonRecFlags.doCSCs():
getPublicTool("CscSegmentUtilTool")
getPublicTool("Csc2dSegmentMaker")
getPublicTool("Csc4dSegmentMaker")
else:
MuonSegmentFinderAlg.Csc2dSegmentMaker = ""
MuonSegmentFinderAlg.Csc4dSegmentMaker = ""
self.addAlg( MuonSegmentFinderAlg )
else:
getPublicTool("MuonLayerHoughTool")
self.addAlg(MooSegmentFinderAlg("MuonSegmentMaker"))
self.addAlg(MooSegmentFinderNCBAlg("MuonSegmentMaker_NCB"))
if (not cfgKeyStore.isInInput ('xAOD::MuonSegmentContainer', 'MuonSegments_NCB')):
self.addAlg( CfgMgr.xAODMaker__MuonSegmentCnvAlg("MuonSegmentCnvAlg_NCB",SegmentContainerName="NCB_MuonSegments",xAODContainerName="NCB_MuonSegments") )
if (not cfgKeyStore.isInInput ('xAOD::MuonSegmentContainer', 'MuonSegments')):
self.addAlg( CfgMgr.xAODMaker__MuonSegmentCnvAlg("MuonSegmentCnvAlg") )
if muonStandaloneFlags.doSegmentsOnly():
return
# Tracks builder
#
# add the algorithm (which uses the MuonTrackSteering)
#
TrackBuilder = CfgMgr.MuPatTrackBuilder("MuPatTrackBuilder", TrackSteering = getPublicTool("MuonTrackSteering") )
self.addAlg( TrackBuilder )
self.registerOutputKey("MuonSpectrometerTracks", self.MuPatTrackBuilder, "SpectrometerTrackOutputLocation")
self.registerInputKey ("MuonSegments", self.MuPatTrackBuilder, "MuonSegmentCollection" )
if muonStandaloneFlags.createTrackParticles():
xAODTrackParticleCnvAlg = MuonStandaloneTrackParticleCnvAlg("MuonStandaloneTrackParticleCnvAlg")
self.addAlg( xAODTrackParticleCnvAlg )
addTool("MuonRecExample.MuonRecTools.MuonRK_Propagator", "MuonRK_Propagator")
addTool("MuonRecExample.MuonRecTools.MuonSTEP_Propagator",
"MuonSTEP_Propagator")
addTool("MuonRecExample.MuonRecTools.MuonSTEP_Propagator", "MuonPropagator")
addTool("MuonRecExample.MuonRecTools.MuonSTEP_Propagator", "MCTBPropagator")
addTool("Trk::STEP_Propagator", "MuonStraightLinePropagator")
addTool("MuonRecExample.MuonRecTools.MuonExtrapolator", "MuonExtrapolator")
addTool("MuonRecExample.MuonRecTools.MuonStraightLineExtrapolator",
"MuonStraightLineExtrapolator")
addTool("Trk::KalmanUpdator", "MuonMeasUpdator")
addService("Muon::MuonIdHelperSvc",
"MuonIdHelperSvc",
HasCSC=MuonGeometryFlags.hasCSC(),
HasSTgc=MuonGeometryFlags.hasSTGC(),
HasMM=MuonGeometryFlags.hasMM())
addTool("Muon::MuonTrackTruthTool", "MuonTrackTruthTool")
addTool("MuonRecExample.MooreTools.MuonTrackToSegmentTool",
"MuonTrackToSegmentTool")
addService("MuonRecExample.MuonRecTools.MuonEDMHelperSvc", "MuonEDMHelperSvc")
addTool("MuonRecExample.MuonRecTools.MuonEDMPrinterTool", "MuonEDMPrinterTool")
addTool("MuonRecExample.MuonRecTools.MuonKalmanTrackFitter",
"MuonKalmanTrackFitter")
jp.PerfMonFlags.doFastMon = True # to only enable a lightweight monitoring
if hasattr(runArgs, "preExec") and runArgs.preExec != 'NONE':
for cmd in runArgs.preExec:
exec(cmd)
#TileFrameLength=7
from AthenaCommon.AppMgr import ServiceMgr
from AthenaCommon.GlobalFlags import globalflags
from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
from OverlayCommonAlgs.OverlayFlags import overlayFlags
from MuonRecExample.MuonRecFlags import muonRecFlags
from AtlasGeoModel.MuonGMJobProperties import MuonGeometryFlags
if MuonGeometryFlags.hasCSC(): muonRecFlags.doCSCs.set_Value_and_Lock(True)
from LArConditionsCommon.LArCondFlags import larCondFlags
larCondFlags.LArCoolChannelSelection.set_Value_and_Lock("")
larCondFlags.useShape.set_Value_and_Lock(True)
larCondFlags.OFCShapeFolder.set_Value_and_Lock("")
globalflags.isOverlay.set_Value_and_Lock(True)
overlayFlags.isDataOverlay.set_Value_and_Lock(True)
from AthenaCommon.BeamFlags import jobproperties
jobproperties.Beam.beamType.set_Value_and_Lock("collisions")
import AthenaCommon.AtlasUnixStandardJob #FIXME: Is this needed?
if hasattr(runArgs,"preInclude"):
# call setDefaults to update flags
muonRecFlags.setDefaults()
class MuPatCandidateTool(CfgMgr.Muon__MuPatCandidateTool,ConfiguredBase):
__slots__ = ()
def __init__(self,name='MuPatCandidateTool',**kwargs):
self.applyUserDefaults(kwargs,name)
if not MuonGeometryFlags.hasCSC():
kwargs["CscRotCreator"] = ""
super(MuPatCandidateTool,self).__init__(name,**kwargs)
class MuPatHitTool(CfgMgr.Muon__MuPatHitTool,ConfiguredBase):
__slots__ = ()
def __init__(self,name="MuPatHitTool",**kwargs):
self.applyUserDefaults(kwargs,name)
if not muonRecFlags.doCSCs():
# overwrite whatever is set
kwargs["CscRotCreator"] = ""
super(MuPatHitTool,self).__init__(name,**kwargs)
getPublicTool("ResidualPullCalculator")
MuPatHitTool.setDefaultProperties(
CscRotCreator = ("FixedErrorMuonClusterOnTrackCreator" if MuonGeometryFlags.hasCSC() else ""),
MdtRotCreator = "MdtDriftCircleOnTrackCreatorPreFit" )
# end of class MuPatHitTool
def __init__(self, name="TrigMuonEFStandaloneTrackTool", **kwargs):
super(TrigMuonEFStandaloneTrackToolConfig,
self).__init__(name, **kwargs)
if MuonGeometryFlags.hasCSC():
self.CscClusterProvider = CfgGetter.getPublicTool(
"CscThresholdClusterBuilderTool")
self.SegmentsFinderTool = CfgGetter.getPublicToolClone(
"TMEF_SegmentsFinderTool",
"MooSegmentFinder",
HoughPatternFinder=CfgGetter.getPublicTool("MuonLayerHoughTool"),
Csc2dSegmentMaker=("Csc2dSegmentMaker/Csc2dSegmentMaker"
if MuonGeometryFlags.hasCSC() else ""),
Csc4dSegmentMaker=("Csc4dSegmentMaker/Csc4dSegmentMaker"
if MuonGeometryFlags.hasCSC() else ""))
CfgGetter.getPublicTool("MuonHoughPatternFinderTool").RecordAll = False
CfgGetter.getPublicTool("MuonLayerHoughTool").DoTruth = False
CfgGetter.getPublicTool("MooTrackFitter").SLFit = False
self.MdtRawDataProvider = "TMEF_MdtRawDataProviderTool"
self.CscRawDataProvider = "TMEF_CscRawDataProviderTool"
self.RpcRawDataProvider = "TMEF_RpcRawDataProviderTool"
self.TgcRawDataProvider = "TMEF_TgcRawDataProviderTool"
#Need to run non-MT version of decoding tools in the trigger since the caching is not available in MT versions
#Need different PRD container names to run offline and trigger in same jobs, but there are many tools that depend on these containers...
#Since this is legacy code only used for validation comparisons against the Run 3 triggers, will do the not-particularly-nice solution of
#creating containers with unique names only if we are running offline and trigger in the same jobs, and otherwise just use the default names.
#This means that the trigger output when running the trigger as part of RAWtoESD is not 100% correct (the pattern finding uses the correct containers,
#so it's a small effect overall anyway), but that's an use case not currently needed for trigger validation purposes
from AthenaCommon.AppMgr import ToolSvc
#MDT
from MuonMDT_CnvTools.MuonMDT_CnvToolsConf import Muon__MdtRdoToPrepDataTool
from MuonCSC_CnvTools.MuonCSC_CnvToolsConf import Muon__CscRdoToCscPrepDataTool
from MuonTGC_CnvTools.MuonTGC_CnvToolsConf import Muon__TgcRdoToPrepDataTool
from MuonRPC_CnvTools.MuonRPC_CnvToolsConf import Muon__RpcRdoToPrepDataTool
MdtRdoToMdtPrepDataTool = Muon__MdtRdoToPrepDataTool(
name="TrigEFMdtRdoToPrepDataTool")
CscRdoToCscPrepDataTool = Muon__CscRdoToCscPrepDataTool(
name="TrigEFCscRdoToPrepDataTool")
TgcRdoToTgcPrepDataTool = Muon__TgcRdoToPrepDataTool(
name="TrigEFTgcRdoToPrepDataTool")
RpcRdoToRpcPrepDataTool = Muon__RpcRdoToPrepDataTool(
name="TrigEFRpcRdoToPrepDataTool")
if not rec.doRDOTrigger and rec.doESD:
MdtRdoToMdtPrepDataTool.OutputCollection = "TrigMDT_DriftCircles"
CscRdoToCscPrepDataTool.OutputCollection = "TrigCSC_Measurements"
TgcRdoToTgcPrepDataTool.OutputCollection = "TrigTGC_Measurements"
TgcRdoToTgcPrepDataTool.OutputCoinCollection = "TrigerT1CoinDataCollection"
RpcRdoToRpcPrepDataTool.TriggerOutputCollection = "TrigRPC_Measurements"
#InputCollection is really the output RPC coin collection...
RpcRdoToRpcPrepDataTool.InputCollection = "TrigRPC_triggerHits"
else:
MdtRdoToMdtPrepDataTool.OutputCollection = "MDT_DriftCircles"
CscRdoToCscPrepDataTool.OutputCollection = "CSC_Measurements"
TgcRdoToTgcPrepDataTool.OutputCollection = "TGC_Measurements"
TgcRdoToTgcPrepDataTool.OutputCoinCollection = "TrigT1CoinDataCollection"
RpcRdoToRpcPrepDataTool.TriggerOutputCollection = "RPC_Measurements"
RpcRdoToRpcPrepDataTool.InputCollection = "RPC_triggerHits"
ToolSvc += MdtRdoToMdtPrepDataTool
self.MdtPrepDataContainer = MdtRdoToMdtPrepDataTool.OutputCollection
self.MdtPrepDataProvider = MdtRdoToMdtPrepDataTool
#CSC
ToolSvc += CscRdoToCscPrepDataTool
self.CscPrepDataProvider = CscRdoToCscPrepDataTool
#We use the clusters not the PRD hits directly for CSCs
self.CscPrepDataContainer = "CSC_Clusters"
#TGC
ToolSvc += TgcRdoToTgcPrepDataTool
self.TgcPrepDataProvider = TgcRdoToTgcPrepDataTool
self.TgcPrepDataContainer = TgcRdoToTgcPrepDataTool.OutputCollection
#RPC
ToolSvc += RpcRdoToRpcPrepDataTool
self.RpcPrepDataProvider = RpcRdoToRpcPrepDataTool
self.RpcPrepDataContainer = RpcRdoToRpcPrepDataTool.TriggerOutputCollection
self.DecodeMdtBS = DetFlags.readRDOBS.MDT_on()
self.DecodeRpcBS = DetFlags.readRDOBS.RPC_on()
self.DecodeTgcBS = DetFlags.readRDOBS.TGC_on()
if MuonGeometryFlags.hasCSC():
self.DecodeCscBS = DetFlags.readRDOBS.CSC_on()
# use seeded decoding
if (TriggerFlags.MuonSlice.doEFRoIDrivenAccess()):
self.useMdtSeededDecoding = True
self.useRpcSeededDecoding = True
self.useTgcSeededDecoding = True
if MuonGeometryFlags.hasCSC(): self.useCscSeededDecoding = True
# use ROB based seeded decoding instead of PRD based
self.useTgcRobDecoding = False # neither available nor needed
self.useCscRobDecoding = False # neither available nor needed
self.useRpcData = muonRecFlags.doRPCs()
self.useTgcData = muonRecFlags.doTGCs()
self.useCscData = muonRecFlags.doCSCs()
# to select barrel(useMdtData=2), endcap(useMdtData=3)
if muonRecFlags.doMDTs():
self.useMdtData = 1
else:
self.useMdtData = 0
self.useTGCInPriorNextBC = False
self.doTimeOutChecks = False
self.doTimeOutGuard = False
self.maxTgcHits = 0
self.maxCscHits = 0
self.maxRpcHits = 0
self.maxMdtHits = 0
self.doCache = True
self.IgnoreMisalginedCSCs = False
self.TrackBuilderTool = "TMEF_TrackBuilderTool"
self.TrkSummaryTool = "TMEF_TrackSummaryTool"
self.MuonCandidateTool = "TMEF_MuonCandidateTool"
self.TrackToTrackParticleConvTool = "MuonParticleCreatorTool"
import MuonCondAlg.MdtCondDbAlgConfig # noqa: F401 (MDT conditions, needed for the MuonStationIntersectSvc)
ToolSvc += muonErrorScaleDbTool
muonErrorScalingTool = Muon__MuonRIO_OnTrackErrorScalingTool(
"MuonRIO_OnTrackErrorScalingTool",
OutputLevel=align.OutputLevel(),
ErrorScaleDbTool=muonErrorScaleDbTool)
ToolSvc += muonErrorScalingTool
from MuonRecExample import MuonRecTools
MdtDriftCircleOnTrackCreator = MuonRecTools.getPublicTool(
"MdtDriftCircleOnTrackCreator")
MdtDriftCircleOnTrackCreator.DoErrorScaling = True
MdtDriftCircleOnTrackCreator.OutputLevel = align.OutputLevel()
MdtDriftCircleOnTrackCreator.ErrorScalingTool = muonErrorScalingTool
from AtlasGeoModel.MuonGMJobProperties import MuonGeometryFlags
if MuonGeometryFlags.hasCSC():
CscClusterOnTrackCreator = MuonRecTools.getPublicTool(
"CscClusterOnTrackCreator")
CscClusterOnTrackCreator.DoErrorScaling = True
CscClusterOnTrackCreator.OutputLevel = align.OutputLevel()
CscClusterOnTrackCreator.ErrorScalingTool = muonErrorScalingTool
MuonClusterOnTrackCreator = MuonRecTools.getPublicTool(
"MuonClusterOnTrackCreator")
MuonClusterOnTrackCreator.DoErrorScaling = True
MuonClusterOnTrackCreator.OutputLevel = align.OutputLevel()
MuonClusterOnTrackCreator.ErrorScalingTool = muonErrorScalingTool
try:
doSetup
doSetup()
from MuonCombinedRecExample import MuonCombinedCalibConfig
#--------------------------------------------------------------------------
# Do track truth
#--------------------------------------------------------------------------
if rec.doTruth() and muonCombinedRecFlags.doxAOD() and rec.doMuonCombined():
from MuonTruthAlgs.MuonTruthAlgsConf import MuonDetailedTrackTruthMaker
from TrkTruthAlgs.TrkTruthAlgsConf import TrackTruthSelector
colsTP = [ "ExtrapolatedMuonTrackParticles", "CombinedMuonTrackParticles", "MSOnlyExtrapolatedMuonTrackParticles" ]
cols = [ "ExtrapolatedMuonTracks", "CombinedMuonTracks", "MSOnlyExtrapolatedTracks" ]
topSequence+= MuonDetailedTrackTruthMaker("MuonCombinedDetailedTrackTruthMaker")
topSequence.MuonCombinedDetailedTrackTruthMaker.TrackCollectionNames = cols
from AtlasGeoModel.MuonGMJobProperties import MuonGeometryFlags
topSequence.MuonCombinedDetailedTrackTruthMaker.HasCSC = MuonGeometryFlags.hasCSC()
topSequence.MuonCombinedDetailedTrackTruthMaker.HasSTgc = MuonGeometryFlags.hasSTGC()
topSequence.MuonCombinedDetailedTrackTruthMaker.HasMM = MuonGeometryFlags.hasMM()
from TrkTruthAlgs.TrkTruthAlgsConf import TrackParticleTruthAlg
for i in range(0, len(cols)):
topSequence += TrackTruthSelector(name= cols[i] + "Selector",
DetailedTrackTruthName = cols[i] + "DetailedTruth",
OutputName = cols[i] + "Truth" )
topSequence += TrackParticleTruthAlg(name = cols[i]+"TruthAlg",
TrackTruthName=cols[i]+"Truth",
TrackParticleName = colsTP[i] )
from MuonTruthAlgs.MuonTruthAlgsConf import MuonTruthAssociationAlg
topSequence += MuonTruthAssociationAlg("MuonTruthAssociationAlg")
include.block("MuonByteStreamCnvTest/jobOptions_MuonRDOToDigit.py")
from AthenaCommon.CfgGetter import getPublicTool
from AtlasGeoModel.MuonGMJobProperties import MuonGeometryFlags
## configure the tool
from MuonByteStreamCnvTest.MuonByteStreamCnvTestConf import MuonRdoToMuonDigitTool
MuonRdoToMuonDigitTool = MuonRdoToMuonDigitTool(
DecodeMdtRDO=True,
DecodeRpcRDO=True,
DecodeTgcRDO=True,
DecodeCscRDO=MuonGeometryFlags.hasCSC(),
DecodeSTGC_RDO=MuonGeometryFlags.hasSTGC(),
DecodeMM_RDO=MuonGeometryFlags.hasMM(),
cscRdoDecoderTool=("Muon::CscRDO_Decoder"
if MuonGeometryFlags.hasCSC() else ""),
stgcRdoDecoderTool=("Muon::STGC_RDO_Decoder"
if MuonGeometryFlags.hasSTGC() else ""),
mmRdoDecoderTool=("Muon::MM_RDO_Decoder"
if MuonGeometryFlags.hasMM() else ""))
if MuonGeometryFlags.hasCSC():
MuonRdoToMuonDigitTool.cscCalibTool = getPublicTool("CscCalibTool")
ToolSvc += MuonRdoToMuonDigitTool
## configure the algorithm
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
include.block("ISF_Config/AllDet_detDescr.py")
# also block alternatives
include.block("RecExCond/AllDet_detDescr.py")
include.block("RecExCommon/AllDet_detDescr.py")
from AthenaCommon.Resilience import protectedInclude
from AthenaCommon.DetFlags import DetFlags
if DetFlags.detdescr.any_on():
from AtlasGeoModel import SetGeometryVersion
from AtlasGeoModel import GeoModelInit
from AtlasGeoModel import SetupRecoGeometry
import os
if "AthSimulation_DIR" not in os.environ:
if DetFlags.detdescr.LAr_on():
protectedInclude("LArDetDescr/LArDetDescr_joboptions.py")
if DetFlags.detdescr.Tile_on():
protectedInclude("TileConditions/TileConditions_jobOptions.py")
if DetFlags.detdescr.Muon_on():
protectedInclude("AmdcAth/AmdcAth_jobOptions.py")
from AtlasGeoModel.MuonGMJobProperties import MuonGeometryFlags
if not MuonGeometryFlags.hasCSC():
DetFlags.CSC_setOff()
# MagneticField Service
if DetFlags.detdescr.BField_on():
import MagFieldServices.SetupField
include.block('RecBackgroundAlgs/RecBackground_jobOptions.py')
from RecExConfig.RecFlags import rec
from AthenaCommon.DetFlags import DetFlags
from AtlasGeoModel.MuonGMJobProperties import MuonGeometryFlags
if rec.doInDet() and rec.doMuon() and rec.doCalo() and \
DetFlags.detdescr.Muon_on() and DetFlags.detdescr.Calo_on() and DetFlags.detdescr.ID_on() :
include("LArCellRec/LArCollisionTime_jobOptions.py")
from RecBackgroundAlgs.RecBackgroundAlgsConf import BeamBackgroundFiller
BeamBackgroundFiller = BeamBackgroundFiller(cscSegmentContainerKey=(
"NCB_MuonSegments" if MuonGeometryFlags.hasCSC() else ""))
topSequence += BeamBackgroundFiller
from BCM_BackgroundAlgs.BCM_BackgroundAlgsConf import BcmCollisionTimeAlg
BcmCollisionTimeAlg = BcmCollisionTimeAlg()
topSequence += BcmCollisionTimeAlg
from RecBackgroundAlgs.RecBackgroundAlgsConf import BackgroundWordFiller
BackgroundWordFiller = BackgroundWordFiller()
topSequence += BackgroundWordFiller
BackgroundWordFiller.IsMC = (globalflags.DataSource.get_Value() != 'data')
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')
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("TileInactiveCellCaloCalibHitsTestTool",
checkType=True)
]
##job.G4TestAlg.SimTestTools += [CfgGetter.getPrivateTool("TileDeadMaterialCaloCalibHitsTestTool", checkType=True)]
if DetFlags.Muon_on():
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("MDTHitsTestTool", checkType=True)
]
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("RPCHitsTestTool", checkType=True)
]
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("TGCHitsTestTool", checkType=True)
]
if MuonGeometryFlags.hasCSC():
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("CSCHitsTestTool", checkType=True)
]
if MuonGeometryFlags.hasMM():
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("MMHitsTestTool", checkType=True)
]
if MuonGeometryFlags.hasSTGC():
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("sTGCHitsTestTool", checkType=True)
]
if DetFlags.Truth_on():
job.G4TestAlg.SimTestTools += [
CfgGetter.getPrivateTool("MuonEntryLayerTestTool", checkType=True)
]
def __init__(self,name='MuPatCandidateTool',**kwargs):
self.applyUserDefaults(kwargs,name)
if not MuonGeometryFlags.hasCSC():
kwargs["CscRotCreator"] = ""
super(MuPatCandidateTool,self).__init__(name,**kwargs)
def _do_jobproperties(self):
"""
Place to handle JobProperties.
"""
## Import extra flags if it hasn't already been done
from G4AtlasApps.SimFlags import simFlags
if "atlas_flags" not in simFlags.extra_flags:
simFlags.load_atlas_flags()
if jobproperties.Beam.beamType(
) == "cosmics" and "cosmics_flags" not in simFlags.extra_flags:
simFlags.load_cosmics_flags()
AtlasG4Eng.G4Eng.log.verbose(
'AtlasSimSkeleton._do_jobproperties :: starting')
## Tidy up DBM DetFlags: temporary measure
DetFlags.DBM_setOff()
from AtlasGeoModel.MuonGMJobProperties import MuonGeometryFlags
if not MuonGeometryFlags.hasCSC(): DetFlags.CSC_setOff()
if not MuonGeometryFlags.hasSTGC(): DetFlags.sTGC_setOff()
if not MuonGeometryFlags.hasMM(): DetFlags.Micromegas_setOff()
## Switch off tasks
DetFlags.pileup.all_setOff()
DetFlags.simulateLVL1.all_setOff()
DetFlags.digitize.all_setOff()
if not simFlags.IsEventOverlayInputSim():
DetFlags.overlay.all_setOff()
DetFlags.readRDOPool.all_setOff()
DetFlags.makeRIO.all_setOff()
DetFlags.writeBS.all_setOff()
DetFlags.readRDOBS.all_setOff()
DetFlags.readRIOBS.all_setOff()
DetFlags.readRIOPool.all_setOff()
DetFlags.writeRIOPool.all_setOff()
DetFlags.writeRDOPool.all_setOff()
## Global flags needed by externals
from AthenaCommon.GlobalFlags import globalflags
globalflags.DataSource = 'geant4'
if jobproperties.Beam.beamType() == 'cosmics':
globalflags.DetGeo = 'commis'
else:
globalflags.DetGeo = 'atlas'
## At this point we can set the global job properties flag
globalflags.DetDescrVersion = simFlags.SimLayout.get_Value()
# Switch off GeoModel Release in the case of parameterization
if simFlags.LArParameterization.get_Value(
) > 0 and simFlags.ReleaseGeoModel():
AtlasG4Eng.G4Eng.log.info(
'AtlasSimSkeleton._do_jobproperties :: Running parameterization - switching off GeoModel release!'
)
simFlags.ReleaseGeoModel = False
## Translate conditions tag into IOVDbSvc global tag: must be done before job properties are locked!!!
from AthenaCommon.AppMgr import ServiceMgr
from IOVDbSvc.IOVDbSvcConf import IOVDbSvc
ServiceMgr += IOVDbSvc()
if not hasattr(
globalflags,
"ConditionsTag") or not globalflags.ConditionsTag.get_Value():
msg = "AtlasSimSkeleton._do_jobproperties :: conditions tag has not been set and is no longer guessed by SimAtlasKernel. "
msg += "You must set the globaltags.ConditionsTag flag in your job options."
AtlasG4Eng.G4Eng.log.error(msg)
raise SystemExit(
"AtlasSimSkeleton._do_jobproperties :: Global ConditionsTag not set"
)
if not hasattr(ServiceMgr.IOVDbSvc,
'GlobalTag') or not ServiceMgr.IOVDbSvc.GlobalTag:
ServiceMgr.IOVDbSvc.GlobalTag = globalflags.ConditionsTag.get_Value(
)
## Enable floating point exception handling
## FIXME! This seems to cause the jobs to crash in the FpeControlSvc, so commenting this out for now...
#from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
#athenaCommonFlags.RuntimeStrictness = 'abort'
#AtlasG4Eng.G4Eng.log.debug('AtlasSimSkeleton._do_jobproperties :: Enabled floating point exceptions')
if not simFlags.ISFRun:
from G4AtlasApps.G4Atlas_Metadata import checkForSpecialConfigurationMetadata
checkForSpecialConfigurationMetadata()
## Print flags
if AtlasG4Eng.G4Eng.log.getEffectiveLevel() < 40:
AtlasG4Eng.G4Eng.log.info(
'AtlasSimSkeleton._do_jobproperties :: printing detector flags DetFlags'
)
DetFlags.Print()
AtlasG4Eng.G4Eng.log.info(
'AtlasSimSkeleton._do_jobproperties :: printing simulation flags simFlags'
)
jobproperties.print_JobProperties('tree&value')
# Lock the job properties if not running ISF.
if not simFlags.ISFRun:
jobproperties.lock_JobProperties()
AtlasG4Eng.G4Eng.log.verbose(
'AtlasSimSkeleton._do_jobproperties :: done')