Merge branch 'main' into feature/chrono-fsi-interface

Author: rserban

CMakeLists.txt

@@ -20,7 +20,7 @@ endif()
 # ===============================================================================
 
 project(HydroChrono 
-    VERSION 0.3.1
+    VERSION 0.3.2
     DESCRIPTION "Hydrodynamics for Project Chrono."
     LANGUAGES CXX
 )

include/hydroc/hydro_forces.h

@@ -218,6 +218,8 @@ class TestHydro {
      * @return 6N dimensional force for 6 DOF and N bodies in system (already Eigen type).
      */
     Eigen::VectorXd ComputeForceWaves();
+    // Expose the wave object (read-only) so callers can query inputs if needed
+    std::shared_ptr<WaveBase> GetWave() const { return user_waves_; }
 
     /**
      * @brief Fetches the RIRF value from the h5 file based on the provided indices.

include/hydroc/simulation_exporter.h

@@ -133,6 +133,16 @@ class SimulationExporter {
      */
     void Finalize();
 
+    /**
+     * @brief Write irregular wave input arrays under /inputs/simulation/waves/irregular.
+     *
+     * All arrays are 1D and written with attributes documenting units.
+     */
+    void WriteIrregularInputs(const std::vector<double>& frequencies_hz,
+                              const std::vector<double>& spectral_densities,
+                              const std::vector<double>& free_surface_time,
+                              const std::vector<double>& free_surface_eta);
+
 
 
     // Runtime metadata (written into /meta/run at Finalize)

include/hydroc/wave_types.h

@@ -297,9 +297,14 @@ class IrregularWaves : public WaveBase {
     void Initialize() override {}
 
     void CreateSpectrum();
+    // Returns spectral density values S(f) (one per frequency bin)
     std::vector<double> GetSpectrum();
+    // Returns precomputed free-surface elevation eta(t) samples
     std::vector<double> GetFreeSurfaceElevation();
-    std::vector<double> GetEtaTimeData();
+    // Returns time samples corresponding to eta(t)
+    std::vector<double> GetFreeSurfaceTime() const;
+    // Returns the frequency bins (Hz)
+    std::vector<double> GetFrequenciesHz() const;
 
     Eigen::VectorXd GetForceAtTime(double t) override;
 

src/hydro_forces.cpp

@@ -236,6 +236,9 @@ TestHydro::TestHydro(std::vector<std::shared_ptr<ChBody>> user_bodies,
     // Set up hydro inputs
     user_waves_ = waves;
     AddWaves(user_waves_);
+
+    // If irregular waves are active, publish spectrum and free-surface inputs into HDF5 if an exporter is present.
+    // The exporter is managed by the runner; here we only expose getters via the waves object.
 }
 
 void TestHydro::AddWaves(std::shared_ptr<WaveBase> waves) {

src/hydro_yaml_parser.cpp

@@ -178,6 +178,11 @@ YAMLHydroData ReadHydroYAML(const std::string& hydro_file_path) {
     bool period_form_linspace = false;
     bool period_form_range = false;
 
+    // Wave convenience fields
+    bool waves_amplitude_set = false;
+    double waves_amplitude = 0.0;
+    bool period_set_by_synonym = false; // scalar period given via t/p/tp
+
     auto parse_inline_brace_kv = [](const std::string& v) -> std::vector<std::pair<std::string, std::string>> {
         // Expect something like: { start: 6.0, stop: 9.0, num: 4 }
         std::vector<std::pair<std::string, std::string>> out;
@@ -390,11 +395,18 @@ YAMLHydroData ReadHydroYAML(const std::string& hydro_file_path) {
                     }
                 } else if (in_waves) {
                     // Parse wave properties
-                    if (!in_period_block && key == "type") {
+                    // normalize key for shorthand handling
+                    std::string key_lower = key;
+                    std::transform(key_lower.begin(), key_lower.end(), key_lower.begin(), ::tolower);
+
+                    if (!in_period_block && key_lower == "type") {
                         data.waves.type = value;
-                    } else if (!in_period_block && key == "height") {
+                    } else if (!in_period_block && (key_lower == "height" || key_lower == "h")) {
                         data.waves.height = ParseDouble(value, 0.0);
-                    } else if (!in_period_block && key == "period") {
+                    } else if (!in_period_block && (key_lower == "amplitude" || key_lower == "a")) {
+                        waves_amplitude = ParseDouble(value, 0.0);
+                        waves_amplitude_set = true;
+                    } else if (!in_period_block && (key_lower == "period" || key_lower == "t" || key_lower == "tp" || key_lower == "p")) {
                         period_block_seen = true;
                         period_form_values = period_form_linspace = period_form_range = false;
                         data.waves.period_values.clear();
@@ -403,6 +415,7 @@ YAMLHydroData ReadHydroYAML(const std::string& hydro_file_path) {
                         if (!looks_structured) {
                             data.waves.period = ParseDouble(value, 0.0);
                             data.waves.period_values.push_back(data.waves.period);
+                            period_set_by_synonym = (key_lower != "period");
                         } else {
                             // Inline forms on same line
                             // values inline list inside braces
@@ -509,13 +522,13 @@ YAMLHydroData ReadHydroYAML(const std::string& hydro_file_path) {
                             throw std::runtime_error("waves.period: range produced no values");
                         }
                         data.waves.period = data.waves.period_values.front();
-                    } else if (!in_period_block && key == "direction") {
+                    } else if (!in_period_block && key_lower == "direction") {
                         data.waves.direction = ParseDouble(value, 0.0);
-                    } else if (!in_period_block && key == "phase") {
+                    } else if (!in_period_block && key_lower == "phase") {
                         data.waves.phase = ParseDouble(value, 0.0);
-                    } else if (!in_period_block && key == "spectrum") {
+                    } else if (!in_period_block && key_lower == "spectrum") {
                         data.waves.spectrum = value;
-                    } else if (!in_period_block && key == "seed") {
+                    } else if (!in_period_block && key_lower == "seed") {
                         try { data.waves.seed = std::stoi(value); } catch (...) { data.waves.seed = -1; }
                     }
                 }
@@ -556,6 +569,34 @@ YAMLHydroData ReadHydroYAML(const std::string& hydro_file_path) {
         }
     }
 
+    // Apply amplitude to height if provided
+    if (waves_amplitude_set) {
+        const double derived_height = 2.0 * waves_amplitude;
+        if (data.waves.height > 0.0) {
+            const double eps = 1e-9;
+            if (std::abs(data.waves.height - derived_height) > eps) {
+                throw std::runtime_error("waves: both height and amplitude provided but inconsistent (expected height = 2*amplitude)");
+            }
+        } else {
+            data.waves.height = derived_height;
+        }
+    }
+
+    // Validation and helpful errors for regular waves
+    {
+        std::string type_lower = data.waves.type;
+        std::transform(type_lower.begin(), type_lower.end(), type_lower.begin(), ::tolower);
+        if (type_lower == "regular") {
+            if (data.waves.height <= 0.0) {
+                throw std::runtime_error("waves: regular requires wave height (use 'height' or 'h', or 'amplitude'/'a')");
+            }
+            bool has_period = (data.waves.period > 0.0) || !data.waves.period_values.empty();
+            if (!has_period) {
+                throw std::runtime_error("waves: regular requires wave period (use 'period' or shorthand 't', 'tp', or 'p')");
+            }
+        }
+    }
+
     // Validate that we found the required sections
     if (!in_hydrodynamics) {
         throw std::runtime_error("No 'hydrodynamics:' section found in hydro file: " + hydro_file_path);

src/hydrochrono_runner/run_hydrochrono_from_yaml.cpp

@@ -6,6 +6,7 @@
 #include "../hydro_yaml_parser.h"
 #include <hydroc/hydro_forces.h>
 #include <hydroc/simulation_exporter.h>
+#include <hydroc/wave_types.h>
 
 #include <chrono_parsers/yaml/ChParserMbsYAML.h>
 #include <chrono/physics/ChSystem.h>
@@ -24,6 +25,7 @@
 #include <sstream>
 #include <chrono>
 #include <iomanip>
+#include <cmath>
 
 #ifdef _WIN32
 #include <windows.h>
@@ -443,8 +445,10 @@ int RunHydroChronoFromYAML(int argc, char* argv[]) {
 
                     // Setup hydrodynamic forces
                     hydroc::debug::LogDebug("Initializing TestHydro...");
-                    // Provide a neutral horizon (Chrono governs runtime via YAML/UI)
-                    test_hydro = SetupHydroFromYAML(hydro_data, bodies, loop_dt, /*time_end_hint*/ 0.0, 0.0);
+                    // Provide simulation horizon from YAML end_time (important for irregular waves spectrum)
+                    double sim_duration_hint = 0.0;
+                    TryFindYamlDouble(sim_file, "end_time", sim_duration_hint);
+                    test_hydro = SetupHydroFromYAML(hydro_data, bodies, loop_dt, sim_duration_hint, 0.0);
                     hydroc::debug::LogDebug("Hydrodynamic forces initialized successfully");
 
                     // Inform location for diagnostics CSVs: write to hydro file directory
@@ -650,9 +654,23 @@ int RunHydroChronoFromYAML(int argc, char* argv[]) {
                 exporter = std::make_unique<hydroc::SimulationExporter>(exp_opts);
 
                 // Write static info and model before stepping
-                exporter->WriteSimulationInfo(system.get(), std::string(""), std::filesystem::path(model_file).filename().generic_string(), loop_dt, /*duration_seconds*/ 0.0);
+                double duration_hint = 0.0; TryFindYamlDouble(sim_file, "end_time", duration_hint);
+                exporter->WriteSimulationInfo(system.get(), std::string(""), std::filesystem::path(model_file).filename().generic_string(), loop_dt, duration_hint);
                 exporter->WriteModel(system.get());
                 exporter->BeginResults(system.get(), /*expected_steps*/ 0);
+
+                // If irregular waves are configured, persist spectrum and eta(t) inputs to HDF5
+                if (test_hydro) {
+                    auto wave_ptr = test_hydro->GetWave();
+                    if (wave_ptr && wave_ptr->GetWaveMode() == WaveMode::irregular) {
+                        auto irreg = std::static_pointer_cast<IrregularWaves>(wave_ptr);
+                        std::vector<double> f = irreg->GetFrequenciesHz();
+                        std::vector<double> S = irreg->GetSpectrum();
+                        std::vector<double> tvec = irreg->GetFreeSurfaceTime();
+                        std::vector<double> eta = irreg->GetFreeSurfaceElevation();
+                        exporter->WriteIrregularInputs(f, S, tvec, eta);
+                    }
+                }
             } catch (const std::exception& e) {
                 hydroc::cli::LogWarning(std::string("HDF5 exporter disabled: ") + e.what());
                 exporter.reset();
@@ -691,6 +709,14 @@ int RunHydroChronoFromYAML(int argc, char* argv[]) {
 
         if (nogui) {
             const double end_time_bound = (yaml_end_time > 0.0) ? yaml_end_time : 40.0;
+            // Estimate total steps for progress bar; ensure at least 1
+            const double remaining_time = std::max(0.0, end_time_bound - initial_time);
+            const size_t total_steps_est = static_cast<size_t>(std::max(1.0, std::ceil(remaining_time / std::max(1e-12, loop_dt))));
+            size_t last_progress_step = 0;
+
+            // Initial progress line
+            hydroc::cli::ShowProgress(0, total_steps_est, std::string("t=") + hydroc::FormatNumber(initial_time, 2) + " / " + hydroc::FormatNumber(end_time_bound, 2) + " s");
+
             while (system->GetChTime() < end_time_bound) {
                 double current_time = system->GetChTime();
                 try {
@@ -703,18 +729,33 @@ int RunHydroChronoFromYAML(int argc, char* argv[]) {
                         exporter->RecordStep(system.get());
                         if (profile_mode) { prof_export_seconds += std::chrono::duration_cast<std::chrono::duration<double>>(std::chrono::steady_clock::now() - t).count(); }
                     }
+                    // Update progress periodically to reduce console churn
+                    if (step_count == 1 || step_count - static_cast<int>(last_progress_step) >= 25) {
+                        const size_t current_steps = static_cast<size_t>(std::min<double>(total_steps_est, std::ceil((system->GetChTime() - initial_time) / std::max(1e-12, loop_dt))));
+                        std::string msg = std::string("t=") + hydroc::FormatNumber(system->GetChTime(), 2) + " / " + hydroc::FormatNumber(end_time_bound, 2) + " s";
+                        hydroc::cli::ShowProgress(current_steps, total_steps_est, msg);
+                        last_progress_step = static_cast<size_t>(step_count);
+                    }
                     previous_time = current_time;
                 } catch (const std::exception& e) {
+                    hydroc::cli::StopProgress();
                     hydroc::cli::LogError(std::string("🔥 Exception during DoStepDynamics at step ") + std::to_string(step_count) + ": " + e.what());
                     hydroc::cli::LogError(std::string("Simulation time: ") + hydroc::FormatNumber(current_time, 6) + " s");
                     hydroc::cli::LogError(std::string("Step size: ") + hydroc::FormatNumber(loop_dt, 6) + " s");
                     break;
                 } catch (...) {
+                    hydroc::cli::StopProgress();
                     hydroc::cli::LogError(std::string("🔥 Unknown exception during DoStepDynamics at step ") + std::to_string(step_count));
                     hydroc::cli::LogError(std::string("Simulation time: ") + hydroc::FormatNumber(current_time, 6) + " s");
                     break;
                 }
             }
+            // Finalize progress line
+            if (system->GetChTime() >= end_time_bound - 1e-9) {
+                hydroc::cli::ShowProgress(total_steps_est, total_steps_est, "Completed");
+            } else {
+                hydroc::cli::StopProgress();
+            }
         } else {
             // GUI-driven loop: respects pause via ui.simulationStarted and closes when window stops
             while (ui.IsRunning(loop_dt)) {

src/setup_hydro_from_yaml.cpp

@@ -56,7 +56,8 @@ std::shared_ptr<WaveBase> CreateWaveFromSettings(const WaveSettings& wave_settin
         params.ramp_duration_ = ramp_duration;
         params.wave_height_ = wave_settings.height;
         params.wave_period_ = wave_settings.period;
-        params.seed_ = 1;  // Default seed, could be made configurable
+        // Use YAML-provided seed if available; fall back to a default deterministic seed
+        params.seed_ = (wave_settings.seed > 0 ? wave_settings.seed : 1);
 
         auto irregular_wave = std::make_shared<IrregularWaves>(params);
 

src/simulation_exporter.cpp

@@ -5,6 +5,7 @@
 
 #include <hydroc/simulation_exporter.h>
 #include <hydroc/h5_writer.h>
+#include <hydroc/wave_types.h>
 #include <hydroc/version.h>
 #include <hydroc/logging.h>
 
@@ -81,6 +82,8 @@ struct SimulationExporter::Impl {
     H5Writer::Group g_results_model_tsdas;
     H5Writer::Group g_results_model_rsdas;
     H5Writer::Group g_results_model_joints;
+    // irregular waves datasets (inputs)
+    H5Writer::Group g_inputs_waves_irregular;
     // meta subtree
     H5Writer::Group g_meta;
 
@@ -184,6 +187,7 @@ struct SimulationExporter::Impl {
         g_inputs_sim_time = writer.RequireGroup("/inputs/simulation/time");
         g_inputs_sim_env = writer.RequireGroup("/inputs/simulation/environment");
         g_inputs_sim_waves = writer.RequireGroup("/inputs/simulation/waves");
+        g_inputs_waves_irregular = writer.RequireGroup("/inputs/simulation/waves/irregular");
         // results
         g_results = writer.RequireGroup("/results");
         g_results_model = writer.RequireGroup("/results/model");
@@ -347,6 +351,7 @@ void SimulationExporter::WriteSimulationInfo(chrono::ChSystem* system,
         g_waves.WriteAttribute("Hs", impl_->options.scenario_Hs);
         g_waves.WriteAttribute("Tp", impl_->options.scenario_Tp);
         if (impl_->options.scenario_seed >= 0) g_waves.WriteAttribute("seed", static_cast<double>(impl_->options.scenario_seed));
+        // Group already reserved in ctor; datasets will be written later if available
     }
 }
 
@@ -357,6 +362,36 @@ void SimulationExporter::WriteInitialConditions(chrono::ChSystem* ,
                                                 double ) {
     // Deprecated in schema v0.3: handled in WriteSimulationInfo under inputs/simulation/*
 }
+void SimulationExporter::WriteIrregularInputs(const std::vector<double>& frequencies_hz,
+                                             const std::vector<double>& spectral_densities,
+                                             const std::vector<double>& free_surface_time,
+                                             const std::vector<double>& free_surface_eta) {
+    auto g = impl_->g_inputs_waves_irregular;
+    // Write datasets if provided (skip empty vectors)
+    if (!frequencies_hz.empty()) {
+        std::array<hsize_t,1> d1 = {static_cast<hsize_t>(frequencies_hz.size())};
+        g.WriteDataset("frequencies_hz", frequencies_hz, d1);
+        g.WriteAttribute("frequencies_hz.units", std::string("Hz"));
+    }
+    if (!spectral_densities.empty()) {
+        std::array<hsize_t,1> d1 = {static_cast<hsize_t>(spectral_densities.size())};
+        g.WriteDataset("spectral_densities", spectral_densities, d1);
+        g.WriteAttribute("spectral_densities.units", std::string("m^2/Hz"));
+        g.WriteAttribute("spectral_densities.convention", std::string("JONSWAP (if gamma>1), else PM"));
+    }
+    if (!free_surface_time.empty()) {
+        std::array<hsize_t,1> d1 = {static_cast<hsize_t>(free_surface_time.size())};
+        g.WriteDataset("free_surface_time", free_surface_time, d1);
+        g.WriteAttribute("free_surface_time.units", std::string("s"));
+    }
+    if (!free_surface_eta.empty()) {
+        std::array<hsize_t,1> d1 = {static_cast<hsize_t>(free_surface_eta.size())};
+        g.WriteDataset("free_surface_eta", free_surface_eta, d1);
+        g.WriteAttribute("free_surface_eta.units", std::string("m"));
+        g.WriteAttribute("free_surface_eta.location", std::string("x=0,y=0,z=0 (assumed)"));
+    }
+}
+
 
 void SimulationExporter::WriteModel(chrono::ChSystem* system) {
     if (system == nullptr) {