def ConfiguredPatSeeding(name
                         , OutputTracksName
                         , VetoTrackLocations = None):
    if name == None:
        log.fatal( '##################################################################################')
        log.fatal( '## FATAL You did not specify the name of the PatSeeding instance.' )
        log.fatal( '## FATAL I will now die, you need to make Hlt2Tracking aware of the name!  ')
        log.fatal( '##################################################################################')
    from Configurables import PatSeeding
    from Configurables import PatSeedingTool
    recoSeeding = PatSeeding(name, OutputTracksName = OutputTracksName )
    recoSeeding.addTool(PatSeedingTool, name="PatSeedingTool")
    # New tool
    if VetoTrackLocations != None and  len(VetoTrackLocations) != 0:
        from Configurables import TrackUsedLHCbID
        recoSeeding.PatSeedingTool.UsedLHCbIDToolName = "TrackUsedLHCbID"
        recoSeeding.PatSeedingTool.addTool( TrackUsedLHCbID, name="TrackUsedLHCbID" )
        recoSeeding.PatSeedingTool.TrackUsedLHCbID.inputContainers = VetoTrackLocations

    from Configurables import HltRecoConf
    from HltRecoConf import OnlineSeedingToolOptions, OfflineSeedingToolOptions
    if HltRecoConf().getProp("OfflineSeeding"):
        recoSeeding.PatSeedingTool.NDblOTHitsInXSearch = OfflineSeedingToolOptions ["NDblOTHitsInXSearch"]
        recoSeeding.PatSeedingTool.MinMomentum = OfflineSeedingToolOptions["MinMomentum"]
    else:
        recoSeeding.PatSeedingTool.NDblOTHitsInXSearch = OnlineSeedingToolOptions ["NDblOTHitsInXSearch"]
        recoSeeding.PatSeedingTool.MinMomentum = OnlineSeedingToolOptions["MinMomentum"]
    from Configurables import HltRecoConf
    from HltTracking.HltRecoConf import CommonForwardOptions
    recoSeeding.PatSeedingTool.MaxOTHits = HltRecoConf().getProp("Forward_MaxOTHits")
    recoSeeding.PatSeedingTool.MaxITHits = CommonForwardOptions["MaxITHits"]
    return recoSeeding
示例#2
0
def Hlt1GECStreamer(gec='Loose', accept=True):
    from Configurables import HltRecoConf
    gecs = {
        'Tight': {
            'MaxOTHits': HltRecoConf().getProp("Forward_MaxOTHits"),
            'MaxITHits': 3000,
            'MaxVeloHits': 3000,
            'IsActivity': False
        },
        'Loose': {
            'MaxOTHits': HltRecoConf().getProp("Forward_MaxOTHits"),
            'MaxITHits': 3000,
            'MaxVeloHits': 6000,
            'IsActivity': False
        },
        'Activity': {
            'MinOTHits': 100,
            'MinITHits': 100,
            'MinVeloHits': 100,
            'IsActivity': True
        }
    }
    from Configurables import Hlt__GEC
    from HltLine.HltDecodeRaw import DecodeIT, DecodeVELO
    from HltLine.HltLine import bindMembers
    tool = Hlt__GEC("%sGECs" % gec, **gecs[gec])
    code = "ACCEPT( '%s' )" % tool.getFullName()
    if not accept: code = '~' + code
    bm = bindMembers(None, [DecodeIT, DecodeVELO])
    return "GEC%s%s  = ( execute( %s ) & %s ) " % ({
        True: 'Accept',
        False: 'Reject'
    }[accept], gec, [m.getFullName() for m in bm.members()], code)
def recoVelo(OutputTracksName=HltSharedTrackLoc["Velo"]):
    recoVelo = FastVeloTracking( 'FastVeloHlt', OutputTracksName = OutputTracksName)
    recoVelo.StatPrint = True
    extendVelo = HltRecoConf().getProp("BeamGasMode")
    if extendVelo:
        recoVelo.ZVertexMin = HltRecoConf().getProp("VeloTrackingZMin")
        recoVelo.ZVertexMax = HltRecoConf().getProp("VeloTrackingZMax")
    recoVelo.VetoObjects = [ OutputTracksName ]
    return recoVelo
def ConfigureFitter( fitter ):
    from TrackFitter.ConfiguredFitters import ConfiguredHltFitter, ConfiguredMasterFitter
    # configure the fitter
    if not HltRecoConf().getProp("MoreOfflineLikeFit"):
        ConfiguredHltFitter( fitter )
        fitter.NumberFitIterations = HltRecoConf().getProp("FitIterationsInHltFit")
    else:
        ConfiguredMasterFitter( fitter , SimplifiedGeometry = True, LiteClusters = True, MSRossiAndGreisen = HltRecoConf().getProp("NewMSinFit"))
    # Ignore Muon hits
    fitter.MeasProvider.IgnoreMuon = True
    return fitter
    def __hlt2FullDownstreamTracking(self):
        """
        Full Downstream track reconstruction and fitting for tracking efficiency lines
        """
        from Configurables import PatSeeding
        from Configurables import PatSeedingTool
        from HltLine.HltLine import bindMembers

        from Configurables import TrackEventFitter, TrackMasterFitter
        DownstreamFit = TrackEventFitter('DownstreamFitter')
        DownstreamFit.TracksInContainer = Hlt2TrackLoc[
            "Downstream"]  #use unfitted Downstream tracks out of Hlt2Tracking
        DownstreamFit.TracksOutContainer = Hlt2TrackEffLoc[
            "FullDownstream"]  #our outputlocation
        DownstreamFit.addTool(TrackMasterFitter, name='Fitter')
        from TrackFitter.ConfiguredFitters import ConfiguredHltFitter, ConfiguredMasterFitter
        DownstreamFitter = getattr(DownstreamFit, 'Fitter')
        from Configurables import HltRecoConf
        ConfiguredMasterFitter(DownstreamFitter,
                               SimplifiedGeometry=True,
                               LiteClusters=True,
                               MSRossiAndGreisen=HltRecoConf().getProp(
                                   "NewMSinFit"))  #on par with Hlt track fits
        DownstreamFitter.OutputLevel = 5

        # Build the bindMembers
        bm_name = self.getProp("Prefix") + "FullDownstreamTracking"
        bm_members = [DownstreamFit]
        bm_output = Hlt2TrackEffLoc["FullDownstream"]

        return bindMembers(bm_name, bm_members).setOutputSelection(bm_output)
def ConfiguredHltInitFitter( parent ):
    from Configurables import ( TrackEventFitter, TrackMasterFitter, TrackInitFit, TrackStateInitTool )
    if not HltRecoConf().getProp("InitFits"):
        parent.addTool( TrackMasterFitter, name="Fitter")
        fitter = parent.Fitter
    else:
        parent.addTool( TrackInitFit, name = "Fitter")
        parent.Fitter.Init = "TrackStateInitTool/StateInit"
        parent.Fitter.addTool(TrackStateInitTool, name="StateInit")
        parent.Fitter.StateInit.VeloFitterName = "FastVeloFitLHCbIDs"
        parent.Fitter.StateInit.UseFastMomentumEstimate = True
        parent.Fitter.StateInit.addTool(TrackMasterExtrapolator, "Extrapolator")
        parent.Fitter.StateInit.Extrapolator.MaterialLocator = "SimplifiedMaterialLocator"
        parent.Fitter.Fit = "TrackMasterFitter/Fitter"
        parent.Fitter.addTool(TrackMasterFitter, name="Fitter")
        fitter = parent.Fitter.Fitter
    ConfigureFitter( fitter )
    return fitter
def ConfiguredForwardComplement(name
                                , InputTracksName #= HltSharedTrackLoc["Velo"]
                                , OutputTracksName #= Hlt2TrackLoc["ForwardComp"]
                                , VetoSeedLocations #= [ HltSharedTrackLoc["ForwardHPT"] ]
                                , MinMomentum #= HltRecoConf().getProp("Forward_LPT_MinP")
                                , MinPt #= HltRecoConf().getProp("Forward_LPT_MinPt")
                                ):
    if name == None:
        log.fatal( '##################################################################################')
        log.fatal( '## FATAL You did not specify the name of the PatForward instance.' )
        log.fatal( '## FATAL I will now die, you need to make Hlt2Tracking aware of the name!  ')
        log.fatal( '##################################################################################')
    forward = PatForward( name
                          , InputTracksName  = InputTracksName
                          , OutputTracksName = OutputTracksName
                          )

    #Sascha Stahl: We should get rid of GECs in the pattern reco, do it centrally
    from HltRecoConf import CommonForwardOptions
    from Configurables import HltRecoConf
    forward.maxOTHits = HltRecoConf().getProp("Forward_MaxOTHits")
    forward.maxITHits = CommonForwardOptions["MaxITHits"]
    forward.MaxNVelo = CommonForwardOptions["MaxNVelo"]

    from HltRecoConf import CommonForwardTrackingOptions, ComplementForwardToolOptions
    opts = CommonForwardTrackingOptions.copy()
    opts.update(ComplementForwardToolOptions)
    opts.update({"MinMomentum" : MinMomentum
                 ,"MinPt" : MinPt })
    forward.addTool(PatForwardTool(**opts), name='PatForwardTool')

    from Configurables import TrackUsedLHCbID
    if VetoSeedLocations != None and  len(VetoSeedLocations) != 0:
        forward.PatForwardTool.addTool(TrackUsedLHCbID, name='TrackUsedLHCbID')
        forward.PatForwardTool.UsedLHCbIDToolName="TrackUsedLHCbID"
        forward.PatForwardTool.TrackUsedLHCbID.inputContainers= VetoSeedLocations
        forward.PatForwardTool.VeloVetoTracksNames =  VetoSeedLocations
    # make them a bit more verbose
    forward.StatPrint = True
    forward.PatForwardTool.StatPrint = True
    return forward
    def __hlt2VeloMuonTracking(self):
        """
        VeloMuon track reconstruction for Hlt2
        """
        #HltSharedTracking decides which Velo sequence is used
        from Configurables import Hlt2Conf, VeloMuonBuilder, StandaloneMuonRec, TrackMasterFitter
        from Configurables import MeasurementProviderT_MeasurementProviderTypes__VeloLiteR_, MeasurementProviderT_MeasurementProviderTypes__VeloLitePhi_
        from HltLine.HltLine import bindMembers

        # Define output location
        VeloMuonTracksOutputLocation = Hlt2TrackEffLoc["VeloMuon"]

        # Get Muon standalone track
        Hlt2StandaloneMuon = StandaloneMuonRec("Hlt2StandaloneMuon")
        Hlt2StandaloneMuon.OutputMuonTracksName = Hlt2TrackEffLoc[
            "StandaloneMuon"]

        #build VeloMuon track
        Hlt2VeloMuonBuild = VeloMuonBuilder('Hlt2VeloMuonBuild')
        Hlt2VeloMuonBuild.MuonLocation = Hlt2StandaloneMuon.OutputMuonTracksName
        Hlt2VeloMuonBuild.VeloLocation = HltSharedTrackLoc[
            "Velo"]  #Velo track location in Hlt
        Hlt2VeloMuonBuild.lhcbids = 4
        Hlt2VeloMuonBuild.OutputLocation = VeloMuonTracksOutputLocation
        Hlt2VeloMuonBuild.addTool(TrackMasterFitter)
        from TrackFitter.ConfiguredFitters import ConfiguredHltFitter, ConfiguredMasterFitter
        from Configurables import HltRecoConf
        ConfiguredMasterFitter(Hlt2VeloMuonBuild.TrackMasterFitter,
                               SimplifiedGeometry=True,
                               LiteClusters=True,
                               MSRossiAndGreisen=HltRecoConf().getProp(
                                   "NewMSinFit"))  #on par with Hlt track fits
        Hlt2VeloMuonBuild.TrackMasterFitter.OutputLevel = 5

        # Build the bindMembers
        bm_name = self.getProp("Prefix") + "VeloMuonTracking"
        bm_members = [Hlt2StandaloneMuon, Hlt2VeloMuonBuild]
        bm_output = VeloMuonTracksOutputLocation

        return bindMembers(bm_name, bm_members).setOutputSelection(bm_output)
def fittedVelo(inputTracks, outputTracks, name='VeloOnlyFitterAlg'):
    from Configurables import TrackEventFitter, TrackInitFit
    from Configurables import TrackStateInitTool, TrackMasterFitter
    if HltRecoConf().getProp("FastFitVelo"):
        # For now use the save option where Velo tracks are copied and the original ones are not changed
        from Configurables import TrackStateInitAlg, TrackStateInitTool,FastVeloFitLHCbIDs
        from Configurables import TrackContainerCopy
        copy = TrackContainerCopy(name+"CopyVelo")
        copy.inputLocations = [ inputTracks ]
        copy.outputLocation = outputTracks
        init = TrackStateInitAlg(name)
        init.TrackLocation = copy.outputLocation
        init.addTool(TrackStateInitTool, name="StateInitTool")
        init.StateInitTool.VeloFitterName = "FastVeloFitLHCbIDs"
        init.StateInitTool.addTool(TrackMasterExtrapolator, "Extrapolator")
        init.StateInitTool.Extrapolator.addTool(SimplifiedMaterialLocator,
                                                name = "MaterialLocator")
        init.StateInitTool.addTool(FastVeloFitLHCbIDs,name="FastVeloFitLHCbIDs")
        init.StateInitTool.FastVeloFitLHCbIDs.UseKalmanFit = True
        return [copy,init]
    else:
        fa = TrackEventFitter(name)
        fa.TracksInContainer = inputTracks
        fa.TracksOutContainer = outputTracks
        fa.Fitter = "TrackInitFit/Fit"
        fa.addTool(TrackInitFit, "Fit")
        fa.Fit.Init = "TrackStateInitTool/VeloOnlyStateInit"
        fa.Fit.addTool(TrackStateInitTool, "VeloOnlyStateInit")
        fa.Fit.VeloOnlyStateInit.VeloFitterName = "FastVeloFitLHCbIDs"
        fa.Fit.VeloOnlyStateInit.addTool(TrackMasterExtrapolator, "Extrapolator")
        fa.Fit.VeloOnlyStateInit.Extrapolator.addTool(SimplifiedMaterialLocator,
                                                      name = "MaterialLocator")
        fa.Fit.Fit = "TrackMasterFitter/Fit"
        fa.Fit.addTool(TrackMasterFitter, name = "Fit")
        from TrackFitter.ConfiguredFitters import ConfiguredForwardFitter
        fitter = ConfiguredForwardFitter(fa.Fit.Fit)
        return [ fa ]
示例#10
0
def PV3D(where):
    """ PV3D(where) -- where must either by Hlt1 or Hlt2 """
    #from HltTrackNames import HltSharedRZVeloTracksName, HltSharedTracksPrefix, _baseTrackLocation
    from HltVertexNames import HltSharedVerticesPrefix
    from HltVertexNames import HltGlobalVertexLocation

    from Configurables import PatPV3D
    from Configurables import PVOfflineTool, LSAdaptPV3DFitter
    from Configurables import SimplifiedMaterialLocator, TrackMasterExtrapolator

    if where.upper() not in ['HLT1', 'HLT2']:
        raise KeyError('PV3D: where must be either HLT1 or HLT2')

    #TODO: Move these options to HltRecoConf
    output3DVertices = _vertexLocation(HltSharedVerticesPrefix,
                                       HltGlobalVertexLocation, PV3DSelection)
    recoPV3D = PatPV3D('HltPVsPV3D')
    recoPV3D.addTool(PVOfflineTool, "PVOfflineTool")
    recoPV3D.PVOfflineTool.PVSeedingName = "PVSeed3DTool"
    recoPV3D.PVOfflineTool.PVFitterName = "LSAdaptPV3DFitter"
    recoPV3D.PVOfflineTool.addTool(LSAdaptPV3DFitter, "LSAdaptPV3DFitter")
    offlineTool = recoPV3D.PVOfflineTool
    fitter = recoPV3D.PVOfflineTool.LSAdaptPV3DFitter
    # Set options from HltRecoConf
    from Configurables import HltRecoConf
    for opt, value in HltRecoConf().getProp("PVOptions").iteritems():
        found = False
        for tool in (fitter, offlineTool):
            if opt in tool.getProperties():
                tool.setProp(opt, value)
                found = True
        if not found:
            raise AttributeError("HltPVs.py: no tool has property %s" % opt)

    ## Simplified Material for TrackMasterExtrapolator
    recoPV3D.PVOfflineTool.LSAdaptPV3DFitter.addTool(
        TrackMasterExtrapolator, "TrackMasterExtrapolator")
    recoPV3D.PVOfflineTool.LSAdaptPV3DFitter.TrackMasterExtrapolator.addTool(
        SimplifiedMaterialLocator, name="MaterialLocator")
    ## Simplified Material for Recalculate. Not used, but let's not load
    from Configurables import PVOfflineRecalculate
    recoPV3D.PVOfflineTool.addTool(PVOfflineRecalculate,
                                   "PVOfflineRecalculate")
    recoPV3D.PVOfflineTool.PVOfflineRecalculate.addTool(
        TrackMasterExtrapolator, "TrackMasterExtrapolator")
    recoPV3D.PVOfflineTool.PVOfflineRecalculate.TrackMasterExtrapolator.addTool(
        SimplifiedMaterialLocator, name="MaterialLocator")
    if HltRecoConf().getProp("FitVelo"):
        recoPV3D.PVOfflineTool.LSAdaptPV3DFitter.UseFittedTracks = True
    #recoPV3D.PVOfflineTool.LSAdaptPV3DFitter.zVtxShift = 0.0
    recoPV3D.OutputVerticesName = output3DVertices

    from HltSharedTracking import FittedVelo, RevivedVelo
    velo = FittedVelo if HltRecoConf().getProp("FitVelo") else RevivedVelo

    pv3dAlgos = ','.join(
        ["'%s'" % m.getFullName() for m in velo.members() + [recoPV3D]])
    recoPV3D.PVOfflineTool.InputTracks = [velo.outputSelection()]

    from Configurables import LoKi__HltUnit as HltUnit
    ## Hlt vertex beamspot filter
    ##-- todo: can we integrate this in the main streamers directly, using 'tee' ?
    ## TODO: Make this a configurable.
    name = "HltPV3D"
    makePV3DSel = HltUnit(name,
                          Preambulo=[
                              'from LoKiPhys.decorators import *',
                              'from LoKiTrigger.decorators import *',
                              'from LoKiHlt.algorithms import *'
                          ],
                          Code="""
        execute( %(algo)s ) * VSOURCE( '%(tesInput)s' )
        >> VX_SINK( '%(hltFinal)s' )
        >> ~VEMPTY
        """ % {
                              'algo': pv3dAlgos,
                              'tesInput': recoPV3D.OutputVerticesName,
                              'hltFinal': PV3DSelection
                          })

    pv3d = bindMembers(name + 'Sequence',
                       [makePV3DSel]).setOutputSelection(PV3DSelection)
    pv3d.output = output3DVertices
    return pv3d
def ConfiguredGoodTrackFilter (name,
                               InputLocation,
                               OutputLocation = None):
    if name == None:
        log.fatal( '##################################################################################')
        log.fatal( '## FATAL You did not specify the name of the Filter instance.' )
        log.fatal( '## FATAL I will now die, you need to make Hlt2Tracking aware of the name!  ')
        log.fatal( '##################################################################################')
    if OutputLocation == None: OutputLocation = InputLocation + "Filtered"
    from Configurables import TrackListRefiner
    filterTracks = TrackListRefiner( name,
                                     inputLocation = InputLocation,
                                     outputLocation = OutputLocation)
    from Configurables import  LoKi__Hybrid__TrackSelector as LoKiTrackSelector
    filterTracks.addTool(LoKiTrackSelector,name="LokiTracksSelector")
    filterTracks.Selector = LoKiTrackSelector(name="LokiTracksSelector")
    filterTracks.Selector.Code = "(~TrINVALID) & ( TrCHI2PDOF < %(TrChi2)s )" % {"TrChi2":  HltRecoConf().getProp("GoodTrCHI2PDOF")}
    filterTracks.Selector.StatPrint = True
    return filterTracks
from Configurables import HltRecoConf

## Simplified Material for public MasterExtrapolator and TrackStateProvider
ToolSvc().addTool(TrackMasterExtrapolator, "TrackMasterExtrapolator")
ToolSvc().TrackMasterExtrapolator.addTool(SimplifiedMaterialLocator, name="MaterialLocator")
ToolSvc().TrackMasterExtrapolator.MaterialLocator.addTool( StateThickMSCorrectionTool, name= "StateMSCorrectionTool" )
ToolSvc().addTool(TrackStateProvider, "TrackStateProvider")
ToolSvc().TrackStateProvider.addTool(TrackMasterExtrapolator,name="Extrapolator")
ToolSvc().TrackStateProvider.Extrapolator.addTool(SimplifiedMaterialLocator, name="MaterialLocator")
ToolSvc().TrackStateProvider.Extrapolator.MaterialLocator.addTool( StateThickMSCorrectionTool, name= "StateMSCorrectionTool" )
ToolSvc().TrackStateProvider.addTool(TrackInterpolator,"Interpolator")
ToolSvc().TrackStateProvider.Interpolator.addTool(TrackMasterExtrapolator,name="Extrapolator")
ToolSvc().TrackStateProvider.addTool(TrackInterpolator,"Interpolator")
ToolSvc().TrackStateProvider.Interpolator.Extrapolator.addTool(SimplifiedMaterialLocator, name="MaterialLocator")
ToolSvc().TrackStateProvider.Interpolator.Extrapolator.MaterialLocator.addTool( StateThickMSCorrectionTool, name= "StateMSCorrectionTool")
if HltRecoConf().getProp("NewMSinFit"):
    ToolSvc().TrackMasterExtrapolator.MaterialLocator.StateMSCorrectionTool.UseRossiAndGreisen = True
    ToolSvc().TrackStateProvider.Extrapolator.MaterialLocator.StateMSCorrectionTool.UseRossiAndGreisen = True
    ToolSvc().TrackStateProvider.Interpolator.Extrapolator.MaterialLocator.StateMSCorrectionTool.UseRossiAndGreisen = True
if HltRecoConf().getProp("CacheStatesInStateProvider"):
    ToolSvc().TrackStateProvider.CacheStatesOnDemand = True
else:
    ToolSvc().TrackStateProvider.CacheStatesOnDemand = False
    
#### Velo Tracking

# the full Velo reconstruction
def recoVelo(OutputTracksName=HltSharedTrackLoc["Velo"]):
    recoVelo = FastVeloTracking( 'FastVeloHlt', OutputTracksName = OutputTracksName)
    recoVelo.StatPrint = True
    extendVelo = HltRecoConf().getProp("BeamGasMode")
    def __hlt2MuonTTTracking(self):
        """
        MuonTT track reconstruction for Hlt2
        """
        from Configurables import Hlt2Conf
        from Configurables import MuonTTTrack, TrackMasterFitter, PatAddTTCoord, MuonCombRec, MuonHitDecode, TrackMasterExtrapolator
        from Configurables import MeasurementProviderT_MeasurementProviderTypes__TTLite_, StateThickMSCorrectionTool
        from HltLine.HltLine import bindMembers
        from Configurables import HltRecoConf
        from HltRecoConf import CommonForwardTrackingOptions, MuonTTOptions
        from HltTracking.HltPVs import PV3D
        #        from Hlt1Lines.HltConfigurePR import ConfiguredPR

        pvreco = PV3D('Hlt2')
        Hlt2MuonTTTrack = MuonTTTrack("Hlt2MuonTTTrack")
        Hlt2MuonTTTrack.AddTTHits = True
        Hlt2MuonTTTrack.FillMuonStubInfo = False
        Hlt2MuonTTTrack.ToolName = "MuonCombRec"
        Hlt2MuonTTTrack.OutputLevel = 6
        Hlt2MuonTTTrack.MC = False
        Hlt2MuonTTTrack.PVLocation = pvreco.output
        Hlt2MuonTTTrack.addTool(MuonCombRec)
        Hlt2MuonTTTrack.MuonCombRec.ClusterTool = "MuonFakeClustering"
        Hlt2MuonTTTrack.MuonCombRec.CloneKiller = False
        Hlt2MuonTTTrack.MuonCombRec.StrongCloneKiller = False
        Hlt2MuonTTTrack.MuonCombRec.SeedStation = MuonTTOptions["SeedStation"]
        Hlt2MuonTTTrack.MuonCombRec.DecodingTool = "MuonHitDecode"
        Hlt2MuonTTTrack.MuonCombRec.PadRecTool = "MuonPadRec"
        Hlt2MuonTTTrack.MuonCombRec.AssumePhysics = True
        Hlt2MuonTTTrack.MuonCombRec.MeasureTime = True
        Hlt2MuonTTTrack.MuonCombRec.addTool(MuonHitDecode("MuonHitDecode"))
        Hlt2MuonTTTrack.MuonCombRec.MuonHitDecode.SkipHWNumber = True
        Hlt2MuonTTTrack.addTool(PatAddTTCoord)
        Hlt2MuonTTTrack.PatAddTTCoord.YTolSlope = MuonTTOptions["YTolSlope"]
        Hlt2MuonTTTrack.PatAddTTCoord.XTol = MuonTTOptions["XTol"]
        Hlt2MuonTTTrack.PatAddTTCoord.XTolSlope = MuonTTOptions["XTolSlope"]
        Hlt2MuonTTTrack.PatAddTTCoord.MaxChi2Tol = MuonTTOptions["MaxChi2Tol"]
        Hlt2MuonTTTrack.PatAddTTCoord.MinAxProj = MuonTTOptions["MinAxProj"]
        Hlt2MuonTTTrack.PatAddTTCoord.MajAxProj = MuonTTOptions["MaxAxProj"]
        Hlt2MuonTTTrack.addTool(TrackMasterFitter)

        from TrackFitter.ConfiguredFitters import ConfiguredHltFitter, ConfiguredMasterFitter
        from Configurables import HltRecoConf, SimplifiedMaterialLocator
        ConfiguredMasterFitter(Hlt2MuonTTTrack.TrackMasterFitter,
                               SimplifiedGeometry=True,
                               LiteClusters=True,
                               MSRossiAndGreisen=HltRecoConf().getProp(
                                   "NewMSinFit"))  #on par with Hlt track fits
        Hlt2MuonTTTrack.TrackMasterFitter.OutputLevel = 5
        Hlt2MuonTTTrack.addTool(TrackMasterExtrapolator)
        Hlt2MuonTTTrack.TrackMasterExtrapolator.MaterialLocator = "SimplifiedMaterialLocator"
        Hlt2MuonTTTrack.addTool(TrackMasterExtrapolator)
        Hlt2MuonTTTrack.TrackMasterExtrapolator.addTool(
            SimplifiedMaterialLocator, name="MaterialLocator")

        materialLocator = Hlt2MuonTTTrack.TrackMasterExtrapolator.MaterialLocator
        materialLocator.addTool(StateThickMSCorrectionTool,
                                name="StateMSCorrectionTool")
        materialLocator.StateMSCorrectionTool.UseRossiAndGreisen = HltRecoConf(
        ).getProp("NewMSinFit")

        Hlt2MuonTTTrack.Output = Hlt2TrackEffLoc["MuonTT"]

        # Build the bindMembers
        bm_name = self.getProp("Prefix") + "MuonTTTracking"
        bm_members = [pvreco, Hlt2MuonTTTrack]
        bm_output = Hlt2MuonTTTrack.Output

        return bindMembers(bm_name, bm_members).setOutputSelection(bm_output)