feat(core)!: Line breaking utilities

sanguinariojoe · sanguinariojoe · commit 269cc73f58c8 · 2026-04-16T15:45:01.000+02:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.10)
 set(MOORDYN_MAJOR_VERSION 2)
-set(MOORDYN_MINOR_VERSION 6)
-set(MOORDYN_PATCH_VERSION 2)
+set(MOORDYN_MINOR_VERSION 7)
+set(MOORDYN_PATCH_VERSION 0)
 set(MOORDYN_VERSION ${MOORDYN_MAJOR_VERSION}.${MOORDYN_MINOR_VERSION})
 project(Moordyn VERSION ${MOORDYN_VERSION})
 
diff --git a/source/MoorDyn2.cpp b/source/MoorDyn2.cpp
@@ -795,6 +795,38 @@ moordyn::MoorDyn::Step(const double* x,
 		return MOORDYN_SUCCESS;
 }
 
+void
+MoorDyn::BreakLine(moordyn::Point* point, moordyn::Line* line)
+{
+	// Detach the line from the point
+	moordyn::EndPoints end_point;
+	auto pt_attachments = point->getLines();
+	for (auto attachment : pt_attachments) {
+		if (attachment.line == line) {
+			end_point = attachment.end_point;
+		}
+	}
+	point->removeLine(line);
+	// Create the new point
+	moordyn::Point *pt = new Point(point, PointList.size());
+	PointList.push_back(pt);
+	waves->addPoint(pt);
+	_t_integrator->AddPoint(pt);
+	// Set the state of the point
+	auto state = _t_integrator->r(0);
+	pt->initialize(state->get(pt));
+	for (unsigned int i = 0; i < _t_integrator->GetNDeriv(); i++) {
+		_t_integrator->rd(i)->get(pt).row(0)(Eigen::seqN(0, 3)) =
+			state->get(pt).row(0)(Eigen::seqN(3, 3));
+		// NOTE: Although when cloning free points we can actually get the
+		// acceleration, I (Jose Luis Cercos-Pita) do not think is worthy, so
+		// I am simply setting no acceleration
+		_t_integrator->rd(i)->get(pt).row(0)(Eigen::seqN(3, 3)) = vec::Zero();
+	}
+	// Attach the line to the point
+	pt->addLine(line, end_point);
+}
+
 std::vector<uint64_t>
 MoorDyn::Serialize(void)
 {
@@ -1155,8 +1187,7 @@ moordyn::MoorDyn::ReadInFile()
 				env->WtrDpth = -r0[2];
 				LOGWRN << "\t Water depth set to point " << PointList.size() + 1
 				       << " z position because point was specified below the "
-				          "seabed"
-				       << endl;
+				          "seabed" << endl;
 			}
 
 			// Check point ID is sequential starting from 1
@@ -2896,6 +2927,28 @@ MoorDyn_GetFASTtens(MoorDyn system,
 	return MOORDYN_SUCCESS;
 }
 
+int DECLDIR
+MoorDyn_BreakLine(MoorDyn system,
+                  MoorDynPoint point,
+                  MoorDynLine line)
+{
+	CHECK_SYSTEM(system);
+
+	moordyn::error_id err = MOORDYN_SUCCESS;
+	string err_msg;
+	try {
+		((moordyn::MoorDyn*)system)->BreakLine((moordyn::Point*)point,
+		                                       (moordyn::Line*)line);
+	}
+	MOORDYN_CATCHER(err, err_msg);
+	if (err != MOORDYN_SUCCESS) {
+		cerr << "Error (" << err << ") at " << __FUNC_NAME__ << "():" << endl
+		     << err_msg << endl;
+		return err;
+	}
+	return MOORDYN_SUCCESS;
+}
+
 int DECLDIR
 MoorDyn_GetDt(MoorDyn system, double* dt)
 {
diff --git a/source/MoorDyn2.h b/source/MoorDyn2.h
@@ -435,6 +435,21 @@ MoorDyn_GetFASTtens(MoorDyn system,
                     float AnchHTen[],
                     float AnchVTen[]);
 
+/** @brief Break a line on a specific point
+ *
+ * This method is dettaching a line from the point, and in exchange is
+ * creating a point duplicate of type moordyn::Point::types::FREE
+ * @param system The Moordyn system
+ * @param point The discconection point
+ * @param line The line that is dettaching from the point
+ * @throw MOORDYN_SUCESS If the line is correctly dettached, an error code
+ * otherwise (see @ref moordyn_errors)
+ */
+int DECLDIR
+MoorDyn_BreakLine(MoorDyn system,
+                  MoorDynPoint point,
+                  MoorDynLine line);
+
 /** @brief Get the current model time step
  * @param system The Moordyn system
  * @param dt The output time step
diff --git a/source/MoorDyn2.hpp b/source/MoorDyn2.hpp
@@ -268,6 +268,17 @@ class MoorDyn final : public io::IO
 		waves->setWaveKinematics(U, Ud);
 	}
 
+	/** @brief Break a line on a specific point
+	 *
+	 * This method is dettaching a line from the point, and in exchange is
+	 * creating a point duplicate of type moordyn::Point::types::FREE
+	 * @param point The discconection point
+	 * @param line The line that is dettaching from the point
+	 * @throw moordyn::invalid_value_error If the line is not attached to the
+	 * point.
+	 */
+	void BreakLine(moordyn::Point* point, moordyn::Line* line);
+
 	/** @brief Produce the packed data to be saved
 	 *
 	 * The produced data can be used afterwards to restore the saved information
diff --git a/source/Point.cpp b/source/Point.cpp
@@ -38,12 +38,35 @@ namespace moordyn {
 
 Point::Point(moordyn::Log* log, size_t id)
   : Instance(log)
+  , waves(nullptr)
   , seafloor(nullptr)
   , pointId(id)
 {
 	vtk.set_binary();
 }
 
+Point::Point(Point* visitor, size_t id)
+  : Instance(visitor->GetLogger())
+  , env(visitor->env)
+  , waves(visitor->waves)
+  , seafloor(visitor->seafloor)
+  , pointM(visitor->pointM)
+  , pointV(visitor->pointV)
+  , pointF(visitor->pointF)
+  , pointCdA(visitor->pointCdA)
+  , r(visitor->r)
+  , rd(visitor->rd)
+  , Fnet(visitor->rd)
+  , t(visitor->t)
+  , M(visitor->M)
+  , acc(visitor->acc)
+  , pointId(id)
+  , number(id + 1)
+  , type(types::FREE)
+{
+	vtk.set_binary();
+}
+
 Point::~Point() {}
 
 void
@@ -150,7 +173,9 @@ Point::initialize()
 		    seafloor ? seafloor->getDepthAt(r[0], r[1]) : -env->WtrDpth;
 		if (waterDepth > r[2]) {
 			LOGERR << "Error: water depth is shallower than Point " << number
-			       << "." << endl;
+			       << "." << endl
+			       << "\tseabed z = " << waterDepth << endl
+			       << "\tpoint = " << r << endl;
 			throw moordyn::invalid_value_error("Invalid water depth");
 		}
 	}
diff --git a/source/Point.hpp b/source/Point.hpp
@@ -74,6 +74,15 @@ class DECLDIR Point final
 	 */
 	Point(moordyn::Log* log, size_t id);
 
+	/** @brief Point duplicator
+	 *
+	 * The duplicated point will have the same dynamics of the original point.
+	 * It will be a ::types::FREE kind of point though
+	 * @param visitor Point to duplicate
+	 * @param id Unique identifier of this instance
+	 */
+	Point(Point* visitor, size_t id);
+
 	/** @brief Destructor
 	 */
 	~Point();
diff --git a/source/Time.hpp b/source/Time.hpp
@@ -256,11 +256,26 @@ class Scheme : public io::IO
 	 */
 	virtual void Step(real& dt) { t_local += dt; };
 
+	/** @brief Get the number of state variables
+	 * @return The number of state variables
+	 */
+	virtual const unsigned int GetNState() const = 0;
+
+	/** @brief Get the number of state derivative variables
+	 * @return The number of state derivative variables
+	 */
+	virtual const unsigned int GetNDeriv() const = 0;
+
 	/** @brief Get the state variable
 	 * @param i The index of the state variable to take
 	 * @return The state variable
+	 * @{
 	 */
 	virtual moordyn::state::State GetState(unsigned int i = 0) = 0;
+	virtual moordyn::state::State* r(unsigned int i = 0) = 0;
+	/**
+	 * @}
+	 */
 
 	/** @brief Resume the simulation from the stationary solution
 	 * @param state The stationary solution
@@ -288,6 +303,17 @@ class Scheme : public io::IO
 	{
 	}
 
+	/** @brief Get the state derivative variable
+	 * @param i The index of the state derivative variable to take
+	 * @return The state derivative variable
+	 * @{
+	 */
+	virtual moordyn::state::State GetDeriv(unsigned int i = 0) = 0;
+	virtual moordyn::state::State* rd(unsigned int i = 0) = 0;
+	/**
+	 * @}
+	 */
+
   protected:
 	/** @brief Constructor
 	 * @param log Logging handler
@@ -623,6 +649,16 @@ class SchemeBase : public Scheme
 	 */
 	virtual void Step(real& dt) { Scheme::Step(dt); };
 
+	/** @brief Get the number of state variables
+	 * @return The number of state variables
+	 */
+	inline const unsigned int GetNState() const { return NSTATE; }
+
+	/** @brief Get the number of state derivative variables
+	 * @return The number of state derivative variables
+	 */
+	inline const unsigned int GetNDeriv() const { return NDERIV; }
+
 	/** @brief Get the state
 	 * @param i The index of the state variable to take
 	 * @return The state variable
@@ -720,6 +756,7 @@ class SchemeBase : public Scheme
 	 * @return The state derivative
 	 * @throws moordyn::invalid_value_error if the @p i index is greater or
 	 * equal than the number of state derivatives
+	 * @{
 	 */
 	inline state::State* rd(unsigned int i = 0)
 	{
@@ -732,6 +769,11 @@ class SchemeBase : public Scheme
 		return _rd[i];
 	}
 
+	inline state::State GetDeriv(unsigned int i = 0) { return *rd(i); }
+	/**
+	 * @}
+	 */
+
 	/** @brief Produce the packed data to be saved
 	 *
 	 * The produced data can be used afterwards to restore the saved information
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
@@ -55,6 +55,7 @@ set(CATCH2_TESTS
     midpoint
     aca
     wilson
+    line_break
 )
 
 function(make_executable test_name, extension)
diff --git a/tests/line_break.cpp b/tests/line_break.cpp
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2022 Jose Luis Cercos-Pita <jlc@core-marine.com>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @file minimal.cpp
+ * Minimal tests that only checks the library is correctly initialized,
+ * running and closing
+ */
+
+#include "MoorDyn2.h"
+#include <algorithm>
+#include <cmath>
+#include <catch2/catch_test_macros.hpp>
+
+// #define SAVE_VTK
+
+using namespace std;
+
+TEST_CASE("Breaker")
+{
+	MoorDyn system = MoorDyn_Create("Mooring/lines.txt");
+	REQUIRE(system);
+
+	unsigned int n_dof;
+	REQUIRE(MoorDyn_NCoupledDOF(system, &n_dof) == MOORDYN_SUCCESS);
+	REQUIRE(n_dof == 9);
+
+	int err;
+	double x[9], dx[9];
+	// Get the initial positions from the config file
+	for (unsigned int i = 0; i < 3; i++) {
+		// 4 = first fairlead id
+		auto point = MoorDyn_GetPoint(system, i + 4);
+		REQUIRE(point);
+		REQUIRE(MoorDyn_GetPointPos(point, x + 3 * i) == MOORDYN_SUCCESS);
+	}
+
+	auto point = MoorDyn_GetPoint(system, 4);
+	REQUIRE(point);
+	auto line = MoorDyn_GetLine(system, 1);
+	REQUIRE(line);
+
+	std::fill(dx, dx + 9, 0.0);
+	REQUIRE(MoorDyn_Init(system, x, dx) == MOORDYN_SUCCESS);
+#ifdef SAVE_VTK
+	REQUIRE(MoorDyn_SaveVTK(system, "line_break.000.vtm") == MOORDYN_SUCCESS);
+#endif
+	// Let's move the system at a 10.0m/s speed during 0.5 seconds
+	double f[9];
+	dx[0] = 10.0;
+	double t = 0.0, dt = 0.5;
+	REQUIRE(MoorDyn_Step(system, x, dx, f, &t, &dt) == MOORDYN_SUCCESS);
+#ifdef SAVE_VTK
+	REQUIRE(MoorDyn_SaveVTK(system, "line_break.001.vtm") == MOORDYN_SUCCESS);
+#endif
+	x[0] += dx[0] * dt;
+
+	// Break a line and repeat 3 times
+	REQUIRE(MoorDyn_BreakLine(system, point, line) == MOORDYN_SUCCESS);
+	REQUIRE(MoorDyn_Step(system, x, dx, f, &t, &dt) == MOORDYN_SUCCESS);
+#ifdef SAVE_VTK
+	REQUIRE(MoorDyn_SaveVTK(system, "line_break.002.vtm") == MOORDYN_SUCCESS);
+#endif
+	x[0] += dx[0] * dt;
+	REQUIRE(MoorDyn_Step(system, x, dx, f, &t, &dt) == MOORDYN_SUCCESS);
+#ifdef SAVE_VTK
+	REQUIRE(MoorDyn_SaveVTK(system, "line_break.003.vtm") == MOORDYN_SUCCESS);
+#endif
+	x[0] += dx[0] * dt;
+	REQUIRE(MoorDyn_Step(system, x, dx, f, &t, &dt) == MOORDYN_SUCCESS);
+#ifdef SAVE_VTK
+	REQUIRE(MoorDyn_SaveVTK(system, "line_break.004.vtm") == MOORDYN_SUCCESS);
+#endif
+	x[0] += dx[0] * dt;
+
+	REQUIRE(MoorDyn_Close(system) == MOORDYN_SUCCESS);
+}
diff --git a/wrappers/fortran/MoorDyn.f90 b/wrappers/fortran/MoorDyn.f90
diff --git a/wrappers/matlab/MoorDynM_BreakLine.cpp b/wrappers/matlab/MoorDynM_BreakLine.cpp
diff --git a/wrappers/python/cmoordyn.cpp b/wrappers/python/cmoordyn.cpp
diff --git a/wrappers/python/moordyn/moordyn.py b/wrappers/python/moordyn/moordyn.py

Original file line number	Diff line number	Diff line change
`@@ -55,6 +55,7 @@ set(CATCH2_TESTS`
`55`	`55`	`midpoint`
`56`	`56`	`aca`
`57`	`57`	`wilson`
	`58`	`+ line_break`
`58`	`59`	`)`
`59`	`60`
`60`	`61`	`function(make_executable test_name, extension)`