def __init__(self, InputTrackCollection = None, InputTrackTruthCollection = None, OutputTrackParticleContainer = None):
from InDetRecExample.InDetJobProperties import InDetFlags
from InDetRecExample.InDetKeys import InDetKeys
#
# --- get ToolSvc and topSequence
#
from AthenaCommon.AppMgr import ToolSvc
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
_perigee_expression=InDetFlags.perigeeExpression()
# need to treat Vertex specifically because at the time of
# the track particle creation the primary vertex does not yet exist.
# The problem is solved by first creating track particles wrt. the beam line
# and correcting the parameters after the vertex finding.
if _perigee_expression == 'Vertex' :
_perigee_expression = 'BeamLine'
#Always the same (so far) so can in principle go in InDetRecLoadTools
from TrkParticleCreator.TrkParticleCreatorConf import Trk__TrackParticleCreatorTool
InDetxAODParticleCreatorTool = Trk__TrackParticleCreatorTool(name = "InDetxAODParticleCreatorTool"+InputTrackCollection,
Extrapolator = InDetExtrapolator,
TrackSummaryTool = InDetTrackSummaryToolSharedHits,
BadClusterID = InDetFlags.pixelClusterBadClusterID(),
KeepParameters = True,
KeepFirstParameters = InDetFlags.KeepFirstParameters(),
PerigeeExpression = _perigee_expression)
ToolSvc += InDetxAODParticleCreatorTool
if (InDetFlags.doPrintConfigurables()):
printfunc (InDetxAODParticleCreatorTool)
from xAODTrackingCnv.xAODTrackingCnvConf import xAODMaker__TrackParticleCnvAlg
xAODTrackParticleCnvAlg = xAODMaker__TrackParticleCnvAlg(name = "InDetxAODParticleCreatorAlg"+InputTrackCollection,
ConvertTracks = True,
ConvertTrackParticles = False,
TrackContainerName = InputTrackCollection,
xAODContainerName = OutputTrackParticleContainer,
xAODTrackParticlesFromTracksContainerName = OutputTrackParticleContainer,
TrackParticleCreator = InDetxAODParticleCreatorTool)
if (InDetFlags.doTruth() and not InputTrackTruthCollection == ''):
xAODTrackParticleCnvAlg.AddTruthLink = True
xAODTrackParticleCnvAlg.TrackTruthContainerName = InputTrackTruthCollection
from MCTruthClassifier.MCTruthClassifierBase import MCTruthClassifier
xAODTrackParticleCnvAlg.MCTruthClassifier = MCTruthClassifier
elif (InDetFlags.doTruth() and InputTrackTruthCollection == ''):
printfunc ("WARNING: ConfiguredxAODTrackParticleCreation - doTruth = True, but no input Truth collection specified!")
else:
xAODTrackParticleCnvAlg.AddTruthLink = False
topSequence += xAODTrackParticleCnvAlg
if (InDetFlags.doPrintConfigurables()):
printfunc (xAODTrackParticleCnvAlg)
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 __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 setup(self):
mlog = logging.getLogger( 'eflowSetupParticleCreator::setup' )
try:
from AthenaCommon.AppMgr import ToolSvc
except:
mlog.error("could not import ToolSvc")
print traceback.format_exc()
return False
try:
from TrkExTools.AtlasExtrapolator import AtlasExtrapolator
eflowExtrapolator = AtlasExtrapolator(name = "eflowExtrapolator")
except:
mlog.error("could not import AtlasExtrapolator from TrkExTools.AtlasExtrapolator")
print traceback.format_exc()
return False
ToolSvc+=eflowExtrapolator
try:
from TrkTrackSummaryTool.AtlasTrackSummaryTool import AtlasTrackSummaryTool
eflowTrackSummaryTool = AtlasTrackSummaryTool(name = "eflowTrackSummaryTool")
except:
mlog.error("could not import AtlasTrackSummaryTool from TrkTrackSummaryTool.AtlasTrackSummaryTool")
print traceback.format_exc()
return False
ToolSvc+=eflowTrackSummaryTool
try:
from TrkParticleCreator.TrkParticleCreatorConf import Trk__TrackParticleCreatorTool
eflowParticleCreatorTool = Trk__TrackParticleCreatorTool(name = "eflowParticleCreatorTool",Extrapolator = eflowExtrapolator, TrackSummaryTool = eflowTrackSummaryTool)
except:
mlog.error("could not import Trk__TrackParticleCreatorTool from TrkParticleCreator.TrkParticleCreatorConf")
print traceback.format_exc()
return False
ToolSvc += eflowParticleCreatorTool
return eflowParticleCreatorTool
def getInDetxAODParticleCreatorTool(prd_to_track_map=None, suffix=""):
from AthenaCommon.AppMgr import ToolSvc
if hasattr(ToolSvc, 'InDetxAODParticleCreatorTool' + suffix):
return getattr(ToolSvc, 'InDetxAODParticleCreatorTool')
_perigee_expression = InDetFlags.perigeeExpression()
# need to treat Vertex specifically because at the time of
# the track particle creation the primary vertex does not yet exist.
# The problem is solved by first creating track particles wrt. the beam line
# and correcting the parameters after the vertex finding.
if _perigee_expression == 'Vertex':
_perigee_expression = 'BeamLine'
from InDetRecExample import TrackingCommon as TrackingCommon
from InDetRecExample.TrackingCommon import setDefaults
if prd_to_track_map is None:
track_summary_tool = TrackingCommon.getInDetTrackSummaryToolSharedHits(
)
else:
prop_args = setDefaults({}, nameSuffix=suffix)
asso_tool = TrackingCommon.getConstPRD_AssociationTool(
**setDefaults(prop_args, PRDtoTrackMap=prd_to_track_map))
helper_tool = TrackingCommon.getInDetSummaryHelperSharedHits(
**setDefaults(prop_args, AssoTool=asso_tool))
track_summary_tool = TrackingCommon.getInDetTrackSummaryToolSharedHits(
**setDefaults(prop_args, InDetSummaryHelperTool=helper_tool))
from TrkParticleCreator.TrkParticleCreatorConf import Trk__TrackParticleCreatorTool
InDetxAODParticleCreatorTool = Trk__TrackParticleCreatorTool(
name="InDetxAODParticleCreatorTool" + suffix,
Extrapolator=InDetExtrapolator,
TrackSummaryTool=track_summary_tool,
BadClusterID=InDetFlags.pixelClusterBadClusterID(),
KeepParameters=True,
KeepFirstParameters=InDetFlags.KeepFirstParameters(),
PerigeeExpression=_perigee_expression)
ToolSvc += InDetxAODParticleCreatorTool
if InDetFlags.doPrintConfigurables():
printfunc(InDetxAODParticleCreatorTool)
return InDetxAODParticleCreatorTool
TrackFitter=ToolSvc.InDetTrackFitter)
ToolSvc += splittertool
from InDetTrackValidation.InDetTrackValidationConf import InDet__InDetSplittedTracksCreator
splitter = InDet__InDetSplittedTracksCreator(
name='InDetTrackSplitterForMuonCombined',
TrackSplitterTool=splittertool,
TrackCollection=InDetKeys.Tracks(),
OutputTrackCollection=InDetKeys.Tracks() + "_split")
topSequence += splitter
from TrkParticleCreator.TrkParticleCreatorConf import Trk__TrackParticleCreatorTool
InDetParticleCreatorTool_split = Trk__TrackParticleCreatorTool(
name="InDetParticleCreatorTool_split",
KeepParameters=True,
Extrapolator=InDetExtrapolator,
TrackSummaryTool=InDetTrackSummaryTool,
PerigeeExpression="Origin")
ToolSvc += InDetParticleCreatorTool_split
output_track_particle_name = InDetKeys.TrackParticles() + "_split"
from xAODTrackingCnv.xAODTrackingCnvConf import xAODMaker__TrackParticleCnvAlg
xAODTrackParticleCnvAlg = xAODMaker__TrackParticleCnvAlg(
name="InDetxAODParticleCreatorAlg" + InputTrackCollection + "_split",
ConvertTracks=True,
ConvertTrackParticles=False,
TrackContainerName=InDetKeys.Tracks() + "_split",
xAODContainerName=output_track_particle_name,
xAODTrackParticlesFromTracksContainerName=output_track_particle_name,
TrackParticleCreator=InDetParticleCreatorTool_split)
def getTrackParticleCnv(prefix, suffix, outPTTracks, outPTTrackParticles):
""" Use the track collection and convert it to container of xAOD Track Particles """
#suffix = '_%s'suff if suff else '' #Suffix should be based on the signature and type of tracking, e.g for cosmics and PT -> Cosmics_PT ( for FTF or EFID, Cosmics_FTF, Cosmics_EFID )
from AthenaCommon.AppMgr import ToolSvc
keepParameter = False
if 'Electron' in suffix:
keepParameter = True
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigTrackSummaryTool, InDetTrigExtrapolator
from TrkParticleCreator.TrkParticleCreatorConf import Trk__TrackParticleCreatorTool
InDetTrigMTxAODParticleCreatorTool = Trk__TrackParticleCreatorTool(
name="%sxAODParticleCreatorTool%s" % (prefix, suffix),
Extrapolator=InDetTrigExtrapolator,
KeepParameters=keepParameter,
#TrackSummaryTool = InDetTrigTrackSummaryToolSharedHits)
TrackSummaryTool=InDetTrigTrackSummaryTool)
ToolSvc += InDetTrigMTxAODParticleCreatorTool
#log.info(InDetTrigMTxAODParticleCreatorTool)
from xAODTrackingCnv.xAODTrackingCnvConf import xAODMaker__TrackCollectionCnvTool
InDetTrigMTxAODTrackCollectionCnvTool = xAODMaker__TrackCollectionCnvTool(
name="%sxAODTrackCollectionCnvTool%s" % (prefix, suffix),
TrackParticleCreator=InDetTrigMTxAODParticleCreatorTool)
ToolSvc += InDetTrigMTxAODTrackCollectionCnvTool
#log.info(InDetTrigMTxAODTrackCollectionCnvTool)
#This one shouldn't be necessary
#TODO: obsolete, try to turn off
from xAODTrackingCnv.xAODTrackingCnvConf import xAODMaker__RecTrackParticleContainerCnvTool
InDetTrigMTRecTrackParticleContainerCnvTool = xAODMaker__RecTrackParticleContainerCnvTool(
name="%sRecTrackContainerCnvTool%s" % (prefix, suffix),
TrackParticleCreator=InDetTrigMTxAODParticleCreatorTool)
ToolSvc += InDetTrigMTRecTrackParticleContainerCnvTool
#Adding new monitoring tool
#First load the generic monitoring tool with set of histograms for Particle Cnv
from TrigInDetMonitoringTools.TrigInDetTrackingMonitoring import TrigInDetTrackCnvMonitoring
#TODO need to add extra property for prefix and suffix of the track collections to be monitored
#Or maybe no need the name itself should be obvious from the particle cnv alg
monTool = TrigInDetTrackCnvMonitoring(name='%sParticleCreatorCnv%s' %
(prefix, suffix))
#Now pass this tool to the Track Monitoring tool
from TrigInDetMonitoringTools.TrigInDetTrackMonitoringToolConf import TrigInDetTrackMonitoringTool
monTrackCnv = TrigInDetTrackMonitoringTool(name='%sParticleCreatorCnv%s' %
(prefix, suffix),
MonitoringTool=monTool)
ToolSvc += monTrackCnv
from xAODTrackingCnv.xAODTrackingCnvConf import xAODMaker__TrackParticleCnvAlg
InDetTrigMTxAODTrackParticleCnvAlg = xAODMaker__TrackParticleCnvAlg(
name="%sxAODParticleCreatorAlg%s" % (prefix, suffix),
# Properties below are used for: TrackCollection -> xAOD::TrackParticle
ConvertTracks=
True, #Turn on retrieve of TrackCollection, false by default
TrackContainerName=outPTTracks,
xAODTrackParticlesFromTracksContainerName=outPTTrackParticles,
TrackCollectionCnvTool=InDetTrigMTxAODTrackCollectionCnvTool,
## Properties below are used for: Rec:TrackParticle, aod -> xAOD::TrackParticle (Turn off)
ConvertTrackParticles=
False, # Retrieve of Rec:TrackParticle, don't need this atm
xAODContainerName='',
RecTrackParticleContainerCnvTool=
InDetTrigMTRecTrackParticleContainerCnvTool,
TrackParticleCreator=InDetTrigMTxAODParticleCreatorTool,
#Add online track monitoring
DoMonitoring=True,
TrackMonTool=monTrackCnv)
return InDetTrigMTxAODTrackParticleCnvAlg
#----- tools for track splliting ---- START ----
splittertoolcomb = InDet__InDetTrackSplitterTool(
name="VARO_SplitterTool",
TrackFitter=InDetTrackFitter, #InDetTrackFitter,
OutputUpperTracksName="TracksUpperSplit",
OutputLowerTracksName="TracksLowerSplit",
OutputLevel=INFO)
#ToolSvc += splittertoolcomb
printfunc(splittertoolcomb)
# tool to convert to xAOD::TrackParticles
from TrkParticleCreator.TrkParticleCreatorConf import Trk__TrackParticleCreatorTool
InDetxAODSplitParticleCreatorTool = Trk__TrackParticleCreatorTool(
name="InDetSplitxAODParticleCreatorTool",
Extrapolator=InDetExtrapolator,
TrackSummaryTool=InDetTrackSummaryToolSharedHits,
KeepParameters=True,
OutputLevel=DEBUG)
#ToolSvc += InDetxAODSplitParticleCreatorTool
#----- tools for track splliting ---- COMPLETED ----
#
#### first task #### prepare the segment track selectors
#
#--> needed ? InDetAlignMonManager.DataType = "cosmics"
m_alignMonTrackSelectorTool = []
m_alignMonTrackSelectionTool = []
m_trackSelectorToolName = [
"AlignTracksTrackSelectorTool", "CombinedTracksTrackSelectorTool"
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]
from InDetTrackValidation.InDetTrackValidationConf import InDet__InDetSplittedTracksCreator
splittercomb=InDet__InDetSplittedTracksCreator(name='CombinedTrackSplitter',
TrackSplitterTool = splittertoolcomb,
TrackCollection = "Tracks",
OutputTrackCollection = "Tracks_split")
topSequence+=splittercomb
if (printIdTrkDxAODConf):
print splittercomb
print splittercomb.properties()
# Create xAOD::TrackParticles out of them
from TrkParticleCreator.TrkParticleCreatorConf import Trk__TrackParticleCreatorTool
InDetxAODSplitParticleCreatorTool = Trk__TrackParticleCreatorTool(name = "InDetSplitxAODParticleCreatorTool",
Extrapolator = InDetExtrapolator,
TrackSummaryTool = InDetTrackSummaryToolSharedHits,
ForceTrackSummaryUpdate = False,
KeepParameters = True)
ToolSvc += InDetxAODSplitParticleCreatorTool
# The following adds truth information, but needs further testing
#include ("InDetRecExample/ConfiguredInDetTrackTruth.py")
#if isIdTrkDxAODSimulation:
# InDetSplitTracksTruth = ConfiguredInDetTrackTruth("Tracks_split",'SplitTrackDetailedTruth','SplitTrackTruth')
xAODSplitTrackParticleCnvAlg = xAODMaker__TrackParticleCnvAlg('InDetSplitTrackParticles')
xAODSplitTrackParticleCnvAlg.xAODContainerName = 'InDetSplitTrackParticles'
xAODSplitTrackParticleCnvAlg.xAODTrackParticlesFromTracksContainerName = 'InDetSplitTrackParticles'
xAODSplitTrackParticleCnvAlg.TrackParticleCreator = InDetxAODSplitParticleCreatorTool
xAODSplitTrackParticleCnvAlg.TrackContainerName = 'Tracks_split'
xAODSplitTrackParticleCnvAlg.ConvertTrackParticles = False
xAODSplitTrackParticleCnvAlg.ConvertTracks = True
xAODTruthCnvPU.WriteAllPileUpTruth = True
xAODTruthCnvPU.AODContainerName = "GEN_EVENT_PU"
xAODTruthCnvPU.xAODTruthEventContainerName = "TruthEvents_PU" #output
xAODTruthCnvPU.xAODTruthPileupEventContainerName = "TruthPileupEvents_PU" #output
xAODTruthCnvPU.xAODTruthParticleContainerName = "TruthParticles_PU" #output
xAODTruthCnvPU.xAODTruthVertexContainerName = "TruthVertices_PU" #output
xAODTruthCnvPU.TruthLinks = "xAODTruthLinks_PU" #output/intermediate
xAODTruthCnvPU.MetaObjectName = "TruthMetaData_PU" #output
topSequence += xAODTruthCnvPU
from TrkParticleCreator.TrkParticleCreatorConf import Trk__TrackParticleCreatorTool
InDetxAODParticleCreatorTool = Trk__TrackParticleCreatorTool(
name="InDetxAODParticleCreatorTool",
Extrapolator=InDetExtrapolator,
TrackSummaryTool=InDetTrackSummaryToolSharedHits,
BadClusterID=InDetFlags.pixelClusterBadClusterID(),
ForceTrackSummaryUpdate=False,
KeepParameters=True,
KeepFirstParameters=InDetFlags.KeepFirstParameters(),
PerigeeExpression=_perigee_expression)
ToolSvc += InDetxAODParticleCreatorTool
if InDetFlags.doPrintConfigurables():
print InDetxAODParticleCreatorTool
if (
doCreation or doConversion
): # or InDetFlags.useExistingTracksAsInput()) : <---- [XXX JDC Should we included this?
# problems appear when nothing should
# be done but
# useExistinTracksAsInput...
def __init__(self, name="EMBremCollectionBuilder", **kw):
mlog = logging.getLogger(name + '::__init__')
mlog.info("entering")
super(egammaBremCollectionBuilder, self).__init__(name, **kw)
# do the configuration
import egammaRec.EMCommonRefitter
GSFBuildInDetExtrapolator = egammaExtrapolator()
from egammaTrackTools.egammaTrackToolsConf import egammaTrkRefitterTool
GSFRefitterTool = egammaTrkRefitterTool(
name='GSFRefitterTool',
FitterTool=egammaRec.EMCommonRefitter.GSFTrackFitter,
useBeamSpot=False,
ReintegrateOutliers=True)
from AthenaCommon.AppMgr import ToolSvc
ToolSvc += GSFRefitterTool
# ----------- load association tool from Inner Detector to handle pixel ganged ambiguities
#
from InDetAssociationTools.InDetAssociationToolsConf import InDet__InDetPRD_AssociationToolGangedPixels
GSFBuildInDetPrdAssociationTool = InDet__InDetPRD_AssociationToolGangedPixels(
name="GSFBuildInDetPrdAssociationTool",
PixelClusterAmbiguitiesMapName='PixelClusterAmbiguitiesMap')
ToolSvc += GSFBuildInDetPrdAssociationTool
#
# ----------- Load SummaryTool
#
# Loading Configurable HoleSearchTool
#
from InDetTrackHoleSearch.InDetTrackHoleSearchConf import InDet__InDetTrackHoleSearchTool
GSFBuildHoleSearchTool = InDet__InDetTrackHoleSearchTool(
name="GSFBuildHoleSearchTool",
Extrapolator=GSFBuildInDetExtrapolator,
usePixel=DetFlags.haveRIO.pixel_on(),
useSCT=DetFlags.haveRIO.SCT_on(),
checkBadSCTChip=InDetFlags.checkDeadElementsOnTrack(),
CountDeadModulesAfterLastHit=True)
from AthenaCommon.AppMgr import ServiceMgr
if (DetFlags.haveRIO.SCT_on()):
from SCT_ConditionsServices.SCT_ConditionsServicesConf import SCT_ConditionsSummarySvc
InDetSCT_ConditionsSummarySvc = SCT_ConditionsSummarySvc(
name="InDetSCT_ConditionsSummarySvc")
ServiceMgr += InDetSCT_ConditionsSummarySvc
GSFBuildHoleSearchTool.SctSummarySvc = ServiceMgr.InDetSCT_ConditionsSummarySvc
else:
GSFBuildHoleSearchTool.SctSummarySvc = None
ToolSvc += GSFBuildHoleSearchTool
#
# Load BLayer tool
#
GSFBuildTestBLayerTool = None
if DetFlags.haveRIO.pixel_on():
from InDetTestBLayer.InDetTestBLayerConf import InDet__InDetTestBLayerTool
from PixelConditionsServices.PixelConditionsServicesConf import PixelConditionsSummarySvc
ServiceMgr += PixelConditionsSummarySvc()
GSFBuildTestBLayerTool = InDet__InDetTestBLayerTool(
name="GSFBuildTestBLayerTool",
PixelSummarySvc=ServiceMgr.PixelConditionsSummarySvc,
Extrapolator=GSFBuildInDetExtrapolator)
ToolSvc += GSFBuildTestBLayerTool
# Configurable version of TRT_ElectronPidTools
#
GSFBuildTRT_ElectronPidTool = None
if DetFlags.haveRIO.TRT_on(
) and not InDetFlags.doSLHC() and not InDetFlags.doHighPileup():
from TRT_ElectronPidTools.TRT_ElectronPidToolsConf import InDet__TRT_LocalOccupancy
GSFBuildTRT_LocalOccupancy = InDet__TRT_LocalOccupancy(
name="GSF_TRT_LocalOccupancy")
ToolSvc += GSFBuildTRT_LocalOccupancy
from TRT_ElectronPidTools.TRT_ElectronPidToolsConf import InDet__TRT_ElectronPidToolRun2
GSFBuildTRT_ElectronPidTool = InDet__TRT_ElectronPidToolRun2(
name="GSFBuildTRT_ElectronPidTool",
TRT_LocalOccupancyTool=GSFBuildTRT_LocalOccupancy,
isData=(globalflags.DataSource == 'data'))
ToolSvc += GSFBuildTRT_ElectronPidTool
#
# Configurable version of PixelToTPIDTOol
#
GSFBuildPixelToTPIDTool = None
if DetFlags.haveRIO.pixel_on():
from PixelToTPIDTool.PixelToTPIDToolConf import InDet__PixelToTPIDTool
GSFBuildPixelToTPIDTool = InDet__PixelToTPIDTool(
name="GSFBuildPixelToTPIDTool")
GSFBuildPixelToTPIDTool.ReadFromCOOL = True
ToolSvc += GSFBuildPixelToTPIDTool
#
# Configrable version of loading the InDetTrackSummaryHelperTool
#
from InDetTrackSummaryHelperTool.InDetTrackSummaryHelperToolConf import InDet__InDetTrackSummaryHelperTool
GSFBuildTrackSummaryHelperTool = InDet__InDetTrackSummaryHelperTool(
name="GSFBuildTrackSummaryHelperTool",
AssoTool=GSFBuildInDetPrdAssociationTool,
PixelToTPIDTool=GSFBuildPixelToTPIDTool,
TestBLayerTool=GSFBuildTestBLayerTool,
DoSharedHits=False,
HoleSearch=GSFBuildHoleSearchTool,
usePixel=DetFlags.haveRIO.pixel_on(),
useSCT=DetFlags.haveRIO.SCT_on(),
useTRT=DetFlags.haveRIO.TRT_on())
ToolSvc += GSFBuildTrackSummaryHelperTool
#
# Configurable version of TrkTrackSummaryTool: no TRT_PID tool needed here (no shared hits)
#
from TrkTrackSummaryTool.TrkTrackSummaryToolConf import Trk__TrackSummaryTool
GSFBuildInDetTrackSummaryTool = Trk__TrackSummaryTool(
name="GSFBuildInDetTrackSummaryTool",
InDetSummaryHelperTool=GSFBuildTrackSummaryHelperTool,
doSharedHits=False,
InDetHoleSearchTool=GSFBuildHoleSearchTool,
TRT_ElectronPidTool=GSFBuildTRT_ElectronPidTool,
PixelToTPIDTool=GSFBuildPixelToTPIDTool)
ToolSvc += GSFBuildInDetTrackSummaryTool
#
# --- load patricle creator tool
#
from TrkParticleCreator.TrkParticleCreatorConf import Trk__TrackParticleCreatorTool
GSFBuildInDetParticleCreatorTool = Trk__TrackParticleCreatorTool(
name="GSFBuildInDetParticleCreatorTool",
KeepParameters=True,
Extrapolator=GSFBuildInDetExtrapolator,
TrackSummaryTool=GSFBuildInDetTrackSummaryTool,
UseTrackSummaryTool=False,
ForceTrackSummaryUpdate=False)
ToolSvc += GSFBuildInDetParticleCreatorTool
#
# --- do track slimming
#
from TrkTrackSlimmingTool.TrkTrackSlimmingToolConf import Trk__TrackSlimmingTool as ConfigurableTrackSlimmingTool
GSFBuildInDetTrkSlimmingTool = ConfigurableTrackSlimmingTool(
name="GSFBuildInDetTrackSlimmingTool",
KeepParameters=False,
KeepOutliers=True)
ToolSvc += GSFBuildInDetTrkSlimmingTool
# do the configuration
self.ClusterContainerName = "LArClusterEM"
from InDetRecExample.InDetKeys import InDetKeys
self.TrackParticleContainerName = InDetKeys.xAODTrackParticleContainer(
)
self.OutputTrkPartContainerName = "GSFTrackParticles"
self.OutputTrackContainerName = "GSFTracks"
self.TrackRefitTool = GSFRefitterTool
self.TrackParticleCreatorTool = GSFBuildInDetParticleCreatorTool
self.TrackSlimmingTool = GSFBuildInDetTrkSlimmingTool
self.TrackSummaryTool = GSFBuildInDetTrackSummaryTool
# do the configuration (from old EMBremCollectionBuilderBase)
self.minNoSiHits = 4
self.broadDeltaEta = 0.1 # this is multiplied by 2 for the Candidate Match , so +- 0.2 in eta
self.broadDeltaPhi = 0.15 # this is multiplied by 2 for the Candidate Match , so +- 0.3 in phi
self.narrowDeltaEta = 0.05
#These have to be relaxed enough for the conversions
self.narrowDeltaPhi = 0.05
self.narrowDeltaPhiBrem = 0.20 #Dominated by the needs of assymetric conversions
self.narrowDeltaPhiRescale = 0.05
self.narrowDeltaPhiRescaleBrem = 0.1
# ToolSvc += InDetTrigTrackSummaryToolWithHoleSearch
# if (InDetTrigFlags.doPrintConfigurables()):
# print (InDetTrigTrackSummaryToolWithHoleSearch)
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import \
InDetTrigTrackSummaryHelperTool, InDetTrigTrackSummaryTool, InDetTrigTrackSummaryToolSharedHits, \
InDetTrigHoleSearchTool,InDetTrigExtrapolator
from TrigInDetConf.TrigInDetRecCommonTools import InDetTrigFastTrackSummaryTool, InDetTrigTrackSummaryToolSharedHitsWithTRTPid
from TrkParticleCreator.TrkParticleCreatorConf import Trk__TrackParticleCreatorTool
InDetTrigParticleCreatorTool = \
Trk__TrackParticleCreatorTool( name = "InDetTrigParticleCreatorTool",
Extrapolator = InDetTrigExtrapolator,
TrackSummaryTool = InDetTrigTrackSummaryToolSharedHits,
KeepParameters = False,
)
ToolSvc += InDetTrigParticleCreatorTool
if (InDetTrigFlags.doPrintConfigurables()):
print(InDetTrigParticleCreatorTool)
InDetTrigParticleCreatorToolWithSummary = \
Trk__TrackParticleCreatorTool( name = "InDetTrigParticleCreatorToolWithSummary",
Extrapolator = InDetTrigExtrapolator,
TrackSummaryTool = InDetTrigTrackSummaryToolSharedHits,
KeepParameters = True,
ComputeAdditionalInfo = True
)
def __init__(self, name="EMBremCollectionBuilder", **kw):
mlog = logging.getLogger(name + '::__init__')
mlog.info("entering")
super(egammaBremCollectionBuilder, self).__init__(name, **kw)
import egammaRec.EMCommonRefitter
# Extrapolator to be used for GSF (private)
GSFBuildInDetExtrapolator = egammaExtrapolator()
# GsfReffiter (private not in ToolSvc)
from egammaTrackTools.egammaTrackToolsConf import egammaTrkRefitterTool
GSFRefitterTool = egammaTrkRefitterTool(
name='GSFRefitterTool',
FitterTool=egammaRec.EMCommonRefitter.getGSFTrackFitter(),
useBeamSpot=False,
Extrapolator=GSFBuildInDetExtrapolator,
ReintegrateOutliers=True)
#
# BLayer and Pixel Related Tools (private = True)
#
GSFBuildTestBLayerTool = None
GSFBuildPixelToTPIDTool = None
if DetFlags.haveRIO.pixel_on():
GSFPixelConditionsSummaryTool = (
TrackingCommon.getInDetPixelConditionsSummaryTool())
if InDetFlags.usePixelDCS():
GSFPixelConditionsSummaryTool.IsActiveStates = [
'READY', 'ON', 'UNKNOWN', 'TRANSITION', 'UNDEFINED'
]
GSFPixelConditionsSummaryTool.IsActiveStatus = [
'OK', 'WARNING', 'ERROR', 'FATAL'
]
GSFBuildTestBLayerTool = TrackingCommon.getInDetRecTestBLayerTool(
name="GSFBuildTestBLayerTool",
PixelSummaryTool=GSFPixelConditionsSummaryTool,
Extrapolator=GSFBuildInDetExtrapolator,
private=True)
GSFBuildPixelToTPIDTool = TrackingCommon.getInDetPixelToTPIDTool(
name="GSFBuildPixelToTPIDTool", private=True)
#
# TRT_ElectronPidTool (private =True)
#
GSFBuildTRT_ElectronPidTool = None
if DetFlags.haveRIO.TRT_on(
) and not InDetFlags.doSLHC() and not InDetFlags.doHighPileup():
GSFBuildTRT_ElectronPidTool = (
TrackingCommon.getInDetTRT_ElectronPidTool(
name="GSFBuildTRT_ElectronPidTool", private=True))
#
# InDet Track Summary Helper, no Association and no hole
# as we do not redo them (private = true)
#
GSFBuildTrackSummaryHelperTool = TrackingCommon.getInDetSummaryHelper(
name="GSFBuildTrackSummaryHelperTool",
AssoTool=None,
HoleSearch=None,
PixelToTPIDTool=GSFBuildPixelToTPIDTool,
TestBLayerTool=GSFBuildTestBLayerTool,
DoSharedHits=False,
private=True)
#
# TrkTrackSummaryTool: no shared hits no hole search
# still public due to TrackParticleCreatorTool
#
GSFBuildInDetTrackSummaryTool = (
TrackingCommon.getInDetTrackSummaryTool(
name="GSFBuildInDetTrackSummaryTool",
InDetSummaryHelperTool=GSFBuildTrackSummaryHelperTool,
doSharedHits=False,
doHolesInDet=False,
TRT_ElectronPidTool=GSFBuildTRT_ElectronPidTool,
PixelToTPIDTool=GSFBuildPixelToTPIDTool))
#
# Track Particle Creator tool (private not in ToolSvc)
# But needs a public extrapolator and
# InDetTrackSummaryTool still...
#
from TrkParticleCreator.TrkParticleCreatorConf import (
Trk__TrackParticleCreatorTool)
GSFBuildInDetParticleCreatorTool = Trk__TrackParticleCreatorTool(
name="GSFBuildInDetParticleCreatorTool",
KeepParameters=True,
Extrapolator=AtlasPublicExtrapolator(),
TrackSummaryTool=GSFBuildInDetTrackSummaryTool,
UseTrackSummaryTool=False)
#
# Track slimming (private not in ToolSvc)
#
from TrkTrackSlimmingTool.TrkTrackSlimmingToolConf import (
Trk__TrackSlimmingTool as ConfigurableTrackSlimmingTool)
GSFBuildInDetTrkSlimmingTool = ConfigurableTrackSlimmingTool(
name="GSFBuildInDetTrackSlimmingTool",
KeepParameters=False,
KeepOutliers=True)
#
# Default Configuration
#
self.TrackRefitTool = GSFRefitterTool
self.TrackParticleCreatorTool = GSFBuildInDetParticleCreatorTool
self.TrackSlimmingTool = GSFBuildInDetTrkSlimmingTool
self.TrackSummaryTool = GSFBuildInDetTrackSummaryTool
# ToolSvc += InDetTrigTrackSummaryToolWithHoleSearch
# if (InDetTrigFlags.doPrintConfigurables()):
# print InDetTrigTrackSummaryToolWithHoleSearch
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import \
InDetTrigTrackSummaryHelperTool, InDetTrigTrackSummaryTool, InDetTrigTrackSummaryToolSharedHits, \
InDetTrigHoleSearchTool,InDetTrigExtrapolator
from TrigInDetConf.TrigInDetRecCommonTools import InDetTrigFastTrackSummaryTool, InDetTrigTrackSummaryToolSharedHitsWithTRTPid
from TrkParticleCreator.TrkParticleCreatorConf import Trk__TrackParticleCreatorTool
InDetTrigParticleCreatorTool = \
Trk__TrackParticleCreatorTool( name = "InDetTrigParticleCreatorTool",
Extrapolator = InDetTrigExtrapolator,
TrackSummaryTool = InDetTrigTrackSummaryToolSharedHits,
KeepParameters = False,
ForceTrackSummaryUpdate = False,
)
ToolSvc += InDetTrigParticleCreatorTool
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigParticleCreatorTool
InDetTrigParticleCreatorToolWithSummary = \
Trk__TrackParticleCreatorTool( name = "InDetTrigParticleCreatorToolWithSummary",
Extrapolator = InDetTrigExtrapolator,
TrackSummaryTool = InDetTrigTrackSummaryToolSharedHits,
KeepParameters = True,
ForceTrackSummaryUpdate = True,
)
# UseClusterEnergy = False,
# UseClusterPhi = False)
#ToolSvc += ccotBuilderTool
#
#print ccotBuilderTool
#
#from egammaTrackTools.egammaTrackToolsConf import egammaTrkRefitterTool
#electronRefitterToolGSFCalo = egammaTrkRefitterTool(name = 'electronRefitterToolGSFCalo',
# FitterTool = GSFTrackFitter,
# CCOTBuilder = ccotBuilderTool,
# useBeamSpot = False,
# useClusterPosition = True,
# OutputLevel = 4
# )
#
#ToolSvc += electronRefitterToolGSFCalo
#
#print electronRefitterToolGSFCalo
#
#include("egammaBremRec/ElectronAnalysisCommonTools.py")
from TrkParticleCreator.TrkParticleCreatorConf import Trk__TrackParticleCreatorTool
InDetParticleCreatorTool = Trk__TrackParticleCreatorTool(
name="InDetParticleCreatorTool",
KeepParameters=True,
Extrapolator=InDetExtrapolator,
TrackSummaryTool=InDetTrackSummaryTool,
UseTrackSummaryTool=True,
ForceTrackSummaryUpdate=False)
ToolSvc += InDetParticleCreatorTool
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_ParticleCreatorTool = Trk__TrackParticleCreatorTool(
name=" FTK_ParticleCreatorTool",
Extrapolator=InDetTrigExtrapolator,
TrackSummaryTool=FTK_TrackSummaryHelperTool,
KeepParameters=True,
ForceTrackSummaryUpdate=False, #summary update moved (in the slimmer now)
)
ToolSvc += FTK_ParticleCreatorTool
print FTK_ParticleCreatorTool
print " added FTK_ParticleCreatorTool to ToolSvc"
from TrigInDetConf.TrigInDetRecVtxTools import InDetTrigLinFactory, InDetTrigVxEdmCnv
from TrigInDetConf.TrigInDetRecVtxTools import InDetTrigLinFactory, InDetTrigVxEdmCnv
from TrkVertexSeedFinderTools.TrkVertexSeedFinderToolsConf import Trk__CrossDistancesSeedFinder
FTK_VtxSeedFinder = Trk__CrossDistancesSeedFinder(
name="InDetTrigCrossDistancesSeedFinder",
trackdistcutoff=1.,
def makeInDetPrecisionTracking(whichSignature,
verifier=False,
inputFTFtracks='TrigFastTrackFinder_Tracks',
outputTrackPrefixName="HLT_ID",
rois='EMViewRoIs',
doTRTextension=True):
ptAlgs = [
] #List containing all the precision tracking algorithms hence every new added alg has to be appended to the list
#-----------------------------------------------------------------------------
# Naming conventions
algNamePrefix = "InDetTrigMT"
#If signature specified add suffix to the algorithms
signature = "_" + whichSignature if whichSignature else ''
#Name settings for output Tracks/TrackParticles
#This first part is for ambiguity solver tracks
nameAmbiTrackCollection = "%s%sTrkTrack%s" % (outputTrackPrefixName,
'AmbSol', signature)
#Tracks from TRT extension
nameExtTrackCollection = "%s%sTrkTrack%s" % (outputTrackPrefixName,
'TRText', signature)
#Note IDTrig suffix as a key to specify that this collection comes from precision tracking rather than fast tracking (FTF)
outPTTracks = "%sTrkTrack_%s_%s" % (outputTrackPrefixName,
remapSuffix(whichSignature), 'IDTrig')
outPTTrackParticles = "%sTrack_%s_%s" % (
outputTrackPrefixName, remapSuffix(whichSignature), 'IDTrig')
#Atm there are mainly two output track collections one from ambiguity solver stage and one from trt,
#we want to have the output name of the track collection the same whether TRT was run or not,
#e.g InDetTrigPT_Tracks_electron
if doTRTextension is True:
nameExtTrackCollection = outPTTracks
else:
nameAmbiTrackCollection = outPTTracks
#-----------------------------------------------------------------------------
# Verifying input data for the algorithms
#If run in views need to check data dependancies!
#NOTE: this seems necessary only when PT is called from a different view than FTF otherwise causes stalls
if verifier:
verifier.DataObjects += [
('InDet::PixelGangedClusterAmbiguities',
'StoreGateSvc+' + TrigPixelKeys.PixelClusterAmbiguitiesMap),
('TrackCollection', 'StoreGateSvc+' + inputFTFtracks)
]
from AthenaCommon.AppMgr import ToolSvc
#-----------------------------------------------------------------------------
# Choose track summary tool
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigTrackSummaryTool
from TrkTrackSummaryTool.TrkTrackSummaryToolConf import Trk__TrackSummaryTool
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigTrackSummaryHelperToolSharedHits, InDetTrigTRT_ElectronPidTool
trigTrackSummaryTool = Trk__TrackSummaryTool(
name="%sTrackSummaryToolSharedHitsWithTRT%s" %
(algNamePrefix, signature),
InDetSummaryHelperTool=InDetTrigTrackSummaryHelperToolSharedHits,
doSharedHits=True,
doHolesInDet=True)
if doTRTextension:
if "electron" in whichSignature or "tau" in whichSignature:
trigTrackSummaryTool.TRT_ElectronPidTool = InDetTrigTRT_ElectronPidTool
Parameter_config = True
SummaryTool_config = trigTrackSummaryTool
else:
SummaryTool_config = InDetTrigTrackSummaryTool
Parameter_config = False
ToolSvc += SummaryTool_config
#-----------------------------------------------------------------------------
# Ambiguity solving stage
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigExtrapolator
from InDetTrackScoringTools.InDetTrackScoringToolsConf import InDet__InDetAmbiScoringTool
InDetTrigAmbiScoringTool = InDet__InDetAmbiScoringTool(
name='%sScoringTool%s' % (algNamePrefix, signature),
Extrapolator=InDetTrigExtrapolator,
doEmCaloSeed=False,
SummaryTool=SummaryTool_config)
ToolSvc += InDetTrigAmbiScoringTool
#TODO: Need option to change scoring tool based on the slice (beamgas)
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigAmbiTrackSelectionTool
from InDetRecExample import TrackingCommon as TrackingCommon
from TrkAmbiguityProcessor.TrkAmbiguityProcessorConf import Trk__DenseEnvironmentsAmbiguityScoreProcessorTool as ScoreProcessorTool
InDetTrigAmbiguityScoreProcessor = ScoreProcessorTool(
name='%sAmbiguityScoreProcessor%s' % (algNamePrefix, signature),
ScoringTool=InDetTrigAmbiScoringTool,
AssociationTool=TrackingCommon.
getInDetTrigPRDtoTrackMapToolGangedPixels(),
SelectionTool=InDetTrigAmbiTrackSelectionTool)
from TrkAmbiguitySolver.TrkAmbiguitySolverConf import Trk__TrkAmbiguityScore
InDetTrigAmbiguityScore = Trk__TrkAmbiguityScore(
name='%sAmbiguityScore%s' % (algNamePrefix, signature),
TrackInput=[inputFTFtracks],
TrackOutput='ScoredMap' + signature,
AmbiguityScoreProcessor=InDetTrigAmbiguityScoreProcessor)
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigTrackFitter
from TrkAmbiguityProcessor.TrkAmbiguityProcessorConf import Trk__SimpleAmbiguityProcessorTool as ProcessorTool
InDetTrigMTAmbiguityProcessor = ProcessorTool(
name='%sAmbiguityProcessor%s' % (algNamePrefix, signature),
Fitter=InDetTrigTrackFitter,
ScoringTool=InDetTrigAmbiScoringTool,
AssociationTool=TrackingCommon.
getInDetTrigPRDtoTrackMapToolGangedPixels(),
TrackSummaryTool=SummaryTool_config,
SelectionTool=InDetTrigAmbiTrackSelectionTool)
ToolSvc += InDetTrigMTAmbiguityProcessor
from TrkAmbiguitySolver.TrkAmbiguitySolverConf import Trk__TrkAmbiguitySolver
InDetTrigMTAmbiguitySolver = Trk__TrkAmbiguitySolver(
name='%sAmbiguitySolver%s' % (algNamePrefix, signature),
TrackInput='ScoredMap' + signature,
TrackOutput=nameAmbiTrackCollection,
AmbiguityProcessor=InDetTrigMTAmbiguityProcessor)
ptAlgs.extend([InDetTrigAmbiguityScore, InDetTrigMTAmbiguitySolver])
if doTRTextension:
proxySignature = whichSignature
if "tau" in whichSignature:
proxySignature = "tau"
#-----------------------------------------------------------------------------
# TRT data preparation
from AthenaCommon.GlobalFlags import globalflags
#Only add raw data decoders if we're running over raw data
TRT_RDO_Key = "TRT_RDOs"
if globalflags.InputFormat.is_bytestream():
TRT_RDO_Key = TrigTRTKeys.RDOs
from TRT_RawDataByteStreamCnv.TRT_RawDataByteStreamCnvConf import TRT_RodDecoder
InDetTRTRodDecoder = TRT_RodDecoder(
name="%sTRTRodDecoder%s" % (algNamePrefix, signature),
LoadCompressTableDB=True
) #(globalflags.DataSource() != 'geant4'))
ToolSvc += InDetTRTRodDecoder
from TRT_RawDataByteStreamCnv.TRT_RawDataByteStreamCnvConf import TRTRawDataProviderTool
InDetTRTRawDataProviderTool = TRTRawDataProviderTool(
name="%sTRTRawDataProviderTool%s" % (algNamePrefix, signature),
Decoder=InDetTRTRodDecoder)
ToolSvc += InDetTRTRawDataProviderTool
# load the TRTRawDataProvider
from TRT_RawDataByteStreamCnv.TRT_RawDataByteStreamCnvConf import TRTRawDataProvider
InDetTRTRawDataProvider = TRTRawDataProvider(
name="%sTRTRawDataProvider%s" % (algNamePrefix, signature),
RDOKey=TrigTRTKeys.RDOs,
ProviderTool=InDetTRTRawDataProviderTool)
InDetTRTRawDataProvider.isRoI_Seeded = True
InDetTRTRawDataProvider.RoIs = rois
ptAlgs.append(InDetTRTRawDataProvider)
#-----------------------------------------------------------------------------
# TRT extension
# Keep track that this needs to have a switch between DAF and XK
# trkExtensionType = 'XK'
# if InDetTrigFlags.trtExtensionType() is 'DAF' :
from InDetTrigRecExample.InDetTrigCommonTools import InDetTrigTRT_DriftCircleTool
from InDetTrigRecExample.InDetTrigSliceSettings import InDetTrigSliceSettings
from InDetPrepRawDataFormation.InDetPrepRawDataFormationConf import InDet__TRT_RIO_Maker
InDetTrigTRTRIOMaker = InDet__TRT_RIO_Maker(
name="%sTRTDriftCircleMaker%s" % (algNamePrefix, signature),
TRTRIOLocation=TrigTRTKeys.DriftCircles,
TRTRDOLocation=TRT_RDO_Key,
#EtaHalfWidth = InDetTrigSliceSettings[('etaHalfWidth',signature)],
#PhiHalfWidth = InDetTrigSliceSettings[('phiHalfWidth',signature)],
#doFullScan = InDetTrigSliceSettings[('doFullScan',signature)],
TRT_DriftCircleTool=InDetTrigTRT_DriftCircleTool)
InDetTrigTRTRIOMaker.isRoI_Seeded = True
InDetTrigTRTRIOMaker.RoIs = rois
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigPatternPropagator, InDetTrigPatternUpdator
from InDetTrigRecExample.ConfiguredNewTrackingTrigCuts import EFIDTrackingCuts
InDetTrigCutValues = EFIDTrackingCuts
#from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigSiDetElementsRoadMaker, InDetTrigSiComTrackFinder
# Condition algorithm for InDet__TRT_DetElementsRoadMaker_xk
from AthenaCommon.AlgSequence import AthSequencer
condSeq = AthSequencer("AthCondSeq")
InDetTRTRoadAlgName = "%sTRT_DetElementsRoadCondAlg_xk" % (
algNamePrefix)
if not hasattr(condSeq, InDetTRTRoadAlgName):
from TRT_DetElementsRoadTool_xk.TRT_DetElementsRoadTool_xkConf import InDet__TRT_DetElementsRoadCondAlg_xk
# condSeq += InDet__TRT_DetElementsRoadCondAlg_xk(name = "%sTRT_DetElementsRoadCondAlg_xk%s"%(algNamePrefix, signature) )
condSeq += InDet__TRT_DetElementsRoadCondAlg_xk(
name=InDetTRTRoadAlgName)
from TRT_DetElementsRoadTool_xk.TRT_DetElementsRoadTool_xkConf import InDet__TRT_DetElementsRoadMaker_xk
InDetTrigTRTDetElementsRoadMaker = InDet__TRT_DetElementsRoadMaker_xk(
name='%sTRTRoadMaker%s' % (algNamePrefix, signature),
#DetectorStoreLocation = 'DetectorStore',
#TRTManagerLocation = 'TRT',
MagneticFieldMode='MapSolenoid',
PropagatorTool=InDetTrigPatternPropagator)
ToolSvc += InDetTrigTRTDetElementsRoadMaker
#TODO implement new configuration of circle cut
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigTRTDriftCircleCut
from TRT_TrackExtensionTool_xk.TRT_TrackExtensionTool_xkConf import InDet__TRT_TrackExtensionTool_xk
InDetTrigTRTExtensionTool = InDet__TRT_TrackExtensionTool_xk(
name="%sTrackExtensionTool%s" % (algNamePrefix, signature),
MagneticFieldMode='MapSolenoid', # default
TRT_ClustersContainer=TrigTRTKeys.DriftCircles, # default
TrtManagerLocation='TRT', # default
PropagatorTool=InDetTrigPatternPropagator,
UpdatorTool=InDetTrigPatternUpdator,
#RIOonTrackToolYesDr = # default for now
#RIOonTrackToolNoDr = # default for now
RoadTool=InDetTrigTRTDetElementsRoadMaker,
DriftCircleCutTool=InDetTrigTRTDriftCircleCut,
MinNumberDriftCircles=EFIDTrackingCuts.minTRTonTrk(),
ScaleHitUncertainty=2.,
RoadWidth=20.,
UseParameterization=EFIDTrackingCuts.useParameterizedTRTCuts())
ToolSvc += InDetTrigTRTExtensionTool
# TODO add second option of track extension
# elif InDetTrigFlags.trtExtensionType() is 'DAF' :
from TRT_TrackExtensionAlg.TRT_TrackExtensionAlgConf import InDet__TRT_TrackExtensionAlg
InDetTrigTRTextensionAlg = InDet__TRT_TrackExtensionAlg(
name="%sTrackExtensionAlg%s" % (algNamePrefix, signature),
InputTracksLocation=nameAmbiTrackCollection,
TrackExtensionTool=InDetTrigTRTExtensionTool,
ExtendedTracksLocation='ExtendedTrackMap')
#-----------------------------------------------------------------------------
# TRT processor
#TODO: do I need a new fitter for this? Or can I use the same one?
#TODO In Run2 option for cosmic
#InDetTrigExtensionFitter = InDetTrigTrackFitter
#from InDetTrackScoringTools.InDetTrackScoringToolsConf import InDet__InDetAmbiScoringTool
InDetTrigExtScoringTool = InDet__InDetAmbiScoringTool(
name='%sExtScoringTool%s' % (algNamePrefix, signature),
Extrapolator=InDetTrigExtrapolator,
SummaryTool=SummaryTool_config,
useAmbigFcn=True, # this is NewTracking
maxRPhiImp=InDetTrigCutValues.maxPrimaryImpact(),
maxZImp=InDetTrigCutValues.maxZImpact(),
maxEta=InDetTrigCutValues.maxEta(),
minSiClusters=InDetTrigCutValues.minClusters(),
maxSiHoles=InDetTrigCutValues.maxHoles(),
maxDoubleHoles=InDetTrigCutValues.maxDoubleHoles(),
usePixel=InDetTrigCutValues.usePixel(),
useSCT=InDetTrigCutValues.useSCT(),
doEmCaloSeed=False,
minTRTonTrk=InDetTrigCutValues.minTRTonTrk(),
#useSigmaChi2 = False # tuning from Thijs
DriftCircleCutTool=InDetTrigTRTDriftCircleCut,
)
InDetTrigExtScoringTool.minPt = InDetTrigSliceSettings[(
'pTmin', proxySignature)]
ToolSvc += InDetTrigExtScoringTool
from InDetExtensionProcessor.InDetExtensionProcessorConf import InDet__InDetExtensionProcessor
InDetTrigExtensionProcessor = InDet__InDetExtensionProcessor(
name="%sExtensionProcessor%s" % (algNamePrefix, signature),
TrackName=nameAmbiTrackCollection,
#Cosmics = InDetFlags.doCosmics(),
ExtensionMap='ExtendedTrackMap',
NewTrackName=nameExtTrackCollection,
TrackFitter=InDetTrigTrackFitter,
TrackSummaryTool=SummaryTool_config,
ScoringTool=
InDetTrigExtScoringTool, #TODO do I provide the same tool as for ambiguity solver?
suppressHoleSearch=False) # does not work properly
#Check these option after DAF is implemented
#tryBremFit = InDetFlags.doBremRecovery(),
#caloSeededBrem = InDetFlags.doCaloSeededBrem(),
#pTminBrem = NewTrackingCuts.minPTBrem() )
#RefitPrds = not (InDetFlags.refitROT() or (InDetFlags.trtExtensionType() is 'DAF')))
#InDetTRTExtension.OutputLevel = VERBOSE
ptAlgs.extend([
InDetTrigTRTRIOMaker, InDetTrigTRTextensionAlg,
InDetTrigExtensionProcessor
])
#-----------------------------------------------------------------------------
# Track particle conversion algorithm
#
#
""" Use the finalised track collection and convert it to container of xAOD Track Particles """
from TrkParticleCreator.TrkParticleCreatorConf import Trk__TrackParticleCreatorTool
InDetTrigMTxAODParticleCreatorTool = Trk__TrackParticleCreatorTool(
name="%sxAODParticleCreatorTool%s" % (algNamePrefix, signature),
Extrapolator=InDetTrigExtrapolator,
KeepParameters=Parameter_config,
#TrackSummaryTool = InDetTrigTrackSummaryToolSharedHits)
TrackSummaryTool=SummaryTool_config)
ToolSvc += InDetTrigMTxAODParticleCreatorTool
log.debug(InDetTrigMTxAODParticleCreatorTool)
from xAODTrackingCnv.xAODTrackingCnvConf import xAODMaker__TrackCollectionCnvTool
InDetTrigMTxAODTrackCollectionCnvTool = xAODMaker__TrackCollectionCnvTool(
name="%sxAODTrackCollectionCnvTool%s" % (algNamePrefix, signature),
TrackParticleCreator=InDetTrigMTxAODParticleCreatorTool)
ToolSvc += InDetTrigMTxAODTrackCollectionCnvTool
log.debug(InDetTrigMTxAODTrackCollectionCnvTool)
#This one shouldn't be necessary
#TODO: obsolete turn off
from xAODTrackingCnv.xAODTrackingCnvConf import xAODMaker__RecTrackParticleContainerCnvTool
InDetTrigMTRecTrackParticleContainerCnvTool = xAODMaker__RecTrackParticleContainerCnvTool(
name="%sRecTrackContainerCnvTool%s" % (algNamePrefix, signature),
TrackParticleCreator=InDetTrigMTxAODParticleCreatorTool)
ToolSvc += InDetTrigMTRecTrackParticleContainerCnvTool
#print (InDetTrigMTRecTrackParticleContainerCnvTool)
from TrigEDMConfig.TriggerEDMRun3 import recordable
from xAODTrackingCnv.xAODTrackingCnvConf import xAODMaker__TrackParticleCnvAlg
InDetTrigMTxAODTrackParticleCnvAlg = xAODMaker__TrackParticleCnvAlg(
name="%sxAODParticleCreatorAlg%s" % (algNamePrefix, signature),
# Properties below are used for: TrackCollection -> xAOD::TrackParticle
ConvertTracks=
True, #Turn on retrieve of TrackCollection, false by default
TrackContainerName=outPTTracks,
xAODTrackParticlesFromTracksContainerName=recordable(
outPTTrackParticles),
TrackCollectionCnvTool=InDetTrigMTxAODTrackCollectionCnvTool,
## Properties below are used for: Rec:TrackParticle, aod -> xAOD::TrackParticle (Turn off)
ConvertTrackParticles=
False, # Retrieve of Rec:TrackParticle, don't need this atm
xAODContainerName='',
RecTrackParticleContainerCnvTool=
InDetTrigMTRecTrackParticleContainerCnvTool,
TrackParticleCreator=InDetTrigMTxAODParticleCreatorTool)
#allViewAlgorithms += InDetTrigMTxAODTrackParticleCnvAlg
log.debug(InDetTrigMTxAODTrackParticleCnvAlg)
ptAlgs.append(InDetTrigMTxAODTrackParticleCnvAlg)
#ToolSvc.InDetTrigHoleSearchTool.SctSummaryTool.InDetTrigInDetSCT_FlaggedConditionTool.SCT_FlaggedCondData = "SCT_FlaggedCondData_TRIG"
#Potentialy other algs with more collections?
#Might Drop the list in the end and keep just one output key
nameTrackCollections = [outPTTracks]
nameTrackParticles = [outPTTrackParticles]
#Return list of Track keys, TrackParticle keys, and PT algs
return nameTrackCollections, nameTrackParticles, ptAlgs