Merge pull request #76 from dav-og/fix/CLI_bugs

CLI fixes - progress bar, parsing wave inputs, adding some irregular data to .h5 files & GUI button bugfix

Author: dav-og

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/gui/guihelper.cpp

@@ -77,7 +77,6 @@ class hydroc::gui::GUIImpl::MyActionReceiver : public irr::IEventReceiver {
   private:
     chrono::irrlicht::ChVisualSystemIrrlicht* vis;
     irr::gui::IGUIButton* pauseButton;
-    irr::gui::IGUIStaticText* buttonText;
 
     bool& pressed;
 };
@@ -131,11 +130,24 @@ void GUIImpl::Init(UI& ui, chrono::ChSystem* system, const char* title) {
     }
 
     try {
-        hydroc::debug::LogDebug("🔍 GUIImpl::Init - Setting up event receiver...");
+        hydroc::debug::LogDebug("🔍 GUIImpl::Init - Setting up GUI skin and event receiver...");
+        // Improve GUI readability: use built-in font for crisper text
+        try {
+            auto* env  = pVis->GetGUIEnvironment();
+            auto* skin = env ? env->getSkin() : nullptr;
+            if (env && skin) {
+                auto* builtin = env->getBuiltInFont();
+                if (builtin) {
+                    skin->setFont(builtin);
+                }
+            }
+        } catch (...) {
+            // non-fatal if font override fails
+        }
         InitReceiver(ui.simulationStarted);
         receiver->Init(pVis.get());
         pVis->AddUserEventReceiver(receiver.get());
-        hydroc::debug::LogDebug("✅ Event receiver set up successfully");
+        hydroc::debug::LogDebug("✅ GUI skin and event receiver set up successfully");
     } catch (const std::exception& e) {
         hydroc::cli::LogError(std::string("🔥 Exception during receiver setup: ") + e.what());
         // Don't re-throw here, receiver is optional
@@ -288,8 +300,18 @@ void hydroc::gui::GUIImpl::MyActionReceiver::Init(chrono::irrlicht::ChVisualSyst
     vis = vsys;
 
     // ..add a GUI button to control pause/play
-    pauseButton = vis->GetGUIEnvironment()->addButton(rect<s32>(510, 20, 650, 35));
-    buttonText  = vis->GetGUIEnvironment()->addStaticText(L"Paused", rect<s32>(560, 20, 600, 35), false);
+    pauseButton = vis->GetGUIEnvironment()->addButton(rect<s32>(500, 18, 700, 50));
+    pauseButton->setIsPushButton(true);
+    pauseButton->setScaleImage(true);
+    // Increase text visibility by adjusting the skin font was done in Init; ensure border size is sane
+    if (auto* skin = vis->GetGUIEnvironment()->getSkin()) {
+        skin->setSize(irr::gui::EGDS_BUTTON_PRESSED_IMAGE_OFFSET_X, 2);
+        skin->setSize(irr::gui::EGDS_BUTTON_PRESSED_IMAGE_OFFSET_Y, 2);
+        // Optional: increase button text distance to border for clarity
+        skin->setSize(irr::gui::EGDS_TEXT_DISTANCE_X, 6);
+        skin->setSize(irr::gui::EGDS_TEXT_DISTANCE_Y, 3);
+    }
+    pauseButton->setText(L"Paused");
 }
 
 bool hydroc::gui::GUIImpl::MyActionReceiver::OnEvent(const irr::SEvent& event) {
@@ -299,9 +321,9 @@ bool hydroc::gui::GUIImpl::MyActionReceiver::OnEvent(const irr::SEvent& event) {
             case EGUI_EVENT_TYPE::EGET_BUTTON_CLICKED:
                 pressed = !pressed;
                 if (pressed) {
-                    buttonText->setText(L"Playing");
+                    pauseButton->setText(L"Playing");
                 } else {
-                    buttonText->setText(L"Paused");
+                    pauseButton->setText(L"Paused");
                 }
                 return pressed;
                 break;

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

@@ -5,6 +5,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>
@@ -23,6 +24,7 @@
 #include <sstream>
 #include <chrono>
 #include <iomanip>
+#include <cmath>
 
 #ifdef _WIN32
 #include <windows.h>
@@ -449,8 +451,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
@@ -656,9 +660,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();
@@ -697,6 +715,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 {
@@ -709,18 +735,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);