diff --git a/Trigger/TrigAlgorithms/TrigMuonEF/CMakeLists.txt b/Trigger/TrigAlgorithms/TrigMuonEF/CMakeLists.txt
index 4913e6602b6edf101cb250b6fbdc3cab5de7fe86..a2e8880d3721a08d473421db1466f4e0e373532f 100644
--- a/Trigger/TrigAlgorithms/TrigMuonEF/CMakeLists.txt
+++ b/Trigger/TrigAlgorithms/TrigMuonEF/CMakeLists.txt
@@ -3,16 +3,11 @@
# Declare the package name:
atlas_subdir( TrigMuonEF )
-# External dependencies:
-find_package( CLHEP )
-find_package( ROOT COMPONENTS MathCore )
-
# Component(s) in the package:
atlas_add_component( TrigMuonEF
src/*.cxx
src/components/*.cxx
- INCLUDE_DIRS ${ROOT_INCLUDE_DIRS} ${CLHEP_INCLUDE_DIRS}
- LINK_LIBRARIES ${CLHEP_LIBRARIES} ${ROOT_LIBRARIES} AthContainers AthenaBaseComps AthenaKernel AthenaMonitoringKernelLib CaloEvent CscClusterizationLib CxxUtils EventPrimitives FourMomUtils GaudiKernel IRegionSelector InDetTrackSelectionToolLib MuidInterfaces MuonCablingData MuonCnvToolInterfacesLib MuonCombinedEvent MuonCombinedToolInterfaces MuonIdHelpersLib MuonPattern MuonPrepRawData MuonRIO_OnTrack MuonReadoutGeometry MuonRecToolInterfaces MuonSegment MuonSegmentCombinerToolInterfaces MuonSegmentMakerToolInterfaces Particle RecoToolInterfaces RPC_CondCablingLib StoreGateLib TrigCompositeUtilsLib TrigConfHLTData TrigInDetEvent TrigInterfacesLib TrigMuonEvent TrigMuonToolInterfaces TrigNavigationLib TrigParticle TrigSteeringEvent TrigTimeAlgsLib TrkEventPrimitives TrkParameters TrkSegment TrkToolInterfaces TrkTrack TrkTrackSummary xAODCaloEvent xAODMuon xAODTracking xAODTrigMuon )
+ LINK_LIBRARIES AthenaMonitoringKernelLib FourMomUtils InDetTrackSelectionToolLib TrigCompositeUtilsLib TrigMuonToolInterfaces )
# Install files from the package:
atlas_install_python_modules( python/*.py POST_BUILD_CMD ${ATLAS_FLAKE8} --extend-extensions=ATL900,ATL901 )
diff --git a/Trigger/TrigAlgorithms/TrigMuonEF/doc/packagedoc.h b/Trigger/TrigAlgorithms/TrigMuonEF/doc/packagedoc.h
deleted file mode 100644
index 51b568da621a3f7eb1a041c8c228155916dea66d..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuonEF/doc/packagedoc.h
+++ /dev/null
@@ -1,14 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-/**
-@page TrigMuonEF_page The TrigMuonEF Package
-
-@section TrigMuonEF_IntroTrigMuonEF Introduction
-
-This package provides the implementation of EF wrappers for the offline muon reconstruction algorithms.
-
-
-
-*/
diff --git a/Trigger/TrigAlgorithms/TrigMuonEF/python/TrigMuonEFConfig.py b/Trigger/TrigAlgorithms/TrigMuonEF/python/TrigMuonEFConfig.py
index 79ac0573ff888c588f7f7c9962903a6b261cee02..842801b8344765b1a3486cd688314ddd7e7f1942 100755
--- a/Trigger/TrigAlgorithms/TrigMuonEF/python/TrigMuonEFConfig.py
+++ b/Trigger/TrigAlgorithms/TrigMuonEF/python/TrigMuonEFConfig.py
@@ -3,660 +3,7 @@
# TrigMuonEF configurables
#
from TrigMuonEF import TrigMuonEFConf
-from TrigMuonEF import TrigMuonEFMonitoring
-from TriggerJobOpts.TriggerFlags import TriggerFlags
-from AthenaCommon.AppMgr import ToolSvc
-from AthenaCommon.AppMgr import ServiceMgr
-from AthenaCommon import CfgMgr
-from AthenaCommon import CfgGetter
-from AthenaCommon.DetFlags import DetFlags
-from AthenaCommon.SystemOfUnits import GeV,mm
-from AthenaCommon.Logging import logging
-log = logging.getLogger('TrigMuonEFConfig')
-
-from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
-
-from RecExConfig.RecFlags import rec
-from MuonCombinedRecExample.MuonCombinedRecFlags import muonCombinedRecFlags
-
-from TrkDetDescrSvc.AtlasTrackingGeometrySvc import AtlasTrackingGeometrySvc
-
-from MuonRecExample.MuonRecFlags import muonRecFlags
-from AtlasGeoModel.MuonGMJobProperties import MuonGeometryFlags
-
-from InDetRecExample import TrackingCommon
-
-from AthenaCommon.BeamFlags import jobproperties
-beamFlags = jobproperties.Beam
-
-#Offline calorimeter isolation tool
-#from TrackInCaloTools import TrackInCaloTools
-#TMEFTrackInCaloTools = TrackInCaloTools.TrackInCaloTools(name='MuonIsoTrackInCaloTools')
-#ToolSvc += TMEFTrackInCaloTools
-
-#from IsolationTool.IsolationToolConf import xAOD__CaloIsolationTool
-#TMEFCaloIsolationTool = xAOD__CaloIsolationTool(name='MuonIsoCaloIsolationTool',
-# ExtrapolTrackToCaloTool = TMEFTrackInCaloTools)
-
-#ToolSvc += TMEFCaloIsolationTool
-
-from egammaRec.Factories import PublicToolFactory
-
-from AthenaCommon.GlobalFlags import globalflags
-isMC = not globalflags.DataSource()=='data'
-from IsolationCorrections.IsolationCorrectionsConf import CP__IsolationCorrectionTool as ICT
-IsoCorrectionTool = PublicToolFactory(ICT,
- name = "NewLeakageCorrTool",
- IsMC = isMC)
-
-from IsolationTool.IsolationToolConf import xAOD__CaloIsolationTool
-
-# tool to collect topo clusters in cone
-from ParticlesInConeTools.ParticlesInConeToolsConf import xAOD__CaloClustersInConeTool
-CaloClustersInConeTool = PublicToolFactory(xAOD__CaloClustersInConeTool,
- CaloClusterLocation = "CaloCalTopoClusters")
-
-from CaloClusterCorrection import CaloClusterCorrectionConf as Cccc
-TrigCaloFillRectangularCluster = PublicToolFactory( Cccc.CaloFillRectangularCluster,
- name = "trigMuon_CaloFillRectangularCluster",
- eta_size = 5,
- phi_size = 7,
- cells_name = "")
-
-
-if not hasattr(ServiceMgr,"TrackingVolumesSvc"):
- from TrkDetDescrSvc.TrkDetDescrSvcConf import Trk__TrackingVolumesSvc
- ServiceMgr += Trk__TrackingVolumesSvc("TrackingVolumesSvc")
-
-def TMEF_MaterialEffectsUpdator(name='TMEF_MaterialEffectsUpdator',**kwargs):
- return CfgMgr.Trk__MaterialEffectsUpdator(name,**kwargs)
-
-
-def TMEF_Propagator(name='TMEF_Propagator',**kwargs):
- return ToolSvc.AtlasRungeKuttaPropagator
- return CfgMgr.Trk__IntersectorWrapper(name,**kwargs)
-
-
-def TMEF_Navigator(name='TMEF_Navigator',**kwargs):
- return TrackingCommon.getAtlasNavigator(name)
-
-
-def TMEF_Extrapolator(name='TMEF_Extrapolator',**kwargs):
- return ToolSvc.AtlasExtrapolator
- kwargs.setdefault("Propagators", [ "TMEF_Propagator" ])
- kwargs.setdefault("MaterialEffectsUpdators",[ "TMEF_MaterialEffectsUpdator" ])
- kwargs.setdefault("Navigator","TMEF_Navigator")
- return CfgMgr.Trk__Extrapolator(name,**kwargs)
-
-
-def TMEF_CaloEnergyTool(name='TMEF_CaloEnergyTool', **kwargs):
- kwargs.setdefault("EnergyLossMeasurement",False)
- kwargs.setdefault("MopParametrization",True)
- return CfgMgr.Rec__MuidCaloEnergyTool(name,**kwargs)
-
-
-def TMEF_CaloTrackStateOnSurface(name='TMEF_CaloTrackStateOnSurface',**kwargs):
- kwargs.setdefault("CaloEnergyDeposit","TMEF_CaloEnergyTool")
- kwargs.setdefault("CaloEnergyParam" ,"TMEF_CaloEnergyTool")
- kwargs.setdefault("Propagator", "TMEF_Propagator")
- kwargs.setdefault("MinRemainingEnergy", 0.2*GeV)
- kwargs.setdefault("ParamPtCut", 3.0*GeV)
- return CfgMgr.Rec__MuidCaloTrackStateOnSurface(name,**kwargs)
-
-
-def TMEF_TrackSummaryTool(name='TMEF_TrackSummaryTool',**kwargs):
- # always setup muon tool
- kwargs.setdefault("MuonSummaryHelperTool", "MuonTrackSummaryHelperTool")
- kwargs.setdefault("doSharedHits", False)
- # only add ID tool if ID is on
- if DetFlags.detdescr.ID_on():
- from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigTrackSummaryHelperTool
- kwargs.setdefault("InDetSummaryHelperTool", InDetTrigTrackSummaryHelperTool)
- kwargs.setdefault("doHolesInDet",True)
-
- return CfgMgr.Trk__TrackSummaryTool(name,**kwargs)
-
-
-def TMEF_CombinedMuonTag(name='TMEF_CombinedMuonTag',**kwargs):
- kwargs.setdefault("ExtrapolatorTool","TMEF_Extrapolator")
- kwargs.setdefault("Chi2Cut", 50000.) # Muid: 50000. old value: 2500.
- return CfgMgr.MuonCombined__MuonTrackTagTestTool(name,**kwargs)
-
-
-def TMEF_MatchQuality(name='TMEF_MatchQuality',**kwargs):
- kwargs.setdefault("TagTool","TMEF_CombinedMuonTag")
- kwargs.setdefault("TrackQuery","TMEF_MuonTrackQuery")
- return CfgMgr.Rec__MuonMatchQuality(name,**kwargs)
-
-def TMEF_MaterialAllocator(name='TMEF_MaterialAllocator',**kwargs):
- kwargs.setdefault("AggregateMaterial", True)
- kwargs.setdefault("Extrapolator","TMEF_Extrapolator")
- kwargs.setdefault("TrackingGeometrySvc", AtlasTrackingGeometrySvc)
- return CfgMgr.Trk__MaterialAllocator(name,**kwargs)
-
-
-
-def TMEF_iPatFitter(name='TMEF_iPatFitter',**kwargs):
- kwargs.setdefault("AggregateMaterial", True)
- kwargs.setdefault("FullCombinedFit", True)
- if not TriggerFlags.run2Config == '2016':
- kwargs.setdefault("MaxIterations", 15)
- kwargs.setdefault("MaterialAllocator", "TMEF_MaterialAllocator")
- from InDetRecExample import TrackingCommon
- kwargs.setdefault("SolenoidalIntersector",TrackingCommon.getSolenoidalIntersector())
- kwargs.setdefault("TrackSummaryTool", 'TMEF_TrackSummaryTool')
- return CfgMgr.Trk__iPatFitter(name,**kwargs)
-
-
-def TMEF_iPatSLFitter(name='TMEF_iPatSLFitter',**kwargs):
- kwargs.setdefault("LineFit", True)
- #kwargs.setdefault("LineMomentum", muonStandaloneFlags.straightLineFitMomentum())
- # call the other factory function
- return TMEF_iPatFitter(name,**kwargs)
-
-
-def TMEF_TrackCleaner(name = 'TMEF_TrackCleaner',**kwargs):
- if TriggerFlags.run2Config=='2016':
- kwargs.setdefault('PullCut', 3.0)
- kwargs.setdefault('PullCutPhi', 3.0)
- else:
- kwargs.setdefault('PullCut', 4.0)
- kwargs.setdefault('PullCutPhi', 4.0)
- kwargs.setdefault("Fitter", "TMEF_iPatFitter")
- kwargs.setdefault("SLFitter", "TMEF_iPatSLFitter")
- if not TriggerFlags.run2Config == '2016':
- kwargs.setdefault("Iterate", False)
- kwargs.setdefault("RecoverOutliers", False)
- if muonRecFlags.doSegmentT0Fit():
- kwargs.setdefault("RecoverOutliers", False)
- return CfgMgr.Muon__MuonTrackCleaner(name,**kwargs)
-
-
-def TMEF_TrkMaterialProviderTool(name='TMEF_TrkMaterialProviderTool',**kwargs):
- kwargs.setdefault("UseCaloEnergyMeasurement", False)
- return TrackingCommon.getTrkMaterialProviderTool(name,**kwargs)
-
-
-def TMEF_CombinedMuonTrackBuilder(name='TMEF_CombinedMuonTrackBuilder',**kwargs):
- kwargs.setdefault("CaloEnergyParam", "TMEF_CaloEnergyTool")
- kwargs.setdefault("CaloTSOS", "TMEF_CaloTrackStateOnSurface")
- kwargs.setdefault("CscRotCreator", "") # enabled with special version in Muid offline
- kwargs.setdefault("Fitter", "TMEF_iPatFitter")
- kwargs.setdefault("SLFitter", "TMEF_iPatSLFitter")
- kwargs.setdefault("MaterialAllocator", "TMEF_MaterialAllocator")
- kwargs.setdefault("MdtRotCreator", "MdtDriftCircleOnTrackCreator")
- kwargs.setdefault("MuonHoleRecovery", "")
- kwargs.setdefault("Propagator", "TMEF_Propagator")
- kwargs.setdefault("SLPropagator", "TMEF_Propagator")
- kwargs.setdefault("CleanCombined", True)
- kwargs.setdefault("CleanStandalone", True)
- kwargs.setdefault("BadFitChi2", 2.5)
- kwargs.setdefault("LargeMomentumError", 0.5)
- #kwargs.setdefault("LineMomentum", muonStandaloneFlags.straightLineFitMomentum())
- kwargs.setdefault("LowMomentum", 10.*GeV)
- kwargs.setdefault("MinEnergy", 0.3*GeV)
- kwargs.setdefault("PerigeeAtSpectrometerEntrance", False)
- kwargs.setdefault("ReallocateMaterial", False)
- kwargs.setdefault("Vertex2DSigmaRPhi", 100.*mm)
- kwargs.setdefault("Vertex3DSigmaRPhi", 6.*mm)
- kwargs.setdefault("Vertex3DSigmaZ", 60.*mm)
- if not TriggerFlags.run2Config == '2016':
- kwargs.setdefault("MuonErrorOptimizer", '')
-
- # note - the TrackSummaryTool is done as follows offline:
- # import MuonCombinedRecExample.CombinedMuonTrackSummary
- # combinedMuonTrackBuilder.TrackSummaryTool = ToolSvc.CombinedMuonTrackSummary
- # should check our config is really ok here
- kwargs.setdefault("TrackSummaryTool", 'TMEF_TrackSummaryTool')
-
- # extra w.r.t. Muid Offline
- kwargs.setdefault("Cleaner", "TMEF_TrackCleaner")
- if muonRecFlags.doSegmentT0Fit():
- kwargs.setdefault("MdtRotCreator", "")
-
- kwargs.setdefault("UseCaloTG", True)
- kwargs.setdefault("CaloMaterialProvider", "TMEF_TrkMaterialProviderTool")
- kwargs.setdefault("TrackQuery", "TMEF_MuonTrackQuery")
- if muonRecFlags.enableErrorTuning():
- kwargs.setdefault("MuonErrorOptimizer", CfgGetter.getPublicToolClone("TMEF_MuidErrorOptimisationTool",
- "MuonErrorOptimisationTool",
- PrepareForFit = False,
- RecreateStartingParameters = False,
- RefitTool = CfgGetter.getPublicToolClone("TMEF_MuidRefitTool",
- "MuonRefitTool",
- AlignmentErrors = False,
- Fitter = CfgGetter.getPublicTool("iPatFitter"))
- ))
-
- return CfgMgr.Rec__CombinedMuonTrackBuilder(name,**kwargs)
-
-
-def TMEF_MuonTrackQuery(name='TMEF_MuonTrackQuery',**kwargs):
- kwargs.setdefault("MdtRotCreator","MdtDriftCircleOnTrackCreator")
- kwargs.setdefault("Fitter", 'TMEF_iPatFitter')
- return CfgMgr.Rec__MuonTrackQuery(name,**kwargs)
-
-
-def TMEF_MatchMaker(name='TMEF_MatchMaker',**kwargs):
- kwargs.setdefault("AmbiguityProcessor", "MuonAmbiProcessor")
- kwargs.setdefault("MatchQuality", "TMEF_MatchQuality")
- kwargs.setdefault("CaloTSOS", "TMEF_CaloTrackStateOnSurface") # not in Muid?
- kwargs.setdefault("TrackBuilder", "TMEF_CombinedMuonTrackBuilder")
- kwargs.setdefault("TrackQuery", "TMEF_MuonTrackQuery")
- kwargs.setdefault("Propagator", "TMEF_Propagator")
- kwargs.setdefault("IndetPullCut", 6.0)
- kwargs.setdefault("MomentumBalanceCut", 10.0) # old value: 20.0
- return CfgMgr.Rec__MuidMatchMaker(name,**kwargs)
-
-
-def TMEF_TrackBuilderTool(name='TMEF_TrackBuilderTool',extraFlags=None,**kwargs):
- if extraFlags is None:
- from MuonRecExample.MuonRecUtils import ExtraFlags
- extraFlags = ExtraFlags()
-
- extraFlags.setFlagDefault("namePrefix","TMEF_")
- # extraFlags.setFlagDefault("optimiseMomentumResolutionUsingChi2", False) # offline default: False
- # extraFlags.setFlagDefault("materialSource", "TGMat") # offline default: "TGMat"
- from MuonRecExample.MuonStandalone import MuonTrackSteering
- return MuonTrackSteering(name, extraFlags=extraFlags, **kwargs)
-
-# new tools added by MO
-def TMEF_TrackSummaryToolNoHole(name='TMEF_TrackSummaryToolNoHole',**kwargs):
- sumtool = TMEF_TrackSummaryTool(name, **kwargs)
- sumtool.doHolesInDet = False
- # @TODO to switch off hole search should use a prticular InDet...Helper
- return sumtool
-
-def TMEF_TrkToTrackParticleConvTool(name="TMEF_TrkToTrackParticleConvTool",**kwargs):
- #import MuonCombinedRecExample.CombinedMuonTrackSummary
- kwargs.setdefault("TrackSummaryTool", 'TMEF_TrackSummaryToolNoHole')#ToolSvc.CombinedMuonTrackSummary ) #getPublicTool("CombinedMuonTrackSummary") )
- kwargs.setdefault("KeepAllPerigee",False )
- return CfgMgr.Trk__TrackParticleCreatorTool(name,**kwargs)
-
-def TMEF_MuonCombinedTool(name="TMEF_MuonCombinedTool",**kwargs):
- #protectedInclude ("MuidExample/MuonIdentification_jobOptions.py")
- kwargs.setdefault("MuonCombinedTagTools", [ "TMEF_MuonCombinedFitTagTool" ] )
- # kwargs.setdefault("PtBalancePreSelection", 0.75)
- return CfgMgr.MuonCombined__MuonCombinedTool(name,**kwargs)
-
-def TMEF_MuidMuonRecovery(name='TMEF_MuidMuonRecovery',**kwargs):
- kwargs.setdefault('Extrapolator', "AtlasExtrapolator")
- kwargs.setdefault('TrackBuilder',"TMEF_CombinedMuonTrackBuilder")
- return CfgMgr.Rec__MuidMuonRecovery(name,**kwargs)
-
-def MuonHolesOnTrack(name='MuonHolesOnTrack',**kwargs):
- kwargs.setdefault("ExtrapolatorName" , "MuonExtrapolator" )
- kwargs.setdefault("RIO_OnTrackCreator" , "MuonRotCreator" )
- kwargs.setdefault("DoHolesIdentification" , True )
- kwargs.setdefault("DoParameterUpdate", True )
- kwargs.setdefault("LowerTrackMomentumCut", 2000.0 )
- AtlasTrackingGeometrySvc = CfgGetter.getService("AtlasTrackingGeometrySvc")
- kwargs.setdefault("TrackingGeometryName", AtlasTrackingGeometrySvc.TrackingGeometryName )
-
- from MuonTGRecTools.MuonTGRecToolsConf import Muon__MuonHolesOnTrackTool
- return Muon__MuonHolesOnTrackTool(name,**kwargs)
-# end of factory function MuonHolesOnTrackTool
-
-# need to do something about cosmics here - in offline this tool is None if not collisions running
-# if jobproperties.Beam.beamType()=='collisions':
-def TMEF_CombMuonMEOTPParam(name='TMEF_CombMuonMEOTPParam',**kwargs):
- kwargs.setdefault('TSOSTool','TMEF_CaloTrackStateOnSurface')
- from MuidCaloScatteringTools.MuidCaloScatteringToolsConf import Rec__MuidMaterialEffectsOnTrackProvider
- return Rec__MuidMaterialEffectsOnTrackProvider(name, **kwargs)
-
-def TMEF_MuonCombinedPropagator(name='TMEF_MuonCombinedPropagator',**kwargs):
- kwargs.setdefault('AccuracyParameter', 0.000001)
- kwargs.setdefault('IncludeBgradients', True)
- kwargs.setdefault('MaxStraightLineStep', 0.001)
- kwargs.setdefault('MaxHelixStep', 0.001)
- from TrkExRungeKuttaPropagator.TrkExRungeKuttaPropagatorConf import Trk__RungeKuttaPropagator
- return Trk__RungeKuttaPropagator(name, **kwargs)
-
-def TMEF_MuonCombinedTrackFitter(name='TMEF_MuonCombinedTrackFitter',**kwargs):
- kwargs.setdefault('ExtrapolationTool', 'AtlasExtrapolator')#gpt
- kwargs.setdefault('NavigatorTool', ToolSvc.MuonNavigator)
- kwargs.setdefault('PropagatorTool', 'TMEF_MuonCombinedPropagator')#gpt
- kwargs.setdefault('RotCreatorTool', 'MuonRotCreator')#gpt
- kwargs.setdefault('MeasurementUpdateTool', 'MuonMeasUpdator')#gpt
- kwargs.setdefault('TrackingGeometrySvc', ServiceMgr.AtlasTrackingGeometrySvc)
- kwargs.setdefault('ExtrapolatorMaterial', True)
- kwargs.setdefault('MuidTool', None)
- kwargs.setdefault('MuidToolParam', 'TMEF_CombMuonMEOTPParam')#gpt
- kwargs.setdefault('MuidMat', False)
- kwargs.setdefault('StraightLine', False) #FIX? StraightLine = not jobproperties.BField.solenoidOn() and not jobproperties.BField.allToroidOn(),
- kwargs.setdefault('MaxIterations', 50)
- kwargs.setdefault('GetMaterialFromTrack', True) #FIX? jobproperties.BField.solenoidOn() and jobproperties.BField.allToroidOn(),
- kwargs.setdefault('RecalculateDerivatives',False)
- kwargs.setdefault("UseCaloTG", True)
- kwargs.setdefault("CaloMaterialProvider", "TMEF_TrkMaterialProviderTool")
- from TrkGlobalChi2Fitter.TrkGlobalChi2FitterConf import Trk__GlobalChi2Fitter
- return Trk__GlobalChi2Fitter(name, **kwargs)
-
-def TMEF_MuonCombinedFitTagTool(name="TMEF_MuonCombinedFitTagTool",**kwargs):
- kwargs.setdefault("TrackBuilder", 'TMEF_CombinedMuonTrackBuilder' )
- if not TriggerFlags.run2Config == '2016':
- kwargs.setdefault("MuonRecovery", '' )
- else:
- kwargs.setdefault("MuonRecovery", 'TMEF_MuidMuonRecovery' )
- kwargs.setdefault("TrackQuery", 'TMEF_MuonTrackQuery' )
- kwargs.setdefault("MatchQuality", 'TMEF_MatchQuality' )
- return CfgMgr.MuonCombined__MuonCombinedFitTagTool(name,**kwargs)
-
-def TMEF_MuonCandidateTool(name="TMEF_MuonCandidateTool",**kwargs):
- kwargs.setdefault("TrackBuilder","TMEF_CombinedMuonTrackBuilder")
- if beamFlags.beamType() == 'cosmics':
- kwargs.setdefault("TrackExtrapolationTool", CfgGetter.getPublicTool("ExtrapolateMuonToIPTool"))
- return CfgMgr.MuonCombined__MuonCandidateTool(name,**kwargs)
-
-def TrigMuonAmbiProcessor(name="TrigMuonAmbiProcessor",**kwargs) :
- # definition mostly copied from MuonRecExample/python/MooreTools.py
- import InDetRecExample.TrackingCommon as TrackingCommon
- kwargs.setdefault("AssociationTool",TrackingCommon.getInDetTrigPRDtoTrackMapToolGangedPixels())
- kwargs.setdefault("DropDouble", False)
- kwargs.setdefault("ScoringTool", "MuonTrackScoringTool")
- kwargs.setdefault("SelectionTool", "MuonAmbiSelectionTool" )
- return CfgMgr.Trk__TrackSelectionProcessorTool(name,**kwargs)
-
-def TMEF_MuonCreatorTool(name="TMEF_MuonCreatorTool",**kwargs):
- from TrkExTools.AtlasExtrapolator import AtlasExtrapolator
- from TrackToCalo.TrackToCaloConf import Trk__ParticleCaloExtensionTool
- pcExtensionTool = Trk__ParticleCaloExtensionTool(Extrapolator = AtlasExtrapolator())
- kwargs.setdefault("ParticleCaloExtensionTool", pcExtensionTool)
- #Should be safe as the dynamic alignment is only for data
- kwargs.setdefault("ParticleCaloExtensionToolID", pcExtensionTool)
- kwargs.setdefault('TrackParticleCreator','TMEF_TrkToTrackParticleConvTool')
- kwargs.setdefault("AmbiguityProcessor", CfgGetter.getPublicTool('TrigMuonAmbiProcessor'))
- kwargs.setdefault('MakeTrackAtMSLink',True)
- kwargs.setdefault("CaloMaterialProvider", "TMEF_TrkMaterialProviderTool")
- kwargs.setdefault("FillTimingInformation",False)
- kwargs.setdefault("MuonSelectionTool", "")
- kwargs.setdefault("TrackQuery", "TMEF_MuonTrackQuery")
- kwargs.setdefault("TrackSummaryTool", "TMEF_TrackSummaryTool")
- return CfgMgr.MuonCombined__MuonCreatorTool(name,**kwargs)
-
-def TMEF_MuonCandidateTrackBuilderTool(name="TMEF_MuonCandidateTrackBuilderTool",**kwargs):
- kwargs.setdefault('MuonTrackBuilder', 'TMEF_CombinedMuonTrackBuilder')
- from MuonRecExample.MuonRecUtils import ExtraFlags
- extraFlags = ExtraFlags()
- extraFlags.setFlagDefault("doSegmentPhiMatching", True)
- from MuonRecExample.MuonStandaloneFlags import muonStandaloneFlags
- extraFlags.setFlagDefault(muonStandaloneFlags.optimiseMomentumResolutionUsingChi2) # take name & value from JobProperty
- extraFlags.setFlagDefault(muonStandaloneFlags.strategy)
- extraFlags.setFlagDefault(muonStandaloneFlags.trackBuilder)
- extraFlags.setFlagDefault(muonStandaloneFlags.printSummary)
- extraFlags.setFlagDefault(muonStandaloneFlags.refinementTool)
- if "TrackBuilderTool" not in kwargs:
- extraFlags.setFlagDefault('UseTrackingHistory',True)
- kwargs.setdefault('MuonSegmentTrackBuilder', CfgGetter.getPublicToolClone("MooMuonTrackBuilder","MooTrackBuilderTemplate",extraFlags=extraFlags))
- return CfgMgr.Muon__MuonCandidateTrackBuilderTool(name,**kwargs)
-
-def TMEF_MuonPRDSelectionTool(name="TMEF_MuonPRDSelectionTool",**kwargs):
- kwargs.setdefault('MuonRecoValidationTool','')
- return CfgMgr.Muon__MuonPRDSelectionTool(name,**kwargs)
-
-def TMEF_MuonClusterSegmentFinder(name="TMEF_MuonClusterSegmentFinder", **kwargs):
- kwargs.setdefault('MuonPRDSelectionTool', 'TMEF_MuonPRDSelectionTool')
- return CfgMgr.Muon__MuonClusterSegmentFinder(name,**kwargs)
-
-def TMEF_MuonClusterSegmentFinderTool(name="TMEF_MuonClusterSegmentFinderTool", extraFlags=None,**kwargs):
- kwargs.setdefault("TrackSummaryTool", "TMEF_TrackSummaryTool")
- return CfgMgr.Muon__MuonClusterSegmentFinderTool(name,**kwargs)
-
-def TMEF_MuonLayerSegmentFinderTool(name="TMEF_MuonLayerSegmentFinderTool",**kwargs):
- kwargs.setdefault('MuonRecoValidationTool','')
- kwargs.setdefault('MuonPRDSelectionTool','TMEF_MuonPRDSelectionTool')
- kwargs.setdefault('MuonClusterSegmentFinder','TMEF_MuonClusterSegmentFinder')
- if not MuonGeometryFlags.hasCSC():
- kwargs.setdefault('Csc2DSegmentMaker', '')
- kwargs.setdefault('Csc4DSegmentMaker', '')
- if (MuonGeometryFlags.hasSTGC() and MuonGeometryFlags.hasMM()): kwargs.setdefault('NSWMuonClusterSegmentFinderTool','TMEF_MuonClusterSegmentFinderTool')
- return CfgMgr.Muon__MuonLayerSegmentFinderTool(name,**kwargs)
-
-def TMEF_MuonInsideOutRecoTool(name="TMEF_MuonInsideOutRecoTool",**kwargs):
- kwargs.setdefault('MuonTrackBuilder','TMEF_CombinedMuonTrackBuilder')
- kwargs.setdefault('MuonCandidateTrackBuilderTool','TMEF_MuonCandidateTrackBuilderTool')
- kwargs.setdefault('MuonRecoValidationTool','')
- kwargs.setdefault('MuonLayerSegmentFinderTool', 'TMEF_MuonLayerSegmentFinderTool')
- return CfgMgr.MuonCombined__MuonInsideOutRecoTool(name,**kwargs )
-
-### Stau late trigger configs
-
-def TMEF_MuonStauRecoTool( name='TMEF_MuonStauRecoTool', **kwargs ):
- # kwargs.setdefault('DoSummary', True)
- kwargs.setdefault('DoSummary', muonCombinedRecFlags.printSummary() )
- kwargs.setdefault('ConsideredPDGs', [13,-13,1000015,-1000015])
- kwargs.setdefault('DoTruth', rec.doTruth() )
- kwargs.setdefault('MuonSegmentMaker', CfgGetter.getPublicTool('DCMathStauSegmentMaker') )
- kwargs.setdefault('MuonInsideOutRecoTool', CfgGetter.getPublicTool('TMEF_MuonStauInsideOutRecoTool') )
- return CfgMgr.MuonCombined__MuonStauRecoTool(name,**kwargs )
-
-def TMEF_MuonStauInsideOutRecoTool( name='TMEF_MuonStauInsideOutRecoTool', **kwargs ):
- kwargs.setdefault('MuonTrackBuilder','TMEF_CombinedMuonTrackBuilder')
- kwargs.setdefault('MuonCandidateTrackBuilderTool', CfgGetter.getPublicTool('TMEF_MuonStauCandidateTrackBuilderTool') )
- return CfgMgr.MuonCombined__MuonInsideOutRecoTool(name,**kwargs )
-
-def TMEF_MuonStauCandidateTrackBuilderTool( name='TMEF_MuonStauCandidateTrackBuilderTool',**kwargs):
- kwargs.setdefault('MuonTrackBuilder', CfgGetter.getPublicTool('TMEF_CombinedStauTrackBuilder') )
- return CfgMgr.Muon__MuonCandidateTrackBuilderTool(name,**kwargs)
-
-def TMEF_CombinedStauTrackBuilder( name='TMEF_CombinedStauTrackBuilder', **kwargs ):
- kwargs.setdefault('MdtRotCreator' , CfgGetter.getPublicTool('MdtDriftCircleOnTrackCreatorStau') )
- kwargs.setdefault('MuonHoleRecovery' , CfgGetter.getPublicTool('TMEF_MuonStauSegmentRegionRecoveryTool') )
- return TMEF_CombinedMuonTrackBuilder(name,**kwargs )
-
-def TMEF_MuonStauSegmentRegionRecoveryTool(name='TMEF_MuonStauSegmentRegionRecoveryTool',**kwargs ):
- kwargs.setdefault('SeededSegmentFinder', CfgGetter.getPublicTool('MuonStauSeededSegmentFinder') )
- kwargs.setdefault('ChamberHoleRecoveryTool', CfgGetter.getPublicTool('MuonStauChamberHoleRecoveryTool') )
- kwargs.setdefault('Fitter', CfgGetter.getPublicTool('TMEF_CombinedStauTrackBuilderFit') )
- from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
- if athenaCommonFlags.isOnline:
- kwargs.setdefault('MdtCondKey', "")
- return CfgMgr.Muon__MuonSegmentRegionRecoveryTool(name,**kwargs)
-
-def TMEF_CombinedStauTrackBuilderFit( name='TMEF_CombinedStauTrackBuilderFit', **kwargs ):
- kwargs.setdefault('MdtRotCreator' , CfgGetter.getPublicTool('MdtDriftCircleOnTrackCreatorStau') )
- return TMEF_CombinedMuonTrackBuilder(name,**kwargs )
-
-def TMEF_MdtRawDataProviderTool(name="TMEF_MdtRawDataProviderTool",**kwargs):
- kwargs.setdefault("Decoder", "MdtROD_Decoder")
- from OverlayCommonAlgs.OverlayFlags import overlayFlags
- if DetFlags.overlay.MDT_on() and overlayFlags.isDataOverlay():
- kwargs.setdefault("RdoLocation",overlayFlags.dataStore()+"+MDTCSM")
- return CfgMgr.Muon__MDT_RawDataProviderTool(name,**kwargs)
-
-def TMEF_RpcRawDataProviderTool(name = "TMEF_RpcRawDataProviderTool",**kwargs):
- kwargs.setdefault("Decoder", "RpcROD_Decoder")
- from OverlayCommonAlgs.OverlayFlags import overlayFlags
- if DetFlags.overlay.RPC_on() and overlayFlags.isDataOverlay():
- kwargs.setdefault("RdoLocation", overlayFlags.dataStore()+"+RPCPAD")
- return CfgMgr.Muon__RPC_RawDataProviderTool(name,**kwargs)
-
-def TMEF_TgcRawDataProviderTool(name = "TMEF_TgcRawDataProviderTool",**kwargs):
- kwargs.setdefault("Decoder", "TgcROD_Decoder")
- from OverlayCommonAlgs.OverlayFlags import overlayFlags
- if DetFlags.overlay.TGC_on() and overlayFlags.isDataOverlay():
- kwargs.setdefault("RdoLocation", overlayFlags.dataStore()+"+TGCRDO")
- return CfgMgr.Muon__TGC_RawDataProviderTool(name,**kwargs)
-
-def TMEF_CscRawDataProviderTool(name = "TMEF_CscRawDataProviderTool",**kwargs):
- kwargs.setdefault("Decoder", "CscROD_Decoder")
- from OverlayCommonAlgs.OverlayFlags import overlayFlags
- if DetFlags.overlay.CSC_on() and overlayFlags.isDataOverlay():
- kwargs.setdefault("RdoLocation", overlayFlags.dataStore()+"+CSCRDO")
- return CfgMgr.Muon__CSC_RawDataProviderTool(name,**kwargs)
-
-# TrigMuonEF classes
-class TrigMuonEFTrackBuilderConfig ():
- __slots__ = ()
-
- def __init__( self, name="TrigMuonEFTrackBuilder" ):
-
- raise RuntimeError("TrigMuonEFTrackBuilder no longer supported in release 19 (or later) due to removal of MooTrackSteering from the release.")
-
-class TrigMuonEFCombinerConfig ():
- __slots__ = ()
-
- def __init__( self, name="TrigMuonEFCombiner" ):
- raise RuntimeError("TrigMuonEFCombinerConfig no longer supported - please switch to combiner mode of TrigMuSuperEF")
-
-
-
-class TrigMuonEFStandaloneTrackToolConfig (TrigMuonEFConf.TrigMuonEFStandaloneTrackTool):
- __slots__ = ()
-
- def __init__( self, name="TrigMuonEFStandaloneTrackTool", **kwargs ):
- super( TrigMuonEFStandaloneTrackToolConfig, self ).__init__( name, **kwargs )
-
- if MuonGeometryFlags.hasCSC(): self.CscClusterProvider = CfgGetter.getPublicTool("CscThresholdClusterBuilderTool")
-
- muonLayerHoughTool = CfgGetter.getPublicTool("MuonLayerHoughTool")
- muonLayerHoughTool.DoTruth=False
-
- self.SegmentsFinderTool = CfgGetter.getPublicToolClone( "TMEF_SegmentsFinderTool","MooSegmentFinder",
- HoughPatternFinder = muonLayerHoughTool,
- Csc2dSegmentMaker=("Csc2dSegmentMaker/Csc2dSegmentMaker" if MuonGeometryFlags.hasCSC() else ""),
- Csc4dSegmentMaker=("Csc4dSegmentMaker/Csc4dSegmentMaker" if MuonGeometryFlags.hasCSC() else ""))
-
- CfgGetter.getPublicTool("MuonHoughPatternFinderTool").RecordAll=False
- CfgGetter.getPublicTool("MooTrackFitter").SLFit=False
-
- self.MdtRawDataProvider = "TMEF_MdtRawDataProviderTool"
- self.CscRawDataProvider = "TMEF_CscRawDataProviderTool"
- self.RpcRawDataProvider = "TMEF_RpcRawDataProviderTool"
- self.TgcRawDataProvider = "TMEF_TgcRawDataProviderTool"
-
- #Need to run non-MT version of decoding tools in the trigger since the caching is not available in MT versions
- #Need different PRD container names to run offline and trigger in same jobs, but there are many tools that depend on these containers...
- #Since this is legacy code only used for validation comparisons against the Run 3 triggers, will do the not-particularly-nice solution of
- #creating containers with unique names only if we are running offline and trigger in the same jobs, and otherwise just use the default names.
- #This means that the trigger output when running the trigger as part of RAWtoESD is not 100% correct (the pattern finding uses the correct containers,
- #so it's a small effect overall anyway), but that's an use case not currently needed for trigger validation purposes
- from AthenaCommon.AppMgr import ToolSvc
- #MDT
- from MuonMDT_CnvTools.MuonMDT_CnvToolsConf import Muon__MdtRdoToPrepDataTool
- from MuonCSC_CnvTools.MuonCSC_CnvToolsConf import Muon__CscRdoToCscPrepDataTool
- from MuonTGC_CnvTools.MuonTGC_CnvToolsConf import Muon__TgcRdoToPrepDataTool
- from MuonRPC_CnvTools.MuonRPC_CnvToolsConf import Muon__RpcRdoToPrepDataTool
- from MuonCnvExample import MuonCalibConfig
-
- MdtRdoToMdtPrepDataTool = Muon__MdtRdoToPrepDataTool(name = "TrigEFMdtRdoToPrepDataTool", CalibrationTool=MuonCalibConfig.MdtCalibrationTool())
- CscRdoToCscPrepDataTool = Muon__CscRdoToCscPrepDataTool(name = "TrigEFCscRdoToPrepDataTool")
- TgcRdoToTgcPrepDataTool = Muon__TgcRdoToPrepDataTool(name = "TrigEFTgcRdoToPrepDataTool")
- RpcRdoToRpcPrepDataTool = Muon__RpcRdoToPrepDataTool(name = "TrigEFRpcRdoToPrepDataTool")
- if not rec.doRDOTrigger and rec.doESD:
- MdtRdoToMdtPrepDataTool.OutputCollection = "TrigMDT_DriftCircles"
- CscRdoToCscPrepDataTool.OutputCollection = "TrigCSC_Measurements"
- TgcRdoToTgcPrepDataTool.OutputCollection = "TrigTGC_Measurements"
- TgcRdoToTgcPrepDataTool.OutputCoinCollection = "TrigerT1CoinDataCollection"
- RpcRdoToRpcPrepDataTool.TriggerOutputCollection="TrigRPC_Measurements"
- #InputCollection is really the output RPC coin collection...
- RpcRdoToRpcPrepDataTool.InputCollection="TrigRPC_triggerHits"
- else:
- MdtRdoToMdtPrepDataTool.OutputCollection = "MDT_DriftCircles"
- CscRdoToCscPrepDataTool.OutputCollection = "CSC_Measurements"
- TgcRdoToTgcPrepDataTool.OutputCollection = "TGC_Measurements"
- TgcRdoToTgcPrepDataTool.OutputCoinCollection = "TrigT1CoinDataCollection"
- RpcRdoToRpcPrepDataTool.TriggerOutputCollection="RPC_Measurements"
- RpcRdoToRpcPrepDataTool.InputCollection="RPC_triggerHits"
-
- ToolSvc += MdtRdoToMdtPrepDataTool
- self.MdtPrepDataContainer = MdtRdoToMdtPrepDataTool.OutputCollection
- self.MdtPrepDataProvider=MdtRdoToMdtPrepDataTool
- #CSC
- ToolSvc += CscRdoToCscPrepDataTool
- self.CscPrepDataProvider=CscRdoToCscPrepDataTool
- #TGC
- ToolSvc += TgcRdoToTgcPrepDataTool
- self.TgcPrepDataProvider=TgcRdoToTgcPrepDataTool
- self.TgcPrepDataContainer=TgcRdoToTgcPrepDataTool.OutputCollection
- #RPC
- ToolSvc += RpcRdoToRpcPrepDataTool
- self.RpcPrepDataProvider=RpcRdoToRpcPrepDataTool
- self.RpcPrepDataContainer=RpcRdoToRpcPrepDataTool.TriggerOutputCollection
-
- self.DecodeMdtBS = DetFlags.readRDOBS.MDT_on()
- self.DecodeRpcBS = DetFlags.readRDOBS.RPC_on()
- self.DecodeTgcBS = DetFlags.readRDOBS.TGC_on()
- if MuonGeometryFlags.hasCSC(): self.DecodeCscBS = DetFlags.readRDOBS.CSC_on()
-
- # use seeded decoding
- if (TriggerFlags.MuonSlice.doEFRoIDrivenAccess()):
- self.useMdtSeededDecoding = True
- self.useRpcSeededDecoding = True
- self.useTgcSeededDecoding = True
- if MuonGeometryFlags.hasCSC(): self.useCscSeededDecoding = True
-
- # use ROB based seeded decoding instead of PRD based
- self.useTgcRobDecoding = False # neither available nor needed
- self.useCscRobDecoding = False # neither available nor needed
-
-
- self.useRpcData=muonRecFlags.doRPCs()
- self.useTgcData=muonRecFlags.doTGCs()
- self.useCscData=muonRecFlags.doCSCs()
- # to select barrel(useMdtData=2), endcap(useMdtData=3)
- if muonRecFlags.doMDTs():
- self.useMdtData=1
- else:
- self.useMdtData=0
-
-
- self.useTGCInPriorNextBC = False
-
- self.doTimeOutChecks = False
- self.doTimeOutGuard = False
- self.maxTgcHits = 0
- self.maxCscHits = 0
- self.maxRpcHits = 0
- self.maxMdtHits = 0
- self.doCache = True
- self.IgnoreMisalginedCSCs = False
-
- self.TrackBuilderTool = "TMEF_TrackBuilderTool"
- self.TrkSummaryTool = "TMEF_TrackSummaryTool"
- self.MuonCandidateTool = "TMEF_MuonCandidateTool"
-
- self.TrackToTrackParticleConvTool = "MuonParticleCreatorTool"
-
- import MuonCondAlg.MdtCondDbAlgConfig # noqa: F401 (MDT conditions, needed for the MuonStationIntersectSvc)
-
- #from MuonRecExample.MuonRecTools import MuonSTEP_Propagator
- #MuonSTEP_Propagator.OutputLevel=5
- #CfgGetter.getPublicTool("MuonStraightLinePropagator").OutputLevel=5
-
-class TrigMuonEFCombinerConfigTRTOnly ():
- __slots__ = ()
-
- def __init__( self, name="TrigMuonEFCombinerTRTOnly" ):
- raise RuntimeError("TrigMuonEFCombinerTRTOnly no longer supported - please switch to combiner mode of TrigMuSuperEF")
-
-
-class TrigMuonEFCaloIsolationConfig (TrigMuonEFConf.TrigMuonEFCaloIsolation):
- __slots__ = ()
-
- def __init__( self, name="TrigMuonEFCaloIsolationConfig" ):
- super( TrigMuonEFCaloIsolationConfig, self ).__init__( name )
-
- self.RequireCombinedMuon = True
- self.applyPileupCorrection = False
-
- CaloTopoIsolationTool = PublicToolFactory(xAOD__CaloIsolationTool,name = "CaloTopoClusterIsolationTool",
- doEnergyDensityCorrection = self.applyPileupCorrection,
- saveOnlyRequestedCorrections = True,
- IsoLeakCorrectionTool = IsoCorrectionTool,
- ClustersInConeTool = CaloClustersInConeTool,
- CaloFillRectangularClusterTool = TrigCaloFillRectangularCluster,
- UseEMScale = True)
-
- self.CaloTopoClusterIsolationTool = CaloTopoIsolationTool()
-
- # histograms
- self.HistoPathBase = ""
- validation_caloiso = TrigMuonEFMonitoring.TrigMuonEFCaloIsolationValidationMonitoring()
- #online_caloiso = TrigMuonEFMonitoring.TrigMuonEFCaloIsolationOnlineMonitoring()
- #monitoring_caloiso = TrigMuonEFMonitoring.TrigMuonEFCaloIsolationMonitoring()
-
- self.AthenaMonTools = [validation_caloiso]
+from AthenaCommon.SystemOfUnits import mm
def TMEF_TrackIsolationTool(name='TMEF_isolationTool',**kwargs):
kwargs.setdefault('deltaZCut', 2.0*mm)
@@ -666,212 +13,10 @@ def TMEF_TrackIsolationTool(name='TMEF_isolationTool',**kwargs):
# Get the track selection tool
from InDetTrackSelectionTool.InDetTrackSelectionToolConf import InDet__InDetTrackSelectionTool
trkseltool = InDet__InDetTrackSelectionTool()
- if 'LooseTSel' in name:
- trkseltool.CutLevel='Loose'
- elif 'TightTSel' in name:
- trkseltool.CutLevel='TightPrimary'
- log.debug('TMEF_TrackIsolationTool added trackselection tool:\n%s', trkseltool)
kwargs.setdefault('TrackSelectionTool',trkseltool)
return TrigMuonEFConf.TrigMuonEFTrackIsolationTool(name, **kwargs)
-class TrigMuonEFTrackIsolationConfig (TrigMuonEFConf.TrigMuonEFTrackIsolation):
- __slots__ = ()
-
- def __init__( self, name="TrigMuonEFTrackIsolationConfig" ):
- super( TrigMuonEFTrackIsolationConfig, self ).__init__( name )
-
- # configure the isolation tool
- TMEF_IsolationTool = TMEF_TrackIsolationTool('TMEF_IsolationTool',useVarIso=False)
-
- # Isolation tool
- self.IsolationTool = TMEF_IsolationTool
-
- # ID tracks
- self.IdTrackParticles = "InDetTrigTrackingxAODCnv_Muon_IDTrig"
-
- # Only run algo on combined muons
- self.requireCombinedMuon = True
-
- # Use offline isolation variables
- self.useVarIso = False
-
- # histograms
- self.histoPathBase = ""
- validation_trkiso = TrigMuonEFMonitoring.TrigMuonEFTrackIsolationValidationMonitoring()
- online_trkiso = TrigMuonEFMonitoring.TrigMuonEFTrackIsolationOnlineMonitoring()
-
- self.AthenaMonTools = [ validation_trkiso, online_trkiso ]
-
-
-class TrigMuonEFMSTrackIsolationConfig (TrigMuonEFConf.TrigMuonEFTrackIsolation):
- __slots__ = ()
-
- def __init__( self, name="TrigMuonEFMSTrackIsolationConfig" ):
- super( TrigMuonEFMSTrackIsolationConfig, self ).__init__( name )
-
- # configure the isolation tool
- TMEF_IsolationTool = TMEF_TrackIsolationTool('TMEF_IsolationTool',useVarIso=False)
-
- # Isolation tool
- self.IsolationTool = TMEF_IsolationTool
-
- # ID tracks
- self.IdTrackParticles = "InDetTrigTrackingxAODCnv_Muon_IDTrig"
-
- # Only run algo on combined muons
- self.requireCombinedMuon = False
-
- # Use offline isolation variables
- self.useVarIso = False
-
- # histograms
- self.histoPathBase = ""
- validation_trkiso = TrigMuonEFMonitoring.TrigMuonEFTrackIsolationValidationMonitoring()
- online_trkiso = TrigMuonEFMonitoring.TrigMuonEFTrackIsolationOnlineMonitoring()
-
- self.AthenaMonTools = [ validation_trkiso, online_trkiso ]
-
-
-class TrigMuonEFTrackIsolationVarConfig (TrigMuonEFConf.TrigMuonEFTrackIsolation):
- __slots__ = ()
-
- def __init__( self, name="TrigMuonEFTrackIsolationVarConfig" ):
- super( TrigMuonEFTrackIsolationVarConfig, self ).__init__( name )
-
- # configure the isolation tool
- trkseltoolname = 'TMEF_VarIsolationTool'
- if 'LooseTSel' in name:
- trkseltoolname = trkseltoolname + 'LooseTSel'
- elif 'TightTSel' in name:
- trkseltoolname = trkseltoolname + 'TightTSel'
-
- TMEF_VarIsolationTool = TMEF_TrackIsolationTool(trkseltoolname,useVarIso=True)
-
- # Isolation tool
- self.IsolationTool = TMEF_VarIsolationTool
-
-
- # ID tracks
- self.IdTrackParticles = "InDetTrigTrackingxAODCnv_Muon_IDTrig"
-
- # Only run algo on combined muons
- self.requireCombinedMuon = True
-
- # Use offline isolation variables
- self.useVarIso = True
-
- # histograms
- self.histoPathBase = ""
- validation_trkiso = TrigMuonEFMonitoring.TrigMuonEFTrackIsolationValidationMonitoring()
- online_trkiso = TrigMuonEFMonitoring.TrigMuonEFTrackIsolationOnlineMonitoring()
-
- # timing
- self.doMyTiming = True
- timetool = TrigTimeHistToolConfig("Time")
- timetool.NumberOfHistBins=100
- timetool.TimerHistLimits=[0,1000]
-
- self.AthenaMonTools = [ validation_trkiso, online_trkiso, timetool ]
-
-
-def InDetTrkRoiMaker_Muon(name="InDetTrkRoiMaker_Muon",**kwargs):
- kwargs.setdefault("FullScanMode", "HybridScan")
- kwargs.setdefault("SeedsIDalgo", "FTF")
- kwargs.setdefault("SeedsEtaMax", 2.5)
- kwargs.setdefault("SeedsPtMin", 2.0) # GeV
- kwargs.setdefault("FullEtaRange", 3.0) # MS goes up to 2.7
- kwargs.setdefault("AthenaMonTools", [ TrigMuonEFMonitoring.InDetTrkRoiMakerMonitoring("Monitoring"),
- TrigMuonEFMonitoring.InDetTrkRoiMakerValidationMonitoring("MonitoringVal"),
- TrigTimeHistToolConfig("Time")] )
-
- return CfgMgr.InDetTrkRoiMaker(name,**kwargs)
-
-
-class TrigMuonEFRoiAggregatorConfig (TrigMuonEFConf.TrigMuonEFRoiAggregator):
- __slots__ = ()
-
- def __init__( self, name="TrigMuonEFRoiAggregator", **kwargs):
- super( TrigMuonEFRoiAggregatorConfig, self ).__init__( name )
-
- kwargs.setdefault("CopyTracks", False)
- self.CopyTracks = True
-
-
-class TrigMuonEFFSRoiMakerConfig(TrigMuonEFConf.TrigMuonEFFSRoiMaker):
- __slots__ = ()
-
- def __init__( self, name="TrigMuonEFFSRoiMaker", **kwargs):
- super( TrigMuonEFFSRoiMakerConfig, self ).__init__( name )
-
- self.MuonPtCut = 0.0
- self.OutputContName = "MuonEFInfo"
- self.CreateFSRoI = False
-
- montool = TrigMuonEFMonitoring.TrigMuonEFFSRoiMakerMonitoring()
-
- self.AthenaMonTools = [ montool ]
-
-class TrigMuonEFFSRoiMakerCaloTagConfig(TrigMuonEFConf.TrigMuonEFFSRoiMaker):
- __slots__ = ()
-
- def __init__( self, name="TrigMuonEFFSRoiMakerCaloTag", **kwargs):
- super( TrigMuonEFFSRoiMakerCaloTagConfig, self ).__init__( name )
-
- self.MuonPtCut = 0.0
- self.OutputContName = "MuonEFInfo"
- self.InvertRoI = True
- self.UseFSRoI = False
-
- kwargs.setdefault("RoISizeEta", 3.0)
- kwargs.setdefault("RoISizePhi", 1.5)
- kwargs.setdefault("RoILabel", "forID")
-
- self.RoISizeEta = kwargs["RoISizeEta"]
- self.RoISizePhi = kwargs["RoISizePhi"]
-
- self.RoILabel = kwargs["RoILabel"]
-
- montool = TrigMuonEFMonitoring.TrigMuonEFFSRoiMakerMonitoring()
-
- self.AthenaMonTools = [ montool ]
-
-class TrigMuonEFFSRoiMakerUnseededConfig(TrigMuonEFConf.TrigMuonEFFSRoiMaker):
- __slots__ = ()
-
- def __init__( self, name="TrigMuonEFFSRoiMakerUnseeded", **kwargs):
- super( TrigMuonEFFSRoiMakerUnseededConfig, self ).__init__( name )
-
- self.MuonPtCut = 0.0
- self.OutputContName = "MuonEFInfo"
- self.CreateCrackRoI = True
-
- kwargs.setdefault("RoISizeEta", 0.1)
- kwargs.setdefault("RoISizePhi", 3.14159)
- kwargs.setdefault("RoILabel", "forID")
-
- self.RoISizeEta = kwargs["RoISizeEta"]
- self.RoISizePhi = kwargs["RoISizePhi"]
- self.RoILabel = kwargs["RoILabel"]
-
- montool = TrigMuonEFMonitoring.TrigMuonEFFSRoiMakerMonitoring()
-
- self.AthenaMonTools = [ montool ]
-
-# Python config class for the TrigMuonEDIDTrackRoiMaker c++ algorithm
-class TrigMuonEFIDTrackRoiMakerConfig(TrigMuonEFConf.TrigMuonEFIDTrackRoiMaker):
- __slots__ = ()
-
- def __init__( self, name="TrigMuonEFIDTrackRoiMaker", **kwargs):
- super( TrigMuonEFIDTrackRoiMakerConfig, self ).__init__( name )
-
- # use 12mm z-width for all chains
- self.Z0Width = 12.0*mm
-
- montool = TrigMuonEFMonitoring.TrigMuonEFIDTrackRoiMakerMonitoring()
-
- self.AthenaMonTools = [ montool ]
-
class TrigMuonEFTrackIsolationMTConfig (TrigMuonEFConf.TrigMuonEFTrackIsolationAlgMT):
__slots__ = ()
diff --git a/Trigger/TrigAlgorithms/TrigMuonEF/python/TrigMuonEFConfigDb.py b/Trigger/TrigAlgorithms/TrigMuonEF/python/TrigMuonEFConfigDb.py
deleted file mode 100644
index af5ddc0daedbd7fc8e2bdf5258b6c94dcf832f37..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuonEF/python/TrigMuonEFConfigDb.py
+++ /dev/null
@@ -1,69 +0,0 @@
-# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
-
-from AthenaCommon.CfgGetter import addAlgorithm,addTool
-from AtlasGeoModel.MuonGMJobProperties import MuonGeometryFlags
-
-addTool("TrigMuonEF.TrigMuonEFConfig.TrigMuonEFStandaloneTrackToolConfig", "TrigMuonEFStandaloneTrackTool")
-
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_CaloEnergyMeas", "TMEF_CaloEnergyMeas")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_CaloEnergyTool", "TMEF_CaloEnergyTool")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_CaloTrackStateOnSurface", "TMEF_CaloTrackStateOnSurface")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_MaterialEffectsUpdator", "TMEF_MaterialEffectsUpdator")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_Navigator", "TMEF_Navigator")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_Propagator", "TMEF_Propagator")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_Extrapolator", "TMEF_Extrapolator")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_TrackSummaryTool", "TMEF_TrackSummaryTool")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_CombinedMuonTag", "TMEF_CombinedMuonTag")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_MatchQuality", "TMEF_MatchQuality")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_MaterialAllocator", "TMEF_MaterialAllocator")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_iPatFitter", "TMEF_iPatFitter")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_iPatSLFitter", "TMEF_iPatSLFitter")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_TrackCleaner", "TMEF_TrackCleaner")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_CombinedMuonTrackBuilder", "TMEF_CombinedMuonTrackBuilder")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_MuonTrackQuery", "TMEF_MuonTrackQuery")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_MatchMaker", "TMEF_MatchMaker")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_TrackBuilderTool", "TMEF_TrackBuilderTool")
-
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_TrackSummaryToolNoHole", "TMEF_TrackSummaryToolNoHole")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_TrkToTrackParticleConvTool", "TMEF_TrkToTrackParticleConvTool")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_MuonCombinedTool", "TMEF_MuonCombinedTool")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_MuidMuonRecovery","TMEF_MuidMuonRecovery")
-addTool("TrigMuonEF.TrigMuonEFConfig.MuonHolesOnTrack","MuonHolesOnTrack")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_CombMuonMEOTPParam","TMEF_CombMuonMEOTPParam")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_MuonCombinedPropagator","TMEF_MuonCombinedPropagator")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_OutwardsMuonTrackCleaner","TMEF_OutwardsMuonTrackCleaner")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_MuonCombinedTrackFitter","TMEF_MuonCombinedTrackFitter")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_OutwardsCombinedMuonTrackBuilder","TMEF_OutwardsCombinedMuonTrackBuilder")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_MuonCombinedFitTagTool","TMEF_MuonCombinedFitTagTool")
-addTool("TrigMuonEF.TrigMuonEFConfig.TrigMuonAmbiProcessor","TrigMuonAmbiProcessor")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_MuonCreatorTool","TMEF_MuonCreatorTool")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_MuonCandidateTool","TMEF_MuonCandidateTool")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_TrkMaterialProviderTool", "TMEF_TrkMaterialProviderTool")
-
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_MuonCandidateTrackBuilderTool", "TMEF_MuonCandidateTrackBuilderTool")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_MuonInsideOutRecoTool", "TMEF_MuonInsideOutRecoTool")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_MuonPRDSelectionTool", "TMEF_MuonPRDSelectionTool")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_MuonLayerSegmentFinderTool", "TMEF_MuonLayerSegmentFinderTool", Csc2DSegmentMaker=("Csc2dSegmentMaker/Csc2dSegmentMaker" if MuonGeometryFlags.hasCSC() else ""), Csc4DSegmentMaker=("Csc4dSegmentMaker/Csc4dSegmentMaker" if MuonGeometryFlags.hasCSC() else ""))
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_MuonClusterSegmentFinderTool", "TMEF_MuonClusterSegmentFinderTool")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_MuonClusterSegmentFinder", "TMEF_MuonClusterSegmentFinder")
-
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_MuonStauRecoTool", "TMEF_MuonStauRecoTool")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_MuonStauInsideOutRecoTool", "TMEF_MuonStauInsideOutRecoTool")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_MuonStauCandidateTrackBuilderTool", "TMEF_MuonStauCandidateTrackBuilderTool")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_CombinedStauTrackBuilder", "TMEF_CombinedStauTrackBuilder")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_MuonStauSegmentRegionRecoveryTool", "TMEF_MuonStauSegmentRegionRecoveryTool")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_CombinedStauTrackBuilderFit", "TMEF_CombinedStauTrackBuilderFit")
-
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_MdtRawDataProviderTool", "TMEF_MdtRawDataProviderTool")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_CscRawDataProviderTool", "TMEF_CscRawDataProviderTool")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_RpcRawDataProviderTool", "TMEF_RpcRawDataProviderTool")
-addTool("TrigMuonEF.TrigMuonEFConfig.TMEF_TgcRawDataProviderTool", "TMEF_TgcRawDataProviderTool")
-
-addAlgorithm("TrigMuonEF.TrigMuonEFConfig.TrigMuonEFTrackIsolationConfig", "TrigMuonEFTrackIsolation")
-
-addAlgorithm("TrigMuonEF.TrigMuonEFConfig.TrigMuonEFFSRoiMakerConfig","TrigMuonEFFSRoiMaker")
-
-addAlgorithm("TrigMuonEF.TrigMuonEFConfig.TrigMuonEFIDTrackRoiMaker","TrigMuonEFIDTrackRoiMaker")
-
-addAlgorithm("TrigMuonEF.TrigMuonEFConfig.InDetTrkRoiMaker_Muon", "InDetTrkRoiMaker_Muon")
-
diff --git a/Trigger/TrigAlgorithms/TrigMuonEF/python/TrigMuonEFMonitoring.py b/Trigger/TrigAlgorithms/TrigMuonEF/python/TrigMuonEFMonitoring.py
deleted file mode 100644
index ac152e99475d26c37808c96e91f5c7d84802a593..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuonEF/python/TrigMuonEFMonitoring.py
+++ /dev/null
@@ -1,326 +0,0 @@
-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-
-import math
-
-from TrigMonitorBase.TrigGenericMonitoringToolConfig import defineHistogram, TrigGenericMonitoringToolConfig
-
-
-
-
-class TrigMuonEFTrackIsolationOnlineMonitoring(TrigGenericMonitoringToolConfig):
- def __init__ (self, name="TrigMuonEFTrackIsolationOnlineMonitoring"):
- super(TrigMuonEFTrackIsolationOnlineMonitoring, self).__init__(name)
- self.defineTarget("Online")
- self.Histograms += [ defineHistogram('trks_trkptiso_cone2', type='TH1F', title="Track Isolation cone 0.2; MuonEF CB Trk Isolation cone 0.2 [GeV] (ID)",
- xbins=35, xmin=-10, xmax=25) ]
- self.Histograms += [ defineHistogram('trks_trkptiso_cone3', type='TH1F', title="Track Isolation cone 0.3; MuonEF CB Trk Isolation cone 0.3 [GeV] (ID)",
- xbins=35, xmin=-10, xmax=25) ]
- self.Histograms += [ defineHistogram('trks_trkdz', type='TH1F', title="dz to trks; dz to trks",
- xbins=200, xmin=-10, xmax=10.0) ]
- self.Histograms += [ defineHistogram('trks_trkdr', type='TH1F', title="dr to trks; dr to trks",
- xbins=60, xmin=0.0, xmax=3.0) ]
-
-class TrigMuonEFTrackIsolationValidationMonitoring(TrigGenericMonitoringToolConfig):
- def __init__ (self, name="TrigMuonEFTrackIsolationValidationMonitoring"):
- super(TrigMuonEFTrackIsolationValidationMonitoring, self).__init__(name)
- self.defineTarget("Validation")
-
- self.Histograms += [ defineHistogram('trks_trkptiso_cone2', type='TH1F', title="Track Isolation cone 0.2; MuonEF CB Trk Isolation cone 0.2 [GeV] (ID)",
- xbins=35, xmin=-10, xmax=25) ]
- self.Histograms += [ defineHistogram('trks_trkptiso_cone3', type='TH1F', title="Track Isolation cone 0.3; MuonEF CB Trk Isolation cone 0.3 [GeV] (ID)",
- xbins=35, xmin=-10, xmax=25) ]
- self.Histograms += [ defineHistogram('trks_trkdz', type='TH1F', title="dz to trks; dz to trks",
- xbins=200, xmin=-10, xmax=10.0) ]
- self.Histograms += [ defineHistogram('trks_trkdr', type='TH1F', title="dr to trks; dr to trks",
- xbins=60, xmin=0.0, xmax=3.0) ]
-
- self.Histograms += [ defineHistogram('n_trks', type='TH1F', title="N_tracks passed to algorithm",
- xbins=11, xmin=-0.5, xmax=10.5) ]
-
- self.Histograms += [ defineHistogram('muon_selfpt', type='TH1F', title="Muon ID Track pT (ID Tracks)",
- xbins=100, xmin=0, xmax=100) ]
-
- self.Histograms += [ defineHistogram('muon_removedpt', type='TH1F', title="Muon Removed pT (ID Tracks)",
- xbins=100, xmin=0, xmax=100) ]
- self.Histograms += [ defineHistogram('muon_combinedpt', type='TH1F', title="Muon Combined pT (ID Tracks)",
- xbins=100, xmin=0, xmax=100) ]
-
-
-
-
-class TrigMuonEFCaloIsolationValidationMonitoring(TrigGenericMonitoringToolConfig):
- def __init__ (self, name="TrigMuonEFCaloIsolationValidationMonitoring"):
- super(TrigMuonEFCaloIsolationValidationMonitoring, self).__init__(name)
- self.defineTarget("Validation")
- self.Histograms += [ defineHistogram('EF_etiso_cone2', type='TH1F', title="Calo Isolation cone 0.2; MuonEF Calo Isolation cone 0.2 [GeV]",
- xbins=40, xmin=-10, xmax=30) ]
- self.Histograms += [ defineHistogram('EF_etiso_cone3', type='TH1F', title="Calo Isolation cone 0.3; MuonEF Calo Isolation cone 0.3 [GeV]",
- xbins=40, xmin=-10, xmax=30) ]
- self.Histograms += [ defineHistogram('EF_etiso_cone4', type='TH1F', title="Calo Isolation cone 0.4; MuonEF Calo Isolation cone 0.4 [GeV]",
- xbins=40, xmin=-10, xmax=30) ]
-
-
-class TrigMuonEFStandaloneToolMonitoring(TrigGenericMonitoringToolConfig):
- def __init__ (self, name="TrigMuonEFStandaloneToolMonitoring"):
- super(TrigMuonEFStandaloneToolMonitoring, self).__init__(name)
- self.defineTarget( ["Online", "Validation"] )
-
- # segment finding
- self.Histograms += [ defineHistogram('EF_segs_nsegs', type='TH1F', title="Number of segments (TMEF seg); Muon EF SF segments",
- xbins=100, xmin=0, xmax=100)]
- self.Histograms += [ defineHistogram('EF_segs_phi', type='TH1F', title="EF Segment Phi (TMEF seg); Muon EF SF Phi",
- xbins=100, xmin=-5, xmax=5)]
- self.Histograms += [ defineHistogram('EF_segs_eta', type='TH1F', title="EF Segment Eta (TMEF seg); Muon EF SF Eta",
- xbins=100, xmin=-5, xmax=5)]
- self.Histograms += [ defineHistogram('EF_segs_eta, EF_segs_phi', type='TH2F', title="EF Segment Eta vs Phi (TMEF seg); Muon EF SF Eta ; Muon EF SF Phi",
- xbins=60, xmin=-3., xmax=3., ybins=48, ymin=-3.142, ymax=3.142) ]
-
- # TMEF MS track
- self.Histograms += [ defineHistogram('EF_mstrks_n', type='TH1F', title="Number of tracks (TMEF MS track); Muon EF TB Number of Tracks",
- xbins=50, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_mstrks_pt', type='TH1F', title="pt (TMEF MS track); Muon EF TB Track pt [GeV]",
- xbins=100, xmin=0, xmax=200) ]
- self.Histograms += [ defineHistogram('EF_mstrks_phi', type='TH1F', title="phi (TMEF MS track); Muon EF TB Track Phi",
- xbins=100, xmin=-5, xmax=5) ]
- self.Histograms += [ defineHistogram('EF_mstrks_eta', type='TH1F', title="eta (TMEF MS track); Muon EF TB Track Eta",
- xbins=100, xmin=-5.5, xmax=5.5) ]
- self.Histograms += [ defineHistogram('EF_mstrks_eta, EF_mstrks_phi', type='TH2F', title="EF_mstrks_eta_vs_EF_mstrks_phi (TMEF MS track); Muon EF TB Eta-Phi",
- xbins=60, xmin=-3, xmax=3, ybins=48, ymin=-3.142, ymax=3.142) ]
-
-
- # TMEF SA track
- self.Histograms += [ defineHistogram('EF_satrks_n', type='TH1F', title="Number of tracks (TMEF SA track); Muon EF SA Number of Tracks",
- xbins=50, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_satrks_pt', type='TH1F', title="pt (TMEF SA track); Muon EF SA Track pt [GeV]",
- xbins=100, xmin=0, xmax=200) ]
- self.Histograms += [ defineHistogram('EF_satrks_phi', type='TH1F', title="phi (TMEF SA track); Muon EF SA Track Phi",
- xbins=100, xmin=-5, xmax=5) ]
- self.Histograms += [ defineHistogram('EF_satrks_eta', type='TH1F', title="eta (TMEF SA track); Muon EF SA Track Eta",
- xbins=100, xmin=-5.5, xmax=5.5) ]
-
-class TrigMuonEFStandaloneToolValidationMonitoring(TrigGenericMonitoringToolConfig):
- def __init__ (self, name="TrigMuonEFStandaloneToolValidationMonitoring"):
- super(TrigMuonEFStandaloneToolValidationMonitoring, self).__init__(name)
- self.defineTarget( ["Validation"] )
-
- # segment finding
- self.Histograms += [ defineHistogram('l2_cosmic_phi', type='TH1F', title="L2 CosmicMuon phi (TMEF seg); Muon EF SF Phi",
- xbins=100, xmin=-5, xmax=5) ]
- self.Histograms += [ defineHistogram('l2_cosmic_eta', type='TH1F', title="L2 CosmicMuon eta (TMEF seg); Muon EF SF Eta",
- xbins=100, xmin=-5, xmax=5)]
- self.Histograms += [ defineHistogram('ef_phi, l2_cosmic_phi', type='TH2F', title="EF phi L2 vs EF (TMEF seg); Muon EF SF Phi",
- xbins=48, xmin=-3.142, xmax=3.142, ybins=48, ymin=-3.142, ymax=3.142) ]
- self.Histograms += [ defineHistogram('ef_eta, l2_cosmic_eta', type='TH2F', title="EF eta L2 vs EF (TMEF seg); Muon EF SF Eta",
- xbins=60, xmin=-3, xmax=3, ybins=60, ymin=-3, ymax=3.) ]
-
- self.Histograms += [ defineHistogram('EF_segs_wasCached', type='TH1F',
- title="Did segments come from cache?;0=no 1=yes",
- xbins=2, xmin=-0.5, xmax=1.5) ]
- self.Histograms += [ defineHistogram('EF_segs_nsegcomb', type='TH1F', title="Number of segment combinations (TMEF seg); Muon EF SF segments",
- xbins=50, xmin=0, xmax=50)]
- self.Histograms += [ defineHistogram('EF_segs_nstations', type='TH1F', title="Number of stations (TMEF seg); Muon EF SF segments",
- xbins=10, xmin=0, xmax=10)]
- self.Histograms += [ defineHistogram('EF_segs_chi2pndof', type='TH1F', title="EF Segment Chi2 / ndof (TMEF seg); Muon EF SF Chi2 / ndof",
- xbins=100, xmin=0.0, xmax=20.0) ]
- self.Histograms += [ defineHistogram('EF_segs_nMdt', type='TH1F', title="Number mdt hits per segment (TMEF seg); Muon EF SF Mdt Hits ",
- xbins=50, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_segs_nCsc', type='TH1F', title="Number csc hits per segment (TMEF seg); Muon EF SF Csc hits",
- xbins=50, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_segs_nRpc', type='TH1F', title="Number rpc hits per segment (TMEF seg); Muon EF SF Rpc hits",
- xbins=50, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_segs_nTgc', type='TH1F', title="Number tgc hits per segment (TMEF seg); Muon EF SF Tgc hits",
- xbins=50, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_segs_mdt_radius', type='TH1F', title="Mdt tube radius (TMEF seg); Muon EF SF Drift radius [mm] of Mdt hits",
- xbins=50, xmin=-50, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_segs_mdt_tdc', type='TH1F', title="Mdt tube tdc (TMEF seg); Muon EF SF TDC counts of Mdt hits",
- xbins=100, xmin=0, xmax=2000) ]
- self.Histograms += [ defineHistogram('EF_segs_mdt_adc', type='TH1F', title="Mdt tube adc (TMEF seg); Muon EF SF ADC counts of Mdt hits",
- xbins=100, xmin=0, xmax=2000) ]
- self.Histograms += [ defineHistogram('EF_segs_mdt_z', type='TH1F', title="Mdt tube z (TMEF seg); Muon EF SF Tube z [mm]",
- xbins=100, xmin=-25000, xmax=25000) ]
-
- # TMEF MS track
- self.Histograms += [ defineHistogram('EF_mstrks_wasCached', type='TH1F',
- title="Did MS tracks come from cache?;0=no 1=yes",
- xbins=2, xmin=-0.5, xmax=1.5) ]
- self.Histograms += [ defineHistogram('EF_mstrks_chi2', type='TH1F', title="chi2 (TMEF MS track); Muon EF TB Track chi2",
- xbins=100, xmin=0, xmax=30) ]
- self.Histograms += [ defineHistogram('EF_mstrks_d0', type='TH1F', title="d0 (TMEF MS track); Muon EF TB Track d0",
- xbins=100, xmin=-0.01, xmax=0.01) ]
- self.Histograms += [ defineHistogram('EF_mstrks_z0', type='TH1F', title="z0 (TMEF MS track); Muon EF TB Track z0 [mm]",
- xbins=100, xmin=-50, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_mstrks_nMdt', type='TH1F', title="Number of Mdt (TMEF MS track); Muon EF TB Mdt hits",
- xbins=50, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_mstrks_nRpcEta', type='TH1F', title="Number of Rpc eta (TMEF MS track); Muon EF TB Rpc Eta hits",
- xbins=50, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_mstrks_nRpcPhi', type='TH1F', title="Number of Rpc phi (TMEF MS track); Muon EF TB Rpc Phi hits",
- xbins=50, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_mstrks_nTgcEta', type='TH1F', title="Number of Tgc eta (TMEF MS track); Muon EF TB Tgc Eta hits",
- xbins=50, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_mstrks_nTgcPhi', type='TH1F', title="Number of Tgc phi (TMEF MS track); Muon EF TB Tgc Phi hits",
- xbins=50, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_mstrks_nCscEta', type='TH1F', title="Number of Csc eta (TMEF MS track); Muon EF TB Csc Eta hits",
- xbins=50, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_mstrks_nCscPhi', type='TH1F', title="Number of Csc phi (TMEF MS track); Muon EF TB Csc Phi hits",
- xbins=50, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_mstrks_nHit', type='TH1F', title="Number of Hit on track (TMEF MS track); Muon EF TB Total hits",
- xbins=50, xmin=0, xmax=100) ]
-
-
- # TMEF SA track
- self.Histograms += [ defineHistogram('EF_satrks_wasCached', type='TH1F',
- title="Did SA tracks come from cache?;0=no 1=yes",
- xbins=2, xmin=-0.5, xmax=1.5) ]
- self.Histograms += [ defineHistogram('EF_satrks_chi2', type='TH1F', title="chi2 (TMEF SA track); Muon EF SA Track chi2",
- xbins=100, xmin=0, xmax=30) ]
- self.Histograms += [ defineHistogram('EF_satrks_d0', type='TH1F', title="d0 (TMEF SA track); Muon EF SA Track d0",
- xbins=100, xmin=-1000, xmax=1000) ]
- self.Histograms += [ defineHistogram('EF_satrks_z0', type='TH1F', title="z0 (TMEF SA track); Muon EF SA Track z0 [mm]",
- xbins=100, xmin=-1000, xmax=1000) ]
- self.Histograms += [ defineHistogram('EF_satrks_nMdt', type='TH1F', title="Number of Mdt (TMEF SA track); Muon EF SA Mdt hits",
- xbins=50, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_satrks_nRpcEta', type='TH1F', title="Number of Rpc eta (TMEF SA track); Muon EF SA Rpc Eta hits",
- xbins=50, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_satrks_nRpcPhi', type='TH1F', title="Number of Rpc phi (TMEF SA track); Muon EF SA Rpc Phi hits",
- xbins=50, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_satrks_nTgcEta', type='TH1F', title="Number of Tgc eta (TMEF SA track); Muon EF SA Tgc Eta hits",
- xbins=50, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_satrks_nTgcPhi', type='TH1F', title="Number of Tgc phi (TMEF SA track); Muon EF SA Tgc Phi hits",
- xbins=50, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_satrks_nCscEta', type='TH1F', title="Number of Csc eta (TMEF SA track); Muon EF SA Csc Eta hits",
- xbins=50, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_satrks_nCscPhi', type='TH1F', title="Number of Csc phi (TMEF SA track); Muon EF SA Csc Phi hits",
- xbins=50, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_satrks_nHit', type='TH1F', title="Number of Hit on track (TMEF SA track); Muon EF SA Total hits",
- xbins=50, xmin=0, xmax=100) ]
-
-
-class TrigMuonEFCombinerToolMonitoring(TrigGenericMonitoringToolConfig):
- def __init__ (self, name="TrigMuonEFCombinerToolMonitoring"):
- super(TrigMuonEFCombinerToolMonitoring, self).__init__(name)
- self.defineTarget( ["Online", "Validation"] )
-
- # TMEF combined track
- self.Histograms += [ defineHistogram('EF_cbtrks_n', type='TH1F', title="Number of tracks (TMEF CB track); MuonEF CB Number of Tracks",
- xbins=50, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_cbtrks_pt', type='TH1F', title="pt (TMEF CB track); MuonEF CB Track pt [GeV]",
- xbins=100, xmin=0, xmax=200) ]
- self.Histograms += [ defineHistogram('EF_cbtrks_phi', type='TH1F', title="phi (TMEF CB track); MuonEF CB Track Phi",
- xbins=100, xmin=-5, xmax=5) ]
- self.Histograms += [ defineHistogram('EF_cbtrks_eta', type='TH1F', title="eta (TMEF CB track); MuonEF CB Track Eta",
- xbins=100, xmin=-5.5, xmax=5.5) ]
-
-
-class TrigMuonEFCombinerToolValidationMonitoring(TrigGenericMonitoringToolConfig):
- def __init__ (self, name="TrigMuonEFCombinerToolValidationMonitoring"):
- super(TrigMuonEFCombinerToolValidationMonitoring, self).__init__(name)
- self.defineTarget( ["Validation"] )
-
- # TMEF combined track
- self.Histograms += [ defineHistogram('EF_cbtrks_chi2', type='TH1F', title="chi2 (TMEF CB track); MuonEF CB Track chi2",
- xbins=100, xmin=0, xmax=30) ]
- self.Histograms += [ defineHistogram('EF_cbtrks_match_chi2', type='TH1F', title="chi2 (TMEF CB track); MuonEF CB Track matching chi2",
- xbins=100, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_cbtrks_nMdt', type='TH1F', title="Number of Mdt (TMEF CB track); MuonEF CB Mdt hits",
- xbins=50, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_cbtrks_nRpcEta', type='TH1F', title="Number of Rpc eta (TMEF CB track); MuonEF CB Rpc Eta hits",
- xbins=50, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_cbtrks_nRpcPhi', type='TH1F', title="Number of Rpc phi (TMEF CB track); MuonEF CB Rpc Phi hits",
- xbins=50, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_cbtrks_nTgcEta', type='TH1F', title="Number of Tgc eta (TMEF CB track); MuonEF CB Tgc Eta hits",
- xbins=50, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_cbtrks_nTgcPhi', type='TH1F', title="Number of Tgc phi (TMEF CB track); MuonEF CB Tgc Phi hits",
- xbins=50, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_cbtrks_nCscEta', type='TH1F', title="Number of Csc eta (TMEF CB track); MuonEF CB Csc Eta hits",
- xbins=50, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_cbtrks_nCscPhi', type='TH1F', title="Number of Csc phi (TMEF CB track); MuonEF CB Csc Phi hits",
- xbins=50, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_cbtrks_nHit', type='TH1F', title="Number of Hit on track (TMEF CB track); MuonEF CB Total hits",
- xbins=150, xmin=0, xmax=150) ]
- self.Histograms += [ defineHistogram('EF_cbtrks_nIdPixelHit', type='TH1F', title="Number of IdPixelHit on track (TMEF CB track); MuonEF CB Pixel hits",
- xbins=10, xmin=0, xmax=10) ]
- self.Histograms += [ defineHistogram('EF_cbtrks_nIdSctHit', type='TH1F', title="Number of IdSctHit on track (TMEF CB track); MuonEF CB Sct hits",
- xbins=20, xmin=0, xmax=20) ]
- self.Histograms += [ defineHistogram('EF_cbtrks_nIdTrtHit', type='TH1F', title="Number of IdTrtHit on track (TMEF CB track); MuonEF CB Trt hits",
- xbins=50, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_cbtrks_d0', type='TH1F', title="d0 (TMEF CB track); MuonEF CB Track d0",
- xbins=100, xmin=-10, xmax=10) ]
- self.Histograms += [ defineHistogram('EF_cbtrks_z0', type='TH1F', title="z0 (TMEF CB track); MuonEF CB Track z0 [mm]",
- xbins=100, xmin=-250, xmax=250) ]
-
-
-
-class InDetTrkRoiMakerMonitoring(TrigGenericMonitoringToolConfig):
- def __init__ (self, name="InDetTrkRoiMakerMonitoring",**kwargs):
- super(InDetTrkRoiMakerMonitoring, self).__init__(name,**kwargs)
- self.defineTarget( ["Online", "Validation"] )
-
- self.Histograms += [ defineHistogram('nTrksIn', type='TH1F', title="Number of ID tracks in input",
- xbins=1001, xmin=-0.5, xmax=1000.5) ]
-
- self.Histograms += [ defineHistogram('nRoiOut', type='TH1F', title="Number of ROI's made from ID tracks",
- xbins=101, xmin=-0.5, xmax=100.5) ]
-
- self.Histograms += [ defineHistogram('etaTrkIn', type='TH1F', title="eta of input ID tracks",
- xbins=60, xmin=-3.0, xmax=3.0) ]
-
- self.Histograms += [ defineHistogram('phiTrkIn', type='TH1F', title="phi of input ID tracks",
- xbins=60, xmin=-math.pi, xmax=math.pi) ]
-
-
-class InDetTrkRoiMakerValidationMonitoring(TrigGenericMonitoringToolConfig):
- def __init__ (self, name="InDetTrkRoiMakerValidationMonitoring",**kwargs):
- super(InDetTrkRoiMakerValidationMonitoring, self).__init__(name,**kwargs)
- self.defineTarget( ["Validation"] )
-
- self.Histograms += [ defineHistogram('nRoiToTrkRatio', type='TH1F', title="fraction of ID tracks that become ROI's",
- xbins=100, xmin=0.0, xmax=1.0) ]
-
-
- self.Histograms += [ defineHistogram('ptTrkIn', type='TH1F', title="pT of input ID tracks [GeV]",
- xbins=100, xmin=0.0, xmax=100) ]
-
-
- self.Histograms += [ defineHistogram('ptRoiOut', type='TH1F', title="pT of ID tracks that make an ROI [GeV]",
- xbins=100, xmin=0.0, xmax=100) ]
-
-
- self.Histograms += [ defineHistogram('etaRoiOut', type='TH1F', title="eta of ID tracks that make an ROI",
- xbins=60, xmin=-3.0, xmax=3.0) ]
-
- self.Histograms += [ defineHistogram('phiRoiOut', type='TH1F', title="phi of ID tracks that make an ROI",
- xbins=60, xmin=-math.pi, xmax=math.pi) ]
-
- self.Histograms += [ defineHistogram('dEtaTrkSel', type='TH1F', title="eta difference between ID tracks that pass track cuts",
- xbins=120, xmin=-6.0, xmax=6.0) ]
-
- self.Histograms += [ defineHistogram('dPhiTrkSel', type='TH1F', title="phi difference between ID tracks that pass track cuts",
- xbins=60, xmin=-math.pi, xmax=math.pi) ]
- self.Histograms += [ defineHistogram('dRTrkSel', type='TH1F', title="deltaR between ID tracks that pass track cuts",
- xbins=100, xmin=0, xmax=1) ]
-
- self.Histograms += [ defineHistogram('logdRTrkSel', type='TH1F', title="log(deltaR) between ID tracks that pass track cuts",
- xbins=100, xmin=-3, xmax=1) ]
-
-
-class TrigMuonEFFSRoiMakerMonitoring(TrigGenericMonitoringToolConfig):
- def __init__ (self, name="TrigMuonEFFSRoiMakerMonitoring",**kwargs):
- super(TrigMuonEFFSRoiMakerMonitoring, self).__init__(name,**kwargs)
- self.defineTarget( ["Online", "Validation"] )
-
- self.Histograms += [ defineHistogram('nTrkIn', type='TH1F', title="Number of input muon tracks to EFFSRoiMaker;n(muons);Events",
- xbins=6, xmin=-0.5, xmax=5.5) ]
- self.Histograms += [ defineHistogram('nRoIOut', type='TH1F', title="Number of created RoIs;n(RoIs);Events",
- xbins=6, xmin=-0.5, xmax=5.5) ]
-
-class TrigMuonEFIDTrackRoiMakerMonitoring(TrigGenericMonitoringToolConfig):
- def __init__(self, name="TrigMuonEFIDTrackRoiMakerMonitoring",**kwargs):
- super(TrigMuonEFIDTrackRoiMakerMonitoring, self).__init__(name,**kwargs)
- self.defineTarget( ["Online", "Validation"] )
-
- self.Histograms += [ defineHistogram('RoIz', type='TH1F', title="z0 of created RoIs;z0 [mm];RoIs",
- xbins=50, xmin=-250, xmax=250) ]
- self.Histograms += [ defineHistogram('DeltaEta', type='TH1F', title="difference in eta between muon and RoI;d(eta); Muons",
- xbins=50, xmin=0.0, xmax=0.3) ]
- self.Histograms += [ defineHistogram('DeltaPhi', type='TH1F', title="difference in phi between muon and RoI;d(phi); Muons",
- xbins=50, xmin=0.0, xmax=0.3) ]
diff --git a/Trigger/TrigAlgorithms/TrigMuonEF/src/InDetTrkRoiMaker.cxx b/Trigger/TrigAlgorithms/TrigMuonEF/src/InDetTrkRoiMaker.cxx
deleted file mode 100644
index 1d2d43fdfc1fcee7e8c97b8035f0f678806df614..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuonEF/src/InDetTrkRoiMaker.cxx
+++ /dev/null
@@ -1,316 +0,0 @@
-/*
- Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
-*/
-
-#include <cstdlib>
-#include <cmath>
-
-#include "InDetTrkRoiMaker.h"
-
-#include "TrigSteeringEvent/TrigRoiDescriptor.h"
-#include "TrigNavigation/TriggerElement.h"
-
-#include "TrigInDetEvent/TrigInDetTrackCollection.h"
-#include "EventPrimitives/EventPrimitivesHelpers.h"
-
-namespace {
- inline std::string quote( const std::string& s ) { return "\"" + s + "\""; }
-}
-
-// static functions
-InDetTrkRoiMaker::EFSMode InDetTrkRoiMaker::modeNameToEnum( const std::string& modeName ) {
- unsigned int nModes = (unsigned int)kNumberOfModes;
- for ( unsigned int iMode = 0; iMode < nModes; ++iMode ) {
- if ( modeName == s_scanModeNames[iMode] ) return EFSMode(iMode);
- }
- // not found
- return kNumberOfModes; // to signal failure
-}
-
-TrigInDetTrack::AlgoId InDetTrkRoiMaker::seedsNameToEnum( const std::string& seedsName ) {
- TrigInDetTrack::AlgoId algoId(TrigInDetTrack::STRATEGY_F_ID);
-
- if (seedsName=="STRATEGY_F") algoId = TrigInDetTrack::STRATEGY_F_ID;
- else if (seedsName=="IDSCAN") algoId = TrigInDetTrack::IDSCANID;
- else if (seedsName=="SITRACK") algoId = TrigInDetTrack::SITRACKID;
- else if (seedsName=="STRATEGY_A") algoId = TrigInDetTrack::STRATEGY_A_ID;
- else if (seedsName=="STRATEGY_B") algoId = TrigInDetTrack::STRATEGY_B_ID;
- else if (seedsName=="STRATEGY_C") algoId = TrigInDetTrack::STRATEGY_C_ID;
- else if (seedsName=="TRTXK") algoId = TrigInDetTrack::TRTXKID;
- else if (seedsName=="TRTSEG") algoId = TrigInDetTrack::TRTLUTID;
- else if (seedsName=="FTF") algoId = TrigInDetTrack::FTF;
- return algoId;
-}
-
-std::string InDetTrkRoiMaker::getScanModeHelp() {
- std::string scanModeHelp("Possible values of full-scan mode:\n");
- unsigned int nModes = (unsigned int)kNumberOfModes;
- for ( unsigned int iMode = 0; iMode < nModes; ++iMode ) {
- scanModeHelp += quote(s_scanModeNames[kFullScan]);
- scanModeHelp += ": Use full detector\n";
- scanModeHelp += quote(s_scanModeNames[kSeededScan]);
- scanModeHelp += ": Use tracks as seeds to use multiple parts of detector";
- scanModeHelp += quote(s_scanModeNames[kHybridScan]);
- scanModeHelp += ": Use SeededScan mode for |eta| <= SeedsEtaMax and FullScan mode for |eta| > SeedsEtaMax";
- }
- return scanModeHelp;
-}
-
-
-/**
- * Constructor - set up the algorithm
- */
-InDetTrkRoiMaker::InDetTrkRoiMaker(const std::string & name, ISvcLocator* pSvcLocator) :
- HLT::FexAlgo(name, pSvcLocator)
-{
- // ID algorithm to use as input
- declareProperty("FullScanMode", m_fullScanModeProperty="HybridScan", getScanModeHelp());
- // what to consider full detector eta range for end-caps in HybridScan mode
- declareProperty("FullEtaRange", m_fullEtaRange = 5.0 );
-
- declareProperty("SeedsIDalgo", m_ID_algo_to_use="STRATEGY_F");
- // main track cuts
- declareProperty("SeedsEtaMax", m_EtaMaxTrk = 2.5, "Only use track seeds with |eta| <= SeedsEtaMax. Only used in modes \"SeededScan\" and \"HybridScan\"");
- declareProperty("SeedsPtMin", m_PtMinTrk = 5.0, "Only use track seeds with pT >= SeedsPtMin (GeV/c). Only used in modes \"SeededScan\" and \"HybridScan\"");
- //ID tracks quality parameters
- declareProperty("SeedsMaxAbsZ", m_ZMaxTrk=999999999.);
- declareProperty("SeedsMaxChi2", m_Chi2MaxTrk=999999999.);
- declareProperty("SeedsMinNPixHit", m_NPIXhitMinTrk=0);
- declareProperty("SeedsMinNSCTHit", m_NSCThitMinTrk=0);
-
- declareMonitoredVariable("nTrksIn", m_nTrksIn, IMonitoredAlgo::AutoClear);
- declareMonitoredVariable("nRoiOut", m_nRoiOut, IMonitoredAlgo::AutoClear);
- declareMonitoredVariable("nRoiToTrkRatio", m_nRoiToTrkRatio, IMonitoredAlgo::AutoClear);
-
- declareMonitoredStdContainer("ptTrkIn", m_ptTrkIn, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("etaTrkIn", m_etaTrkIn, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("phiTrkIn", m_phiTrkIn, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("ptRoiOut", m_ptRoiOut, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("etaRoiOut", m_etaRoiOut, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("phiRoiOut", m_phiRoiOut, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("dEtaTrkSel", m_dEtaTrkSel, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("dPhiTrkSel", m_dPhiTrkSel, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("dRTrkSel", m_dRTrkSel, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("logdRTrkSel", m_logdRTrkSel, IMonitoredAlgo::AutoClear);
-
- // set consistent values of data members
- m_seedsAlgoId = seedsNameToEnum(m_ID_algo_to_use);
- m_fullScanMode = modeNameToEnum(m_fullScanModeProperty);
-
-}
-
-/**
- * Destructor - clean up when done
- */
-InDetTrkRoiMaker::~InDetTrkRoiMaker() {
-
-}
-
-/**
- * Initialize the algorithm
- */
-HLT::ErrorCode InDetTrkRoiMaker::hltInitialize() {
-
- m_seedsAlgoId = seedsNameToEnum(m_ID_algo_to_use);
- m_fullScanMode = modeNameToEnum(m_fullScanModeProperty);
- if ( m_fullScanMode == kNumberOfModes ) {
- ATH_MSG_FATAL("FullScanMode = \"" << m_fullScanModeProperty << "\" not supported. "
- << getScanModeHelp() );
- return HLT::BAD_JOB_SETUP;
- }
-
- return HLT::OK;
-}//hltInitialize
-
-/**
- * Finalize the algorithm
- */
-HLT::ErrorCode InDetTrkRoiMaker::hltFinalize() {
-
- return HLT::OK;
-}//hltFinalize
-
-HLT::ErrorCode InDetTrkRoiMaker::hltExecute(const HLT::TriggerElement* inputTE, HLT::TriggerElement* outputTE) {
- // clear monitor variables
- beforeExecMonitors().ignore();
- outputTE->setActiveState(true);
-
- TrigRoiDescriptor* superRoI = new TrigRoiDescriptor(true); // create fullscan RoI
- // superRoI->set_roiId(10000); /// do we need this ??
-
- if ( m_fullScanMode == kFullScan ) {
- /// now use a standard TrigRoiDescriptor, these are not
- /// composite by default
- superRoI->setComposite(false); // so it will be treated as a full-scan
-
- } else if ( m_fullScanMode == kSeededScan || m_fullScanMode == kHybridScan ) {
- superRoI->setComposite(false);
- // superRoI->manageConstituents(true);
-
-
-
- // std::vector <const TrigInDetTrackCollection*> vectorOfTrackCollections;
- std::vector<const TrackCollection*> vectorOfTrackCollections;
- if( HLT::OK != getFeatures(inputTE,vectorOfTrackCollections, "") ) {
- ATH_MSG_WARNING(" Failed to get InDetTrackCollections --> no match");
- return HLT::MISSING_FEATURE;
- }
-
- ATH_MSG_DEBUG(" Got InDetTrackCollections "<<vectorOfTrackCollections.size());
-
- std::vector<const TrackCollection*>::iterator
- theTrackColl = vectorOfTrackCollections.begin(),
- endTrackColl = vectorOfTrackCollections.end();
-
- // Loop on container & create ROIs.
- int nFound(0);
- int nIDtracks(0);
- for ( ; theTrackColl != endTrackColl; ++theTrackColl ) {//Tracks Collections Loop
-
- TrackCollection::const_iterator
- track = (*theTrackColl)->begin(),
- lasttrack = (*theTrackColl)->end();
-
- for ( ; track != lasttrack; ++track ) {//Tracks Loop
- //Select tracks
- ++nIDtracks;
-
- if (!((*track)->perigeeParameters())) continue; //Must have helix parameters
- double pt_id = (*track)->perigeeParameters()->momentum().perp()*0.001; //in GeV/c
- double phi_id = (*track)->perigeeParameters()->parameters()[Trk::phi0];
- double theta = (*track)->perigeeParameters()->parameters()[Trk::theta] ;
- double eta_id = -log(fabs(tan(theta*0.5)));
-
- // FIXME: MS what are the eta and phi resolutions? are these set correctly?
- // Use these for the roi sizes
- // double deta_id = (*track)->perigeeParameters()->parameters()[Trk::eeta];
-
- double zPos_id = (*track)->perigeeParameters()->parameters()[Trk::z0];
- double chi2_id = (*track)->fitQuality()->chiSquared();
- // int npixh_id = (*track)->NPixelSpacePoints();
- // int nscth_id = (*track)->NSCT_SpacePoints();
- // Eigen::Matrix<double, 5, 5, 0, 5, 5> covMat = *( (*track)->perigeeParameters()->covariance());
- double dphi_id = 0.1;//Amg::error(covMat,Trk::phi0);
- // double dtheta_id = Amg::error(covMat,Trk::theta);
- double deta_id = 0.1;
- // if(fabs(sin(theta))>0) deta_id = dtheta_id/sin(theta);
- // ATH_MSG_DEBUG("dphi: "<<dphi_id<<" deta: "<<deta_id);
- ATH_MSG_DEBUG( "Found track: "
- << m_ID_algo_to_use
- << " with pt= " << pt_id
- << ", eta=" << eta_id
- << ", phi=" << phi_id
- << ", Zid=" << zPos_id
- << ", Chi2=" << chi2_id
- // << ", NPix=" << npixh_id
- // << ", NSCT=" << nscth_id
- );
-
- // monitoring
- m_ptTrkIn.push_back( std::abs(pt_id) );
- m_etaTrkIn.push_back( eta_id );
- m_phiTrkIn.push_back( phi_id );
-
- // track selection
- if (std::abs(pt_id) < m_PtMinTrk) continue;
- if (std::abs(eta_id) > m_EtaMaxTrk) continue;
- if (std::abs(zPos_id) > m_ZMaxTrk) continue;
- if (chi2_id > m_Chi2MaxTrk) continue;
- // if (npixh_id < m_NPIXhitMinTrk) continue;
- // if (nscth_id < m_NSCThitMinTrk) continue;
-
- ++nFound;
-
- TrigRoiDescriptor* newRoi = createSingleTrigRoiDescriptor( eta_id, phi_id, deta_id, dphi_id, superRoI->roiId() + nFound );
- superRoI->push_back( newRoi );
- ATH_MSG_DEBUG("Added RoI from selected track: " << *newRoi );
-
- // difference w.r.t already found tracks
- int n = m_etaRoiOut.size();
- for ( int i = 0; i < n; ++i ) {
- double dEta = eta_id - m_etaRoiOut[i];
- double dPhi = phi_id - m_phiRoiOut[i];
- // put phi in range -PI,PI
- while ( dPhi > M_PI ) dPhi -= 2*M_PI;
- while ( dPhi <= -M_PI ) dPhi += 2*M_PI;
- double dR = std::sqrt( dEta*dEta + dPhi*dPhi );
- m_dEtaTrkSel.push_back( dEta );
- m_dPhiTrkSel.push_back( dPhi );
- m_dRTrkSel.push_back( dR );
- if ( dR > 0.0 ) m_logdRTrkSel.push_back( std::log10(dR) );
- }
-
- // monitoring
- m_ptRoiOut.push_back( std::abs(pt_id) );
- m_etaRoiOut.push_back( eta_id );
- m_phiRoiOut.push_back( phi_id );
-
-
- }//Tracks loop
- }
-
- m_nTrksIn = nIDtracks;
- m_nRoiOut = nFound;
- if ( m_nTrksIn > 0 ) {
- m_nRoiToTrkRatio = (double)m_nRoiOut/(double)m_nTrksIn;
- } else {
- m_nRoiToTrkRatio = 0.0;
- }
-
- ATH_MSG_DEBUG("Made " << nFound << " ROIs from " << nIDtracks << m_ID_algo_to_use << " tracks.");
-
- if ( m_fullScanMode == kHybridScan ) {
- // add 2 eta regions outside of seeds range
- if ( m_EtaMaxTrk < m_fullEtaRange - 0.00001 ) {
- double etaCentral = 0.5 * std::abs(m_EtaMaxTrk + m_fullEtaRange);
- TrigRoiDescriptor* endcapPositive = new TrigRoiDescriptor( etaCentral, m_EtaMaxTrk, m_fullEtaRange, /* eta positive end-cap */
- 0., -M_PI+1e-6, M_PI-1e-6 /* full phi range */ ,0.,-255.,255.);
- TrigRoiDescriptor* endcapNegative = new TrigRoiDescriptor( -etaCentral, -m_fullEtaRange, -m_EtaMaxTrk, /* eta negative end-cap */
- 0., -M_PI+1e-6, M_PI-1e-6 /* full phi range */,0.,-255.,255. );
-
- superRoI->push_back( endcapPositive );
- superRoI->push_back( endcapNegative );
-
- ATH_MSG_DEBUG("Added RoI from positive end-cap: " << *endcapPositive );
- ATH_MSG_DEBUG("Added RoI from negative end-cap: " << *endcapNegative );
- }
- } // if m_fullScanMode == kHybridScan
-
- } // if m_fullScanMode == kSeededScan || kHybridScan
-
- // add just one new outputTE with one TrigSuperRoI
- // outputTE = addRoI(0, superRoI);
- // for(auto roi : superRoI)
- attachFeature(outputTE,superRoI,"forMSFS");
- outputTE->setActiveState(true);
- // fill monitor variables "by hand" because this is an allTE algo
- afterExecMonitors().ignore();
- return HLT::OK;
-}//hltExecute
-
-
-
-TrigRoiDescriptor* InDetTrkRoiMaker::createSingleTrigRoiDescriptor( double eta, double phi, double etaWidth, double phiWidth, int roiNum ) {
- double minphi = phi - std::abs(phiWidth);
- double maxphi = phi + std::abs(phiWidth);
- if(minphi < -M_PI) minphi += 2.0*M_PI;
- if(minphi >= M_PI) minphi -= 2.0*M_PI;
- if(maxphi <= -M_PI) maxphi += 2.0*M_PI;
- if(maxphi > M_PI) maxphi -= 2.0*M_PI;
- double minEta = eta - std::abs(etaWidth);
- double maxEta = eta + std::abs(etaWidth);
-
- /// Oh no!! will setting the roiword and the l1id to 0 have any serious consequences?
- /// do we really need these identifiers? Does anything actually ever use them for
- /// anything except printout? I guess not, since by default they are set to 0 anyhow.
- TrigRoiDescriptor* trigRoI = new TrigRoiDescriptor( unsigned(0), unsigned(roiNum), eta, minEta, maxEta, phi, minphi, maxphi);
- // trigRoI->set_roiId(roiNum);
-
- ATH_MSG_VERBOSE( "createSingleTrigRoiDescriptor: Creating Roi with center " << " (eta,phi) = (" << eta << "," << phi <<
- ") and size (dEta,dPhi) = (" << etaWidth << "," << phiWidth << ")\n" <<
- " createSingleTrigRoiDescriptor: Roi num = " << roiNum << " etaRange = " << minEta << " -> " << maxEta <<
- " phiRange = " << minphi << " -> " << maxphi );
-
- return trigRoI;
-}
-
diff --git a/Trigger/TrigAlgorithms/TrigMuonEF/src/InDetTrkRoiMaker.h b/Trigger/TrigAlgorithms/TrigMuonEF/src/InDetTrkRoiMaker.h
deleted file mode 100644
index 84c04b71042dcca177c8a71dede566238e52b4d2..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuonEF/src/InDetTrkRoiMaker.h
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
- Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
-*/
-
-#ifndef TRIGMUONEF_INDETTRKROIMAKER_H
-#define TRIGMUONEF_INDETTRKROIMAKER_H
-
-// ************************************************
-//
-// NAME: InDetTrkRoiMaker.h
-// PACKAGE: Trigger/TrigAlgorithms/TrigMuonEF
-//
-// AUTHORS: Alex Oh, Martin Woudstra. Inspired by code from Mark Owen.
-//
-// ************************************************
-
-#include "TrigInterfaces/Algo.h"
-#include "TrigInDetEvent/TrigInDetTrack.h"
-#include "TrigInterfaces/FexAlgo.h"
-
-class InDetTrkRoiMaker : public HLT::FexAlgo {
-
- public:
-
-
- /// Constructor
- InDetTrkRoiMaker(const std::string & name, ISvcLocator* pSvcLocator);
-
- /// Destructor
- ~InDetTrkRoiMaker();
-
- /// Initialize
- HLT::ErrorCode hltInitialize();
-
- /// Execute for each event
- HLT::ErrorCode hltExecute(const HLT::TriggerElement*, HLT::TriggerElement*);
-
- /// Finalize
- HLT::ErrorCode hltFinalize();
-
- protected:
-
- //
- // nested types
- //
- enum EFSMode { kFullScan, // Make a full-scan RoI
- kSeededScan, // Make SuperRoI filled with RoI's based on input track seeds, within |eta| < etaMax
- kHybridScan, // use seeded mode for |eta| <= etaMax, and full-scan mode for |eta| > etaMax
- kNumberOfModes }; // for book keeping
-
- //
- // static data
- //
- static constexpr const char* s_scanModeNames[kNumberOfModes]{ "FullScan", "SeededScan", "HybridScan" };
-
- //
- // static functions
- //
- static EFSMode modeNameToEnum( const std::string& modeName );
-
- static TrigInDetTrack::AlgoId seedsNameToEnum( const std::string& seedsName );
-
- static std::string getScanModeHelp();
-
- //
- // member functions
- //
- TrigRoiDescriptor* createSingleTrigRoiDescriptor( double eta, double phi, double etaWidth, double phiWidth, int roiNum );
-
- //
- // member data
- //
-
- /** Identifier for the ID algorithm to use. Set from m_ID_algo_to_use Property */
- TrigInDetTrack::AlgoId m_seedsAlgoId;
-
- /** Full-scan mode for internal use. Value set from Property m_fullScanModeProperty */
- EFSMode m_fullScanMode;
-
- //
- // JobOptions Properties
- //
-
- std::string m_fullScanModeProperty;
-
- std::string m_ID_algo_to_use;
-
- std::string m_outputRoiLabel;
-
- /** Full eta range of the whole detector. Will be used as upper eta limit in Hybrid mode for the end-caps. */
- double m_fullEtaRange;
-
- /** In SeededMode and Hybrid mode: only use track seeds with |eta| <= m_seedsEtaMax.
- In Hybrid mode: In addition, do full scan for |eta| > m_seedsEtaMax. */
- double m_EtaMaxTrk;
-
- /** In SeededMode and HybridMode: only use tracks seeds with pT > m_seedsPtMin (GeV/c) */
- double m_PtMinTrk;
-
- /** Max abs(Zeta) to select the ID track for matching */
- double m_ZMaxTrk;
-
- /** Max chi2 to select the ID track for matching */
- double m_Chi2MaxTrk;
-
- /** Min number of PIX space points to select the ID track for matching */
- int m_NPIXhitMinTrk;
-
- /** Min number of SCT space points to select the ID track for matching */
- int m_NSCThitMinTrk;
-
- //
- // Monitoring variables
- //
- int m_nTrksIn;
- int m_nRoiOut;
- double m_nRoiToTrkRatio;
- std::vector<double> m_ptTrkIn;
- std::vector<double> m_etaTrkIn;
- std::vector<double> m_phiTrkIn;
- std::vector<double> m_ptRoiOut;
- std::vector<double> m_etaRoiOut;
- std::vector<double> m_phiRoiOut;
- std::vector<double> m_dEtaTrkSel;
- std::vector<double> m_dPhiTrkSel;
- std::vector<double> m_dRTrkSel;
- std::vector<double> m_logdRTrkSel;
-
-
-};//class InDetTrkRoiMaker
-
-
-#endif // TRIGMUONEF_INDETTRKROIMAKER_H
diff --git a/Trigger/TrigAlgorithms/TrigMuonEF/src/SegmentCache.cxx b/Trigger/TrigAlgorithms/TrigMuonEF/src/SegmentCache.cxx
deleted file mode 100644
index bfba9e32e7d5c799311d2c76f84d278ce72dfe7d..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuonEF/src/SegmentCache.cxx
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
-*/
-
-#include "SegmentCache.h"
-#include "TrigMuonEvent/TrigMuonEFInfo.h"
-#include "MuonSegment/MuonSegment.h"
-#include "MuonPattern/MuonPatternCombinationCollection.h"
-#include "MuonPattern/MuonPatternCombination.h"
-
-SegmentCache::SegmentCache(){
- m_segments=0;
- m_pattcoll=0;
- m_msTracks = 0;
- m_saTracks = 0;
- m_nroi=0;
- }
-
-
-/**
- * Destructor.
- * We do not delete the pointers, since these are not owned by this class.
- */
-SegmentCache::~SegmentCache(){
-
-}
-
-void SegmentCache::AddPatternCollection(const MuonPatternCombinationCollection* pat) {
- m_pattcoll = pat;
-}
-
-void SegmentCache::AddSegments(const Trk::SegmentCollection* trk) {
- m_segments = trk;
-}
-
-void SegmentCache::SetNROI(int n){
- m_nroi= n;
-}
-
-void SegmentCache::SetSpectrometerTrackCollection( const TrackCollection* msTracks ) {
- m_msTracks = msTracks;
-}
-
-void SegmentCache::SetExtrapolatedTrackCollection( TrackCollection* saTracks ) {
- m_saTracks = saTracks;
-}
diff --git a/Trigger/TrigAlgorithms/TrigMuonEF/src/SegmentCache.h b/Trigger/TrigAlgorithms/TrigMuonEF/src/SegmentCache.h
deleted file mode 100644
index e2a9078e3407b90ea101cce5044e0a9996bad55d..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuonEF/src/SegmentCache.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
-*/
-
-#ifndef TrigMuonEF_SegmentCache_H__
-#define TrigMuonEF_SegmentCache_H__
-
-#include <vector>
-#include "MuonPattern/MuonPatternCombinationCollection.h"
-#include "MuonPattern/MuonPatternCombination.h"
-#include "TrkSegment/SegmentCollection.h"
-#include "TrkTrack/TrackCollection.h"
-
-
-class TrigMuonEFInfo;
-class SegmentCache {
-
- public:
- /// Default Constructor
- SegmentCache();
-
- /// Destructor
- ~SegmentCache();
-
-
- //void AddMuonInfo(TrigMuonEFInfo* MI);
- void AddPatternCollection(const MuonPatternCombinationCollection* pat);
- void AddSegments(const Trk::SegmentCollection* trk);
- void SetNROI(int n);
- void SetSpectrometerTrackCollection( const TrackCollection* msTracks );
- void SetExtrapolatedTrackCollection( TrackCollection* saTracks );
- const MuonPatternCombinationCollection* PattColl() const {return m_pattcoll;}
- const Trk::SegmentCollection* Segments() const {return m_segments;}
- int NROI() const {return m_nroi;}
- const TrackCollection* SpectrometerTrackColl() { return m_msTracks;}
- TrackCollection* ExtrapolatedTrackColl() { return m_saTracks;}
-
- private:
-
- const MuonPatternCombinationCollection* m_pattcoll;
- const Trk::SegmentCollection* m_segments;
- const TrackCollection* m_msTracks;
- TrackCollection* m_saTracks;
- int m_nroi;
-};
-
-#endif
diff --git a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFCaloIsolation.cxx b/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFCaloIsolation.cxx
deleted file mode 100644
index ea1f2011c0a144a17a48b5991bd95d5957eae9ae..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFCaloIsolation.cxx
+++ /dev/null
@@ -1,220 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-#include "TrigMuonEFCaloIsolation.h"
-#include "TrigConfHLTData/HLTTriggerElement.h"
-
-#include "xAODMuon/MuonContainer.h"
-#include "RecoToolInterfaces/ICaloCellIsolationTool.h"
-#include "RecoToolInterfaces/ICaloTopoClusterIsolationTool.h"
-#include "RecoToolInterfaces/IsolationCommon.h"
-
-#include "TLorentzVector.h"
-#include <iostream>
-#include <deque>
-
-ATLAS_NO_CHECK_FILE_THREAD_SAFETY; // legacy trigger code
-
-// ------------------------------------------------------------------------------------------------------
-/**
- * Standard constructor for the calo isolation algo.
- */
-TrigMuonEFCaloIsolation::TrigMuonEFCaloIsolation(const std::string &name, ISvcLocator *pSvcLocator) :
- FexAlgo(name, pSvcLocator),
- m_requireCombined(false),
- m_debug(false),
- m_caloTopoClusterIsolationTool("xAOD__CaloIsolationTool"),
- m_etiso_cone2(),
- m_etiso_cone3(),
- m_etiso_cone4() {
- declareProperty("RequireCombinedMuon", m_requireCombined);
- declareProperty("CaloTopoClusterIsolationTool", m_caloTopoClusterIsolationTool);
- declareProperty("HistoPathBase", m_histo_path_base = "/EXPERT/");
- declareProperty("applyPileupCorrection", m_applyPileupCorrection = false);
-
- ///////// Monitoring Variables
- declareMonitoredStdContainer("EF_etiso_cone2", m_etiso_cone2, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_etiso_cone3", m_etiso_cone3, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_etiso_cone4", m_etiso_cone4, IMonitoredAlgo::AutoClear);
-}
-
-// ------------------------------------------------------------------------------------------------------
-/**
- * Destructor.
- */
-TrigMuonEFCaloIsolation::~TrigMuonEFCaloIsolation() {
-}
-
-// ------------------------------------------------------------------------------------------------------
-/**
- * Initialize the algorithm.
- */
-HLT::ErrorCode TrigMuonEFCaloIsolation::hltInitialize() {
-
- m_debug = msgLvl() <= MSG::DEBUG;
-
- ATH_MSG_DEBUG("Initializing TrigMuonEFCaloIsolation[" << name() << "]");
- ATH_MSG_DEBUG("package version = " << PACKAGE_VERSION);
- ATH_MSG_DEBUG("Properties set as follows: ");
- ATH_MSG_DEBUG("RequireCombinedMuon: " << m_requireCombined);
-
- if (m_caloTopoClusterIsolationTool.retrieve().isSuccess()) {
- ATH_MSG_DEBUG("Retrieved " << m_caloTopoClusterIsolationTool);
- } else {
- ATH_MSG_FATAL("Could not retrieve " << m_caloTopoClusterIsolationTool);
- return HLT::BAD_JOB_SETUP;
- }
-
- ATH_MSG_DEBUG("End of init TrigMuonEFCaloIsolation");
-
- return HLT::OK;
-}
-
-// ------------------------------------------------------------------------------------------------------
-/**
- * Fill the et-cone calorimeter isolation values for a container of xAOD muons.
- */
-void TrigMuonEFCaloIsolation::fillCaloIsolation(const xAOD::MuonContainer *muons, const xAOD::CaloClusterContainer *clustercont) {
-
- if (m_caloTopoClusterIsolationTool.empty()) {
- ATH_MSG_WARNING("No calorimeter topo cluster isolation tool available." );
- return;
- }
-
- std::vector<xAOD::Iso::IsolationType> etCones = { xAOD::Iso::etcone40,
- xAOD::Iso::etcone30,
- xAOD::Iso::etcone20
- };
-
- for (auto muon : *muons) {
-
- if (m_debug) {
- ATH_MSG_DEBUG("Processing next EF muon " << muon);
- }
-
- const xAOD::Muon::MuonType muontype = muon->muonType();
- if ( muontype == xAOD::Muon::MuonType::Combined || muontype == xAOD::Muon::MuonType::SegmentTagged ) {
- if (m_debug) {
- ATH_MSG_DEBUG("EF muon has combined or segment tagged muon");
- }
- } else {
- if (m_requireCombined) {
- if (m_debug) {
- ATH_MSG_DEBUG("Not a combined or segment tagged muon & requireCombined=true, so ignore this muon");
- }
- continue;
- }//requireCombined
- }//no combined muon
-
- const xAOD::TrackParticle *tp = 0;
- if (muon->inDetTrackParticleLink().isValid()) tp = *(muon->inDetTrackParticleLink());
- if ( !tp ) tp = muon->primaryTrackParticle();
- if ( !tp ) {
- ATH_MSG_WARNING("No TrackParticle found for muon." );
- continue;
- }
-
- xAOD::CaloIsolation caloIsolation;
- xAOD::CaloCorrection corrlist;
- if (m_applyPileupCorrection)
- corrlist.calobitset.set(static_cast<unsigned int>(xAOD::Iso::pileupCorrection));
-
- corrlist.calobitset.set(static_cast<unsigned int>(xAOD::Iso::IsolationCaloCorrection::coreCone));
- if ( !m_caloTopoClusterIsolationTool->caloTopoClusterIsolation( caloIsolation, *tp, etCones, corrlist, clustercont ) ) {
- ATH_MSG_WARNING("Calculation of topocluster based calorimeter isolation failed");
- continue;
- }
- // if ( !m_caloTopoClusterIsolationTool->decorateParticle_topoClusterIso(*tp, etCones, corrlist, clustercont) ) {
- // ATH_MSG_WARNING("Calculation of topocluster based calorimeter isolation failed");
- // continue;
- // }
-
- for ( unsigned int i = 0; i < etCones.size(); ++i ) {
- ((xAOD::Muon *)muon)->setIsolation(caloIsolation.etcones[i], etCones[i]);
- }
-
- //Monitor the values
- m_etiso_cone2.push_back( caloIsolation.etcones[2] * 1e-3 );
- m_etiso_cone3.push_back( caloIsolation.etcones[1] * 1e-3 );
- m_etiso_cone4.push_back( caloIsolation.etcones[0] * 1e-3 );
-
- if (m_debug) {
- ATH_MSG_DEBUG("Filled muon isolation information with:");
- ATH_MSG_DEBUG("\tCone Et 0.2 sum = " << m_etiso_cone2.back() << " GeV");
- ATH_MSG_DEBUG("\tCone Et 0.3 sum = " << m_etiso_cone3.back() << " GeV");
- ATH_MSG_DEBUG("\tCone Et 0.4 sum = " << m_etiso_cone4.back() << " GeV");
- }
-
-
- }
-
-}
-
-// ------------------------------------------------------------------------------------------------------
-/**
- * Execute function - called for each roi.
- */
-HLT::ErrorCode TrigMuonEFCaloIsolation::hltExecute(const HLT::TriggerElement *inputTE, HLT::TriggerElement *TEout) {
-
- ATH_MSG_DEBUG(": Executing TrigMuonEFCaloIsolation::execHLTAlgorithm()");
-
- /// extract EF muons
- const xAOD::MuonContainer *muonContainer(0);
- if (HLT::OK != getFeature(inputTE, muonContainer)) {
- ATH_MSG_WARNING("Could not get xAOD::MuonContainer from the trigger element");
- return HLT::MISSING_FEATURE;
- } else {
- if (!muonContainer) {
- ATH_MSG_WARNING("muonContainer is 0 pointer");
- return HLT::MISSING_FEATURE;
- }
- ATH_MSG_DEBUG("MuonContainer extracted with size = " << muonContainer->size());
- }
-
- //Access the last created trigger cluster container
- std::vector<const xAOD::CaloClusterContainer * > vectorOfClusterContainers;
-
- if ( getFeatures(inputTE, vectorOfClusterContainers, "") != HLT::OK) { // Was TEout???
- ATH_MSG_ERROR("Failed to get TrigClusters at: getFeatures()");
- return HLT::ErrorCode(HLT::Action::ABORT_CHAIN, HLT::Reason::NAV_ERROR);
- }
-
- ATH_MSG_DEBUG("Got vector with " << vectorOfClusterContainers.size() << " ClusterContainers");
-
- const xAOD::CaloClusterContainer *theClusterCont = 0;
- if ( vectorOfClusterContainers.size() > 0 ) {
- theClusterCont = vectorOfClusterContainers.back();
- } else {
- ATH_MSG_ERROR("Failed to get TrigClusters: vector size is 0");
- return HLT::ErrorCode(HLT::Action::ABORT_CHAIN, HLT::Reason::NAV_ERROR);
- }
-
- //For each of the muons fill the calorimeter isolation values using the offline tool
- fillCaloIsolation(muonContainer, theClusterCont);
-
- //validate sequence
- TEout->setActiveState(true);
-
- return HLT::OK;
-}
-
-// ------------------------------------------------------------------------------------------------------
-/**
- * Finalize the algorithm.
- */
-HLT::ErrorCode TrigMuonEFCaloIsolation::hltFinalize() {
- ATH_MSG_DEBUG("Finalizing " + name());
- return HLT::OK;
-}
-
-/**
- * Here we can handle incidents like end of event, but for now
- * nothing to do.
- */
-void TrigMuonEFCaloIsolation::handle(const Incident & /*inc*/) {
-}
-
-
-
-
diff --git a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFCaloIsolation.h b/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFCaloIsolation.h
deleted file mode 100644
index fec55c9e6fb8ac6639150b169711d6894b9b536a..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFCaloIsolation.h
+++ /dev/null
@@ -1,84 +0,0 @@
-// This file is really -*- C++ -*-.
-
-/*
- Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
-*/
-
-#ifndef TRIGMUONEF_TRIGMUONEFCALOISOLATION_H__
-#define TRIGMUONEF_TRIGMUONEFCALOISOLATION_H__
-
-#include "TrigInterfaces/FexAlgo.h"
-#include "GaudiKernel/IIncidentListener.h"
-#include "GaudiKernel/ToolHandle.h"
-#include "xAODCaloEvent/CaloClusterContainer.h"
-#include "CaloEvent/CaloCellContainer.h"
-
-#include "CxxUtils/checker_macros.h"
-ATLAS_NO_CHECK_FILE_THREAD_SAFETY; // legacy trigger code
-
-class IsoMuonFeature;
-
-
-namespace xAOD {
-class ICaloCellIsolationTool;
-class ICaloTopoClusterIsolationTool;
-}
-
-/**
- * @class TrigMuonEFCaloIsolation
- *
- * @brief Algorithm to fill etcone or topoetcone calorimeter isolation for EF muons
- *
- * This class calculates calorimeter isolation for EF muons. It uses
- * the last created calorimeter topo cluster container from TrigCaloRec as input
- * to the CaloIsolationTool to calculate the isolation.
- *
- * @author Martin Spangenberg (Martin.Spangenberg@cern.ch)
- */
-class TrigMuonEFCaloIsolation : public virtual HLT::FexAlgo,
- public virtual IIncidentListener {
-public:
-
- /// Constructor
- TrigMuonEFCaloIsolation (const std::string &name, ISvcLocator *pSvcLocator);
- /// Destructor
- ~TrigMuonEFCaloIsolation();
-
- /// Initialize the algorithm
- HLT::ErrorCode hltInitialize();
- /// Execute - called per trigger element
- HLT::ErrorCode hltExecute(const HLT::TriggerElement *, HLT::TriggerElement *);
- /// Finalize the algorithm
- HLT::ErrorCode hltFinalize();
-
-private:
-
- /// Fill et-cone isolation values for xAOD muons
- void fillCaloIsolation(const xAOD::MuonContainer *muons,
- const xAOD::CaloClusterContainer *clustercont);
-
-
- /// Require that EF muons are combined
- bool m_requireCombined;
-
- /// Select if pileup correction should be applied
- bool m_applyPileupCorrection;
-
- /// flag to see if debug is enabled
- bool m_debug;
-
- /// Tool to calculate the isolation
- ToolHandle<xAOD::ICaloTopoClusterIsolationTool> m_caloTopoClusterIsolationTool;
-
- /// Monitoring Histograms
- StringProperty m_histo_path_base; // set the histo path for Monitoring
- //std::vector<double > m_etiso_cone1;
- std::vector<double > m_etiso_cone2;
- std::vector<double > m_etiso_cone3;
- std::vector<double > m_etiso_cone4;
-
- void handle(const Incident &);
-
-}; //class TrigMuonEFCaloIsolation
-
-#endif //TRIGMUONEF_TRIGMUONEFCALOISOLATION_H__
diff --git a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFFSRoiMaker.cxx b/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFFSRoiMaker.cxx
deleted file mode 100644
index f5c67a3c1a0c28c87d50534449924c403c033e67..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFFSRoiMaker.cxx
+++ /dev/null
@@ -1,264 +0,0 @@
-/*
- Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-*/
-
-#include "TrigMuonEFFSRoiMaker.h"
-
-#include "TrigSteeringEvent/TrigRoiDescriptor.h"
-#include "TrigNavigation/TriggerElement.h"
-
-#include "xAODMuon/MuonContainer.h"
-#include "xAODMuon/MuonAuxContainer.h"
-
-//#include "AthContainers/ConstDataVector.h"
-
-/**
- * Constructor - set up the algorithm
- */
-TrigMuonEFFSRoiMaker::TrigMuonEFFSRoiMaker(const std::string & name, ISvcLocator* pSvcLocator) :
- HLT::AllTEAlgo(name, pSvcLocator),
- m_classIDSvc("ClassIDSvc/ClassIDSvc", this->name())
-{
- declareProperty ("MuonPtCut", m_ptcut=-1.0);
- declareProperty ("OutputContName", m_efContName);
- declareProperty ("InvertRoI", m_doInvertRoI=false);
- declareProperty ("UseFSRoI" , m_useFS=true);
- declareProperty ("CreateCrackRoI", m_createCrackRoI=false);
- declareProperty ("CreateFSRoI", m_createFSroi=false);
- declareProperty ("CreateRoIFromL1", m_createRoIfromL1=false);
- declareProperty ("RoISizeEta", m_roiSizeEta=0.1);
- declareProperty ("RoISizePhi", m_roiSizePhi=0.1);
- declareProperty ("RoILabel", m_roiLabel="");
-
- declareMonitoredVariable("nTrkIn", m_nTrkIn, IMonitoredAlgo::AutoClear);
- declareMonitoredVariable("nRoIOut", m_nRoIOut, IMonitoredAlgo::AutoClear);
-}
-
-/**
- * Destructor - clean up when done
- */
-TrigMuonEFFSRoiMaker::~TrigMuonEFFSRoiMaker() {
-
-}
-
-/**
- * Initialize the algorithm
- */
-HLT::ErrorCode TrigMuonEFFSRoiMaker::hltInitialize() {
-
- if (msgLvl() <= MSG::INFO) {
- msg() << MSG::INFO << "Initializing TrigMuonEFFSRoiMaker[" << name() << "], version " << PACKAGE_VERSION << endmsg;
- msg() << MSG::INFO << "pT cut on muons = " << m_ptcut << " MeV" << endmsg;
- msg() << MSG::INFO << "Output EF container name = " << m_efContName << endmsg;
- msg() << MSG::INFO << "RoI eta,phi = " << m_roiSizeEta << "," << m_roiSizePhi << endmsg;
- msg() << MSG::INFO << "RoI Label = " << m_roiLabel << endmsg;
- msg() << MSG::INFO << "Invert RoI = " << m_doInvertRoI << endmsg;
- msg() << MSG::INFO << "Use FS RoI = " << m_useFS << endmsg;
- msg() << MSG::INFO << "Create crack RoI = " << m_createCrackRoI << endmsg;
- msg() << MSG::INFO << "Create FS RoI = " << m_createFSroi << endmsg;
- msg() << MSG::INFO << "Create RoI from L1 = " << m_createRoIfromL1 << endmsg;
- }
-
- if (m_classIDSvc.retrieve().isFailure()) {
- msg() << MSG::WARNING << "Cannot retrieve ClassIDSvc" << endmsg;
- return HLT::BAD_JOB_SETUP;
- }
- else {
- msg() << MSG::INFO << "Retrieved " << m_classIDSvc << endmsg;
- }
-
- return HLT::OK;
-}//hltInitialize
-
-/**
- * Finalize the algorithm
- */
-HLT::ErrorCode TrigMuonEFFSRoiMaker::hltFinalize() {
-
- return HLT::OK;
-}//hltFinalize
-
-HLT::ErrorCode TrigMuonEFFSRoiMaker::hltExecute(std::vector<std::vector<HLT::TriggerElement*> >& inputTEs, unsigned int output) {
-
- // reset monitoring variables
- beforeExecMonitors().ignore();
- m_nTrkIn=0;
- m_nRoIOut=0;
-
- if(m_createFSroi){
- ATH_MSG_DEBUG("creating full scan RoI");
- TrigRoiDescriptor* roiFS = new TrigRoiDescriptor(0.0, -2.5, 2.5, 0.0, -M_PI, M_PI-0.0001);
- HLT::TriggerElement* te = nullptr;
- te = addRoI(output, nullptr );
- te->setActiveState(true);
- std::string key;
- m_config->getNavigation()->attachFeature(te, roiFS, HLT::Navigation::ObjectCreatedByNew, key, m_roiLabel);
- return HLT::OK;
- }
-
- //create RoI from L1 RoIs. Make sure this is run first in the sequence (needed for MGonly chains).
- if(m_createRoIfromL1){
- HLT::TriggerElement* te;
- const HLT::TEVec &tev = inputTEs.back();
- for ( unsigned iTe=0; iTe<tev.size() ; iTe++ ){
- const HLT::TriggerElement* inputTe = tev[iTe];
-
- if(!inputTe){
- msg() << MSG::ERROR << "Invalid TriggerElement pointer = "<< inputTe << endmsg;
- return HLT::ERROR;
- } // end if(!inputTe)
-
- // get the RoiDescriptor
- const TrigRoiDescriptor* roiDescriptor = 0;
- HLT::ErrorCode hltStatus = getFeature(inputTe, roiDescriptor);
- if( hltStatus != HLT::OK ){
- msg()<<MSG::ERROR<<" Failed to find RoiDescriptor "<<endmsg;
- return hltStatus;
- }
- te = addRoI(output, nullptr);
- te->setActiveState(true); // set this trigger element to be active
- std::string key;
- m_config->getNavigation()->attachFeature(te, roiDescriptor, HLT::Navigation::ObjectCreatedByNew, key, m_roiLabel);
- }
- return HLT::OK;
- }
-
- //start of FS roi building
- // we run after FS instance - so should only be one inputTE
- if (inputTEs.size() < 1) {
- msg() << MSG::ERROR << "Got less than one inputTE" << endmsg;
- return HLT::ErrorCode(HLT::Action::ABORT_CHAIN, HLT::Reason::MISSING_FEATURE);
- }
- for(auto inputTE : inputTEs){
- ATH_MSG_DEBUG( "inputTE.size() " << inputTE.size() );
-
- if(inputTE.size() < 1) {
- ATH_MSG_ERROR("Size of the vector<HLT::TriggerElement*> < 1 - no input to process, abort chain");
- return HLT::ErrorCode(HLT::Action::ABORT_CHAIN, HLT::Reason::MISSING_FEATURE);
- }
-
- //Create RoI centered around the crack in MS
- if (m_createCrackRoI) {
-
- TrigRoiDescriptor* newRoI = new TrigRoiDescriptor(0.0, -m_roiSizeEta, m_roiSizeEta, 0.0, -m_roiSizePhi, m_roiSizePhi);
-
- HLT::TriggerElement* outputTE = nullptr;
- if (m_roiLabel == "") {
- //Add RoI with default label
- outputTE = addRoI(output, newRoI);
- } else {
- //Create RoI with no descriptor then attach descriptor as feature with desired label
- std::string key;
- outputTE = addRoI(output, nullptr);
- m_config->getNavigation()->attachFeature(outputTE, newRoI, HLT::Navigation::ObjectCreatedByNew, key, m_roiLabel);
- }
-
- outputTE->setActiveState(true);
- ATH_MSG_DEBUG("RoI:" << *newRoI);
- return HLT::OK;
- }
-
- // Get MuonContainer
- const xAOD::MuonContainer* muonContainer(0);
- for (auto inTE : inputTE) {
- HLT::ErrorCode status = getFeature(inTE, muonContainer);
-
- if(status!=HLT::OK || muonContainer==0) {
- ATH_MSG_WARNING( "Could not get MuonContainer" );
- return HLT::ErrorCode(HLT::Action::ABORT_CHAIN, HLT::Reason::MISSING_FEATURE);
- }
- ATH_MSG_DEBUG("Got MuonContainer with size = " << muonContainer->size());
-
- // Loop on container & create ROIs.
- for(auto muon : *muonContainer) {
-
- const xAOD::TrackParticle* saTrack = muon->primaryTrackParticle();
- if(!saTrack) {
- ATH_MSG_WARNING("No track particle, skip this muon");
- continue;
- }
- ++m_nTrkIn; // count input tracks
- double phi = saTrack->phi();
- double eta = saTrack->eta();
- double pt = saTrack->pt();
-
- /* Some debugging of the error matrix - need to fix for Eigen
- if(msgLvl(MSG::DEBUG)) {
- const Amg::AmgSymMatrix(5)* em = perigee->covariance();
- msg(MSG::DEBUG) << "Err[Trk::z0] = " << Amg::error(*em,Trk::z0) << endmsg;
- msg(MSG::DEBUG) << "Cov[Trk::phi0] = " << em.covValue(Trk::phi0) << endmsg;
- msg(MSG::DEBUG) << "Cov[Trk::theta] = " << em.covValue(Trk::theta) << endmsg;
- msg(MSG::DEBUG) << "Cov[Trk::qoverp] = " << em.covValue(Trk::qOverP) << endmsg;
- }//DEBUG
- } else {
- msg(MSG::DEBUG) << "No Trk::MeasuredPerigee" << endmsg;
- }
- */
-
- if(msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Extrapolated track, pT, eta, phi = " << pt << ", " << eta << ", " << phi << endmsg;
-
- if (m_doInvertRoI) {
- eta = -eta; //Flip RoI in eta
- if (phi > 0) phi -= M_PI; //Shift phi by pi
- else phi += M_PI;
-
- if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "Reversed extrapolated track, pT, eta, phi = " << pt << ", " << eta << ", " << phi << endmsg;
- }
-
- // check pT of track
- if( pt < m_ptcut) {
- ATH_MSG_DEBUG( "Track fails pT cut, ignore" );
- continue;
- }
-
- // create a new ROI from extrapolated track - make it active
- double minphi = phi-m_roiSizePhi;
- if(minphi < -M_PI) minphi = 2.0*M_PI + minphi;
- double maxphi = phi+m_roiSizePhi;
- if(maxphi > M_PI) maxphi = maxphi - 2.0*M_PI;
- TrigRoiDescriptor* newRoI = new TrigRoiDescriptor(eta, eta-m_roiSizeEta, eta+m_roiSizeEta, phi, minphi, maxphi);
-
- HLT::TriggerElement* outputTE = nullptr;
- if (m_roiLabel == "") {
- outputTE = addRoI(output, newRoI);
- } else {
- std::string key;
- outputTE = addRoI(output, nullptr);
- //status = attachFeature(outputTE, newRoI, m_roiLabel);
- m_config->getNavigation()->attachFeature(outputTE, newRoI, HLT::Navigation::ObjectCreatedByNew, key, m_roiLabel);
- //if (status != HLT::OK) {
- // ATH_MSG_ERROR("Failed to attach new RoI.");
- // return status;
- // }
- }
-
- outputTE->setActiveState(true);
- ATH_MSG_DEBUG("Added RoI with eta, phi = " << eta << ", " << phi << ", outputTE = " << outputTE->getId());
- ++m_nRoIOut; // count created RoIs
-
- ATH_MSG_DEBUG("Create output container");
- // make a new MuonContainer with just this muon
- xAOD::MuonContainer* outputContainer = new xAOD::MuonContainer(1);
- xAOD::MuonAuxContainer auxCont;
- outputContainer->setStore(&auxCont);
-
- // deep copy the muon
- xAOD::Muon* muoncopy = new xAOD::Muon();
- (*outputContainer)[0] = muoncopy;
- *muoncopy = *muon;
-
- status = attachFeature(outputTE, outputContainer, m_efContName);
- if ( status != HLT::OK ) {
- msg() << MSG::ERROR << "Failed to attach MuonContainer" << endmsg;
- return status;
- } else {
- ATH_MSG_DEBUG("Successfully attached new MuonContainer to " << outputTE->getId());
- }
- }//loop on muons
- }
- }
- // fill monitor variables "by hand" because this is an allTE algo
- afterExecMonitors().ignore();
-
- return HLT::OK;
-}//hltExecute
diff --git a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFFSRoiMaker.h b/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFFSRoiMaker.h
deleted file mode 100644
index 1af0f20e8b3bbad751fc1c76ec7b098a21df6387..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFFSRoiMaker.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-#ifndef TRIGMUONEF_TRIGMUONEFFSROIMAKER_H__
-#define TRIGMUONEF_TRIGMUONEFFSROIMAKER_H__
-
-// ************************************************
-//
-// NAME: TrigMuonEFFSRoiMaker.h
-// PACKAGE: Trigger/TrigAlgorithms/TrigMuonEF
-//
-// AUTHOR: Mark Owen
-// EMAIL: markowen AT cern.ch
-//
-// ************************************************
-
-#include "TrigInterfaces/AllTEAlgo.h"
-#include "AthenaKernel/IClassIDSvc.h"
-
-/**
- * Class to make ROIs from the results of an MS full scan.
- * Class takes the EDM objects stored by the full scan and
- * creates an ROI based on the eta-phi of the extrapolated track.
- * The EDM objects are re-packaged and attached to the trigger element
- * so they can be processed in standard ROI mode.
- */
-class TrigMuonEFFSRoiMaker : public HLT::AllTEAlgo {
-
- public:
-
- /// Constructor
- TrigMuonEFFSRoiMaker(const std::string & name, ISvcLocator* pSvcLocator);
-
- /// Destructor
- ~TrigMuonEFFSRoiMaker();
-
- /// Initialize
- HLT::ErrorCode hltInitialize();
-
- /// Execute for each event
- HLT::ErrorCode hltExecute(std::vector<std::vector<HLT::TriggerElement*> >&,unsigned int);
-
- /// Finalize
- HLT::ErrorCode hltFinalize();
-
- protected:
- //Construct RoI in cone back-to-back with muon track direction.
- bool m_doInvertRoI;
- bool m_useFS;
- bool m_createCrackRoI;
- bool m_createFSroi;
- bool m_createRoIfromL1;
-
- /// minimum pT cut on extrapolated tracks - above this create ROIs.
- double m_ptcut;
-
- //Radius of roi in eta and phi
- double m_roiSizeEta;
- double m_roiSizePhi;
-
- /// Name of output xAOD::MuonContainer
- std::string m_efContName;
-
- /// Handle to ClassIDSvc
- ServiceHandle<IClassIDSvc> m_classIDSvc;
-
- /// monitor number of input tracks
- unsigned int m_nTrkIn;
- /// monitor number of output ROIs
- unsigned int m_nRoIOut;
-
- /// Label to store RoI with
- std::string m_roiLabel;
-
-};//class TrigMuonEFFSRoiMaker
-
-
-#endif // TRIGMUONEF_TRIGMUONEFFSROIMAKER_H__
diff --git a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFIDTrackRoiMaker.cxx b/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFIDTrackRoiMaker.cxx
deleted file mode 100644
index 578b7a21991de57859cde65006d9ae1c06b136e9..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFIDTrackRoiMaker.cxx
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
- Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
-*/
-
-#include "TrigMuonEFIDTrackRoiMaker.h"
-
-// RoI include
-#include "TrigSteeringEvent/TrigRoiDescriptor.h"
-
-/**
- * Standard constructor for the algorithm
- */
-TrigMuonEFIDTrackRoiMaker::TrigMuonEFIDTrackRoiMaker(const std::string& name, ISvcLocator* pSvcLocator) :
- FexAlgo(name, pSvcLocator),
- m_roiSizeZ0(225.0),//default to large width in mm
- m_inputRoiName("forID"),
- m_outputRoiName("forID2")
-{
-
- declareProperty("Z0Width",m_roiSizeZ0); // should be set in JO to appropriate z-width, ATLAS standard units (mm)
- declareProperty("InputRoiName",m_inputRoiName="forID"); // generally don't expect to need to change this
- declareProperty("OutputRoiName",m_outputRoiName="forID2"); // generally don't expect to need to change this
-
- // variables to monitor
- declareMonitoredVariable("RoIz",m_roiZ);
- declareMonitoredStdContainer("DeltaEta",m_deltaEta,IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("DeltaPhi",m_deltaPhi,IMonitoredAlgo::AutoClear);
-}
-
-/**
- * Destructor
- */
-TrigMuonEFIDTrackRoiMaker::~TrigMuonEFIDTrackRoiMaker()
-{
-
-}
-
-/**
- * Initialize the algo
- */
-HLT::ErrorCode TrigMuonEFIDTrackRoiMaker::hltInitialize() {
- // print out the configuration
- ATH_MSG_DEBUG("Initializing TrigMuonEFIDTrackRoiMaker[" << name() << "]");
- ATH_MSG_DEBUG("InputRoiName = " << m_inputRoiName);
- ATH_MSG_DEBUG("OutputRoiName = " << m_outputRoiName);
- ATH_MSG_DEBUG("Z0Width = " << m_roiSizeZ0);
-
- return HLT::OK;
-}//hltInitialize
-
-/**
- * Finalise the algo - nothing to do yet
- */
-HLT::ErrorCode TrigMuonEFIDTrackRoiMaker::hltFinalize() {
- return HLT::OK;
-}
-
-/**
- * Execute function - called for each roi
- */
-HLT::ErrorCode TrigMuonEFIDTrackRoiMaker::hltExecute(const HLT::TriggerElement* inputTE, HLT::TriggerElement* outputTE) {
-
- ATH_MSG_DEBUG("Executing TrigMuonEFIDTrackRoiMaker::hltExecute");
-
- // get the RoI for the ID tracking
- const TrigRoiDescriptor *roi = 0;
- if (HLT::OK != getFeature(inputTE, roi, m_inputRoiName) ) {
- ATH_MSG_WARNING("Could not get " << m_inputRoiName << " RoI descriptor, cannot update it");
- return HLT::OK;
- }
-
- // get the xAOD::Muons
- const xAOD::MuonContainer* muons = 0;
- if (HLT::OK != getFeature(outputTE, muons) ) {
- ATH_MSG_WARNING("Could not get muons, cannot update the RoI");
- return HLT::OK;
- }
-
- // make new RoI
- TrigRoiDescriptor* newroi = createIDtrackRoI(*roi, *muons);
-
- // save it
- if(newroi!=0) {
- // monitor z position
- m_roiZ = newroi->zed();
- // attached to trigger element
- HLT::ErrorCode hltStatus = attachFeature(outputTE, newroi, m_outputRoiName);
- if(hltStatus!=HLT::OK) {
- msg() << MSG::WARNING << "Attaching roi " << newroi << " with name " << m_outputRoiName << " to TEout: unsuccessful" << endmsg;
- delete newroi;
- } else {
- msg() << MSG::DEBUG << "Attached roi " << newroi << " with name forID2" << endmsg;
- }
-
- }//valid roi
-
- return HLT::OK;
-
-}//hltExecute
-
-/**
- * Create a new RoI using the parameters of the old one, updating the z and zWidth
- *
- * @return the new RoiDescriptor, returns 0 in case it could not be created (e.g. no muons with ID tracks)
- */
-TrigRoiDescriptor* TrigMuonEFIDTrackRoiMaker::createIDtrackRoI(const TrigRoiDescriptor& roi, const xAOD::MuonContainer& muons) {
-
- // loop on muons to find the z values & store eta, phi of muon
- std::vector<double> z0values;
- for( auto muon : muons ) {
- ElementLink<xAOD::TrackParticleContainer> idTrackLink = muon->inDetTrackParticleLink();
- if(!idTrackLink.isValid()) continue;
- const Trk::Perigee* idtrk_perigee = &((*idTrackLink)->perigeeParameters());
- if(!idtrk_perigee) {
- ATH_MSG_WARNING("ID track with no Perigee, skip");
- continue;
- }
-
- // monitor how far our muons are from the RoI center
- m_deltaEta.push_back( fabs((*idTrackLink)->eta() - roi.eta()) );
- m_deltaPhi.push_back( fabs(TVector2::Phi_mpi_pi((*idTrackLink)->phi() - roi.phi())) );
-
- const double z0 = idtrk_perigee->parameters()[Trk::z0];
- z0values.push_back( z0 );
- if(msgLvl(MSG::DEBUG) && idtrk_perigee->covariance()) {
- ATH_MSG_DEBUG("z0 = " << z0 << " +- " << sqrt((*(idtrk_perigee->covariance()))(Trk::z0, Trk::z0)) );
- }
- }// muon loop
-
- // if no muons, then nothing to do
- if(z0values.size()==0 ) {
- if(!muons.empty()) ATH_MSG_WARNING("No valid z0 found, will not create new RoI, old RoI has zWidth = " << roi.zedPlus() - roi.zedMinus());
- else ATH_MSG_WARNING("Zero muons, so cannot create new RoI");
-
- return 0;
- }
-
- // 1 muon, use central z0 with the fixed width
- double zCentral=z0values[0];
- double zMinus = zCentral-m_roiSizeZ0;
- double zPlus = zCentral+m_roiSizeZ0;
-
- if(z0values.size()>1) {
- //multiple muons, first sort z values so they are low -> high
- std::sort(z0values.begin(), z0values.end());
- // our z low is lowest z - width, z high is highest z + width
- zMinus = z0values[0] - m_roiSizeZ0;
- zPlus = z0values.back() + m_roiSizeZ0;
- // center RoI in the middle of the muons
- zCentral = (z0values[0] + z0values.back()) / 2.0;
- }
-
- // make new RoI
- ATH_MSG_DEBUG("Create RoI at eta=" << roi.eta() << " phi=" << roi.phi() << " z=" << zCentral << " in range " << zMinus << " -> " << zPlus);
- TrigRoiDescriptor* newroi = new TrigRoiDescriptor(roi.roiWord(), roi.l1Id(), roi.roiId(), roi.eta(), roi.etaMinus(), roi.etaPlus(), roi.phi(), roi.phiMinus(), roi.phiPlus(), zCentral, zMinus, zPlus);
-
- return newroi;
-}// createIDtrackRoI
diff --git a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFIDTrackRoiMaker.h b/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFIDTrackRoiMaker.h
deleted file mode 100644
index 801efeab73b3c11a98c3fd7f8c5926d6d9d7fff9..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFIDTrackRoiMaker.h
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
-*/
-#ifndef TRIGMUONEF_TRIGMUONIDTRACKROIMAKER_H__
-#define TRIGMUONEF_TRIGMUONIDTRACKROIMAKER_H__
-
-// ************************************************
-//
-// NAME: TrigMuonEFIDTrackRoiMaker.h
-// PACKAGE: Trigger/TrigAlgorithms/TrigMuonEF
-//
-// AUTHOR: Mark Owen
-// EMAIL: markowen AT cern.ch
-//
-// ************************************************
-
-#include "TrigInterfaces/FexAlgo.h"
-#include <string>
-
-// edm classes
-#include "xAODMuon/MuonContainer.h"
-
-// fwd declare TrigRoiDescriptor class
-class TrigRoiDescriptor;
-
-/**
- * @brief Algorithm to create RoIs from muon ID tracks.
- *
- * Class to make ROIs from the ID tracks of xAOD::Muons
- * Class takes the previous RoI and creates a new one
- * centred on the muon z0, with a configurable width.
- *
- * @author Mark Owen <markowen@cern.ch>
- */
-class TrigMuonEFIDTrackRoiMaker : public virtual HLT::FexAlgo
-{
- public:
-
- /// Constructor
- TrigMuonEFIDTrackRoiMaker(const std::string & name, ISvcLocator* pSvcLocator);
-
- /// Destructor
- ~TrigMuonEFIDTrackRoiMaker();
-
- /// Initialize
- HLT::ErrorCode hltInitialize();
-
- /// Execute for each RoI
- HLT::ErrorCode hltExecute(const HLT::TriggerElement* inputTE, HLT::TriggerElement* outputTE);
-
- /// Finalize
- HLT::ErrorCode hltFinalize();
-
- protected:
-
- /// Function to create new RoI based on the muons
- TrigRoiDescriptor* createIDtrackRoI(const TrigRoiDescriptor& roi, const xAOD::MuonContainer& muons) ;
-
- /// ROI size in z0
- float m_roiSizeZ0;
-
- /// input RoI name
- std::string m_inputRoiName;
-
- /// output RoI name
- std::string m_outputRoiName;
-
- /// monitor the z position of the RoIs we make
- float m_roiZ;
-
- std::vector<float> m_deltaEta;
- std::vector<float> m_deltaPhi;
-
-}; // class TrigMuonEFIDTrackRoiMaker
-
-#endif //TRIGMUONEF_TRIGMUONIDTRACKROIMAKER_H__
diff --git a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFRoiAggregator.cxx b/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFRoiAggregator.cxx
deleted file mode 100644
index ac0fb1a4f7df68c7d88a64b1a2d154c30bca5171..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFRoiAggregator.cxx
+++ /dev/null
@@ -1,174 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-#include <cstdlib>
-#include <cmath>
-#include <algorithm>
-
-#include "TrigMuonEFRoiAggregator.h"
-
-#include "TrigNavigation/TriggerElement.h"
-#include "TrigConfHLTData/HLTTriggerElement.h"
-#include "xAODMuon/MuonContainer.h"
-#include "xAODMuon/MuonAuxContainer.h"
-#include "xAODMuon/Muon.h"
-
-#include "xAODTracking/TrackParticleContainer.h"
-#include "xAODTracking/TrackParticle.h"
-
-/**
- * Constructor - set up the algorithm
- */
-TrigMuonEFRoiAggregator::TrigMuonEFRoiAggregator(const std::string & name, ISvcLocator* pSvcLocator) :
- HLT::AllTEAlgo(name, pSvcLocator)
-{
- declareMonitoredVariable("nRoiIn", m_nRoiIn, IMonitoredAlgo::AutoClear);
- declareMonitoredVariable("nTrkIn", m_nTrkIn, IMonitoredAlgo::AutoClear);
- declareProperty("CopyTracks", m_copyTracks=false);
- m_PtLo=0;
- m_PtHi=0;
-}
-
-/**
- * Destructor - clean up when done
- */
-TrigMuonEFRoiAggregator::~TrigMuonEFRoiAggregator() {
-
-}
-
-/**
- * Initialize the algorithm
- */
-HLT::ErrorCode TrigMuonEFRoiAggregator::hltInitialize() {
-
- return HLT::OK;
-}//hltInitialize
-
-/**
- * Finalize the algorithm
- */
-HLT::ErrorCode TrigMuonEFRoiAggregator::hltFinalize() {
-
- return HLT::OK;
-}//hltFinalize
-
-HLT::ErrorCode TrigMuonEFRoiAggregator::hltExecute(std::vector< std::vector<HLT::TriggerElement*> >& inputTEtypes, unsigned int output) {
-
- // init monitor variables "by hand" because this is an allTE algo
- beforeExecMonitors().ignore();
-
- // we run after FS instance - so should only be one inputTE
- if (inputTEtypes.size() != 1) {
- ATH_MSG_WARNING("Got more than one inputTE collections");
- return HLT::ErrorCode(HLT::Action::ABORT_CHAIN, HLT::Reason::MISSING_FEATURE);
- }
-
- std::vector<HLT::TriggerElement*>& inputTEs = inputTEtypes.at(0);
- ATH_MSG_DEBUG( "Number of input TEs: " << inputTEs.size() );
-
- std::vector<HLT::TriggerElement*>::iterator itTE = inputTEs.begin();
-
- // would be better to use a view container or ConstDataVector
- // here to avoid the deep copy - but need to figure out how to
- // put this to the navigation
- xAOD::MuonContainer* outMuons = new xAOD::MuonContainer();
- xAOD::MuonAuxContainer muonAux;
- outMuons->setStore( &muonAux );
-
- xAOD::TrackParticleContainer* outTP = new xAOD::TrackParticleContainer();
- xAOD::TrackParticleAuxContainer tpAux;
- outTP->setStore( &tpAux );
-
- m_nRoiIn = inputTEs.size();
- m_nTrkIn = 0;
-
- // loop over all ROIs (aka TEs)
- for ( ; itTE != inputTEs.end(); ++itTE ) {
- HLT::TriggerElement* inputTE = *itTE;
- // Some debug output:
- std::string label;
- TrigConf::HLTTriggerElement::getLabel (inputTE->getId(), label );
- ATH_MSG_DEBUG( "inputTE: \"" << label << "\" with ID " << inputTE->getId() );
-
- // Get xAOD Muon container linked to input TE
- const xAOD::MuonContainer* inputMuonCont=0;
- const xAOD::TrackParticleContainer* inputTPCont=0;
- if(getFeature(inputTE, inputMuonCont)!=HLT::OK || !inputMuonCont) {
- ATH_MSG_DEBUG("no MuonContainer Feature found in TE " << inputTE->getId() );
- return HLT::MISSING_FEATURE;
- }
-
- if (m_copyTracks && getFeature(inputTE, inputTPCont, "MuonEFInfo_CaloTagTrackParticles") != HLT::OK) {
- ATH_MSG_DEBUG("no MuonContainer Feature found in TE " << inputTE->getId() );
- return HLT::MISSING_FEATURE;
- }
-
-
-
- // loop on the muons within the RoI
- ATH_MSG_DEBUG( "MuonContainer found with size " << inputMuonCont->size() );
- for(auto muon : *inputMuonCont) {
- ATH_MSG_DEBUG( "Looking at next muon, primaryTrackPartile = " << muon->primaryTrackParticle());
- ++m_nTrkIn;
- // deep copy the muon
- xAOD::Muon* muoncopy = new xAOD::Muon();
- outMuons->push_back( muoncopy );
- *muoncopy = *muon;
- } // loop over muons within the RoI
-
- ATH_MSG_DEBUG("CopyTracks:" << m_copyTracks << " TPCont: " << inputTPCont);
-
- if (m_copyTracks && inputTPCont) {
- ATH_MSG_DEBUG( "TrackParticleContainer found with size " << inputTPCont->size() );
- for (auto tp : * inputTPCont) {
- ATH_MSG_DEBUG( "Looking at next TP" );
- xAOD::TrackParticle* tpcopy = new xAOD::TrackParticle();
- outTP->push_back( tpcopy );
- *tpcopy = *tp;
- }
- }
-
- } //loop over inputTEs
-
- // make output TE
- HLT::TriggerElement* outputTE = addRoI(output);
-
- if ( outMuons->size() > 0 ) {
- outputTE->setActiveState(true);
- HLT::ErrorCode hltStatus = attachFeature(outputTE, outMuons, "MuonEFInfo");
- if( hltStatus != HLT::OK ) {
- std::string label;
- TrigConf::HLTTriggerElement::getLabel( outputTE->getId(), label );
- ATH_MSG_WARNING( "Failed to attach output muons to output TE \"" << label << "\" ID=" << outputTE->getId() );
- delete outMuons;
- if(outTP) delete outTP;
- return hltStatus;
- }
- ATH_MSG_DEBUG( "attached muon container with size: " << outMuons->size() );
- } else {
- outputTE->setActiveState(false);
- delete outMuons;
- outMuons = 0;
- }
-
- if ( m_copyTracks){
- if( outTP->size() > 0 ) {
- outputTE->setActiveState(true);
- HLT::ErrorCode hltStatus = attachFeature(outputTE, outTP, "MuonEFInfo_CaloTagTrackParticles");
- if ( hltStatus != HLT::OK ) {
- std::string label;
- TrigConf::HLTTriggerElement::getLabel( outputTE->getId(), label );
- ATH_MSG_WARNING( "Failed to attach output track particles to output TE \"" << label << "\" ID=" << outputTE->getId() );
- delete outTP;
- return hltStatus;
- }
- ATH_MSG_DEBUG( "Attached track particle container with size: " << outTP->size() );
- }
- }
- if(outTP) delete outTP;
- // fill monitor variables "by hand" because this is an allTE algo
- afterExecMonitors().ignore();
-
- return HLT::OK;
-}//hltExecute
diff --git a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFRoiAggregator.h b/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFRoiAggregator.h
deleted file mode 100644
index 886d88b75553d1a0ce297ab33866dd08764cb863..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFRoiAggregator.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-#ifndef TRIGMUONEF_TRIGMUONEFROIAGGREGATOR_H__
-#define TRIGMUONEF_TRIGMUONEFROIAGGREGATOR_H__
-
-// ************************************************
-//
-// NAME: TrigMuonEFRoiAggregator.h
-// PACKAGE: Trigger/TrigAlgorithms/TrigMuonEF
-//
-// AUTHORS: Alex Oh, Martin Woudstra, Mark Owen.
-//
-// ************************************************
-
-#include "TrigInterfaces/AllTEAlgo.h"
-#include "TrigInDetEvent/TrigInDetTrack.h"
-
-class TrigMuonEFRoiAggregator : public HLT::AllTEAlgo {
-
- public:
-
- /// Constructor
- TrigMuonEFRoiAggregator(const std::string & name, ISvcLocator* pSvcLocator);
-
- /// Destructor
- ~TrigMuonEFRoiAggregator();
-
- /// Initialize
- HLT::ErrorCode hltInitialize();
-
- /// Execute for each event
- HLT::ErrorCode hltExecute(std::vector<std::vector<HLT::TriggerElement*> >&,unsigned int);
-
- /// Finalize
- HLT::ErrorCode hltFinalize();
-
- protected:
-
- //
- // JobOptions Properties
- //
- /** Min Pt for muon 1 */
- double m_PtLo;
- /** Min Pt for muon 2 */
- double m_PtHi;
- /** Option to also copy trackparticles */
- bool m_copyTracks;
-
- //
- // Monitoring variables
- //
- int m_nRoiIn;
- int m_nTrkIn;
-
-};//class TrigMuonEFRoiAggregator
-
-
-#endif // TRIGMUONEF_TRIGMUONEFROIAGGREGATOR_H__
-
diff --git a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFRoiUtils.cxx b/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFRoiUtils.cxx
deleted file mode 100644
index 06bd9d2ff658079902f2bf3e24d873383586bddb..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFRoiUtils.cxx
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-#include "TrigMuonEFRoiUtils.h"
-
-#include "IRegionSelector/IRoiDescriptor.h"
-#include "TrigSteeringEvent/TrigRoiDescriptor.h"
-
-#include <iostream>
-
-using std::cout;
-using std::endl;
-
-/**
- * Take input RoI and create new TrigRoiDescriptor with fixed width.
- * This function is to migrate from old to new RegionSelection interface.
- * Eventually it should be removed and the algorithms should use dynamic widths
- * stored in the RoIs.
- */
-const IRoiDescriptor* createRoiDescriptor(const IRoiDescriptor* inmuonRoI, const double etaWidth, const double phiWidth, bool debug) {
-
- TrigRoiDescriptor* newRoI = 0;
- if (inmuonRoI) {
-
- const double eta = inmuonRoI->eta();
- const double phi = inmuonRoI->phi();
-
- double minphi = phi - phiWidth;
- if(minphi < -M_PI) minphi = 2.0*M_PI + minphi;
- double maxphi = phi + phiWidth;
- if(maxphi > M_PI) maxphi = maxphi - 2.0*M_PI;
- newRoI = new TrigRoiDescriptor(eta, eta - etaWidth, eta + etaWidth, phi, minphi, maxphi);
-
- if(debug) {
- cout << "createRoiDescriptor: input Roi eta, phi = " << eta << ", " << phi << endl;
- cout << "createRoiDescriptor: etaWidth, phiWidth = " << etaWidth << ", " << phiWidth << endl;
- cout << "createRoiDescriptor: etaRange = " << eta - etaWidth << " -> " << eta + etaWidth << endl;
- cout << "createRoiDescriptor: phiRange = " << minphi << " -> " << maxphi << endl;
- } // debug
-
- } else { // assume we are in full scan mode
-
- if(debug) {
- cout << "createRoiDescriptor: 0 input, will create 'full scan' RoI" << endl;
- }
-
- newRoI = new TrigRoiDescriptor(true);
- }
- return newRoI;
-}
diff --git a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFRoiUtils.h b/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFRoiUtils.h
deleted file mode 100644
index f0041ccf4424d50f857a7157b1c26b591b16dca5..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFRoiUtils.h
+++ /dev/null
@@ -1,14 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-#ifndef TRIGMUONEFROIUTILS_H__
-#define TRIGMUONEFROIUTILS_H__
-
-// fwd declare IRoiDescriptor class
-class IRoiDescriptor;
-
-/// Utility function that takes input ROI descriptor and makes a new one with the specified range.
-const IRoiDescriptor* createRoiDescriptor(const IRoiDescriptor* inmuonRoI, const double etaWidth, const double phiWidth, bool debug=false);
-
-#endif //TRIGMUONEFROIUTILS_H__
diff --git a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFStandaloneTrackTool.cxx b/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFStandaloneTrackTool.cxx
deleted file mode 100644
index db09de354a4a11e3f7984abd215b15f856bdd766..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFStandaloneTrackTool.cxx
+++ /dev/null
@@ -1,2594 +0,0 @@
-/*
- Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-*/
-
-#include <algorithm> // for find
-#include "TrigMuonEFStandaloneTrackTool.h"
-
-#include "StoreGate/ActiveStoreSvc.h"
-
-#include "GaudiKernel/IIncidentSvc.h"
-#include "AthenaKernel/Timeout.h"
-
-#include "TrigConfHLTData/HLTTriggerElement.h"
-
-#include "MuonSegmentCombinerToolInterfaces/IMooSegmentCombinationFinder.h"
-#include "MuonRecToolInterfaces/IMuonPatternSegmentAssociationTool.h"
-#include "TrkToolInterfaces/ITrackSummaryTool.h"
-#include "TrkTrack/Track.h"
-#include "TrkTrackSummary/TrackSummary.h"
-#include "TrkParameters/TrackParameters.h"
-
-#include "TrkEventPrimitives/FitQuality.h"
-#include "MuonSegment/MuonSegment.h"
-
-#include "IRegionSelector/IRegSelSvc.h"
-#include "IRegionSelector/IRoiDescriptor.h"
-
-#include "MuonPrepRawData/MuonPrepDataContainer.h"
-#include "MuonRIO_OnTrack/MdtDriftCircleOnTrack.h"
-
-#include "MuonReadoutGeometry/MuonDetectorManager.h"
-#include "MuonCnvToolInterfaces/IMuonRawDataProviderTool.h"
-#include "MuonCnvToolInterfaces/IMuonRdoToPrepDataTool.h"
-#include "CscClusterization/ICscClusterBuilder.h"
-
-#include "MuidInterfaces/IMuidBackTracker.h"
-
-#include "TrigMuonToolInterfaces/TrigMuonEFMonVars.h"
-
-#include "TrigNavigation/TriggerElement.h"
-
-#include "TrigTimeAlgs/TrigTimerSvc.h"
-#include "TrigTimeAlgs/TrigTimer.h"
-
-#include "TrigInterfaces/Algo.h"
-#include "TrigInterfaces/FexAlgo.h"
-#include "TrigInterfaces/IMonitoredAlgo.h" // for AutoClear
-#include "AthContainers/ConstDataVector.h"
-
-// xAOD related includes
-#include "MuonCombinedEvent/MuonCandidate.h"
-#include "MuonCombinedToolInterfaces/IMuonCandidateTool.h"
-#include "TrkToolInterfaces/ITrackParticleCreatorTool.h"
-#include "xAODTracking/Vertex.h"
-#include "xAODTracking/VertexAuxContainer.h"
-#include "xAODTracking/TrackParticleAuxContainer.h"
-
-#include "CLHEP/GenericFunctions/CumulativeChiSquare.hh"
-#include <fstream>
-
-#include "TrigMuonEFUtils.icc"
-
-ATLAS_NO_CHECK_FILE_THREAD_SAFETY; // legacy trigger code
-
-#if DEBUG_ROI_VS_FULL
-#include <set> //used in the method sanity_check
-#endif
-
-#define testRoiDrivenMode false
-
-using namespace std;
-using namespace Muon;
-using CLHEP::GeV;
-
-//________________________________________________________________________
-TrigMuonEFStandaloneTrackTool::TrigMuonEFStandaloneTrackTool(const std::string& type,
- const std::string& name,
- const IInterface* parent)
- : AthAlgTool(type,name,parent),
- m_regionSelector("RegSelSvc",name),
- m_segmentsFinderTool("Muon::MooSegmentCombinationFinder/TMEF_SegmentFinder",this),
- m_assocTool("Muon::MuonPatternSegmentAssociationTool/MuonPatternSegmentAssociationTool"),
- m_trackBuilderTool("Muon::MuonTrackSteering/TMEF_TracksBuilderTool",this),
- m_trackSummaryTool("Trk::TrackSummaryTool/MuidTrackSummaryTool"),
- m_mdtRawDataProvider("Muon::MDT_RawDataProviderTool/MDT_RawDataProviderTool"),
- m_rpcRawDataProvider("Muon::RPC_RawDataProviderTool/RPC_RawDataProviderTool"),
- m_tgcRawDataProvider("Muon::TGC_RawDataProviderTool/TGC_RawDataProviderTool"),
- m_cscRawDataProvider("Muon::CSC_RawDataProviderTool/CSC_RawDataProviderTool"),
- m_cscPrepDataProvider("Muon::CscRdoToCscPrepDataTool/CscPrepDataProviderTool"),
- m_mdtPrepDataProvider("Muon::MdtRdoToPrepDataTool/MdtPrepDataProviderTool"),
- m_rpcPrepDataProvider("Muon::RpcRdoToPrepDataTool/RpcPrepDataProviderTool"),
- m_tgcPrepDataProvider("Muon::TgcRdoToPrepDataTool/TgcPrepDataProviderTool"),
- m_cscClusterProvider(""),
- p_ActiveStore(0),
- m_firstEvent(true),
- m_useCscData(true),
- m_useRpcData(true),
- m_useTgcData(true),
- m_useTGCInPriorNextBC(false),
- m_useMdtData(1), //0=NO, 1=ALL(default), 2=BarrelOnly, 3=EndCapsOnly
- m_useMdtSeededDecoding(false),
- m_useRpcSeededDecoding(false),
- m_useTgcSeededDecoding(false),
- m_useCscSeededDecoding(false),
- m_useTgcRobDecoding(false),
- m_useCscRobDecoding(false),
- m_doTimeOutChecks(false),
- m_doTimeOutGuard(false),
- m_useL2Hits(false),
- m_maxCscHits(0),
- m_maxMdtHits(0),
- m_maxRpcHits(0),
- m_maxTgcHits(0),
- m_patternCombiColl(0),
- m_segments(0),
- m_spectrometerTracks(0),
- m_patternCombiCollInternal(0),
- m_segmentsInternal(0),
- m_spectrometerTracksInternal(0),
- m_extrapolatedTracks(0),
- m_spectrometerTrackParticles(0),
- m_spectrometerTrackParticlesAux(0),
- m_roi_num_seg(0),
- m_roi_num_mstrk(0),
- m_roi_num_satrk(0),
- m_totalSegmentCalls(0),
- m_cachedSegmentCalls(0),
- m_totalSpectrometerCalls(0),
- m_cachedSpectrometerCalls(0),
- m_totalExtrapolatedCalls(0),
- m_cachedExtrapolatedCalls(0),
- m_muonCandidateTool("MuonCandidateTool/MuonCandidateTool"),
- m_TrackToTrackParticleConvTool("MuonParticleCreatorTool"),
- m_rpcKey("RPC_Measurements"),
- m_tgcKey("TGC_Measurements"),
- m_tgcKeyNextBC("TGC_MeasurementsNextBC"),
- m_mdtKey("MDT_DriftCircles"),
- m_ignoreCSC(true),
- m_segmentOverlapRemovalTool("Muon::MuonSegmentOverlapRemovalTool/MuonSegmentOverlapRemovalTool")
-{
- m_hashlist.reserve(4);
-
- declareInterface<ITrigMuonStandaloneTrackTool>(this);
-
- declareProperty("RegionSelectionSvc", m_regionSelector);
- declareProperty("SegmentsFinderTool", m_segmentsFinderTool);
- declareProperty("AssociationTool", m_assocTool);
- declareProperty("TrackBuilderTool", m_trackBuilderTool);
- declareProperty("TrkSummaryTool", m_trackSummaryTool);
- declareProperty("MuonCandidateTool", m_muonCandidateTool);
- declareProperty("TrackToTrackParticleConvTool", m_TrackToTrackParticleConvTool);
-
- declareProperty ("MdtRawDataProvider",m_mdtRawDataProvider);
- declareProperty ("RpcRawDataProvider",m_rpcRawDataProvider);
- declareProperty ("TgcRawDataProvider",m_tgcRawDataProvider);
- declareProperty ("CscRawDataProvider",m_cscRawDataProvider);
-
- declareProperty("CscPrepDataProvider", m_cscPrepDataProvider);
- declareProperty("MdtPrepDataProvider", m_mdtPrepDataProvider);
- declareProperty("RpcPrepDataProvider", m_rpcPrepDataProvider);
- declareProperty("TgcPrepDataProvider", m_tgcPrepDataProvider);
- declareProperty("CscClusterProvider", m_cscClusterProvider);
-
- declareProperty("doCache", m_doCache=true);
-
- declareProperty("useMdtData", m_useMdtData );
- declareProperty("useRpcData", m_useRpcData );
- declareProperty("useTgcData", m_useTgcData );
- declareProperty("useTGCInPriorNextBC", m_useTGCInPriorNextBC);
- declareProperty("useCscData", m_useCscData );
-
-
- declareProperty("useMdtSeededDecoding", m_useMdtSeededDecoding );
- declareProperty("useRpcSeededDecoding", m_useRpcSeededDecoding );
- declareProperty("useTgcSeededDecoding", m_useTgcSeededDecoding );
- declareProperty("useCscSeededDecoding", m_useCscSeededDecoding );
- declareProperty("useTgcRobDecoding", m_useTgcRobDecoding );
- declareProperty("useCscRobDecoding", m_useCscRobDecoding );
-
- declareProperty("doTimeOutChecks",m_doTimeOutChecks);
- declareProperty("doTimeOutGuard",m_doTimeOutGuard);
- declareProperty("useL2Hits", m_useL2Hits);
- declareProperty("maxTgcHits",m_maxTgcHits);
- declareProperty("maxCscHits",m_maxCscHits);
- declareProperty("maxRpcHits",m_maxRpcHits);
- declareProperty("maxMdtHits",m_maxMdtHits);
- declareProperty("RpcPrepDataContainer", m_rpcKey);
- declareProperty("TgcPrepDataContainer", m_tgcKey);
- declareProperty("TgcPrepDataContainerNextBC", m_tgcKeyNextBC);
- declareProperty("MdtPrepDataContainer", m_mdtKey);
- declareProperty("IgnoreMisalginedCSCs", m_ignoreCSC);
-
- declareProperty("SegmentOverlapRemovalTool", m_segmentOverlapRemovalTool, "tool to removal overlaps in segment combinations" );
-
- clearRoiCache();
-
-}
-
-//________________________________________________________________________
-TrigMuonEFStandaloneTrackTool::~TrigMuonEFStandaloneTrackTool()
-{
- // clean up any xAOD particles
- if( m_spectrometerTrackParticles ) delete m_spectrometerTrackParticles;
- if( m_spectrometerTrackParticlesAux ) delete m_spectrometerTrackParticlesAux;
-}
-
-//________________________________________________________________________
-StatusCode TrigMuonEFStandaloneTrackTool::initialize()
-{
-
-#if DEBUG_ROI_VS_FULL
- m_fileWithHashIds_rpc.open("HashID_rpc.txt");
- m_fileWithHashIds_tgc.open("HashID_tgc.txt");
- m_fileWithHashIds_mdt.open("HashID_mdt.txt");
- m_fileWithHashIds_csc.open("HashID_csc.txt");
-#endif
- //m_SFCache\TrigMap.clear();
- ATH_MSG_DEBUG("clearing SFCacheSCmap (initialize)");
- m_SFCacheSCMap.clear();
-
- if (msgLvl(MSG::DEBUG)) {
- msg() << MSG::DEBUG
- << "package version = " << PACKAGE_VERSION << endmsg;
- msg() << MSG::DEBUG
- << "Properties are set as follows: " << endmsg;
- msg() << MSG::DEBUG
- << "SegmentsFinderTool " << m_segmentsFinderTool << endmsg;
- msg() << MSG::DEBUG
- << "TrackBuilderTool " << m_trackBuilderTool << endmsg;
- msg() << MSG::DEBUG
- << "CscRawDataProvider " << m_cscRawDataProvider << endmsg;
- msg() << MSG::DEBUG
- << "MdtRawDataProvider " << m_mdtRawDataProvider << endmsg;
- msg() << MSG::DEBUG
- << "RpcRawDataProvider " << m_rpcRawDataProvider << endmsg;
- msg() << MSG::DEBUG
- << "TgcRawDataProvider " << m_tgcRawDataProvider << endmsg;
- msg() << MSG::DEBUG
- << "CscPrepDataProvider " << m_cscPrepDataProvider << endmsg;
- msg() << MSG::DEBUG
- << "MdtPrepDataProvider " << m_mdtPrepDataProvider << endmsg;
- msg() << MSG::DEBUG
- << "RpcPrepDataProvider " << m_rpcPrepDataProvider << endmsg;
- msg() << MSG::DEBUG
- << "TgcPrepDataProvider " << m_tgcPrepDataProvider << endmsg;
-
- msg() << MSG::DEBUG
- << "doCache " << m_doCache << endmsg;
-
- msg() << MSG::DEBUG
- << "useMdtData " << m_useMdtData << endmsg;
- msg() << MSG::DEBUG
- << "useRpcData " << m_useRpcData << endmsg;
- msg() << MSG::DEBUG
- << "useTgcData " << m_useTgcData << endmsg;
- msg() << MSG::DEBUG
- << "useTGCInPriorNextBC " << m_useTGCInPriorNextBC << endmsg;
- msg() << MSG::DEBUG
- << "useCscData " << m_useCscData << endmsg;
- msg() << MSG::DEBUG
- << "useMdtSeededDecoding " << m_useMdtSeededDecoding << endmsg;
- msg() << MSG::DEBUG
- << "useRpcSeededDecoding " << m_useRpcSeededDecoding << endmsg;
- msg() << MSG::DEBUG
- << "useTgcSeededDecoding " << m_useTgcSeededDecoding << endmsg;
- msg() << MSG::DEBUG
- << "useCscSeededDecoding " << m_useCscSeededDecoding << endmsg;
- msg() << MSG::DEBUG
- << "useTgcRobDecoding " << m_useTgcRobDecoding << endmsg;
- msg() << MSG::DEBUG
- << "useCscRobDecoding " << m_useCscRobDecoding << endmsg;
-
- msg() << MSG::DEBUG
- << m_decodeMdtBS.name() << " " << m_decodeMdtBS << endmsg;
- msg() << MSG::DEBUG
- << m_decodeRpcBS.name() << " " << m_decodeRpcBS << endmsg;
- msg() << MSG::DEBUG
- << m_decodeTgcBS.name() << " " << m_decodeTgcBS << endmsg;
- msg() << MSG::DEBUG
- << m_decodeCscBS.name() << " " << m_decodeCscBS << endmsg;
- msg() << MSG::DEBUG
- << "doTimeOutChecks " << m_doTimeOutChecks << endmsg;
- msg() << MSG::DEBUG
- << "doTimeOutGuard " << m_doTimeOutGuard << endmsg;
- msg() << MSG::DEBUG
- << "useL2Hits " << m_useL2Hits << endmsg;
-
- msg() << MSG::DEBUG
- << "maxRpcHits " << m_maxRpcHits << endmsg;
- msg() << MSG::DEBUG
- << "maxCscHits " << m_maxCscHits << endmsg;
- msg() << MSG::DEBUG
- << "maxMdtHits " << m_maxMdtHits << endmsg;
- msg() << MSG::DEBUG
- << "maxTgcHits " << m_maxTgcHits << endmsg;
- }
-
- // Get the region selector tool:
- if (m_regionSelector.retrieve().isFailure()) {
- msg() << MSG::FATAL
- << "Unable to retrieve RegionSelector Svc"
- << endmsg;
- return StatusCode::FAILURE;
- }
-
- // Retrieve ActiveStore
- StatusCode status = serviceLocator()->service("ActiveStoreSvc", p_ActiveStore);
- if(!status.isSuccess() || 0 == p_ActiveStore) {
- msg() << MSG::ERROR <<" Could not find ActiveStoreSvc " << endmsg;
- return StatusCode::FAILURE;
- }
-
- // Retrieve MDT raw data provider tool if needed
- if (m_mdtRawDataProvider.retrieve(DisableTool{ !m_decodeMdtBS }).isSuccess()) {
- msg (MSG::INFO) << "Retrieved " << m_mdtRawDataProvider << endmsg;
- }
- else {
- msg (MSG::FATAL) << "Could not get " << m_mdtRawDataProvider << endmsg;
- return StatusCode::FAILURE;
- }
-
- // Retrieve RPC raw data provider tool if needed
- if (m_rpcRawDataProvider.retrieve(DisableTool{ !m_decodeRpcBS }).isSuccess()) {
- msg (MSG::INFO) << "Retrieved " << m_rpcRawDataProvider << endmsg;
- }
- else {
- msg (MSG::FATAL) << "Could not get " << m_rpcRawDataProvider << endmsg;
- return StatusCode::FAILURE;
- }
-
- // Retrieve TGC raw data provider tool if needed
- if (m_tgcRawDataProvider.retrieve(DisableTool{ !m_decodeTgcBS }).isSuccess()) {
- msg (MSG::INFO) << "Retrieved " << m_tgcRawDataProvider << endmsg;
- }
- else {
- msg (MSG::FATAL) << "Could not get " << m_tgcRawDataProvider << endmsg;
- return StatusCode::FAILURE;
- }
-
- // Retrieve CSC raw data provider tool if needed
- if (m_cscRawDataProvider.retrieve(DisableTool{ !m_decodeCscBS }).isSuccess()) {
- msg (MSG::INFO) << "Retrieved " << m_cscRawDataProvider << endmsg;
- }
- else {
- msg (MSG::FATAL) << "Could not get " << m_cscRawDataProvider << endmsg;
- return StatusCode::FAILURE;
- }
-
- // Retrieve segment maker tool
- status = m_segmentsFinderTool.retrieve();
- if (status.isSuccess()){
- msg() << MSG::INFO << "Retrieved " << m_segmentsFinderTool << endmsg;
- } else {
- msg() << MSG::FATAL << "Could not get " << m_segmentsFinderTool << endmsg;
- return StatusCode::FAILURE;
- }
-
-
- status = m_assocTool.retrieve();
- if (status.isSuccess()){
- msg() << MSG::INFO << "Retrieved " << m_assocTool << endmsg;
- }else{
- msg() << MSG::FATAL << "Could not get " << m_assocTool <<endmsg;
- return StatusCode::FAILURE;
- }
-
- status = m_trackBuilderTool.retrieve();
- if (status.isSuccess()){
- ATH_MSG_INFO("Retrieved " << m_trackBuilderTool);
- }
- else{
- ATH_MSG_FATAL("Could not get " << m_trackBuilderTool);
- return StatusCode::FAILURE;
- }
-
- // Retrieve track summary tool
- if (m_trackSummaryTool.retrieve().isSuccess()){
- ATH_MSG_INFO("Retrieved " << m_trackSummaryTool);
- }
- else{
- ATH_MSG_FATAL("Could not get " << m_trackSummaryTool);
- return StatusCode::FAILURE;
- }
-
-
-
-
- if (m_useCscData) {
-
- status = m_cscPrepDataProvider.retrieve();
- if (status.isSuccess()) {
- msg() << MSG::INFO << "Retrieved " << m_cscPrepDataProvider << endmsg;
- } else {
- msg() << MSG::FATAL << "Could not get " << m_cscPrepDataProvider << endmsg;
- return StatusCode::FAILURE;
- }
- // clusterization tool
- status = m_cscClusterProvider.retrieve();
- if (status.isSuccess()) {
- msg() << MSG::INFO << "Retrieved " << m_cscClusterProvider << endmsg;
- } else {
- msg() << MSG::FATAL << "Could not get " << m_cscClusterProvider << endmsg;
- return StatusCode::FAILURE;
- }
- }
- if (m_useMdtData) {
- status = m_mdtPrepDataProvider.retrieve();
- if (status.isSuccess()) {
- msg() << MSG::INFO << "Retrieved " << m_mdtPrepDataProvider << endmsg;
- } else {
- msg() << MSG::FATAL << "Could not get " << m_mdtPrepDataProvider << endmsg;
- return StatusCode::FAILURE;
- }
- }
- if (m_useRpcData) {
- status = m_rpcPrepDataProvider.retrieve();
- if (status.isSuccess()) {
- msg() << MSG::INFO << "Retrieved " << m_rpcPrepDataProvider << endmsg;
- } else {
- msg() << MSG::FATAL << "Could not get " << m_rpcPrepDataProvider << endmsg;
- return StatusCode::FAILURE;
- }
- }
- if (m_useTgcData) {
- status = m_tgcPrepDataProvider.retrieve();
- if (status.isSuccess()) {
- msg() << MSG::INFO << "Retrieved " << m_tgcPrepDataProvider << endmsg;
- } else {
- msg() << MSG::FATAL << "Could not get " << m_tgcPrepDataProvider << endmsg;
- return StatusCode::FAILURE;
- }
- }
-
- // retrive muon candidate tool
- status = m_muonCandidateTool.retrieve();
- if (status.isSuccess()){
- ATH_MSG_INFO("Retrieved " << m_muonCandidateTool);
- }
- else{
- ATH_MSG_FATAL("Could not get " << m_muonCandidateTool);
- return StatusCode::FAILURE;
- }
-
- // retrive track particle creator tool
- status = m_TrackToTrackParticleConvTool.retrieve();
- if (status.isSuccess()){
- ATH_MSG_INFO("Retrieved " << m_TrackToTrackParticleConvTool);
- }
- else{
- ATH_MSG_FATAL("Could not get " << m_TrackToTrackParticleConvTool);
- return StatusCode::FAILURE;
- }
-
- ATH_CHECK( m_idHelperSvc.retrieve() );
-
- // register EndEvent incident
- IIncidentSvc* pIncsvc;
- int priority = 100;
- if ( serviceLocator()->service("IncidentSvc", pIncsvc).isSuccess() ) {
- pIncsvc->addListener( this, "EndEvent", priority);
- } else {
- ATH_MSG_ERROR( "Could not register incident service " );
- return StatusCode::FAILURE;
- }
-
- ATH_MSG_DEBUG("End of init TrigMuonEFStandaloneTrackTool");
-
- //initialise for data handles
-
- if(!m_rpcKey.initialize()){
- ATH_MSG_ERROR("Couldn't initalize RPC ReadHandleKey");
- return StatusCode::FAILURE;
- }
- if(!m_tgcKey.initialize()){
- ATH_MSG_ERROR("Couldn't initalize TGC ReadHandleKey");
- return StatusCode::FAILURE;
- }
- if(!m_tgcKeyNextBC.initialize()){
- ATH_MSG_ERROR("Couldn't initalize TGCNextBC ReadHandleKey");
- return StatusCode::FAILURE;
- }
- if(!m_mdtKey.initialize()){
- ATH_MSG_ERROR("Couldn't initalize MDT ReadHandleKey");
- return StatusCode::FAILURE;
- }
- ATH_CHECK(m_cscClustersKey.initialize());
- //segment overlap removal
- ATH_CHECK( m_segmentOverlapRemovalTool.retrieve() );
- ATH_CHECK(m_mdtCablingKey.initialize());
-
- return StatusCode::SUCCESS;
-}
-
-//________________________________________________________________________
-StatusCode TrigMuonEFStandaloneTrackTool::finalize()
-{
- double segmentCacheFraction = getFraction(m_cachedSegmentCalls, m_totalSegmentCalls);
- double spectroCacheFraction = getFraction(m_cachedSpectrometerCalls, m_totalSpectrometerCalls);
- double extrapolCacheFraction = getFraction(m_cachedExtrapolatedCalls, m_totalExtrapolatedCalls);
-
- ATH_MSG_INFO("Segment making calls : " << m_totalSegmentCalls << ". Returned from cache: " << m_cachedSegmentCalls
- << ". Cached fraction: " << segmentCacheFraction );
- ATH_MSG_INFO("Spectrometer Track making calls: " << m_totalSpectrometerCalls << ". Returned from cache: " << m_cachedSpectrometerCalls
- << ". Cached fraction: " << spectroCacheFraction );
- ATH_MSG_INFO("Extrapolated Track making calls: " << m_totalExtrapolatedCalls << ". Returned from cache: " << m_cachedExtrapolatedCalls
- << ". Cached fraction: " << extrapolCacheFraction );
-
-#if DEBUG_ROI_VS_FULL
- m_fileWithHashIds_rpc.close();
- m_fileWithHashIds_tgc.close();
- m_fileWithHashIds_mdt.close();
- m_fileWithHashIds_csc.close();
-#endif
-
- return StatusCode::SUCCESS;
-}
-
-//________________________________________________________________________
-#if DEBUG_ROI_VS_FULL
-void TrigMuonEFStandaloneTrackTool::sanity_check(const std::vector<IdentifierHash>& input_hash_ids, const std::vector<IdentifierHash>& hash_ids_withData, std::ostream& outfile)
-{
-
- std::set<IdentifierHash> inputSet;
- std::set<IdentifierHash> outputSet;
- std::vector<IdentifierHash> inputDuplicates;
- std::vector<IdentifierHash> outputDuplicates;
- std::vector<IdentifierHash> inputUnmatched;
- std::vector<IdentifierHash> outputUnmatched;
-
- //print input and output hash IDs and check for duplicates or unmatched
- outfile << "requested hash IDs: ";
- for (auto it = input_hash_ids.begin(); it != input_hash_ids.end(); ++it) {//loop over requested hash IDs
- outfile << *it << " ";
- if (!inputSet.insert(*it).second) //check for duplicate
- inputDuplicates.push_back(*it);
- }
- outfile << "\n";
- outfile << "hash IDs with data: ";
- for (auto it = hash_ids_withData.begin(); it != hash_ids_withData.end(); ++it) {//loop over hash IDs with data
- outfile << *it << " ";
- if (!outputSet.insert(*it).second) //check for duplicate
- outputDuplicates.push_back(*it);
- if (inputSet.find(*it) == inputSet.end()) //check for mismatch
- outputUnmatched.push_back(*it);
- }
- outfile << "\n";
-
- for (auto it = input_hash_ids.begin(); it != input_hash_ids.end(); ++it) {//another loop over requested hash IDs
- if (outputSet.find(*it) == outputSet.end()) //check for mismatch
- inputUnmatched.push_back(*it);
- }
-
-
- //print duplicates if any
- if (inputDuplicates.size()) {
- outfile << "requested hID duplicates: ";
- for (auto it = inputDuplicates.begin(); it != inputDuplicates.end(); ++it)
- outfile << *it << " ";
- outfile << "\n";
- }
- if (outputDuplicates.size()) {
- outfile << "hID with data duplicates: ";
- for (auto it = outputDuplicates.begin(); it != outputDuplicates.end(); ++it)
- outfile << *it << " ";
- outfile << "\n";
- }
-
- //print unmatched IDs if any
- if (inputUnmatched.size()) {
- outfile << "requested hID unrecovered with data: ";
- for (auto it = inputUnmatched.begin(); it != inputUnmatched.end(); ++it)
- outfile << *it << " ";
- outfile << "\n";
- }
- if (outputUnmatched.size()) {
- outfile << "recovered but unrequested hID with data: ";
- for (auto it = outputUnmatched.begin(); it != outputUnmatched.end(); ++it)
- outfile << *it << " ";
- outfile << "\n";
- }
-
-}
-#endif
-
-//________________________________________________________________________
-void TrigMuonEFStandaloneTrackTool::unpackTimers( std::vector<TrigTimer*>& timers, unsigned int firstIndex,
- TrigTimer*& dataPrepTime, TrigTimer*& algTime, TrigTimer*& dataOutputTime )
-{
- dataPrepTime = 0;
- algTime = 0;
- dataOutputTime = 0;
- unsigned int index = firstIndex;
- if ( timers.size() > index ) {
- dataPrepTime = timers[index];
- ++index;
- if ( timers.size() > index ) {
- algTime = timers[index];
- ++index;
- if ( timers.size() > index ) {
- dataOutputTime = timers[index];
- }
- }
- }
-}
-
-
-//________________________________________________________________________
-HLT::ErrorCode
-TrigMuonEFStandaloneTrackTool::getSpectrometerTracks(const IRoiDescriptor* muonRoI,
- SegmentCache*& cache,
- TrigMuonEFMonVars& monVars,
- std::vector<TrigTimer*>& timers, const EventContext& ctx)
-{
- //
- // Segment finding
- //
- ATH_MSG_DEBUG("In getSpectrometerTracks, about to call findSegments");
- HLT::ErrorCode hltStatus = findSegments(muonRoI, cache, monVars.segs, timers, 0, ctx);
- if (hltStatus!=HLT::OK) {
- return hltStatus;
- }
-
-
- /// Making Object to cache pointers for segfinder: SC holds Pointers that are all deleted at end of event
- if( not m_segments ) {
- ATH_MSG_DEBUG( "No Muon Segments built. Check configuration! Stop here to process the RoI" );
- return HLT::MISSING_FEATURE;
- }
- //
- // build tracks
- //
- return buildTracks(m_segments, cache, monVars.MS, timers, 3);
-}
-
-
-//________________________________________________________________________
-HLT::ErrorCode TrigMuonEFStandaloneTrackTool::getExtrapolatedTracks(const IRoiDescriptor* muonRoI,
- MuonCandidateCollection& candidateCollection,
- TrackCollection& extrapolatedTracks,
- SegmentCache*& cache,
- TrigMuonEFMonVars& monVars,
- std::vector<TrigTimer*>& timers, const EventContext& ctx)
-{
-
- ATH_MSG_DEBUG("In getExtrapolatedTracks with cache");
- HLT::ErrorCode hltStatus = getSpectrometerTracks( muonRoI, cache, monVars, timers, ctx );
- // if fail to get trks from L2 hits, retry with all hits
- if(m_useL2Hits && (hltStatus==HLT::MISSING_FEATURE || !m_spectrometerTracks || m_spectrometerTracks->empty()) ){
- m_useL2Hits=false;
- hltStatus = getSpectrometerTracks( muonRoI, cache, monVars, timers, ctx );
- m_useL2Hits=true;
- }
- if (hltStatus!=HLT::OK && hltStatus!=HLT::MISSING_FEATURE) {
- ATH_MSG_DEBUG( "Failed to build spectrometerTracks" );
- return hltStatus;
- }
-
- if (hltStatus==HLT::MISSING_FEATURE || !m_spectrometerTracks || m_spectrometerTracks->empty()) {
- ATH_MSG_DEBUG( "No Muon Spectrometer track found: stop here to process the RoI." );
- return HLT::MISSING_FEATURE;
- } else {
- ATH_MSG_DEBUG( "Muon Spectrometer Track container retrieved with size : " << m_spectrometerTracks->size() );
- }
-
- //
- // extrapolation
- //
- hltStatus = extrapolate(m_spectrometerTrackParticles, candidateCollection, extrapolatedTracks, cache, monVars.SA, timers, 6);
- if (hltStatus!=HLT::OK && hltStatus !=HLT::MISSING_FEATURE) {
- ATH_MSG_DEBUG( "Failed to extrapolate spectrometer tracks to IP" );
- return hltStatus;
- }
-
- return hltStatus;
-}
-//_______________________________________________________________________
-void TrigMuonEFStandaloneTrackTool::clearRoiCache(){
-
- m_MdtRobList.clear();
- m_RpcRobList.clear();
- m_TgcRobList.clear();
- m_CscRobList.clear();
-
- m_HasMdtRobList = false;
- m_HasRpcRobList = false;
- m_HasTgcRobList = false;
- m_HasCscRobList = false;
-}
-//_______________________________________________________________________
-const std::vector<uint32_t>& TrigMuonEFStandaloneTrackTool::getMdtRobList( const IRoiDescriptor* muonRoI){
- if(!m_HasMdtRobList){
- m_HasMdtRobList = true;
- if(muonRoI){
- m_regionSelector->DetROBIDListUint(MDT,*muonRoI, m_MdtRobList);
- }
- else {
- m_regionSelector->DetROBIDListUint(MDT, m_MdtRobList);
- }
- }
- return m_MdtRobList;
-}
-//________________________________________________________________________
-const std::vector<uint32_t>& TrigMuonEFStandaloneTrackTool::getRpcRobList( const IRoiDescriptor* muonRoI){
- if(!m_HasRpcRobList){
- m_HasRpcRobList = true;
- if(muonRoI){
- m_regionSelector->DetROBIDListUint(RPC,*muonRoI,m_RpcRobList);
- }
- else{
- m_regionSelector->DetROBIDListUint(RPC,m_RpcRobList);
- }
- }
- return m_RpcRobList;
-}
-//________________________________________________________________________
-const std::vector<uint32_t>& TrigMuonEFStandaloneTrackTool::getTgcRobList( const IRoiDescriptor* muonRoI){
- if(!m_HasTgcRobList){
- m_HasTgcRobList = true;
- if(muonRoI){
- m_regionSelector->DetROBIDListUint(TGC,*muonRoI,m_TgcRobList);
- }
- else{
- m_regionSelector->DetROBIDListUint(TGC,m_TgcRobList);
- }
- }
- return m_TgcRobList;
-}
-//________________________________________________________________________
-const std::vector<uint32_t>& TrigMuonEFStandaloneTrackTool::getCscRobList( const IRoiDescriptor* muonRoI){
- if(!m_HasCscRobList){
- m_HasCscRobList = true;
- if(muonRoI){
- m_regionSelector->DetROBIDListUint(CSC,*muonRoI,m_CscRobList);
- }
- else{
- m_regionSelector->DetROBIDListUint(CSC,m_CscRobList);
- }
- }
- return m_CscRobList;
-}
-//________________________________________________________________________
-HLT::ErrorCode TrigMuonEFStandaloneTrackTool::findSegments(const IRoiDescriptor* muonRoI,
- SegmentCache*& cache,
- TrigMuonEFSegmentMonVars& monVars,
- std::vector<TrigTimer*>& timers,
- unsigned int firstTimerIndex, const EventContext& ctx )
-{
-#if DEBUG_ROI_VS_FULL
- m_fileWithHashIds_rpc << "\n#####\n\n";
- m_fileWithHashIds_mdt << "\n#####\n\n";
- m_fileWithHashIds_tgc << "\n#####\n\n";
- m_fileWithHashIds_csc << "\n#####\n\n";
-#endif
-
- ATH_MSG_DEBUG("in findSegments()");
-
- TrigTimer* dataPrepTime = 0;
- TrigTimer* segFinderTime = 0;
- TrigTimer* dataOutputTime = 0;
- unpackTimers( timers, firstTimerIndex, dataPrepTime, segFinderTime, dataOutputTime);
-
- if (dataPrepTime) dataPrepTime->start();
- const xAOD::L2StandAloneMuonContainer* l2cont=0;
- const xAOD::L2StandAloneMuon *l2muon = 0;
- std::string l2muonKey = "HLT_xAOD__L2StandAloneMuonContainer_MuonL2SAInfo";
- if(m_useL2Hits){
- if((*p_ActiveStore)->retrieve(l2cont, l2muonKey).isFailure()) {
- msg() << MSG::DEBUG << " Cannot retrieve L2 Muon Container " << l2muonKey <<" stop processing here"<< endmsg;
- } else msg()<< MSG::DEBUG << " L2 Muon Container retrieved with key " << l2muonKey << endmsg;
- }
- // reset cached pointers
- m_patternCombiColl=0;
- m_segments= 0;
- m_patternCombiCollInternal=0;
- m_segmentsInternal= 0;
- m_spectrometerTracks = 0;
- m_extrapolatedTracks = 0;
-
- ///// Vectors of prep data collections
- std::vector<const Muon::MdtPrepDataCollection*> mdtCols;
- std::vector<const Muon::MdtPrepDataCollection*> mdtCols2;
- std::vector<const Muon::CscPrepDataCollection*> cscCols;
- std::vector<const Muon::TgcPrepDataCollection*> tgcCols;
- std::vector<const Muon::RpcPrepDataCollection*> rpcCols;
-
- ++m_roi_num_seg;
-
- // These parameters are stored in the EDM.
- // For standard chains they are set from the input Roi.
- // However now we have full scan chains where we ask for a dummy TE.
- // For these cases we for now set etaRoI=phiRoI=0
-
-
- if (muonRoI) {
- monVars.phiL2CosmicMuon = muonRoI->phi();
- monVars.etaL2CosmicMuon = muonRoI->eta();
- }
-
- //
- // get PrepRawData
- //
- int nTgcHits = 0;
- int nMdtHits = 0;
- int nRpcHits = 0;
- int nCscHits = 0;
-
- bool mdtDataFound = true;
- bool cscDataFound = true;
-
- HLT::ErrorCode hltStatus = HLT::OK;
-
- std::vector<IdentifierHash> rpc_hash_ids;
- std::vector<IdentifierHash> rpc_hash_ids_cache;
-
- if (m_useRpcData) {
- if ( muonRoI ) m_regionSelector->DetHashIDList(RPC, *muonRoI, rpc_hash_ids);
- else m_regionSelector->DetHashIDList(RPC, rpc_hash_ids);
- }
-
-
- std::vector<IdentifierHash> tgc_hash_ids;
- std::vector<IdentifierHash> tgc_hash_ids_cache;
- if (m_useTgcData){
- if ( muonRoI ) m_regionSelector->DetHashIDList(TGC, *muonRoI, tgc_hash_ids);
- else m_regionSelector->DetHashIDList(TGC, tgc_hash_ids);
- }
-
-
- std::vector<IdentifierHash> temp_mdt_hash_ids;
- std::vector<IdentifierHash> mdt_hash_ids;
- std::vector<IdentifierHash> mdt_hash_ids_cache;
-if (m_useMdtData>0) {
- if ( muonRoI ) {
- m_regionSelector->DetHashIDList(MDT, *muonRoI, temp_mdt_hash_ids);
- }
- else {
- m_regionSelector->DetHashIDList(MDT, temp_mdt_hash_ids);
- }
-
-
- if (m_useMdtData >1) {
- for (std::vector<IdentifierHash>::const_iterator it=temp_mdt_hash_ids.begin();
- it!= temp_mdt_hash_ids.end(); ++it) {
- bool select = false;
- if (m_useMdtData == 2) {
- if ( (*it) < 638 || (*it) >1151 ) //barrel only: BIL to BOG + BIM
- select = true;
- } else if (m_useMdtData == 3) {
- if ( (*it) > 637 && (*it) <1152) //all endcap chambers
- select = true;
- }
- if (select) {
- mdt_hash_ids.push_back((*it));
- }
- }
- if (msgLvl(MSG::VERBOSE)) msg() << MSG::VERBOSE
- << "Size of the Mdt hash list " << temp_mdt_hash_ids.size()
- << " reset to " << mdt_hash_ids.size() << endmsg;
- } else {
-
- mdt_hash_ids = temp_mdt_hash_ids;
- }
- }
-
- std::vector<IdentifierHash> csc_hash_ids;
- std::vector<IdentifierHash> csc_hash_ids_cache;
- if (m_useCscData) {
- if ( muonRoI ) m_regionSelector->DetHashIDList(CSC, *muonRoI, csc_hash_ids);
- else m_regionSelector->DetHashIDList(CSC, csc_hash_ids);
- }
-
- if (msgLvl(MSG::DEBUG)) {
- msg()<< MSG::DEBUG << "The size of RPC hashId list is " << rpc_hash_ids.size() << endmsg;
- msg()<< MSG::DEBUG << "The size of TGC hashId list is " << tgc_hash_ids.size() << endmsg;
- msg()<< MSG::DEBUG << "The size of MDT hashId list is " << mdt_hash_ids.size() << endmsg;
- msg()<< MSG::DEBUG << "The size of CSC hashId list is " << csc_hash_ids.size() << endmsg;
- msg()<< MSG::DEBUG << "The size of mdt:rpc hashId list is " << mdt_hash_ids_cache.size() << " : "<< rpc_hash_ids_cache.size()<< endmsg;
- }
- else
- {
- if (testRoiDrivenMode)
- {
- msg()<< MSG::INFO << "The size of RPC hashId list is " << rpc_hash_ids.size() << endmsg;
- msg()<< MSG::INFO << "The size of TGC hashId list is " << tgc_hash_ids.size() << endmsg;
- msg()<< MSG::INFO << "The size of MDT hashId list is " << mdt_hash_ids.size() << endmsg;
- msg()<< MSG::INFO << "The size of CSC hashId list is " << csc_hash_ids.size() << endmsg;
- }
- }
-
-
- // perform the data decoding
-
- std::vector<IdentifierHash> hash_ids_withData;
-
- if (m_useRpcData && !rpc_hash_ids.empty()) {// RPC decoding
- if (m_useRpcSeededDecoding) {// seeded decoding of RPC
- if(m_decodeRpcBS) {// bytestream conversion
- if (m_rpcRawDataProvider->convert( getRpcRobList(muonRoI) ).isSuccess()) {
- ATH_MSG_DEBUG("RPC BS conversion for ROB-based seeded PRD decoding done successfully");
- } else {
- ATH_MSG_WARNING("RPC BS conversion for ROB-based seeded PRD decoding failed");
- }
- }
- if (m_rpcPrepDataProvider->decode( rpc_hash_ids, hash_ids_withData ).isSuccess()) {
- ATH_MSG_DEBUG("ROB-based seeded PRD decoding of RPC done successfully");
- } else {
- ATH_MSG_WARNING("ROB-based seeded PRD decoding of RPC failed");
- }
-
- }
- else {// full decoding of RPC
- if(m_decodeRpcBS) {// bytestream conversion
- if (m_rpcRawDataProvider->convert().isSuccess()) {
- ATH_MSG_DEBUG("RPC BS conversion for full decoding done successfully");
- } else {
- ATH_MSG_WARNING("RPC BS conversion for full decoding failed");
- }
- }
- std::vector<IdentifierHash> input_hash_ids;
- input_hash_ids.reserve(0);
- if(m_rpcPrepDataProvider->decode(input_hash_ids, hash_ids_withData).isSuccess()) {
- ATH_MSG_DEBUG("PRD-based full decoding of RPC done successfully");
-#if DEBUG_ROI_VS_FULL
- sanity_check(input_hash_ids, hash_ids_withData, m_fileWithHashIds_rpc);
-#endif
- } else {
- ATH_MSG_WARNING("PRD-based full decoding of RPC failed");
- }
-
- }
- }// end of RPC decoding
-
-
- if (m_useMdtData && !mdt_hash_ids.empty()) {// MDT decoding
- if (m_useMdtSeededDecoding) {// seeded decoding of MDT
- if(m_decodeMdtBS) {// bytestream conversion
- if (m_mdtRawDataProvider->convert( getMdtRobList(muonRoI) ).isSuccess()) {
- ATH_MSG_DEBUG("MDT BS conversion for ROB-based seeded PRD decoding done successfully");
- } else {
- ATH_MSG_WARNING("MDT BS conversion for ROB-based seeded PRD decoding failed");
- }
- }
- if (m_mdtPrepDataProvider->decode( getMdtRobList(muonRoI) ).isSuccess()) {
- ATH_MSG_DEBUG("ROB-based seeded decoding of MDT done successfully");
- SG::ReadCondHandle<MuonMDT_CablingMap> mdtCableHandle{m_mdtCablingKey, ctx};
- const MuonMDT_CablingMap* mdtCabling{*mdtCableHandle};
- if(!mdtCabling){
- ATH_MSG_ERROR("nullptr to the read mdt cabling conditions object");
- return HLT::NAV_ERROR;
- }
- mdt_hash_ids = mdtCabling->getChamberHashVec(m_MdtRobList);
- } else {
- ATH_MSG_WARNING("ROB-based seeded decoding of MDT failed");
- }
- } else {// full decoding of MDT
- if(m_decodeMdtBS) {// bytestream conversion
- if (m_mdtRawDataProvider->convert().isSuccess()) {
- ATH_MSG_DEBUG("MDT BS conversion for full decoding done successfully");
- } else {
- ATH_MSG_WARNING("MDT BS conversion for full decoding failed");
- }
- }
- std::vector<IdentifierHash> input_hash_ids;
- input_hash_ids.reserve(0);
- if(m_mdtPrepDataProvider->decode(input_hash_ids, hash_ids_withData).isSuccess()) {
- ATH_MSG_DEBUG("PRD-based full decoding of MDT done successfully");
-#if DEBUG_ROI_VS_FULL
- sanity_check(input_hash_ids, hash_ids_withData, m_fileWithHashIds_mdt);
-#endif
- } else {
- ATH_MSG_WARNING("PRD-based full decoding of MDT failed");
- }
-
- }
- }// end of MDT decoding
-
-
- if (m_useTgcData && !tgc_hash_ids.empty()) {// TGC decoding
- if (m_useTgcSeededDecoding) {// seeded decoding of TGC
- if (m_useTgcRobDecoding) {// ROB-based seeded decoding of TGC is neither available nor needed
- ATH_MSG_DEBUG("ROB-based seeded decoding of TGC requested, which is neither available nor needed. Calling the PRD-based seeded decoding.");
- }
- if (m_decodeTgcBS) {// bytesream conversion
- if (m_tgcRawDataProvider->convert( tgc_hash_ids ).isSuccess()) {
- ATH_MSG_DEBUG("TGC BS conversion for hashID-based seeded PRD decoding done successfully");
- } else {
- ATH_MSG_WARNING("TGC BS conversion for hashID-based seeded PRD decoding failed");
- }
- }
-
- if (m_tgcPrepDataProvider->decode(tgc_hash_ids, hash_ids_withData).isSuccess()) {
- ATH_MSG_DEBUG("PRD-based seeded decoding of TGC done successfully");
-#if DEBUG_ROI_VS_FULL
- sanity_check(tgc_hash_ids, hash_ids_withData, m_fileWithHashIds_tgc);
-#endif
- tgc_hash_ids.clear();
- tgc_hash_ids_cache.clear();
- tgc_hash_ids = hash_ids_withData;
- ATH_MSG_DEBUG("TgcHashId vector resized to " << tgc_hash_ids.size());
- } else {
- ATH_MSG_WARNING("PRD-based seeded decoding of TGC failed");
- }
-
- }
- else {// full decoding of TGC
- if (m_decodeTgcBS) {// bytesream conversion
- if (m_tgcRawDataProvider->convert().isSuccess()) {
- ATH_MSG_DEBUG("TGC BS conversion for full decoding done successfully");
- } else {
- ATH_MSG_WARNING("TGC BS conversion for full decoding failed");
- }
- }
- std::vector<IdentifierHash> input_hash_ids;
- input_hash_ids.reserve(0);
- if(m_tgcPrepDataProvider->decode(input_hash_ids, hash_ids_withData).isSuccess()) {
- ATH_MSG_DEBUG("PRD-based full decoding of TGC done successfully");
-#if DEBUG_ROI_VS_FULL
- sanity_check(input_hash_ids, hash_ids_withData, m_fileWithHashIds_tgc);
-#endif
- } else {
- ATH_MSG_WARNING("PRD-based full decoding of TGC failed");
- }
-
- }
- }// end of TGC decoding
-
- CscPrepDataContainer* cscPrds = nullptr;
- if (m_useCscData && !csc_hash_ids.empty()) {// CSC decoding
- SG::WriteHandle<Muon::CscPrepDataContainer> wh_clusters(m_cscClustersKey, ctx);
- cscPrds = new CscPrepDataContainer(m_idHelperSvc->cscIdHelper().module_hash_max());
- if (!wh_clusters.isPresent()) {
- /// record the container in storeGate
- if(wh_clusters.record(std::unique_ptr<Muon::CscPrepDataContainer>(cscPrds)).isFailure()){
- ATH_MSG_ERROR("Could not record CSC cluster container "<<m_cscClustersKey.key());
- return HLT::NAV_ERROR;
- }
- } else {
- const Muon::CscPrepDataContainer* outputCollection_c = nullptr;
- if(evtStore()->retrieve(outputCollection_c, m_cscClustersKey.key()).isFailure()){
- ATH_MSG_ERROR("Could not retrieve CSC cluster container "<<m_cscClustersKey.key());
- return HLT::NAV_ERROR;
- }
- else{
- cscPrds = const_cast<Muon::CscPrepDataContainer*> (outputCollection_c);
- }
- }
-
-
- if (m_useCscSeededDecoding) {// seeded decoding of CSC
- if (m_useCscRobDecoding) {// ROB-based seeded decoding of CSC is not available
- ATH_MSG_DEBUG("ROB-based seeded decoding of CSC requested, which is not available. Calling the PRD-based seeded decoding.");
- }
- if (m_decodeCscBS) {// bytesream conversion
- if (m_cscRawDataProvider->convert( csc_hash_ids ).isSuccess()) {
- ATH_MSG_DEBUG("CSC BS conversion for ROB-based seeded PRD decoding done successfully");
- } else {
- ATH_MSG_WARNING("CSC BS conversion for ROB-based seeded PRD decoding failed");
- }
- }
- if (m_cscPrepDataProvider->decode(csc_hash_ids, hash_ids_withData).isSuccess()) {
- ATH_MSG_DEBUG("PRD-based seeded decoding of CSC done successfully");
-#if DEBUG_ROI_VS_FULL
- sanity_check(csc_hash_ids, hash_ids_withData, m_fileWithHashIds_csc);
-#endif
- csc_hash_ids.clear();
- csc_hash_ids_cache.clear();
- csc_hash_ids = hash_ids_withData;
- ATH_MSG_DEBUG("CscHashId vector resized to " << csc_hash_ids.size());
- } else {
- ATH_MSG_WARNING("PRD-based seeded decoding of CSC failed");
- }
- // get clusters out of PRD
- if(csc_hash_ids.size()!=0) {
- if (m_cscClusterProvider->getClusters(csc_hash_ids, hash_ids_withData, cscPrds).isSuccess()) {
- ATH_MSG_DEBUG("CSC clusters obtained successfully");
- csc_hash_ids.clear();
- csc_hash_ids = hash_ids_withData;
- ATH_MSG_DEBUG("CscHashId vector resized to " << csc_hash_ids.size());
- } else {
- ATH_MSG_WARNING("Preparing CSC clusters failed");
- }
- } else {
- ATH_MSG_DEBUG("CscHashId vector is empty - skipping cluster preparation");
- }
-
- }
- else {// full decoding of CSC
- if (m_decodeCscBS) {// bytesream conversion
- if (m_cscRawDataProvider->convert().isSuccess()) {
- ATH_MSG_DEBUG("CSC BS conversion for full decoding done successfully");
- } else {
- ATH_MSG_WARNING("CSC BS conversion for full decoding failed");
- }
- }
- std::vector<IdentifierHash> input_hash_ids;
- input_hash_ids.reserve(0);
- if(m_cscPrepDataProvider->decode(input_hash_ids, hash_ids_withData).isSuccess()) {
- ATH_MSG_DEBUG("PRD-based full decoding of CSC done successfully");
-#if DEBUG_ROI_VS_FULL
- sanity_check(input_hash_ids, hash_ids_withData, m_fileWithHashIds_tgc);
-#endif
- } else {
- ATH_MSG_WARNING("PRD-based full decoding of CSC failed");
- }
- //get clusters out of PRD
- if(m_cscClusterProvider->getClusters(input_hash_ids, hash_ids_withData, cscPrds).isSuccess()) {
- ATH_MSG_DEBUG("CSC clusters obtained successfully");
- } else {
- ATH_MSG_WARNING("Preparing CSC clusters failed");
- }
-
- }
- }// end of CSC decoding
-
- // end of data decoding
-
- // select non-empty PRD collections for segment finding
-
- // Get RPC container
- if (m_useRpcData && !rpc_hash_ids.empty()) {
- const RpcPrepDataContainer* rpcPrds = 0;
- SG::ReadHandle<Muon::RpcPrepDataContainer> RpcCont(m_rpcKey, ctx);
- if( !RpcCont.isValid() ) {
- msg() << MSG::ERROR << " Cannot retrieve RPC PRD Container" << endmsg;
- return HLT::NAV_ERROR;
- }
- else{
- rpcPrds=RpcCont.cptr();
- msg()<< MSG::DEBUG << " RPC PRD Container retrieved" << endmsg;
- }
- // Get RPC collections
- const Muon::RpcPrepDataCollection* RPCcoll = nullptr;
- for(std::vector<IdentifierHash>::const_iterator idit = rpc_hash_ids.begin(); idit != rpc_hash_ids.end(); ++idit) {
- RPCcoll = rpcPrds->indexFindPtr(*idit);
- if( RPCcoll == nullptr ) {
- if (msgLvl(MSG::VERBOSE)) {
- Identifier idColl;
- IdContext rpcContext = m_idHelperSvc->rpcIdHelper().module_context();
- int code = m_idHelperSvc->rpcIdHelper().get_id(*idit, idColl, &rpcContext);
- ATH_MSG_VERBOSE("get_id code = " << code
- << " collection for rpc id hash = " << (int)*idit
- << " not found in the cont. ext.id = " << m_idHelperSvc->rpcIdHelper().show_to_string(idColl));
- }
- continue;
- }
- if( RPCcoll->size() == 0) {
- if (msgLvl(MSG::VERBOSE)) {
- Identifier idColl;
- IdContext rpcContext = m_idHelperSvc->rpcIdHelper().module_context();
- int code = m_idHelperSvc->rpcIdHelper().get_id(*idit, idColl, &rpcContext);
- ATH_MSG_VERBOSE("get_id code = " << code
- << " collection for rpc id hash = " << (int)*idit
- << " is empty ext.id = " << m_idHelperSvc->rpcIdHelper().show_to_string(idColl));
- }
- continue;
- }
-
- rpc_hash_ids_cache.push_back(*idit);
-
- nRpcHits+=RPCcoll->size(); // count hits for TrigMuonEFInfo
- rpcCols.push_back(RPCcoll);
- if (msgLvl(MSG::DEBUG))
- ATH_MSG_DEBUG("Selected Rpc Collection: "
- << m_idHelperSvc->rpcIdHelper().show_to_string(RPCcoll->identify())
- << " (hash = " << (int)*idit
- << ") with size " << RPCcoll->size());
- else if (testRoiDrivenMode)
- ATH_MSG_INFO("Selected Rpc Collection: "
- << m_idHelperSvc->rpcIdHelper().show_to_string(RPCcoll->identify())
- << " (hash = " << (int)*idit
- << "), with size " << RPCcoll->size());
-
- }
- if (rpcCols.empty()) {
- ATH_MSG_DEBUG("No Rpc data collections selected");
- }
- }
-
- // Get MDT container
- if (m_useMdtData && !mdt_hash_ids.empty()) {
-
- const MdtPrepDataContainer* mdtPrds = 0;
- SG::ReadHandle<Muon::MdtPrepDataContainer> MdtCont(m_mdtKey, ctx);
- if( !MdtCont.isValid() ) {
- ATH_MSG_ERROR(" Cannot retrieve MDT PRD Container");
- return HLT::NAV_ERROR;
- }
- else{
- mdtPrds=MdtCont.cptr();
- ATH_MSG_DEBUG(" MDT PRD Container retrieved");
- }
-
- // Get MDT collections
- const Muon::MdtPrepDataCollection* MDTcoll = nullptr;
- for(std::vector<IdentifierHash>::const_iterator idit = mdt_hash_ids.begin();
- idit != mdt_hash_ids.end(); ++idit) {
- MDTcoll = mdtPrds->indexFindPtr(*idit);
- if( MDTcoll == nullptr ) {
- if (msgLvl(MSG::VERBOSE)) {
- Identifier idColl;
- IdContext mdtContext = m_idHelperSvc->mdtIdHelper().module_context();
- int code = m_idHelperSvc->mdtIdHelper().get_id(*idit, idColl, &mdtContext);
- ATH_MSG_VERBOSE("get_id code = " << code
- << " collection for mdt id hash = " << (int)*idit
- << " not found in the cont. ext.id = " << m_idHelperSvc->mdtIdHelper().show_to_string(idColl));
- }
- continue;
- }
- if( MDTcoll->size() == 0) {
- if (msgLvl(MSG::VERBOSE)) {
- Identifier idColl;
- IdContext mdtContext = m_idHelperSvc->mdtIdHelper().module_context();
- int code = m_idHelperSvc->mdtIdHelper().get_id(*idit, idColl, &mdtContext);
- ATH_MSG_VERBOSE("get_id code = " << code
- << " collection for mdt id hash = " << (int)*idit
- << " is empty ext.id = " << m_idHelperSvc->mdtIdHelper().show_to_string(idColl));
- }
- continue;
- }
-
- if(m_useL2Hits && l2cont){
- Muon::MdtPrepDataCollection *mdtcollection=new Muon::MdtPrepDataCollection();
- addElement( m_mdtcollCache, mdtcollection );
-
- Muon::MdtPrepDataCollection::const_iterator cit_begin = MDTcoll->begin();
- Muon::MdtPrepDataCollection::const_iterator cit_end = MDTcoll->end();
- Muon::MdtPrepDataCollection::const_iterator cit = cit_begin;
- for( ; cit!=cit_end;++cit ) // first
- {
-
- const Muon::MdtPrepData* mdt = *cit;
- int TubeLayers = mdt->detectorElement()->getNLayers();
- int TubeLayer = m_idHelperSvc->mdtIdHelper().tubeLayer(mdt->identify());
- if(TubeLayer > TubeLayers) TubeLayer -= TubeLayers;
- const Amg::Vector3D mdtpos = mdt->detectorElement()->center(TubeLayer,m_idHelperSvc->mdtIdHelper().tube(mdt->identify()));
- for(uint l2=0; l2<l2cont->size(); l2++){
- l2muon = l2cont->at(l2);
- if(l2muon->nMdtHits()==0){
- mdtcollection->push_back(new Muon::MdtPrepData(*mdt));
- }
- for(uint hitnum=0; hitnum<l2muon->nMdtHits(); hitnum++){
- if(fabs(mdtpos.eta())<1.0 ? (fabs(l2muon->mdtHitR(hitnum)-mdtpos.perp())<0.1 && fabs(l2muon->mdtHitZ(hitnum)-mdtpos.z())<0.001): (fabs(l2muon->mdtHitR(hitnum)-fabs(mdtpos.perp()))<200 && fabs(l2muon->mdtHitZ(hitnum)-mdtpos.z())<0.001)){
- if(l2muon->mdtHitOfflineId(hitnum)!=0) continue;
-
- mdtcollection->push_back(new Muon::MdtPrepData(*mdt));
-
- }
- }
-
-
- }
- }
-
- mdtcollection->setIdentifier(MDTcoll->identify());
- nMdtHits+=mdtcollection->size(); // count hits for TrigMuonEFInfo
- mdtCols2.push_back(mdtcollection);
- }
- else{
- nMdtHits+=MDTcoll->size();
- }
-
-
- mdt_hash_ids_cache.push_back(*idit);
- mdtCols.push_back(MDTcoll);
- if (msgLvl(MSG::DEBUG)) ATH_MSG_DEBUG("Selected Mdt Collection: "
- << m_idHelperSvc->mdtIdHelper().show_to_string(MDTcoll->identify())
- << " with size " << MDTcoll->size());
- else
- if (testRoiDrivenMode) ATH_MSG_INFO("Selected Mdt Collection: "
- << m_idHelperSvc->mdtIdHelper().show_to_string(MDTcoll->identify())
- << " with size " << MDTcoll->size());
- }
- if (mdtCols.empty()) {
- ATH_MSG_DEBUG("No Mdt data collections selected");
- mdtDataFound = false;
- }
- }
-
- // Get TGC container
- if (m_useTgcData && !tgc_hash_ids.empty()) {
-
- const TgcPrepDataContainer* tgcPrds = 0;
- SG::ReadHandle<Muon::TgcPrepDataContainer> TgcCont(m_tgcKey, ctx);
- if( !TgcCont.isValid() ) {
- ATH_MSG_ERROR(" Cannot retrieve TGC PRD Container");
- return HLT::NAV_ERROR;
- }
- else{
- tgcPrds=TgcCont.cptr();
- ATH_MSG_DEBUG(" MDT PRD Container retrieved");
- }
-
- // Get TGC collections
- const Muon::TgcPrepDataCollection* TGCcoll;
- for(std::vector<IdentifierHash>::const_iterator idit = tgc_hash_ids.begin();
- idit != tgc_hash_ids.end(); ++idit) {
- TGCcoll = tgcPrds->indexFindPtr(*idit);
- if( TGCcoll == nullptr ) {
- if (msgLvl(MSG::VERBOSE)) {
- Identifier idColl;
- IdContext tgcContext = m_idHelperSvc->tgcIdHelper().module_context();
- int code = m_idHelperSvc->tgcIdHelper().get_id(*idit, idColl, &tgcContext);
- ATH_MSG_VERBOSE("get_id code = " << code
- << " collection for tgc id hash = " << (int)*idit
- << " not found in the cont. ext.id = " << m_idHelperSvc->tgcIdHelper().show_to_string(idColl));
- }
- continue;
- }
- if( TGCcoll->size() == 0) {
- if (msgLvl(MSG::VERBOSE)) {
- Identifier idColl;
- IdContext tgcContext = m_idHelperSvc->tgcIdHelper().module_context();
- int code = m_idHelperSvc->tgcIdHelper().get_id(*idit, idColl, &tgcContext);
- ATH_MSG_VERBOSE("get_id code = " << code
- << " collection for tgc id hash = " << (int)*idit
- << " is empty ext.id = " << m_idHelperSvc->tgcIdHelper().show_to_string(idColl));
- }
- continue;
- }
-
- tgc_hash_ids_cache.push_back(*idit);
- nTgcHits+=TGCcoll->size(); // count hits for TrigMuonEFInfo
- tgcCols.push_back(TGCcoll);
- if (msgLvl(MSG::DEBUG)) ATH_MSG_DEBUG("Selected Tgc Collection: "
- << m_idHelperSvc->tgcIdHelper().show_to_string(TGCcoll->identify())
- << " with size " << TGCcoll->size());
- else
- if (testRoiDrivenMode) ATH_MSG_INFO("Selected Tgc Collection: "
- << m_idHelperSvc->tgcIdHelper().show_to_string(TGCcoll->identify())
- << " with size " << TGCcoll->size());
- }
-
- if(m_useTGCInPriorNextBC){
- const TgcPrepDataContainer* tgcPrdsPriorBC = 0;
-
- for(std::vector<IdentifierHash>::const_iterator idit = tgc_hash_ids.begin();
- idit != tgc_hash_ids.end(); ++idit) {
- TGCcoll = tgcPrdsPriorBC->indexFindPtr(*idit);
- if( TGCcoll == nullptr ) {
- if (msgLvl(MSG::VERBOSE)) {
- Identifier idColl;
- IdContext tgcContext = m_idHelperSvc->tgcIdHelper().module_context();
- int code = m_idHelperSvc->tgcIdHelper().get_id(*idit, idColl, &tgcContext);
- ATH_MSG_VERBOSE("get_id code = " << code
- << " collection for tgc id hash = " << (int)*idit
- << " not found in the cont. ext.id = " << m_idHelperSvc->tgcIdHelper().show_to_string(idColl));
- }
- continue;
- }
- if( TGCcoll->size() == 0) {
- if (msgLvl(MSG::VERBOSE)) {
- Identifier idColl;
- IdContext tgcContext = m_idHelperSvc->tgcIdHelper().module_context();
- int code = m_idHelperSvc->tgcIdHelper().get_id(*idit, idColl, &tgcContext);
- ATH_MSG_VERBOSE("get_id code = " << code
- << " collection for tgc id hash = " << (int)*idit
- << " is empty ext.id = " << m_idHelperSvc->tgcIdHelper().show_to_string(idColl));
- }
- continue;
- }
- nTgcHits+=TGCcoll->size(); // count hits for TrigMuonEFInfo
- tgcCols.push_back(TGCcoll);
- if (msgLvl(MSG::DEBUG)) ATH_MSG_DEBUG("Selected Tgc Collection: "
- << m_idHelperSvc->tgcIdHelper().show_to_string(TGCcoll->identify())
- << " with size " << TGCcoll->size());
- }
- const TgcPrepDataContainer* tgcPrdsNextBC = 0;
- SG::ReadHandle<Muon::TgcPrepDataContainer> TgcCont(m_tgcKeyNextBC, ctx);
- if( !TgcCont.isValid() ) {
- ATH_MSG_ERROR(" Cannot retrieve TGC PRD Container");
- return HLT::NAV_ERROR;
- }
- else{
- tgcPrds=TgcCont.cptr();
- ATH_MSG_DEBUG(" MDT PRD Container retrieved");
- }
-
- for(std::vector<IdentifierHash>::const_iterator idit = tgc_hash_ids.begin();
- idit != tgc_hash_ids.end(); ++idit) {
- TGCcoll = tgcPrdsNextBC->indexFindPtr(*idit);
- if( TGCcoll == nullptr ) {
- if (msgLvl(MSG::VERBOSE)) {
- Identifier idColl;
- IdContext tgcContext = m_idHelperSvc->tgcIdHelper().module_context();
- int code = m_idHelperSvc->tgcIdHelper().get_id(*idit, idColl, &tgcContext);
- ATH_MSG_VERBOSE("get_id code = " << code
- << " collection for tgc id hash = " << (int)*idit
- << " not found in the cont. ext.id = " << m_idHelperSvc->tgcIdHelper().show_to_string(idColl));
- }
- continue;
- }
- if( TGCcoll->size() == 0) {
- if (msgLvl(MSG::VERBOSE)) {
- Identifier idColl;
- IdContext tgcContext = m_idHelperSvc->tgcIdHelper().module_context();
- int code = m_idHelperSvc->tgcIdHelper().get_id(*idit, idColl, &tgcContext);
- ATH_MSG_VERBOSE("get_id code = " << code
- << " collection for tgc id hash = " << (int)*idit
- << " is empty ext.id = " << m_idHelperSvc->tgcIdHelper().show_to_string(idColl));
- }
- continue;
- }
- nTgcHits+=TGCcoll->size(); // count hits for TrigMuonEFInfo
- tgcCols.push_back(TGCcoll);
- ATH_MSG_DEBUG("Selected Tgc Collection: "
- << m_idHelperSvc->tgcIdHelper().show_to_string(TGCcoll->identify())
- << " with size " << TGCcoll->size());
- }
- }
-
- if (tgcCols.empty()) {
- ATH_MSG_DEBUG("No Tgc data collections selected");
- }
- }
-
-
- // Get CSC container
- if (m_useCscData && !csc_hash_ids.empty()) {
-
-
- // Get CSC collections
- const Muon::CscPrepDataCollection* CSCcoll = nullptr;
- for(std::vector<IdentifierHash>::const_iterator idit = csc_hash_ids.begin();
- idit != csc_hash_ids.end(); ++idit) {
- if(m_ignoreCSC && (*idit==16 || *idit==17)){
- ATH_MSG_DEBUG("Skipping misaligned chamber with hashid "<<*idit);
- continue;
- }
- CSCcoll = cscPrds->indexFindPtr(*idit);
- if( CSCcoll == nullptr ) continue;
- if( CSCcoll->size() == 0) continue;
-
- csc_hash_ids_cache.push_back(*idit);
- nCscHits+=CSCcoll->size(); // count hits for TrigMuonEFInfo
- cscCols.push_back(CSCcoll);
- if (msgLvl(MSG::DEBUG)) ATH_MSG_DEBUG("Selected Csc Collection: "
- << m_idHelperSvc->cscIdHelper().show_to_string(CSCcoll->identify())
- << " with size " << CSCcoll->size());
- else
- if (testRoiDrivenMode) ATH_MSG_INFO("Selected Csc Collection: "
- << m_idHelperSvc->cscIdHelper().show_to_string(CSCcoll->identify())
- << " with size " << CSCcoll->size());
- }
- if (cscCols.empty()) {
- ATH_MSG_DEBUG("No Csc data collections selected");
- cscDataFound = false;
- }
- }
-
-
- if ( !(cscDataFound || mdtDataFound) ) {
- ATH_MSG_DEBUG("No precision data found: stop here to process the RoI");
- if (!muonRoI) return HLT::OK;
- return HLT::MISSING_FEATURE;
- }
-
- if (dataPrepTime) dataPrepTime->stop();
-
- // check time-out
- if (m_doTimeOutChecks && Athena::Timeout::instance(ctx).reached() ) {
- ATH_MSG_WARNING("Timeout reached. Aborting sequence.");
- return HLT::ErrorCode(HLT::Action::ABORT_EVENT, HLT::Reason::TIMEOUT);
- }
-
-#if DEBUG_ROI_VS_FULL
- //rpc
-
- std::vector<IdentifierHash> rpc_hash_list(rpc_hash_ids_cache);
- std::sort(rpc_hash_list.begin(),rpc_hash_list.end());
-
- if(rpc_hash_ids_cache.size() > 0)
- m_fileWithHashIds_rpc << "selected hash IDs passed to pattern finder: ";
-
- for (unsigned int i = 0; i<rpc_hash_list.size(); i++)
- m_fileWithHashIds_rpc << rpc_hash_list[i] << " ";
-
- if(rpc_hash_ids_cache.size() > 0)
- m_fileWithHashIds_rpc << "\n";
-
- //tgc
-
-
- std::vector<IdentifierHash> tgc_hash_list(tgc_hash_ids_cache);
- std::sort(tgc_hash_list.begin(),tgc_hash_list.end());
-
- if(tgc_hash_ids_cache.size() > 0)
- m_fileWithHashIds_tgc << "selected hash IDs passed to pattern finder: ";
-
- for (unsigned int i = 0; i<tgc_hash_list.size(); i++)
- {
- m_fileWithHashIds_tgc <<tgc_hash_list[i]<<" ";
- }
-
- if(tgc_hash_ids_cache.size() > 0)
- {
- m_fileWithHashIds_tgc <<"\n";
- }
-
- //mdt
-
- std::vector<IdentifierHash> mdt_hash_list(mdt_hash_ids_cache);
- std::sort(mdt_hash_list.begin(),mdt_hash_list.end());
-
- if(mdt_hash_ids_cache.size() > 0)
- m_fileWithHashIds_mdt << "selected hash IDs passed to pattern finder: ";
-
- for (unsigned int i = 0; i<mdt_hash_list.size(); i++)
- {
- m_fileWithHashIds_mdt <<mdt_hash_list[i]<<" ";
- }
-
- if(mdt_hash_ids_cache.size() > 0)
- {
- m_fileWithHashIds_mdt <<"\n";
- }
-
- //csc
-
- std::vector<IdentifierHash> csc_hash_list(csc_hash_ids_cache);
- std::sort(csc_hash_list.begin(),csc_hash_list.end());
-
- if(csc_hash_ids_cache.size() > 0)
- m_fileWithHashIds_csc << "selected hash IDs passed to pattern finder: ";
-
- for (unsigned int i = 0; i<csc_hash_list.size(); i++)
- {
- m_fileWithHashIds_csc <<csc_hash_list[i]<<" ";
- }
-
- if(csc_hash_ids_cache.size() > 0)
- {
- m_fileWithHashIds_csc <<"\n";
- }
-#endif
-
- //Filling Vector of Detector Elements For Comparison of Repeated ROIS
- m_hashlist.clear();
- m_hashlist.push_back(rpc_hash_ids_cache);
- m_hashlist.push_back(tgc_hash_ids_cache);
- m_hashlist.push_back(mdt_hash_ids_cache);
- m_hashlist.push_back(csc_hash_ids_cache);
-
- ++m_totalSegmentCalls;
-
- //Creating pointers to TE & SC for RepROI Information used for caching
- ATH_MSG_DEBUG("finding hashlist of size "<<m_hashlist.size()<<" in segment cache of size: "<<m_SFCacheSCMap.size());
- map<std::vector<std::vector<IdentifierHash> >, SegmentCache*>::iterator itSCmap = m_SFCacheSCMap.end();
-
- // Making Object to cache pointers for segfinder: SC holds
- // pointers that are all deleted at end of event
- cache = 0;
- if (m_doCache) itSCmap = m_SFCacheSCMap.find(m_hashlist);
-
- if (itSCmap!=m_SFCacheSCMap.end()) {
- ATH_MSG_DEBUG("Repeated ROI");
- ATH_MSG_DEBUG("retrieved segments from cache (roi_num="<<m_roi_num_seg<<"). hashlist size: "<<m_hashlist.size()<<", cache size: "<<m_SFCacheSCMap.size());
- if (segFinderTime) segFinderTime->start();
-
- cache = itSCmap->second;
- if(cache->PattColl()) m_patternCombiCollInternal = cache->PattColl();
- if(cache->Segments()) m_segmentsInternal = cache->Segments();
-
-
- if (segFinderTime) segFinderTime->stop();
- ++m_cachedSegmentCalls;
- monVars.wasCached = 1;
- }
- else { // itSCmap == m_SFCacheSCMap.end()
-
- if (segFinderTime) segFinderTime->start();
-
- ///// Call segment finding tool
- // check preconditions to spot conditions which could lead to
- // very long processing times.
- if (m_doTimeOutGuard) {
- if ((m_maxCscHits > 0 && nCscHits > m_maxCscHits) ||
- (m_maxTgcHits > 0 && nTgcHits > m_maxTgcHits) ||
- (m_maxRpcHits > 0 && nRpcHits > m_maxRpcHits) ||
- (m_maxMdtHits > 0 && nMdtHits > m_maxMdtHits)) {
- if (segFinderTime) segFinderTime->stop();
- ATH_MSG_WARNING("Timeout guard fired. Aborting sequence. Limits (0 means no limit):"
- << "CSC hit limit: " << m_maxCscHits << ", counted hits: " << nCscHits << ". "
- << "TGC hit limit: " << m_maxTgcHits << ", counted hits: " << nTgcHits << ". "
- << "RPC hit limit: " << m_maxRpcHits << ", counted hits: " << nRpcHits << ". "
- << "MDT hit limit: " << m_maxMdtHits << ", counted hits: " << nMdtHits << ". ");
- return HLT::ErrorCode(HLT::Action::ABORT_EVENT, HLT::Reason::TIMEOUT);
- }
- }
-
- Muon::IMooSegmentCombinationFinder::Output output;
- std::unique_ptr<MuonPatternCombinationCollection> pattColl(new MuonPatternCombinationCollection());
- output.patternCombinations=pattColl.get();
- std::unique_ptr<Trk::SegmentCollection> segColl(new Trk::SegmentCollection());
- output.segmentCollection=segColl.get();
- if(m_useL2Hits){
- if(mdtCols2.size()>0){
- m_segmentsFinderTool->findSegments(mdtCols2, cscCols, tgcCols, rpcCols, output, ctx);
- if(output.segmentCollection->size()==0){
- ATH_MSG_DEBUG("didn't find mstrk with l2 hits, use all mdt hits in roi");
- m_segmentsFinderTool->findSegments(mdtCols, cscCols, tgcCols, rpcCols, output, ctx);
- }
- }
- else m_segmentsFinderTool->findSegments(mdtCols, cscCols, tgcCols, rpcCols, output, ctx);
- }
- else m_segmentsFinderTool->findSegments(mdtCols, cscCols, tgcCols, rpcCols, output, ctx);
- if (!output.segmentCollection) {
- if (segFinderTime) segFinderTime->stop();
- ATH_MSG_WARNING("Segment finder returned an invalid pointer for the segments");
- cleanSegmentCollections();
- return HLT::ErrorCode(HLT::Action::ABORT_CHAIN);
- }
- if ( output.segmentCollection->empty() ) {
- if (segFinderTime) segFinderTime->stop();
- ATH_MSG_DEBUG("Segment finder return nothing: stop here to process the RoI");
- return HLT::MISSING_FEATURE;
- }
-
- //remove overlapping segments
- m_segmentOverlapRemovalTool->removeDuplicates(segColl.get());
-
- /// SegmentCache object takes pointers to be given to m_patternCombiColl and segments
- ATH_MSG_DEBUG("SegmentCache object taking pointers");
- m_patternCombiCollInternal=pattColl.release();
- m_segmentsInternal=segColl.release();
-
- for(auto mdtcoll : mdtCols2) if(mdtcoll) delete mdtcoll;
-
- if (m_doCache) {
- ATH_MSG_DEBUG("Setting up caching");
- cache = new SegmentCache();
- cache->AddPatternCollection(m_patternCombiCollInternal);
- cache->AddSegments(m_segmentsInternal);
- cache->SetNROI(m_roi_num_seg);//Setting roi number to SC obj for caching info
- m_SFCacheSCMap[m_hashlist] = cache;
- ATH_MSG_DEBUG("added segments to cache (roi_num="<<m_roi_num_seg<<"). hashlist size: "<<m_hashlist.size()<<". cache size: "<<m_SFCacheSCMap.size());
- } else { // not using cache
- ATH_MSG_DEBUG("Not using cache. hashlist size: "<<m_hashlist.size()<<". cache size: "<<m_SFCacheSCMap.size());
- cache = 0;
- monVars.wasCached = 0;
- }
-
- ATH_MSG_DEBUG("m_segments = "<< m_segmentsInternal);
- if(m_segmentsInternal){
- ATH_MSG_DEBUG("Found "<< m_segmentsInternal->size()<<" segments");
- }
-
- ATH_MSG_DEBUG("Stopping segFinderTime");
- if (segFinderTime) segFinderTime->stop();
- monVars.wasCached = 0;
-
- }//end else itSCmap == m_SFCacheSCMap.end()
-
- ATH_MSG_DEBUG("Starting dataOutputTime");
- if (dataOutputTime) dataOutputTime->start();
- if(m_patternCombiCollInternal) {
- typedef ConstDataVector<MuonPatternCombinationCollection> constvec_t;
- constvec_t* tmpvec = new constvec_t (m_patternCombiCollInternal->begin(),
- m_patternCombiCollInternal->end());
- m_patternCombiColl = tmpvec->asDataVector();
- }
- if(m_segmentsInternal) {
- typedef ConstDataVector<Trk::SegmentCollection> constvec_t;
- constvec_t* tmpvec = new constvec_t (m_segmentsInternal->begin(),
- m_segmentsInternal->end());
- m_segments = tmpvec->asDataVector();
- }
-
-
- // for deletion at end of event
- ATH_MSG_DEBUG("Doing addElement for m_patternCombiColl");
- addElement( m_patternCombisCache, m_patternCombiColl );
- addElement( m_patternCombisCache, m_patternCombiCollInternal );
- ATH_MSG_DEBUG("Doing addElement for m_segments");
- addElement( m_segmentsCache, m_segments );
- addElement( m_segmentsCache, m_segmentsInternal );
-
- int nSeg = 0;
- if(m_segments){
- std::vector<const Muon::MuonSegment*> muonSegCollection;
- for(Trk::SegmentCollection::const_iterator itSeg = m_segments->begin(); itSeg!= m_segments->end(); ++itSeg){
- if(*itSeg) muonSegCollection.push_back(dynamic_cast<const Muon::MuonSegment*>(*itSeg));
- }
- nSeg = segmentMonitoring(muonSegCollection, monVars);
- }
-
- monVars.numberOfSegs.push_back(nSeg);
-
- if (dataOutputTime) dataOutputTime->stop();
-
- return hltStatus;
-}
-
-
-//________________________________________________________________________
-HLT::ErrorCode
-TrigMuonEFStandaloneTrackTool::buildTracks(const Trk::SegmentCollection* segment_collection,
- SegmentCache* cache,
- TrigMuonEFMSMonVars& monVars,
- std::vector<TrigTimer*>& timers, unsigned int firstTimerIndex )
-{
- ATH_MSG_DEBUG("in buildTracks");
-
- TrigTimer* dataPrepTime = 0;
- TrigTimer* trackFinderTime = 0;
- TrigTimer* dataOutputTime = 0;
- unpackTimers( timers, firstTimerIndex, dataPrepTime, trackFinderTime, dataOutputTime);
-
- if(dataPrepTime) dataPrepTime->start();
-
- ATH_MSG_DEBUG("resetting cached pointers");
- // reset cached pointers
- m_spectrometerTracks = 0;
- m_spectrometerTracksInternal = 0;
- m_extrapolatedTracks = 0;
-
- HLT::ErrorCode hltStatus = HLT::OK;
-
- ++m_roi_num_mstrk;
-
- if(dataPrepTime) dataPrepTime->stop();
-
- ///// Call track finding tool
- ++m_totalSpectrometerCalls;
- if(trackFinderTime) trackFinderTime->start();
-
- if( m_doCache && cache && cache->SpectrometerTrackColl()) {
- ATH_MSG_DEBUG("retrieving tracks from cache");
- // retrieve tracks from cache
- m_spectrometerTracksInternal=cache->SpectrometerTrackColl();
- ++m_cachedSpectrometerCalls;
- monVars.wasCached = 1;
- } // no cached track found
- else{
- // Call track finding tool
- ATH_MSG_DEBUG("no tracks found in cache, calling track finder tool");
- std::vector<const Muon::MuonSegment*> muonSegCollection;
- if ( segment_collection and segment_collection->size() ) {
- ATH_MSG_VERBOSE("Converting Trk::SegmentCollection into std::vector<const Muon::MuonSegment*>");
- for(Trk::SegmentCollection::const_iterator itSeg = segment_collection->begin(); itSeg!= segment_collection->end(); ++itSeg){
- muonSegCollection.push_back(dynamic_cast<const Muon::MuonSegment*>(*itSeg));
- }
- }
- if ( muonSegCollection.size() ) {
- ATH_MSG_DEBUG("Doing Muon track finding with muon segment collection of size " << muonSegCollection.size());
- m_spectrometerTracksInternal = m_trackBuilderTool->find(muonSegCollection);
- if ( not m_spectrometerTracksInternal ) {
- ATH_MSG_VERBOSE("No tracks found. Making empty tracks collection.");
- m_spectrometerTracksInternal = new TrackCollection;
- }
- } else {
- ATH_MSG_VERBOSE("No segments found. Making empty tracks collection.");
- m_spectrometerTracksInternal = new TrackCollection;
- }
-
- if ( m_doCache && cache ) {
- cache->SetSpectrometerTrackCollection( m_spectrometerTracksInternal );
- }
- monVars.wasCached = 0;
-
- }//end of track finding
-
- if(trackFinderTime) trackFinderTime->stop();
- if(dataOutputTime) dataOutputTime->start();
- m_spectrometerTracks = (new ConstDataVector<TrackCollection>(m_spectrometerTracksInternal->begin(), m_spectrometerTracksInternal->end()))->asDataVector();
- // store for deletion at the end of event
- addElement( m_spectrometerTracksCache, m_spectrometerTracks );
- addElement( m_spectrometerTracksCache, m_spectrometerTracksInternal );
-
- // Dump tracks
- if (msgLvl(MSG::DEBUG)) {
- ATH_MSG_DEBUG("REGTEST MuonEF Found " << m_spectrometerTracks->size() << " tracks");
- } else if (testRoiDrivenMode) {
- ATH_MSG_INFO("REGTEST MuonEF Found " << m_spectrometerTracks->size() << " tracks");
- }
-
- if(m_spectrometerTracks) monVars.numberOfTracks.push_back(m_spectrometerTracks->size());
-
- // create track particle container, need to be careful with ownership
- if( m_spectrometerTrackParticles ) delete m_spectrometerTrackParticles;
- if( m_spectrometerTrackParticlesAux ) delete m_spectrometerTrackParticlesAux;
- m_spectrometerTrackParticles = new xAOD::TrackParticleContainer();
- m_spectrometerTrackParticlesAux = new xAOD::TrackParticleAuxContainer();
- m_spectrometerTrackParticles->setStore( m_spectrometerTrackParticlesAux );
-
- unsigned int nTrack=0;
- if(m_spectrometerTracks){
- for (TrackCollection::const_iterator itTrk = m_spectrometerTracks->begin(); itTrk!= m_spectrometerTracks->end(); ++itTrk) {
-
-
- const Trk::Track* trk = *itTrk;
- // create track particle - this is needed because later on we use the track particle container (m_spectrometerTrackParticles)
- // for the extrapolation of the muons
- const ElementLink<TrackCollection> trackLink(*m_spectrometerTracks, nTrack);
- m_TrackToTrackParticleConvTool->createParticle( trackLink, m_spectrometerTrackParticles, 0, xAOD::muon);
-
-
- ATH_MSG_DEBUG("REGTEST MuonEF - track " << nTrack
- << " has Author " << trk->info().dumpInfo());
- ++nTrack;
- const Trk::Perigee* perigee = trk->perigeeParameters ();
-
-
- const Amg::Vector3D mom = perigee->momentum();
- double z0 = perigee->parameters()[Trk::z0] ;
- double d0 = perigee->parameters()[Trk::d0] ;
- double phi = perigee->parameters()[Trk::phi0] ;
- double theta = perigee->parameters()[Trk::theta] ;
- // double charge = perigee->charge();
- double pt = mom.perp();
- double chi2 = -999.;
- double chi2prob = -999.;
- int ndof = -999;
- if( trk->fitQuality() ) {
- chi2 = trk->fitQuality()->chiSquared() ;
- ndof = trk->fitQuality()->numberDoF() ;
- if ((chi2/((double)ndof)) < 100.)
- chi2prob = Genfun::CumulativeChiSquare(ndof)(chi2);
- else
- chi2prob = 0.;
- }
- double eta = -log(tan(theta*0.5));
-
- unsigned short int nRpcEtaHits = 0;
- unsigned short int nRpcPhiHits = 0;
- unsigned short int nTgcEtaHits = 0;
- unsigned short int nTgcPhiHits = 0;
- unsigned short int nCscEtaHits = 0;
- unsigned short int nCscPhiHits = 0;
- unsigned short int nMdtHits = 0;
-
-
- // update track summary
- const Trk::TrackSummary* summary = NULL;
- Trk::Track& nonConstTrack = const_cast<Trk::Track&>(*trk);
- m_trackSummaryTool->updateTrack(nonConstTrack);
- summary = (nonConstTrack.trackSummary());
- if(summary==0) {
- ATH_MSG_DEBUG("trackSummary not found for this track, cannot get number of subdetector hits.");
- }
- else {
- nRpcEtaHits = summary->get(Trk::numberOfRpcEtaHits);
- nRpcPhiHits = summary->get(Trk::numberOfRpcPhiHits);
- nTgcEtaHits = summary->get(Trk::numberOfTgcEtaHits);
- nTgcPhiHits = summary->get(Trk::numberOfTgcPhiHits);
- nCscEtaHits = summary->get(Trk::numberOfCscEtaHits);
- nCscPhiHits = summary->get(Trk::numberOfCscPhiHits);
- nMdtHits = summary->get(Trk::numberOfMdtHits);
- }
-
- if (msgLvl(MSG::DEBUG))
- ATH_MSG_DEBUG(" REGTEST MuonEF - parameters are: pt " << pt
- << " MeV - eta " << eta
- << " phi " << phi << " z0/d0 " << z0 << " " << d0);
- else
- if (testRoiDrivenMode) msg() << MSG::INFO << " REGTEST MuonEF - parameters are: pt " << pt
- << " MeV - eta " << eta
- << " phi " << phi << " z0/d0 " << z0 << " " << d0 << endmsg;
-
- monVars.chi2.push_back(chi2/ndof);
- monVars.chi2Prob.push_back(chi2prob);
- monVars.pt.push_back(fabs(pt*(1./GeV)));
- monVars.phi.push_back(phi);
- monVars.eta.push_back(eta);
- monVars.d0.push_back(d0);
- monVars.z0.push_back(z0);
-
- if( summary!=0 ){
- if (nMdtHits > 0){
- monVars.nMdt.push_back(nMdtHits);
- }
- if(nRpcEtaHits > 0){
- monVars.nRpcEta.push_back(nRpcEtaHits);
- }
- if(nRpcPhiHits > 0){
- monVars.nRpcPhi.push_back(nRpcPhiHits);
- }
- if(nCscEtaHits > 0){
- monVars.nCscEta.push_back(nCscEtaHits);
- }
- if(nCscPhiHits > 0){
- monVars.nCscPhi.push_back(nCscPhiHits);
- }
- if(nTgcEtaHits > 0){
- monVars.nTgcEta.push_back(nTgcEtaHits);
- }
- if(nTgcPhiHits > 0){
- monVars.nTgcPhi.push_back(nTgcPhiHits);
- }
- } else {
- ATH_MSG_DEBUG("trackSummary not found for this track, cannot get number of subdetector hits.");
- }
-
- if(trk->measurementsOnTrack()){
- monVars.nHit.push_back(trk->measurementsOnTrack()->size());
- } else {
- ATH_MSG_DEBUG("measurementsOnTrack not found for this track, cannot get size.");
- }
- }//loop on MS tracks
- }// valid TrackCollection
- else ATH_MSG_DEBUG("m_spectrometerTracks = "<<m_spectrometerTracks);
- if(dataOutputTime) dataOutputTime->stop();
-
- return hltStatus;
-}
-
-
-//________________________________________________________________________
-HLT::ErrorCode
-TrigMuonEFStandaloneTrackTool::extrapolate(const xAOD::TrackParticleContainer* spectrometerTrackParticles,
- MuonCandidateCollection& candidateCollection,
- TrackCollection& extrapolatedTracks,
- SegmentCache* cache,
- TrigMuonEFSAMonVars& monVars,
- std::vector<TrigTimer*>& timers, unsigned int firstTimerIndex )
-{
- ATH_MSG_DEBUG("in extrapolate");
-
-
- // reset cached pointers
- m_extrapolatedTracks = 0;
-
- TrigTimer* dataPrepTime = 0;
- TrigTimer* trackFinderTime = 0;
- TrigTimer* dataOutputTime = 0;
- unpackTimers(timers, firstTimerIndex, dataPrepTime, trackFinderTime, dataOutputTime);
-
- if(dataPrepTime) dataPrepTime->start();
- ++m_totalExtrapolatedCalls;
- if(dataPrepTime) dataPrepTime->stop();
-
- if (trackFinderTime) trackFinderTime->start();
-
- bool needToCacheExtrapTrks=false;
- if( m_doCache && cache && cache->ExtrapolatedTrackColl()) {
- // caching will not work currently
- // ATH_MSG_ERROR("Caching not currently working with new EDM?");
- // retrieve tracks from cache
- m_extrapolatedTracks = cache->ExtrapolatedTrackColl();
- // ATH_MSG_DEBUG("Caching active, n(trks) = " << m_extrapolatedTracks->size());
- ++m_cachedExtrapolatedCalls;
- monVars.wasCached = 1;
- } // no cached track found
- else{
- ///// Call extrapolator tool
- ATH_MSG_DEBUG("Call MuonCandidateTool");
- m_muonCandidateTool->create( *spectrometerTrackParticles, candidateCollection, extrapolatedTracks );
- needToCacheExtrapTrks=true;
- monVars.wasCached = 0;
- }//end of else
-
- if (trackFinderTime) trackFinderTime->stop();
- if (dataOutputTime) dataOutputTime->start();
-
- // Dump tracks
- ATH_MSG_DEBUG("REGTEST MuonEF Found " << candidateCollection.size() << " tracks.");
-
- unsigned int nTrack=0;
- for(auto trk : extrapolatedTracks) {
-
- ATH_MSG_DEBUG("REGTEST MuonEF - extrapolated track has Author " << trk->info().dumpInfo());
-
- ++nTrack;
-
- const Trk::Perigee* perigee = trk->perigeeParameters ();
- double z0 = perigee->parameters()[Trk::z0] ;
- double d0 = perigee->parameters()[Trk::d0] ;
- double phi = perigee->parameters()[Trk::phi0] ;
- double theta = perigee->parameters()[Trk::theta] ;
- // double charge = perigee->charge();
-
-
- const Amg::Vector3D mom = perigee->momentum();
- double pt = mom.perp();
- double chi2 = -999.;
- double chi2prob = -999;
- int ndof = -999;
-
- if( trk->fitQuality() ){
- chi2 = trk->fitQuality()->chiSquared() ;
- ndof = trk->fitQuality()->numberDoF() ;
- if ((chi2/((double)ndof)) < 100.)
- chi2prob = Genfun::CumulativeChiSquare(ndof)(chi2);
- else
- chi2prob = 0.;
- }
- double eta = -log(tan(theta*0.5));
-
- unsigned short int nRpcEtaHits = 0;
- unsigned short int nRpcPhiHits = 0;
- unsigned short int nTgcEtaHits = 0;
- unsigned short int nTgcPhiHits = 0;
- unsigned short int nCscEtaHits = 0;
- unsigned short int nCscPhiHits = 0;
- unsigned short int nMdtHits = 0;
-
- // update track summary
- const Trk::TrackSummary* summary = NULL;
- m_trackSummaryTool->updateTrack(*trk);
- summary = (trk->trackSummary());
- if(summary==0) {
- ATH_MSG_DEBUG("trackSummary not found for this track, cannot get number of subdetector hits.");
- }
- else {
- nRpcEtaHits = summary->get(Trk::numberOfRpcEtaHits);
- nRpcPhiHits = summary->get(Trk::numberOfRpcPhiHits);
- nTgcEtaHits = summary->get(Trk::numberOfTgcEtaHits);
- nTgcPhiHits = summary->get(Trk::numberOfTgcPhiHits);
- nCscEtaHits = summary->get(Trk::numberOfCscEtaHits);
- nCscPhiHits = summary->get(Trk::numberOfCscPhiHits);
- nMdtHits = summary->get(Trk::numberOfMdtHits);
- if ((trk->trackSummary()->get(Trk::numberOfMdtHits) ) > 0){
- monVars.nMdt.push_back(nMdtHits);
- }
- if(nRpcEtaHits > 0){
- monVars.nRpcEta.push_back(nRpcEtaHits);
- }
- if(nRpcPhiHits > 0){
- monVars.nRpcPhi.push_back(nRpcPhiHits);
- }
- if(nCscEtaHits > 0){
- monVars.nCscEta.push_back(nCscEtaHits);
- }
- if(nCscPhiHits > 0){
- monVars.nCscPhi.push_back(nCscPhiHits);
- }
- if(nTgcEtaHits > 0){
- monVars.nTgcEta.push_back(nTgcEtaHits);
- }
- if(nTgcPhiHits > 0){
- monVars.nTgcPhi.push_back(nTgcPhiHits);
- }
- }
-
- if(trk->measurementsOnTrack()){
- monVars.nHit.push_back(trk->measurementsOnTrack()->size());
- } else {
- ATH_MSG_DEBUG("measurementsOnTrack not found for this track, cannot get size.");
- }
-
- ATH_MSG_DEBUG(" REGTEST MuonEF - parameters are: pt " << pt
- << " MeV - eta " << eta
- << " phi " << phi << " z0/d0 " << z0 << " " << d0);
-
- monVars.chi2.push_back(chi2/ndof);
- monVars.chi2Prob.push_back(chi2prob);
- monVars.pt.push_back(fabs(pt*(1./GeV)));
- monVars.phi.push_back(phi);
- monVars.eta.push_back(eta);
- monVars.d0.push_back(d0);
- monVars.z0.push_back(z0);
-
- ///////////////////////////////////////////// create xAOD muon for this track
-
- // create MuonCandidate - do deep copy of the extrapolated track because MuonCandidate takes ownership of the pointer
- /*
- ATH_MSG_DEBUG("Create MuonCandidate");
- MuonCombined::MuonCandidate muonCand(**itMSTrk, new Trk::Track(*trk));
-
- // Use muon creator tool
- ATH_MSG_DEBUG("Call MuonCreatorTool->create");
- xAOD::Muon* muon = m_muonCreatorTool->create( muonCand, *muonContainer, extrapolatedTrackParticles, 0);
- ATH_MSG_DEBUG("Created xAOD::Muon with pt, eta, phi, m = " << muon->pt() << ", " << muon->eta() << ", " << muon->phi() << ", " << muon->m() << ", muon conainter size = " << muonContainer->size() << ", TrackParticleCont size = " << extrapolatedTrackParticles->size() << " TrackCollection size = " << m_extrapolatedTracks->size());
- xAOD::TrackParticle* trackparticle = extrapolatedTrackParticles->back();
- ElementLink< TrackCollection > linkToTrkTrack( *m_extrapolatedTracks, nTrack-1);
- trackparticle->setTrackLink( linkToTrkTrack );
- ATH_MSG_DEBUG("Last xAOD::TrackParticle pt, eta, phi, m = " << trackparticle->pt() << ", " << trackparticle->eta() << ", " << trackparticle->phi() << ", " << trackparticle->m());
- ATH_MSG_DEBUG(" EleLink to Trk::Track isValid = " << trackparticle->trackLink().isValid());
- if(trackparticle->trackLink().isValid()) ATH_MSG_DEBUG(" pT, eta from Trk::Track = " << trackparticle->track()->perigeeParameters()->pT() << ", " << trackparticle->track()->perigeeParameters()->eta());
-
- ATH_MSG_DEBUG("Finished this track, muon candidate extrapolatedTrack() = " << muonCand.extrapolatedTrack());
- */
- }
-
- if ( m_doCache && cache && needToCacheExtrapTrks) {
- if(m_extrapolatedTracks) cache->SetExtrapolatedTrackCollection( m_extrapolatedTracks );
- }
-
- // store for deletion at end of event
- if(m_extrapolatedTracks) addElement( m_extrapolatedTracksCache, m_extrapolatedTracks );
-
- monVars.numberOfTracks.push_back(nTrack);
-
- if(dataOutputTime) dataOutputTime->stop();
-
- return HLT::OK;
-}
-
-
-//________________________________________________________________________
-void TrigMuonEFStandaloneTrackTool::cleanSegmentCollections()
-{
- ATH_MSG_DEBUG("cleanSegmentCollections");
-
- // should not be called passing collections already attached to the TriggerElement
-
- /// Before deleting the collections, we check whether the objects within them are stored in the association map.
- /// If they are then we remove them from the map (see savannah #71203)
-
- if (m_patternCombiColl) {
- if ( m_patternCombiColl->size() > 0 ) {
- const IMuonPatternSegmentAssociationTool::AssociationMap& assMap = m_assocTool->map();
- IMuonPatternSegmentAssociationTool::AssociationMap* nonConstMap = const_cast<IMuonPatternSegmentAssociationTool::AssociationMap*>(&assMap);
- bool printedHeader = false;
- // check for each patterncombi if it is still in the association map
- MuonPatternCombinationCollection::const_iterator itP = m_patternCombiColl->begin(), itP_end =m_patternCombiColl->end();
- for ( ; itP != itP_end; ++itP ) {
- const MuonPatternCombination* pat = *itP;
- // check if anything is still pointing to this pattern
- IMuonPatternSegmentAssociationTool::AssociationMap::const_iterator itA = assMap.begin(), itA_end = assMap.end();
- for ( ; itA != itA_end; ++itA ) {
- if ( itA->second == pat ) {
- // bug hunting printout
- if ( !printedHeader ) {
- ATH_MSG_INFO(__FUNCTION__ << " Event where by-hand clean-up needed:");
- printedHeader = true;
- }
- ATH_MSG_INFO(" About to delete patternCombi @ " << pat << " so first remove it from associationMap");
-
- // hacky FIX for bug #71203 (clean fix would use assocTool->remove( itA->first ), but that does not exist yet)
- if( nonConstMap ) nonConstMap->erase( itA->first );
- }
- }
- }
- if ( printedHeader ) msg() << endmsg; // prints out run,event,etc.
- }
-
- delete m_patternCombiColl;
- m_patternCombiColl=0;
- }
- if (m_segments)
- delete m_segments;
- m_segments=0;
-}
-
-//________________________________________________________________________
-void TrigMuonEFStandaloneTrackTool::recordPatterns()
-{
- // store the MuonPatternCombinationCollection in StoreGate for debug purposes
- MuonPatternCombinationCollection* patternCombColl = 0;
- std::string patternCombCollLocation = "TrigMuonEFPatterns";
- if( evtStore()->contains<MuonPatternCombinationCollection>(patternCombCollLocation) ){
- if (evtStore()->retrieve(patternCombColl,patternCombCollLocation).isFailure()){
- msg() << MSG::WARNING << "Could not retrieve MuonPatternCombinationCollection at "
- << patternCombCollLocation << endmsg;
- }
- }
- else{
- ATH_MSG_DEBUG("Recording new pattern combination collection with key "
- << patternCombCollLocation);
-
- patternCombColl = new MuonPatternCombinationCollection();
- if(evtStore()->record(patternCombColl,patternCombCollLocation,true).isFailure()){
- msg() << MSG::WARNING << "Could not record MuonPatternCombinationCollection at "
- << patternCombCollLocation << endmsg;
- delete patternCombColl;
- patternCombColl = 0;
- }
- }
- if (patternCombColl && m_patternCombiColl) {
- for (MuonPatternCombinationCollection::const_iterator itPatt = m_patternCombiColl->begin(); itPatt!= m_patternCombiColl->end(); ++itPatt) {
- const MuonPatternCombination* patt = *itPatt;
- patternCombColl->push_back( new Muon::MuonPatternCombination(*patt) );
- }
- }
-
-}
-
-//________________________________________________________________________
-void TrigMuonEFStandaloneTrackTool::recordSpectrometerTracks()
-{
- // store the TrackCollection in StoreGate for debug purposes
- TrackCollection* trackCollection = 0;
- std::string trackCollectionLocation = "TrigMuonEFTBTracks";
- if ( evtStore()->contains<TrackCollection>(trackCollectionLocation) ){
- if (evtStore()->retrieve(trackCollection,trackCollectionLocation).isFailure()){
- msg() << MSG::WARNING << "Could not retrieve TrackCollection at " << trackCollectionLocation
- << endmsg;
- }
- }
- else {
- ATH_MSG_DEBUG("Recording new collection with key " << trackCollectionLocation);
- trackCollection = new TrackCollection();
- if(evtStore()->record(trackCollection,trackCollectionLocation,true).isFailure()){
- ATH_MSG_WARNING("Could not record TrackCollection at " << trackCollectionLocation);
- delete trackCollection;
- trackCollection=0;
- }
- }
- if (trackCollection && m_spectrometerTracks) { // make sure TrackCollection is valid (could be 0 if SG record / retrieve failed)
- for (TrackCollection::const_iterator itTrk = m_spectrometerTracks->begin(); itTrk!= m_spectrometerTracks->end(); ++itTrk) {
- const Trk::Track* trk = *itTrk;
- trackCollection->push_back( new Trk::Track(*trk) );
- }
-
- }//valid trackCollection
-
-}
-
-//________________________________________________________________________
-void TrigMuonEFStandaloneTrackTool::setSegmentTimers(HLT::Algo* fexAlgo,
- std::vector<TrigTimer*>& timers)
-{
- ATH_MSG_INFO("Setting TMEF Segment Timers");
- timers.push_back( fexAlgo->addTimer("TMEF_segDataPrepTime") );
- timers.push_back( fexAlgo->addTimer("TMEF_segFinderTime") );
- timers.push_back( fexAlgo->addTimer("TMEF_segDataOutputTime") );
-}
-
-//________________________________________________________________________
-void TrigMuonEFStandaloneTrackTool::setSpectrometerTimers(HLT::Algo* fexAlgo,
- std::vector<TrigTimer*>& timers)
-{
- ATH_MSG_INFO("Setting TMEF Spectrometer Timers");
- setSegmentTimers(fexAlgo, timers);
- timers.push_back( fexAlgo->addTimer("TMEF_msTrackDataPrepTime") );
- timers.push_back( fexAlgo->addTimer("TMEF_msTrackFinderTime") );
- timers.push_back( fexAlgo->addTimer("TMEF_msTrackDataOutputTime") );
-}
-
-//________________________________________________________________________
-void TrigMuonEFStandaloneTrackTool::setExtrapolatedTimers(HLT::Algo* fexAlgo,
- std::vector<TrigTimer*>& timers)
-{
- ATH_MSG_INFO("Setting TMEF SA Timers");
- setSpectrometerTimers(fexAlgo, timers);
- timers.push_back( fexAlgo->addTimer("TMEF_saTrackDataPrepTime") );
- timers.push_back( fexAlgo->addTimer("TMEF_saTrackFinderTime") );
- timers.push_back( fexAlgo->addTimer("TMEF_saTrackDataOutputTime") );
-}
-
-//________________________________________________________________________
-void TrigMuonEFStandaloneTrackTool::declareSegmentMonitoringVariables(HLT::Algo* fexAlgo,
- TrigMuonEFMonVars& allMonVars)
-{
- ATH_MSG_DEBUG("declaring monitoring variables");
- TrigMuonEFSegmentMonVars& monVars = allMonVars.segs;
-
- // Segment monitoring variables
- fexAlgo->declareMonitoredVariable ("EF_segs_wasCached", monVars.wasCached);
- fexAlgo->declareMonitoredStdContainer ("EF_segs_nstations", monVars.numberOfStations, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_segs_nsegcomb", monVars.numberOfSegComb, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_segs_nsegs", monVars.numberOfSegs, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_segs_phi", monVars.phi, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_segs_eta", monVars.eta, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_segs_chi2pndof", monVars.chi2pNdof, IMonitoredAlgo::AutoClear);
-
- fexAlgo->declareMonitoredStdContainer ("EF_segs_nMdt", monVars.nMdt, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_segs_nCsc", monVars.nCsc, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_segs_nRpc", monVars.nRpc, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_segs_nTgc", monVars.nTgc, IMonitoredAlgo::AutoClear);
-
- fexAlgo->declareMonitoredStdContainer ("EF_segs_mdt_radius", monVars.mdtRadius, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_segs_mdt_tdc", monVars.mdtTDC, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_segs_mdt_adc", monVars.mdtADC, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_segs_mdt_z", monVars.mdtZ, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_segs_mdt_perp", monVars.mdtPerp, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_segs_mdt_eta", monVars.mdtEta, IMonitoredAlgo::AutoClear);
-
- fexAlgo->declareMonitoredVariable ("l2_cosmic_phi", monVars.phiL2CosmicMuon);
- fexAlgo->declareMonitoredVariable ("l2_cosmic_eta", monVars.etaL2CosmicMuon);
-
- fexAlgo->declareMonitoredVariable ("ef_phi", monVars.efPhi);
- fexAlgo->declareMonitoredVariable ("ef_eta", monVars.efEta);
-
-}
-
-//________________________________________________________________________
-void TrigMuonEFStandaloneTrackTool::declareSpectrometerMonitoringVariables(HLT::Algo* fexAlgo,
- TrigMuonEFMonVars& allMonVars)
-{
- // segment monitoring variables
- declareSegmentMonitoringVariables(fexAlgo, allMonVars);
-
- // MS track monitoring Variables
- TrigMuonEFMSMonVars& monVars = allMonVars.MS;
- fexAlgo->declareMonitoredVariable ("EF_mstrks_wasCached", monVars.wasCached);
- fexAlgo->declareMonitoredStdContainer ("EF_mstrks_n", monVars.numberOfTracks, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_mstrks_chi2", monVars.chi2, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_mstrks_chi2Prob", monVars.chi2Prob, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_mstrks_pt", monVars.pt, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_mstrks_phi", monVars.phi, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_mstrks_eta", monVars.eta, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_mstrks_d0", monVars.d0, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_mstrks_z0", monVars.z0, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_mstrks_nMdt", monVars.nMdt, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_mstrks_nRpcEta", monVars.nRpcEta, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_mstrks_nRpcPhi", monVars.nRpcPhi, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_mstrks_nCscEta", monVars.nCscEta, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_mstrks_nCscPhi", monVars.nCscPhi, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_mstrks_nTgcEta", monVars.nTgcEta, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_mstrks_nTgcPhi", monVars.nTgcPhi, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_mstrks_nHit", monVars.nHit, IMonitoredAlgo::AutoClear);
-}
-
-//__________________________________________________________________________________
-void TrigMuonEFStandaloneTrackTool::declareExtrapolatedMonitoringVariables(HLT::Algo* fexAlgo,
- TrigMuonEFMonVars& allMonVars)
-{
- // declare segment + spectrometer track monitoring variables
- declareSpectrometerMonitoringVariables(fexAlgo, allMonVars);
-
- // Extrapolated track monitoring Variables
- TrigMuonEFSAMonVars& monVars = allMonVars.SA;
- fexAlgo->declareMonitoredVariable ("EF_satrks_wasCached", monVars.wasCached);
- fexAlgo->declareMonitoredStdContainer ("EF_satrks_n", monVars.numberOfTracks, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_satrks_chi2", monVars.chi2, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_satrks_pt", monVars.pt, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_satrks_phi", monVars.phi, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_satrks_eta", monVars.eta, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_satrks_d0", monVars.d0, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_satrks_z0", monVars.z0, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_satrks_nMdt", monVars.nMdt, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_satrks_nRpcEta", monVars.nRpcEta, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_satrks_nRpcPhi", monVars.nRpcPhi, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_satrks_nCscEta", monVars.nCscEta, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_satrks_nCscPhi", monVars.nCscPhi, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_satrks_nTgcEta", monVars.nTgcEta, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_satrks_nTgcPhi", monVars.nTgcPhi, IMonitoredAlgo::AutoClear);
- fexAlgo->declareMonitoredStdContainer ("EF_satrks_nHit", monVars.nHit, IMonitoredAlgo::AutoClear);
-}
-
-//________________________________________________________________________
-void TrigMuonEFStandaloneTrackTool::handle(const Incident &inc)
-{
- if (inc.type() == "EndEvent"){
- ATH_MSG_DEBUG( "=====> End of Event" );
-
- // delete the SegmentCache objects we created with new
- for (map<std::vector<std::vector<IdentifierHash> >, SegmentCache*>::iterator itSCmap=m_SFCacheSCMap.begin(); itSCmap!=m_SFCacheSCMap.end(); ++itSCmap) {
- delete itSCmap->second;
- }
-
- ATH_MSG_DEBUG("clearing SFCacheSCmap");
- m_SFCacheSCMap.clear();
- m_hashlist.clear();
- m_assocTool->reset();
-
- m_roi_num_seg=0;
- m_roi_num_mstrk = 0;
- m_roi_num_satrk = 0;
-
- clearCacheVector( m_spectrometerTracksCache );
- clearCacheVector( m_extrapolatedTracksCache );
- clearCacheVector( m_patternCombisCache );
- clearCacheVector( m_segmentsCache );
- clearCacheVector(m_mdtcollCache);
-
- }
-}
-
-//________________________________________________________________________
-HLT::ErrorCode
-TrigMuonEFStandaloneTrackTool::getSegments(const IRoiDescriptor* muonRoI,
- TrigMuonEFMonVars& monVars,
- std::vector<TrigTimer*>& timers, const EventContext& ctx )
-{
- SegmentCache* cache = 0;
- return findSegments(muonRoI, cache, monVars.segs, timers, 0, ctx );
-}
-
-//________________________________________________________________________
-HLT::ErrorCode
-TrigMuonEFStandaloneTrackTool::getSpectrometerTracks(const IRoiDescriptor* muonRoI,
- TrigMuonEFMonVars& monVars,
- std::vector<TrigTimer*>& timers, const EventContext& ctx )
-{
- SegmentCache* cache = 0;
- return getSpectrometerTracks( muonRoI, cache, monVars, timers, ctx );
-}
-
-//________________________________________________________________________
-HLT::ErrorCode
-TrigMuonEFStandaloneTrackTool::getExtrapolatedTracks(const IRoiDescriptor* muonRoI,
- MuonCandidateCollection& candidateCollection,
- TrackCollection& extrapolatedTracks,
- TrigMuonEFMonVars& monVars,
- std::vector<TrigTimer*>& timers, const EventContext& ctx)
-{
- SegmentCache* cache = 0;
- ATH_MSG_DEBUG("In getExtrapolatedTracks without cache");
- return getExtrapolatedTracks( muonRoI, candidateCollection, extrapolatedTracks, cache, monVars, timers, ctx );
-}
-
-//________________________________________________________________________
-const MuonPatternCombinationCollection*
-TrigMuonEFStandaloneTrackTool::patternCombis()
-{
- return m_patternCombiColl;
-}
-
-//________________________________________________________________________
-const Trk::SegmentCollection*
-TrigMuonEFStandaloneTrackTool::segments()
-{
- return m_segments;
-}
-
-//________________________________________________________________________
-const TrackCollection*
-TrigMuonEFStandaloneTrackTool::spectrometerTracks()
-{
- return m_spectrometerTracks;
-}
-
-//________________________________________________________________________
-const TrackCollection*
-TrigMuonEFStandaloneTrackTool::extrapolatedTracks()
-{
- return m_extrapolatedTracks;
-}
-
-//________________________________________________________________________
-const MuonPatternCombinationCollection*
-TrigMuonEFStandaloneTrackTool::patternCombisToAttach()
-{
- removeElement(m_patternCombisCache, m_patternCombiColl);
- return m_patternCombiColl;
-}
-
-//________________________________________________________________________
-const Trk::SegmentCollection*
-TrigMuonEFStandaloneTrackTool::segmentsToAttach()
-{
- removeElement(m_segmentsCache, m_segments );
- return m_segments;
-}
-
-//________________________________________________________________________
-const TrackCollection*
-TrigMuonEFStandaloneTrackTool::spectrometerTracksToAttach()
-{
- removeElement(m_spectrometerTracksCache, m_spectrometerTracks);
- return m_spectrometerTracks;
-}
-
-//________________________________________________________________________
-const TrackCollection*
-TrigMuonEFStandaloneTrackTool::extrapolatedTracksToAttach()
-{
- removeElement(m_extrapolatedTracksCache, m_extrapolatedTracks);
- return m_extrapolatedTracks;
-}
-
-//________________________________________________________________________
-const xAOD::TrackParticleContainer*
-TrigMuonEFStandaloneTrackTool::trackParticleContainerToAttach()
-{
- const xAOD::TrackParticleContainer* coll = m_spectrometerTrackParticles;
- m_spectrometerTrackParticles=0;
- return coll;
-}
-
-//________________________________________________________________________
-const xAOD::TrackParticleAuxContainer*
-TrigMuonEFStandaloneTrackTool::trackParticleAuxContainerToAttach()
-{
- const xAOD::TrackParticleAuxContainer* coll = m_spectrometerTrackParticlesAux;
- m_spectrometerTrackParticlesAux=0;
- return coll;
-}
-
-
-//________________________________________________________________________
-std::vector<std::vector<IdentifierHash> > TrigMuonEFStandaloneTrackTool::getHashList(const IRoiDescriptor* muonRoI){
-
- std::vector<std::vector<IdentifierHash> > CurrentHashlist;
- CurrentHashlist.clear();
-
-
-
- std::vector<IdentifierHash> rpc_hash_ids;
- std::vector<IdentifierHash> rpc_hash_ids_cache;
-
- if (m_useRpcData) {
- if ( muonRoI ) m_regionSelector->DetHashIDList(RPC, *muonRoI, rpc_hash_ids);
- else m_regionSelector->DetHashIDList(RPC, rpc_hash_ids);
- }
-
-
- std::vector<IdentifierHash> tgc_hash_ids;
- std::vector<IdentifierHash> tgc_hash_ids_cache;
- if (m_useTgcData){
- if ( muonRoI ) m_regionSelector->DetHashIDList(TGC, *muonRoI, tgc_hash_ids);
- else m_regionSelector->DetHashIDList(TGC, tgc_hash_ids);
- }
-
-
- std::vector<IdentifierHash> temp_mdt_hash_ids;
- std::vector<IdentifierHash> mdt_hash_ids;
- std::vector<IdentifierHash> mdt_hash_ids_cache;
- if (m_useMdtData>0) {
- if ( muonRoI ) {
- m_regionSelector->DetHashIDList(MDT, *muonRoI, temp_mdt_hash_ids);
- }
- else {
- m_regionSelector->DetHashIDList(MDT, temp_mdt_hash_ids);
- }
-
- if (m_useMdtData >1) {
- for (std::vector<IdentifierHash>::const_iterator it=temp_mdt_hash_ids.begin();
- it!= temp_mdt_hash_ids.end(); ++it) {
- bool select = false;
- if (m_useMdtData == 2) {
- if ( (*it) < 638 || (*it) >1151 ) //barrel only: BIL to BOG + BIM
- select = true;
- } else if (m_useMdtData == 3) {
- if ( (*it) > 637 && (*it) <1152) //all endcap chambers
- select = true;
- }
- if (select) {
- mdt_hash_ids.push_back((*it));
- }
- }
- } else {
- mdt_hash_ids = temp_mdt_hash_ids;
- }
- }
-
- std::vector<IdentifierHash> csc_hash_ids;
- std::vector<IdentifierHash> csc_hash_ids_cache;
- if (m_useCscData) {
- if ( muonRoI ) m_regionSelector->DetHashIDList(CSC, *muonRoI, csc_hash_ids);
- else m_regionSelector->DetHashIDList(CSC, csc_hash_ids);
- }
-
-
-
-
-
- CurrentHashlist.push_back(rpc_hash_ids);
- CurrentHashlist.push_back(tgc_hash_ids);
- CurrentHashlist.push_back(mdt_hash_ids);
- CurrentHashlist.push_back(csc_hash_ids);
-
- return CurrentHashlist;
-
-}
-
-//________________________________________________________________________
-int TrigMuonEFStandaloneTrackTool::segmentMonitoring(const std::vector< const MuonSegment*>& segmentVector, TrigMuonEFSegmentMonVars& monVars)
-{
- for(std::vector< const MuonSegment* >::const_iterator segment=segmentVector.begin();
- segment!=segmentVector.end(); ++segment){
- monVars.phi.push_back( (*segment)->globalDirection().phi() );
- //float eta = -std::log(tan(0.5*(*segment)->globalDirection().theta()));
- float eta = (*segment)->globalDirection().eta();
- monVars.eta.push_back( eta );
- // Not optimal if nSeg>1 ...
- monVars.efPhi=(*segment)->globalDirection().phi();
- monVars.efEta=eta;
- /// get chi2 / ndof
- if((*segment)->fitQuality()) {
- const double chi2 = (*segment)->fitQuality()->chiSquared();
- const double dof = (*segment)->fitQuality()->doubleNumberDoF();
- monVars.chi2pNdof.push_back( ((float) (chi2 / dof)) );
- }//if FitQuality() valid
- int nMdt = 0; int nCsc = 0; int nRpc = 0; int nTgc = 0;
- for(unsigned int irio=0; irio < (*segment)->numberOfContainedROTs(); ++irio) {
-
- Trk::RIO_OnTrack* rio = const_cast<Trk::RIO_OnTrack*> ((*segment)->rioOnTrack(irio));
- if(!rio) continue;
- Identifier rioId = rio->identify();
- if(m_idHelperSvc->isMdt(rioId)) {
- nMdt++;
- const MdtDriftCircleOnTrack* mdt = dynamic_cast<const MdtDriftCircleOnTrack*>(rio);
- if(mdt!=0){
- const MdtPrepData* mdtPrd = mdt->prepRawData();
- monVars.mdtRadius.push_back(mdt->driftRadius());
- monVars.mdtZ.push_back(mdt->globalPosition().z());
- monVars.mdtPerp.push_back(mdt->globalPosition().perp());
- monVars.mdtEta.push_back(mdt->globalPosition().eta());
- monVars.mdtTDC.push_back(mdtPrd->tdc());
- monVars.mdtADC.push_back(mdtPrd->adc());
-
- } else ATH_MSG_ERROR("cannot cast to MdtDriftCircle ");
- } else if (m_idHelperSvc->isCsc(rioId)) {
- nCsc++;
- } else if (m_idHelperSvc->isRpc(rioId)) {
- nRpc++;
- } else if (m_idHelperSvc->isTgc(rioId)){
- nTgc++;
- }
- } // end loop on rio
- monVars.nMdt.push_back(nMdt);
- monVars.nCsc.push_back(nCsc);
- monVars.nRpc.push_back(nRpc);
- monVars.nTgc.push_back(nTgc);
- } // end loop on segs
-
- return segmentVector.size();
-}
-
-
-
diff --git a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFStandaloneTrackTool.h b/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFStandaloneTrackTool.h
deleted file mode 100644
index a29917964c531fd37e6b05d1476d1d42fd100546..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFStandaloneTrackTool.h
+++ /dev/null
@@ -1,393 +0,0 @@
-/*
- Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-*/
-
-#ifndef TRIGMUONEF_TRIGMUONEFSTANDALONETRACKTOOL_H
-#define TRIGMUONEF_TRIGMUONEFSTANDALONETRACKTOOL_H
-
-
-#include "SegmentCache.h"
-
-#include "AthenaBaseComps/AthAlgTool.h"
-#include "GaudiKernel/ServiceHandle.h"
-#include "GaudiKernel/ToolHandle.h"
-
-#include "MuonIdHelpers/IMuonIdHelperSvc.h"
-#include "TrkTrack/TrackCollection.h"
-#include "TrigMuonToolInterfaces/ITrigMuonStandaloneTrackTool.h"
-#include "TrigMuonToolInterfaces/TrigMuonEFMonVars.h"
-#include "MuonRecToolInterfaces/IMuonTrackFinder.h"
-#include "MuonRecToolInterfaces/IMuonCombiTrackMaker.h"
-#include "GaudiKernel/IIncidentListener.h"
-#include "MuonPattern/MuonPatternCombinationCollection.h"
-#include "TrkSegment/SegmentCollection.h"
-#include "TrigInterfaces/IMonitoredAlgo.h"
-#include "MuonCnvToolInterfaces/IMuonRawDataProviderTool.h"
-#include "MuonPrepRawData/MdtPrepDataCollection.h"
-#include "MuonPrepRawData/CscPrepDataCollection.h"
-#include "MuonPrepRawData/RpcPrepDataCollection.h"
-#include "MuonPrepRawData/TgcPrepDataCollection.h"
-#include "MuonPrepRawData/RpcPrepDataContainer.h"
-#include "IRegionSelector/RegSelEnums.h"
-#include "TrigSteeringEvent/TrigRoiDescriptor.h"
-#include "xAODMuon/MuonContainer.h"
-#include "xAODTracking/TrackParticleContainer.h"
-#include "xAODTracking/TrackParticleAuxContainer.h"
-#include "MuonCombinedEvent/MuonCandidateCollection.h"
-#include <fstream>
-#include "MuonCablingData/MuonMDT_CablingMap.h"
-
-#include "MuonSegmentMakerToolInterfaces/IMuonSegmentOverlapRemovalTool.h"
-#include "CxxUtils/checker_macros.h"
-
-ATLAS_NO_CHECK_FILE_THREAD_SAFETY; // legacy trigger code
-
-#include <vector>
-
-#define DEBUG_ROI_VS_FULL false
-
-/**
- @file TrigMuonEFStandaloneTrackTool.h
- @class TrigMuonEFStandaloneTrackTool
-
- @brief Tool to find segments for TrigMuonEF
-
- @author Robert Harrington <roberth@cern.ch>
- @author Martin Woudstra <martin.woudstra@cern.ch>
- @date 10/21/2011
- */
-
-namespace HLT {
- class TriggerElement;
- class Algo;
-}
-
-namespace Muon {
- class IMooSegmentCombinationFinder;
- class IMuonPatternSegmentAssociationTool;
- class IMuonRdoToPrepDataTool;
- class IMuonTrackFinder;
- class MboyMooSegmentCombinationFinder;
-
-}
-namespace MuonCombined {
- class IMuonCandidateTool;
-}
-
-namespace Rec {
- class IMuidBackTracker;
-}
-
-namespace Trk {
- class ITrackSummaryTool;
- class ITrackParticleCreatorTool;
-}
-
-class ICscClusterBuilder;
-class TrigMuonEFInfoContainer;
-class TrigTimer;
-class ActiveStoreSvc;
-class IRegSelSvc;
-
-class IRoiDescriptor;
-
-class TrigMuonEFStandaloneTrackTool : public AthAlgTool,
- public virtual ITrigMuonStandaloneTrackTool,
- public virtual IIncidentListener
-{
-
- public:
-
- TrigMuonEFStandaloneTrackTool(const std::string& type,
- const std::string& name,
- const IInterface* parent);
-
- virtual ~TrigMuonEFStandaloneTrackTool();
-
- virtual StatusCode initialize();
- virtual StatusCode finalize();
-
- /** Run segment finding only */
- virtual HLT::ErrorCode getSegments(const IRoiDescriptor* muonRoI,
- TrigMuonEFMonVars& monvars,
- std::vector<TrigTimer*>& timers, const EventContext& ctx);
-
- /** Run segment finding and spectrometer track building */
- virtual HLT::ErrorCode getSpectrometerTracks(const IRoiDescriptor* muonRoI,
- TrigMuonEFMonVars& monVars,
- std::vector<TrigTimer*>& timers, const EventContext& ctx);
-
- /** Run segment finding, spectrometer track building and extrapolation */
- virtual HLT::ErrorCode getExtrapolatedTracks(const IRoiDescriptor* muonRoI,
- MuonCandidateCollection& candidateCollection,
- TrackCollection& extrapolatedTracks,
- TrigMuonEFMonVars& monvars,
- std::vector<TrigTimer*>& timers, const EventContext& ctx);
-
- /** get list of hashIDs used in roi (used for internal caching in TrigMuSuperEF) **/
- virtual std::vector<std::vector<IdentifierHash> > getHashList(const IRoiDescriptor* muonRoI);
-
- /** return last created MuonPatternCombinationCollection. Caller is responsible for deletion of object.
- Call this function if you want to attach the object to the TriggerElement */
- virtual const MuonPatternCombinationCollection* patternCombisToAttach();
-
- /** return last created Trk::SegmentCollection. Caller is responsible for deletion of object.
- Call this function if you want to attach the object to the TriggerElement */
- virtual const Trk::SegmentCollection* segmentsToAttach();
-
- /** return last created TrackCollection with muon spectrometer tracks. Caller is responsible for deletion of object.
- Call this function if you want to attach the object to the TriggerElement */
- virtual const TrackCollection* spectrometerTracksToAttach();
-
- /** return last created TrackCollection with extrapolated tracks. Caller is responsible for deletion of object.
- Call this function if you want to attach the object to the TriggerElement */
- virtual const TrackCollection* extrapolatedTracksToAttach();
-
- /** return last created TrackParticleContainer with extrapolated tracks. Caller is responsible for deletion of object.
- Call this function if you want to attach the object to the TriggerElement */
- virtual const xAOD::TrackParticleContainer* trackParticleContainerToAttach();
- virtual const xAOD::TrackParticleAuxContainer* trackParticleAuxContainerToAttach();
-
- /** return last created MuonPatternCombinationCollection. Object will be deleted by tool at the end of the event.
- NB: You can not attach this object to the TriggerElement */
- virtual const MuonPatternCombinationCollection* patternCombis();
-
- /** return last created Trk::SegmentCollection. Object will be deleted by tool at the end of the event.
- NB: You can not attach this object to the TriggerElement */
- virtual const Trk::SegmentCollection* segments();
-
- /** return last created TrackCollection with muon spectrometer tracks. Object will be deleted by tool at the end of the event.
- NB: You can not attach this object to the TriggerElement */
- virtual const TrackCollection* spectrometerTracks();
-
- /** return last created TrackCollection with extrapolated tracks. Object will be deleted by tool at the end of the event.
- NB: You can not attach this object to the TriggerElement */
- virtual const TrackCollection* extrapolatedTracks();
-
- int segmentMonitoring(const std::vector<const Muon::MuonSegment*>& segmentVector,
- TrigMuonEFSegmentMonVars& monVars);
-
- virtual void handle(const Incident &inc);
-
- virtual void recordPatterns();
- virtual void recordSpectrometerTracks();
-
- virtual void declareSegmentMonitoringVariables (HLT::Algo* fexAlgo, TrigMuonEFMonVars& monVars);
- virtual void declareSpectrometerMonitoringVariables(HLT::Algo* fexAlgo, TrigMuonEFMonVars& monVars);
- virtual void declareExtrapolatedMonitoringVariables(HLT::Algo* fexAlgo, TrigMuonEFMonVars& monVars);
-
- virtual void setSegmentTimers (HLT::Algo* fexAlgo, std::vector<TrigTimer*>& timers);
- virtual void setSpectrometerTimers(HLT::Algo* fexAlgo, std::vector<TrigTimer*>& timers);
- virtual void setExtrapolatedTimers(HLT::Algo* fexAlgo, std::vector<TrigTimer*>& timers);
-
- virtual const std::vector<uint32_t>& getMdtRobList( const IRoiDescriptor* muonRoI);
- virtual const std::vector<uint32_t>& getRpcRobList( const IRoiDescriptor* muonRoI);
- virtual const std::vector<uint32_t>& getTgcRobList( const IRoiDescriptor* muonRoI);
- virtual const std::vector<uint32_t>& getCscRobList( const IRoiDescriptor* muonRoI);
- virtual void clearRoiCache();
-
- virtual bool useMdtSeededDecoding() {return m_useMdtSeededDecoding;}
- virtual bool useRpcSeededDecoding() {return m_useRpcSeededDecoding;}
- virtual bool useTgcSeededDecoding() {return m_useTgcSeededDecoding;}
- virtual bool useCscSeededDecoding() {return m_useCscSeededDecoding;}
-
- private:
-
- void cleanSegmentCollections();
-
-
- /** Run segment finding only */
- HLT::ErrorCode getSegments(const IRoiDescriptor* muonRoI,
- SegmentCache*& cache,
- TrigMuonEFMonVars& monvars,
- std::vector<TrigTimer*>& timers);
-
- /** Run segment finding and spectrometer track building */
- HLT::ErrorCode getSpectrometerTracks(const IRoiDescriptor* muonRoI,
- SegmentCache*& cache,
- TrigMuonEFMonVars& monVars,
- std::vector<TrigTimer*>& timers, const EventContext& ctx);
-
- /** Run segment finding, spectrometer track building and extrapolation */
- HLT::ErrorCode getExtrapolatedTracks(const IRoiDescriptor* muonRoI,
- MuonCandidateCollection& candidateCollection,
- TrackCollection& extrapolatedTracks,
- SegmentCache*& cache,
- TrigMuonEFMonVars& monvars,
- std::vector<TrigTimer*>& timers, const EventContext& ctx);
-
-
- /** Find segments in input ROI */
- HLT::ErrorCode findSegments(const IRoiDescriptor* muonRoI,
- SegmentCache*& cache,
- TrigMuonEFSegmentMonVars& monvars,
- std::vector<TrigTimer*>& timers, unsigned int firstTimerIndex, const EventContext& ctx );
-
- /** Build tracks out of input segments */
- HLT::ErrorCode buildTracks(const Trk::SegmentCollection* segment_collection,
- SegmentCache* cache,
- TrigMuonEFMSMonVars& monVars,
- std::vector<TrigTimer*>& timers, unsigned int firstTimerIndex );
-
- /** Extrapolate input track to IP */
- HLT::ErrorCode extrapolate(const xAOD::TrackParticleContainer* spectrometerTrackParticles,
- MuonCandidateCollection& candidateCollection,
- TrackCollection&extrapolatedTracks,
- SegmentCache* cache,
- TrigMuonEFSAMonVars& monvars,
- std::vector<TrigTimer*>& timers, unsigned int firstTimerIndex );
-
-#if DEBUG_ROI_VS_FULL
- void sanity_check(const std::vector<IdentifierHash>& input_hash_ids, const std::vector<IdentifierHash>& hash_ids_withData, std::ostream& outfile);
-#endif
-
- void unpackTimers( std::vector<TrigTimer*>& timers, unsigned int firstIndex,
- TrigTimer*& dataPrepTime, TrigTimer*& algTime, TrigTimer*& dataOutputTime );
-
- // Region Selector
- ServiceHandle<IRegSelSvc> m_regionSelector; //<! pointer to RegionSelectionSvc
-
- // Pointers to sub-algoritms
- ToolHandle<Muon::IMooSegmentCombinationFinder> m_segmentsFinderTool; //<! pointer to the segment finder
- ToolHandle<Muon::IMuonPatternSegmentAssociationTool> m_assocTool; //<! pointer to association tool
- ToolHandle<Muon::IMuonTrackFinder> m_trackBuilderTool; //<! pointer to the track finder in the 3rd chain implementation
-
- ToolHandle<Trk::ITrackSummaryTool > m_trackSummaryTool;
-
- // handles to the RoI driven data access
- ToolHandle<Muon::IMuonRawDataProviderTool> m_mdtRawDataProvider;
- ToolHandle<Muon::IMuonRawDataProviderTool> m_rpcRawDataProvider;
- ToolHandle<Muon::IMuonRawDataProviderTool> m_tgcRawDataProvider;
- ToolHandle<Muon::IMuonRawDataProviderTool> m_cscRawDataProvider;
- ToolHandle<Muon::IMuonRdoToPrepDataTool> m_cscPrepDataProvider;
- ToolHandle<Muon::IMuonRdoToPrepDataTool> m_mdtPrepDataProvider;
- ToolHandle<Muon::IMuonRdoToPrepDataTool> m_rpcPrepDataProvider;
- ToolHandle<Muon::IMuonRdoToPrepDataTool> m_tgcPrepDataProvider;
- ToolHandle<ICscClusterBuilder> m_cscClusterProvider;
-
- // Cache the ActiveStoreSvc ptr
- ActiveStoreSvc* p_ActiveStore;
-
- ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
-
- //Cache Rob Lists
- std::vector<uint32_t> m_MdtRobList;
- std::vector<uint32_t> m_RpcRobList;
- std::vector<uint32_t> m_TgcRobList;
- std::vector<uint32_t> m_CscRobList;
-
- bool m_HasMdtRobList;
- bool m_HasRpcRobList;
- bool m_HasTgcRobList;
- bool m_HasCscRobList;
-
- // true before first event done (used to initialize in first event)
- bool m_firstEvent;
-
- // job-opt properties
-
- // if true do caching
- bool m_doCache;
-
- // Flag to decide whether or not to run BS decoding
- Gaudi::Property< bool > m_decodeMdtBS { this, "DecodeMdtBS", true, "Flag to decide whether or not to run BS->RDO decoding for MTDs" };
- Gaudi::Property< bool > m_decodeRpcBS { this, "DecodeRpcBS", true, "Flag to decide whether or not to run BS->RDO decoding for RPCs" };
- Gaudi::Property< bool > m_decodeTgcBS { this, "DecodeTgcBS", true, "Flag to decide whether or not to run BS->RDO decoding for TGCs" };
- Gaudi::Property< bool > m_decodeCscBS { this, "DecodeCscBS", true, "Flag to decide whether or not to run BS->RDO decoding for CSCs" };
-
- bool m_useCscData;
- bool m_useRpcData;
- bool m_useTgcData;
- bool m_useTGCInPriorNextBC;
- unsigned int m_useMdtData;
-
-
- // decoding options
- bool m_useMdtSeededDecoding;
- bool m_useRpcSeededDecoding;
- bool m_useTgcSeededDecoding;
- bool m_useCscSeededDecoding;
- bool m_useTgcRobDecoding;
- bool m_useCscRobDecoding;
-
- // timeout awareness
- bool m_doTimeOutChecks;
-
- // timeout guard (checks on number of hits)
- bool m_doTimeOutGuard;
-
- //Use L2 hits
- bool m_useL2Hits;
-
- // conditions to prevent events with excessive processing times
- int m_maxCscHits;
- int m_maxMdtHits;
- int m_maxRpcHits;
- int m_maxTgcHits;
-
-
- //Map to cache
- std::map<std::vector<std::vector<IdentifierHash> >, SegmentCache*> m_SFCacheSCMap;
-
- // list of IdentifierHash for PRD in RoI
- std::vector<std::vector<IdentifierHash> > m_hashlist;
-
- // features written to TriggerElement
- // TrigMuonEFInfoContainer* m_myMuonEFInfoCont;
- const MuonPatternCombinationCollection* m_patternCombiColl;
- const Trk::SegmentCollection* m_segments;
- const TrackCollection* m_spectrometerTracks;
- const MuonPatternCombinationCollection* m_patternCombiCollInternal;
- const Trk::SegmentCollection* m_segmentsInternal;
- const TrackCollection* m_spectrometerTracksInternal;
- TrackCollection* m_extrapolatedTracks;
- xAOD::TrackParticleContainer* m_spectrometerTrackParticles;
- xAOD::TrackParticleAuxContainer* m_spectrometerTrackParticlesAux;
- unsigned short int m_roi_num_seg;
- unsigned short int m_roi_num_mstrk;
- unsigned short int m_roi_num_satrk;
-
- unsigned int m_totalSegmentCalls;
- unsigned int m_cachedSegmentCalls;
- unsigned int m_totalSpectrometerCalls;
- unsigned int m_cachedSpectrometerCalls;
- unsigned int m_totalExtrapolatedCalls;
- unsigned int m_cachedExtrapolatedCalls;
-
- // tracks stored in cache for deletion at end of event
- std::vector<const TrackCollection*> m_spectrometerTracksCache;
- std::vector<TrackCollection*> m_extrapolatedTracksCache;
- std::vector<const MuonPatternCombinationCollection*> m_patternCombisCache;
- std::vector<const Trk::SegmentCollection*> m_segmentsCache;
- std::vector<Muon::MdtPrepDataCollection*> m_mdtcollCache;
-
-
- /// tool to create muon candidates
- ToolHandle<MuonCombined::IMuonCandidateTool> m_muonCandidateTool;
-
- /// tool to create track particles from Trk::Tracks
- ToolHandle<Trk::ITrackParticleCreatorTool> m_TrackToTrackParticleConvTool;
-
-#if DEBUG_ROI_VS_FULL
- std::ofstream m_fileWithHashIds_rpc;
- std::ofstream m_fileWithHashIds_tgc;
- std::ofstream m_fileWithHashIds_mdt;
- std::ofstream m_fileWithHashIds_csc;
-#endif
-
- SG::ReadHandleKey <Muon::RpcPrepDataContainer> m_rpcKey;
- SG::ReadHandleKey <Muon::TgcPrepDataContainer> m_tgcKey;
- SG::ReadHandleKey <Muon::TgcPrepDataContainer> m_tgcKeyNextBC;
- SG::ReadHandleKey <Muon::MdtPrepDataContainer> m_mdtKey;
-
- //write handle for CSC cluster container
- SG::WriteHandleKey <Muon::CscPrepDataContainer> m_cscClustersKey{this, "CscClusterContainer", "CSC_Clusters", "Output CSC Cluster container"};
-
- bool m_ignoreCSC;
- ToolHandle<Muon::IMuonSegmentOverlapRemovalTool> m_segmentOverlapRemovalTool;
- SG::ReadCondHandleKey<MuonMDT_CablingMap> m_mdtCablingKey{this, "MdtCablingKey", "MuonMDT_CablingMap", "Key of MuonMDT_CablingMap"};
-
-};
-
-#endif // TRIGMUONEF_TRIGMUONEFSTANDALONETRACKTOOL_H
-
diff --git a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFTrackIsolation.cxx b/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFTrackIsolation.cxx
deleted file mode 100644
index e0d55a4d761cd3c982be583f1224af1afbbc6f98..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFTrackIsolation.cxx
+++ /dev/null
@@ -1,320 +0,0 @@
-/*
- Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-*/
-
-#include "TrigConfHLTData/HLTTriggerElement.h"
-#include "TrigTimeAlgs/TrigTimerSvc.h"
-
-#include "TrigMuonToolInterfaces/IMuonEFTrackIsolationTool.h"
-#include "TrigMuonEFTrackIsolation.h"
-
-#include "FourMomUtils/P4Helpers.h"
-
-// edm includes
-#include "Particle/TrackParticleContainer.h"
-#include "xAODMuon/MuonContainer.h"
-
-#include <iostream>
-
-using Rec::TrackParticleContainer;
-using Rec::TrackParticle;
-
-using std::endl;
-
-// ------------------------------------------------------------------------------------------------------
-/**
- * Standard constructor for the track isolation algo.
- */
-TrigMuonEFTrackIsolation::TrigMuonEFTrackIsolation(const std::string& name, ISvcLocator* pSvcLocator) :
- FexAlgo(name, pSvcLocator),
- m_requireCombined(false),
- m_useVarIso(false),
- m_muonContName("MuonEFInfo"),
- m_debug(false),
- m_coneSizes(),
- m_efIsoTool("TrigMuonEFTrackIsolationTool/TrigMuonEFTrackIsolationTool", this),
-
- m_trkptiso_cone2(),
- m_trkptiso_cone3(),
- m_trkdz(),
- m_trkdr(),
- m_muon_selfpt(),
- m_muon_removedpt(),
- m_muon_combinedpt(),
- m_n_trks(),
-
- m_doMyTiming(false),
- m_dataPrepTime(0),
- m_calcTime(0),
- m_dataOutputTime(0){
-
-
- declareProperty("IsolationTool", m_efIsoTool);
- declareProperty("MuonContName", m_muonContName);
- declareProperty("IdTrackParticles", m_idTrackParticlesName);
- declareProperty("doMyTiming", m_doMyTiming);
- declareProperty("requireCombinedMuon", m_requireCombined);
- declareProperty("useVarIso", m_useVarIso);
-
-
- ///////// Monitoring Variables
- declareProperty("histoPathBase",m_histo_path_base="/EXPERT/");
- declareMonitoredStdContainer("trks_trkptiso_cone2", m_trkptiso_cone2, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("trks_trkptiso_cone3", m_trkptiso_cone3, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("trks_trkdz", m_trkdz, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("trks_trkdr", m_trkdr, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("n_trks", m_n_trks, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("muon_selfpt", m_muon_selfpt, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("muon_removedpt", m_muon_removedpt, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("muon_combinedpt", m_muon_combinedpt, IMonitoredAlgo::AutoClear);
-
- // cone sizes are hard-coded to ensure the correct result goes to the edm
- m_coneSizes.push_back(0.2);
- m_coneSizes.push_back(0.3);
-}
-
-// ------------------------------------------------------------------------------------------------------
-/**
- * Detructor
- */
-TrigMuonEFTrackIsolation::~TrigMuonEFTrackIsolation() {
-
-}
-
-// ------------------------------------------------------------------------------------------------------
-/**
- * Initialize the algo
- */
-HLT::ErrorCode TrigMuonEFTrackIsolation::hltInitialize() {
-
- m_debug = msgLvl() <= MSG::DEBUG;
-
- if(m_debug) {
- msg() << MSG::DEBUG << "Initializing TrigMuonEFTrackIsolation[" << name() << "]" << endmsg;
- msg() << MSG::DEBUG
- << "package version = " << PACKAGE_VERSION << endmsg;
- msg() << MSG::DEBUG
- << "Properties set as follows: " << endmsg;
- msg() << MSG::DEBUG
- << "Track isolation tool: " << m_efIsoTool << endmsg;
- msg() << MSG::DEBUG
- << "IdTrackParticles: " << m_idTrackParticlesName << endmsg;
- msg() << MSG::DEBUG
- << "requireCombinedMuon: " << m_requireCombined << endmsg;
- msg() << MSG::DEBUG
- << "doMyTiming " << m_doMyTiming << endmsg;
- msg() << MSG::DEBUG
- << "useVarIso " << m_useVarIso << endmsg;
-
- }//debug
-
- StatusCode sc = m_efIsoTool.retrieve();
- if(sc.isSuccess()) {
- msg() << MSG::INFO << "Retrieved " << m_efIsoTool << endmsg;
- } else {
- msg() << MSG::FATAL << "Could not retrieve " << m_efIsoTool << endmsg;
- return HLT::BAD_JOB_SETUP;
- }
-
- if(m_doMyTiming){
- msg() << MSG::INFO << "Running Timing for IsoTool" << endmsg;
- m_dataPrepTime = addTimer("dataPrepTime");
- m_calcTime = addTimer("calcTime");
- m_dataOutputTime = addTimer("dataOutputTime");
- msg() << MSG::INFO << "Timers: " << m_dataPrepTime << " " << m_calcTime << " " << m_dataOutputTime << endmsg;
- }
-
- if (m_debug) msg() << MSG::DEBUG
- << "End of init TrigMuonEFTrackIsolation" << endmsg;
- return HLT::OK;
-
-}
-
-// ------------------------------------------------------------------------------------------------------
-/**
- * Execute function - called for each roi
- */
-HLT::ErrorCode
-TrigMuonEFTrackIsolation::hltExecute(const HLT::TriggerElement* inputTE, HLT::TriggerElement* TEout) {
-
- if(m_doMyTiming && m_dataPrepTime) m_dataPrepTime->start();
-
- if (m_debug) msg() << MSG::DEBUG
- << ": Executing TrigMuonEFTrackIsolation::execHLTAlgorithm()" << endmsg;
-
- // prepare output
- auto muonContainer = std::make_unique<xAOD::MuonContainer>();
- xAOD::MuonAuxContainer muonAuxContainer;
- muonContainer->setStore( &muonAuxContainer );
- ATH_MSG_DEBUG("Created xAOD::MuonContainer");
-
- // Get ID Track & EF Muons
- const xAOD::TrackParticleContainer* idTrackParticles = 0;
- const xAOD::MuonContainer* EFmuonContainer(0);
-
- // ID Tracks
- HLT::ErrorCode hltStatus = getFeature(inputTE, idTrackParticles, m_idTrackParticlesName);
- if (hltStatus != HLT::OK) {
- msg() << MSG::WARNING << "Failed to retrieve inner detector track particles" << endmsg;
- return hltStatus;
- }
- if(!idTrackParticles) {
- std::string label;
- std::string inlabel;
- TrigConf::HLTTriggerElement::getLabel (TEout->getId(), label );
- TrigConf::HLTTriggerElement::getLabel (inputTE->getId(), inlabel );
- msg() << MSG::WARNING << "Pointer to xAOD::TrackParticleContainer[" << m_idTrackParticlesName << "] for id tracks = 0, stopping processing of ROI" << endmsg;
- msg() << MSG::WARNING << "Input TE = " << inlabel << ", Output TE = " << label << endmsg;
- return HLT::MISSING_FEATURE;
- } else {
- if(m_debug) msg() << MSG::DEBUG << "Inner detector track particles retrieved with size: " << idTrackParticles->size() << endmsg;
- } // Get ID tracks
-
- // EF Muons
- if(HLT::OK != getFeature(inputTE, EFmuonContainer)) {
- ATH_MSG_WARNING("Could not get xAOD::MuonContainer from the trigger element");
- return HLT::MISSING_FEATURE;
- } else {
- if(!EFmuonContainer) {
- ATH_MSG_WARNING("muonContainer is 0 pointer");
- return HLT::MISSING_FEATURE;
- }
- ATH_MSG_DEBUG("EF MuonContainer extracted with size = " << EFmuonContainer->size());
-
- } // Get EF Muons
-
-
-
- if(m_doMyTiming){
- if (m_dataPrepTime) m_dataPrepTime->stop();
- if (m_calcTime) m_calcTime->start();
- }
-
- // loop on EF muons
- for(auto muon : *EFmuonContainer) {
- if(m_debug) {
- msg() << MSG::DEBUG << "Processing next EF muon w/ ID Track Isolation " << muon << endmsg;
- }
- const xAOD::Muon::MuonType muontype = muon->muonType();
- if( muontype == xAOD::Muon::MuonType::Combined || muontype == xAOD::Muon::MuonType::SegmentTagged ) {
- if(m_debug) {
- msg() << MSG::DEBUG << "EF muon has combined or segment tagged muon" << endmsg;
- }
- } else {
- if(m_requireCombined) {
- if(m_debug) {
- msg() << MSG::DEBUG << "Not a combined or segment tagged muon & requireCombined=true, so ignore this muon" << endmsg;
- }
- continue;
- }//requireCombined
- else{
- if( muontype == xAOD::Muon::MuonType::MuonStandAlone ){
- if(m_debug) {
- msg() << MSG::DEBUG << "EF muon has standalone muon" << endmsg;
- }
- }
- else{
- if(m_debug) {
- msg() << MSG::DEBUG << "EF muon has neither combined, segment tagged, nor standalone muon" << endmsg;
- }
- continue;
- }
- }
- }//no combined muon
-
- std::vector<double> isoResults;
- std::vector<double> dzvals; // for monitoring
- std::vector<double> drvals; // for monitoring
- std::vector<double> selfremoval;
-
- // use the tool to calculate the isolation
- // ID tracks
- if (m_debug)
- msg() << MSG::DEBUG << "Running ID Tracks now" << endmsg;
- StatusCode result = m_efIsoTool->calcTrackIsolation( muon, idTrackParticles, m_coneSizes, isoResults, &dzvals, &drvals, &selfremoval);
-
- m_trkdz.insert(m_trkdz.begin(), dzvals.begin(), dzvals.end());
- m_trkdr.insert(m_trkdr.begin(), drvals.begin(), drvals.end());
-
- if (selfremoval.size() == 2)
- {
- m_muon_selfpt.push_back(selfremoval[0] * 1e-3);
- m_muon_combinedpt.push_back(selfremoval[1] * 1e-3);
- }
- else
- msg() << MSG::DEBUG << "Muon pT not stored correctly - histograms have not been filled for this muon" << endmsg;
-
- if(result.isFailure() || isoResults.size() != 2) {
- if(result.isFailure()) {
- msg() << MSG::WARNING << "Isolation tool failed for this muon - isolation will not be set for this muon" << endmsg;
- } else {
- if(isoResults.size() != 2) {
- msg() << MSG::WARNING << "Wrong number of isolation results - isolation will not be set for this muon." << endmsg;
- }
- }
- } else { //isolation tool was ok - store results
-
- const float ptcone20 = isoResults[0];
- const float ptcone30 = isoResults[1];
-
- m_trkptiso_cone2.push_back(ptcone20 * 1e-3); // convert to GeV
- m_trkptiso_cone3.push_back(ptcone30 * 1e-3); // convert to GeV
-
- // deep copy muon (since otherwise we risk overwriting isolation results from other algos)
- muonContainer->push_back( new xAOD::Muon(*muon) );
- xAOD::Muon* outputmuon = muonContainer->back();
-
- if (m_useVarIso){
- outputmuon->setIsolation( ptcone20, xAOD::Iso::ptvarcone20 );
- outputmuon->setIsolation( ptcone30, xAOD::Iso::ptvarcone30 );
- } else {
- outputmuon->setIsolation( ptcone20, xAOD::Iso::ptcone20 );
- outputmuon->setIsolation( ptcone30, xAOD::Iso::ptcone30 );
- }
- }// isolation tool ok for ID
- }// EF Muon Loop
-
- const size_t noutputMuons = muonContainer->size();
- hltStatus = attachFeature(TEout, muonContainer.release() , m_muonContName);
- if(hltStatus!=HLT::OK) {
- msg() << MSG::WARNING << "Attaching xAOD::MuonContainer to TEout: unsuccessful" << endmsg;
- return hltStatus;
- } else {
- ATH_MSG_DEBUG( "Successfully attached to TEout the muon container with size " << noutputMuons );
- }
-
-
-
-
- if(m_doMyTiming){
- if(m_calcTime) m_calcTime->stop();
- if(m_dataOutputTime) m_dataOutputTime->start();
- }
-
- m_n_trks.push_back(idTrackParticles->size());
-
- //validate sequence
- TEout->setActiveState(true);
- if(m_doMyTiming && m_dataOutputTime){
- m_dataOutputTime->stop();
- }
- return HLT::OK;
-
-}//hltExecute
-
-HLT::ErrorCode TrigMuonEFTrackIsolation:: hltFinalize()
-{
- if (m_debug)
- msg() << MSG::DEBUG << "Finalizing TrigMuonEFTrackIsolation" << endmsg;
-
- return HLT::OK;
-}
-
-/**
- * Here we can handle incidents like end of event, but for now
- * nothing to do.
- */
-void TrigMuonEFTrackIsolation::handle(const Incident& /*inc*/)
-{
-
-}
diff --git a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFTrackIsolation.h b/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFTrackIsolation.h
deleted file mode 100644
index 51c96e4860bb67717dc887d2554d20d755a17926..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFTrackIsolation.h
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
- Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-*/
-
-#ifndef TRIGMUONEF_TRIGMUONEFTRACKISOLATION_H__
-#define TRIGMUONEF_TRIGMUONEFTRACKISOLATION_H__
-
-#include "TrigInterfaces/FexAlgo.h"
-#include "GaudiKernel/IIncidentListener.h"
-#include "GaudiKernel/ToolHandle.h"
-
-// fwd declare EF track isolation tool interface
-class IMuonEFTrackIsolationTool;
-
-/**
- * @class TrigMuonEFTrackIsolation
- *
- * @brief Algorithm to extract track isolation for EF muons
- *
- * This class calculates track isolation for EF muons.
- * It uses the IMuonEFTrackIsolationTool tool interface for
- * the actual isolation calculation.
- *
- *
- * @author Mark Owen (markowen@cern.ch)
- * @author Michael Fenton (m.fenton@cern.ch
- */
-class TrigMuonEFTrackIsolation : public virtual HLT::FexAlgo,
- public virtual IIncidentListener
-{
- public:
-
- /// Constructor
- TrigMuonEFTrackIsolation (const std::string& name, ISvcLocator* pSvcLocator);
- /// Destructor
- ~TrigMuonEFTrackIsolation();
-
- /// Initialize the algorithm
- HLT::ErrorCode hltInitialize();
- /// Execute - called per trigger element
- HLT::ErrorCode hltExecute(const HLT::TriggerElement*, HLT::TriggerElement*);
- /// Finalize the algorithm
- HLT::ErrorCode hltFinalize();
-
- private:
-
- /// name of ID Track Particle container
- std::string m_idTrackParticlesName;
-
- /// Require that EF muons are combined (should move to pass bits)
- bool m_requireCombined;
-
- /// Use offline isolation variables
- bool m_useVarIso;
-
- /// Name of output muon container
- std::string m_muonContName;
-
- /// flag to see if debug is enabled
- bool m_debug;
-
- /// cone sizes to calculate the isolation
- std::vector<double> m_coneSizes;
-
- /// Tool handle for isolation tool
- ToolHandle<IMuonEFTrackIsolationTool> m_efIsoTool;
-
- //// Monitoring Histograms
- StringProperty m_histo_path_base; // set the histo path for Monitoring
- std::vector<double> m_trkptiso_cone2;
- std::vector<double> m_trkptiso_cone3;
- std::vector<double> m_trkdz;
- std::vector<double> m_trkdr;
- std::vector<double> m_muon_selfpt;
- std::vector<double> m_muon_removedpt;
- std::vector<double> m_muon_combinedpt;
- std::vector<int> m_n_trks;
-
- //Timers
- bool m_doMyTiming;
- TrigTimer* m_dataPrepTime;
- TrigTimer* m_calcTime;
- TrigTimer* m_dataOutputTime;
-
- void handle(const Incident &);
-
-}; //class TrigMuonEFTrackIsolation
-
-#endif //TRIGMUONEF_TRIGMUONEFTRACKISOLATION_H__
diff --git a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFUtils.icc b/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFUtils.icc
deleted file mode 100644
index 1b60742ba1db3b49356bd6cdf4106be4265128f1..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuonEF/src/TrigMuonEFUtils.icc
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-// dear emacs this is -*-c++-*-
-
-#ifndef TRIGMUONEF_TRIGMUONEFUTILS_ICC_
-#define TRIGMUONEF_TRIGMUONEFUTILS_ICC_
-
-// Small file with some helper functions used in TrigMuonEF classes
-
-namespace {
-
- inline double getFraction( unsigned int part, unsigned int total ) {
- if ( total == 0 ) return 0.0;
- return ((double)part) / ((double)total);
- }
-
- template<class T>
- inline T* makeViewContainerClone( T* orig ) {
- return new T( orig->begin(), orig->end(), SG::VIEW_ELEMENTS);
- }
-
- // delete all entries in cache vector, and clear the vector
- template <class T>
- void clearCacheVector( std::vector<T*>& cache ) {
- typename std::vector<T*>::iterator it = cache.begin(), it_end = cache.end();
- for ( ; it != it_end; ++it ) delete *it;
- cache.clear();
- }
-
- template <class T>
- bool addElement( std::vector<T>& v, T& e ) {
- typename std::vector<T>::iterator it = std::find( v.begin(), v.end(), e );
- if ( it == v.end() ) {
- v.push_back( e );
- return true;
- }
- return false;
- }
-
- template <class T>
- bool removeElement( std::vector<T>& v, T& e ) {
- typename std::vector<T>::iterator it = std::find( v.begin(), v.end(), e );
- if ( it != v.end() ) {
- v.erase( it );
- return true;
- }
- return false;
- }
-
-
-} // end of unnamed namespace for private local functions
-
-#endif //TRIGMUONEF_TRIGMUONEFUTILS_ICC_
diff --git a/Trigger/TrigAlgorithms/TrigMuonEF/src/components/TrigMuonEF_entries.cxx b/Trigger/TrigAlgorithms/TrigMuonEF/src/components/TrigMuonEF_entries.cxx
index 85becf366a149dcf2378008d0a5afa0c7643f659..3ee075a179e5c65cea1139fb0c98a8dcf33a552f 100644
--- a/Trigger/TrigAlgorithms/TrigMuonEF/src/components/TrigMuonEF_entries.cxx
+++ b/Trigger/TrigAlgorithms/TrigMuonEF/src/components/TrigMuonEF_entries.cxx
@@ -1,24 +1,10 @@
#include "../TrigMuonEFTrackIsolationTool.h"
-#include "../TrigMuonEFTrackIsolation.h"
-#include "../TrigMuonEFStandaloneTrackTool.h"
-#include "../TrigMuonEFRoiAggregator.h"
-#include "../TrigMuonEFFSRoiMaker.h"
-#include "../InDetTrkRoiMaker.h"
-#include "../TrigMuonEFCaloIsolation.h"
-#include "../TrigMuonEFIDTrackRoiMaker.h"
#include "../TrigMuonEFTrackIsolationAlgMT.h"
#include "../MuonFilterAlg.h"
#include "../MuonChainFilterAlg.h"
#include "../MergeEFMuonsAlg.h"
DECLARE_COMPONENT( TrigMuonEFTrackIsolationTool )
-DECLARE_COMPONENT( TrigMuonEFStandaloneTrackTool )
-DECLARE_COMPONENT( TrigMuonEFTrackIsolation )
-DECLARE_COMPONENT( TrigMuonEFRoiAggregator )
-DECLARE_COMPONENT( InDetTrkRoiMaker )
-DECLARE_COMPONENT( TrigMuonEFCaloIsolation )
-DECLARE_COMPONENT( TrigMuonEFFSRoiMaker )
-DECLARE_COMPONENT( TrigMuonEFIDTrackRoiMaker )
DECLARE_COMPONENT( TrigMuonEFTrackIsolationAlgMT )
DECLARE_COMPONENT( MuonFilterAlg )
DECLARE_COMPONENT( MuonChainFilterAlg )