From 669a75da8d89b6452ba99b7444071f18508faa61 Mon Sep 17 00:00:00 2001 From: dcdemen Date: Mon, 10 Feb 2025 13:18:01 -0700 Subject: [PATCH 1/5] Added InterfaceBuilder to improve ergonomics of creating our CFD interface. --- src/interfaces/cfd/CMakeLists.txt | 1 + src/interfaces/cfd/interface_builder.hpp | 130 ++++++++++++ .../floating_platform/floating_platform.cpp | 78 ++----- .../interfaces/test_cfd_interface.cpp | 198 ++++++------------ 4 files changed, 214 insertions(+), 193 deletions(-) create mode 100644 src/interfaces/cfd/interface_builder.hpp diff --git a/src/interfaces/cfd/CMakeLists.txt b/src/interfaces/cfd/CMakeLists.txt index 20314cc4e..7dd061d2a 100644 --- a/src/interfaces/cfd/CMakeLists.txt +++ b/src/interfaces/cfd/CMakeLists.txt @@ -7,6 +7,7 @@ install(FILES floating_platform.hpp floating_platform_input.hpp interface.hpp + interface_builder.hpp interface_input.hpp mooring_line.hpp mooring_line_input.hpp diff --git a/src/interfaces/cfd/interface_builder.hpp b/src/interfaces/cfd/interface_builder.hpp new file mode 100644 index 000000000..e2e68ab74 --- /dev/null +++ b/src/interfaces/cfd/interface_builder.hpp @@ -0,0 +1,130 @@ +#pragma once + +#include "floating_platform_input.hpp" +#include "interface.hpp" +#include "interface_input.hpp" +#include "mooring_line_input.hpp" + +namespace openturbine::cfd { + +struct InterfaceBuilder { + InterfaceBuilder& SetGravity(const std::array& gravity) { + interface_in.gravity = gravity; + return *this; + } + + InterfaceBuilder& SetMaximumNonlinearIterations(size_t max_iter) { + interface_in.max_iter = max_iter; + return *this; + } + + InterfaceBuilder& SetTimeStep(double time_step) { + interface_in.time_step = time_step; + return *this; + } + + InterfaceBuilder& SetDampingFactor(double rho_inf) { + interface_in.rho_inf = rho_inf; + return *this; + } + + InterfaceBuilder& EnableFloatingPlatform(bool enable) { + interface_in.turbine.floating_platform.enable = enable; + return *this; + } + + InterfaceBuilder& SetFloatingPlatformPosition(const std::array& position) { + interface_in.turbine.floating_platform.position = position; + return *this; + } + + InterfaceBuilder& SetFloatingPlatformVelocity(const std::array& velocity) { + interface_in.turbine.floating_platform.velocity = velocity; + return *this; + } + + InterfaceBuilder& SetFloatingPlatformAcceleration(const std::array& acceleration) { + interface_in.turbine.floating_platform.acceleration = acceleration; + return *this; + } + + InterfaceBuilder& SetFloatingPlatformMassMatrix( + const std::array, 6>& mass_matrix + ) { + interface_in.turbine.floating_platform.mass_matrix = mass_matrix; + return *this; + } + + InterfaceBuilder& SetNumberOfMooringLines(size_t number_of_mooring_lines) { + interface_in.turbine.floating_platform.mooring_lines.resize(number_of_mooring_lines); + return *this; + } + + InterfaceBuilder& SetMooringLineStiffness(size_t line_number, double stiffness) { + interface_in.turbine.floating_platform.mooring_lines[line_number].stiffness = stiffness; + return *this; + } + + InterfaceBuilder& SetMooringLineUndeformedLength(size_t line_number, double length) { + interface_in.turbine.floating_platform.mooring_lines[line_number].undeformed_length = length; + return *this; + } + + InterfaceBuilder& SetMooringLineFairleadPosition( + size_t line_number, const std::array& position + ) { + interface_in.turbine.floating_platform.mooring_lines[line_number].fairlead_position = + position; + return *this; + } + + InterfaceBuilder& SetMooringLineFairleadVelocity( + size_t line_number, const std::array& velocity + ) { + interface_in.turbine.floating_platform.mooring_lines[line_number].fairlead_velocity = + velocity; + return *this; + } + + InterfaceBuilder& SetMooringLineFairleadAcceleration( + size_t line_number, const std::array& acceleration + ) { + interface_in.turbine.floating_platform.mooring_lines[line_number].fairlead_acceleration = + acceleration; + return *this; + } + + InterfaceBuilder& SetMooringLineAnchorPosition( + size_t line_number, const std::array& position + ) { + interface_in.turbine.floating_platform.mooring_lines[line_number].anchor_position = position; + return *this; + } + + InterfaceBuilder& SetMooringLineAnchorVelocity( + size_t line_number, const std::array& velocity + ) { + interface_in.turbine.floating_platform.mooring_lines[line_number].anchor_velocity = velocity; + return *this; + } + + InterfaceBuilder& SetMooringLineAnchorAcceleration( + size_t line_number, const std::array& acceleration + ) { + interface_in.turbine.floating_platform.mooring_lines[line_number].anchor_acceleration = + acceleration; + return *this; + } + + InterfaceBuilder& SetTurbine(const TurbineInput& turbine_in) { + interface_in.turbine = turbine_in; + return *this; + } + + Interface Build() const { return Interface(interface_in); } + +private: + InterfaceInput interface_in; +}; + +} // namespace openturbine::cfd diff --git a/tests/documentation_tests/floating_platform/floating_platform.cpp b/tests/documentation_tests/floating_platform/floating_platform.cpp index a3cc9822f..e74dd03fd 100644 --- a/tests/documentation_tests/floating_platform/floating_platform.cpp +++ b/tests/documentation_tests/floating_platform/floating_platform.cpp @@ -3,6 +3,7 @@ #include #include +#include int main() { Kokkos::initialize(); @@ -37,61 +38,28 @@ int main() { constexpr auto mooring_line_initial_length{55.432}; // m // Create cfd interface - auto interface = openturbine::cfd::Interface(openturbine::cfd::InterfaceInput{ - gravity, - time_step, // time step - rho_inf, // rho infinity (numerical damping) - max_iter, // max convergence iterations - openturbine::cfd::TurbineInput{ - openturbine::cfd::FloatingPlatformInput{ - true, // enable - { - platform_cm_position[0], - platform_cm_position[1], - platform_cm_position[2], - 1., - 0., - 0., - 0., - }, // position - {0., 0., 0., 0., 0., 0.}, // velocity - {0., 0., 0., 0., 0., 0.}, // acceleration - platform_mass_matrix, - { - { - mooring_line_stiffness, - mooring_line_initial_length, - {-40.87, 0.0, -14.}, // Fairlead node coordinates - {0., 0., 0.}, // Fairlead node velocity - {0., 0., 0.}, // Fairlead node acceleration - {-105.47, 0.0, -58.4}, // Anchor node coordinates - {0., 0., 0.}, // Anchor node velocity - {0., 0., 0.}, // Anchor node acceleration - }, - { - mooring_line_stiffness, - mooring_line_initial_length, - {20.43, -35.39, -14.}, // Fairlead node coordinates - {0., 0., 0.}, // Fairlead node velocity - {0., 0., 0.}, // Fairlead node acceleration - {52.73, -91.34, -58.4}, // Anchor node coordinates - {0., 0., 0.}, // Anchor node velocity - {0., 0., 0.}, // Anchor node acceleration - }, - { - mooring_line_stiffness, - mooring_line_initial_length, - {20.43, 35.39, -14.}, // Fairlead node coordinates - {0., 0., 0.}, // Fairlead node velocity - {0., 0., 0.}, // Fairlead node acceleration - {52.73, 91.34, -58.4}, // Anchor node coordinates - {0., 0., 0.}, // Anchor node velocity - {0., 0., 0.}, // Anchor node acceleration - }, - }, - }, - }, - }); + auto interface = InterfaceBuilder{} + .SetGravity(gravity) + .SetTimeStep(time_step) + .SetDampingFactor(rho_inf) + .SetMaximumNonlinearIterations(max_iter) + .EnableFloatingPlatform(true) + .SetFloatingPlatformPosition({0., 0., -7.53, 1., 0., 0., 0.}) + .SetFloatingPlatformMassMatrix(platform_mass_matrix) + .SetNumberOfMooringLines(3) + .SetMooringLineStiffness(0, mooring_line_stiffness) + .SetMooringLineUndeformedLength(0, mooring_line_initial_length) + .SetMooringLineFairleadPosition(0, {-40.87, 0.0, -14.}) + .SetMooringLineAnchorPosition(0, {-105.47, 0.0, -58.4}) + .SetMooringLineStiffness(1, mooring_line_stiffness) + .SetMooringLineUndeformedLength(1, mooring_line_initial_length) + .SetMooringLineFairleadPosition(1, {20.43, -35.39, -14.}) + .SetMooringLineAnchorPosition(1, {52.73, -91.34, -58.4}) + .SetMooringLineStiffness(2, mooring_line_stiffness) + .SetMooringLineUndeformedLength(2, mooring_line_initial_length) + .SetMooringLineFairleadPosition(2, {20.43, 35.39, -14.}) + .SetMooringLineAnchorPosition(2, {52.73, 91.34, -58.4}) + .Build(); // Save the initial state, then take first step interface.SaveState(); diff --git a/tests/regression_tests/interfaces/test_cfd_interface.cpp b/tests/regression_tests/interfaces/test_cfd_interface.cpp index 72c1fc859..acd5a80da 100644 --- a/tests/regression_tests/interfaces/test_cfd_interface.cpp +++ b/tests/regression_tests/interfaces/test_cfd_interface.cpp @@ -1,6 +1,7 @@ #include #include "interfaces/cfd/interface.hpp" +#include "interfaces/cfd/interface_builder.hpp" #include "regression/test_utilities.hpp" #include "viz/vtk_lines.hpp" @@ -10,29 +11,18 @@ using namespace openturbine::cfd; TEST(CFDInterfaceTest, PrecessionTest) { // Create cfd interface - Interface interface(InterfaceInput{ - {{0., 0., 0.}}, // gravity - 0.01, // time step - 1., // rho infinity (numerical damping) - 5, // max convergence iterations - TurbineInput{ - FloatingPlatformInput{ - true, // enable - {0., 0., 0., 1., 0., 0., 0.}, // position - {0., 0., 0., 0.5, 0.5, 1.0}, // velocity - {0., 0., 0., 0., 0., 0.}, // acceleration - {{ - {1., 0., 0., 0., 0., 0.}, // - {0., 1., 0., 0., 0., 0.}, // - {0., 0., 1., 0., 0., 0.}, // - {0., 0., 0., 1., 0., 0.}, // - {0., 0., 0., 0., 1., 0.}, // - {0., 0., 0., 0., 0., 0.5}, // - }}, // platform mass matrix - {}, // no mooring lines - }, - }, - }); + constexpr auto mass_matrix = + std::array{std::array{1., 0., 0., 0., 0., 0.}, std::array{0., 1., 0., 0., 0., 0.}, + std::array{0., 0., 1., 0., 0., 0.}, std::array{0., 0., 0., 1., 0., 0.}, + std::array{0., 0., 0., 0., 1., 0.}, std::array{0., 0., 0., 0., 0., .5}}; + auto interface = InterfaceBuilder{} + .SetTimeStep(0.01) + .SetDampingFactor(1.) + .SetMaximumNonlinearIterations(5U) + .EnableFloatingPlatform(true) + .SetFloatingPlatformVelocity({0., 0., 0., 0.5, 0.5, 1.}) + .SetFloatingPlatformMassMatrix(mass_matrix) + .Build(); // Create reference to platform node in interface auto& platform_node = interface.turbine.floating_platform.node; @@ -148,7 +138,6 @@ TEST(CFDInterfaceTest, FloatingPlatform) { constexpr auto platform_mass{1.419625E+7}; // kg constexpr Array_3 gravity{0., 0., -9.8124}; // m/s/s constexpr Array_3 platform_moi{1.2898E+10, 1.2851E+10, 1.4189E+10}; // kg*m*m - constexpr Array_3 platform_cm_position{0., 0., -7.53}; // m constexpr Array_6x6 platform_mass_matrix{{ {platform_mass, 0., 0., 0., 0., 0.}, // Row 1 {0., platform_mass, 0., 0., 0., 0.}, // Row 2 @@ -163,61 +152,28 @@ TEST(CFDInterfaceTest, FloatingPlatform) { constexpr auto mooring_line_initial_length{55.432}; // m // Create cfd interface - Interface interface(InterfaceInput{ - gravity, - time_step, // time step - rho_inf, // rho infinity (numerical damping) - max_iter, // max convergence iterations - TurbineInput{ - FloatingPlatformInput{ - true, // enable - { - platform_cm_position[0], - platform_cm_position[1], - platform_cm_position[2], - 1., - 0., - 0., - 0., - }, // position - {0., 0., 0., 0., 0., 0.}, // velocity - {0., 0., 0., 0., 0., 0.}, // acceleration - platform_mass_matrix, - { - { - mooring_line_stiffness, - mooring_line_initial_length, - {-40.87, 0.0, -14.}, // Fairlead node coordinates - {0., 0., 0.}, // Fairlead node velocity - {0., 0., 0.}, // Fairlead node acceleration - {-105.47, 0.0, -58.4}, // Anchor node coordinates - {0., 0., 0.}, // Anchor node velocity - {0., 0., 0.}, // Anchor node acceleration - }, - { - mooring_line_stiffness, - mooring_line_initial_length, - {20.43, -35.39, -14.}, // Fairlead node coordinates - {0., 0., 0.}, // Fairlead node velocity - {0., 0., 0.}, // Fairlead node acceleration - {52.73, -91.34, -58.4}, // Anchor node coordinates - {0., 0., 0.}, // Anchor node velocity - {0., 0., 0.}, // Anchor node acceleration - }, - { - mooring_line_stiffness, - mooring_line_initial_length, - {20.43, 35.39, -14.}, // Fairlead node coordinates - {0., 0., 0.}, // Fairlead node velocity - {0., 0., 0.}, // Fairlead node acceleration - {52.73, 91.34, -58.4}, // Anchor node coordinates - {0., 0., 0.}, // Anchor node velocity - {0., 0., 0.}, // Anchor node acceleration - }, - }, - }, - }, - }); + auto interface = InterfaceBuilder{} + .SetGravity(gravity) + .SetTimeStep(time_step) + .SetDampingFactor(rho_inf) + .SetMaximumNonlinearIterations(max_iter) + .EnableFloatingPlatform(true) + .SetFloatingPlatformPosition({0., 0., -7.53, 1., 0., 0., 0.}) + .SetFloatingPlatformMassMatrix(platform_mass_matrix) + .SetNumberOfMooringLines(3) + .SetMooringLineStiffness(0, mooring_line_stiffness) + .SetMooringLineUndeformedLength(0, mooring_line_initial_length) + .SetMooringLineFairleadPosition(0, {-40.87, 0.0, -14.}) + .SetMooringLineAnchorPosition(0, {-105.47, 0.0, -58.4}) + .SetMooringLineStiffness(1, mooring_line_stiffness) + .SetMooringLineUndeformedLength(1, mooring_line_initial_length) + .SetMooringLineFairleadPosition(1, {20.43, -35.39, -14.}) + .SetMooringLineAnchorPosition(1, {52.73, -91.34, -58.4}) + .SetMooringLineStiffness(2, mooring_line_stiffness) + .SetMooringLineUndeformedLength(2, mooring_line_initial_length) + .SetMooringLineFairleadPosition(2, {20.43, 35.39, -14.}) + .SetMooringLineAnchorPosition(2, {52.73, 91.34, -58.4}) + .Build(); // Save the initial state, then take first step interface.SaveState(); @@ -285,7 +241,6 @@ TEST(CFDInterfaceTest, Restart) { constexpr auto platform_mass{1.419625E+7}; // kg constexpr Array_3 gravity{0., 0., -9.8124}; // m/s/s constexpr Array_3 platform_moi{1.2898E+10, 1.2851E+10, 1.4189E+10}; // kg*m*m - constexpr Array_3 platform_cm_position{0., 0., -7.53}; // m constexpr Array_6x6 platform_mass_matrix{{ {platform_mass, 0., 0., 0., 0., 0.}, // Row 1 {0., platform_mass, 0., 0., 0., 0.}, // Row 2 @@ -299,63 +254,30 @@ TEST(CFDInterfaceTest, Restart) { constexpr auto mooring_line_stiffness{48.9e3}; // N constexpr auto mooring_line_initial_length{55.432}; // m - auto interface_input = InterfaceInput{ - gravity, - time_step, // time step - rho_inf, // rho infinity (numerical damping) - max_iter, // max convergence iterations - TurbineInput{ - FloatingPlatformInput{ - true, // enable - { - platform_cm_position[0], - platform_cm_position[1], - platform_cm_position[2], - 1., - 0., - 0., - 0., - }, // position - {0., 0., 0., 0., 0., 0.}, // velocity - {0., 0., 0., 0., 0., 0.}, // acceleration - platform_mass_matrix, - { - { - mooring_line_stiffness, - mooring_line_initial_length, - {-40.87, 0.0, -14.}, // Fairlead node coordinates - {0., 0., 0.}, // Fairlead node velocity - {0., 0., 0.}, // Fairlead node acceleration - {-105.47, 0.0, -58.4}, // Anchor node coordinates - {0., 0., 0.}, // Anchor node velocity - {0., 0., 0.}, // Anchor node acceleration - }, - { - mooring_line_stiffness, - mooring_line_initial_length, - {20.43, -35.39, -14.}, // Fairlead node coordinates - {0., 0., 0.}, // Fairlead node velocity - {0., 0., 0.}, // Fairlead node acceleration - {52.73, -91.34, -58.4}, // Anchor node coordinates - {0., 0., 0.}, // Anchor node velocity - {0., 0., 0.}, // Anchor node acceleration - }, - { - mooring_line_stiffness, - mooring_line_initial_length, - {20.43, 35.39, -14.}, // Fairlead node coordinates - {0., 0., 0.}, // Fairlead node velocity - {0., 0., 0.}, // Fairlead node acceleration - {52.73, 91.34, -58.4}, // Anchor node coordinates - {0., 0., 0.}, // Anchor node velocity - {0., 0., 0.}, // Anchor node acceleration - }, - }, - }, - }, - }; - - auto interface1 = Interface(interface_input); + auto builder = InterfaceBuilder{} + .SetGravity(gravity) + .SetTimeStep(time_step) + .SetDampingFactor(rho_inf) + .SetMaximumNonlinearIterations(max_iter) + .EnableFloatingPlatform(true) + .SetFloatingPlatformPosition({0., 0., -7.53, 1., 0., 0., 0.}) + .SetFloatingPlatformMassMatrix(platform_mass_matrix) + .SetNumberOfMooringLines(3) + .SetMooringLineStiffness(0, mooring_line_stiffness) + .SetMooringLineUndeformedLength(0, mooring_line_initial_length) + .SetMooringLineFairleadPosition(0, {-40.87, 0.0, -14.}) + .SetMooringLineAnchorPosition(0, {-105.47, 0.0, -58.4}) + .SetMooringLineStiffness(1, mooring_line_stiffness) + .SetMooringLineUndeformedLength(1, mooring_line_initial_length) + .SetMooringLineFairleadPosition(1, {20.43, -35.39, -14.}) + .SetMooringLineAnchorPosition(1, {52.73, -91.34, -58.4}) + .SetMooringLineStiffness(2, mooring_line_stiffness) + .SetMooringLineUndeformedLength(2, mooring_line_initial_length) + .SetMooringLineFairleadPosition(2, {20.43, 35.39, -14.}) + .SetMooringLineAnchorPosition(2, {52.73, 91.34, -58.4}); + + auto interface1 = builder.Build(); + ; // Take 10 initial steps for (auto i = 0U; i < 100U; ++i) { @@ -375,7 +297,7 @@ TEST(CFDInterfaceTest, Restart) { EXPECT_TRUE(converged); } - auto interface2 = Interface(interface_input); + auto interface2 = builder.Build(); interface2.ReadRestart("test_restart.dat"); // Take 10 steps using restarted system From 482162ee49453ade7b8199b3c8b9f8546f6a0121 Mon Sep 17 00:00:00 2001 From: dcdemen Date: Mon, 10 Feb 2025 16:02:25 -0700 Subject: [PATCH 2/5] clang-tidy fixes --- src/interfaces/cfd/floating_platform_input.hpp | 4 ++-- src/interfaces/cfd/interface_builder.hpp | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/interfaces/cfd/floating_platform_input.hpp b/src/interfaces/cfd/floating_platform_input.hpp index cc6f5d35a..684c8edd1 100644 --- a/src/interfaces/cfd/floating_platform_input.hpp +++ b/src/interfaces/cfd/floating_platform_input.hpp @@ -21,10 +21,10 @@ struct FloatingPlatformInput { std::array acceleration{0., 0., 0., 0., 0., 0.}; /// Platform point mass matrix - std::array, 6> mass_matrix; + std::array, 6> mass_matrix{}; /// Mooring line array - std::vector mooring_lines; + std::vector mooring_lines{}; }; } // namespace openturbine::cfd diff --git a/src/interfaces/cfd/interface_builder.hpp b/src/interfaces/cfd/interface_builder.hpp index e2e68ab74..a32246b20 100644 --- a/src/interfaces/cfd/interface_builder.hpp +++ b/src/interfaces/cfd/interface_builder.hpp @@ -121,7 +121,7 @@ struct InterfaceBuilder { return *this; } - Interface Build() const { return Interface(interface_in); } + [[nodiscard]] Interface Build() const { return Interface(interface_in); } private: InterfaceInput interface_in; From ba03b3066ea4eab7c83e2a227512da3e59023d3f Mon Sep 17 00:00:00 2001 From: ddement Date: Mon, 10 Feb 2025 21:42:05 -0500 Subject: [PATCH 3/5] Update floating_platform_input.hpp --- src/interfaces/cfd/floating_platform_input.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/interfaces/cfd/floating_platform_input.hpp b/src/interfaces/cfd/floating_platform_input.hpp index 684c8edd1..09890d195 100644 --- a/src/interfaces/cfd/floating_platform_input.hpp +++ b/src/interfaces/cfd/floating_platform_input.hpp @@ -24,7 +24,7 @@ struct FloatingPlatformInput { std::array, 6> mass_matrix{}; /// Mooring line array - std::vector mooring_lines{}; + std::vector mooring_lines; }; } // namespace openturbine::cfd From d2aefee03fc911b2b701036b98236569492de126 Mon Sep 17 00:00:00 2001 From: dcdemen Date: Wed, 19 Feb 2025 16:15:18 -0700 Subject: [PATCH 4/5] Addressed formatting feedback --- src/interfaces/cfd/CMakeLists.txt | 2 +- src/interfaces/cfd/interface_builder.hpp | 84 ++++++++---------------- 2 files changed, 30 insertions(+), 56 deletions(-) diff --git a/src/interfaces/cfd/CMakeLists.txt b/src/interfaces/cfd/CMakeLists.txt index 7dd061d2a..df5715b7e 100644 --- a/src/interfaces/cfd/CMakeLists.txt +++ b/src/interfaces/cfd/CMakeLists.txt @@ -1,4 +1,4 @@ -target_sources(openturbine_library +target_sources(openturbine_library PRIVATE interface.cpp ) diff --git a/src/interfaces/cfd/interface_builder.hpp b/src/interfaces/cfd/interface_builder.hpp index a32246b20..ba45625e2 100644 --- a/src/interfaces/cfd/interface_builder.hpp +++ b/src/interfaces/cfd/interface_builder.hpp @@ -9,122 +9,96 @@ namespace openturbine::cfd { struct InterfaceBuilder { InterfaceBuilder& SetGravity(const std::array& gravity) { - interface_in.gravity = gravity; + interface_input.gravity = gravity; return *this; } InterfaceBuilder& SetMaximumNonlinearIterations(size_t max_iter) { - interface_in.max_iter = max_iter; + interface_input.max_iter = max_iter; return *this; } InterfaceBuilder& SetTimeStep(double time_step) { - interface_in.time_step = time_step; + interface_input.time_step = time_step; return *this; } InterfaceBuilder& SetDampingFactor(double rho_inf) { - interface_in.rho_inf = rho_inf; + interface_input.rho_inf = rho_inf; return *this; } InterfaceBuilder& EnableFloatingPlatform(bool enable) { - interface_in.turbine.floating_platform.enable = enable; + interface_input.turbine.floating_platform.enable = enable; return *this; } - InterfaceBuilder& SetFloatingPlatformPosition(const std::array& position) { - interface_in.turbine.floating_platform.position = position; + InterfaceBuilder& SetFloatingPlatformPosition(const std::array& p) { + interface_input.turbine.floating_platform.position = p; return *this; } - InterfaceBuilder& SetFloatingPlatformVelocity(const std::array& velocity) { - interface_in.turbine.floating_platform.velocity = velocity; + InterfaceBuilder& SetFloatingPlatformVelocity(const std::array& v) { + interface_input.turbine.floating_platform.velocity = v; return *this; } - InterfaceBuilder& SetFloatingPlatformAcceleration(const std::array& acceleration) { - interface_in.turbine.floating_platform.acceleration = acceleration; + InterfaceBuilder& SetFloatingPlatformAcceleration(const std::array& a) { + interface_input.turbine.floating_platform.acceleration = a; return *this; } InterfaceBuilder& SetFloatingPlatformMassMatrix( const std::array, 6>& mass_matrix ) { - interface_in.turbine.floating_platform.mass_matrix = mass_matrix; + interface_input.turbine.floating_platform.mass_matrix = mass_matrix; return *this; } - InterfaceBuilder& SetNumberOfMooringLines(size_t number_of_mooring_lines) { - interface_in.turbine.floating_platform.mooring_lines.resize(number_of_mooring_lines); + InterfaceBuilder& SetNumberOfMooringLines(size_t number) { + interface_input.turbine.floating_platform.mooring_lines.resize(number); return *this; } - InterfaceBuilder& SetMooringLineStiffness(size_t line_number, double stiffness) { - interface_in.turbine.floating_platform.mooring_lines[line_number].stiffness = stiffness; + InterfaceBuilder& SetMooringLineStiffness(size_t line, double stiffness) { + interface_input.turbine.floating_platform.mooring_lines[line].stiffness = stiffness; return *this; } - InterfaceBuilder& SetMooringLineUndeformedLength(size_t line_number, double length) { - interface_in.turbine.floating_platform.mooring_lines[line_number].undeformed_length = length; + InterfaceBuilder& SetMooringLineUndeformedLength(size_t line, double length) { + interface_input.turbine.floating_platform.mooring_lines[line].undeformed_length = length; return *this; } - InterfaceBuilder& SetMooringLineFairleadPosition( - size_t line_number, const std::array& position - ) { - interface_in.turbine.floating_platform.mooring_lines[line_number].fairlead_position = - position; - return *this; - } - - InterfaceBuilder& SetMooringLineFairleadVelocity( - size_t line_number, const std::array& velocity - ) { - interface_in.turbine.floating_platform.mooring_lines[line_number].fairlead_velocity = - velocity; - return *this; - } - - InterfaceBuilder& SetMooringLineFairleadAcceleration( - size_t line_number, const std::array& acceleration - ) { - interface_in.turbine.floating_platform.mooring_lines[line_number].fairlead_acceleration = - acceleration; + InterfaceBuilder& SetMooringLineFairleadPosition(size_t line, const std::array& p) { + interface_input.turbine.floating_platform.mooring_lines[line].fairlead_position = p; return *this; } - InterfaceBuilder& SetMooringLineAnchorPosition( - size_t line_number, const std::array& position - ) { - interface_in.turbine.floating_platform.mooring_lines[line_number].anchor_position = position; + InterfaceBuilder& SetMooringLineAnchorPosition(size_t line, const std::array& p) { + interface_input.turbine.floating_platform.mooring_lines[line].anchor_position = p; return *this; } - InterfaceBuilder& SetMooringLineAnchorVelocity( - size_t line_number, const std::array& velocity - ) { - interface_in.turbine.floating_platform.mooring_lines[line_number].anchor_velocity = velocity; + InterfaceBuilder& SetMooringLineAnchorVelocity(size_t line, const std::array& v) { + interface_input.turbine.floating_platform.mooring_lines[line].anchor_velocity = v; return *this; } - InterfaceBuilder& SetMooringLineAnchorAcceleration( - size_t line_number, const std::array& acceleration - ) { - interface_in.turbine.floating_platform.mooring_lines[line_number].anchor_acceleration = - acceleration; + InterfaceBuilder& SetMooringLineAnchorAcceleration(size_t line, const std::array& a) { + interface_input.turbine.floating_platform.mooring_lines[line].anchor_acceleration = a; return *this; } InterfaceBuilder& SetTurbine(const TurbineInput& turbine_in) { - interface_in.turbine = turbine_in; + interface_input.turbine = turbine_in; return *this; } - [[nodiscard]] Interface Build() const { return Interface(interface_in); } + [[nodiscard]] Interface Build() const { return Interface(interface_input); } private: - InterfaceInput interface_in; + InterfaceInput interface_input; }; } // namespace openturbine::cfd From 1447cbc88e86bdf9509c6b24afdf14e28b1f9716 Mon Sep 17 00:00:00 2001 From: dcdemen Date: Fri, 28 Feb 2025 14:31:56 -0700 Subject: [PATCH 5/5] Prototyped "step builder" approach to the interface builder for feedback --- src/interfaces/cfd/interface_builder.hpp | 97 +++++++++++++++++-- .../interfaces/test_cfd_interface.cpp | 65 +++++++++---- 2 files changed, 137 insertions(+), 25 deletions(-) diff --git a/src/interfaces/cfd/interface_builder.hpp b/src/interfaces/cfd/interface_builder.hpp index ba45625e2..da5d13e44 100644 --- a/src/interfaces/cfd/interface_builder.hpp +++ b/src/interfaces/cfd/interface_builder.hpp @@ -6,8 +6,82 @@ #include "mooring_line_input.hpp" namespace openturbine::cfd { - struct InterfaceBuilder { + struct FloatingPlatformBuilder { + FloatingPlatformBuilder& SetPosition(const std::array& p) { + i_builder->interface_input.turbine.floating_platform.position = p; + return *this; + } + + FloatingPlatformBuilder& SetVelocity(const std::array& v) { + i_builder->interface_input.turbine.floating_platform.velocity = v; + return *this; + } + + FloatingPlatformBuilder& SetAcceleration(const std::array& a) { + i_builder->interface_input.turbine.floating_platform.acceleration = a; + return *this; + } + + FloatingPlatformBuilder& SetMassMatrix( + const std::array, 6>& mass_matrix + ) { + i_builder->interface_input.turbine.floating_platform.mass_matrix = mass_matrix; + return *this; + } + + [[nodiscard]] InterfaceBuilder& EndFloatingPlatform() const { + i_builder->interface_input.turbine.floating_platform.enable = true; + return *i_builder; + } + + InterfaceBuilder* i_builder; + }; + + struct MooringLineBuilder { + MooringLineBuilder& SetStiffness(double stiffness) { + i_builder->interface_input.turbine.floating_platform.mooring_lines.back().stiffness = + stiffness; + return *this; + } + + MooringLineBuilder& SetUndeformedLength(double length) { + i_builder->interface_input.turbine.floating_platform.mooring_lines.back() + .undeformed_length = length; + return *this; + } + + MooringLineBuilder& SetFairleadPosition(const std::array& p) { + i_builder->interface_input.turbine.floating_platform.mooring_lines.back() + .fairlead_position = p; + return *this; + } + + MooringLineBuilder& SetAnchorPosition(const std::array& p) { + i_builder->interface_input.turbine.floating_platform.mooring_lines.back() + .anchor_position = p; + return *this; + } + + MooringLineBuilder& SetAnchorVelocity(const std::array& v) { + i_builder->interface_input.turbine.floating_platform.mooring_lines.back() + .anchor_velocity = v; + return *this; + } + + MooringLineBuilder& SetAnchorAcceleration(const std::array& a) { + i_builder->interface_input.turbine.floating_platform.mooring_lines.back() + .anchor_acceleration = a; + return *this; + } + + [[nodiscard]] InterfaceBuilder& EndMooringLine() const { return *i_builder; } + + InterfaceBuilder* i_builder; + }; + + InterfaceBuilder() : interface_input{}, fp_builder{this}, ml_builder{this} {} + InterfaceBuilder& SetGravity(const std::array& gravity) { interface_input.gravity = gravity; return *this; @@ -23,6 +97,13 @@ struct InterfaceBuilder { return *this; } + FloatingPlatformBuilder& StartFloatingPlatform() { return fp_builder; } + + MooringLineBuilder& AddMooringLine() { + interface_input.turbine.floating_platform.mooring_lines.push_back({}); + return ml_builder; + } + InterfaceBuilder& SetDampingFactor(double rho_inf) { interface_input.rho_inf = rho_inf; return *this; @@ -90,15 +171,17 @@ struct InterfaceBuilder { return *this; } - InterfaceBuilder& SetTurbine(const TurbineInput& turbine_in) { - interface_input.turbine = turbine_in; - return *this; - } - [[nodiscard]] Interface Build() const { return Interface(interface_input); } -private: + friend FloatingPlatformBuilder; + friend MooringLineBuilder; + +protected: InterfaceInput interface_input; + +private: + FloatingPlatformBuilder fp_builder; + MooringLineBuilder ml_builder; }; } // namespace openturbine::cfd diff --git a/tests/regression_tests/interfaces/test_cfd_interface.cpp b/tests/regression_tests/interfaces/test_cfd_interface.cpp index 4c589c66a..edfc31688 100644 --- a/tests/regression_tests/interfaces/test_cfd_interface.cpp +++ b/tests/regression_tests/interfaces/test_cfd_interface.cpp @@ -151,30 +151,59 @@ TEST(CFDInterfaceTest, FloatingPlatform) { constexpr auto mooring_line_stiffness{48.9e3}; // N constexpr auto mooring_line_initial_length{55.432}; // m - // Create cfd interface auto interface = InterfaceBuilder{} .SetGravity(gravity) .SetTimeStep(time_step) .SetDampingFactor(rho_inf) .SetMaximumNonlinearIterations(max_iter) - .EnableFloatingPlatform(true) - .SetFloatingPlatformPosition({0., 0., -7.53, 1., 0., 0., 0.}) - .SetFloatingPlatformMassMatrix(platform_mass_matrix) - .SetNumberOfMooringLines(3) - .SetMooringLineStiffness(0, mooring_line_stiffness) - .SetMooringLineUndeformedLength(0, mooring_line_initial_length) - .SetMooringLineFairleadPosition(0, {-40.87, 0.0, -14.}) - .SetMooringLineAnchorPosition(0, {-105.47, 0.0, -58.4}) - .SetMooringLineStiffness(1, mooring_line_stiffness) - .SetMooringLineUndeformedLength(1, mooring_line_initial_length) - .SetMooringLineFairleadPosition(1, {20.43, -35.39, -14.}) - .SetMooringLineAnchorPosition(1, {52.73, -91.34, -58.4}) - .SetMooringLineStiffness(2, mooring_line_stiffness) - .SetMooringLineUndeformedLength(2, mooring_line_initial_length) - .SetMooringLineFairleadPosition(2, {20.43, 35.39, -14.}) - .SetMooringLineAnchorPosition(2, {52.73, 91.34, -58.4}) + .StartFloatingPlatform() + .SetPosition({0., 0., -7.53, 1., 0., 0., 0.}) + .SetMassMatrix(platform_mass_matrix) + .EndFloatingPlatform() + .AddMooringLine() + .SetStiffness(mooring_line_stiffness) + .SetUndeformedLength(mooring_line_initial_length) + .SetFairleadPosition({-40.87, 0.0, -14.}) + .SetAnchorPosition({-105.47, 0.0, -58.4}) + .EndMooringLine() + .AddMooringLine() + .SetStiffness(mooring_line_stiffness) + .SetUndeformedLength(mooring_line_initial_length) + .SetFairleadPosition({20.43, -35.39, -14.}) + .SetAnchorPosition({52.73, -91.34, -58.4}) + .EndMooringLine() + .AddMooringLine() + .SetStiffness(mooring_line_stiffness) + .SetUndeformedLength(mooring_line_initial_length) + .SetFairleadPosition({20.43, 35.39, -14.}) + .SetAnchorPosition({52.73, 91.34, -58.4}) + .EndMooringLine() .Build(); - + /* + // Create cfd interface + auto interface = InterfaceBuilder{} + .SetGravity(gravity) + .SetTimeStep(time_step) + .SetDampingFactor(rho_inf) + .SetMaximumNonlinearIterations(max_iter) + .EnableFloatingPlatform(true) + .SetFloatingPlatformPosition({0., 0., -7.53, 1., 0., 0., 0.}) + .SetFloatingPlatformMassMatrix(platform_mass_matrix) + .SetNumberOfMooringLines(3) + .SetMooringLineStiffness(0, mooring_line_stiffness) + .SetMooringLineUndeformedLength(0, mooring_line_initial_length) + .SetMooringLineFairleadPosition(0, {-40.87, 0.0, -14.}) + .SetMooringLineAnchorPosition(0, {-105.47, 0.0, -58.4}) + .SetMooringLineStiffness(1, mooring_line_stiffness) + .SetMooringLineUndeformedLength(1, mooring_line_initial_length) + .SetMooringLineFairleadPosition(1, {20.43, -35.39, -14.}) + .SetMooringLineAnchorPosition(1, {52.73, -91.34, -58.4}) + .SetMooringLineStiffness(2, mooring_line_stiffness) + .SetMooringLineUndeformedLength(2, mooring_line_initial_length) + .SetMooringLineFairleadPosition(2, {20.43, 35.39, -14.}) + .SetMooringLineAnchorPosition(2, {52.73, 91.34, -58.4}) + .Build(); + */ // Calculate buoyancy force as percentage of gravitational force plus spring forces times const auto initial_spring_force = 1907514.4912628897; const auto platform_gravity_force = -gravity[2] * platform_mass;