chore: Update doxygen documentation format (acts-project#4427)

- Update the format of the doxygen comments from /** @brief --> /// @brief
- Make the number of bins in the hough plane configurable

Author: junggjo9

Examples/Algorithms/TrackFinding/include/ActsExamples/TrackFinding/MuonHoughSeeder.hpp

@@ -36,16 +36,26 @@ namespace ActsExamples {
 /// given station.
 class MuonHoughSeeder final : public IAlgorithm {
  public:
-  /// config
+  /// @brief Configuration object of the Hough seeder
   struct Config {
+    /// @brief Container name of the truth segments (used for validation)
     std::string inTruthSegments{};
+    /// @brief Container name of the space point collection
     std::string inSpacePoints{};
+    /// @brief Container name of the output hough seed collection
     std::string outHoughMax{};
-
-    /** @brief Extra margin added to both y-sides of the eta-hough accumulator plane */
+    /// @brief Extra margin added to both y-sides of the eta-hough accumulator plane
     double etaPlaneMarginIcept{10. * Acts::UnitConstants::cm};
-    /** @brief Extra margin added to both y-sides of the phi-hough accumulator plane */
+    /// @brief Extra margin added to both y-sides of the phi-hough accumulator plane
     double phiPlaneMarginIcept{10. * Acts::UnitConstants::cm};
+    /// @brief Number of bins to scan tan (theta)
+    unsigned nBinsTanTheta = 25;
+    /// @brief Number of bins in y0 space (complementary to tan (theta))
+    unsigned nBinsY0 = 25;
+    /// @brief Number of bins to scan tan (phi)
+    unsigned nBinsTanPhi = 10;
+    /// @brief Number of bins in x0 space (omplementary to tan (phi))
+    unsigned nBinsX0 = 10;
   };
 
   MuonHoughSeeder(Config cfg, Acts::Logging::Level lvl);
@@ -63,46 +73,45 @@ class MuonHoughSeeder final : public IAlgorithm {
   const Config& config() const { return m_cfg; }
 
  private:
-  /** @brief Abbrivation of the HoughPlane_t */
+  /// @brief Abbrivation of the HoughPlane_t
   using HoughPlane_t =
       Acts::HoughTransformUtils::HoughPlane<const MuonSpacePoint*>;
-  /** @brief Abbrivation of the PeakFinder */
+  /// @brief Abbrivation of the PeakFinder
   using PeakFinder_t = Acts::HoughTransformUtils::PeakFinders::IslandsAroundMax<
       const MuonSpacePoint*>;
-  /** @brief Abbrivation of the PeakFinder configuration object  */
+  /// @brief Abbrivation of the PeakFinder configuration object
   using PeakFinderCfg_t =
       Acts::HoughTransformUtils::PeakFinders::IslandsAroundMaxConfig;
-  /** @brief Abbrivation of the HoughMaximum type returned by the PeakFinder */
+  /// @brief Abbrivation of the HoughMaximum type returned by the PeakFinder
   using Maximum_t = PeakFinder_t::Maximum;
-  /** @brief Abbrivation of the HoughMaximum vector */
+  /// @brief Abbrivation of the HoughMaximum vector
   using MaximumVec_t = std::vector<Maximum_t>;
-  /** @brief Abbrivation of the HoughTransform axis utils */
+  /// @brief Abbrivation of the HoughTransform axis utils
   using AxisRange_t = Acts::HoughTransformUtils::HoughAxisRanges;
-  /** @brief Abbrivation of the space point id */
+  /// @brief Abbrivation of the space point id
   using MuonId = MuonSpacePoint::MuonId;
 
-  /** @brief Find eta maxima from the space point bucket and fills them into a new
-   *         maximum container
-   *  @param ctx: Algorithm context needed for the display of the truth-parameters
-   *  @param bucket: Spacepoint bucket of interest
-   *  @param plane: Allocated hough plane to be recycled for all hough searches in the event*/
+  /// @brief Find eta maxima from the space point bucket and fills them into a new
+  ///        maximum container
+  /// @param ctx: Algorithm context needed for the display of the truth-parameters
+  /// @param bucket: Spacepoint bucket of interest
+  /// @param plane: Allocated hough plane to be recycled for all hough searches in the event
   MuonHoughMaxContainer constructEtaMaxima(const AlgorithmContext& ctx,
                                            const MuonSpacePointBucket& bucket,
                                            HoughPlane_t& plane) const;
-  /** @brief Extends the obtained eta maxima and tries to attach straight line parameters
-   *         in the non-precision plane (phi).
-   */
+  /// @brief Extends the obtained eta maxima and tries to attach straight line parameters
+  ///        in the non-precision plane (phi).
   MuonHoughMaxContainer extendMaximaWithPhi(const AlgorithmContext& ctx,
                                             MuonHoughMaxContainer&& etaMaxima,
                                             HoughPlane_t& plane) const;
 
-  /** @brief Displays the found maxima onto a TCanvas
-   *  @param ctx: Algorithm context to fetch the truth segment parameters
-   *  @param bucketId: identifier of the bucket to display on the Canvas and also
-   *                   to determine whether it's an eta / phi maximum
-   *  @param maxima: List of maxima from the PeakFinder
-   *  @param plane: Filled hough plane
-   *  @param axis: Axis range needed to interpret the hough binning */
+  /// @brief Displays the found maxima onto a TCanvas
+  /// @param ctx: Algorithm context to fetch the truth segment parameters
+  /// @param bucketId: identifier of the bucket to display on the Canvas and also
+  ///                  to determine whether it's an eta / phi maximum
+  /// @param maxima: List of maxima from the PeakFinder
+  /// @param plane: Filled hough plane
+  /// @param axis: Axis range needed to interpret the hough binning
   void displayMaxima(const AlgorithmContext& ctx, const MuonId& bucketId,
                      const MaximumVec_t& maxima, const HoughPlane_t& plane,
                      const AxisRange_t& axis) const;

Examples/Algorithms/TrackFinding/src/MuonHoughSeeder.cpp

@@ -87,12 +87,12 @@ ProcessCode MuonHoughSeeder::execute(const AlgorithmContext& ctx) const {
 
   // configure the binning of the hough plane
   Acts::HoughTransformUtils::HoughPlaneConfig etaPlaneCfg;
-  etaPlaneCfg.nBinsX = 25;
-  etaPlaneCfg.nBinsY = 25;
+  etaPlaneCfg.nBinsX = m_cfg.nBinsTanTheta;
+  etaPlaneCfg.nBinsY = m_cfg.nBinsY0;
 
   Acts::HoughTransformUtils::HoughPlaneConfig phiPlaneCfg;
-  phiPlaneCfg.nBinsX = 10;
-  phiPlaneCfg.nBinsY = 10;
+  phiPlaneCfg.nBinsX = m_cfg.nBinsTanPhi;
+  phiPlaneCfg.nBinsY = m_cfg.nBinsX0;
 
   // instantiate the hough plane
   HoughPlane_t etaPlane{etaPlaneCfg};

Examples/Framework/include/ActsExamples/EventData/MuonHoughMaximum.hpp

@@ -10,30 +10,31 @@
 #include "ActsExamples/EventData/MuonSpacePoint.hpp"
 
 namespace ActsExamples {
-/** @brief EDM class to store the result from the HoughTransform pattern finding step. The class takes the
- *         local line parameters of the transform in the precision direction
- * (tanAlpha, interceptY) if the transform, is performed to find an parameter
- * estimate in the bending direction or (tanAlpha, interceptY, tanBeta,
- * interceptX) if a second hough transform is performed on top of the first
- * transform to find the parameters in the complementary direction. Further, the
- * MuonHoughMaximum stores the list of all hits associated with the maximum. */
+///  @brief EDM class to store the result from the HoughTransform pattern finding step. The class takes the
+///         local line parameters of the transform in the precision direction
+///         (tanBeta, interceptY) if the transform, is performed to find an
+///         parameter estimate in the bending direction or (tanBeta, interceptY,
+///         tanAlpha, interceptX) if a second hough transform is performed on
+///         top of the first transform to find the parameters in the
+///         complementary direction. Further, the MuonHoughMaximum stores the
+///         list of all hits associated with the maximum.
 class MuonHoughMaximum {
  public:
   using HitVec = std::vector<const MuonSpacePoint*>;
-  /** @brief Constructor taking the estimated hough parameters and the associated hits
-   *  @param tanBeta: Slope of the estimated line in precision direction
-   *  @param interceptY: Intercept of the line along the precision direction
-   *  @param assocHits: List of hits associated with these parameters */
+  /// @brief Constructor taking the estimated hough parameters and the associated hits
+  /// @param tanBeta: Slope of the estimated line in precision direction
+  /// @param interceptY: Intercept of the line along the precision direction
+  /// @param assocHits: List of hits associated with these parameters
   MuonHoughMaximum(const double tanBeta, const double interceptY,
                    const HitVec& assocHits)
       : m_tanBeta{tanBeta}, m_interceptY{interceptY}, m_hits{assocHits} {}
-  /** @brief Constructor taking the estimated hough parameters from a complementary hough transform
-   *        & the associated hits.
-   *  @param tanAlpha: Slope of the estimate line in the non-bending direction
-   *  @param interceptX: Intercept of the line along the non-bending direction
-   *  @param tanBeta: Slope of the estimated line in precision direction
-   *  @param interceptY: Intercept of the line along the precision direction
-   *  @param assocHits: List of hits associated with these parameters */
+  /// @brief Constructor taking the estimated hough parameters from a complementary hough transform
+  ///       & the associated hits.
+  /// @param tanAlpha: Slope of the estimate line in the non-bending direction
+  /// @param interceptX: Intercept of the line along the non-bending direction
+  /// @param tanBeta: Slope of the estimated line in precision direction
+  /// @param interceptY: Intercept of the line along the precision direction
+  /// @param assocHits: List of hits associated with these parameters
   MuonHoughMaximum(const double tanAlpha, const double interceptX,
                    const double tanBeta, const double interceptY,
                    const HitVec& assocHits)
@@ -42,15 +43,15 @@ class MuonHoughMaximum {
         m_tanBeta{tanBeta},
         m_interceptY{interceptY},
         m_hits{assocHits} {}
-  /** @brief Return the slope along the non-bending direction */
+  /// @brief Return the slope along the non-bending direction
   double tanAlpha() const { return m_tanAlpha; }
-  /** @brief Return slope along the bending direction */
+  /// @brief Return slope along the bending direction
   double tanBeta() const { return m_tanBeta; }
-  /** @brief Return the intercept in the non-precision plane */
+  /// @brief Return the intercept in the non-precision plane
   double interceptX() const { return m_interceptX; }
-  /** @brief Return the intercept in the precision plane */
+  /// @brief Return the intercept in the precision plane
   double interceptY() const { return m_interceptY; }
-  /** @brief Return the associated hits */
+  /// @brief Return the associated hits
   const HitVec& hits() const { return m_hits; }
 
  private:

Examples/Framework/include/ActsExamples/EventData/MuonSegment.hpp

@@ -19,61 +19,63 @@ namespace ActsExamples {
 class MuonSegment {
  public:
   using MuonId = MuonSpacePoint::MuonId;
-  /** @brief Empty default constructor */
+  /// @brief Empty default constructor
   MuonSegment() = default;
-  /** @brief Standard copy constructor */
+  /// @brief Standard copy constructor
   MuonSegment(const MuonSegment& other) = default;
-  /** @brief Standard move constructor */
+  /// @brief Standard move constructor
   MuonSegment(MuonSegment&& other) = default;
-  /** @brief Standard copy assignment */
+  /// @brief Standard copy assignment
   MuonSegment& operator=(const MuonSegment& other) = default;
 
-  /** @brief Returns the reconstructed segment position in global coordinates */
+  /// @brief Returns the reconstructed segment position in global coordinates
   const Acts::Vector3& globalPosition() const { return m_globPos; }
-  /** @brief Returns the reconstructed segment direction in global coordinates */
+  /// @brief Returns the reconstructed segment direction in global coordinates
   const Acts::Vector3& globalDirection() const { return m_globDir; }
-  /** @brief Returns the reconstructed segment position expressed in the local space point frame*/
+  /// @brief Returns the reconstructed segment position expressed in the local space point frame
   const Acts::Vector3& localPosition() const { return m_localPos; }
-  /** @brief Returns the reconstructed segment direction expressed in the local space point frame*/
+  /// @brief Returns the reconstructed segment direction expressed in the local space point frame
   const Acts::Vector3& localDirection() const { return m_localDir; }
-  /** @brief Returns the associated MS sector identifier */
+  /// @brief Returns the associated MS sector identifier
   const MuonId& id() const { return m_id; }
-  /** @brief returns the fitted segment time & uncertainty */
+  /// @brief returns the fitted segment time & uncertainty
   double time() const { return m_time; }
   double timeUncert() const { return m_timeError; }
-  /** @brief Returns the chiSquared & degreed of freedom */
+  /// @brief Returns the chiSquared & degreed of freedom
   double chiSquared() const { return m_chiSquared; }
   double nDoF() const { return m_nDoF; }
-  /** @brief Returns the number of precision hits building the segment */
+  /// @brief Returns the number of precision hits building the segment
   unsigned nPrecisionHits() const { return m_precisionHits; }
-  /** @brief Returns the number of complementary trigger hits in the bending plane */
+  /// @brief Returns the number of complementary trigger hits in the bending plane
   unsigned nTrigEtaLayers() const { return m_triEtaLayers; }
-  /** @brief Returns the number of complementary trigger hits in the non-bending plane */
+  /// @brief Returns the number of complementary trigger hits in the non-bending plane
   unsigned nTrigPhiLayers() const { return m_phiLayers; }
-  /** @brief Set the global segment position & direction */
+  /// @brief Set the global segment position & direction
   void setGlobalCoords(const Acts::Vector3& pos, const Acts::Vector3& dir) {
     m_globPos = pos;
     m_globDir = dir;
   }
-  /** @brief Set the local segment position & direction */
+  /// @brief Set the local segment position & direction
+  /// @param pos: Position of the segment in the local frame
+  /// @param dir: Direction of the segment in the local frame
   void setLocalCoords(const Acts::Vector3& pos, const Acts::Vector3& dir) {
     m_localPos = pos;
     m_localDir = dir;
   }
-  /** @brief Set the Identifier */
+  /// @brief Set the Identifier
   void setId(const MuonId& id) { m_id = id; }
-  /** @brief Set the time & unceratinty */
+  /// @brief Set the time & unceratinty
   void setTime(const double time, const double timeError) {
     m_time = time;
     m_timeError = timeError;
   }
-  /** @brief Set the chi2 & the number of degrees of freedom */
+  /// @brief Set the chi2 & the number of degrees of freedom
   void setFitQuality(const double chi2, const unsigned nDoF) {
     m_chiSquared = chi2;
     m_nDoF = nDoF;
   }
-  /** @brief Set the segment hit summary in terms of precision hits (Straw/ Mm /sTgc)
-   *         & trigger eta (Rpc /Tgc) & trigger phi (Rpc / Tgc) hits  */
+  /// @brief Set the segment hit summary in terms of precision hits (Straw/ Mm /sTgc)
+  ///        & trigger eta (Rpc /Tgc) & trigger phi (Rpc / Tgc) hits
   void setHitSummary(unsigned nPrec, unsigned nTrigEta, unsigned nTrigPhi) {
     m_precisionHits = nPrec;
     m_triEtaLayers = nTrigEta;
@@ -86,18 +88,18 @@ class MuonSegment {
   Acts::Vector3 m_globDir{Acts::Vector3::Zero()};
   Acts::Vector3 m_localPos{Acts::Vector3::Zero()};
   Acts::Vector3 m_localDir{Acts::Vector3::Zero()};
-  /** @brief Fitted segment time of arrival */
+  /// @brief Fitted segment time of arrival
   double m_time{0.f};
-  /** @brief Uncertainty on the time of arrival */
+  /// @brief Uncertainty on the time of arrival
   double m_timeError{0.f};
-  /** @brief segment chi2 & number of degrees of freedom */
+  /// @brief segment chi2 & number of degrees of freedom
   double m_chiSquared{0.f};
   unsigned m_nDoF{0u};
-  /** @brief how many precision hits are on the segment (Straw tubes or Mm) */
+  /// @brief how many precision hits are on the segment (Straw tubes or Mm)
   unsigned m_precisionHits{0u};
-  /** @brief  Complementary hits in the non-bending direction (Rpc / Tgc / sTgc) */
+  /// @brief  Complementary hits in the non-bending direction (Rpc / Tgc / sTgc)
   unsigned m_phiLayers{0u};
-  /** @brief  Complementary hits in the bending direction (Rpc / Tgc) */
+  /// @brief  Complementary hits in the bending direction (Rpc / Tgc)
   unsigned m_triEtaLayers{0u};
 };
 using MuonSegmentContainer = std::vector<MuonSegment>;