add HydroSystem profiling and per-component timing

- Introduce HydroComponentType and Type() in hydro force components.
- Add HydroSystemProfileStats and per-component timing in HydroSystem::Evaluate.
- Expose profiling enable/disable and stats via ChronoHydroCoupler and TestHydro.
- Default to profiling disabled; only enabled in profile runs.

Author: dav-og

include/hydroc/hydro_forces.h

@@ -359,6 +359,16 @@ class TestHydro {
     // Hydrodynamics profiling accessors
     HydroProfileStats GetProfileStats() const { return profile_stats_; }
 
+    /**
+     * @brief Enable or disable profiling in HydroSystem.
+     * 
+     * When enabled, HydroSystem measures timing for each force component.
+     * Disabled by default to avoid overhead in normal runs.
+     * 
+     * @param enabled True to enable profiling, false to disable
+     */
+    void SetProfilingEnabled(bool enabled);
+
     // Compare mode: legacy debugging feature, retained for API compatibility.
     // No longer affects behavior since the main path now uses HydroSystem exclusively.
     void SetCompareMode(bool enable) { compare_mode_ = enable; }
@@ -426,6 +436,9 @@ class TestHydro {
     // Legacy compare mode flag: retained for API compatibility; no longer used.
     bool compare_mode_ = false;
 
+    // Profiling enable flag: stored here because chrono_coupler_ is created lazily.
+    bool profiling_enabled_ = false;
+
     // Convolution kernel preprocessing (optional)
     RadiationConvolutionMode convolution_mode_ = RadiationConvolutionMode::Baseline;
     bool rirf_processed_ready_ = false;

src/hydro/chrono/chrono_hydro_coupler.cpp

@@ -18,7 +18,7 @@ ChronoHydroCoupler::ChronoHydroCoupler(
     assert(!bodies_.empty());
 }
 
-BodyForces ChronoHydroCoupler::Evaluate(double time) const {
+BodyForces ChronoHydroCoupler::Evaluate(double time) {
     // Build SystemState from Chrono bodies
     SystemState system_state;
     BuildSystemStateFromChronoBodies(bodies_, system_state);

src/hydro/chrono/chrono_hydro_coupler.h

@@ -42,7 +42,7 @@ class ChronoHydroCoupler {
      * @param time Current simulation time
      * @return BodyForces Total forces (one GeneralizedForce per body, 6 DOF each)
      */
-    BodyForces Evaluate(double time) const;
+    BodyForces Evaluate(double time);
 
     /**
      * @brief Apply forces to Chrono bodies.
@@ -53,6 +53,26 @@ class ChronoHydroCoupler {
      */
     void ApplyForcesToChrono(const BodyForces& forces);
 
+    /**
+     * @brief Get profiling statistics from HydroSystem.
+     * 
+     * Returns cumulative timing and call counts for each component type.
+     * 
+     * @return HydroSystemProfileStats Profiling statistics
+     */
+    HydroSystemProfileStats GetProfileStats() const { 
+        return hydro_system_->GetProfileStats(); 
+    }
+
+    /**
+     * @brief Enable or disable profiling in HydroSystem.
+     * 
+     * @param enabled True to enable profiling, false to disable
+     */
+    void SetProfilingEnabled(bool enabled) {
+        hydro_system_->SetProfilingEnabled(enabled);
+    }
+
 private:
     std::shared_ptr<HydroSystem> hydro_system_;
     std::vector<std::shared_ptr<chrono::ChBody>> bodies_;

src/hydro/core/hydro_force_component.h

@@ -10,6 +10,17 @@
 
 namespace hydrochrono::hydro {
 
+/**
+ * @brief Identifies the type of a hydrodynamic force component.
+ * 
+ * Used for profiling to categorize execution time by component type.
+ */
+enum class HydroComponentType {
+    Hydrostatics,   ///< Hydrostatic restoring forces and buoyancy
+    Radiation,      ///< Radiation damping (RIRF convolution)
+    Excitation      ///< Wave excitation forces
+};
+
 /**
  * @brief Interface for computing hydrodynamic forces.
  * 
@@ -24,6 +35,15 @@ class IHydroForceComponent {
 public:
     virtual ~IHydroForceComponent() = default;
 
+    /**
+     * @brief Get the type of this component.
+     * 
+     * Used for profiling to categorize execution time by component type.
+     * 
+     * @return Component type (Hydrostatics, Radiation, or Excitation)
+     */
+    virtual HydroComponentType Type() const = 0;
+
     /**
      * @brief Compute force contribution and add to inout_forces.
      * 

src/hydro/core/hydro_system.cpp

@@ -6,18 +6,21 @@
 #include "hydro_system.h"
 
 #include <cassert>
+#include <chrono>
 #include <Eigen/Dense>
 
 namespace hydrochrono::hydro {
 
 HydroSystem::HydroSystem(int num_bodies,
                          std::vector<std::unique_ptr<IHydroForceComponent>> components)
     : num_bodies_(num_bodies),
-      components_(std::move(components)) {
+      components_(std::move(components)),
+      profile_stats_(),
+      profiling_enabled_(false) {
     assert(num_bodies_ > 0);
 }
 
-BodyForces HydroSystem::Evaluate(const SystemState& state, double time) const {
+BodyForces HydroSystem::Evaluate(const SystemState& state, double time) {
     // Initialize forces: one 6-DOF zero vector per body
     BodyForces forces(num_bodies_);
     for (int b = 0; b < num_bodies_; ++b) {
@@ -27,7 +30,31 @@ BodyForces HydroSystem::Evaluate(const SystemState& state, double time) const {
 
     // Accumulate force contributions from all components
     for (const auto& component : components_) {
-        component->Compute(state, time, forces);
+        if (profiling_enabled_) {
+            // Profiling path: measure timing for each component
+            auto t0 = std::chrono::steady_clock::now();
+            component->Compute(state, time, forces);
+            auto t1 = std::chrono::steady_clock::now();
+            double elapsed = std::chrono::duration<double>(t1 - t0).count();
+            
+            switch (component->Type()) {
+                case HydroComponentType::Hydrostatics:
+                    profile_stats_.hydrostatics_seconds += elapsed;
+                    profile_stats_.hydrostatics_calls++;
+                    break;
+                case HydroComponentType::Radiation:
+                    profile_stats_.radiation_seconds += elapsed;
+                    profile_stats_.radiation_calls++;
+                    break;
+                case HydroComponentType::Excitation:
+                    profile_stats_.excitation_seconds += elapsed;
+                    profile_stats_.excitation_calls++;
+                    break;
+            }
+        } else {
+            // Fast path: no timing overhead
+            component->Compute(state, time, forces);
+        }
     }
 
     return forces;

src/hydro/core/hydro_system.h

@@ -13,6 +13,26 @@
 
 namespace hydrochrono::hydro {
 
+/**
+ * @brief Profiling statistics for HydroSystem components.
+ * 
+ * Tracks cumulative execution time and call counts for each component type.
+ */
+struct HydroSystemProfileStats {
+    double hydrostatics_seconds = 0.0;
+    double radiation_seconds    = 0.0;
+    double excitation_seconds   = 0.0;
+    int hydrostatics_calls      = 0;
+    int radiation_calls         = 0;
+    int excitation_calls        = 0;
+    
+    /// Reset all counters to zero
+    void Reset() {
+        hydrostatics_seconds = radiation_seconds = excitation_seconds = 0.0;
+        hydrostatics_calls = radiation_calls = excitation_calls = 0;
+    }
+};
+
 /**
  * @brief HydroSystem: orchestrates force components to compute total forces.
  * 
@@ -36,12 +56,13 @@ class HydroSystem {
      * 
      * Computes force contributions from all components for the given
      * system state and time, accumulating them into a single result.
+     * Also updates profiling statistics for each component type.
      * 
      * @param state Current system state (positions, velocities for all bodies)
      * @param time Current simulation time
      * @return BodyForces Total forces (one GeneralizedForce per body, 6 DOF each)
      */
-    BodyForces Evaluate(const SystemState& state, double time) const;
+    BodyForces Evaluate(const SystemState& state, double time);
 
     /**
      * @brief Get number of bodies in the system.
@@ -50,9 +71,43 @@ class HydroSystem {
      */
     int num_bodies() const { return num_bodies_; }
 
+    /**
+     * @brief Get profiling statistics.
+     * 
+     * Returns cumulative timing and call counts for each component type.
+     * 
+     * @return HydroSystemProfileStats Profiling statistics
+     */
+    HydroSystemProfileStats GetProfileStats() const { return profile_stats_; }
+
+    /**
+     * @brief Reset profiling statistics.
+     * 
+     * Clears all timing and call counts.
+     */
+    void ResetProfileStats() { profile_stats_.Reset(); }
+
+    /**
+     * @brief Enable or disable profiling.
+     * 
+     * When disabled (default), Evaluate() skips timing measurements.
+     * 
+     * @param enabled True to enable profiling, false to disable
+     */
+    void SetProfilingEnabled(bool enabled) { profiling_enabled_ = enabled; }
+
+    /**
+     * @brief Check if profiling is enabled.
+     * 
+     * @return True if profiling is enabled
+     */
+    bool ProfilingEnabled() const { return profiling_enabled_; }
+
 private:
     int num_bodies_;
     std::vector<std::unique_ptr<IHydroForceComponent>> components_;
+    mutable HydroSystemProfileStats profile_stats_;
+    bool profiling_enabled_ = false;  ///< Profiling disabled by default
 };
 
 }  // namespace hydrochrono::hydro

src/hydro/force_components/excitation_component.h

@@ -29,6 +29,12 @@ class ExcitationComponent : public IHydroForceComponent {
      */
     ExcitationComponent(std::shared_ptr<WaveBase> waves, int num_bodies);
 
+    /**
+     * @brief Get the component type.
+     * @return HydroComponentType::Excitation
+     */
+    HydroComponentType Type() const override { return HydroComponentType::Excitation; }
+
     /**
      * @brief Compute wave excitation force contribution.
      * 

src/hydro/force_components/hydrostatics_component.h

@@ -39,6 +39,12 @@ class HydrostaticsComponent : public IHydroForceComponent {
                      const std::vector<double>& cb_minus_cg,
                      const Eigen::Vector3d& gravitational_acceleration);
 
+    /**
+     * @brief Get the component type.
+     * @return HydroComponentType::Hydrostatics
+     */
+    HydroComponentType Type() const override { return HydroComponentType::Hydrostatics; }
+
     /**
      * @brief Compute hydrostatic force contribution.
      * 

src/hydro/force_components/radiation_component.h

@@ -55,6 +55,12 @@ class RadiationComponent : public IHydroForceComponent {
                   const TaperedDirectOptions& tapered_opts,
                   const std::string& diagnostics_output_dir);
 
+    /**
+     * @brief Get the component type.
+     * @return HydroComponentType::Radiation
+     */
+    HydroComponentType Type() const override { return HydroComponentType::Radiation; }
+
     /**
      * @brief Compute radiation damping force contribution.
      * 

src/hydro_forces.cpp

@@ -552,6 +552,11 @@ void TestHydro::EnsureHydroSystemAndCoupler() {
     // Construct ChronoHydroCoupler
     chrono_coupler_ = std::make_unique<hydrochrono::hydro::ChronoHydroCoupler>(
         hydro_system_shared, bodies_);
+
+    // Apply deferred profiling setting (may have been set before coupler was created)
+    if (profiling_enabled_) {
+        chrono_coupler_->SetProfilingEnabled(true);
+    }
 }
 
 
@@ -721,6 +726,15 @@ double TestHydro::CoordinateFuncForBody(int b, int dof_index) {
     // Result: total = hydrostatics - radiation + waves
     hydrochrono::hydro::BodyForces body_forces = chrono_coupler_->Evaluate(prev_time);
 
+    // Copy profiling stats from HydroSystem to TestHydro's profile_stats_
+    auto hydro_stats = chrono_coupler_->GetProfileStats();
+    profile_stats_.hydrostatics_seconds = hydro_stats.hydrostatics_seconds;
+    profile_stats_.hydrostatics_calls   = hydro_stats.hydrostatics_calls;
+    profile_stats_.radiation_seconds    = hydro_stats.radiation_seconds;
+    profile_stats_.radiation_calls      = hydro_stats.radiation_calls;
+    profile_stats_.waves_seconds        = hydro_stats.excitation_seconds;  // excitation == waves
+    profile_stats_.waves_calls          = hydro_stats.excitation_calls;
+
     // Flatten BodyForces into total_force_ (legacy flat 6N format)
     std::fill(total_force_.begin(), total_force_.end(), 0.0);
     for (int body_idx = 0; body_idx < num_bodies_; ++body_idx) {
@@ -740,4 +754,11 @@ double TestHydro::CoordinateFuncForBody(int b, int dof_index) {
     }
 
     return total_force_[body_num_offset + dof_index];
+}
+
+void TestHydro::SetProfilingEnabled(bool enabled) {
+    profiling_enabled_ = enabled;
+    if (chrono_coupler_) {
+        chrono_coupler_->SetProfilingEnabled(enabled);
+    }
 }