def test3ToolSvc( self ):
"""Test ToolSvc __iadd__"""
from AthenaCommon.AppMgr import ToolSvc
from AthenaCommon.Configurable import ConfigurableAlgTool, ConfigurableService
t1 = ConfigurableAlgTool('tool1')
t2 = ConfigurableAlgTool('tool2')
s1 = ConfigurableService('svc1')
## Check silent adding of duplicate
ToolSvc += t1
self.assertEqual( ToolSvc.getChildren(), [t1] )
ToolSvc += t1
self.assertEqual( ToolSvc.getChildren(), [t1] )
ToolSvc += [t1,t2]
self.assertEqual( ToolSvc.getChildren(), [t1,t2] )
## Check type checking
with self.assertRaises(TypeError):
ToolSvc += s1
with self.assertRaises(TypeError):
ToolSvc += [s1]
return
def test2SetToolProperties(self):
"""Test setting of tool properties"""
from AthExHelloWorld.AthExHelloWorldConf import HelloAlg
from AthExHelloWorld.AthExHelloWorldConf import HelloTool
HelloWorld = HelloAlg('HelloWorld')
msg1 = "A Private Message!"
HelloWorld.MyPrivateHelloTool = HelloTool("HelloTool")
HelloWorld.MyPrivateHelloTool.MyMessage = msg1
HelloWorld.setup()
global ToolSvc
msg2 = "A Public Message!"
ToolSvc += HelloTool("PublicHello")
ToolSvc.PublicHello.MyMessage = msg2
ToolSvc.setup()
self.assertEqual(HelloWorld.MyPrivateHelloTool.MyMessage, msg1)
client = HelloWorld.getName(
) + '.' + HelloWorld.MyPrivateHelloTool.getName()
self.assert_(JobOptionsSvc.verify(client, 'MyMessage', msg1))
self.assertEqual(ToolSvc.PublicHello.MyMessage, msg2)
self.assert_(
JobOptionsSvc.verify('ToolSvc.PublicHello', 'MyMessage', msg2))
def test2SetToolProperties( self ):
"""Test setting of tool properties"""
from AthExHelloWorld.AthExHelloWorldConf import HelloAlg
from AthExHelloWorld.AthExHelloWorldConf import HelloTool
HelloWorld = HelloAlg( 'HelloWorld' )
msg1 = "A Private Message!"
HelloWorld.MyPrivateHelloTool = HelloTool( "HelloTool" )
HelloWorld.MyPrivateHelloTool.MyMessage = msg1
HelloWorld.setup()
global ToolSvc
msg2 = "A Public Message!"
ToolSvc += HelloTool( "PublicHello" )
ToolSvc.PublicHello.MyMessage = msg2
ToolSvc.setup()
self.assertEqual( HelloWorld.MyPrivateHelloTool.MyMessage, msg1 )
client = HelloWorld.getName() + '.' + HelloWorld.MyPrivateHelloTool.getName()
self.assert_( JobOptionsSvc.verify( client, 'MyMessage', msg1 ) )
self.assertEqual( ToolSvc.PublicHello.MyMessage, msg2 )
self.assert_( JobOptionsSvc.verify( 'ToolSvc.PublicHello', 'MyMessage', msg2 ) )
def __init__(self, name='CaloTrackingGeometryBuilderCond'):
from TrkDetDescrSvc.TrkDetDescrJobProperties import TrkDetFlags
from LArTrackingGeometry.ConfiguredLArVolumeBuilder import ConfiguredLArVolumeBuilder
# import the ToolSvc
from AthenaCommon.AppMgr import ToolSvc
if 'ToolSvc' not in dir():
ToolSvc = ToolSvc()
ConfLArVolumeBuilder = ConfiguredLArVolumeBuilder()
ToolSvc += ConfLArVolumeBuilder
from TileTrackingGeometry.ConfiguredTileVolumeBuilder import ConfiguredTileVolumeBuilder
ConfTileVolumeBuilder = ConfiguredTileVolumeBuilder()
ToolSvc += ConfTileVolumeBuilder
# The volume helper
from TrkDetDescrTools.TrkDetDescrToolsConf import Trk__TrackingVolumeHelper
CaloTrackingVolumeHelper = Trk__TrackingVolumeHelper(
name='TrackingVolumeHelper')
ToolSvc += CaloTrackingVolumeHelper
Calo__CaloTrackingGeometryBuilderCond.__init__(self,name,\
LArVolumeBuilder = ConfLArVolumeBuilder,\
TileVolumeBuilder = ConfTileVolumeBuilder,\
TrackingVolumeHelper = CaloTrackingVolumeHelper,\
GapLayerEnvelope = TrkDetFlags.CaloEnvelopeCover(),\
EntryVolumeName = TrkDetFlags.CaloEntryVolumeName(),\
ExitVolumeName = TrkDetFlags.CaloContainerName(),
MagneticFieldMode = TrkDetFlags.MagneticFieldMode())
def __init__(self, name='MuonTrackingGeometryBuilder'):
from TrkDetDescrSvc.TrkDetDescrJobProperties import TrkDetFlags
# import the ToolSvc
from AthenaCommon.AppMgr import ToolSvc
if 'ToolSvc' not in dir():
ToolSvc = ToolSvc()
from MuonTrackingGeometry.MuonTrackingGeometryConf import Muon__MuonStationTypeBuilder
MuonStationTypeBuilder = Muon__MuonStationTypeBuilder(
name='MuonStationTypeBuilder')
ToolSvc += MuonStationTypeBuilder
# muon active/passive geometry setup
from MuonTrackingGeometry.MuonTrackingGeometryConf import Muon__MuonStationBuilder
MuonStationBuilder = Muon__MuonStationBuilder(
name='MuonStationBuilder')
ToolSvc += MuonStationBuilder
from MuonTrackingGeometry.MuonTrackingGeometryConf import Muon__MuonInertMaterialBuilder
MuonInertMaterialBuilder = Muon__MuonInertMaterialBuilder(
name='MuonInertMaterialBuilder')
ToolSvc += MuonInertMaterialBuilder
Muon__MuonTrackingGeometryBuilder.__init__(self,name,\
EntryVolumeName=TrkDetFlags.MuonSystemEntryVolumeName(),\
ExitVolumeName = TrkDetFlags.MuonSystemContainerName())
def __getitem__(self, key, refresh=True):
if refresh:
# remove current configuration first, as much as possible, to prevent
# hysteresis; note that if the user keeps configurables around in the
# main (or any other) space, a merge will occur
from AthenaCommon.AlgSequence import AlgSequence
topSeq = AlgSequence()
topSeq.removeAll()
from AthenaCommon.AppMgr import theApp, ServiceMgr, ToolSvc, theAuditorSvc
theApp._streams.removeAll()
ServiceMgr.removeAll()
ToolSvc.removeAll()
theAuditorSvc.removeAll()
del topSeq, theApp, ServiceMgr, ToolSvc, theAuditorSvc
return self._shelve[key]
def tooldiff():
from AthenaCommon.AppMgr import ToolSvc
from AthenaCommon.AppMgr import ServiceMgr
alltools = ToolSvc.getAllChildren()
alltools += ServiceMgr.getAllChildren()
toolmap = dict()
for i in alltools:
tooltype = i.configurables.keys()[0]
toolitems = i.configurables.items()
if toolmap.has_key(tooltype):
if toolmap[tooltype] != toolitems:
print '%s seen before' % tooltype,
print ' and differs'
print 'previous contents: ', toolmap[tooltype]
print 'new contents: ', toolitems
else:
toolmap[tooltype] = toolitems
for i in toolmap.keys():
print ' '
print ' '
print '******************************************************************************'
print 'toolmap key ', i
print '******************************************************************************'
if len(toolmap[i]) > 1:
firsttool = toolmap[i][1]
prop = firsttool[1].getProperties()
prop_differ = False
diff_list = list()
diffvals = dict()
diffvals[firsttool] = prop
for j in toolmap[i]:
print 'toolmap item ', j
print j[1]
print ' '
if prop != j[1].getProperties():
prop_differ = True
jprop = j[1].getProperties()
diffvals[j[1]] = jprop
for p in prop.keys():
if prop[p] != jprop[p]:
diff_list.append(p)
if prop_differ:
print 'Properties differ in ', set(diff_list)
for kk in diffvals.keys():
print kk, diffvals[kk]
else:
print 'single item'
print '******************************************************************************'
def debuglevel(level=2):
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
if hasattr(job, 'TrigSteer_HLT'):
steeringEF = job.TrigSteer_HLT
steeringEF.OutputLevel = level
import re
exp = re.compile("EFID|FTF|IDTrig|FTK|L2ID")
pokus = None
reftoconf = list()
reftoname = list()
for alg in steeringEF.getAllChildren():
try:
algname = alg.name()
except:
print 'No algname for ', alg
algname = ''
if exp.search(algname):
print algname
try:
alg.OutputLevel = level
pokus = alg
except:
pass
for j in alg.properties().items():
(aa, ab) = j
if hasattr(type(ab), '__name__'):
nm = type(ab).__name__
if nm.find('ToolHandle') > -1 and nm.find(
'ToolHandleArray') == -1:
print nm
reftoconf.append(ab)
reftoname.append(ab.getName())
from AthenaCommon.AppMgr import ToolSvc
for t in ToolSvc.getAllChildren():
for it in reftoname:
if t.getName().find(it) > -1:
try:
t.OutputLevel = level
except:
print 'Setting of outputlevel failed for ', t
def get_available_trigger_monitoring_tools(self):
"Get list of currently running trigger-monitoring tools"
# get list of all tools in ToolSvc
tool_list = ToolSvc.getAllChildren()
# list of monitoring tools
mon_tools = []
# loop over tools
for tool in tool_list:
# skip tools with names that will garble our commands
# (no TrigMonTools do this)
# specifically skip tools with scope resolution operators in their names (why do they have these here!?)
if "::" in tool.getName():
print "Skipping",tool.getName(),"as its name contains a scope resolution operator '::'."
continue
# OLD:
# find if Trig and Monitoring are in the tool Dll name
if "Trig" in tool.getDlls() and "Monitoring" in tool.getDlls():
mon_tools.append(tool.getName())
#
# NEW:
# find if Trig and Monitoring are in the tool Dll name, or if the tool name contains both 'Mon' and either 'HLT' or 'Trig'
# (This change was made to catch TrigEgammaMonTool, which has 'TrigEgammaAnalysisTools' as its Dll name)
# FURTHER EDIT: extra if statemend added below (7 lines below here) to catch all TrigEgammaAnalysisTools, so we can just revert back to the previous 'OLD' if statement above
#if ( "Trig" in tool.getDlls() and "Monitoring" in tool.getDlls() ) or ( ("HLT" in tool.getName() or "Trig" in tool.getName()) and "Mon" in tool.getName() ):
# mon_tools.append(tool.getName())
# of if the tool Dll name is TrigInDetAnalysisExample, as is the case for the IDtrk tools
if 'TrigInDetAnalysisExample' == tool.getDlls():
mon_tools.append(tool.getName())
# of if the tool Dll name is TrigEgammaAnalysisTools, as is the case for the Egamma tools
if 'TrigEgammaAnalysisTools' == tool.getDlls():
mon_tools.append(tool.getName())
# return the list of monitoring tools
print "mon_tools =",mon_tools
return mon_tools
def __init__(self,name = 'TileVolumeBuilder'):
from TrkDetDescrSvc.TrkDetDescrJobProperties import TrkDetFlags
# import the ToolSvc if necessary
from AthenaCommon.AppMgr import ToolSvc
if 'ToolSvc' not in dir():
ToolSvc = ToolSvc()
# The volume helper for the Tile
from TrkDetDescrTools.TrkDetDescrToolsConf import Trk__TrackingVolumeHelper
TileTrackingVolumeHelper = Trk__TrackingVolumeHelper(name='TrackingVolumeHelper')
ToolSvc += TileTrackingVolumeHelper
Tile__TileVolumeBuilder.__init__(self,name,
UseCaloSurfBuilder = TrkDetFlags.TileUseCaloSurfBuilder(),
TrackingVolumeHelper = TileTrackingVolumeHelper,
BarrelEnvelopeCover = TrkDetFlags.TileBarrelEnvelopeCover(),
OutputLevel = TrkDetFlags.TileBuildingOutputLevel(),
MagneticFieldMode = TrkDetFlags.MagneticFieldMode())
DQTDataFlowMon = DQTDataFlowMonTool(name = 'DQTDataFlowMon',
histoPathBase = '/GLOBAL/DQTDataFlow',
releaseString = releaseString)
#ToolSvc += DQTDataFlowMon #bugfix ATR-20161
ManagedAthenaGlobalMon.AthenaMonTools += [ DQTDataFlowMon ]
#-- set up output histogram file ------------------------------------------------------------------------------
log.info('HLTFlags %s', HLTMonFlags)
from GaudiSvc.GaudiSvcConf import THistSvc
svcMgr += THistSvc()
svcMgr.THistSvc.Output += ["GLOBAL DATAFILE='" + DQMonFlags.histogramFile() + "' OPT='RECREATE'"]
include( "TrigHLTMonitoring/HLTMonitoring_topOptions.py" )
if hasattr(runArgs,"useDB"):
if runArgs.useDB:
pass
elif not runArgs.useDB:
log.info("Update tools to use xAODConfigTool")
for tool in ToolSvc.getAllChildren():
tool_prop = tool.getDefaultProperties()
for prop,value in tool_prop.iteritems():
if prop == "TrigConfigTool":
log.info("Set xAOD::TrigConfigTool %s",tool.getName())
tool.TrigConfigTool="TrigConf::xAODConfigTool"
if prop == "TrigConfigSvc":
log.info("Set xAOD::TrigConfigSvc %s",tool.getName())
tool.TrigConfigTool="TrigConf::xAODConfigSvc"
def removeFromToolSvc(tool):
"removeFromToolSvc( tool ) --> remove tool from ToolSvc"
from AthenaCommon.AppMgr import ToolSvc
if hasattr(ToolSvc, tool.getName()):
print("Removing tool %s from ToolSvc." % tool.getName())
ToolSvc.remove(tool.getName())
def clearAllAsgSelectors():
from AthenaCommon.AppMgr import ToolSvc
for name in getAsgToolNames():
if hasattr(ToolSvc, name):
print 'removing ', name
ToolSvc.remove(name)
def __init__(self, name='AtlasExtrapolator'):
# get the correct TrackingGeometry setup
from TrkDetDescrSvc.AtlasTrackingGeometrySvc import AtlasTrackingGeometrySvc
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
AtlasTrackingGeometrySvc = svcMgr.AtlasTrackingGeometrySvc
# import the ToolSvc
from AthenaCommon.AppMgr import ToolSvc
if 'ToolSvc' not in dir():
ToolSvc = ToolSvc()
# PROPAGATOR DEFAULTS --------------------------------------------------------------------------------------
self.AtlasPropagators = []
from TrkExRungeKuttaPropagator.TrkExRungeKuttaPropagatorConf import Trk__RungeKuttaPropagator as RkPropagator
AtlasRungeKuttaPropagator = RkPropagator(
name='AtlasRungeKuttaPropagator')
ToolSvc += AtlasRungeKuttaPropagator
self.AtlasPropagators += [AtlasRungeKuttaPropagator]
from TrkExSTEP_Propagator.TrkExSTEP_PropagatorConf import Trk__STEP_Propagator as STEP_Propagator
AtlasSTEP_Propagator = STEP_Propagator(name='AtlasSTEP_Propagator')
ToolSvc += AtlasSTEP_Propagator
self.AtlasPropagators += [AtlasSTEP_Propagator]
# UPDATOR DEFAULTS -----------------------------------------------------------------------------------------
self.AtlasUpdators = []
from TrkExTools.TrkExToolsConf import Trk__MaterialEffectsUpdator as MaterialEffectsUpdator
AtlasMaterialEffectsUpdator = MaterialEffectsUpdator(
name='AtlasMaterialEffectsUpdator')
ToolSvc += AtlasMaterialEffectsUpdator
self.AtlasUpdators += [AtlasMaterialEffectsUpdator]
AtlasMaterialEffectsUpdatorLandau = MaterialEffectsUpdator(
name='AtlasMaterialEffectsUpdatorLandau')
AtlasMaterialEffectsUpdatorLandau.LandauMode = True
ToolSvc += AtlasMaterialEffectsUpdatorLandau
self.AtlasUpdators += [AtlasMaterialEffectsUpdatorLandau]
# the UNIQUE NAVIGATOR ( === UNIQUE GEOMETRY) --------------------------------------------------------------
from TrkExTools.TrkExToolsConf import Trk__Navigator
AtlasNavigator = Trk__Navigator(name='AtlasNavigator')
AtlasNavigator.TrackingGeometrySvc = AtlasTrackingGeometrySvc
ToolSvc += AtlasNavigator
# CONFIGURE PROPAGATORS/UPDATORS ACCORDING TO GEOMETRY SIGNATURE
AtlasSubPropagators = []
AtlasSubUpdators = []
# -------------------- set it depending on the geometry ----------------------------------------------------
# default for Global is (Rk,Mat)
AtlasSubPropagators += [AtlasRungeKuttaPropagator.name()]
AtlasSubUpdators += [AtlasMaterialEffectsUpdator.name()]
# default for ID is (Rk,Mat)
AtlasSubPropagators += [AtlasRungeKuttaPropagator.name()]
AtlasSubUpdators += [AtlasMaterialEffectsUpdator.name()]
# default for BeamPipe is (Rk,Mat)
AtlasSubPropagators += [AtlasRungeKuttaPropagator.name()]
AtlasSubUpdators += [AtlasMaterialEffectsUpdator.name()]
# default for Calo is (STEP,Mat)
AtlasSubPropagators += [AtlasSTEP_Propagator.name()]
AtlasSubUpdators += [AtlasMaterialEffectsUpdator.name()]
# default for MS is (STEP,Mat)
AtlasSubPropagators += [AtlasSTEP_Propagator.name()]
AtlasSubUpdators += [AtlasMaterialEffectsUpdator.name()]
# default for Cavern is (Rk,Mat)
AtlasSubPropagators += [AtlasRungeKuttaPropagator.name()]
AtlasSubUpdators += [AtlasMaterialEffectsUpdator.name()]
# ----------------------------------------------------------------------------------------------------------
# call the base class constructor
Trk__Extrapolator.__init__(self,name,\
Navigator = AtlasNavigator,\
MaterialEffectsUpdators = self.AtlasUpdators,\
Propagators = self.AtlasPropagators,\
SubPropagators = AtlasSubPropagators,\
SubMEUpdators = AtlasSubUpdators,\
DoCaloDynamic = False
)
clist += [y]
else:
print "Removing: ", y, " from CaloCellMaker.CaloCellMakerToolNames"
topSequence.CaloCellMaker.CaloCellMakerToolNames = clist
# Configuring LArBadChanTool
ToolSvc.LArBadChanTool.ReadFromASCII = True
ToolSvc.LArBadChanTool.CoolFolder = ""
ToolSvc.LArBadChanTool.ComplementaryCoolFolder = ""
ToolSvc.LArBadChanTool.CoolMissingFEBsFolder = ""
ToolSvc.LArBadChanTool.WriteEmptyFolders = True
ToolSvc.LArBadChanTool.FCALAfile = "H6BadChannels.txt"
ToolSvc.LArBadChanTool.HECAfile = "H6BadChannels.txt"
ToolSvc.LArBadChanTool.EMECAfile = "H6BadChannels.txt"
# and removing TileBadChanTool
ToolSvc.remove("TileBadChanTool/TileBadChanTool")
if doBeamQuality and doSim:
from TBRec.TBRecConf import TBBeamQualityMC
TBBeamQualityClus = TBBeamQualityMC("TBBeamQualityClus")
TBBeamQualityClus.ReadFileforXcryo = False
TBBeamQualityClus.CheckTrackParams = False
TBBeamQualityClus.CheckPrimaryTrack = False
TBBeamQualityClus.CheckVetoScint = False
TBBeamQualityClus.CheckClusters = True
TBBeamQualityClus.CheckTrackReco = False
# from AthenaCommon.AppMgr import athMasterSeq
topSequence += TBBeamQualityClus
if doMakeEMTopoCluster:
include("CaloRec/EMTopoCluster_jobOptions.py")
def __init__(self,name = 'Extrapolation', nameprefix = 'Atlas', ToolOutputLevel = None, TrackingGeometrySvc = None):
# get the correct TrackingGeometry setup
if not TrackingGeometrySvc :
from TrkDetDescrSvc.AtlasTrackingGeometrySvc import AtlasTrackingGeometrySvc
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
AtlasTrackingGeometrySvc = svcMgr.AtlasTrackingGeometrySvc
else :
AtlasTrackingGeometrySvc = TrackingGeometrySvc
# import the ToolSvc
from AthenaCommon.AppMgr import ToolSvc
if 'ToolSvc' not in dir() :
ToolSvc = ToolSvc()
# load the RungeKutta Propagator
from TrkExRungeKuttaPropagator.TrkExRungeKuttaPropagatorConf import Trk__RungeKuttaPropagator
RungeKuttaPropagator = Trk__RungeKuttaPropagator(name = nameprefix+'RungeKuttaPropagator')
if ToolOutputLevel :
RungeKuttaPropagator.OutputLevel = ToolOutputLevel
ToolSvc += RungeKuttaPropagator
# from the Propagator create a Propagation engine to handle path length
from TrkExEngine.TrkExEngineConf import Trk__PropagationEngine
StaticPropagator = Trk__PropagationEngine(name = nameprefix+'StaticPropagation')
# give the tools it needs
StaticPropagator.Propagator = RungeKuttaPropagator
# configure output formatting
StaticPropagator.OutputPrefix = '[SP] - '
StaticPropagator.OutputPostfix = ' - '
if ToolOutputLevel :
StaticPropagator.OutputLevel = ToolOutputLevel
# add to tool service
ToolSvc += StaticPropagator
# load the material effects engine
from TrkExEngine.TrkExEngineConf import Trk__MaterialEffectsEngine
MaterialEffectsEngine = Trk__MaterialEffectsEngine(name = nameprefix+'MaterialEffects')
# configure output formatting
MaterialEffectsEngine.OutputPrefix = '[ME] - '
MaterialEffectsEngine.OutputPostfix = ' - '
#MaterialEffectsEngine.EnergyLossCorrection = False
if ToolOutputLevel :
MaterialEffectsEngine.OutputLevel = ToolOutputLevel
# add to tool service
ToolSvc += MaterialEffectsEngine
# load the static navigation engine
from TrkExEngine.TrkExEngineConf import Trk__StaticNavigationEngine
StaticNavigator = Trk__StaticNavigationEngine(name = nameprefix+'StaticNavigation')
# give the tools it needs
StaticNavigator.PropagationEngine = StaticPropagator
StaticNavigator.MaterialEffectsEngine = MaterialEffectsEngine
# Geometry name
StaticNavigator.TrackingGeometry = AtlasTrackingGeometrySvc.TrackingGeometryName
# configure output formatting
StaticNavigator.OutputPrefix = '[SN] - '
StaticNavigator.OutputPostfix = ' - '
if ToolOutputLevel :
StaticNavigator.OutputLevel = ToolOutputLevel
# add to tool service
ToolSvc += StaticNavigator
# load the Static ExtrapolationEngine
from TrkExEngine.TrkExEngineConf import Trk__StaticEngine
StaticExtrapolator = Trk__StaticEngine(name = nameprefix+'StaticExtrapolation')
# give the tools it needs
StaticExtrapolator.PropagationEngine = StaticPropagator
StaticExtrapolator.MaterialEffectsEngine = MaterialEffectsEngine
StaticExtrapolator.NavigationEngine = StaticNavigator
# configure output formatting
StaticExtrapolator.OutputPrefix = '[SE] - '
StaticExtrapolator.OutputPostfix = ' - '
if ToolOutputLevel :
StaticExtrapolator.OutputLevel = ToolOutputLevel
# add to tool service
ToolSvc += StaticExtrapolator
# call the base class constructor
ExEngine.__init__(self, name=nameprefix+'Extrapolation',\
ExtrapolationEngines = [ StaticExtrapolator ], \
PropagationEngine = StaticPropagator, \
NavigationEngine = StaticNavigator, \
TrackingGeometrySvc = AtlasTrackingGeometrySvc, \
OutputPrefix = '[ME] - ', \
OutputPostfix = ' - ')
# set the output level
if ToolOutputLevel :
self.OutputLevel = ToolOutputLevel
