From a47254c6f6e29a0e9f79c88d4b64d4d7183e1989 Mon Sep 17 00:00:00 2001
From: "s.zharko@gsi.de" <s.zharko@gsi.de>
Date: Tue, 10 Sep 2024 02:29:53 +0200
Subject: [PATCH] Tracking detector interfaces: replacement of virtual getters
 override with the vector access

---
 .../base/CbmTrackingDetectorInterfaceBase.cxx | 15 +---
 core/base/CbmTrackingDetectorInterfaceBase.h  | 21 ++---
 .../much/CbmMuchTrackingInterface.cxx         | 27 ++-----
 .../detectors/much/CbmMuchTrackingInterface.h | 65 ++++------------
 .../detectors/mvd/CbmMvdTrackingInterface.cxx | 13 ++--
 core/detectors/mvd/CbmMvdTrackingInterface.h  | 58 +++-----------
 .../detectors/sts/CbmStsTrackingInterface.cxx | 14 ++--
 core/detectors/sts/CbmStsTrackingInterface.h  | 63 +++------------
 .../detectors/tof/CbmTofTrackingInterface.cxx | 12 +--
 core/detectors/tof/CbmTofTrackingInterface.h  | 69 ++++-------------
 .../detectors/trd/CbmTrdTrackingInterface.cxx | 37 +++------
 core/detectors/trd/CbmTrdTrackingInterface.h  | 76 +++----------------
 12 files changed, 106 insertions(+), 364 deletions(-)

diff --git a/core/base/CbmTrackingDetectorInterfaceBase.cxx b/core/base/CbmTrackingDetectorInterfaceBase.cxx
index e8a69dbbd0..8720cf43e9 100644
--- a/core/base/CbmTrackingDetectorInterfaceBase.cxx
+++ b/core/base/CbmTrackingDetectorInterfaceBase.cxx
@@ -1,4 +1,4 @@
-/* Copyright (C) 2022-2023 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
+/* Copyright (C) 2022-2024 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
    SPDX-License-Identifier: GPL-3.0-only
    Authors: Sergey Gorbunov, Sergei Zharko [committer] */
 
@@ -125,19 +125,6 @@ std::string CbmTrackingDetectorInterfaceBase::ToString() const
     table << setw(10) << IsTimeInfoProvided(iSt) << ' ';
     table << '\n';
   }
-  table << "--------------\n";
-  for (int iSt = 0; iSt < GetNtrackingStations(); ++iSt) {
-    table << setw(5) << iSt << ' ';
-    table << setw(10) << fvStations[iSt].fZref << ' ';
-    table << setw(10) << fvStations[iSt].fZmin << ' ';
-    table << setw(10) << fvStations[iSt].fZmax << ' ';
-    table << setw(10) << fvStations[iSt].fXmin << ' ';
-    table << setw(10) << fvStations[iSt].fXmax << ' ';
-    table << setw(10) << fvStations[iSt].fYmin << ' ';
-    table << setw(10) << fvStations[iSt].fYmax << ' ';
-    table << setw(10) << IsTimeInfoProvided(iSt) << ' ';
-    table << '\n';
-  }
   return table.str();
 }
 
diff --git a/core/base/CbmTrackingDetectorInterfaceBase.h b/core/base/CbmTrackingDetectorInterfaceBase.h
index 0271756774..d66f152516 100644
--- a/core/base/CbmTrackingDetectorInterfaceBase.h
+++ b/core/base/CbmTrackingDetectorInterfaceBase.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2022-2023 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
+/* Copyright (C) 2022-2024 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
    SPDX-License-Identifier: GPL-3.0-only
    Authors: Sergey Gorbunov, Sergei Zharko [committer] */
 
@@ -67,7 +67,7 @@ public:
   virtual std::string GetDetectorName() const = 0;
 
   /// @brief Gets actual number of stations, provided by the current geometry setup
-  virtual int GetNtrackingStations() const = 0;
+  int GetNtrackingStations() const { return fvStations.size(); }
 
   /// @brief Gets stereo angles of the two independent measured coordinates
   /// @note  The tracking does not use this method. It is only used by the QA task.
@@ -93,27 +93,27 @@ public:
   /// @brief  Gets upper bound of a station along the X-axis
   /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
   /// @return Size of station along the X-axis [cm]
-  virtual double GetXmax(int stationId) const = 0;
+  double GetXmax(int stationId) const { return fvStations[stationId].fXmax; }
 
   /// @brief  Gets lower bound of a station along the X-axis
   /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
   /// @return Size of station along the X-axis [cm]
-  virtual double GetXmin(int stationId) const = 0;
+  double GetXmin(int stationId) const { return fvStations[stationId].fXmin; }
 
   /// @brief  Gets upper bound of a station along the Y-axis
   /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
   /// @return Size of station along the Y-axis [cm]
-  virtual double GetYmax(int stationId) const = 0;
+  double GetYmax(int stationId) const { return fvStations[stationId].fYmax; }
 
   /// @brief  Gets lower bound of a station along the Y-axis
   /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
   /// @return Size of station along the Y-axis [cm]
-  virtual double GetYmin(int stationId) const = 0;
+  double GetYmin(int stationId) const { return fvStations[stationId].fYmin; }
 
   /// @brief  Gets reference z of the station
   /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
   /// @return Reference z position of the station [cm]
-  virtual double GetZref(int stationId) const = 0;
+  double GetZref(int stationId) const { return fvStations[stationId].fZref; };
 
   /// @brief  Gets reference z of the detector module (e.g., RPC for TOF)
   /// @param  address  Address of the module
@@ -123,12 +123,12 @@ public:
   /// @brief  Gets min z of the station
   /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
   /// @return min Z of the station [cm]
-  virtual double GetZmin(int stationId) const = 0;
+  double GetZmin(int stationId) const { return fvStations[stationId].fZmin; }
 
   /// @brief  Gets max z of the station
   /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
   /// @return max Z of the station [cm]
-  virtual double GetZmax(int stationId) const = 0;
+  double GetZmax(int stationId) const { return fvStations[stationId].fZmax; }
 
   /// @brief  Check if station provides time measurements
   /// @param  stationId  Tracking station ID in the setup
@@ -138,7 +138,7 @@ public:
   /// @brief  Gets x,y,t ranges of a CbmPixelHit
   /// @param  hit  A hit
   /// @return range X, Y, T
-  std::tuple<double, double, double> GetHitRanges(const CbmPixelHit& hit) const
+  virtual std::tuple<double, double, double> GetHitRanges(const CbmPixelHit& hit) const
   {
     // by default assume gaussian distributions of errors
     return std::tuple(3.5 * hit.GetDx(), 3.5 * hit.GetDy(), 3.5 * hit.GetTimeError());
@@ -168,6 +168,7 @@ public:
 
   /// @brief Creates volume info from a geo node provided by path
   /// @param path  Path to volume in TGeoManager
+  /// @throw std::runtime_error  If node is not found by path
   VolumeInfo ReadVolume(const TString& path);
 
   std::vector<VolumeInfo> fvStations{};  ///< Geometric properties of stations
diff --git a/core/detectors/much/CbmMuchTrackingInterface.cxx b/core/detectors/much/CbmMuchTrackingInterface.cxx
index 3411721649..60a9f61984 100644
--- a/core/detectors/much/CbmMuchTrackingInterface.cxx
+++ b/core/detectors/much/CbmMuchTrackingInterface.cxx
@@ -19,34 +19,21 @@ ClassImp(CbmMuchTrackingInterface)
 
   CbmMuchTrackingInterface* CbmMuchTrackingInterface::fpInstance = nullptr;
 
-//-------------------------------------------------------------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------------------------------------------------
 //
 CbmMuchTrackingInterface::CbmMuchTrackingInterface() : FairTask("CbmMuchTrackingInterface")
 {
   if (!fpInstance) { fpInstance = this; }
 }
 
-//-------------------------------------------------------------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------------------------------------------------
 //
 CbmMuchTrackingInterface::~CbmMuchTrackingInterface()
 {
   if (fpInstance == this) { fpInstance = nullptr; }
 }
 
-//-------------------------------------------------------------------------------------------------------------------------------------
-//
-int CbmMuchTrackingInterface::GetNtrackingStations() const
-{
-  // NOTE: For MuCh detector subsystem, a MuCh layer is assigned as a tracking station! Thus, we here separate names for MuCh stations:
-  // iMuchSt, muchStationId and for the tracking stations - iSt, stationId
-  int nStations = 0;
-  for (int iMuchSt = 0; iMuchSt < fGeoScheme->GetNStations(); ++iMuchSt) {
-    nStations += fGeoScheme->GetStation(iMuchSt)->GetNLayers();
-  }
-  return nStations;
-}
-
-//-------------------------------------------------------------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------------------------------------------------
 //
 InitStatus CbmMuchTrackingInterface::Init()
 {
@@ -106,7 +93,7 @@ InitStatus CbmMuchTrackingInterface::Init()
   return kSUCCESS;
 }
 
-//-------------------------------------------------------------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------------------------------------------------
 //
 InitStatus CbmMuchTrackingInterface::ReInit()
 {
@@ -114,13 +101,13 @@ InitStatus CbmMuchTrackingInterface::ReInit()
   return Init();
 }
 
-//-------------------------------------------------------------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------------------------------------------------
 //
 void CbmMuchTrackingInterface::SetParContainers() {}
 
-//-------------------------------------------------------------------------------------------------------------------------------------
-//
 
+// ---------------------------------------------------------------------------------------------------------------------
+//
 std::pair<int, int> CbmMuchTrackingInterface::ConvTrackingStationId2MuchId(int traStationId) const
 {
   int muchStation = fFirstTrackingStation.size() - 1;
diff --git a/core/detectors/much/CbmMuchTrackingInterface.h b/core/detectors/much/CbmMuchTrackingInterface.h
index 8449b0b05f..a9d6163ae0 100644
--- a/core/detectors/much/CbmMuchTrackingInterface.h
+++ b/core/detectors/much/CbmMuchTrackingInterface.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2022-2023 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
+/* Copyright (C) 2022-2024 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
    SPDX-License-Identifier: GPL-3.0-only
    Authors: Sergey Gorbunov, Sergei Zharko [committer] */
 
@@ -56,10 +56,10 @@ public:
   CbmMuchTrackingInterface& operator=(CbmMuchTrackingInterface&&) = delete;
 
   /// @brief FairTask: Init method
-  InitStatus Init();
+  InitStatus Init() override;
 
   /// @brief FairTask: ReInit method
-  InitStatus ReInit();
+  InitStatus ReInit() override;
 
   /// @brief Gets pointer to the instance of the CbmMuchTrackingInterface
   static CbmMuchTrackingInterface* Instance() { return fpInstance; }
@@ -67,33 +67,15 @@ public:
   /// @brief Gets name of this subsystem
   std::string GetDetectorName() const { return "MuCh"; }
 
-  /// @brief Gets actual number of tracking stations, provided by the current geometry setup
-  int GetNtrackingStations() const;
-
-  /// @brief  Gets reference z of the station
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return Reference z position of the station [cm]
-  double GetZref(int stationId) const { return GetMuchLayer(stationId)->GetZ(); }
-
-  /// @brief  Gets min z of the station
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return min Z of the station [cm]
-  double GetZmin(int stationId) const { return GetZref(stationId) - 0.5 * GetMuchLayer(stationId)->GetDz(); }
-
-  /// @brief  Gets max z of the station
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return max Z of the station [cm]
-  double GetZmax(int stationId) const { return GetZref(stationId) + 0.5 * GetMuchLayer(stationId)->GetDz(); }
-
   /// @brief  Gets a tracking station of a CbmHit
   /// @param  hit  A pointer to CbmHit
   /// @return Local index of the tracking station
-  int GetTrackingStationIndex(const CbmHit* hit) const { return GetTrackingStationIndex(hit->GetAddress()); }
+  int GetTrackingStationIndex(const CbmHit* hit) const override { return GetTrackingStationIndex(hit->GetAddress()); }
 
   /// @brief  Gets a tracking station by the address of element
   /// @param  address  Unique element address
   /// @return Local index of the tracking station
-  int GetTrackingStationIndex(int address) const
+  int GetTrackingStationIndex(int address) const override
   {
     return fFirstTrackingStation.at(CbmMuchGeoScheme::GetStationIndex(address))
            + CbmMuchGeoScheme::GetLayerIndex(address);
@@ -102,50 +84,29 @@ public:
   /// @brief  Gets a tracking station of a FairMCPoint
   /// @param  point  A pointer to FairMCHit
   /// @return Local index of the tracking station
-  int GetTrackingStationIndex(const FairMCPoint* point) const
+  int GetTrackingStationIndex(const FairMCPoint* point) const override
   {
     return GetTrackingStationIndex(point->GetDetectorID());
   }
 
-  // TODO: SZh 30.08.2023: Provide automatic definintion of bounds
-  /// @brief  Gets upper bound of a station along the X-axis
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return Size of station along the X-axis [cm]
-  double GetXmax(int /*stationId*/) const { return 100.; }
-
-  // TODO: SZh 30.08.2023: Provide automatic definintion of bounds
-  /// @brief  Gets lower bound of a station along the X-axis
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return Size of station along the X-axis [cm]
-  double GetXmin(int /*stationId*/) const { return -100.; }
-
-  // TODO: SZh 30.08.2023: Provide automatic definintion of bounds
-  /// @brief  Gets upper bound of a station along the Y-axis
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return Size of station along the Y-axis [cm]
-  double GetYmax(int /*stationId*/) const { return 100.; }
-
-  // TODO: SZh 30.08.2023: Provide automatic definintion of bounds
-  /// @brief  Gets lower bound of a station along the Y-axis
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return Size of station along the Y-axis [cm]
-  double GetYmin(int /*stationId*/) const { return -100.; }
-
   /// @brief  Check if station provides time measurements
   /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
   /// @return Flag: true - station provides time measurements, false - station does not provide time measurements
-  bool IsTimeInfoProvided(int /*stationId*/) const { return true; }
+  bool IsTimeInfoProvided(int /*stationId*/) const override { return true; }
 
   /// @brief  Gets stereo angles of the two independent measured coordinates
   /// @note   The tracking does not use this method. It is only used by the QA task.
   /// @param  address  detector unique identifier
   /// @return [phiU, phiV] - Stereo angles [rad]
-  std::tuple<double, double> GetStereoAnglesSensor(int /*address*/) const { return std::tuple(0., TMath::Pi() / 2.); }
+  std::tuple<double, double> GetStereoAnglesSensor(int /*address*/) const override
+  {
+    return std::tuple(0., TMath::Pi() / 2.);
+  }
 
   /// @brief FairTask: sets parameter containers up
-  void SetParContainers();
+  void SetParContainers() override;
 
-private:
+ private:
   /// @brief  Gets pointer to the TRD module
   /// @param  stationId  Tracking staton ID
   /// @return Pointer to the particular CbmTrdParModDigi object
diff --git a/core/detectors/mvd/CbmMvdTrackingInterface.cxx b/core/detectors/mvd/CbmMvdTrackingInterface.cxx
index eaadd4eeaf..85898f50bd 100644
--- a/core/detectors/mvd/CbmMvdTrackingInterface.cxx
+++ b/core/detectors/mvd/CbmMvdTrackingInterface.cxx
@@ -21,21 +21,21 @@ ClassImp(CbmMvdTrackingInterface)
 
   CbmMvdTrackingInterface* CbmMvdTrackingInterface::fpInstance = nullptr;
 
-//-------------------------------------------------------------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------------------------------------------------
 //
 CbmMvdTrackingInterface::CbmMvdTrackingInterface() : FairTask("CbmMvdTrackingInterface")
 {
   if (!fpInstance) { fpInstance = this; }
 }
 
-//-------------------------------------------------------------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------------------------------------------------
 //
 CbmMvdTrackingInterface::~CbmMvdTrackingInterface()
 {
   if (fpInstance == this) { fpInstance = nullptr; }
 }
 
-//-------------------------------------------------------------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------------------------------------------------
 //
 InitStatus CbmMvdTrackingInterface::Init()
 {
@@ -66,7 +66,7 @@ InitStatus CbmMvdTrackingInterface::Init()
   return kSUCCESS;
 }
 
-//-------------------------------------------------------------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------------------------------------------------
 //
 InitStatus CbmMvdTrackingInterface::ReInit()
 {
@@ -74,13 +74,12 @@ InitStatus CbmMvdTrackingInterface::ReInit()
   return Init();
 }
 
-//-------------------------------------------------------------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------------------------------------------------
 //
 void CbmMvdTrackingInterface::SetParContainers() {}
 
-//-------------------------------------------------------------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------------------------------------------------
 //
-
 int CbmMvdTrackingInterface::GetTrackingStationIndex(const FairMCPoint* point) const
 {
   const CbmMvdPoint* mvdPoint = [&] {
diff --git a/core/detectors/mvd/CbmMvdTrackingInterface.h b/core/detectors/mvd/CbmMvdTrackingInterface.h
index eed072bf09..ec899d06a4 100644
--- a/core/detectors/mvd/CbmMvdTrackingInterface.h
+++ b/core/detectors/mvd/CbmMvdTrackingInterface.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2022-2023 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
+/* Copyright (C) 2022-2024 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
    SPDX-License-Identifier: GPL-3.0-only
    Authors: Sergey Gorbunov, Sergei Zharko [committer] */
 
@@ -58,9 +58,6 @@ public:
   /// @brief Gets name of this subsystem
   std::string GetDetectorName() const { return "MVD"; }
 
-  /// @brief Gets actual number of tracking stations, provided by the current geometry setup
-  int GetNtrackingStations() const { return fMvdStationPar->GetStationCount(); }
-
   /// --- to be removed --- Gets the tracking station radiation length
   /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
   /// @return Radiation length [cm]
@@ -74,7 +71,10 @@ public:
   /// @note   The tracking does not use this method. It is only used by the QA task.
   /// @param  address  detector unique identifier
   /// @return [phiU, phiV] - Stereo angles [rad]
-  std::tuple<double, double> GetStereoAnglesSensor(int /*address*/) const { return std::tuple(0., TMath::Pi() / 2.); }
+  std::tuple<double, double> GetStereoAnglesSensor(int /*address*/) const override
+  {
+    return std::tuple(0., TMath::Pi() / 2.);
+  }
 
   /// --- to be removed --- Gets the tracking station thickness along the Z-axis
   /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
@@ -85,7 +85,7 @@ public:
   /// @brief  Gets a tracking station of a CbmHit
   /// @param  hit  A pointer to CbmHit
   /// @return Local index of the tracking station
-  int GetTrackingStationIndex(const CbmHit* hit) const
+  int GetTrackingStationIndex(const CbmHit* hit) const override
   {
     auto hitMvd = [&] {
       if constexpr (kUseDynamicCast) { return dynamic_cast<const CbmMvdHit*>(hit); }
@@ -99,50 +99,16 @@ public:
   /// @brief  Gets a tracking station of a FairMCPoint
   /// @param  point  A pointer to FairMCHit
   /// @return Local index of the tracking station
-  int GetTrackingStationIndex(const FairMCPoint* point) const;
+  int GetTrackingStationIndex(const FairMCPoint* point) const override;
 
   /// @brief  Gets a tracking station by the address of element (detectorID in terms of MVD)
   /// @param  detectorId  Unique element address (detectorID in terms of MVD)
   /// @return Local index of the tracking station
-  int GetTrackingStationIndex(int detectorId) const { return StationNr(detectorId); }
-
-  /// @brief  Gets upper bound of a tracking station along the X-axis
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return Size of station along the X-axis [cm]
-  double GetXmax(int stationId) const { return fMvdStationPar->GetWidth(stationId); }
-
-  /// @brief  Gets lower bound of a tracking station along the X-axis
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return Size of station along the X-axis [cm]
-  double GetXmin(int stationId) const { return -fMvdStationPar->GetWidth(stationId); }
-
-  /// @brief  Gets upper bound of a tracking station along the Y-axis
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return Size of station along the Y-axis [cm]
-  double GetYmax(int stationId) const { return fMvdStationPar->GetHeight(stationId); }
-
-  /// @brief  Gets lower bound of a tracking station along the Y-axis
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return Size of station along the Y-axis [cm]
-  double GetYmin(int stationId) const { return -fMvdStationPar->GetHeight(stationId); }
-
-  /// @brief  Gets reference z of the station
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return Reference z position of the station [cm]
-  double GetZref(int stationId) const { return fMvdStationPar->GetZPosition(stationId); }
-
-  /// @brief  Gets max z of the station
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return max Z of the station [cm]
-  double GetZmax(int stationId) const { return GetZref(stationId) + 0.5 * fMvdStationPar->GetZThickness(stationId); }
+  int GetTrackingStationIndex(int detectorId) const override { return StationNr(detectorId); }
 
-  /// @brief  Gets min z of the station
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return min Z of the station [cm]
-  double GetZmin(int stationId) const { return GetZref(stationId) - 0.5 * fMvdStationPar->GetZThickness(stationId); }
 
   /// @brief FairTask: Init method
-  InitStatus Init();
+  InitStatus Init() override;
 
   /// @brief Gets pointer to the instance of the CbmMvdTrackingInterface
   static CbmMvdTrackingInterface* Instance() { return fpInstance; }
@@ -153,12 +119,12 @@ public:
   bool IsTimeInfoProvided(int /*stationId*/) const { return true; }
 
   /// @brief FairTask: ReInit method
-  InitStatus ReInit();
+  InitStatus ReInit() override;
 
   /// @brief FairTask: sets parameter containers up
-  void SetParContainers();
+  void SetParContainers() override;
 
-private:
+ private:
   static CbmMvdTrackingInterface* fpInstance;  ///< Instance of the class
 
   const CbmMvdStationPar* fMvdStationPar {nullptr};  ///< Pointer to the Mvd station parameters
diff --git a/core/detectors/sts/CbmStsTrackingInterface.cxx b/core/detectors/sts/CbmStsTrackingInterface.cxx
index 5e45e64926..e3c9533a35 100644
--- a/core/detectors/sts/CbmStsTrackingInterface.cxx
+++ b/core/detectors/sts/CbmStsTrackingInterface.cxx
@@ -21,21 +21,21 @@ ClassImp(CbmStsTrackingInterface)
 
   CbmStsTrackingInterface* CbmStsTrackingInterface::fpInstance = nullptr;
 
-//-------------------------------------------------------------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------------------------------------------------
 //
 CbmStsTrackingInterface::CbmStsTrackingInterface() : FairTask("CbmStsTrackingInterface")
 {
   if (!fpInstance) { fpInstance = this; }
 }
 
-//-------------------------------------------------------------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------------------------------------------------
 //
 CbmStsTrackingInterface::~CbmStsTrackingInterface()
 {
   if (fpInstance == this) { fpInstance = nullptr; }
 }
 
-//-------------------------------------------------------------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------------------------------------------------
 //
 std::tuple<double, double> CbmStsTrackingInterface::GetStereoAnglesSensor(int address) const
 {
@@ -75,7 +75,7 @@ std::tuple<double, double> CbmStsTrackingInterface::GetStereoAnglesSensor(int ad
   return std::tuple(angleF, angleB);
 }
 
-//-------------------------------------------------------------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------------------------------------------------
 //
 InitStatus CbmStsTrackingInterface::Init()
 {
@@ -121,7 +121,7 @@ InitStatus CbmStsTrackingInterface::Init()
   return kSUCCESS;
 }
 
-//-------------------------------------------------------------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------------------------------------------------
 //
 InitStatus CbmStsTrackingInterface::ReInit()
 {
@@ -129,7 +129,7 @@ InitStatus CbmStsTrackingInterface::ReInit()
   return Init();
 }
 
-//-------------------------------------------------------------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------------------------------------------------
 //
 void CbmStsTrackingInterface::SetParContainers()
 {
@@ -148,5 +148,3 @@ void CbmStsTrackingInterface::SetParContainers()
   }
 }
 
-//-------------------------------------------------------------------------------------------------------------------------------------
-//
diff --git a/core/detectors/sts/CbmStsTrackingInterface.h b/core/detectors/sts/CbmStsTrackingInterface.h
index b81307ae39..c1a4ae8222 100644
--- a/core/detectors/sts/CbmStsTrackingInterface.h
+++ b/core/detectors/sts/CbmStsTrackingInterface.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2022-2023 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
+/* Copyright (C) 2022-2024 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
    SPDX-License-Identifier: GPL-3.0-only
    Authors: Sergey Gorbunov, Sergei Zharko [committer] */
 
@@ -51,87 +51,46 @@ public:
   /// @brief Move assignment operator
   CbmStsTrackingInterface& operator=(CbmStsTrackingInterface&&) = delete;
 
-
   /// @brief FairTask: Init method
-  InitStatus Init();
+  InitStatus Init() override;
 
   /// @brief FairTask: ReInit method
-  InitStatus ReInit();
+  InitStatus ReInit() override;
 
   /// @brief Gets pointer to the instance of the CbmStsTrackingInterface class
   static CbmStsTrackingInterface* Instance() { return fpInstance; }
 
   /// @brief Gets name of this subsystem
-  std::string GetDetectorName() const { return "STS"; }
-
-  /// @brief Gets actual number of the tracking stations, provided by the current geometry setup
-  int GetNtrackingStations() const { return CbmStsSetup::Instance()->GetNofStations(); }
+  std::string GetDetectorName() const override { return "STS"; }
 
   /// @brief  Gets stereo angles of the two independent measured coordinates
   /// @note   The tracking does not use this method. It is only used by the QA task.
   /// @param  address  detector unique identifier
   /// @return [phiU, phiV] - Stereo angles [rad]
-  std::tuple<double, double> GetStereoAnglesSensor(int address) const;
+  std::tuple<double, double> GetStereoAnglesSensor(int address) const override;
 
   /// @brief  Gets a tracking station of a CbmHit
   /// @param  hit  A pointer to CbmHit
   /// @return Local index of the tracking station
-  int GetTrackingStationIndex(const CbmHit* hit) const { return GetTrackingStationIndex(hit->GetAddress()); }
+  int GetTrackingStationIndex(const CbmHit* hit) const override { return GetTrackingStationIndex(hit->GetAddress()); }
 
   /// @brief  Gets a tracking station by the address of element
   /// @param  address  Unique element address
   /// @return Local index of the tracking station
-  int GetTrackingStationIndex(int address) const { return CbmStsSetup::Instance()->GetStationNumber(address); }
+  int GetTrackingStationIndex(int address) const override { return CbmStsSetup::Instance()->GetStationNumber(address); }
 
   /// @brief  Gets a tracking station of a FairMCPoint
   /// @param  point  A pointer to FairMCHit
   /// @return Local index of the tracking station
-  int GetTrackingStationIndex(const FairMCPoint* point) const
+  int GetTrackingStationIndex(const FairMCPoint* point) const override
   {
     return GetTrackingStationIndex(point->GetDetectorID());
   }
 
-  /// @brief  Gets upper edge of a station along the X-axis
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return Size of station along the X-axis [cm]
-  double GetXmax(int stationId) const { return GetStsStation(stationId)->GetXmax(); }
-
-  /// @brief  Gets lower edge of a station along the X-axis
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return Size of station along the X-axis [cm]
-  double GetXmin(int stationId) const { return GetStsStation(stationId)->GetXmin(); }
-
-  /// @brief  Gets max size of a station along the Y-axis
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return Size of station along the Y-axis [cm]
-  double GetYmax(int stationId) const { return GetStsStation(stationId)->GetYmax(); }
-
-  /// @brief  Gets lower edge of a station along the Y-axis
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return Size of station along the Y-axis [cm]
-  double GetYmin(int stationId) const { return GetStsStation(stationId)->GetYmin(); }
-
-  /// @brief  Gets reference Z position of the station: approximately == mean Z of all its component
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return Reference z position of station [cm]
-  double GetZref(int stationId) const { return GetStsStation(stationId)->GetZ(); }
-
-  /// @brief  Gets maximal z of the station
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return max z position of station [cm]
-  // TODO: calculate from components
-  double GetZmax(int stationId) const { return GetStsStation(stationId)->GetZ() + 2.; }
-
-  /// @brief  Gets minimal z of the station
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return min z position of station [cm]
-  // TODO: calculate from components
-  double GetZmin(int stationId) const { return GetStsStation(stationId)->GetZ() - 2.; }
-
   /// @brief  Check if station provides time measurements
   /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
   /// @return Flag: true - station provides time measurements, false - station does not provide time measurements
-  bool IsTimeInfoProvided(int /*stationId*/) const { return true; }
+  bool IsTimeInfoProvided(int /*stationId*/) const override { return true; }
 
   /// -- to be removed -- Gets station radiation length
   /// \param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
@@ -146,9 +105,9 @@ public:
   [[deprecated]] double GetSensorThickness(int stationId) const { return GetStsStation(stationId)->GetSensorD(); }
 
   /// @brief FairTask: sets parameter containers up
-  void SetParContainers();
+  void SetParContainers() override;
 
-private:
+ private:
   /// @brief  Gets pointer to the STS station object
   /// @param  stationId  Tracking staton ID
   /// @return Pointer to the particular CbmStsStation object
diff --git a/core/detectors/tof/CbmTofTrackingInterface.cxx b/core/detectors/tof/CbmTofTrackingInterface.cxx
index f233c523fa..ecc9928db2 100644
--- a/core/detectors/tof/CbmTofTrackingInterface.cxx
+++ b/core/detectors/tof/CbmTofTrackingInterface.cxx
@@ -1,4 +1,4 @@
-/* Copyright (C) 2022 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
+/* Copyright (C) 2022-2024 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
    SPDX-License-Identifier: GPL-3.0-only
    Authors: Sergey Gorbunov, Sergei Zharko [committer] */
 
@@ -24,7 +24,7 @@ ClassImp(CbmTofTrackingInterface)
 
   CbmTofTrackingInterface* CbmTofTrackingInterface::fpInstance = nullptr;
 
-//-------------------------------------------------------------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------------------------------------------------
 //
 CbmTofTrackingInterface::CbmTofTrackingInterface() : FairTask("CbmTofTrackingInterface")
 {
@@ -33,7 +33,7 @@ CbmTofTrackingInterface::CbmTofTrackingInterface() : FairTask("CbmTofTrackingInt
   }
 }
 
-//-------------------------------------------------------------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------------------------------------------------
 //
 CbmTofTrackingInterface::~CbmTofTrackingInterface()
 {
@@ -42,7 +42,7 @@ CbmTofTrackingInterface::~CbmTofTrackingInterface()
   }
 }
 
-//-------------------------------------------------------------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------------------------------------------------
 //
 InitStatus CbmTofTrackingInterface::Init()
 {
@@ -159,7 +159,7 @@ InitStatus CbmTofTrackingInterface::Init()
   return kSUCCESS;
 }
 
-//-------------------------------------------------------------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------------------------------------------------
 //
 InitStatus CbmTofTrackingInterface::ReInit()
 {
@@ -167,7 +167,7 @@ InitStatus CbmTofTrackingInterface::ReInit()
   return Init();
 }
 
-//-------------------------------------------------------------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------------------------------------------------
 //
 void CbmTofTrackingInterface::SetParContainers()
 {
diff --git a/core/detectors/tof/CbmTofTrackingInterface.h b/core/detectors/tof/CbmTofTrackingInterface.h
index 365db1e321..cc970114be 100644
--- a/core/detectors/tof/CbmTofTrackingInterface.h
+++ b/core/detectors/tof/CbmTofTrackingInterface.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2022-2023 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
+/* Copyright (C) 2022-2024 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
    SPDX-License-Identifier: GPL-3.0-only
    Authors: Sergey Gorbunov, Sergei Zharko [committer] */
 
@@ -53,24 +53,24 @@ class CbmTofTrackingInterface : public FairTask, public CbmTrackingDetectorInter
   /// @brief Gets name of this subsystem
   std::string GetDetectorName() const { return "TOF"; }
 
-  /// @brief Gets actual number of tracking stations, provided by the current geometry setup
-  int GetNtrackingStations() const { return fDigiBdfPar->GetNbTrackingStations(); }
-
   /// @brief  Gets stereo angles of the two independent measured coordinates
   /// @note   The tracking does not use this method. It is only used by the QA task.
   /// @param  address  detector unique identifier
   /// @return [phiU, phiV] - Stereo angles [rad]
-  std::tuple<double, double> GetStereoAnglesSensor(int /*address*/) const { return std::tuple(0., TMath::Pi() / 2.); }
+  std::tuple<double, double> GetStereoAnglesSensor(int /*address*/) const override
+  {
+    return std::tuple(0., TMath::Pi() / 2.);
+  }
 
   /// @brief  Gets a tracking station of a ToF hit
   /// @param  hit  A pointer to ToF hit
   /// @return Local index of the tracking station
-  int GetTrackingStationIndex(const CbmHit* hit) const { return GetTrackingStationIndex(hit->GetAddress()); }
+  int GetTrackingStationIndex(const CbmHit* hit) const override { return GetTrackingStationIndex(hit->GetAddress()); }
 
   /// @brief  Gets a tracking station by the address of element
   /// @param  address  Unique element address
   /// @return Local index of the tracking station
-  int GetTrackingStationIndex(int address) const
+  int GetTrackingStationIndex(int address) const override
   {
     int iSt = fDigiBdfPar->GetTrackingStation(CbmTofAddress::GetSmType(address), CbmTofAddress::GetSmId(address),
                                               CbmTofAddress::GetRpcId(address));
@@ -80,80 +80,37 @@ class CbmTofTrackingInterface : public FairTask, public CbmTrackingDetectorInter
   /// @brief  Gets a tracking station of a FairMCPoint
   /// @param  point  A pointer to FairMCHit
   /// @return Local index of the tracking station
-  int GetTrackingStationIndex(const FairMCPoint* point) const
+  int GetTrackingStationIndex(const FairMCPoint* point) const override
   {
     return GetTrackingStationIndex(point->GetDetectorID());
   }
 
-  // TODO: SZh. 10.09.2023: Provide automatic selection
-  /// @brief  Gets upper bound of a station along the X-axis
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return Size of station along the X-axis [cm]
-  double GetXmax(int /*stationId*/) const { return 100; }
-
-  // TODO: SZh. 10.09.2023: Provide automatic definition
-  /// @brief  Gets lower bound of a station along the X-axis
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return Size of station along the X-axis [cm]
-  double GetXmin(int /*stationId*/) const { return -100; }
-
-  // TODO: SZh. 10.09.2023: Provide automatic definition
-  /// @brief  Gets max size of a station along the Y-axis
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return Size of station along the Y-axis [cm]
-  double GetYmax(int /*stationId*/) const { return 100; }
-
-  // TODO: SZh. 10.09.2023: Provide automatic definition
-  /// @brief  Gets max size of a station along the Y-axis
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return Size of station along the Y-axis [cm]
-  double GetYmin(int /*stationId*/) const { return -100; }
-
-  /// @brief  Gets reference z of the station
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return Reference z position of the station [cm]
-  double GetZref(int stationId) const { return fTofStationZ[stationId]; }
-
   /// @brief  Gets reference z of the detector module (e.g., RPC for TOF)
   /// @param  address  Address of the module
   /// @return Reference z of module (if not defined, the ref z of the station will be returned)
-  double GetZrefModule(int address)
+  double GetZrefModule(int address) override
   {
     auto* pCell = dynamic_cast<CbmTofCell*>(fDigiPar->GetCell(address));
     assert(pCell);
     return pCell->GetZ();
   }
 
-  /// Gets max z of the station
-  /// FIXME: Replace GetZref(stationId) + 5 with fTofStationZMax[stationId] + 0.5
-  /// \param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// \return max Z of the station [cm]
-  //double GetZmax(int stationId) const { return GetZref(stationId) + 5.; }
-  double GetZmax(int stationId) const { return fTofStationZMax[stationId] + .5; }
-
-  /// FIXME: Replace GetZref(stationId) - 5 with fTofStationZMin[stationId] - 0.5
-  /// @brief  Gets min z of the station
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return min Z of the station [cm]
-  //double GetZmin(int stationId) const { return GetZref(stationId) - 5.; }
-  double GetZmin(int stationId) const { return fTofStationZMin[stationId] - .5; }
-
   /// @brief  Check if station provides time measurements
   /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
   /// @return Flag: true - station provides time measurements, false - station does not provide time measurements
-  bool IsTimeInfoProvided(int /*stationId*/) const { return true; }
+  bool IsTimeInfoProvided(int /*stationId*/) const override { return true; }
 
   /// @brief FairTask: Init method
-  InitStatus Init();
+  InitStatus Init() override;
 
   /// @brief Gets pointer to the instance of the CbmTofTrackingInterface
   static CbmTofTrackingInterface* Instance() { return fpInstance; }
 
   /// @brief FairTask: ReInit method
-  InitStatus ReInit();
+  InitStatus ReInit() override;
 
   /// @brief FairTask: sets parameter containers up
-  void SetParContainers();
+  void SetParContainers() override;
 
  private:
   static CbmTofTrackingInterface* fpInstance;  ///< Instance of the class
diff --git a/core/detectors/trd/CbmTrdTrackingInterface.cxx b/core/detectors/trd/CbmTrdTrackingInterface.cxx
index 4477b9d024..8369859c83 100644
--- a/core/detectors/trd/CbmTrdTrackingInterface.cxx
+++ b/core/detectors/trd/CbmTrdTrackingInterface.cxx
@@ -1,4 +1,4 @@
-/* Copyright (C) 2022 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
+/* Copyright (C) 2022-2024 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
    SPDX-License-Identifier: GPL-3.0-only
    Authors: Sergey Gorbunov, Sergei Zharko [committer] */
 
@@ -25,41 +25,22 @@ ClassImp(CbmTrdTrackingInterface)
 
   CbmTrdTrackingInterface* CbmTrdTrackingInterface::fpInstance = nullptr;
 
-//-------------------------------------------------------------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------------------------------------------------
 //
 CbmTrdTrackingInterface::CbmTrdTrackingInterface() : FairTask("CbmTrdTrackingInterface")
 {
   if (!fpInstance) { fpInstance = this; }
 }
 
-//-------------------------------------------------------------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------------------------------------------------
 //
 CbmTrdTrackingInterface::~CbmTrdTrackingInterface()
 {
   if (fpInstance == this) { fpInstance = nullptr; }
 }
 
-//-------------------------------------------------------------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------------------------------------------------
 //
-int CbmTrdTrackingInterface::GetNtrackingStations() const
-{
-  // NOTE: For TRD detector subsystem, a TRD layer is assigned as a tracking station:
-  int nTrdLayers = 0;
-  auto topNodes  = gGeoManager->GetTopNode()->GetNodes();
-  for (int iTopNode = 0; iTopNode < topNodes->GetEntriesFast(); ++iTopNode) {
-    auto topNode = static_cast<TGeoNode*>(topNodes->At(iTopNode));
-    if (TString(topNode->GetName()).Contains("trd")) {
-      auto layers = topNode->GetNodes();
-      for (int iLayer = 0; iLayer < layers->GetEntriesFast(); ++iLayer) {
-        auto layer = static_cast<TGeoNode*>(layers->At(iLayer));
-        if (TString(layer->GetName()).Contains("layer")) { ++nTrdLayers; }
-      }
-    }
-  }
-  return nTrdLayers;
-}
-
-
 std::tuple<double, double> CbmTrdTrackingInterface::GetStereoAnglesSensor(int address) const
 {
   const CbmTrdParModDigi* par = dynamic_cast<const CbmTrdParModDigi*>(fTrdDigiPar->GetModulePar(address));
@@ -74,6 +55,8 @@ std::tuple<double, double> CbmTrdTrackingInterface::GetStereoAnglesSensor(int ad
   return std::tuple(0., TMath::Pi() / 2.);
 }
 
+// ---------------------------------------------------------------------------------------------------------------------
+//
 std::tuple<double, double, double> CbmTrdTrackingInterface::GetHitRanges(const CbmPixelHit& hit) const
 {
   const CbmTrdHit* trdHit = dynamic_cast<const CbmTrdHit*>(&hit);
@@ -102,7 +85,7 @@ std::tuple<double, double, double> CbmTrdTrackingInterface::GetHitRanges(const C
   return std::tuple(rangeX, rangeY, rangeT);
 }
 
-//-------------------------------------------------------------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------------------------------------------------
 //
 InitStatus CbmTrdTrackingInterface::Init()
 {
@@ -175,7 +158,7 @@ InitStatus CbmTrdTrackingInterface::Init()
   return kSUCCESS;
 }
 
-//-------------------------------------------------------------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------------------------------------------------
 //
 InitStatus CbmTrdTrackingInterface::ReInit()
 {
@@ -183,7 +166,7 @@ InitStatus CbmTrdTrackingInterface::ReInit()
   return Init();
 }
 
-//-------------------------------------------------------------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------------------------------------------------
 //
 void CbmTrdTrackingInterface::SetParContainers()
 {
@@ -194,5 +177,3 @@ void CbmTrdTrackingInterface::SetParContainers()
   }
 }
 
-//-------------------------------------------------------------------------------------------------------------------------------------
-//
diff --git a/core/detectors/trd/CbmTrdTrackingInterface.h b/core/detectors/trd/CbmTrdTrackingInterface.h
index 88355618d4..16ee4d943f 100644
--- a/core/detectors/trd/CbmTrdTrackingInterface.h
+++ b/core/detectors/trd/CbmTrdTrackingInterface.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2022-2023 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
+/* Copyright (C) 2022-2024 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
    SPDX-License-Identifier: GPL-3.0-only
    Authors: Sergey Gorbunov, Sergei Zharko [committer] */
 
@@ -50,107 +50,53 @@ class CbmTrdTrackingInterface : public FairTask, public CbmTrackingDetectorInter
   CbmTrdTrackingInterface& operator=(CbmTrdTrackingInterface&&) = delete;
 
   /// @brief Gets name of this subsystem
-  std::string GetDetectorName() const { return "TRD"; }
-
-  /// @brief Gets actual number of tracking stations, provided by the current geometry setup
-  int GetNtrackingStations() const;
+  std::string GetDetectorName() const override { return "TRD"; }
 
   /// @brief  Gets stereo angles of the two independent measured coordinates
   /// @note   The tracking does not use this method. It is only used by the QA task.
   /// @param  address  detector unique identifier
   /// @return [phiU, phiV] - Stereo angles [rad]
-  std::tuple<double, double> GetStereoAnglesSensor(int address) const;
+  std::tuple<double, double> GetStereoAnglesSensor(int address) const override;
 
   /// @brief  Gets a tracking station of a CbmHit
   /// @param  hit  A pointer to CbmHit
   /// @return Local index of the tracking station
-  int GetTrackingStationIndex(const CbmHit* hit) const { return GetTrackingStationIndex(hit->GetAddress()); }
+  int GetTrackingStationIndex(const CbmHit* hit) const override { return GetTrackingStationIndex(hit->GetAddress()); }
 
   /// @brief  Gets a tracking station by the address
   /// @param  address  Unique element address
   /// @return Local index of the tracking station
-  int GetTrackingStationIndex(int address) const { return CbmTrdAddress::GetLayerId(address); }
+  int GetTrackingStationIndex(int address) const override { return CbmTrdAddress::GetLayerId(address); }
 
   /// @brief  Gets a tracking station of a FairMCPoint
   /// @param  point  A pointer to FairMCHit
   /// @return Local index of the tracking station
-  int GetTrackingStationIndex(const FairMCPoint* point) const
+  int GetTrackingStationIndex(const FairMCPoint* point) const override
   {
     return GetTrackingStationIndex(point->GetDetectorID());
   }
 
-  /// @brief  Gets upper edge of a station along the X-axis
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return Size of station along the X-axis [cm]
-  double GetXmax(int stationId) const
-  {
-    const auto module = GetTrdModulePar(stationId);
-    return module->GetX() + module->GetSizeX();
-  }
-
-  /// @brief  Gets lower edge coordinate of a station along the X-axis
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return Size of station along the X-axis [cm]
-  double GetXmin(int stationId) const
-  {
-    const auto module = GetTrdModulePar(stationId);
-    return module->GetX() - module->GetSizeX();
-  }
-
-  /// @brief  Gets upper edge of a station along the Y-axis
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return Size of station along the Y-axis [cm]
-  double GetYmax(int stationId) const
-  {
-    const auto module = GetTrdModulePar(stationId);
-    return module->GetY() + module->GetSizeY();
-  }
-
-  /// @brief  Gets lower edge of a station along the Y-axis
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return Size of station along the Y-axis [cm]
-  double GetYmin(int stationId) const
-  {
-    const auto module = GetTrdModulePar(stationId);
-    return module->GetY() - module->GetSizeY();
-  }
-
-  /// @brief  Gets reference z of the station
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return Reference z position of the station [cm]
-  double GetZref(int stationId) const { return GetTrdModulePar(stationId)->GetZ(); }
-
-  /// @brief  Gets max z of the station
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return max Z of the station [cm]
-  double GetZmax(int stationId) const { return GetZref(stationId) + GetTrdModulePar(stationId)->GetSizeZ(); }
-
-  /// @brief  Gets min z of the station
-  /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
-  /// @return min Z of the station [cm]
-  double GetZmin(int stationId) const { return GetZref(stationId) - GetTrdModulePar(stationId)->GetSizeZ(); }
-
   /// @brief  Check if station provides time measurements
   /// @param  stationId  Tracking station ID in the setup (NOTE: must be in range [0..GetNstations()-1])
   /// @return Flag: true - station provides time measurements, false - station does not provide time measurements
-  bool IsTimeInfoProvided(int /*stationId*/) const { return true; }
+  bool IsTimeInfoProvided(int /*stationId*/) const override { return true; }
 
   /// @brief  Gets x,y,t ranges of a CbmTrdHit
   /// @param  hit  A hit
   /// @return range X, Y, T
-  std::tuple<double, double, double> GetHitRanges(const CbmPixelHit& hit) const;
+  std::tuple<double, double, double> GetHitRanges(const CbmPixelHit& hit) const override;
 
   /// @brief FairTask: Init method
-  InitStatus Init();
+  InitStatus Init() override;
 
   /// @brief Gets pointer to the instance of the CbmTrdTrackingInterface
   static CbmTrdTrackingInterface* Instance() { return fpInstance; }
 
   /// @brief FairTask: ReInit method
-  InitStatus ReInit();
+  InitStatus ReInit() override;
 
   /// @brief  FairTask: sets parameter containers up
-  void SetParContainers();
+  void SetParContainers() override;
 
  private:
   /// @brief  Gets pointer to the TRD module
-- 
GitLab