Beispiel #1
0
def configureExtrapolator(egammaExtrapolator):

    # this turns off dynamic calculation of eloss in calorimeters
    egammaExtrapolator.DoCaloDynamic = False

    # all left to MaterialEffects/EnergyLossUpdators
    from TrkExTools.TrkExToolsConf import (Trk__MaterialEffectsUpdator as
                                           MaterialEffectsUpdator)

    egammaMaterialEffectsUpdator = MaterialEffectsUpdator(
        name='egammaMaterialEffectsUpdator')
    egammaNoElossMaterialEffectsUpdator = MaterialEffectsUpdator(
        name='egammaNoElossMaterialEffectsUpdator')
    egammaNoElossMaterialEffectsUpdator.EnergyLoss = False

    MyUpdators = []
    MyUpdators += [egammaMaterialEffectsUpdator]
    MyUpdators += [egammaNoElossMaterialEffectsUpdator]

    MySubUpdators = []
    MySubUpdators += [egammaMaterialEffectsUpdator.name()]  # for Global
    MySubUpdators += [egammaMaterialEffectsUpdator.name()]  # for ID
    MySubUpdators += [egammaMaterialEffectsUpdator.name()]  # for BeamPipe
    MySubUpdators += [egammaNoElossMaterialEffectsUpdator.name()]  # for Calo
    # for muon spectrometer
    MySubUpdators += [egammaNoElossMaterialEffectsUpdator.name()]
    MySubUpdators += [egammaMaterialEffectsUpdator.name()]  # for cavern

    # egamma RungeKutta Propagator
    from TrkExRungeKuttaPropagator.TrkExRungeKuttaPropagatorConf import (
        Trk__RungeKuttaPropagator as RkPropagator)
    egammaRungeKuttaPropagator = RkPropagator(
        name='egammaRungeKuttaPropagator')

    # egamma STEP_Propagator with no material effects
    from TrkExSTEP_Propagator.TrkExSTEP_PropagatorConf import (
        Trk__STEP_Propagator as STEP_Propagator)
    egammaNoMatSTEP_Propagator = STEP_Propagator(
        name='egammaNoMatSTEP_Propagator')
    egammaNoMatSTEP_Propagator.MaterialEffects = False

    myPropagators = []
    myPropagators += [egammaRungeKuttaPropagator]
    myPropagators += [egammaNoMatSTEP_Propagator]

    MySubPropagators = []
    MySubPropagators += [egammaRungeKuttaPropagator.name()]  # for Global
    MySubPropagators += [egammaRungeKuttaPropagator.name()]  # for ID
    MySubPropagators += [egammaRungeKuttaPropagator.name()]  # for BeamPipe
    MySubPropagators += [egammaRungeKuttaPropagator.name()]  # for Calo
    MySubPropagators += [egammaNoMatSTEP_Propagator.name()]  # for MS
    MySubPropagators += [egammaRungeKuttaPropagator.name()]  # for cavern

    egammaExtrapolator.MaterialEffectsUpdators = MyUpdators
    egammaExtrapolator.SubMEUpdators = MySubUpdators
    egammaExtrapolator.Propagators = myPropagators
    egammaExtrapolator.SubPropagators = MySubPropagators
    # egamma STEP with no eloss for calo intersections
    egammaExtrapolator.STEP_Propagator = egammaNoMatSTEP_Propagator
Beispiel #2
0
def getGSFTrackFitter():
    egRotCreator = TrackingCommon.getInDetRotCreator(name='egRotCreator',
                                                     private=True)

    TrackingCommon.createAndAddCondAlg(
        TrackingCommon.getRIO_OnTrackErrorScalingCondAlg,
        'RIO_OnTrackErrorScalingCondAlg')

    # get Rk propagator
    from TrkExRungeKuttaPropagator.TrkExRungeKuttaPropagatorConf import (
        Trk__RungeKuttaPropagator as Propagator)

    egTrkPropagator = Propagator(name='egTrkPropagator')
    egTrkPropagator.AccuracyParameter = 0.0001

    # Setup the Navigator (default)
    from TrkDetDescrSvc.AtlasTrackingGeometrySvc import (
        AtlasTrackingGeometrySvc)

    from TrkExTools.TrkExToolsConf import Trk__Navigator
    egTrkNavigator = Trk__Navigator(
        name='egTrkNavigator', TrackingGeometrySvc=AtlasTrackingGeometrySvc)

    # Set up the GSF
    from TrkGaussianSumFilter.TrkGaussianSumFilterConf import (
        Trk__GsfMaterialMixtureConvolution)

    GsfMaterialUpdator = Trk__GsfMaterialMixtureConvolution(
        name='GsfMaterialUpdator', MaximumNumberOfComponents=12)

    from TrkGaussianSumFilter.TrkGaussianSumFilterConf import (
        Trk__GsfExtrapolator)

    GsfExtrapolator = Trk__GsfExtrapolator(
        name='GsfExtrapolator',
        Propagators=[egTrkPropagator],
        SearchLevelClosestParameters=10,
        StickyConfiguration=True,
        Navigator=egTrkNavigator,
        GsfMaterialConvolution=GsfMaterialUpdator,
        SurfaceBasedMaterialEffects=False)

    from TrkGaussianSumFilter.TrkGaussianSumFilterConf import (
        Trk__GaussianSumFitter)

    GSFTrackFitter = Trk__GaussianSumFitter(
        name='GSFTrackFitter',
        ToolForExtrapolation=GsfExtrapolator,
        ReintegrateOutliers=True,
        MakePerigee=True,
        RefitOnMeasurementBase=True,
        DoHitSorting=True,
        ToolForROTCreation=egRotCreator)
    # --- end of fitter loading
    return GSFTrackFitter
Beispiel #3
0
def TMEF_MuonCombinedPropagator(name='TMEF_MuonCombinedPropagator', **kwargs):
    kwargs.setdefault('AccuracyParameter', 0.000001)
    kwargs.setdefault('IncludeBgradients', True)
    kwargs.setdefault('MaxStraightLineStep', 0.001)
    kwargs.setdefault('MaxHelixStep', 0.001)
    from TrkExRungeKuttaPropagator.TrkExRungeKuttaPropagatorConf import Trk__RungeKuttaPropagator
    return Trk__RungeKuttaPropagator(name, **kwargs)
Beispiel #4
0
    def __init__(self, name = 'ConfiguredTrigL2_Extrapolator') :
        Trk__Extrapolator.__init__(self, name)
        from AthenaCommon.AppMgr import ToolSvc
        from TrkDetDescrSvc.AtlasTrackingGeometrySvc import AtlasTrackingGeometrySvc

        from IOVDbSvc.CondDB import conddb
        if not (conddb.folderRequested( "/Indet/TrkErrorScaling" ) or conddb.folderRequested( "/Indet/Onl/TrkErrorScaling" )):
            conddb.addFolderSplitOnline("INDET", "/Indet/Onl/TrkErrorScaling", "/Indet/TrkErrorScaling" )
        
        from TrkExSTEP_Propagator.TrkExSTEP_PropagatorConf import Trk__STEP_Propagator
        TrigL2_StepPropagator = Trk__STEP_Propagator(name = 'TrigL2_StepPropagator')
        ToolSvc += TrigL2_StepPropagator
        from TrkExRungeKuttaPropagator.TrkExRungeKuttaPropagatorConf import Trk__RungeKuttaPropagator
        TrigL2_RKPropagator = Trk__RungeKuttaPropagator(name = 'TrigL2_RKPropagator')
        ToolSvc += TrigL2_RKPropagator
        from InDetTrigRecExample.InDetTrigFlags import InDetTrigFlags
        if InDetTrigFlags.propagatorType() is "STEP":
            TrigL2_Propagator = TrigL2_StepPropagator
        else:
            TrigL2_Propagator = TrigL2_RKPropagator
        
        from AthenaCommon.AppMgr import ServiceMgr as svcMgr
        AtlasTrackingGeometrySvc  = svcMgr.AtlasTrackingGeometrySvc
        from TrkExTools.TrkExToolsConf import Trk__Navigator
        TrigL2_Navigator = Trk__Navigator(name = 'TrigL2_Navigator',TrackingGeometrySvc = AtlasTrackingGeometrySvc)
        ToolSvc += TrigL2_Navigator
        from TrkExTools.TrkExToolsConf import Trk__MaterialEffectsUpdator
        TrigL2_MaterialUpdator = Trk__MaterialEffectsUpdator(name = "TrigL2_MaterialEffectsUpdator")
        ToolSvc += TrigL2_MaterialUpdator
        TrigL2_SubPropagators = []
        TrigL2_SubUpdators = []
        TrigL2_SubPropagators += [ TrigL2_Propagator.name() ]
        TrigL2_SubUpdators    += [ TrigL2_MaterialUpdator.name() ]
        TrigL2_SubPropagators += [ TrigL2_Propagator.name() ]
        TrigL2_SubUpdators    += [ TrigL2_MaterialUpdator.name() ]
        TrigL2_SubPropagators += [ TrigL2_StepPropagator.name() ]
        TrigL2_SubUpdators    += [ TrigL2_MaterialUpdator.name() ]
        self.Propagators             = [ TrigL2_RKPropagator, TrigL2_StepPropagator]
        self.MaterialEffectsUpdators = [ TrigL2_MaterialUpdator ]
        self.Navigator               = TrigL2_Navigator
        self.SubPropagators          = TrigL2_SubPropagators
        self.SubMEUpdators           = TrigL2_SubUpdators
Beispiel #5
0
#
#
# Extrapolator to be used for tracking inside egamma i.e GSF , conversions
# Set up AtlasExtrapolator
if not hasattr(ToolSvc, 'AtlasExtrapolator'):
    from TrkExTools.AtlasExtrapolator import AtlasExtrapolator
    ToolSvc += AtlasExtrapolator()

from AthenaCommon.AppMgr import ServiceMgr as svcMgr

AtlasTrackingGeometrySvc = svcMgr.AtlasTrackingGeometrySvc
# get propagator
from TrkExRungeKuttaPropagator.TrkExRungeKuttaPropagatorConf import Trk__RungeKuttaPropagator as Propagator
#
egTrkPropagator = Propagator(name='egTrkPropagator')
egTrkPropagator.AccuracyParameter = 0.0001
ToolSvc += egTrkPropagator
#
from TrkExSTEP_Propagator.TrkExSTEP_PropagatorConf import Trk__STEP_Propagator as StepPropagator

egTrkStepPropagator = StepPropagator(name='egTrkStepPropagator')
ToolSvc += egTrkStepPropagator
# Setup the Navigator (default)
from TrkExTools.TrkExToolsConf import Trk__Navigator

egTrkNavigator = Trk__Navigator(name='egTrkNavigator')
ToolSvc += egTrkNavigator
# Setup the MaterialEffectsUpdator
from TrkExTools.TrkExToolsConf import Trk__MaterialEffectsUpdator
Beispiel #6
0
# declare the extrapolator
#
from TrkMagFieldTools.TrkMagFieldToolsConf import Trk__MagneticFieldTool
ElectronTrkMagField = Trk__MagneticFieldTool('ElectronTrkMagField')
ToolSvc += ElectronTrkMagField
#
# set up geometry
#
include('TrkDetDescrSvc/AtlasTrackingGeometrySvc.py')
from __main__ import AtlasTrackingGeometrySvc
#
# get propagator
#
from TrkExRungeKuttaPropagator.TrkExRungeKuttaPropagatorConf import Trk__RungeKuttaPropagator as Propagator
#
ElectronTrkPropagator = Propagator(name='ElectronTrkPropagator')
ElectronTrkPropagator.AccuracyParameter = 0.0001
ToolSvc += ElectronTrkPropagator

from TrkExSTEP_Propagator.TrkExSTEP_PropagatorConf import Trk__STEP_Propagator as StepPropagator
ElectronTrkStepPropagator = StepPropagator(name='ElectronTrkStepPropagator')
ToolSvc += ElectronTrkStepPropagator
#
# Setup the Navigator (default, could be removed)
#
from TrkExTools.TrkExToolsConf import Trk__Navigator
ElectronTrkNavigator = Trk__Navigator(
    name='ElectronTrkNavigator',
    #TrackingGeometrySvc = AtlasTrackingGeometrySvc
)
ToolSvc += ElectronTrkNavigator
Beispiel #7
0
) + '.C'
ToolSvc += TrackingVolumeDisplayer

# PROPAGATOR DEFAULTS --------------------------------------------------------------------------------------

TestEnergyLossUpdator = []
from TrkExTools.TrkExToolsConf import Trk__EnergyLossUpdator
AtlasEnergyLossUpdator = Trk__EnergyLossUpdator(name="AtlasEnergyLossUpdator")
ToolSvc += AtlasEnergyLossUpdator
ToolSvc.AtlasEnergyLossUpdator.DetailedEloss = True
TestEnergyLossUpdator += [AtlasEnergyLossUpdator]

TestPropagators = []

from TrkExRungeKuttaPropagator.TrkExRungeKuttaPropagatorConf import Trk__RungeKuttaPropagator as Propagator
TestPropagator = Propagator(name='TestPropagator')
ToolSvc += TestPropagator

TestPropagators += [TestPropagator]

from TrkExSTEP_Propagator.TrkExSTEP_PropagatorConf import Trk__STEP_Propagator as STEP_Propagator
TestSTEP_Propagator = STEP_Propagator(name='TestSTEP_Propagator')
ToolSvc += TestSTEP_Propagator
TestSTEP_Propagator.DetailedEloss = True

TestPropagators += [TestSTEP_Propagator]

# UPDATOR DEFAULTS -----------------------------------------------------------------------------------------

TestUpdators = []
Beispiel #8
0
###############################################################################
if not 'doMEOTP' in dir():
    doMEOTP = False

### Setup extrapolator ###
if (doMEOTP):
    ### Configure Material Effects On Track Provider (usually this is not done) ###
    include(
        'CaloMaterialEffectsOnTrackProvider/CaloMaterialEffectsOnTrackProvider.py'
    )
    from TrkExTools.TrkExToolsConf import Trk__MaterialEffectsUpdator
    CaloTrkMuId_MaterialUpdator = Trk__MaterialEffectsUpdator()
    ToolSvc += CaloTrkMuId_MaterialUpdator

    from TrkExRungeKuttaPropagator.TrkExRungeKuttaPropagatorConf import Trk__RungeKuttaPropagator
    CaloTrkMuId_Propagator = Trk__RungeKuttaPropagator()
    ToolSvc += CaloTrkMuId_Propagator

    from TrkExTools.AtlasExtrapolator import AtlasExtrapolator
    CaloTrkMuIdTools_Extrapolator = AtlasExtrapolator(
        name='CaloTrkMuIdTools_Extrapolator')
    CaloTrkMuIdTools_Extrapolator.DoCaloDynamic = True
    CaloTrkMuIdTools_Extrapolator.Propagators = [CaloTrkMuIdTools_Propagator]
    CaloTrkMuIdTools_Extrapolator.MaterialEffectsUpdator = CaloTrkMuIdTools_MaterialUpdator

else:
    ### Use the public AtlasExtrapolator ###
    from TrkExTools.AtlasExtrapolator import AtlasExtrapolator
    CaloTrkMuIdTools_Extrapolator = AtlasExtrapolator()

ToolSvc += CaloTrkMuIdTools_Extrapolator
Beispiel #9
0
# job option fragment to enable InDetAlignNt for combined testbeam geometry
# in framework of RecExTB
# enables alignment ntuple production for InDetTB_Tracks (produced by
# straightline fitter)
#
theApp.Dlls += ["InDetAlignGenAlgs", "InDetAlignGenTools"]
theApp.TopAlg += ["InDetAlignNt"]
InDetAlignNt = Algorithm("InDetAlignNt")
InDetAlignNt.ReadAl = TRUE
InDetAlignNt.TRT = 1
InDetAlignNt.layout = 11
InDetAlignNt.truth = FALSE
InDetAlignNt.newtrk = True
InDetAlignNt.newtrkcol = "InDetTB_Tracks"

# setup extrapolator/propagator instance
from TrkExRungeKuttaPropagator.TrkExRungeKuttaPropagatorConf import Trk__RungeKuttaPropagator as Propagator
InDetAlignNtPropag = Propagator(name='InDetAlignNtPropag')
ToolSvc += InDetAlignNtPropag
from TrkExTools.TrkExToolsConf import Trk__Extrapolator
InDetAlignNtExtrap = Trk__Extrapolator(
    name='InDetAlignNtExtrap',
    Propagators=[InDetAlignNtPropag.getType()],
    PropagatorInstances=[InDetAlignNtPropag.getName()])
ToolSvc += InDetAlignNtExtrap
InDetAlignNt.Extrapolator = InDetAlignNtExtrap
Beispiel #10
0
    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
                                   )
Beispiel #11
0
    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
Beispiel #12
0
print '* [ Configuration : end   ] *** AtlasTrackingGeometry ********************************'

# the navigator Configurable way
from TrkExTools.TrkExToolsConf import Trk__Navigator
CombinedNavigator = Trk__Navigator( name = 'CombinedNavigator',
                                    TrackingGeometrySvc = AtlasTrackingGeometrySvc )
ToolSvc += CombinedNavigator
print      CombinedNavigator


# PROPAGATOR DEFAULTS --------------------------------------------------------------------------------------

AtlasPropagators  = []

from TrkExRungeKuttaPropagator.TrkExRungeKuttaPropagatorConf import Trk__RungeKuttaPropagator as RkPropagator
AtlasRungeKuttaPropagator = RkPropagator(name = 'AtlasRungeKuttaPropagator')
ToolSvc += AtlasRungeKuttaPropagator

AtlasPropagators += [AtlasRungeKuttaPropagator]

from TrkExSTEP_Propagator.TrkExSTEP_PropagatorConf import Trk__STEP_Propagator as STEP_Propagator
AtlasSTEP_Propagator = STEP_Propagator(name = 'AtlasSTEP_Propagator')
ToolSvc += AtlasSTEP_Propagator

AtlasPropagators += [AtlasSTEP_Propagator]

# UPDATOR DEFAULTS -----------------------------------------------------------------------------------------       

AtlasUpdators    = []

from TrkExTools.TrkExToolsConf import Trk__MaterialEffectsUpdator as MaterialEffectsUpdator
Beispiel #13
0
ScaleHitUncertainty = 2.5
InDetRefitRotCreator = InDetRotCreator

from TrkMeasurementUpdator.TrkMeasurementUpdatorConf import Trk__KalmanUpdator
InDetUpdator = Trk__KalmanUpdator(name='InDetUpdator')
InDetUpdator.OutputLevel = OutputLevel
ToolSvc += InDetUpdator
print InDetUpdator

#
# get propagator
#

from TrkExRungeKuttaPropagator.TrkExRungeKuttaPropagatorConf import Trk__RungeKuttaPropagator as Propagator

InDetPropagator = Propagator(name='InDetPropagator')

ToolSvc += InDetPropagator
print InDetPropagator

#
# Setup the Navigator (default, could be removed)
#

from TrkExTools.TrkExToolsConf import Trk__Navigator
InDetNavigator = Trk__Navigator(name='InDetNavigator',
                                TrackingGeometrySvc=AtlasTrackingGeometrySvc)
ToolSvc += InDetNavigator
print InDetNavigator

#