From 2ee8344efe4a84c7cc95c2e0207b39fbff2e4089 Mon Sep 17 00:00:00 2001 From: tstreble <thomas.strebler@cern.ch> Date: Thu, 21 Jul 2022 15:59:43 +0200 Subject: [PATCH 1/6] Clean up CA config for TRT DAF tools --- .../InDetConfig/python/InDetConfigFlags.py | 5 -- .../InDetConfig/python/TRTExtensionConfig.py | 65 ++++--------------- .../python/TRT_TrackExtensionToolConfig.py | 35 ++-------- .../python/TrackingCommonConfig.py | 23 ------- .../python/TrkRIO_OnTrackCreatorConfig.py | 2 +- 5 files changed, 20 insertions(+), 110 deletions(-) diff --git a/InnerDetector/InDetConfig/python/InDetConfigFlags.py b/InnerDetector/InDetConfig/python/InDetConfigFlags.py index 1624bacb6aa5..fb71abd82b63 100644 --- a/InnerDetector/InDetConfig/python/InDetConfigFlags.py +++ b/InnerDetector/InDetConfig/python/InDetConfigFlags.py @@ -99,11 +99,6 @@ def createInDetConfigFlags(): False) # Use broad cluster errors for Pixel icf.addFlag("InDet.Tracking.useBroadSCTClusterErrors", False) # Use broad cluster errors for SCT - # which extension type ("xk"/"DAF") - icf.addFlag("InDet.Tracking.trtExtensionType", "xk") - # use smart TRT LR/tube hit creator and redo ROTs - icf.addFlag("InDet.Tracking.redoTRT_LR", - lambda prevFlags: (not prevFlags.InDet.Tracking.trtExtensionType == "DAF")) # Tracking passes/configurations scheduled diff --git a/InnerDetector/InDetConfig/python/TRTExtensionConfig.py b/InnerDetector/InDetConfig/python/TRTExtensionConfig.py index 266a315f0052..2d44076f37b2 100644 --- a/InnerDetector/InDetConfig/python/TRTExtensionConfig.py +++ b/InnerDetector/InDetConfig/python/TRTExtensionConfig.py @@ -18,62 +18,25 @@ def TRT_TrackExtensionAlgCfg(flags, name = 'InDetTRT_ExtensionPhase', SiTrackCol acc.addEventAlgo(CompFactory.InDet.TRT_TrackExtensionAlg(name = name, **kwargs)) return acc -def CompetingRIOsOnTrackToolCfg(flags, name = 'InDetCompetingRotCreator', **kwargs): - acc = ComponentAccumulator() - InDetCompetingTRT_DC_Tool = acc.popToolsAndMerge(TC.InDetCompetingTRT_DC_ToolCfg(flags)) - acc.addPublicTool(InDetCompetingTRT_DC_Tool) - - kwargs.setdefault("ToolForCompPixelClusters", None) - kwargs.setdefault("ToolForCompSCT_Clusters", None) - kwargs.setdefault("ToolForCompTRT_DriftCircles", InDetCompetingTRT_DC_Tool) - acc.setPrivateTools(CompFactory.Trk.CompetingRIOsOnTrackTool(name = name, **kwargs)) - return acc - -def DeterministicAnnealingFilterCfg(flags, name = 'InDetDAF', **kwargs): - acc = ComponentAccumulator() - InDetCompetingRotCreator = acc.popToolsAndMerge(CompetingRIOsOnTrackToolCfg(flags)) - acc.addPublicTool(InDetCompetingRotCreator) - - from TrkConfig.AtlasExtrapolatorConfig import InDetExtrapolatorCfg - InDetExtrapolator = acc.getPrimaryAndMerge(InDetExtrapolatorCfg(flags)) - - from InDetConfig.TrackingCommonConfig import InDetUpdatorCfg - InDetUpdator = acc.popToolsAndMerge(InDetUpdatorCfg(flags)) - - kwargs.setdefault("ToolForExtrapolation", InDetExtrapolator) - kwargs.setdefault("ToolForCompetingROTsCreation", InDetCompetingRotCreator) - kwargs.setdefault("ToolForUpdating", InDetUpdator) - kwargs.setdefault("AnnealingScheme", [200., 81., 9., 4., 1., 1., 1.]) - kwargs.setdefault("DropOutlierCutValue", 1.E-7) - kwargs.setdefault("OutlierCutValue", 0.01) - acc.setPrivateTools(CompFactory.Trk.DeterministicAnnealingFilter(name = name, **kwargs)) - return acc - def InDetExtensionProcessorCfg(flags, SiTrackCollection=None, ExtendedTrackCollection = None, ExtendedTracksMap = None, **kwargs): acc = ComponentAccumulator() - if flags.InDet.Tracking.trtExtensionType == 'DAF' : - # - # --- DAF Fitter setup - # - InDetExtensionFitter = acc.popToolsAndMerge(DeterministicAnnealingFilterCfg(flags, name = 'InDetDAF'+ flags.InDet.Tracking.ActivePass.extension)) + fitter_args = {} + if flags.InDet.Tracking.holeSearchInGX2Fit: + fitter_args.setdefault("DoHoleSearch", True) + from InDetConfig.InDetBoundaryCheckToolConfig import InDetBoundaryCheckToolCfg + InDetBoundaryCheckTool = acc.popToolsAndMerge(InDetBoundaryCheckToolCfg(flags)) + fitter_args.setdefault("BoundaryCheckTool", InDetBoundaryCheckTool) + + if flags.InDet.Tracking.ActivePass.extension != "LowPt": + from TrkConfig.CommonTrackFitterConfig import InDetTrackFitterCfg + InDetExtensionFitter = acc.popToolsAndMerge(InDetTrackFitterCfg(flags, 'InDetTrackFitter_TRTExtension'+flags.InDet.Tracking.ActivePass.extension, **fitter_args)) acc.addPublicTool(InDetExtensionFitter) else: - fitter_args = {} - if flags.InDet.Tracking.holeSearchInGX2Fit: - fitter_args.setdefault("DoHoleSearch", True) - from InDetConfig.InDetBoundaryCheckToolConfig import InDetBoundaryCheckToolCfg - InDetBoundaryCheckTool = acc.popToolsAndMerge(InDetBoundaryCheckToolCfg(flags)) - fitter_args.setdefault("BoundaryCheckTool", InDetBoundaryCheckTool) - - if flags.InDet.Tracking.ActivePass.extension != "LowPt": - from TrkConfig.CommonTrackFitterConfig import InDetTrackFitterCfg - InDetExtensionFitter = acc.popToolsAndMerge(InDetTrackFitterCfg(flags, 'InDetTrackFitter_TRTExtension'+flags.InDet.Tracking.ActivePass.extension, **fitter_args)) - acc.addPublicTool(InDetExtensionFitter) - else: - from TrkConfig.CommonTrackFitterConfig import InDetTrackFitterLowPtCfg - InDetExtensionFitter = acc.popToolsAndMerge(InDetTrackFitterLowPtCfg(flags, 'InDetTrackFitter_TRTExtension'+flags.InDet.Tracking.ActivePass.extension, **fitter_args)) - acc.addPublicTool(InDetExtensionFitter) + from TrkConfig.CommonTrackFitterConfig import InDetTrackFitterLowPtCfg + InDetExtensionFitter = acc.popToolsAndMerge(InDetTrackFitterLowPtCfg(flags, 'InDetTrackFitter_TRTExtension'+flags.InDet.Tracking.ActivePass.extension, **fitter_args)) + acc.addPublicTool(InDetExtensionFitter) + # # --- load scoring for extension # diff --git a/InnerDetector/InDetConfig/python/TRT_TrackExtensionToolConfig.py b/InnerDetector/InDetConfig/python/TRT_TrackExtensionToolConfig.py index 58b34e2132c2..a5e42a914526 100644 --- a/InnerDetector/InDetConfig/python/TRT_TrackExtensionToolConfig.py +++ b/InnerDetector/InDetConfig/python/TRT_TrackExtensionToolConfig.py @@ -1,5 +1,5 @@ # Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration -# Configuration of TRT_TrackExtensionTool_xk and TRT_TrackExtensionTool_DAF packages +# Configuration of TRT_TrackExtensionTool_xk packages from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator from AthenaConfiguration.ComponentFactory import CompFactory from AthenaConfiguration.Enums import BeamType @@ -92,33 +92,8 @@ def TRT_TrackExtensionTool_xkCfg(flags, name='TRT_TrackExtensionTool_xk', **kwar acc.setPrivateTools(CompFactory.InDet.TRT_TrackExtensionTool_xk(name, **kwargs)) return acc -def TRT_TrackExtensionTool_DAFCfg(flags, name='TRT_TrackExtensionTool_DAF',**kwargs): - acc = ComponentAccumulator() - - if 'CompetingDriftCircleTool' not in kwargs: - from InDetConfig.TrackingCommonConfig import InDetCompetingTRT_DC_ToolCfg - kwargs.setdefault("CompetingDriftCircleTool", acc.popToolsAndMerge(InDetCompetingTRT_DC_ToolCfg(flags))) - - if 'PropagatorTool' not in kwargs: - from TrkConfig.TrkExRungeKuttaPropagatorConfig import RungeKuttaPropagatorCfg - InDetPatternPropagator = acc.popToolsAndMerge(RungeKuttaPropagatorCfg(flags, name="InDetPatternPropagator")) - acc.addPublicTool(InDetPatternPropagator) - kwargs.setdefault("PropagatorTool", InDetPatternPropagator) - - if 'RoadTool' not in kwargs: - from InDetConfig.TrackingCommonConfig import InDetTRT_RoadMakerCfg - kwargs.setdefault("RoadTool", acc.popToolsAndMerge(InDetTRT_RoadMakerCfg(flags))) - - kwargs.setdefault("TRT_DriftCircleContainer", 'TRT_DriftCircles') - - acc.setPrivateTools(CompFactory.InDet.TRT_TrackExtensionTool_DAF(name,**kwargs)) - return acc - def TRT_TrackExtensionToolCfg(flags, name='TRT_TrackExtensionTool', **kwargs): - if flags.InDet.Tracking.trtExtensionType == 'xk': - if flags.Beam.Type is BeamType.Cosmics: - return TRT_TrackExtensionToolCosmicsCfg(flags, name, **kwargs) - else: - return TRT_TrackExtensionTool_xkCfg(flags, name, **kwargs) - if flags.InDet.Tracking.trtExtensionType == 'DAF': - return TRT_TrackExtensionTool_DAFCfg(flags, name, **kwargs) + if flags.Beam.Type is BeamType.Cosmics: + return TRT_TrackExtensionToolCosmicsCfg(flags, name, **kwargs) + else: + return TRT_TrackExtensionTool_xkCfg(flags, name, **kwargs) diff --git a/InnerDetector/InDetConfig/python/TrackingCommonConfig.py b/InnerDetector/InDetConfig/python/TrackingCommonConfig.py index 0f009472d0b8..641cc72e15d4 100644 --- a/InnerDetector/InDetConfig/python/TrackingCommonConfig.py +++ b/InnerDetector/InDetConfig/python/TrackingCommonConfig.py @@ -6,29 +6,6 @@ from AthenaConfiguration.ComponentFactory import CompFactory #TRTSegmentFinder ############################################################################################# -def InDetWeightCalculatorCfg(name='InDetWeightCalculator', **kwargs): - acc = ComponentAccumulator() - acc.setPrivateTools(CompFactory.Trk.DAF_SimpleWeightCalculator(name, **kwargs)) - return acc - -def InDetCompetingTRT_DC_ToolCfg(flags, name='InDetCompetingTRT_DC_Tool', **kwargs): - acc = ComponentAccumulator() - - if 'Extrapolator' not in kwargs: - from TrkConfig.AtlasExtrapolatorConfig import InDetExtrapolatorCfg - kwargs.setdefault("Extrapolator", acc.getPrimaryAndMerge(InDetExtrapolatorCfg(flags))) - - if 'ToolForWeightCalculation' not in kwargs: - InDetWeightCalculator = acc.popToolsAndMerge(InDetWeightCalculatorCfg()) - kwargs.setdefault("ToolForWeightCalculation", InDetWeightCalculator) - - if 'ToolForTRT_DriftCircleOnTrackCreation' not in kwargs: - from InDetConfig.TRT_DriftCircleOnTrackToolConfig import TRT_DriftCircleOnTrackToolCfg - kwargs.setdefault("ToolForTRT_DriftCircleOnTrackCreation", acc.popToolsAndMerge(TRT_DriftCircleOnTrackToolCfg(flags))) - - acc.setPrivateTools(CompFactory.InDet.CompetingTRT_DriftCirclesOnTrackTool(name, **kwargs)) - return acc - def InDetTRT_RoadMakerCfg(flags, name='InDetTRT_RoadMaker', **kwargs): from MagFieldServices.MagFieldServicesConfig import MagneticFieldSvcCfg acc = MagneticFieldSvcCfg(flags) diff --git a/Tracking/TrkConfig/python/TrkRIO_OnTrackCreatorConfig.py b/Tracking/TrkConfig/python/TrkRIO_OnTrackCreatorConfig.py index b3a13744a6f8..a9565ede0255 100644 --- a/Tracking/TrkConfig/python/TrkRIO_OnTrackCreatorConfig.py +++ b/Tracking/TrkConfig/python/TrkRIO_OnTrackCreatorConfig.py @@ -90,7 +90,7 @@ def InDetBroadRotCreatorCfg(flags, name='InDetBroadInDetRotCreator', **kwargs): def InDetRefitRotCreatorCfg(flags, name='InDetRefitRotCreator', **kwargs): acc = ComponentAccumulator() - if flags.Detector.EnableTRT and flags.InDet.Tracking.redoTRT_LR: + if flags.Detector.EnableTRT: if 'ToolTRT_DriftCircle' not in kwargs: from InDetConfig.TRT_DriftCircleOnTrackToolConfig import ( TRT_DriftCircleOnTrackUniversalToolCfg) -- GitLab From b2932da7454364b21c167771889ad5ddf71b7838 Mon Sep 17 00:00:00 2001 From: tstreble <thomas.strebler@cern.ch> Date: Thu, 21 Jul 2022 16:05:48 +0200 Subject: [PATCH 2/6] Removed InDetCompetingRIOsOnTrackTool and TRT_TrackExtensionTool_DAF directories --- .../CMakeLists.txt | 16 - .../ATLAS_CHECK_THREAD_SAFETY | 1 - .../CompetingPixelClustersOnTrackTool.h | 148 --- .../CompetingSCT_ClustersOnTrackTool.h | 151 --- .../CompetingTRT_DriftCirclesOnTrackTool.h | 174 --- .../ICompetingPixelClustersOnTrackCreator.h | 91 -- .../ICompetingSCT_ClustersOnTrackCreator.h | 92 -- ...ICompetingTRT_DriftCirclesOnTrackCreator.h | 81 -- .../doc/packagedoc.h | 43 - .../src/CompetingPixelClustersOnTrackTool.cxx | 557 -------- .../src/CompetingSCT_ClustersOnTrackTool.cxx | 542 -------- .../CompetingTRT_DriftCirclesOnTrackTool.cxx | 1140 ----------------- ...ingTRT_DriftCirclesOnTrackTool_entries.cxx | 8 - .../ATLAS_CHECK_THREAD_SAFETY | 1 - .../TRT_TrackExtensionTool_DAF/CMakeLists.txt | 10 - .../TRT_TrackExtensionTool_DAF.h | 186 --- .../doc/packagedoc.h | 86 -- .../src/TRT_TrackExtensionTool_DAF.cxx | 727 ----------- .../TRT_TrackExtensionTool_DAF_entries.cxx | 4 - 19 files changed, 4058 deletions(-) delete mode 100644 InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/CMakeLists.txt delete mode 100644 InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/InDetCompetingRIOsOnTrackTool/ATLAS_CHECK_THREAD_SAFETY delete mode 100755 InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/InDetCompetingRIOsOnTrackTool/CompetingPixelClustersOnTrackTool.h delete mode 100755 InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/InDetCompetingRIOsOnTrackTool/CompetingSCT_ClustersOnTrackTool.h delete mode 100755 InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/InDetCompetingRIOsOnTrackTool/CompetingTRT_DriftCirclesOnTrackTool.h delete mode 100755 InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/InDetCompetingRIOsOnTrackTool/ICompetingPixelClustersOnTrackCreator.h delete mode 100755 InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/InDetCompetingRIOsOnTrackTool/ICompetingSCT_ClustersOnTrackCreator.h delete mode 100755 InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/InDetCompetingRIOsOnTrackTool/ICompetingTRT_DriftCirclesOnTrackCreator.h delete mode 100644 InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/doc/packagedoc.h delete mode 100755 InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/src/CompetingPixelClustersOnTrackTool.cxx delete mode 100755 InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/src/CompetingSCT_ClustersOnTrackTool.cxx delete mode 100755 InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/src/CompetingTRT_DriftCirclesOnTrackTool.cxx delete mode 100644 InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/src/components/CompetingTRT_DriftCirclesOnTrackTool_entries.cxx delete mode 100644 InnerDetector/InDetRecTools/TRT_TrackExtensionTool_DAF/ATLAS_CHECK_THREAD_SAFETY delete mode 100644 InnerDetector/InDetRecTools/TRT_TrackExtensionTool_DAF/CMakeLists.txt delete mode 100755 InnerDetector/InDetRecTools/TRT_TrackExtensionTool_DAF/TRT_TrackExtensionTool_DAF/TRT_TrackExtensionTool_DAF.h delete mode 100644 InnerDetector/InDetRecTools/TRT_TrackExtensionTool_DAF/doc/packagedoc.h delete mode 100755 InnerDetector/InDetRecTools/TRT_TrackExtensionTool_DAF/src/TRT_TrackExtensionTool_DAF.cxx delete mode 100644 InnerDetector/InDetRecTools/TRT_TrackExtensionTool_DAF/src/components/TRT_TrackExtensionTool_DAF_entries.cxx diff --git a/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/CMakeLists.txt b/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/CMakeLists.txt deleted file mode 100644 index 30741ab96e0e..000000000000 --- a/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/CMakeLists.txt +++ /dev/null @@ -1,16 +0,0 @@ -# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration - -# Declare the package name: -atlas_subdir( InDetCompetingRIOsOnTrackTool ) - -atlas_add_library( InDetCompetingRIOsOnTrackToolLib - InDetCompetingRIOsOnTrackTool/*.h - INTERFACE - PUBLIC_HEADERS InDetCompetingRIOsOnTrackTool - LINK_LIBRARIES GaudiKernel AthenaBaseComps TrkParameters EventPrimitives GeoPrimitives TrkToolInterfaces InDetCompetingRIOsOnTrack ) - -# Component(s) in the package: -atlas_add_component( InDetCompetingRIOsOnTrackTool - src/*.cxx - src/components/*.cxx - LINK_LIBRARIES InDetCompetingRIOsOnTrack InDetCompetingRIOsOnTrackToolLib InDetPrepRawData TrkEventPrimitives TrkExInterfaces TrkSurfaces TrkToolInterfaces ) diff --git a/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/InDetCompetingRIOsOnTrackTool/ATLAS_CHECK_THREAD_SAFETY b/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/InDetCompetingRIOsOnTrackTool/ATLAS_CHECK_THREAD_SAFETY deleted file mode 100644 index b86ad13e8993..000000000000 --- a/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/InDetCompetingRIOsOnTrackTool/ATLAS_CHECK_THREAD_SAFETY +++ /dev/null @@ -1 +0,0 @@ -InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool diff --git a/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/InDetCompetingRIOsOnTrackTool/CompetingPixelClustersOnTrackTool.h b/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/InDetCompetingRIOsOnTrackTool/CompetingPixelClustersOnTrackTool.h deleted file mode 100755 index 6f7e6fe1cec8..000000000000 --- a/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/InDetCompetingRIOsOnTrackTool/CompetingPixelClustersOnTrackTool.h +++ /dev/null @@ -1,148 +0,0 @@ -/* - Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration -*/ - -/////////////////////////////////////////////////////////////////// -// Header file for class CompetingPixelClustersOnTrackTool -/////////////////////////////////////////////////////////////////// -// (c) ATLAS Detector software -/////////////////////////////////////////////////////////////////// -// Tool for CompetingPixelClustersOnTrack creation -/////////////////////////////////////////////////////////////////// -// sebastian.fleischmann@cern.ch -/////////////////////////////////////////////////////////////////// - -#ifndef COMPETINGPIXELCLUSTERSONTRACKTOOL_H -#define COMPETINGPIXELCLUSTERSONTRACKTOOL_H -// Gaudi -#include "AthenaBaseComps/AthAlgTool.h" -#include "GaudiKernel/ToolHandle.h" - -// InDet -#include "InDetCompetingRIOsOnTrackTool/ICompetingPixelClustersOnTrackCreator.h" -//#include "SiClusterOnTrackTool/PixelClusterOnTrackTool.h" // re-visit once this has an abstract interface - -// Trk -#include "TrkParameters/TrackParameters.h" // typedef -// STL -#include <list> -//#include <vector> -#include <string> - -namespace Trk { - class LocalParameters; - class ErrorMatrix; - class Surface; - class PrepRawData; - class IExtrapolator; - class IRIO_OnTrackCreator; - class IWeightCalculator; -} - - -namespace InDet { - class CompetingPixelClustersOnTrack; - -/** @class CompetingPixelClustersOnTrackTool - This tool creates - InDet::CompetingPixelClustersOnTrack objects using a given - track hypothesis and a list of InDet::PixelCluster - (given as Trk::PrepRawData to allow for a common interface in namespace Trk). - It uses Trk::IRIO_OnTrackCreator (jobOption: ToolForPixelClusterOnTrackCreation) - to create the PixelClusterOnTrack and - Trk::IWeightCalculator (jobOption: ToolForWeightCalculation) to calculate the assignment probabilities of the - competing measurements. - - From each PixelCluster (RIO) a PixelClusterOnTrack (ROTs) is created. - - The annealing factor used in the weight calculation can be given in the function call - and the used cut values for Barrel or End-Cap Pixel detector, resp. are given by jobOptions (WeightCutValueBarrel - resp. WeightCutValueEndCap). - - This tool can also be used to update the assignment probabilities and the effective measurements - after an annealing iteration step. - - @author Sebastian.Fleischmann@cern.ch -*/ - - -class CompetingPixelClustersOnTrackTool : public AthAlgTool, - virtual public InDet::ICompetingPixelClustersOnTrackCreator { - /////////////////////////////////////////////////////////////////// - // Public methods: - /////////////////////////////////////////////////////////////////// - -public: - /** AlgTool Constructor */ - CompetingPixelClustersOnTrackTool(const std::string&,const std::string&,const IInterface*); - virtual ~CompetingPixelClustersOnTrackTool (); - /** AlgTool init */ - virtual StatusCode initialize(); - /** AlgTool finalize */ - virtual StatusCode finalize (); - - /** creation of an InDet::CompetingPixelClustersOnTrack from a list of Trk::PrepRawData - (which should be InDet::PixelCluster, otherwise they will be ignored). - - TrackParameters should be given in the frame of one of the PixelCluster - - the AnnealingFactor is given to the IWeightCalculator */ - virtual const InDet::CompetingPixelClustersOnTrack* createCompetingROT( - const std::list< const Trk::PrepRawData* >&, - const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor ) const; - - /** update of the assignment probabilities and effective measurements - of an InDet::CompetingPixelClustersOnTrack using a new track prediction. - - Trk::IWeightCalculator is called first to recalculate the assignment probabilities - - the new effective measurements are calculated afterwards (this cannot be done by the - Trk::IWeightCalculator, because it has no detector specific knowledge) - - the update can be performed because CompetingPixelClustersOnTrackTool is a - friend of CompetingPixelClustersOnTrack - - if recreateROTs==true the PixelClusterOnTrack (ROTs) contained in the - CompetingPixelClustersOnTrack are recreated using IRIO_OnTrackCreator - to do detector specific corrections of the measurements again (might - be needed when the predicted TrackParameters have changed rapidly) */ - virtual void updateCompetingROT( - //const InDet::CompetingPixelClustersOnTrack&, - Trk::CompetingRIOsOnTrack&, - const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor - // const bool recreateROTs=false - ) const; - - virtual void reequipCompetingROT(Trk::CompetingRIOsOnTrack*&, - const Trk::RIO_OnTrack*, - const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor, - const Trk::TrackState::MeasurementType - = Trk::TrackState::unidentified) const; - - virtual StatusCode updateCompetingROTprobs( - Trk::CompetingRIOsOnTrack&, - const std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >& - ) const; - -private: - - /////////////////////////////////////////////////////////////////// - // Private data: - /////////////////////////////////////////////////////////////////// - - ToolHandle< Trk::IRIO_OnTrackCreator > m_Pixel_ROTCreator; //!< Det-specific ROT creation for Pixels - // TODO: change PixelClusterOnTrackTool to interface class (eg. IPixelClusterOnTrackTool) - // once that one exists - - ToolHandle< Trk::IWeightCalculator > m_WeightCalculator; //!< Weight calculator tool for assignment probabilities - - double m_jo_EndCapCutValue; //!< job option set cutValue of assignment probabilities for Pixel end-cap - double m_jo_BarrelCutValue; //!< job option set cutValue of assignment probabilities for barrel Pixel - - ToolHandle< Trk::IExtrapolator > m_extrapolator; //!< the Extrapolator tool - - /////////////////////////////////////////////////////////////////// - // Private functions: - /////////////////////////////////////////////////////////////////// - void testCompetingROT(const InDet::CompetingPixelClustersOnTrack&)const; - -}; -} // end of namespace InDet -#endif // COMPETINGPIXELCLUSTERSONTRACKTOOL_H diff --git a/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/InDetCompetingRIOsOnTrackTool/CompetingSCT_ClustersOnTrackTool.h b/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/InDetCompetingRIOsOnTrackTool/CompetingSCT_ClustersOnTrackTool.h deleted file mode 100755 index a411a29eed5a..000000000000 --- a/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/InDetCompetingRIOsOnTrackTool/CompetingSCT_ClustersOnTrackTool.h +++ /dev/null @@ -1,151 +0,0 @@ -/* - Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration -*/ - -/////////////////////////////////////////////////////////////////// -// Header file for class CompetingSCT_ClustersOnTrackTool -/////////////////////////////////////////////////////////////////// -// (c) ATLAS Detector software -/////////////////////////////////////////////////////////////////// -// Tool for CompetingSCT_ClustersOnTrack creation -/////////////////////////////////////////////////////////////////// -// sebastian.fleischmann@cern.ch -/////////////////////////////////////////////////////////////////// - -#ifndef COMPETINGSCT_CLUSTERSONTRACKTOOL_H -#define COMPETINGSCT_CLUSTERSONTRACKTOOL_H -// Gaudi -#include "AthenaBaseComps/AthAlgTool.h" -#include "GaudiKernel/ToolHandle.h" - -// InDet -#include "InDetCompetingRIOsOnTrackTool/ICompetingSCT_ClustersOnTrackCreator.h" -//#include "InDetCompetingRIOsOnTrack/CompetingSCT_ClustersOnTrack.h" -// #include "SiClusterOnTrackTool/SCT_ClusterOnTrackTool.h" - -// Trk -//#include "InDetRIO_OnTrack/SCT_ClusterOnTrack.h" -#include "TrkParameters/TrackParameters.h" -//#include "TrkToolInterfaces/IWeightCalculator.h" -// STL -#include <list> -//#include <vector> -#include <string> - -namespace Trk { - class LocalParameters; - class ErrorMatrix; - class Surface; - class PrepRawData; - class IExtrapolator; - class IRIO_OnTrackCreator; - class IWeightCalculator; -} - - -namespace InDet { - class CompetingSCT_ClustersOnTrack; - -/** @class CompetingSCT_ClustersOnTrackTool - This tool creates - InDet::CompetingSCT_ClustersOnTrack objects using a given - track hypothesis and a list of InDet::SCT_Cluster - (given as Trk::PrepRawData to allow for a common interface in namespace Trk). - It uses Trk::IRIO_OnTrackCreator (jobOption: ToolForSCT_ClusterOnTrackCreation) - to create the SCT_ClusterOnTrack and - Trk::IWeightCalculator (jobOption: ToolForWeightCalculation) to calculate the assignment probabilities of the - competing measurements. - - From each SCT_Cluster (RIO) a SCT_ClusterOnTrack (ROTs) is created. - - The annealing factor used in the weight calculation can be given in the function call - and the used cut values for Barrel or End-Cap SCT_ detector, resp. are given by jobOptions (WeightCutValueBarrel - resp. WeightCutValueEndCap). - - This tool can also be used to update the assignment probabilities and the effective measurements - after an annealing iteration step. - - @author Sebastian.Fleischmann@cern.ch -*/ - - -class CompetingSCT_ClustersOnTrackTool : public AthAlgTool, - virtual public InDet::ICompetingSCT_ClustersOnTrackCreator { - /////////////////////////////////////////////////////////////////// - // Public methods: - /////////////////////////////////////////////////////////////////// - -public: - /** AlgTool Constructor */ - CompetingSCT_ClustersOnTrackTool(const std::string&,const std::string&,const IInterface*); - virtual ~CompetingSCT_ClustersOnTrackTool (); - /** AlgTool init */ - virtual StatusCode initialize(); - /** AlgTool finalize */ - virtual StatusCode finalize (); - - /** creation of an InDet::CompetingSCT_ClustersOnTrack from a list of Trk::PrepRawData - (which should be InDet::SCT_Cluster, otherwise they will be ignored). - - TrackParameters should be given in the frame of one of the SCT_Cluster - - the AnnealingFactor is given to the IWeightCalculator */ - virtual const InDet::CompetingSCT_ClustersOnTrack* createCompetingROT( - const std::list< const Trk::PrepRawData* >&, - const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor ) const; - - /** update of the assignment probabilities and effective measurements - of an InDet::CompetingSCT_ClustersOnTrack using a new track prediction. - - Trk::IWeightCalculator is called first to recalculate the assignment probabilities - - the new effective measurements are calculated afterwards (this cannot be done by the - Trk::IWeightCalculator, because it has no detector specific knowledge) - - the update can be performed because CompetingSCT_ClustersOnTrackTool is a - friend of CompetingSCT_ClustersOnTrack - - if recreateROTs==true the SCT_ClusterOnTrack (ROTs) contained in the - CompetingSCT_ClustersOnTrack are recreated using IRIO_OnTrackCreator - to do detector specific corrections of the measurements again (might - be needed when the predicted TrackParameters have changed rapidly) */ - virtual void updateCompetingROT( - //const InDet::CompetingSCT_ClustersOnTrack&, - Trk::CompetingRIOsOnTrack&, - const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor - // const bool recreateROTs=false - ) const; - - virtual void reequipCompetingROT(Trk::CompetingRIOsOnTrack*&, - const Trk::RIO_OnTrack*, - const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor, - const Trk::TrackState::MeasurementType - = Trk::TrackState::unidentified) const; - virtual StatusCode updateCompetingROTprobs( - Trk::CompetingRIOsOnTrack&, - const std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >& - ) const; - - -private: - - /////////////////////////////////////////////////////////////////// - // Private data: - /////////////////////////////////////////////////////////////////// - - ToolHandle< Trk::IRIO_OnTrackCreator > m_SCT__ROTCreator; //!< Det-specific ROT creation for SCT - // TODO: change SCT_ClusterOnTrackTool to interface class (eg. ISCT_ClusterOnTrackTool) - // once it exists some time - - ToolHandle< Trk::IWeightCalculator > m_WeightCalculator; //!< Weight calculator tool for assignment probabilities - - double m_jo_EndCapCutValue; //!< job option set cutValue of assignment probabilities for end-cap - double m_jo_BarrelCutValue; //!< job option set cutValue of assignment probabilities for barrel SCT_ - - ToolHandle< Trk::IExtrapolator > m_extrapolator; //!< the Extrapolator tool - - /////////////////////////////////////////////////////////////////// - // Private functions: - /////////////////////////////////////////////////////////////////// - void testCompetingROT(const InDet::CompetingSCT_ClustersOnTrack&)const; - -}; -} // end of namespace InDet -#endif // COMPETINGSCT_CLUSTERSONTRACKTOOL_H diff --git a/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/InDetCompetingRIOsOnTrackTool/CompetingTRT_DriftCirclesOnTrackTool.h b/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/InDetCompetingRIOsOnTrackTool/CompetingTRT_DriftCirclesOnTrackTool.h deleted file mode 100755 index cb7ddb87ec2c..000000000000 --- a/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/InDetCompetingRIOsOnTrackTool/CompetingTRT_DriftCirclesOnTrackTool.h +++ /dev/null @@ -1,174 +0,0 @@ -/* - Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration -*/ - -/////////////////////////////////////////////////////////////////// -// Header file for class CompetingTRT_DriftCirclesOnTrackTool -/////////////////////////////////////////////////////////////////// -// (c) ATLAS Detector software -/////////////////////////////////////////////////////////////////// -// Tool for CompetingTRT_DriftCirclesOnTrack creation -/////////////////////////////////////////////////////////////////// -// sebastian.fleischmann@cern.ch -/////////////////////////////////////////////////////////////////// - -#ifndef COMPETINGTRT_DRIFTCIRCLESONTRACKTOOL_H -#define COMPETINGTRT_DRIFTCIRCLESONTRACKTOOL_H -// Gaudi -#include "AthenaBaseComps/AthAlgTool.h" -#include "GaudiKernel/ToolHandle.h" - -// InDet -#include "InDetCompetingRIOsOnTrackTool/ICompetingTRT_DriftCirclesOnTrackCreator.h" - -// Trk -#include "TrkParameters/TrackParameters.h" -// STL -#include <list> -#include <string> - -#include "EventPrimitives/EventPrimitives.h" -#include "GeoPrimitives/GeoPrimitives.h" - -// interfaces -#include "TrkExInterfaces/IExtrapolator.h" -#include "TrkToolInterfaces/IRIO_OnTrackCreator.h" -#include "TrkToolInterfaces/IWeightCalculator.h" - -namespace Trk { - class LocalParameters; - class Surface; - class PrepRawData; -} - - -namespace InDet { - class CompetingTRT_DriftCirclesOnTrack; - -/** @class CompetingTRT_DriftCirclesOnTrackTool - This tool creates - InDet::CompetingTRT_DriftCirclesOnTrack objects using a given - track hypothesis and a list of InDet::TRT_DriftCircle - (given as Trk::PrepRawData to allow for a common interface in namespace Trk). - It uses Trk::IRIO_OnTrackCreator (jobOption: ToolForTRT_DriftCircleOnTrackCreation) - to create the TRT_DriftCircleOnTrack and - Trk::IWeightCalculator (jobOption: ToolForWeightCalculation) to calculate the assignment probabilities of the - competing measurements. - - From each TRT_DriftCircle (RIO) two TRT_DriftCircleOnTrack (ROTs) are created. This - corresponds to the left and the right solution of the DriftCircle. - - The annealing factor used in the weight calculation can be given in the function call - and the used cut values for Barrel TRT resp. End-Cap TRT are given by jobOptions (WeightCutValueBarrel - resp. WeightCutValueEndCap). - - This tool can also be used to update the assignment probabilities and the effective measurements - after an annealing iteration step. -*/ - - -class CompetingTRT_DriftCirclesOnTrackTool : public AthAlgTool, - virtual public InDet::ICompetingTRT_DriftCirclesOnTrackCreator { - /////////////////////////////////////////////////////////////////// - // Public methods: - /////////////////////////////////////////////////////////////////// - -public: - /** AlgTool Constructor */ - CompetingTRT_DriftCirclesOnTrackTool(const std::string&,const std::string&,const IInterface*); - virtual ~CompetingTRT_DriftCirclesOnTrackTool (); - /** AlgTool init */ - virtual StatusCode initialize(); - /** AlgTool finalize */ - virtual StatusCode finalize (); - - /** creation of an InDet::CompetingTRT_DriftCirclesOnTrack from a list of Trk::PrepRawData - (which should be TRT_DriftCircle, otherwise they will be ignored). - - TrackParameters should be given in the frame of one of the TRT_DriftCircle - - the AnnealingFactor is given to the IWeightCalculator */ - virtual const InDet::CompetingTRT_DriftCirclesOnTrack* createCompetingROT( - const std::list< const Trk::PrepRawData* >&, - const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor ) const; - - /** update of the assignment probabilities and effective measurements - of an InDet::CompetingTRT_DriftCirclesOnTrack using a new track prediction. - - Trk::IWeightCalculator is called first to recalculate the assignment probabilities - - the new effective measurements are calculated afterwards (this cannot be done by the - Trk::IWeightCalculator, because it has no detector specific knowledge) - - the update can be performed because CompetingTRT_DriftCirclesOnTrackTool is a - friend of CompetingTRT_DriftCirclesOnTrack - - if recreateROTs==true the TRT_DriftCircleOnTrack (ROTs) contained in the - CompetingTRT_DriftCirclesOnTrack are recreated using IRIO_OnTrackCreator - to do detector specific corrections of the measurements again (might - be needed when the predicted TrackParameters have changed rapidly) */ - virtual void updateCompetingROT( - //const InDet::CompetingTRT_DriftCirclesOnTrack&, - Trk::CompetingRIOsOnTrack&, - const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor - // const bool recreateROTs=false - ) const; - - /** making of simple competing ROT (competes against outlier hypothesis) */ - virtual const Trk::CompetingRIOsOnTrack* createSimpleCompetingROT( - const Trk::PrepRawData&, - const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor, - const Trk::TrackState::MeasurementType) const; - - virtual void reequipCompetingROT(Trk::CompetingRIOsOnTrack*&, - const Trk::RIO_OnTrack*, - const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor, - const Trk::TrackState::MeasurementType - = Trk::TrackState::unidentified) const; - - -private: - - /////////////////////////////////////////////////////////////////// - // Private data: - /////////////////////////////////////////////////////////////////// - - ToolHandle< Trk::IRIO_OnTrackCreator > m_TRT_ROTCreator - {this, "ToolForTRT_DriftCircleOnTrackCreation", "InDet::TRT_DriftCircleOnTrackTool/TRT_DriftCircleOnTrackTool", "TRT_DriftCircleOnTrackCreator needed for the creation of CompetingPixelClustersOnTrack"}; //!< Det-specific ROT creation for TRT - - ToolHandle< Trk::IWeightCalculator > m_weightCalculator - {this, "ToolForWeightCalculation", "Trk::DAF_SimpleWeightCalculator/DAF_WeightCalculator", "Tool for weight (assignment probability) calculation"}; //!< Weight calculator tool for assignment probabilities - - double m_jo_EndCapCutValue; //!< job option set cutValue of assignment probabilities for TRT end-cap - double m_jo_BarrelCutValue; //!< job option set cutValue of assignment probabilities for barrel TRT - - PublicToolHandle< Trk::IExtrapolator > m_extrapolator - {this, "Extrapolator", "Trk::Extrapolator/AtlasExtrapolator", "Extrapolator tool"}; //!< the Extrapolator tool - - /////////////////////////////////////////////////////////////////// - // Private functions: - /////////////////////////////////////////////////////////////////// - - //return the effective LocalParameters according to the weights (assignment probabilities) - void calcEffectiveMeasurement( - std::unique_ptr<const Trk::LocalParameters>& effectiveLocalPar, - std::unique_ptr<const Amg::MatrixX>& effectiveErrMat, - const std::vector< const InDet::TRT_DriftCircleOnTrack* >*, - const std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >*, - const Trk::TrackParameters*, - const Trk::Surface* surf, - bool nonVanishingROTsHaveCommonSurface - )const; - - void calcEffectiveEndCapMeasurement( - std::unique_ptr<const Trk::LocalParameters>& effectiveLocalPar, - std::unique_ptr<const Amg::MatrixX>& effectiveErrMat, - const std::vector< const InDet::TRT_DriftCircleOnTrack* >*, - const std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >*, - const Amg::Vector2D& localTrack, - const Trk::Surface* surf - )const; - - void testCompetingROT(const InDet::CompetingTRT_DriftCirclesOnTrack&)const; - -}; -} // end of namespace InDet -#endif // COMPETINGTRT_DRIFTCIRCLESONTRACKTOOL_H diff --git a/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/InDetCompetingRIOsOnTrackTool/ICompetingPixelClustersOnTrackCreator.h b/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/InDetCompetingRIOsOnTrackTool/ICompetingPixelClustersOnTrackCreator.h deleted file mode 100755 index 05a801af2c05..000000000000 --- a/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/InDetCompetingRIOsOnTrackTool/ICompetingPixelClustersOnTrackCreator.h +++ /dev/null @@ -1,91 +0,0 @@ -/* - Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration -*/ - -/////////////////////////////////////////////////////////////////// -// Header file for class ICompetingPixelClustersOnTrackCreator -/////////////////////////////////////////////////////////////////// -// (c) ATLAS Detector software -/////////////////////////////////////////////////////////////////// -// Interface class for CompetingPixelClustersOnTrack creation -/////////////////////////////////////////////////////////////////// -// sebastian.fleischmann@cern.ch -/////////////////////////////////////////////////////////////////// - -#ifndef ICOMPETINGPIXELCLUSTERSONTRACKCREATOR_H -#define ICOMPETINGPIXELCLUSTERSONTRACKCREATOR_H - -#include "GaudiKernel/IAlgTool.h" -#include "TrkParameters/TrackParameters.h" //typedef -// needed for typedef of AnnealingFactor: -#include "TrkToolInterfaces/IWeightCalculator.h" - -#include "TrkToolInterfaces/ICompetingRIOsOnTrackTool.h" -#include "InDetCompetingRIOsOnTrack/CompetingPixelClustersOnTrack.h" // needed due to inheritance of the return pointer -// STL -#include <list> - -/** @class ICompetingPixelClustersOnTrackCreator - This class provides the interface for tools that create - InDet::CompetingPixelClustersOnTrack objects using a given - track hypothesis and a list of InDet::PixelCluster - (given as Trk::PrepRawData to allow for a common interface in namespace Trk). - @author Sebastian.Fleischmann@cern.ch -*/ - -namespace Trk { - class PrepRawData; - class CompetingRIOsOnTrack; -} - -namespace InDet { -//class CompetingPixelClustersOnTrack; - -static const InterfaceID IID_ICompetingPixelClustersOnTrackCreator("ICompetingPixelClustersOnTrackCreator",1,0); - - -//class ICompetingPixelClustersOnTrackCreator : virtual public IAlgTool { -class ICompetingPixelClustersOnTrackCreator : virtual public Trk::ICompetingRIOsOnTrackTool { - /////////////////////////////////////////////////////////////////// - // Public methods: - /////////////////////////////////////////////////////////////////// - -public: - - static const InterfaceID& interfaceID() { - return IID_ICompetingPixelClustersOnTrackCreator; - } //!< The AlgTool InterfaceID - virtual StatusCode initialize()=0; //!< standard AlgTool method - virtual StatusCode finalize()=0; //!< standard AlgTool method - - /** abstract base method for the creation of a single InDet::CompetingPixelClustersOnTrack, - it takes a list of RIOs (PrepRawData) and the given Track Parameter, cutValue defines - the cut used for calculating the initial assignment probabilities (see Trk::IWeightCalculator). - */ - virtual const InDet::CompetingPixelClustersOnTrack* createCompetingROT( - const std::list< const Trk::PrepRawData * > &, - const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor ) const = 0; // pure virtual - - /** abstract base method for the update of the assignment probabilities and effective measurements - of an InDet::CompetingPixelClustersOnTrack using a new track prediction. - - Trk::CompetingRIOsOnTrack is used because of interface reasons - (common interface Trk::ICompetingRIOsOnTrackTool)*/ - virtual void updateCompetingROT( - Trk::CompetingRIOsOnTrack&, - const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor - // const bool recreateROTs=false - ) const = 0; - - /** @brief update of the assignment probabilities - and effective measurements of a Trk::CompetingRIOsOnTrack using - a given set of assignment probabilities */ - virtual StatusCode updateCompetingROTprobs( - Trk::CompetingRIOsOnTrack&, - const std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >& - ) const = 0; - -}; -} // end of namespace InDet -#endif // ICOMPETINGPIXELCLUSTERSONTRACKCREATOR_H diff --git a/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/InDetCompetingRIOsOnTrackTool/ICompetingSCT_ClustersOnTrackCreator.h b/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/InDetCompetingRIOsOnTrackTool/ICompetingSCT_ClustersOnTrackCreator.h deleted file mode 100755 index ebb258d7be3b..000000000000 --- a/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/InDetCompetingRIOsOnTrackTool/ICompetingSCT_ClustersOnTrackCreator.h +++ /dev/null @@ -1,92 +0,0 @@ -/* - Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration -*/ - -/////////////////////////////////////////////////////////////////// -// Header file for class ICompetingSCT_ClustersOnTrackCreator -/////////////////////////////////////////////////////////////////// -// (c) ATLAS Detector software -/////////////////////////////////////////////////////////////////// -// Interface class for CompetingSCT_ClustersOnTrack creation -/////////////////////////////////////////////////////////////////// -// sebastian.fleischmann@cern.ch -/////////////////////////////////////////////////////////////////// - -#ifndef ICOMPETINGSCT_CLUSTERSONTRACKCREATOR_H -#define ICOMPETINGSCT_CLUSTERSONTRACKCREATOR_H - -#include "GaudiKernel/IAlgTool.h" -#include "TrkParameters/TrackParameters.h" // typedef -// needed for typedef of AnnealingFactor: -#include "TrkToolInterfaces/IWeightCalculator.h" - -#include "TrkToolInterfaces/ICompetingRIOsOnTrackTool.h" -#include "InDetCompetingRIOsOnTrack/CompetingSCT_ClustersOnTrack.h" // needed due to inheritance of the return pointer -// STL -#include <list> - -/** @class ICompetingSCT_ClustersOnTrackCreator - This class provides the interface for tools that create - InDet::CompetingSCT_ClustersOnTrack objects using a given - track hypothesis and a list of InDet::SCT_Cluster - (given as Trk::PrepRawData to allow for a common interface in namespace Trk). - @author Sebastian.Fleischmann@cern.ch -*/ - -namespace Trk { -class PrepRawData; -//class CompetingRIOsOnTrack; -} - -namespace InDet { -//class CompetingSCT_ClustersOnTrack; - -static const InterfaceID IID_ICompetingSCT_ClustersOnTrackCreator("ICompetingSCT_ClustersOnTrackCreator",1,0); - - -//class ICompetingSCT_ClustersOnTrackCreator : virtual public IAlgTool { -class ICompetingSCT_ClustersOnTrackCreator : virtual public Trk::ICompetingRIOsOnTrackTool { - /////////////////////////////////////////////////////////////////// - // Public methods: - /////////////////////////////////////////////////////////////////// - -public: - - static const InterfaceID& interfaceID() { - return IID_ICompetingSCT_ClustersOnTrackCreator; - } //!< The AlgTool InterfaceID - virtual StatusCode initialize()=0; //!< standard AlgTool method - virtual StatusCode finalize()=0; //!< standard AlgTool method - - /** abstract base method for the creation of a single InDet::CompetingSCT_ClustersOnTrack, - it takes a list of RIOs (PrepRawData) and the given Track Parameter, cutValue defines - the cut used for calculating the initial assignment probabilities (see Trk::IWeightCalculator). - */ - virtual const InDet::CompetingSCT_ClustersOnTrack* createCompetingROT( - const std::list< const Trk::PrepRawData * > &, - const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor ) const = 0; // pure virtual - - /** abstract base method for the update of the assignment probabilities and effective measurements - of an InDet::CompetingSCT_ClustersOnTrack using a new track prediction. - - Trk::CompetingRIOsOnTrack is used because of interface reasons - (common interface Trk::ICompetingRIOsOnTrackTool)*/ - virtual void updateCompetingROT( - //const InDet::CompetingSCT_ClustersOnTrack&, - Trk::CompetingRIOsOnTrack&, - const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor - // const bool recreateROTs=false - ) const = 0; - - /** @brief update of the assignment probabilities - and effective measurements of a Trk::CompetingRIOsOnTrack using - a given set of assignment probabilities */ - virtual StatusCode updateCompetingROTprobs( - Trk::CompetingRIOsOnTrack&, - const std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >& - ) const = 0; - -}; -} // end of namespace InDet -#endif // ICOMPETINGSCT_CLUSTERSONTRACKCREATOR_H diff --git a/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/InDetCompetingRIOsOnTrackTool/ICompetingTRT_DriftCirclesOnTrackCreator.h b/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/InDetCompetingRIOsOnTrackTool/ICompetingTRT_DriftCirclesOnTrackCreator.h deleted file mode 100755 index d9014b99d434..000000000000 --- a/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/InDetCompetingRIOsOnTrackTool/ICompetingTRT_DriftCirclesOnTrackCreator.h +++ /dev/null @@ -1,81 +0,0 @@ -/* - Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration -*/ - -/////////////////////////////////////////////////////////////////// -// Header file for class ICompetingTRT_DriftCirclesOnTrackTool -/////////////////////////////////////////////////////////////////// -// (c) ATLAS Detector software -/////////////////////////////////////////////////////////////////// -// Interface class for CompetingTRT_DriftCirclesOnTrack creation -/////////////////////////////////////////////////////////////////// -// sebastian.fleischmann@cern.ch -/////////////////////////////////////////////////////////////////// - -#ifndef ICOMPETINGTRT_DRIFTCIRCLESONTRACKCREATOR_H -#define ICOMPETINGTRT_DRIFTCIRCLESONTRACKCREATOR_H - -#include "GaudiKernel/IAlgTool.h" -#include "TrkParameters/TrackParameters.h" //typedef -// needed for typedef of AnnealingFactor: -#include "TrkToolInterfaces/IWeightCalculator.h" - -#include "TrkToolInterfaces/ICompetingRIOsOnTrackTool.h" -#include "InDetCompetingRIOsOnTrack/CompetingTRT_DriftCirclesOnTrack.h" // needed due to inheritance of the return pointer -// STL -#include <list> - -/** @class ICompetingTRT_DriftCirclesOnTrackCreator - This class provides the interface for tools that create - InDet::CompetingTRT_DriftCirclesOnTrack objects using a given - track hypothesis and a list of InDet::TRT_DriftCircle - (given as Trk::PrepRawData to allow for a common interface in namespace Trk). -*/ - -namespace Trk { -class PrepRawData; -//class CompetingRIOsOnTrack; -} - -namespace InDet { -//class CompetingTRT_DriftCirclesOnTrack; -static const InterfaceID IID_ICompetingTRT_DriftCirclesOnTrackCreator("ICompetingTRT_DriftCirclesOnTrackCreator",1,0); - - -//class ICompetingTRT_DriftCirclesOnTrackCreator : virtual public IAlgTool { -class ICompetingTRT_DriftCirclesOnTrackCreator : virtual public Trk::ICompetingRIOsOnTrackTool { - /////////////////////////////////////////////////////////////////// - // Public methods: - /////////////////////////////////////////////////////////////////// - -public: - - static const InterfaceID& interfaceID() { - return IID_ICompetingTRT_DriftCirclesOnTrackCreator; - } //!< The AlgTool InterfaceID - virtual StatusCode initialize()=0; //!< standard AlgTool method - virtual StatusCode finalize()=0; //!< standard AlgTool method - - /** abstract base method for the creation of a single InDet::CompetingTRT_DriftCirclesOnTrack, - it takes a list of RIOs (PrepRawData) and the given Track Parameter, cutValue defines - the cut used for calculating the initial assignment probabilities (see Trk::IWeightCalculator). - */ - virtual const InDet::CompetingTRT_DriftCirclesOnTrack* createCompetingROT( - const std::list< const Trk::PrepRawData * > &, - const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor ) const = 0; // pure virtual - - /** abstract base method for the update of the assignment probabilities and effective measurements - of an InDet::CompetingTRT_DriftCirclesOnTrack using a new track prediction. - - Trk::CompetingRIOsOnTrack is used because of interface reasons - (common interface Trk::ICompetingRIOsOnTrackTool)*/ - virtual void updateCompetingROT( - //const InDet::CompetingTRT_DriftCirclesOnTrack&, - Trk::CompetingRIOsOnTrack&, - const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor - // const bool recreateROTs=false - ) const = 0; -}; -} // end of namespace InDet -#endif // ICOMPETINGTRT_DRIFTCIRCLESONTRACKCREATOR_H diff --git a/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/doc/packagedoc.h b/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/doc/packagedoc.h deleted file mode 100644 index 51b0ebb28751..000000000000 --- a/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/doc/packagedoc.h +++ /dev/null @@ -1,43 +0,0 @@ -/* - Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration -*/ - -/** -@page InDetCompetingRIOsOnTrackTool_page The InDetCompetingRIOsOnTrackTool package -The InDet package for CompetingRIOsOnTrack creation. - -@author Sebastian.Fleischmann@cern.ch - -@section InDetCompetingRIOsOnTrackTool_introductionInDetCompetingRIOsOnTrackTool Introduction - -This package contains the tools to create Trk::CompetingRIOsOnTrack for the InDet realm -(i.e. InDet::CompetingTRT_DriftCirclesOnTrack, InDet::CompetingPixelClustersOnTrack, InDet::CompetingSCT_ClustersOnTrack). This includes - creation of the RIO_OnTrack objects with the corresponding tools. - - From each TRT_DriftCircle (RIO) two TRT_DriftCircleOnTrack (ROTs) are created. This - corresponds to the left and the right solution of the DriftCircle. - -@section InDetCompetingRIOsOnTrackTool_InDetCompetingRIOsOnTrackToolOverview Class Overview - The InDetCompetingRIOsOnTrackTool package contains the following classes: - - - InDet::ICompetingPixelClustersOnTrackCreator : Interface class for CompetingPixelClustersOnTrackTools. - - InDet::ICompetingSCT_ClustersOnTrackCreator : Interface class for CompetingSCT_ClustersOnTrackTools. - - InDet::ICompetingTRT_DriftCirclesOnTrackCreator : Interface class for CompetingTRT_DriftCirclesOnTrackTools. - - InDet::CompetingPixelClustersOnTrackTool : creates InDet::CompetingPixelClustersOnTrack objects using a given - track hypothesis and a list of InDet::PixelCluster (given as Trk::PrepRawData). It creates - the InDet::PixelClusterOnTrack objects with the PixelClusterOnTrackTool. All InDet::PixelCluster have to - belong to the same detector element. - - InDet::CompetingSCT_ClustersOnTrackTool : creates InDet::CompetingSCT_ClustersOnTrack objects using a given - track hypothesis and a list of InDet::SCT_Cluster (given as Trk::PrepRawData). It creates - the InDet::SCT_ClusterOnTrack objects with the SCT_ClusterOnTrackTool. All InDet::SCT_Cluster have to - belong to the same detector element. - - InDet::CompetingTRT_DriftCirclesOnTrackTool : creates InDet::CompetingTRT_DriftCirclesOnTrack objects using a given - track hypothesis and a list of InDet::TRT_DriftCircle (given as Trk::PrepRawData). It creates - the InDet::TRT_DriftCircleOnTrack objects with the TRT_DriftCircleOnTrackTool. - From each TRT_DriftCircle (RIO) two TRT_DriftCircleOnTrack (ROTs) are created. This - corresponds to the left and the right solution of the DriftCircle. The TRT_DriftCircle may belong to different - straw tubes and the effective measurement is projected to the tube of the most probable measurement. - -@section InDetCompetingRIOsOnTrackTool_ExtrasInDetCompetingRIOsOnTrackTool Extra Pages - -*/ diff --git a/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/src/CompetingPixelClustersOnTrackTool.cxx b/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/src/CompetingPixelClustersOnTrackTool.cxx deleted file mode 100755 index 0de0f566bede..000000000000 --- a/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/src/CompetingPixelClustersOnTrackTool.cxx +++ /dev/null @@ -1,557 +0,0 @@ -/* - Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration -*/ - -/////////////////////////////////////////////////////////////////// -// Implementation file for class CompetingPixelClustersOnTrackTool -/////////////////////////////////////////////////////////////////// -// (c) ATLAS Detector software -/////////////////////////////////////////////////////////////////// -// Tool for CompetingPixelClustersOnTrack creation -/////////////////////////////////////////////////////////////////// -// sebastian.fleischmann@cern.ch -/////////////////////////////////////////////////////////////////// - -// Header -#include "InDetCompetingRIOsOnTrackTool/CompetingPixelClustersOnTrackTool.h" - -//#include "GaudiKernel/MsgStream.h" - -// data model -#include "TrkEventPrimitives/LocalParameters.h" -#include "InDetPrepRawData/PixelCluster.h" -//#include "TrkParameters/AtaStraightLine.h" -//#include "TrkSurfaces/DiscSurface.h" -//#include "TrkSurfaces/StraightLineSurface.h" - -#include "InDetCompetingRIOsOnTrack/CompetingPixelClustersOnTrack.h" - - -// interfaces -#include "TrkExInterfaces/IExtrapolator.h" -#include "TrkToolInterfaces/IRIO_OnTrackCreator.h" -#include "TrkToolInterfaces/IWeightCalculator.h" - -/////////////////////////////////////////////////////////////////// -// Constructor -/////////////////////////////////////////////////////////////////// - -InDet::CompetingPixelClustersOnTrackTool::CompetingPixelClustersOnTrackTool( - const std::string& ty, - const std::string& na, - const IInterface* pa ) : - AthAlgTool(ty,na,pa), - m_Pixel_ROTCreator("InDet::PixelClusterOnTrackTool/PixelClusterOnTrackTool"), - m_WeightCalculator("Trk::DAF_SimpleWeightCalculator/DAF_WeightCalculator"), - m_extrapolator("Trk::Extrapolator/AtlasExtrapolator") -{ - declareInterface<ICompetingPixelClustersOnTrackCreator>(this); - declareProperty("ToolForPixelClusterOnTrackCreation", m_Pixel_ROTCreator, "PixelClusterOnTrackCreator needed for the creation of CompetingPixelClustersOnTrack"); - declareProperty("ToolForWeightCalculation", m_WeightCalculator, "Tool for weight (assignment probability) calculation"); - declareProperty("WeightCutValueBarrel", m_jo_BarrelCutValue=13.81551,"lambda parameter (intrinsic roadwidth) for measurements in the Barrel part"); - declareProperty("WeightCutValueEndCap", m_jo_EndCapCutValue=13.81551,"lambda parameter (intrinsic roadwidth) for measurements in the EndCap part"); - declareProperty("Extrapolator", m_extrapolator, "Extrapolator tool"); -} - -/////////////////////////////////////////////////////////////////// -// Destructor -/////////////////////////////////////////////////////////////////// - -InDet::CompetingPixelClustersOnTrackTool::~CompetingPixelClustersOnTrackTool() = default; - -/////////////////////////////////////////////////////////////////// -// Initialisation -/////////////////////////////////////////////////////////////////// - -StatusCode InDet::CompetingPixelClustersOnTrackTool::initialize() { - StatusCode sc = AlgTool::initialize(); - - ATH_MSG_INFO("Pixel ROTCreation by : " << m_Pixel_ROTCreator.name() ); - ATH_MSG_INFO("weight calculation by: " << m_WeightCalculator.name() ); - ATH_MSG_INFO("WeightCutValues are : " << m_jo_BarrelCutValue<< " (barrel) and " - << m_jo_EndCapCutValue<< " (end-cap)"); - - // Get the correction tool to create PixelClusters on Track - sc = m_Pixel_ROTCreator.retrieve(); - if (sc.isFailure()) { - ATH_MSG_FATAL( "Could not retrieve the Pixel ROT creator: "<< m_Pixel_ROTCreator ); - return sc; - } - - // Get the weightCalculator tool to calc the assignment probabilities - sc = m_WeightCalculator.retrieve(); - if (sc.isFailure()) { - ATH_MSG_FATAL( "Could not retrieve Tool for weight (assignment probability) calculation: "<< m_WeightCalculator ); - return sc; - } - // ------------- - // Get extrapolator - sc = m_extrapolator.retrieve(); - if (sc.isFailure()) { - ATH_MSG_FATAL( "Could not retrieve extrapolator: "<< m_extrapolator ); - return sc; - } - - return sc; -} - -/////////////////////////////////////////////////////////////////// -// Finalize -/////////////////////////////////////////////////////////////////// - -StatusCode InDet::CompetingPixelClustersOnTrackTool::finalize() { - StatusCode sc = AlgTool::finalize(); - return sc; -} - -/////////////////////////////////////////////////////////////////// -// InDet::CompetingPixelClustersOnTrack production -/////////////////////////////////////////////////////////////////// -const InDet::CompetingPixelClustersOnTrack* InDet::CompetingPixelClustersOnTrackTool::createCompetingROT( - const std::list< const Trk::PrepRawData* >& RIO_List, - const Trk::TrackParameters& trkPar, - const Trk::IWeightCalculator::AnnealingFactor beta ) const { - - const EventContext& ctx = Gaudi::Hive::currentContext(); - ATH_MSG_DEBUG("********* in createCompetingROT() ********** "); - // vector of ROTs - std::vector< const InDet::PixelClusterOnTrack* >* ROTvector = new std::vector<const InDet::PixelClusterOnTrack*>; - // vector of assignmentProbs - std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb > *assgnProbVector = new std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >; - // type of TRT_BaseElement to check if all RIOs are of same type - //InDetDD::TRT_BaseElement::Type* TRTtype = 0; - const Trk::Surface* detElementSurface = nullptr; - const Trk::TrackParameters* trkParAtRIOsurface = nullptr; - const Trk::TrackParameters* newTrackParameters = nullptr; - bool isBarrel = true; - // maxium assignment propability for choosing the surface.... - //Trk::CompetingRIOsOnTrack::AssignmentProb maximumAssignProb = 0; - //const InDet::PixelClusterOnTrack* ROTwithMaximumAssgnProb = 0; - - ATH_MSG_VERBOSE("trackSurfacePointer: " << &trkPar.associatedSurface() << " at (" - << trkPar.associatedSurface().center().x() << ", " - << trkPar.associatedSurface().center().y() << ", " - << trkPar.associatedSurface().center().z() << ")"); - // clone TrkParameters without error to force the extrapolator to do propagation without error matrix - const Trk::TrackParameters* trkParWithoutError = trkPar.clone(); - // ---------------------- - // loop over all given PrepRawData - std::list<const Trk::PrepRawData*>::const_iterator rioIter = RIO_List.begin(); - for (; rioIter!=RIO_List.end(); ++rioIter) { - // check if given pointer is not NULL - const InDet::PixelCluster* riopointer = dynamic_cast<const InDet::PixelCluster*>(*rioIter); - if (!riopointer) { - //ATH_MSG_WARNING("That's mean: given list of PrepRawData* contains a NULL pointer resp. not a PixelCluster!"); - ATH_MSG_WARNING("Given list of PrepRawData* contains a non PixelCluster!"); - ATH_MSG_WARNING("Entry will therefore be ignored!"); - continue; - } - // --------------------------------------------------- - // get trackParameters on the surface of the first RIO - if (!detElementSurface) { - // get surface of detector element of first RIO - detElementSurface = &(riopointer->detectorElement()->surface()); - isBarrel = riopointer->detectorElement()->isBarrel(); - // check if track parameters are expressed on the RIO surface - if ( (*detElementSurface)==((trkPar.associatedSurface())) ) { - // track parameters are given on the surface of the RIO, use them - ATH_MSG_VERBOSE("TrackParameters are on RIO surface: GP (" - << trkPar.position().x() << ", " - << trkPar.position().y() << ", " - << trkPar.position().z() << ") GM (" - << trkPar.momentum().x() << ", " - << trkPar.momentum().y() << ", " - << trkPar.momentum().z() << ") LP (" - << trkPar.localPosition()[Trk::distEta] << ", " - << trkPar.localPosition()[Trk::distPhi] << ")"); - trkParAtRIOsurface = &trkPar; - } else { - // first create trkParameter on the Surface of the RIO - // extrapolate to RIO surface - ATH_MSG_VERBOSE("Try to propagate TrackParameters to RIO surface"); - newTrackParameters = m_extrapolator->extrapolateDirectly(ctx, - (trkParWithoutError ? *trkParWithoutError : trkPar), *detElementSurface, - Trk::anyDirection, // propagate in any direction - false, //do noBoundaryCheck! - Trk::nonInteracting).release(); // without material interaction - if (!newTrackParameters){ - ATH_MSG_ERROR("TrackParameters could not be propagated to PrepRawData surface"); - delete ROTvector; - // FIXME: delete entries of ROT vector - delete assgnProbVector; - return nullptr; - } // end if (extrapolation failed) - // const Trk::AtaStraightLine* trkParAtRIOsurface1 = new Trk::AtaStraightLine(trkPar.position(), trkPar.momentum(), trkPar.charge(), *RIOsurfacePointer); - trkParAtRIOsurface = newTrackParameters; - ATH_MSG_VERBOSE("propagated TrackParameters on RIO surface: GP (" - << trkParAtRIOsurface->position().x() << ", " - << trkParAtRIOsurface->position().y() << ", " - << trkParAtRIOsurface->position().z() << ") GM (" - << trkParAtRIOsurface->momentum().x() << ", " - << trkParAtRIOsurface->momentum().y() << ", " - << trkParAtRIOsurface->momentum().z() << ") LP (" - << trkParAtRIOsurface->localPosition()[Trk::distEta] << ", " - << trkParAtRIOsurface->localPosition()[Trk::distPhi] << ")"); - } // end if (track parameters on RIO surface) - } // end if(!detElementSurface) - - // --------------------------------- - // check if all RIOs are on the same detector module: - if (riopointer->detectorElement()->surface() != (*detElementSurface)) { - ATH_MSG_WARNING("Given Pixel PrepRawData do not belong to the same detector element:"); - ATH_MSG_WARNING("Current entry of PrepRawData list will be ignored!!!"); - // Ignore current RIO and jump do next RIO - continue; - } - // --------------------------------- - // create ROT from PrepRawData: - const InDet::PixelClusterOnTrack* rot = dynamic_cast<const InDet::PixelClusterOnTrack*>( m_Pixel_ROTCreator->correct(*riopointer, *trkParAtRIOsurface)); - if (!rot) { - ATH_MSG_WARNING("PixelClusterOnTrack could not be created"); - } else { - //ATH_MSG_VERBOSE("Created ROT"); - // add ROT to vector of ROTs - ROTvector->push_back(rot); - // call weightcalculator and calc assignment probabilty: - ATH_MSG_VERBOSE("Call weight calculator for non-normalized assignment probability"); - Trk::CompetingRIOsOnTrack::AssignmentProb assgnProb = m_WeightCalculator->calculateWeight(*trkParAtRIOsurface, *rot, beta); - ATH_MSG_VERBOSE("Current ROT has assignment probability: " << assgnProb ); - assgnProbVector->push_back( assgnProb ); -// if (assgnProb >= maximumAssignProb) { -// ATH_MSG_VERBOSE("Current ROT has maximum assignment probabilty for now"); -// maximumAssignProb = assgnProb; -// ROTwithMaximumAssgnProb = rot; -// } - }// end else (!rot) - } // end for loop - delete newTrackParameters; - delete trkParWithoutError; - trkParWithoutError = nullptr; - - // ------------------------------------- - // test if at least one ROT was created: - if (ROTvector->empty()) { - ATH_MSG_ERROR("No valid PixelClusterOnTrack could be created:"); - ATH_MSG_ERROR("CompetingPixelClustersOnTrack creation aborted!"); - //clean-up - delete ROTvector; - delete assgnProbVector; - return nullptr; - } - ATH_MSG_DEBUG("List of competing Pixel ROTs contains "<< ROTvector->size() << " PixelClustersOnTrack"); - - // ----------------------------------- - // normalize assignment probabilities: - // copy ROTvector to base class vector (vector of RIO_OnTrack) because vector<> does not know inheritance structure - std::vector< const Trk::RIO_OnTrack* >* baseROTvector = new std::vector<const Trk::RIO_OnTrack*>; - std::vector< const InDet::PixelClusterOnTrack*>::const_iterator rotIter = ROTvector->begin(); - for (; rotIter!=ROTvector->end(); ++rotIter) { - baseROTvector->push_back(*rotIter); - } - // call normalize() - if (isBarrel) { - ATH_MSG_DEBUG("Call weight calculator for normalization now (Barrel cut)"); - m_WeightCalculator->normalize(*assgnProbVector, baseROTvector, beta, m_jo_BarrelCutValue); - } else { - ATH_MSG_DEBUG("Call weight calculator for normalization now (end-cap cut)"); - m_WeightCalculator->normalize(*assgnProbVector, baseROTvector, beta, m_jo_EndCapCutValue); - } - delete baseROTvector; - - // --------------------------------------- - // create CompetingPixelClustersOnTrack - //return (new CompetingPixelClustersOnTrack(assocSurface, ROTvector, assgnProbVector, effectiveLocalPar, effectiveErrMat, ROTsHaveCommonSurface)); - CompetingPixelClustersOnTrack* theCompetingROT = new CompetingPixelClustersOnTrack(ROTvector, assgnProbVector); - if (msgLvl(MSG::DEBUG)) testCompetingROT(*theCompetingROT); - return theCompetingROT; -} - - -/////////////////////////////////////////////////////////////////// -// InDet::CompetingPixelClustersOnTrack update -/////////////////////////////////////////////////////////////////// -void InDet::CompetingPixelClustersOnTrackTool::updateCompetingROT( - //const InDet::CompetingPixelClustersOnTrack& compROT, - Trk::CompetingRIOsOnTrack& baseCompROT, - const Trk::TrackParameters& trkPar, - const Trk::IWeightCalculator::AnnealingFactor beta - //const bool recreateROTs=false -) const { - - // TODO: if recreateROTs==true call standard createCompROT method - const EventContext& ctx = Gaudi::Hive::currentContext(); - ATH_MSG_DEBUG("********* in updateCompetingROT() **********"); - - // cast baseCompROT to CompPixelClusterOnTrack: - InDet::CompetingPixelClustersOnTrack* compROT = dynamic_cast< InDet::CompetingPixelClustersOnTrack* >(&baseCompROT); - if (!compROT) { - ATH_MSG_ERROR("Given CompetingRIOsOnTrack is not a CompetingPixelClustersOnTrack!"); - ATH_MSG_ERROR("Update of assignment probabilities aborted!!!"); - return; - } - // new vector of assignmentProbs - std::vector< InDet::CompetingPixelClustersOnTrack::AssignmentProb >* assgnProbVector = new std::vector< InDet::CompetingPixelClustersOnTrack::AssignmentProb >; - // maxium assignment propability to update the index - Trk::CompetingRIOsOnTrack::AssignmentProb maximumAssignProb = 0; - unsigned int maximumAssignProbIndex = 0; - - ATH_MSG_VERBOSE("trackSurfacePointer: " << trkPar.associatedSurface() << " at (" - << trkPar.associatedSurface().center().x() << ", " - << trkPar.associatedSurface().center().y() << ", " - << trkPar.associatedSurface().center().z() << ")"); - const Trk::TrackParameters* newTrackParameters = nullptr; - const Trk::TrackParameters* trkParAtROTsurface = nullptr; - // --------------------------------------------------- - // get trackParameters on the surface of the compROT - // check if track parameters are expressed on the compROT surface - if (compROT->associatedSurface()==((trkPar.associatedSurface())) ) { - // track parameters are given on the surface of the RIO, use them - ATH_MSG_VERBOSE("TrackParameters are on compROT surface: GP (" - << trkPar.position().x() << ", " - << trkPar.position().y() << ", " - << trkPar.position().z() << ") GM (" - << trkPar.momentum().x() << ", " - << trkPar.momentum().y() << ", " - << trkPar.momentum().z() << ") LP (" - << trkPar.localPosition()[Trk::distPhi] << ", " - << trkPar.localPosition()[Trk::distEta] << ")"); - trkParAtROTsurface = &trkPar; - } else { - // first create trkParameter on the Surface of the compROT - // extrapolate to compROT surface - // clone TrkParameters without error to force the extrapolator to do propagation without error matrix - const Trk::TrackParameters* trkParWithoutError = trkPar.clone(); - ATH_MSG_VERBOSE("Try to propagate TrackParameters to compROT surface"); - newTrackParameters = m_extrapolator->extrapolateDirectly(ctx, - (trkParWithoutError ? *trkParWithoutError : trkPar), compROT->associatedSurface(), - Trk::anyDirection, // propagate in any direction - false, //do noBoundaryCheck! - Trk::nonInteracting).release(); // without material interaction - delete trkParWithoutError; - trkParWithoutError = nullptr; - if (!newTrackParameters){ - ATH_MSG_ERROR("TrackParameters could not be propagated to compROT surface:"); - ATH_MSG_ERROR(" CompetingPixelClustersOnTrack could not be updated!"); - delete assgnProbVector; - return; - } // end if (extrapolation failed) - // const Trk::AtaStraightLine* trkParAtRIOsurface1 = new Trk::AtaStraightLine(trkPar.position(), trkPar.momentum(), trkPar.charge(), *RIOsurfacePointer); - trkParAtROTsurface = newTrackParameters; - ATH_MSG_VERBOSE("propagated TrackParameters on compROT surface: GP (" - << trkParAtROTsurface->position().x() << ", " - << trkParAtROTsurface->position().y() << ", " - << trkParAtROTsurface->position().z() << ") GM (" - << trkParAtROTsurface->momentum().x() << ", " - << trkParAtROTsurface->momentum().y() << ", " - << trkParAtROTsurface->momentum().z() << ") LP (" - << trkParAtROTsurface->localPosition()[Trk::distPhi] << ", " - << trkParAtROTsurface->localPosition()[Trk::distEta] << ")"); - } // end if (track parameters on compROT surface) - // ---------------------- - // loop over all ROTs in the CompetingROT - for (unsigned int i=0; i<compROT->numberOfContainedROTs(); i++) { - // call weightcalculator and calc assignment probabilty: - Trk::CompetingRIOsOnTrack::AssignmentProb assgnProb = m_WeightCalculator->calculateWeight(*trkParAtROTsurface, (compROT->rioOnTrack(i)), beta); - ATH_MSG_VERBOSE("non-normalized weight for ROT "<< i << ": " << assgnProb ); - assgnProbVector->push_back( assgnProb ); - if (assgnProb >= maximumAssignProb) { - ATH_MSG_VERBOSE("current ROT has maximum assignment probability up to now" ); - maximumAssignProb = assgnProb; - maximumAssignProbIndex = i; - //ROTwithMaximumAssgnProb = compROT->rioOnTrack(i); - } - } // end for loop - delete newTrackParameters; - if (maximumAssignProb > 0. ) { - // ----------------------------------- - // normalize assignment probabilities: - // copy ROTvector to base class vector (vector of RIO_OnTrack) because vector<> does not know inheritance structure - std::vector< const Trk::RIO_OnTrack* >* baseROTvector = new std::vector<const Trk::RIO_OnTrack*>; - std::vector< const InDet::PixelClusterOnTrack* >::const_iterator rotIter = compROT->containedROTs().begin(); - for (; rotIter!=compROT->containedROTs().end(); ++rotIter) { - baseROTvector->push_back(*rotIter); - } - // call normalize() - ATH_MSG_VERBOSE("normalize the assignment probabilities"); - if(compROT->rioOnTrack(0).detectorElement()->isBarrel()) { - ATH_MSG_DEBUG("Call weight calculator for normalization now (Barrel cut)"); - m_WeightCalculator->normalize(*assgnProbVector, baseROTvector, beta, m_jo_BarrelCutValue); - } else { - ATH_MSG_DEBUG("Call weight calculator for normalization now (end-cap cut)"); - m_WeightCalculator->normalize(*assgnProbVector, baseROTvector, beta, m_jo_EndCapCutValue); - } - delete baseROTvector; - } else { - ATH_MSG_VERBOSE("all ROTs have probability 0."); - maximumAssignProbIndex = 0; - } - // --------------------------------- - // update the competingROT - // set new assignment probabilities - delete compROT->m_assignProb; - compROT->m_assignProb = assgnProbVector; - // update maximum assign prob index: - compROT->m_indexMaxAssignProb = maximumAssignProbIndex; - // delete global position (will be recreated by the competingROT itself) - if (compROT->m_globalPosition) { - compROT->m_globalPosition.release().reset(); - } - compROT->setLocalParametersAndErrorMatrix(); - if (msgLvl(MSG::DEBUG)) testCompetingROT(*compROT); -} - -void InDet::CompetingPixelClustersOnTrackTool::reequipCompetingROT -(Trk::CompetingRIOsOnTrack*& modifiableCompROT, - const Trk::RIO_OnTrack* newROT, - const Trk::TrackParameters& trkPar, - const Trk::IWeightCalculator::AnnealingFactor beta, - const Trk::TrackState::MeasurementType ) const -{ - InDet::CompetingPixelClustersOnTrack* cpx - = dynamic_cast<InDet::CompetingPixelClustersOnTrack*>(modifiableCompROT); - const InDet::PixelClusterOnTrack* newCluster - = dynamic_cast<const InDet::PixelClusterOnTrack*>(newROT); - if (!cpx || !newCluster) { - ATH_MSG_WARNING( "inconsistent use of reequipCompetingROT() " ); - return; - } - std::vector<const InDet::PixelClusterOnTrack*>::const_iterator - rotIter = cpx->m_containedChildRots->begin(); - for (; rotIter!=cpx->m_containedChildRots->end(); ++rotIter) - delete (*rotIter); - delete cpx->m_containedChildRots; - cpx->m_containedChildRots = new std::vector<const InDet::PixelClusterOnTrack*>; - cpx->m_containedChildRots->push_back(newCluster); - - this->updateCompetingROT(*modifiableCompROT, trkPar, beta); -} - - - - -void InDet::CompetingPixelClustersOnTrackTool::testCompetingROT(const InDet::CompetingPixelClustersOnTrack& compROT)const { - - if (!msgLvl(MSG::VERBOSE)) return; - - ATH_MSG_VERBOSE("**Test**"); - - ATH_MSG_VERBOSE(" - associatedSurface(): "); - const Trk::Surface* assocsurface = &(compROT.associatedSurface()); - //ATH_MSG_VERBOSE(" distance of surface center from origin: " << assocsurface->center().distance()); - ATH_MSG_VERBOSE( assocsurface << " at ("<< assocsurface->center().x() << ", "<< assocsurface->center().y() << ", "<< assocsurface->center().z() << ")" ); - - ATH_MSG_VERBOSE(" - containedROTs(): "); - //ATH_MSG_VERBOSE(" size of ROT vector: " << compROT.containedROTs().size()); - ATH_MSG_VERBOSE(" numberOfContainedROTs(): " << compROT.numberOfContainedROTs()); - - ATH_MSG_VERBOSE(" - eff. localParameters():"); - //ATH_MSG_VERBOSE(" dimension of the effective local params: " << compROT.localParameters().dimension()); - ATH_MSG_VERBOSE(" dim: " << compROT.localParameters().dimension()); - //ATH_MSG_VERBOSE(" effective localPar[locX]: " << compROT.localParameters()[Trk::locX] ); - ATH_MSG_VERBOSE(" [locX]: " << compROT.localParameters()[Trk::locX] ); - - if (compROT.assignmentProbability(compROT.indexOfMaxAssignProb()) > 0. ) { - // if maxAssgnProb==0 the weight matrix is 0 and therefore singular => can not get covariance - ATH_MSG_VERBOSE(" - localErrorMatrix():"); - ATH_MSG_VERBOSE(" dimCov: " << compROT.localCovariance().rows()); - ATH_MSG_VERBOSE(" cov[loc1]: " << compROT.localCovariance()(Trk::loc1,Trk::loc1)); - } - - ATH_MSG_VERBOSE(" - indexOfMaxAssignProb(): " << compROT.indexOfMaxAssignProb() ); - //ATH_MSG_VERBOSE(" assignmentProbability( indexOfMaxAssignProb() ): " << compROT.assignmentProbability(compROT.indexOfMaxAssignProb()) ); - - ATH_MSG_VERBOSE(" - assignmentProbability(index) and rioOnTrack(index)"); - for (unsigned int i=0; i<compROT.numberOfContainedROTs(); i++) { - ATH_MSG_VERBOSE(" ["<< i <<"] assgnProb: "<< compROT.assignmentProbability(i) - << " ROT ID: "<< compROT.rioOnTrack(i).identify().getString() - << " [locX]: "<< compROT.rioOnTrack(i).localParameters()[Trk::locX] - << " ROT surf: "<< &(compROT.rioOnTrack(i).associatedSurface())); - if (compROT.assignmentProbability(i) > compROT.assignmentProbability(compROT.indexOfMaxAssignProb()) ) { - ATH_MSG_ERROR(" assignment probability larger than maximum assignment probability!!!"); - } - } - - - ATH_MSG_VERBOSE(" - eff. globalPosition(): "); - //ATH_MSG_VERBOSE(" distance of effective measurement from origin: " << compROT.globalPosition().distance()); - ATH_MSG_VERBOSE( " ("<< compROT.globalPosition().x() << ", "<< compROT.globalPosition().y() << ", "<< compROT.globalPosition().z() << ")" ); - /* ATH_MSG_VERBOSE(" - clone()"); - CompetingPixelClustersOnTrack* newcompROT = compROT.clone(); - if (!newcompROT){ - ATH_MSG_ERROR(" Got no clone!"); - } else { - ATH_MSG_VERBOSE(" Got the clone: do the same tests with it:"); - - ATH_MSG_VERBOSE(" clone- associatedSurface()"); - const Trk::Surface* cloneassocsurface = &(newcompROT->associatedSurface()); - ATH_MSG_VERBOSE(" distance of surface center from origin: " << cloneassocsurface->center().distance()); - - ATH_MSG_VERBOSE(" clone- containedROTs()"); - ATH_MSG_VERBOSE(" size of ROT vector: " << newcompROT->containedROTs().size()); - ATH_MSG_VERBOSE(" clone- numberOfContainedROTs(): " << newcompROT->numberOfContainedROTs()); - - ATH_MSG_VERBOSE(" clone- localParameters()"); - ATH_MSG_VERBOSE(" dimension of the effective local params: " << newcompROT->localParameters().dimension()); - - ATH_MSG_VERBOSE(" clone- localErrorMatrix()"); - ATH_MSG_VERBOSE(" dimension of covariance matrix: " << newcompROT->localErrorMatrix().covariance().num_row()); - ATH_MSG_VERBOSE(" error of first local coordinate: " << newcompROT->localErrorMatrix().error(Trk::loc1)); - ATH_MSG_VERBOSE(" weight value of first local coordinate: " << newcompROT->localErrorMatrix().weightValue(Trk::loc1)); - - ATH_MSG_VERBOSE(" clone- assignmentProbability(index) and rioOnTrack(index)"); - for (unsigned int i=0; i<newcompROT->numberOfContainedROTs(); i++) { - ATH_MSG_VERBOSE(" ["<< i <<"] assgnProb: "<< newcompROT->assignmentProbability(i)<< "ROT identifier:"<< newcompROT->rioOnTrack(i)->identify().getString() ); - } - - ATH_MSG_VERBOSE(" clone- globalPosition()"); - ATH_MSG_VERBOSE(" distance of effective measurement from origin: " << newcompROT->globalPosition().distance()); - } - delete newcompROT;*/ - -} - -StatusCode InDet::CompetingPixelClustersOnTrackTool::updateCompetingROTprobs( - Trk::CompetingRIOsOnTrack& baseCompROT, - const std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >& assignmentProbs - ) const { - InDet::CompetingPixelClustersOnTrack* compROT = dynamic_cast< InDet::CompetingPixelClustersOnTrack* >(&baseCompROT); - if (!compROT) { - ATH_MSG_ERROR("Given CompetingRIOsOnTrack is not a CompetingPixelClustersOnTrack!"); - ATH_MSG_ERROR("Update of assignment probabilities aborted!!!"); - return StatusCode::FAILURE; - } - if (assignmentProbs.size() != compROT->numberOfContainedROTs() ) { - ATH_MSG_ERROR("Given size of vector of assignment probabilities does not match number of contained ROTs in CompetingRIOsOnTrack!"); - ATH_MSG_ERROR("Update of assignment probabilities aborted!!!"); - return StatusCode::FAILURE; - } - // --------------------------------- - // update the competingROT - // set new assignment probabilities - delete compROT->m_assignProb; - std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >* assgnProbVector = new std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >(assignmentProbs); - // update maximum assign prob index: - double maximumAssignProb = 0.; - compROT->m_indexMaxAssignProb = 0; - for (unsigned int i=0; i<assignmentProbs.size(); i++) { - if (assignmentProbs[i] >= maximumAssignProb) { - //ATH_MSG_VERBOSE("current ROT has maximum assignment probability up to now" ); - maximumAssignProb = assignmentProbs[i]; - compROT->m_indexMaxAssignProb = i; - } - if (assignmentProbs[i] < 0.) { - ATH_MSG_WARNING("Got negative assignment probability, setting to 0 !"); - (*(assgnProbVector))[i] = 0.; - } - } // end for loop - compROT->m_assignProb = assgnProbVector; - // delete global position (will be recreated by the competingROT itself) - if (compROT->m_globalPosition) { - compROT->m_globalPosition.release().reset(); - } - // recalc localParameters - compROT->setLocalParametersAndErrorMatrix(); - - if (msgLvl(MSG::DEBUG)) testCompetingROT(*compROT); - return StatusCode::SUCCESS; -} diff --git a/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/src/CompetingSCT_ClustersOnTrackTool.cxx b/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/src/CompetingSCT_ClustersOnTrackTool.cxx deleted file mode 100755 index 287437d2ec6b..000000000000 --- a/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/src/CompetingSCT_ClustersOnTrackTool.cxx +++ /dev/null @@ -1,542 +0,0 @@ -/* - Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration -*/ - -/////////////////////////////////////////////////////////////////// -// Implementation file for class CompetingSCT_ClustersOnTrackTool -/////////////////////////////////////////////////////////////////// -// (c) ATLAS Detector software -/////////////////////////////////////////////////////////////////// -// Tool for CompetingSCT_ClustersOnTrack creation -/////////////////////////////////////////////////////////////////// -// sebastian.fleischmann@cern.ch -/////////////////////////////////////////////////////////////////// - -// Header -#include "InDetCompetingRIOsOnTrackTool/CompetingSCT_ClustersOnTrackTool.h" - -//#include "GaudiKernel/MsgStream.h" - -// data model -#include "TrkEventPrimitives/LocalParameters.h" -#include "InDetPrepRawData/SCT_Cluster.h" -#include "InDetCompetingRIOsOnTrack/CompetingSCT_ClustersOnTrack.h" -//#include "TrkParameters/AtaStraightLine.h" -//#include "TrkSurfaces/DiscSurface.h" -//#include "TrkSurfaces/StraightLineSurface.h" -//#include "TrkWeightCalculator/IWeightCalculator.h" -// interfaces -#include "TrkExInterfaces/IExtrapolator.h" -#include "TrkToolInterfaces/IRIO_OnTrackCreator.h" -#include "TrkToolInterfaces/IWeightCalculator.h" - -/////////////////////////////////////////////////////////////////// -// Constructor -/////////////////////////////////////////////////////////////////// - -InDet::CompetingSCT_ClustersOnTrackTool::CompetingSCT_ClustersOnTrackTool( - const std::string& ty, - const std::string& na, - const IInterface* pa ) : - AthAlgTool(ty,na,pa), - m_SCT__ROTCreator("InDet::SCT_ClusterOnTrackTool/SCT_ClusterOnTrackTool"), - m_WeightCalculator("Trk::DAF_SimpleWeightCalculator/DAF_WeightCalculator"), - m_extrapolator("Trk::Extrapolator/AtlasExtrapolator") -{ - declareInterface<ICompetingSCT_ClustersOnTrackCreator>(this); - declareInterface<ICompetingRIOsOnTrackTool>(this); - declareProperty("ToolForSCT_ClusterOnTrackCreation", m_SCT__ROTCreator, "SCT_ClusterOnTrackCreator needed for the creation of CompetingSCT_ClustersOnTrack"); - declareProperty("ToolForWeightCalculation", m_WeightCalculator, "Tool for weight (assignment probability) calculation"); - declareProperty("WeightCutValueBarrel", m_jo_BarrelCutValue=10.8275, "lambda parameter (intrinsic roadwidth) for measurements in the Barrel part"); - declareProperty("WeightCutValueEndCap", m_jo_EndCapCutValue=10.8275, "lambda parameter (intrinsic roadwidth) for measurements in the EndCap part"); - declareProperty("Extrapolator", m_extrapolator, "Extrapolator tool"); -} - -/////////////////////////////////////////////////////////////////// -// Destructor -/////////////////////////////////////////////////////////////////// - -InDet::CompetingSCT_ClustersOnTrackTool::~CompetingSCT_ClustersOnTrackTool() = default; - -/////////////////////////////////////////////////////////////////// -// Initialisation -/////////////////////////////////////////////////////////////////// - -StatusCode InDet::CompetingSCT_ClustersOnTrackTool::initialize() { - StatusCode sc = AlgTool::initialize(); - - ATH_MSG_INFO("SCT ROTCreation by : " << m_SCT__ROTCreator.name() ); - ATH_MSG_INFO("weight calculation by: " << m_WeightCalculator.name() ); - ATH_MSG_INFO("WeightCutValues are : " << m_jo_BarrelCutValue<< " (barrel) and " - << m_jo_EndCapCutValue<< " (end-cap)"); - - // Get the correction tool to create SCT_Clusters on Track - sc = m_SCT__ROTCreator.retrieve(); - if (sc.isFailure()) { - ATH_MSG_FATAL( "Could not retrieve the SCT ROT creator: "<< m_SCT__ROTCreator ); - return sc; - } - - // Get the weightCalculator tool to calc the assignment probabilities - sc = m_WeightCalculator.retrieve(); - if (sc.isFailure()) { - ATH_MSG_FATAL( "Could not retrieve Tool for weight (assignment probability) calculation: "<< m_WeightCalculator ); - return sc; - } - // Get extrapolator - sc = m_extrapolator.retrieve(); - if (sc.isFailure()) { - ATH_MSG_FATAL( "Could not retrieve extrapolator: "<< m_extrapolator ); - return sc; - } - - return sc; -} - -/////////////////////////////////////////////////////////////////// -// Finalize -/////////////////////////////////////////////////////////////////// - -StatusCode InDet::CompetingSCT_ClustersOnTrackTool::finalize() { - StatusCode sc = AlgTool::finalize(); - return sc; -} - -/////////////////////////////////////////////////////////////////// -// InDet::CompetingSCT_ClustersOnTrack production -/////////////////////////////////////////////////////////////////// -const InDet::CompetingSCT_ClustersOnTrack* InDet::CompetingSCT_ClustersOnTrackTool::createCompetingROT( - const std::list< const Trk::PrepRawData* >& RIO_List, - const Trk::TrackParameters& trkPar, - const Trk::IWeightCalculator::AnnealingFactor beta ) const { - - const EventContext& ctx = Gaudi::Hive::currentContext(); - ATH_MSG_DEBUG("********* in createCompetingROT() ********** "); - // vector of ROTs - std::vector< const InDet::SCT_ClusterOnTrack* > ROTvector; - // vector of assignmentProbs - auto assgnProbVector = std::make_unique<std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >>(); - // type of TRT_BaseElement to check if all RIOs are of same type - //InDetDD::TRT_BaseElement::Type* TRTtype = 0; - const Trk::Surface* detElementSurface = nullptr; - const Trk::TrackParameters* trkParAtRIOsurface = nullptr; - std::unique_ptr<const Trk::TrackParameters> newTrackParameters; - bool isBarrel = true; - // maxium assignment propability for choosing the surface.... - //Trk::CompetingRIOsOnTrack::AssignmentProb maximumAssignProb = 0; - //const InDet::SCT_ClusterOnTrack* ROTwithMaximumAssgnProb = 0; - - ATH_MSG_VERBOSE("trackSurfacePointer: " << trkPar.associatedSurface() << " at (" - << trkPar.associatedSurface().center().x() << ", " - << trkPar.associatedSurface().center().y() << ", " - << trkPar.associatedSurface().center().z() << ")"); - // ---------------------- - // loop over all given PrepRawData - for (const Trk::PrepRawData* rio : RIO_List) { - // check if given pointer is not nullptr - const InDet::SCT_Cluster* riopointer = dynamic_cast<const InDet::SCT_Cluster*>(rio); - if (!riopointer) { - //ATH_MSG_WARNING("That's mean: given list of PrepRawData* contains a nullptr resp. not a SCT_Cluster!"); - ATH_MSG_WARNING("Given list of PrepRawData* contains a non SCT_Cluster!"); - ATH_MSG_WARNING("Entry will therefore be ignored!"); - continue; - } - // --------------------------------------------------- - // get trackParameters on the surface of the first RIO - if (!detElementSurface) { - // get surface of detector element of first RIO - detElementSurface = &(riopointer->detectorElement()->surface()); - isBarrel = riopointer->detectorElement()->isBarrel(); - // check if track parameters are expressed on the RIO surface - if ( (*detElementSurface)==((trkPar.associatedSurface())) ) { - // track parameters are given on the surface of the RIO, use them - ATH_MSG_VERBOSE("TrackParameters are on RIO surface: GP (" - << trkPar.position().x() << ", " - << trkPar.position().y() << ", " - << trkPar.position().z() << ") GM (" - << trkPar.momentum().x() << ", " - << trkPar.momentum().y() << ", " - << trkPar.momentum().z() << ") LP (" - << trkPar.localPosition()[Trk::distEta] << ", " - << trkPar.localPosition()[Trk::distPhi] << ")"); - trkParAtRIOsurface = &trkPar; - } else { - // first create trkParameter on the Surface of the RIO - // clone TrkParameters without error to force the extrapolator to do propagation without error matrix - std::unique_ptr<const Trk::TrackParameters> trkParWithoutError{trkPar.clone()}; - // extrapolate to RIO surface - ATH_MSG_VERBOSE("Try to propagate TrackParameters to compROT surface"); - newTrackParameters = m_extrapolator->extrapolateDirectly( - ctx, - (trkParWithoutError ? *trkParWithoutError : trkPar), - *detElementSurface, - Trk::anyDirection, // propagate in any direction - false, // do noBoundaryCheck! - Trk::nonInteracting); // without material interaction - if (!newTrackParameters) { - ATH_MSG_ERROR("TrackParameters could not be propagated to " - "PrepRawData surface"); - return nullptr; - } // end if (extrapolation failed) - // const Trk::AtaStraightLine* trkParAtRIOsurface1 = new - // Trk::AtaStraightLine(trkPar.position(), trkPar.momentum(), - // trkPar.charge(), *RIOsurfacePointer); - trkParAtRIOsurface = newTrackParameters.get(); - ATH_MSG_VERBOSE("propagated TrackParameters on RIO surface: GP (" - << trkParAtRIOsurface->position().x() << ", " - << trkParAtRIOsurface->position().y() << ", " - << trkParAtRIOsurface->position().z() << ") GM (" - << trkParAtRIOsurface->momentum().x() << ", " - << trkParAtRIOsurface->momentum().y() << ", " - << trkParAtRIOsurface->momentum().z() << ") LP (" - << trkParAtRIOsurface->localPosition()[Trk::distEta] << ", " - << trkParAtRIOsurface->localPosition()[Trk::distPhi] << ")"); - } // end if (track parameters on RIO surface) - } // end if(!detElementSurface) - - // --------------------------------- - // check if all RIOs are on the same detector module: - if (riopointer->detectorElement()->surface() != (*detElementSurface)) { - ATH_MSG_WARNING("Given SCT_ PrepRawData do not belong to the same detector element:"); - ATH_MSG_WARNING("Current entry of PrepRawData list will be ignored!!!"); - // Ignore current RIO and jump do next RIO - continue; - } - // --------------------------------- - // create ROT from PrepRawData: - const InDet::SCT_ClusterOnTrack* rot = dynamic_cast<const InDet::SCT_ClusterOnTrack*>( m_SCT__ROTCreator->correct(*riopointer, *trkParAtRIOsurface)); - if (!rot) { - ATH_MSG_WARNING("SCT_ClusterOnTrack could not be created"); - } else { - //ATH_MSG_VERBOSE("Created ROT"); - // add ROT to vector of ROTs - ROTvector.push_back(rot); - // call weightcalculator and calc assignment probabilty: - ATH_MSG_VERBOSE("Call weight calculator for non-normalized assignment probability"); - Trk::CompetingRIOsOnTrack::AssignmentProb assgnProb = m_WeightCalculator->calculateWeight(*trkParAtRIOsurface, *rot, beta); - ATH_MSG_VERBOSE("Current ROT has assignment probability: " << assgnProb ); - assgnProbVector->push_back( assgnProb ); -// if (assgnProb >= maximumAssignProb) { -// ATH_MSG_VERBOSE("Current ROT has maximum assignment probabilty for now"); -// maximumAssignProb = assgnProb; -// ROTwithMaximumAssgnProb = rot; -// } - }// end else (!rot) - } // end for loop - - // ------------------------------------- - // test if at least one ROT was created: - if (ROTvector.empty()) { - ATH_MSG_ERROR("No valid SCT_ClusterOnTrack could be created:"); - ATH_MSG_ERROR("CompetingSCT_ClustersOnTrack creation aborted!"); - //clean-up - return nullptr; - } - ATH_MSG_DEBUG("List of competing SCT_ ROTs contains "<< ROTvector.size() << " SCT_ClustersOnTrack"); - - // ----------------------------------- - // normalize assignment probabilities: - // copy ROTvector to base class vector (vector of RIO_OnTrack) because vector<> does not know inheritance structure - std::vector< const Trk::RIO_OnTrack* > baseROTvector; - baseROTvector.reserve(ROTvector.size()); - -for (const InDet::SCT_ClusterOnTrack* rot : ROTvector) { - baseROTvector.push_back(rot); - } - // call normalize() - if (isBarrel) { - ATH_MSG_DEBUG("Call weight calculator for normalization now (Barrel cut)"); - m_WeightCalculator->normalize(*assgnProbVector, &baseROTvector, beta, m_jo_BarrelCutValue); - } else { - ATH_MSG_DEBUG("Call weight calculator for normalization now (end-cap cut)"); - m_WeightCalculator->normalize(*assgnProbVector, &baseROTvector, beta, m_jo_EndCapCutValue); - } - - // --------------------------------------- - // create CompetingSCT_ClustersOnTrack - //return (new CompetingSCT_ClustersOnTrack(assocSurface, ROTvector, assgnProbVector, effectiveLocalPar, effectiveErrMat, ROTsHaveCommonSurface)); - CompetingSCT_ClustersOnTrack* theCompetingROT = new CompetingSCT_ClustersOnTrack(std::move(ROTvector), assgnProbVector.release()); - if (msgLvl(MSG::VERBOSE)) testCompetingROT(*theCompetingROT); - return theCompetingROT; -} - - -/////////////////////////////////////////////////////////////////// -// InDet::CompetingSCT_ClustersOnTrack update -/////////////////////////////////////////////////////////////////// -void InDet::CompetingSCT_ClustersOnTrackTool::updateCompetingROT( - //const InDet::CompetingSCT_ClustersOnTrack& compROT, - Trk::CompetingRIOsOnTrack& baseCompROT, - const Trk::TrackParameters& trkPar, - const Trk::IWeightCalculator::AnnealingFactor beta - //const bool recreateROTs=false -) const { - - const EventContext& ctx = Gaudi::Hive::currentContext(); - // TODO: if recreateROTs==true call standard createCompROT method - - ATH_MSG_DEBUG("********* in updateCompetingROT() **********"); - - // cast baseCompROT to CompSCT_ClusterOnTrack: - InDet::CompetingSCT_ClustersOnTrack* compROT = dynamic_cast< InDet::CompetingSCT_ClustersOnTrack* >(&baseCompROT); - if (!compROT) { - ATH_MSG_WARNING("Given CompetingRIOsOnTrack is not a CompetingSCT_ClustersOnTrack!"); - ATH_MSG_WARNING("Update of assignment probabilities aborted!!!"); - return; - } - // new vector of assignmentProbs - auto assgnProbVector = std::make_unique<std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >>(); - // maxium assignment propability to update the index - Trk::CompetingRIOsOnTrack::AssignmentProb maximumAssignProb = 0; - unsigned int maximumAssignProbIndex = 0; - - ATH_MSG_VERBOSE("trackSurfacePointer: " << trkPar.associatedSurface() << " at (" - << trkPar.associatedSurface().center().x() << ", " - << trkPar.associatedSurface().center().y() << ", " - << trkPar.associatedSurface().center().z() << ")"); - std::unique_ptr<const Trk::TrackParameters> newTrackParameters; - const Trk::TrackParameters* trkParAtROTsurface = nullptr; - // --------------------------------------------------- - // get trackParameters on the surface of the compROT - // check if track parameters are expressed on the compROT surface - if (compROT->associatedSurface()==((trkPar.associatedSurface())) ) { - // track parameters are given on the surface of the RIO, use them - ATH_MSG_VERBOSE("TrackParameters are on compROT surface: GP (" - << trkPar.position().x() << ", " - << trkPar.position().y() << ", " - << trkPar.position().z() << ") GM (" - << trkPar.momentum().x() << ", " - << trkPar.momentum().y() << ", " - << trkPar.momentum().z() << ") LP (" - << trkPar.localPosition()[Trk::distPhi] << ", " - << trkPar.localPosition()[Trk::distEta] << ")"); - trkParAtROTsurface = &trkPar; - } else { - // first create trkParameter on the Surface of the compROT - // clone TrkParameters without error to force the extrapolator to do propagation without error matrix - std::unique_ptr<const Trk::TrackParameters> trkParWithoutError{trkPar.clone()}; - ATH_MSG_VERBOSE("Try to propagate TrackParameters to compROT surface"); - newTrackParameters = m_extrapolator->extrapolateDirectly( - ctx, - (trkParWithoutError ? *trkParWithoutError : trkPar), - compROT->associatedSurface(), - Trk::anyDirection, // propagate in any direction - false, // do noBoundaryCheck! - Trk::nonInteracting); // without material interaction - if (!newTrackParameters){ - ATH_MSG_ERROR("TrackParameters could not be propagated to compROT surface:"); - ATH_MSG_ERROR(" CompetingSCT_ClustersOnTrack could not be updated!"); - return; - } // end if (extrapolation failed) - // const Trk::AtaStraightLine* trkParAtRIOsurface1 = new Trk::AtaStraightLine(trkPar.position(), trkPar.momentum(), trkPar.charge(), *RIOsurfacePointer); - trkParAtROTsurface = newTrackParameters.get(); - ATH_MSG_VERBOSE("propagated TrackParameters on compROT surface: GP (" - << trkParAtROTsurface->position().x() << ", " - << trkParAtROTsurface->position().y() << ", " - << trkParAtROTsurface->position().z() << ") GM (" - << trkParAtROTsurface->momentum().x() << ", " - << trkParAtROTsurface->momentum().y() << ", " - << trkParAtROTsurface->momentum().z() << ") LP (" - << trkParAtROTsurface->localPosition()[Trk::distPhi] << ", " - << trkParAtROTsurface->localPosition()[Trk::distEta] << ")"); - } // end if (track parameters on compROT surface) - // ---------------------- - // loop over all ROTs in the CompetingROT - for (unsigned int i=0; i<compROT->numberOfContainedROTs(); i++) { - // call weightcalculator and calc assignment probabilty: - Trk::CompetingRIOsOnTrack::AssignmentProb assgnProb = m_WeightCalculator->calculateWeight(*trkParAtROTsurface, (compROT->rioOnTrack(i)), beta); - ATH_MSG_VERBOSE("non-normalized weight for ROT "<< i << ": " << assgnProb ); - assgnProbVector->push_back( assgnProb ); - if (assgnProb >= maximumAssignProb) { - ATH_MSG_VERBOSE("current ROT has maximum assignment probability up to now" ); - maximumAssignProb = assgnProb; - maximumAssignProbIndex = i; - } - } // end for loop - if (maximumAssignProb > 0. ) { - // ----------------------------------- - // normalize assignment probabilities: - // copy ROTvector to base class vector (vector of RIO_OnTrack) because vector<> does not know inheritance structure - std::vector< const Trk::RIO_OnTrack* > baseROTvector; - for (const InDet::SCT_ClusterOnTrack* rot : compROT->containedROTs()) { - baseROTvector.push_back(rot); - } - // call normalize() - ATH_MSG_VERBOSE("normalize the assignment probabilities"); - if(compROT->rioOnTrack(0).detectorElement()->isBarrel()) { - ATH_MSG_DEBUG("Call weight calculator for normalization now (Barrel cut)"); - m_WeightCalculator->normalize(*assgnProbVector, &baseROTvector, beta, m_jo_BarrelCutValue); - } else { - ATH_MSG_DEBUG("Call weight calculator for normalization now (end-cap cut)"); - m_WeightCalculator->normalize(*assgnProbVector, &baseROTvector, beta, m_jo_EndCapCutValue); - } - } else { - ATH_MSG_VERBOSE("all ROTs have probability 0."); - maximumAssignProbIndex = 0; - } - // --------------------------------- - // update the competingROT - // set new assignment probabilities - delete compROT->m_assignProb; - compROT->m_assignProb = assgnProbVector.release(); - // update maximum assign prob index: - compROT->m_indexMaxAssignProb = maximumAssignProbIndex; - // delete global position (will be recreated by the competingROT itself) - if (compROT->m_globalPosition) { - compROT->m_globalPosition.release().reset(); - } - // delete localParameters - compROT->setLocalParametersAndErrorMatrix(); - if (msgLvl(MSG::VERBOSE)) testCompetingROT(*compROT); -} - -void InDet::CompetingSCT_ClustersOnTrackTool::reequipCompetingROT -(Trk::CompetingRIOsOnTrack*& modifiableCompROT, - const Trk::RIO_OnTrack* newROT, - const Trk::TrackParameters& trkPar, - const Trk::IWeightCalculator::AnnealingFactor beta, - const Trk::TrackState::MeasurementType ) const -{ - - InDet::CompetingSCT_ClustersOnTrack* cst - = dynamic_cast<InDet::CompetingSCT_ClustersOnTrack*>(modifiableCompROT); - const InDet::SCT_ClusterOnTrack* newCluster - = dynamic_cast<const InDet::SCT_ClusterOnTrack*>(newROT); - if (!cst || !newCluster) { - ATH_MSG_WARNING( "inconsistent use of reequipCompetingROT() " ); - return; - } - for (const InDet::SCT_ClusterOnTrack* rot : cst->m_containedChildRots) delete rot; - cst->m_containedChildRots.clear(); - cst->m_containedChildRots.push_back(newCluster); - - this->updateCompetingROT(*modifiableCompROT, trkPar, beta); -} - - -void InDet::CompetingSCT_ClustersOnTrackTool::testCompetingROT(const InDet::CompetingSCT_ClustersOnTrack& compROT)const { - - if (!msgLvl(MSG::VERBOSE)) return; - - msg(MSG::VERBOSE)<<"**Test**"<<endmsg; - - msg()<<" - associatedSurface(): "; - const Trk::Surface* assocsurface = &(compROT.associatedSurface()); - //msg(MSG::VERBOSE)<<" distance of surface center from origin: " << assocsurface->center().distance()<<endmsg; - msg()<< assocsurface << " at ("<< assocsurface->center().x() << ", "<< assocsurface->center().y() << ", "<< assocsurface->center().z() << ")" <<endmsg; - - msg()<<" - containedROTs(): "; - //msg()<<" size of ROT vector: " << compROT.containedROTs().size()<<endmsg; - msg()<<" numberOfContainedROTs(): " << compROT.numberOfContainedROTs()<<endmsg; - - msg()<<" - eff. localParameters():"; - //msg()<<" dimension of the effective local params: " << compROT.localParameters().dimension()<<endmsg; - msg()<<" dim: " << compROT.localParameters().dimension(); - //msg()<<" effective localPar[locX]: " << compROT.localParameters()[Trk::locX] <<endmsg; - msg()<<" [locX]: " << compROT.localParameters()[Trk::locX] <<endmsg; - - if (compROT.assignmentProbability(compROT.indexOfMaxAssignProb()) > 0. ) { - // if maxAssgnProb==0 the weight matrix is 0 and therefore singular => can not get covariance - msg()<<" - localErrorMatrix():"; - msg()<<" dimCov: " << compROT.localCovariance().rows(); - msg()<<" cov[loc1]: " << compROT.localCovariance()(Trk::loc1,Trk::loc1) << endmsg; - } - - msg()<<" - indexOfMaxAssignProb(): " << compROT.indexOfMaxAssignProb() <<endmsg; - //msg()<<" assignmentProbability( indexOfMaxAssignProb() ): " << compROT.assignmentProbability(compROT.indexOfMaxAssignProb()) <<endmsg; - - msg()<<" - assignmentProbability(index) and rioOnTrack(index)"<<endmsg; - for (unsigned int i=0; i<compROT.numberOfContainedROTs(); i++) { - msg()<<" ["<< i <<"] assgnProb: "<< compROT.assignmentProbability(i) - << " ROT ID: "<< compROT.rioOnTrack(i).identify().getString() - << " [locX]: "<< compROT.rioOnTrack(i).localParameters()[Trk::locX] - << " ROT surf: "<< &(compROT.rioOnTrack(i).associatedSurface()) - << endmsg; - if (compROT.assignmentProbability(i) > compROT.assignmentProbability(compROT.indexOfMaxAssignProb()) ) { - ATH_MSG_ERROR(" assignment probability larger than maximum assignment probability!!!"); - } - } - - - msg()<<" - eff. globalPosition(): "; - //msg()<<" distance of effective measurement from origin: " << compROT.globalPosition().distance()<<endmsg; - msg()<< " ("<< compROT.globalPosition().x() << ", "<< compROT.globalPosition().y() << ", "<< compROT.globalPosition().z() << ")" <<endmsg; - /* msg()<<" - clone()"<<endmsg; - CompetingSCT_ClustersOnTrack* newcompROT = compROT.clone(); - if (!newcompROT){ - m_log<<MSG::ERROR<<" Got no clone!"<<endmsg; - } else { - msg()<<" Got the clone: do the same tests with it:"<<endmsg; - - msg()<<" clone- associatedSurface()"<<endmsg; - const Trk::Surface* cloneassocsurface = &(newcompROT->associatedSurface()); - msg()<<" distance of surface center from origin: " << cloneassocsurface->center().distance()<<endmsg; - - msg()<<" clone- containedROTs()"<<endmsg; - msg()<<" size of ROT vector: " << newcompROT->containedROTs().size()<<endmsg; - msg()<<" clone- numberOfContainedROTs(): " << newcompROT->numberOfContainedROTs()<<endmsg; - - msg()<<" clone- localParameters()"<<endmsg; - msg()<<" dimension of the effective local params: " << newcompROT->localParameters().dimension()<<endmsg; - - msg()<<" clone- localErrorMatrix()"<<endmsg; - msg()<<" dimension of covariance matrix: " << newcompROT->localErrorMatrix().covariance().num_row()<<endmsg; - msg()<<" error of first local coordinate: " << newcompROT->localErrorMatrix().error(Trk::loc1)<<endmsg; - msg()<<" weight value of first local coordinate: " << newcompROT->localErrorMatrix().weightValue(Trk::loc1)<<endmsg; - - msg()<<" clone- assignmentProbability(index) and rioOnTrack(index)"<<endmsg; - for (unsigned int i=0; i<newcompROT->numberOfContainedROTs(); i++) { - msg()<<" ["<< i <<"] assgnProb: "<< newcompROT->assignmentProbability(i)<< "ROT identifier:"<< newcompROT->rioOnTrack(i)->identify().getString() <<endmsg; - } - - msg()<<" clone- globalPosition()"<<endmsg; - msg()<<" distance of effective measurement from origin: " << newcompROT->globalPosition().distance()<<endmsg; - } - delete newcompROT;*/ - -} - -StatusCode InDet::CompetingSCT_ClustersOnTrackTool::updateCompetingROTprobs( - Trk::CompetingRIOsOnTrack& baseCompROT, - const std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >& assignmentProbs - ) const { - InDet::CompetingSCT_ClustersOnTrack* compROT = dynamic_cast< InDet::CompetingSCT_ClustersOnTrack* >(&baseCompROT); - if (!compROT) { - ATH_MSG_ERROR("Given CompetingRIOsOnTrack is not a CompetingPixelClustersOnTrack!"); - ATH_MSG_ERROR("Update of assignment probabilities aborted!!!"); - return StatusCode::FAILURE; - } - if (assignmentProbs.size() != compROT->numberOfContainedROTs() ) { - ATH_MSG_ERROR("Given size of vector of assignment probabilities does not match number of contained ROTs in CompetingRIOsOnTrack!"); - ATH_MSG_ERROR("Update of assignment probabilities aborted!!!"); - return StatusCode::FAILURE; - } - // --------------------------------- - // update the competingROT - // set new assignment probabilities - delete compROT->m_assignProb; - auto assgnProbVector = std::make_unique<std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >>(); - // update maximum assign prob index: - double maximumAssignProb = 0.; - compROT->m_indexMaxAssignProb = 0; - for (unsigned int i=0; i<assignmentProbs.size(); i++) { - if (assignmentProbs[i] >= maximumAssignProb) { - //ATH_MSG_VERBOSE("current ROT has maximum assignment probability up to now" ); - maximumAssignProb = assignmentProbs[i]; - compROT->m_indexMaxAssignProb = i; - } - if (assignmentProbs[i] < 0.) { - ATH_MSG_WARNING("Got negative assignment probability, setting to 0 !"); - (*(assgnProbVector))[i] = 0.; - } - } // end for loop - compROT->m_assignProb = assgnProbVector.release(); - // delete global position (will be recreated by the competingROT itself) - if (compROT->m_globalPosition) { - compROT->m_globalPosition.release().reset(); - } - // recalc localParameters - compROT->setLocalParametersAndErrorMatrix(); - if (msgLvl(MSG::DEBUG)) testCompetingROT(*compROT); - return StatusCode::SUCCESS; -} diff --git a/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/src/CompetingTRT_DriftCirclesOnTrackTool.cxx b/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/src/CompetingTRT_DriftCirclesOnTrackTool.cxx deleted file mode 100755 index fc0ab74995a4..000000000000 --- a/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/src/CompetingTRT_DriftCirclesOnTrackTool.cxx +++ /dev/null @@ -1,1140 +0,0 @@ -/* - Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration -*/ - -/////////////////////////////////////////////////////////////////// -// Implementation file for class CompetingTRT_DriftCirclesOnTrackTool -/////////////////////////////////////////////////////////////////// -// (c) ATLAS Detector software -/////////////////////////////////////////////////////////////////// -// Tool for CompetingTRT_DriftCirclesOnTrack creation -/////////////////////////////////////////////////////////////////// -// sebastian.fleischmann@cern.ch -/////////////////////////////////////////////////////////////////// - -// Header -#include "InDetCompetingRIOsOnTrackTool/CompetingTRT_DriftCirclesOnTrackTool.h" - -// data model -#include "TrkEventPrimitives/LocalParameters.h" -#include "TrkSurfaces/DiscSurface.h" -#include "TrkSurfaces/StraightLineSurface.h" -#include "TrkSurfaces/CylinderBounds.h" -#include "InDetPrepRawData/TRT_DriftCircle.h" -#include "InDetCompetingRIOsOnTrack/CompetingTRT_DriftCirclesOnTrack.h" - -// -#include <cmath> - -/////////////////////////////////////////////////////////////////// -// Constructor -/////////////////////////////////////////////////////////////////// - -InDet::CompetingTRT_DriftCirclesOnTrackTool::CompetingTRT_DriftCirclesOnTrackTool( - const std::string& ty, - const std::string& na, - const IInterface* pa ) : - AthAlgTool(ty,na,pa) -{ - declareInterface<ICompetingTRT_DriftCirclesOnTrackCreator>(this); - declareInterface<ICompetingRIOsOnTrackTool>(this); - declareProperty("WeightCutValueBarrel", m_jo_BarrelCutValue=6.66, "lambda parameter (intrinsic roadwidth) for measurements in the Barrel part"); - declareProperty("WeightCutValueEndCap", m_jo_EndCapCutValue=6.66, "lambda parameter (intrinsic roadwidth) for measurements in the EndCap part"); -} - -/////////////////////////////////////////////////////////////////// -// Destructor -/////////////////////////////////////////////////////////////////// - -InDet::CompetingTRT_DriftCirclesOnTrackTool::~CompetingTRT_DriftCirclesOnTrackTool() = default; - -/////////////////////////////////////////////////////////////////// -// Initialisation -/////////////////////////////////////////////////////////////////// - -StatusCode InDet::CompetingTRT_DriftCirclesOnTrackTool::initialize() { - StatusCode sc = AlgTool::initialize(); - - ATH_MSG_DEBUG("WeightCutValueBarrel: " << m_jo_BarrelCutValue); - ATH_MSG_DEBUG("WeightCutValueEndCap: " << m_jo_EndCapCutValue); - - // Get the correction tool to create TRT_DriftCircles on Track - sc = m_TRT_ROTCreator.retrieve(); - if (sc.isFailure()) { - ATH_MSG_FATAL( "Could not retrieve the TRT ROT creator: "<< m_TRT_ROTCreator ); - return sc; - } - - // Get the weightCalculator tool to calc the assignment probabilities - sc = m_weightCalculator.retrieve(); - if (sc.isFailure()) { - ATH_MSG_FATAL( "Could not retrieve Tool for weight (assignment probability) calculation: "<< m_weightCalculator ); - return sc; - } - // ------------- - // Get extrapolator - sc = m_extrapolator.retrieve(); - if (sc.isFailure()) { - ATH_MSG_FATAL( "Could not retrieve extrapolator: "<< m_extrapolator ); - return sc; - } - return sc; -} - -/////////////////////////////////////////////////////////////////// -// Finalize -/////////////////////////////////////////////////////////////////// - -StatusCode InDet::CompetingTRT_DriftCirclesOnTrackTool::finalize() { - StatusCode sc = AlgTool::finalize(); - return sc; -} - -/////////////////////////////////////////////////////////////////// -// InDet::CompetingTRT_DriftCirclesOnTrack production -/////////////////////////////////////////////////////////////////// -const InDet::CompetingTRT_DriftCirclesOnTrack* InDet::CompetingTRT_DriftCirclesOnTrackTool::createCompetingROT( - const std::list< const Trk::PrepRawData* >& RIO_List, - const Trk::TrackParameters& trkPar, - const Trk::IWeightCalculator::AnnealingFactor beta ) const { - - const EventContext& ctx = Gaudi::Hive::currentContext(); - ATH_MSG_DEBUG("********* in createCompetingROT() ********** "); - // get trkPar error in localZ for locZ cut - double trkParErrorLocZ = 2.; - if (trkPar.covariance()) { - trkParErrorLocZ = std::sqrt((*trkPar.covariance())(Trk::locZ,Trk::locZ)); - } - // vector of ROTs - std::vector< const InDet::TRT_DriftCircleOnTrack* >* ROTvector = new std::vector<const InDet::TRT_DriftCircleOnTrack*>; - // vector of assignmentProbs - std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb > *assgnProbVector = new std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >; - // type of TRT_BaseElement to check if all RIOs are of same type - InDetDD::TRT_BaseElement::Type TRTtype = InDetDD::TRT_BaseElement::BARREL; - bool TRTtypeSet = false; - // maxium assignment propability for choosing the surface.... - Trk::CompetingRIOsOnTrack::AssignmentProb maximumAssignProb = 0; - const InDet::TRT_DriftCircleOnTrack* ROTwithMaximumAssgnProb = nullptr; - - ATH_MSG_VERBOSE("trackSurfacePointer: " << &trkPar.associatedSurface() << " at (" - << trkPar.associatedSurface().center().x() << ", " - << trkPar.associatedSurface().center().y() << ", " - << trkPar.associatedSurface().center().z() << ")"); - // clone TrkParameters without error to force the extrapolator to do propagation without error matrix - const Trk::TrackParameters* trkParWithoutError = trkPar.clone(); - // ---------------------- - // loop over all given PrepRawData - std::list<const Trk::PrepRawData*>::const_iterator rioIter = RIO_List.begin(); - for (; rioIter!=RIO_List.end(); ++rioIter) { - // check if given pointer is not NULL - const InDet::TRT_DriftCircle* riopointer = dynamic_cast<const InDet::TRT_DriftCircle*>(*rioIter); - if (!riopointer) { - //ATH_MSG_WARNING("That's mean: given list of PrepRawData* contains a NULL pointer resp. not a TRT_DriftCircle!"); - ATH_MSG_WARNING("Given list of PrepRawData* contains a non TRT_DriftCircle!"); - ATH_MSG_WARNING("Entry will therefore be ignored!"); - } else { - ATH_MSG_VERBOSE("Got next RIO in list"); - // --------------------------------- - // check if all RIOs are of the same detector type: - if (!TRTtypeSet) { - TRTtype = riopointer->detectorElement()->type(); - TRTtypeSet = true; - } - if (riopointer->detectorElement()->type() != TRTtype) { - ATH_MSG_WARNING("Given TRT PrepRawData do not have all the same detector type (Barrel resp. End-Cap):"); - ATH_MSG_WARNING("Current entry of PrepRawData list will be ignored!!!"); - // Ignore current RIO and jump do next RIO - continue; - } - // --------------------------------- - // create two ROTs from PrepRawData (left and right solution): - - // get RIO surface - const Trk::Surface* RIOsurface = &(riopointer->detectorElement()->surface(riopointer->identify())); - const Trk::StraightLineSurface* RIOsurfacePointer = dynamic_cast< const Trk::StraightLineSurface* > (RIOsurface); - - if (!RIOsurfacePointer) { - ATH_MSG_WARNING("RIO has no StraightLineSurface: TRT_DriftCircleOnTrack can not be created"); - } else { - //ATH_MSG_VERBOSE("Got StraightLineSurface from RIO"); - ATH_MSG_VERBOSE("RIOsurfacePointer: " << RIOsurfacePointer << " at (" - << RIOsurfacePointer->center().x() << ", " - << RIOsurfacePointer->center().y() << ", " - << RIOsurfacePointer->center().z() << ")"); - // ----------------- - // create first ROT: - // check if track parameters are expressed on the RIO surface - const Trk::TrackParameters* trkParAtRIOsurface = nullptr; - const Trk::TrackParameters* newTrackParameters = nullptr; - if ( (*RIOsurface)==((trkPar.associatedSurface())) ) { - // track parameters are given on the surface of the RIO, use them - ATH_MSG_VERBOSE("TrackParameters are on RIO surface: GP (" - << trkPar.position().x() << ", " - << trkPar.position().y() << ", " - << trkPar.position().z() << ") GM (" - << trkPar.momentum().x() << ", " - << trkPar.momentum().y() << ", " - << trkPar.momentum().z() << ") LP (" - << trkPar.localPosition()[Trk::driftRadius] << ", " - << trkPar.localPosition()[Trk::locZ] << ")"); - trkParAtRIOsurface = &trkPar; - } else { - // first create trkParameter on the Surface of the RIO - // extrapolate to RIO surface - ATH_MSG_VERBOSE("Try to propagate TrackParameters to RIO surface"); - newTrackParameters = m_extrapolator->extrapolateDirectly(ctx, - (trkParWithoutError ? *trkParWithoutError : trkPar), *RIOsurfacePointer, - Trk::anyDirection, // propagate in any direction - false, //do noBoundaryCheck! - Trk::noHypothesis).release(); // without material interaction - if (!newTrackParameters){ - ATH_MSG_ERROR("TrackParameters could not be propagated to PrepRawData surface"); - delete ROTvector; - delete assgnProbVector; - return nullptr; - } // end if (extrapolation failed) - trkParAtRIOsurface = newTrackParameters; - ATH_MSG_VERBOSE("propagated TrackParameters on RIO surface: GP (" - << trkParAtRIOsurface->position().x() << ", " - << trkParAtRIOsurface->position().y() << ", " - << trkParAtRIOsurface->position().z() << ") GM (" - << trkParAtRIOsurface->momentum().x() << ", " - << trkParAtRIOsurface->momentum().y() << ", " - << trkParAtRIOsurface->momentum().z() << ") LP (" - << trkParAtRIOsurface->localPosition()[Trk::driftRadius] << ", " - << trkParAtRIOsurface->localPosition()[Trk::locZ] << ")"); - } // end if (track parameters on RIO surface) - // test if track prediction is out of local z range of the drift tube - bool outOfZbounds = false; - const Trk::CylinderBounds& cylBounds = dynamic_cast<const Trk::CylinderBounds&>(RIOsurfacePointer->bounds()); - ATH_MSG_VERBOSE( "TRT surface bounds (r, Z): (" << cylBounds.r() << ", " << cylBounds.halflengthZ() << ")" ); - if ( std::abs(trkParAtRIOsurface->localPosition()[Trk::locZ]) > cylBounds.halflengthZ() ) { - ATH_MSG_VERBOSE( "out of locZ bounds, trkParErrorLocZ="<<trkParErrorLocZ ); - if ( std::abs(trkParAtRIOsurface->localPosition()[Trk::locZ]) > cylBounds.halflengthZ() + 4.*trkParErrorLocZ ) { - ATH_MSG_VERBOSE( "set assign prob to 0." ); - outOfZbounds = true; - } - } - // now create ROT - const InDet::TRT_DriftCircleOnTrack* rot1 = dynamic_cast<const InDet::TRT_DriftCircleOnTrack*>( m_TRT_ROTCreator->correct(*riopointer, *trkParAtRIOsurface)); - if (!rot1) { - ATH_MSG_WARNING("first TRT_DriftCircleOnTrack could not be created"); - } else { - ATH_MSG_VERBOSE("Created first ROT"); - // add ROT to vector of ROTs - ROTvector->push_back(rot1); - // call weightcalculator and calc assignment probabilty: - ATH_MSG_VERBOSE("Call weight calculator for non-normalized assignment probability"); - Trk::CompetingRIOsOnTrack::AssignmentProb assgnProb1 = m_weightCalculator->calculateWeight(*trkParAtRIOsurface, *rot1, beta); - ATH_MSG_VERBOSE("Current ROT has assignment probability: " << assgnProb1 ); - if (outOfZbounds) assgnProb1 = 0.; - assgnProbVector->push_back( assgnProb1 ); - if (assgnProb1 >= maximumAssignProb) { - ATH_MSG_VERBOSE("Current ROT has maximum assignment probabilty for now"); - maximumAssignProb = assgnProb1; - ROTwithMaximumAssgnProb = rot1; - } - }// end else (!rot1) - - // ------------------ - // create second ROT: - // first create mirrored trkParameter on the Surface of the RIO - Amg::VectorX par = trkParAtRIOsurface->parameters(); - par[Trk::locR] = (-1.0) * par[Trk::locR]; - std::optional<AmgSymMatrix(5)> covN = - trkParAtRIOsurface->covariance() - ? std::optional<AmgSymMatrix(5)>(*trkParAtRIOsurface->covariance()) - : std::nullopt; - auto mirrorTrkPar = - trkParAtRIOsurface->associatedSurface() - .createUniqueTrackParameters(par[Trk::loc1], - par[Trk::loc2], - par[Trk::phi], - par[Trk::theta], - par[Trk::qOverP], - std::move(covN)); - // now create ROT - const InDet::TRT_DriftCircleOnTrack* rot2 = dynamic_cast<const InDet::TRT_DriftCircleOnTrack*>(m_TRT_ROTCreator->correct(*riopointer, *mirrorTrkPar)); - if (!rot2) { - ATH_MSG_WARNING("second TRT_DriftCircleOnTrack could not be created"); - } else { - ATH_MSG_VERBOSE("Created second ROT"); - // add ROT to vector of ROTs - ROTvector->push_back(rot2); - // call weightcalculator and calc assignment probabilty: - // using trkParAtRIOsurface is not a bug (the other is mirrored parameter)!!! - Trk::CompetingRIOsOnTrack::AssignmentProb assgnProb2 = m_weightCalculator->calculateWeight(*trkParAtRIOsurface, *rot2, beta); - ATH_MSG_VERBOSE("Current ROT has assignment probability: " << assgnProb2 ); - if (outOfZbounds) assgnProb2 = 0.; - assgnProbVector->push_back( assgnProb2 ); - if (assgnProb2 >= maximumAssignProb) { - ATH_MSG_VERBOSE("Current ROT has maximum assignment probabilty for now"); - maximumAssignProb = assgnProb2; - ROTwithMaximumAssgnProb = rot2; - } - }// end else (!rot2) - delete newTrackParameters; - }// end else (!RIOsurfacePointer) - } // end else (!riopointer) - } // end for loop - - delete trkParWithoutError; - trkParWithoutError = nullptr; - - // ------------------------------------- - // test if at least one ROT was created: - if (ROTvector->empty()) { - ATH_MSG_ERROR("No valid TRT_DriftCircleOnTrack could be created:"); - ATH_MSG_ERROR("CompetingTRT_DriftCirclesOnTrack creation aborted!"); - //clean-up - delete ROTvector; - delete assgnProbVector; - return nullptr; - } - ATH_MSG_DEBUG("List of competing TRT ROTs contains "<< ROTvector->size() << " TRT_DriftCirclesOnTrack"); - - // ----------------------------------- - // normalize assignment probabilities: - // copy ROTvector to base class vector (vector of RIO_OnTrack) because vector<> does not know inheritance structure - std::vector< const Trk::RIO_OnTrack* >* baseROTvector = new std::vector<const Trk::RIO_OnTrack*>; - std::vector< const InDet::TRT_DriftCircleOnTrack*>::const_iterator rotIter = ROTvector->begin(); - for (; rotIter!=ROTvector->end(); ++rotIter) { - baseROTvector->push_back(*rotIter); - } - // call normalize() - if(TRTtype == InDetDD::TRT_BaseElement::BARREL) { - ATH_MSG_DEBUG("Call weight calculator for normalization now (Barrel cut)"); - m_weightCalculator->normalize(*assgnProbVector, baseROTvector, beta, m_jo_BarrelCutValue); - } else { - ATH_MSG_DEBUG("Call weight calculator for normalization now (end-cap cut)"); - m_weightCalculator->normalize(*assgnProbVector, baseROTvector, beta, m_jo_EndCapCutValue); - } - delete baseROTvector; - baseROTvector=nullptr; - - if (!ROTwithMaximumAssgnProb) { - ATH_MSG_ERROR("No RIO_OnTrack with maximum assignment probability!"); - //clean-up - delete ROTvector; - delete assgnProbVector; - return nullptr; - } - // --------------------------------- - // check if ROTs have common surface - ATH_MSG_VERBOSE("Check if ROTs have a common surface"); - bool nonVanishingROTsHaveCommonSurface=true; - bool allROTsHaveCommonSurface=true; - for (unsigned int i=0; i<ROTvector->size(); i++) { - if (ROTvector->operator[](i)->associatedSurface() != ROTwithMaximumAssgnProb->associatedSurface()) { - allROTsHaveCommonSurface = false; - if (TRTtype == InDetDD::TRT_BaseElement::BARREL) { - if ( (assgnProbVector->operator[](i)) > 0. ) { - nonVanishingROTsHaveCommonSurface=false; - } - } else { - // in the endcaps we ignore negligible assignment probs to use a single tube as soon as possible - // (avoids the ugly transform to polar-coordinates) - if ( (assgnProbVector->operator[](i)) > 1.e-5 ) { - nonVanishingROTsHaveCommonSurface=false; - } else { - // assgn prob is negligble, set it to zero: - (assgnProbVector->operator[](i)) = 0.; - ATH_MSG_VERBOSE("In endcap: assgn prob on second best straw is negligble, set to "<<(assgnProbVector->operator[](i))); - } - } - } - } - // values of int ROTsHaveCommonSurface: - // no yes NA (ROTs on a common surface) NA means not checked yet - // 0 1 2 - // for all | just ROTs with non-vanishing assgnProb - // * 1 | * 3 - int ROTsHaveCommonSurface = 0; - if (allROTsHaveCommonSurface) { - ROTsHaveCommonSurface = 1; - ATH_MSG_DEBUG("all ROTs have a common surface"); - } - if (nonVanishingROTsHaveCommonSurface) { - ROTsHaveCommonSurface += 3; - ATH_MSG_DEBUG("and non-vanishing ROTs have a common surface"); - } - // ---------------------------------- - // calculate effective measurement: - // TRT barrel and TRT end-cap differ - std::unique_ptr<const Trk::LocalParameters> effectiveLocalPar = nullptr; - std::unique_ptr<const Amg::MatrixX> effectiveErrMat = nullptr; - const Trk::Surface* assocSurface = nullptr; - if(TRTtype == InDetDD::TRT_BaseElement::BARREL) { - //calculation of effective measurements for Barrel-TRT - // surface of the trkPar does not matter for standard calc - assocSurface = &(ROTwithMaximumAssgnProb->associatedSurface()); - ATH_MSG_DEBUG("CompetingROT is in Barrel part"); - calcEffectiveMeasurement(effectiveLocalPar, - effectiveErrMat, - ROTvector, - assgnProbVector, - &trkPar, - assocSurface, - nonVanishingROTsHaveCommonSurface); - - } else { - //calculation of effective measurements for EndCap-TRT - ATH_MSG_DEBUG("CompetingROT is in end-cap part"); - if (nonVanishingROTsHaveCommonSurface) { - // use standard calculation if just one straw is in the competition - // surface of the trkPar does not matter for standard calc - ATH_MSG_DEBUG(" but all non-vanishing ROTs have the same surface: use standard calc"); - assocSurface = &(ROTwithMaximumAssgnProb->associatedSurface()); - calcEffectiveMeasurement(effectiveLocalPar, - effectiveErrMat, - ROTvector, - assgnProbVector, - &trkPar, - assocSurface, - nonVanishingROTsHaveCommonSurface); - } else { - // use DiscSurface as the common one - assocSurface = - &(ROTwithMaximumAssgnProb->detectorElement()->surface()); - // get LocR of trkPar on this surface - // this is not the optimal way, but should be sufficient if trkPar is - // given on one of the straws. The LocR of trkPar has not such a great - // influence and the last iterations where just one straw remains in - // competition are done on this StraightLineSurface anyway - // TODO: check how this can be done in a better way - std::optional<Amg::Vector2D> localTrkPar = - assocSurface->globalToLocal( - trkPar.position(), - 10.); // use rather huge tolerance because z-coord does not matter - if (!localTrkPar) { - ATH_MSG_ERROR("Could not get TrackParameters on DiscSurface:"); - ATH_MSG_ERROR("CompetingTRT_DriftCirclesOnTrack creation aborted!"); - // clean-up - delete ROTvector; - delete assgnProbVector; - return nullptr; - } - ATH_MSG_DEBUG("estimated TrackParametres on DiscSurface: (" - << (*localTrkPar)[Trk::locR] << "," - << (*localTrkPar)[Trk::locPhi] << ")"); - - // delete discpar; - calcEffectiveEndCapMeasurement(effectiveLocalPar, - effectiveErrMat, - ROTvector, - assgnProbVector, - *localTrkPar, - assocSurface); - } - } - - if (!effectiveLocalPar) { - ATH_MSG_ERROR("Could not produce effective localParameters"); - //clean-up - delete ROTvector; - delete assgnProbVector; - return nullptr; - } - if (!effectiveErrMat) { - ATH_MSG_ERROR("Could not produce effective ErrorMatrix"); - //clean-up - delete ROTvector; - delete assgnProbVector; - return nullptr; - } - - // --------------------------------------- - // create CompetingTRT_DriftCirclesOnTrack - //return (new CompetingTRT_DriftCirclesOnTrack(assocSurface, ROTvector, assgnProbVector, effectiveLocalPar, effectiveErrMat, ROTsHaveCommonSurface)); - CompetingTRT_DriftCirclesOnTrack* theCompetingROT = - new CompetingTRT_DriftCirclesOnTrack(assocSurface, - ROTvector, - assgnProbVector, - *effectiveLocalPar, - *effectiveErrMat, - ROTsHaveCommonSurface); - if (msgLvl(MSG::VERBOSE)){ - testCompetingROT(*theCompetingROT); - } - return theCompetingROT; -} - - -/////////////////////////////////////////////////////////////////// -// InDet::CompetingTRT_DriftCirclesOnTrack update -/////////////////////////////////////////////////////////////////// -void InDet::CompetingTRT_DriftCirclesOnTrackTool::updateCompetingROT( - //const InDet::CompetingTRT_DriftCirclesOnTrack& compROT, - Trk::CompetingRIOsOnTrack& baseCompROT, - const Trk::TrackParameters& trkPar, - const Trk::IWeightCalculator::AnnealingFactor beta - //const bool recreateROTs=false -) const { - - const EventContext& ctx = Gaudi::Hive::currentContext(); - // TODO: if recreateROTs==true call standard createCompROT method - - ATH_MSG_DEBUG("********* in updateCompetingROT() **********"); - // get trkPar error in localZ for locZ cut - double trkParErrorLocZ = 2.; - if (trkPar.covariance()) { - trkParErrorLocZ = std::sqrt( (*trkPar.covariance())(Trk::locZ,Trk::locZ)); - } - - // cast baseCompROT to CompTRT_DConTrack: - - InDet::CompetingTRT_DriftCirclesOnTrack* compROT = dynamic_cast< InDet::CompetingTRT_DriftCirclesOnTrack* >(&baseCompROT); - if (!compROT) { - ATH_MSG_ERROR("Given CompetingRIOsOnTrack is not a CompetingTRT_DriftCirclesOnTrack!"); - ATH_MSG_ERROR("Update of assignment probabilities aborted!!!"); - return; - } - std::vector< InDet::CompetingTRT_DriftCirclesOnTrack::AssignmentProb >* assgnProbVector - = new std::vector< InDet::CompetingTRT_DriftCirclesOnTrack::AssignmentProb >; - // get maxium assignment propability for choosing the surface.... - Trk::CompetingRIOsOnTrack::AssignmentProb maximumAssignProb = 0; - unsigned int maximumAssignProbIndex = 0; - const InDet::TRT_DriftCircleOnTrack* ROTwithMaximumAssgnProb = nullptr; - - // clone TrkParameters without error to force the extrapolator to do propagation without error matrix - const Trk::TrackParameters* trkParWithoutError = trkPar.clone(); - - // ---------------------- - // loop over all ROTs in the CompetingROT - ATH_MSG_VERBOSE("trackSurfacePointer: " << trkPar.associatedSurface() << " at (" - << trkPar.associatedSurface().center().x() << ", " - << trkPar.associatedSurface().center().y() << ", " - << trkPar.associatedSurface().center().z() << ")"); - ATH_MSG_VERBOSE("loop over ROTs:"); - const Trk::TrackParameters* newTrackParameters = nullptr; - for (unsigned int i=0; i<compROT->numberOfContainedROTs(); i++) { - const Trk::StraightLineSurface* ROTsurfacePointer = dynamic_cast< const Trk::StraightLineSurface* > (&(compROT->rioOnTrack(i).associatedSurface())); - if (!ROTsurfacePointer) throw std::logic_error("Unhandled surface."); - ATH_MSG_VERBOSE("ROTsurfacePointer: " << ROTsurfacePointer << " at (" - << ROTsurfacePointer->center().x() << ", " - << ROTsurfacePointer->center().y() << ", " - << ROTsurfacePointer->center().z() << ")"); - // check if track parameters are expressed on the RIO surface - const Trk::TrackParameters* trkParAtROTsurface = nullptr; - if ( (*ROTsurfacePointer)==((trkPar.associatedSurface())) ) { - // track parameters are given on the surface of the ROT, use them - ATH_MSG_VERBOSE("TrackParameters are on ROT surface: GP (" - << trkPar.position().x() << ", " - << trkPar.position().y() << ", " - << trkPar.position().z() << ") GM (" - << trkPar.momentum().x() << ", " - << trkPar.momentum().y() << ", " - << trkPar.momentum().z() << ") LP (" - << trkPar.localPosition()[Trk::driftRadius] << ", " - << trkPar.localPosition()[Trk::locZ] << ")"); - trkParAtROTsurface = &trkPar; - } else { - // check if we already created track parameters on the surface of the ROT - if (newTrackParameters) { - if ( (*ROTsurfacePointer)==((newTrackParameters->associatedSurface())) ) { - // track parameters are given on the surface of the ROT, use them - trkParAtROTsurface = newTrackParameters; - } // end if already created trackParameters on the ROT surface - } // end if (newTrackParameters) - } // end if (TrackParameters on ROT surface exist) - if (!trkParAtROTsurface) { - // first create trkParameter on the Surface of the ROT - // extrapolate to ROT surface - ATH_MSG_VERBOSE("Try to propagate TrackParameters to ROT surface"); - ATH_MSG_VERBOSE("Try to propagate TrackParameters to RIO surface"); - delete newTrackParameters; - newTrackParameters = m_extrapolator->extrapolateDirectly(ctx, - (trkParWithoutError ? *trkParWithoutError : trkPar), *ROTsurfacePointer, - Trk::anyDirection, // propagate in any direction - //Trk::alongMomentum, // propagate in any direction - false, //do noBoundaryCheck! - Trk::noHypothesis).release(); // without material interaction - if (!newTrackParameters){ - ATH_MSG_ERROR("TrackParameters could not be propagated to RIO_OnTrack surface"); - delete assgnProbVector; - return; - } // end if (extrapolation failed) - // const Trk::AtaStraightLine* trkParAtRIOsurface1 = new Trk::AtaStraightLine(trkPar.position(), trkPar.momentum(), trkPar.charge(), *RIOsurfacePointer); - trkParAtROTsurface = newTrackParameters; - ATH_MSG_VERBOSE("propagated TrackParameters on ROT surface: GP (" - << trkParAtROTsurface->position().x() << ", " - << trkParAtROTsurface->position().y() << ", " - << trkParAtROTsurface->position().z() << ") GM (" - << trkParAtROTsurface->momentum().x() << ", " - << trkParAtROTsurface->momentum().y() << ", " - << trkParAtROTsurface->momentum().z() << ") LP (" - << trkParAtROTsurface->localPosition()[Trk::driftRadius] << ", " - << trkParAtROTsurface->localPosition()[Trk::locZ] << ")"); - } // end if (!trkParAtROTsurface) - - // call weightcalculator and calc assignment probabilty: - Trk::CompetingRIOsOnTrack::AssignmentProb assgnProb = m_weightCalculator->calculateWeight(*trkParAtROTsurface, (compROT->rioOnTrack(i)), beta); - ATH_MSG_VERBOSE("non-normalized weight for ROT "<< i << ": " << assgnProb ); - - // test if track prediction is out of local z range of the drift tube - const Trk::CylinderBounds& cylBounds = dynamic_cast<const Trk::CylinderBounds&>(ROTsurfacePointer->bounds()); - ATH_MSG_VERBOSE( "TRT surface bounds (r, Z): (" << cylBounds.r() << ", " << cylBounds.halflengthZ() << ")" ); - if ( std::abs(trkParAtROTsurface->localPosition()[Trk::locZ]) > cylBounds.halflengthZ() ) { - ATH_MSG_VERBOSE( "out of locZ bounds, trkParErrorLocZ="<<trkParErrorLocZ ); - if ( std::abs(trkParAtROTsurface->localPosition()[Trk::locZ]) > cylBounds.halflengthZ() + 4.*trkParErrorLocZ ) { - ATH_MSG_VERBOSE( "set assign prob to 0." ); - assgnProb = 0.; - } - } - - - assgnProbVector->push_back( assgnProb ); - if (assgnProb >= maximumAssignProb) { - ATH_MSG_VERBOSE("current ROT has maximum assignment probability up to now" ); - maximumAssignProb = assgnProb; - maximumAssignProbIndex = i; - ROTwithMaximumAssgnProb = &compROT->rioOnTrack(i); - } - } // end for loop - delete newTrackParameters; - newTrackParameters = nullptr; - - delete trkParWithoutError; - trkParWithoutError = nullptr; - - if (maximumAssignProb > 0. ) { - // ----------------------------------- - // normalize assignment probabilities: - // copy ROTvector to base class vector (vector of RIO_OnTrack) because vector<> does not know inheritance structure - std::vector< const Trk::RIO_OnTrack* >* baseROTvector = new std::vector<const Trk::RIO_OnTrack*>; - std::vector< const InDet::TRT_DriftCircleOnTrack* >::const_iterator rotIter = compROT->containedROTs().begin(); - for (; rotIter!=compROT->containedROTs().end(); ++rotIter) { - baseROTvector->push_back(*rotIter); - } - // call normalize() - ATH_MSG_VERBOSE("normalize the assignment probabilities"); - if(compROT->rioOnTrack(0).detectorElement()->type() == InDetDD::TRT_BaseElement::BARREL) { - ATH_MSG_DEBUG("Call weight calculator for normalization now (Barrel cut)"); - m_weightCalculator->normalize(*assgnProbVector, baseROTvector, beta, m_jo_BarrelCutValue); - } else { - ATH_MSG_DEBUG("Call weight calculator for normalization now (end-cap cut)"); - m_weightCalculator->normalize(*assgnProbVector, baseROTvector, beta, m_jo_EndCapCutValue); - } - delete baseROTvector; - } else { - ATH_MSG_VERBOSE("all ROTs have probability 0."); - ROTwithMaximumAssgnProb = &compROT->rioOnTrack(0); // to avoid segfaults when asking for the surface - maximumAssignProbIndex = 0; - } - // --------------------------------- - // set pointer in compROT to the new assgnProbVector - delete compROT->m_assignProb; - compROT->m_assignProb = assgnProbVector; - - bool isBarrel = (compROT->rioOnTrack(0).detectorElement()->type() == InDetDD::TRT_BaseElement::BARREL); - // --------------------------------- - // check if ROTs have common surface - if (!ROTwithMaximumAssgnProb) { - ATH_MSG_ERROR("No RIO_OnTrack with maximum assignment probability!"); - delete assgnProbVector; - return; - } - - bool nonVanishingROTsHaveCommonSurface=true; - bool allROTsHaveCommonSurface=true; - for (unsigned int i=0; i<compROT->numberOfContainedROTs(); i++) { - if (compROT->rioOnTrack(i).associatedSurface() != ROTwithMaximumAssgnProb->associatedSurface()) { - allROTsHaveCommonSurface = false; - if (isBarrel) { - if ( (assgnProbVector->operator[](i)) > 0. ) { - nonVanishingROTsHaveCommonSurface=false; - } - } else { - // in the endcaps we ignore negligible assignment probs to use a single tube as soon as possible - // (avoids the ugly transform to polar-coordinates) - if ( (assgnProbVector->operator[](i)) > 1.e-5 ) { - nonVanishingROTsHaveCommonSurface=false; - } else { - // assgn prob is negligble, set it to zero: - (assgnProbVector->operator[](i)) = 0.; - ATH_MSG_VERBOSE("In endcap: assgn prob on second best straw is negligble, set to "<<compROT->assignmentProbability(i)); - } - } - } - } - // values of int ROTsHaveCommonSurface: - // no yes NA (ROTs on a common surface) NA means not checked yet - // 0 1 2 - // for all | just ROTs with non-vanishing assgnProb - // * 1 | * 3 - int ROTsHaveCommonSurface = 0; - if (allROTsHaveCommonSurface) { - ROTsHaveCommonSurface = 1; - ATH_MSG_DEBUG("all ROTs have a common surface"); - } - if (nonVanishingROTsHaveCommonSurface) { - ROTsHaveCommonSurface += 3; - ATH_MSG_DEBUG("non-vanishing ROTs have a common surface"); - } - - // update m_ROTsHaveCommonSurface in compROT - compROT->m_ROTsHaveCommonSurface = ROTsHaveCommonSurface; - // ---------------------------------- - // calculate effective measurement: - // TRT barrel and TRT end-cap differ - std::unique_ptr<const Trk::LocalParameters> effectiveLocalPar = nullptr; - std::unique_ptr<const Amg::MatrixX> effectiveErrMat = nullptr; - const Trk::Surface* assocSurface = nullptr; - if(isBarrel) { - //calculation of effective measurements for Barrel-TRT - // surface of the trkPar does not matter for standard calc - assocSurface = &(ROTwithMaximumAssgnProb->associatedSurface()); - calcEffectiveMeasurement(effectiveLocalPar, - effectiveErrMat, - &(compROT->containedROTs()), - assgnProbVector, - &trkPar, - assocSurface, - nonVanishingROTsHaveCommonSurface); - - } else { - //calculation of effective measurements for EndCap-TRT - if (nonVanishingROTsHaveCommonSurface) { - // use standard calculation if just one straw is in the competition - // surface of the trkPar does not matter for standard calc - assocSurface = &(ROTwithMaximumAssgnProb->associatedSurface()); - calcEffectiveMeasurement(effectiveLocalPar, - effectiveErrMat, - &(compROT->containedROTs()), - assgnProbVector, - &trkPar, - assocSurface, - nonVanishingROTsHaveCommonSurface); - } else { - // use DiscSurface as the common one - assocSurface = - &(ROTwithMaximumAssgnProb->detectorElement()->surface()); - // get LocR of trkPar on this surface - // this is not the optimal way, but should be sufficient if trkPar is - // given on one of the straws. The LocR of trkPar has not such a great - // influence and the last iterations where just one straw remains in - // competition are done on this StraightLineSurface anyway - // TODO: check how this can be done in a better way - std::optional<Amg::Vector2D> localTrkPar = - assocSurface->globalToLocal( - trkPar.position(), - 10.); // use rather huge tolerance because z-coord does not matter - if (!localTrkPar) { - ATH_MSG_ERROR("Could not get TrackParameters on DiscSurface:"); - ATH_MSG_ERROR("CompetingTRT_DriftCirclesOnTrack update aborted!"); - // FIXME: delete everything - return; - } - ATH_MSG_DEBUG("estimated TrackParametres on DiscSurface: (" - << (*localTrkPar)[Trk::locR] << "," - << (*localTrkPar)[Trk::locPhi] << ")"); - calcEffectiveEndCapMeasurement(effectiveLocalPar, - effectiveErrMat, - &(compROT->containedROTs()), - assgnProbVector, - *localTrkPar, - assocSurface); - } // end else (nonVanishingROTsHaveCommonSurface) - } // end TRT end-cap - - // update compROT: - // update maximum assign prob index: - compROT->m_indexMaxAssignProb = maximumAssignProbIndex; - // update surface - if (!compROT->m_associatedSurface->associatedDetectorElement()) - delete compROT->m_associatedSurface; - compROT->m_associatedSurface=assocSurface; - // delete global position (will be recreated in competingROT itself - if (compROT->m_globalPosition) { - compROT->m_globalPosition.release().reset(); - } - // have to set the effective measurement and error matrix directly: - compROT->m_localParams = (*effectiveLocalPar); - compROT->m_localCovariance = (*effectiveErrMat); - if (msgLvl(MSG::VERBOSE)) { - testCompetingROT(*compROT); - } -} - - -///////////////////////////////////////////////////////////////////// -// create simple competing ROTs (one tube, two left-right ROTs -///////////////////////////////////////////////////////////////////// -const Trk::CompetingRIOsOnTrack* -InDet::CompetingTRT_DriftCirclesOnTrackTool::createSimpleCompetingROT( - const Trk::PrepRawData& rio, - const Trk::TrackParameters& trkPars, - const Trk::IWeightCalculator::AnnealingFactor beta, - const Trk::TrackState::MeasurementType) const { - - // --- ID-or-MS check for tube-detectors - const Trk::Surface* PrdSf = &(rio.detectorElement()->surface(rio.identify())); - const Trk::StraightLineSurface* DriftSurface = - dynamic_cast< const Trk::StraightLineSurface* > (PrdSf); - if (!DriftSurface || PrdSf != &trkPars.associatedSurface()) { - ATH_MSG_WARNING( "detector hit is not of type drift circle!" ); - return nullptr; - } - if (PrdSf->center().perp()>1500. || PrdSf->center().z() > 3000.) { - ATH_MSG_WARNING( "input PRD is in the enemy's territory, wrong detector" ); - return nullptr; - } - - // --- make first ROT (the L/R solution nearest to prediction) and vectors - const Trk::RIO_OnTrack* rot1 = m_TRT_ROTCreator->correct(rio, trkPars); - if (!rot1) { - ATH_MSG_WARNING( "first and only DriftCircleOnTrack could not be created."); - return nullptr; - } - auto ROTvector = std::make_unique<std::vector<const Trk::RIO_OnTrack*>>(); - auto assgnProbVector = - std::make_unique<std::vector<Trk::CompetingRIOsOnTrack::AssignmentProb>>(); - ROTvector->push_back(rot1); - Trk::CompetingRIOsOnTrack::AssignmentProb assgnProb1 = - m_weightCalculator->calculateWeight(trkPars, *rot1, beta); - assgnProbVector->push_back( assgnProb1 ); - ATH_MSG_VERBOSE("Created first ROT with r=" - << rot1->localParameters()[Trk::locX] <<" and ass.prob = " - << assgnProb1); - - // --- create mirrored ROT, but protect against case where DC creators return a wire/tube hit. - if (std::abs(rot1->localParameters()[Trk::locX]) > 0.001) { - - Amg::VectorX par = trkPars.parameters(); - ATH_MSG_VERBOSE("track prediction at " << par[Trk::locR]); - par[Trk::locR] = (-1.0) * par[Trk::locR]; - std::optional<AmgSymMatrix(5)> covN = - trkPars.covariance() - ? std::optional<AmgSymMatrix(5)>(*trkPars.covariance()) - : std::nullopt; - auto mirrorTrkPar = - trkPars.associatedSurface().createUniqueTrackParameters(par[Trk::loc1], - par[Trk::loc2], - par[Trk::phi], - par[Trk::theta], - par[Trk::qOverP], - std::move(covN)); - const Trk::RIO_OnTrack* rot2 = m_TRT_ROTCreator->correct(rio,*mirrorTrkPar); - if (!rot2) { - ATH_MSG_DEBUG("2nd DriftCircleOnTrack is not created"); - } else { - ATH_MSG_VERBOSE("Created second ROT with r=" << rot2->localParameters()[Trk::locX]); - // add ROT to vector of ROTs - ROTvector->push_back(rot2); - // call weightcalculator and calc assignment probabilty: - Trk::CompetingRIOsOnTrack::AssignmentProb assgnProb2 = - m_weightCalculator->calculateWeight(trkPars, *rot2, beta); // must be trkPars, not mirror - ATH_MSG_VERBOSE("Current ROT has assignment probability: " << assgnProb2 ); - assgnProbVector->push_back( assgnProb2 ); - if (assgnProb2 >= assgnProb1) { - ATH_MSG_VERBOSE("Current ROT has maximum assignment probabilty for now"); - } - } // end else (!rot2) - } - - // --- call normalize() - double thisWeightCut = (std::abs(trkPars.position().z())>800.0 ? - m_jo_EndCapCutValue : m_jo_BarrelCutValue ); - m_weightCalculator->normalize(*assgnProbVector, ROTvector.get(), beta, thisWeightCut); - - double meanWeight = assgnProbVector->at(0) /std::sqrt( ROTvector->at(0)->localCovariance()(Trk::locX,Trk::locX)); - double meanDriftR = meanWeight * ROTvector->at(0)->localParameters()[Trk::locX]; - if (ROTvector->size()==2) { - double addWeight = assgnProbVector->at(1) / std::sqrt( ROTvector->at(1)->localCovariance()(Trk::locX,Trk::locX)); - meanDriftR += addWeight * ROTvector->at(1)->localParameters()[Trk::locX]; - meanWeight += addWeight; - } - if (meanWeight<=1.0e-12) { - meanWeight = 1.0e-10; - ATH_MSG_DEBUG("mean weight 0, rescale to: " << meanWeight ); - } - Amg::MatrixX meanCovMatrix(1,1); - meanCovMatrix(0,0) = 1./meanWeight; - meanDriftR = meanCovMatrix(Trk::locX,Trk::locX) * meanDriftR; - Trk::DefinedParameter radiusPar(meanDriftR,Trk::locX); - Trk::LocalParameters effectiveLocalPar(radiusPar); - ATH_MSG_VERBOSE("filling rot with lPar,err = " << effectiveLocalPar <<" and "<< meanCovMatrix); - - // --- create final CompetingTRT_DriftCirclesOnTrack - std::vector< const InDet::TRT_DriftCircleOnTrack* >* DCvector = - new std::vector<const InDet::TRT_DriftCircleOnTrack*>; - const InDet::TRT_DriftCircleOnTrack* dc1 = dynamic_cast<const InDet::TRT_DriftCircleOnTrack*> - ( ROTvector->at(0)); - if (!dc1) { - delete DCvector; - throw std::logic_error("Not a TRT_DriftCircleOnTrack"); - } - DCvector->push_back(dc1); - if (ROTvector->size() > 1) { - const InDet::TRT_DriftCircleOnTrack* dc2 - = dynamic_cast<const InDet::TRT_DriftCircleOnTrack*>( ROTvector->at(1)); - if (!dc2) { - delete DCvector; - throw std::logic_error("Not a TRT_DriftCircleOnTrack"); - } - DCvector->push_back(dc2); - } - InDet::CompetingTRT_DriftCirclesOnTrack* theCompetingROT = - new InDet::CompetingTRT_DriftCirclesOnTrack( - PrdSf, - DCvector, - assgnProbVector.release(), - effectiveLocalPar, - meanCovMatrix, - 4 /* 4 = common surface*/); - return theCompetingROT; -} - - -///////////////////////////////////////////////////////////////////// -// put new (e.g. broad-error) ROT into existing CompROT and run update -///////////////////////////////////////////////////////////////////// -void InDet::CompetingTRT_DriftCirclesOnTrackTool::reequipCompetingROT -(Trk::CompetingRIOsOnTrack*& modifiableCompROT, - const Trk::RIO_OnTrack* newROT, - const Trk::TrackParameters& trkPar, - const Trk::IWeightCalculator::AnnealingFactor beta, - const Trk::TrackState::MeasurementType ) const -{ - InDet::CompetingTRT_DriftCirclesOnTrack* ctt - = dynamic_cast<InDet::CompetingTRT_DriftCirclesOnTrack*>(modifiableCompROT); - const InDet::TRT_DriftCircleOnTrack* newStraw - = dynamic_cast<const InDet::TRT_DriftCircleOnTrack*>(newROT); - if (!ctt || !newStraw) { - ATH_MSG_WARNING( "inconsistent use of reequipCompetingROT() " ); - return; - } - std::vector<const InDet::TRT_DriftCircleOnTrack*>::const_iterator - rotIter = ctt->m_containedChildRots->begin(); - for (; rotIter!=ctt->m_containedChildRots->end(); ++rotIter) - delete (*rotIter); - delete ctt->m_containedChildRots; - ctt->m_containedChildRots = new std::vector<const InDet::TRT_DriftCircleOnTrack*>; - ctt->m_containedChildRots->push_back(newStraw); - - this->updateCompetingROT(*modifiableCompROT, trkPar, beta); -} - -///////////////////////////////////////////////////////////////////// -// INTERNAL: calculate eff. LocPars+Err according to the weights (BR) -///////////////////////////////////////////////////////////////////// -void InDet::CompetingTRT_DriftCirclesOnTrackTool::calcEffectiveMeasurement( - std::unique_ptr<const Trk::LocalParameters>& effectiveLocalPar, - std::unique_ptr<const Amg::MatrixX>& effectiveErrMat, - const std::vector< const InDet::TRT_DriftCircleOnTrack* >* ROTs, - const std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >* assgnProbs, - const Trk::TrackParameters* trkPar, - const Trk::Surface* surf, - bool nonVanishingROTsHaveCommonSurface -) const { - - ATH_MSG_VERBOSE("in calcEffectiveMeasurement():"); - unsigned int rotsnum = ROTs->size(); - double* driftCenterShift = new double[rotsnum]; - for (unsigned int i=0; i<rotsnum; i++) - driftCenterShift[i] = 0; //TODO: check if this is right - // - if (!nonVanishingROTsHaveCommonSurface) { - ATH_MSG_VERBOSE("Have to calc shift of drift centers:"); - // calculation of effective localParameters for Barrel-TRT: - // calculate shift of the straw centers relative to the associated surface - // in the plane normal to the assumedTrackParameters: - // //<Trk::StraightLineSurface>m_associatedSurface; - // calculate vector to project on first: perpendicular to straw axis and to track momentum - // normal() is z-axis of the surface rotation, so it should be the z-direction of the StraightLineSurface - const Amg::Vector3D& strawDirection = surf->normal(); - // or use TRT_BaseElement.strawAxis(int straw) for one straw... - const Amg::Vector3D& globCenterSurface = surf->center(); - Amg::Vector3D projectionVector = strawDirection.cross(trkPar->momentum()); - projectionVector = projectionVector.unit(); - for (unsigned int i=0; i<rotsnum; i++) { - driftCenterShift[i] = projectionVector.dot(ROTs->operator[](i)->associatedSurface().center() - globCenterSurface); - ATH_MSG_VERBOSE("driftCenterShift[" << i << "] = " << driftCenterShift[i] ); - } - } - // now use standard 1-dim calculation with correction of strawcenter shift - - if (ROTs->operator[](0)->localParameters().dimension() == 1) { - //double meanDriftRadius = assignmentProbability(0) * rioOnTrack(0)->localErrorMatrix().weightValue(Trk::locX) * (rioOnTrack(0)->localParameters()[Trk::locX] + driftCenterShift[0]); - - // Mean weight value - double meanWeight = 0; - // mean driftradius - double meanDriftRadius = 0; - double currentWeight; - // loop over ROTs - ATH_MSG_VERBOSE(" loop over ROTs " ); - for (unsigned int i=0; i<rotsnum; i++) { - currentWeight = assgnProbs->operator[](i) /std::sqrt( ROTs->operator[](i)->localCovariance()(Trk::locX,Trk::locX)); - meanWeight += currentWeight; - meanDriftRadius += currentWeight * (ROTs->operator[](i)->localParameters()[Trk::locX] + driftCenterShift[i]); - } - // create mean ErrorMatrix - ATH_MSG_DEBUG("mean weight: " << meanWeight ); - if (meanWeight<=1.0e-12) { - meanWeight = 1e-10; // use very small value, otherwise inversion will fail! - ATH_MSG_DEBUG("mean weight 0, rescale to: " << meanWeight ); - } - Amg::MatrixX meanCovMatrix(1, 1); - meanCovMatrix(0,0) = 1./meanWeight; - // devide mean DriftRadius by mean Weight - meanDriftRadius = meanCovMatrix(Trk::locX,Trk::locX) * meanDriftRadius; - // make new LocalParameters - ATH_MSG_DEBUG("mean driftradius: " << meanDriftRadius ); - Trk::DefinedParameter radiusPar(meanDriftRadius,Trk::locX); - effectiveLocalPar = std::make_unique<Trk::LocalParameters>(radiusPar); - effectiveErrMat = std::make_unique<Amg::MatrixX>(meanCovMatrix); - } else { - // weird dimension for a TRT_DriftCircle - // FIXME: decide what to do... - delete[] driftCenterShift; - ATH_MSG_ERROR("weird dimension of TRT_DriftCircle parameters" ); - return; - } - // } - delete[] driftCenterShift; - // } - // return *m_localParameters; -} - -///////////////////////////////////////////////////////////////////// -// INTERNAL: calculate eff. LocPars+Err according to the weights (EC) -///////////////////////////////////////////////////////////////////// -void InDet::CompetingTRT_DriftCirclesOnTrackTool::calcEffectiveEndCapMeasurement( - std::unique_ptr<const Trk::LocalParameters>& effectiveLocalPar, - std::unique_ptr<const Amg::MatrixX>& effectiveErrMat, - const std::vector< const InDet::TRT_DriftCircleOnTrack* >* ROTs, - const std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >* assgnProbs, - const Amg::Vector2D& localTrack, - const Trk::Surface* surf - //const InDet::TRT_DriftCircleOnTrack* mostProbableROT, - //const bool nonVanishingROTsHaveCommonSurface -) const { - - ATH_MSG_VERBOSE("calcEffectiveEndCapMeasurement:"); - unsigned int rotsnum = ROTs->size(); - // calculation of effective localParameters and ErrorMatrix for EndCap-TRT: - //--------------- - // solution 1 (with measurements on different straws): - // Use plane of TRT-wheel as measurement plane (DiscSurface). - // For tracks with small angles between plane and momentum this is not - // perfect, because the point of closest approach does not lie in - // the plane. - // Using DiscSurface as the plane for computing the effective measurement - // means that the local measurements (DriftRadii) need to be converted to - // polar coordinates. - // Just one coordinate (the angle) is used for the effective measurement - // because all the information about locR comes from the assumedTrackParameters. - // Even this result depends (slightly) on the assumed locR, therefore - // the real surface (StraighLineSurface) of the most probable hit should be - // used in the last iteration steps of annealing (when just the ambiguities - // of one straw have to solved anymore). - // TODO: check if origin of m_associatedSurface is intersection point of straw directions - // alpha: angle between hit and straw - // tan(alpha) = DriftRadius/(locR of Track) - // => sigma_alpha = sigma_DriftRadius/(locR of Track) (for small alpha, should be valid here) - // TODO: use correct linear error expansion - // beta: angle between straw direction and coordinate axis of the DiscSurface - //double localR_Track = trkPar->parameters()[Trk::locR]; - double meanPhi = 0.; - double meanPhiWeight = 0.; - double sumAssgnProb = 0.; - ATH_MSG_VERBOSE(" loop over ROTs " ); - for (unsigned int i=0; i<rotsnum; i++) { - double alpha = ((localTrack[Trk::locR]!=0.)?std::atan(ROTs->operator[](i)->localParameters()[Trk::locX]/localTrack[Trk::locR]):0.); - double alphaWeight = localTrack[Trk::locR]*localTrack[Trk::locR] / std::sqrt( ROTs->operator[](i)->localCovariance()(Trk::locX,Trk::locX)); - // there must be an easier way... - // perhaps use product of transforms? - // TODO: check if this REALLY gives the correct angle in all possible cases - const InDet::TRT_DriftCircleOnTrack& rot = *ROTs->operator[](i); - const Identifier& id = rot.identify(); - int sdir = rot.detectorElement()->strawDirection(); - Amg::Vector3D dirt = surf->transform().rotation().col(1); - Amg::Vector3D dirt2 = rot.detectorElement()->transform(id).linear()*Amg::Vector3D(0,0,1) * sdir; - - double beta = 1.; - double ptot = dirt.mag()*dirt2.mag(); - if(ptot > 0) { - beta = dirt.dot(dirt2)/ptot; - if(beta > 1) beta = 1; - if(beta < -1) beta = -1; - beta = std::acos(beta); - } - beta = (CLHEP::twopi/4.)-beta; - double phi = -alpha + beta; - ATH_MSG_DEBUG("beta["<<i<<"]="<< beta <<"="<<(beta/CLHEP::twopi*360.)<<"deg; -alpha+beta="<< phi ); - // HACK: correct the sign: - if ((localTrack[Trk::locPhi]*phi)<.0) phi *= -1.; - meanPhi += assgnProbs->operator[](i) * phi; - meanPhiWeight += assgnProbs->operator[](i) * alphaWeight; - ATH_MSG_DEBUG("assgnProb="<<assgnProbs->operator[](i)<<" meanPhi="<<meanPhi<<" meanPhiWeight="<<meanPhiWeight ); - sumAssgnProb += assgnProbs->operator[](i); - } - ATH_MSG_DEBUG("mean weight: " << meanPhiWeight ); - if (meanPhiWeight <= 1.0e-12) { - meanPhiWeight = 1e-10; // use very small value otherwise inversion will fail!!! - ATH_MSG_DEBUG("mean weight 0, rescale to: "<<meanPhiWeight); - } - Amg::MatrixX meanCovMatrix(1, 1); - meanCovMatrix(0,0) = 1./meanPhiWeight; - effectiveErrMat = std::make_unique<Amg::MatrixX>(meanCovMatrix); - // !!!!! do not use effectiveErrMat->covValue(Trk::locPhi) !!!!! - // effectiveErrMat->covValue(0) has to be used - // ErrorMatrix uses the internal index not the extrenal of LocalParameters!!!!! - - // scale mean value by mean weight - //meanPhi = effectiveErrMat->covValue(Trk::locPhi) * meanPhi; - meanPhi /= sumAssgnProb; - ATH_MSG_DEBUG("mean phi: " << meanPhi ); - Trk::DefinedParameter radiusPar(meanPhi, Trk::locPhi); - effectiveLocalPar = std::make_unique<Trk::LocalParameters>(radiusPar); - - // solution 2 (just with the ambiguity of one straw): - // Use the surface of the straw as measurement surface (StraightLineSurface). - // in this case the standard function can be called. - -} - -void InDet::CompetingTRT_DriftCirclesOnTrackTool::testCompetingROT(const InDet::CompetingTRT_DriftCirclesOnTrack& compROT)const { - - if (!msgLvl(MSG::VERBOSE)) return; - - ATH_MSG_VERBOSE("**Test**"); - - msg(MSG::VERBOSE) <<" - associatedSurface(): "; - const Trk::Surface* assocsurface = &(compROT.associatedSurface()); - msg()<< assocsurface << " at ("<< assocsurface->center().x() << ", "<< assocsurface->center().y() << ", "<< assocsurface->center().z() << ")" <<endmsg; - - msg()<<" - containedROTs(): "; - msg()<<" numberOfContainedROTs(): " << compROT.numberOfContainedROTs()<<endmsg; - - msg()<<" - eff. localParameters():"; - msg()<<" dim: " << compROT.localParameters().dimension(); - msg()<<" [locX]: " << compROT.localParameters()[Trk::locX] <<endmsg; - - if (compROT.assignmentProbability(compROT.indexOfMaxAssignProb()) > 0. ) { - // if maxAssgnProb==0 the weight matrix is 0 and therefore singular => can not get covariance - msg()<<" - localErrorMatrix():"; - msg()<<" dimCov: " << compROT.localCovariance().rows(); - msg()<<" cov[loc1]: " << compROT.localCovariance()(Trk::loc1,Trk::loc1)<<endmsg; - } - - msg()<<" - indexOfMaxAssignProb(): " << compROT.indexOfMaxAssignProb() <<endmsg; - - msg()<<" - assignmentProbability(index) and rioOnTrack(index)"<<endmsg; - for (unsigned int i=0; i<compROT.numberOfContainedROTs(); i++) { - msg()<<" ["<< i <<"] assgnProb: "<< compROT.assignmentProbability(i) - << " ROT ID: "<< compROT.rioOnTrack(i).identify().getString() - << " [locX]: "<< compROT.rioOnTrack(i).localParameters()[Trk::locX] - << " ROT surf: "<< &(compROT.rioOnTrack(i).associatedSurface()) - << endmsg; - if (compROT.assignmentProbability(i) > compROT.assignmentProbability(compROT.indexOfMaxAssignProb()) ) { - msg(MSG::ERROR)<<" assignment probability larger than maximum assignment probability!!!"<<endmsg; - msg(MSG::VERBOSE)<<endmsg; - } - } - - - msg()<<" - eff. globalPosition(): "; - msg()<< " ("<< compROT.globalPosition().x() << ", "<< compROT.globalPosition().y() << ", "<< compROT.globalPosition().z() << ")" <<endmsg; -} diff --git a/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/src/components/CompetingTRT_DriftCirclesOnTrackTool_entries.cxx b/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/src/components/CompetingTRT_DriftCirclesOnTrackTool_entries.cxx deleted file mode 100644 index f59f05f47f6a..000000000000 --- a/InnerDetector/InDetRecTools/InDetCompetingRIOsOnTrackTool/src/components/CompetingTRT_DriftCirclesOnTrackTool_entries.cxx +++ /dev/null @@ -1,8 +0,0 @@ -#include "InDetCompetingRIOsOnTrackTool/CompetingTRT_DriftCirclesOnTrackTool.h" -#include "InDetCompetingRIOsOnTrackTool/CompetingPixelClustersOnTrackTool.h" -#include "InDetCompetingRIOsOnTrackTool/CompetingSCT_ClustersOnTrackTool.h" - -DECLARE_COMPONENT( InDet::CompetingTRT_DriftCirclesOnTrackTool ) -DECLARE_COMPONENT( InDet::CompetingPixelClustersOnTrackTool ) -DECLARE_COMPONENT( InDet::CompetingSCT_ClustersOnTrackTool ) - diff --git a/InnerDetector/InDetRecTools/TRT_TrackExtensionTool_DAF/ATLAS_CHECK_THREAD_SAFETY b/InnerDetector/InDetRecTools/TRT_TrackExtensionTool_DAF/ATLAS_CHECK_THREAD_SAFETY deleted file mode 100644 index 94bf57b0fb9a..000000000000 --- a/InnerDetector/InDetRecTools/TRT_TrackExtensionTool_DAF/ATLAS_CHECK_THREAD_SAFETY +++ /dev/null @@ -1 +0,0 @@ -InnerDetector/InDetRecTools/TRT_TrackExtensionTool_DAF diff --git a/InnerDetector/InDetRecTools/TRT_TrackExtensionTool_DAF/CMakeLists.txt b/InnerDetector/InDetRecTools/TRT_TrackExtensionTool_DAF/CMakeLists.txt deleted file mode 100644 index 67cadf1c225a..000000000000 --- a/InnerDetector/InDetRecTools/TRT_TrackExtensionTool_DAF/CMakeLists.txt +++ /dev/null @@ -1,10 +0,0 @@ -# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration - -# Declare the package name: -atlas_subdir( TRT_TrackExtensionTool_DAF ) - -# Component(s) in the package: -atlas_add_component( TRT_TrackExtensionTool_DAF - src/*.cxx - src/components/*.cxx - LINK_LIBRARIES AthenaBaseComps GaudiKernel InDetCompetingRIOsOnTrackToolLib InDetIdentifier InDetPrepRawData InDetRecToolInterfaces MagFieldConditions MagFieldElements TRT_ReadoutGeometry TrkEventUtils TrkExInterfaces TrkGeometry TrkMeasurementBase TrkParameters TrkToolInterfaces TrkTrack ) diff --git a/InnerDetector/InDetRecTools/TRT_TrackExtensionTool_DAF/TRT_TrackExtensionTool_DAF/TRT_TrackExtensionTool_DAF.h b/InnerDetector/InDetRecTools/TRT_TrackExtensionTool_DAF/TRT_TrackExtensionTool_DAF/TRT_TrackExtensionTool_DAF.h deleted file mode 100755 index c0c7c3a83e5e..000000000000 --- a/InnerDetector/InDetRecTools/TRT_TrackExtensionTool_DAF/TRT_TrackExtensionTool_DAF/TRT_TrackExtensionTool_DAF.h +++ /dev/null @@ -1,186 +0,0 @@ -/* - Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration -*/ - -///////////////////////////////////////////////////////////////////////////////// -// Header file for class TRT_TrackExtensionTool_DAF -///////////////////////////////////////////////////////////////////////////////// -// (c) ATLAS Detector software -///////////////////////////////////////////////////////////////////////////////// -// Concrete implementation for base class ITRT_TrackExtensionTool -///////////////////////////////////////////////////////////////////////////////// -// Sebastian Fleischmann -///////////////////////////////////////////////////////////////////////////////// - -#ifndef TRT_TRACKEXTENSIONTOOL_DAF_H -#define TRT_TRACKEXTENSIONTOOL_DAF_H - -#include <vector> -#include <string> -#include "GaudiKernel/ToolHandle.h" -#include "AthenaBaseComps/AthAlgTool.h" -#include "GaudiKernel/ServiceHandle.h" - -#include "TrkParameters/TrackParameters.h" // typedef -#include "InDetPrepRawData/TRT_DriftCircleContainer.h" // typedef - -#include "InDetRecToolInterfaces/ITRT_TrackExtensionTool.h" -#include "TrkEventUtils/EventDataBase.h" -#include "TrkGeometry/MagneticFieldProperties.h" - -// MagField cache -#include "MagFieldConditions/AtlasFieldCacheCondObj.h" -#include "MagFieldElements/AtlasFieldCache.h" - -// tools: -#include "TrkExInterfaces/IPropagator.h" -#include "InDetRecToolInterfaces/ITRT_DetElementsRoadMaker.h" -#include "InDetCompetingRIOsOnTrackTool/ICompetingTRT_DriftCirclesOnTrackCreator.h" - -class MsgStream; -class TRT_ID; - -namespace Trk { - class Surface; -} - -namespace InDet { - -/** -@class TRT_TrackExtensionTool_DAF -The TRT_TrackExtensionTool_DAF produces an extension with Trk::CompetingRIOsOnTrack of -silicon tracks into the TRT. - -@author Sebastian.Fleischmann@cern.ch -*/ - -class TRT_TrackExtensionTool_DAF : - - virtual public ITRT_TrackExtensionTool, public AthAlgTool { - /////////////////////////////////////////////////////////////////// - // Public methods: - /////////////////////////////////////////////////////////////////// - -public: - - /////////////////////////////////////////////////////////////////// - // Standard tool methods - /////////////////////////////////////////////////////////////////// - - TRT_TrackExtensionTool_DAF(const std::string&,const std::string&,const IInterface*); - virtual ~TRT_TrackExtensionTool_DAF(); - virtual StatusCode initialize() override; - virtual StatusCode finalize () override; - - /////////////////////////////////////////////////////////////////// - // Main methods for track extension to TRT - /////////////////////////////////////////////////////////////////// - - virtual std::vector<const Trk::MeasurementBase*>& - extendTrack(const EventContext& ctx, - const Trk::Track&, - InDet::ITRT_TrackExtensionTool::IEventData &virt_event_data) const override; - - virtual std::vector<const Trk::MeasurementBase*>& - extendTrack(const EventContext& ctx, - const Trk::TrackParameters * pTrackParams, - InDet::ITRT_TrackExtensionTool::IEventData &virt_event_data) const override; - - virtual Trk::Track* - newTrack(const EventContext& ctx, - const Trk::Track&, - InDet::ITRT_TrackExtensionTool::IEventData &virt_event_data) const override; - - virtual std::unique_ptr<InDet::ITRT_TrackExtensionTool::IEventData> newEvent(const EventContext& ctx) const override; - /////////////////////////////////////////////////////////////////// - // TRT seed extension to TRT - /////////////////////////////////////////////////////////////////// - - virtual Trk::TrackSegment* findSegment(const EventContext& ctx, - const Trk::TrackParameters *, - InDet::ITRT_TrackExtensionTool::IEventData &virt_event_data) const override; - - /////////////////////////////////////////////////////////////////// - // Print internal tool parameters and status - /////////////////////////////////////////////////////////////////// - - virtual MsgStream& dump(MsgStream& out) const override; - virtual std::ostream& dump(std::ostream& out) const override; - -protected: - - /////////////////////////////////////////////////////////////////// - // Protected Data - /////////////////////////////////////////////////////////////////// - - const TRT_DriftCircleContainer* m_trtcontainer; //!< container of TRT RIOs - SG::ReadHandleKey<TRT_DriftCircleContainer> m_jo_trtcontainername; //!< jobOption: name of container with TRT RIOs - double m_jo_roadwidth; //!< jobOption: Max width of the road - bool m_jo_simpleExtension; //!< jobOption: do the simple TRT extension by putting all RIOs of one detector element within the road into one Trk::CompetingRIOsOnTrack - - double m_jo_maxGroupDistance; //!< jobOption: Max distance of the RIO groups in the grouped barrel extension (distance in the x-y-plane) - double m_jo_minGroupDistance; //!< jobOption: Min distance of the RIO groups in the grouped barrel extension (distance in the x-y-plane) - - - class EventData; - class EventData : public Trk::EventDataBase<EventData,InDet::ITRT_TrackExtensionTool::IEventData> - { - friend class TRT_TrackExtensionTool_DAF; - public: - EventData(const TRT_DriftCircleContainer *trtcontainer) : m_trtcontainer(trtcontainer) {} - - ~EventData() {} - protected: - const TRT_DriftCircleContainer *m_trtcontainer = nullptr; - std::vector<const Trk::MeasurementBase*> m_measurement; //!< vector of MeasurementBase for the output - std::vector <const InDetDD::TRT_BaseElement*> m_detectorElements; //!< vector to store the detElements - std::vector <std::shared_ptr< const Trk::TrackParameters>> m_propagatedTrackParameters; //!< vector to store the propagated track parameters (propagated to the related entry of m_detectorElements) - const Trk::TrackParameters *m_siliconTrkParams = nullptr; //!< track parameters at the outermost Silicon layer - }; - - - /////////////////////////////////////////// - // the different tools and their jobOptions - /////////////////////////////////////////// - ToolHandle< InDet::ICompetingTRT_DriftCirclesOnTrackCreator > m_compROTcreator - {this, - "CompetingDriftCircleTool", - "InDet::CompetingTRT_DriftCirclesOnTrackTool/CompetingTRT_DriftCirclesOnTrackTool", - "Tool for the creation of CompetingTRT_DriftCirclesOnTrack"}; //!< the instance of the CompetingTRT_DriftCirclesOnTrackCreator tool - double m_jo_annealingFactor; //!< jobOption: The annealing factor used for Trk::CompetingRIOsOnTrack creation - - ToolHandle< InDet::ITRT_DetElementsRoadMaker > m_roadtool - {this, - "RoadTool", - "InDet::TRT_DetElementsRoadMaker_xk/TRT_DetElementsRoadMaker", - "TRT Road Tool for the search of Detector Elements"}; //!< instance of the TRT road maker tool - - PublicToolHandle< Trk::IPropagator > m_propagator - {this, - "PropagatorTool", - "Trk::RungeKuttaPropagator/Propagator", - "Propagator tool"}; //!< the Propagator tool - - SG::ReadCondHandleKey<AtlasFieldCacheCondObj> m_fieldCondObjInputKey {this, "AtlasFieldCacheCondObj", "fieldCondObj", "Name of the Magnetic Field conditions object key"}; - - - std::string m_fieldmode; //!< jobOption: Magnetic field mode - Trk::MagneticFieldProperties m_fieldprop; //!< Magnetic field properties - - const TRT_ID* m_trtID; //!< the TRT ID helper - - /////////////////////////////////////////////////////////////////// - // Methods - /////////////////////////////////////////////////////////////////// - - /** find an element-wise extension (ie. the RIOs in a CompROT belong to one detElement) */ - bool elementWiseExtension(int, int, InDet::TRT_TrackExtensionTool_DAF::EventData &event_data) const; - /** find a barrel extension with RIOs grouped along the globalPositions of the track */ - bool groupedBarrelExtension(int, int, InDet::TRT_TrackExtensionTool_DAF::EventData &event_data) const; - -}; - - -} // end of name space - -#endif // TRT_TRACKEXTENSIONTOOL_DAF_H diff --git a/InnerDetector/InDetRecTools/TRT_TrackExtensionTool_DAF/doc/packagedoc.h b/InnerDetector/InDetRecTools/TRT_TrackExtensionTool_DAF/doc/packagedoc.h deleted file mode 100644 index 1973a88d1a1d..000000000000 --- a/InnerDetector/InDetRecTools/TRT_TrackExtensionTool_DAF/doc/packagedoc.h +++ /dev/null @@ -1,86 +0,0 @@ -/* - Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration -*/ - -/** -@page TRT_TrackExtensionTool_DAF_page The TRT_TrackExtensionTool_DAF package -Tool to extend Silicon tracks into the TRT based on the Deterministic Annealing Filter. - -@author Sebastian.Fleischmann@cern.ch - -@section TRT_TrackExtensionTool_DAF_introductionTRT_TrackExtensionTool_DAF Introduction - -This package contains a tool to produce a vector of InDet::CompetingTRT_DriftCirclesOnTrack -which can be used by the InDetExtensionProcessor to extend silicon tracks into the TRT. -InDet::TRT_DriftCircles lying on a road around the track prediction are choosen and grouped -into InDet::CompetingTRT_DriftCirclesOnTrack containing measurements which are not compatible -with each other. The Trk::DeterministicAnnealingFilter (DAF) will then decide in an iterative annealing procedure which InDet::TRT_DriftCircleOnTrack s are assigned to the extended track. - -As the DAF TRT_TrackExtensionTool just produces a vector of Trk::MeasurementBase (resp. -InDet::CompetingTRT_DriftCirclesOnTrack) without actually deciding which measurements belong -to the track (i.e. just doing a course assignment) this tool can only be used in combination -with the Trk::DeterministicAnnealingFilter. - -This tool has two operation modes. The first (simple) one just groups all measurements (TRT_DriftCircles) -on one TRT detector element into the same CompetingTRT_DriftCirclesOnTrack. The more sophisticated mode -groups measurements on "pseudo-detector surfaces" which are perpendicular to the track prediction for the -Barrel pert of the track. In the TRT endcaps the measurements are always grouped by the detector elements -because polar coordinates in the wheel plane are used. Both modes are almost identical if the tracks are -nearly perpendicular to the detector element planes as it is the case for high momentum tracks. - -The following sketch shows a track prediction and how TRT measurements are grouped in the more -sophisticated mode. -@image html TRT-extension-grouped.png - -Figure 2 shows the same track prediction and measurements in the case of the simple mode. The first -measurements are grouped in a sensible way, whereas the grouping fails for the last measurements, because -the track is not perpendicular to the detector elements anymore. -@image html TRT-extension-detElement-wise.png - - -@section TRT_TrackExtensionTool_DAF_TRT_TrackExtensionTool_DAFOverview Class Overview - The TRT_TrackExtensionTool_DAF package contains the following class: - - - InDet::TRT_TrackExtensionTool_DAF : Tool to collect the compatible measurements - in InDet::CompetingTRT_DriftCirclesOnTrack. - -@section TRT_TrackExtensionTool_DAF_howToUseTRT_TrackExtensionTool_DAF How to use the TRT_TrackExtensionTool_DAF -The Trk::TRT_TrackExtensionTool_DAF can be configured by the Python setup class <tt>ConfiguredTRT_TrackExtensionTool_DAF</tt> which is defined in <tt><a href="ConfiguredTRT__TrackExtensionTool__DAF_8py-source.html">ConfiguredTRT_TrackExtensionTool_DAF.py</a></tt>.It is important to configure the InDetExtensionProcessor to use the TrkDeterministicAnnealingFilter as TrackFitter. This can be done by the Python setup class <tt>ConfiguredInDetExtensionProcessor</tt>. - - -@subsection TRT_TrackExtensionTool_DAFJobOptions jobOptions of the InDet::TRT_TrackExtensionTool_DAF -<DL> - <DT>MagneticTool - <DD>The magnetic field tool to get the field properties used by the propagator. Default: <tt>Trk::MagneticFieldTool_xk</tt> - - <DT>MagneticFieldMode - <DD>fieldmode to be used for the field properties. Default: <tt>MapSolenoid</tt> - - <DT>PropagatorTool - <DD>tool to propagate track parameters. Default: <tt>Trk::RungeKuttaPropagator</tt> - - <DT>CompetingDriftCircleTool - <DD>tool to create the InDet::CompetingTRT_DriftCirclesOnTrack. Default: <tt>InDet::CompetingTRT_DriftCirclesOnTrackTool/CompetingTRT_DriftCirclesOnTrackTool</tt> - - <DT>RoadTool - <DD>tool to find a road of detector elements in the TRT. Default: <tt>InDet::TRT_DetElementsRoadMaker_xk</tt> - - <DT>RoadWidth - <DD>width of the road of InDet::TRT_DriftCircle s (independent of the RoadTool). Default: <tt>10.</tt> - - <DT>TRT_DriftCircleContainer - <DD>StoreGate container name of the InDet::TRT_DriftCircle. Default: <tt>TRT_DriftCircles</tt> - - <DT>InitialAnnealingFactor - <DD>annealing factor used to create the InDet::CompetingTRT_DriftCirclesOnTrack. Default: <tt>81.</tt> - - <DT>SimpleElementWiseExtension - <DD>do a simple detector element-wise grouping of the TRT_DriftCircles or use a more - sophisticated way in the Barrel part? See above for a detailed description. Default: <tt>false</tt> - - <DT>MaxGroupDistance - <DD>maximum distance of TRT_DriftCircle groups when using the sophisticated grouping method. Default: <tt>5.</tt> - -@section TRT_TrackExtensionTool_DAF_ExtrasTRT_TrackExtensionTool_DAF Extra Pages - -*/ diff --git a/InnerDetector/InDetRecTools/TRT_TrackExtensionTool_DAF/src/TRT_TrackExtensionTool_DAF.cxx b/InnerDetector/InDetRecTools/TRT_TrackExtensionTool_DAF/src/TRT_TrackExtensionTool_DAF.cxx deleted file mode 100755 index 673af407753a..000000000000 --- a/InnerDetector/InDetRecTools/TRT_TrackExtensionTool_DAF/src/TRT_TrackExtensionTool_DAF.cxx +++ /dev/null @@ -1,727 +0,0 @@ -/* - Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration -*/ - -/////////////////////////////////////////////////////////////////// -// Implementation file for class InDet::TRT_TrackExtensionTool_DAF -/////////////////////////////////////////////////////////////////// -// (c) ATLAS Detector software -/////////////////////////////////////////////////////////////////// -/////////////////////////////////////////////////////////////////// -// Sebastian Fleischmann -/////////////////////////////////////////////////////////////////// - - -#include "TrkParameters/TrackParameters.h" - -#include "TrkTrack/Track.h" -#include "TrkMeasurementBase/MeasurementBase.h" - -#include "TRT_TrackExtensionTool_DAF/TRT_TrackExtensionTool_DAF.h" - -#include "TRT_ReadoutGeometry/TRT_BaseElement.h" -#include "InDetIdentifier/TRT_ID.h" -#include <cmath> -#include <iostream> -#include <iomanip> -#include <utility> - -//http://www-zeuthen.desy.de/geant4/clhep-2.0.4.3/BasicVector3D_8h-source.html -double perp2( const Amg::Vector3D& v1, const Amg::Vector3D& v2 ) { - double mag2 = v2.squaredNorm(); - double dp = v1.dot(v2); - if (mag2 > 0.) { - return v1.squaredNorm() - dp*dp / mag2; - } else { - return v1.squaredNorm(); - } -} - -/////////////////////////////////////////////////////////////////// -// Constructor -/////////////////////////////////////////////////////////////////// - -InDet::TRT_TrackExtensionTool_DAF::TRT_TrackExtensionTool_DAF -(const std::string& t,const std::string& n,const IInterface* p) - : AthAlgTool(t,n,p), - m_trtcontainer(nullptr), - m_jo_trtcontainername("TRT_DriftCircles"), - m_jo_roadwidth(10.), - m_jo_simpleExtension(true), - m_jo_maxGroupDistance(5.), - m_jo_minGroupDistance(1.), - m_jo_annealingFactor(81.), - m_fieldmode("MapSolenoid"), - m_trtID(nullptr) -{ - - declareInterface<ITRT_TrackExtensionTool>(this); - - declareProperty("MagneticFieldMode", m_fieldmode, "field mode of the field tool"); - declareProperty("TRT_DriftCircleContainer", m_jo_trtcontainername, "Name of the container of TRT measurements (TRT_DriftCircles)"); - declareProperty("InitialAnnealingFactor", m_jo_annealingFactor, "Annealing factor (temperature) used to calculate the initial assignment probabilities of a group of competing TRT measurements. Should be choosen identical to the first entry of the annealing schedule of the Deterministic Annealing Filter"); - declareProperty("SimpleElementWiseExtension", m_jo_simpleExtension, "Do simple element wise extension or do sophisticated grouping of measurements?"); - declareProperty("RoadWidth", m_jo_roadwidth, "Width of the road of measurements (the RoadTool uses its own road width!)"); - declareProperty("MaxGroupDistance", m_jo_maxGroupDistance, "Maximum distance of measurement groups in sophisticated grouping"); -} - -/////////////////////////////////////////////////////////////////// -// Destructor -/////////////////////////////////////////////////////////////////// - -InDet::TRT_TrackExtensionTool_DAF::~TRT_TrackExtensionTool_DAF() = default; - -/////////////////////////////////////////////////////////////////// -// Initialisation -/////////////////////////////////////////////////////////////////// - -StatusCode InDet::TRT_TrackExtensionTool_DAF::initialize() { - ATH_CHECK( AlgTool::initialize() ); - - // Build MagneticFieldProperties - if (m_fieldmode == "NoField" ) m_fieldprop = Trk::MagneticFieldProperties(Trk::NoField ); - else if(m_fieldmode == "MapSolenoid") m_fieldprop = Trk::MagneticFieldProperties(Trk::FastField); - else m_fieldprop = Trk::MagneticFieldProperties(Trk::FullField); - // ------------------- - // Get propagator tool - ATH_CHECK(m_propagator.retrieve()); - - // -------------------------------- - // Get CompetingRIOsOnTrack creator - ATH_CHECK(m_compROTcreator.retrieve()); - - // ------------------------------------ - // Get detector elements road maker tool - ATH_CHECK( m_roadtool.retrieve()); - - // ------------------------- - // Get TRT identifier: - // First get TRT manager - ATH_CHECK(detStore()->retrieve(m_trtID, "TRT_ID")); - // ---------------------------- - // init the size of the vectors - - ATH_CHECK( m_jo_trtcontainername.initialize()); - - ATH_CHECK( m_fieldCondObjInputKey.initialize()); - - return StatusCode::SUCCESS; -} - -/////////////////////////////////////////////////////////////////// -// Finalize -/////////////////////////////////////////////////////////////////// - -StatusCode InDet::TRT_TrackExtensionTool_DAF::finalize() { - StatusCode sc = AlgTool::finalize(); - return sc; -} - -/////////////////////////////////////////////////////////////////// -// Dumps relevant information into the MsgStream -/////////////////////////////////////////////////////////////////// - -MsgStream& InDet::TRT_TrackExtensionTool_DAF::dump( MsgStream& out ) const { - return out; -} - - -/////////////////////////////////////////////////////////////////// -// Dumps relevant information into the ostream -/////////////////////////////////////////////////////////////////// - -std::ostream& InDet::TRT_TrackExtensionTool_DAF::dump( std::ostream& out ) const { - return out; -} - - -/////////////////////////////////////////////////////////////////// -// Track extension init for a new event -/////////////////////////////////////////////////////////////////// -std::unique_ptr<InDet::ITRT_TrackExtensionTool::IEventData> -InDet::TRT_TrackExtensionTool_DAF::newEvent(const EventContext& ctx) const { - // ----------- - // get the container with TRT RIOs - SG::ReadHandle<TRT_DriftCircleContainer> trtcontainer(m_jo_trtcontainername, ctx); - if((not trtcontainer.isValid())) { - std::stringstream msg; - msg << "Missing TRT_DriftCircleContainer " << m_jo_trtcontainername.key(); - throw std::runtime_error( msg.str() ); - } - auto eventData = std::make_unique<EventData>(trtcontainer.cptr()); - eventData->m_measurement.reserve(200); - eventData->m_propagatedTrackParameters.reserve(200); - return eventData; -} - -/////////////////////////////////////////////////////////////////// -// Main methods for track extension to TRT -/////////////////////////////////////////////////////////////////// -std::vector<const Trk::MeasurementBase*>& -InDet::TRT_TrackExtensionTool_DAF::extendTrack(const EventContext& ctx, - const Trk::Track& track, - InDet::ITRT_TrackExtensionTool::IEventData &eventDataBaseclass) const -{ - EventData & event_data=EventData::getPrivateEventData(eventDataBaseclass); - // ------------- - // get the last TrackStateOnSurface of the Track: this should be the outermost Silicon measurement - const auto *pTrackPar = track.trackStateOnSurfaces()->back()->trackParameters(); - if (!pTrackPar) { - // if the last TSoS does not like us we use the perigee - ATH_MSG_DEBUG("last track state has no trackParameters, use Perigee instead."); - pTrackPar = track.perigeeParameters(); - if(!pTrackPar) { - // now I am upset... - ATH_MSG_ERROR("even the Perigee == Null, stop!"); - return event_data.m_measurement; - } - } - // call main function - return extendTrack(ctx, pTrackPar,event_data); -} - - -std::vector<const Trk::MeasurementBase*>& -InDet::TRT_TrackExtensionTool_DAF::extendTrack(const EventContext& ctx, - const Trk::TrackParameters * pTrackPar, //I don't own this - InDet::ITRT_TrackExtensionTool::IEventData &eventDataBaseclass) const -{ - InDet::TRT_TrackExtensionTool_DAF::EventData & - event_data=InDet::TRT_TrackExtensionTool_DAF::EventData::getPrivateEventData(eventDataBaseclass); - // ------------ - // reset the output vector - event_data.m_measurement.clear(); - // reset the detElements vector - event_data.m_detectorElements.clear(); - // reset the vector with propagated trackParameters - event_data.m_propagatedTrackParameters.clear(); - // ------------ - // stop immediately if no RIO container could be retrieved - if(!event_data.m_trtcontainer) { - ATH_MSG_DEBUG("no RIO container retrieved, stop!"); - return event_data.m_measurement; - } - event_data.m_siliconTrkParams = pTrackPar; - ATH_MSG_DEBUG("starting TRT detector elements road maker with initial TrackParameters: "<< *event_data.m_siliconTrkParams ); - // Get AtlasFieldCache - SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle{m_fieldCondObjInputKey, ctx}; - const AtlasFieldCacheCondObj* fieldCondObj{*readHandle}; - if (fieldCondObj == nullptr) { - ATH_MSG_ERROR("InDet::TRT_TrackExtensionTool_xk::findSegment: Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCondObjInputKey.key()); - return event_data.m_measurement; - } - MagField::AtlasFieldCache fieldCache; - fieldCondObj->getInitializedCache (fieldCache); - // ---------------------------------- - // start the TRT detector elements road maker to get a list of possibly interesting detector elements - const std::vector<const InDetDD::TRT_BaseElement*> detElements = m_roadtool->detElementsRoad(ctx, fieldCache, *event_data.m_siliconTrkParams, Trk::alongMomentum); - ATH_MSG_DEBUG("TRT detector elements road maker found "<< detElements.size()<< " detElements" ); - if(detElements.empty()) { - ATH_MSG_DEBUG("TRT_DetElementsRoadMaker found no road, stop!"); - return event_data.m_measurement; - } - // ---------------------------------- - // extrapolate to get a list of global track positions: - // (extrapolate just parameters, not covariance) - - // the index of the detElement vector where the track changes from one sub type to another - // in the most general case the track crosses the TRT in the way: Endcap, Barrel, Encap (including cosmics) - int beginBarrelRoad = 0; - int beginSecondEndcapRoad = 0; - // was the barrel already crossed? - bool barrelCrossed = false; - // start extrapolation with TrkParameters from Silicon, but don't touch the original - // object in case the shared ptr goes out of scope - std::shared_ptr<const Trk::TrackParameters> previousTrkPar(event_data.m_siliconTrkParams->uniqueClone()); - // loop over detElements - for(const auto & pThisDetectorElement: detElements) { - // propagate without boundary checks to detElement - std::shared_ptr<const Trk::TrackParameters> nextTrkPar = m_propagator->propagateParameters(ctx, - *previousTrkPar, pThisDetectorElement->surface(), - Trk::alongMomentum, false, m_fieldprop, Trk::nonInteracting); - if(!nextTrkPar) { - // propagate directly to this detElement and hope that the Fitter will do a better job: - ATH_MSG_DEBUG("step by step propagation of track parameters to TRT detector element failed: Try direct propagation (this may cause problems for the Fitter)"); - ATH_MSG_DEBUG("Problem was in " << pThisDetectorElement->type() <<" at (" << pThisDetectorElement->center().x() <<", "<< pThisDetectorElement->center().y() <<", "<< pThisDetectorElement->center().z() << ")" ); - nextTrkPar = m_propagator->propagateParameters(ctx,*event_data.m_siliconTrkParams, - pThisDetectorElement->surface(), Trk::alongMomentum, false, m_fieldprop, Trk::nonInteracting); - if (!nextTrkPar) { - ATH_MSG_WARNING("direct propagation of track parameters to TRT detector element failed:"); - ATH_MSG_WARNING(" this detector element will be dropped and RIOs on the road may be lost!"); - continue; - } - //return m_measurement; - } // end if !nextTrkPar - ATH_MSG_VERBOSE("propagated TrackParameters: ("<< nextTrkPar->position().x() <<", "<< nextTrkPar->position().y() <<", "<< nextTrkPar->position().z() << ") in detectorType: " << pThisDetectorElement->type() ); - - // append the detElement and the trkParameters to the vectors - event_data.m_detectorElements.push_back(pThisDetectorElement); - event_data.m_propagatedTrackParameters.push_back(nextTrkPar); - - // set the index if subdetector crossed: - if (pThisDetectorElement->type() == InDetDD::TRT_BaseElement::BARREL) { - if (!barrelCrossed) { - barrelCrossed = true; - beginBarrelRoad = event_data.m_detectorElements.size()-1; - } - } else { - if ( (barrelCrossed) && (beginSecondEndcapRoad == 0) ) { - //barrelCrossed = true; - beginSecondEndcapRoad = event_data.m_detectorElements.size()-1; - } - } - // prepare for next propagation - previousTrkPar = nextTrkPar; - } // end for loop over detElements - - ATH_MSG_DEBUG("Barrel Road starts at index "<< beginBarrelRoad << ", second Encap Road at "<< beginSecondEndcapRoad << " with a total of "<< event_data.m_detectorElements.size()<< " detElements" ); - bool anExtensionFailed{false}; - if (m_jo_simpleExtension) { - ATH_MSG_DEBUG("run the simpleExtension" ); - // ----------------- - // build the complete extension element-wise: - anExtensionFailed |= elementWiseExtension(0, event_data.m_detectorElements.size()-1,event_data); - } else { - // ----------------- - // build the extensions for the three road parts and combine them: - // endcap before barrel - if (beginBarrelRoad > 0) { - ATH_MSG_DEBUG("start processing of endcap road before barrel" ); - anExtensionFailed |= elementWiseExtension(0, beginBarrelRoad-1,event_data); - } else if (!barrelCrossed) { - ATH_MSG_DEBUG("start processing of endcap road (endcap only track)" ); - anExtensionFailed |= elementWiseExtension(0, event_data.m_detectorElements.size()-1,event_data); - } - // barrel - if (barrelCrossed and not(anExtensionFailed)) { - ATH_MSG_DEBUG("start processing of barrel road" ); - if (beginSecondEndcapRoad > 0) { - // endcap was reached after the barrel was crossed - anExtensionFailed |= groupedBarrelExtension(beginBarrelRoad, beginSecondEndcapRoad-1,event_data); - } else { - // after the barrel no endcap was hit - anExtensionFailed |= groupedBarrelExtension(beginBarrelRoad, event_data.m_detectorElements.size()-1,event_data); - } - } - // endcap after barrel - if ((beginSecondEndcapRoad > 0) and not(anExtensionFailed)) { - ATH_MSG_DEBUG("start processing of endcap road after barrel" ); - anExtensionFailed |= elementWiseExtension(beginSecondEndcapRoad, event_data.m_detectorElements.size()-1,event_data); - } - }// end if (simpleExtension) - - // did one of the extensions fail? - if (anExtensionFailed) { - ATH_MSG_WARNING("extensions failed: Return empty MeasurementBase vector" ); - // delete extension made so far - for(const auto *pThisROT : event_data.m_measurement) { - delete (pThisROT); - } - event_data.m_measurement.clear(); - } - // ------------------------------------------ - // delete all the propagated track parameters: - event_data.m_propagatedTrackParameters.clear(); - event_data.m_detectorElements.clear(); - ATH_MSG_DEBUG("** done: Made TRT extension with "<< event_data.m_measurement.size() << " CompetingTRT_DriftCirclesOnTrack"); - return event_data.m_measurement; -} - -/////////////////////////////////////////////////////////////////// -// find an element-wise extension (ie. the RIOs in a CompROT belong to one detElement) -/////////////////////////////////////////////////////////////////// - -bool -InDet::TRT_TrackExtensionTool_DAF::elementWiseExtension(int beginIndex, - int endIndex, - InDet::TRT_TrackExtensionTool_DAF::EventData &event_data) const -{ - const double squaredMaxBarrelRIOdistance = m_jo_roadwidth * m_jo_roadwidth; - const double squaredMaxEndcapRIOdistance = m_jo_roadwidth * m_jo_roadwidth; - double lastEndCapZ = -10000.; - // create a new list of RIOs - std::list< const Trk::PrepRawData * > RIOlist; - - ATH_MSG_DEBUG("looping over detElements" ); - // loop over detElements - for(int index = beginIndex; index <= endIndex; ++index) { - // ---------- - // global position of the track prediction - // get the global position of the track prediction on the detElement - Amg::Vector3D trkPos( event_data.m_propagatedTrackParameters[index]->position() ); - // ignore the z coordinate: - trkPos[Amg::z]=0.; - // determine the subdetector type - bool isBarrel = (event_data.m_detectorElements[index]->type() == InDetDD::TRT_BaseElement::BARREL); - bool createCompROT = true; - if (!isBarrel) { - if ( event_data.m_detectorElements[index]->surface().center().z() == lastEndCapZ ) { - // this detector element belongs to the same wheel, so we add its measurements to - // the previous group - createCompROT = false; - } else { - lastEndCapZ = event_data.m_detectorElements[index]->surface().center().z(); - } - } else { - lastEndCapZ = -10000.; - } - if ( (!RIOlist.empty()) && createCompROT ) { - ATH_MSG_DEBUG("try to create CompetingTRT_DriftCirclesOnTrackTool with " << RIOlist.size() << " RIOs" ); - const Trk::MeasurementBase* compROT = m_compROTcreator->createCompetingROT(RIOlist, *(event_data.m_propagatedTrackParameters[index-1]), m_jo_annealingFactor); - if (!compROT) { - ATH_MSG_WARNING("current CompetingTRT_DriftCirclesOnTrack could not be created:"); - ATH_MSG_WARNING(" the RIOs on this detElement will be skipped!"); - //continue; - } else { - // --------------- - // append the created compROT to the MeasurementBase vector: - event_data.m_measurement.push_back(compROT); - } - // RIOs were used in the CompetingROT, clear the list - RIOlist.clear(); - } - // ------------ - // Driftcircle collection and contained RIOs - ATH_MSG_VERBOSE("trying to get detElement for index "<< index ); - // get the id of the detElement - IdentifierHash detElementID = event_data.m_detectorElements[index]->identifyHash(); - // get the driftCircleCollection belonging to this id - const auto *container = event_data.m_trtcontainer->indexFindPtr(detElementID); - - if(container==nullptr) { - ATH_MSG_DEBUG("for the current detectorElement no DriftCircleContainer seems to exist"); - continue; - } - - ATH_MSG_DEBUG( "There are " << container->size() << " entries in the TRT_DriftCircleCollection" ); - // loop over RIOs in the collection - InDet::TRT_DriftCircleCollection::const_iterator driftCircleIterator = container->begin(); - for (; driftCircleIterator != container->end(); ++driftCircleIterator) { - // get the straw center of the RIO - Amg::Vector3D strawGlobPos( event_data.m_detectorElements[index]->center( (*driftCircleIterator)->identify() ) ); - ATH_MSG_DEBUG("straw center at: ("<< strawGlobPos.x() <<", "<< strawGlobPos.y() << ")" ); - strawGlobPos[Amg::z]=0.; - if (isBarrel) { - // calc squared distance in the x-y-plane - double distance = (trkPos - strawGlobPos).squaredNorm(); - ATH_MSG_DEBUG("distance in the x-y-plane: " << std::sqrt(distance) ); - // exclude RIOs too far from global track position on the detElement: - if ( distance > squaredMaxBarrelRIOdistance ) { - ATH_MSG_DEBUG("distance too large, RIO will be dropped." ); - continue; - } - } else { - // get the straw number for the straw axis - int straw = m_trtID->straw( (*driftCircleIterator)->identify() ); - // calc squared distance of straw and track prediction perpendicular to the straw axis - double distance = perp2(strawGlobPos-trkPos, event_data.m_detectorElements[index]->strawAxis(straw)); - ATH_MSG_DEBUG("distance perp. to straw axis: " << std::sqrt(distance) ); - - if ( distance > squaredMaxEndcapRIOdistance ) { - ATH_MSG_DEBUG("distance too large, RIO will be dropped." ); - continue; - } - } // end else (isBarrel) - // append the RIO to the RIO list - RIOlist.push_back((*driftCircleIterator)); - }// end for (loop over DriftCircles) - } // end for (loop over detElements) - if ( !RIOlist.empty() ) { - ATH_MSG_DEBUG("try to create CompetingTRT_DriftCirclesOnTrackTool with " << RIOlist.size() << " RIOs" ); - const Trk::MeasurementBase* compROT = m_compROTcreator->createCompetingROT(RIOlist, *(event_data.m_propagatedTrackParameters[endIndex]), m_jo_annealingFactor); - if (!compROT) { - ATH_MSG_WARNING("current CompetingTRT_DriftCirclesOnTrack could not be created:"); - ATH_MSG_WARNING(" the RIOs on this detElement will be skipped!"); - } else { - // --------------- - // append the created compROT to the MeasurementBase vector: - event_data.m_measurement.push_back(compROT); - } - } - return true; -} - -/////////////////////////////////////////////////////////////////// -// find a barrel extension with RIOs grouped along the globalPositions of the track -/////////////////////////////////////////////////////////////////// -bool -InDet::TRT_TrackExtensionTool_DAF::groupedBarrelExtension(int beginIndex, - int endIndex, - InDet::TRT_TrackExtensionTool_DAF::EventData &event_data) const -{ - - - // the pre-cut for RIOs (use twice the real road width): - const double squaredMaxRIOdistanceFromTrackOnDetElement = m_jo_roadwidth*m_jo_roadwidth*16; - - // ------------------- - // loop over the road elements and extract the global positions - // of the track prediction in the x-y-plane: - - std::vector<Amg::Vector3D*> trackGlobalPos; - trackGlobalPos.reserve(200); - - // index of the last global position belonging to the detElement - std::vector<int> detElementGlobPosIndex(event_data.m_propagatedTrackParameters.size(), 0); - - - ATH_MSG_DEBUG("looping over detElements between index " << beginIndex << " and " << endIndex << "to produce a list of global positions" ); - // do the first iteration manually to get the - // last global position - Amg::Vector3D* lastPos = new Amg::Vector3D( event_data.m_propagatedTrackParameters[beginIndex]->position() ); - ATH_MSG_VERBOSE("global position: ("<< lastPos->x() <<", "<< lastPos->y() << ")" ); - // ignore z coordinate (along the straw) - (*lastPos)[Amg::z]=0.; - trackGlobalPos.push_back( lastPos ); - detElementGlobPosIndex[beginIndex] = trackGlobalPos.size()-1; - - for(int index = beginIndex+1; index <= endIndex; ++index) { - // get the global track position and fill it into vectors - Amg::Vector3D* Pos = new Amg::Vector3D( event_data.m_propagatedTrackParameters[index]->position() ); - // ignore z coordinate (along the straw) - (*Pos)[Amg::z]=0.; - - double distance = ((*Pos) - (*lastPos)).norm(); - ATH_MSG_VERBOSE("global position: ("<< Pos->x() <<", "<< Pos->y() << ") -> distance to previous: "<< distance ); - if ( distance > m_jo_maxGroupDistance ) { - // distance between the global positions is too large: include more points - int numberOfPoints = int(distance / m_jo_maxGroupDistance); - Amg::Vector3D diffVector = (*Pos) - (*lastPos); - for (int i=1; i<=numberOfPoints; i++) { - Amg::Vector3D* newPos = new Amg::Vector3D( (*lastPos) + ((i / double(numberOfPoints+1)) * diffVector) ); - trackGlobalPos.push_back( newPos ); - ATH_MSG_VERBOSE("insert point with global position: ("<< newPos->x() <<", "<< newPos->y() << ")" ); - } - } - if (distance < m_jo_minGroupDistance){ - // ignore this global position - detElementGlobPosIndex[index] = trackGlobalPos.size()-1; - ATH_MSG_VERBOSE("ignore this global position"); - continue; - } - // append the Global Position and the related Index to the vector - trackGlobalPos.push_back( Pos ); - detElementGlobPosIndex[index] = trackGlobalPos.size()-1; - lastPos = Pos; - } - - // the vector which stores the grouped RIOs - std::vector< std::list< const Trk::PrepRawData* >* > groupedRIOs( trackGlobalPos.size(), nullptr ); - // the vector for grouped RIOs with the minimal distances to the secant - std::vector< double > groupedRIOsMinDistance( trackGlobalPos.size() ); - // the vector for grouped RIOs with the pointer to the RIO with the minimal distance - std::vector< const InDet::TRT_DriftCircle* > minDistanceRIO( trackGlobalPos.size(), nullptr ); - - ATH_MSG_DEBUG("looping over detElements to get the DriftCircles" ); - int createdGroupCounter=0; - - // loop over detElements - for(int index = beginIndex+1; index <= endIndex; ++index) { - ATH_MSG_VERBOSE("trying to get detElement for index "<< index ); - // get the id of the detElement - IdentifierHash detElementID = event_data.m_detectorElements[index]->identifyHash(); - // get the driftCircleCollection belonging to this id - const auto *container = event_data.m_trtcontainer->indexFindPtr(detElementID); - // loop over RIOs in the collection - if(container==nullptr) { - ATH_MSG_DEBUG("for the current detectorElement no DriftCircleContainer seems to exist"); - continue; - } - ATH_MSG_DEBUG( "There are " << container->size() << " entries in the TRT_DriftCircleCollection" ); - - InDet::TRT_DriftCircleCollection::const_iterator driftCircleIterator = container->begin(); - for (; driftCircleIterator != container->end(); ++driftCircleIterator) { - // get the straw center of the RIO - Amg::Vector3D strawGlobPos( event_data.m_detectorElements[index]->center( (*driftCircleIterator)->identify() ) ); - strawGlobPos[Amg::z]=0.; - - // -------------------------------- - // search for the closest track global position to the straw center: - // as a first try use the distance to the global pos of the track on the detElement - // index of the global position with the minimal distance: - unsigned int minDistIndex = detElementGlobPosIndex[index]; - //double minDistance = strawGlobPos.distance2(*(trackGlobalPos[minDistIndex])); - double minDistance = (*(trackGlobalPos[minDistIndex]) - strawGlobPos).squaredNorm(); - ATH_MSG_VERBOSE("global position of the RIO belonging to globPos index "<< minDistIndex <<" : ("<< strawGlobPos.x() <<", "<< strawGlobPos.y() << ") --> distance: " << std::sqrt(minDistance) ); - - // Perhaps already exclude RIOs too far from global track position on the detElement: - if ( minDistance > squaredMaxRIOdistanceFromTrackOnDetElement ) { - continue; - } - // search backward: - double newDistance = -1.; - for (int i = minDistIndex-1; i >= 0; i--) { - //newDistance = strawGlobPos.distance2(*(trackGlobalPos[i])); - newDistance = (*(trackGlobalPos[i]) - strawGlobPos).squaredNorm(); - if (newDistance < minDistance ) { - // new distance is smaller than the one we had before! - minDistIndex = i; - minDistance = newDistance; - } else { - // new distance is larger: stop backward search - break; - //i = 0; - } - } // end for (backward search) - if (newDistance == -1.) { - // backward serach did not succeed in finding a closer global position, try forward search - for (unsigned int i = minDistIndex+1; i < trackGlobalPos.size(); i++) { - newDistance = (*(trackGlobalPos[i]) - strawGlobPos).squaredNorm(); - if (newDistance < minDistance ) { - // new distance is smaller than the one we had before! - minDistIndex = i; - minDistance = newDistance; - } else { - // new distance is larger: stop forward search - break; - //i = trackGlobalPos.size(); - } - } // end for (forward search) - }// end if (nackward searched failed) - ATH_MSG_VERBOSE("nearest point with index "<< minDistIndex <<" : ("<< trackGlobalPos[minDistIndex]->x() <<", "<< trackGlobalPos[minDistIndex]->y() << ") --> distance:"<< sqrt(minDistance) ); - - // -------------- - // now that we found the global position with minimum distance, decide whether - // the RIO has to be sorted before or after this position. - int groupIndex = 0; - if (minDistIndex <= 0) { - // we can not go in front of this position - groupIndex = 0; - } else if (minDistIndex >= (trackGlobalPos.size()-1)) { - // we can not go beyond this position - groupIndex = trackGlobalPos.size()-2; - } else { - // distance to the point before the minimum - double distBeforeMin = (*(trackGlobalPos[minDistIndex-1]) - strawGlobPos).squaredNorm(); - // distance to the point after the minimum - double distAfterMin = (*(trackGlobalPos[minDistIndex+1]) - strawGlobPos).squaredNorm(); - if (distBeforeMin < distAfterMin) { - groupIndex = minDistIndex-1; - } else { - groupIndex = minDistIndex; - } - } - // ------------ - // now decide whether or not the RIO lies on the road - // calc the distance of the straw center to the secant - //double distToSecant = ((*(trackGlobalPos[groupIndex]))- (*(trackGlobalPos[groupIndex+1]))).perp( (strawGlobPos - (*(trackGlobalPos[groupIndex]))) ); - //double distToSecant = (strawGlobPos - (*(trackGlobalPos[groupIndex]))).perp( ((*(trackGlobalPos[groupIndex]))- (*(trackGlobalPos[groupIndex+1]))) ); - double distToSecant = std::sqrt(perp2(strawGlobPos - (*(trackGlobalPos[groupIndex])), ((*(trackGlobalPos[groupIndex]))- (*(trackGlobalPos[groupIndex+1]))) ) ); - ATH_MSG_VERBOSE(" belongs to group "<< groupIndex <<", distance to secant: "<< distToSecant ); - if (distToSecant > m_jo_roadwidth ) { - // ignore the current RIO - ATH_MSG_DEBUG("RIO too far from road: ignore" ); - continue; - } - // check whether the current group already contains some entries - if (groupedRIOs[groupIndex]) { - ATH_MSG_VERBOSE(" append RIO to group list " << groupIndex ); - // append the RIO to the RIO list of the current group - groupedRIOs[groupIndex]->push_back((*driftCircleIterator)); - // check if the current RIO is closer to the secant - if (distToSecant < groupedRIOsMinDistance[groupIndex] ) { - // put distance to secant in vector - groupedRIOsMinDistance[groupIndex] = distToSecant; - // put the RIO in the vector with the minimum distance RIOs - minDistanceRIO[groupIndex] = (*driftCircleIterator); - ATH_MSG_VERBOSE(" RIO has min. distance in the group" ); - } - } else { - // create a new list for this group - ATH_MSG_VERBOSE(" create a new RIO list for group " << groupIndex ); - createdGroupCounter++; - std::list< const Trk::PrepRawData* >* RIOlist = new std::list< const Trk::PrepRawData* >; - RIOlist->push_back((*driftCircleIterator)); - // put the list into the vector for RIO lists - groupedRIOs[groupIndex] = RIOlist; - // put distance to secant in vector - groupedRIOsMinDistance[groupIndex] = distToSecant; - // put the RIO in the vector with the minimum distance RIOs - minDistanceRIO[groupIndex] = (*driftCircleIterator); - } // end else (no list of RIOs for current group) - } // end for (loop over driftCircleContainer entries) - } // end for (loop over detElements) - - // -------- - // delete the global positions - std::vector< Amg::Vector3D* >::iterator globPosIterator = trackGlobalPos.begin(); - for (; globPosIterator != trackGlobalPos.end(); ++globPosIterator ) { - delete (*globPosIterator); - (*globPosIterator) = 0; - } - ATH_MSG_DEBUG("loop over groups to create CompetingRIOsOnTrack" ); - - int usedGroupCounter=0; - // -------------------------- - // create CompetingTRT_DriftCirclesOnTrack out of the groups - for(unsigned int groupIndex = 0; groupIndex < groupedRIOs.size(); ++groupIndex) { - // does a group exist for the current index? - if (!groupedRIOs[groupIndex]) { - // jump to the next group - continue; - } - // produce TrackParameters for the group - // get StraightLineSurface of the RIO closest to the prediction - const Trk::Surface& RIOsurface = minDistanceRIO[groupIndex]->detectorElement()->surface(minDistanceRIO[groupIndex]->identify()); - // propagate to this surface - auto TrkPar = m_propagator->propagateParameters(Gaudi::Hive::currentContext(), - *event_data.m_siliconTrkParams, RIOsurface, Trk::alongMomentum, - false, m_fieldprop, Trk::nonInteracting); - if (!TrkPar) { - ATH_MSG_WARNING("propagation of track parameters to the RIO surface failed:"); - ATH_MSG_WARNING(" this group of RIOs will skipped!"); - continue; - } - ATH_MSG_DEBUG("try to create CompetingTRT_DriftCirclesOnTrackTool with " << groupedRIOs[groupIndex]->size() << " RIOs" ); - - const Trk::MeasurementBase* compROT = m_compROTcreator->createCompetingROT(*groupedRIOs[groupIndex], *TrkPar, m_jo_annealingFactor); - if (!compROT) { - ATH_MSG_WARNING("current CompetingTRT_DriftCirclesOnTrack could not be created:"); - ATH_MSG_WARNING(" this group of RIOs will skipped!"); - // delete the trkParameters - //delete TrkPar; - continue; - } - // --------------- - // append the created compROT to the MeasurementBase vector: - // first we have to cast to the base class? - event_data.m_measurement.push_back(compROT); - // delete the propagated trkParams - //delete TrkPar; - usedGroupCounter++; - } // end for (loop over RIO groups) - ATH_MSG_DEBUG("Used " << usedGroupCounter << " from at total " << groupedRIOs.size() << " groups, should be used "<< createdGroupCounter); - - // delete the RIOlists - std::vector< std::list< const Trk::PrepRawData* >* >::iterator RIOlistIterator = groupedRIOs.begin(); - for (; RIOlistIterator != groupedRIOs.end(); ++RIOlistIterator ) { - // just delete the list, the entries (RIOs) belong to the driftcircle collection - delete (*RIOlistIterator); - (*RIOlistIterator) = 0; - } - - return true; -} - -/////////////////////////////////////////////////////////////////// -// Main methods for segment finding in TRT -/////////////////////////////////////////////////////////////////// -Trk::TrackSegment* -InDet::TRT_TrackExtensionTool_DAF::findSegment(const EventContext& /*ctx*/, - const Trk::TrackParameters *, - InDet::ITRT_TrackExtensionTool::IEventData &) const -{ - return nullptr; -} -/////////////////////////////////////////////////////////////////// -// Methods for track extension to TRT for pixles+sct tracks -// and new track production -/////////////////////////////////////////////////////////////////// - -Trk::Track* -InDet::TRT_TrackExtensionTool_DAF::newTrack(const EventContext& /*ctx*/, - const Trk::Track&, - InDet::ITRT_TrackExtensionTool::IEventData &) const -{ - return nullptr; -} diff --git a/InnerDetector/InDetRecTools/TRT_TrackExtensionTool_DAF/src/components/TRT_TrackExtensionTool_DAF_entries.cxx b/InnerDetector/InDetRecTools/TRT_TrackExtensionTool_DAF/src/components/TRT_TrackExtensionTool_DAF_entries.cxx deleted file mode 100644 index 2d4fefcfab63..000000000000 --- a/InnerDetector/InDetRecTools/TRT_TrackExtensionTool_DAF/src/components/TRT_TrackExtensionTool_DAF_entries.cxx +++ /dev/null @@ -1,4 +0,0 @@ -#include "TRT_TrackExtensionTool_DAF/TRT_TrackExtensionTool_DAF.h" - -DECLARE_COMPONENT( InDet::TRT_TrackExtensionTool_DAF ) - -- GitLab From 4a9612126745d053565da10cb6061e5a66612610 Mon Sep 17 00:00:00 2001 From: tstreble <thomas.strebler@cern.ch> Date: Thu, 21 Jul 2022 16:26:10 +0200 Subject: [PATCH 3/6] Removed unusued TrkCompetingRIOsOnTrackTool --- .../CMakeLists.txt | 16 - .../ATLAS_CHECK_THREAD_SAFETY | 1 - .../CompetingRIOsOnTrackTool.h | 135 -------- .../ICompetingRIOsOnTrackTool.h | 7 - .../doc/packagedoc.h | 28 -- .../src/CompetingRIOsOnTrackTool.cxx | 306 ------------------ .../CompetingRIOsOnTrackTool_entries.cxx | 5 - 7 files changed, 498 deletions(-) delete mode 100644 Tracking/TrkTools/TrkCompetingRIOsOnTrackTool/CMakeLists.txt delete mode 100644 Tracking/TrkTools/TrkCompetingRIOsOnTrackTool/TrkCompetingRIOsOnTrackTool/ATLAS_CHECK_THREAD_SAFETY delete mode 100755 Tracking/TrkTools/TrkCompetingRIOsOnTrackTool/TrkCompetingRIOsOnTrackTool/CompetingRIOsOnTrackTool.h delete mode 100755 Tracking/TrkTools/TrkCompetingRIOsOnTrackTool/TrkCompetingRIOsOnTrackTool/ICompetingRIOsOnTrackTool.h delete mode 100644 Tracking/TrkTools/TrkCompetingRIOsOnTrackTool/doc/packagedoc.h delete mode 100755 Tracking/TrkTools/TrkCompetingRIOsOnTrackTool/src/CompetingRIOsOnTrackTool.cxx delete mode 100644 Tracking/TrkTools/TrkCompetingRIOsOnTrackTool/src/components/CompetingRIOsOnTrackTool_entries.cxx diff --git a/Tracking/TrkTools/TrkCompetingRIOsOnTrackTool/CMakeLists.txt b/Tracking/TrkTools/TrkCompetingRIOsOnTrackTool/CMakeLists.txt deleted file mode 100644 index a04d34a38cc7..000000000000 --- a/Tracking/TrkTools/TrkCompetingRIOsOnTrackTool/CMakeLists.txt +++ /dev/null @@ -1,16 +0,0 @@ -# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration - -# Declare the package name: -atlas_subdir( TrkCompetingRIOsOnTrackTool ) - -atlas_add_library( TrkCompetingRIOsOnTrackToolLib - TrkCompetingRIOsOnTrackTool/*.h - INTERFACE - PUBLIC_HEADERS TrkCompetingRIOsOnTrackTool - LINK_LIBRARIES GaudiKernel AthenaBaseComps TrkToolInterfaces TrkParameters ) - -# Component(s) in the package: -atlas_add_component( TrkCompetingRIOsOnTrackTool - src/*.cxx - src/components/*.cxx - LINK_LIBRARIES GaudiKernel TrkCompetingRIOsOnTrackToolLib AthenaBaseComps TrkToolInterfaces AtlasDetDescr TrkSurfaces TrkCompetingRIOsOnTrack TrkEventUtils TrkParameters TrkPrepRawData TrkRIO_OnTrack ) diff --git a/Tracking/TrkTools/TrkCompetingRIOsOnTrackTool/TrkCompetingRIOsOnTrackTool/ATLAS_CHECK_THREAD_SAFETY b/Tracking/TrkTools/TrkCompetingRIOsOnTrackTool/TrkCompetingRIOsOnTrackTool/ATLAS_CHECK_THREAD_SAFETY deleted file mode 100644 index 1933c512d7c3..000000000000 --- a/Tracking/TrkTools/TrkCompetingRIOsOnTrackTool/TrkCompetingRIOsOnTrackTool/ATLAS_CHECK_THREAD_SAFETY +++ /dev/null @@ -1 +0,0 @@ -Tracking/TrkTools/TrkCompetingRIOsOnTrackTool diff --git a/Tracking/TrkTools/TrkCompetingRIOsOnTrackTool/TrkCompetingRIOsOnTrackTool/CompetingRIOsOnTrackTool.h b/Tracking/TrkTools/TrkCompetingRIOsOnTrackTool/TrkCompetingRIOsOnTrackTool/CompetingRIOsOnTrackTool.h deleted file mode 100755 index 8e8595be2df1..000000000000 --- a/Tracking/TrkTools/TrkCompetingRIOsOnTrackTool/TrkCompetingRIOsOnTrackTool/CompetingRIOsOnTrackTool.h +++ /dev/null @@ -1,135 +0,0 @@ -/* - Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration -*/ - -/////////////////////////////////////////////////////////////////// -// Header file for class CompetingRIOsOnTrackTool -/////////////////////////////////////////////////////////////////// -// (c) ATLAS Detector software -/////////////////////////////////////////////////////////////////// -// Tool for CompetingRIOsOnTrack creation -/////////////////////////////////////////////////////////////////// -// sebastian.fleischmann@cern.ch -/////////////////////////////////////////////////////////////////// - -#ifndef COMPETINGRIOSONTRACKTOOL_H -#define COMPETINGRIOSONTRACKTOOL_H -// Gaudi -#include "AthenaBaseComps/AthAlgTool.h" -#include "GaudiKernel/ToolHandle.h" -// Trk -#include "TrkToolInterfaces/ICompetingRIOsOnTrackTool.h" -#include "TrkParameters/TrackParameters.h" // typedef - -#include "TrkToolInterfaces/IWeightCalculator.h" // needed for IWeightCalculator::AnnealingFactor -// STL -#include <list> -//#include <vector> - -class AtlasDetectorID; - -namespace Trk { -class LocalParameters; -class ErrorMatrix; -class Surface; -class PrepRawData; -class MeasurementTypeID; -class CompetingRIOsOnTrack; - -/** @class CompetingRIOsOnTrackTool - @brief This tool creates Trk::CompetingRIOsOnTrack objects using a given - track hypothesis and a list of Trk::PrepRawData. - - When making the objects, it internally creates Trk::RIO_OnTrack objects - with the RIO_OnTrackTool. The creation is done by the underlying detector-specific - classes (e.g. InDet::CompetingTRT_DriftCirclesOnTrackTool). -*/ - -class CompetingRIOsOnTrackTool : public AthAlgTool, - virtual public Trk::ICompetingRIOsOnTrackTool { - /////////////////////////////////////////////////////////////////// - // Public methods: - /////////////////////////////////////////////////////////////////// - -public: - /** AlgTool Constructor */ - CompetingRIOsOnTrackTool(const std::string&,const std::string&,const IInterface*); - virtual ~CompetingRIOsOnTrackTool (); - /** AlgTool init */ - virtual StatusCode initialize(); - /** AlgTool finalize */ - virtual StatusCode finalize (); - - /** creation of a Trk::CompetingRIOsOnTrack from a list of Trk::PrepRawData - (which should be of the same type, otherwise they will be ignored). - - TrackParameters should be given in the frame of one of the PrepRawData - - the AnnealingFactor is given to the IWeightCalculator */ - virtual const Trk::CompetingRIOsOnTrack* createCompetingROT( - const std::list< const Trk::PrepRawData* >&, - const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor ) const; - - /** update of the assignment probabilities and effective measurements - of a Trk::CompetingRIOsOnTrack using a new track prediction. All calcs are done - by the detector-specific classes: - - Trk::IWeightCalculator is called first to recalculate the assignment probabilities - - the new effective measurements are calculated afterwards (this cannot be done by the - Trk::IWeightCalculator, because it has no detector specific knowledge) */ - virtual void updateCompetingROT( - Trk::CompetingRIOsOnTrack&, - const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor - // const bool recreateROTs=false - ) const; - - /** update of the assignment probabilities - and effective measurements of a Trk::CompetingRIOsOnTrack using - a given set of assignment probabilities */ - virtual StatusCode updateCompetingROTprobs( - Trk::CompetingRIOsOnTrack&, - const std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >& - ) const; - - virtual const Trk::CompetingRIOsOnTrack* createSimpleCompetingROT( - const Trk::PrepRawData&, - const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor, - const Trk::TrackState::MeasurementType=Trk::TrackState::unidentified) const; - - virtual void reequipCompetingROT(Trk::CompetingRIOsOnTrack*&, - const Trk::RIO_OnTrack*, - const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor, - const Trk::TrackState::MeasurementType - = Trk::TrackState::unidentified) const; - - -private: - - /////////////////////////////////////////////////////////////////// - // Private data: - /////////////////////////////////////////////////////////////////// - - //! helper to find out the sub-det from PRD->identify() - const AtlasDetectorID* m_idHelper; - MeasurementTypeID* m_mbHelper; //!< wrapper around above helper - - // the sub-detector tools: - - // the job option control for the tools: - - //! specific competingROT creation for PixelClusters - ToolHandle< ICompetingRIOsOnTrackTool > m_compPixelToolHandle; - ICompetingRIOsOnTrackTool* m_compPixelTool; - //! specific competingROT creation for SCT_Clusters - ToolHandle< ICompetingRIOsOnTrackTool > m_compSCT_Tool; - //! det-specific competingROT creation for TRT - ToolHandle< ICompetingRIOsOnTrackTool > m_compTRT_Tool; - //! Det-specific competingROT creation for MDT - ToolHandle< ICompetingRIOsOnTrackTool > m_compMuonDriftCircleTool; - //! Det-specific competingROT creation for TGC, RPC and CSC - ToolHandle< ICompetingRIOsOnTrackTool > m_compMuonClusterTool; - -}; -} // end of namespace Trk -#endif // COMPETINGRIOSONTRACKTOOL_H diff --git a/Tracking/TrkTools/TrkCompetingRIOsOnTrackTool/TrkCompetingRIOsOnTrackTool/ICompetingRIOsOnTrackTool.h b/Tracking/TrkTools/TrkCompetingRIOsOnTrackTool/TrkCompetingRIOsOnTrackTool/ICompetingRIOsOnTrackTool.h deleted file mode 100755 index 4f36f32f3106..000000000000 --- a/Tracking/TrkTools/TrkCompetingRIOsOnTrackTool/TrkCompetingRIOsOnTrackTool/ICompetingRIOsOnTrackTool.h +++ /dev/null @@ -1,7 +0,0 @@ -/* - Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration -*/ - -/* forward-declaration, remove ASAP */ - -#include "TrkToolInterfaces/ICompetingRIOsOnTrackTool.h" diff --git a/Tracking/TrkTools/TrkCompetingRIOsOnTrackTool/doc/packagedoc.h b/Tracking/TrkTools/TrkCompetingRIOsOnTrackTool/doc/packagedoc.h deleted file mode 100644 index ac6b377bee37..000000000000 --- a/Tracking/TrkTools/TrkCompetingRIOsOnTrackTool/doc/packagedoc.h +++ /dev/null @@ -1,28 +0,0 @@ -/* - Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration -*/ - -/** -@page TrkCompetingRIOsOnTrackTool_page The TrkCompetingRIOsOnTrackTool package -The package for CompetingRIOsOnTrack creation. - -@author Sebastian.Fleischmann@cern.ch - -@section TrkCompetingRIOsOnTrackTool_introductionTrkCompetingRIOsOnTrackTool Introduction - -This package contains the tools to create Trk::CompetingRIOsOnTrack. This includes - creation of the RIO_OnTrack objects with the corresponding tools. - The actual calculations are not done in this package, but are - delegated to the detector-specific packages. - -@section TrkCompetingRIOsOnTrackTool_TrkCompetingRIOsOnTrackToolOverview Class Overview - The TrkCompetingRIOsOnTrackTool package contains the following classes: - - - Trk::ICompetingRIOsOnTrackTool : Interface class for CompetingRIOsOnTrackTools. - - Trk::CompetingRIOsOnTrackTool : creates Trk::CompetingRIOsOnTrack objects using a given - track hypothesis and a list of Trk::PrepRawData using the detector specific sub-tool. - - Trk::IWeightCalculator : Interface class for WeightCalculators, which compute the assignment probabilities of competing measurements to a track - -@section TrkCompetingRIOsOnTrackTool_ExtrasTrkCompetingRIOsOnTrackTool Extra Pages - -*/ diff --git a/Tracking/TrkTools/TrkCompetingRIOsOnTrackTool/src/CompetingRIOsOnTrackTool.cxx b/Tracking/TrkTools/TrkCompetingRIOsOnTrackTool/src/CompetingRIOsOnTrackTool.cxx deleted file mode 100755 index ca1fc1233db8..000000000000 --- a/Tracking/TrkTools/TrkCompetingRIOsOnTrackTool/src/CompetingRIOsOnTrackTool.cxx +++ /dev/null @@ -1,306 +0,0 @@ -/* - Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration -*/ - -/////////////////////////////////////////////////////////////////// -// Implementation file for class CompetingRIOsOnTrackTool -/////////////////////////////////////////////////////////////////// -// (c) ATLAS Detector software -/////////////////////////////////////////////////////////////////// -// Tool for CompetingRIOsOnTrack creation -/////////////////////////////////////////////////////////////////// -// sebastian.fleischmann@cern.ch -/////////////////////////////////////////////////////////////////// - -#include "AtlasDetDescr/AtlasDetectorID.h" -#include "TrkCompetingRIOsOnTrackTool/CompetingRIOsOnTrackTool.h" -#include "TrkCompetingRIOsOnTrack/CompetingRIOsOnTrack.h" -#include "TrkPrepRawData/PrepRawData.h" -#include "TrkSurfaces/StraightLineSurface.h" -#include "TrkEventUtils/MeasurementTypeID.h" -#include "TrkRIO_OnTrack/RIO_OnTrack.h" - -/////////////////////////////////////////////////////////////////// -// Constructor -/////////////////////////////////////////////////////////////////// - -Trk::CompetingRIOsOnTrackTool::CompetingRIOsOnTrackTool( - const std::string& ty, - const std::string& na, - const IInterface* pa ) : - AthAlgTool(ty,na,pa), - m_idHelper{}, - m_mbHelper{}, - m_compPixelToolHandle("InDet::CompetingPixelClustersOnTrackTool/CompetingPixelClustersOnTrackTool"), - m_compPixelTool{}, - m_compSCT_Tool("InDet::CompetingSCT_ClustersOnTrackTool/CompetingSCT_ClustersOnTrackTool"), - m_compTRT_Tool("InDet::CompetingTRT_DriftCirclesOnTrackTool/CompetingTRT_DriftCirclesOnTrackTool"), - m_compMuonDriftCircleTool(""), - m_compMuonClusterTool("") { - - declareInterface<ICompetingRIOsOnTrackTool>(this); - declareProperty("ToolForCompPixelClusters", m_compPixelToolHandle, "CompetingPixelClustersOnTrackTool"); - declareProperty("ToolForCompSCT_Clusters", m_compSCT_Tool, "CompetingSCT_ClustersOnTrackTool"); - declareProperty("ToolForCompTRT_DriftCircles", m_compTRT_Tool, "CompetingTRT_DriftCirclesOnTrackTool"); - declareProperty("ToolForCompMuonDriftCircles", m_compMuonDriftCircleTool,"CompetingMuonDriftCirclesOnTrackTool"); - declareProperty("ToolForCompMuonClusters", m_compMuonClusterTool, "CompetingMuonClustersOnTrackTool"); -} - -/////////////////////////////////////////////////////////////////// -// Destructor -/////////////////////////////////////////////////////////////////// - -Trk::CompetingRIOsOnTrackTool::~CompetingRIOsOnTrackTool() = default; - -/////////////////////////////////////////////////////////////////// -// Initialization -/////////////////////////////////////////////////////////////////// - -StatusCode Trk::CompetingRIOsOnTrackTool::initialize() { - - StatusCode sc = AthAlgTool::initialize(); - if (sc.isFailure()) return sc; - - // --- Get the tool to create Competing SiClusters on Track - if ( ! m_compPixelToolHandle.empty() ) { - IAlgTool* p; - sc=toolSvc()->retrieveTool(m_compPixelToolHandle.type(),m_compPixelToolHandle.name(),p); - if(sc.isFailure()) { - ATH_MSG_FATAL( "Could not retrieve the Pixel tool: "<< m_compPixelToolHandle ); - return sc; - } - m_compPixelTool = dynamic_cast<Trk::ICompetingRIOsOnTrackTool*>(p); - if (!m_compPixelTool) { - ATH_MSG_FATAL("Tool is not a ICompetingRIOsOnTrackTool!"); - return StatusCode::FAILURE; - } - } else { - ATH_MSG_DEBUG("No Tool for making CompetingPixelClustersOnTrack given."); - m_compPixelTool = nullptr; - } - - if ( ! m_compSCT_Tool.empty() ) { - ATH_CHECK(m_compSCT_Tool.retrieve()); - } - - /* Get the tool to create competing TRT_DriftCircles on Track - */ - if ( ! m_compTRT_Tool.empty() ) { - ATH_CHECK(m_compTRT_Tool.retrieve()); - } - - /* Get the tool to create competing MuonDriftCircles (MDT) on Track - */ - if ( ! m_compMuonDriftCircleTool.empty() ) { - ATH_CHECK (m_compMuonDriftCircleTool.retrieve()); - } - - /* Get the tool to create Competing CSC / RPC / TGC Clusters on Track - */ - if ( ! m_compMuonClusterTool.empty() ) { - ATH_CHECK (m_compMuonClusterTool.retrieve()); - } - - // Set up ATLAS ID helper to be able to identify the RIO's det-subsystem. - ATH_CHECK (detStore()->retrieve(m_idHelper, "AtlasID")); - m_mbHelper = new MeasurementTypeID(m_idHelper); - - ATH_MSG_DEBUG( " initialize() successful in " << name() ); - return StatusCode::SUCCESS; - -} - -/////////////////////////////////////////////////////////////////// -// Finalize -/////////////////////////////////////////////////////////////////// - -StatusCode Trk::CompetingRIOsOnTrackTool::finalize() { - StatusCode sc = AlgTool::finalize(); - delete m_mbHelper; - return sc; -} - -/////////////////////////////////////////////////////////////////// -// General Trk::CompetingRIOsOnTrack production -/////////////////////////////////////////////////////////////////// -const Trk::CompetingRIOsOnTrack* Trk::CompetingRIOsOnTrackTool::createCompetingROT( - const std::list< const Trk::PrepRawData* >& RIO_List, - const Trk::TrackParameters& trkPar, - const Trk::IWeightCalculator::AnnealingFactor beta ) const { - - - // identify by first RIO in list (if list is not genuine it is not my problem) - Identifier id = (*(RIO_List.begin()))->identify(); - ATH_MSG_VERBOSE("first RIO ID prints as " <<m_idHelper->print_to_string(id)); - - if (m_idHelper->is_pixel(id) && m_compPixelTool) - return m_compPixelTool->createCompetingROT(RIO_List, trkPar, beta); - - if (m_idHelper->is_sct(id) && !m_compSCT_Tool.empty()) - return m_compSCT_Tool->createCompetingROT(RIO_List, trkPar, beta); - - if (m_idHelper->is_trt(id) && !m_compTRT_Tool.empty()) - return m_compTRT_Tool->createCompetingROT(RIO_List, trkPar, beta); - - if (m_idHelper->is_mdt(id) && !m_compMuonDriftCircleTool.empty()) - return m_compMuonDriftCircleTool->createCompetingROT(RIO_List, trkPar, beta); - - if ( (m_idHelper->is_csc(id) || m_idHelper->is_rpc(id) || m_idHelper->is_tgc(id)) - && !m_compMuonClusterTool.empty()) - return m_compMuonClusterTool->createCompetingROT(RIO_List, trkPar, beta); - - - // --- if we arrive here, the necessary sub-tool is not given or the identifier invalid - // --- this is not necessarily a problem or a wrong configuration, e.g. the DAF can - // --- operate in a mode, where annealing is just performed for some of the sub-detectors - // simply return a NULL pointer: - return nullptr; - -} - - -/////////////////////////////////////////////////////////////////// -// Trk::CompetingRIOsOnTrack update -/////////////////////////////////////////////////////////////////// -void Trk::CompetingRIOsOnTrackTool::updateCompetingROT( - Trk::CompetingRIOsOnTrack& compROT, - const Trk::TrackParameters& trkPar, - const Trk::IWeightCalculator::AnnealingFactor beta - //const bool recreateROTs=false -) const { - - - // identify by first ROT of the competing ROTs - Identifier id = compROT.rioOnTrack(0).identify(); - ATH_MSG_VERBOSE("first ROT ID prints as " << m_idHelper->print_to_string(id)); - - if (m_idHelper->is_pixel(id) && m_compPixelTool) - return m_compPixelTool->updateCompetingROT(compROT, trkPar, beta); - - if (m_idHelper->is_sct(id) && !m_compSCT_Tool.empty()) - return m_compSCT_Tool->updateCompetingROT(compROT, trkPar, beta); - - if (m_idHelper->is_trt(id) && !m_compTRT_Tool.empty()) - return m_compTRT_Tool->updateCompetingROT(compROT, trkPar, beta); - - if (m_idHelper->is_mdt(id) && !m_compMuonDriftCircleTool.empty()) - return m_compMuonDriftCircleTool->updateCompetingROT(compROT, trkPar, beta); - - if ( (m_idHelper->is_csc(id) || m_idHelper->is_rpc(id) || m_idHelper->is_tgc(id)) - && !m_compMuonClusterTool.empty()) - return m_compMuonClusterTool->updateCompetingROT(compROT, trkPar, beta); - - // --- if we arrive here, the necessary sub-tool is not given or the identifier invalid - // --- this should not happen: once we created a CompetingROT, we should be able to update - // --- its assignment probabilities - ATH_MSG_WARNING( "could not identify CompetingROT as one of those with a detector-specific tool given!"); - ATH_MSG_WARNING( "PRD with identifier " << m_idHelper->print_to_string(id)); -} - -StatusCode Trk::CompetingRIOsOnTrackTool::updateCompetingROTprobs( - Trk::CompetingRIOsOnTrack& compROT, - const std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >& assignmentProbs - ) const { - // identify by first ROT of the competing ROTs - Identifier id = compROT.rioOnTrack(0).identify(); - ATH_MSG_VERBOSE("first ROT ID prints as " << m_idHelper->print_to_string(id)); - - if (m_idHelper->is_pixel(id) && m_compPixelTool) - return m_compPixelTool->updateCompetingROTprobs(compROT, assignmentProbs); - - if (m_idHelper->is_sct(id) && !m_compSCT_Tool.empty()) - return m_compSCT_Tool->updateCompetingROTprobs(compROT, assignmentProbs); - - if (m_idHelper->is_trt(id) && !m_compTRT_Tool.empty()) - return m_compTRT_Tool->updateCompetingROTprobs(compROT, assignmentProbs); - - if (m_idHelper->is_mdt(id) && !m_compMuonDriftCircleTool.empty()) - return m_compMuonDriftCircleTool->updateCompetingROTprobs(compROT, assignmentProbs); - - if ( (m_idHelper->is_csc(id) || m_idHelper->is_rpc(id) || m_idHelper->is_tgc(id)) - && !m_compMuonClusterTool.empty()) - return m_compMuonClusterTool->updateCompetingROTprobs(compROT, assignmentProbs); - - // --- if we arrive here, the necessary sub-tool is not given or the identifier invalid - // --- this should not happen: once we created a CompetingROT, we should be able to update - // --- its assignment probabilities - ATH_MSG_WARNING( "could not identify CompetingROT as one of those with a detector-specific tool given!"); - ATH_MSG_WARNING( "PRD with identifier " << m_idHelper->print_to_string(id)); - return StatusCode::FAILURE; -} - -/////////////////////////////////////////////////////////////////// -// Simplified Trk::CompetingRIOsOnTrack production (1 channel per CompROT) -/////////////////////////////////////////////////////////////////// -const Trk::CompetingRIOsOnTrack* -Trk::CompetingRIOsOnTrackTool::createSimpleCompetingROT - (const Trk::PrepRawData& prd, - const Trk::TrackParameters& trkPar, - const Trk::IWeightCalculator::AnnealingFactor beta, - const Trk::TrackState::MeasurementType mtype) const -{ - Identifier id = prd.identify(); - - if (mtype == Trk::TrackState::Pixel - || (mtype==Trk::TrackState::unidentified && m_idHelper->is_pixel(id)) ) { - if (!m_compPixelTool) return nullptr; - std::list< const Trk::PrepRawData* > plist; - plist.push_back(&prd); - return m_compPixelTool->createCompetingROT(plist,trkPar,beta); - } - if (mtype == Trk::TrackState::SCT - || (mtype==Trk::TrackState::unidentified && m_idHelper->is_sct(id)) ) { - if (m_compSCT_Tool.empty()) return nullptr; - std::list< const Trk::PrepRawData* > plist; - plist.push_back(&prd); - return m_compSCT_Tool->createCompetingROT(plist,trkPar,beta); - } - if (mtype == Trk::TrackState::TRT - || (mtype==Trk::TrackState::unidentified && m_idHelper->is_trt(id)) ) - return (m_compTRT_Tool.empty() ? nullptr : - m_compTRT_Tool->createSimpleCompetingROT(prd,trkPar,beta) ); - - if (mtype == Trk::TrackState::MDT - || (mtype==Trk::TrackState::unidentified && m_idHelper->is_mdt(id)) ) - return (m_compMuonDriftCircleTool.empty() ? nullptr : - m_compMuonDriftCircleTool->createSimpleCompetingROT(prd,trkPar,beta)); - - return (m_compMuonClusterTool.empty() ? nullptr : - m_compMuonClusterTool->createSimpleCompetingROT(prd,trkPar,beta)); -} - -void Trk::CompetingRIOsOnTrackTool::reequipCompetingROT -(Trk::CompetingRIOsOnTrack*& modifiableCompROT, - const Trk::RIO_OnTrack* newROT, - const Trk::TrackParameters& trkPar, - const Trk::IWeightCalculator::AnnealingFactor beta, - const Trk::TrackState::MeasurementType mtype) const -{ - if (!newROT) { - ATH_MSG_WARNING( "inconsistency with use of reequipCompetingROT() !" ); - return; - } - Identifier id = newROT->identify(); - - if (mtype == Trk::TrackState::Pixel - || (mtype==Trk::TrackState::unidentified && m_idHelper->is_pixel(id)) ) { - if (!m_compPixelTool) return; - m_compPixelTool->reequipCompetingROT(modifiableCompROT, newROT, trkPar, beta); - return; - } - - if (mtype == Trk::TrackState::SCT - || (mtype==Trk::TrackState::unidentified && m_idHelper->is_sct(id)) ) { - if (m_compSCT_Tool.empty()) return; - m_compSCT_Tool->reequipCompetingROT(modifiableCompROT, newROT, trkPar, beta); - return; - } - - if (mtype == Trk::TrackState::TRT - || (mtype==Trk::TrackState::unidentified && m_idHelper->is_trt(id)) ) { - if (m_compTRT_Tool.empty()) return; - m_compTRT_Tool->reequipCompetingROT(modifiableCompROT, newROT, trkPar, beta); - return; - } - -} diff --git a/Tracking/TrkTools/TrkCompetingRIOsOnTrackTool/src/components/CompetingRIOsOnTrackTool_entries.cxx b/Tracking/TrkTools/TrkCompetingRIOsOnTrackTool/src/components/CompetingRIOsOnTrackTool_entries.cxx deleted file mode 100644 index ac61e9120bb0..000000000000 --- a/Tracking/TrkTools/TrkCompetingRIOsOnTrackTool/src/components/CompetingRIOsOnTrackTool_entries.cxx +++ /dev/null @@ -1,5 +0,0 @@ -#include "TrkCompetingRIOsOnTrackTool/CompetingRIOsOnTrackTool.h" - -using namespace Trk; -DECLARE_COMPONENT( CompetingRIOsOnTrackTool ) - -- GitLab From 791d7a56c0eee0729340b4f500854f70fa70ad51 Mon Sep 17 00:00:00 2001 From: tstreble <thomas.strebler@cern.ch> Date: Thu, 21 Jul 2022 16:52:27 +0200 Subject: [PATCH 4/6] Cleaned unused interfaces --- .../MuonCompetingClustersOnTrackCreator.cxx | 1 - .../src/MuonCompetingClustersOnTrackCreator.h | 23 --- .../src/TriggerChamberClusterOnTrackCreator.h | 23 --- .../IMuonCompetingClustersOnTrackCreator.h | 6 +- .../ICompetingRIOsOnTrackTool.h | 131 ------------------ .../TrkToolInterfaces/IWeightCalculator.h | 92 ------------ 6 files changed, 3 insertions(+), 273 deletions(-) delete mode 100755 Tracking/TrkTools/TrkToolInterfaces/TrkToolInterfaces/ICompetingRIOsOnTrackTool.h delete mode 100755 Tracking/TrkTools/TrkToolInterfaces/TrkToolInterfaces/IWeightCalculator.h diff --git a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MuonCompetingClustersOnTrackCreator/src/MuonCompetingClustersOnTrackCreator.cxx b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MuonCompetingClustersOnTrackCreator/src/MuonCompetingClustersOnTrackCreator.cxx index f049da3802d4..8bf01133d894 100644 --- a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MuonCompetingClustersOnTrackCreator/src/MuonCompetingClustersOnTrackCreator.cxx +++ b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MuonCompetingClustersOnTrackCreator/src/MuonCompetingClustersOnTrackCreator.cxx @@ -31,7 +31,6 @@ namespace Muon { { // algtool interface - necessary! declareInterface<IMuonCompetingClustersOnTrackCreator>(this); - declareInterface<Trk::ICompetingRIOsOnTrackTool>(this); } StatusCode MuonCompetingClustersOnTrackCreator::initialize() diff --git a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MuonCompetingClustersOnTrackCreator/src/MuonCompetingClustersOnTrackCreator.h b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MuonCompetingClustersOnTrackCreator/src/MuonCompetingClustersOnTrackCreator.h index b03e566ae206..64e564cf5293 100644 --- a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MuonCompetingClustersOnTrackCreator/src/MuonCompetingClustersOnTrackCreator.h +++ b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MuonCompetingClustersOnTrackCreator/src/MuonCompetingClustersOnTrackCreator.h @@ -28,29 +28,6 @@ namespace Muon { MuonCompetingClustersOnTrackCreator(const std::string&,const std::string&,const IInterface*); virtual ~MuonCompetingClustersOnTrackCreator()=default; virtual StatusCode initialize(); - - /** method for the creation of a single - Trk::CompetingRIOsOnTrack: - It takes a list of RIOs (PrepRawData) and the given Track - Parameter, cutValue defines - the cut used for calculating the initial assignment probabilities - (see Trk::IWeightCalculator). Not implemented for now!! - */ - const Trk::CompetingRIOsOnTrack* createCompetingROT(const std::list< const Trk::PrepRawData * > &, - const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor ) const - { - return 0; - } - - /** method for the update of the assignment - probabilities and effective measurements - of an Muon::CompetingMuonClustersOnTrack using a new track prediction. Not implemented for now!! */ - void updateCompetingROT( Trk::CompetingRIOsOnTrack&, - const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor ) const - { - } /** method to create a CompetingMuonClustersOnTrack using the PrepRawData hits and a scaled factor for the errors */ std::unique_ptr<const CompetingMuonClustersOnTrack> diff --git a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MuonCompetingClustersOnTrackCreator/src/TriggerChamberClusterOnTrackCreator.h b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MuonCompetingClustersOnTrackCreator/src/TriggerChamberClusterOnTrackCreator.h index bf286df06b1c..0987967c0499 100644 --- a/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MuonCompetingClustersOnTrackCreator/src/TriggerChamberClusterOnTrackCreator.h +++ b/MuonSpectrometer/MuonReconstruction/MuonRIO_OnTrackCreators/MuonCompetingClustersOnTrackCreator/src/TriggerChamberClusterOnTrackCreator.h @@ -37,29 +37,6 @@ public: virtual ~TriggerChamberClusterOnTrackCreator()=default; StatusCode initialize(); - - /** method for the creation of a single - Trk::CompetingRIOsOnTrack: - It takes a list of RIOs (PrepRawData) and the given Track - Parameter, cutValue defines - the cut used for calculating the initial assignment probabilities - (see Trk::IWeightCalculator). Not implemented for now!! - */ - const Trk::CompetingRIOsOnTrack* createCompetingROT(const std::list< const Trk::PrepRawData* > &, - const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor ) const - { - return 0; - } - - /** method for the update of the assignment - probabilities and effective measurements - of an Muon::CompetingMuonClustersOnTrack using a new track prediction. Not implemented for now!! */ - void updateCompetingROT( Trk::CompetingRIOsOnTrack&, - const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor ) const - { - } /** method to create a CompetingMuonClustersOnTrack using the PrepRawData hits and a scaled factor for the errors */ std::unique_ptr<const CompetingMuonClustersOnTrack> diff --git a/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/MuonRecToolInterfaces/IMuonCompetingClustersOnTrackCreator.h b/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/MuonRecToolInterfaces/IMuonCompetingClustersOnTrackCreator.h index 928373b4099f..c181bee50158 100755 --- a/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/MuonRecToolInterfaces/IMuonCompetingClustersOnTrackCreator.h +++ b/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/MuonRecToolInterfaces/IMuonCompetingClustersOnTrackCreator.h @@ -8,7 +8,7 @@ #include <list> #include <memory> -#include "TrkCompetingRIOsOnTrackTool/ICompetingRIOsOnTrackTool.h" +#include "GaudiKernel/IAlgTool.h" static const InterfaceID IID_IMuonCompetingClustersOnTrackCreator("Muon::IMuonCompetingClustersOnTrackCreator", 1, 0); @@ -20,9 +20,9 @@ namespace Muon { class CompetingMuonClustersOnTrack; - /** @brief Interface for tools creating CompetingMuonClustersOnTrack objects, inherits from ICompetingRIOsOnTrackTool. + /** @brief Interface for tools creating CompetingMuonClustersOnTrack objects */ - class IMuonCompetingClustersOnTrackCreator : virtual public Trk::ICompetingRIOsOnTrackTool { + class IMuonCompetingClustersOnTrackCreator : virtual public IAlgTool { public: static const InterfaceID& interfaceID(); diff --git a/Tracking/TrkTools/TrkToolInterfaces/TrkToolInterfaces/ICompetingRIOsOnTrackTool.h b/Tracking/TrkTools/TrkToolInterfaces/TrkToolInterfaces/ICompetingRIOsOnTrackTool.h deleted file mode 100755 index 0a0e57078f82..000000000000 --- a/Tracking/TrkTools/TrkToolInterfaces/TrkToolInterfaces/ICompetingRIOsOnTrackTool.h +++ /dev/null @@ -1,131 +0,0 @@ -/* - Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration -*/ - -/////////////////////////////////////////////////////////////////// -// Header file for class ICompetingRIOsOnTrackTool -/////////////////////////////////////////////////////////////////// -// (c) ATLAS Detector software -/////////////////////////////////////////////////////////////////// -// Interface class for CompetingRIOsOnTrack creation -/////////////////////////////////////////////////////////////////// -// sebastian.fleischmann@cern.ch -/////////////////////////////////////////////////////////////////// - -#ifndef TRK_ICOMPETINGRIOSONTRACKTOOL_H -#define TRK_ICOMPETINGRIOSONTRACKTOOL_H - -#include "GaudiKernel/IAlgTool.h" -#include "TrkParameters/TrackParameters.h" // typedef -// needed for typedef of AnnealingFactor: -#include "TrkToolInterfaces/IWeightCalculator.h" -#include "TrkEventPrimitives/TrackStateDefs.h" -// STL -#include <list> - -/** @class ICompetingRIOsOnTrackTool - @brief This class provides the interface for tools that create - Trk::CompetingRIOsOnTrack objects using a given - track hypothesis and a list of Trk::PrepRawData. - - @author Sebastian Fleischmann -*/ - -namespace Trk { - -class PrepRawData; -class CompetingRIOsOnTrack; -class RIO_OnTrack; - -static const InterfaceID IID_ICompetingRIOsOnTrackTool("ICompetingRIOsOnTrackTool",1,0); - - -class ICompetingRIOsOnTrackTool : virtual public IAlgTool { - /////////////////////////////////////////////////////////////////// - // Public methods: - /////////////////////////////////////////////////////////////////// - -public: - - static const InterfaceID& interfaceID() { - return IID_ICompetingRIOsOnTrackTool; - } //!< The AlgTool InterfaceID - - /** @brief abstract base method for making a Trk::CompetingRIOsOnTrack object. - - It takes a list of RIOs (PrepRawData) and the given Track Parameter, cutValue - defines the cut used for calculating the initial assignment probabilities - (see Trk::IWeightCalculator). - */ - virtual const Trk::CompetingRIOsOnTrack* createCompetingROT( - const std::list< const Trk::PrepRawData * > &, - const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor ) const = 0; // pure virtual - - /** @brief abstract base method for the update of the assignment probabilities - and effective measurements of a Trk::CompetingRIOsOnTrack using a new track - prediction. */ - virtual void updateCompetingROT( - Trk::CompetingRIOsOnTrack&, - const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor - ) const = 0; - - /** @brief update of the assignment probabilities - and effective measurements of a Trk::CompetingRIOsOnTrack using - a given set of assignment probabilities */ - virtual StatusCode updateCompetingROTprobs( - Trk::CompetingRIOsOnTrack&, - const std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >& - ) const; - - /** making of simple competing ROT (i.e. which competes against outlier hypothesis) */ - virtual const Trk::CompetingRIOsOnTrack* createSimpleCompetingROT( - const Trk::PrepRawData&, - const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor, - const Trk::TrackState::MeasurementType=Trk::TrackState::unidentified) const; - - /** write documentation! */ - virtual void reequipCompetingROT(Trk::CompetingRIOsOnTrack*&, - const Trk::RIO_OnTrack*, - const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor, - const Trk::TrackState::MeasurementType - = Trk::TrackState::unidentified) const; - -}; -} // end of namespace Trk - -inline StatusCode Trk::ICompetingRIOsOnTrackTool::updateCompetingROTprobs( - Trk::CompetingRIOsOnTrack&, - const std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >& - ) const { - std::cout << "CONFIGURATION WARNING: dummy version of CompetingRIOsOnTrack update called." << std::endl; - return StatusCode::FAILURE; -} - - -inline const Trk::CompetingRIOsOnTrack* Trk::ICompetingRIOsOnTrackTool::createSimpleCompetingROT -( const Trk::PrepRawData&, const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor, - const Trk::TrackState::MeasurementType) const -{ - std::cout << "CONFIGURATION WARNING: dummy version of single-hit CompetingRIOsOnTrack maker called." << std::endl; - return nullptr; -} - -inline void Trk::ICompetingRIOsOnTrackTool::reequipCompetingROT -( Trk::CompetingRIOsOnTrack*&, - const Trk::RIO_OnTrack*, - const Trk::TrackParameters&, - const Trk::IWeightCalculator::AnnealingFactor, - const Trk::TrackState::MeasurementType) const -{ - std::cout << "CONFIGURATION WARNING: dummy version of single-hit CompROT re-equipping called." << std::endl; -} - - - - -#endif // TRK_ICOMPETINGRIOSONTRACKTOOL_H diff --git a/Tracking/TrkTools/TrkToolInterfaces/TrkToolInterfaces/IWeightCalculator.h b/Tracking/TrkTools/TrkToolInterfaces/TrkToolInterfaces/IWeightCalculator.h deleted file mode 100755 index f18c60c2e74a..000000000000 --- a/Tracking/TrkTools/TrkToolInterfaces/TrkToolInterfaces/IWeightCalculator.h +++ /dev/null @@ -1,92 +0,0 @@ -/* - Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration -*/ - -////////////////////////////////////////////////////////////////// -// IWeightCalculator.h -// Header file for interface of WeightCalculator -/////////////////////////////////////////////////////////////////// -// (c) ATLAS Detector software -/////////////////////////////////////////////////////////////////// -// Sebastian.Fleischmann@cern.ch -/////////////////////////////////////////////////////////////////// - -#ifndef TRK_IWEIGHTCALCULATOR_H -#define TRK_IWEIGHTCALCULATOR_H - -#include "GaudiKernel/IAlgTool.h" -#include "TrkParameters/TrackParameters.h" // typedef - -// just needed for assignProb typedef till now: -#include "TrkCompetingRIOsOnTrack/CompetingRIOsOnTrack.h" -// may result in circular dependency :-( -#include <vector> - -namespace Trk { -static const InterfaceID IID_IWeightCalculator("IWeightCalculator",1,0); - -class RIO_OnTrack; //!< RIO_OnTrack base -//typedef AssignmentProb; //!< assignment probabilities - - -/** @class IWeightCalculator - provides the interface to encapsulate the calculations of assignmentProbabilities of - competing measurements to a track. - These calculations are needed in fitters such as the - Deterministic Annealing Filter. -*/ - -class IWeightCalculator : virtual public IAlgTool { -public: - /** Type def of annealing factor: factor to increase the variances of measurements, to be lowered in the annealing process */ - typedef double AnnealingFactor; - - /**Interface ID, declared here, and defined below*/ - static const InterfaceID& interfaceID(); - -// /** calculate the assignment probabilities (assignment weights) for a collection of measurements: -// if doNormalization==true the AssignmentProbs will be normalized using the given cutValue*/ -// virtual const std::vector< AssignmentProb >* calculateWeights ( -// const TrackParameters&, -// const std::vector< const RIO_OnTrack* >*, -// const double cutValue, -// const bool doNormalization=true ) const = 0; - /** calculate the assignment probabilities (assignment weights) for a collection of measurements: - if doNormalization==true the AssignmentProbs will be normalized using the given cutValue - use vector of TrackParameters to avoid transformations to local frame (TrackParameters must - be given on the associated surface of the particular ROT)*/ - virtual const std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >* calculateWeights ( - const std::vector< const TrackParameters* >*, - const std::vector< const RIO_OnTrack* >*, - const AnnealingFactor, - const double cutValue, - const bool doNormalization=true ) const = 0; - - /** calculate the assignment probability (assignment weight) for a single measurement (no normalization can be done in this case)*/ - virtual Trk::CompetingRIOsOnTrack::AssignmentProb calculateWeight ( - const TrackParameters&, - const RIO_OnTrack&, - const AnnealingFactor ) const = 0; - - /** normalize given assignment probabilities (assignment weights) using a given cutValue*/ - virtual const std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >* normalize ( - const std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >*, - const std::vector< const RIO_OnTrack* >*, - const AnnealingFactor, - const double cutValue ) const = 0; - /** normalize given assignment probabilities (assignment weights) using a given cutValue*/ - virtual void normalize ( - std::vector< Trk::CompetingRIOsOnTrack::AssignmentProb >&, - const std::vector< const RIO_OnTrack* >*, - const AnnealingFactor, - const double cutValue ) const = 0; - -}; - -inline const InterfaceID& Trk::IWeightCalculator::interfaceID() { - return IID_IWeightCalculator; -} - -} // end of namespace - -#endif // TRK_IWEIGHTCALCULATOR_H -- GitLab From 4f491d9deec0f02ad6976e9a0ac4786528622abf Mon Sep 17 00:00:00 2001 From: tstreble <thomas.strebler@cern.ch> Date: Thu, 21 Jul 2022 17:11:28 +0200 Subject: [PATCH 5/6] Clean up TRT DAF configs in old-style RecExCommon config --- .../python/InDetJobProperties.py | 11 ---- .../InDetRecExample/python/TrackingCommon.py | 53 ++----------------- .../ConfiguredNewTrackingTRTExtension.py | 47 ++++------------ 3 files changed, 14 insertions(+), 97 deletions(-) diff --git a/InnerDetector/InDetExample/InDetRecExample/python/InDetJobProperties.py b/InnerDetector/InDetExample/InDetRecExample/python/InDetJobProperties.py index 13bb8c12a791..20ffbe1fa331 100644 --- a/InnerDetector/InDetExample/InDetRecExample/python/InDetJobProperties.py +++ b/InnerDetector/InDetExample/InDetRecExample/python/InDetJobProperties.py @@ -516,13 +516,6 @@ class doTRTExtensionNew(InDetFlagsJobProperty): statusOn = True allowedTypes = ['bool'] StoredValue = True - -class trtExtensionType(InDetFlagsJobProperty): - """ which extension type ("xk"/"DAF") """ - statusOn = True - allowedTypes = ['str'] - allowedValues= ['xk','DAF'] - StoredValue = 'xk' class redoTRT_LR(InDetFlagsJobProperty): """ use smart TRT LR/tube hit creator and redo ROTs """ @@ -1834,8 +1827,6 @@ class InDetJobProperties(JobPropertyContainer): # some tracking switches # ------------------------------------------------------------------- self.redoTRT_LR = DetFlags.haveRIO.TRT_on() - if self.trtExtensionType() == 'DAF': - self.redoTRT_LR = False # # -------------------------------------------------------------------- # ---- Refit of tracks @@ -2639,9 +2630,7 @@ _list_InDetJobProperties = [Enabled, useZvertexTool, useActsPriVertexing, doSiSPSeededTrackFinder, -# doTRTExtension, doTRTExtensionNew, - trtExtensionType, redoTRT_LR, doTrtSegments, doTRTPhaseCalculation, diff --git a/InnerDetector/InDetExample/InDetRecExample/python/TrackingCommon.py b/InnerDetector/InDetExample/InDetRecExample/python/TrackingCommon.py index ea4c5e165413..5b3714c970f4 100644 --- a/InnerDetector/InDetExample/InDetRecExample/python/TrackingCommon.py +++ b/InnerDetector/InDetExample/InDetRecExample/python/TrackingCommon.py @@ -1459,59 +1459,14 @@ def getInDetTRT_TrackExtensionTool_xk(name='InDetTRT_ExtensionTool', TrackingCut from TRT_TrackExtensionTool_xk.TRT_TrackExtensionTool_xkConf import InDet__TRT_TrackExtensionTool_xk return InDet__TRT_TrackExtensionTool_xk(the_name, **kwargs) -@makePublicTool -def getInDetWeightCalculator(name='InDetWeightCalculator',**kwargs) : - the_name = makeName( name, kwargs) - from TrkDeterministicAnnealingFilter.TrkDeterministicAnnealingFilterConf import Trk__DAF_SimpleWeightCalculator - return Trk__DAF_SimpleWeightCalculator( name = the_name, **kwargs) - - -@makePublicTool -def getInDetCompetingTRT_DC_Tool(name='InDetCompetingTRT_DC_Tool',**kwargs) : - the_name = makeName( name, kwargs) - - if 'Extrapolator' not in kwargs : - kwargs=setDefaults(kwargs, Extrapolator = getInDetExtrapolator()) - - if 'ToolForWeightCalculation' not in kwargs : - kwargs=setDefaults(kwargs, ToolForWeightCalculation = getInDetWeightCalculator()) - - if 'ToolForTRT_DriftCircleOnTrackCreation' not in kwargs : - kwargs=setDefaults(kwargs, ToolForTRT_DriftCircleOnTrackCreation = getInDetTRT_DriftCircleOnTrackTool()) - - from InDetCompetingRIOsOnTrackTool.InDetCompetingRIOsOnTrackToolConf import InDet__CompetingTRT_DriftCirclesOnTrackTool - return InDet__CompetingTRT_DriftCirclesOnTrackTool( the_name, **kwargs) - - -@makePublicTool -def getInDetTRT_TrackExtensionTool_DAF(name='TRT_TrackExtensionTool_DAF',**kwargs) : - the_name = makeName( name, kwargs) - if 'CompetingDriftCircleTool' not in kwargs : - kwargs=setDefaults(kwargs, CompetingDriftCircleTool = getInDetCompetingTRT_DC_Tool()) - - if 'PropagatorTool' not in kwargs : - kwargs=setDefaults(kwargs, PropagatorTool = getInDetPatternPropagator()) - - if 'RoadTool' not in kwargs : - kwargs=setDefaults(kwargs, RoadTool = getInDetTRT_RoadMaker()) - - from InDetRecExample.InDetKeys import InDetKeys - kwargs = setDefaults(kwargs, TRT_DriftCircleContainer = InDetKeys.TRT_DriftCircles()) - - from TRT_TrackExtensionTool_DAF.TRT_TrackExtensionTool_DAFConf import InDet__TRT_TrackExtensionTool_DAF - return InDet__TRT_TrackExtensionTool_DAF(the_name,**kwargs) - def getInDetTRT_ExtensionTool(TrackingCuts=None, **kwargs) : # @TODO set all names to InDetTRT_ExtensionTool ? from InDetRecExample.InDetJobProperties import InDetFlags - if (InDetFlags.trtExtensionType() == 'xk') or (not InDetFlags.doNewTracking()) : - if InDetFlags.doCosmics(): - return getInDetTRT_ExtensionToolCosmics(**kwargs) - else : - return getInDetTRT_TrackExtensionTool_xk(TrackingCuts=TrackingCuts, **kwargs) - elif InDetFlags.trtExtensionType() == 'DAF' : - return getInDetTRT_TrackExtensionTool_DAF('InDetTRT_ExtensionTool',**kwargs) + if InDetFlags.doCosmics(): + return getInDetTRT_ExtensionToolCosmics(**kwargs) + else : + return getInDetTRT_TrackExtensionTool_xk(TrackingCuts=TrackingCuts, **kwargs) def getTRT_DetElementsRoadCondAlg(**kwargs): the_name=kwargs.pop("name","InDet__TRT_DetElementsRoadCondAlg_xk") diff --git a/InnerDetector/InDetExample/InDetRecExample/share/ConfiguredNewTrackingTRTExtension.py b/InnerDetector/InDetExample/InDetRecExample/share/ConfiguredNewTrackingTRTExtension.py index bbabae472b28..1cf401c13f41 100644 --- a/InnerDetector/InDetExample/InDetRecExample/share/ConfiguredNewTrackingTRTExtension.py +++ b/InnerDetector/InDetExample/InDetRecExample/share/ConfiguredNewTrackingTRTExtension.py @@ -69,43 +69,16 @@ class ConfiguredNewTrackingTRTExtension: # ------------ Track Extension Processor # if InDetFlags.doExtensionProcessor() and InDetFlags.doTRTExtensionNew(): - - if InDetFlags.trtExtensionType() == 'DAF' : - # - # --- DAF Fitter setup - # - from TrkCompetingRIOsOnTrackTool.TrkCompetingRIOsOnTrackToolConf import Trk__CompetingRIOsOnTrackTool - InDetCompetingRotCreator = Trk__CompetingRIOsOnTrackTool( name = 'InDetCompetingRotCreator'+NewTrackingCuts.extension(), - ToolForCompPixelClusters = None, # default - ToolForCompSCT_Clusters = None, # default - ToolForCompTRT_DriftCircles = InDetCompetingTRT_DC_Tool ) - ToolSvc += InDetCompetingRotCreator - if (InDetFlags.doPrintConfigurables()): - printfunc (InDetCompetingRotCreator) - # - from TrkDeterministicAnnealingFilter.TrkDeterministicAnnealingFilterConf import Trk__DeterministicAnnealingFilter - InDetExtensionFitter = Trk__DeterministicAnnealingFilter( name = 'InDetDAF'+NewTrackingCuts.extension(), - ToolForExtrapolation = InDetExtrapolator, - ToolForCompetingROTsCreation = InDetCompetingRotCreator, - ToolForUpdating = InDetUpdator, - AnnealingScheme = [200., 81., 9., 4., 1., 1., 1.], - DropOutlierCutValue = 1.E-7, - OutlierCutValue = 0.01 ) - ToolSvc += InDetExtensionFitter - if (InDetFlags.doPrintConfigurables()): - printfunc (InDetExtensionFitter) - else: - from AthenaCommon import CfgGetter - fitter_args = {} - if InDetFlags.holeSearchInGX2Fit(): - from InDetRecExample.TrackingCommon import setDefaults - fitter_args = setDefaults(fitter_args, - DoHoleSearch = True, - BoundaryCheckTool = TrackingCommon.getInDetBoundaryCheckTool()) - InDetExtensionFitter = CfgGetter.getPublicToolClone('InDetTrackFitter_TRTExtension'+NewTrackingCuts.extension(),'InDetTrackFitter' if NewTrackingCuts.mode() != "LowPt" else 'InDetTrackFitterLowPt',**fitter_args) - - - + + from AthenaCommon import CfgGetter + fitter_args = {} + if InDetFlags.holeSearchInGX2Fit(): + from InDetRecExample.TrackingCommon import setDefaults + fitter_args = setDefaults(fitter_args, + DoHoleSearch = True, + BoundaryCheckTool = TrackingCommon.getInDetBoundaryCheckTool()) + InDetExtensionFitter = CfgGetter.getPublicToolClone('InDetTrackFitter_TRTExtension'+NewTrackingCuts.extension(),'InDetTrackFitter' if NewTrackingCuts.mode() != "LowPt" else 'InDetTrackFitterLowPt',**fitter_args) + # # --- load scoring for extension -- GitLab From 1a32de6b41c124c1577eae6475daed047660d2d1 Mon Sep 17 00:00:00 2001 From: tstreble <thomas.strebler@cern.ch> Date: Fri, 22 Jul 2022 07:39:55 +0200 Subject: [PATCH 6/6] Clean up of last CompetingRIOsOnTrackTool refs --- Control/AthenaConfiguration/share/referenceDuplicates.txt | 2 +- .../MuonRecTools/MuonRecToolInterfaces/CMakeLists.txt | 2 +- Tracking/TrkTools/TrkToolInterfaces/doc/packagedoc.h | 2 -- 3 files changed, 2 insertions(+), 4 deletions(-) diff --git a/Control/AthenaConfiguration/share/referenceDuplicates.txt b/Control/AthenaConfiguration/share/referenceDuplicates.txt index d22404d0274d..eaec85c435b4 100644 --- a/Control/AthenaConfiguration/share/referenceDuplicates.txt +++ b/Control/AthenaConfiguration/share/referenceDuplicates.txt @@ -1 +1 @@ -{"getComps": ["Database/AthenaPOOL/AthenaPoolCnvSvc/python/PoolReadConfig.py", "Reconstruction/egamma/egammaMVACalib/python/egammaMVACalibConfig.py", "MuonSpectrometer/MuonG4/MuonG4SD/python/MuonG4SDToolConfig.py", "Simulation/G4Atlas/G4AtlasServices/python/G4AtlasServicesConfigNew.py", "Simulation/G4Atlas/G4AtlasTools/python/G4FieldConfigNew.py", "LArCalorimeter/LArCellRec/python/LArNoisyROSummaryConfig.py", "InnerDetector/InDetDigitization/StripDigitization/python/StripDigitizationConfig.py", "MuonSpectrometer/MuonConfig/python/MuonRecToolsConfig.py", "Calorimeter/CaloRec/python/CaloTopoClusterConfig.py", "Simulation/G4Atlas/G4AtlasTools/python/G4GeometryToolConfig.py", "TileCalorimeter/TileRecUtils/python/TileCellMakerConfig.py", "LArCalorimeter/LArExample/LArCalibProcessing/python/LArCalib_BadChannelConfig.py", "InnerDetector/InDetDigitization/SCT_Digitization/python/SCT_DigitizationConfigNew.py", "PhysicsAnalysis/JetTagging/JetTagAlgs/BTagging/python/BTagRun3Config.py", "Reconstruction/egamma/egammaMVACalib/python/TrigEgammaMVACalibConfig.py", "PhysicsAnalysis/JetTagging/JetTagCalibration/python/JetTagCalibConfig.py", "Simulation/Digitization/python/PileUpToolsConfig.py", "MuonSpectrometer/MuonConfig/python/MuonTrackBuildingConfig.py", "Database/AthenaPOOL/OutputStreamAthenaPool/python/OutputStreamConfig.py", "MuonSpectrometer/MuonConfig/python/MuonCondSvcConfig.py", "TileCalorimeter/TileG4/TileGeoG4SD/python/TileGeoG4SDToolConfig.py", "Control/AthenaServices/python/MetaDataSvcConfig.py", "Reconstruction/RecoTools/TrackToCalo/python/TrackToCaloConfig.py", "PhysicsAnalysis/DerivationFramework/DerivationFrameworkFlavourTag/python/FtagRun3DerivationConfig.py", "Trigger/TriggerCommon/TriggerJobOpts/python/TriggerConfig.py", "MuonSpectrometer/MuonConfig/python/MuonCondAlgConfig.py", "Trigger/TrigAlgorithms/TrigT2CaloEgamma/python/TrigT2CaloEgammaMTConfig.py", "Control/SGComps/python/AddressRemappingConfig.py", "MuonSpectrometer/MuonConfig/python/MuonSegmentFindingConfig.py", "MuonSpectrometer/MuonConfig/python/MuonGeometryConfig.py", "LArCalorimeter/LArCabling/python/LArCablingConfig.py", "LArCalorimeter/LArCellRec/python/LArCellBuilderConfig.py", "Reconstruction/egamma/egammaTools/python/EMShowerBuilderConfig.py"], "THistSvc": ["Control/AthenaExamples/AthExMonitored/python/MonitoredConfig.py", "Simulation/Tools/RDOAnalysis/python/RDOAnalysisConfig.py", "LArCalorimeter/LArCafJobs/python/LArShapeDumperConfig.py", "TileCalorimeter/TileRec/python/TileAANtupleConfig.py", "Tracking/TrkExtrapolation/TrkExAlgs/python/TrkExAlgsConfig.py", "Reconstruction/eflowRec/python/PFHLTConfig.py", "Simulation/G4Atlas/G4AtlasTests/share/DCubeTestsConfig.py", "Trigger/TriggerCommon/TriggerJobOpts/python/TriggerHistSvcConfig.py"], "DQDummyFilterTool": ["Control/AthenaMonitoring/python/BadLBFilterToolConfig.py", "Control/AthenaMonitoring/python/AtlasReadyFilterConfig.py"], "StoreGateSvc": ["Simulation/ISF/ISF_Geant4/ISF_Geant4CommonTools/python/ISF_Geant4CommonToolsConfigNew.py", "Control/AthenaServices/python/MetaDataSvcConfig.py"], "ProxyProviderSvc": ["Control/AthenaServices/python/MetaDataSvcConfig.py", "HLT/Event/TrigByteStreamCnvSvc/python/TrigByteStreamConfig.py", "Trigger/TrigAlgorithms/TrigT2CaloCommon/python/TrigCaloDataAccessConfig.py"], "getComp": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "Trigger/TrigT1/TrigT1MuonRecRoiTool/python/TrigT1MuonRecRoiToolConfig.py", "TileCalorimeter/TileConditions/python/TileTimingConfig.py", "TileCalorimeter/TileConditions/python/TilePulseShapeConfig.py", "TileCalorimeter/TileConditions/python/TileIntegratorConfig.py", "TileCalorimeter/TileConditions/python/TileOFCConfig.py", "Reconstruction/TrackCaloClusterRec/TrackCaloClusterRecTools/python/TrackCaloClusterConfig.py", "TileCalorimeter/TileConditions/python/TileBadChannelsConfig.py", "Trigger/TrigAlgorithms/TrigT2CaloCommon/python/TrigCaloDataAccessConfig.py", "TileCalorimeter/TileConditions/python/TileEMScaleConfig.py", "TileCalorimeter/TileConditions/python/TileAutoCorrelationConfig.py", "Trigger/TrigT1/TrigT1CaloByteStream/python/LVL1CaloRun2ByteStreamConfig.py", "LArCalorimeter/LArConfiguration/python/LArElecCalibDBConfig.py", "Reconstruction/MET/METUtilities/python/ORMETMakerConfig.py", "TileCalorimeter/TileConditions/python/TileMuIDConfig.py", "Trigger/TrigSteer/L1Decoder/python/L1DecoderConfig.py", "Reconstruction/Jet/JetRecTools/python/JetRecToolsConfig.py", "TileCalorimeter/TileConditions/python/TileDSPThresholdConfig.py", "TileCalorimeter/TileConditions/python/TileSampleNoiseConfig.py", "TileCalorimeter/TileConditions/python/TileTMDBConfig.py", "Database/AthenaPOOL/OutputStreamAthenaPool/python/OutputStreamConfig.py", "Reconstruction/MET/METUtilities/python/METMakerConfig.py", "Trigger/TriggerCommon/TriggerJobOpts/python/TriggerConfig.py", "Calorimeter/CaloRec/python/CaloBCIDCoeffsCondAlgConfig.py", "Trigger/TrigT1/TrigT1MuctpiPhase1/python/TrigT1MuctpiPhase1Config.py", "Reconstruction/Jet/JetRecConfig/python/JetRecConfig.py", "MuonSpectrometer/MuonConfig/python/MuonSegmentFindingConfig.py", "Trigger/TrigSteer/DecisionHandling/python/HLTSignatureConfig.py"], "EvtPersistencySvc": ["HLT/Event/TrigByteStreamCnvSvc/python/TrigByteStreamConfig.py", "Database/AthenaPOOL/AthenaPoolCnvSvc/python/PoolWriteConfig.py"], "TriggerSummaryAlg": ["HLT/Trigger/TrigControl/TrigExamples/TrigExPartialEB/python/MTCalibPebConfig.py", "Trigger/TrigSteer/DecisionHandling/python/DecisionHandlingConfig.py"], "TriggerBitsMakerTool": ["Trigger/TrigSteer/TrigOutputHandling/python/TrigOutputHandlingConfig.py", "Trigger/TriggerCommon/TriggerJobOpts/python/TriggerConfig.py"], "CaloClusterMomentsMaker": ["TileCalorimeter/TileMonitoring/python/TileTopoClusterConfig.py", "Trigger/TrigAlgorithms/TrigCaloRec/python/TrigCaloRecConfig.py"], "InDet.InDetPriVxFinder": ["InnerDetector/InDetConfig/python/VertexFindingConfig.py", "Trigger/TrigTools/TrigInDetConfig/python/TrigInDetPriVtxConfig.py"], "Trk.VertexCollectionSortingTool": ["InnerDetector/InDetConfig/python/VertexFindingConfig.py", "Trigger/TrigTools/TrigInDetConfig/python/TrigInDetPriVtxConfig.py"], "Trk.SumPtVertexWeightCalculator": ["InnerDetector/InDetConfig/python/VertexFindingConfig.py", "Trigger/TrigTools/TrigInDetConfig/python/TrigInDetPriVtxConfig.py"], "InDet.InDetTrackSelectionTool": ["InnerDetector/InDetMonitoring/InDetGlobalMonitoringRun3Test/python/InDetGlobalMonitoringRun3TestConfig.py", "InnerDetector/InDetConfig/python/VertexFindingConfig.py", "InnerDetector/InDetMonitoring/InDetAlignmentMonitoringRun3/python/InDetAlignmentMonitoringRun3Config.py", "Reconstruction/eflowRec/python/PFHLTConfig.py", "Trigger/TrigTools/TrigInDetConfig/python/TrigInDetPriVtxConfig.py"], "Trk.RungeKuttaPropagator": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/InDetRecToolConfig.py", "Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedRecToolsConfig.py", "MuonSpectrometer/MuonConfig/python/MuonRecToolsConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "InDet.SiDetElementsRoadCondAlg_xk": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingSiPatternConfig.py", "InnerDetector/InDetConfig/python/BackTrackingConfig.py", "InnerDetector/InDetConfig/python/TRTExtensionConfig.py"], "InDet.SiDetElementsRoadMaker_xk": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingSiPatternConfig.py", "InnerDetector/InDetConfig/python/BackTrackingConfig.py", "InnerDetector/InDetConfig/python/TRTExtensionConfig.py"], "InDet.NnClusterizationFactory": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "InDet.PixelClusterOnTrackTool": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "InDet.SCT_ClusterOnTrackTool": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "Trk.RIO_OnTrackCreator": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "Trk.KalmanUpdator_xk": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "InDet.SiCombinatorialTrackFinder_xk": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingSiPatternConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py", "InnerDetector/InDetConfig/python/TRTExtensionConfig.py"], "RIO_OnTrackErrorScalingCondAlg": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "InDet.SiTrackMaker_xk": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingSiPatternConfig.py", "InnerDetector/InDetConfig/python/TRTExtensionConfig.py"], "InDet.InDetTestPixelLayerTool": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/InDetRecToolConfig.py"], "InDet.InDetTrackHoleSearchTool": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/InDetRecToolConfig.py"], "InDet.InDetPRD_AssociationToolGangedPixels": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "Tracking/TrkConfig/python/AtlasTrackSummaryToolConfig.py", "InnerDetector/InDetConfig/python/InDetRecToolConfig.py"], "InDet.InDetTrackSummaryHelperTool": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/InDetRecToolConfig.py"], "Trk.TrackSummaryTool": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "Tracking/TrkConfig/python/AtlasTrackSummaryToolConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "InDet.SiDetElementBoundaryLinksCondAlg_xk": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingSiPatternConfig.py", "InnerDetector/InDetConfig/python/BackTrackingConfig.py", "InnerDetector/InDetConfig/python/TRTExtensionConfig.py"], "Reco.TrackToVertex": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackRecoConfig.py", "PhysicsAnalysis/JetTagging/JetTagTools/python/BTagTrackToVertexToolConfig.py", "Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedRecToolsConfig.py"], "Trk.TrackParticleCreatorTool": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackRecoConfig.py", "Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedRecToolsConfig.py"], "InDet.InDetTrtDriftCircleCutTool": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "InDet.TRT_DetElementsRoadCondAlg_xk": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "InDet.TRT_DetElementsRoadMaker_xk": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "InDet.TRT_TrackExtensionTool_xk": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "InDet.TRT_TrackExtensionAlg": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TRTExtensionConfig.py"], "InDet.InDetExtensionProcessor": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TRTExtensionConfig.py"], "InDet.InDetPRDtoTrackMapToolGangedPixels": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "InDet.InDetAmbiTrackSelectionTool": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/BackTrackingConfig.py"], "InDet.InDetAmbiScoringTool": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "Trk.KalmanUpdator": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedRecToolsConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "Trk.GlobalChi2Fitter": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedRecToolsConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "Trk.MaterialEffectsUpdator": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/InDetRecToolConfig.py"], "Trk.SimpleAmbiguityProcessorTool": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/BackTrackingConfig.py"], "Trk.TrkAmbiguityScore": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingSiPatternConfig.py", "InnerDetector/InDetConfig/python/BackTrackingConfig.py"], "Trk.TrkAmbiguitySolver": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingSiPatternConfig.py", "InnerDetector/InDetConfig/python/BackTrackingConfig.py"], "PseudoJetMerger": ["Reconstruction/Jet/JetRecConfig/python/JetRecConfig.py", "Trigger/TriggerCommon/TriggerMenuMT/python/HLT/Jet/JetRecoConfig.py"], "PseudoJetAlgorithm": ["Trigger/TriggerCommon/TriggerMenuMT/python/HLT/Jet/JetTrackingConfig.py", "Reconstruction/Jet/JetRecConfig/python/JetRecConfig.py"], "JetAlgorithm": ["Trigger/TriggerCommon/TriggerMenuMT/python/HLT/Jet/JetTrackingConfig.py", "Reconstruction/Jet/JetRecConfig/python/JetRecConfig.py", "Reconstruction/Jet/JetRecConfig/python/JetInputConfig.py"], "TrackVertexAssociationTool": ["Reconstruction/Jet/JetRecTools/python/JetRecToolsConfig.py", "Trigger/TriggerCommon/TriggerMenuMT/python/HLT/Jet/JetTrackingConfig.py"], "Trk__TrkVKalVrtFitter": ["Trigger/TrigHypothesis/TrigBphysHypo/python/TrigBmumuxComboHypoConfig.py", "Trigger/TrigHypothesis/TrigBphysHypo/python/TrigMultiTrkComboHypoConfig.py"], "InDet__VertexPointEstimator": ["Trigger/TrigHypothesis/TrigBphysHypo/python/TrigBmumuxComboHypoConfig.py", "Trigger/TrigHypothesis/TrigBphysHypo/python/TrigMultiTrkComboHypoConfig.py"], "AthenaPoolCnvSvc": ["Simulation/G4Atlas/G4AtlasAlg/python/G4AtlasAlgConfigNew.py", "MuonSpectrometer/MuonConfig/python/MuonRdoDecodeConfig.py"], "CaloCellContainerFinalizerTool": ["Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimServices/python/ISF_FastCaloSimServicesConfigNew.py", "Calorimeter/CaloRec/python/CaloCellMakerConfig.py"], "CaloTopoClusterMaker": ["TileCalorimeter/TileMonitoring/python/TileTopoClusterConfig.py", "Calorimeter/CaloRec/python/CaloTopoClusterConfig.py"], "CaloTopoClusterSplitter": ["TileCalorimeter/TileMonitoring/python/TileTopoClusterConfig.py", "Calorimeter/CaloRec/python/CaloTopoClusterConfig.py"], "LArADC2MeVCondAlg": ["LArCalorimeter/LArRecUtils/python/LArADC2MeVSCCondAlgConfig.py", "LArCalorimeter/LArRecUtils/python/LArADC2MeVCondAlgConfig.py"], "Trk.TrackingVolumeArrayCreator": ["Tracking/TrkConfig/python/AtlasTrackingGeometrySvcConfig.py", "Tracking/TrkConditions/TrackingGeometryCondAlg/python/AtlasTrackingGeometryCondAlgConfig.py"], "Trk.TrackingVolumeHelper": ["Tracking/TrkConfig/python/AtlasTrackingGeometrySvcConfig.py", "Tracking/TrkConditions/TrackingGeometryCondAlg/python/AtlasTrackingGeometryCondAlgConfig.py"], "ISF.LegacySimSvc": ["Simulation/ISF/ISF_Core/ISF_Services/python/ISF_ServicesCoreConfigNew.py", "Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimServices/python/ISF_FastCaloSimServicesConfigNew.py", "Simulation/ISF/ISF_Fatras/ISF_FatrasServices/python/ISF_FatrasConfig.py"], "MergeRecoTimingObjTool": ["Simulation/G4Utilities/MCTruthSimAlgs/python/MCTruthSimAlgsConfigNew.py", "Simulation/G4Utilities/MCTruthSimAlgs/python/RecoTimingConfig.py"], "FlavorTagDiscriminants.BTagDecoratorAlg": ["PhysicsAnalysis/JetTagging/JetTagAlgs/BTagging/python/HighLevelBTagAlgConfig.py", "PhysicsAnalysis/JetTagging/JetTagAlgs/BTagging/python/BTagHighLevelAugmenterAlgConfig.py"], "AsgElectronLikelihoodTool": ["Reconstruction/MET/METUtilities/python/METMakerConfig.py", "Reconstruction/MET/METUtilities/python/ORMETMakerConfig.py"], "AsgPhotonIsEMSelector": ["Reconstruction/MET/METUtilities/python/METMakerConfig.py", "Reconstruction/MET/METUtilities/python/ORMETMakerConfig.py"], "TrackDepositInCaloTool": ["Reconstruction/eflowRec/python/PFHLTConfig.py", "Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedRecToolsConfig.py"], "CaloMuonScoreTool": ["Reconstruction/eflowRec/python/PFHLTConfig.py", "Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedRecToolsConfig.py"], "CaloMuonTag": ["Reconstruction/eflowRec/python/PFHLTConfig.py", "Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedRecToolsConfig.py"], "Trk.ParticleCaloExtensionTool": ["Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedReconstructionConfig.py", "Reconstruction/eflowRec/python/PFHLTConfig.py"], "Muon.MuonEDMHelperSvc": ["Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedReconstructionConfig.py", "Event/DumpEventDataToJSON/python/DumpEventDataToJSONConfig.py"], "InDet.SiZvertexMaker_xk": ["InnerDetector/InDetConfig/python/TrackingSiPatternConfig.py", "InnerDetector/InDetConfig/python/TRTExtensionConfig.py"], "SCT_ConditionsSummaryTool": ["InnerDetector/InDetConfig/python/InDetRecToolConfig.py", "InnerDetector/InDetConfig/python/TrackingSiPatternConfig.py"], "InDet.SeedToTrackConversionTool": ["InnerDetector/InDetConfig/python/TrackingSiPatternConfig.py", "InnerDetector/InDetConfig/python/TRTExtensionConfig.py"], "InDet.SiSPSeededTrackFinder": ["InnerDetector/InDetConfig/python/TrackingSiPatternConfig.py", "InnerDetector/InDetConfig/python/TRTExtensionConfig.py"], "Trk.CompetingRIOsOnTrackTool": ["InnerDetector/InDetConfig/python/TrackingCommonConfig.py", "InnerDetector/InDetConfig/python/TRTExtensionConfig.py"], "SCT_CablingTool": ["InnerDetector/InDetConfig/python/InDetRecToolConfig.py", "InnerDetector/InDetDetDescr/SCT_Cabling/python/TestSCT_CablingConfig.py"], "PixelAlignCondAlg": ["InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/ITkPixelConditionsConfig.py", "InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/PixelConditionsConfig.py"], "PixelChargeCalibCondAlg": ["InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/ITkPixelConditionsConfig.py", "InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/PixelConditionsConfig.py"], "PixelChargeLUTCalibCondAlg": ["InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/ITkPixelConditionsConfig.py", "InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/PixelConditionsConfig.py"], "PixelDCSCondHVAlg": ["InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/ITkPixelConditionsConfig.py", "InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/PixelConditionsConfig.py"], "PixelDCSCondStateAlg": ["InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/ITkPixelConditionsConfig.py", "InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/PixelConditionsConfig.py"], "PixelDCSCondStatusAlg": ["InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/ITkPixelConditionsConfig.py", "InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/PixelConditionsConfig.py"], "PixelDCSCondTempAlg": ["InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/ITkPixelConditionsConfig.py", "InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/PixelConditionsConfig.py"], "PixelDeadMapCondAlg": ["InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/ITkPixelConditionsConfig.py", "InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/PixelConditionsConfig.py"], "PixelDetectorElementCondAlg": ["InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/ITkPixelConditionsConfig.py", "InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/PixelConditionsConfig.py"], "PixelDistortionAlg": ["InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/ITkPixelConditionsConfig.py", "InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/PixelConditionsConfig.py"], "PixelConditionsSummaryTool": ["InnerDetector/InDetConditions/PixelConditionsTools/python/PixelConditionsSummaryConfig.py", "InnerDetector/InDetConditions/PixelConditionsTools/python/ITkPixelConditionsSummaryConfig.py"], "DetDescrDBEnvelopeSvc": ["AtlasGeometryCommon/SubDetectorEnvelopes/python/SubDetectorEnvelopesConfig.py", "Simulation/ISF/ISF_Geant4/ISF_Geant4Services/python/ISF_Geant4ServicesConfigNew.py"]} +{"getComps": ["Database/AthenaPOOL/AthenaPoolCnvSvc/python/PoolReadConfig.py", "Reconstruction/egamma/egammaMVACalib/python/egammaMVACalibConfig.py", "MuonSpectrometer/MuonG4/MuonG4SD/python/MuonG4SDToolConfig.py", "Simulation/G4Atlas/G4AtlasServices/python/G4AtlasServicesConfigNew.py", "Simulation/G4Atlas/G4AtlasTools/python/G4FieldConfigNew.py", "LArCalorimeter/LArCellRec/python/LArNoisyROSummaryConfig.py", "InnerDetector/InDetDigitization/StripDigitization/python/StripDigitizationConfig.py", "MuonSpectrometer/MuonConfig/python/MuonRecToolsConfig.py", "Calorimeter/CaloRec/python/CaloTopoClusterConfig.py", "Simulation/G4Atlas/G4AtlasTools/python/G4GeometryToolConfig.py", "TileCalorimeter/TileRecUtils/python/TileCellMakerConfig.py", "LArCalorimeter/LArExample/LArCalibProcessing/python/LArCalib_BadChannelConfig.py", "InnerDetector/InDetDigitization/SCT_Digitization/python/SCT_DigitizationConfigNew.py", "PhysicsAnalysis/JetTagging/JetTagAlgs/BTagging/python/BTagRun3Config.py", "Reconstruction/egamma/egammaMVACalib/python/TrigEgammaMVACalibConfig.py", "PhysicsAnalysis/JetTagging/JetTagCalibration/python/JetTagCalibConfig.py", "Simulation/Digitization/python/PileUpToolsConfig.py", "MuonSpectrometer/MuonConfig/python/MuonTrackBuildingConfig.py", "Database/AthenaPOOL/OutputStreamAthenaPool/python/OutputStreamConfig.py", "MuonSpectrometer/MuonConfig/python/MuonCondSvcConfig.py", "TileCalorimeter/TileG4/TileGeoG4SD/python/TileGeoG4SDToolConfig.py", "Control/AthenaServices/python/MetaDataSvcConfig.py", "Reconstruction/RecoTools/TrackToCalo/python/TrackToCaloConfig.py", "PhysicsAnalysis/DerivationFramework/DerivationFrameworkFlavourTag/python/FtagRun3DerivationConfig.py", "Trigger/TriggerCommon/TriggerJobOpts/python/TriggerConfig.py", "MuonSpectrometer/MuonConfig/python/MuonCondAlgConfig.py", "Trigger/TrigAlgorithms/TrigT2CaloEgamma/python/TrigT2CaloEgammaMTConfig.py", "Control/SGComps/python/AddressRemappingConfig.py", "MuonSpectrometer/MuonConfig/python/MuonSegmentFindingConfig.py", "MuonSpectrometer/MuonConfig/python/MuonGeometryConfig.py", "LArCalorimeter/LArCabling/python/LArCablingConfig.py", "LArCalorimeter/LArCellRec/python/LArCellBuilderConfig.py", "Reconstruction/egamma/egammaTools/python/EMShowerBuilderConfig.py"], "THistSvc": ["Control/AthenaExamples/AthExMonitored/python/MonitoredConfig.py", "Simulation/Tools/RDOAnalysis/python/RDOAnalysisConfig.py", "LArCalorimeter/LArCafJobs/python/LArShapeDumperConfig.py", "TileCalorimeter/TileRec/python/TileAANtupleConfig.py", "Tracking/TrkExtrapolation/TrkExAlgs/python/TrkExAlgsConfig.py", "Reconstruction/eflowRec/python/PFHLTConfig.py", "Simulation/G4Atlas/G4AtlasTests/share/DCubeTestsConfig.py", "Trigger/TriggerCommon/TriggerJobOpts/python/TriggerHistSvcConfig.py"], "DQDummyFilterTool": ["Control/AthenaMonitoring/python/BadLBFilterToolConfig.py", "Control/AthenaMonitoring/python/AtlasReadyFilterConfig.py"], "StoreGateSvc": ["Simulation/ISF/ISF_Geant4/ISF_Geant4CommonTools/python/ISF_Geant4CommonToolsConfigNew.py", "Control/AthenaServices/python/MetaDataSvcConfig.py"], "ProxyProviderSvc": ["Control/AthenaServices/python/MetaDataSvcConfig.py", "HLT/Event/TrigByteStreamCnvSvc/python/TrigByteStreamConfig.py", "Trigger/TrigAlgorithms/TrigT2CaloCommon/python/TrigCaloDataAccessConfig.py"], "getComp": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "Trigger/TrigT1/TrigT1MuonRecRoiTool/python/TrigT1MuonRecRoiToolConfig.py", "TileCalorimeter/TileConditions/python/TileTimingConfig.py", "TileCalorimeter/TileConditions/python/TilePulseShapeConfig.py", "TileCalorimeter/TileConditions/python/TileIntegratorConfig.py", "TileCalorimeter/TileConditions/python/TileOFCConfig.py", "Reconstruction/TrackCaloClusterRec/TrackCaloClusterRecTools/python/TrackCaloClusterConfig.py", "TileCalorimeter/TileConditions/python/TileBadChannelsConfig.py", "Trigger/TrigAlgorithms/TrigT2CaloCommon/python/TrigCaloDataAccessConfig.py", "TileCalorimeter/TileConditions/python/TileEMScaleConfig.py", "TileCalorimeter/TileConditions/python/TileAutoCorrelationConfig.py", "Trigger/TrigT1/TrigT1CaloByteStream/python/LVL1CaloRun2ByteStreamConfig.py", "LArCalorimeter/LArConfiguration/python/LArElecCalibDBConfig.py", "Reconstruction/MET/METUtilities/python/ORMETMakerConfig.py", "TileCalorimeter/TileConditions/python/TileMuIDConfig.py", "Trigger/TrigSteer/L1Decoder/python/L1DecoderConfig.py", "Reconstruction/Jet/JetRecTools/python/JetRecToolsConfig.py", "TileCalorimeter/TileConditions/python/TileDSPThresholdConfig.py", "TileCalorimeter/TileConditions/python/TileSampleNoiseConfig.py", "TileCalorimeter/TileConditions/python/TileTMDBConfig.py", "Database/AthenaPOOL/OutputStreamAthenaPool/python/OutputStreamConfig.py", "Reconstruction/MET/METUtilities/python/METMakerConfig.py", "Trigger/TriggerCommon/TriggerJobOpts/python/TriggerConfig.py", "Calorimeter/CaloRec/python/CaloBCIDCoeffsCondAlgConfig.py", "Trigger/TrigT1/TrigT1MuctpiPhase1/python/TrigT1MuctpiPhase1Config.py", "Reconstruction/Jet/JetRecConfig/python/JetRecConfig.py", "MuonSpectrometer/MuonConfig/python/MuonSegmentFindingConfig.py", "Trigger/TrigSteer/DecisionHandling/python/HLTSignatureConfig.py"], "EvtPersistencySvc": ["HLT/Event/TrigByteStreamCnvSvc/python/TrigByteStreamConfig.py", "Database/AthenaPOOL/AthenaPoolCnvSvc/python/PoolWriteConfig.py"], "TriggerSummaryAlg": ["HLT/Trigger/TrigControl/TrigExamples/TrigExPartialEB/python/MTCalibPebConfig.py", "Trigger/TrigSteer/DecisionHandling/python/DecisionHandlingConfig.py"], "TriggerBitsMakerTool": ["Trigger/TrigSteer/TrigOutputHandling/python/TrigOutputHandlingConfig.py", "Trigger/TriggerCommon/TriggerJobOpts/python/TriggerConfig.py"], "CaloClusterMomentsMaker": ["TileCalorimeter/TileMonitoring/python/TileTopoClusterConfig.py", "Trigger/TrigAlgorithms/TrigCaloRec/python/TrigCaloRecConfig.py"], "InDet.InDetPriVxFinder": ["InnerDetector/InDetConfig/python/VertexFindingConfig.py", "Trigger/TrigTools/TrigInDetConfig/python/TrigInDetPriVtxConfig.py"], "Trk.VertexCollectionSortingTool": ["InnerDetector/InDetConfig/python/VertexFindingConfig.py", "Trigger/TrigTools/TrigInDetConfig/python/TrigInDetPriVtxConfig.py"], "Trk.SumPtVertexWeightCalculator": ["InnerDetector/InDetConfig/python/VertexFindingConfig.py", "Trigger/TrigTools/TrigInDetConfig/python/TrigInDetPriVtxConfig.py"], "InDet.InDetTrackSelectionTool": ["InnerDetector/InDetMonitoring/InDetGlobalMonitoringRun3Test/python/InDetGlobalMonitoringRun3TestConfig.py", "InnerDetector/InDetConfig/python/VertexFindingConfig.py", "InnerDetector/InDetMonitoring/InDetAlignmentMonitoringRun3/python/InDetAlignmentMonitoringRun3Config.py", "Reconstruction/eflowRec/python/PFHLTConfig.py", "Trigger/TrigTools/TrigInDetConfig/python/TrigInDetPriVtxConfig.py"], "Trk.RungeKuttaPropagator": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/InDetRecToolConfig.py", "Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedRecToolsConfig.py", "MuonSpectrometer/MuonConfig/python/MuonRecToolsConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "InDet.SiDetElementsRoadCondAlg_xk": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingSiPatternConfig.py", "InnerDetector/InDetConfig/python/BackTrackingConfig.py", "InnerDetector/InDetConfig/python/TRTExtensionConfig.py"], "InDet.SiDetElementsRoadMaker_xk": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingSiPatternConfig.py", "InnerDetector/InDetConfig/python/BackTrackingConfig.py", "InnerDetector/InDetConfig/python/TRTExtensionConfig.py"], "InDet.NnClusterizationFactory": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "InDet.PixelClusterOnTrackTool": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "InDet.SCT_ClusterOnTrackTool": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "Trk.RIO_OnTrackCreator": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "Trk.KalmanUpdator_xk": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "InDet.SiCombinatorialTrackFinder_xk": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingSiPatternConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py", "InnerDetector/InDetConfig/python/TRTExtensionConfig.py"], "RIO_OnTrackErrorScalingCondAlg": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "InDet.SiTrackMaker_xk": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingSiPatternConfig.py", "InnerDetector/InDetConfig/python/TRTExtensionConfig.py"], "InDet.InDetTestPixelLayerTool": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/InDetRecToolConfig.py"], "InDet.InDetTrackHoleSearchTool": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/InDetRecToolConfig.py"], "InDet.InDetPRD_AssociationToolGangedPixels": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "Tracking/TrkConfig/python/AtlasTrackSummaryToolConfig.py", "InnerDetector/InDetConfig/python/InDetRecToolConfig.py"], "InDet.InDetTrackSummaryHelperTool": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/InDetRecToolConfig.py"], "Trk.TrackSummaryTool": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "Tracking/TrkConfig/python/AtlasTrackSummaryToolConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "InDet.SiDetElementBoundaryLinksCondAlg_xk": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingSiPatternConfig.py", "InnerDetector/InDetConfig/python/BackTrackingConfig.py", "InnerDetector/InDetConfig/python/TRTExtensionConfig.py"], "Reco.TrackToVertex": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackRecoConfig.py", "PhysicsAnalysis/JetTagging/JetTagTools/python/BTagTrackToVertexToolConfig.py", "Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedRecToolsConfig.py"], "Trk.TrackParticleCreatorTool": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackRecoConfig.py", "Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedRecToolsConfig.py"], "InDet.InDetTrtDriftCircleCutTool": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "InDet.TRT_DetElementsRoadCondAlg_xk": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "InDet.TRT_DetElementsRoadMaker_xk": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "InDet.TRT_TrackExtensionTool_xk": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "InDet.TRT_TrackExtensionAlg": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TRTExtensionConfig.py"], "InDet.InDetExtensionProcessor": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TRTExtensionConfig.py"], "InDet.InDetPRDtoTrackMapToolGangedPixels": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "InDet.InDetAmbiTrackSelectionTool": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/BackTrackingConfig.py"], "InDet.InDetAmbiScoringTool": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "Trk.KalmanUpdator": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedRecToolsConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "Trk.GlobalChi2Fitter": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedRecToolsConfig.py", "InnerDetector/InDetConfig/python/TrackingCommonConfig.py"], "Trk.MaterialEffectsUpdator": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/InDetRecToolConfig.py"], "Trk.SimpleAmbiguityProcessorTool": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/BackTrackingConfig.py"], "Trk.TrkAmbiguityScore": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingSiPatternConfig.py", "InnerDetector/InDetConfig/python/BackTrackingConfig.py"], "Trk.TrkAmbiguitySolver": ["Trigger/TrigTools/TrigInDetConfig/python/TrigInDetConfig.py", "InnerDetector/InDetConfig/python/TrackingSiPatternConfig.py", "InnerDetector/InDetConfig/python/BackTrackingConfig.py"], "PseudoJetMerger": ["Reconstruction/Jet/JetRecConfig/python/JetRecConfig.py", "Trigger/TriggerCommon/TriggerMenuMT/python/HLT/Jet/JetRecoConfig.py"], "PseudoJetAlgorithm": ["Trigger/TriggerCommon/TriggerMenuMT/python/HLT/Jet/JetTrackingConfig.py", "Reconstruction/Jet/JetRecConfig/python/JetRecConfig.py"], "JetAlgorithm": ["Trigger/TriggerCommon/TriggerMenuMT/python/HLT/Jet/JetTrackingConfig.py", "Reconstruction/Jet/JetRecConfig/python/JetRecConfig.py", "Reconstruction/Jet/JetRecConfig/python/JetInputConfig.py"], "TrackVertexAssociationTool": ["Reconstruction/Jet/JetRecTools/python/JetRecToolsConfig.py", "Trigger/TriggerCommon/TriggerMenuMT/python/HLT/Jet/JetTrackingConfig.py"], "Trk__TrkVKalVrtFitter": ["Trigger/TrigHypothesis/TrigBphysHypo/python/TrigBmumuxComboHypoConfig.py", "Trigger/TrigHypothesis/TrigBphysHypo/python/TrigMultiTrkComboHypoConfig.py"], "InDet__VertexPointEstimator": ["Trigger/TrigHypothesis/TrigBphysHypo/python/TrigBmumuxComboHypoConfig.py", "Trigger/TrigHypothesis/TrigBphysHypo/python/TrigMultiTrkComboHypoConfig.py"], "AthenaPoolCnvSvc": ["Simulation/G4Atlas/G4AtlasAlg/python/G4AtlasAlgConfigNew.py", "MuonSpectrometer/MuonConfig/python/MuonRdoDecodeConfig.py"], "CaloCellContainerFinalizerTool": ["Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimServices/python/ISF_FastCaloSimServicesConfigNew.py", "Calorimeter/CaloRec/python/CaloCellMakerConfig.py"], "CaloTopoClusterMaker": ["TileCalorimeter/TileMonitoring/python/TileTopoClusterConfig.py", "Calorimeter/CaloRec/python/CaloTopoClusterConfig.py"], "CaloTopoClusterSplitter": ["TileCalorimeter/TileMonitoring/python/TileTopoClusterConfig.py", "Calorimeter/CaloRec/python/CaloTopoClusterConfig.py"], "LArADC2MeVCondAlg": ["LArCalorimeter/LArRecUtils/python/LArADC2MeVSCCondAlgConfig.py", "LArCalorimeter/LArRecUtils/python/LArADC2MeVCondAlgConfig.py"], "Trk.TrackingVolumeArrayCreator": ["Tracking/TrkConfig/python/AtlasTrackingGeometrySvcConfig.py", "Tracking/TrkConditions/TrackingGeometryCondAlg/python/AtlasTrackingGeometryCondAlgConfig.py"], "Trk.TrackingVolumeHelper": ["Tracking/TrkConfig/python/AtlasTrackingGeometrySvcConfig.py", "Tracking/TrkConditions/TrackingGeometryCondAlg/python/AtlasTrackingGeometryCondAlgConfig.py"], "ISF.LegacySimSvc": ["Simulation/ISF/ISF_Core/ISF_Services/python/ISF_ServicesCoreConfigNew.py", "Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloSimServices/python/ISF_FastCaloSimServicesConfigNew.py", "Simulation/ISF/ISF_Fatras/ISF_FatrasServices/python/ISF_FatrasConfig.py"], "MergeRecoTimingObjTool": ["Simulation/G4Utilities/MCTruthSimAlgs/python/MCTruthSimAlgsConfigNew.py", "Simulation/G4Utilities/MCTruthSimAlgs/python/RecoTimingConfig.py"], "FlavorTagDiscriminants.BTagDecoratorAlg": ["PhysicsAnalysis/JetTagging/JetTagAlgs/BTagging/python/HighLevelBTagAlgConfig.py", "PhysicsAnalysis/JetTagging/JetTagAlgs/BTagging/python/BTagHighLevelAugmenterAlgConfig.py"], "AsgElectronLikelihoodTool": ["Reconstruction/MET/METUtilities/python/METMakerConfig.py", "Reconstruction/MET/METUtilities/python/ORMETMakerConfig.py"], "AsgPhotonIsEMSelector": ["Reconstruction/MET/METUtilities/python/METMakerConfig.py", "Reconstruction/MET/METUtilities/python/ORMETMakerConfig.py"], "TrackDepositInCaloTool": ["Reconstruction/eflowRec/python/PFHLTConfig.py", "Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedRecToolsConfig.py"], "CaloMuonScoreTool": ["Reconstruction/eflowRec/python/PFHLTConfig.py", "Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedRecToolsConfig.py"], "CaloMuonTag": ["Reconstruction/eflowRec/python/PFHLTConfig.py", "Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedRecToolsConfig.py"], "Trk.ParticleCaloExtensionTool": ["Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedReconstructionConfig.py", "Reconstruction/eflowRec/python/PFHLTConfig.py"], "Muon.MuonEDMHelperSvc": ["Reconstruction/MuonIdentification/MuonCombinedConfig/python/MuonCombinedReconstructionConfig.py", "Event/DumpEventDataToJSON/python/DumpEventDataToJSONConfig.py"], "InDet.SiZvertexMaker_xk": ["InnerDetector/InDetConfig/python/TrackingSiPatternConfig.py", "InnerDetector/InDetConfig/python/TRTExtensionConfig.py"], "SCT_ConditionsSummaryTool": ["InnerDetector/InDetConfig/python/InDetRecToolConfig.py", "InnerDetector/InDetConfig/python/TrackingSiPatternConfig.py"], "InDet.SeedToTrackConversionTool": ["InnerDetector/InDetConfig/python/TrackingSiPatternConfig.py", "InnerDetector/InDetConfig/python/TRTExtensionConfig.py"], "InDet.SiSPSeededTrackFinder": ["InnerDetector/InDetConfig/python/TrackingSiPatternConfig.py", "InnerDetector/InDetConfig/python/TRTExtensionConfig.py"], "SCT_CablingTool": ["InnerDetector/InDetConfig/python/InDetRecToolConfig.py", "InnerDetector/InDetDetDescr/SCT_Cabling/python/TestSCT_CablingConfig.py"], "PixelAlignCondAlg": ["InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/ITkPixelConditionsConfig.py", "InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/PixelConditionsConfig.py"], "PixelChargeCalibCondAlg": ["InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/ITkPixelConditionsConfig.py", "InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/PixelConditionsConfig.py"], "PixelChargeLUTCalibCondAlg": ["InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/ITkPixelConditionsConfig.py", "InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/PixelConditionsConfig.py"], "PixelDCSCondHVAlg": ["InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/ITkPixelConditionsConfig.py", "InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/PixelConditionsConfig.py"], "PixelDCSCondStateAlg": ["InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/ITkPixelConditionsConfig.py", "InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/PixelConditionsConfig.py"], "PixelDCSCondStatusAlg": ["InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/ITkPixelConditionsConfig.py", "InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/PixelConditionsConfig.py"], "PixelDCSCondTempAlg": ["InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/ITkPixelConditionsConfig.py", "InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/PixelConditionsConfig.py"], "PixelDeadMapCondAlg": ["InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/ITkPixelConditionsConfig.py", "InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/PixelConditionsConfig.py"], "PixelDetectorElementCondAlg": ["InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/ITkPixelConditionsConfig.py", "InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/PixelConditionsConfig.py"], "PixelDistortionAlg": ["InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/ITkPixelConditionsConfig.py", "InnerDetector/InDetConditions/PixelConditionsAlgorithms/python/PixelConditionsConfig.py"], "PixelConditionsSummaryTool": ["InnerDetector/InDetConditions/PixelConditionsTools/python/PixelConditionsSummaryConfig.py", "InnerDetector/InDetConditions/PixelConditionsTools/python/ITkPixelConditionsSummaryConfig.py"], "DetDescrDBEnvelopeSvc": ["AtlasGeometryCommon/SubDetectorEnvelopes/python/SubDetectorEnvelopesConfig.py", "Simulation/ISF/ISF_Geant4/ISF_Geant4Services/python/ISF_Geant4ServicesConfigNew.py"]} diff --git a/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/CMakeLists.txt b/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/CMakeLists.txt index 87f920a0cbf4..c4007f0268f8 100644 --- a/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/CMakeLists.txt +++ b/MuonSpectrometer/MuonReconstruction/MuonRecTools/MuonRecToolInterfaces/CMakeLists.txt @@ -8,5 +8,5 @@ atlas_subdir( MuonRecToolInterfaces ) # Component(s) in the package: atlas_add_library( MuonRecToolInterfaces PUBLIC_HEADERS MuonRecToolInterfaces - LINK_LIBRARIES GeoPrimitives Identifier EventPrimitives xAODTracking GeneratorObjects GaudiKernel MuonClusterizationLib MuonLayerEvent MuonPattern MuonPrepRawData MuonRIO_OnTrack MuonSegment MuonEDM_AssociationObjects MuonLayerHough MuonSimData MuonCombinedEvent TrkEventPrimitives TrkMeasurementBase TrkParameters TrkPrepRawData TrkTrack TrkTruthData TrkToolInterfaces TrkDriftCircleMath MuonStationIndexLib TrkCompetingRIOsOnTrackToolLib ) + LINK_LIBRARIES GeoPrimitives Identifier EventPrimitives xAODTracking GeneratorObjects GaudiKernel MuonClusterizationLib MuonLayerEvent MuonPattern MuonPrepRawData MuonRIO_OnTrack MuonSegment MuonEDM_AssociationObjects MuonLayerHough MuonSimData MuonCombinedEvent TrkEventPrimitives TrkMeasurementBase TrkParameters TrkPrepRawData TrkTrack TrkTruthData TrkToolInterfaces TrkDriftCircleMath MuonStationIndexLib ) diff --git a/Tracking/TrkTools/TrkToolInterfaces/doc/packagedoc.h b/Tracking/TrkTools/TrkToolInterfaces/doc/packagedoc.h index 5c9725b9b077..b99b47ee4b69 100644 --- a/Tracking/TrkTools/TrkToolInterfaces/doc/packagedoc.h +++ b/Tracking/TrkTools/TrkToolInterfaces/doc/packagedoc.h @@ -21,7 +21,6 @@ Abstract interfaces for the following tracking tasks are defined: @htmlinclude annotated.html - Trk::IAmbiTrackSelectionTool : forms new tracks using information about shared and already associated hits - - Trk::ICompetingRIOsOnTrackTool : creates Trk::CompetingRIOsOnTrack objects from a list of mutually exclusive PrepRawData and a track hypothesis - Trk::IDetailedTrackTruthBuilder : creates full truth information at track level - Trk::IDetailedTrackTruthSimilarity : Interface for track-truth match quality estimator tools - Trk::IPatternParametersUpdator : Interface for updating Trk::PatternTrackParameters with measurements @@ -45,7 +44,6 @@ Abstract interfaces for the following tracking tasks are defined: - Trk::ITruthToTrack : converts MC-generator particle parameters into EDM representation for validation studies - Trk::ITruthTrajectoryBuilder : collects MC-generator information to build full (truth) trajectory across the detector - Trk::IUpdator : collection of methods operating on track states, mainly for Kalman filtering - - Trk::IWeightCalculator : encapsulates the calculations of assignmentProbabilities of competing measurements to a track This package is not built as any library, it is a simple include package. -- GitLab