Ejemplo n.º 1
0
    def __init__(self,
                 name="SiTrigTrackFinder_Electron_EF",
                 type="electron",
                 lowPt=False):
        super(InDet__SiTrigSPSeededTrackFinder, self).__init__(name)

        from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigPrdAssociationTool, \
            InDetTrigPatternPropagator, InDetTrigPatternUpdator, \
            InDetTrigRotCreator, InDetTrigPixelConditionsSummarySvc, InDetTrigSCTConditionsSummarySvc
        from AthenaCommon.AppMgr import ToolSvc

        # configure tools used

        # Space points seeds maker
        #
        from InDetTrigRecExample.InDetTrigSliceSettings import InDetTrigSliceSettings
        from AthenaCommon.DetFlags import DetFlags

        if type == "beamgas":
            from InDetTrigRecExample.InDetTrigConfigRecLoadToolsBeamGas import InDetTrigSiSpacePointsSeedMakerBeamGas
            InDetTrigSiSpacePointsSeedMaker = InDetTrigSiSpacePointsSeedMakerBeamGas

        elif type == "cosmicsN":
            from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_Cosmic

            InDetTrigSiSpacePointsSeedMaker = \
                InDet__SiSpacePointsSeedMaker_Cosmic(name                   = 'InDetTrigSiSpacePointsSeedMaker_'+type,
                                                     pTmin                  = InDetTrigSliceSettings[('pTmin',type)],
                                                     maxdImpact             = EFIDTrackingCutsCosmics.maxPrimaryImpact(),
                                                     maxZ                   = EFIDTrackingCutsCosmics.maxZImpact(),
                                                     minZ                   = -EFIDTrackingCutsCosmics.maxZImpact(),
                                                     SpacePointsPixelName   = 'SCT_CosmicsTrigSpacePoints',
                                                     SpacePointsSCTName     = 'PixelCosmicsTrigSpacePoints',
                                                     #SpacePointsOverlapName = InDetKeys.OverlapSpacePoints(),
                                                     UseAssociationTool     = False,
                                                     AssociationTool        =  InDetTrigPrdAssociationTool)
        elif lowPt:
            from InDetTrigRecExample.InDetTrigConfigRecLoadToolsLowPt import InDetTrigSiSpacePointsSeedMakerLowPt
            InDetTrigSiSpacePointsSeedMaker = InDetTrigSiSpacePointsSeedMakerLowPt

        elif type == "heavyIon" or type == "heavyIonFS":
            from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_HeavyIon
            InDetTrigSiSpacePointsSeedMaker = \
                InDet__SiSpacePointsSeedMaker_HeavyIon(name=                  'InDetTrigSiSpacePointsSeedMaker_'+type,
                                                     pTmin = InDetTrigSliceSettings[('pTmin',type)],
                                                     maxdImpact = EFIDTrackingCutsHeavyIon.maxPrimaryImpact(),
                                                     maxZ = EFIDTrackingCutsHeavyIon.maxZImpact(),
                                                     minZ = -EFIDTrackingCutsHeavyIon.maxZImpact(),
                                                     #useOverlapSpCollection   = False, #overlapCollections not used in EFID
                                                     useOverlapSpCollection   = InDetTrigFlags.doOverlapSP(), #testing
                                                     usePixel = DetFlags.haveRIO.pixel_on(),
                                                     useSCT   = DetFlags.haveRIO.SCT_on(),
                                                     SpacePointsSCTName = 'SCT_TrigSpacePoints',
                                                     SpacePointsPixelName = 'PixelTrigSpacePoints',
                                                     SpacePointsOverlapName = 'SPTrigOverlap',
                                                     radMax = EFIDTrackingCutsHeavyIon.radMax())

        else:
            from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_ATLxk
            InDetTrigSiSpacePointsSeedMaker = \
                InDet__SiSpacePointsSeedMaker_ATLxk( name = 'InDetTrigSiSpacePointsSeedMaker_'+type,
                                                     pTmin = InDetTrigSliceSettings[('pTmin',type)],
                                                     maxdImpact = InDetTrigCutValues.maxPrimaryImpact(),
                                                     maxZ = InDetTrigCutValues.maxZImpact(),
                                                     minZ = -InDetTrigCutValues.maxZImpact(),
                                                     #useOverlapSpCollection   = False, #overlapCollections not used in EFID
                                                     useOverlapSpCollection   = InDetTrigFlags.doOverlapSP(), #testing
                                                     usePixel = DetFlags.haveRIO.pixel_on(),
                                                     useSCT   = DetFlags.haveRIO.SCT_on(),
                                                     SpacePointsSCTName = 'SCT_TrigSpacePoints',
                                                     SpacePointsPixelName = 'PixelTrigSpacePoints',
                                                     SpacePointsOverlapName = 'SPTrigOverlap',
                                                     radMax = InDetTrigCutValues.radMax(),
                                                     maxdImpactPPS = InDetTrigCutValues.maxdImpactPPSSeeds(),
                                                     maxdImpactSSS = InDetTrigCutValues.maxdImpactSSSSeeds(),
                                                     )

        if type != "cosmicsN":
            InDetTrigSiSpacePointsSeedMaker.maxRadius1 = 0.75 * InDetTrigCutValues.radMax(
            )
            InDetTrigSiSpacePointsSeedMaker.maxRadius2 = InDetTrigCutValues.radMax(
            )
            InDetTrigSiSpacePointsSeedMaker.maxRadius3 = InDetTrigCutValues.radMax(
            )

        # if type=="minBias":
        #   InDetTrigSiSpacePointsSeedMaker.maxdImpact=5.

        ToolSvc += InDetTrigSiSpacePointsSeedMaker
        if (InDetTrigFlags.doPrintConfigurables()):
            print InDetTrigSiSpacePointsSeedMaker

        #InDetTrigSiSpacePointsSeedMaker.OutputLevel = 1

        # Z-coordinates primary vertices finder
        #

        from SiZvertexTool_xk.SiZvertexTool_xkConf import InDet__SiZvertexMaker_xk
        InDetTrigZvertexMaker = InDet__SiZvertexMaker_xk(
            name='InDetTrigZvertexMaker_' + type,
            Zmax=InDetTrigCutValues.maxZImpact(),
            Zmin=-InDetTrigCutValues.maxZImpact(),
            minRatio=0.17  # not default
        )
        if type == "heavyIon" or type == "heavyIonFS":
            InDetTrigZvertexMaker.HistSize = 2000
            InDetTrigZvertexMaker.minContent = 30

        #InDetTrigZvertexMaker.SeedMakerTool = InDet__SiSpacePointsSeedMaker_ATLxk('InDetTrigSiSpacePointsSeedMaker_'+type)#to make it tool neutral
        InDetTrigZvertexMaker.SeedMakerTool = ToolSvc.allConfigurables[
            'InDetTrigSiSpacePointsSeedMaker_' + type]
        ToolSvc += InDetTrigZvertexMaker

        #InDetTrigZvertexMaker.OutputLevel=1

        # SCT and Pixel detector elements road builder
        #
        from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigSiDetElementsRoadMaker, InDetTrigSiComTrackFinder

        # Local track finding using space point seed
        #
        from SiTrackMakerTool_xk.SiTrackMakerTool_xkConf import InDet__SiTrackMaker_xk
        InDetTrigSiTrackMaker = InDet__SiTrackMaker_xk(
            name='InDetTrigSiTrackMaker_' + type,
            RoadTool=InDetTrigSiDetElementsRoadMaker,
            CombinatorialTrackFinder=InDetTrigSiComTrackFinder,
            pTmin=InDetTrigSliceSettings[('pTmin', type)],
            nClustersMin=InDetTrigCutValues.minClusters(),
            nHolesMax=InDetTrigCutValues.nHolesMax(),
            nHolesGapMax=InDetTrigCutValues.nHolesGapMax(),
            SeedsFilterLevel=InDetTrigCutValues.seedFilterLevel(),
            Xi2max=InDetTrigCutValues.Xi2max(),
            Xi2maxNoAdd=InDetTrigCutValues.Xi2maxNoAdd(),
            nWeightedClustersMin=InDetTrigCutValues.nWeightedClustersMin(),
            #CosmicTrack              = InDetFlags.doCosmics(),
            Xi2maxMultiTracks=InDetTrigCutValues.Xi2max(),
            UseAssociationTool=False)

        if type == "beamgas":
            InDetTrigSiTrackMaker.pTmin = EFIDTrackingCutsBeamGas.minPT()
            InDetTrigSiTrackMaker.nClustersMin = EFIDTrackingCutsBeamGas.minClusters(
            )
            InDetTrigSiTrackMaker.nHolesMax = EFIDTrackingCutsBeamGas.nHolesMax(
            )
            InDetTrigSiTrackMaker.UseAssociationTool = True  #for BG and LowPt
        elif type == "cosmicsN":
            #create an additional for cosmics
            from InDetTrigRecExample.InDetTrigConfigRecLoadToolsCosmics import InDetTrigSiDetElementsRoadMakerCosmics
            InDetTrigSiTrackMaker.RoadTool = InDetTrigSiDetElementsRoadMakerCosmics
            InDetTrigSiTrackMaker.nClustersMin = EFIDTrackingCutsCosmics.minClusters(
            )
            InDetTrigSiTrackMaker.nHolesMax = EFIDTrackingCutsCosmics.nHolesMax(
            )  #3 vs 7
            InDetTrigSiTrackMaker.nHolesGapMax = EFIDTrackingCutsCosmics.nHolesGapMax(
            )  #3
            InDetTrigSiTrackMaker.CosmicTrack = True
            #InDetTrigSiTrackMaker.GoodSeedClusterCount = 3
        elif type == 'electron' and InDetTrigFlags.doBremRecovery():
            InDetTrigSiTrackMaker.useBremModel = True

        ToolSvc += InDetTrigSiTrackMaker

        if (InDetTrigFlags.doPrintConfigurables()):
            print InDetTrigSiTrackMaker

        self.SeedsTool = InDetTrigSiSpacePointsSeedMaker
        self.ZvertexTool = InDetTrigZvertexMaker
        self.useZvertexTool = InDetTrigFlags.useZvertexTool()
        if type == "beamgas" or type == "cosmicsN":
            self.ZvertexTool = None
            self.useZvertexTool = False
        elif type == "heavyIon" or type == "heavyIonFS":
            self.useZvertexTool = True

        if lowPt:
            from InDetTrigRecExample.InDetTrigConfigRecLoadToolsLowPt \
                import InDetTrigSiSpacePointsSeedMakerLowPt,InDetTrigSiTrackMakerLowPt, InDetTrigZvertexMakerLowPt
            self.TrackTool = InDetTrigSiTrackMakerLowPt
            self.SeedsTool = InDetTrigSiSpacePointsSeedMakerLowPt
            self.useZvertexTool = InDetTrigFlags.useZvertexTool()
            self.ZvertexTool = InDetTrigZvertexMakerLowPt

        else:
            #self.TrackTool = InDetTrigSiTrackMaker
            self.TrackTool = InDet__SiTrackMaker_xk('InDetTrigSiTrackMaker_' +
                                                    type)

        self.EtaHalfWidth = InDetTrigSliceSettings[('etaHalfWidth', type)]
        self.PhiHalfWidth = InDetTrigSliceSettings[('phiHalfWidth', type)]
        self.doFullScan = InDetTrigSliceSettings[('doFullScan', type)]

        #monitoring
        from SiTrigSPSeededTrackFinder.SiTrigSPSeededTrackFinderMonitoring import \
            SiTrigSPSeededTrackFinderValidationMonitor, \
            SiTrigSPSeededTrackFinderOnlineMonitor

        from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig

        sitrktime = TrigTimeHistToolConfig("SiTRKTime")
        sitrktime.TimerHistLimits = [0, 200]
        self.AthenaMonTools = [
            SiTrigSPSeededTrackFinderValidationMonitor(type=type),
            SiTrigSPSeededTrackFinderOnlineMonitor(type=type), sitrktime
        ]
Ejemplo n.º 2
0
    def __init__(self,
                 name="TrigAmbiguitySolver_Electron_EF",
                 type="electron",
                 lowPt=False):
        super(InDet__InDetTrigAmbiguitySolver, self).__init__(name)

        slice = type
        if name.find('FTK') > -1:
            slice = 'FTK'

        from AthenaCommon.AppMgr import ToolSvc
        from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigPrdAssociationTool, \
            InDetTrigTrackFitter, InDetTrigExtrapolator, InDetTrigTrackSummaryTool, \
            InDetTrigTRTDriftCircleCut

        # load InnerDetector TrackSelectionTool
        #

        from InDetTrigRecExample.InDetTrigSliceSettings import InDetTrigSliceSettings

        from InDetTrackScoringTools.InDetTrackScoringToolsConf import InDet__InDetAmbiScoringTool
        #ptint
        ptintcut = InDetTrigSliceSettings[('pTmin', slice)]
        if slice == 'minBias':
            ptintcut = 0.95 * InDetTrigSliceSettings[('pTmin', slice)]
        elif slice == 'minBias400':
            ptintcut = 0.95 * InDetTrigSliceSettings[('pTmin', slice)]

        InDetTrigScoringTool = InDet__InDetAmbiScoringTool(
            name='InDetTrigScoringTool_' + slice,
            Extrapolator=InDetTrigExtrapolator,
            SummaryTool=InDetTrigTrackSummaryTool,
            useAmbigFcn=True,  # this is NewTracking
            useTRT_AmbigFcn=False,
            #to have a steeper turn-n curve
            minPt=ptintcut,
            maxRPhiImp=InDetTrigCutValues.maxPrimaryImpact(),
            maxZImp=InDetTrigCutValues.maxZImpact(),
            maxEta=InDetTrigCutValues.maxEta(),
            minSiClusters=InDetTrigCutValues.minClusters(),
            maxSiHoles=InDetTrigCutValues.maxHoles(),
            maxPixelHoles=InDetTrigCutValues.maxPixelHoles(),
            maxSCTHoles=InDetTrigCutValues.maxSCTHoles(),
            maxDoubleHoles=InDetTrigCutValues.maxDoubleHoles(),
            usePixel=InDetTrigCutValues.usePixel(),
            useSCT=InDetTrigCutValues.useSCT(),
            minTRTonTrk=0,  # no TRT here
            DriftCircleCutTool=InDetTrigTRTDriftCircleCut,
            doEmCaloSeed=False,
            #BeamPositionSvc = default instance ,
        )

        if slice == 'beamgas':
            InDetTrigScoringTool.minPt = EFIDTrackingCutsBeamGas.minPT()
            InDetTrigScoringTool.maxRPhiImp = EFIDTrackingCutsBeamGas.maxPrimaryImpact(
            )
            InDetTrigScoringTool.maxZImp = EFIDTrackingCutsBeamGas.maxZImpact()
            InDetTrigScoringTool.minSiClusters = EFIDTrackingCutsBeamGas.minClusters(
            )
            InDetTrigScoringTool.maxSiHoles = EFIDTrackingCutsBeamGas.maxHoles(
            )
            InDetTrigScoringTool.useTRT_AmbigFcn = False
            InDetTrigScoringTool.useSigmaChi2 = True

        if slice == 'FTK' or slice == 'FTKRefit' or slice == 'FTKMon':
            InDetTrigScoringTool.minSiClusters = FTKTrackingCuts.minClusters()
            InDetTrigScoringTool.maxSiHoles = FTKTrackingCuts.maxHoles()
            InDetTrigScoringTool.maxPixelHoles = FTKTrackingCuts.maxPixelHoles(
            )
            InDetTrigScoringTool.maxSCTHoles = FTKTrackingCuts.maxSCTHoles()
            InDetTrigScoringTool.maxDoubleHoles = FTKTrackingCuts.maxDoubleHoles(
            )

        #
        ToolSvc += InDetTrigScoringTool
        if (InDetTrigFlags.doPrintConfigurables()):
            print InDetTrigScoringTool

        # load Ambiguity Processor
        from InDetTrigRecExample.InDetTrigConfigRecLoadTools import \
            InDetTrigAmbiTrackSelectionTool

        from TrkAmbiguityProcessor.TrkAmbiguityProcessorConf import Trk__SimpleAmbiguityProcessorTool

        InDetTrigAmbiguityProcessor = \
            Trk__SimpleAmbiguityProcessorTool(name = 'InDetTrigAmbiguityProcessor_'+slice,
                                              #AssoTool    = InDetTrigPrdAssociationTool,
                                              Fitter      = InDetTrigTrackFitter,
                                              SelectionTool = InDetTrigAmbiTrackSelectionTool,
                                              RefitPrds   = not InDetTrigFlags.refitROT()
                                              )

        InDetTrigAmbiguityProcessor.ScoringTool = InDet__InDetAmbiScoringTool(
            'InDetTrigScoringTool_' + slice)

        if slice == 'beamgas':
            from InDetTrigRecExample.InDetTrigConfigRecLoadToolsBeamGas import \
                InDetTrigAmbiTrackSelectionToolBeamGas
            InDetTrigAmbiguityProcessor.SelectionTool = InDetTrigAmbiTrackSelectionToolBeamGas

        elif slice == 'cosmicsN':
            from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigTrackFitterCosmics
            from InDetTrigRecExample.InDetTrigConfigRecLoadToolsCosmics \
                import InDetTrigScoringToolCosmics_SiPattern, InDetTrigAmbiTrackSelectionToolCosmicsN

            InDetTrigAmbiguityProcessor.Fitter = InDetTrigTrackFitterCosmics
            InDetTrigAmbiguityProcessor.SuppressHoleSearch = False
            InDetTrigAmbiguityProcessor.SelectionTool = InDetTrigAmbiTrackSelectionToolCosmicsN
            InDetTrigAmbiguityProcessor.ScoringTool = InDetTrigScoringToolCosmics_SiPattern
            #InDetTrigAmbiguityProcessor.SuppressTrackFit = True
            #InDetTrigAmbiguityProcessor.ForceRefit = False
            InDetTrigAmbiguityProcessor.RefitPrds = False
        elif slice == 'electron' and InDetTrigFlags.doBremRecovery():
            InDetTrigAmbiguityProcessor.tryBremFit = True
            import AthenaCommon.SystemOfUnits as Units
            InDetTrigAmbiguityProcessor.pTminBrem = 5 * Units.GeV
        elif slice == 'FTK' or slice == 'FTKRefit' or slice == 'FTKMon':
            from TrigInDetConf.TrigInDetRecToolsFTK import InDetTrigAmbiTrackSelectionToolFTK, InDetTrigTrackFitterFTK
            InDetTrigAmbiguityProcessor.SelectionTool = InDetTrigAmbiTrackSelectionToolFTK
            InDetTrigAmbiguityProcessor.Fitter = InDetTrigTrackFitterFTK
            #InDetTrigAmbiguityProcessor.RefitPrds =

        if InDetTrigFlags.materialInteractions() and InDetTrigFlags.solenoidOn(
        ):
            InDetTrigAmbiguityProcessor.MatEffects = 3
        else:
            InDetTrigAmbiguityProcessor.MatEffects = 0

        ToolSvc += InDetTrigAmbiguityProcessor
        if (InDetTrigFlags.doPrintConfigurables()):
            print InDetTrigAmbiguityProcessor

        self.AmbiguityProcessor = InDetTrigAmbiguityProcessor
        if lowPt:
            from InDetTrigRecExample.InDetTrigConfigRecLoadToolsLowPt import InDetTrigAmbiguityProcessorLowPt
            self.AmbiguityProcessor = InDetTrigAmbiguityProcessorLowPt
            self.OutputTracksLabel = "AmbigSolvLowPt"

        #use either SPSeeded or FTF tracks
        self.InputTracksLabel = ""

        #FIX
        #InDetTrigExtrapolator.ApplyMaterialEffects = False

        #monitoring
        from InDetTrigAmbiguitySolver.InDetTrigAmbiguitySolverMonitoring import InDetTrigAmbiguitySolverValidationMonitor
        from InDetTrigAmbiguitySolver.InDetTrigAmbiguitySolverMonitoring import InDetTrigAmbiguitySolverOnlineMonitor
        from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
        ambtime = TrigTimeHistToolConfig("AmbTime")
        ambtime.TimerHistLimits = [0, 100]
        if InDetTrigSliceSettings[('doFullScan', slice)]:
            ambtime.TimerHistLimits = [0, 500]
        self.AthenaMonTools = [
            InDetTrigAmbiguitySolverValidationMonitor(),
            InDetTrigAmbiguitySolverOnlineMonitor(), ambtime
        ]
Ejemplo n.º 3
0
    def __init__(self, name, type):
        TrigFastTrackFinder.__init__(self, name)
        remapped_type = remap[type]
        assert (remapped_type is not None)

        #Global keys/names for collections
        from TrigInDetConfig.InDetTrigCollectionKeys import TrigPixelKeys, TrigSCTKeys

        self.useNewLayerNumberScheme = True

        self.OutputCollectionSuffix = type
        from AthenaCommon.AppMgr import ToolSvc

        numberingTool = TrigL2LayerNumberTool(name="TrigL2LayerNumberTool_FTF")
        numberingTool.UseNewLayerScheme = self.useNewLayerNumberScheme
        ToolSvc += numberingTool
        self.LayerNumberTool = numberingTool

        from InDetTrigRecExample.InDetTrigSliceSettings import InDetTrigSliceSettings

        # GPU offloading config begins

        self.useGPU = False

        #if type == "FS" : self.useGPU = True

        if self.useGPU:
            from TrigInDetAccelerationTool.TrigInDetAccelerationToolConf import TrigInDetAccelerationTool
            accelTool = TrigInDetAccelerationTool(
                name="TrigInDetAccelerationTool_FTF")
            ToolSvc += accelTool

        # GPU offloading config ends

        self.doResMon = InDetTrigSliceSettings[('doResMon', remapped_type)]

        # switch between Run-2/3 monitoring
        self.MonTool = TrigFastTrackFinderMonitoring(type, self.doResMon)
        from TrigInDetConf.TrigInDetRecCommonTools import InDetTrigFastTrackSummaryTool
        self.TrackSummaryTool = InDetTrigFastTrackSummaryTool

        # why is this TrigFastTrackFinderMonitoring() line added twice ???
        # Run3 monitoring
        #        self.MonTool = TrigFastTrackFinderMonitoring(type, self.doResMon)

        #Spacepoint conversion
        from TrigOnlineSpacePointTool.TrigOnlineSpacePointToolConf import TrigSpacePointConversionTool
        spTool = TrigSpacePointConversionTool().clone(
            'TrigSpacePointConversionTool_' + remapped_type)
        spTool.DoPhiFiltering = InDetTrigSliceSettings[('doSpPhiFiltering',
                                                        remapped_type)]
        spTool.UseNewLayerScheme = self.useNewLayerNumberScheme
        spTool.UseBeamTilt = False
        spTool.PixelSP_ContainerName = TrigPixelKeys.SpacePoints
        spTool.SCT_SP_ContainerName = TrigSCTKeys.SpacePoints
        spTool.layerNumberTool = numberingTool

        from RegionSelector.RegSelToolConfig import makeRegSelTool_Pixel
        from RegionSelector.RegSelToolConfig import makeRegSelTool_SCT

        spTool.RegSel_Pixel = makeRegSelTool_Pixel()
        spTool.RegSel_SCT = makeRegSelTool_SCT()

        ToolSvc += spTool
        self.SpacePointProviderTool = spTool
        self.MinHits = 5  #Only process RoI with more than 5 spacepoints

        self.Triplet_MinPtFrac = 1
        self.Triplet_nMaxPhiSlice = 53
        if remapped_type == "cosmics":
            self.Triplet_nMaxPhiSlice = 2  #Divide detector in 2 halves for cosmics

        self.Triplet_MaxBufferLength = 3
        self.doSeedRedundancyCheck = InDetTrigSliceSettings[(
            'checkRedundantSeeds', remapped_type)]
        self.Triplet_D0Max = InDetTrigSliceSettings[('d0SeedMax',
                                                     remapped_type)]
        self.Triplet_D0_PPS_Max = InDetTrigSliceSettings[('d0SeedPPSMax',
                                                          remapped_type)]
        self.TrackInitialD0Max = 20.
        if remapped_type == 'cosmics':
            self.TrackInitialD0Max = 1000.
            self.TrackZ0Max = 1000.

        self.TripletDoPSS = False
        self.pTmin = InDetTrigSliceSettings[('pTmin', remapped_type)]
        self.DoubletDR_Max = InDetTrigSliceSettings[('dRdoubletMax',
                                                     remapped_type)]
        self.SeedRadBinWidth = InDetTrigSliceSettings[('seedRadBinWidth',
                                                       remapped_type)]

        if remapped_type == "cosmics":
            self.Doublet_FilterRZ = False

        ## SCT and Pixel detector elements road builder
        from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigSiDetElementsRoadMaker
        InDetTrigSiDetElementsRoadMaker_FTF = InDetTrigSiDetElementsRoadMaker.clone(
            'InDetTrigSiDetElementsRoadMaker_FTF')
        InDetTrigSiDetElementsRoadMaker_FTF.RoadWidth = 10.0
        if remapped_type == "cosmics":
            from InDetTrigRecExample.InDetTrigConfigRecLoadToolsCosmics import InDetTrigSiDetElementsRoadMakerCosmics
            InDetTrigSiDetElementsRoadMaker_FTF = InDetTrigSiDetElementsRoadMakerCosmics.clone(
                'InDetTrigSiDetElementsRoadMaker_FTF')

        from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigSiComTrackFinder
        InDetTrigSiComTrackFinder_FTF = InDetTrigSiComTrackFinder.clone(
            "InDetTrigSiComTrackFinder_FTF")
        from InDetTrigRecExample.InDetTrigConditionsAccess import SCT_ConditionsSetup
        from SCT_ConditionsTools.SCT_ConditionsToolsConf import SCT_ConditionsSummaryTool
        InDetTrigSiComTrackFinder_FTF.SctSummaryTool = SCT_ConditionsSummaryTool(
            SCT_ConditionsSetup.instanceName(
                'InDetSCT_ConditionsSummaryToolWithoutFlagged'))
        ToolSvc += InDetTrigSiComTrackFinder_FTF

        from InDetTrigRecExample.ConfiguredNewTrackingTrigCuts import EFIDTrackingCuts
        TrackingCuts = EFIDTrackingCuts
        if remapped_type == "cosmics":
            from InDetTrigRecExample.ConfiguredNewTrackingTrigCuts import EFIDTrackingCutsCosmics
            TrackingCuts = EFIDTrackingCutsCosmics

        from SiTrackMakerTool_xk.SiTrackMakerTool_xkConf import InDet__SiTrackMaker_xk

        TrackMaker_FTF = InDet__SiTrackMaker_xk(
            name='InDetTrigSiTrackMaker_FTF_' + type,
            RoadTool=InDetTrigSiDetElementsRoadMaker_FTF,
            CombinatorialTrackFinder=InDetTrigSiComTrackFinder_FTF,
            pTmin=InDetTrigSliceSettings[('pTmin', remapped_type)],
            nClustersMin=TrackingCuts.minClusters(),
            nHolesMax=TrackingCuts.nHolesMax(),
            nHolesGapMax=TrackingCuts.nHolesGapMax(),
            SeedsFilterLevel=0,  # Do not use built-in seeds filter
            Xi2max=TrackingCuts.Xi2max(),
            Xi2maxNoAdd=TrackingCuts.Xi2maxNoAdd(),
            nWeightedClustersMin=TrackingCuts.nWeightedClustersMin(),
            Xi2maxMultiTracks=TrackingCuts.Xi2max(),
            UseAssociationTool=False)

        from InDetTrigRecExample.InDetTrigFlags import InDetTrigFlags
        if type == 'eGamma' and InDetTrigFlags.doBremRecovery():
            TrackMaker_FTF.useBremModel = True

        if remapped_type == "cosmics":
            TrackMaker_FTF.CosmicTrack = True

        ToolSvc += TrackMaker_FTF
        self.initialTrackMaker = TrackMaker_FTF

        from TrigInDetTrackFitter.TrigInDetTrackFitterConf import TrigInDetTrackFitter
        theTrigInDetTrackFitter = TrigInDetTrackFitter()
        #theTrigInDetTrackFitter.correctClusterPos = False #Flag to control whether to correct cluster position
        theTrigInDetTrackFitter.correctClusterPos = True  #temporarily to true to improve err(z0) estimates

        from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigRotCreator
        theTrigInDetTrackFitter.ROTcreator = InDetTrigRotCreator
        ToolSvc += theTrigInDetTrackFitter
        self.trigInDetTrackFitter = theTrigInDetTrackFitter
        from InDetTrigRecExample.InDetTrigFlags import InDetTrigFlags
        if type == 'eGamma' and InDetTrigFlags.doBremRecovery():
            theTrigInDetTrackFitterBrem = TrigInDetTrackFitter(
                name='theTrigInDetTrackFitterBrem', doBremmCorrection=True)
            ToolSvc += theTrigInDetTrackFitterBrem
            self.trigInDetTrackFitter = theTrigInDetTrackFitterBrem

        self.doZFinder = InDetTrigSliceSettings[('doZFinder', remapped_type)]
        if (self.doZFinder):
            from IDScanZFinder.IDScanZFinderConf import TrigZFinder
            theTrigZFinder = TrigZFinder(name="TrigZFinder_" + remapped_type)
            theTrigZFinder.NumberOfPeaks = 3
            theTrigZFinder.LayerNumberTool = numberingTool

            if remapped_type == "beamSpot":
                theTrigZFinder.TripletMode = 1
                theTrigZFinder.TripletDZ = 1
                theTrigZFinder.PhiBinSize = 0.1
                theTrigZFinder.UseOnlyPixels = True
                theTrigZFinder.MaxLayer = 3

            theTrigZFinder.FullScanMode = True  #TODO: know this from the RoI anyway - should set for every event

            self.trigZFinder = theTrigZFinder
            self.doFastZVertexSeeding = True
            self.zVertexResolution = 1

        TrackMaker_FTF.InputClusterContainerName = ""
        TrackMaker_FTF.InputHadClusterContainerName = ""

        from TrigInDetConf.TrigInDetRecCommonTools import InDetTrigFastTrackSummaryTool
        self.TrackSummaryTool = InDetTrigFastTrackSummaryTool

        if remapped_type == "tauCore":
            from TrigInDetConf.TrigInDetRecCommonTools import InDetTrigTrackSummaryToolWithHoleSearch
            self.TrackSummaryTool = InDetTrigTrackSummaryToolWithHoleSearch

        self.doCloneRemoval = InDetTrigSliceSettings[('doCloneRemoval',
                                                      remapped_type)]
Ejemplo n.º 4
0
    def __init__(self, name, type):
        TrigFastTrackFinder.__init__(self, name)
        remapped_type = remapper(type)

        self.retrieveBarCodes = False  #Look at truth information for spacepoints from barcodes
        #self.SignalBarCodes = [10001] #single particles
        self.SignalBarCodes = [11, 12]  #z->mumu

        self.useNewLayerNumberScheme = True

        self.OutputCollectionSuffix = type
        from AthenaCommon.AppMgr import ToolSvc

        numberingTool = TrigL2LayerNumberTool(name="TrigL2LayerNumberTool_FTF")
        numberingTool.UseNewLayerScheme = self.useNewLayerNumberScheme
        ToolSvc += numberingTool
        self.LayerNumberTool = numberingTool

        timeHist = TrigTimeHistToolConfig("Time")
        timeHist.TimerHistLimits = [0, 10000]
        from InDetTrigRecExample.InDetTrigSliceSettings import InDetTrigSliceSettings
        self.doResMon = InDetTrigSliceSettings[('doResMon', remapped_type)]
        self.AthenaMonTools = [
            TrigFastTrackFinder_ValidationMonitoring(
                "TrigFastTrackFinder_ValidationMonitoring", self.doResMon),
            TrigFastTrackFinder_OnlineMonitoring(
                "TrigFastTrackFinder_OnlineMonitoring", self.doResMon),
            timeHist
        ]

        if type == "FTK" or type == "FTKRefit" or type == "FTKMon":
            from TrigFTK_RecExample.TrigFTKLoadTools import theFTK_DataProviderSvc
            self.FTK_DataProviderSvc = theFTK_DataProviderSvc
            self.FTK_Mode = True
        if type == "FTKRefit":
            self.FTK_Refit = True
        else:
            #Spacepoint conversion
            from TrigOnlineSpacePointTool.TrigOnlineSpacePointToolConf import TrigSpacePointConversionTool
            spTool = TrigSpacePointConversionTool().clone(
                'TrigSpacePointConversionTool_' + remapped_type)
            spTool.DoPhiFiltering = InDetTrigSliceSettings[('doSpPhiFiltering',
                                                            remapped_type)]
            spTool.UseNewLayerScheme = self.useNewLayerNumberScheme
            spTool.UseBeamTilt = False
            spTool.layerNumberTool = numberingTool
            ToolSvc += spTool
            self.SpacePointProviderTool = spTool
            self.MinSPs = 5  #Only process RoI with more than 5 spacepoints

            self.Triplet_MinPtFrac = 1
            self.Triplet_nMaxPhiSlice = 53
            if remapped_type == "cosmics":
                self.Triplet_nMaxPhiSlice = 2  #Divide detector in 2 halves for cosmics

            self.Triplet_MaxBufferLength = 3
            self.doSeedRedundancyCheck = InDetTrigSliceSettings[(
                'checkRedundantSeeds', remapped_type)]
            self.Triplet_D0Max = InDetTrigSliceSettings[('d0SeedMax',
                                                         remapped_type)]
            self.Triplet_D0_PPS_Max = InDetTrigSliceSettings[('d0SeedPPSMax',
                                                              remapped_type)]
            self.TrackInitialD0Max = 20.
            if remapped_type == 'cosmics':
                self.TrackInitialD0Max = 1000.
                self.TrackZ0Max = 1000.

            self.TripletDoPSS = False
            self.pTmin = InDetTrigSliceSettings[('pTmin', remapped_type)]
            self.DoubletDR_Max = InDetTrigSliceSettings[('dRdoubletMax',
                                                         remapped_type)]
            self.SeedRadBinWidth = InDetTrigSliceSettings[('seedRadBinWidth',
                                                           remapped_type)]

            if remapped_type == "cosmics":
                self.Doublet_FilterRZ = False

            ## SCT and Pixel detector elements road builder
            from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigSiDetElementsRoadMaker
            InDetTrigSiDetElementsRoadMaker_FTF = InDetTrigSiDetElementsRoadMaker.clone(
                'InDetTrigSiDetElementsRoadMaker_FTF')
            InDetTrigSiDetElementsRoadMaker_FTF.RoadWidth = 10.0
            if remapped_type == "cosmics":
                from InDetTrigRecExample.InDetTrigConfigRecLoadToolsCosmics import InDetTrigSiDetElementsRoadMakerCosmics
                InDetTrigSiDetElementsRoadMaker_FTF = InDetTrigSiDetElementsRoadMakerCosmics.clone(
                    'InDetTrigSiDetElementsRoadMaker_FTF')
            ToolSvc += InDetTrigSiDetElementsRoadMaker_FTF

            from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigSiComTrackFinder
            InDetTrigSiComTrackFinder_FTF = InDetTrigSiComTrackFinder.clone(
                "InDetTrigSiComTrackFinder_FTF")
            ToolSvc += InDetTrigSiComTrackFinder_FTF

            from InDetTrigRecExample.ConfiguredNewTrackingTrigCuts import EFIDTrackingCuts
            TrackingCuts = EFIDTrackingCuts
            if remapped_type == "cosmics":
                from InDetTrigRecExample.ConfiguredNewTrackingTrigCuts import EFIDTrackingCutsCosmics
                TrackingCuts = EFIDTrackingCutsCosmics

            from SiTrackMakerTool_xk.SiTrackMakerTool_xkConf import InDet__SiTrackMaker_xk

            TrackMaker_FTF = InDet__SiTrackMaker_xk(
                name='InDetTrigSiTrackMaker_FTF_' + type,
                RoadTool=InDetTrigSiDetElementsRoadMaker_FTF,
                CombinatorialTrackFinder=InDetTrigSiComTrackFinder_FTF,
                pTmin=InDetTrigSliceSettings[('pTmin', remapped_type)],
                nClustersMin=TrackingCuts.minClusters(),
                nHolesMax=TrackingCuts.nHolesMax(),
                nHolesGapMax=TrackingCuts.nHolesGapMax(),
                SeedsFilterLevel=0,  # Do not use built-in seeds filter
                Xi2max=TrackingCuts.Xi2max(),
                Xi2maxNoAdd=TrackingCuts.Xi2maxNoAdd(),
                nWeightedClustersMin=TrackingCuts.nWeightedClustersMin(),
                Xi2maxMultiTracks=TrackingCuts.Xi2max(),
                UseAssociationTool=False)

            from InDetTrigRecExample.InDetTrigFlags import InDetTrigFlags
            if type == 'eGamma' and InDetTrigFlags.doBremRecovery():
                TrackMaker_FTF.useBremModel = True

            if remapped_type == "cosmics":
                TrackMaker_FTF.RoadTool.CosmicTrack = True

            ToolSvc += TrackMaker_FTF
            self.initialTrackMaker = TrackMaker_FTF

            from TrigInDetTrackFitter.TrigInDetTrackFitterConf import TrigInDetTrackFitter
            theTrigInDetTrackFitter = TrigInDetTrackFitter()
            #theTrigInDetTrackFitter.correctClusterPos = False #Flag to control whether to correct cluster position
            theTrigInDetTrackFitter.correctClusterPos = True  #temporarily to true to improve err(z0) estimates

            from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigRotCreator
            theTrigInDetTrackFitter.ROTcreator = InDetTrigRotCreator
            ToolSvc += theTrigInDetTrackFitter
            self.trigInDetTrackFitter = theTrigInDetTrackFitter
            from InDetTrigRecExample.InDetTrigFlags import InDetTrigFlags
            if type == 'eGamma' and InDetTrigFlags.doBremRecovery():
                theTrigInDetTrackFitterBrem = TrigInDetTrackFitter(
                    name='theTrigInDetTrackFitterBrem', doBremmCorrection=True)
                ToolSvc += theTrigInDetTrackFitterBrem
                self.trigInDetTrackFitter = theTrigInDetTrackFitterBrem

            self.doZFinder = InDetTrigSliceSettings[('doZFinder',
                                                     remapped_type)]
            if (self.doZFinder):
                from IDScanZFinder.IDScanZFinderConf import TrigZFinder
                theTrigZFinder = TrigZFinder()
                theTrigZFinder.NumberOfPeaks = 3
                theTrigZFinder.LayerNumberTool = numberingTool

                theTrigZFinder.FullScanMode = True  #TODO: know this from the RoI anyway - should set for every event
                ToolSvc += theTrigZFinder
                self.trigZFinder = theTrigZFinder
                self.doFastZVertexSeeding = True
                self.zVertexResolution = 1

            from TrigInDetConf.TrigInDetRecCommonTools import InDetTrigFastTrackSummaryTool
            self.TrackSummaryTool = InDetTrigFastTrackSummaryTool

            if remapped_type == "tauCore":
                from TrigInDetConf.TrigInDetRecCommonTools import InDetTrigTrackSummaryToolWithHoleSearch
                self.TrackSummaryTool = InDetTrigTrackSummaryToolWithHoleSearch

            from TrigInDetTrackFitter.TrigInDetTrackFitterConf import TrigL2ResidualCalculator
            resCalc = TrigL2ResidualCalculator(OfflineClusters=False)
            ToolSvc += resCalc
            self.TrigL2ResidualCalculator = resCalc
            self.doCloneRemoval = InDetTrigSliceSettings[('doCloneRemoval',
                                                          remapped_type)]
Ejemplo n.º 5
0
    def __init__(self, name="FTF", type="eGamma"):
        TrigFastTrackFinderMT.__init__(self, name)
        remapped_type = "electron"
        from TrigOnlineSpacePointTool.TrigOnlineSpacePointToolConf import TrigL2LayerNumberTool

        self.retrieveBarCodes = False  #Look at truth information for spacepoints from barcodes
        #self.SignalBarCodes = [10001] #single particles
        self.SignalBarCodes = [11, 12]  #z->mumu

        self.useNewLayerNumberScheme = True

        self.OutputCollectionSuffix = type
        from AthenaCommon.AppMgr import ToolSvc

        numberingTool = TrigL2LayerNumberTool(name="TrigL2LayerNumberTool_FTF")
        numberingTool.UseNewLayerScheme = self.useNewLayerNumberScheme
        ToolSvc += numberingTool
        self.LayerNumberTool = numberingTool

        from InDetTrigRecExample.InDetTrigSliceSettings import InDetTrigSliceSettings
        if type == "FTK" or type == "FTKRefit":
            from TrigFTK_RecExample.TrigFTKLoadTools import theFTK_DataProviderSvc
            self.FTK_DataProviderSvc = theFTK_DataProviderSvc
            self.FTK_Mode = True
        if type == "FTKRefit":
            self.FTK_Refit = True
        else:
            #Spacepoint conversion
            from TrigOnlineSpacePointTool.TrigOnlineSpacePointToolConf import TrigSpacePointConversionTool
            spTool = TrigSpacePointConversionTool().clone(
                'TrigSpacePointConversionTool_' + remapped_type)
            spTool.DoPhiFiltering = InDetTrigSliceSettings[('doSpPhiFiltering',
                                                            remapped_type)]
            spTool.UseNewLayerScheme = self.useNewLayerNumberScheme
            spTool.UseBeamTilt = False
            spTool.PixelSP_ContainerName = 'PixelSpacePoints'
            spTool.SCT_SP_ContainerName = 'SCT_SpacePoints'
            spTool.layerNumberTool = numberingTool
            ToolSvc += spTool
            self.SpacePointProviderTool = spTool
            self.MinSPs = 5  #Only process RoI with more than 5 spacepoints

            self.Triplet_MinPtFrac = 1
            self.Triplet_nMaxPhiSlice = 53
            if remapped_type == "cosmics":
                self.Triplet_nMaxPhiSlice = 2  #Divide detector in 2 halves for cosmics

            self.Triplet_MaxBufferLength = 3
            self.doSeedRedundancyCheck = InDetTrigSliceSettings[(
                'checkRedundantSeeds', remapped_type)]
            self.Triplet_D0Max = InDetTrigSliceSettings[('d0SeedMax',
                                                         remapped_type)]
            self.Triplet_D0_PPS_Max = InDetTrigSliceSettings[('d0SeedPPSMax',
                                                              remapped_type)]
            self.TrackInitialD0Max = 20.
            if remapped_type == 'cosmics':
                self.TrackInitialD0Max = 1000.
                self.TrackZ0Max = 1000.
            self.TripletDoPSS = False
            self.pTmin = InDetTrigSliceSettings[('pTmin', remapped_type)]
            self.DoubletDR_Max = InDetTrigSliceSettings[('dRdoubletMax',
                                                         remapped_type)]
            self.SeedRadBinWidth = InDetTrigSliceSettings[('seedRadBinWidth',
                                                           remapped_type)]

            if remapped_type == "cosmics":
                self.Doublet_FilterRZ = False

            ## SCT and Pixel detector elements road builder
            from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigSiDetElementsRoadMaker
            InDetTrigSiDetElementsRoadMaker_FTF = InDetTrigSiDetElementsRoadMaker.clone(
                'InDetTrigSiDetElementsRoadMaker_FTF')
            InDetTrigSiDetElementsRoadMaker_FTF.RoadWidth = 10.0
            InDetTrigSiDetElementsRoadMaker_FTF.usePixel = True
            InDetTrigSiDetElementsRoadMaker_FTF.useSCT = True
            if remapped_type == "cosmics":
                from InDetTrigRecExample.InDetTrigConfigRecLoadToolsCosmics import InDetTrigSiDetElementsRoadMakerCosmics
                InDetTrigSiDetElementsRoadMaker_FTF = InDetTrigSiDetElementsRoadMakerCosmics.clone(
                    'InDetTrigSiDetElementsRoadMaker_FTF')
            ToolSvc += InDetTrigSiDetElementsRoadMaker_FTF

            from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigSiComTrackFinder
            InDetTrigSiComTrackFinder_FTF = InDetTrigSiComTrackFinder.clone(
                "InDetTrigSiComTrackFinder_FTF")
            ToolSvc += InDetTrigSiComTrackFinder_FTF
            print InDetTrigSiComTrackFinder_FTF

            from InDetTrigRecExample.ConfiguredNewTrackingTrigCuts import EFIDTrackingCuts
            TrackingCuts = EFIDTrackingCuts
            if remapped_type == "cosmics":
                from InDetTrigRecExample.ConfiguredNewTrackingTrigCuts import EFIDTrackingCutsCosmics
                TrackingCuts = EFIDTrackingCutsCosmics

            from InDetRecExample.InDetKeys import InDetKeys
            from TrkExRungeKuttaPropagator.TrkExRungeKuttaPropagatorConf import Trk__RungeKuttaPropagator as Propagator
            InDetPatternPropagator = Propagator(name='InDetPatternPropagator')
            ToolSvc += InDetPatternPropagator
            from TrkMeasurementUpdator_xk.TrkMeasurementUpdator_xkConf import Trk__KalmanUpdator_xk
            InDetPatternUpdator = Trk__KalmanUpdator_xk(
                name='InDetPatternUpdator')
            ToolSvc += InDetPatternUpdator

            from SiClusterOnTrackTool.SiClusterOnTrackToolConf import InDet__PixelClusterOnTrackTool
            PixelClusterOnTrackToolDigital = InDet__PixelClusterOnTrackTool(
                "InDetPixelClusterOnTrackToolDigital",
                DisableDistortions=False,
                applyNNcorrection=False,
                NNIBLcorrection=False,
                SplitClusterAmbiguityMap=InDetKeys.SplitClusterAmbiguityMap(),
                RunningTIDE_Ambi=False,
                ErrorStrategy=2,
                PositionStrategy=1)

            ToolSvc += PixelClusterOnTrackToolDigital
            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
            ToolSvc += SCT_ClusterOnTrackTool
            from TrkRIO_OnTrackCreator.TrkRIO_OnTrackCreatorConf import Trk__RIO_OnTrackCreator
            InDetRotCreatorDigital = Trk__RIO_OnTrackCreator(
                name='InDetRotCreatorDigital',
                ToolPixelCluster=PixelClusterOnTrackToolDigital,
                ToolSCT_Cluster=SCT_ClusterOnTrackTool,
                Mode='indet')
            ToolSvc += InDetRotCreatorDigital
            from InDetAssociationTools.InDetAssociationToolsConf import InDet__InDetPRD_AssociationToolGangedPixels
            InDetPrdAssociationTool = InDet__InDetPRD_AssociationToolGangedPixels(
                name="InDetPrdAssociationTool",
                PixelClusterAmbiguitiesMapName=InDetKeys.GangedPixelMap(),
                addTRToutliers=True)
            ToolSvc += InDetPrdAssociationTool

            from AthenaCommon.DetFlags import DetFlags
            from SiCombinatorialTrackFinderTool_xk.SiCombinatorialTrackFinderTool_xkConf import InDet__SiCombinatorialTrackFinder_xk
            InDetSiComTrackFinder = InDet__SiCombinatorialTrackFinder_xk(
                name='InDetSiComTrackFinder',
                PropagatorTool=InDetPatternPropagator,
                UpdatorTool=InDetPatternUpdator,
                RIOonTrackTool=InDetRotCreatorDigital,
                AssosiationTool=InDetPrdAssociationTool,
                usePixel=True,  #DetFlags.haveRIO.pixel_on(),
                useSCT=True,  #DetFlags.haveRIO.SCT_on(),
                PixManagerLocation=InDetKeys.PixelManager(),
                SCTManagerLocation=InDetKeys.SCT_Manager(),
                PixelClusterContainer=InDetKeys.PixelClusters(),
                SCT_ClusterContainer=InDetKeys.SCT_Clusters())
            ToolSvc += InDetSiComTrackFinder
            from SiDetElementsRoadTool_xk.SiDetElementsRoadTool_xkConf import InDet__SiDetElementsRoadMaker_xk
            InDetSiDetElementsRoadMaker = InDet__SiDetElementsRoadMaker_xk(
                name='InDetSiRoadMaker_' + remapped_type,
                PropagatorTool=InDetPatternPropagator,
                usePixel=True,  #DetFlags.haveRIO.pixel_on(),
                PixManagerLocation=InDetKeys.PixelManager(),
                useSCT=True,  #DetFlags.haveRIO.SCT_on(), 
                SCTManagerLocation=InDetKeys.SCT_Manager(),
                RoadWidth=10.0)
            print InDetSiDetElementsRoadMaker
            ToolSvc += InDetSiDetElementsRoadMaker

            from SiTrackMakerTool_xk.SiTrackMakerTool_xkConf import InDet__SiTrackMaker_xk as SiTrackMaker
            TrackMaker_FTF = SiTrackMaker(
                name='InDetTrigSiTrackMaker_FTF_' + remapped_type,
                RoadTool=InDetSiDetElementsRoadMaker,
                CombinatorialTrackFinder=InDetSiComTrackFinder,
                pTmin=InDetTrigSliceSettings[('pTmin', remapped_type)],
                nClustersMin=TrackingCuts.minClusters(),
                nHolesMax=TrackingCuts.nHolesMax(),
                nHolesGapMax=TrackingCuts.nHolesGapMax(),
                SeedsFilterLevel=0,  # Do not use built-in seeds filter
                Xi2max=TrackingCuts.Xi2max(),
                Xi2maxNoAdd=TrackingCuts.Xi2maxNoAdd(),
                nWeightedClustersMin=TrackingCuts.nWeightedClustersMin(),
                Xi2maxMultiTracks=TrackingCuts.Xi2max(),
                UseAssociationTool=False)

            from InDetRecExample.InDetJobProperties import InDetFlags
            if not InDetFlags.doCaloSeededBrem():
                TrackMaker_FTF.InputClusterContainerName = ""
                TrackMaker_FTF.InputHadClusterContainerName = ""

            from InDetTrigRecExample.InDetTrigFlags import InDetTrigFlags
            if type == 'eGamma' and InDetTrigFlags.doBremRecovery():
                TrackMaker_FTF.useBremModel = True

            if remapped_type == "cosmics":
                TrackMaker_FTF.RoadTool.CosmicTrack = True

            ToolSvc += TrackMaker_FTF
            self.initialTrackMaker = TrackMaker_FTF

            from TrigInDetTrackFitter.TrigInDetTrackFitterConf import TrigInDetTrackFitter
            theTrigInDetTrackFitter = TrigInDetTrackFitter()
            #theTrigInDetTrackFitter.correctClusterPos = False #Flag to control whether to correct cluster position
            theTrigInDetTrackFitter.correctClusterPos = True  #temporarily to true to improve err(z0) estimates

            from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigRotCreator
            theTrigInDetTrackFitter.ROTcreator = InDetTrigRotCreator
            ToolSvc += theTrigInDetTrackFitter
            self.trigInDetTrackFitter = theTrigInDetTrackFitter
            from InDetTrigRecExample.InDetTrigFlags import InDetTrigFlags
            if type == 'eGamma' and InDetTrigFlags.doBremRecovery():
                theTrigInDetTrackFitterBrem = TrigInDetTrackFitter(
                    name='theTrigInDetTrackFitterBrem', doBremmCorrection=True)
                ToolSvc += theTrigInDetTrackFitterBrem
                self.trigInDetTrackFitter = theTrigInDetTrackFitterBrem

            self.doZFinder = InDetTrigSliceSettings[('doZFinder',
                                                     remapped_type)]
            if (self.doZFinder):
                from IDScanZFinder.IDScanZFinderConf import TrigZFinder
                theTrigZFinder = TrigZFinder()
                theTrigZFinder.NumberOfPeaks = 3
                theTrigZFinder.LayerNumberTool = numberingTool

                theTrigZFinder.FullScanMode = True  #TODO: know this from the RoI anyway - should set for every event
                ToolSvc += theTrigZFinder
                self.trigZFinder = theTrigZFinder
                self.doFastZVertexSeeding = True
                self.zVertexResolution = 7.5

            from TrigInDetConf.TrigInDetRecCommonTools import InDetTrigFastTrackSummaryTool
            self.TrackSummaryTool = InDetTrigFastTrackSummaryTool

            if remapped_type == "tauCore":
                from TrigInDetConf.TrigInDetRecCommonTools import InDetTrigTrackSummaryToolWithHoleSearch
                self.TrackSummaryTool = InDetTrigTrackSummaryToolWithHoleSearch

            from TrigInDetTrackFitter.TrigInDetTrackFitterConf import TrigL2ResidualCalculator
            resCalc = TrigL2ResidualCalculator(OfflineClusters=False)
            ToolSvc += resCalc
            self.TrigL2ResidualCalculator = resCalc
            self.doCloneRemoval = InDetTrigSliceSettings[('doCloneRemoval',
                                                          remapped_type)]