Added InterfaceBuilder to improve ergonomics of creating our CFD interface

src/interfaces/cfd/CMakeLists.txt

@@ -1,4 +1,4 @@
-target_sources(openturbine_library 
+target_sources(openturbine_library
   PRIVATE
   interface.cpp
 )
@@ -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

src/interfaces/cfd/floating_platform_input.hpp

@@ -21,7 +21,7 @@ struct FloatingPlatformInput {
     std::array<double, 6> acceleration{0., 0., 0., 0., 0., 0.};
 
     /// Platform point mass matrix
-    std::array<std::array<double, 6>, 6> mass_matrix;
+    std::array<std::array<double, 6>, 6> mass_matrix{};
 
     /// Mooring line array
     std::vector<MooringLineInput> mooring_lines;

src/interfaces/cfd/interface_builder.hpp

@@ -0,0 +1,111 @@
+#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<double, 3>& gravity) {
+        interface_input.gravity = gravity;
+        return *this;
+    }
+
+    InterfaceBuilder& SetMaximumNonlinearIterations(size_t max_iter) {
+        interface_input.max_iter = max_iter;
+        return *this;
+    }
+
+    InterfaceBuilder& SetTimeStep(double time_step) {
+        if (time_step < 0.) {
+            throw std::out_of_range("time_step must be positive");
+        }
+        interface_input.time_step = time_step;
+        return *this;
+    }
+
+    InterfaceBuilder& SetDampingFactor(double rho_inf) {
+        if (rho_inf < 0. || rho_inf > 1.) {
+            throw std::out_of_range("rho_inf must be in range [0., 1.]");
+        }
+        interface_input.rho_inf = rho_inf;
+        return *this;
+    }
+
+    InterfaceBuilder& EnableFloatingPlatform(bool enable) {
+        interface_input.turbine.floating_platform.enable = enable;
+        return *this;
+    }
+
+    InterfaceBuilder& SetFloatingPlatformPosition(const std::array<double, 7>& p) {
+        interface_input.turbine.floating_platform.position = p;
+        return *this;
+    }
+
+    InterfaceBuilder& SetFloatingPlatformVelocity(const std::array<double, 6>& v) {
+        interface_input.turbine.floating_platform.velocity = v;
+        return *this;
+    }
+
+    InterfaceBuilder& SetFloatingPlatformAcceleration(const std::array<double, 6>& a) {
+        interface_input.turbine.floating_platform.acceleration = a;
+        return *this;
+    }
+
+    InterfaceBuilder& SetFloatingPlatformMassMatrix(
+        const std::array<std::array<double, 6>, 6>& mass_matrix
+    ) {
+        interface_input.turbine.floating_platform.mass_matrix = mass_matrix;
+        return *this;
+    }
+
+    InterfaceBuilder& SetNumberOfMooringLines(size_t number) {
+        interface_input.turbine.floating_platform.mooring_lines.resize(number);
+        return *this;
+    }
+
+    InterfaceBuilder& SetMooringLineStiffness(size_t line, double stiffness) {
+        if (stiffness < 0.) {
+            throw std::out_of_range("stiffness must be positive");
+        }
+        interface_input.turbine.floating_platform.mooring_lines.at(line).stiffness = stiffness;
+        return *this;
+    }
+
+    InterfaceBuilder& SetMooringLineUndeformedLength(size_t line, double length) {
+        if (length < 0.) {
+            throw std::out_of_range("undeformed length must be positive");
+        }
+        interface_input.turbine.floating_platform.mooring_lines.at(line).undeformed_length = length;
+        return *this;
+    }
+
+    InterfaceBuilder& SetMooringLineFairleadPosition(size_t line, const std::array<double, 3>& p) {
+        interface_input.turbine.floating_platform.mooring_lines.at(line).fairlead_position = p;
+        return *this;
+    }
+
+    InterfaceBuilder& SetMooringLineAnchorPosition(size_t line, const std::array<double, 3>& p) {
+        interface_input.turbine.floating_platform.mooring_lines.at(line).anchor_position = p;
+        return *this;
+    }
+
+    InterfaceBuilder& SetMooringLineAnchorVelocity(size_t line, const std::array<double, 3>& v) {
+        interface_input.turbine.floating_platform.mooring_lines.at(line).anchor_velocity = v;
+        return *this;
+    }
+
+    InterfaceBuilder& SetMooringLineAnchorAcceleration(size_t line, const std::array<double, 3>& a) {
+        interface_input.turbine.floating_platform.mooring_lines.at(line).anchor_acceleration = a;
+        return *this;
+    }
+
+    [[nodiscard]] Interface Build() const { return Interface(interface_input); }
+
+private:
+    InterfaceInput interface_input;
+};
+
+}  // namespace openturbine::cfd

tests/documentation_tests/floating_platform/floating_platform.cpp

@@ -3,6 +3,7 @@
 
 #include <Kokkos_Core.hpp>
 #include <interfaces/cfd/interface.hpp>
+#include <interfaces/cfd/interface_builder.hpp>
 
 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();
 
         // Calculate buoyancy force as percentage of gravitational force plus spring forces times
         const auto initial_spring_force = 1907514.4912628897;