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 __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 #3
0
egTrkNavigator = Trk__Navigator(name='egTrkNavigator')
ToolSvc += egTrkNavigator
# Setup the MaterialEffectsUpdator
from TrkExTools.TrkExToolsConf import Trk__MaterialEffectsUpdator

egTrkMaterialUpdator = Trk__MaterialEffectsUpdator(
    name="egTrkMaterialEffectsUpdator")
ToolSvc += egTrkMaterialUpdator
# CONFIGURE PROPAGATORS/UPDATORS ACCORDING TO GEOMETRY SIGNATURE
egTrkSubPropagators = []
egTrkSubUpdators = []
# -------------------- set it depending on the geometry ----------------------------------------------------
# default for ID is (Rk,Mat)
egTrkSubPropagators += [egTrkPropagator.name()]
egTrkSubUpdators += [egTrkMaterialUpdator.name()]
# default for Calo is (Rk,MatLandau)
egTrkSubPropagators += [egTrkPropagator.name()]
egTrkSubUpdators += [egTrkMaterialUpdator.name()]
# default for MS is (STEP,Mat)
egTrkSubPropagators += [egTrkStepPropagator.name()]
egTrkSubUpdators += [egTrkMaterialUpdator.name()]
# ----------------------------------------------------------------------------------------------------------
# set up extrapolator to be used by egamma during tracking / vertexing operations
from TrkExTools.TrkExToolsConf import Trk__Extrapolator

egTrkExtrapolator = Trk__Extrapolator(
    name='egTrkExtrapolator',
    Propagators=[egTrkPropagator, egTrkStepPropagator],
    MaterialEffectsUpdators=[egTrkMaterialUpdator],
    Navigator=egTrkNavigator,
Beispiel #4
0
# Setup the MaterialEffectsUpdator
#
from TrkExTools.TrkExToolsConf import Trk__MaterialEffectsUpdator
ElectronTrkMaterialUpdator = Trk__MaterialEffectsUpdator(
    name="ElectronTrkMaterialEffectsUpdator")
ToolSvc += ElectronTrkMaterialUpdator

# CONFIGURE PROPAGATORS/UPDATORS ACCORDING TO GEOMETRY SIGNATURE

ElectronTrkSubPropagators = []
ElectronTrkSubUpdators = []

# -------------------- set it depending on the geometry ----------------------------------------------------
# default for ID is (Rk,Mat)
ElectronTrkSubPropagators += [ElectronTrkPropagator.name()]
ElectronTrkSubUpdators += [ElectronTrkMaterialUpdator.name()]

# default for Calo is (Rk,MatLandau)
ElectronTrkSubPropagators += [ElectronTrkPropagator.name()]
ElectronTrkSubUpdators += [ElectronTrkMaterialUpdator.name()]

# default for MS is (STEP,Mat)
ElectronTrkSubPropagators += [ElectronTrkStepPropagator.name()]
ElectronTrkSubUpdators += [ElectronTrkMaterialUpdator.name()]
# ----------------------------------------------------------------------------------------------------------

#
# set up extrapolator
#
from TrkExTools.TrkExToolsConf import Trk__Extrapolator
ElectronTrkExtrapolator = Trk__Extrapolator(
Beispiel #5
0
    ToolSvc += AtlasMaterialEffectsUpdator  #default material effects updator
    NoElossMaterialEffectsUpdator = MaterialEffectsUpdator(
        name='NoElossMaterialEffectsUpdator')
    NoElossMaterialEffectsUpdator.EnergyLoss = False
    ToolSvc += NoElossMaterialEffectsUpdator

    # setup MaterialEffectsUpdator arrays
    MyUpdators = []
    #    MyUpdators += [AtlasMaterialEffectsUpdator] # for ID
    MyUpdators += [NoElossMaterialEffectsUpdator]  # for ID
    MyUpdators += [NoElossMaterialEffectsUpdator]  # for Calo
    MyUpdators += [NoElossMaterialEffectsUpdator]  # for muon
    # MyUpdators += [NoElossMaterialEffectsUpdator] # for muon

    MySubUpdators = []
    MySubUpdators += [NoElossMaterialEffectsUpdator.name()]  # for ID
    #    MySubUpdators += [AtlasMaterialEffectsUpdator.name()] # for ID
    MySubUpdators += [NoElossMaterialEffectsUpdator.name()]  # for Calo
    MySubUpdators += [NoElossMaterialEffectsUpdator.name()]  # for muon

    theAtlasExtrapolator.MaterialEffectsUpdators = MyUpdators
    theAtlasExtrapolator.SubMEUpdators = MySubUpdators
    ToolSvc += theAtlasExtrapolator

    # add tool ExtrapolateTrackToCalo
    from TrackToCalo.TrackToCaloConf import ExtrapolateToCaloTool
    exToCalo = ExtrapolateToCaloTool(name="exToCalo",
                                     Extrapolator=theAtlasExtrapolator)
    ToolSvc += exToCalo

    ##### Add the Zee Monitoring to the manager ########
  InDetMaterialUpdator.ForceMomentum = True
  InDetMaterialUpdator.ForcedMomentumValue = 1000*MeV

ToolSvc += InDetMaterialUpdator

if InDetFlags.doPrintConfigurables: print      InDetMaterialUpdator

# CONFIGURE PROPAGATORS/UPDATORS ACCORDING TO GEOMETRY SIGNATURE
 
InDetSubPropagators = []
InDetSubUpdators = []
 
# -------------------- set it depending on the geometry ----------------------------------------------------
# default for ID is (Rk,Mat)
InDetSubPropagators += [ InDetPropagator.name() ]
InDetSubUpdators    += [ InDetMaterialUpdator.name() ]
 
# default for Calo is (Rk,MatLandau)
InDetSubPropagators += [ InDetPropagator.name() ]
InDetSubUpdators    += [ InDetMaterialUpdator.name() ]
 
# default for MS is (STEP,Mat)
InDetSubPropagators += [ InDetStepPropagator.name() ]
InDetSubUpdators    += [ InDetMaterialUpdator.name() ]
#----------------------------------------------------------------------------------------------------------            

from TrkExTools.TrkExToolsConf import Trk__Extrapolator
InDetExtrapolator = Trk__Extrapolator(name                    = 'InDetExtrapolator',
                                      Propagators             = [ InDetPropagator, InDetStepPropagator ],
                                      MaterialEffectsUpdators = [ InDetMaterialUpdator ],
                                      Navigator               = InDetNavigator,
Beispiel #7
0
# the UNIQUE NAVIGATOR ( === UNIQUE GEOMETRY) --------------------------------------------------------------
from TrkExTools.TrkExToolsConf import Trk__Navigator
TestNavigator = Trk__Navigator(name='TestNavigator')
TestNavigator.TrackingGeometrySvc = "Trk::TrackingGeometrySvc/AtlasTrackingGeometrySvc"
ToolSvc += TestNavigator

# CONFIGURE PROPAGATORS/UPDATORS ACCORDING TO GEOMETRY SIGNATURE

TestSubPropagators = []
TestSubUpdators = []

# -------------------- set it depending on the geometry ----------------------------------------------------
# default for ID is (Rk,Mat)
TestSubPropagators += [TestPropagator.name()]
TestSubUpdators += [TestMaterialEffectsUpdator.name()]

# default for Calo is (Rk,MatLandau)
TestSubPropagators += [TestPropagator.name()]
TestSubUpdators += [TestMaterialEffectsUpdator.name()]

TestSubPropagators += [TestPropagator.name()]
TestSubUpdators += [TestMaterialEffectsUpdator.name()]

# default for MS is (STEP,Mat)
TestSubPropagators += [TestSTEP_Propagator.name()]
TestSubUpdators += [TestMaterialEffectsUpdator.name()]

TestSubPropagators += [TestSTEP_Propagator.name()]
TestSubUpdators += [TestMaterialEffectsUpdator.name()]
Beispiel #8
0
def getPhotonConversionTool():

    if jobproperties.tauRecFlags.useVertexBasedConvFinder():
        from AthenaCommon.AppMgr import ToolSvc

        name = "_PhotonConversionVertex"

        ##

        from TrkExTools.TrkExToolsConf import Trk__MaterialEffectsUpdator as MaterialEffectsUpdator
        AtlasMaterialEffectsUpdator = MaterialEffectsUpdator(
            name='AtlasMaterialEffectsUpdator')
        ToolSvc += AtlasMaterialEffectsUpdator  #default material effects updator
        NoElossMaterialEffectsUpdator = MaterialEffectsUpdator(
            name='NoElossMaterialEffectsUpdator')
        NoElossMaterialEffectsUpdator.EnergyLoss = False
        ToolSvc += NoElossMaterialEffectsUpdator

        # setup MaterialEffectsUpdator arrays
        MyUpdators = []
        MyUpdators += [AtlasMaterialEffectsUpdator]  # for ID
        MyUpdators += [NoElossMaterialEffectsUpdator]  # for Calo
        # MyUpdators += [NoElossMaterialEffectsUpdator] # for muon

        MySubUpdators = []
        MySubUpdators += [AtlasMaterialEffectsUpdator.name()]  # for ID
        MySubUpdators += [NoElossMaterialEffectsUpdator.name()]  # for Calo
        MySubUpdators += [NoElossMaterialEffectsUpdator.name()]  # for muon

        #Configure the extrapolator
        from TrkExTools.AtlasExtrapolator import AtlasExtrapolator
        theAtlasExtrapolator = AtlasExtrapolator(name='theAtlasExtrapolator' +
                                                 name)
        theAtlasExtrapolator.DoCaloDynamic = False  # this turns off dynamic
        theAtlasExtrapolator.MaterialEffectsUpdators = MyUpdators
        theAtlasExtrapolator.SubMEUpdators = MySubUpdators
        ToolSvc += theAtlasExtrapolator

        #        from TrkMagFieldTools.TrkMagFieldToolsConf import Trk__MagneticFieldTool
        #        InDetMagField = Trk__MagneticFieldTool('InDetMagField'+name)
        #        ToolSvc += InDetMagField
        ### Ly S swith bellow off Oct 7
        #        from AthenaCommon.AppMgr import ServiceMgr
        #        from MagFieldServices.MagFieldServicesConf import MagField__AtlasFieldSvc
        #        ServiceMgr += MagField__AtlasFieldSvc("myAtlasFieldSvc")

        #
        # Setup track summary tool
        #
        from InDetAssociationTools.InDetAssociationToolsConf import InDet__InDetPRD_AssociationToolGangedPixels
        tauInDetPrdAssociationTool = InDet__InDetPRD_AssociationToolGangedPixels(
            name="tauInDetPrdAssociationTool",
            PixelClusterAmbiguitiesMapName='PixelClusterAmbiguitiesMap')
        ToolSvc += tauInDetPrdAssociationTool
        from InDetRecExample.InDetJobProperties import InDetFlags
        from InDetTrackHoleSearch.InDetTrackHoleSearchConf import InDet__InDetTrackHoleSearchTool
        tauInDetHoleSearchTool = InDet__InDetTrackHoleSearchTool(
            name="tauInDetHoleSearchTool",
            Extrapolator=theAtlasExtrapolator,
            checkBadSCTChip=InDetFlags.checkDeadElementsOnTrack())
        ToolSvc += tauInDetHoleSearchTool

        from AthenaCommon.DetFlags import DetFlags
        from InDetTrackSummaryHelperTool.InDetTrackSummaryHelperToolConf import InDet__InDetTrackSummaryHelperTool
        tauInDetTrackSummaryHelperTool = InDet__InDetTrackSummaryHelperTool(
            name="tauInDetTrackSummaryHelper",
            AssoTool=tauInDetPrdAssociationTool,
            DoSharedHits=False,
            HoleSearch=tauInDetHoleSearchTool,
            usePixel=DetFlags.haveRIO.pixel_on(),
            useSCT=DetFlags.haveRIO.SCT_on(),
            useTRT=DetFlags.haveRIO.TRT_on())
        ToolSvc += tauInDetTrackSummaryHelperTool

        #        from TrkTrackSummaryTool.AtlasTrackSummaryTool import AtlasTrackSummaryTool
        #        MyInDetTrackSummaryTool = AtlasTrackSummaryTool(
        #                                       InDetSummaryHelperTool = tauInDetTrackSummaryHelperTool,
        #                                       doSharedHits           = False )
        from TrkTrackSummaryTool.TrkTrackSummaryToolConf import Trk__TrackSummaryTool
        MyInDetTrackSummaryTool = Trk__TrackSummaryTool(
            name="MyInDetTrackSummaryTool",
            InDetSummaryHelperTool=tauInDetTrackSummaryHelperTool,
            doSharedHits=False,
            InDetHoleSearchTool=tauInDetHoleSearchTool)
        ToolSvc += MyInDetTrackSummaryTool

        from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
        InDetConversionVxFitterTool = Trk__TrkVKalVrtFitter(
            name="InDetConversionVxFitter" + name,
            Extrapolator=theAtlasExtrapolator,
            #                                        Extrapolator        = "Trk::Extrapolator/AtlasExtrapolator",
            IterationNumber=30,
            MakeExtendedVertex=True,
            FirstMeasuredPoint=False,

            #                                        MagFieldSvc         = InDetMagField,
            ##                                       MagFieldSvc="Trk::MagneticFieldTool/InDetMagField",
            #                                        AtlasMagFieldSvc="myAtlasFieldSvc",
            Robustness=6,
            usePhiCnst=True,
            useThetaCnst=True,
            FirstMeasuredPointLimit=True,
            InputParticleMasses=[0.511, 0.511],
            VertexForConstraint=[0., 0., 0.],
            CovVrtForConstraint=[
                0.015 * 0.015, 0., 0.015 * 0.015, 0., 0., 10000. * 10000.
            ])
        ToolSvc += InDetConversionVxFitterTool
        print InDetConversionVxFitterTool

        # Distance of minimum approach utility
        #
        from TrkVertexSeedFinderUtils.TrkVertexSeedFinderUtilsConf import Trk__SeedNewtonTrkDistanceFinder
        InDetConversionTrkDistanceFinder = Trk__SeedNewtonTrkDistanceFinder(
            name='InDetConversionTrkDistanceFinder' + name)
        ToolSvc += InDetConversionTrkDistanceFinder
        print InDetConversionTrkDistanceFinder

        # Straight line propagator needed to clean-up single track conversions
        #
        #        from TrkExRungeKuttaPropagator.TrkExRungeKuttaPropagatorConf import Trk__RungeKuttaPropagator as Propagator

        # Helper Tool
        #
        from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__ConversionFinderUtils
        InDetConversionHelper = InDet__ConversionFinderUtils(
            name="InDetConversionFinderUtils" + name)
        ToolSvc += InDetConversionHelper
        print InDetConversionHelper

        # Track selector tool
        #
        from InDetTrackSelectorTool.InDetTrackSelectorToolConf import InDet__InDetConversionTrackSelectorTool
        InDetConversionTrackSelector = InDet__InDetConversionTrackSelectorTool(
            name="InDetConversionTrackSelector" + name,
            TrackSummaryTool=MyInDetTrackSummaryTool,
            Extrapolator=theAtlasExtrapolator,
            maxSiD0=10000.,  #50.0,
            maxTrtD0=10000.,  #100.,
            maxSiZ0=10000.,  #350.0,
            maxTrtZ0=10000.,  #1400.,
            minPt=300,  #InDetNewTrackingCuts.minSecondaryPt()
            RatioCut1=0.0,  #0.5,
            RatioCut2=0.05,
            RatioCut3=0.05,
            RatioTRT=0.05,
            IsConversion=True,
            significanceD0_Si=-1.,
            RatioV0=-1.)

        ToolSvc += InDetConversionTrackSelector
        print InDetConversionTrackSelector

        # Track pairs selector
        #
        ## There are many tunings on Oct 5
        from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__TrackPairsSelector
        InDetConversionTrackPairsSelector = InDet__TrackPairsSelector(
            name="InDetConversionTrackPairsSelector" + name,
            ConversionFinderHelperTool=InDetConversionHelper,
            DistanceTool=InDetConversionTrkDistanceFinder,
            #                             MaxEta                     = [0.12,10000.,10000.],      #[0.5,1.0,0.5])
            MaxEta=[0.15, 0.3, 0.5],  #[0.5,1.0,0.5])
            #                             MaxDistBetweenTracks       = [6.6,10000.,10000.],     #[6.,80.,30.]
            MaxDistBetweenTracks=[7.5, 15., 30.],  #[6.,80.,30.]
            MaxInitDistance=[10000., 10000., 10000.],
            MinTrackAngle=0.)
        ToolSvc += InDetConversionTrackPairsSelector
        print InDetConversionTrackPairsSelector

        # Vertex point estimator
        #
        from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__VertexPointEstimator
        InDetConversionVtxPointEstimator = InDet__VertexPointEstimator(
            name="InDetConversionVtxPointEstimator" + name,
            MaxTrkXYDiffAtVtx=[10000., 10000., 10000.],
            MaxTrkZDiffAtVtx=[10000., 10000., 10000.],
            MaxTrkXYValue=[10000., 10000., 10000.],
            MinArcLength=[-10000., -10000., -10000.],
            MaxArcLength=[10000., 10000., 10000.],
            MinDeltaR=[-5., -25., -50.],
            #                                   MaxDeltaR              = [10000.,10000.,10000.],
            MaxDeltaR=[5., 10., 10.],
            #                                   MaxHl                  = [10000.,10000.,10000.],
            #                                   MaxPhi                 = [0.034, 10000., 10000.] #[0.05, 0.1, 0.1]
            #                                   MaxPhi                 = [ 10000., 10000., 10000.]
            MaxPhi=[0.05, 0.1, 0.2])
        ToolSvc += InDetConversionVtxPointEstimator
        print InDetConversionVtxPointEstimator

        # Conversion post selector
        #
        from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__ConversionPostSelector
        InDetConversionPostSelector = InDet__ConversionPostSelector(
            name="InDetConversionPostSelector" + name,
            #                                      MaxChi2Vtx       = [10000.,10000.,10000.],   #[40.,100.,80.],
            MaxChi2Vtx=[500., 700., 900.],  #[40.,100.,80.],
            #                                      MaxInvariantMass = [45.,25000.,25000.],     #[60.,60.,30.],
            MaxInvariantMass=[350., 400., 500.],  #[60.,60.,30.],
            MinFitMomentum=[0., 0., 0.],  #[2000.,2000.,2000.],
            MinRadius=[21, 20., 15.],  #[30.,35.,250.],
            #                                      MinRadius        = [ -10000.0, -10000.0, -10000.0 ],  #[30.,35.,250.],
            MinPt=0.,
            #                                      MaxdR            = 10000.,               #-250.,
            ## equivalent to InDetConversionFinderTools.MaxDistVtxHit
            MaxdR=-10000.,  #-250.,
            #                                      MaxPhiVtxTrk     = 0.046   #0.2
            MaxPhiVtxTrk=0.05)
        ToolSvc += InDetConversionPostSelector
        print InDetConversionPostSelector

        # Single track conversion tool
        #
        from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__SingleTrackConversionTool
        InDetSingleTrackConversion = InDet__SingleTrackConversionTool(
            name="InDetSingleTrackConversionTool" + name,
            ConversionFinderHelperTool=InDetConversionHelper,
            TrackSummaryTool=MyInDetTrackSummaryTool,
            Extrapolator=theAtlasExtrapolator,
            MaxBLayerHits=0,
            MinInitialHitRadius=70.,
            MinInitialHitRadius_noBlay=90.,
            MinRatioOfHLhits=0.95)
        ToolSvc += InDetSingleTrackConversion
        print InDetSingleTrackConversion
        ## Oct 5, following egamma
        from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__InDetConversionFinderTools
        MyInDetConversionFinderTools = InDet__InDetConversionFinderTools(
            name="InDetConversionFinderTools" + name,
            VertexFitterTool=InDetConversionVxFitterTool,
            TrackSelectorTool=InDetConversionTrackSelector,
            TrackPairsSelector=InDetConversionTrackPairsSelector,
            ConversionFinderHelperTool=InDetConversionHelper,
            VertexPointEstimator=InDetConversionVtxPointEstimator,
            PostSelector=InDetConversionPostSelector,
            SingleTrackConversionTool=InDetSingleTrackConversion,
            Extrapolator=theAtlasExtrapolator,
            TrackParticleCollection="InDetTrackParticles",
            #                                                MinDistVtxHit              = -10000.,
            MinDistVtxHit=-350.,
            MaxDistVtxHit=230.,
            MinFlightAngle=0.0,
            MinInitVtxR=0.0,
            RemoveTrtTracks=False,
            IsConversion=True)
        ToolSvc += MyInDetConversionFinderTools
        print MyInDetConversionFinderTools

        from tauRecTools.tauRecToolsConf import PhotonConversionVertex
        photonConv = PhotonConversionVertex(
            name="PhotonConversionVertex",
            TauRecContainer="TauJets",
            TrackParticleContainer="InDetTrackParticles",
            OutputConversionVertexContainerName="ConversionsVertex_Container",
            MaxTauJetDr=0.5,
            ConversionFinderTool=MyInDetConversionFinderTools)

        return photonConv

    else:
        from tauRecTools.tauRecToolsConf import PhotonConversionPID
        photonConv = PhotonConversionPID(
            ConversionCandidatesName="ConversionCandidate",
            ConversionOutputName="ConversionsPID_Container",
            ElectronProbability=0.9)
        return photonConv
Beispiel #9
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
                                   )
AtlasMaterialEffectsUpdator = MaterialEffectsUpdator(name = 'AtlasMaterialEffectsUpdator')
ToolSvc += AtlasMaterialEffectsUpdator #default material effects updator
NoElossMaterialEffectsUpdator = MaterialEffectsUpdator(name = 'NoElossMaterialEffectsUpdator')
NoElossMaterialEffectsUpdator.EnergyLoss = False
ToolSvc += NoElossMaterialEffectsUpdator
	           
# setup MaterialEffectsUpdator arrays
MyUpdators = []
#    MyUpdators += [AtlasMaterialEffectsUpdator] # for ID
MyUpdators += [NoElossMaterialEffectsUpdator] # for ID
MyUpdators += [NoElossMaterialEffectsUpdator] # for Calo
MyUpdators += [NoElossMaterialEffectsUpdator] # for muon
# MyUpdators += [NoElossMaterialEffectsUpdator] # for muon
	           
MySubUpdators = []
MySubUpdators += [NoElossMaterialEffectsUpdator.name()] # for ID
#    MySubUpdators += [AtlasMaterialEffectsUpdator.name()] # for ID
MySubUpdators += [NoElossMaterialEffectsUpdator.name()] # for Calo
MySubUpdators += [NoElossMaterialEffectsUpdator.name()] # for muon
	           
theAtlasExtrapolator.MaterialEffectsUpdators = MyUpdators
theAtlasExtrapolator.SubMEUpdators = MySubUpdators
ToolSvc+=theAtlasExtrapolator
	           
from TrackToCalo.TrackToCaloConf import Trk__ParticleCaloExtensionTool
ClassifierParticleCaloExtensionTool= Trk__ParticleCaloExtensionTool(name="ClassifierParticleCaloExtensionTool",
                                                                                Extrapolator = theAtlasExtrapolator)
ToolSvc+=ClassifierParticleCaloExtensionTool

from MCTruthClassifier.MCTruthClassifierConf import MCTruthClassifier
MCTruthClassifier = MCTruthClassifier(name = 'MCTruthClassifier',
Beispiel #11
0
AtlasMaterialEffectsUpdatorLandau = MaterialEffectsUpdator(name = 'AtlasMaterialEffectsUpdatorLandau')
AtlasMaterialEffectsUpdatorLandau.LandauMode = True
ToolSvc += AtlasMaterialEffectsUpdatorLandau

AtlasUpdators    += [ AtlasMaterialEffectsUpdatorLandau ]
                     

# CONFIGURE PROPAGATORS/UPDATORS ACCORDING TO GEOMETRY SIGNATURE

AtlasSubPropagators = []
AtlasSubUpdators = []

# -------------------- set it depending on the geometry ----------------------------------------------------
# default for ID is (Rk,Mat)
AtlasSubPropagators += [ AtlasRungeKuttaPropagator.name() ]
AtlasSubUpdators    += [ AtlasMaterialEffectsUpdator.name() ]

# default for Calo is (Rk,MatLandau)
AtlasSubPropagators += [ AtlasRungeKuttaPropagator.name() ]
AtlasSubUpdators    += [ AtlasMaterialEffectsUpdatorLandau.name() ]

# default for MS is (STEP,Mat)
AtlasSubPropagators += [ AtlasSTEP_Propagator.name() ]
AtlasSubUpdators    += [ AtlasMaterialEffectsUpdator.name() ]
# ----------------------------------------------------------------------------------------------------------
          
# the Extrapolator
from TrkExTools.TrkExToolsConf import Trk__Extrapolator
CombinedExtrapolator = Trk__Extrapolator( name = 'CombinedExtrapolator', 
                                          Navigator = CombinedNavigator,
                                          MaterialEffectsUpdators = AtlasUpdators,