def __init__(self, name = 'AtlasVKalVxInJetFinder' ):
from __main__ import ToolSvc
mlog = logging.getLogger( 'AtlasVKalVxInJetFinder::__init__ ' )
mlog.info("entering")
#----------------- ATLAS magnetic field
from AthenaCommon.AppMgr import ServiceMgr
from MagFieldServices.MagFieldServicesConf import MagField__AtlasFieldSvc
ServiceMgr += MagField__AtlasFieldSvc("myAtlasFieldSvc");
#----------------- ATLAS extrapolator
from TrkExTools.AtlasExtrapolator import AtlasExtrapolator
SVAtlasExtrapolator=AtlasExtrapolator()
ToolSvc+=SVAtlasExtrapolator
#--------------------------
from TrkTrackSummaryTool.AtlasTrackSummaryTool import AtlasTrackSummaryTool
SVAtlasTrackSummaryTool = AtlasTrackSummaryTool()
ToolSvc += SVAtlasTrackSummaryTool
#-------------------------
# TrackParticle creator
#
from TrkParticleCreator.TrkParticleCreatorConf import Trk__TrackParticleCreatorTool
SVParticleCreatorTool = Trk__TrackParticleCreatorTool(name="SVParticleCreatorTool",
TrackSummaryTool=SVAtlasTrackSummaryTool,
UseTrackSummaryTool=False
)
ToolSvc += SVParticleCreatorTool
#----------------------
# VKalVrt vertex fitter
#
from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
SVertexFitterTool = Trk__TrkVKalVrtFitter(name="SVertexFitterTool",
Extrapolator=SVAtlasExtrapolator,
AtlasMagFieldSvc = "myAtlasFieldSvc"
)
ToolSvc += SVertexFitterTool
#----------------------
# Secondary vertex finder itself
#
from TrkVertexFitterUtils.TrkVertexFitterUtilsConf import Trk__FullLinearizedTrackFactory
SVLinearizedTrackFactory = Trk__FullLinearizedTrackFactory(name="SVLinearizedTrackFactory",Extrapolator = SVAtlasExtrapolator)
ToolSvc += SVLinearizedTrackFactory
from TrkVertexFitterUtils.TrkVertexFitterUtilsConf import Trk__TrackToVertexIPEstimator
SVTrackToVertexIPEstimator = Trk__TrackToVertexIPEstimator(name="SVTrackToVertexIPEstimator",
Extrapolator = SVAtlasExtrapolator,
LinearizedTrackFactory=SVLinearizedTrackFactory)
ToolSvc += SVTrackToVertexIPEstimator
InDet__InDetVKalVxInJetTool.__init__( self, name = name,
VertexFitterTool = SVertexFitterTool,
TrackParticleCreator = SVParticleCreatorTool,
TrackSummaryTool = SVAtlasTrackSummaryTool,
TrackToVertexTool = SVTrackToVertexIPEstimator
)
def ConfigurationComboHypo(self,
trigSequenceName='Dimu',
trigLevel='L2',
trackCollection='',
muonCollection=''):
trigLevelDict = {'L2': 0, 'EF': 1}
try:
value = trigLevelDict[trigLevel]
log.debug('TrigMultiTrkComboHypo.trigLevel = %s ', value)
except KeyError:
log.error(
'TrigMultiTrkComboHypo.trigLevel should be L2 or EF, but %s provided.',
trigLevel)
from TrkExTools.AtlasExtrapolator import AtlasExtrapolator
from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
VertexFitter = Trk__TrkVKalVrtFitter(name='TrigBphysFitter_' +
trigSequenceName + trigLevel,
FirstMeasuredPoint=False,
MakeExtendedVertex=False,
Extrapolator=AtlasExtrapolator())
from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__VertexPointEstimator
VertexPointEstimator = InDet__VertexPointEstimator(
name='VertexPointEstimator_' + trigSequenceName + trigLevel,
MinDeltaR=[-10000., -10000., -10000.],
MaxDeltaR=[10000., 10000., 10000.],
MaxPhi=[10000., 10000., 10000.],
MaxChi2OfVtxEstimation=2000.)
tool = TrigMultiTrkComboHypo(
name=trigSequenceName + trigLevel + 'ComboHypo',
trigLevel=trigLevel,
nTracks=2,
massRanges=[(100., 20000.)],
TrackCollectionKey=trackCollection,
MuonCollectionKey=muonCollection,
VertexFitter=VertexFitter,
VertexPointEstimator=VertexPointEstimator,
CheckMultiplicityMap=False,
MonTool=TrigMultiTrkComboHypoMonitoring(
'TrigMultiTrkComboHypoMonitoring_' + trigSequenceName +
trigLevel))
if trigLevel == 'EF':
tool.TrigBphysCollectionKey = 'HLT_' + trigSequenceName + trigLevel
return tool
def applySoftBtagging(algname, sequence):
from VrtSecInclusive.SoftBtagTrackSelector import SoftBtagTrackSelector
SoftBtagTrackSelector = SoftBtagTrackSelector()
SoftBtagTrackSelector.Jetcontainer = "AntiKt4EMTopoJets"
SoftBtagTrackSelector.InputTrackContainer = "InDetTrackParticles"
SoftBtagTrackSelector.OutputTrackContainer = "SoftBtagSeedTrackParticles"
sequence += SoftBtagTrackSelector
from AthenaCommon.AppMgr import ToolSvc
from VrtSecInclusive.VrtSecInclusive import VrtSecInclusive
VrtSecInclusive_SoftB = VrtSecInclusive("VrtSecInclusive_SoftB")
sequence += VrtSecInclusive_SoftB
# set options for vertexing
VrtSecInclusive_SoftB.TrackLocation = "SoftBtagSeedTrackParticles"
VrtSecInclusive_SoftB.SecondaryVerticesContainerName = "SoftBtagCandidateVertices"
VrtSecInclusive_SoftB.TruthParticleFilter = "Bhadron"
VrtSecInclusive_SoftB.DoTwoTrSoftBtag = True
VrtSecInclusive_SoftB.TwoTrVrtAngleCut = 0.7
VrtSecInclusive_SoftB.twoTrVrtMinDistFromPV = 0.2
VrtSecInclusive_SoftB.PassThroughTrackSelection = True
VrtSecInclusive_SoftB.ImpactWrtBL = False
VrtSecInclusive_SoftB.doPVcompatibilityCut = False
VrtSecInclusive_SoftB.RemoveFake2TrkVrt = True
VrtSecInclusive_SoftB.doReassembleVertices = False
VrtSecInclusive_SoftB.doMergeByShuffling = False
VrtSecInclusive_SoftB.doMergeFinalVerticesDistance = False
VrtSecInclusive_SoftB.doAssociateNonSelectedTracks = False
VrtSecInclusive_SoftB.doFinalImproveChi2 = False
VrtSecInclusive_SoftB.DoTruth = False
VrtSecInclusive_SoftB.SelVrtChi2Cut = 5.
VrtSecInclusive_SoftB.SelTrkMaxCutoff = 30
VrtSecInclusive_SoftB.twoTrkVtxFormingD0Cut = 0.
from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
InclusiveVxFitterTool = Trk__TrkVKalVrtFitter(
name="InclusiveVxFitter",
Extrapolator=ToolSvc.AtlasExtrapolator,
IterationNumber=30)
ToolSvc += InclusiveVxFitterTool
VrtSecInclusive_SoftB.VertexFitterTool = InclusiveVxFitterTool
VrtSecInclusive_SoftB.Extrapolator = ToolSvc.AtlasExtrapolator
def __init__(self, name="VrtSecInclusive"):
from __main__ import ToolSvc
mlog = logging.getLogger('VrtSecInclusive::__init__ ')
mlog.info("entering")
from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
TrkVKalVrtFitter = Trk__TrkVKalVrtFitter()
# print TrkVKalVrtFitter
ToolSvc += TrkVKalVrtFitter
from TrkTrackSummaryTool.AtlasTrackSummaryTool import AtlasTrackSummaryTool
AtlasTrackSummaryTool = AtlasTrackSummaryTool()
# print AtlasTrackSummaryTool
mlog.info("AtlasTrackSummaryTool for VrtSecInclusive created")
ToolSvc += AtlasTrackSummaryTool
VKalVrtAthena__VrtSecInclusive.__init__(self, name)
def __init__(self, name='SecVrtWithMuonFinder'):
from __main__ import ToolSvc
mlog = logging.getLogger('SecVrtWithMuonFinder::__init__ ')
mlog.info("entering")
#----------------------
# VKalVrt vertex fitter
#
from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
MuonVertexFitterTool = Trk__TrkVKalVrtFitter(
name="MuonVertexFitterTool",
Extrapolator="Trk::Extrapolator/AtlasExtrapolator")
ToolSvc += MuonVertexFitterTool
#----------------------
# Secondary vertex finder itself
#
InDet__InDetSVWithMuonTool.__init__(
self, name=name, VertexFitterTool=MuonVertexFitterTool)
def __init__(self, name = 'InDetVKalVxInJetFinder' ):
from __main__ import ToolSvc
mlog = logging.getLogger( 'InDetVKalVxInJetFinder::__init__ ' )
mlog.info("entering")
#----------------------
# VKalVrt vertex fitter
#
from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
SVertexFitterTool = Trk__TrkVKalVrtFitter(name="SVertexFitterTool",
Extrapolator="Trk::Extrapolator/AtlasExtrapolator",
AtlasMagFieldSvc = "AtlasFieldSvc"
#AtlasMagFieldSvc = "Default",
#Extrapolator = "DefaultVKalPropagator"
)
ToolSvc += SVertexFitterTool
#----------------------
# Secondary vertex finder itself
#
if hasattr(ToolSvc,'InDetParticleCreatorTool'):
InDet__InDetVKalVxInJetTool.__init__( self, name = name,
VertexFitterTool = SVertexFitterTool
)
else: #--------------------------------
# TrackParticle creator is needed
from TrkParticleCreator.TrkParticleCreatorConf import Trk__TrackParticleCreatorTool
if hasattr(ToolSvc,'InDetTrackSummaryTool'):
SVParticleCreatorTool = Trk__TrackParticleCreatorTool(name="SVParticleCreatorTool",
TrackSummaryTool="InDetTrackSummaryTool",
UseTrackSummaryTool=False )
else:
from TrkTrackSummaryTool.AtlasTrackSummaryTool import AtlasTrackSummaryTool
SVTrackSummaryTool = AtlasTrackSummaryTool(name="SVTrackSummaryTool")
ToolSvc += SVTrackSummaryTool
SVParticleCreatorTool = Trk__TrackParticleCreatorTool(name="SVParticleCreatorTool",
TrackSummaryTool=SVTrackSummaryTool,
UseTrackSummaryTool=False )
ToolSvc += SVParticleCreatorTool
InDet__InDetVKalVxInJetTool.__init__( self, name = name,
VertexFitterTool = SVertexFitterTool,
TrackParticleCreator = SVParticleCreatorTool
)
def __init__(self, name="InDetVKalPriVxFinder"):
from AthenaCommon.AppMgr import ToolSvc
mlog = logging.getLogger( 'InDetVKalPriVxFinder::__init__ ' )
mlog.info("entering")
from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
TrkVKalVrtPFitter = Trk__TrkVKalVrtFitter()
ToolSvc += TrkVKalVrtPFitter
from TrkTrackSummaryTool.AtlasTrackSummaryTool import AtlasTrackSummaryTool
AtlasTrackSummaryTool = AtlasTrackSummaryTool()
mlog.info("AtlasTrackSummaryTool for InDetVKalPriVxFinder created")
ToolSvc += AtlasTrackSummaryTool
InDet__InDetVKalPriVxFinderTool.__init__( self,name="InDetVKalPriVxFinderTool",
TrackSummaryTool=AtlasTrackSummaryTool,
FitterTool=TrkVKalVrtPFitter )
# --------------------------------------------------------------------------------------------- #
# Get ToolSvc and topSequence
from AthenaCommon.AppMgr import ToolSvc
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
from InDetRecExample.InDetKeys import InDetKeys
#
# --- load vertex fitter
#
from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
InDetSecVxFitterTool = Trk__TrkVKalVrtFitter(
name="InclusiveVxFitter",
Extrapolator=ToolSvc.AtlasExtrapolator,
IterationNumber=30,
AtlasMagFieldSvc="AtlasFieldSvc")
ToolSvc += InDetSecVxFitterTool
#
# Add driving algorithm
#
from VrtSecDecay.VrtSecDecayConf import VKalVrtAthena__VrtSecDecay
VrtSecDecayFinder = VKalVrtAthena__VrtSecDecay(
name="VrtSecDecayFinder",
VertexFitterTool=InDetSecVxFitterTool,
OutputVtxContainer=InDetKeys.xAODSecVertexDecayContainer(),
ParentxAODContainer=InDetKeys.xAODPixelThreeLayerTrackParticleContainer(),
ChildxAODContainer=InDetKeys.xAODTrackParticleContainer(),
from TrkExTools.AtlasExtrapolator import AtlasExtrapolator
InDetExtrapolator = AtlasExtrapolator(name="AtlasExtrapolator")
ToolSvc += InDetExtrapolator
print InDetExtrapolator
from TrkV0Fitter.TrkV0FitterConf import Trk__TrkV0VertexFitter
TrkV0Fitter = Trk__TrkV0VertexFitter(name="TrkV0FitterName",
MaxIterations=10,
Use_deltaR=False,
Extrapolator=InDetExtrapolator)
ToolSvc += TrkV0Fitter
print TrkV0Fitter
from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
TrkVKalVrtFitter = Trk__TrkVKalVrtFitter(name="VKalVrtFitter",
Extrapolator=InDetExtrapolator,
FirstMeasuredPoint=False,
MakeExtendedVertex=True)
ToolSvc += TrkVKalVrtFitter
print TrkVKalVrtFitter
from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__VertexPointEstimator
VtxPointEstimator = InDet__VertexPointEstimator(
name="VtxPointEstimator",
MinDeltaR=[-10000., -10000., -10000.],
MaxDeltaR=[10000., 10000., 10000.],
MaxPhi=[10000., 10000., 10000.],
MaxChi2OfVtxEstimation=2000.)
ToolSvc += VtxPointEstimator
print VtxPointEstimator
from InDetRecExample.InDetKeys import InDetKeys
topSequence.VrtSecInclusive.TrkZErrCut = 200000
topSequence.VrtSecInclusive.a0TrkPVDstMinCut = 2.0
topSequence.VrtSecInclusive.TrkPtCut = 1000
topSequence.VrtSecInclusive.SelVrtChi2Cut=5
topSequence.VrtSecInclusive.CutSharedHits=2
topSequence.VrtSecInclusive.TrkChi2Cut=50
topSequence.VrtSecInclusive.TruthTrkLen=1
topSequence.VrtSecInclusive.SelTrkMaxCutoff=300
topSequence.VrtSecInclusive.DoSAloneTRT=False
topSequence.VrtSecInclusive.DoTruth = (globalflags.DataSource == 'geant4' and globalflags.InputFormat == "pool")
topSequence.VrtSecInclusive.RemoveFake2TrkVrt = True
from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
InclusiveVxFitterTool = Trk__TrkVKalVrtFitter(name = "InclusiveVxFitter",
Extrapolator = ToolSvc.AtlasExtrapolator,
IterationNumber = 30,
AtlasMagFieldSvc = "AtlasFieldSvc"
)
ToolSvc += InclusiveVxFitterTool;
InclusiveVxFitterTool.OutputLevel = INFO
topSequence.VrtSecInclusive.VertexFitterTool=InclusiveVxFitterTool
topSequence.VrtSecInclusive.Extrapolator = ToolSvc.AtlasExtrapolator
# Tell VrtSecInclusive the interface name for Trk::IVertexMapper
from TrkDetDescrTestTools.TrkDetDescrTestToolsConf import Trk__VertexMapper
HadronicVertexMapper = Trk__VertexMapper("HadronicVertexMapper")
ToolSvc += HadronicVertexMapper
topSequence.VrtSecInclusive.VertexMapper = HadronicVertexMapper
# Now add the new vertex collection to the output DAOD_RPVLL file
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
ToolSvc += InDetTrackSummaryHelperTool
from TrkTrackSummaryTool.TrkTrackSummaryToolConf import Trk__TrackSummaryTool
InDetTrackSummaryTool = Trk__TrackSummaryTool(name = 'InDetTrackSummaryTool',
InDetSummaryHelperTool = InDetTrackSummaryHelperTool,
doSharedHits = False,
InDetHoleSearchTool = InDetHoleSearchTool)
ToolSvc += InDetTrackSummaryTool
#------------------------------------------------------------------------------
# Configure vertex fitters
#------------------------------------------------------------------------------
from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
TrkVKalVrtFitter = Trk__TrkVKalVrtFitter(name = 'VKalVrtFitterName',
Extrapolator = InDetExtrapolator,
MagFieldSvc = InDetMagField,
FirstMeasuredPoint = True,
#FirstMeasuredPointLimit = True,
MakeExtendedVertex = True)
ToolSvc += TrkVKalVrtFitter
print TrkVKalVrtFitter
from TrkV0Fitter.TrkV0FitterConf import Trk__TrkV0VertexFitter
TrkV0Fitter = Trk__TrkV0VertexFitter(name = 'TrkV0FitterName',
MaxIterations = 10,
Use_deltaR = False,
Extrapolator = InDetExtrapolator,
MagneticFieldTool = InDetMagField)
ToolSvc += TrkV0Fitter
print TrkV0Fitter
#------------------------------------------------------------------------------
#
#load adaptive multi vertex fitter
#
from TrkVertexFitters.TrkVertexFittersConf import Trk__AdaptiveMultiVertexFitter
InDetVxFitterTool = Trk__AdaptiveMultiVertexFitter(name = "InDetAdaptiveMultiVertexFitter",
LinearizedTrackFactory = InDetLinFactory,
ImpactPoint3dAtaPlaneFactory = InDetIp3dAtaPointFactory,
AnnealingMaker = InDetAnnealingMaker,
DoSmoothing = True) # false is default
elif InDetFlags.primaryVertexSetup() == 'DefaultVKalVrtFinding':
#
#load vkal fitter
#
from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
InDetVxFitterTool = Trk__TrkVKalVrtFitter(name = "InDetVKalVrtFitter")
ToolSvc += InDetVxFitterTool
if InDetFlags.doPrintConfigurables: print InDetVxFitterTool
#
# ----- load vertex finder tool
#
# LEVEL 1
if not (InDetFlags.primaryVertexSetup() == 'AdaptiveFinding') and not (InDetFlags.primaryVertexSetup() == 'AdaptiveMultiFinding') and not (InDetFlags.primaryVertexSetup() == 'DefaultVKalVrtFinding'):
#
# load primary vertex finder tool
#
from InDetPriVxFinderTool.InDetPriVxFinderToolConf import InDet__InDetPriVxFinderTool
InDetPriVxFinderTool = InDet__InDetPriVxFinderTool(name = "InDetPriVxFinderTool",
HypothesisName="Jpsi",
InputVtxContainerName="MUON2JpsiCandidates",
VtxMassHypo=3096.916,
MassMin=2000.0,
MassMax=3600.0,
Chi2Max=200,
DoVertexType=1)
ToolSvc += MUON2_Select_Jpsi2mumu
printfunc(MUON2_Select_Jpsi2mumu)
## 4/ setup a new vertexing tool (necessary due to use of mass constraint)
from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
BsKKVertexFit = Trk__TrkVKalVrtFitter(
name="BsKKVertexFit",
Extrapolator=MUON2_VertexTools.InDetExtrapolator,
FirstMeasuredPoint=True,
MakeExtendedVertex=True)
ToolSvc += BsKKVertexFit
printfunc(BsKKVertexFit)
from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
BplKplVertexFit = Trk__TrkVKalVrtFitter(
name="BplKplVertexFit",
Extrapolator=MUON2_VertexTools.InDetExtrapolator,
FirstMeasuredPoint=True,
MakeExtendedVertex=True)
ToolSvc += BplKplVertexFit
printfunc(BplKplVertexFit)
## 5/ setup the Jpsi+2 track finder
def __init__(self,
name="InDetTrigConversionFinder_Electron_EFID",
type="electron"):
super(InDet__TrigConversionFinder, self).__init__(name)
from AthenaCommon.AppMgr import ToolSvc
from InDetTrigRecExample.InDetTrigFlags import InDetTrigFlags
from InDetTrigRecExample.InDetTrigSliceSettings import InDetTrigSliceSettings
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import \
InDetTrigExtrapolator, InDetTrigTrackSummaryTool
#
from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
InDetTrigConversionVxFitterTool = Trk__TrkVKalVrtFitter(
name="InDetTrigConversionVxFitter",
Extrapolator=InDetTrigExtrapolator,
IterationNumber=30,
MakeExtendedVertex=True,
FirstMeasuredPoint=True,
# MagFieldSvc = InDetTrigMagField,
Robustness=6,
usePhiCnst=True,
useThetaCnst=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 += InDetTrigConversionVxFitterTool
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigConversionVxFitterTool
# Distance of minimum approach utility
#
from TrkVertexSeedFinderUtils.TrkVertexSeedFinderUtilsConf import Trk__SeedNewtonTrkDistanceFinder
InDetTrigConversionTrkDistanceFinder = Trk__SeedNewtonTrkDistanceFinder(
name='InDetTrigConversionTrkDistanceFinder')
ToolSvc += InDetTrigConversionTrkDistanceFinder
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigConversionTrkDistanceFinder
# Helper Tool
#
from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__ConversionFinderUtils
InDetTrigConversionHelper = InDet__ConversionFinderUtils(
name="InDetTrigConversionFinderUtils",
#OutputLevel = 1
)
ToolSvc += InDetTrigConversionHelper
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigConversionHelper
# Track selector tool
#
from InDetTrackSelectorTool.InDetTrackSelectorToolConf import InDet__InDetConversionTrackSelectorTool
InDetTrigConversionTrackSelector = InDet__InDetConversionTrackSelectorTool(
name="InDetTrigConversionTrackSelector",
TrackSummaryTool=InDetTrigTrackSummaryTool,
Extrapolator=InDetTrigExtrapolator,
maxSiD0=10000., #50.0,
maxTrtD0=10000., #100.,
maxSiZ0=10000., #350.0,
maxTrtZ0=10000., #1400.,
minPt=InDetTrigSliceSettings[('pTmin', type)],
RatioCut1=0.0, #0.5,
RatioCut2=0.1,
RatioCut3=0.1)
ToolSvc += InDetTrigConversionTrackSelector
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigConversionTrackSelector
# Track pairs selector
#
from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__TrackPairsSelector
InDetTrigConversionTrackPairsSelector = InDet__TrackPairsSelector(
name="InDetTrigConversionTrackPairsSelector",
ConversionFinderHelperTool=InDetTrigConversionHelper,
DistanceTool=InDetTrigConversionTrkDistanceFinder,
MaxFirstHitRadius=500.,
#OutputLevel = 1,
MaxDistBetweenTracks=[10., 50., 50.], #[6.,80.,30.],
MaxEta=[0.3, 0.5, 0.5] #[0.5,1.0,0.5]
)
ToolSvc += InDetTrigConversionTrackPairsSelector
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigConversionTrackPairsSelector
# Vertex point estimator
#
from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__VertexPointEstimator
InDetTrigConversionVtxPointEstimator = InDet__VertexPointEstimator(
name="InDetTrigConversionVtxPointEstimator",
MinDeltaR=[-5., -25., -50.],
MaxDeltaR=[5., 10., 10.],
MaxPhi=[0.05, 0.5, 0.5]) #[0.05, 0.1, 0.1])
ToolSvc += InDetTrigConversionVtxPointEstimator
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigConversionVtxPointEstimator
# Conversion post selector
#
from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__ConversionPostSelector
InDetTrigConversionPostSelector = InDet__ConversionPostSelector(
name="InDetTrigConversionPostSelector",
MaxChi2Vtx=[50., 50., 50.], #[40.,100.,80.],
MaxInvariantMass=[10000., 10000., 10000.], #[60.,60.,30.],
MinFitMomentum=[0., 0., 0.], #[2000.,2000.,2000.],
MinRadius=[-10000., -10000., -10000.], #[30.,35.,250.],
MinPt=0.,
MaxdR=-10000., #-250.,
MaxPhiVtxTrk=10000.) #0.2)
ToolSvc += InDetTrigConversionPostSelector
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigConversionPostSelector
# Single track conversion tool
#
from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__SingleTrackConversionTool
InDetTrigSingleTrackConversion = InDet__SingleTrackConversionTool(
name="InDetTrigSingleTrackConversionTool",
ConversionFinderHelperTool=InDetTrigConversionHelper,
TrackSummaryTool=InDetTrigTrackSummaryTool,
Extrapolator=InDetTrigExtrapolator,
MinInitialHitRadius=70.,
MinRatioOfHLhits=0.95)
ToolSvc += InDetTrigSingleTrackConversion
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigSingleTrackConversion
from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__InDetConversionFinderTools
InDetTrigConversionFinderTools = InDet__InDetConversionFinderTools(
name="InDetTrigConversionFinderTools",
VertexFitterTool=InDetTrigConversionVxFitterTool,
TrackSelectorTool=InDetTrigConversionTrackSelector,
TrackPairsSelector=InDetTrigConversionTrackPairsSelector,
ConversionFinderHelperTool=InDetTrigConversionHelper,
VertexPointEstimator=InDetTrigConversionVtxPointEstimator,
PostSelector=InDetTrigConversionPostSelector,
SingleTrackConversionTool=InDetTrigSingleTrackConversion,
Extrapolator=InDetTrigExtrapolator,
RemoveTrtTracks=False,
#OutputLevel = 1,
IsConversion=True)
ToolSvc += InDetTrigConversionFinderTools
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigConversionFinderTools
self.VertexFinderTool = InDetTrigConversionFinderTools
#monitoring
from InDetTrigConversionFinder.InDetTrigConversionFinderMonitoring import InDetTrigConversionFinderValidationMonitor
from InDetTrigConversionFinder.InDetTrigConversionFinderMonitoring import InDetTrigConversionFinderOnlineMonitor
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
convtime = TrigTimeHistToolConfig("ConvVxTime")
convtime.TimerHistLimits = [0, 200]
self.AthenaMonTools = [
InDetTrigConversionFinderValidationMonitor(),
InDetTrigConversionFinderOnlineMonitor(), convtime
]
ToolSvc += InDetV0Fitter
#InDetV0Fitter.OutputLevel = DEBUG
if (InDetFlags.doPrintConfigurables()):
print InDetV0Fitter
#
InDetVKVertexFitter = None
InDetKshortFitter = None
InDetLambdaFitter = None
InDetLambdabarFitter = None
else:
InDetV0Fitter = None
#
from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
InDetVKVertexFitter = Trk__TrkVKalVrtFitter(
name="InDetVKVFitter",
Extrapolator="Trk::Extrapolator/InDetExtrapolator",
IterationNumber=30,
MakeExtendedVertex=True,
FirstMeasuredPoint=True)
ToolSvc += InDetVKVertexFitter
#InDetVKVertexFitter.OutputLevel = DEBUG
if (InDetFlags.doPrintConfigurables()):
print InDetVKVertexFitter
#
from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
InDetKshortFitter = Trk__TrkVKalVrtFitter(
name="InDetVKKVFitter",
Extrapolator="Trk::Extrapolator/InDetExtrapolator",
IterationNumber=30,
MakeExtendedVertex=True,
FirstMeasuredPoint=True,
InputParticleMasses=[139.57, 139.57],
TrZ0Max=1500.,
TrMinSctHits=2,
TrMaxSharedHits=2,
TrMinPixelHitsNoTRT=2,
VxChi2Max=5.)
from TrkExTools.AtlasExtrapolator import AtlasExtrapolator
AtlasExtrapolator = AtlasExtrapolator()
ToolSvc += AtlasExtrapolator
# set up vertexer
from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
ToolSvc += Trk__TrkVKalVrtFitter(name="CombBkgVxFitter",
Extrapolator=ToolSvc.AtlasExtrapolator,
IterationNumber=30,
AtlasMagFieldSvc="AtlasFieldSvc")
from RecExConfig.RecFlags import rec
rec.AutoConfiguration = ["everything"]
rec.doCBNT.set_Value_and_Lock(False)
rec.doWriteESD.set_Value_and_Lock(False)
rec.doWriteAOD.set_Value_and_Lock(False)
rec.doWriteTAG.set_Value_and_Lock(False)
rec.doESD.set_Value_and_Lock(False)
rec.doAOD.set_Value_and_Lock(False)
rec.doDPD.set_Value_and_Lock(False)
rec.doHist.set_Value_and_Lock(False)
rec.doPerfMon.set_Value_and_Lock(False)
rec.doForwardDet.set_Value_and_Lock(False)
topSequence = AlgSequence()
theApp.EvtMax = 2
from xAODEventInfoCnv.xAODEventInfoCnvConf import xAODMaker__EventInfoCnvAlg
eialg = xAODMaker__EventInfoCnvAlg()
topSequence += eialg
# Suppress useless GeoModelSvc messages.
from AthenaCommon import Constants
GeoModelSvc().OutputLevel = Constants.WARNING
#from AthenaCommon.GlobalFlags import globalflags
#from InDetRecExample.InDetJobProperties import InDetFlags
#include ('InDetRecExample/InDetRecLoadTools.py')
from TrkExTools.AtlasExtrapolator import AtlasExtrapolator
from TrkVKalVrtFitter.TrkVKalVrtFitterConf import \
Trk__TrkVKalVrtFitterTestAlg, Trk__TrkVKalVrtFitter
fitter = Trk__TrkVKalVrtFitter(
'TrkVKalVrtFitter',
Extrapolator=AtlasExtrapolator(),
#Extrapolator = 'Trk::Extrapolator/InDetExtrapolator',
#Extrapolator = 'DefaultVKalPropagator',
OutputLevel=INFO)
testalg1 = Trk__TrkVKalVrtFitterTestAlg('testalg1',
OutputLevel=VERBOSE,
Tool=fitter)
topSequence += testalg1
def __init__(self,
prefix="",
VertexCuts=None,
TrackParticles=None,
SecVertices=None,
Extrapolator=None,
TrackSummaryTool=None,
MagFieldSvc=None,
printConfig=False):
# get ToolSvc and topSequence
from AthenaCommon.AppMgr import ToolSvc
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
# get InDetFlags
from InDetRecExample.InDetJobProperties import InDetFlags
#
# --- load vertex fitter
#
from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
InDetSecVxFitterTool = Trk__TrkVKalVrtFitter(
name=prefix + "Fitter",
Extrapolator=Extrapolator,
IterationNumber=VertexCuts.Fitter_IterationNumber(),
MakeExtendedVertex=VertexCuts.Fitter_MakeExtendedVertex(),
FirstMeasuredPoint=VertexCuts.Fitter_FirstMeasuredPoint(),
Robustness=VertexCuts.Fitter_Robustness(),
InputParticleMasses=VertexCuts.Fitter_InputParticleMasses(),
VertexForConstraint=VertexCuts.Fitter_VertexForConstraint(),
CovVrtForConstraint=VertexCuts.Fitter_CovVrtForConstraint(),
FirstMeasuredPointLimit=VertexCuts.FirstMeasuredPointLimit(),
usePhiCnst=VertexCuts.usePhiCnst(),
useThetaCnst=VertexCuts.useThetaCnst())
ToolSvc += InDetSecVxFitterTool
if (printConfig):
print InDetSecVxFitterTool
#
# --- Distance of minimum approach utility
#
from TrkVertexSeedFinderUtils.TrkVertexSeedFinderUtilsConf import Trk__SeedNewtonTrkDistanceFinder
InDetSecVxTrkDistanceFinder = Trk__SeedNewtonTrkDistanceFinder(
name=prefix + 'TrkDistanceFinder')
ToolSvc += InDetSecVxTrkDistanceFinder
if (printConfig):
print InDetSecVxTrkDistanceFinder
#
# --- Helper Tool
#
from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__ConversionFinderUtils
InDetSecVxHelper = InDet__ConversionFinderUtils(name=prefix +
"FinderUtils")
ToolSvc += InDetSecVxHelper
if (printConfig):
print InDetSecVxHelper
#
# --- Track selector tool
#
from InDetTrackSelectorTool.InDetTrackSelectorToolConf import InDet__InDetConversionTrackSelectorTool
InDetSecVxTrackSelector = InDet__InDetConversionTrackSelectorTool(
name=prefix + "TrackSelector",
TrackSummaryTool=TrackSummaryTool,
Extrapolator=Extrapolator,
maxSiD0=VertexCuts.TrkSel_maxSiD0(),
maxTrtD0=VertexCuts.TrkSel_maxTrtD0(),
maxSiZ0=VertexCuts.TrkSel_maxSiZ0(),
maxTrtZ0=VertexCuts.TrkSel_maxTrtZ0(),
minPt=VertexCuts.TrkSel_minPt(),
RatioCut1=VertexCuts.TrkSel_RatioCut1(),
RatioCut2=VertexCuts.TrkSel_RatioCut2(),
RatioCut3=VertexCuts.TrkSel_RatioCut3(),
RatioTRT=VertexCuts.TrkSel_RatioTRT(),
IsConversion=VertexCuts.TrkSel_IsConversion(),
significanceD0_Si=VertexCuts.TrkSel_significanceD0_Si(),
RatioV0=VertexCuts.TrkSel_RatioV0())
ToolSvc += InDetSecVxTrackSelector
if (printConfig):
print InDetSecVxTrackSelector
#
# Track pairs selector
#
from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__TrackPairsSelector
InDetSecVxTrackPairsSelector = InDet__TrackPairsSelector(
name=prefix + "TrackPairsSelector",
ConversionFinderHelperTool=InDetSecVxHelper,
DistanceTool=InDetSecVxTrkDistanceFinder,
MaxFirstHitRadius=VertexCuts.TrkPairSel_MaxFirstHitRadius(),
MaxDistBetweenTracks=VertexCuts.TrkPairSel_MaxDistBetweenTracks(),
MaxEta=VertexCuts.TrkPairSel_MaxEta(),
MaxInitDistance=VertexCuts.TrkPairSel_MaxInitDistance(),
MinTrackAngle=VertexCuts.TrkPairSel_MinTrackAngle())
ToolSvc += InDetSecVxTrackPairsSelector
if (printConfig):
print InDetSecVxTrackPairsSelector
#
# Vertex point estimator
#
from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__VertexPointEstimator
InDetSecVtxPointEstimator = InDet__VertexPointEstimator(
name=prefix + "PointEstimator",
MinDeltaR=VertexCuts.VtxPt_MinDeltaR(),
MaxDeltaR=VertexCuts.VtxPt_MaxDeltaR(),
MaxPhi=VertexCuts.VtxPt_MaxPhi())
ToolSvc += InDetSecVtxPointEstimator
if (printConfig):
print InDetSecVtxPointEstimator
#
# Secondary Vertex post selector
#
from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__ConversionPostSelector
InDetSecVtxPostSelector = InDet__ConversionPostSelector(
name=prefix + "PostSelector",
MaxChi2Vtx=VertexCuts.SecVtxPost_MaxChi2Vtx(),
MaxInvariantMass=VertexCuts.SecVtxPost_MaxInvariantMass(),
MinFitMomentum=VertexCuts.SecVtxPost_MinFitMomentum(),
MinRadius=VertexCuts.SecVtxPost_MinRadius(),
MinPt=VertexCuts.SecVtxPost_MinPt(),
MaxdR=VertexCuts.SecVtxPost_MaxdR(),
MaxPhiVtxTrk=VertexCuts.SecVtxPost_MaxPhiVtxTrk())
ToolSvc += InDetSecVtxPostSelector
if (printConfig):
print InDetSecVtxPostSelector
#
# Single track secondary vertex tool
#
from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__SingleTrackConversionTool
InDetSingleTrackSecVtx = InDet__SingleTrackConversionTool(
name=prefix + "SingleTrackTool",
ConversionFinderHelperTool=InDetSecVxHelper,
TrackSummaryTool=TrackSummaryTool,
Extrapolator=Extrapolator,
MaxBLayerHits=VertexCuts.SingleTrk_MaxBLayerHits(),
MinInitialHitRadius=VertexCuts.SingleTrk_MinInitialHitRadius(),
MinInitialHitRadius_noBlay=VertexCuts.
SingleTrk_MinInitialHitRadius_noBlay(),
MinRatioOfHLhits=VertexCuts.SingleTrk_MinRatioOfHLhits())
ToolSvc += InDetSingleTrackSecVtx
if (printConfig):
print InDetSingleTrackSecVtx
#
# conversion finder tool
#
from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__InDetConversionFinderTools
InDetSecVtxFinderTool = InDet__InDetConversionFinderTools(
name=prefix + "FinderTool",
VertexFitterTool=InDetSecVxFitterTool,
TrackSelectorTool=InDetSecVxTrackSelector,
TrackPairsSelector=InDetSecVxTrackPairsSelector,
ConversionFinderHelperTool=InDetSecVxHelper,
VertexPointEstimator=InDetSecVtxPointEstimator,
PostSelector=InDetSecVtxPostSelector,
SingleTrackConversionTool=InDetSingleTrackSecVtx,
Extrapolator=Extrapolator,
TrackParticleCollection=TrackParticles,
RemoveTrtTracks=VertexCuts.Finder_RemoveTrtTracks(),
IsConversion=VertexCuts.Finder_IsConversion(),
MinDistVtxHit=VertexCuts.Finder_MinDistVtxHit(),
MaxDistVtxHit=VertexCuts.Finder_MaxDistVtxHit(),
MinFlightAngle=VertexCuts.Finder_MinFlightAngle(),
MinInitVtxR=VertexCuts.Finder_MinInitVtxR())
ToolSvc += InDetSecVtxFinderTool
if (printConfig):
print InDetSecVtxFinderTool
# --- remember instances
self.__prefix = prefix
self.__InDetSecVtxFinderTool = InDetSecVtxFinderTool
self.__TrackParticles = TrackParticles
self.__SecVertices = SecVertices
self.__printConfig = printConfig
self.__topSequence = topSequence
topSequence.VrtSecInclusive.DoSAloneTRT=False
topSequence.VrtSecInclusive.DoTruth = False
# following is when there is no GEN_AOD in input file,
# e.g., when I run on output of InDetRecExample or on a ESD file
# when running on AOD output of InDetRecEx, explicitly uncomment the next line and comment out rec.readESD
# topSequence.VrtSecInclusive.MCEventContainer = "TruthEvent"
if rec.readESD():
topSequence.VrtSecInclusive.MCEventContainer = "TruthEvent"
if 'IS_SIMULATION' in metadata['eventTypes']:
topSequence.VrtSecInclusive.DoTruth=True
from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
InclusiveVxFitterTool = Trk__TrkVKalVrtFitter(name = "InclusiveVxFitter",
Extrapolator = ToolSvc.AtlasExtrapolator,
IterationNumber = 30
)
ToolSvc += InclusiveVxFitterTool;
InclusiveVxFitterTool.OutputLevel = INFO
topSequence.VrtSecInclusive.VertexFitterTool=InclusiveVxFitterTool
topSequence.VrtSecInclusive.Extrapolator = ToolSvc.AtlasExtrapolator
print VrtSecInclusive
# The input file
ServiceMgr.EventSelector.InputCollections = jp.AthenaCommonFlags.FilesInput()
##########################################
# setup TTree registration Service
# save ROOT histograms and NTuple
# Avoid double inclusion:
#include.block( "TrigBphysHypo/TrigBphysVertexingConfig.py" )
# Set up the TrigBphysHelperUtils to use special configuration of VertexFitter
from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
from TrigBphysHypo.TrigBphysHypoConf import TrigBphysHelperUtilsTool
from AthenaCommon.AppMgr import ToolSvc
#from TrkExTools.AtlasExtrapolator import AtlasExtrapolator
#TrigBphysExtrapolator = AtlasExtrapolator()
#ToolSvc += TrigBphysExtrapolator
#print TrigBphysExtrapolator
trigBphysFitter = Trk__TrkVKalVrtFitter("TrigBphysFitter",
FirstMeasuredPoint = False,
MakeExtendedVertex = True,
#OutputLevel = 2,
Extrapolator = "Trk::Extrapolator/InDetExtrapolator",
)
ToolSvc += trigBphysFitter
ToolSvc += TrigBphysHelperUtilsTool(VertexFitterTool = ToolSvc.TrigBphysFitter,
#OutputLevel=2
)
# fitter and helper tool with legacy configuration
trigBphysFitterLegacy = Trk__TrkVKalVrtFitter("TrigBphysFitterLegacy",
#OutputLevel = 2,
)
ToolSvc += trigBphysFitterLegacy
trigBphysHelperUtilsToolLegacy = TrigBphysHelperUtilsTool("TrigBphysHelperUtilsToolLegacy",
VertexFitterTool = ToolSvc.TrigBphysFitterLegacy,
#OutputLevel = 2,
def GeneralVertexer(system='Combined', setup=None, tracksName=None, suffix=""):
""" attempt to make a simple tool for any type of combination of vertexing """
ToolSvc = Service('ToolSvc')
hasPix = True if system in ['Combined', 'Pix', 'Resolved'] else False
hasSCT = True if system in ['Combined', 'SCT', 'Resolved'] else False
hasTRT = True if system in ['Combined', 'TRT'] else False
nHitBLayer = InDetPrimaryVertexingCuts.nHitBLayer() if hasPix else 0
nHitPix = InDetPrimaryVertexingCuts.nHitPix() if hasPix else 0
nHitBLayerPlusPix = InDetPrimaryVertexingCuts.nHitBLayerPlusPix(
) if hasPix else 0
nHitSct = InDetPrimaryVertexingCuts.nHitSct() if hasSCT else 0
nHitSi = InDetPrimaryVertexingCuts.nHitSi() if hasSCT else 0
nHitTrt = InDetPrimaryVertexingCuts.nHitTrt() if hasTRT else 0
vxSetup = InDetFlags.primaryVertexSetup() if setup == None else setup
print "JW: Setup is: ", system, hasPix, hasSCT, hasTRT, tracksName, setup, vxSetup
#Extras
try:
InDetTrackZ0SortingTool = ToolSvc.InDetTrackZ0SortingTool
except:
from InDetMultipleVertexSeedFinderUtils.InDetMultipleVertexSeedFinderUtilsConf import InDet__InDetTrackZ0SortingTool
InDetTrackZ0SortingTool = InDet__InDetTrackZ0SortingTool(
name="InDetTrackZ0SortingTool")
ToolSvc += InDetTrackZ0SortingTool
if (InDetFlags.doPrintConfigurables()):
print InDetTrackZ0SortingTool
try:
InDetSlidingWindowMultiSeedFinder = ToolSvc.InDetSlidingWindowMultiSeedFinder
except:
from InDetMultipleVertexSeedFinder.InDetMultipleVertexSeedFinderConf import InDet__SlidingWindowMultiSeedFinder
InDetSlidingWindowMultiSeedFinder = InDet__SlidingWindowMultiSeedFinder(
name="InDetSlidingWindowMultiSeedFinder",
clusterLength=5. * mm,
TrackSelector=InDetTrackSelectorTool,
Extrapolator=InDetExtrapolator,
SortingTool=InDetTrackZ0SortingTool,
#UseMaxInCluster = True
)
ToolSvc += InDetSlidingWindowMultiSeedFinder
#Load additional fitters:
try:
InDetVKalVrtFitter = ToolSvc.InDetVKalVrtFitter
print " JW Found InDetVKalVrtFitter"
except:
print " JW no InDetVKalVrtFitter"
from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
InDetVKalVrtFitter = Trk__TrkVKalVrtFitter(name="InDetVKalVrtFitter")
ToolSvc += InDetVKalVrtFitter
if (InDetFlags.doPrintConfigurables()):
print InDetVKalVrtFitter
try:
InDetVxFitterToolFastFinder = ToolSvc.InDetVxFitterToolFastFinder
print " JW: found InDetVxFitterToolFastFinder"
except:
print "JW no InDetVxFitterToolFastFinder"
from TrkVertexBilloirTools.TrkVertexBilloirToolsConf import Trk__FastVertexFitter
InDetVxFitterToolFastFinder = Trk__FastVertexFitter(
name="InDetVxFitterToolFastFinder",
LinearizedTrackFactory=InDetLinFactory,
Extrapolator=InDetExtrapolator)
ToolSvc += InDetVxFitterToolFastFinder
if (InDetFlags.doPrintConfigurables()):
print InDetVxFitterToolFastFinder
try:
InDetVxFitterToolFullFinder = ToolSvc.InDetVxFitterToolFullFinder
print "JW found InDetVxFitterToolFullFinder"
except:
print "JW no InDetVxFitterToolFullFinder"
from TrkVertexBilloirTools.TrkVertexBilloirToolsConf import Trk__FullVertexFitter
InDetVxFitterToolFullFinder = Trk__FullVertexFitter(
name="InDetVxFitterToolFullFinder",
LinearizedTrackFactory=InDetLinFactory,
Extrapolator=InDetExtrapolator)
ToolSvc += InDetVxFitterToolFullFinder
if (InDetFlags.doPrintConfigurables()):
print InDetVxFitterToolFullFinder
try:
print "JW Found InDetVxFitterToolSequential"
except:
print "JW no InDetVxFitterToolSequential"
from TrkVertexFitters.TrkVertexFittersConf import Trk__SequentialVertexSmoother
InDetVertexSmoother = Trk__SequentialVertexSmoother(
name="InDetVertexSmoother")
ToolSvc += InDetVertexSmoother
if (InDetFlags.doPrintConfigurables()):
print InDetVertexSmoother
from TrkVertexFitters.TrkVertexFittersConf import Trk__SequentialVertexFitter
InDetVxFitterToolSequential = Trk__SequentialVertexFitter(
name="InDetSequentialVxFitterTool",
LinearizedTrackFactory=InDetLinFactory,
VertexSmoother=InDetVertexSmoother
#VertexUpdator = # no setting required
)
ToolSvc += InDetVxFitterToolSequential
if (InDetFlags.doPrintConfigurables()):
print InDetVxFitterToolSequential
from InDetTrackSelectorTool.InDetTrackSelectorToolConf import InDet__InDetDetailedTrackSelectorTool
InDetTrackSelectorTool_vx = InDet__InDetDetailedTrackSelectorTool(
name="InDetDetailedTrackSelectorTool_" + system + "_" + vxSetup +
suffix,
pTMin=InDetPrimaryVertexingCuts.minPT(),
IPd0Max=InDetPrimaryVertexingCuts.IPd0Max(),
IPz0Max=InDetPrimaryVertexingCuts.IPz0Max(),
z0Max=InDetPrimaryVertexingCuts.z0Max(),
sigIPd0Max=InDetPrimaryVertexingCuts.sigIPd0Max(),
sigIPz0Max=InDetPrimaryVertexingCuts.sigIPz0Max(),
d0significanceMax=InDetPrimaryVertexingCuts.d0significanceMax(),
z0significanceMax=InDetPrimaryVertexingCuts.z0significanceMax(),
etaMax=InDetPrimaryVertexingCuts.etaMax(),
useTrackSummaryInfo=InDetPrimaryVertexingCuts.useTrackSummaryInfo(),
nHitBLayer=nHitBLayer,
nHitPix=nHitPix,
nHitBLayerPlusPix=nHitBLayerPlusPix,
nHitSct=nHitSct,
nHitSi=nHitSi,
nHitTrt=nHitTrt,
nHitTrtHighEFractionMax=InDetPrimaryVertexingCuts.
nHitTrtHighEFractionMax(),
nHitTrtHighEFractionWithOutliersMax=InDetPrimaryVertexingCuts.
nHitTrtHighEFractionWithOutliersMax(),
useSharedHitInfo=InDetPrimaryVertexingCuts.useSharedHitInfo(),
useTrackQualityInfo=InDetPrimaryVertexingCuts.useTrackQualityInfo(),
fitChi2OnNdfMax=InDetPrimaryVertexingCuts.fitChi2OnNdfMax(),
TrtMaxEtaAcceptance=InDetPrimaryVertexingCuts.TrtMaxEtaAcceptance(),
TrackSummaryTool=InDetTrackSummaryTool,
Extrapolator=InDetExtrapolator)
ToolSvc += InDetTrackSelectorTool_vx
if (InDetFlags.doPrintConfigurables()):
print InDetTrackSelectorTool_vx
# -----------------------------------------
#
# ----- load primary vertex finder tool
#
# -----------------------------------------
if (not (vxSetup == 'AdaptiveFinding')
and not (vxSetup == 'AdaptiveMultiFinding')
and not (vxSetup == 'DefaultVKalVrtFinding')
and not (vxSetup == 'InDetPriVxFinderFullFinder')
and not (vxSetup == 'InDetPriVxFinderFastFinder')):
#
# --- load primary vertex finder tool
#
from InDetPriVxFinderTool.InDetPriVxFinderToolConf import InDet__InDetPriVxFinderTool
InDetPriVxFinderTool_vx = InDet__InDetPriVxFinderTool(
name="InDetPriVxFinderTool_" + system + "_" + vxSetup + suffix,
PriVxSeedFinder=InDetMultiSeedFinder,
TrackSelector=InDetTrackSelectorTool_vx,
VertexFitterTool=InDetVxFitterTool,
chi2CutMethod=2,
useBeamConstraint=InDetFlags.useBeamConstraint())
if jobproperties.Beam.numberOfCollisions(
) > 2.0: # 900 GeV running at "zero lumi" has 2.0 for this variable
InDetPriVxFinderTool_vx.enableMultipleVertices = 1
else:
InDetPriVxFinderTool_vx.enableMultipleVertices = 0
if rec.Commissioning():
InDetPriVxFinderTool_vx.maxChi2PerTrack = 15.
elif vxSetup == 'AdaptiveFinding':
#
# --- load adaptive primary vertex finder
#
from InDetPriVxFinderTool.InDetPriVxFinderToolConf import InDet__InDetIterativePriVxFinderTool
InDetPriVxFinderTool_vx = InDet__InDetIterativePriVxFinderTool(
name="InDetIterativePriVxFinderTool_" + system + "_" + vxSetup +
suffix,
VertexFitterTool=InDetVxFitterTool,
TrackSelector=InDetTrackSelectorTool_vx,
SeedFinder=InDetVtxSeedFinder,
ImpactPoint3dEstimator=InDetImpactPoint3dEstimator,
LinearizedTrackFactory=InDetLinFactory,
useBeamConstraint=InDetFlags.useBeamConstraint(),
significanceCutSeeding=12,
maximumChi2cutForSeeding=49,
maxVertices=25)
elif vxSetup == 'AdaptiveMultiFinding':
#
# --- load adaptive multi primary vertex finder
#
from InDetPriVxFinderTool.InDetPriVxFinderToolConf import InDet__InDetAdaptiveMultiPriVxFinderTool
InDetPriVxFinderTool_vx = InDet__InDetAdaptiveMultiPriVxFinderTool(
name="InDetAdaptiveMultiPriVxFinderTool_" + system + "_" +
vxSetup + suffix,
SeedFinder=InDetVtxSeedFinder,
VertexFitterTool=InDetVxFitterTool,
TrackSelector=InDetTrackSelectorTool_vx,
useBeamConstraint=InDetFlags.useBeamConstraint(),
selectiontype=0,
do3dSplitting=InDetFlags.doPrimaryVertex3DFinding())
#Add additional finder tools
elif vxSetup == 'InDetPriVxFinderFastFinder': # not the official name
from InDetPriVxFinderTool.InDetPriVxFinderToolConf import InDet__InDetPriVxFinderTool
InDetPriVxFinderTool_vx = InDet__InDetPriVxFinderTool(
name="InDetPriVxFinderToolFastFinder_" + system + "_" + vxSetup +
suffix,
VertexFitterTool=InDetVxFitterToolFastFinder,
PriVxSeedFinder=InDetSlidingWindowMultiSeedFinder,
TrackSelector=InDetTrackSelectorTool_vx,
useBeamConstraint=InDetFlags.useBeamConstraint())
if jobproperties.Beam.zeroLuminosity():
InDetPriVxFinderTool_vx.enableMultipleVertices = 0
else:
InDetPriVxFinderTool_vx.enableMultipleVertices = 1
elif vxSetup == 'InDetPriVxFinderFullFinder':
from InDetPriVxFinderTool.InDetPriVxFinderToolConf import InDet__InDetPriVxFinderTool
InDetPriVxFinderTool_vx = InDet__InDetPriVxFinderTool(
name="InDetPriVxFinderToolFullFinder_" + system + "_" + vxSetup +
suffix,
VertexFitterTool=InDetVxFitterToolFullFinder,
PriVxSeedFinder=InDetSlidingWindowMultiSeedFinder,
TrackSelector=InDetTrackSelectorTool_vx,
useBeamConstraint=InDetFlags.useBeamConstraint())
if jobproperties.Beam.zeroLuminosity():
InDetPriVxFinderTool_vx.enableMultipleVertices = 0
else:
InDetPriVxFinderTool_vx.enableMultipleVertices = 1
ToolSvc += InDetPriVxFinderTool_vx
if (InDetFlags.doPrintConfigurables()):
print InDetPriVxFinderTool_vx
from InDetPriVxFinder.InDetPriVxFinderConf import InDet__InDetPriVxFinder
InDetPriVxFinder_vx = InDet__InDetPriVxFinder(
name="InDetPriVxFinder_" + system + "_" + vxSetup,
VertexFinderTool=InDetPriVxFinderTool_vx,
TracksName=tracksName,
VxCandidatesOutputName=InDetKeys.PrimaryVertices() + "_" + system +
"_" + vxSetup + suffix,
VertexCollectionSortingTool=VertexCollectionSortingTool,
doVertexSorting=doSorting,
OutputLevel=DEBUG)
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
topSequence += InDetPriVxFinder_vx
pvFinders.append(InDetPriVxFinder_vx)
primaryVertices.append(InDetPriVxFinder_vx.VxCandidatesOutputName)
if InDetFlags.doPrintConfigurables():
print InDetPriVxFinder_vx
Stream.AddItem([
'VxContainer#' + InDetKeys.PrimaryVertices() + "_" + system + "_" +
vxSetup + suffix
])
return (InDetTrackSelectorTool_vx, InDetPriVxFinderTool_vx,
InDetPriVxFinder_vx)
theAtlasTrackSummaryTool = AtlasTrackSummaryTool("theAtlasTrackSummaryTool")
ToolSvc += theAtlasTrackSummaryTool
from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
InDetConversionVxFitterTool = Trk__TrkVKalVrtFitter(
name="InDetConversionVxFitter",
# Extrapolator = InDetExtrapolator,
Extrapolator=theAtlasExtrapolator,
IterationNumber=30,
#MagFieldSvc = InDetMagField,
MagFieldSvc=theAtlasMagField,
Robustness=6,
#This line has no more meaning Constraint = 12,
usePhiCnst=True,
useThetaCnst=True,
InputParticleMasses=[0.511, 0.511],
MassForConstraint=2.,
VertexForConstraint=[0., 0., 0.],
CovVrtForConstraint=[
0.015 * 0.015, 0., 0.015 * 0.015, 0., 0., 10000. * 10000.
],
MakeExtendedVertex=True
# MakeExtendedVertex=False
# IterationPrecision = 1.e-5,
)
ToolSvc += InDetConversionVxFitterTool
print InDetConversionVxFitterTool
#next instruction no more useful but keep it for a while
topSequence.VrtSecInclusive.SelVrtChi2Cut = 4.5
topSequence.VrtSecInclusive.TrkChi2Cut = 5.0
topSequence.VrtSecInclusive.TruthTrkLen = 1
topSequence.VrtSecInclusive.CutSharedHits = 5
topSequence.VrtSecInclusive.DoSAloneTRT = False
# next line needed if running on ESD or output of InDetRecEx , otherwise GEN_AOD
#topSequence.VrtSecInclusive.MCEventContainer = "TruthEvent"
topSequence.VrtSecInclusive.MCEventContainer = "GEN_AOD"
#
from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
InclusiveVxFitterTool = Trk__TrkVKalVrtFitter(
name="InclusiveVxFitter",
Extrapolator=ToolSvc.AtlasExtrapolator,
IterationNumber=30,
MagFieldSvc=ToolSvc.AtlasMagneticFieldTool,
AtlasMagFieldSvc='dummy')
ToolSvc += InclusiveVxFitterTool
InclusiveVxFitterTool.OutputLevel = INFO
topSequence.VrtSecInclusive.VertexFitterTool = InclusiveVxFitterTool
topSequence.VrtSecInclusive.Extrapolator = ToolSvc.AtlasExtrapolator
print VrtSecInclusive
# The AOD input file
ServiceMgr.EventSelector.InputCollections = ["AOD.pool.root"]
### Following lines is to read AOD files without listing all of them individually
###
#DATAPATH = '/direct/usatlas+u/vj/vj_tracking/datafile/single_pion_task25576/'
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
