if InDetFlags.doVertexFindingForMonitoring():
# also load finder tools here (easier for container naming)
#
# PV with NO beam constraint
#
from InDetPriVxFinderTool.InDetPriVxFinderToolConf import InDet__InDetIterativePriVxFinderTool
InDetPriVxFinderToolNoBeamConstraint = InDet__InDetIterativePriVxFinderTool(
name="InDetPriVxFinderToolNoBeamConstraint",
VertexFitterTool=InDetVxFitterTool,
TrackSelector=InDetTrackSelectorTool,
SeedFinder=InDetVtxSeedFinder,
ImpactPoint3dEstimator=InDetImpactPoint3dEstimator,
LinearizedTrackFactory=InDetLinFactory,
useBeamConstraint=False,
significanceCutSeeding=12,
maximumChi2cutForSeeding=49,
maxVertices=200,
createSplitVertices=False,
InternalEdmFactory=InDetVxEdmCnv,
doMaxTracksCut=InDetPrimaryVertexingCuts.doMaxTracksCut(),
MaxTracks=InDetPrimaryVertexingCuts.MaxTracks())
ToolSvc += InDetPriVxFinderToolNoBeamConstraint
if (InDetFlags.doPrintConfigurables()):
print InDetPriVxFinderToolNoBeamConstraint
from InDetPriVxFinder.InDetPriVxFinderConf import InDet__InDetPriVxFinder
InDetPriVxFinderNoBeamConstraint = InDet__InDetPriVxFinder(
name="InDetPriVxFinderNoBeamConstraint",
VertexFinderTool=InDetPriVxFinderToolNoBeamConstraint,
#TrackCompatibilityEstimator =
VertexSmoother=FTK_VertexSmoother,
#VertexUpdator = , #does not use any tools?
#onlyzseed = ,
)
FTK_VxFitterTool.XAODConverter = InDetTrigVxEdmCnv
ToolSvc += FTK_VxFitterTool
from InDetPriVxFinderTool.InDetPriVxFinderToolConf import InDet__InDetIterativePriVxFinderTool
FTK_PriVxFinderTool = InDet__InDetIterativePriVxFinderTool(
name="FTK_PriVxFinderTool",
VertexFitterTool=FTK_VxFitterTool,
TrackSelector=InDetTrigTrackSelectorTool,
SeedFinder=FTK_VtxSeedFinder,
ImpactPoint3dEstimator=FTK_ImpactPoint3dEstimator,
LinearizedTrackFactory=InDetTrigLinFactory,
useBeamConstraint=True,
significanceCutSeeding=12,
maximumChi2cutForSeeding=49,
maxVertices=200,
InternalEdmFactory=InDetTrigVxEdmCnv)
ToolSvc += FTK_PriVxFinderTool
from FTK_DataProviderSvc.FTK_DataProviderSvc_Config import ConfiguredFTK_UncertaintyTool
FTK_UncertaintyTool = ConfiguredFTK_UncertaintyTool(name="FTK_UncertaintyTool")
ToolSvc += FTK_UncertaintyTool
print "FTK_DataProviderLoad.py loaded all FTK tools: ToolSvc=", ToolSvc
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
from FTK_DataProviderSvc.FTK_DataProviderSvcConf import FTK_DataProviderSvc
elif InDetFlags.primaryVertexSetup() == 'AdaptiveFinding':
# --- load adaptive primary vertex finder
#
#from InDetPriVxFinderTool.InDetPriVxFinderToolConf import InDet__InDetAdaptivePriVxFinderTool
#InDetPriVxFinderTool_Si = InDet__InDetAdaptivePriVxFinderTool(name = "InDetAdaptivePriVxFinderTool_Si",
# VertexFitterTool = InDetVxFitterTool,
# TrackSelector = InDetTrackSelectorTool_Si
# )
from InDetPriVxFinderTool.InDetPriVxFinderToolConf import InDet__InDetIterativePriVxFinderTool
InDetPriVxFinderTool_Pix = InDet__InDetIterativePriVxFinderTool(
name="InDetIterativePriVxFinderTool_Pix",
VertexFitterTool=InDetVxFitterTool,
TrackSelector=InDetTrackSelectorTool_Pix,
SeedFinder=InDetVtxSeedFinder,
ImpactPoint3dEstimator=InDetImpactPoint3dEstimator,
LinearizedTrackFactory=InDetLinFactory,
useBeamConstraint=InDetFlags.useBeamConstraint(),
significanceCutSeeding=12,
maximumChi2cutForSeeding=49,
maxVertices=25)
elif InDetFlags.primaryVertexSetup() == 'AdaptiveMultiFinding':
#
# --- load adaptive multi primary vertex finder
#
from InDetPriVxFinderTool.InDetPriVxFinderToolConf import InDet__InDetAdaptiveMultiPriVxFinderTool
InDetPriVxFinderTool_Pix = InDet__InDetAdaptiveMultiPriVxFinderTool(
name="InDetAdaptiveMultiPriVxFinderTool_Pix",
SeedFinder=InDetVtxSeedFinder,
VertexFitterTool=InDetVxFitterTool,
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)
def __init__(self, name="ConfiguredFTK_DataProviderSvc"):
print "In FTK_DataProviderSvc_Config.py"
FTK_DataProviderSvc.__init__(self, name)
# Track Fitter
from TrkGlobalChi2Fitter.TrkGlobalChi2FitterConf import Trk__GlobalChi2Fitter
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigExtrapolator, InDetTrigNavigator, InDetTrigPropagator, InDetTrigRefitRotCreator,InDetTrigBroadInDetRotCreator, \
InDetTrigUpdator, InDetTrigMaterialUpdator, InDetTrigUpdator, InDetTrigMaterialUpdator
from TrkDetDescrSvc.AtlasTrackingGeometrySvc import AtlasTrackingGeometrySvc
from TrkDistributedKalmanFilter.DistributedKalmanFilter_Config import ConfiguredDistributedKalmanFilter
FTK_TrackFitter = Trk__GlobalChi2Fitter(
name="FTK_TrackFitter",
ExtrapolationTool=InDetTrigExtrapolator,
NavigatorTool=InDetTrigNavigator,
PropagatorTool=InDetTrigPropagator,
RotCreatorTool=InDetTrigRefitRotCreator,
BroadRotCreatorTool=InDetTrigBroadInDetRotCreator,
MeasurementUpdateTool=InDetTrigUpdator,
TrackingGeometrySvc=AtlasTrackingGeometrySvc,
MaterialUpdateTool=InDetTrigMaterialUpdator,
StraightLine=False,
OutlierCut=4,
SignedDriftRadius=True,
RecalibrateSilicon=True,
RecalibrateTRT=True,
ReintegrateOutliers=True,
TrackChi2PerNDFCut=7,
TRTExtensionCuts=False,
MaxIterations=40,
Acceleration=True,
Momentum=1000.,
)
from AthenaCommon.AppMgr import ToolSvc
print "printing FTK_TrackFitter configured with DKF"
print FTK_TrackFitter
ToolSvc += FTK_TrackFitter
print "added FTK_TrackFitter to ToolSvc"
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigExtrapolator, InDetTrigTrackSelectorTool, InDetTrigHoleSearchTool
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigTrackSummaryToolSharedHits, InDetTrigPrdAssociationTool
from InDetTrackSummaryHelperTool.InDetTrackSummaryHelperToolConf import InDet__InDetTrackSummaryHelperTool
FTK_TrackSummaryHelperTool = InDet__InDetTrackSummaryHelperTool(
name="FTK_TrackSummaryHelperTool",
AssoTool=InDetTrigPrdAssociationTool,
DoSharedHits=False,
HoleSearch=InDetTrigHoleSearchTool,
TestBLayerTool=None,
PixelToTPIDTool=None,
usePixel=True,
useSCT=True,
useTRT=False)
ToolSvc += FTK_TrackSummaryHelperTool
print "added FTK_TrackSummaryHelperTool to ToolSvc"
from TrkTrackSummaryTool.TrkTrackSummaryToolConf import Trk__TrackSummaryTool
FTK_TrackSummaryTool = Trk__TrackSummaryTool(
name="FTK_TrackSummaryTool",
InDetSummaryHelperTool=FTK_TrackSummaryHelperTool,
InDetHoleSearchTool=None,
doSharedHits=False,
TRT_ElectronPidTool=None)
ToolSvc += FTK_TrackSummaryTool
print "added FTK_TrackSummaryTool to ToolSvc"
from TrkParticleCreator.TrkParticleCreatorConf import Trk__TrackParticleCreatorTool
FTK_TrackParticleCreatorTool = Trk__TrackParticleCreatorTool(
name="FTK_ParticleCreatorTool",
Extrapolator=InDetTrigExtrapolator,
TrackSummaryTool=FTK_TrackSummaryTool,
KeepParameters=True,
ForceTrackSummaryUpdate=
False, #summary update moved (in the slimmer now)
)
ToolSvc += FTK_TrackParticleCreatorTool
print FTK_TrackParticleCreatorTool
print " added FTK_TrackParticleCreatorTool to ToolSvc"
from TrigInDetConf.TrigInDetRecVtxTools import InDetTrigLinFactory, InDetTrigVxEdmCnv
from TrigInDetConf.TrigInDetRecVtxTools import InDetTrigLinFactory, InDetTrigVxEdmCnv
from TrkVertexSeedFinderTools.TrkVertexSeedFinderToolsConf import Trk__ZScanSeedFinder
FTK_VtxSeedFinder = Trk__ZScanSeedFinder(
name="FTK_ZScanSeedFinder"
#Mode1dFinder = # default, no setting needed
)
ToolSvc += FTK_VtxSeedFinder
from TrkVertexFitterUtils.TrkVertexFitterUtilsConf import Trk__ImpactPoint3dEstimator, Trk__DetAnnealingMaker
FTK_ImpactPoint3dEstimator = Trk__ImpactPoint3dEstimator(
name="FTK_TrkImpactPoint3dEstimator",
Extrapolator=InDetTrigExtrapolator,
)
ToolSvc += FTK_ImpactPoint3dEstimator
FTK_AnnealingMaker = Trk__DetAnnealingMaker(
name="FTK_TrkAnnealingMaker")
FTK_AnnealingMaker.SetOfTemperatures = [64., 16., 4., 2., 1.5,
1.] # not default
ToolSvc += FTK_AnnealingMaker
from TrkVertexFitters.TrkVertexFittersConf import Trk__SequentialVertexSmoother
FTK_VertexSmoother = Trk__SequentialVertexSmoother(
name="FTK_SequentialVertexSmoother")
ToolSvc += FTK_VertexSmoother
from TrkVertexFitters.TrkVertexFittersConf import Trk__AdaptiveVertexFitter
FTK_VxFitterTool = Trk__AdaptiveVertexFitter(
name="FTK_AdaptiveVxFitterTool",
SeedFinder=FTK_VtxSeedFinder,
LinearizedTrackFactory=InDetTrigLinFactory,
ImpactPoint3dEstimator=FTK_ImpactPoint3dEstimator,
AnnealingMaker=FTK_AnnealingMaker,
#TrackCompatibilityEstimator =
VertexSmoother=FTK_VertexSmoother,
#VertexUpdator = , #does not use any tools?
#onlyzseed = ,
)
FTK_VxFitterTool.XAODConverter = InDetTrigVxEdmCnv
ToolSvc += FTK_VxFitterTool
from InDetPriVxFinderTool.InDetPriVxFinderToolConf import InDet__InDetIterativePriVxFinderTool
FTK_PriVxFinderTool = InDet__InDetIterativePriVxFinderTool(
name="FTK_PriVxFinderTool",
VertexFitterTool=FTK_VxFitterTool,
TrackSelector=InDetTrigTrackSelectorTool,
SeedFinder=FTK_VtxSeedFinder,
ImpactPoint3dEstimator=FTK_ImpactPoint3dEstimator,
LinearizedTrackFactory=InDetTrigLinFactory,
useBeamConstraint=True,
significanceCutSeeding=12,
maximumChi2cutForSeeding=49,
maxVertices=200,
InternalEdmFactory=InDetTrigVxEdmCnv)
ToolSvc += FTK_PriVxFinderTool
from FTK_DataProviderSvc.FTK_DataProviderSvcConf import FTK_UncertaintyTool
theFTK_UncertaintyTool = FTK_UncertaintyTool(
name="FTK_UncertaintyTool")
ToolSvc += theFTK_UncertaintyTool
from FTK_RecTools.FTK_RecToolsConf import FTK_VertexFinderTool
FTK_RawVertexFinderTool = FTK_VertexFinderTool(
name="FTK_RawVertexFinderTool",
VertexInternalEdmFactory=InDetTrigVxEdmCnv)
ToolSvc += FTK_RawVertexFinderTool
self.TrackCollectionName = "FTK_TrackCollection"
self.TrackParticleContainerName = "FTK_TrackParticleContainer"
self.VxContainerName = "FTK_VxContainer"
self.VertexContainerName = "FTK_VertexContainer"
self.PixelTruthName = "FTK_PRD_MultiTruthPixel"
self.SctTruthName = "FTK_PRD_MultiTruthSCT"
self.PixelClusterContainerName = "FTK_PixelClusterContainer"
self.SCT_ClusterContainerName = "FTK_SCT_ClusterContainer"
self.TrackFitter = FTK_TrackFitter
self.UncertaintyTool = theFTK_UncertaintyTool
self.TrackSummaryTool = FTK_TrackSummaryTool
self.TrackParticleCreatorTool = FTK_TrackParticleCreatorTool
self.RawVertexFinderTool = FTK_RawVertexFinderTool
self.VertexFinderTool = FTK_PriVxFinderTool
from RecExConfig.RecFlags import rec
self.doTruth = rec.doTruth()
self.TrainingBeamspotX = 0.0
self.TrainingBeamspotY = 0.0
self.TrainingBeamspotZ = 0.0
self.TrainingBeamspotTiltX = 0.0
self.TrainingBeamspotTiltY = 0.0
self.PixelBarrelPhiOffsets = [0.0, 0.0, 0.0, 0.0]
self.PixelBarrelEtaOffsets = [0.0, 0.0, 0.0, 0.0]
self.PixelEndCapPhiOffsets = [0.0, 0.0, 0.0]
self.PixelEndCapEtaOffsets = [0.0, 0.0, 0.0]
InDet__InDetAdaptiveMultiPriVxFinderTool( name = "InDetTrigAdaptiveMultiPriVxFinderTool",
VertexFitterTool = InDetTrigVxFitterTool,
TrackSelector = InDetTrigTrackSelectorTool,
useBeamConstraint = InDetTrigFlags.useBeamConstraint(),
selectiontype = 0
)
elif InDetTrigFlags.primaryVertexSetup() == 'IterativeFinding':
from InDetPriVxFinderTool.InDetPriVxFinderToolConf import InDet__InDetIterativePriVxFinderTool
InDetTrigPriVxFinderTool = \
InDet__InDetIterativePriVxFinderTool(name = "InDetTrigIterativePriVxFinderTool",
VertexFitterTool = InDetTrigVxFitterTool,
TrackSelector = InDetTrigTrackSelectorTool,
SeedFinder = InDetTrigVtxSeedFinder,
ImpactPoint3dEstimator = InDetTrigImpactPoint3dEstimator,
LinearizedTrackFactory = InDetTrigLinFactory,
useBeamConstraint = InDetTrigFlags.useBeamConstraint(),
significanceCutSeeding = 12,
maximumChi2cutForSeeding = 49,
maxVertices = 200,
)
else:
from InDetPriVxFinderTool.InDetPriVxFinderToolConf import InDet__InDetPriVxFinderTool
InDetTrigPriVxFinderTool = \
InDet__InDetPriVxFinderTool( name = "InDetTrigPriVxFinderTool",
VertexFitterTool = InDetTrigVxFitterTool,
TrackSelector = InDetTrigTrackSelectorTool,
useBeamConstraint = InDetTrigFlags.useBeamConstraint(),
)
if not 'outputfileprefix' in jobConfig: jobConfig['outputfileprefix'] = ''
if not 'histfile' in jobConfig:
jobConfig['histfile'] = jobConfig['outputfileprefix'] + 'split.nt.root'
#-------------------------------------------------------------
# vertexing fragment for running split vertices
#------------------------------------------------------------
from InDetPriVxFinderTool.InDetPriVxFinderToolConf import InDet__InDetIterativePriVxFinderTool
InDetPriVxFinderToolSplit = InDet__InDetIterativePriVxFinderTool(
name="InDetIterativePriVxFinderToolSplit",
VertexFitterTool=InDetVxFitterTool,
TrackSelector=InDetTrackSelectorTool,
SeedFinder=InDetVtxSeedFinder,
ImpactPoint3dEstimator=InDetImpactPoint3dEstimator,
LinearizedTrackFactory=InDetLinFactory,
useBeamConstraint=False,
significanceCutSeeding=12,
maximumChi2cutForSeeding=49,
maxVertices=25,
createSplitVertices=True)
ToolSvc += InDetPriVxFinderToolSplit
if (InDetFlags.doPrintConfigurables()):
printfunc(InDetPriVxFinderToolSplit)
InDetPriVxFinder.VertexFinderTool = InDetPriVxFinderToolSplit
InDetPriVxFinder.VxCandidatesOutputName = "SplitVxCandidates"
InDetPriVxFinder.doVertexSorting = False
if (InDetFlags.doPrintConfigurables()):
printfunc(InDetPriVxFinder)
def vertexFinderTool_builder( signature ) :
from AthenaCommon.AppMgr import ToolSvc
# use the getters from TrackingCommon ...
import InDetRecExample.TrackingCommon as TrackingCommon
# the track summary tool, and extrapolator will be needed by multiple
# tools so create them once and pass them into the builders ...
trackSummaryTool = TrackingCommon.getInDetTrackSummaryTool()
extrapolator = TrackingCommon.getInDetExtrapolator()
# get the selection cuts use to select the actual tracks in the tool ...
from InDetTrigRecExample.TrigInDetConfiguredVtxCuts import ConfiguredTrigVtxCuts
vtxcuts = ConfiguredTrigVtxCuts()
vtxcuts.printInfo()
# now create the five sub tools needed ...
linearTrackFactory = linearTrackFactory_builder( signature, extrapolator )
vertexFitterTool = vertexFitterTool_builder( signature, linearTrackFactory, extrapolator )
impactEstimator = impactEstimator_builder( signature, extrapolator )
trackSelectorTool = trackSelectorTool_builder( signature, trackSummaryTool, extrapolator, vtxcuts )
trackDensitySeedFinder = trackDensitySeedFinder_builder( signature )
# now create the actual vertex finder tool ...
# this is the main part of the actual working part of the code -
# the vertoces are found by this class, in this instance it includes
# a beam line constraint - it we want this to allow this constrain
# to be disabled we can add a flag and some additional logic
from InDetPriVxFinderTool.InDetPriVxFinderToolConf import InDet__InDetIterativePriVxFinderTool
vertexFinderTool = InDet__InDetIterativePriVxFinderTool( name = "InDetTrigPriVxFinderTool" + signature,
VertexFitterTool = vertexFitterTool,
TrackSelector = trackSelectorTool,
SeedFinder = trackDensitySeedFinder,
ImpactPoint3dEstimator = impactEstimator,
LinearizedTrackFactory = linearTrackFactory,
useBeamConstraint = True,
significanceCutSeeding = 12,
maximumChi2cutForSeeding = 49,
maxVertices = 200,
createSplitVertices = False,
doMaxTracksCut = vtxcuts.doMaxTracksCut(),
MaxTracks = vtxcuts.MaxTracks() )
# InDetAdaptiveMultiPriVxFinderTool job options for later
# verxtexFinderTool = InDet__InDetAdaptiveMultiPriVxFinderTool( name = "InDetTrigPriVxFinderTool" + signature,
# VertexFitterTool = vertexFitterTool,
# ...
# VertexFitterTool = vertexFitterTool,
# TrackSelector = trackSelectorTool,
# SeedFinder = trackDensitySeedFinder,
# IPEstimator = Trk::ITrackToVertexIPEstimator : impactEstimator is different type than for IterativeFinder
# BeamSpotKey = InDet::BeamSpotData : what is this ??
# TracksMaxZinterval =
# maxVertexChi2 =
# finalCutMaxVertexChi2 =
# cutVertexDependence =
# MinWeight =
# realMultiVertex =
# useFastCompatibility =
# useBeamConstraint =
# addSingleTrackVertices =
# tracksMaxSignificance =
# m_useSeedConstraint =
# selectiontype =
# //==0 for sum p_t^2
# //==1 for NN
# //==2 for min bias compatibility estimation (in the future)
# maxIterations =
# do3dSplitting =
# zBfieldApprox =
# maximumVertexContamination =
ToolSvc += vertexFinderTool
return vertexFinderTool