diff --git a/Trigger/TrigAlgorithms/TrigMuSuperEF/ATLAS_CHECK_THREAD_SAFETY b/Trigger/TrigAlgorithms/TrigMuSuperEF/ATLAS_CHECK_THREAD_SAFETY
deleted file mode 100644
index b3ed46b4372bbd5d2d7e9dc07118e72fcb51257e..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuSuperEF/ATLAS_CHECK_THREAD_SAFETY
+++ /dev/null
@@ -1 +0,0 @@
-Trigger/TrigAlgorithms/TrigMuSuperEF
diff --git a/Trigger/TrigAlgorithms/TrigMuSuperEF/CMakeLists.txt b/Trigger/TrigAlgorithms/TrigMuSuperEF/CMakeLists.txt
deleted file mode 100644
index 78eb5422cf181c05454ae8f89cd99d90d0c12358..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuSuperEF/CMakeLists.txt
+++ /dev/null
@@ -1,13 +0,0 @@
-# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-
-# Declare the package name:
-atlas_subdir( TrigMuSuperEF )
-
-# Component(s) in the package:
-atlas_add_component( TrigMuSuperEF
- src/*.cxx
- src/components/*.cxx
- LINK_LIBRARIES AthenaKernel CaloEvent FourMomUtils GaudiKernel MuidEvent MuonCombinedEvent MuonCombinedToolInterfaces MuonPattern MuonRecToolInterfaces MuonSegment Particle TrigConfHLTData TrigInterfacesLib TrigMuonEvent TrigMuonToolInterfaces TrigNavigationLib TrigSteeringEvent TrigT1Interfaces TrigTimeAlgsLib TrkSegment TrkToolInterfaces xAODMuon xAODTracking )
-
-# 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/TrigMuSuperEF/python/TrigMuSuperEFConfig.py b/Trigger/TrigAlgorithms/TrigMuSuperEF/python/TrigMuSuperEFConfig.py
deleted file mode 100644
index 38cb03db20b3d3ebe3ceafa7884e1da77ad22fa4..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuSuperEF/python/TrigMuSuperEFConfig.py
+++ /dev/null
@@ -1,297 +0,0 @@
-# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-
-from TriggerJobOpts.TriggerFlags import TriggerFlags
-from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
-from .TrigMuSuperEFMonitoring import TrigMuSuperEFMonitoring,TrigMuSuperEFValidationMonitoring
-from TrigMuonEF.TrigMuonEFMonitoring import TrigMuonEFStandaloneToolMonitoring,TrigMuonEFCombinerToolMonitoring,TrigMuonEFStandaloneToolValidationMonitoring,TrigMuonEFCombinerToolValidationMonitoring
-
-from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFCombinerHypoConfig
-from .TrigMuSuperEFConf import TrigMuSuperEF
-
-from AthenaCommon.CfgGetter import getPublicTool
-from AthenaCommon import CfgMgr
-
-#
-# Default config: RoI based, Combined, TrigMuonEF only
-# Old default: RoI based, Combined, TrigMuonEF first, TrigMuGirl is TrigMuonEF fails. Should be put back once TrigMuGirl is back in release
-#
-class TrigMuSuperEFConfig(TrigMuSuperEF):
- __slots__ = ()
-
- def __init__(self,name="TrigMuSuperEF",**kwargs):
- kwargs.setdefault("doInsideOut", True)
- kwargs.setdefault("doOutsideIn", True)
- kwargs.setdefault("insideOutFirst", False)
- kwargs.setdefault("fullScan", False)
- kwargs.setdefault("StandaloneOnly", False)
- kwargs.setdefault("CombinerOnly", False)
- kwargs.setdefault("CaloTagOnly", False)
- kwargs.setdefault("TMEF_standaloneTrackTool", "TrigMuonEFStandaloneTrackTool")
- kwargs.setdefault("MuonCombinedTool","TMEF_MuonCombinedTool")
- kwargs.setdefault("TrkToTrackParticleConvTool","TMEF_TrkToTrackParticleConvTool")
- kwargs.setdefault("MuonCreatorTool","TMEF_MuonCreatorTool")
- kwargs.setdefault("deltaEtaRoI",0.2)
- kwargs.setdefault("deltaPhiRoI",0.2)
- kwargs.setdefault("UseL2Info",False)
- kwargs.setdefault("DoCache", True)
-
- from TrkExTools.AtlasExtrapolator import AtlasExtrapolator
- from TrackToCalo.TrackToCaloConf import Trk__ParticleCaloExtensionTool
-
- from MuonTGRecTools.MuonTGRecToolsConf import Muon__MuonSystemExtensionTool
- pcExtensionTool = Trk__ParticleCaloExtensionTool(Extrapolator = AtlasExtrapolator())
-
- muonExtTool = Muon__MuonSystemExtensionTool(Extrapolator = AtlasExtrapolator(),
- ParticleCaloExtensionTool = pcExtensionTool)
- kwargs.setdefault("MuonSystemExtensionTool", muonExtTool)
-
- doTrigMuonEF = kwargs["doOutsideIn"]
- doTrigMuGirl = kwargs["doInsideOut"]
- doStandaloneOnly = kwargs["StandaloneOnly"]
- combinerOnly = kwargs["CombinerOnly"]
-
- # turn on seeded data decoding by default
- TriggerFlags.MuonSlice.doEFRoIDrivenAccess = True
-
- # make instance
- super(TrigMuSuperEFConfig,self).__init__(name,**kwargs)
-
- # setup monitoring depending on configuration
- monTools = []
- # top level histograms use Combined Muons
- if not doStandaloneOnly:
- monTools.append( TrigMuSuperEFMonitoring() )
- monTools.append( TrigMuSuperEFValidationMonitoring() )
- # only add TrigMuonEF monitoring if it is run
- if doTrigMuonEF:
- if not combinerOnly:
- monTools.append( TrigMuonEFStandaloneToolMonitoring() )
- monTools.append( TrigMuonEFStandaloneToolValidationMonitoring() )
- if not doStandaloneOnly:
- monTools.append( TrigMuonEFCombinerToolMonitoring() )
- monTools.append( TrigMuonEFCombinerToolValidationMonitoring() )
-
- from AthenaCommon.CfgGetter import getPublicTool,getPublicToolClone
- self.StauCreatorTool = getPublicToolClone("TMEF_StauCreatorTool","TMEF_MuonCreatorTool",BuildStauContainer=True)
- # only add TrigMuGirl monitoring if it is run
- if doTrigMuGirl:
- self.MuGirlTool = getPublicTool("TMEF_MuonInsideOutRecoTool")
-
- if self.UseL2Info:
- self.TMEF_standaloneTrackTool.useL2Hits=True
- else:
- self.TMEF_standaloneTrackTool.useL2Hits=False
-
-
- # always add timing monitoring
- timetool = TrigTimeHistToolConfig("Time")
- timetool.NumberOfHistBins = 100
- timetool.TimerHistLimits = [0,1000]
- monTools.append( timetool )
-
- self.AthenaMonTools = monTools
- # end of __init__
-
-
-#
-# Several pre-configured RoI based variations
-#
-def TrigMuSuperEF(name="TrigMuSuperEF",**kwargs):
- return TrigMuSuperEFConfig(name,**kwargs)
-
-def TrigMuSuperEF_MGfirst(name="TrigMuSuperEF_MGfirst",**kwargs):
-
- kwargs.setdefault("doInsideOut", True)
- kwargs.setdefault("doOutsideIn", True)
- kwargs.setdefault("insideOutFirst", True)
- return TrigMuSuperEFConfig(name,**kwargs)
-
-
-def TrigMuSuperEF_TMEFfirst(name="TrigMuSuperEF_TMEFfirst",**kwargs):
- kwargs.setdefault("doInsideOut", True)
- kwargs.setdefault("doOutsideIn", True)
- kwargs.setdefault("insideOutFirst", False)
- return TrigMuSuperEFConfig(name,**kwargs)
-
-
-def TrigMuSuperEF_MGonly(name="TrigMuSuperEF_MGonly",**kwargs):
- kwargs.setdefault("doInsideOut", True)
- kwargs.setdefault("doOutsideIn", False)
- kwargs.setdefault("UseL2Info",False)
- kwargs.setdefault("DoCache", False)
- kwargs.setdefault("MuGirlTool", getPublicTool("TMEF_MuonStauRecoTool"))
- return TrigMuSuperEFConfig(name,**kwargs)
-
-
-def TrigMuSuperEF_TMEFonly(name="TrigMuSuperEF_TMEFonly",**kwargs):
- kwargs.setdefault("doInsideOut", False)
- kwargs.setdefault("doOutsideIn", True)
- kwargs.setdefault("UseL2Info",False)
- return TrigMuSuperEFConfig(name,**kwargs)
-
-
-def TrigMuSuperEF_both(name="TrigMuSuperEF_both",**kwargs):
- kwargs.setdefault("doInsideOut", True)
- kwargs.setdefault("doOutsideIn", True)
- kwargs.setdefault("forceBoth", True)
- return TrigMuSuperEFConfig(name,**kwargs)
-
-
-def TrigMuSuperEF_SAonly(name="TrigMuSuperEF_SAonly",**kwargs):
- kwargs.setdefault("doInsideOut", False)
- kwargs.setdefault("doOutsideIn", True)
- kwargs.setdefault("StandaloneOnly", True)
- return TrigMuSuperEFConfig(name,**kwargs)
-
-def TrigMuSuperEF_STonly(name="TrigMuSuperEF_STonly",**kwargs):
- kwargs.setdefault("doInsideOut", False)
- kwargs.setdefault("doOutsideIn", True)
- kwargs.setdefault("SegmentTagOnly", True)
- return TrigMuSuperEFConfig(name,**kwargs)
-
-def TrigMuSuperEF_TMEFCombinerOnly(name="TrigMuSuperEF_TMEFCombinerOnly",**kwargs):
- kwargs.setdefault("doInsideOut", False)
- kwargs.setdefault("doOutsideIn", True)
- kwargs.setdefault("CombinerOnly", True)
- kwargs.setdefault("UseL2Info",False)
- kwargs.setdefault("ExtrapolatedTrackParticleContName", "MuonEFInfo_ExtrapTrackParticles_FullScan")
- kwargs.setdefault("MSonlyTrackParticleContName", "MuonEFInfo_MSonlyTrackParticles_FullScan")
- kwargs.setdefault("CBTrackParticleContName", "MuonEFInfo_CombTrackParticles_FullScan")
- kwargs.setdefault("MuonContName", "MuonEFInfo_FullScan" )
- if TriggerFlags.run2Config=='2016':
- kwargs.setdefault("DoCache", True)
- else:
- kwargs.setdefault("DoCache", False)
- return TrigMuSuperEFConfig(name,**kwargs)
-
-
-def TrigMuSuperEF_WideCone(name="TrigMuSuperEF_WideCone",**kwargs):
- kwargs.setdefault("deltaEtaRoI", 0.3)
- kwargs.setdefault("deltaPhiRoI", 0.3)
- kwargs.setdefault("IdTrackParticles", "InDetTrigTrackingxAODCnv_Muon_IDTrig")
- kwargs.setdefault("doInsideOut", False)
- kwargs.setdefault("doOutsideIn", True)
- kwargs.setdefault("StandaloneOnly", True)
- kwargs.setdefault("UseL2Info",False)
- kwargs.setdefault("ExtrapolatedTrackParticleContName", "MuonEFInfo_ExtrapTrackParticles_FullScan")
- kwargs.setdefault("MSonlyTrackParticleContName", "MuonEFInfo_MSonlyTrackParticles_FullScan")
- kwargs.setdefault("CBTrackParticleContName", "MuonEFInfo_CombTrackParticles_FullScan")
- kwargs.setdefault("MuonContName", "MuonEFInfo_FullScan" )
- return TrigMuSuperEFConfig(name,**kwargs)
-
-def TrigMuSuperEF_WideCone04(name="TrigMuSuperEF_WideCone04",**kwargs):
- kwargs.setdefault("deltaEtaRoI", 0.4)
- kwargs.setdefault("deltaPhiRoI", 0.4)
- kwargs.setdefault("IdTrackParticles", "InDetTrigTrackingxAODCnv_Muon_IDTrig")
- kwargs.setdefault("doInsideOut", False)
- kwargs.setdefault("doOutsideIn", True)
- kwargs.setdefault("StandaloneOnly", True)
- kwargs.setdefault("UseL2Info",False)
- kwargs.setdefault("ExtrapolatedTrackParticleContName", "MuonEFInfo_ExtrapTrackParticles_FullScan")
- kwargs.setdefault("MSonlyTrackParticleContName", "MuonEFInfo_MSonlyTrackParticles_FullScan")
- kwargs.setdefault("CBTrackParticleContName", "MuonEFInfo_CombTrackParticles_FullScan")
- kwargs.setdefault("MuonContName", "MuonEFInfo_FullScan" )
- return TrigMuSuperEFConfig(name,**kwargs)
-
-def TrigMuSuperEF_WideCone05(name="TrigMuSuperEF_WideCone05",**kwargs):
- kwargs.setdefault("deltaEtaRoI", 0.5)
- kwargs.setdefault("deltaPhiRoI", 0.5)
- kwargs.setdefault("IdTrackParticles", "InDetTrigTrackingxAODCnv_Muon_IDTrig")
- kwargs.setdefault("doInsideOut", False)
- kwargs.setdefault("doOutsideIn", True)
- kwargs.setdefault("StandaloneOnly", True)
- kwargs.setdefault("UseL2Info",False)
- kwargs.setdefault("ExtrapolatedTrackParticleContName", "MuonEFInfo_ExtrapTrackParticles_FullScan")
- kwargs.setdefault("MSonlyTrackParticleContName", "MuonEFInfo_MSonlyTrackParticles_FullScan")
- kwargs.setdefault("CBTrackParticleContName", "MuonEFInfo_CombTrackParticles_FullScan")
- kwargs.setdefault("MuonContName", "MuonEFInfo_FullScan" )
- return TrigMuSuperEFConfig(name,**kwargs)
-
-#
-# Full scan configs
-#
-def TrigMuSuperEF_FSCB(name="TrigMuSuperEF_FSCB",**kwargs):
- kwargs.setdefault("doInsideOut",False)
- kwargs.setdefault("doOutsideIn",True)
- kwargs.setdefault("fullScan",True)
- kwargs.setdefault("UseL2Info",False)
- kwargs.setdefault("ExtrapolatedTrackParticleContName", "MuonEFInfo_ExtrapTrackParticles_FullScan")
- kwargs.setdefault("MSonlyTrackParticleContName", "MuonEFInfo_MSonlyTrackParticles_FullScan")
- kwargs.setdefault("CBTrackParticleContName", "MuonEFInfo_CombTrackParticles_FullScan")
- kwargs.setdefault("MuonContName", "MuonEFInfo_FullScan" )
- return TrigMuSuperEFConfig(name,**kwargs)
-
-
-def TrigMuSuperEF_FSSA(name="TrigMuSuperEF_FSSA",**kwargs):
- kwargs.setdefault("StandaloneOnly",True)
- kwargs.setdefault("UseL2Info",False)
- kwargs.setdefault("ExtrapolatedTrackParticleContName", "MuonEFInfo_ExtrapTrackParticles_FullScan")
- kwargs.setdefault("MSonlyTrackParticleContName", "MuonEFInfo_MSonlyTrackParticles_FullScan")
- kwargs.setdefault("CBTrackParticleContName", "MuonEFInfo_CombTrackParticles_FullScan")
- kwargs.setdefault("MuonContName", "MuonEFInfo_FullScan" )
- #Turn off seeded decoding for full scan reconstruction
- from AthenaCommon.CfgGetter import getPublicToolClone
- kwargs.setdefault("TMEF_standaloneTrackTool", getPublicToolClone("TrigMuonEFStandaloneTrackToolFullScan", "TrigMuonEFStandaloneTrackTool",
- useMdtSeededDecoding=False, useRpcSeededDecoding=False, useTgcSeededDecoding=False, useCscSeededDecoding=False))
- return TrigMuSuperEF_FSCB(name,**kwargs)
-
-def TrigMuSuperEF_CTonly(name="TrigMuSuperEF_CTonly", **kwargs):
- kwargs.setdefault("CaloTagOnly", True)
- kwargs.setdefault("UseL2Info", False)
- kwargs.setdefault("fullScan", False)
- kwargs.setdefault("doInsideOut", True)
- kwargs.setdefault("doOutsideIn", False)
- kwargs.setdefault("IdTrackParticles", "InDetTrigTrackingxAODCnv_Muon_IDTrig")
- kwargs.setdefault("deltaEtaRoI", 0.1)
- kwargs.setdefault("deltaPhiRoI", 3.1415)
-
- return TrigMuSuperEFConfig(name, **kwargs)
-
-
-class TrigMuSuperEFHypoConfig(TrigMuonEFCombinerHypoConfig):
- __slots__ = ()
-
- # overwrite the __new__ of TrigMuonEFCombinerHypeConfig so we can set our own instance name
- def __new__( cls, *args, **kwargs ):
- newargs = ['%s_%s_%s' % (args[0],'Muon',args[1])] + list(args)
- # Note: skip the __new__ of TrigMuonEFCombinerHypeConfig, so go directly to its superclass !!!
- return super(TrigMuonEFCombinerHypoConfig, cls ).__new__( cls, *newargs, **kwargs )
-
-
-
-def TrigMuSuperEF_MuonCaloTagTool( name='OnlineMuonCaloTagTool', **kwargs ):
- from CaloTrkMuIdTools.CaloTrkMuIdToolsConf import CaloMuonTag as ConfiguredCaloMuonTag
- TrigMuSuperEF_CaloMuonTagLoose = ConfiguredCaloMuonTag(name = "TrigMuSuperEF_CaloMuonTagLoose")
- TrigMuSuperEF_CaloMuonTagLoose.TagMode="Loose"
- TrigMuSuperEF_CaloMuonTagTight = ConfiguredCaloMuonTag(name = "TrigMuSuperEF_CaloMuonTag")
- kwargs.setdefault("CaloMuonTagLoose", TrigMuSuperEF_CaloMuonTagLoose )
- kwargs.setdefault("CaloMuonTagTight", TrigMuSuperEF_CaloMuonTagTight )
- kwargs.setdefault("CaloMuonLikelihoodTool", getPublicTool("CaloMuonLikelihoodTool") )
- kwargs.setdefault("TrackDepositInCaloTool", getPublicTool("TrigMuSuperEF_TrackDepositInCaloTool") )
- kwargs.setdefault("TrackSelectorTool", getPublicTool("TrigMuSuperEF_CaloTrkSelectorTool") )
- kwargs.setdefault("TrackIsolationTool", None)
- kwargs.setdefault("DebugMode", False)
- kwargs.setdefault("doTrkSelection", True)
- kwargs.setdefault("doCaloLR", False)
- kwargs.setdefault("doOldExtrapolation", True)
- kwargs.setdefault("ShowTruth", False)
- kwargs.setdefault("CaloCells", "TrigCaloCellMaker")
- return CfgMgr.MuonCombined__MuonCaloTagTool(name,**kwargs )
-
-def TrigMuSuperEF_TrackDepositInCaloTool(name = "TrigMuSuperEF_TrackDepositInCaloTool", **kwargs):
- return CfgMgr.TrackDepositInCaloTool(name, **kwargs)
-
-def TrigMuSuperEF_CaloTrkSelectorTool( name = 'TrigMuSuperEF_CaloTrkSelectorTool', **kwargs):
-
- kwargs.setdefault("pTMin", 5000.)
- kwargs.setdefault("IPd0Max", 7)
- kwargs.setdefault("IPz0Max", 130) # 130 (tuned on Z)
- kwargs.setdefault("nHitBLayer", 0)
- kwargs.setdefault("nHitPix", 1)
- kwargs.setdefault("nHitSct", 5)
- kwargs.setdefault("nHitSi", 7)
- kwargs.setdefault("nHitTrt", 0)
- kwargs.setdefault("TrackSummaryTool", getPublicTool("TMEF_TrackSummaryTool"))
- kwargs.setdefault("Extrapolator", getPublicTool("AtlasExtrapolator") )
-
- return CfgMgr.InDet__InDetDetailedTrackSelectorTool( name, **kwargs )
diff --git a/Trigger/TrigAlgorithms/TrigMuSuperEF/python/TrigMuSuperEFConfigDb.py b/Trigger/TrigAlgorithms/TrigMuSuperEF/python/TrigMuSuperEFConfigDb.py
deleted file mode 100644
index ea3abd9210ae1c4a0719dcaa81c9f1660c88885b..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuSuperEF/python/TrigMuSuperEFConfigDb.py
+++ /dev/null
@@ -1,29 +0,0 @@
-# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-
-from AthenaCommon.CfgGetter import addAlgorithm,addTool
-
-# RoI based
-addAlgorithm("TrigMuSuperEF.TrigMuSuperEFConfig.TrigMuSuperEF","TrigMuSuperEF")
-#addAlgorithm("TrigMuSuperEF.TrigMuSuperEFConfig.TrigMuSuperEF_MGfirst","TrigMuSuperEF_MGfirst")
-addAlgorithm("TrigMuSuperEF.TrigMuSuperEFConfig.TrigMuSuperEF_TMEFfirst","TrigMuSuperEF_TMEFfirst")
-addAlgorithm("TrigMuSuperEF.TrigMuSuperEFConfig.TrigMuSuperEF_MGonly","TrigMuSuperEF_MGonly")
-addAlgorithm("TrigMuSuperEF.TrigMuSuperEFConfig.TrigMuSuperEF_TMEFonly","TrigMuSuperEF_TMEFonly")
-#addAlgorithm("TrigMuSuperEF.TrigMuSuperEFConfig.TrigMuSuperEF_both","TrigMuSuperEF_both")
-addAlgorithm("TrigMuSuperEF.TrigMuSuperEFConfig.TrigMuSuperEF_SAonly","TrigMuSuperEF_SAonly")
-addAlgorithm("TrigMuSuperEF.TrigMuSuperEFConfig.TrigMuSuperEF_STonly","TrigMuSuperEF_STonly")
-#calotag
-addAlgorithm("TrigMuSuperEF.TrigMuSuperEFConfig.TrigMuSuperEF_CTonly","TrigMuSuperEF_CTonly")
-# combiner only
-addAlgorithm("TrigMuSuperEF.TrigMuSuperEFConfig.TrigMuSuperEF_TMEFCombinerOnly","TrigMuSuperEF_TMEFCombinerOnly")
-# full-scans
-addAlgorithm("TrigMuSuperEF.TrigMuSuperEFConfig.TrigMuSuperEF_FSCB","TrigMuSuperEF_FSCB")
-addAlgorithm("TrigMuSuperEF.TrigMuSuperEFConfig.TrigMuSuperEF_FSSA","TrigMuSuperEF_FSSA")
-addAlgorithm("TrigMuSuperEF.TrigMuSuperEFConfig.TrigMuSuperEF_WideCone","TrigMuSuperEF_WideCone")
-addAlgorithm("TrigMuSuperEF.TrigMuSuperEFConfig.TrigMuSuperEF_WideCone04","TrigMuSuperEF_WideCone04")
-addAlgorithm("TrigMuSuperEF.TrigMuSuperEFConfig.TrigMuSuperEF_WideCone05","TrigMuSuperEF_WideCone05")
-
-# tools for Calotag #####Commenting out so things will run...
-#addTool("TrigMuSuperEF.TrigMuSuperEFConfig.TrigMuSuperEF_TrackIsolationTool", "TrigMuSuperEF_TrackIsolationTool")
-addTool("TrigMuSuperEF.TrigMuSuperEFConfig.TrigMuSuperEF_MuonCaloTagTool", "TrigMuSuperEF_MuonCaloTagTool")
-addTool("TrigMuSuperEF.TrigMuSuperEFConfig.TrigMuSuperEF_TrackDepositInCaloTool", "TrigMuSuperEF_TrackDepositInCaloTool")
-addTool("TrigMuSuperEF.TrigMuSuperEFConfig.TrigMuSuperEF_CaloTrkSelectorTool", "TrigMuSuperEF_CaloTrkSelectorTool")
diff --git a/Trigger/TrigAlgorithms/TrigMuSuperEF/python/TrigMuSuperEFMonitoring.py b/Trigger/TrigAlgorithms/TrigMuSuperEF/python/TrigMuSuperEFMonitoring.py
deleted file mode 100644
index 5bd874e5c57ce64813643635e324087a13871e3e..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuSuperEF/python/TrigMuSuperEFMonitoring.py
+++ /dev/null
@@ -1,105 +0,0 @@
-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-
-from TrigMonitorBase.TrigGenericMonitoringToolConfig import defineHistogram, TrigGenericMonitoringToolConfig
-
-class TrigMuSuperEFMonitoring(TrigGenericMonitoringToolConfig):
- def __init__ (self, name="TrigMuSuperEFMonitoring"):
- super(TrigMuSuperEFMonitoring, self).__init__(name)
- self.defineTarget( ["Online", "Validation"] )
-
- # overall histograms for full algorithm
- self.Histograms += [ defineHistogram('EF_trks_n', type='TH1F', title="Number of tracks; MuEF Number of Tracks",
- xbins=51, xmin=-0.5, xmax=50.5) ]
- self.Histograms += [ defineHistogram('EF_trks_pt', type='TH1F', title="pt ; MuEF Track pt [GeV]",
- xbins=100, xmin=0, xmax=200) ]
- self.Histograms += [ defineHistogram('EF_trks_phi', type='TH1F', title="phi ; MuEF Track Phi",
- xbins=100, xmin=-5, xmax=5) ]
- self.Histograms += [ defineHistogram('EF_trks_eta', type='TH1F', title="eta ; MuEF Track Eta",
- xbins=100, xmin=-5.5, xmax=5.5) ]
- self.Histograms += [ defineHistogram('EF_IDtrks_n', type='TH1F', title="Number of ID tracks ; n MuEF ID tracks",
- xbins=51, xmin=-0.5, xmax=50.5) ]
- self.Histograms += [ defineHistogram('EF_IDtrks_phi', type='TH1F', title="ID track phi; MuEF ID track phi",
- xbins=100, xmin=-5, xmax=5) ]
- self.Histograms += [ defineHistogram('EF_IDtrks_eta', type='TH1F', title="ID track eta ; MuEF ID track eta",
- xbins=100, xmin=-5.5, xmax=5.5) ]
- self.Histograms += [ defineHistogram('EF_IDtrks_pT', type='TH1F', title="ID track pT; MuEF ID track pT",
- xbins=100, xmin=0.0, xmax=200.0) ]
- self.Histograms += [ defineHistogram('EF_IDtrks_pT,EF_IDtrks_phi', type='TH2F', title="ID track phi; MuEF ID track pT; MuEF ID track phi",
- xbins=100, xmin=0.0, xmax=200.0, ybins=100, ymin=-5, ymax=5) ]
- self.Histograms += [ defineHistogram('EF_IDtrks_pT,EF_IDtrks_eta', type='TH2F', title="ID track eta; MuEF ID track pT; MuEF ID track eta",
- xbins=100, xmin=0.0, xmax=200.0, ybins=100, ymin=-5.5, ymax=5.5) ]
-
-
-class TrigMuSuperEFValidationMonitoring(TrigGenericMonitoringToolConfig):
- def __init__ (self, name="TrigMuSuperEFValidationMonitoring"):
- super(TrigMuSuperEFValidationMonitoring, self).__init__(name)
- self.defineTarget( ["Validation"] )
-
- # overall histograms for full algorithm
- self.Histograms += [ defineHistogram('EF_trks_type', type='TH1F', title="author;1=TrigMuonEF 2=TrigMuGirl 3=TrigMuGirlTag",
- xbins=3, xmin=0.5, xmax=3.5) ]
- self.Histograms += [ defineHistogram('EF_trks_chi2', type='TH1F', title="chi2; MuEF Track chi2",
- xbins=100, xmin=0, xmax=30) ]
- self.Histograms += [ defineHistogram('EF_trks_chi2Prob', type='TH1F', title="chi2Prob; MuEF Track chi2 probability",
- xbins=50, xmin=0, xmax=1) ]
- self.Histograms += [ defineHistogram('EF_trks_match_chi2', type='TH1F', title="match_chi2; MuEF Track matching chi2",
- xbins=100, xmin=0, xmax=50) ]
- self.Histograms += [ defineHistogram('EF_trks_charge', type='TH1F', title="charge;Muon charge",
- xbins=3, xmin=-1.5, xmax=1.5) ]
- self.Histograms += [ defineHistogram('EF_trks_d0', type='TH1F', title="d0 ; MuEF Track d0",
- xbins=100, xmin=-10, xmax=10) ]
- self.Histograms += [ defineHistogram('EF_trks_z0', type='TH1F', title="z0 ; MuEF Track z0 [mm]",
- xbins=100, xmin=-250, xmax=250) ]
- self.Histograms += [ defineHistogram('EF_trks_nMdt', type='TH1F', title="Number of Mdt ; MuEF Mdt hits",
- xbins=51, xmin=-0.5, xmax=50.5) ]
- self.Histograms += [ defineHistogram('EF_trks_nRpcEta', type='TH1F', title="Number of Rpc eta; MuEF Rpc Eta hits",
- xbins=51, xmin=-0.5, xmax=50.5) ]
- self.Histograms += [ defineHistogram('EF_trks_nRpcPhi', type='TH1F', title="Number of Rpc phi ; MuEF Rpc Phi hits",
- xbins=51, xmin=-0.5, xmax=50.5) ]
- self.Histograms += [ defineHistogram('EF_trks_nTgcEta', type='TH1F', title="Number of Tgc eta; MuEF Tgc Eta hits",
- xbins=51, xmin=-0.5, xmax=50.5) ]
- self.Histograms += [ defineHistogram('EF_trks_nTgcPhi', type='TH1F', title="Number of Tgc phi; MuEF Tgc Phi hits",
- xbins=51, xmin=-0.5, xmax=50.5) ]
- self.Histograms += [ defineHistogram('EF_trks_nCscEta', type='TH1F', title="Number of Csc eta; MuEF Csc Eta hits",
- xbins=51, xmin=-0.5, xmax=50.5) ]
- self.Histograms += [ defineHistogram('EF_trks_nCscPhi', type='TH1F', title="Number of Csc phi; MuEF Csc Phi hits",
- xbins=51, xmin=-0.5, xmax=50.5) ]
- self.Histograms += [ defineHistogram('EF_trks_nHit', type='TH1F', title="Number of Hit on track ; MuEF Total hits",
- xbins=151, xmin=-0.5, xmax=150.5) ]
- self.Histograms += [ defineHistogram('EF_trks_nIdPixelHit', type='TH1F', title="Number of IdPixelHit on track ; MuEF Pixel hits",
- xbins=11, xmin=-0.5, xmax=10.5) ]
- self.Histograms += [ defineHistogram('EF_trks_nIdSctHit', type='TH1F', title="Number of IdSctHit on track ; MuEF Sct hits",
- xbins=21, xmin=-0.5, xmax=20.5) ]
- self.Histograms += [ defineHistogram('EF_trks_nIdTrtHit', type='TH1F', title="Number of IdTrtHit on track ; MuEF Trt hits",
- xbins=51, xmin=-0.5, xmax=50.5) ]
-
- #CT
- self.Histograms += [ defineHistogram('EF_cttrks_n', type='TH1F', title="Number of tracks; MuEF Number of Tracks",
- xbins=51, xmin=-0.5, xmax=50.5) ]
- self.Histograms += [ defineHistogram('EF_cttrks_pT', type='TH1F', title="pt ; MuEF Track pt [GeV]",
- xbins=100, xmin=0, xmax=200) ]
- self.Histograms += [ defineHistogram('EF_cttrks_phi', type='TH1F', title="phi ; MuEF Track Phi",
- xbins=100, xmin=-5, xmax=5) ]
- self.Histograms += [ defineHistogram('EF_cttrks_eta', type='TH1F', title="eta ; MuEF Track Eta",
- xbins=100, xmin=-5.5, xmax=5.5) ]
- self.Histograms += [ defineHistogram('EF_cttrks_d0', type='TH1F', title="d0 ; MuEF Track d0",
- xbins=100, xmin=-10, xmax=10) ]
- self.Histograms += [ defineHistogram('EF_cttrks_z0', type='TH1F', title="z0 ; MuEF Track z0 [mm]",
- xbins=100, xmin=-250, xmax=250) ]
- self.Histograms += [ defineHistogram('EF_cttrks_nHit', type='TH1F', title="Total Hits ; Total Hits",
- xbins=51, xmin=-0.5, xmax=50.5) ]
- self.Histograms += [ defineHistogram('EF_cttrks_nIdSctHit', type='TH1F', title="Sct Hits ; Sct Hits",
- xbins=51, xmin=-0.5, xmax=50.5) ]
- self.Histograms += [ defineHistogram('EF_cttrks_nIdPixelHit', type='TH1F', title="Pixel Hits ; Pixel Hits",
- xbins=51, xmin=-0.5, xmax=50.5) ]
- self.Histograms += [ defineHistogram('EF_cttrks_nIdTrtHit', type='TH1F', title="TRT Hits ; TRT Hits",
- xbins=51, xmin=-0.5, xmax=50.5) ]
- self.Histograms += [ defineHistogram('EF_cttrks_caloTag', type='TH1F', title="Calotag ; Calotag",
- xbins=51, xmin=-0.5, xmax=50.5) ]
- self.Histograms += [ defineHistogram('EF_cttrks_caloLH', type='TH1F', title="Calotag Likelihood ' Calo LH",
- xbins=51, xmin=-0.05, xmax=1.05) ]
- self.Histograms += [ defineHistogram('EF_cttrks_pT,EF_cttrks_caloTag', type='TH2F', title="CT Track Pt; MuEF ID track pT; CaloTag",
- xbins=100, xmin=0.0, xmax=200.0, ybins=51, ymin=-0.5, ymax=50.5)]
- self.Histograms += [ defineHistogram('EF_cttrks_eta,EF_cttrks_caloTag', type='TH2F', title="CT Track Eta; MuEF ID track eta; CaloTag",
- xbins=100, xmin=-5.5, xmax=5.5, ybins=51, ymin=-0.5, ymax=50.5)]
-
diff --git a/Trigger/TrigAlgorithms/TrigMuSuperEF/python/TrigMuonEFTagandProbeConfig.py b/Trigger/TrigAlgorithms/TrigMuSuperEF/python/TrigMuonEFTagandProbeConfig.py
deleted file mode 100644
index 3da277d11705d72de1e5379415b98b26d086e527..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuSuperEF/python/TrigMuonEFTagandProbeConfig.py
+++ /dev/null
@@ -1,50 +0,0 @@
-# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
-
-from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
-from .TrigMuonEFTagandProbeMonitoring import TrigMuonEFTagandProbeMonitoring
-
-from .TrigMuSuperEFConf import TrigMuonEFTagandProbe #Conf is based on algorithm package not individual algs
-
-# Default config: Online Z->mumu HLT based Tag and Probe efficiency monitoring
-
-class TrigMuonEFTagandProbeConfig(TrigMuonEFTagandProbe): #making python class from Conf import TaP object
- __slots__ = () #Saves space by not using memory slots rather than a dictionary for storing class attributes
-
-# These are methods tied to class being built
-# self is a reference to the class object itself
-# __init__ is essentially pythons version of a constructor, gets called whenever base class is used and takes self as an implicit argument to know what to build as well as any other arguments passed when calling base class method
-# **kwargs is a 'magic' argument variable which stands in for unknown numbers of arguments when we don't know how many are going to be passed, used for arguments in python list format with associated key strings
-
-# Currently no kwargs to set up for TaP
- def __init__(self,name="TrigMuonEFTagandProbe",**kwargs):
-
- #Set out actions associated with class construction
-
-
- # make instance of TrigMuonEFTagandProbe class when constructor is called
- # Super allows direct use of inherited methods and attributes from the parent class, TrigMuonEFTagandProbe in this case, without having to directly reference this class, useful for multiple inheritance
-
- super(TrigMuonEFTagandProbeConfig,self).__init__(name,**kwargs)
-
- # setup monitoring depending on configuration
- monTools = []
-
- monTools.append( TrigMuonEFTagandProbeMonitoring() )
-
- # always add timing monitoring
- timetool = TrigTimeHistToolConfig("Time")
- timetool.NumberOfHistBins = 100
- timetool.TimerHistLimits = [0,1000]
- monTools.append( timetool )
-
- self.AthenaMonTools = monTools
- # end of __init__
-
-
-#
-# Space for Several pre-configured TaP variations
-# Only base class needed for now
-#
-def TrigMuonEFTagandProbe(name="TrigMuonEFTagandProbe",**kwargs):
- return TrigMuonEFTagandProbeConfig(name,**kwargs)
-
diff --git a/Trigger/TrigAlgorithms/TrigMuSuperEF/python/TrigMuonEFTagandProbeConfigDb.py b/Trigger/TrigAlgorithms/TrigMuSuperEF/python/TrigMuonEFTagandProbeConfigDb.py
deleted file mode 100644
index 2010a42d228c38f0bd97eba85d04d4f7b6a56655..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuSuperEF/python/TrigMuonEFTagandProbeConfigDb.py
+++ /dev/null
@@ -1,5 +0,0 @@
-# Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
-from AthenaCommon.CfgGetter import addAlgorithm
-
-# Online Z->mumu Tag and Probe efficiency monitoring (Currently only one flavour of TaP algorithm)
-addAlgorithm("TrigMuonEFTagandProbe.TrigMuonEFTagandProbeConfig.TrigMuonEFTagandProbe","TrigMuonEFTagandProbe")
diff --git a/Trigger/TrigAlgorithms/TrigMuSuperEF/python/TrigMuonEFTagandProbeMonitoring.py b/Trigger/TrigAlgorithms/TrigMuSuperEF/python/TrigMuonEFTagandProbeMonitoring.py
deleted file mode 100644
index 8975e045d68b553a76075a67870d45837387b7bd..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuSuperEF/python/TrigMuonEFTagandProbeMonitoring.py
+++ /dev/null
@@ -1,39 +0,0 @@
-# Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
-
-from TrigMonitorBase.TrigGenericMonitoringToolConfig import defineHistogram, TrigGenericMonitoringToolConfig
-
-class TrigMuonEFTagandProbeMonitoring(TrigGenericMonitoringToolConfig):
- def __init__ (self, name="TrigMuonEFTagandProbeMonitoring"):
- super(TrigMuonEFTagandProbeMonitoring, self).__init__(name)
- self.defineTarget( ["Online", "Validation"] )
-
-
-#Profile Histograms for producing efficiency plots online - built by threshold number
-
- for i in range(1,7):
-
- #Phi barrel
- self.Histograms += [ defineHistogram('EF_Phi_Total_thr' + str(i) + '_b, EF_Etaphi_Eff_thr' + str(i) + '_b', type='TProfile', title="L1 Trigger Efficiency by #phi in threshold " + str(i) + " Barrel;Muon #phi [Rad];Efficiency",
- xbins=35, xmin=-3.5, xmax=3.5) ]
- #Phi endcap
- self.Histograms += [ defineHistogram('EF_Phi_Total_thr' + str(i) + '_e, EF_Etaphi_Eff_thr' + str(i) + '_e', type='TProfile', title="L1 Trigger Efficiency by #phi in threshold " + str(i) + " Endcap;Muon #phi [Rad];Efficiency",
- xbins=35, xmin=-3.5, xmax=3.5) ]
-
-
-#Additional Profile histograms for combined barrel and endcap eta plots - built by threshold number
-
- #Eta combined barrel + endcap
- self.Histograms += [ defineHistogram('EF_Eta_Total_thr' + str(i) + ', EF_Eta_Eff_thr' + str(i) + '', type='TProfile', title="L1 Trigger Efficiency by #eta in threshold " + str(i) + ";Muon #eta;Efficiency",
- xbins=35, xmin=-3.5, xmax=3.5) ]
-
-
-#2D Profile Histograms for producing efficiency plots of eta v phi online - built by threshold number ([31/05/18] only using thresholds 1,5, and 6 to limit memory allocation, thresholds 5&6 are identical in endcap)
-
- for i in [1,5,6]:
- #Eta + Phi barrel
- self.Histograms += [ defineHistogram('EF_Eta_Total_thr' + str(i) + '_b, EF_Phi_Total_thr' + str(i) + '_b, EF_Etaphi_Eff_thr' + str(i) + '_b', type='TProfile2D', title="L1 Trigger Efficiency in #eta and #phi Threshold " + str(i) + " Barrel;Muon #eta ;Muon #phi",
- xbins=11, xmin=-1.1, xmax=1.1, ybins=8, ymin=-3.4, ymax=3.4, zmin=-0.1,zmax=1.1) ]
- for i in [1,6]:
- #Eta + Phi endcap
- self.Histograms += [ defineHistogram('EF_Eta_Total_thr' + str(i) + '_e, EF_Phi_Total_thr' + str(i) + '_e, EF_Etaphi_Eff_thr' + str(i) + '_e', type='TProfile2D', title="L1 Trigger Efficiency in #eta and #phi Threshold " + str(i) + " Endcap;Muon #eta ;Muon #phi",
- xbins=27, xmin=-2.7, xmax=2.7, ybins=8, ymin=-3.4, ymax=3.4, zmin=-0.1,zmax=1.1) ]
diff --git a/Trigger/TrigAlgorithms/TrigMuSuperEF/src/InternalCache.cxx b/Trigger/TrigAlgorithms/TrigMuSuperEF/src/InternalCache.cxx
deleted file mode 100644
index 6aaedda5a84c105853c7cac70a236e002e08f88f..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuSuperEF/src/InternalCache.cxx
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-#include "InternalCache.h"
-#include "MuonCombinedEvent/MuonCandidate.h"
-#include "MuonCombinedEvent/MuonCandidateCollection.h"
-#include "xAODTracking/TrackParticleContainer.h"
-#include "xAODTracking/TrackParticleAuxContainer.h"
-#include "Particle/TrackParticleContainer.h"
-#include "TrkToolInterfaces/ITrackParticleCreatorTool.h"
-#include "xAODTracking/TrackParticlexAODHelpers.h"
-
-InternalCache::InternalCache(){
- m_muoncandidates=0;
- m_STMuonCandidates=0;
- m_extrapolatedtracks =0;
- m_combinedtracks=std::make_pair(new xAOD::TrackParticleContainer(),new xAOD::TrackParticleAuxContainer());
- m_satracks=std::make_pair(new xAOD::TrackParticleContainer(), new xAOD::TrackParticleAuxContainer());
- m_combtrkcoll=0;
- m_muoncont=std::make_pair(new xAOD::MuonContainer, new xAOD::MuonAuxContainer());
- }
-
-
-/**
- * Destructor.
- * We do not delete the pointers, since these are not owned by this class.
- */
-InternalCache::~InternalCache(){
- if(m_combinedtracks.first) delete m_combinedtracks.first;
- if(m_combinedtracks.second) delete m_combinedtracks.second;
- if(m_satracks.first) delete m_satracks.first;
- if(m_satracks.second) delete m_satracks.second;
- if(m_muoncont.first) delete m_muoncont.first;
- if(m_muoncont.second) delete m_muoncont.second;
-}
-
-
-void InternalCache::SetMuonCandidates(MuonCandidateCollection *muonCand){
- m_muoncandidates = muonCand;
-}
-
-void InternalCache::SetSegmentTaggedMuonCandidates(MuonCandidateCollection *muonCand){
- m_STMuonCandidates = muonCand;
-}
-
-void InternalCache::SetCombinedTracks(xAOD::TrackParticleContainer* combtrk){
- xAOD::TrackParticleContainer::iterator trk_itr = combtrk->begin();
- xAOD::TrackParticleContainer::iterator trk_end = combtrk->end();
- m_combinedtracks.first->setStore(m_combinedtracks.second);
- m_combinedtracks.first->reserve(combtrk->size());
- for(; trk_itr !=trk_end; ++trk_itr){
- xAOD::TrackParticle *trk1 = new xAOD::TrackParticle();
- trk1->makePrivateStore(**trk_itr);
- m_combinedtracks.first->push_back(trk1);
- }
-}
-
-void InternalCache::SetSATracks(xAOD::TrackParticleContainer* satrk){
- xAOD::TrackParticleContainer::iterator trk_itr = satrk->begin();
- xAOD::TrackParticleContainer::iterator trk_end = satrk->end();
-
- m_satracks.first->setStore(m_satracks.second);
- m_satracks.first->reserve(satrk->size());
- for(; trk_itr !=trk_end; ++trk_itr){
- xAOD::TrackParticle *trk1 = new xAOD::TrackParticle();
- trk1->makePrivateStore(**trk_itr);
- m_satracks.first->push_back(trk1);
- }
-}
-
-void InternalCache::SetExtrapolatedTracks(TrackCollection *extrtrk){
- m_extrapolatedtracks = extrtrk;
-}
-
-void InternalCache::SetCombinedTrackColl(TrackCollection *combtrkcoll){
- m_combtrkcoll=combtrkcoll;
-}
-
-void InternalCache::SetMuonContainer(xAOD::MuonContainer* muonContainer){
-
- m_muoncont.first->setStore(m_muoncont.second);
- xAOD::MuonContainer::iterator mu_itr = muonContainer->begin();
- xAOD::MuonContainer::iterator mu_end = muonContainer->end();
- m_muoncont.first->reserve(muonContainer->size());
- for(; mu_itr != mu_end; ++mu_itr){
- xAOD::Muon *mu1 = new xAOD::Muon();
- mu1->makePrivateStore(**mu_itr);
- m_muoncont.first->push_back(mu1);
- }
-}
diff --git a/Trigger/TrigAlgorithms/TrigMuSuperEF/src/InternalCache.h b/Trigger/TrigAlgorithms/TrigMuSuperEF/src/InternalCache.h
deleted file mode 100644
index 3ee43ea969bf6ca1d0f775ff9eb9f759860b2b69..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuSuperEF/src/InternalCache.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-#ifndef TrigMuSuperEF_InternalCache_H__
-#define TrigMuSuperEF_InternalCache_H__
-
-#include <vector>
-#include "MuonCombinedEvent/MuonCandidateCollection.h"
-#include "MuonCombinedEvent/MuonCandidate.h"
-#include "MuonCombinedEvent/InDetCandidateCollection.h"
-#include "xAODTracking/TrackParticleContainer.h"
-#include "xAODTracking/TrackParticleAuxContainer.h"
-#include "xAODMuon/MuonContainer.h"
-#include "xAODMuon/MuonAuxContainer.h"
-
-class TrigMuonEFInfo;
-class InternalCache {
-
- public:
- /// Default Constructor
- InternalCache();
-
- /// Destructor
- ~InternalCache();
-
-
- void SetMuonCandidates(MuonCandidateCollection *muonCand);
- void SetCombinedTracks(xAOD::TrackParticleContainer *combtrk);
- void SetSATracks(xAOD::TrackParticleContainer *satrk);
- void SetExtrapolatedTracks(TrackCollection *extrtrk);
- void SetCombinedTrackColl(TrackCollection *combtrkcoll);
- void SetSATracksAux(xAOD::TrackParticleAuxContainer satrkaux);
- void SetMuonContainer(xAOD::MuonContainer* muonContainerOwn);
- void SetSegmentTaggedMuonCandidates(MuonCandidateCollection* muonCand);
- MuonCandidateCollection *MuonCandidates() { return m_STMuonCandidates; }
- std::pair<xAOD::TrackParticleContainer*,xAOD::TrackParticleAuxContainer*> CombinedTracks() {return m_combinedtracks;}
- std::pair<xAOD::TrackParticleContainer*, xAOD::TrackParticleAuxContainer*> SATracks() {return m_satracks;}
- TrackCollection *ExtrapolatedTracks() { return m_extrapolatedtracks;}
- TrackCollection *CombinedTrackColl() {return m_combtrkcoll;}
- std::pair<xAOD::MuonContainer*, xAOD::MuonAuxContainer*> MuonContainer() {return m_muoncont;}
- MuonCandidateCollection *MuonSTCandidates() { return m_STMuonCandidates; }
-
- private:
-
- MuonCandidateCollection *m_muoncandidates;
- MuonCandidateCollection *m_STMuonCandidates;
- std::pair<xAOD::TrackParticleContainer*,xAOD::TrackParticleAuxContainer*> m_combinedtracks;
- std::pair<xAOD::TrackParticleContainer*,xAOD::TrackParticleAuxContainer*> m_satracks;
- TrackCollection *m_extrapolatedtracks;
- TrackCollection *m_combtrkcoll;
- std::pair<xAOD::MuonContainer*, xAOD::MuonAuxContainer*> m_muoncont;
-};
-
-#endif
diff --git a/Trigger/TrigAlgorithms/TrigMuSuperEF/src/TrigMuSuperEF.cxx b/Trigger/TrigAlgorithms/TrigMuSuperEF/src/TrigMuSuperEF.cxx
deleted file mode 100644
index ead6487ccbf53df509006ba7ede22117b18ad5c6..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuSuperEF/src/TrigMuSuperEF.cxx
+++ /dev/null
@@ -1,2063 +0,0 @@
-
-/*
- Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
-*/
-
-#include <iomanip>
-#include <cmath>
-
-#include "TrigMuSuperEF.h"
-
-#include "Particle/TrackParticleContainer.h"
-#include "MuonRecToolInterfaces/IMuonPatternSegmentAssociationTool.h"
-#include "MuidEvent/MuidTrackContainer.h"
-#include "MuonSegment/MuonSegment.h"
-#include "MuonPattern/MuonPatternCombinationCollection.h"
-#include "TrkSegment/SegmentCollection.h"
-#include "CaloEvent/CaloClusterContainer.h"
-#include "MuonRecToolInterfaces/IMuonSystemExtensionTool.h"
-
-
-#include "TrigNavigation/TriggerElement.h"
-#include "TrigConfHLTData/HLTTriggerElement.h"
-#include "TrigSteeringEvent/TrigRoiDescriptor.h"
-
-#include "TrigMuonEvent/CachingFeatureCollection.h"
-#include "TrigMuonEvent/TrigMuonEFTrack.h"
-#include "TrigMuonEvent/TrigMuonEFInfoTrack.h"
-#include "TrigMuonEvent/TrigMuonEFInfoTrackContainer.h"
-#include "TrigMuonEvent/TrigMuonEFInfo.h"
-#include "TrigMuonEvent/TrigMuonEFInfoContainer.h"
-#include "TrigMuonEvent/TrigMuonEFCbTrack.h"
-
-#include "TrigMuonToolInterfaces/ITrigMuonStandaloneTrackTool.h"
-
-#include "TrigTimeAlgs/TrigTimerSvc.h"
-
-// xAOD classes
-#include "xAODMuon/MuonContainer.h"
-#include "xAODTracking/TrackParticleContainer.h"
-#include "xAODTracking/TrackParticleAuxContainer.h"
-
-// xAOD related tools
-#include "TrkToolInterfaces/ITrackParticleCreatorTool.h"
-#include "MuonCombinedToolInterfaces/IMuonCreatorTool.h"
-
-// offline muon reco EDM wrapper classes
-#include "MuonCombinedEvent/MuonCandidate.h"
-#include "MuonCombinedEvent/MuonCandidateCollection.h"
-#include "MuonCombinedEvent/InDetCandidate.h"
-#include "MuonCombinedEvent/InDetCandidateCollection.h"
-#include "MuonCombinedEvent/TagBase.h"
-#include "MuonCombinedEvent/CaloTag.h"
-#include "MuonCombinedEvent/SegmentTag.h"
-#include "MuonCombinedEvent/InDetCandidateToTagMap.h"
-
-// offline reco tools
-#include "MuonCombinedToolInterfaces/IMuonCombinedTool.h"
-#include "MuonCombinedToolInterfaces/IMuonCombinedInDetExtensionTool.h"
-#include "MuonCombinedToolInterfaces/IMuonSegmentTagTool.h"
-#include "TrkToolInterfaces/ITrackSummaryTool.h"
-
-// utility functions
-#include "TrigMuSuperEFUtils.icc"
-#include "AthenaKernel/Units.h"
-
-class ISvcLocator;
-
-using std::map;
-namespace Units = Athena::Units;
-
-// ----------------------------------------
-TrigMuSuperEF::TrigMuSuperEF(const std::string& name, ISvcLocator* pSvcLocator) :
- FexAlgo(name, pSvcLocator),
- m_TrigMuonEF_saTrackTool("TrigMuonEFStandaloneTrackTool/TrigMuonEFStandaloneTrackTool"),
- m_roi(0),
- m_Roi_StillToBeAttached(0),
- m_totalTime(0),
- m_muonContainer(0),
- m_ctTrackParticleContainer(0),
- m_combTrkTrackColl(0),
- m_tracksCache(),
- m_doInsideOut(true),
- m_doOutsideIn(true),
- m_insideOutFirst(false),
- m_forceBoth(false),
- m_singleContainer(true),
- m_standaloneOnly(false),
- m_combinerOnly(false),
- m_segmentTagOnly(false),
- m_fullScan(false),
- m_recordSegments(false),
- m_recordPatterns(false),
- m_recordTracks(false),
- m_dEtaRoI(0.2),
- m_dPhiRoI(0.2),
- m_idTrackParticlesName(""),
- m_saTrackParticleContName("MuonEFInfo_ExtrapTrackParticles"),
- m_msTrackParticleContName("MuonEFInfo_MSonlyTrackParticles"),
- m_cbTrackParticleContName("MuonEFInfo_CombTrackParticles"),
- m_ctTrackParticleContName("MuonEFInfo_CaloTagTrackParticles"),
- m_muonContName("MuonEFInfo"),
- m_debug(false),
- m_verbose(false),
- m_muonCombinedTool("MuonCombined::MuonCombinedTool/MuonCombinedTool"),
- m_muGirlTool("TMEF_MuonInsideOutRecoTool"),
- m_caloTagTool("TrigMuSuperEF_MuonCaloTagTool"),
- m_muonSegmentTagTool("MuonCombined::MuonCombinedTool/MuonSegmentTagTool"),
- m_TrackToTrackParticleConvTool("TrackToTrackParticleConvTool",this),
- m_muonCreatorTool("MuonCreatorTool"),
- m_stauCreatorTool("MuonCreatorTool"),
- m_muonSystemExtensionTool("Muon::MuonSystemExtensionTool/MuonSystemExtensionTool", this),
- m_doMuonFeature(false),
- m_useL2Info(false),
- m_doCache(true)
-{
- m_hashlist.reserve(4);
-
- declareProperty("doInsideOut", m_doInsideOut, "Run TrigMuGirl or not (starts from ID, then goes to MS)");
- declareProperty("doOutsideIn", m_doOutsideIn, "Run TrigMuonEF or not (starts from MS, then goes to ID)");
- declareProperty("insideOutFirst", m_insideOutFirst, "Run TrigMuGirl first (true) or run TrigMuonEF first (false)");
- declareProperty("forceBoth", m_forceBoth, "Always run both algorithms");
- declareProperty("SingleContainer", m_singleContainer, "Write muons of both algorithms in the same TrigMuonEFInfoContainer");
- declareProperty("StandaloneOnly", m_standaloneOnly, "Run only up to Muon Standalone tracks (extrapolated to IP)");
- declareProperty("CombinerOnly", m_combinerOnly, "Run only the combiner (MS tracks must already by attached to the trigger element");
- declareProperty("CaloTagOnly", m_caloTagOnly, "Use calo-tagging to identify muon tracks using ID only");
- declareProperty("SegmentTagOnly", m_segmentTagOnly, "Use segment-tagging to identify muon tracks using ID only");
- declareProperty("fullScan", m_fullScan, "Search for tracks in the full Muon Spectrometer");
-
- declareProperty("TMEF_standaloneTrackTool", m_TrigMuonEF_saTrackTool);
- declareProperty("MuGirlTool", m_muGirlTool);
- declareProperty("CaloTagTool", m_caloTagTool);
- declareProperty("SegmentTagTool", m_muonSegmentTagTool);
-
- // tool to run offline combiner
- declareProperty("MuonCombinedTool", m_muonCombinedTool);
- // tool to create xAOD::TrackParticles
- declareProperty("TrkToTrackParticleConvTool", m_TrackToTrackParticleConvTool);
- // tool to create xAOD::Muons
- declareProperty("MuonCreatorTool", m_muonCreatorTool);
- declareProperty("StauCreatorTool", m_stauCreatorTool);
- // tool for extending ID tracks to muon system
- declareProperty("MuonSystemExtensionTool", m_muonSystemExtensionTool );
-
- declareProperty("recordSegmentCombinations", m_recordSegments);
- declareProperty("recordPatternCombinations", m_recordPatterns);
- declareProperty("recordTrackCollection", m_recordTracks);
-
- declareProperty("doMuGirlMuonFeature", m_doMuonFeature);
-
- declareProperty("deltaEtaRoI", m_dEtaRoI);
- declareProperty("deltaPhiRoI", m_dPhiRoI);
-
- declareProperty("IdTrackParticles", m_idTrackParticlesName);
-
- declareProperty("DoCache", m_doCache);
- declareProperty("ExtrapolatedTrackParticleContName", m_saTrackParticleContName);
- declareProperty("MSonlyTrackParticleContName", m_msTrackParticleContName);
- declareProperty("CBTrackParticleContName", m_cbTrackParticleContName);
- declareProperty("CTTrackParticleContName", m_ctTrackParticleContName);
- declareProperty("MuonContName", m_muonContName);
- declareProperty("UseL2Info", m_useL2Info);
- declareMonitoredStdContainer ("EF_trks_n", m_monVars.numberOfTracks, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_trks_type", m_monVars.type, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_trks_charge", m_monVars.charge, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_trks_chi2", m_monVars.chi2, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_trks_chi2Prob", m_monVars.chi2Prob, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_trks_match_chi2", m_monVars.matchChi2, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_trks_pt", m_monVars.pt, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_trks_phi", m_monVars.phi, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_trks_eta", m_monVars.eta, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_trks_d0", m_monVars.d0, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_trks_z0", m_monVars.z0, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_trks_nMdt", m_monVars.nMdt, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_trks_nRpcEta", m_monVars.nRpcEta, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_trks_nRpcPhi", m_monVars.nRpcPhi, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_trks_nCscEta", m_monVars.nCscEta, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_trks_nCscPhi", m_monVars.nCscPhi, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_trks_nTgcEta", m_monVars.nTgcEta, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_trks_nTgcPhi", m_monVars.nTgcPhi, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_trks_nIdSctHit", m_monVars.nSct, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_trks_nIdPixelHit", m_monVars.nPixel, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_trks_nIdTrtHit", m_monVars.nTrt, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_trks_nHit", m_monVars.nHit, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_IDtrks_n", m_monVars.nIDTrks, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_IDtrks_phi", m_monVars.IDTrk_phi, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_IDtrks_eta", m_monVars.IDTrk_eta, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_IDtrks_pT", m_monVars.IDTrk_pT, IMonitoredAlgo::AutoClear);
-
- declareCombinedMonitoringVariables(m_TMEF_monVars.CB);
- declareCaloTagMonitoringVariables(m_TrigCaloTag_monVars);
-
-
-}
-
-TrigMuSuperEF::~TrigMuSuperEF(){}
-
-//Function to clear the RoI cache (per RoI) used in the hltExecute function
-void TrigMuSuperEF::clearRoiCache(){
- m_roi = 0;
- //m_Roi_StillToBeAttached = new TrigRoiDescriptor();
- delete m_Roi_StillToBeAttached;
- m_Roi_StillToBeAttached = 0;
- //clear the RoI cache (per RoI) in the standalone track tool
- if(m_doOutsideIn && !m_combinerOnly){
- m_TrigMuonEF_saTrackTool->clearRoiCache();
- }
-
- for(auto tMap : m_tagMaps) delete tMap;
- m_tagMaps.clear();
-}
-
-HLT::ErrorCode
-TrigMuSuperEF::prepareRobRequests(const HLT::TriggerElement* input){
-
- ATH_MSG_DEBUG("prepareRobRequests called");
-
- clearRoiCache();
-
- HLT::RobRequestInfo* RRInfo = config()->robRequestInfo();
-
- const IRoiDescriptor* muonRoI = getRoiDescriptor(input, 0);
-
- std::vector<uint32_t> MdtRobList;
- std::vector<uint32_t> RpcRobList;
- std::vector<uint32_t> TgcRobList;
- std::vector<uint32_t> CscRobList;
-
- //MDT
- if (m_TrigMuonEF_saTrackTool->useMdtSeededDecoding())
- MdtRobList = m_TrigMuonEF_saTrackTool->getMdtRobList(muonRoI);
- else
- MdtRobList = m_TrigMuonEF_saTrackTool->getMdtRobList(0);
-
- //RPC
- if (m_TrigMuonEF_saTrackTool->useRpcSeededDecoding())
- RpcRobList = m_TrigMuonEF_saTrackTool->getRpcRobList(muonRoI);
- else
- RpcRobList = m_TrigMuonEF_saTrackTool->getRpcRobList(0);
-
- //TGC
- if (m_TrigMuonEF_saTrackTool->useTgcSeededDecoding())
- TgcRobList = m_TrigMuonEF_saTrackTool->getTgcRobList(muonRoI);
- else
- TgcRobList = m_TrigMuonEF_saTrackTool->getTgcRobList(0);
-
- //CSC
- if (m_TrigMuonEF_saTrackTool->useCscSeededDecoding())
- CscRobList = m_TrigMuonEF_saTrackTool->getCscRobList(muonRoI);
- else
- CscRobList = m_TrigMuonEF_saTrackTool->getCscRobList(0);
-
- RRInfo->addRequestScheduledRobIDs(MdtRobList);
- RRInfo->addRequestScheduledRobIDs(RpcRobList);
- RRInfo->addRequestScheduledRobIDs(TgcRobList);
- RRInfo->addRequestScheduledRobIDs(CscRobList);
-
- ATH_MSG_DEBUG( "prepareRobRequests found "<<MdtRobList.size()<<" MDT ROBs, "<<RpcRobList.size()<<" RPC ROBs, "<<TgcRobList.size()<< "TGC ROBs, and "<<CscRobList.size()<< " CSC ROBs");
-
- return HLT::OK;
-}
-// ----------------------------------------
-HLT::ErrorCode
-TrigMuSuperEF::hltInitialize()
-{
- m_debug = msgLvl() <= MSG::DEBUG;
- m_verbose = msgLvl() <= MSG::VERBOSE;
-
- ATH_MSG_DEBUG( "Start of Initializing TrigMuSuperEF" );
- ATH_MSG_DEBUG( "package version = " << PACKAGE_VERSION );
-
- if( m_fullScan ) {
- ATH_MSG_INFO("In full scan mode");
- if(m_doInsideOut) {
- ATH_MSG_ERROR("doInsideOut is set to true, but we are in full scan - please fix the setup");
- return HLT::BAD_JOB_SETUP;
- }
- if(!m_doOutsideIn) {
- ATH_MSG_ERROR("doOutsideIn is set to false, but we are in full scan - please fix the setup");
- return HLT::BAD_JOB_SETUP;
- }
-
- }//full scan
-
- if ( m_doInsideOut && m_doOutsideIn ) {
- if ( m_forceBoth ) {
- ATH_MSG_INFO("TrigMuGirl and TrigMuonEF always run both");
- } else if ( m_insideOutFirst ) {
- ATH_MSG_INFO("TrigMuGirl runs first and TrigMuonEF runs only if no muon found by TrigMuGirl");
- } else {
- ATH_MSG_INFO("TrigMuonEF runs first and TrigMuGirl runs only if no muon found by TrigMuonEF");
- }
- } else if ( m_doInsideOut ) {
- ATH_MSG_INFO("Only TrigMuGirl runs");
- } else if ( m_doOutsideIn ) {
- ATH_MSG_INFO("Only TrigMuonEF runs");
- }
-
- if ( m_standaloneOnly ) {
- ATH_MSG_INFO("Running in Muon Standalone Mode");
- }
-
- if( m_combinerOnly ) {
- ATH_MSG_INFO("Running in Combiner only Mode");
- if( m_standaloneOnly ) {
- ATH_MSG_ERROR("Cannot run in only MS-only and CB-only modes");
- return HLT::BAD_JOB_SETUP;
- }
- }
-
- if( m_caloTagOnly) {
- ATH_MSG_INFO("Running in Calotag-only Mode");
- if( m_standaloneOnly ) {
- ATH_MSG_ERROR("Cannot run in Calotag-only and MS-only modes");
- }
- if ( m_combinerOnly ) {
- ATH_MSG_ERROR("Cannot run in Calotag-only and Combined modes");
- }
- }
-
- if( m_segmentTagOnly)
- ATH_MSG_INFO("Running in segment tag-only Mode");
-
- if(!m_doOutsideIn && !m_doInsideOut) {
- ATH_MSG_ERROR( "Both MuonEF and MuGirl disabled" );
- return HLT::BAD_JOB_SETUP;
- }
-
- ATH_MSG_INFO("doTiming is set to: "<< doTiming());
- if(doTiming()) m_totalTime = addTimer("TrigMuSuperEF_totalTime");
-
- // for now always loading TrigMuonEF tools, or get errors when running MuGirl only (9-1-15)
- //if ( m_doOutsideIn ) {
- // TrigMuonEF algtools
- if(!m_combinerOnly) {
- if (m_TrigMuonEF_saTrackTool.retrieve().isSuccess()){
- ATH_MSG_INFO( "Retrieved " << m_TrigMuonEF_saTrackTool );
- }else{
- ATH_MSG_FATAL( "Could not get " << m_TrigMuonEF_saTrackTool );
- return HLT::BAD_JOB_SETUP;
- }
-
- if (doTiming()) m_TrigMuonEF_saTrackTool->setExtrapolatedTimers(this, m_TMEF_SATimers);
- m_TrigMuonEF_saTrackTool->declareExtrapolatedMonitoringVariables(this, m_TMEF_monVars);
- } else {
- // disable tools we don't need when in combiner-only mode
- m_TrigMuonEF_saTrackTool.disable();
- }
-
- if ( !m_standaloneOnly) {
- if (m_muonCombinedTool.retrieve().isSuccess()){
- msg() << MSG::INFO << "Retrieved " << m_muonCombinedTool << endmsg;
- }else{
- msg() << MSG::FATAL << "Could not get " << m_muonCombinedTool << endmsg;
- return HLT::BAD_JOB_SETUP;
- }
-
- if(m_muonSystemExtensionTool.retrieve().isSuccess()) {
- ATH_MSG_INFO("Retrieved " << m_muonSystemExtensionTool);
- } else {
- ATH_MSG_FATAL("Could not get " << m_muonSystemExtensionTool);
- return HLT::BAD_JOB_SETUP;
- }
-
- if (doTiming()) setCombinedTimers(this, m_TMEF_CBTimers);
- } else {
- // disable any tools we don't need in standalone-only mode
- m_muonCombinedTool.disable();
- m_muonSystemExtensionTool.disable();
- }
-
- // retrieve Trk::Track -> TrackParticle converter
- if (m_TrackToTrackParticleConvTool.retrieve().isSuccess()){
- msg() << MSG::INFO << "Retrieved " << m_TrackToTrackParticleConvTool << endmsg;
- }
- else{
- msg() << MSG::FATAL << "Could not get " << m_TrackToTrackParticleConvTool << endmsg;
- return HLT::BAD_JOB_SETUP;
- }
-
- // retrieve the tool for making xAOD muons
- if(m_muonCreatorTool.retrieve().isSuccess()){
- msg() << MSG::INFO << "Retrieved " << m_muonCreatorTool << endmsg;
- }
- else {
- msg() << MSG::FATAL << "Could not get " << m_muonCreatorTool << endmsg;
- return HLT::BAD_JOB_SETUP;
- }
-
- if(m_doInsideOut ){
- if( m_stauCreatorTool.retrieve().isSuccess()){
- msg() << MSG::INFO << "Retrieved " << m_stauCreatorTool << endmsg;
- }
- else {
- msg() << MSG::FATAL << "Could not get " << m_stauCreatorTool << endmsg;
- return HLT::BAD_JOB_SETUP;
- }
-
- // Retrieve TrigMuGirl tool
- ATH_MSG_INFO("Try to retrieve " << m_muGirlTool);
- if (m_muGirlTool.retrieve().isSuccess()) {
- ATH_MSG_INFO( "Retrieved " << m_muGirlTool );
- }else{
- ATH_MSG_FATAL( "Could not get " << m_muGirlTool );
- return HLT::BAD_JOB_SETUP;
- }
- } else {
- // disable tools when not running inside-out
- m_stauCreatorTool.disable();
- m_muGirlTool.disable();
- }
-
- if ( m_caloTagOnly ) {
- //Retreive CaloTagTool
- if(m_caloTagTool.retrieve().isSuccess()) {
- ATH_MSG_INFO( "Retrieved " << m_caloTagTool );
- }else{
- ATH_MSG_FATAL("Could not retrieve " << m_caloTagTool);
- return HLT::BAD_JOB_SETUP;
- }
- } else {
- // disable calo-tagging tool when not needed
- m_caloTagTool.disable();
- }
-
- if ( m_segmentTagOnly ) {
- //Retreive CaloTagTool
- if (m_muonSegmentTagTool.retrieve().isSuccess()){
- ATH_MSG_INFO( "Retrieved " << m_muonSegmentTagTool );
- }else{
- ATH_MSG_FATAL("Could not retrieve " << m_muonSegmentTagTool);
- return HLT::BAD_JOB_SETUP;
- }
- } else {
- // disable segment tagging tool when not needed
- m_muonSegmentTagTool.disable();
- }
-
- if ( m_segmentTagOnly ) {
- //Retreive CaloTagTool
- StatusCode sc = m_muonSegmentTagTool.retrieve();
- if(sc.isSuccess()){
- ATH_MSG_INFO( "Retrieved " << m_muonSegmentTagTool );
- }else{
- ATH_MSG_FATAL("Could not retrieve " << m_muonSegmentTagTool);
- return HLT::BAD_JOB_SETUP;
- }
- }
-
- if (!m_caloTagOnly) {
- ATH_MSG_INFO("Output MS-only track particle container = " << m_msTrackParticleContName);
- ATH_MSG_INFO("Output SA track particle container = " << m_saTrackParticleContName);
- ATH_MSG_INFO("Output CB track particle container = " << m_cbTrackParticleContName);
- ATH_MSG_INFO("Output muon container = " << m_muonContName);
- }
- else {
- ATH_MSG_INFO("Output CT track particle container = " << m_ctTrackParticleContName);
- }
-
- ATH_MSG_DEBUG("End of init TrigMuSuperEF");
- return HLT::OK;
-}
-
-//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-
-HLT::ErrorCode TrigMuSuperEF::hltEndEvent()
-{
-
- // delete the SegmentCache objects we created with new
- for(map<std::vector<std::vector<IdentifierHash> >, InternalCache*>::iterator itmap=m_CacheMap.begin(); itmap!=m_CacheMap.end(); ++itmap) {
- if(itmap->second) delete itmap->second;
- }
- // for(map<std::vector<std::vector<IdentifierHash> >, InternalCache*>::iterator itmap=m_CacheMapTMEFonly.begin(); itmap!=m_CacheMapTMEFonly.end(); ++itmap) {
- for(auto itmap : m_CacheMapTMEFonly){
- if(itmap.second) delete itmap.second;
- }
- ATH_MSG_VERBOSE("clearing SFCacheSCmap");
- m_CacheMap.clear();
- m_CacheMapTMEFonly.clear();
- m_hashlist.clear();
- clearCacheVector( m_tracksCache );
- clearCacheVector( m_segsCache );
-
- return HLT::OK;
-}
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-
-HLT::ErrorCode
-TrigMuSuperEF::hltExecute(const HLT::TriggerElement* inputTE, HLT::TriggerElement* TEout)
-{
- ResetTimers(m_TMEF_SATimers);
- ResetTimers(m_TMEF_CBTimers);
- ResetTimers(m_TrigMuGirl_Timers);
-
- if(doTiming()) m_totalTime->start(); //Start the clock
-
- ++m_counter.total;
- unsigned int teID = TEout->getId();
- ++m_counter_perTE[teID].total;
-
- clearRoiCache();
-
- HLT::ErrorCode hltStatus = HLT::OK;
- if (m_debug) {
- std::string teInLabel;
- std::string teOutLabel;
- TrigConf::HLTTriggerElement::getLabel( inputTE->getId(), teInLabel );
- TrigConf::HLTTriggerElement::getLabel( TEout->getId(), teOutLabel );
- ATH_MSG_DEBUG("hltExecute() TE inID=" << inputTE->getId() << " TE outID=" << TEout->getId()
- << " inLabel=" << teInLabel << " outLabel=" << teOutLabel);
- }
-
- //
- // prepare for execute
- //
- for(auto tMap : m_tagMaps) delete tMap;
- m_tagMaps.clear();
- auto muonContainerOwn = std::make_unique<xAOD::MuonContainer>();
- m_muonContainer = muonContainerOwn.get();
- xAOD::MuonAuxContainer muonAuxContainer;
- muonContainerOwn->setStore( &muonAuxContainer );
- ATH_MSG_DEBUG("Created xAOD::MuonContainer");
-
- HLT::ErrorCode ec = HLT::OK;
- if( m_combinerOnly) {
- ec = runCombinerOnly(inputTE, TEout,muonContainerOwn);
- } else if (m_caloTagOnly) {
- // run calotag mode
- ec = runCaloTagOnly(inputTE, TEout, muonContainerOwn);
- }
- else if (m_segmentTagOnly) {
- // run calotag mode
- ec = runSegmentTaggedOnly(inputTE, TEout, muonContainerOwn);
- }
- else { // not in combiner only mode
- ec = runStandardChain(inputTE, TEout,muonContainerOwn);
- }
- if(ec!=HLT::OK && ec!=HLT::MISSING_FEATURE) { // allow processing to finish for missing feature (e.g. when no muon found)
- ATH_MSG_ERROR("Problem in running TrigMuSuperEF");
- return ec;
- }
-
- //
- // post processing
- //
-
- for( auto muon : *m_muonContainer ) {
- ATH_MSG_DEBUG("Muon: author = " << muon->author() << ", " << "type = " << muon->muonType());
- ATH_MSG_DEBUG(" pt, eta, phi = " << muon->pt() << ", " << muon->eta() << ", " << muon->phi());
- }
-
- if (m_muonContainer->size()>0) {//may want to make this more clever looking e.g. at combined vs standalone
- ++m_counter.pass;
- ++m_counter_perTE[teID].pass;
- }
-
- // always fill monitoring histograms, even if no muon found
- if(!m_caloTagOnly) {
- fillMonitoringVars( );
- fillCBMonitoringVars( );
-
- } else {
- ATH_MSG_DEBUG("Filling monitoring vars with container size: " << m_ctTrackParticleContainer->size() );
- fillCTMonitoringVars( *m_ctTrackParticleContainer );
- }
-
- // no muon found is OK
- if (hltStatus == HLT::MISSING_FEATURE) hltStatus = HLT::OK;
-
- if(doTiming()) m_totalTime->stop(); //Stop the clock
-
- return hltStatus;
-}
-
-HLT::ErrorCode
-TrigMuSuperEF::hltFinalize()
-{
- HLT::ErrorCode hltStatus = HLT::OK;
- ATH_MSG_DEBUG( "Finalizing TrigMuSuperEF" );
- // call hltFinalize on all sub-algorithms
-
- ATH_MSG_INFO( "------------- TrigMuSuperEF Output ----------------" );
- if ( m_doInsideOut && m_doOutsideIn ) {
- if ( m_forceBoth ) {
- ATH_MSG_INFO("TrigMuGirl and TrigMuonEF were always run both");
- printTrigMuGirlStats();
- printTrigMuonEFStats();
- printTotalStats();
- } else if ( m_insideOutFirst ) {
- ATH_MSG_INFO("TrigMuGirl was run first and TrigMuonEF was run only if no muon found by TrigMuGirl");
- printTrigMuGirlStats();
- printTrigMuonEFStats();
- printTotalStats();
- } else {
- ATH_MSG_INFO("TrigMuonEF was run first and TrigMuGirl was run only if no muon found by TrigMuonEF");
- printTrigMuonEFStats();
- printTrigMuGirlStats();
- printTotalStats();
- }
- } else if ( m_doInsideOut ) {
- ATH_MSG_INFO("Only TrigMuGirl was run");
- printTrigMuGirlStats();
- } else if ( m_doOutsideIn ) {
- ATH_MSG_INFO("Only TrigMuonEF was run");
- printTrigMuonEFStats();
- } else if ( m_caloTagOnly ) {
- ATH_MSG_INFO("Only CaloTag was run");
- }
- printTEStats();
-
- return hltStatus;
-}
-
-HLT::ErrorCode TrigMuSuperEF::runCombinerOnly(const HLT::TriggerElement* inputTE, HLT::TriggerElement* TEout,std::unique_ptr<xAOD::MuonContainer> &muonContainerOwn) {
- // get xAOD ID tracks
- HLT::ErrorCode hltStatus;
- ElementLinkVector<xAOD::TrackParticleContainer> elv_xaodidtrks;
- ElementLinkVector<xAOD::TrackParticleContainer> elv_xaodidtrksL2;
- const xAOD::TrackParticleContainer l2idtrks;
- const xAOD::L2CombinedMuonContainer *l2combcont;
- hltStatus = getIDTrackParticleLinks(inputTE, elv_xaodidtrks);
- if(hltStatus != HLT::OK && hltStatus!=HLT::MISSING_FEATURE) {
- ATH_MSG_ERROR("Problem getting ID tracks");
- return hltStatus;
- }
-
- hltStatus = getIDTrackParticleLinksL2(inputTE, elv_xaodidtrksL2);
- if(hltStatus != HLT::OK && hltStatus!=HLT::MISSING_FEATURE) {
- ATH_MSG_ERROR("Problem getting ID tracks");
- return hltStatus;
- }
-
- InDetCandidateCollection inDetCandidates(0);
- inDetCandidates.reserve(elv_xaodidtrks.size());
- if(m_useL2Info){
- hltStatus=getFeature(inputTE,l2combcont);
- auto isSuccess = buildL2InDetCandidates(elv_xaodidtrksL2, &inDetCandidates, l2combcont);
- if(!isSuccess){
- buildInDetCandidates(elv_xaodidtrks, &inDetCandidates);
- fillIDMonitoringVars(elv_xaodidtrks);
- }
- }
- else{
- buildInDetCandidates(elv_xaodidtrks, &inDetCandidates);
- fillIDMonitoringVars(elv_xaodidtrks);
- }
-
- // get muons from the last step
- const xAOD::MuonContainer* lastMuons=0;
- hltStatus = getFeature(inputTE, lastMuons);
- if(hltStatus != HLT::OK || !lastMuons) {
- ATH_MSG_WARNING("Could not get xAOD::MuonContainer");
- return hltStatus;
- }
-
- m_extrTrkTrackColl=new TrackCollection();
- addElement( m_tracksCache, m_extrTrkTrackColl);
-
- // build muon candidates from the xAOD muons
- MuonCandidateCollection *muonCandidates = new MuonCandidateCollection();
- xAOD::TrackParticleContainer* combTrackParticleCont = new xAOD::TrackParticleContainer();
- xAOD::TrackParticleAuxContainer combTrackParticleAuxCont;
- combTrackParticleCont->setStore( &combTrackParticleAuxCont );
-
- // can remove the extrapolated track containers once the MuonCandidate no longer takes ownership of the track
- xAOD::TrackParticleContainer* saTrackParticleCont = new xAOD::TrackParticleContainer();
- xAOD::TrackParticleAuxContainer saTrackParticleAuxCont;
- saTrackParticleCont->setStore( &saTrackParticleAuxCont );
-
- for(auto muon : *lastMuons) {
- const ElementLink<xAOD::TrackParticleContainer>& saTrackLink = muon->extrapolatedMuonSpectrometerTrackParticleLink();
- if(saTrackLink.isValid() && muon->muonSpectrometerTrackParticleLink()) {
- const ElementLink<xAOD::TrackParticleContainer> msTrackLink = muon->muonSpectrometerTrackParticleLink();
- if(msTrackLink.isValid()) muonCandidates->push_back( new MuonCombined::MuonCandidate( msTrackLink, (*saTrackLink)->trackLink()));
- else ATH_MSG_WARNING("xAOD::Muon has msTrackLink, but it is not valid");
- }//valid Element Links
- }//loop on muons
-
-
- map<std::vector<std::vector<IdentifierHash> >, InternalCache*>::iterator itmap = m_CacheMap.end();
- const IRoiDescriptor* muonRoI = getRoiDescriptor(inputTE,TEout);
- m_hashlist.clear();
- m_hashlist = m_TrigMuonEF_saTrackTool->getHashList(muonRoI);
-
- if(m_doCache){
- itmap = m_CacheMap.find(m_hashlist);
- if (itmap!=m_CacheMap.end()) {
- InternalCache *cache = itmap->second;
- retrieveTrackContainersFromCache(cache, combTrackParticleCont, saTrackParticleCont);
- }
- else{//if cache not in map or we don't have all the containers
- //build the muons
- m_combTrkTrackColl = new TrackCollection();
- addElement( m_tracksCache, m_combTrkTrackColl);
- hltStatus = buildCombinedTracks( muonCandidates, inDetCandidates, m_TMEF_monVars.CB,m_TMEF_CBTimers);
- ATH_MSG_DEBUG( "Call buildMuons, n(inDetCandidates) = " << inDetCandidates.size());
- hltStatus = buildMuons( muonCandidates, &inDetCandidates, combTrackParticleCont, saTrackParticleCont);
- if(hltStatus!=HLT::OK) {
- if(muonCandidates) for(auto cand : *muonCandidates) delete cand;
- ATH_MSG_ERROR("Problem building muons");
- return hltStatus;
- }
- //Set all the containers in the cache
- if(muonCandidates && combTrackParticleCont && saTrackParticleCont && m_combTrkTrackColl && m_extrTrkTrackColl){
- InternalCache *cacheStore = new InternalCache();
- cacheStore->SetMuonCandidates(muonCandidates);
- cacheStore->SetCombinedTracks(combTrackParticleCont);
- cacheStore->SetSATracks(saTrackParticleCont);
- cacheStore->SetCombinedTrackColl(m_combTrkTrackColl);
- cacheStore->SetExtrapolatedTracks(m_extrTrkTrackColl);
-
- cacheStore->SetMuonContainer(m_muonContainer);
- //put the cache in the map
- m_CacheMap[m_hashlist] = cacheStore;
- }
- }//if cache not in map r containers are missing
- }
- else{//if not in do cache
- //build muons
- m_combTrkTrackColl = new TrackCollection();
- addElement( m_tracksCache, m_combTrkTrackColl);
- hltStatus = buildCombinedTracks( muonCandidates, inDetCandidates, m_TMEF_monVars.CB,m_TMEF_CBTimers);
- ATH_MSG_DEBUG( "Call buildMuons, n(inDetCandidates) = " << inDetCandidates.size());
- hltStatus = buildMuons( muonCandidates, &inDetCandidates, combTrackParticleCont, saTrackParticleCont);
- if(hltStatus!=HLT::OK) {
- if(muonCandidates) for(auto cand : *muonCandidates) delete cand;
- ATH_MSG_ERROR("Problem building muons");
- return hltStatus;
- }
- }
-
- if(muonCandidates) for(auto cand : *muonCandidates) delete cand;
-
- // attach output
- if(attachOutput( TEout, combTrackParticleCont, saTrackParticleCont, std::move(muonContainerOwn))!=HLT::OK) {
- ATH_MSG_WARNING("Problem attaching output");
- return HLT::MISSING_FEATURE;
- }
- return hltStatus;
-}// runCombinerOnly
-
-HLT::ErrorCode TrigMuSuperEF::runCaloTagOnly(const HLT::TriggerElement* inputTE, HLT::TriggerElement* TEout, std::unique_ptr<xAOD::MuonContainer>& muonContainerOwn) {
- ATH_MSG_DEBUG("Running CaloTag only mode");
-
- if (m_debug) {
- const auto roi = getRoiDescriptor(inputTE, TEout);
- ATH_MSG_DEBUG("Roi eta: " <<roi->etaMinus() << "-" << roi->eta() << "-" << roi->etaPlus());
- ATH_MSG_DEBUG("Roi phi: " <<roi->phiMinus() << "-" << roi->phi() << "-" << roi->phiPlus());
- }
-
- // get xAOD ID tracks
- ElementLinkVector<xAOD::TrackParticleContainer> elv_xaodidtrks;
- HLT::ErrorCode hltStatus = getIDTrackParticleLinks(inputTE, elv_xaodidtrks);
- if(hltStatus != HLT::OK && hltStatus!=HLT::MISSING_FEATURE) {
- ATH_MSG_ERROR("Problem retrieving ID tracks");
- return hltStatus;
- }
- ATH_MSG_DEBUG("ID Track particles size = " << elv_xaodidtrks.size());
-
- // build InDetCandidates
- InDetCandidateCollection inDetCandidates(0);
- buildInDetCandidates(elv_xaodidtrks, &inDetCandidates);
- ATH_MSG_DEBUG( "Inner detector muon candidates, n(inDetCandidates) = " << inDetCandidates.size());
-
- //Fill ID track monitoring variables
- fillIDMonitoringVars(elv_xaodidtrks);
-
- //Retrieve CaloCellContainer
- const CaloCellContainer* caloCellContainer = nullptr;
- if( (getFeature(inputTE, caloCellContainer, "") != HLT::OK) || !caloCellContainer ) {
- ATH_MSG_ERROR("Failed to retrieve CaloCellContainer");
- return HLT::MISSING_FEATURE;
- }
- //Retrieve CaloClusterContainer
- const xAOD::CaloClusterContainer* caloClusterContainer = nullptr;
- if( (getFeature(inputTE, caloClusterContainer, "") != HLT::OK) || !caloClusterContainer ) {
- ATH_MSG_ERROR("Failed to retrieve CaloClusterContainer");
- return HLT::MISSING_FEATURE;
- }
-
- //Do calotagging
- MuonCombined::InDetCandidateToTagMap* caloTagMap=new MuonCombined::InDetCandidateToTagMap();
- m_tagMaps.push_back(caloTagMap);
- m_caloTagTool->extend(inDetCandidates, caloTagMap, caloCellContainer, caloClusterContainer);
-
- ATH_MSG_DEBUG("Finished CaloTag");
-
- m_ctTrackParticleContainer = new xAOD::TrackParticleContainer();
- xAOD::TrackParticleAuxContainer tpAuxCont;
- m_ctTrackParticleContainer->setStore( &tpAuxCont );
-
- for (auto idCandidate : inDetCandidates) {
- // Get calotag and select tracks with successful tag
- const MuonCombined::CaloTag* calotag = dynamic_cast<const MuonCombined::CaloTag*>(caloTagMap->getTag(idCandidate));
-
- if (calotag == nullptr) {
- ATH_MSG_DEBUG("CaloTag was not attached to InDetCandidate");
- continue;
- }
-
- MuonCombined::IMuonCreatorTool::OutputData output(*muonContainerOwn);
- std::vector<const MuonCombined::TagBase*> tags;
- for(auto tmap : m_tagMaps){
- const MuonCombined::TagBase* tag=tmap->getTag(idCandidate);
- if(tag) tags.push_back(tag);
- }
- MuonCombined::InDetCandidateTags idCandTags(idCandidate,tags);
- m_muonCreatorTool->create(idCandTags, output);
-
- //attach to output container
- ATH_MSG_DEBUG("Attaching TrackParticle to TE");
-
- //Convoluted copy due to TrackParticle copy constructor not working correctly
- xAOD::TrackParticle* tp = new xAOD::TrackParticle();
- tp->makePrivateStore(idCandidate->indetTrackParticle());
-
- //Decorate tracks with Calotag results
- tp->auxdata<unsigned short>("CaloTag") = calotag->caloMuonIdTag();
- tp->auxdata<double>("CaloTagLH") = calotag->caloLRLikelihood();
-
- ATH_MSG_DEBUG("TPCont: " << m_ctTrackParticleContainer);
- //idTrackParticleCont->push_back( tp );
- //
- ATH_MSG_DEBUG("Size: " << m_ctTrackParticleContainer->size());
- m_ctTrackParticleContainer->push_back( tp );
-
- ATH_MSG_DEBUG("pT: " << tp->pt() << ", " << idCandidate->indetTrackParticle().pt());
- } // loop over InDetCandidates
-
-
- if (m_ctTrackParticleContainer->size() == 0) {
- ATH_MSG_DEBUG("No muons found");
- }
- // attach output
- if(attachOutput( TEout, m_ctTrackParticleContainer, 0, std::move(muonContainerOwn))!=HLT::OK) {
- ATH_MSG_WARNING("Problem attaching output");
- return HLT::MISSING_FEATURE;
- }
-
- return hltStatus;
-} //runCaloTagOnly
-
-//////////////////////// Run TrigMuonEF standalone reconstruction
-HLT::ErrorCode TrigMuSuperEF::runMSReconstruction(const IRoiDescriptor* muonRoI, HLT::TriggerElement* TEout, MuonCandidateCollection& muonCandidates, std::unique_ptr<xAOD::MuonContainer>& muonContainerOwn) {
- ATH_MSG_DEBUG("Call getExtrapolatedTracks");
-
- // Use standalone track tool to find muon candidate
- const EventContext& ctx = getContext();
- HLT::ErrorCode hltStatus = m_TrigMuonEF_saTrackTool->getExtrapolatedTracks(muonRoI, muonCandidates, *m_extrTrkTrackColl, m_TMEF_monVars, m_TMEF_SATimers, ctx);
-
- // only bail out in case of real problem. So still attach features if no muon found: important for caching!
- if ( hltStatus != HLT::OK && hltStatus != HLT::MISSING_FEATURE ) return hltStatus;
-
- hltStatus = attachSegments(TEout);
- if(hltStatus != HLT::OK)
- return hltStatus;
-
- hltStatus = attachMSTracks(TEout);
- if(hltStatus != HLT::OK)
- return hltStatus;
-
- // extract the MS track particles
- const xAOD::TrackParticleContainer* msTrackParticleCont = m_TrigMuonEF_saTrackTool->trackParticleContainerToAttach();
- const xAOD::TrackParticleAuxContainer* msTrackParticleAuxCont = m_TrigMuonEF_saTrackTool->trackParticleAuxContainerToAttach();
-
- if( msTrackParticleCont && msTrackParticleAuxCont ) {
- // attach MS track particles to the TE
- ATH_MSG_DEBUG( "Muon tracks container retrieved with size : " << msTrackParticleCont->size() );
- attachTrackParticleContainer( TEout, msTrackParticleCont, m_msTrackParticleContName);
- } else {
- ATH_MSG_WARNING("Problem with MS track particle container");
- if (!msTrackParticleCont || msTrackParticleCont->empty()) {
- ATH_MSG_DEBUG( "No muon tracks found: stop here to process the RoI." );
- if(msTrackParticleCont) delete msTrackParticleCont;
- return HLT::MISSING_FEATURE;
- }
- if(msTrackParticleCont) delete msTrackParticleCont;
- }
- if(msTrackParticleAuxCont) delete msTrackParticleAuxCont; // always clean up Aux container
-
- // record collections
- if (m_recordPatterns)
- m_TrigMuonEF_saTrackTool->recordPatterns();
- if (m_recordTracks)
- m_TrigMuonEF_saTrackTool->recordSpectrometerTracks();
-
- if ( m_standaloneOnly ) {
- ATH_MSG_DEBUG("In standalone only mode, call buildMuons");
- // create xAOD track particle container for extrapolated tracks
- ATH_MSG_DEBUG("Create xAOD::TrackParticleContainer for extrapolated tracks");
- xAOD::TrackParticleContainer* saTrackParticleCont = new xAOD::TrackParticleContainer();
- xAOD::TrackParticleAuxContainer saTrackParticleAuxCont;
- saTrackParticleCont->setStore( &saTrackParticleAuxCont );
- // and the track container
- // call muon builder, so muons are available to the hypos
- hltStatus = buildMuons( &muonCandidates, 0, 0, saTrackParticleCont );
- if(hltStatus!=HLT::OK) {
- ATH_MSG_ERROR("Error building muons");
- return hltStatus;
- }
-
- hltStatus = attachOutput( TEout, 0, saTrackParticleCont, std::move(muonContainerOwn) );
- if(hltStatus!=HLT::OK) {
- ATH_MSG_ERROR("Problem attaching output");
- return hltStatus;
- }
- }//standalone only
-
- return HLT::OK;
-}//runMSReconstruction
-
-HLT::ErrorCode TrigMuSuperEF::runSegmentTaggedOnly(const HLT::TriggerElement* inputTE, HLT::TriggerElement* TEout, std::unique_ptr<xAOD::MuonContainer> & muonContainer){
- HLT::ErrorCode hltStatus = HLT::OK;
- const IRoiDescriptor* muonRoI = getRoiDescriptor(inputTE,TEout);
- m_hashlist.clear();
- m_hashlist = m_TrigMuonEF_saTrackTool->getHashList(muonRoI);
- map<std::vector<std::vector<IdentifierHash> >, InternalCache*>::iterator itmap;
- if(!m_doInsideOut) itmap = m_CacheMapTMEFonly.end();
- else itmap = m_CacheMap.end();
-
- if ( not muonRoI ) {
- std::string teInLabel;
- std::string teOutLabel;
- TrigConf::HLTTriggerElement::getLabel( inputTE->getId(), teInLabel );
- TrigConf::HLTTriggerElement::getLabel( TEout->getId(), teOutLabel );
- ATH_MSG_WARNING("No RoI found in inputTE=\"" << teInLabel << "\" outputTE=\"" << teOutLabel << "\". Not running TrigMuonEF");
- return HLT::MISSING_FEATURE;
- }
-
- MuonCandidateCollection* muonCandidates;
- ElementLinkVector<xAOD::TrackParticleContainer> elv_xaodidtrks;
- hltStatus = getIDTrackParticleLinks(inputTE, elv_xaodidtrks);
- if(hltStatus != HLT::OK && hltStatus!=HLT::MISSING_FEATURE) {
- ATH_MSG_ERROR("Problem getting ID tracks");
- return hltStatus;
- }
- const EventContext& ctx = getContext();
- hltStatus = m_TrigMuonEF_saTrackTool->getSegments(muonRoI, m_TMEF_monVars, m_TMEF_STTimers, ctx);
-
- InDetCandidateCollection inDetCandidates;
- buildInDetCandidates(elv_xaodidtrks, &inDetCandidates);
-
- muonCandidates= new MuonCandidateCollection();
- ++m_counter_TrigMuonEF.total;
- hltStatus = runMSSegmentTaggedReconstruction(TEout, *muonCandidates, inDetCandidates, muonContainer );
-
- ++m_counter_TrigMuonEF.pass;// check this
-
- if(muonCandidates)
- delete muonCandidates;
-
- return hltStatus;
-}
-
-HLT::ErrorCode TrigMuSuperEF::runStandAlone(const IRoiDescriptor* muonRoI, HLT::TriggerElement* TEout, MuonCandidateCollection* muonCandidates, std::unique_ptr<xAOD::MuonContainer>& muonContainerOwn){
- //todo: muonCandidates don't have to be passed I guess
- muonCandidates= new MuonCandidateCollection();
- ++m_counter_TrigMuonEF.total;
- auto hltStatus = runMSReconstruction(muonRoI, TEout, *muonCandidates, muonContainerOwn );
- ++m_counter_TrigMuonEF.pass;
- if(muonCandidates)
- delete muonCandidates;
- return hltStatus;
-}
-
-HLT::ErrorCode TrigMuSuperEF::runStandardChain(const HLT::TriggerElement* inputTE, HLT::TriggerElement* TEout, std::unique_ptr<xAOD::MuonContainer> &muonContainerOwn)
-{
-
- HLT::ErrorCode hltStatus = HLT::OK;
- const IRoiDescriptor* muonRoI = getRoiDescriptor(inputTE,TEout);
- m_hashlist.clear();
- m_hashlist = m_TrigMuonEF_saTrackTool->getHashList(muonRoI);
- map<std::vector<std::vector<IdentifierHash> >, InternalCache*>::iterator itmap;
- if(!m_doInsideOut) itmap = m_CacheMapTMEFonly.end();
- else itmap = m_CacheMap.end();
-
- if (!muonRoI) {
- std::string teInLabel;
- std::string teOutLabel;
- TrigConf::HLTTriggerElement::getLabel( inputTE->getId(), teInLabel );
- TrigConf::HLTTriggerElement::getLabel( TEout->getId(), teOutLabel );
- ATH_MSG_WARNING("No RoI found in inputTE=\"" << teInLabel << "\" outputTE=\"" << teOutLabel << "\". Not running TrigMuonEF");
- return HLT::MISSING_FEATURE;
- }
-
- // pre-define objects that are needed in muon building
- InDetCandidateCollection inDetCandidates(0);
- MuonCandidateCollection* muonCandidates=nullptr;
-
- if(m_standaloneOnly){
- m_extrTrkTrackColl=new TrackCollection();
- addElement( m_tracksCache, m_extrTrkTrackColl);
- return runStandAlone(muonRoI, TEout, muonCandidates, muonContainerOwn);
- }
-
- // some kind of combined reco
- // get xAOD ID tracks
- ElementLinkVector<xAOD::TrackParticleContainer> elv_xaodidtrks;
- ElementLinkVector<xAOD::TrackParticleContainer> elv_xaodidtrksL2;
- const xAOD::TrackParticleContainer l2idtrks;
- const xAOD::L2CombinedMuonContainer *l2combcont;
- hltStatus = getIDTrackParticleLinks(inputTE, elv_xaodidtrks);
- if(hltStatus != HLT::OK && hltStatus!=HLT::MISSING_FEATURE) {
- ATH_MSG_ERROR("Problem getting ID tracks");
- return hltStatus;
- }
-
- hltStatus = getIDTrackParticleLinksL2(inputTE, elv_xaodidtrksL2);
- if(hltStatus != HLT::OK && hltStatus!=HLT::MISSING_FEATURE) {
- ATH_MSG_ERROR("Problem getting ID tracks");
- return hltStatus;
- }
-
- if(m_useL2Info){
- hltStatus=getFeature(inputTE,l2combcont);
- auto isSuccess = buildL2InDetCandidates(elv_xaodidtrksL2, &inDetCandidates, l2combcont);
- if(!isSuccess){
- buildInDetCandidates(elv_xaodidtrks, &inDetCandidates);
- fillIDMonitoringVars(elv_xaodidtrks);
- }
- }
- else{
- buildInDetCandidates(elv_xaodidtrks, &inDetCandidates);
- fillIDMonitoringVars(elv_xaodidtrks);
- }
- xAOD::TrackParticleContainer* combTrackParticleCont = new xAOD::TrackParticleContainer();
- xAOD::TrackParticleAuxContainer combTrackParticleAuxCont;
- xAOD::TrackParticleContainer* saTrackParticleCont = new xAOD::TrackParticleContainer();
- xAOD::TrackParticleAuxContainer saTrackParticleAuxCont;
- saTrackParticleCont->setStore( &saTrackParticleAuxCont );
- combTrackParticleCont->setStore( &combTrackParticleAuxCont );
-
-
- if(m_doCache){
- auto isSuccess = retrieveFromCache(itmap, muonCandidates, combTrackParticleCont, saTrackParticleCont);
- //todo: check if this can be returned directly
- if(!isSuccess)
- hltStatus = rebuildCache(muonRoI, TEout, muonCandidates, &inDetCandidates, combTrackParticleCont, saTrackParticleCont, muonContainerOwn, elv_xaodidtrks);
- }
- else{//not in do cache
- muonCandidates= new MuonCandidateCollection();
-
- m_combTrkTrackColl=new TrackCollection();
- addElement( m_tracksCache, m_combTrkTrackColl);
- m_extrTrkTrackColl=new TrackCollection();
- addElement( m_tracksCache, m_extrTrkTrackColl);
-
- if(m_doOutsideIn && (!m_insideOutFirst || !m_doInsideOut) ) { // run TrigMuonEF
- auto hltStatus = runOutsideInOnly(muonRoI, TEout, muonCandidates, &inDetCandidates, muonContainerOwn, elv_xaodidtrks);
- if(hltStatus != HLT::OK && hltStatus != HLT::MISSING_FEATURE)
- return hltStatus;
-
- if(m_doInsideOut) {
- if(m_forceBoth || hltStatus==HLT::MISSING_FEATURE) {
- m_muGirlTrkSegColl=new Trk::SegmentCollection();
- addElement(m_segsCache,m_muGirlTrkSegColl);
- runMuGirl(elv_xaodidtrks, &inDetCandidates);
- }
- }
- }//TrigMuonEF first
- if(m_doInsideOut && (m_insideOutFirst || !m_doOutsideIn)) {
- ATH_MSG_DEBUG( "Executing extend()" );
- ++m_counter_TrigMuGirl.total;
- const EventContext& ctx = getContext();
- hltStatus = m_TrigMuonEF_saTrackTool->getSegments(muonRoI, m_TMEF_monVars, m_TMEF_SATimers, ctx);
- MuonCombined::InDetCandidateToTagMap* mugirlTagMap=new MuonCombined::InDetCandidateToTagMap();
- m_tagMaps.push_back(mugirlTagMap);
-
- m_muGirlTrkSegColl=new Trk::SegmentCollection();
- addElement(m_segsCache,m_muGirlTrkSegColl);
-
- m_muGirlTool->extend(inDetCandidates,mugirlTagMap,m_combTrkTrackColl,m_extrTrkTrackColl,m_muGirlTrkSegColl, ctx);
-
- ++m_counter_TrigMuGirl.pass;//@todo fix this counter
-
- if(m_doOutsideIn) {
- bool foundMuon=false; // @todo: need to check if MuGirl tagged a muon - always assume it didn't for now
- if(m_forceBoth || !foundMuon) {
- // now run TrigMuonEF MS+CB
- ++m_counter_TrigMuonEF.total;
- hltStatus = runMSCBReconstruction( muonRoI, TEout, *muonCandidates, inDetCandidates, muonContainerOwn );
-
- if(hltStatus==HLT::OK) ++m_counter_TrigMuonEF.total;
- else if(hltStatus!=HLT::MISSING_FEATURE) { // missing feature indicates no muon - which we don't report as an error
- if(muonCandidates) delete muonCandidates;
- ATH_MSG_ERROR("Problem building combined tracks");
- return hltStatus;
- }
- }// need to run TrigMuonEF
- }//doOutsideIn
- }// MuGirl first
- ATH_MSG_DEBUG( "Call buildMuons, n(inDetCandidates) = " << inDetCandidates.size());
-
- hltStatus = buildMuons( muonCandidates, &inDetCandidates, combTrackParticleCont, saTrackParticleCont);
-
- if(hltStatus!=HLT::OK) {
- if(muonCandidates) delete muonCandidates;
- ATH_MSG_ERROR("Problem building muons");
- return hltStatus;
- }
- if(muonCandidates) delete muonCandidates;
- }//not doCache
-
- ATH_MSG_DEBUG("saTrackParticleCont size after buildMuons = " << saTrackParticleCont->size());
-
- // attach output
- if(attachOutput( TEout, combTrackParticleCont, saTrackParticleCont, std::move(muonContainerOwn) )!=HLT::OK) {
- ATH_MSG_WARNING("Problem attaching output");
- return HLT::MISSING_FEATURE;
- }
-
- if (hltStatus!=HLT::OK) return hltStatus;
-
- // no muon found
- if(!m_combTrkTrackColl || m_combTrkTrackColl->empty()) {
- ATH_MSG_DEBUG( "No combined tracks found by TrigMuonEF, return HLT::MISSING_FEATURE");
- return HLT::MISSING_FEATURE;
- }
-
- ATH_MSG_DEBUG("Found " << m_combTrkTrackColl->size() << " combined tracks, return HLT::OK");
- return HLT::OK; // found muon
-}
-
-HLT::ErrorCode TrigMuSuperEF::runMSCBReconstruction(const IRoiDescriptor* muonRoI,
- HLT::TriggerElement* TEout,
- MuonCandidateCollection& muonCandidates,
- InDetCandidateCollection& inDetCandidates, std::unique_ptr<xAOD::MuonContainer>& muonContainerOwn) {
-
- HLT::ErrorCode hltStatus = runMSReconstruction(muonRoI, TEout, muonCandidates, muonContainerOwn);
- if(hltStatus!=HLT::OK) {
- ATH_MSG_WARNING("Stop processing before looking for combined muons");
- return hltStatus;
- }
-
- ATH_MSG_DEBUG( "Executing buildCombinedTracks()" );
-
- // build combined tracks
- hltStatus = buildCombinedTracks(&muonCandidates,
- inDetCandidates,
- m_TMEF_monVars.CB,m_TMEF_CBTimers);
-
- return hltStatus;
-}
-
-HLT::ErrorCode TrigMuSuperEF::runMSSegmentTaggedReconstruction(HLT::TriggerElement* TEout,
- MuonCandidateCollection& muonCandidates,
- InDetCandidateCollection& inDetCandidates,
- std::unique_ptr<xAOD::MuonContainer>& muonContainerOwn) {
-
- ATH_MSG_DEBUG("Call runMSSegmentTaggedReconstruction ");
- HLT::ErrorCode hltStatus;
- if(m_doCache){
- map<std::vector<std::vector<IdentifierHash> >, InternalCache*>::iterator itmap;
- itmap = m_CacheMap.find(m_hashlist);
- if (itmap!=m_CacheMap.end()) {
- InternalCache *cache = itmap->second;
- muonCandidates = *(cache->MuonSTCandidates());
- }
- else{
- auto hltStatus = buildSegmentTaggedTracks(inDetCandidates);
- InternalCache *cacheStore = new InternalCache();
- hltStatus = buildMuons( &muonCandidates, &inDetCandidates, nullptr, nullptr);
- cacheStore->SetSegmentTaggedMuonCandidates(&muonCandidates);
- }
- }
- else{
- hltStatus = buildSegmentTaggedTracks(inDetCandidates);
- hltStatus = buildMuons( &muonCandidates, &inDetCandidates, nullptr, nullptr);
- }
- if(hltStatus!=HLT::OK) {
- ATH_MSG_ERROR("Error building muons");
- return hltStatus;
- }
-
- hltStatus = attachOutput( TEout, nullptr, nullptr, std::move(muonContainerOwn) );
- if(hltStatus!=HLT::OK) {
- ATH_MSG_ERROR("Problem attaching output");
- return hltStatus;
- }
- if(hltStatus!=HLT::OK) {
- ATH_MSG_WARNING("Stop processing before looking for combined muons");
- return hltStatus;
- }
-
- ATH_MSG_DEBUG( "Executing buildSegmentTaggedTracks()" );
-
- return hltStatus;
-}
-
-
-HLT::ErrorCode TrigMuSuperEF::buildSegmentTaggedTracks(InDetCandidateCollection& inDetCandidates) {
- std::vector<const Muon::MuonSegment*> segments;
- auto segmentCollection = m_TrigMuonEF_saTrackTool->segments();
- for(auto tseg : *segmentCollection){
- const Muon::MuonSegment* mseg=dynamic_cast<const Muon::MuonSegment*>(tseg);
- segments.push_back(mseg);
- }
- MuonCombined::InDetCandidateToTagMap* segmentTagMap=new MuonCombined::InDetCandidateToTagMap();
- m_tagMaps.push_back(segmentTagMap);
- m_muonSegmentTagTool->tag(inDetCandidates, segments, nullptr, segmentTagMap);
-
- for(auto candidate : inDetCandidates) {
- const MuonCombined::TagBase* tag=segmentTagMap->getTag(candidate);
- if(tag){
- if( tag->type() == xAOD::Muon::SegmentTagged )
- return HLT::OK;
- }
- }
- return HLT::MISSING_FEATURE;
-}
-
-/// Function to build combined tracks
-HLT::ErrorCode TrigMuSuperEF::buildCombinedTracks(const MuonCandidateCollection* muonCandidates,
- InDetCandidateCollection& inDetCandidates,
- TrigMuonEFCBMonVars& ,
- std::vector<TrigTimer*>& timers) {
-
- MuonCombined::InDetCandidateToTagMap* muidcoTagMap=new MuonCombined::InDetCandidateToTagMap();
- std::vector<MuonCombined::InDetCandidateToTagMap*> combinedTagMaps;
- combinedTagMaps.push_back(muidcoTagMap);
- m_tagMaps.push_back(muidcoTagMap);
-
- TrigTimer* trackFinderTime = 0;
- TrigTimer* dataOutputTime = 0;
- if ( timers.size() >= 1 ) trackFinderTime = timers[0];
- if ( timers.size() >= 2 ) dataOutputTime = timers[1];
-
- if(trackFinderTime) trackFinderTime->start();
-
- // call the combiner
- ATH_MSG_DEBUG("Call m_muonCombinedTool->combine, n(muon cand)=" << muonCandidates->size() << " n(ID cand)=" << inDetCandidates.size());
-
- if(muonCandidates) m_muonCombinedTool->combine( *muonCandidates, inDetCandidates, combinedTagMaps, m_combTrkTrackColl, m_extrTrkTrackColl) ;
-
- if(trackFinderTime) trackFinderTime->stop();
- if(dataOutputTime) dataOutputTime->start();
- if(muidcoTagMap->size()>0) return HLT::OK; //found combined muon
-
- if(dataOutputTime) dataOutputTime->stop();
- return HLT::MISSING_FEATURE; // if we got to here - no combined muon found
-}
-
-/**
- * Function to attach all the output info to the trigger element
- */
-HLT::ErrorCode TrigMuSuperEF::attachOutput(HLT::TriggerElement* TEout,
- xAOD::TrackParticleContainer* combinedTrackParticles,
- xAOD::TrackParticleContainer* extrapolatedTrackParticles, std::unique_ptr<xAOD::MuonContainer> muonContainerOwn) {
- // attach TrackCollection for extrapolated tracks
- if(m_extrTrkTrackColl) {
- std::string label="MuonEFExtrTrkTracks";
- if(m_standaloneOnly) label="MuonEFSATrkTracks";
- HLT::ErrorCode hltStatus = attachFeature(TEout, m_extrTrkTrackColl, label);
- if( hltStatus!=HLT::OK ) {
- ATH_MSG_WARNING("attaching muon standalone tracks to TEout: unsuccessful");
- return hltStatus;
- } else {
- ATH_MSG_DEBUG("attached muon standalone tracks. Size: " << m_extrTrkTrackColl->size());
- removeElement( m_tracksCache, m_extrTrkTrackColl ); // make sure we don't try to delete it later
- }
- }//valid extrapolated tracks
-
- // attach extrapolated track particles
- if(extrapolatedTrackParticles)
- attachTrackParticleContainer( TEout, extrapolatedTrackParticles, m_saTrackParticleContName );
-
- // attach info for combined tracks
- if(combinedTrackParticles && !m_caloTagOnly)
- attachTrackParticleContainer( TEout, combinedTrackParticles, m_cbTrackParticleContName);
-
- if(combinedTrackParticles && m_caloTagOnly)
- attachTrackParticleContainer( TEout, combinedTrackParticles, m_ctTrackParticleContName);
-
- if(m_combTrkTrackColl) {
- HLT::ErrorCode hltStatus = attachFeature(TEout, m_combTrkTrackColl, "MuonEFCombTrkTracks");
- if(hltStatus!=HLT::OK) {
- ATH_MSG_WARNING( "attaching combined tracks to TEout: unsuccessful" );
- return hltStatus;
- } else {
- ATH_MSG_DEBUG( "attached combined tracks. Size: " << m_combTrkTrackColl->size() );
- removeElement( m_tracksCache, m_combTrkTrackColl ); // make sure we don't try to delete it later
- }
-
- }
-
- // now pull back element links to the track particles and assign to the muons
- std::vector< std::pair< std::string, xAOD::Muon::TrackParticleType > > tpReassignVec;
- if(extrapolatedTrackParticles) tpReassignVec.push_back( std::make_pair(m_saTrackParticleContName, xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle) );
- if(combinedTrackParticles && !m_caloTagOnly) tpReassignVec.push_back( std::make_pair(m_cbTrackParticleContName, xAOD::Muon::CombinedTrackParticle) );
- if(m_caloTagOnly) tpReassignVec.push_back(std::make_pair(m_ctTrackParticleContName, xAOD::Muon::InnerDetectorTrackParticle) );
-
- // loop on the containers we need to do this for
- for(auto reassignEle : tpReassignVec) {
-
- ATH_MSG_DEBUG("Start EleLink reassignment for " << reassignEle.first);
- ElementLinkVector<xAOD::TrackParticleContainer> elv_xaodtrks;
- HLT::ErrorCode hltStatus = getFeaturesLinks<xAOD::TrackParticleContainer,xAOD::TrackParticleContainer>(TEout, elv_xaodtrks, reassignEle.first);
- if( hltStatus != HLT::OK ) {
- ATH_MSG_WARNING("Failed to get ElementLinkVector<xAOD::TrackParticleContainer>, " << reassignEle.first << " links in xAOD::Muon will be bad after writing to disk");
- } else {
- // loop on muons
- for(auto muon : *muonContainerOwn) {
- // skip if muon has no MS TP
- if(!muon->trackParticleLink(reassignEle.second).isValid()) continue;
-
- bool foundmatch=false;
- const xAOD::TrackParticle* tp = *(muon->trackParticleLink(reassignEle.second));
- ATH_MSG_DEBUG("Try to find ElementLink for TP with pT = " << tp->pt());
-
- // loop on the vector of element links
- for(auto trklink : elv_xaodtrks) {
- if(!trklink.isValid()) continue;
- ATH_MSG_VERBOSE("Try next EleLink, pt = " << (*trklink)->pt());
- if( (*trklink)->pt() == tp->pt() ) {
- ATH_MSG_DEBUG("Found matching element link for this track particle, re-assign to xAOD::Muon, pt = " << (*trklink)->pt());
- muon->setTrackParticleLink( reassignEle.second, trklink);
- foundmatch=true;
- break; // break from for loop
- }// match
- }//loop on element links to track particles
- if(!foundmatch) ATH_MSG_WARNING("Did not find matching element link for this track particle, link in xAOD::Muon will be bad after writing to disk");
-
- }//loop on muons
- }
- }// loop on the trackparticles we need to reassign
-
- // attach xAOD muon container to TE
-
- if(muonContainerOwn) {
- size_t sz = muonContainerOwn->size();
- HLT::ErrorCode hltStatus = attachFeature(TEout, muonContainerOwn.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 " << sz );
- }
- }
-
- return HLT::OK;
-}
-
-/**
- * Function to build xAOD muons from the results of the trigger reconstruction
- */
-HLT::ErrorCode TrigMuSuperEF::buildMuons(const MuonCandidateCollection* muonCandidates,
- InDetCandidateCollection* inDetCandidates,
- xAOD::TrackParticleContainer* combinedTrackParticles,
- xAOD::TrackParticleContainer* extrapolatedTrackParticles) {
-
- // call muon creator tool to fill all xAOD objects
- // note, this also does duplicate removal
-
- ATH_MSG_DEBUG("Call m_muonCreatorTool->create");
- MuonCombined::IMuonCreatorTool::OutputData output(*m_muonContainer);
- output.combinedTrackParticleContainer = combinedTrackParticles;
- output.combinedTrackCollection = m_combTrkTrackColl;
-
- output.extrapolatedTrackParticleContainer = extrapolatedTrackParticles;
- output.extrapolatedTrackCollection = m_extrTrkTrackColl;
-
- std::vector<const MuonCombined::InDetCandidateToTagMap*> tagMaps;
- for(auto tmap : m_tagMaps){
- const MuonCombined::InDetCandidateToTagMap* ctmap=new MuonCombined::InDetCandidateToTagMap(*tmap);
- tagMaps.push_back(ctmap);
- }
-
- m_muonCreatorTool->create( muonCandidates, inDetCandidates, tagMaps, output);
- if( m_doInsideOut ) m_stauCreatorTool->create( 0, inDetCandidates, tagMaps, output);
-
- tagMaps.clear();
-
- ATH_MSG_DEBUG("N(input SA) = " << muonCandidates->size() << " N(SA from muon creator tool) = " << m_extrTrkTrackColl->size());
-
- if(combinedTrackParticles) ATH_MSG_DEBUG("n(xAOD combinedTrackParticles)=" << combinedTrackParticles->size());
- if(extrapolatedTrackParticles) ATH_MSG_DEBUG("n(xAOD extrapolatedTrackParticles)=" << extrapolatedTrackParticles->size());
- ATH_MSG_DEBUG("n(xAOD muons)=" << m_muonContainer->size());
- if(m_combTrkTrackColl) ATH_MSG_DEBUG("n(tracks) in m_combTrkTrackColl = " << m_combTrkTrackColl->size());
-
- return HLT::OK;
-}
-
-void TrigMuSuperEF::fillIDMonitoringVars(const ElementLinkVector<xAOD::TrackParticleContainer>& elv_idtrks){
-
- ATH_MSG_DEBUG( "Inner detector track monitoring started, container has size : " << elv_idtrks.size() );
- m_monVars.nIDTrks.push_back(elv_idtrks.size());
- for(auto elidtrk : elv_idtrks) {
- if(elidtrk.isValid()) {
- const xAOD::TrackParticle* idtrk = *elidtrk;
- m_monVars.IDTrk_phi.push_back(idtrk->phi());
- m_monVars.IDTrk_eta.push_back(idtrk->eta());
- m_monVars.IDTrk_pT.push_back( idtrk->pt() / Units::GeV );
- }
- }//loop on ID tracks
-}
-
-
-void TrigMuSuperEF::fillCTMonitoringVars( const xAOD::TrackParticleContainer& idTrks )
-{
- ATH_MSG_DEBUG("Filling CaloTag monitoring variables");
-
- m_TrigCaloTag_monVars.numberOfTracks.push_back(idTrks.size());
-
- for ( auto trk : idTrks ) {
-
- uint8_t numberOfPixelHits=0;
- uint8_t numberOfSCTHits=0;
- uint8_t numberOfTRTHits=0;
- if( trk->summaryValue(numberOfPixelHits,xAOD::numberOfPixelHits) )
- ATH_MSG_DEBUG("Successfully retrieved the integer value, numberOfPixelHits");
- if( trk->summaryValue(numberOfSCTHits,xAOD::numberOfSCTHits) )
- ATH_MSG_DEBUG("Successfully retrieved the integer value, numberOfSCTHits");
- if( trk->summaryValue(numberOfTRTHits,xAOD::numberOfTRTHits) )
- ATH_MSG_DEBUG("Successfully retrieved the integer value, numberOfTRTHits");
-
- m_TrigCaloTag_monVars.nSct.push_back(numberOfSCTHits);
- m_TrigCaloTag_monVars.nPixel.push_back(numberOfPixelHits);
- m_TrigCaloTag_monVars.nTrt.push_back(numberOfTRTHits);
- m_TrigCaloTag_monVars.IDTrk_CaloTag.push_back(trk->auxdata<unsigned short>("CaloTag"));
- m_TrigCaloTag_monVars.d0.push_back( trk->d0() );
- m_TrigCaloTag_monVars.z0.push_back( trk->z0() );
- m_TrigCaloTag_monVars.IDTrk_phi.push_back(trk->phi());
- m_TrigCaloTag_monVars.IDTrk_eta.push_back(trk->eta());
- m_TrigCaloTag_monVars.IDTrk_pT.push_back(trk->pt() / Units::GeV);
- m_TrigCaloTag_monVars.IDTrk_CaloLH.push_back(trk->auxdata<double>("CaloTagLH"));
- }
- return;
-}
-
-void TrigMuSuperEF::fillMonitoringVars( ) {
- //To be fixed: Still need to get some hit information.
-
- unsigned int nTracks = 0;
- for(auto muon : *m_muonContainer) {
-
- const xAOD::TrackParticle *trkpart = muon->primaryTrackParticle();
-
-
- ATH_MSG_DEBUG("muon type " << muon->muonType() << " muon pt " << muon->pt() << " trk d0 " << trkpart->d0() << " trk z0 " << trkpart->z0() << " trk chi2 " <<trkpart->chiSquared() << " trk charge "<<trkpart->charge());
- ++nTracks;
- if(m_debug) {
- if(muon->muonSpectrometerTrackParticleLink()) {
- const ElementLink<xAOD::TrackParticleContainer> msTrackLink = muon->muonSpectrometerTrackParticleLink();
- if(msTrackLink.isValid()) ATH_MSG_DEBUG(" muon MS track before extrapolation pt = " << (*msTrackLink)->pt());
- else ATH_MSG_DEBUG(" muon MS track before extrapolation is not valid");
- } else ATH_MSG_DEBUG( " no MS track link available for this muon");
- }
-
- uint8_t numberOfPixelHits=0;
- uint8_t numberOfSCTHits=0;
- uint8_t numberOfTRTHits=0;
- if( trkpart->summaryValue(numberOfPixelHits,xAOD::numberOfPixelHits) ){
- ATH_MSG_DEBUG("Successfully retrieved the integer value, numberOfPixelHits");
- }
- if( trkpart->summaryValue(numberOfSCTHits,xAOD::numberOfSCTHits) ){
- ATH_MSG_DEBUG("Successfully retrieved the integer value, numberOfSCTHits");
- }
- if( trkpart->summaryValue(numberOfTRTHits,xAOD::numberOfTRTHits) ){
- ATH_MSG_DEBUG("Successfully retrieved the integer value, numberOfTRTHits");
- }
-
- m_monVars.type.push_back(muon->muonType());
- m_monVars.charge.push_back( trkpart->charge() );
- m_monVars.chi2.push_back( trkpart->chiSquared() );
- if(trkpart->numberDoF()>0) m_monVars.chi2Prob.push_back( trkpart->chiSquared()/trkpart->numberDoF() );
- float matchchi2 = 0.0;
- muon->parameter(matchchi2,xAOD::Muon::msOuterMatchChi2);
- m_monVars.matchChi2.push_back( matchchi2 );
- m_monVars.pt.push_back( muon->pt() / Units::GeV );
- m_monVars.phi.push_back( muon->phi() );
- m_monVars.eta.push_back( muon->eta() );
- m_monVars.d0.push_back( trkpart->d0() );
- m_monVars.z0.push_back( trkpart->z0() );
- m_monVars.nSct.push_back( numberOfSCTHits );
- m_monVars.nPixel.push_back( numberOfPixelHits );
- m_monVars.nTrt.push_back( numberOfTRTHits );
- }//loop over muons
- m_monVars.numberOfTracks.push_back(nTracks);
-
-}
-
-void TrigMuSuperEF::fillCBMonitoringVars() {
-
- //To be fixed: Still need to get some hit information.
-
- unsigned int nTracks = 0;
- for(auto muon : *m_muonContainer) {
- if(muon->muonType()!=0) continue;
- const xAOD::TrackParticle *trkpart = muon->primaryTrackParticle();
-
-
- ATH_MSG_DEBUG("muon type " << muon->muonType() << " muon pt " << muon->pt() << " trk d0 " << trkpart->d0() << " trk z0 " << trkpart->z0() << " trk chi2 " <<trkpart->chiSquared() << " trk charge "<<trkpart->charge());
- ++nTracks;
- if(m_debug) {
- if(muon->muonSpectrometerTrackParticleLink()) {
- const ElementLink<xAOD::TrackParticleContainer> msTrackLink = muon->muonSpectrometerTrackParticleLink();
- if(msTrackLink.isValid()) ATH_MSG_DEBUG(" muon MS track before extrapolation pt = " << (*msTrackLink)->pt());
- else ATH_MSG_DEBUG(" muon MS track before extrapolation is not valid");
- } else ATH_MSG_DEBUG( " no MS track link available for this muon");
- }
-
- uint8_t numberOfPixelHits=0;
- uint8_t numberOfSCTHits=0;
- uint8_t numberOfTRTHits=0;
- if( trkpart->summaryValue(numberOfPixelHits,xAOD::numberOfPixelHits) ){
- ATH_MSG_DEBUG("Successfully retrieved the integer value, numberOfPixelHits");
- }
- if( trkpart->summaryValue(numberOfSCTHits,xAOD::numberOfSCTHits) ){
- ATH_MSG_DEBUG("Successfully retrieved the integer value, numberOfSCTHits");
- }
- if( trkpart->summaryValue(numberOfTRTHits,xAOD::numberOfTRTHits) ){
- ATH_MSG_DEBUG("Successfully retrieved the integer value, numberOfTRTHits");
- }
-
- m_TMEF_monVars.CB.chi2.push_back( trkpart->chiSquared() );
- float matchchi2 = 0.0;
- muon->parameter(matchchi2,xAOD::Muon::msOuterMatchChi2);
- m_TMEF_monVars.CB.matchChi2.push_back( matchchi2 );
- m_TMEF_monVars.CB.pt.push_back( muon->pt() / Units::GeV );
- m_TMEF_monVars.CB.phi.push_back( muon->phi() );
- m_TMEF_monVars.CB.eta.push_back( muon->eta() );
- m_TMEF_monVars.CB.d0.push_back( trkpart->d0() );
- m_TMEF_monVars.CB.z0.push_back( trkpart->z0() );
- m_TMEF_monVars.CB.nSct.push_back( numberOfSCTHits );
- m_TMEF_monVars.CB.nPixel.push_back( numberOfPixelHits );
- m_TMEF_monVars.CB.nTrt.push_back( numberOfTRTHits );
- }//loop over muons
- m_TMEF_monVars.CB.numberOfTracks.push_back(nTracks);
-
-}
-
-void TrigMuSuperEF::printCounterStats( const PassCounters& counter, const std::string& source, int precision ) const {
- double ratio = 0.0;
- if ( counter.total ) ratio = ((double)counter.pass) / ((double)counter.total);
- ATH_MSG_INFO("Number of ROI's processed " << source << ": " << counter.total
- << " found muons: " << counter.pass
- << " fraction: " << std::setprecision(precision) << ratio);
-}
-
-void TrigMuSuperEF::printTrigMuonEFStats() const {
- printCounterStats( m_counter_TrigMuonEF, "by TrigMuonEF" );
-}
-
-void TrigMuSuperEF::printTrigMuGirlStats() const {
- printCounterStats( m_counter_TrigMuGirl, "by TrigMuGirl" );
-}
-
-void TrigMuSuperEF::printTotalStats() const {
- printCounterStats( m_counter, "in total", 4 );
-}
-
-void TrigMuSuperEF::printTEStats() const {
- std::map<unsigned int,PassCounters>::const_iterator itC = m_counter_perTE.begin(), itC_end = m_counter_perTE.end();
- std::string tePrefix = "in TE ";
- std::string teLabel;
- for ( ; itC != itC_end; ++itC ) {
- TrigConf::HLTTriggerElement::getLabel( itC->first, teLabel );
- printCounterStats( itC->second, tePrefix + teLabel, 4 );
- }
-}
-
-
-const IRoiDescriptor* TrigMuSuperEF::getRoiDescriptor(const HLT::TriggerElement* inputTE, HLT::TriggerElement* outputTE) {
- if (!m_roi) {
- HLT::ErrorCode hltStatus = HLT::OK;
- const TrigRoiDescriptor* trigRoI = 0;
- const TrigRoiDescriptor* superRoI = 0;
- TrigRoiDescriptor* newTrigRoI = 0;
- // only get RoI if not in full scan mode. For full scan mode, 0 pointer for RoI is fine
-
- if(m_fullScan) {
- // first try to retrieve (partial) full-scan SuperRoI
- hltStatus = getFeature(inputTE, superRoI, "forMSFS");
- if ( hltStatus != HLT::OK ) {
- ATH_MSG_DEBUG("Failure in getFeature((composite)TrigRoiDescriptor,\"forMSFS\") due to internal navigation error");
- } else if (superRoI) {
- if ( !superRoI->composite() ) {
- ATH_MSG_DEBUG("Retrieved TrigRoiDescriptor \"forMFFS\" is not a composite RoI");
- if(superRoI->isFullscan()) m_roi = superRoI;
- }
- else {
- ATH_MSG_VERBOSE("Retrieved (composite)TrigRoiDescriptor \"forMFFS\"");
- m_roi = superRoI;
- }
- } else {
- ATH_MSG_DEBUG("Could not find (composite)TrigRoiDescriptor \"forMSFS\", trying to get the default one (\"\")");
- // try with default SuperRoI (latest added?)
- hltStatus = getFeature(inputTE, superRoI, "");
- if ( hltStatus != HLT::OK ) {
- ATH_MSG_DEBUG("Failure in getFeature((composite)TrigRoiDescriptor,\"\") due to internal navigation error");
- } else if (superRoI) {
- if ( !superRoI->composite() ) {
- ATH_MSG_DEBUG("Retrieved TrigRoiDescriptor \"forMFFS\" is not a composite RoI, fullScan setting of RoI= " << superRoI->isFullscan());
-
- if(superRoI->isFullscan()) m_roi = superRoI;
- }
- else {
- ATH_MSG_VERBOSE("Retrieved (composite)TrigRoiDescriptor \"\"");
- m_roi = superRoI;
- }
- }
- if(m_roi==0) {
- // no RoI found, create new full-scan RoI
- ATH_MSG_VERBOSE("No (composite)TrigRoiDescriptor found. Creating new full-scan RoI");
- newTrigRoI = new TrigRoiDescriptor(true);
- /// newTrigRoI->set_roiId(10000); /// do we need this identifier set ???
- m_Roi_StillToBeAttached = newTrigRoI;
- m_roi = newTrigRoI;
- }
- }
- // end of if m_fullScan
- } else if(m_caloTagOnly){
- hltStatus = getFeature(inputTE, trigRoI, "forID1"); // RoI based
- if (hltStatus != HLT::OK) {
- ATH_MSG_DEBUG("Failure in getFeature(TrigRoIDescriptor,\"forID1\") due to internal navigation error");
- m_roi = 0;
- return 0;
- } else if (trigRoI) { // Found it!
- ATH_MSG_VERBOSE("Found RoIDescriptor \"forID1\"");
- } else { // did not find it
- ATH_MSG_DEBUG("Could not find RoIDescriptor \"forID1\", trying to recover the L1 one (with \"\")");
- hltStatus = getFeature(inputTE, trigRoI, "");
- if (hltStatus != HLT::OK) {
- ATH_MSG_DEBUG("Failure in getFeature(TrigRoIDescriptor) due to internal navigation error");
- m_roi = 0;
- return 0;
- } else if (trigRoI) { // found it!
- ATH_MSG_VERBOSE("Found (L1) RoIDescriptor \"\"");
- } else { // did not find it
- ATH_MSG_DEBUG("Could not find (L1) RoIDescriptor \"\"");
- m_roi = 0;
- return 0;
- }
- }
-
- if (trigRoI) {
- newTrigRoI = createSingleTrigRoiDescriptor( trigRoI->eta(), trigRoI->phi(), m_dEtaRoI, m_dPhiRoI, trigRoI->roiId() );
- m_Roi_StillToBeAttached = newTrigRoI;
- m_roi = newTrigRoI;
- } // if trigRoI
-
- }
- else {
- // RoI mode
- hltStatus = getFeature(inputTE, trigRoI, "forMS"); // RoI based
- if (hltStatus != HLT::OK) {
- ATH_MSG_DEBUG("Failure in getFeature(TrigRoIDescriptor,\"forMS\") due to internal navigation error");
- m_roi = 0;
- return 0;
- } else if (trigRoI) { // Found it!
- ATH_MSG_DEBUG("Found RoIDescriptor \"forMS\""
- <<trigRoI->eta() << " " << trigRoI->phi());
- } else { // did not find it
- ATH_MSG_DEBUG("Could not find RoIDescriptor \"forMS\", trying to recover the L1 one (with \"\")");
- hltStatus = getFeature(inputTE, trigRoI, "");
- if (hltStatus != HLT::OK) {
- ATH_MSG_DEBUG("Failure in getFeature(TrigRoIDescriptor) due to internal navigation error");
- m_roi = 0;
- return 0;
- } else if (trigRoI) { // found it!
- ATH_MSG_VERBOSE("Found (L1) RoIDescriptor \"\"");
- } else { // did not find it
- ATH_MSG_DEBUG("Could not find (L1) RoIDescriptor \"\"");
- m_roi = 0;
- return 0;
- }
- }
-
- if (trigRoI) {
- newTrigRoI = new TrigRoiDescriptor(unsigned(0), unsigned(trigRoI->roiId()), trigRoI->eta(), trigRoI->etaMinus(), trigRoI->etaPlus(), trigRoI->phi(), trigRoI->phiMinus(), trigRoI->phiPlus());
- m_Roi_StillToBeAttached = newTrigRoI;
- m_roi = newTrigRoI;
- } // if trigRoI
-
- } // RoI mode
- } //if(!m_roi)
-
- if(outputTE && m_Roi_StillToBeAttached){
- attachFeature(outputTE, m_Roi_StillToBeAttached, "forSA");
- m_Roi_StillToBeAttached = 0;
- }
-
- return m_roi;
-}
-
-TrigRoiDescriptor* TrigMuSuperEF::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);
- TrigRoiDescriptor* muonRoI = new TrigRoiDescriptor(unsigned(0), unsigned(roiNum), eta, minEta, maxEta, phi, minphi, maxphi);
- // muonRoI->set_roiId(roiNum);
-
- ATH_MSG_VERBOSE( "Creating Roi #" << roiNum << " with center " << " (eta,phi) = (" << eta << "," << phi
- << ") and size (dEta,dPhi) = (" << etaWidth << "," << phiWidth << ")" <<
- " ==> etaRange = " << minEta << " -> " << maxEta <<
- " phiRange = " << minphi << " -> " << maxphi );
-
- return muonRoI;
-}
-
-
-void TrigMuSuperEF::ResetTimers(std::vector<TrigTimer*>& timers){
- for(std::vector<TrigTimer*>::const_iterator time_it=timers.begin(); time_it!=timers.end(); time_it++){
- (*time_it)->reset();
- }
-}
-
-void TrigMuSuperEF::attachTrackParticleContainer( HLT::TriggerElement* TEout, const xAOD::TrackParticleContainer* trackParticleCont, const std::string& name) {
-
- if(trackParticleCont) {
- HLT::ErrorCode hltStatus = attachFeature(TEout, trackParticleCont , name);
- if(hltStatus!=HLT::OK) {
- msg() << MSG::WARNING << "Attaching xAOD::TrackParticleContainer " << trackParticleCont << " with name " << name << " to TEout: unsuccessful" << endmsg;
- if(trackParticleCont) delete trackParticleCont;
- }
- else{
- if (m_debug) msg() << MSG::DEBUG << "Successfully attached to TEout the xAOD track particle container " << name << " with size " << trackParticleCont->size() << endmsg;
- }
- }//valid xAOD::TrackParticle container
- else {
- msg() << MSG::WARNING << "Called attachTrackParticleContainer with null TrackParticleContainer, name = " << name << ", likely a problem in the code" << endmsg;
- }
-}
-
-// declare all monitored variables relating to combined muons
-void TrigMuSuperEF::declareCombinedMonitoringVariables(TrigMuonEFCBMonVars& monVars)
-{
- declareMonitoredStdContainer ("EF_cbtrks_n", monVars.numberOfTracks, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_cbtrks_chi2", monVars.chi2, IMonitoredAlgo::AutoClear);
- //declareMonitoredStdContainer ("EF_cbtrks_chi2Prob", monVars.chi2Prob, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_cbtrks_match_chi2", monVars.matchChi2, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_cbtrks_pt", monVars.pt, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_cbtrks_phi", monVars.phi, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_cbtrks_eta", monVars.eta, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_cbtrks_d0", monVars.d0, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_cbtrks_z0", monVars.z0, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_cbtrks_nMdt", monVars.nMdt, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_cbtrks_nRpcEta", monVars.nRpcEta, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_cbtrks_nRpcPhi", monVars.nRpcPhi, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_cbtrks_nCscEta", monVars.nCscEta, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_cbtrks_nCscPhi", monVars.nCscPhi, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_cbtrks_nTgcEta", monVars.nTgcEta, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_cbtrks_nTgcPhi", monVars.nTgcPhi, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_cbtrks_nHit", monVars.nHit, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_cbtrks_nIdSctHit", monVars.nSct, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_cbtrks_nIdPixelHit", monVars.nPixel, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_cbtrks_nIdTrtHit", monVars.nTrt, IMonitoredAlgo::AutoClear);
-
- return;
-}
-
-
-void TrigMuSuperEF::declareCaloTagMonitoringVariables(TrigMuonCaloTagMonVars& monVars)
-{
- ATH_MSG_DEBUG("Declaring monitored CaloTag variables");
-
- declareMonitoredStdContainer ("EF_cttrks_n", monVars.numberOfTracks, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_cttrks_nHit", monVars.nHit, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_cttrks_nIdSctHit", monVars.nSct, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_cttrks_nIdPixelHit", monVars.nPixel, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_cttrks_nIdTrtHit", monVars.nTrt, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_cttrks_caloTag", monVars.IDTrk_CaloTag, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_cttrks_d0", monVars.d0, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_cttrks_z0", monVars.z0, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_cttrks_phi", monVars.IDTrk_phi, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_cttrks_eta", monVars.IDTrk_eta, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_cttrks_pT", monVars.IDTrk_pT, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer ("EF_cttrks_caloLH", monVars.IDTrk_CaloLH, IMonitoredAlgo::AutoClear);
-
- return;
-}
-
-
-
-HLT::ErrorCode TrigMuSuperEF::getIDTrackParticleLinks(const HLT::TriggerElement* te, ElementLinkVector<xAOD::TrackParticleContainer>& elv_xaodidtrks) {
- // get element links to the ID tracks
- HLT::ErrorCode hltStatus = getFeaturesLinks<xAOD::TrackParticleContainer,xAOD::TrackParticleContainer>(te, elv_xaodidtrks, m_idTrackParticlesName);
- if( hltStatus != HLT::OK )
- ATH_MSG_WARNING("Failed to get ElementLinkVector<xAOD::TrackParticleContainer>, " << m_idTrackParticlesName << " aborting this ROI");
- return hltStatus;
-}
-
-HLT::ErrorCode TrigMuSuperEF::getIDTrackParticleLinksL2(const HLT::TriggerElement* te, ElementLinkVector<xAOD::TrackParticleContainer>& elv_xaodidtrks) {
- HLT::ErrorCode hltStatus = getFeaturesLinks<xAOD::TrackParticleContainer,xAOD::TrackParticleContainer>(te, elv_xaodidtrks, "InDetTrigTrackingxAODCnv_Muon_FTF");
- return hltStatus;
-}
-
-
-void TrigMuSuperEF::setCombinedTimers(HLT::Algo* fexAlgo, std::vector<TrigTimer*>& timers){
- ATH_MSG_INFO("Setting TMEF Combined Timers");
- timers.push_back( fexAlgo->addTimer("TMEF_CBFinderTime") );
- timers.push_back( fexAlgo->addTimer("TMEF_CBDataOutputTime") );
-}
-
-HLT::ErrorCode TrigMuSuperEF::attachSegments(HLT::TriggerElement* TEout){
- const Trk::SegmentCollection* segments = m_TrigMuonEF_saTrackTool->segmentsToAttach();
- if(segments) {
- auto hltStatus = attachFeature(TEout, segments, "forMT");
- if(hltStatus!=HLT::OK) {
- ATH_MSG_WARNING("Attaching segments to TEout: unsuccessful");
- delete segments;
- return hltStatus;
- }
- else
- ATH_MSG_DEBUG("Successfully attached to TEout the container of segments with size " << segments->size());
- }
- else
- ATH_MSG_DEBUG("segments pointer zero, not attached to TE");
- return HLT::OK;
-}
-
-HLT::ErrorCode TrigMuSuperEF::attachMSTracks(HLT::TriggerElement* TEout){
- const TrackCollection* msTracks = m_TrigMuonEF_saTrackTool->spectrometerTracksToAttach();
- if (msTracks) {
- auto hltStatus = attachFeature(TEout, msTracks , "forSA");
- if(hltStatus!=HLT::OK) {
- ATH_MSG_WARNING("Attaching spectrometer tracks to TEout: unsuccessful");
- return hltStatus;
- }
- else
- if (m_debug) ATH_MSG_DEBUG("Successfully attached to TEout the spectrometer track container with size " << msTracks->size());
- }
- return HLT::OK;
-}
-
-HLT::ErrorCode TrigMuSuperEF::attachTrackParticleContainer(HLT::TriggerElement* TEout){
- // extract the MS track particles
- const xAOD::TrackParticleContainer* msTrackParticleCont = m_TrigMuonEF_saTrackTool->trackParticleContainerToAttach();
- const xAOD::TrackParticleAuxContainer* msTrackParticleAuxCont = m_TrigMuonEF_saTrackTool->trackParticleAuxContainerToAttach();
-
- if( msTrackParticleCont && msTrackParticleAuxCont ) {
- // attach MS track particles to the TE
- ATH_MSG_DEBUG( "Muon tracks container retrieved with size : " << msTrackParticleCont->size() );
- attachTrackParticleContainer( TEout, msTrackParticleCont, m_msTrackParticleContName);
- }
- else {
- ATH_MSG_WARNING("Problem with MS track particle container");
- if (!msTrackParticleCont || msTrackParticleCont->empty()) {
- ATH_MSG_DEBUG( "No muon tracks found: stop here to process the RoI." );
- if(msTrackParticleCont)
- delete msTrackParticleCont;
- return HLT::MISSING_FEATURE;
- }
- if(msTrackParticleCont)
- delete msTrackParticleCont;
- }
- if(msTrackParticleAuxCont)
- delete msTrackParticleAuxCont; // always clean up Aux container
- return HLT::OK;
-}
-
-
-void TrigMuSuperEF::buildInDetCandidates(const ElementLinkVector<xAOD::TrackParticleContainer>& trackLinks, InDetCandidateCollection* inDetCandidates){
- // build InDetCandidates
- // Use ElementLink so the xAOD::TrackParticle has a link back to the Trk::Track
- for(unsigned int itrack=0; itrack<trackLinks.size(); ++itrack) {
- if((*(trackLinks.at(itrack)))->pt() < 2000.){
- continue;
- }
- MuonCombined::InDetCandidate* candidate = new MuonCombined::InDetCandidate(trackLinks.at(itrack));
- // add extension to muon system
- const Muon::MuonSystemExtension* muonSystemExtension = 0;
- m_muonSystemExtensionTool->muonSystemExtension( candidate->indetTrackParticle(), muonSystemExtension );
- candidate->setExtension(muonSystemExtension);// candidate takes ownership of the extension
- inDetCandidates->push_back(candidate);
- }
-}
-
-bool TrigMuSuperEF::buildL2InDetCandidates(const ElementLinkVector<xAOD::TrackParticleContainer>& trackLinks, InDetCandidateCollection* inDetCandidates, const xAOD::L2CombinedMuonContainer* l2combcont){
- if(!l2combcont)
- return false;
- if(l2combcont->size() == 0)
- return false;
- for(uint l2=0; l2<l2combcont->size(); l2++){
- for(unsigned int itrack=0; itrack<trackLinks.size(); ++itrack) {
- if(*(trackLinks.at(itrack))==l2combcont->at(l2)->idTrack())
- inDetCandidates->push_back( new MuonCombined::InDetCandidate( trackLinks.at(itrack) ) );
- }
- }
- fillIDMonitoringVars(trackLinks);
- return true;
-}
-
-
-bool TrigMuSuperEF::retrieveFromCache(map<std::vector<std::vector<IdentifierHash> >, InternalCache*>::iterator itmap, MuonCandidateCollection* muonCandidates, xAOD::TrackParticleContainer* combTrackParticleCont, xAOD::TrackParticleContainer* saTrackParticleCont){
-
- if(!m_doInsideOut)
- itmap = m_CacheMapTMEFonly.find(m_hashlist);
- else itmap = m_CacheMap.find(m_hashlist);
-
- if(!(m_doInsideOut ? itmap!=m_CacheMap.end() : itmap!=m_CacheMapTMEFonly.end()))
- return false;
- InternalCache *cache = itmap->second;
- ATH_MSG_VERBOSE("Repeated ROI");
- //get objects from cache
- muonCandidates=cache->MuonCandidates();
- ATH_MSG_VERBOSE("got muon candidates with size: "<<muonCandidates->size());
- retrieveTrackContainersFromCache(cache, combTrackParticleCont, saTrackParticleCont);
- return true;
-}
-
-HLT::ErrorCode TrigMuSuperEF::rebuildCache(const IRoiDescriptor* muonRoI, HLT::TriggerElement* TEout, MuonCandidateCollection* muonCandidates, InDetCandidateCollection* inDetCandidates, xAOD::TrackParticleContainer* combTrackParticleCont, xAOD::TrackParticleContainer* saTrackParticleCont, std::unique_ptr<xAOD::MuonContainer>& muonContainerOwn, const ElementLinkVector<xAOD::TrackParticleContainer>& elv_xaodidtrks){
- auto hltStatus = HLT::OK;
- muonCandidates = new MuonCandidateCollection();
-
- m_combTrkTrackColl=new TrackCollection();
- addElement( m_tracksCache, m_combTrkTrackColl);
-
- m_extrTrkTrackColl=new TrackCollection();
- addElement( m_tracksCache, m_extrTrkTrackColl);
- if(m_doOutsideIn && (!m_insideOutFirst || !m_doInsideOut) ) { // run TrigMuonEF
- auto hltStatus = runOutsideInOnly(muonRoI, TEout, muonCandidates, inDetCandidates, muonContainerOwn, elv_xaodidtrks);
- if(hltStatus != HLT::OK && hltStatus != HLT::MISSING_FEATURE){
- if(muonCandidates) delete muonCandidates;
- return hltStatus;
- }
- if(m_doInsideOut) {
- if(m_forceBoth || hltStatus==HLT::MISSING_FEATURE){
- m_muGirlTrkSegColl=new Trk::SegmentCollection();
- addElement(m_segsCache,m_muGirlTrkSegColl);
- runMuGirl(elv_xaodidtrks, inDetCandidates);
- }
- }
-
- }//TrigMuonEF first
- if(m_doInsideOut && (m_insideOutFirst || !m_doOutsideIn)) {
- ATH_MSG_DEBUG( "Executing extend()" );
- ++m_counter_TrigMuGirl.total;
- const EventContext& ctx = getContext();
- hltStatus = m_TrigMuonEF_saTrackTool->getSegments(muonRoI, m_TMEF_monVars, m_TMEF_SATimers, ctx);
- MuonCombined::InDetCandidateToTagMap* mugirlTagMap=new MuonCombined::InDetCandidateToTagMap();
- m_tagMaps.push_back(mugirlTagMap);
-
- m_muGirlTrkSegColl=new Trk::SegmentCollection();
- addElement(m_segsCache,m_muGirlTrkSegColl);
-
- m_muGirlTool->extend(*inDetCandidates,mugirlTagMap,m_combTrkTrackColl,m_extrTrkTrackColl,m_muGirlTrkSegColl, ctx);
- ++m_counter_TrigMuGirl.pass;//@todo fix this counter
-
- if(m_doOutsideIn) {
- bool foundMuon=false; // @todo: need to check if MuGirl tagged a muon - always assume it didn't for now
- if(m_forceBoth || !foundMuon) {
- // now run TrigMuonEF MS+CB
- ++m_counter_TrigMuonEF.total;
- hltStatus = runMSCBReconstruction( muonRoI, TEout, *muonCandidates, *inDetCandidates, muonContainerOwn );
-
- if(hltStatus==HLT::OK) ++m_counter_TrigMuonEF.total;
- else if(hltStatus!=HLT::MISSING_FEATURE) { // missing feature indicates no muon - which we don't report as an error
- if(muonCandidates) delete muonCandidates;
- ATH_MSG_ERROR("Problem building combined tracks");
- return hltStatus;
- }
- }// need to run TrigMuonEF
- }//doOutsideIn
- }// MuGirl first
- ATH_MSG_DEBUG( "Call buildMuons, n(inDetCandidates) = " << inDetCandidates->size());
- hltStatus = buildMuons( muonCandidates, inDetCandidates, combTrackParticleCont, saTrackParticleCont);
- if(hltStatus!=HLT::OK) {
- if(muonCandidates)
- delete muonCandidates;
- ATH_MSG_ERROR("Problem building muons");
- return hltStatus;
- }
-
- //set cache objects
- if(muonCandidates && combTrackParticleCont && saTrackParticleCont && m_combTrkTrackColl && m_muGirlTrkSegColl){
- InternalCache *cacheStore = new InternalCache();
- cacheStore->SetMuonCandidates(muonCandidates);
- cacheStore->SetCombinedTracks(combTrackParticleCont);
- cacheStore->SetExtrapolatedTracks(m_extrTrkTrackColl);
- cacheStore->SetSATracks(saTrackParticleCont);
- cacheStore->SetCombinedTrackColl(m_combTrkTrackColl);
- cacheStore->SetMuonContainer(m_muonContainer);
- //put cache in map (separate map for outside in only running)
- if(!m_doInsideOut) m_CacheMapTMEFonly[m_hashlist] = cacheStore;
- else m_CacheMap[m_hashlist] = cacheStore;
- }
-
- if(muonCandidates) delete muonCandidates;
- return HLT::OK;
-}
-
-void TrigMuSuperEF::runMuGirl(const ElementLinkVector<xAOD::TrackParticleContainer>& elv_xaodidtrks, InDetCandidateCollection* inDetCandidates){
- buildInDetCandidates(elv_xaodidtrks, inDetCandidates);
- ATH_MSG_DEBUG( "Executing extend()" );
- ++m_counter_TrigMuGirl.total;
- MuonCombined::InDetCandidateToTagMap* mugirlTagMap=new MuonCombined::InDetCandidateToTagMap();
- m_tagMaps.push_back(mugirlTagMap);
- const EventContext& ctx = getContext();
- m_muGirlTool->extend(*inDetCandidates,mugirlTagMap, m_combTrkTrackColl, m_extrTrkTrackColl, m_muGirlTrkSegColl, ctx);
- ++m_counter_TrigMuGirl.pass;//@todo fix this counter
-}
-
-HLT::ErrorCode TrigMuSuperEF::runOutsideInOnly(const IRoiDescriptor* muonRoI, HLT::TriggerElement* TEout, MuonCandidateCollection* muonCandidates, InDetCandidateCollection* inDetCandidates, std::unique_ptr<xAOD::MuonContainer>& muonContainerOwn, const ElementLinkVector<xAOD::TrackParticleContainer>& elv_xaodidtrks){
- ++m_counter_TrigMuonEF.total;
- // TrigMuonEF MS+CB
- auto hltStatus = runMSCBReconstruction( muonRoI, TEout, *muonCandidates, *inDetCandidates, muonContainerOwn );
- if((hltStatus==HLT::MISSING_FEATURE || muonCandidates->size()==0) && m_useL2Info){
- //if combination with L2 ID trk fails, use EF trks instead
- ATH_MSG_DEBUG("refitting combined track with ef id tracks");
- buildInDetCandidates(elv_xaodidtrks, inDetCandidates);
- hltStatus = runMSCBReconstruction( muonRoI, TEout, *muonCandidates, *inDetCandidates, muonContainerOwn );
- }
- if(hltStatus==HLT::OK)
- ++m_counter_TrigMuonEF.pass;
- else if(hltStatus!=HLT::MISSING_FEATURE) { // missing feature indicates no muon - which we don't report as an error
- if(muonCandidates)
- delete muonCandidates;
- ATH_MSG_ERROR("Problem running runMSCBReconstruction");
- }
- return hltStatus;
-}
-
-void TrigMuSuperEF::retrieveTrackContainersFromCache(InternalCache* cache, xAOD::TrackParticleContainer* combTrackParticleCont, xAOD::TrackParticleContainer* saTrackParticleCont){
-
- ATH_MSG_VERBOSE("Repeated ROI");
- xAOD::TrackParticleContainer::iterator trk_itr = cache->CombinedTracks().first->begin();
- xAOD::TrackParticleContainer::iterator trk_end = cache->CombinedTracks().first->end();
-
- combTrackParticleCont->reserve(cache->CombinedTracks().first->size());
- for(; trk_itr !=trk_end; ++trk_itr){
- xAOD::TrackParticle *trk1 = new xAOD::TrackParticle();
- trk1->makePrivateStore(**trk_itr);
- combTrackParticleCont->push_back(trk1);
- }
-
- //Get SA track particles from cache
- saTrackParticleCont->reserve(cache->SATracks().first->size());
- for(auto trk_itr : *(cache->SATracks().first)){
- xAOD::TrackParticle *trk1 = new xAOD::TrackParticle();
- trk1->makePrivateStore(*trk_itr);
- saTrackParticleCont->push_back(trk1);
- }
-
- //Get extrapolated tracks from cache
- m_extrTrkTrackColl = new TrackCollection();
- m_extrTrkTrackColl->reserve(cache->ExtrapolatedTracks()->size());
- addElement( m_tracksCache, m_extrTrkTrackColl);
- for(auto trk : *(cache->ExtrapolatedTracks()))
- m_extrTrkTrackColl->push_back(new Trk::Track(*trk));
-
- //Get combined track collection from cache
- m_combTrkTrackColl = new TrackCollection();
- m_combTrkTrackColl->reserve(cache->CombinedTrackColl()->size());
- addElement( m_tracksCache, m_combTrkTrackColl);
- for(auto trk : *(cache->CombinedTrackColl()))
- m_combTrkTrackColl->push_back(new Trk::Track(*trk));
-
- //Get muon container from cache
- xAOD::MuonContainer::iterator mu_itr = cache->MuonContainer().first->begin();
- xAOD::MuonContainer::iterator mu_end = cache->MuonContainer().first->end();
- m_muonContainer->reserve(cache->MuonContainer().first->size());
- for(; mu_itr!=mu_end; ++mu_itr){
- xAOD::Muon *mu2 = new xAOD::Muon();
- mu2->makePrivateStore(**mu_itr);
- m_muonContainer->push_back(mu2);
- }
-}
diff --git a/Trigger/TrigAlgorithms/TrigMuSuperEF/src/TrigMuSuperEF.h b/Trigger/TrigAlgorithms/TrigMuSuperEF/src/TrigMuSuperEF.h
deleted file mode 100644
index 4464d7241d7626e7cea8739e36d1ef4490700d8a..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuSuperEF/src/TrigMuSuperEF.h
+++ /dev/null
@@ -1,293 +0,0 @@
-/*
- Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
-*/
-
-// Wrapper algorithm to make a smart "OR" of TrigMuonEF and TrigMuGirl
-// Authors: Martin Woudstra, Joel Klinger, Mark Owen
-
-#ifndef TRIGMUSUPEREF_TRIGMUSUPEREF_H
-#define TRIGMUSUPEREF_TRIGMUSUPEREF_H
-
-#include <string>
-#include <vector>
-#include <map>
-
-#include "TrigInterfaces/Algo.h"
-#include "TrigInterfaces/FexAlgo.h"
-
-#include "TrigNavigation/NavigationCore.icc"
-
-#include "GaudiKernel/System.h"
-
-#include "TrigConfHLTData/HLTTriggerElement.h"
-
-#include "TrigMuonToolInterfaces/TrigMuonEFMonVars.h"
-#include "MuonCombinedToolInterfaces/IMuonCombinedTrigCaloTagExtensionTool.h"
-
-// EDM includes
-#include "xAODMuon/MuonContainer.h"
-#include "xAODMuon/SlowMuonContainer.h"
-#include "Particle/TrackParticleContainer.h"
-#include "MuonCombinedEvent/MuonCandidateCollection.h"
-#include "MuonCombinedEvent/InDetCandidateCollection.h"
-#include "MuonCombinedEvent/InDetCandidateToTagMap.h"
-#include "TrkSegment/SegmentCollection.h"
-
-#include "InternalCache.h"
-
-class IRoiDescriptor;
-class TrigRoiDescriptor;
-class TrigTimer;
-
-
-class ITrigMuonStandaloneTrackTool;
-
-namespace Trk {
- class ITrackSummaryTool;
- class ITrackParticleCreatorTool;
-}
-
-namespace MuonCombined {
- class IMuonCombinedTool;
- class IMuonCreatorTool;
- class IMuonCombinedInDetExtensionTool;
- class IMuonCombinedTrigCaloTagExtensionTool;
- class IMuonSegmentTagTool;
-}
-
-namespace Muon {
- class IMuonSystemExtensionTool;
-}
-
-
-class TrigMuSuperEF: public virtual HLT::FexAlgo {
- public:
-
- TrigMuSuperEF (const std::string& name, ISvcLocator* pSvcLocator);
- virtual ~TrigMuSuperEF();
-
- virtual HLT::ErrorCode hltInitialize();
- virtual HLT::ErrorCode hltExecute(const HLT::TriggerElement*, HLT::TriggerElement*);
- virtual HLT::ErrorCode hltEndEvent();
- virtual HLT::ErrorCode hltFinalize();
-
- using HLT::FexAlgo::prepareRobRequests;
- virtual HLT::ErrorCode prepareRobRequests(const HLT::TriggerElement* input );
-
-
- private:
-
- struct PassCounters {
- PassCounters() : total(0), pass(0) {};
- unsigned int total;
- unsigned int pass;
- };
-
-
- void clearRoiCache();
-
- // run the standard chain of MS (possible stopping at that point), then CB
- HLT::ErrorCode runStandardChain(const HLT::TriggerElement*, HLT::TriggerElement*, std::unique_ptr<xAOD::MuonContainer>& muonContainerOwn);
-
- HLT::ErrorCode runStandAlone(const IRoiDescriptor*, HLT::TriggerElement*, MuonCandidateCollection*, std::unique_ptr<xAOD::MuonContainer>& muonContainerOwn);
-
- // run in combiner only mode
- HLT::ErrorCode runCombinerOnly(const HLT::TriggerElement* inputTE, HLT::TriggerElement* TEout, std::unique_ptr<xAOD::MuonContainer>& muonContainerOwn);
-
- // run in caloTag mode
- HLT::ErrorCode runCaloTagOnly(const HLT::TriggerElement* inputTE, HLT::TriggerElement* TEout, std::unique_ptr<xAOD::MuonContainer>& muonContainerOwn);
-
- // run the MS+CB reconstruction of TrigMuonEF
- HLT::ErrorCode runMSCBReconstruction(const IRoiDescriptor* muonRoI,
- HLT::TriggerElement* TEout,
- MuonCandidateCollection& muonCandidates,
- InDetCandidateCollection& inDetCandidates, std::unique_ptr<xAOD::MuonContainer>& muonContainerOwn);
-
- // run the MS-only reconstruction
- HLT::ErrorCode runMSReconstruction(const IRoiDescriptor* muonRoI, HLT::TriggerElement* TEout, MuonCandidateCollection& muonCandidates, std::unique_ptr<xAOD::MuonContainer>& muonContainerOwn);
-
- HLT::ErrorCode runSegmentTaggedOnly(const HLT::TriggerElement* inputTE, HLT::TriggerElement* TEout, std::unique_ptr<xAOD::MuonContainer> & muonContainer);
-
- HLT::ErrorCode runMSSegmentTaggedReconstruction(HLT::TriggerElement* TEout,
- MuonCandidateCollection& muonCandidates,
- InDetCandidateCollection& inDetCandidates, std::unique_ptr<xAOD::MuonContainer>& muonContainerOwn);
-
- /// Function to get ID track particle links from trigger element
- HLT::ErrorCode getIDTrackParticleLinks(const HLT::TriggerElement* te, ElementLinkVector<xAOD::TrackParticleContainer>& elv_xaodidtrks) ;
- HLT::ErrorCode getIDTrackParticleLinksL2(const HLT::TriggerElement* te, ElementLinkVector<xAOD::TrackParticleContainer>& elv_xaodidtrks) ;
-
- /// Function to build combined tracks
-
- HLT::ErrorCode buildCombinedTracks(const MuonCandidateCollection* muonCandidates,
- InDetCandidateCollection& inDetCandidates,
- TrigMuonEFCBMonVars& monVars,
- std::vector<TrigTimer*>& timers);
-
- /// Function to segment tagged candidates tracks
- HLT::ErrorCode buildSegmentTaggedTracks(InDetCandidateCollection& inDetCandidates);
-
- // function to build xAOD muons
- HLT::ErrorCode buildMuons(const MuonCandidateCollection* muonCandidates,
- InDetCandidateCollection* inDetCandidates,
- xAOD::TrackParticleContainer* combinedTrackParticles,
- xAOD::TrackParticleContainer* extrapolatedTrackParticles);
-
- // attach all the different output collections to the TE
- HLT::ErrorCode attachOutput(HLT::TriggerElement* TEout,
- xAOD::TrackParticleContainer* combinedTrackParticles,
- xAOD::TrackParticleContainer* extrapolatedTrackParticles, std::unique_ptr<xAOD::MuonContainer> muonContainerOwn);
-
- HLT::ErrorCode attachSegments(HLT::TriggerElement* TEout);
- HLT::ErrorCode attachMSTracks(HLT::TriggerElement* TEout);
- HLT::ErrorCode attachTrackParticleContainer(HLT::TriggerElement* TEout);
- /// Utility function to attached xAOD track particle container to the trigger element
- void attachTrackParticleContainer( HLT::TriggerElement* TEout, const xAOD::TrackParticleContainer* trackParticleCont, const std::string& name);
- void setCombinedTimers(HLT::Algo* fexAlgo, std::vector<TrigTimer*>& timers);
-
- const IRoiDescriptor* getRoiDescriptor(const HLT::TriggerElement* inputTE, HLT::TriggerElement* outputTE);
-
- TrigRoiDescriptor* createSingleTrigRoiDescriptor( double eta, double phi, double etaWidth, double phiWidth, int roiNum );
-
- void buildInDetCandidates(const ElementLinkVector<xAOD::TrackParticleContainer>&, InDetCandidateCollection*);
- bool buildL2InDetCandidates(const ElementLinkVector<xAOD::TrackParticleContainer>&, InDetCandidateCollection*, const xAOD::L2CombinedMuonContainer*);
- void runMuGirl(const ElementLinkVector<xAOD::TrackParticleContainer>&, InDetCandidateCollection*);
-
- bool retrieveFromCache(std::map<std::vector<std::vector<IdentifierHash> >, InternalCache*>::iterator itmap, MuonCandidateCollection* muonCandidates, xAOD::TrackParticleContainer* combTrackParticleCont, xAOD::TrackParticleContainer* saTrackParticleCont);
-
- void retrieveTrackContainersFromCache(InternalCache* cache, xAOD::TrackParticleContainer* combTrackParticleCont, xAOD::TrackParticleContainer* saTrackParticleCont);
-
- HLT::ErrorCode rebuildCache(const IRoiDescriptor*, HLT::TriggerElement*, MuonCandidateCollection* muonCandidates, InDetCandidateCollection* inDetCandidates, xAOD::TrackParticleContainer* combTrackParticleCont, xAOD::TrackParticleContainer* saTrackParticleCont, std::unique_ptr<xAOD::MuonContainer>& muonContainerOwn, const ElementLinkVector<xAOD::TrackParticleContainer>& elv_idtrks );
-
- HLT::ErrorCode runOutsideInOnly(const IRoiDescriptor*, HLT::TriggerElement*, MuonCandidateCollection* muonCandidates, InDetCandidateCollection* inDetCandidates, std::unique_ptr<xAOD::MuonContainer>& muonContainerOwn, const ElementLinkVector<xAOD::TrackParticleContainer>& elv_idtrks);
- void printCounterStats( const PassCounters& counter, const std::string& source, int precision = 3 ) const;
- void printTrigMuGirlStats() const;
- void printTrigMuonEFStats() const;
- void printTotalStats() const;
- void printTEStats() const;
-
- // function to declare combined muon monitoring variables
- void declareCombinedMonitoringVariables(TrigMuonEFCBMonVars& monVars);
-
- // function to declare caloTag muon monitoring variables
- void declareCaloTagMonitoringVariables(TrigMuonCaloTagMonVars& monVars);
-
- void fillMonitoringVars( );
- void fillIDMonitoringVars( const ElementLinkVector<xAOD::TrackParticleContainer>& elv_idtrks );
- void fillCTMonitoringVars( const xAOD::TrackParticleContainer& idTrks );
- void fillCBMonitoringVars();
-
- void ResetTimers(std::vector<TrigTimer*>& timers);
-
- ToolHandle<ITrigMuonStandaloneTrackTool> m_TrigMuonEF_saTrackTool;
-
- const IRoiDescriptor* m_roi; // to cache actually used RoI
- TrigRoiDescriptor* m_Roi_StillToBeAttached;
- TrigTimer* m_totalTime;
-
- //Maps to muon tags
- std::vector<MuonCombined::InDetCandidateToTagMap*> m_tagMaps;
-
- // Output xAOD muons
- xAOD::MuonContainer* m_muonContainer;
- //xAOD::SlowMuonContainer* m_slowMuonContainer;
-
- // Output tagged TrackParticles
- xAOD::TrackParticleContainer* m_ctTrackParticleContainer;
-
- // Output combined TrackCollection
- TrackCollection* m_combTrkTrackColl;
-
- //Output extrapolated TrackCollection
- TrackCollection* m_extrTrkTrackColl;
-
- /// holder for containers that we create and may need to be deleted at end of event
- std::vector< TrackCollection* > m_tracksCache;
-
- //collection for segments created by MuGirl and MuonStau
- Trk::SegmentCollection* m_muGirlTrkSegColl;
-
- // holder for segment containers that may need to be deleted
- std::vector<Trk::SegmentCollection*> m_segsCache;
-
- //Trigger pass/fail counts
- PassCounters m_counter_TrigMuonEF;
- PassCounters m_counter_TrigMuGirl;
- PassCounters m_counter_CaloTag;
- PassCounters m_counter;
- std::map<unsigned int,PassCounters> m_counter_perTE; // use TE id as key
-
- //// Monitoring Histograms
-
- TrigMuonEFCBMonVars m_monVars;
-
- TrigMuonEFMonVars m_TMEF_monVars;
- TrigMuGirlMonVars m_TrigMuGirl_monVars;
- TrigMuonCaloTagMonVars m_TrigCaloTag_monVars;
-
- bool m_doInsideOut; // run TrigMuGirl or not
- bool m_doOutsideIn; // run TrigMuonEF or not
- bool m_insideOutFirst; // run TrigMuGirl first (true) or run TrigMuonEF first (false)
- bool m_forceBoth;
- bool m_singleContainer;
- bool m_standaloneOnly; // run only the MS reconstruction
- bool m_combinerOnly; // run only the combiner - MS reco must have been run previously
- bool m_caloTagOnly;
- bool m_segmentTagOnly;
-
- bool m_fullScan;
- bool m_recordSegments;
- bool m_recordPatterns;
- bool m_recordTracks;
-
- float m_dEtaRoI;
- float m_dPhiRoI;
-
- std::string m_idTrackParticlesName;
-
- std::string m_saTrackParticleContName; /// Name of the xAOD track particle container for extrapolated tracks
- std::string m_msTrackParticleContName; /// Name of the xAOD track particle container for muon spectrometer tracks
- std::string m_cbTrackParticleContName; /// Name of the xAOD track particle container for combined tracks
- std::string m_ctTrackParticleContName; /// Name of the xAOD track particle container for caloTag tracks
-
- std::string m_muonContName; // Name of the xAOD muon container
-
- bool m_debug; // handy flag for conditional DEBUG output
- bool m_verbose; // handy flag for conditional VERBOSE output
-
- // Pointers to tools
- ToolHandle<Trk::ITrackSummaryTool > m_trackSummaryTool;
- ToolHandle<MuonCombined::IMuonCombinedTool> m_muonCombinedTool;
- ToolHandle<MuonCombined::IMuonCombinedInDetExtensionTool> m_muGirlTool;
- ToolHandle<MuonCombined::IMuonCombinedTrigCaloTagExtensionTool> m_caloTagTool;
- ToolHandle<MuonCombined::IMuonSegmentTagTool> m_muonSegmentTagTool;
-
- /// tool to create track particles from Trk::Tracks
- ToolHandle<Trk::ITrackParticleCreatorTool> m_TrackToTrackParticleConvTool;
-
- /// tool for creating xAOD muons
- ToolHandle<MuonCombined::IMuonCreatorTool> m_muonCreatorTool;
- ToolHandle<MuonCombined::IMuonCreatorTool> m_stauCreatorTool;
-
- /// tool for extending ID tracks to the muon system
- ToolHandle <Muon::IMuonSystemExtensionTool> m_muonSystemExtensionTool;
-
- //Timers
- std::vector<TrigTimer*> m_TMEF_SATimers;
- std::vector<TrigTimer*> m_TMEF_STTimers;
- std::vector<TrigTimer*> m_TMEF_CBTimers;
- std::vector<TrigTimer*> m_TrigMuGirl_Timers;
-
- bool m_doMuonFeature;
- bool m_useL2Info;
- bool m_doCache;
-
- //Map to cache
- std::map<std::vector<std::vector<IdentifierHash> >, InternalCache*> m_CacheMap;
- std::map<std::vector<std::vector<IdentifierHash> >, InternalCache*> m_CacheMapTMEFonly;
-
- // list of IdentifierHash for PRD in RoI
- std::vector<std::vector<IdentifierHash> > m_hashlist;
-
-};
-
-#endif // TRIGMUSUPEREF_TRIGMUSUPEREF_H
diff --git a/Trigger/TrigAlgorithms/TrigMuSuperEF/src/TrigMuSuperEFUtils.icc b/Trigger/TrigAlgorithms/TrigMuSuperEF/src/TrigMuSuperEFUtils.icc
deleted file mode 100644
index 204250199cd9196d7be73eebcfe4847874acd67d..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuSuperEF/src/TrigMuSuperEFUtils.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 TRIGMUSUPEREF_TRIGMUSUPEREFUTILS_ICC_
-#define TRIGMUSUPEREF_TRIGMUSUPEREFUTILS_ICC_
-
-// Small file with some helper functions used in TrigMuSuperEF 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 //TRIGMUSUPEREF_TRIGMUSUPEREFUTILS_ICC_
diff --git a/Trigger/TrigAlgorithms/TrigMuSuperEF/src/TrigMuonEFTagandProbe.cxx b/Trigger/TrigAlgorithms/TrigMuSuperEF/src/TrigMuonEFTagandProbe.cxx
deleted file mode 100644
index ffdf93e567ad50fb797db103bd007cd94a9e36e5..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuSuperEF/src/TrigMuonEFTagandProbe.cxx
+++ /dev/null
@@ -1,794 +0,0 @@
-/*
- Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
-*/
-
-/*--------------------------------------------------------------------------------------
- Event Filter Z_mu+mu- Online Tag and Probe algorithm
- Authors: Jonathan Jamieson, University of Glasgow, Created: 09/10/2017, Last edit: 31/05/2018
-
- Summary:-----------------------------------------------------------------------------------------
-
- Accesses collection of xaod::muons within event and picks out only 'good muons', i.e. muons formed from combined (NOT Stand Alone) tracks including any duplicates and with isolation criteria DeltaR > 0.2
-
- Events passed from preceding Mu22_mu8noL1 HLT trigger are trimmed by first applying a 10 GeV cut on pt to remove events with pt below that expected in z_mu+mu- events (10 GeV picked to not be too high as to bias against low momentum Z events and to stay consistent with previous work
-
- >2 muon events are then trimmed to exact pairs by matching all the avaliable opposite charge muons and picking the best fit to the Z mass, applying a default +-10 GeV threshold cut around the Z mass to match the eventual pair requirement.
-
- LVL 1 trigger information is then accessed for the event and Delta R values are calculated for each RoI and muon pair
-
- Tag and probe selection:
- A tag muon is defined as any good muon with pt > 10GeV that can be associated with a LVL 1 RoI (DeltaR <0.1) belonging to LVL1 threshold >= threshold 5 (MU20))
- A candidate probe muon is any other muon with pt > 10GeV with the additional requirement on tag and probe pairs that their invariant mass be within +-10GeV from the Z mass
-
- Efficiency plots for three kinematic variables (eta,phi and pT) are avaliable, produced from TProfile objects created from two vectors
- -kinematic values for every probe candidate [e.g: EF_Phi_Total_thr1_b]
- -1.0 or 0.0 for every probe candidate denoting RoI match (1) or no matching L1 info (0)
-
- For probe muon candidates without a matching L1 RoI: count 0 for match in all thresholds to avoid biasing for higher efficiencies at pTs lower than threshold acceptance.
-
- Seperate plots for each threshold as well as barrel and endcap where appropriate are produced for all kinemetics and a flat PT cut of 25GeV applied to data in Eta and Phi plots for all thresholds to avoid poor efficiency at to low pT turn on.
-
- Eta barrel and endcap statistics are merged to facilitate more sensible plotting of efficiencies but seperated statistics still required for producing 2d plots vs Phi
-
- ([31/05/2018] pT plots, split Eta plots and Threshold 2-4 2D plots have been removed from python plotting code: "TrigMuonEFTagandProbeMonitoring.py" to reduce memory allocation, monitored containers for these are still filled)
-
- Running:-----------------------------------------------------------------------------------------
-
- athenaHLT:
- from glob import glob;athenaHLT.py -M -f "glob("/path/to/dir1/star")+glob("/path/to/dir2/star")+glob(etc..)" -o HLT_MCV7 -c 'testMCV7=True;HLTOutputLevel=INFO;ServiceMgr.MessageSvc.defaultLimit=9999999;doValidation=True;fpeAuditor=True' -C "topSequence.TrigSteer_HLT.TrigMuonEFTagandProbe.OutputLevel=DEBUG" TriggerJobOpts/runHLT_standalone.py >& log
-
- Output of online histogramming will be in r000...HLT-Histogramming.root
-
- athena (data):
-
- athena.py -c 'testMCV7=True;HLTOutputLevel=INFO;ServiceMgr.MessageSvc.defaultLimit=9999999;doValidation=True;fpeAuditor=True;from glob import glob;BSRDOInput=glob("/path/to/dir1/star")+glob("/path/to/dir2/star")+glob(etc..)' TriggerJobOpts/runHLT_standalone.py Path/To/localDebug.py >& log_file
-
- athena (MC):
-
-/usr/bin/time -f "mem=%K RSS=%M elapsed=%E cpu.sys=%S .user=%U" athena.py -c 'menu="MC_pp_v7";sliceName="muon";ServiceMgr.MessageSvc.defaultLimit=9999999;EvtMax=-1;from glob import glob;jp.AthenaCommonFlags.FilesInput=glob("/path/to/dir1/star")+glob("/path/to/dir2/star")+glob(etc..)' TriggerTest/testCommonSliceAthenaTrigRDO.py Path/To/localDebug.py >& log_file_MC
-*/
-
-
-#include <iomanip>
-#include <cmath>
-#include "TrigMuonEFTagandProbe.h"
-
-#include "TrigConfHLTData/HLTTriggerElement.h"
-#include "FourMomUtils/xAODP4Helpers.h"
-
-#include "GaudiKernel/SystemOfUnits.h"
-
-//Monitoring object constructor
-MonitoringObject::MonitoringObject() {
-
- //Sets up vector of containers for each threshold so filling functions can pick correct threshold by element index
- m_ThreshMon.push_back(m_Threshold1);
- m_ThreshMon.push_back(m_Threshold2);
- m_ThreshMon.push_back(m_Threshold3);
- m_ThreshMon.push_back(m_Threshold4);
- m_ThreshMon.push_back(m_Threshold5);
- m_ThreshMon.push_back(m_Threshold6);
-
-}
-
-
-//Constructor for new algorithm class inheriting from base FexAlgo class
-//ISvcLocator is service locator for shared global services between algorithms (e.g. magnetic field information etc)
-TrigMuonEFTagandProbe::TrigMuonEFTagandProbe(const std::string &name, ISvcLocator *pSvcLocator) :
- FexAlgo(name, pSvcLocator),
- m_debug(false),
- m_verbose(false)
-
-{
-
- declareMonitoredStdContainer("EF_Eta_Total_thr1_b", m_eta_total_thr1_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Phi_Total_thr1_b", m_phi_total_thr1_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Pt_Total_thr1_b", m_pt_total_thr1_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Eta_Total_thr1_e", m_eta_total_thr1_e, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Phi_Total_thr1_e", m_phi_total_thr1_e, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Pt_Total_thr1_e", m_pt_total_thr1_e, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Eta_Total_thr1", m_eta_total_thr1, IMonitoredAlgo::AutoClear);
-
-
- declareMonitoredStdContainer("EF_Eta_Total_thr2_b", m_eta_total_thr2_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Phi_Total_thr2_b", m_phi_total_thr2_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Pt_Total_thr2_b", m_pt_total_thr2_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Eta_Total_thr2_e", m_eta_total_thr2_e, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Phi_Total_thr2_e", m_phi_total_thr2_e, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Pt_Total_thr2_e", m_pt_total_thr2_e, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Eta_Total_thr2", m_eta_total_thr2, IMonitoredAlgo::AutoClear);
-
-
- declareMonitoredStdContainer("EF_Eta_Total_thr3_b", m_eta_total_thr3_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Phi_Total_thr3_b", m_phi_total_thr3_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Pt_Total_thr3_b", m_pt_total_thr3_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Eta_Total_thr3_e", m_eta_total_thr3_e, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Phi_Total_thr3_e", m_phi_total_thr3_e, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Pt_Total_thr3_e", m_pt_total_thr3_e, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Eta_Total_thr3", m_eta_total_thr3, IMonitoredAlgo::AutoClear);
-
-
- declareMonitoredStdContainer("EF_Eta_Total_thr4_b", m_eta_total_thr4_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Phi_Total_thr4_b", m_phi_total_thr4_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Pt_Total_thr4_b", m_pt_total_thr4_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Eta_Total_thr4_e", m_eta_total_thr4_e, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Phi_Total_thr4_e", m_phi_total_thr4_e, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Pt_Total_thr4_e", m_pt_total_thr4_e, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Eta_Total_thr4", m_eta_total_thr4, IMonitoredAlgo::AutoClear);
-
-
- declareMonitoredStdContainer("EF_Eta_Total_thr5_b", m_eta_total_thr5_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Phi_Total_thr5_b", m_phi_total_thr5_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Pt_Total_thr5_b", m_pt_total_thr5_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Eta_Total_thr5_e", m_eta_total_thr5_e, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Phi_Total_thr5_e", m_phi_total_thr5_e, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Pt_Total_thr5_e", m_pt_total_thr5_e, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Eta_Total_thr5", m_eta_total_thr5, IMonitoredAlgo::AutoClear);
-
-
- declareMonitoredStdContainer("EF_Eta_Total_thr6_b", m_eta_total_thr6_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Phi_Total_thr6_b", m_phi_total_thr6_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Pt_Total_thr6_b", m_pt_total_thr6_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Eta_Total_thr6_e", m_eta_total_thr6_e, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Phi_Total_thr6_e", m_phi_total_thr6_e, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Pt_Total_thr6_e", m_pt_total_thr6_e, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Eta_Total_thr6", m_eta_total_thr6, IMonitoredAlgo::AutoClear);
-
-
-
- //Need three seperate eff vectors as Totals are different sizes for Eta unsplit, phi&eta split and pT split
- declareMonitoredStdContainer("EF_Eta_Eff_thr1", m_eta_eff_thr1, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Eta_Eff_thr2", m_eta_eff_thr2, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Eta_Eff_thr3", m_eta_eff_thr3, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Eta_Eff_thr4", m_eta_eff_thr4, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Eta_Eff_thr5", m_eta_eff_thr5, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Eta_Eff_thr6", m_eta_eff_thr6, IMonitoredAlgo::AutoClear);
-
- declareMonitoredStdContainer("EF_Etaphi_Eff_thr1_b", m_etaphi_eff_thr1_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Etaphi_Eff_thr1_e", m_etaphi_eff_thr1_e, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Etaphi_Eff_thr2_b", m_etaphi_eff_thr2_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Etaphi_Eff_thr2_e", m_etaphi_eff_thr2_e, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Etaphi_Eff_thr3_b", m_etaphi_eff_thr3_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Etaphi_Eff_thr3_e", m_etaphi_eff_thr3_e, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Etaphi_Eff_thr4_b", m_etaphi_eff_thr4_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Etaphi_Eff_thr4_e", m_etaphi_eff_thr4_e, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Etaphi_Eff_thr5_b", m_etaphi_eff_thr5_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Etaphi_Eff_thr5_e", m_etaphi_eff_thr5_e, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Etaphi_Eff_thr6_b", m_etaphi_eff_thr6_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Etaphi_Eff_thr6_e", m_etaphi_eff_thr6_e, IMonitoredAlgo::AutoClear);
-
-
- declareMonitoredStdContainer("EF_Pt_Eff_thr1_b", m_pt_eff_thr1_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Pt_Eff_thr1_e", m_pt_eff_thr1_e, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Pt_Eff_thr2_b", m_pt_eff_thr2_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Pt_Eff_thr2_e", m_pt_eff_thr2_e, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Pt_Eff_thr3_b", m_pt_eff_thr3_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Pt_Eff_thr3_e", m_pt_eff_thr3_e, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Pt_Eff_thr4_b", m_pt_eff_thr4_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Pt_Eff_thr4_e", m_pt_eff_thr4_e, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Pt_Eff_thr5_b", m_pt_eff_thr5_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Pt_Eff_thr5_e", m_pt_eff_thr5_e, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Pt_Eff_thr6_b", m_pt_eff_thr6_b, IMonitoredAlgo::AutoClear);
- declareMonitoredStdContainer("EF_Pt_Eff_thr6_e", m_pt_eff_thr6_e, IMonitoredAlgo::AutoClear);
-
-}
-
-TrigMuonEFTagandProbe::~TrigMuonEFTagandProbe(){} //Destructor
-
-
-HLT::ErrorCode TrigMuonEFTagandProbe::hltInitialize()
-{
-
- // Conditional debug flags for when debug output requires extra compute
- m_debug = msgLvl() <= MSG::DEBUG; // MSG levels are 1-7, VERBOSE,DEBUG,INFO,WARNINGS,ERROR,FATAL,ALWAYS
- m_verbose = msgLvl() <= MSG::VERBOSE;
-
- ATH_MSG_DEBUG("TrigMuonEFTagandProbe::hltInitialize()");
- ATH_MSG_DEBUG("TrigMuonEFTagandProbe::hltInitialize(); building framework for monitored variables");
-
- //Set up Monitoring framework to handle sensible filling of per threshold monitoring values for efficiency calculations
-
- //Build seperate containers for each monitored variable within each threshold
- //------------------------ORDER OF VARIABLES MUST BE RETAINED---------------------------
- //Order for filling is Barrel/Endcap/merged THEN eta/phi/etaphi/pt THEN total/efficiency
- //Threshold number must be unsigned int between 1 and 6 inclusive
-
- m_Thresh_Mon.build_threshold(1, //Threshold Number
- m_eta_total_thr1_b, //Eta values for all probe candidates passing threshold 1 within the barrel with extra 25GeV pT cut applied
- m_phi_total_thr1_b, //Phi values """ with extra 25GeV pT cut applied
- m_etaphi_eff_thr1_b, // 1.0 for all matched probes passing threshold 1 in barrel with extra 25GeV pT cut, 0.0 otherwise
- m_pt_total_thr1_b, //Pt values for all probe candidates excluding 25GeV cut
- m_pt_eff_thr1_b, //1.0 """ excluding 25GeV cut, 0.0 otherwise
- m_eta_total_thr1_e, //Eta values """ within the endcaps, pT cut
- m_phi_total_thr1_e, //Phi, endcap, pT cut
- m_etaphi_eff_thr1_e, // 1.0 """ in endcap with 25GeV cut
- m_pt_total_thr1_e, //pT values """ within endcap, excluding pT cut
- m_pt_eff_thr1_e, //1.0 """ excluding 25GeV cut, endcap
- m_eta_total_thr1, //Eta values for all probe candidates passing thresh 1 in full detector volume, including 25GeV pT cut
- m_eta_eff_thr1); //1.0 """ full detector volume, including pT cut
-
- m_Thresh_Mon.build_threshold(2,
- m_eta_total_thr2_b,
- m_phi_total_thr2_b,
- m_etaphi_eff_thr2_b,
- m_pt_total_thr2_b,
- m_pt_eff_thr2_b,
- m_eta_total_thr2_e,
- m_phi_total_thr2_e,
- m_etaphi_eff_thr2_e,
- m_pt_total_thr2_e,
- m_pt_eff_thr2_e,
- m_eta_total_thr2,
- m_eta_eff_thr2);
-
- m_Thresh_Mon.build_threshold(3,
- m_eta_total_thr3_b,
- m_phi_total_thr3_b,
- m_etaphi_eff_thr3_b,
- m_pt_total_thr3_b,
- m_pt_eff_thr3_b,
- m_eta_total_thr3_e,
- m_phi_total_thr3_e,
- m_etaphi_eff_thr3_e,
- m_pt_total_thr3_e,
- m_pt_eff_thr3_e,
- m_eta_total_thr3,
- m_eta_eff_thr3);
-
- m_Thresh_Mon.build_threshold(4,
- m_eta_total_thr4_b,
- m_phi_total_thr4_b,
- m_etaphi_eff_thr4_b,
- m_pt_total_thr4_b,
- m_pt_eff_thr4_b,
- m_eta_total_thr4_e,
- m_phi_total_thr4_e,
- m_etaphi_eff_thr4_e,
- m_pt_total_thr4_e,
- m_pt_eff_thr4_e,
- m_eta_total_thr4,
- m_eta_eff_thr4);
-
- m_Thresh_Mon.build_threshold(5,
- m_eta_total_thr5_b,
- m_phi_total_thr5_b,
- m_etaphi_eff_thr5_b,
- m_pt_total_thr5_b,
- m_pt_eff_thr5_b,
- m_eta_total_thr5_e,
- m_phi_total_thr5_e,
- m_etaphi_eff_thr5_e,
- m_pt_total_thr5_e,
- m_pt_eff_thr5_e,
- m_eta_total_thr5,
- m_eta_eff_thr5);
-
- m_Thresh_Mon.build_threshold(6,
- m_eta_total_thr6_b,
- m_phi_total_thr6_b,
- m_etaphi_eff_thr6_b,
- m_pt_total_thr6_b,
- m_pt_eff_thr6_b,
- m_eta_total_thr6_e,
- m_phi_total_thr6_e,
- m_etaphi_eff_thr6_e,
- m_pt_total_thr6_e,
- m_pt_eff_thr6_e,
- m_eta_total_thr6,
- m_eta_eff_thr6);
-
- ATH_MSG_INFO("TrigMuonEFTagandProbe Initialization completed successfully");
-
- return HLT::OK;
-}
-
-
-
-HLT::ErrorCode TrigMuonEFTagandProbe::hltFinalize()
-{
- ATH_MSG_DEBUG("TrigMuonEFTagandProbe::hltFinalize()");
-
- return HLT::OK;
-}
-
-
-HLT::ErrorCode TrigMuonEFTagandProbe::hltExecute(const HLT::TriggerElement* inputTE, HLT::TriggerElement* TEout)
-{
-
- //Reset temporary containers
- m_good_muons.clear(); //holds all combined muons
-
- ATH_MSG_DEBUG("TrigMuonEFTagandProbe::hltExecute()");
-
-
- //DEBUG to check if Trigger events are being passed to algorithm
- if (m_debug){
- std::string teInLabel;
- std::string teOutLabel;
- TrigConf::HLTTriggerElement::getLabel( inputTE->getId(), teInLabel );
- TrigConf::HLTTriggerElement::getLabel( TEout->getId(), teOutLabel );
-
- ATH_MSG_DEBUG("TrigMuonEFTagandProbeExecute() chain Trigger Event input ID=" << inputTE->getId() << " Trigger Event output ID=" << TEout->getId() << " Input Label=" << teInLabel << " Output Label=" << teOutLabel);
- }
-
-
- //-----------------Access LVL1 trigger ROI information--------------------------------------------------
-
-
- //Have to access from initialNode as AllTE combiner algorithms earlier in chain remove regular access back to seeding RoIs through getFeature
- //Check for LVL1 muon RoI information in current event first, if there is no info then we shouldn't bother calculating anything else and should move to next event
-
- std::vector<const LVL1::RecMuonRoI*> l1_muon_RoIs;
-
- HLT::Navigation* nav = config()->getNavigation();
- HLT::TriggerElement* initialTE = nav->getInitialNode(); //Get initial TE that chain is seeded from
- const std::vector<HLT::TriggerElement*>& inputTE_RoIs_nav = nav->getDirectSuccessors(initialTE); //Get all first generation TEs seeded from initialTE
-
- for (auto TERoI : inputTE_RoIs_nav) { //Loop through TEs (RoIs)
- const LVL1::RecMuonRoI* RoI;
- if(getFeature(TERoI, RoI)!=HLT::OK) { //Check TE for L1 RoI information
- ATH_MSG_DEBUG("No LVL1::RecMuonRoI Feature found in initial RoI Node"); //If getfeature fails
- return HLT::MISSING_FEATURE;
- }
- if (!RoI) { // if L1 Muon RoI entry is null
- ATH_MSG_DEBUG("Empty LVL1::RecMuonRoI feature found, trying another Trigger Element");
- }
- else{
- l1_muon_RoIs.push_back(RoI);
- }
- }
-
- if(l1_muon_RoIs.empty()){ //Save compute by killing if there is no L1 information
- ATH_MSG_DEBUG("L1 RoI size = 0, moving to next event");
- return HLT::OK;
- }
-
- ATH_MSG_DEBUG("Number of L1 RoIs found = "<<l1_muon_RoIs.size());
-
-
-
- //---------------------Get muonContainer linked to inputTE---------------------------------------------
-
- const xAOD::MuonContainer* muonContainer=0;
-
- // getFeature takes a trigger element (inputTE) and a target feature (MuonContainer) and fills the target with the feature found in the trigger element, Output is a HLT::code, but OK does NOT mean a matching, non zero feature was found just that the feature exists within the trigger element
-
- if(getFeature(inputTE, muonContainer)!=HLT::OK) { //If getfeature fails
- ATH_MSG_DEBUG("no xAOD::MuonContainer Feature found");
- return HLT::MISSING_FEATURE;
- }
-
-
-
- else { //If get feature succeeds
- if (!muonContainer) { // if muonContainer entry is null
- ATH_MSG_DEBUG("null xAOD::MuonContainer Feature found");
- return HLT::MISSING_FEATURE;
- }
-
- ATH_MSG_DEBUG("xAOD::MuonContainer found with size " << muonContainer->size());
- }
-
-
- // Initialise temporary value containers
- float deltaR=0.0;
- unsigned int tag_thresh=0;
- unsigned int probe_thresh=0;
-
- struct TaPMuon tagmuon, probemuon; //TaP Muon structures to group muon and RoI values into one object
-
-
- //----------------------Loop over EF muons within event ------------------------------------------------
-
-
- for(auto muon : *muonContainer) {
-
- if (!muon) { // Check if muon object is null
- ATH_MSG_DEBUG("No xAOD::Muon found.");
- continue; //move to next muon
- }
- else {
-
- if (muon->primaryTrackParticle()) { //was there a muon in this RoI? (check muon hasn't been stripped of information)
-
- //Checking muon is good (i.e. EF Combined muon NOT EF stand alone muon)
- const xAOD::TrackParticle* tr = muon->trackParticle(xAOD::Muon::CombinedTrackParticle);
-
-
- //------------------------10 GeV minimum pT cut applied--------------------------------------------
-
- if (!tr || tr->pt()/Gaudi::Units::GeV < 10.0) { // if this muon has NOT been formed from a combined track > 10GeV
-
- ATH_MSG_DEBUG("Bad muon is of type: " << muon->muonType() << " With 0=combined, 1=MuonSA, 2=SegmentTagged, 3=CaloTagged, 4=SiliconAssociatedForwardMuon, Abs pt = " << muon->pt()/Gaudi::Units::GeV << " GeV. Charge=" << muon->charge() << " Psuedorapidity = " << muon->eta() << " Phi = " << muon->phi());
- continue;
- }
-
- //---------------------------Collect good muons--------------------------------------------------
-
- else { //Current muon is formed from combined track
- ATH_MSG_DEBUG("Retrieved muon of type " << muon->muonType() << ": Combined track with abs pt " << tr->pt()/Gaudi::Units::GeV << " GeV. Charge=" << tr->charge() << " match chi2 = " << tr->chiSquared() << " Psuedorapidity = " << tr->eta() << " Phi = " << tr->phi());
-
- m_good_muons.push_back(muon);
- }
- }
- }
- }
-
-
- //------------------------Check and ensure exactly 2 good muons per event--------------------------------
-
- if (m_good_muons.size()<2){
- ATH_MSG_WARNING("Less than 2 combined muons before trimming so event will be ignored, moving to next event");
- return HLT::OK;
- }
-
-
- if (m_good_muons.size()>2 || (m_good_muons)[0]->charge() == (m_good_muons)[1]->charge())
- {
- ATH_MSG_DEBUG(">2 muons found or matching charge found, no. of \"good\" muons = " << m_good_muons.size());
- trim_container(m_good_muons); //Performs trimming of muon container reducing to size = 2
-
- if (m_good_muons.size()!=2){
- ATH_MSG_DEBUG("More/Less than 2 good muons after trimming so further event analysis will be ignored, moving to next event"); //Extra safety check although trim_container should only allow exit with exactly 2 muons
- return HLT::OK;
- }
-
- ATH_MSG_DEBUG("container trimmed, no. of good muons = " << m_good_muons.size());
- }
-
- //---------------------------Check isolation criteria for muon pair---------------------------------------
- //Require deltaR > 0.2 between the two muons in order to keep probe muons unbiased from the event trigger
-
- float TaPdeltaR = (m_good_muons)[0]->p4().DeltaR((m_good_muons)[1]->p4());
- ATH_MSG_DEBUG("TaP DeltaR value = " << TaPdeltaR);
-
- if (TaPdeltaR <= 0.2){
- ATH_MSG_WARNING("Tag and Probe not sufficiently isolated for unbiased efficiency; DeltaR = "<< TaPdeltaR <<" <= 0.2, moving to next event, LocalReadTest");
- return HLT::OK;
- }
-
-
- //-------------------Calculate dimuon invariant mass from 4 momenta for probe selection----------------
-
- float invMass_dimuon = (((m_good_muons)[0]->p4() + (m_good_muons)[1]->p4()).M())/Gaudi::Units::GeV;
-
- ATH_MSG_DEBUG("final size of good muon container = " << m_good_muons.size());
- ATH_MSG_DEBUG("Dimuon Invariant Mass from 4mom = " << invMass_dimuon);
-
-
-
- //--------------------Perform Tag L1 matching to produce Tag and Probe pairs--------------------------
-
- //Define a vector of pairs containing TaPmuon structure object and Probe muon i.e. tag and probe pairs
- std::vector<std::pair <TaPMuon,const xAOD::Muon*> > TaP;
-
- //A check so we don't bother trying to match muons to same RoI as isolation criteria already applied
- const LVL1::RecMuonRoI* sharedRoItest=0;
-
- for (unsigned int i=0;i<m_good_muons.size();i++){ //loop over good muons
-
- //For each muon calculate all Delta R values in scope
- for (auto roi : l1_muon_RoIs){
-
- //xAOD::P4Helpers class required for DeltaR calculation as RoI objects don't have 4 momenta
- deltaR = xAOD::P4Helpers::deltaR((*(m_good_muons)[i]), roi->eta(), roi->phi(), false); //UseRapidity=false
-
- ATH_MSG_DEBUG("DeltaR value = " << deltaR);
- tag_thresh=roi->getThresholdNumber();
- ATH_MSG_DEBUG("Threshold_ALL value = " << tag_thresh);
-
-
- //---------------------------------Apply tag muon criteria---------------------------------------
-
- if (abs(91.1876-invMass_dimuon)<10.0 && deltaR<0.1 && roi!=sharedRoItest && tag_thresh>=5) {
- sharedRoItest=roi; //Potentially removes extra loops as isolation criteria doesn't allow shared RoIs anyway
-
- ATH_MSG_DEBUG("Threshold_Tag value = " << tag_thresh);
-
- tagmuon.Mu = m_good_muons[i]; //Tag muon
- tagmuon.DR = deltaR; //Tag muon DeltaR
- tagmuon.Thresh = tag_thresh; // Tag muon matched L1 threshold number
- tagmuon.RoI = roi; //Tag muon match L1 RoI
-
- //construct Tag and Probe pair including extra tag muon information
- TaP.push_back(std::make_pair(tagmuon,m_good_muons[1-i])); //1-i index is safe as events are checked to be size=2
- break; //don't need to check other RoIs once a match is found
- }
- }
- }
-
- ATH_MSG_DEBUG("NUMBER of tag and probe pairs = " << TaP.size());
-
-
-
- //-----------------Perform Probe L1 matching to fill Total and Passing histograms for each threshold--------------------
-
- for (unsigned int i=0;i<TaP.size();i++){ //Loop over each tag and Probe pair
-
- //if Probe is also a tag then Tag matching isn't required, go straight to filling kinemetics
- if (TaP[i].second==(TaP[1-i].first).Mu){
-
- //Fill monitoring variables for different probe thresholds inclusively (probe muon info,Threshold MonitoringObject)
- match_thresh(TaP[1-i].first,m_Thresh_Mon);
- continue;
- }
-
- //If probe isn't a tag then loop over RoIs and look for a L1 match that is different from the Tag L1
- for (unsigned int j=0;j<l1_muon_RoIs.size();j++){
-
- //xAOD::P4Helpers class required for DeltaR calculation as RoI objects don't have 4 momenta
- deltaR = xAOD::P4Helpers::deltaR((*(TaP[i].second)), l1_muon_RoIs[j]->eta(), l1_muon_RoIs[j]->phi(), false);
-
- if (deltaR<0.1 && l1_muon_RoIs[j]!=(TaP[1-i].first).RoI){ //If probe passes LVL1 match criteria
-
- probe_thresh=l1_muon_RoIs[j]->getThresholdNumber();
-
- ATH_MSG_DEBUG("Threshold_Probe value = " << probe_thresh);
-
- probemuon.Mu = TaP[i].second; //Probe Muon
- probemuon.DR = deltaR; //Probe muon DeltaR
- probemuon.Thresh = probe_thresh; //Probe muon matched L1 threshold number
-
- match_thresh(probemuon,m_Thresh_Mon); //Fill monitoring variables (probe muon info, Threshold MonitoringObject)
- break;
- }
-
- //If Probe muon cannot be L1 matched
- if (j==(l1_muon_RoIs.size()-1)){
-
- match_thresh(TaP[i].second,m_Thresh_Mon); //Fill monitoring variables for unmatched probe (probe muon, MonitoringObject)
-
- }
- }
- }
-
- return HLT::OK;
-
-}
-
-
-//-----------------------------------Monitoring variable filling functions------------------------------------
-
-//-------------------------------------If Probe is successfully matched---------------------------------------
-//-------------------------------------Fill 1.0 into Efficiency histograms------------------------------------
-void TrigMuonEFTagandProbe::match_thresh (TaPMuon tap ,MonitoringObject Thresh_Mon){
-
- //Barrel
- if (abs(tap.Mu->eta())<1.05){
- for (unsigned int i=0;i<tap.Thresh;i++){ //Loop over all thresholds <= current probe threshold value
- if ((tap.Mu->pt()/Gaudi::Units::GeV) > 25.0){ //Apply extra 25GeV pT cut to eta and phi variables
-
- //Fills eta values within barrel for all probe candidates matching threshold i+1
- //i must be unsigned int between 0 and 5 inclusive
- Thresh_Mon.fill_eta_total_barrel(i,tap.Mu->eta()); //(Threshold Number,kinematic)
- Thresh_Mon.fill_phi_total_barrel(i,tap.Mu->phi());
- Thresh_Mon.fill_etaphi_matchfail_barrel(i,1.0); //(Threshold Number,Pass(1.0)/Fail(0.0))
- Thresh_Mon.fill_eta_total_merged(i,tap.Mu->eta());
- Thresh_Mon.fill_eta_matchfail_merged(i,1.0);
- }
-
- Thresh_Mon.fill_pt_total_barrel(i,tap.Mu->pt()/Gaudi::Units::GeV);
- Thresh_Mon.fill_pt_matchfail_barrel(i,1.0);
-
- }
- }
-
- //Endcap
- else {
- for (unsigned int i=0;i<tap.Thresh;i++){
- if ((tap.Mu->pt()/Gaudi::Units::GeV) > 25.0){
-
- Thresh_Mon.fill_eta_total_endcap(i,tap.Mu->eta());
- Thresh_Mon.fill_phi_total_endcap(i,tap.Mu->phi());
- Thresh_Mon.fill_etaphi_matchfail_endcap(i,1.0);
- Thresh_Mon.fill_eta_total_merged(i,tap.Mu->eta());
- Thresh_Mon.fill_eta_matchfail_merged(i,1.0);
- }
-
- Thresh_Mon.fill_pt_total_endcap(i,tap.Mu->pt()/Gaudi::Units::GeV);
- Thresh_Mon.fill_pt_matchfail_endcap(i,1.0);
-
- }
- }
-
-}
-
-
-//-------------------------------------If Probe cannot be successfully matched---------------------------
-//-------------------------------------Fill 0.0 into Efficiency histograms---------------------------------
-void TrigMuonEFTagandProbe::match_thresh (const xAOD::Muon* muon , MonitoringObject Thresh_Mon){
-
- //Barrel
- if (abs(muon->eta())<1.05){
- for (unsigned int i=0;i<6;i++){
- if ((muon->pt()/Gaudi::Units::GeV) > 25.0){
-
- Thresh_Mon.fill_eta_total_barrel(i,muon->eta());
- Thresh_Mon.fill_phi_total_barrel(i,muon->phi());
- Thresh_Mon.fill_etaphi_matchfail_barrel(i,0.0);
- Thresh_Mon.fill_eta_total_merged(i,muon->eta());
- Thresh_Mon.fill_eta_matchfail_merged(i,0.0);
- }
-
- Thresh_Mon.fill_pt_total_barrel(i,muon->pt()/Gaudi::Units::GeV);
- Thresh_Mon.fill_pt_matchfail_barrel(i,0.0);
-
- }
- }
-
- //Endcap
- else {
- for (unsigned int i=0;i<6;i++){
- if ((muon->pt()/Gaudi::Units::GeV) > 25.0){
-
-
- Thresh_Mon.fill_eta_total_endcap(i,muon->eta());
- Thresh_Mon.fill_phi_total_endcap(i,muon->phi());
- Thresh_Mon.fill_etaphi_matchfail_endcap(i,0.0);
- Thresh_Mon.fill_eta_total_merged(i,muon->eta());
- Thresh_Mon.fill_eta_matchfail_merged(i,0.0);
- }
-
- Thresh_Mon.fill_pt_total_endcap(i,muon->pt()/Gaudi::Units::GeV);
- Thresh_Mon.fill_pt_matchfail_endcap(i,0.0);
- }
- }
-}
-
-
-//--------------------------------------Event trimming function--------------------------------------
-
-//Function to resolve cases of >2 muons or 2 muons with same sign within muon container
-//Loops over muon pairs, check for opposite sign and evaluates diiference between Z mass and pair invariant mass
-//Picks pair with smallest mass difference < 10.0GeV
-void TrigMuonEFTagandProbe::trim_container (std::vector<const xAOD::Muon*>& good_muons){
-
- std::vector<const xAOD::Muon*> best_muon_pair; //Holds current best pair
-
- double mZdiff = 10.0; // Default cut to match condition for valid tag and probe pair
- for (unsigned int itmu1=0;itmu1<good_muons.size();itmu1++){ //Loop over muons
- for (unsigned int itmu2=itmu1+1;itmu2<good_muons.size();itmu2++){ //Loop over remaining muons
-
- const xAOD::Muon *mu1 = good_muons[itmu1];
- const xAOD::Muon *mu2 = good_muons[itmu2];
-
- if( (mu1->charge() * mu2->charge()) > 0 ){ //Look for same charge muons
- ATH_MSG_DEBUG("(trim_container) only found muons of one sign, moving to next pair");
- continue;
- }
-
- double tempinvmass = abs(91.1876-((mu1->p4() + mu2->p4()).M())/Gaudi::Units::GeV);
- if (tempinvmass < mZdiff){ //Found a new best pair
- best_muon_pair.resize(2, nullptr);
- best_muon_pair[0] = mu1;
- best_muon_pair[1] = mu2;
- mZdiff = tempinvmass; //Set new best mass difference
- }
- }
- }
-
- if( best_muon_pair.empty() ){
- ATH_MSG_DEBUG("(trim_container) Found no viable muon pairs, clearing container and moving on");
- good_muons.clear();
- return;
- }
-
- ATH_MSG_DEBUG("(trim_container) best match found, current number of muons in pair = "<<best_muon_pair.size());
-
- good_muons.clear();
- good_muons = best_muon_pair;
-
- ATH_MSG_DEBUG("(trim_container) best match found, current size of good_muons = "<<good_muons.size());
-}
-
-
-//-------------------------------------Threshold Monitoring functions------------------------------------
-//-------------------------------------Public functions within class MonitoringObject--------------------
-
-//Simple function to build ordered container for variables in each threshold
-//------------------ORDER OF VARIABLES IN EACH THRESHOLD CONTAINER IS IMPORTANT------------------------
-void MonitoringObject::build_threshold (unsigned int thresh,
- std::vector<float> &eta_total_b,
- std::vector<float> &phi_total_b,
- std::vector<float> &etaphi_eff_b,
- std::vector<float> &pt_total_b,
- std::vector<float> &pt_eff_b,
- std::vector<float> &eta_total_e,
- std::vector<float> &phi_total_e,
- std::vector<float> &etaphi_eff_e,
- std::vector<float> &pt_total_e,
- std::vector<float> &pt_eff_e,
- std::vector<float> &eta_total_merge,
- std::vector<float> &eta_eff_merge){
- if (thresh > m_ThreshMon.size()) return; //Safeguard against invalid threshold number, Valid thresholds are 1-->6 inclusive
-
- else {
- m_ThreshMon[thresh-1].push_back(&eta_total_b);
- m_ThreshMon[thresh-1].push_back(&phi_total_b);
- m_ThreshMon[thresh-1].push_back(&etaphi_eff_b);
- m_ThreshMon[thresh-1].push_back(&pt_total_b);
- m_ThreshMon[thresh-1].push_back(&pt_eff_b);
- m_ThreshMon[thresh-1].push_back(&eta_total_e);
- m_ThreshMon[thresh-1].push_back(&phi_total_e);
- m_ThreshMon[thresh-1].push_back(&etaphi_eff_e);
- m_ThreshMon[thresh-1].push_back(&pt_total_e);
- m_ThreshMon[thresh-1].push_back(&pt_eff_e);
- m_ThreshMon[thresh-1].push_back(&eta_total_merge);
- m_ThreshMon[thresh-1].push_back(&eta_eff_merge);
- }
-}
-
-
-//Simple filling functions for each variable type and each threshold value
-//--------------------ORDER OF VARIABLES IN THRESHOLD CONTAINERS IS IMPORTANT------------------------
-
-void MonitoringObject::fill_eta_total_barrel (unsigned int thresh, float value){
- if (thresh > m_ThreshMon.size()) return; //Safeguard against invalid threshold number, Valid thresholds are 1-->6 inclusive
- else m_ThreshMon[thresh][0]->push_back(value);
-}
-
-
-void MonitoringObject::fill_phi_total_barrel (unsigned int thresh, float value){
- if (thresh > m_ThreshMon.size()) return; //Safeguard against invalid threshold number, Valid thresholds are 1-->6 inclusive
- else m_ThreshMon[thresh][1]->push_back(value);
-}
-
-
-void MonitoringObject::fill_etaphi_matchfail_barrel (unsigned int thresh, float value){
- if (thresh > m_ThreshMon.size()) return; //Safeguard against invalid threshold number, Valid thresholds are 1-->6 inclusive
- else m_ThreshMon[thresh][2]->push_back(value);
-}
-
-
-void MonitoringObject::fill_pt_total_barrel (unsigned int thresh, float value){
- if (thresh > m_ThreshMon.size()) return; //Safeguard against invalid threshold number, Valid thresholds are 1-->6 inclusive
- else m_ThreshMon[thresh][3]->push_back(value);
-}
-
-
-void MonitoringObject::fill_pt_matchfail_barrel (unsigned int thresh, float value){
- if (thresh > m_ThreshMon.size()) return; //Safeguard against invalid threshold number, Valid thresholds are 1-->6 inclusive
- else m_ThreshMon[thresh][4]->push_back(value);
-}
-
-
-void MonitoringObject::fill_eta_total_endcap (unsigned int thresh, float value){
- if (thresh > m_ThreshMon.size()) return; //Safeguard against invalid threshold number, Valid thresholds are 1-->6 inclusive
- else m_ThreshMon[thresh][5]->push_back(value);
-}
-
-
-void MonitoringObject::fill_phi_total_endcap (unsigned int thresh, float value){
- if (thresh > m_ThreshMon.size()) return; //Safeguard against invalid threshold number, Valid thresholds are 1-->6 inclusive
- else m_ThreshMon[thresh][6]->push_back(value);
-}
-
-
-void MonitoringObject::fill_etaphi_matchfail_endcap (unsigned int thresh, float value){
- if (thresh > m_ThreshMon.size()) return; //Safeguard against invalid threshold number, Valid thresholds are 1-->6 inclusive
- else m_ThreshMon[thresh][7]->push_back(value);
-}
-
-
-void MonitoringObject::fill_pt_total_endcap (unsigned int thresh, float value){
- if (thresh > m_ThreshMon.size()) return; //Safeguard against invalid threshold number, Valid thresholds are 1-->6 inclusive
- else m_ThreshMon[thresh][8]->push_back(value);
-}
-
-
-void MonitoringObject::fill_pt_matchfail_endcap (unsigned int thresh, float value){
- if (thresh > m_ThreshMon.size()) return; //Safeguard against invalid threshold number, Valid thresholds are 1-->6 inclusive
- else m_ThreshMon[thresh][9]->push_back(value);
-}
-
-
-void MonitoringObject::fill_eta_total_merged (unsigned int thresh, float value){
- if (thresh > m_ThreshMon.size()) return; //Safeguard against invalid threshold number, Valid thresholds are 1-->6 inclusive
- else m_ThreshMon[thresh][10]->push_back(value);
-}
-
-
-void MonitoringObject::fill_eta_matchfail_merged (unsigned int thresh, float value){
- if (thresh > m_ThreshMon.size()) return; //Safeguard against invalid threshold number, Valid thresholds are 1-->6 inclusive
- else m_ThreshMon[thresh][11]->push_back(value);
-}
diff --git a/Trigger/TrigAlgorithms/TrigMuSuperEF/src/TrigMuonEFTagandProbe.h b/Trigger/TrigAlgorithms/TrigMuSuperEF/src/TrigMuonEFTagandProbe.h
deleted file mode 100644
index ec9f0701f44e9622f6834b4b3f8a3cd04eddc4d7..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuSuperEF/src/TrigMuonEFTagandProbe.h
+++ /dev/null
@@ -1,178 +0,0 @@
-/*
- Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
-*/
-
-/*
- TrigMuonEFTagandProbe
- Package: Trigger/TrigAlgorithms/TrigMuSuperEF
- Authors: Jonathan Jamieson, University of Glasgow, Created 09/10/2017, Last edit: 28/05/18
-*/
-
-#ifndef TRIGMUONEFTAGANDPROBE_TRIGMUONEFTAGANDPROBE_H
-#define TRIGMUONEFTAGANDPROBE_TRIGMUONEFTAGANDPROBE_H
-
-#include <string>
-#include <vector>
-
-#include "TrigInterfaces/Algo.h"
-#include "TrigInterfaces/FexAlgo.h"
-#include "TrigT1Interfaces/RecMuonRoI.h"
-
-//Structure for holding sets of useful Tag and Probe muon information
-struct TaPMuon {
- const xAOD::Muon* Mu;
- float DR;
- unsigned int Thresh;
- const LVL1::RecMuonRoI* RoI;
-};
-
-
-//Class to handle structuring and filling various monitoring variables by L1 trigger threshold
-class MonitoringObject {
-
- std::vector<std::vector <float>* > m_Threshold1, m_Threshold2, m_Threshold3, m_Threshold4, m_Threshold5, m_Threshold6;
- std::vector<std::vector<std::vector <float>* > > m_ThreshMon;
-
- public:
-
- MonitoringObject (); //Constructor, Allows for setting up framework of vectors ahead of time
-
- void build_threshold (unsigned int, std::vector<float>&, std::vector<float>&, std::vector<float>&, std::vector<float>&, std::vector<float>&, std::vector<float>&, std::vector<float>&, std::vector<float>&, std::vector<float>&, std::vector<float>&, std::vector<float>&, std::vector<float>&); //(Threshold number, Threshold specific variables)
-
- void fill_eta_total_barrel (unsigned int, float); //Threshold number, monitoring value)
- void fill_phi_total_barrel (unsigned int, float);
- void fill_etaphi_matchfail_barrel (unsigned int, float);
- void fill_pt_total_barrel (unsigned int, float);
- void fill_pt_matchfail_barrel (unsigned int, float);
- void fill_eta_total_endcap (unsigned int, float);
- void fill_phi_total_endcap (unsigned int, float);
- void fill_etaphi_matchfail_endcap (unsigned int, float);
- void fill_pt_total_endcap (unsigned int, float);
- void fill_pt_matchfail_endcap (unsigned int, float);
- void fill_eta_total_merged (unsigned int, float);
- void fill_eta_matchfail_merged (unsigned int, float);
-
-
-};
-
-
-class TriggerElement;
-
-class TrigMuonEFTagandProbe: public virtual HLT::FexAlgo { //TaP algorithm will inherit from HLT::FexAlgo
- public:
-
- TrigMuonEFTagandProbe (const std::string &name, ISvcLocator *pSvcLocator);
-
- virtual ~TrigMuonEFTagandProbe(); //destructor
-
- virtual HLT::ErrorCode hltInitialize();
- virtual HLT::ErrorCode hltExecute(const HLT::TriggerElement*, HLT::TriggerElement*);
- virtual HLT::ErrorCode hltFinalize();
-
- private:
-
- void trim_container(std::vector<const xAOD::Muon*>& good_muons);
-
- void match_thresh(TaPMuon tap,MonitoringObject Thresh_Mon);
- void match_thresh(const xAOD::Muon* muon,MonitoringObject Thresh_Mon);
-
- std::vector<const xAOD::Muon*> m_good_muons;
-
-
- std::vector<float> m_eta_total_thr1_b; //Threshold 1, barrel
- std::vector<float> m_phi_total_thr1_b;
- std::vector<float> m_pt_total_thr1_b;
- std::vector<float> m_eta_total_thr1_e; //Threshold 1, endcap
- std::vector<float> m_phi_total_thr1_e;
- std::vector<float> m_pt_total_thr1_e;
- std::vector<float> m_eta_total_thr1; //Threshold 1, combined barrel and endcap
-
- std::vector<float> m_eta_total_thr2_b; //Threshold 2, barrel
- std::vector<float> m_phi_total_thr2_b;
- std::vector<float> m_pt_total_thr2_b;
- std::vector<float> m_eta_total_thr2_e; //Threshold 2, endcap
- std::vector<float> m_phi_total_thr2_e;
- std::vector<float> m_pt_total_thr2_e;
- std::vector<float> m_eta_total_thr2; //Threshold 2, combined barrel and endcap
-
- std::vector<float> m_eta_total_thr3_b;
- std::vector<float> m_phi_total_thr3_b;
- std::vector<float> m_pt_total_thr3_b;
- std::vector<float> m_eta_total_thr3_e;
- std::vector<float> m_phi_total_thr3_e;
- std::vector<float> m_pt_total_thr3_e;
- std::vector<float> m_eta_total_thr3;
-
-
- std::vector<float> m_eta_total_thr4_b;
- std::vector<float> m_phi_total_thr4_b;
- std::vector<float> m_pt_total_thr4_b;
- std::vector<float> m_eta_total_thr4_e;
- std::vector<float> m_phi_total_thr4_e;
- std::vector<float> m_pt_total_thr4_e;
- std::vector<float> m_eta_total_thr4;
-
-
- std::vector<float> m_eta_total_thr5_b;
- std::vector<float> m_phi_total_thr5_b;
- std::vector<float> m_pt_total_thr5_b;
- std::vector<float> m_eta_total_thr5_e;
- std::vector<float> m_phi_total_thr5_e;
- std::vector<float> m_pt_total_thr5_e;
- std::vector<float> m_eta_total_thr5;
-
-
- std::vector<float> m_eta_total_thr6_b;
- std::vector<float> m_phi_total_thr6_b;
- std::vector<float> m_pt_total_thr6_b;
- std::vector<float> m_eta_total_thr6_e;
- std::vector<float> m_phi_total_thr6_e;
- std::vector<float> m_pt_total_thr6_e;
- std::vector<float> m_eta_total_thr6;
-
-
-
- std::vector<float> m_etaphi_eff_thr1_b;
- std::vector<float> m_pt_eff_thr1_b;
- std::vector<float> m_etaphi_eff_thr2_b;
- std::vector<float> m_pt_eff_thr2_b;
- std::vector<float> m_etaphi_eff_thr3_b;
- std::vector<float> m_pt_eff_thr3_b;
- std::vector<float> m_etaphi_eff_thr4_b;
- std::vector<float> m_pt_eff_thr4_b;
- std::vector<float> m_etaphi_eff_thr5_b;
- std::vector<float> m_pt_eff_thr5_b;
- std::vector<float> m_etaphi_eff_thr6_b;
- std::vector<float> m_pt_eff_thr6_b;
-
-
- std::vector<float> m_etaphi_eff_thr1_e;
- std::vector<float> m_pt_eff_thr1_e;
- std::vector<float> m_etaphi_eff_thr2_e;
- std::vector<float> m_pt_eff_thr2_e;
- std::vector<float> m_etaphi_eff_thr3_e;
- std::vector<float> m_pt_eff_thr3_e;
- std::vector<float> m_etaphi_eff_thr4_e;
- std::vector<float> m_pt_eff_thr4_e;
- std::vector<float> m_etaphi_eff_thr5_e;
- std::vector<float> m_pt_eff_thr5_e;
- std::vector<float> m_etaphi_eff_thr6_e;
- std::vector<float> m_pt_eff_thr6_e;
-
-
- std::vector<float> m_eta_eff_thr1;
- std::vector<float> m_eta_eff_thr2;
- std::vector<float> m_eta_eff_thr3;
- std::vector<float> m_eta_eff_thr4;
- std::vector<float> m_eta_eff_thr5;
- std::vector<float> m_eta_eff_thr6;
-
-
- //Sets up instance of MonitoringObject public to TrigMuonEFTagandProbe
- MonitoringObject m_Thresh_Mon;
-
- bool m_debug; //Flag for conditional DEBUG output
- bool m_verbose; //Flag for conditional VEROSE output
-
-};
-#endif
diff --git a/Trigger/TrigAlgorithms/TrigMuSuperEF/src/components/TrigMuSuperEF_entries.cxx b/Trigger/TrigAlgorithms/TrigMuSuperEF/src/components/TrigMuSuperEF_entries.cxx
deleted file mode 100644
index 2c3dcf0beaae9aafcdac108c12fb102a2fa8102d..0000000000000000000000000000000000000000
--- a/Trigger/TrigAlgorithms/TrigMuSuperEF/src/components/TrigMuSuperEF_entries.cxx
+++ /dev/null
@@ -1,5 +0,0 @@
-#include "../TrigMuSuperEF.h"
-#include "../TrigMuonEFTagandProbe.h"
-
-DECLARE_COMPONENT( TrigMuSuperEF )
-DECLARE_COMPONENT(TrigMuonEFTagandProbe)