From 5192790ef9e43d3649662708497996c921f0164c Mon Sep 17 00:00:00 2001 From: Jae Hoon Seo Date: Sat, 14 Nov 2026 13:02:40 +0900 Subject: [PATCH 1/4] feat: a finite-EI line may end on a Free point (a free cable end) A finite-EI line could not end on a Free point: the single-cable route held both end positions and refused the point's loads, and with a Free point the deck went to the multibody march, which holds cable ends. A free-hanging cable or riser with a clump weight (forced-oscillation and tow tests of power cables, installation, a dropped line) had no deck. A Free point that ends exactly one finite-EI line as its End B, from a Coupled or Vessel End A, on a standalone deck whose lines are all finite-EI and that has no BODIES, RODS or other Connect/Free point, is now that line's free end: - the point's Mass, Vol, CdA and CA act on the End B node as an end attachment (weight and buoyancy, added mass, fluid inertia, drag); - the static solve holds the end first on the chord from End A towards the deck position, at the line's length stretched by its hanging weight (the taut seed; a vertical span of exactly the line's length has no catenary seed), then releases it with the attachment polish's warm-started Newton solve (new option release), so the run starts at the end's rest position; - the dynamics hold End A alone; - Point

p channels read the line's End B node. The line must be pinned in bending at both ends and the end net heavy; a torsion restraint at one end is noted and not solved. A deck in which any Free point is not such an end, and a host-driven deck, keeps its behaviour and its refusal messages. The Python deck reader takes the same rule. Checks (tests/test_free_end_deck.f90, a 7 m cable with a 200 kg clump): - still water: top tension = submerged weight to 1e-6 relative, the end one stretched length below the top to 1e-7 m, nothing moves; - 0.5 m/s current: the end rests where the EI = 0 route puts the same deck's Free point, within 2e-5 m at EI 3 N m^2 (0.134357 against 0.134353 m), converging as EI falls; - 0.05 m sway of the top at 0.05 Hz: the end follows in phase, the amplitude ratio within 1 % of the Rayleigh estimate (1.106 against 1.104); - a clamped end, a buoyant end and a second Free point keep their refusal messages; - python/tests/test_deck_native_parity.py: the reader and the driver agree on the accepted and refused decks. Signed-off-by: Jae Hoon Seo --- CHANGELOG.md | 8 + CMakeLists.txt | 3 + doc/capabilities.rst | 6 + doc/driver_format.md | 23 +- doc/theory.rst | 29 +++ python/cabledyn/deck_file.py | 98 ++++++++ python/tests/test_deck_native_parity.py | 83 ++++++- src/CableDyn_DeckDriver.f90 | 196 +++++++++++++++- tests/test_free_end_deck.f90 | 289 ++++++++++++++++++++++++ 9 files changed, 724 insertions(+), 11 deletions(-) create mode 100644 tests/test_free_end_deck.f90 diff --git a/CHANGELOG.md b/CHANGELOG.md index 1d5118d..4308e25 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,6 +10,14 @@ All notable changes to CableDyn are recorded in this file. The format follows ### Added +- A finite-EI line may end on a `Free` point: the line's free End B, its position free in the + static equilibrium and the dynamics, with the point's Mass/Vol/CdA/Ca acting on the end node as + an attachment (a free-hanging cable or riser with a clump). The static solve holds the end on + the stretched chord first and then releases it; `Point

p…` channels read the end node. + Standalone decks of finite-EI lines without bodies, rods or Connect points, every Free point + such an end (pinned in bending at both ends, net heavy, from a Coupled/Vessel End A; a torsion + restraint at one end is noted and not solved); any other deck, + and host-driven decks, keep their behaviour. The Python deck reader takes the same rule. - Bending damping of finite-EI cables: the LINE TYPES EI column takes `EI|Bb`, a Kelvin-Voigt damping moment `Bb` [N m^2 s] times the curvature rate (in the frame carried with the tangent), or `EI|-zeta|f`, the damping ratio of a pure bending mode of frequency `f` (Bb = zeta EI/(pi f)). diff --git a/CMakeLists.txt b/CMakeLists.txt index 8b2474f..24c5931 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1362,6 +1362,9 @@ set_tests_properties(viv_amplitude_deck PROPERTIES LABELS "fortran;integration;d add_executable(test_viv_diameter_deck tests/test_viv_diameter_deck.f90) target_link_libraries(test_viv_diameter_deck PRIVATE cabledyn_core) add_test(NAME viv_diameter_deck COMMAND test_viv_diameter_deck WORKING_DIRECTORY ${CMAKE_BINARY_DIR}) +add_executable(test_free_end_deck tests/test_free_end_deck.f90) +target_link_libraries(test_free_end_deck PRIVATE cabledyn_core) +add_test(NAME free_end_deck COMMAND test_free_end_deck WORKING_DIRECTORY ${CMAKE_BINARY_DIR}) set_tests_properties(viv_diameter_deck PROPERTIES LABELS "fortran;integration;dynamic;viv" TIMEOUT 1200) add_executable(test_hermite_viv tests/test_hermite_viv.f90) diff --git a/doc/capabilities.rst b/doc/capabilities.rst index 7bcb038..f1526d5 100644 --- a/doc/capabilities.rst +++ b/doc/capabilities.rst @@ -128,6 +128,12 @@ Line and constitutive capability - Supported - lumped at nodes of a finite-EI cable, standalone and coupled, also on a line restrained in torsion (they add no polar inertia to its twist) + * - Free end of a finite-EI cable (a ``Free`` End B) + - Supported with limits + - a free-hanging cable or riser with a clump or a bare end, its static rest position solved + before the march, on a standalone deck of finite-EI lines without bodies, rods or + Connect points, from a Coupled/Vessel End A; host-driven decks refuse it + (:ref:`theory-free-cable-end`) * - Bend stiffeners (``STIFFENERS``) - Supported with limits - tapered linear-elastic sleeve over a finite-EI line end, adding bending stiffness, mass, diff --git a/doc/driver_format.md b/doc/driver_format.md index 538fb97..e5913c5 100644 --- a/doc/driver_format.md +++ b/doc/driver_format.md @@ -727,7 +727,7 @@ A POINTS row has 9 columns, `ID Type X Y Z Mass Vol CdA Ca`, or the short 5-colu | `Body` | line end on body N; (X,Y,Z) is the attachment offset in the body frame | X,Y,Z offset; the body supplies Mass/Vol/CdA/Ca | | `RodA` / `RodB` | line end on rod N End A / End B; coordinates come from the `RODS` row | X,Y,Z placeholders; zero Mass/Vol/CdA/Ca | | `Connect` | free internal point where ≥ 2 lines meet; its static position is solved from force balance (lines, weight/buoyancy, current drag) starting at the deck seed, and the march starts there | X,Y,Z seed; Mass, Vol, CdA, Ca ≥ 0 | -| `Free` | free line end (clump or float terminal); a one-line `Connect`, solved the same way | X,Y,Z seed; Mass, Vol, CdA, Ca ≥ 0 | +| `Free` | free line end (clump or float terminal); a one-line `Connect`, solved the same way; as the End B of a finite-EI line, that line's free end ([below](#free-cable-end)) | X,Y,Z seed; Mass, Vol, CdA, Ca ≥ 0 | | `Turbine` / `T` | FAST.Farm coupled point on turbine J (turbine-local coordinates) | X,Y,Z; zero Mass/Vol/CdA/Ca | For dynamic `Connect`/`Free` points, `Mass` is inertial mass and `(rhoW·Vol − Mass)·g` is a @@ -742,6 +742,25 @@ of its BODY `Mass`/`Vol` (see the theory manual, Seabed contact). standalone driver. Non-zero `Mass`/`Vol`/`CdA`/`Ca` on `Fixed`, `Coupled`, `Vessel`, `Body`, `RodA/B`, or `Turbine` points is rejected. +(free-cable-end)= +**A free finite-EI cable end.** A `Free` point that ends exactly one finite-EI line, as its End B +with a `Coupled` or `Vessel` End A (a still hang-off is a `Coupled` point without motion), is that +line's free end on a standalone deck whose lines are all finite-EI and that has no BODIES, +RODS or other `Connect`/`Free` point (a free-hanging cable or riser with a clump or a bare end). +The point's `Mass`, `Vol`, `CdA` and `Ca` act on the line's End B node as an +[ATTACHMENTS](#attachments-optional-finite-ei-lines) row at the line's full arc length (weight +and buoyancy, added mass, and drag against current and waves). The static equilibrium is solved +with the end first held on the chord from End A towards the deck position, at the line's length +stretched by its hanging weight, then released, so the run starts at the end's rest position +(the theory manual, Free cable ends); the dynamics leave the end's position free. `Point

p…` +channels read the line's End B node. The line must be pinned in bending at both ends (no +non-pinned `END CONNECTIONS` row), with at most one end restrained in torsion, which is then not +solved (a free end carries no moment or torque; the initialisation note says why), and the point +and the line must be net heavy (the end hangs). A deck in which any `Free` point is not such an end +(a clamped or buoyant end, a second `Free` point, a `Connect` point), and a host-driven deck +(OpenFAST, the C API), is left as it was: the routes that take `Free` points run it or refuse a +finite-EI cable on a `Free` point by name. + `Turbine` points (J ≥ 1) need the turbine reference positions from one of two sources: the OpenFAST/FAST.Farm aggregate route, where the host supplies them, or a [TURBINES](#turbines-standalone-farm-decks) section, with which the standalone driver runs the @@ -789,6 +808,8 @@ rod end, and `Free`/`Connect`-to-`Coupled` lines are left as written. fails with `LINE End A fairlead (NodeA) must not be below End B anchor (NodeB)`. The exceptions are a FAST.Farm shared line with both ends on `Turbine` points and a finite-EI line whose End B is also a `Coupled`/`Vessel` point (a line between two moving points, driven at both ends). +- A finite-EI line may end on a `Free` point as its End B on a standalone deck of finite-EI lines + (its [free end](#free-cable-end)); that point does not count as a dynamic point. - In a deck with dynamic points, line ends may be `Fixed`, `Coupled`, `Vessel`, `Connect`, `Free`, `Body`, or `RodA/B`. diff --git a/doc/theory.rst b/doc/theory.rst index 97f6de3..02af585 100644 --- a/doc/theory.rst +++ b/doc/theory.rst @@ -229,6 +229,35 @@ as closely. The local value is floored at 0.1 % of the root curvature, as the cu sign near the tip. On the same hang-off, the curvature along the stiffener follows OrcaFlex 11.6d with its stiffener given as a line attachment within 0.5 % of the root curvature. +.. _theory-free-cable-end: + +Free cable ends +~~~~~~~~~~~~~~~ + +A finite-EI line whose End B is a ``Free`` point (:doc:`driver_format`) has that end's position +free: the dynamic march holds only End A's three positions, and the point's mass, volume, drag +area and added-mass coefficient act on the End B node as a discrete attachment (the weight +:math:`(M - \rho V)g`, the added mass :math:`C_a \rho V`, the fluid inertia and the drag of the +attachment law). The end carries no moment (it is pinned, a natural boundary condition of the +cubic-Hermite element) and no torque: the line is pinned in bending at both ends, and a torsion +restraint at its other end is not solved (it is noted, as for a line with two moving ends). + +The static equilibrium starts from a held seed: the end is placed on the chord from End A towards +the point's deck position, at the line's length stretched by its hanging weight, +:math:`L\,(1 + (W_B + \sum w_i L_i)/EA_{\min})`, so that the seed is the taut straight line (a +vertical span of exactly the line's length has no catenary seed). The line's static solve (with +its attachments' homotopy) runs with that end held; the end is then released and the full-load +equilibrium is solved again with its position free, by the attachment polish's warm-started +Newton solve with its fallbacks, repeated to the drag and surface fixed point. The run starts at +that rest position. The line and the point must be net heavy, so that the end hangs. + +On a 7 m cable (2.8 kg/m, EA 1e8 N) with a 200 kg clump the top tension is the submerged weight +of both to 1e-6 relative and the end hangs one stretched length below the top to 1e-7 m; in a +0.5 m/s current the end rests where the ``EI = 0`` route puts the same deck's ``Free`` point +(within 2e-5 m at EI 3 N m², and converging to it as EI falls); and a 0.05 m sway of the top at +0.05 Hz moves the end in phase with an amplitude ratio within 1 % of the Rayleigh estimate of the +hanging string with its end mass (``tests/test_free_end_deck.f90``). + .. _theory-output-recovery: Node tension, curvature and bend moment diff --git a/python/cabledyn/deck_file.py b/python/cabledyn/deck_file.py index 2e0aaa0..8615540 100644 --- a/python/cabledyn/deck_file.py +++ b/python/cabledyn/deck_file.py @@ -3720,6 +3720,93 @@ def validate(self) -> None: raise DeckFormatError(f"{exc}{_STATIC_CHECK_HINT}") from None raise + def _free_cable_ends( + self, + point_types: dict[str, str], + line_type_meta: dict[str, tuple[float, float, float, float]], + effective: Callable[[str, float], float], + ) -> set[str]: + """The Free points native promote_free_cable_ends makes free finite-EI cable ends.""" + if ( + self.caller_driven + or self._rows("BODIES") + or any(segments != 0 for _, segments in self._rod_rows_by_id().values()) + ): + return set() + sections: dict[str, list[tuple[str, float]]] = {} + ends: dict[str, tuple[str, str]] = {} + try: + for section in self._rows("SECTIONS"): + sections.setdefault(str(_native_int(section.tokens[0])), []).append( + (section.tokens[1].lower(), _native_float(section.tokens[2])) + ) + for row in self.lines: + line_key = str(_native_int(row.tokens[0])) + a_tok, b_tok = ( + (row.tokens[2], row.tokens[3]) if len(row.tokens) == 7 else row.tokens[1:3] + ) + ends[line_key] = (str(_native_int(a_tok)), str(_native_int(b_tok))) + if len(row.tokens) == 7: + sections[line_key] = [(row.tokens[1].lower(), _native_float(row.tokens[4]))] + except (ValueError, IndexError): + return set() + if not ends or not all( + any( + line_type_meta.get(name, (0.0, 0.0, 0.0, 0.0))[3] > 0.0 + for name, _ in sections.get(k, []) + ) + for k in ends + ): + return set() + # pinned in bending at both ends, at most one end restrained in torsion + clamped: set[str] = set() + twisted: dict[str, int] = {} + for row in self.end_connections: + with contextlib.suppress(ValueError, IndexError): + line_key = str(_native_int(row.tokens[0])) + if _strip_quotes(row.tokens[2]).lower() not in _PINNED_END_CONNECTIONS: + clamped.add(line_key) + if ( + len(row.tokens) >= 10 + and _strip_quotes(row.tokens[6]).lower() not in _FREE_TORSION_KEYWORDS + ): + twisted[line_key] = twisted.get(line_key, 0) + 1 + clamped |= {line_key for line_key, count in twisted.items() if count > 1} + rho_w, grav = effective("water_density", 1025.0), effective("gravity", 9.80665) + rows = {str(_native_int(row.tokens[0])): row for row in self.points} + promoted: set[str] = set() + for point_id, point_type in point_types.items(): + if point_type == "connect": + return set() + if point_type != "free": + continue + refs = [k for k, pair in ends.items() if point_id in pair] + if len(refs) != 1 or ends[refs[0]][1] != point_id: + return set() + line_key = refs[0] + if ( + point_types.get(ends[line_key][0], "") not in {"coupled", "vessel"} + or line_key in clamped + ): + return set() + if any(name not in line_type_meta for name, _ in sections.get(line_key, [])): + return set() + values = [_native_float(tok) for tok in rows[point_id].tokens[2:]] + mass, vol = (values[3], values[4]) if len(values) == 7 else (0.0, 0.0) + w_line = sum( + (line_type_meta[name][1] - rho_w * 0.25 * math.pi * line_type_meta[name][0] ** 2) + * grav + * length + for name, length in sections.get(line_key, []) + ) + w_point = (mass - rho_w * vol) * grav + if not (w_line + w_point > 0.0 and w_point >= 0.0): + return set() + if not any(line_type_meta[name][2] > 0.0 for name, _ in sections.get(line_key, [])): + return set() + promoted.add(point_id) + return promoted + def _validate(self) -> None: required = {"LINE TYPES", "POINTS", "LINES"} if not self._rows("LINES") and (self._rows("RODS") or self._rows("BODIES")): @@ -4383,6 +4470,15 @@ def end_key(token: str) -> str: f"z = -WtrDpth = {z_floor:.10g} m by more than the {tolerance:.2e} m " "seabed tolerance; place the anchor on (or above) the seabed" ) + # Native promote_free_cable_ends: a Free point that ends exactly one finite-EI line as its + # End B (from a Coupled/Vessel End A, pinned and free in torsion, net heavy), on a + # standalone deck of finite-EI lines with no BODIES, RODS or Connect point, is the line's + # free End B (its loads an end attachment) and reads Fixed from here on, when every Free + # point of the deck is such an end; otherwise the deck is left as it is. + free_cable_ends = self._free_cable_ends(point_types, line_type_meta, effective) + self._free_cable_end_points = free_cable_ends + for point_id in free_cable_ends: + point_types[point_id] = "fixed" has_dynamic_points = any( point_type in {"connect", "free"} or point_type.startswith(("body", "rod")) for point_type in point_types.values() @@ -6379,6 +6475,8 @@ def _check_torsion_lines( "its LINE TYPES rows give no GJ (the 14-column row; torsion has no " "EI/1.3 default)" ) + elif end_b in getattr(self, "_free_cable_end_points", set()): + note = "its End B is a free end (a Free point)" elif point_types[end_b] != "fixed": note = "it has two moving ends (torsion needs a Fixed End B)" elif dynamic and not force_blend: diff --git a/python/tests/test_deck_native_parity.py b/python/tests/test_deck_native_parity.py index 8cd8743..2305747 100644 --- a/python/tests/test_deck_native_parity.py +++ b/python/tests/test_deck_native_parity.py @@ -2141,7 +2141,8 @@ def test_torsion_scope_rules_follow_the_native_checks(): 'point; line 1 ends on a "free" point', ) # one restrained end only, or none, is ignored: the same verdict as the six-column rows (here - # the multibody march's, which ends no finite-EI cable on a Free point) + # both run: the Free End B is the line's free end, promote_free_cable_ends, and the one-end + # restraint is noted, not solved) one_end = _edit(_torsion_two_moving("1 A Pinned 1 0 0 Free 0 0 1 0\n"), _NO_TORSION_OUTPUTS) six = _edit( _torsion_two_moving("1 A Pinned 1 0 0\n"), @@ -2149,7 +2150,7 @@ def test_torsion_scope_rules_follow_the_native_checks(): _NO_TORSION_OUTPUTS, ) for deck in (six, one_end): - _rejects(deck, "a cable end on a Free/Connect point or a Point3 buoy") + DeckFile.from_text(deck) both_free = _edit( _TORSION, (_TORSION_ROW_A, "1 A Rigid 1 0 0 Free 0 0 1 0\n"), @@ -2985,3 +2986,81 @@ def test_dtm_bound_matches_the_driver(dt, accepted, ei, tmp_path): assert _accepted(deck) == accepted if not accepted: assert "dtM must be at least 1e-100 s" in completed.stderr + + +# ------------------------------------------------------------------ a free cable end + +_FREE_END_DECK = """--------------------- CableDyn Input File --------------------------------- +free cable end +----------------------- LINE TYPES ------------------------------------------ +TypeName Diam Mass EA BA EI Cd_n Cd_t Ca_n Ca_t +(-) (m) (kg/m) (N) (N-s) (N-m^2) (-) (-) (-) (-) +cable 0.048 2.8 1.0e8 0.0 3000 1.2 0.0 1.0 0.0 +----------------------- POINTS ---------------------------------------------- +ID Attachment X Y Z M V CdA CA +(-) (-) (m) (m) (m) (kg) (m^3) (m^2) (-) +1 Coupled 0.0 0.0 -0.5 0 0 0 0 +2 Free 0.0 0.0 -7.5 {clump} +{extra}----------------------- LINES ----------------------------------------------- +ID LineType AttachA AttachB UnstrLen NumSegs Outputs +(-) (-) (-) (-) (m) (-) (-) +1 cable 1 2 7.0 70 - +{endconn}---------------------- OPTIONS ---------------------------------------------- +1025 rhoW +9.80665 g +20 WtrDpth +0.005 dtM +0.1 TMax +---------------------- OUTPUTS ----------------------------------------------- +FairTen1 +Point2pz +END +------------------------- need this line -------------------------------------- +""" +_CLAMPED_B = ( + "--------------------- END CONNECTIONS ----------------------------------\n" + "LineID End Stiffness EzX EzY EzZ\n(-) (-) (N-m/rad) (-) (-) (-)\n1 B Rigid 0 0 1\n" +) + + +@pytest.mark.parametrize( + ("clump", "extra", "endconn", "message"), + [ + ("200 0.02548 0.06 1.0", "", "", None), + ("0 0 0 0", "", "", None), + ("200 0.02548 0.06 1.0", "", _CLAMPED_B, "non-pinned END CONNECTIONS need End B"), + ("10 0.5 0.06 1.0", "", "", "not supported on the multibody march"), + ( + "200 0.02548 0.06 1.0", + "3 Free 5.0 0.0 -5.0 10 0 0 0\n", + "", + "not supported on the multibody march", + ), + ], +) +def test_free_cable_end_matches_the_driver(clump, extra, endconn, message, tmp_path): + # a finite-EI line on a Free End B: the line's free end, the point's loads an end attachment + text = _FREE_END_DECK.format(clump=clump, extra=extra, endconn=endconn) + if message is None: + DeckFile.from_text(text) + else: + _rejects(text, message) + if not _PARITY_DRIVER or not Path(_PARITY_DRIVER).is_file(): + return + deck = tmp_path / "free_end.dat" + deck.write_text(text, encoding="utf-8") + completed = subprocess.run( + [_PARITY_DRIVER, str(deck), str(tmp_path / "free_end")], + capture_output=True, + text=True, + errors="replace", + cwd=tmp_path, + timeout=600, + env={**os.environ, "OMP_NUM_THREADS": "1", "OPENBLAS_NUM_THREADS": "1"}, + check=False, + ) + if message is None: + assert completed.returncode == 0, completed.stderr[-600:] + else: + assert completed.returncode == 1, completed.stderr[-600:] + assert message in completed.stderr diff --git a/src/CableDyn_DeckDriver.f90 b/src/CableDyn_DeckDriver.f90 index 372f8d0..709712c 100644 --- a/src/CableDyn_DeckDriver.f90 +++ b/src/CableDyn_DeckDriver.f90 @@ -499,6 +499,10 @@ MODULE CableDyn_DeckDriver ! the Body attachment of a Point3 BODY: stepped as a Free point with the BODY Mass/Vol/CdA/Ca ! (copied into mass, vol, cda, ca above), its seabed contact included LOGICAL :: point3 = .FALSE. + ! a Free point that ends exactly one finite-EI line (its End B) on a standalone deck of + ! finite-EI lines: the line's End B is free and the point's Mass/Volume/CdA/CA ride on it as + ! an end attachment (promote_free_cable_ends); ptype reads 'fixed' for the static seed only + LOGICAL :: free_cable_end = .FALSE. INTEGER :: deck_line = 0 ! deck file line of the row, for error messages END TYPE @@ -596,6 +600,9 @@ MODULE CableDyn_DeckDriver ! the deck's written NodeB (MoorDyn's AttachB) is then End A, otherwise End B. Active line ! control reads it for a line with no single host-driven end. LOGICAL :: ends_swapped = .FALSE. + ! End B on a Free point (promote_free_cable_ends): its position is free in the static + ! equilibrium and the dynamics, the point's loads acting as an end attachment + LOGICAL :: free_end_b = .FALSE. ! ATTACHMENTS (finite-EI lines): one column per discrete attachment -- arc length from ! End A [m], mass [kg], displaced volume [m^3], drag area CdA [m^2], added-mass Ca [-], ! axial drag area CdAx [m^2] (rows 1-6). @@ -3385,8 +3392,14 @@ RECURSIVE SUBROUTINE build_one_hermite_cable(ln, sections, types, points, opts, ! collapse of the endpoint tangent norm. Release the interior and tangent DOFs at ! dynamic hand-off; only the two endpoint translations remain constrained. The ! planar equilibrium is still an exact three-dimensional initial state by symmetry. - ALLOCATE (dynamic_fixed_dofs(6)) - dynamic_fixed_dofs = [1, 2, 3, ndof - 5, ndof - 4, ndof - 3] + IF (ln%free_end_b) THEN + ! a free End B (a Free point, promote_free_cable_ends): End A alone is held + ALLOCATE (dynamic_fixed_dofs(3)) + dynamic_fixed_dofs = [ndof - 5, ndof - 4, ndof - 3] + ELSE + ALLOCATE (dynamic_fixed_dofs(6)) + dynamic_fixed_dofs = [1, 2, 3, ndof - 5, ndof - 4, ndof - 3] + END IF IF (has_att) THEN w_bare = w_bare_deck IF (SIZE(l0) /= SIZE(l0_deck_att)) CALL remap_elem_by_reference_arc(w_bare, l0_deck_att, l0) @@ -3475,6 +3488,36 @@ RECURSIVE SUBROUTINE build_one_hermite_cable(ln, sections, types, points, opts, ' attachment(s) lumped at the nearest nodes (largest arc offset ', att_offset, ' m)' CALL report_note(note_text) END IF + IF (ln%free_end_b) THEN + ! The static solve held End B at the Free point's deck position (the seed); release it: the + ! full-load equilibrium with End B's position free, its loads the end attachment's (the + ! point's weight, buoyancy and current drag) and the line's own. + BLOCK + INTEGER, ALLOCATABLE :: fixed_rel(:), node_rel(:) + REAL(wp), ALLOCATABLE :: att_rel(:, :) + REAL(wp) :: rel_floor + fixed_rel = PACK(fixed_dofs, fixed_dofs > 3) + IF (has_att) THEN + node_rel = att_node + att_rel = ln%att + ELSE + ALLOCATE (node_rel(0), att_rel(6, 0)) + END IF + CALL attachment_static_polish(l0, ea, ei, w, w, diam, node_rel, att_rel, q_static, fixed_rel, & + contact_enabled, contact_z, frame_cs, endconn_k, endconn_d0_local, & + endconn_mode, opts, static_tol, ErrStat, ErrMsg, bathymetry, cur_obj, & + tol_floor=COUPLED_STATIC_TOL, floor_res=rel_floor, release=.TRUE.) + IF (ErrStat /= CD_DECKDRV_OK) THEN + ErrMsg = 'CableDyn_DeckDriver: line '//TRIM(int_to_str(ln%id))//': static equilibrium of the free '// & + 'End B (released from the Free point''s deck position): '//TRIM(ErrMsg) + RETURN + END IF + fixed_dofs = fixed_rel + WRITE (note_text, '(A,I0,A,3ES12.4,A)') 'line ', ln%id, ': free End B at rest at (', & + q_static(1:3), ') m in the line frame' + CALL report_note(note_text) + END BLOCK + END IF ! Dynamic step controls: the deck's dynamic_solver relative tolerance and iteration budget ! (default 1e-8 and 30) on every route, standalone or coupled, so that a cable driven by the ! same motion steps to the same state on each. The tolerance is not a coupling-force accuracy @@ -5729,7 +5772,7 @@ END SUBROUTINE smear_attachment_drag SUBROUTINE attachment_static_polish(l0, ea, ei, w_bare, w_smear, diam, node, att, q, fixed_dofs, & contact_enabled, contact_z, frame_cs, endconn_k, endconn_d0, endconn_mode, & opts, tol, ErrStat, ErrMsg, bathymetry, cur_obj, fell_back, cdn_bare, & - cdt_bare, tol_floor, floor_res) + cdt_bare, tol_floor, floor_res, release) !! Homotopy from the smeared-attachment equilibrium q to the discrete one: in warm-started !! Newton solves the element weights move from w_smear to w_bare while the lumped nodal !! forces -(m - rho V) g e_z (-m g e_z for an attachment above the still-water level, @@ -5771,6 +5814,9 @@ SUBROUTINE attachment_static_polish(l0, ea, ei, w_bare, w_smear, diam, node, att !! the next update rule, as the line's own static solve accepts a floor at the coupled static !! tolerance; floor_res (optional out) is the relative residual of the returned state when it !! lies above tol, and 0 otherwise. + !! release (optional, default false) skips the homotopy: q is an equilibrium of the full loads + !! with more DOFs held than fixed_dofs holds (a free end seeded held), and the full-load solve + !! runs at once, at least once, then to the fixed point as above. REAL(wp), INTENT(IN) :: l0(:), ea(:), ei(:), w_bare(:), w_smear(:), diam(:), att(:, :) INTEGER, INTENT(IN) :: node(:), fixed_dofs(:), endconn_mode(2) REAL(wp), INTENT(INOUT) :: q(:) @@ -5784,6 +5830,7 @@ SUBROUTINE attachment_static_polish(l0, ea, ei, w_bare, w_smear, diam, node, att LOGICAL, INTENT(OUT), OPTIONAL :: fell_back REAL(wp), INTENT(IN), OPTIONAL :: cdn_bare(:), cdt_bare(:), tol_floor REAL(wp), INTENT(OUT), OPTIONAL :: floor_res + LOGICAL, INTENT(IN), OPTIONAL :: release INTEGER, PARAMETER :: NSTEP = 8, MAX_FIXED_POINT = 60 ! the update rules of a solve (solve_with, static_solve) INTEGER, PARAMETER :: NEWTON = 1, PSEUDO_TRANSIENT = 2, MERIT = 3 @@ -5797,7 +5844,7 @@ SUBROUTINE attachment_static_polish(l0, ea, ei, w_bare, w_smear, diam, node, att REAL(wp), ALLOCATABLE :: f_att(:), f_drag(:), dry(:), knnode(:), wl(:), q_out(:), curv(:) REAL(wp) :: lam, lam_done, dlam, res, change INTEGER :: i, ne, fp, n_failed, n_ok, grow_after - LOGICAL :: has_drag, converged, newton_failed, grown + LOGICAL :: has_drag, converged, newton_failed, grown, release_ ! which attachments are above the still-water level: in the state the last solve took its ! loads at, and in the state it returned LOGICAL, ALLOCATABLE :: att_dry(:), att_dry_now(:) @@ -5855,6 +5902,10 @@ SUBROUTINE attachment_static_polish(l0, ea, ei, w_bare, w_smear, diam, node, att n_ok = 0 grow_after = 2 grown = .FALSE. + release_ = .FALSE. + IF (PRESENT(release)) release_ = release + IF (release_) lam_done = CD_ONE + wl = w_bare ! the full-load weights (the homotopy sets its own per step) DO WHILE (lam_done < CD_ONE) lam = MIN(CD_ONE, lam_done + dlam) wl = w_bare + (CD_ONE - lam)*(w_smear - w_bare) @@ -5902,7 +5953,7 @@ SUBROUTINE attachment_static_polish(l0, ea, ei, w_bare, w_smear, diam, node, att ! the weight of the other side: the full-load solve is repeated (below) until none does. A ! line below the surface (or wholly above it) without attachment drag is done. CALL attachment_static_weight(q, node, att, opts, f_att, att_dry_now) - IF (.NOT. has_drag .AND. ALL(att_dry_now .EQV. att_dry)) RETURN + IF (.NOT. release_ .AND. .NOT. has_drag .AND. ALL(att_dry_now .EQV. att_dry)) RETURN DO fp = 1, MAX_FIXED_POINT CALL solve_with(CD_ONE, converged, change) IF (ErrStat /= CD_DECKDRV_OK) RETURN @@ -14403,6 +14454,7 @@ SUBROUTINE parse_deck(path, types, bodies, rod_types, rods, points, lines, secti END IF END DO CALL normalize_stock_endpoint_order(points, lines, sections, types) + CALL promote_free_cable_ends(points, lines, sections, types, opts, SIZE(bodies), SIZE(rods), ext_march) tors_marched = ext_march IF (PRESENT(static_run)) tors_marched = ext_march .AND. .NOT. static_run ! A static check marches no step, so it needs no dtM: on the routes no caller marches @@ -19309,6 +19361,114 @@ LOGICAL FUNCTION finite_ei_by_name(line_id) RESULT(fin) END FUNCTION finite_ei_by_name END SUBROUTINE normalize_stock_endpoint_order + SUBROUTINE promote_free_cable_ends(points, lines, sections, types, opts, n_bodies, n_rods, caller_driven) + !! A Free point that ends exactly one finite-EI line, as its End B, from a Coupled or Vessel + !! End A, on a standalone deck whose lines are all finite-EI and that has no other dynamic + !! object (BODIES, RODS, other Free/Connect points), becomes the line's free End B: the line's + !! End B position is free in the static equilibrium and the dynamics, and the point's Mass, + !! Volume, CdA and CA ride on it as an end attachment (ATTACHMENTS at the line's full arc + !! length). The line must be pinned in bending at both ends with at most one end restrained in + !! torsion, which is then not solved (a free end carries no moment or torque), and the end must + !! hang (the point and the line net heavy). The point's type reads 'fixed' from here + !! on, so the builder seeds the static solve with the end held, then releases it + !! (build_one_hermite_cable): the seed is on the chord from End A towards the deck position, at + !! the line's length stretched by its hanging weight (the taut straight line; a vertical span of + !! exactly the line's length has no catenary seed). A deck with any Free point that is not such + !! an end is left as it is, to the routes that take Free points or refuse them by name. + TYPE(DeckPoint), INTENT(INOUT) :: points(:) + TYPE(DeckLine), INTENT(INOUT) :: lines(:) + TYPE(DeckSection), INTENT(IN) :: sections(:) + TYPE(DeckLineType), INTENT(IN) :: types(:) + TYPE(DeckOptions), INTENT(IN) :: opts + INTEGER, INTENT(IN) :: n_bodies, n_rods + LOGICAL, INTENT(IN) :: caller_driven + INTEGER :: ip, j, nref, jl, ia, k, it + INTEGER :: cand_line(SIZE(points)) + REAL(wp) :: seed(3, SIZE(points)), arc, wline, wpt, ea_min, chord(3), cl + REAL(wp), ALLOCATABLE :: att_new(:, :) + IF (caller_driven .OR. n_bodies > 0 .OR. n_rods > 0 .OR. SIZE(lines) < 1) RETURN + DO j = 1, SIZE(lines) + IF (.NOT. finite_ei_line(lines(j)%id)) RETURN + END DO + cand_line = 0 + DO ip = 1, SIZE(points) + IF (TRIM(points(ip)%ptype) == 'connect') RETURN + IF (TRIM(points(ip)%ptype) /= 'free') CYCLE + nref = 0 + jl = 0 + DO j = 1, SIZE(lines) + IF (lines(j)%nodeA == points(ip)%id .OR. lines(j)%nodeB == points(ip)%id) THEN + nref = nref + 1 + jl = j + END IF + END DO + IF (nref /= 1) RETURN + IF (lines(jl)%nodeB /= points(ip)%id) RETURN + ia = find_point(points, lines(jl)%nodeA) + IF (ia < 1) RETURN + ! End A must be the driven (or still) fairlead of a deck without dynamic points + IF (TRIM(points(ia)%ptype) /= 'coupled' .AND. TRIM(points(ia)%ptype) /= 'vessel') RETURN + ! pinned in bending at both ends; a torsion restraint at one end is not solved (a free end + ! carries no torque; resolve_one_end_torsion notes it), at both ends the deck is left as it is + IF (ANY(lines(jl)%endconn_mode /= CD_ENDCONN_PINNED) .OR. COUNT(lines(jl)%tors_mode /= TORS_FREE) > 1) RETURN + ! the hanging weight (line and point, in water) and the softest section + wline = CD_ZERO + ea_min = HUGE(CD_ONE) + arc = CD_ZERO + DO k = 1, SIZE(sections) + IF (sections(k)%line_id /= lines(jl)%id) CYCLE + it = find_type(types, sections(k)%ltype_name) + IF (it < 1) RETURN + wline = wline + (types(it)%mass - opts%rhoW*QUARTER_PI*types(it)%diam**2)*opts%g*sections(k)%length + IF (types(it)%ea > CD_ZERO) ea_min = MIN(ea_min, types(it)%ea) + arc = arc + sections(k)%length + END DO + wpt = (points(ip)%mass - opts%rhoW*points(ip)%vol)*opts%g + IF (.NOT. (wline + wpt > CD_ZERO .AND. wpt >= CD_ZERO) .OR. .NOT. ea_min < HUGE(CD_ONE)) RETURN + chord = points(ip)%pos - points(ia)%pos + cl = NORM2(chord) + IF (cl > CD_ZERO) THEN + chord = chord/cl + ELSE + chord = [CD_ZERO, CD_ZERO, -CD_ONE] + END IF + seed(:, ip) = points(ia)%pos + chord*arc*(CD_ONE + (wline + wpt)/ea_min + 1.0e-9_wp) + cand_line(ip) = jl + END DO + ! every Free point of the deck is a free cable end: promote them + DO ip = 1, SIZE(points) + jl = cand_line(ip) + IF (jl < 1) CYCLE + points(ip)%pos = seed(:, ip) + points(ip)%free_cable_end = .TRUE. + points(ip)%ptype = 'fixed' + lines(jl)%free_end_b = .TRUE. + IF (points(ip)%mass > CD_ZERO .OR. points(ip)%vol > CD_ZERO .OR. points(ip)%cda > CD_ZERO) THEN + arc = SUM(sections%length, MASK=sections%line_id == lines(jl)%id) + IF (ALLOCATED(lines(jl)%att)) THEN + ALLOCATE (att_new(6, SIZE(lines(jl)%att, 2) + 1)) + att_new(:, 1:SIZE(lines(jl)%att, 2)) = lines(jl)%att + ELSE + ALLOCATE (att_new(6, 1)) + END IF + att_new(:, SIZE(att_new, 2)) = [arc, points(ip)%mass, points(ip)%vol, points(ip)%cda, points(ip)%ca, CD_ZERO] + CALL MOVE_ALLOC(att_new, lines(jl)%att) + END IF + END DO + CONTAINS + LOGICAL FUNCTION finite_ei_line(line_id) RESULT(fin) + INTEGER, INTENT(IN) :: line_id + INTEGER :: kk, itt + fin = .FALSE. + DO kk = 1, SIZE(sections) + IF (sections(kk)%line_id /= line_id) CYCLE + itt = find_type(types, sections(kk)%ltype_name) + IF (itt < 1) CYCLE + IF (types(itt)%ei > CD_ZERO) fin = .TRUE. + END DO + END FUNCTION finite_ei_line + END SUBROUTINE promote_free_cable_ends + SUBROUTINE reverse_line_sections(sections, line_id) !! Reverse the in-deck order of the SECTIONS rows belonging to one line (their !! positions in the global array are kept; only the payloads swap). @@ -20045,9 +20205,11 @@ SUBROUTINE finalize_checks(types, bodies, rod_types, rods, points, lines, sectio CASE ('fixed', 'coupled', 'vessel') ! Mass/Vol/CdA/Ca (clump weight, buoyancy, drag area, added mass) apply only to ! Connect/Free points; non-zero values on a held point would be silently ignored, - ! so fail closed rather than solve as if they were zero. - IF (ABS(points(i)%mass) > CD_ZERO .OR. ABS(points(i)%vol) > CD_ZERO .OR. & - ABS(points(i)%cda) > CD_ZERO .OR. ABS(points(i)%ca) > CD_ZERO) THEN + ! so fail closed rather than solve as if they were zero. (A free cable end keeps its Free + ! point's columns: they act as its end attachment, promote_free_cable_ends.) + IF ((ABS(points(i)%mass) > CD_ZERO .OR. ABS(points(i)%vol) > CD_ZERO .OR. & + ABS(points(i)%cda) > CD_ZERO .OR. ABS(points(i)%ca) > CD_ZERO) .AND. & + .NOT. points(i)%free_cable_end) THEN CALL fail(ErrStat, ErrMsg, 'POINT '//'(Fixed/Coupled/Vessel) must not carry '// & 'Mass/Vol/CdA/Ca load columns (those apply to Connect/Free points)'); RETURN END IF @@ -33892,6 +34054,22 @@ SUBROUTINE write_hermite_model_row(unit, time, channels, lines, points, cables, CALL fail(ErrStat, ErrMsg, 'Hermite motion OUTPUT is missing its point'); RETURN END IF val = motion%q(comp, mi, motion_time_index) + ELSE IF (points(pp)%free_cable_end) THEN + ! a free cable end (promote_free_cable_ends): the End B node of its line + BLOCK + INTEGER :: lf + CHARACTER(NAMELEN) :: chf + CHARACTER(3), PARAMETER :: AXES = 'xyz' + DO lf = 1, SIZE(lines) + IF (lines(lf)%free_end_b .AND. lines(lf)%nodeB == pidx) EXIT + END DO + IF (lf > SIZE(lines)) THEN + CALL fail(ErrStat, ErrMsg, 'Hermite Point OUTPUT: free cable end without its line'); RETURN + END IF + WRITE (chf, '(A,I0,A,I0,A)') 'L', lines(lf)%id, 'N', cables(lf)%line%nn, 'p'//AXES(comp:comp) + CALL eval_cable_channel(cables(lf), chf, val, ErrStat, ErrMsg, mesh_node=.TRUE.) + IF (ErrStat /= CD_DECKDRV_OK) RETURN + END BLOCK ELSE val = points(pp)%pos(comp) END IF @@ -41187,6 +41365,8 @@ SUBROUTINE resolve_one_end_torsion(types, bodies, rods, points, lines, sections, why = 'its LINE TYPES rows give no GJ (the 14-column row; torsion has no EI/1.3 default)' ELSE IF (j < 1) THEN why = 'its End B point is undefined' + ELSE IF (points(j)%free_cable_end) THEN + why = 'its End B is a free end (a Free point)' ELSE IF (TRIM(points(j)%ptype) /= 'fixed') THEN why = 'it has two moving ends (torsion needs a Fixed End B)' ELSE IF (.NOT. opts%alpha_force_blend .AND. (caller_driven .OR. (opts%has_tmax .AND. opts%tmax > CD_ZERO))) THEN diff --git a/tests/test_free_end_deck.f90 b/tests/test_free_end_deck.f90 new file mode 100644 index 0000000..4848571 --- /dev/null +++ b/tests/test_free_end_deck.f90 @@ -0,0 +1,289 @@ +! File: tests/test_free_end_deck.f90 +! SPDX-License-Identifier: Apache-2.0 +! Copyright (c) 2026 Jae Hoon Seo, SMI Lab, Inha University +PROGRAM test_free_end_deck + !! A finite-EI line ending on a Free point (a free end): a 7 m cable (Diam 0.048 m, 2.8 kg/m, + !! EA 1e8 N) hanging from a Coupled point at z = -0.5 m with a 200 kg clump (0.02548 m^3, CdA + !! 0.06 m^2, CA 1) on its Free End B, 70 elements: + !! F1 in still water the run holds the static state: the top tension is the submerged weight of + !! the line and the clump (to 1e-6 relative), the end hangs one stretched line length below + !! the top (the stretch (W_B L + w L^2/2)/EA, to 1e-7 m), and nothing moves over the run; + !! F2 in a 0.5 m/s current along x the end rests where the same deck as an EI = 0 line on the + !! point-system route puts its Free point (EI 3 N m^2: within 2e-5 m), and the Point + !! channels of the free end read its line's End B node; + !! F3 a prescribed 0.05 m sway of the top at 0.05 Hz moves the end in phase with an amplitude + !! ratio within 1 % of the Rayleigh estimate for a hanging string with a heavy end mass + !! (1.104: the end mass with its added mass, a third of the line's, the mean tension); + !! F4 a Free point that is not such an end leaves the deck as it was, refused by the routes' + !! own messages: a clamped End B, a net-buoyant end, a second Free point. + USE CableDyn_Precision, ONLY: wp + USE CableDyn_DeckDriver, ONLY: CD_Run_Deck_Driver, CD_DECKDRV_OK + IMPLICIT NONE + REAL(wp), PARAMETER :: PI = 3.14159265358979323846_wp, G = 9.80665_wp, RHO = 1025.0_wp + REAL(wp), PARAMETER :: L = 7.0_wp, D = 0.048_wp, M = 2.8_wp, EA = 1.0e8_wp + REAL(wp), PARAMETER :: MB = 200.0_wp, VB = 0.02548_wp + INTEGER :: nfail = 0 + + CALL check_still() + CALL check_current() + CALL check_sway() + CALL check_refusals() + IF (nfail > 0) THEN + WRITE (*, '(A,I0,A)') 'FAIL: ', nfail, ' assertion(s) failed' + ERROR STOP 1 + END IF + WRITE (*, '(A)') 'PASS: free cable end deck gates' + +CONTAINS + + SUBROUTINE require(cond, label) + LOGICAL, INTENT(IN) :: cond + CHARACTER(*), INTENT(IN) :: label + IF (cond) RETURN + nfail = nfail + 1 + WRITE (*, '(A)') 'FAIL: '//TRIM(label) + END SUBROUTINE require + + SUBROUTINE write_profile(path, u) + CHARACTER(*), INTENT(IN) :: path + REAL(wp), INTENT(IN) :: u + INTEGER :: k + OPEN (NEWUNIT=k, FILE=path, STATUS='REPLACE', ACTION='WRITE') + WRITE (k, '(A)') 'z ux uy uz' + WRITE (k, '(A)') '(m) (m/s) (m/s) (m/s)' + WRITE (k, '(A,F6.3,A)') '-20 ', u, ' 0 0' + WRITE (k, '(A,F6.3,A)') '0 ', u, ' 0 0' + CLOSE (k) + END SUBROUTINE write_profile + + SUBROUTINE write_deck(path, ei, pt2, extra_pts, endconn, opts_extra, outs, dt, tmax) + !! ei: the type's EI; pt2: the Free point row of End B (after 'ID'); extra_pts: more POINTS rows + !! (';'-separated, '' for none); endconn: an END CONNECTIONS data row ('' for none); + !! opts_extra: more OPTIONS rows (';'-separated); outs: OUTPUTS channels (';'-separated). + CHARACTER(*), INTENT(IN) :: path, ei, pt2, extra_pts, endconn, opts_extra, outs + REAL(wp), INTENT(IN) :: dt, tmax + INTEGER :: u + OPEN (NEWUNIT=u, FILE=path, STATUS='REPLACE', ACTION='WRITE') + WRITE (u, '(A)') '--------------------- CableDyn Input File ---------------------------------' + WRITE (u, '(A)') 'free cable end gate' + WRITE (u, '(A)') '----------------------- LINE TYPES ------------------------------------------' + WRITE (u, '(A)') 'TypeName Diam Mass EA BA EI Cd_n Cd_t Ca_n Ca_t' + WRITE (u, '(A)') '(-) (m) (kg/m) (N) (N-s) (N-m^2) (-) (-) (-) (-)' + WRITE (u, '(A)') 'cable 0.048 2.8 1.0e8 0.0 '//ei//' 1.2 0.0 1.0 0.0' + WRITE (u, '(A)') '----------------------- POINTS ----------------------------------------------' + WRITE (u, '(A)') 'ID Attachment X Y Z M V CdA CA' + WRITE (u, '(A)') '(-) (-) (m) (m) (m) (kg) (m^3) (m^2) (-)' + WRITE (u, '(A)') '1 Coupled 0.0 0.0 -0.5 0 0 0 0' + WRITE (u, '(A)') '2 '//pt2 + CALL put_rows(u, extra_pts) + WRITE (u, '(A)') '----------------------- LINES -----------------------------------------------' + WRITE (u, '(A)') 'ID LineType AttachA AttachB UnstrLen NumSegs Outputs' + WRITE (u, '(A)') '(-) (-) (-) (-) (m) (-) (-)' + WRITE (u, '(A)') '1 cable 1 2 7.0 70 -' + IF (LEN_TRIM(endconn) > 0) THEN + WRITE (u, '(A)') '--------------------- END CONNECTIONS ----------------------------------' + WRITE (u, '(A)') 'LineID End Stiffness EzX EzY EzZ' + WRITE (u, '(A)') '(-) (-) (N-m/rad) (-) (-) (-)' + WRITE (u, '(A)') endconn + END IF + WRITE (u, '(A)') '---------------------- OPTIONS ----------------------------------------------' + WRITE (u, '(A)') '1025 rhoW' + WRITE (u, '(A)') '9.80665 g' + WRITE (u, '(A)') '20 WtrDpth' + WRITE (u, '(ES12.5,A)') dt, ' dtM' + WRITE (u, '(ES12.5,A)') tmax, ' TMax' + CALL put_rows(u, opts_extra) + WRITE (u, '(A)') '---------------------- OUTPUTS -----------------------------------------------' + CALL put_rows(u, outs) + WRITE (u, '(A)') 'END' + WRITE (u, '(A)') '------------------------- need this line --------------------------------------' + CLOSE (u) + END SUBROUTINE write_deck + + SUBROUTINE put_rows(u, rows) + INTEGER, INTENT(IN) :: u + CHARACTER(*), INTENT(IN) :: rows + INTEGER :: i0, i1 + i0 = 1 + DO WHILE (i0 <= LEN_TRIM(rows)) + i1 = INDEX(rows(i0:), ';') + IF (i1 == 0) THEN + WRITE (u, '(A)') TRIM(rows(i0:)) + EXIT + END IF + WRITE (u, '(A)') rows(i0:i0 + i1 - 2) + i0 = i0 + i1 + END DO + END SUBROUTINE put_rows + + SUBROUTINE run(deck, root, ok, msg) + CHARACTER(*), INTENT(IN) :: deck, root + LOGICAL, INTENT(OUT) :: ok + CHARACTER(*), INTENT(OUT) :: msg + LOGICAL :: conv + INTEGER :: es + CALL CD_Run_Deck_Driver(deck, root, conv, es, msg) + ok = es == CD_DECKDRV_OK + END SUBROUTINE run + + SUBROUTINE read_out(path, ncol, tab, n) + CHARACTER(*), INTENT(IN) :: path + INTEGER, INTENT(IN) :: ncol + REAL(wp), ALLOCATABLE, INTENT(OUT) :: tab(:, :) + INTEGER, INTENT(OUT) :: n + CHARACTER(2048) :: rec + INTEGER :: u, ios + ALLOCATE (tab(ncol, 20000)) + n = 0 + OPEN (NEWUNIT=u, FILE=path, STATUS='OLD', ACTION='READ', IOSTAT=ios) + IF (ios /= 0) RETURN + READ (u, '(A)') rec + READ (u, '(A)') rec + DO + READ (u, '(A)', IOSTAT=ios) rec + IF (ios /= 0) EXIT + IF (LEN_TRIM(rec) == 0) CYCLE + IF (n == SIZE(tab, 2)) EXIT + n = n + 1 + READ (rec, *) tab(:, n) + END DO + CLOSE (u) + END SUBROUTINE read_out + + SUBROUTINE check_still() + REAL(wp), ALLOCATABLE :: tab(:, :) + REAL(wp) :: w, wb, stretch + INTEGER :: n + LOGICAL :: ok + CHARACTER(1024) :: msg + CALL write_deck('fed_still.dat', '3000', 'Free 0.0 0.0 -7.5 200 0.02548 0.06 1.0', '', '', '', & + 'FairTen1;Point2px;Point2pz', 0.005_wp, 2.0_wp) + CALL run('fed_still.dat', 'fed_still', ok, msg) + CALL require(ok, 'F1 still-water run: '//TRIM(msg)) + IF (.NOT. ok) RETURN + CALL read_out('fed_still.out', 4, tab, n) + CALL require(n > 10, 'F1 output rows') + IF (n <= 10) RETURN + w = (M - RHO*0.25_wp*PI*D**2)*G + wb = (MB - RHO*VB)*G + stretch = (wb*L + 0.5_wp*w*L**2)/EA + CALL require(ABS(tab(2, 1)/(w*L + wb) - 1.0_wp) < 1.0e-6_wp, 'F1 top tension = submerged weight') + CALL require(ABS(tab(4, 1) - (-0.5_wp - L - stretch)) < 1.0e-7_wp, 'F1 end one stretched length below') + CALL require(MAXVAL(ABS(tab(3:4, 1:n) - SPREAD(tab(3:4, 1), 2, n))) < 1.0e-10_wp, 'F1 nothing moves') + END SUBROUTINE check_still + + SUBROUTINE check_current() + REAL(wp), ALLOCATABLE :: tf(:, :), t0(:, :) + INTEGER :: nf, n0 + LOGICAL :: ok + CHARACTER(1024) :: msg + CALL write_profile('current_profile.txt', 0.5_wp) + CALL write_deck('fed_cur.dat', '3', 'Free 0.0 0.0 -7.5 200 0.02548 0.06 1.0', '', '', '1 Currents', & + 'Point2px;Con2pz;L1N71px;L1N71pz', 0.005_wp, 0.5_wp) + CALL run('fed_cur.dat', 'fed_cur', ok, msg) + CALL require(ok, 'F2 finite-EI free end in current: '//TRIM(msg)) + CALL write_deck('fed_cur0.dat', '0', 'Free 0.0 0.0 -7.5 200 0.02548 0.06 1.0', '', '', '1 Currents', & + 'Point2px;Point2pz', 0.005_wp, 0.5_wp) + CALL run('fed_cur0.dat', 'fed_cur0', ok, msg) + CALL require(ok, 'F2 EI = 0 Free point in current: '//TRIM(msg)) + CALL read_out('fed_cur.out', 5, tf, nf) + CALL read_out('fed_cur0.out', 3, t0, n0) + IF (nf < 1 .OR. n0 < 1) THEN + CALL require(.FALSE., 'F2 output rows') + RETURN + END IF + CALL require(ABS(tf(2, 1) - t0(2, 1)) < 2.0e-5_wp .AND. ABS(tf(3, 1) - t0(3, 1)) < 2.0e-5_wp, & + 'F2 rest position = the EI = 0 Free point''s') + CALL require(tf(2, 1) > 0.1_wp, 'F2 the end is carried downstream') + CALL require(ABS(tf(2, nf) - tf(4, nf)) < 1.0e-12_wp .AND. ABS(tf(3, nf) - tf(5, nf)) < 1.0e-12_wp, & + 'F2 Point channels read the End B node') + END SUBROUTINE check_current + + SUBROUTINE check_sway() + REAL(wp), PARAMETER :: A = 0.05_wp, F = 0.05_wp, DT = 0.01_wp, TMAX = 120.0_wp, TR = 20.0_wp + REAL(wp), ALLOCATABLE :: tab(:, :) + REAL(wp) :: t, r, dr, ddr, om, s, c, ata(3, 3), atb(3), coef(3), w, wb, ma, tmean, om2, ratio + INTEGER :: u, k, n, i + LOGICAL :: ok + CHARACTER(1024) :: msg + om = 2.0_wp*PI*F + OPEN (NEWUNIT=u, FILE='fed_motion.txt', STATUS='REPLACE', ACTION='WRITE') + WRITE (u, '(A)') '# time point x y z vx vy vz ax ay az' + DO k = 0, NINT(TMAX/DT) + t = REAL(k, wp)*DT + IF (t < TR) THEN + r = 0.5_wp*(1.0_wp - COS(PI*t/TR)) + dr = 0.5_wp*PI/TR*SIN(PI*t/TR) + ddr = 0.5_wp*(PI/TR)**2*COS(PI*t/TR) + ELSE + r = 1.0_wp; dr = 0.0_wp; ddr = 0.0_wp + END IF + s = SIN(om*t); c = COS(om*t) + WRITE (u, '(F12.6,A,3ES17.9,A,ES17.9,A,ES17.9,A)') t, ' 1', A*r*s, 0.0_wp, -0.5_wp, ' ', & + A*(dr*s + r*om*c), ' 0 0 ', A*(ddr*s + 2.0_wp*dr*om*c - r*om*om*s), ' 0 0' + END DO + CLOSE (u) + CALL write_deck('fed_sway.dat', '3000', 'Free 0.0 0.0 -7.5 200 0.02548 0.06 1.0', '', '', & + 'fed_motion.txt motionFile', 'Point2px', DT, TMAX) + CALL run('fed_sway.dat', 'fed_sway', ok, msg) + CALL require(ok, 'F3 prescribed sway: '//TRIM(msg)) + IF (.NOT. ok) RETURN + CALL read_out('fed_sway.out', 2, tab, n) + ata = 0.0_wp; atb = 0.0_wp + DO i = 1, n + IF (tab(1, i) < 40.0_wp) CYCLE + coef = [SIN(om*tab(1, i)), COS(om*tab(1, i)), 1.0_wp] + ata = ata + SPREAD(coef, 2, 3)*SPREAD(coef, 1, 3) + atb = atb + coef*tab(2, i) + END DO + CALL solve3(ata, atb, coef) + ! Rayleigh estimate, shape s/L from the top: omega_p^2 = (mean tension / L)/(end mass with + ! added mass + a third of the line's mass with added mass) + w = (M - RHO*0.25_wp*PI*D**2)*G + wb = (MB - RHO*VB)*G + tmean = wb + 0.5_wp*w*L + ma = (MB + RHO*VB) + (M + RHO*0.25_wp*PI*D**2)*L/3.0_wp + om2 = (tmean/L)/ma + ratio = 1.0_wp/(1.0_wp - om**2/om2) + CALL require(ABS(HYPOT(coef(1), coef(2))/A/ratio - 1.0_wp) < 0.01_wp, 'F3 sway amplitude ratio') + CALL require(ABS(coef(2)) < 0.05_wp*ABS(coef(1)) .AND. coef(1) > 0.0_wp, 'F3 the end moves in phase') + END SUBROUTINE check_sway + + SUBROUTINE solve3(a, b, x) + REAL(wp), INTENT(IN) :: a(3, 3), b(3) + REAL(wp), INTENT(OUT) :: x(3) + REAL(wp) :: m(3, 4), f + INTEGER :: i, j + m(:, 1:3) = a + m(:, 4) = b + DO i = 1, 3 + DO j = i + 1, 3 + f = m(j, i)/m(i, i) + m(j, :) = m(j, :) - f*m(i, :) + END DO + END DO + DO i = 3, 1, -1 + x(i) = (m(i, 4) - SUM(m(i, i + 1:3)*x(i + 1:3)))/m(i, i) + END DO + END SUBROUTINE solve3 + + SUBROUTINE check_refusals() + LOGICAL :: ok + CHARACTER(1024) :: msg + CALL write_deck('fed_r1.dat', '3000', 'Free 0.0 0.0 -7.5 200 0.02548 0.06 1.0', '', '1 B Rigid 0 0 -1', '', & + 'FairTen1', 0.005_wp, 0.1_wp) + CALL run('fed_r1.dat', 'fed_r1', ok, msg) + CALL require(.NOT. ok .AND. INDEX(msg, 'non-pinned END CONNECTIONS need End B') > 0, & + 'F4 clamped End B refused: '//TRIM(msg)) + CALL write_deck('fed_r2.dat', '3000', 'Free 0.0 0.0 -7.5 10 0.5 0.06 1.0', '', '', '', 'FairTen1', & + 0.005_wp, 0.1_wp) + CALL run('fed_r2.dat', 'fed_r2', ok, msg) + CALL require(.NOT. ok .AND. INDEX(msg, 'not supported on the multibody march') > 0, & + 'F4 net-buoyant end refused: '//TRIM(msg)) + CALL write_deck('fed_r3.dat', '3000', 'Free 0.0 0.0 -7.5 200 0.02548 0.06 1.0', & + '3 Free 5.0 0.0 -5.0 10 0 0 0', '', '', 'FairTen1', 0.005_wp, 0.1_wp) + CALL run('fed_r3.dat', 'fed_r3', ok, msg) + CALL require(.NOT. ok .AND. INDEX(msg, 'not supported on the multibody march') > 0, & + 'F4 a second Free point refused: '//TRIM(msg)) + END SUBROUTINE check_refusals +END PROGRAM test_free_end_deck From b846a313445d0414538c95359ad06398bf4a28ee Mon Sep 17 00:00:00 2001 From: Jae Hoon Seo Date: Sat, 14 Nov 2026 14:53:03 +0900 Subject: [PATCH 2/4] fix: a free cable end's seed is not a seabed anchor Review: the promoted point reads Fixed, so a stretched chord seed below a flat seabed was refused by the anchor seabed check before the free end's equilibrium was solved, although the seed is only a starting position (a line longer than the depth whose end the current lifts clear of the seabed). - check_fixed_point_above_seabed skips a free cable end. - On a flat seabed a seed below the seabed is placed on it at the same stretched length, out along the deck chord's horizontal direction, so the held seed is still the taut straight line. - An end whose point is net heavy and that comes to rest on the seabed is refused by name: an attachment has no seabed contact of its own on a finite-EI line, so the point would sink into the line's contact (a 200 kg clump on a 6 m deep seabed came to rest 0.8 m below it). A bare end rests on the line's own contact. - A bathymetry deck keeps its behaviour (no promotion), as the seed is placed against the flat seabed only; the Python reader mirrors it. tests/test_free_end_deck.f90 F5: a 5 kg end in a 0.8 m/s current over a 7.3 m deep seabed (the vertical seed 7.5 m) rests 1.2 m above it, 4.19 m downstream; the 200 kg clump on a 6 m deep seabed is refused by name. Signed-off-by: Jae Hoon Seo --- doc/driver_format.md | 7 +++++-- doc/theory.rst | 6 +++++- python/cabledyn/deck_file.py | 1 + src/CableDyn_DeckDriver.f90 | 34 ++++++++++++++++++++++++++++++++++ tests/test_free_end_deck.f90 | 29 ++++++++++++++++++++++++++++- 5 files changed, 73 insertions(+), 4 deletions(-) diff --git a/doc/driver_format.md b/doc/driver_format.md index e5913c5..dab3879 100644 --- a/doc/driver_format.md +++ b/doc/driver_format.md @@ -758,8 +758,11 @@ non-pinned `END CONNECTIONS` row), with at most one end restrained in torsion, w solved (a free end carries no moment or torque; the initialisation note says why), and the point and the line must be net heavy (the end hangs). A deck in which any `Free` point is not such an end (a clamped or buoyant end, a second `Free` point, a `Connect` point), and a host-driven deck -(OpenFAST, the C API), is left as it was: the routes that take `Free` points run it or refuse a -finite-EI cable on a `Free` point by name. +(OpenFAST, the C API) or a `bathymetryFile` deck, is left as it was: the routes that take `Free` +points run it or refuse a finite-EI cable on a `Free` point by name. On a flat seabed a seed below +the seabed is placed on it at the same stretched length; an end that comes to rest on the seabed +with a net-heavy point is refused by name (the point has no seabed contact of its own on a +finite-EI line), while a bare end rests on the line's own contact. `Turbine` points (J ≥ 1) need the turbine reference positions from one of two sources: the OpenFAST/FAST.Farm aggregate route, where the host supplies them, or a diff --git a/doc/theory.rst b/doc/theory.rst index 02af585..c59a192 100644 --- a/doc/theory.rst +++ b/doc/theory.rst @@ -249,7 +249,11 @@ vertical span of exactly the line's length has no catenary seed). The line's sta its attachments' homotopy) runs with that end held; the end is then released and the full-load equilibrium is solved again with its position free, by the attachment polish's warm-started Newton solve with its fallbacks, repeated to the drag and surface fixed point. The run starts at -that rest position. The line and the point must be net heavy, so that the end hangs. +that rest position. The line and the point must be net heavy, so that the end hangs. On a flat +seabed a seed that would lie below the seabed (a line longer than the depth below End A) is placed +on the seabed at the same stretched length, out along the deck chord's horizontal direction; an end +whose point is net heavy and that comes to rest on the seabed is refused, since an attachment has no +seabed contact of its own on a finite-EI line (a bare end rests on the line's contact). On a 7 m cable (2.8 kg/m, EA 1e8 N) with a 200 kg clump the top tension is the submerged weight of both to 1e-6 relative and the end hangs one stretched length below the top to 1e-7 m; in a diff --git a/python/cabledyn/deck_file.py b/python/cabledyn/deck_file.py index 8615540..b5fac1b 100644 --- a/python/cabledyn/deck_file.py +++ b/python/cabledyn/deck_file.py @@ -3731,6 +3731,7 @@ def _free_cable_ends( self.caller_driven or self._rows("BODIES") or any(segments != 0 for _, segments in self._rod_rows_by_id().values()) + or any(_option_key(option.keyword) == "bathymetry" for option in self.options) ): return set() sections: dict[str, list[tuple[str, float]]] = {} diff --git a/src/CableDyn_DeckDriver.f90 b/src/CableDyn_DeckDriver.f90 index 709712c..ddee1de 100644 --- a/src/CableDyn_DeckDriver.f90 +++ b/src/CableDyn_DeckDriver.f90 @@ -3513,6 +3513,15 @@ RECURSIVE SUBROUTINE build_one_hermite_cable(ln, sections, types, points, opts, RETURN END IF fixed_dofs = fixed_rel + ! a net-heavy point at a free end that comes to rest on the seabed would sink into the line's + ! contact (an attachment has no seabed contact of its own): refused by name + IF (contact_enabled .AND. q_static(3) <= contact_z) THEN + IF (ANY(node_rel == 1 .AND. att_rel(2, :) - opts%rhoW*att_rel(3, :) > CD_ZERO)) THEN + CALL fail(ErrStat, ErrMsg, 'line '//TRIM(int_to_str(ln%id))//': the free End B comes to rest on '// & + 'the seabed with the net weight of its Free point, which has no seabed contact of its '// & + 'own on a finite-EI line; shorten the line, or end it on a Fixed point there'); RETURN + END IF + END IF WRITE (note_text, '(A,I0,A,3ES12.4,A)') 'line ', ln%id, ': free End B at rest at (', & q_static(1:3), ') m in the line frame' CALL report_note(note_text) @@ -19387,6 +19396,8 @@ SUBROUTINE promote_free_cable_ends(points, lines, sections, types, opts, n_bodie REAL(wp) :: seed(3, SIZE(points)), arc, wline, wpt, ea_min, chord(3), cl REAL(wp), ALLOCATABLE :: att_new(:, :) IF (caller_driven .OR. n_bodies > 0 .OR. n_rods > 0 .OR. SIZE(lines) < 1) RETURN + ! (a bathymetry deck keeps its behaviour: the seed is placed against the flat seabed only) + IF (opts%has_bathymetry_file) RETURN DO j = 1, SIZE(lines) IF (.NOT. finite_ei_line(lines(j)%id)) RETURN END DO @@ -19433,6 +19444,27 @@ SUBROUTINE promote_free_cable_ends(points, lines, sections, types, opts, n_bodie chord = [CD_ZERO, CD_ZERO, -CD_ONE] END IF seed(:, ip) = points(ia)%pos + chord*arc*(CD_ONE + (wline + wpt)/ea_min + 1.0e-9_wp) + ! a seed below a flat seabed (a line longer than the depth below End A) goes onto the seabed at + ! the same stretched length, out along the deck chord's horizontal direction (+x without one), + ! so the held seed is still the taut straight line; the release lays the end on the seabed + IF (opts%has_wtrdpth .AND. .NOT. opts%has_bathymetry_file) THEN + IF (seed(3, ip) < -opts%wtrdpth) THEN + BLOCK + REAL(wp) :: dlen, dz, hz(2), hn + dlen = NORM2(seed(:, ip) - points(ia)%pos) + dz = -opts%wtrdpth - points(ia)%pos(3) + hz = points(ip)%pos(1:2) - points(ia)%pos(1:2) + hn = NORM2(hz) + IF (hn > CD_ZERO) THEN + hz = hz/hn + ELSE + hz = [CD_ONE, CD_ZERO] + END IF + seed(1:2, ip) = points(ia)%pos(1:2) + hz*SQRT(MAX(dlen**2 - dz**2, CD_ZERO)) + seed(3, ip) = -opts%wtrdpth + END BLOCK + END IF + END IF cand_line(ip) = jl END DO ! every Free point of the deck is a free cable end: promote them @@ -19513,6 +19545,8 @@ SUBROUTINE check_fixed_point_above_seabed(pt, z_floor, what, ErrStat, ErrMsg, z_ REAL(wp) :: tol ErrStat = 0; ErrMsg = '' + ! a free cable end's position is a static seed, not an anchor (promote_free_cable_ends) + IF (pt%free_cable_end) RETURN tol = CD_Static_Anchor_Seabed_Tolerance(z_floor) ! (a relative round-off margin keeps an anchor written exactly one tolerance off inside) IF (ABS(pt%pos(3) - z_floor) <= tol*(CD_ONE + 1.0e-9_wp)) THEN diff --git a/tests/test_free_end_deck.f90 b/tests/test_free_end_deck.f90 index 4848571..5e20c56 100644 --- a/tests/test_free_end_deck.f90 +++ b/tests/test_free_end_deck.f90 @@ -14,6 +14,10 @@ PROGRAM test_free_end_deck !! F3 a prescribed 0.05 m sway of the top at 0.05 Hz moves the end in phase with an amplitude !! ratio within 1 % of the Rayleigh estimate for a hanging string with a heavy end mass !! (1.104: the end mass with its added mass, a third of the line's, the mean tension); + !! F5 on a flat seabed above which the vertical seed would lie (7.3 m deep, the line 7 m from + !! z = -0.5 m), a 5 kg end in a 0.8 m/s current rests above the seabed (the seed is placed on + !! it, the release lifts the end), and the 200 kg clump, which comes to rest on the seabed + !! (6 m deep), is refused by name (a Free point has no seabed contact on a finite-EI line); !! F4 a Free point that is not such an end leaves the deck as it was, refused by the routes' !! own messages: a clamped End B, a net-buoyant end, a second Free point. USE CableDyn_Precision, ONLY: wp @@ -28,6 +32,7 @@ PROGRAM test_free_end_deck CALL check_current() CALL check_sway() CALL check_refusals() + CALL check_seabed() IF (nfail > 0) THEN WRITE (*, '(A,I0,A)') 'FAIL: ', nfail, ' assertion(s) failed' ERROR STOP 1 @@ -89,7 +94,7 @@ SUBROUTINE write_deck(path, ei, pt2, extra_pts, endconn, opts_extra, outs, dt, t WRITE (u, '(A)') '---------------------- OPTIONS ----------------------------------------------' WRITE (u, '(A)') '1025 rhoW' WRITE (u, '(A)') '9.80665 g' - WRITE (u, '(A)') '20 WtrDpth' + IF (INDEX(opts_extra, 'WtrDpth') == 0) WRITE (u, '(A)') '20 WtrDpth' WRITE (u, '(ES12.5,A)') dt, ' dtM' WRITE (u, '(ES12.5,A)') tmax, ' TMax' CALL put_rows(u, opts_extra) @@ -267,6 +272,28 @@ SUBROUTINE solve3(a, b, x) END DO END SUBROUTINE solve3 + SUBROUTINE check_seabed() + REAL(wp), ALLOCATABLE :: tab(:, :) + INTEGER :: n + LOGICAL :: ok + CHARACTER(1024) :: msg + CALL write_profile('current_profile.txt', 0.8_wp) + CALL write_deck('fed_lift.dat', '3000', 'Free 0.0 0.0 -7.5 5 0.000637 0.01 1.0', '', '', & + '1 Currents;7.3 WtrDpth', 'Point2px;Point2pz', 0.005_wp, 0.2_wp) + CALL run('fed_lift.dat', 'fed_lift', ok, msg) + CALL require(ok, 'F5 a seed below the seabed, the end at rest above it: '//TRIM(msg)) + IF (ok) THEN + CALL read_out('fed_lift.out', 3, tab, n) + IF (n > 0) CALL require(tab(3, n) > -7.3_wp + 0.5_wp .AND. tab(2, n) > 1.0_wp, 'F5 the end lifted and carried') + END IF + CALL write_profile('current_profile.txt', 0.5_wp) + CALL write_deck('fed_ground.dat', '3000', 'Free 0.0 0.0 -7.5 200 0.02548 0.06 1.0', '', '', & + '1 Currents;6.0 WtrDpth', 'FairTen1', 0.005_wp, 0.1_wp) + CALL run('fed_ground.dat', 'fed_ground', ok, msg) + CALL require(.NOT. ok .AND. INDEX(msg, 'comes to rest on the seabed') > 0, & + 'F5 a clump at rest on the seabed refused: '//TRIM(msg)) + END SUBROUTINE check_seabed + SUBROUTINE check_refusals() LOGICAL :: ok CHARACTER(1024) :: msg From 5fe0a11386111e43ca3ea422cf4fae2fc0e67b74 Mon Sep 17 00:00:00 2001 From: Jae Hoon Seo Date: Sat, 14 Nov 2026 15:54:09 +0900 Subject: [PATCH 3/4] fix: a free cable end keeps the Free point's isotropic drag Review: - The promoted end attachment applied the point's CdA to the normal relative velocity only (CdAx 0), while a Free point's drag acts on the whole relative velocity (point_environment_force): a hanging clump in heave or axial flow lost its drag, and oblique flow drag differed. - The Python reader counted a numeric zero END CONNECTIONS stiffness (0, 0.0) as a restraint, where the native reader maps it to pinned (bending) and free (torsion), so it refused decks the driver accepts. The attachment drag kernel takes an optional isotropic flag, the point's law rho CdA |w| w / 2 with its exact Jacobian (no tangent dependence); CD_HermiteCable_Dyn_Set_Attachments and CD_HFMF_Set_Attachments carry it per attachment, and the deck static drag uses it too. The promoted attachment marks it internally (CdAx -1, which a deck row cannot give); the smeared continuation start takes CdAx = CdA. The Python check reads a numeric zero as pinned or free. tests/test_free_end_deck.f90 F6: in a vertical 0.5 m/s current along the hanging line the top tension grows by the clump's rho CdA w^2 / 2 = 7.69 N (to 1e-3 N). The parity test accepts a numeric zero End B stiffness on both sides. Signed-off-by: Jae Hoon Seo --- doc/driver_format.md | 3 +- doc/theory.rst | 5 ++- python/cabledyn/deck_file.py | 20 +++++++--- python/tests/test_deck_native_parity.py | 6 +++ src/CableDyn_DeckDriver.f90 | 15 ++++--- src/CableDyn_HermiteCableDynamic.f90 | 53 +++++++++++++++++++++---- src/CableDyn_OpenFAST_HermiteFMF.f90 | 6 ++- tests/test_free_end_deck.f90 | 28 +++++++++++++ 8 files changed, 113 insertions(+), 23 deletions(-) diff --git a/doc/driver_format.md b/doc/driver_format.md index dab3879..d30975c 100644 --- a/doc/driver_format.md +++ b/doc/driver_format.md @@ -749,7 +749,8 @@ line's free end on a standalone deck whose lines are all finite-EI and that has RODS or other `Connect`/`Free` point (a free-hanging cable or riser with a clump or a bare end). The point's `Mass`, `Vol`, `CdA` and `Ca` act on the line's End B node as an [ATTACHMENTS](#attachments-optional-finite-ei-lines) row at the line's full arc length (weight -and buoyancy, added mass, and drag against current and waves). The static equilibrium is solved +and buoyancy, added mass, and drag against current and waves), with the point's isotropic drag +`½ rhoW CdA ‖w‖ w` on the whole relative velocity rather than the attachment's normal/axial split. The static equilibrium is solved with the end first held on the chord from End A towards the deck position, at the line's length stretched by its hanging weight, then released, so the run starts at the end's rest position (the theory manual, Free cable ends); the dynamics leave the end's position free. `Point

p…` diff --git a/doc/theory.rst b/doc/theory.rst index c59a192..7c80563 100644 --- a/doc/theory.rst +++ b/doc/theory.rst @@ -237,8 +237,9 @@ Free cable ends A finite-EI line whose End B is a ``Free`` point (:doc:`driver_format`) has that end's position free: the dynamic march holds only End A's three positions, and the point's mass, volume, drag area and added-mass coefficient act on the End B node as a discrete attachment (the weight -:math:`(M - \rho V)g`, the added mass :math:`C_a \rho V`, the fluid inertia and the drag of the -attachment law). The end carries no moment (it is pinned, a natural boundary condition of the +:math:`(M - \rho V)g`, the added mass :math:`C_a \rho V`, the fluid inertia), with the point's +isotropic drag :math:`\tfrac12 \rho\, C_dA\, |\mathbf w|\,\mathbf w` on the whole relative velocity, +as a ``Free`` point carries it, rather than the attachment's normal/axial split. The end carries no moment (it is pinned, a natural boundary condition of the cubic-Hermite element) and no torque: the line is pinned in bending at both ends, and a torsion restraint at its other end is not solved (it is noted, as for a line with two moving ends). diff --git a/python/cabledyn/deck_file.py b/python/cabledyn/deck_file.py index b5fac1b..b59704e 100644 --- a/python/cabledyn/deck_file.py +++ b/python/cabledyn/deck_file.py @@ -3759,18 +3759,26 @@ def _free_cable_ends( for k in ends ): return set() - # pinned in bending at both ends, at most one end restrained in torsion + + # pinned in bending at both ends, at most one end restrained in torsion; a numeric zero + # stiffness is pinned / free, as native append_end_connection reads it + def zero_or(token: str, keywords: frozenset[str]) -> bool: + word = _strip_quotes(token).lower() + if word in keywords: + return True + try: + return _native_float(word) == 0.0 + except ValueError: + return False + clamped: set[str] = set() twisted: dict[str, int] = {} for row in self.end_connections: with contextlib.suppress(ValueError, IndexError): line_key = str(_native_int(row.tokens[0])) - if _strip_quotes(row.tokens[2]).lower() not in _PINNED_END_CONNECTIONS: + if not zero_or(row.tokens[2], _PINNED_END_CONNECTIONS): clamped.add(line_key) - if ( - len(row.tokens) >= 10 - and _strip_quotes(row.tokens[6]).lower() not in _FREE_TORSION_KEYWORDS - ): + if len(row.tokens) >= 10 and not zero_or(row.tokens[6], _FREE_TORSION_KEYWORDS): twisted[line_key] = twisted.get(line_key, 0) + 1 clamped |= {line_key for line_key, count in twisted.items() if count > 1} rho_w, grav = effective("water_density", 1025.0), effective("gravity", 9.80665) diff --git a/python/tests/test_deck_native_parity.py b/python/tests/test_deck_native_parity.py index 2305747..47bfe11 100644 --- a/python/tests/test_deck_native_parity.py +++ b/python/tests/test_deck_native_parity.py @@ -3028,6 +3028,12 @@ def test_dtm_bound_matches_the_driver(dt, accepted, ei, tmp_path): [ ("200 0.02548 0.06 1.0", "", "", None), ("0 0 0 0", "", "", None), + ( + "200 0.02548 0.06 1.0", + "", + _CLAMPED_B.replace("1 B Rigid 0 0 1", "1 B 0.0 0 0 1"), + None, + ), ("200 0.02548 0.06 1.0", "", _CLAMPED_B, "non-pinned END CONNECTIONS need End B"), ("10 0.5 0.06 1.0", "", "", "not supported on the multibody march"), ( diff --git a/src/CableDyn_DeckDriver.f90 b/src/CableDyn_DeckDriver.f90 index ddee1de..d039463 100644 --- a/src/CableDyn_DeckDriver.f90 +++ b/src/CableDyn_DeckDriver.f90 @@ -3741,8 +3741,9 @@ RECURSIVE SUBROUTINE build_one_hermite_cable(ln, sections, types, points, opts, CALL fail(ErrStat, ErrMsg, 'finite-EI cable added-mass wiring failed: '//TRIM(em)); RETURN END IF IF (has_att) THEN - CALL CD_HFMF_Set_Attachments(cable, att_node, ln%att(2, :), ln%att(3, :), ln%att(4, :), ln%att(6, :), & - ln%att(5, :), opts%rhoW, opts%g, es, em) + CALL CD_HFMF_Set_Attachments(cable, att_node, ln%att(2, :), ln%att(3, :), ln%att(4, :), & + MAX(ln%att(6, :), CD_ZERO), ln%att(5, :), opts%rhoW, opts%g, es, em, & + isotropic=ln%att(6, :) < CD_ZERO) IF (es /= CD_HFMF_OK) THEN CALL fail(ErrStat, ErrMsg, 'finite-EI cable attachment wiring failed: '//TRIM(em)); RETURN END IF @@ -5774,7 +5775,8 @@ SUBROUTINE add_share(e, share) INTEGER, INTENT(IN) :: e REAL(wp), INTENT(IN) :: share cdn(e) = cdn(e) + share*att(4, k)/(diam(e)*l0(e)) - cdt(e) = cdt(e) + share*att(6, k)/(4.0_wp*QUARTER_PI*diam(e)*l0(e)) + ! (a point's isotropic drag, CdAx < 0, smears with CdAx = CdA for the continuation start) + cdt(e) = cdt(e) + share*MERGE(att(4, k), att(6, k), att(6, k) < CD_ZERO)/(4.0_wp*QUARTER_PI*diam(e)*l0(e)) END SUBROUTINE add_share END SUBROUTINE smear_attachment_drag @@ -6131,7 +6133,8 @@ SUBROUTINE attachment_static_drag(q, node, att, opts, frame_cs, f, ErrStat, ErrM CALL fail(ErrStat, ErrMsg, TRIM(em)); RETURN END IF ul = [frame_cs(1)*ug(1) + frame_cs(2)*ug(2), -frame_cs(2)*ug(1) + frame_cs(1)*ug(2), ug(3)] - CALL CD_HermiteCable_Attachment_Drag(ul, q(base + 4:base + 6), opts%rhoW, att(4, k), att(6, k), fd, es, em) + CALL CD_HermiteCable_Attachment_Drag(ul, q(base + 4:base + 6), opts%rhoW, att(4, k), MAX(att(6, k), CD_ZERO), & + fd, es, em, isotropic=att(6, k) < CD_ZERO) IF (es /= CD_HCDYN_OK) THEN CALL fail(ErrStat, ErrMsg, TRIM(em)); RETURN END IF @@ -19483,7 +19486,9 @@ SUBROUTINE promote_free_cable_ends(points, lines, sections, types, opts, n_bodie ELSE ALLOCATE (att_new(6, 1)) END IF - att_new(:, SIZE(att_new, 2)) = [arc, points(ip)%mass, points(ip)%vol, points(ip)%cda, points(ip)%ca, CD_ZERO] + ! CdAx -1: the internal marker of a point's isotropic drag rho CdA |w| w / 2 (a deck + ! ATTACHMENTS row cannot give a negative CdAx) + att_new(:, SIZE(att_new, 2)) = [arc, points(ip)%mass, points(ip)%vol, points(ip)%cda, points(ip)%ca, -CD_ONE] CALL MOVE_ALLOC(att_new, lines(jl)%att) END IF END DO diff --git a/src/CableDyn_HermiteCableDynamic.f90 b/src/CableDyn_HermiteCableDynamic.f90 index 1bb731e..cda9256 100644 --- a/src/CableDyn_HermiteCableDynamic.f90 +++ b/src/CableDyn_HermiteCableDynamic.f90 @@ -506,6 +506,8 @@ MODULE CableDyn_HermiteCableDynamic LOGICAL :: a_restored = .FALSE. INTEGER, ALLOCATABLE :: att_node(:) REAL(wp), ALLOCATABLE :: att_w(:), att_b(:), att_fk(:), att_cda(:), att_cdax(:) + ! a point's isotropic drag (a Free point ending the line) in place of the normal/axial split + LOGICAL, ALLOCATABLE :: att_iso(:) ! The two nodal mass terms each attachment adds to Mgb, the dry mass m and the added mass ! Ca rho V, kept so that a length change rebuilds Mgb in the order initialisation used. REAL(wp), ALLOCATABLE :: att_mass(:), att_madd(:) @@ -2218,7 +2220,7 @@ END SUBROUTINE fail_fr END SUBROUTINE CD_HermiteCable_Dyn_Set_Friction_Anchors SUBROUTINE CD_HermiteCable_Dyn_Set_Attachments(model, node, mass, volume, cda, cdax, ca, rho_w, gravity, & - ErrStat, ErrMsg) + ErrStat, ErrMsg, isotropic) !! Install discrete point attachments (clumps, buoyancy modules) lumped at nodes. Each !! carries its weight and buoyancy (m - rho V) g downward, isotropic added mass !! Ca rho V (with the dry mass m, a constant nodal mass on the translational DOFs), the @@ -2229,12 +2231,15 @@ SUBROUTINE CD_HermiteCable_Dyn_Set_Attachments(model, node, mass, volume, cda, c !! surface an attachment loses its buoyancy and fluid loads. Called once, after Init and !! never together with internal waves; the initial acceleration is refreshed. The !! kinetic energy (CD_HermiteCable_Dyn_Energy) then includes the attachment mass and its - !! added mass Ca rho V. + !! added mass Ca rho V. isotropic (optional, default false) makes an attachment's drag a + !! point's, rho CdA |w| w / 2 on the whole relative velocity (CdAx unused), as a Free point + !! that ends the line carries it. TYPE(CD_HermiteCableDynType), INTENT(INOUT) :: model INTEGER, INTENT(IN) :: node(:) REAL(wp), INTENT(IN) :: mass(:), volume(:), cda(:), cdax(:), ca(:), rho_w, gravity INTEGER, INTENT(OUT) :: ErrStat CHARACTER(*), INTENT(OUT) :: ErrMsg + LOGICAL, INTENT(IN), OPTIONAL :: isotropic(:) INTEGER :: n, k, d, dof, es REAL(wp), ALLOCATABLE :: a_old(:), mgb_old(:, :) CHARACTER(1024) :: em @@ -2259,6 +2264,13 @@ SUBROUTINE CD_HermiteCable_Dyn_Set_Attachments(model, node, mass, volume, cda, c ErrMsg = 'CD_HermiteCable_Dyn_Set_Attachments: node/mass/volume/cda/ca must share one length >= 1' RETURN END IF + IF (PRESENT(isotropic)) THEN + IF (SIZE(isotropic) /= n) THEN + ErrStat = CD_HCDYN_BADINPUT + ErrMsg = 'CD_HermiteCable_Dyn_Set_Attachments: isotropic must have one entry per attachment' + RETURN + END IF + END IF IF (ANY(node < 1) .OR. ANY(node > model%nn)) THEN ErrStat = CD_HCDYN_BADINPUT; ErrMsg = 'CD_HermiteCable_Dyn_Set_Attachments: node out of range'; RETURN END IF @@ -2279,7 +2291,9 @@ SUBROUTINE CD_HermiteCable_Dyn_Set_Attachments(model, node, mass, volume, cda, c a_old = model%a mgb_old = model%Mgb ALLOCATE (model%att_node(n), model%att_w(n), model%att_b(n), model%att_fk(n), model%att_cda(n), & - model%att_cdax(n), model%att_mass(n), model%att_madd(n)) + model%att_cdax(n), model%att_mass(n), model%att_madd(n), model%att_iso(n)) + model%att_iso = .FALSE. + IF (PRESENT(isotropic)) model%att_iso = isotropic model%att_node = node model%att_w = (mass - rho_w*volume)*gravity model%att_b = rho_w*gravity*volume @@ -2299,7 +2313,7 @@ SUBROUTINE CD_HermiteCable_Dyn_Set_Attachments(model, node, mass, volume, cda, c CALL solve_consistent_acceleration(model, es, em) IF (es /= CD_HCDYN_OK) THEN DEALLOCATE (model%att_node, model%att_w, model%att_b, model%att_fk, model%att_cda, model%att_cdax, & - model%att_mass, model%att_madd) + model%att_mass, model%att_madd, model%att_iso) model%has_attach = .FALSE. model%Mgb = mgb_old model%a = a_old @@ -2309,17 +2323,40 @@ SUBROUTINE CD_HermiteCable_Dyn_Set_Attachments(model, node, mass, volume, cda, c END SUBROUTINE CD_HermiteCable_Dyn_Set_Attachments SUBROUTINE CD_HermiteCable_Attachment_Drag(rel_velocity, tangent, rho, cda, cdax, force, ErrStat, ErrMsg, & - jac_rel, jac_tan) + jac_rel, jac_tan, isotropic) !! Quadratic drag of a line attachment: f = rho [CdA |w_n| w_n + CdAx |w_t| w_t] / 2 with !! w the relative fluid velocity split normal and axial to the line tangent (any non-zero !! vector; normalised internally). Optional Jacobians d f/d w and d f/d tangent, as a pair. !! Shared by the dynamic residual and the deck static solve, so both use one law. + !! isotropic (optional, default false): a point's drag f = rho CdA |w| w / 2 on the whole + !! relative velocity (CdAx unused; d f/d tangent = 0), the law of a Free point. REAL(wp), INTENT(IN) :: rel_velocity(3), tangent(3), rho, cda, cdax REAL(wp), INTENT(OUT) :: force(3) INTEGER, INTENT(OUT) :: ErrStat CHARACTER(*), INTENT(OUT) :: ErrMsg REAL(wp), INTENT(OUT), OPTIONAL :: jac_rel(3, 3), jac_tan(3, 3) + LOGICAL, INTENT(IN), OPTIONAL :: isotropic REAL(wp), PARAMETER :: PI_A = 3.14159265358979323846_wp + REAL(wp) :: wn + INTEGER :: i + IF (PRESENT(isotropic)) THEN + IF (isotropic) THEN + ErrStat = CD_HCDYN_OK; ErrMsg = '' + wn = NORM2(rel_velocity) + force = 0.5_wp*rho*cda*wn*rel_velocity + IF (PRESENT(jac_rel) .AND. PRESENT(jac_tan)) THEN + jac_tan = CD_ZERO + jac_rel = CD_ZERO + IF (wn > CD_ZERO) THEN + jac_rel = 0.5_wp*rho*cda*SPREAD(rel_velocity, 2, 3)*SPREAD(rel_velocity, 1, 3)/wn + DO i = 1, 3 + jac_rel(i, i) = jac_rel(i, i) + 0.5_wp*rho*cda*wn + END DO + END IF + END IF + RETURN + END IF + END IF ! The Morison per-length primitive with unit diameter is 1/2 rho Cdn |w_n| w_n + ! 1/2 rho pi Cdt |w_t| w_t, so Cdn = CdA and Cdt = CdAx/pi. IF (PRESENT(jac_rel) .AND. PRESENT(jac_tan)) THEN @@ -2414,11 +2451,12 @@ SUBROUTINE attachment_residual(model, k, q_cfg, v_cfg, want_jac, rk, has_jac, jr wrel = u - v_cfg(base + 1:base + 3) IF (want_jac) THEN CALL CD_HermiteCable_Attachment_Drag(wrel, q_cfg(base + 4:base + 6), model%att_rho, model%att_cda(k), & - model%att_cdax(k), f, ErrStat, ErrMsg, jrel, jtan) + model%att_cdax(k), f, ErrStat, ErrMsg, jrel, jtan, & + isotropic=model%att_iso(k)) has_jac = .TRUE. ELSE CALL CD_HermiteCable_Attachment_Drag(wrel, q_cfg(base + 4:base + 6), model%att_rho, model%att_cda(k), & - model%att_cdax(k), f, ErrStat, ErrMsg) + model%att_cdax(k), f, ErrStat, ErrMsg, isotropic=model%att_iso(k)) END IF IF (ErrStat /= CD_HCDYN_OK) RETURN rk = rk - f @@ -9247,6 +9285,7 @@ SUBROUTINE CD_HermiteCable_Dyn_End(model) IF (ALLOCATED(model%att_node)) DEALLOCATE (model%att_node, model%att_w, model%att_b, model%att_fk, & model%att_cda, model%att_cdax) IF (ALLOCATED(model%att_mass)) DEALLOCATE (model%att_mass, model%att_madd) + IF (ALLOCATED(model%att_iso)) DEALLOCATE (model%att_iso) model%has_attach = .FALSE. IF (ALLOCATED(model%l0_dot)) DEALLOCATE (model%l0_dot, model%l0_c, model%l0_dot_c, model%ws_recovery_l0_c, & model%ws_recovery_l0_dot_c) diff --git a/src/CableDyn_OpenFAST_HermiteFMF.f90 b/src/CableDyn_OpenFAST_HermiteFMF.f90 index bb28e17..e84c89c 100644 --- a/src/CableDyn_OpenFAST_HermiteFMF.f90 +++ b/src/CableDyn_OpenFAST_HermiteFMF.f90 @@ -330,7 +330,8 @@ SUBROUTINE CD_HFMF_Set_Drag(self, rho_w, diam, cdn, cdt, waterline_z, current, E END IF END SUBROUTINE CD_HFMF_Set_Drag - SUBROUTINE CD_HFMF_Set_Attachments(self, node, mass, volume, cda, cdax, ca, rho_w, gravity, ErrStat, ErrMsg) + SUBROUTINE CD_HFMF_Set_Attachments(self, node, mass, volume, cda, cdax, ca, rho_w, gravity, ErrStat, ErrMsg, & + isotropic) !! Install discrete point attachments lumped at cable nodes (internal node order, !! anchor = node 1); see CD_HermiteCable_Dyn_Set_Attachments. TYPE(CD_HFMF_ModuleType), INTENT(INOUT) :: self @@ -338,6 +339,7 @@ SUBROUTINE CD_HFMF_Set_Attachments(self, node, mass, volume, cda, cdax, ca, rho_ REAL(wp), INTENT(IN) :: mass(:), volume(:), cda(:), cdax(:), ca(:), rho_w, gravity INTEGER, INTENT(OUT) :: ErrStat CHARACTER(*), INTENT(OUT) :: ErrMsg + LOGICAL, INTENT(IN), OPTIONAL :: isotropic(:) INTEGER :: es CHARACTER(1024) :: em ErrStat = CD_HFMF_OK; ErrMsg = '' @@ -345,7 +347,7 @@ SUBROUTINE CD_HFMF_Set_Attachments(self, node, mass, volume, cda, cdax, ca, rho_ ErrStat = CD_HFMF_BADINPUT; ErrMsg = 'CD_HFMF_Set_Attachments: module not initialised'; RETURN END IF CALL CD_HermiteCable_Dyn_Set_Attachments(self%line, node, mass, volume, cda, cdax, ca, rho_w, gravity, & - es, em) + es, em, isotropic=isotropic) IF (es /= CD_HCDYN_OK) THEN ErrStat = CD_HFMF_BADINPUT; ErrMsg = TRIM(em) END IF diff --git a/tests/test_free_end_deck.f90 b/tests/test_free_end_deck.f90 index 5e20c56..8ee0629 100644 --- a/tests/test_free_end_deck.f90 +++ b/tests/test_free_end_deck.f90 @@ -14,6 +14,9 @@ PROGRAM test_free_end_deck !! F3 a prescribed 0.05 m sway of the top at 0.05 Hz moves the end in phase with an amplitude !! ratio within 1 % of the Rayleigh estimate for a hanging string with a heavy end mass !! (1.104: the end mass with its added mass, a third of the line's, the mean tension); + !! F6 the point keeps its isotropic drag rho CdA |w| w / 2: in a vertical 0.5 m/s current along + !! the hanging line (axial flow at the end) the top tension grows by the clump's drag + !! rho CdA w^2 / 2 = 7.69 N (to 1e-3 N; the line's own axial drag is zero here); !! F5 on a flat seabed above which the vertical seed would lie (7.3 m deep, the line 7 m from !! z = -0.5 m), a 5 kg end in a 0.8 m/s current rests above the seabed (the seed is placed on !! it, the release lifts the end), and the 200 kg clump, which comes to rest on the seabed @@ -33,6 +36,7 @@ PROGRAM test_free_end_deck CALL check_sway() CALL check_refusals() CALL check_seabed() + CALL check_axial_drag() IF (nfail > 0) THEN WRITE (*, '(A,I0,A)') 'FAIL: ', nfail, ' assertion(s) failed' ERROR STOP 1 @@ -272,6 +276,30 @@ SUBROUTINE solve3(a, b, x) END DO END SUBROUTINE solve3 + SUBROUTINE check_axial_drag() + REAL(wp), ALLOCATABLE :: tab(:, :) + REAL(wp) :: w, wb + INTEGER :: n, k + LOGICAL :: ok + CHARACTER(1024) :: msg + OPEN (NEWUNIT=k, FILE='current_profile.txt', STATUS='REPLACE', ACTION='WRITE') + WRITE (k, '(A)') 'z ux uy uz' + WRITE (k, '(A)') '(m) (m/s) (m/s) (m/s)' + WRITE (k, '(A)') '-20 0 0 -0.5' + WRITE (k, '(A)') '0 0 0 -0.5' + CLOSE (k) + CALL write_deck('fed_axial.dat', '3000', 'Free 0.0 0.0 -7.5 200 0.02548 0.06 1.0', '', '', '1 Currents', & + 'FairTen1', 0.005_wp, 0.05_wp) + CALL run('fed_axial.dat', 'fed_axial', ok, msg) + CALL require(ok, 'F6 axial current: '//TRIM(msg)) + IF (.NOT. ok) RETURN + CALL read_out('fed_axial.out', 2, tab, n) + w = (M - RHO*0.25_wp*PI*D**2)*G + wb = (MB - RHO*VB)*G + IF (n > 0) CALL require(ABS(tab(2, 1) - (w*L + wb + 0.5_wp*RHO*0.06_wp*0.25_wp)) < 1.0e-3_wp, & + 'F6 the clump''s isotropic drag in axial flow') + END SUBROUTINE check_axial_drag + SUBROUTINE check_seabed() REAL(wp), ALLOCATABLE :: tab(:, :) INTEGER :: n From df7108ababd2d2b7ccf18885144fc2543b49bf84 Mon Sep 17 00:00:00 2001 From: Jae Hoon Seo Date: Sat, 14 Nov 2026 18:13:56 +0900 Subject: [PATCH 4/4] fix: the End B force of a free cable end leaves out the point's loads Review: the promoted point's loads sit on the End B node as an attachment, and CD_HermiteCable_Dyn_End_Force adds every attachment on the end node to the end force. At the free end that attachment is the body the force acts on, so its loads cancelled the line's: a hanging clump at rest read AnchTen, the End B nodal tension and Point

Fz of about zero instead of its submerged weight, unlike the EI = 0 route and the documented "line load a free point balances". CD_HermiteCable_Dyn_Set_Attachments (and CD_HFMF_Set_Attachments) take an optional point_load flag per attachment: the attachment stays in the equations of motion, and the end force leaves it out. The deck driver sets it on the promoted attachment. tests/test_free_end_deck.f90 F1: in still water AnchTen1 and Point2Fz read the clump's submerged weight (1705.21 N, to 1e-6 relative) and Point2Fx zero, the same values as the deck run as an EI = 0 line. Signed-off-by: Jae Hoon Seo --- doc/driver_format.md | 3 ++- doc/theory.rst | 4 +++- src/CableDyn_DeckDriver.f90 | 2 +- src/CableDyn_HermiteCableDynamic.f90 | 31 +++++++++++++++++++++------- src/CableDyn_OpenFAST_HermiteFMF.f90 | 6 +++--- tests/test_free_end_deck.f90 | 23 ++++++++++++++++----- 6 files changed, 51 insertions(+), 18 deletions(-) diff --git a/doc/driver_format.md b/doc/driver_format.md index d30975c..51a9812 100644 --- a/doc/driver_format.md +++ b/doc/driver_format.md @@ -754,7 +754,8 @@ and buoyancy, added mass, and drag against current and waves), with the point's with the end first held on the chord from End A towards the deck position, at the line's length stretched by its hanging weight, then released, so the run starts at the end's rest position (the theory manual, Free cable ends); the dynamics leave the end's position free. `Point

p…` -channels read the line's End B node. The line must be pinned in bending at both ends (no +channels read the line's End B node, and the End B force (`AnchTen`, `Point

F…`) is the line load +the point balances, without the point's own loads (a clump at rest reads its submerged weight). The line must be pinned in bending at both ends (no non-pinned `END CONNECTIONS` row), with at most one end restrained in torsion, which is then not solved (a free end carries no moment or torque; the initialisation note says why), and the point and the line must be net heavy (the end hangs). A deck in which any `Free` point is not such an end diff --git a/doc/theory.rst b/doc/theory.rst index 7c80563..0ad2c0a 100644 --- a/doc/theory.rst +++ b/doc/theory.rst @@ -239,7 +239,9 @@ free: the dynamic march holds only End A's three positions, and the point's mass area and added-mass coefficient act on the End B node as a discrete attachment (the weight :math:`(M - \rho V)g`, the added mass :math:`C_a \rho V`, the fluid inertia), with the point's isotropic drag :math:`\tfrac12 \rho\, C_dA\, |\mathbf w|\,\mathbf w` on the whole relative velocity, -as a ``Free`` point carries it, rather than the attachment's normal/axial split. The end carries no moment (it is pinned, a natural boundary condition of the +as a ``Free`` point carries it, rather than the attachment's normal/axial split. The point's loads +stay out of the End B force (``AnchTen``, ``Point

F``): it is the force the line exerts on the +point, the line load the point balances, as on the ``EI = 0`` route. The end carries no moment (it is pinned, a natural boundary condition of the cubic-Hermite element) and no torque: the line is pinned in bending at both ends, and a torsion restraint at its other end is not solved (it is noted, as for a line with two moving ends). diff --git a/src/CableDyn_DeckDriver.f90 b/src/CableDyn_DeckDriver.f90 index d039463..ae0033a 100644 --- a/src/CableDyn_DeckDriver.f90 +++ b/src/CableDyn_DeckDriver.f90 @@ -3743,7 +3743,7 @@ RECURSIVE SUBROUTINE build_one_hermite_cable(ln, sections, types, points, opts, IF (has_att) THEN CALL CD_HFMF_Set_Attachments(cable, att_node, ln%att(2, :), ln%att(3, :), ln%att(4, :), & MAX(ln%att(6, :), CD_ZERO), ln%att(5, :), opts%rhoW, opts%g, es, em, & - isotropic=ln%att(6, :) < CD_ZERO) + isotropic=ln%att(6, :) < CD_ZERO, point_load=ln%att(6, :) < CD_ZERO) IF (es /= CD_HFMF_OK) THEN CALL fail(ErrStat, ErrMsg, 'finite-EI cable attachment wiring failed: '//TRIM(em)); RETURN END IF diff --git a/src/CableDyn_HermiteCableDynamic.f90 b/src/CableDyn_HermiteCableDynamic.f90 index cda9256..7546323 100644 --- a/src/CableDyn_HermiteCableDynamic.f90 +++ b/src/CableDyn_HermiteCableDynamic.f90 @@ -508,6 +508,8 @@ MODULE CableDyn_HermiteCableDynamic REAL(wp), ALLOCATABLE :: att_w(:), att_b(:), att_fk(:), att_cda(:), att_cdax(:) ! a point's isotropic drag (a Free point ending the line) in place of the normal/axial split LOGICAL, ALLOCATABLE :: att_iso(:) + ! the point a free end carries: in the equations of motion, not in the end force + LOGICAL, ALLOCATABLE :: att_point(:) ! The two nodal mass terms each attachment adds to Mgb, the dry mass m and the added mass ! Ca rho V, kept so that a length change rebuilds Mgb in the order initialisation used. REAL(wp), ALLOCATABLE :: att_mass(:), att_madd(:) @@ -2220,7 +2222,7 @@ END SUBROUTINE fail_fr END SUBROUTINE CD_HermiteCable_Dyn_Set_Friction_Anchors SUBROUTINE CD_HermiteCable_Dyn_Set_Attachments(model, node, mass, volume, cda, cdax, ca, rho_w, gravity, & - ErrStat, ErrMsg, isotropic) + ErrStat, ErrMsg, isotropic, point_load) !! Install discrete point attachments (clumps, buoyancy modules) lumped at nodes. Each !! carries its weight and buoyancy (m - rho V) g downward, isotropic added mass !! Ca rho V (with the dry mass m, a constant nodal mass on the translational DOFs), the @@ -2233,13 +2235,16 @@ SUBROUTINE CD_HermiteCable_Dyn_Set_Attachments(model, node, mass, volume, cda, c !! kinetic energy (CD_HermiteCable_Dyn_Energy) then includes the attachment mass and its !! added mass Ca rho V. isotropic (optional, default false) makes an attachment's drag a !! point's, rho CdA |w| w / 2 on the whole relative velocity (CdAx unused), as a Free point - !! that ends the line carries it. + !! that ends the line carries it. point_load (optional, default false) marks the attachment + !! that is the point itself on a free end: it stays in the equations of motion, but + !! CD_HermiteCable_Dyn_End_Force leaves its loads out, so the end force is the line load + !! the point balances (its submerged weight for a clump at rest). TYPE(CD_HermiteCableDynType), INTENT(INOUT) :: model INTEGER, INTENT(IN) :: node(:) REAL(wp), INTENT(IN) :: mass(:), volume(:), cda(:), cdax(:), ca(:), rho_w, gravity INTEGER, INTENT(OUT) :: ErrStat CHARACTER(*), INTENT(OUT) :: ErrMsg - LOGICAL, INTENT(IN), OPTIONAL :: isotropic(:) + LOGICAL, INTENT(IN), OPTIONAL :: isotropic(:), point_load(:) INTEGER :: n, k, d, dof, es REAL(wp), ALLOCATABLE :: a_old(:), mgb_old(:, :) CHARACTER(1024) :: em @@ -2271,6 +2276,13 @@ SUBROUTINE CD_HermiteCable_Dyn_Set_Attachments(model, node, mass, volume, cda, c RETURN END IF END IF + IF (PRESENT(point_load)) THEN + IF (SIZE(point_load) /= n) THEN + ErrStat = CD_HCDYN_BADINPUT + ErrMsg = 'CD_HermiteCable_Dyn_Set_Attachments: point_load must have one entry per attachment' + RETURN + END IF + END IF IF (ANY(node < 1) .OR. ANY(node > model%nn)) THEN ErrStat = CD_HCDYN_BADINPUT; ErrMsg = 'CD_HermiteCable_Dyn_Set_Attachments: node out of range'; RETURN END IF @@ -2291,9 +2303,12 @@ SUBROUTINE CD_HermiteCable_Dyn_Set_Attachments(model, node, mass, volume, cda, c a_old = model%a mgb_old = model%Mgb ALLOCATE (model%att_node(n), model%att_w(n), model%att_b(n), model%att_fk(n), model%att_cda(n), & - model%att_cdax(n), model%att_mass(n), model%att_madd(n), model%att_iso(n)) + model%att_cdax(n), model%att_mass(n), model%att_madd(n), model%att_iso(n), & + model%att_point(n)) model%att_iso = .FALSE. IF (PRESENT(isotropic)) model%att_iso = isotropic + model%att_point = .FALSE. + IF (PRESENT(point_load)) model%att_point = point_load model%att_node = node model%att_w = (mass - rho_w*volume)*gravity model%att_b = rho_w*gravity*volume @@ -2313,7 +2328,7 @@ SUBROUTINE CD_HermiteCable_Dyn_Set_Attachments(model, node, mass, volume, cda, c CALL solve_consistent_acceleration(model, es, em) IF (es /= CD_HCDYN_OK) THEN DEALLOCATE (model%att_node, model%att_w, model%att_b, model%att_fk, model%att_cda, model%att_cdax, & - model%att_mass, model%att_madd, model%att_iso) + model%att_mass, model%att_madd, model%att_iso, model%att_point) model%has_attach = .FALSE. model%Mgb = mgb_old model%a = a_old @@ -7557,9 +7572,10 @@ SUBROUTINE CD_HermiteCable_Dyn_End_Force(model, node, force, ErrStat, ErrMsg) END IF IF (model%has_attach) THEN ! A clump or buoy on the end node loads the point holding it, exactly as it loads the - ! end node in the residual (assemble_attachments). + ! end node in the residual (assemble_attachments). The point a free end carries + ! (att_point) is the body this force acts on, so its own loads stay out. DO k = 1, SIZE(model%att_node) - IF (model%att_node(k) /= node) CYCLE + IF (model%att_node(k) /= node .OR. model%att_point(k)) CYCLE CALL attachment_residual(model, k, model%q, model%v, .FALSE., rk, has_jac, jrel, jtan, es, em2) IF (es /= CD_HCDYN_OK) THEN ErrStat = es; ErrMsg = 'CD_HermiteCable_Dyn_End_Force: '//TRIM(em2); RETURN @@ -9286,6 +9302,7 @@ SUBROUTINE CD_HermiteCable_Dyn_End(model) model%att_cda, model%att_cdax) IF (ALLOCATED(model%att_mass)) DEALLOCATE (model%att_mass, model%att_madd) IF (ALLOCATED(model%att_iso)) DEALLOCATE (model%att_iso) + IF (ALLOCATED(model%att_point)) DEALLOCATE (model%att_point) model%has_attach = .FALSE. IF (ALLOCATED(model%l0_dot)) DEALLOCATE (model%l0_dot, model%l0_c, model%l0_dot_c, model%ws_recovery_l0_c, & model%ws_recovery_l0_dot_c) diff --git a/src/CableDyn_OpenFAST_HermiteFMF.f90 b/src/CableDyn_OpenFAST_HermiteFMF.f90 index e84c89c..1dd2aca 100644 --- a/src/CableDyn_OpenFAST_HermiteFMF.f90 +++ b/src/CableDyn_OpenFAST_HermiteFMF.f90 @@ -331,7 +331,7 @@ SUBROUTINE CD_HFMF_Set_Drag(self, rho_w, diam, cdn, cdt, waterline_z, current, E END SUBROUTINE CD_HFMF_Set_Drag SUBROUTINE CD_HFMF_Set_Attachments(self, node, mass, volume, cda, cdax, ca, rho_w, gravity, ErrStat, ErrMsg, & - isotropic) + isotropic, point_load) !! Install discrete point attachments lumped at cable nodes (internal node order, !! anchor = node 1); see CD_HermiteCable_Dyn_Set_Attachments. TYPE(CD_HFMF_ModuleType), INTENT(INOUT) :: self @@ -339,7 +339,7 @@ SUBROUTINE CD_HFMF_Set_Attachments(self, node, mass, volume, cda, cdax, ca, rho_ REAL(wp), INTENT(IN) :: mass(:), volume(:), cda(:), cdax(:), ca(:), rho_w, gravity INTEGER, INTENT(OUT) :: ErrStat CHARACTER(*), INTENT(OUT) :: ErrMsg - LOGICAL, INTENT(IN), OPTIONAL :: isotropic(:) + LOGICAL, INTENT(IN), OPTIONAL :: isotropic(:), point_load(:) INTEGER :: es CHARACTER(1024) :: em ErrStat = CD_HFMF_OK; ErrMsg = '' @@ -347,7 +347,7 @@ SUBROUTINE CD_HFMF_Set_Attachments(self, node, mass, volume, cda, cdax, ca, rho_ ErrStat = CD_HFMF_BADINPUT; ErrMsg = 'CD_HFMF_Set_Attachments: module not initialised'; RETURN END IF CALL CD_HermiteCable_Dyn_Set_Attachments(self%line, node, mass, volume, cda, cdax, ca, rho_w, gravity, & - es, em, isotropic=isotropic) + es, em, isotropic=isotropic, point_load=point_load) IF (es /= CD_HCDYN_OK) THEN ErrStat = CD_HFMF_BADINPUT; ErrMsg = TRIM(em) END IF diff --git a/tests/test_free_end_deck.f90 b/tests/test_free_end_deck.f90 index 8ee0629..ef2d6dd 100644 --- a/tests/test_free_end_deck.f90 +++ b/tests/test_free_end_deck.f90 @@ -7,7 +7,9 @@ PROGRAM test_free_end_deck !! 0.06 m^2, CA 1) on its Free End B, 70 elements: !! F1 in still water the run holds the static state: the top tension is the submerged weight of !! the line and the clump (to 1e-6 relative), the end hangs one stretched line length below - !! the top (the stretch (W_B L + w L^2/2)/EA, to 1e-7 m), and nothing moves over the run; + !! the top (the stretch (W_B L + w L^2/2)/EA, to 1e-7 m), nothing moves over the run, and + !! the force the line exerts on the point (AnchTen1, Point2Fz) is the clump's submerged weight + !! (to 1e-6 relative), as the EI = 0 Free point reads it: the point's own loads stay out; !! F2 in a 0.5 m/s current along x the end rests where the same deck as an EI = 0 line on the !! point-system route puts its Free point (EI 3 N m^2: within 2e-5 m), and the Point !! channels of the free end read its line's End B node; @@ -160,17 +162,17 @@ SUBROUTINE read_out(path, ncol, tab, n) END SUBROUTINE read_out SUBROUTINE check_still() - REAL(wp), ALLOCATABLE :: tab(:, :) + REAL(wp), ALLOCATABLE :: tab(:, :), t0(:, :) REAL(wp) :: w, wb, stretch - INTEGER :: n + INTEGER :: n, n0 LOGICAL :: ok CHARACTER(1024) :: msg CALL write_deck('fed_still.dat', '3000', 'Free 0.0 0.0 -7.5 200 0.02548 0.06 1.0', '', '', '', & - 'FairTen1;Point2px;Point2pz', 0.005_wp, 2.0_wp) + 'FairTen1;Point2px;Point2pz;AnchTen1;Point2Fz;Point2Fx', 0.005_wp, 2.0_wp) CALL run('fed_still.dat', 'fed_still', ok, msg) CALL require(ok, 'F1 still-water run: '//TRIM(msg)) IF (.NOT. ok) RETURN - CALL read_out('fed_still.out', 4, tab, n) + CALL read_out('fed_still.out', 7, tab, n) CALL require(n > 10, 'F1 output rows') IF (n <= 10) RETURN w = (M - RHO*0.25_wp*PI*D**2)*G @@ -179,6 +181,17 @@ SUBROUTINE check_still() CALL require(ABS(tab(2, 1)/(w*L + wb) - 1.0_wp) < 1.0e-6_wp, 'F1 top tension = submerged weight') CALL require(ABS(tab(4, 1) - (-0.5_wp - L - stretch)) < 1.0e-7_wp, 'F1 end one stretched length below') CALL require(MAXVAL(ABS(tab(3:4, 1:n) - SPREAD(tab(3:4, 1), 2, n))) < 1.0e-10_wp, 'F1 nothing moves') + CALL require(ABS(tab(5, n)/wb - 1.0_wp) < 1.0e-6_wp, 'F1 AnchTen = the clump''s submerged weight') + CALL require(ABS(tab(6, n)/wb - 1.0_wp) < 1.0e-6_wp .AND. ABS(tab(7, n)) < 1.0e-6_wp*wb, & + 'F1 Point2Fz = the clump''s submerged weight') + CALL write_deck('fed_still0.dat', '0', 'Free 0.0 0.0 -7.5 200 0.02548 0.06 1.0', '', '', '', & + 'AnchTen1;Point2Fz', 0.005_wp, 0.1_wp) + CALL run('fed_still0.dat', 'fed_still0', ok, msg) + CALL require(ok, 'F1 EI = 0 still-water run: '//TRIM(msg)) + IF (.NOT. ok) RETURN + CALL read_out('fed_still0.out', 3, t0, n0) + IF (n0 > 0) CALL require(ABS(tab(5, n) - t0(2, n0)) < 1.0e-6_wp*wb .AND. & + ABS(tab(6, n) - t0(3, n0)) < 1.0e-6_wp*wb, 'F1 the end force = the EI = 0 Free point''s') END SUBROUTINE check_still SUBROUTINE check_current()