diff --git a/InnerDetector/InDetExample/InDetRecExample/python/InDetRecExampleConfig.py b/InnerDetector/InDetExample/InDetRecExample/python/InDetRecExampleConfig.py
index ab66c503ddebaf7b2c88adbf19dc3e8f23f39e7b..5ec47e436e5153d16d6aa085a267e43ced00a79a 100644
--- a/InnerDetector/InDetExample/InDetRecExample/python/InDetRecExampleConfig.py
+++ b/InnerDetector/InDetExample/InDetRecExample/python/InDetRecExampleConfig.py
@@ -1,9 +1,11 @@
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
from AthenaCommon import CfgMgr,CfgGetter
+import AthenaCommon.SystemOfUnits as Units
+from InDetRecExample.TrackingCommon import setDefaults
def setTool(prop,tool_name,kwargs) :
- if tool_name == None :
+ if tool_name is None :
kwargs.setdefault(prop, tool_name )
return
@@ -101,24 +103,49 @@ def InDetKOL(name='InDetKOL',**kwargs) :
def InDetMeasRecalibST(name='InDetMeasRecalibST',**kwargs) :
from TrkKalmanFitter.TrkKalmanFitterConf import Trk__MeasRecalibSteeringTool
- from AthenaCommon.AppMgr import ToolSvc
- kwargs.setdefault('BroadPixelClusterOnTrackTool',ToolSvc.InDetBroadPixelClusterOnTrackTool)
- kwargs.setdefault('BroadSCT_ClusterOnTrackTool', ToolSvc.InDetBroadSCT_ClusterOnTrackTool)
- kwargs.setdefault('CommonRotCreator', ToolSvc.InDetRefitRotCreator)
+
+ split_cluster_map_extension = kwargs.pop('SplitClusterMapExtension','')
+
+ from InDetRecExample import TrackingCommon as TrackingCommon
+ if 'BroadPixelClusterOnTrackTool' not in kwargs :
+ kwargs = setDefaults(kwargs,
+ BroadPixelClusterOnTrackTool = TrackingCommon.getInDetBroadPixelClusterOnTrackTool(nameSuffix = split_cluster_map_extension,
+ SplitClusterMapExtension = split_cluster_map_extension))
+ if 'BroadSCT_ClusterOnTrackTool' not in kwargs :
+ kwargs = setDefaults(kwargs,
+ BroadSCT_ClusterOnTrackTool = TrackingCommon.getInDetBroadSCT_ClusterOnTrackTool())
+
+ if 'CommonRotCreator' not in kwargs :
+ kwargs=setDefaults(kwargs,
+ CommonRotCreator = TrackingCommon.getInDetRefitRotCreator(
+ SplitClusterMapExtension = split_cluster_map_extension))
+
return Trk__MeasRecalibSteeringTool(name,**kwargs)
def InDetKalmanTrackFitterBase(name='InDetKalmanTrackFitterBase',**kwargs) :
from TrkKalmanFitter.TrkKalmanFitterConf import Trk__KalmanFitter
from AthenaCommon.AppMgr import ToolSvc
+ split_cluster_map_extension = kwargs.get('SplitClusterMapExtension','')
+
kwargs.setdefault('ExtrapolatorHandle', ToolSvc.InDetExtrapolator)
- kwargs.setdefault('RIO_OnTrackCreatorHandle', ToolSvc.InDetRefitRotCreator)
+ if 'RIO_OnTrackCreatorHandle' not in kwargs :
+ from InDetRecExample import TrackingCommon as TrackingCommon
+ kwargs=setDefaults(kwargs,
+ RIO_OnTrackCreatorHandle = TrackingCommon.getInDetRefitRotCreator(
+ SplitClusterMapExtension = split_cluster_map_extension))
+
kwargs.setdefault('MeasurementUpdatorHandle', ToolSvc.InDetUpdator)
setTool('KalmanSmootherHandle', 'InDetBKS', kwargs )
setTool('KalmanOutlierLogicHandle', 'InDetKOL',kwargs )
kwargs.setdefault('DynamicNoiseAdjustorHandle', None)
kwargs.setdefault('BrempointAnalyserHandle', None)
kwargs.setdefault('AlignableSurfaceProviderHandle',None)
- setTool('RecalibratorHandle', 'InDetMeasRecalibST', kwargs )
+ if len(split_cluster_map_extension)>0 :
+ if 'RecalibratorHandle' not in kwargs :
+ the_tool_name = 'InDetMeasRecalibST'
+ kwargs.setdefault('RecalibratorHandle', CfgGetter.getPublicToolClone(the_tool_name+split_cluster_map_extension,the_tool_name, SplitClusterMapExtension = split_cluster_map_extension) )
+ else :
+ setTool('RecalibratorHandle', 'InDetMeasRecalibST', kwargs )
# setTool('InternalDAFHandle','KalmanInternalDAF',kwargs )
# from InDetRecExample.InDetJobProperties import InDetFlags
# kwargs.setdefault('DoDNAForElectronsOnly', True if InDetFlags.doBremRecovery() and InDetFlags.trackFitterType() is 'KalmanFitter' else False)
@@ -154,6 +181,235 @@ def ReferenceKalmanFitter(name='ReferenceKalmanFitter',**kwargs) :
def KalmanDNAFitter(name='KalmanDNAFitter',**kwargs) :
setTool('ForwardKalmanFitterHandle','InDetFKF', kwargs )
setTool('DynamicNoiseAdjustorHandle', 'InDetDNAdjustor',kwargs )
- setTool('BrempointAnalyserHandle', 'InDetDNASeparator', kwargs)
+ setTool('BrempointAnalyserHandle', 'InDetDNASeparator', kwargs )
setTool('InternalDAFHandle','KalmanInternalDAF',kwargs )
return InDetKalmanTrackFitterBase(name,**kwargs)
+
+def DistributedKalmanFilter(name="DistributedKalmanFilter", **kwargs) :
+ split_cluster_map_extension = kwargs.pop('SplitClusterMapExtension','')
+
+ from AthenaCommon.AppMgr import ToolSvc
+ from InDetRecExample.TrackingCommon import setDefaults
+ if 'ExtrapolatorTool' not in kwargs :
+ kwargs = setDefaults(kwargs, ExtrapolatorTool = ToolSvc.InDetExtrapolator)
+
+ from InDetRecExample import TrackingCommon as TrackingCommon
+ if 'ROTcreator' not in kwargs :
+ kwargs=setDefaults(kwargs,
+ ROTcreator = TrackingCommon.getInDetRotCreator(
+ nameSuffix = split_cluster_map_extension,
+ SplitClusterMapExtension = split_cluster_map_extension))
+
+ # @TODO set sortingReferencePoint = ???
+ from TrkDistributedKalmanFilter.TrkDistributedKalmanFilterConf import Trk__DistributedKalmanFilter
+ return Trk__DistributedKalmanFilter(name = name, **kwargs)
+
+
+def InDetGlobalChi2FitterBase(name='GlobalChi2FitterBase', **kwargs) :
+ from TrkDetDescrSvc.AtlasTrackingGeometrySvc import AtlasTrackingGeometrySvc
+ from InDetRecExample.TrackingCommon import setDefaults
+ from AthenaCommon.AppMgr import ToolSvc
+ from InDetRecExample.InDetJobProperties import InDetFlags
+ import InDetRecExample.TrackingCommon as TrackingCommon
+
+ kwargs=setDefaults(kwargs,
+ ExtrapolationTool = ToolSvc.InDetExtrapolator,
+ NavigatorTool = ToolSvc.InDetNavigator,
+ PropagatorTool = ToolSvc.InDetPropagator,
+ MultipleScatteringTool = ToolSvc.InDetMultipleScatteringUpdator,
+ MeasurementUpdateTool = ToolSvc.InDetUpdator,
+ TrackingGeometrySvc = AtlasTrackingGeometrySvc,
+ MaterialUpdateTool = ToolSvc.InDetMaterialEffectsUpdator,
+ StraightLine = not InDetFlags.solenoidOn(),
+ OutlierCut = 4,
+ SignedDriftRadius = True,
+ ReintegrateOutliers = True,
+ RecalibrateSilicon = True,
+ RecalibrateTRT = True,
+ TRTTubeHitCut = TrackingCommon.default_ScaleHitUncertainty,
+ MaxIterations = 40,
+ Acceleration = True,
+ RecalculateDerivatives = InDetFlags.doMinBias() or InDetFlags.doCosmics() or InDetFlags.doBeamHalo(),
+ TRTExtensionCuts = True,
+ TrackChi2PerNDFCut = 7)
+ from TrkGlobalChi2Fitter.TrkGlobalChi2FitterConf import Trk__GlobalChi2Fitter
+ return Trk__GlobalChi2Fitter(name, **kwargs)
+
+def InDetGlobalChi2Fitter(name='InDetGlobalChi2Fitter', **kwargs) :
+ split_cluster_map_extension = kwargs.pop('SplitClusterMapExtension','')
+
+ from InDetRecExample import TrackingCommon as TrackingCommon
+ if 'RotCreatorTool' not in kwargs :
+ kwargs=setDefaults(kwargs,
+ RotCreatorTool = TrackingCommon.getInDetRotCreator(
+ nameSuffix = split_cluster_map_extension,
+ SplitClusterMapExtension = split_cluster_map_extension))
+
+ from InDetRecExample.InDetJobProperties import InDetFlags
+ use_broad_cluster_any = InDetFlags.useBroadClusterErrors() and (not InDetFlags.doDBMstandalone())
+ if 'BroadRotCreatorTool' not in kwargs and not InDetFlags.doRefit():
+ kwargs=setDefaults(kwargs,
+ BroadRotCreatorTool = TrackingCommon.getInDetBroadRotCreator(
+ nameSuffix = split_cluster_map_extension,
+ SplitClusterMapExtension = split_cluster_map_extension))
+
+ if InDetFlags.doDBMstandalone():
+ kwargs=setDefaults(kwargs,
+ StraightLine = True,
+ OutlierCut = 5,
+ RecalibrateTRT = False,
+ TRTExtensionCuts = False,
+ TrackChi2PerNDFCut = 20)
+
+ if InDetFlags.doRefit() or use_broad_cluster_any is True:
+ kwargs=setDefaults(kwargs,
+ RecalibrateSilicon = False)
+ if InDetFlags.doRefit():
+ kwargs=setDefaults(kwargs,
+ BroadRotCreatorTool = None,
+ ReintegrateOutliers = False,
+ RecalibrateTRT = False)
+ if InDetFlags.doRobustReco():
+ kwargs=setDefaults(kwargs,
+ # BroadRotCreatorTool = None
+ OutlierCut = 10.0,
+ TrackChi2PerNDFCut = 20)
+
+ if InDetFlags.doRobustReco() or InDetFlags.doCosmics():
+ kwargs=setDefaults(kwargs,
+ MaxOutliers = 99)
+ if InDetFlags.doCosmics() or InDetFlags.doBeamHalo():
+ kwargs=setDefaults(kwargs,
+ Acceleration = False)
+
+ if InDetFlags.materialInteractions() and not InDetFlags.solenoidOn():
+ kwargs=setDefaults(kwargs,
+ Momentum = 1000.*Units.MeV)
+ return InDetGlobalChi2FitterBase(name, **kwargs)
+
+def InDetGlobalChi2FitterLowPt(name='InDetGlobalChi2FitterLowPt', **kwargs) :
+ # @TODO TrackingGeometrySvc was not set but is set now
+ # RotCreatorTool and BroadRotCreatorTool not set
+ split_cluster_map_extension = kwargs.pop('SplitClusterMapExtension','')
+
+ from InDetRecExample import TrackingCommon as TrackingCommon
+ if 'RotCreatorTool' not in kwargs :
+ kwargs=setDefaults(kwargs,
+ RotCreatorTool = TrackingCommon.getInDetRotCreator(
+ nameSuffix = split_cluster_map_extension,
+ SplitClusterMapExtension = split_cluster_map_extension))
+
+ from InDetRecExample.InDetJobProperties import InDetFlags
+ use_broad_cluster_any = InDetFlags.useBroadClusterErrors() and (not InDetFlags.doDBMstandalone())
+ if 'BroadRotCreatorTool' not in kwargs and not InDetFlags.doRefit():
+ kwargs=setDefaults(kwargs,
+ BroadRotCreatorTool = TrackingCommon.getInDetBroadRotCreator(
+ nameSuffix = split_cluster_map_extension,
+ SplitClusterMapExtension = split_cluster_map_extension))
+
+ return InDetGlobalChi2FitterBase(name, **setDefaults(kwargs,
+ OutlierCut = 5.0,
+ Acceleration = False, # default
+ RecalculateDerivatives = True,
+ TrackChi2PerNDFCut = 10))
+
+
+def InDetGlobalChi2FitterTRT(name='InDetGlobalChi2FitterTRT', **kwargs) :
+ '''
+ Global Chi2 Fitter for TRT segments with different settings
+ '''
+ split_cluster_map_extension = kwargs.pop('SplitClusterMapExtension','')
+
+ if 'RotCreatorTool' not in kwargs :
+ from InDetRecExample import TrackingCommon as TrackingCommon
+ kwargs=setDefaults(kwargs,
+ RotCreatorTool = TrackingCommon.getInDetRefitRotCreator(
+ nameSuffix = split_cluster_map_extension,
+ SplitClusterMapExtension = split_cluster_map_extension))
+
+ from InDetRecExample.InDetJobProperties import InDetFlags
+ return InDetGlobalChi2FitterBase(name, **setDefaults(
+ kwargs,
+ MaterialUpdateTool = '', # default
+ TrackingGeometrySvc = '', # default
+ SignedDriftRadius = True, # default,
+ RecalibrateSilicon = False, # default,
+ RecalibrateTRT = False, # default,
+ TRTTubeHitCut = 2.5, # default,
+ MaxIterations = 10,
+ Acceleration = False, # default,
+ RecalculateDerivatives = False,
+ TRTExtensionCuts = True, # default,
+ TrackChi2PerNDFCut = 999999,
+ Momentum = 1000.*Units.MeV if InDetFlags.materialInteractions() and not InDetFlags.solenoidOn() else 0, # default,
+ OutlierCut = 5, # default
+ MaxOutliers = 99 if InDetFlags.doRobustReco() or InDetFlags.doCosmics() else 10, # default,
+ ReintegrateOutliers = False if InDetFlags.doRefit() else False # default
+ ))
+
+def InDetGlobalChi2FitterDBM(name='InDetGlobalChi2FitterDBM', **kwargs) :
+ split_cluster_map_extension = kwargs.pop('SplitClusterMapExtension','')
+ if 'RotCreatorTool' not in kwargs :
+ from InDetRecExample import TrackingCommon as TrackingCommon
+ kwargs=setDefaults(kwargs, RotCreatorTool = TrackingCommon.getInDetRotCreatorDBM(SplitClusterMapExtension = split_cluster_map_extension))
+
+ return InDetGlobalChi2FitterBase(name, **setDefaults(kwargs,
+ BroadRotCreatorTool = None,
+ StraightLine = True,
+ OutlierCut = 5,
+ RecalibrateTRT = False,
+ RecalculateDerivatives= False,
+ TRTExtensionCuts = False,
+ TrackChi2PerNDFCut = 20,
+ Momentum = 1000.*Units.MeV))
+
+def GaussianSumFitter(name='GaussianSumFitter', **kwargs) :
+ split_cluster_map_extension = kwargs.pop('SplitClusterMapExtension','')
+
+ from InDetRecExample import TrackingCommon as TrackingCommon
+ if 'ToolForROTCreation' not in kwargs :
+ kwargs=setDefaults(kwargs,
+ ToolForROTCreation = TrackingCommon.getInDetRotCreator(
+ nameSuffix = split_cluster_map_extension,
+ SplitClusterMapExtension = split_cluster_map_extension))
+
+ if 'ToolForExtrapolation' not in kwargs :
+ kwargs=setDefaults(kwargs, ToolForExtrapolation = TrackingCommon.getInDetGsfExtrapolator())
+
+ if 'MeasurementUpdatorType' not in kwargs :
+ kwargs=setDefaults(kwargs, MeasurementUpdatorType = TrackingCommon.getInDetGsfMeasurementUpdator())
+
+ from TrkGaussianSumFilter.TrkGaussianSumFilterConf import Trk__GaussianSumFitter
+ return Trk__GaussianSumFitter(name = the_name, **setDefaults(kwargs,
+ ReintegrateOutliers = False,
+ MakePerigee = True,
+ RefitOnMeasurementBase = True,
+ DoHitSorting = True))
+
+def InDetTrackFitter(name='InDetTrackFitter', **kwargs) :
+ from InDetRecExample.InDetJobProperties import InDetFlags
+ return {
+ 'KalmanFitter' : KalmanFitter,
+ 'KalmanDNAFitter' : KalmanDNAFitter,
+ 'ReferenceKalmanFitter' : ReferenceKalmanFitter,
+ 'DistributedKalmanFilter' : DistributedKalmanFilter,
+ 'GlobalChi2Fitter' : InDetGlobalChi2Fitter,
+ 'GaussianSumFilter' : GaussianSumFitter
+ }[InDetFlags.trackFitterType()](name,**kwargs)
+
+def InDetTrackFitterLowPt(name='InDetTrackFitter', **kwargs) :
+ from InDetRecExample.InDetJobProperties import InDetFlags
+ if InDetFlags.trackFitterType() != 'GlobalChi2Fitter' :
+ return InDetTrackFitter(name,**kwargs)
+ else :
+ return InDetGlobalChi2FitterLowPt(name,**kwargs)
+
+def InDetTrackFitterTRT(name='InDetTrackFitterTRT', **kwargs) :
+ from InDetRecExample.InDetJobProperties import InDetFlags
+ if InDetFlags.trackFitterType() != 'GlobalChi2Fitter' :
+ return InDetTrackFitter(name,**kwargs)
+ else :
+ return InDetGlobalChi2FitterTRT(name,**kwargs)
+
+def InDetTrackFitterDBM(name='InDetTrackFitterDBM', **kwargs) :
+ return InDetGlobalChi2FitterDBM(name,**kwargs)
diff --git a/InnerDetector/InDetExample/InDetRecExample/python/InDetRecExampleConfigDb.py b/InnerDetector/InDetExample/InDetRecExample/python/InDetRecExampleConfigDb.py
index 2c876b7019219e97b660609ae6910604bc8d226e..c636839641bc3ce29b62098a1dac485d73101e53 100644
--- a/InnerDetector/InDetExample/InDetRecExample/python/InDetRecExampleConfigDb.py
+++ b/InnerDetector/InDetExample/InDetRecExample/python/InDetRecExampleConfigDb.py
@@ -25,3 +25,7 @@ addTool('InDetRecExample.InDetRecExampleConfig.InDetMeasRecalibST','InDetMeasRec
addTool('InDetRecExample.InDetRecExampleConfig.KalmanFitter','KalmanFitter')
addTool('InDetRecExample.InDetRecExampleConfig.ReferenceKalmanFitter','ReferenceKalmanFitter')
addTool('InDetRecExample.InDetRecExampleConfig.KalmanDNAFitter','KalmanDNAFitter')
+addTool('InDetRecExample.InDetRecExampleConfig.InDetTrackFitter','InDetTrackFitter')
+addTool('InDetRecExample.InDetRecExampleConfig.InDetTrackFitterLowPt','InDetTrackFitterLowPt')
+addTool('InDetRecExample.InDetRecExampleConfig.InDetTrackFitterTRT','InDetTrackFitterTRT')
+addTool('InDetRecExample.InDetRecExampleConfig.InDetTrackFitterDBM','InDetTrackFitterDBM')
diff --git a/InnerDetector/InDetExample/InDetRecExample/python/TrackingCommon.py b/InnerDetector/InDetExample/InDetRecExample/python/TrackingCommon.py
index 7c21b63a59cb93bf0317a7135541171dd33a055f..028c288866b33d08193186841364a83f5396cb91 100644
--- a/InnerDetector/InDetExample/InDetRecExample/python/TrackingCommon.py
+++ b/InnerDetector/InDetExample/InDetRecExample/python/TrackingCommon.py
@@ -19,12 +19,55 @@ def setDefaults(kwargs, **def_kwargs) :
def_kwargs.update(kwargs)
return def_kwargs
+def makeName( name, kwargs) :
+ namePrefix=kwargs.pop('namePrefix','')
+ nameSuffix=kwargs.pop('nameSuffix','')
+ return namePrefix + name + nameSuffix
+
+def getDefaultName(func) :
+ # @TODO only works for python 2
+ import inspect
+ defaults=inspect.getargspec(func).defaults
+ if len(defaults)==0 :
+ raise Exception("Missing default name for %s" % func.__name__)
+ return defaults[0]
+
+def makePublicTool(tool_creator) :
+ '''
+ If the decorated method gets called the created tool will be added to ToolSvc
+ '''
+ def createPublicTool(*args,**kwargs):
+ from AthenaCommon.AppMgr import ToolSvc
+ name=kwargs.pop('name',None)
+ if len(args) == 1 :
+ if name != None :
+ raise Exception('Name given as positional and keyword argument')
+ name=args[0]
+ if name is None :
+ name=getDefaultName(tool_creator)
+
+ the_name = kwargs.get('namePrefix','') + name + kwargs.get('nameSuffix','')
+ if the_name not in ToolSvc :
+ if len(args) > 1 :
+ raise Exception('Too many positional arguments')
+ tool = tool_creator(name, **kwargs)
+ if the_name != tool.name() :
+ raise Exception('Tool has not the exepected name %s but %s' % (the_name, tool.the_name()))
+ ToolSvc += tool
+ return tool
+ else :
+ return getattr(ToolSvc, the_name)
+
+ createPublicTool.__name__ = tool_creator.__name__
+ createPublicTool.__module__ = tool_creator.__module__
+ return createPublicTool
+
def getPixelRIO_OnTrackErrorScalingDbOverrideCondAlg( **kwargs) :
'''
usage:
createAndAddCondAlg( getPixelRIO_OnTrackErrorScalingDbOverrideCondAlg, 'PixelRIO_OnTrackErrorScalingDbOverrideCondAlg' )
'''
- the_name=kwargs.pop("name",None)
+ the_name=kwargs.pop("name",'PixelRIO_OnTrackErrorScalingDbOverrideCondAlg')
from AtlasGeoModel.InDetGMJobProperties import InDetGeometryFlags as geoFlags
# kPixBarrelPhi
params = [ 10. , 0.0044]
@@ -45,12 +88,12 @@ def getPixelRIO_OnTrackErrorScalingDbOverrideCondAlg( **kwargs) :
from TrkRIO_OnTrackCreator.TrkRIO_OnTrackCreatorConf import RIO_OnTrackErrorScalingDbOverrideCondAlg
- return RIO_OnTrackErrorScalingDbOverrideCondAlg( 'PixelRIO_OnTrackErrorScalingDbOverrideCondAlg',
+ return RIO_OnTrackErrorScalingDbOverrideCondAlg( name = the_name,
**setDefaults( kwargs,
ErrorScalingTypeName = error_scaling_type,
WriteKey = "/Indet/TrkErrorScalingPixel",
ErorScalingParameters = params,
- OutputLevel = 1) ) # VERBOSE
+ OutputLevel = 1) ) # VERBOSE
def getRIO_OnTrackErrorScalingCondAlg( **kwargs) :
the_name=kwargs.pop("name",None)
@@ -92,10 +135,9 @@ def getRIO_OnTrackErrorScalingCondAlg( **kwargs) :
OutKeys = error_scaling_outkey) )
-
def getEventInfoKey() :
- from AthenaCommon.GlobalFlags import globalflags
- from AthenaCommon.DetFlags import DetFlags
+ from AthenaCommon.GlobalFlags import globalflags
+ from AthenaCommon.DetFlags import DetFlags
isData = (globalflags.DataSource == 'data')
@@ -111,19 +153,6 @@ def getEventInfoKey() :
return eventInfoKey
-def getTRT_DriftCircleOnTrackTool() :
- from AthenaCommon.AppMgr import ToolSvc
- if not hasattr(ToolSvc,'TRT_DriftCircleOnTrackTool') :
- createAndAddCondAlg(getRIO_OnTrackErrorScalingCondAlg,'RIO_OnTrackErrorScalingCondAlg')
- from TRT_DriftCircleOnTrackTool.TRT_DriftCircleOnTrackToolConf import InDet__TRT_DriftCircleOnTrackTool
- tool = InDet__TRT_DriftCircleOnTrackTool( EventInfoKey = getEventInfoKey(),
- TRTErrorScalingKey = '/Indet/TrkErrorScalingTRT')
- log.debug('default name = %s', tool.getName())
- ToolSvc += tool
- return tool
- else :
- return ToolSvc.TRT_DriftCircleOnTrackTool
-
def getNeuralNetworkToHistoTool(**kwargs) :
from TrkNeuralNetworkUtils.TrkNeuralNetworkUtilsConf import Trk__NeuralNetworkToHistoTool
name = kwargs.pop('name',"NeuralNetworkToHistoTool")
@@ -176,3 +205,292 @@ def getPixelClusterNnWithTrackCondAlg(**kwargs) :
TrackNetwork = True,
name ='PixelClusterNnWithTrackCondAlg')
return getPixelClusterNnCondAlg( **kwargs )
+
+def getPixelLorentzAngleTool(name='PixelLorentzAngleTool', **kwargs) :
+ the_name = makeName( name, kwargs)
+ if the_name != "PixelLorentzAngleTool" :
+ raise Exception('There should be only one Pixel Lorentz angle tool configuration named "PixelLorentzAngleTool"')
+ from AthenaCommon.AppMgr import ToolSvc
+ if not hasattr(ToolSvc, the_name ):
+ from SiLorentzAngleTool.PixelLorentzAngleToolSetup import PixelLorentzAngleToolSetup
+ PixelLorentzAngleToolSetup()
+ return getattr(ToolSvc,the_name)
+
+def getSCTLorentzAngleTool(name='SCTLorentzAngleTool', **kwargs) :
+ the_name = makeName( name, kwargs)
+ if the_name != "SCTLorentzAngleTool" :
+ raise Exception('There should be only one SCT Lorentz angle tool configuration named "SCTLorentzAngleTool"')
+ from SiLorentzAngleTool.SCTLorentzAngleToolSetup import SCTLorentzAngleToolSetup
+ return SCTLorentzAngleToolSetup().SCTLorentzAngleTool
+
+@makePublicTool
+def getNnClusterizationFactory(name='NnClusterizationFactory', **kwargs) :
+ the_name = makeName( name, kwargs)
+ from SiClusterizationTool.SiClusterizationToolConf import InDet__NnClusterizationFactory
+
+ if 'PixelLorentzAngleTool' not in kwargs :
+ kwargs = setDefaults( kwargs, PixelLorentzAngleTool = getPixelLorentzAngleTool())
+
+ from AtlasGeoModel.CommonGMJobProperties import CommonGeometryFlags as geoFlags
+ do_runI = geoFlags.Run() not in ["RUN2", "RUN3"]
+ createAndAddCondAlg( getPixelClusterNnCondAlg, 'PixelClusterNnCondAlg', GetInputsInfo = do_runI)
+ createAndAddCondAlg( getPixelClusterNnWithTrackCondAlg,'PixelClusterNnWithTrackCondAlg', GetInputsInfo = do_runI)
+
+ from InDetRecExample.InDetJobProperties import InDetFlags
+ kwargs = setDefaults( kwargs,
+ doRunI = do_runI,
+ useToT = False if do_runI else InDetFlags.doNNToTCalibration(),
+ useRecenteringNNWithoutTracks = True if do_runI else False, # default,
+ useRecenteringNNWithTracks = False if do_runI else False, # default,
+ correctLorShiftBarrelWithoutTracks = 0,
+ correctLorShiftBarrelWithTracks = 0.030 if do_runI else 0.000, # default,
+ NnCollectionReadKey = 'PixelClusterNN',
+ NnCollectionWithTrackReadKey = 'PixelClusterNNWithTrack')
+ return InDet__NnClusterizationFactory(name=the_name, **kwargs)
+
+@makePublicTool
+def getInDetPixelClusterOnTrackToolBase(name, **kwargs) :
+ the_name = makeName( name, kwargs)
+ split_cluster_map_extension = kwargs.pop('SplitClusterMapExtension','')
+ from InDetRecExample.InDetJobProperties import InDetFlags
+ from SiClusterOnTrackTool.SiClusterOnTrackToolConf import InDet__PixelClusterOnTrackTool
+
+ if InDetFlags.doCosmics() or InDetFlags.doDBMstandalone():
+ kwargs = setDefaults(kwargs,
+ ErrorStrategy = 0,
+ PositionStrategy = 0)
+
+ from InDetRecExample.InDetKeys import InDetKeys
+ kwargs = setDefaults(kwargs,
+ DisableDistortions = (InDetFlags.doFatras() or InDetFlags.doDBMstandalone()),
+ applyNNcorrection = ( InDetFlags.doPixelClusterSplitting() and
+ InDetFlags.pixelClusterSplittingType() == 'NeuralNet' and not InDetFlags.doSLHC()),
+ NNIBLcorrection = ( InDetFlags.doPixelClusterSplitting() and
+ InDetFlags.pixelClusterSplittingType() == 'NeuralNet' and not InDetFlags.doSLHC()),
+ SplitClusterAmbiguityMap = InDetKeys.SplitClusterAmbiguityMap() + split_cluster_map_extension,
+ RunningTIDE_Ambi = InDetFlags.doTIDE_Ambi())
+
+ return InDet__PixelClusterOnTrackTool(the_name , **kwargs)
+
+def getInDetPixelClusterOnTrackToolNNSplitting(name='InDetPixelClusterOnTrackToolNNSplitting', **kwargs) :
+ from InDetRecExample.InDetJobProperties import InDetFlags
+ if InDetFlags.doPixelClusterSplitting() and InDetFlags.pixelClusterSplittingType() == 'NeuralNet':
+ if 'NnClusterizationFactory' not in kwargs :
+ kwargs = setDefaults(kwargs, NnClusterizationFactory = getNnClusterizationFactory())
+
+ if InDetFlags.doTIDE_RescalePixelCovariances() :
+ kwargs = setDefaults(kwargs, applydRcorrection = True)
+ return getInDetPixelClusterOnTrackToolBase(name=name, **kwargs)
+
+def getInDetPixelClusterOnTrackTool(name='InDetPixelClusterOnTrackTool', **kwargs) :
+ if 'LorentzAngleTool' not in kwargs :
+ kwargs = setDefaults(kwargs, LorentzAngleTool = getPixelLorentzAngleTool())
+
+ return getInDetPixelClusterOnTrackToolNNSplitting(name=name, **kwargs)
+
+def getInDetPixelClusterOnTrackToolPattern(name='InDetPixelClusterOnTrackToolPattern', **kwargs) :
+ return getInDetPixelClusterOnTrackToolNNSplitting(name=name, **kwargs)
+
+def getInDetPixelClusterOnTrackToolDigital(name='InDetPixelClusterOnTrackToolDigital', **kwargs) :
+ from InDetRecExample.InDetJobProperties import InDetFlags
+ if 'LorentzAngleTool' not in kwargs :
+ kwargs = setDefaults(kwargs, LorentzAngleTool = getPixelLorentzAngleTool())
+
+ if InDetFlags.doDigitalROTCreation():
+ kwargs = setDefaults(kwargs,
+ applyNNcorrection = False,
+ NNIBLcorrection = False,
+ ErrorStrategy = 2,
+ PositionStrategy = 1)
+ else :
+ kwargs = setDefaults(kwargs,
+ SplitClusterAmbiguityMap = "")
+
+ return getInDetPixelClusterOnTrackToolBase(name=name, **kwargs)
+
+def getInDetPixelClusterOnTrackToolDBM(name='InDetPixelClusterOnTrackToolDBM', **kwargs) :
+ return getInDetPixelClusterOnTrackToolBase(name=name, **setDefaults(kwargs,
+ DisableDistortions = True,
+ applyNNcorrection = False,
+ NNIBLcorrection = False,
+ RunningTIDE_Ambi = False,
+ ErrorStrategy = 0,
+ PositionStrategy = 0))
+
+def getInDetBroadPixelClusterOnTrackTool(name='InDetBroadPixelClusterOnTrackTool', **kwargs) :
+ return getInDetPixelClusterOnTrackTool(name=name, **setDefaults(kwargs, ErrorStrategy = 0))
+
+@makePublicTool
+def getInDetSCT_ClusterOnTrackTool(name='InDetSCT_ClusterOnTrackTool', **kwargs) :
+ the_name = makeName( name, kwargs)
+ if 'LorentzAngleTool' not in kwargs :
+ kwargs = setDefaults(kwargs, LorentzAngleTool = getSCTLorentzAngleTool())
+
+ kwargs = setDefaults(kwargs,
+ # CorrectionStrategy = -1, # no position correction (test for bug #56477)
+ CorrectionStrategy = 0, # do correct position bias
+ ErrorStrategy = 2 # do use phi dependent errors
+ )
+ from SiClusterOnTrackTool.SiClusterOnTrackToolConf import InDet__SCT_ClusterOnTrackTool
+ return InDet__SCT_ClusterOnTrackTool (the_name, **kwargs)
+
+def getInDetBroadSCT_ClusterOnTrackTool(name='InDetBroadSCT_ClusterOnTrackTool', **kwargs) :
+ return getInDetSCT_ClusterOnTrackTool(name=name, **setDefaults( kwargs, ErrorStrategy = 0) )
+
+
+@makePublicTool
+def getInDetBroadTRT_DriftCircleOnTrackTool(name='InDetBroadTRT_DriftCircleOnTrackTool', **kwargs) :
+ the_name = makeName( name, kwargs)
+ from TRT_DriftCircleOnTrackTool.TRT_DriftCircleOnTrackToolConf import InDet__TRT_DriftCircleOnTrackNoDriftTimeTool
+ return InDet__TRT_DriftCircleOnTrackNoDriftTimeTool(the_name)
+
+# @TODO rename to InDetTRT_DriftCircleOnTrackTool ?
+def getInDetTRT_DriftCircleOnTrackTool(name='TRT_DriftCircleOnTrackTool', **kwargs) :
+ createAndAddCondAlg(getRIO_OnTrackErrorScalingCondAlg,'RIO_OnTrackErrorScalingCondAlg')
+ kwargs = setDefaults(kwargs,
+ EventInfoKey = getEventInfoKey(),
+ TRTErrorScalingKey = '/Indet/TrkErrorScalingTRT')
+ return getInDetBroadTRT_DriftCircleOnTrackTool(name = name, **kwargs)
+
+default_ScaleHitUncertainty = 2.5
+
+@makePublicTool
+def getInDetTRT_DriftCircleOnTrackUniversalTool(name='InDetTRT_RefitRotCreator',**kwargs) :
+ the_name = makeName( name, kwargs)
+ if 'RIOonTrackToolDrift' not in kwargs :
+ kwargs = setDefaults(kwargs, RIOonTrackToolDrift = getInDetTRT_DriftCircleOnTrackTool())
+ if 'RIOonTrackToolTube' not in kwargs :
+ kwargs = setDefaults(kwargs, RIOonTrackToolTube = getInDetBroadTRT_DriftCircleOnTrackTool())
+
+ from TRT_DriftCircleOnTrackTool.TRT_DriftCircleOnTrackToolConf import InDet__TRT_DriftCircleOnTrackUniversalTool
+ return InDet__TRT_DriftCircleOnTrackUniversalTool(name = the_name, **setDefaults(kwargs,
+ ScaleHitUncertainty = default_ScaleHitUncertainty))
+
+@makePublicTool
+def getInDetRotCreator(name='InDetRotCreator', **kwargs) :
+ the_name = makeName( name, kwargs)
+ split_cluster_map_extension = kwargs.pop('SplitClusterMapExtension','')
+ from InDetRecExample.InDetJobProperties import InDetFlags
+ use_broad_cluster_pix = InDetFlags.useBroadPixClusterErrors() and (not InDetFlags.doDBMstandalone())
+ use_broad_cluster_sct = InDetFlags.useBroadSCTClusterErrors() and (not InDetFlags.doDBMstandalone())
+
+ if 'ToolPixelCluster' not in kwargs :
+ if use_broad_cluster_pix :
+ kwargs = setDefaults( kwargs,
+ ToolPixelCluster = getInDetBroadPixelClusterOnTrackTool(nameSuffix = split_cluster_map_extension,
+ SplitClusterMapExtension = split_cluster_map_extension))
+ else :
+ kwargs = setDefaults( kwargs,
+ ToolPixelCluster = getInDetPixelClusterOnTrackTool(nameSuffix = split_cluster_map_extension,
+ SplitClusterMapExtension = split_cluster_map_extension))
+
+ if 'ToolSCT_Cluster' not in kwargs :
+ if use_broad_cluster_sct :
+ kwargs = setDefaults( kwargs, ToolSCT_Cluster = getInDetBroadSCT_ClusterOnTrackTool())
+ else :
+ kwargs = setDefaults( kwargs, ToolSCT_Cluster = getInDetSCT_ClusterOnTrackTool())
+
+ kwargs = setDefaults( kwargs, Mode = 'indet')
+
+ from TrkRIO_OnTrackCreator.TrkRIO_OnTrackCreatorConf import Trk__RIO_OnTrackCreator
+ return Trk__RIO_OnTrackCreator(name=the_name, **kwargs)
+
+def getInDetRotCreatorPattern(name='InDetRotCreatorPattern', **kwargs) :
+ if 'ToolPixelCluster' not in kwargs :
+ split_cluster_map_extension = kwargs.get('SplitClusterMapExtension','')
+ kwargs = setDefaults(kwargs,
+ ToolPixelCluster = getInDetPixelClusterOnTrackToolPattern(nameSuffix = split_cluster_map_extension,
+ SplitClusterMapExtension = split_cluster_map_extension))
+ return getInDetRotCreator(name=name, **kwargs)
+
+
+def getInDetRotCreatorDBM(name='InDetRotCreatorDBM', **kwargs) :
+ split_cluster_map_extension = kwargs.pop('SplitClusterMapExtension','')
+ if 'ToolPixelCluster' not in kwargs :
+ from InDetRecExample.InDetJobProperties import InDetFlags
+ from AthenaCommon.DetFlags import DetFlags
+ if InDetFlags.loadRotCreator() and DetFlags.haveRIO.pixel_on():
+ kwargs = setDefaults(kwargs,
+ ToolPixelCluster = getInDetPixelClusterOnTrackToolDBM(nameSuffix = split_cluster_map_extension,
+ SplitClusterMapExtension = split_cluster_map_extension))
+ else :
+ kwargs = setDefaults(kwargs,
+ ToolPixelCluster = getInDetPixelClusterOnTrackTool(nameSuffix = split_cluster_map_extension,
+ SplitClusterMapExtension = split_cluster_map_extension))
+ return getInDetRotCreator(name=name, **kwargs)
+
+def getInDetRotCreatorDigital(name='InDetRotCreatorDigital', **kwargs) :
+ if 'ToolPixelCluster' not in kwargs :
+ split_cluster_map_extension = kwargs.get('SplitClusterMapExtension','')
+ kwargs = setDefaults(kwargs,
+ ToolPixelCluster = getInDetPixelClusterOnTrackToolDigital(nameSuffix = split_cluster_map_extension,
+ SplitClusterMapExtension = split_cluster_map_extension))
+ return getInDetRotCreator(name=name, **kwargs)
+
+# @TODO rename to InDetBroadRotCreator
+def getInDetBroadRotCreator(name='InDetBroadInDetRotCreator', **kwargs) :
+ if 'ToolPixelCluster' not in kwargs :
+ split_cluster_map_extension = kwargs.get('SplitClusterMapExtension','')
+ kwargs = setDefaults(kwargs,
+ ToolPixelCluster = getInDetBroadPixelClusterOnTrackTool(nameSuffix = split_cluster_map_extension,
+ SplitClusterMapExtension = split_cluster_map_extension))
+ if 'ToolSCT_Cluster' not in kwargs :
+ kwargs = setDefaults(kwargs,
+ ToolSCT_Cluster = getInDetBroadSCT_ClusterOnTrackTool())
+
+ from AthenaCommon.DetFlags import DetFlags
+ if DetFlags.haveRIO.TRT_on():
+ if 'ToolTRT_DriftCircle' not in kwargs :
+ kwargs = setDefaults(kwargs,
+ ToolTRT_DriftCircle = getInDetBroadTRT_DriftCircleOnTrackTool())
+
+ return getInDetRotCreator(name=name, **kwargs)
+
+
+def getInDetRefitRotCreator(name='InDetRefitRotCreator', **kwargs) :
+ ScaleHitUncertainty = kwargs.pop('ScaleHitUncertainty',default_ScaleHitUncertainty)
+ from InDetRecExample.InDetJobProperties import InDetFlags
+ from AthenaCommon.DetFlags import DetFlags
+
+ if InDetFlags.redoTRT_LR():
+ if DetFlags.haveRIO.TRT_on():
+ if 'ToolTRT_DriftCircle' not in kwargs :
+ kwargs = setDefaults(kwargs,
+ ToolTRT_DriftCircle = getInDetTRT_DriftCircleOnTrackUniversalTool(ScaleHitUncertainty = ScaleHitUncertainty))
+
+ return getInDetRotCreator(name = name, **kwargs)
+
+@makePublicTool
+def getInDetGsfMaterialUpdator(name='InDetGsfMaterialUpdator', **kwargs) :
+ the_name = makeName( name, kwargs)
+ from TrkGaussianSumFilter.TrkGaussianSumFilterConf import Trk__GsfMaterialMixtureConvolution
+ return Trk__GsfMaterialMixtureConvolution (name = the_name, **kwargs)
+
+@makePublicTool
+def getInDetGsfComponentReduction(name='InDetGsfComponentReduction', **kwargs) :
+ the_name = makeName( name, kwargs)
+ from TrkGaussianSumFilter.TrkGaussianSumFilterConf import Trk__QuickCloseComponentsMultiStateMerger
+ return Trk__QuickCloseComponentsMultiStateMerger (name = the_name, **setDefaults(kwargs, MaximumNumberOfComponents = 12))
+
+@makePublicTool
+def getInDetGsfExtrapolator(name='InDetGsfExtrapolator', **kwargs) :
+ the_name = makeName(name,kwargs)
+ if 'Propagators' not in kwargs :
+ from AthenaCommon.AppMgr import ToolSvc
+ kwargs=setDefaults(kwargs, Propagators = [ ToolSvc.InDetPropagator ] )
+
+ if 'Navigator' not in kwargs :
+ from AthenaCommon.AppMgr import ToolSvc
+ kwargs=setDefaults(kwargs, Navigator = ToolSvc.InDetNavigator)
+
+ if 'GsfMaterialConvolution' not in kwargs :
+ kwargs=setDefaults(kwargs, GsfMaterialConvolution = getInDetGsfMaterialUpdator())
+
+ if 'ComponentMerger' not in kwargs :
+ kwargs=setDefaults(kwargs, ComponentMerger = getInDetGsfComponentReduction())
+
+ from TrkGaussianSumFilter.TrkGaussianSumFilterConf import Trk__GsfExtrapolator
+ return Trk__GsfExtrapolator(name = the_name, **setDefaults(kwargs,
+ SearchLevelClosestParameters = 10,
+ StickyConfiguration = True,
+ SurfaceBasedMaterialEffects = False ))
diff --git a/InnerDetector/InDetExample/InDetRecExample/share/ConfiguredBackTracking.py b/InnerDetector/InDetExample/InDetRecExample/share/ConfiguredBackTracking.py
index fc0c79a5e1422561f8a22f7cc9bc606802adf7d3..ce6927a04498b673b0e652cfcf0bdb1f792a093a 100755
--- a/InnerDetector/InDetExample/InDetRecExample/share/ConfiguredBackTracking.py
+++ b/InnerDetector/InDetExample/InDetRecExample/share/ConfiguredBackTracking.py
@@ -148,9 +148,10 @@ class ConfiguredBackTracking:
#
# TRT seeded back tracking algorithm
#
+ from AthenaCommon import CfgGetter
from TRT_SeededTrackFinder.TRT_SeededTrackFinderConf import InDet__TRT_SeededTrackFinder
InDetTRT_SeededTrackFinder = InDet__TRT_SeededTrackFinder(name = 'InDetTRT_SeededTrackFinder',
- RefitterTool = InDetTrackFitter,
+ RefitterTool = CfgGetter.getPublicTool('InDetTrackFitter'),
TrackTool = InDetTRT_SeededTrackTool,
TrackExtensionTool = InDetTRTExtensionTool,
MinTRTonSegment = NewTrackingCuts.minSecondaryTRTonTrk(),
@@ -269,7 +270,7 @@ class ConfiguredBackTracking:
#
from TrkAmbiguityProcessor.TrkAmbiguityProcessorConf import Trk__SimpleAmbiguityProcessorTool
InDetTRT_SeededAmbiguityProcessor = Trk__SimpleAmbiguityProcessorTool(name = 'InDetTRT_SeededAmbiguityProcessor',
- Fitter = InDetTrackFitter,
+ Fitter = CfgGetter.getPublicTool('InDetTrackFitter'),
SelectionTool = InDetTRT_SeededAmbiTrackSelectionTool,
RefitPrds = not InDetFlags.refitROT(),
SuppressTrackFit = False,
diff --git a/InnerDetector/InDetExample/InDetRecExample/share/ConfiguredNewTrackingSiPattern.py b/InnerDetector/InDetExample/InDetRecExample/share/ConfiguredNewTrackingSiPattern.py
index 5988b6431ea3b5c6642950eae2c15ba8147f89f2..af98cf6d41dca60773ea316bf0e37ab13928b599 100644
--- a/InnerDetector/InDetExample/InDetRecExample/share/ConfiguredNewTrackingSiPattern.py
+++ b/InnerDetector/InDetExample/InDetRecExample/share/ConfiguredNewTrackingSiPattern.py
@@ -36,7 +36,7 @@ class ConfiguredNewTrackingSiPattern:
from InDetTrackPRD_Association.InDetTrackPRD_AssociationConf import InDet__InDetTrackPRD_Association
InDetPRD_Association = InDet__InDetTrackPRD_Association(name = 'InDetPRD_Association'+NewTrackingCuts.extension(),
AssociationTool = InDetPrdAssociationTool,
- TracksName = list(InputCollections))
+ TracksName = list(InputCollections))
topSequence += InDetPRD_Association
if (InDetFlags.doPrintConfigurables()):
print InDetPRD_Association
@@ -169,6 +169,29 @@ class ConfiguredNewTrackingSiPattern:
#
# --- Local track finding using sdCaloSeededSSSpace point seed
#
+ # @TODO ensure that PRD association map is used if usePrdAssociationTool is set
+ is_dbm = InDetFlags.doDBMstandalone() or NewTrackingCuts.extension()=='DBM'
+ rot_creator_digital = TrackingCommon.getInDetRotCreatorDigital() if not is_dbm else TrackingCommon.getInDetRotCreatorDBM()
+ from SiCombinatorialTrackFinderTool_xk.SiCombinatorialTrackFinderTool_xkConf import InDet__SiCombinatorialTrackFinder_xk
+ track_finder = InDet__SiCombinatorialTrackFinder_xk(name = 'InDetSiComTrackFinder'+NewTrackingCuts.extension(),
+ PropagatorTool = InDetPatternPropagator,
+ UpdatorTool = InDetPatternUpdator,
+ RIOonTrackTool = rot_creator_digital,
+ usePixel = DetFlags.haveRIO.pixel_on(),
+ useSCT = DetFlags.haveRIO.SCT_on() if not is_dbm else False,
+ PixelClusterContainer = InDetKeys.PixelClusters(),
+ SCT_ClusterContainer = InDetKeys.SCT_Clusters())
+ if is_dbm :
+ track_finder.MagneticFieldMode = "NoField"
+ track_finder.TrackQualityCut = 9.3
+
+
+ if (DetFlags.haveRIO.SCT_on()):
+ track_finder.SctSummaryTool = InDetSCT_ConditionsSummaryTool
+ else:
+ track_finder.SctSummaryTool = None
+
+ ToolSvc += track_finder
useBremMode = NewTrackingCuts.mode() == "Offline" or NewTrackingCuts.mode() == "SLHC" or NewTrackingCuts.mode() == "DBM"
from SiTrackMakerTool_xk.SiTrackMakerTool_xkConf import InDet__SiTrackMaker_xk as SiTrackMaker
@@ -176,7 +199,7 @@ class ConfiguredNewTrackingSiPattern:
useSCT = NewTrackingCuts.useSCT(),
usePixel = NewTrackingCuts.usePixel(),
RoadTool = InDetSiDetElementsRoadMaker,
- CombinatorialTrackFinder = InDetSiComTrackFinder,
+ CombinatorialTrackFinder = track_finder,
pTmin = NewTrackingCuts.minPT(),
pTminBrem = NewTrackingCuts.minPTBrem(),
pTminSSS = InDetFlags.pT_SSScut(),
@@ -189,7 +212,7 @@ class ConfiguredNewTrackingSiPattern:
nWeightedClustersMin = NewTrackingCuts.nWeightedClustersMin(),
CosmicTrack = InDetFlags.doCosmics(),
Xi2maxMultiTracks = NewTrackingCuts.Xi2max(), # was 3.
- useSSSseedsFilter = InDetFlags.doSSSfilter(),
+ useSSSseedsFilter = InDetFlags.doSSSfilter(),
doMultiTracksProd = True,
useBremModel = InDetFlags.doBremRecovery() and useBremMode, # only for NewTracking the brem is debugged !!!
doCaloSeededBrem = InDetFlags.doCaloSeededBrem(),
@@ -452,11 +475,26 @@ class ConfiguredNewTrackingSiPattern:
# DenseEnvironmentsAmbiguityProcessorTool
from TrkAmbiguityProcessor.TrkAmbiguityProcessorConf import Trk__DenseEnvironmentsAmbiguityProcessorTool as ProcessorTool
use_low_pt_fitter = True if NewTrackingCuts.mode() == "LowPt" or NewTrackingCuts.mode() == "VeryLowPt" or (NewTrackingCuts.mode() == "Pixel" and InDetFlags.doMinBias()) else False
- fitter_list=[( InDetTrackFitter if not use_low_pt_fitter else InDetTrackFitterLowPt )]
+
+ from AthenaCommon import CfgGetter
+ from InDetRecExample.TrackingCommon import setDefaults
+ if len(NewTrackingCuts.extension()) > 0 :
+ fitter_args = setDefaults({}, SplitClusterMapExtension = NewTrackingCuts.extension() )
+ fitter_list=[ CfgGetter.getPublicToolClone('InDetTrackFitter'+NewTrackingCuts.extension(), 'InDetTrackFitter',**fitter_args) if not use_low_pt_fitter \
+ else CfgGetter.getPublicToolClone('InDetTrackFitterLowPt'+NewTrackingCuts.extension(), 'InDetTrackFitterLowPt',**fitter_args)]
+ else :
+ fitter_list=[ CfgGetter.getPublicTool('InDetTrackFitter') if not use_low_pt_fitter \
+ else CfgGetter.getPublicTool('InDetTrackFitterLowPt')]
+
if InDetFlags.doRefitInvalidCov() :
from AthenaCommon import CfgGetter
- fitter_list.append(CfgGetter.getPublicTool('KalmanFitter'))
- fitter_list.append(CfgGetter.getPublicTool('ReferenceKalmanFitter'))
+ if len(NewTrackingCuts.extension()) > 0 :
+ fitter_args = setDefaults({}, SplitClusterMapExtension = NewTrackingCuts.extension() )
+ fitter_list.append(CfgGetter.getPublicToolClone('KalmanFitter' +NewTrackingCuts.extension(),'KalmanFitter', **fitter_args))
+ fitter_list.append(CfgGetter.getPublicToolClone('ReferenceKalmanFitter'+NewTrackingCuts.extension(),'ReferenceKalmanFitter',**fitter_args))
+ else :
+ fitter_list.append(CfgGetter.getPublicTool('KalmanFitter'))
+ fitter_list.append(CfgGetter.getPublicTool('ReferenceKalmanFitter'))
InDetAmbiguityProcessor = ProcessorTool(name = 'InDetAmbiguityProcessor'+NewTrackingCuts.extension(),
Fitter = fitter_list ,
@@ -466,7 +504,7 @@ class ConfiguredNewTrackingSiPattern:
tryBremFit = InDetFlags.doBremRecovery() and useBremMode and NewTrackingCuts.mode() != "DBM",
caloSeededBrem = InDetFlags.doCaloSeededBrem() and NewTrackingCuts.mode() != "DBM",
pTminBrem = NewTrackingCuts.minPTBrem(),
- RefitPrds = True,
+ RefitPrds = True,
doHadCaloSeed = InDetFlags.doCaloSeededRefit(),
InputHadClusterContainerName = InDetKeys.HadCaloClusterROIContainer()+"Bjet")
@@ -477,9 +515,10 @@ class ConfiguredNewTrackingSiPattern:
SelectionTool = InDetAmbiTrackSelectionTool)
hasScoreProcessorTool = True
else:
+ from AthenaCommon import CfgGetter
from TrkAmbiguityProcessor.TrkAmbiguityProcessorConf import Trk__SimpleAmbiguityProcessorTool as ProcessorTool
InDetAmbiguityProcessor = ProcessorTool(name = 'InDetAmbiguityProcessor'+NewTrackingCuts.extension(),
- Fitter = InDetTrackFitter,
+ Fitter = CfgGetter.getPublicTool('InDetTrackFitter'),
ScoringTool = InDetAmbiScoringTool,
SelectionTool = InDetAmbiTrackSelectionTool,
SuppressHoleSearch = False,
@@ -508,7 +547,8 @@ class ConfiguredNewTrackingSiPattern:
if InDetAmbiguityProcessor.getName().find('Dense') :
pass
else :
- InDetAmbiguityProcessor.Fitter = InDetTrackFitterLowPt
+ from AthenaCommon import CfgGetter
+ InDetAmbiguityProcessor.Fitter = CfgGetter.getPublicTool('InDetTrackFitterLowPt')
if InDetFlags.materialInteractions():
InDetAmbiguityProcessor.MatEffects = InDetFlags.materialInteractionsType()
diff --git a/InnerDetector/InDetExample/InDetRecExample/share/ConfiguredNewTrackingTRTExtension.py b/InnerDetector/InDetExample/InDetRecExample/share/ConfiguredNewTrackingTRTExtension.py
index b53a80239c31c41a1d9a5894e25367f587a726e0..0b7ee6e43cc4155945b2594d01de263b628b16b9 100644
--- a/InnerDetector/InDetExample/InDetRecExample/share/ConfiguredNewTrackingTRTExtension.py
+++ b/InnerDetector/InDetExample/InDetRecExample/share/ConfiguredNewTrackingTRTExtension.py
@@ -98,9 +98,8 @@ class ConfiguredNewTrackingTRTExtension:
if (InDetFlags.doPrintConfigurables()):
print InDetExtensionFitter
else:
- InDetExtensionFitter = InDetTrackFitter
- if NewTrackingCuts.mode() == "LowPt":
- InDetExtensionFitter = InDetTrackFitterLowPt
+ from AthenaCommon import CfgGetter
+ InDetExtensionFitter = CfgGetter.getPublicTool('InDetTrackFitter' if NewTrackingCuts.mode() != "LowPt" else 'InDetTrackFitterLowPt')
#
# --- load scoring for extension
diff --git a/InnerDetector/InDetExample/InDetRecExample/share/ConfiguredTRTSegmentFinding.py b/InnerDetector/InDetExample/InDetRecExample/share/ConfiguredTRTSegmentFinding.py
index d96239ca37dc1aa3d5c1cdf4202df11f46b7d2e4..077799b161260bf9710be4082cb60d4dd906d418 100644
--- a/InnerDetector/InDetExample/InDetRecExample/share/ConfiguredTRTSegmentFinding.py
+++ b/InnerDetector/InDetExample/InDetRecExample/share/ConfiguredTRTSegmentFinding.py
@@ -35,7 +35,7 @@ class ConfiguredTRTSegmentFinding:
from InDetTrackPRD_Association.InDetTrackPRD_AssociationConf import InDet__InDetTrackPRD_Association
InDetSegmentPRD_Association = InDet__InDetTrackPRD_Association(name = 'InDetSegmentPRD_Association'+extension,
AssociationTool = InDetPrdAssociationTool,
- TracksName = list(InputCollections))
+ TracksName = list(InputCollections))
topSequence += InDetSegmentPRD_Association
if (InDetFlags.doPrintConfigurables()):
print InDetSegmentPRD_Association
diff --git a/InnerDetector/InDetExample/InDetRecExample/share/ConfiguredTRTStandalone.py b/InnerDetector/InDetExample/InDetRecExample/share/ConfiguredTRTStandalone.py
index 1b6dae5930d3abe910b45032eb41edf813e049d7..6b72227291881aceec64abe409187b84663ea4a0 100644
--- a/InnerDetector/InDetExample/InDetRecExample/share/ConfiguredTRTStandalone.py
+++ b/InnerDetector/InDetExample/InDetRecExample/share/ConfiguredTRTStandalone.py
@@ -77,17 +77,18 @@ class ConfiguredTRTStandalone:
#
# set up TRT_SegmentToTrackTool
#
+ from AthenaCommon import CfgGetter
from TRT_SegmentToTrackTool.TRT_SegmentToTrackToolConf import InDet__TRT_SegmentToTrackTool
InDetTRT_SegmentToTrackTool = InDet__TRT_SegmentToTrackTool(name = 'InDetTRT_SegmentToTrackTool'+extension,
- RefitterTool = InDetTrackFitterTRT,
- UseAssociationTool = usePrdAssociationTool,
- AssociationTool = InDetPrdAssociationTool,
- ScoringTool = InDetTRT_StandaloneScoringTool,
- Extrapolator = InDetExtrapolator,
- FinalRefit = True,
- MaxSharedHitsFraction = NewTrackingCuts.maxTRTonlyShared(),
- SuppressHoleSearch = True
- )
+ RefitterTool = CfgGetter.getPublicTool('InDetTrackFitterTRT'),
+ UseAssociationTool = usePrdAssociationTool,
+ AssociationTool = InDetPrdAssociationTool,
+ ScoringTool = InDetTRT_StandaloneScoringTool,
+ Extrapolator = InDetExtrapolator,
+ FinalRefit = True,
+ MaxSharedHitsFraction = NewTrackingCuts.maxTRTonlyShared(),
+ SuppressHoleSearch = True)
+
ToolSvc += InDetTRT_SegmentToTrackTool
if (InDetFlags.doPrintConfigurables()):
print InDetTRT_SegmentToTrackTool
@@ -121,12 +122,12 @@ class ConfiguredTRTStandalone:
#
# --- cosmics segment to track conversion for Barrel
#
-
+ from AthenaCommon import CfgGetter
from TRT_SegmentsToTrack.TRT_SegmentsToTrackConf import InDet__TRT_SegmentsToTrack
InDetTrkSegmenttoTrk = InDet__TRT_SegmentsToTrack(name = "InDetTRT_SegmentsToTrack_Barrel"+extension,
InputSegmentsCollection = BarrelSegments,
OutputTrackCollection = self.__TRTStandaloneTracks,
- TrackFitter = InDetTrackFitter,
+ TrackFitter = CfgGetter.getPublicTool('InDetTrackFitter'),
MinNHit = NewTrackingCuts.minTRTonly(),
CombineTracks = False,
OutputCombiCollection = "",
diff --git a/InnerDetector/InDetExample/InDetRecExample/share/InDetMonitoringAlignment.py b/InnerDetector/InDetExample/InDetRecExample/share/InDetMonitoringAlignment.py
index 25fb8bfc2461bd2ce34029c4c4194b4decfa6955..dd28ca7acfb0e1b37319d0ea5447c19d82ee842e 100755
--- a/InnerDetector/InDetExample/InDetRecExample/share/InDetMonitoringAlignment.py
+++ b/InnerDetector/InDetExample/InDetRecExample/share/InDetMonitoringAlignment.py
@@ -276,10 +276,11 @@ if jobproperties.Beam.beamType()=='cosmics':
m_deltaPhi2D = [ 0.02, 0.02, 0.02, 0.02,0.05]
m_deltaQoverPt = [ 0.05, 0.2, 0.05, 0.04, 0.1]
m_deltaQoverPt2D = [ 0.05, 0.2, 0.05, 0.04, 0.1]
-
+ from AthenaCommon import CfgGetter
+ indet_track_fitter = CfgGetter.getPublicTool('InDetTrackFitter')
for i in range(5):
m_trackSplitter.append(InDet__InDetTrackSplitterTool(name = m_trackSplitterName[i],
- TrackFitter = InDetTrackFitter,
+ TrackFitter = indet_track_fitter,
OutputUpperTracksName = m_upperTracksName[i],
OutputLowerTracksName = m_lowerTracksName[i]))
diff --git a/InnerDetector/InDetExample/InDetRecExample/share/InDetRecLoadTools.py b/InnerDetector/InDetExample/InDetRecExample/share/InDetRecLoadTools.py
index e27e7905faaf0d576682d81d55f72e6d9c04ab90..b6d0de222ce7cb0659fd77336899537614ef2ab4 100755
--- a/InnerDetector/InDetExample/InDetRecExample/share/InDetRecLoadTools.py
+++ b/InnerDetector/InDetExample/InDetRecExample/share/InDetRecLoadTools.py
@@ -6,7 +6,7 @@
# ------------------------------------------------------------
from InDetRecExample.TrackingCommon import createAndAddCondAlg
-from InDetRecExample.TrackingCommon import getRIO_OnTrackErrorScalingCondAlg,getEventInfoKey, getTRT_DriftCircleOnTrackTool
+from InDetRecExample.TrackingCommon import getRIO_OnTrackErrorScalingCondAlg,getEventInfoKey, getInDetTRT_DriftCircleOnTrackTool
use_broad_cluster_any = InDetFlags.useBroadClusterErrors() and (not InDetFlags.doDBMstandalone())
use_broad_cluster_pix = InDetFlags.useBroadPixClusterErrors() and (not InDetFlags.doDBMstandalone())
@@ -125,6 +125,7 @@ from TrkEventCnvTools import TrkEventCnvToolsConfig
#
if InDetFlags.loadRotCreator():
+ import InDetRecExample.TrackingCommon as TrackingCommon
#
# --- configure default ROT creator
#
@@ -133,205 +134,59 @@ if InDetFlags.loadRotCreator():
# load Pixel ROT creator, we overwrite the defaults for the
# tool to always make conservative pixel cluster errors
# SiLorentzAngleTool
- if not hasattr(ToolSvc, "PixelLorentzAngleTool"):
- from SiLorentzAngleTool.PixelLorentzAngleToolSetup import PixelLorentzAngleToolSetup
- pixelLorentzAngleToolSetup = PixelLorentzAngleToolSetup()
- from SiClusterOnTrackTool.SiClusterOnTrackToolConf import InDet__PixelClusterOnTrackTool
if InDetFlags.doDBM():
- PixelClusterOnTrackToolDBM = InDet__PixelClusterOnTrackTool("InDetPixelClusterOnTrackToolDBM",
- LorentzAngleTool = ToolSvc.PixelLorentzAngleTool,
- DisableDistortions = True,
- applyNNcorrection = False,
- NNIBLcorrection = False,
- SplitClusterAmbiguityMap = InDetKeys.SplitClusterAmbiguityMap() + InDetNewTrackingCuts.extension(),
- RunningTIDE_Ambi = False,
- ErrorStrategy = 0,
- PositionStrategy = 0
- )
- ToolSvc += PixelClusterOnTrackToolDBM
- PixelClusterOnTrackTool = InDet__PixelClusterOnTrackTool("InDetPixelClusterOnTrackTool",
- LorentzAngleTool = ToolSvc.PixelLorentzAngleTool,
- DisableDistortions = (InDetFlags.doFatras() or InDetFlags.doDBMstandalone()),
- applyNNcorrection = ( InDetFlags.doPixelClusterSplitting() and
- InDetFlags.pixelClusterSplittingType() == 'NeuralNet' and not InDetFlags.doSLHC()),
- NNIBLcorrection = ( InDetFlags.doPixelClusterSplitting() and
- InDetFlags.pixelClusterSplittingType() == 'NeuralNet' and not InDetFlags.doSLHC()),
- SplitClusterAmbiguityMap = InDetKeys.SplitClusterAmbiguityMap() + InDetNewTrackingCuts.extension(),
- RunningTIDE_Ambi = InDetFlags.doTIDE_Ambi()
- )
- if InDetFlags.doPixelClusterSplitting() and InDetFlags.pixelClusterSplittingType() == 'NeuralNet':
- PixelClusterOnTrackTool.NnClusterizationFactory = NnClusterizationFactory
- if InDetFlags.doTIDE_RescalePixelCovariances() :
- PixelClusterOnTrackTool.applydRcorrection = True
-
- if InDetFlags.doCosmics() or InDetFlags.doDBMstandalone():
- PixelClusterOnTrackTool.ErrorStrategy = 0
- PixelClusterOnTrackTool.PositionStrategy = 0
-
- ToolSvc += PixelClusterOnTrackTool
-
- PixelClusterOnTrackToolPattern = InDet__PixelClusterOnTrackTool("InDetPixelClusterOnTrackToolPattern",
- DisableDistortions = (InDetFlags.doFatras() or InDetFlags.doDBMstandalone()),
- applyNNcorrection = ( InDetFlags.doPixelClusterSplitting() and
- InDetFlags.pixelClusterSplittingType() == 'NeuralNet' and not InDetFlags.doSLHC()),
- NNIBLcorrection = ( InDetFlags.doPixelClusterSplitting() and
- InDetFlags.pixelClusterSplittingType() == 'NeuralNet' and not InDetFlags.doSLHC()),
- SplitClusterAmbiguityMap = InDetKeys.SplitClusterAmbiguityMap(),
- RunningTIDE_Ambi = InDetFlags.doTIDE_Ambi()
- )
- if InDetFlags.doPixelClusterSplitting() and InDetFlags.pixelClusterSplittingType() == 'NeuralNet':
- PixelClusterOnTrackToolPattern.NnClusterizationFactory = NnClusterizationFactory
- if InDetFlags.doTIDE_RescalePixelCovariances() :
- PixelClusterOnTrackToolPattern.applydRcorrection = True
-
- ToolSvc += PixelClusterOnTrackToolPattern
+ PixelClusterOnTrackToolDBM = TrackingCommon.getInDetPixelClusterOnTrackToolDBM()
+ PixelClusterOnTrackTool = TrackingCommon.getInDetPixelClusterOnTrackTool()
+ PixelClusterOnTrackToolPattern = TrackingCommon.getInDetPixelClusterOnTrackToolPattern()
- if (InDetFlags.doPrintConfigurables()):
- print PixelClusterOnTrackTool
- if InDetFlags.doDBM():
- print PixelClusterOnTrackToolDBM
-
if InDetFlags.doDigitalROTCreation():
-
- PixelClusterOnTrackToolDigital = InDet__PixelClusterOnTrackTool("InDetPixelClusterOnTrackToolDigital",
- LorentzAngleTool = ToolSvc.PixelLorentzAngleTool,
- DisableDistortions = (InDetFlags.doFatras() or InDetFlags.doDBMstandalone()),
- applyNNcorrection = False,
- NNIBLcorrection = False,
- SplitClusterAmbiguityMap = InDetKeys.SplitClusterAmbiguityMap() + InDetNewTrackingCuts.extension(),
- RunningTIDE_Ambi = InDetFlags.doTIDE_Ambi(),
- ErrorStrategy = 2,
- PositionStrategy = 1
- )
-
- ToolSvc += PixelClusterOnTrackToolDigital
-
+ PixelClusterOnTrackToolDigital = TrackingCommon.getInDetPixelClusterOnTrackToolDigital()
else :
- PixelClusterOnTrackToolDigital = InDet__PixelClusterOnTrackTool("InDetPixelClusterOnTrackToolDigital",
- LorentzAngleTool = ToolSvc.PixelLorentzAngleTool,
- DisableDistortions = (InDetFlags.doFatras() or InDetFlags.doDBMstandalone()),
- applyNNcorrection = ( InDetFlags.doPixelClusterSplitting() and
- InDetFlags.pixelClusterSplittingType() == 'NeuralNet' and not InDetFlags.doSLHC()),
- NNIBLcorrection = ( InDetFlags.doPixelClusterSplitting() and
- InDetFlags.pixelClusterSplittingType() == 'NeuralNet' and not InDetFlags.doSLHC()),
- SplitClusterAmbiguityMap = "",
- RunningTIDE_Ambi = InDetFlags.doTIDE_Ambi()
- )
- ToolSvc += PixelClusterOnTrackToolDigital
+ PixelClusterOnTrackToolDigital = TrackingCommon.getInDetPixelClusterOnTrackTool(name = "InDetPixelClusterOnTrackToolNoSplitClusterMap",
+ SplitClusterAmbiguityMap = "")
else:
PixelClusterOnTrackTool = None
PixelClusterOnTrackToolDigital = None
PixelClusterOnTrackToolPattern = None
if DetFlags.haveRIO.SCT_on():
- # SiLorentzAngleTool
- from SiLorentzAngleTool.SCTLorentzAngleToolSetup import SCTLorentzAngleToolSetup
- sctLorentzAngleToolSetup = SCTLorentzAngleToolSetup()
- from SiClusterOnTrackTool.SiClusterOnTrackToolConf import InDet__SCT_ClusterOnTrackTool
- SCT_ClusterOnTrackTool = InDet__SCT_ClusterOnTrackTool ("InDetSCT_ClusterOnTrackTool",
- #CorrectionStrategy = -1, # no position correction (test for bug #56477)
- CorrectionStrategy = 0, # do correct position bias
- ErrorStrategy = 2, # do use phi dependent errors
- LorentzAngleTool = sctLorentzAngleToolSetup.SCTLorentzAngleTool)
- if (InDetFlags.doPrintConfigurables()):
- print SCT_ClusterOnTrackTool
+ SCT_ClusterOnTrackTool = TrackingCommon.getInDetSCT_ClusterOnTrackTool()
else:
SCT_ClusterOnTrackTool = None
#
# default ROT creator, not smart !
#
- from TrkRIO_OnTrackCreator.TrkRIO_OnTrackCreatorConf import Trk__RIO_OnTrackCreator
- InDetRotCreator = Trk__RIO_OnTrackCreator(name = 'InDetRotCreator',
- ToolPixelCluster = PixelClusterOnTrackTool,
- ToolSCT_Cluster = SCT_ClusterOnTrackTool,
- Mode = 'indet')
-
- InDetRotCreatorPattern = Trk__RIO_OnTrackCreator(name = 'InDetRotCreatorPattern',
- ToolPixelCluster = PixelClusterOnTrackToolPattern,
- ToolSCT_Cluster = SCT_ClusterOnTrackTool,
- Mode = 'indet')
+ InDetRotCreator = TrackingCommon.getInDetRotCreator()
+ InDetRotCreatorPattern = TrackingCommon.getInDetRotCreatorPattern()
if InDetFlags.doDBM():
- if InDetFlags.loadRotCreator() and DetFlags.haveRIO.pixel_on():
- InDetRotCreatorDBM = Trk__RIO_OnTrackCreator(name = 'InDetRotCreatorDBM',
- ToolPixelCluster = PixelClusterOnTrackToolDBM,
- ToolSCT_Cluster = SCT_ClusterOnTrackTool,
- Mode = 'indet')
- else:
- InDetRotCreatorDBM = Trk__RIO_OnTrackCreator(name = 'InDetRotCreatorDBM',
- ToolPixelCluster = PixelClusterOnTrackTool,
- ToolSCT_Cluster = SCT_ClusterOnTrackTool,
- Mode = 'indet')
- ToolSvc += InDetRotCreatorDBM
-
-
-
- ToolSvc += InDetRotCreator
- ToolSvc += InDetRotCreatorPattern
+ InDetRotCreatorDBM=TrackingCommon.getInDetRotCreatorDBM()
if PixelClusterOnTrackToolDigital != None :
- InDetRotCreatorDigital = Trk__RIO_OnTrackCreator(name = 'InDetRotCreatorDigital',
- ToolPixelCluster = PixelClusterOnTrackToolDigital,
- ToolSCT_Cluster = SCT_ClusterOnTrackTool,
- Mode = 'indet')
- ToolSvc += InDetRotCreatorDigital
-
+ InDetRotCreatorDigital = TrackingCommon.getInDetRotCreatorDigital()
else:
-
InDetRotCreatorDigital=InDetRotCreatorPattern
#
# --- configure broad cluster ROT creator
#
if DetFlags.haveRIO.pixel_on():
- # SiLorentzAngleTool
- if not hasattr(ToolSvc, "PixelLorentzAngleTool"):
- from SiLorentzAngleTool.PixelLorentzAngleToolSetup import PixelLorentzAngleToolSetup
- pixelLorentzAngleToolSetup = PixelLorentzAngleToolSetup()
#
# tool to always make conservative pixel cluster errors
if not InDetFlags.doDBMstandalone():
- from SiClusterOnTrackTool.SiClusterOnTrackToolConf import InDet__PixelClusterOnTrackTool
- BroadPixelClusterOnTrackTool = InDet__PixelClusterOnTrackTool("InDetBroadPixelClusterOnTrackTool",
- LorentzAngleTool = ToolSvc.PixelLorentzAngleTool,
- ErrorStrategy = 0,
- DisableDistortions = (InDetFlags.doFatras() or InDetFlags.doDBMstandalone()),
- applyNNcorrection = ( InDetFlags.doPixelClusterSplitting() and
- InDetFlags.pixelClusterSplittingType() == 'NeuralNet' and not InDetFlags.doSLHC()),
- NNIBLcorrection = ( InDetFlags.doPixelClusterSplitting() and
- InDetFlags.pixelClusterSplittingType() == 'NeuralNet' and not InDetFlags.doSLHC()),
- SplitClusterAmbiguityMap = InDetKeys.SplitClusterAmbiguityMap(),
- RunningTIDE_Ambi = InDetFlags.doTIDE_Ambi()
- )
- if InDetFlags.doPixelClusterSplitting() and InDetFlags.pixelClusterSplittingType() == 'NeuralNet':
- BroadPixelClusterOnTrackTool.NnClusterizationFactory = NnClusterizationFactory
- if InDetFlags.doTIDE_RescalePixelCovariances() :
- BroadPixelClusterOnTrackTool.applydRcorrection = True
-
- ToolSvc += BroadPixelClusterOnTrackTool
- if (InDetFlags.doPrintConfigurables()):
- print BroadPixelClusterOnTrackTool
+ BroadPixelClusterOnTrackTool = TrackingCommon.getInDetBroadPixelClusterOnTrackTool()
else:
BroadPixelClusterOnTrackTool = None
else:
BroadPixelClusterOnTrackTool = None
if DetFlags.haveRIO.SCT_on():
- # SiLorentzAngleTool
- from SiLorentzAngleTool.SCTLorentzAngleToolSetup import SCTLorentzAngleToolSetup
- sctLorentzAngleToolSetup = SCTLorentzAngleToolSetup()
#
# tool to always make conservative sct cluster errors
#
from SiClusterOnTrackTool.SiClusterOnTrackToolConf import InDet__SCT_ClusterOnTrackTool
- BroadSCT_ClusterOnTrackTool = InDet__SCT_ClusterOnTrackTool ("InDetBroadSCT_ClusterOnTrackTool",
- #CorrectionStrategy = -1, # no position correction (test for bug #56477)
- CorrectionStrategy = 0, # do correct position bias
- ErrorStrategy = 0, # do use broad errors
- LorentzAngleTool = sctLorentzAngleToolSetup.SCTLorentzAngleTool)
- if (InDetFlags.doPrintConfigurables()):
- print BroadSCT_ClusterOnTrackTool
+ BroadSCT_ClusterOnTrackTool = TrackingCommon.getInDetBroadSCT_ClusterOnTrackTool()
else:
BroadSCT_ClusterOnTrackTool= None
@@ -339,38 +194,12 @@ if InDetFlags.loadRotCreator():
#
# tool to always make conservative trt drift circle errors
#
- from TRT_DriftCircleOnTrackTool.TRT_DriftCircleOnTrackToolConf import InDet__TRT_DriftCircleOnTrackNoDriftTimeTool
- BroadTRT_DriftCircleOnTrackTool = InDet__TRT_DriftCircleOnTrackNoDriftTimeTool ("InDetBroadTRT_DriftCircleOnTrackTool")
- ToolSvc += BroadTRT_DriftCircleOnTrackTool
- if (InDetFlags.doPrintConfigurables()):
- print BroadTRT_DriftCircleOnTrackTool
+ BroadTRT_DriftCircleOnTrackTool = TrackingCommon.getInDetBroadTRT_DriftCircleOnTrackTool()
else:
BroadTRT_DriftCircleOnTrackTool = None
- from TrkRIO_OnTrackCreator.TrkRIO_OnTrackCreatorConf import Trk__RIO_OnTrackCreator
- BroadInDetRotCreator = Trk__RIO_OnTrackCreator(name = 'InDetBroadInDetRotCreator',
- ToolPixelCluster = BroadPixelClusterOnTrackTool,
- ToolSCT_Cluster = BroadSCT_ClusterOnTrackTool,
- ToolTRT_DriftCircle = BroadTRT_DriftCircleOnTrackTool,
- Mode = 'indet')
- ToolSvc += BroadInDetRotCreator
+ BroadInDetRotCreator = TrackingCommon.getInDetBroadRotCreator()
- #
- # use broad clusters everywhere ?
- #
- if use_broad_cluster_pix == True :
- InDetRotCreator.ToolPixelCluster = BroadPixelClusterOnTrackTool
-
- if use_broad_cluster_sct == True :
- InDetRotCreator.ToolSCT_Cluster = BroadSCT_ClusterOnTrackTool
-
- if (InDetFlags.doPrintConfigurables()):
- print InDetRotCreator
- if InDetFlags.doDBM():
- print InDetRotCreatorDBM
- if (InDetFlags.doPrintConfigurables()):
- print BroadInDetRotCreator
-
#
# --- load error scaling
#
@@ -383,35 +212,13 @@ if InDetFlags.loadRotCreator():
if InDetFlags.redoTRT_LR():
if DetFlags.haveRIO.TRT_on():
- from TRT_DriftCircleOnTrackTool.TRT_DriftCircleOnTrackToolConf import InDet__TRT_DriftCircleOnTrackUniversalTool
-
# --- this is the cut for making a TRT hit a tube hit (biases the distribution)
-
- TRT_RefitRotCreator = InDet__TRT_DriftCircleOnTrackUniversalTool(name = 'InDetTRT_RefitRotCreator',
- RIOonTrackToolDrift = getTRT_DriftCircleOnTrackTool(),
- RIOonTrackToolTube = BroadTRT_DriftCircleOnTrackTool,
- ScaleHitUncertainty = ScaleHitUncertainty) # fix from Thijs
- ToolSvc += TRT_RefitRotCreator
- if (InDetFlags.doPrintConfigurables()):
- print TRT_RefitRotCreator
+ TRT_RefitRotCreator = TrackingCommon.getInDetTRT_DriftCircleOnTrackUniversalTool()
else:
TRT_RefitRotCreator = None
-
- from TrkRIO_OnTrackCreator.TrkRIO_OnTrackCreatorConf import Trk__RIO_OnTrackCreator
- InDetRefitRotCreator = Trk__RIO_OnTrackCreator(name = 'InDetRefitRotCreator',
- ToolPixelCluster = PixelClusterOnTrackTool,
- ToolSCT_Cluster = SCT_ClusterOnTrackTool,
- ToolTRT_DriftCircle = TRT_RefitRotCreator,
- Mode = 'indet')
- if use_broad_cluster_pix == True :
- InDetRefitRotCreator.ToolPixelCluster=BroadPixelClusterOnTrackTool
- if use_broad_cluster_sct == True :
- InDetRefitRotCreator.ToolSCT_Cluster=BroadSCT_ClusterOnTrackTool
-
- ToolSvc += InDetRefitRotCreator
- if (InDetFlags.doPrintConfigurables()):
- print InDetRefitRotCreator
-
+
+ InDetRefitRotCreator = TrackingCommon.getInDetRefitRotCreator()
+
else:
InDetRefitRotCreator = InDetRotCreator
@@ -557,330 +364,32 @@ if InDetFlags.loadExtrapolator():
#
if InDetFlags.loadFitter():
- #
- # ----------- Kalman Filter setup (including DNA setup if needed)
- #
- if InDetFlags.trackFitterType() in ['KalmanFitter', 'KalmanDNAFitter', 'ReferenceKalmanFitter']:
-
- from InDetCompetingRIOsOnTrackTool.InDetCompetingRIOsOnTrackToolConf \
- import InDet__CompetingPixelClustersOnTrackTool as IDCPCOTT
- InDetCompetingPixelTool = IDCPCOTT(name='KalmanCompetingPixelClustersTool',
- WeightCutValueBarrel = 5.5,
- WeightCutValueEndCap = 5.5)
- ToolSvc+=InDetCompetingPixelTool
- from InDetCompetingRIOsOnTrackTool.InDetCompetingRIOsOnTrackToolConf \
- import InDet__CompetingSCT_ClustersOnTrackTool as IDCSCOTT
- InDetCompetingSctTool = IDCSCOTT(name='KalmanCompetingSCT_ClustersTool',
- WeightCutValueBarrel = 5.5,
- WeightCutValueEndCap = 5.5)
- ToolSvc+=InDetCompetingSctTool
- from TrkCompetingRIOsOnTrackTool.TrkCompetingRIOsOnTrackToolConf \
- import Trk__CompetingRIOsOnTrackTool as CompRotTool
- InDetKalmanCompetingROT_Tool = CompRotTool(name='KalmanCompetingRIOsTool',
- ToolForCompPixelClusters = InDetCompetingPixelTool,
- ToolForCompSCT_Clusters = InDetCompetingSctTool)
- ToolSvc += InDetKalmanCompetingROT_Tool
-
- if InDetFlags.trackFitterType() is 'KalmanDNAFitter' or \
- ( InDetFlags.doBremRecovery() and InDetFlags.trackFitterType() is 'KalmanFitter'):
-
- from TrkDynamicNoiseAdjustor.TrkDynamicNoiseAdjustorConf import Trk__InDetDynamicNoiseAdjustment
- InDetDNAdjustor = Trk__InDetDynamicNoiseAdjustment(name = 'InDetDNAdjustor')
- ToolSvc += InDetDNAdjustor
- if (InDetFlags.doPrintConfigurables()):
- print InDetDNAdjustor
-
- from InDetDNASeparator.InDetDNASeparatorConf import InDet__InDetDNASeparator
- InDetDNASeparator = InDet__InDetDNASeparator(name="InDetDNASeparator")
-
- ToolSvc += InDetDNASeparator
- if (InDetFlags.doPrintConfigurables()):
- print InDetDNASeparator
-
- else:
- InDetDNAdjustor = None
- InDetDNASeparator = None
-
- # Load Kalman Filter tools
- if InDetFlags.trackFitterType() is 'ReferenceKalmanFitter' :
- from TrkKalmanFitter.TrkKalmanFitterConf import Trk__ForwardRefTrackKalmanFitter as PublicFKF
- else :
- from TrkKalmanFitter.TrkKalmanFitterConf import Trk__ForwardKalmanFitter as PublicFKF
- InDetFKF = PublicFKF(name = 'InDetFKF',
- StateChi2PerNDFPreCut = 30.0)
- ToolSvc += InDetFKF
- if (InDetFlags.doPrintConfigurables()):
- print InDetFKF
- from TrkKalmanFitter.TrkKalmanFitterConf import Trk__KalmanSmoother as PublicBKS
- InDetBKS = PublicBKS(name = 'InDetBKS',
- InitialCovarianceSeedFactor = 200.)
- ToolSvc += InDetBKS
- if (InDetFlags.doPrintConfigurables()):
- print InDetBKS
- from TrkKalmanFitter.TrkKalmanFitterConf import Trk__KalmanOutlierRecovery_InDet as PublicKOR
- InDetKOR = PublicKOR(name = "KOL_RecoveryID")
-
- from TrkKalmanFitter.TrkKalmanFitterConf import Trk__KalmanOutlierLogic as PublicKOL
- InDetKOL = PublicKOL(name = 'InDetKOL',
- TrackChi2PerNDFCut = 17.0,
- StateChi2PerNDFCut = 12.5)
- ToolSvc += InDetKOL
- if (InDetFlags.doPrintConfigurables()):
- print InDetKOL
-
- from TrkKalmanFitter.TrkKalmanFitterConf import Trk__KalmanPiecewiseAnnealingFilter as KPAF
- InDetKalmanInternalDAF = KPAF(name = 'KalmanInternalDAF',
- CompetingRIOsOnTrackCreator = InDetKalmanCompetingROT_Tool)
- ToolSvc += InDetKalmanInternalDAF
- if InDetFlags.trackFitterType() is 'ReferenceKalmanFitter' :
- InDetAnnealFKF = PublicFKF(name = 'InDetAnnealFKF') # allow separate options
- ToolSvc+=InDetAnnealFKF
- InDetKalmanInternalDAF.ForwardFitter = InDetAnnealFKF
- InDetKalmanInternalDAF.BackwardSmoother = InDetBKS # same tuning so far
-
- from TrkKalmanFitter.TrkKalmanFitterConf import Trk__MeasRecalibSteeringTool
- InDetMeasRecalibST = Trk__MeasRecalibSteeringTool(name='InDetMeasRecalibST',
- BroadPixelClusterOnTrackTool = BroadPixelClusterOnTrackTool,
- BroadSCT_ClusterOnTrackTool = BroadSCT_ClusterOnTrackTool,
- CommonRotCreator = InDetRefitRotCreator
- )
- ToolSvc += InDetMeasRecalibST
- if (InDetFlags.doPrintConfigurables()):
- print InDetMeasRecalibST
-
- from TrkKalmanFitter.TrkKalmanFitterConf import Trk__KalmanFitter as ConfiguredKalmanFitter
- InDetTrackFitter = ConfiguredKalmanFitter(name = 'InDetTrackFitter',
- ExtrapolatorHandle = InDetExtrapolator,
- RIO_OnTrackCreatorHandle = InDetRefitRotCreator,
- MeasurementUpdatorHandle = InDetUpdator,
- ForwardKalmanFitterHandle = InDetFKF,
- KalmanSmootherHandle = InDetBKS,
- KalmanOutlierLogicHandle = InDetKOL,
- DynamicNoiseAdjustorHandle = InDetDNAdjustor,
- BrempointAnalyserHandle = InDetDNASeparator,
- AlignableSurfaceProviderHandle = None,
- RecalibratorHandle = InDetMeasRecalibST,
- InternalDAFHandle = InDetKalmanInternalDAF)
-
- if InDetFlags.doBremRecovery() and InDetFlags.trackFitterType() is 'KalmanFitter':
- InDetTrackFitter.DoDNAForElectronsOnly = True
-
- #
- # ----------- Distributed Kalman Filter setup
- #
- elif InDetFlags.trackFitterType() is 'DistributedKalmanFilter' :
- from TrkDistributedKalmanFilter.TrkDistributedKalmanFilterConf import Trk__DistributedKalmanFilter
- InDetTrackFitter = Trk__DistributedKalmanFilter(name = 'InDetTrackFitter',
- ExtrapolatorTool = InDetExtrapolator,
- ROTcreator = InDetRotCreator
- #sortingReferencePoint = ???
- )
-
- #
- # ----------- Global Chi2 Fitter setup
- #
- elif InDetFlags.trackFitterType() is 'GlobalChi2Fitter' :
- #
- # !!!!!!!!!!!!!!!!!!!!!!! HACK
- #
- if InDetFlags.doBremRecovery() :
- from TrkExTools.TrkExToolsConf import Trk__EnergyLossUpdator
- InDetEnergyLossUpdator = Trk__EnergyLossUpdator(name="AtlasEnergyLossUpdator")
- ToolSvc += InDetEnergyLossUpdator
- ToolSvc.AtlasEnergyLossUpdator.UseBetheBlochForElectrons = False
- #
- # ----------- main Global Chi2 Fitter for NewT and BackT
- #
- from TrkGlobalChi2Fitter.TrkGlobalChi2FitterConf import Trk__GlobalChi2Fitter
- InDetTrackFitter = Trk__GlobalChi2Fitter(name = 'InDetTrackFitter',
- ExtrapolationTool = InDetExtrapolator,
- NavigatorTool = InDetNavigator,
- PropagatorTool = InDetPropagator,
- RotCreatorTool = InDetRotCreator,
- BroadRotCreatorTool = BroadInDetRotCreator,
- MultipleScatteringTool = InDetMultipleScatteringUpdator,
- MeasurementUpdateTool = InDetUpdator,
- TrackingGeometrySvc = AtlasTrackingGeometrySvc,
- MaterialUpdateTool = InDetMaterialUpdator,
- StraightLine = not InDetFlags.solenoidOn(),
- OutlierCut = 4,
- SignedDriftRadius = True,
- ReintegrateOutliers = True,
- RecalibrateSilicon = True,
- RecalibrateTRT = True,
- TRTTubeHitCut = ScaleHitUncertainty,
- MaxIterations = 40,
- Acceleration = True,
- RecalculateDerivatives= InDetFlags.doMinBias() or InDetFlags.doCosmics() or InDetFlags.doBeamHalo(),
- TRTExtensionCuts = True,
- TrackChi2PerNDFCut = 7)
-
- if InDetFlags.doDBMstandalone():
- InDetTrackFitter.StraightLine = True
- InDetTrackFitter.OutlierCut = 5
- InDetTrackFitter.RecalibrateTRT = False
- InDetTrackFitter.TRTExtensionCuts = False
- InDetTrackFitter.TrackChi2PerNDFCut = 20
-
- if InDetFlags.doRefit() or use_broad_cluster_any == True:
- InDetTrackFitter.RecalibrateSilicon = False
- if InDetFlags.doRefit():
- InDetTrackFitter.BroadRotCreatorTool = None
- InDetTrackFitter.ReintegrateOutliers = False
- InDetTrackFitter.RecalibrateTRT = False
- if InDetFlags.doRobustReco():
- #InDetTrackFitter.BroadRotCreatorTool=None
- InDetTrackFitter.OutlierCut = 10.0
- InDetTrackFitter.TrackChi2PerNDFCut = 20
- if InDetFlags.doRobustReco() or InDetFlags.doCosmics():
- InDetTrackFitter.MaxOutliers = 99
- if InDetFlags.doCosmics() or InDetFlags.doBeamHalo():
- InDetTrackFitter.Acceleration = False
-
- if InDetFlags.materialInteractions() and not InDetFlags.solenoidOn():
- InDetTrackFitter.Momentum = 1000.*MeV
-
- #
- # ----------- Global Chi2 Fitter for Low-Pt with different settings
- #
- if InDetFlags.doLowPt() or InDetFlags.doVeryLowPt() or (InDetFlags.doTrackSegmentsPixel() and InDetFlags.doMinBias()):
- InDetTrackFitterLowPt = Trk__GlobalChi2Fitter(name = 'InDetTrackFitterLowPt',
- ExtrapolationTool = InDetExtrapolator,
- NavigatorTool = InDetNavigator,
- PropagatorTool = InDetPropagator,
- RotCreatorTool = InDetRotCreator,
- BroadRotCreatorTool = BroadInDetRotCreator,
- MultipleScatteringTool = InDetMultipleScatteringUpdator,
- MeasurementUpdateTool = InDetUpdator,
- StraightLine = not InDetFlags.solenoidOn(),
- OutlierCut = 5.0,
- SignedDriftRadius = True,
- ReintegrateOutliers = True,
- RecalibrateSilicon = True,
- RecalibrateTRT = True,
- TRTTubeHitCut = ScaleHitUncertainty,
- MaxIterations = 40,
- RecalculateDerivatives= True,
- TRTExtensionCuts = True,
- TrackChi2PerNDFCut = 10)
-
- #
- # ----------- Global Chi2 Fitter for TRT segments with different settings
- #
- InDetTrackFitterTRT = Trk__GlobalChi2Fitter(name = 'InDetTrackFitterTRT',
- ExtrapolationTool = InDetExtrapolator,
- NavigatorTool = InDetNavigator,
- PropagatorTool = InDetPropagator,
- RotCreatorTool = InDetRefitRotCreator,
- MeasurementUpdateTool = InDetUpdator,
- MultipleScatteringTool = InDetMultipleScatteringUpdator,
- StraightLine = not InDetFlags.solenoidOn(),
- ReintegrateOutliers = False,
- MaxIterations = 10,
- RecalculateDerivatives= False,
- TrackChi2PerNDFCut = 999999)
- #TrackChi2PerNDFCut = 10)
-
- if InDetFlags.materialInteractions() and not InDetFlags.solenoidOn():
- InDetTrackFitterTRT.Momentum=1000.*MeV
- if InDetFlags.doRobustReco() or InDetFlags.doCosmics():
- InDetTrackFitterTRT.MaxOutliers=99
- if InDetFlags.doRefit():
- InDetTrackFitterTRT.ReintegrateOutliers = False
-
- #
- # ----------- Gaussian Sum Fitter setup
- #
- elif InDetFlags.trackFitterType() is 'GaussianSumFilter' :
- #
- # Material effects for the Gsf Extrapolator
- #
- from TrkGaussianSumFilter.TrkGaussianSumFilterConf import Trk__GsfMaterialMixtureConvolution
- InDetGsfMaterialUpdator = Trk__GsfMaterialMixtureConvolution (name = 'InDetGsfMaterialUpdator')
- ToolSvc += InDetGsfMaterialUpdator
- if (InDetFlags.doPrintConfigurables()):
- print InDetGsfMaterialUpdator
- #
- # component Reduction
- #
- from TrkGaussianSumFilter.TrkGaussianSumFilterConf import Trk__QuickCloseComponentsMultiStateMerger
- InDetGsfComponentReduction = Trk__QuickCloseComponentsMultiStateMerger (name = 'InDetGsfComponentReduction',
- MaximumNumberOfComponents = 12)
- ToolSvc += InDetGsfComponentReduction
- if (InDetFlags.doPrintConfigurables()):
- print InDetGsfComponentReduction
- #
- # declare the extrapolator
- #
- from TrkGaussianSumFilter.TrkGaussianSumFilterConf import Trk__GsfExtrapolator
- InDetGsfExtrapolator = Trk__GsfExtrapolator(name = 'InDetGsfExtrapolator',
- Propagators = [ InDetPropagator ],
- SearchLevelClosestParameters = 10,
- StickyConfiguration = True,
- Navigator = InDetNavigator,
- GsfMaterialConvolution = InDetGsfMaterialUpdator,
- ComponentMerger = InDetGsfComponentReduction,
- SurfaceBasedMaterialEffects = False )
- ToolSvc += InDetGsfExtrapolator
- if (InDetFlags.doPrintConfigurables()):
- print InDetGsfExtrapolator
- # load alternative track fitter
- from TrkGaussianSumFilter.TrkGaussianSumFilterConf import Trk__GaussianSumFitter
- InDetTrackFitter = Trk__GaussianSumFitter(name = 'InDetTrackFitter',
- ToolForExtrapolation = InDetGsfExtrapolator,
- MeasurementUpdatorType = InDetGsfMeasurementUpdator,
- ToolForROTCreation = InDetRotCreator,
- ReintegrateOutliers = False,
- MakePerigee = True,
- RefitOnMeasurementBase = True,
- DoHitSorting = True)
+ if InDetFlags.doBremRecovery() and InDetFlags.trackFitterType() is 'GlobalChi2Fitter' :
+ # @TODO create where it is needed
+ from TrkExTools.TrkExToolsConf import Trk__EnergyLossUpdator
+ InDetEnergyLossUpdator = Trk__EnergyLossUpdator(name="AtlasEnergyLossUpdator",
+ UseBetheBlochForElectrons = False)
+ ToolSvc += InDetEnergyLossUpdator
+ from AthenaCommon import CfgGetter
+ InDetTrackFitter = CfgGetter.getPublicTool('InDetTrackFitter')
+ if InDetFlags.doLowPt() or InDetFlags.doVeryLowPt() or (InDetFlags.doTrackSegmentsPixel() and InDetFlags.doMinBias()):
+ InDetTrackFitterLowPt = CfgGetter.getPublicTool('InDetTrackFitterLowPt')
+ if DetFlags.TRT_on():
+ InDetTrackFitterTRT = CfgGetter.getPublicTool('InDetTrackFitterTRT')
if InDetFlags.doDBM():
- InDetTrackFitterDBM = Trk__GlobalChi2Fitter(name = 'InDetTrackFitterDBM',
- ExtrapolationTool = InDetExtrapolator,
- NavigatorTool = InDetNavigator,
- PropagatorTool = InDetPropagator,
- RotCreatorTool = InDetRotCreatorDBM,
- BroadRotCreatorTool = None,
- MultipleScatteringTool = InDetMultipleScatteringUpdator,
- MeasurementUpdateTool = InDetUpdator,
- TrackingGeometrySvc = AtlasTrackingGeometrySvc,
- MaterialUpdateTool = InDetMaterialUpdator,
- StraightLine = True,
- OutlierCut = 5,
- SignedDriftRadius = True,
- ReintegrateOutliers = True,
- RecalibrateSilicon = True,
- RecalibrateTRT = False,
- TRTTubeHitCut = ScaleHitUncertainty,
- MaxIterations = 40,
- Acceleration = True,
- RecalculateDerivatives= False,
- TRTExtensionCuts = False,
- TrackChi2PerNDFCut = 20,
- Momentum = 1000.*MeV)
- ToolSvc += InDetTrackFitterDBM
-
- # --- end of fitter loading
- ToolSvc += InDetTrackFitter
- if (InDetFlags.doPrintConfigurables()):
- print InDetTrackFitter
- if InDetFlags.doDBM():
- print InDetTrackFitterDBM
-
- if InDetFlags.trackFitterType() is not 'GlobalChi2Fitter' :
- InDetTrackFitterTRT=InDetTrackFitter
- InDetTrackFitterLowPt=InDetTrackFitter
- else:
- if not InDetFlags.doDBMstandalone():
- ToolSvc += InDetTrackFitterTRT
- if (InDetFlags.doPrintConfigurables()):
- print InDetTrackFitterTRT
- if InDetFlags.doLowPt() or (InDetFlags.doTrackSegmentsPixel() and InDetFlags.doMinBias()):
- ToolSvc+=InDetTrackFitterLowPt
- if (InDetFlags.doPrintConfigurables()):
- print InDetTrackFitterLowPt
+ InDetTrackFitterDBM = CfgGetter.getPublicTool('InDetTrackFitterDBM')
+
+ # @TODO should aldready be in ToolSvc
+ # if not InDetFlags.doDBMstandalone():
+ # ToolSvc += InDetTrackFitterTRT
+ # if (InDetFlags.doPrintConfigurables()):
+ # print InDetTrackFitterTRT
+ # if InDetFlags.doLowPt() or (InDetFlags.doTrackSegmentsPixel() and InDetFlags.doMinBias()):
+ # ToolSvc+=InDetTrackFitterLowPt
+ # if (InDetFlags.doPrintConfigurables()):
+ # print InDetTrackFitterLowPt
#
# ----------- load association tool from Inner Detector to handle pixel ganged ambiguities
@@ -1375,10 +884,11 @@ if InDetFlags.doPattern() and InDetFlags.doCosmics():
print InDetAmbiTrackSelectionToolCosmics
+ from AthenaCommon import CfgGetter
from TrkAmbiguityProcessor.TrkAmbiguityProcessorConf import Trk__SimpleAmbiguityProcessorTool
InDetAmbiguityProcessorCosmics = Trk__SimpleAmbiguityProcessorTool(name = 'InDetAmbiguityProcessorCosmics',
ScoringTool = InDetScoringToolCosmics,
- Fitter = InDetTrackFitter,
+ Fitter = CfgGetter.getPublicTool('InDetTrackFitter'),
SelectionTool = InDetAmbiTrackSelectionToolCosmics,
SuppressTrackFit = True,
ForceRefit = False,
diff --git a/InnerDetector/InDetExample/InDetRecExample/share/InDetRec_jobOptions.py b/InnerDetector/InDetExample/InDetRecExample/share/InDetRec_jobOptions.py
index 61f18672cc63661cf16f08f2f92b1e9cf0706cd5..9438c8a3565a4d9bb00dc2acdebf42ecbe692f4f 100755
--- a/InnerDetector/InDetExample/InDetRecExample/share/InDetRec_jobOptions.py
+++ b/InnerDetector/InDetExample/InDetRecExample/share/InDetRec_jobOptions.py
@@ -309,17 +309,17 @@ else:
from InDetTrackPRD_Association.InDetTrackPRD_AssociationConf import InDet__InDetTrackPRD_Association
InDetTRTonly_PRD_AssociationPhase = InDet__InDetTrackPRD_Association(name = 'InDetTRTonly_PRD_AssociationPhase',
AssociationTool = InDetPrdAssociationTool,
- TracksName = copy.copy(TrackCollectionKeys))
+ TracksName = copy.copy(TrackCollectionKeys))
topSequence += InDetTRTonly_PRD_AssociationPhase
if (InDetFlags.doPrintConfigurables()):
print InDetTRTonly_PRD_AssociationPhase
-
+ from AthenaCommon import CfgGetter
from TRT_SegmentsToTrack.TRT_SegmentsToTrackConf import InDet__TRT_SegmentsToTrack
InDetTrkSegmenttoTrkPhase = InDet__TRT_SegmentsToTrack(name = "InDetTRT_SegmentsToTrack_BarrelPhase",
InputSegmentsCollection = InDetKeys.TRT_Segments_Phase(),
OutputTrackCollection = InDetKeys.TRT_Tracks_Phase(),
- TrackFitter = InDetTrackFitter,
+ TrackFitter = CfgGetter.getPublicTool('InDetTrackFitter'),
MinNHit = InDetNewTrackingCuts.minTRTonly(),
CombineTracks = False,
OutputCombiCollection = "",
@@ -765,9 +765,10 @@ else:
if DetFlags.haveRIO.pixel_on():
PixelClusterOnTrackTool = PixelClusterOnTrackToolDBM
if InDetFlags.loadFitter():
- InDetTrackFitter = InDetTrackFitterDBM
- if InDetFlags.doPattern():
- InDetSiComTrackFinder = InDetSiComTrackFinderDBM
+ from AthenaCommon import CfgGetter
+ InDetTrackFitter = CfgGetter.getPublicTool('InDetTrackFitterDBM')
+ # if InDetFlags.doPattern():
+ # InDetSiComTrackFinder = InDetSiComTrackFinderDBM
# InDetSiTrackerSpacePointFinder = InDetSiTrackerSpacePointFinderDBM
@@ -792,10 +793,10 @@ else:
InputCosmicsCombinedAmbiSolver = list(InputCombinedInDetTracks)
from TrkAmbiguitySolver.TrkAmbiguitySolverConf import Trk__TrkAmbiguityScore
- InDetAmbiguityScore_combinedCosmics = Trk__TrkAmbiguityScore(name = 'InDetCombinedCosmicsAmbiguityScore',
- TrackInput = InputCosmicsCombinedAmbiSolver,
- TrackOutput = 'ScoredMapCosmics')#,
- #AmbiguityScoreProcessor = InDetAmbiguityScoreProcessor )
+ InDetAmbiguityScore_combinedCosmics = Trk__TrkAmbiguityScore(name = 'InDetCombinedCosmicsAmbiguityScore',
+ TrackInput = InputCosmicsCombinedAmbiSolver,
+ TrackOutput = 'ScoredMapCosmics',
+ AmbiguityScoreProcessor = '' )
topSequence += InDetAmbiguityScore_combinedCosmics
@@ -849,9 +850,11 @@ else:
ToolSvc += InDetPRD_Provider
# --- the truth track builder
+ from AthenaCommon import CfgGetter
from TrkTruthTrackTools.TrkTruthTrackToolsConf import Trk__TruthTrackBuilder
+ # @TODO should a track fitter be used which does not require a split cluster map ?
InDetTruthTrackBuilder = Trk__TruthTrackBuilder(name = 'InDetTruthTrackBuilder',
- TrackFitter = InDetTrackFitter,
+ TrackFitter = CfgGetter.getPublicTool('InDetTrackFitter'),
ExtrapolationTool = InDetExtrapolator,
RotCreatorTool = InDetRotCreator,
BroadRotCreatorTool = BroadInDetRotCreator,
@@ -1079,16 +1082,19 @@ else:
# ----------------------------------------------------------------
if InDetFlags.doRefit():
from TrkRefitAlg.TrkRefitAlgConf import Trk__ReFitTrack
+ from AthenaCommon import CfgGetter
+ # @TODO for the track refit can a track fitter be used which requires a split cluster map ?
+ # Should the scoring+split cluster map building be executed ?
InDetReFitTrack = Trk__ReFitTrack (name = "InDetRefitTrack",
- FitterTool = InDetTrackFitter,
- FitterToolTRT = InDetTrackFitterTRT,
+ FitterTool = CfgGetter.getPublicTool('InDetTrackFitter'),
+ FitterToolTRT = CfgGetter.getPublicTool('InDetTrackFitterTRT'),
SummaryTool = InDetTrackSummaryToolSharedHits,
AssoTool = InDetPrdAssociationTool,
TrackName = InputTrackCollection,
NewTrackName = InDetKeys.RefittedTracks(),
fitRIO_OnTrack = InDetFlags.refitROT(),
useParticleHypothesisFromTrack = True)
-
+
if InDetFlags.materialInteractions():
InDetReFitTrack.matEffects = InDetFlags.materialInteractionsType()
else:
diff --git a/InnerDetector/InDetExample/InDetTrigRecExample/python/InDetTrigConfigRecLoadTools.py b/InnerDetector/InDetExample/InDetTrigRecExample/python/InDetTrigConfigRecLoadTools.py
index 94988a83948e06ea8087003f6be50eeab40a5c07..bf446a74346cbd538392aed7eef6fa1a1f2a1a63 100755
--- a/InnerDetector/InDetExample/InDetTrigRecExample/python/InDetTrigConfigRecLoadTools.py
+++ b/InnerDetector/InDetExample/InDetTrigRecExample/python/InDetTrigConfigRecLoadTools.py
@@ -192,12 +192,12 @@ if InDetTrigFlags.loadRotCreator():
#
if InDetTrigFlags.redoTRT_LR():
- from InDetRecExample.TrackingCommon import getTRT_DriftCircleOnTrackTool
+ from InDetRecExample.TrackingCommon import getInDetTRT_DriftCircleOnTrackTool
from TRT_DriftCircleOnTrackTool.TRT_DriftCircleOnTrackToolConf import \
InDet__TRT_DriftCircleOnTrackUniversalTool
InDetTrigTRT_RefitRotCreator = \
InDet__TRT_DriftCircleOnTrackUniversalTool(name = 'InDetTrigTRT_RefitRotCreator',
- RIOonTrackToolDrift = getTRT_DriftCircleOnTrackTool(), # special settings for trigger needed ?
+ RIOonTrackToolDrift = getInDetTRT_DriftCircleOnTrackTool(), # special settings for trigger needed ?
ScaleHitUncertainty = 2.5) # fix from Thijs
# if InDetTrigFlags.doCommissioning(): #introduced for cosmics do not use for collisions
# InDetTrigTRT_RefitRotCreator.ScaleHitUncertainty = 5.