diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md index 5f289870..e6d44401 100644 --- a/ARCHITECTURE.md +++ b/ARCHITECTURE.md @@ -322,14 +322,16 @@ analytic Jacobians. about its static equilibrium, `K φ = ω² M φ`, over the free DOFs, with `K` the static tangent (element stiffness and linearised seabed contact) and `M` the consistent mass plus Morison added mass. `K` and `M` are assembled in symmetric -band storage; LAPACK `DSBGVX` gives the eigenvalues and inverse iteration on the -banded pencil gives each mode shape, so the cost grows with line length rather -than with its square. Dense `DSYGV` is kept as the test reference. Both line paths -are supported (`nModes`). A finite-EI line's modes (`CD_Modal_Hermite_Line`) take -its end connections and attachments from the dynamic model, and a line restrained -in torsion adds the twist angle of every node: its lumped polar inertia and the -second variation of the nodal-twist energy (`CD_HermiteCable_Dyn_Twist_Hessian`) -in a band of 7 DOFs per node. +band storage. A shift-invert block Lanczos iteration on the banded Cholesky factor +of `K` gives the eigenvalues, certified by a Sturm count of `K - σM` (LAPACK +`DSBGVX` takes short lines, an indefinite or singular `K`, and an uncertified run), +and inverse iteration on the banded pencil gives each mode shape, so the cost +grows with line length rather than with its square. Dense `DSYGV` is kept as the +test reference. Both line paths are supported (`nModes`). A finite-EI line's +modes (`CD_Modal_Hermite_Line`) take its end connections and attachments from the +dynamic model, and a line restrained in torsion adds the twist angle of every +node: its lumped polar inertia and the second variation of the nodal-twist energy +(`CD_HermiteCable_Dyn_Twist_Hessian`) in a band of 7 DOFs per node. ### Outputs diff --git a/CHANGELOG.md b/CHANGELOG.md index b6df6ab8..1b8be549 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,238 @@ All notable changes to CableDyn are recorded in this file. The format follows ## [Unreleased] +## [0.4.2] - 2026-11-09 + +### Added + +- OPTION `axialDampingRatio` (`segment` or `mode1`): under `mode1` a negative `BA` is the damping + ratio of the line's first axial mode, the same on any mesh (BA = 2 zeta EA / omega_1, omega_1 + from the line's sections). `segment`, MoorDyn's damping ratio per segment, stays the default. +- An initialisation note for every line with a negative `BA` per segment: the damping ratio this + gives the line's first axial mode on its mesh, about zeta pi/(2N) on N elements. +- `VIVphaseSeed zero` starts every VIV phase at zero, the start of MoorDyn-F in OpenFAST v5.0.0, + which does not carry its phase seed into its state; the default `spread` keeps MoorDyn-C's + `2 pi i/N`. +- Initialisation notes for a modal analysis about an unstable static state (the line and the + number of its modes with omega^2 < 0) and for a `Point3` buoy that starts off balance under + the default `bodyIC static` (the unbalanced force and the distance to the buoy's static + balance as a `Free` point). The static solve does not place a `Point3` buoy: a 112 t, 259 m^3 + buoy started with 1.5 MN unbalanced and surfaced in 2 s without a word. +- Example decks for cross-flow VIV, the mode-1 axial damping ratio, MoorDyn-C `WaveKin 3` and + `Currents 2`/`5` files, viscoelastic and Syrope composite legs on an RAO-driven floater, a + cable shared by two moving floaters, buoyancy modules under a bend stiffener, a sloping + bathymetry with as-laid friction, torsion with one end free, and the modes of a composite + line; every shipped deck, those of the `moordynC_*` folders included, now runs in CTest and in + the example fallback scan. +- Regression tests through the deck driver: one linear sea as deck wave rows, `WaveKin 7` and + `WaveKin 3` gives one response; the modes of a two-section string match its closed-form + frequency equation at second order in the element length; a cylindrical bend stiffener + matches the equivalent cable-and-sleeve section, and a clamped cable's root moment is + `a sqrt(EI T)`. + +### Changed + +- The modal analysis (`nModes`) of a long line is many times faster. Its lowest eigenvalues come + from a shift-invert block Lanczos iteration on the banded Cholesky factor of the stiffness, + their count certified by the inertia of `K - σM`, instead of the band reduction (LAPACK + `dsbgvx`), whose time grew with the square of the line length. The 10 modes of a 1024-element + finite-EI line take 0.14 s instead of 3.7 s; on a 4000-element line 10 modes take 0.5 s + instead of 55 s and 50 modes 2.9 s instead of 59 s (GNU build, one thread). Shapes and + frequencies still come from inverse iteration and the quadruple-precision Rayleigh quotient: + on the same matrices the frequencies agree to 1e-15, and `lazy_wave_modes.dat` writes the same + frequencies and shapes within 2e-8 of a unit displacement. Short lines, an indefinite or + singular stiffness, and an iteration that is not certified keep the band reduction. A mode + whose largest components are equally large (the mirrored nodes of a symmetric line) takes its + sign from the first of them in node order instead of from round-off. +- The finite-EI dynamic step does less redundant work: band operators are swept over their stored + rows only, the step mass is summed in one pass, the rigid-end transport tangent and the rigid + end-connection moment are formed from the rows they need, the element kernels form their + Gauss-point factors once, and each element kernel is evaluated once for its load and its + tangent where a tangent follows at the same state. Results are bit-identical; the finite-EI + example decks run 2-15 % faster. +- The coupled loads of an `EI = 0` line attached at its end nodes are formed from those nodes' + rows only, and a system stepped on one thread runs its per-line loops without entering an + OpenMP region. Results are bit-identical; a moored Rigid6 body on three chains runs about 7 % + faster. +- With `modified_newton True`, a finite-EI cable in the monolithic step of the multibody march + keeps full Newton: it is stepped again from the same start at every coupling iteration, where + reuse cost more than it saved (`mixed_body_rods_points.dat` with the option: 7.0 s, now 5.6 s). + The documented speed trade-off of the option is measured again on the examples. +- A finite-EI static solve whose equilibrium is in axial compression (with `tensile_safety True`) + stops refining once two passes leave the compression where it was (to 0.1 %), instead of + splitting elements up to the element budget: a power cable given twice its length fails in 6 s + instead of 76 s, with the same compression named. Decks that refinement does resolve are + unchanged (the static matrix and every example give identical outputs). +- The standalone driver runs a line combining `EI = 0` and finite-EI sections as one finite-EI + cable, as the C API and OpenFAST do, whatever the other lines of the deck; it refused such a + line unless the deck also had a separate `EI = 0` line. Its results match the C API's stepping + of the same deck to the digits of the output file. +- The L5 wall-clock records (`validation/performance` and the L5 rows of `VALIDATION.md`) are + measured again on one host, with the release driver and a GNU build. The new + `validation/scripts/performance_records.py` builds the lazy-wave span, one-hour mooring and + tension-only chain models for CableDyn, OrcaFlex, MoorDyn-F and MoorDyn-C, checks each against + its reference response (the records are written only inside it), times them and writes the + records. + +### Fixed + +- Finite-EI node tension, curvature and bend moment next to the touchdown point: the floor + reaction of the first grounded node was spread over its grounded half-element alone, wherever + the touchdown point lay in the touchdown element. The local tension error there fell only at + the first order with the element length (4.3, 1.9, 1.0 N at 1.6, 0.8, 0.4 m elements on a + lazy-wave cable at 270 N) and the node outputs stepped as each node grounded or lifted off. + The touchdown element now takes the reaction of its grounded stretch, from the grounded node + to the touchdown point located from the two nodes' clearances: the error falls at the second + order (2.1, 0.7, 0.2 N) and the outputs vary continuously. +- The tangent outputs of a finite-EI line take the line's tangent, the node's Hermite tangent + DOF, instead of a difference of node positions. At an end clamped by an `END CONNECTIONS` + `Rigid` row they now give the direction the clamp holds: a cable clamped 15 deg off the + vertical read 163.8 deg for a 165 deg clamp, and up to 14 deg off where the line bends within + its first element. +- The VIV lift of a line written fairlead first pointed against MoorDyn's: the node tangent ran + from End B to End A, which is MoorDyn's model started from the phases plus pi. The lift and the + `V` line files now match MoorDyn's on either deck order. Where two lock-in branches coexist the + start can select the other one. +- A negative `BA` of an `EI = 0` line of several sections is resolved with the length, `EA` and + mass of its own element. It took those of the element at the mirrored position from the other + end, so the line types of an asymmetric composite line exchanged their axial damping. +- Finite-EI dynamic step at rest under a large axial damping coefficient: the round-off floor of + the step's force scale left out the axial damping, whose strain rate is formed from the Newmark + velocity and carries gamma/(beta dtM) times the rounding of the coordinates. A held line damped + near its first axial mode (`BA` = 2 zeta EA/omega_1, as `mode1 axialDampingRatio` gives, or a + direct `BA` of that size) stalled at a few times the tolerance and stopped (3 of 30 runs of a + 400 m wire held at rest, `BA` 5e7 to 8e8 N s, `dtM` 0.002 to 0.01 s). The floor now includes + `BA` gamma/(beta dtM), as the twist floor includes its damping. +- Finite-EI statics on a strongly graded deck mesh: when the route fails on the deck mesh and on + its uniform refinement, it is repeated on the deck mesh with each element longer than half the + bending length split to that length. A lazy wave meshed 4 m / 0.9 m / 10 m (sag bend, buoyant + section, touchdown) failed in an oblique or cross current with "already in axial compression + without the current", and now agrees with the same deck on 2 m elements. +- The static solve of a finite-EI line in a current named an element-mean axial compression on + elements longer than half the bending length as a limit of the current (the friction holding + the grounded run, or the run pushed along the seabed), and on that diagnosis skipped the + mesh-sequenced route. On such elements the axial force of a stiff line oscillates, so the + compression names the mesh: the message now says so and how to refine, and the other routes + still run (a lazy wave on a graded mesh in a 0.2 m/s cross current now solves). +- Static solve of discrete `ATTACHMENTS` in a current across the line's vertical plane: the + smeared start now carries the attachments' drag as well as their weight, and the attachment + polish moves both to the nodes. It applied the whole attachment drag to a state without it, and + on a frictional seabed its Newton solves diverged, so the discrete state was reached only + through the fallback solves or not at all (a lazy wave with 25 modules in 0.3 m/s across its + plane). A current along the plane takes the former path. +- Finite-EI statics with discrete `ATTACHMENTS`: a solve of the attachment polish that stalled on + a residual floor above the tight static tolerance (a few times 1e-8, on a fine or locally + refined mesh) went on to the fallbacks and halved its load steps until the static start + failed, although the line's own static solve accepts such a floor at the coupled static + tolerance 1e-6. A clamped cable arriving at its anchor in a tight bend with one clump failed + for every clump mass and position tried. The polish now repeats a stalled solve at 1e-6 from + the same state before its fallbacks, and the run notes the residual of the discrete + equilibrium when it lies above the tight tolerance. +- Finite-EI statics in a current with a `Rigid` end connection: when the drag load steps stall at + a limit point, the pseudo-arclength continuation that follows the path around it was skipped + for a line with a `Rigid` end, so the statics failed where the same line with a stiff + rotational spring solved (a 3 km cable clamped at its fairlead in 1.1 m/s, folded back past + its anchor). The continuation now takes a `Rigid` end in the basis of its direction, with the + transverse components of the end tangent held, as the static solve does. +- Finite-EI statics that restart at full stiffness no longer depend on the line's azimuth. When + the first stage of the stiffness continuation fails (a clamped end on a mesh too coarse for + its boundary layer), the energy descent from the seed was cut at a fixed count (1600 + iterations at the default allowance). On a 3.8 km clamped lazy wave that descent takes 1171 + to 1661 iterations depending on the last digits of the input, so turning the deck about the + vertical failed the statics at 328.3 and 329 deg and solved them elsewhere. Past its allowance + the descent now runs on while the norm of its residual keeps halving within an allowance, to + one and a half allowances. The lazy wave solves at all 28 azimuths tried, with the same + tensions, and the static states of the decks that solved before are unchanged. +- Finite-EI statics: the note "static residual floor above the dynamic tolerance" could report a + residual below that tolerance (accepted at 6.91e-9 against 1e-8): a polish repeated at the + coupled static tolerance after the tight one failed can still end below the tight tolerance. + The note is now printed only when the residual reached lies above it. +- `staticsFriction asLaid` on a bathymetry: the friction reference of a finite-EI line sinks each + node under the normal load the solver applies at its laid position, with the buoyancy of the + dry part of a section laid within its radius of the surface (a seabed shallower than the + cable radius) and the dry weight of an attachment above it. It took the submerged weights, so + such a run rested off its laid path across a slope (0.8 mm on a 0.5 m cable 0.1 m deep), + held there by a spurious friction force. The dry-part load is solved by Newton's method with + halved steps, which converge where full steps cycle between a wholly dry and a wholly wet node + (a net-buoyant cable on a seabed shallower than its radius). +- `EI = 0` statics: a residual inside the round-off floor of the nodal forces but above the + relative tolerance was converged only when it stayed flat. Iterates that alternated between two + values there ran every stage out of iterations, so a line could fail to find its equilibrium or + find it depending on the last digits of its coordinates (13 of 32 small translations of a + suspended three-section line in a current failed, as did translated copies of point systems). A + residual inside the floor that sets no new minimum over three iterations is now converged. +- Static balance of `Connect`/`Free` points, bodies and rods: a step that raised the force + residual was accepted when the Newton step from it was half the current one. Near the + slack/taut kink of a line the Newton step can grow again, and the steps then cycled (a + Connect point between a near-vertical heavy chain and two wires on the seabed: 4e4 N to 6e6 N + and back, every four steps) until the solve failed from every seed, although an independent + catenary solution gives the balance. Such a step is now accepted only when the new Newton step + is also half the shortest of the solve so far. +- Syrope lines of one section: the static start took one secant EA from the working curve at + the line's mean strain, so where the tension varies along the rope (its weight on a long or + inclined taut line) the elements away from the mean started off their curve and their slow + strains settled the line at rest (a 991 m rope moved its fairlead tension by 3.4e-4 in 1 s; + 63 of 125 random Syrope lines drifted by more than 1e-5). Every Syrope element now takes its + own secant at its own tension, as on a composite line: the same lines start at rest to 1e-6. + An update that reverses without contracting takes a secant step on the line's response, so a + strongly concave working curve converges instead of cycling. +- A bend stiffener over an element that two STIFFENERS rows share no longer gives it a negative + EI: their covered lengths can sum past the element length by round-off, which a soft cable's EI + (1e-12 N m^2 and below) turned into a negative compliance, and the static solve then failed + with an internal message. STIFFENERS `RootOD` and `TipOD` are now at most 1e3 m, the bound of a + line type's `Diam`, in the solver and the Python deck validator. +- C API and Python on a deck of `EI = 0` lines in a current that varies in space (a `profile` + current, a `Currents 1` table or a steady grid): the lines took the current at the nodes of + their straight seeds, while the static solve sampled it at its own nodes. The start was not + the static state's (end loads off by up to 1.7 % of a component), and a line held at rest + drifted (0.4 % of its fairlead tension and 12 % of a force component in 2 s). The field is + now sampled at the static nodes and at the step-start nodes before every step, as the + standalone driver samples it, and a step that does not commit puts back the field it + replaced; a uniform current is unchanged. +- A time step below 1e-100 s is refused by name (`dtM`, `CableDyn_Step` and the OpenFAST glue + `DT`): the time integration divides by its square, which overflowed near 1e-155 s inside the + line solve ("banded model load q/v must be finite", "non-finite Jacobian"). The Python deck + validator applies the `dtM` bound. +- A `waves` or `current` row overridden by a later one no longer leaves a bound behind: an Airy + or stream `waves` row after a JONSWAP row was refused for that row's gamma above 1e3, and a + `profile` current row after a `uniform` one for that row's velocity above 1e3 m/s. The Python + deck validator now applies the magnitude bounds of these rows (wave height and period, JONSWAP + gamma, current speed and depth) to the row in effect only, as the solver does, instead of + refusing a deck for an out-of-range row a later row overrides. +- A finite-EI line type with `MassDenInAir` of zero or less is refused by name + (`MassDenInAir must be > 0 on a finite-EI line`) instead of failing inside the model build. +- The Python deck validator refuses, as the solver does, `TDP` channels on a standalone deck + without a seabed, `Point

p` channels of a Coupled/Vessel point that only finite-EI lines reach + on the aggregate and of any point on a standalone multibody march without an `EI = 0` line, + and a finite-EI line type without mass. +- Python: `CableDyn.channel` and `channels` refuse a token holding a NUL character, which the + library read only up to the NUL (`"FairTen1\0x"` returned `FairTen1`). +- Documentation: the length the Morison drag is taken over on each path (unstretched on `EI = 0` + lines, the deformed centreline on finite-EI lines), and how an independent check of the static + force balance in a current must integrate it. The end reactions of a finite-EI cable at rest + in a current, pinned or clamped, balance its weight and drag to 2e-8 of the end force; a test + checks it. The signed frequency of a mode with omega^2 < 0 (`Omega` = -sqrt(|omega^2|), + `Frequency` = `Omega`/2 pi, period 0) is documented, and a troubleshooting entry covers a long + line that solves at one orientation and not at another. + +### Upgrading + +- On finite-EI lines `LNDec` and `LNAzi`, `FairDecl`/`AnchDecl`, `FairIncl`/`AnchIncl` + and `FairAngle`/`AnchAngle`, the `Declination`, `Inclination` and `Azimuth` columns of + `.static.out`, the `Declination` envelope of the range graph and the `line tangent` of the + initialisation reports (driver, mixed route, C API notes and OpenFAST) change: by up to 3.1 deg + at the clamped end of `buoy_clamped_cable.dat`, 1.8 deg in the static profile of + `lozon_gomex80_power_cable_motion.dat` (1.4 deg in `iea15mw_umaine_mixed_cabledyn.dat`, 0.5 deg + in `torsion_lazy_wave_hangoff_twist.dat`) and 0.6 deg in the `FairIncl1` history of + `lazy_wave_vessel_motion.dat`, and by 0.2 deg or less on the other finite-EI examples. + Positions, forces, tensions, curvatures and every `EI = 0` line are unchanged. +- The VIV lift of a line written fairlead first changes direction (see Fixed); a deck run with VIV + gives MoorDyn's response on either deck order. +- The static tensions of a one-section Syrope line move by up to 3e-4 (relative); the Syrope + example is unchanged. +- On the C API and Python point route, a deck in a current that varies in space starts from the + driver's static state and stays at rest when held. + ## [0.4.1] - 2026-11-08 ### Added @@ -818,7 +1050,8 @@ Corrections made during the pre-release review. values of the shipped example decks and states which tension (end element or `FairTen` end force) each comparison uses. -[Unreleased]: https://github.com/SMI-Lab-Inha/CableDyn/compare/v0.4.1...HEAD +[Unreleased]: https://github.com/SMI-Lab-Inha/CableDyn/compare/v0.4.2...HEAD +[0.4.2]: https://github.com/SMI-Lab-Inha/CableDyn/releases/tag/v0.4.2 [0.4.1]: https://github.com/SMI-Lab-Inha/CableDyn/releases/tag/v0.4.1 [0.4.0]: https://github.com/SMI-Lab-Inha/CableDyn/releases/tag/v0.4.0 [0.3.0]: https://github.com/SMI-Lab-Inha/CableDyn/releases/tag/v0.3.0 diff --git a/CITATION.cff b/CITATION.cff index a9b4ade9..a34cf73c 100644 --- a/CITATION.cff +++ b/CITATION.cff @@ -23,8 +23,8 @@ authors: repository-code: "https://github.com/SMI-Lab-Inha/CableDyn" url: "https://github.com/SMI-Lab-Inha/CableDyn" license: Apache-2.0 -version: 0.4.1 -date-released: 2026-11-08 +version: 0.4.2 +date-released: 2026-11-09 keywords: - mooring dynamics - cable dynamics diff --git a/CMakeLists.txt b/CMakeLists.txt index aebdc15a..d92bc8ce 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -8,7 +8,7 @@ # cmake_minimum_required(VERSION 3.20) # VERSION is a bare numeric triple matching the release version. -project(CableDynCore VERSION 0.4.1 LANGUAGES C Fortran +project(CableDynCore VERSION 0.4.2 LANGUAGES C Fortran DESCRIPTION "CableDyn geometrically exact cable/mooring solver — Fortran core") option(CABLEDYN_ENABLE_COVERAGE "Instrument the GNU Fortran core for gcov/gcovr source coverage" OFF) @@ -1284,6 +1284,19 @@ add_executable(test_static_dry_weight tests/test_static_dry_weight.f90) target_link_libraries(test_static_dry_weight PRIVATE cabledyn_core) add_test(NAME static_dry_weight COMMAND test_static_dry_weight WORKING_DIRECTORY ${CMAKE_BINARY_DIR}) set_tests_properties(static_dry_weight PROPERTIES LABELS "fortran;integration;static;openfast") +# The tangent channels of a finite-EI line read its tangent DOF: at a clamped end the clamp's +# angles, at a pinned end and every other node the solution's tangent. +add_executable(test_end_tangent_channels tests/test_end_tangent_channels.f90) +target_link_libraries(test_end_tangent_channels PRIVATE cabledyn_core) +add_test(NAME end_tangent_channels COMMAND test_end_tangent_channels WORKING_DIRECTORY ${CMAKE_BINARY_DIR}) +set_tests_properties(end_tangent_channels PROPERTIES LABELS "fortran;integration;static;outputs" TIMEOUT 600) +# The end reactions of a finite-EI cable at rest in a uniform current, pinned or clamped, +# suspended or touching down, balance its weight and its Morison drag integrated independently. +add_executable(test_static_current_balance tests/test_static_current_balance.f90) +target_link_libraries(test_static_current_balance PRIVATE cabledyn_core) +add_test(NAME static_current_balance COMMAND test_static_current_balance + WORKING_DIRECTORY ${CMAKE_BINARY_DIR}) +set_tests_properties(static_current_balance PROPERTIES LABELS "fortran;integration;static;hydro" TIMEOUT 600) add_executable(test_viv_kernels tests/test_viv_kernels.f90) target_link_libraries(test_viv_kernels PRIVATE cabledyn_core) @@ -1752,9 +1765,8 @@ if(Python3_Interpreter_FOUND) TIMEOUT 600 ENVIRONMENT "${_cabledyn_python_test_environment}") - # Discrete buoyancy modules on a lazy wave in a cross current (the attachment polish falls - # back from diverging Newton steps on the frictional seabed): the static solve converges and - # its end tensions match the equivalent smeared section. + # Discrete buoyancy modules on a lazy wave in a cross current on a frictional seabed: the static + # solve converges without a fallback and its end tensions match the equivalent smeared section. add_test(NAME attachment_cross_current COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_attachment_cross_current.py --exe $ @@ -1765,6 +1777,32 @@ if(Python3_Interpreter_FOUND) TIMEOUT 600 ENVIRONMENT "${_cabledyn_python_test_environment}") + # A clump on a cable clamped in a tight bend at its anchor: the attachment polish accepts the + # residual floor of its solves at the coupled static tolerance, as the line's own solve does. + add_test(NAME attachment_polish_floor + COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_attachment_polish_floor.py + --exe $ + --output ${CMAKE_BINARY_DIR}/attachment_polish_floor) + set_tests_properties(attachment_polish_floor PROPERTIES + LABELS "python;hermite;static;robustness;attachments" + TIMEOUT 900 + ENVIRONMENT "${_cabledyn_python_test_environment}") + + # A lazy wave on a strongly graded deck mesh (4 m and 10 m elements beside a refined buoyant + # section) in oblique and cross currents: the route is repeated on the mesh refined element by + # element to the bending length, and agrees with the deck on 2 m elements. PROCESSORS reserves + # the four driver processes the test runs at once. + add_test(NAME graded_mesh_statics + COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_graded_mesh_statics.py + --exe $ + --data ${CMAKE_CURRENT_SOURCE_DIR}/tests/data + --output ${CMAKE_BINARY_DIR}/graded_mesh_statics) + set_tests_properties(graded_mesh_statics PROPERTIES + LABELS "python;hermite;static;robustness;attachments" + PROCESSORS 4 + TIMEOUT 1500 + ENVIRONMENT "${_cabledyn_python_test_environment}") + # Finite-EI generalised-alpha blends: force-blend dtM convergence under prescribed surge. add_test(NAME hermite_force_blend_dt COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_hermite_force_blend_dt.py @@ -1788,6 +1826,17 @@ if(Python3_Interpreter_FOUND) TIMEOUT 600 ENVIRONMENT "${_cabledyn_python_test_environment}") + # A heavily damped finite-EI line held at rest completes every step and stays at rest over + # a sweep of the axial damping coefficient and dtM (the damping's residual round-off floor). + add_test(NAME hermite_damped_rest + COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_hermite_damped_rest.py + --exe $ + --output ${CMAKE_BINARY_DIR}/hermite_damped_rest) + set_tests_properties(hermite_damped_rest PROPERTIES + LABELS "python;hermite;dynamic;robustness" + TIMEOUT 300 + ENVIRONMENT "${_cabledyn_python_test_environment}") + # Range graphs (LINES flag r) and touchdown channels on every standalone route: envelopes # against the node channels, the analytic catenary TDP, quasi-static tracking under a # moving fairlead, and agreement with cabledyn.touchdown_history (needs numpy). @@ -1822,6 +1871,81 @@ if(Python3_Interpreter_FOUND) TIMEOUT 600 ENVIRONMENT "${_cabledyn_python_test_environment}") + # EI = 0 statics: a residual that cycles inside its round-off floor is converged, so a line in + # a current solves the same under every small translation of its deck. + add_test(NAME ei0_static_floor_cycle + COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_ei0_static_floor_cycle.py + --exe $ + --output ${CMAKE_BINARY_DIR}/ei0_static_floor_cycle) + set_tests_properties(ei0_static_floor_cycle PROPERTIES + LABELS "python;static;robustness" + TIMEOUT 300 + ENVIRONMENT "${_cabledyn_python_test_environment}") + + # A Point3 buoy that starts off balance under bodyIC static is noted with its unbalanced force. + add_test(NAME point3_balance_note + COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_point3_balance_note.py + --exe $ + --output ${CMAKE_BINARY_DIR}/point3_balance_note) + set_tests_properties(point3_balance_note PROPERTIES + LABELS "python;bodies;static" + TIMEOUT 300 + ENVIRONMENT "${_cabledyn_python_test_environment}") + + # Taut single-section Syrope ropes whose tension varies along them start at rest: every element + # takes its own secant on its working curve. + add_test(NAME syrope_taut_rest + COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_syrope_taut_rest.py + --exe $ + --output ${CMAKE_BINARY_DIR}/syrope_taut_rest) + set_tests_properties(syrope_taut_rest PROPERTIES + LABELS "python;syrope;static;dynamic" + TIMEOUT 300 + ENVIRONMENT "${_cabledyn_python_test_environment}") + + # The static residual-floor note reports a residual above the tolerance it says was missed. + add_test(NAME static_floor_note + COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_static_floor_note.py + --exe $ + --output ${CMAKE_BINARY_DIR}/static_floor_note) + set_tests_properties(static_floor_note PROPERTIES + LABELS "python;hermite;static" + TIMEOUT 300 + ENVIRONMENT "${_cabledyn_python_test_environment}") + + # The static balance of a Connect point between a heavy chain and two wires on the seabed does + # not cycle between trial steps, and agrees with the independent catenary balance. + add_test(NAME point_static_cycle + COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_point_static_cycle.py + --exe $ + --output ${CMAKE_BINARY_DIR}/point_static_cycle) + set_tests_properties(point_static_cycle PROPERTIES + LABELS "python;static;points;robustness" + TIMEOUT 300 + ENVIRONMENT "${_cabledyn_python_test_environment}") + + # A Rigid-ended cable in a strong current follows its drag path past a limit point by the + # pseudo-arclength continuation, as a stiff rotational spring does. + add_test(NAME arclength_rigid_end + COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_arclength_rigid_end.py + --exe $ + --output ${CMAKE_BINARY_DIR}/arclength_rigid_end) + set_tests_properties(arclength_rigid_end PROPERTIES + LABELS "python;hermite;static;robustness;current" + TIMEOUT 900 + ENVIRONMENT "${_cabledyn_python_test_environment}") + + # The finite-EI statics of a clamped lazy wave do not depend on its azimuth: its restart at full + # stiffness runs while the residual keeps falling instead of to a fixed count. + add_test(NAME hermite_static_azimuth + COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_hermite_static_azimuth.py + --exe $ + --output ${CMAKE_BINARY_DIR}/hermite_static_azimuth) + set_tests_properties(hermite_static_azimuth PROPERTIES + LABELS "python;hermite;static;robustness" + TIMEOUT 900 + ENVIRONMENT "${_cabledyn_python_test_environment}") + # The note on grounded lines that a current moves over a seabed without friction: once per run # on every standalone route, and never without a grounded node, a current, or a march, or # with friction. @@ -1941,6 +2065,39 @@ if(Python3_Interpreter_FOUND) message(STATUS "viv_lockin: skipped (numpy not importable in ${Python3_EXECUTABLE})") endif() + # Deck-driver end-to-end oracles (need numpy): one linear sea written as deck wave rows, as a + # MoorDyn-C WaveKin 7 table and as a WaveKin 3 record gives one line response; the modes of a + # two-section string are the roots of its closed-form frequency equation; a cylindrical bend + # stiffener is the section of cable and sleeve, and a cable clamped at the angle a off its + # tangent carries the root moment a sqrt(EI T). + if(_range_tdp_numpy_rc EQUAL 0) + add_test(NAME wave_input_equivalence + COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_wave_input_equivalence.py + --exe $ + --output ${CMAKE_BINARY_DIR}/wave_input_equivalence) + set_tests_properties(wave_input_equivalence PROPERTIES + LABELS "python;driver;integration;dynamic;validation" + TIMEOUT 600 + ENVIRONMENT "${_cabledyn_python_test_environment}") + add_test(NAME composite_string_modes + COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_composite_string_modes.py + --exe $ + --output ${CMAKE_BINARY_DIR}/composite_string_modes) + set_tests_properties(composite_string_modes PROPERTIES + LABELS "python;driver;integration;static;modal;validation" + TIMEOUT 600 + ENVIRONMENT "${_cabledyn_python_test_environment}") + add_test(NAME stiffener_section_equivalence + COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_stiffener_section_equivalence.py + --exe $ + --examples ${CMAKE_CURRENT_SOURCE_DIR}/examples + --output ${CMAKE_BINARY_DIR}/stiffener_section_equivalence) + set_tests_properties(stiffener_section_equivalence PROPERTIES + LABELS "python;driver;integration;static;dynamic;finite_ei;validation" + TIMEOUT 600 + ENVIRONMENT "${_cabledyn_python_test_environment}") + endif() + # Node channels on a refined finite-EI line name deck nodes: the static profile's DeckNode # column, the standalone static and dynamic cubic-Hermite routes, the mixed route (the OpenFAST # aggregate evaluator) and the C API on the coarse lazy-wave deck the static solve refines @@ -1961,8 +2118,23 @@ if(Python3_Interpreter_FOUND) LABELS "python;integration;static;dynamic;capi" TIMEOUT 600 ENVIRONMENT "${_cabledyn_python_test_environment}") + # Discrete buoyancy modules in oblique and cross currents (speed, heading, module count and + # mesh refinement swept): the attachment polish converges without its fallbacks on a frictional + # seabed, and a mid-water lazy wave's end forces balance its weight, buoyancy and drag (C API). + # PROCESSORS reserves the four driver processes the test runs at once. + add_test(NAME attachment_polish_current + COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_attachment_polish_current.py + --exe $ + --library ${_node_channels_library} + --source ${CMAKE_CURRENT_SOURCE_DIR} + --output ${CMAKE_BINARY_DIR}/attachment_polish_current) + set_tests_properties(attachment_polish_current PROPERTIES + LABELS "python;hermite;static;robustness;attachments;capi" + PROCESSORS 4 + TIMEOUT 900 + ENVIRONMENT "${_cabledyn_python_test_environment}") else() - message(STATUS "node_channels_refined_line: skipped (numpy not importable in ${Python3_EXECUTABLE})") + message(STATUS "node_channels_refined_line, attachment_polish_current: skipped (numpy not importable in ${Python3_EXECUTABLE})") endif() # The arbiter imports numpy + scipy at load time; only register the test when they are @@ -2779,13 +2951,24 @@ if(Python3_Interpreter_FOUND) ENVIRONMENT "${_cabledyn_python_test_environment}") # Node tension through touchdown on a coarse mesh (10 m grounded elements) follows a four # times finer reference within 3.5 %: the touchdown element, grounded at one end only, takes - # no share of its grounded node's floor reaction. + # the floor reaction of its grounded stretch alone, not half an element's. add_test(NAME driver_touchdown_recovery COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/tests/check_touchdown_recovery.py $) set_tests_properties(driver_touchdown_recovery PROPERTIES LABELS "python;driver;integration;static" ENVIRONMENT "${_cabledyn_python_test_environment}") + # Node tension at touchdown converges at second order wherever the touchdown point falls in + # its element: the local error over a sweep of meshes at 1.6, 0.8 and 0.4 m elements falls + # by at least 2.5 from 0.8 to 0.4 m and stays below 0.35 N there (the touchdown element takes + # the floor reaction of its grounded stretch). + add_test(NAME driver_touchdown_convergence + COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/tests/check_touchdown_convergence.py + $) + set_tests_properties(driver_touchdown_convergence PROPERTIES + LABELS "python;driver;integration;static" + TIMEOUT 600 + ENVIRONMENT "${_cabledyn_python_test_environment}") # A hang-off through a tapered bend stiffener follows the planar elastica (scipy solve_bvp) # within 2 % of the root moment and 1 cm, and node by node on a sweep of element sizes within # 0.5 % of the local curvature on 0.1 m elements; skipped where scipy is not installed. @@ -2805,6 +2988,24 @@ if(Python3_Interpreter_FOUND) LABELS "python;driver;integration;static;validation" SKIP_RETURN_CODE 77 ENVIRONMENT "${_cabledyn_python_test_environment}") + # The end tangent outputs of a clamped finite-EI line (channels, static profile, range graph, + # initialisation reports on the finite-EI and mixed routes) are the clamp's angles. + add_test(NAME driver_end_tangent_channels + COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/tests/check_end_tangent_channels.py + $) + set_tests_properties(driver_end_tangent_channels PROPERTIES + LABELS "python;driver;integration;static;outputs" + TIMEOUT 600 + ENVIRONMENT "${_cabledyn_python_test_environment}") + # A negative BA damps the first axial mode of a line at zeta pi/(2N) per segment (the + # default), and at zeta on every mesh under axialDampingRatio mode1, uniform and composite. + add_test(NAME driver_axial_damping_ratio + COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/tests/check_axial_damping_ratio.py + $) + set_tests_properties(driver_axial_damping_ratio PROPERTIES + LABELS "python;driver;integration;dynamic;validation" + TIMEOUT 600 + ENVIRONMENT "${_cabledyn_python_test_environment}") endif() # The scan of the round-off CI job: it must flag a fallback note, a failed run and a forced # BLAS kernel that did not take effect, or a clean scan would prove nothing. @@ -2819,6 +3020,16 @@ if(Python3_Interpreter_FOUND) endif() # A clamped finite-EI cable with a buoyant section on a Rigid6 body: the body static solve # holds the objects at their deck poses, warns once, and reports no balanced clamped end loads. +# A lazy wave on a graded mesh in a cross current: the continuation route stops on a compression +# read on elements longer than half the bending length, which is no grounded-run limit, so the +# mesh-sequenced route still runs and solves the deck, with no fallback. +add_test(NAME driver_graded_cross_current + COMMAND ${CMAKE_COMMAND} -DDRIVER=$ -DEXPECT_RC=0 + "-DARGS=${CMAKE_CURRENT_SOURCE_DIR}/tests/data/lazy_wave_graded_cross_current.dat|graded" + "-DMUST_NOT=failed Newton;stalled;looser tolerance" + -DWORKDIR=${CMAKE_CURRENT_BINARY_DIR}/driver_graded_cross_current + -P ${CMAKE_CURRENT_SOURCE_DIR}/tests/check_driver_output.cmake) +set_tests_properties(driver_graded_cross_current PROPERTIES LABELS "fortran;driver;integration;static" TIMEOUT 600) add_test(NAME driver_clamped_buoyant_held COMMAND ${CMAKE_COMMAND} -DDRIVER=$ -DEXPECT_RC=0 "-DARGS=${CMAKE_CURRENT_SOURCE_DIR}/tests/data/clamped_buoyant_cable_held.dat|held" @@ -3065,6 +3276,14 @@ if(Python3_Interpreter_FOUND) --source ${CMAKE_CURRENT_SOURCE_DIR} --output ${CMAKE_CURRENT_BINARY_DIR}/modal_torsion_deck) set_tests_properties(modal_torsion_deck PROPERTIES LABELS "python;driver;integration;validation") + # A modal analysis about an unstable static state writes its negative omega^2 as a negative + # frequency of period 0 and notes it; the stable state of a finer mesh does neither. + add_test( + NAME modal_negative_note + COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/tests/test_modal_negative_note.py + --exe $ + --output ${CMAKE_CURRENT_BINARY_DIR}/modal_negative_note) + set_tests_properties(modal_negative_note PROPERTIES LABELS "python;driver;modal" TIMEOUT 300) # Static-initialization robustness matrix: a deterministic sample of EI=0 mooring regimes # (catenary, semi-taut, taut, suspended, composite, slack/vertical, anchors off the seabed, # sloped seabed, fine mesh, soft seabed, current, one/two segments, Free/Connect points) @@ -3323,19 +3542,37 @@ foreach(_dyn_example IN ITEMS dynamic_chain_held dynamic_chain_current dynamic_c endforeach() # Feature examples (vessel motion and RAOs, discrete buoyancy, range graphs and touchdown, wave # spectra, stream waves, anisotropic friction, modal analysis, clamped ends on bodies, MoorDyn-C -# kinematics files, bodies and rods, line failure): every shipped deck must run to completion. +# kinematics files, bodies and rods, line failure, cross-flow VIV, the mode-1 axial damping ratio, +# composite synthetic ropes on a floater, a cable between two moving ends, attachments under a +# bend stiffener, bathymetry with as-laid friction, torsion with one end free): every shipped +# deck must run to completion. foreach(_feature_example IN ITEMS lazy_wave_vessel_motion lazy_wave_vessel_rao lazy_wave_bend_stiffener lazy_wave_buoyancy_modules lazy_wave_buoyancy_smeared chain_range_tdp chain_torsethaugen_spread chain_two_train_sea stream_wave_shallow_chain airy_wave_shallow_chain laid_cable_cross_current chain_modes lazy_wave_modes buoy_clamped_cable moordynC_wavekin/chain_wavekin7_currents1 spar_pinned_rods mixed_body_rods_points - als_volturnus_line_break_time als_volturnus_line_break_tension) + als_volturnus_line_break_time als_volturnus_line_break_tension + viv_taut_line_crossflow composite_axial_damping_mode1 composite_ve_syrope_jonswap + composite_chain_poly_chain_modes shared_cable_two_floaters lazy_wave_modules_stiffener + chain_sloped_bathymetry_friction torsion_free_end_armoured_cable + moordynC_currents/chain_wavekin3_currents2 moordynC_currents/chain_currents5_grid) get_filename_component(_feature_name "${_feature_example}" NAME) add_test(NAME example_${_feature_name} COMMAND cabledyn "${CMAKE_CURRENT_SOURCE_DIR}/examples/${_feature_example}.dat" "${CMAKE_CURRENT_BINARY_DIR}/example_${_feature_name}") set_tests_properties(example_${_feature_name} PROPERTIES LABELS "fortran;driver;integration;example;dynamic") endforeach() +# The shipped decks no other test runs by name (static moorings, a buoy and a spar on legs): +# each must run as shipped. +foreach(_shipped_example IN ITEMS + composite_chain_wire nylon_taut_mooring semitaut_chain_polyester spread_4line_chain + taut_chain_steep ve_nylon_loaddependent_mooring wd0050_chain wire_catenary_mooring + rigid6_buoy rod_moored_spar) + add_test(NAME example_${_shipped_example} + COMMAND cabledyn "${CMAKE_CURRENT_SOURCE_DIR}/examples/${_shipped_example}.dat" + "${CMAKE_CURRENT_BINARY_DIR}/example_${_shipped_example}") + set_tests_properties(example_${_shipped_example} PROPERTIES LABELS "fortran;driver;integration;example") +endforeach() # Composite grounded moorings must initialize at every mesh refinement of the shipped decks. add_executable(test_static_mesh_refinement tests/test_static_mesh_refinement.f90) diff --git a/README.md b/README.md index c37d30e7..9ee384f5 100644 --- a/README.md +++ b/README.md @@ -9,38 +9,76 @@ [![License: Apache-2.0](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE) [![DOI](https://img.shields.io/badge/DOI-10.1016%2Fj.oceaneng.2026.128332-blue.svg)](https://doi.org/10.1016/j.oceaneng.2026.128332) -CableDyn is an open-source, geometrically exact finite-element solver for the -static and dynamic analysis of offshore mooring lines and dynamic power cables. -Its strain and curvature are the exact large-deformation measures, never -linearised, so large displacements and rotations, slack and snap, and a line -lifting off the seabed lie inside the formulation. It is written in -Fortran 2018 and runs as a standalone program, as a mooring module of OpenFAST, -maintained by NLR (National Laboratory of the Rockies, formerly NREL) -(`CompMooring = 5`), through a C interface, or from Python. It reads input decks -in the MoorDyn v2 format and solves them with two line formulations: - -- **Tension-only lines** (`EI = 0`): chains, wire ropes, and synthetic-fibre - moorings. -- **Finite-bending lines** (finite-EI): cubic-Hermite elements for dynamic power - cables, including lazy-wave configurations, with continuous centreline curvature. - -The current stable release is `v0.4.1`. Interfaces are -versioned and may change before `1.0.0`. - -## Capabilities - -| Area | Features | -|---|---| -| Statics | Catenary seeding, Newton solution, load continuation, mesh sequencing, adaptive meshing | -| Dynamics | Implicit generalised-alpha integration, prescribed support motion, consistent mass, automatic step subdivision, torsion with a twist angle and rotary inertia at every node, cross-flow vortex-induced vibration | -| Environment | Buoyancy, Morison drag, added mass, Froude–Krylov loading, regular and irregular waves, current profiles, seabed contact with friction | -| Materials | Linear axial stiffness, Kelvin–Voigt damping, viscoelastic (series-Kelvin; MoorDyn `ElasticMod` 2/3), Syrope polyester model, torsional stiffness with torque–tension coupling, tapered bend stiffeners | -| Topology | Fixed, coupled, free, and connected points; clump weights; buoyancy modules along cables; rigid bodies and rods; end rotational stiffness; cables between two moving ends; active line-length control; line failure | -| Outputs | Effective tension, position, velocity, acceleration, curvature (also on the section's own axes), bending moment, torque and twist, end angles, contact response, natural modes, solver diagnostics | -| Interfaces | Standalone driver, OpenFAST and FAST.Farm (with linearisation of the line dynamics), C ABI, Python package | - -Section and keyword names follow MoorDyn v2; unsupported combinations stop with -a named error rather than running approximately. +CableDyn is an open-source, geometrically exact finite-element solver for the static and +dynamic analysis of mooring lines and dynamic power cables. It resolves what a power cable is +designed against: the curvature along the line, under a bend stiffener, through a lazy wave and +across a moving touchdown, together with tension, torque and twist. Strain and curvature are the +exact large-deformation measures, never linearised, so slack and snap, large rotations and a line +lifting off the seabed lie inside the formulation. + +It runs as a standalone program, as a mooring module of OpenFAST and FAST.Farm +(`CompMooring = 5`), through a C interface, or from Python. +The current stable release is `v0.4.2`; interfaces are versioned and may change before `1.0.0`. + +## What CableDyn does + +- **Finite-element cables with real bending stiffness.** Cubic-Hermite elements carry position + and tangent at every node, so the slope is continuous along the line, and the deflection of a + beam under its weight converges at fourth order with the mesh (measured slope 3.99). + Tension-only `EI = 0` elements serve chains, wire and fibre ropes in the same model. +- **An implicit solver.** Generalised-alpha integration with consistent mass and automatic step + subdivision: a snap load stays within 1.5 % of a 0.5 ms reference at a 20 ms step, where an + explicit lumped-mass step must stay near 1 ms. +- **Bend stiffeners and section curvature.** Tapered stiffener sleeves with their own mass, + buoyancy and drag; the curvature of the section, its two components on the section's own axes + (`CurvX`, `CurvY`) and the moments of the cable and of the sleeve, for fatigue. +- **Torsion.** A twist angle and polar inertia at every node, torque–tension coupling for + armoured cables, the buckling onset of a twisted line, and end restraints that are rigid, + elastic or free in twist. +- **Statics that start from the geometry alone.** No seed files: a catenary start, continuation in + bending stiffness and buoyancy, mesh sequencing and refinement to the bending length solve hard + lazy waves, long grounded runs, bathymetry and friction held as laid; a deck that has no + equilibrium stops with a named reason. +- **Coupled analysis.** OpenFAST and FAST.Farm coupling with checkpoint restart at any step, the + host's waves and current at every node, active line control, line failure, and linearisation + that carries the line dynamics as states. +- **More analyses.** Natural modes and shapes, cross-flow vortex-induced vibration of chains and + cables, viscoelastic and Syrope fibre ropes, buoyancy modules, clumps, rigid bodies and rods, + range graphs and seabed contact channels. +- **In-process hosts.** The C API and Python step a deck from a CFD code or a script, with the + host's fluid field at every node, saved and restored states and whole-line reads in one call. + +## Evidence + +Every capability above is tested, and the comparisons are published with their data and scripts +in the [validation record](https://cabledyn.readthedocs.io/en/latest/validation.html). A +selection: + +| Case | Reference | Result | +|---|---|---| +| Large-deflection elastica | Bisshopp–Drucker closed form | error 1.9e-6 | +| Lazy-wave cables at 80, 200 and 800 m, static | OrcaFlex 11.6d | peak curvature within 0.08, 0.26 and 4.8 % | +| Installed 800 m lazy-wave cable | OrcaFlex 11.6d | peak curvature 0.06 %, hang-off tension 0.15 % | +| Lazy wave in an irregular sea | OrcaFlex 11.6d, same 80-component sea | curvature 0.21 %, tension 0.20 % | +| Moving touchdown under heave | OrcaFlex 11.6d | curvature within 0.6 %, touchdown point within 0.08 m | +| Tapered bend stiffener at a clamped hang-off | OrcaFlex 11.6d | curvature 0.45 % of its root value, moments 0.01 % | +| Lazy-wave cable twisted five turns | OrcaFlex 11.6d | torque 0.019 %, peak curvature 0.049 % | +| One-hour VolturnUS-S chain mooring | OrcaFlex 11.6d | fairlead tension mean 0.27 %, standard deviation 0.26 % | +| Holcombe lazy-wave model test | measured geometry | position error 1.1–1.9 % of the suspended length | +| Bergdahl dynamic chain test, 30 conditions | measured end force | correlation 0.993 | +| IEA 15 MW VolturnUS-S in OpenFAST with a power cable | OpenFAST with MoorDyn | platform motions within 0.6 % | + +Run times on one processor thread, same host and protocol, with the timing scripts in +[`validation/performance`](https://cabledyn.readthedocs.io/en/latest/validation.html): + +| Case | CableDyn 0.4.2 | OrcaFlex 11.6d | +|---|---|---| +| 80 / 200 / 800 m lazy-wave spans, 60 s of heave | 1.3 / 2.4 / 5.0 s | 2.7 / 5.3 / 27.8 s | +| One-hour VolturnUS-S chain mooring | 4.3 s | 19.7 s | + +The method and the lazy-wave comparisons are peer-reviewed +([Ocean Engineering 368, 128332, 2026](https://doi.org/10.1016/j.oceaneng.2026.128332)). +Unsupported combinations stop with a named error rather than running approximately. ## Quick start @@ -51,8 +89,8 @@ a named error rather than running approximately. |---|---| | `CableDyn_driver.exe` | Standalone solver for Windows x64 (AVX2 processor) | | `openfast.exe` | OpenFAST with CableDyn available as `CompMooring = 5` | - | `cabledyn-0.4.1-py3-none-any.whl` | Python package (pre- and post-processing, batch runs) | - | `cabledyn-0.4.1.tar.gz` | Python source distribution | + | `cabledyn-0.4.2-py3-none-any.whl` | Python package (pre- and post-processing, batch runs) | + | `cabledyn-0.4.2.tar.gz` | Python source distribution | | `SHA256SUMS.txt` | Checksums for the assets above | Both executables are statically linked, need no installer, compiler, or runtime @@ -90,7 +128,7 @@ a named error rather than running approximately. cabledyn-run examples\wd0050_chain.dat wd0050 ``` - The pure Python wheel on the release page (`cabledyn-0.4.1-py3-none-any.whl`) + The pure Python wheel on the release page (`cabledyn-0.4.2-py3-none-any.whl`) carries no driver: `cabledyn-run` then needs `--executable .\CableDyn_driver.exe`, the `CABLEDYN_DRIVER` environment variable, or the driver on `PATH`. A source build names the driver `cabledyn` (see [Build from source](#build-from-source)); @@ -101,6 +139,11 @@ a CableDyn deck; ready-to-run cases are in [`examples/openfast`](https://cabledyn.readthedocs.io/en/latest/tutorial_openfast.html). Every shipped deck is listed in [`examples/`](https://cabledyn.readthedocs.io/en/latest/examples.html). +Coming from MoorDyn: CableDyn reads decks written in the MoorDyn v2 format (its section and +keyword names), so an existing mooring model runs as it is and can then take finite-EI sections, +stiffeners and the other features above; the +[migration guide](https://cabledyn.readthedocs.io/en/latest/migrating.html) lists the differences. + ## Documentation The manual at covers installation, tutorials, @@ -157,7 +200,7 @@ If you use CableDyn in academic work, please cite: > offshore wind. *Ocean Engineering* 368 (Part 2), 128332, 2026. > -To identify the software version, also cite the release (CableDyn 0.4.1). +To identify the software version, also cite the release (CableDyn 0.4.2). The [citation file](https://cabledyn.readthedocs.io/en/latest/citing.html) contains both entries (GitHub **Cite this repository**); BibTeX is on the manual's [How to cite](https://cabledyn.readthedocs.io/en/latest/citing.html) page. diff --git a/RELEASE.md b/RELEASE.md index 60bd59c4..0758dcda 100644 --- a/RELEASE.md +++ b/RELEASE.md @@ -104,7 +104,7 @@ The build fails if either executable imports a non-system DLL or lacks the UTF-8 active-code-page manifest (`release/check_static_windows_binary.ps1`), or if the standalone and `CompMooring = 5` smoke cases fail with a system-only `PATH` or from a folder named in mixed scripts. It also fails unless `openfast.exe -v` names the -executable `OpenFAST-v5.0.0-CableDyn-0.4.1`: the OpenFAST base and the CableDyn version, +executable `OpenFAST-v5.0.0-CableDyn-0.4.2`: the OpenFAST base and the CableDyn version, never a `-dirty` describe of the patched tree. The release workflow (`.github/workflows/release-windows-static.yml`) produces @@ -140,7 +140,7 @@ python release/smoke_test_wheel.py examples/dynamic_chain_current.dat --expect-b Tag only the commit that passed every check: ```powershell -$ReleaseVersion = "0.4.0" +$ReleaseVersion = "MAJOR.MINOR.PATCH" git tag -s "v$ReleaseVersion" -m "CableDyn v$ReleaseVersion" git push origin "v$ReleaseVersion" ``` diff --git a/VALIDATION.md b/VALIDATION.md index 722cc8db..f5d2257b 100644 --- a/VALIDATION.md +++ b/VALIDATION.md @@ -62,7 +62,7 @@ article's methods, are compared in | **L2-V** | VolturnUS-S anchor tension | closed-form catenary | 0.77% | <3% | Pass | | **L2-80** | Lozon 80 m all-chain mooring | catenary (H) / MoorDyn-F (fairlead) | 0.03% / 1.8% | <2% / <5% | Pass | | **L2-arb** | Closed-form catenary reference check | OrcaFlex VolturnUS-S ref | 0.69% | <2% | Pass | -| **L2-VIV** | Cross-flow VIV lock-in of a taut 100 m line, U = 0.06–0.42 m/s | MoorDyn-F (OpenFAST v5 `moordyn_driver`, `dtM` 5e-4 s) | mode-1 and mode-3 lock-in (U ≤ 0.18 and ≥ 0.36 m/s): mid-span A/D within 1.2%, frequency within one spectral bin; same response at `dtM` 5e-4 to 1e-2 s; at 0.21–0.33 m/s the codes settle on different modes (MoorDyn-F mode 1, CableDyn mode 2) | A/D <3%, frequency within one spectral bin (`viv_lockin`) | Pass scoped | +| **L2-VIV** | Cross-flow VIV lock-in of a taut 100 m line, U = 0.06–0.42 m/s | MoorDyn-C v2.7.2 (RK2, `dtM` 5e-4 s) and MoorDyn-F (OpenFAST v5 `moordyn_driver`, `dtM` 5e-4 s) | mode-1 and mode-3 lock-in (U ≤ 0.18 and ≥ 0.36 m/s): mid-span A/D within 1.2% of MoorDyn-F, frequency within one spectral bin; same response at `dtM` 5e-4 to 1e-2 s. At 0.21–0.33 m/s two branches coexist (a run ramped up from 0.18 m/s stays in mode 1, one ramped down from 0.30 m/s stays in mode 2): from rest CableDyn and MoorDyn-C settle in mode 2 (U 0.24 m/s: A/D 0.575 against 0.574 at x/L 0.24, same frequency); MoorDyn-F, whose phases start at zero (it does not carry its seed into its state), in mode 1, which `zero VIVphaseSeed` reproduces (0.701 against 0.699, transient to four digits) | A/D <3%, frequency within one spectral bin; band: 3% (MoorDyn-C), 1% (MoorDyn-F) (`viv_lockin`) | Pass | | **L2-VIV-riser** | Catenary riser of Thorsen et al. in a uniform 0.2 m/s current (MoorDyn-C's VIV test: D 0.024 m, EI 10.5 N m², 100 segments, `Cl` 0.7), deck written anchor first | measured cross-flow frequency 1.04 Hz; MoorDyn-C v2.7.2 (RK4, `dtM` 1e-4 s) | over 20–40 s at `dtM` 1e-3 s: mean fairlead tension 69.92 N against 69.93 N, range 3.73 N against 3.72 N, tension period 0.4853 s against the measured 0.4808 s and MoorDyn-C's 0.4811 s (0.4843 / 0.4829 s at `dtM` 5e-4 / 2.5e-4 s) | mean 0.2%, range 10%, period 1.5% (`viv_riser`) | Pass | | **L2-VIV-EI** | Cross-flow VIV of a finite-EI cable: the L2-VIV line with EI = 1 N m², and a bending-stiff line (EA 5e9 N, EI 5e7 N m², β = π²EI/(TL²) ≈ 1, neutrally buoyant) against the EI = 0 string of equal first-mode frequency, U = 0.10–0.36 m/s | CableDyn `EI = 0` line (verification) | EI = 1: mid/quarter A/D 0.662/0.421 against 0.663/0.421, same frequency, at `dtM` 5e-4 to 1e-2 s; stiff line: mode-1 lock-in A/D within 2.5% of the string's at the same frequency for U ≤ 0.24 m/s; for U ≥ 0.27 m/s the string jumps to mode 2 while the stiff line stays in mode 1 (bending raises f₂/f₁ to 3.15) | EI = 1: A/D within 1% at `dtM` 0.01 and 0.002 s (5e-4 s run once over 200 s); stiff line at U 0.21 m/s: A/D within 3%; frequency within one spectral bin; at U 0.30 m/s stiff line A/D > 0.6, string < 0.15 (`viv_lockin`, `hermite_viv`) | Pass | | **L3-1** | WD0050 static | OrcaFlex | 0.15 / 0.85% | <2% | Pass | @@ -88,9 +88,9 @@ article's methods, are compared in | **L4-rot** | Coupled mooring rotational stiffness | held 1° pitch geometry | upwind −16.0 kN, downwind +7.8 kN each; first-order restoring moment | signs + first-order | Pass | | **L5-stab** | Snap-load Δt-stability | sub-CFL fine-dt (0.5 ms) self-ref | peak 1.5% at dt = 20 ms (explicit limit 3.2 ms) | — | Pass | | **L5-stab** | Snap-load Δt-stability, implicit and explicit steps | MoorDyn-C explicit step limit | 20 ms implicit; ~1 ms explicit | — | Pass | -| **L5-V** | VolturnUS-S 1-hr mooring wall-clock | measured, matched protocol | CableDyn 18.1–32 s across repeated runs (full Newton) vs OrcaFlex 14.5 s; heave-only config 10.3 s | — | Pass (response at L3-7) | -| **L5-wc** | Wall-clock vs explicit C solver | external-C RK2 (WD chain) | L2 0.967 s vs external-C 0.541 s; traces validated | matched comparison reported | Pass measured | -| **L5-DPC** | Pinned-TDP lazy-wave spans, 80/200/800 m | OrcaFlex / refined MoorDyn-F | CableDyn 1.55/4.64/7.37 s; OrcaFlex 2.29/4.56/23.17 s; MoorDyn-F 249/145/243 s | resolved meshes, same host, one thread | Pass measured | +| **L5-V** | VolturnUS-S 1-hr mooring wall-clock | OrcaFlex 11.6d, same drive and host | CableDyn 4.30 s (IFX release) / 6.05 s (GNU) vs OrcaFlex 19.72 s; the timed deck reproduces the L3-7 response | — | Pass measured | +| **L5-wc** | Wall-clock, tension-only chain | MoorDyn-C v2.7.2, explicit RK2 (WD0050 chain) | CableDyn 0.197 s (IFX) / 0.268 s (GNU) vs MoorDyn-C 0.482 s; tensions 1.35 / 1.71% (mean / max) | matched comparison reported | Pass measured | +| **L5-DPC** | Pinned-TDP lazy-wave spans, 80/200/800 m | OrcaFlex / refined MoorDyn-F | CableDyn 1.34/2.37/4.98 s (IFX release; GNU 1.91/3.18/6.87 s); OrcaFlex 2.69/5.31/27.81 s; MoorDyn-F 327/192/321 s | resolved meshes, same host, one thread | Pass measured | | **L5-pk** | Snap-load peak, 3-code | MoorDyn-C + OrcaFlex | 4.86 / 6.32 / 10.22 MN | — | Informative | | **T-1** | Torsion kernel: twist of the centreline, gradient, Hessian | automatic differentiation; finite differences | ≤3.8e-15; ≤5.3e-11 | <1e-10; <1e-6 | Pass | | **T-2** | Pure torsion (multi-section, end springs, five turns) | `Φ/C`; OrcaFlex 11.6d | round-off; ≤1.7e-8 | <1e-12; <1e-7 | Pass | @@ -318,7 +318,7 @@ scripts, results, and source provenance are in over the full 30-condition period-radius matrix, cycle-maximum upper-end force has RMSE 1.58 N, mean absolute percentage error 3.11%, Pearson correlation 0.993, and Lin concordance 0.989. Two phase-averaged measured histories had - waveform RMSEs of 5.93% and 2.56% of their force ranges with 0.3.0 (not rerun for 0.4.0 or 0.4.1). + waveform RMSEs of 5.93% and 2.56% of their force ranges with 0.3.0 (not rerun for 0.4.0, 0.4.1 or 0.4.2). Halving the mesh length and the time step changes the mean cycle maximum by at most 0.29% and 0.27%. The 0.3125 ms step resolves the segment axial modes that the snap loads excite (and the axial @@ -505,49 +505,68 @@ scripts, results, and source provenance are in ### Wall-clock time -- **Tension-only chain (Pass measured)**: MoorDyn-C runs the 8 s snap in about - 0.03 s and CableDyn in about 0.26 s; cheap lumped-mass substeps make the explicit - model faster for this short axial-line problem. For the L2 WD0050/A1 80 s deck, - CableDyn takes **0.967 s** and the external-C RK2 calculation **0.541 s**; the - traces agree to 1.67 / 3.61% in mean / maximum fairlead tension. -- **VolturnUS-S one-hour mooring**: - -| Case | CableDyn | Reference | Note | -|------|----------|-----------|------| -| All-chain static IC | converged | OrcaFlex 2427 / MoorDyn 2439 kN | `FairTen` 2437 kN (0.42% / 0.08%); anchor 0.77% (L2) | -| 1-hour (3600 s) dynamic, heave-only config | **10.3 s** (dt=0.1 s, 36000 steps, 0 non-convergent, ~2 iterations/step) | — | throughput at production step | -| 1-hour dynamic, matched 2-component drive (L3-7) | **18.1–32 s** across repeated runs (full Newton) | OrcaFlex **14.5 s** | same drive and host | - -- **Finite-bending lazy-wave spans (L5-DPC)**: the 80, 200, and 800 m pinned-TDP - suspended spans are timed after spatial convergence, without grounded tail or - seabed contact. CableDyn uses 240, 480, and 960 Hermite elements at 0.05 s. - OrcaFlex uses independently checked segment lengths and the same step. MoorDyn-F - uses a fourfold-refined mesh and the largest step for which all reported - responses change by less than 0.01% on further halving. - -| Depth | CableDyn | OrcaFlex | Refined MoorDyn-F | -|------:|---------:|---------:|------------------:| -| 80 m | 1.55 s | 2.29 s | 249.07 s | -| 200 m | 4.64 s | 4.56 s | 144.61 s | -| 800 m | 7.37 s | 23.17 s | 243.08 s | - -Totals include initialisation and the same 60 s dynamic interval. The explicit MoorDyn-F -step is set by its stability limit on the fourfold-refined bending mesh, so these times reflect -the chosen resolution protocol rather than a general property of any code. Each value is the -median of three runs after one warm-up on one Intel Core i9-13900K thread. Model -sizes, timing ranges, memory, Newton work, and the OrcaFlex mesh sweep are in +The measurements below were made on 2026-11-08 and 2026-11-09 (CableDyn 0.4.2) on one host (AMD Ryzen Threadripper PRO 7965WX, +Windows 11 Pro) with one thread per code, as the median of three runs after one warm-up. They +come from [`validation/scripts/performance_records.py`](https://github.com/SMI-Lab-Inha/CableDyn/blob/main/validation/scripts/performance_records.py), +which also checks each timed model against its reference response. CableDyn is timed with the +Windows release driver (IFX, the shipped binary) and with a GNU Release build of the same source. Their +versions and hashes, the ranges and the timing definitions are in [`validation/performance`](https://github.com/SMI-Lab-Inha/CableDyn/blob/main/validation/performance/README.md). - -- **Hermite solver timings** (development workstation; machine-specific, not - portable tests): the banded solves reproduce the dense reference to identical - digits and Newton counts, and the dynamic step performs no heap allocation. The - 960-element Humboldt static solve takes 40.3 s and the 480-element solve 17.3 s; - the 240-element pinned-span static solve takes 471 Newton iterations direct and - 477 with mesh sequencing; the installed-cable sequence takes 529 coarse and - 20/60/14 polishing iterations; the 240-element 200 m dynamic case runs at - 2.21 ms per step with 3.95 Newton iterations per step; and the 78-component - irregular-wave lazy-wave comparison (the article's sea) runs in 66.6 s. -- **Coupled throughput**: at `dtM = 0.025 s` the one-line, 50-element aggregate +The figures depend on each code's configuration and on this host; they are not rankings. + +- **Tension-only chain (L5-wc)**: the WD0050 grounded chain (`examples/wd0050_chain.dat`) + under the L2-2 A1 heave for 80 s. CableDyn at dt 0.05 s takes **0.197 s** (IFX) and + **0.268 s** (GNU); MoorDyn-C v2.7.2 through `moordyn_c_driver.cpp` (explicit RK2, dtM 1 ms) + takes **0.482 s**, of which 0.452 s is its stepping loop. Over the 20 s scored window the + fairlead tensions of the two codes differ by 1.35% in mean and 1.71% in maximum. The + original external solver of this row was MoorDyn-C v2.6.1 through the same driver, whose deck + settings were not recorded. +- **VolturnUS-S one-hour mooring (L5-V)**: the L3-7 drive (5 m / 90 s surge and 2 m / 12 s + heave of the fairlead) on one 850 m chain with 50 elements. + +| Case | CableDyn (IFX) | CableDyn (GNU) | OrcaFlex 11.6d | Note | +|------|---------------:|---------------:|---------------:|------| +| All-chain static IC, `FairTen` | 2437 kN | 2437 kN | 2427 kN | 0.42% from OrcaFlex, 0.08% from MoorDyn (2439 kN); anchor 0.77% (L2) | +| 1-hour dynamic, dt 0.1 s | **4.30 s** (4.26–4.31) | **6.05 s** (6.00–6.09) | **19.72 s** (19.33–19.74) | 36,000 steps, 2.03 Newton iterations per step; OrcaFlex adds a 200 s build-up | + + The timed CableDyn deck reproduces the L3-7 response: fairlead tension mean, standard + deviation, minimum and maximum within 0.27, 0.26, 0.50 and 0.43% of OrcaFlex. + +- **Finite-bending lazy-wave spans (L5-DPC)**: the 80, 200 and 800 m pinned-touchdown + suspended spans of the L3-6 protocol (3 m / 12 s hang-off heave, 60 s), without grounded tail + or seabed contact. CableDyn uses 240, 480 and 960 Hermite elements at 0.05 s; OrcaFlex uses + 0.75 m segments (179, 350 and 1227) at the same step; MoorDyn-F uses its native meshes refined + fourfold (208, 224 and 232 segments) at the largest explicit step for which halving the step + moves every scored response by less than 0.01% (0.125 ms at 80 and 200 m, 0.5 ms at 800 m, + re-checked in this run: halving moved them by at most 0.0005%). + +| Depth | CableDyn (IFX) | CableDyn (GNU) | OrcaFlex | Refined MoorDyn-F | +|------:|---------------:|---------------:|---------:|------------------:| +| 80 m | 1.34 s | 1.91 s | 2.69 s | 326.6 s | +| 200 m | 2.37 s | 3.18 s | 5.31 s | 191.9 s | +| 800 m | 4.98 s | 6.87 s | 27.81 s | 320.7 s | + +Totals include initialisation and the dynamic interval. The timed CableDyn and refined +MoorDyn-F models reproduce the OrcaFlex hang-off tension mean, minimum and maximum of the L3-6 +gate within 0.12% and 0.29%. The explicit MoorDyn-F step is set by its stability limit on the +fourfold-refined bending mesh, so these times reflect the chosen resolution protocol rather than +a general property of any code; the MoorDyn-F totals include its dynamic-relaxation +initialisation. CableDyn takes 2.7–3.3 linear solves per step, and no step needs recovery +subdivision. + +- **Cubic-Hermite solver work** (GNU Release build of `dev` on the same host; the iteration + counts are deterministic, the times are not): the 240-element pinned Humboldt span + (`hermite_sequenced`) takes 507 Newton iterations solved directly and 460 with mesh + sequencing (450 / 4 / 6 by level); the installed 800 m cable (`l3_lazywave_fullcable`) takes + 524 iterations on its 89-element mesh and 20 / 60 / 14 to polish at 178 / 356 / 712 + elements; the mesh-sequenced 480- and 960-element static solves of `l3_lazywave_refinement` + take 81 and 4 iterations and 0.1 s or less each; and the irregular-sea comparison in the + article's 78-component sea (`test_l3_lazywave_irregular OUT TABLE.dat`, the table written by + `orcaflex_lazywave_irregular_reference.py --orcaflex-jonswap`) runs in 10.9 s. The per-step + advance of the OpenFAST aggregate route, Hermite cables included, makes no heap allocation + (`step_allocations`). +- **Coupled throughput** (measured in September 2026 with the code of that date on an Intel Core + i9-13900K; not re-measured for the records above): at `dtM = 0.025 s` the one-line, 50-element aggregate advances at 0.540 ms per step and the three-line spread at 0.590 ms per step; these are mooring-module figures only. With `OpenFAST DT = CableDyn dtM = OpenFAST DT_Out = 0.025 s`, uninterrupted 4200 s @@ -556,7 +575,7 @@ sizes, timing ranges, memory, Newton work, and the OrcaFlex mesh sweep are in and **1399.44 s** with an added 55-element suspended finite-EI power cable (a variant of the mixed example without touchdown), using default full-Newton settings (no `dynamic_solver` override, no modified Newton, no adaptive - remeshing), on the development workstation. Each binary output has + remeshing). Each binary output has exactly 144,001 rows from 600 s to 4200 s with 47 channels. The OpenFAST runtime Jacobian is the fixed-state direct-feedthrough derivative; formal linearisation differentiates the line dynamics with the line states registered. @@ -743,17 +762,28 @@ cannot restart the buoyancy ramp. AutoMesh warm-start refinement is tested by buoyant fraction. Each is solved by the production mesh-sequenced solver from a library-built trivial seed (`CD_HermiteCable_Trivial_Seed`: endpoints, rest lengths, and seabed in; isometric seed out; no catenary, seed files, or per-case -tuning). Result: **117 pass, 3 known failures, 2 cases annotated as known failures -that now pass, 0 unexpected failures, and 0 silent wrong answers**. Known-failure -annotations are checked both ways: an annotated case must either fail cleanly or be -reported when it passes. +tuning). Result: **118 pass, 4 known failures, 0 unexpected failures, and 0 silent +wrong answers**, the same on every OpenBLAS kernel. Known-failure annotations are checked +both ways: an annotated case must either fail cleanly or be reported when it passes. + +The deck route solves all 122 cases but the one beyond the L-shape bound that it refuses by +name: a deck seeds a line with a buoyant section as a lazy wave, starts it from the +`EI = 0` catenary and refines a kinked state locally, never this kernel from the trivial seed. +Run through the standalone driver on both `cable_statics` routes, the 121 equilibria agree +between the routes to 1.3e-7 in tension and 1e-5 m in position, with `max(h*kappa)` at most +0.56. The four known failures of the kernel and the former fifth are cases of the +`cable_statics_matrix` test (entries `SIS_*`, both routes): where the arch stays submerged +their fairlead tension is within 2.4e-4 of an independent elastic multi-segment `EI = 0` +catenary; two float their arch at the surface. - On a frictionless bed, a smooth planar equilibrium exists only while the rest length is below the L-shape bound `L < h_fairlead + x_anchor`; beyond it the surplus must fold on the bed. The slack axis runs to 0.97× the bound. A separate family crosses it and must return either a clean error or a finite - bounded-curvature solution, never NaN or a silent cusp. The three known failures - are hard contact cases at the lowest EI of the sweep (5e2 N·m²). + bounded-curvature solution, never NaN or a silent cusp. The four known failures + are lazy waves at the lowest EI of the sweep (5e2 N·m²): from the trivial seed the + kernel reaches a residual-converged kink of a few elements in mid-water, which the + check below rejects. - A residual-converged state is not sufficient: the solver rejects an element-localised branch when `max(h*kappa) > 0.7`, so a folded equilibrium cannot enter dynamics. diff --git a/doc/capi.rst b/doc/capi.rst index a4d00fd6..7c7593dd 100644 --- a/doc/capi.rst +++ b/doc/capi.rst @@ -122,12 +122,12 @@ files directly, as shown below. - Library files - Header * - Linux - - ``lib/libcabledyn.so.0.4.1``, the soname link ``libcabledyn.so.1``, and the development + - ``lib/libcabledyn.so.0.4.2``, the soname link ``libcabledyn.so.1``, and the development link ``libcabledyn.so``. ``lib`` is the platform ``CMAKE_INSTALL_LIBDIR``, which can be ``lib64`` or a multiarch directory. - ``include/CableDyn_CAPI.h`` * - macOS - - ``lib/libcabledyn.0.4.1.dylib``, ``lib/libcabledyn.1.dylib``, ``lib/libcabledyn.dylib`` + - ``lib/libcabledyn.0.4.2.dylib``, ``lib/libcabledyn.1.dylib``, ``lib/libcabledyn.dylib`` - ``include/CableDyn_CAPI.h`` * - Windows, GNU toolchain - ``bin/libcabledyn.dll`` and the import library ``lib/libcabledyn.dll.a``. The GNU @@ -257,7 +257,7 @@ ABI and versioning - the same four numbers, reported by the loaded library * - ``CableDyn_GetVersionString`` - runtime - - ``"CableDyn 0.4.1 C-ABI 1"`` + - ``"CableDyn 0.4.2 C-ABI 1"`` * - shared-library ``SOVERSION`` - 1 - soname ``libcabledyn.so.1`` or install name ``libcabledyn.1.dylib``. The Windows DLL @@ -830,7 +830,7 @@ Version queries - ``char *`` - ``version_len`` - yes: no-op - - receives ``"CableDyn 0.4.1 C-ABI 1"``, truncated to ``version_len - 1`` characters and + - receives ``"CableDyn 0.4.2 C-ABI 1"``, truncated to ``version_len - 1`` characters and ``NUL``-terminated * - ``version_len`` - in @@ -1024,7 +1024,10 @@ The deck is validated under the standalone-deck rules: The C ABI has no simulation clock and no per-node fluid input. A deck's current is applied as a steady field. A deck with a ``waves`` option, or a MoorDyn-C ``Currents 2``/``5`` table that varies in time, is rejected with ``CD_C_BAD_INPUT``, because it could not be evaluated - in time; such a table constant in time is applied as the steady field. Time-varying fluid kinematics reach the ``Free`` + in time; such a table constant in time is applied as the steady field. On a deck of + ``EI = 0`` lines the field is sampled at every node of the static state and again at the + step-start nodes before every ``CableDyn_Step``, as the standalone driver samples it, so a + depth profile or grid follows the line. Time-varying fluid kinematics reach the ``Free`` and ``Connect`` points through ``CableDyn_UpdatePointFluidFields``. Parse and validation failures, including a file that cannot be opened, return @@ -1449,7 +1452,8 @@ is stored. A non-finite field returns ``CD_C_BAD_INPUT``. - ``double`` - -- - -- - - step size [s], finite and greater than 0 + - step size [s], finite and at least ``1e-100`` (the time integration divides by + ``dt**2``; a smaller step is ``CD_C_BAD_INPUT``) * - ``q_coupled``, ``v_coupled``, ``a_coupled`` - in - ``const double *`` diff --git a/doc/citing.rst b/doc/citing.rst index 252c45c8..de9623bd 100644 --- a/doc/citing.rst +++ b/doc/citing.rst @@ -53,7 +53,7 @@ software]. https://github.com/SMI-Lab-Inha/CableDyn } When results depend on a particular release, quote the version reported in the solver banner -(``CableDyn v0.4.1``) together with the options recorded for the run. +(``CableDyn v0.4.2``) together with the options recorded for the run. Relation to the journal article ------------------------------- diff --git a/doc/cli.rst b/doc/cli.rst index 6003ec44..9abd9670 100644 --- a/doc/cli.rst +++ b/doc/cli.rst @@ -208,7 +208,11 @@ The counts follow the march: torsion and consistent-acceleration solves count to the rest. * **Finite-EI cable assembly time** splits the residual and tangent assemblies into their sections. The tangent element kernels evaluate the structural, damping, drag and wave - tangents of each element together; the other sections are the element residuals, the weight + tangents of each element together. A residual evaluation that a tangent is expected to follow + at the same state (the predictor of a step, and the full Newton step of an iteration the + previous step went past) runs them with the element loads, so their time then counts to the + residual assembly and the tangent assembly only scatters their blocks; the other sections + are the element residuals, the weight and supports, the attachments, the dry-part buoyancy, the seabed contact, the axial damping, the drag, the end connections, the wave and held Froude-Krylov loads and the torsion. The sections also count the assemblies made outside the step (reactions, end moments and diff --git a/doc/coupling_boundary.md b/doc/coupling_boundary.md index 7985a2d6..4caf90cf 100644 --- a/doc/coupling_boundary.md +++ b/doc/coupling_boundary.md @@ -117,7 +117,7 @@ Rules shared by every entry point: The interface ships as the versioned shared library `libcabledyn` (`cabledyn.dll` in an Intel Fortran and MSVC build; CMake target `cabledyn_shared`) with the installed header; it reports -CableDyn 0.4.1 and C ABI version 1, minor extension 4. The Python package uses the same library. +CableDyn 0.4.2 and C ABI version 1, minor extension 4. The Python package uses the same library. ### Concurrency diff --git a/doc/driver_format.md b/doc/driver_format.md index 84d808ed..dabaf1f0 100644 --- a/doc/driver_format.md +++ b/doc/driver_format.md @@ -237,7 +237,7 @@ Inside OUTPUTS, a row whose first token is `END` also closes the channel list. | `Diam` | hydrodynamic / volume-equivalent diameter [m] | used for submerged weight, drag, and added mass; at least 1e-6 and at most 1e3 where used | | `MassDenInAir` | dry mass per unstretched metre [kg/m] | submerged weight = (m − ρ_w·πd²/4)·g; its magnitude at most 1e6 where used | | `EA` | axial stiffness [N] | linear (T = EA·ε); at least 1e-3 and at most 1e15 where used; see the viscoelastic and Syrope forms below | -| `BA/-zeta` | axial damping: ≥ 0 is BA [N·s], < 0 is −ζ (damping ratio) | active in EI = 0 and finite-EI dynamics; ignored in a static-only run | +| `BA/-zeta` | axial damping: ≥ 0 is BA [N·s], < 0 is −ζ (damping ratio): by default (MoorDyn's convention) of each segment, BA = ζ L0 √(EA m) per element, which damps the line's first axial mode at about ζ π/(2N) on N elements and so depends on the mesh (a run notes the ratio); under `mode1 axialDampingRatio` of the line's first axial mode, on any mesh (see the OPTIONS table) | active in EI = 0 and finite-EI dynamics; ignored in a static-only run | | `EI` | bending stiffness [N·m²] | finite and ≥ 0; see [EI routing](#ei-routing) | | `Cd_n`, `Cd_t` | normal / tangential drag coefficients | used by EI = 0 dynamic current and Airy-wave runs | | `Ca_n`, `Ca_t` | normal / tangential added-mass coefficients | used by EI = 0 dynamic Froude–Krylov and added-mass runs | @@ -306,10 +306,10 @@ and `BA = BA_s|BA_d`: waves, host fluid fields and VIV of any `EI = 0` line, and active line control of a Syrope segment on the OpenFAST route ([CONTROL](#control-optional-openfast-line-control)). - The static start solves each Syrope element on the rest curve of its load history (the OWC, or - the `Tmax0` working curve under `SYROPE IC`). A single-section line takes one secant EA from the - curve at its mean strain; on a composite line, where the tension varies along a sagging Syrope - section, every Syrope element takes its own secant at its own tension, so every element starts - on its curve and the dynamics start in the static equilibrium. + the `Tmax0` working curve under `SYROPE IC`). The tension varies along a Syrope section (a + sagging section of a composite line, or the weight of a long or inclined taut rope), so every + Syrope element takes its own secant EA at its own tension: every element starts on its curve + and the dynamics start in the static equilibrium. The settings-file grammar is in [Auxiliary file formats](file_formats.rst). @@ -527,7 +527,10 @@ A line's End A attaches to a body through a `Body` point; the point's positi fairlead offset in the body frame. - A `Point3` body supports exactly one attachment point, which becomes a dynamic point with the - body's `Mass`/`Vol`/`CdA`/`Ca`. + body's `Mass`/`Vol`/`CdA`/`Ca`. The static solve does not place it: it starts at its deck + position. Under `bodyIC static` (the default) a run whose buoy is not balanced there notes the + unbalanced force and the distance to its static balance as a `Free` point; give the deck + position of that balance, or set `bodyIC deck` to start it off balance on purpose. - A `Rigid6` body transfers structural force and moment through rigid attachment kinematics, plus lumped translational current and wave hydrodynamics from `CdA`/`Ca`. Rotational body hydrodynamics are not modelled. @@ -1041,11 +1044,14 @@ Behaviour: with the same drag law at rest, so a run in a current starts in equilibrium. An attachment above the free surface carries its weight only, in the static initial condition too. Attachments have no seabed contact of their own; the node's contact acts on the line. -- The static equilibrium is solved first with each attachment's net weight spread over the two - elements at its node, then carried to the discrete loads by continuation. The current drag +- The static equilibrium is solved first with each attachment's net weight, and in a current + across the vertical plane of the line its drag areas, spread over the two elements at its node, + then carried to the discrete loads by continuation. The current drag depends on the node's position and line direction, and the weight on the side of the surface an attachment is on, so the final solve is repeated until the node positions change by less - than 1e-9 m and no attachment changes side. On a line restrained in torsion the torsion stage + than 1e-9 m and no attachment changes side. A residual floor above the tight static tolerance + is accepted at the coupled static tolerance 1e-6, as on a line without attachments, and noted + with the residual reached. On a line restrained in torsion the torsion stage (the imposed twist) follows on the discrete equilibrium, with the attachments' net weights and drag as nodal loads (the drag again to a fixed point), so a run starts in the twisted equilibrium. An attachment adds no polar inertia to the line's twist. @@ -1272,6 +1278,7 @@ syntax form. The most frequently edited keywords are: | `cable_load_feedback` | coupled finite-EI cable reaction switch. `True` returns cable force and moment to the host. `False` marches the cable with the same moving boundary and host fluid field and keeps its output channels, but returns zero force and moment; use it for a one-way comparison, not as a physical model | `True` | | `adaptive_mesh` | `True`/`False`; allow finite-EI mesh refinement when the static resolution check is fragile | `False` | | `cable_statics` | `continuation` or `sequenced`: which finite-EI static route runs first (the other is its fallback); both results are audited | `continuation` | +| `axialDampingRatio` / `axial_damping_ratio` | `segment` or `mode1`: what a negative `BA` is the damping ratio ζ of. `segment` (MoorDyn's convention): of each segment, BA = ζ L0 √(EA m) per element, so the line's first axial mode is damped at about ζ π/(2N) on N elements and less on a finer mesh; a dynamic run notes that ratio. `mode1`: of the line's first axial mode (both ends held, dry mass, from its sections, so the same on any mesh): BA = 2 ζ EA / ω1 on every element, a damping proportional to the stiffness, so the axial mode n is damped at ζ ωn/ω1. A line with a negative `BA` and a viscoelastic or Syrope section is refused under `mode1` | `segment` | | `OutputRecovery` / `output_recovery` | `equilibrium` or `element`: definition of the finite-EI node tension, curvature, bend moment and segment tension. `equilibrium` recovers them from nodal equilibrium (the effective tension F·t, the moment the neighbouring elements carry, curvature = moment / EI); `element` reports the length-weighted element-mean axial force EA(\|r'\| − 1), the larger one-sided exact curvature, and the element-midpoint axial resultant as segment tension. End forces, positions and TDP channels are the same under both | `equilibrium` | | `alpha_force_blend` | `True`/`False`; generalised-α blend of the finite-EI and `EI = 0` dynamics: forces (`True`) or the configuration `q_αf` (`False`), which biases the mean tension of a rotating finite-EI line at large `dtM` and lets `EI = 0` segments that go slack report spurious tension spikes | `True` | | `tensile_safety` | `False`, `warn`, or `True`; audits the element-mean axial force (three-point Gauss mean of the signed axial resultant, averaged over an element and its two neighbours). `True` rejects. `warn` commits the state, counts accepted-step events, and reports the worst force, threshold, element and time (the printed `xi` is always 0.5, the element centre) | `False` | @@ -1356,7 +1363,9 @@ every node's position and time as MoorDyn-C interpolates them. Standalone decks - a grid holds at most 2e6 resampled points in space and time (every static solve holds a copy, 48 MB at the limit); - the C API and the OpenFAST point-system shells have no simulation clock: they apply a current - constant in time as a steady field, as `Currents 1`, and refuse one that varies in time; + constant in time as a steady field, as `Currents 1`, sampled at the nodes of the static state + and, through the C API, at the step-start nodes before every step, and refuse one that varies + in time; - `current_profile_4d.txt` is read as MoorDyn-C documents it, which MoorDyn-C v2.7.1 does not quite do: it reads its rows from line 7, so a row on line 6 leaves that grid point at zero, and it matches a row to the grid by the text of its coordinates, so a row writing `-0` for `0` or diff --git a/doc/examples.rst b/doc/examples.rst index cb8abf50..994bcd4d 100644 --- a/doc/examples.rst +++ b/doc/examples.rst @@ -97,6 +97,11 @@ Mooring configurations - chain–polyester–chain: one line, three ordered sections - cable, static - < 1 s + * - ``composite_chain_poly_chain_modes.dat`` + - the 12 lowest natural periods and mode shapes (``nModes``) of that composite line, partly + grounded, with each section's added mass and the linearised seabed contact + - cable, modal + - < 1 s * - ``semitaut_chain_polyester.dat`` - Lozon et al. (2025) Gulf of Maine 200 m semi-taut composite (chain at the anchor, polyester above) @@ -163,6 +168,12 @@ for the equations, the viscoelastic (series-Kelvin) and Syrope sections of :doc: needs ``data/syrope/`` and ``data/vessel/vessel_surge_heave_pitch_12s_dt005.txt`` - cable, dynamic - < 1 s + * - ``composite_ve_syrope_jonswap.dat`` + - two chain–polyester–chain legs of one floater, the polyester viscoelastic (``Es|Ed``) on + one and Syrope on the other, the floater moved by ``data/vessel/sample_rao.txt`` + (``vesselRAO``) in a JONSWAP sea that also loads the lines: the two rope models side by side + - cable, dynamic + - ~2 s Dynamic environment ------------------- @@ -203,6 +214,18 @@ Dynamic environment (``current_profile.txt``) read from the deck folder — :doc:`tutorial_dynamics` - cable, dynamic - < 1 s + * - ``moordynC_currents/chain_wavekin3_currents2.dat`` + - MoorDyn-C ``WaveKin 3`` (the elevation record ``wave_elevation.txt``, reduced to its + Fourier components) and ``Currents 2`` (``current_profile_dynamic.txt``: a sheared current + that turns across the line and grows over the run) on a partly grounded chain held by + seabed friction + - cable, dynamic + - < 1 s + * - ``moordynC_currents/chain_currents5_grid.dat`` + - MoorDyn-C ``Currents 5``: the grid in x, y, z and time ``current_profile_4d.txt``, a cross + current growing along the line and ramped in over 30 s + - cable, dynamic + - < 1 s * - ``stream_wave_shallow_chain.dat`` - the 30 m R4 chain under a steep Dean stream-function wave (H 8 m, T 10 s, ``StreamOrder`` 20) — :doc:`tutorial_dynamics` @@ -223,6 +246,25 @@ Dynamic environment (``frictionMuAxial`` 0.3, ``frictionMuLateral`` 1.0) — :doc:`tutorial_dynamics` - cable, dynamic - < 1 s + * - ``chain_sloped_bathymetry_friction.dat`` + - the chain of ``chain_range_tdp.dat`` on a structured seabed (``bathymetryFile`` + ``data/bathymetry/sloped_seabed.txt``) that rises toward the anchor and slopes across the + line, held by seabed friction from its as-laid layout (``staticsFriction asLaid``) under + the surging fairlead + - cable, dynamic + - < 1 s + * - ``composite_axial_damping_mode1.dat`` + - the chain–polyester–chain mooring under a 4 m Airy wave with ``axialDampingRatio mode1``: + a negative ``BA`` of −0.02 damps the line's first axial mode (2.03 Hz) at 2 % on any mesh + - cable, dynamic + - < 1 s + * - ``viv_taut_line_crossflow.dat`` + - cross-flow VIV (``LINE TYPES`` ``Cl``, ``dF``, ``cF``; ``VIVphaseSeed``, + ``VIVrmsWindow``): a taut 100 m line locks in across a 0.15 m/s current at a mid-span + amplitude A/D of 0.66, MoorDyn-F's; the ``Outputs`` flag ``V`` writes the nodal lift — + :ref:`theory-viv` + - cable, dynamic + - ~2 s Points, buoys, bodies, and rods ------------------------------- @@ -360,7 +402,7 @@ touchdown and lazy-wave shape from the geometry alone; there is no initial-shape - the 10 lowest natural periods and mode shapes (``nModes``) of the 80 m cable on its 1024-element mesh — :doc:`tutorial_lazywave` - Hermite, modal - - ~2 s + - ~1 s * - ``torsion_lazy_wave_hangoff_twist.dat`` - the 80 m cable with an illustrative ``GJ`` of 50 kN·m², clamped and restrained in torsion at both ends, twisted two turns at the hang-off over 60 s by the ``motionFile`` roll column @@ -370,6 +412,26 @@ touchdown and lazy-wave shape from the geometry alone; there is no initial-shape :ref:`theory-torsion` - Hermite, dynamic - ~2 s + * - ``torsion_free_end_armoured_cable.dat`` + - the 80 m cable with an illustrative torque–tension coupling (``GJ|K|Bt``), restrained in + torsion at the hang-off and free to twist at the anchor: the stretch twists the line + (``Twist1`` −5.6°), and under the 3 m hang-off heave the twist oscillates through torsional + waves whose torque the hang-off takes (``Torq1N1``) — :ref:`theory-torsion` + - Hermite, dynamic + - ~2 s + * - ``lazy_wave_modules_stiffener.dat`` + - the 80 m cable with ten discrete buoyancy modules (``ATTACHMENTS``) and a 4 m bend + stiffener (``STIFFENERS``) at its clamped hang-off on the vessel of + ``lazy_wave_vessel_motion.dat``, in a 0.3 m/s current; the range graph (``Outputs`` flag + ``r``) of the finite-EI line + - Hermite, dynamic + - ~2 s + * - ``shared_cable_two_floaters.dat`` + - a 360 m array cable hung between the clamped hang-offs of two floaters 300 m apart, both + ends moving (two ``Coupled`` points, ``data/shared/floaters_surge_heave_12s_dt0025.txt``): + the span opens and closes by 4 m + - Hermite, dynamic + - ~1 s The first three set ``TMax = 0`` (static only). The motion file holds absolute position, velocity, and acceleration at every ``dtM`` and is regenerated by @@ -437,4 +499,11 @@ These files are inputs referenced by decks, not decks: ``torsion_lazy_wave_hangoff_twist.dat``; ``data/torsion/generate_hangoff_roll.py`` writes it. * ``moordynC_wavekin/wave_frequencies.txt`` and ``moordynC_wavekin/current_profile.txt`` — the MoorDyn-C kinematics files, read from the folder of the deck beside them. +* ``moordynC_currents/wave_elevation.txt``, ``current_profile_dynamic.txt`` and + ``current_profile_4d.txt`` — the MoorDyn-C files of the two decks in that folder; + ``moordynC_currents/generate_kinematics.py`` writes them. +* ``data/shared/floaters_surge_heave_12s_dt0025.txt`` — the hang-off motions of both ends of + ``shared_cable_two_floaters.dat``; ``data/shared/generate_floater_motion.py`` writes it. +* ``data/bathymetry/sloped_seabed.txt`` — the ``x y depth`` grid of + ``chain_sloped_bathymetry_friction.dat``. * ``plot_range_envelope.py`` — plots the tension envelope of a range-graph file. diff --git a/doc/index.rst b/doc/index.rst index 33e0d2fa..81e9d1f7 100644 --- a/doc/index.rst +++ b/doc/index.rst @@ -14,10 +14,12 @@ with MoorDyn-C, MoorDyn-F, and OrcaFlex on common reference cases. .. admonition:: Release status :class: note - CableDyn ``v0.4.1`` is the current stable release. It is on PyPI with wheels that carry the - solver (``pip install cabledyn``), runs 13-33 % faster in the release build, extrapolates the - coupled loads between OpenFAST solves at a ``dtM`` above ``DT``, restarts bit for bit at any - ``dtM``, and recovers node tension through touchdown on coarse meshes. + CableDyn ``v0.4.2`` is the current stable release. It is on PyPI with wheels that carry the + solver (``pip install cabledyn``). It makes the modal analysis of long lines and the + finite-EI dynamic step faster, holds the finite-EI static solve to its tolerance on graded + meshes, in cross currents, with attachments, ``Rigid`` ends and as-laid friction, gives a + mesh-independent axial damping ratio (``axialDampingRatio mode1``), and runs every shipped + example deck in its test suite. Every comparative-accuracy statement is linked to a passing benchmark in :doc:`validation`. The project remains below ``1.0.0``, so public APIs may evolve between minor releases. @@ -53,8 +55,8 @@ Download to first result in five minutes ---------------------------------------- #. Download ``CableDyn_driver.exe``, ``SHA256SUMS.txt``, and **Source code (zip)** (for the - ``examples`` folder) from the `v0.4.1 release - `_ and verify the checksum — + ``examples`` folder) from the `v0.4.2 release + `_ and verify the checksum — :doc:`installation`. No installer and no runtime DLLs. #. Put ``CableDyn_driver.exe`` in a working folder, unzip the source archive, and copy its ``examples`` folder next to the executable. diff --git a/doc/installation.rst b/doc/installation.rst index dde97b84..65f1395c 100644 --- a/doc/installation.rst +++ b/doc/installation.rst @@ -6,8 +6,8 @@ Installation There are two ways to get CableDyn: * **Windows release (recommended for users).** Two single-file executables and a Python wheel, - attached to the `v0.4.1 GitHub release - `_. No installer, no compiler, + attached to the `v0.4.2 GitHub release + `_. No installer, no compiler, and no runtime DLLs. Start here if you want a first result in five minutes. * **Build from source** (Windows, Linux, macOS). Needed for the C/Python in-process API, for development, and on every platform other than Windows x64. @@ -35,11 +35,11 @@ What is on the release page - OpenFAST v5.0.0 (maintained by NLR, the National Laboratory of the Rockies, formerly NREL) with CableDyn built in as ``CompMooring = 5``; stock MoorDyn (``CompMooring = 3``) is still available in the same binary (:doc:`openfast`). It names - itself ``OpenFAST-v5.0.0-CableDyn-0.4.1`` (``openfast.exe -v`` and the start of every run). - * - ``cabledyn-0.4.1-py3-none-any.whl`` + itself ``OpenFAST-v5.0.0-CableDyn-0.4.2`` (``openfast.exe -v`` and the start of every run). + * - ``cabledyn-0.4.2-py3-none-any.whl`` - the pure-Python package: deck editing, case generation, driver automation, result readers, fatigue and spectral post-processing (:doc:`python`) - * - ``cabledyn-0.4.1.tar.gz`` + * - ``cabledyn-0.4.2.tar.gz`` - the Python source distribution (same package as the wheel) * - ``SHA256SUMS.txt`` - SHA-256 checksums of the four files above @@ -65,7 +65,7 @@ Download and verify ~~~~~~~~~~~~~~~~~~~ 1. Create a folder, for example ``C:\CableDyn``, and download into it ``CableDyn_driver.exe``, - ``openfast.exe`` (only if you will couple with OpenFAST), ``cabledyn-0.4.1-py3-none-any.whl`` + ``openfast.exe`` (only if you will couple with OpenFAST), ``cabledyn-0.4.2-py3-none-any.whl`` (only if you will use Python), ``SHA256SUMS.txt``, and ``Source code (zip)``. 2. Verify every downloaded asset against ``SHA256SUMS.txt`` in PowerShell: @@ -85,8 +85,8 @@ Download and verify OK CableDyn_driver.exe OK openfast.exe - OK cabledyn-0.4.1-py3-none-any.whl - not downloaded cabledyn-0.4.1.tar.gz + OK cabledyn-0.4.2-py3-none-any.whl + not downloaded cabledyn-0.4.2.tar.gz ``not downloaded`` only reports an asset you chose to skip. @@ -95,7 +95,7 @@ Download and verify ``(Get-FileHash .\CableDyn_driver.exe -Algorithm SHA256).Hash`` with its line in ``SHA256SUMS.txt`` (the comparison is case-insensitive). -3. Unzip ``Source code (zip)``. It expands to a folder such as ``CableDyn-0.4.1``; copy (or move) +3. Unzip ``Source code (zip)``. It expands to a folder such as ``CableDyn-0.4.2``; copy (or move) its ``examples`` folder into ``C:\CableDyn`` so the layout is:: C:\CableDyn\ @@ -121,7 +121,7 @@ Check that it runs .. code-block:: text =================================================================== - CableDyn v0.4.1 + CableDyn v0.4.2 Geometrically exact finite-element statics and dynamics of mooring lines and dynamic power cables for floating offshore wind ------------------------------------------------------------------- @@ -177,8 +177,8 @@ the CableDyn shared library and the standalone driver, so the package runs decks release executables. On another platform pip builds from the source distribution, which needs a Fortran compiler and LAPACK. -The pure Python wheel on the release page (``cabledyn-0.4.1-py3-none-any.whl``) carries no -solver; install it with ``py -m pip install .\cabledyn-0.4.1-py3-none-any.whl``. The package +The pure Python wheel on the release page (``cabledyn-0.4.2-py3-none-any.whl``) carries no +solver; install it with ``py -m pip install .\cabledyn-0.4.2-py3-none-any.whl``. The package finds the driver in this order: #. an explicit path, ``CableDynDriver(r"C:\CableDyn\CableDyn_driver.exe")`` or @@ -273,7 +273,7 @@ The script downloads the LAPACK source from its release tag and verifies its SHA integration to OpenFAST itself (do not pre-apply it), builds both executables, rejects any non-system DLL import, runs a standalone and a coupled ``CompMooring = 5`` / ``CompMooring = 3`` smoke case with a system-only ``PATH``, and writes -``SHA256SUMS.txt`` into ``build-static-release\dist``. The v0.4.1 assets were built from +``SHA256SUMS.txt`` into ``build-static-release\dist``. The v0.4.2 assets were built from OpenFAST revision ``2895884d2be01862173c88d70f86b358d2f1a50a`` and smoke-tested against ``r-test`` revision ``dd5feaaaa500ba7283140107806300d551cff0a7``. diff --git a/doc/openfast.rst b/doc/openfast.rst index fc7f65c7..d944fefe 100644 --- a/doc/openfast.rst +++ b/doc/openfast.rst @@ -223,7 +223,7 @@ Run and confirm Before trusting a run, confirm in the console: -#. ``Running CableDyn (v0.4.1, ...)`` and ``Parsing CableDyn input file: ``; +#. ``Running CableDyn (v0.4.2, ...)`` and ``Parsing CableDyn input file: ``; #. the ``dtM`` line and the model inventory (``Created CableDyn model: ... line object(s)``); #. for every line, the converged fairlead effective tension, force vector, inclination, declination, and azimuth at the static equilibrium — printed unconditionally, whether or not diff --git a/doc/options.rst b/doc/options.rst index ca74bbde..e259ba35 100644 --- a/doc/options.rst +++ b/doc/options.rst @@ -261,7 +261,8 @@ Clock and initial condition * - ``dtM`` / ``dt`` - real, s - absent (static-only) - - finite, > 0. In the standalone driver ``dtM`` and ``TMax`` are given together or not at + - finite, at least ``1e-100`` (the time integration divides by ``dtM**2``). In the + standalone driver ``dtM`` and ``TMax`` are given together or not at all; only ``TMax = 0``, which marches no step, needs no ``dtM`` - standalone step; OpenFAST targets ``0.1`` s when absent, rounds it to at least one whole glue ``DT``, and reports the value used @@ -355,10 +356,14 @@ rejected as unknown. The dynamic Newton controls are set with ``dynamic_solver`` - ``False`` - ``True`` enables guarded within-step tangent reuse on every dynamic solver the deck builds. It does not relax convergence tolerances and should be qualified against full Newton. - Measured against full Newton: 8-12 % faster on free-hanging finite-EI cables (lazy wave, - buoyed cable), about 1.5 times slower on finite-EI lines on the seabed (contact fails the - reuse contraction test and rebuilds the tangent), 3 % slower to 5 % faster on ``EI = 0`` - systems; + Measured against full Newton on the example decks (one thread): 4 to 20 % faster on + finite-EI cables, free-hanging or with a touchdown (lazy waves in waves, current and vessel + motion, a buoyed cable, rods on a spar); 12 % slower on an ``EI = 0`` cable laid on a + frictional seabed in a current, whose stick-slip friction makes a reused tangent take more + iterations; within a few per cent elsewhere on ``EI = 0`` systems. A finite-EI cable in + the monolithic step of the multibody march keeps full Newton, as it is stepped again from + the same start at every coupling iteration (reuse there made ``mixed_body_rods_points.dat`` + 7.0 s against 5.8 s); results move at the solver tolerance (Bergdahl mean cycle maxima within 0.16 %) - both - ``False modified_newton`` @@ -502,6 +507,22 @@ Finite-EI cable controls same under both - both (finite-EI lines) - ``element OutputRecovery`` + * - ``axialDampingRatio`` / ``axial_damping_ratio`` + - mode + - ``segment`` + - what a negative ``LINE TYPES`` ``BA`` is the damping ratio :math:`\zeta` of. + ``segment`` (MoorDyn's convention): of each segment, + :math:`BA = \zeta L_0 \sqrt{EA\,m}` per element, which damps the line's first axial mode + at about :math:`\zeta\pi/(2N)` on :math:`N` elements, so the axial damping depends on + the mesh; a dynamic run notes the ratio for each such line. ``mode1``: of the line's + first axial mode, both ends held, from its sections' lengths, ``EA`` and dry mass, so + the same on any mesh: :math:`BA = 2\zeta EA/\omega_1` on every element, a damping + proportional to the stiffness, under which the axial mode :math:`n` is damped at + :math:`\zeta\,\omega_n/\omega_1` (see :doc:`theory`). A positive ``BA`` is used as given + under both. Under ``mode1`` a line with a negative ``BA`` and a viscoelastic + (``ElasticMod`` 2 or 3) or Syrope section is refused by name + - both (``EI = 0`` and finite-EI lines) + - ``mode1 axialDampingRatio`` * - ``axial_quadrature_order`` / ``axialquadratureorder`` / ``axial_quadrature`` - integer, – - ``4`` @@ -622,8 +643,8 @@ Ambient fluid and prescribed motion lines stops with ``OPTION nModes is not supported for mixed EI=0/finite-EI decks; remove it or set it to 0``. A line restrained in torsion adds the twist angle of every node to its modes (``PolarShare`` and ``dTwist`` in :doc:`outputs`). The banded solver has - no line-length limit: a - 1024-element finite-EI cable takes a few seconds. See :doc:`theory` + no line-length limit: the 10 modes of a 1024-element finite-EI cable take a fraction of a + second. See :doc:`theory` - standalone - ``10 nModes`` * - ``WaveSeed`` / ``wave_seed`` @@ -695,6 +716,15 @@ Ambient fluid and prescribed motion different ``dtM`` with the same averaging time - lines with a LINE TYPES ``Cl > 0``, on every route - ``0.25 VIVrmsWindow`` + * - ``VIVphaseSeed`` / ``viv_phase_seed`` + - mode + - ``spread`` + - the initial phases of the VIV synchronisation model (:ref:`theory-viv`): ``spread`` starts + node ``i`` from the deck's End A at ``2 pi i/N``, as MoorDyn-C; ``zero`` starts every node + at zero, where MoorDyn-F in OpenFAST v5.0.0 starts (it does not carry its seed into its + state). Where two lock-in branches coexist, the seed selects the one a run settles on + - lines with a LINE TYPES ``Cl > 0``, on every route + - ``zero VIVphaseSeed`` * - ``motionFile`` - path, or ``0``/``none`` - absent diff --git a/doc/outputs.rst b/doc/outputs.rst index 0cb33a4d..1fd0325e 100644 --- a/doc/outputs.rst +++ b/doc/outputs.rst @@ -218,7 +218,8 @@ finite-EI line of the run: stiffener); written as 0 by the ``EI = 0`` static route * - ``Declination`` - ``(deg)`` - - axial-tangent angle from +Z (0 = up, 90 = horizontal, 180 = down) + - axial-tangent angle from +Z (0 = up, 90 = horizontal, 180 = down); the + :ref:`node tangent ` * - ``Inclination`` - ``(deg)`` - signed inclination below horizontal, ``Declination − 90`` @@ -458,11 +459,17 @@ holds two tab-separated tables, each introduced by a ``#`` comment line, a heade row: * ``# Natural frequencies``: ``LineID Mode Frequency Period Omega`` (Hz, s, rad/s), the - ``nModes`` lowest modes of every line in ascending order; + ``nModes`` lowest modes of every line in ascending order of :math:`\omega^2`. A mode with + :math:`\omega^2 < 0`, an instability of the static state (a planar equilibrium that is + unstable out of its plane, a compressed strut), is written with the signed values + ``Omega`` :math:`= -\sqrt{|\omega^2|}` and ``Frequency`` :math:`= -\sqrt{|\omega^2|}/2\pi` and + ``Period`` 0, and the run prints a note naming the line and the number of such modes; * ``# Mode shapes``: ``LineID Mode Node X Y Z dX dY dZ``, one row per mode and node. ``X Y Z`` is the static node position and ``dX dY dZ`` the nodal translation of the mode, scaled so that the largest nodal displacement of the mode is 1. Nodes are numbered End A first, - as in the other line files; the held end nodes have zero displacement. + as in the other line files; the held end nodes have zero displacement. The sign of a mode + makes the largest component of its mode vector positive; where two components are equally + large (the mirrored nodes of a symmetric line), the first of them in the solver's node order. When a line is restrained in torsion (both ends, see :doc:`driver_format`), its modes carry the twist angle of every node (:ref:`nodal twist `) and both tables gain a @@ -608,7 +615,8 @@ Line-end channels availability; for an anchor that holds one line it equals ``Point

FH`` - N * - ``FairIncl`` / ``AnchIncl`` - - signed inclination of the End-A / End-B tangent below horizontal + - signed inclination of the End-A / End-B tangent (:ref:`node tangent `) + below horizontal (``Decl − 90``: 0 = horizontal, +90 = pointing down, −90 = pointing up) - deg * - ``FairDecl`` / ``AnchDecl`` @@ -751,7 +759,8 @@ Line-node channels - node acceleration component (0 on a static run) - m/s² * - ``LNDec`` - - declination of the node's axial tangent from +Z (0 = up, 90 = horizontal, 180 = down) + - declination of the node's axial tangent from +Z (0 = up, 90 = horizontal, 180 = down); + the :ref:`node tangent ` - deg * - ``LNAzi`` - azimuth of the node's axial tangent from +X toward +Y, in the line's range @@ -841,6 +850,19 @@ the channels report that end node (and ``TDPGrd`` reads 0); when the whole li seabed, the suspended end node. ``TDPGrd`` is the grounded length of the `Anchor uplift`_ check. +The seabed carries the line at its nodes, so the mesh at touchdown sets how finely the touchdown +point and the tension around it are resolved: a node lands on the floor at once, and in a +dynamic run its landing shakes the line. The node tension near touchdown converges at the second +order in the element length there. On the lazy-wave cable of +``lozon_gomex80_power_cable_motion.dat`` (bending length :math:`\sqrt{EI/T}` = 3.9 m at +touchdown, tension 1.3 to 1.9 kN) it departs from a 1024-element solution by at most 140, 55, +19 and 5.8 N with 3.3, 1.6, 0.8 and 0.4 m elements at touchdown over the heave cycle (time step +0.0125 s), and by 4.6, 1.0 and 0.25 N in the static state with 3.3, 1.6 and 0.8 m elements; on +the 3.3 m mesh ``TDPs`` moves at up to 4 m/s while a node lands (0.7 m/s converged) and its +lowest value differs from the converged one by 0.6 m. Elements no longer than about a fifth of +:math:`\sqrt{EI/T}` at touchdown keep the node tension there within about 1.5 % of the +converged value through the motion, and a tenth within 0.5 %. + Point channels ~~~~~~~~~~~~~~ @@ -931,6 +953,21 @@ The axial tangent of every orientation channel points from End A toward End B (O ``Ez`` axis). Curvature, declination and azimuth are evaluated from the solved geometry on every route (static, ``EI = 0`` dynamic, finite-EI dynamic, rod and Rigid6 decks). +.. _outputs-node-tangent: + +The tangent of a node is the line's own direction there. On a finite-EI line it is the node's +tangent degree of freedom :math:`\mathbf r_{,s}` of the cubic-Hermite centreline, normalised: at +an end clamped by an ``END CONNECTIONS`` ``Rigid`` row it is the direction the connection holds, +at an end on a rotational spring the direction the spring lets the line take, and at every other +node the tangent of the solution, continuous through the node. On an ``EI = 0`` line, whose segments are straight, it is the direction from +the previous to the next node (from the end node to its neighbour at an end). The +``LNDec``/``Azi`` channels, ``FairDecl``/``AnchDecl``, ``FairIncl``/``AnchIncl`` and +their aliases, the ``Declination``, ``Inclination`` and ``Azimuth`` columns of ``.static.out``, +the ``Declination`` envelope of the range graph and the ``line tangent`` of the initialisation +reports all take it, on every route (the standalone driver, the mixed and multibody routes, the +C API and Python, and OpenFAST). :func:`cabledyn.line_geometry` is a post-processing estimate from +the node positions alone. + Validation of channel names ~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/doc/python.rst b/doc/python.rst index 378db20e..8517c5fa 100644 --- a/doc/python.rst +++ b/doc/python.rst @@ -787,8 +787,8 @@ active ANSI code page; a path that code page cannot represent is rejected with ` :class:`cabledyn.CableDynError` and leaves the model at the start of the step. A step that ends without meeting the Newton tolerance raises :class:`cabledyn.ConvergenceError`, which carries ``n_iter`` and ``stalled``; the model has then already advanced to ``t + dt`` with its best -iterate, so retrying the same step would advance time twice. ``dt`` must be a finite positive -real number, and array arguments must be real-valued: a string, complex, or boolean ``dt`` and a +iterate, so retrying the same step would advance time twice. ``dt`` must be a finite real number +of at least ``1e-100``, and array arguments must be real-valued: a string, complex, or boolean ``dt`` and a complex or non-numeric array raise ``TypeError`` before the library is called. Calls on one ``CableDyn`` instance are serialised by an internal lock; separate instances may run on separate threads. Deck initialisation is serialised inside the library, so instances created from many diff --git a/doc/quickstart.rst b/doc/quickstart.rst index c12bf0cb..7dbe3dca 100644 --- a/doc/quickstart.rst +++ b/doc/quickstart.rst @@ -18,7 +18,7 @@ and the ``examples`` folder (from the release's **Source code (zip)**) side by s .. code-block:: powershell Set-Location C:\CableDyn - .\CableDyn_driver.exe --version # prints the v0.4.1 banner, exit code 0 + .\CableDyn_driver.exe --version # prints the v0.4.2 banner, exit code 0 2. Solve a mooring line ----------------------- @@ -38,7 +38,7 @@ The run takes well under a second: .. code-block:: text =================================================================== - CableDyn v0.4.1 + CableDyn v0.4.2 Geometrically exact finite-element statics and dynamics of mooring lines and dynamic power cables for floating offshore wind ------------------------------------------------------------------- diff --git a/doc/theory.rst b/doc/theory.rst index 7b45a636..ee8f8b64 100644 --- a/doc/theory.rst +++ b/doc/theory.rst @@ -314,11 +314,22 @@ end residual holds only the element's own distributed loads: consistent submerged weight, the buoyancy lost above the free surface, drag, Froude-Krylov force, structural and added-mass inertia, and the -seabed reaction of its end nodes, each nodal reaction spread uniformly over the node's tributary -length (the distributed floor reaction it stands for; without it a line resting on the floor -would report the fixed-end moment :math:`w L_0^2/12` of its own weight; at a held line end whose -end element lies on the floor, the reaction of the end half is the floor-support share of the -weight, the share that the static and dynamic residuals carry on the end tangent rows). +seabed reaction of its end nodes, each nodal reaction spread uniformly over the grounded part of +the node's tributary length (the distributed floor reaction it stands for; without it a line +resting on the floor would report the fixed-end moment :math:`w L_0^2/12` of its own weight; at a +held line end whose end element lies on the floor, the reaction of the end half is the +floor-support share of the weight, the share that the static and dynamic residuals carry on the +end tangent rows). A half-element whose far node is on the floor is grounded whole; the +touchdown element, on the floor at one end only, is grounded from that end to the touchdown +point, where the clearance interpolated linearly between its two nodes reaches the contact onset +height (at most its half). The grounded stretch reaches the half-element as the suspended node +reaches the floor, and vanishes with the reaction as the grounded node lifts off, so the node +outputs vary continuously as nodes ground and lift off. With the reaction of the first grounded +node spread over its grounded half-element alone, the tension near touchdown carried a local +error that depended on where the touchdown point fell in its element and fell only at the first +order (at most 4.3, 1.9 and 1.0 N at 1.6, 0.8 and 0.4 m elements on the lazy-wave cable of +``lazy_wave_buoyancy_smeared.dat``, line tension 270 N there; 2.1, 0.7 and 0.2 N with the +grounded stretch), and it stepped as each node grounded. :math:`\mathbf{g}_e` is the generalised force the two end nodes exert on the element: its position rows at the End-B side of the internal arc are the section force :math:`\mathbf{F}_j^-` just before node @@ -800,9 +811,31 @@ so the element-scale modes (:math:`n \approx N`) are damped at up to :math:`(\pi ``BA``), while the line's global axial modes are damped much less, and less again on a finer mesh: ``BA = -1`` on 100 elements gives the first axial mode 1.6 %, and 0.8 % on 200 elements. Results that depend on the axial damping (tension peaks of snatch loads, the decay of axial -oscillations) therefore change with the mesh. For mesh-independent damping give ``BA`` in N·s: -a material damping ratio :math:`\zeta_1` of the first axial mode of a line of length :math:`L` is -:math:`BA = 2\,\zeta_1\,EA/\omega_1` with :math:`\omega_1 = (\pi/L)\sqrt{EA/\rho_A}`. +oscillations) therefore change with the mesh. The initialisation of a dynamic run notes, for every +line with a negative ``BA``, the damping ratio this gives its first axial mode on its final mesh: +the Rayleigh quotient :math:`\zeta_1 = \mathbf u^\mathsf T\mathbf C\mathbf u / +(2\,\omega_1\,\mathbf u^\mathsf T\mathbf M\mathbf u)` of the first mode :math:`\mathbf u` of the +line's axial chain with both ends held (element stiffness :math:`EA/L_0`, damping +:math:`BA/L_0`, the dry mass lumped at the nodes), which is :math:`\zeta\sin(\pi/(2N))` on a +uniform line and holds for a composite one. + +**First-mode damping ratio** (``mode1 axialDampingRatio``, :doc:`options`). A negative ``BA`` is +then the damping ratio of the line's first axial mode, the same on any mesh: + +.. math:: + + BA = \frac{2\,\zeta\,EA}{\omega_1} + +on every element, with :math:`\omega_1` the first axial natural frequency of the line with both +ends held, from its sections' unstretched lengths, ``EA`` and dry mass per length (the first mode +of the axial chain on a fixed internal mesh of 2048 elements, so independent of the line's mesh; +:math:`\omega_1 = (\pi/L)\sqrt{EA/\rho_A}` on a uniform line, to 1e-7). The damping is then +proportional to the stiffness, :math:`\mathbf C = (2\zeta/\omega_1)\,\mathbf K`, so the first +axial mode of a composite line is damped at :math:`\zeta` too and the mode :math:`n` at +:math:`\zeta\,\omega_n/\omega_1`. Added mass and the tension are left out of :math:`\omega_1`. A +viscoelastic or Syrope section has no single ``EA`` that sets the first mode, so a line with one +and a negative ``BA`` is refused under this option; ``BA`` in N·s is used as given under both +conventions. Viscoelastic rope (MoorDyn ``ElasticMod`` 2 and 3) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -925,15 +958,16 @@ ratchets and regenerates the working curve when the mean tension exceeds it. **Initial condition.** The static solve uses the rest curve of the initial load history: the OWC for a virgin rope, or, with ``SYROPE IC``, the working curve regenerated at :math:`T_\text{max,0}` (zero tension below its zero-tension strain, the OWC above its top -strain :math:`\varepsilon_\text{OWC}(T_\text{max,0})`). A single secant axial stiffness of that -curve is iterated to the solved mean strain, the line otherwise built as any ``EI = 0`` line +strain :math:`\varepsilon_\text{OWC}(T_\text{max,0})`). Each element's secant axial stiffness of +that curve is iterated to the curve's strain at its solved tension, the line otherwise built as +any ``EI = 0`` line (its drag in a deck current included). Each element then starts with the running maximum :math:`\max(T_\text{max,0}, T_e)` (:math:`T_e` for a virgin rope), where :math:`T_e` is its static tension, and with the slow strain whose kernel tension at the static strain and zero strain rate equals :math:`T_e`. The dynamic state therefore starts in the static equilibrium, -with no initial transient. Where the static strain lies on the rest curve, that slow strain is -the curve's rest point. Elsewhere, for example along a sagging line, it creeps at -:math:`(T_e - T_\text{mean})/BA_s`. With fixed line ends the mean tension follows from the +with no initial transient: every element's static strain lies on the rest curve, where that slow +strain is the curve's rest point. (With one secant for a whole section, an element away from the +mean tension sat off the curve and its slow strain crept at :math:`(T_e - T_\text{mean})/BA_s`.) With fixed line ends the mean tension follows from the geometry and :math:`T_\text{max,0}`, so :math:`T_\text{mean,0}` does not enter the state. A value that differs from the static mean tension by more than 1 % is reported on the console. A strain below the working curve's zero-tension strain (a slack rope on that history) stops at @@ -977,7 +1011,17 @@ With the relative velocity :math:`\mathbf{u}_r = \mathbf{u}_f - \mathbf{v}` spli + \tfrac{1}{2}\rho\,\pi d\,C_{d,t}\,\lvert\mathbf{u}_{r,t}\rvert\,\mathbf{u}_{r,t}. Its derivatives with respect to position (through :math:`\mathbf{t}`) and velocity enter the -implicit tangent exactly. +implicit tangent exactly. The length is the element's unstretched length :math:`L_0` on the +``EI = 0`` path (with the chord tangent and the wet-weighted relative velocity) and +the deformed length :math:`\lvert\mathbf r_{,\xi}\rvert\,\mathrm{d}\xi` of the cubic centreline +on the Hermite path (three Gauss points per element). At rest in a current the end reactions +(``FairTen``/``AnchTen``, ``Point

F``) balance the weight and this drag to the static +tolerance, about :math:`10^{-8}` of the end force, pinned or clamped ends alike. A check of the +balance must integrate the drag the same way: on straight chords between the nodes of a +finite-EI line it misses by a share that falls with the square of the element length +(:math:`3\times10^{-5}` of the end force on 1.25 m elements of a cable in a 1 m/s current, +:math:`4.5\times10^{-4}` on 5 m elements), and per unstretched length by about the axial strain +times the drag. Added mass and fluid inertia ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -1026,10 +1070,24 @@ so the shedding frequency locks onto the cross-flow motion inside the band :math:`c_F \pm d_F` (MoorDyn's defaults 0.18 and 0.08). The running RMS values average over ``VIVrmsWindow`` seconds, by default 500 steps of ``dtM`` as in MoorDyn, and the phases start at :math:`2\pi i/N` at node :math:`i` counted from the deck's End A (MoorDyn's ``AttachA``), also on -a line written anchor first, which the reader turns around. On a finite-EI mesh the static solve +a line written anchor first, which the reader turns around. The node tangent +:math:`\mathbf{q}` runs from End A to End B, as MoorDyn's; turning it around turns the lift and +:math:`\mathbf{e}` around and starts the same motion from the phases plus :math:`\pi`, with +:math:`\phi_{\dot y} = \pi` instead of MoorDyn's 0 at a node with no cross-flow motion (a node at +rest, a held end of a finite-EI cable), so the lift field is MoorDyn's whichever end a deck writes +first. On a finite-EI mesh the static solve refined, the deck nodes keep that seed and the nodes it added take the seed interpolated in arc length. The static equilibrium carries no lift. +The seed decides which response the line settles on where two lock-in branches coexist. On the +taut line of the ``viv_lockin`` test, between about 0.21 and 0.33 m/s, a line locked in its first +mode at 0.18 m/s stays there as the current rises, while one coming down from 0.30 m/s stays in +its second mode, and a start from rest with the spread seed settles in the second mode, as +MoorDyn-C does. MoorDyn-F (v2.3.8, OpenFAST v5.0.0) sets the same seed but does not copy it into +the state vector it integrates, so its phases start at zero at every node: a uniform lift that +excites the symmetric modes only, after which the line stays in its first mode. ``zero +VIVphaseSeed`` starts every phase at zero, and reproduces that start (:doc:`options`). + In the implicit step the phase is explicit: the step's lift takes the phase predicted at :math:`t_{n+1}` from the step-start rate (the generalised-α level under the configuration blend), and the committed phase is the trapezoidal (Heun) update with the rate at the converged end @@ -1068,6 +1126,8 @@ phases, the running mean squares and the averaging time are part of the checkpoi restart continues the uninterrupted run bit for bit. The OpenFAST correction iterations rewind them with the rest of the state. +.. _theory-dry-buoyancy: + Buoyancy and wetting ~~~~~~~~~~~~~~~~~~~~ @@ -1395,7 +1455,15 @@ laid node sinks into the penalty seabed along its normal by its static penetrati slope moves it horizontally by :math:`w_i\,(z_{,x}, z_{,y})/k_i`, with :math:`w_i` its nodal load: its share of the line's submerged weight, plus the net weight of a discrete attachment lumped at it (the finite-EI solve first smears an attachment over the two elements at its -node, then rebuilds the reference for the discrete loads before it polishes to them). Where +node, then rebuilds the reference for the discrete loads before it polishes to them). It is the +normal load the solver applies to the node resting at its laid position: a finite-EI section +that lies within its radius of the still-water level there (a seabed shallower than the cable +radius) carries the buoyancy of its dry part, as in the static solve and the dynamics +(:ref:`buoyancy recovery `), at the height the node sinks to under that +load, :math:`z_f - w_i s^2/k_i`, and an attachment above the level its dry weight. The seabed +lies below the still-water level everywhere (a positive ``WtrDpth`` and positive bathymetry +depths), so a grounded node with its attachment stays submerged; an ``EI = 0`` line, whose +submergence follows its node heights, is wholly submerged where it is grounded. Where the slope varies, the laid tension turns at every node and adds :math:`-T_\text{laid}\,(\mathbf{t}_{i}^{+} - \mathbf{t}_{i}^{-})\cdot\mathbf{n}_i` to the normal load (it presses the line into a crest and lifts it from a hollow), with @@ -1566,7 +1634,9 @@ hang it from the seabed. The contact acts along the surface normal of a sloped o bathymetry, in the point static equilibrium and in the monolithic and staggered point steps alike (in the staggered step its stiffness and damping are linearly implicit, like the end blocks of the attached lines), so a grounded point starts at rest. A ``Point3`` buoy is not -placed by the static solve (it starts at its deck position) but carries the same contact in +placed by the static solve (it starts at its deck position; under ``bodyIC static`` the run notes +the force its line, weight, buoyancy, drag and contact leave on it there and the distance to its +balance as a ``Free`` point) but carries the same contact in every march, the monolithic and staggered steps and the coupled point step of the OpenFAST aggregate and the C API. The contact is frictionless: the point routes reject ``frictionMu``. A point clear of the seabed sees exactly no contact load, and its results are unchanged. @@ -1627,7 +1697,8 @@ beyond a :math:`10^{-6}` relative round-off band; a slack element reports zero t :math:`\lVert\mathbf{R}\rVert_\infty < 10^{-14}`, where :math:`s` is the largest of the infinity norms of the external load, the seabed reaction, and any current drag; a residual that stops decreasing inside the round-off floor - :math:`16\,\epsilon\,\max(EA/L_0)\max(\lvert q\rvert, L_0)` of the nodal forces is converged. + :math:`16\,\epsilon\,\max(EA/L_0)\max(\lvert q\rvert, L_0)` of the nodal forces is converged, + whether it stays flat or cycles between values (three iterations without a new minimum). A line with no admissible equilibrium fails closed, naming the line, the seeds and stages tried, and the reason. @@ -1763,7 +1834,12 @@ mesh-sequenced route described below first and this route as its fallback): take over, because the seabed contact and waterline laws are only piecewise smooth (and the curvature of a structured bathymetry grid is not differentiated). Stages that jump further than a small fraction of the line are retried at a smaller step; a first stage that - does not converge is restarted at full ``EI``. + does not converge is restarted at full ``EI``. Such a descent from the seed (and the one past + a limit point of the continuation) can run for more than a thousand iterations while the + energy falls and the residual rises and falls, and that count scatters with the last digits + of the input, such as the line's azimuth. Past its allowance it therefore runs on while the + two-norm of the scaled residual keeps halving within an allowance, to one and a half + allowances (a longer descent can settle on a folded branch that the other routes avoid). 3. **Polish and diagnosis** on the deck mesh at the static tolerance. A residual floor above it is accepted at :math:`10^{-6}` (or, for a line on the seabed, :math:`10^{-5}`, nodes alternating across the 1 µm contact blend) and reported. An element folded beyond @@ -1789,7 +1865,13 @@ mesh-sequenced route described below first and this route as its fallback): whose continuation or polish fails, or whose folded element the local refinement does not resolve, repeats the route on a mesh refined until the elements are at most half the bending length (when the continuation on that mesh runs out of its iteration - budget, on the coarser powers of two down to twice the deck mesh); a rotationally + budget, on the coarser powers of two down to twice the deck mesh) and, when that fails too, + on the deck mesh with each element split only into the power of two (at most 16) that brings + it to half the bending length. A uniform refinement keeps a graded deck's ratios and refines + its short elements with the long ones: a lazy wave meshed 4 m at its sag bend, 0.9 m over its + buoyant section and 10 m at its touchdown failed in an oblique current on the deck mesh and on + the 8x refined one, and solves on the mesh refined element by element (within 1.2e-3 of its + fairlead tension of the same deck on 2 m elements); a rotationally restrained end whose boundary layer :math:`\sqrt{EI/T}` is shorter than its element, which shows as a polish that does not converge or a compression at that end, repeats it on a mesh graded geometrically toward that end. The refined mesh is reported. @@ -1860,7 +1942,9 @@ still-water equilibrium is found first and the drag is brought in by load steps. that stalls hands over to a pseudo-arclength continuation in the drag fraction :math:`\lambda`: each corrector solves the bordered system :math:`[K,\,-D;\ t_q^T,\ t_\lambda]` (:math:`D` the drag at full current) by block elimination -with two banded solves, so the path can turn at a limit point in :math:`\lambda`. A current +with two banded solves, so the path can turn at a limit point in :math:`\lambda`. At a ``Rigid`` +end the system is taken in the basis of the end direction, as in the static solve, with the +two transverse components of the end tangent held. A current across the vertical plane of the line makes the static solve three-dimensional, as the dynamics are. @@ -1979,15 +2063,35 @@ element, the Hessian of its strain energy. The linearised seabed normal contact stiffness on the contacting nodes. :math:`\mathbf M` is the consistent structural mass plus the Morison added mass at the static shape. Friction, damping, and drag are left out, as in any undamped modal analysis. :math:`\mathbf K` and :math:`\mathbf M` are banded (the nodes are -numbered along the line), and only the ``nModes`` lowest modes are computed: LAPACK ``dsbgvx`` -gives the eigenvalues, inverse iteration with the banded factors of -:math:`\mathbf K - \omega^2\mathbf M` gives each shape (M-orthogonal to the shapes before -it, so a repeated frequency gets independent shapes), and the returned :math:`\omega^2` is the -Rayleigh quotient of the shape, summed in quadruple precision. That quotient keeps the lowest -frequencies of a long, axially stiff line accurate, where the band reduction alone loses -digits. Memory grows linearly with the line length. The frequencies +numbered along the line), and only the ``nModes`` lowest modes are computed. Their eigenvalues +come from a block Lanczos iteration on the shift-inverted operator +:math:`\mathbf K^{-1}\mathbf M`, applied with the banded Cholesky factor of :math:`\mathbf K`, +in the :math:`\mathbf M` inner product with full reorthogonalisation. The block holds two +vectors, so both planes of a straight line, whose transverse frequencies coincide, are found. +A Ritz value is accepted when the residual of the shift-inverted eigenproblem is below +:math:`10^{-10}` of its eigenvalue. The count is then certified: the Cholesky factor shows that +no eigenvalue lies at or below zero, and the inertia of :math:`\mathbf K - \sigma\mathbf M` +(the negative pivots of its banded :math:`\mathbf L\mathbf D\mathbf L^{\mathsf T}` +factorisation, by Sylvester's law of inertia) at a shift :math:`\sigma` in a gap above the +wanted eigenvalues must equal the number of Ritz values below :math:`\sigma`, so no frequency +is missed or counted twice. The iteration's time grows linearly with the line length. Short +lines, many modes of a short line, an indefinite or singular :math:`\mathbf K` (a compressed +or slack line), and an iteration that does not converge or is not certified within its basis +bound take LAPACK ``dsbgvx`` instead (band reduction and bisection), whose time grows with the +square of the line length. Inverse iteration with the banded factors of +:math:`\mathbf K - \omega^2\mathbf M` then gives each shape (M-orthogonal to the shapes +before it, so a repeated frequency gets independent shapes), and the returned +:math:`\omega^2` is the Rayleigh quotient of the shape, summed in quadruple precision. That +quotient keeps the lowest frequencies of a long, axially stiff line accurate, where the band +reduction alone loses digits. A shape the Lanczos eigenvalues do not give is solved again on +the eigenvalues of the band reduction. Each shape is signed so that its largest component is +positive; where two components are equally large to round-off (the mirrored nodes of a +symmetric line), the first of them in the solver's node order is. Memory grows linearly with the line +length. The frequencies :math:`f = \omega/2\pi` and the nodal translations of each mode (scaled to a unit largest -nodal displacement) are written to ``.modes.out``. For a taut string of tension +nodal displacement) are written to ``.modes.out``; an eigenvalue :math:`\omega^2 < 0`, an +instability of the static state, is written as the negative frequency +:math:`-\sqrt{|\omega^2|}/2\pi` and noted. For a taut string of tension :math:`T` the transverse frequencies are :math:`f_n = (n/2L)\sqrt{T/m}`; for a shallow sagging cable the out-of-plane and antisymmetric in-plane modes follow the string with the horizontal tension :math:`H`, and the symmetric in-plane modes satisfy @@ -2292,8 +2396,10 @@ residual decreases; its convergence norm divides each translational residual by frozen at the predictor and each tangent-DOF residual additionally by the nodal tributary length. The force scale is the largest inertial or residual entry, bounded below by 1 N, by the peak element weight, and by the round-off floor -:math:`16\,\epsilon\,\max(EA/L_0)\,x_\text{ref}/\text{tol}` of the axial forces -(:math:`x_\text{ref}` the largest coordinate magnitude or element length). The +:math:`16\,\epsilon\,\max\big((EA + BA\,\gamma/(\beta\,\Delta t))/L_0\big)\,x_\text{ref}/\text{tol}` +of the axial forces (:math:`x_\text{ref}` the largest coordinate magnitude or element length; +the axial damping takes the strain rate from the Newmark velocity, whose rounding is +:math:`\gamma/(\beta\,\Delta t)` times that of the coordinates). The deck defaults are relative tolerance :math:`10^{-8}`, absolute tolerance :math:`10^{-14}`, 30 iterations, and 12 backtracks (option ``dynamic_solver``). Option ``modified_newton`` reuses the factorised tangent within a step while each iterate reduces the residual to at most a quarter @@ -2577,7 +2683,9 @@ does not converge. At a slack line whose condensed stiffness vanishes, the itera a central-difference Jacobian of the full residual. A step is accepted when it lowers the residual, or when the Newton step from the trial point is -at most half the current one. The second test lets an object swing along a curved valley: a +at most half the current one and half the shortest Newton step of the solve so far (a Newton step +that grows again near a slack/taut kink of a line must not reset that measure, or the steps can +cycle). The second test lets an object swing along a curved valley: a buoy on a stiff taut line moves on a sphere about the anchor, and every straight step overstretches the line by its sagitta, so the force residual alone would reject any step longer than a few centimetres. After each accepted step the rotation unknowns are folded into @@ -2959,8 +3067,12 @@ the nodal tangent :math:`\mathbf{m}_j/\lvert\mathbf{m}_j\rvert` (the line's Mori :math:`C_dA = C_{d,n} d` and :math:`C_dA_x = \pi C_{d,t} d`). The drag enters the velocity tangent and, through :math:`\mathbf{m}_j`, the position tangent exactly. Above the free surface an attachment carries its weight :math:`-m g\,\mathbf{e}_z` alone. The statics start from the -equilibrium with the net weight smeared over the node's two elements and continue to the lumped -load in warm-started Newton solves; in a deck current the drag at rest is added, each solve takes +equilibrium with the net weight smeared over the node's two elements, in a deck current across +the vertical plane of the chord with the drag areas smeared over them too (per-metre drag +coefficients :math:`C_dA/(d\,L)` and :math:`C_dA_x/(\pi d\,L)` added to an element of length +:math:`L` for each share), and continue to the lumped loads in warm-started Newton solves, the +smeared weight and drag moving to the node together; in a deck current the drag at rest is +lumped at the node, each solve takes every attachment's load on the side of the still-water level its node is on, and the final solve is repeated with the loads of its own solution until the nodes stop moving and no attachment changes side (an attachment that its weight in air takes below the surface and its @@ -2968,8 +3080,12 @@ weight in water above it has no static position, and the solve fails closed, nam attachment that crossed the surface). Before, an attachment above the surface kept its buoyancy in the statics: a 500 kg, 0.2 m\ :sup:`3` module 3 m above it moved the fairlead load by up to 6.1 % in the first second of the march. The load moves -in eighths; a step whose damped Newton solve does not converge is repeated from the last -converged state with pseudo-transient continuation and then with a residual-merit line search, +in eighths; a solve that stalls on a residual floor above the tight static tolerance is +repeated from the same state at the coupled static tolerance :math:`10^{-6}`, as the line's own +static solve accepts such a floor, and the run notes the residual of the discrete equilibrium +when it lies above the tight tolerance. A step whose damped Newton solve does not converge is +repeated from the last converged state with pseudo-transient continuation and then with a +residual-merit line search, and is halved (down to 1/1024) when neither converges. A halved step doubles again (up to 1/8) after two consecutive converged steps of its size; each time a doubled step fails, the number of converged steps a doubling waits for doubles, so a homotopy that converges steadily at one @@ -2978,12 +3094,16 @@ At most 64 load steps may fail in all. A discrete state reached this way passes tensile, physical-branch and stability checks of the smeared state before it is accepted, the kink limit :math:`L_0\kappa \le 0.7` applied away from the attachment nodes: a lumped load turns the line by a slope jump :math:`\theta` at its node, which the :math:`C^1` elements -beside the node carry as :math:`L_0\kappa \approx 2\theta` at any mesh size. The smeared state carries no -attachment drag, and on a frictional seabed, whose regularised friction force turns from its -sticking stiffness to its sliding capacity over a short slip, the Newton update for a -cross-flow drag can overshoot and diverge from the first step (a lazy wave with 25 modules in a -0.3 m/s cross current on 2 m elements, even in steps of 1/64), which the pseudo-transient -regularisation avoids. +beside the node carry as :math:`L_0\kappa \approx 2\theta` at any mesh size. On a frictional +seabed, whose regularised friction force turns from its sticking stiffness to its sliding +capacity over a short slip, a smeared state without the attachment drag left the polish to apply +the whole module drag, and its damped Newton updates diverged from the first step as the +grounded run slid metres sideways (a lazy wave with 25 modules in a 0.3 m/s cross current on 2 m +elements); with the drag smeared, each load step moves the line by millimetres and converges in +a few iterations. A current along the plane does not move the line out of it, and the polish +carries the attachment drag from the smeared state without it, as the smeared start of a coarse +deck mesh could otherwise stop at the grounded-run compression check (a lazy wave restrained in +torsion in 0.5 m/s along its plane). As the pitch :math:`p` of identical modules shrinks, the discrete equilibrium converges to the smeared section at :math:`O(p^2)`. diff --git a/doc/troubleshooting.rst b/doc/troubleshooting.rst index 78388c12..fd141c64 100644 --- a/doc/troubleshooting.rst +++ b/doc/troubleshooting.rst @@ -568,6 +568,18 @@ but a few geometries are genuinely hard: sparse long section is not over-coarsened merely because the deck also contains many short elements. Flat-bed installed lines with an already supported anchor retain their grounded-tail branch homotopy and are still accepted only after exact-mesh residual and kink checks. +- **A long, light finite-EI line that solves at one orientation and not at another.** Turning a + deck about the vertical (its end points, current and seabed with it) leaves the physics + unchanged, but not the arithmetic: the static solve of a long line from its seed is a long + descent whose path the last digits of the input can change. Azimuths, declinations and the + global frame are defined in :doc:`conventions`; check that the deck's are the intended ones + before anything else. A descent from the seed runs on while its residual keeps falling and + stops when it has stalled (:doc:`theory`, Static equilibrium), so such a line normally solves + at every orientation; one that still fails, or that reaches a different shape at a nearby + orientation, is near a branch boundary of its own geometry. Inspect the static profile + (``.static.out``: positions, tension and curvature along the line), compare it with the deck at + a refined mesh, and judge whether the shape is the one the line would take. CableDyn does not + choose between physically admissible branches for you. - **A very slack cable on a frictionless flat bed.** If its rest length exceeds the vertical-plus- horizontal L-shaped path between the endpoints, a smooth single-touchdown equilibrium may not exist: the surplus must fold or form another contact region. CableDyn rejects a resulting @@ -857,7 +869,8 @@ Warnings and notes that do not stop a run elements; or the continuation or polish failed on a deck mesh with elements longer than half the bending length :math:`(EI/|w|)^{1/3}`, and the route was repeated on the whole line refined uniformly by a power of two, up to the factor at which every element meets - that length (or, at a rotationally + that length, and then on the deck mesh with only its long elements split to that length + (or, at a rotationally restrained end, on end elements halved toward the end down to its boundary layer). See :doc:`theory`, Static equilibrium. The run uses the refined mesh, statics and dynamics alike, and its profile and per-line outputs have that many segments; the refinement diff --git a/doc/tutorial_lazywave.rst b/doc/tutorial_lazywave.rst index 40790dbb..c324eef7 100644 --- a/doc/tutorial_lazywave.rst +++ b/doc/tutorial_lazywave.rst @@ -184,7 +184,7 @@ vertical), 19.9 s (out of plane, along the grounded run) and 16.9 s (in plane). 2048 elements the out-of-plane periods and the 20.4 s mode agree to four digits. The in-plane modes that move the touchdown (39.9 s, 16.9 s and 11.7 s) shift by up to 0.5 %, because the linearised seabed contact at the touchdown changes with the node spacing. The run takes about -2 s, most of it in the modal solve. +a second, a quarter of it in the modal solve. Exercises --------- diff --git a/doc/tutorial_openfast.rst b/doc/tutorial_openfast.rst index 684bd368..a9e41cb1 100644 --- a/doc/tutorial_openfast.rst +++ b/doc/tutorial_openfast.rst @@ -168,7 +168,7 @@ The CableDyn part of the console (other modules' lines trimmed): .. code-block:: text - Running CableDyn (v0.4.1, 2026-11-08). + Running CableDyn (v0.4.2, 2026-11-09). CableDyn: geometrically exact finite-element statics and dynamics of mooring lines and dynamic power cables. ... CableDyn time step dtM = 2.50000E-02 s (1 x glue DT; deck dtM) @@ -339,7 +339,7 @@ seabed. Copy it into the case folder and point a copy of the ``.fst`` at it: ... Line 4 fairlead effective tension: 11922 N force [Fx, Fy, Fz]: [1230, 0, -11858] N, inclination=84.078 deg - line tangent: inclination=83.943 deg, declination=173.94 deg, azimuth=0 deg + line tangent: inclination=83.973 deg, declination=173.97 deg, azimuth=0 deg ... Curv4N38 = 9.01822E-02 (1/m) BendMom4N38 = 1794.6 (N.m) diff --git a/examples/README.md b/examples/README.md index f2acc80e..ae4325e5 100644 --- a/examples/README.md +++ b/examples/README.md @@ -44,11 +44,14 @@ Copy a deck under a new name and keep every file it references at the same relat | `*.dat` | Standalone decks. `iea15mw_umaine_openfast_cabledyn.dat` is an OpenFAST-only `MooringFile`; `iea15mw_umaine_mixed_cabledyn.dat` runs both standalone and coupled. | | `openfast/` | IEA-15MW VolturnUS-S `.fst` pair (`CompMooring = 5` and `3`) with their mooring decks; see [openfast/README.md](openfast/README.md). | | `data/syrope/` | Syrope settings and original working-curve table used by `syrope_polyester_mooring.dat` and `composite_chain_syrope_chain.dat`. | -| `data/lozon/` | Prescribed hang-off heave history for `lozon_gomex80_power_cable_motion.dat` and the script that generates it. | -| `data/vessel/` | 6-DOF vessel-motion record for `lazy_wave_vessel_motion.dat` and `composite_chain_syrope_chain.dat`, the script that generates it, and the illustrative RAO table for `lazy_wave_vessel_rao.dat` and `lazy_wave_bend_stiffener.dat`. | +| `data/lozon/` | Prescribed hang-off heave history for `lozon_gomex80_power_cable_motion.dat` and `torsion_free_end_armoured_cable.dat`, and the script that generates it. | +| `data/vessel/` | 6-DOF vessel-motion record for `lazy_wave_vessel_motion.dat`, `composite_chain_syrope_chain.dat` and `lazy_wave_modules_stiffener.dat`, the script that generates it, and the illustrative RAO table for `lazy_wave_vessel_rao.dat`, `lazy_wave_bend_stiffener.dat` and `composite_ve_syrope_jonswap.dat`. | | `data/torsion/` | Hang-off roll history (motionFile roll column) for `torsion_lazy_wave_hangoff_twist.dat` and the script that generates it. | -| `data/range_tdp/` | Fairlead surge history for `chain_range_tdp.dat` and the script that generates it. | +| `data/range_tdp/` | Fairlead surge history for `chain_range_tdp.dat` and `chain_sloped_bathymetry_friction.dat`, and the script that generates it. | +| `data/shared/` | Hang-off motions of both ends of `shared_cable_two_floaters.dat` and the script that generates them. | +| `data/bathymetry/` | The `x y depth` seabed grid of `chain_sloped_bathymetry_friction.dat`. | | `moordynC_wavekin/` | A deck with the MoorDyn-C `wave_frequencies.txt` and `current_profile.txt` files it reads from its own folder. | +| `moordynC_currents/` | Two decks with the MoorDyn-C `wave_elevation.txt`, `current_profile_dynamic.txt` and `current_profile_4d.txt` files they read from their own folder (`WaveKin 3`, `Currents 2` and `5`), and the script that generates the files. | | `plot_range_envelope.py` | Plots the tension envelope of a range-graph file (`python plot_range_envelope.py `). | Files under `data/` are inputs referenced by decks; do not pass them to an executable. diff --git a/examples/cabledyn_options_reference.dat b/examples/cabledyn_options_reference.dat index b9fc3128..a9f693e1 100644 --- a/examples/cabledyn_options_reference.dat +++ b/examples/cabledyn_options_reference.dat @@ -82,6 +82,7 @@ none waves - Wave model and parameters (m, s, deg) {none; airy; -- 0.5 frictionMuAxial - Seabed friction along the line axis {>=0} [default: frictionMu] -- 0.5 frictionMuLateral - Seabed friction across the line axis {>=0} [default: frictionMu] -- asLaid staticsFriction - Statics seabed friction policy {none; asLaid} [default: none] +-- mode1 axialDampingRatio - A negative BA is the damping ratio of {segment=each segment; mode1=the first axial mode} [default: segment] -- 0.0 layAzimuth - Lay azimuth of every line from +x toward +y (deg) [default: anchor -> fairlead] -- 225.0 layAzimuth2 - Lay azimuth of line 2 alone (deg) [default: layAzimuth] -- 0.0 asLaidTension - As-laid effective tension of every line (N) [default: 0] @@ -108,6 +109,7 @@ none waves - Wave model and parameters (m, s, deg) {none; airy; -- layAzimuth = lay_azimuth; asLaidTension = as_laid_tension -- dtM = dt; rhoInf = rho_inf; modified_newton = modifiedNewton; adaptive_mesh = adaptiveMesh -- cable_statics = cableStatics; alpha_force_blend = alphaForceBlend; OutputRecovery = output_recovery +-- axialDampingRatio = axial_damping_ratio -- maxStrain = max_strain; WaveSeed = wave_seed; rampTime = ramp_time = tRamp -- RangeStart = range_start -- cable_load_feedback = cableLoadFeedback; tensile_safety = tensileSafety diff --git a/examples/chain_sloped_bathymetry_friction.dat b/examples/chain_sloped_bathymetry_friction.dat new file mode 100644 index 00000000..855252af --- /dev/null +++ b/examples/chain_sloped_bathymetry_friction.dat @@ -0,0 +1,58 @@ +--------------------- CableDyn Input File ------------------------------------ +CableDyn driver deck -- chain on a sloping seabed (bathymetryFile) held by as-laid friction, surging fairlead, 60 s +-- The 410 m studless chain of chain_range_tdp.dat on a structured seabed instead of a flat one: +-- data/bathymetry/sloped_seabed.txt is a grid of `x y depth` rows, here a plane 60 m deep under +-- the fairlead that rises 2.1 deg toward the anchor (45 m deep at x = 400 m) and falls 2.9 deg +-- across the line, toward +Y. The seabed is bilinear between the grid points; bathymetryFile +-- replaces WtrDpth, which the deck must then leave out. Seabed friction (frictionMu 0.5) exceeds +-- the cross slope (tan 2.9 deg = 0.05), so the grounded chain holds; staticsFriction asLaid +-- solves the static start against the as-laid layout, the chain laid from the anchor along its +-- chord and its top end then moved to the fairlead, so the grounded length rests where it was +-- laid instead of sliding down the cross slope. The fairlead then surges 5 m at 30 s +-- (data/range_tdp/chain_surge_5m_30s_dt005.txt, after a 15 s smooth start). TDP1s and TDP1x +-- follow the touchdown point; L1N30py is the sideways position of a grounded node 290 m from +-- the fairlead, which friction keeps from creeping downslope. +--------------------- LINE TYPES --------------------------------------- +TypeName Diam MassDenInAir EA BA/-zeta EI Cd_n Cd_t Ca_n Ca_t +(-) (m) (kg/m) (N) (N-s/-) (N-m^2) (-) (-) (-) (-) +chain 0.252 390.0 1.674e9 -1.0 0.0 1.37 0.64 1.0 0.0 +--------------------- POINTS ------------------------------------------- +ID Type X Y Z Mass Vol CdA Ca +(-) (-) (m) (m) (m) (kg) (m^3) (m^2) (-) +1 Fixed 400.0 0.0 -45.0 0 0 0 0 +2 Coupled 0.0 0.0 0.0 0 0 0 0 +--------------------- LINES -------------------------------------------- +ID NodeA NodeB Outputs +(-) (-) (-) (-) +1 2 1 - +--------------------- SECTIONS ----------------------------------------- +LineID LineType Length NumSegs +(-) (-) (m) (-) +1 chain 410.0 41 +--------------------- OPTIONS ------------------------------------------ +9.80665 g - Gravitational acceleration (m/s^2) [default: 9.80665] +1025.0 rhoW - Water density (kg/m^3) [default: 1025] +data/bathymetry/sloped_seabed.txt bathymetryFile - Structured seabed: x y depth grid (m) [default: absent] +1.0e5 kBot - Seabed penalty stiffness base (Pa/m) [default: 1.0e5] +1.0e4 cBot - Seabed normal damping base (Pa-s/m) [default: 1.0e4] +0.5 frictionMu - Seabed friction coefficient {none; value>=0} [default: none] +asLaid staticsFriction - Static seabed friction policy {none; asLaid} [default: none] +0.05 dtM - CableDyn internal time step (s) [default: omitted standalone; the glue DT in OpenFAST] +60.0 TMax - Standalone simulation duration (s) [default: omitted standalone; host-owned OpenFAST] +data/range_tdp/chain_surge_5m_30s_dt005.txt motionFile - Prescribed fairlead motion history +0.4 rhoInf - Generalised-alpha spectral radius {0<=rhoInf<=1} [default: 0.4] +False modified_newton - Tangent-reuse mode {False=full Newton; True=guarded reuse} [default: False] +False adaptive_mesh - Automatic finite-EI refinement {False; True} [default: False] +dynamic_solver 1.0e-8 1.0e-14 30 12 - Relative tolerance, absolute tolerance, max iterations, backtracks [defaults shown] +none current - Current model and velocity (m/s) {none; uniform; profile} [default: none] +none waves - Wave model, height, period, and direction (m, s, deg) {none; airy; jonswap} [default: none] +0 WaterKin - Water-kinematics source {0/none; file; SEASTATE coupled only} [default: no policy] +-- Complete option/default reference: cabledyn_options_reference.dat and doc/options.rst. +--------------------- OUTPUTS ------------------------------------------ +"FairTen1" +"AnchTen1" +"TDP1s" +"TDP1x" +"L1N30py" +"L1N30pz" +--------------------- need this line ----------------------------------- diff --git a/examples/composite_axial_damping_mode1.dat b/examples/composite_axial_damping_mode1.dat new file mode 100644 index 00000000..98010719 --- /dev/null +++ b/examples/composite_axial_damping_mode1.dat @@ -0,0 +1,55 @@ +--------------------- CableDyn Input File ------------------------------------ +CableDyn driver deck -- chain-polyester-chain mooring with a mesh-independent axial damping ratio, Airy wave, 60 s +-- The three-section mooring of composite_chain_poly_chain.dat (200 m depth) under a regular +-- 4 m, 10 s Airy wave, ramped in over 10 s. Every section's BA is -0.02, and the OPTION +-- axialDampingRatio mode1 reads a negative BA as the damping ratio of the line's first axial +-- mode (both ends held), worked out from the sections' lengths, EA and dry mass: here 2 % at +-- 2.03 Hz on any mesh. Each element then takes BA = 2 zeta EA/omega1, a damping +-- proportional to the stiffness, which damps axial mode n at zeta omega_n/omega_1. Under the +-- default segment form the same -0.02 would damp the first mode at about zeta pi/(2N) = 0.04 % +-- on these 77 elements, and half that on a mesh twice as fine. +--------------------- LINE TYPES --------------------------------------- +TypeName Diam MassDenInAir EA BA/-zeta EI Cd_n Cd_t Ca_n Ca_t +(-) (m) (kg/m) (N) (N-s/-) (N-m^2) (-) (-) (-) (-) +chain 0.2791 480.93 2.058e9 -0.02 0.0 1.37 0.64 1.0 0.0 +polyester 0.1438 22.42 1.42e8 -0.02 0.0 1.2 0.2 1.0 0.0 +--------------------- POINTS ------------------------------------------- +ID Type X Y Z Mass Vol CdA Ca +(-) (-) (m) (m) (m) (kg) (m^3) (m^2) (-) +1 Fixed 750.0 0.0 -200.0 0 0 0 0 +2 Coupled 58.0 0.0 -14.0 0 0 0 0 +--------------------- LINES -------------------------------------------- +ID NodeA NodeB Outputs +(-) (-) (-) (-) +1 2 1 - +--------------------- SECTIONS ----------------------------------------- +LineID LineType Length NumSegs +(-) (-) (m) (-) +1 chain 100.0 12 +1 polyester 400.0 40 +1 chain 250.0 25 +--------------------- OPTIONS ------------------------------------------ +9.80665 g - Gravitational acceleration (m/s^2) [default: 9.80665] +1025.0 rhoW - Water density (kg/m^3) [default: 1025] +200.0 WtrDpth - Water depth (m) [default: absent standalone; host-owned OpenFAST] +3.0e6 kBot - Seabed penalty stiffness base (Pa/m) [default: 1.0e5] +1.0e4 cBot - Seabed normal damping base (Pa-s/m) [default: 1.0e4] +0.05 dtM - CableDyn internal time step (s) [default: omitted standalone; the glue DT in OpenFAST] +60.0 TMax - Standalone simulation duration (s) [default: omitted standalone; host-owned OpenFAST] +mode1 axialDampingRatio - What a negative BA is the damping ratio of {segment=each segment, MoorDyn; mode1=first axial mode} [default: segment] +airy 4.0 10.0 0.0 waves - Wave model, height, period, and direction (m, s, deg) {none; airy; jonswap} [default: none] +10.0 rampTime - Half-cosine start-up ramp of the wave amplitudes (s) [default: 0] +0.4 rhoInf - Generalised-alpha spectral radius {0<=rhoInf<=1} [default: 0.4] +False modified_newton - Tangent-reuse mode {False=full Newton; True=guarded reuse} [default: False] +False adaptive_mesh - Automatic finite-EI refinement {False; True} [default: False] +dynamic_solver 1.0e-8 1.0e-14 30 12 - Relative tolerance, absolute tolerance, max iterations, backtracks [defaults shown] +none frictionMu - Seabed friction coefficient {none; value>=0} [default: none] +none current - Current model and velocity (m/s) {none; uniform; profile} [default: none] +0 WaterKin - Water-kinematics source {0/none; file; SEASTATE coupled only} [default: no policy] +-- Complete option/default reference: cabledyn_options_reference.dat and doc/options.rst. +--------------------- OUTPUTS ------------------------------------------ +"FairTen1" +"AnchTen1" +"FairIncl1" +"AnchIncl1" +--------------------- need this line ----------------------------------- diff --git a/examples/composite_chain_poly_chain_modes.dat b/examples/composite_chain_poly_chain_modes.dat new file mode 100644 index 00000000..6db484c2 --- /dev/null +++ b/examples/composite_chain_poly_chain_modes.dat @@ -0,0 +1,51 @@ +--------------------- CableDyn Input File ------------------------------------ +CableDyn driver deck -- natural periods and mode shapes of a chain-polyester-chain composite mooring +-- Modal analysis (nModes) of the three-section line of composite_chain_poly_chain.dat (200 m +-- depth): a 100 m chain at the fairlead, 400 m of polyester and a 250 m chain at the anchor, +-- partly grounded. The 12 lowest natural frequencies and mode shapes about the static +-- equilibrium, ends held, are written to .modes.out, with the Morison added mass of each +-- section and the linearised seabed contact stiffness of the grounded chain; the lowest is the +-- out-of-plane swing of the suspended span (51 s). The deck is static (no dtM/TMax), so no +-- time march follows. +--------------------- LINE TYPES --------------------------------------- +TypeName Diam MassDenInAir EA BA/-zeta EI Cd_n Cd_t Ca_n Ca_t +(-) (m) (kg/m) (N) (N-s/-) (N-m^2) (-) (-) (-) (-) +chain 0.2791 480.93 2.058e9 -1.0 0.0 1.37 0.64 1.0 0.0 +polyester 0.1438 22.42 1.42e8 -1.0 0.0 1.2 0.2 1.0 0.0 +--------------------- POINTS ------------------------------------------- +ID Type X Y Z Mass Vol CdA Ca +(-) (-) (m) (m) (m) (kg) (m^3) (m^2) (-) +1 Fixed 750.0 0.0 -200.0 0 0 0 0 +2 Coupled 58.0 0.0 -14.0 0 0 0 0 +--------------------- LINES -------------------------------------------- +ID NodeA NodeB Outputs +(-) (-) (-) (-) +1 2 1 - +--------------------- SECTIONS ----------------------------------------- +LineID LineType Length NumSegs +(-) (-) (m) (-) +1 chain 100.0 12 +1 polyester 400.0 40 +1 chain 250.0 25 +--------------------- OPTIONS ------------------------------------------ +9.80665 g - Gravitational acceleration (m/s^2) [default: 9.80665] +1025.0 rhoW - Water density (kg/m^3) [default: 1025] +200.0 WtrDpth - Water depth (m) [default: absent standalone; host-owned OpenFAST] +3.0e6 kBot - Seabed penalty stiffness base (Pa/m) [default: 1.0e5] +1.0e4 cBot - Seabed normal damping base (Pa-s/m) [default: 1.0e4] +0.4 rhoInf - Generalised-alpha spectral radius {0<=rhoInf<=1} [default: 0.4] +False modified_newton - Tangent-reuse mode {False=full Newton; True=guarded reuse} [default: False] +False adaptive_mesh - Automatic finite-EI refinement {False; True} [default: False] +dynamic_solver 1.0e-8 1.0e-14 30 12 - Relative tolerance, absolute tolerance, max iterations, backtracks [defaults shown] +none frictionMu - Seabed friction coefficient {none; value>=0} [default: none] +none current - Current model and velocity (m/s) {none; uniform; profile} [default: none] +none waves - Wave model, height, period, and direction (m, s, deg) {none; airy; jonswap} [default: none] +0 WaterKin - Water-kinematics source {0/none; file; SEASTATE coupled only} [default: no policy] +12 nModes - Modal analysis: number of lowest natural modes per line {0=off; 1 to 1000} [default: 0] +-- Complete option/default reference: cabledyn_options_reference.dat and doc/options.rst. +--------------------- OUTPUTS ------------------------------------------ +"FairTen1" +"AnchTen1" +"FairIncl1" +"AnchIncl1" +--------------------- need this line ----------------------------------- diff --git a/examples/composite_ve_syrope_jonswap.dat b/examples/composite_ve_syrope_jonswap.dat new file mode 100644 index 00000000..9042702b --- /dev/null +++ b/examples/composite_ve_syrope_jonswap.dat @@ -0,0 +1,71 @@ +--------------------- CableDyn Input File ------------------------------------ +CableDyn driver deck -- two chain-polyester-chain legs, viscoelastic and Syrope polyester, on a floater in a JONSWAP sea, 60 s +-- Two parallel legs 50 m apart from one floater, each a 100 m studless chain at the fairlead, +-- a 400 m polyester section and a 250 m chain at the anchor in 200 m of water, with the anchor +-- radius of composite_chain_syrope_chain.dat. The polyester of line 1 follows the viscoelastic +-- (series-Kelvin) law, MoorDyn ElasticMod 2: EA = Es|Ed, the static and dynamic stiffness, +-- BA = Bs|Bd. That of line 2 follows the Syrope working-curve model with the +-- settings and OWC table of syrope_polyester_mooring.dat: the static start puts every polyester +-- element on its rest curve, and the dynamic stiffness alpha + beta * mean load governs the wave +-- response. The floater moves in a long-crested JONSWAP sea (Hs 6 m, Tp 11 s, gamma 3.3, along +-- +X, ramped in over 15 s) by the illustrative RAO table data/vessel/sample_rao.txt (vesselRAO), +-- which carries both fairleads, 14 m below the surface; the same waves load the lines. Both +-- legs see the same motion and wave kinematics, so their tensions compare the two rope models: +-- the static stiffness sets the different pretensions (Es against the OWC), the dynamic +-- stiffness the wave-frequency tension range. +-- chain 155 mm R4 studless: volume-equivalent diam 0.2791 m, dry mass 480.93 kg/m, EA 2.058e9 N. +-- polyester 181.8 mm: diam 0.1438 m, dry mass 22.42 kg/m. +--------------------- LINE TYPES --------------------------------------- +TypeName Diam MassDenInAir EA BA EI Cd_n Cd_t Ca_n Ca_t +(-) (m) (kg/m) (-) (N-s|N-s) (N-m^2) (-) (-) (-) (-) +chain 0.2791 480.93 2.058e9 -1.0 0.0 1.37 0.64 1.0 0.0 +poly_ve 0.1438 22.42 1.424e8|2.50e8 4.0e9|1.1e7 0.0 1.2 0.2 1.0 0.0 +poly_syr 0.1438 22.42 "SYROPE:data/syrope/syrope_settings.dat|1.53e8|23.12" 5.0e10|1.0e5 0.0 1.2 0.2 1.0 0.0 +--------------------- POINTS ------------------------------------------- +ID Type X Y Z Mass Vol CdA Ca +(-) (-) (m) (m) (m) (kg) (m^3) (m^2) (-) +1 Fixed 780.0 -25.0 -200.0 0 0 0 0 +2 Coupled 58.0 -25.0 -14.0 0 0 0 0 +3 Fixed 780.0 25.0 -200.0 0 0 0 0 +4 Coupled 58.0 25.0 -14.0 0 0 0 0 +--------------------- LINES -------------------------------------------- +ID NodeA NodeB Outputs +(-) (-) (-) (-) +1 2 1 - +2 4 3 - +--------------------- SECTIONS ----------------------------------------- +LineID LineType Length NumSegs +(-) (-) (m) (-) +1 chain 100.0 12 +1 poly_ve 400.0 40 +1 chain 250.0 25 +2 chain 100.0 12 +2 poly_syr 400.0 40 +2 chain 250.0 25 +--------------------- OPTIONS ------------------------------------------ +9.80665 g - Gravitational acceleration (m/s^2) [default: 9.80665] +1025.0 rhoW - Water density (kg/m^3) [default: 1025] +200.0 WtrDpth - Water depth (m) [default: absent standalone; host-owned OpenFAST] +3.0e6 kBot - Seabed penalty stiffness base (Pa/m) [default: 1.0e5] +1.0e4 cBot - Seabed normal damping base (Pa-s/m) [default: 1.0e4] +0.05 dtM - CableDyn internal time step (s) [default: omitted standalone; the glue DT in OpenFAST] +60.0 TMax - Standalone simulation duration (s) [default: omitted standalone; host-owned OpenFAST] +jonswap 6.0 11.0 3.3 0.0 waves - Wave model, JONSWAP Hs, Tp, gamma, and direction (m, s, deg) {none; airy; jonswap} [default: none] +1 WaveSeed - Seed of the random sea {integer 1..2147483646; same seed = same sea} [default: 1] +15.0 rampTime - Half-cosine start-up ramp of the wave amplitudes (s) [default: 0] +data/vessel/sample_rao.txt vesselRAO - Displacement RAO table: vessel motion from the deck waves +0.0|0.0|0.0 vesselRef - Vessel reference point, rotation centre and RAO origin (m) [default: 0|0|0] +0.4 rhoInf - Generalised-alpha spectral radius {0<=rhoInf<=1} [default: 0.4] +False modified_newton - Tangent-reuse mode {False=full Newton; True=guarded reuse} [default: False] +False adaptive_mesh - Automatic finite-EI refinement {False; True} [default: False] +dynamic_solver 1.0e-8 1.0e-14 30 12 - Relative tolerance, absolute tolerance, max iterations, backtracks [defaults shown] +none frictionMu - Seabed friction coefficient {none; value>=0} [default: none] +none current - Current model and velocity (m/s) {none; uniform; profile} [default: none] +0 WaterKin - Water-kinematics source {0/none; file; SEASTATE coupled only} [default: no policy] +-- Complete option/default reference: cabledyn_options_reference.dat and doc/options.rst. +--------------------- OUTPUTS ------------------------------------------ +"FairTen1" +"AnchTen1" +"FairTen2" +"AnchTen2" +--------------------- need this line ----------------------------------- diff --git a/examples/data/bathymetry/sloped_seabed.txt b/examples/data/bathymetry/sloped_seabed.txt new file mode 100644 index 00000000..f88460c1 --- /dev/null +++ b/examples/data/bathymetry/sloped_seabed.txt @@ -0,0 +1,25 @@ +# File: examples/data/bathymetry/sloped_seabed.txt +# Bathymetry of chain_sloped_bathymetry_friction.dat: rows x y depth (m), one complete grid. +# A plane, depth = 60 - 0.0375 x + 0.05 y: rising 2.1 deg toward the anchor (+x) and falling +# 2.9 deg toward +y, across the line. +-100.0 -100.0 58.7500 +-100.0 0.0 63.7500 +-100.0 100.0 68.7500 +0.0 -100.0 55.0000 +0.0 0.0 60.0000 +0.0 100.0 65.0000 +100.0 -100.0 51.2500 +100.0 0.0 56.2500 +100.0 100.0 61.2500 +200.0 -100.0 47.5000 +200.0 0.0 52.5000 +200.0 100.0 57.5000 +300.0 -100.0 43.7500 +300.0 0.0 48.7500 +300.0 100.0 53.7500 +400.0 -100.0 40.0000 +400.0 0.0 45.0000 +400.0 100.0 50.0000 +500.0 -100.0 36.2500 +500.0 0.0 41.2500 +500.0 100.0 46.2500 diff --git a/examples/data/shared/floaters_surge_heave_12s_dt0025.txt b/examples/data/shared/floaters_surge_heave_12s_dt0025.txt new file mode 100644 index 00000000..15403964 --- /dev/null +++ b/examples/data/shared/floaters_surge_heave_12s_dt0025.txt @@ -0,0 +1,2887 @@ +# File: examples/data/shared/floaters_surge_heave_12s_dt0025.txt +# Hang-off motions of the two floaters of shared_cable_two_floaters.dat (motionFile). +# Each surges 2 m and heaves 1.5 m at 12 s; floater 2 surges in antiphase and heaves a +# quarter period behind floater 1. A 12 s C2 quintic ramp starts both smoothly. +# Columns: time(s) point_id x(m) y(m) z(m) vx(m/s) vy(m/s) vz(m/s) ax(m/s2) ay(m/s2) az(m/s2) +0.000 1 0 0 -14 0 0 0 0 0 0 +0.000 2 300 0 -14 0 0 0 0 0 0 +0.025 1 2.359795405e-09 0 -14 3.772664683e-07 0 2.829498513e-07 4.521162233e-05 0 3.390871675e-05 +0.025 2 300 0 -14.00000014 -3.772664683e-07 0 -1.620598018e-05 -4.521162233e-05 0 -0.00129358652 +0.050 1 3.763543845e-08 0 -13.99999997 3.005944914e-06 0 2.254458686e-06 0.0001798645984 0 0.0001348984488 +0.050 2 300 0 -14.00000108 -3.005944914e-06 0 -6.452585878e-05 -0.0001798645984 0 -0.002568758404 +0.075 1 1.899056403e-07 0 -13.99999986 1.010315661e-05 0 7.577367459e-06 0.0004024345575 0 0.0003018259181 +0.075 2 299.9999998 0 -14.00000363 -1.010315661e-05 0 -0.0001444729397 -0.0004024345575 0 -0.003823416475 +0.100 1 5.981937205e-07 0 -13.99999955 2.384706847e-05 0 1.788530135e-05 0.0007113298132 0 0.0005334973599 +0.100 2 299.9999994 0 -14.00000856 -2.384706847e-05 0 -0.0002555085947 -0.0007113298132 0 -0.005055505505 +0.125 1 1.455472895e-06 0 -13.99999891 4.637523214e-05 0 3.478142411e-05 0.001104893128 0 0.000828669846 +0.125 2 299.9999985 0 -14.00001665 -4.637523214e-05 0 -0.0003970433746 -0.001104893128 0 -0.006263015223 +0.150 1 3.007630595e-06 0 -13.99999774 7.978296757e-05 0 5.983722568e-05 0.001581403502 0 0.001186052626 +0.150 2 299.999997 0 -14.00002866 -7.978296757e-05 0 -0.0005684381457 -0.001581403502 0 -0.00744398129 +0.175 1 5.552392937e-06 0 -13.99999584 0.0001261217915 0 9.45913436e-05 0.00213907798 0 0.001604308485 +0.175 2 299.9999944 0 -14.00004532 -0.0001261217915 0 -0.0007690052499 -0.00213907798 0 -0.008596486242 +0.200 1 9.438210472e-06 0 -13.99999292 0.0001873978914 0 0.0001405484185 0.002776073488 0 0.002082055116 +0.200 2 299.9999906 0 -14.00006735 -0.0001873978914 0 -0.0009980096876 -0.002776073488 0 -0.00971866039 +0.225 1 1.506310636e-05 0 -13.9999887 0.0002655706456 0 0.0001991779842 0.003490488677 0 0.002617866507 +0.225 2 299.9999849 0 -14.00009545 -0.0002655706456 0 -0.001254670324 -0.003490488677 0 -0.0108086827 +0.250 1 2.287348812e-05 0 -13.99998284 0.0003625511897 0 0.0002719133923 0.004280365792 0 0.003210274344 +0.250 2 299.9999771 0 -14.00013031 -0.0003625511897 0 -0.001538161114 -0.004280365792 0 -0.01186478162 +0.275 1 3.336292414e-05 0 -13.99997498 0.0004802010302 0 0.0003601507727 0.005143692563 0 0.003857769422 +0.275 2 299.9999666 0 -14.00017258 -0.0004802010302 0 -0.001847612352 -0.005143692563 0 -0.01288523588 +0.300 1 4.70708861e-05 0 -13.9999647 0.000620330705 0 0.0004652480288 0.006078404103 0 0.004558803077 +0.300 2 299.9999529 0 -14.0002229 -0.000620330705 0 -0.002182111936 -0.006078404103 0 -0.01386837528 +0.325 1 6.458145852e-05 0 -13.99995156 0.0007846984921 0 0.0005885238691 0.007082384828 0 0.005311788621 +0.325 2 299.9999354 0 -14.00028188 -0.0007846984921 0 -0.002540706657 -0.007082384828 0 -0.01481258138 +0.350 1 8.652201663e-05 0 -13.99993511 0.0009750091664 0 0.0007312568748 0.008153470388 0 0.006115102791 +0.350 2 299.9999135 0 -14.00035012 -0.0009750091664 0 -0.002922403497 -0.008153470388 0 -0.01571628823 +0.375 1 0.0001135618737 0 -13.99991483 0.001192912805 0 0.0008946846034 0.009289449612 0 0.006967087209 +0.375 2 299.9998864 0 -14.00042819 -0.001192912805 0 -0.003326170953 -0.009289449612 0 -0.01657798299 +0.400 1 0.0001464108993 0 -13.99989019 0.001440003639 0 0.001080002729 0.01048806647 0 0.00786604985 +0.400 2 299.9998536 0 -14.00051661 -0.001440003639 0 -0.003750940372 -0.01048806647 0 -0.01739620661 +0.425 1 0.0001858181092 0 -13.99986064 0.001717818962 0 0.001288364221 0.01174702202 0 0.008810266518 +0.425 2 299.9998142 0 -14.0006159 -0.001717818962 0 -0.004195607302 -0.01174702202 0 -0.01816955436 +0.450 1 0.0002325702287 0 -13.99982557 0.002027838075 0 0.001520878556 0.01306397644 0 0.00979798233 +0.450 2 299.9997674 0 -14.00072654 -0.002027838075 0 -0.00465903286 -0.01306397644 0 -0.0188966764 +0.475 1 0.0002874902305 0 -13.99978438 0.002371481295 0 0.001778610971 0.01443655094 0 0.0108274132 +0.475 2 299.9997125 0 -14.000849 -0.002371481295 0 -0.005140045105 -0.01443655094 0 -0.0195762783 +0.500 1 0.0003514358477 0 -13.99973642 0.002750109001 0 0.002062581751 0.01586232981 0 0.01189674736 +0.500 2 299.9996486 0 -14.00098368 -0.002750109001 0 -0.005637440437 -0.01586232981 0 -0.02020712151 +0.525 1 0.0004252980646 0 -13.99968103 0.003165020742 0 0.002373765557 0.01733886242 0 0.01300414682 +0.525 2 299.9995747 0 -14.00113099 -0.003165020742 0 -0.006149984991 -0.01733886242 0 -0.02078802383 +0.550 1 0.0005099995847 0 -13.9996175 0.003617454383 0 0.002713090787 0.0188636652 0 0.0141477489 +0.550 2 299.99949 0 -14.0012913 -0.003617454383 0 -0.006676416059 -0.0188636652 0 -0.02131785976 +0.575 1 0.0006064932787 0 -13.99954513 0.004108585308 0 0.003081438981 0.02043422367 0 0.01532566775 +0.575 2 299.9993935 0 -14.00146492 -0.004108585308 0 -0.007215443507 -0.02043422367 0 -0.02179556092 +0.600 1 0.0007157606132 0 -13.99946318 0.004639525676 0 0.003479644257 0.02204799446 0 0.01653599584 +0.600 2 299.9992842 0 -14.00165216 -0.004639525676 0 -0.007765751208 -0.02204799446 0 -0.02222011635 +0.625 1 0.0008388100611 0 -13.99937089 0.005211323722 0 0.003908492791 0.0237024073 0 0.01777680548 +0.625 2 299.9991612 0 -14.00185329 -0.005211323722 0 -0.008325998484 -0.0237024073 0 -0.02259057285 +0.650 1 0.0009766754952 0 -13.99926749 0.005824963106 0 0.004368722329 0.02539486709 0 0.01904615032 +0.650 2 299.9990233 0 -14.00206853 -0.005824963106 0 -0.00889482155 -0.02539486709 0 -0.0229060352 +0.675 1 0.001130414567 0 -13.99915219 0.006481362323 0 0.004861021743 0.02712275587 0 0.0203420669 +0.675 2 299.9988696 0 -14.00229809 -0.006481362323 0 -0.009470834968 -0.02712275587 0 -0.02316566641 +0.700 1 0.001301107068 0 -13.99902417 0.007181374156 0 0.005386030617 0.02888343486 0 0.02166257615 +0.700 2 299.9986989 0 -14.00254212 -0.007181374156 0 -0.01005263311 -0.02888343486 0 -0.02336868789 +0.725 1 0.001489853286 0 -13.99888261 0.007925785176 0 0.005944338882 0.03067424649 0 0.02300568487 +0.725 2 299.9985101 0 -14.00280076 -0.007925785176 0 -0.0106387916 -0.03067424649 0 -0.02351437965 +0.750 1 0.001697772338 0 -13.99872667 0.008715315304 0 0.006536486478 0.03249251639 0 0.02436938729 +0.750 2 299.9983022 0 -14.00307409 -0.008715315304 0 -0.01122786881 -0.03249251639 0 -0.02360208036 +0.775 1 0.001926000503 0 -13.9985555 0.009550617409 0 0.007162963057 0.03433555542 0 0.02575166657 +0.775 2 299.998074 0 -14.00336217 -0.009550617409 0 -0.01181840732 -0.03433555542 0 -0.02363118747 +0.800 1 0.00217568954 0 -13.99836823 0.01043227697 0 0.007824207728 0.03620066167 0 0.02715049626 +0.800 2 299.9978243 0 -14.00366501 -0.01043227697 0 -0.01240893536 -0.03620066167 0 -0.02360115729 +0.825 1 0.002448004998 0 -13.998164 0.01136081178 0 0.008520608837 0.03808512247 0 0.02856384185 +0.825 2 299.997552 0 -14.0039826 -0.01136081178 0 -0.01299796832 -0.03808512247 0 -0.02351150492 +0.850 1 0.002744124524 0 -13.99794191 0.01233667171 0 0.009252503779 0.03998621636 0 0.02998966227 +0.850 2 299.9972559 0 -14.00431488 -0.01233667171 0 -0.01358401019 -0.03998621636 0 -0.02336180433 +0.875 1 0.003065236159 0 -13.99770107 0.01336023848 0 0.01002017886 0.04190121509 0 0.03142591132 +0.875 2 299.9969348 0 -14.00466176 -0.01336023848 0 -0.01416555505 -0.04190121509 0 -0.02315168822 +0.900 1 0.003412536636 0 -13.9974406 0.01443182556 0 0.01082386917 0.04382738564 0 0.03287053923 +0.900 2 299.9965875 0 -14.00502311 -0.01443182556 0 -0.01474108855 -0.04382738564 0 -0.022880848 +0.925 1 0.003787229668 0 -13.99715958 0.01555167806 0 0.01166375854 0.04576199209 0 0.03432149407 +0.925 2 299.9962128 0 -14.00539875 -0.01555167806 0 -0.01530908932 -0.04576199209 0 -0.02254903361 +0.950 1 0.004190524242 0 -13.99685711 0.01671997266 0 0.01253997949 0.0477022977 0 0.03577672328 +0.950 2 299.9958095 0 -14.00578849 -0.01671997266 0 -0.0158680305 -0.0477022977 0 -0.02215605343 +0.975 1 0.004623632906 0 -13.99653228 0.01793681764 0 0.01345261323 0.04964556675 0 0.03723417506 +0.975 2 299.9953764 0 -14.00619207 -0.01793681764 0 -0.01641638115 -0.04964556675 0 -0.02170177403 +1.000 1 0.005087770062 0 -13.99618417 0.01920225292 0 0.01440168969 0.05158906654 0 0.0386917999 +1.000 2 299.9949122 0 -14.00660921 -0.01920225292 0 -0.01695260773 -0.05158906654 0 -0.02118611997 +1.025 1 0.005584150254 0 -13.99581189 0.02051625015 0 0.01538718761 0.05353006927 0 0.04014755195 +1.025 2 299.9944158 0 -14.00703958 -0.02051625015 0 -0.01747517553 -0.05353006927 0 -0.02060907357 +1.050 1 0.006113986467 0 -13.99541451 0.02187871289 0 0.01640903467 0.05546585399 0 0.04159939049 +1.050 2 299.993886 0 -14.00748284 -0.02187871289 0 -0.01798255012 -0.05546585399 0 -0.0199706746 +1.075 1 0.006678488427 0 -13.99499113 0.02328947676 0 0.01746710757 0.05739370845 0 0.04304528134 +1.075 2 299.9933215 0 -14.00793857 -0.02328947676 0 -0.01847319878 -0.05739370845 0 -0.01927101993 +1.100 1 0.0072788609 0 -13.99454085 0.02474830971 0 0.01856123228 0.059310931 0 0.04448319825 +1.100 2 299.9927211 0 -14.00840635 -0.02474830971 0 -0.01894559192 -0.059310931 0 -0.01851026327 +1.125 1 0.007916302011 0 -13.99406277 0.0262549123 0 0.01969118423 0.06121483245 0 0.04591112433 +1.125 2 299.9920837 0 -14.00888569 -0.0262549123 0 -0.01939820449 -0.06121483245 0 -0.01768861468 +1.150 1 0.00859200156 0 -13.993556 0.02780891803 0 0.02085668852 0.06310273787 0 0.0473270534 +1.150 2 299.991408 0 -14.00937608 -0.02780891803 0 -0.01982951742 -0.06310273787 0 -0.01680634024 +1.175 1 0.009307139348 0 -13.99301965 0.02940989373 0 0.0220574203 0.06497198849 0 0.04872899136 +1.175 2 299.9906929 0 -14.00987697 -0.02940989373 0 -0.02023801896 -0.06497198849 0 -0.01586376156 +1.200 1 0.01006288352 0 -13.99245284 0.03105733999 0 0.02329300499 0.06681994341 0 0.05011495756 +1.200 2 299.9899371 0 -14.01038778 -0.03105733999 0 -0.02062220609 -0.06681994341 0 -0.01486125534 +1.225 1 0.01086038891 0 -13.99185471 0.03275069159 0 0.02456301869 0.06864398146 0 0.0514829861 +1.225 2 299.9891396 0 -14.01090787 -0.03275069159 0 -0.0209805859 -0.06864398146 0 -0.01379925282 +1.250 1 0.01170079541 0 -13.9912244 0.03448931808 0 0.02586698856 0.07044150292 0 0.05283112719 +1.250 2 299.9882992 0 -14.01143658 -0.03448931808 0 -0.02131167695 -0.07044150292 0 -0.01267823929 +1.275 1 0.01258522633 0 -13.99056108 0.03627252429 0 0.02720439321 0.07220993127 0 0.05415744845 +1.275 2 299.9874148 0 -14.01197321 -0.03627252429 0 -0.02161401059 -0.07220993127 0 -0.01149875351 +1.300 1 0.01351478681 0 -13.98986391 0.03809955093 0 0.0285746632 0.0739467149 0 0.05546003618 +1.300 2 299.9864852 0 -14.01251703 -0.03809955093 0 -0.02188613228 -0.0739467149 0 -0.01026138713 +1.325 1 0.01449056221 0 -13.98913208 0.03996957528 0 0.02997718146 0.07564932882 0 0.05673699662 +1.325 2 299.9855094 0 -14.01306726 -0.03996957528 0 -0.02212660296 -0.07564932882 0 -0.008966784064 +1.350 1 0.01551361653 0 -13.98836479 0.04188171181 0 0.03141128386 0.07731527631 0 0.05798645723 +1.350 2 299.9844864 0 -14.01362308 -0.04188171181 0 -0.02233400029 -0.07731527631 0 -0.007615639826 +1.375 1 0.01658499085 0 -13.98756126 0.04383501297 0 0.03287625973 0.07894209057 0 0.05920656792 +1.375 2 299.983415 0 -14.01418367 -0.04383501297 0 -0.02250691998 -0.07894209057 0 -0.006208700891 +1.400 1 0.01770570182 0 -13.98672072 0.04582846992 0 0.03437135244 0.08052733634 0 0.06039550225 +1.400 2 299.9822943 0 -14.01474813 -0.04582846992 0 -0.022643977 -0.08052733634 0 -0.004746763974 +1.425 1 0.01887674009 0 -13.98584244 0.04786101336 0 0.03589576002 0.0820686115 0 0.06155145863 +1.425 2 299.9811233 0 -14.01531556 -0.04786101336 0 -0.0227438069 -0.0820686115 0 -0.003230675309 +1.450 1 0.02009906882 0 -13.9849257 0.04993151434 0 0.03744863575 0.08356354863 0 0.06267266147 +1.450 2 299.9799009 0 -14.015885 -0.04993151434 0 -0.02280506695 -0.08356354863 0 -0.001661329897 +1.475 1 0.02137362224 0 -13.98396978 0.0520387852 0 0.0390290889 0.08500981652 0 0.06375736239 +1.475 2 299.9786264 0 -14.01645548 -0.0520387852 0 -0.02282643743 -0.08500981652 0 -3.967073148e-05 +1.500 1 0.02270130413 0 -13.98297402 0.05418158047 0 0.04063618535 0.08640512174 0 0.0648038413 +1.500 2 299.9772987 0 -14.01702598 -0.05418158047 0 -0.02280662278 -0.08640512174 0 0.001633312007 +1.525 1 0.02408298646 0 -13.98193776 0.0563585978 0 0.04226894835 0.08774721005 0 0.06581040754 +1.525 2 299.975917 0 -14.01759546 -0.0563585978 0 -0.02274435276 -0.08774721005 0 0.003356581771 +1.550 1 0.0255195079 0 -13.98086037 0.05856847904 0 0.04392635928 0.0890338679 0 0.06677540092 +1.550 2 299.9744805 0 -14.01816283 -0.05856847904 0 -0.02263838363 -0.0890338679 0 0.005129056501 +1.575 1 0.02701167252 0 -13.97974125 0.06080981117 0 0.04560735838 0.09026292383 0 0.06769719287 +1.575 2 299.9729883 0 -14.018727 -0.06080981117 0 -0.02248749927 -0.09026292383 0 0.00694960949 +1.600 1 0.02856024834 0 -13.97857981 0.06308112747 0 0.0473108456 0.09143224986 0 0.06857418739 +1.600 2 299.9714398 0 -14.01928682 -0.06308112747 0 -0.02229051225 -0.09143224986 0 0.008817070284 +1.625 1 0.03016596611 0 -13.97737553 0.06538090854 0 0.04903568141 0.09253976285 0 0.06940482214 +1.625 2 299.969834 0 -14.01984113 -0.06538090854 0 -0.02204626496 -0.09253976285 0 0.01073022559 +1.650 1 0.0318295179 0 -13.97612786 0.06770758351 0 0.05078068763 0.09358342583 0 0.07018756937 +1.650 2 299.9681705 0 -14.02038873 -0.06770758351 0 -0.02175363063 -0.09358342583 0 0.01268782024 +1.675 1 0.0335515559 0 -13.97483633 0.07005953116 0 0.05254464837 0.09456124927 0 0.07092093696 +1.675 2 299.9664484 0 -14.0209284 -0.07005953116 0 -0.02141151441 -0.09456124927 0 0.01468855808 +1.700 1 0.03533269116 0 -13.97350048 0.07243508113 0 0.05432631084 0.09547129239 0 0.0716034693 +1.700 2 299.9646673 0 -14.02145889 -0.07243508113 0 -0.02101885432 -0.09547129239 0 0.01673110305 +1.725 1 0.03717349234 0 -13.97211988 0.07483251517 0 0.05612438638 0.09631166433 0 0.07223374825 +1.725 2 299.9628265 0 -14.02197891 -0.07483251517 0 -0.02057462231 -0.09631166433 0 0.01881408009 +1.750 1 0.03907448459 0 -13.97069414 0.0772500684 0 0.0579375513 0.09708052538 0 0.07281039403 +1.750 2 299.9609255 0 -14.02248718 -0.0772500684 0 -0.02007782515 -0.09708052538 0 0.0209360762 +1.775 1 0.04103614835 0 -13.96922289 0.0796859306 0 0.05976444795 0.0977760881 0 0.07333206608 +1.775 2 299.9589639 0 -14.02298236 -0.0796859306 0 -0.01952750541 -0.0977760881 0 0.02309564148 +1.800 1 0.04305891825 0 -13.96770581 0.08213824752 0 0.06160368564 0.09839661851 0 0.07379746388 +1.800 2 299.9569411 0 -14.0234631 -0.08213824752 0 -0.01892274237 -0.09839661851 0 0.02529129015 +1.825 1 0.04514318205 0 -13.96614261 0.08460512225 0 0.06345384169 0.09894043709 0 0.07420532782 +1.825 2 299.9548568 0 -14.02392804 -0.08460512225 0 -0.01826265287 -0.09894043709 0 0.02752150165 +1.850 1 0.04728927954 0 -13.96453304 0.08708461656 0 0.06531346242 0.09940591992 0 0.07455443994 +1.850 2 299.9527107 0 -14.02437577 -0.08708461656 0 -0.01754639221 -0.09940591992 0 0.02978472171 +1.875 1 0.04949750157 0 -13.96287687 0.08957475237 0 0.06718106428 0.09979149961 0 0.07484362471 +1.875 2 299.9505025 0 -14.02480488 -0.08957475237 0 -0.01677315493 -0.09979149961 0 0.03207936345 +1.900 1 0.05176808904 0 -13.96117393 0.09207351309 0 0.06905513482 0.1000956664 0 0.07507174977 +1.900 2 299.9482319 0 -14.02521394 -0.09207351309 0 -0.01594217567 -0.1000956664 0 0.0344038085 +1.925 1 0.05410123199 0 -13.95942408 0.09457884513 0 0.07093413385 0.1003169688 0 0.07523772664 +1.925 2 299.9458988 0 -14.0256015 -0.09457884513 0 -0.01505272988 -0.1003169688 0 0.03675640814 +1.950 1 0.05649706866 0 -13.9576272 0.09708865938 0 0.07281649453 0.1004540151 0 0.07534051136 +1.950 2 299.9435029 0 -14.02596609 -0.09708865938 0 -0.01410413461 -0.1004540151 0 0.03913548444 +1.975 1 0.05895568463 0 -13.95578324 0.09960083264 0 0.07470062448 0.1005054736 0 0.07537910519 +1.975 2 299.9410443 0 -14.02630621 -0.09960083264 0 -0.01309574923 -0.1005054736 0 0.04153933139 +2.000 1 0.061477112 0 -13.95389217 0.1021132092 0 0.07658490692 0.1004700736 0 0.07535255522 +2.000 2 299.9385229 0 -14.02662037 -0.1021132092 0 -0.01202697605 -0.1004700736 0 0.04396621611 +2.025 1 0.06406132857 0 -13.951954 0.1046236024 0 0.07846770181 0.1003466066 0 0.07525995494 +2.025 2 299.9359387 0 -14.02690705 -0.1046236024 0 -0.01089726109 -0.1003466066 0 0.04641438003 +2.050 1 0.06670825713 0 -13.94996881 0.1071297961 0 0.08034734707 0.1001339264 0 0.07510044481 +2.050 2 299.9332917 0 -14.02716472 -0.1071297961 0 -0.009706094579 -0.1001339264 0 0.04888204003 +2.075 1 0.06941776469 0 -13.94793668 0.1096295463 0 0.08222215969 0.09983095044 0 0.07487321283 +2.075 2 299.9305822 0 -14.02739184 -0.1096295463 0 -0.008453011665 -0.09983095044 0 0.05136738973 +2.100 1 0.07218966183 0 -13.94585775 0.1121205826 0 0.08409043698 0.09943666001 0 0.07457749501 +2.100 2 299.9278103 0 -14.02758685 -0.1121205826 0 -0.007137592911 -0.09943666001 0 0.05386860061 +2.125 1 0.07502370209 0 -13.94373222 0.1146006103 0 0.08595045775 0.09895010114 0 0.07421257586 +2.125 2 299.9249763 0 -14.0277482 -0.1146006103 0 -0.005759464863 -0.09895010114 0 0.05638382332 +2.150 1 0.0779195813 0 -13.94156031 0.1170673114 0 0.08780048353 0.0983703851 0 0.07377778882 +2.150 2 299.9220804 0 -14.0278743 -0.1170673114 0 -0.00431830055 -0.0983703851 0 0.05891118884 +2.175 1 0.08087693711 0 -13.9393423 0.1195183464 0 0.0896387598 0.09769668897 0 0.07327251673 +2.175 2 299.9191231 0 -14.02796358 -0.1195183464 0 -0.002813819955 -0.09769668897 0 0.06144880977 +2.200 1 0.08389534842 0 -13.93707849 0.1219513563 0 0.09146351725 0.0969282562 0 0.07269619215 +2.200 2 299.9161047 0 -14.02801446 -0.1219513563 0 -0.001245790466 -0.0969282562 0 0.06399478155 +2.225 1 0.08697433491 0 -13.93476925 0.124363964 0 0.09327297298 0.09606439703 0 0.07204829777 +2.225 2 299.9130257 0 -14.02802534 -0.124363964 0 0.0003859727132 -0.09606439703 0 0.06654718372 +2.250 1 0.09011335665 0 -13.93241498 0.1267537758 0 0.09506533181 0.09510448895 0 0.07132836671 +2.250 2 299.9098866 0 -14.02799463 -0.1267537758 0 0.002081606184 -0.09510448895 0 0.06910408117 +2.275 1 0.09331181367 0 -13.93001614 0.1291183834 0 0.09683878753 0.09404797713 0 0.07053598285 +2.275 2 299.9066882 0 -14.02792073 -0.1291183834 0 0.003841197998 -0.09404797713 0 0.07166352543 +2.300 1 0.09656904561 0 -13.92757322 0.1314553655 0 0.09859152413 0.09289437473 0 0.06967078105 +2.300 2 299.903431 0 -14.02780204 -0.1314553655 0 0.005664787344 -0.09289437473 0 0.07422355591 +2.325 1 0.09988433146 0 -13.92508675 0.1337622895 0 0.1003217171 0.09164326324 0 0.06873244743 +2.325 2 299.9001157 0 -14.02763696 -0.1337622895 0 0.007552364253 -0.09164326324 0 0.07678220119 +2.350 1 0.1032568893 0 -13.92255733 0.1360367132 0 0.1020275349 0.09029429276 0 0.06772071957 +2.350 2 299.8967431 0 -14.02742389 -0.1360367132 0 0.009503869354 -0.09029429276 0 0.07933748027 +2.375 1 0.1066858759 0 -13.91998559 0.1382761863 0 0.1037071397 0.08884718226 0 0.06663538669 +2.375 2 299.8933141 0 -14.02716123 -0.1382761863 0 0.01151919364 -0.08884718226 0 0.08188740389 +2.400 1 0.1101703868 0 -13.91737221 0.1404782526 0 0.1053586895 0.08730171972 0 0.06547628979 +2.400 2 299.8898296 0 -14.0268474 -0.1404782526 0 0.01359817829 -0.08730171972 0 0.08442997579 +2.425 1 0.1137094563 0 -13.91471791 0.1426404515 0 0.1069803386 0.08565776234 0 0.06424332175 +2.425 2 299.8862905 0 -14.02648079 -0.1426404515 0 0.01574061448 -0.08565776234 0 0.08696319395 +2.450 1 0.1173020567 0 -13.91202346 0.1447603193 0 0.1085702395 0.08391523665 0 0.06293642748 +2.450 2 299.8826979 0 -14.02605984 -0.1447603193 0 0.01794624332 -0.08391523665 0 0.08948505196 +2.475 1 0.1209470989 0 -13.90928968 0.1468353918 0 0.1101265439 0.08207413857 0 0.06155560392 +2.475 2 299.8790529 0 -14.02558296 -0.1468353918 0 0.02021475567 -0.08207413857 0 0.09199354022 +2.500 1 0.1246434324 0 -13.90651743 0.1488632054 0 0.111647404 0.08013453346 0 0.0601009001 +2.500 2 299.8753566 0 -14.02504858 -0.1488632054 0 0.02254579215 -0.08013453346 0 0.09448664725 +2.525 1 0.1283898449 0 -13.90370762 0.1508412987 0 0.1131309741 0.07809655614 0 0.05857241711 +2.525 2 299.8716102 0 -14.02445515 -0.1508412987 0 0.02493894308 -0.07809655614 0 0.09696236098 +2.550 1 0.1321850626 0 -13.9008612 0.1527672151 0 0.1145754113 0.0759604108 0 0.0569703081 +2.550 2 299.8678149 0 -14.02380112 -0.1527672151 0 0.02739374849 -0.0759604108 0 0.09941867002 +2.575 1 0.1360277504 0 -13.89797919 0.1546385035 0 0.1159788776 0.07372637096 0 0.05529477822 +2.575 2 299.8639722 0 -14.02308495 -0.1546385035 0 0.02990969813 -0.07372637096 0 0.1018535649 +2.600 1 0.1399165121 0 -13.89506262 0.1564527207 0 0.1173395405 0.07139477935 0 0.05354608452 +2.600 2 299.8600835 0 -14.02230513 -0.1564527207 0 0.03248623157 -0.07139477935 0 0.1042650395 +2.625 1 0.1438498906 0 -13.89211258 0.1582074329 0 0.1186555747 0.06896604773 0 0.0517245358 +2.625 2 299.8561501 0 -14.02146014 -0.1582074329 0 0.03512273825 -0.06896604773 0 0.1066510919 +2.650 1 0.1478263677 0 -13.88913022 0.1599002175 0 0.1199251632 0.06644065671 0 0.04983049253 +2.650 2 299.8521736 0 -14.0205485 -0.1599002175 0 0.03781855768 -0.06644065671 0 0.1090097262 +2.675 1 0.1518443653 0 -13.88611673 0.1615286648 0 0.1211464986 0.06381915549 0 0.04786436662 +2.675 2 299.8481556 0 -14.01956873 -0.1615286648 0 0.04057297951 -0.06381915549 0 0.1113389535 +2.700 1 0.1559022448 0 -13.88307332 0.1630903795 0 0.1223177846 0.06110216164 0 0.04582662123 +2.700 2 299.8440978 0 -14.01851937 -0.1630903795 0 0.04338524379 -0.06110216164 0 0.113636793 +2.725 1 0.1599983083 0 -13.88000127 0.1645829828 0 0.1234372371 0.05829036071 0 0.04371777053 +2.725 2 299.8400017 0 -14.01739899 -0.1645829828 0 0.04625454116 -0.05829036071 0 0.1159012735 +2.750 1 0.1641307984 0 -13.8769019 0.1660041138 0 0.1245030853 0.05538450596 0 0.04153837947 +2.750 2 299.8358692 0 -14.01620617 -0.1660041138 0 0.04918001313 -0.05538450596 0 0.1181304345 +2.775 1 0.1682978989 0 -13.87377658 0.1673514312 0 0.1255135734 0.0523854179 0 0.03928906343 +2.775 2 299.8317021 0 -14.01493953 -0.1673514312 0 0.05216075231 -0.0523854179 0 0.1203223274 +2.800 1 0.1724977355 0 -13.8706267 0.1686226151 0 0.1264669613 0.04929398393 0 0.03697048795 +2.800 2 299.8275023 0 -14.01359768 -0.1686226151 0 0.0551958028 -0.04929398393 0 0.1224750169 +2.825 1 0.1767283761 0 -13.86745372 0.1698153687 0 0.1273615265 0.0461111578 0 0.03458336835 +2.825 2 299.8232716 0 -14.01217929 -0.1698153687 0 0.05828416045 -0.0461111578 0 0.1245865822 +2.850 1 0.1809878314 0 -13.86425913 0.1709274199 0 0.1281955649 0.0428379592 0 0.0321284694 +2.850 2 299.8190122 0 -14.01068304 -0.1709274199 0 0.06142477332 -0.0428379592 0 0.1266551177 +2.875 1 0.1852740558 0 -13.86104446 0.1719565226 0 0.128967392 0.03947547315 0 0.02960660486 +2.875 2 299.8147259 0 -14.00910763 -0.1719565226 0 0.06461654202 -0.03947547315 0 0.128678735 +2.900 1 0.1895849478 0 -13.85781129 0.172900459 0 0.1296753443 0.03602484947 0 0.0270186371 +2.900 2 299.8104151 0 -14.00745179 -0.172900459 0 0.06785832016 -0.03602484947 0 0.1306555635 +2.925 1 0.1939183508 0 -13.85456124 0.1737570407 0 0.1303177805 0.03248730216 0 0.02436547662 +2.925 2 299.8060816 0 -14.0057143 -0.1737570407 0 0.07114891485 -0.03248730216 0 0.1325837517 +2.950 1 0.1982720539 0 -13.85129596 0.1745241104 0 0.1308930828 0.02886410874 0 0.02164808156 +2.950 2 299.8017279 0 -14.00389395 -0.1745241104 0 0.07448708714 -0.02886410874 0 0.1344614683 +2.975 1 0.2026437927 0 -13.84801716 0.1751995436 0 0.1313996577 0.02515660962 0 0.01886745721 +2.975 2 299.7973562 0 -14.00198956 -0.1751995436 0 0.07787155259 -0.02515660962 0 0.1362869038 +3.000 1 0.20703125 0 -13.84472656 0.17578125 0 0.1318359375 0.02136620733 0 0.0160246555 +3.000 2 299.7929688 0 -14 -0.17578125 0 0.08130098176 -0.02136620733 0 0.1380582709 +3.025 1 0.211432057 0 -13.84142596 0.1762671753 0 0.1322003814 0.01749436582 0 0.01312077436 +3.025 2 299.7885679 0 -13.99792415 -0.1762671753 0 0.08477400086 -0.01749436582 0 0.1397738061 +3.050 1 0.2158437938 0 -13.83811715 0.1766553023 0 0.1324914767 0.01354260965 0 0.01015695724 +3.050 2 299.7841562 0 -13.99576095 -0.1766553023 0 0.0882891923 -0.01354260965 0 0.1414317708 +3.075 1 0.2202639906 0 -13.83480201 0.176943653 0 0.1327077397 0.009512523201 0 0.007134392401 +3.075 2 299.779736 0 -13.99350935 -0.176943653 0 0.09184509536 -0.009512523201 0 0.143030452 +3.100 1 0.2246901288 0 -13.8314824 0.1771302894 0 0.1328477171 0.005405749815 0 0.004054312361 +3.100 2 299.7753099 0 -13.99116837 -0.1771302894 0 0.09544020682 -0.005405749815 0 0.1445681639 +3.125 1 0.2291196416 0 -13.82816027 0.1772133156 0 0.1329099867 0.001223990923 0 0.0009179931919 +3.125 2 299.7708804 0 -13.98873703 -0.1772133156 0 0.09907298166 -0.001223990923 0 0.1460432487 +3.150 1 0.2335499157 0 -13.82483756 0.1771908787 0 0.132893159 -0.003030994866 0 -0.002273246149 +3.150 2 299.7664501 0 -13.98621442 -0.1771908787 0 0.1027418338 0.003030994866 0 0.1474540774 +3.175 1 0.2379782916 0 -13.82151628 0.1770611707 0 0.132795878 -0.007357392698 0 -0.005518044523 +3.175 2 299.7620217 0 -13.98359965 -0.1770611707 0 0.1064451367 0.007357392698 0 0.1487990514 +3.200 1 0.2424020656 0 -13.81819845 0.1768224295 0 0.1326168222 -0.01175333245 0 -0.008814999337 +3.200 2 299.7575979 0 -13.98089189 -0.1768224295 0 0.1101812245 0.01175333245 0 0.1500766029 +3.225 1 0.2468184902 0 -13.81488613 0.1764729406 0 0.1323547054 -0.01621688973 0 -0.0121626673 +3.225 2 299.7531815 0 -13.97809033 -0.1764729406 0 0.1139483922 0.01621688973 0 0.1512851962 +3.250 1 0.2512247758 0 -13.81158142 0.176011038 0 0.1320082785 -0.02074608689 0 -0.01555956517 +3.250 2 299.7487752 0 -13.97519422 -0.176011038 0 0.1177448971 0.02074608689 0 0.1524233288 +3.275 1 0.2556180919 0 -13.80828643 0.1754351062 0 0.1315763296 -0.02533889413 0 -0.0190041706 +3.275 2 299.7443819 0 -13.97220286 -0.1754351062 0 0.1215689592 0.02533889413 0 0.153489532 +3.300 1 0.2599955679 0 -13.80500332 0.1747435806 0 0.1310576854 -0.02999323051 0 -0.02249492288 +3.300 2 299.7400044 0 -13.96911556 -0.1747435806 0 0.1254187623 0.02999323051 0 0.1544823721 +3.325 1 0.264354295 0 -13.80173428 0.1739349496 0 0.1304512122 -0.03470696512 0 -0.02603022384 +3.325 2 299.7356457 0 -13.96593172 -0.1739349496 0 0.1292924548 0.03470696512 0 0.1554004512 +3.350 1 0.2686913273 0 -13.7984815 0.1730077555 0 0.1297558166 -0.03947791823 0 -0.02960843867 +3.350 2 299.7313087 0 -13.96265075 -0.1730077555 0 0.1331881505 0.03947791823 0 0.1562424082 +3.375 1 0.273003683 0 -13.79524724 0.1719605954 0 0.1289704466 -0.0443038624 0 -0.0332278968 +3.375 2 299.7269963 0 -13.95927214 -0.1719605954 0 0.1371039298 0.0443038624 0 0.1570069194 +3.400 1 0.2772883461 0 -13.79203374 0.1707921231 0 0.1280940923 -0.0491825237 0 -0.03688689278 +3.400 2 299.7227117 0 -13.95579541 -0.1707921231 0 0.1410378404 0.0491825237 0 0.1576926997 +3.425 1 0.2815422675 0 -13.7888433 0.1695010493 0 0.127125787 -0.05411158297 0 -0.04058368723 +3.425 2 299.7184577 0 -13.95222012 -0.1695010493 0 0.1449878983 0.05411158297 0 0.1582985033 +3.450 1 0.2857623666 0 -13.78567823 0.1680861436 0 0.1260646077 -0.05908867697 0 -0.04431650773 +3.450 2 299.7142376 0 -13.94854589 -0.1680861436 0 0.148952089 0.05908867697 0 0.1588231244 +3.475 1 0.289945533 0 -13.78254085 0.1665462352 0 0.1249096764 -0.06411139975 0 -0.04808354981 +3.475 2 299.7100545 0 -13.94477241 -0.1665462352 0 0.1529283683 0.06411139975 0 0.159265398 +3.500 1 0.2940886274 0 -13.77943353 0.1648802138 0 0.1236601603 -0.06917730385 0 -0.05188297789 +3.500 2 299.7059114 0 -13.94089939 -0.1648802138 0 0.1569146633 0.06917730385 0 0.1596242008 +3.525 1 0.298188484 0 -13.77635864 0.1630870308 0 0.1223152731 -0.07428390165 0 -0.05571292624 +3.525 2 299.7018115 0 -13.93692661 -0.1630870308 0 0.1609088737 0.07428390165 0 0.159898452 +3.550 1 0.3022419111 0 -13.77331857 0.1611657006 0 0.1208742755 -0.07942866672 0 -0.05957150004 +3.550 2 299.6977581 0 -13.9328539 -0.1611657006 0 0.1649088727 0.07942866672 0 0.1600871136 +3.575 1 0.3062456934 0 -13.77031573 0.1591153008 0 0.1193364756 -0.08460903512 0 -0.06345677634 +3.575 2 299.6937543 0 -13.92868114 -0.1591153008 0 0.1689125079 0.08460903512 0 0.1601891916 +3.600 1 0.3101965934 0 -13.76735255 0.1569349738 0 0.1177012304 -0.08982240684 0 -0.06736680513 +3.600 2 299.6898034 0 -13.92440826 -0.1569349738 0 0.1729176028 0.08982240684 0 0.1602037363 +3.625 1 0.3140913527 0 -13.76443149 0.1546239274 0 0.1159679455 -0.09506614712 0 -0.07129961034 +3.625 2 299.6859086 0 -13.92003526 -0.1546239274 0 0.1769219577 0.09506614712 0 0.1601298434 +3.650 1 0.3179266943 0 -13.76155498 0.1521814356 0 0.1141360767 -0.1003375879 0 -0.07525319095 +3.650 2 299.6820733 0 -13.91556219 -0.1521814356 0 0.1809233508 0.1003375879 0 0.159966654 +3.675 1 0.3216993236 0 -13.75872551 0.1496068396 0 0.1122051297 -0.1056340294 0 -0.07922552203 +3.675 2 299.6783007 0 -13.91098914 -0.1496068396 0 0.1849195395 0.1056340294 0 0.1597133555 +3.700 1 0.3254059305 0 -13.75594555 0.1468995485 0 0.1101746614 -0.1109527411 0 -0.0832145558 +3.700 2 299.6745941 0 -13.90631627 -0.1468995485 0 0.1889082613 0.1109527411 0 0.1593691825 +3.725 1 0.3290431909 0 -13.75321761 0.14405904 0 0.10804428 -0.1162909637 0 -0.0872182228 +3.725 2 299.6709568 0 -13.90154381 -0.14405904 0 0.1928872353 0.1162909637 0 0.1589334167 +3.750 1 0.3326077686 0 -13.75054417 0.141084861 0 0.1058136457 -0.1216459106 0 -0.09123443294 +3.750 2 299.6673922 0 -13.89667201 -0.141084861 0 0.1968541633 0.1216459106 0 0.1584053879 +3.775 1 0.3360963168 0 -13.74792776 0.1379766285 0 0.1034824714 -0.1270147688 0 -0.09526107663 +3.775 2 299.6639037 0 -13.89170122 -0.1379766285 0 0.2008067307 0.1270147688 0 0.1577844745 +3.800 1 0.3395054802 0 -13.74537089 0.1347340303 0 0.1010505227 -0.1323947012 0 -0.09929602593 +3.800 2 299.6604945 0 -13.88663182 -0.1347340303 0 0.2047426082 0.1323947012 0 0.1570701036 +3.825 1 0.3428318966 0 -13.74287608 0.131356825 0 0.09851761876 -0.1377828476 0 -0.1033371357 +3.825 2 299.6571681 0 -13.88146425 -0.131356825 0 0.2086594527 0.1377828476 0 0.1562617517 +3.850 1 0.3460721983 0 -13.74044585 0.1278448434 0 0.09588363257 -0.1431763261 0 -0.1073822446 +3.850 2 299.6539278 0 -13.87619902 -0.1278448434 0 0.2125549086 0.1431763261 0 0.1553589452 +3.875 1 0.3492230148 0 -13.73808274 0.1241979884 0 0.09314849133 -0.1485722355 0 -0.1114291766 +3.875 2 299.650777 0 -13.8708367 -0.1241979884 0 0.2164266092 0.1485722355 0 0.1543612605 +3.900 1 0.3522809736 0 -13.73578927 0.1204162357 0 0.0903121768 -0.1539676557 0 -0.1154757417 +3.900 2 299.647719 0 -13.86537791 -0.1204162357 0 0.2202721779 0.1539676557 0 0.1532683248 +3.925 1 0.3552427028 0 -13.73356797 0.1164996342 0 0.08737472565 -0.1593596501 0 -0.1195197376 +3.925 2 299.6447573 0 -13.85982333 -0.1164996342 0 0.224089229 0.1593596501 0 0.1520798159 +3.950 1 0.3581048326 0 -13.73142138 0.1124483064 0 0.08433622977 -0.164745267 0 -0.1235589503 +3.950 2 299.6418952 0 -13.85417371 -0.1124483064 0 0.2278753699 0.164745267 0 0.150795463 +3.975 1 0.360863997 0 -13.729352 0.1082624487 0 0.08119683653 -0.170121541 0 -0.1275911558 +3.975 2 299.639136 0 -13.84842984 -0.1082624487 0 0.2316282016 0.170121541 0 0.1494150467 +4.000 1 0.3635168362 0 -13.72736237 0.103942332 0 0.07795674899 -0.1754854946 0 -0.131614121 +4.000 2 299.6364832 0 -13.84259259 -0.103942332 0 0.2353453203 0.1754854946 0 0.1479383993 +4.025 1 0.3660599977 0 -13.725455 0.09948830154 0 0.07461622615 -0.1808341401 0 -0.1356256051 +4.025 2 299.63394 0 -13.83666289 -0.09948830154 0 0.2390243187 0.1808341401 0 0.146365405 +4.050 1 0.3684901388 0 -13.7236324 0.09490077751 0 0.07117558313 -0.1861644808 0 -0.1396233606 +4.050 2 299.6315099 0 -13.83064171 -0.09490077751 0 0.2426627871 0.1861644808 0 0.1446960003 +4.075 1 0.3708039282 0 -13.72189705 0.09018025506 0 0.0676351913 -0.191473513 0 -0.1436051348 +4.075 2 299.6291961 0 -13.82453011 -0.09018025506 0 0.2462583152 0.191473513 0 0.142930174 +4.100 1 0.3729980479 0 -13.72025146 0.08532730451 0 0.06399547838 -0.1967582272 0 -0.1475686704 +4.100 2 299.627002 0 -13.81832918 -0.08532730451 0 0.2498084927 0.1967582272 0 0.1410679674 +4.125 1 0.3750691952 0 -13.7186981 0.08034257146 0 0.0602569286 -0.2020156102 0 -0.1515117077 +4.125 2 299.6249308 0 -13.81204008 -0.08034257146 0 0.2533109111 0.2020156102 0 0.1391094743 +4.150 1 0.3770140843 0 -13.71723944 0.07522677689 0 0.05642008267 -0.2072426463 0 -0.1554319847 +4.150 2 299.6229859 0 -13.80566405 -0.07522677689 0 0.2567631652 0.2072426463 0 0.1370548412 +4.175 1 0.3788294485 0 -13.71587791 0.06998071717 0 0.05248553788 -0.2124363192 0 -0.1593272394 +4.175 2 299.6211706 0 -13.79920236 -0.06998071717 0 0.2601628537 0.2124363192 0 0.1349042675 +4.200 1 0.3805120419 0 -13.71461597 0.06460526409 0 0.04845394807 -0.2175936133 0 -0.16319521 +4.200 2 299.619488 0 -13.79265636 -0.06460526409 0 0.2635075812 0.2175936133 0 0.1326580054 +4.225 1 0.3820586413 0 -13.71345602 0.05910136477 0 0.04432602358 -0.2227115159 0 -0.1670336369 +4.225 2 299.6179414 0 -13.78602746 -0.05910136477 0 0.2667949591 0.2227115159 0 0.1303163597 +4.250 1 0.3834660482 0 -13.71240046 0.05347004163 0 0.04010253122 -0.2277870181 0 -0.1708402636 +4.250 2 299.616534 0 -13.77931711 -0.05347004163 0 0.2700226072 0.2277870181 0 0.127879688 +4.275 1 0.3847310906 0 -13.71145168 0.04771239223 0 0.03578429417 -0.2328171172 0 -0.1746128379 +4.275 2 299.6152689 0 -13.77252685 -0.04771239223 0 0.273188155 0.2328171172 0 0.125348401 +4.300 1 0.3858506249 0 -13.71061203 0.0418295891 0 0.03137219182 -0.2377988176 0 -0.1783491132 +4.300 2 299.6141494 0 -13.76565824 -0.0418295891 0 0.2762892427 0.2377988176 0 0.1227229616 +4.325 1 0.3868215375 0 -13.70988385 0.03582287956 0 0.02686715967 -0.2427291328 0 -0.1820468496 +4.325 2 299.6131785 0 -13.75871294 -0.03582287956 0 0.2793235228 0.2427291328 0 0.1200038855 +4.350 1 0.3876407473 0 -13.70926944 0.02969358547 0 0.0222701891 -0.2476050871 0 -0.1857038153 +4.350 2 299.6123593 0 -13.75169264 -0.02969358547 0 0.2822886614 0.2476050871 0 0.1171917409 +4.375 1 0.3883052069 0 -13.70877109 0.02344310291 0 0.01758232719 -0.2524237169 0 -0.1893177877 +4.375 2 299.6116948 0 -13.7445991 -0.02344310291 0 0.2851823394 0.2524237169 0 0.114287148 +4.400 1 0.3888119047 0 -13.70839107 0.01707290191 0 0.01280467643 -0.2571820726 0 -0.1928865545 +4.400 2 299.6111881 0 -13.73743414 -0.01707290191 0 0.288002254 0.2571820726 0 0.1112907795 +4.425 1 0.3891578671 0 -13.7081316 0.01058452602 0 0.007938394517 -0.2618772201 0 -0.1964079151 +4.425 2 299.6108421 0 -13.73019963 -0.01058452602 0 0.2907461196 0.2618772201 0 0.1082033596 +4.450 1 0.3893401597 0 -13.70799488 0.003979591955 0 0.002984693966 -0.2665062423 0 -0.1998796817 +4.450 2 299.6106598 0 -13.72289749 -0.003979591955 0 0.2934116696 0.2665062423 0 0.1050256643 +4.475 1 0.3893558895 0 -13.70798308 -0.002740210888 0 -0.002055158166 -0.2710662407 0 -0.2032996805 +4.475 2 299.6106441 0 -13.71552971 0.002740210888 0 0.2959966574 0.2710662407 0 0.101758521 +4.500 1 0.3892022066 0 -13.70809835 -0.009573120892 0 -0.007179840669 -0.2755543372 0 -0.2066657529 +4.500 2 299.6107978 0 -13.70809835 0.009573120892 0 0.2984988576 0.2755543372 0 0.09840280822 +4.525 1 0.3888763061 0 -13.70834277 -0.01651730476 0 -0.01238797857 -0.2799676754 0 -0.2099757566 +4.525 2 299.6111237 0 -13.70060548 0.01651730476 0 0.3009160675 0.2799676754 0 0.09495945517 +4.550 1 0.3883754299 0 -13.70871843 -0.02357085806 0 -0.01767814355 -0.2843034224 0 -0.2132275668 +4.550 2 299.6116246 0 -13.69305327 0.02357085806 0 0.3032461081 0.2843034224 0 0.0914294415 +4.575 1 0.3876968683 0 -13.70922735 -0.03073180587 0 -0.02304885441 -0.28855877 0 -0.2164190775 +4.575 2 299.6123031 0 -13.68544392 0.03073180587 0 0.3054868259 0.28855877 0 0.08781379694 +4.600 1 0.3868379617 0 -13.70987153 -0.03799810338 0 -0.02849857754 -0.2927309367 0 -0.2195482025 +4.600 2 299.613162 0 -13.67777969 0.03799810338 0 0.3076360934 0.2927309367 0 0.08411360087 +4.625 1 0.3857961028 0 -13.71065292 -0.04536763658 0 -0.03402572744 -0.2968171689 0 -0.2226128767 +4.625 2 299.6142039 0 -13.67006289 0.04536763658 0 0.3096918108 0.2968171689 0 0.0803299819 +4.650 1 0.3845687377 0 -13.71157345 -0.05283822299 0 -0.03962866725 -0.3008147423 0 -0.2256110568 +4.650 2 299.6154313 0 -13.6622959 0.05283822299 0 0.3116519071 0.3008147423 0 0.07646411743 +4.675 1 0.3831533682 0 -13.71263497 -0.06040761242 0 -0.04530570932 -0.304720964 0 -0.228540723 +4.675 2 299.6168466 0 -13.65448111 0.06040761242 0 0.3135143415 0.304720964 0 0.07251723316 +4.700 1 0.381547553 0 -13.71383934 -0.06807348775 0 -0.05105511581 -0.3085331732 0 -0.2313998799 +4.700 2 299.6184524 0 -13.64662101 0.06807348775 0 0.3152771042 0.3085331732 0 0.06849060261 +4.725 1 0.3797489096 0 -13.71518832 -0.07583346575 0 -0.05687509931 -0.3122487433 0 -0.2341865575 +4.725 2 299.6202511 0 -13.6387181 0.07583346575 0 0.316938218 0.3122487433 0 0.06438554659 +4.750 1 0.377755116 0 -13.71668366 -0.08368509798 0 -0.06276382349 -0.315865083 0 -0.2368988122 +4.750 2 299.6222449 0 -13.63077496 0.08368509798 0 0.3184957393 0.315865083 0 0.06020343265 +4.775 1 0.3755639119 0 -13.71832707 -0.09162587168 0 -0.06871940376 -0.3193796378 0 -0.2395347284 +4.775 2 299.6244361 0 -13.6227942 0.09162587168 0 0.3199477593 0.3193796378 0 0.05594567449 +4.800 1 0.373173101 0 -13.72012017 -0.09965321069 0 -0.07473990802 -0.3227898916 0 -0.2420924187 +4.800 2 299.6268269 0 -13.61477847 0.09965321069 0 0.3212924049 0.3227898916 0 0.0516137314 +4.825 1 0.3705805519 0 -13.72206459 -0.1077644764 0 -0.08082335733 -0.3260933678 0 -0.2445700258 +4.825 2 299.6294194 0 -13.60673049 0.1077644764 0 0.3225278402 0.3260933678 0 0.0472091076 +4.850 1 0.3677842002 0 -13.72416185 -0.115956969 0 -0.08696772672 -0.329287631 0 -0.2469657232 +4.850 2 299.6322158 0 -13.598653 0.115956969 0 0.3236522675 0.329287631 0 0.0427333516 +4.875 1 0.3647820496 0 -13.72641346 -0.1242279279 0 -0.09317094594 -0.3323702881 0 -0.2492777161 +4.875 2 299.635218 0 -13.59054881 0.1242279279 0 0.3246639282 0.3323702881 0 0.03818805557 +4.900 1 0.3615721734 0 -13.72882087 -0.1325745337 0 -0.09943090029 -0.3353389899 0 -0.2515042424 +4.900 2 299.6384278 0 -13.58242076 0.1325745337 0 0.3255611043 0.3353389899 0 0.0335748546 +4.925 1 0.3581527165 0 -13.73138546 -0.1409939086 0 -0.1057454314 -0.3381914321 0 -0.253643574 +4.925 2 299.6418473 0 -13.57427172 0.1409939086 0 0.3263421191 0.3381914321 0 0.02889542601 +4.950 1 0.354521896 0 -13.73410858 -0.1494831177 0 -0.1121123383 -0.3409253568 0 -0.2556940176 +4.950 2 299.6454781 0 -13.56610463 0.1494831177 0 0.3270053381 0.3409253568 0 0.02415148861 +4.975 1 0.3506780036 0 -13.7369915 -0.1580391703 0 -0.1185293778 -0.343538554 0 -0.2576539155 +4.975 2 299.649322 0 -13.55792245 0.1580391703 0 0.3275491706 0.343538554 0 0.01934480196 +5.000 1 0.3466194059 0 -13.74003545 -0.1666590213 0 -0.124994266 -0.3460288622 0 -0.2595216467 +5.000 2 299.6533806 0 -13.54972818 0.1666590213 0 0.3279720702 0.3460288622 0 0.01447716555 +5.025 1 0.3423445466 0 -13.74324159 -0.1753395718 0 -0.1315046788 -0.3483941705 0 -0.2612956279 +5.025 2 299.6576555 0 -13.54152487 0.1753395718 0 0.3282725362 0.3483941705 0 0.009550418033 +5.050 1 0.3378519477 0 -13.74661104 -0.184077671 0 -0.1380582532 -0.3506324191 0 -0.2629743143 +5.050 2 299.6621481 0 -13.53331559 0.184077671 0 0.3284491142 0.3506324191 0 0.004566436399 +5.075 1 0.3331402102 0 -13.75014484 -0.1928701172 0 -0.1446525879 -0.3527416008 0 -0.2645562006 +5.075 2 299.6668598 0 -13.52510346 0.1928701172 0 0.328500397 0.3527416008 0 -0.0004728648762 +5.100 1 0.328208016 0 -13.75384399 -0.2017136591 0 -0.1512852444 -0.3547197621 0 -0.2660398216 +5.100 2 299.671792 0 -13.51689162 0.2017136591 0 0.3284250262 0.3547197621 0 -0.005565534687 +5.125 1 0.3230541289 0 -13.7577094 -0.2106049976 0 -0.1579537482 -0.3565650043 0 -0.2674237532 +5.125 2 299.6769459 0 -13.50868327 0.2106049976 0 0.3282216921 0.3565650043 0 -0.01070958618 +5.150 1 0.3176773957 0 -13.76174195 -0.2195407863 0 -0.1646555897 -0.3582754848 0 -0.2687066136 +5.150 2 299.6823226 0 -13.50048162 0.2195407863 0 0.3278891355 0.3582754848 0 -0.01590299765 +5.175 1 0.3120767474 0 -13.76594244 -0.2285176339 0 -0.1713882254 -0.3598494179 0 -0.2698870634 +5.175 2 299.6879233 0 -13.4922899 0.2285176339 0 0.327426148 0.3598494179 0 -0.02114371347 +5.200 1 0.3062512005 0 -13.7703116 -0.2375321049 0 -0.1781490787 -0.361285076 0 -0.270963807 +5.200 2 299.6937488 0 -13.48411141 0.2375321049 0 0.326831573 0.361285076 0 -0.026429645 +5.225 1 0.3001998576 0 -13.77485011 -0.2465807215 0 -0.1849355411 -0.3625807907 0 -0.271935593 +5.225 2 299.6998001 0 -13.47594943 0.2465807215 0 0.3261043066 0.3625807907 0 -0.03175867158 +5.250 1 0.2939219092 0 -13.77955857 -0.2556599648 0 -0.1917449736 -0.3637349537 0 -0.2728012152 +5.250 2 299.7060781 0 -13.46780731 0.2556599648 0 0.3252432983 0.3637349537 0 -0.03712864148 +5.275 1 0.2874166338 0 -13.78443752 -0.2647662767 0 -0.1985747075 -0.3647460176 0 -0.2735595132 +5.275 2 299.7125834 0 -13.45968839 0.2647662767 0 0.3242475515 0.3647460176 0 -0.04253737289 +5.300 1 0.2806833997 0 -13.78948745 -0.2738960608 0 -0.2054220456 -0.3656124973 0 -0.274209373 +5.300 2 299.7193166 0 -13.45159606 0.2738960608 0 0.323116125 0.3656124973 0 -0.04798265491 +5.325 1 0.2737216654 0 -13.79470875 -0.2830456848 0 -0.2122842636 -0.3663329706 0 -0.2747497279 +5.325 2 299.7262783 0 -13.44353372 0.2830456848 0 0.3218481329 0.3663329706 0 -0.05346224862 +5.350 1 0.2665309807 0 -13.80010176 -0.2922114813 0 -0.219158611 -0.3669060788 0 -0.2751795591 +5.350 2 299.733469 0 -13.4355048 0.2922114813 0 0.3204427455 0.3669060788 0 -0.05897388804 +5.375 1 0.2591109874 0 -13.80566676 -0.3013897499 0 -0.2260423124 -0.3673305283 0 -0.2754978962 +5.375 2 299.740889 0 -13.42751273 0.3013897499 0 0.3188991905 0.3673305283 0 -0.06451528125 +5.400 1 0.2514614204 0 -13.81140393 -0.3105767586 0 -0.232932569 -0.3676050907 0 -0.275703818 +5.400 2 299.7485386 0 -13.41956099 0.3105767586 0 0.3172167528 0.3676050907 0 -0.07008411143 +5.425 1 0.243582108 0 -13.81731342 -0.3197687457 0 -0.2398265593 -0.367728604 0 -0.275796453 +5.425 2 299.7564179 0 -13.41165306 0.3197687457 0 0.3153947758 0.367728604 0 -0.07567803793 +5.450 1 0.2354729732 0 -13.82339527 -0.328961921 0 -0.2467214407 -0.3676999732 0 -0.2757749799 +5.450 2 299.764527 0 -13.40379242 0.328961921 0 0.3134326615 0.3676999732 0 -0.08129469736 +5.475 1 0.2271340338 0 -13.82964947 -0.3381524679 0 -0.2536143509 -0.3675181711 0 -0.2756386284 +5.475 2 299.772866 0 -13.3959826 0.3381524679 0 0.3113298714 0.3675181711 0 -0.08693170472 +5.500 1 0.2185654037 0 -13.83607595 -0.3473365451 0 -0.2605024088 -0.3671822389 0 -0.2753866792 +5.500 2 299.7814346 0 -13.38822711 0.3473365451 0 0.3090859267 0.3671822389 0 -0.09258665449 +5.525 1 0.2097672927 0 -13.84267453 -0.356510288 0 -0.267382716 -0.3666912869 0 -0.2750184652 +5.525 2 299.7902327 0 -13.38052948 0.356510288 0 0.3067004093 0.3666912869 0 -0.09825712178 +5.550 1 0.2007400078 0 -13.84944499 -0.3656698107 0 -0.2742523581 -0.3660444951 0 -0.2745333713 +5.550 2 299.79926 0 -13.37289327 0.3656698107 0 0.3041729617 0.3660444951 0 -0.1039406635 +5.575 1 0.1914839532 0 -13.85638704 -0.3748112078 0 -0.2811084059 -0.3652411139 0 -0.2739308354 +5.575 2 299.808516 0 -13.36532202 0.3748112078 0 0.3015032877 0.3652411139 0 -0.1096348193 +5.600 1 0.1819996311 0 -13.86350028 -0.3839305558 0 -0.2879479169 -0.3642804646 0 -0.2732103485 +5.600 2 299.8180004 0 -13.35781929 0.3839305558 0 0.2986911529 0.3642804646 0 -0.1153371132 +5.625 1 0.172287642 0 -13.87078427 -0.3930239154 0 -0.2947679365 -0.3631619398 0 -0.2723714549 +5.625 2 299.8277124 0 -13.35038865 0.3930239154 0 0.295736385 0.3631619398 0 -0.1210450541 +5.650 1 0.1623486849 0 -13.87823849 -0.4020873327 0 -0.3015654995 -0.3618850041 0 -0.2714137531 +5.650 2 299.8376513 0 -13.34303366 0.4020873327 0 0.292638874 0.3618850041 0 -0.1267561377 +5.675 1 0.1521835579 0 -13.88586233 -0.4111168416 0 -0.3083376312 -0.3604491943 0 -0.2703368957 +5.675 2 299.8478164 0 -13.3357579 0.4111168416 0 0.2893985729 0.3604491943 0 -0.132467847 +5.700 1 0.1417931585 0 -13.89365513 -0.4201084652 0 -0.3150813489 -0.3588541201 0 -0.2691405901 +5.700 2 299.8582068 0 -13.32856492 0.4201084652 0 0.2860154975 0.3588541201 0 -0.138177654 +5.725 1 0.1311784836 0 -13.90161614 -0.4290582178 0 -0.3217936633 -0.3570994643 0 -0.2678245982 +5.725 2 299.8688215 0 -13.32145831 0.4290582178 0 0.2824897272 0.3570994643 0 -0.1438830206 +5.750 1 0.1203406298 0 -13.90974453 -0.4379621065 0 -0.3284715799 -0.3551849832 0 -0.2663887374 +5.750 2 299.8796594 0 -13.31444162 0.4379621065 0 0.2788214047 0.3551849832 0 -0.1495814 +5.775 1 0.1092807938 0 -13.9180394 -0.4468161336 0 -0.3351121002 -0.353110507 0 -0.2648328802 +5.775 2 299.8907192 0 -13.30751843 0.4468161336 0 0.2750107367 0.353110507 0 -0.1552702377 +5.800 1 0.09800027198 0 -13.9264998 -0.4556162978 0 -0.3417122233 -0.3508759397 0 -0.2631569548 +5.800 2 299.9019997 0 -13.30069227 0.4556162978 0 0.2710579937 0.3508759397 0 -0.1609469731 +5.825 1 0.08650046108 0 -13.93512465 -0.4643585963 0 -0.3482689472 -0.34848126 0 -0.261360945 +5.825 2 299.9134995 0 -13.29396671 0.4643585963 0 0.2669635103 0.34848126 0 -0.1666090401 +5.850 1 0.07478285773 0 -13.94391286 -0.4730390269 0 -0.3547792702 -0.3459265208 0 -0.2594448906 +5.850 2 299.9252171 0 -13.28734527 0.4730390269 0 0.2627276853 0.3459265208 0 -0.1722538691 +5.875 1 0.06284905864 0 -13.95286321 -0.4816535896 0 -0.3612401922 -0.34321185 0 -0.2574088875 +5.875 2 299.9371509 0 -13.2808315 0.4816535896 0 0.2583509819 0.34321185 0 -0.1778788876 +5.900 1 0.05070076046 0 -13.96197443 -0.4901982883 0 -0.3676487162 -0.34033745 0 -0.2552530875 +5.900 2 299.9492992 0 -13.27442889 0.4901982883 0 0.2538339275 0.34033745 0 -0.1834815218 +5.925 1 0.03833975967 0 -13.97124518 -0.4986691333 0 -0.37400185 -0.3373035986 0 -0.2529776989 +5.925 2 299.9616602 0 -13.26814097 0.4986691333 0 0.2491771138 0.3373035986 0 -0.1890591977 +5.950 1 0.02576795243 0 -13.98067404 -0.5070621424 0 -0.3802966068 -0.334110648 0 -0.250582986 +5.950 2 299.974232 0 -13.2619712 0.5070621424 0 0.244381197 0.334110648 0 -0.1946093422 +5.975 1 0.01298733429 0 -13.9902595 -0.5153733434 0 -0.3865300075 -0.3307590259 0 -0.2480692694 +5.975 2 299.9870127 0 -13.25592306 0.5153733434 0 0.2394468975 0.3307590259 0 -0.2001293848 +6.000 1 1.224646799e-16 0 -14 -0.5235987756 0 -0.3926990817 -0.3272492347 0 -0.2454369261 +6.000 2 300 0 -13.25 0.5235987756 0 0.234375 0.3272492347 0 -0.2056167584 +6.025 1 -0.01319185685 0 -14.00989389 -0.5317344918 0 -0.3988008689 -0.323581852 0 -0.242686389 +6.025 2 300.0131919 0 -13.24420545 0.5317344918 0 0.2291663532 0.323581852 0 -0.2110689005 +6.050 1 -0.02658594419 0 -14.01993946 -0.5397765604 0 -0.4048324203 -0.31975753 0 -0.2398181475 +6.050 2 300.0265859 0 -13.23854281 0.5397765604 0 0.2238218699 0.31975753 0 -0.216483255 +6.075 1 -0.04017987185 0 -14.0301349 -0.5477210666 0 -0.4107907999 -0.3157769958 0 -0.2368327468 +6.075 2 300.0401799 0 -13.23301548 0.5477210666 0 0.2183425266 0.3157769958 0 -0.2218572729 +6.100 1 -0.05397115203 0 -14.04047836 -0.555564115 0 -0.4166730863 -0.3116410509 0 -0.2337307882 +6.100 2 300.0539712 0 -13.2276268 0.555564115 0 0.2127293635 0.3116410509 0 -0.2271884137 +6.125 1 -0.06795719982 0 -14.0509679 -0.5633018313 0 -0.4224763735 -0.3073505715 0 -0.2305129286 +6.125 2 300.0679572 0 -13.22238012 0.5633018313 0 0.2069834843 0.3073505715 0 -0.2324741466 +6.150 1 -0.08213533372 0 -14.0616015 -0.5709303637 0 -0.4281977728 -0.3029065077 0 -0.2271798807 +6.150 2 300.0821353 0 -13.21727873 0.5709303637 0 0.2011060556 0.3029065077 0 -0.2377119519 +6.175 1 -0.09650277624 0 -14.07237708 -0.5784458853 0 -0.433834414 -0.2983098834 0 -0.2237324125 +6.175 2 300.0965028 0 -13.2123259 0.5784458853 0 0.195098307 0.2983098834 0 -0.2428993222 +6.200 1 -0.1110566546 0 -14.08329249 -0.5858445957 0 -0.4393834468 -0.2935617963 0 -0.2201713472 +6.200 2 300.1110567 0 -13.20752489 0.5858445957 0 0.1889615306 0.2935617963 0 -0.2480337634 +6.225 1 -0.1257940012 0 -14.0943455 -0.5931227227 0 -0.444842042 -0.2886634172 0 -0.2164975629 +6.225 2 300.125794 0 -13.20287889 0.5931227227 0 0.1826970806 0.2886634172 0 -0.2531127962 +6.250 1 -0.1407117546 0 -14.10553382 -0.6002765244 0 -0.4502073933 -0.2836159898 0 -0.2127119924 +6.250 2 300.1407118 0 -13.19839108 0.6002765244 0 0.176306373 0.2836159898 0 -0.258133957 +6.275 1 -0.1558067604 0 -14.11685507 -0.6073022911 0 -0.4554767183 -0.2784208302 0 -0.2088156227 +6.275 2 300.1558068 0 -13.19406461 0.6073022911 0 0.1697908854 0.2784208302 0 -0.2630947995 +6.300 1 -0.1710757716 0 -14.12830683 -0.6141963464 0 -0.4606472598 -0.2730793265 0 -0.2048094949 +6.300 2 300.1710758 0 -13.18990257 0.6141963464 0 0.163152156 0.2730793265 0 -0.2679928957 +6.325 1 -0.1865154498 0 -14.13988659 -0.62095505 0 -0.4657162875 -0.2675929383 0 -0.2006947037 +6.325 2 300.1865154 0 -13.18590802 0.62095505 0 0.1563917836 0.2675929383 0 -0.2728258371 +6.350 1 -0.2021223661 0 -14.15159177 -0.6275747987 0 -0.470681099 -0.2619631961 0 -0.196472397 +6.350 2 300.2021224 0 -13.18208398 0.6275747987 0 0.149511427 0.2619631961 0 -0.2775912358 +6.375 1 -0.2178930021 0 -14.16341975 -0.6340520285 0 -0.4755390214 -0.2561917009 0 -0.1921437757 +6.375 2 300.217893 0 -13.17843343 0.6340520285 0 0.1425128044 0.2561917009 0 -0.2822867259 +6.400 1 -0.2338237505 0 -14.17536781 -0.6403832164 0 -0.4802874123 -0.2502801236 0 -0.1877100927 +6.400 2 300.2338238 0 -13.17495931 0.6403832164 0 0.1353976928 0.2502801236 0 -0.2869099646 +6.425 1 -0.2499109168 0 -14.18743319 -0.6465648818 0 -0.4849236614 -0.2442302041 0 -0.1831726531 +6.425 2 300.2499109 0 -13.1716645 0.6465648818 0 0.1281679276 0.2442302041 0 -0.2914586332 +6.450 1 -0.2661507199 0 -14.19961304 -0.6525935888 0 -0.4894451916 -0.2380437512 0 -0.1785328134 +6.450 2 300.2661507 0 -13.16855185 0.6525935888 0 0.1208254017 0.2380437512 0 -0.2959304384 +6.475 1 -0.2825392934 0 -14.21190447 -0.6584659472 0 -0.4938494604 -0.2317226411 0 -0.1737919808 +6.475 2 300.2825393 0 -13.16562415 0.6584659472 0 0.1133720651 0.2317226411 0 -0.3003231137 +6.500 1 -0.2990726865 0 -14.22430451 -0.6641786149 0 -0.4981339611 -0.2252688174 0 -0.1689516131 +6.500 2 300.2990727 0 -13.16288415 0.6641786149 0 0.1058099241 0.2252688174 0 -0.3046344199 +6.525 1 -0.3157468659 0 -14.23681015 -0.6697282989 0 -0.5022962241 -0.2186842901 0 -0.1640132176 +6.525 2 300.3157469 0 -13.16033455 0.6697282989 0 0.09814104056 0.2186842901 0 -0.3088621468 +6.550 1 -0.3325577162 0 -14.24941829 -0.6751117574 0 -0.5063338181 -0.2119711346 0 -0.1589783509 +6.550 2 300.3325577 0 -13.15797797 0.6751117574 0 0.09036753138 0.2119711346 0 -0.3130041141 +6.575 1 -0.349501042 0 -14.26212578 -0.6803258015 0 -0.5102443511 -0.205131491 0 -0.1538486183 +6.575 2 300.349501 0 -13.15581702 0.6803258015 0 0.08249156744 0.205131491 0 -0.3170581724 +6.600 1 -0.3665725684 0 -14.27492943 -0.6853672963 0 -0.5140254722 -0.1981675636 0 -0.1486256727 +6.600 2 300.3665726 0 -13.15385423 0.6853672963 0 0.07451537299 0.1981675636 0 -0.3210222044 +6.625 1 -0.3837679432 0 -14.28782596 -0.6902331629 0 -0.5176748721 -0.1910816193 0 -0.1433112145 +6.625 2 300.3837679 0 -13.15209207 0.6902331629 0 0.06644122482 0.1910816193 0 -0.324894126 +6.650 1 -0.4010827378 0 -14.30081205 -0.6949203798 0 -0.5211902849 -0.1838759873 0 -0.1379069905 +6.650 2 300.4010827 0 -13.15053297 0.6949203798 0 0.05827145137 0.1838759873 0 -0.3286718873 +6.675 1 -0.4185124487 0 -14.31388434 -0.6994259847 0 -0.5245694885 -0.1765530578 0 -0.1324147933 +6.675 2 300.4185124 0 -13.14917928 0.6994259847 0 0.05000843192 0.1765530578 0 -0.3323534738 +6.700 1 -0.4360524994 0 -14.32703937 -0.7037470756 0 -0.5278103067 -0.1691152811 0 -0.1268364608 +6.700 2 300.4360525 0 -13.1480333 0.7037470756 0 0.04165459563 0.1691152811 0 -0.335936907 +6.725 1 -0.4536982412 0 -14.34027368 -0.7078808126 0 -0.5309106095 -0.1615651667 0 -0.121173875 +6.725 2 300.4536982 0 -13.14709728 0.7078808126 0 0.0332124207 0.1615651667 0 -0.3394202459 +6.750 1 -0.4714449556 0 -14.35358372 -0.7118244192 0 -0.5338683144 -0.1539052821 0 -0.1154289616 +6.750 2 300.471445 0 -13.1463734 0.7118244192 0 0.02468443333 0.1539052821 0 -0.3428015877 +6.775 1 -0.4892878551 0 -14.36696589 -0.7155751838 0 -0.5366813879 -0.1461382517 0 -0.1096036888 +6.775 2 300.4892879 0 -13.14586375 0.7155751838 0 0.01607320683 0.1461382517 0 -0.3460790689 +6.800 1 -0.5072220857 0 -14.38041656 -0.7191304612 0 -0.5393478459 -0.1382667559 0 -0.1037000669 +6.800 2 300.5072221 0 -13.14557041 0.7191304612 0 0.007381360592 0.1382667559 0 -0.3492508662 +6.825 1 -0.5252427276 0 -14.39393205 -0.7224876739 0 -0.5418657554 -0.1302935297 0 -0.09772014724 +6.825 2 300.5252427 0 -13.14549534 0.7224876739 0 -0.001388440922 0.1302935297 0 -0.3523151976 +6.850 1 -0.5433447979 0 -14.4075086 -0.7256443132 0 -0.5442332349 -0.1222213617 0 -0.09166602127 +6.850 2 300.5433448 0 -13.14564046 0.7256443132 0 -0.01023348923 0.1222213617 0 -0.355270323 +6.875 1 -0.5615232515 0 -14.42114244 -0.7285979411 0 -0.5464484558 -0.114053093 0 -0.08553981975 +6.875 2 300.5615233 0 -13.14600761 0.7285979411 0 -0.01915103287 0.114053093 0 -0.3581145454 +6.900 1 -0.5797729835 0 -14.43482974 -0.7313461911 0 -0.5485096433 -0.1057916157 0 -0.0793437118 +6.900 2 300.579773 0 -13.14659859 0.7313461911 0 -0.02813827851 0.1057916157 0 -0.3608462117 +6.925 1 -0.5980888305 0 -14.44856662 -0.7338867696 0 -0.5504150772 -0.09743987197 0 -0.07307990398 +6.925 2 300.5980888 0 -13.14741509 0.7338867696 0 -0.03719239207 0.09743987197 0 -0.3634637135 +6.950 1 -0.6164655728 0 -14.46234918 -0.7362174574 0 -0.552163093 -0.08900085245 0 -0.06675063934 +6.950 2 300.6164656 0 -13.14845874 0.7362174574 0 -0.04631049978 0.08900085245 0 -0.3659654882 +6.975 1 -0.6348979363 0 -14.47617345 -0.7383361103 0 -0.5537520827 -0.08047759523 0 -0.06035819642 +6.975 2 300.6348979 0 -13.14973112 0.7383361103 0 -0.05548968943 0.08047759523 0 -0.3683500193 +7.000 1 -0.6533805941 0 -14.49003545 -0.7402406608 0 -0.5551804956 -0.07187318442 0 -0.05390488832 +7.000 2 300.6533806 0 -13.15123371 0.7402406608 0 -0.06472701147 0.07187318442 0 -0.3706158379 +7.025 1 -0.6719081686 0 -14.50393113 -0.7419291193 0 -0.5564468395 -0.06319074881 0 -0.04739306161 +7.025 2 300.6719082 0 -13.15296793 0.7419291193 0 -0.0740194802 0.06319074881 0 -0.3727615228 +7.050 1 -0.6904752334 0 -14.51785643 -0.7433995745 0 -0.5575496809 -0.05443346048 0 -0.04082509536 +7.050 2 300.6904752 0 -13.15493512 0.7433995745 0 -0.08336407505 0.05443346048 0 -0.3747857019 +7.075 1 -0.7090763153 0 -14.53180724 -0.7446501953 0 -0.5584876465 -0.04560453347 0 -0.0342034001 +7.075 2 300.7090763 0 -13.15713654 0.7446501953 0 -0.09275774171 0.04560453347 0 -0.3766870523 +7.100 1 -0.7277058966 0 -14.54577942 -0.7456792313 0 -0.5592594235 -0.03670722228 0 -0.02753041671 +7.100 2 300.7277059 0 -13.15957339 0.7456792313 0 -0.1021973935 0.03670722228 0 -0.3784643016 +7.125 1 -0.7463584164 0 -14.55976881 -0.746485014 0 -0.5598637605 -0.02774482052 0 -0.02080861539 +7.125 2 300.7463584 0 -13.16224677 0.746485014 0 -0.1116799124 0.02774482052 0 -0.3801162283 +7.150 1 -0.7650282736 0 -14.57377121 -0.7470659576 0 -0.5602994682 -0.0187206594 0 -0.01404049455 +7.150 2 300.7650283 0 -13.16515772 0.7470659576 0 -0.1212021508 0.0187206594 0 -0.3816416624 +7.175 1 -0.7837098281 0 -14.58778237 -0.7474205603 0 -0.5605654203 -0.00963810626 0 -0.007228579695 +7.175 2 300.7837098 0 -13.16830718 0.7474205603 0 -0.1307609321 0.00963810626 0 -0.3830394862 +7.200 1 -0.8023974036 0 -14.60179805 -0.7475474047 0 -0.5606605535 -0.0005005630815 0 -0.0003754223111 +7.200 2 300.8023974 0 -13.17169604 0.7475474047 0 -0.1403530528 0.0005005630815 0 -0.3843086351 +7.225 1 -0.8210852893 0 -14.61581397 -0.7474451589 0 -0.5605838691 0.008688535032 0 0.006516401274 +7.225 2 300.8210853 0 -13.17532509 0.7474451589 0 -0.1499752831 -0.008688535032 0 -0.3854480977 +7.250 1 -0.8397677421 0 -14.62982581 -0.7471125772 0 -0.5603344329 0.01792572139 0 0.01344429104 +7.250 2 300.8397677 0 -13.17919503 0.7471125772 0 -0.1596243689 -0.01792572139 0 -0.3864569168 +7.275 1 -0.858438989 0 -14.64382924 -0.7465485012 0 -0.5599113759 0.02720749928 0 0.02040562446 +7.275 2 300.858439 0 -13.1833065 0.7465485012 0 -0.1692970327 -0.02720749928 0 -0.3873341898 +7.300 1 -0.8770932291 0 -14.65781992 -0.74575186 0 -0.559313895 0.0365303435 0 0.02739775762 +7.300 2 300.8770932 0 -13.18766005 0.74575186 0 -0.1789899751 -0.0365303435 0 -0.3880790693 +7.325 1 -0.8957246357 0 -14.67179348 -0.7447216714 0 -0.5585412535 0.045890702 0 0.0344180265 +7.325 2 300.8957246 0 -13.19225614 0.7447216714 0 -0.1886998763 -0.045890702 0 -0.3886907636 +7.350 1 -0.9143273589 0 -14.68574552 -0.7434570421 0 -0.5575927816 0.05528499744 0 0.04146374808 +7.350 2 300.9143274 0 -13.19709516 0.7434570421 0 -0.1984233973 -0.05528499744 0 -0.3891685368 +7.375 1 -0.9328955274 0 -14.69967165 -0.7419571687 0 -0.5564678765 0.06470962882 0 0.04853222162 +7.375 2 300.9328955 0 -13.2021774 0.7419571687 0 -0.2081571815 -0.06470962882 0 -0.3895117099 +7.400 1 -0.951423251 0 -14.71356744 -0.740221338 0 -0.5551660035 0.07416097313 0 0.05562072985 +7.400 2 300.9514233 0 -13.20750307 0.740221338 0 -0.2178978559 -0.07416097313 0 -0.3897196609 +7.425 1 -0.9699046228 0 -14.72742847 -0.7382489278 0 -0.5536866958 0.08363538695 0 0.06272654021 +7.425 2 300.9699046 0 -13.21307232 0.7382489278 0 -0.2276420329 -0.08363538695 0 -0.3897918249 +7.450 1 -0.9883337215 0 -14.74125029 -0.736039407 0 -0.5520295552 0.09312920815 0 0.06984690611 +7.450 2 300.9883337 0 -13.21888518 0.736039407 0 -0.2373863114 -0.09312920815 0 -0.389727695 +7.475 1 -1.006704614 0 -14.75502846 -0.7335923363 0 -0.5501942522 0.1026387575 0 0.07697906816 +7.475 2 301.0067046 0 -13.22494161 0.7335923363 0 -0.2471272781 -0.1026387575 0 -0.3895268224 +7.500 1 -1.025011356 0 -14.76875852 -0.7309073688 0 -0.5481805266 0.1121603406 0 0.08412025542 +7.500 2 301.0250114 0 -13.23124148 0.7309073688 0 -0.2568615097 -0.1121603406 0 -0.3891888165 +7.525 1 -1.043247997 0 -14.782436 -0.7279842499 0 -0.5459881874 0.1216902489 0 0.0912676867 +7.525 2 301.043248 0 -13.2377846 0.7279842499 0 -0.2665855734 -0.1216902489 0 -0.3887133457 +7.550 1 -1.061408582 0 -14.79605644 -0.724822818 0 -0.5436171135 0.1312247624 0 0.09841857181 +7.550 2 301.0614086 0 -13.24457065 0.724822818 0 -0.2762960291 -0.1312247624 0 -0.3881001372 +7.575 1 -1.079487152 0 -14.80961536 -0.7214230045 0 -0.5410672534 0.1407601505 0 0.1055701129 +7.575 2 301.0794872 0 -13.25159926 0.7214230045 0 -0.2859894307 -0.1407601505 0 -0.3873489773 +7.600 1 -1.097477746 0 -14.82310831 -0.7177848343 0 -0.5383386257 0.150292674 0 0.1127195055 +7.600 2 301.0974777 0 -13.25886995 0.7177848343 0 -0.2956623271 -0.150292674 0 -0.3864597119 +7.625 1 -1.115374408 0 -14.83653081 -0.7139084259 0 -0.5354313194 0.1598185871 0 0.1198639404 +7.625 2 301.1153744 0 -13.26638217 0.7139084259 0 -0.3053112646 -0.1598185871 0 -0.3854322463 +7.650 1 -1.133171184 0 -14.84987839 -0.7097939913 0 -0.5323454935 0.1693341387 0 0.1270006041 +7.650 2 301.1331712 0 -13.27413528 0.7097939913 0 -0.3149327875 -0.1693341387 0 -0.3842665457 +7.675 1 -1.150862127 0 -14.86314659 -0.7054418366 0 -0.5290813774 0.1788355744 0 0.1341266808 +7.675 2 301.1508621 0 -13.28212855 0.7054418366 0 -0.3245234401 -0.1788355744 0 -0.382962635 +7.700 1 -1.168441298 0 -14.87633097 -0.7008523615 0 -0.5256392711 0.1883191381 0 0.1412393535 +7.700 2 301.1684413 0 -13.29036117 0.7008523615 0 -0.3340797681 -0.1883191381 0 -0.3815205991 +7.725 1 -1.185902771 0 -14.88942708 -0.6960260599 0 -0.5220195449 0.1977810738 0 0.1483358053 +7.725 2 301.1859028 0 -13.29883223 0.6960260599 0 -0.3435983202 -0.1977810738 0 -0.3799405829 +7.750 1 -1.203240632 0 -14.90243047 -0.6909635194 0 -0.5182226395 0.2072176274 0 0.1554132205 +7.750 2 301.2032406 0 -13.30754074 0.6909635194 0 -0.3530756491 -0.2072176274 0 -0.3782227913 +7.775 1 -1.220448984 0 -14.91533674 -0.6856654213 0 -0.514249066 0.2166250484 0 0.1624687863 +7.775 2 301.220449 0 -13.31648564 0.6856654213 0 -0.3625083138 -0.2166250484 0 -0.3763674893 +7.800 1 -1.237521947 0 -14.92814146 -0.6801325409 0 -0.5100994057 0.2259995916 0 0.1694996937 +7.800 2 301.2375219 0 -13.32566576 0.6801325409 0 -0.3718928804 -0.2259995916 0 -0.3743750018 +7.825 1 -1.254453662 0 -14.94084025 -0.6743657469 0 -0.5057743101 0.235337519 0 0.1765031393 +7.825 2 301.2544537 0 -13.33507985 0.6743657469 0 -0.3812259239 -0.235337519 0 -0.3722457137 +7.850 1 -1.271238293 0 -14.95342872 -0.6683660012 0 -0.5012745009 0.2446351014 0 0.183476326 +7.850 2 301.2712383 0 -13.3447266 0.6683660012 0 -0.3905040298 -0.2446351014 0 -0.3699800699 +7.875 1 -1.287870029 0 -14.96590252 -0.662134359 0 -0.4966007692 0.25388862 0 0.190416465 +7.875 2 301.28787 0 -13.35460457 0.662134359 0 -0.3997237953 -0.25388862 0 -0.367578575 +7.900 1 -1.304343088 0 -14.97825732 -0.6556719683 0 -0.4917539762 0.2630943688 0 0.1973207766 +7.900 2 301.3043431 0 -13.36471227 0.6556719683 0 -0.4088818311 -0.2630943688 0 -0.3650417931 +7.925 1 -1.320651715 0 -14.99048879 -0.6489800694 0 -0.4867350521 0.2722486554 0 0.2041864915 +7.925 2 301.3206517 0 -13.37504812 0.6489800694 0 -0.4179747627 -0.2722486554 0 -0.362370348 +7.950 1 -1.33679019 0 -15.00259264 -0.642059995 0 -0.4815449962 0.2813478035 0 0.2110108526 +7.950 2 301.3367902 0 -13.38561044 0.642059995 0 -0.426999232 -0.2813478035 0 -0.3595649225 +7.975 1 -1.352752825 0 -15.01456462 -0.6349131692 0 -0.4761848769 0.2903881544 0 0.2177911158 +7.975 2 301.3527528 0 -13.39639748 0.6349131692 0 -0.4359518985 -0.2903881544 0 -0.3566262588 +8.000 1 -1.368533971 0 -15.02640048 -0.6275411076 0 -0.4706558307 0.2993660685 0 0.2245245514 +8.000 2 301.368534 0 -13.40740741 0.6275411076 0 -0.4448294413 -0.2993660685 0 -0.3535551576 +8.025 1 -1.384128017 0 -15.03809601 -0.6199454163 0 -0.4649590622 0.3082779274 0 0.2312084455 +8.025 2 301.384128 0 -13.4186383 0.6199454163 0 -0.4536285599 -0.3082779274 0 -0.3503524782 +8.050 1 -1.399529393 0 -15.04964704 -0.6121277916 0 -0.4590958437 0.3171201353 0 0.2378401015 +8.050 2 301.3995294 0 -13.43008815 0.6121277916 0 -0.4623459763 -0.3171201353 0 -0.347019138 +8.075 1 -1.414732572 0 -15.06104943 -0.6040900197 0 -0.4530675148 0.3258891211 0 0.2444168408 +8.075 2 301.4147326 0 -13.44175489 0.6040900197 0 -0.4709784361 -0.3258891211 0 -0.3435561126 +8.100 1 -1.429732075 0 -15.07229906 -0.5958339753 0 -0.4468754815 0.3345813395 0 0.2509360046 +8.100 2 301.4297321 0 -13.45363634 0.5958339753 0 -0.4795227098 -0.3345813395 0 -0.3399644346 +8.125 1 -1.444522468 0 -15.08339185 -0.5873616218 0 -0.4405212163 0.3431932733 0 0.2573949549 +8.125 2 301.4445225 0 -13.46573026 0.5873616218 0 -0.4879755948 -0.3431932733 0 -0.336245194 +8.150 1 -1.45909837 0 -15.09432378 -0.5786750098 0 -0.4340062573 0.3517214347 0 0.263791076 +8.150 2 301.4590984 0 -13.47803433 0.5786750098 0 -0.496333916 -0.3517214347 0 -0.3323995375 +8.175 1 -1.473454451 0 -15.10509084 -0.5697762769 0 -0.4273322077 0.3601623672 0 0.2701217754 +8.175 2 301.4734545 0 -13.49054615 0.5697762769 0 -0.5045945282 -0.3601623672 0 -0.3284286679 +8.200 1 -1.487585435 0 -15.11568908 -0.5606676469 0 -0.4205007351 0.3685126471 0 0.2763844853 +8.200 2 301.4875854 0 -13.50326322 0.5606676469 0 -0.5127543165 -0.3685126471 0 -0.3243338437 +8.225 1 -1.501486103 0 -15.12611458 -0.5513514283 0 -0.4135135712 0.3767688851 0 0.2825766638 +8.225 2 301.5014861 0 -13.516183 0.5513514283 0 -0.5208101983 -0.3767688851 0 -0.3201163788 +8.250 1 -1.515151296 0 -15.13636347 -0.5418300142 0 -0.4063725107 0.3849277283 0 0.2886957962 +8.250 2 301.5151513 0 -13.52930284 0.5418300142 0 -0.5287591248 -0.3849277283 0 -0.3157776416 +8.275 1 -1.528575915 0 -15.14643194 -0.5321058811 0 -0.3990794108 0.3929858613 0 0.294739396 +8.275 2 301.5285759 0 -13.54262004 0.5321058811 0 -0.5365980817 -0.3929858613 0 -0.3113190548 +8.300 1 -1.541754922 0 -15.15631619 -0.5221815877 0 -0.3916361908 0.4009400082 0 0.3007050061 +8.300 2 301.5417549 0 -13.5561318 0.5221815877 0 -0.5443240911 -0.4009400082 0 -0.3067420946 +8.325 1 -1.554683348 0 -15.16601251 -0.5120597742 0 -0.3840448307 0.4087869339 0 0.3065902004 +8.325 2 301.5546833 0 -13.56983527 0.5120597742 0 -0.5519342127 -0.4087869339 0 -0.3020482901 +8.350 1 -1.567356288 0 -15.17551722 -0.5017431612 0 -0.3763073709 0.4165234459 0 0.3123925844 +8.350 2 301.5673563 0 -13.58372752 0.5017431612 0 -0.559425545 -0.4165234459 0 -0.2972392226 +8.375 1 -1.579768906 0 -15.18482668 -0.4912345483 0 -0.3684259112 0.4241463959 0 0.3181097969 +8.375 2 301.5797689 0 -13.59780554 0.4912345483 0 -0.5667952269 -0.4241463959 0 -0.2923165251 +8.400 1 -1.591916439 0 -15.19393733 -0.4805368136 0 -0.3604026102 0.4316526809 0 0.3237395107 +8.400 2 301.5919164 0 -13.61206625 0.4805368136 0 -0.5740404384 -0.4316526809 0 -0.2872818817 +8.425 1 -1.603794196 0 -15.20284565 -0.469652912 0 -0.352239684 0.4390392453 0 0.3292794339 +8.425 2 301.6037942 0 -13.6265065 0.469652912 0 -0.5811584025 -0.4390392453 0 -0.2821370263 +8.450 1 -1.615397559 0 -15.21154817 -0.4585858741 0 -0.3439394056 0.4463030819 0 0.3347273114 +8.450 2 301.6153976 0 -13.64112308 0.4585858741 0 -0.5881463861 -0.4463030819 0 -0.2768837426 +8.475 1 -1.626721989 0 -15.22004149 -0.4473388052 0 -0.3355041039 0.4534412338 0 0.3400809253 +8.475 2 301.626722 0 -13.65591271 0.4473388052 0 -0.5950017013 -0.4534412338 0 -0.2715238627 +8.500 1 -1.637763025 0 -15.22832227 -0.435914884 0 -0.326936163 0.4604507954 0 0.3453380965 +8.500 2 301.637763 0 -13.67087204 0.435914884 0 -0.6017217066 -0.4604507954 0 -0.2660592669 +8.525 1 -1.648516286 0 -15.23638721 -0.4243173608 0 -0.3182380206 0.4673289143 0 0.3504966857 +8.525 2 301.6485163 0 -13.68599765 0.4243173608 0 -0.6083038081 -0.4673289143 0 -0.2604918823 +8.550 1 -1.658977474 0 -15.24423311 -0.412549557 0 -0.3094121677 0.4740727922 0 0.3555545942 +8.550 2 301.6589775 0 -13.70128606 0.412549557 0 -0.6147454606 -0.4740727922 0 -0.2548236823 +8.575 1 -1.669142374 0 -15.25185678 -0.4006148628 0 -0.3004611471 0.480679687 0 0.3605097652 +8.575 2 301.6691424 0 -13.71673373 0.4006148628 0 -0.6210441689 -0.480679687 0 -0.2490566857 +8.600 1 -1.679006855 0 -15.25925514 -0.3885167365 0 -0.2913875524 0.4871469132 0 0.3653601849 +8.600 2 301.6790069 0 -13.73233706 0.3885167365 0 -0.6271974887 -0.4871469132 0 -0.2431929555 +8.625 1 -1.688566878 0 -15.26642516 -0.3762587029 0 -0.2821940272 0.4934718443 0 0.3701038832 +8.625 2 301.6885669 0 -13.74809237 0.3762587029 0 -0.6332030281 -0.4934718443 0 -0.2372345986 +8.650 1 -1.697818488 0 -15.27336387 -0.3638443515 0 -0.2728832636 0.4996519131 0 0.3747389348 +8.650 2 301.6978185 0 -13.76399596 0.3638443515 0 -0.639058448 -0.4996519131 0 -0.2311837642 +8.675 1 -1.706757823 0 -15.28006837 -0.3512773354 0 -0.2634580015 0.5056846137 0 0.3792634602 +8.675 2 301.7067578 0 -13.78004403 0.3512773354 0 -0.6447614639 -0.5056846137 0 -0.2250426432 +8.700 1 -1.715381113 0 -15.28653584 -0.3385613693 0 -0.253921027 0.5115675025 0 0.3836756268 +8.700 2 301.7153811 0 -13.79623274 0.3385613693 0 -0.6503098464 -0.5115675025 0 -0.2188134673 +8.725 1 -1.723684682 0 -15.29276351 -0.3257002285 0 -0.2442751714 0.5172981994 0 0.3879736495 +8.725 2 301.7236847 0 -13.81255821 0.3257002285 0 -0.6557014224 -0.5172981994 0 -0.2124985075 +8.750 1 -1.731664947 0 -15.29874871 -0.3126977469 0 -0.2345233102 0.5228743891 0 0.3921557918 +8.750 2 301.7316649 0 -13.82901649 0.3126977469 0 -0.6609340761 -0.5228743891 0 -0.2061000738 +8.775 1 -1.739318424 0 -15.30448882 -0.2995578154 0 -0.2246683615 0.5282938221 0 0.3962203666 +8.775 2 301.7393184 0 -13.84560357 0.2995578154 0 -0.66600575 -0.5282938221 0 -0.1996205135 +8.800 1 -1.746641725 0 -15.30998129 -0.2862843803 0 -0.2147132852 0.5335543162 0 0.4001657371 +8.800 2 301.7466417 0 -13.86231542 0.2862843803 0 -0.6709144456 -0.5335543162 0 -0.1930622104 +8.825 1 -1.753631564 0 -15.31522367 -0.2728814417 0 -0.2046610813 0.5386537571 0 0.4039903178 +8.825 2 301.7536316 0 -13.87914792 0.2728814417 0 -0.6756582245 -0.5386537571 0 -0.1864275838 +8.850 1 -1.760284752 0 -15.32021356 -0.2593530516 0 -0.1945147887 0.5435900998 0 0.4076925749 +8.850 2 301.7602848 0 -13.89609694 0.2593530516 0 -0.6802352092 -0.5435900998 0 -0.1797190873 +8.875 1 -1.766598205 0 -15.32494865 -0.2457033123 0 -0.1842774843 0.5483613698 0 0.4112710274 +8.875 2 301.7665982 0 -13.91315828 0.2457033123 0 -0.684643584 -0.5483613698 0 -0.1729392075 +8.900 1 -1.772568941 0 -15.32942671 -0.2319363746 0 -0.173952281 0.5529656638 0 0.4147242478 +8.900 2 301.7725689 0 -13.9303277 0.2319363746 0 -0.6888815957 -0.5529656638 0 -0.1660904633 +8.925 1 -1.778194082 0 -15.33364556 -0.2180564359 0 -0.1635423269 0.5574011506 0 0.418050863 +8.925 2 301.7781941 0 -13.94760092 0.2180564359 0 -0.6929475545 -0.5574011506 0 -0.1591754041 +8.950 1 -1.783470856 0 -15.33760314 -0.2040677385 0 -0.1530508039 0.5616660727 0 0.4212495545 +8.950 2 301.7834709 0 -13.96497363 0.2040677385 0 -0.6968398348 -0.5616660727 0 -0.1521966093 +8.975 1 -1.788396598 0 -15.34129745 -0.1899745677 0 -0.1424809258 0.5657587463 0 0.4243190597 +8.975 2 301.7883966 0 -13.98244145 0.1899745677 0 -0.7005568756 -0.5657587463 0 -0.1451566865 +9.000 1 -1.79296875 0 -15.34472656 -0.17578125 0 -0.1318359375 0.5696775629 0 0.4272581722 +9.000 2 301.7929688 0 -14 0.17578125 0 -0.7040971816 -0.5696775629 0 -0.1380582709 +9.025 1 -1.797184862 0 -15.34788865 -0.1614921511 0 -0.1211191134 0.5734209901 0 0.4300657426 +9.025 2 301.7971849 0 -14.01764483 0.1614921511 0 -0.7074593238 -0.5734209901 0 -0.1309040234 +9.050 1 -1.801042596 0 -15.35078195 -0.1471116742 0 -0.1103337557 0.5769875717 0 0.4327406788 +9.050 2 301.8010426 0 -14.03537147 0.1471116742 0 -0.7106419399 -0.5769875717 0 -0.1236966298 +9.075 1 -1.804539722 0 -15.35340479 -0.1326442578 0 -0.09948319333 0.5803759296 0 0.4352819472 +9.075 2 301.8045397 0 -14.05317542 0.1326442578 0 -0.713643735 -0.5803759296 0 -0.1164387996 +9.100 1 -1.807674122 0 -15.35575559 -0.1180943738 0 -0.08857078035 0.5835847634 0 0.4376885726 +9.100 2 301.8076741 0 -14.07105214 0.1180943738 0 -0.7164634823 -0.5835847634 0 -0.1091332642 +9.125 1 -1.810443791 0 -15.35783284 -0.1034665258 0 -0.07759989438 0.5866128521 0 0.439959639 +9.125 2 301.8104438 0 -14.08899707 0.1034665258 0 -0.7191000236 -0.5866128521 0 -0.1017827762 +9.150 1 -1.812846836 0 -15.35963513 -0.08876524695 0 -0.06657393521 0.5894590539 0 0.4420942904 +9.150 2 301.8128468 0 -14.10700561 0.08876524695 0 -0.7215522697 -0.5894590539 0 -0.09439010787 +9.175 1 -1.814881479 0 -15.36116111 -0.07399509774 0 -0.0554963233 0.5921223076 0 0.4440917307 +9.175 2 301.8148815 0 -14.12507314 0.07399509774 0 -0.7238192008 -0.5921223076 0 -0.08695804975 +9.200 1 -1.816546055 0 -15.36240954 -0.05916066433 0 -0.04437049825 0.5946016326 0 0.4459512244 +9.200 2 301.8165461 0 -14.14319501 0.05916066433 0 -0.7258998673 -0.5946016326 0 -0.0794894094 +9.225 1 -1.817839015 0 -15.36337926 -0.04426655636 0 -0.03319991727 0.5968961298 0 0.4476720973 +9.225 2 301.817839 0 -14.16136657 0.04426655636 0 -0.7277933899 -0.5968961298 0 -0.07198701009 +9.250 1 -1.818758924 0 -15.36406919 -0.02931740491 0 -0.02198805368 0.5990049819 0 0.4492537364 +9.250 2 301.8187589 0 -14.17958312 0.02931740491 0 -0.7294989601 -0.5990049819 0 -0.06445368942 +9.275 1 -1.819304465 0 -15.36447835 -0.01431786045 0 -0.01073839534 0.6009274542 0 0.4506955907 +9.275 2 301.8193045 0 -14.19783995 0.01431786045 0 -0.7310158404 -0.6009274542 0 -0.05689229794 +9.300 1 -1.819474436 0 -15.36460583 0.0007274091798 0 0.0005455568849 0.6026628946 0 0.4519971709 +9.300 2 301.8194744 0 -14.21613233 -0.0007274091798 0 -0.7323433649 -0.6026628946 0 -0.04930569783 +9.325 1 -1.819267753 0 -15.36445081 0.01581372091 0 0.01186029068 0.6042107343 0 0.4531580507 +9.325 2 301.8192678 0 -14.23445553 -0.01581372091 0 -0.7334809392 -0.6042107343 0 -0.04169676151 +9.350 1 -1.818683447 0 -15.36401259 0.03093637849 0 0.02320228387 0.605570488 0 0.454177866 +9.350 2 301.8186834 0 -14.25280479 -0.03093637849 0 -0.7344280409 -0.605570488 0 -0.03406837023 +9.375 1 -1.81772067 0 -15.3632905 0.04609067456 0 0.03456800592 0.6067417544 0 0.4550563158 +9.375 2 301.8177207 0 -14.27117534 -0.04609067456 0 -0.7351842197 -0.6067417544 0 -0.0264234127 +9.400 1 -1.816378689 0 -15.36228402 0.06127189281 0 0.04595391961 0.6077242163 0 0.4557931622 +9.400 2 301.8163787 0 -14.28956241 -0.06127189281 0 -0.7357490976 -0.6077242163 0 -0.01876478368 +9.425 1 -1.814656891 0 -15.36099267 0.07647531004 0 0.05735648253 0.6085176409 0 0.4563882307 +9.425 2 301.8146569 0 -14.3079612 -0.07647531004 0 -0.7361223691 -0.6085176409 0 -0.01109538259 +9.450 1 -1.812554778 0 -15.35941608 0.09169619829 0 0.06877214872 0.60912188 0 0.45684141 +9.450 2 301.8125548 0 -14.32636693 -0.09169619829 0 -0.7363038011 -0.60912188 0 -0.003418112082 +9.475 1 -1.810071975 0 -15.35755398 0.1069298269 0 0.08019737021 0.6095368701 0 0.4571526526 +9.475 2 301.810072 0 -14.34477479 -0.1069298269 0 -0.7362932333 -0.6095368701 0 0.00426412336 +9.500 1 -1.80720822 0 -15.35540617 0.1221714649 0 0.09162859866 0.6097626327 0 0.4573219745 +9.500 2 301.8072082 0 -14.36317999 -0.1221714649 0 -0.7360905778 -0.6097626327 0 0.01194841886 +9.525 1 -1.803963374 0 -15.35297253 0.1374163825 0 0.1030622869 0.609799274 0 0.4573494555 +9.525 2 301.8039634 0 -14.38157772 -0.1374163825 0 -0.7356958194 -0.609799274 0 0.01963187056 +9.550 1 -1.800337413 0 -15.35025306 0.1526598541 0 0.1144948906 0.6096469853 0 0.4572352389 +9.550 2 301.8003374 0 -14.39996318 -0.1526598541 0 -0.7351090155 -0.6096469853 0 0.02731157704 +9.575 1 -1.796330433 0 -15.34724782 0.1678971597 0 0.1259228698 0.6093060427 0 0.456979532 +9.575 2 301.7963304 0 -14.41833157 -0.1678971597 0 -0.7343302959 -0.6093060427 0 0.03498464077 +9.600 1 -1.791942646 0 -15.34395698 0.1831235871 0 0.1373426904 0.6087768074 0 0.4565826056 +9.600 2 301.7919426 0 -14.4366781 -0.1831235871 0 -0.7333598629 -0.6087768074 0 0.04264816953 +9.625 1 -1.787174383 0 -15.34038079 0.1983344346 0 0.148750826 0.6080597252 0 0.4560447939 +9.625 2 301.7871744 0 -14.45499797 -0.1983344346 0 -0.7321979909 -0.6080597252 0 0.05029927783 +9.650 1 -1.782026093 0 -15.33651957 0.2135250124 0 0.1601437593 0.6071553266 0 0.455366495 +9.650 2 301.7820261 0 -14.4732864 -0.2135250124 0 -0.7308450265 -0.6071553266 0 0.05793508836 +9.675 1 -1.77649834 0 -15.33237376 0.2286906451 0 0.1715179838 0.6060642265 0 0.4545481698 +9.675 2 301.7764983 0 -14.49153863 -0.2286906451 0 -0.7293013879 -0.6060642265 0 0.06555273339 +9.700 1 -1.770591807 0 -15.32794386 0.2438266737 0 0.1828700053 0.604787124 0 0.453590343 +9.700 2 301.7705918 0 -14.50974989 -0.2438266737 0 -0.727567565 -0.604787124 0 0.07314935626 +9.725 1 -1.764307292 0 -15.32323047 0.2589284578 0 0.1941963433 0.6033248022 0 0.4524936016 +9.725 2 301.7643073 0 -14.52791543 -0.2589284578 0 -0.725644119 -0.6033248022 0 0.08072211274 +9.750 1 -1.757645708 0 -15.31823428 0.2739913775 0 0.2054935331 0.6016781278 0 0.4512585959 +9.750 2 301.7576457 0 -14.54603052 -0.2739913775 0 -0.7235316819 -0.6016781278 0 0.08826817251 +9.775 1 -1.750608085 0 -15.31295606 0.2890108358 0 0.2167581268 0.599848051 0 0.4498860382 +9.775 2 301.7506081 0 -14.56409044 -0.2890108358 0 -0.7212309563 -0.599848051 0 0.09578472055 +9.800 1 -1.743195567 0 -15.30739668 0.3039822603 0 0.2279866952 0.5978356045 0 0.4483767034 +9.800 2 301.7431956 0 -14.5820905 -0.3039822603 0 -0.7187427151 -0.5978356045 0 0.1032689586 +9.825 1 -1.735409411 0 -15.30155706 0.3189011055 0 0.2391758291 0.5956419037 0 0.4467314278 +9.825 2 301.7354094 0 -14.60002602 -0.3189011055 0 -0.7160678008 -0.5956419037 0 0.1107181064 +9.850 1 -1.727250987 0 -15.29543824 0.333762855 0 0.2503221412 0.5932681459 0 0.4449511094 +9.850 2 301.727251 0 -14.61789234 -0.333762855 0 -0.7132071252 -0.5932681459 0 0.1181294035 +9.875 1 -1.718721781 0 -15.28904134 0.348563023 0 0.2614222672 0.5907156099 0 0.4430367074 +9.875 2 301.7187218 0 -14.63568484 -0.348563023 0 -0.7101616689 -0.5907156099 0 0.1255001102 +9.900 1 -1.709823387 0 -15.28236754 0.363297157 0 0.2724728677 0.5879856552 0 0.4409892414 +9.900 2 301.7098234 0 -14.6533989 -0.363297157 0 -0.7069324806 -0.5879856552 0 0.1328275092 +9.925 1 -1.70055751 0 -15.27541813 0.3779608392 0 0.2834706294 0.5850797216 0 0.4388097912 +9.925 2 301.7005575 0 -14.67102994 -0.3779608392 0 -0.7035206768 -0.5850797216 0 0.1401089069 +9.950 1 -1.690925968 0 -15.26819448 0.3925496892 0 0.2944122669 0.5819993288 0 0.4364994966 +9.950 2 301.690926 0 -14.68857342 -0.3925496892 0 -0.6999274408 -0.5819993288 0 0.147341635 +9.975 1 -1.680930686 0 -15.26069801 0.4070593651 0 0.3052945239 0.578746075 0 0.4340595562 +9.975 2 301.6809307 0 -14.70602481 -0.4070593651 0 -0.6961540226 -0.578746075 0 0.1545230515 +10.000 1 -1.670573696 0 -15.25293027 0.4214855664 0 0.3161141748 0.5753216368 0 0.4314912276 +10.000 2 301.6705737 0 -14.72337963 -0.4214855664 0 -0.6922017376 -0.5753216368 0 0.1616505422 +10.025 1 -1.659857138 0 -15.24489285 0.435824035 0 0.3268680263 0.5717277681 0 0.4287958261 +10.025 2 301.6598571 0 -14.74063342 -0.435824035 0 -0.6880719664 -0.5717277681 0 0.1687215225 +10.050 1 -1.64878326 0 -15.23658745 0.4500705581 0 0.3375529186 0.5679662995 0 0.4259747246 +10.050 2 301.6487833 0 -14.75778176 -0.4500705581 0 -0.6837661537 -0.5679662995 0 0.1757334378 +10.075 1 -1.637354411 0 -15.22801581 0.4642209692 0 0.3481657269 0.5640391372 0 0.4230293529 +10.075 2 301.6373544 0 -14.77482027 -0.4642209692 0 -0.6792858078 -0.5640391372 0 0.1826837658 +10.100 1 -1.625573047 0 -15.21917979 0.4782711507 0 0.358703363 0.5599482624 0 0.4199611968 +10.100 2 301.625573 0 -14.79174461 -0.4782711507 0 -0.6746324994 -0.5599482624 0 0.1895700172 +10.125 1 -1.613441723 0 -15.21008129 0.4922170352 0 0.3691627764 0.5556957299 0 0.4167717974 +10.125 2 301.6134417 0 -14.80855047 -0.4922170352 0 -0.6698078614 -0.5556957299 0 0.1963897373 +10.150 1 -1.600963098 0 -15.20072232 0.5060546077 0 0.3795409558 0.5512836676 0 0.4134627507 +10.150 2 301.6009631 0 -14.82523359 -0.5060546077 0 -0.6648135872 -0.5512836676 0 0.203140507 +10.175 1 -1.588139928 0 -15.19110495 0.5197799074 0 0.3898349306 0.5467142753 0 0.4100357064 +10.175 2 301.5881399 0 -14.84178975 -0.5197799074 0 -0.6596514305 -0.5467142753 0 0.2098199445 +10.200 1 -1.57497507 0 -15.1812313 0.5333890293 0 0.400041772 0.5419898234 0 0.4064923676 +10.200 2 301.5749751 0 -14.85821478 -0.5333890293 0 -0.6543232039 -0.5419898234 0 0.2164257062 +10.225 1 -1.561471477 0 -15.17110361 0.5468781259 0 0.4101585945 0.5371126523 0 0.4028344892 +10.225 2 301.5614715 0 -14.87450454 -0.5468781259 0 -0.6488307783 -0.5371126523 0 0.2229554881 +10.250 1 -1.547632196 0 -15.16072415 0.5602434093 0 0.420182557 0.5320851709 0 0.3990638782 +10.250 2 301.5476322 0 -14.89065496 -0.5602434093 0 -0.6431760815 -0.5320851709 0 0.2294070271 +10.275 1 -1.533460369 0 -15.15009528 0.5734811525 0 0.4301108644 0.5269098553 0 0.3951823915 +10.275 2 301.5334604 0 -14.90666201 -0.5734811525 0 -0.6373610975 -0.5269098553 0 0.2357781019 +10.300 1 -1.518959232 0 -15.13921942 0.5865876913 0 0.4399407685 0.521589248 0 0.391191936 +10.300 2 301.5189592 0 -14.9225217 -0.5865876913 0 -0.6313878651 -0.521589248 0 0.2420665345 +10.325 1 -1.504132108 0 -15.12809908 0.5995594259 0 0.4496695694 0.5161259565 0 0.3870944674 +10.325 2 301.5041321 0 -14.9382301 -0.5995594259 0 -0.6252584773 -0.5161259565 0 0.2482701914 +10.350 1 -1.488982413 0 -15.11673681 0.6123928223 0 0.4592946167 0.5105226516 0 0.3828919887 +10.350 2 301.4889824 0 -14.95378334 -0.6123928223 0 -0.6189750794 -0.5105226516 0 0.2543869846 +10.375 1 -1.473513649 0 -15.10513524 0.6250844144 0 0.4688133108 0.5047820669 0 0.3785865502 +10.375 2 301.4735136 0 -14.96917759 -0.6250844144 0 -0.6125398689 -0.5047820669 0 0.2604148727 +10.400 1 -1.457729403 0 -15.09329705 0.6376308049 0 0.4782231037 0.4989069965 0 0.3741802474 +10.400 2 301.4577294 0 -14.98440909 -0.6376308049 0 -0.6059550933 -0.4989069965 0 0.2663518621 +10.425 1 -1.441633346 0 -15.08122501 0.6500286673 0 0.4875215005 0.4929002944 0 0.3696752208 +10.425 2 301.4416333 0 -14.99947412 -0.6500286673 0 -0.5992230495 -0.4929002944 0 0.2721960082 +10.450 1 -1.425229234 0 -15.06892193 0.662274747 0 0.4967060602 0.4867648726 0 0.3650736544 +10.450 2 301.4252292 0 -15.01436903 -0.662274747 0 -0.5923460824 -0.4867648726 0 0.2779454164 +10.475 1 -1.4085209 0 -15.05639068 0.674365863 0 0.5057743972 0.4805036997 0 0.3603777748 +10.475 2 301.4085209 0 -15.02909023 -0.674365863 0 -0.5853265836 -0.4805036997 0 0.283598243 +10.500 1 -1.391512258 0 -15.04363419 0.6862989092 0 0.5147241819 0.4741197995 0 0.3555898496 +10.500 2 301.3915123 0 -15.04363419 -0.6862989092 0 -0.57816699 -0.4741197995 0 0.2891526963 +10.525 1 -1.374207297 0 -15.03065547 0.6980708559 0 0.5235531419 0.4676162495 0 0.3507121871 +10.525 2 301.3742073 0 -15.05799744 -0.6980708559 0 -0.570869783 -0.4676162495 0 0.294607038 +10.550 1 -1.356610083 0 -15.01745756 0.7096787507 0 0.532259063 0.4609961792 0 0.3457471344 +10.550 2 301.3566101 0 -15.07217656 -0.7096787507 0 -0.5634374865 -0.4609961792 0 0.2999595834 +10.575 1 -1.338724751 0 -15.00404356 0.7211197203 0 0.5408397902 0.4542627685 0 0.3406970764 +10.575 2 301.3387248 0 -15.08616821 -0.7211197203 0 -0.5558726658 -0.4542627685 0 0.3052087033 +10.600 1 -1.320555511 0 -14.99041663 0.7323909715 0 0.5492932286 0.4474192462 0 0.3355644346 +10.600 2 301.3205555 0 -15.09996911 -0.7323909715 0 -0.5481779263 -0.4474192462 0 0.310352824 +10.625 1 -1.302106639 0 -14.97657998 0.7434897923 0 0.5576173442 0.4404688883 0 0.3303516662 +10.625 2 301.3021066 0 -15.11357604 -0.7434897923 0 -0.5403559122 -0.4404688883 0 0.3153904289 +10.650 1 -1.28338248 0 -14.96253686 0.7544135533 0 0.565810165 0.4334150161 0 0.3250612621 +10.650 2 301.2833825 0 -15.12698587 -0.7544135533 0 -0.5324093047 -0.4334150161 0 0.3203200592 +10.675 1 -1.264387442 0 -14.94829058 0.7651597085 0 0.5738697814 0.4262609948 0 0.3196957461 +10.675 2 301.2643874 0 -15.14019549 -0.7651597085 0 -0.5243408207 -0.4262609948 0 0.3251403145 +10.700 1 -1.245125995 0 -14.9338445 0.7757257968 0 0.5817943476 0.4190102316 0 0.3142576737 +10.700 2 301.245126 0 -15.15320191 -0.7757257968 0 -0.5161532116 -0.4190102316 0 0.3298498539 +10.725 1 -1.225602672 0 -14.919202 0.7861094426 0 0.589582082 0.4116661739 0 0.3087496304 +10.725 2 301.2256027 0 -15.16600218 -0.7861094426 0 -0.5078492613 -0.4116661739 0 0.3344473967 +10.750 1 -1.205822063 0 -14.90436655 0.7963083571 0 0.5972312678 0.4042323073 0 0.3031742305 +10.750 2 301.2058221 0 -15.17859343 -0.7963083571 0 -0.4994317852 -0.4042323073 0 0.3389317234 +10.775 1 -1.185788812 0 -14.88934161 0.8063203389 0 0.6047402542 0.3967121543 0 0.2975341157 +10.775 2 301.1857888 0 -15.19097285 -0.8063203389 0 -0.4909036283 -0.3967121543 0 0.343301676 +10.800 1 -1.165507621 0 -14.87413072 0.8161432754 0 0.6121074566 0.3891092719 0 0.2918319539 +10.800 2 301.1655076 0 -15.20313771 -0.8161432754 0 -0.4822676637 -0.3891092719 0 0.347556159 +10.825 1 -1.144983241 0 -14.85873743 0.825775143 0 0.6193313573 0.38142725 0 0.2860704375 +10.825 2 301.1449832 0 -15.21508536 -0.825775143 0 -0.4735267912 -0.38142725 0 0.3516941402 +10.850 1 -1.124220472 0 -14.84316535 0.8352140086 0 0.6264105064 0.3736697095 0 0.2802522821 +10.850 2 301.1242205 0 -15.2268132 -0.8352140086 0 -0.4646839356 -0.3736697095 0 0.355714651 +10.875 1 -1.103224164 0 -14.82741812 0.8444580296 0 0.6333435222 0.3658403001 0 0.274380225 +10.875 2 301.1032242 0 -15.23831873 -0.8444580296 0 -0.4557420451 -0.3658403001 0 0.3596167874 +10.900 1 -1.081999209 0 -14.81149941 0.8535054553 0 0.6401290915 0.3579426986 0 0.268457024 +10.900 2 301.0819992 0 -15.2495995 -0.8535054553 0 -0.4467040897 -0.3579426986 0 0.3633997103 +10.925 1 -1.060550543 0 -14.79541291 0.8623546271 0 0.6467659703 0.349980607 0 0.2624854553 +10.925 2 301.0605505 0 -15.26065316 -0.8623546271 0 -0.4375730595 -0.349980607 0 0.3670626462 +10.950 1 -1.038883143 0 -14.77916236 0.8710039793 0 0.6532529845 0.3419577503 0 0.2564683127 +10.950 2 301.0388831 0 -15.27147741 -0.8710039793 0 -0.4283519632 -0.3419577503 0 0.3706048879 +10.975 1 -1.017002022 0 -14.76275152 0.8794520395 0 0.6595890296 0.3338778744 0 0.2504084058 +10.975 2 301.017002 0 -15.28207003 -0.8794520395 0 -0.4190438263 -0.3338778744 0 0.3740257945 +11.000 1 -0.9949122299 0 -14.74618417 0.8876974292 0 0.6657730719 0.3257447443 0 0.2443085583 +11.000 2 300.9949122 0 -15.2924289 -0.8876974292 0 -0.4096516894 -0.3257447443 0 0.3773247923 +11.025 1 -0.9726188501 0 -14.72946414 0.8957388644 0 0.6718041483 0.3175621421 0 0.2381716065 +11.025 2 300.9726189 0 -15.30255194 -0.8957388644 0 -0.4001786068 -0.3175621421 0 0.3805013753 +11.050 1 -0.9501269963 0 -14.71259525 0.9035751557 0 0.6776813668 0.3093338644 0 0.2320003983 +11.050 2 300.950127 0 -15.31243718 -0.9035751557 0 -0.3906276445 -0.3093338644 0 0.3835551052 +11.075 1 -0.927441811 0 -14.69558136 0.9112052087 0 0.6834039066 0.3010637209 0 0.2257977907 +11.075 2 300.9274418 0 -15.3220827 -0.9112052087 0 -0.3810018784 -0.3010637209 0 0.386485612 +11.100 1 -0.9045684628 0 -14.67842635 0.9186280247 0 0.6889710185 0.292755532 0 0.219566649 +11.100 2 300.9045685 0 -15.33148668 -0.9186280247 0 -0.3713043932 -0.292755532 0 0.3892925944 +11.125 1 -0.8815121443 0 -14.66113411 0.9258427002 0 0.6943820251 0.2844131264 0 0.2133098448 +11.125 2 300.8815121 0 -15.34064735 -0.9258427002 0 -0.36153828 -0.2844131264 0 0.3919758198 +11.150 1 -0.8582780691 0 -14.64370855 0.9328484278 0 0.6996363209 0.2760403395 0 0.2070302546 +11.150 2 300.8582781 0 -15.34956304 -0.9328484278 0 -0.3517066349 -0.2760403395 0 0.3945351249 +11.175 1 -0.8348714701 0 -14.6261536 0.939644496 0 0.704733372 0.2676410107 0 0.200730758 +11.175 2 300.8348715 0 -15.35823216 -0.939644496 0 -0.3418125573 -0.2676410107 0 0.396970416 +11.200 1 -0.8112975966 0 -14.6084732 0.9462302892 0 0.7096727169 0.2592189818 0 0.1944142364 +11.200 2 300.8112976 0 -15.36665318 -0.9462302892 0 -0.3318591478 -0.2592189818 0 0.3992816685 +11.225 1 -0.7875617123 0 -14.59067128 0.9526052879 0 0.7144539659 0.2507780944 0 0.1880835708 +11.225 2 300.7875617 0 -15.37482465 -0.9526052879 0 -0.3218495071 -0.2507780944 0 0.4014689279 +11.250 1 -0.7636690924 0 -14.57275182 0.9587690687 0 0.7190768016 0.242322188 0 0.181741641 +11.250 2 300.7636691 0 -15.38274521 -0.9587690687 0 -0.3117867338 -0.242322188 0 0.4035323095 +11.275 1 -0.7396250217 0 -14.55471877 0.9647213041 0 0.7235409781 0.2338550974 0 0.175391323 +11.275 2 300.739625 0 -15.39041357 -0.9647213041 0 -0.3016739225 -0.2338550974 0 0.4054719984 +11.300 1 -0.715434792 0 -14.53657609 0.9704617623 0 0.7278463217 0.2253806511 0 0.1690354883 +11.300 2 300.7154348 0 -15.39782851 -0.9704617623 0 -0.2915141625 -0.2253806511 0 0.4072882498 +11.325 1 -0.6911036996 0 -14.51832777 0.9759903072 0 0.7319927304 0.2169026686 0 0.1626770015 +11.325 2 300.6911037 0 -15.40498891 -0.9759903072 0 -0.2813105359 -0.2169026686 0 0.4089813888 +11.350 1 -0.666637043 0 -14.49997778 0.981306898 0 0.7359801735 0.2084249586 0 0.1563187189 +11.350 2 300.666637 0 -15.4118937 -0.981306898 0 -0.2710661157 -0.2084249586 0 0.4105518106 +11.375 1 -0.6420401205 0 -14.48153009 0.986411589 0 0.7398086918 0.1999513163 0 0.1499634872 +11.375 2 300.6420401 0 -15.4185419 -0.986411589 0 -0.2607839642 -0.1999513163 0 0.4119999801 +11.400 1 -0.6173182281 0 -14.46298867 0.9913045292 0 0.7434783969 0.1914855216 0 0.1436141412 +11.400 2 300.6173182 0 -15.42493261 -0.9913045292 0 -0.250467131 -0.1914855216 0 0.4133264321 +11.425 1 -0.5924766567 0 -14.44435749 0.9959859619 0 0.7469894714 0.1830313366 0 0.1372735025 +11.425 2 300.5924767 0 -15.431065 -0.9959859619 0 -0.2401186519 -0.1830313366 0 0.4145317712 +11.450 1 -0.5675206898 0 -14.42564052 1.000456224 0 0.750342168 0.1745925039 0 0.1309443779 +11.450 2 300.5675207 0 -15.4369383 -1.000456224 0 -0.2297415462 -0.1745925039 0 0.4156166712 +11.475 1 -0.5424556017 0 -14.4068417 1.004715746 0 0.7535368095 0.1661727435 0 0.1246295576 +11.475 2 300.5424556 0 -15.44255186 -1.004715746 0 -0.2193388158 -0.1661727435 0 0.4165818754 +11.500 1 -0.5172866544 0 -14.38796499 1.008765051 0 0.7565737882 0.1577757513 0 0.1183318135 +11.500 2 300.5172867 0 -15.44790506 -1.008765051 0 -0.2089134431 -0.1577757513 0 0.4174281959 +11.525 1 -0.4920190958 0 -14.36901432 1.012604754 0 0.7594535654 0.1494051967 0 0.1120538975 +11.525 2 300.4920191 0 -15.45299737 -1.012604754 0 -0.1984683894 -0.1494051967 0 0.4181565138 +11.550 1 -0.4666581575 0 -14.34999362 1.016235561 0 0.7621766711 0.1410647204 0 0.1057985403 +11.550 2 300.4666582 0 -15.45782834 -1.016235561 0 -0.1880065929 -0.1410647204 0 0.4187677783 +11.575 1 -0.4412090519 0 -14.33090679 1.019658271 0 0.764743703 0.1327579318 0 0.09956844885 +11.575 2 300.4412091 0 -15.46239758 -1.019658271 0 -0.1775309674 -0.1327579318 0 0.4192630068 +11.600 1 -0.4156769707 0 -14.31175773 1.022873769 0 0.7671553264 0.1244884075 0 0.09336630563 +11.600 2 300.415677 0 -15.46670479 -1.022873769 0 -0.1670444005 -0.1244884075 0 0.4196432843 +11.625 1 -0.3900670822 0 -14.29255031 1.025883031 0 0.7694122733 0.1162596885 0 0.08719476641 +11.625 2 300.3900671 0 -15.47074974 -1.025883031 0 -0.1565497516 -0.1162596885 0 0.419909763 +11.650 1 -0.364384529 0 -14.2732884 1.028687122 0 0.7715153417 0.1080752784 0 0.08105645881 +11.650 2 300.3643845 0 -15.47453224 -1.028687122 0 -0.1460498505 -0.1080752784 0 0.4200636617 +11.675 1 -0.3386344262 0 -14.25397582 1.031287193 0 0.7734653948 0.09993864086 0 0.07495398064 +11.675 2 300.3386344 0 -15.47805221 -1.031287193 0 -0.135547496 -0.09993864086 0 0.4201062655 +11.700 1 -0.3128218592 0 -14.23461639 1.033684481 0 0.7752633607 0.09185319769 0 0.06888989827 +11.700 2 300.3128219 0 -15.48130962 -1.033684481 0 -0.1250454535 -0.09185319769 0 0.420038925 +11.725 1 -0.2869518811 0 -14.21521391 1.035880308 0 0.7769102308 0.08382232665 0 0.06286674499 +11.725 2 300.2869519 0 -15.48430451 -1.035880308 0 -0.1145464541 -0.08382232665 0 0.419863056 +11.750 1 -0.261029511 0 -14.19577213 1.03787608 0 0.7784070598 0.07584935919 0 0.05688701939 +11.750 2 300.2610295 0 -15.48703699 -1.03787608 0 -0.1040531928 -0.07584935919 0 0.4195801386 +11.775 1 -0.2350597318 0 -14.1762948 1.039673286 0 0.7797549642 0.06793757841 0 0.05095318381 +11.775 2 300.2350597 0 -15.48950723 -1.039673286 0 -0.09356832642 -0.06793757841 0 0.4191917166 +11.800 1 -0.2090474883 0 -14.15678562 1.041273496 0 0.7809551217 0.06009021688 0 0.04506766266 +11.800 2 300.2090475 0 -15.49171549 -1.041273496 0 -0.08309447276 -0.06009021688 0 0.4186993969 +11.825 1 -0.1829976849 0 -14.13724826 1.04267836 0 0.7820087699 0.05231045455 0 0.03923284091 +11.825 2 300.1829977 0 -15.49366207 -1.04267836 0 -0.0726342085 -0.05231045455 0 0.4181048486 +11.850 1 -0.1569151838 0 -14.11768639 1.043889608 0 0.7829172057 0.04460141664 0 0.03345106248 +11.850 2 300.1569152 0 -15.49534734 -1.043889608 0 -0.06219006783 -0.04460141664 0 0.4174098023 +11.875 1 -0.130804803 0 -14.0981036 1.044909046 0 0.7836817842 0.03696617158 0 0.02772462868 +11.875 2 300.1308048 0 -15.49677173 -1.044909046 0 -0.05176454095 -0.03696617158 0 0.4166160494 +11.900 1 -0.1046713143 0 -14.07850349 1.045738556 0 0.7843039172 0.02940772893 0 0.0220557967 +11.900 2 300.1046713 0 -15.49793574 -1.045738556 0 -0.04136007251 -0.02940772893 0 0.415725441 +11.925 1 -0.07851944161 0 -14.05888958 1.046380097 0 0.7847850725 0.02192903736 0 0.01644677802 +11.925 2 300.0785194 0 -15.49883993 -1.046380097 0 -0.03097906013 -0.02192903736 0 0.414739887 +11.950 1 -0.05235385898 0 -14.03926539 1.046835697 0 0.7851267726 0.01453298261 0 0.01089973696 +11.950 2 300.0523539 0 -15.49948491 -1.046835697 0 -0.02062385298 -0.01453298261 0 0.4136613557 +11.975 1 -0.02617918878 0 -14.01963439 1.047107458 0 0.7853305935 0.007222385515 0 0.005416789136 +11.975 2 300.0261792 0 -15.49987136 -1.047107458 0 -0.0102967503 -0.007222385515 0 0.4124918719 +12.000 1 -4.898587197e-16 0 -14 1.047197551 0 0.7853981634 1.342975493e-16 0 1.00723162e-16 +12.000 2 300 0 -15.5 -1.047197551 0 -1.44275302e-16 -2.01446324e-16 0 0.4112335167 +12.025 1 0.02617919114 0 -13.98036561 1.047107835 0 0.7853308764 -0.007177173892 0 -0.005382880419 +12.025 2 299.9738208 0 -15.49987149 -1.047107835 0 0.01028054432 0.007177173892 0 0.4111982853 +12.050 1 0.05235389662 0 -13.96073458 1.046838703 0 0.7851290271 -0.01435311801 0 -0.01076483851 +12.050 2 299.9476461 0 -15.49948599 -1.046838703 0 0.02055932712 0.01435311801 0 0.4110925973 +12.075 1 0.07851963152 0 -13.94111028 1.0463902 0 0.7847926499 -0.0215266028 0 -0.0161449521 +12.075 2 299.9214804 0 -15.49884355 -1.0463902 0 0.03083458719 0.0215266028 0 0.4109164706 +12.100 1 0.1046719125 0 -13.92149607 1.045762403 0 0.7843218025 -0.02869639912 0 -0.02152229934 +12.100 2 299.8953281 0 -15.4979443 -1.045762403 0 0.04110456391 0.02869639912 0 0.4106699355 +12.125 1 0.1308062585 0 -13.90189531 1.044955421 0 0.7837165656 -0.03586127845 0 -0.02689595884 +12.125 2 299.8691937 0 -15.49678838 -1.044955421 0 0.05136749758 0.03586127845 0 0.4103530342 +12.150 1 0.1569181915 0 -13.88231136 1.043969391 0 0.782977043 -0.04302001314 0 -0.03226500985 +12.150 2 299.8430818 0 -15.495376 -1.043969391 0 0.06162162969 0.04302001314 0 0.409965821 +12.175 1 0.1830032373 0 -13.86274757 1.042804482 0 0.7821033612 -0.05017137657 0 -0.03762853243 +12.175 2 299.8169968 0 -15.49370739 -1.042804482 0 0.07186520325 0.05017137657 0 0.4095083623 +12.200 1 0.2090569265 0 -13.84320731 1.041460893 0 0.7810956701 -0.05731414339 0 -0.04298560755 +12.200 2 299.7909431 0 -15.49178284 -1.041460893 0 0.08209646307 0.05731414339 0 0.4089807365 +12.225 1 0.2350747949 0 -13.8236939 1.039938856 0 0.7799541422 -0.06444708974 0 -0.0483353173 +12.225 2 299.7649252 0 -15.48960269 -1.039938856 0 0.09231365609 0.06444708974 0 0.4083830339 +12.250 1 0.2610523844 0 -13.80421071 1.038238631 0 0.7786789732 -0.0715689934 0 -0.05367674505 +12.250 2 299.7389476 0 -15.48716729 -1.038238631 0 0.1025150316 0.0715689934 0 0.407715357 +12.275 1 0.286985244 0 -13.78476107 1.036360509 0 0.7772703816 -0.07867863408 0 -0.05900897556 +12.275 2 299.7130148 0 -15.48447708 -1.036360509 0 0.1126988418 0.07867863408 0 0.4069778201 +12.300 1 0.3128689301 0 -13.7653483 1.034304812 0 0.7757286087 -0.08577479359 0 -0.06433109519 +12.300 2 299.6871311 0 -15.48153251 -1.034304812 0 0.1228633415 0.08577479359 0 0.4061705497 +12.325 1 0.3386990077 0 -13.74597574 1.032071892 0 0.7740539187 -0.09285625603 0 -0.06964219202 +12.325 2 299.661301 0 -15.47833409 -1.032071892 0 0.1330067893 0.09285625603 0 0.4052936841 +12.350 1 0.364471051 0 -13.72664671 1.029662131 0 0.7722465986 -0.09992180802 0 -0.07494135602 +12.350 2 299.6355289 0 -15.47488236 -1.029662131 0 0.143127447 0.09992180802 0 0.4043473735 +12.375 1 0.390180644 0 -13.70736452 1.027075944 0 0.7703069579 -0.1069702389 0 -0.0802276792 +12.375 2 299.6098194 0 -15.47117792 -1.027075944 0 0.1532235806 0.1069702389 0 0.40333178 +12.400 1 0.4158233816 0 -13.68813246 1.024313772 0 0.7682353291 -0.114000341 0 -0.08550025578 +12.400 2 299.5841766 0 -15.4672214 -1.024313772 0 0.1632934601 0.114000341 0 0.4022470777 +12.425 1 0.44139487 0 -13.66895385 1.02137609 0 0.7660320672 -0.1210109098 0 -0.09075818233 +12.425 2 299.5586051 0 -15.46301348 -1.02137609 0 0.1733353601 0.1210109098 0 0.4010934525 +12.450 1 0.4668907277 0 -13.64983195 1.018263399 0 0.7636975496 -0.1280007439 0 -0.09600055794 +12.450 2 299.5331093 0 -15.45855488 -1.018263399 0 0.18334756 0.1280007439 0 0.3998711019 +12.475 1 0.4923065861 0 -13.63077006 1.014976235 0 0.7612321764 -0.1349686458 0 -0.1012264843 +12.475 2 299.5076934 0 -15.45384636 -1.014976235 0 0.1933283443 0.1349686458 0 0.3985802355 +12.500 1 0.5176380902 0 -13.61177143 1.01151516 0 0.7586363699 -0.1419134215 0 -0.1064350661 +12.500 2 299.4823619 0 -15.44888874 -1.01151516 0 0.2032760027 0.1419134215 0 0.3972210744 +12.525 1 0.5428808997 0 -13.59283933 1.007880767 0 0.7559105751 -0.148833881 0 -0.1116254108 +12.525 2 299.4571191 0 -15.44368285 -1.007880767 0 0.2131888308 0.148833881 0 0.3957938516 +12.550 1 0.5680306894 0 -13.57397698 1.004073678 0 0.7530552588 -0.1557288387 0 -0.116796629 +12.550 2 299.4319693 0 -15.4382296 -1.004073678 0 0.2230651301 0.1557288387 0 0.3942988115 +12.575 1 0.59308315 0 -13.55518764 1.000094547 0 0.7500709104 -0.162597113 0 -0.1219478347 +12.575 2 299.4069169 0 -15.43252992 -1.000094547 0 0.2329032084 0.162597113 0 0.3927362103 +12.600 1 0.6180339887 0 -13.53647451 0.9959440549 0 0.7469580412 -0.1694375271 0 -0.1270781453 +12.600 2 299.381966 0 -15.42658477 -0.9959440549 0 0.2427013798 0.1694375271 0 0.3911063158 +12.625 1 0.6428789306 0 -13.5178408 0.9916229128 0 0.7437171846 -0.176248909 0 -0.1321866817 +12.625 2 299.3571211 0 -15.42039519 -0.9916229128 0 0.2524579657 0.176248909 0 0.3894094072 +12.650 1 0.6676137185 0 -13.49928971 0.9871318611 0 0.7403488958 -0.1830300915 0 -0.1372725686 +12.650 2 299.3323863 0 -15.41396224 -0.9871318611 0 0.2621712942 0.1830300915 0 0.3876457754 +12.675 1 0.6922341142 0 -13.48082441 0.9824716695 0 0.7368537521 -0.1897799128 0 -0.1423349346 +12.675 2 299.3077659 0 -15.407287 -0.9824716695 0 0.2718397009 0.1897799128 0 0.3858157224 +12.700 1 0.7167358991 0 -13.46244808 0.9776431365 0 0.7332323524 -0.1964972162 0 -0.1473729122 +12.700 2 299.2832641 0 -15.40037064 -0.9776431365 0 0.2814615294 0.1964972162 0 0.3839195619 +12.725 1 0.741114875 0 -13.44416384 0.9726470893 0 0.729485317 -0.2031808509 0 -0.1523856382 +12.725 2 299.2588851 0 -15.39321433 -0.9726470893 0 0.2910351309 0.2031808509 0 0.3819576188 +12.750 1 0.7653668647 0 -13.42597485 0.967484384 0 0.725613288 -0.2098296716 0 -0.1573722537 +12.750 2 299.2346331 0 -15.3858193 -0.967484384 0 0.3005588649 0.2098296716 0 0.3799302292 +12.775 1 0.7894877128 0 -13.40788422 0.9621559053 0 0.721616929 -0.216442539 0 -0.1623319043 +12.775 2 299.2105123 0 -15.37818682 -0.9621559053 0 0.3100310998 0.216442539 0 0.3778377405 +12.800 1 0.8134732862 0 -13.38989504 0.9566625662 0 0.7174969246 -0.2230183201 0 -0.1672637401 +12.800 2 299.1865267 0 -15.37031819 -0.9566625662 0 0.3194502125 0.2230183201 0 0.3756805112 +12.825 1 0.8373194751 0 -13.37201039 0.9510053078 0 0.7132539808 -0.2295558882 0 -0.1721669162 +12.825 2 299.1626805 0 -15.36221476 -0.9510053078 0 0.328814589 0.2295558882 0 0.3734589111 +12.850 1 0.8610221936 0 -13.35423335 0.9451850995 0 0.7088888246 -0.2360541231 0 -0.1770405923 +12.850 2 299.1389778 0 -15.35387793 -0.9451850995 0 0.3381226248 0.2360541231 0 0.3711733206 +12.875 1 0.8845773804 0 -13.33656696 0.9392029387 0 0.704402204 -0.2425119113 0 -0.1818839335 +12.875 2 299.1154226 0 -15.34530911 -0.9392029387 0 0.347372725 0.2425119113 0 0.3688241315 +12.900 1 0.9079809995 0 -13.31901425 0.9330598502 0 0.6997948877 -0.2489281463 0 -0.1866961098 +12.900 2 299.092019 0 -15.33650979 -0.9330598502 0 0.3565633047 0.2489281463 0 0.3664117464 +12.925 1 0.9312290407 0 -13.30157822 0.9267568868 0 0.6950676651 -0.2553017288 0 -0.1914762966 +12.925 2 299.068771 0 -15.32748146 -0.9267568868 0 0.3656927891 0.2553017288 0 0.3639365784 +12.950 1 0.9543175205 0 -13.28426186 0.9202951283 0 0.6902213462 -0.2616315667 0 -0.196223675 +12.950 2 299.0456825 0 -15.31822567 -0.9202951283 0 0.374759614 0.2616315667 0 0.3613990518 +12.975 1 0.977242483 0 -13.26706814 0.913675682 0 0.6852567615 -0.2679165753 0 -0.2009374315 +12.975 2 299.0227575 0 -15.30874401 -0.913675682 0 0.3837622257 0.2679165753 0 0.3587996013 +13.000 1 1 0 -13.25 0.9068996821 0 0.6801747616 -0.2741556778 0 -0.2056167584 +13.000 2 299 0 -15.29903811 -0.9068996821 0 0.3926990817 0.2741556778 0 0.3561386724 +13.025 1 1.022586172 0 -13.23306037 0.8999682896 0 0.6749762172 -0.2803478051 0 -0.2102608539 +13.025 2 298.9774138 0 -15.28910962 -0.8999682896 0 0.4015686508 0.2803478051 0 0.3534167209 +13.050 1 1.044997129 0 -13.21625215 0.8928826922 0 0.6696620191 -0.2864918963 0 -0.2148689222 +13.050 2 298.9550029 0 -15.27896025 -0.8928826922 0 0.4103694131 0.2864918963 0 0.3506342133 +13.075 1 1.067229032 0 -13.19957823 0.8856441039 0 0.6642330779 -0.2925868986 0 -0.2194401739 +13.075 2 298.932771 0 -15.26859173 -0.8856441039 0 0.4190998608 0.2925868986 0 0.3477916263 +13.100 1 1.08927807 0 -13.18304145 0.878253765 0 0.6586903238 -0.2986317676 0 -0.2239738257 +13.100 2 298.9107219 0 -15.25800585 -0.878253765 0 0.4277584978 0.2986317676 0 0.344889447 +13.125 1 1.111140466 0 -13.16664465 0.8707129419 0 0.6530347064 -0.3046254676 0 -0.2284691007 +13.125 2 298.8888595 0 -15.24720442 -0.8707129419 0 0.4363438407 0.3046254676 0 0.3419281727 +13.150 1 1.132812474 0 -13.15039064 0.8630229266 0 0.647267195 -0.3105669716 0 -0.2329252287 +13.150 2 298.8671875 0 -15.23618928 -0.8630229266 0 0.4448544182 0.3105669716 0 0.3389083108 +13.175 1 1.15429038 0 -13.13428221 0.8551850368 0 0.6413887776 -0.3164552615 0 -0.2373414462 +13.175 2 298.8457096 0 -15.22496233 -0.8551850368 0 0.4532887723 0.3164552615 0 0.3358303786 +13.200 1 1.175570505 0 -13.11832212 0.8472006154 0 0.6354004615 -0.3222893285 0 -0.2417169964 +13.200 2 298.8244295 0 -15.21352549 -0.8472006154 0 0.4616454576 0.3222893285 0 0.3326949037 +13.225 1 1.196649201 0 -13.1025131 0.8390710305 0 0.6293032729 -0.3280681728 0 -0.2460511296 +13.225 2 298.8033508 0 -15.20188072 -0.8390710305 0 0.4699230424 0.3280681728 0 0.3295024232 +13.250 1 1.217522858 0 -13.08685786 0.8307976752 0 0.6230982564 -0.3337908044 0 -0.2503431033 +13.250 2 298.7824771 0 -15.19003001 -0.8307976752 0 0.4781201083 0.3337908044 0 0.3262534841 +13.275 1 1.238187899 0 -13.07135908 0.8223819669 0 0.6167864752 -0.3394562426 0 -0.2545921819 +13.275 2 298.7618121 0 -15.1779754 -0.8223819669 0 0.4862352508 0.3394562426 0 0.3229486432 +13.300 1 1.258640782 0 -13.05601941 0.8138253478 0 0.6103690108 -0.3450635167 0 -0.2587976376 +13.300 2 298.7413592 0 -15.16571894 -0.8138253478 0 0.4942670793 0.3450635167 0 0.3195884667 +13.325 1 1.278878004 0 -13.0408415 0.8051292838 0 0.6038469629 -0.350611666 0 -0.2629587495 +13.325 2 298.721122 0 -15.15326275 -0.8051292838 0 0.5022142178 0.350611666 0 0.3161735304 +13.350 1 1.298896097 0 -13.02582793 0.7962952651 0 0.5972214488 -0.3560997398 0 -0.2670748048 +13.350 2 298.7011039 0 -15.14060895 -0.7962952651 0 0.5100753044 0.3560997398 0 0.3127044194 +13.375 1 1.31869163 0 -13.01098128 0.7873248053 0 0.590493604 -0.3615267977 0 -0.2711450983 +13.375 2 298.6813084 0 -15.12775971 -0.7873248053 0 0.5178489922 0.3615267977 0 0.309181728 +13.400 1 1.338261213 0 -12.99630409 0.7782194414 0 0.5836645811 -0.3668919099 0 -0.2751689324 +13.400 2 298.6617388 0 -15.11471724 -0.7782194414 0 0.5255339493 0.3668919099 0 0.30560606 +13.425 1 1.357601491 0 -12.98179888 0.7689807337 0 0.5767355503 -0.372194157 0 -0.2791456177 +13.425 2 298.6423985 0 -15.10148376 -0.7689807337 0 0.5331288589 0.372194157 0 0.301978028 +13.450 1 1.376709151 0 -12.96746814 0.759610265 0 0.5697076988 -0.3774326305 0 -0.2830744729 +13.450 2 298.6232908 0 -15.08806156 -0.759610265 0 0.5406324195 0.3774326305 0 0.2982982535 +13.475 1 1.39558092 0 -12.95331431 0.7501096411 0 0.5625822308 -0.382606433 0 -0.2869548247 +13.475 2 298.6044191 0 -15.07445292 -0.7501096411 0 0.5480433456 0.382606433 0 0.2945673672 +13.500 1 1.414213562 0 -12.93933983 0.7404804897 0 0.5553603673 -0.3877146778 0 -0.2907860083 +13.500 2 298.5857864 0 -15.06066017 -0.7404804897 0 0.5553603673 0.3877146778 0 0.2907860083 +13.525 1 1.432603887 0 -12.92554708 0.7307244608 0 0.5480433456 -0.3927564896 0 -0.2945673672 +13.525 2 298.5673961 0 -15.04668569 -0.7307244608 0 0.5625822308 0.3927564896 0 0.2869548247 +13.550 1 1.450748742 0 -12.91193844 0.720843226 0 0.5406324195 -0.3977310047 0 -0.2982982535 +13.550 2 298.5492513 0 -15.03253186 -0.720843226 0 0.5697076988 0.3977310047 0 0.2830744729 +13.575 1 1.468645019 0 -12.89851624 0.7108384785 0 0.5331288589 -0.4026373706 0 -0.301978028 +13.575 2 298.531355 0 -15.01820112 -0.7108384785 0 0.5767355503 0.4026373706 0 0.2791456177 +13.600 1 1.486289651 0 -12.88528276 0.7007119324 0 0.5255339493 -0.4074747467 0 -0.30560606 +13.600 2 298.5137103 0 -15.00369591 -0.7007119324 0 0.5836645811 0.4074747467 0 0.2751689324 +13.625 1 1.503679615 0 -12.87224029 0.690465323 0 0.5178489922 -0.412242304 0 -0.309181728 +13.625 2 298.4963204 0 -14.98901872 -0.690465323 0 0.590493604 0.412242304 0 0.2711450983 +13.650 1 1.520811931 0 -12.85939105 0.6801004058 0 0.5100753044 -0.4169392258 0 -0.3127044194 +13.650 2 298.4791881 0 -14.97417207 -0.6801004058 0 0.5972214488 0.4169392258 0 0.2670748048 +13.675 1 1.537683664 0 -12.84673725 0.669618957 0 0.5022142178 -0.4215647072 0 -0.3161735304 +13.675 2 298.4623163 0 -14.9591585 -0.669618957 0 0.6038469629 0.4215647072 0 0.2629587495 +13.700 1 1.554291923 0 -12.83428106 0.6590227724 0 0.4942670793 -0.4261179556 0 -0.3195884667 +13.700 2 298.4457081 0 -14.94398059 -0.6590227724 0 0.6103690108 0.4261179556 0 0.2587976376 +13.725 1 1.570633862 0 -12.8220246 0.6483136677 0 0.4862352508 -0.430598191 0 -0.3229486432 +13.725 2 298.4293661 0 -14.92864092 -0.6483136677 0 0.6167864752 0.430598191 0 0.2545921819 +13.750 1 1.586706681 0 -12.80996999 0.6374934777 0 0.4781201083 -0.4350046455 0 -0.3262534841 +13.750 2 298.4132933 0 -14.91314214 -0.6374934777 0 0.6230982564 0.4350046455 0 0.2503431033 +13.775 1 1.602507625 0 -12.79811928 0.6265640565 0 0.4699230424 -0.4393365642 0 -0.3295024232 +13.775 2 298.3974924 0 -14.8974869 -0.6265640565 0 0.6293032729 0.4393365642 0 0.2460511296 +13.800 1 1.618033989 0 -12.78647451 0.6155272768 0 0.4616454576 -0.4435932049 0 -0.3326949037 +13.800 2 298.381966 0 -14.88167788 -0.6155272768 0 0.6354004615 0.4435932049 0 0.2417169964 +13.825 1 1.63328311 0 -12.77503767 0.6043850297 0 0.4532887723 -0.4477738382 0 -0.3358303786 +13.825 2 298.3667169 0 -14.86571779 -0.6043850297 0 0.6413887776 0.4477738382 0 0.2373414462 +13.850 1 1.648252377 0 -12.76381072 0.5931392243 0 0.4448544182 -0.4518777477 0 -0.3389083108 +13.850 2 298.3517476 0 -14.84960936 -0.5931392243 0 0.647267195 0.4518777477 0 0.2329252287 +13.875 1 1.662939225 0 -12.75279558 0.5817917875 0 0.4363438407 -0.4559042303 0 -0.3419281727 +13.875 2 298.3370608 0 -14.83335535 -0.5817917875 0 0.6530347064 0.4559042303 0 0.2284691007 +13.900 1 1.677341136 0 -12.74199415 0.5703446638 0 0.4277584978 -0.459852596 0 -0.344889447 +13.900 2 298.3226589 0 -14.81695855 -0.5703446638 0 0.6586903238 0.459852596 0 0.2239738257 +13.925 1 1.691455643 0 -12.73140827 0.5587998143 0 0.4190998608 -0.4637221684 0 -0.3477916263 +13.925 2 298.3085444 0 -14.80042177 -0.5587998143 0 0.6642330779 0.4637221684 0 0.2194401739 +13.950 1 1.705280329 0 -12.72103975 0.5471592175 0 0.4103694131 -0.4675122844 0 -0.3506342133 +13.950 2 298.2947197 0 -14.78374785 -0.5471592175 0 0.6696620191 0.4675122844 0 0.2148689222 +13.975 1 1.718812823 0 -12.71089038 0.5354248677 0 0.4015686508 -0.4712222945 0 -0.3534167209 +13.975 2 298.2811872 0 -14.76693963 -0.5354248677 0 0.6749762172 0.4712222945 0 0.2102608539 +14.000 1 1.732050808 0 -12.70096189 0.5235987756 0 0.3926990817 -0.4748515631 0 -0.3561386724 +14.000 2 298.2679492 0 -14.75 -0.5235987756 0 0.6801747616 0.4748515631 0 0.2056167584 +14.025 1 1.744992014 0 -12.69125599 0.5116829676 0 0.3837622257 -0.4783994684 0 -0.3587996013 +14.025 2 298.255008 0 -14.73293186 -0.5116829676 0 0.6852567615 0.4783994684 0 0.2009374315 +14.050 1 1.757634225 0 -12.68177433 0.4996794853 0 0.374759614 -0.4818654024 0 -0.3613990518 +14.050 2 298.2423658 0 -14.71573814 -0.4996794853 0 0.6902213462 0.4818654024 0 0.196223675 +14.075 1 1.769975275 0 -12.67251854 0.4875903855 0 0.3656927891 -0.4852487712 0 -0.3639365784 +14.075 2 298.2300247 0 -14.69842178 -0.4875903855 0 0.6950676651 0.4852487712 0 0.1914762966 +14.100 1 1.782013048 0 -12.66349021 0.4754177396 0 0.3565633047 -0.4885489951 0 -0.3664117464 +14.100 2 298.217987 0 -14.68098575 -0.4754177396 0 0.6997948877 0.4885489951 0 0.1866961098 +14.125 1 1.793745483 0 -12.65469089 0.4631636333 0 0.347372725 -0.4917655087 0 -0.3688241315 +14.125 2 298.2062545 0 -14.66343304 -0.4631636333 0 0.704402204 0.4917655087 0 0.1818839335 +14.150 1 1.805170569 0 -12.64612207 0.4508301663 0 0.3381226248 -0.4948977608 0 -0.3711733206 +14.150 2 298.1948294 0 -14.64576665 -0.4508301663 0 0.7088888246 0.4948977608 0 0.1770405923 +14.175 1 1.816286348 0 -12.63778524 0.4384194519 0 0.328814589 -0.4979452147 0 -0.3734589111 +14.175 2 298.1837137 0 -14.62798961 -0.4384194519 0 0.7132539808 0.4979452147 0 0.1721669162 +14.200 1 1.827090915 0 -12.62968181 0.4259336166 0 0.3194502125 -0.5009073483 0 -0.3756805112 +14.200 2 298.1729091 0 -14.61010496 -0.4259336166 0 0.7174969246 0.5009073483 0 0.1672637401 +14.225 1 1.83758242 0 -12.62181318 0.4133747998 0 0.3100310998 -0.503783654 0 -0.3778377405 +14.225 2 298.1624176 0 -14.59211578 -0.4133747998 0 0.721616929 0.503783654 0 0.1623319043 +14.250 1 1.847759065 0 -12.6141807 0.4007451533 0 0.3005588649 -0.5065736389 0 -0.3799302292 +14.250 2 298.1522409 0 -14.57402515 -0.4007451533 0 0.725613288 0.5065736389 0 0.1573722537 +14.275 1 1.857619106 0 -12.60678567 0.3880468411 0 0.2910351309 -0.509276825 0 -0.3819576188 +14.275 2 298.1423809 0 -14.55583616 -0.3880468411 0 0.729485317 0.509276825 0 0.1523856382 +14.300 1 1.867160853 0 -12.59962936 0.3752820392 0 0.2814615294 -0.5118927492 0 -0.3839195619 +14.300 2 298.1328391 0 -14.53755192 -0.3752820392 0 0.7332323524 0.5118927492 0 0.1473729122 +14.325 1 1.876382672 0 -12.592713 0.3624529346 0 0.2718397009 -0.5144209632 0 -0.3858157224 +14.325 2 298.1236173 0 -14.51917559 -0.3624529346 0 0.7368537521 0.5144209632 0 0.1423349346 +14.350 1 1.885282982 0 -12.58603776 0.3495617256 0 0.2621712942 -0.5168610338 0 -0.3876457754 +14.350 2 298.114717 0 -14.50071029 -0.3495617256 0 0.7403488958 0.5168610338 0 0.1372725686 +14.375 1 1.893860259 0 -12.57960481 0.3366106209 0 0.2524579657 -0.519212543 0 -0.3894094072 +14.375 2 298.1061397 0 -14.4821592 -0.3366106209 0 0.7437171846 0.519212543 0 0.1321866817 +14.400 1 1.902113033 0 -12.57341523 0.3236018398 0 0.2427013798 -0.5214750877 0 -0.3911063158 +14.400 2 298.097887 0 -14.46352549 -0.3236018398 0 0.7469580412 0.5214750877 0 0.1270781453 +14.425 1 1.910039889 0 -12.56747008 0.3105376111 0 0.2329032084 -0.5236482804 0 -0.3927362103 +14.425 2 298.0899601 0 -14.44481236 -0.3105376111 0 0.7500709104 0.5236482804 0 0.1219478347 +14.450 1 1.91763947 0 -12.5617704 0.2974201735 0 0.2230651301 -0.5257317486 0 -0.3942988115 +14.450 2 298.0823605 0 -14.42602302 -0.2974201735 0 0.7530552588 0.5257317486 0 0.116796629 +14.475 1 1.924910473 0 -12.55631715 0.2842517744 0 0.2131888308 -0.5277251354 0 -0.3957938516 +14.475 2 298.0750895 0 -14.40716067 -0.2842517744 0 0.7559105751 0.5277251354 0 0.1116254108 +14.500 1 1.931851653 0 -12.55111126 0.2710346702 0 0.2032760027 -0.5296280992 0 -0.3972210744 +14.500 2 298.0681483 0 -14.38822857 -0.2710346702 0 0.7586363699 0.5296280992 0 0.1064350661 +14.525 1 1.938461819 0 -12.54615364 0.2577711257 0 0.1933283443 -0.531440314 0 -0.3985802355 +14.525 2 298.0615382 0 -14.36922994 -0.2577711257 0 0.7612321764 0.531440314 0 0.1012264843 +14.550 1 1.944739841 0 -12.54144512 0.2444634134 0 0.18334756 -0.5331614692 0 -0.3998711019 +14.550 2 298.0552602 0 -14.35016805 -0.2444634134 0 0.7636975496 0.5331614692 0 0.09600055794 +14.575 1 1.950684641 0 -12.53698652 0.2311138135 0 0.1733353601 -0.5347912699 0 -0.4010934525 +14.575 2 298.0493154 0 -14.33104615 -0.2311138135 0 0.7660320672 0.5347912699 0 0.09075818233 +14.600 1 1.956295201 0 -12.5327786 0.2177246135 0 0.1632934601 -0.536329437 0 -0.4022470777 +14.600 2 298.0437048 0 -14.31186754 -0.2177246135 0 0.7682353291 0.536329437 0 0.08550025578 +14.625 1 1.961570561 0 -12.52882208 0.2042981075 0 0.1532235806 -0.5377757067 0 -0.40333178 +14.625 2 298.0384294 0 -14.29263548 -0.2042981075 0 0.7703069579 0.5377757067 0 0.0802276792 +14.650 1 1.966509815 0 -12.52511764 0.190836596 0 0.143127447 -0.5391298313 0 -0.4043473735 +14.650 2 298.0334902 0 -14.27335329 -0.190836596 0 0.7722465986 0.5391298313 0 0.07494135602 +14.675 1 1.971112118 0 -12.52166591 0.1773423857 0 0.1330067893 -0.5403915788 0 -0.4052936841 +14.675 2 298.0288879 0 -14.25402426 -0.1773423857 0 0.7740539187 0.5403915788 0 0.06964219202 +14.700 1 1.975376681 0 -12.51846749 0.1638177887 0 0.1228633415 -0.541560733 0 -0.4061705497 +14.700 2 298.0246233 0 -14.2346517 -0.1638177887 0 0.7757286087 0.541560733 0 0.06433109519 +14.725 1 1.979302774 0 -12.51552292 0.1502651224 0 0.1126988418 -0.5426370935 0 -0.4069778201 +14.725 2 298.0206972 0 -14.21523893 -0.1502651224 0 0.7772703816 0.5426370935 0 0.05900897556 +14.750 1 1.982889723 0 -12.51283271 0.1366867089 0 0.1025150316 -0.543620476 0 -0.407715357 +14.750 2 298.0171103 0 -14.19578929 -0.1366867089 0 0.7786789732 0.543620476 0 0.05367674505 +14.775 1 1.986136914 0 -12.51039731 0.1230848748 0 0.09231365609 -0.5445107119 0 -0.4083830339 +14.775 2 298.0138631 0 -14.1763061 -0.1230848748 0 0.7799541422 0.5445107119 0 0.0483353173 +14.800 1 1.989043791 0 -12.50821716 0.1094619508 0 0.08209646307 -0.5453076486 0 -0.4089807365 +14.800 2 298.0109562 0 -14.15679269 -0.1094619508 0 0.7810956701 0.5453076486 0 0.04298560755 +14.825 1 1.991609855 0 -12.50629261 0.09582027099 0 0.07186520325 -0.5460111498 0 -0.4095083623 +14.825 2 298.0083901 0 -14.13725243 -0.09582027099 0 0.7821033612 0.5460111498 0 0.03762853243 +14.850 1 1.993834667 0 -12.504624 0.08216217292 0 0.06162162969 -0.5466210947 0 -0.409965821 +14.850 2 298.0061653 0 -14.11768864 -0.08216217292 0 0.782977043 0.5466210947 0 0.03226500985 +14.875 1 1.995717846 0 -12.50321162 0.06848999677 0 0.05136749758 -0.5471373789 0 -0.4103530342 +14.875 2 298.0042822 0 -14.09810469 -0.06848999677 0 0.7837165656 0.5471373789 0 0.02689595884 +14.900 1 1.99725907 0 -12.5020557 0.05480608522 0 0.04110456391 -0.547559914 0 -0.4106699355 +14.900 2 298.0027409 0 -14.07850393 -0.05480608522 0 0.7843218025 0.547559914 0 0.02152229934 +14.925 1 1.998458072 0 -12.50115645 0.04111278292 0 0.03083458719 -0.5478886274 0 -0.4109164706 +14.925 2 298.0015419 0 -14.05888972 -0.04111278292 0 0.7847926499 0.5478886274 0 0.0161449521 +14.950 1 1.99931465 0 -12.50051401 0.02741243617 0 0.02055932712 -0.548123463 0 -0.4110925973 +14.950 2 298.0006854 0 -14.03926542 -0.02741243617 0 0.7851290271 0.548123463 0 0.01076483851 +14.975 1 1.999828655 0 -12.50012851 0.01370739243 0 0.01028054432 -0.5482643805 0 -0.4111982853 +14.975 2 298.0001713 0 -14.01963439 -0.01370739243 0 0.7853308764 0.5482643805 0 0.005382880419 +15.000 1 2 0 -12.5 1.250710048e-15 0 9.380325363e-16 -0.5483113556 0 -0.4112335167 +15.000 2 298 0 -14 -2.309053027e-15 0 0.7853981634 0.5483113556 0 4.65971897e-16 +15.025 1 1.999828655 0 -12.50012851 -0.01370739243 0 -0.01028054432 -0.5482643805 0 -0.4111982853 +15.025 2 298.0001713 0 -13.98036561 0.01370739243 0 0.7853308764 0.5482643805 0 -0.005382880419 +15.050 1 1.99931465 0 -12.50051401 -0.02741243617 0 -0.02055932712 -0.548123463 0 -0.4110925973 +15.050 2 298.0006854 0 -13.96073458 0.02741243617 0 0.7851290271 0.548123463 0 -0.01076483851 +15.075 1 1.998458072 0 -12.50115645 -0.04111278292 0 -0.03083458719 -0.5478886274 0 -0.4109164706 +15.075 2 298.0015419 0 -13.94111028 0.04111278292 0 0.7847926499 0.5478886274 0 -0.0161449521 +15.100 1 1.99725907 0 -12.5020557 -0.05480608522 0 -0.04110456391 -0.547559914 0 -0.4106699355 +15.100 2 298.0027409 0 -13.92149607 0.05480608522 0 0.7843218025 0.547559914 0 -0.02152229934 +15.125 1 1.995717846 0 -12.50321162 -0.06848999677 0 -0.05136749758 -0.5471373789 0 -0.4103530342 +15.125 2 298.0042822 0 -13.90189531 0.06848999677 0 0.7837165656 0.5471373789 0 -0.02689595884 +15.150 1 1.993834667 0 -12.504624 -0.08216217292 0 -0.06162162969 -0.5466210947 0 -0.409965821 +15.150 2 298.0061653 0 -13.88231136 0.08216217292 0 0.782977043 0.5466210947 0 -0.03226500985 +15.175 1 1.991609855 0 -12.50629261 -0.09582027099 0 -0.07186520325 -0.5460111498 0 -0.4095083623 +15.175 2 298.0083901 0 -13.86274757 0.09582027099 0 0.7821033612 0.5460111498 0 -0.03762853243 +15.200 1 1.989043791 0 -12.50821716 -0.1094619508 0 -0.08209646307 -0.5453076486 0 -0.4089807365 +15.200 2 298.0109562 0 -13.84320731 0.1094619508 0 0.7810956701 0.5453076486 0 -0.04298560755 +15.225 1 1.986136914 0 -12.51039731 -0.1230848748 0 -0.09231365609 -0.5445107119 0 -0.4083830339 +15.225 2 298.0138631 0 -13.8236939 0.1230848748 0 0.7799541422 0.5445107119 0 -0.0483353173 +15.250 1 1.982889723 0 -12.51283271 -0.1366867089 0 -0.1025150316 -0.543620476 0 -0.407715357 +15.250 2 298.0171103 0 -13.80421071 0.1366867089 0 0.7786789732 0.543620476 0 -0.05367674505 +15.275 1 1.979302774 0 -12.51552292 -0.1502651224 0 -0.1126988418 -0.5426370935 0 -0.4069778201 +15.275 2 298.0206972 0 -13.78476107 0.1502651224 0 0.7772703816 0.5426370935 0 -0.05900897556 +15.300 1 1.975376681 0 -12.51846749 -0.1638177887 0 -0.1228633415 -0.541560733 0 -0.4061705497 +15.300 2 298.0246233 0 -13.7653483 0.1638177887 0 0.7757286087 0.541560733 0 -0.06433109519 +15.325 1 1.971112118 0 -12.52166591 -0.1773423857 0 -0.1330067893 -0.5403915788 0 -0.4052936841 +15.325 2 298.0288879 0 -13.74597574 0.1773423857 0 0.7740539187 0.5403915788 0 -0.06964219202 +15.350 1 1.966509815 0 -12.52511764 -0.190836596 0 -0.143127447 -0.5391298313 0 -0.4043473735 +15.350 2 298.0334902 0 -13.72664671 0.190836596 0 0.7722465986 0.5391298313 0 -0.07494135602 +15.375 1 1.961570561 0 -12.52882208 -0.2042981075 0 -0.1532235806 -0.5377757067 0 -0.40333178 +15.375 2 298.0384294 0 -13.70736452 0.2042981075 0 0.7703069579 0.5377757067 0 -0.0802276792 +15.400 1 1.956295201 0 -12.5327786 -0.2177246135 0 -0.1632934601 -0.536329437 0 -0.4022470777 +15.400 2 298.0437048 0 -13.68813246 0.2177246135 0 0.7682353291 0.536329437 0 -0.08550025578 +15.425 1 1.950684641 0 -12.53698652 -0.2311138135 0 -0.1733353601 -0.5347912699 0 -0.4010934525 +15.425 2 298.0493154 0 -13.66895385 0.2311138135 0 0.7660320672 0.5347912699 0 -0.09075818233 +15.450 1 1.944739841 0 -12.54144512 -0.2444634134 0 -0.18334756 -0.5331614692 0 -0.3998711019 +15.450 2 298.0552602 0 -13.64983195 0.2444634134 0 0.7636975496 0.5331614692 0 -0.09600055794 +15.475 1 1.938461819 0 -12.54615364 -0.2577711257 0 -0.1933283443 -0.531440314 0 -0.3985802355 +15.475 2 298.0615382 0 -13.63077006 0.2577711257 0 0.7612321764 0.531440314 0 -0.1012264843 +15.500 1 1.931851653 0 -12.55111126 -0.2710346702 0 -0.2032760027 -0.5296280992 0 -0.3972210744 +15.500 2 298.0681483 0 -13.61177143 0.2710346702 0 0.7586363699 0.5296280992 0 -0.1064350661 +15.525 1 1.924910473 0 -12.55631715 -0.2842517744 0 -0.2131888308 -0.5277251354 0 -0.3957938516 +15.525 2 298.0750895 0 -13.59283933 0.2842517744 0 0.7559105751 0.5277251354 0 -0.1116254108 +15.550 1 1.91763947 0 -12.5617704 -0.2974201735 0 -0.2230651301 -0.5257317486 0 -0.3942988115 +15.550 2 298.0823605 0 -13.57397698 0.2974201735 0 0.7530552588 0.5257317486 0 -0.116796629 +15.575 1 1.910039889 0 -12.56747008 -0.3105376111 0 -0.2329032084 -0.5236482804 0 -0.3927362103 +15.575 2 298.0899601 0 -13.55518764 0.3105376111 0 0.7500709104 0.5236482804 0 -0.1219478347 +15.600 1 1.902113033 0 -12.57341523 -0.3236018398 0 -0.2427013798 -0.5214750877 0 -0.3911063158 +15.600 2 298.097887 0 -13.53647451 0.3236018398 0 0.7469580412 0.5214750877 0 -0.1270781453 +15.625 1 1.893860259 0 -12.57960481 -0.3366106209 0 -0.2524579657 -0.519212543 0 -0.3894094072 +15.625 2 298.1061397 0 -13.5178408 0.3366106209 0 0.7437171846 0.519212543 0 -0.1321866817 +15.650 1 1.885282982 0 -12.58603776 -0.3495617256 0 -0.2621712942 -0.5168610338 0 -0.3876457754 +15.650 2 298.114717 0 -13.49928971 0.3495617256 0 0.7403488958 0.5168610338 0 -0.1372725686 +15.675 1 1.876382672 0 -12.592713 -0.3624529346 0 -0.2718397009 -0.5144209632 0 -0.3858157224 +15.675 2 298.1236173 0 -13.48082441 0.3624529346 0 0.7368537521 0.5144209632 0 -0.1423349346 +15.700 1 1.867160853 0 -12.59962936 -0.3752820392 0 -0.2814615294 -0.5118927492 0 -0.3839195619 +15.700 2 298.1328391 0 -13.46244808 0.3752820392 0 0.7332323524 0.5118927492 0 -0.1473729122 +15.725 1 1.857619106 0 -12.60678567 -0.3880468411 0 -0.2910351309 -0.509276825 0 -0.3819576188 +15.725 2 298.1423809 0 -13.44416384 0.3880468411 0 0.729485317 0.509276825 0 -0.1523856382 +15.750 1 1.847759065 0 -12.6141807 -0.4007451533 0 -0.3005588649 -0.5065736389 0 -0.3799302292 +15.750 2 298.1522409 0 -13.42597485 0.4007451533 0 0.725613288 0.5065736389 0 -0.1573722537 +15.775 1 1.83758242 0 -12.62181318 -0.4133747998 0 -0.3100310998 -0.503783654 0 -0.3778377405 +15.775 2 298.1624176 0 -13.40788422 0.4133747998 0 0.721616929 0.503783654 0 -0.1623319043 +15.800 1 1.827090915 0 -12.62968181 -0.4259336166 0 -0.3194502125 -0.5009073483 0 -0.3756805112 +15.800 2 298.1729091 0 -13.38989504 0.4259336166 0 0.7174969246 0.5009073483 0 -0.1672637401 +15.825 1 1.816286348 0 -12.63778524 -0.4384194519 0 -0.328814589 -0.4979452147 0 -0.3734589111 +15.825 2 298.1837137 0 -13.37201039 0.4384194519 0 0.7132539808 0.4979452147 0 -0.1721669162 +15.850 1 1.805170569 0 -12.64612207 -0.4508301663 0 -0.3381226248 -0.4948977608 0 -0.3711733206 +15.850 2 298.1948294 0 -13.35423335 0.4508301663 0 0.7088888246 0.4948977608 0 -0.1770405923 +15.875 1 1.793745483 0 -12.65469089 -0.4631636333 0 -0.347372725 -0.4917655087 0 -0.3688241315 +15.875 2 298.2062545 0 -13.33656696 0.4631636333 0 0.704402204 0.4917655087 0 -0.1818839335 +15.900 1 1.782013048 0 -12.66349021 -0.4754177396 0 -0.3565633047 -0.4885489951 0 -0.3664117464 +15.900 2 298.217987 0 -13.31901425 0.4754177396 0 0.6997948877 0.4885489951 0 -0.1866961098 +15.925 1 1.769975275 0 -12.67251854 -0.4875903855 0 -0.3656927891 -0.4852487712 0 -0.3639365784 +15.925 2 298.2300247 0 -13.30157822 0.4875903855 0 0.6950676651 0.4852487712 0 -0.1914762966 +15.950 1 1.757634225 0 -12.68177433 -0.4996794853 0 -0.374759614 -0.4818654024 0 -0.3613990518 +15.950 2 298.2423658 0 -13.28426186 0.4996794853 0 0.6902213462 0.4818654024 0 -0.196223675 +15.975 1 1.744992014 0 -12.69125599 -0.5116829676 0 -0.3837622257 -0.4783994684 0 -0.3587996013 +15.975 2 298.255008 0 -13.26706814 0.5116829676 0 0.6852567615 0.4783994684 0 -0.2009374315 +16.000 1 1.732050808 0 -12.70096189 -0.5235987756 0 -0.3926990817 -0.4748515631 0 -0.3561386724 +16.000 2 298.2679492 0 -13.25 0.5235987756 0 0.6801747616 0.4748515631 0 -0.2056167584 +16.025 1 1.718812823 0 -12.71089038 -0.5354248677 0 -0.4015686508 -0.4712222945 0 -0.3534167209 +16.025 2 298.2811872 0 -13.23306037 0.5354248677 0 0.6749762172 0.4712222945 0 -0.2102608539 +16.050 1 1.705280329 0 -12.72103975 -0.5471592175 0 -0.4103694131 -0.4675122844 0 -0.3506342133 +16.050 2 298.2947197 0 -13.21625215 0.5471592175 0 0.6696620191 0.4675122844 0 -0.2148689222 +16.075 1 1.691455643 0 -12.73140827 -0.5587998143 0 -0.4190998608 -0.4637221684 0 -0.3477916263 +16.075 2 298.3085444 0 -13.19957823 0.5587998143 0 0.6642330779 0.4637221684 0 -0.2194401739 +16.100 1 1.677341136 0 -12.74199415 -0.5703446638 0 -0.4277584978 -0.459852596 0 -0.344889447 +16.100 2 298.3226589 0 -13.18304145 0.5703446638 0 0.6586903238 0.459852596 0 -0.2239738257 +16.125 1 1.662939225 0 -12.75279558 -0.5817917875 0 -0.4363438407 -0.4559042303 0 -0.3419281727 +16.125 2 298.3370608 0 -13.16664465 0.5817917875 0 0.6530347064 0.4559042303 0 -0.2284691007 +16.150 1 1.648252377 0 -12.76381072 -0.5931392243 0 -0.4448544182 -0.4518777477 0 -0.3389083108 +16.150 2 298.3517476 0 -13.15039064 0.5931392243 0 0.647267195 0.4518777477 0 -0.2329252287 +16.175 1 1.63328311 0 -12.77503767 -0.6043850297 0 -0.4532887723 -0.4477738382 0 -0.3358303786 +16.175 2 298.3667169 0 -13.13428221 0.6043850297 0 0.6413887776 0.4477738382 0 -0.2373414462 +16.200 1 1.618033989 0 -12.78647451 -0.6155272768 0 -0.4616454576 -0.4435932049 0 -0.3326949037 +16.200 2 298.381966 0 -13.11832212 0.6155272768 0 0.6354004615 0.4435932049 0 -0.2417169964 +16.225 1 1.602507625 0 -12.79811928 -0.6265640565 0 -0.4699230424 -0.4393365642 0 -0.3295024232 +16.225 2 298.3974924 0 -13.1025131 0.6265640565 0 0.6293032729 0.4393365642 0 -0.2460511296 +16.250 1 1.586706681 0 -12.80996999 -0.6374934777 0 -0.4781201083 -0.4350046455 0 -0.3262534841 +16.250 2 298.4132933 0 -13.08685786 0.6374934777 0 0.6230982564 0.4350046455 0 -0.2503431033 +16.275 1 1.570633862 0 -12.8220246 -0.6483136677 0 -0.4862352508 -0.430598191 0 -0.3229486432 +16.275 2 298.4293661 0 -13.07135908 0.6483136677 0 0.6167864752 0.430598191 0 -0.2545921819 +16.300 1 1.554291923 0 -12.83428106 -0.6590227724 0 -0.4942670793 -0.4261179556 0 -0.3195884667 +16.300 2 298.4457081 0 -13.05601941 0.6590227724 0 0.6103690108 0.4261179556 0 -0.2587976376 +16.325 1 1.537683664 0 -12.84673725 -0.669618957 0 -0.5022142178 -0.4215647072 0 -0.3161735304 +16.325 2 298.4623163 0 -13.0408415 0.669618957 0 0.6038469629 0.4215647072 0 -0.2629587495 +16.350 1 1.520811931 0 -12.85939105 -0.6801004058 0 -0.5100753044 -0.4169392258 0 -0.3127044194 +16.350 2 298.4791881 0 -13.02582793 0.6801004058 0 0.5972214488 0.4169392258 0 -0.2670748048 +16.375 1 1.503679615 0 -12.87224029 -0.690465323 0 -0.5178489922 -0.412242304 0 -0.309181728 +16.375 2 298.4963204 0 -13.01098128 0.690465323 0 0.590493604 0.412242304 0 -0.2711450983 +16.400 1 1.486289651 0 -12.88528276 -0.7007119324 0 -0.5255339493 -0.4074747467 0 -0.30560606 +16.400 2 298.5137103 0 -12.99630409 0.7007119324 0 0.5836645811 0.4074747467 0 -0.2751689324 +16.425 1 1.468645019 0 -12.89851624 -0.7108384785 0 -0.5331288589 -0.4026373706 0 -0.301978028 +16.425 2 298.531355 0 -12.98179888 0.7108384785 0 0.5767355503 0.4026373706 0 -0.2791456177 +16.450 1 1.450748742 0 -12.91193844 -0.720843226 0 -0.5406324195 -0.3977310047 0 -0.2982982535 +16.450 2 298.5492513 0 -12.96746814 0.720843226 0 0.5697076988 0.3977310047 0 -0.2830744729 +16.475 1 1.432603887 0 -12.92554708 -0.7307244608 0 -0.5480433456 -0.3927564896 0 -0.2945673672 +16.475 2 298.5673961 0 -12.95331431 0.7307244608 0 0.5625822308 0.3927564896 0 -0.2869548247 +16.500 1 1.414213562 0 -12.93933983 -0.7404804897 0 -0.5553603673 -0.3877146778 0 -0.2907860083 +16.500 2 298.5857864 0 -12.93933983 0.7404804897 0 0.5553603673 0.3877146778 0 -0.2907860083 +16.525 1 1.39558092 0 -12.95331431 -0.7501096411 0 -0.5625822308 -0.382606433 0 -0.2869548247 +16.525 2 298.6044191 0 -12.92554708 0.7501096411 0 0.5480433456 0.382606433 0 -0.2945673672 +16.550 1 1.376709151 0 -12.96746814 -0.759610265 0 -0.5697076988 -0.3774326305 0 -0.2830744729 +16.550 2 298.6232908 0 -12.91193844 0.759610265 0 0.5406324195 0.3774326305 0 -0.2982982535 +16.575 1 1.357601491 0 -12.98179888 -0.7689807337 0 -0.5767355503 -0.372194157 0 -0.2791456177 +16.575 2 298.6423985 0 -12.89851624 0.7689807337 0 0.5331288589 0.372194157 0 -0.301978028 +16.600 1 1.338261213 0 -12.99630409 -0.7782194414 0 -0.5836645811 -0.3668919099 0 -0.2751689324 +16.600 2 298.6617388 0 -12.88528276 0.7782194414 0 0.5255339493 0.3668919099 0 -0.30560606 +16.625 1 1.31869163 0 -13.01098128 -0.7873248053 0 -0.590493604 -0.3615267977 0 -0.2711450983 +16.625 2 298.6813084 0 -12.87224029 0.7873248053 0 0.5178489922 0.3615267977 0 -0.309181728 +16.650 1 1.298896097 0 -13.02582793 -0.7962952651 0 -0.5972214488 -0.3560997398 0 -0.2670748048 +16.650 2 298.7011039 0 -12.85939105 0.7962952651 0 0.5100753044 0.3560997398 0 -0.3127044194 +16.675 1 1.278878004 0 -13.0408415 -0.8051292838 0 -0.6038469629 -0.350611666 0 -0.2629587495 +16.675 2 298.721122 0 -12.84673725 0.8051292838 0 0.5022142178 0.350611666 0 -0.3161735304 +16.700 1 1.258640782 0 -13.05601941 -0.8138253478 0 -0.6103690108 -0.3450635167 0 -0.2587976376 +16.700 2 298.7413592 0 -12.83428106 0.8138253478 0 0.4942670793 0.3450635167 0 -0.3195884667 +16.725 1 1.238187899 0 -13.07135908 -0.8223819669 0 -0.6167864752 -0.3394562426 0 -0.2545921819 +16.725 2 298.7618121 0 -12.8220246 0.8223819669 0 0.4862352508 0.3394562426 0 -0.3229486432 +16.750 1 1.217522858 0 -13.08685786 -0.8307976752 0 -0.6230982564 -0.3337908044 0 -0.2503431033 +16.750 2 298.7824771 0 -12.80996999 0.8307976752 0 0.4781201083 0.3337908044 0 -0.3262534841 +16.775 1 1.196649201 0 -13.1025131 -0.8390710305 0 -0.6293032729 -0.3280681728 0 -0.2460511296 +16.775 2 298.8033508 0 -12.79811928 0.8390710305 0 0.4699230424 0.3280681728 0 -0.3295024232 +16.800 1 1.175570505 0 -13.11832212 -0.8472006154 0 -0.6354004615 -0.3222893285 0 -0.2417169964 +16.800 2 298.8244295 0 -12.78647451 0.8472006154 0 0.4616454576 0.3222893285 0 -0.3326949037 +16.825 1 1.15429038 0 -13.13428221 -0.8551850368 0 -0.6413887776 -0.3164552615 0 -0.2373414462 +16.825 2 298.8457096 0 -12.77503767 0.8551850368 0 0.4532887723 0.3164552615 0 -0.3358303786 +16.850 1 1.132812474 0 -13.15039064 -0.8630229266 0 -0.647267195 -0.3105669716 0 -0.2329252287 +16.850 2 298.8671875 0 -12.76381072 0.8630229266 0 0.4448544182 0.3105669716 0 -0.3389083108 +16.875 1 1.111140466 0 -13.16664465 -0.8707129419 0 -0.6530347064 -0.3046254676 0 -0.2284691007 +16.875 2 298.8888595 0 -12.75279558 0.8707129419 0 0.4363438407 0.3046254676 0 -0.3419281727 +16.900 1 1.08927807 0 -13.18304145 -0.878253765 0 -0.6586903238 -0.2986317676 0 -0.2239738257 +16.900 2 298.9107219 0 -12.74199415 0.878253765 0 0.4277584978 0.2986317676 0 -0.344889447 +16.925 1 1.067229032 0 -13.19957823 -0.8856441039 0 -0.6642330779 -0.2925868986 0 -0.2194401739 +16.925 2 298.932771 0 -12.73140827 0.8856441039 0 0.4190998608 0.2925868986 0 -0.3477916263 +16.950 1 1.044997129 0 -13.21625215 -0.8928826922 0 -0.6696620191 -0.2864918963 0 -0.2148689222 +16.950 2 298.9550029 0 -12.72103975 0.8928826922 0 0.4103694131 0.2864918963 0 -0.3506342133 +16.975 1 1.022586172 0 -13.23306037 -0.8999682896 0 -0.6749762172 -0.2803478051 0 -0.2102608539 +16.975 2 298.9774138 0 -12.71089038 0.8999682896 0 0.4015686508 0.2803478051 0 -0.3534167209 +17.000 1 1 0 -13.25 -0.9068996821 0 -0.6801747616 -0.2741556778 0 -0.2056167584 +17.000 2 299 0 -12.70096189 0.9068996821 0 0.3926990817 0.2741556778 0 -0.3561386724 +17.025 1 0.977242483 0 -13.26706814 -0.913675682 0 -0.6852567615 -0.2679165753 0 -0.2009374315 +17.025 2 299.0227575 0 -12.69125599 0.913675682 0 0.3837622257 0.2679165753 0 -0.3587996013 +17.050 1 0.9543175205 0 -13.28426186 -0.9202951283 0 -0.6902213462 -0.2616315667 0 -0.196223675 +17.050 2 299.0456825 0 -12.68177433 0.9202951283 0 0.374759614 0.2616315667 0 -0.3613990518 +17.075 1 0.9312290407 0 -13.30157822 -0.9267568868 0 -0.6950676651 -0.2553017288 0 -0.1914762966 +17.075 2 299.068771 0 -12.67251854 0.9267568868 0 0.3656927891 0.2553017288 0 -0.3639365784 +17.100 1 0.9079809995 0 -13.31901425 -0.9330598502 0 -0.6997948877 -0.2489281463 0 -0.1866961098 +17.100 2 299.092019 0 -12.66349021 0.9330598502 0 0.3565633047 0.2489281463 0 -0.3664117464 +17.125 1 0.8845773804 0 -13.33656696 -0.9392029387 0 -0.704402204 -0.2425119113 0 -0.1818839335 +17.125 2 299.1154226 0 -12.65469089 0.9392029387 0 0.347372725 0.2425119113 0 -0.3688241315 +17.150 1 0.8610221936 0 -13.35423335 -0.9451850995 0 -0.7088888246 -0.2360541231 0 -0.1770405923 +17.150 2 299.1389778 0 -12.64612207 0.9451850995 0 0.3381226248 0.2360541231 0 -0.3711733206 +17.175 1 0.8373194751 0 -13.37201039 -0.9510053078 0 -0.7132539808 -0.2295558882 0 -0.1721669162 +17.175 2 299.1626805 0 -12.63778524 0.9510053078 0 0.328814589 0.2295558882 0 -0.3734589111 +17.200 1 0.8134732862 0 -13.38989504 -0.9566625662 0 -0.7174969246 -0.2230183201 0 -0.1672637401 +17.200 2 299.1865267 0 -12.62968181 0.9566625662 0 0.3194502125 0.2230183201 0 -0.3756805112 +17.225 1 0.7894877128 0 -13.40788422 -0.9621559053 0 -0.721616929 -0.216442539 0 -0.1623319043 +17.225 2 299.2105123 0 -12.62181318 0.9621559053 0 0.3100310998 0.216442539 0 -0.3778377405 +17.250 1 0.7653668647 0 -13.42597485 -0.967484384 0 -0.725613288 -0.2098296716 0 -0.1573722537 +17.250 2 299.2346331 0 -12.6141807 0.967484384 0 0.3005588649 0.2098296716 0 -0.3799302292 +17.275 1 0.741114875 0 -13.44416384 -0.9726470893 0 -0.729485317 -0.2031808509 0 -0.1523856382 +17.275 2 299.2588851 0 -12.60678567 0.9726470893 0 0.2910351309 0.2031808509 0 -0.3819576188 +17.300 1 0.7167358991 0 -13.46244808 -0.9776431365 0 -0.7332323524 -0.1964972162 0 -0.1473729122 +17.300 2 299.2832641 0 -12.59962936 0.9776431365 0 0.2814615294 0.1964972162 0 -0.3839195619 +17.325 1 0.6922341142 0 -13.48082441 -0.9824716695 0 -0.7368537521 -0.1897799128 0 -0.1423349346 +17.325 2 299.3077659 0 -12.592713 0.9824716695 0 0.2718397009 0.1897799128 0 -0.3858157224 +17.350 1 0.6676137185 0 -13.49928971 -0.9871318611 0 -0.7403488958 -0.1830300915 0 -0.1372725686 +17.350 2 299.3323863 0 -12.58603776 0.9871318611 0 0.2621712942 0.1830300915 0 -0.3876457754 +17.375 1 0.6428789306 0 -13.5178408 -0.9916229128 0 -0.7437171846 -0.176248909 0 -0.1321866817 +17.375 2 299.3571211 0 -12.57960481 0.9916229128 0 0.2524579657 0.176248909 0 -0.3894094072 +17.400 1 0.6180339887 0 -13.53647451 -0.9959440549 0 -0.7469580412 -0.1694375271 0 -0.1270781453 +17.400 2 299.381966 0 -12.57341523 0.9959440549 0 0.2427013798 0.1694375271 0 -0.3911063158 +17.425 1 0.59308315 0 -13.55518764 -1.000094547 0 -0.7500709104 -0.162597113 0 -0.1219478347 +17.425 2 299.4069169 0 -12.56747008 1.000094547 0 0.2329032084 0.162597113 0 -0.3927362103 +17.450 1 0.5680306894 0 -13.57397698 -1.004073678 0 -0.7530552588 -0.1557288387 0 -0.116796629 +17.450 2 299.4319693 0 -12.5617704 1.004073678 0 0.2230651301 0.1557288387 0 -0.3942988115 +17.475 1 0.5428808997 0 -13.59283933 -1.007880767 0 -0.7559105751 -0.148833881 0 -0.1116254108 +17.475 2 299.4571191 0 -12.55631715 1.007880767 0 0.2131888308 0.148833881 0 -0.3957938516 +17.500 1 0.5176380902 0 -13.61177143 -1.01151516 0 -0.7586363699 -0.1419134215 0 -0.1064350661 +17.500 2 299.4823619 0 -12.55111126 1.01151516 0 0.2032760027 0.1419134215 0 -0.3972210744 +17.525 1 0.4923065861 0 -13.63077006 -1.014976235 0 -0.7612321764 -0.1349686458 0 -0.1012264843 +17.525 2 299.5076934 0 -12.54615364 1.014976235 0 0.1933283443 0.1349686458 0 -0.3985802355 +17.550 1 0.4668907277 0 -13.64983195 -1.018263399 0 -0.7636975496 -0.1280007439 0 -0.09600055794 +17.550 2 299.5331093 0 -12.54144512 1.018263399 0 0.18334756 0.1280007439 0 -0.3998711019 +17.575 1 0.44139487 0 -13.66895385 -1.02137609 0 -0.7660320672 -0.1210109098 0 -0.09075818233 +17.575 2 299.5586051 0 -12.53698652 1.02137609 0 0.1733353601 0.1210109098 0 -0.4010934525 +17.600 1 0.4158233816 0 -13.68813246 -1.024313772 0 -0.7682353291 -0.114000341 0 -0.08550025578 +17.600 2 299.5841766 0 -12.5327786 1.024313772 0 0.1632934601 0.114000341 0 -0.4022470777 +17.625 1 0.390180644 0 -13.70736452 -1.027075944 0 -0.7703069579 -0.1069702389 0 -0.0802276792 +17.625 2 299.6098194 0 -12.52882208 1.027075944 0 0.1532235806 0.1069702389 0 -0.40333178 +17.650 1 0.364471051 0 -13.72664671 -1.029662131 0 -0.7722465986 -0.09992180802 0 -0.07494135602 +17.650 2 299.6355289 0 -12.52511764 1.029662131 0 0.143127447 0.09992180802 0 -0.4043473735 +17.675 1 0.3386990077 0 -13.74597574 -1.032071892 0 -0.7740539187 -0.09285625603 0 -0.06964219202 +17.675 2 299.661301 0 -12.52166591 1.032071892 0 0.1330067893 0.09285625603 0 -0.4052936841 +17.700 1 0.3128689301 0 -13.7653483 -1.034304812 0 -0.7757286087 -0.08577479359 0 -0.06433109519 +17.700 2 299.6871311 0 -12.51846749 1.034304812 0 0.1228633415 0.08577479359 0 -0.4061705497 +17.725 1 0.286985244 0 -13.78476107 -1.036360509 0 -0.7772703816 -0.07867863408 0 -0.05900897556 +17.725 2 299.7130148 0 -12.51552292 1.036360509 0 0.1126988418 0.07867863408 0 -0.4069778201 +17.750 1 0.2610523844 0 -13.80421071 -1.038238631 0 -0.7786789732 -0.0715689934 0 -0.05367674505 +17.750 2 299.7389476 0 -12.51283271 1.038238631 0 0.1025150316 0.0715689934 0 -0.407715357 +17.775 1 0.2350747949 0 -13.8236939 -1.039938856 0 -0.7799541422 -0.06444708974 0 -0.0483353173 +17.775 2 299.7649252 0 -12.51039731 1.039938856 0 0.09231365609 0.06444708974 0 -0.4083830339 +17.800 1 0.2090569265 0 -13.84320731 -1.041460893 0 -0.7810956701 -0.05731414339 0 -0.04298560755 +17.800 2 299.7909431 0 -12.50821716 1.041460893 0 0.08209646307 0.05731414339 0 -0.4089807365 +17.825 1 0.1830032373 0 -13.86274757 -1.042804482 0 -0.7821033612 -0.05017137657 0 -0.03762853243 +17.825 2 299.8169968 0 -12.50629261 1.042804482 0 0.07186520325 0.05017137657 0 -0.4095083623 +17.850 1 0.1569181915 0 -13.88231136 -1.043969391 0 -0.782977043 -0.04302001314 0 -0.03226500985 +17.850 2 299.8430818 0 -12.504624 1.043969391 0 0.06162162969 0.04302001314 0 -0.409965821 +17.875 1 0.1308062585 0 -13.90189531 -1.044955421 0 -0.7837165656 -0.03586127845 0 -0.02689595884 +17.875 2 299.8691937 0 -12.50321162 1.044955421 0 0.05136749758 0.03586127845 0 -0.4103530342 +17.900 1 0.1046719125 0 -13.92149607 -1.045762403 0 -0.7843218025 -0.02869639912 0 -0.02152229934 +17.900 2 299.8953281 0 -12.5020557 1.045762403 0 0.04110456391 0.02869639912 0 -0.4106699355 +17.925 1 0.07851963152 0 -13.94111028 -1.0463902 0 -0.7847926499 -0.0215266028 0 -0.0161449521 +17.925 2 299.9214804 0 -12.50115645 1.0463902 0 0.03083458719 0.0215266028 0 -0.4109164706 +17.950 1 0.05235389662 0 -13.96073458 -1.046838703 0 -0.7851290271 -0.01435311801 0 -0.01076483851 +17.950 2 299.9476461 0 -12.50051401 1.046838703 0 0.02055932712 0.01435311801 0 -0.4110925973 +17.975 1 0.02617919114 0 -13.98036561 -1.047107835 0 -0.7853308764 -0.007177173892 0 -0.005382880419 +17.975 2 299.9738208 0 -12.50012851 1.047107835 0 0.01028054432 0.007177173892 0 -0.4111982853 +18.000 1 7.347880795e-16 0 -14 -1.047197551 0 -0.7853981634 -2.01446324e-16 0 -1.51084743e-16 +18.000 2 300 0 -12.5 1.047197551 0 2.404588367e-16 2.685950986e-16 0 -0.4112335167 +18.025 1 -0.02617919114 0 -14.01963439 -1.047107835 0 -0.7853308764 0.007177173892 0 0.005382880419 +18.025 2 300.0261792 0 -12.50012851 1.047107835 0 -0.01028054432 -0.007177173892 0 -0.4111982853 +18.050 1 -0.05235389662 0 -14.03926542 -1.046838703 0 -0.7851290271 0.01435311801 0 0.01076483851 +18.050 2 300.0523539 0 -12.50051401 1.046838703 0 -0.02055932712 -0.01435311801 0 -0.4110925973 +18.075 1 -0.07851963152 0 -14.05888972 -1.0463902 0 -0.7847926499 0.0215266028 0 0.0161449521 +18.075 2 300.0785196 0 -12.50115645 1.0463902 0 -0.03083458719 -0.0215266028 0 -0.4109164706 +18.100 1 -0.1046719125 0 -14.07850393 -1.045762403 0 -0.7843218025 0.02869639912 0 0.02152229934 +18.100 2 300.1046719 0 -12.5020557 1.045762403 0 -0.04110456391 -0.02869639912 0 -0.4106699355 +18.125 1 -0.1308062585 0 -14.09810469 -1.044955421 0 -0.7837165656 0.03586127845 0 0.02689595884 +18.125 2 300.1308063 0 -12.50321162 1.044955421 0 -0.05136749758 -0.03586127845 0 -0.4103530342 +18.150 1 -0.1569181915 0 -14.11768864 -1.043969391 0 -0.782977043 0.04302001314 0 0.03226500985 +18.150 2 300.1569182 0 -12.504624 1.043969391 0 -0.06162162969 -0.04302001314 0 -0.409965821 +18.175 1 -0.1830032373 0 -14.13725243 -1.042804482 0 -0.7821033612 0.05017137657 0 0.03762853243 +18.175 2 300.1830032 0 -12.50629261 1.042804482 0 -0.07186520325 -0.05017137657 0 -0.4095083623 +18.200 1 -0.2090569265 0 -14.15679269 -1.041460893 0 -0.7810956701 0.05731414339 0 0.04298560755 +18.200 2 300.2090569 0 -12.50821716 1.041460893 0 -0.08209646307 -0.05731414339 0 -0.4089807365 +18.225 1 -0.2350747949 0 -14.1763061 -1.039938856 0 -0.7799541422 0.06444708974 0 0.0483353173 +18.225 2 300.2350748 0 -12.51039731 1.039938856 0 -0.09231365609 -0.06444708974 0 -0.4083830339 +18.250 1 -0.2610523844 0 -14.19578929 -1.038238631 0 -0.7786789732 0.0715689934 0 0.05367674505 +18.250 2 300.2610524 0 -12.51283271 1.038238631 0 -0.1025150316 -0.0715689934 0 -0.407715357 +18.275 1 -0.286985244 0 -14.21523893 -1.036360509 0 -0.7772703816 0.07867863408 0 0.05900897556 +18.275 2 300.2869852 0 -12.51552292 1.036360509 0 -0.1126988418 -0.07867863408 0 -0.4069778201 +18.300 1 -0.3128689301 0 -14.2346517 -1.034304812 0 -0.7757286087 0.08577479359 0 0.06433109519 +18.300 2 300.3128689 0 -12.51846749 1.034304812 0 -0.1228633415 -0.08577479359 0 -0.4061705497 +18.325 1 -0.3386990077 0 -14.25402426 -1.032071892 0 -0.7740539187 0.09285625603 0 0.06964219202 +18.325 2 300.338699 0 -12.52166591 1.032071892 0 -0.1330067893 -0.09285625603 0 -0.4052936841 +18.350 1 -0.364471051 0 -14.27335329 -1.029662131 0 -0.7722465986 0.09992180802 0 0.07494135602 +18.350 2 300.3644711 0 -12.52511764 1.029662131 0 -0.143127447 -0.09992180802 0 -0.4043473735 +18.375 1 -0.390180644 0 -14.29263548 -1.027075944 0 -0.7703069579 0.1069702389 0 0.0802276792 +18.375 2 300.3901806 0 -12.52882208 1.027075944 0 -0.1532235806 -0.1069702389 0 -0.40333178 +18.400 1 -0.4158233816 0 -14.31186754 -1.024313772 0 -0.7682353291 0.114000341 0 0.08550025578 +18.400 2 300.4158234 0 -12.5327786 1.024313772 0 -0.1632934601 -0.114000341 0 -0.4022470777 +18.425 1 -0.44139487 0 -14.33104615 -1.02137609 0 -0.7660320672 0.1210109098 0 0.09075818233 +18.425 2 300.4413949 0 -12.53698652 1.02137609 0 -0.1733353601 -0.1210109098 0 -0.4010934525 +18.450 1 -0.4668907277 0 -14.35016805 -1.018263399 0 -0.7636975496 0.1280007439 0 0.09600055794 +18.450 2 300.4668907 0 -12.54144512 1.018263399 0 -0.18334756 -0.1280007439 0 -0.3998711019 +18.475 1 -0.4923065861 0 -14.36922994 -1.014976235 0 -0.7612321764 0.1349686458 0 0.1012264843 +18.475 2 300.4923066 0 -12.54615364 1.014976235 0 -0.1933283443 -0.1349686458 0 -0.3985802355 +18.500 1 -0.5176380902 0 -14.38822857 -1.01151516 0 -0.7586363699 0.1419134215 0 0.1064350661 +18.500 2 300.5176381 0 -12.55111126 1.01151516 0 -0.2032760027 -0.1419134215 0 -0.3972210744 +18.525 1 -0.5428808997 0 -14.40716067 -1.007880767 0 -0.7559105751 0.148833881 0 0.1116254108 +18.525 2 300.5428809 0 -12.55631715 1.007880767 0 -0.2131888308 -0.148833881 0 -0.3957938516 +18.550 1 -0.5680306894 0 -14.42602302 -1.004073678 0 -0.7530552588 0.1557288387 0 0.116796629 +18.550 2 300.5680307 0 -12.5617704 1.004073678 0 -0.2230651301 -0.1557288387 0 -0.3942988115 +18.575 1 -0.59308315 0 -14.44481236 -1.000094547 0 -0.7500709104 0.162597113 0 0.1219478347 +18.575 2 300.5930831 0 -12.56747008 1.000094547 0 -0.2329032084 -0.162597113 0 -0.3927362103 +18.600 1 -0.6180339887 0 -14.46352549 -0.9959440549 0 -0.7469580412 0.1694375271 0 0.1270781453 +18.600 2 300.618034 0 -12.57341523 0.9959440549 0 -0.2427013798 -0.1694375271 0 -0.3911063158 +18.625 1 -0.6428789306 0 -14.4821592 -0.9916229128 0 -0.7437171846 0.176248909 0 0.1321866817 +18.625 2 300.6428789 0 -12.57960481 0.9916229128 0 -0.2524579657 -0.176248909 0 -0.3894094072 +18.650 1 -0.6676137185 0 -14.50071029 -0.9871318611 0 -0.7403488958 0.1830300915 0 0.1372725686 +18.650 2 300.6676137 0 -12.58603776 0.9871318611 0 -0.2621712942 -0.1830300915 0 -0.3876457754 +18.675 1 -0.6922341142 0 -14.51917559 -0.9824716695 0 -0.7368537521 0.1897799128 0 0.1423349346 +18.675 2 300.6922341 0 -12.592713 0.9824716695 0 -0.2718397009 -0.1897799128 0 -0.3858157224 +18.700 1 -0.7167358991 0 -14.53755192 -0.9776431365 0 -0.7332323524 0.1964972162 0 0.1473729122 +18.700 2 300.7167359 0 -12.59962936 0.9776431365 0 -0.2814615294 -0.1964972162 0 -0.3839195619 +18.725 1 -0.741114875 0 -14.55583616 -0.9726470893 0 -0.729485317 0.2031808509 0 0.1523856382 +18.725 2 300.7411149 0 -12.60678567 0.9726470893 0 -0.2910351309 -0.2031808509 0 -0.3819576188 +18.750 1 -0.7653668647 0 -14.57402515 -0.967484384 0 -0.725613288 0.2098296716 0 0.1573722537 +18.750 2 300.7653669 0 -12.6141807 0.967484384 0 -0.3005588649 -0.2098296716 0 -0.3799302292 +18.775 1 -0.7894877128 0 -14.59211578 -0.9621559053 0 -0.721616929 0.216442539 0 0.1623319043 +18.775 2 300.7894877 0 -12.62181318 0.9621559053 0 -0.3100310998 -0.216442539 0 -0.3778377405 +18.800 1 -0.8134732862 0 -14.61010496 -0.9566625662 0 -0.7174969246 0.2230183201 0 0.1672637401 +18.800 2 300.8134733 0 -12.62968181 0.9566625662 0 -0.3194502125 -0.2230183201 0 -0.3756805112 +18.825 1 -0.8373194751 0 -14.62798961 -0.9510053078 0 -0.7132539808 0.2295558882 0 0.1721669162 +18.825 2 300.8373195 0 -12.63778524 0.9510053078 0 -0.328814589 -0.2295558882 0 -0.3734589111 +18.850 1 -0.8610221936 0 -14.64576665 -0.9451850995 0 -0.7088888246 0.2360541231 0 0.1770405923 +18.850 2 300.8610222 0 -12.64612207 0.9451850995 0 -0.3381226248 -0.2360541231 0 -0.3711733206 +18.875 1 -0.8845773804 0 -14.66343304 -0.9392029387 0 -0.704402204 0.2425119113 0 0.1818839335 +18.875 2 300.8845774 0 -12.65469089 0.9392029387 0 -0.347372725 -0.2425119113 0 -0.3688241315 +18.900 1 -0.9079809995 0 -14.68098575 -0.9330598502 0 -0.6997948877 0.2489281463 0 0.1866961098 +18.900 2 300.907981 0 -12.66349021 0.9330598502 0 -0.3565633047 -0.2489281463 0 -0.3664117464 +18.925 1 -0.9312290407 0 -14.69842178 -0.9267568868 0 -0.6950676651 0.2553017288 0 0.1914762966 +18.925 2 300.931229 0 -12.67251854 0.9267568868 0 -0.3656927891 -0.2553017288 0 -0.3639365784 +18.950 1 -0.9543175205 0 -14.71573814 -0.9202951283 0 -0.6902213462 0.2616315667 0 0.196223675 +18.950 2 300.9543175 0 -12.68177433 0.9202951283 0 -0.374759614 -0.2616315667 0 -0.3613990518 +18.975 1 -0.977242483 0 -14.73293186 -0.913675682 0 -0.6852567615 0.2679165753 0 0.2009374315 +18.975 2 300.9772425 0 -12.69125599 0.913675682 0 -0.3837622257 -0.2679165753 0 -0.3587996013 +19.000 1 -1 0 -14.75 -0.9068996821 0 -0.6801747616 0.2741556778 0 0.2056167584 +19.000 2 301 0 -12.70096189 0.9068996821 0 -0.3926990817 -0.2741556778 0 -0.3561386724 +19.025 1 -1.022586172 0 -14.76693963 -0.8999682896 0 -0.6749762172 0.2803478051 0 0.2102608539 +19.025 2 301.0225862 0 -12.71089038 0.8999682896 0 -0.4015686508 -0.2803478051 0 -0.3534167209 +19.050 1 -1.044997129 0 -14.78374785 -0.8928826922 0 -0.6696620191 0.2864918963 0 0.2148689222 +19.050 2 301.0449971 0 -12.72103975 0.8928826922 0 -0.4103694131 -0.2864918963 0 -0.3506342133 +19.075 1 -1.067229032 0 -14.80042177 -0.8856441039 0 -0.6642330779 0.2925868986 0 0.2194401739 +19.075 2 301.067229 0 -12.73140827 0.8856441039 0 -0.4190998608 -0.2925868986 0 -0.3477916263 +19.100 1 -1.08927807 0 -14.81695855 -0.878253765 0 -0.6586903238 0.2986317676 0 0.2239738257 +19.100 2 301.0892781 0 -12.74199415 0.878253765 0 -0.4277584978 -0.2986317676 0 -0.344889447 +19.125 1 -1.111140466 0 -14.83335535 -0.8707129419 0 -0.6530347064 0.3046254676 0 0.2284691007 +19.125 2 301.1111405 0 -12.75279558 0.8707129419 0 -0.4363438407 -0.3046254676 0 -0.3419281727 +19.150 1 -1.132812474 0 -14.84960936 -0.8630229266 0 -0.647267195 0.3105669716 0 0.2329252287 +19.150 2 301.1328125 0 -12.76381072 0.8630229266 0 -0.4448544182 -0.3105669716 0 -0.3389083108 +19.175 1 -1.15429038 0 -14.86571779 -0.8551850368 0 -0.6413887776 0.3164552615 0 0.2373414462 +19.175 2 301.1542904 0 -12.77503767 0.8551850368 0 -0.4532887723 -0.3164552615 0 -0.3358303786 +19.200 1 -1.175570505 0 -14.88167788 -0.8472006154 0 -0.6354004615 0.3222893285 0 0.2417169964 +19.200 2 301.1755705 0 -12.78647451 0.8472006154 0 -0.4616454576 -0.3222893285 0 -0.3326949037 +19.225 1 -1.196649201 0 -14.8974869 -0.8390710305 0 -0.6293032729 0.3280681728 0 0.2460511296 +19.225 2 301.1966492 0 -12.79811928 0.8390710305 0 -0.4699230424 -0.3280681728 0 -0.3295024232 +19.250 1 -1.217522858 0 -14.91314214 -0.8307976752 0 -0.6230982564 0.3337908044 0 0.2503431033 +19.250 2 301.2175229 0 -12.80996999 0.8307976752 0 -0.4781201083 -0.3337908044 0 -0.3262534841 +19.275 1 -1.238187899 0 -14.92864092 -0.8223819669 0 -0.6167864752 0.3394562426 0 0.2545921819 +19.275 2 301.2381879 0 -12.8220246 0.8223819669 0 -0.4862352508 -0.3394562426 0 -0.3229486432 +19.300 1 -1.258640782 0 -14.94398059 -0.8138253478 0 -0.6103690108 0.3450635167 0 0.2587976376 +19.300 2 301.2586408 0 -12.83428106 0.8138253478 0 -0.4942670793 -0.3450635167 0 -0.3195884667 +19.325 1 -1.278878004 0 -14.9591585 -0.8051292838 0 -0.6038469629 0.350611666 0 0.2629587495 +19.325 2 301.278878 0 -12.84673725 0.8051292838 0 -0.5022142178 -0.350611666 0 -0.3161735304 +19.350 1 -1.298896097 0 -14.97417207 -0.7962952651 0 -0.5972214488 0.3560997398 0 0.2670748048 +19.350 2 301.2988961 0 -12.85939105 0.7962952651 0 -0.5100753044 -0.3560997398 0 -0.3127044194 +19.375 1 -1.31869163 0 -14.98901872 -0.7873248053 0 -0.590493604 0.3615267977 0 0.2711450983 +19.375 2 301.3186916 0 -12.87224029 0.7873248053 0 -0.5178489922 -0.3615267977 0 -0.309181728 +19.400 1 -1.338261213 0 -15.00369591 -0.7782194414 0 -0.5836645811 0.3668919099 0 0.2751689324 +19.400 2 301.3382612 0 -12.88528276 0.7782194414 0 -0.5255339493 -0.3668919099 0 -0.30560606 +19.425 1 -1.357601491 0 -15.01820112 -0.7689807337 0 -0.5767355503 0.372194157 0 0.2791456177 +19.425 2 301.3576015 0 -12.89851624 0.7689807337 0 -0.5331288589 -0.372194157 0 -0.301978028 +19.450 1 -1.376709151 0 -15.03253186 -0.759610265 0 -0.5697076988 0.3774326305 0 0.2830744729 +19.450 2 301.3767092 0 -12.91193844 0.759610265 0 -0.5406324195 -0.3774326305 0 -0.2982982535 +19.475 1 -1.39558092 0 -15.04668569 -0.7501096411 0 -0.5625822308 0.382606433 0 0.2869548247 +19.475 2 301.3955809 0 -12.92554708 0.7501096411 0 -0.5480433456 -0.382606433 0 -0.2945673672 +19.500 1 -1.414213562 0 -15.06066017 -0.7404804897 0 -0.5553603673 0.3877146778 0 0.2907860083 +19.500 2 301.4142136 0 -12.93933983 0.7404804897 0 -0.5553603673 -0.3877146778 0 -0.2907860083 +19.525 1 -1.432603887 0 -15.07445292 -0.7307244608 0 -0.5480433456 0.3927564896 0 0.2945673672 +19.525 2 301.4326039 0 -12.95331431 0.7307244608 0 -0.5625822308 -0.3927564896 0 -0.2869548247 +19.550 1 -1.450748742 0 -15.08806156 -0.720843226 0 -0.5406324195 0.3977310047 0 0.2982982535 +19.550 2 301.4507487 0 -12.96746814 0.720843226 0 -0.5697076988 -0.3977310047 0 -0.2830744729 +19.575 1 -1.468645019 0 -15.10148376 -0.7108384785 0 -0.5331288589 0.4026373706 0 0.301978028 +19.575 2 301.468645 0 -12.98179888 0.7108384785 0 -0.5767355503 -0.4026373706 0 -0.2791456177 +19.600 1 -1.486289651 0 -15.11471724 -0.7007119324 0 -0.5255339493 0.4074747467 0 0.30560606 +19.600 2 301.4862897 0 -12.99630409 0.7007119324 0 -0.5836645811 -0.4074747467 0 -0.2751689324 +19.625 1 -1.503679615 0 -15.12775971 -0.690465323 0 -0.5178489922 0.412242304 0 0.309181728 +19.625 2 301.5036796 0 -13.01098128 0.690465323 0 -0.590493604 -0.412242304 0 -0.2711450983 +19.650 1 -1.520811931 0 -15.14060895 -0.6801004058 0 -0.5100753044 0.4169392258 0 0.3127044194 +19.650 2 301.5208119 0 -13.02582793 0.6801004058 0 -0.5972214488 -0.4169392258 0 -0.2670748048 +19.675 1 -1.537683664 0 -15.15326275 -0.669618957 0 -0.5022142178 0.4215647072 0 0.3161735304 +19.675 2 301.5376837 0 -13.0408415 0.669618957 0 -0.6038469629 -0.4215647072 0 -0.2629587495 +19.700 1 -1.554291923 0 -15.16571894 -0.6590227724 0 -0.4942670793 0.4261179556 0 0.3195884667 +19.700 2 301.5542919 0 -13.05601941 0.6590227724 0 -0.6103690108 -0.4261179556 0 -0.2587976376 +19.725 1 -1.570633862 0 -15.1779754 -0.6483136677 0 -0.4862352508 0.430598191 0 0.3229486432 +19.725 2 301.5706339 0 -13.07135908 0.6483136677 0 -0.6167864752 -0.430598191 0 -0.2545921819 +19.750 1 -1.586706681 0 -15.19003001 -0.6374934777 0 -0.4781201083 0.4350046455 0 0.3262534841 +19.750 2 301.5867067 0 -13.08685786 0.6374934777 0 -0.6230982564 -0.4350046455 0 -0.2503431033 +19.775 1 -1.602507625 0 -15.20188072 -0.6265640565 0 -0.4699230424 0.4393365642 0 0.3295024232 +19.775 2 301.6025076 0 -13.1025131 0.6265640565 0 -0.6293032729 -0.4393365642 0 -0.2460511296 +19.800 1 -1.618033989 0 -15.21352549 -0.6155272768 0 -0.4616454576 0.4435932049 0 0.3326949037 +19.800 2 301.618034 0 -13.11832212 0.6155272768 0 -0.6354004615 -0.4435932049 0 -0.2417169964 +19.825 1 -1.63328311 0 -15.22496233 -0.6043850297 0 -0.4532887723 0.4477738382 0 0.3358303786 +19.825 2 301.6332831 0 -13.13428221 0.6043850297 0 -0.6413887776 -0.4477738382 0 -0.2373414462 +19.850 1 -1.648252377 0 -15.23618928 -0.5931392243 0 -0.4448544182 0.4518777477 0 0.3389083108 +19.850 2 301.6482524 0 -13.15039064 0.5931392243 0 -0.647267195 -0.4518777477 0 -0.2329252287 +19.875 1 -1.662939225 0 -15.24720442 -0.5817917875 0 -0.4363438407 0.4559042303 0 0.3419281727 +19.875 2 301.6629392 0 -13.16664465 0.5817917875 0 -0.6530347064 -0.4559042303 0 -0.2284691007 +19.900 1 -1.677341136 0 -15.25800585 -0.5703446638 0 -0.4277584978 0.459852596 0 0.344889447 +19.900 2 301.6773411 0 -13.18304145 0.5703446638 0 -0.6586903238 -0.459852596 0 -0.2239738257 +19.925 1 -1.691455643 0 -15.26859173 -0.5587998143 0 -0.4190998608 0.4637221684 0 0.3477916263 +19.925 2 301.6914556 0 -13.19957823 0.5587998143 0 -0.6642330779 -0.4637221684 0 -0.2194401739 +19.950 1 -1.705280329 0 -15.27896025 -0.5471592175 0 -0.4103694131 0.4675122844 0 0.3506342133 +19.950 2 301.7052803 0 -13.21625215 0.5471592175 0 -0.6696620191 -0.4675122844 0 -0.2148689222 +19.975 1 -1.718812823 0 -15.28910962 -0.5354248677 0 -0.4015686508 0.4712222945 0 0.3534167209 +19.975 2 301.7188128 0 -13.23306037 0.5354248677 0 -0.6749762172 -0.4712222945 0 -0.2102608539 +20.000 1 -1.732050808 0 -15.29903811 -0.5235987756 0 -0.3926990817 0.4748515631 0 0.3561386724 +20.000 2 301.7320508 0 -13.25 0.5235987756 0 -0.6801747616 -0.4748515631 0 -0.2056167584 +20.025 1 -1.744992014 0 -15.30874401 -0.5116829676 0 -0.3837622257 0.4783994684 0 0.3587996013 +20.025 2 301.744992 0 -13.26706814 0.5116829676 0 -0.6852567615 -0.4783994684 0 -0.2009374315 +20.050 1 -1.757634225 0 -15.31822567 -0.4996794853 0 -0.374759614 0.4818654024 0 0.3613990518 +20.050 2 301.7576342 0 -13.28426186 0.4996794853 0 -0.6902213462 -0.4818654024 0 -0.196223675 +20.075 1 -1.769975275 0 -15.32748146 -0.4875903855 0 -0.3656927891 0.4852487712 0 0.3639365784 +20.075 2 301.7699753 0 -13.30157822 0.4875903855 0 -0.6950676651 -0.4852487712 0 -0.1914762966 +20.100 1 -1.782013048 0 -15.33650979 -0.4754177396 0 -0.3565633047 0.4885489951 0 0.3664117464 +20.100 2 301.782013 0 -13.31901425 0.4754177396 0 -0.6997948877 -0.4885489951 0 -0.1866961098 +20.125 1 -1.793745483 0 -15.34530911 -0.4631636333 0 -0.347372725 0.4917655087 0 0.3688241315 +20.125 2 301.7937455 0 -13.33656696 0.4631636333 0 -0.704402204 -0.4917655087 0 -0.1818839335 +20.150 1 -1.805170569 0 -15.35387793 -0.4508301663 0 -0.3381226248 0.4948977608 0 0.3711733206 +20.150 2 301.8051706 0 -13.35423335 0.4508301663 0 -0.7088888246 -0.4948977608 0 -0.1770405923 +20.175 1 -1.816286348 0 -15.36221476 -0.4384194519 0 -0.328814589 0.4979452147 0 0.3734589111 +20.175 2 301.8162863 0 -13.37201039 0.4384194519 0 -0.7132539808 -0.4979452147 0 -0.1721669162 +20.200 1 -1.827090915 0 -15.37031819 -0.4259336166 0 -0.3194502125 0.5009073483 0 0.3756805112 +20.200 2 301.8270909 0 -13.38989504 0.4259336166 0 -0.7174969246 -0.5009073483 0 -0.1672637401 +20.225 1 -1.83758242 0 -15.37818682 -0.4133747998 0 -0.3100310998 0.503783654 0 0.3778377405 +20.225 2 301.8375824 0 -13.40788422 0.4133747998 0 -0.721616929 -0.503783654 0 -0.1623319043 +20.250 1 -1.847759065 0 -15.3858193 -0.4007451533 0 -0.3005588649 0.5065736389 0 0.3799302292 +20.250 2 301.8477591 0 -13.42597485 0.4007451533 0 -0.725613288 -0.5065736389 0 -0.1573722537 +20.275 1 -1.857619106 0 -15.39321433 -0.3880468411 0 -0.2910351309 0.509276825 0 0.3819576188 +20.275 2 301.8576191 0 -13.44416384 0.3880468411 0 -0.729485317 -0.509276825 0 -0.1523856382 +20.300 1 -1.867160853 0 -15.40037064 -0.3752820392 0 -0.2814615294 0.5118927492 0 0.3839195619 +20.300 2 301.8671609 0 -13.46244808 0.3752820392 0 -0.7332323524 -0.5118927492 0 -0.1473729122 +20.325 1 -1.876382672 0 -15.407287 -0.3624529346 0 -0.2718397009 0.5144209632 0 0.3858157224 +20.325 2 301.8763827 0 -13.48082441 0.3624529346 0 -0.7368537521 -0.5144209632 0 -0.1423349346 +20.350 1 -1.885282982 0 -15.41396224 -0.3495617256 0 -0.2621712942 0.5168610338 0 0.3876457754 +20.350 2 301.885283 0 -13.49928971 0.3495617256 0 -0.7403488958 -0.5168610338 0 -0.1372725686 +20.375 1 -1.893860259 0 -15.42039519 -0.3366106209 0 -0.2524579657 0.519212543 0 0.3894094072 +20.375 2 301.8938603 0 -13.5178408 0.3366106209 0 -0.7437171846 -0.519212543 0 -0.1321866817 +20.400 1 -1.902113033 0 -15.42658477 -0.3236018398 0 -0.2427013798 0.5214750877 0 0.3911063158 +20.400 2 301.902113 0 -13.53647451 0.3236018398 0 -0.7469580412 -0.5214750877 0 -0.1270781453 +20.425 1 -1.910039889 0 -15.43252992 -0.3105376111 0 -0.2329032084 0.5236482804 0 0.3927362103 +20.425 2 301.9100399 0 -13.55518764 0.3105376111 0 -0.7500709104 -0.5236482804 0 -0.1219478347 +20.450 1 -1.91763947 0 -15.4382296 -0.2974201735 0 -0.2230651301 0.5257317486 0 0.3942988115 +20.450 2 301.9176395 0 -13.57397698 0.2974201735 0 -0.7530552588 -0.5257317486 0 -0.116796629 +20.475 1 -1.924910473 0 -15.44368285 -0.2842517744 0 -0.2131888308 0.5277251354 0 0.3957938516 +20.475 2 301.9249105 0 -13.59283933 0.2842517744 0 -0.7559105751 -0.5277251354 0 -0.1116254108 +20.500 1 -1.931851653 0 -15.44888874 -0.2710346702 0 -0.2032760027 0.5296280992 0 0.3972210744 +20.500 2 301.9318517 0 -13.61177143 0.2710346702 0 -0.7586363699 -0.5296280992 0 -0.1064350661 +20.525 1 -1.938461819 0 -15.45384636 -0.2577711257 0 -0.1933283443 0.531440314 0 0.3985802355 +20.525 2 301.9384618 0 -13.63077006 0.2577711257 0 -0.7612321764 -0.531440314 0 -0.1012264843 +20.550 1 -1.944739841 0 -15.45855488 -0.2444634134 0 -0.18334756 0.5331614692 0 0.3998711019 +20.550 2 301.9447398 0 -13.64983195 0.2444634134 0 -0.7636975496 -0.5331614692 0 -0.09600055794 +20.575 1 -1.950684641 0 -15.46301348 -0.2311138135 0 -0.1733353601 0.5347912699 0 0.4010934525 +20.575 2 301.9506846 0 -13.66895385 0.2311138135 0 -0.7660320672 -0.5347912699 0 -0.09075818233 +20.600 1 -1.956295201 0 -15.4672214 -0.2177246135 0 -0.1632934601 0.536329437 0 0.4022470777 +20.600 2 301.9562952 0 -13.68813246 0.2177246135 0 -0.7682353291 -0.536329437 0 -0.08550025578 +20.625 1 -1.961570561 0 -15.47117792 -0.2042981075 0 -0.1532235806 0.5377757067 0 0.40333178 +20.625 2 301.9615706 0 -13.70736452 0.2042981075 0 -0.7703069579 -0.5377757067 0 -0.0802276792 +20.650 1 -1.966509815 0 -15.47488236 -0.190836596 0 -0.143127447 0.5391298313 0 0.4043473735 +20.650 2 301.9665098 0 -13.72664671 0.190836596 0 -0.7722465986 -0.5391298313 0 -0.07494135602 +20.675 1 -1.971112118 0 -15.47833409 -0.1773423857 0 -0.1330067893 0.5403915788 0 0.4052936841 +20.675 2 301.9711121 0 -13.74597574 0.1773423857 0 -0.7740539187 -0.5403915788 0 -0.06964219202 +20.700 1 -1.975376681 0 -15.48153251 -0.1638177887 0 -0.1228633415 0.541560733 0 0.4061705497 +20.700 2 301.9753767 0 -13.7653483 0.1638177887 0 -0.7757286087 -0.541560733 0 -0.06433109519 +20.725 1 -1.979302774 0 -15.48447708 -0.1502651224 0 -0.1126988418 0.5426370935 0 0.4069778201 +20.725 2 301.9793028 0 -13.78476107 0.1502651224 0 -0.7772703816 -0.5426370935 0 -0.05900897556 +20.750 1 -1.982889723 0 -15.48716729 -0.1366867089 0 -0.1025150316 0.543620476 0 0.407715357 +20.750 2 301.9828897 0 -13.80421071 0.1366867089 0 -0.7786789732 -0.543620476 0 -0.05367674505 +20.775 1 -1.986136914 0 -15.48960269 -0.1230848748 0 -0.09231365609 0.5445107119 0 0.4083830339 +20.775 2 301.9861369 0 -13.8236939 0.1230848748 0 -0.7799541422 -0.5445107119 0 -0.0483353173 +20.800 1 -1.989043791 0 -15.49178284 -0.1094619508 0 -0.08209646307 0.5453076486 0 0.4089807365 +20.800 2 301.9890438 0 -13.84320731 0.1094619508 0 -0.7810956701 -0.5453076486 0 -0.04298560755 +20.825 1 -1.991609855 0 -15.49370739 -0.09582027099 0 -0.07186520325 0.5460111498 0 0.4095083623 +20.825 2 301.9916099 0 -13.86274757 0.09582027099 0 -0.7821033612 -0.5460111498 0 -0.03762853243 +20.850 1 -1.993834667 0 -15.495376 -0.08216217292 0 -0.06162162969 0.5466210947 0 0.409965821 +20.850 2 301.9938347 0 -13.88231136 0.08216217292 0 -0.782977043 -0.5466210947 0 -0.03226500985 +20.875 1 -1.995717846 0 -15.49678838 -0.06848999677 0 -0.05136749758 0.5471373789 0 0.4103530342 +20.875 2 301.9957178 0 -13.90189531 0.06848999677 0 -0.7837165656 -0.5471373789 0 -0.02689595884 +20.900 1 -1.99725907 0 -15.4979443 -0.05480608522 0 -0.04110456391 0.547559914 0 0.4106699355 +20.900 2 301.9972591 0 -13.92149607 0.05480608522 0 -0.7843218025 -0.547559914 0 -0.02152229934 +20.925 1 -1.998458072 0 -15.49884355 -0.04111278292 0 -0.03083458719 0.5478886274 0 0.4109164706 +20.925 2 301.9984581 0 -13.94111028 0.04111278292 0 -0.7847926499 -0.5478886274 0 -0.0161449521 +20.950 1 -1.99931465 0 -15.49948599 -0.02741243617 0 -0.02055932712 0.548123463 0 0.4110925973 +20.950 2 301.9993146 0 -13.96073458 0.02741243617 0 -0.7851290271 -0.548123463 0 -0.01076483851 +20.975 1 -1.999828655 0 -15.49987149 -0.01370739243 0 -0.01028054432 0.5482643805 0 0.4111982853 +20.975 2 301.9998287 0 -13.98036561 0.01370739243 0 -0.7853308764 -0.5482643805 0 -0.005382880419 +21.000 1 -2 0 -15.5 -4.488564952e-16 0 -3.366423714e-16 0.5483113556 0 0.4112335167 +21.000 2 302 0 -14 5.771012081e-16 0 -0.7853981634 -0.5483113556 0 -1.51084743e-16 +21.025 1 -1.999828655 0 -15.49987149 0.01370739243 0 0.01028054432 0.5482643805 0 0.4111982853 +21.025 2 301.9998287 0 -14.01963439 -0.01370739243 0 -0.7853308764 -0.5482643805 0 0.005382880419 +21.050 1 -1.99931465 0 -15.49948599 0.02741243617 0 0.02055932712 0.548123463 0 0.4110925973 +21.050 2 301.9993146 0 -14.03926542 -0.02741243617 0 -0.7851290271 -0.548123463 0 0.01076483851 +21.075 1 -1.998458072 0 -15.49884355 0.04111278292 0 0.03083458719 0.5478886274 0 0.4109164706 +21.075 2 301.9984581 0 -14.05888972 -0.04111278292 0 -0.7847926499 -0.5478886274 0 0.0161449521 +21.100 1 -1.99725907 0 -15.4979443 0.05480608522 0 0.04110456391 0.547559914 0 0.4106699355 +21.100 2 301.9972591 0 -14.07850393 -0.05480608522 0 -0.7843218025 -0.547559914 0 0.02152229934 +21.125 1 -1.995717846 0 -15.49678838 0.06848999677 0 0.05136749758 0.5471373789 0 0.4103530342 +21.125 2 301.9957178 0 -14.09810469 -0.06848999677 0 -0.7837165656 -0.5471373789 0 0.02689595884 +21.150 1 -1.993834667 0 -15.495376 0.08216217292 0 0.06162162969 0.5466210947 0 0.409965821 +21.150 2 301.9938347 0 -14.11768864 -0.08216217292 0 -0.782977043 -0.5466210947 0 0.03226500985 +21.175 1 -1.991609855 0 -15.49370739 0.09582027099 0 0.07186520325 0.5460111498 0 0.4095083623 +21.175 2 301.9916099 0 -14.13725243 -0.09582027099 0 -0.7821033612 -0.5460111498 0 0.03762853243 +21.200 1 -1.989043791 0 -15.49178284 0.1094619508 0 0.08209646307 0.5453076486 0 0.4089807365 +21.200 2 301.9890438 0 -14.15679269 -0.1094619508 0 -0.7810956701 -0.5453076486 0 0.04298560755 +21.225 1 -1.986136914 0 -15.48960269 0.1230848748 0 0.09231365609 0.5445107119 0 0.4083830339 +21.225 2 301.9861369 0 -14.1763061 -0.1230848748 0 -0.7799541422 -0.5445107119 0 0.0483353173 +21.250 1 -1.982889723 0 -15.48716729 0.1366867089 0 0.1025150316 0.543620476 0 0.407715357 +21.250 2 301.9828897 0 -14.19578929 -0.1366867089 0 -0.7786789732 -0.543620476 0 0.05367674505 +21.275 1 -1.979302774 0 -15.48447708 0.1502651224 0 0.1126988418 0.5426370935 0 0.4069778201 +21.275 2 301.9793028 0 -14.21523893 -0.1502651224 0 -0.7772703816 -0.5426370935 0 0.05900897556 +21.300 1 -1.975376681 0 -15.48153251 0.1638177887 0 0.1228633415 0.541560733 0 0.4061705497 +21.300 2 301.9753767 0 -14.2346517 -0.1638177887 0 -0.7757286087 -0.541560733 0 0.06433109519 +21.325 1 -1.971112118 0 -15.47833409 0.1773423857 0 0.1330067893 0.5403915788 0 0.4052936841 +21.325 2 301.9711121 0 -14.25402426 -0.1773423857 0 -0.7740539187 -0.5403915788 0 0.06964219202 +21.350 1 -1.966509815 0 -15.47488236 0.190836596 0 0.143127447 0.5391298313 0 0.4043473735 +21.350 2 301.9665098 0 -14.27335329 -0.190836596 0 -0.7722465986 -0.5391298313 0 0.07494135602 +21.375 1 -1.961570561 0 -15.47117792 0.2042981075 0 0.1532235806 0.5377757067 0 0.40333178 +21.375 2 301.9615706 0 -14.29263548 -0.2042981075 0 -0.7703069579 -0.5377757067 0 0.0802276792 +21.400 1 -1.956295201 0 -15.4672214 0.2177246135 0 0.1632934601 0.536329437 0 0.4022470777 +21.400 2 301.9562952 0 -14.31186754 -0.2177246135 0 -0.7682353291 -0.536329437 0 0.08550025578 +21.425 1 -1.950684641 0 -15.46301348 0.2311138135 0 0.1733353601 0.5347912699 0 0.4010934525 +21.425 2 301.9506846 0 -14.33104615 -0.2311138135 0 -0.7660320672 -0.5347912699 0 0.09075818233 +21.450 1 -1.944739841 0 -15.45855488 0.2444634134 0 0.18334756 0.5331614692 0 0.3998711019 +21.450 2 301.9447398 0 -14.35016805 -0.2444634134 0 -0.7636975496 -0.5331614692 0 0.09600055794 +21.475 1 -1.938461819 0 -15.45384636 0.2577711257 0 0.1933283443 0.531440314 0 0.3985802355 +21.475 2 301.9384618 0 -14.36922994 -0.2577711257 0 -0.7612321764 -0.531440314 0 0.1012264843 +21.500 1 -1.931851653 0 -15.44888874 0.2710346702 0 0.2032760027 0.5296280992 0 0.3972210744 +21.500 2 301.9318517 0 -14.38822857 -0.2710346702 0 -0.7586363699 -0.5296280992 0 0.1064350661 +21.525 1 -1.924910473 0 -15.44368285 0.2842517744 0 0.2131888308 0.5277251354 0 0.3957938516 +21.525 2 301.9249105 0 -14.40716067 -0.2842517744 0 -0.7559105751 -0.5277251354 0 0.1116254108 +21.550 1 -1.91763947 0 -15.4382296 0.2974201735 0 0.2230651301 0.5257317486 0 0.3942988115 +21.550 2 301.9176395 0 -14.42602302 -0.2974201735 0 -0.7530552588 -0.5257317486 0 0.116796629 +21.575 1 -1.910039889 0 -15.43252992 0.3105376111 0 0.2329032084 0.5236482804 0 0.3927362103 +21.575 2 301.9100399 0 -14.44481236 -0.3105376111 0 -0.7500709104 -0.5236482804 0 0.1219478347 +21.600 1 -1.902113033 0 -15.42658477 0.3236018398 0 0.2427013798 0.5214750877 0 0.3911063158 +21.600 2 301.902113 0 -14.46352549 -0.3236018398 0 -0.7469580412 -0.5214750877 0 0.1270781453 +21.625 1 -1.893860259 0 -15.42039519 0.3366106209 0 0.2524579657 0.519212543 0 0.3894094072 +21.625 2 301.8938603 0 -14.4821592 -0.3366106209 0 -0.7437171846 -0.519212543 0 0.1321866817 +21.650 1 -1.885282982 0 -15.41396224 0.3495617256 0 0.2621712942 0.5168610338 0 0.3876457754 +21.650 2 301.885283 0 -14.50071029 -0.3495617256 0 -0.7403488958 -0.5168610338 0 0.1372725686 +21.675 1 -1.876382672 0 -15.407287 0.3624529346 0 0.2718397009 0.5144209632 0 0.3858157224 +21.675 2 301.8763827 0 -14.51917559 -0.3624529346 0 -0.7368537521 -0.5144209632 0 0.1423349346 +21.700 1 -1.867160853 0 -15.40037064 0.3752820392 0 0.2814615294 0.5118927492 0 0.3839195619 +21.700 2 301.8671609 0 -14.53755192 -0.3752820392 0 -0.7332323524 -0.5118927492 0 0.1473729122 +21.725 1 -1.857619106 0 -15.39321433 0.3880468411 0 0.2910351309 0.509276825 0 0.3819576188 +21.725 2 301.8576191 0 -14.55583616 -0.3880468411 0 -0.729485317 -0.509276825 0 0.1523856382 +21.750 1 -1.847759065 0 -15.3858193 0.4007451533 0 0.3005588649 0.5065736389 0 0.3799302292 +21.750 2 301.8477591 0 -14.57402515 -0.4007451533 0 -0.725613288 -0.5065736389 0 0.1573722537 +21.775 1 -1.83758242 0 -15.37818682 0.4133747998 0 0.3100310998 0.503783654 0 0.3778377405 +21.775 2 301.8375824 0 -14.59211578 -0.4133747998 0 -0.721616929 -0.503783654 0 0.1623319043 +21.800 1 -1.827090915 0 -15.37031819 0.4259336166 0 0.3194502125 0.5009073483 0 0.3756805112 +21.800 2 301.8270909 0 -14.61010496 -0.4259336166 0 -0.7174969246 -0.5009073483 0 0.1672637401 +21.825 1 -1.816286348 0 -15.36221476 0.4384194519 0 0.328814589 0.4979452147 0 0.3734589111 +21.825 2 301.8162863 0 -14.62798961 -0.4384194519 0 -0.7132539808 -0.4979452147 0 0.1721669162 +21.850 1 -1.805170569 0 -15.35387793 0.4508301663 0 0.3381226248 0.4948977608 0 0.3711733206 +21.850 2 301.8051706 0 -14.64576665 -0.4508301663 0 -0.7088888246 -0.4948977608 0 0.1770405923 +21.875 1 -1.793745483 0 -15.34530911 0.4631636333 0 0.347372725 0.4917655087 0 0.3688241315 +21.875 2 301.7937455 0 -14.66343304 -0.4631636333 0 -0.704402204 -0.4917655087 0 0.1818839335 +21.900 1 -1.782013048 0 -15.33650979 0.4754177396 0 0.3565633047 0.4885489951 0 0.3664117464 +21.900 2 301.782013 0 -14.68098575 -0.4754177396 0 -0.6997948877 -0.4885489951 0 0.1866961098 +21.925 1 -1.769975275 0 -15.32748146 0.4875903855 0 0.3656927891 0.4852487712 0 0.3639365784 +21.925 2 301.7699753 0 -14.69842178 -0.4875903855 0 -0.6950676651 -0.4852487712 0 0.1914762966 +21.950 1 -1.757634225 0 -15.31822567 0.4996794853 0 0.374759614 0.4818654024 0 0.3613990518 +21.950 2 301.7576342 0 -14.71573814 -0.4996794853 0 -0.6902213462 -0.4818654024 0 0.196223675 +21.975 1 -1.744992014 0 -15.30874401 0.5116829676 0 0.3837622257 0.4783994684 0 0.3587996013 +21.975 2 301.744992 0 -14.73293186 -0.5116829676 0 -0.6852567615 -0.4783994684 0 0.2009374315 +22.000 1 -1.732050808 0 -15.29903811 0.5235987756 0 0.3926990817 0.4748515631 0 0.3561386724 +22.000 2 301.7320508 0 -14.75 -0.5235987756 0 -0.6801747616 -0.4748515631 0 0.2056167584 +22.025 1 -1.718812823 0 -15.28910962 0.5354248677 0 0.4015686508 0.4712222945 0 0.3534167209 +22.025 2 301.7188128 0 -14.76693963 -0.5354248677 0 -0.6749762172 -0.4712222945 0 0.2102608539 +22.050 1 -1.705280329 0 -15.27896025 0.5471592175 0 0.4103694131 0.4675122844 0 0.3506342133 +22.050 2 301.7052803 0 -14.78374785 -0.5471592175 0 -0.6696620191 -0.4675122844 0 0.2148689222 +22.075 1 -1.691455643 0 -15.26859173 0.5587998143 0 0.4190998608 0.4637221684 0 0.3477916263 +22.075 2 301.6914556 0 -14.80042177 -0.5587998143 0 -0.6642330779 -0.4637221684 0 0.2194401739 +22.100 1 -1.677341136 0 -15.25800585 0.5703446638 0 0.4277584978 0.459852596 0 0.344889447 +22.100 2 301.6773411 0 -14.81695855 -0.5703446638 0 -0.6586903238 -0.459852596 0 0.2239738257 +22.125 1 -1.662939225 0 -15.24720442 0.5817917875 0 0.4363438407 0.4559042303 0 0.3419281727 +22.125 2 301.6629392 0 -14.83335535 -0.5817917875 0 -0.6530347064 -0.4559042303 0 0.2284691007 +22.150 1 -1.648252377 0 -15.23618928 0.5931392243 0 0.4448544182 0.4518777477 0 0.3389083108 +22.150 2 301.6482524 0 -14.84960936 -0.5931392243 0 -0.647267195 -0.4518777477 0 0.2329252287 +22.175 1 -1.63328311 0 -15.22496233 0.6043850297 0 0.4532887723 0.4477738382 0 0.3358303786 +22.175 2 301.6332831 0 -14.86571779 -0.6043850297 0 -0.6413887776 -0.4477738382 0 0.2373414462 +22.200 1 -1.618033989 0 -15.21352549 0.6155272768 0 0.4616454576 0.4435932049 0 0.3326949037 +22.200 2 301.618034 0 -14.88167788 -0.6155272768 0 -0.6354004615 -0.4435932049 0 0.2417169964 +22.225 1 -1.602507625 0 -15.20188072 0.6265640565 0 0.4699230424 0.4393365642 0 0.3295024232 +22.225 2 301.6025076 0 -14.8974869 -0.6265640565 0 -0.6293032729 -0.4393365642 0 0.2460511296 +22.250 1 -1.586706681 0 -15.19003001 0.6374934777 0 0.4781201083 0.4350046455 0 0.3262534841 +22.250 2 301.5867067 0 -14.91314214 -0.6374934777 0 -0.6230982564 -0.4350046455 0 0.2503431033 +22.275 1 -1.570633862 0 -15.1779754 0.6483136677 0 0.4862352508 0.430598191 0 0.3229486432 +22.275 2 301.5706339 0 -14.92864092 -0.6483136677 0 -0.6167864752 -0.430598191 0 0.2545921819 +22.300 1 -1.554291923 0 -15.16571894 0.6590227724 0 0.4942670793 0.4261179556 0 0.3195884667 +22.300 2 301.5542919 0 -14.94398059 -0.6590227724 0 -0.6103690108 -0.4261179556 0 0.2587976376 +22.325 1 -1.537683664 0 -15.15326275 0.669618957 0 0.5022142178 0.4215647072 0 0.3161735304 +22.325 2 301.5376837 0 -14.9591585 -0.669618957 0 -0.6038469629 -0.4215647072 0 0.2629587495 +22.350 1 -1.520811931 0 -15.14060895 0.6801004058 0 0.5100753044 0.4169392258 0 0.3127044194 +22.350 2 301.5208119 0 -14.97417207 -0.6801004058 0 -0.5972214488 -0.4169392258 0 0.2670748048 +22.375 1 -1.503679615 0 -15.12775971 0.690465323 0 0.5178489922 0.412242304 0 0.309181728 +22.375 2 301.5036796 0 -14.98901872 -0.690465323 0 -0.590493604 -0.412242304 0 0.2711450983 +22.400 1 -1.486289651 0 -15.11471724 0.7007119324 0 0.5255339493 0.4074747467 0 0.30560606 +22.400 2 301.4862897 0 -15.00369591 -0.7007119324 0 -0.5836645811 -0.4074747467 0 0.2751689324 +22.425 1 -1.468645019 0 -15.10148376 0.7108384785 0 0.5331288589 0.4026373706 0 0.301978028 +22.425 2 301.468645 0 -15.01820112 -0.7108384785 0 -0.5767355503 -0.4026373706 0 0.2791456177 +22.450 1 -1.450748742 0 -15.08806156 0.720843226 0 0.5406324195 0.3977310047 0 0.2982982535 +22.450 2 301.4507487 0 -15.03253186 -0.720843226 0 -0.5697076988 -0.3977310047 0 0.2830744729 +22.475 1 -1.432603887 0 -15.07445292 0.7307244608 0 0.5480433456 0.3927564896 0 0.2945673672 +22.475 2 301.4326039 0 -15.04668569 -0.7307244608 0 -0.5625822308 -0.3927564896 0 0.2869548247 +22.500 1 -1.414213562 0 -15.06066017 0.7404804897 0 0.5553603673 0.3877146778 0 0.2907860083 +22.500 2 301.4142136 0 -15.06066017 -0.7404804897 0 -0.5553603673 -0.3877146778 0 0.2907860083 +22.525 1 -1.39558092 0 -15.04668569 0.7501096411 0 0.5625822308 0.382606433 0 0.2869548247 +22.525 2 301.3955809 0 -15.07445292 -0.7501096411 0 -0.5480433456 -0.382606433 0 0.2945673672 +22.550 1 -1.376709151 0 -15.03253186 0.759610265 0 0.5697076988 0.3774326305 0 0.2830744729 +22.550 2 301.3767092 0 -15.08806156 -0.759610265 0 -0.5406324195 -0.3774326305 0 0.2982982535 +22.575 1 -1.357601491 0 -15.01820112 0.7689807337 0 0.5767355503 0.372194157 0 0.2791456177 +22.575 2 301.3576015 0 -15.10148376 -0.7689807337 0 -0.5331288589 -0.372194157 0 0.301978028 +22.600 1 -1.338261213 0 -15.00369591 0.7782194414 0 0.5836645811 0.3668919099 0 0.2751689324 +22.600 2 301.3382612 0 -15.11471724 -0.7782194414 0 -0.5255339493 -0.3668919099 0 0.30560606 +22.625 1 -1.31869163 0 -14.98901872 0.7873248053 0 0.590493604 0.3615267977 0 0.2711450983 +22.625 2 301.3186916 0 -15.12775971 -0.7873248053 0 -0.5178489922 -0.3615267977 0 0.309181728 +22.650 1 -1.298896097 0 -14.97417207 0.7962952651 0 0.5972214488 0.3560997398 0 0.2670748048 +22.650 2 301.2988961 0 -15.14060895 -0.7962952651 0 -0.5100753044 -0.3560997398 0 0.3127044194 +22.675 1 -1.278878004 0 -14.9591585 0.8051292838 0 0.6038469629 0.350611666 0 0.2629587495 +22.675 2 301.278878 0 -15.15326275 -0.8051292838 0 -0.5022142178 -0.350611666 0 0.3161735304 +22.700 1 -1.258640782 0 -14.94398059 0.8138253478 0 0.6103690108 0.3450635167 0 0.2587976376 +22.700 2 301.2586408 0 -15.16571894 -0.8138253478 0 -0.4942670793 -0.3450635167 0 0.3195884667 +22.725 1 -1.238187899 0 -14.92864092 0.8223819669 0 0.6167864752 0.3394562426 0 0.2545921819 +22.725 2 301.2381879 0 -15.1779754 -0.8223819669 0 -0.4862352508 -0.3394562426 0 0.3229486432 +22.750 1 -1.217522858 0 -14.91314214 0.8307976752 0 0.6230982564 0.3337908044 0 0.2503431033 +22.750 2 301.2175229 0 -15.19003001 -0.8307976752 0 -0.4781201083 -0.3337908044 0 0.3262534841 +22.775 1 -1.196649201 0 -14.8974869 0.8390710305 0 0.6293032729 0.3280681728 0 0.2460511296 +22.775 2 301.1966492 0 -15.20188072 -0.8390710305 0 -0.4699230424 -0.3280681728 0 0.3295024232 +22.800 1 -1.175570505 0 -14.88167788 0.8472006154 0 0.6354004615 0.3222893285 0 0.2417169964 +22.800 2 301.1755705 0 -15.21352549 -0.8472006154 0 -0.4616454576 -0.3222893285 0 0.3326949037 +22.825 1 -1.15429038 0 -14.86571779 0.8551850368 0 0.6413887776 0.3164552615 0 0.2373414462 +22.825 2 301.1542904 0 -15.22496233 -0.8551850368 0 -0.4532887723 -0.3164552615 0 0.3358303786 +22.850 1 -1.132812474 0 -14.84960936 0.8630229266 0 0.647267195 0.3105669716 0 0.2329252287 +22.850 2 301.1328125 0 -15.23618928 -0.8630229266 0 -0.4448544182 -0.3105669716 0 0.3389083108 +22.875 1 -1.111140466 0 -14.83335535 0.8707129419 0 0.6530347064 0.3046254676 0 0.2284691007 +22.875 2 301.1111405 0 -15.24720442 -0.8707129419 0 -0.4363438407 -0.3046254676 0 0.3419281727 +22.900 1 -1.08927807 0 -14.81695855 0.878253765 0 0.6586903238 0.2986317676 0 0.2239738257 +22.900 2 301.0892781 0 -15.25800585 -0.878253765 0 -0.4277584978 -0.2986317676 0 0.344889447 +22.925 1 -1.067229032 0 -14.80042177 0.8856441039 0 0.6642330779 0.2925868986 0 0.2194401739 +22.925 2 301.067229 0 -15.26859173 -0.8856441039 0 -0.4190998608 -0.2925868986 0 0.3477916263 +22.950 1 -1.044997129 0 -14.78374785 0.8928826922 0 0.6696620191 0.2864918963 0 0.2148689222 +22.950 2 301.0449971 0 -15.27896025 -0.8928826922 0 -0.4103694131 -0.2864918963 0 0.3506342133 +22.975 1 -1.022586172 0 -14.76693963 0.8999682896 0 0.6749762172 0.2803478051 0 0.2102608539 +22.975 2 301.0225862 0 -15.28910962 -0.8999682896 0 -0.4015686508 -0.2803478051 0 0.3534167209 +23.000 1 -1 0 -14.75 0.9068996821 0 0.6801747616 0.2741556778 0 0.2056167584 +23.000 2 301 0 -15.29903811 -0.9068996821 0 -0.3926990817 -0.2741556778 0 0.3561386724 +23.025 1 -0.977242483 0 -14.73293186 0.913675682 0 0.6852567615 0.2679165753 0 0.2009374315 +23.025 2 300.9772425 0 -15.30874401 -0.913675682 0 -0.3837622257 -0.2679165753 0 0.3587996013 +23.050 1 -0.9543175205 0 -14.71573814 0.9202951283 0 0.6902213462 0.2616315667 0 0.196223675 +23.050 2 300.9543175 0 -15.31822567 -0.9202951283 0 -0.374759614 -0.2616315667 0 0.3613990518 +23.075 1 -0.9312290407 0 -14.69842178 0.9267568868 0 0.6950676651 0.2553017288 0 0.1914762966 +23.075 2 300.931229 0 -15.32748146 -0.9267568868 0 -0.3656927891 -0.2553017288 0 0.3639365784 +23.100 1 -0.9079809995 0 -14.68098575 0.9330598502 0 0.6997948877 0.2489281463 0 0.1866961098 +23.100 2 300.907981 0 -15.33650979 -0.9330598502 0 -0.3565633047 -0.2489281463 0 0.3664117464 +23.125 1 -0.8845773804 0 -14.66343304 0.9392029387 0 0.704402204 0.2425119113 0 0.1818839335 +23.125 2 300.8845774 0 -15.34530911 -0.9392029387 0 -0.347372725 -0.2425119113 0 0.3688241315 +23.150 1 -0.8610221936 0 -14.64576665 0.9451850995 0 0.7088888246 0.2360541231 0 0.1770405923 +23.150 2 300.8610222 0 -15.35387793 -0.9451850995 0 -0.3381226248 -0.2360541231 0 0.3711733206 +23.175 1 -0.8373194751 0 -14.62798961 0.9510053078 0 0.7132539808 0.2295558882 0 0.1721669162 +23.175 2 300.8373195 0 -15.36221476 -0.9510053078 0 -0.328814589 -0.2295558882 0 0.3734589111 +23.200 1 -0.8134732862 0 -14.61010496 0.9566625662 0 0.7174969246 0.2230183201 0 0.1672637401 +23.200 2 300.8134733 0 -15.37031819 -0.9566625662 0 -0.3194502125 -0.2230183201 0 0.3756805112 +23.225 1 -0.7894877128 0 -14.59211578 0.9621559053 0 0.721616929 0.216442539 0 0.1623319043 +23.225 2 300.7894877 0 -15.37818682 -0.9621559053 0 -0.3100310998 -0.216442539 0 0.3778377405 +23.250 1 -0.7653668647 0 -14.57402515 0.967484384 0 0.725613288 0.2098296716 0 0.1573722537 +23.250 2 300.7653669 0 -15.3858193 -0.967484384 0 -0.3005588649 -0.2098296716 0 0.3799302292 +23.275 1 -0.741114875 0 -14.55583616 0.9726470893 0 0.729485317 0.2031808509 0 0.1523856382 +23.275 2 300.7411149 0 -15.39321433 -0.9726470893 0 -0.2910351309 -0.2031808509 0 0.3819576188 +23.300 1 -0.7167358991 0 -14.53755192 0.9776431365 0 0.7332323524 0.1964972162 0 0.1473729122 +23.300 2 300.7167359 0 -15.40037064 -0.9776431365 0 -0.2814615294 -0.1964972162 0 0.3839195619 +23.325 1 -0.6922341142 0 -14.51917559 0.9824716695 0 0.7368537521 0.1897799128 0 0.1423349346 +23.325 2 300.6922341 0 -15.407287 -0.9824716695 0 -0.2718397009 -0.1897799128 0 0.3858157224 +23.350 1 -0.6676137185 0 -14.50071029 0.9871318611 0 0.7403488958 0.1830300915 0 0.1372725686 +23.350 2 300.6676137 0 -15.41396224 -0.9871318611 0 -0.2621712942 -0.1830300915 0 0.3876457754 +23.375 1 -0.6428789306 0 -14.4821592 0.9916229128 0 0.7437171846 0.176248909 0 0.1321866817 +23.375 2 300.6428789 0 -15.42039519 -0.9916229128 0 -0.2524579657 -0.176248909 0 0.3894094072 +23.400 1 -0.6180339887 0 -14.46352549 0.9959440549 0 0.7469580412 0.1694375271 0 0.1270781453 +23.400 2 300.618034 0 -15.42658477 -0.9959440549 0 -0.2427013798 -0.1694375271 0 0.3911063158 +23.425 1 -0.59308315 0 -14.44481236 1.000094547 0 0.7500709104 0.162597113 0 0.1219478347 +23.425 2 300.5930831 0 -15.43252992 -1.000094547 0 -0.2329032084 -0.162597113 0 0.3927362103 +23.450 1 -0.5680306894 0 -14.42602302 1.004073678 0 0.7530552588 0.1557288387 0 0.116796629 +23.450 2 300.5680307 0 -15.4382296 -1.004073678 0 -0.2230651301 -0.1557288387 0 0.3942988115 +23.475 1 -0.5428808997 0 -14.40716067 1.007880767 0 0.7559105751 0.148833881 0 0.1116254108 +23.475 2 300.5428809 0 -15.44368285 -1.007880767 0 -0.2131888308 -0.148833881 0 0.3957938516 +23.500 1 -0.5176380902 0 -14.38822857 1.01151516 0 0.7586363699 0.1419134215 0 0.1064350661 +23.500 2 300.5176381 0 -15.44888874 -1.01151516 0 -0.2032760027 -0.1419134215 0 0.3972210744 +23.525 1 -0.4923065861 0 -14.36922994 1.014976235 0 0.7612321764 0.1349686458 0 0.1012264843 +23.525 2 300.4923066 0 -15.45384636 -1.014976235 0 -0.1933283443 -0.1349686458 0 0.3985802355 +23.550 1 -0.4668907277 0 -14.35016805 1.018263399 0 0.7636975496 0.1280007439 0 0.09600055794 +23.550 2 300.4668907 0 -15.45855488 -1.018263399 0 -0.18334756 -0.1280007439 0 0.3998711019 +23.575 1 -0.44139487 0 -14.33104615 1.02137609 0 0.7660320672 0.1210109098 0 0.09075818233 +23.575 2 300.4413949 0 -15.46301348 -1.02137609 0 -0.1733353601 -0.1210109098 0 0.4010934525 +23.600 1 -0.4158233816 0 -14.31186754 1.024313772 0 0.7682353291 0.114000341 0 0.08550025578 +23.600 2 300.4158234 0 -15.4672214 -1.024313772 0 -0.1632934601 -0.114000341 0 0.4022470777 +23.625 1 -0.390180644 0 -14.29263548 1.027075944 0 0.7703069579 0.1069702389 0 0.0802276792 +23.625 2 300.3901806 0 -15.47117792 -1.027075944 0 -0.1532235806 -0.1069702389 0 0.40333178 +23.650 1 -0.364471051 0 -14.27335329 1.029662131 0 0.7722465986 0.09992180802 0 0.07494135602 +23.650 2 300.3644711 0 -15.47488236 -1.029662131 0 -0.143127447 -0.09992180802 0 0.4043473735 +23.675 1 -0.3386990077 0 -14.25402426 1.032071892 0 0.7740539187 0.09285625603 0 0.06964219202 +23.675 2 300.338699 0 -15.47833409 -1.032071892 0 -0.1330067893 -0.09285625603 0 0.4052936841 +23.700 1 -0.3128689301 0 -14.2346517 1.034304812 0 0.7757286087 0.08577479359 0 0.06433109519 +23.700 2 300.3128689 0 -15.48153251 -1.034304812 0 -0.1228633415 -0.08577479359 0 0.4061705497 +23.725 1 -0.286985244 0 -14.21523893 1.036360509 0 0.7772703816 0.07867863408 0 0.05900897556 +23.725 2 300.2869852 0 -15.48447708 -1.036360509 0 -0.1126988418 -0.07867863408 0 0.4069778201 +23.750 1 -0.2610523844 0 -14.19578929 1.038238631 0 0.7786789732 0.0715689934 0 0.05367674505 +23.750 2 300.2610524 0 -15.48716729 -1.038238631 0 -0.1025150316 -0.0715689934 0 0.407715357 +23.775 1 -0.2350747949 0 -14.1763061 1.039938856 0 0.7799541422 0.06444708974 0 0.0483353173 +23.775 2 300.2350748 0 -15.48960269 -1.039938856 0 -0.09231365609 -0.06444708974 0 0.4083830339 +23.800 1 -0.2090569265 0 -14.15679269 1.041460893 0 0.7810956701 0.05731414339 0 0.04298560755 +23.800 2 300.2090569 0 -15.49178284 -1.041460893 0 -0.08209646307 -0.05731414339 0 0.4089807365 +23.825 1 -0.1830032373 0 -14.13725243 1.042804482 0 0.7821033612 0.05017137657 0 0.03762853243 +23.825 2 300.1830032 0 -15.49370739 -1.042804482 0 -0.07186520325 -0.05017137657 0 0.4095083623 +23.850 1 -0.1569181915 0 -14.11768864 1.043969391 0 0.782977043 0.04302001314 0 0.03226500985 +23.850 2 300.1569182 0 -15.495376 -1.043969391 0 -0.06162162969 -0.04302001314 0 0.409965821 +23.875 1 -0.1308062585 0 -14.09810469 1.044955421 0 0.7837165656 0.03586127845 0 0.02689595884 +23.875 2 300.1308063 0 -15.49678838 -1.044955421 0 -0.05136749758 -0.03586127845 0 0.4103530342 +23.900 1 -0.1046719125 0 -14.07850393 1.045762403 0 0.7843218025 0.02869639912 0 0.02152229934 +23.900 2 300.1046719 0 -15.4979443 -1.045762403 0 -0.04110456391 -0.02869639912 0 0.4106699355 +23.925 1 -0.07851963152 0 -14.05888972 1.0463902 0 0.7847926499 0.0215266028 0 0.0161449521 +23.925 2 300.0785196 0 -15.49884355 -1.0463902 0 -0.03083458719 -0.0215266028 0 0.4109164706 +23.950 1 -0.05235389662 0 -14.03926542 1.046838703 0 0.7851290271 0.01435311801 0 0.01076483851 +23.950 2 300.0523539 0 -15.49948599 -1.046838703 0 -0.02055932712 -0.01435311801 0 0.4110925973 +23.975 1 -0.02617919114 0 -14.01963439 1.047107835 0 0.7853308764 0.007177173892 0 0.005382880419 +23.975 2 300.0261792 0 -15.49987149 -1.047107835 0 -0.01028054432 -0.007177173892 0 0.4111982853 +24.000 1 -9.797174393e-16 0 -14 1.047197551 0 0.7853981634 2.685950986e-16 0 2.01446324e-16 +24.000 2 300 0 -15.5 -1.047197551 0 -3.366423714e-16 -3.357438733e-16 0 0.4112335167 +24.025 1 0.02617919114 0 -13.98036561 1.047107835 0 0.7853308764 -0.007177173892 0 -0.005382880419 +24.025 2 299.9738208 0 -15.49987149 -1.047107835 0 0.01028054432 0.007177173892 0 0.4111982853 +24.050 1 0.05235389662 0 -13.96073458 1.046838703 0 0.7851290271 -0.01435311801 0 -0.01076483851 +24.050 2 299.9476461 0 -15.49948599 -1.046838703 0 0.02055932712 0.01435311801 0 0.4110925973 +24.075 1 0.07851963152 0 -13.94111028 1.0463902 0 0.7847926499 -0.0215266028 0 -0.0161449521 +24.075 2 299.9214804 0 -15.49884355 -1.0463902 0 0.03083458719 0.0215266028 0 0.4109164706 +24.100 1 0.1046719125 0 -13.92149607 1.045762403 0 0.7843218025 -0.02869639912 0 -0.02152229934 +24.100 2 299.8953281 0 -15.4979443 -1.045762403 0 0.04110456391 0.02869639912 0 0.4106699355 +24.125 1 0.1308062585 0 -13.90189531 1.044955421 0 0.7837165656 -0.03586127845 0 -0.02689595884 +24.125 2 299.8691937 0 -15.49678838 -1.044955421 0 0.05136749758 0.03586127845 0 0.4103530342 +24.150 1 0.1569181915 0 -13.88231136 1.043969391 0 0.782977043 -0.04302001314 0 -0.03226500985 +24.150 2 299.8430818 0 -15.495376 -1.043969391 0 0.06162162969 0.04302001314 0 0.409965821 +24.175 1 0.1830032373 0 -13.86274757 1.042804482 0 0.7821033612 -0.05017137657 0 -0.03762853243 +24.175 2 299.8169968 0 -15.49370739 -1.042804482 0 0.07186520325 0.05017137657 0 0.4095083623 +24.200 1 0.2090569265 0 -13.84320731 1.041460893 0 0.7810956701 -0.05731414339 0 -0.04298560755 +24.200 2 299.7909431 0 -15.49178284 -1.041460893 0 0.08209646307 0.05731414339 0 0.4089807365 +24.225 1 0.2350747949 0 -13.8236939 1.039938856 0 0.7799541422 -0.06444708974 0 -0.0483353173 +24.225 2 299.7649252 0 -15.48960269 -1.039938856 0 0.09231365609 0.06444708974 0 0.4083830339 +24.250 1 0.2610523844 0 -13.80421071 1.038238631 0 0.7786789732 -0.0715689934 0 -0.05367674505 +24.250 2 299.7389476 0 -15.48716729 -1.038238631 0 0.1025150316 0.0715689934 0 0.407715357 +24.275 1 0.286985244 0 -13.78476107 1.036360509 0 0.7772703816 -0.07867863408 0 -0.05900897556 +24.275 2 299.7130148 0 -15.48447708 -1.036360509 0 0.1126988418 0.07867863408 0 0.4069778201 +24.300 1 0.3128689301 0 -13.7653483 1.034304812 0 0.7757286087 -0.08577479359 0 -0.06433109519 +24.300 2 299.6871311 0 -15.48153251 -1.034304812 0 0.1228633415 0.08577479359 0 0.4061705497 +24.325 1 0.3386990077 0 -13.74597574 1.032071892 0 0.7740539187 -0.09285625603 0 -0.06964219202 +24.325 2 299.661301 0 -15.47833409 -1.032071892 0 0.1330067893 0.09285625603 0 0.4052936841 +24.350 1 0.364471051 0 -13.72664671 1.029662131 0 0.7722465986 -0.09992180802 0 -0.07494135602 +24.350 2 299.6355289 0 -15.47488236 -1.029662131 0 0.143127447 0.09992180802 0 0.4043473735 +24.375 1 0.390180644 0 -13.70736452 1.027075944 0 0.7703069579 -0.1069702389 0 -0.0802276792 +24.375 2 299.6098194 0 -15.47117792 -1.027075944 0 0.1532235806 0.1069702389 0 0.40333178 +24.400 1 0.4158233816 0 -13.68813246 1.024313772 0 0.7682353291 -0.114000341 0 -0.08550025578 +24.400 2 299.5841766 0 -15.4672214 -1.024313772 0 0.1632934601 0.114000341 0 0.4022470777 +24.425 1 0.44139487 0 -13.66895385 1.02137609 0 0.7660320672 -0.1210109098 0 -0.09075818233 +24.425 2 299.5586051 0 -15.46301348 -1.02137609 0 0.1733353601 0.1210109098 0 0.4010934525 +24.450 1 0.4668907277 0 -13.64983195 1.018263399 0 0.7636975496 -0.1280007439 0 -0.09600055794 +24.450 2 299.5331093 0 -15.45855488 -1.018263399 0 0.18334756 0.1280007439 0 0.3998711019 +24.475 1 0.4923065861 0 -13.63077006 1.014976235 0 0.7612321764 -0.1349686458 0 -0.1012264843 +24.475 2 299.5076934 0 -15.45384636 -1.014976235 0 0.1933283443 0.1349686458 0 0.3985802355 +24.500 1 0.5176380902 0 -13.61177143 1.01151516 0 0.7586363699 -0.1419134215 0 -0.1064350661 +24.500 2 299.4823619 0 -15.44888874 -1.01151516 0 0.2032760027 0.1419134215 0 0.3972210744 +24.525 1 0.5428808997 0 -13.59283933 1.007880767 0 0.7559105751 -0.148833881 0 -0.1116254108 +24.525 2 299.4571191 0 -15.44368285 -1.007880767 0 0.2131888308 0.148833881 0 0.3957938516 +24.550 1 0.5680306894 0 -13.57397698 1.004073678 0 0.7530552588 -0.1557288387 0 -0.116796629 +24.550 2 299.4319693 0 -15.4382296 -1.004073678 0 0.2230651301 0.1557288387 0 0.3942988115 +24.575 1 0.59308315 0 -13.55518764 1.000094547 0 0.7500709104 -0.162597113 0 -0.1219478347 +24.575 2 299.4069169 0 -15.43252992 -1.000094547 0 0.2329032084 0.162597113 0 0.3927362103 +24.600 1 0.6180339887 0 -13.53647451 0.9959440549 0 0.7469580412 -0.1694375271 0 -0.1270781453 +24.600 2 299.381966 0 -15.42658477 -0.9959440549 0 0.2427013798 0.1694375271 0 0.3911063158 +24.625 1 0.6428789306 0 -13.5178408 0.9916229128 0 0.7437171846 -0.176248909 0 -0.1321866817 +24.625 2 299.3571211 0 -15.42039519 -0.9916229128 0 0.2524579657 0.176248909 0 0.3894094072 +24.650 1 0.6676137185 0 -13.49928971 0.9871318611 0 0.7403488958 -0.1830300915 0 -0.1372725686 +24.650 2 299.3323863 0 -15.41396224 -0.9871318611 0 0.2621712942 0.1830300915 0 0.3876457754 +24.675 1 0.6922341142 0 -13.48082441 0.9824716695 0 0.7368537521 -0.1897799128 0 -0.1423349346 +24.675 2 299.3077659 0 -15.407287 -0.9824716695 0 0.2718397009 0.1897799128 0 0.3858157224 +24.700 1 0.7167358991 0 -13.46244808 0.9776431365 0 0.7332323524 -0.1964972162 0 -0.1473729122 +24.700 2 299.2832641 0 -15.40037064 -0.9776431365 0 0.2814615294 0.1964972162 0 0.3839195619 +24.725 1 0.741114875 0 -13.44416384 0.9726470893 0 0.729485317 -0.2031808509 0 -0.1523856382 +24.725 2 299.2588851 0 -15.39321433 -0.9726470893 0 0.2910351309 0.2031808509 0 0.3819576188 +24.750 1 0.7653668647 0 -13.42597485 0.967484384 0 0.725613288 -0.2098296716 0 -0.1573722537 +24.750 2 299.2346331 0 -15.3858193 -0.967484384 0 0.3005588649 0.2098296716 0 0.3799302292 +24.775 1 0.7894877128 0 -13.40788422 0.9621559053 0 0.721616929 -0.216442539 0 -0.1623319043 +24.775 2 299.2105123 0 -15.37818682 -0.9621559053 0 0.3100310998 0.216442539 0 0.3778377405 +24.800 1 0.8134732862 0 -13.38989504 0.9566625662 0 0.7174969246 -0.2230183201 0 -0.1672637401 +24.800 2 299.1865267 0 -15.37031819 -0.9566625662 0 0.3194502125 0.2230183201 0 0.3756805112 +24.825 1 0.8373194751 0 -13.37201039 0.9510053078 0 0.7132539808 -0.2295558882 0 -0.1721669162 +24.825 2 299.1626805 0 -15.36221476 -0.9510053078 0 0.328814589 0.2295558882 0 0.3734589111 +24.850 1 0.8610221936 0 -13.35423335 0.9451850995 0 0.7088888246 -0.2360541231 0 -0.1770405923 +24.850 2 299.1389778 0 -15.35387793 -0.9451850995 0 0.3381226248 0.2360541231 0 0.3711733206 +24.875 1 0.8845773804 0 -13.33656696 0.9392029387 0 0.704402204 -0.2425119113 0 -0.1818839335 +24.875 2 299.1154226 0 -15.34530911 -0.9392029387 0 0.347372725 0.2425119113 0 0.3688241315 +24.900 1 0.9079809995 0 -13.31901425 0.9330598502 0 0.6997948877 -0.2489281463 0 -0.1866961098 +24.900 2 299.092019 0 -15.33650979 -0.9330598502 0 0.3565633047 0.2489281463 0 0.3664117464 +24.925 1 0.9312290407 0 -13.30157822 0.9267568868 0 0.6950676651 -0.2553017288 0 -0.1914762966 +24.925 2 299.068771 0 -15.32748146 -0.9267568868 0 0.3656927891 0.2553017288 0 0.3639365784 +24.950 1 0.9543175205 0 -13.28426186 0.9202951283 0 0.6902213462 -0.2616315667 0 -0.196223675 +24.950 2 299.0456825 0 -15.31822567 -0.9202951283 0 0.374759614 0.2616315667 0 0.3613990518 +24.975 1 0.977242483 0 -13.26706814 0.913675682 0 0.6852567615 -0.2679165753 0 -0.2009374315 +24.975 2 299.0227575 0 -15.30874401 -0.913675682 0 0.3837622257 0.2679165753 0 0.3587996013 +25.000 1 1 0 -13.25 0.9068996821 0 0.6801747616 -0.2741556778 0 -0.2056167584 +25.000 2 299 0 -15.29903811 -0.9068996821 0 0.3926990817 0.2741556778 0 0.3561386724 +25.025 1 1.022586172 0 -13.23306037 0.8999682896 0 0.6749762172 -0.2803478051 0 -0.2102608539 +25.025 2 298.9774138 0 -15.28910962 -0.8999682896 0 0.4015686508 0.2803478051 0 0.3534167209 +25.050 1 1.044997129 0 -13.21625215 0.8928826922 0 0.6696620191 -0.2864918963 0 -0.2148689222 +25.050 2 298.9550029 0 -15.27896025 -0.8928826922 0 0.4103694131 0.2864918963 0 0.3506342133 +25.075 1 1.067229032 0 -13.19957823 0.8856441039 0 0.6642330779 -0.2925868986 0 -0.2194401739 +25.075 2 298.932771 0 -15.26859173 -0.8856441039 0 0.4190998608 0.2925868986 0 0.3477916263 +25.100 1 1.08927807 0 -13.18304145 0.878253765 0 0.6586903238 -0.2986317676 0 -0.2239738257 +25.100 2 298.9107219 0 -15.25800585 -0.878253765 0 0.4277584978 0.2986317676 0 0.344889447 +25.125 1 1.111140466 0 -13.16664465 0.8707129419 0 0.6530347064 -0.3046254676 0 -0.2284691007 +25.125 2 298.8888595 0 -15.24720442 -0.8707129419 0 0.4363438407 0.3046254676 0 0.3419281727 +25.150 1 1.132812474 0 -13.15039064 0.8630229266 0 0.647267195 -0.3105669716 0 -0.2329252287 +25.150 2 298.8671875 0 -15.23618928 -0.8630229266 0 0.4448544182 0.3105669716 0 0.3389083108 +25.175 1 1.15429038 0 -13.13428221 0.8551850368 0 0.6413887776 -0.3164552615 0 -0.2373414462 +25.175 2 298.8457096 0 -15.22496233 -0.8551850368 0 0.4532887723 0.3164552615 0 0.3358303786 +25.200 1 1.175570505 0 -13.11832212 0.8472006154 0 0.6354004615 -0.3222893285 0 -0.2417169964 +25.200 2 298.8244295 0 -15.21352549 -0.8472006154 0 0.4616454576 0.3222893285 0 0.3326949037 +25.225 1 1.196649201 0 -13.1025131 0.8390710305 0 0.6293032729 -0.3280681728 0 -0.2460511296 +25.225 2 298.8033508 0 -15.20188072 -0.8390710305 0 0.4699230424 0.3280681728 0 0.3295024232 +25.250 1 1.217522858 0 -13.08685786 0.8307976752 0 0.6230982564 -0.3337908044 0 -0.2503431033 +25.250 2 298.7824771 0 -15.19003001 -0.8307976752 0 0.4781201083 0.3337908044 0 0.3262534841 +25.275 1 1.238187899 0 -13.07135908 0.8223819669 0 0.6167864752 -0.3394562426 0 -0.2545921819 +25.275 2 298.7618121 0 -15.1779754 -0.8223819669 0 0.4862352508 0.3394562426 0 0.3229486432 +25.300 1 1.258640782 0 -13.05601941 0.8138253478 0 0.6103690108 -0.3450635167 0 -0.2587976376 +25.300 2 298.7413592 0 -15.16571894 -0.8138253478 0 0.4942670793 0.3450635167 0 0.3195884667 +25.325 1 1.278878004 0 -13.0408415 0.8051292838 0 0.6038469629 -0.350611666 0 -0.2629587495 +25.325 2 298.721122 0 -15.15326275 -0.8051292838 0 0.5022142178 0.350611666 0 0.3161735304 +25.350 1 1.298896097 0 -13.02582793 0.7962952651 0 0.5972214488 -0.3560997398 0 -0.2670748048 +25.350 2 298.7011039 0 -15.14060895 -0.7962952651 0 0.5100753044 0.3560997398 0 0.3127044194 +25.375 1 1.31869163 0 -13.01098128 0.7873248053 0 0.590493604 -0.3615267977 0 -0.2711450983 +25.375 2 298.6813084 0 -15.12775971 -0.7873248053 0 0.5178489922 0.3615267977 0 0.309181728 +25.400 1 1.338261213 0 -12.99630409 0.7782194414 0 0.5836645811 -0.3668919099 0 -0.2751689324 +25.400 2 298.6617388 0 -15.11471724 -0.7782194414 0 0.5255339493 0.3668919099 0 0.30560606 +25.425 1 1.357601491 0 -12.98179888 0.7689807337 0 0.5767355503 -0.372194157 0 -0.2791456177 +25.425 2 298.6423985 0 -15.10148376 -0.7689807337 0 0.5331288589 0.372194157 0 0.301978028 +25.450 1 1.376709151 0 -12.96746814 0.759610265 0 0.5697076988 -0.3774326305 0 -0.2830744729 +25.450 2 298.6232908 0 -15.08806156 -0.759610265 0 0.5406324195 0.3774326305 0 0.2982982535 +25.475 1 1.39558092 0 -12.95331431 0.7501096411 0 0.5625822308 -0.382606433 0 -0.2869548247 +25.475 2 298.6044191 0 -15.07445292 -0.7501096411 0 0.5480433456 0.382606433 0 0.2945673672 +25.500 1 1.414213562 0 -12.93933983 0.7404804897 0 0.5553603673 -0.3877146778 0 -0.2907860083 +25.500 2 298.5857864 0 -15.06066017 -0.7404804897 0 0.5553603673 0.3877146778 0 0.2907860083 +25.525 1 1.432603887 0 -12.92554708 0.7307244608 0 0.5480433456 -0.3927564896 0 -0.2945673672 +25.525 2 298.5673961 0 -15.04668569 -0.7307244608 0 0.5625822308 0.3927564896 0 0.2869548247 +25.550 1 1.450748742 0 -12.91193844 0.720843226 0 0.5406324195 -0.3977310047 0 -0.2982982535 +25.550 2 298.5492513 0 -15.03253186 -0.720843226 0 0.5697076988 0.3977310047 0 0.2830744729 +25.575 1 1.468645019 0 -12.89851624 0.7108384785 0 0.5331288589 -0.4026373706 0 -0.301978028 +25.575 2 298.531355 0 -15.01820112 -0.7108384785 0 0.5767355503 0.4026373706 0 0.2791456177 +25.600 1 1.486289651 0 -12.88528276 0.7007119324 0 0.5255339493 -0.4074747467 0 -0.30560606 +25.600 2 298.5137103 0 -15.00369591 -0.7007119324 0 0.5836645811 0.4074747467 0 0.2751689324 +25.625 1 1.503679615 0 -12.87224029 0.690465323 0 0.5178489922 -0.412242304 0 -0.309181728 +25.625 2 298.4963204 0 -14.98901872 -0.690465323 0 0.590493604 0.412242304 0 0.2711450983 +25.650 1 1.520811931 0 -12.85939105 0.6801004058 0 0.5100753044 -0.4169392258 0 -0.3127044194 +25.650 2 298.4791881 0 -14.97417207 -0.6801004058 0 0.5972214488 0.4169392258 0 0.2670748048 +25.675 1 1.537683664 0 -12.84673725 0.669618957 0 0.5022142178 -0.4215647072 0 -0.3161735304 +25.675 2 298.4623163 0 -14.9591585 -0.669618957 0 0.6038469629 0.4215647072 0 0.2629587495 +25.700 1 1.554291923 0 -12.83428106 0.6590227724 0 0.4942670793 -0.4261179556 0 -0.3195884667 +25.700 2 298.4457081 0 -14.94398059 -0.6590227724 0 0.6103690108 0.4261179556 0 0.2587976376 +25.725 1 1.570633862 0 -12.8220246 0.6483136677 0 0.4862352508 -0.430598191 0 -0.3229486432 +25.725 2 298.4293661 0 -14.92864092 -0.6483136677 0 0.6167864752 0.430598191 0 0.2545921819 +25.750 1 1.586706681 0 -12.80996999 0.6374934777 0 0.4781201083 -0.4350046455 0 -0.3262534841 +25.750 2 298.4132933 0 -14.91314214 -0.6374934777 0 0.6230982564 0.4350046455 0 0.2503431033 +25.775 1 1.602507625 0 -12.79811928 0.6265640565 0 0.4699230424 -0.4393365642 0 -0.3295024232 +25.775 2 298.3974924 0 -14.8974869 -0.6265640565 0 0.6293032729 0.4393365642 0 0.2460511296 +25.800 1 1.618033989 0 -12.78647451 0.6155272768 0 0.4616454576 -0.4435932049 0 -0.3326949037 +25.800 2 298.381966 0 -14.88167788 -0.6155272768 0 0.6354004615 0.4435932049 0 0.2417169964 +25.825 1 1.63328311 0 -12.77503767 0.6043850297 0 0.4532887723 -0.4477738382 0 -0.3358303786 +25.825 2 298.3667169 0 -14.86571779 -0.6043850297 0 0.6413887776 0.4477738382 0 0.2373414462 +25.850 1 1.648252377 0 -12.76381072 0.5931392243 0 0.4448544182 -0.4518777477 0 -0.3389083108 +25.850 2 298.3517476 0 -14.84960936 -0.5931392243 0 0.647267195 0.4518777477 0 0.2329252287 +25.875 1 1.662939225 0 -12.75279558 0.5817917875 0 0.4363438407 -0.4559042303 0 -0.3419281727 +25.875 2 298.3370608 0 -14.83335535 -0.5817917875 0 0.6530347064 0.4559042303 0 0.2284691007 +25.900 1 1.677341136 0 -12.74199415 0.5703446638 0 0.4277584978 -0.459852596 0 -0.344889447 +25.900 2 298.3226589 0 -14.81695855 -0.5703446638 0 0.6586903238 0.459852596 0 0.2239738257 +25.925 1 1.691455643 0 -12.73140827 0.5587998143 0 0.4190998608 -0.4637221684 0 -0.3477916263 +25.925 2 298.3085444 0 -14.80042177 -0.5587998143 0 0.6642330779 0.4637221684 0 0.2194401739 +25.950 1 1.705280329 0 -12.72103975 0.5471592175 0 0.4103694131 -0.4675122844 0 -0.3506342133 +25.950 2 298.2947197 0 -14.78374785 -0.5471592175 0 0.6696620191 0.4675122844 0 0.2148689222 +25.975 1 1.718812823 0 -12.71089038 0.5354248677 0 0.4015686508 -0.4712222945 0 -0.3534167209 +25.975 2 298.2811872 0 -14.76693963 -0.5354248677 0 0.6749762172 0.4712222945 0 0.2102608539 +26.000 1 1.732050808 0 -12.70096189 0.5235987756 0 0.3926990817 -0.4748515631 0 -0.3561386724 +26.000 2 298.2679492 0 -14.75 -0.5235987756 0 0.6801747616 0.4748515631 0 0.2056167584 +26.025 1 1.744992014 0 -12.69125599 0.5116829676 0 0.3837622257 -0.4783994684 0 -0.3587996013 +26.025 2 298.255008 0 -14.73293186 -0.5116829676 0 0.6852567615 0.4783994684 0 0.2009374315 +26.050 1 1.757634225 0 -12.68177433 0.4996794853 0 0.374759614 -0.4818654024 0 -0.3613990518 +26.050 2 298.2423658 0 -14.71573814 -0.4996794853 0 0.6902213462 0.4818654024 0 0.196223675 +26.075 1 1.769975275 0 -12.67251854 0.4875903855 0 0.3656927891 -0.4852487712 0 -0.3639365784 +26.075 2 298.2300247 0 -14.69842178 -0.4875903855 0 0.6950676651 0.4852487712 0 0.1914762966 +26.100 1 1.782013048 0 -12.66349021 0.4754177396 0 0.3565633047 -0.4885489951 0 -0.3664117464 +26.100 2 298.217987 0 -14.68098575 -0.4754177396 0 0.6997948877 0.4885489951 0 0.1866961098 +26.125 1 1.793745483 0 -12.65469089 0.4631636333 0 0.347372725 -0.4917655087 0 -0.3688241315 +26.125 2 298.2062545 0 -14.66343304 -0.4631636333 0 0.704402204 0.4917655087 0 0.1818839335 +26.150 1 1.805170569 0 -12.64612207 0.4508301663 0 0.3381226248 -0.4948977608 0 -0.3711733206 +26.150 2 298.1948294 0 -14.64576665 -0.4508301663 0 0.7088888246 0.4948977608 0 0.1770405923 +26.175 1 1.816286348 0 -12.63778524 0.4384194519 0 0.328814589 -0.4979452147 0 -0.3734589111 +26.175 2 298.1837137 0 -14.62798961 -0.4384194519 0 0.7132539808 0.4979452147 0 0.1721669162 +26.200 1 1.827090915 0 -12.62968181 0.4259336166 0 0.3194502125 -0.5009073483 0 -0.3756805112 +26.200 2 298.1729091 0 -14.61010496 -0.4259336166 0 0.7174969246 0.5009073483 0 0.1672637401 +26.225 1 1.83758242 0 -12.62181318 0.4133747998 0 0.3100310998 -0.503783654 0 -0.3778377405 +26.225 2 298.1624176 0 -14.59211578 -0.4133747998 0 0.721616929 0.503783654 0 0.1623319043 +26.250 1 1.847759065 0 -12.6141807 0.4007451533 0 0.3005588649 -0.5065736389 0 -0.3799302292 +26.250 2 298.1522409 0 -14.57402515 -0.4007451533 0 0.725613288 0.5065736389 0 0.1573722537 +26.275 1 1.857619106 0 -12.60678567 0.3880468411 0 0.2910351309 -0.509276825 0 -0.3819576188 +26.275 2 298.1423809 0 -14.55583616 -0.3880468411 0 0.729485317 0.509276825 0 0.1523856382 +26.300 1 1.867160853 0 -12.59962936 0.3752820392 0 0.2814615294 -0.5118927492 0 -0.3839195619 +26.300 2 298.1328391 0 -14.53755192 -0.3752820392 0 0.7332323524 0.5118927492 0 0.1473729122 +26.325 1 1.876382672 0 -12.592713 0.3624529346 0 0.2718397009 -0.5144209632 0 -0.3858157224 +26.325 2 298.1236173 0 -14.51917559 -0.3624529346 0 0.7368537521 0.5144209632 0 0.1423349346 +26.350 1 1.885282982 0 -12.58603776 0.3495617256 0 0.2621712942 -0.5168610338 0 -0.3876457754 +26.350 2 298.114717 0 -14.50071029 -0.3495617256 0 0.7403488958 0.5168610338 0 0.1372725686 +26.375 1 1.893860259 0 -12.57960481 0.3366106209 0 0.2524579657 -0.519212543 0 -0.3894094072 +26.375 2 298.1061397 0 -14.4821592 -0.3366106209 0 0.7437171846 0.519212543 0 0.1321866817 +26.400 1 1.902113033 0 -12.57341523 0.3236018398 0 0.2427013798 -0.5214750877 0 -0.3911063158 +26.400 2 298.097887 0 -14.46352549 -0.3236018398 0 0.7469580412 0.5214750877 0 0.1270781453 +26.425 1 1.910039889 0 -12.56747008 0.3105376111 0 0.2329032084 -0.5236482804 0 -0.3927362103 +26.425 2 298.0899601 0 -14.44481236 -0.3105376111 0 0.7500709104 0.5236482804 0 0.1219478347 +26.450 1 1.91763947 0 -12.5617704 0.2974201735 0 0.2230651301 -0.5257317486 0 -0.3942988115 +26.450 2 298.0823605 0 -14.42602302 -0.2974201735 0 0.7530552588 0.5257317486 0 0.116796629 +26.475 1 1.924910473 0 -12.55631715 0.2842517744 0 0.2131888308 -0.5277251354 0 -0.3957938516 +26.475 2 298.0750895 0 -14.40716067 -0.2842517744 0 0.7559105751 0.5277251354 0 0.1116254108 +26.500 1 1.931851653 0 -12.55111126 0.2710346702 0 0.2032760027 -0.5296280992 0 -0.3972210744 +26.500 2 298.0681483 0 -14.38822857 -0.2710346702 0 0.7586363699 0.5296280992 0 0.1064350661 +26.525 1 1.938461819 0 -12.54615364 0.2577711257 0 0.1933283443 -0.531440314 0 -0.3985802355 +26.525 2 298.0615382 0 -14.36922994 -0.2577711257 0 0.7612321764 0.531440314 0 0.1012264843 +26.550 1 1.944739841 0 -12.54144512 0.2444634134 0 0.18334756 -0.5331614692 0 -0.3998711019 +26.550 2 298.0552602 0 -14.35016805 -0.2444634134 0 0.7636975496 0.5331614692 0 0.09600055794 +26.575 1 1.950684641 0 -12.53698652 0.2311138135 0 0.1733353601 -0.5347912699 0 -0.4010934525 +26.575 2 298.0493154 0 -14.33104615 -0.2311138135 0 0.7660320672 0.5347912699 0 0.09075818233 +26.600 1 1.956295201 0 -12.5327786 0.2177246135 0 0.1632934601 -0.536329437 0 -0.4022470777 +26.600 2 298.0437048 0 -14.31186754 -0.2177246135 0 0.7682353291 0.536329437 0 0.08550025578 +26.625 1 1.961570561 0 -12.52882208 0.2042981075 0 0.1532235806 -0.5377757067 0 -0.40333178 +26.625 2 298.0384294 0 -14.29263548 -0.2042981075 0 0.7703069579 0.5377757067 0 0.0802276792 +26.650 1 1.966509815 0 -12.52511764 0.190836596 0 0.143127447 -0.5391298313 0 -0.4043473735 +26.650 2 298.0334902 0 -14.27335329 -0.190836596 0 0.7722465986 0.5391298313 0 0.07494135602 +26.675 1 1.971112118 0 -12.52166591 0.1773423857 0 0.1330067893 -0.5403915788 0 -0.4052936841 +26.675 2 298.0288879 0 -14.25402426 -0.1773423857 0 0.7740539187 0.5403915788 0 0.06964219202 +26.700 1 1.975376681 0 -12.51846749 0.1638177887 0 0.1228633415 -0.541560733 0 -0.4061705497 +26.700 2 298.0246233 0 -14.2346517 -0.1638177887 0 0.7757286087 0.541560733 0 0.06433109519 +26.725 1 1.979302774 0 -12.51552292 0.1502651224 0 0.1126988418 -0.5426370935 0 -0.4069778201 +26.725 2 298.0206972 0 -14.21523893 -0.1502651224 0 0.7772703816 0.5426370935 0 0.05900897556 +26.750 1 1.982889723 0 -12.51283271 0.1366867089 0 0.1025150316 -0.543620476 0 -0.407715357 +26.750 2 298.0171103 0 -14.19578929 -0.1366867089 0 0.7786789732 0.543620476 0 0.05367674505 +26.775 1 1.986136914 0 -12.51039731 0.1230848748 0 0.09231365609 -0.5445107119 0 -0.4083830339 +26.775 2 298.0138631 0 -14.1763061 -0.1230848748 0 0.7799541422 0.5445107119 0 0.0483353173 +26.800 1 1.989043791 0 -12.50821716 0.1094619508 0 0.08209646307 -0.5453076486 0 -0.4089807365 +26.800 2 298.0109562 0 -14.15679269 -0.1094619508 0 0.7810956701 0.5453076486 0 0.04298560755 +26.825 1 1.991609855 0 -12.50629261 0.09582027099 0 0.07186520325 -0.5460111498 0 -0.4095083623 +26.825 2 298.0083901 0 -14.13725243 -0.09582027099 0 0.7821033612 0.5460111498 0 0.03762853243 +26.850 1 1.993834667 0 -12.504624 0.08216217292 0 0.06162162969 -0.5466210947 0 -0.409965821 +26.850 2 298.0061653 0 -14.11768864 -0.08216217292 0 0.782977043 0.5466210947 0 0.03226500985 +26.875 1 1.995717846 0 -12.50321162 0.06848999677 0 0.05136749758 -0.5471373789 0 -0.4103530342 +26.875 2 298.0042822 0 -14.09810469 -0.06848999677 0 0.7837165656 0.5471373789 0 0.02689595884 +26.900 1 1.99725907 0 -12.5020557 0.05480608522 0 0.04110456391 -0.547559914 0 -0.4106699355 +26.900 2 298.0027409 0 -14.07850393 -0.05480608522 0 0.7843218025 0.547559914 0 0.02152229934 +26.925 1 1.998458072 0 -12.50115645 0.04111278292 0 0.03083458719 -0.5478886274 0 -0.4109164706 +26.925 2 298.0015419 0 -14.05888972 -0.04111278292 0 0.7847926499 0.5478886274 0 0.0161449521 +26.950 1 1.99931465 0 -12.50051401 0.02741243617 0 0.02055932712 -0.548123463 0 -0.4110925973 +26.950 2 298.0006854 0 -14.03926542 -0.02741243617 0 0.7851290271 0.548123463 0 0.01076483851 +26.975 1 1.999828655 0 -12.50012851 0.01370739243 0 0.01028054432 -0.5482643805 0 -0.4111982853 +26.975 2 298.0001713 0 -14.01963439 -0.01370739243 0 0.7853308764 0.5482643805 0 0.005382880419 +27.000 1 2 0 -12.5 2.43729774e-15 0 1.827973305e-15 -0.5483113556 0 -0.4112335167 +27.000 2 298 0 -14 -2.565542453e-15 0 0.7853981634 0.5483113556 0 9.31943794e-16 +27.025 1 1.999828655 0 -12.50012851 -0.01370739243 0 -0.01028054432 -0.5482643805 0 -0.4111982853 +27.025 2 298.0001713 0 -13.98036561 0.01370739243 0 0.7853308764 0.5482643805 0 -0.005382880419 +27.050 1 1.99931465 0 -12.50051401 -0.02741243617 0 -0.02055932712 -0.548123463 0 -0.4110925973 +27.050 2 298.0006854 0 -13.96073458 0.02741243617 0 0.7851290271 0.548123463 0 -0.01076483851 +27.075 1 1.998458072 0 -12.50115645 -0.04111278292 0 -0.03083458719 -0.5478886274 0 -0.4109164706 +27.075 2 298.0015419 0 -13.94111028 0.04111278292 0 0.7847926499 0.5478886274 0 -0.0161449521 +27.100 1 1.99725907 0 -12.5020557 -0.05480608522 0 -0.04110456391 -0.547559914 0 -0.4106699355 +27.100 2 298.0027409 0 -13.92149607 0.05480608522 0 0.7843218025 0.547559914 0 -0.02152229934 +27.125 1 1.995717846 0 -12.50321162 -0.06848999677 0 -0.05136749758 -0.5471373789 0 -0.4103530342 +27.125 2 298.0042822 0 -13.90189531 0.06848999677 0 0.7837165656 0.5471373789 0 -0.02689595884 +27.150 1 1.993834667 0 -12.504624 -0.08216217292 0 -0.06162162969 -0.5466210947 0 -0.409965821 +27.150 2 298.0061653 0 -13.88231136 0.08216217292 0 0.782977043 0.5466210947 0 -0.03226500985 +27.175 1 1.991609855 0 -12.50629261 -0.09582027099 0 -0.07186520325 -0.5460111498 0 -0.4095083623 +27.175 2 298.0083901 0 -13.86274757 0.09582027099 0 0.7821033612 0.5460111498 0 -0.03762853243 +27.200 1 1.989043791 0 -12.50821716 -0.1094619508 0 -0.08209646307 -0.5453076486 0 -0.4089807365 +27.200 2 298.0109562 0 -13.84320731 0.1094619508 0 0.7810956701 0.5453076486 0 -0.04298560755 +27.225 1 1.986136914 0 -12.51039731 -0.1230848748 0 -0.09231365609 -0.5445107119 0 -0.4083830339 +27.225 2 298.0138631 0 -13.8236939 0.1230848748 0 0.7799541422 0.5445107119 0 -0.0483353173 +27.250 1 1.982889723 0 -12.51283271 -0.1366867089 0 -0.1025150316 -0.543620476 0 -0.407715357 +27.250 2 298.0171103 0 -13.80421071 0.1366867089 0 0.7786789732 0.543620476 0 -0.05367674505 +27.275 1 1.979302774 0 -12.51552292 -0.1502651224 0 -0.1126988418 -0.5426370935 0 -0.4069778201 +27.275 2 298.0206972 0 -13.78476107 0.1502651224 0 0.7772703816 0.5426370935 0 -0.05900897556 +27.300 1 1.975376681 0 -12.51846749 -0.1638177887 0 -0.1228633415 -0.541560733 0 -0.4061705497 +27.300 2 298.0246233 0 -13.7653483 0.1638177887 0 0.7757286087 0.541560733 0 -0.06433109519 +27.325 1 1.971112118 0 -12.52166591 -0.1773423857 0 -0.1330067893 -0.5403915788 0 -0.4052936841 +27.325 2 298.0288879 0 -13.74597574 0.1773423857 0 0.7740539187 0.5403915788 0 -0.06964219202 +27.350 1 1.966509815 0 -12.52511764 -0.190836596 0 -0.143127447 -0.5391298313 0 -0.4043473735 +27.350 2 298.0334902 0 -13.72664671 0.190836596 0 0.7722465986 0.5391298313 0 -0.07494135602 +27.375 1 1.961570561 0 -12.52882208 -0.2042981075 0 -0.1532235806 -0.5377757067 0 -0.40333178 +27.375 2 298.0384294 0 -13.70736452 0.2042981075 0 0.7703069579 0.5377757067 0 -0.0802276792 +27.400 1 1.956295201 0 -12.5327786 -0.2177246135 0 -0.1632934601 -0.536329437 0 -0.4022470777 +27.400 2 298.0437048 0 -13.68813246 0.2177246135 0 0.7682353291 0.536329437 0 -0.08550025578 +27.425 1 1.950684641 0 -12.53698652 -0.2311138135 0 -0.1733353601 -0.5347912699 0 -0.4010934525 +27.425 2 298.0493154 0 -13.66895385 0.2311138135 0 0.7660320672 0.5347912699 0 -0.09075818233 +27.450 1 1.944739841 0 -12.54144512 -0.2444634134 0 -0.18334756 -0.5331614692 0 -0.3998711019 +27.450 2 298.0552602 0 -13.64983195 0.2444634134 0 0.7636975496 0.5331614692 0 -0.09600055794 +27.475 1 1.938461819 0 -12.54615364 -0.2577711257 0 -0.1933283443 -0.531440314 0 -0.3985802355 +27.475 2 298.0615382 0 -13.63077006 0.2577711257 0 0.7612321764 0.531440314 0 -0.1012264843 +27.500 1 1.931851653 0 -12.55111126 -0.2710346702 0 -0.2032760027 -0.5296280992 0 -0.3972210744 +27.500 2 298.0681483 0 -13.61177143 0.2710346702 0 0.7586363699 0.5296280992 0 -0.1064350661 +27.525 1 1.924910473 0 -12.55631715 -0.2842517744 0 -0.2131888308 -0.5277251354 0 -0.3957938516 +27.525 2 298.0750895 0 -13.59283933 0.2842517744 0 0.7559105751 0.5277251354 0 -0.1116254108 +27.550 1 1.91763947 0 -12.5617704 -0.2974201735 0 -0.2230651301 -0.5257317486 0 -0.3942988115 +27.550 2 298.0823605 0 -13.57397698 0.2974201735 0 0.7530552588 0.5257317486 0 -0.116796629 +27.575 1 1.910039889 0 -12.56747008 -0.3105376111 0 -0.2329032084 -0.5236482804 0 -0.3927362103 +27.575 2 298.0899601 0 -13.55518764 0.3105376111 0 0.7500709104 0.5236482804 0 -0.1219478347 +27.600 1 1.902113033 0 -12.57341523 -0.3236018398 0 -0.2427013798 -0.5214750877 0 -0.3911063158 +27.600 2 298.097887 0 -13.53647451 0.3236018398 0 0.7469580412 0.5214750877 0 -0.1270781453 +27.625 1 1.893860259 0 -12.57960481 -0.3366106209 0 -0.2524579657 -0.519212543 0 -0.3894094072 +27.625 2 298.1061397 0 -13.5178408 0.3366106209 0 0.7437171846 0.519212543 0 -0.1321866817 +27.650 1 1.885282982 0 -12.58603776 -0.3495617256 0 -0.2621712942 -0.5168610338 0 -0.3876457754 +27.650 2 298.114717 0 -13.49928971 0.3495617256 0 0.7403488958 0.5168610338 0 -0.1372725686 +27.675 1 1.876382672 0 -12.592713 -0.3624529346 0 -0.2718397009 -0.5144209632 0 -0.3858157224 +27.675 2 298.1236173 0 -13.48082441 0.3624529346 0 0.7368537521 0.5144209632 0 -0.1423349346 +27.700 1 1.867160853 0 -12.59962936 -0.3752820392 0 -0.2814615294 -0.5118927492 0 -0.3839195619 +27.700 2 298.1328391 0 -13.46244808 0.3752820392 0 0.7332323524 0.5118927492 0 -0.1473729122 +27.725 1 1.857619106 0 -12.60678567 -0.3880468411 0 -0.2910351309 -0.509276825 0 -0.3819576188 +27.725 2 298.1423809 0 -13.44416384 0.3880468411 0 0.729485317 0.509276825 0 -0.1523856382 +27.750 1 1.847759065 0 -12.6141807 -0.4007451533 0 -0.3005588649 -0.5065736389 0 -0.3799302292 +27.750 2 298.1522409 0 -13.42597485 0.4007451533 0 0.725613288 0.5065736389 0 -0.1573722537 +27.775 1 1.83758242 0 -12.62181318 -0.4133747998 0 -0.3100310998 -0.503783654 0 -0.3778377405 +27.775 2 298.1624176 0 -13.40788422 0.4133747998 0 0.721616929 0.503783654 0 -0.1623319043 +27.800 1 1.827090915 0 -12.62968181 -0.4259336166 0 -0.3194502125 -0.5009073483 0 -0.3756805112 +27.800 2 298.1729091 0 -13.38989504 0.4259336166 0 0.7174969246 0.5009073483 0 -0.1672637401 +27.825 1 1.816286348 0 -12.63778524 -0.4384194519 0 -0.328814589 -0.4979452147 0 -0.3734589111 +27.825 2 298.1837137 0 -13.37201039 0.4384194519 0 0.7132539808 0.4979452147 0 -0.1721669162 +27.850 1 1.805170569 0 -12.64612207 -0.4508301663 0 -0.3381226248 -0.4948977608 0 -0.3711733206 +27.850 2 298.1948294 0 -13.35423335 0.4508301663 0 0.7088888246 0.4948977608 0 -0.1770405923 +27.875 1 1.793745483 0 -12.65469089 -0.4631636333 0 -0.347372725 -0.4917655087 0 -0.3688241315 +27.875 2 298.2062545 0 -13.33656696 0.4631636333 0 0.704402204 0.4917655087 0 -0.1818839335 +27.900 1 1.782013048 0 -12.66349021 -0.4754177396 0 -0.3565633047 -0.4885489951 0 -0.3664117464 +27.900 2 298.217987 0 -13.31901425 0.4754177396 0 0.6997948877 0.4885489951 0 -0.1866961098 +27.925 1 1.769975275 0 -12.67251854 -0.4875903855 0 -0.3656927891 -0.4852487712 0 -0.3639365784 +27.925 2 298.2300247 0 -13.30157822 0.4875903855 0 0.6950676651 0.4852487712 0 -0.1914762966 +27.950 1 1.757634225 0 -12.68177433 -0.4996794853 0 -0.374759614 -0.4818654024 0 -0.3613990518 +27.950 2 298.2423658 0 -13.28426186 0.4996794853 0 0.6902213462 0.4818654024 0 -0.196223675 +27.975 1 1.744992014 0 -12.69125599 -0.5116829676 0 -0.3837622257 -0.4783994684 0 -0.3587996013 +27.975 2 298.255008 0 -13.26706814 0.5116829676 0 0.6852567615 0.4783994684 0 -0.2009374315 +28.000 1 1.732050808 0 -12.70096189 -0.5235987756 0 -0.3926990817 -0.4748515631 0 -0.3561386724 +28.000 2 298.2679492 0 -13.25 0.5235987756 0 0.6801747616 0.4748515631 0 -0.2056167584 +28.025 1 1.718812823 0 -12.71089038 -0.5354248677 0 -0.4015686508 -0.4712222945 0 -0.3534167209 +28.025 2 298.2811872 0 -13.23306037 0.5354248677 0 0.6749762172 0.4712222945 0 -0.2102608539 +28.050 1 1.705280329 0 -12.72103975 -0.5471592175 0 -0.4103694131 -0.4675122844 0 -0.3506342133 +28.050 2 298.2947197 0 -13.21625215 0.5471592175 0 0.6696620191 0.4675122844 0 -0.2148689222 +28.075 1 1.691455643 0 -12.73140827 -0.5587998143 0 -0.4190998608 -0.4637221684 0 -0.3477916263 +28.075 2 298.3085444 0 -13.19957823 0.5587998143 0 0.6642330779 0.4637221684 0 -0.2194401739 +28.100 1 1.677341136 0 -12.74199415 -0.5703446638 0 -0.4277584978 -0.459852596 0 -0.344889447 +28.100 2 298.3226589 0 -13.18304145 0.5703446638 0 0.6586903238 0.459852596 0 -0.2239738257 +28.125 1 1.662939225 0 -12.75279558 -0.5817917875 0 -0.4363438407 -0.4559042303 0 -0.3419281727 +28.125 2 298.3370608 0 -13.16664465 0.5817917875 0 0.6530347064 0.4559042303 0 -0.2284691007 +28.150 1 1.648252377 0 -12.76381072 -0.5931392243 0 -0.4448544182 -0.4518777477 0 -0.3389083108 +28.150 2 298.3517476 0 -13.15039064 0.5931392243 0 0.647267195 0.4518777477 0 -0.2329252287 +28.175 1 1.63328311 0 -12.77503767 -0.6043850297 0 -0.4532887723 -0.4477738382 0 -0.3358303786 +28.175 2 298.3667169 0 -13.13428221 0.6043850297 0 0.6413887776 0.4477738382 0 -0.2373414462 +28.200 1 1.618033989 0 -12.78647451 -0.6155272768 0 -0.4616454576 -0.4435932049 0 -0.3326949037 +28.200 2 298.381966 0 -13.11832212 0.6155272768 0 0.6354004615 0.4435932049 0 -0.2417169964 +28.225 1 1.602507625 0 -12.79811928 -0.6265640565 0 -0.4699230424 -0.4393365642 0 -0.3295024232 +28.225 2 298.3974924 0 -13.1025131 0.6265640565 0 0.6293032729 0.4393365642 0 -0.2460511296 +28.250 1 1.586706681 0 -12.80996999 -0.6374934777 0 -0.4781201083 -0.4350046455 0 -0.3262534841 +28.250 2 298.4132933 0 -13.08685786 0.6374934777 0 0.6230982564 0.4350046455 0 -0.2503431033 +28.275 1 1.570633862 0 -12.8220246 -0.6483136677 0 -0.4862352508 -0.430598191 0 -0.3229486432 +28.275 2 298.4293661 0 -13.07135908 0.6483136677 0 0.6167864752 0.430598191 0 -0.2545921819 +28.300 1 1.554291923 0 -12.83428106 -0.6590227724 0 -0.4942670793 -0.4261179556 0 -0.3195884667 +28.300 2 298.4457081 0 -13.05601941 0.6590227724 0 0.6103690108 0.4261179556 0 -0.2587976376 +28.325 1 1.537683664 0 -12.84673725 -0.669618957 0 -0.5022142178 -0.4215647072 0 -0.3161735304 +28.325 2 298.4623163 0 -13.0408415 0.669618957 0 0.6038469629 0.4215647072 0 -0.2629587495 +28.350 1 1.520811931 0 -12.85939105 -0.6801004058 0 -0.5100753044 -0.4169392258 0 -0.3127044194 +28.350 2 298.4791881 0 -13.02582793 0.6801004058 0 0.5972214488 0.4169392258 0 -0.2670748048 +28.375 1 1.503679615 0 -12.87224029 -0.690465323 0 -0.5178489922 -0.412242304 0 -0.309181728 +28.375 2 298.4963204 0 -13.01098128 0.690465323 0 0.590493604 0.412242304 0 -0.2711450983 +28.400 1 1.486289651 0 -12.88528276 -0.7007119324 0 -0.5255339493 -0.4074747467 0 -0.30560606 +28.400 2 298.5137103 0 -12.99630409 0.7007119324 0 0.5836645811 0.4074747467 0 -0.2751689324 +28.425 1 1.468645019 0 -12.89851624 -0.7108384785 0 -0.5331288589 -0.4026373706 0 -0.301978028 +28.425 2 298.531355 0 -12.98179888 0.7108384785 0 0.5767355503 0.4026373706 0 -0.2791456177 +28.450 1 1.450748742 0 -12.91193844 -0.720843226 0 -0.5406324195 -0.3977310047 0 -0.2982982535 +28.450 2 298.5492513 0 -12.96746814 0.720843226 0 0.5697076988 0.3977310047 0 -0.2830744729 +28.475 1 1.432603887 0 -12.92554708 -0.7307244608 0 -0.5480433456 -0.3927564896 0 -0.2945673672 +28.475 2 298.5673961 0 -12.95331431 0.7307244608 0 0.5625822308 0.3927564896 0 -0.2869548247 +28.500 1 1.414213562 0 -12.93933983 -0.7404804897 0 -0.5553603673 -0.3877146778 0 -0.2907860083 +28.500 2 298.5857864 0 -12.93933983 0.7404804897 0 0.5553603673 0.3877146778 0 -0.2907860083 +28.525 1 1.39558092 0 -12.95331431 -0.7501096411 0 -0.5625822308 -0.382606433 0 -0.2869548247 +28.525 2 298.6044191 0 -12.92554708 0.7501096411 0 0.5480433456 0.382606433 0 -0.2945673672 +28.550 1 1.376709151 0 -12.96746814 -0.759610265 0 -0.5697076988 -0.3774326305 0 -0.2830744729 +28.550 2 298.6232908 0 -12.91193844 0.759610265 0 0.5406324195 0.3774326305 0 -0.2982982535 +28.575 1 1.357601491 0 -12.98179888 -0.7689807337 0 -0.5767355503 -0.372194157 0 -0.2791456177 +28.575 2 298.6423985 0 -12.89851624 0.7689807337 0 0.5331288589 0.372194157 0 -0.301978028 +28.600 1 1.338261213 0 -12.99630409 -0.7782194414 0 -0.5836645811 -0.3668919099 0 -0.2751689324 +28.600 2 298.6617388 0 -12.88528276 0.7782194414 0 0.5255339493 0.3668919099 0 -0.30560606 +28.625 1 1.31869163 0 -13.01098128 -0.7873248053 0 -0.590493604 -0.3615267977 0 -0.2711450983 +28.625 2 298.6813084 0 -12.87224029 0.7873248053 0 0.5178489922 0.3615267977 0 -0.309181728 +28.650 1 1.298896097 0 -13.02582793 -0.7962952651 0 -0.5972214488 -0.3560997398 0 -0.2670748048 +28.650 2 298.7011039 0 -12.85939105 0.7962952651 0 0.5100753044 0.3560997398 0 -0.3127044194 +28.675 1 1.278878004 0 -13.0408415 -0.8051292838 0 -0.6038469629 -0.350611666 0 -0.2629587495 +28.675 2 298.721122 0 -12.84673725 0.8051292838 0 0.5022142178 0.350611666 0 -0.3161735304 +28.700 1 1.258640782 0 -13.05601941 -0.8138253478 0 -0.6103690108 -0.3450635167 0 -0.2587976376 +28.700 2 298.7413592 0 -12.83428106 0.8138253478 0 0.4942670793 0.3450635167 0 -0.3195884667 +28.725 1 1.238187899 0 -13.07135908 -0.8223819669 0 -0.6167864752 -0.3394562426 0 -0.2545921819 +28.725 2 298.7618121 0 -12.8220246 0.8223819669 0 0.4862352508 0.3394562426 0 -0.3229486432 +28.750 1 1.217522858 0 -13.08685786 -0.8307976752 0 -0.6230982564 -0.3337908044 0 -0.2503431033 +28.750 2 298.7824771 0 -12.80996999 0.8307976752 0 0.4781201083 0.3337908044 0 -0.3262534841 +28.775 1 1.196649201 0 -13.1025131 -0.8390710305 0 -0.6293032729 -0.3280681728 0 -0.2460511296 +28.775 2 298.8033508 0 -12.79811928 0.8390710305 0 0.4699230424 0.3280681728 0 -0.3295024232 +28.800 1 1.175570505 0 -13.11832212 -0.8472006154 0 -0.6354004615 -0.3222893285 0 -0.2417169964 +28.800 2 298.8244295 0 -12.78647451 0.8472006154 0 0.4616454576 0.3222893285 0 -0.3326949037 +28.825 1 1.15429038 0 -13.13428221 -0.8551850368 0 -0.6413887776 -0.3164552615 0 -0.2373414462 +28.825 2 298.8457096 0 -12.77503767 0.8551850368 0 0.4532887723 0.3164552615 0 -0.3358303786 +28.850 1 1.132812474 0 -13.15039064 -0.8630229266 0 -0.647267195 -0.3105669716 0 -0.2329252287 +28.850 2 298.8671875 0 -12.76381072 0.8630229266 0 0.4448544182 0.3105669716 0 -0.3389083108 +28.875 1 1.111140466 0 -13.16664465 -0.8707129419 0 -0.6530347064 -0.3046254676 0 -0.2284691007 +28.875 2 298.8888595 0 -12.75279558 0.8707129419 0 0.4363438407 0.3046254676 0 -0.3419281727 +28.900 1 1.08927807 0 -13.18304145 -0.878253765 0 -0.6586903238 -0.2986317676 0 -0.2239738257 +28.900 2 298.9107219 0 -12.74199415 0.878253765 0 0.4277584978 0.2986317676 0 -0.344889447 +28.925 1 1.067229032 0 -13.19957823 -0.8856441039 0 -0.6642330779 -0.2925868986 0 -0.2194401739 +28.925 2 298.932771 0 -12.73140827 0.8856441039 0 0.4190998608 0.2925868986 0 -0.3477916263 +28.950 1 1.044997129 0 -13.21625215 -0.8928826922 0 -0.6696620191 -0.2864918963 0 -0.2148689222 +28.950 2 298.9550029 0 -12.72103975 0.8928826922 0 0.4103694131 0.2864918963 0 -0.3506342133 +28.975 1 1.022586172 0 -13.23306037 -0.8999682896 0 -0.6749762172 -0.2803478051 0 -0.2102608539 +28.975 2 298.9774138 0 -12.71089038 0.8999682896 0 0.4015686508 0.2803478051 0 -0.3534167209 +29.000 1 1 0 -13.25 -0.9068996821 0 -0.6801747616 -0.2741556778 0 -0.2056167584 +29.000 2 299 0 -12.70096189 0.9068996821 0 0.3926990817 0.2741556778 0 -0.3561386724 +29.025 1 0.977242483 0 -13.26706814 -0.913675682 0 -0.6852567615 -0.2679165753 0 -0.2009374315 +29.025 2 299.0227575 0 -12.69125599 0.913675682 0 0.3837622257 0.2679165753 0 -0.3587996013 +29.050 1 0.9543175205 0 -13.28426186 -0.9202951283 0 -0.6902213462 -0.2616315667 0 -0.196223675 +29.050 2 299.0456825 0 -12.68177433 0.9202951283 0 0.374759614 0.2616315667 0 -0.3613990518 +29.075 1 0.9312290407 0 -13.30157822 -0.9267568868 0 -0.6950676651 -0.2553017288 0 -0.1914762966 +29.075 2 299.068771 0 -12.67251854 0.9267568868 0 0.3656927891 0.2553017288 0 -0.3639365784 +29.100 1 0.9079809995 0 -13.31901425 -0.9330598502 0 -0.6997948877 -0.2489281463 0 -0.1866961098 +29.100 2 299.092019 0 -12.66349021 0.9330598502 0 0.3565633047 0.2489281463 0 -0.3664117464 +29.125 1 0.8845773804 0 -13.33656696 -0.9392029387 0 -0.704402204 -0.2425119113 0 -0.1818839335 +29.125 2 299.1154226 0 -12.65469089 0.9392029387 0 0.347372725 0.2425119113 0 -0.3688241315 +29.150 1 0.8610221936 0 -13.35423335 -0.9451850995 0 -0.7088888246 -0.2360541231 0 -0.1770405923 +29.150 2 299.1389778 0 -12.64612207 0.9451850995 0 0.3381226248 0.2360541231 0 -0.3711733206 +29.175 1 0.8373194751 0 -13.37201039 -0.9510053078 0 -0.7132539808 -0.2295558882 0 -0.1721669162 +29.175 2 299.1626805 0 -12.63778524 0.9510053078 0 0.328814589 0.2295558882 0 -0.3734589111 +29.200 1 0.8134732862 0 -13.38989504 -0.9566625662 0 -0.7174969246 -0.2230183201 0 -0.1672637401 +29.200 2 299.1865267 0 -12.62968181 0.9566625662 0 0.3194502125 0.2230183201 0 -0.3756805112 +29.225 1 0.7894877128 0 -13.40788422 -0.9621559053 0 -0.721616929 -0.216442539 0 -0.1623319043 +29.225 2 299.2105123 0 -12.62181318 0.9621559053 0 0.3100310998 0.216442539 0 -0.3778377405 +29.250 1 0.7653668647 0 -13.42597485 -0.967484384 0 -0.725613288 -0.2098296716 0 -0.1573722537 +29.250 2 299.2346331 0 -12.6141807 0.967484384 0 0.3005588649 0.2098296716 0 -0.3799302292 +29.275 1 0.741114875 0 -13.44416384 -0.9726470893 0 -0.729485317 -0.2031808509 0 -0.1523856382 +29.275 2 299.2588851 0 -12.60678567 0.9726470893 0 0.2910351309 0.2031808509 0 -0.3819576188 +29.300 1 0.7167358991 0 -13.46244808 -0.9776431365 0 -0.7332323524 -0.1964972162 0 -0.1473729122 +29.300 2 299.2832641 0 -12.59962936 0.9776431365 0 0.2814615294 0.1964972162 0 -0.3839195619 +29.325 1 0.6922341142 0 -13.48082441 -0.9824716695 0 -0.7368537521 -0.1897799128 0 -0.1423349346 +29.325 2 299.3077659 0 -12.592713 0.9824716695 0 0.2718397009 0.1897799128 0 -0.3858157224 +29.350 1 0.6676137185 0 -13.49928971 -0.9871318611 0 -0.7403488958 -0.1830300915 0 -0.1372725686 +29.350 2 299.3323863 0 -12.58603776 0.9871318611 0 0.2621712942 0.1830300915 0 -0.3876457754 +29.375 1 0.6428789306 0 -13.5178408 -0.9916229128 0 -0.7437171846 -0.176248909 0 -0.1321866817 +29.375 2 299.3571211 0 -12.57960481 0.9916229128 0 0.2524579657 0.176248909 0 -0.3894094072 +29.400 1 0.6180339887 0 -13.53647451 -0.9959440549 0 -0.7469580412 -0.1694375271 0 -0.1270781453 +29.400 2 299.381966 0 -12.57341523 0.9959440549 0 0.2427013798 0.1694375271 0 -0.3911063158 +29.425 1 0.59308315 0 -13.55518764 -1.000094547 0 -0.7500709104 -0.162597113 0 -0.1219478347 +29.425 2 299.4069169 0 -12.56747008 1.000094547 0 0.2329032084 0.162597113 0 -0.3927362103 +29.450 1 0.5680306894 0 -13.57397698 -1.004073678 0 -0.7530552588 -0.1557288387 0 -0.116796629 +29.450 2 299.4319693 0 -12.5617704 1.004073678 0 0.2230651301 0.1557288387 0 -0.3942988115 +29.475 1 0.5428808997 0 -13.59283933 -1.007880767 0 -0.7559105751 -0.148833881 0 -0.1116254108 +29.475 2 299.4571191 0 -12.55631715 1.007880767 0 0.2131888308 0.148833881 0 -0.3957938516 +29.500 1 0.5176380902 0 -13.61177143 -1.01151516 0 -0.7586363699 -0.1419134215 0 -0.1064350661 +29.500 2 299.4823619 0 -12.55111126 1.01151516 0 0.2032760027 0.1419134215 0 -0.3972210744 +29.525 1 0.4923065861 0 -13.63077006 -1.014976235 0 -0.7612321764 -0.1349686458 0 -0.1012264843 +29.525 2 299.5076934 0 -12.54615364 1.014976235 0 0.1933283443 0.1349686458 0 -0.3985802355 +29.550 1 0.4668907277 0 -13.64983195 -1.018263399 0 -0.7636975496 -0.1280007439 0 -0.09600055794 +29.550 2 299.5331093 0 -12.54144512 1.018263399 0 0.18334756 0.1280007439 0 -0.3998711019 +29.575 1 0.44139487 0 -13.66895385 -1.02137609 0 -0.7660320672 -0.1210109098 0 -0.09075818233 +29.575 2 299.5586051 0 -12.53698652 1.02137609 0 0.1733353601 0.1210109098 0 -0.4010934525 +29.600 1 0.4158233816 0 -13.68813246 -1.024313772 0 -0.7682353291 -0.114000341 0 -0.08550025578 +29.600 2 299.5841766 0 -12.5327786 1.024313772 0 0.1632934601 0.114000341 0 -0.4022470777 +29.625 1 0.390180644 0 -13.70736452 -1.027075944 0 -0.7703069579 -0.1069702389 0 -0.0802276792 +29.625 2 299.6098194 0 -12.52882208 1.027075944 0 0.1532235806 0.1069702389 0 -0.40333178 +29.650 1 0.364471051 0 -13.72664671 -1.029662131 0 -0.7722465986 -0.09992180802 0 -0.07494135602 +29.650 2 299.6355289 0 -12.52511764 1.029662131 0 0.143127447 0.09992180802 0 -0.4043473735 +29.675 1 0.3386990077 0 -13.74597574 -1.032071892 0 -0.7740539187 -0.09285625603 0 -0.06964219202 +29.675 2 299.661301 0 -12.52166591 1.032071892 0 0.1330067893 0.09285625603 0 -0.4052936841 +29.700 1 0.3128689301 0 -13.7653483 -1.034304812 0 -0.7757286087 -0.08577479359 0 -0.06433109519 +29.700 2 299.6871311 0 -12.51846749 1.034304812 0 0.1228633415 0.08577479359 0 -0.4061705497 +29.725 1 0.286985244 0 -13.78476107 -1.036360509 0 -0.7772703816 -0.07867863408 0 -0.05900897556 +29.725 2 299.7130148 0 -12.51552292 1.036360509 0 0.1126988418 0.07867863408 0 -0.4069778201 +29.750 1 0.2610523844 0 -13.80421071 -1.038238631 0 -0.7786789732 -0.0715689934 0 -0.05367674505 +29.750 2 299.7389476 0 -12.51283271 1.038238631 0 0.1025150316 0.0715689934 0 -0.407715357 +29.775 1 0.2350747949 0 -13.8236939 -1.039938856 0 -0.7799541422 -0.06444708974 0 -0.0483353173 +29.775 2 299.7649252 0 -12.51039731 1.039938856 0 0.09231365609 0.06444708974 0 -0.4083830339 +29.800 1 0.2090569265 0 -13.84320731 -1.041460893 0 -0.7810956701 -0.05731414339 0 -0.04298560755 +29.800 2 299.7909431 0 -12.50821716 1.041460893 0 0.08209646307 0.05731414339 0 -0.4089807365 +29.825 1 0.1830032373 0 -13.86274757 -1.042804482 0 -0.7821033612 -0.05017137657 0 -0.03762853243 +29.825 2 299.8169968 0 -12.50629261 1.042804482 0 0.07186520325 0.05017137657 0 -0.4095083623 +29.850 1 0.1569181915 0 -13.88231136 -1.043969391 0 -0.782977043 -0.04302001314 0 -0.03226500985 +29.850 2 299.8430818 0 -12.504624 1.043969391 0 0.06162162969 0.04302001314 0 -0.409965821 +29.875 1 0.1308062585 0 -13.90189531 -1.044955421 0 -0.7837165656 -0.03586127845 0 -0.02689595884 +29.875 2 299.8691937 0 -12.50321162 1.044955421 0 0.05136749758 0.03586127845 0 -0.4103530342 +29.900 1 0.1046719125 0 -13.92149607 -1.045762403 0 -0.7843218025 -0.02869639912 0 -0.02152229934 +29.900 2 299.8953281 0 -12.5020557 1.045762403 0 0.04110456391 0.02869639912 0 -0.4106699355 +29.925 1 0.07851963152 0 -13.94111028 -1.0463902 0 -0.7847926499 -0.0215266028 0 -0.0161449521 +29.925 2 299.9214804 0 -12.50115645 1.0463902 0 0.03083458719 0.0215266028 0 -0.4109164706 +29.950 1 0.05235389662 0 -13.96073458 -1.046838703 0 -0.7851290271 -0.01435311801 0 -0.01076483851 +29.950 2 299.9476461 0 -12.50051401 1.046838703 0 0.02055932712 0.01435311801 0 -0.4110925973 +29.975 1 0.02617919114 0 -13.98036561 -1.047107835 0 -0.7853308764 -0.007177173892 0 -0.005382880419 +29.975 2 299.9738208 0 -12.50012851 1.047107835 0 0.01028054432 0.007177173892 0 -0.4111982853 +30.000 1 4.777360478e-15 0 -14 -1.047197551 0 -0.7853981634 -1.3097405e-15 0 -9.82305375e-16 +30.000 2 300 0 -12.5 1.047197551 0 1.827973305e-15 4.02892648e-16 0 -0.4112335167 +30.025 1 -0.02617919114 0 -14.01963439 -1.047107835 0 -0.7853308764 0.007177173892 0 0.005382880419 +30.025 2 300.0261792 0 -12.50012851 1.047107835 0 -0.01028054432 -0.007177173892 0 -0.4111982853 +30.050 1 -0.05235389662 0 -14.03926542 -1.046838703 0 -0.7851290271 0.01435311801 0 0.01076483851 +30.050 2 300.0523539 0 -12.50051401 1.046838703 0 -0.02055932712 -0.01435311801 0 -0.4110925973 +30.075 1 -0.07851963152 0 -14.05888972 -1.0463902 0 -0.7847926499 0.0215266028 0 0.0161449521 +30.075 2 300.0785196 0 -12.50115645 1.0463902 0 -0.03083458719 -0.0215266028 0 -0.4109164706 +30.100 1 -0.1046719125 0 -14.07850393 -1.045762403 0 -0.7843218025 0.02869639912 0 0.02152229934 +30.100 2 300.1046719 0 -12.5020557 1.045762403 0 -0.04110456391 -0.02869639912 0 -0.4106699355 +30.125 1 -0.1308062585 0 -14.09810469 -1.044955421 0 -0.7837165656 0.03586127845 0 0.02689595884 +30.125 2 300.1308063 0 -12.50321162 1.044955421 0 -0.05136749758 -0.03586127845 0 -0.4103530342 +30.150 1 -0.1569181915 0 -14.11768864 -1.043969391 0 -0.782977043 0.04302001314 0 0.03226500985 +30.150 2 300.1569182 0 -12.504624 1.043969391 0 -0.06162162969 -0.04302001314 0 -0.409965821 +30.175 1 -0.1830032373 0 -14.13725243 -1.042804482 0 -0.7821033612 0.05017137657 0 0.03762853243 +30.175 2 300.1830032 0 -12.50629261 1.042804482 0 -0.07186520325 -0.05017137657 0 -0.4095083623 +30.200 1 -0.2090569265 0 -14.15679269 -1.041460893 0 -0.7810956701 0.05731414339 0 0.04298560755 +30.200 2 300.2090569 0 -12.50821716 1.041460893 0 -0.08209646307 -0.05731414339 0 -0.4089807365 +30.225 1 -0.2350747949 0 -14.1763061 -1.039938856 0 -0.7799541422 0.06444708974 0 0.0483353173 +30.225 2 300.2350748 0 -12.51039731 1.039938856 0 -0.09231365609 -0.06444708974 0 -0.4083830339 +30.250 1 -0.2610523844 0 -14.19578929 -1.038238631 0 -0.7786789732 0.0715689934 0 0.05367674505 +30.250 2 300.2610524 0 -12.51283271 1.038238631 0 -0.1025150316 -0.0715689934 0 -0.407715357 +30.275 1 -0.286985244 0 -14.21523893 -1.036360509 0 -0.7772703816 0.07867863408 0 0.05900897556 +30.275 2 300.2869852 0 -12.51552292 1.036360509 0 -0.1126988418 -0.07867863408 0 -0.4069778201 +30.300 1 -0.3128689301 0 -14.2346517 -1.034304812 0 -0.7757286087 0.08577479359 0 0.06433109519 +30.300 2 300.3128689 0 -12.51846749 1.034304812 0 -0.1228633415 -0.08577479359 0 -0.4061705497 +30.325 1 -0.3386990077 0 -14.25402426 -1.032071892 0 -0.7740539187 0.09285625603 0 0.06964219202 +30.325 2 300.338699 0 -12.52166591 1.032071892 0 -0.1330067893 -0.09285625603 0 -0.4052936841 +30.350 1 -0.364471051 0 -14.27335329 -1.029662131 0 -0.7722465986 0.09992180802 0 0.07494135602 +30.350 2 300.3644711 0 -12.52511764 1.029662131 0 -0.143127447 -0.09992180802 0 -0.4043473735 +30.375 1 -0.390180644 0 -14.29263548 -1.027075944 0 -0.7703069579 0.1069702389 0 0.0802276792 +30.375 2 300.3901806 0 -12.52882208 1.027075944 0 -0.1532235806 -0.1069702389 0 -0.40333178 +30.400 1 -0.4158233816 0 -14.31186754 -1.024313772 0 -0.7682353291 0.114000341 0 0.08550025578 +30.400 2 300.4158234 0 -12.5327786 1.024313772 0 -0.1632934601 -0.114000341 0 -0.4022470777 +30.425 1 -0.44139487 0 -14.33104615 -1.02137609 0 -0.7660320672 0.1210109098 0 0.09075818233 +30.425 2 300.4413949 0 -12.53698652 1.02137609 0 -0.1733353601 -0.1210109098 0 -0.4010934525 +30.450 1 -0.4668907277 0 -14.35016805 -1.018263399 0 -0.7636975496 0.1280007439 0 0.09600055794 +30.450 2 300.4668907 0 -12.54144512 1.018263399 0 -0.18334756 -0.1280007439 0 -0.3998711019 +30.475 1 -0.4923065861 0 -14.36922994 -1.014976235 0 -0.7612321764 0.1349686458 0 0.1012264843 +30.475 2 300.4923066 0 -12.54615364 1.014976235 0 -0.1933283443 -0.1349686458 0 -0.3985802355 +30.500 1 -0.5176380902 0 -14.38822857 -1.01151516 0 -0.7586363699 0.1419134215 0 0.1064350661 +30.500 2 300.5176381 0 -12.55111126 1.01151516 0 -0.2032760027 -0.1419134215 0 -0.3972210744 +30.525 1 -0.5428808997 0 -14.40716067 -1.007880767 0 -0.7559105751 0.148833881 0 0.1116254108 +30.525 2 300.5428809 0 -12.55631715 1.007880767 0 -0.2131888308 -0.148833881 0 -0.3957938516 +30.550 1 -0.5680306894 0 -14.42602302 -1.004073678 0 -0.7530552588 0.1557288387 0 0.116796629 +30.550 2 300.5680307 0 -12.5617704 1.004073678 0 -0.2230651301 -0.1557288387 0 -0.3942988115 +30.575 1 -0.59308315 0 -14.44481236 -1.000094547 0 -0.7500709104 0.162597113 0 0.1219478347 +30.575 2 300.5930831 0 -12.56747008 1.000094547 0 -0.2329032084 -0.162597113 0 -0.3927362103 +30.600 1 -0.6180339887 0 -14.46352549 -0.9959440549 0 -0.7469580412 0.1694375271 0 0.1270781453 +30.600 2 300.618034 0 -12.57341523 0.9959440549 0 -0.2427013798 -0.1694375271 0 -0.3911063158 +30.625 1 -0.6428789306 0 -14.4821592 -0.9916229128 0 -0.7437171846 0.176248909 0 0.1321866817 +30.625 2 300.6428789 0 -12.57960481 0.9916229128 0 -0.2524579657 -0.176248909 0 -0.3894094072 +30.650 1 -0.6676137185 0 -14.50071029 -0.9871318611 0 -0.7403488958 0.1830300915 0 0.1372725686 +30.650 2 300.6676137 0 -12.58603776 0.9871318611 0 -0.2621712942 -0.1830300915 0 -0.3876457754 +30.675 1 -0.6922341142 0 -14.51917559 -0.9824716695 0 -0.7368537521 0.1897799128 0 0.1423349346 +30.675 2 300.6922341 0 -12.592713 0.9824716695 0 -0.2718397009 -0.1897799128 0 -0.3858157224 +30.700 1 -0.7167358991 0 -14.53755192 -0.9776431365 0 -0.7332323524 0.1964972162 0 0.1473729122 +30.700 2 300.7167359 0 -12.59962936 0.9776431365 0 -0.2814615294 -0.1964972162 0 -0.3839195619 +30.725 1 -0.741114875 0 -14.55583616 -0.9726470893 0 -0.729485317 0.2031808509 0 0.1523856382 +30.725 2 300.7411149 0 -12.60678567 0.9726470893 0 -0.2910351309 -0.2031808509 0 -0.3819576188 +30.750 1 -0.7653668647 0 -14.57402515 -0.967484384 0 -0.725613288 0.2098296716 0 0.1573722537 +30.750 2 300.7653669 0 -12.6141807 0.967484384 0 -0.3005588649 -0.2098296716 0 -0.3799302292 +30.775 1 -0.7894877128 0 -14.59211578 -0.9621559053 0 -0.721616929 0.216442539 0 0.1623319043 +30.775 2 300.7894877 0 -12.62181318 0.9621559053 0 -0.3100310998 -0.216442539 0 -0.3778377405 +30.800 1 -0.8134732862 0 -14.61010496 -0.9566625662 0 -0.7174969246 0.2230183201 0 0.1672637401 +30.800 2 300.8134733 0 -12.62968181 0.9566625662 0 -0.3194502125 -0.2230183201 0 -0.3756805112 +30.825 1 -0.8373194751 0 -14.62798961 -0.9510053078 0 -0.7132539808 0.2295558882 0 0.1721669162 +30.825 2 300.8373195 0 -12.63778524 0.9510053078 0 -0.328814589 -0.2295558882 0 -0.3734589111 +30.850 1 -0.8610221936 0 -14.64576665 -0.9451850995 0 -0.7088888246 0.2360541231 0 0.1770405923 +30.850 2 300.8610222 0 -12.64612207 0.9451850995 0 -0.3381226248 -0.2360541231 0 -0.3711733206 +30.875 1 -0.8845773804 0 -14.66343304 -0.9392029387 0 -0.704402204 0.2425119113 0 0.1818839335 +30.875 2 300.8845774 0 -12.65469089 0.9392029387 0 -0.347372725 -0.2425119113 0 -0.3688241315 +30.900 1 -0.9079809995 0 -14.68098575 -0.9330598502 0 -0.6997948877 0.2489281463 0 0.1866961098 +30.900 2 300.907981 0 -12.66349021 0.9330598502 0 -0.3565633047 -0.2489281463 0 -0.3664117464 +30.925 1 -0.9312290407 0 -14.69842178 -0.9267568868 0 -0.6950676651 0.2553017288 0 0.1914762966 +30.925 2 300.931229 0 -12.67251854 0.9267568868 0 -0.3656927891 -0.2553017288 0 -0.3639365784 +30.950 1 -0.9543175205 0 -14.71573814 -0.9202951283 0 -0.6902213462 0.2616315667 0 0.196223675 +30.950 2 300.9543175 0 -12.68177433 0.9202951283 0 -0.374759614 -0.2616315667 0 -0.3613990518 +30.975 1 -0.977242483 0 -14.73293186 -0.913675682 0 -0.6852567615 0.2679165753 0 0.2009374315 +30.975 2 300.9772425 0 -12.69125599 0.913675682 0 -0.3837622257 -0.2679165753 0 -0.3587996013 +31.000 1 -1 0 -14.75 -0.9068996821 0 -0.6801747616 0.2741556778 0 0.2056167584 +31.000 2 301 0 -12.70096189 0.9068996821 0 -0.3926990817 -0.2741556778 0 -0.3561386724 +31.025 1 -1.022586172 0 -14.76693963 -0.8999682896 0 -0.6749762172 0.2803478051 0 0.2102608539 +31.025 2 301.0225862 0 -12.71089038 0.8999682896 0 -0.4015686508 -0.2803478051 0 -0.3534167209 +31.050 1 -1.044997129 0 -14.78374785 -0.8928826922 0 -0.6696620191 0.2864918963 0 0.2148689222 +31.050 2 301.0449971 0 -12.72103975 0.8928826922 0 -0.4103694131 -0.2864918963 0 -0.3506342133 +31.075 1 -1.067229032 0 -14.80042177 -0.8856441039 0 -0.6642330779 0.2925868986 0 0.2194401739 +31.075 2 301.067229 0 -12.73140827 0.8856441039 0 -0.4190998608 -0.2925868986 0 -0.3477916263 +31.100 1 -1.08927807 0 -14.81695855 -0.878253765 0 -0.6586903238 0.2986317676 0 0.2239738257 +31.100 2 301.0892781 0 -12.74199415 0.878253765 0 -0.4277584978 -0.2986317676 0 -0.344889447 +31.125 1 -1.111140466 0 -14.83335535 -0.8707129419 0 -0.6530347064 0.3046254676 0 0.2284691007 +31.125 2 301.1111405 0 -12.75279558 0.8707129419 0 -0.4363438407 -0.3046254676 0 -0.3419281727 +31.150 1 -1.132812474 0 -14.84960936 -0.8630229266 0 -0.647267195 0.3105669716 0 0.2329252287 +31.150 2 301.1328125 0 -12.76381072 0.8630229266 0 -0.4448544182 -0.3105669716 0 -0.3389083108 +31.175 1 -1.15429038 0 -14.86571779 -0.8551850368 0 -0.6413887776 0.3164552615 0 0.2373414462 +31.175 2 301.1542904 0 -12.77503767 0.8551850368 0 -0.4532887723 -0.3164552615 0 -0.3358303786 +31.200 1 -1.175570505 0 -14.88167788 -0.8472006154 0 -0.6354004615 0.3222893285 0 0.2417169964 +31.200 2 301.1755705 0 -12.78647451 0.8472006154 0 -0.4616454576 -0.3222893285 0 -0.3326949037 +31.225 1 -1.196649201 0 -14.8974869 -0.8390710305 0 -0.6293032729 0.3280681728 0 0.2460511296 +31.225 2 301.1966492 0 -12.79811928 0.8390710305 0 -0.4699230424 -0.3280681728 0 -0.3295024232 +31.250 1 -1.217522858 0 -14.91314214 -0.8307976752 0 -0.6230982564 0.3337908044 0 0.2503431033 +31.250 2 301.2175229 0 -12.80996999 0.8307976752 0 -0.4781201083 -0.3337908044 0 -0.3262534841 +31.275 1 -1.238187899 0 -14.92864092 -0.8223819669 0 -0.6167864752 0.3394562426 0 0.2545921819 +31.275 2 301.2381879 0 -12.8220246 0.8223819669 0 -0.4862352508 -0.3394562426 0 -0.3229486432 +31.300 1 -1.258640782 0 -14.94398059 -0.8138253478 0 -0.6103690108 0.3450635167 0 0.2587976376 +31.300 2 301.2586408 0 -12.83428106 0.8138253478 0 -0.4942670793 -0.3450635167 0 -0.3195884667 +31.325 1 -1.278878004 0 -14.9591585 -0.8051292838 0 -0.6038469629 0.350611666 0 0.2629587495 +31.325 2 301.278878 0 -12.84673725 0.8051292838 0 -0.5022142178 -0.350611666 0 -0.3161735304 +31.350 1 -1.298896097 0 -14.97417207 -0.7962952651 0 -0.5972214488 0.3560997398 0 0.2670748048 +31.350 2 301.2988961 0 -12.85939105 0.7962952651 0 -0.5100753044 -0.3560997398 0 -0.3127044194 +31.375 1 -1.31869163 0 -14.98901872 -0.7873248053 0 -0.590493604 0.3615267977 0 0.2711450983 +31.375 2 301.3186916 0 -12.87224029 0.7873248053 0 -0.5178489922 -0.3615267977 0 -0.309181728 +31.400 1 -1.338261213 0 -15.00369591 -0.7782194414 0 -0.5836645811 0.3668919099 0 0.2751689324 +31.400 2 301.3382612 0 -12.88528276 0.7782194414 0 -0.5255339493 -0.3668919099 0 -0.30560606 +31.425 1 -1.357601491 0 -15.01820112 -0.7689807337 0 -0.5767355503 0.372194157 0 0.2791456177 +31.425 2 301.3576015 0 -12.89851624 0.7689807337 0 -0.5331288589 -0.372194157 0 -0.301978028 +31.450 1 -1.376709151 0 -15.03253186 -0.759610265 0 -0.5697076988 0.3774326305 0 0.2830744729 +31.450 2 301.3767092 0 -12.91193844 0.759610265 0 -0.5406324195 -0.3774326305 0 -0.2982982535 +31.475 1 -1.39558092 0 -15.04668569 -0.7501096411 0 -0.5625822308 0.382606433 0 0.2869548247 +31.475 2 301.3955809 0 -12.92554708 0.7501096411 0 -0.5480433456 -0.382606433 0 -0.2945673672 +31.500 1 -1.414213562 0 -15.06066017 -0.7404804897 0 -0.5553603673 0.3877146778 0 0.2907860083 +31.500 2 301.4142136 0 -12.93933983 0.7404804897 0 -0.5553603673 -0.3877146778 0 -0.2907860083 +31.525 1 -1.432603887 0 -15.07445292 -0.7307244608 0 -0.5480433456 0.3927564896 0 0.2945673672 +31.525 2 301.4326039 0 -12.95331431 0.7307244608 0 -0.5625822308 -0.3927564896 0 -0.2869548247 +31.550 1 -1.450748742 0 -15.08806156 -0.720843226 0 -0.5406324195 0.3977310047 0 0.2982982535 +31.550 2 301.4507487 0 -12.96746814 0.720843226 0 -0.5697076988 -0.3977310047 0 -0.2830744729 +31.575 1 -1.468645019 0 -15.10148376 -0.7108384785 0 -0.5331288589 0.4026373706 0 0.301978028 +31.575 2 301.468645 0 -12.98179888 0.7108384785 0 -0.5767355503 -0.4026373706 0 -0.2791456177 +31.600 1 -1.486289651 0 -15.11471724 -0.7007119324 0 -0.5255339493 0.4074747467 0 0.30560606 +31.600 2 301.4862897 0 -12.99630409 0.7007119324 0 -0.5836645811 -0.4074747467 0 -0.2751689324 +31.625 1 -1.503679615 0 -15.12775971 -0.690465323 0 -0.5178489922 0.412242304 0 0.309181728 +31.625 2 301.5036796 0 -13.01098128 0.690465323 0 -0.590493604 -0.412242304 0 -0.2711450983 +31.650 1 -1.520811931 0 -15.14060895 -0.6801004058 0 -0.5100753044 0.4169392258 0 0.3127044194 +31.650 2 301.5208119 0 -13.02582793 0.6801004058 0 -0.5972214488 -0.4169392258 0 -0.2670748048 +31.675 1 -1.537683664 0 -15.15326275 -0.669618957 0 -0.5022142178 0.4215647072 0 0.3161735304 +31.675 2 301.5376837 0 -13.0408415 0.669618957 0 -0.6038469629 -0.4215647072 0 -0.2629587495 +31.700 1 -1.554291923 0 -15.16571894 -0.6590227724 0 -0.4942670793 0.4261179556 0 0.3195884667 +31.700 2 301.5542919 0 -13.05601941 0.6590227724 0 -0.6103690108 -0.4261179556 0 -0.2587976376 +31.725 1 -1.570633862 0 -15.1779754 -0.6483136677 0 -0.4862352508 0.430598191 0 0.3229486432 +31.725 2 301.5706339 0 -13.07135908 0.6483136677 0 -0.6167864752 -0.430598191 0 -0.2545921819 +31.750 1 -1.586706681 0 -15.19003001 -0.6374934777 0 -0.4781201083 0.4350046455 0 0.3262534841 +31.750 2 301.5867067 0 -13.08685786 0.6374934777 0 -0.6230982564 -0.4350046455 0 -0.2503431033 +31.775 1 -1.602507625 0 -15.20188072 -0.6265640565 0 -0.4699230424 0.4393365642 0 0.3295024232 +31.775 2 301.6025076 0 -13.1025131 0.6265640565 0 -0.6293032729 -0.4393365642 0 -0.2460511296 +31.800 1 -1.618033989 0 -15.21352549 -0.6155272768 0 -0.4616454576 0.4435932049 0 0.3326949037 +31.800 2 301.618034 0 -13.11832212 0.6155272768 0 -0.6354004615 -0.4435932049 0 -0.2417169964 +31.825 1 -1.63328311 0 -15.22496233 -0.6043850297 0 -0.4532887723 0.4477738382 0 0.3358303786 +31.825 2 301.6332831 0 -13.13428221 0.6043850297 0 -0.6413887776 -0.4477738382 0 -0.2373414462 +31.850 1 -1.648252377 0 -15.23618928 -0.5931392243 0 -0.4448544182 0.4518777477 0 0.3389083108 +31.850 2 301.6482524 0 -13.15039064 0.5931392243 0 -0.647267195 -0.4518777477 0 -0.2329252287 +31.875 1 -1.662939225 0 -15.24720442 -0.5817917875 0 -0.4363438407 0.4559042303 0 0.3419281727 +31.875 2 301.6629392 0 -13.16664465 0.5817917875 0 -0.6530347064 -0.4559042303 0 -0.2284691007 +31.900 1 -1.677341136 0 -15.25800585 -0.5703446638 0 -0.4277584978 0.459852596 0 0.344889447 +31.900 2 301.6773411 0 -13.18304145 0.5703446638 0 -0.6586903238 -0.459852596 0 -0.2239738257 +31.925 1 -1.691455643 0 -15.26859173 -0.5587998143 0 -0.4190998608 0.4637221684 0 0.3477916263 +31.925 2 301.6914556 0 -13.19957823 0.5587998143 0 -0.6642330779 -0.4637221684 0 -0.2194401739 +31.950 1 -1.705280329 0 -15.27896025 -0.5471592175 0 -0.4103694131 0.4675122844 0 0.3506342133 +31.950 2 301.7052803 0 -13.21625215 0.5471592175 0 -0.6696620191 -0.4675122844 0 -0.2148689222 +31.975 1 -1.718812823 0 -15.28910962 -0.5354248677 0 -0.4015686508 0.4712222945 0 0.3534167209 +31.975 2 301.7188128 0 -13.23306037 0.5354248677 0 -0.6749762172 -0.4712222945 0 -0.2102608539 +32.000 1 -1.732050808 0 -15.29903811 -0.5235987756 0 -0.3926990817 0.4748515631 0 0.3561386724 +32.000 2 301.7320508 0 -13.25 0.5235987756 0 -0.6801747616 -0.4748515631 0 -0.2056167584 +32.025 1 -1.744992014 0 -15.30874401 -0.5116829676 0 -0.3837622257 0.4783994684 0 0.3587996013 +32.025 2 301.744992 0 -13.26706814 0.5116829676 0 -0.6852567615 -0.4783994684 0 -0.2009374315 +32.050 1 -1.757634225 0 -15.31822567 -0.4996794853 0 -0.374759614 0.4818654024 0 0.3613990518 +32.050 2 301.7576342 0 -13.28426186 0.4996794853 0 -0.6902213462 -0.4818654024 0 -0.196223675 +32.075 1 -1.769975275 0 -15.32748146 -0.4875903855 0 -0.3656927891 0.4852487712 0 0.3639365784 +32.075 2 301.7699753 0 -13.30157822 0.4875903855 0 -0.6950676651 -0.4852487712 0 -0.1914762966 +32.100 1 -1.782013048 0 -15.33650979 -0.4754177396 0 -0.3565633047 0.4885489951 0 0.3664117464 +32.100 2 301.782013 0 -13.31901425 0.4754177396 0 -0.6997948877 -0.4885489951 0 -0.1866961098 +32.125 1 -1.793745483 0 -15.34530911 -0.4631636333 0 -0.347372725 0.4917655087 0 0.3688241315 +32.125 2 301.7937455 0 -13.33656696 0.4631636333 0 -0.704402204 -0.4917655087 0 -0.1818839335 +32.150 1 -1.805170569 0 -15.35387793 -0.4508301663 0 -0.3381226248 0.4948977608 0 0.3711733206 +32.150 2 301.8051706 0 -13.35423335 0.4508301663 0 -0.7088888246 -0.4948977608 0 -0.1770405923 +32.175 1 -1.816286348 0 -15.36221476 -0.4384194519 0 -0.328814589 0.4979452147 0 0.3734589111 +32.175 2 301.8162863 0 -13.37201039 0.4384194519 0 -0.7132539808 -0.4979452147 0 -0.1721669162 +32.200 1 -1.827090915 0 -15.37031819 -0.4259336166 0 -0.3194502125 0.5009073483 0 0.3756805112 +32.200 2 301.8270909 0 -13.38989504 0.4259336166 0 -0.7174969246 -0.5009073483 0 -0.1672637401 +32.225 1 -1.83758242 0 -15.37818682 -0.4133747998 0 -0.3100310998 0.503783654 0 0.3778377405 +32.225 2 301.8375824 0 -13.40788422 0.4133747998 0 -0.721616929 -0.503783654 0 -0.1623319043 +32.250 1 -1.847759065 0 -15.3858193 -0.4007451533 0 -0.3005588649 0.5065736389 0 0.3799302292 +32.250 2 301.8477591 0 -13.42597485 0.4007451533 0 -0.725613288 -0.5065736389 0 -0.1573722537 +32.275 1 -1.857619106 0 -15.39321433 -0.3880468411 0 -0.2910351309 0.509276825 0 0.3819576188 +32.275 2 301.8576191 0 -13.44416384 0.3880468411 0 -0.729485317 -0.509276825 0 -0.1523856382 +32.300 1 -1.867160853 0 -15.40037064 -0.3752820392 0 -0.2814615294 0.5118927492 0 0.3839195619 +32.300 2 301.8671609 0 -13.46244808 0.3752820392 0 -0.7332323524 -0.5118927492 0 -0.1473729122 +32.325 1 -1.876382672 0 -15.407287 -0.3624529346 0 -0.2718397009 0.5144209632 0 0.3858157224 +32.325 2 301.8763827 0 -13.48082441 0.3624529346 0 -0.7368537521 -0.5144209632 0 -0.1423349346 +32.350 1 -1.885282982 0 -15.41396224 -0.3495617256 0 -0.2621712942 0.5168610338 0 0.3876457754 +32.350 2 301.885283 0 -13.49928971 0.3495617256 0 -0.7403488958 -0.5168610338 0 -0.1372725686 +32.375 1 -1.893860259 0 -15.42039519 -0.3366106209 0 -0.2524579657 0.519212543 0 0.3894094072 +32.375 2 301.8938603 0 -13.5178408 0.3366106209 0 -0.7437171846 -0.519212543 0 -0.1321866817 +32.400 1 -1.902113033 0 -15.42658477 -0.3236018398 0 -0.2427013798 0.5214750877 0 0.3911063158 +32.400 2 301.902113 0 -13.53647451 0.3236018398 0 -0.7469580412 -0.5214750877 0 -0.1270781453 +32.425 1 -1.910039889 0 -15.43252992 -0.3105376111 0 -0.2329032084 0.5236482804 0 0.3927362103 +32.425 2 301.9100399 0 -13.55518764 0.3105376111 0 -0.7500709104 -0.5236482804 0 -0.1219478347 +32.450 1 -1.91763947 0 -15.4382296 -0.2974201735 0 -0.2230651301 0.5257317486 0 0.3942988115 +32.450 2 301.9176395 0 -13.57397698 0.2974201735 0 -0.7530552588 -0.5257317486 0 -0.116796629 +32.475 1 -1.924910473 0 -15.44368285 -0.2842517744 0 -0.2131888308 0.5277251354 0 0.3957938516 +32.475 2 301.9249105 0 -13.59283933 0.2842517744 0 -0.7559105751 -0.5277251354 0 -0.1116254108 +32.500 1 -1.931851653 0 -15.44888874 -0.2710346702 0 -0.2032760027 0.5296280992 0 0.3972210744 +32.500 2 301.9318517 0 -13.61177143 0.2710346702 0 -0.7586363699 -0.5296280992 0 -0.1064350661 +32.525 1 -1.938461819 0 -15.45384636 -0.2577711257 0 -0.1933283443 0.531440314 0 0.3985802355 +32.525 2 301.9384618 0 -13.63077006 0.2577711257 0 -0.7612321764 -0.531440314 0 -0.1012264843 +32.550 1 -1.944739841 0 -15.45855488 -0.2444634134 0 -0.18334756 0.5331614692 0 0.3998711019 +32.550 2 301.9447398 0 -13.64983195 0.2444634134 0 -0.7636975496 -0.5331614692 0 -0.09600055794 +32.575 1 -1.950684641 0 -15.46301348 -0.2311138135 0 -0.1733353601 0.5347912699 0 0.4010934525 +32.575 2 301.9506846 0 -13.66895385 0.2311138135 0 -0.7660320672 -0.5347912699 0 -0.09075818233 +32.600 1 -1.956295201 0 -15.4672214 -0.2177246135 0 -0.1632934601 0.536329437 0 0.4022470777 +32.600 2 301.9562952 0 -13.68813246 0.2177246135 0 -0.7682353291 -0.536329437 0 -0.08550025578 +32.625 1 -1.961570561 0 -15.47117792 -0.2042981075 0 -0.1532235806 0.5377757067 0 0.40333178 +32.625 2 301.9615706 0 -13.70736452 0.2042981075 0 -0.7703069579 -0.5377757067 0 -0.0802276792 +32.650 1 -1.966509815 0 -15.47488236 -0.190836596 0 -0.143127447 0.5391298313 0 0.4043473735 +32.650 2 301.9665098 0 -13.72664671 0.190836596 0 -0.7722465986 -0.5391298313 0 -0.07494135602 +32.675 1 -1.971112118 0 -15.47833409 -0.1773423857 0 -0.1330067893 0.5403915788 0 0.4052936841 +32.675 2 301.9711121 0 -13.74597574 0.1773423857 0 -0.7740539187 -0.5403915788 0 -0.06964219202 +32.700 1 -1.975376681 0 -15.48153251 -0.1638177887 0 -0.1228633415 0.541560733 0 0.4061705497 +32.700 2 301.9753767 0 -13.7653483 0.1638177887 0 -0.7757286087 -0.541560733 0 -0.06433109519 +32.725 1 -1.979302774 0 -15.48447708 -0.1502651224 0 -0.1126988418 0.5426370935 0 0.4069778201 +32.725 2 301.9793028 0 -13.78476107 0.1502651224 0 -0.7772703816 -0.5426370935 0 -0.05900897556 +32.750 1 -1.982889723 0 -15.48716729 -0.1366867089 0 -0.1025150316 0.543620476 0 0.407715357 +32.750 2 301.9828897 0 -13.80421071 0.1366867089 0 -0.7786789732 -0.543620476 0 -0.05367674505 +32.775 1 -1.986136914 0 -15.48960269 -0.1230848748 0 -0.09231365609 0.5445107119 0 0.4083830339 +32.775 2 301.9861369 0 -13.8236939 0.1230848748 0 -0.7799541422 -0.5445107119 0 -0.0483353173 +32.800 1 -1.989043791 0 -15.49178284 -0.1094619508 0 -0.08209646307 0.5453076486 0 0.4089807365 +32.800 2 301.9890438 0 -13.84320731 0.1094619508 0 -0.7810956701 -0.5453076486 0 -0.04298560755 +32.825 1 -1.991609855 0 -15.49370739 -0.09582027099 0 -0.07186520325 0.5460111498 0 0.4095083623 +32.825 2 301.9916099 0 -13.86274757 0.09582027099 0 -0.7821033612 -0.5460111498 0 -0.03762853243 +32.850 1 -1.993834667 0 -15.495376 -0.08216217292 0 -0.06162162969 0.5466210947 0 0.409965821 +32.850 2 301.9938347 0 -13.88231136 0.08216217292 0 -0.782977043 -0.5466210947 0 -0.03226500985 +32.875 1 -1.995717846 0 -15.49678838 -0.06848999677 0 -0.05136749758 0.5471373789 0 0.4103530342 +32.875 2 301.9957178 0 -13.90189531 0.06848999677 0 -0.7837165656 -0.5471373789 0 -0.02689595884 +32.900 1 -1.99725907 0 -15.4979443 -0.05480608522 0 -0.04110456391 0.547559914 0 0.4106699355 +32.900 2 301.9972591 0 -13.92149607 0.05480608522 0 -0.7843218025 -0.547559914 0 -0.02152229934 +32.925 1 -1.998458072 0 -15.49884355 -0.04111278292 0 -0.03083458719 0.5478886274 0 0.4109164706 +32.925 2 301.9984581 0 -13.94111028 0.04111278292 0 -0.7847926499 -0.5478886274 0 -0.0161449521 +32.950 1 -1.99931465 0 -15.49948599 -0.02741243617 0 -0.02055932712 0.548123463 0 0.4110925973 +32.950 2 301.9993146 0 -13.96073458 0.02741243617 0 -0.7851290271 -0.548123463 0 -0.01076483851 +32.975 1 -1.999828655 0 -15.49987149 -0.01370739243 0 -0.01028054432 0.5482643805 0 0.4111982853 +32.975 2 301.9998287 0 -13.98036561 0.01370739243 0 -0.7853308764 -0.5482643805 0 -0.005382880419 +33.000 1 -2 0 -15.5 -2.565542453e-15 0 -1.92415684e-15 0.5483113556 0 0.4112335167 +33.000 2 302 0 -14 2.693787166e-15 0 -0.7853981634 -0.5483113556 0 -9.82305375e-16 +33.025 1 -1.999828655 0 -15.49987149 0.01370739243 0 0.01028054432 0.5482643805 0 0.4111982853 +33.025 2 301.9998287 0 -14.01963439 -0.01370739243 0 -0.7853308764 -0.5482643805 0 0.005382880419 +33.050 1 -1.99931465 0 -15.49948599 0.02741243617 0 0.02055932712 0.548123463 0 0.4110925973 +33.050 2 301.9993146 0 -14.03926542 -0.02741243617 0 -0.7851290271 -0.548123463 0 0.01076483851 +33.075 1 -1.998458072 0 -15.49884355 0.04111278292 0 0.03083458719 0.5478886274 0 0.4109164706 +33.075 2 301.9984581 0 -14.05888972 -0.04111278292 0 -0.7847926499 -0.5478886274 0 0.0161449521 +33.100 1 -1.99725907 0 -15.4979443 0.05480608522 0 0.04110456391 0.547559914 0 0.4106699355 +33.100 2 301.9972591 0 -14.07850393 -0.05480608522 0 -0.7843218025 -0.547559914 0 0.02152229934 +33.125 1 -1.995717846 0 -15.49678838 0.06848999677 0 0.05136749758 0.5471373789 0 0.4103530342 +33.125 2 301.9957178 0 -14.09810469 -0.06848999677 0 -0.7837165656 -0.5471373789 0 0.02689595884 +33.150 1 -1.993834667 0 -15.495376 0.08216217292 0 0.06162162969 0.5466210947 0 0.409965821 +33.150 2 301.9938347 0 -14.11768864 -0.08216217292 0 -0.782977043 -0.5466210947 0 0.03226500985 +33.175 1 -1.991609855 0 -15.49370739 0.09582027099 0 0.07186520325 0.5460111498 0 0.4095083623 +33.175 2 301.9916099 0 -14.13725243 -0.09582027099 0 -0.7821033612 -0.5460111498 0 0.03762853243 +33.200 1 -1.989043791 0 -15.49178284 0.1094619508 0 0.08209646307 0.5453076486 0 0.4089807365 +33.200 2 301.9890438 0 -14.15679269 -0.1094619508 0 -0.7810956701 -0.5453076486 0 0.04298560755 +33.225 1 -1.986136914 0 -15.48960269 0.1230848748 0 0.09231365609 0.5445107119 0 0.4083830339 +33.225 2 301.9861369 0 -14.1763061 -0.1230848748 0 -0.7799541422 -0.5445107119 0 0.0483353173 +33.250 1 -1.982889723 0 -15.48716729 0.1366867089 0 0.1025150316 0.543620476 0 0.407715357 +33.250 2 301.9828897 0 -14.19578929 -0.1366867089 0 -0.7786789732 -0.543620476 0 0.05367674505 +33.275 1 -1.979302774 0 -15.48447708 0.1502651224 0 0.1126988418 0.5426370935 0 0.4069778201 +33.275 2 301.9793028 0 -14.21523893 -0.1502651224 0 -0.7772703816 -0.5426370935 0 0.05900897556 +33.300 1 -1.975376681 0 -15.48153251 0.1638177887 0 0.1228633415 0.541560733 0 0.4061705497 +33.300 2 301.9753767 0 -14.2346517 -0.1638177887 0 -0.7757286087 -0.541560733 0 0.06433109519 +33.325 1 -1.971112118 0 -15.47833409 0.1773423857 0 0.1330067893 0.5403915788 0 0.4052936841 +33.325 2 301.9711121 0 -14.25402426 -0.1773423857 0 -0.7740539187 -0.5403915788 0 0.06964219202 +33.350 1 -1.966509815 0 -15.47488236 0.190836596 0 0.143127447 0.5391298313 0 0.4043473735 +33.350 2 301.9665098 0 -14.27335329 -0.190836596 0 -0.7722465986 -0.5391298313 0 0.07494135602 +33.375 1 -1.961570561 0 -15.47117792 0.2042981075 0 0.1532235806 0.5377757067 0 0.40333178 +33.375 2 301.9615706 0 -14.29263548 -0.2042981075 0 -0.7703069579 -0.5377757067 0 0.0802276792 +33.400 1 -1.956295201 0 -15.4672214 0.2177246135 0 0.1632934601 0.536329437 0 0.4022470777 +33.400 2 301.9562952 0 -14.31186754 -0.2177246135 0 -0.7682353291 -0.536329437 0 0.08550025578 +33.425 1 -1.950684641 0 -15.46301348 0.2311138135 0 0.1733353601 0.5347912699 0 0.4010934525 +33.425 2 301.9506846 0 -14.33104615 -0.2311138135 0 -0.7660320672 -0.5347912699 0 0.09075818233 +33.450 1 -1.944739841 0 -15.45855488 0.2444634134 0 0.18334756 0.5331614692 0 0.3998711019 +33.450 2 301.9447398 0 -14.35016805 -0.2444634134 0 -0.7636975496 -0.5331614692 0 0.09600055794 +33.475 1 -1.938461819 0 -15.45384636 0.2577711257 0 0.1933283443 0.531440314 0 0.3985802355 +33.475 2 301.9384618 0 -14.36922994 -0.2577711257 0 -0.7612321764 -0.531440314 0 0.1012264843 +33.500 1 -1.931851653 0 -15.44888874 0.2710346702 0 0.2032760027 0.5296280992 0 0.3972210744 +33.500 2 301.9318517 0 -14.38822857 -0.2710346702 0 -0.7586363699 -0.5296280992 0 0.1064350661 +33.525 1 -1.924910473 0 -15.44368285 0.2842517744 0 0.2131888308 0.5277251354 0 0.3957938516 +33.525 2 301.9249105 0 -14.40716067 -0.2842517744 0 -0.7559105751 -0.5277251354 0 0.1116254108 +33.550 1 -1.91763947 0 -15.4382296 0.2974201735 0 0.2230651301 0.5257317486 0 0.3942988115 +33.550 2 301.9176395 0 -14.42602302 -0.2974201735 0 -0.7530552588 -0.5257317486 0 0.116796629 +33.575 1 -1.910039889 0 -15.43252992 0.3105376111 0 0.2329032084 0.5236482804 0 0.3927362103 +33.575 2 301.9100399 0 -14.44481236 -0.3105376111 0 -0.7500709104 -0.5236482804 0 0.1219478347 +33.600 1 -1.902113033 0 -15.42658477 0.3236018398 0 0.2427013798 0.5214750877 0 0.3911063158 +33.600 2 301.902113 0 -14.46352549 -0.3236018398 0 -0.7469580412 -0.5214750877 0 0.1270781453 +33.625 1 -1.893860259 0 -15.42039519 0.3366106209 0 0.2524579657 0.519212543 0 0.3894094072 +33.625 2 301.8938603 0 -14.4821592 -0.3366106209 0 -0.7437171846 -0.519212543 0 0.1321866817 +33.650 1 -1.885282982 0 -15.41396224 0.3495617256 0 0.2621712942 0.5168610338 0 0.3876457754 +33.650 2 301.885283 0 -14.50071029 -0.3495617256 0 -0.7403488958 -0.5168610338 0 0.1372725686 +33.675 1 -1.876382672 0 -15.407287 0.3624529346 0 0.2718397009 0.5144209632 0 0.3858157224 +33.675 2 301.8763827 0 -14.51917559 -0.3624529346 0 -0.7368537521 -0.5144209632 0 0.1423349346 +33.700 1 -1.867160853 0 -15.40037064 0.3752820392 0 0.2814615294 0.5118927492 0 0.3839195619 +33.700 2 301.8671609 0 -14.53755192 -0.3752820392 0 -0.7332323524 -0.5118927492 0 0.1473729122 +33.725 1 -1.857619106 0 -15.39321433 0.3880468411 0 0.2910351309 0.509276825 0 0.3819576188 +33.725 2 301.8576191 0 -14.55583616 -0.3880468411 0 -0.729485317 -0.509276825 0 0.1523856382 +33.750 1 -1.847759065 0 -15.3858193 0.4007451533 0 0.3005588649 0.5065736389 0 0.3799302292 +33.750 2 301.8477591 0 -14.57402515 -0.4007451533 0 -0.725613288 -0.5065736389 0 0.1573722537 +33.775 1 -1.83758242 0 -15.37818682 0.4133747998 0 0.3100310998 0.503783654 0 0.3778377405 +33.775 2 301.8375824 0 -14.59211578 -0.4133747998 0 -0.721616929 -0.503783654 0 0.1623319043 +33.800 1 -1.827090915 0 -15.37031819 0.4259336166 0 0.3194502125 0.5009073483 0 0.3756805112 +33.800 2 301.8270909 0 -14.61010496 -0.4259336166 0 -0.7174969246 -0.5009073483 0 0.1672637401 +33.825 1 -1.816286348 0 -15.36221476 0.4384194519 0 0.328814589 0.4979452147 0 0.3734589111 +33.825 2 301.8162863 0 -14.62798961 -0.4384194519 0 -0.7132539808 -0.4979452147 0 0.1721669162 +33.850 1 -1.805170569 0 -15.35387793 0.4508301663 0 0.3381226248 0.4948977608 0 0.3711733206 +33.850 2 301.8051706 0 -14.64576665 -0.4508301663 0 -0.7088888246 -0.4948977608 0 0.1770405923 +33.875 1 -1.793745483 0 -15.34530911 0.4631636333 0 0.347372725 0.4917655087 0 0.3688241315 +33.875 2 301.7937455 0 -14.66343304 -0.4631636333 0 -0.704402204 -0.4917655087 0 0.1818839335 +33.900 1 -1.782013048 0 -15.33650979 0.4754177396 0 0.3565633047 0.4885489951 0 0.3664117464 +33.900 2 301.782013 0 -14.68098575 -0.4754177396 0 -0.6997948877 -0.4885489951 0 0.1866961098 +33.925 1 -1.769975275 0 -15.32748146 0.4875903855 0 0.3656927891 0.4852487712 0 0.3639365784 +33.925 2 301.7699753 0 -14.69842178 -0.4875903855 0 -0.6950676651 -0.4852487712 0 0.1914762966 +33.950 1 -1.757634225 0 -15.31822567 0.4996794853 0 0.374759614 0.4818654024 0 0.3613990518 +33.950 2 301.7576342 0 -14.71573814 -0.4996794853 0 -0.6902213462 -0.4818654024 0 0.196223675 +33.975 1 -1.744992014 0 -15.30874401 0.5116829676 0 0.3837622257 0.4783994684 0 0.3587996013 +33.975 2 301.744992 0 -14.73293186 -0.5116829676 0 -0.6852567615 -0.4783994684 0 0.2009374315 +34.000 1 -1.732050808 0 -15.29903811 0.5235987756 0 0.3926990817 0.4748515631 0 0.3561386724 +34.000 2 301.7320508 0 -14.75 -0.5235987756 0 -0.6801747616 -0.4748515631 0 0.2056167584 +34.025 1 -1.718812823 0 -15.28910962 0.5354248677 0 0.4015686508 0.4712222945 0 0.3534167209 +34.025 2 301.7188128 0 -14.76693963 -0.5354248677 0 -0.6749762172 -0.4712222945 0 0.2102608539 +34.050 1 -1.705280329 0 -15.27896025 0.5471592175 0 0.4103694131 0.4675122844 0 0.3506342133 +34.050 2 301.7052803 0 -14.78374785 -0.5471592175 0 -0.6696620191 -0.4675122844 0 0.2148689222 +34.075 1 -1.691455643 0 -15.26859173 0.5587998143 0 0.4190998608 0.4637221684 0 0.3477916263 +34.075 2 301.6914556 0 -14.80042177 -0.5587998143 0 -0.6642330779 -0.4637221684 0 0.2194401739 +34.100 1 -1.677341136 0 -15.25800585 0.5703446638 0 0.4277584978 0.459852596 0 0.344889447 +34.100 2 301.6773411 0 -14.81695855 -0.5703446638 0 -0.6586903238 -0.459852596 0 0.2239738257 +34.125 1 -1.662939225 0 -15.24720442 0.5817917875 0 0.4363438407 0.4559042303 0 0.3419281727 +34.125 2 301.6629392 0 -14.83335535 -0.5817917875 0 -0.6530347064 -0.4559042303 0 0.2284691007 +34.150 1 -1.648252377 0 -15.23618928 0.5931392243 0 0.4448544182 0.4518777477 0 0.3389083108 +34.150 2 301.6482524 0 -14.84960936 -0.5931392243 0 -0.647267195 -0.4518777477 0 0.2329252287 +34.175 1 -1.63328311 0 -15.22496233 0.6043850297 0 0.4532887723 0.4477738382 0 0.3358303786 +34.175 2 301.6332831 0 -14.86571779 -0.6043850297 0 -0.6413887776 -0.4477738382 0 0.2373414462 +34.200 1 -1.618033989 0 -15.21352549 0.6155272768 0 0.4616454576 0.4435932049 0 0.3326949037 +34.200 2 301.618034 0 -14.88167788 -0.6155272768 0 -0.6354004615 -0.4435932049 0 0.2417169964 +34.225 1 -1.602507625 0 -15.20188072 0.6265640565 0 0.4699230424 0.4393365642 0 0.3295024232 +34.225 2 301.6025076 0 -14.8974869 -0.6265640565 0 -0.6293032729 -0.4393365642 0 0.2460511296 +34.250 1 -1.586706681 0 -15.19003001 0.6374934777 0 0.4781201083 0.4350046455 0 0.3262534841 +34.250 2 301.5867067 0 -14.91314214 -0.6374934777 0 -0.6230982564 -0.4350046455 0 0.2503431033 +34.275 1 -1.570633862 0 -15.1779754 0.6483136677 0 0.4862352508 0.430598191 0 0.3229486432 +34.275 2 301.5706339 0 -14.92864092 -0.6483136677 0 -0.6167864752 -0.430598191 0 0.2545921819 +34.300 1 -1.554291923 0 -15.16571894 0.6590227724 0 0.4942670793 0.4261179556 0 0.3195884667 +34.300 2 301.5542919 0 -14.94398059 -0.6590227724 0 -0.6103690108 -0.4261179556 0 0.2587976376 +34.325 1 -1.537683664 0 -15.15326275 0.669618957 0 0.5022142178 0.4215647072 0 0.3161735304 +34.325 2 301.5376837 0 -14.9591585 -0.669618957 0 -0.6038469629 -0.4215647072 0 0.2629587495 +34.350 1 -1.520811931 0 -15.14060895 0.6801004058 0 0.5100753044 0.4169392258 0 0.3127044194 +34.350 2 301.5208119 0 -14.97417207 -0.6801004058 0 -0.5972214488 -0.4169392258 0 0.2670748048 +34.375 1 -1.503679615 0 -15.12775971 0.690465323 0 0.5178489922 0.412242304 0 0.309181728 +34.375 2 301.5036796 0 -14.98901872 -0.690465323 0 -0.590493604 -0.412242304 0 0.2711450983 +34.400 1 -1.486289651 0 -15.11471724 0.7007119324 0 0.5255339493 0.4074747467 0 0.30560606 +34.400 2 301.4862897 0 -15.00369591 -0.7007119324 0 -0.5836645811 -0.4074747467 0 0.2751689324 +34.425 1 -1.468645019 0 -15.10148376 0.7108384785 0 0.5331288589 0.4026373706 0 0.301978028 +34.425 2 301.468645 0 -15.01820112 -0.7108384785 0 -0.5767355503 -0.4026373706 0 0.2791456177 +34.450 1 -1.450748742 0 -15.08806156 0.720843226 0 0.5406324195 0.3977310047 0 0.2982982535 +34.450 2 301.4507487 0 -15.03253186 -0.720843226 0 -0.5697076988 -0.3977310047 0 0.2830744729 +34.475 1 -1.432603887 0 -15.07445292 0.7307244608 0 0.5480433456 0.3927564896 0 0.2945673672 +34.475 2 301.4326039 0 -15.04668569 -0.7307244608 0 -0.5625822308 -0.3927564896 0 0.2869548247 +34.500 1 -1.414213562 0 -15.06066017 0.7404804897 0 0.5553603673 0.3877146778 0 0.2907860083 +34.500 2 301.4142136 0 -15.06066017 -0.7404804897 0 -0.5553603673 -0.3877146778 0 0.2907860083 +34.525 1 -1.39558092 0 -15.04668569 0.7501096411 0 0.5625822308 0.382606433 0 0.2869548247 +34.525 2 301.3955809 0 -15.07445292 -0.7501096411 0 -0.5480433456 -0.382606433 0 0.2945673672 +34.550 1 -1.376709151 0 -15.03253186 0.759610265 0 0.5697076988 0.3774326305 0 0.2830744729 +34.550 2 301.3767092 0 -15.08806156 -0.759610265 0 -0.5406324195 -0.3774326305 0 0.2982982535 +34.575 1 -1.357601491 0 -15.01820112 0.7689807337 0 0.5767355503 0.372194157 0 0.2791456177 +34.575 2 301.3576015 0 -15.10148376 -0.7689807337 0 -0.5331288589 -0.372194157 0 0.301978028 +34.600 1 -1.338261213 0 -15.00369591 0.7782194414 0 0.5836645811 0.3668919099 0 0.2751689324 +34.600 2 301.3382612 0 -15.11471724 -0.7782194414 0 -0.5255339493 -0.3668919099 0 0.30560606 +34.625 1 -1.31869163 0 -14.98901872 0.7873248053 0 0.590493604 0.3615267977 0 0.2711450983 +34.625 2 301.3186916 0 -15.12775971 -0.7873248053 0 -0.5178489922 -0.3615267977 0 0.309181728 +34.650 1 -1.298896097 0 -14.97417207 0.7962952651 0 0.5972214488 0.3560997398 0 0.2670748048 +34.650 2 301.2988961 0 -15.14060895 -0.7962952651 0 -0.5100753044 -0.3560997398 0 0.3127044194 +34.675 1 -1.278878004 0 -14.9591585 0.8051292838 0 0.6038469629 0.350611666 0 0.2629587495 +34.675 2 301.278878 0 -15.15326275 -0.8051292838 0 -0.5022142178 -0.350611666 0 0.3161735304 +34.700 1 -1.258640782 0 -14.94398059 0.8138253478 0 0.6103690108 0.3450635167 0 0.2587976376 +34.700 2 301.2586408 0 -15.16571894 -0.8138253478 0 -0.4942670793 -0.3450635167 0 0.3195884667 +34.725 1 -1.238187899 0 -14.92864092 0.8223819669 0 0.6167864752 0.3394562426 0 0.2545921819 +34.725 2 301.2381879 0 -15.1779754 -0.8223819669 0 -0.4862352508 -0.3394562426 0 0.3229486432 +34.750 1 -1.217522858 0 -14.91314214 0.8307976752 0 0.6230982564 0.3337908044 0 0.2503431033 +34.750 2 301.2175229 0 -15.19003001 -0.8307976752 0 -0.4781201083 -0.3337908044 0 0.3262534841 +34.775 1 -1.196649201 0 -14.8974869 0.8390710305 0 0.6293032729 0.3280681728 0 0.2460511296 +34.775 2 301.1966492 0 -15.20188072 -0.8390710305 0 -0.4699230424 -0.3280681728 0 0.3295024232 +34.800 1 -1.175570505 0 -14.88167788 0.8472006154 0 0.6354004615 0.3222893285 0 0.2417169964 +34.800 2 301.1755705 0 -15.21352549 -0.8472006154 0 -0.4616454576 -0.3222893285 0 0.3326949037 +34.825 1 -1.15429038 0 -14.86571779 0.8551850368 0 0.6413887776 0.3164552615 0 0.2373414462 +34.825 2 301.1542904 0 -15.22496233 -0.8551850368 0 -0.4532887723 -0.3164552615 0 0.3358303786 +34.850 1 -1.132812474 0 -14.84960936 0.8630229266 0 0.647267195 0.3105669716 0 0.2329252287 +34.850 2 301.1328125 0 -15.23618928 -0.8630229266 0 -0.4448544182 -0.3105669716 0 0.3389083108 +34.875 1 -1.111140466 0 -14.83335535 0.8707129419 0 0.6530347064 0.3046254676 0 0.2284691007 +34.875 2 301.1111405 0 -15.24720442 -0.8707129419 0 -0.4363438407 -0.3046254676 0 0.3419281727 +34.900 1 -1.08927807 0 -14.81695855 0.878253765 0 0.6586903238 0.2986317676 0 0.2239738257 +34.900 2 301.0892781 0 -15.25800585 -0.878253765 0 -0.4277584978 -0.2986317676 0 0.344889447 +34.925 1 -1.067229032 0 -14.80042177 0.8856441039 0 0.6642330779 0.2925868986 0 0.2194401739 +34.925 2 301.067229 0 -15.26859173 -0.8856441039 0 -0.4190998608 -0.2925868986 0 0.3477916263 +34.950 1 -1.044997129 0 -14.78374785 0.8928826922 0 0.6696620191 0.2864918963 0 0.2148689222 +34.950 2 301.0449971 0 -15.27896025 -0.8928826922 0 -0.4103694131 -0.2864918963 0 0.3506342133 +34.975 1 -1.022586172 0 -14.76693963 0.8999682896 0 0.6749762172 0.2803478051 0 0.2102608539 +34.975 2 301.0225862 0 -15.28910962 -0.8999682896 0 -0.4015686508 -0.2803478051 0 0.3534167209 +35.000 1 -1 0 -14.75 0.9068996821 0 0.6801747616 0.2741556778 0 0.2056167584 +35.000 2 301 0 -15.29903811 -0.9068996821 0 -0.3926990817 -0.2741556778 0 0.3561386724 +35.025 1 -0.977242483 0 -14.73293186 0.913675682 0 0.6852567615 0.2679165753 0 0.2009374315 +35.025 2 300.9772425 0 -15.30874401 -0.913675682 0 -0.3837622257 -0.2679165753 0 0.3587996013 +35.050 1 -0.9543175205 0 -14.71573814 0.9202951283 0 0.6902213462 0.2616315667 0 0.196223675 +35.050 2 300.9543175 0 -15.31822567 -0.9202951283 0 -0.374759614 -0.2616315667 0 0.3613990518 +35.075 1 -0.9312290407 0 -14.69842178 0.9267568868 0 0.6950676651 0.2553017288 0 0.1914762966 +35.075 2 300.931229 0 -15.32748146 -0.9267568868 0 -0.3656927891 -0.2553017288 0 0.3639365784 +35.100 1 -0.9079809995 0 -14.68098575 0.9330598502 0 0.6997948877 0.2489281463 0 0.1866961098 +35.100 2 300.907981 0 -15.33650979 -0.9330598502 0 -0.3565633047 -0.2489281463 0 0.3664117464 +35.125 1 -0.8845773804 0 -14.66343304 0.9392029387 0 0.704402204 0.2425119113 0 0.1818839335 +35.125 2 300.8845774 0 -15.34530911 -0.9392029387 0 -0.347372725 -0.2425119113 0 0.3688241315 +35.150 1 -0.8610221936 0 -14.64576665 0.9451850995 0 0.7088888246 0.2360541231 0 0.1770405923 +35.150 2 300.8610222 0 -15.35387793 -0.9451850995 0 -0.3381226248 -0.2360541231 0 0.3711733206 +35.175 1 -0.8373194751 0 -14.62798961 0.9510053078 0 0.7132539808 0.2295558882 0 0.1721669162 +35.175 2 300.8373195 0 -15.36221476 -0.9510053078 0 -0.328814589 -0.2295558882 0 0.3734589111 +35.200 1 -0.8134732862 0 -14.61010496 0.9566625662 0 0.7174969246 0.2230183201 0 0.1672637401 +35.200 2 300.8134733 0 -15.37031819 -0.9566625662 0 -0.3194502125 -0.2230183201 0 0.3756805112 +35.225 1 -0.7894877128 0 -14.59211578 0.9621559053 0 0.721616929 0.216442539 0 0.1623319043 +35.225 2 300.7894877 0 -15.37818682 -0.9621559053 0 -0.3100310998 -0.216442539 0 0.3778377405 +35.250 1 -0.7653668647 0 -14.57402515 0.967484384 0 0.725613288 0.2098296716 0 0.1573722537 +35.250 2 300.7653669 0 -15.3858193 -0.967484384 0 -0.3005588649 -0.2098296716 0 0.3799302292 +35.275 1 -0.741114875 0 -14.55583616 0.9726470893 0 0.729485317 0.2031808509 0 0.1523856382 +35.275 2 300.7411149 0 -15.39321433 -0.9726470893 0 -0.2910351309 -0.2031808509 0 0.3819576188 +35.300 1 -0.7167358991 0 -14.53755192 0.9776431365 0 0.7332323524 0.1964972162 0 0.1473729122 +35.300 2 300.7167359 0 -15.40037064 -0.9776431365 0 -0.2814615294 -0.1964972162 0 0.3839195619 +35.325 1 -0.6922341142 0 -14.51917559 0.9824716695 0 0.7368537521 0.1897799128 0 0.1423349346 +35.325 2 300.6922341 0 -15.407287 -0.9824716695 0 -0.2718397009 -0.1897799128 0 0.3858157224 +35.350 1 -0.6676137185 0 -14.50071029 0.9871318611 0 0.7403488958 0.1830300915 0 0.1372725686 +35.350 2 300.6676137 0 -15.41396224 -0.9871318611 0 -0.2621712942 -0.1830300915 0 0.3876457754 +35.375 1 -0.6428789306 0 -14.4821592 0.9916229128 0 0.7437171846 0.176248909 0 0.1321866817 +35.375 2 300.6428789 0 -15.42039519 -0.9916229128 0 -0.2524579657 -0.176248909 0 0.3894094072 +35.400 1 -0.6180339887 0 -14.46352549 0.9959440549 0 0.7469580412 0.1694375271 0 0.1270781453 +35.400 2 300.618034 0 -15.42658477 -0.9959440549 0 -0.2427013798 -0.1694375271 0 0.3911063158 +35.425 1 -0.59308315 0 -14.44481236 1.000094547 0 0.7500709104 0.162597113 0 0.1219478347 +35.425 2 300.5930831 0 -15.43252992 -1.000094547 0 -0.2329032084 -0.162597113 0 0.3927362103 +35.450 1 -0.5680306894 0 -14.42602302 1.004073678 0 0.7530552588 0.1557288387 0 0.116796629 +35.450 2 300.5680307 0 -15.4382296 -1.004073678 0 -0.2230651301 -0.1557288387 0 0.3942988115 +35.475 1 -0.5428808997 0 -14.40716067 1.007880767 0 0.7559105751 0.148833881 0 0.1116254108 +35.475 2 300.5428809 0 -15.44368285 -1.007880767 0 -0.2131888308 -0.148833881 0 0.3957938516 +35.500 1 -0.5176380902 0 -14.38822857 1.01151516 0 0.7586363699 0.1419134215 0 0.1064350661 +35.500 2 300.5176381 0 -15.44888874 -1.01151516 0 -0.2032760027 -0.1419134215 0 0.3972210744 +35.525 1 -0.4923065861 0 -14.36922994 1.014976235 0 0.7612321764 0.1349686458 0 0.1012264843 +35.525 2 300.4923066 0 -15.45384636 -1.014976235 0 -0.1933283443 -0.1349686458 0 0.3985802355 +35.550 1 -0.4668907277 0 -14.35016805 1.018263399 0 0.7636975496 0.1280007439 0 0.09600055794 +35.550 2 300.4668907 0 -15.45855488 -1.018263399 0 -0.18334756 -0.1280007439 0 0.3998711019 +35.575 1 -0.44139487 0 -14.33104615 1.02137609 0 0.7660320672 0.1210109098 0 0.09075818233 +35.575 2 300.4413949 0 -15.46301348 -1.02137609 0 -0.1733353601 -0.1210109098 0 0.4010934525 +35.600 1 -0.4158233816 0 -14.31186754 1.024313772 0 0.7682353291 0.114000341 0 0.08550025578 +35.600 2 300.4158234 0 -15.4672214 -1.024313772 0 -0.1632934601 -0.114000341 0 0.4022470777 +35.625 1 -0.390180644 0 -14.29263548 1.027075944 0 0.7703069579 0.1069702389 0 0.0802276792 +35.625 2 300.3901806 0 -15.47117792 -1.027075944 0 -0.1532235806 -0.1069702389 0 0.40333178 +35.650 1 -0.364471051 0 -14.27335329 1.029662131 0 0.7722465986 0.09992180802 0 0.07494135602 +35.650 2 300.3644711 0 -15.47488236 -1.029662131 0 -0.143127447 -0.09992180802 0 0.4043473735 +35.675 1 -0.3386990077 0 -14.25402426 1.032071892 0 0.7740539187 0.09285625603 0 0.06964219202 +35.675 2 300.338699 0 -15.47833409 -1.032071892 0 -0.1330067893 -0.09285625603 0 0.4052936841 +35.700 1 -0.3128689301 0 -14.2346517 1.034304812 0 0.7757286087 0.08577479359 0 0.06433109519 +35.700 2 300.3128689 0 -15.48153251 -1.034304812 0 -0.1228633415 -0.08577479359 0 0.4061705497 +35.725 1 -0.286985244 0 -14.21523893 1.036360509 0 0.7772703816 0.07867863408 0 0.05900897556 +35.725 2 300.2869852 0 -15.48447708 -1.036360509 0 -0.1126988418 -0.07867863408 0 0.4069778201 +35.750 1 -0.2610523844 0 -14.19578929 1.038238631 0 0.7786789732 0.0715689934 0 0.05367674505 +35.750 2 300.2610524 0 -15.48716729 -1.038238631 0 -0.1025150316 -0.0715689934 0 0.407715357 +35.775 1 -0.2350747949 0 -14.1763061 1.039938856 0 0.7799541422 0.06444708974 0 0.0483353173 +35.775 2 300.2350748 0 -15.48960269 -1.039938856 0 -0.09231365609 -0.06444708974 0 0.4083830339 +35.800 1 -0.2090569265 0 -14.15679269 1.041460893 0 0.7810956701 0.05731414339 0 0.04298560755 +35.800 2 300.2090569 0 -15.49178284 -1.041460893 0 -0.08209646307 -0.05731414339 0 0.4089807365 +35.825 1 -0.1830032373 0 -14.13725243 1.042804482 0 0.7821033612 0.05017137657 0 0.03762853243 +35.825 2 300.1830032 0 -15.49370739 -1.042804482 0 -0.07186520325 -0.05017137657 0 0.4095083623 +35.850 1 -0.1569181915 0 -14.11768864 1.043969391 0 0.782977043 0.04302001314 0 0.03226500985 +35.850 2 300.1569182 0 -15.495376 -1.043969391 0 -0.06162162969 -0.04302001314 0 0.409965821 +35.875 1 -0.1308062585 0 -14.09810469 1.044955421 0 0.7837165656 0.03586127845 0 0.02689595884 +35.875 2 300.1308063 0 -15.49678838 -1.044955421 0 -0.05136749758 -0.03586127845 0 0.4103530342 +35.900 1 -0.1046719125 0 -14.07850393 1.045762403 0 0.7843218025 0.02869639912 0 0.02152229934 +35.900 2 300.1046719 0 -15.4979443 -1.045762403 0 -0.04110456391 -0.02869639912 0 0.4106699355 +35.925 1 -0.07851963152 0 -14.05888972 1.0463902 0 0.7847926499 0.0215266028 0 0.0161449521 +35.925 2 300.0785196 0 -15.49884355 -1.0463902 0 -0.03083458719 -0.0215266028 0 0.4109164706 +35.950 1 -0.05235389662 0 -14.03926542 1.046838703 0 0.7851290271 0.01435311801 0 0.01076483851 +35.950 2 300.0523539 0 -15.49948599 -1.046838703 0 -0.02055932712 -0.01435311801 0 0.4110925973 +35.975 1 -0.02617919114 0 -14.01963439 1.047107835 0 0.7853308764 0.007177173892 0 0.005382880419 +35.975 2 300.0261792 0 -15.49987149 -1.047107835 0 -0.01028054432 -0.007177173892 0 0.4111982853 +36.000 1 -1.469576159e-15 0 -14 1.047197551 0 0.7853981634 4.02892648e-16 0 3.02169486e-16 +36.000 2 300 0 -15.5 -1.047197551 0 -1.92415684e-15 -4.700414226e-16 0 0.4112335167 diff --git a/examples/data/shared/generate_floater_motion.py b/examples/data/shared/generate_floater_motion.py new file mode 100644 index 00000000..6b20c1a4 --- /dev/null +++ b/examples/data/shared/generate_floater_motion.py @@ -0,0 +1,75 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Copyright (c) 2026 Jae Hoon Seo, SMI Lab, Inha University +"""Generate the hang-off motions of the two floaters of shared_cable_two_floaters.dat. + +Floater 1 (point 1, at x = 0) and floater 2 (point 2, at x = 300 m) each surge 2 m and +heave 1.5 m at a 12 s period. Floater 2 surges in antiphase with floater 1, so the span between +the hang-offs opens and closes by 4 m, and heaves a quarter period behind it. Both motions start +smoothly through a 12 s C2 quintic ramp of their amplitude. +""" + +from __future__ import annotations + +import math +from pathlib import Path + +DT = 0.025 +T_MAX = 36.0 +PERIOD = 12.0 +RAMP_DURATION = 12.0 +# point id, deck position (m), surge amplitude (m), surge phase (rad), heave amplitude (m), +# heave phase (rad) +FLOATERS = ( + (1, (0.0, 0.0, -14.0), 2.0, 0.0, 1.5, 0.0), + (2, (300.0, 0.0, -14.0), 2.0, math.pi, 1.5, -0.5 * math.pi), +) + + +def ramp(time: float) -> tuple[float, float, float]: + """A C2 quintic ramp from 0 to 1 and its first two time derivatives.""" + if time >= RAMP_DURATION: + return 1.0, 0.0, 0.0 + tau = time / RAMP_DURATION + value = 10.0 * tau**3 - 15.0 * tau**4 + 6.0 * tau**5 + rate = (30.0 * tau**2 - 60.0 * tau**3 + 30.0 * tau**4) / RAMP_DURATION + acceleration = (60.0 * tau - 180.0 * tau**2 + 120.0 * tau**3) / RAMP_DURATION**2 + return value, rate, acceleration + + +def ramped_sine(time: float, amplitude: float, phase: float) -> tuple[float, float, float]: + """amplitude r(t) sin(omega t + phase) and its first two time derivatives.""" + omega = 2.0 * math.pi / PERIOD + value, rate, acceleration = ramp(time) + sine = math.sin(omega * time + phase) + cosine = math.cos(omega * time + phase) + position = amplitude * value * sine + velocity = amplitude * (rate * sine + value * omega * cosine) + accel = amplitude * (acceleration * sine + 2.0 * rate * omega * cosine - value * omega**2 * sine) + return position, velocity, accel + + +def main() -> None: + output = Path(__file__).with_name("floaters_surge_heave_12s_dt0025.txt") + lines = [ + "# File: examples/data/shared/floaters_surge_heave_12s_dt0025.txt", + "# Hang-off motions of the two floaters of shared_cable_two_floaters.dat (motionFile).", + "# Each surges 2 m and heaves 1.5 m at 12 s; floater 2 surges in antiphase and heaves a", + "# quarter period behind floater 1. A 12 s C2 quintic ramp starts both smoothly.", + "# Columns: time(s) point_id x(m) y(m) z(m) vx(m/s) vy(m/s) vz(m/s) " + "ax(m/s2) ay(m/s2) az(m/s2)", + ] + for index in range(round(T_MAX / DT) + 1): + time = index * DT + for point, (x0, y0, z0), surge_a, surge_p, heave_a, heave_p in FLOATERS: + sx, sv, sa = ramped_sine(time, surge_a, surge_p) + hz, hv, ha = ramped_sine(time, heave_a, heave_p) + lines.append( + f"{time:.3f} {point:d} {x0 + sx:.10g} {y0:.10g} {z0 + hz:.10g} " + f"{sv:.10g} 0 {hv:.10g} {sa:.10g} 0 {ha:.10g}" + ) + output.write_text("\n".join(lines) + "\n", encoding="ascii", newline="\n") + + +if __name__ == "__main__": + main() diff --git a/examples/lazy_wave_modules_stiffener.dat b/examples/lazy_wave_modules_stiffener.dat new file mode 100644 index 00000000..d3847401 --- /dev/null +++ b/examples/lazy_wave_modules_stiffener.dat @@ -0,0 +1,80 @@ +--------------------- CableDyn Input File ------------------------------------ +Lazy-wave power cable with discrete buoyancy modules and a bend stiffener on a moving vessel in a current, 36 s +-- The 80 m Gulf of Mexico cable of lazy_wave_buoyancy_modules.dat: its buoyant stretch is ten +-- discrete modules (ATTACHMENTS series 70.614:5.0:115.614) on the bare cable, in a 0.3 m/s +-- current along -X, from the touchdown toward the hang-off; seabed friction (0.5) holds the +-- grounded tail. The hang-off carries the 4 m polyurethane bend stiffener of +-- lazy_wave_bend_stiffener.dat (STIFFENERS: a 0.4 m cylindrical root and a 3.6 m cone) and is +-- clamped (Rigid) along its static tangent on the vessel of lazy_wave_vessel_motion.dat +-- (vesselMotion: 1.5 m surge, 2 m heave and 3 deg pitch at 12 s, after a 12 s smooth start). +-- The mesh puts 0.15 m elements under the stiffener and a couple of metres past its tip, and a +-- node at every module, 0.5 m apart along the buoyant stretch. The modules and the stiffener +-- both enter the static solve, so the march starts in the equilibrium in the current. +-- BendMom1N1 + StfMom1N1 is the root moment, BendMom1N1 the cable's share; Curv1N28 samples +-- the cable 4.05 m from the root, just past the stiffener tip. The Outputs flag r writes the +-- range graph (tension, curvature, bend moment, declination and seabed clearance envelopes +-- from RangeStart) to .Line1.range.out. +--------------------- LINE TYPES --------------------------------------------- +TypeName Diam MassDenInAir EA BA EI Cd_n Cd_t Ca_n Ca_t +(-) (m) (kg/m) (N) (-) (N-m2) (-) (-) (-) (-) +bare 0.160 36.70 4.69e8 0.0 1.99e4 1.2 0.1 1.0 0.0 +--------------------- POINTS ------------------------------------------------ +ID Type X Y Z +(-) (-) (m) (m) (m) +1 Coupled 5.0 0.0 -14.0 +2 Fixed 125.0 0.0 -80.0 +--------------------- LINES ------------------------------------------------- +ID NodeA NodeB Outputs +(-) (-) (-) (-) +1 1 2 r +--------------------- SECTIONS ---------------------------------------------- +LineID LineType Length NumSegs +(-) (-) (m) (-) +1 bare 6.0 40 +1 bare 62.114 62 +1 bare 50.000 100 +1 bare 52.101 52 +--------------------- ATTACHMENTS ------------------------------------------- +LineID ArcLength Mass Volume CdA Ca CdAx +(-) (m) (kg) (m^3) (m^2) (-) (m^2) +1 70.614:5.0:115.614 114.15 0.2297 0.78 1.0 0.2042 +--------------------- STIFFENERS -------------------------------------------- +-- Rows run outward from the root at End A: the cylindrical root, then the cone. +LineID End Length RootOD TipOD InnerD E Density +(-) (-) (m) (m) (m) (m) (Pa) (kg/m^3) +1 A 0.4 0.45 0.45 0.17 5.0e7 1150 +1 A 3.6 0.45 0.18 0.17 5.0e7 1150 +--------------------- END CONNECTIONS --------------------------------------- +-- End A is clamped along the static hang-off tangent in the current (84.4 deg below horizontal). +LineID End Stiffness EzX EzY EzZ +(-) (-) (N-m/rad) (-) (-) (-) +1 A Rigid 0.0984 0.0 -0.9951 +--------------------- OPTIONS ----------------------------------------------- +9.80665 g - Gravitational acceleration (m/s^2) [default: 9.80665] +1025.0 rhoW - Water density (kg/m^3) [default: 1025] +80.0 WtrDpth - Water depth for the flat seabed (m) [default: absent standalone; host-owned OpenFAST] +1.0e5 kBot - Seabed penalty stiffness base (Pa/m) [default: 1.0e5] +1.0e4 cBot - Seabed normal damping base (Pa-s/m) [default: 1.0e4] +0.05 dtM - CableDyn internal time step (s) [default: omitted standalone; the glue DT in OpenFAST] +36.0 TMax - Standalone simulation duration (s), including the 12 s smooth start +data/vessel/vessel_surge_heave_pitch_12s_dt005.txt vesselMotion - 6-DOF vessel record moving every Coupled point rigidly +0.0|0.0|0.0 vesselRef - Vessel reference point, rotation centre and RAO origin (m) [default: 0|0|0] +12.0 RangeStart - First output time in the range graphs (s) [default: 0] +uniform -0.3 0.0 0.0 current - Current model and X/Y/Z velocity (m/s) {none; uniform; profile} [default: none] +none waves - Wave model, height, period, and direction (m, s, deg) {none; airy; jonswap} [default: none] +0 WaterKin - Water-kinematics source {0/none; file; SEASTATE coupled only} [default: no policy] +0.4 rhoInf - Generalised-alpha spectral radius {0<=rhoInf<=1} [default: 0.4] +False modified_newton - Tangent-reuse mode {False=full Newton; True=guarded reuse} [default: False] +False adaptive_mesh - Automatic finite-EI refinement {False; True} [default: False] +dynamic_solver 1.0e-8 1.0e-14 30 12 - Relative tolerance, absolute tolerance, max iterations, backtracks [defaults shown] +0.5 frictionMu - Seabed friction coefficient, holding the grounded tail in the current {none; value>=0} [default: none] +-- Complete option/default reference: cabledyn_options_reference.dat and doc/options.rst. +--------------------- OUTPUTS ----------------------------------------------- +"FairTen1" +"AnchTen1" +"FairIncl1" +"BendMom1N1" +"StfMom1N1" +"Curv1N28" +"TDP1s" +--------------------- need this line ---------------------------------------- diff --git a/examples/moordynC_currents/chain_currents5_grid.dat b/examples/moordynC_currents/chain_currents5_grid.dat new file mode 100644 index 00000000..474378e6 --- /dev/null +++ b/examples/moordynC_currents/chain_currents5_grid.dat @@ -0,0 +1,55 @@ +--------------------- CableDyn Input File ------------------------------------ +CableDyn driver deck -- chain in a MoorDyn-C current grid in x, y, z and time (Currents 5), 120 s +-- The 410 m studless chain of dynamic_chain_waves.dat with its anchor 390 m from the held +-- fairlead in 50 m of water: about 90 m hangs free and the rest lies on the seabed, held by +-- seabed friction (0.7). The current varies along the line, in depth and in time, read from +-- current_profile_4d.txt in this folder (generate_kinematics.py writes it). Line 1 of the file +-- gives the grid size nx ny nz nt, lines 2-5 the x, y, z and t coordinates, line 6 is a header, +-- and each later row is one grid point `x y z t ux uy uz`. Here the current runs across the line +-- (+Y), grows from 0.4 m/s at the fairlead (x = 0) to 1.2 m/s at x = 400 m, is sheared to 30 % +-- of that at the seabed, and ramps in linearly over the first 30 s from still water, the static +-- start. CableDyn interpolates the grid at every node and time as MoorDyn-C v2.7.1 does: linear +-- between grid coordinates, held beyond the end ones, with no fluid acceleration. The hanging +-- chain is pushed out of its plane (L1N5py, the node 40 m from the fairlead); friction holds +-- the grounded chain. +--------------------- LINE TYPES --------------------------------------- +TypeName Diam MassDenInAir EA BA/-zeta EI Cd_n Cd_t Ca_n Ca_t +(-) (m) (kg/m) (N) (N-s/-) (N-m^2) (-) (-) (-) (-) +chain 0.252 390.0 1.674e9 -1.0 0.0 1.37 0.64 1.0 0.0 +--------------------- POINTS ------------------------------------------- +ID Type X Y Z Mass Vol CdA Ca +(-) (-) (m) (m) (m) (kg) (m^3) (m^2) (-) +1 Fixed 390.0 0.0 -50.0 0 0 0 0 +2 Coupled 0.0 0.0 0.0 0 0 0 0 +--------------------- LINES -------------------------------------------- +ID NodeA NodeB Outputs +(-) (-) (-) (-) +1 2 1 - +--------------------- SECTIONS ----------------------------------------- +LineID LineType Length NumSegs +(-) (-) (m) (-) +1 chain 410.0 41 +--------------------- OPTIONS ------------------------------------------ +9.80665 g - Gravitational acceleration (m/s^2) [default: 9.80665] +1025.0 rhoW - Water density (kg/m^3) [default: 1025] +50.0 WtrDpth - Water depth (m) [default: absent standalone; host-owned OpenFAST] +1.0e5 kBot - Seabed penalty stiffness base (Pa/m) [default: 1.0e5] +1.0e4 cBot - Seabed normal damping base (Pa-s/m) [default: 1.0e4] +0.05 dtM - CableDyn internal time step (s) [default: omitted standalone; the glue DT in OpenFAST] +120.0 TMax - Standalone simulation duration (s) [default: omitted standalone; host-owned OpenFAST] +5 Currents - MoorDyn-C current mode {0=none; 1=current_profile.txt; 2=current_profile_dynamic.txt; 5=current_profile_4d.txt} [default: 0] +0 WaterKin - Water-kinematics source {0/none; 3; 7; file; SEASTATE coupled only} [default: no policy] +none waves - Wave model, height, period, and direction (m, s, deg) {none; airy; jonswap} [default: none] +none current - Current model and velocity (m/s) {none; uniform; profile} [default: none] +0.4 rhoInf - Generalised-alpha spectral radius {0<=rhoInf<=1} [default: 0.4] +False modified_newton - Tangent-reuse mode {False=full Newton; True=guarded reuse} [default: False] +False adaptive_mesh - Automatic finite-EI refinement {False; True} [default: False] +dynamic_solver 1.0e-8 1.0e-14 30 12 - Relative tolerance, absolute tolerance, max iterations, backtracks [defaults shown] +0.7 frictionMu - Seabed friction coefficient, holding the grounded chain in the current {none; value>=0} [default: none] +-- Complete option/default reference: cabledyn_options_reference.dat and doc/options.rst. +--------------------- OUTPUTS ------------------------------------------ +"FairTen1" +"AnchTen1" +"FairIncl1" +"L1N5py" +--------------------- need this line ----------------------------------- diff --git a/examples/moordynC_currents/chain_wavekin3_currents2.dat b/examples/moordynC_currents/chain_wavekin3_currents2.dat new file mode 100644 index 00000000..7094b86f --- /dev/null +++ b/examples/moordynC_currents/chain_wavekin3_currents2.dat @@ -0,0 +1,60 @@ +--------------------- CableDyn Input File ------------------------------------ +CableDyn driver deck -- chain in a MoorDyn-C wave record (WaveKin 3) and a current varying in time (Currents 2), 120 s +-- The 410 m studless chain of dynamic_chain_waves.dat with its anchor 390 m from the held +-- fairlead in 50 m of water: about 90 m hangs free and the rest lies on the seabed, held by +-- seabed friction (0.7). The water kinematics come from MoorDyn-C's fixed-name files in this +-- folder (generate_kinematics.py writes them). WaveKin 3 reads wave_elevation.txt, `time +-- elevation` rows from t = 0 without a header: here 280 s of a bimodal swell at the origin +-- (1.0 m at 10 s and 0.6 m at 14 s, travelling along +X). CableDyn resamples it at dtWave, +-- reduces it to its Fourier components up to WvHiCOff (0.5 Hz) and evaluates them at every node +-- with Wheeler stretching. Currents 2 reads current_profile_dynamic.txt, a depth profile in +-- time: line 5 lists the depths, each later row `t ux(z1..zn) uy(z1..zn)`. Here the current, +-- sheared from 30 % of its surface speed at the seabed, turns from along the line (+X) to +-- across it (+Y) while its surface speed grows from 0.5 to 1.0 m/s; it is linear in time between +-- rows, carries no fluid acceleration, and the static start takes its t = 0 profile, as +-- MoorDyn-C does. The hanging chain swings out of its plane as the current turns across it: +-- L1N5px and L1N5py track the node 40 m from the fairlead. +--------------------- LINE TYPES --------------------------------------- +TypeName Diam MassDenInAir EA BA/-zeta EI Cd_n Cd_t Ca_n Ca_t +(-) (m) (kg/m) (N) (N-s/-) (N-m^2) (-) (-) (-) (-) +chain 0.252 390.0 1.674e9 -1.0 0.0 1.37 0.64 1.0 0.0 +--------------------- POINTS ------------------------------------------- +ID Type X Y Z Mass Vol CdA Ca +(-) (-) (m) (m) (m) (kg) (m^3) (m^2) (-) +1 Fixed 390.0 0.0 -50.0 0 0 0 0 +2 Coupled 0.0 0.0 0.0 0 0 0 0 +--------------------- LINES -------------------------------------------- +ID NodeA NodeB Outputs +(-) (-) (-) (-) +1 2 1 - +--------------------- SECTIONS ----------------------------------------- +LineID LineType Length NumSegs +(-) (-) (m) (-) +1 chain 410.0 41 +--------------------- OPTIONS ------------------------------------------ +9.80665 g - Gravitational acceleration (m/s^2) [default: 9.80665] +1025.0 rhoW - Water density (kg/m^3) [default: 1025] +50.0 WtrDpth - Water depth (m) [default: absent standalone; host-owned OpenFAST] +1.0e5 kBot - Seabed penalty stiffness base (Pa/m) [default: 1.0e5] +1.0e4 cBot - Seabed normal damping base (Pa-s/m) [default: 1.0e4] +0.05 dtM - CableDyn internal time step (s) [default: omitted standalone; the glue DT in OpenFAST] +120.0 TMax - Standalone simulation duration (s) [default: omitted standalone; host-owned OpenFAST] +3 WaterKin - Water-kinematics source, here MoorDyn-C WaveKin 3 {0/none; 3; 7; file; SEASTATE coupled only} [default: no policy] +2 Currents - MoorDyn-C current mode {0=none; 1=current_profile.txt; 2=current_profile_dynamic.txt; 5=current_profile_4d.txt} [default: 0] +0.1 dtWave - Resampling step of wave_elevation.txt (s) [default: 0.25] +3.14159 WvHiCOff - High cut-off frequency of the elevation record (rad/s) [default: 3.14159] +none waves - Wave model, height, period, and direction (m, s, deg) {none; airy; jonswap} [default: none] +none current - Current model and velocity (m/s) {none; uniform; profile} [default: none] +0.4 rhoInf - Generalised-alpha spectral radius {0<=rhoInf<=1} [default: 0.4] +False modified_newton - Tangent-reuse mode {False=full Newton; True=guarded reuse} [default: False] +False adaptive_mesh - Automatic finite-EI refinement {False; True} [default: False] +dynamic_solver 1.0e-8 1.0e-14 30 12 - Relative tolerance, absolute tolerance, max iterations, backtracks [defaults shown] +0.7 frictionMu - Seabed friction coefficient, holding the grounded chain in the current {none; value>=0} [default: none] +-- Complete option/default reference: cabledyn_options_reference.dat and doc/options.rst. +--------------------- OUTPUTS ------------------------------------------ +"FairTen1" +"AnchTen1" +"FairIncl1" +"L1N5px" +"L1N5py" +--------------------- need this line ----------------------------------- diff --git a/examples/moordynC_currents/current_profile_4d.txt b/examples/moordynC_currents/current_profile_4d.txt new file mode 100644 index 00000000..6307badd --- /dev/null +++ b/examples/moordynC_currents/current_profile_4d.txt @@ -0,0 +1,42 @@ +2 2 3 3 +0.0 400.0 +-50.0 50.0 +-50.0 -25.0 0.0 +0.0 30.0 120.0 +x y z t ux uy uz +0.0 -50.0 -50.0 0.0 0.000000 0.000000 0.000000 +0.0 -50.0 -25.0 0.0 0.000000 0.000000 0.000000 +0.0 -50.0 0.0 0.0 0.000000 0.000000 0.000000 +0.0 50.0 -50.0 0.0 0.000000 0.000000 0.000000 +0.0 50.0 -25.0 0.0 0.000000 0.000000 0.000000 +0.0 50.0 0.0 0.0 0.000000 0.000000 0.000000 +400.0 -50.0 -50.0 0.0 0.000000 0.000000 0.000000 +400.0 -50.0 -25.0 0.0 0.000000 0.000000 0.000000 +400.0 -50.0 0.0 0.0 0.000000 0.000000 0.000000 +400.0 50.0 -50.0 0.0 0.000000 0.000000 0.000000 +400.0 50.0 -25.0 0.0 0.000000 0.000000 0.000000 +400.0 50.0 0.0 0.0 0.000000 0.000000 0.000000 +0.0 -50.0 -50.0 30.0 0.000000 0.120000 0.000000 +0.0 -50.0 -25.0 30.0 0.000000 0.260000 0.000000 +0.0 -50.0 0.0 30.0 0.000000 0.400000 0.000000 +0.0 50.0 -50.0 30.0 0.000000 0.120000 0.000000 +0.0 50.0 -25.0 30.0 0.000000 0.260000 0.000000 +0.0 50.0 0.0 30.0 0.000000 0.400000 0.000000 +400.0 -50.0 -50.0 30.0 0.000000 0.360000 0.000000 +400.0 -50.0 -25.0 30.0 0.000000 0.780000 0.000000 +400.0 -50.0 0.0 30.0 0.000000 1.200000 0.000000 +400.0 50.0 -50.0 30.0 0.000000 0.360000 0.000000 +400.0 50.0 -25.0 30.0 0.000000 0.780000 0.000000 +400.0 50.0 0.0 30.0 0.000000 1.200000 0.000000 +0.0 -50.0 -50.0 120.0 0.000000 0.120000 0.000000 +0.0 -50.0 -25.0 120.0 0.000000 0.260000 0.000000 +0.0 -50.0 0.0 120.0 0.000000 0.400000 0.000000 +0.0 50.0 -50.0 120.0 0.000000 0.120000 0.000000 +0.0 50.0 -25.0 120.0 0.000000 0.260000 0.000000 +0.0 50.0 0.0 120.0 0.000000 0.400000 0.000000 +400.0 -50.0 -50.0 120.0 0.000000 0.360000 0.000000 +400.0 -50.0 -25.0 120.0 0.000000 0.780000 0.000000 +400.0 -50.0 0.0 120.0 0.000000 1.200000 0.000000 +400.0 50.0 -50.0 120.0 0.000000 0.360000 0.000000 +400.0 50.0 -25.0 120.0 0.000000 0.780000 0.000000 +400.0 50.0 0.0 120.0 0.000000 1.200000 0.000000 diff --git a/examples/moordynC_currents/current_profile_dynamic.txt b/examples/moordynC_currents/current_profile_dynamic.txt new file mode 100644 index 00000000..d50badc1 --- /dev/null +++ b/examples/moordynC_currents/current_profile_dynamic.txt @@ -0,0 +1,11 @@ +--------------------- MoorDyn dynamic currents File ---------------------------------- +a sheared current that turns from +X to +Y and grows from 0.5 to 1.0 m/s over 120 s +line 5 lists the depths (m); each later row is t ux(z1..zn) uy(z1..zn) +-------------------------------------------------------------------------------------- +-50.0 -40.0 -30.0 -20.0 -10.0 0.0 +time ux... uy... +0.0 0.150000 0.220000 0.290000 0.360000 0.430000 0.500000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 +30.0 0.173227 0.254067 0.334906 0.415746 0.496585 0.577425 0.071753 0.105238 0.138723 0.172208 0.205692 0.239177 +60.0 0.159099 0.233345 0.307591 0.381838 0.456084 0.530330 0.159099 0.233345 0.307591 0.381838 0.456084 0.530330 +90.0 0.100454 0.147333 0.194212 0.241091 0.287969 0.334848 0.242518 0.355694 0.468869 0.582044 0.695219 0.808395 +120.0 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.300000 0.440000 0.580000 0.720000 0.860000 1.000000 diff --git a/examples/moordynC_currents/generate_kinematics.py b/examples/moordynC_currents/generate_kinematics.py new file mode 100644 index 00000000..86f063dd --- /dev/null +++ b/examples/moordynC_currents/generate_kinematics.py @@ -0,0 +1,93 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Copyright (c) 2026 Jae Hoon Seo, SMI Lab, Inha University +"""Generate the MoorDyn-C kinematics files of the decks in this folder. + +* wave_elevation.txt (WaveKin 3): 280 s of a bimodal swell at x = 0, a 1.0 m amplitude at 10 s + and 0.6 m at 14 s, sampled every 0.1 s. 280 s holds a whole number of both periods, so the + Fourier reduction of the record recovers the two components exactly. +* current_profile_dynamic.txt (Currents 2): a depth profile in time, sheared from 30 % of the + surface speed at the seabed to the full speed at the surface, which turns from +X (along the + line) to +Y (across it) and grows from 0.5 to 1.0 m/s over 120 s. +* current_profile_4d.txt (Currents 5): a grid in x, y, z and time, a current along +Y (across + the line) that grows from 0.4 m/s at the fairlead (x = 0) to 1.2 m/s at the anchor + (x = 400 m), sheared in depth as above and ramped in over the first 30 s. +""" + +from __future__ import annotations + +import math +from pathlib import Path + +HERE = Path(__file__).resolve().parent +DEPTH = 50.0 +SWELL = ((1.0, 10.0), (0.6, 14.0)) # amplitude (m), period (s) + + +def shear(z: float) -> float: + """Fraction of the surface speed at elevation z: 0.3 at the seabed, 1 at the surface.""" + return 0.3 + 0.7 * (z + DEPTH) / DEPTH + + +def wave_elevation() -> str: + rows = [] + for index in range(2801): + t = 0.1 * index + eta = sum(a * math.cos(2.0 * math.pi * t / period) for a, period in SWELL) + rows.append(f"{t:.1f} {eta:.10f}") + return "\n".join(rows) + "\n" + + +def current_dynamic() -> str: + depths = (-50.0, -40.0, -30.0, -20.0, -10.0, 0.0) + lines = [ + "--------------------- MoorDyn dynamic currents File ----------------------------------", + "a sheared current that turns from +X to +Y and grows from 0.5 to 1.0 m/s over 120 s", + "line 5 lists the depths (m); each later row is t ux(z1..zn) uy(z1..zn)", + "--------------------------------------------------------------------------------------", + " ".join(f"{z:.1f}" for z in depths), + "time ux... uy...", + ] + for t in (0.0, 30.0, 60.0, 90.0, 120.0): + speed = 0.5 + 0.5 * t / 120.0 + heading = 0.5 * math.pi * t / 120.0 + ux = [speed * shear(z) * math.cos(heading) for z in depths] + uy = [speed * shear(z) * math.sin(heading) for z in depths] + lines.append(f"{t:.1f} " + " ".join(f"{u:.6f}" for u in ux + uy)) + return "\n".join(lines) + "\n" + + +def current_4d() -> str: + xs = (0.0, 400.0) + ys = (-50.0, 50.0) + zs = (-50.0, -25.0, 0.0) + ts = (0.0, 30.0, 120.0) + lines = [ + f"{len(xs)} {len(ys)} {len(zs)} {len(ts)}", + " ".join(f"{x:.1f}" for x in xs), + " ".join(f"{y:.1f}" for y in ys), + " ".join(f"{z:.1f}" for z in zs), + " ".join(f"{t:.1f}" for t in ts), + "x y z t ux uy uz", + ] + for t in ts: + ramp = min(t / 30.0, 1.0) + for x in xs: + surface = 0.4 + 0.8 * (x - xs[0]) / (xs[1] - xs[0]) + for y in ys: + for z in zs: + uy = ramp * surface * shear(z) + lines.append(f"{x:.1f} {y:.1f} {z:.1f} {t:.1f} 0.000000 {uy:.6f} 0.000000") + return "\n".join(lines) + "\n" + + +def main() -> None: + (HERE / "wave_elevation.txt").write_text(wave_elevation(), encoding="ascii", newline="\n") + (HERE / "current_profile_dynamic.txt").write_text( + current_dynamic(), encoding="ascii", newline="\n" + ) + (HERE / "current_profile_4d.txt").write_text(current_4d(), encoding="ascii", newline="\n") + + +if __name__ == "__main__": + main() diff --git a/examples/moordynC_currents/wave_elevation.txt b/examples/moordynC_currents/wave_elevation.txt new file mode 100644 index 00000000..644d3c03 --- /dev/null +++ b/examples/moordynC_currents/wave_elevation.txt @@ -0,0 +1,2801 @@ +0.0 1.6000000000 +0.1 1.5974225684 +0.2 1.5896992777 +0.3 1.5768571078 +0.4 1.5589409143 +0.5 1.5360132636 +0.6 1.5081542023 +0.7 1.4754609622 +0.8 1.4380476024 +0.9 1.3960445890 +1.0 1.3495983151 +1.1 1.2988705619 +1.2 1.2440379036 +1.3 1.1852910582 +1.4 1.1228341864 +1.5 1.0568841418 +1.6 0.9876696746 +1.7 0.9154305924 +1.8 0.8404168810 +1.9 0.7628877882 +2.0 0.6831108755 +2.1 0.6013610385 +2.2 0.5179195035 +2.3 0.4330728000 +2.4 0.3471117170 +2.5 0.2603302435 +2.6 0.1730244995 +2.7 0.0854916609 +2.8 -0.0019711180 +2.9 -0.0890677798 +3.0 -0.1755044340 +3.1 -0.2609904158 +3.2 -0.3452393321 +3.3 -0.4279700888 +3.4 -0.5089078968 +3.5 -0.5877852523 +3.6 -0.6643428880 +3.7 -0.7383306913 +3.8 -0.8095085869 +3.9 -0.8776473797 +4.0 -0.9425295547 +4.1 -1.0039500328 +4.2 -1.0617168767 +4.3 -1.1156519469 +4.4 -1.1655915049 +4.5 -1.2113867598 +4.6 -1.2529043586 +4.7 -1.2900268172 +4.8 -1.3226528902 +4.9 -1.3506978798 +5.0 -1.3740938811 +5.1 -1.3927899640 +5.2 -1.4067522907 +5.3 -1.4159641690 +5.4 -1.4204260407 +5.5 -1.4201554058 +5.6 -1.4151866825 +5.7 -1.4055710047 +5.8 -1.3913759562 +5.9 -1.3726852446 +6.0 -1.3495983151 +6.1 -1.3222299063 +6.2 -1.2907095498 +6.3 -1.2551810157 +6.4 -1.2158017062 +6.5 -1.1727419996 +6.6 -1.1261845481 +6.7 -1.0763235312 +6.8 -1.0233638680 +6.9 -0.9675203926 +7.0 -0.9090169944 +7.1 -0.8480857271 +7.2 -0.7849658910 +7.3 -0.7199030906 +7.4 -0.6531482727 +7.5 -0.5849567473 +7.6 -0.5155871969 +7.7 -0.4453006762 +7.8 -0.3743596078 +7.9 -0.3030267764 +8.0 -0.2315643264 +8.1 -0.1602327664 +8.2 -0.0892899846 +8.3 -0.0189902781 +8.4 0.0504165984 +8.5 0.1186863628 +8.6 0.1855811101 +8.7 0.2508701876 +8.8 0.3143310380 +8.9 0.3757500072 +9.0 0.4349231133 +9.1 0.4916567741 +9.2 0.5457684912 +9.3 0.5970874860 +9.4 0.6454552884 +9.5 0.6907262728 +9.6 0.7327681421 +9.7 0.7714623563 +9.8 0.8067045047 +9.9 0.8384046211 +10.0 0.8664874396 +10.1 0.8908925915 +10.2 0.9115747418 +10.3 0.9285036654 +10.4 0.9416642629 +10.5 0.9510565163 +10.6 0.9566953841 +10.7 0.9586106378 +10.8 0.9568466395 +10.9 0.9514620624 +11.0 0.9425295547 +11.1 0.9301353501 +11.2 0.9143788240 +11.3 0.8953720004 +11.4 0.8732390087 +11.5 0.8481154958 +11.6 0.8201479925 +11.7 0.7894932405 +11.8 0.7563174804 +11.9 0.7207957041 +12.0 0.6831108755 +12.1 0.6434531227 +12.2 0.6020189040 +12.3 0.5590101519 +12.4 0.5146333991 +12.5 0.4690988895 +12.6 0.4226196771 +12.7 0.3754107187 +12.8 0.3276879616 +12.9 0.2796674319 +13.0 0.2315643264 +13.1 0.1835921108 +13.2 0.1359616308 +13.3 0.0888802357 +13.4 0.0425509214 +13.5 -0.0028285050 +13.6 -0.0470662366 +13.7 -0.0899772489 +13.8 -0.1313840510 +13.9 -0.1711174029 +14.0 -0.2090169944 +14.1 -0.2449320856 +14.2 -0.2787221036 +14.3 -0.3102571954 +14.4 -0.3394187327 +14.5 -0.3660997690 +14.6 -0.3902054447 +14.7 -0.4116533410 +14.8 -0.4303737789 +14.9 -0.4463100649 +15.0 -0.4594186793 +15.1 -0.4696694093 +15.2 -0.4770454252 +15.3 -0.4815432985 +15.4 -0.4831729645 +15.5 -0.4819576268 +15.6 -0.4779336063 +15.7 -0.4711501342 +15.8 -0.4616690907 +15.9 -0.4495646899 +16.0 -0.4349231133 +16.1 -0.4178420914 +16.2 -0.3984304386 +16.3 -0.3768075395 +16.4 -0.3531027923 +16.5 -0.3274550088 +16.6 -0.3000117760 +16.7 -0.2709287797 +16.8 -0.2403690949 +16.9 -0.2085024453 +17.0 -0.1755044340 +17.1 -0.1415557503 +17.2 -0.1068413551 +17.3 -0.0715496482 +17.4 -0.0358716213 +17.5 -0.0000000000 +17.6 0.0358716213 +17.7 0.0715496482 +17.8 0.1068413551 +17.9 0.1415557503 +18.0 0.1755044340 +18.1 0.2085024453 +18.2 0.2403690949 +18.3 0.2709287797 +18.4 0.3000117760 +18.5 0.3274550088 +18.6 0.3531027923 +18.7 0.3768075395 +18.8 0.3984304386 +18.9 0.4178420914 +19.0 0.4349231133 +19.1 0.4495646899 +19.2 0.4616690907 +19.3 0.4711501342 +19.4 0.4779336063 +19.5 0.4819576268 +19.6 0.4831729645 +19.7 0.4815432985 +19.8 0.4770454252 +19.9 0.4696694093 +20.0 0.4594186793 +20.1 0.4463100649 +20.2 0.4303737789 +20.3 0.4116533410 +20.4 0.3902054447 +20.5 0.3660997690 +20.6 0.3394187327 +20.7 0.3102571954 +20.8 0.2787221036 +20.9 0.2449320856 +21.0 0.2090169944 +21.1 0.1711174029 +21.2 0.1313840510 +21.3 0.0899772489 +21.4 0.0470662366 +21.5 0.0028285050 +21.6 -0.0425509214 +21.7 -0.0888802357 +21.8 -0.1359616308 +21.9 -0.1835921108 +22.0 -0.2315643264 +22.1 -0.2796674319 +22.2 -0.3276879616 +22.3 -0.3754107187 +22.4 -0.4226196771 +22.5 -0.4690988895 +22.6 -0.5146333991 +22.7 -0.5590101519 +22.8 -0.6020189040 +22.9 -0.6434531227 +23.0 -0.6831108755 +23.1 -0.7207957041 +23.2 -0.7563174804 +23.3 -0.7894932405 +23.4 -0.8201479925 +23.5 -0.8481154958 +23.6 -0.8732390087 +23.7 -0.8953720004 +23.8 -0.9143788240 +23.9 -0.9301353501 +24.0 -0.9425295547 +24.1 -0.9514620624 +24.2 -0.9568466395 +24.3 -0.9586106378 +24.4 -0.9566953841 +24.5 -0.9510565163 +24.6 -0.9416642629 +24.7 -0.9285036654 +24.8 -0.9115747418 +24.9 -0.8908925915 +25.0 -0.8664874396 +25.1 -0.8384046211 +25.2 -0.8067045047 +25.3 -0.7714623563 +25.4 -0.7327681421 +25.5 -0.6907262728 +25.6 -0.6454552884 +25.7 -0.5970874860 +25.8 -0.5457684912 +25.9 -0.4916567741 +26.0 -0.4349231133 +26.1 -0.3757500072 +26.2 -0.3143310380 +26.3 -0.2508701876 +26.4 -0.1855811101 +26.5 -0.1186863628 +26.6 -0.0504165984 +26.7 0.0189902781 +26.8 0.0892899846 +26.9 0.1602327664 +27.0 0.2315643264 +27.1 0.3030267764 +27.2 0.3743596078 +27.3 0.4453006762 +27.4 0.5155871969 +27.5 0.5849567473 +27.6 0.6531482727 +27.7 0.7199030906 +27.8 0.7849658910 +27.9 0.8480857271 +28.0 0.9090169944 +28.1 0.9675203926 +28.2 1.0233638680 +28.3 1.0763235312 +28.4 1.1261845481 +28.5 1.1727419996 +28.6 1.2158017062 +28.7 1.2551810157 +28.8 1.2907095498 +28.9 1.3222299063 +29.0 1.3495983151 +29.1 1.3726852446 +29.2 1.3913759562 +29.3 1.4055710047 +29.4 1.4151866825 +29.5 1.4201554058 +29.6 1.4204260407 +29.7 1.4159641690 +29.8 1.4067522907 +29.9 1.3927899640 +30.0 1.3740938811 +30.1 1.3506978798 +30.2 1.3226528902 +30.3 1.2900268172 +30.4 1.2529043586 +30.5 1.2113867598 +30.6 1.1655915049 +30.7 1.1156519469 +30.8 1.0617168767 +30.9 1.0039500328 +31.0 0.9425295547 +31.1 0.8776473797 +31.2 0.8095085869 +31.3 0.7383306913 +31.4 0.6643428880 +31.5 0.5877852523 +31.6 0.5089078968 +31.7 0.4279700888 +31.8 0.3452393321 +31.9 0.2609904158 +32.0 0.1755044340 +32.1 0.0890677798 +32.2 0.0019711180 +32.3 -0.0854916609 +32.4 -0.1730244995 +32.5 -0.2603302435 +32.6 -0.3471117170 +32.7 -0.4330728000 +32.8 -0.5179195035 +32.9 -0.6013610385 +33.0 -0.6831108755 +33.1 -0.7628877882 +33.2 -0.8404168810 +33.3 -0.9154305924 +33.4 -0.9876696746 +33.5 -1.0568841418 +33.6 -1.1228341864 +33.7 -1.1852910582 +33.8 -1.2440379036 +33.9 -1.2988705619 +34.0 -1.3495983151 +34.1 -1.3960445890 +34.2 -1.4380476024 +34.3 -1.4754609622 +34.4 -1.5081542023 +34.5 -1.5360132636 +34.6 -1.5589409143 +34.7 -1.5768571078 +34.8 -1.5896992777 +34.9 -1.5974225684 +35.0 -1.6000000000 +35.1 -1.5974225684 +35.2 -1.5896992777 +35.3 -1.5768571078 +35.4 -1.5589409143 +35.5 -1.5360132636 +35.6 -1.5081542023 +35.7 -1.4754609622 +35.8 -1.4380476024 +35.9 -1.3960445890 +36.0 -1.3495983151 +36.1 -1.2988705619 +36.2 -1.2440379036 +36.3 -1.1852910582 +36.4 -1.1228341864 +36.5 -1.0568841418 +36.6 -0.9876696746 +36.7 -0.9154305924 +36.8 -0.8404168810 +36.9 -0.7628877882 +37.0 -0.6831108755 +37.1 -0.6013610385 +37.2 -0.5179195035 +37.3 -0.4330728000 +37.4 -0.3471117170 +37.5 -0.2603302435 +37.6 -0.1730244995 +37.7 -0.0854916609 +37.8 0.0019711180 +37.9 0.0890677798 +38.0 0.1755044340 +38.1 0.2609904158 +38.2 0.3452393321 +38.3 0.4279700888 +38.4 0.5089078968 +38.5 0.5877852523 +38.6 0.6643428880 +38.7 0.7383306913 +38.8 0.8095085869 +38.9 0.8776473797 +39.0 0.9425295547 +39.1 1.0039500328 +39.2 1.0617168767 +39.3 1.1156519469 +39.4 1.1655915049 +39.5 1.2113867598 +39.6 1.2529043586 +39.7 1.2900268172 +39.8 1.3226528902 +39.9 1.3506978798 +40.0 1.3740938811 +40.1 1.3927899640 +40.2 1.4067522907 +40.3 1.4159641690 +40.4 1.4204260407 +40.5 1.4201554058 +40.6 1.4151866825 +40.7 1.4055710047 +40.8 1.3913759562 +40.9 1.3726852446 +41.0 1.3495983151 +41.1 1.3222299063 +41.2 1.2907095498 +41.3 1.2551810157 +41.4 1.2158017062 +41.5 1.1727419996 +41.6 1.1261845481 +41.7 1.0763235312 +41.8 1.0233638680 +41.9 0.9675203926 +42.0 0.9090169944 +42.1 0.8480857271 +42.2 0.7849658910 +42.3 0.7199030906 +42.4 0.6531482727 +42.5 0.5849567473 +42.6 0.5155871969 +42.7 0.4453006762 +42.8 0.3743596078 +42.9 0.3030267764 +43.0 0.2315643264 +43.1 0.1602327664 +43.2 0.0892899846 +43.3 0.0189902781 +43.4 -0.0504165984 +43.5 -0.1186863628 +43.6 -0.1855811101 +43.7 -0.2508701876 +43.8 -0.3143310380 +43.9 -0.3757500072 +44.0 -0.4349231133 +44.1 -0.4916567741 +44.2 -0.5457684912 +44.3 -0.5970874860 +44.4 -0.6454552884 +44.5 -0.6907262728 +44.6 -0.7327681421 +44.7 -0.7714623563 +44.8 -0.8067045047 +44.9 -0.8384046211 +45.0 -0.8664874396 +45.1 -0.8908925915 +45.2 -0.9115747418 +45.3 -0.9285036654 +45.4 -0.9416642629 +45.5 -0.9510565163 +45.6 -0.9566953841 +45.7 -0.9586106378 +45.8 -0.9568466395 +45.9 -0.9514620624 +46.0 -0.9425295547 +46.1 -0.9301353501 +46.2 -0.9143788240 +46.3 -0.8953720004 +46.4 -0.8732390087 +46.5 -0.8481154958 +46.6 -0.8201479925 +46.7 -0.7894932405 +46.8 -0.7563174804 +46.9 -0.7207957041 +47.0 -0.6831108755 +47.1 -0.6434531227 +47.2 -0.6020189040 +47.3 -0.5590101519 +47.4 -0.5146333991 +47.5 -0.4690988895 +47.6 -0.4226196771 +47.7 -0.3754107187 +47.8 -0.3276879616 +47.9 -0.2796674319 +48.0 -0.2315643264 +48.1 -0.1835921108 +48.2 -0.1359616308 +48.3 -0.0888802357 +48.4 -0.0425509214 +48.5 0.0028285050 +48.6 0.0470662366 +48.7 0.0899772489 +48.8 0.1313840510 +48.9 0.1711174029 +49.0 0.2090169944 +49.1 0.2449320856 +49.2 0.2787221036 +49.3 0.3102571954 +49.4 0.3394187327 +49.5 0.3660997690 +49.6 0.3902054447 +49.7 0.4116533410 +49.8 0.4303737789 +49.9 0.4463100649 +50.0 0.4594186793 +50.1 0.4696694093 +50.2 0.4770454252 +50.3 0.4815432985 +50.4 0.4831729645 +50.5 0.4819576268 +50.6 0.4779336063 +50.7 0.4711501342 +50.8 0.4616690907 +50.9 0.4495646899 +51.0 0.4349231133 +51.1 0.4178420914 +51.2 0.3984304386 +51.3 0.3768075395 +51.4 0.3531027923 +51.5 0.3274550088 +51.6 0.3000117760 +51.7 0.2709287797 +51.8 0.2403690949 +51.9 0.2085024453 +52.0 0.1755044340 +52.1 0.1415557503 +52.2 0.1068413551 +52.3 0.0715496482 +52.4 0.0358716213 +52.5 0.0000000000 +52.6 -0.0358716213 +52.7 -0.0715496482 +52.8 -0.1068413551 +52.9 -0.1415557503 +53.0 -0.1755044340 +53.1 -0.2085024453 +53.2 -0.2403690949 +53.3 -0.2709287797 +53.4 -0.3000117760 +53.5 -0.3274550088 +53.6 -0.3531027923 +53.7 -0.3768075395 +53.8 -0.3984304386 +53.9 -0.4178420914 +54.0 -0.4349231133 +54.1 -0.4495646899 +54.2 -0.4616690907 +54.3 -0.4711501342 +54.4 -0.4779336063 +54.5 -0.4819576268 +54.6 -0.4831729645 +54.7 -0.4815432985 +54.8 -0.4770454252 +54.9 -0.4696694093 +55.0 -0.4594186793 +55.1 -0.4463100649 +55.2 -0.4303737789 +55.3 -0.4116533410 +55.4 -0.3902054447 +55.5 -0.3660997690 +55.6 -0.3394187327 +55.7 -0.3102571954 +55.8 -0.2787221036 +55.9 -0.2449320856 +56.0 -0.2090169944 +56.1 -0.1711174029 +56.2 -0.1313840510 +56.3 -0.0899772489 +56.4 -0.0470662366 +56.5 -0.0028285050 +56.6 0.0425509214 +56.7 0.0888802357 +56.8 0.1359616308 +56.9 0.1835921108 +57.0 0.2315643264 +57.1 0.2796674319 +57.2 0.3276879616 +57.3 0.3754107187 +57.4 0.4226196771 +57.5 0.4690988895 +57.6 0.5146333991 +57.7 0.5590101519 +57.8 0.6020189040 +57.9 0.6434531227 +58.0 0.6831108755 +58.1 0.7207957041 +58.2 0.7563174804 +58.3 0.7894932405 +58.4 0.8201479925 +58.5 0.8481154958 +58.6 0.8732390087 +58.7 0.8953720004 +58.8 0.9143788240 +58.9 0.9301353501 +59.0 0.9425295547 +59.1 0.9514620624 +59.2 0.9568466395 +59.3 0.9586106378 +59.4 0.9566953841 +59.5 0.9510565163 +59.6 0.9416642629 +59.7 0.9285036654 +59.8 0.9115747418 +59.9 0.8908925915 +60.0 0.8664874396 +60.1 0.8384046211 +60.2 0.8067045047 +60.3 0.7714623563 +60.4 0.7327681421 +60.5 0.6907262728 +60.6 0.6454552884 +60.7 0.5970874860 +60.8 0.5457684912 +60.9 0.4916567741 +61.0 0.4349231133 +61.1 0.3757500072 +61.2 0.3143310380 +61.3 0.2508701876 +61.4 0.1855811101 +61.5 0.1186863628 +61.6 0.0504165984 +61.7 -0.0189902781 +61.8 -0.0892899846 +61.9 -0.1602327664 +62.0 -0.2315643264 +62.1 -0.3030267764 +62.2 -0.3743596078 +62.3 -0.4453006762 +62.4 -0.5155871969 +62.5 -0.5849567473 +62.6 -0.6531482727 +62.7 -0.7199030906 +62.8 -0.7849658910 +62.9 -0.8480857271 +63.0 -0.9090169944 +63.1 -0.9675203926 +63.2 -1.0233638680 +63.3 -1.0763235312 +63.4 -1.1261845481 +63.5 -1.1727419996 +63.6 -1.2158017062 +63.7 -1.2551810157 +63.8 -1.2907095498 +63.9 -1.3222299063 +64.0 -1.3495983151 +64.1 -1.3726852446 +64.2 -1.3913759562 +64.3 -1.4055710047 +64.4 -1.4151866825 +64.5 -1.4201554058 +64.6 -1.4204260407 +64.7 -1.4159641690 +64.8 -1.4067522907 +64.9 -1.3927899640 +65.0 -1.3740938811 +65.1 -1.3506978798 +65.2 -1.3226528902 +65.3 -1.2900268172 +65.4 -1.2529043586 +65.5 -1.2113867598 +65.6 -1.1655915049 +65.7 -1.1156519469 +65.8 -1.0617168767 +65.9 -1.0039500328 +66.0 -0.9425295547 +66.1 -0.8776473797 +66.2 -0.8095085869 +66.3 -0.7383306913 +66.4 -0.6643428880 +66.5 -0.5877852523 +66.6 -0.5089078968 +66.7 -0.4279700888 +66.8 -0.3452393321 +66.9 -0.2609904158 +67.0 -0.1755044340 +67.1 -0.0890677798 +67.2 -0.0019711180 +67.3 0.0854916609 +67.4 0.1730244995 +67.5 0.2603302435 +67.6 0.3471117170 +67.7 0.4330728000 +67.8 0.5179195035 +67.9 0.6013610385 +68.0 0.6831108755 +68.1 0.7628877882 +68.2 0.8404168810 +68.3 0.9154305924 +68.4 0.9876696746 +68.5 1.0568841418 +68.6 1.1228341864 +68.7 1.1852910582 +68.8 1.2440379036 +68.9 1.2988705619 +69.0 1.3495983151 +69.1 1.3960445890 +69.2 1.4380476024 +69.3 1.4754609622 +69.4 1.5081542023 +69.5 1.5360132636 +69.6 1.5589409143 +69.7 1.5768571078 +69.8 1.5896992777 +69.9 1.5974225684 +70.0 1.6000000000 +70.1 1.5974225684 +70.2 1.5896992777 +70.3 1.5768571078 +70.4 1.5589409143 +70.5 1.5360132636 +70.6 1.5081542023 +70.7 1.4754609622 +70.8 1.4380476024 +70.9 1.3960445890 +71.0 1.3495983151 +71.1 1.2988705619 +71.2 1.2440379036 +71.3 1.1852910582 +71.4 1.1228341864 +71.5 1.0568841418 +71.6 0.9876696746 +71.7 0.9154305924 +71.8 0.8404168810 +71.9 0.7628877882 +72.0 0.6831108755 +72.1 0.6013610385 +72.2 0.5179195035 +72.3 0.4330728000 +72.4 0.3471117170 +72.5 0.2603302435 +72.6 0.1730244995 +72.7 0.0854916609 +72.8 -0.0019711180 +72.9 -0.0890677798 +73.0 -0.1755044340 +73.1 -0.2609904158 +73.2 -0.3452393321 +73.3 -0.4279700888 +73.4 -0.5089078968 +73.5 -0.5877852523 +73.6 -0.6643428880 +73.7 -0.7383306913 +73.8 -0.8095085869 +73.9 -0.8776473797 +74.0 -0.9425295547 +74.1 -1.0039500328 +74.2 -1.0617168767 +74.3 -1.1156519469 +74.4 -1.1655915049 +74.5 -1.2113867598 +74.6 -1.2529043586 +74.7 -1.2900268172 +74.8 -1.3226528902 +74.9 -1.3506978798 +75.0 -1.3740938811 +75.1 -1.3927899640 +75.2 -1.4067522907 +75.3 -1.4159641690 +75.4 -1.4204260407 +75.5 -1.4201554058 +75.6 -1.4151866825 +75.7 -1.4055710047 +75.8 -1.3913759562 +75.9 -1.3726852446 +76.0 -1.3495983151 +76.1 -1.3222299063 +76.2 -1.2907095498 +76.3 -1.2551810157 +76.4 -1.2158017062 +76.5 -1.1727419996 +76.6 -1.1261845481 +76.7 -1.0763235312 +76.8 -1.0233638680 +76.9 -0.9675203926 +77.0 -0.9090169944 +77.1 -0.8480857271 +77.2 -0.7849658910 +77.3 -0.7199030906 +77.4 -0.6531482727 +77.5 -0.5849567473 +77.6 -0.5155871969 +77.7 -0.4453006762 +77.8 -0.3743596078 +77.9 -0.3030267764 +78.0 -0.2315643264 +78.1 -0.1602327664 +78.2 -0.0892899846 +78.3 -0.0189902781 +78.4 0.0504165984 +78.5 0.1186863628 +78.6 0.1855811101 +78.7 0.2508701876 +78.8 0.3143310380 +78.9 0.3757500072 +79.0 0.4349231133 +79.1 0.4916567741 +79.2 0.5457684912 +79.3 0.5970874860 +79.4 0.6454552884 +79.5 0.6907262728 +79.6 0.7327681421 +79.7 0.7714623563 +79.8 0.8067045047 +79.9 0.8384046211 +80.0 0.8664874396 +80.1 0.8908925915 +80.2 0.9115747418 +80.3 0.9285036654 +80.4 0.9416642629 +80.5 0.9510565163 +80.6 0.9566953841 +80.7 0.9586106378 +80.8 0.9568466395 +80.9 0.9514620624 +81.0 0.9425295547 +81.1 0.9301353501 +81.2 0.9143788240 +81.3 0.8953720004 +81.4 0.8732390087 +81.5 0.8481154958 +81.6 0.8201479925 +81.7 0.7894932405 +81.8 0.7563174804 +81.9 0.7207957041 +82.0 0.6831108755 +82.1 0.6434531227 +82.2 0.6020189040 +82.3 0.5590101519 +82.4 0.5146333991 +82.5 0.4690988895 +82.6 0.4226196771 +82.7 0.3754107187 +82.8 0.3276879616 +82.9 0.2796674319 +83.0 0.2315643264 +83.1 0.1835921108 +83.2 0.1359616308 +83.3 0.0888802357 +83.4 0.0425509214 +83.5 -0.0028285050 +83.6 -0.0470662366 +83.7 -0.0899772489 +83.8 -0.1313840510 +83.9 -0.1711174029 +84.0 -0.2090169944 +84.1 -0.2449320856 +84.2 -0.2787221036 +84.3 -0.3102571954 +84.4 -0.3394187327 +84.5 -0.3660997690 +84.6 -0.3902054447 +84.7 -0.4116533410 +84.8 -0.4303737789 +84.9 -0.4463100649 +85.0 -0.4594186793 +85.1 -0.4696694093 +85.2 -0.4770454252 +85.3 -0.4815432985 +85.4 -0.4831729645 +85.5 -0.4819576268 +85.6 -0.4779336063 +85.7 -0.4711501342 +85.8 -0.4616690907 +85.9 -0.4495646899 +86.0 -0.4349231133 +86.1 -0.4178420914 +86.2 -0.3984304386 +86.3 -0.3768075395 +86.4 -0.3531027923 +86.5 -0.3274550088 +86.6 -0.3000117760 +86.7 -0.2709287797 +86.8 -0.2403690949 +86.9 -0.2085024453 +87.0 -0.1755044340 +87.1 -0.1415557503 +87.2 -0.1068413551 +87.3 -0.0715496482 +87.4 -0.0358716213 +87.5 0.0000000000 +87.6 0.0358716213 +87.7 0.0715496482 +87.8 0.1068413551 +87.9 0.1415557503 +88.0 0.1755044340 +88.1 0.2085024453 +88.2 0.2403690949 +88.3 0.2709287797 +88.4 0.3000117760 +88.5 0.3274550088 +88.6 0.3531027923 +88.7 0.3768075395 +88.8 0.3984304386 +88.9 0.4178420914 +89.0 0.4349231133 +89.1 0.4495646899 +89.2 0.4616690907 +89.3 0.4711501342 +89.4 0.4779336063 +89.5 0.4819576268 +89.6 0.4831729645 +89.7 0.4815432985 +89.8 0.4770454252 +89.9 0.4696694093 +90.0 0.4594186793 +90.1 0.4463100649 +90.2 0.4303737789 +90.3 0.4116533410 +90.4 0.3902054447 +90.5 0.3660997690 +90.6 0.3394187327 +90.7 0.3102571954 +90.8 0.2787221036 +90.9 0.2449320856 +91.0 0.2090169944 +91.1 0.1711174029 +91.2 0.1313840510 +91.3 0.0899772489 +91.4 0.0470662366 +91.5 0.0028285050 +91.6 -0.0425509214 +91.7 -0.0888802357 +91.8 -0.1359616308 +91.9 -0.1835921108 +92.0 -0.2315643264 +92.1 -0.2796674319 +92.2 -0.3276879616 +92.3 -0.3754107187 +92.4 -0.4226196771 +92.5 -0.4690988895 +92.6 -0.5146333991 +92.7 -0.5590101519 +92.8 -0.6020189040 +92.9 -0.6434531227 +93.0 -0.6831108755 +93.1 -0.7207957041 +93.2 -0.7563174804 +93.3 -0.7894932405 +93.4 -0.8201479925 +93.5 -0.8481154958 +93.6 -0.8732390087 +93.7 -0.8953720004 +93.8 -0.9143788240 +93.9 -0.9301353501 +94.0 -0.9425295547 +94.1 -0.9514620624 +94.2 -0.9568466395 +94.3 -0.9586106378 +94.4 -0.9566953841 +94.5 -0.9510565163 +94.6 -0.9416642629 +94.7 -0.9285036654 +94.8 -0.9115747418 +94.9 -0.8908925915 +95.0 -0.8664874396 +95.1 -0.8384046211 +95.2 -0.8067045047 +95.3 -0.7714623563 +95.4 -0.7327681421 +95.5 -0.6907262728 +95.6 -0.6454552884 +95.7 -0.5970874860 +95.8 -0.5457684912 +95.9 -0.4916567741 +96.0 -0.4349231133 +96.1 -0.3757500072 +96.2 -0.3143310380 +96.3 -0.2508701876 +96.4 -0.1855811101 +96.5 -0.1186863628 +96.6 -0.0504165984 +96.7 0.0189902781 +96.8 0.0892899846 +96.9 0.1602327664 +97.0 0.2315643264 +97.1 0.3030267764 +97.2 0.3743596078 +97.3 0.4453006762 +97.4 0.5155871969 +97.5 0.5849567473 +97.6 0.6531482727 +97.7 0.7199030906 +97.8 0.7849658910 +97.9 0.8480857271 +98.0 0.9090169944 +98.1 0.9675203926 +98.2 1.0233638680 +98.3 1.0763235312 +98.4 1.1261845481 +98.5 1.1727419996 +98.6 1.2158017062 +98.7 1.2551810157 +98.8 1.2907095498 +98.9 1.3222299063 +99.0 1.3495983151 +99.1 1.3726852446 +99.2 1.3913759562 +99.3 1.4055710047 +99.4 1.4151866825 +99.5 1.4201554058 +99.6 1.4204260407 +99.7 1.4159641690 +99.8 1.4067522907 +99.9 1.3927899640 +100.0 1.3740938811 +100.1 1.3506978798 +100.2 1.3226528902 +100.3 1.2900268172 +100.4 1.2529043586 +100.5 1.2113867598 +100.6 1.1655915049 +100.7 1.1156519469 +100.8 1.0617168767 +100.9 1.0039500328 +101.0 0.9425295547 +101.1 0.8776473797 +101.2 0.8095085869 +101.3 0.7383306913 +101.4 0.6643428880 +101.5 0.5877852523 +101.6 0.5089078968 +101.7 0.4279700888 +101.8 0.3452393321 +101.9 0.2609904158 +102.0 0.1755044340 +102.1 0.0890677798 +102.2 0.0019711180 +102.3 -0.0854916609 +102.4 -0.1730244995 +102.5 -0.2603302435 +102.6 -0.3471117170 +102.7 -0.4330728000 +102.8 -0.5179195035 +102.9 -0.6013610385 +103.0 -0.6831108755 +103.1 -0.7628877882 +103.2 -0.8404168810 +103.3 -0.9154305924 +103.4 -0.9876696746 +103.5 -1.0568841418 +103.6 -1.1228341864 +103.7 -1.1852910582 +103.8 -1.2440379036 +103.9 -1.2988705619 +104.0 -1.3495983151 +104.1 -1.3960445890 +104.2 -1.4380476024 +104.3 -1.4754609622 +104.4 -1.5081542023 +104.5 -1.5360132636 +104.6 -1.5589409143 +104.7 -1.5768571078 +104.8 -1.5896992777 +104.9 -1.5974225684 +105.0 -1.6000000000 +105.1 -1.5974225684 +105.2 -1.5896992777 +105.3 -1.5768571078 +105.4 -1.5589409143 +105.5 -1.5360132636 +105.6 -1.5081542023 +105.7 -1.4754609622 +105.8 -1.4380476024 +105.9 -1.3960445890 +106.0 -1.3495983151 +106.1 -1.2988705619 +106.2 -1.2440379036 +106.3 -1.1852910582 +106.4 -1.1228341864 +106.5 -1.0568841418 +106.6 -0.9876696746 +106.7 -0.9154305924 +106.8 -0.8404168810 +106.9 -0.7628877882 +107.0 -0.6831108755 +107.1 -0.6013610385 +107.2 -0.5179195035 +107.3 -0.4330728000 +107.4 -0.3471117170 +107.5 -0.2603302435 +107.6 -0.1730244995 +107.7 -0.0854916609 +107.8 0.0019711180 +107.9 0.0890677798 +108.0 0.1755044340 +108.1 0.2609904158 +108.2 0.3452393321 +108.3 0.4279700888 +108.4 0.5089078968 +108.5 0.5877852523 +108.6 0.6643428880 +108.7 0.7383306913 +108.8 0.8095085869 +108.9 0.8776473797 +109.0 0.9425295547 +109.1 1.0039500328 +109.2 1.0617168767 +109.3 1.1156519469 +109.4 1.1655915049 +109.5 1.2113867598 +109.6 1.2529043586 +109.7 1.2900268172 +109.8 1.3226528902 +109.9 1.3506978798 +110.0 1.3740938811 +110.1 1.3927899640 +110.2 1.4067522907 +110.3 1.4159641690 +110.4 1.4204260407 +110.5 1.4201554058 +110.6 1.4151866825 +110.7 1.4055710047 +110.8 1.3913759562 +110.9 1.3726852446 +111.0 1.3495983151 +111.1 1.3222299063 +111.2 1.2907095498 +111.3 1.2551810157 +111.4 1.2158017062 +111.5 1.1727419996 +111.6 1.1261845481 +111.7 1.0763235312 +111.8 1.0233638680 +111.9 0.9675203926 +112.0 0.9090169944 +112.1 0.8480857271 +112.2 0.7849658910 +112.3 0.7199030906 +112.4 0.6531482727 +112.5 0.5849567473 +112.6 0.5155871969 +112.7 0.4453006762 +112.8 0.3743596078 +112.9 0.3030267764 +113.0 0.2315643264 +113.1 0.1602327664 +113.2 0.0892899846 +113.3 0.0189902781 +113.4 -0.0504165984 +113.5 -0.1186863628 +113.6 -0.1855811101 +113.7 -0.2508701876 +113.8 -0.3143310380 +113.9 -0.3757500072 +114.0 -0.4349231133 +114.1 -0.4916567741 +114.2 -0.5457684912 +114.3 -0.5970874860 +114.4 -0.6454552884 +114.5 -0.6907262728 +114.6 -0.7327681421 +114.7 -0.7714623563 +114.8 -0.8067045047 +114.9 -0.8384046211 +115.0 -0.8664874396 +115.1 -0.8908925915 +115.2 -0.9115747418 +115.3 -0.9285036654 +115.4 -0.9416642629 +115.5 -0.9510565163 +115.6 -0.9566953841 +115.7 -0.9586106378 +115.8 -0.9568466395 +115.9 -0.9514620624 +116.0 -0.9425295547 +116.1 -0.9301353501 +116.2 -0.9143788240 +116.3 -0.8953720004 +116.4 -0.8732390087 +116.5 -0.8481154958 +116.6 -0.8201479925 +116.7 -0.7894932405 +116.8 -0.7563174804 +116.9 -0.7207957041 +117.0 -0.6831108755 +117.1 -0.6434531227 +117.2 -0.6020189040 +117.3 -0.5590101519 +117.4 -0.5146333991 +117.5 -0.4690988895 +117.6 -0.4226196771 +117.7 -0.3754107187 +117.8 -0.3276879616 +117.9 -0.2796674319 +118.0 -0.2315643264 +118.1 -0.1835921108 +118.2 -0.1359616308 +118.3 -0.0888802357 +118.4 -0.0425509214 +118.5 0.0028285050 +118.6 0.0470662366 +118.7 0.0899772489 +118.8 0.1313840510 +118.9 0.1711174029 +119.0 0.2090169944 +119.1 0.2449320856 +119.2 0.2787221036 +119.3 0.3102571954 +119.4 0.3394187327 +119.5 0.3660997690 +119.6 0.3902054447 +119.7 0.4116533410 +119.8 0.4303737789 +119.9 0.4463100649 +120.0 0.4594186793 +120.1 0.4696694093 +120.2 0.4770454252 +120.3 0.4815432985 +120.4 0.4831729645 +120.5 0.4819576268 +120.6 0.4779336063 +120.7 0.4711501342 +120.8 0.4616690907 +120.9 0.4495646899 +121.0 0.4349231133 +121.1 0.4178420914 +121.2 0.3984304386 +121.3 0.3768075395 +121.4 0.3531027923 +121.5 0.3274550088 +121.6 0.3000117760 +121.7 0.2709287797 +121.8 0.2403690949 +121.9 0.2085024453 +122.0 0.1755044340 +122.1 0.1415557503 +122.2 0.1068413551 +122.3 0.0715496482 +122.4 0.0358716213 +122.5 0.0000000000 +122.6 -0.0358716213 +122.7 -0.0715496482 +122.8 -0.1068413551 +122.9 -0.1415557503 +123.0 -0.1755044340 +123.1 -0.2085024453 +123.2 -0.2403690949 +123.3 -0.2709287797 +123.4 -0.3000117760 +123.5 -0.3274550088 +123.6 -0.3531027923 +123.7 -0.3768075395 +123.8 -0.3984304386 +123.9 -0.4178420914 +124.0 -0.4349231133 +124.1 -0.4495646899 +124.2 -0.4616690907 +124.3 -0.4711501342 +124.4 -0.4779336063 +124.5 -0.4819576268 +124.6 -0.4831729645 +124.7 -0.4815432985 +124.8 -0.4770454252 +124.9 -0.4696694093 +125.0 -0.4594186793 +125.1 -0.4463100649 +125.2 -0.4303737789 +125.3 -0.4116533410 +125.4 -0.3902054447 +125.5 -0.3660997690 +125.6 -0.3394187327 +125.7 -0.3102571954 +125.8 -0.2787221036 +125.9 -0.2449320856 +126.0 -0.2090169944 +126.1 -0.1711174029 +126.2 -0.1313840510 +126.3 -0.0899772489 +126.4 -0.0470662366 +126.5 -0.0028285050 +126.6 0.0425509214 +126.7 0.0888802357 +126.8 0.1359616308 +126.9 0.1835921108 +127.0 0.2315643264 +127.1 0.2796674319 +127.2 0.3276879616 +127.3 0.3754107187 +127.4 0.4226196771 +127.5 0.4690988895 +127.6 0.5146333991 +127.7 0.5590101519 +127.8 0.6020189040 +127.9 0.6434531227 +128.0 0.6831108755 +128.1 0.7207957041 +128.2 0.7563174804 +128.3 0.7894932405 +128.4 0.8201479925 +128.5 0.8481154958 +128.6 0.8732390087 +128.7 0.8953720004 +128.8 0.9143788240 +128.9 0.9301353501 +129.0 0.9425295547 +129.1 0.9514620624 +129.2 0.9568466395 +129.3 0.9586106378 +129.4 0.9566953841 +129.5 0.9510565163 +129.6 0.9416642629 +129.7 0.9285036654 +129.8 0.9115747418 +129.9 0.8908925915 +130.0 0.8664874396 +130.1 0.8384046211 +130.2 0.8067045047 +130.3 0.7714623563 +130.4 0.7327681421 +130.5 0.6907262728 +130.6 0.6454552884 +130.7 0.5970874860 +130.8 0.5457684912 +130.9 0.4916567741 +131.0 0.4349231133 +131.1 0.3757500072 +131.2 0.3143310380 +131.3 0.2508701876 +131.4 0.1855811101 +131.5 0.1186863628 +131.6 0.0504165984 +131.7 -0.0189902781 +131.8 -0.0892899846 +131.9 -0.1602327664 +132.0 -0.2315643264 +132.1 -0.3030267764 +132.2 -0.3743596078 +132.3 -0.4453006762 +132.4 -0.5155871969 +132.5 -0.5849567473 +132.6 -0.6531482727 +132.7 -0.7199030906 +132.8 -0.7849658910 +132.9 -0.8480857271 +133.0 -0.9090169944 +133.1 -0.9675203926 +133.2 -1.0233638680 +133.3 -1.0763235312 +133.4 -1.1261845481 +133.5 -1.1727419996 +133.6 -1.2158017062 +133.7 -1.2551810157 +133.8 -1.2907095498 +133.9 -1.3222299063 +134.0 -1.3495983151 +134.1 -1.3726852446 +134.2 -1.3913759562 +134.3 -1.4055710047 +134.4 -1.4151866825 +134.5 -1.4201554058 +134.6 -1.4204260407 +134.7 -1.4159641690 +134.8 -1.4067522907 +134.9 -1.3927899640 +135.0 -1.3740938811 +135.1 -1.3506978798 +135.2 -1.3226528902 +135.3 -1.2900268172 +135.4 -1.2529043586 +135.5 -1.2113867598 +135.6 -1.1655915049 +135.7 -1.1156519469 +135.8 -1.0617168767 +135.9 -1.0039500328 +136.0 -0.9425295547 +136.1 -0.8776473797 +136.2 -0.8095085869 +136.3 -0.7383306913 +136.4 -0.6643428880 +136.5 -0.5877852523 +136.6 -0.5089078968 +136.7 -0.4279700888 +136.8 -0.3452393321 +136.9 -0.2609904158 +137.0 -0.1755044340 +137.1 -0.0890677798 +137.2 -0.0019711180 +137.3 0.0854916609 +137.4 0.1730244995 +137.5 0.2603302435 +137.6 0.3471117170 +137.7 0.4330728000 +137.8 0.5179195035 +137.9 0.6013610385 +138.0 0.6831108755 +138.1 0.7628877882 +138.2 0.8404168810 +138.3 0.9154305924 +138.4 0.9876696746 +138.5 1.0568841418 +138.6 1.1228341864 +138.7 1.1852910582 +138.8 1.2440379036 +138.9 1.2988705619 +139.0 1.3495983151 +139.1 1.3960445890 +139.2 1.4380476024 +139.3 1.4754609622 +139.4 1.5081542023 +139.5 1.5360132636 +139.6 1.5589409143 +139.7 1.5768571078 +139.8 1.5896992777 +139.9 1.5974225684 +140.0 1.6000000000 +140.1 1.5974225684 +140.2 1.5896992777 +140.3 1.5768571078 +140.4 1.5589409143 +140.5 1.5360132636 +140.6 1.5081542023 +140.7 1.4754609622 +140.8 1.4380476024 +140.9 1.3960445890 +141.0 1.3495983151 +141.1 1.2988705619 +141.2 1.2440379036 +141.3 1.1852910582 +141.4 1.1228341864 +141.5 1.0568841418 +141.6 0.9876696746 +141.7 0.9154305924 +141.8 0.8404168810 +141.9 0.7628877882 +142.0 0.6831108755 +142.1 0.6013610385 +142.2 0.5179195035 +142.3 0.4330728000 +142.4 0.3471117170 +142.5 0.2603302435 +142.6 0.1730244995 +142.7 0.0854916609 +142.8 -0.0019711180 +142.9 -0.0890677798 +143.0 -0.1755044340 +143.1 -0.2609904158 +143.2 -0.3452393321 +143.3 -0.4279700888 +143.4 -0.5089078968 +143.5 -0.5877852523 +143.6 -0.6643428880 +143.7 -0.7383306913 +143.8 -0.8095085869 +143.9 -0.8776473797 +144.0 -0.9425295547 +144.1 -1.0039500328 +144.2 -1.0617168767 +144.3 -1.1156519469 +144.4 -1.1655915049 +144.5 -1.2113867598 +144.6 -1.2529043586 +144.7 -1.2900268172 +144.8 -1.3226528902 +144.9 -1.3506978798 +145.0 -1.3740938811 +145.1 -1.3927899640 +145.2 -1.4067522907 +145.3 -1.4159641690 +145.4 -1.4204260407 +145.5 -1.4201554058 +145.6 -1.4151866825 +145.7 -1.4055710047 +145.8 -1.3913759562 +145.9 -1.3726852446 +146.0 -1.3495983151 +146.1 -1.3222299063 +146.2 -1.2907095498 +146.3 -1.2551810157 +146.4 -1.2158017062 +146.5 -1.1727419996 +146.6 -1.1261845481 +146.7 -1.0763235312 +146.8 -1.0233638680 +146.9 -0.9675203926 +147.0 -0.9090169944 +147.1 -0.8480857271 +147.2 -0.7849658910 +147.3 -0.7199030906 +147.4 -0.6531482727 +147.5 -0.5849567473 +147.6 -0.5155871969 +147.7 -0.4453006762 +147.8 -0.3743596078 +147.9 -0.3030267764 +148.0 -0.2315643264 +148.1 -0.1602327664 +148.2 -0.0892899846 +148.3 -0.0189902781 +148.4 0.0504165984 +148.5 0.1186863628 +148.6 0.1855811101 +148.7 0.2508701876 +148.8 0.3143310380 +148.9 0.3757500072 +149.0 0.4349231133 +149.1 0.4916567741 +149.2 0.5457684912 +149.3 0.5970874860 +149.4 0.6454552884 +149.5 0.6907262728 +149.6 0.7327681421 +149.7 0.7714623563 +149.8 0.8067045047 +149.9 0.8384046211 +150.0 0.8664874396 +150.1 0.8908925915 +150.2 0.9115747418 +150.3 0.9285036654 +150.4 0.9416642629 +150.5 0.9510565163 +150.6 0.9566953841 +150.7 0.9586106378 +150.8 0.9568466395 +150.9 0.9514620624 +151.0 0.9425295547 +151.1 0.9301353501 +151.2 0.9143788240 +151.3 0.8953720004 +151.4 0.8732390087 +151.5 0.8481154958 +151.6 0.8201479925 +151.7 0.7894932405 +151.8 0.7563174804 +151.9 0.7207957041 +152.0 0.6831108755 +152.1 0.6434531227 +152.2 0.6020189040 +152.3 0.5590101519 +152.4 0.5146333991 +152.5 0.4690988895 +152.6 0.4226196771 +152.7 0.3754107187 +152.8 0.3276879616 +152.9 0.2796674319 +153.0 0.2315643264 +153.1 0.1835921108 +153.2 0.1359616308 +153.3 0.0888802357 +153.4 0.0425509214 +153.5 -0.0028285050 +153.6 -0.0470662366 +153.7 -0.0899772489 +153.8 -0.1313840510 +153.9 -0.1711174029 +154.0 -0.2090169944 +154.1 -0.2449320856 +154.2 -0.2787221036 +154.3 -0.3102571954 +154.4 -0.3394187327 +154.5 -0.3660997690 +154.6 -0.3902054447 +154.7 -0.4116533410 +154.8 -0.4303737789 +154.9 -0.4463100649 +155.0 -0.4594186793 +155.1 -0.4696694093 +155.2 -0.4770454252 +155.3 -0.4815432985 +155.4 -0.4831729645 +155.5 -0.4819576268 +155.6 -0.4779336063 +155.7 -0.4711501342 +155.8 -0.4616690907 +155.9 -0.4495646899 +156.0 -0.4349231133 +156.1 -0.4178420914 +156.2 -0.3984304386 +156.3 -0.3768075395 +156.4 -0.3531027923 +156.5 -0.3274550088 +156.6 -0.3000117760 +156.7 -0.2709287797 +156.8 -0.2403690949 +156.9 -0.2085024453 +157.0 -0.1755044340 +157.1 -0.1415557503 +157.2 -0.1068413551 +157.3 -0.0715496482 +157.4 -0.0358716213 +157.5 0.0000000000 +157.6 0.0358716213 +157.7 0.0715496482 +157.8 0.1068413551 +157.9 0.1415557503 +158.0 0.1755044340 +158.1 0.2085024453 +158.2 0.2403690949 +158.3 0.2709287797 +158.4 0.3000117760 +158.5 0.3274550088 +158.6 0.3531027923 +158.7 0.3768075395 +158.8 0.3984304386 +158.9 0.4178420914 +159.0 0.4349231133 +159.1 0.4495646899 +159.2 0.4616690907 +159.3 0.4711501342 +159.4 0.4779336063 +159.5 0.4819576268 +159.6 0.4831729645 +159.7 0.4815432985 +159.8 0.4770454252 +159.9 0.4696694093 +160.0 0.4594186793 +160.1 0.4463100649 +160.2 0.4303737789 +160.3 0.4116533410 +160.4 0.3902054447 +160.5 0.3660997690 +160.6 0.3394187327 +160.7 0.3102571954 +160.8 0.2787221036 +160.9 0.2449320856 +161.0 0.2090169944 +161.1 0.1711174029 +161.2 0.1313840510 +161.3 0.0899772489 +161.4 0.0470662366 +161.5 0.0028285050 +161.6 -0.0425509214 +161.7 -0.0888802357 +161.8 -0.1359616308 +161.9 -0.1835921108 +162.0 -0.2315643264 +162.1 -0.2796674319 +162.2 -0.3276879616 +162.3 -0.3754107187 +162.4 -0.4226196771 +162.5 -0.4690988895 +162.6 -0.5146333991 +162.7 -0.5590101519 +162.8 -0.6020189040 +162.9 -0.6434531227 +163.0 -0.6831108755 +163.1 -0.7207957041 +163.2 -0.7563174804 +163.3 -0.7894932405 +163.4 -0.8201479925 +163.5 -0.8481154958 +163.6 -0.8732390087 +163.7 -0.8953720004 +163.8 -0.9143788240 +163.9 -0.9301353501 +164.0 -0.9425295547 +164.1 -0.9514620624 +164.2 -0.9568466395 +164.3 -0.9586106378 +164.4 -0.9566953841 +164.5 -0.9510565163 +164.6 -0.9416642629 +164.7 -0.9285036654 +164.8 -0.9115747418 +164.9 -0.8908925915 +165.0 -0.8664874396 +165.1 -0.8384046211 +165.2 -0.8067045047 +165.3 -0.7714623563 +165.4 -0.7327681421 +165.5 -0.6907262728 +165.6 -0.6454552884 +165.7 -0.5970874860 +165.8 -0.5457684912 +165.9 -0.4916567741 +166.0 -0.4349231133 +166.1 -0.3757500072 +166.2 -0.3143310380 +166.3 -0.2508701876 +166.4 -0.1855811101 +166.5 -0.1186863628 +166.6 -0.0504165984 +166.7 0.0189902781 +166.8 0.0892899846 +166.9 0.1602327664 +167.0 0.2315643264 +167.1 0.3030267764 +167.2 0.3743596078 +167.3 0.4453006762 +167.4 0.5155871969 +167.5 0.5849567473 +167.6 0.6531482727 +167.7 0.7199030906 +167.8 0.7849658910 +167.9 0.8480857271 +168.0 0.9090169944 +168.1 0.9675203926 +168.2 1.0233638680 +168.3 1.0763235312 +168.4 1.1261845481 +168.5 1.1727419996 +168.6 1.2158017062 +168.7 1.2551810157 +168.8 1.2907095498 +168.9 1.3222299063 +169.0 1.3495983151 +169.1 1.3726852446 +169.2 1.3913759562 +169.3 1.4055710047 +169.4 1.4151866825 +169.5 1.4201554058 +169.6 1.4204260407 +169.7 1.4159641690 +169.8 1.4067522907 +169.9 1.3927899640 +170.0 1.3740938811 +170.1 1.3506978798 +170.2 1.3226528902 +170.3 1.2900268172 +170.4 1.2529043586 +170.5 1.2113867598 +170.6 1.1655915049 +170.7 1.1156519469 +170.8 1.0617168767 +170.9 1.0039500328 +171.0 0.9425295547 +171.1 0.8776473797 +171.2 0.8095085869 +171.3 0.7383306913 +171.4 0.6643428880 +171.5 0.5877852523 +171.6 0.5089078968 +171.7 0.4279700888 +171.8 0.3452393321 +171.9 0.2609904158 +172.0 0.1755044340 +172.1 0.0890677798 +172.2 0.0019711180 +172.3 -0.0854916609 +172.4 -0.1730244995 +172.5 -0.2603302435 +172.6 -0.3471117170 +172.7 -0.4330728000 +172.8 -0.5179195035 +172.9 -0.6013610385 +173.0 -0.6831108755 +173.1 -0.7628877882 +173.2 -0.8404168810 +173.3 -0.9154305924 +173.4 -0.9876696746 +173.5 -1.0568841418 +173.6 -1.1228341864 +173.7 -1.1852910582 +173.8 -1.2440379036 +173.9 -1.2988705619 +174.0 -1.3495983151 +174.1 -1.3960445890 +174.2 -1.4380476024 +174.3 -1.4754609622 +174.4 -1.5081542023 +174.5 -1.5360132636 +174.6 -1.5589409143 +174.7 -1.5768571078 +174.8 -1.5896992777 +174.9 -1.5974225684 +175.0 -1.6000000000 +175.1 -1.5974225684 +175.2 -1.5896992777 +175.3 -1.5768571078 +175.4 -1.5589409143 +175.5 -1.5360132636 +175.6 -1.5081542023 +175.7 -1.4754609622 +175.8 -1.4380476024 +175.9 -1.3960445890 +176.0 -1.3495983151 +176.1 -1.2988705619 +176.2 -1.2440379036 +176.3 -1.1852910582 +176.4 -1.1228341864 +176.5 -1.0568841418 +176.6 -0.9876696746 +176.7 -0.9154305924 +176.8 -0.8404168810 +176.9 -0.7628877882 +177.0 -0.6831108755 +177.1 -0.6013610385 +177.2 -0.5179195035 +177.3 -0.4330728000 +177.4 -0.3471117170 +177.5 -0.2603302435 +177.6 -0.1730244995 +177.7 -0.0854916609 +177.8 0.0019711180 +177.9 0.0890677798 +178.0 0.1755044340 +178.1 0.2609904158 +178.2 0.3452393321 +178.3 0.4279700888 +178.4 0.5089078968 +178.5 0.5877852523 +178.6 0.6643428880 +178.7 0.7383306913 +178.8 0.8095085869 +178.9 0.8776473797 +179.0 0.9425295547 +179.1 1.0039500328 +179.2 1.0617168767 +179.3 1.1156519469 +179.4 1.1655915049 +179.5 1.2113867598 +179.6 1.2529043586 +179.7 1.2900268172 +179.8 1.3226528902 +179.9 1.3506978798 +180.0 1.3740938811 +180.1 1.3927899640 +180.2 1.4067522907 +180.3 1.4159641690 +180.4 1.4204260407 +180.5 1.4201554058 +180.6 1.4151866825 +180.7 1.4055710047 +180.8 1.3913759562 +180.9 1.3726852446 +181.0 1.3495983151 +181.1 1.3222299063 +181.2 1.2907095498 +181.3 1.2551810157 +181.4 1.2158017062 +181.5 1.1727419996 +181.6 1.1261845481 +181.7 1.0763235312 +181.8 1.0233638680 +181.9 0.9675203926 +182.0 0.9090169944 +182.1 0.8480857271 +182.2 0.7849658910 +182.3 0.7199030906 +182.4 0.6531482727 +182.5 0.5849567473 +182.6 0.5155871969 +182.7 0.4453006762 +182.8 0.3743596078 +182.9 0.3030267764 +183.0 0.2315643264 +183.1 0.1602327664 +183.2 0.0892899846 +183.3 0.0189902781 +183.4 -0.0504165984 +183.5 -0.1186863628 +183.6 -0.1855811101 +183.7 -0.2508701876 +183.8 -0.3143310380 +183.9 -0.3757500072 +184.0 -0.4349231133 +184.1 -0.4916567741 +184.2 -0.5457684912 +184.3 -0.5970874860 +184.4 -0.6454552884 +184.5 -0.6907262728 +184.6 -0.7327681421 +184.7 -0.7714623563 +184.8 -0.8067045047 +184.9 -0.8384046211 +185.0 -0.8664874396 +185.1 -0.8908925915 +185.2 -0.9115747418 +185.3 -0.9285036654 +185.4 -0.9416642629 +185.5 -0.9510565163 +185.6 -0.9566953841 +185.7 -0.9586106378 +185.8 -0.9568466395 +185.9 -0.9514620624 +186.0 -0.9425295547 +186.1 -0.9301353501 +186.2 -0.9143788240 +186.3 -0.8953720004 +186.4 -0.8732390087 +186.5 -0.8481154958 +186.6 -0.8201479925 +186.7 -0.7894932405 +186.8 -0.7563174804 +186.9 -0.7207957041 +187.0 -0.6831108755 +187.1 -0.6434531227 +187.2 -0.6020189040 +187.3 -0.5590101519 +187.4 -0.5146333991 +187.5 -0.4690988895 +187.6 -0.4226196771 +187.7 -0.3754107187 +187.8 -0.3276879616 +187.9 -0.2796674319 +188.0 -0.2315643264 +188.1 -0.1835921108 +188.2 -0.1359616308 +188.3 -0.0888802357 +188.4 -0.0425509214 +188.5 0.0028285050 +188.6 0.0470662366 +188.7 0.0899772489 +188.8 0.1313840510 +188.9 0.1711174029 +189.0 0.2090169944 +189.1 0.2449320856 +189.2 0.2787221036 +189.3 0.3102571954 +189.4 0.3394187327 +189.5 0.3660997690 +189.6 0.3902054447 +189.7 0.4116533410 +189.8 0.4303737789 +189.9 0.4463100649 +190.0 0.4594186793 +190.1 0.4696694093 +190.2 0.4770454252 +190.3 0.4815432985 +190.4 0.4831729645 +190.5 0.4819576268 +190.6 0.4779336063 +190.7 0.4711501342 +190.8 0.4616690907 +190.9 0.4495646899 +191.0 0.4349231133 +191.1 0.4178420914 +191.2 0.3984304386 +191.3 0.3768075395 +191.4 0.3531027923 +191.5 0.3274550088 +191.6 0.3000117760 +191.7 0.2709287797 +191.8 0.2403690949 +191.9 0.2085024453 +192.0 0.1755044340 +192.1 0.1415557503 +192.2 0.1068413551 +192.3 0.0715496482 +192.4 0.0358716213 +192.5 -0.0000000000 +192.6 -0.0358716213 +192.7 -0.0715496482 +192.8 -0.1068413551 +192.9 -0.1415557503 +193.0 -0.1755044340 +193.1 -0.2085024453 +193.2 -0.2403690949 +193.3 -0.2709287797 +193.4 -0.3000117760 +193.5 -0.3274550088 +193.6 -0.3531027923 +193.7 -0.3768075395 +193.8 -0.3984304386 +193.9 -0.4178420914 +194.0 -0.4349231133 +194.1 -0.4495646899 +194.2 -0.4616690907 +194.3 -0.4711501342 +194.4 -0.4779336063 +194.5 -0.4819576268 +194.6 -0.4831729645 +194.7 -0.4815432985 +194.8 -0.4770454252 +194.9 -0.4696694093 +195.0 -0.4594186793 +195.1 -0.4463100649 +195.2 -0.4303737789 +195.3 -0.4116533410 +195.4 -0.3902054447 +195.5 -0.3660997690 +195.6 -0.3394187327 +195.7 -0.3102571954 +195.8 -0.2787221036 +195.9 -0.2449320856 +196.0 -0.2090169944 +196.1 -0.1711174029 +196.2 -0.1313840510 +196.3 -0.0899772489 +196.4 -0.0470662366 +196.5 -0.0028285050 +196.6 0.0425509214 +196.7 0.0888802357 +196.8 0.1359616308 +196.9 0.1835921108 +197.0 0.2315643264 +197.1 0.2796674319 +197.2 0.3276879616 +197.3 0.3754107187 +197.4 0.4226196771 +197.5 0.4690988895 +197.6 0.5146333991 +197.7 0.5590101519 +197.8 0.6020189040 +197.9 0.6434531227 +198.0 0.6831108755 +198.1 0.7207957041 +198.2 0.7563174804 +198.3 0.7894932405 +198.4 0.8201479925 +198.5 0.8481154958 +198.6 0.8732390087 +198.7 0.8953720004 +198.8 0.9143788240 +198.9 0.9301353501 +199.0 0.9425295547 +199.1 0.9514620624 +199.2 0.9568466395 +199.3 0.9586106378 +199.4 0.9566953841 +199.5 0.9510565163 +199.6 0.9416642629 +199.7 0.9285036654 +199.8 0.9115747418 +199.9 0.8908925915 +200.0 0.8664874396 +200.1 0.8384046211 +200.2 0.8067045047 +200.3 0.7714623563 +200.4 0.7327681421 +200.5 0.6907262728 +200.6 0.6454552884 +200.7 0.5970874860 +200.8 0.5457684912 +200.9 0.4916567741 +201.0 0.4349231133 +201.1 0.3757500072 +201.2 0.3143310380 +201.3 0.2508701876 +201.4 0.1855811101 +201.5 0.1186863628 +201.6 0.0504165984 +201.7 -0.0189902781 +201.8 -0.0892899846 +201.9 -0.1602327664 +202.0 -0.2315643264 +202.1 -0.3030267764 +202.2 -0.3743596078 +202.3 -0.4453006762 +202.4 -0.5155871969 +202.5 -0.5849567473 +202.6 -0.6531482727 +202.7 -0.7199030906 +202.8 -0.7849658910 +202.9 -0.8480857271 +203.0 -0.9090169944 +203.1 -0.9675203926 +203.2 -1.0233638680 +203.3 -1.0763235312 +203.4 -1.1261845481 +203.5 -1.1727419996 +203.6 -1.2158017062 +203.7 -1.2551810157 +203.8 -1.2907095498 +203.9 -1.3222299063 +204.0 -1.3495983151 +204.1 -1.3726852446 +204.2 -1.3913759562 +204.3 -1.4055710047 +204.4 -1.4151866825 +204.5 -1.4201554058 +204.6 -1.4204260407 +204.7 -1.4159641690 +204.8 -1.4067522907 +204.9 -1.3927899640 +205.0 -1.3740938811 +205.1 -1.3506978798 +205.2 -1.3226528902 +205.3 -1.2900268172 +205.4 -1.2529043586 +205.5 -1.2113867598 +205.6 -1.1655915049 +205.7 -1.1156519469 +205.8 -1.0617168767 +205.9 -1.0039500328 +206.0 -0.9425295547 +206.1 -0.8776473797 +206.2 -0.8095085869 +206.3 -0.7383306913 +206.4 -0.6643428880 +206.5 -0.5877852523 +206.6 -0.5089078968 +206.7 -0.4279700888 +206.8 -0.3452393321 +206.9 -0.2609904158 +207.0 -0.1755044340 +207.1 -0.0890677798 +207.2 -0.0019711180 +207.3 0.0854916609 +207.4 0.1730244995 +207.5 0.2603302435 +207.6 0.3471117170 +207.7 0.4330728000 +207.8 0.5179195035 +207.9 0.6013610385 +208.0 0.6831108755 +208.1 0.7628877882 +208.2 0.8404168810 +208.3 0.9154305924 +208.4 0.9876696746 +208.5 1.0568841418 +208.6 1.1228341864 +208.7 1.1852910582 +208.8 1.2440379036 +208.9 1.2988705619 +209.0 1.3495983151 +209.1 1.3960445890 +209.2 1.4380476024 +209.3 1.4754609622 +209.4 1.5081542023 +209.5 1.5360132636 +209.6 1.5589409143 +209.7 1.5768571078 +209.8 1.5896992777 +209.9 1.5974225684 +210.0 1.6000000000 +210.1 1.5974225684 +210.2 1.5896992777 +210.3 1.5768571078 +210.4 1.5589409143 +210.5 1.5360132636 +210.6 1.5081542023 +210.7 1.4754609622 +210.8 1.4380476024 +210.9 1.3960445890 +211.0 1.3495983151 +211.1 1.2988705619 +211.2 1.2440379036 +211.3 1.1852910582 +211.4 1.1228341864 +211.5 1.0568841418 +211.6 0.9876696746 +211.7 0.9154305924 +211.8 0.8404168810 +211.9 0.7628877882 +212.0 0.6831108755 +212.1 0.6013610385 +212.2 0.5179195035 +212.3 0.4330728000 +212.4 0.3471117170 +212.5 0.2603302435 +212.6 0.1730244995 +212.7 0.0854916609 +212.8 -0.0019711180 +212.9 -0.0890677798 +213.0 -0.1755044340 +213.1 -0.2609904158 +213.2 -0.3452393321 +213.3 -0.4279700888 +213.4 -0.5089078968 +213.5 -0.5877852523 +213.6 -0.6643428880 +213.7 -0.7383306913 +213.8 -0.8095085869 +213.9 -0.8776473797 +214.0 -0.9425295547 +214.1 -1.0039500328 +214.2 -1.0617168767 +214.3 -1.1156519469 +214.4 -1.1655915049 +214.5 -1.2113867598 +214.6 -1.2529043586 +214.7 -1.2900268172 +214.8 -1.3226528902 +214.9 -1.3506978798 +215.0 -1.3740938811 +215.1 -1.3927899640 +215.2 -1.4067522907 +215.3 -1.4159641690 +215.4 -1.4204260407 +215.5 -1.4201554058 +215.6 -1.4151866825 +215.7 -1.4055710047 +215.8 -1.3913759562 +215.9 -1.3726852446 +216.0 -1.3495983151 +216.1 -1.3222299063 +216.2 -1.2907095498 +216.3 -1.2551810157 +216.4 -1.2158017062 +216.5 -1.1727419996 +216.6 -1.1261845481 +216.7 -1.0763235312 +216.8 -1.0233638680 +216.9 -0.9675203926 +217.0 -0.9090169944 +217.1 -0.8480857271 +217.2 -0.7849658910 +217.3 -0.7199030906 +217.4 -0.6531482727 +217.5 -0.5849567473 +217.6 -0.5155871969 +217.7 -0.4453006762 +217.8 -0.3743596078 +217.9 -0.3030267764 +218.0 -0.2315643264 +218.1 -0.1602327664 +218.2 -0.0892899846 +218.3 -0.0189902781 +218.4 0.0504165984 +218.5 0.1186863628 +218.6 0.1855811101 +218.7 0.2508701876 +218.8 0.3143310380 +218.9 0.3757500072 +219.0 0.4349231133 +219.1 0.4916567741 +219.2 0.5457684912 +219.3 0.5970874860 +219.4 0.6454552884 +219.5 0.6907262728 +219.6 0.7327681421 +219.7 0.7714623563 +219.8 0.8067045047 +219.9 0.8384046211 +220.0 0.8664874396 +220.1 0.8908925915 +220.2 0.9115747418 +220.3 0.9285036654 +220.4 0.9416642629 +220.5 0.9510565163 +220.6 0.9566953841 +220.7 0.9586106378 +220.8 0.9568466395 +220.9 0.9514620624 +221.0 0.9425295547 +221.1 0.9301353501 +221.2 0.9143788240 +221.3 0.8953720004 +221.4 0.8732390087 +221.5 0.8481154958 +221.6 0.8201479925 +221.7 0.7894932405 +221.8 0.7563174804 +221.9 0.7207957041 +222.0 0.6831108755 +222.1 0.6434531227 +222.2 0.6020189040 +222.3 0.5590101519 +222.4 0.5146333991 +222.5 0.4690988895 +222.6 0.4226196771 +222.7 0.3754107187 +222.8 0.3276879616 +222.9 0.2796674319 +223.0 0.2315643264 +223.1 0.1835921108 +223.2 0.1359616308 +223.3 0.0888802357 +223.4 0.0425509214 +223.5 -0.0028285050 +223.6 -0.0470662366 +223.7 -0.0899772489 +223.8 -0.1313840510 +223.9 -0.1711174029 +224.0 -0.2090169944 +224.1 -0.2449320856 +224.2 -0.2787221036 +224.3 -0.3102571954 +224.4 -0.3394187327 +224.5 -0.3660997690 +224.6 -0.3902054447 +224.7 -0.4116533410 +224.8 -0.4303737789 +224.9 -0.4463100649 +225.0 -0.4594186793 +225.1 -0.4696694093 +225.2 -0.4770454252 +225.3 -0.4815432985 +225.4 -0.4831729645 +225.5 -0.4819576268 +225.6 -0.4779336063 +225.7 -0.4711501342 +225.8 -0.4616690907 +225.9 -0.4495646899 +226.0 -0.4349231133 +226.1 -0.4178420914 +226.2 -0.3984304386 +226.3 -0.3768075395 +226.4 -0.3531027923 +226.5 -0.3274550088 +226.6 -0.3000117760 +226.7 -0.2709287797 +226.8 -0.2403690949 +226.9 -0.2085024453 +227.0 -0.1755044340 +227.1 -0.1415557503 +227.2 -0.1068413551 +227.3 -0.0715496482 +227.4 -0.0358716213 +227.5 -0.0000000000 +227.6 0.0358716213 +227.7 0.0715496482 +227.8 0.1068413551 +227.9 0.1415557503 +228.0 0.1755044340 +228.1 0.2085024453 +228.2 0.2403690949 +228.3 0.2709287797 +228.4 0.3000117760 +228.5 0.3274550088 +228.6 0.3531027923 +228.7 0.3768075395 +228.8 0.3984304386 +228.9 0.4178420914 +229.0 0.4349231133 +229.1 0.4495646899 +229.2 0.4616690907 +229.3 0.4711501342 +229.4 0.4779336063 +229.5 0.4819576268 +229.6 0.4831729645 +229.7 0.4815432985 +229.8 0.4770454252 +229.9 0.4696694093 +230.0 0.4594186793 +230.1 0.4463100649 +230.2 0.4303737789 +230.3 0.4116533410 +230.4 0.3902054447 +230.5 0.3660997690 +230.6 0.3394187327 +230.7 0.3102571954 +230.8 0.2787221036 +230.9 0.2449320856 +231.0 0.2090169944 +231.1 0.1711174029 +231.2 0.1313840510 +231.3 0.0899772489 +231.4 0.0470662366 +231.5 0.0028285050 +231.6 -0.0425509214 +231.7 -0.0888802357 +231.8 -0.1359616308 +231.9 -0.1835921108 +232.0 -0.2315643264 +232.1 -0.2796674319 +232.2 -0.3276879616 +232.3 -0.3754107187 +232.4 -0.4226196771 +232.5 -0.4690988895 +232.6 -0.5146333991 +232.7 -0.5590101519 +232.8 -0.6020189040 +232.9 -0.6434531227 +233.0 -0.6831108755 +233.1 -0.7207957041 +233.2 -0.7563174804 +233.3 -0.7894932405 +233.4 -0.8201479925 +233.5 -0.8481154958 +233.6 -0.8732390087 +233.7 -0.8953720004 +233.8 -0.9143788240 +233.9 -0.9301353501 +234.0 -0.9425295547 +234.1 -0.9514620624 +234.2 -0.9568466395 +234.3 -0.9586106378 +234.4 -0.9566953841 +234.5 -0.9510565163 +234.6 -0.9416642629 +234.7 -0.9285036654 +234.8 -0.9115747418 +234.9 -0.8908925915 +235.0 -0.8664874396 +235.1 -0.8384046211 +235.2 -0.8067045047 +235.3 -0.7714623563 +235.4 -0.7327681421 +235.5 -0.6907262728 +235.6 -0.6454552884 +235.7 -0.5970874860 +235.8 -0.5457684912 +235.9 -0.4916567741 +236.0 -0.4349231133 +236.1 -0.3757500072 +236.2 -0.3143310380 +236.3 -0.2508701876 +236.4 -0.1855811101 +236.5 -0.1186863628 +236.6 -0.0504165984 +236.7 0.0189902781 +236.8 0.0892899846 +236.9 0.1602327664 +237.0 0.2315643264 +237.1 0.3030267764 +237.2 0.3743596078 +237.3 0.4453006762 +237.4 0.5155871969 +237.5 0.5849567473 +237.6 0.6531482727 +237.7 0.7199030906 +237.8 0.7849658910 +237.9 0.8480857271 +238.0 0.9090169944 +238.1 0.9675203926 +238.2 1.0233638680 +238.3 1.0763235312 +238.4 1.1261845481 +238.5 1.1727419996 +238.6 1.2158017062 +238.7 1.2551810157 +238.8 1.2907095498 +238.9 1.3222299063 +239.0 1.3495983151 +239.1 1.3726852446 +239.2 1.3913759562 +239.3 1.4055710047 +239.4 1.4151866825 +239.5 1.4201554058 +239.6 1.4204260407 +239.7 1.4159641690 +239.8 1.4067522907 +239.9 1.3927899640 +240.0 1.3740938811 +240.1 1.3506978798 +240.2 1.3226528902 +240.3 1.2900268172 +240.4 1.2529043586 +240.5 1.2113867598 +240.6 1.1655915049 +240.7 1.1156519469 +240.8 1.0617168767 +240.9 1.0039500328 +241.0 0.9425295547 +241.1 0.8776473797 +241.2 0.8095085869 +241.3 0.7383306913 +241.4 0.6643428880 +241.5 0.5877852523 +241.6 0.5089078968 +241.7 0.4279700888 +241.8 0.3452393321 +241.9 0.2609904158 +242.0 0.1755044340 +242.1 0.0890677798 +242.2 0.0019711180 +242.3 -0.0854916609 +242.4 -0.1730244995 +242.5 -0.2603302435 +242.6 -0.3471117170 +242.7 -0.4330728000 +242.8 -0.5179195035 +242.9 -0.6013610385 +243.0 -0.6831108755 +243.1 -0.7628877882 +243.2 -0.8404168810 +243.3 -0.9154305924 +243.4 -0.9876696746 +243.5 -1.0568841418 +243.6 -1.1228341864 +243.7 -1.1852910582 +243.8 -1.2440379036 +243.9 -1.2988705619 +244.0 -1.3495983151 +244.1 -1.3960445890 +244.2 -1.4380476024 +244.3 -1.4754609622 +244.4 -1.5081542023 +244.5 -1.5360132636 +244.6 -1.5589409143 +244.7 -1.5768571078 +244.8 -1.5896992777 +244.9 -1.5974225684 +245.0 -1.6000000000 +245.1 -1.5974225684 +245.2 -1.5896992777 +245.3 -1.5768571078 +245.4 -1.5589409143 +245.5 -1.5360132636 +245.6 -1.5081542023 +245.7 -1.4754609622 +245.8 -1.4380476024 +245.9 -1.3960445890 +246.0 -1.3495983151 +246.1 -1.2988705619 +246.2 -1.2440379036 +246.3 -1.1852910582 +246.4 -1.1228341864 +246.5 -1.0568841418 +246.6 -0.9876696746 +246.7 -0.9154305924 +246.8 -0.8404168810 +246.9 -0.7628877882 +247.0 -0.6831108755 +247.1 -0.6013610385 +247.2 -0.5179195035 +247.3 -0.4330728000 +247.4 -0.3471117170 +247.5 -0.2603302435 +247.6 -0.1730244995 +247.7 -0.0854916609 +247.8 0.0019711180 +247.9 0.0890677798 +248.0 0.1755044340 +248.1 0.2609904158 +248.2 0.3452393321 +248.3 0.4279700888 +248.4 0.5089078968 +248.5 0.5877852523 +248.6 0.6643428880 +248.7 0.7383306913 +248.8 0.8095085869 +248.9 0.8776473797 +249.0 0.9425295547 +249.1 1.0039500328 +249.2 1.0617168767 +249.3 1.1156519469 +249.4 1.1655915049 +249.5 1.2113867598 +249.6 1.2529043586 +249.7 1.2900268172 +249.8 1.3226528902 +249.9 1.3506978798 +250.0 1.3740938811 +250.1 1.3927899640 +250.2 1.4067522907 +250.3 1.4159641690 +250.4 1.4204260407 +250.5 1.4201554058 +250.6 1.4151866825 +250.7 1.4055710047 +250.8 1.3913759562 +250.9 1.3726852446 +251.0 1.3495983151 +251.1 1.3222299063 +251.2 1.2907095498 +251.3 1.2551810157 +251.4 1.2158017062 +251.5 1.1727419996 +251.6 1.1261845481 +251.7 1.0763235312 +251.8 1.0233638680 +251.9 0.9675203926 +252.0 0.9090169944 +252.1 0.8480857271 +252.2 0.7849658910 +252.3 0.7199030906 +252.4 0.6531482727 +252.5 0.5849567473 +252.6 0.5155871969 +252.7 0.4453006762 +252.8 0.3743596078 +252.9 0.3030267764 +253.0 0.2315643264 +253.1 0.1602327664 +253.2 0.0892899846 +253.3 0.0189902781 +253.4 -0.0504165984 +253.5 -0.1186863628 +253.6 -0.1855811101 +253.7 -0.2508701876 +253.8 -0.3143310380 +253.9 -0.3757500072 +254.0 -0.4349231133 +254.1 -0.4916567741 +254.2 -0.5457684912 +254.3 -0.5970874860 +254.4 -0.6454552884 +254.5 -0.6907262728 +254.6 -0.7327681421 +254.7 -0.7714623563 +254.8 -0.8067045047 +254.9 -0.8384046211 +255.0 -0.8664874396 +255.1 -0.8908925915 +255.2 -0.9115747418 +255.3 -0.9285036654 +255.4 -0.9416642629 +255.5 -0.9510565163 +255.6 -0.9566953841 +255.7 -0.9586106378 +255.8 -0.9568466395 +255.9 -0.9514620624 +256.0 -0.9425295547 +256.1 -0.9301353501 +256.2 -0.9143788240 +256.3 -0.8953720004 +256.4 -0.8732390087 +256.5 -0.8481154958 +256.6 -0.8201479925 +256.7 -0.7894932405 +256.8 -0.7563174804 +256.9 -0.7207957041 +257.0 -0.6831108755 +257.1 -0.6434531227 +257.2 -0.6020189040 +257.3 -0.5590101519 +257.4 -0.5146333991 +257.5 -0.4690988895 +257.6 -0.4226196771 +257.7 -0.3754107187 +257.8 -0.3276879616 +257.9 -0.2796674319 +258.0 -0.2315643264 +258.1 -0.1835921108 +258.2 -0.1359616308 +258.3 -0.0888802357 +258.4 -0.0425509214 +258.5 0.0028285050 +258.6 0.0470662366 +258.7 0.0899772489 +258.8 0.1313840510 +258.9 0.1711174029 +259.0 0.2090169944 +259.1 0.2449320856 +259.2 0.2787221036 +259.3 0.3102571954 +259.4 0.3394187327 +259.5 0.3660997690 +259.6 0.3902054447 +259.7 0.4116533410 +259.8 0.4303737789 +259.9 0.4463100649 +260.0 0.4594186793 +260.1 0.4696694093 +260.2 0.4770454252 +260.3 0.4815432985 +260.4 0.4831729645 +260.5 0.4819576268 +260.6 0.4779336063 +260.7 0.4711501342 +260.8 0.4616690907 +260.9 0.4495646899 +261.0 0.4349231133 +261.1 0.4178420914 +261.2 0.3984304386 +261.3 0.3768075395 +261.4 0.3531027923 +261.5 0.3274550088 +261.6 0.3000117760 +261.7 0.2709287797 +261.8 0.2403690949 +261.9 0.2085024453 +262.0 0.1755044340 +262.1 0.1415557503 +262.2 0.1068413551 +262.3 0.0715496482 +262.4 0.0358716213 +262.5 -0.0000000000 +262.6 -0.0358716213 +262.7 -0.0715496482 +262.8 -0.1068413551 +262.9 -0.1415557503 +263.0 -0.1755044340 +263.1 -0.2085024453 +263.2 -0.2403690949 +263.3 -0.2709287797 +263.4 -0.3000117760 +263.5 -0.3274550088 +263.6 -0.3531027923 +263.7 -0.3768075395 +263.8 -0.3984304386 +263.9 -0.4178420914 +264.0 -0.4349231133 +264.1 -0.4495646899 +264.2 -0.4616690907 +264.3 -0.4711501342 +264.4 -0.4779336063 +264.5 -0.4819576268 +264.6 -0.4831729645 +264.7 -0.4815432985 +264.8 -0.4770454252 +264.9 -0.4696694093 +265.0 -0.4594186793 +265.1 -0.4463100649 +265.2 -0.4303737789 +265.3 -0.4116533410 +265.4 -0.3902054447 +265.5 -0.3660997690 +265.6 -0.3394187327 +265.7 -0.3102571954 +265.8 -0.2787221036 +265.9 -0.2449320856 +266.0 -0.2090169944 +266.1 -0.1711174029 +266.2 -0.1313840510 +266.3 -0.0899772489 +266.4 -0.0470662366 +266.5 -0.0028285050 +266.6 0.0425509214 +266.7 0.0888802357 +266.8 0.1359616308 +266.9 0.1835921108 +267.0 0.2315643264 +267.1 0.2796674319 +267.2 0.3276879616 +267.3 0.3754107187 +267.4 0.4226196771 +267.5 0.4690988895 +267.6 0.5146333991 +267.7 0.5590101519 +267.8 0.6020189040 +267.9 0.6434531227 +268.0 0.6831108755 +268.1 0.7207957041 +268.2 0.7563174804 +268.3 0.7894932405 +268.4 0.8201479925 +268.5 0.8481154958 +268.6 0.8732390087 +268.7 0.8953720004 +268.8 0.9143788240 +268.9 0.9301353501 +269.0 0.9425295547 +269.1 0.9514620624 +269.2 0.9568466395 +269.3 0.9586106378 +269.4 0.9566953841 +269.5 0.9510565163 +269.6 0.9416642629 +269.7 0.9285036654 +269.8 0.9115747418 +269.9 0.8908925915 +270.0 0.8664874396 +270.1 0.8384046211 +270.2 0.8067045047 +270.3 0.7714623563 +270.4 0.7327681421 +270.5 0.6907262728 +270.6 0.6454552884 +270.7 0.5970874860 +270.8 0.5457684912 +270.9 0.4916567741 +271.0 0.4349231133 +271.1 0.3757500072 +271.2 0.3143310380 +271.3 0.2508701876 +271.4 0.1855811101 +271.5 0.1186863628 +271.6 0.0504165984 +271.7 -0.0189902781 +271.8 -0.0892899846 +271.9 -0.1602327664 +272.0 -0.2315643264 +272.1 -0.3030267764 +272.2 -0.3743596078 +272.3 -0.4453006762 +272.4 -0.5155871969 +272.5 -0.5849567473 +272.6 -0.6531482727 +272.7 -0.7199030906 +272.8 -0.7849658910 +272.9 -0.8480857271 +273.0 -0.9090169944 +273.1 -0.9675203926 +273.2 -1.0233638680 +273.3 -1.0763235312 +273.4 -1.1261845481 +273.5 -1.1727419996 +273.6 -1.2158017062 +273.7 -1.2551810157 +273.8 -1.2907095498 +273.9 -1.3222299063 +274.0 -1.3495983151 +274.1 -1.3726852446 +274.2 -1.3913759562 +274.3 -1.4055710047 +274.4 -1.4151866825 +274.5 -1.4201554058 +274.6 -1.4204260407 +274.7 -1.4159641690 +274.8 -1.4067522907 +274.9 -1.3927899640 +275.0 -1.3740938811 +275.1 -1.3506978798 +275.2 -1.3226528902 +275.3 -1.2900268172 +275.4 -1.2529043586 +275.5 -1.2113867598 +275.6 -1.1655915049 +275.7 -1.1156519469 +275.8 -1.0617168767 +275.9 -1.0039500328 +276.0 -0.9425295547 +276.1 -0.8776473797 +276.2 -0.8095085869 +276.3 -0.7383306913 +276.4 -0.6643428880 +276.5 -0.5877852523 +276.6 -0.5089078968 +276.7 -0.4279700888 +276.8 -0.3452393321 +276.9 -0.2609904158 +277.0 -0.1755044340 +277.1 -0.0890677798 +277.2 -0.0019711180 +277.3 0.0854916609 +277.4 0.1730244995 +277.5 0.2603302435 +277.6 0.3471117170 +277.7 0.4330728000 +277.8 0.5179195035 +277.9 0.6013610385 +278.0 0.6831108755 +278.1 0.7628877882 +278.2 0.8404168810 +278.3 0.9154305924 +278.4 0.9876696746 +278.5 1.0568841418 +278.6 1.1228341864 +278.7 1.1852910582 +278.8 1.2440379036 +278.9 1.2988705619 +279.0 1.3495983151 +279.1 1.3960445890 +279.2 1.4380476024 +279.3 1.4754609622 +279.4 1.5081542023 +279.5 1.5360132636 +279.6 1.5589409143 +279.7 1.5768571078 +279.8 1.5896992777 +279.9 1.5974225684 +280.0 1.6000000000 diff --git a/examples/openfast/README.md b/examples/openfast/README.md index 7aeb4033..7ed66bfb 100644 --- a/examples/openfast/README.md +++ b/examples/openfast/README.md @@ -70,7 +70,7 @@ Grid sizing is described in the manual's OpenFAST page (SeaState grid). .\openfast.exe IEA-15-UMaine_CompMooring3_MoorDyn.fst # MoorDyn ``` -The CableDyn run log identifies the module with `Running CableDyn (v0.4.1, 2026-11-08)` and +The CableDyn run log identifies the module with `Running CableDyn (v0.4.2, 2026-11-09)` and prints the converged fairlead state of each line, as the standalone driver does: ```text diff --git a/examples/shared_cable_two_floaters.dat b/examples/shared_cable_two_floaters.dat new file mode 100644 index 00000000..cdba2c13 --- /dev/null +++ b/examples/shared_cable_two_floaters.dat @@ -0,0 +1,62 @@ +--------------------- CableDyn Input File ------------------------------------ +CableDyn driver deck -- dynamic power cable shared by two floaters, both hang-offs moving, 36 s +-- A 360 m finite-EI array cable (the bare cable of the Lozon lazy-wave decks: D 0.16 m, +-- 36.7 kg/m, EI 1.99e4 N m^2) hangs in a free catenary between the hang-offs of two floaters +-- 300 m apart, 14 m below the surface, in 200 m of water: its lowest point is about 100 m deep, +-- clear of the seabed. Both ends are Coupled points, so End B moves as End A does: the motionFile +-- (data/shared/floaters_surge_heave_12s_dt0025.txt, written by generate_floater_motion.py) gives +-- each floater a 2 m surge and a 1.5 m heave at 12 s, floater 2 surging in antiphase so that +-- the span opens and closes by 4 m. Both hang-offs are clamped (Rigid) along their static +-- tangents; BendMom1N1 and BendMom1N73 are the hang-off moments, FairTen1 and AnchTen1 the two +-- hang-off tensions (End A and End B), L1N37pz the depth of the mid-span node. +--------------------- LINE TYPES --------------------------------------------- +TypeName Diam MassDenInAir EA BA EI Cd_n Cd_t Ca_n Ca_t +(-) (m) (kg/m) (N) (-) (N-m2) (-) (-) (-) (-) +bare 0.160 36.70 4.69e8 0.0 1.99e4 1.2 0.1 1.0 0.0 +--------------------- POINTS ------------------------------------------------ +ID Type X Y Z +(-) (-) (m) (m) (m) +1 Coupled 0.0 0.0 -14.0 +2 Coupled 300.0 0.0 -14.0 +--------------------- LINES ------------------------------------------------- +ID NodeA NodeB Outputs +(-) (-) (-) (-) +1 1 2 - +--------------------- SECTIONS ---------------------------------------------- +LineID LineType Length NumSegs +(-) (-) (m) (-) +1 bare 360.0 72 +--------------------- END CONNECTIONS --------------------------------------- +-- Both hang-offs are clamped along the static tangents, 51.9 deg below horizontal at End A and +-- 51.9 deg above it, toward End B, at End B (the A-to-B direction at either end). +LineID End Stiffness EzX EzY EzZ +(-) (-) (N-m/rad) (-) (-) (-) +1 A Rigid 0.61757 0.0 -0.78651 +1 B Rigid 0.61757 0.0 0.78651 +--------------------- OPTIONS ----------------------------------------------- +9.80665 g - Gravitational acceleration (m/s^2) [default: 9.80665] +1025.0 rhoW - Water density (kg/m^3) [default: 1025] +200.0 WtrDpth - Water depth for the flat seabed (m) [default: absent standalone; host-owned OpenFAST] +1.0e5 kBot - Seabed penalty stiffness base (Pa/m) [default: 1.0e5] +1.0e4 cBot - Seabed normal damping base (Pa-s/m) [default: 1.0e4] +0.025 dtM - CableDyn internal time step (s) [default: omitted standalone; the glue DT in OpenFAST] +36.0 TMax - Standalone simulation duration (s) [default: omitted standalone; host-owned OpenFAST] +data/shared/floaters_surge_heave_12s_dt0025.txt motionFile - Prescribed motion of both Coupled hang-offs +0.4 rhoInf - Generalised-alpha spectral radius {0<=rhoInf<=1} [default: 0.4] +False modified_newton - Tangent-reuse mode {False=full Newton; True=guarded reuse} [default: False] +False adaptive_mesh - Automatic finite-EI refinement {False; True} [default: False] +dynamic_solver 1.0e-8 1.0e-14 30 12 - Relative tolerance, absolute tolerance, max iterations, backtracks [defaults shown] +none frictionMu - Seabed friction coefficient {none; value>=0} [default: none] +none current - Current model and velocity (m/s) {none; uniform; profile} [default: none] +none waves - Wave model, height, period, and direction (m, s, deg) {none; airy; jonswap} [default: none] +0 WaterKin - Water-kinematics source {0/none; file; SEASTATE coupled only} [default: no policy] +-- Complete option/default reference: cabledyn_options_reference.dat and doc/options.rst. +--------------------- OUTPUTS ----------------------------------------------- +"FairTen1" +"AnchTen1" +"FairIncl1" +"AnchIncl1" +"BendMom1N1" +"BendMom1N73" +"L1N37pz" +--------------------- need this line ---------------------------------------- diff --git a/examples/torsion_free_end_armoured_cable.dat b/examples/torsion_free_end_armoured_cable.dat new file mode 100644 index 00000000..db8a0f00 --- /dev/null +++ b/examples/torsion_free_end_armoured_cable.dat @@ -0,0 +1,67 @@ +--------------------- CableDyn Input File ------------------------------------ +Lazy-wave armoured power cable restrained in torsion at the hang-off and free to twist at the anchor, heaving 36 s +-- The 80 m Gulf of Mexico cable of lozon_gomex80_power_cable_motion.dat (64 elements, the 3 m, +-- 12 s hang-off heave of data/lozon/gomex80_heave_3m_12s_dt005.txt), with ILLUSTRATIVE torsion +-- properties of a single-armoured cable: GJ = 50 kN.m^2, a torque-tension coupling K = 3.0 MN.m +-- (T = EA eps + K tau, M = GJ tau + K eps, K^2 < EA GJ) and a torsional damping of 5 % of each +-- element's critical value (the GJ column GJ|K|Bt, Bt = -0.05). The hang-off is clamped (Rigid) +-- and restrained in torsion (TorsStiffness Rigid); the anchor end has no END CONNECTIONS row, so +-- it is pinned and free to twist, as on a swivel. The free end carries no torque: in statics the +-- line has none, and the stretch alone twists it, Twist1 = -sum (K/GJ)(l - L) over the elements: +-- -5.6 deg here, the stretch being that of the reduced axial stiffness EA - K^2/GJ of a line free +-- to twist. Under the heave the tension, and with it the stretch, oscillates (Twist1 between +-- -7.6 and -3.7 deg): the twist follows through torsional waves carried by the polar inertia +-- Irn (m r^2/2 of each section) that reflect at the free end, and the restrained hang-off takes +-- their torque, Torq1N1. Twist1 is the turn of the free anchor end against the hang-off frame +-- carried along the line. +--------------------- LINE TYPES --------------------------------------------- +TypeName Diam MassDenInAir EA BA EI GAs GJ|K|Bt Irt Irn Cd_n Cd_t Ca_n Ca_t +(-) (m) (kg/m) (N) (-) (N-m2) (N) (N-m2|N-m|N-m2-s) (kg-m) (kg-m) (-) (-) (-) (-) +bare 0.160 36.70 4.69e8 0.0 1.99e4 9.02e7 5.0e4|3.0e6|-0.05 0.0587 0.1174 1.2 0.1 1.0 0.0 +buoy 0.290 59.53 4.69e8 0.0 1.99e4 9.02e7 5.0e4|3.0e6|-0.05 0.3129 0.6258 1.2 0.1 1.0 0.0 +--------------------- POINTS ------------------------------------------------ +ID Type X Y Z +(-) (-) (m) (m) (m) +1 Coupled 5.0 0.0 -14.0 +2 Fixed 125.0 0.0 -80.0 +--------------------- LINES ------------------------------------------------- +ID NodeA NodeB Outputs +(-) (-) (-) (-) +1 1 2 - +--------------------- SECTIONS ---------------------------------------------- +LineID LineType Length NumSegs +(-) (-) (m) (-) +1 bare 68.114 28 +1 buoy 50.000 20 +1 bare 52.101 16 +--------------------- END CONNECTIONS --------------------------------------- +-- End A only: clamped along the static hang-off tangent and restrained in torsion, Nx the +-- zero-twist reference normal. End B, with no row, is pinned and free in torsion. +LineID End Stiffness EzX EzY EzZ TorsStiffness NxX NxY NxZ Pretwist +(-) (-) (N-m/rad) (-) (-) (-) (N-m/rad) (-) (-) (-) (deg) +1 A Rigid 0.14641 0.0 -0.98922 Rigid 0.0 1.0 0.0 0.0 +--------------------- OPTIONS ----------------------------------------------- +9.80665 g - Gravitational acceleration (m/s^2) [default: 9.80665] +1025.0 rhoW - Water density (kg/m^3) [default: 1025] +80.0 WtrDpth - Water depth for the flat seabed (m) [default: absent standalone; host-owned OpenFAST] +1.0e5 kBot - Seabed penalty stiffness base (Pa/m) [default: 1.0e5] +1.0e4 cBot - Seabed normal damping base (Pa-s/m) [default: 1.0e4] +0.4 rhoInf - Generalised-alpha spectral radius {0<=rhoInf<=1} [default: 0.4] +False modified_newton - Tangent-reuse mode {False=full Newton; True=guarded reuse} [default: False] +0.05 dtM - CableDyn internal time step (s) [default: omitted standalone; the glue DT in OpenFAST] +36.0 TMax - Standalone simulation duration (s), including the 12 s smooth start +data/lozon/gomex80_heave_3m_12s_dt005.txt motionFile - Prescribed hang-off heave +False adaptive_mesh - Automatic finite-EI refinement {False; True} [default: False] +dynamic_solver 1.0e-8 1.0e-14 30 12 - Relative tolerance, absolute tolerance, max iterations, backtracks [defaults shown] +none frictionMu - Seabed friction coefficient {none; value>=0} [default: none] +none current - Current model and velocity (m/s) {none; uniform; profile} [default: none] +none waves - Wave model, height, period, and direction (m, s, deg) {none; airy; jonswap} [default: none] +0 WaterKin - Water-kinematics source {0/none; file; SEASTATE coupled only} [default: no policy] +-- Complete option/default reference: cabledyn_options_reference.dat and doc/options.rst. +--------------------- OUTPUTS ----------------------------------------------- +"FairTen1" +"AnchTen1" +"Torq1N1" +"Twist1" +"BendMom1N1" +--------------------- need this line ---------------------------------------- diff --git a/examples/viv_taut_line_crossflow.dat b/examples/viv_taut_line_crossflow.dat new file mode 100644 index 00000000..4ace1ee5 --- /dev/null +++ b/examples/viv_taut_line_crossflow.dat @@ -0,0 +1,56 @@ +--------------------- CableDyn Input File ------------------------------------ +CableDyn driver deck -- cross-flow VIV lock-in of a taut line in a uniform cross current, 90 s +-- A 100 m line (D 0.1 m, 10 kg/m, EA 5e7 N, about 50 kN) held at both ends 50 m below the +-- surface in a 0.15 m/s current along +Y, across the line. The LINE TYPES columns Cl dF cF give +-- the lift coefficient 0.8 and MoorDyn's synchronisation band (dF 0.08 around cF 0.18): the +-- shedding frequency cF U/D = 0.27 Hz sits on the first vertical mode (0.27 Hz with the added +-- mass), so the line locks in and vibrates in Z, across the flow: over 60-90 s the mid-span +-- amplitude A/D is 0.66, MoorDyn-F's on this line (tests/test_viv_lockin.py). L1N26pz is the +-- mid-span node, L1N13pz the quarter span; the Outputs flag V writes the lift at every node to +-- .Line1.V.out. +-- VIVphaseSeed spread starts node i at the phase 2 pi i/N (MoorDyn-C); VIVrmsWindow sets the +-- averaging time of the running RMS motion of the synchronisation model. The static start +-- carries the current drag but no lift; the lift builds up from the seeded phases. +--------------------- LINE TYPES --------------------------------------- +TypeName Diam MassDenInAir EA BA/-zeta EI Cd_n Cd_t Ca_n Ca_t Cl dF cF +(-) (m) (kg/m) (N) (N-s/-) (N-m^2) (-) (-) (-) (-) (-) (-) (-) +riser 0.10 10.0 5.0e7 -0.8 0.0 1.2 0.0 1.0 0.0 0.8 0.08 0.18 +--------------------- POINTS ------------------------------------------- +ID Type X Y Z Mass Vol CdA Ca +(-) (-) (m) (m) (m) (kg) (m^3) (m^2) (-) +1 Coupled 0.0 0.0 -50.0 0 0 0 0 +2 Fixed 100.0 0.0 -50.0 0 0 0 0 +--------------------- LINES -------------------------------------------- +ID NodeA NodeB Outputs +(-) (-) (-) (-) +1 1 2 V +--------------------- SECTIONS ----------------------------------------- +-- 99.9 m unstretched: 50 kN stretches it to the 100 m span (EA 5e7 N, strain 0.1 %). +LineID LineType Length NumSegs +(-) (-) (m) (-) +1 riser 99.9001 50 +--------------------- OPTIONS ------------------------------------------ +9.80665 g - Gravitational acceleration (m/s^2) [default: 9.80665] +1025.0 rhoW - Water density (kg/m^3) [default: 1025] +100.0 WtrDpth - Water depth (m) [default: absent standalone; host-owned OpenFAST] +1.0e5 kBot - Seabed penalty stiffness base (Pa/m) [default: 1.0e5] +1.0e4 cBot - Seabed normal damping base (Pa-s/m) [default: 1.0e4] +0.02 dtM - CableDyn internal time step (s) [default: omitted standalone; the glue DT in OpenFAST] +90.0 TMax - Standalone simulation duration (s) [default: omitted standalone; host-owned OpenFAST] +0.25 VIVrmsWindow - Averaging time of the VIV running RMS motion (s) {0=500 steps of dtM} [default: 0] +spread VIVphaseSeed - Initial VIV phases {spread=2 pi i/N, MoorDyn-C; zero=MoorDyn-F} [default: spread] +uniform 0.0 0.15 0.0 current - Current model and X/Y/Z velocity (m/s) {none; uniform; profile} [default: none] +none waves - Wave model, height, period, and direction (m, s, deg) {none; airy; jonswap} [default: none] +0 WaterKin - Water-kinematics source {0/none; 3; 7; file; SEASTATE coupled only} [default: no policy] +0.4 rhoInf - Generalised-alpha spectral radius {0<=rhoInf<=1} [default: 0.4] +False modified_newton - Tangent-reuse mode {False=full Newton; True=guarded reuse} [default: False] +False adaptive_mesh - Automatic finite-EI refinement {False; True} [default: False] +dynamic_solver 1.0e-8 1.0e-14 30 12 - Relative tolerance, absolute tolerance, max iterations, backtracks [defaults shown] +none frictionMu - Seabed friction coefficient {none; value>=0} [default: none] +-- Complete option/default reference: cabledyn_options_reference.dat and doc/options.rst. +--------------------- OUTPUTS ------------------------------------------ +"FairTen1" +"AnchTen1" +"L1N26pz" +"L1N13pz" +--------------------- need this line ----------------------------------- diff --git a/integration/openfast/README.md b/integration/openfast/README.md index 26523f91..3761dbea 100644 --- a/integration/openfast/README.md +++ b/integration/openfast/README.md @@ -9,7 +9,7 @@ who only run coupled cases should use the released `openfast.exe` and the The patches in [`patches/`](patches/) apply to the public OpenFAST upstream commit `2895884d2be01862173c88d70f86b358d2f1a50a` (the OpenFAST v5.0.0 release, used by -CableDyn v0.4.1). They add only the OpenFAST host integration; the CableDyn sources come from +CableDyn v0.4.2). They add only the OpenFAST host integration; the CableDyn sources come from this repository. | File | Purpose | @@ -67,7 +67,7 @@ ifx default, `/fp:fast`, may reassociate sums and flush subnormals to zero. OpenFAST names its version with `git describe --dirty`, which would read `v5.0.0-dirty` on the patched tree. A CableDyn-enabled executable names itself `OpenFAST--CableDyn-` instead, here -`OpenFAST-v5.0.0-CableDyn-0.4.1` (printed by `openfast.exe -v` and at the start of every run). +`OpenFAST-v5.0.0-CableDyn-0.4.2` (printed by `openfast.exe -v` and at the start of every run). The OpenFAST part is `git describe --tags --abbrev=8` of the checked-out commit, the unpatched base; the CableDyn part is the project version in the CableDyn `CMakeLists.txt`. Patch `0021` sets it in the CMake build, and `integrate_openfast_vs_solution.ps1` in the diff --git a/pyproject.toml b/pyproject.toml index 264f7e6b..b89abb2a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -12,7 +12,7 @@ build-backend = "scikit_build_core.build" [project] name = "cabledyn" -version = "0.4.1" +version = "0.4.2" description = "Python tools for CableDyn, a geometrically exact finite-element solver for mooring lines and dynamic power cables" readme = "python/README.md" requires-python = ">=3.10" diff --git a/python/README.md b/python/README.md index e1fe8757..23652cae 100644 --- a/python/README.md +++ b/python/README.md @@ -25,7 +25,7 @@ Fortran compiler and LAPACK. The pure Python wheel attached to each [GitHub release](https://github.com/SMI-Lab-Inha/CableDyn/releases/latest) -(`cabledyn-0.4.1-py3-none-any.whl`) carries no solver. `CableDynDriver` finds the +(`cabledyn-0.4.2-py3-none-any.whl`) carries no solver. `CableDynDriver` finds the driver from an explicit path, then the `CABLEDYN_DRIVER` environment variable, then the driver inside the package, then `PATH`; the in-process `CableDyn` class uses the library inside the package, or one named by `CABLEDYN_LIBRARY` or found in diff --git a/python/cabledyn/__init__.py b/python/cabledyn/__init__.py index 032a6c06..90ecc52b 100644 --- a/python/cabledyn/__init__.py +++ b/python/cabledyn/__init__.py @@ -286,7 +286,7 @@ "upcrossing_maxima", ] -__version__ = "0.4.1" +__version__ = "0.4.2" def __getattr__(name: str) -> Any: diff --git a/python/cabledyn/deck_file.py b/python/cabledyn/deck_file.py index 5ba451b2..a6ad7d83 100644 --- a/python/cabledyn/deck_file.py +++ b/python/cabledyn/deck_file.py @@ -231,6 +231,8 @@ "max_strain": "max_strain", "vivrmswindow": "viv_rms_window", "viv_rms_window": "viv_rms_window", + "vivphaseseed": "viv_phase_seed", + "viv_phase_seed": "viv_phase_seed", "rangestart": "range_start", "range_start": "range_start", "waveseed": "wave_seed", @@ -266,6 +268,8 @@ "as_laid_tension": "as_laid_tension", "outputrecovery": "output_recovery", "output_recovery": "output_recovery", + "axialdampingratio": "axial_damping_ratio", + "axial_damping_ratio": "axial_damping_ratio", } # Per-line static friction rows (native apply_option): ``layAzimuth`` and ``asLaidTension`` # with the LINE id appended; the id is a plain decimal suffix, and leading zeros name the same line. @@ -323,6 +327,8 @@ _NATIVE_MAX_GRAVITY = 1.0e3 _NATIVE_MAX_WATER_DENSITY = 1.0e5 _NATIVE_MAX_FLUID_SPEED = 1.0e3 +# native CD_MIN_TIME_STEP: the smallest dtM (the time integration divides by dtM^2) +_NATIVE_MIN_TIME_STEP = 1.0e-100 _NATIVE_MAX_WAVE_HEIGHT = 1.0e3 _NATIVE_WAVE_PERIOD_RANGE = (0.1, 1.0e5) _DISABLED_MOTION_FILE_VALUES = frozenset({"0", "none"}) @@ -1016,8 +1022,15 @@ def _positional_numbers_are_finite(tokens: list[str]) -> bool: return False -def _positional_range_error(tokens: list[str]) -> str | None: - """Return a native-finalizer range error for a parsed positional option.""" +def _positional_range_error(tokens: list[str], *, effective: bool = True) -> str | None: + """Return a native range error for a parsed positional option. + + The native reader checks some rules on every row as it reads it (positive wave + height and period, distinct profile depths, every spectral and wavetrain row) and + the magnitude bounds of a regular or JONSWAP ``waves`` row and of a ``current`` row + only on the row in effect once OPTIONS is read: the last one. ``effective=False`` + returns the per-row rules alone, for a row a later row may override. + """ mode = tokens[0].lower() if mode == "profile": # The native two-point parser accepts either input direction and @@ -1026,7 +1039,7 @@ def _positional_range_error(tokens: list[str]) -> str | None: if abs(_native_float(tokens[5]) - _native_float(tokens[1])) <= 100.0 * math.ulp(1.0): return "current profile depths must be strictly increasing" values = [_native_float(token) for token in tokens[1:9]] - if ( + if effective and ( abs(values[0]) > _NATIVE_MAX_COORDINATE or abs(values[4]) > _NATIVE_MAX_COORDINATE or any(abs(value) > _NATIVE_MAX_FLUID_SPEED for value in values[1:4] + values[5:8]) @@ -1036,7 +1049,9 @@ def _positional_range_error(tokens: list[str]) -> str | None: "in magnitude" ) elif mode == "uniform": - if any(abs(_native_float(token)) > _NATIVE_MAX_FLUID_SPEED for token in tokens[1:4]): + if effective and any( + abs(_native_float(token)) > _NATIVE_MAX_FLUID_SPEED for token in tokens[1:4] + ): return "OPTION current velocity components must be at most 1e3 m/s" elif ( mode in {"airy", "jonswap", "stream", "dean"} @@ -1047,6 +1062,8 @@ def _positional_range_error(tokens: list[str]) -> str | None: gamma = _native_float(tokens[3]) if mode == "jonswap" else 1.0 if height <= 0.0 or period <= 0.0 or gamma < 1.0: return "waves require positive height/period and JONSWAP gamma >= 1" + if not effective: + return None low, high = _NATIVE_WAVE_PERIOD_RANGE if height > _NATIVE_MAX_WAVE_HEIGHT or not low <= period <= high: return "waves need height <= 1e3 m and period in [0.1, 1e5] s" @@ -1246,6 +1263,9 @@ def _scalar_option_value_error(keyword: str, value: str) -> str | None: return "must be finite" if positive and numeric <= 0.0: return "must be positive" + # native check_option_row_value rule 'time step' + if key == "dtm" and numeric < _NATIVE_MIN_TIME_STEP: + return "must be at least 1e-100 s: the time integration divides by its square" if lower is not None and numeric < lower: return f"must be >= {lower:g}" if upper is not None and numeric > upper: @@ -1332,12 +1352,21 @@ def _scalar_option_value_error(keyword: str, value: str) -> str | None: if _strip_quotes(value).lower() in _STATICS_FRICTION_POLICIES else "must be asLaid or none" ) + if key == "viv_phase_seed": + return None if value.lower() in {"spread", "zero"} else "must be spread or zero" if key == "cable_statics": return ( None if value.lower() in {"continuation", "sequenced"} else "must be continuation or sequenced" ) + if key == "axial_damping_ratio": + # native: the value is dequoted and compared case-insensitively + return ( + None + if _strip_quotes(value).lower() in {"segment", "mode1"} + else "must be segment or mode1" + ) if key == "output_recovery": return ( None @@ -3122,6 +3151,12 @@ def _check_stiffeners( raise DeckFormatError( f"{where}: STIFFENERS InnerD must be smaller than RootOD and TipOD" ) + # as wide as the widest line type at most (native, LINE TYPES Diam <= 1e3 m) + if max(root_od, tip_od) > _NATIVE_MAX_DIAMETER: + raise DeckFormatError( + f"{where}: STIFFENERS RootOD and TipOD must be at most 1e3 m, as a line " + "type's Diam" + ) extent[(line_id, end)] = extent.get((line_id, end), 0.0) + length for line_id in sorted({key[0] for key in extent}, key=int): if not any( @@ -3251,7 +3286,8 @@ def _option_row(self, index: int) -> OptionRecord | None: raise DeckFormatError( f"{where}: positional option values must be finite plain numbers" ) - if error := _positional_range_error(tokens): + # the magnitude bounds apply to the row in effect only (``_validate``) + if error := _positional_range_error(tokens, effective=False): raise DeckFormatError(f"{where}: {error}") _raise_option_defect(where, tokens) return OptionRecord(index, tokens[-1], tuple(tokens[:-1]), description) @@ -3376,6 +3412,15 @@ def _validate(self) -> None: options = self.options channels = self.outputs option_by_key = {_option_key(option.keyword): option for option in options} + # native finalize_checks: the magnitude bounds of the waves and current rows in + # effect (the last of each); a row a later row overrides takes its row rules only + for overridden_kind in ("waves", "current"): + record = option_by_key.get(overridden_kind) + if record is None or record.keyword_first: + continue + tokens = [*record.values, record.keyword] + if _is_positional_option(tokens) and (error := _positional_range_error(tokens)): + raise DeckFormatError(f"{self._label}:{record.index + 1}: {error}") has_depth = "water_depth" in option_by_key has_bathymetry = "bathymetry" in option_by_key if has_depth and has_bathymetry: @@ -4924,6 +4969,13 @@ def is_body_kind(kind: str, pinned: bool) -> bool: raise DeckFormatError( f"{self._label}: used LINE TYPE {line_type!r} requires Diam > 0" ) + # native finalize_checks: a finite-EI line carries its mass in the bending dynamics + # and its weight in the statics + if ei > 0.0 and mass <= 0.0: + raise DeckFormatError( + f"{self._label}: used LINE TYPE {line_type!r}: MassDenInAir must be > 0 on a " + "finite-EI line" + ) damping, coefficient = line_type_scales[line_type] if ( 0.0 < ea_static < _NATIVE_MIN_EA @@ -5096,6 +5148,27 @@ def is_body_kind(kind: str, pinned: bool) -> bool: # Native check_channel: ids are digit strings compared by value, so leading zeros # are accepted (FairTen01 is FairTen1). stiffened_lines = {str(_native_int(row.tokens[0])) for row in self._rows("STIFFENERS")} + # Point

p channels are read from the EI=0 system's point store. The aggregate + # (a host route, or the standalone mixed deck) has no live entry for a Coupled/Vessel + # point that only finite-EI lines reach (native validate_aggregate_point_channels); + # the standalone multibody march has no system without an EI=0 line. + finite_line_set = set(finite_line_ids) + cable_points = { + end + for line_id, ends in normalized_line_endpoints.items() + if line_id in finite_line_set + for end in ends + } + chain_points = { + end + for line_id, ends in normalized_line_endpoints.items() + if line_id not in finite_line_set + for end in ends + } + aggregate_points = self.caller_driven or mixed_route + multibody_without_system = ( + deck_driver_route and needs_multibody and line_ids and all(finite_lines) + ) for channel in channels: lowered = channel.lower() endpoint_channel = re.fullmatch( @@ -5104,9 +5177,9 @@ def is_body_kind(kind: str, pinned: bool) -> bool: lowered, ) # Con

p{x,y,z} is the native alias of Point

p{x,y,z} (MoorDyn v1 spelling). - point_channel = re.fullmatch(r"(?:point|con)([0-9]+)p([xyz])", lowered) + position_channel = re.fullmatch(r"(?:point|con)([0-9]+)p([xyz])", lowered) # Point

F{x,y,z,H}: resultant of the line-end forces on the point. - point_channel = point_channel or re.fullmatch(r"point([0-9]+)f([xyzh])", lowered) + point_channel = position_channel or re.fullmatch(r"point([0-9]+)f([xyzh])", lowered) # MoorDyn-F body/rod channels (native parse_object_channel, OBJ_QTY) body_channel = re.fullmatch(r"body([0-9]+)(?:p|r|v|rv|a|ra|f|m)[xyz]", lowered) rod_channel = re.fullmatch( @@ -5175,6 +5248,23 @@ def is_body_kind(kind: str, pinned: bool) -> bool: raise DeckFormatError( f"{self._label}: OUTPUT {channel!r} references an unknown point" ) + position = position_channel is not None + if ( + position + and aggregate_points + and point_id in cable_points + and point_id not in chain_points + and point_types.get(point_id) in {"coupled", "vessel"} + ): + raise DeckFormatError( + f"{self._label}: aggregate OUTPUT {channel!r} targets a cable-only point; " + "use the finite-EI cable line-node position channel instead" + ) + if position and multibody_without_system: + raise DeckFormatError( + f"{self._label}: OUTPUT {channel!r}: Point channels need an EI=0 mooring " + "system (a cable-endpoint Point channel is not supported)" + ) continue # TDP{s,x,y,z,Lay,Exc,Grd}: the touchdown point of line L (native # CD_Parse_TDP_Channel) @@ -5184,6 +5274,14 @@ def is_body_kind(kind: str, pinned: bool) -> bool: raise DeckFormatError( f"{self._label}: OUTPUT {channel!r} references an unknown line" ) + # native CD_Range_Setup: the touchdown point lies on a seabed, which a standalone + # deck states itself (a host gives its own water depth) + if not self.caller_driven and not (has_depth or has_bathymetry): + raise DeckFormatError( + f"{self._label}: TDP channels of line " + f"{_channel_id(touchdown_channel.group(1))} need a seabed (WtrDpth or a " + "bathymetry file)" + ) continue if lowered.startswith(("torq", "twist")): # native: TorqN, TwistN and Twist on a torsional line diff --git a/python/cabledyn/model.py b/python/cabledyn/model.py index ac0b6a49..138019cd 100644 --- a/python/cabledyn/model.py +++ b/python/cabledyn/model.py @@ -810,7 +810,8 @@ def step(self, dt: float, q: ArrayInput, v: ArrayInput, a: ArrayInput) -> int: without meeting the Newton tolerance raises :class:`ConvergenceError`; the model has then already advanced to ``t + dt`` with its best iterate. ``dt`` must be a finite positive real number (a string, complex, or - boolean value raises :class:`TypeError`). + boolean value raises :class:`TypeError`); the library refuses one below + ``1e-100`` s, as the time integration divides by ``dt**2``. """ step_dt = _as_real_scalar(dt, "dt", positive=True) with self._lock: diff --git a/python/cabledyn/objects.py b/python/cabledyn/objects.py index 12a8c0b3..083e25b3 100644 --- a/python/cabledyn/objects.py +++ b/python/cabledyn/objects.py @@ -494,6 +494,9 @@ def eval_channel(model: CableDyn, token: str) -> float: """Evaluate one OUTPUTS token (the caller holds the model lock).""" if not isinstance(token, str): raise TypeError(f"channel token must be a string; got {type(token).__name__}") + if "\0" in token: + # the library ends a token at its first NUL, so "FairTen1\0x" would read as FairTen1 + raise ValueError(f"channel token must not contain a NUL character; got {token!r}") try: raw = token.strip().encode("ascii") except UnicodeEncodeError: diff --git a/python/pyproject.toml b/python/pyproject.toml index 88a70094..6a99fb89 100644 --- a/python/pyproject.toml +++ b/python/pyproject.toml @@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta" [project] name = "cabledyn" -version = "0.4.1" +version = "0.4.2" description = "Python tools for CableDyn, a geometrically exact finite-element solver for mooring lines and dynamic power cables" readme = "README.md" requires-python = ">=3.10" diff --git a/python/tests/test_cabledyn.py b/python/tests/test_cabledyn.py index d0f079da..08990829 100644 --- a/python/tests/test_cabledyn.py +++ b/python/tests/test_cabledyn.py @@ -220,3 +220,34 @@ def test_error_types_import_without_loading_the_library(): assert issubclass(ConvergenceError, CableDynError) error = ConvergenceError("CableDyn_Step", "tolerance not met", n_iter=40, stalled=True) assert error.status == 4 and error.n_iter == 40 and error.stalled + + +@pytest.mark.parametrize("dt", [1e-101, 1e-160, 1e-300, 5e-324]) +def test_a_step_below_the_smallest_time_step_is_named(dt): + # the implicit march divides by dt^2: below 1e-100 s the step is refused by name, not left + # to overflow inside the line solve + with cabledyn.CableDyn(VOLTURNUS_DECK) as m: + q, v, a = m.get_coupled_motion() + before = m.calc_output() + with pytest.raises( + cabledyn.CableDynError, match=r"below the smallest time step, 1e-100 s" + ) as err: + m.step(dt, q, v, a) + assert "BAD_INPUT" in str(err.value) + assert np.array_equal(m.calc_output(), before) + m.step(1e-100, q, v, a) # the bound itself steps + assert np.all(np.isfinite(m.calc_output())) + with cabledyn.CableDyn() as m: + m.init_line( + [0, 0, 0, 1, 0, 0, 2, 0, 0], + np.zeros(9), + [1, 2, 2, 3], + [1.0, 1.0], + [1e6, 1e6], + [1.0, 1.0], + [1, 2, 3, 7, 8, 9], + False, + 0.5, + ) + with pytest.raises(cabledyn.CableDynError, match=r"below the smallest time step, 1e-100 s"): + m.step(dt, [0, 0, 0, 2, 0, 0], np.zeros(6), np.zeros(6)) diff --git a/python/tests/test_deck_file.py b/python/tests/test_deck_file.py index 25fea080..09682893 100644 --- a/python/tests/test_deck_file.py +++ b/python/tests/test_deck_file.py @@ -672,7 +672,11 @@ def test_unknown_scalar_option_keyword_fails_closed(tmp_path): ("1.5", "wave_seed", "must be an integer"), ("maybe", "alpha_force_blend", "native boolean"), ("relaxed", "cable_statics", "continuation or sequenced"), + ("random", "VIVphaseSeed", "spread or zero"), + ("0", "viv_phase_seed", "spread or zero"), ("nodal", "OutputRecovery", "equilibrium or element"), + ("mode2", "axialDampingRatio", "segment or mode1"), + ("element", "axial_damping_ratio", "segment or mode1"), ("on", "ei0_substeps", "auto or off"), ("0", "ei0_substep_angle", r"\(0, 90\] deg"), ("91", "ei0SubstepAngle", r"\(0, 90\] deg"), @@ -756,8 +760,13 @@ def test_zero_e_exponent_waterkin_mode_is_accepted(tmp_path): "True alphaForceBlend", "continuation cable_statics", "sequenced cableStatics", + "spread VIVphaseSeed", + "ZERO viv_phase_seed", "equilibrium OutputRecovery", "element output_recovery", + "segment axialDampingRatio", + "mode1 axial_damping_ratio", + "MODE1 AXIALDAMPINGRATIO", "auto ei0_substeps", "off ei0Substeps", "0.5 ei0_substep_angle", @@ -4099,7 +4108,8 @@ def test_subnormal_dtm_is_rejected_before_the_step_count(): DeckFile.from_text(text) -@pytest.mark.parametrize("dtm", ["1e-300", "1e-12"]) +# (a dtM below 1e-100 s is refused before the step count: test_deck_native_parity) +@pytest.mark.parametrize("dtm", ["1e-90", "1e-12"]) def test_step_count_beyond_the_native_counter_is_a_format_error(dtm): text = _minimal_chain_source().replace( "100.0 WtrDpth", f"100.0 WtrDpth\n{dtm} dtM\n30.0 TMax", 1 diff --git a/python/tests/test_deck_native_parity.py b/python/tests/test_deck_native_parity.py index f968114a..29f8c802 100644 --- a/python/tests/test_deck_native_parity.py +++ b/python/tests/test_deck_native_parity.py @@ -567,7 +567,9 @@ def _syrope(settings=_SETTINGS, owc=_OWC) -> dict[str, str]: def _shipped_decks() -> list[str]: decks = [path.name for path in sorted(EXAMPLES.glob("*.dat"))] decks.remove("cabledyn_options_reference.dat") - return [*decks, "moordynC_wavekin/chain_wavekin7_currents1.dat"] + # the decks of the MoorDyn-C kinematics folders, which read fixed-name files beside them + folders = sorted(EXAMPLES.glob("moordynC_*/*.dat")) + return [*decks, *(path.relative_to(EXAMPLES).as_posix() for path in folders)] def _carries_waves(name: str) -> bool: @@ -584,12 +586,41 @@ def _carries_waves(name: str) -> bool: if _carries_waves(name) for variant in ("spelled", "upper") ] +_PROFILE_ROW = "profile -30 0.2 0 0 0 0.5 0 0 current" +# (rows, message): the last waves or current row is the one in effect; the native reader +# checks the magnitude bounds on that row alone and the row rules on every row +_OVERRIDDEN_ROW_CASES = [ + (("airy 2000 8 0 waves", "none waves"), None), + (("airy 2 0.01 0 waves", "airy 2 8 0 waves"), None), + (("stream 2 2e5 0 waves", "pm 3 10 0 waves"), None), + (("jonswap 3 10 40 0 waves", "airy 2 8 0 waves"), None), + (("jonswap 3 10 2000 0 waves", "airy 2 8 0 waves"), None), + (("jonswap 3 10 2000 0 waves", "stream 2 8 0 waves"), None), + (("jonswap 3000 10 3.3 0 waves", "none waves"), None), + (("uniform 2000 0 0 current", "none current"), None), + (("uniform 2000 0 0 current", _PROFILE_ROW), None), + (("profile -2e6 0.2 0 0 0 0.5 0 0 current", "uniform 0.1 0 0 current"), None), + (("profile -30 2000 0 0 0 0.5 0 0 current", _PROFILE_ROW), None), + (("airy 2 8 0 waves", "airy 2000 8 0 waves"), r"waves need height <= 1e3 m"), + (("none waves", "jonswap 3 10 40 0 waves"), r"JONSWAP gamma must be in \[1, 32\.6\)"), + (("airy 2 8 0 waves", "jonswap 3 10 2000 0 waves"), r"JONSWAP gamma must be in \[1, 32\.6\)"), + ((_PROFILE_ROW, "uniform 2000 0 0 current"), r"at most 1e3 m/s"), + (("uniform 0.1 0 0 current", "profile -2e6 0.2 0 0 0 0.5 0 0 current"), r"at most 1e6 m"), + # the row rules hold on an overridden row too + (("airy 0 8 0 waves", "none waves"), r"positive height/period"), + (("jonswap 3 10 0.5 0 waves", "airy 2 8 0 waves"), r"JONSWAP gamma >= 1"), + (("profile -30 0.2 0 0 -30 0.5 0 0 current", "none current"), r"strictly increasing"), + (("pm 3000 10 0 waves", "none waves"), r"a wave train needs height <= 1e3 m"), +] + + _ALL_FILE_CASES = [ *[("held", rows, files) for rows, files in _WAVE_RECORD_CASES], *_ANCILLARY_CASES, *_SPELLED_CASES, *_STATIC_CASES, *_SHIPPED_CASES, + *[("held", rows, {}) for rows, _ in _OVERRIDDEN_ROW_CASES], ] @@ -827,6 +858,21 @@ def test_jonswap_gamma_limit_applies_on_every_path(rows): _rejects(_options(_HELD, *rows), r"JONSWAP gamma must be in \[1, 32\.6\)") +@pytest.mark.parametrize(("rows", "message"), _OVERRIDDEN_ROW_CASES) +def test_magnitude_bounds_apply_to_the_waves_and_current_rows_in_effect(rows, message): + text = _options(_HELD, *rows) + if message is None: + DeckFile.from_text(text) + else: + _rejects(text, message) + + +def test_an_edited_waves_row_takes_the_magnitude_bounds(): + deck = DeckFile.from_text(_options(_HELD, "airy 2000 8 0 waves", "airy 2 8 0 waves")) + with pytest.raises(ValueError, match="waves need height <= 1e3 m"): + deck.set_option("waves", ("airy", 2000.0, 8.0, 0.0)) + + def test_spread_jonswap_row_is_validated_as_a_wave_train(): DeckFile.from_text(_options(_HELD, "jonswap 2 8 3.3 2e6 waves")) _rejects( @@ -898,6 +944,8 @@ def test_attachment_arc_length_lies_on_the_line(arc, accepted): ("1 A 0.0 0.45 0.45 0.17 5.0e7 1150", "Length, RootOD, TipOD and E must be > 0"), ("1 A 0.4 0.45 0.45 -0.1 5.0e7 1150", "InnerD and Density must be >= 0"), ("1 A 0.4 0.45 0.15 0.17 5.0e7 1150", "InnerD must be smaller than RootOD and TipOD"), + ("1 A 0.4 1.0e6 0.45 0.17 5.0e7 1150", "RootOD and TipOD must be at most 1e3 m"), + ("1 A 0.4 0.45 1001.0 0.17 5.0e7 1150", "RootOD and TipOD must be at most 1e3 m"), ("1 B 167.0 0.45 0.45 0.17 5.0e7 1150", "are longer than the line"), ], ) @@ -2573,3 +2621,261 @@ def test_static_check_clock_gets_the_native_verdict(text, accepted, tmp_path): ) assert python_accepts == accepted assert (completed.returncode == 0) == accepted, completed.stdout + completed.stderr + + +# --------------------------------------------------------------- deck rules of the native routes + +_STIFF = "stiff 0.252 390.0 1.674e9 -1.0 1.0e4 1.37 0.64 1.0 0.0\n" +_CHAIN_TYPE = "chain 0.252 390.0 1.674e9 -1.0 0.0 1.37 0.64 1.0 0.0\n" +# _HELD with a second (finite-EI) line type and its line 1 split between both types +_SPLIT_LINE = _edit( + _HELD, + (_CHAIN_TYPE, _CHAIN_TYPE + _STIFF), + ("1 chain 410.0 41\n", "1 chain 200.0 20\n1 stiff 210.0 21\n"), +) +# ... and a second, EI=0 line beside it (the standalone mixed route) +_SPLIT_LINE_AND_CHAIN = _edit( + _SPLIT_LINE, + ( + "2 Coupled 0.0 0.0 0.0 0 0 0 0\n", + "2 Coupled 0.0 0.0 0.0 0 0 0 0\n3 Fixed -400.0 0.0 -50.0 0 0 0 0\n", + ), + ("1 2 1 -\n", "1 2 1 -\n2 2 3 -\n"), + ("1 stiff 210.0 21\n", "1 stiff 210.0 21\n2 chain 410.0 41\n"), +) +# a finite-EI line on its own +_FINITE = _edit(_HELD, (_CHAIN_TYPE, _CHAIN_TYPE.replace(" 0.0 1.37", " 1.0e4 1.37"))) +# a finite-EI line from Coupled point 2 beside an EI=0 line from Coupled point 4 (the mixed route) +_FINITE_AND_CHAIN = _edit( + _HELD, + (_CHAIN_TYPE, _CHAIN_TYPE + _STIFF), + ( + "2 Coupled 0.0 0.0 0.0 0 0 0 0\n", + "2 Coupled 0.0 0.0 0.0 0 0 0 0\n" + "3 Fixed -400.0 0.0 -50.0 0 0 0 0\n4 Coupled -10.0 0.0 0.0 0 0 0 0\n", + ), + ("1 2 1 -\n", "1 2 1 -\n2 4 3 -\n"), + ("1 chain 410.0 41\n", "1 stiff 410.0 41\n2 chain 410.0 41\n"), +) +# the submerged Rigid6 buoy of the examples with finite-EI legs (the standalone multibody march) +_BUOY_FINITE_LEGS = _example( + "rigid6_buoy.dat", + ("5.0e7 -1.0 0.0 ", "5.0e7 -1.0 1.0e3 "), + ("60.0 TMax", "0.04 TMax"), +) +_BUOY_FORCES = _edit( + _BUOY_FINITE_LEGS, + ('"Point1px"\n"Point1pz"\n"Point2pz"\n"Point3pz"\n', '"Point1Fx"\n"Point2Fz"\n'), +) + + +_NO_SEABED_TDP = _edit(_STATIC, ("50.0 WtrDpth\n", ""), ("FairTen1\n", "FairTen1\nTDP1s\n")) +_FINITE_POINT_POSITIONS = _edit(_FINITE, ("FairTen1\n", "FairTen1\nPoint2px\nPoint1pz\nPoint2Fz\n")) +_MIXED_CABLE_POINT = _edit(_FINITE_AND_CHAIN, ("FairTen1\n", "FairTen1\nPoint2px\n")) +_MIXED_CHAIN_POINT = _edit(_FINITE_AND_CHAIN, ("FairTen1\n", "FairTen1\nPoint4px\nPoint2Fz\n")) +# (name, deck, caller_driven, message): None accepts +_ROUTE_RULE_CASES = [ + # TDP channels need a seabed on the standalone routes (a host gives the depth) + ("tdp-no-seabed", _NO_SEABED_TDP, False, r"TDP channels of line 1 need a seabed"), + ("tdp-no-seabed-host", _NO_SEABED_TDP, True, None), + ("tdp-seabed", _edit(_STATIC, ("FairTen1\n", "FairTen1\nTDP1s\n")), False, None), + # a finite-EI line needs mass, on every route + ("finite-mass-0", _edit(_FINITE, (" 390.0 ", " 0 ")), False, r"MassDenInAir must be > 0"), + ("finite-mass-neg", _edit(_FINITE, (" 390.0 ", " -1 ")), False, r"MassDenInAir must be > 0"), + ( + "finite-mass-neg-host", + _edit(_FINITE, (" 390.0 ", " -1 ")), + True, + r"MassDenInAir must be > 0", + ), + ("finite-mass-small", _edit(_FINITE, (" 390.0 ", " 1e-3 ")), False, None), + # a line with EI = 0 and finite-EI sections is one finite-EI cable on every route + ("split-line", _SPLIT_LINE, False, None), + ("split-line-static", _static_check(_SPLIT_LINE, keep_dtm=True), False, None), + ("split-line-host", _SPLIT_LINE, True, None), + ("split-line-mixed-route", _SPLIT_LINE_AND_CHAIN, False, None), + # Point

p channels are read from the EI=0 system: on the aggregate a Coupled point of + # finite-EI lines alone has no live entry there, and a multibody march with no EI=0 line + # has no system at all + ("finite-point-channels", _FINITE_POINT_POSITIONS, False, None), + ( + "finite-cable-point-host", + _edit(_FINITE, ("FairTen1\n", "FairTen1\nPoint2px\n")), + True, + r"targets a cable-only point", + ), + ( + "finite-fixed-point-host", + _edit(_FINITE, ("FairTen1\n", "FairTen1\nPoint1pz\nPoint2Fz\n")), + True, + None, + ), + ("mixed-cable-point", _MIXED_CABLE_POINT, False, r"targets a cable-only point"), + ("mixed-chain-point", _MIXED_CHAIN_POINT, False, None), + ("buoy-finite-legs-forces", _BUOY_FORCES, False, None), + ( + "buoy-finite-legs-positions", + _BUOY_FINITE_LEGS, + False, + r"Point channels need an EI=0 mooring system", + ), +] + + +@pytest.mark.parametrize( + ("text", "caller_driven", "message"), + [pytest.param(*case[1:], id=case[0]) for case in _ROUTE_RULE_CASES], +) +def test_route_rules_of_the_native_reader(text, caller_driven, message): + if message is None: + DeckFile.from_text(text, caller_driven=caller_driven) + else: + _rejects(text, message, caller_driven=caller_driven) + + +@pytest.mark.skipif( + not _PARITY_DRIVER or not Path(_PARITY_DRIVER).is_file(), + reason="set CABLEDYN_TEST_DRIVER to a built native driver to run the route-rule parity", +) +@pytest.mark.parametrize( + "text", + [pytest.param(case[1], id=case[0]) for case in _ROUTE_RULE_CASES if not case[2]], +) +def test_route_rules_match_the_driver(text, tmp_path): + deck = tmp_path / "rules.dat" + deck.write_text(text, encoding="utf-8") + completed = subprocess.run( + [_PARITY_DRIVER, str(deck), str(tmp_path / "rules")], + 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, + ) + assert completed.returncode in (0, 1), completed.stderr[-600:] + assert _accepted(deck) == (completed.returncode == 0), completed.stderr[-600:] + + +@pytest.mark.skipif( + not _PARITY_DRIVER or not Path(_PARITY_DRIVER).is_file(), + reason="set CABLEDYN_TEST_DRIVER to a built native driver to run the refinement-stop check", +) +def test_a_compression_refinement_leaves_where_it_was_stops_the_refinement(tmp_path): + # the power cable with its sections given twice: too long to hang clear of the seabed, it is + # held in axial compression by its bending stiffness, a compression of the equilibrium that + # no mesh removes; the axial refinement stops once two passes leave it where it was instead + # of splitting elements to the element budget (6 passes, 32768 elements) + tail = "1 bare 52.101 256\n" + text = _example( + "lozon_gomex80_power_cable.dat", + (tail, tail + "1 bare 68.114 448\n1 buoy 50.000 320\n" + tail), + ) + deck = tmp_path / "long.dat" + deck.write_text(text, encoding="utf-8") + completed = subprocess.run( + [_PARITY_DRIVER, str(deck), str(tmp_path / "long")], + capture_output=True, + text=True, + errors="replace", + cwd=tmp_path, + timeout=900, + env={**os.environ, "OMP_NUM_THREADS": "1", "OPENBLAS_NUM_THREADS": "1"}, + check=False, + ) + assert completed.returncode == 2, completed.stderr[-600:] + assert "two passes left the compression where it was" in completed.stderr, completed.stderr[ + -900: + ] + assert _accepted(deck) + + +@pytest.mark.parametrize( + ("od", "accepted"), [("1000.0", True), ("1000.001", False), ("1e6", False)] +) +def test_stiffener_diameter_bound_matches_the_driver(od, accepted, tmp_path): + # a sleeve as wide as the widest line type (Diam <= 1e3 m) at most + text = _example( + "lazy_wave_bend_stiffener.dat", + (_STIFFENER_ROOT, f"1 A 0.4 {od} 0.45 0.17 5.0e7 1150"), + ) + if accepted: + DeckFile.from_text(text) + else: + _rejects(text, "RootOD and TipOD must be at most 1e3 m") + if not _PARITY_DRIVER or not Path(_PARITY_DRIVER).is_file(): + return + deck = tmp_path / "stiffener.dat" + deck.write_text(_static_check(text), encoding="utf-8") + shutil.copytree(EXAMPLES / "data", tmp_path / "data") + completed = subprocess.run( + [_PARITY_DRIVER, str(deck), str(tmp_path / "stiffener")], + 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 accepted: + assert completed.returncode != 1 or "at most 1e3 m" not in completed.stderr + else: + assert completed.returncode == 1, completed.stderr[-600:] + assert "RootOD and TipOD must be at most 1e3 m" in completed.stderr + + +# ------------------------------------------------------------------ the smallest time step + +# the implicit marches divide by dt^2, which overflows the inertia terms near 1e-155 s +_TINY_STEPS = [ + ("1e-100", True), + ("1e-60", True), + ("1e-101", False), + ("1e-160", False), + ("1e-300", False), +] + + +@pytest.mark.parametrize(("dt", "accepted"), _TINY_STEPS) +def test_dtm_has_a_smallest_value(dt, accepted): + text = _edit(_HELD, ("0.1 dtM\n10.0 TMax\n", f"{dt} dtM\n{2 * float(dt)!r} TMax\n")) + if accepted: + DeckFile.from_text(text) + else: + _rejects(text, r"dtM must be at least 1e-100 s") + # every row is checked, also one a later row overrides + _rejects( + _edit(_HELD, ("0.1 dtM\n", f"{dt} dtM\n0.1 dtM\n")), r"dtM must be at least 1e-100 s" + ) + + +@pytest.mark.skipif( + not _PARITY_DRIVER or not Path(_PARITY_DRIVER).is_file(), + reason="set CABLEDYN_TEST_DRIVER to a built native driver to run the time-step parity", +) +@pytest.mark.parametrize(("dt", "accepted"), _TINY_STEPS) +@pytest.mark.parametrize("ei", ["0.0", "1.0e4"], ids=["ei0", "finite-ei"]) +def test_dtm_bound_matches_the_driver(dt, accepted, ei, tmp_path): + text = _edit( + _HELD, + ("0.1 dtM\n10.0 TMax\n", f"{dt} dtM\n{2 * float(dt)!r} TMax\n"), + (" -1.0 0.0 1.37", f" -1.0 {ei} 1.37"), + ) + deck = tmp_path / "step.dat" + deck.write_text(text, encoding="utf-8") + completed = subprocess.run( + [_PARITY_DRIVER, str(deck), str(tmp_path / "step")], + 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, + ) + assert completed.returncode == (0 if accepted else 1), completed.stderr[-600:] + assert _accepted(deck) == accepted + if not accepted: + assert "dtM must be at least 1e-100 s" in completed.stderr diff --git a/python/tests/test_end_tangent.py b/python/tests/test_end_tangent.py new file mode 100644 index 00000000..54dd89d7 --- /dev/null +++ b/python/tests/test_end_tangent.py @@ -0,0 +1,69 @@ +# SPDX-License-Identifier: Apache-2.0 +"""The tangent of a finite-EI line in process: at an end clamped by END CONNECTIONS Rigid the +declination and azimuth the C API returns are the clamp's, and the line values match the +channels (aggregate route).""" + +from __future__ import annotations + +import math +from pathlib import Path + +import pytest + +try: + import cabledyn._lib # noqa: F401 (loads the shared library) +except (ImportError, OSError) as exc: # a missing library raises OSError + pytest.skip(f"CableDyn shared library not available: {exc}", allow_module_level=True) + +from cabledyn.model import CableDyn + +_BAR = "-" * 21 + + +def _deck(path: Path, declination: float, azimuth: float) -> Path: + d, a = math.radians(declination), math.radians(azimuth) + ez = (math.sin(d) * math.cos(a), math.sin(d) * math.sin(a), math.cos(d)) + path.write_text( + f"""{_BAR} CableDyn Input File {_BAR} +a cable clamped at End A +{_BAR} LINE TYPES {_BAR} +Name Diam Mass EA BA EI Cdn Cdt Can Cat +cable 0.2 60.0 1.0e8 -1.0 1.0e4 1.2 0.008 1.0 0.0 +{_BAR} POINTS {_BAR} +ID Type X Y Z Mass Vol CdA Ca +1 Coupled 0.0 0.0 -10.0 0 0 0 0 +2 Fixed 80.0 0.0 -80.0 0 0 0 0 +{_BAR} LINES {_BAR} +ID NodeA NodeB Outputs +1 1 2 - +{_BAR} SECTIONS {_BAR} +LineID LineType Length NumSegs +1 cable 125.0 100 +{_BAR} END CONNECTIONS {_BAR} +LineID End Stiffness EzX EzY EzZ +1 A Rigid {ez[0]:.17g} {ez[1]:.17g} {ez[2]:.17g} +{_BAR} OPTIONS {_BAR} +9.80665 g +1025.0 rhoW +0.05 dtM +1.0 TMax +{_BAR} OUTPUTS {_BAR} +FairDecl1 +{_BAR} need this line {_BAR} +""", + encoding="utf-8", + ) + return path + + +@pytest.mark.parametrize(("declination", "azimuth"), [(165.0, 0.0), (135.0, 20.0)]) +def test_the_clamped_end_reads_the_clamp(tmp_path, declination, azimuth): + with CableDyn(_deck(tmp_path / "clamp.dat", declination, azimuth)) as model: + line = model.line(1) + dec, azi = line.declination(), line.azimuth() + assert dec[0] == pytest.approx(declination, abs=1.0e-9) + assert azi[0] == pytest.approx(azimuth, abs=1.0e-9) + assert model.channel("FairDecl1") == pytest.approx(declination, abs=1.0e-9) + # the ends of the line's mesh (refined at the clamp) are its deck end nodes + assert dec[0] == model.channel("L1N1Dec") and azi[0] == model.channel("L1N1Azi") + assert dec[-1] == model.channel("AnchDecl1") diff --git a/python/tests/test_init_notes.py b/python/tests/test_init_notes.py index 645e347a..426e630c 100644 --- a/python/tests/test_init_notes.py +++ b/python/tests/test_init_notes.py @@ -4,6 +4,7 @@ from __future__ import annotations +import math import os import re import subprocess @@ -119,6 +120,21 @@ def test_the_notes_of_a_deck_on_both_routes(tmp_path): assert "LINE 1: dtM = 0.1000 s resolves its axial period" in notes +@pytest.mark.parametrize("ei", [0.0, 1.0e6], ids=["point", "aggregate"]) +def test_the_axial_damping_note_reaches_an_in_process_host(tmp_path, ei): + # BA = -1 is a damping ratio per segment: the note gives the first-mode ratio of the mesh + with CableDyn(_deck(tmp_path, ei=ei)) as model: + notes = [note for note in model.init_notes if "damping ratio per segment" in note] + assert len(notes) == 1 + match = re.search(r"at ([0-9.]+) % of critical on its ([0-9]+) elements", notes[0]) + assert match is not None, notes[0] + # zeta pi/(2N) on the uniform chain, N its final mesh + expected = 100.0 * math.pi / (2 * int(match.group(2))) + assert float(match.group(1)) == pytest.approx(expected, rel=1e-3) + with CableDyn(_deck(tmp_path, "mode1 axialDampingRatio", ei=ei, name="mode1.dat")) as model: + assert not [note for note in model.init_notes if "damping ratio per segment" in note] + + def test_a_note_of_the_parse_is_kept_once(tmp_path): # the deck is read twice, to find its route and to build it (tmp_path / "current_profile_dynamic.txt").write_text(CONSTANT_GRID, encoding="utf-8") diff --git a/python/tests/test_objects.py b/python/tests/test_objects.py index 6486fc45..ec3a27d6 100644 --- a/python/tests/test_objects.py +++ b/python/tests/test_objects.py @@ -562,6 +562,16 @@ def test_channel_tokens_must_be_ascii(tmp_path): model.channel("FairTen\u00b91") +@pytest.mark.parametrize("token", ["FairTen1\x00", "FairTen1\x00x", "\x00FairTen1"]) +def test_channel_tokens_must_not_hold_a_nul(tmp_path, token): + # the library reads a token up to its first NUL: "FairTen1\0x" would read as FairTen1 + with CableDyn(_held_chain(tmp_path)) as model: + with pytest.raises(ValueError, match="NUL"): + model.channel(token) + with pytest.raises(ValueError, match="NUL"): + model.channels(["FairTen1", token]) + + def test_zero_length_rod_axis_is_a_value_error(tmp_path, monkeypatch): deck = _write(tmp_path, "rod.dat", _ROD_DECK) with CableDyn(deck) as model: @@ -598,3 +608,88 @@ def test_c_api_takes_bodies_or_rods_not_both(tmp_path): still.write_text(base, encoding="utf-8") with CableDyn() as model: model.init_deck(still) + + +_SPLIT_LINE_DECK = """Split line: an EI = 0 chain section and a finite-EI section of one line +--- LINE TYPES --- +Name Diam Mass EA BA EI Cdn Cdt Can Cat +chain 0.252 390.0 1.674e9 -1.0 0.0 1.37 0.64 1.0 0.0 +stiff 0.252 390.0 1.674e9 -1.0 1.0e4 1.37 0.64 1.0 0.0 +--- POINTS --- +ID Type X Y Z Mass Vol CdA Ca +1 Fixed 400.0 0.0 -50.0 0 0 0 0 +2 Coupled 0.0 0.0 0.0 0 0 0 0 +--- LINES --- +ID NodeA NodeB Outputs +1 2 1 - +--- SECTIONS --- +LineID LineType Length NumSegs +{sections}--- OPTIONS --- +9.80665 g +1025.0 rhoW +50.0 WtrDpth +0.1 dtM +1.0 TMax +{motion}--- OUTPUTS --- +FairTen1 +AnchTen1 +L1N10px +L1N10pz +Ten1N30 +L1N35pz +Curv1N35 +--- need this line --- +""" + + +def _surge(t: float) -> tuple[float, float, float]: + """A smooth 0.5 m surge of the fairlead from rest over the first second.""" + s = min(max(t, 0.0), 1.0) + return ( + 0.5 * (10 * s**3 - 15 * s**4 + 6 * s**5), + 0.5 * (30 * s**2 - 60 * s**3 + 30 * s**4), + 0.5 * (60 * s - 180 * s**2 + 120 * s**3), + ) + + +@needs_driver +@pytest.mark.parametrize( + "sections", + ["1 chain 200.0 20\n1 stiff 210.0 21\n", "1 stiff 210.0 21\n1 chain 200.0 20\n"], + ids=["chain-at-fairlead", "chain-at-anchor"], +) +def test_split_line_runs_standalone_as_on_the_c_api(tmp_path, sections): + # a line of EI = 0 and finite-EI sections is one finite-EI cable on every route + times = [round(0.1 * k, 10) for k in range(11)] + (tmp_path / "m.txt").write_text( + "".join( + f"{t:.10g} 2 {_surge(t)[0]!r} 0 0 {_surge(t)[1]!r} 0 0 {_surge(t)[2]!r} 0 0\n" + for t in times + ), + encoding="utf-8", + ) + deck = _write( + tmp_path, + "split.dat", + _SPLIT_LINE_DECK.format(sections=sections, motion="m.txt motionFile\n"), + ) + result = _driver_run(deck, tmp_path) + main = result.read_main() + channels = list(main.channels[1:]) + host = _write(tmp_path, "split_host.dat", _SPLIT_LINE_DECK.format(sections=sections, motion="")) + with CableDyn(host) as model: + (line,) = model.lines + assert line.finite_ei + q0, _, _ = model.get_coupled_motion() + for k, t in enumerate(times): + if k: + x, v, a = _surge(t) + model.step( + 0.1, + q0 + np.array([x, 0.0, 0.0]), + np.array([v, 0.0, 0.0]), + np.array([a, 0.0, 0.0]), + ) + row = int(np.argmin(np.abs(main.values[:, 0] - t))) + assert abs(main.values[row, 0] - t) < 1.0e-9 + _assert_close(model.channels(channels), main.values[row, 1:], f"channels at t={t}") diff --git a/python/tests/test_point_current_profile.py b/python/tests/test_point_current_profile.py new file mode 100644 index 00000000..a0ab636d --- /dev/null +++ b/python/tests/test_point_current_profile.py @@ -0,0 +1,142 @@ +# SPDX-License-Identifier: Apache-2.0 +# Copyright (c) 2026 Jae Hoon Seo, SMI Lab, Inha University +"""A deck of ``EI = 0`` lines in a depth-profile current, stepped in-process. + +The current falls from 1.3 m/s at the surface to 0.23 m/s at the seabed. The line takes it at +its own nodes, at the static state and before every step: held at rest the model stays at +rest, and its start is the standalone driver's static state. +""" + +from __future__ import annotations + +import os +import subprocess +from ctypes import POINTER, byref, c_bool, c_double, c_int +from pathlib import Path + +import numpy as np +import pytest + +try: + from cabledyn._lib import _lib +except OSError as exc: + pytest.skip(f"CableDyn shared library not available: {exc}", allow_module_level=True) + +from cabledyn.model import CableDyn + +CHANNELS = ["FairTen1", "AnchTen1", "Point1Fx", "Point1Fy", "Point1Fz"] + +DECK = """--------------------- CableDyn Input File ------------------------------------ +A chain catenary in a depth-profile current +--------------------- LINE TYPES --------------------------------------- +TypeName Diam Mass EA BA EI Cd_n Cd_t Ca_n Ca_t +(-) (m) (kg/m) (N) (N-s) (N-m2) (-) (-) (-) (-) +chain 0.1754 189.03 8.112e8 -0.5 0.0 2.4 1.15 1.0 0.5 +--------------------- POINTS ------------------------------------------- +ID Type X Y Z +(-) (-) (m) (m) (m) +1 Coupled -2.667 6.615 -9.621 +2 Fixed -189.019 -269.414 -137.53 +--------------------- LINES -------------------------------------------- +ID NodeA NodeB Outputs +(-) (-) (-) (-) +1 1 2 - +--------------------- SECTIONS ----------------------------------------- +LineID LineType Length NumSegs +(-) (-) (m) (-) +1 chain 430.23 25 +--------------------- OPTIONS ------------------------------------------ +137.53 WtrDpth +1.0e5 kBot +profile 0.0 0.5435 1.1875 0.0 -137.53 0.0946 0.2066 0.0 current +0.02 dtM +0.0 TMax +--------------------- OUTPUTS ------------------------------------------ +FairTen1 +AnchTen1 +Point1Fx +Point1Fy +Point1Fz +--------------------- need this line ----------------------------------- +""" + + +@pytest.fixture +def deck(tmp_path: Path) -> Path: + path = tmp_path / "profile_chain.dat" + path.write_text(DECK, encoding="utf-8", newline="\n") + return path + + +def test_held_line_stays_at_rest(deck: Path) -> None: + with CableDyn(deck) as model: + start = model.channels(CHANNELS) + for _ in range(100): + model.step_held(0.02) + end = model.channels(CHANNELS) + scale = abs(start[0]) + assert np.max(np.abs(end - start)) < 1.0e-6 * scale, (start, end) + + +def test_a_refused_step_leaves_the_loads(deck: Path) -> None: + # After the fairlead has moved, the field the next step samples differs from the held one. + # A step the library refuses (dt <= 0, or a non-finite motion: both bypass the binding's own + # checks here) commits nothing, so the loads after it are those before it, bit for bit. + with CableDyn(deck) as model: + q0, _, _ = model.get_coupled_motion() + dt, n = 0.02, 20 + for k in range(1, n + 1): + s = k / n + shape = s * s * (3.0 - 2.0 * s) # smooth 2 m surge, at rest at both ends + rate = 6.0 * s * (1.0 - s) / (n * dt) + accel = 6.0 * (1.0 - 2.0 * s) / (n * dt) ** 2 + q = q0.copy() + q[0] += 2.0 * shape + v = np.zeros_like(q0) + v[0] = 2.0 * rate + a = np.zeros_like(q0) + a[0] = 2.0 * accel + model.step(dt, q, v, a) + before = model.calc_output() + channels = model.channels(CHANNELS) + nan_q = q.copy() + nan_q[0] = float("nan") + for step_dt, motion in ((-1.0, q), (dt, nan_q)): + qa = np.ascontiguousarray(motion, dtype=np.float64) + va = np.zeros_like(qa) + aa = np.zeros_like(qa) + conv, stall, nit, status = c_bool(), c_bool(), c_int(), c_int() + _lib.CableDyn_Step( + model._handle, + step_dt, + qa.ctypes.data_as(POINTER(c_double)), + va.ctypes.data_as(POINTER(c_double)), + aa.ctypes.data_as(POINTER(c_double)), + qa.size, + byref(conv), + byref(stall), + byref(nit), + byref(status), + ) + assert status.value != 0 + assert np.array_equal(model.calc_output(), before) + assert np.array_equal(model.channels(CHANNELS), channels) + + +@pytest.mark.skipif( + not os.environ.get("CABLEDYN_DRIVER", "").strip(), + reason="set CABLEDYN_DRIVER to compare with the standalone driver", +) +def test_start_is_the_driver_static_state(deck: Path, tmp_path: Path) -> None: + root = tmp_path / "profile_chain" + proc = subprocess.run( + [os.environ["CABLEDYN_DRIVER"].strip(), str(deck), str(root)], + capture_output=True, + text=True, + ) + assert proc.returncode == 0, proc.stdout + proc.stderr + rows = Path(str(root) + ".out").read_text(encoding="utf-8").splitlines() + driver = np.array([float(v) for v in rows[2].split()[1:]]) + with CableDyn(deck) as model: + start = model.channels(CHANNELS) + assert np.max(np.abs(start - driver)) < 2.0e-7 * abs(driver[0]), (start, driver) diff --git a/release/check_release_metadata.py b/release/check_release_metadata.py index d5566795..e0636349 100644 --- a/release/check_release_metadata.py +++ b/release/check_release_metadata.py @@ -26,8 +26,8 @@ def capture(relative_path: str, pattern: str, label: str) -> str: return match.group(1) -# Spellings that name a CableDyn release: "CableDyn 0.4.1", "CableDyn v0.4.1", "v0.4.1", -# "cabledyn-0.4.1-py3-none-any.whl", ".../releases/tag/v0.4.1" and "libcabledyn.so.0.4.1". +# Spellings that name a CableDyn release: "CableDyn 0.4.2", "CableDyn v0.4.2", "v0.4.2", +# "cabledyn-0.4.2-py3-none-any.whl", ".../releases/tag/v0.4.2" and "libcabledyn.so.0.4.2". VERSION_REFERENCE = re.compile( r"(?i)(?:cabledyn[ _-]+v?|cabledyn-|releases/tag/v|libcabledyn\.(?:so\.)?|(? str: r"^(CHANGELOG\.md|validation/(RELEASE|PERFORMANCE)_\d+_\d+_\d+\.md" r"|validation/PAPER_REPRODUCTION\.md|validation/README\.md" r"|validation/experiments/[^/]+/provenance\.json|validation/bodies/references/.*" + r"|validation/performance/.*" r"|tests/test_documentation\.py)$" ) diff --git a/src/CableDyn_Banner.f90 b/src/CableDyn_Banner.f90 index f57d0d66..9f466948 100644 --- a/src/CableDyn_Banner.f90 +++ b/src/CableDyn_Banner.f90 @@ -25,7 +25,7 @@ PURE FUNCTION CD_Banner_Line(i) RESULT(s) CASE (1) s = ' ===================================================================' CASE (2) - s = ' CableDyn v0.4.1' + s = ' CableDyn v0.4.2' CASE (3) s = ' Geometrically exact finite-element statics and dynamics of' CASE (4) diff --git a/src/CableDyn_CAPI.f90 b/src/CableDyn_CAPI.f90 index 61655166..1d24d503 100644 --- a/src/CableDyn_CAPI.f90 +++ b/src/CableDyn_CAPI.f90 @@ -14,6 +14,7 @@ MODULE CableDyn_CAPI USE, INTRINSIC :: ISO_FORTRAN_ENV, ONLY: INT64, COMPILER_VERSION USE, INTRINSIC :: IEEE_ARITHMETIC, ONLY: IEEE_IS_FINITE USE CableDyn_DeckDriver, ONLY: CD_Init_Deck_System, CD_DECKDRV_OK, CD_DECKDRV_BADINPUT, CD_DECKDRV_SOLVEFAIL, & + CD_DeckCurrentRuntimeType, CD_Deck_Current_Active, CD_Deck_Current_Sample_System, & CD_Deck_Query_dtM, CD_DECK_NAMELEN, CD_Eval_Aggregate_Channel, & CD_Eval_Aggregate_Segment_Tensions, CD_Eval_Aggregate_Line_Values, & CD_Rigid6_Inventory, CD_Rod_Inventory, CD_Channel_Token_Parses, CD_Cable_Deck_Node, & @@ -27,14 +28,14 @@ MODULE CableDyn_CAPI USE CableDyn_Dynamic, ONLY: GenAlphaConfig USE CableDyn_Linalg, ONLY: CD_Blas_Runtime_Check, CD_LINALG_OK USE CableDyn_Model, ONLY: CD_ModelType, CD_Init_Model, CD_End_Model, CD_MODEL_OK, CD_MODEL_BADINPUT, & - CD_MODEL_SOLVEFAIL, CD_MODEL_ALLOCFAIL + CD_MODEL_SOLVEFAIL, CD_MODEL_ALLOCFAIL, CD_Update_Model_Hydro_Fields USE CableDyn_OpenFAST, ONLY: CD_FAST_ModuleType, CD_FAST_End, CD_FAST_Init_From_Models, & CD_FAST_UpdateStates, CD_FAST_Step, CD_FAST_CalcOutput, & CD_FAST_CalcOutputDerivatives, CD_FAST_GetCoupledMotion, CD_FAST_IsInitialized, & CD_FAST_NCoupledDOF, CD_FAST_NPoints, CD_FAST_NLines, CD_FAST_OK, CD_FAST_BADINPUT, & CD_FAST_NOT_INITIALIZED, CD_FAST_ALLOCFAIL, CD_FAST_UpdatePointFluidFields USE CableDyn_OpenFAST_HermiteFMF, ONLY: CD_HFMF_ModuleType, CD_HFMF_Section_Curvature, CD_HFMF_OK - USE CableDyn_Precision, ONLY: wp, CD_ZERO, CD_ONE + USE CableDyn_Precision, ONLY: wp, CD_ZERO, CD_ONE, CD_MIN_TIME_STEP USE CableDyn_System, ONLY: CD_SystemType, CD_System_Line_NDOF, CD_Get_System_PointBlocks, CD_SYSTEM_OK, & CD_POINT_COUPLED IMPLICIT NONE @@ -87,9 +88,9 @@ MODULE CableDyn_CAPI INTEGER(C_INT), PARAMETER :: CD_C_NOT_INITIALIZED = 5_C_INT INTEGER(C_INT), PARAMETER :: CD_C_VERSION_MAJOR = 0_C_INT INTEGER(C_INT), PARAMETER :: CD_C_VERSION_MINOR = 4_C_INT - INTEGER(C_INT), PARAMETER :: CD_C_VERSION_PATCH = 1_C_INT + INTEGER(C_INT), PARAMETER :: CD_C_VERSION_PATCH = 2_C_INT INTEGER(C_INT), PARAMETER :: CD_C_ABI_VERSION = 1_C_INT - CHARACTER(*), PARAMETER :: CD_C_VERSION_STRING = 'CableDyn 0.4.1 C-ABI 1' + CHARACTER(*), PARAMETER :: CD_C_VERSION_STRING = 'CableDyn 0.4.2 C-ABI 1' !> Minor extension level of ABI 1: 1 adds the in-process object queries, 2 the host-coupling !> calls (initialization at host positions, state save/restore, the coupled layout query), 3 !> the host rotations (initialization for a host that turns its coupled points, their @@ -170,6 +171,9 @@ END FUNCTION cabledyn_blas_threads_once ! coupled DOFs, its step is the deck dtM (agg_dt), and agg_t is its committed time. LOGICAL :: use_agg = .FALSE. TYPE(CD_AGG_ModuleType) :: agg + ! The point route's deck current (a steady field), sampled at the step-start node positions + ! before every step, as the standalone point-system march samples it. + TYPE(CD_DeckCurrentRuntimeType) :: pt_current REAL(wp) :: agg_dt = CD_ZERO, agg_t = CD_ZERO REAL(wp), ALLOCATABLE :: agg_pos(:, :), agg_vel(:, :), agg_acc(:, :), agg_load(:, :) ! A handle initialised by CableDyn_InitDeckRotating (host_rot): the host's rotation of each @@ -391,6 +395,7 @@ SUBROUTINE init_deck_build(handle, deck_path_ptr, deck_path_len, caller, err_sta TYPE(CD_C_Handle), POINTER :: h TYPE(CD_FAST_ModuleType) :: new_fast + TYPE(CD_DeckCurrentRuntimeType) :: new_current CHARACTER(KIND=C_CHAR), POINTER :: path_c(:) CHARACTER(:), ALLOCATABLE :: deck_path INTEGER :: i, es, end_es, stat, n_objects, n_finite @@ -438,7 +443,7 @@ SUBROUTINE init_deck_build(handle, deck_path_ptr, deck_path_len, caller, err_sta END IF ! An absent positions argument stays absent through the optional coupled_positions. CALL CD_Init_Deck_System(TRIM(deck_path), new_fast%system, dtm, gravity, rho_water, es, em, line_ids=line_ids, & - coupled_positions=positions) + coupled_positions=positions, deck_current=new_current) IF (es /= CD_DECKDRV_OK) THEN CALL map_deck_status(es, err_stat) CALL store_status(h, err_stat, caller//': '//TRIM(em)) @@ -455,6 +460,7 @@ SUBROUTINE init_deck_build(handle, deck_path_ptr, deck_path_len, caller, err_sta END IF CALL CD_FAST_End(h%fast, end_es, end_em) h%fast = new_fast + h%pt_current = new_current CALL CD_FAST_End(new_fast, end_es, end_em) CALL drop_aggregate(h) CALL drop_saved_state(h) @@ -602,6 +608,7 @@ SUBROUTINE init_deck_aggregate(h, deck_path, has_dtm, dtm, caller, rotating, err END IF CALL add_aggregate_notes(new_agg) CALL CD_FAST_End(h%fast, es, em) + CALL drop_point_current(h) CALL drop_aggregate(h) CALL drop_saved_state(h) CALL clear_c_workspace(h) @@ -699,6 +706,14 @@ SUBROUTINE drop_saved_state(h) h%has_saved = .FALSE. END SUBROUTINE drop_saved_state + SUBROUTINE drop_point_current(h) + !! Forget the point route's deck current (a model built from raw lines or on the aggregate + !! has none of its own). + TYPE(CD_C_Handle), POINTER, INTENT(INOUT) :: h + TYPE(CD_DeckCurrentRuntimeType) :: none + h%pt_current = none + END SUBROUTINE drop_point_current + SUBROUTINE drop_aggregate(h) !! Release the aggregate route of a handle (another initialization replaces it). TYPE(CD_C_Handle), POINTER, INTENT(INOUT) :: h @@ -850,6 +865,7 @@ SUBROUTINE init_line_serialised(handle, n_nodes, n_elem, q0_ptr, v0_ptr, elem_co CALL CD_End_Model(model, es, em) RETURN END IF + CALL drop_point_current(h) CALL CD_FAST_Init_From_Models(h%fast, [model], es, fast_em) CALL CD_End_Model(model, end_es, em) CALL map_fast_status(es, err_stat) @@ -1045,6 +1061,7 @@ SUBROUTINE init_lines_serialised(handle, n_lines, n_nodes_ptr, n_elem_ptr, n_fix elem_off = elem_stop fixed_off = fixed_stop END DO + CALL drop_point_current(h) IF (ALLOCATED(coupled_map)) THEN CALL CD_FAST_Init_From_Models(h%fast, models, es, em, coupled_dof_map=coupled_map) ELSE @@ -1337,15 +1354,27 @@ SUBROUTINE CableDyn_Step(handle, dt, q_ptr, v_ptr, a_ptr, n_coupled_dof, converg INTEGER(C_INT), INTENT(OUT) :: n_iter, err_stat TYPE(CD_C_Handle), POINTER :: h REAL(C_DOUBLE), POINTER :: q_c(:), v_c(:), a_c(:) - LOGICAL :: conv_f, stall_f + LOGICAL :: conv_f, stall_f, sampled INTEGER :: es, nit CHARACTER(CD_C_MSG_LEN) :: em + ! the point route's drag fields before the step's current sample, put back by a step that + ! does not commit + TYPE :: held_fluid + REAL(wp), ALLOCATABLE :: velocity(:, :), waterline(:) + END TYPE held_fluid + TYPE(held_fluid), ALLOCATABLE :: held(:) converged = .FALSE._C_BOOL stalled = .FALSE._C_BOOL n_iter = 0_C_INT CALL coupled_inputs(handle, q_ptr, v_ptr, a_ptr, n_coupled_dof, h, q_c, v_c, a_c, err_stat) IF (err_stat /= CD_C_OK) RETURN + ! a positive step too small to integrate (NaN, Inf and dt <= 0 are named by the route) + IF (dt > 0.0_C_DOUBLE .AND. dt < REAL(CD_MIN_TIME_STEP, C_DOUBLE)) THEN + CALL set_status(h, CD_C_BAD_INPUT, 'CableDyn_Step: dt is below the smallest time step, 1e-100 s: '// & + 'the time integration divides by dt^2', err_stat) + RETURN + END IF IF (h%use_agg) THEN IF (h%agg_host_fluid .AND. .NOT. h%fluid_ready) THEN CALL set_status(h, CD_C_BAD_INPUT, 'CableDyn_Step: the model takes a host fluid field: call '// & @@ -1381,8 +1410,22 @@ SUBROUTINE CableDyn_Step(handle, dt, q_ptr, v_ptr, a_ptr, n_coupled_dof, converg h%v_work(1:INT(n_coupled_dof)) = REAL(v_c, wp) h%a_work(1:INT(n_coupled_dof)) = REAL(a_c, wp) END IF + ! the deck's steady current at the step-start node positions, held over the step; a step + ! that does not commit (refused input or a hard failure) puts back the fields it replaced, + ! so the model's loads are those before the call + sampled = CD_Deck_Current_Active(h%pt_current) + IF (sampled) THEN + CALL hold_point_fluid() + CALL CD_Deck_Current_Sample_System(h%pt_current, h%fast%system, CD_ZERO, es, em) + IF (es /= CD_DECKDRV_OK) THEN + CALL restore_point_fluid() + CALL set_status(h, CD_C_SOLVE_FAIL, 'CableDyn_Step: '//TRIM(em), err_stat) + RETURN + END IF + END IF CALL CD_FAST_Step(h%fast, REAL(dt, wp), h%q_work(1:INT(n_coupled_dof)), h%v_work(1:INT(n_coupled_dof)), & h%a_work(1:INT(n_coupled_dof)), conv_f, stall_f, nit, es, em) + IF (sampled .AND. es /= CD_FAST_OK) CALL restore_point_fluid() converged = LOGICAL(conv_f, C_BOOL) stalled = LOGICAL(stall_f, C_BOOL) n_iter = INT(nit, C_INT) @@ -1392,6 +1435,34 @@ SUBROUTINE CableDyn_Step(handle, dt, q_ptr, v_ptr, a_ptr, n_coupled_dof, converg CONTAINS + SUBROUTINE hold_point_fluid() + !! Keep each line's drag fluid velocity and waterline. + INTEGER :: il + ALLOCATE (held(SIZE(h%fast%system%lines))) + DO il = 1, SIZE(held) + IF (ALLOCATED(h%fast%system%lines(il)%fluid_velocity)) & + held(il)%velocity = h%fast%system%lines(il)%fluid_velocity + IF (ALLOCATED(h%fast%system%lines(il)%drag_waterline_z)) & + held(il)%waterline = h%fast%system%lines(il)%drag_waterline_z + END DO + END SUBROUTINE hold_point_fluid + + SUBROUTINE restore_point_fluid() + !! Put back the fields hold_point_fluid kept (the values the model held, so they pass the + !! setter's checks). + INTEGER :: il, es_r + CHARACTER(CD_C_MSG_LEN) :: em_r + IF (.NOT. ALLOCATED(held)) RETURN + DO il = 1, SIZE(held) + IF (ALLOCATED(held(il)%velocity) .AND. ALLOCATED(held(il)%waterline)) THEN + CALL CD_Update_Model_Hydro_Fields(h%fast%system%lines(il), es_r, em_r, fluid_velocity=held(il)%velocity, & + drag_waterline_z=held(il)%waterline) + ELSE IF (ALLOCATED(held(il)%velocity)) THEN + CALL CD_Update_Model_Hydro_Fields(h%fast%system%lines(il), es_r, em_r, fluid_velocity=held(il)%velocity) + END IF + END DO + END SUBROUTINE restore_point_fluid + SUBROUTINE clear_failed_step_flags() !! A step that did not commit reports converged = stalled = false and n_iter = 0 on !! every route (the documented hard-failure contract). diff --git a/src/CableDyn_CAPI.h b/src/CableDyn_CAPI.h index 5b0da392..9d01580c 100644 --- a/src/CableDyn_CAPI.h +++ b/src/CableDyn_CAPI.h @@ -45,7 +45,7 @@ #define CABLEDYN_CAPI_VERSION_MAJOR 0 #define CABLEDYN_CAPI_VERSION_MINOR 4 -#define CABLEDYN_CAPI_VERSION_PATCH 1 +#define CABLEDYN_CAPI_VERSION_PATCH 2 #define CABLEDYN_CAPI_ABI_VERSION 1 #ifdef __cplusplus diff --git a/src/CableDyn_Damping.f90 b/src/CableDyn_Damping.f90 index 03e4bdfb..04708243 100644 --- a/src/CableDyn_Damping.f90 +++ b/src/CableDyn_Damping.f90 @@ -21,7 +21,13 @@ MODULE CableDyn_Damping !! -- a non-negative value IS the coefficient (N.s); a NEGATIVE !! value is the desired damping ratio -zeta, giving BA = zeta * L_seg * sqrt(EA * w) !! (w = mass per unstretched metre), so each segment's axial mode carries that - !! fraction of critical damping. + !! fraction of critical damping. That ratio belongs to the segment, so the line's own axial + !! modes are damped less on a finer mesh (zeta_1 = zeta pi/(2N) on a uniform line of N + !! elements, CD_Axial_Mode1_Damping). The mesh-independent alternative + !! (CD_Resolve_Mode1_BA) makes -zeta the damping ratio of the line's first axial mode: + !! BA = 2 zeta EA / omega_1, a damping proportional to the stiffness, with omega_1 the + !! line's first axial frequency (CD_Axial_Mode1_Omega), so the first mode of a composite + !! line is damped at zeta too. !! !! Load convention (matches CD_Cable_Dynamic_Load_Proc / CableDyn_Hydro): the !! returned `force` is the external load to SUBTRACT from the residual, and @@ -33,6 +39,9 @@ MODULE CableDyn_Damping PRIVATE PUBLIC :: CD_Resolve_Legacy_BA + PUBLIC :: CD_Resolve_Mode1_BA + PUBLIC :: CD_Axial_Mode1_Omega + PUBLIC :: CD_Axial_Mode1_Damping PUBLIC :: CD_Cable_Axial_Damping_Force PUBLIC :: CD_Cable_Axial_Damping_Load PUBLIC :: CD_Axial_Damping_Element_Force @@ -78,6 +87,195 @@ SUBROUTINE CD_Resolve_Legacy_BA(ba_input, segment_length, ea, mass_per_length, b ba = (-ba_input)*segment_length*SQRT(ea*mass_per_length) END SUBROUTINE CD_Resolve_Legacy_BA + SUBROUTINE CD_Resolve_Mode1_BA(ba_input, ea, omega1, ba, ErrStat, ErrMsg) + !! Resolve a BA/-zeta line-type value with -zeta the damping ratio of the line's first axial + !! mode: BA = 2 zeta EA / omega_1 [N.s] on every element, the same for any mesh. The damping + !! is then proportional to the stiffness, so the axial mode n of a uniform line has the + !! ratio zeta omega_n / omega_1. ba_input >= 0 is the coefficient directly. + REAL(wp), INTENT(IN) :: ba_input !! BA value (negative => -zeta ratio of the first axial mode) + REAL(wp), INTENT(IN) :: ea !! axial stiffness EA of the element [N] (> 0 if -zeta) + REAL(wp), INTENT(IN) :: omega1 !! first axial frequency of the line [rad/s] (> 0 if -zeta) + REAL(wp), INTENT(OUT) :: ba !! resolved damping coefficient [N.s] + INTEGER, INTENT(OUT) :: ErrStat + CHARACTER(*), INTENT(OUT) :: ErrMsg + + ba = CD_ZERO + ErrStat = CD_DAMP_OK + ErrMsg = '' + IF (.NOT. CD_Is_Finite(ba_input)) THEN + CALL fail(ErrStat, ErrMsg, 'BA must be finite'); RETURN + END IF + IF (ba_input >= CD_ZERO) THEN + ba = ba_input + RETURN + END IF + IF (.NOT. (CD_Is_Finite(ea) .AND. ea > CD_ZERO) .OR. .NOT. (CD_Is_Finite(omega1) .AND. omega1 > CD_ZERO)) THEN + CALL fail(ErrStat, ErrMsg, 'resolving a -zeta first-mode damping ratio needs a positive EA and '// & + 'first axial frequency') + RETURN + END IF + ba = 2.0_wp*(-ba_input)*ea/omega1 + END SUBROUTINE CD_Resolve_Mode1_BA + + SUBROUTINE CD_Axial_Mode1_Omega(length, ea, mass_per_length, omega1, ErrStat, ErrMsg) + !! First axial natural frequency [rad/s] of a line of sections (unstretched length, EA and + !! dry mass per length each) fixed at both ends: the first mode of the axial chain of a + !! fixed mesh of the sections (CD_Axial_Mode1_Damping on MODE1_ELEMENTS elements shared by + !! the sections in proportion to their axial-wave transit times, at least + !! MODE1_SECTION_ELEMENTS each), so it does not depend on the line's own mesh. It is + !! (pi/L) sqrt(EA/m) on a uniform line, low by (pi/(2 MODE1_ELEMENTS))^2/6 = 1e-7. Added + !! mass is left out. + REAL(wp), INTENT(IN) :: length(:) !! section unstretched lengths [m] (> 0) + REAL(wp), INTENT(IN) :: ea(:) !! section EA [N] (> 0) + REAL(wp), INTENT(IN) :: mass_per_length(:) !! section dry mass per length [kg/m] (> 0) + REAL(wp), INTENT(OUT) :: omega1 + INTEGER, INTENT(OUT) :: ErrStat + CHARACTER(*), INTENT(OUT) :: ErrMsg + INTEGER, PARAMETER :: MODE1_ELEMENTS = 2048, MODE1_SECTION_ELEMENTS = 16 + REAL(wp), ALLOCATABLE :: l0(:), ea_e(:), m_e(:), ba_e(:) + REAL(wp) :: transit, zeta1 + INTEGER :: i, j, e, ns + INTEGER, ALLOCATABLE :: n_sec(:) + + omega1 = CD_ZERO + ErrStat = CD_DAMP_OK + ErrMsg = '' + ns = SIZE(length) + IF (ns < 1 .OR. SIZE(ea) /= ns .OR. SIZE(mass_per_length) /= ns) THEN + CALL fail(ErrStat, ErrMsg, 'the first axial frequency needs one length, EA and mass per section'); RETURN + END IF + DO i = 1, ns + IF (.NOT. (CD_Is_Finite(length(i)) .AND. length(i) > CD_ZERO .AND. CD_Is_Finite(ea(i)) .AND. & + ea(i) > CD_ZERO .AND. CD_Is_Finite(mass_per_length(i)) .AND. mass_per_length(i) > CD_ZERO)) THEN + CALL fail(ErrStat, ErrMsg, 'the first axial frequency needs a positive length, EA and mass per length'); RETURN + END IF + END DO + transit = SUM(length*SQRT(mass_per_length/ea)) + IF (.NOT. (CD_Is_Finite(transit) .AND. transit > CD_ZERO)) THEN + CALL fail(ErrStat, ErrMsg, 'the first axial frequency is not finite'); RETURN + END IF + ALLOCATE (n_sec(ns)) + DO i = 1, ns + n_sec(i) = MAX(MODE1_SECTION_ELEMENTS, NINT(REAL(MODE1_ELEMENTS, wp)*length(i)*SQRT(mass_per_length(i)/ea(i))/ & + transit)) + END DO + ALLOCATE (l0(SUM(n_sec)), ea_e(SUM(n_sec)), m_e(SUM(n_sec)), ba_e(SUM(n_sec))) + e = 0 + DO i = 1, ns + DO j = 1, n_sec(i) + e = e + 1 + l0(e) = length(i)/REAL(n_sec(i), wp) + ea_e(e) = ea(i) + m_e(e) = mass_per_length(i) + END DO + END DO + ba_e = CD_ZERO + CALL CD_Axial_Mode1_Damping(l0, ea_e, m_e, ba_e, zeta1, omega1, ErrStat, ErrMsg) + IF (ErrStat /= CD_DAMP_OK) RETURN + IF (.NOT. (CD_Is_Finite(omega1) .AND. omega1 > CD_ZERO)) THEN + omega1 = CD_ZERO + CALL fail(ErrStat, ErrMsg, 'the first axial frequency is not finite'); RETURN + END IF + END SUBROUTINE CD_Axial_Mode1_Omega + + SUBROUTINE CD_Axial_Mode1_Damping(l0, ea, mass_per_length, ba, zeta1, omega1, ErrStat, ErrMsg) + !! Damping ratio zeta_1 and frequency omega_1 [rad/s] of the first axial mode of a line of + !! elements (unstretched length, EA, dry mass per length and resolved BA each) fixed at both + !! ends: the axial chain of the mesh, element stiffness EA/L0 and damping BA/L0, the mass + !! lumped at the nodes. The undamped first mode u (inverse iteration) gives + !! omega_1^2 = u'Ku / u'Mu and zeta_1 = u'Cu / (2 omega_1 u'Mu). On a uniform line with + !! BA = zeta L0 sqrt(EA m), zeta_1 = zeta sin(pi/(2N)) ~ zeta pi/(2N). A one-element line, + !! which has no free node, takes the continuous bar: omega_1 = (pi/L0) sqrt(EA/m). + REAL(wp), INTENT(IN) :: l0(:), ea(:), mass_per_length(:), ba(:) + REAL(wp), INTENT(OUT) :: zeta1, omega1 + INTEGER, INTENT(OUT) :: ErrStat + CHARACTER(*), INTENT(OUT) :: ErrMsg + REAL(wp), PARAMETER :: PI = 3.14159265358979323846_wp + INTEGER, PARAMETER :: MAX_ITER = 2000 + REAL(wp), PARAMETER :: RAYLEIGH_TOL = 1.0e-14_wp + REAL(wp), ALLOCATABLE :: k(:), c(:), m(:), u(:), rhs(:), cp(:), dp(:) + REAL(wp) :: ukk, umm, ucc, rq, rq_old, denom + INTEGER :: n, i, it + + zeta1 = CD_ZERO + omega1 = CD_ZERO + ErrStat = CD_DAMP_OK + ErrMsg = '' + n = SIZE(l0) + IF (n < 1 .OR. SIZE(ea) /= n .OR. SIZE(mass_per_length) /= n .OR. SIZE(ba) /= n) THEN + CALL fail(ErrStat, ErrMsg, 'the first axial mode needs one length, EA, mass and BA per element'); RETURN + END IF + DO i = 1, n + IF (.NOT. (CD_Is_Finite(l0(i)) .AND. l0(i) > CD_ZERO .AND. CD_Is_Finite(ea(i)) .AND. ea(i) > CD_ZERO .AND. & + CD_Is_Finite(mass_per_length(i)) .AND. mass_per_length(i) > CD_ZERO .AND. & + CD_Is_Finite(ba(i)) .AND. ba(i) >= CD_ZERO)) THEN + CALL fail(ErrStat, ErrMsg, 'the first axial mode needs a positive length, EA and mass and a '// & + 'non-negative BA on every element'); RETURN + END IF + END DO + IF (n == 1) THEN + omega1 = (PI/l0(1))*SQRT(ea(1)/mass_per_length(1)) + zeta1 = ba(1)*omega1/(2.0_wp*ea(1)) + RETURN + END IF + ! element stiffness and damping, node masses of the n - 1 free nodes (node i joins + ! elements i and i + 1) + ALLOCATE (k(n), c(n), m(n - 1), u(n - 1), rhs(n - 1), cp(n - 1), dp(n - 1)) + k = ea/l0 + c = ba/l0 + DO i = 1, n - 1 + m(i) = 0.5_wp*(mass_per_length(i)*l0(i) + mass_per_length(i + 1)*l0(i + 1)) + END DO + u = CD_ONE + rq_old = -CD_ONE + DO it = 1, MAX_ITER + ! solve K y = M u (K tridiagonal, symmetric positive definite: Thomas without pivoting) + rhs = m*u + cp(1) = -k(2)/(k(1) + k(2)) + dp(1) = rhs(1)/(k(1) + k(2)) + DO i = 2, n - 1 + denom = (k(i) + k(i + 1)) + k(i)*cp(i - 1) + IF (i < n - 1) cp(i) = -k(i + 1)/denom + dp(i) = (rhs(i) + k(i)*dp(i - 1))/denom + END DO + u(n - 1) = dp(n - 1) + DO i = n - 2, 1, -1 + u(i) = dp(i) - cp(i)*u(i + 1) + END DO + u = u/MAXVAL(ABS(u)) + CALL forms(u, ukk, umm, ucc) + rq = ukk/umm + IF (ABS(rq - rq_old) <= RAYLEIGH_TOL*rq) EXIT + rq_old = rq + END DO + omega1 = SQRT(rq) + zeta1 = ucc/(2.0_wp*omega1*umm) + IF (.NOT. (CD_Is_Finite(omega1) .AND. CD_Is_Finite(zeta1))) THEN + zeta1 = CD_ZERO + omega1 = CD_ZERO + CALL fail(ErrStat, ErrMsg, 'the first axial mode is not finite'); RETURN + END IF + + CONTAINS + + SUBROUTINE forms(x, xkx, xmx, xcx) + !! The quadratic forms of K, M and C at the free-node displacements x (both ends held). + REAL(wp), INTENT(IN) :: x(:) + REAL(wp), INTENT(OUT) :: xkx, xmx, xcx + REAL(wp) :: dx + INTEGER :: e + ! the end elements stretch by the displacement of their free node alone + xkx = k(1)*x(1)**2 + k(n)*x(n - 1)**2 + xcx = c(1)*x(1)**2 + c(n)*x(n - 1)**2 + DO e = 2, n - 1 + dx = x(e) - x(e - 1) + xkx = xkx + k(e)*dx*dx + xcx = xcx + c(e)*dx*dx + END DO + xmx = SUM(m*x*x) + END SUBROUTINE forms + END SUBROUTINE CD_Axial_Mode1_Damping + SUBROUTINE CD_Cable_Element_Damping_Tension(q, v, elem_conn, l0, ba, td, ErrStat, ErrMsg, l0_dot) !! Signed per-element axial damping tension Td = (BA/L0)(t . (v_b - v_a)). !! Positive when the element is stretching, negative when shortening; zero at rest. diff --git a/src/CableDyn_DeckDriver.f90 b/src/CableDyn_DeckDriver.f90 index bb3317d5..ad250b7a 100644 --- a/src/CableDyn_DeckDriver.f90 +++ b/src/CableDyn_DeckDriver.f90 @@ -30,7 +30,7 @@ MODULE CableDyn_DeckDriver !! connected to Rigid6 bodies and rods (moment returned) are supported within the documented !! scope. Features outside it parse but FAIL CLOSED with a clear error naming the unsupported !! feature. - USE CableDyn_Precision, ONLY: wp, CD_ZERO, CD_ONE + USE CableDyn_Precision, ONLY: wp, CD_ZERO, CD_ONE, CD_MIN_TIME_STEP USE CableDyn_FatalReport, ONLY: CD_Fatal_Report_Time USE CableDyn_Loads, ONLY: CD_Submerged_Weight, CD_Equivalent_Buoyant_Section, CD_Assemble_Distributed_Load USE CableDyn_Assemble, ONLY: CD_Compute_Cable_Tension, CD_Cable_Free_Bandwidth, & @@ -47,7 +47,8 @@ MODULE CableDyn_DeckDriver CD_Nodal_Seabed_Stiffness, CD_LINE_OK USE CableDyn_Catenary, ONLY: CD_Catenary_Seed, CD_CAT_OK, CD_CAT_NOSEED USE CableDyn_Linalg, ONLY: CD_Solve_Dense_As_Banded, CD_LINALG_OK - USE CableDyn_Damping, ONLY: CD_Resolve_Legacy_BA, CD_DAMP_OK + USE CableDyn_Damping, ONLY: CD_Resolve_Legacy_BA, CD_Resolve_Mode1_BA, CD_Axial_Mode1_Omega, & + CD_Axial_Mode1_Damping, CD_DAMP_OK USE CableDyn_Syrope, ONLY: CD_SYROPE_WC_LINEAR, CD_SYROPE_WC_QUADRATIC, CD_SYROPE_WC_EXP, & CD_SyropeType, CD_Syrope_Init, CD_Syrope_End, & CD_Syrope_Static_Tension, CD_Syrope_Slow_For_Tension, CD_SYROPE_OK, & @@ -670,6 +671,9 @@ MODULE CableDyn_DeckDriver ! of the synchronisation model (OPTION VIVrmsWindow, s); 0 = MoorDyn's 500 time steps of ! the deck dtM (or of the run's step when the deck has none). REAL(wp) :: viv_rms_window = CD_ZERO + ! Initial VIV phases (OPTION VIVphaseSeed): spread over a turn along the line, 2 pi i/N + ! (MoorDyn-C), or zero at every node (.TRUE.: the start of MoorDyn-F in OpenFAST v5.0.0). + LOGICAL :: viv_phase_zero = .FALSE. ! WaveKinMod-1 elevation history reduced once to its real Fourier components. ! These feed the same arbitrary-component Airy kernel used by reference-matched ! irregular seas; wave_eta_mean carries the zero-frequency waterline offset. @@ -785,6 +789,10 @@ MODULE CableDyn_DeckDriver ! effective tension, curvature and bend moment from nodal equilibrium; 'element' reports the ! element-mean axial force EA (|r'| - 1) and the exact one-sided curvature traces. LOGICAL :: output_element_recovery = .FALSE. + ! A negative LINE TYPES BA (axialDampingRatio): 'segment' (default, MoorDyn's convention) + ! is the damping ratio of each segment, BA = zeta L0 sqrt(EA m) per element; 'mode1' is the + ! damping ratio of the line's first axial mode, BA = 2 zeta EA / omega_1 (CD_Resolve_Mode1_BA). + LOGICAL :: axial_damping_mode1 = .FALSE. INTEGER :: tensile_mode = CD_HCDYN_TENSILE_OFF REAL(wp) :: tensile_strain_tolerance = 2.0e-6_wp ! HOST-DRIVEN AMBIENT FLUID (not a deck keyword): set by CD_Init_Deck_Aggregate when @@ -1179,6 +1187,10 @@ MODULE CableDyn_DeckDriver ! seabed_drift: a current moves the line along a seabed without friction (seabed_drift_note); ! friction_refused: the line's route rejects frictionMu (FOLD_FRICTION_NONE). LOGICAL :: seabed_drift = .FALSE., friction_refused = .FALSE. + ! axial_zeta1: the damping ratio of the first axial mode of the built line, with both ends + ! held, on its axial_elements elements (summary_axial_damping); -1 when not worked out. + REAL(wp) :: axial_zeta1 = -1.0_wp + INTEGER :: axial_elements = 0 END TYPE CD_LineInitSummary TYPE :: CD_DeckAggregateType @@ -1356,7 +1368,7 @@ SUBROUTINE CD_Init_Deck_Models(deck_path, models, ErrStat, ErrMsg) END SUBROUTINE CD_Init_Deck_Models SUBROUTINE CD_Init_Deck_System(deck_path, system, dtM, gravity, rho_water, ErrStat, ErrMsg, caller_driven, & - env_gravity, env_rho_water, env_wtrdpth, line_ids, coupled_positions) + env_gravity, env_rho_water, env_wtrdpth, line_ids, coupled_positions, deck_current) !! Parse a supported EI=0 deck and initialize one persistent multi-line !! CableDyn system with product-facing points and endpoint bindings. !! caller_driven (default .FALSE.): the host marches the system, so the deck's @@ -1378,6 +1390,9 @@ SUBROUTINE CD_Init_Deck_System(deck_path, system, dtM, gravity, rho_water, ErrSt REAL(wp), INTENT(IN), OPTIONAL :: env_gravity, env_rho_water, env_wtrdpth INTEGER, ALLOCATABLE, INTENT(OUT), OPTIONAL :: line_ids(:) REAL(wp), INTENT(IN), OPTIONAL :: coupled_positions(:, :) + ! The deck's steady current, for the caller to sample at the node positions before every + ! step (CD_Deck_Current_Sample_System); inactive without a deck current. + TYPE(CD_DeckCurrentRuntimeType), INTENT(OUT), OPTIONAL :: deck_current TYPE(DeckLineType), ALLOCATABLE :: types(:) TYPE(DeckBody), ALLOCATABLE :: bodies(:) @@ -1389,6 +1404,7 @@ SUBROUTINE CD_Init_Deck_System(deck_path, system, dtM, gravity, rho_water, ErrSt TYPE(DeckOptions) :: opts CHARACTER(NAMELEN), ALLOCATABLE :: channels(:) TYPE(CD_BathymetryType) :: bathymetry + TYPE(HydroUpdateWorkspace) :: current_work LOGICAL :: ext_march INTEGER :: i ErrStat = CD_DECKDRV_OK @@ -1468,6 +1484,18 @@ SUBROUTINE CD_Init_Deck_System(deck_path, system, dtM, gravity, rho_water, ErrSt ELSE CALL init_deck_system_from_parsed(types, points, lines, sections, opts, system, ErrStat, ErrMsg) END IF + ! A line model takes its drag's fluid velocity at the nodes of its straight seed; the static + ! solve samples a depth profile or grid at its own node positions. The field is sampled + ! again at the static nodes (the t = 0 state), as the standalone march does before its first + ! step, so the end loads at the start are those of the static state and a caller stepping + ! the system at rest stays at rest. A uniform current is the same at every node. + IF (ErrStat == CD_DECKDRV_OK .AND. opts%has_current) THEN + CALL update_system_line_hydro(system, opts, CD_ZERO, current_work, ErrStat, ErrMsg, initial_condition=.TRUE.) + IF (ErrStat == CD_DECKDRV_OK .AND. PRESENT(deck_current)) THEN + deck_current%active = .TRUE. + deck_current%opts = opts + END IF + END IF IF (PRESENT(line_ids) .AND. ErrStat == CD_DECKDRV_OK) THEN ALLOCATE (line_ids(SIZE(lines))) line_ids = lines(:)%id @@ -1619,6 +1647,9 @@ SUBROUTINE capture_system_notes(lines, points, sections, types, opts, system, dt CALL axial_period_note(summaries(i)%line_id, dt, sections, types, note) CALL capture_note(note) END IF + ! the caller marches the system, with the deck's step or its own + CALL axial_damping_note(summaries(i), sections, types, opts, note) + CALL capture_note(note) END DO IF (ANY(summaries%seabed_drift)) THEN CALL seabed_drift_note(PACK(summaries%line_id, summaries%seabed_drift), & @@ -1844,6 +1875,7 @@ RECURSIVE SUBROUTINE build_one_hermite_cable(ln, sections, types, points, opts, REAL(wp), ALLOCATABLE :: curv(:), cdn(:), cdt(:), can(:), cat(:), catenary_pos(:) REAL(wp), ALLOCATABLE :: viv_cl(:), viv_cf(:), viv_df(:) REAL(wp), ALLOCATABLE :: ba_raw(:), ba(:), dry_b(:) + REAL(wp) :: mode1_omega REAL(wp), ALLOCATABLE :: contact_kn(:), contact_cn(:) REAL(wp) :: anchor(3), fairlead(3), res, tvec(3), tnrm, contact_z, seed_z, seed_floor_a, seed_floor_b REAL(wp) :: dxh, dyh, hspan, frame_cs(2), horizontal_tension, grounded_length @@ -1871,9 +1903,14 @@ RECURSIVE SUBROUTINE build_one_hermite_cable(ln, sections, types, points, opts, LOGICAL :: polish_ready ! Set when the attachment polish needed its fallbacks (attachment_fallback_checks). LOGICAL :: att_fell_back + ! The relative residual of the discrete attachment equilibrium when a residual floor kept it + ! above the tight static tolerance (0 otherwise). + REAL(wp) :: att_floor_res LOGICAL :: bathymetry_flat, require_3d_static, sym_broken, planar_unstable, saddle_kept ! whether the line would be solved in 3D without its torsion (a twisted line always is) LOGICAL :: require_3d_untwisted + ! the deck current has a component across the vertical plane of the chord + LOGICAL :: cross_current ! A planar equilibrium in a current that is a saddle out of its plane (see route_pass). REAL(wp), ALLOCATABLE :: l0_saddle(:), ea_saddle(:), ei_saddle(:), w_saddle(:), q_saddle(:), curv_saddle(:) INTEGER, ALLOCATABLE :: fixed_saddle(:) @@ -1892,6 +1929,8 @@ RECURSIVE SUBROUTINE build_one_hermite_cable(ln, sections, types, points, opts, LOGICAL :: tensile_error CHARACTER(1024) :: note_text CHARACTER(1024) :: limit_text + ! the still-water diagnosis read its compression on elements longer than half the bending length + LOGICAL :: coarse_sw ! The geometric cause of a line with no admissible planar equilibrium clear of the seabed: ! too long to hang as a catenary (net-heavy), or weightless (no catenary exists at all). LOGICAL :: weightless_line @@ -1916,6 +1955,10 @@ RECURSIVE SUBROUTINE build_one_hermite_cable(ln, sections, types, points, opts, ! smeared equivalent first), and the attachment nodes on the final mesh. LOGICAL :: has_att REAL(wp), ALLOCATABLE :: w_bare_deck(:), l0_deck_att(:), w_bare(:) + ! In a current across the line's plane, the line's own drag coefficients (cur_obj, deck mesh), + ! to which the attachments' drag smeared into cur_obj (smear_attachment_drag) returns in the + ! polish; unallocated when no attachment drag is smeared. + REAL(wp), ALLOCATABLE :: att_cdn_bare(:), att_cdt_bare(:) INTEGER, ALLOCATABLE :: att_node(:) ! STIFFENERS: the cable's own bending stiffness per element (internal order), without the ! sleeve, for the cable's share of the bend moment (allocated only on a stiffened line) @@ -2116,6 +2159,7 @@ RECURSIVE SUBROUTINE build_one_hermite_cable(ln, sections, types, points, opts, ! A current with a component across the vertical plane of the chord pushes the line out ! of that plane, which the dynamics (endpoints held, every other DOF free) follow: the ! static equilibrium is then solved in 3D as well. + cross_current = .FALSE. IF (opts%has_current) THEN IF (opts%has_current_grid) THEN ! a current grid (Currents 2 and 5): the static start takes its t = 0 sample, every point @@ -2129,7 +2173,7 @@ RECURSIVE SUBROUTINE build_one_hermite_cable(ln, sections, types, points, opts, IF (ABS(-frame_cs(2)*opts%current_grid%velocity(1, ix, iy, iz, 1) + & frame_cs(1)*opts%current_grid%velocity(2, ix, iy, iz, 1)) > & 64.0_wp*EPSILON(CD_ONE)*MAX(CD_ONE, NORM2(opts%current_grid%velocity(:, ix, iy, iz, 1)))) & - require_3d_static = .TRUE. + cross_current = .TRUE. END DO END DO END DO @@ -2138,13 +2182,14 @@ RECURSIVE SUBROUTINE build_one_hermite_cable(ln, sections, types, points, opts, DO i = 1, SIZE(opts%current_profile_z) IF (ABS(-frame_cs(2)*opts%current_profile_velocity(1, i) + frame_cs(1)*opts%current_profile_velocity(2, i)) & > 64.0_wp*EPSILON(CD_ONE)*MAX(CD_ONE, NORM2(opts%current_profile_velocity(:, i)))) & - require_3d_static = .TRUE. + cross_current = .TRUE. END DO ELSE IF (ABS(-frame_cs(2)*opts%current_velocity(1) + frame_cs(1)*opts%current_velocity(2)) > & 64.0_wp*EPSILON(CD_ONE)*MAX(CD_ONE, NORM2(opts%current_velocity))) THEN - require_3d_static = .TRUE. + cross_current = .TRUE. END IF END IF + IF (cross_current) require_3d_static = .TRUE. ! A lay azimuth across the vertical plane of the chord puts the as-laid friction ! reference, and the friction it holds, out of that plane: solved in 3D as well. This is ! decided here, before the held (planar) DOFs below are chosen. @@ -2440,6 +2485,24 @@ RECURSIVE SUBROUTINE build_one_hermite_cable(ln, sections, types, points, opts, IF (ALLOCATED(cur_obj%profile_velocity)) DEALLOCATE (cur_obj%profile_velocity) IF (ALLOCATED(cur_obj%grid)) DEALLOCATE (cur_obj%grid) END IF + ! In a current across the vertical plane of the chord the smeared start carries the + ! attachments' drag as well as their weight, spread over the same elements + ! (smear_attachment_drag), and the polish moves it to the nodes with the weight. Without + ! it the polish applied the whole attachment drag to the smeared state, which that drag + ! pushes out of its plane: on a frictional seabed its damped Newton solves diverged as + ! the grounded run slid metres sideways (25 modules on a lazy wave in 0.3 m/s across its + ! plane). A current along the plane does not move the line out of it, and the polish + ! carries the attachment drag as before: carried by the smeared start instead, it stopped + ! the current stepping on a coarse deck mesh at the grounded-run compression check (a lazy + ! wave restrained in torsion in 0.5 m/s along its plane, whose discrete state the polish + ! reaches). + IF (has_att .AND. cur_obj%drag .AND. cross_current) THEN + IF (ANY(ln%att(4, :) > CD_ZERO .OR. ln%att(6, :) > CD_ZERO)) THEN + att_cdn_bare = cur_obj%cdn + att_cdt_bare = cur_obj%cdt + CALL smear_attachment_drag(cur_obj%cdn, cur_obj%cdt, cur_obj%diam, l0, att_node, ln%att) + END IF + END IF IF (as_laid) THEN CALL as_laid_reference(es, em) IF (es /= CD_DECKDRV_OK) THEN @@ -3070,8 +3133,13 @@ RECURSIVE SUBROUTINE build_one_hermite_cable(ln, sections, types, points, opts, ! route diagnostics below are bounded and would cut it. A line already compressed ! without the current is named before that: the current starts from that layout. limit_text = '' - IF (opts%has_current) CALL still_water_compression(limit_text) - IF (LEN_TRIM(limit_text) > 0) THEN + IF (opts%has_current) CALL still_water_compression(limit_text, coarse_sw) + IF (LEN_TRIM(limit_text) > 0 .AND. coarse_sw) THEN + CALL fail_solve(ErrStat, ErrMsg, 'finite-EI cable static solve failed in the current: '// & + TRIM(limit_text)//'. Catenary-continuation route: '// & + TRIM(short_message(primary_msg, 360))//'. Mesh-sequenced route: '// & + TRIM(short_message(sequence_msg, 360))); RETURN + ELSE IF (LEN_TRIM(limit_text) > 0) THEN CALL fail_solve(ErrStat, ErrMsg, 'finite-EI cable has no static equilibrium in the current: '// & TRIM(limit_text)//'. Catenary-continuation route: '// & TRIM(short_message(primary_msg, 360))//'. Mesh-sequenced route: '// & @@ -3128,7 +3196,9 @@ RECURSIVE SUBROUTINE build_one_hermite_cable(ln, sections, types, points, opts, END IF IF (LEN_TRIM(resolution_note) > 0 .AND. primary_done) & CALL report_note('line '//TRIM(int_to_str(ln%id))//': '//TRIM(resolution_note)) - IF (tolerance_note) THEN + ! tolerance_note is set by a solve repeated at a looser tolerance, whose last Newton step can + ! still land below the tight one: only a residual above the tight tolerance is a floor to note + IF (tolerance_note .AND. res > static_tol_target) THEN WRITE (note_text, '(A,I0,A,ES9.2,A,ES9.2)') 'line ', ln%id, ': static residual floor above the '// & 'dynamic tolerance ', static_tol_target, '; equilibrium accepted at the relative residual ', res CALL report_note(note_text) @@ -3221,11 +3291,24 @@ RECURSIVE SUBROUTINE build_one_hermite_cable(ln, sections, types, points, opts, CALL MOVE_ALLOC(w_am, w) CALL MOVE_ALLOC(fixed_am, fixed_dofs) ALLOCATE (ba(SIZE(l0))) + ! OPTION axialDampingRatio mode1: a negative BA is the damping ratio of the line's first + ! axial mode, set by the deck sections whatever the mesh + mode1_omega = CD_ZERO + IF (opts%axial_damping_mode1 .AND. ANY(ba_raw < CD_ZERO)) THEN + CALL line_mode1_omega(ln%id, sections, types, mode1_omega, es, em) + IF (es /= CD_DECKDRV_OK) THEN + CALL fail(ErrStat, ErrMsg, TRIM(em)); RETURN + END IF + END IF DO i = 1, SIZE(l0) ! Resolve negative damping-ratio inputs only after adaptive remeshing because ! BA = zeta*l0*sqrt(EA*mass_per_length) is defined for the final element length. ! A direct positive BA remains a mesh-independent constitutive coefficient. - CALL CD_Resolve_Legacy_BA(ba_raw(i), l0(i), ea(i), rho_a(i), ba(i), es, em) + IF (opts%axial_damping_mode1) THEN + CALL CD_Resolve_Mode1_BA(ba_raw(i), ea(i), mode1_omega, ba(i), es, em) + ELSE + CALL CD_Resolve_Legacy_BA(ba_raw(i), l0(i), ea(i), rho_a(i), ba(i), es, em) + END IF IF (es /= CD_DAMP_OK) THEN CALL fail(ErrStat, ErrMsg, 'finite-EI BA resolution failed: '//TRIM(em)); RETURN END IF @@ -3257,16 +3340,20 @@ RECURSIVE SUBROUTINE build_one_hermite_cable(ln, sections, types, points, opts, ! friction deflection along a slope, beyond the slope load its spring carries at rest. IF (as_laid .AND. PRESENT(bathymetry)) THEN BLOCK - REAL(wp), ALLOCATABLE :: node_load(:) - ALLOCATE (node_load(SIZE(l0) + 1)) + REAL(wp), ALLOCATABLE :: node_load(:), node_dry(:) + ALLOCATE (node_load(SIZE(l0) + 1), node_dry(SIZE(l0) + 1)) node_load = CD_ZERO + node_dry = CD_ZERO DO i = 1, SIZE(l0) node_load(i:i + 1) = node_load(i:i + 1) + 0.5_wp*w_bare(i)*l0(i) END DO + ! the net weight of each attachment, and the buoyancy it has not above the surface + ! (attachment_static_weight) DO i = 1, SIZE(att_node) node_load(att_node(i)) = node_load(att_node(i)) + (ln%att(2, i) - opts%rhoW*ln%att(3, i))*opts%g + node_dry(att_node(i)) = node_dry(att_node(i)) + opts%rhoW*ln%att(3, i)*opts%g END DO - CALL as_laid_reference(es, em, node_load) + CALL as_laid_reference(es, em, node_load, node_dry) END BLOCK IF (es /= CD_DECKDRV_OK) THEN CALL fail_solve(ErrStat, ErrMsg, 'finite-EI as-laid reference for the seabed friction with discrete '// & @@ -3276,7 +3363,13 @@ RECURSIVE SUBROUTINE build_one_hermite_cable(ln, sections, types, points, opts, CALL attachment_static_polish(l0, ea, ei, w_bare, w, diam, att_node, ln%att, q_static, fixed_dofs, & contact_enabled, contact_z, frame_cs, endconn_k, endconn_d0_local, & endconn_mode, opts, static_tol, ErrStat, ErrMsg, bathymetry, cur_obj, & - fell_back=att_fell_back) + fell_back=att_fell_back, cdn_bare=att_cdn_bare, cdt_bare=att_cdt_bare, & + tol_floor=COUPLED_STATIC_TOL, floor_res=att_floor_res) + ! the discrete equilibrium carries the line's own drag (the attachments' at their nodes) + IF (ALLOCATED(att_cdn_bare)) THEN + cur_obj%cdn = att_cdn_bare + cur_obj%cdt = att_cdt_bare + END IF IF (ErrStat /= CD_DECKDRV_OK) RETURN ! A discrete state the damped Newton solves did not reach alone (pseudo-transient ! continuation, line search or smaller load steps) passes the acceptance checks the @@ -3292,6 +3385,12 @@ RECURSIVE SUBROUTINE build_one_hermite_cable(ln, sections, types, points, opts, 'after a failed Newton solve (pseudo-transient continuation, line search or smaller '// & 'load steps) and passed the acceptance checks of the smeared state') END IF + IF (att_floor_res > CD_ZERO) THEN + WRITE (note_text, '(A,I0,A,ES9.2,A,ES9.2)') 'line ', ln%id, ': static residual floor above the '// & + 'dynamic tolerance ', static_tol_target, '; discrete attachment equilibrium accepted at the relative '// & + 'residual ', att_floor_res + CALL report_note(note_text) + END IF ! On the final mesh, with the bare weights the polished state carries; the bending-length ! rule of the note uses the smeared section weights w. A line restrained in torsion starts ! from the twisted state, whose stability the torsion stage tests (with the same static @@ -3468,27 +3567,23 @@ RECURSIVE SUBROUTINE build_one_hermite_cable(ln, sections, types, points, opts, ! coupled host may step the cable at a dt adjusted from the deck dtM. IF (PRESENT(install_viv)) THEN IF (install_viv .AND. ANY(viv_cl > CD_ZERO)) THEN - ! MoorDyn's phase seed counts the deck nodes from the deck's End A: a line the reader turned - ! around, or a mesh the static solve refined, takes it node by node (CD_Deck_VIV_Phase_Seed) - IF (ln%ends_swapped .OR. ALLOCATED(cable%deck_node)) THEN - BLOCK - REAL(wp) :: seed(cable%line%nn) - IF (ALLOCATED(cable%deck_node)) THEN - CALL CD_Deck_VIV_Phase_Seed(cable%line%l0, ln%ends_swapped, seed, deck_map=cable%deck_node) - ELSE - CALL CD_Deck_VIV_Phase_Seed(cable%line%l0, ln%ends_swapped, seed) - END IF - CALL CD_HermiteCable_Dyn_Set_VIV(cable%line, viv_cl, viv_cf, viv_df, & - MERGE(opts%viv_rms_window, & - REAL(CD_VIV_NM, wp)*MERGE(opts%dtM, dt, opts%has_dtm), & - opts%viv_rms_window > CD_ZERO), es, em, phase_seed=seed) - END BLOCK - ELSE + ! MoorDyn's phase seed counts the deck nodes from the deck's End A, with its node tangent + ! towards the deck's End B; CD_Deck_VIV_Phase_Seed takes it node by node to the model's + ! nodes and tangent (a line the reader turned around, a mesh the static solve refined) + BLOCK + REAL(wp) :: seed(cable%line%nn) + IF (ALLOCATED(cable%deck_node)) THEN + CALL CD_Deck_VIV_Phase_Seed(cable%line%l0, ln%ends_swapped, seed, deck_map=cable%deck_node, & + zero=opts%viv_phase_zero) + ELSE + CALL CD_Deck_VIV_Phase_Seed(cable%line%l0, ln%ends_swapped, seed, zero=opts%viv_phase_zero) + END IF CALL CD_HermiteCable_Dyn_Set_VIV(cable%line, viv_cl, viv_cf, viv_df, & MERGE(opts%viv_rms_window, & REAL(CD_VIV_NM, wp)*MERGE(opts%dtM, dt, opts%has_dtm), & - opts%viv_rms_window > CD_ZERO), es, em) - END IF + opts%viv_rms_window > CD_ZERO), es, em, phase_seed=seed, & + tangent_reversed=.NOT. ln%ends_swapped) + END BLOCK IF (es /= CD_HCDYN_OK) THEN CALL fail(ErrStat, ErrMsg, 'finite-EI cable VIV wiring failed: '//TRIM(em)); RETURN END IF @@ -4164,18 +4259,25 @@ SUBROUTINE audit_refined_state(done, why) END IF END SUBROUTINE audit_refined_state - SUBROUTINE still_water_compression(text) + SUBROUTINE still_water_compression(text, coarse) !! On a failed solve in a current: whether the same line without the current is !! already in axial compression (an element-mean force below -1e-3 of the peak !! tension, held only by the bending stiffness). Returns the diagnosis, or blank. + !! coarse: the still-water state is on elements longer than half the bending length + !! (EI/|w|)^(1/3), where the element-mean axial force of a stiff line oscillates and can + !! read a compression the line does not carry; the diagnosis then says so instead of + !! naming the layout (a lazy wave on 4 m and 10 m elements beside 0.9 m ones read + !! -2.8 kN where it carries about +1 kN, and solves on a mesh that resolves its bends). CHARACTER(*), INTENT(OUT) :: text + LOGICAL, INTENT(OUT) :: coarse TYPE(DeckOptions) :: opts_sw TYPE(CD_HFMF_ModuleType) :: sw_cable INTEGER :: sw_node, esw, e_min, wios - REAL(wp) :: t_min, t_max, s_min + REAL(wp) :: t_min, t_max, s_min, need CHARACTER(1024) :: emw CHARACTER(2048) :: sw_note text = '' + coarse = .FALSE. opts_sw = opts opts_sw%has_current = .FALSE. opts_sw%has_current_profile = .FALSE. @@ -4195,10 +4297,21 @@ SUBROUTINE still_water_compression(text) CALL CD_HermiteCable_Mean_Axial_Extremes(sw_cable%line%l0, sw_cable%line%EA, sw_cable%line%q, t_min, & t_max, e_min, s_min, esw, emw) IF (esw == CD_HCSTAT_OK .AND. t_min < -1.0e-3_wp*t_max) THEN - WRITE (text, '(A,ES10.3,A,F10.2,A,ES10.3,A)', IOSTAT=wios) 'the line is already in axial '// & - 'compression without the current (element mean ', t_min, ' N at unstretched arc length ', & - s_min, ' m from the anchor, peak tension ', t_max, ' N), a layout that only its bending '// & - 'stiffness holds; the current pushes that layout further and no equilibrium follows it' + need = bending_refine_need(sw_cable%line%l0, sw_cable%line%EI, sw_cable%line%w) + coarse = need > CD_ONE + IF (coarse) THEN + WRITE (text, '(A,ES10.3,A,F10.2,A,ES10.3,A,F6.2,A)', IOSTAT=wios) 'without the current the line '// & + 'reads an element-mean axial compression (', t_min, ' N at unstretched arc length ', s_min, & + ' m from the anchor, peak tension ', t_max, ' N) on elements up to ', need, ' times half the '// & + 'bending length (EI/|w|)^(1/3), where the element-mean axial force of a stiff line oscillates '// & + 'and can read a compression the line does not carry; refine those elements (NumSegs) to half '// & + 'the bending length or less' + ELSE + WRITE (text, '(A,ES10.3,A,F10.2,A,ES10.3,A)', IOSTAT=wios) 'the line is already in axial '// & + 'compression without the current (element mean ', t_min, ' N at unstretched arc length ', & + s_min, ' m from the anchor, peak tension ', t_max, ' N), a layout that only its bending '// & + 'stiffness holds; the current pushes that layout further and no equilibrium follows it' + END IF END IF END IF CALL CD_HFMF_End(sw_cable) @@ -5138,7 +5251,7 @@ LOGICAL FUNCTION as_laid_cross_slope() RESULT(cross) END DO END FUNCTION as_laid_cross_slope - SUBROUTINE as_laid_reference(esr, emr, node_load) + SUBROUTINE as_laid_reference(esr, emr, node_load, node_dry_load) !! Friction reference of the static solve (CD_HermiteCable_As_Laid_Offsets): the line laid !! on the seabed from its lower end (the anchor, node 1, unless the fairlead is lower, as in !! the EI = 0 line model) along the lay azimuth at the as-laid tension, as (x, y) offsets @@ -5152,9 +5265,13 @@ SUBROUTINE as_laid_reference(esr, emr, node_load) !! dynamic hand-off does on the final mesh. node_load [N, downward positive, one entry per !! node]: the discrete loads of an attachment polish on the final mesh l0, which hold on !! that mesh alone; the reference is then this profile (default: the lumped weights w). + !! node_dry_load (with node_load): the attachments' buoyancy at each node, which a node + !! laid above the still-water level does not have. On a bathymetry a node sinks under the + !! normal load the solver applies at its laid position, the dry part of a section laid + !! within its radius of the surface included (the friction's laid_* dry-part data). INTEGER, INTENT(OUT) :: esr CHARACTER(*), INTENT(OUT) :: emr - REAL(wp), INTENT(IN), OPTIONAL :: node_load(:) + REAL(wp), INTENT(IN), OPTIONAL :: node_load(:), node_dry_load(:) REAL(wp), ALLOCATABLE :: wn(:), kn_r(:), offsets(:, :) REAL(wp) :: laid_t, az INTEGER :: k, ne_r, es_r @@ -5180,6 +5297,15 @@ SUBROUTINE as_laid_reference(esr, emr, node_load) cur_obj%friction%laid_azimuth = az cur_obj%friction%laid_tension = laid_t cur_obj%friction%laid_frame_cs = frame_cs + ! the dry part of the line at the still-water level z = 0, the diameter by reference arc + cur_obj%friction%laid_water_weight = opts%rhoW*opts%g + cur_obj%friction%laid_waterline_z = CD_ZERO + ALLOCATE (cur_obj%friction%laid_arc_end(ne_r), cur_obj%friction%laid_diam(ne_r)) + cur_obj%friction%laid_arc_end(1) = l0(1) + DO k = 2, ne_r + cur_obj%friction%laid_arc_end(k) = cur_obj%friction%laid_arc_end(k - 1) + l0(k) + END DO + cur_obj%friction%laid_diam = diam(1:ne_r) ! the nodal loads and seabed stiffnesses the nodes of mesh l0 sink under ALLOCATE (wn(ne_r + 1), kn_r(ne_r + 1), offsets(2, ne_r + 1)) wn = CD_ZERO @@ -5194,7 +5320,10 @@ SUBROUTINE as_laid_reference(esr, emr, node_load) wn(k:k + 1) = wn(k:k + 1) + 0.5_wp*w(k)*l0(k) END DO END IF - IF (PRESENT(bathymetry)) THEN + IF (PRESENT(bathymetry) .AND. PRESENT(node_dry_load)) THEN + CALL CD_HermiteCable_As_Laid_Offsets(cur_obj%friction, l0, ea, wn, kn_r, offsets, es_r, emr, bathymetry, & + node_dry_load=node_dry_load) + ELSE IF (PRESENT(bathymetry)) THEN CALL CD_HermiteCable_As_Laid_Offsets(cur_obj%friction, l0, ea, wn, kn_r, offsets, es_r, emr, bathymetry) ELSE CALL CD_HermiteCable_As_Laid_Offsets(cur_obj%friction, l0, ea, wn, kn_r, offsets, es_r, emr) @@ -5471,15 +5600,51 @@ SUBROUTINE smear_attachments(w, l0, node, att, rho_w, g) END DO END SUBROUTINE smear_attachments + SUBROUTINE smear_attachment_drag(cdn, cdt, diam, l0, node, att) + !! Spread each attachment's drag areas over the elements next to its node, as + !! smear_attachments spreads its net weight: the normal drag area CdA and the axial drag area + !! CdAx become per-metre drag coefficients of those elements (Cd_n d per metre and + !! pi Cd_t d per metre, the line's own Morison law), so that the smeared line carries the + !! attachments' current drag as well as their weight. + REAL(wp), INTENT(INOUT) :: cdn(:), cdt(:) + REAL(wp), INTENT(IN) :: diam(:), l0(:), att(:, :) + INTEGER, INTENT(IN) :: node(:) + INTEGER :: k, j, ne + ne = SIZE(l0) + DO k = 1, SIZE(node) + j = node(k) + IF (j == 1) THEN + CALL add_share(1, CD_ONE) + ELSE IF (j == ne + 1) THEN + CALL add_share(ne, CD_ONE) + ELSE + CALL add_share(j - 1, 0.5_wp) + CALL add_share(j, 0.5_wp) + END IF + END DO + CONTAINS + 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)) + END SUBROUTINE add_share + 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) + opts, tol, ErrStat, ErrMsg, bathymetry, cur_obj, fell_back, cdn_bare, & + cdt_bare, tol_floor, floor_res) !! 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, !! attachment_static_weight) and, in a deck current, the attachment current drag grow from !! zero to full, with the contact, dry-buoyancy, end-connection and line current terms of - !! the builder's static problem. The drag depends on the node's position (profile current, + !! the builder's static problem. With cdn_bare and cdt_bare (the line's own drag + !! coefficients of cur_obj, whose cdn and cdt carry the attachments' drag smeared, + !! smear_attachment_drag) the element drag coefficients move from those of cur_obj to them + !! with the weights, so the smeared drag passes to the nodes as the smeared weight does. + !! The drag depends on the node's position (profile current, !! current grid) and line tangent, and the weight on the side of the surface the node is on, !! so each solve takes them at its incoming state and the full-load solve is repeated with !! those of the last solution until the solution stops moving and no attachment changes @@ -5495,17 +5660,22 @@ SUBROUTINE attachment_static_polish(l0, ea, ei, w_bare, w_smear, diam, node, att !! and still advances at the smaller size. At most MAX_FAILED_STEPS load steps may fail in !! all, a backstop that a steady homotopy does not reach (16 failures at worst, at !! MIN_STEP); with at most 1/MIN_STEP converged steps this bounds the polish. - !! The smeared state carries no attachment drag, and on a frictional seabed, whose - !! regularised friction force turns from its sticking stiffness to its sliding capacity - !! over a short slip, the Newton update for a cross-flow drag can overshoot far from the - !! equilibrium and diverge (even in load steps of 1/64), which the pseudo-transient - !! regularisation avoids. Once a damped Newton solve has failed, the - !! later ones get NEWTON_RETRY_ITER iterations before the fallbacks take over. A polish + !! On a frictional seabed, whose regularised friction force turns from its sticking + !! stiffness to its sliding capacity over a short slip, the Newton update for a cross-flow + !! drag can overshoot far from the equilibrium and diverge, which the pseudo-transient + !! regularisation avoids (from a smeared state without the attachment drag, which the polish + !! then applied whole, even load steps of 1/64 diverged). Once a damped Newton solve has + !! failed, the later ones get NEWTON_RETRY_ITER iterations before the fallbacks take over. A polish !! whose damped Newton solves all converge takes exactly the solves it took before. !! fell_back (optional out) reports that a damped Newton solve failed, so that the state !! was reached with the fallbacks (and the caller re-runs its acceptance checks on it). !! A failure names the load fraction of the first failed solve and, when the homotopy !! stops, the load fraction it reached. + !! tol_floor (optional, > tol) is the tolerance of a residual floor: a solve whose Newton + !! iteration stalls above tol is repeated at tol_floor, from the same incoming state, before + !! 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. 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(:) @@ -5517,7 +5687,11 @@ SUBROUTINE attachment_static_polish(l0, ea, ei, w_bare, w_smear, diam, node, att TYPE(CD_BathymetryType), INTENT(IN), OPTIONAL :: bathymetry TYPE(CD_HermiteStaticCurrentType), INTENT(IN), OPTIONAL :: cur_obj LOGICAL, INTENT(OUT), OPTIONAL :: fell_back + REAL(wp), INTENT(IN), OPTIONAL :: cdn_bare(:), cdt_bare(:), tol_floor + REAL(wp), INTENT(OUT), OPTIONAL :: floor_res 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 ! Smallest load-fraction step: 1/NSTEP halved seven times. Newton budget once a damped ! Newton solve of this polish has failed (a converging one takes well under it). Budget ! of failed load steps: each takes at most NEWTON_RETRY_ITER + 400 Newton iterations @@ -5538,9 +5712,30 @@ SUBROUTINE attachment_static_polish(l0, ea, ei, w_bare, w_smear, diam, node, att ! The damped Newton failure of the first failed solve, and of the last one. CHARACTER(1024) :: first_msg, last_msg CHARACTER(48) :: step_buf, lam_buf + ! the current of the solves (cur_obj with the element drag coefficients of the load + ! fraction; unallocated without cur_obj) and cur_obj's smeared coefficients + TYPE(CD_HermiteStaticCurrentType), ALLOCATABLE :: cur_l + REAL(wp), ALLOCATABLE :: cdn_smear(:), cdt_smear(:) + LOGICAL :: blend_drag + ! the looser tolerance of a residual floor, and the number of tolerances a solve may take + REAL(wp) :: tol_loose + INTEGER :: n_tol ErrStat = CD_DECKDRV_OK; ErrMsg = '' IF (PRESENT(fell_back)) fell_back = .FALSE. + IF (PRESENT(floor_res)) floor_res = CD_ZERO + tol_loose = tol + IF (PRESENT(tol_floor)) tol_loose = MAX(tol, tol_floor) + n_tol = MERGE(2, 1, tol_loose > tol) + blend_drag = .FALSE. + IF (PRESENT(cur_obj)) THEN + ALLOCATE (cur_l, SOURCE=cur_obj) + blend_drag = PRESENT(cdn_bare) .AND. PRESENT(cdt_bare) + IF (blend_drag) THEN + cdn_smear = cur_obj%cdn + cdt_smear = cur_obj%cdt + END IF + END IF first_msg = '' last_msg = '' newton_failed = .FALSE. @@ -5568,6 +5763,10 @@ SUBROUTINE attachment_static_polish(l0, ea, ei, w_bare, w_smear, diam, node, att DO WHILE (lam_done < CD_ONE) lam = MIN(CD_ONE, lam_done + dlam) wl = w_bare + (CD_ONE - lam)*(w_smear - w_bare) + IF (blend_drag) THEN + cur_l%cdn = cdn_bare + (CD_ONE - lam)*(cdn_smear - cdn_bare) + cur_l%cdt = cdt_bare + (CD_ONE - lam)*(cdt_smear - cdt_bare) + END IF CALL solve_with(lam, converged) IF (ErrStat /= CD_DECKDRV_OK) RETURN IF (converged) THEN @@ -5663,8 +5862,8 @@ SUBROUTINE solve_with(scale, ok, dq_max) REAL(wp), INTENT(IN) :: scale LOGICAL, INTENT(OUT) :: ok REAL(wp), INTENT(OUT), OPTIONAL :: dq_max - INTEGER, PARAMETER :: NEWTON = 1, PSEUDO_TRANSIENT = 2, MERIT = 3 - INTEGER :: it, es, mode, max_it(3) + INTEGER :: it, es, mode, max_it(3), k_tol + REAL(wp) :: tol_k CHARACTER(1024) :: em CHARACTER(48) :: num_buf ok = .FALSE. @@ -5683,34 +5882,18 @@ SUBROUTINE solve_with(scale, ok, dq_max) END IF END IF DO mode = NEWTON, MERIT - IF (contact_enabled) THEN - CALL CD_HermiteCable_Static_Solve(l0, ea, ei, wl, q, fixed_dofs, contact_z, CD_ZERO, 1, max_it(mode), & - tol, 0.7_wp, q_out, curv, res, it, es, em, & - f_nodal=scale*(f_att + f_drag), n_buoy_steps=1, contact_kn=knnode, & - bathymetry=bathymetry, contact_frame_cs=frame_cs, & - axial_quadrature_order=opts%axial_quadrature_order, & - bending_quadrature_order=opts%bending_quadrature_order, & - endconn_stiffness=endconn_k, endconn_direction=endconn_d0, & - endconn_mode=endconn_mode, waterline_z=CD_ZERO, dry_buoyancy=dry, & - water_weight=opts%rhoW*opts%g, current=cur_obj, & - backtracking=mode == MERIT, merit_line_search=mode == MERIT, & - pseudo_transient=mode == PSEUDO_TRANSIENT) - ELSE - CALL CD_HermiteCable_Static_Solve(l0, ea, ei, wl, q, fixed_dofs, contact_z, CD_ZERO, 1, max_it(mode), & - tol, 0.7_wp, q_out, curv, res, it, es, em, & - f_nodal=scale*(f_att + f_drag), n_buoy_steps=1, & - axial_quadrature_order=opts%axial_quadrature_order, & - bending_quadrature_order=opts%bending_quadrature_order, & - endconn_stiffness=endconn_k, endconn_direction=endconn_d0, & - endconn_mode=endconn_mode, waterline_z=CD_ZERO, dry_buoyancy=dry, & - water_weight=opts%rhoW*opts%g, current=cur_obj, & - backtracking=mode == MERIT, merit_line_search=mode == MERIT, & - pseudo_transient=mode == PSEUDO_TRANSIENT) - END IF - IF (es == CD_HCSTAT_OK .AND. res <= tol) THEN - ok = .TRUE. - EXIT - END IF + ! A solve that stalls on a residual floor above the tight tolerance is repeated at the + ! looser one from the same incoming state, as the line's own static solve is + DO k_tol = 1, n_tol + tol_k = MERGE(tol, tol_loose, k_tol == 1) + CALL static_solve(mode, tol_k, scale, max_it, it, es, em) + IF (es == CD_HCSTAT_OK .AND. res <= tol_k) THEN + ok = .TRUE. + EXIT + END IF + IF (es == CD_HCSTAT_BADINPUT .OR. INDEX(em, 'Newton did not converge') == 0) EXIT + END DO + IF (ok) EXIT IF (mode == NEWTON) THEN ! numbers into a local buffer: an internal WRITE into the caller's ErrMsg would abort ! on a short buffer @@ -5729,7 +5912,42 @@ SUBROUTINE solve_with(scale, ok, dq_max) IF (.NOT. ok) RETURN IF (PRESENT(dq_max)) dq_max = MAXVAL(ABS(q_out - q)) q = q_out + ! the residual of the state the polish returns, when it lies above the tight tolerance + IF (PRESENT(floor_res)) floor_res = MERGE(res, CD_ZERO, res > tol) END SUBROUTINE solve_with + + SUBROUTINE static_solve(mode_s, tol_s, scale, max_it, it, es, em) + !! One warm-started static solve of solve_with at load fraction scale with the update rule + !! mode_s (pseudo_transient 2, merit 3) and the tolerance tol_s, from q into q_out, curv, res. + INTEGER, INTENT(IN) :: mode_s, max_it(3) + REAL(wp), INTENT(IN) :: tol_s, scale + INTEGER, INTENT(OUT) :: it, es + CHARACTER(*), INTENT(OUT) :: em + IF (contact_enabled) THEN + CALL CD_HermiteCable_Static_Solve(l0, ea, ei, wl, q, fixed_dofs, contact_z, CD_ZERO, 1, max_it(mode_s), & + tol_s, 0.7_wp, q_out, curv, res, it, es, em, & + f_nodal=scale*(f_att + f_drag), n_buoy_steps=1, contact_kn=knnode, & + bathymetry=bathymetry, contact_frame_cs=frame_cs, & + axial_quadrature_order=opts%axial_quadrature_order, & + bending_quadrature_order=opts%bending_quadrature_order, & + endconn_stiffness=endconn_k, endconn_direction=endconn_d0, & + endconn_mode=endconn_mode, waterline_z=CD_ZERO, dry_buoyancy=dry, & + water_weight=opts%rhoW*opts%g, current=cur_l, & + backtracking=mode_s == MERIT, merit_line_search=mode_s == MERIT, & + pseudo_transient=mode_s == PSEUDO_TRANSIENT) + ELSE + CALL CD_HermiteCable_Static_Solve(l0, ea, ei, wl, q, fixed_dofs, contact_z, CD_ZERO, 1, max_it(mode_s), & + tol_s, 0.7_wp, q_out, curv, res, it, es, em, & + f_nodal=scale*(f_att + f_drag), n_buoy_steps=1, & + axial_quadrature_order=opts%axial_quadrature_order, & + bending_quadrature_order=opts%bending_quadrature_order, & + endconn_stiffness=endconn_k, endconn_direction=endconn_d0, & + endconn_mode=endconn_mode, waterline_z=CD_ZERO, dry_buoyancy=dry, & + water_weight=opts%rhoW*opts%g, current=cur_l, & + backtracking=mode_s == MERIT, merit_line_search=mode_s == MERIT, & + pseudo_transient=mode_s == PSEUDO_TRANSIENT) + END IF + END SUBROUTINE static_solve END SUBROUTINE attachment_static_polish SUBROUTINE attachment_static_drag(q, node, att, opts, frame_cs, f, ErrStat, ErrMsg) @@ -6868,9 +7086,119 @@ RECURSIVE SUBROUTINE graded_restart() END SUBROUTINE graded_restart RECURSIVE SUBROUTINE refined_restart() - !! Repeat the route on a uniformly refined mesh (power of two, capped) when the - !! deck mesh is longer than half the bending length (EI/|w|)^(1/3) somewhere. The + !! Repeat the route on a refined mesh when the deck mesh is longer than half the bending + !! length (EI/|w|)^(1/3) somewhere: uniformly refined (uniform_restart), then, when that + !! fails, with each element split only as far as the rule asks of it (rule_restart). The !! refined equilibrium is returned in the *_am outputs like an adaptive refinement. + CALL uniform_restart() + IF (ErrStat /= CD_HCSTAT_OK .AND. .NOT. inadmissible) CALL rule_restart() + END SUBROUTINE refined_restart + + RECURSIVE SUBROUTINE rule_restart() + !! Repeat the route on the deck mesh with every element split into the power of two + !! (capped) that brings it to half its bending length (EI/|w|)^(1/3), the elements that + !! meet the rule kept. A uniform refinement by the largest factor keeps the deck's grading + !! and refines the short elements beside the long ones as well: on a lazy wave meshed + !! 4 m / 0.9 m / 10 m (the buoyant section refined, the sag bend and the touchdown + !! coarse) the long elements' axial force oscillated into compression beside the short + !! ones, the 8x refined mesh stalled at the start of its stiffness continuation, and the + !! deck failed in an oblique current although the same layout solves on 2 m elements. + !! Not run when the rule asks the same factor of every element (the uniform refinement + !! was that mesh) or more than REFINED_MAX_ELEMENTS elements. + INTEGER, PARAMETER :: REFINED_MAX_ELEMENTS = 4096 + REAL(wp), ALLOCATABLE :: l0_g(:), ea_g(:), ei_g(:), w_g(:), diam_g(:), dry_g(:) + INTEGER, ALLOCATABLE :: fixed_g(:), parent_g(:), node_of(:), split(:) + LOGICAL, ALLOCATABLE :: fixed_map(:, :) + LOGICAL :: planar, inadm_g, walked_sub + INTEGER :: k, j, n_g, nf, es_g, slot, piece + REAL(wp) :: need + CHARACTER(1024) :: em_g + IF (PRESENT(refined_pass) .OR. fold) RETURN + ALLOCATE (split(ne)) + split = 1 + DO k = 1, ne + IF (.NOT. (ei(k) > CD_ZERO .AND. ABS(w(k)) > CD_ZERO)) CYCLE + need = l0(k)/(0.5_wp*(ei(k)/ABS(w(k)))**(CD_ONE/3.0_wp)) + DO WHILE (REAL(split(k), wp) < need .AND. split(k) < CD_HC_REFINE_CAP) + split(k) = 2*split(k) + END DO + END DO + IF (ALL(split == 1)) RETURN + IF (ALL(split == MAXVAL(split))) RETURN + n_g = SUM(split) + IF (n_g > REFINED_MAX_ELEMENTS) RETURN + ALLOCATE (l0_g(n_g), parent_g(n_g), node_of(nnode)) + j = 0 + node_of(1) = 1 + DO k = 1, ne + DO piece = 1, split(k) + j = j + 1 + l0_g(j) = l0(k)/REAL(split(k), wp) + parent_g(j) = k + END DO + node_of(k + 1) = j + 1 + END DO + ALLOCATE (ea_g(n_g), ei_g(n_g), w_g(n_g), diam_g(n_g), dry_g(n_g)) + ea_g = ea(parent_g); ei_g = ei(parent_g); w_g = w(parent_g) + diam_g = diam(parent_g); dry_g = dry_b(parent_g) + ! Held DOFs: the deck nodes keep theirs; inserted nodes take the out-of-plane reduction + ! (y, m_y) when the deck holds it on every node (as graded_restart). + ALLOCATE (fixed_map(6, nnode)) + fixed_map = .FALSE. + DO k = 1, SIZE(fixed_dofs) + fixed_map(MOD(fixed_dofs(k) - 1, 6) + 1, (fixed_dofs(k) - 1)/6 + 1) = .TRUE. + END DO + planar = ALL(fixed_map(2, :)) + ALLOCATE (fixed_g(6*(n_g + 1))) + nf = 0 + k = 1 + DO j = 1, n_g + 1 + IF (k <= nnode) THEN + IF (node_of(k) == j) THEN + DO slot = 1, 6 + IF (fixed_map(slot, k)) THEN + nf = nf + 1; fixed_g(nf) = 6*(j - 1) + slot + END IF + END DO + k = k + 1 + CYCLE + END IF + END IF + IF (planar) THEN + nf = nf + 1; fixed_g(nf) = 6*(j - 1) + 2 + nf = nf + 1; fixed_g(nf) = 6*(j - 1) + 5 + END IF + END DO + IF (PRESENT(bathymetry)) THEN + CALL hermite_static_primary(anchor, fairlead, l0_g, ea_g, ei_g, w_g, diam_g, dry_g, fixed_g(1:nf), & + contact_enabled, contact_z, frame_cs, endconn_k, endconn_d0, endconn_mode, & + opts, static_tol, l0_am, ea_am, ei_am, w_am, q_static, curv, fixed_am, & + applied_scale, diag, res, iters, es_g, em_g, inadm_g, tolerance_note, & + kink_refined, bathymetry=bathymetry, refined_pass=.TRUE., cur_obj=cur_obj, & + walked=walked_sub, fold_walk=fold) + ELSE + CALL hermite_static_primary(anchor, fairlead, l0_g, ea_g, ei_g, w_g, diam_g, dry_g, fixed_g(1:nf), & + contact_enabled, contact_z, frame_cs, endconn_k, endconn_d0, endconn_mode, & + opts, static_tol, l0_am, ea_am, ei_am, w_am, q_static, curv, fixed_am, & + applied_scale, diag, res, iters, es_g, em_g, inadm_g, tolerance_note, & + kink_refined, refined_pass=.TRUE., cur_obj=cur_obj, walked=walked_sub, & + fold_walk=fold) + END IF + IF (es_g == CD_HCSTAT_OK) THEN + ErrStat = CD_HCSTAT_OK + ErrMsg = '' + kink_refined = .TRUE. + inadmissible = .FALSE. + IF (PRESENT(walked)) walked = walked_sub + ELSE + ErrMsg = TRIM(ErrMsg)//'; on the mesh refined element by element to the bending length: '//TRIM(em_g) + IF (inadm_g) inadmissible = .TRUE. + END IF + END SUBROUTINE rule_restart + + RECURSIVE SUBROUTINE uniform_restart() + !! The route on a uniformly refined mesh (power of two, capped) when the deck mesh is + !! longer than half the bending length somewhere (refined_restart). REAL(wp), ALLOCATABLE :: l0_r(:), q_r(:), q_ref_r(:), ea_r(:), ei_r(:), w_r(:), diam_r(:), dry_r(:) INTEGER, ALLOCATABLE :: fixed_r(:) INTEGER :: scale, scale_need, k, es_r, parent @@ -6936,7 +7264,7 @@ RECURSIVE SUBROUTINE refined_restart() IF (INDEX(em_r, 'iteration budget') == 0) RETURN scale = scale/2 END DO - END SUBROUTINE refined_restart + END SUBROUTINE uniform_restart SUBROUTINE polish_with_floor() !! Polish at the tight tolerance; accept the coupled static tolerance when the @@ -8571,6 +8899,8 @@ SUBROUTINE CD_Init_Deck_Aggregate(deck_path, dt, agg, ErrStat, ErrMsg, env_gravi IF (static_only) CYCLE CALL axial_period_note(agg%init_lines(il)%line_id, dt, sections, types, strain_note) IF (LEN_TRIM(strain_note) > 0) CALL append_note_line(agg%init_lines(il)%note, strain_note) + CALL axial_damping_note(agg%init_lines(il), sections, types, opts, strain_note) + IF (LEN_TRIM(strain_note) > 0) CALL append_note_line(agg%init_lines(il)%note, strain_note) END DO IF (own_current) CALL warn_coarse_sections(lines, sections) END BLOCK @@ -9629,11 +9959,12 @@ SUBROUTINE run_deck_driver(deck_path, out_root, converged, ErrStat, ErrMsg) RETURN END IF IF (has_finite) THEN - ! The standalone finite-EI march owns one homogeneous family of bending - ! lines. Mixed EI=0/EI>0 composition belongs to the aggregate route; keep - ! this guard ahead of the Hermite dispatch so an EI=0 line can never be - ! coerced through the all-lines Hermite builder. - IF (.NOT. all_lines_have_finite_ei(types, lines, sections)) THEN + ! The standalone finite-EI march owns the finite-EI lines: a line with any finite-EI + ! section, built as one cable whose EI = 0 sections carry no bending, as on the coupled + ! aggregate. A deck of separate EI=0 and finite-EI lines belongs to the aggregate route + ! (the standalone executable sends it there); keep this guard ahead of the Hermite + ! dispatch so a line without a finite-EI section is never coerced through the builder. + IF (.NOT. ALL([(line_is_finite_ei(lines(li), types, sections), li=1, SIZE(lines))])) THEN IF (opts%has_bathymetry_file) CALL CD_End_Bathymetry(bathymetry) CALL fail(ErrStat, ErrMsg, 'mixed EI=0 and finite-EI dynamic decks are not supported by this entry point') RETURN @@ -10008,9 +10339,9 @@ RECURSIVE SUBROUTINE init_one_model(ln, sections, types, points, opts, model, Er REAL(wp), ALLOCATABLE :: ve_ead(:), ve_bas(:), ve_bad(:), ve_ambl(:), ve_vbet(:) REAL(wp), ALLOCATABLE :: viv_cl(:), viv_cf(:), viv_df(:) LOGICAL, ALLOCATABLE :: syr_el(:) - REAL(wp) :: anchor(3), fairlead(3) + REAL(wp) :: anchor(3), fairlead(3), mode1_omega REAL(wp), PARAMETER :: factors(4) = [0.25_wp, 0.5_wp, 0.75_wp, CD_ONE] - INTEGER :: j, i, e, es + INTEGER :: j, i, e, er, es LOGICAL :: want_wave_cfg CHARACTER(1024) :: em ! static seabed friction of this line: lay azimuth override [rad] (unallocated: the @@ -10054,12 +10385,31 @@ RECURSIVE SUBROUTINE init_one_model(ln, sections, types, points, opts, model, Er ve_bad = CD_ZERO ve_ambl = CD_ZERO ve_vbet = CD_ZERO + ! OPTION axialDampingRatio mode1: a negative BA is the damping ratio of the line's first + ! axial mode, set by the deck sections whatever the mesh + mode1_omega = CD_ZERO + IF (opts%axial_damping_mode1) THEN + IF (ANY([(types(line_section_type(sections, ln%id, i))%ba < CD_ZERO, i=1, SIZE(secs))])) THEN + CALL line_mode1_omega(ln%id, sections, types, mode1_omega, es, em) + IF (es /= CD_DECKDRV_OK) THEN + CALL fail(ErrStat, ErrMsg, TRIM(em)); RETURN + END IF + END IF + END IF e = 0 DO i = 1, SIZE(secs) DO j = 1, secs(i)%n_segments e = e + 1 - CALL CD_Resolve_Legacy_BA(types(line_section_type(sections, ln%id, i))%ba, l0(e), ea(e), mpl(e), & - ba(e), es, em) + ! e counts the elements from End A, as the per-element arrays filled here (reversed + ! below); the mesh l0, ea, mpl runs from the anchor, End B: element e is er there + er = SIZE(l0) + 1 - e + IF (opts%axial_damping_mode1) THEN + CALL CD_Resolve_Mode1_BA(types(line_section_type(sections, ln%id, i))%ba, ea(er), mode1_omega, ba(e), & + es, em) + ELSE + CALL CD_Resolve_Legacy_BA(types(line_section_type(sections, ln%id, i))%ba, l0(er), ea(er), mpl(er), & + ba(e), es, em) + END IF IF (es /= CD_DAMP_OK) THEN CALL fail(ErrStat, ErrMsg, 'BA resolution for model init: '//TRIM(em)); RETURN END IF @@ -10379,17 +10729,14 @@ RECURSIVE SUBROUTINE init_one_model(ln, sections, types, points, opts, model, Er END IF tw = opts%viv_rms_window IF (.NOT. (tw > CD_ZERO) .AND. opts%has_dtm) tw = REAL(CD_VIV_NM, wp)*opts%dtM - IF (ln%ends_swapped) THEN - ! MoorDyn counts the phase seed from the deck's End A, which the reader turned around - BLOCK - REAL(wp) :: seed(model%n_dof/3) - CALL CD_Deck_VIV_Phase_Seed(model%l0, .TRUE., seed) - CALL CD_Set_Model_VIV(model, opts%rhoW, viv_cl, hydro_diam, viv_cf, viv_df, tw, es, em, & - phase_seed=seed) - END BLOCK - ELSE - CALL CD_Set_Model_VIV(model, opts%rhoW, viv_cl, hydro_diam, viv_cf, viv_df, tw, es, em) - END IF + ! MoorDyn counts the phase seed from the deck's End A, with its node tangent towards the + ! deck's End B: CD_Deck_VIV_Phase_Seed takes it to the model's nodes and tangent + BLOCK + REAL(wp) :: seed(model%n_dof/3) + CALL CD_Deck_VIV_Phase_Seed(model%l0, ln%ends_swapped, seed, zero=opts%viv_phase_zero) + CALL CD_Set_Model_VIV(model, opts%rhoW, viv_cl, hydro_diam, viv_cf, viv_df, tw, es, em, & + phase_seed=seed, tangent_reversed=.NOT. ln%ends_swapped) + END BLOCK IF (es == CD_MODEL_OK) CALL CD_Recompute_Model_Acceleration(model, es, em) IF (es /= CD_MODEL_OK) THEN ErrStat = CD_DECKDRV_BADINPUT @@ -10478,15 +10825,17 @@ RECURSIVE SUBROUTINE init_one_syrope_model(types, ln, sections, points, l0, opts !! strain whose t = 0 kernel force equals its static tension, so the dynamic state starts in !! the static equilibrium. Tmean0 is not a state input (the fixed-end geometry and Tmax0 set !! the mean tension); a disagreement beyond 1 % is reported on the console. - !! The static solve uses secant EAs, iterated to the rest curve. A single-section line, taut - !! and of nearly uniform tension, takes one secant from the curve at its mean strain (the - !! strain the taut geometry fixes). On a composite line the tension varies along a sagging - !! Syrope section, so each Syrope element takes its own secant, from the curve's strain at the - !! element's tension: every element then starts on its rest curve, its slow strain at rest - !! (one secant per section would leave the elements away from the mean off the curve, and - !! their slow strains would settle the line after the start). The tension, which the chains' - !! weight and the geometry largely fix, keeps this update a contraction where a strain update - !! can overshoot. + !! The static solve uses secant EAs, iterated to the rest curve. The tension varies along a + !! Syrope section (a sagging section of a composite line, or the weight of a single long or + !! inclined taut rope), so each Syrope element takes its own secant, from the curve's strain + !! at the element's tension: every element then starts on its rest curve, its slow strain at + !! rest (one secant per section, from the curve at the mean strain, left the elements away + !! from the mean off the curve, and their slow strains settled the line after the start: a + !! 991 m single-section rope at rest moved its fairlead tension by 3.4e-4 in 1 s). A + !! single-section line starts the iteration from the secant at the strain its taut geometry + !! fixes, a composite line from the curve's alpha. The tension, which the chains' weight and + !! the geometry largely fix, keeps this update a contraction where a strain update can + !! overshoot. TYPE(DeckLineType), INTENT(IN) :: types(:) TYPE(DeckLine), INTENT(IN) :: ln TYPE(DeckSection), INTENT(IN) :: sections(:) @@ -10505,9 +10854,11 @@ RECURSIVE SUBROUTINE init_one_syrope_model(types, ln, sections, points, l0, opts TYPE(CD_SyropeType), ALLOCATABLE :: tds(:), stype(:) INTEGER, ALLOCATABLE :: sec_type(:), sec_nseg(:), el_sec(:) LOGICAL, ALLOCATABLE :: sec_syr(:), sis(:) - REAL(wp), ALLOCATABLE :: sec_el(:), cand_el(:), sslow(:), stmax(:), t_static(:), eps_prev(:), t_prev(:) - REAL(wp) :: anchor(3), fairlead(3), eps0, t_ref, total_l0, t_hist, eps_bar, t_mean_static - REAL(wp) :: eps_e, change, secant, cand, eps_now, d_eps, d_t, eps_r, t_r, acc + REAL(wp), ALLOCATABLE :: sec_el(:), cand_el(:), sslow(:), stmax(:), t_static(:), eps_prev(:), t_prev(:), & + step_prev(:) + REAL(wp) :: anchor(3), fairlead(3), eps0, t_ref, total_l0, t_hist, t_mean_static + REAL(wp) :: eps_e, change, secant, eps_now, d_eps, d_t, eps_r, t_r, acc + LOGICAL :: have_acc INTEGER :: ne, e, es, n_owc, iter, nsec, j, k, isec, st LOGICAL :: composite, converged CHARACTER(1024) :: em @@ -10580,10 +10931,11 @@ RECURSIVE SUBROUTINE init_one_syrope_model(types, ln, sections, points, l0, opts t_hist = CD_ZERO IF (ln%has_syrope_ic) t_hist = ln%syrope_tmax0 ALLOCATE (sec_el(ne), cand_el(ne), stype(ne), sis(ne), sslow(ne), stmax(ne), t_static(ne), eps_prev(ne), & - t_prev(ne)) + t_prev(ne), step_prev(ne)) sis = .FALSE. sslow = CD_ZERO stmax = CD_ZERO + step_prev = CD_ZERO sec_el = CD_ZERO DO e = 1, ne IF (.NOT. sec_syr(el_sec(e))) CYCLE @@ -10633,7 +10985,7 @@ RECURSIVE SUBROUTINE init_one_syrope_model(types, ln, sections, points, l0, opts ! current's deflection). The solve just made belongs to the current secants, which are kept ! once the candidates agree with them. converged = .FALSE. - DO iter = 1, MERGE(MAX_ITER_COMPOSITE, 6, composite) + DO iter = 1, MAX_ITER_COMPOSITE CALL init_one_model(ln, sections, types, points, opts, model, ErrStat, ErrMsg, bathymetry=bathymetry, & syrope_secant=sec_el) IF (ErrStat /= CD_DECKDRV_OK) EXIT @@ -10644,7 +10996,7 @@ RECURSIVE SUBROUTINE init_one_syrope_model(types, ln, sections, points, l0, opts ErrMsg = em END IF IF (ErrStat /= CD_MODEL_OK) EXIT - IF (composite) THEN + BLOCK ! each Syrope element: the curve's strain at its tension change = CD_ZERO cand_el = sec_el @@ -10685,19 +11037,40 @@ RECURSIVE SUBROUTINE init_one_syrope_model(types, ln, sections, points, l0, opts ! equilibrium. It is taken only beyond the tension update in the same direction and ! at most 100 times as far, else the tension update stands. eps_now = t_static(e)/sec_el(e) + have_acc = .FALSE. IF (iter > 1) THEN d_eps = eps_now - eps_prev(e) d_t = t_static(e) - t_prev(e) - IF (d_eps*d_t < CD_ZERO) THEN + ! (a response of fixed strain, d_eps = 0, as of a taut rope whose geometry sets its + ! strain, crosses the curve at that strain) + IF (d_eps*d_t < CD_ZERO .OR. (.NOT. (ABS(d_eps) > CD_ZERO) .AND. ABS(d_t) > CD_ZERO)) THEN CALL response_root(isec, eps_now, t_static(e), d_eps, d_t, eps_r, t_r) IF (eps_r > CD_ZERO .AND. t_r > CD_ZERO) THEN acc = t_r/eps_r - IF ((acc - sec_el(e))*(cand_el(e) - sec_el(e)) > CD_ZERO .AND. & - ABS(acc - sec_el(e)) >= ABS(cand_el(e) - sec_el(e)) .AND. & - ABS(acc - sec_el(e)) <= 100.0_wp*ABS(cand_el(e) - sec_el(e))) cand_el(e) = acc + have_acc = .TRUE. END IF END IF + ! A tension update that reverses the previous one and is not below half of it + ! overshot the crossing without contracting: on a curve concave enough (the secant + ! far above the tangent) it would cycle. The secant step then stands where it lies + ! between the secant and the update, else half the update. Any other update (in the + ! same direction as the last, as on a convex curve, or an alternating one that + ! contracts) keeps the rule below. + IF ((cand_el(e) - sec_el(e))*step_prev(e) < CD_ZERO .AND. & + ABS(cand_el(e) - sec_el(e)) >= 0.5_wp*ABS(step_prev(e))) THEN + IF (have_acc .AND. (acc - sec_el(e))*(cand_el(e) - sec_el(e)) > CD_ZERO .AND. & + ABS(acc - sec_el(e)) < ABS(cand_el(e) - sec_el(e))) THEN + cand_el(e) = acc + ELSE + cand_el(e) = sec_el(e) + 0.5_wp*(cand_el(e) - sec_el(e)) + END IF + ELSE IF (have_acc .AND. d_eps*d_t < CD_ZERO) THEN + IF ((acc - sec_el(e))*(cand_el(e) - sec_el(e)) > CD_ZERO .AND. & + ABS(acc - sec_el(e)) >= ABS(cand_el(e) - sec_el(e)) .AND. & + ABS(acc - sec_el(e)) <= 100.0_wp*ABS(cand_el(e) - sec_el(e))) cand_el(e) = acc + END IF END IF + step_prev(e) = cand_el(e) - sec_el(e) eps_prev(e) = eps_now t_prev(e) = t_static(e) END DO @@ -10706,15 +11079,7 @@ RECURSIVE SUBROUTINE init_one_syrope_model(types, ln, sections, points, l0, opts EXIT END IF sec_el = cand_el - ELSE - eps_bar = SUM(l0*t_static)/(secant*SUM(l0)) - CALL rest_tension(1, eps_bar, t_ref, es, em) - IF (es /= CD_SYROPE_OK .OR. .NOT. (t_ref > CD_ZERO .AND. eps_bar > CD_ZERO)) EXIT - cand = t_ref/eps_bar - IF (ABS(cand - secant) <= 1.0e-10_wp*secant) EXIT - secant = cand - sec_el = secant - END IF + END BLOCK END DO IF (ErrStat /= CD_MODEL_OK) THEN CALL release_syrope(.TRUE.) @@ -10722,8 +11087,8 @@ RECURSIVE SUBROUTINE init_one_syrope_model(types, ln, sections, points, l0, opts IF (ErrStat /= CD_DECKDRV_BADINPUT) ErrStat = CD_DECKDRV_SOLVEFAIL RETURN END IF - IF (composite) THEN - ! a composite line starts only from converged secants, every Syrope element on its + BLOCK + ! a Syrope line starts only from converged secants, every Syrope element on its ! curve's table IF (.NOT. converged) THEN CALL release_syrope(.TRUE.) @@ -10747,7 +11112,7 @@ RECURSIVE SUBROUTINE init_one_syrope_model(types, ln, sections, points, l0, opts RETURN END IF END DO - END IF + END BLOCK ! Per Syrope element: the running maximum is the history's (raised to the element's static ! tension where that exceeds it, i.e. the element sits on the OWC; without SYROPE IC ! every element is a virgin rope at its own static tension), and the slow strain @@ -11264,7 +11629,9 @@ SUBROUTINE CD_Stiffener_Overlay(stf, l0, diam, ei, mpl) IF (.NOT. (covered > CD_ZERO)) CYCLE IF (PRESENT(ei)) THEN IF (ei_line > CD_ZERO) THEN - compliance = compliance + (l0(e) - covered)/ei_line + ! the bare part: rows meeting inside the element can sum past its length by round-off, + ! which a soft cable's EI would turn into a negative compliance + compliance = compliance + MAX(CD_ZERO, l0(e) - covered)/ei_line ei(e) = l0(e)/compliance ELSE IF (covered >= l0(e)*(CD_ONE - 1.0e-12_wp)) THEN ! an EI = 0 element bends only where the sleeve covers all of it; a bare part has an @@ -12095,7 +12462,10 @@ SUBROUTINE solve_point_equilibrium(types, points, lines, sections, opts, ErrStat DO i = 1, SIZE(points) IF (point_moves(i)) np = np + 1 END DO - IF (np == 0) RETURN + IF (np == 0) THEN + CALL point3_balance_note() + RETURN + END IF ALLOCATE (pidx(np)) np = 0 DO i = 1, SIZE(points) @@ -12123,9 +12493,74 @@ SUBROUTINE solve_point_equilibrium(types, points, lines, sections, opts, ErrStat END DO CALL solve_body_equilibrium(types, no_bodies, no_rod_types, no_rods, points, lines, sections, opts, ErrStat, & ErrMsg, bathymetry, points_only=.TRUE.) + IF (ErrStat == CD_DECKDRV_OK) CALL point3_balance_note() CONTAINS + SUBROUTINE point3_balance_note() + !! A Point3 buoy is not placed by the static solve: it starts at its deck position. Under + !! bodyIC static, where every other free object starts balanced, note the force its line, + !! weight, buoyancy, current drag and seabed contact leave on it there, and how far its + !! static equilibrium (the balance of the buoy as a Free point, with the Free/Connect + !! points held where the static solve put them) lies from it. + TYPE(DeckPoint), ALLOCATABLE :: pc(:) + REAL(wp), ALLOCATABLE :: f0(:) + REAL(wp) :: w_net + INTEGER :: ip, es_n + LOGICAL :: any3, skp + CHARACTER(1024) :: em_n + CHARACTER(32) :: fbuf, dbuf + IF (.NOT. opts%body_ic_static) RETURN + any3 = .FALSE. + DO ip = 1, SIZE(points) + IF (points(ip)%point3 .AND. point_has_line(ip)) any3 = .TRUE. + END DO + IF (.NOT. any3) RETURN + pc = points + DO ip = 1, SIZE(pc) + IF (pc(ip)%point3 .AND. point_has_line(ip)) THEN + pc(ip)%ptype = 'free' + ELSE IF (TRIM(pc(ip)%ptype) == 'free' .OR. TRIM(pc(ip)%ptype) == 'connect') THEN + pc(ip)%ptype = 'fixed' + END IF + END DO + ALLOCATE (f0(SIZE(pc))) + f0 = CD_ZERO + skp = .FALSE. + CALL solve_body_equilibrium_core(types, no_bodies, no_rod_types, no_rods, pc, lines, sections, opts, es_n, & + em_n, bathymetry, points_only=.TRUE., quiet=.TRUE., skipped=skp, & + point_force_start=f0) + IF (skp) RETURN + DO ip = 1, SIZE(points) + IF (.NOT. (points(ip)%point3 .AND. point_has_line(ip))) CYCLE + w_net = ABS(opts%rhoW*points(ip)%vol - points(ip)%mass)*opts%g + IF (.NOT. (f0(ip) > 1.0e-4_wp*w_net + CD_ONE)) CYCLE + WRITE (fbuf, '(ES10.3)') f0(ip) + IF (es_n == CD_DECKDRV_OK) THEN + WRITE (dbuf, '(ES10.3)') NORM2(pc(ip)%pos - points(ip)%pos) + CALL print_note(output_unit, ' ', 'BODY '//TRIM(int_to_str(points(ip)%body_id))//' (Point3) starts '// & + 'at its deck position, which the static solve does not change, with an unbalanced '// & + 'force of '//TRIM(ADJUSTL(fbuf))//' N there; its static equilibrium lies '// & + TRIM(ADJUSTL(dbuf))//' m away. Give the deck position of its equilibrium, or set '// & + 'OPTION bodyIC deck to start it from its deck position on purpose') + ELSE + CALL print_note(output_unit, ' ', 'BODY '//TRIM(int_to_str(points(ip)%body_id))//' (Point3) starts '// & + 'at its deck position, which the static solve does not change, with an unbalanced '// & + 'force of '//TRIM(ADJUSTL(fbuf))//' N there. Give the deck position of its '// & + 'equilibrium, or set OPTION bodyIC deck to start it from its deck position on purpose') + END IF + END DO + END SUBROUTINE point3_balance_note + + LOGICAL FUNCTION point_has_line(ip) RESULT(has) + INTEGER, INTENT(IN) :: ip + INTEGER :: jl + has = .FALSE. + DO jl = 1, SIZE(lines) + IF (lines(jl)%nodeA == points(ip)%id .OR. lines(jl)%nodeB == points(ip)%id) has = .TRUE. + END DO + END FUNCTION point_has_line + LOGICAL FUNCTION point_moves(ip) RESULT(mv) INTEGER, INTENT(IN) :: ip INTEGER :: jl @@ -12371,6 +12806,117 @@ SUBROUTINE axial_period_note(line_id, dt, sections, types, note) 'can be wrong. A dtM of at most '//TRIM(ADJUSTL(b4))//' s resolves them' END SUBROUTINE axial_period_note + SUBROUTINE line_mode1_omega(line_id, sections, types, omega1, ErrStat, ErrMsg) + !! The first axial frequency [rad/s] that OPTION axialDampingRatio mode1 sets a negative BA + !! of the line by: the first axial mode of the line fixed at both ends, from its deck + !! sections (CD_Axial_Mode1_Omega: unstretched lengths, EA, dry mass per length, on a fixed + !! internal mesh), so it does not depend on the line's mesh. A section whose axial stiffness is not one EA + !! (viscoelastic ElasticMod 2 or 3, Syrope) fails by name: its first axial mode is not set + !! by one BA. + INTEGER, INTENT(IN) :: line_id + TYPE(DeckSection), INTENT(IN) :: sections(:) + TYPE(DeckLineType), INTENT(IN) :: types(:) + REAL(wp), INTENT(OUT) :: omega1 + INTEGER, INTENT(OUT) :: ErrStat + CHARACTER(*), INTENT(OUT) :: ErrMsg + REAL(wp), ALLOCATABLE :: len_s(:), ea_s(:), m_s(:) + INTEGER :: j, k, es + CHARACTER(1024) :: em + + ErrStat = CD_DECKDRV_OK + ErrMsg = '' + omega1 = CD_ZERO + ALLOCATE (len_s(0), ea_s(0), m_s(0)) + DO j = 1, SIZE(sections) + IF (sections(j)%line_id /= line_id) CYCLE + k = find_type(types, sections(j)%ltype_name) + IF (k < 1) THEN + CALL fail(ErrStat, ErrMsg, 'internal: LINE '//TRIM(int_to_str(line_id))//' has a section of an unknown type') + RETURN + END IF + IF (types(k)%is_syrope .OR. types(k)%elastic_mod > 1) THEN + CALL fail(ErrStat, ErrMsg, 'OPTION axialDampingRatio mode1: LINE '//TRIM(int_to_str(line_id))// & + ' has a negative BA and the section type '//TRIM(types(k)%name)//', whose axial stiffness is '// & + 'viscoelastic or a Syrope working curve: the damping ratio of its first axial mode is not set by '// & + 'one BA. Give BA in N s or use axialDampingRatio segment') + RETURN + END IF + len_s = [len_s, sections(j)%length] + ea_s = [ea_s, types(k)%ea] + m_s = [m_s, types(k)%mass] + END DO + CALL CD_Axial_Mode1_Omega(len_s, ea_s, m_s, omega1, es, em) + IF (es /= CD_DAMP_OK) THEN + CALL fail(ErrStat, ErrMsg, 'OPTION axialDampingRatio mode1: LINE '//TRIM(int_to_str(line_id))//': '//TRIM(em)) + RETURN + END IF + END SUBROUTINE line_mode1_omega + + SUBROUTINE axial_damping_note(summary, sections, types, opts, note) + !! A line whose negative BA is the damping ratio of each segment (MoorDyn's convention, the + !! default of OPTION axialDampingRatio): the damping ratio this gives the line's first axial + !! mode, from the line's final mesh and resolved BA (summary%axial_zeta1, + !! CD_Axial_Mode1_Damping: the line fixed at both ends), with the number of elements, since + !! it falls as the mesh is refined (zeta pi/(2N) on a uniform line). A line with a + !! viscoelastic or Syrope section is noted without the ratio. Only a note: nothing is changed. + TYPE(CD_LineInitSummary), INTENT(IN) :: summary + TYPE(DeckSection), INTENT(IN) :: sections(:) + TYPE(DeckLineType), INTENT(IN) :: types(:) + TYPE(DeckOptions), INTENT(IN) :: opts + CHARACTER(*), INTENT(OUT) :: note + INTEGER :: j, k + LOGICAL :: negative, simple + CHARACTER(32) :: b1 + + note = '' + IF (opts%axial_damping_mode1) RETURN + negative = .FALSE. + simple = .TRUE. + DO j = 1, SIZE(sections) + IF (sections(j)%line_id /= summary%line_id) CYCLE + k = find_type(types, sections(j)%ltype_name) + IF (k < 1) RETURN + IF (types(k)%ba < CD_ZERO) negative = .TRUE. + IF (types(k)%is_syrope .OR. types(k)%elastic_mod > 1) simple = .FALSE. + END DO + IF (.NOT. negative) RETURN + note = 'LINE '//TRIM(int_to_str(summary%line_id))//': its negative BA is a damping ratio per segment, BA = '// & + 'zeta L0 sqrt(EA m) on each element' + IF (simple .AND. summary%axial_zeta1 >= CD_ZERO .AND. summary%axial_elements > 0) THEN + IF (100.0_wp*summary%axial_zeta1 >= 0.01_wp) THEN + WRITE (b1, '(F12.3)') 100.0_wp*summary%axial_zeta1 + ELSE + WRITE (b1, '(ES10.3)') 100.0_wp*summary%axial_zeta1 + END IF + note = TRIM(note)//', which damps the first axial mode of the line (both ends held) at '// & + TRIM(ADJUSTL(b1))//' % of critical on its '//TRIM(int_to_str(summary%axial_elements))// & + ' elements (zeta pi/(2N) on a uniform line of N elements): the axial damping depends on the mesh' + ELSE + note = TRIM(note)//': the axial damping of the line depends on the mesh' + END IF + note = TRIM(note)//'. With OPTION mode1 axialDampingRatio a negative BA is the damping ratio of the '// & + 'first axial mode, the same on any mesh' + END SUBROUTINE axial_damping_note + + SUBROUTINE summary_axial_damping(summary, l0, ea, mass_per_length, ba) + !! The damping ratio of the first axial mode of a built line (CD_Axial_Mode1_Damping), for its + !! initialisation note (axial_damping_note); left unset (-1) when it cannot be worked out. + TYPE(CD_LineInitSummary), INTENT(INOUT) :: summary + REAL(wp), INTENT(IN) :: l0(:), ea(:), mass_per_length(:), ba(:) + REAL(wp) :: zeta1, omega1 + INTEGER :: es + CHARACTER(256) :: em + + summary%axial_zeta1 = -CD_ONE + summary%axial_elements = 0 + IF (SIZE(l0) < 1 .OR. SIZE(ea) /= SIZE(l0) .OR. SIZE(mass_per_length) /= SIZE(l0) .OR. & + SIZE(ba) /= SIZE(l0)) RETURN + CALL CD_Axial_Mode1_Damping(l0, ea, mass_per_length, ba, zeta1, omega1, es, em) + IF (es /= CD_DAMP_OK) RETURN + summary%axial_zeta1 = zeta1 + summary%axial_elements = SIZE(l0) + END SUBROUTINE summary_axial_damping + SUBROUTINE warn_line_below_anchor(lines, points, sections, q_all, q_off) !! Standard-output WARNING for a deck with no seabed (no WtrDpth or bathymetryFile) on !! which a line hangs below its lowest Fixed end by more than max(1 m, 1 % of its @@ -16548,6 +17094,10 @@ SUBROUTINE append_line_stiffener(row, lines, ErrStat, ErrMsg) IF (.NOT. (vals(4) < MIN(vals(2), vals(3)))) THEN CALL fail(ErrStat, ErrMsg, 'STIFFENERS InnerD must be smaller than RootOD and TipOD'); RETURN END IF + ! as wide as the widest line type at most (LINE TYPES Diam <= 1e3 m) + IF (MAX(vals(2), vals(3)) > 1.0e3_wp) THEN + CALL fail(ErrStat, ErrMsg, 'STIFFENERS RootOD and TipOD must be at most 1e3 m, as a line type''s Diam'); RETURN + END IF ! a segment starts where the previous segment of the same line end stops s0 = CD_ZERO nold = 0 @@ -16956,6 +17506,8 @@ SUBROUTINE apply_option(line, opts, ErrStat, ErrMsg) opts%current_profile_velocity(:, 1) = [x6, x7, x8] opts%current_profile_velocity(:, 2) = [x2, x3, x4] END IF + ! last row wins: an earlier uniform row leaves no velocity behind + opts%current_velocity = CD_ZERO opts%has_current = .TRUE. opts%has_current_profile = .TRUE. RETURN @@ -17011,6 +17563,8 @@ SUBROUTINE apply_option(line, opts, ErrStat, ErrMsg) opts%wave_height = x1 opts%wave_period = x2 opts%wave_direction = x3 + ! last row wins: a regular wave has no gamma, so an earlier JONSWAP row leaves none + opts%wave_gamma = CD_ONE opts%has_wave = .TRUE. opts%wave_kind = WAVE_AIRY IF (to_lower(TRIM(mode)) /= 'airy') opts%wave_kind = WAVE_STREAM @@ -17154,6 +17708,15 @@ SUBROUTINE apply_option(line, opts, ErrStat, ErrMsg) opts%has_max_strain = ErrStat == 0 CASE ('vivrmswindow', 'viv_rms_window') CALL rd(val, opts%viv_rms_window, ErrStat, ErrMsg) + CASE ('vivphaseseed', 'viv_phase_seed') + SELECT CASE (TRIM(to_lower(val))) + CASE ('spread') + opts%viv_phase_zero = .FALSE. + CASE ('zero') + opts%viv_phase_zero = .TRUE. + CASE DEFAULT + CALL fail(ErrStat, ErrMsg, 'OPTION VIVphaseSeed "'//TRIM(val)//'" must be spread or zero') + END SELECT CASE ('streamorder', 'stream_order') CALL rd(val, x1, ErrStat, ErrMsg) IF (ErrStat == 0) THEN @@ -17263,6 +17826,17 @@ SUBROUTINE apply_option(line, opts, ErrStat, ErrMsg) CASE DEFAULT CALL fail(ErrStat, ErrMsg, 'OPTION OutputRecovery "'//TRIM(val)//'" must be equilibrium or element') END SELECT + CASE ('axialdampingratio', 'axial_damping_ratio') + ! what a negative LINE TYPES BA is the damping ratio of: each segment (MoorDyn) or the + ! line's first axial mode + SELECT CASE (to_lower(TRIM(strip_quotes(val)))) + CASE ('segment') + opts%axial_damping_mode1 = .FALSE. + CASE ('mode1') + opts%axial_damping_mode1 = .TRUE. + CASE DEFAULT + CALL fail(ErrStat, ErrMsg, 'OPTION axialDampingRatio "'//TRIM(val)//'" must be segment or mode1') + END SELECT CASE ('cable_load_feedback', 'cableloadfeedback') CALL rd_bool(val, opts%cable_load_feedback, ErrStat, ErrMsg) CASE ('predict_loads', 'predictloads') @@ -17635,8 +18209,10 @@ SUBROUTINE check_option_row_value(kw, val, ErrStat, ErrMsg) IF (key(1:13) == 'aslaidtension' .AND. VERIFY(TRIM(key(14:)), '0123456789') == 0) key = 'aslaidtension' END IF SELECT CASE (TRIM(key)) - CASE ('g', 'gravity', 'rhow', 'wtrdnsty', 'water_density', 'wtrdpth', 'water_depth', 'dtm', 'dt', 'dtwave') + CASE ('g', 'gravity', 'rhow', 'wtrdnsty', 'water_density', 'wtrdpth', 'water_depth', 'dtwave') rule = 'positive' + CASE ('dtm', 'dt') + rule = 'time step' CASE ('tmax', 'tensile_strain_tolerance', 'tensilestraintolerance', 'ramptime', 'ramp_time', 'tramp', & 'maxstrain', 'max_strain', 'rangestart', 'range_start', 'vivrmswindow', 'viv_rms_window') rule = 'non-negative' @@ -17673,6 +18249,9 @@ SUBROUTINE check_option_row_value(kw, val, ErrStat, ErrMsg) IF (x < CD_ZERO) CALL fail(ErrStat, ErrMsg, 'OPTION '//TRIM(kw)//' must be >= 0') CASE ('unit') IF (x < CD_ZERO .OR. x > CD_ONE) CALL fail(ErrStat, ErrMsg, 'OPTION '//TRIM(kw)//' must lie in [0, 1]') + CASE ('time step') + IF (.NOT. (x >= CD_MIN_TIME_STEP)) CALL fail(ErrStat, ErrMsg, 'OPTION '//TRIM(kw)//' must be at least '// & + '1e-100 s: the time integration divides by its square') END SELECT END SUBROUTINE check_option_row_value @@ -18957,6 +19536,12 @@ SUBROUTINE finalize_checks(types, bodies, rod_types, rods, points, lines, sectio CALL fail(ErrStat, ErrMsg, 'LINE TYPE "'//TRIM(types(idx)%name)// & '": Diam and EA must be > 0'); RETURN END IF + ! A finite-EI line carries its mass in the bending dynamics and its weight in the statics + ! (an EI=0 line without mass is refused as net-buoyant below). + IF (types(idx)%ei > CD_ZERO .AND. .NOT. (types(idx)%mass > CD_ZERO)) THEN + CALL fail(ErrStat, ErrMsg, 'LINE TYPE "'//TRIM(types(idx)%name)// & + '": MassDenInAir must be > 0 on a finite-EI line'); RETURN + END IF ! Net-buoyant gate: EI=0 decks cannot build a lazy-wave arch. The finite-EI ! route has the cubic-Hermite arch seed and may proceed. A dynamic standalone ! run gets its clock from dtM; the executable's metadata scan also admits a @@ -22586,6 +23171,15 @@ SUBROUTINE write_multibody_dynamic_out(deck_path, out_root, channels, types, bod mb%cab_imp(c) = mb%cab_imp(c) .OR. attachment_moves(mb%cab_kind_b(c), mb%cab_obj_b(c)) IF (mb%cab_imp(c)) mb%cables(c)%tol = MIN(mb%cables(c)%tol, CLAMPED_CABLE_TOL) END IF + ! A cable in the monolithic step is restored and stepped again from the same start at every + ! coupling iteration; within-step tangent reuse (OPTIONS modified_newton) made each of those + ! steps dearer than a full Newton one (mixed_body_rods_points.dat: 7.0 s against 5.8 s), so + ! such a cable keeps full Newton; the other solvers of the deck keep the option. The + ! staggered march (bodyScheme staggered) steps each cable once per step and keeps it. + IF (mb%implicit .AND. mb%cab_imp(c) .AND. opts%dynamic_modified_newton) THEN + CALL CD_HFMF_Set_ModifiedNewton(mb%cables(c), .FALSE., ErrStat, ErrMsg) + IF (ErrStat /= CD_HFMF_OK) GOTO 900 + END IF END DO ALLOCATE (mb%cable_points(2, SIZE(cab_lines))) DO c = 1, SIZE(cab_lines) @@ -26944,7 +27538,8 @@ END SUBROUTINE rigid6_rod_loads SUBROUTINE solve_body_equilibrium_core(types, bodies, rod_types, rods, points, lines, sections, opts, ErrStat, & ErrMsg, bathymetry, points_only, jac_check_err, ext_pt, ext_fm, & - end_force_a, quiet, skipped, ext_km, ext_rot, end_force_b, res_left) + end_force_a, quiet, skipped, ext_km, ext_rot, end_force_b, res_left, & + point_force_start) !! Static equilibrium of the free objects of a deck: free Rigid6 bodies (six DOFs: position !! and a rotation-vector increment on SO(3); a CoupledPinned body holds its position at its !! host node and balances its moment about it), free rods (position and the two rotations @@ -26981,8 +27576,9 @@ SUBROUTINE solve_body_equilibrium_core(types, bodies, rod_types, rods, points, l !! whose radius starts at the first Newton step (capped at a quarter of the shortest moving !! line), widens after a well-predicted step on its boundary and shrinks after a rejected !! one, with Levenberg-Marquardt steps as the fallback. A trial is accepted when the residual - !! drops or when the Newton step from it is at most half the current one (a taut line - !! swinging about its anchor: every straight step overstretches it by its sagitta). Each + !! drops or when the Newton step from it is at most half the current one and half the shortest + !! of the phase (a taut line swinging about its anchor: every straight step overstretches it + !! by its sagitta). Each !! step turns an object by at most 0.25 rad, and accepted rotations are folded into the base !! orientation (rebase_rotations) so the Jacobian stays exact. Converged when the largest !! scaled residual is below 1e-9 of the force scale (largest net weight or line end force) @@ -27031,6 +27627,9 @@ SUBROUTINE solve_body_equilibrium_core(types, bodies, rod_types, rods, points, l ! [N m] of an object at the returned poses (zero when nothing was balanced): the resolution of ! the balance, which the passes of solve_body_equilibrium cannot refine REAL(wp), INTENT(OUT), OPTIONAL :: res_left + ! point_force_start: the magnitude of the net force on every moving point at its starting + ! position (per entry of points; zero for a point that does not move) + REAL(wp), INTENT(OUT), OPTIONAL :: point_force_start(:) TYPE :: LineStaticCache !! A moving line's mesh and loads (fixed) and its last converged shape (the warm seed). @@ -27062,6 +27661,9 @@ SUBROUTINE solve_body_equilibrium_core(types, bodies, rod_types, rods, points, l INTEGER :: nobj, n, i, j, k, it, inner, info, worst, jk LOGICAL :: ok, only_points REAL(wp) :: sc, rnorm, rnorm_try, mu, step_cap, len_min, dmax, trust, pred + ! the shortest Newton step of the phase so far (the natural-level test of a step that grew + ! the residual) + REAL(wp) :: dn_min ! the completion line: the deck pose of every point, and the largest turn of a body or rod REAL(wp), ALLOCATABLE :: pos_deck(:, :) REAL(wp) :: turn_rot(3, 3), turn_max @@ -27079,6 +27681,7 @@ SUBROUTINE solve_body_equilibrium_core(types, bodies, rod_types, rods, points, l IF (PRESENT(quiet)) silent = quiet IF (PRESENT(skipped)) skipped = .FALSE. IF (PRESENT(res_left)) res_left = CD_ZERO + IF (PRESENT(point_force_start)) point_force_start = CD_ZERO IF (.NOT. (only_points .OR. opts%body_ic_static)) RETURN ! the objects that move: free Rigid6 bodies and free rods with a line, then Free/Connect points ALLOCATE (okind(SIZE(bodies) + SIZE(rods) + SIZE(points)), idx(SIZE(bodies) + SIZE(rods) + SIZE(points))) @@ -27266,9 +27869,15 @@ SUBROUTINE solve_body_equilibrium_core(types, bodies, rod_types, rods, points, l DO CALL residual(x, r, sc, ok, .TRUE.) IF (.NOT. ok) RETURN + IF (phase == 1 .AND. PRESENT(point_force_start)) THEN + DO k = 1, nobj + IF (okind(k) == OBJ_POINT) point_force_start(idx(k)) = NORM2(r(off(k) + 1:off(k) + 3)) + END DO + END IF rnorm = NORM2(r) mu = 1.0e-8_wp trust = -CD_ONE + dn_min = HUGE(CD_ONE) DO it = 1, MAX_IT IF (MAXVAL(ABS(r)) <= 1.0e-9_wp*sc) EXIT ! the analytic Jacobian, and a central-difference one of the full residual when the @@ -27314,7 +27923,12 @@ SUBROUTINE solve_body_equilibrium_core(types, bodies, rod_types, rods, points, l ! centimetres although the pose is nearer the equilibrium. The Newton step length ! measures the distance in displacement units, where the overstretch counts only ! as its small length: the step is also accepted when the Newton step from the - ! trial point (its own analytic Jacobian) is at most half the current one. + ! trial point (its own analytic Jacobian) is at most half the current one, and + ! half the shortest Newton step of the phase so far: a Newton step that grows + ! again (a near-singular Jacobian at a slack/taut kink, whose long step lands on an + ! overstretched line) cannot reset the measure, which the residual then descends + ! back from, so the steps could otherwise cycle forever (a Connect point between a + ! near-vertical heavy chain and a wire lying nearly taut on the seabed). IF (.NOT. ok .AND. jk == 1) THEN CALL analytic_jacobian(x_try, jtry, ok) IF (ok) THEN @@ -27326,7 +27940,7 @@ SUBROUTINE solve_body_equilibrium_core(types, bodies, rod_types, rods, points, l END IF ok = info == CD_LINALG_OK IF (ok) ok = ALL(IEEE_IS_FINITE(dxc)) - IF (ok) ok = NORM2(dxc) <= 0.5_wp*NORM2(dxn) + IF (ok) ok = NORM2(dxc) <= 0.5_wp*MIN(NORM2(dxn), dn_min) END IF END IF END IF @@ -27371,6 +27985,8 @@ SUBROUTINE solve_body_equilibrium_core(types, bodies, rod_types, rods, points, l END DO IF (.NOT. ok) EXIT mu = MAX(0.25_wp*mu, 1.0e-12_wp) + ! the Newton step of the iterate just left (the last solve of dxn, from x) + IF (ALL(IEEE_IS_FINITE(dxn))) dn_min = MIN(dn_min, NORM2(dxn)) x = x_try r = r_try rnorm = rnorm_try @@ -33011,7 +33627,7 @@ SUBROUTINE write_modes_file(out_root, lines, res, ErrStat, ErrMsg) TYPE(ModalLineResult), INTENT(IN) :: res(:) INTEGER, INTENT(OUT) :: ErrStat CHARACTER(*), INTENT(OUT) :: ErrMsg - INTEGER :: unit, ios, li, part, nn, k, dpn, src, dst + INTEGER :: unit, ios, li, part, nn, k, dpn, src, dst, n_neg REAL(wp), ALLOCATABLE :: q_a(:), shapes_a(:, :), polar(:) CHARACTER(1) :: tb LOGICAL :: twist @@ -33072,6 +33688,17 @@ SUBROUTINE write_modes_file(out_root, lines, res, ErrStat, ErrMsg) END DO END DO CLOSE (unit) + ! A mode with omega^2 < 0 is an instability of the static state: it is written with a + ! negative frequency, and the run says so. + DO li = 1, SIZE(lines) + n_neg = 0 + IF (ALLOCATED(res(li)%omega2) .AND. res(li)%n_found > 0) & + n_neg = COUNT(res(li)%omega2(1:res(li)%n_found) < CD_ZERO) + IF (n_neg > 0) CALL print_note(output_unit, ' ', 'line '//TRIM(int_to_str(lines(li)%id))//': '// & + TRIM(int_to_str(n_neg))//' of its modes have omega^2 < 0, so its static state '// & + 'is unstable in them; '//TRIM(out_root)//'.modes.out gives each a negative '// & + 'frequency, -sqrt(|omega^2|)/(2 pi), and a period of 0') + END DO END SUBROUTINE write_modes_file SUBROUTINE resolve_deck_friction(opts, ErrStat, ErrMsg) @@ -36621,12 +37248,28 @@ END FUNCTION wrap_azimuth_deg PURE REAL(wp) FUNCTION line_geom_value(kind, deck_node, nnode, q_flat, stride, signed) RESULT(v) !! Shared evaluator for the GEOMETRIC output channels so every writer computes them - !! identically. `q_flat` holds the line node positions in INTERNAL order - !! (anchor->fairlead) with `stride` reals per node (3 for EI=0, 6 for finite-EI). + !! identically. `q_flat` holds the line node states in INTERNAL order + !! (anchor->fairlead) with `stride` reals per node (3 for EI=0: the position; 6 for + !! finite-EI: the position and the tangent DOF m = dr/ds). !! kind: 5 curvature, 7 declination, 8 azimuth. Bend moment is NOT geometric -- it is !! the MATERIAL moment EI*(kappa - kappa_0), computed per path (zero on EI=0 lines; !! eval_cable_channel and range_sample_cable on finite-EI lines), so it is not handled here and - !! kind = 6 returns 0. signed: the line's azimuth range (DeckLine%azi_signed). + !! kind = 6 returns 0. signed: the line's azimuth range (DeckLine%azi_signed). The + !! declination and azimuth of a finite-EI node are those of its tangent DOF + !! (cable_node_tangent), of an EI = 0 node those of the difference of node positions + !! (deck_node_tangent). + INTEGER, INTENT(IN) :: kind, deck_node, nnode, stride + REAL(wp), INTENT(IN) :: q_flat(:) + LOGICAL, INTENT(IN), OPTIONAL :: signed + IF (stride >= 6 .AND. (kind == 7 .OR. kind == 8)) THEN + v = cable_tangent_angle(kind, cable_node_tangent(q_flat, stride, nnode, deck_node), signed) + ELSE + v = position_geom_value(kind, deck_node, nnode, q_flat, stride, signed) + END IF + END FUNCTION line_geom_value + + PURE REAL(wp) FUNCTION position_geom_value(kind, deck_node, nnode, q_flat, stride, signed) RESULT(v) + !! line_geom_value from the node positions alone (line_geom_from_r), q_flat as there. INTEGER, INTENT(IN) :: kind, deck_node, nnode, stride REAL(wp), INTENT(IN) :: q_flat(:) LOGICAL, INTENT(IN), OPTIONAL :: signed @@ -36638,21 +37281,56 @@ PURE REAL(wp) FUNCTION line_geom_value(kind, deck_node, nnode, q_flat, stride, s r(:, j) = q_flat(base + 1:base + 3) END DO v = line_geom_from_r(kind, r, nnode, deck_node, signed) - END FUNCTION line_geom_value + END FUNCTION position_geom_value PURE SUBROUTINE line_geom_values(kind, nnode, stride, q, signed, values) !! line_geom_value at every deck node of a line. q(:, n) is internal node n's state, its first - !! three entries the position; the deck-ordered positions are read in place, not copied. + !! three entries the position (and on a finite-EI line, stride 6, the next three its tangent + !! DOF); the deck-ordered positions are read in place, not copied. INTEGER, INTENT(IN) :: kind, nnode, stride REAL(wp), INTENT(IN) :: q(stride, nnode) LOGICAL, INTENT(IN) :: signed REAL(wp), INTENT(OUT) :: values(nnode) INTEGER :: j + IF (stride >= 6 .AND. (kind == 7 .OR. kind == 8)) THEN + DO j = 1, nnode + ! deck node j is internal node nnode + 1 - j, whose tangent runs End B -> End A + values(j) = cable_tangent_angle(kind, -q(4:6, nnode + 1 - j), signed) + END DO + RETURN + END IF DO j = 1, nnode values(j) = line_geom_from_r(kind, q(1:3, nnode:1:-1), nnode, j, signed) END DO END SUBROUTINE line_geom_values + PURE FUNCTION cable_node_tangent(q_flat, stride, nnode, deck_node) RESULT(t) + !! The axial tangent of a finite-EI line at a deck node, oriented End A -> End B: its tangent + !! DOF m = dr/ds (q_flat in internal order, anchor -> fairlead, stride reals per node, the + !! position then m), reversed, as the internal arc length runs from End B. It is the line's + !! own direction at the node: the direction an END CONNECTIONS row holds at a restrained + !! end, continuous through the node, where a difference of node positions is the direction + !! of a chord. + REAL(wp), INTENT(IN) :: q_flat(:) + INTEGER, INTENT(IN) :: stride, nnode, deck_node + REAL(wp) :: t(3) + INTEGER :: base + base = stride*(nnode - MIN(MAX(deck_node, 1), nnode)) + t = -q_flat(base + 4:base + 6) + END FUNCTION cable_node_tangent + + PURE REAL(wp) FUNCTION cable_tangent_angle(kind, t, signed) RESULT(v) + !! kind 7: the declination [deg] of the tangent t; 8: its azimuth, in the line's range. + INTEGER, INTENT(IN) :: kind + REAL(wp), INTENT(IN) :: t(3) + LOGICAL, INTENT(IN), OPTIONAL :: signed + IF (kind == 7) THEN + v = tangent_declination_deg(t) + ELSE + v = tangent_azimuth_deg(t, signed) + END IF + END FUNCTION cable_tangent_angle + PURE REAL(wp) FUNCTION line_geom_from_r(kind, r, nnode, deck_node, signed) RESULT(v) !! Geometric channel value (kind: 5 curvature, 7 declination, 8 azimuth) from the !! deck-ordered node positions r(3, nnode). Factored out of line_geom_value so a caller @@ -36759,6 +37437,7 @@ SUBROUTINE collect_aggregate_init_summaries(lines, agg, ErrStat, ErrMsg) RETURN END IF CALL set_init_summary(lines(i)%id, tension, declination, azimuth, agg%init_lines(i), fair_force=fair_force) + CALL cable_axial_damping(agg%init_lines(i), agg%cables(agg%line_obj_index(lines(i)%id))) IF (ALLOCATED(agg%cable_note)) agg%init_lines(i)%note = agg%cable_note(agg%line_obj_index(lines(i)%id)) ELSE IF (agg%has_sys) THEN ! The force the EI=0 line exerts on its fairlead (internal last node), as the @@ -36771,6 +37450,7 @@ SUBROUTINE collect_aggregate_init_summaries(lines, agg, ErrStat, ErrMsg) RETURN END IF CALL set_init_summary(lines(i)%id, tension, declination, azimuth, agg%init_lines(i), fair_force=fair_force) + CALL model_axial_damping(agg%init_lines(i), agg%sys%lines(agg%line_obj_index(lines(i)%id))) ELSE CALL set_init_summary(lines(i)%id, tension, declination, azimuth, agg%init_lines(i)) END IF @@ -36838,6 +37518,7 @@ SUBROUTINE collect_model_init_summaries(lines, points, models, summaries, ErrSta RETURN END IF CALL set_init_summary(lines(i)%id, tension, declination, azimuth, summaries(i), fair_force=fair_force) + CALL model_axial_damping(summaries(i), models(i)) END DO IF (PRESENT(opts)) CALL add_model_fold_notes(lines, points, opts, models, summaries, FOLD_FRICTION_FULL) END SUBROUTINE collect_model_init_summaries @@ -36878,6 +37559,7 @@ SUBROUTINE collect_system_init_summaries(lines, points, system, summaries, ErrSt RETURN END IF CALL set_init_summary(lines(i)%id, tension, declination, azimuth, summaries(i), fair_force=fair_force) + CALL model_axial_damping(summaries(i), system%lines(i)) END DO IF (PRESENT(opts)) THEN IF (PRESENT(friction_support)) THEN @@ -36913,9 +37595,29 @@ SUBROUTINE collect_hermite_init_summaries(lines, cables, summaries, opts, fricti CALL set_init_summary(lines(i)%id, tension, declination, azimuth, summaries(i), fair_force=fair_force) summaries(i)%seabed_drift = cable_seabed_drift(opts, cables(i)) summaries(i)%friction_refused = friction_support == FOLD_FRICTION_NONE + CALL cable_axial_damping(summaries(i), cables(i)) END DO END SUBROUTINE collect_hermite_init_summaries + SUBROUTINE model_axial_damping(summary, model) + !! summary_axial_damping of an EI = 0 line: its plain axial damping (zero on viscoelastic and + !! Syrope elements, whose own laws carry theirs). + TYPE(CD_LineInitSummary), INTENT(INOUT) :: summary + TYPE(CD_ModelType), INTENT(IN) :: model + IF (.NOT. (ALLOCATED(model%ba_dyn) .AND. ALLOCATED(model%l0) .AND. ALLOCATED(model%ea) .AND. & + ALLOCATED(model%rho_a))) RETURN + CALL summary_axial_damping(summary, model%l0, model%ea, model%rho_a, model%ba_dyn) + END SUBROUTINE model_axial_damping + + SUBROUTINE cable_axial_damping(summary, cable) + !! summary_axial_damping of a finite-EI cable, on its final mesh. + TYPE(CD_LineInitSummary), INTENT(INOUT) :: summary + TYPE(CD_HFMF_ModuleType), INTENT(IN) :: cable + IF (.NOT. (ALLOCATED(cable%line%BA) .AND. ALLOCATED(cable%line%l0) .AND. ALLOCATED(cable%line%EA) .AND. & + ALLOCATED(cable%line%rho_a))) RETURN + CALL summary_axial_damping(summary, cable%line%l0, cable%line%EA, cable%line%rho_a, cable%line%BA) + END SUBROUTINE cable_axial_damping + SUBROUTINE print_deck_init_report(deck_path, lines, points, sections, n_finite, summaries, types, opts) !! The initialization report goes to stderr (see doc/cli.rst). CHARACTER(*), INTENT(IN) :: deck_path @@ -36974,6 +37676,8 @@ SUBROUTINE print_deck_init_report(deck_path, lines, points, sections, n_finite, IF (opts%has_dtm .AND. opts%tmax > CD_ZERO) THEN CALL axial_period_note(summaries(i)%line_id, opts%dtM, sections, types, strain_note) IF (LEN_TRIM(strain_note) > 0) WRITE (error_unit, '(A)') ' Note: '//TRIM(strain_note)//'.' + CALL axial_damping_note(summaries(i), sections, types, opts, strain_note) + IF (LEN_TRIM(strain_note) > 0) WRITE (error_unit, '(A)') ' Note: '//TRIM(strain_note)//'.' END IF END IF END DO @@ -37222,13 +37926,10 @@ SUBROUTINE range_sample_cable(cable, rl, ErrStat, ErrMsg) IF (cable%line%nn /= nn .OR. cable%line%ne /= ne .OR. SIZE(cable%line%q) < 6*nn) THEN CALL fail_solve(ErrStat, ErrMsg, 'range-graph sample: cable state not available'); RETURN END IF - DO j = 1, nn - inode = nn + 1 - j - rl%r(:, j) = cable%line%q(6*(inode - 1) + 1:6*(inode - 1) + 3) - END DO IF (rl%want_range) THEN + ! the declination of each node's tangent DOF (cable_node_tangent), as LNDec DO j = 1, nn - rl%val(CD_RQ_DECLINATION, j) = line_geom_from_r(7, rl%r, nn, j) + rl%val(CD_RQ_DECLINATION, j) = cable_tangent_angle(7, cable_node_tangent(cable%line%q, 6, nn, j)) END DO END IF DO j = 1, nn @@ -38444,18 +39145,25 @@ PURE FUNCTION cable_frame_is_identity(cable) RESULT(is_id) is_id = .NOT. (ABS(cable%frame_s) > CD_ZERO .OR. ABS(cable%frame_c - CD_ONE) > CD_ZERO) END FUNCTION cable_frame_is_identity - PURE SUBROUTINE CD_Deck_VIV_Phase_Seed(l0, swapped, seed, deck_map) - !! MoorDyn's VIV phase seed i/N (phase 2 pi i/N at node i = 0 .. N counted from the deck's - !! End A, N the deck's segment count) at every node of a line, in the model's internal node - !! order (node 1 = End B; element e of length l0(e) joins nodes e and e + 1). swapped: the - !! reader turned the line's ends around, so the deck's End A is the model's End B. deck_map: - !! the mesh node (public order, End A = 1) of each deck node, on a mesh the static solve - !! refined; a node it added takes the seed interpolated linearly in unstretched arc length - !! between its two deck nodes. Without deck_map the mesh is the deck's. + PURE SUBROUTINE CD_Deck_VIV_Phase_Seed(l0, swapped, seed, deck_map, zero) + !! The initial VIV phase of every node of a line, as a fraction of a turn, in the model's + !! internal node order (node 1 = End B; element e of length l0(e) joins nodes e and e + 1). + !! + !! MoorDyn starts node i = 0 .. N (counted from the deck's End A, N the deck's segment count) + !! at the phase 2 pi i/N (MoorDyn-C; zero: at 0, where MoorDyn-F in OpenFAST v5.0.0 starts), + !! with the node tangent from the deck's End A to its End B. The model's node tangent runs from + !! its End B to its End A: against MoorDyn's on a line the reader keeps in the deck order, + !! which turns the lift and the cross-flow axis of the synchronisation model around. That + !! motion is MoorDyn's from the phases half a turn on, which the seed adds there; a line the + !! reader turned around (swapped: the deck's End A is the model's End B) has MoorDyn's tangent. + !! deck_map: the mesh node (public order, End A = 1) of each deck node, on a mesh the static + !! solve refined; a node it added takes the seed interpolated linearly in unstretched arc + !! length between its two deck nodes. Without deck_map the mesh is the deck's. REAL(wp), INTENT(IN) :: l0(:) LOGICAL, INTENT(IN) :: swapped REAL(wp), INTENT(OUT) :: seed(:) INTEGER, INTENT(IN), OPTIONAL :: deck_map(:) + LOGICAL, INTENT(IN), OPTIONAL :: zero REAL(wp) :: s(SIZE(l0) + 1), f INTEGER :: ne, nn, p, j, nd ne = SIZE(l0) @@ -38479,6 +39187,10 @@ PURE SUBROUTINE CD_Deck_VIV_Phase_Seed(l0, swapped, seed, deck_map) f = REAL(p - 1, wp)/REAL(ne, wp) END IF IF (swapped) f = CD_ONE - f + IF (PRESENT(zero)) THEN + IF (zero) f = CD_ZERO + END IF + IF (.NOT. swapped) f = MODULO(f + 0.5_wp, CD_ONE) seed(nn + 1 - p) = f END DO END SUBROUTINE CD_Deck_VIV_Phase_Seed @@ -39543,9 +40255,9 @@ END FUNCTION deck_has_torsion_columns LOGICAL FUNCTION line_is_finite_ei(ln, types, sections) RESULT(is_finite) !! A LINE is a finite-EI (bending) cable iff ANY of its sections has EI > 0. - !! Factored from all_lines_have_finite_ei's per-line finite test so the OpenFAST - !! aggregate (CD_Init_Deck_Aggregate) can partition a mixed deck into its - !! {EI=0 mooring} and {finite-EI cable} subsets from one shared predicate. + !! The one predicate every route partitions a deck by: the coupled aggregate and the + !! multibody march into their {EI=0 mooring} and {finite-EI cable} subsets, the standalone + !! finite-EI march into the cables it builds. TYPE(DeckLine), INTENT(IN) :: ln TYPE(DeckLineType), INTENT(IN) :: types(:) TYPE(DeckSection), INTENT(IN) :: sections(:) @@ -39562,28 +40274,6 @@ LOGICAL FUNCTION line_is_finite_ei(ln, types, sections) RESULT(is_finite) END DO END FUNCTION line_is_finite_ei - LOGICAL FUNCTION all_lines_have_finite_ei(types, lines, sections) RESULT(all_finite) - !! Every line is fully finite-EI: each line has at least one finite-EI section - !! (line_is_finite_ei) AND no line carries an EI=0 section. Used to reject a deck - !! that mixes EI=0 and finite-EI sections on the standalone finite-EI dynamic path. - TYPE(DeckLineType), INTENT(IN) :: types(:) - TYPE(DeckLine), INTENT(IN) :: lines(:) - TYPE(DeckSection), INTENT(IN) :: sections(:) - INTEGER :: i, j - all_finite = .TRUE. - DO i = 1, SIZE(lines) - DO j = 1, SIZE(sections) - IF (sections(j)%line_id /= lines(i)%id) CYCLE - IF (sections(j)%ltype < 1 .OR. sections(j)%ltype > SIZE(types)) THEN - all_finite = .FALSE. - CYCLE - END IF - IF (.NOT. (types(sections(j)%ltype)%ei > CD_ZERO)) all_finite = .FALSE. - END DO - all_finite = all_finite .AND. line_is_finite_ei(lines(i), types, sections) - END DO - END FUNCTION all_lines_have_finite_ei - INTEGER FUNCTION point_index(points, id) RESULT(idx) TYPE(DeckPoint), INTENT(IN) :: points(:) INTEGER, INTENT(IN) :: id diff --git a/src/CableDyn_HermiteCable.f90 b/src/CableDyn_HermiteCable.f90 index ea7cef97..dc62e175 100644 --- a/src/CableDyn_HermiteCable.f90 +++ b/src/CableDyn_HermiteCable.f90 @@ -327,6 +327,8 @@ SUBROUTINE hermite_element_integrated(qr, L, EA, EI, quadrature_order, Eout, fin ! symmetry without redundant flops. DO m = 1, 4 DO k = 1, 4 + ! a node block below the diagonal (k > m) holds only rows ic > jc: none in the upper triangle + IF (half_kt .AND. k > m) CYCLE w11 = b1(k)*b1(m) w12 = b1(k)*b2(m) w21 = b2(k)*b1(m) diff --git a/src/CableDyn_HermiteCableDynamic.f90 b/src/CableDyn_HermiteCableDynamic.f90 index c711a155..ff12e0c5 100644 --- a/src/CableDyn_HermiteCableDynamic.f90 +++ b/src/CableDyn_HermiteCableDynamic.f90 @@ -179,6 +179,11 @@ MODULE CableDyn_HermiteCableDynamic ! Half-bandwidth of the nodal-twist tangent in 7-DOF-per-node order ([r, m, phi] per node). INTEGER, PARAMETER :: KB7 = 13 INTEGER, PARAMETER :: LDAB_D = 2*KL_D + KU_D + 1 + ! First row of the stored band. Rows 1..KL_D are the factorization's fill-in space: every + ! band array is allocated with them zero and only an LU factor (ws_Keffb) ever writes them, + ! so the sweeps over the operators (zeroing, sums, the effective-tangent combination, the + ! added-mass check) skip them. + INTEGER, PARAMETER :: BAND_TOP_D = KL_D + 1 ! Profiling is OFF by default: SYSTEM_CLOCK in the step/residual hot path is measurable ! overhead in a production run. CD_HermiteCable_Dyn_Reset_Profile ARMS it (a benchmark @@ -306,6 +311,9 @@ MODULE CableDyn_HermiteCableDynamic ! the Newton iterations); viv_rate/viv_ms_next hold the step-start rate and mean squares. ! ws_recovery_viv_* is the step-start copy of the recovering step, snap_viv_* the snapshot. LOGICAL :: has_viv = .FALSE. + ! the cross-flow phase of a node at rest (CD_VIV_Phase_Rate phi_rest): pi where the material + ! tangent runs against MoorDyn's node tangent (End B to End A), 0 where it runs as MoorDyn's + REAL(wp) :: viv_phi_rest = CD_ZERO REAL(wp) :: viv_tw = CD_ZERO REAL(wp), ALLOCATABLE :: viv_cl(:), viv_k(:), viv_cf(:), viv_df(:), viv_dn(:), viv_phi(:), viv_phi_eval(:) REAL(wp), ALLOCATABLE :: viv_rate(:), viv_ms(:, :), viv_ms_next(:, :) @@ -355,10 +363,27 @@ MODULE CableDyn_HermiteCableDynamic REAL(wp), ALLOCATABLE :: ws_Kb(:, :), ws_Kvb(:, :) REAL(wp), ALLOCATABLE :: ws_Keffb(:, :), ws_Msumb(:, :), ws_Mamb(:, :) INTEGER, ALLOCATABLE :: ws_ipiv(:) ! band-factorization pivots - REAL(wp), ALLOCATABLE :: ws_elem_f(:, :), ws_elem_K(:, :, :), ws_elem_Kdrag(:, :, :) + REAL(wp), ALLOCATABLE :: ws_elem_K(:, :, :), ws_elem_Kdrag(:, :, :) REAL(wp), ALLOCATABLE :: ws_elem_Kv(:, :, :), ws_elem_Kwave(:, :, :), ws_elem_Kheld(:, :, :) INTEGER, ALLOCATABLE :: ws_elem_es(:) CHARACTER(200), ALLOCATABLE :: ws_elem_em(:) + ! Element tangents kept by a residual evaluation (assemble_residual with stash_tangent): the + ! element loads of each kernel, ws_elem_f(:, k, e) for k = structure, axial damping, drag, VIV + ! lift, wave and held Froude-Krylov, the element tangent blocks in ws_elem_K..ws_elem_Kheld, + ! and the configuration, velocity and time of that evaluation. A tangent assembly at the same + ! state (use_stash) scatters the kept blocks instead of evaluating the kernels again. Every + ! other assembly clears ws_stash_ok. + REAL(wp), ALLOCATABLE :: ws_elem_f(:, :, :), ws_stash_q(:), ws_stash_v(:) + REAL(wp) :: ws_stash_t = CD_ZERO + LOGICAL :: ws_stash_ok = .FALSE. + ! The Newton solves of the last committed step (1 before the first): the predictor, which the + ! first iteration's tangent follows at the same state, keeps its element tangents when the + ! last step made a solve (did not converge at its predictor). + INTEGER :: ws_stash_solves = 1 + ! The tangents the last committed step's line searches assembled at their accepted trial: the + ! full step of a full-Newton line search keeps its element tangents while the step has + ! assembled fewer. + INTEGER :: ws_stash_ls = 0 REAL(wp) :: alpha_m = CD_ZERO, alpha_f = CD_ZERO, beta = CD_ZERO, gamma = CD_ZERO ! Optional Morison drag (transverse + tangential quadratic drag on the submerged cable, relative ! to a uniform fluid velocity). Off by default; wired in via CD_HermiteCable_Dyn_Set_Drag. @@ -832,10 +857,16 @@ SUBROUTINE CD_HermiteCable_Dyn_Init(model, l0, EA, EI, rho_a, w, seed, fixed_dof ALLOCATE (model%ws_Kb(LDAB_D, ndof), model%ws_Kvb(LDAB_D, ndof), & model%ws_Keffb(LDAB_D, ndof), model%ws_Msumb(LDAB_D, ndof), & model%ws_Mamb(LDAB_D, ndof)) + ! zero fill-in rows (BAND_TOP_D), which the band sweeps then leave untouched + model%ws_Kb = CD_ZERO; model%ws_Kvb = CD_ZERO; model%ws_Keffb = CD_ZERO + model%ws_Msumb = CD_ZERO; model%ws_Mamb = CD_ZERO ALLOCATE (model%ws_ipiv(ndof)) - ALLOCATE (model%ws_elem_f(12, ne), model%ws_elem_K(12, 12, ne), model%ws_elem_Kdrag(12, 12, ne), & + ALLOCATE (model%ws_elem_f(12, 6, ne), model%ws_elem_K(12, 12, ne), model%ws_elem_Kdrag(12, 12, ne), & model%ws_elem_Kv(12, 12, ne), model%ws_elem_Kwave(12, 12, ne), model%ws_elem_Kheld(12, 12, ne), & - model%ws_elem_es(ne), model%ws_elem_em(ne)) + model%ws_elem_es(ne), model%ws_elem_em(ne), model%ws_stash_q(ndof), model%ws_stash_v(ndof)) + model%ws_stash_ok = .FALSE. + model%ws_stash_solves = 1 + model%ws_stash_ls = 0 ! state: at-rest seed, v = 0, consistent a0 ALLOCATE (model%q(ndof), model%v(ndof), model%a(ndof)) @@ -1045,14 +1076,17 @@ SUBROUTINE CD_HermiteCable_Dyn_Set_Friction_Axial(model, mu_axial, ErrStat, ErrM model%tr_valid = .FALSE. END SUBROUTINE CD_HermiteCable_Dyn_Set_Friction_Axial - SUBROUTINE CD_HermiteCable_Dyn_Set_VIV(model, cl, cf, df, t_window, ErrStat, ErrMsg, phase_seed) + SUBROUTINE CD_HermiteCable_Dyn_Set_VIV(model, cl, cf, df, t_window, ErrStat, ErrMsg, phase_seed, tangent_reversed) !! Install the cross-flow VIV synchronisation model (CableDyn_VIV) on a cable with drag: !! per element the lift coefficient cl (0: no lift) and the band df/cf, and the running-RMS !! averaging time t_window (s; 0 takes 500 steps of the first step). The lift acts on the !! wetted Gauss points of every element with cl > 0, its phase lives on the nodes of those - !! elements; the phases start at 2 pi i/N with node i counted from End A (the model's last - !! node), as MoorDyn's; phase_seed, per node, gives i/N instead (a line whose deck End A the - !! reader turned around, or a mesh refined from the deck's). The phase follows the drag's + !! elements; MoorDyn starts node i counted from End A (the model's last node) at 2 pi i/N + !! with its tangent from End A to End B, and the material tangent here runs from End B to + !! End A, which turns the lift and the cross-flow axis around: the phases start at 2 pi i/N + !! plus pi, the same motion. phase_seed, per node, gives the start as a fraction of a turn + !! instead (CD_Deck_VIV_Phase_Seed: a line whose deck End A the reader turned around, a mesh + !! refined from the deck's). The phase follows the drag's !! current and a held host field (which !! carries any waves); the internal wave families (Set_Waves) are refused with VIV. The !! committed acceleration is refreshed with the new lift; if that fails, the previous VIV @@ -1062,8 +1096,12 @@ SUBROUTINE CD_HermiteCable_Dyn_Set_VIV(model, cl, cf, df, t_window, ErrStat, Err INTEGER, INTENT(OUT) :: ErrStat CHARACTER(*), INTENT(OUT) :: ErrMsg REAL(wp), INTENT(IN), OPTIONAL :: phase_seed(:) + !! tangent_reversed (default .TRUE., the model's own seed): the material tangent runs against + !! MoorDyn's node tangent, so a node at rest takes the cross-flow phase pi + !! (CD_VIV_Phase_Rate phi_rest); .FALSE. on a line the reader turned around + LOGICAL, INTENT(IN), OPTIONAL :: tangent_reversed INTEGER :: e, k, ne, nn, es - REAL(wp) :: wsum, tw_old + REAL(wp) :: wsum, tw_old, rest_old LOGICAL :: had_viv CHARACTER(LEN=1024) :: em REAL(wp), ALLOCATABLE :: a_old(:), o_cl(:), o_k(:), o_cf(:), o_df(:), o_dn(:), o_phi(:), o_phi_eval(:), & @@ -1109,6 +1147,7 @@ SUBROUTINE CD_HermiteCable_Dyn_Set_VIV(model, cl, cf, df, t_window, ErrStat, Err ! the previous configuration and state, kept for a rollback had_viv = model%has_viv tw_old = model%viv_tw + rest_old = model%viv_phi_rest a_old = model%a CALL move_viv(.FALSE.) CALL clear_viv(model) @@ -1144,7 +1183,7 @@ SUBROUTINE CD_HermiteCable_Dyn_Set_VIV(model, cl, cf, df, t_window, ErrStat, Err model%viv_node(k) = .TRUE. model%viv_cf(k) = model%viv_cf(k)/wsum model%viv_df(k) = model%viv_df(k)/wsum - model%viv_phi(k) = CD_VIV_TWO_PI*REAL(nn - k, wp)/REAL(ne, wp) + model%viv_phi(k) = CD_VIV_Wrap_Phase(CD_VIV_TWO_PI*(REAL(nn - k, wp)/REAL(ne, wp) + 0.5_wp)) IF (PRESENT(phase_seed)) model%viv_phi(k) = CD_VIV_TWO_PI*phase_seed(k) END DO CALL viv_drag_terms(model) @@ -1156,6 +1195,8 @@ SUBROUTINE CD_HermiteCable_Dyn_Set_VIV(model, cl, cf, df, t_window, ErrStat, Err model%snap_viv_phi = model%viv_phi model%snap_viv_ms = model%viv_ms model%viv_tw = t_window + model%viv_phi_rest = 0.5_wp*CD_VIV_TWO_PI + IF (PRESENT(tangent_reversed)) model%viv_phi_rest = MERGE(0.5_wp*CD_VIV_TWO_PI, CD_ZERO, tangent_reversed) model%has_viv = .TRUE. ! the lift is part of the committed load: the first step's predictor and phase rate need it CALL refresh_acceleration() @@ -1168,6 +1209,7 @@ SUBROUTINE refresh_acceleration() CALL move_viv(.TRUE.) model%has_viv = had_viv model%viv_tw = tw_old + model%viv_phi_rest = rest_old model%a = a_old ErrStat = es ErrMsg = 'CD_HermiteCable_Dyn_Set_VIV: acceleration refresh failed: '//TRIM(em) @@ -1279,7 +1321,7 @@ SUBROUTINE viv_step_begin(model, dt, ErrStat, ErrMsg) model%viv_ms_next(2, k) = CD_VIV_Mean_Square(model%viv_ms(2, k), ydd, w) model%viv_rate(k) = CD_VIV_Phase_Rate(yd, ydd, model%viv_ms_next(1, k), model%viv_ms_next(2, k), & model%viv_phi(k), un, model%viv_dn(k), model%viv_cf(k), & - model%viv_df(k)) + model%viv_df(k), phi_rest=model%viv_phi_rest) model%viv_phi_eval(k) = model%viv_phi(k) + frac*dt*model%viv_rate(k) END DO END SUBROUTINE viv_step_begin @@ -1305,7 +1347,7 @@ SUBROUTINE viv_step_end(model, dt) ms1 = CD_VIV_Mean_Square(model%viv_ms_next(1, k), yd, w) ms2 = CD_VIV_Mean_Square(model%viv_ms_next(2, k), ydd, w) rate_end = CD_VIV_Phase_Rate(yd, ydd, ms1, ms2, model%viv_phi(k) + dt*model%viv_rate(k), un, & - model%viv_dn(k), model%viv_cf(k), model%viv_df(k)) + model%viv_dn(k), model%viv_cf(k), model%viv_df(k), phi_rest=model%viv_phi_rest) IF (.NOT. CD_Is_Finite(rate_end)) rate_end = model%viv_rate(k) END IF model%viv_phi(k) = CD_VIV_Wrap_Phase(model%viv_phi(k) + 0.5_wp*dt*(model%viv_rate(k) + rate_end)) @@ -3685,6 +3727,7 @@ SUBROUTINE dyn_step_core(model, dt, max_iter, tol, ErrStat, ErrMsg, iters_out, r INTEGER :: ndof, it, es, i, np, ip, ls, gdof, nsolve_step, axial_element, axial_es INTEGER :: axial_worst_element, iv, attempt, n_attempt + INTEGER :: n_ls_tan ! tangents the step's line searches assembled at their accepted trial REAL(wp) :: c_a, c_v, c_a2, am, af, bt, gm, rnorm, fscale, rnt, lambda, chosen, lam_ok, cw, t_alpha, dth_lin REAL(wp) :: e_bal, e_ma, tors_theta_new, tors_mt_new REAL(wp) :: axial_qe(12), axial_min @@ -3879,8 +3922,7 @@ SUBROUTINE dyn_step_core(model, dt, max_iter, tol, ErrStat, ErrMsg, iters_out, r ! Total mass for this step: structural + added mass FROZEN at the beginning-of-step ! configuration q_n (constant within the Newton -> no dM/dq term; O(dt) freeze error consistent ! with gen-alpha accuracy, exact at any at-rest fixed point). All band arrays share the - ! DGBSV layout, so the sum is a plain array operation. - CALL band_copy(model%Mgb, model%ws_Msumb) + ! DGBSV layout, so the sum is a plain array operation (one sweep, after the added mass). IF (model%has_am) THEN IF (prof_enabled) CALL SYSTEM_CLOCK(pc0) CALL assemble_added_mass(model, model%ws_qn, es, em2) @@ -3892,7 +3934,9 @@ SUBROUTINE dyn_step_core(model, dt, max_iter, tol, ErrStat, ErrMsg, iters_out, r IF (es /= CD_HCDYN_OK) THEN ErrStat = es; ErrMsg = 'CD_HermiteCable_Dyn_Step: '//TRIM(em2); RETURN END IF - CALL band_add(model%ws_Mamb, model%ws_Msumb) + CALL band_sum(model%Mgb, model%ws_Mamb, model%ws_Msumb) + ELSE + CALL band_copy(model%Mgb, model%ws_Msumb) END IF ! A fixed DOF that is NOT prescribed this step is a boundary HELD AT REST: zero its velocity and ! acceleration so the predictor keeps it at q_n and the commit leaves v = a = 0. Without this a @@ -4080,7 +4124,13 @@ SUBROUTINE dyn_step_core(model, dt, max_iter, tol, ErrStat, ErrMsg, iters_out, r ! A carried factor starts the iteration already factored (and stale). mn_factored = xs_active mn_fresh = .FALSE. - CALL eval_res(model%ws_qk, .FALSE., rnorm, es, em2) + n_ls_tan = 0 + ! The first iteration assembles its tangent at the predictor unless a carried factor is + ! reused, so the predictor evaluation keeps its element tangents for it (stash), unless the + ! last step converged at its predictor (made no solve). Either way every result is the same: + ! only where the element kernels run changes. + CALL eval_res(model%ws_qk, .FALSE., rnorm, es, em2, & + stash=nsolve_step < model%ws_stash_solves .AND. .NOT. ((mn .OR. xs_active) .AND. mn_factored)) IF (es /= CD_HCDYN_OK) THEN ErrStat = es; ErrMsg = 'CD_HermiteCable_Dyn_Step: '//TRIM(em2) IF (attempt < n_attempt) CYCLE predict @@ -4134,8 +4184,9 @@ SUBROUTINE dyn_step_core(model, dt, max_iter, tol, ErrStat, ErrMsg, iters_out, r IF (.NOT. ((mn .OR. xs_active) .AND. mn_factored)) THEN IF (.NOT. have_tangent) THEN IF (prof_enabled) CALL SYSTEM_CLOCK(pc0) + ! the element tangents the predictor (or refresh) evaluation kept at this very state CALL assemble_residual(model, model%ws_qa, model%ws_va, t_alpha, .FALSE., .TRUE., es, em2, & - endconn_direction_eval=step_endconn_eval) + endconn_direction_eval=step_endconn_eval, use_stash=.TRUE.) IF (prof_enabled) THEN CALL SYSTEM_CLOCK(pc1) prof_n_tan = prof_n_tan + 1 @@ -4257,7 +4308,11 @@ SUBROUTINE dyn_step_core(model, dt, max_iter, tol, ErrStat, ErrMsg, iters_out, r model%ws_qtrial(iv) = model%ws_qk(iv) + lambda*model%ws_dq(iv) END DO IF (model%tw_active) CALL tw_trial(lambda) - CALL eval_res(model%ws_qtrial, .TRUE., rnt, es, em2) + ! The full step of a full-Newton iteration keeps its element tangents while this step's + ! line searches have assembled fewer tangents than the last step's (an accepted trial that + ! iterates again assembles its tangent below, at this state). + CALL eval_res(model%ws_qtrial, .TRUE., rnt, es, em2, & + stash=ls == 1 .AND. .NOT. (mn .OR. xs_active) .AND. n_ls_tan < model%ws_stash_ls) IF (es == CD_HCDYN_OK) THEN lam_ok = lambda ! loop shrinks lambda, so this ends smallest IF (rnt < rnorm) THEN @@ -4283,7 +4338,7 @@ SUBROUTINE dyn_step_core(model, dt, max_iter, tol, ErrStat, ErrMsg, iters_out, r END IF IF (prof_enabled) CALL SYSTEM_CLOCK(pc0) CALL assemble_residual(model, model%ws_qa, model%ws_va, t_alpha, .FALSE., .TRUE., es, em2, & - endconn_direction_eval=step_endconn_eval) + endconn_direction_eval=step_endconn_eval, use_stash=.TRUE.) IF (prof_enabled) THEN CALL SYSTEM_CLOCK(pc1) prof_n_tan = prof_n_tan + 1 @@ -4291,6 +4346,7 @@ SUBROUTINE dyn_step_core(model, dt, max_iter, tol, ErrStat, ErrMsg, iters_out, r END IF IF (es == CD_HCDYN_OK) THEN have_tangent = .TRUE. + n_ls_tan = n_ls_tan + 1 chosen = lambda; EXIT END IF END IF @@ -4319,8 +4375,9 @@ SUBROUTINE dyn_step_core(model, dt, max_iter, tol, ErrStat, ErrMsg, iters_out, r ! assembles the fresh tangent at the right point. At most one refresh fires per ! iteration (the rebuild sets mn_fresh, which blocks this guard). If the fresh ! direction still cannot improve, the step is genuinely hard and the fallback - ! below handles it exactly as full Newton would. - CALL eval_res(model%ws_qk, .FALSE., rnorm, es, em2) + ! below handles it exactly as full Newton would. The retry-top tangent is at this + ! evaluation's state, so it keeps its element tangents (stash). + CALL eval_res(model%ws_qk, .FALSE., rnorm, es, em2, stash=.TRUE.) IF (es /= CD_HCDYN_OK) THEN ErrStat = es; ErrMsg = 'CD_HermiteCable_Dyn_Step: '//TRIM(em2) IF (attempt < n_attempt) CYCLE predict @@ -4409,6 +4466,8 @@ SUBROUTINE dyn_step_core(model, dt, max_iter, tol, ErrStat, ErrMsg, iters_out, r END DO EXIT predict END DO predict + model%ws_stash_solves = nsolve_step + model%ws_stash_ls = n_ls_tan ! Force blend: the committed force F_{n+1} enters every later step through af F_n, so the ! accepted state is taken one Newton correction beyond the tolerance, with the factor of @@ -4787,7 +4846,7 @@ LOGICAL FUNCTION force_cache_matches() RESULT(ok) END DO END FUNCTION force_cache_matches - SUBROUTINE eval_res(qcur, use_trial, rn, esx, emx) + SUBROUTINE eval_res(qcur, use_trial, rn, esx, emx, stash) !! gen-alpha residual G = M a_alpha + f_int - f_ext, its banded position/velocity !! tangents, and the dimensionless per-slot residual norm rn at the trial !! configuration qcur. Prescribed DOFs carry their prescribed acceleration/velocity; @@ -4797,15 +4856,19 @@ SUBROUTINE eval_res(qcur, use_trial, rn, esx, emx) !! at the loop top, directly into the committed band buffers) -- through pointers into the !! host's model, so no model subobject is ever argument-associated alongside the !! model itself (which the Fortran aliasing rule would forbid). Uses the ws_* Newmark scratch and the host fscale. + !! stash (optional): an evaluation the next tangent assembly follows at the same state + !! also keeps the element tangents (assemble_residual, stash_tangent); the residual is + !! the same either way. REAL(wp), INTENT(IN) :: qcur(:) LOGICAL, INTENT(IN) :: use_trial REAL(wp), INTENT(OUT) :: rn INTEGER, INTENT(OUT) :: esx CHARACTER(*), INTENT(OUT) :: emx + LOGICAL, INTENT(IN), OPTIONAL :: stash REAL(wp), POINTER :: Gout(:) INTEGER :: ii, nd INTEGER(INT64) :: ec0, ec1 - REAL(wp) :: xref, xd, xc, ea_r, kt, tw_round + REAL(wp) :: xref, xd, xc, ea_r, ka, kt, tw_round REAL(wp), PARAMETER :: RESID_ROUNDOFF = 16.0_wp REAL(wp), PARAMETER :: STATE_DIVERGED = 1.0e12_wp ec0 = 0_INT64 ! defined even with profiling off (see the step-entry note) @@ -4813,6 +4876,7 @@ SUBROUTINE eval_res(qcur, use_trial, rn, esx, emx) CALL SYSTEM_CLOCK(ec0) prof_n_resid = prof_n_resid + 1 END IF + model%ws_stash_ok = .FALSE. ! kept element tangents never outlive a new evaluation IF (use_trial) THEN Gout => model%ws_Gt ELSE @@ -4871,7 +4935,7 @@ SUBROUTINE eval_res(qcur, use_trial, rn, esx, emx) END IF CALL vector_blend(CD_ONE - am, model%ws_ak, am, model%ws_an, model%ws_aa) CALL assemble_residual(model, model%ws_qa, model%ws_va, t_alpha, .TRUE., .FALSE., esx, emx, & - endconn_direction_eval=step_endconn_eval) + endconn_direction_eval=step_endconn_eval, stash_tangent=stash) IF (esx /= CD_HCDYN_OK) THEN rn = CD_ZERO IF (prof_enabled) THEN @@ -4925,18 +4989,24 @@ SUBROUTINE eval_res(qcur, use_trial, rn, esx, emx) ! whose rounding is (K^2/GJ) eps |r|/l0, so the floor takes the whole axial stiffness ! EA - K^2/GJ + K^2/GJ of the line (without it the floor fell by 1 - K^2/(EA GJ): at ! K = 0.99 sqrt(EA GJ) to 2 % of the rounding it bounds, and a held line failed its step). + ! The axial damping force BA d(|r'|)/dt takes the strain rate from the Newmark velocity, + ! whose rounding is gamma/(beta dt) times that of the coordinates, so the floor adds + ! BA gamma/(beta dt) to the axial stiffness, as the twist floor below adds Bt: without it a + ! held line damped near its first axial mode (BA = 2 zeta EA/omega_1, which at small dt + ! puts the damping term well above EA) stagnated at a residual of a few times the + ! tolerance and failed its step. xref = MAXVAL(model%l0) DO ii = 1, ndof IF (MOD(ii - 1, 6) < 3) xref = MAX(xref, ABS(qcur(ii))) END DO - IF (model%torsion%active .AND. ALLOCATED(model%torsion%couple)) THEN - ea_r = CD_ZERO - DO ii = 1, SIZE(model%l0) - ea_r = MAX(ea_r, (ABS(model%EA(ii)) + model%torsion%couple(ii)**2*model%torsion%gj(ii))/model%l0(ii)) - END DO - ELSE - ea_r = MAXVAL(model%EA/model%l0) - END IF + ea_r = CD_ZERO + DO ii = 1, SIZE(model%l0) + ka = ABS(model%EA(ii)) + IF (model%torsion%active .AND. ALLOCATED(model%torsion%couple)) & + ka = ka + model%torsion%couple(ii)**2*model%torsion%gj(ii) + IF (model%has_axial_damping) ka = ka + ABS(model%BA(ii))*gm/(bt*dt) + ea_r = MAX(ea_r, ka/model%l0(ii)) + END DO fscale = MAX(fscale, RESID_ROUNDOFF*EPSILON(CD_ONE)*ea_r*xref/tol) ! Nodal twist: the torque scale of the angle rows, frozen with fscale and formed like it ! from the nodal loads (a node's torque imbalance, not the torque the line carries, @@ -5038,8 +5108,12 @@ SUBROUTINE add_rigid_transport_tangent() !! contains the c_a*d and gamma/(beta*dt)*d contributions. Add the terms !! from d_dot and d_ddot as a rank-one update whose right vector is d; !! after the rigid basis transform this affects only the free axial column. - INTEGER :: iend, base, row, j - REAL(wp) :: rate_coefficient, extra_acceleration(3) + !! The left vector (1 - am) M a_x + (1 - af) Kv d_dot has non-zeros only in the band rows + !! of the three tangent columns, so it is formed on those rows alone: the products of the + !! three column entries, summed in column order as the band matvec would sum them. + INTEGER :: iend, base, row, j, lo, hi + REAL(wp) :: rate_coefficient, extra_acceleration(3), mass_part, damping_part + REAL(wp) :: transport(KL_D + KU_D + 3) rate_coefficient = gm/(bt*dt) DO iend = 1, 2 IF (model%endconn_mode(iend) /= CD_ENDCONN_RIGID) CYCLE @@ -5050,19 +5124,23 @@ SUBROUTINE add_rigid_transport_tangent() END IF extra_acceleration = 2.0_wp*rate_coefficient*step_endconn_rate(:, iend) + & step_endconn_acceleration(:, iend) - model%ws_dq = CD_ZERO - model%ws_dq(base + 1:base + 3) = extra_acceleration - CALL band_matvec(model%ws_Msumb, model%ws_dq, model%ws_inert) - model%ws_inert = (CD_ONE - am)*model%ws_inert - model%ws_dq = CD_ZERO - model%ws_dq(base + 1:base + 3) = step_endconn_rate(:, iend) - CALL band_matvec(model%ws_Kvb, model%ws_dq, model%ws_vk) - model%ws_inert = model%ws_inert + (CD_ONE - af)*model%ws_vk + lo = MAX(1, base + 1 - KU_D) + hi = MIN(model%ndof, base + 3 + KL_D) + DO row = lo, hi + mass_part = CD_ZERO + damping_part = CD_ZERO + DO j = 1, 3 + mass_part = mass_part + dynamic_band_entry(model, model%ws_Msumb, row, base + j)*extra_acceleration(j) + damping_part = damping_part + & + dynamic_band_entry(model, model%ws_Kvb, row, base + j)*step_endconn_rate(j, iend) + END DO + transport(row - lo + 1) = (CD_ONE - am)*mass_part + (CD_ONE - af)*damping_part + END DO DO j = 1, 3 DO row = MAX(1, base + j - KU_D), MIN(model%ndof, base + j + KL_D) CALL set_dynamic_band_entry(model, model%ws_Keffb, row, base + j, & dynamic_band_entry(model, model%ws_Keffb, row, base + j) + & - model%ws_inert(row)*step_endconn_target(j, iend)) + transport(row - lo + 1)*step_endconn_target(j, iend)) END DO END DO END DO @@ -6334,19 +6412,21 @@ SUBROUTINE CD_HermiteCable_Dyn_Reaction(model, node, freac, ErrStat, ErrMsg, ful freac = -(model%ws_inert(gi + 1:gi + 3) + model%ws_R(gi + 1:gi + 3)) END SUBROUTINE CD_HermiteCable_Dyn_Reaction - SUBROUTINE node_reaction(model, node, freac, ErrStat, ErrMsg) + SUBROUTINE node_reaction(model, node, freac, ErrStat, ErrMsg, tangent_rows) !! CD_HermiteCable_Dyn_Reaction from the node's rows only: the residual of the one or two !! elements that reach the node and of its nodal terms (assemble_residual node_only), and !! the node's rows of the total mass times the acceleration, with the added mass of those !! elements. Every row term is formed and summed in the order of the full assembly and of !! band_matvec, so the reaction is bit-identical, at the cost of one or two elements !! instead of the line, and the model's scratch is not touched. Not for a line with - !! torsion, which couples every element. + !! torsion, which couples every element. tangent_rows = .TRUE. returns the node's three + !! material-tangent rows instead of its translational ones (a rigid end connection). TYPE(CD_HermiteCableDynType), INTENT(INOUT) :: model INTEGER, INTENT(IN) :: node REAL(wp), INTENT(OUT) :: freac(3) INTEGER, INTENT(OUT) :: ErrStat CHARACTER(*), INTENT(OUT) :: ErrMsg + LOGICAL, INTENT(IN), OPTIONAL :: tangent_rows REAL(wp) :: Rn(SIZE(model%ws_R)), Me(12, 12), mam(3, -KL_D:KU_D), inert(3), m INTEGER :: e, a, b, k, gi, gj, j, n, es CHARACTER(1024) :: em @@ -6357,6 +6437,9 @@ SUBROUTINE node_reaction(model, node, freac, ErrStat, ErrMsg) ErrStat = es; ErrMsg = TRIM(em); RETURN END IF gi = 6*(node - 1) + IF (PRESENT(tangent_rows)) THEN + IF (tangent_rows) gi = gi + 3 + END IF n = SIZE(model%a) ! the node's rows of the added mass, mam(k, j - (gi + k)) = Mamb(gi + k, j), summed element ! by element from zero as assemble_added_mass scatters them @@ -7257,15 +7340,18 @@ PURE FUNCTION unit_tangent(model, node) RESULT(t) END IF END FUNCTION unit_tangent - SUBROUTINE node_contact_normal(model, node, fc, ErrStat, ErrMsg) + SUBROUTINE node_contact_normal(model, node, fc, ErrStat, ErrMsg, clearance) !! Frictionless seabed contact force on a node at the committed state, exactly as !! assemble_contact applies it: the normal force with its damping and, in a rounded crease !! of the bathymetry, the elastic increment of the penalty potential (crease_contact_increment). + !! clearance is the node's normal distance above the height at which the contact law engages: + !! negative on the floor, positive above it. TYPE(CD_HermiteCableDynType), INTENT(IN) :: model INTEGER, INTENT(IN) :: node REAL(wp), INTENT(OUT) :: fc(3) INTEGER, INTENT(OUT) :: ErrStat CHARACTER(*), INTENT(OUT) :: ErrMsg + REAL(wp), INTENT(OUT), OPTIONAL :: clearance REAL(wp) :: z_floor, gx, gy, xg, yg, gxg, gyg, sfac, nvec(3), gap, normal, normal_gap, vn, gate, gate_gap REAL(wp) :: curv_g(3), fcrease(3), kcrease(3, 3) INTEGER :: iz, es @@ -7273,6 +7359,7 @@ SUBROUTINE node_contact_normal(model, node, fc, ErrStat, ErrMsg) CHARACTER(200) :: em2 ErrStat = CD_HCDYN_OK; ErrMsg = '' fc = CD_ZERO + IF (PRESENT(clearance)) clearance = HUGE(CD_ONE) iz = 6*(node - 1) + 3 IF (model%has_contact) THEN z_floor = model%seabed_z @@ -7293,6 +7380,7 @@ SUBROUTINE node_contact_normal(model, node, fc, ErrStat, ErrMsg) sfac = SQRT(CD_ONE + gx*gx + gy*gy) nvec = [-gx, -gy, CD_ONE]/sfac gap = (z_floor - model%q(iz))/sfac + IF (PRESENT(clearance)) clearance = -gap - CD_SEABED_CONTACT_BLEND CALL CD_Seabed_Normal_Law(gap, model%contact_kn(node), normal, normal_gap) CALL CD_Seabed_Contact_Gate(gap, gate, gate_gap) IF (normal <= CD_ZERO .AND. gate <= CD_ZERO) RETURN @@ -7308,6 +7396,7 @@ SUBROUTINE node_contact_normal(model, node, fc, ErrStat, ErrMsg) END IF ELSE IF (model%kn > CD_ZERO) THEN gap = model%seabed_z - model%q(iz) + IF (PRESENT(clearance)) clearance = -gap IF (gap > CD_ZERO) fc(3) = model%kn*gap*model%trib(node) END IF END SUBROUTINE node_contact_normal @@ -7364,7 +7453,7 @@ SUBROUTINE element_end_residual(model, e, g, ErrStat, ErrMsg) INTEGER, PARAMETER :: ZS(4) = [3, 6, 9, 12] REAL(wp) :: qe(12), ve(12), ae(12), fe(12), fx(12), energy, fdry(4), kdry(4, 4) REAL(wp) :: dry_wl, dry_b, dry_r, hf_mid(3), l0, fca(3), fcb(3), c, a4(4), m4(4, 4) - REAL(wp) :: support(3), dsupport(3), nin(3) + REAL(wp) :: support(3), dsupport(3), nin(3), xa, xb, ca(4), cb(4) INTEGER :: es, k, inode LOGICAL :: dry CHARACTER(200) :: em2 @@ -7465,20 +7554,22 @@ SUBROUTINE element_end_residual(model, e, g, ErrStat, ErrMsg) ! Seabed contact acts at the nodes; spread over the grounded line next to each node it is the ! distributed floor reaction it stands for. Its consistent share is taken out of the element, ! so a line resting on the floor carries no fixed-end moment of its own weight. A node's - ! reaction is shared by the half-elements beside it whose far node is on the floor as well - ! (grounded elements), by length. The touchdown element, on the floor at one end only, is - ! mostly suspended and takes none of it; spreading the reaction onto it understated the - ! tension of the last suspended node by the floor reaction of half an element (5 % on a - ! 10 m lazy-wave mesh). A node with no grounded element beside it (a node just touching - ! down, or an isolated contact) shares its reaction by tributary length. + ! reaction is spread uniformly over the grounded part of its two half-elements and shared + ! between them by that length (grounded_share). The touchdown element, on the floor at one + ! end only, is grounded from that end to the touchdown point, located on it from the two + ! nodes' clearances; it takes the reaction of that stretch alone (spreading the reaction over + ! its half understated the tension of the last suspended node by the floor reaction of half + ! an element, 5 % on a 10 m lazy-wave mesh). The grounded stretch grows to the half-element + ! as the suspended node reaches the floor, so the spread, and the node outputs, change + ! continuously as nodes ground and lift off. IF (model%has_contact .OR. model%kn > CD_ZERO) THEN CALL node_contact_normal(model, e, fca, es, em2) IF (es /= CD_HCDYN_OK) GOTO 900 CALL node_contact_normal(model, e + 1, fcb, es, em2) IF (es /= CD_HCDYN_OK) GOTO 900 - CALL grounded_share(e, e, fca, es) + CALL grounded_share(e, e, fca, xa, es) IF (es /= CD_HCDYN_OK) GOTO 900 - CALL grounded_share(e + 1, e, fcb, es) + CALL grounded_share(e + 1, e, fcb, xb, es) IF (es /= CD_HCDYN_OK) GOTO 900 ! A held end whose end element lies on the floor (assemble_residual): the seabed carries the ! element's weight with its consistent end moment, which the held end node's own contact @@ -7486,18 +7577,23 @@ SUBROUTINE element_end_residual(model, e, g, ErrStat, ErrMsg) ! end half of that element is the support share of its weight, uniform with the reaction ! of the neighbouring node, so that a laid end element carries no fixed-end moment. IF (e == 1) THEN - IF (held_end_floor_support(model, model%q, 1, support, dsupport, inode, nin)) & - fca = (model%w(1)*l0)*support + IF (held_end_floor_support(model, model%q, 1, support, dsupport, inode, nin)) THEN + fca = (0.5_wp*model%w(1)*l0)*support; xa = 0.5_wp + END IF END IF IF (e == model%ne) THEN - IF (held_end_floor_support(model, model%q, 2, support, dsupport, inode, nin)) & - fcb = (model%w(e)*l0)*support + IF (held_end_floor_support(model, model%q, 2, support, dsupport, inode, nin)) THEN + fcb = (0.5_wp*model%w(e)*l0)*support; xb = 0.5_wp + END IF END IF - ! integrals of the four shapes over xi in [0, 1/2] (fca) and [1/2, 1] (fcb) - g(1:3) = g(1:3) - (0.40625_wp*fca + 0.09375_wp*fcb) - g(4:6) = g(4:6) - l0*(0.0572916666666666667_wp*fca + 0.0260416666666666667_wp*fcb) - g(7:9) = g(7:9) - (0.09375_wp*fca + 0.40625_wp*fcb) - g(10:12) = g(10:12) + l0*(0.0260416666666666667_wp*fca + 0.0572916666666666667_wp*fcb) + ! the loads fca and fcb spread uniformly over xi in [0, xa] and [1 - xb, 1]: the integrals + ! of the four shapes over those stretches per unit length of xi (spread_shapes) + ca = spread_shapes(xa) + cb = spread_shapes(xb) + g(1:3) = g(1:3) - (ca(1)*fca + cb(3)*fcb) + g(4:6) = g(4:6) - l0*(ca(2)*fca - cb(4)*fcb) + g(7:9) = g(7:9) - (ca(3)*fca + cb(1)*fcb) + g(10:12) = g(10:12) - l0*(ca(4)*fca - cb(2)*fcb) END IF ae(1:6) = model%a(6*(e - 1) + 1:6*e); ae(7:12) = model%a(6*e + 1:6*(e + 1)) IF (ANY(ABS(ae) > CD_ZERO)) THEN @@ -7529,40 +7625,68 @@ SUBROUTINE element_end_residual(model, e, g, ErrStat, ErrMsg) CONTAINS - SUBROUTINE grounded_share(node, el, fc, esx) - !! Scale the floor reaction fc of node (an end of element el) to el's share of it, as the - !! factor l0(el)/(grounded length beside the node) that the half-element shape integrals - !! below expect: zero when el is not grounded but another element beside the node is, the - !! tributary-length share when no element beside the node is grounded. + SUBROUTINE grounded_share(node, el, fc, x, esx) + !! Element el's share of the floor reaction fc of node (an end of el), and the grounded + !! stretch x of el's half beside the node (a fraction of el, at most 1/2) that it is + !! spread over. Each half-element beside the node is grounded over x = 1/2 when its far + !! node is on the floor as well, and otherwise up to the touchdown point, where the + !! clearance interpolated linearly between the node (on the floor) and the far node (above + !! it) reaches the contact onset; the reaction is shared between the two halves by the + !! grounded length x l0. The touchdown point reaches the far node as that node reaches + !! the floor and the node itself as it lifts off (its reaction then vanishing), so the + !! share and the stretch are continuous in the configuration. A node off the floor with a + !! reaction (a held end the floor supports) keeps the tributary-length share over the + !! half-element. INTEGER, INTENT(IN) :: node, el REAL(wp), INTENT(INOUT) :: fc(3) + REAL(wp), INTENT(OUT) :: x INTEGER, INTENT(OUT) :: esx - REAL(wp) :: grounded_len - LOGICAL :: on_el, grounded - INTEGER :: k + REAL(wp) :: ext, ext_el, grounded_len, c_node, c_far, fdum(3) + LOGICAL :: grounded + INTEGER :: k, far esx = CD_HCDYN_OK + x = 0.5_wp IF (.NOT. ANY(ABS(fc) > CD_ZERO)) RETURN + CALL node_contact_normal(model, node, fdum, esx, em2, clearance=c_node) + IF (esx /= CD_HCDYN_OK) RETURN grounded_len = CD_ZERO - on_el = .FALSE. + ext_el = CD_ZERO DO k = MAX(1, node - 1), MIN(model%ne, node) CALL element_on_floor(k, grounded, esx) IF (esx /= CD_HCDYN_OK) RETURN IF (grounded) THEN - grounded_len = grounded_len + 0.5_wp*model%l0(k) - IF (k == el) on_el = .TRUE. + ext = 0.5_wp + ELSE + far = MERGE(k, k + 1, k == node - 1) + CALL node_contact_normal(model, far, fdum, esx, em2, clearance=c_far) + IF (esx /= CD_HCDYN_OK) RETURN + ext = CD_ZERO + IF (c_node < CD_ZERO .AND. c_far > c_node) ext = MIN(0.5_wp, -c_node/(c_far - c_node)) END IF + grounded_len = grounded_len + ext*model%l0(k) + IF (k == el) ext_el = ext END DO IF (grounded_len > CD_ZERO) THEN - IF (on_el) THEN - fc = fc*model%l0(el)/grounded_len - ELSE - fc = CD_ZERO - END IF + fc = fc*(ext_el*model%l0(el)/grounded_len) + x = ext_el ELSE IF (model%trib(node) > CD_ZERO) THEN - fc = fc*model%l0(el)/model%trib(node) + fc = fc*(0.5_wp*model%l0(el)/model%trib(node)) END IF END SUBROUTINE grounded_share + PURE FUNCTION spread_shapes(xs) RESULT(cs) + !! Integrals of the cubic Hermite shapes H1, H2/l0, H3, H4/l0 over xi in [0, xs], divided + !! by xs: the consistent loads of a unit load spread uniformly over that stretch (a point + !! load at xi = 0 as xs goes to zero). A stretch [1 - xs, 1] at the other end takes + !! [cs(3), -cs(4), cs(1), -cs(2)]. + REAL(wp), INTENT(IN) :: xs + REAL(wp) :: cs(4) + cs(1) = CD_ONE - xs*xs + 0.5_wp*xs**3 + cs(2) = 0.5_wp*xs - 2.0_wp*xs*xs/3.0_wp + 0.25_wp*xs**3 + cs(3) = xs*xs - 0.5_wp*xs**3 + cs(4) = -xs*xs/3.0_wp + 0.25_wp*xs**3 + END FUNCTION spread_shapes + SUBROUTINE element_on_floor(k, grounded, esx) !! Element k is grounded when both its nodes are on the floor (node_on_floor). INTEGER, INTENT(IN) :: k @@ -7722,25 +7846,36 @@ SUBROUTINE CD_HermiteCable_Dyn_EndConnection_Moment(model, node, moment, ErrStat ! G0 is the unconstrained dynamic residual. The constraint contribution ! required in the residual is -G0 in the transverse tangent plane; under ! virtual work, m cross that contribution is the line's moment on the - ! supporting body, matching the finite-spring convention. - CALL assemble_residual(model, model%q, model%v, model%t, .TRUE., .FALSE., es, em) - IF (es /= CD_HCDYN_OK) THEN - ErrStat = es - ErrMsg = 'CD_HermiteCable_Dyn_EndConnection_Moment: '//TRIM(em) - RETURN - END IF - model%ws_Msumb = model%Mgb - IF (model%has_am) THEN - CALL assemble_added_mass(model, model%q, es, em) + ! supporting body, matching the finite-spring convention. Only the end tangent's three + ! rows are needed: without torsion (which couples every element) they come from the + ! elements at the node, bit-identical to the full assembly (node_reaction). + IF (model%torsion%active) THEN + CALL assemble_residual(model, model%q, model%v, model%t, .TRUE., .FALSE., es, em) + IF (es /= CD_HCDYN_OK) THEN + ErrStat = es + ErrMsg = 'CD_HermiteCable_Dyn_EndConnection_Moment: '//TRIM(em) + RETURN + END IF + model%ws_Msumb = model%Mgb + IF (model%has_am) THEN + CALL assemble_added_mass(model, model%q, es, em) + IF (es /= CD_HCDYN_OK) THEN + ErrStat = es + ErrMsg = 'CD_HermiteCable_Dyn_EndConnection_Moment: '//TRIM(em) + RETURN + END IF + model%ws_Msumb = model%ws_Msumb + model%ws_Mamb + END IF + CALL band_matvec(model%ws_Msumb, model%a, model%ws_inert) + f_ec = -(model%ws_inert(base + 1:base + 3) + model%ws_R(base + 1:base + 3)) + ELSE + CALL node_reaction(model, node, f_ec, es, em, tangent_rows=.TRUE.) IF (es /= CD_HCDYN_OK) THEN ErrStat = es ErrMsg = 'CD_HermiteCable_Dyn_EndConnection_Moment: '//TRIM(em) RETURN END IF - model%ws_Msumb = model%ws_Msumb + model%ws_Mamb END IF - CALL band_matvec(model%ws_Msumb, model%a, model%ws_inert) - f_ec = -(model%ws_inert(base + 1:base + 3) + model%ws_R(base + 1:base + 3)) direction = model%endconn_d0(:, iend) f_ec = f_ec - DOT_PRODUCT(f_ec, direction)*direction END IF @@ -8275,7 +8410,8 @@ SUBROUTINE CD_HermiteCable_Dyn_End(model) DEALLOCATE (model%ws_ipiv) DEALLOCATE (model%ws_elem_f, model%ws_elem_K, model%ws_elem_Kdrag, model%ws_elem_Kv, & model%ws_elem_Kwave, model%ws_elem_Kheld, & - model%ws_elem_es, model%ws_elem_em) + model%ws_elem_es, model%ws_elem_em, model%ws_stash_q, model%ws_stash_v) + model%ws_stash_ok = .FALSE. END IF IF (ALLOCATED(model%rc_q)) DEALLOCATE (model%rc_q, model%rc_v, model%rc_a, model%rc_g, model%rc_have, model%rc_qnb) model%rc_key_ok = .FALSE. @@ -8365,7 +8501,7 @@ END SUBROUTINE CD_HermiteCable_Dyn_End ! ------------------------------------------------------------------------------------------ SUBROUTINE assemble_residual(model, q_cfg, v_cfg, t_eval, want_residual, want_tangent, ErrStat, ErrMsg, & - endconn_direction_eval, node_only, R_out) + endconn_direction_eval, node_only, R_out, stash_tangent, use_stash) !! Residual R = f_int(q) - f_ext(q, v, t), banded position tangent Kb = dR/dq, and banded !! velocity tangent Kvb = dR/dv at configuration q_cfg with nodal velocity v_cfg at time !! t_eval (LAPACK band layout, see the module note), written into the MODEL'S OWN @@ -8397,11 +8533,25 @@ SUBROUTINE assemble_residual(model, q_cfg, v_cfg, t_eval, want_residual, want_ta ! (which couples every element). The other rows of R_out are partial. INTEGER, INTENT(IN), OPTIONAL :: node_only REAL(wp), INTENT(INOUT), TARGET, OPTIONAL :: R_out(:) + ! stash_tangent: a full residual-only assembly that evaluates each element kernel once for + ! its load AND its tangent (evaluate_tangent_element with forces, in parallel like the + ! tangent assembly), adds the loads to R in the order of the residual-only assembly and keeps + ! the element tangent blocks (ws_stash_ok). R is bit-for-bit that of the residual-only + ! assembly. If any element evaluation fails (a tangent can overflow where the load stays + ! finite), this assembly evaluates the loads again residual-only, so its result and message + ! are those of the residual-only assembly, and keeps nothing. + ! use_stash: a tangent-only assembly at exactly the configuration, velocity and time of the + ! last assembly, when that one kept its element tangents, scatters those blocks instead of + ! evaluating the kernels again. Otherwise it evaluates them as usual. + LOGICAL, INTENT(IN), OPTIONAL :: stash_tangent, use_stash REAL(wp), POINTER :: R(:), Kb(:, :), Kvb(:, :) INTEGER :: ne, e, a, gi, es, omp_threads INTEGER :: e_lo, e_hi, n_lo, n_hi ! the elements and nodes assembled (all unless node_only) INTEGER(INT64) :: asm_t ! clock at the last section mark (asm_mark; profiled runs only) LOGICAL :: tangent_only + LOGICAL :: stash ! this residual assembly keeps its element tangents (stash_tangent) + LOGICAL :: kept ! the element loads and tangents of this assembly's kernels are in ws_elem_* + LOGICAL :: reuse ! this tangent assembly scatters the element tangents the last one kept REAL(wp) :: qe(12), ve(12), Ee, fe(12), Ke(12, 12), pen REAL(wp) :: fdrag(12), djq(12, 12), djv(12, 12), ffk(12), fjq(12, 12) REAL(wp) :: fdamp(12), kdq(12, 12), kdv(12, 12) @@ -8424,6 +8574,29 @@ SUBROUTINE assemble_residual(model, q_cfg, v_cfg, t_eval, want_residual, want_ta !$ omp_threads = MIN(4, omp_get_max_threads()) !$ IF (omp_in_parallel()) omp_threads = 1 tangent_only = want_tangent .AND. .NOT. want_residual + ! The kept element tangents belong to the last assembly alone: decide whether this tangent + ! assembly is at its exact state, then drop them (a keeping assembly sets them on success). + reuse = .FALSE. + IF (PRESENT(use_stash)) THEN + IF (use_stash .AND. tangent_only .AND. model%ws_stash_ok) THEN + reuse = bits_equal(t_eval, model%ws_stash_t) .AND. SIZE(q_cfg) == SIZE(model%ws_stash_q) .AND. & + SIZE(v_cfg) == SIZE(model%ws_stash_v) + IF (reuse) THEN + DO gi = 1, SIZE(q_cfg) + IF (.NOT. (bits_equal(q_cfg(gi), model%ws_stash_q(gi)) .AND. & + bits_equal(v_cfg(gi), model%ws_stash_v(gi)))) THEN + reuse = .FALSE. + EXIT + END IF + END DO + END IF + END IF + END IF + model%ws_stash_ok = .FALSE. + stash = .FALSE. + IF (PRESENT(stash_tangent)) stash = stash_tangent .AND. want_residual .AND. .NOT. want_tangent .AND. & + .NOT. PRESENT(node_only) .AND. .NOT. PRESENT(R_out) + kept = .FALSE. R => model%ws_R Kb => model%ws_Kb Kvb => model%ws_Kvb @@ -8452,27 +8625,56 @@ SUBROUTINE assemble_residual(model, q_cfg, v_cfg, t_eval, want_residual, want_ta IF (prof_enabled) CALL SYSTEM_CLOCK(asm_t) IF (want_residual) R = CD_ZERO IF (want_tangent) THEN - Kb = CD_ZERO; Kvb = CD_ZERO + ! the stored band only: the fill-in rows above it are never written (BAND_TOP_D) + Kb(BAND_TOP_D:, :) = CD_ZERO; Kvb(BAND_TOP_D:, :) = CD_ZERO END IF CALL asm_mark(HC_ASM_ZERO, asm_t) ! Tangent-only element kernels are independent. Evaluate them in parallel into persistent - ! buffers, then validate and scatter serially in the original element order. Residual and - ! combined-output requests retain the lower-overhead serial path. A four-thread cap avoids + ! buffers, then validate and scatter serially in the original element order. Plain residual + ! and combined-output requests retain the lower-overhead serial path. A four-thread cap avoids ! tiny-kernel oversubscription while respecting a smaller host OpenMP thread limit. - IF (tangent_only) THEN - !$OMP PARALLEL DEFAULT(SHARED) PRIVATE(qe) NUM_THREADS(omp_threads) IF(ne >= 32) + ! A residual assembly that keeps its element tangents (stash) runs the same parallel + ! kernels with their loads; the loads then enter R serially, phase by phase, in the + ! element order of the residual-only assembly below. A tangent assembly at the kept + ! state (reuse) scatters the kept blocks. + IF (stash) THEN + !$OMP PARALLEL DEFAULT(SHARED) NUM_THREADS(omp_threads) IF(ne >= 32) CALL CD_Fatal_Thread_Init() ! this thread can report its own stack overflow !$OMP DO SCHEDULE(STATIC) DO e = 1, ne CALL evaluate_tangent_element(model, e, q_cfg, v_cfg, t_eval, model%ws_elem_K(:, :, e), & model%ws_elem_Kdrag(:, :, e), model%ws_elem_Kv(:, :, e), & model%ws_elem_Kwave(:, :, e), model%ws_elem_Kheld(:, :, e), & - model%ws_elem_es(e), model%ws_elem_em(e)) + model%ws_elem_es(e), model%ws_elem_em(e), & + forces=model%ws_elem_f(:, :, e)) END DO !$OMP END DO !$OMP END PARALLEL CALL asm_mark(HC_ASM_TAN_KERNELS, asm_t) + kept = .TRUE. + DO e = 1, ne + IF (model%ws_elem_es(e) /= CD_HCABLE_OK) THEN + kept = .FALSE. + EXIT + END IF + END DO + END IF + IF (tangent_only) THEN + IF (.NOT. reuse) THEN + !$OMP PARALLEL DEFAULT(SHARED) PRIVATE(qe) NUM_THREADS(omp_threads) IF(ne >= 32) + CALL CD_Fatal_Thread_Init() ! this thread can report its own stack overflow + !$OMP DO SCHEDULE(STATIC) + DO e = 1, ne + CALL evaluate_tangent_element(model, e, q_cfg, v_cfg, t_eval, model%ws_elem_K(:, :, e), & + model%ws_elem_Kdrag(:, :, e), model%ws_elem_Kv(:, :, e), & + model%ws_elem_Kwave(:, :, e), model%ws_elem_Kheld(:, :, e), & + model%ws_elem_es(e), model%ws_elem_em(e)) + END DO + !$OMP END DO + !$OMP END PARALLEL + CALL asm_mark(HC_ASM_TAN_KERNELS, asm_t) + END IF DO e = 1, ne IF (model%ws_elem_es(e) /= CD_HCABLE_OK) THEN ErrStat = CD_HCDYN_NOCONVERGE; ErrMsg = 'element: '//TRIM(model%ws_elem_em(e)); RETURN @@ -8482,6 +8684,13 @@ SUBROUTINE assemble_residual(model, q_cfg, v_cfg, t_eval, want_residual, want_ta CALL asm_mark(HC_ASM_SCATTER, asm_t) ELSE DO e = e_lo, e_hi + IF (kept) THEN + DO a = 1, 12 + gi = elem_gdof(e, a) + R(gi) = R(gi) + model%ws_elem_f(a, 1, e) + END DO + CYCLE + END IF qe(1:3) = q_cfg(6*(e - 1) + 1:6*(e - 1) + 3) qe(4:6) = q_cfg(6*(e - 1) + 4:6*(e - 1) + 6) qe(7:9) = q_cfg(6*e + 1:6*e + 3) @@ -8636,6 +8845,13 @@ SUBROUTINE assemble_residual(model, q_cfg, v_cfg, t_eval, want_residual, want_ta ! reference-arc Hermite interpolation and axial quadrature as the elastic resultant. IF (model%has_axial_damping .AND. .NOT. tangent_only) THEN DO e = e_lo, e_hi + IF (kept) THEN + DO a = 1, 12 + gi = elem_gdof(e, a) + R(gi) = R(gi) + model%ws_elem_f(a, 2, e) + END DO + CYCLE + END IF qe(1:3) = q_cfg(6*(e - 1) + 1:6*(e - 1) + 3); qe(4:6) = q_cfg(6*(e - 1) + 4:6*(e - 1) + 6) qe(7:9) = q_cfg(6*e + 1:6*e + 3); qe(10:12) = q_cfg(6*e + 4:6*e + 6) ve(1:3) = v_cfg(6*(e - 1) + 1:6*(e - 1) + 3); ve(4:6) = v_cfg(6*(e - 1) + 4:6*(e - 1) + 6) @@ -8682,6 +8898,13 @@ SUBROUTINE assemble_residual(model, q_cfg, v_cfg, t_eval, want_residual, want_ta ! Kv -= djv over all 12 element DOFs. IF (model%has_drag .AND. .NOT. tangent_only) THEN DO e = e_lo, e_hi + IF (kept) THEN + DO a = 1, 12 + gi = elem_gdof(e, a) + R(gi) = R(gi) - model%ws_elem_f(a, 3, e) + END DO + CYCLE + END IF qe(1:3) = q_cfg(6*(e - 1) + 1:6*(e - 1) + 3); qe(4:6) = q_cfg(6*(e - 1) + 4:6*(e - 1) + 6) qe(7:9) = q_cfg(6*e + 1:6*e + 3); qe(10:12) = q_cfg(6*e + 4:6*e + 6) ve(1:3) = v_cfg(6*(e - 1) + 1:6*(e - 1) + 3); ve(4:6) = v_cfg(6*(e - 1) + 4:6*(e - 1) + 6) @@ -8760,6 +8983,13 @@ SUBROUTINE assemble_residual(model, q_cfg, v_cfg, t_eval, want_residual, want_ta ! Cross-flow VIV lift (an external load like the drag, at the step's phase viv_phi_eval). IF (model%has_viv .AND. .NOT. tangent_only) THEN DO e = e_lo, e_hi + IF (kept) THEN + DO a = 1, 12 + gi = elem_gdof(e, a) + R(gi) = R(gi) - model%ws_elem_f(a, 4, e) + END DO + CYCLE + END IF IF (want_tangent) THEN CALL viv_element_lift(model, q_cfg, v_cfg, e, fdrag, es, em_e, djq, djv) ELSE @@ -8814,6 +9044,13 @@ SUBROUTINE assemble_residual(model, q_cfg, v_cfg, t_eval, want_residual, want_ta ! the wave-field spatial gradient is neglected in K -- see the element note). IF (model%has_wave .AND. model%has_am .AND. .NOT. tangent_only) THEN DO e = e_lo, e_hi + IF (kept) THEN + DO a = 1, 12 + gi = elem_gdof(e, a) + R(gi) = R(gi) - model%ws_elem_f(a, 5, e) + END DO + CYCLE + END IF qe(1:3) = q_cfg(6*(e - 1) + 1:6*(e - 1) + 3); qe(4:6) = q_cfg(6*(e - 1) + 4:6*(e - 1) + 6) qe(7:9) = q_cfg(6*e + 1:6*e + 3); qe(10:12) = q_cfg(6*e + 4:6*e + 6) IF (model%wv_ncomp > 0) THEN @@ -8868,6 +9105,13 @@ SUBROUTINE assemble_residual(model, q_cfg, v_cfg, t_eval, want_residual, want_ta ! configuration's coefficients -- the held-mode twin of the wave FK block above. IF (model%has_held_field .AND. model%has_am .AND. .NOT. tangent_only) THEN DO e = e_lo, e_hi + IF (kept) THEN + DO a = 1, 12 + gi = elem_gdof(e, a) + R(gi) = R(gi) - model%ws_elem_f(a, 6, e) + END DO + CYCLE + END IF qe(1:3) = q_cfg(6*(e - 1) + 1:6*(e - 1) + 3); qe(4:6) = q_cfg(6*(e - 1) + 4:6*(e - 1) + 6) qe(7:9) = q_cfg(6*e + 1:6*e + 3); qe(10:12) = q_cfg(6*e + 4:6*e + 6) IF (want_tangent) THEN @@ -8922,6 +9166,13 @@ SUBROUTINE assemble_residual(model, q_cfg, v_cfg, t_eval, want_residual, want_ta END IF END IF CALL asm_mark(HC_ASM_TORSION, asm_t) + ! A complete keeping assembly records the state its element tangents belong to. + IF (kept) THEN + model%ws_stash_q = q_cfg + model%ws_stash_v = v_cfg + model%ws_stash_t = t_eval + model%ws_stash_ok = .TRUE. + END IF END SUBROUTINE assemble_residual SUBROUTINE assemble_torsion(model, q_cfg, want_residual, want_tangent, ErrStat, ErrMsg) @@ -10164,10 +10415,16 @@ SUBROUTINE scatter_contact_band(ab, row_dof, col_dof, value) END SUBROUTINE scatter_contact_band SUBROUTINE evaluate_tangent_element(model, e, q_cfg, v_cfg, t_eval, Kstruct, Kdrag, Kvel, Kwave, Kheld, & - ErrStat, ErrMsg) + ErrStat, ErrMsg, forces) !! Evaluate the complete element-local Newton package. Keeping structural, drag and !! fluid-inertia tangents in one worker avoids three OpenMP regions per iteration; !! the caller scatters these private blocks in deterministic element order. + !! forces (optional) also returns the element load of each kernel from the same call: + !! forces(:, k) for k = 1 structure (f_int), 2 axial damping, 3 drag, 4 VIV lift, 5 wave and + !! 6 held Froude-Krylov (the loads as the kernels return them, before the residual's signs). + !! Every kernel forms its load by the same statements with or without its tangent, so these + !! are bit-for-bit the loads of a residual-only evaluation. The columns of the kernels the + !! model does not configure are not defined. TYPE(CD_HermiteCableDynType), INTENT(IN) :: model INTEGER, INTENT(IN) :: e REAL(wp), INTENT(IN) :: q_cfg(:), v_cfg(:), t_eval @@ -10175,6 +10432,7 @@ SUBROUTINE evaluate_tangent_element(model, e, q_cfg, v_cfg, t_eval, Kstruct, Kdr REAL(wp), INTENT(OUT) :: Kwave(12, 12), Kheld(12, 12) INTEGER, INTENT(OUT) :: ErrStat CHARACTER(*), INTENT(OUT) :: ErrMsg + REAL(wp), INTENT(OUT), OPTIONAL :: forces(12, 6) REAL(wp) :: qe(12), ve(12), energy, force(12), fload(12) REAL(wp) :: djq(12, 12), djv(12, 12), fjq(12, 12) @@ -10190,12 +10448,22 @@ SUBROUTINE evaluate_tangent_element(model, e, q_cfg, v_cfg, t_eval, Kstruct, Kdr qe(7:12) = q_cfg(6*e + 1:6*(e + 1)) ve(1:6) = v_cfg(6*(e - 1) + 1:6*e) ve(7:12) = v_cfg(6*e + 1:6*(e + 1)) - Kdrag = CD_ZERO; Kvel = CD_ZERO; Kwave = CD_ZERO; Kheld = CD_ZERO - - CALL CD_HermiteCable_Element(qe, model%l0(e), model%EA(e), model%EI(e), energy, force, Kstruct, es, em, & - symmetric_half=.TRUE., tangent_only=.TRUE., & - axial_quadrature_order=model%axial_quadrature_order, & - bending_quadrature_order=model%bending_quadrature_order) + ! Kdrag and Kvel accumulate their contributors from zero. Kwave and Kheld are each set + ! whole by their one contributor below and read (scattered) only when it is configured, + ! so they are not cleared. + Kdrag = CD_ZERO; Kvel = CD_ZERO + + IF (PRESENT(forces)) THEN + CALL CD_HermiteCable_Element(qe, model%l0(e), model%EA(e), model%EI(e), energy, forces(:, 1), Kstruct, & + es, em, symmetric_half=.TRUE., & + axial_quadrature_order=model%axial_quadrature_order, & + bending_quadrature_order=model%bending_quadrature_order) + ELSE + CALL CD_HermiteCable_Element(qe, model%l0(e), model%EA(e), model%EI(e), energy, force, Kstruct, es, em, & + symmetric_half=.TRUE., tangent_only=.TRUE., & + axial_quadrature_order=model%axial_quadrature_order, & + bending_quadrature_order=model%bending_quadrature_order) + END IF IF (es /= CD_HCABLE_OK) THEN ErrStat = CD_HCDYN_NOCONVERGE; ErrMsg = 'element: '//TRIM(em); RETURN END IF @@ -10213,6 +10481,7 @@ SUBROUTINE evaluate_tangent_element(model, e, q_cfg, v_cfg, t_eval, Kstruct, Kdr IF (es /= CD_HCDYN_OK) THEN ErrStat = CD_HCDYN_NOCONVERGE; ErrMsg = TRIM(em); RETURN END IF + IF (PRESENT(forces)) forces(:, 2) = fload Kdrag = Kdrag + djq Kvel = Kvel + djv END IF @@ -10244,6 +10513,7 @@ SUBROUTINE evaluate_tangent_element(model, e, q_cfg, v_cfg, t_eval, Kstruct, Kdr IF (es /= CD_HCDYN_OK) THEN ErrStat = es; ErrMsg = TRIM(em); RETURN END IF + IF (PRESENT(forces)) forces(:, 3) = fload Kdrag = Kdrag - djq Kvel = Kvel - djv END IF @@ -10253,6 +10523,7 @@ SUBROUTINE evaluate_tangent_element(model, e, q_cfg, v_cfg, t_eval, Kstruct, Kdr IF (es /= CD_HCDYN_OK) THEN ErrStat = es; ErrMsg = TRIM(em); RETURN END IF + IF (PRESENT(forces)) forces(:, 4) = fload Kdrag = Kdrag - djq Kvel = Kvel - djv END IF @@ -10275,6 +10546,7 @@ SUBROUTINE evaluate_tangent_element(model, e, q_cfg, v_cfg, t_eval, Kstruct, Kdr IF (es /= CD_HCDYN_OK) THEN ErrStat = es; ErrMsg = TRIM(em); RETURN END IF + IF (PRESENT(forces)) forces(:, 5) = fload Kwave = -fjq END IF @@ -10290,6 +10562,7 @@ SUBROUTINE evaluate_tangent_element(model, e, q_cfg, v_cfg, t_eval, Kstruct, Kdr IF (es /= CD_HCDYN_OK) THEN ErrStat = es; ErrMsg = TRIM(em); RETURN END IF + IF (PRESENT(forces)) forces(:, 6) = fload Kheld = -fjq END IF END SUBROUTINE evaluate_tangent_element @@ -10380,8 +10653,8 @@ SUBROUTINE CD_HermiteCable_Axial_Damping_Element(qe, ve, l0, BA, fdamp, Kq, Kv, REAL(wp), INTENT(IN), OPTIONAL :: l0_dot REAL(wp) :: gp(6), gw(6), H(4), dH(4) - REAL(wp) :: r_xi(3), v_xi(3), tangent(3), pperp(3), projector(3, 3) - REAL(wp) :: speed, strain_rate, scale_q, scale_v, rate_ratio + REAL(wp) :: r_xi(3), v_xi(3), tangent(3), pperp(3), projector(3, 3), kq3(3, 3) + REAL(wp) :: speed, strain_rate, scale_q, scale_v, scale_r, rate_ratio INTEGER :: order, ig, s, sp, c, cp, ia, ib ErrStat = CD_HCDYN_OK @@ -10437,25 +10710,34 @@ SUBROUTINE CD_HermiteCable_Axial_Damping_Element(qe, ve, l0, BA, fdamp, Kq, Kv, END DO END DO pperp = MATMUL(projector, v_xi) + ! the 3 x 3 factor of the position Jacobian, formed once per Gauss point + DO cp = 1, 3 + DO c = 1, 3 + kq3(c, cp) = strain_rate*projector(c, cp) + tangent(c)*pperp(cp)/l0 + END DO + END DO DO s = 1, 4 DO c = 1, 3 ia = 3*(s - 1) + c fdamp(ia) = fdamp(ia) + gw(ig)*BA*strain_rate*dH(s)*tangent(c) - DO sp = 1, 4 - DO cp = 1, 3 - ib = 3*(sp - 1) + cp - IF (PRESENT(Kv)) THEN - scale_v = gw(ig)*BA*dH(s)*dH(sp)/l0 - Kv(ia, ib) = Kv(ia, ib) + scale_v*tangent(c)*tangent(cp) - END IF + END DO + END DO + DO sp = 1, 4 + DO s = 1, 4 + scale_v = gw(ig)*BA*dH(s)*dH(sp)/l0 + scale_q = gw(ig)*BA*dH(s)*dH(sp)/speed + scale_r = gw(ig)*BA*dH(s)*dH(sp)*(rate_ratio/l0) + DO cp = 1, 3 + ib = 3*(sp - 1) + cp + DO c = 1, 3 + ia = 3*(s - 1) + c + IF (PRESENT(Kv)) Kv(ia, ib) = Kv(ia, ib) + scale_v*tangent(c)*tangent(cp) IF (PRESENT(Kq)) THEN - scale_q = gw(ig)*BA*dH(s)*dH(sp)/speed - Kq(ia, ib) = Kq(ia, ib) + scale_q*(strain_rate*projector(c, cp) + & - tangent(c)*pperp(cp)/l0) + Kq(ia, ib) = Kq(ia, ib) + scale_q*kq3(c, cp) ! the length-rate term depends on the end positions (sp = 1, 3) only IF (PRESENT(l0_dot) .AND. MOD(sp, 2) == 1) & - Kq(ia, ib) = Kq(ia, ib) - gw(ig)*BA*dH(s)*dH(sp)*(rate_ratio/l0)*tangent(c)*tangent(cp) + Kq(ia, ib) = Kq(ia, ib) - scale_r*tangent(c)*tangent(cp) END IF END DO END DO @@ -10534,7 +10816,7 @@ SUBROUTINE CD_HermiteCable_Drag_Element(qe, ve, l0, fluid, waterline_z, rho, dia REAL(wp), PARAMETER :: G3 = 0.7745966692414834_wp ! sqrt(3/5) REAL(wp) :: gp(NGP), gw(NGP), H(4), dH(4) REAL(wp) :: rpos(3), vvel(3), rp(3), speed, tangent(3), urel(3), fpl(3), Jrel(3, 3), Jtan(3, 3) - REAL(wp) :: scale, eta_w, uw(3), aw(3) + REAL(wp) :: jq3(3, 3), scale, eta_w, uw(3), aw(3) LOGICAL :: has_wv, has_shared, has_trio, has_cmp, any_wv_arg, want_jac INTEGER :: g, s, c, sp, cp, a, b, es ! the message of a per-Gauss-point CableDyn_Hydro kinematics or Morison call (at most 154 @@ -10639,12 +10921,15 @@ SUBROUTINE CD_HermiteCable_Drag_Element(qe, ve, l0, fluid, waterline_z, rho, dia IF (has_wv) urel = urel + uw ! Pass the raw dr/dxi as the tangent vector: the primitive normalises it and returns Jtan = ! d f_perlen / d(dr/dxi), so d f_perlen/d qe folds in through d(dr/dxi)/d qe = dH directly. + ! rho, diam, cdn and cdt were validated above, before the Gauss loop. IF (want_jac) THEN - CALL CD_Morison_Drag_Per_Length_Jac(urel, rp, rho, diam, cdn, cdt, fpl, Jrel, Jtan, es, em2) + CALL CD_Morison_Drag_Per_Length_Jac(urel, rp, rho, diam, cdn, cdt, fpl, Jrel, Jtan, es, em2, & + scalars_validated=.TRUE.) ELSE ! same primitive without the Jacobian pair: the force statements are identical, so ! the residual-only trial force is bit-for-bit the with-Jacobian force. - CALL CD_Morison_Drag_Per_Length_Jac(urel, rp, rho, diam, cdn, cdt, fpl, ErrStat=es, ErrMsg=em2) + CALL CD_Morison_Drag_Per_Length_Jac(urel, rp, rho, diam, cdn, cdt, fpl, ErrStat=es, ErrMsg=em2, & + scalars_validated=.TRUE.) END IF IF (es /= CD_HYDRO_OK) THEN ErrStat = CD_HCDYN_NOCONVERGE; ErrMsg = 'CD_HermiteCable_Drag_Element: '//TRIM(em2); RETURN @@ -10657,6 +10942,15 @@ SUBROUTINE CD_HermiteCable_Drag_Element(qe, ve, l0, fluid, waterline_z, rho, dia END DO END DO IF (.NOT. want_jac) CYCLE + ! position: d[speed * f_perlen_c]/d qe(b) with d(dr/dxi)/d qe = dH(sp) -- + ! speed * Jtan(c,cp) * dH(sp) (force direction/tangent) + ! + f_perlen_c * d(speed)/d qe(b), d(speed)/d qe(b) = tangent(cp) dH(sp); + ! its 3 x 3 factor jq3 is formed once per Gauss point. + DO cp = 1, 3 + DO c = 1, 3 + jq3(c, cp) = speed*Jtan(c, cp) + fpl(c)*tangent(cp) + END DO + END DO DO s = 1, 4 DO c = 1, 3 a = 3*(s - 1) + c @@ -10665,10 +10959,7 @@ SUBROUTINE CD_HermiteCable_Drag_Element(qe, ve, l0, fluid, waterline_z, rho, dia b = 3*(sp - 1) + cp ! velocity: d urel/d ve(b) = -H(sp), scaled by the deformed length measure djv(a, b) = djv(a, b) - scale*H(s)*H(sp)*Jrel(c, cp) - ! position: d[speed * f_perlen_c]/d qe(b) with d(dr/dxi)/d qe = dH(sp) -- - ! speed * Jtan(c,cp) * dH(sp) (force direction/tangent) - ! + f_perlen_c * d(speed)/d qe(b), d(speed)/d qe(b) = tangent(cp) dH(sp) - djq(a, b) = djq(a, b) + gw(g)*H(s)*dH(sp)*(speed*Jtan(c, cp) + fpl(c)*tangent(cp)) + djq(a, b) = djq(a, b) + gw(g)*H(s)*dH(sp)*jq3(c, cp) END DO END DO END DO @@ -10882,7 +11173,7 @@ SUBROUTINE CD_HermiteCable_FK_Element(qe, l0, waterline_z, rho, diam, can, cat, REAL(wp), PARAMETER :: PI_L = 3.14159265358979323846_wp REAL(wp) :: gp(NGP), gw(NGP), H(4), dH(4) REAL(wp) :: rpos(3), rp(3), speed, tangent(3), eta_w, uw(3), aw(3), area, alpha - REAL(wp) :: fpl(3), Jtan(3, 3), proj(3, 3), projk(3), dalpha + REAL(wp) :: fpl(3), Jtan(3, 3), proj(3, 3), projk(3), dalpha, jq3(3, 3) LOGICAL :: has_trio, has_cmp, has_held, want_jac INTEGER :: g, s, c, sp, cp, a, b, k, es ! the message of a per-Gauss-point CableDyn_Hydro kinematics call (at most 154 characters): a @@ -11025,14 +11316,20 @@ SUBROUTINE CD_HermiteCable_FK_Element(qe, l0, waterline_z, rho, diam, can, cat, END DO END DO IF (.NOT. want_jac) CYCLE + ! d[speed * fpl_c]/d qe(b): the tangent chain plus the length-measure derivative, with + ! its 3 x 3 factor jq3 formed once per Gauss point. + DO cp = 1, 3 + DO c = 1, 3 + jq3(c, cp) = speed*Jtan(c, cp) + fpl(c)*tangent(cp) + END DO + END DO DO s = 1, 4 DO c = 1, 3 a = 3*(s - 1) + c DO sp = 1, 4 DO cp = 1, 3 b = 3*(sp - 1) + cp - ! d[speed * fpl_c]/d qe(b): the tangent chain plus the length-measure derivative. - fjq(a, b) = fjq(a, b) + gw(g)*H(s)*dH(sp)*(speed*Jtan(c, cp) + fpl(c)*tangent(cp)) + fjq(a, b) = fjq(a, b) + gw(g)*H(s)*dH(sp)*jq3(c, cp) END DO END DO END DO @@ -11063,7 +11360,8 @@ SUBROUTINE assemble_added_mass(model, q_cfg, ErrStat, ErrMsg) REAL(wp) :: Me(12, 12) CHARACTER(1024) :: em2 ErrStat = CD_HCDYN_OK; ErrMsg = '' - model%ws_Mamb = CD_ZERO + ! the stored band only: the fill-in rows above it stay zero (BAND_TOP_D) + model%ws_Mamb(BAND_TOP_D:, :) = CD_ZERO IF (.NOT. model%has_am) RETURN DO e = 1, model%ne CALL added_mass_element(model, q_cfg, e, Me, es, em2) @@ -11075,7 +11373,7 @@ SUBROUTINE assemble_added_mass(model, q_cfg, ErrStat, ErrMsg) ! Every element matrix can be finite while two adjacent contributions ! overflow at their shared-node band entry. Validate the assembled global ! operator before it is added to the structural mass or factorised. - IF (.NOT. CD_All_Finite(model%ws_Mamb)) THEN + IF (.NOT. CD_All_Finite(model%ws_Mamb(BAND_TOP_D:, :))) THEN ErrStat = CD_HCDYN_NOCONVERGE ErrMsg = 'assemble_added_mass: non-finite global added-mass matrix' END IF @@ -11231,25 +11529,44 @@ PURE SUBROUTINE vector_sum3(x, b, y, c, z, out) out = x + b*y + c*z END SUBROUTINE vector_sum3 + ! The band sweeps below take CONTIGUOUS dummies, which lets the compiler vectorise them. + ! Every caller passes whole allocatable model arrays, so no copy is ever made; an actual + ! the compiler cannot prove contiguous (a pointer, an assumed-shape dummy) would be + ! packed into a temporary at each call. They sweep the stored band rows only: the fill-in + ! rows of their operands are zero (BAND_TOP_D). + PURE SUBROUTINE band_copy(x, y) !! y = x for band storage (distinct arrays). - REAL(wp), INTENT(IN) :: x(:, :) - REAL(wp), INTENT(INOUT) :: y(:, :) - y = x + REAL(wp), CONTIGUOUS, INTENT(IN) :: x(:, :) + REAL(wp), CONTIGUOUS, INTENT(INOUT) :: y(:, :) + INTEGER :: j + DO j = 1, SIZE(x, 2) + y(BAND_TOP_D:, j) = x(BAND_TOP_D:, j) + END DO END SUBROUTINE band_copy - PURE SUBROUTINE band_add(x, y) - !! y = y + x for band storage (distinct arrays). - REAL(wp), INTENT(IN) :: x(:, :) - REAL(wp), INTENT(INOUT) :: y(:, :) - y = y + x - END SUBROUTINE band_add + PURE SUBROUTINE band_sum(x, y, out) + !! out = x + y for band storage in one sweep (out distinct from x and y). + REAL(wp), CONTIGUOUS, INTENT(IN) :: x(:, :), y(:, :) + REAL(wp), CONTIGUOUS, INTENT(INOUT) :: out(:, :) + INTEGER :: j + DO j = 1, SIZE(x, 2) + out(BAND_TOP_D:, j) = x(BAND_TOP_D:, j) + y(BAND_TOP_D:, j) + END DO + END SUBROUTINE band_sum PURE SUBROUTINE band_combine(a, x, b, y, c, z, out) - !! out = a*x + b*y + c*z for band storage (out distinct from x, y, z). - REAL(wp), INTENT(IN) :: a, b, c, x(:, :), y(:, :), z(:, :) - REAL(wp), INTENT(INOUT) :: out(:, :) - out = a*x + b*y + c*z + !! out = a*x + b*y + c*z for band storage (out distinct from x, y, z). The fill-in rows of + !! out, which a previous factorization overwrote, are reset to the zero a*0 + b*0 + c*0 + !! of the operands' fill-in rows. + REAL(wp), INTENT(IN) :: a, b, c + REAL(wp), CONTIGUOUS, INTENT(IN) :: x(:, :), y(:, :), z(:, :) + REAL(wp), CONTIGUOUS, INTENT(INOUT) :: out(:, :) + INTEGER :: j + DO j = 1, SIZE(x, 2) + out(1:BAND_TOP_D - 1, j) = CD_ZERO + out(BAND_TOP_D:, j) = a*x(BAND_TOP_D:, j) + b*y(BAND_TOP_D:, j) + c*z(BAND_TOP_D:, j) + END DO END SUBROUTINE band_combine SUBROUTINE transform_rigid_band(model, bases, matrix) @@ -11444,23 +11761,25 @@ SUBROUTINE scatter12_band(abg, Ke, e) !! Scatter a 12x12 element matrix into LAPACK general-band storage for element e !! (entry (gi, gj) at abg(KL_D + KU_D + 1 + gi - gj, gj); the chain connectivity !! keeps |gi - gj| <= 11 = KU_D, so every entry is in band by construction). + !! The element's DOFs are the 12 consecutive global DOFs from 6(e - 1) + 1 (elem_gdof), so + !! column b of Ke lands in one contiguous run of band column 6(e - 1) + b. REAL(wp), INTENT(INOUT) :: abg(:, :) REAL(wp), INTENT(IN) :: Ke(12, 12) INTEGER, INTENT(IN) :: e - INTEGER :: a, b, gi, gj - DO a = 1, 12 - gi = elem_gdof(e, a) - DO b = 1, 12 - gj = elem_gdof(e, b) - abg(KL_D + KU_D + 1 + gi - gj, gj) = abg(KL_D + KU_D + 1 + gi - gj, gj) + Ke(a, b) + INTEGER :: a, b, gj, row0 + DO b = 1, 12 + gj = 6*(e - 1) + b + row0 = KL_D + KU_D + 1 - b + DO a = 1, 12 + abg(row0 + a, gj) = abg(row0 + a, gj) + Ke(a, b) END DO END DO END SUBROUTINE scatter12_band PURE SUBROUTINE band_matvec(abg, x, y) !! y = A x for A in the module's LAPACK general-band layout. - REAL(wp), INTENT(IN) :: abg(:, :), x(:) - REAL(wp), INTENT(OUT) :: y(:) + REAL(wp), CONTIGUOUS, INTENT(IN) :: abg(:, :), x(:) + REAL(wp), CONTIGUOUS, INTENT(OUT) :: y(:) INTEGER :: i, j, n n = SIZE(x) y = CD_ZERO @@ -11475,7 +11794,7 @@ PURE SUBROUTINE dirichlet_band(abg, freemask) !! Apply Dirichlet conditions in band form: zero each fixed DOF's row and column !! within the band and set a unit diagonal, so the full-size banded solve returns !! exactly zero update at every fixed DOF (with a zero RHS slot). - REAL(wp), INTENT(INOUT) :: abg(:, :) + REAL(wp), CONTIGUOUS, INTENT(INOUT) :: abg(:, :) LOGICAL, INTENT(IN) :: freemask(:) INTEGER :: j, gi, gj, n n = SIZE(freemask) diff --git a/src/CableDyn_HermiteCableStatic.f90 b/src/CableDyn_HermiteCableStatic.f90 index 4aa6374b..6451254e 100644 --- a/src/CableDyn_HermiteCableStatic.f90 +++ b/src/CableDyn_HermiteCableStatic.f90 @@ -206,6 +206,13 @@ MODULE CableDyn_HermiteCableStatic REAL(wp) :: laid_origin(2) = 0.0_wp, laid_node1(2) = 0.0_wp REAL(wp) :: laid_azimuth = 0.0_wp, laid_tension = 0.0_wp REAL(wp) :: laid_frame_cs(2) = [1.0_wp, 0.0_wp] + ! The dry part of a laid line (laid_water_weight > 0, on a bathymetry): the nodes of a line + ! laid within its section radius of the still-water level laid_waterline_z sink under the + ! buoyancy the solver gives back there (CD_HermiteCable_As_Laid_Offsets). laid_water_weight + ! is rho g [N/m^3]; the section diameter is laid_diam on the reference-arc intervals ending + ! at laid_arc_end (cumulative rest length from node 1), so any mesh of the line looks it up. + REAL(wp) :: laid_water_weight = 0.0_wp, laid_waterline_z = 0.0_wp + REAL(wp), ALLOCATABLE :: laid_arc_end(:), laid_diam(:) END TYPE CD_HermiteStaticFrictionType TYPE, PUBLIC :: CD_HermiteStaticCurrentType @@ -302,7 +309,7 @@ SUBROUTINE CD_HermiteCable_Static_Solve(l0, EA, EI, w, seed, fixed_dofs, seabed_ waterline_z, dry_buoyancy, merit_line_search, pseudo_transient, & energy_minimization, stable, water_weight, current, residual_out, & tangent_out, friction, residual_unmet, torsion, energy_out, & - end_share_hold, f_nodal_twist) + end_share_hold, f_nodal_twist, stall_limit) !! Solve the finite-EI static equilibrium of a Hermite bending-cable line. !! !! l0(ne), EA(ne), EI(ne), w(ne) : per-element rest length, axial/bending stiffness, @@ -444,6 +451,15 @@ SUBROUTINE CD_HermiteCable_Static_Solve(l0, EA, EI, w, seed, fixed_dofs, seabed_ !! attachments in a current, evaluated at a twisted state) !! then leaves the untwisted state in equilibrium under !! f_nodal alone. + !! stall_limit (optional, >= 1) : max_iter becomes the cap of a long descent, which + !! stops (not converged) once stall_limit updates have + !! not brought the two-norm of the scaled residual below + !! half its value at the last such fall (the first: the + !! start), so after stall_limit updates without any. A + !! descent that is still converging is then not cut at a + !! fixed count; the norm, unlike the largest component + !! that decides convergence, does not change when the + !! line is turned. REAL(wp), INTENT(IN) :: l0(:), EA(:), EI(:), w(:), seed(:) INTEGER, INTENT(IN) :: fixed_dofs(:) REAL(wp), INTENT(IN) :: seabed_z, kn, tol, damping @@ -482,8 +498,13 @@ SUBROUTINE CD_HermiteCable_Static_Solve(l0, EA, EI, w, seed, fixed_dofs, seabed_ REAL(wp), INTENT(IN), OPTIONAL :: end_share_hold(2) TYPE(CD_HermiteTorsionType), INTENT(INOUT), OPTIONAL :: torsion REAL(wp), INTENT(IN), OPTIONAL :: f_nodal_twist(:) + INTEGER, INTENT(IN), OPTIONAL :: stall_limit INTEGER :: ne, nn, ndof, c, it, es, i, b, nci, n_buoy, omp_threads, axial_order, bending_order + ! stall_limit: the residual merit at the start of an update, its value at the last halving + ! of the norm, and the number of updates that had reached that state. + REAL(wp) :: merit_update, merit_fall + INTEGER :: it_fall REAL(wp) :: eifac, rnorm, fscale, bfac, rmerit, ptc_tau, ptc_rprev, pi_total, pi_abs, lm_mu, chord REAL(wp), ALLOCATABLE :: q(:), trib(:), w_cur(:), q_base(:) REAL(wp) :: endconn_k(2), endconn_d0(3, 2), direction_norm @@ -608,6 +629,11 @@ SUBROUTINE CD_HermiteCable_Static_Solve(l0, EA, EI, w, seed, fixed_dofs, seabed_ .NOT. CD_Is_Finite(damping) .OR. damping <= CD_ZERO .OR. damping > CD_ONE) THEN CALL fail('need n_cont>=1, max_iter>=1, finite tol>0, finite 0= 1'); RETURN + END IF + END IF IF (PRESENT(residual_history)) THEN IF (SIZE(residual_history) < max_iter) THEN CALL fail('residual_history must have at least max_iter entries'); RETURN @@ -1027,10 +1053,20 @@ SUBROUTINE CD_HermiteCable_Static_Solve(l0, EA, EI, w, seed, fixed_dofs, seabed_ drag_now = use_current .AND. b == n_buoy .AND. c == nci IF (PRESENT(history_count)) history_count = 0 IF (PRESENT(residual_history)) residual_history = CD_ZERO + it_fall = 0 DO it = 1, max_iter ! newton_step measures the residual at the CURRENT q and updates only when ! not yet converged, so it never over-steps a converged state. CALL newton_step(rnorm, es, ErrMsg, .TRUE.) + IF (PRESENT(stall_limit) .AND. rnorm >= tol .AND. es == CD_HCSTAT_OK) THEN + ! The norm has halved when its square (the merit) falls below a quarter. + IF (it == 1) THEN + merit_fall = merit_update + ELSE IF (merit_update < 0.25_wp*merit_fall) THEN + merit_fall = merit_update + it_fall = it - 1 + END IF + END IF ! A stall is sticky by design: every later stage then runs a single step, so the ! stage loops still end at the full load and full EI, where the final evaluation ! gives the verdict (a stalled solve ends NOCONVERGE). @@ -1046,6 +1082,9 @@ SUBROUTINE CD_HermiteCable_Static_Solve(l0, EA, EI, w, seed, fixed_dofs, seabed_ IF (PRESENT(residual_history)) residual_history(it) = rnorm IF (PRESENT(history_count)) history_count = it IF (rnorm < tol) EXIT + IF (PRESENT(stall_limit)) THEN + IF (it - it_fall >= stall_limit) EXIT + END IF END DO END DO q_sec2 = q_sec1 @@ -1443,6 +1482,7 @@ RECURSIVE SUBROUTINE newton_step(rnorm, es, em, do_update) IF (.NOT. CD_Is_Finite(rnorm)) THEN es = CD_HCSTAT_NOCONVERGE; em = 'non-finite residual'; RETURN END IF + IF (do_update) merit_update = rmerit ! Pure residual evaluation, or already at tolerance: do not step. IF (.NOT. do_update .OR. rnorm < tol) RETURN @@ -2786,7 +2826,8 @@ END SUBROUTINE fail END SUBROUTINE CD_HermiteCable_Static_Solve - SUBROUTINE CD_HermiteCable_As_Laid_Offsets(fr, l0, EA, node_load, node_kn, offsets, ErrStat, ErrMsg, bathymetry) + SUBROUTINE CD_HermiteCable_As_Laid_Offsets(fr, l0, EA, node_load, node_kn, offsets, ErrStat, ErrMsg, bathymetry, & + node_dry_load) !! As-laid friction reference of the nodes of mesh l0 (the lay of fr, laid_* above; !! CD_Static_As_Laid_Reference): node i at the stretched arc length of the elements !! l0 (1 + laid_tension/EA) along the seabed from the lower end, and on a bathymetry @@ -2795,13 +2836,20 @@ SUBROUTINE CD_HermiteCable_As_Laid_Offsets(fr, l0, EA, node_load, node_kn, offse !! turning force of the laid tension). offsets(1:2, i) is the reference of node i less !! the global position laid_node1 of node 1, in the solve frame laid_frame_cs; with !! laid_in_plane on a bathymetry only the sink offset across the chord leaves its plane. + !! node_load holds the submerged weights. On a bathymetry with fr%laid_water_weight > 0 a + !! node sinks under the normal load the solver applies at its laid position instead + !! (laid_dry_loads): with the buoyancy the line gives back on its part above the still-water + !! level fr%laid_waterline_z (CD_HermiteCable_Dry_Buoyancy of the laid centreline: a section + !! within its radius of the surface is partly dry), and node_dry_load(i) [N, downward, the + !! buoyancy of the attachments on node i] where node i is laid above that level. TYPE(CD_HermiteStaticFrictionType), INTENT(IN) :: fr REAL(wp), INTENT(IN) :: l0(:), EA(:), node_load(:), node_kn(:) REAL(wp), INTENT(OUT) :: offsets(:, :) INTEGER, INTENT(OUT) :: ErrStat CHARACTER(*), INTENT(OUT) :: ErrMsg TYPE(CD_BathymetryType), INTENT(IN), OPTIONAL :: bathymetry - REAL(wp), ALLOCATABLE :: ref_g(:, :), ref_0(:, :), wn(:), sn(:), kn_o(:), l0_r(:), ea_r(:) + REAL(wp), INTENT(IN), OPTIONAL :: node_dry_load(:) + REAL(wp), ALLOCATABLE :: ref_g(:, :), ref_0(:, :), wn(:), sn(:), kn_o(:), l0_r(:), ea_r(:), load(:) REAL(wp) :: dg(2), dg0(2), cs(2) INTEGER :: k, ne, es CHARACTER(1024) :: em @@ -2816,13 +2864,26 @@ SUBROUTINE CD_HermiteCable_As_Laid_Offsets(fr, l0, EA, node_load, node_kn, offse ErrStat = CD_HCSTAT_BADINPUT; ErrMsg = 'as-laid friction reference: nodal loads and stiffnesses must be finite' RETURN END IF + IF (PRESENT(node_dry_load)) THEN + IF (SIZE(node_dry_load) /= ne + 1 .OR. .NOT. CD_All_Finite(node_dry_load)) THEN + ErrStat = CD_HCSTAT_BADINPUT + ErrMsg = 'as-laid friction reference: node_dry_load must be finite, one entry per node'; RETURN + END IF + END IF offsets = CD_ZERO ALLOCATE (ref_g(2, ne + 1)) IF (PRESENT(bathymetry)) THEN + load = node_load + IF (fr%laid_water_weight > CD_ZERO) THEN + CALL laid_dry_loads(load, es, em) + IF (es /= CD_HCSTAT_OK) THEN + ErrStat = CD_HCSTAT_BADINPUT; ErrMsg = 'as-laid friction reference: '//TRIM(em); RETURN + END IF + END IF ! the static penalty penetration factor w_i/k_i of every node ALLOCATE (wn(ne + 1)) WHERE (node_kn > CD_ZERO) - wn = MAX(node_load, CD_ZERO)/node_kn + wn = MAX(load, CD_ZERO)/node_kn ELSEWHERE wn = CD_ZERO END WHERE @@ -2870,6 +2931,156 @@ SUBROUTINE CD_HermiteCable_As_Laid_Offsets(fr, l0, EA, node_load, node_kn, offse offsets(2, k) = (-cs(2)*dg(1) + cs(1)*dg(2)) - (-cs(2)*dg0(1) + cs(1)*dg0(2)) END IF END DO + + CONTAINS + + SUBROUTINE laid_dry_loads(nl, esd, emd) + !! The nodal loads nl (the submerged weights on entry) as the static solve and the dynamics + !! apply them to a node resting at its laid position: the line laid without its sink, the + !! seabed under every node, the tangent along the laid path stretched by the laid tension. + !! There a node of load W stands at the height z = z_floor - W (1 + |grad z_floor|^2)/k of + !! the penalty seabed's static penetration, and the line gives back the buoyancy + !! laid_water_weight pi d^2/4 of its part above laid_waterline_z + !! (CD_HermiteCable_Dry_Buoyancy with the section radius d/2, d the laid_diam of the + !! element's midpoint arc), a node above that level also node_dry_load: W = nl + the dry + !! load at z(W), solved by Newton's method with the dry load's exact height derivative (its + !! residual decreases monotonically in W), each step halved until it reduces the residual's + !! 2-norm: a full step can jump between a node held off the floor (wholly dry) and one sunk + !! below the surface (wholly wet) and cycle there. The turning force of the laid tension is left + !! out of the height. nl is unchanged where the line lies below the surface by more than + !! its radius. + REAL(wp), INTENT(INOUT) :: nl(:) + INTEGER, INTENT(OUT) :: esd + CHARACTER(*), INTENT(OUT) :: emd + INTEGER, PARAMETER :: MAX_NEWTON = 200 + REAL(wp), PARAMETER :: LOAD_RTOL = 1.0e-12_wp + ! the Armijo slope of the step acceptance and the shortest step tried + REAL(wp), PARAMETER :: ARMIJO = 1.0e-4_wp, MIN_STEP = 2.0_wp**(-30) + REAL(wp), ALLOCATABLE :: ref_u(:, :), zf(:), dzds(:), sfac2(:), de(:), base(:), wl(:), z(:), fd(:), & + gres(:), dg(:), lo(:), up(:), y(:), wl_acc(:) + REAL(wp) :: dir(2), gx, gy, ga, qz(4), fdry(4), kdry(4, 4), s_mid, stretch, scale_w, piv, gnorm, & + gnorm_acc, lam + INTEGER :: j, e, ix, esq, it + LOGICAL :: dry, any_dry + esd = CD_HCSTAT_OK + emd = '' + IF (.NOT. (ALLOCATED(fr%laid_arc_end) .AND. ALLOCATED(fr%laid_diam))) RETURN + IF (SIZE(fr%laid_arc_end) < 1 .OR. SIZE(fr%laid_diam) /= SIZE(fr%laid_arc_end)) THEN + esd = CD_HCSTAT_BADINPUT; emd = 'the dry-part diameter profile is inconsistent'; RETURN + END IF + IF (ANY(node_kn <= CD_ZERO)) RETURN + ! the laid path without the sink, from the lower end, in node order + ALLOCATE (ref_u(2, ne + 1), zf(ne + 1), dzds(ne + 1), sfac2(ne + 1), de(ne)) + IF (fr%laid_from_top) THEN + CALL CD_Static_As_Laid_Reference(fr%laid_origin, fr%laid_azimuth, l0(ne:1:-1), EA(ne:1:-1), & + fr%laid_tension, ref_u, esq, emd, bathymetry=bathymetry) + ref_u = ref_u(:, ne + 1:1:-1) + ELSE + CALL CD_Static_As_Laid_Reference(fr%laid_origin, fr%laid_azimuth, l0, EA, fr%laid_tension, ref_u, esq, & + emd, bathymetry=bathymetry) + END IF + IF (esq /= CD_STATIC_OK) THEN + esd = CD_HCSTAT_BADINPUT; RETURN + END IF + dir = [COS(fr%laid_azimuth), SIN(fr%laid_azimuth)] + DO j = 1, ne + 1 + CALL CD_Bathymetry_Floor_Gradient(bathymetry, ref_u(1, j), ref_u(2, j), zf(j), gx, gy, esq, emd) + IF (esq /= CD_BATHY_OK) THEN + esd = CD_HCSTAT_BADINPUT; RETURN + END IF + ! the rise of the laid path per unit length along it, in node order (laid from the last + ! node, the node order runs against the lay) + ga = gx*dir(1) + gy*dir(2) + dzds(j) = MERGE(-CD_ONE, CD_ONE, fr%laid_from_top)*ga/SQRT(CD_ONE + ga*ga) + sfac2(j) = CD_ONE + gx*gx + gy*gy + END DO + s_mid = CD_ZERO + ix = 1 + DO e = 1, ne + s_mid = s_mid + 0.5_wp*l0(e) + DO WHILE (ix < SIZE(fr%laid_arc_end)) + IF (fr%laid_arc_end(ix) >= s_mid) EXIT + ix = ix + 1 + END DO + s_mid = s_mid + 0.5_wp*l0(e) + de(e) = fr%laid_diam(ix) + END DO + base = nl + wl = nl + scale_w = MAX(CD_ONE, MAXVAL(ABS(base))) + ALLOCATE (z(ne + 1), fd(ne + 1), gres(ne + 1), dg(ne + 1), lo(ne + 1), up(ne + 1), y(ne + 1), & + wl_acc(ne + 1)) + wl_acc = wl + gnorm_acc = HUGE(CD_ONE) + lam = CD_ONE + DO it = 1, MAX_NEWTON + ! the dry load at the heights of the loads wl, and its derivative with respect to them + z = zf - MAX(wl, CD_ZERO)*sfac2/node_kn + fd = CD_ZERO + dg = CD_ONE + lo = CD_ZERO + up = CD_ZERO + any_dry = .FALSE. + DO e = 1, ne + IF (.NOT. (de(e) > CD_ZERO)) CYCLE + stretch = CD_ONE + fr%laid_tension/EA(e) + qz = [z(e), stretch*dzds(e), z(e + 1), stretch*dzds(e + 1)] + CALL CD_HermiteCable_Dry_Buoyancy(qz, l0(e), fr%laid_water_weight*0.25_wp*PI_W*de(e)**2, & + fr%laid_waterline_z, fdry, kdry, dry, radius=0.5_wp*de(e)) + IF (.NOT. dry) CYCLE + any_dry = .TRUE. + fd(e) = fd(e) + fdry(1) + fd(e + 1) = fd(e + 1) + fdry(3) + ! d(fd)/d(wl) = -kdry dz/dwl, dz/dwl = -sfac2/kn where the load presses the node in + IF (wl(e) > CD_ZERO) THEN + dg(e) = dg(e) + kdry(1, 1)*sfac2(e)/node_kn(e) + lo(e + 1) = lo(e + 1) + kdry(3, 1)*sfac2(e)/node_kn(e) + END IF + IF (wl(e + 1) > CD_ZERO) THEN + dg(e + 1) = dg(e + 1) + kdry(3, 3)*sfac2(e + 1)/node_kn(e + 1) + up(e) = up(e) + kdry(1, 3)*sfac2(e + 1)/node_kn(e + 1) + END IF + END DO + IF (PRESENT(node_dry_load)) THEN + WHERE (z > fr%laid_waterline_z) fd = fd + node_dry_load + any_dry = any_dry .OR. ANY(z > fr%laid_waterline_z .AND. ABS(node_dry_load) > CD_ZERO) + END IF + IF (it == 1 .AND. .NOT. any_dry) RETURN + gres = wl - base - fd + IF (MAXVAL(ABS(gres)) <= LOAD_RTOL*scale_w) EXIT + ! a step that does not reduce the residual is halved from the last accepted loads (the + ! Newton step is a descent direction of its 2-norm); the shortest is taken as it is + gnorm = SQRT(SUM(gres*gres)) + IF (.NOT. (gnorm <= (CD_ONE - ARMIJO*lam)*gnorm_acc) .AND. lam > MIN_STEP) THEN + lam = 0.5_wp*lam + wl = wl_acc + lam*y + CYCLE + END IF + wl_acc = wl + gnorm_acc = gnorm + lam = CD_ONE + ! (I + K D) dw = -gres, tridiagonal (diagonal dg, sub lo, super up): Thomas elimination; + ! the diagonal is at least 1 and grows with the dry stiffness + y = -gres + DO j = 2, ne + 1 + piv = lo(j)/dg(j - 1) + dg(j) = dg(j) - piv*up(j - 1) + y(j) = y(j) - piv*y(j - 1) + END DO + y(ne + 1) = y(ne + 1)/dg(ne + 1) + DO j = ne, 1, -1 + y(j) = (y(j) - up(j)*y(j + 1))/dg(j) + END DO + wl = wl + y + IF (.NOT. CD_All_Finite(wl)) THEN + esd = CD_HCSTAT_BADINPUT; emd = 'the dry-part load is not finite'; RETURN + END IF + END DO + IF (MAXVAL(ABS(gres)) > LOAD_RTOL*scale_w) THEN + esd = CD_HCSTAT_BADINPUT; emd = 'the dry-part load of the laid line did not converge'; RETURN + END IF + nl = wl + END SUBROUTINE laid_dry_loads END SUBROUTINE CD_HermiteCable_As_Laid_Offsets SUBROUTINE CD_HermiteCable_Friction_Reference(fr, l0, origin, ref, ErrStat, ErrMsg, EA, w, node_kn, bathymetry) @@ -3248,7 +3459,7 @@ PURE LOGICAL FUNCTION current_has_drag(cur) RESULT(has) has = cur%drag END FUNCTION current_has_drag - FUNCTION current_compression_note(l0, EA, qx, seabed_z, flat, frictional, frictionless_run) RESULT(note) + FUNCTION current_compression_note(l0, EA, qx, seabed_z, flat, frictional, frictionless_run, EI, w) RESULT(note) !! Diagnosis of a current that has no tension-only equilibrium on the traced branch: !! empty unless the state qx (the last one reached) carries an element-mean axial force !! (three-point Gauss mean of EA (|r'| - 1), free of the end-node boundary layer) below @@ -3263,8 +3474,13 @@ FUNCTION current_compression_note(l0, EA, qx, seabed_z, flat, frictional, fricti ! TRUE for the two frictionless grounded-run diagnoses (the run folds against its end or ! is pushed along the seabed in compression). LOGICAL, INTENT(OUT), OPTIONAL :: frictionless_run + ! The bending stiffness and weight per length of the elements (both or neither): on an + ! element longer than half its bending length (EI/|w|)^(1/3) the element-mean axial force of + ! a stiff line oscillates and can read a compression the line does not carry, so a + ! compression there names the mesh, not a limit of the current. + REAL(wp), INTENT(IN), OPTIONAL :: EI(:), w(:) CHARACTER(1024) :: note - REAL(wp) :: t_min, t_max, s_min, z_min, z_top + REAL(wp) :: t_min, t_max, s_min, z_min, z_top, need INTEGER :: k, k_min, wios, ne, es CHARACTER(1024) :: em note = '' @@ -3279,6 +3495,22 @@ FUNCTION current_compression_note(l0, EA, qx, seabed_z, flat, frictional, fricti IF (.NOT. (t_min < -1.0e-3_wp*t_max)) RETURN ! Height of the compressed element: the lower of its two nodes. z_min = MIN(qx(6*(k_min - 1) + 3), qx(6*k_min + 3)) + IF (PRESENT(EI) .AND. PRESENT(w)) THEN + ! the compressed element and its neighbours against half their bending length + need = CD_ZERO + DO k = MAX(1, k_min - 1), MIN(ne, k_min + 1) + IF (EI(k) > CD_ZERO .AND. ABS(w(k)) > CD_ZERO) & + need = MAX(need, l0(k)/(0.5_wp*(EI(k)/ABS(w(k)))**(1.0_wp/3.0_wp))) + END DO + IF (need > 1.0_wp) THEN + WRITE (note, '(A,ES10.3,A,F10.2,A,F6.2,A)', IOSTAT=wios) 'the line reads an element-mean axial '// & + 'compression (', t_min, ' N at unstretched arc length ', s_min, ' m) on elements ', need, & + ' times half the bending length (EI/|w|)^(1/3), where the element-mean axial force of a stiff '// & + 'line oscillates and can read a compression the line does not carry; refine those elements '// & + '(NumSegs) to half the bending length or less; ' + RETURN + END IF + END IF IF (flat .AND. z_min <= seabed_z + 0.01_wp*(z_top - seabed_z) .AND. frictional) THEN WRITE (note, '(A,ES10.3,A,F10.2,A,ES10.3,A)', IOSTAT=wios) 'the line is in axial compression at '// & 'the seabed (', t_min, ' N at unstretched arc length ', s_min, ' m, ', z_min - seabed_z, & @@ -3333,6 +3565,11 @@ SUBROUTINE CD_HermiteCable_Static_Solve_Continuation(l0, EA, EI, w, seed, fixed_ !! full-stiffness descent from the last converged state is tried (a limit point where !! the equilibrium snaps to another stable configuration); the continuation then stops !! with NOCONVERGE, as it does once iteration_budget Newton iterations are spent. + !! A full-stiffness descent (that one, or the restart from the seed of a first stage + !! that does not converge) has RESTART_ITER_FACTOR stage allowances; its energy pass runs + !! on to one and a half of them, within the budget, while its residual keeps falling, and + !! stops after that allowance without the norm of the residual halving (stall_limit of + !! CD_HermiteCable_Static_Solve). !! Intermediate stages use a looser tolerance (MAX(tol, 1e-6)); the final stage uses tol. !! The budget makes the failure path bounded: a caller's fallback route receives control !! after at most that many Newton iterations. @@ -3366,7 +3603,8 @@ SUBROUTINE CD_HermiteCable_Static_Solve_Continuation(l0, EA, EI, w, seed, fixed_ REAL(wp), PARAMETER :: STAGE_MOVE_TOL = 0.02_wp ! Every stage (energy solve and pseudo-transient retry) gets this multiple of max_iter. INTEGER, PARAMETER :: PTC_ITER_FACTOR = 4 - ! A full-stiffness restart from the seed descends from far away; its stage allowance. + ! A full-stiffness restart from the seed descends from far away: its stage allowance, of + ! the iterations without progress in the energy pass. INTEGER, PARAMETER :: RESTART_ITER_FACTOR = 10 INTEGER :: ne, nn, it, es, n_accepted REAL(wp) :: lambda, lambda_try, dlog, stage_tol, res @@ -3386,6 +3624,10 @@ SUBROUTINE CD_HermiteCable_Static_Solve_Continuation(l0, EA, EI, w, seed, fixed_ REAL(wp), ALLOCATABLE :: fres(:), kband(:, :), kwork(:, :), dvec(:) LOGICAL, ALLOCATABLE :: free(:) REAL(wp) :: wq + ! A Rigid end in the arclength solve: the end tangent in the basis of its direction (the + ! static solve's residual and tangent come in it), the two transverse components held. + REAL(wp) :: arc_basis(3, 3, 2) + LOGICAL :: arc_rigid(2) CHARACTER(1024) :: first_msg CHARACTER(16) :: frac_txt ! Seabed friction of the current (active in every stage after the still-water one). @@ -3429,6 +3671,7 @@ SUBROUTINE CD_HermiteCable_Static_Solve_Continuation(l0, EA, EI, w, seed, fixed_ END IF IF (use_fric) ALLOCATE (fric_stage, SOURCE=current%friction) drag_homotopy = PRESENT(current) + arc_rigid = .FALSE. CALL ei_homotopy() IF (.NOT. PRESENT(current)) THEN IF (ErrStat /= CD_HCSTAT_OK) RETURN @@ -3473,7 +3716,7 @@ SUBROUTINE CD_HermiteCable_Static_Solve_Continuation(l0, EA, EI, w, seed, fixed_ planar_run_limit = .FALSE. IF (.NOT. picard_ok .AND. COUNT(MOD(fixed_dofs - 1, 6) == 1) >= nn) & planar_run_limit = frictionless_run_limit(q) - IF (.NOT. picard_ok .AND. .NOT. has_rigid_end() .AND. .NOT. planar_run_limit) THEN + IF (.NOT. picard_ok .AND. .NOT. planar_run_limit) THEN arc_msg = em iters_out = 0 IF (use_fric) THEN @@ -3678,13 +3921,6 @@ SUBROUTINE full_fixed_point(ok) iters_out = iters_out + iters_before END SUBROUTINE full_fixed_point - LOGICAL FUNCTION has_rigid_end() RESULT(rig) - !! A rigid end connection solves its end tangent in a rotated basis (not supported by - !! the bordered arclength solve). - rig = .FALSE. - IF (PRESENT(endconn_mode)) rig = ANY(endconn_mode == CD_ENDCONN_RIGID) - END FUNCTION has_rigid_end - LOGICAL FUNCTION frictionless_run_limit(qx) RESULT(run_limit) !! TRUE when the diagnosis of state qx is a grounded run driven along a frictionless !! seabed (see current_compression_note). @@ -3695,7 +3931,7 @@ LOGICAL FUNCTION frictionless_run_limit(qx) RESULT(run_limit) run_limit = .FALSE. IF (.NOT. PRESENT(current)) RETURN IF (.NOT. current_has_drag(current)) RETURN - note = current_compression_note(l0, EA, qx, seabed_z, flat, use_fric, run_limit) + note = current_compression_note(l0, EA, qx, seabed_z, flat, use_fric, run_limit, EI=EI, w=w) END FUNCTION frictionless_run_limit FUNCTION compression_note(qx) RESULT(note) @@ -3707,7 +3943,7 @@ FUNCTION compression_note(qx) RESULT(note) note = '' IF (.NOT. PRESENT(current)) RETURN IF (.NOT. current_has_drag(current)) RETURN - note = current_compression_note(l0, EA, qx, seabed_z, flat, use_fric) + note = current_compression_note(l0, EA, qx, seabed_z, flat, use_fric, EI=EI, w=w) END FUNCTION compression_note FUNCTION fixed_point_name() RESULT(name) @@ -3756,6 +3992,21 @@ SUBROUTINE drag_arclength(ok) DO k = 1, SIZE(fixed_dofs) free(fixed_dofs(k)) = .FALSE. END DO + ! A Rigid end: the static solve returns its end-tangent rows and columns in the basis of + ! the end direction (CD_EndConn_Basis), whose first component is the free tangent + ! magnitude and whose two transverse components are held. + arc_rigid = .FALSE. + IF (PRESENT(endconn_mode) .AND. PRESENT(endconn_direction)) THEN + DO k = 1, 2 + IF (endconn_mode(k) /= CD_ENDCONN_RIGID) CYCLE + CALL CD_EndConn_Basis(endconn_direction(:, k), arc_basis(:, :, k), es_a, em) + IF (es_a /= CD_ENDCONN_OK) THEN + em = 'arclength continuation: '//TRIM(em); RETURN + END IF + arc_rigid(k) = .TRUE. + free(arc_tangent_base(k) + 2:arc_tangent_base(k) + 3) = .FALSE. + END DO + END IF ei_stage = EI IF (PRESENT(endconn_stiffness)) k_stage = endconn_stiffness wq = CD_ONE/SUM(l0) @@ -3795,6 +4046,8 @@ SUBROUTINE drag_arclength(ok) z2 = dvec CALL CD_Solve_Banded(kwork, KL_H, KU_H, z2, es_a, em) IF (es_a /= CD_LINALG_OK) EXIT + CALL arc_to_global(z1) + CALL arc_to_global(z2) CALL CD_Arclength_Bordered_Update(wq, tq, tl, g, z1, z2, qc, lamc, es_a) IF (es_a /= 0) EXIT IF (.NOT. CD_All_Finite(qc) .OR. .NOT. CD_Is_Finite(lamc)) EXIT @@ -3888,6 +4141,12 @@ SUBROUTINE arc_assemble(qx, lamx, resx, esx) IF (esx /= CD_HCSTAT_OK) RETURN CALL CD_HermiteCable_Current_Load(l0, qx, current, dvec, esx, em) IF (esx /= CD_HCSTAT_OK) RETURN + ! the drag load in the basis of a Rigid end, as the residual and tangent are + DO kk = 1, 2 + IF (.NOT. arc_rigid(kk)) CYCLE + jj = arc_tangent_base(kk) + dvec(jj + 1:jj + 3) = MATMUL(TRANSPOSE(arc_basis(:, :, kk)), dvec(jj + 1:jj + 3)) + END DO ! Held DOFs: zero residual and load, identity rows and columns of the band. DO kk = 1, SIZE(dvec) IF (free(kk)) CYCLE @@ -3915,9 +4174,27 @@ SUBROUTINE arc_tangent(tqx, tlx, esx) esx = CD_HCSTAT_NOCONVERGE; RETURN END IF esx = CD_HCSTAT_OK + CALL arc_to_global(tqx) CALL CD_Arclength_Unit_Tangent(wq, tqx, tlx) END SUBROUTINE arc_tangent + INTEGER FUNCTION arc_tangent_base(iend) RESULT(base) + !! The DOF before the end tangent of End A (iend 1) or End B (iend 2). + INTEGER, INTENT(IN) :: iend + base = MERGE(3, 6*(nn - 1) + 3, iend == 1) + END FUNCTION arc_tangent_base + + SUBROUTINE arc_to_global(vx) + !! A solved increment from the basis of each Rigid end back to the global components. + REAL(wp), INTENT(INOUT) :: vx(:) + INTEGER :: ie, b0 + DO ie = 1, 2 + IF (.NOT. arc_rigid(ie)) CYCLE + b0 = arc_tangent_base(ie) + vx(b0 + 1:b0 + 3) = MATMUL(arc_basis(:, :, ie), vx(b0 + 1:b0 + 3)) + END DO + END SUBROUTINE arc_to_global + SUBROUTINE drag_load_steps(ok) !! Bring the current in at full stiffness from the still-water equilibrium in load !! steps (fraction of the drag advancing by up to half the load, halved on failure), @@ -4086,9 +4363,19 @@ SUBROUTINE stage_solve(ei_x, seed_x, q_x, curv_x, res_x, it_x, es_x, em_x, ptc, CHARACTER(*), INTENT(OUT) :: em_x LOGICAL, INTENT(IN) :: ptc REAL(wp), INTENT(IN), OPTIONAL :: f_frozen(:) - INTEGER :: iter_x + INTEGER :: iter_x, stall_x iter_x = PTC_ITER_FACTOR*max_iter IF (restart_stage) iter_x = MAX(iter_x, MIN(iteration_budget - iters_out, RESTART_ITER_FACTOR*iter_x)) + ! The energy pass of a restart descends from far away (on a long line, through more than + ! a thousand iterations in which the residual rises and falls while the energy falls): + ! past the restart allowance it runs on while the residual keeps falling, and stops after + ! an allowance without progress. A fixed count sat within the scatter of the length of + ! such a descent, so the last digits of the input (as from turning the line about the + ! vertical) decided whether the statics solved. The extension ends at one and a half + ! allowances: a descent still going there can settle on a folded branch that a + ! different start avoids (the PTC retry and the caller's other routes follow). + stall_x = iter_x + IF (restart_stage .AND. .NOT. ptc) iter_x = MAX(iter_x, MIN(iteration_budget - iters_out, (3*iter_x)/2)) IF (PRESENT(endconn_stiffness)) THEN CALL CD_HermiteCable_Static_Solve(l0, EA, ei_x, w, seed_x, fixed_dofs, seabed_z, kn, 1, iter_x, & stage_tol, CD_ONE, q_x, curv_x, res_x, it_x, es_x, em_x, & @@ -4102,7 +4389,7 @@ SUBROUTINE stage_solve(ei_x, seed_x, q_x, curv_x, res_x, it_x, es_x, em_x, ptc, endconn_stiffness=k_stage, endconn_direction=endconn_direction, & endconn_mode=endconn_mode, waterline_z=waterline_z, & dry_buoyancy=dry_buoyancy, water_weight=water_weight, current=cur_stage, & - friction=fric_stage) + friction=fric_stage, stall_limit=stall_x) ELSE CALL CD_HermiteCable_Static_Solve(l0, EA, ei_x, w, seed_x, fixed_dofs, seabed_z, kn, 1, iter_x, & stage_tol, CD_ONE, q_x, curv_x, res_x, it_x, es_x, em_x, & @@ -4114,7 +4401,8 @@ SUBROUTINE stage_solve(ei_x, seed_x, q_x, curv_x, res_x, it_x, es_x, em_x, ptc, axial_quadrature_order=axial_quadrature_order, & bending_quadrature_order=bending_quadrature_order, & waterline_z=waterline_z, dry_buoyancy=dry_buoyancy, & - water_weight=water_weight, current=cur_stage, friction=fric_stage) + water_weight=water_weight, current=cur_stage, friction=fric_stage, & + stall_limit=stall_x) END IF END SUBROUTINE stage_solve @@ -6544,7 +6832,9 @@ SUBROUTINE CD_HermiteCable_Static_Solve_AutoMesh(l0, EA, EI, w, seed, fixed_dofs ! move toward the compression, so it is given two more. INTEGER :: max_axial_stall_passes INTEGER, PARAMETER :: AXIAL_BUDGET_FLOOR = 2048 - INTEGER :: axial_budget, axial_stall, wios + INTEGER :: axial_budget, axial_stall, axial_flat, wios + ! A violation within this share of the previous pass's is flat: refinement does not move it. + REAL(wp), PARAMETER :: AXIAL_FLAT_REL = 1.0e-3_wp REAL(wp) :: axial_prev, end_res_prev LOGICAL :: end_min, end_prev, end_settled CHARACTER(400) :: axial_stop @@ -6555,6 +6845,7 @@ SUBROUTINE CD_HermiteCable_Static_Solve_AutoMesh(l0, EA, EI, w, seed, fixed_dofs applied_scale = 1 local_passes = 0 axial_stall = 0 + axial_flat = 0 axial_prev = CD_ZERO end_prev = .FALSE. end_res_prev = CD_ZERO @@ -6798,7 +7089,7 @@ SUBROUTINE CD_HermiteCable_Static_Solve_AutoMesh(l0, EA, EI, w, seed, fixed_dofs IF (PRESENT(current)) THEN IF (current_has_drag(current)) & emloc = TRIM(current_compression_note(l0_out, EA_out, q_out, seabed_z,.NOT. PRESENT(bathymetry), & - ALLOCATED(current%friction)))//TRIM(emloc) + ALLOCATED(current%friction), EI=EI_out, w=w_out))//TRIM(emloc) END IF ErrStat = es; ErrMsg = 'CD_HermiteCable_Static_Solve_AutoMesh: refined-mesh polish failed: '//TRIM(emloc) RETURN @@ -6849,6 +7140,14 @@ SUBROUTINE CD_HermiteCable_Static_Solve_AutoMesh(l0, EA, EI, w, seed, fixed_dofs ELSE axial_stall = axial_stall + 1 END IF + ! A compression that two successive passes leave where it was (to 0.1 %) is the + ! equilibrium's, not the mesh's: splitting the elements around it further only grows + ! the mesh to its budget. (A mesh compression falls as its elements are split.) + IF (ABS(diag_out%axial_violation - axial_prev) <= AXIAL_FLAT_REL*axial_prev) THEN + axial_flat = axial_flat + 1 + ELSE + axial_flat = 0 + END IF END IF needs_refinement = (must_be_tensile .AND. diag_out%axial_compression) .OR. & (refine_other .AND. refinable(diag_out)) @@ -6858,6 +7157,10 @@ SUBROUTINE CD_HermiteCable_Static_Solve_AutoMesh(l0, EA, EI, w, seed, fixed_dofs axial_stop = 'the minimum axial strain stopped improving' EXIT END IF + IF (needs_refinement .AND. local_axial .AND. axial_flat >= 2) THEN + axial_stop = 'two passes left the compression where it was: it is the equilibrium''s, not the mesh''s' + EXIT + END IF IF (needs_refinement .AND. local_axial .AND. end_settled) THEN axial_stop = 'the compression is the reaction of a held end, which refinement does not change' EXIT @@ -6930,7 +7233,7 @@ SUBROUTINE CD_HermiteCable_Static_Solve_AutoMesh(l0, EA, EI, w, seed, fixed_dofs IF (PRESENT(current)) THEN IF (current_has_drag(current)) & wbuf = TRIM(current_compression_note(l0_out, EA_out, q_out, seabed_z,.NOT. PRESENT(bathymetry), & - ALLOCATED(current%friction)))//TRIM(wbuf) + ALLOCATED(current%friction), EI=EI_out, w=w_out))//TRIM(wbuf) END IF ErrMsg = wbuf RETURN diff --git a/src/CableDyn_Hydro.f90 b/src/CableDyn_Hydro.f90 index 5cde0efc..45514fc9 100644 --- a/src/CableDyn_Hydro.f90 +++ b/src/CableDyn_Hydro.f90 @@ -1365,7 +1365,7 @@ SUBROUTINE CD_Morison_Drag_Per_Length(rel_velocity, tangent, rho, diameter, cdn, END SUBROUTINE CD_Morison_Drag_Per_Length SUBROUTINE CD_Morison_Drag_Per_Length_Jac(rel_velocity, tangent, rho, diameter, cdn, cdt, & - force, jac_rel, jac_tan, ErrStat, ErrMsg) + force, jac_rel, jac_tan, ErrStat, ErrMsg, scalars_validated) !! Morison drag per unit length [N/m] and its analytical Jacobians with respect to the relative !! velocity (jac_rel = d force / d rel_velocity) and the (possibly non-unit) tangent VECTOR !! (jac_tan = d force / d tangent), for consistent distributed-load assembly over an element's @@ -1378,14 +1378,20 @@ SUBROUTINE CD_Morison_Drag_Per_Length_Jac(rel_velocity, tangent, rho, diameter, !! jac_rel/jac_tan are OPTIONAL as a pair: a residual-only caller omits both and pays for !! the force alone -- computed by the IDENTICAL statements either way, so the force is !! bit-for-bit the same with or without the Jacobians. + !! + !! scalars_validated (optional, default .FALSE.): .TRUE. when the caller has already + !! established finite rho > 0, diameter > 0, cdn >= 0 and cdt >= 0 (an element kernel + !! that checks them once per element, before its quadrature loop), which skips the same + !! checks at every quadrature point. The vector inputs and the results are always checked. REAL(wp), INTENT(IN) :: rel_velocity(3), tangent(3), rho, diameter, cdn, cdt REAL(wp), INTENT(OUT) :: force(3) REAL(wp), INTENT(OUT), OPTIONAL :: jac_rel(3, 3), jac_tan(3, 3) INTEGER, INTENT(OUT) :: ErrStat CHARACTER(*), INTENT(OUT) :: ErrMsg + LOGICAL, INTENT(IN), OPTIONAL :: scalars_validated REAL(wp) :: ek(3), col(3), tnorm, tu(3), munit(3, 3), proj(3, 3) INTEGER :: k - LOGICAL :: want_jac + LOGICAL :: want_jac, check_scalars want_jac = PRESENT(jac_rel) IF (want_jac .NEQV. PRESENT(jac_tan)) THEN @@ -1398,11 +1404,15 @@ SUBROUTINE CD_Morison_Drag_Per_Length_Jac(rel_velocity, tangent, rho, diameter, jac_rel = CD_ZERO; jac_tan = CD_ZERO END IF ErrStat = CD_HYDRO_OK; ErrMsg = '' - CALL validate_hydro_scalars(rho, diameter, ErrStat, ErrMsg) - IF (ErrStat /= CD_HYDRO_OK) RETURN - IF (.NOT. (CD_Is_Finite(cdn) .AND. CD_Is_Finite(cdt) .AND. cdn >= CD_ZERO .AND. cdt >= CD_ZERO)) THEN - CALL fail(ErrStat, ErrMsg, 'drag coefficients must be finite and non-negative') - RETURN + check_scalars = .TRUE. + IF (PRESENT(scalars_validated)) check_scalars = .NOT. scalars_validated + IF (check_scalars) THEN + CALL validate_hydro_scalars(rho, diameter, ErrStat, ErrMsg) + IF (ErrStat /= CD_HYDRO_OK) RETURN + IF (.NOT. (CD_Is_Finite(cdn) .AND. CD_Is_Finite(cdt) .AND. cdn >= CD_ZERO .AND. cdt >= CD_ZERO)) THEN + CALL fail(ErrStat, ErrMsg, 'drag coefficients must be finite and non-negative') + RETURN + END IF END IF IF (.NOT. CD_All_Finite(rel_velocity) .OR. .NOT. CD_All_Finite(tangent)) THEN CALL fail(ErrStat, ErrMsg, 'relative velocity and tangent must be finite') diff --git a/src/CableDyn_Modal.f90 b/src/CableDyn_Modal.f90 index 3c15668b..ec0c34d9 100644 --- a/src/CableDyn_Modal.f90 +++ b/src/CableDyn_Modal.f90 @@ -13,14 +13,16 @@ MODULE CableDyn_Modal !! !! K and M are assembled as their symmetric parts in LAPACK symmetric band storage (the !! nodes of a line are numbered along it, so the bandwidth is set by one element) and - !! CD_Modal_Solve_Band computes only the requested lowest modes: the eigenvalues by - !! LAPACK DSBGVX (band reduction and bisection), each mode shape by inverse iteration - !! on the banded pencil, M-orthogonalised against the modes before it, and the returned - !! eigenvalue as the Rayleigh quotient of that shape. Memory and time - !! grow linearly with the line length for the shapes and quadratically, with a small - !! constant, for the band reduction. The dense routines (CD_Modal_Bar_Matrices, - !! CD_Modal_Hermite_Matrices, CD_Modal_Solve with LAPACK DSYGV) are kept as the reference - !! the banded solver is tested against, for small lines only. + !! CD_Modal_Solve_Band computes only the requested lowest modes: the eigenvalues by a + !! shift-invert block Lanczos iteration on the banded Cholesky factor of K, certified by + !! a Sturm count of K - sigma M (or, for a short line, many modes, an indefinite or + !! singular K, or a Lanczos run that is not certified, by LAPACK DSBGVX: band reduction + !! and bisection), each mode shape by inverse iteration on the banded pencil, + !! M-orthogonalised against the modes before it, and the returned eigenvalue as the + !! Rayleigh quotient of that shape. Memory and time grow linearly with the line length + !! (quadratically, with a small constant, for the band reduction). The dense routines + !! (CD_Modal_Bar_Matrices, CD_Modal_Hermite_Matrices, CD_Modal_Solve with LAPACK DSYGV) + !! are kept as the reference the banded solver is tested against, for small lines only. !! !! EI = 0 lines (two-node bars, three translations per node): an element of rest length !! l0 and current length l along the unit vector e, tension T = EA (l/l0 - 1) (zero when @@ -58,7 +60,25 @@ MODULE CableDyn_Modal PRIVATE INTEGER, PARAMETER, PUBLIC :: CD_MODAL_OK = 0, CD_MODAL_BADINPUT = 1, CD_MODAL_FAIL = 2 + ! Eigenvalue stage of CD_Modal_Solve_Band: chosen by problem size, the shift-invert Lanczos + ! iteration (falling back to the band reduction when it is not certified), or the band + ! reduction (DSBGVX) + INTEGER, PARAMETER, PUBLIC :: CD_MODAL_EIG_AUTO = 0, CD_MODAL_EIG_LANCZOS = 1, CD_MODAL_EIG_BANDRED = 2 INTEGER, PARAMETER :: I8 = SELECTED_INT_KIND(18) + ! Shift-invert block Lanczos: block size (two, for the exactly repeated frequencies of the + ! two transverse planes of a straight line), the residual tolerance of a wanted Ritz value + ! and of the Ritz values that bound the Sturm interval (relative to the Ritz value of the + ! shift-inverted operator, with a floor at round-off of the largest one), the relative gap + ! the Sturm shift sits in, and the breakdown threshold of a new Lanczos vector. Below + ! LZ_MIN_DOF free DOFs, or where the basis and its M-image would hold more than + ! LZ_MAX_WORDS values (256 MB), the band reduction is used. + INTEGER, PARAMETER :: LZ_BLOCK = 2, LZ_MIN_DOF = 200 + INTEGER(I8), PARAMETER :: LZ_MAX_WORDS = 32000000_I8 + REAL(wp), PARAMETER :: LZ_TOL = 1.0e-10_wp, LZ_TOL_MAX = 1.0e-7_wp, LZ_TOL_GUARD = 1.0e-6_wp + REAL(wp), PARAMETER :: LZ_FLOOR = 1.0e-13_wp, LZ_GAP = 1.0e-3_wp, LZ_BREAK = 1.0e-10_wp + ! Relative tolerance within which two components of a mode shape count as equally large in + ! its sign convention + REAL(wp), PARAMETER :: SIGN_TIE = 1.0e-6_wp ! Largest problem of the dense reference solver: three 4000 x 4000 matrices are 400 MB INTEGER, PARAMETER :: DENSE_MAX_DOF = 4000 ! Inverse iterations per mode: at least MIN_ITER, at most MAX_ITER @@ -715,19 +735,25 @@ SUBROUTINE CD_Modal_Hermite_Matrices(q, l0, ea, ei, rho_a, K, M, ErrStat, ErrMsg CALL band_to_dense(mb, kd, M) END SUBROUTINE CD_Modal_Hermite_Matrices - SUBROUTINE CD_Modal_Solve_Band(K, M, kd, free, n_modes, omega2, shapes, n_found, ErrStat, ErrMsg) + RECURSIVE SUBROUTINE CD_Modal_Solve_Band(K, M, kd, free, n_modes, omega2, shapes, n_found, ErrStat, ErrMsg, & + eig_method, eig_used) !! The n_modes lowest eigenpairs of K phi = omega^2 M phi on the free DOFs, K and M in !! symmetric upper band storage of half-bandwidth kd (CD_Modal_Bar_Band, - !! CD_Modal_Hermite_Band). The held DOFs are removed, which keeps the band. DSBGVX - !! returns the lowest n_modes eigenvalues without eigenvectors (its eigenvectors would - !! need an n x n work matrix); each shape is then found by inverse iteration with the - !! banded LU factors of K - omega^2 M, M-orthogonalised against the shapes before it - !! (so a repeated frequency, such as the two transverse planes of a taut string, gets - !! two orthogonal shapes), and accepted on the residual of its eigen-equation. omega2 - !! is the Rayleigh quotient of the shape (quadruple-precision sums), in ascending order. - !! shapes(:, j) is the full-length mode vector (zero on the held DOFs), M-orthonormal - !! on the free DOFs, signed so that its largest component is positive. A negative - !! omega2 (an unstable or compressed state) is returned as computed. + !! CD_Modal_Hermite_Band). The held DOFs are removed, which keeps the band. The lowest + !! n_modes eigenvalues come from a shift-invert block Lanczos iteration (lanczos_lowest) + !! when it is the cheaper solver and its count is certified, else from DSBGVX (without + !! eigenvectors: those would need an n x n work matrix); each shape is then found by + !! inverse iteration with the banded LU factors of K - omega^2 M, M-orthogonalised + !! against the shapes before it (so a repeated frequency, such as the two transverse + !! planes of a taut string, gets two orthogonal shapes), and accepted on the residual of + !! its eigen-equation. omega2 is the Rayleigh quotient of the shape (quadruple-precision + !! sums), in ascending order. shapes(:, j) is the full-length mode vector (zero on the + !! held DOFs), M-orthonormal on the free DOFs, signed so that its largest component is + !! positive (the first of those equal to it within SIGN_TIE: a symmetric line's mirrored + !! nodes). A negative omega2 (an unstable or compressed state) is returned as computed. + !! eig_method (CD_MODAL_EIG_AUTO by default) selects the eigenvalue stage; eig_used + !! returns the one that produced the eigenvalues (CD_MODAL_EIG_LANCZOS or + !! CD_MODAL_EIG_BANDRED; CD_MODAL_EIG_AUTO when none did). REAL(wp), INTENT(IN) :: K(:, :), M(:, :) INTEGER, INTENT(IN) :: kd LOGICAL, INTENT(IN) :: free(:) @@ -735,13 +761,15 @@ SUBROUTINE CD_Modal_Solve_Band(K, M, kd, free, n_modes, omega2, shapes, n_found, REAL(wp), INTENT(OUT) :: omega2(:), shapes(:, :) INTEGER, INTENT(OUT) :: n_found, ErrStat CHARACTER(*), INTENT(OUT) :: ErrMsg - INTEGER :: n, nf, kc, i, j, ii, jj, info, m_found, mode, it, ntry, prev, pass, es + INTEGER, INTENT(IN), OPTIONAL :: eig_method + INTEGER, INTENT(OUT), OPTIONAL :: eig_used + INTEGER :: n, nf, kc, i, j, ii, jj, info, m_found, mode, it, ntry, prev, pass, es, method INTEGER, ALLOCATABLE :: map(:), iwork(:), ifail(:), ipiv(:) INTEGER(I8) :: seed REAL(wp), ALLOCATABLE :: ac(:, :), bc(:, :), a(:, :), b(:, :), w(:), work(:), lu(:, :), x(:), y(:), r(:) REAL(wp), ALLOCATABLE :: vec(:, :), bvec(:, :) - REAL(wp) :: qdum(1, 1), zdum(1, 1), anorm, bnorm, shift, scale, nrm, res, rq, noise - LOGICAL :: converged + REAL(wp) :: qdum(1, 1), zdum(1, 1), anorm, bnorm, shift, scale, nrm, res, rq, noise, xmax + LOGICAL :: converged, lz_ok CHARACTER(1024) :: em EXTERNAL :: dsbgvx @@ -750,6 +778,9 @@ SUBROUTINE CD_Modal_Solve_Band(K, M, kd, free, n_modes, omega2, shapes, n_found, omega2 = CD_ZERO shapes = CD_ZERO n_found = 0 + IF (PRESENT(eig_used)) eig_used = CD_MODAL_EIG_AUTO + method = CD_MODAL_EIG_AUTO + IF (PRESENT(eig_method)) method = eig_method n = SIZE(free) IF (kd < 0 .OR. SIZE(K, 1) /= kd + 1 .OR. SIZE(M, 1) /= kd + 1 .OR. SIZE(K, 2) /= n .OR. SIZE(M, 2) /= n .OR. & SIZE(shapes, 1) /= n .OR. SIZE(shapes, 2) < n_modes .OR. SIZE(omega2) < n_modes .OR. n_modes < 1) THEN @@ -789,35 +820,46 @@ SUBROUTINE CD_Modal_Solve_Band(K, M, kd, free, n_modes, omega2, shapes, n_found, END DO n_found = MIN(n_modes, nf) - ! The lowest n_found eigenvalues (DSBGVX overwrites its band copies). - ALLOCATE (a(kc + 1, nf), b(kc + 1, nf), w(nf), work(7*nf), iwork(5*nf), ifail(nf)) - a = ac - b = bc - CALL dsbgvx('N', 'I', 'U', nf, kc, kc, a, kc + 1, b, kc + 1, qdum, 1, CD_ZERO, CD_ZERO, 1, n_found, & - 2.0_wp*TINY(CD_ONE), m_found, w, zdum, 1, work, iwork, ifail, info) - IF (info /= 0 .OR. m_found /= n_found) THEN - ErrStat = CD_MODAL_FAIL - IF (info == CD_BLAS_UNAVAILABLE_INFO) THEN - CALL CD_Blas_Runtime_Check('CableDyn_Modal (DSBGVX)', es, em) - ErrMsg = 'CableDyn_Modal: '//TRIM(em) - ELSE IF (info > nf) THEN - ErrMsg = 'CableDyn_Modal: the mass matrix is not positive definite (DSBGVX)' - ELSE - BLOCK - ! Local buffer: a record longer than the caller's ErrMsg truncates - ! instead of aborting the internal write. - CHARACTER(1024) :: wmsg - INTEGER :: wios - wmsg = '' - WRITE (wmsg, '(A,I0,A,I0,A,I0)', IOSTAT=wios) 'CableDyn_Modal: DSBGVX failed, INFO = ', info, ', ', m_found, & - ' of the requested eigenvalues found: ', n_found - ErrMsg = wmsg - END BLOCK + ! The lowest n_found eigenvalues: the shift-invert Lanczos iteration where it is the + ! cheaper solver, else (or when its count is not certified) the band reduction. + ALLOCATE (w(nf)) + lz_ok = .FALSE. + IF (method == CD_MODAL_EIG_LANCZOS .OR. (method == CD_MODAL_EIG_AUTO .AND. lanczos_cheaper(nf, kc, n_found))) & + CALL lanczos_lowest(ac, bc, kc, n_found, w, lz_ok) + IF (lz_ok) THEN + IF (PRESENT(eig_used)) eig_used = CD_MODAL_EIG_LANCZOS + ELSE + ! DSBGVX overwrites its band copies. + ALLOCATE (a(kc + 1, nf), b(kc + 1, nf), work(7*nf), iwork(5*nf), ifail(nf)) + a = ac + b = bc + CALL dsbgvx('N', 'I', 'U', nf, kc, kc, a, kc + 1, b, kc + 1, qdum, 1, CD_ZERO, CD_ZERO, 1, n_found, & + 2.0_wp*TINY(CD_ONE), m_found, w, zdum, 1, work, iwork, ifail, info) + IF (info /= 0 .OR. m_found /= n_found) THEN + ErrStat = CD_MODAL_FAIL + IF (info == CD_BLAS_UNAVAILABLE_INFO) THEN + CALL CD_Blas_Runtime_Check('CableDyn_Modal (DSBGVX)', es, em) + ErrMsg = 'CableDyn_Modal: '//TRIM(em) + ELSE IF (info > nf) THEN + ErrMsg = 'CableDyn_Modal: the mass matrix is not positive definite (DSBGVX)' + ELSE + BLOCK + ! Local buffer: a record longer than the caller's ErrMsg truncates + ! instead of aborting the internal write. + CHARACTER(1024) :: wmsg + INTEGER :: wios + wmsg = '' + WRITE (wmsg, '(A,I0,A,I0,A,I0)', IOSTAT=wios) 'CableDyn_Modal: DSBGVX failed, INFO = ', info, ', ', & + m_found, ' of the requested eigenvalues found: ', n_found + ErrMsg = wmsg + END BLOCK + END IF + n_found = 0 + RETURN END IF - n_found = 0 - RETURN + DEALLOCATE (a, b, work, iwork, ifail) + IF (PRESENT(eig_used)) eig_used = CD_MODAL_EIG_BANDRED END IF - DEALLOCATE (a, b, work, iwork, ifail) ! The shapes by inverse iteration on the banded pencil. anorm = sym_band_norm(ac, kc) @@ -894,7 +936,12 @@ SUBROUTINE CD_Modal_Solve_Band(K, M, kd, free, n_modes, omega2, shapes, n_found, RETURN END IF END DO - i = MAXLOC(ABS(x), 1) + ! the sign: the largest component positive; of components equal to it in magnitude to + ! round-off (the mirrored nodes of a symmetric line) the first one + xmax = MAXVAL(ABS(x)) + DO i = 1, nf - 1 + IF (ABS(x(i)) >= (CD_ONE - SIGN_TIE)*xmax) EXIT + END DO IF (x(i) < CD_ZERO) x = -x vec(:, mode) = x CALL sym_band_mv(bc, kc, x, bvec(:, mode)) @@ -934,6 +981,15 @@ END SUBROUTINE shifted_general_band SUBROUTINE mode_fail(msg) CHARACTER(*), INTENT(IN) :: msg + INTEGER :: used + IF (lz_ok) THEN + ! A shape the Lanczos eigenvalues did not give: the whole solve again on the + ! eigenvalues of the band reduction, which succeeds or fails as it does alone. + CALL CD_Modal_Solve_Band(K, M, kd, free, n_modes, omega2, shapes, n_found, ErrStat, ErrMsg, & + eig_method=CD_MODAL_EIG_BANDRED, eig_used=used) + IF (PRESENT(eig_used)) eig_used = used + RETURN + END IF ErrStat = CD_MODAL_FAIL BLOCK ! Local buffer: a record longer than the caller's ErrMsg truncates @@ -951,6 +1007,254 @@ END SUBROUTINE mode_fail END SUBROUTINE CD_Modal_Solve_Band + INTEGER FUNCTION lanczos_max_basis(nf, nwant) RESULT(mb) + !! The bound on the Lanczos basis for nwant of nf eigenvalues: the iteration usually + !! converges with about twice nwant vectors. + INTEGER, INTENT(IN) :: nf, nwant + mb = MIN(nf, 2*nwant + MAX(nwant, 40)) + END FUNCTION lanczos_max_basis + + LOGICAL FUNCTION lanczos_cheaper(nf, kc, nwant) RESULT(yes) + !! Whether the shift-invert Lanczos iteration is expected to cost less than the band + !! reduction for nwant of nf eigenvalues at half-bandwidth kc: the work of its + !! reorthogonalisation grows as nf m**2 with the basis size m (about 2 nwant + 20), + !! that of the reduction as nf**2 kc (the constant measured on lines of 300 to 24000 + !! free DOFs). + !! The memory of the basis is bounded (LZ_MAX_WORDS). + INTEGER, INTENT(IN) :: nf, kc, nwant + INTEGER(I8) :: m + m = INT(MIN(nf, 2*nwant + 20), I8) + yes = nf >= LZ_MIN_DOF .AND. m*m <= 4_I8*INT(nf, I8)*INT(MAX(kc, 1), I8) .AND. & + 2_I8*INT(lanczos_max_basis(nf, nwant), I8)*INT(nf, I8) <= LZ_MAX_WORDS + END FUNCTION lanczos_cheaper + + SUBROUTINE lanczos_lowest(ac, bc, kc, nwant, w, ok) + !! The nwant lowest eigenvalues w (ascending) of K x = lambda M x, K and M symmetric in + !! upper band storage of half-bandwidth kc, both positive definite: a block Lanczos + !! iteration (block LZ_BLOCK, a deterministic pseudo-random start, full + !! M-reorthogonalisation by two passes of classical Gram-Schmidt) on the shift-invert + !! operator S = K^-1 M (banded Cholesky factor of K), whose largest eigenvalues + !! theta = 1/lambda belong to the wanted modes. The Ritz values are those of the + !! projection V^T M S V, each accepted on its Lanczos residual, the norm of + !! S x - theta x. Shift-invert keeps the low end of the spectrum to relative accuracy + !! where a band reduction loses it to the round-off of the axial stiffness. The count is + !! certified: the Cholesky factor of K shows that no eigenvalue lies at or below zero, + !! and the inertia of K - sigma M (sturm_count) at a shift sigma in a gap above the + !! wanted values equals the number of Ritz values below sigma, so no mode is missed (a + !! frequency repeated more often than the block size, an eigenvector the start misses) + !! and none is counted twice. ok is false (w undefined) when K or M is not positive + !! definite, the basis reaches lanczos_max_basis unconverged or uncertified, or a LAPACK + !! call fails; the caller then uses the band reduction. + REAL(wp), INTENT(IN) :: ac(:, :), bc(:, :) + INTEGER, INTENT(IN) :: kc, nwant + REAL(wp), INTENT(OUT) :: w(:) + LOGICAL, INTENT(OUT) :: ok + INTEGER :: nf, mmax, nb, c0, pb, pn, nnew, i, j, r, k, info, lwork, next_check, pass + INTEGER(I8) :: seed + REAL(wp), ALLOCATABLE :: fk(:, :), v(:, :), mv(:, :), wb(:, :), mwb(:, :), h(:, :), t(:, :), theta(:) + REAL(wp), ALLOCATABLE :: work(:), c(:, :), cc(:), est(:), lam(:), y(:), my(:) + REAL(wp) :: wq(1), g(LZ_BLOCK, LZ_BLOCK), ref(LZ_BLOCK), thmax, sigma, avg + LOGICAL :: good, conv + EXTERNAL :: dpbtrf, dpbtrs, dsyev + + ok = .FALSE. + w = CD_ZERO + nf = SIZE(ac, 2) + IF (nwant < 1 .OR. nwant > nf .OR. nf < 2*LZ_BLOCK) RETURN + mmax = lanczos_max_basis(nf, nwant) + ! M, then K, positive definite (the factor of M is not used further) + ALLOCATE (fk(kc + 1, nf)) + fk = bc + CALL dpbtrf('U', nf, kc, fk, kc + 1, info) + IF (info /= 0) RETURN + fk = ac + CALL dpbtrf('U', nf, kc, fk, kc + 1, info) + IF (info /= 0) RETURN + ALLOCATE (v(nf, mmax), mv(nf, mmax), wb(nf, LZ_BLOCK), mwb(nf, LZ_BLOCK), h(mmax, mmax), t(mmax, mmax), & + theta(mmax), c(mmax, LZ_BLOCK), cc(mmax), est(mmax), lam(mmax), y(nf), my(nf)) + h = CD_ZERO + t = CD_ZERO + CALL dsyev('V', 'U', mmax, t, mmax, theta, wq, -1, info) + IF (info /= 0) RETURN + lwork = MAX(3*mmax, INT(wq(1))) + ALLOCATE (work(lwork)) + + nb = 0 + DO j = 1, LZ_BLOCK + CALL random_vector(j) + CALL append(1, SQRT(SUM(y*y)), good) + IF (.NOT. good) RETURN + END DO + c0 = 0 + next_check = MIN(nwant + 1, nf) + DO + ! the block c0 + 1..nb: wb = S v, projected out of the basis (twice), the projection + ! coefficients the new columns of H = V^T M S V + pb = nb - c0 + wb(:, 1:pb) = mv(:, c0 + 1:nb) + CALL dpbtrs('U', nf, kc, pb, fk, kc + 1, wb, nf, info) + IF (info /= 0) RETURN + IF (.NOT. CD_All_Finite(wb(:, 1:pb))) RETURN + DO j = 1, pb + ref(j) = SQRT(SUM(wb(:, j)**2)) + END DO + DO pass = 1, 2 + c(1:nb, 1:pb) = MATMUL(TRANSPOSE(mv(:, 1:nb)), wb(:, 1:pb)) + wb(:, 1:pb) = wb(:, 1:pb) - MATMUL(v(:, 1:nb), c(1:nb, 1:pb)) + h(1:nb, c0 + 1:nb) = h(1:nb, c0 + 1:nb) + c(1:nb, 1:pb) + END DO + h(c0 + 1:nb, 1:c0) = TRANSPOSE(h(1:c0, c0 + 1:nb)) + DO j = c0 + 1, nb + DO i = c0 + 1, j - 1 + avg = 0.5_wp*(h(i, j) + h(j, i)) + h(i, j) = avg + h(j, i) = avg + END DO + END DO + + IF (nb >= next_check .OR. nb == nf .OR. nb >= mmax) THEN + next_check = nb + MAX(LZ_BLOCK, nb/8) + ! Ritz values lam(r) = 1/theta, ascending, and the norms est(r) of their residuals + ! wb s (s the Ritz vector's components on the last block) + t(1:nb, 1:nb) = h(1:nb, 1:nb) + CALL dsyev('V', 'U', nb, t, mmax, theta, work, lwork, info) + IF (info /= 0) RETURN + DO j = 1, pb + CALL sym_band_mv(bc, kc, wb(:, j), mwb(:, j)) + END DO + DO j = 1, pb + DO i = 1, pb + g(i, j) = DOT_PRODUCT(wb(:, i), mwb(:, j)) + END DO + END DO + thmax = theta(nb) + DO r = 1, nb + k = nb + 1 - r + lam(r) = HUGE(CD_ONE) + IF (theta(k) > CD_ZERO) lam(r) = CD_ONE/theta(k) + est(r) = SQRT(MAX(DOT_PRODUCT(t(c0 + 1:nb, k), MATMUL(g(1:pb, 1:pb), t(c0 + 1:nb, k))), CD_ZERO)) + END DO + conv = .TRUE. + DO r = 1, nwant + conv = conv .AND. converged_ritz(r, LZ_TOL) .AND. est(r) <= LZ_TOL_MAX*theta(nb + 1 - r) + END DO + IF (conv) THEN + IF (nb == nf) THEN + ! a complete basis: its Ritz values are the eigenvalues + ok = .TRUE. + ELSE + ! the first gap above the wanted values with every Ritz value below it converged + DO k = nwant, nb - 1 + IF (k > nwant .AND. .NOT. converged_ritz(k, LZ_TOL_GUARD)) EXIT + IF (.NOT. theta(nb - k) > CD_ZERO) EXIT + IF (lam(k + 1) - lam(k) >= LZ_GAP*lam(k + 1)) THEN + sigma = 0.5_wp*(lam(k) + lam(k + 1)) + ok = sturm_count(ac, bc, kc, sigma) == k + EXIT + END IF + END DO + END IF + IF (ok) THEN + w(1:nwant) = lam(1:nwant) + RETURN + END IF + END IF + END IF + IF (nb >= mmax .OR. nb == nf) RETURN + + ! the next block: the projected wb, M-orthonormalised (a column that has vanished, an + ! invariant subspace, is replaced by a fresh pseudo-random vector) + pn = MIN(LZ_BLOCK, nf - nb, mmax - nb, pb) + nnew = nb + DO j = 1, pn + y = wb(:, j) + CALL append(nnew + 1, ref(j), good) + IF (.NOT. good) THEN + CALL random_vector(nb + LZ_BLOCK + 1) + CALL append(1, SQRT(SUM(y*y)), good) + IF (.NOT. good) RETURN + END IF + END DO + c0 = nnew + END DO + + CONTAINS + + LOGICAL FUNCTION converged_ritz(r, tol) RESULT(yes) + !! Ritz value r (ascending) converged to tol relative to its theta, or to round-off of + !! the largest theta. + INTEGER, INTENT(IN) :: r + REAL(wp), INTENT(IN) :: tol + yes = theta(nb + 1 - r) > CD_ZERO .AND. est(r) <= MAX(tol*theta(nb + 1 - r), LZ_FLOOR*thmax) + END FUNCTION converged_ritz + + SUBROUTINE random_vector(stream) + !! y: a deterministic pseudo-random vector of the given stream. + INTEGER, INTENT(IN) :: stream + INTEGER :: ir + seed = 24680_I8 + 7919_I8*INT(stream, I8) + DO ir = 1, nf + seed = MOD(69069_I8*seed + 1_I8, 2147483647_I8) + y(ir) = REAL(seed, wp)/2147483647.0_wp - 0.5_wp + END DO + END SUBROUTINE random_vector + + SUBROUTINE append(lo, yref, good) + !! y orthogonalised (two passes) against the basis vectors lo..nb, M-normalised and + !! appended; good is false when it has vanished against its reference norm yref. + INTEGER, INTENT(IN) :: lo + REAL(wp), INTENT(IN) :: yref + LOGICAL, INTENT(OUT) :: good + INTEGER :: ip + REAL(wp) :: nrm2 + good = .FALSE. + DO ip = 1, 2 + IF (nb < lo) EXIT + cc(1:nb - lo + 1) = MATMUL(TRANSPOSE(mv(:, lo:nb)), y) + y = y - MATMUL(v(:, lo:nb), cc(1:nb - lo + 1)) + END DO + CALL sym_band_mv(bc, kc, y, my) + nrm2 = DOT_PRODUCT(y, my) + IF (.NOT. (nrm2 > CD_ZERO .AND. SQRT(SUM(y*y)) > LZ_BREAK*yref .AND. nrm2 <= HUGE(nrm2))) RETURN + nb = nb + 1 + v(:, nb) = y/SQRT(nrm2) + mv(:, nb) = my/SQRT(nrm2) + good = .TRUE. + END SUBROUTINE append + + END SUBROUTINE lanczos_lowest + + INTEGER FUNCTION sturm_count(ac, bc, kc, sigma) RESULT(cnt) + !! The number of eigenvalues of K x = lambda M x below sigma, K and M symmetric in upper + !! band storage of half-bandwidth kc and M positive definite: by Sylvester's law of + !! inertia, the number of negative pivots of the LDL^T factorisation of K - sigma M + !! without pivoting (which keeps the band). -1 when a pivot is zero or not finite. + REAL(wp), INTENT(IN) :: ac(:, :), bc(:, :), sigma + INTEGER, INTENT(IN) :: kc + REAL(wp), ALLOCATABLE :: a(:, :) + REAL(wp) :: d, f + INTEGER :: nf, k, i, j + nf = SIZE(ac, 2) + ALLOCATE (a(kc + 1, nf)) + a = ac - sigma*bc + cnt = 0 + DO k = 1, nf + d = a(kc + 1, k) + IF (.NOT. (ABS(d) > CD_ZERO .AND. ABS(d) <= HUGE(d))) THEN + cnt = -1 + RETURN + END IF + IF (d < CD_ZERO) cnt = cnt + 1 + ! the trailing block of the band: a(i, j) -= a(k, i) a(k, j) / d, k < i <= j <= k + kc + DO j = k + 1, MIN(nf, k + kc) + f = a(kc + 1 + k - j, j)/d + DO i = k + 1, j + a(kc + 1 + i - j, j) = a(kc + 1 + i - j, j) - f*a(kc + 1 + k - i, i) + END DO + END DO + END DO + END FUNCTION sturm_count + SUBROUTINE CD_Modal_Solve(K, M, free, n_modes, omega2, shapes, n_found, ErrStat, ErrMsg) !! Dense reference solver: the n_modes lowest eigenpairs of K phi = omega^2 M phi on the !! free DOFs (DSYGV, symmetric parts of K and M), for lines of at most 4000 free DOFs. diff --git a/src/CableDyn_Model.f90 b/src/CableDyn_Model.f90 index 683b18b2..638ba1fc 100644 --- a/src/CableDyn_Model.f90 +++ b/src/CableDyn_Model.f90 @@ -398,6 +398,9 @@ MODULE CableDyn_Model ! explicit generalised-alpha force-level phase. viv_rate (phase rate at the step start) ! and viv_ms_next (mean squares updated with the step-start sample) are step scratch. LOGICAL :: has_viv = .FALSE. + ! the cross-flow phase of a node at rest (CD_VIV_Phase_Rate phi_rest): pi where the node + ! tangent runs against MoorDyn's (End B to End A), 0 where it runs as MoorDyn's + REAL(wp) :: viv_phi_rest = CD_ZERO REAL(wp) :: viv_rho = CD_ZERO REAL(wp) :: viv_tw = CD_ZERO REAL(wp), ALLOCATABLE :: viv_cl(:), viv_d(:) @@ -3879,16 +3882,20 @@ SUBROUTINE CD_Set_Model_Syrope_State(model, slow, tmax, ErrStat, ErrMsg) model%recovery_syrope_tmax = tmax END SUBROUTINE CD_Set_Model_Syrope_State - SUBROUTINE CD_Set_Model_VIV(model, rho, cl, diameter, cf, df, t_window, ErrStat, ErrMsg, phase_seed) + SUBROUTINE CD_Set_Model_VIV(model, rho, cl, diameter, cf, df, t_window, ErrStat, ErrMsg, phase_seed, & + tangent_reversed) !! Install the cross-flow VIV model (CableDyn_VIV) on an initialised line. Per element: !! the lift coefficient cl (0 = no lift on that element), hydrodynamic diameter, and the !! synchronisation centre cf and half-range df of the non-dimensional shedding frequency; !! rho is the water density. t_window is the averaging time of the running cross-flow mean !! squares [s]; 0 selects MoorDyn's 500 time steps, latched at the first step. Every !! interior free node next to a cl > 0 element carries a lift and a shedding phase; the - !! phases start spread over [0, 2 pi) along the line (MoorDyn-C: 2 pi i/N at node i from - !! End A; phase_seed, per node, gives i/N instead, for a line whose deck End A the reader - !! turned around), the mean squares at 0. + !! phases start spread over [0, 2 pi) along the line, the mean squares at 0. MoorDyn-C starts + !! node i from End A at 2 pi i/N with the node tangent from End A to End B; the model's + !! tangent (from node nd - 1 to nd + 1) runs from End B to End A, which turns the lift and the + !! cross-flow axis around, so the same motion starts here from those phases plus pi. + !! phase_seed, per node, gives the start as a fraction of a turn instead + !! (CD_Deck_VIV_Phase_Seed: a line whose deck End A the reader turned around, a refined mesh). !! An all-zero cl leaves the model without VIV. The mesh must be the single chain the !! line builder makes (element e joins nodes e and e+1). The caller recomputes the !! acceleration if the lift should enter the initial state (CD_Recompute_Model_Acceleration). @@ -3897,6 +3904,10 @@ SUBROUTINE CD_Set_Model_VIV(model, rho, cl, diameter, cf, df, t_window, ErrStat, INTEGER, INTENT(OUT) :: ErrStat CHARACTER(*), INTENT(OUT) :: ErrMsg REAL(wp), INTENT(IN), OPTIONAL :: phase_seed(:) + !! tangent_reversed (default .TRUE., the model's own seed): the node tangent runs against + !! MoorDyn's, so a node at rest takes the cross-flow phase pi (CD_VIV_Phase_Rate phi_rest); + !! .FALSE. on a line the reader turned around, whose tangent runs as MoorDyn's + LOGICAL, INTENT(IN), OPTIONAL :: tangent_reversed INTEGER :: n_nodes, n_elem, e, nd, istat, k REAL(wp) :: wsum @@ -3993,8 +4004,9 @@ SUBROUTINE CD_Set_Model_VIV(model, rho, cl, diameter, cf, df, t_window, ErrStat, model%viv_df(nd) = model%viv_df(nd)/wsum model%viv_dn(nd) = model%viv_dn(nd)/wsum ! MoorDyn: phi_i = 2 pi i/N at node i = 0..N counted from End A; the model numbers its - ! nodes from End B, so node nd is MoorDyn's node n_nodes - nd - model%viv_phi(nd) = CD_VIV_TWO_PI*REAL(n_nodes - nd, wp)/REAL(n_elem, wp) + ! nodes from End B, so node nd is MoorDyn's node n_nodes - nd, and its tangent runs the other + ! way (half a turn on) + model%viv_phi(nd) = CD_VIV_Wrap_Phase(CD_VIV_TWO_PI*(REAL(n_nodes - nd, wp)/REAL(n_elem, wp) + 0.5_wp)) IF (PRESENT(phase_seed)) model%viv_phi(nd) = CD_VIV_TWO_PI*phase_seed(nd) END DO model%viv_phi_rollback = model%viv_phi @@ -4005,6 +4017,8 @@ SUBROUTINE CD_Set_Model_VIV(model, rho, cl, diameter, cf, df, t_window, ErrStat, model%viv_rate = CD_ZERO model%viv_ms_next = model%viv_ms model%viv_phi_next = model%viv_phi + model%viv_phi_rest = 0.5_wp*CD_VIV_TWO_PI + IF (PRESENT(tangent_reversed)) model%viv_phi_rest = MERGE(0.5_wp*CD_VIV_TWO_PI, CD_ZERO, tangent_reversed) model%has_viv = .TRUE. END SUBROUTINE CD_Set_Model_VIV @@ -4191,7 +4205,7 @@ SUBROUTINE viv_step_begin(model, dt, ErrStat, ErrMsg) model%viv_ms_next(2, nd) = CD_VIV_Mean_Square(model%viv_ms(2, nd), ydd, w) model%viv_rate(nd) = CD_VIV_Phase_Rate(yd, ydd, model%viv_ms_next(1, nd), model%viv_ms_next(2, nd), & model%viv_phi(nd), un, model%viv_dn(nd), model%viv_cf(nd), & - model%viv_df(nd)) + model%viv_df(nd), phi_rest=model%viv_phi_rest) model%viv_phi_eval(nd) = model%viv_phi(nd) + (CD_ONE - alpha_f)*dt*model%viv_rate(nd) END DO END SUBROUTINE viv_step_begin @@ -4225,7 +4239,7 @@ SUBROUTINE viv_step_end(model, dt, ErrStat, ErrMsg) ms1 = CD_VIV_Mean_Square(model%viv_ms_next(1, nd), yd, w) ms2 = CD_VIV_Mean_Square(model%viv_ms_next(2, nd), ydd, w) rate_end = CD_VIV_Phase_Rate(yd, ydd, ms1, ms2, model%viv_phi(nd) + dt*model%viv_rate(nd), un, & - model%viv_dn(nd), model%viv_cf(nd), model%viv_df(nd)) + model%viv_dn(nd), model%viv_cf(nd), model%viv_df(nd), phi_rest=model%viv_phi_rest) model%viv_phi_next(nd) = CD_VIV_Wrap_Phase(model%viv_phi(nd) + 0.5_wp*dt*(model%viv_rate(nd) + rate_end)) END DO IF (.NOT. CD_All_Finite(model%viv_phi_next)) THEN @@ -4428,6 +4442,14 @@ SUBROUTINE CD_Calc_Model_CoupledLoads(model, coupled_loads, ErrStat, ErrMsg) ErrMsg = 'CableDyn_Model: internal-force assembly failed during coupled-load calculation: '//TRIM(em) RETURN END IF + ! A line coupled at its end nodes only (a line between points): the remaining terms on the + ! end rows alone (coupled_loads_at_ends), bit-identical to the whole-line residual below. + ! The whole-line terms validate the accelerations element by element (the added-mass + ! kernels): with any non-finite one they are formed whole, to fail as they do. + IF (ALL(model%fixed_dofs <= 3 .OR. model%fixed_dofs > model%n_dof - 3) .AND. CD_All_Finite(model%a)) THEN + CALL coupled_loads_at_ends(model, fint, coupled_loads, ErrStat, ErrMsg) + RETURN + END IF CALL model_structural_mass_product(model, model%a, residual) residual = residual + fint - model%f_ext IF (model%has_added_mass) THEN @@ -4453,6 +4475,119 @@ SUBROUTINE CD_Calc_Model_CoupledLoads(model, coupled_loads, ErrStat, ErrMsg) END ASSOCIATE END SUBROUTINE CD_Calc_Model_CoupledLoads + SUBROUTINE coupled_loads_at_ends(model, fint, coupled_loads, ErrStat, ErrMsg) + !! The rest of CD_Calc_Model_CoupledLoads, given the whole-line internal force fint, for a + !! line whose coupled DOFs all belong to its first or last node and whose accelerations are + !! finite. Only the two end rows of M a + f_int - f_ext + M_add a - load are formed, from + !! the elements that touch an end node and the end nodes' own terms (model_contributor_force + !! end_nodes_only). Each row takes its terms in the element order of the whole-line + !! assembly and its operations in the same order, so the loads are bit-identical to it, as + !! in CD_Get_Model_EndForces; the elements that touch no end node, which add nothing to + !! these rows, are not evaluated. + TYPE(CD_ModelType), INTENT(IN) :: model + REAL(wp), INTENT(IN) :: fint(:) + REAL(wp), INTENT(OUT) :: coupled_loads(:) + INTEGER, INTENT(OUT) :: ErrStat + CHARACTER(*), INTENT(OUT) :: ErrMsg + + INTEGER :: n, nn, e, a, b, ia, ib, sa, sb, k, d, es, idx(6), lk + REAL(wp) :: inertia(3, 2), added(3, 2), residual(3, 2), load(9) + REAL(wp) :: coeff, q2(6), a2(6), wl2(2), ma2(6) + CHARACTER(1024) :: em + + ErrStat = CD_MODEL_OK + ErrMsg = '' + coupled_loads = CD_ZERO + lk = MIN(LEN(em), KERNEL_MSG_LEN) + n = model%n_dof + nn = n/3 + ! M a (model_structural_mass_product) on the end rows, from zero in element order + inertia = CD_ZERO + DO e = 1, model%n_elem + a = model%elem_conn(1, e) + b = model%elem_conn(2, e) + sa = end_slot(a) + sb = end_slot(b) + IF (sa == 0 .AND. sb == 0) CYCLE + ia = 3*a - 2 + ib = 3*b - 2 + coeff = model%rho_a(e)*model%l0(e)/6.0_wp + IF (sa /= 0) inertia(:, sa) = inertia(:, sa) + coeff*(2.0_wp*model%a(ia:ia + 2) + model%a(ib:ib + 2)) + IF (sb /= 0) inertia(:, sb) = inertia(:, sb) + coeff*(model%a(ia:ia + 2) + 2.0_wp*model%a(ib:ib + 2)) + END DO + DO k = 1, 2 + residual(:, k) = inertia(:, k) + fint(end_base(k) + 1:end_base(k) + 3) - & + model%f_ext(end_base(k) + 1:end_base(k) + 3) + END DO + ! M_add a (model_added_mass_force), from zero in element order + IF (model%has_added_mass) THEN + added = CD_ZERO + DO e = 1, model%n_elem + sa = end_slot(model%elem_conn(1, e)) + sb = end_slot(model%elem_conn(2, e)) + IF (sa == 0 .AND. sb == 0) CYCLE + CALL extract_element_positions(model, e, model%q, idx, q2) + a2 = model%a(idx) + CALL extract_nodal_scalar(model%added_mass_waterline_z, model, e, wl2) + em = '' + CALL CD_Added_Mass_Element_Force(q2(1:3), q2(4:6), a2(1:3), a2(4:6), model%l0(e), wl2(1), wl2(2), & + model%added_mass_rho, model%added_mass_diameter_elem(e), & + model%added_mass_can_elem(e), model%added_mass_cat_elem(e), & + ma2, es, em(1:lk)) + IF (es /= 0) THEN + ErrStat = CD_MODEL_SOLVEFAIL + ErrMsg = 'CableDyn_Model: added-mass assembly failed during coupled-load calculation: '//TRIM(em) + RETURN + END IF + ! the far node's share stays finite-checked as in the whole-line force + IF (.NOT. CD_All_Finite(ma2)) THEN + CALL fail(es, em, 'added-mass force returned non-finite values') + ErrStat = CD_MODEL_SOLVEFAIL + ErrMsg = 'CableDyn_Model: added-mass assembly failed during coupled-load calculation: '//TRIM(em) + RETURN + END IF + IF (sa /= 0) added(:, sa) = added(:, sa) + ma2(1:3) + IF (sb /= 0) added(:, sb) = added(:, sb) + ma2(4:6) + END DO + residual = residual + added + END IF + CALL model_contributor_force(model, model%q, model%v, load, es, em, end_nodes_only=.TRUE.) + IF (es /= 0) THEN + ErrStat = CD_MODEL_SOLVEFAIL + ErrMsg = 'CableDyn_Model: load assembly failed during coupled-load calculation: '//TRIM(em) + RETURN + END IF + residual(:, 1) = residual(:, 1) - load(1:3) + residual(:, 2) = residual(:, 2) - load(4:6) + DO k = 1, SIZE(model%fixed_dofs) + d = model%fixed_dofs(k) + IF (d <= 3) THEN + coupled_loads(k) = -residual(d, 1) + ELSE + coupled_loads(k) = -residual(d - end_base(2), 2) + END IF + END DO + + CONTAINS + + PURE INTEGER FUNCTION end_slot(node) RESULT(s) + !! 1 for the first node, 2 for the last, 0 for an interior node. + INTEGER, INTENT(IN) :: node + s = 0 + IF (node == 1) THEN + s = 1 + ELSE IF (node == nn) THEN + s = 2 + END IF + END FUNCTION end_slot + + PURE INTEGER FUNCTION end_base(s) RESULT(base) + !! DOF offset of end slot s. + INTEGER, INTENT(IN) :: s + base = MERGE(0, n - 3, s == 1) + END FUNCTION end_base + END SUBROUTINE coupled_loads_at_ends + SUBROUTINE CD_Calc_Model_CoupledKinematicDerivatives(model, dload_dq, dload_dv, ErrStat, ErrMsg) !! Analytic reduced coupled-load derivatives with respect to prescribed !! coupled positions and velocities. Free DOFs are statically condensed with @@ -6872,6 +7007,7 @@ SUBROUTINE CD_Copy_Model(src, dst, ErrStat, ErrMsg) work%has_viv = src%has_viv work%viv_rho = src%viv_rho work%viv_tw = src%viv_tw + work%viv_phi_rest = src%viv_phi_rest CALL copy_real1(src%viv_cl, work%viv_cl, 'viv_cl', ErrStat, ErrMsg) IF (ErrStat /= CD_MODEL_OK) RETURN CALL copy_real1(src%viv_d, work%viv_d, 'viv_d', ErrStat, ErrMsg) @@ -7043,6 +7179,7 @@ SUBROUTINE commit_model_copy(from, to) to%has_viv = from%has_viv to%viv_rho = from%viv_rho to%viv_tw = from%viv_tw + to%viv_phi_rest = from%viv_phi_rest CALL MOVE_ALLOC(from%viv_cl, to%viv_cl) CALL MOVE_ALLOC(from%viv_d, to%viv_d) CALL MOVE_ALLOC(from%viv_node, to%viv_node) @@ -9106,8 +9243,11 @@ PURE SUBROUTINE extract_element_state(model, e, q, v, idx, q2, v2) a = model%elem_conn(1, e) b = model%elem_conn(2, e) idx = [3*a - 2, 3*a - 1, 3*a, 3*b - 2, 3*b - 1, 3*b] - q2 = q(idx) - v2 = v(idx) + ! the two nodes' contiguous triples (the copies q(idx), v(idx) without a vector subscript) + q2(1:3) = q(3*a - 2:3*a) + q2(4:6) = q(3*b - 2:3*b) + v2(1:3) = v(3*a - 2:3*a) + v2(4:6) = v(3*b - 2:3*b) END SUBROUTINE extract_element_state PURE SUBROUTINE extract_element_positions(model, e, q, idx, q2) @@ -9122,7 +9262,8 @@ PURE SUBROUTINE extract_element_positions(model, e, q, idx, q2) a = model%elem_conn(1, e) b = model%elem_conn(2, e) idx = [3*a - 2, 3*a - 1, 3*a, 3*b - 2, 3*b - 1, 3*b] - q2 = q(idx) + q2(1:3) = q(3*a - 2:3*a) + q2(4:6) = q(3*b - 2:3*b) END SUBROUTINE extract_element_positions PURE SUBROUTINE extract_nodal_vector(field, model, e, field2) diff --git a/src/CableDyn_OpenFAST_Aggregate.f90 b/src/CableDyn_OpenFAST_Aggregate.f90 index 3fb0d595..0b965d12 100644 --- a/src/CableDyn_OpenFAST_Aggregate.f90 +++ b/src/CableDyn_OpenFAST_Aggregate.f90 @@ -41,7 +41,7 @@ MODULE CableDyn_OpenFAST_Aggregate !! pattern) -- the coupling dt freezes at Init and CD_AGG_Step_Moving fails closed on a step !! dt that differs from it (a mismatched size would silently desync the cables, whose !! generalised-alpha step carries the Init dt, from the mooring columns). - USE CableDyn_Precision, ONLY: wp, CD_ZERO, CD_ONE, CD_All_Finite + USE CableDyn_Precision, ONLY: wp, CD_ZERO, CD_ONE, CD_All_Finite, CD_MIN_TIME_STEP USE CableDyn_PathIO, ONLY: CD_Open_Write USE CableDyn_FatalReport, ONLY: CD_Fatal_Thread_Init USE, INTRINSIC :: ISO_FORTRAN_ENV, ONLY: int64 @@ -382,6 +382,12 @@ SUBROUTINE CD_AGG_Init_From_Deck(self, deck_path, dt, ErrStat, ErrMsg, env_gravi ErrMsg = 'CableDyn_OpenFAST_Aggregate: dt must be positive' RETURN END IF + IF (dt < CD_MIN_TIME_STEP) THEN + ErrStat = CD_AGG_BADINPUT + ErrMsg = 'CableDyn_OpenFAST_Aggregate: dt is below the smallest time step, 1e-100 s: the time '// & + 'integration divides by dt^2' + RETURN + END IF ALLOCATE (candidate, parts, STAT=istat) IF (istat /= 0) THEN ErrStat = CD_AGG_ALLOCFAIL @@ -1128,6 +1134,12 @@ SUBROUTINE CD_AGG_Step_Moving(self, dt, position, velocity, acceleration, conver ErrMsg = 'CableDyn_OpenFAST_Aggregate: step dt must be positive' RETURN END IF + IF (dt < CD_MIN_TIME_STEP) THEN + ErrStat = CD_AGG_BADINPUT + ErrMsg = 'CableDyn_OpenFAST_Aggregate: dt is below the smallest time step, 1e-100 s: the time '// & + 'integration divides by dt^2' + RETURN + END IF ! Fixed-dt contract: the cables advance with the Init dt frozen into their gen-alpha step, so a ! step dt differing from it would desync the cable columns from the mooring columns. Fail closed ! rather than silently mis-integrate (self%dt > 0 is guaranteed by Init's dt validation). diff --git a/src/CableDyn_OpenFAST_FMF.f90 b/src/CableDyn_OpenFAST_FMF.f90 index 2ac5ba61..64624aad 100644 --- a/src/CableDyn_OpenFAST_FMF.f90 +++ b/src/CableDyn_OpenFAST_FMF.f90 @@ -8,7 +8,7 @@ MODULE CableDyn_OpenFAST_FMF !! current registry-style types, point-mesh adapter, and lifecycle shell into a !! single Init/UpdateStates/CalcOutput/End object graph. The generated OpenFAST !! binding must preserve this behavior when it is linked against OpenFAST types. - USE CableDyn_Precision, ONLY: wp, CD_ZERO + USE CableDyn_Precision, ONLY: wp, CD_ZERO, CD_MIN_TIME_STEP USE CableDyn_Model, ONLY: CD_ModelType USE CableDyn_System, ONLY: CD_SystemType, CD_SystemPointType, CD_LineEndpointBinding, CD_Get_System_PointBlocks, & CD_System_NDynamicPoints, & @@ -113,6 +113,12 @@ SUBROUTINE CD_FMF_Init_From_Points(self, models, points, bindings, dt, ErrStat, ErrMsg = 'CableDyn_OpenFAST_FMF: dt must be positive' RETURN END IF + IF (dt < CD_MIN_TIME_STEP) THEN + ErrStat = CD_FMF_BADINPUT + ErrMsg = 'CableDyn_OpenFAST_FMF: dt is below the smallest time step, 1e-100 s: the time '// & + 'integration divides by dt^2' + RETURN + END IF candidate%init_input%n_coupled_dof = 0 candidate%init_input%dt = dt CALL CD_FAST_Init_From_Points(candidate%fast, models, points, bindings, es, em) @@ -171,6 +177,12 @@ SUBROUTINE CD_FMF_Init_From_Deck(self, deck_path, dt, ErrStat, ErrMsg, env_gravi ErrMsg = 'CableDyn_OpenFAST_FMF: dt must be positive' RETURN END IF + IF (dt < CD_MIN_TIME_STEP) THEN + ErrStat = CD_FMF_BADINPUT + ErrMsg = 'CableDyn_OpenFAST_FMF: dt is below the smallest time step, 1e-100 s: the time '// & + 'integration divides by dt^2' + RETURN + END IF candidate%init_input%dt = dt ! The host marches the coupled system (CD_FMF_Step at the caller's dt), so the ! deck's own dtM/TMax standalone-marching pairing is advisory here. Absent @@ -230,6 +242,12 @@ SUBROUTINE CD_FMF_Init_From_System(self, system, dt, gravity, rho_water, ErrStat ErrMsg = 'CableDyn_OpenFAST_FMF: dt must be positive' RETURN END IF + IF (dt < CD_MIN_TIME_STEP) THEN + ErrStat = CD_FMF_BADINPUT + ErrMsg = 'CableDyn_OpenFAST_FMF: dt is below the smallest time step, 1e-100 s: the time '// & + 'integration divides by dt^2' + RETURN + END IF candidate%init_input%dt = dt candidate%fast%system = system IF (.NOT. CD_FAST_IsInitialized(candidate%fast)) THEN @@ -335,6 +353,12 @@ SUBROUTINE CD_FMF_Step(self, dt, position, velocity, acceleration, converged, st ErrMsg = 'CableDyn_OpenFAST_FMF: step dt must be positive' RETURN END IF + IF (dt < CD_MIN_TIME_STEP) THEN + ErrStat = CD_FMF_BADINPUT + ErrMsg = 'CableDyn_OpenFAST_FMF: dt is below the smallest time step, 1e-100 s: the time '// & + 'integration divides by dt^2' + RETURN + END IF CALL CD_FAST_Set_PointMesh_State(self%point_mesh, position, velocity, acceleration, es, em) IF (es /= CD_FAST_MESH_OK) THEN CALL map_mesh_status(es, em, ErrStat, ErrMsg) diff --git a/src/CableDyn_Precision.f90 b/src/CableDyn_Precision.f90 index b9004995..69156bd5 100644 --- a/src/CableDyn_Precision.f90 +++ b/src/CableDyn_Precision.f90 @@ -15,6 +15,9 @@ MODULE CableDyn_Precision REAL(wp), PARAMETER, PUBLIC :: CD_ZERO = 0.0_wp REAL(wp), PARAMETER, PUBLIC :: CD_ONE = 1.0_wp + ! The smallest time step any march takes: the implicit integrators divide by dt^2, which + ! overflows the inertia terms near 1e-155 s; this bound keeps a wide margin above that. + REAL(wp), PARAMETER, PUBLIC :: CD_MIN_TIME_STEP = 1.0e-100_wp PUBLIC :: CD_All_Finite, CD_Is_Finite @@ -54,12 +57,20 @@ PURE LOGICAL FUNCTION all_finite_1(x) RESULT(finite) END FUNCTION all_finite_1 PURE LOGICAL FUNCTION all_finite_2(x) RESULT(finite) + ! The column test is inlined rather than called per column: the arrays checked most + ! often are 12 x 12 element matrices, where a call per column costs more than the test. REAL(wp), INTENT(IN) :: x(:, :) - INTEGER :: j + INTEGER :: i, j + INTEGER(I8) :: nonfinite, exponent finite = .TRUE. DO j = 1, SIZE(x, 2) - IF (.NOT. all_finite_1(x(:, j))) THEN + nonfinite = 0_I8 + DO i = 1, SIZE(x, 1) + exponent = IAND(SHIFTR(TRANSFER(x(i, j), 0_I8), 52), EXPONENT_MASK) + nonfinite = IOR(nonfinite, MERGE(1_I8, 0_I8, exponent == EXPONENT_MASK)) + END DO + IF (nonfinite /= 0_I8) THEN finite = .FALSE. RETURN END IF @@ -68,14 +79,22 @@ END FUNCTION all_finite_2 PURE LOGICAL FUNCTION all_finite_3(x) RESULT(finite) REAL(wp), INTENT(IN) :: x(:, :, :) - INTEGER :: k + INTEGER :: i, j, k + INTEGER(I8) :: nonfinite, exponent finite = .TRUE. DO k = 1, SIZE(x, 3) - IF (.NOT. all_finite_2(x(:, :, k))) THEN - finite = .FALSE. - RETURN - END IF + DO j = 1, SIZE(x, 2) + nonfinite = 0_I8 + DO i = 1, SIZE(x, 1) + exponent = IAND(SHIFTR(TRANSFER(x(i, j, k), 0_I8), 52), EXPONENT_MASK) + nonfinite = IOR(nonfinite, MERGE(1_I8, 0_I8, exponent == EXPONENT_MASK)) + END DO + IF (nonfinite /= 0_I8) THEN + finite = .FALSE. + RETURN + END IF + END DO END DO END FUNCTION all_finite_3 diff --git a/src/CableDyn_Static.f90 b/src/CableDyn_Static.f90 index 5afd5b3e..2ee5aa5a 100644 --- a/src/CableDyn_Static.f90 +++ b/src/CableDyn_Static.f90 @@ -726,6 +726,15 @@ SUBROUTINE CD_Static_Cable_Solve(q0, elem_conn, l0, ea, tension_only, f_ext, fix RETURN END IF END IF + ! Inside the round-off floor a residual can also cycle between two or more values (the + ! rounding of the last digits alternating), which the flat test above never sees: when + ! the last stall_window samples set no new minimum, there is no digit left to gain either + IF (k > cfg%stall_window .AND. hist(k) <= r_floor) THEN + IF (lo >= MINVAL(hist(1:k - cfg%stall_window))) THEN + converged = .TRUE. + RETURN + END IF + END IF END IF END DO ! exhausted max_iter without converging or stalling diff --git a/src/CableDyn_System.f90 b/src/CableDyn_System.f90 index 6ca7fc81..272563b8 100644 --- a/src/CableDyn_System.f90 +++ b/src/CableDyn_System.f90 @@ -1493,27 +1493,24 @@ RECURSIVE SUBROUTINE CD_Step_System(system, dt, q_coupled, v_coupled, a_coupled, ! Line models own disjoint state and Newton workspaces. Workers stage results; ! the following serial pass selects the first error and reduces flags in deck order. n_team = line_team_size(system) - !$OMP PARALLEL DEFAULT(SHARED) PRIVATE(i) NUM_THREADS(n_team) IF(n_team > 1) - CALL CD_Fatal_Thread_Init() ! this thread can report its own stack overflow - ! DYNAMIC: a line that is sub-stepped (CD_Step_Model) costs several of its plain steps, so the - ! lines take unequal times; each line's result does not depend on the thread that steps it - !$OMP DO SCHEDULE(DYNAMIC) - DO i = 1, system%n_lines - ! the halves of a stall recovery (0 < depth < MAX_SUBDIV) take their steps as given, as the - ! rungs of CD_Step_Model_Recovering do: no rotation- and snap-resolved sub-steps of - ! sub-steps. The plain full-dt rerun at the depth floor (depth = MAX_SUBDIV) steps every line - ! as the nominal step (depth 0) does, so its result is that of the step without the - ! fallback; the junction step (JUNCTION_NO_SUBDIV = MAX_SUBDIV) likewise, its armed lines - ! being taken as given by CD_Step_Model itself - CALL CD_Step_Model(system%lines(i), dt, system%line_converged(i), system%line_stalled(i), & - system%line_iter(i), system%line_stat(i), system%line_msg(i), & - prescribed_q=system%lines(i)%q_prescribed_work, & - prescribed_v=system%lines(i)%v_prescribed_work, & - prescribed_a=system%lines(i)%a_prescribed_work, & - as_given=depth > 0 .AND. depth < MAX_SUBDIV) - END DO - !$OMP END DO - !$OMP END PARALLEL + IF (n_team > 1) THEN + !$OMP PARALLEL DEFAULT(SHARED) PRIVATE(i) NUM_THREADS(n_team) + CALL CD_Fatal_Thread_Init() ! this thread can report its own stack overflow + ! DYNAMIC: a line that is sub-stepped (CD_Step_Model) costs several of its plain steps, so the + ! lines take unequal times; each line's result does not depend on the thread that steps it + !$OMP DO SCHEDULE(DYNAMIC) + DO i = 1, system%n_lines + CALL step_line(i) + END DO + !$OMP END DO + !$OMP END PARALLEL + ELSE + ! one thread: the same loop without entering a parallel region + CALL CD_Fatal_Thread_Init() + DO i = 1, system%n_lines + CALL step_line(i) + END DO + END IF DO i = 1, system%n_lines IF (system%line_stat(i) /= CD_MODEL_OK) THEN CALL restore_failed_step(system, system%line_stat(i), 'line step failed: '//TRIM(system%line_msg(i)), & @@ -1676,6 +1673,25 @@ RECURSIVE SUBROUTINE CD_Step_System(system, dt, q_coupled, v_coupled, a_coupled, END IF ErrStat = CD_SYSTEM_OK ErrMsg = '' + + CONTAINS + + SUBROUTINE step_line(il) + !! Step line il with its staged prescribed motion. The halves of a stall recovery + !! (0 < depth < MAX_SUBDIV) take their steps as given, as the rungs of + !! CD_Step_Model_Recovering do: no rotation- and snap-resolved sub-steps of sub-steps. The + !! plain full-dt rerun at the depth floor (depth = MAX_SUBDIV) steps every line as the + !! nominal step (depth 0) does, so its result is that of the step without the fallback; the + !! junction step (JUNCTION_NO_SUBDIV = MAX_SUBDIV) likewise, its armed lines being taken as + !! given by CD_Step_Model itself. + INTEGER, INTENT(IN) :: il + CALL CD_Step_Model(system%lines(il), dt, system%line_converged(il), system%line_stalled(il), & + system%line_iter(il), system%line_stat(il), system%line_msg(il), & + prescribed_q=system%lines(il)%q_prescribed_work, & + prescribed_v=system%lines(il)%v_prescribed_work, & + prescribed_a=system%lines(il)%a_prescribed_work, & + as_given=depth > 0 .AND. depth < MAX_SUBDIV) + END SUBROUTINE step_line END SUBROUTINE CD_Step_System SUBROUTINE CD_Step_System_Junction(system, dt, q_coupled, v_coupled, a_coupled, active, warm, loads, kmat, & @@ -2432,17 +2448,23 @@ SUBROUTINE CD_Calc_System_CoupledLoads(system, coupled_loads, ErrStat, ErrMsg) RETURN END IF n_team = line_team_size(system) - !$OMP PARALLEL DEFAULT(SHARED) PRIVATE(i, lo, hi) NUM_THREADS(n_team) IF(n_team > 1) - CALL CD_Fatal_Thread_Init() ! this thread can report its own stack overflow - !$OMP DO SCHEDULE(STATIC) - DO i = 1, system%n_lines - lo = system%line_off(i) - hi = system%line_off(i + 1) - 1 - CALL CD_Calc_Model_CoupledLoads(system%lines(i), system%line_load_work(lo:hi), & - system%line_stat(i), system%line_msg(i)) - END DO - !$OMP END DO - !$OMP END PARALLEL + IF (n_team > 1) THEN + !$OMP PARALLEL DEFAULT(SHARED) PRIVATE(i) NUM_THREADS(n_team) + CALL CD_Fatal_Thread_Init() ! this thread can report its own stack overflow + !$OMP DO SCHEDULE(STATIC) + DO i = 1, system%n_lines + CALL line_coupled_loads(i) + END DO + !$OMP END DO + !$OMP END PARALLEL + ELSE + ! one thread: the same loop without entering a parallel region (whose team setup costs + ! more than a short line's loads) + CALL CD_Fatal_Thread_Init() + DO i = 1, system%n_lines + CALL line_coupled_loads(i) + END DO + END IF DO i = 1, system%n_lines IF (system%line_stat(i) /= CD_MODEL_OK) THEN ErrStat = CD_SYSTEM_SOLVEFAIL @@ -2453,6 +2475,18 @@ SUBROUTINE CD_Calc_System_CoupledLoads(system, coupled_loads, ErrStat, ErrMsg) hi = system%line_off(i + 1) - 1 CALL accumulate_mapped_loads(system, lo, hi, system%line_load_work(lo:hi), coupled_loads) END DO + + CONTAINS + + SUBROUTINE line_coupled_loads(il) + !! The coupled loads of line il into its slice of the per-line workspace. + INTEGER, INTENT(IN) :: il + INTEGER :: l_lo, l_hi + l_lo = system%line_off(il) + l_hi = system%line_off(il + 1) - 1 + CALL CD_Calc_Model_CoupledLoads(system%lines(il), system%line_load_work(l_lo:l_hi), & + system%line_stat(il), system%line_msg(il)) + END SUBROUTINE line_coupled_loads END SUBROUTINE CD_Calc_System_CoupledLoads INTEGER FUNCTION line_team_size(system) RESULT(n_team) diff --git a/src/CableDyn_VIV.f90 b/src/CableDyn_VIV.f90 index 27d742cc..94a60ae0 100644 --- a/src/CableDyn_VIV.f90 +++ b/src/CableDyn_VIV.f90 @@ -268,15 +268,19 @@ ELEMENTAL REAL(wp) FUNCTION CD_VIV_Mean_Square(ms_old, sample, weight) RESULT(ms ms = ms_old + weight*(sample*sample - ms_old) END FUNCTION CD_VIV_Mean_Square - PURE REAL(wp) FUNCTION CD_VIV_Phase_Rate(yd, ydd, ms_yd, ms_ydd, phi, un, diameter, cf, df) RESULT(rate) + PURE REAL(wp) FUNCTION CD_VIV_Phase_Rate(yd, ydd, ms_yd, ms_ydd, phi, un, diameter, cf, df, phi_rest) RESULT(rate) !! Rate of the vortex-shedding phase, d phi/dt = 2 pi (cF + dF sin(phi_y - phi)) U/D, with !! the cross-flow velocity phase phi_y from y', y'' normalised by their running RMS values - !! (unnormalised while either mean square is still zero, as MoorDyn). + !! (unnormalised while either mean square is still zero, as MoorDyn). A node with no + !! cross-flow motion takes phi_y = phi_rest (default 0, MoorDyn's): pi on a line whose node + !! tangent runs against MoorDyn's, which turns the cross-flow axis and so phi_y half a turn. REAL(wp), INTENT(IN) :: yd, ydd, ms_yd, ms_ydd, phi, un, diameter, cf, df + REAL(wp), INTENT(IN), OPTIONAL :: phi_rest REAL(wp) :: phi_y IF (.NOT. (ABS(yd) > CD_ZERO .OR. ABS(ydd) > CD_ZERO)) THEN phi_y = CD_ZERO + IF (PRESENT(phi_rest)) phi_y = phi_rest ELSE IF (ms_yd > CD_ZERO .AND. ms_ydd > CD_ZERO) THEN phi_y = ATAN2(-ydd/SQRT(ms_ydd), yd/SQRT(ms_yd)) ELSE diff --git a/src/openfast/CableDyn_OF.f90 b/src/openfast/CableDyn_OF.f90 index fd427bbb..5cda9ff2 100644 --- a/src/openfast/CableDyn_OF.f90 +++ b/src/openfast/CableDyn_OF.f90 @@ -149,7 +149,7 @@ MODULE CableDyn ! the kinds of first-order linearization state (lin_state_map) INTEGER(IntKi), PARAMETER :: LIN1_VE = 1, LIN1_SYROPE = 2 - TYPE(ProgDesc), PARAMETER :: CableDyn_ProgDesc = ProgDesc( 'CableDyn', 'v0.4.1', '2026-11-08' ) + TYPE(ProgDesc), PARAMETER :: CableDyn_ProgDesc = ProgDesc( 'CableDyn', 'v0.4.2', '2026-11-09' ) INTERFACE ! 1 when the CableDyn core targets x86-64-v3 (CABLEDYN_TARGET_AVX2) and carries the ! start-up processor check of src/cabledyn_cpu_guard.c; the reference also keeps that diff --git a/tests/check_axial_damping_ratio.py b/tests/check_axial_damping_ratio.py new file mode 100644 index 00000000..d8da219c --- /dev/null +++ b/tests/check_axial_damping_ratio.py @@ -0,0 +1,227 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Axial damping of a negative BA under OPTION axialDampingRatio (driver_axial_damping_ratio in +CMakeLists.txt). + +A vertical taut line (99.5 m between points 100 m apart, no axial drag or added mass) is excited in +its first axial mode by a smooth half-cosine lift of its top end, held afterwards, and the free +decay of the anchor tension is fitted with one damped sinusoid. On the uniform line (EA = 5e7 N, +50 kg/m) the lift lasts 3/4 of the mode-1 period, which leaves the second mode at rest; the third, +damped three times as much, has died out before the fitted window. The composite line puts a +stiffer, heavier lower half (EA = 2e8 N, 100 kg/m) under the same upper half. + +* Default ``segment`` form, BA = -1 (BA = zeta L0 sqrt(EA m) of each element): the first axial + mode of the uniform line is damped at zeta pi/(2N), halving as the mesh doubles (N = 50, 100, + 200), and the initialisation note gives that ratio for the line's mesh. On the composite line + the ratio is the Rayleigh quotient of the axial chain with every element damped by its own EA + and mass, worked out here independently. +* ``mode1 axialDampingRatio``, BA = -0.02: the first axial mode is damped at 2 % on every mesh, + uniform and composite, on the EI = 0 route and on the finite-EI route, and no note is made. + The finite-EI route also checks the segment form and its note on 100 elements. A viscoelastic + section, whose first axial mode one BA does not set, is refused by name under mode1. + +Every fitted ratio must lie within 3 % of its target. + +Usage: check_axial_damping_ratio.py +""" + +import math +import pathlib +import re +import subprocess +import sys +import tempfile + +import numpy as np + +UPPER = ("rope", 5.0e7, 50.0) +LOWER = ("wire", 2.0e8, 100.0) +LENGTH = 99.5 +SPAN = 100.0 +TOP_Z = -10.0 +LIFT = 0.05 +OMEGA1 = math.pi / LENGTH * math.sqrt(UPPER[1] / UPPER[2]) +PERIOD = 2.0 * math.pi / OMEGA1 +DT = 0.002 +RAMP = 0.75 * PERIOD +WINDOW = (1.5, 7.5) +TOLERANCE = 0.03 +MESHES = (50, 100, 200) +ZETA_MODE1 = 0.02 + + +def deck(n_elem: int, ba: float, ei: float, mode1: bool, composite: bool = False) -> str: + option = "mode1 axialDampingRatio\n" if mode1 else "" + types = "".join(f"{name} 0.1 {mass} {ea} {ba} {ei} 1.2 0.0 1.0 0.0\n" for name, ea, mass in (UPPER, LOWER)) + if composite: + sections = f"1 rope {LENGTH / 2} {n_elem // 2}\n1 wire {LENGTH / 2} {n_elem // 2}\n" + else: + sections = f"1 rope {LENGTH} {n_elem}\n" + return f"""--------------------- CableDyn Input File ------------------------------------ +Free axial decay of a vertical taut line +--------------------- LINE TYPES --------------------------------------------- +TypeName Diam MassDenInAir EA BA/-zeta EI Cd_n Cd_t Ca_n Ca_t +(-) (m) (kg/m) (N) (N-s/-) (N-m^2) (-) (-) (-) (-) +{types}--------------------- POINTS ------------------------------------------------- +ID Type X Y Z Mass Vol CdA Ca +(-) (-) (m) (m) (m) (kg) (m^3) (m^2) (-) +1 Coupled 0.0 0.0 {TOP_Z} 0 0 0 0 +2 Fixed 0.0 0.0 {TOP_Z - SPAN} 0 0 0 0 +--------------------- LINES -------------------------------------------------- +ID NodeA NodeB Outputs +(-) (-) (-) (-) +1 1 2 - +--------------------- SECTIONS ----------------------------------------------- +LineID LineType Length NumSegs +(-) (-) (m) (-) +{sections}--------------------- OPTIONS ------------------------------------------------ +{option}9.80665 g +1025.0 rhoW +1.0 rhoInf +{DT} dtM +{WINDOW[1]} TMax +motion.txt motionFile +--------------------- OUTPUTS ------------------------------------------------ +"AnchTen1" +END +""" + + +def motion() -> str: + rows = ["# time point x y z vx vy vz ax ay az"] + for k in range(int(round(WINDOW[1] / DT)) + 2): + t = k * DT + if t < RAMP: + arg = math.pi * t / RAMP + z = 0.5 * LIFT * (1.0 - math.cos(arg)) + vz = 0.5 * LIFT * math.pi / RAMP * math.sin(arg) + az = 0.5 * LIFT * (math.pi / RAMP) ** 2 * math.cos(arg) + else: + z, vz, az = LIFT, 0.0, 0.0 + rows.append(f"{t:.6f} 1 0 0 {TOP_Z + z:.12g} 0 0 {vz:.12g} 0 0 {az:.12g}") + return "\n".join(rows) + "\n" + + +def run(exe: str, tmp: pathlib.Path, name: str, text: str) -> tuple[np.ndarray, np.ndarray, str]: + folder = tmp / name + folder.mkdir() + (folder / "motion.txt").write_text(motion()) + (folder / "deck.dat").write_text(text) + proc = subprocess.run([exe, "deck.dat", "run"], cwd=folder, capture_output=True, text=True) + if proc.returncode != 0: + raise SystemExit(f"FAIL: the driver did not run {name}:\n{(proc.stdout + proc.stderr)[-3000:]}") + lines = (folder / "run.out").read_text().splitlines() + names = [name.split("(")[0] for name in lines[1].split()] + data = np.array([[float(v) for v in row.split()] for row in lines[2:] if row.strip()]) + return data[:, names.index("Time")], data[:, names.index("AnchTen1")], proc.stdout + proc.stderr + + +def fit_decay(t: np.ndarray, y: np.ndarray) -> float: + """The damping ratio of y = c + exp(-s t) (a cos(w t) + b sin(w t)), by Gauss-Newton from a + zero-crossing frequency and a log-decrement start.""" + keep = (t >= WINDOW[0]) & (t <= WINDOW[1]) + t, y = t[keep] - WINDOW[0], y[keep] + yc = y - y.mean() + crossings = t[np.nonzero(np.diff(np.signbit(yc)))[0]] + w = math.pi * (len(crossings) - 1) / (crossings[-1] - crossings[0]) + half = len(t) // 2 + s = math.log(np.abs(yc[:half]).max() / np.abs(yc[half:]).max()) / (t[half] - t[0]) + p = np.array([y.mean(), yc[0], 0.0, s, w]) + for _ in range(100): + c, a, b, s, w = p + e = np.exp(-s * t) + cs, sn = np.cos(w * t), np.sin(w * t) + model = c + e * (a * cs + b * sn) + jac = np.column_stack( + [np.ones_like(t), e * cs, e * sn, -t * e * (a * cs + b * sn), t * e * (-a * sn + b * cs)] + ) + step = np.linalg.lstsq(jac, y - model, rcond=None)[0] + p = p + step + if abs(step[3]) <= 1.0e-12 * abs(p[3]) and abs(step[4]) <= 1.0e-12 * abs(p[4]): + break + s, w = p[3], p[4] + return s / math.hypot(s, w) + + +def chain_ratio(n_elem: int, zeta: float) -> float: + """The first-mode damping ratio of the composite line's axial chain (both ends held, element + stiffness EA/L0, damping zeta sqrt(EA m) = BA/L0 of each element itself, lumped masses).""" + half = n_elem // 2 + h = LENGTH / n_elem + ea = np.array([UPPER[1]] * half + [LOWER[1]] * half) + mass = np.array([UPPER[2]] * half + [LOWER[2]] * half) + k, c = ea / h, zeta * np.sqrt(ea * mass) + stiff, damp = np.zeros((n_elem - 1, n_elem - 1)), np.zeros((n_elem - 1, n_elem - 1)) + for e in range(n_elem): + for p, q, sign in ((e - 1, e - 1, 1), (e, e, 1), (e - 1, e, -1), (e, e - 1, -1)): + if 0 <= p < n_elem - 1 and 0 <= q < n_elem - 1: + stiff[p, q] += sign * k[e] + damp[p, q] += sign * c[e] + lumped = 0.5 * (mass[:-1] + mass[1:]) * h + scale = 1.0 / np.sqrt(lumped) + w2, vec = np.linalg.eigh(scale[:, None] * stiff * scale[None, :]) + u = scale * vec[:, 0] + return float(u @ damp @ u / (2.0 * math.sqrt(w2[0]) * (u @ (lumped * u)))) + + +def note_ratio(log: str) -> float | None: + match = re.search(r"first axial mode of the line \(both ends held\) at ([0-9.Ee+-]+) % of critical", log) + return None if match is None else float(match.group(1)) / 100.0 + + +def check(label: str, zeta: float, target: float) -> bool: + err = zeta / target - 1.0 + print(f"{label}: zeta_1 = {zeta:.5f}, target {target:.5f} ({err:+.2%})") + if abs(err) > TOLERANCE: + print(f"FAIL: {label} is not damped at its target ratio") + return False + return True + + +def main() -> int: + exe = sys.argv[1] + ok = True + with tempfile.TemporaryDirectory() as folder: + tmp = pathlib.Path(folder) + print(f"first axial mode of the uniform line: {OMEGA1:.4f} rad/s, period {PERIOD:.4f} s") + for n_elem, ei in [(n, 0.0) for n in MESHES] + [(100, 1.0)]: + target = math.pi / (2.0 * n_elem) + route = "finite-EI " if ei > 0.0 else "" + t, y, log = run(exe, tmp, f"segment_{n_elem}_{ei}", deck(n_elem, -1.0, ei, False)) + ok = check(f"segment {route}N={n_elem}", fit_decay(t, y), target) and ok + noted = note_ratio(log) + print(f" note: {noted}") + if noted is None or abs(noted / target - 1.0) > TOLERANCE: + print("FAIL: the note does not give the first-mode ratio of the segment form") + ok = False + if f"on its {n_elem} elements" not in log or "the axial damping depends on the mesh" not in log: + print("FAIL: the note does not name the mesh") + ok = False + t, y, log = run(exe, tmp, "segment_composite", deck(50, -1.0, 0.0, False, composite=True)) + ok = check("segment composite N=50", fit_decay(t, y), chain_ratio(50, 1.0)) and ok + cases = [(n, 0.0, False) for n in MESHES] + [(50, 0.0, True), (200, 0.0, True), (100, 1.0, False), (100, 1.0, True)] + for n_elem, ei, composite in cases: + label = f"mode1 {'finite-EI' if ei > 0.0 else 'EI=0'}{' composite' if composite else ''} N={n_elem}" + t, y, log = run(exe, tmp, label.replace(" ", "_").replace("=", ""), + deck(n_elem, -ZETA_MODE1, ei, True, composite=composite)) + ok = check(label, fit_decay(t, y), ZETA_MODE1) and ok + if "damping ratio per segment" in log: + print("FAIL: a mode1 line is noted as damped per segment") + ok = False + # a viscoelastic section has no one EA to set its first mode by: refused by name + text = deck(50, -ZETA_MODE1, 0.0, True).replace(f" {UPPER[1]} {-ZETA_MODE1} ", f" {UPPER[1]}|1.0e8 {-ZETA_MODE1}|0 ") + folder_ve = tmp / "mode1_viscoelastic" + folder_ve.mkdir() + (folder_ve / "motion.txt").write_text(motion()) + (folder_ve / "deck.dat").write_text(text) + proc = subprocess.run([exe, "deck.dat", "run"], cwd=folder_ve, capture_output=True, text=True) + refused = "OPTION axialDampingRatio mode1: LINE 1 has a negative BA and the section type rope" + print(f"mode1 viscoelastic: exit {proc.returncode}, refused by name: {refused in proc.stdout + proc.stderr}") + if proc.returncode == 0 or refused not in proc.stdout + proc.stderr: + print("FAIL: mode1 on a viscoelastic section is not refused by name") + ok = False + print("PASS" if ok else "FAIL") + return 0 if ok else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tests/check_end_tangent_channels.py b/tests/check_end_tangent_channels.py new file mode 100644 index 00000000..8121a280 --- /dev/null +++ b/tests/check_end_tangent_channels.py @@ -0,0 +1,135 @@ +# SPDX-License-Identifier: Apache-2.0 +"""The tangent outputs of a finite-EI line clamped at End A, through the standalone driver +(driver_end_tangent_channels in CMakeLists.txt). + +A cable is clamped at End A (END CONNECTIONS Rigid) along a set direction, swept over +declinations of 120 to 180 deg and azimuths of 0 and 20 deg, and pinned at End B. Every output +of the end tangent must equal the clamp's angles to round-off (1e-6 deg, the printed digits +allowing): the FairDecl, FairIncl, L1N1Dec and L1N1Azi channels, the first row of +the static profile (Declination, Inclination, Azimuth), the range graph's DeclinationMin and +DeclinationMax at node 1 over a short held march, and the ``line tangent`` line of the +initialisation report. The line bends within its first element at the clamp, where a +difference of node positions reads several degrees off. The same deck with an EI = 0 chain +beside the cable runs on the mixed route, whose fairlead report must give the clamp too. + +Usage: check_end_tangent_channels.py +""" + +import math +import pathlib +import re +import subprocess +import sys +import tempfile + +DECLINATIONS = (180.0, 165.0, 150.0, 135.0, 120.0) +AZIMUTHS = (0.0, 20.0) +TOL = 1.0e-6 +CHANNELS = ("FairDecl1", "FairIncl1", "L1N1Dec", "L1N1Azi") + + +def deck(dec: float, azi: float, mixed: bool) -> str: + d, a = math.radians(dec), math.radians(azi) + ez = (math.sin(d) * math.cos(a), math.sin(d) * math.sin(a), math.cos(d)) + types = "cable 0.2 60.0 1.0e8 -1.0 1.0e4 1.2 0.008 1.0 0.0\n" + points = "1 Coupled 0.0 0.0 -10.0 0 0 0 0\n2 Fixed 80.0 0.0 -80.0 0 0 0 0\n" + lines = "1 1 2 r\n" + sections = "1 cable 125.0 100\n" + if mixed: + types += "chain 0.1 20.0 5.0e8 -1.0 0.0 1.2 0.4 1.0 0.0\n" + points += "3 Coupled 0.0 50.0 -10.0 0 0 0 0\n4 Fixed 80.0 50.0 -80.0 0 0 0 0\n" + lines = "1 1 2 -\n2 3 4 -\n" + sections += "2 chain 125.0 40\n" + outputs = "".join(f'"{c}"\n' for c in CHANNELS) + return f"""--------------------- CableDyn Input File ------------------------------------ +tangent outputs of a cable clamped at End A +--------------------- LINE TYPES --------------------------------------------- +TypeName Diam MassDenInAir EA BA/-zeta EI Cd_n Cd_t Ca_n Ca_t +(-) (m) (kg/m) (N) (N-s/-) (N-m^2) (-) (-) (-) (-) +{types}--------------------- POINTS ------------------------------------------------- +ID Type X Y Z Mass Vol CdA Ca +(-) (-) (m) (m) (m) (kg) (m^3) (m^2) (-) +{points}--------------------- LINES -------------------------------------------------- +ID NodeA NodeB Outputs +(-) (-) (-) (-) +{lines}--------------------- SECTIONS ----------------------------------------------- +LineID LineType Length NumSegs +(-) (-) (m) (-) +{sections}--------------------- END CONNECTIONS ---------------------------------------- +LineID End Stiffness EzX EzY EzZ +(-) (-) (N-m/rad) (-) (-) (-) +1 A Rigid {ez[0]:.17g} {ez[1]:.17g} {ez[2]:.17g} +--------------------- OPTIONS ------------------------------------------------ +9.80665 g +1025.0 rhoW +0.05 dtM +{0.0 if mixed else 0.1} TMax +--------------------- OUTPUTS ------------------------------------------------ +{outputs}END +""" + + +def table(path: pathlib.Path, skip: int) -> tuple[list[str], list[list[float]]]: + rows = path.read_text().splitlines() + names = [n.split("(")[0] for n in rows[1].split()] + return names, [[float(v) for v in r.split()] for r in rows[skip:] if r.strip()] + + +def main() -> int: + exe = sys.argv[1] + failures = [] + + def check(ok: bool, what: str, got: float, want: float) -> None: + print(("ok " if ok else "FAIL ") + f"{what}: {got:.9f} deg (clamp {want:.9f})") + if not ok: + failures.append(what) + + with tempfile.TemporaryDirectory() as folder: + tmp = pathlib.Path(folder) + for dec in DECLINATIONS: + for azi in AZIMUTHS if dec < 180.0 else (0.0,): + tag = f"d{dec:g}_a{azi:g}" + want = {"FairDecl1": dec, "FairIncl1": dec - 90.0, "L1N1Dec": dec, + "L1N1Azi": azi} + for mixed in (False, True): + name = tag + ("_mixed" if mixed else "") + (tmp / f"{name}.dat").write_text(deck(dec, azi, mixed)) + proc = subprocess.run([exe, f"{name}.dat", name], cwd=tmp, capture_output=True, text=True) + if proc.returncode != 0: + failures.append(f"{name}: the driver failed") + print(f"FAIL {name}: the driver failed:\n{(proc.stdout + proc.stderr)[-1500:]}") + continue + log = proc.stdout + proc.stderr + if mixed: + match = re.search(r"Line 1: FairTen=\s*\S+ N, tangent inclination=\s*(\S+) deg", log) + got = float(match.group(1)) if match else math.nan + check(abs(got - (dec - 90.0)) <= 1.0e-3, f"{name} mixed report inclination", got, dec - 90.0) + continue + names, rows = table(tmp / f"{name}.out", 2) + for ch in CHANNELS: + if ch == "L1N1Azi" and dec == 180.0: + continue + got = rows[0][names.index(ch)] + check(abs(got - want[ch]) <= TOL, f"{name} {ch} at t = 0", got, want[ch]) + names, rows = table(tmp / f"{name}.static.out", 3) + first = rows[0] + check(abs(first[names.index("Declination")] - dec) <= TOL, f"{name} static Declination", + first[names.index("Declination")], dec) + check(abs(first[names.index("Inclination")] - (dec - 90.0)) <= TOL, + f"{name} static Inclination", first[names.index("Inclination")], dec - 90.0) + if dec < 180.0: + check(abs(first[names.index("Azimuth")] - azi) <= TOL, f"{name} static Azimuth", + first[names.index("Azimuth")], azi) + names, rows = table(tmp / f"{name}.Line1.range.out", 3) + for col in ("DeclinationMin", "DeclinationMax"): + got = rows[0][names.index(col)] + check(abs(got - dec) <= TOL, f"{name} range {col}", got, dec) + match = re.search(r"line tangent: inclination=\s*(\S+) deg, declination=\s*(\S+) deg", log) + got = float(match.group(2)) if match else math.nan + check(abs(got - dec) <= 1.0e-3, f"{name} report declination", got, dec) + print("PASS" if not failures else f"FAIL: {len(failures)} check(s)") + return 0 if not failures else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tests/check_example_fallbacks.py b/tests/check_example_fallbacks.py index b61d1dfd..67a210f4 100644 --- a/tests/check_example_fallbacks.py +++ b/tests/check_example_fallbacks.py @@ -2,8 +2,9 @@ # SPDX-License-Identifier: Apache-2.0 """Run every shipped example deck and fail on a solver fallback note. -Each deck of the examples directory runs on the given driver, single-threaded, with its output -root under a scratch directory. A deck offends when the driver does not exit with 0, runs past +Each deck of the examples directory and of its MoorDyn-C kinematics folders (moordynC_*) runs on +the given driver, single-threaded, from its own folder, with its output root under a scratch +directory. A deck offends when the driver does not exit with 0, runs past the timeout, or writes a fallback note to the console: a deck that should converge cleanly must not reach its result through a failed Newton solve, a stall, a looser tolerance or a sub-step that gave up. Such a note marks round-off fragility, which a different BLAS kernel can turn into a @@ -73,6 +74,15 @@ def fallback_notes(console: str) -> list[str]: return found +def example_decks(examples: Path) -> list[Path]: + """The shipped decks: every .dat of the examples directory and of its MoorDyn-C kinematics + folders (moordynC_*), whose decks read fixed-name files beside them. The data and openfast + folders hold auxiliary files and coupled decks, not standalone decks.""" + decks = [path for path in examples.glob("*.dat") if path.is_file()] + decks += [path for path in examples.glob("moordynC_*/*.dat") if path.is_file()] + return sorted(decks, key=lambda path: path.name) + + def run_deck( command: Sequence[str], deck: Path, @@ -185,7 +195,7 @@ def main(argv: Sequence[str] | None = None) -> int: parser.error("--kernel-only needs --coretype") examples = args.examples.resolve() - decks = sorted(path for path in examples.glob("*.dat") if path.is_file()) + decks = example_decks(examples) if not decks: print(f"FAIL: no example decks in {examples}") return 2 diff --git a/tests/check_touchdown_convergence.py b/tests/check_touchdown_convergence.py new file mode 100644 index 00000000..1ef2f4dd --- /dev/null +++ b/tests/check_touchdown_convergence.py @@ -0,0 +1,149 @@ +# SPDX-License-Identifier: Apache-2.0 +"""Node tension at touchdown converges at the element's order (driver_touchdown_convergence). + +A lazy-wave cable in a current is solved statically on three element sizes at touchdown +(about 1.6, 0.8 and 0.4 m), each on nine meshes that differ by a few elements in the section +that holds the touchdown point, so that the touchdown point falls at every position within its +element. A mesh 32 times finer than the 64-element base is the reference; nodes are compared at +the same unstretched arc length. The local error at touchdown is the largest departure of the +node tension error at the last suspended node, the first grounded node and the next node from +the error three nodes either side (the smooth discretisation error of the profile). Its largest +value over the nine meshes must fall at least by RATE when the elements are halved from 0.8 to +0.4 m, and stay below LIMIT on the 0.4 m meshes. + +The floor reaction of the first grounded node used to be spread over its grounded half-element +alone, whatever the position of the touchdown point in the touchdown element: the local error +then fell at the first order (4.3, 1.9, 1.0 N on the three sizes, against a line tension of +about 270 N there). + +Usage: check_touchdown_convergence.py +""" + +import bisect +import pathlib +import subprocess +import sys +import tempfile + +FLOOR_Z = -80.0 +LENGTHS = (68.114, 50.0, 52.101) +BASE = (28, 20, 16) # elements per section of the 64-element base mesh +LEVELS = (2, 4, 8) # multipliers of the base mesh +SHIFTS = range(-4, 5) # elements added to the touchdown section of each level +REFERENCE = 32 +RATE = 2.5 +LIMIT = 0.35 # N, on the 0.4 m meshes + +DECK = """--------------------- CableDyn Input File ------------------------------------ +Touchdown convergence check: lazy-wave cable in a current, static +--------------------- LINE TYPES --------------------------------------------- +TypeName Diam MassDenInAir EA BA EI Cd_n Cd_t Ca_n Ca_t +(-) (m) (kg/m) (N) (-) (N-m2) (-) (-) (-) (-) +bare 0.160 36.70 4.69e8 0.0 1.99e4 1.2 0.1 1.0 0.0 +buoy 0.290 0.0 4.69e8 0.0 1.99e4 1.2 0.1 1.0 0.0 +--------------------- POINTS ------------------------------------------------ +ID Type X Y Z +(-) (-) (m) (m) (m) +1 Coupled 5.0 0.0 -14.0 +2 Fixed 125.0 0.0 -80.0 +--------------------- LINES ------------------------------------------------- +ID NodeA NodeB Outputs +(-) (-) (-) (-) +1 1 2 - +--------------------- SECTIONS ---------------------------------------------- +LineID LineType Length NumSegs +(-) (-) (m) (-) +1 bare 68.114 {n1} +1 buoy 50.000 {n2} +1 bare 52.101 {n3} +--------------------- EQUIVALENT BUOYANCY ----------------------------------- +LineType Diam SubmergedWeightNpm +(-) (m) (N/m) +buoy 0.290 -80.15 +--------------------- OPTIONS ----------------------------------------------- +9.80665 g +1025.0 rhoW +80.0 WtrDpth +1.0e5 kBot +1.0e4 cBot +0.05 dtM +0.0 TMax +uniform 0.5 0.0 0.0 current +--------------------- OUTPUTS ----------------------------------------------- +"FairTen1" +--------------------- need this line ---------------------------------------- +""" + + +def static_profile(exe, work, counts): + """Unstretched arc length, height and node tension of every node of the static state.""" + name = "m_" + "_".join(str(n) for n in counts) + deck = work / f"{name}.dat" + deck.write_text(DECK.format(n1=counts[0], n2=counts[1], n3=counts[2]), encoding="utf-8") + run = subprocess.run([exe, str(deck), str(work / name)], capture_output=True, text=True, check=False) + if run.returncode != 0: + raise SystemExit(f"FAIL: the {name} deck did not solve (exit {run.returncode}):\n{run.stdout}{run.stderr}") + lines = (work / f"{name}.static.out").read_text(encoding="utf-8").splitlines() + header = lines[1].split() + if "DeckNode" in header: + raise SystemExit(f"FAIL: the static solve refined the {name} mesh") + iz, it = header.index("Z"), header.index("Tension") + rows = [line.split() for line in lines[3:] if line.strip()] + arc = [0.0] + start = 0.0 + for length, n in zip(LENGTHS, counts): + arc += [start + length * k / n for k in range(1, n + 1)] + start += length + if len(rows) != len(arc): + raise SystemExit(f"FAIL: {len(rows)} rows in {name}.static.out, expected {len(arc)}") + return arc, [float(r[iz]) for r in rows], [float(r[it]) for r in rows] + + +def interpolate(xs, ys, x): + k = min(max(bisect.bisect_left(xs, x), 1), len(xs) - 1) + f = (x - xs[k - 1]) / (xs[k] - xs[k - 1]) + return ys[k - 1] + f * (ys[k] - ys[k - 1]) + + +def local_error(exe, work, counts, reference): + """Largest local tension error at touchdown, and the element size there.""" + arc, z, t = static_profile(exe, work, counts) + first = next(j for j in range(1, len(z)) if z[j] <= FLOOR_Z + 1e-6 and z[j - 1] > FLOOR_Z + 1e-6) + err = [t[j] - interpolate(reference[0], reference[1], arc[j]) for j in range(len(arc))] + background = 0.5 * (err[first - 3] + err[first + 3]) + return max(abs(err[j] - background) for j in range(first - 1, first + 2)), arc[first] - arc[first - 1] + + +def main(): + if len(sys.argv) != 2: + raise SystemExit(__doc__) + exe = sys.argv[1] + worst = [] + with tempfile.TemporaryDirectory() as tmp: + work = pathlib.Path(tmp) + r_arc, _, r_t = static_profile(exe, work, tuple(REFERENCE * n for n in BASE)) + for m in LEVELS: + values = [] + for shift in SHIFTS: + counts = (BASE[0] * m, BASE[1] * m, BASE[2] * m + shift) + e, h = local_error(exe, work, counts, (r_arc, r_t)) + values.append(e) + worst.append(max(values)) + listed = " ".join(f"{v:.3f}" for v in values) + print(f" {BASE[2] * m + SHIFTS[0]}-{BASE[2] * m + SHIFTS[-1]} elements in the touchdown section " + f"(about {h:.2f} m): local error {listed} N; largest {worst[-1]:.3f} N") + rate = worst[-2] / max(worst[-1], 1e-12) + print(f" largest local error {worst[-2]:.3f} N -> {worst[-1]:.3f} N when the elements are halved: " + f"ratio {rate:.2f} (at least {RATE}; second order 4)") + failures = [] + if rate < RATE: + failures.append(f"the local error fell by {rate:.2f} per halving of the elements (at least {RATE})") + if worst[-1] > LIMIT: + failures.append(f"local error {worst[-1]:.3f} N on the 0.4 m meshes (limit {LIMIT} N)") + if failures: + raise SystemExit("FAIL: node tension at touchdown does not converge at second order: " + "; ".join(failures)) + print("PASS: node tension at touchdown converges at second order wherever the touchdown point falls") + + +if __name__ == "__main__": + main() diff --git a/tests/data/cable_statics_matrix.json b/tests/data/cable_statics_matrix.json index 9e5e0d41..c1b3541c 100644 --- a/tests/data/cable_statics_matrix.json +++ b/tests/data/cable_statics_matrix.json @@ -1612,5 +1612,137 @@ } }, "mesh_of": "ROUGH_1003" + }, + { + "id": "SIS_B800_EA5E7_EI5E2", + "expect": "admissible", + "why": "static_init_sweep case 87 (family b, depth 800 m, slackness 1.25, buoyancy ratio 1.5, EA 5e+07 N, EI 500 N m2, kBot 100000, span ratio 1, buoyant fraction 0.29) through the deck route; oracle: elastic multi-segment EI = 0 catenary", + "deck": "--------------------- CableDyn Input File ------------------------------------\nSW_B800_EA5E7_EI5E2\n--------------------- LINE TYPES ---------------------------------------------\nTypeName Diam MassDenInAir EA BA EI Cd_n Cd_t Ca_n Ca_t\n(-) (m) (kg/m) (N) (-) (N-m2) (-) (-) (-) (-)\nbare 0.160 36.720364 5e+07 0.0 500 1.2 0.1 1.0 0.0\nbuoy 0.290 0.0 5e+07 0.0 500 1.2 0.1 1.0 0.0\n--------------------- POINTS ------------------------------------------------\nID Type X Y Z\n(-) (-) (m) (m) (m)\n1 Coupled 0.0 0.0 -16\n2 Fixed 800 0.0 -800\n--------------------- LINES -------------------------------------------------\nID NodeA NodeB Outputs\n(-) (-) (-) (-)\n1 1 2 -\n--------------------- SECTIONS ----------------------------------------------\nLineID LineType Length NumSegs\n(-) (-) (m) (-)\n1 bare 393.790176522 72\n1 buoy 404.728792536 74\n1 bare 601.623880797 110\n--------------------- EQUIVALENT BUOYANCY -----------------------------------\nLineType Diam SubmergedWeightNpm\n(-) (m) (N/m)\nbuoy 0.290 -237\n--------------------- OPTIONS -----------------------------------------------\n800 WtrDpth\n100000 kBot\n0.0 TMax\nnone frictionMu\n--------------------- OUTPUTS -----------------------------------------------\n\"FairTen1\"\n\"AnchTen1\"\n--------------------- need this line ----------------------------------------\n", + "lines": { + "1": { + "oracle_tfair": [ + 45921.372599184884 + ], + "lambda_over_length": 0.0010485728908409383 + } + } + }, + { + "id": "SIS_B800_EA5E7_EI5E2_SEQ", + "expect": "admissible", + "why": "static_init_sweep case 87 (family b, depth 800 m, slackness 1.25, buoyancy ratio 1.5, EA 5e+07 N, EI 500 N m2, kBot 100000, span ratio 1, buoyant fraction 0.29) through the deck route, mesh-sequenced route first; oracle: elastic multi-segment EI = 0 catenary", + "deck": "--------------------- CableDyn Input File ------------------------------------\nSW_B800_EA5E7_EI5E2_SEQ\n--------------------- LINE TYPES ---------------------------------------------\nTypeName Diam MassDenInAir EA BA EI Cd_n Cd_t Ca_n Ca_t\n(-) (m) (kg/m) (N) (-) (N-m2) (-) (-) (-) (-)\nbare 0.160 36.720364 5e+07 0.0 500 1.2 0.1 1.0 0.0\nbuoy 0.290 0.0 5e+07 0.0 500 1.2 0.1 1.0 0.0\n--------------------- POINTS ------------------------------------------------\nID Type X Y Z\n(-) (-) (m) (m) (m)\n1 Coupled 0.0 0.0 -16\n2 Fixed 800 0.0 -800\n--------------------- LINES -------------------------------------------------\nID NodeA NodeB Outputs\n(-) (-) (-) (-)\n1 1 2 -\n--------------------- SECTIONS ----------------------------------------------\nLineID LineType Length NumSegs\n(-) (-) (m) (-)\n1 bare 393.790176522 72\n1 buoy 404.728792536 74\n1 bare 601.623880797 110\n--------------------- EQUIVALENT BUOYANCY -----------------------------------\nLineType Diam SubmergedWeightNpm\n(-) (m) (N/m)\nbuoy 0.290 -237\n--------------------- OPTIONS -----------------------------------------------\n800 WtrDpth\n100000 kBot\n0.0 TMax\nnone frictionMu\nsequenced cable_statics\n--------------------- OUTPUTS -----------------------------------------------\n\"FairTen1\"\n\"AnchTen1\"\n--------------------- need this line ----------------------------------------\n", + "lines": { + "1": { + "oracle_tfair": [ + 45921.372599184884 + ], + "lambda_over_length": 0.0010485728908409383 + } + } + }, + { + "id": "SIS_B800_EA2E9_EI5E2", + "expect": "admissible", + "why": "static_init_sweep case 89 (family b, depth 800 m, slackness 1.25, buoyancy ratio 1.5, EA 2e+09 N, EI 500 N m2, kBot 100000, span ratio 1, buoyant fraction 0.29) through the deck route; oracle: elastic multi-segment EI = 0 catenary", + "deck": "--------------------- CableDyn Input File ------------------------------------\nSW_B800_EA2E9_EI5E2\n--------------------- LINE TYPES ---------------------------------------------\nTypeName Diam MassDenInAir EA BA EI Cd_n Cd_t Ca_n Ca_t\n(-) (m) (kg/m) (N) (-) (N-m2) (-) (-) (-) (-)\nbare 0.160 36.720364 2e+09 0.0 500 1.2 0.1 1.0 0.0\nbuoy 0.290 0.0 2e+09 0.0 500 1.2 0.1 1.0 0.0\n--------------------- POINTS ------------------------------------------------\nID Type X Y Z\n(-) (-) (m) (m) (m)\n1 Coupled 0.0 0.0 -16\n2 Fixed 800 0.0 -800\n--------------------- LINES -------------------------------------------------\nID NodeA NodeB Outputs\n(-) (-) (-) (-)\n1 1 2 -\n--------------------- SECTIONS ----------------------------------------------\nLineID LineType Length NumSegs\n(-) (-) (m) (-)\n1 bare 393.790176522 72\n1 buoy 404.728792536 74\n1 bare 601.623880797 110\n--------------------- EQUIVALENT BUOYANCY -----------------------------------\nLineType Diam SubmergedWeightNpm\n(-) (m) (N/m)\nbuoy 0.290 -237\n--------------------- OPTIONS -----------------------------------------------\n800 WtrDpth\n100000 kBot\n0.0 TMax\nnone frictionMu\n--------------------- OUTPUTS -----------------------------------------------\n\"FairTen1\"\n\"AnchTen1\"\n--------------------- need this line ----------------------------------------\n", + "lines": { + "1": { + "oracle_tfair": [ + 45968.597408873895 + ], + "lambda_over_length": 0.0010485728908409383 + } + } + }, + { + "id": "SIS_B800_EA2E9_EI5E2_SEQ", + "expect": "admissible", + "why": "static_init_sweep case 89 (family b, depth 800 m, slackness 1.25, buoyancy ratio 1.5, EA 2e+09 N, EI 500 N m2, kBot 100000, span ratio 1, buoyant fraction 0.29) through the deck route, mesh-sequenced route first; oracle: elastic multi-segment EI = 0 catenary", + "deck": "--------------------- CableDyn Input File ------------------------------------\nSW_B800_EA2E9_EI5E2_SEQ\n--------------------- LINE TYPES ---------------------------------------------\nTypeName Diam MassDenInAir EA BA EI Cd_n Cd_t Ca_n Ca_t\n(-) (m) (kg/m) (N) (-) (N-m2) (-) (-) (-) (-)\nbare 0.160 36.720364 2e+09 0.0 500 1.2 0.1 1.0 0.0\nbuoy 0.290 0.0 2e+09 0.0 500 1.2 0.1 1.0 0.0\n--------------------- POINTS ------------------------------------------------\nID Type X Y Z\n(-) (-) (m) (m) (m)\n1 Coupled 0.0 0.0 -16\n2 Fixed 800 0.0 -800\n--------------------- LINES -------------------------------------------------\nID NodeA NodeB Outputs\n(-) (-) (-) (-)\n1 1 2 -\n--------------------- SECTIONS ----------------------------------------------\nLineID LineType Length NumSegs\n(-) (-) (m) (-)\n1 bare 393.790176522 72\n1 buoy 404.728792536 74\n1 bare 601.623880797 110\n--------------------- EQUIVALENT BUOYANCY -----------------------------------\nLineType Diam SubmergedWeightNpm\n(-) (m) (N/m)\nbuoy 0.290 -237\n--------------------- OPTIONS -----------------------------------------------\n800 WtrDpth\n100000 kBot\n0.0 TMax\nnone frictionMu\nsequenced cable_statics\n--------------------- OUTPUTS -----------------------------------------------\n\"FairTen1\"\n\"AnchTen1\"\n--------------------- need this line ----------------------------------------\n", + "lines": { + "1": { + "oracle_tfair": [ + 45968.597408873895 + ], + "lambda_over_length": 0.0010485728908409383 + } + } + }, + { + "id": "SIS_B800_EI5E2", + "expect": "admissible", + "why": "static_init_sweep case 91 (family b, depth 800 m, slackness 1.25, buoyancy ratio 1.5, EA 4.69e+08 N, EI 500 N m2, kBot 100000, span ratio 1, buoyant fraction 0.29) through the deck route; oracle: elastic multi-segment EI = 0 catenary", + "deck": "--------------------- CableDyn Input File ------------------------------------\nSW_B800_EI5E2\n--------------------- LINE TYPES ---------------------------------------------\nTypeName Diam MassDenInAir EA BA EI Cd_n Cd_t Ca_n Ca_t\n(-) (m) (kg/m) (N) (-) (N-m2) (-) (-) (-) (-)\nbare 0.160 36.720364 4.69e+08 0.0 500 1.2 0.1 1.0 0.0\nbuoy 0.290 0.0 4.69e+08 0.0 500 1.2 0.1 1.0 0.0\n--------------------- POINTS ------------------------------------------------\nID Type X Y Z\n(-) (-) (m) (m) (m)\n1 Coupled 0.0 0.0 -16\n2 Fixed 800 0.0 -800\n--------------------- LINES -------------------------------------------------\nID NodeA NodeB Outputs\n(-) (-) (-) (-)\n1 1 2 -\n--------------------- SECTIONS ----------------------------------------------\nLineID LineType Length NumSegs\n(-) (-) (m) (-)\n1 bare 393.790176522 72\n1 buoy 404.728792536 74\n1 bare 601.623880797 110\n--------------------- EQUIVALENT BUOYANCY -----------------------------------\nLineType Diam SubmergedWeightNpm\n(-) (m) (N/m)\nbuoy 0.290 -237\n--------------------- OPTIONS -----------------------------------------------\n800 WtrDpth\n100000 kBot\n0.0 TMax\nnone frictionMu\n--------------------- OUTPUTS -----------------------------------------------\n\"FairTen1\"\n\"AnchTen1\"\n--------------------- need this line ----------------------------------------\n", + "lines": { + "1": { + "oracle_tfair": [ + 45964.63285892178 + ], + "lambda_over_length": 0.0010485728908409383 + } + } + }, + { + "id": "SIS_B800_EI5E2_SEQ", + "expect": "admissible", + "why": "static_init_sweep case 91 (family b, depth 800 m, slackness 1.25, buoyancy ratio 1.5, EA 4.69e+08 N, EI 500 N m2, kBot 100000, span ratio 1, buoyant fraction 0.29) through the deck route, mesh-sequenced route first; oracle: elastic multi-segment EI = 0 catenary", + "deck": "--------------------- CableDyn Input File ------------------------------------\nSW_B800_EI5E2_SEQ\n--------------------- LINE TYPES ---------------------------------------------\nTypeName Diam MassDenInAir EA BA EI Cd_n Cd_t Ca_n Ca_t\n(-) (m) (kg/m) (N) (-) (N-m2) (-) (-) (-) (-)\nbare 0.160 36.720364 4.69e+08 0.0 500 1.2 0.1 1.0 0.0\nbuoy 0.290 0.0 4.69e+08 0.0 500 1.2 0.1 1.0 0.0\n--------------------- POINTS ------------------------------------------------\nID Type X Y Z\n(-) (-) (m) (m) (m)\n1 Coupled 0.0 0.0 -16\n2 Fixed 800 0.0 -800\n--------------------- LINES -------------------------------------------------\nID NodeA NodeB Outputs\n(-) (-) (-) (-)\n1 1 2 -\n--------------------- SECTIONS ----------------------------------------------\nLineID LineType Length NumSegs\n(-) (-) (m) (-)\n1 bare 393.790176522 72\n1 buoy 404.728792536 74\n1 bare 601.623880797 110\n--------------------- EQUIVALENT BUOYANCY -----------------------------------\nLineType Diam SubmergedWeightNpm\n(-) (m) (N/m)\nbuoy 0.290 -237\n--------------------- OPTIONS -----------------------------------------------\n800 WtrDpth\n100000 kBot\n0.0 TMax\nnone frictionMu\nsequenced cable_statics\n--------------------- OUTPUTS -----------------------------------------------\n\"FairTen1\"\n\"AnchTen1\"\n--------------------- need this line ----------------------------------------\n", + "lines": { + "1": { + "oracle_tfair": [ + 45964.63285892178 + ], + "lambda_over_length": 0.0010485728908409383 + } + } + }, + { + "id": "SIS_F800_KN3E6_EI5E2", + "expect": "admissible", + "why": "static_init_sweep case 115 (family f, depth 800 m, slackness 1.372, buoyancy ratio 2.5, EA 4.69e+08 N, EI 500 N m2, kBot 3e+06, span ratio 1, buoyant fraction 0.29) through the deck route; the buoyant arch floats at the surface, so no submerged EI = 0 root applies", + "deck": "--------------------- CableDyn Input File ------------------------------------\nSW_F800_KN3E6_EI5E2\n--------------------- LINE TYPES ---------------------------------------------\nTypeName Diam MassDenInAir EA BA EI Cd_n Cd_t Ca_n Ca_t\n(-) (m) (kg/m) (N) (-) (N-m2) (-) (-) (-) (-)\nbare 0.160 36.720364 4.69e+08 0.0 500 1.2 0.1 1.0 0.0\nbuoy 0.290 0.0 4.69e+08 0.0 500 1.2 0.1 1.0 0.0\n--------------------- POINTS ------------------------------------------------\nID Type X Y Z\n(-) (-) (m) (m) (m)\n1 Coupled 0.0 0.0 -16\n2 Fixed 800 0.0 -800\n--------------------- LINES -------------------------------------------------\nID NodeA NodeB Outputs\n(-) (-) (-) (-)\n1 1 2 -\n--------------------- SECTIONS ----------------------------------------------\nLineID LineType Length NumSegs\n(-) (-) (m) (-)\n1 bare 432.135000000 72\n1 buoy 444.138750000 74\n1 bare 660.206250000 110\n--------------------- EQUIVALENT BUOYANCY -----------------------------------\nLineType Diam SubmergedWeightNpm\n(-) (m) (N/m)\nbuoy 0.290 -395\n--------------------- OPTIONS -----------------------------------------------\n800 WtrDpth\n3e+06 kBot\n0.0 TMax\nnone frictionMu\n--------------------- OUTPUTS -----------------------------------------------\n\"FairTen1\"\n\"AnchTen1\"\n--------------------- need this line ----------------------------------------\n", + "lines": { + "1": { + "oracle_tfair": [], + "lambda_over_length": 0.0009555294150673793 + } + } + }, + { + "id": "SIS_F800_KN3E6_EI5E2_SEQ", + "expect": "admissible", + "why": "static_init_sweep case 115 (family f, depth 800 m, slackness 1.372, buoyancy ratio 2.5, EA 4.69e+08 N, EI 500 N m2, kBot 3e+06, span ratio 1, buoyant fraction 0.29) through the deck route, mesh-sequenced route first; the buoyant arch floats at the surface, so no submerged EI = 0 root applies", + "deck": "--------------------- CableDyn Input File ------------------------------------\nSW_F800_KN3E6_EI5E2_SEQ\n--------------------- LINE TYPES ---------------------------------------------\nTypeName Diam MassDenInAir EA BA EI Cd_n Cd_t Ca_n Ca_t\n(-) (m) (kg/m) (N) (-) (N-m2) (-) (-) (-) (-)\nbare 0.160 36.720364 4.69e+08 0.0 500 1.2 0.1 1.0 0.0\nbuoy 0.290 0.0 4.69e+08 0.0 500 1.2 0.1 1.0 0.0\n--------------------- POINTS ------------------------------------------------\nID Type X Y Z\n(-) (-) (m) (m) (m)\n1 Coupled 0.0 0.0 -16\n2 Fixed 800 0.0 -800\n--------------------- LINES -------------------------------------------------\nID NodeA NodeB Outputs\n(-) (-) (-) (-)\n1 1 2 -\n--------------------- SECTIONS ----------------------------------------------\nLineID LineType Length NumSegs\n(-) (-) (m) (-)\n1 bare 432.135000000 72\n1 buoy 444.138750000 74\n1 bare 660.206250000 110\n--------------------- EQUIVALENT BUOYANCY -----------------------------------\nLineType Diam SubmergedWeightNpm\n(-) (m) (N/m)\nbuoy 0.290 -395\n--------------------- OPTIONS -----------------------------------------------\n800 WtrDpth\n3e+06 kBot\n0.0 TMax\nnone frictionMu\nsequenced cable_statics\n--------------------- OUTPUTS -----------------------------------------------\n\"FairTen1\"\n\"AnchTen1\"\n--------------------- need this line ----------------------------------------\n", + "lines": { + "1": { + "oracle_tfair": [], + "lambda_over_length": 0.0009555294150673793 + } + } + }, + { + "id": "SIS_F200_FB040_EI5E2", + "expect": "admissible", + "why": "static_init_sweep case 118 (family f, depth 200 m, slackness 1.25, buoyancy ratio 2.5, EA 4.69e+08 N, EI 500 N m2, kBot 100000, span ratio 1, buoyant fraction 0.4) through the deck route; the buoyant arch floats at the surface, so no submerged EI = 0 root applies", + "deck": "--------------------- CableDyn Input File ------------------------------------\nSW_F200_FB040_EI5E2\n--------------------- LINE TYPES ---------------------------------------------\nTypeName Diam MassDenInAir EA BA EI Cd_n Cd_t Ca_n Ca_t\n(-) (m) (kg/m) (N) (-) (N-m2) (-) (-) (-) (-)\nbare 0.160 36.720364 4.69e+08 0.0 500 1.2 0.1 1.0 0.0\nbuoy 0.290 0.0 4.69e+08 0.0 500 1.2 0.1 1.0 0.0\n--------------------- POINTS ------------------------------------------------\nID Type X Y Z\n(-) (-) (m) (m) (m)\n1 Coupled 0.0 0.0 -4\n2 Fixed 200 0.0 -200\n--------------------- LINES -------------------------------------------------\nID NodeA NodeB Outputs\n(-) (-) (-) (-)\n1 1 2 -\n--------------------- SECTIONS ----------------------------------------------\nLineID LineType Length NumSegs\n(-) (-) (m) (-)\n1 bare 97.232142351 20\n1 buoy 140.986606409 29\n1 bare 111.816963704 23\n--------------------- EQUIVALENT BUOYANCY -----------------------------------\nLineType Diam SubmergedWeightNpm\n(-) (m) (N/m)\nbuoy 0.290 -395\n--------------------- OPTIONS -----------------------------------------------\n200 WtrDpth\n100000 kBot\n0.0 TMax\nnone frictionMu\n--------------------- OUTPUTS -----------------------------------------------\n\"FairTen1\"\n\"AnchTen1\"\n--------------------- need this line ----------------------------------------\n", + "lines": { + "1": { + "oracle_tfair": [], + "lambda_over_length": 0.0041942915633607575 + } + } + }, + { + "id": "SIS_F200_FB040_EI5E2_SEQ", + "expect": "admissible", + "why": "static_init_sweep case 118 (family f, depth 200 m, slackness 1.25, buoyancy ratio 2.5, EA 4.69e+08 N, EI 500 N m2, kBot 100000, span ratio 1, buoyant fraction 0.4) through the deck route, mesh-sequenced route first; the buoyant arch floats at the surface, so no submerged EI = 0 root applies", + "deck": "--------------------- CableDyn Input File ------------------------------------\nSW_F200_FB040_EI5E2_SEQ\n--------------------- LINE TYPES ---------------------------------------------\nTypeName Diam MassDenInAir EA BA EI Cd_n Cd_t Ca_n Ca_t\n(-) (m) (kg/m) (N) (-) (N-m2) (-) (-) (-) (-)\nbare 0.160 36.720364 4.69e+08 0.0 500 1.2 0.1 1.0 0.0\nbuoy 0.290 0.0 4.69e+08 0.0 500 1.2 0.1 1.0 0.0\n--------------------- POINTS ------------------------------------------------\nID Type X Y Z\n(-) (-) (m) (m) (m)\n1 Coupled 0.0 0.0 -4\n2 Fixed 200 0.0 -200\n--------------------- LINES -------------------------------------------------\nID NodeA NodeB Outputs\n(-) (-) (-) (-)\n1 1 2 -\n--------------------- SECTIONS ----------------------------------------------\nLineID LineType Length NumSegs\n(-) (-) (m) (-)\n1 bare 97.232142351 20\n1 buoy 140.986606409 29\n1 bare 111.816963704 23\n--------------------- EQUIVALENT BUOYANCY -----------------------------------\nLineType Diam SubmergedWeightNpm\n(-) (m) (N/m)\nbuoy 0.290 -395\n--------------------- OPTIONS -----------------------------------------------\n200 WtrDpth\n100000 kBot\n0.0 TMax\nnone frictionMu\nsequenced cable_statics\n--------------------- OUTPUTS -----------------------------------------------\n\"FairTen1\"\n\"AnchTen1\"\n--------------------- need this line ----------------------------------------\n", + "lines": { + "1": { + "oracle_tfair": [], + "lambda_over_length": 0.0041942915633607575 + } + } } ] diff --git a/tests/data/lazy_wave_graded_cross_current.dat b/tests/data/lazy_wave_graded_cross_current.dat new file mode 100644 index 00000000..a871e623 --- /dev/null +++ b/tests/data/lazy_wave_graded_cross_current.dat @@ -0,0 +1,57 @@ +--------------------- CableDyn Input File ------------------------------------ +Lazy-wave cable on a graded mesh in a cross current: a mesh-scale compression is no grounded-run limit +-- The lazy wave of lazy_wave_touchdown_planar_coarse_att.dat (25 discrete buoyancy modules on a +-- frictional seabed) with its buoyant stretch refined fourfold, so 0.9 m elements meet 4 m ones at +-- the sag bend and 10 m ones along the grounded run, in a 0.2 m/s current across the line's plane. +-- The catenary-continuation route stops on an element-mean axial compression read on those long +-- elements, where the axial force of a stiff line oscillates: a mesh artefact, not the friction +-- holding the grounded run. The static solve names it as such and goes on to the mesh-sequenced +-- route, which solves the deck. +--------------------- LINE TYPES --------------------------------------------- +Name Diam Mass EA BA EI GAs GJ Irt Irn Cdn Cdt Can Cat +(-) (m) (kg/m) (N) (-) (Nm2) (N) (Nm2) (kgm) (kgm) (-) (-) (-) (-) +bare 0.16 36.70 4.69e8 0.0 1.99e4 1.0e8 1.5e4 1.0 1.0 1.2 0.1 1.0 0.0 +--------------------- POINTS ------------------------------------------------- +ID Type X Y Z +(-) (-) (m) (m) (m) +7 Coupled 30.0 0.0 -20.0 +8 Fixed 500.0 0.0 -200.0 +--------------------- LINES -------------------------------------------------- +ID NodeA NodeB Outputs +(-) (-) (-) (-) +4 7 8 - +--------------------- SECTIONS ----------------------------------------------- +LineID LineType Length NumSegs +(-) (-) (m) (-) +4 bare 80.0 20 +4 bare 96.0 108 +4 bare 424.0 42 +--------------------- ATTACHMENTS ------------------------------------------- +LineID ArcLength Mass Volume CdA Ca CdAx +(-) (m) (kg) (m^3) (m^2) (-) (m^2) +4 80.0:10.66666667:176.0 228.3 0.45945 3.48 1.0 0.0 +--------------------- END CONNECTIONS ---------------------------------------- +LineID End Stiffness EzX EzY EzZ TorsStiffness NxX NxY NxZ Pretwist +(-) (-) (N-m/rad) (-) (-) (-) (N-m/rad) (-) (-) (-) (deg) +4 A Rigid 0.1058 0 -0.9944 Free 0 1 0 0 +4 B Rigid 1 0 0 Free 0 1 0 0 +--------------------- OPTIONS ------------------------------------------------ +9.80665 g +1025.0 rhoW +3.0e6 kBot +3.0e5 cBot +0.35 frictionMu +200.0 WtrDpth +0.025 dtM +0.0 TMax +uniform 0 0.2 0.0 current +--------------------- OUTPUTS ------------------------------------------------ +FairTen4 +AnchTen4 +Point7Fx +Point7Fy +Point7Fz +Point8Fx +Point8Fy +Point8Fz +--------------------- END ---------------------------------------------------- diff --git a/tests/test_arclength_rigid_end.py b/tests/test_arclength_rigid_end.py new file mode 100644 index 00000000..da9a76aa --- /dev/null +++ b/tests/test_arclength_rigid_end.py @@ -0,0 +1,97 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Copyright (c) 2026 Jae Hoon Seo, SMI Lab, Inha University +"""A clamped (Rigid) finite-EI line in a strong current follows its drag path past a limit point. + +A 2982 m cable hangs from a fairlead 1300 m above a soft seabed, clamped there (Rigid End A), in +a 1.1 m/s current that carries its grounded run 34 m past the anchor, where it folds back (a +hairpin). The drag load steps stall at a limit point in the drag fraction; the pseudo-arclength +continuation that follows the path around such a point was skipped for a line with a Rigid end, +and the statics failed, while the same line with a rotational spring of 1e9 N m/rad, or pinned, +solved. The Rigid line must solve, with end tensions within 1e-3 of the stiff-spring line's. + +usage: test_arclength_rigid_end.py --exe --output

+""" + +from __future__ import annotations + +import argparse +import os +import subprocess +import sys +from pathlib import Path + +DECK = """--------------------- CableDyn Input File ------------------------------------ +Clamped cable in a strong current, folded back past its anchor +--------------------- LINE TYPES --------------------------------------- +TypeName Diam Mass EA BA EI Cd_n Cd_t Ca_n Ca_t +(-) (m) (kg/m) (N) (N-s) (N-m2) (-) (-) (-) (-) +t1 0.220140427337277 98.69067167615302 1404666756.1903045 -1.0 28098.621431099004 1.2 0.01 1.0 0.0 +--------------------- POINTS ------------------------------------------- +ID Type X Y Z +(-) (-) (m) (m) (m) +1 Coupled -86.22983517581444 29.680326533513522 -18.41049814550798 +2 Fixed 1829.3161686664414 -108.94426352048342 -1300.878186612071 +--------------------- LINES -------------------------------------------- +ID NodeA NodeB Outputs +(-) (-) (-) (-) +1 1 2 - +--------------------- SECTIONS ----------------------------------------- +LineID LineType Length NumSegs +(-) (-) (m) (-) +1 t1 2982.4084481132636 100 +--------------------- END CONNECTIONS ------------------------------- +LineID End Stiffness EzX EzY EzZ +(-) (-) (N-m/rad) (-) (-) (-) +1 A {k} 0.9264201469208807 0.154631906329435 -0.343270571013623 +--------------------- OPTIONS ------------------------------------------ +1300.878186612071 WtrDpth +6413.910151738813 kBot +0.02 dtM +0.0 TMax +uniform 1.12 -0.2 0.0 current +--------------------- OUTPUTS ------------------------------------------ +FairTen1 +AnchTen1 +--------------------- need this line ----------------------------------- +""" + + +def run(exe: str, out: Path, k: str) -> list: + name = "clamped_%s" % k.replace(".", "p") + deck = out / (name + ".dat") + deck.write_text(DECK.format(k=k), encoding="utf-8", newline="\n") + root = out / name + env = dict(os.environ) + env.setdefault("OPENBLAS_NUM_THREADS", "1") + p = subprocess.run([exe, str(deck), str(root)], capture_output=True, text=True, env=env, cwd=str(out)) + if p.returncode != 0: + raise RuntimeError("End A %s: exit %d: %s" % (k, p.returncode, (p.stdout + p.stderr)[-400:])) + rows = Path(str(root) + ".out").read_text(encoding="utf-8").splitlines() + return [float(v) for v in rows[2].split()[1:3]] + + +def main() -> int: + ap = argparse.ArgumentParser() + ap.add_argument("--exe", required=True) + ap.add_argument("--output", required=True) + a = ap.parse_args() + out = Path(a.output) + out.mkdir(parents=True, exist_ok=True) + failures = [] + try: + rigid = run(a.exe, out, "Rigid") + spring = run(a.exe, out, "1.0e9") + for r, s, ch in zip(rigid, spring, ("FairTen1", "AnchTen1")): + if abs(r - s) > 1.0e-3 * spring[0]: + failures.append("%s %.6e (Rigid) against %.6e (1e9 N m/rad spring)" % (ch, r, s)) + except RuntimeError as ex: + failures.append(str(ex)) + print("clamped cable in a strong current: %d failures" % len(failures)) + for f in failures: + print("FAIL:", f) + return 1 if failures else 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tests/test_attachment_cross_current.py b/tests/test_attachment_cross_current.py index 29305eee..5f6346b0 100644 --- a/tests/test_attachment_cross_current.py +++ b/tests/test_attachment_cross_current.py @@ -6,14 +6,16 @@ The lazy-wave power cable of ``tests/data/lazy_wave_touchdown_planar_{refined,coarse}_att.dat`` (25 discrete buoyancy modules at a 4 m pitch, rigid end connections, seabed friction 0.35) is put in a uniform current across its vertical plane. The static solve reaches the discrete -equilibrium from the smeared one by a homotopy in the module loads and drag; on the refined -mesh in 0.3 m/s its damped Newton steps diverge on the frictional seabed, and the polish must -fall back to its regularised solves rather than fail (its note naming that path is required). +equilibrium from the smeared one by a homotopy in the module loads and drag. Every deck must solve (exit 0), and its line-end tensions must agree with the deck that replaces the modules by the equivalent smeared section (the same submerged weight, displaced volume and normal drag per metre over the stretch the modules cover): FairTen within 1 % and -AnchTen within 2 % of the smeared values. +AnchTen within 2 % of the smeared values. The static solve reaches the discrete state without a +fallback: in a current across the line's plane the smeared start carries the modules' drag as well +as their weight, so the polish only moves both to the nodes (with the drag left out of the smeared +start, the refined deck in 0.3 m/s reached it only through the pseudo-transient and line-search +repetitions). usage: test_attachment_cross_current.py --exe --data --output """ @@ -32,10 +34,8 @@ BARE_D, BARE_M, BARE_CDN, BARE_CDT = 0.16, 36.70, 1.2, 0.1 FAIR_TOL, ANCH_TOL = 0.01, 0.02 CASES = [("refined", 0.3), ("refined", 0.6), ("coarse", 0.3), ("coarse", 0.6)] -# The case whose polish takes the fallback path; its note says so (and that the state passed -# the acceptance checks of the smeared state). -FALLBACK_CASE = "refined_0.3" -FALLBACK_NOTE = "was reached after a failed Newton solve" +# Notes of a static solve that reached its state through a fallback. +FALLBACK_NOTES = ("reached after a failed Newton solve", "stalled", "looser tolerance") def with_current(text: str, speed: float) -> str: @@ -95,8 +95,9 @@ def main() -> int: rc, row, log = run(exe, d / "deck.dat") if rc != 0 or "FairTen4" not in row: failures.append("%s %s: exit %d\n%s" % (name, kind, rc, log[-2000:])) - if kind == "discrete" and name == FALLBACK_CASE and FALLBACK_NOTE not in log: - failures.append("%s: the polish did not report its fallback path" % name) + notes = [n for n in FALLBACK_NOTES if n in log] + if notes: + failures.append("%s %s: the static solve needed a fallback (%s)" % (name, kind, ", ".join(notes))) results[kind] = row if all("FairTen4" in r for r in results.values()): disc, smr = results["discrete"], results["smeared"] diff --git a/tests/test_attachment_polish_current.py b/tests/test_attachment_polish_current.py new file mode 100644 index 00000000..62fb5126 --- /dev/null +++ b/tests/test_attachment_polish_current.py @@ -0,0 +1,289 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Copyright (c) 2026 Jae Hoon Seo, SMI Lab, Inha University +"""Discrete buoyancy modules in an oblique or cross current: the attachment polish converges cleanly. + +The static solve of a line with ATTACHMENTS first finds the equilibrium with the modules smeared +over the elements beside their nodes, then carries it to the lumped loads by a homotopy (the +attachment polish). The smeared start carried the modules' weight but not their current drag, so +the polish applied the whole module drag to it: on the frictional seabed of +``tests/data/lazy_wave_touchdown_planar_coarse_att.dat`` (friction 0.35) in a current across the +line's plane, its damped Newton solves diverged as the grounded run slid metres sideways, and the +discrete state was reached only through the pseudo-transient and line-search fallbacks (25 +modules, 2 m elements, 0.3 m/s at 90 deg: the first load step of 1/8 failed). In a current +across the line's plane the smeared start now carries the module drag too, and the polish moves it +to the nodes with the weight (a current along the plane keeps the former path: the in-plane +control below). + +Gates: + +1. Robustness, on the frictional lazy wave with its 96 m buoyant stretch rebuilt from 10, 25 or 40 + modules (the same total mass, volume and drag area), on the deck's 4 m / 10 m grading with the + buoyant section at 1, 2 or 4 times its node density, or on 2 m elements throughout with that + section refined again, in a uniform current of 0.1 to 0.5 m/s at 45 or 90 deg to the line's + plane (and two controls: still water and an in-plane current): every deck solves (exit 0) + without a fallback note ("reached after a failed Newton solve", "stalled", "looser + tolerance"), and the line's mean out-of-plane offset has the sign of the current's cross + component. +2. Physics, on the lazy wave of ``examples/lazy_wave_buoyancy_modules.dat`` hung in mid-water (the + seabed lowered to 300 m, so no contact force enters the balance) with 25 or 40 modules in 0.3 or + 0.5 m/s at 45 or 90 deg: the end forces the line puts on its two points (C API, double + precision) balance its weight and buoyancy, the modules' net weight and the current drag of + cable (three-point Gauss on the Hermite centreline rebuilt from the node positions and + tangents) and modules (at their nodes) to 1e-6 of the largest load, and the line deflects + toward the current's cross component. The C API's declination and azimuth are a central + difference of the node positions, which is not the tangent at a module node (the curvature + jumps there), so a module's tangent is the mean of the one-sided fourth-order differences. +3. Torsion, on ``tests/data/lazy_wave_torsion_attachments.dat`` (the frictional lazy wave restrained + in torsion with one turn of pretwist) in 0.3 m/s at 45 deg: the deck solves without a fallback + note and its torsion stage reports the twist solved (it stopped before in the smeared stage). + +usage: test_attachment_polish_current.py --exe --library --source + --output +""" + +from __future__ import annotations + +import argparse +import math +import os +import re +import subprocess +import sys +from concurrent.futures import ThreadPoolExecutor +from pathlib import Path + +import numpy as np + +FALLBACK_NOTES = ("reached after a failed Newton solve", "stalled", "looser tolerance") +BALANCE_TOL = 1.0e-6 + +# (mesh, speed m/s, heading deg from the line's plane, modules, buoyant-section refinement). +# mesh "deck": the deck's 4 m / 10 m grading; "fine": 2 m elements throughout. Every case but the +# two controls reached its discrete state only through the polish's fallbacks before. +ROBUST_CASES = [ + ("fine", 0.3, 90, 25, 1), + ("fine", 0.3, 90, 25, 4), + ("fine", 0.3, 90, 40, 2), + ("fine", 0.3, 45, 40, 4), + ("fine", 0.1, 90, 10, 4), + ("fine", 0.1, 45, 25, 1), + ("fine", 0.2, 45, 10, 2), + ("fine", 0.2, 90, 40, 4), + ("fine", 0.5, 45, 40, 2), + ("fine", 0.5, 45, 25, 1), + ("deck", 0.2, 90, 25, 4), + ("deck", 0.5, 45, 10, 2), + ("deck", 0.5, 45, 40, 4), + ("deck", 0.5, 45, 25, 1), + ("fine", 0.0, 0, 25, 2), + ("fine", 0.3, 0, 25, 2), +] +# (speed, heading, modules, refinement) on the mid-water lazy wave +BALANCE_CASES = [(0.3, 90, 25, 2), (0.5, 90, 40, 4), (0.3, 45, 25, 4), (0.5, 90, 25, 4)] +# (speed, heading) on the lazy wave restrained in torsion +TORSION_CASES = [(0.3, 45)] + +RHO, G = 1025.0, 9.80665 +# examples/lazy_wave_buoyancy_modules.dat: the bare cable and its ten modules over 70.614-115.614 m +GOMEX_D, GOMEX_M, GOMEX_EA, GOMEX_CDN, GOMEX_CDT = 0.16, 36.70, 4.69e8, 1.2, 0.1 +GOMEX_MOD = (114.15, 0.2297, 0.78, 0.2042) + + +def current_row(speed: float, heading: float) -> str: + th = math.radians(heading) + ux, uy = round(speed * math.cos(th), 12) + 0.0, round(speed * math.sin(th), 12) + 0.0 + return "uniform %.12g %.12g 0.0 current" % (ux, uy) + + +def touchdown_deck(source: Path, mesh: str, speed: float, heading: float, n_mod: int, refine: int) -> str: + """The frictional lazy wave with n_mod modules over 80-176 m (25 at 4 m in the deck).""" + text = (source / "tests" / "data" / "lazy_wave_touchdown_planar_coarse_att.dat").read_text() + pitch = 96.0 / (n_mod - 1) + per_pitch = max(1, round(pitch / 4.0)) + g = 2 if mesh == "fine" else 1 + rows = "4 bare 80.0 %d\n4 bare 96.0 %d\n4 bare 424.0 %d\n" % ( + 20 * g, (n_mod - 1) * per_pitch * refine * g, 170 if mesh == "fine" else 42) + text = re.sub(r"(-+ SECTIONS -+\n.*\n.*\n)(?:4 .*\n)+", lambda m: m.group(1) + rows, text) + s = 25.0 / n_mod + att = "4 80.0:%.10g:176.0 %.6g %.6g %.6g 1.0 0.0\n" % (pitch, 91.32 * s, 0.18378 * s, 1.392 * s) + text = re.sub(r"(-+ ATTACHMENTS -+\n.*\n.*\n)(?:4 .*\n)+", lambda m: m.group(1) + att, text) + if speed: + text = re.sub(r"^(0\.0 TMax)$", lambda m: m.group(1) + "\n" + current_row(speed, heading), text, + count=1, flags=re.M) + return text + + +def torsion_deck(source: Path, speed: float, heading: float) -> str: + """tests/data/lazy_wave_torsion_attachments.dat, static only, in a uniform current.""" + text = (source / "tests" / "data" / "lazy_wave_torsion_attachments.dat").read_text() + text, n = re.subn(r"^\S+(\s+TMax)$", lambda m: "0.0" + m.group(1) + "\n" + current_row(speed, heading), text, + count=1, flags=re.M) + if n != 1: + raise RuntimeError("the torsion deck has no TMax row") + return text + + +def gomex_sections(n_mod: int, refine: int) -> list[tuple[float, int]]: + return [(70.614, 71), (45.0, (n_mod - 1) * max(1, round(45.0 / (n_mod - 1))) * refine), (54.601, 55)] + + +def midwater_deck(source: Path, speed: float, heading: float, n_mod: int, refine: int) -> str: + """examples/lazy_wave_buoyancy_modules.dat with n_mod modules (the same totals), seabed at 300 m.""" + text = (source / "examples" / "lazy_wave_buoyancy_modules.dat").read_text() + rows = "".join("1 bare %.3f %d\n" % sec for sec in gomex_sections(n_mod, refine)) + text = re.sub(r"(-+ SECTIONS -+\n.*\n.*\n)(?:1 .*\n)+", lambda m: m.group(1) + rows, text) + s = 10.0 / n_mod + m, v, cda, cdax = (x * s for x in GOMEX_MOD) + att = "1 70.614:%.10g:115.614 %.6g %.6g %.6g 1.0 %.6g\n" % (45.0 / (n_mod - 1), m, v, cda, cdax) + text = re.sub(r"(-+ ATTACHMENTS -+\n.*\n.*\n)(?:1 .*\n)+", lambda m_: m_.group(1) + att, text) + text = re.sub(r"^uniform 0\.5 0\.0 0\.0 .*$", current_row(speed, heading), text, count=1, flags=re.M) + text = re.sub(r"^80\.0(\s+WtrDpth)", r"300.0\1", text, count=1, flags=re.M) + text = re.sub(r'^"TDP1[sx]"\n', "", text, flags=re.M) + return text + + +def run(exe: str, d: Path, text: str) -> tuple[int, str]: + d.mkdir(parents=True, exist_ok=True) + (d / "deck.dat").write_text(text, newline="\n") + p = subprocess.run([exe, "deck.dat", "o"], cwd=d, capture_output=True, text=True, timeout=1200) + return p.returncode, p.stdout + p.stderr + + +def static_y(d: Path) -> np.ndarray: + lines = (d / "o.static.out").read_text().splitlines()[3:] + return np.array([float(ln.split()[4]) for ln in lines if ln.strip()]) + + +def morison(u: np.ndarray, t: np.ndarray, d: float, cdn: float, cdt: float) -> np.ndarray: + t = t / np.linalg.norm(t) + ut = np.dot(u, t) * t + un = u - ut + return 0.5 * RHO * d * (cdn * np.linalg.norm(un) * un + math.pi * cdt * np.linalg.norm(ut) * ut) + + +def balance(deck: Path, speed: float, heading: float, n_mod: int, refine: int) -> tuple[float, float]: + """(|end forces - loads| / largest load, mean y offset) of the static state through the C API.""" + from cabledyn import CableDyn + + with CableDyn(deck) as model: + line = model.line(1) + x = np.array(line.node_positions()) + ten = np.array(line.node_tensions()) + dec, azi = np.radians(line.declination()), np.radians(line.azimuth()) + ends = np.array([model.channel("Point1F" + c) + model.channel("Point2F" + c) for c in "xyz"]) + largest = max(abs(model.channel("FairTen1")), abs(model.channel("AnchTen1"))) + l0 = np.concatenate([np.full(n, length / n) for length, n in gomex_sections(n_mod, refine)]) + if len(x) != len(l0) + 1: + raise RuntimeError("the static solve refined the mesh (%d nodes)" % len(x)) + tan = np.stack([np.sin(dec) * np.cos(azi), np.sin(dec) * np.sin(azi), np.cos(dec)], 1) + m = tan * (1.0 + ten / GOMEX_EA)[:, None] # dr/ds, the stretch from the tension + th = math.radians(heading) + u = np.array([round(speed * math.cos(th), 12), round(speed * math.sin(th), 12), 0.0]) + w_bare = (GOMEX_M - RHO * math.pi / 4.0 * GOMEX_D**2) * G + load = np.array([0.0, 0.0, -w_bare * l0.sum()]) + gx = [0.5 - 0.5 * math.sqrt(0.6), 0.5, 0.5 + 0.5 * math.sqrt(0.6)] + gw = [5.0 / 18.0, 8.0 / 18.0, 5.0 / 18.0] + for e, le in enumerate(l0): + for xi, wgt in zip(gx, gw): + dh = [(-6 * xi + 6 * xi**2) / le, 1 - 4 * xi + 3 * xi**2, (6 * xi - 6 * xi**2) / le, -2 * xi + 3 * xi**2] + rp = dh[0] * x[e] + dh[1] * m[e] + dh[2] * x[e + 1] + dh[3] * m[e + 1] + load += wgt * le * np.linalg.norm(rp) * morison(u, rp, GOMEX_D, GOMEX_CDN, GOMEX_CDT) + s = 10.0 / n_mod + mass, vol, cda, cdax = (v * s for v in GOMEX_MOD) + cum = np.concatenate([[0.0], np.cumsum(l0)]) + for k in range(n_mod): + j = int(np.argmin(np.abs(cum - (70.614 + k * 45.0 / (n_mod - 1))))) + load[2] -= (mass - RHO * vol) * G + tl = 25 * x[j] - 48 * x[j - 1] + 36 * x[j - 2] - 16 * x[j - 3] + 3 * x[j - 4] + tr = -25 * x[j] + 48 * x[j + 1] - 36 * x[j + 2] + 16 * x[j + 3] - 3 * x[j + 4] + t = tl / np.linalg.norm(tl) + tr / np.linalg.norm(tr) + t /= np.linalg.norm(t) + ut = np.dot(u, t) * t + un = u - ut + load += 0.5 * RHO * (cda * np.linalg.norm(un) * un + cdax * np.linalg.norm(ut) * ut) + largest = max(largest, abs(load[2])) + return float(np.abs(ends - load).max() / largest), float(x[:, 1].mean()) + + +def main() -> int: + ap = argparse.ArgumentParser() + ap.add_argument("--exe", required=True) + ap.add_argument("--library", required=True) + ap.add_argument("--source", required=True) + ap.add_argument("--output", required=True) + ap.add_argument("--jobs", type=int, default=4) + a = ap.parse_args() + exe = str(Path(a.exe).resolve()) + source = Path(a.source) + out = Path(a.output) + failures: list[str] = [] + + def robust(case): + mesh, speed, heading, n_mod, refine = case + name = "%s_U%.1f_h%d_N%d_r%d" % case + rc, log = run(exe, out / name, touchdown_deck(source, mesh, speed, heading, n_mod, refine)) + return name, case, rc, log + + def solve_balance(case): + speed, heading, n_mod, refine = case + name = "midwater_U%.1f_h%d_N%d_r%d" % case + rc, log = run(exe, out / name, midwater_deck(source, speed, heading, n_mod, refine)) + return name, case, rc, log + + def torsion(case): + speed, heading = case + name = "torsion_U%.1f_h%d" % case + rc, log = run(exe, out / name, torsion_deck(source, speed, heading)) + return name, rc, log + + with ThreadPoolExecutor(a.jobs) as pool: + torsion_runs = pool.map(torsion, TORSION_CASES) + robust_runs = list(pool.map(robust, ROBUST_CASES)) + balance_runs = list(pool.map(solve_balance, BALANCE_CASES)) + torsion_runs = list(torsion_runs) + + for name, (mesh, speed, heading, n_mod, refine), rc, log in robust_runs: + notes = [n for n in FALLBACK_NOTES if n in log] + y = static_y(out / name).mean() if rc == 0 else float("nan") + uy = speed * math.sin(math.radians(heading)) + print("%-26s exit %d fallback notes %s mean y %+.4f m" % (name, rc, notes or "none", y)) + if rc != 0: + failures.append("%s: exit %d\n%s" % (name, rc, log[-1500:])) + elif notes: + failures.append("%s: the static solve needed a fallback (%s)" % (name, ", ".join(notes))) + elif (uy > 0.0 and not y > 0.0) or (uy == 0.0 and abs(y) > 1.0e-9): + failures.append("%s: mean out-of-plane offset %.3e m against a cross current %.3f m/s" % (name, y, uy)) + + for name, rc, log in torsion_runs: + notes = [n for n in FALLBACK_NOTES if n in log] + solved = "torsion solved" in log + print("%-26s exit %d fallback notes %s torsion solved %s" % (name, rc, notes or "none", solved)) + if rc != 0 or notes or not solved: + failures.append("%s: exit %d, fallback notes %s, torsion solved %s\n%s" % (name, rc, notes, solved, + log[-1500:])) + + os.environ["CABLEDYN_LIBRARY"] = str(Path(a.library).resolve()) + sys.path.insert(0, str(source / "python")) + for name, (speed, heading, n_mod, refine), rc, log in balance_runs: + notes = [n for n in FALLBACK_NOTES if n in log] + if rc != 0 or notes: + failures.append("%s: exit %d, fallback notes %s\n%s" % (name, rc, notes, log[-1500:])) + continue + err, y = balance(out / name / "deck.dat", speed, heading, n_mod, refine) + print("%-26s force balance %.2e of the largest load mean y %+.4f m" % (name, err, y)) + if not err <= BALANCE_TOL: + failures.append("%s: the end forces miss the line's loads by %.2e of the largest load" % (name, err)) + if not y > 0.0: + failures.append("%s: mean out-of-plane offset %.3e m against the current" % (name, y)) + + for f in failures: + print("FAIL: " + f) + if failures: + return 1 + print("PASS: the attachment polish converges cleanly in oblique and cross currents, in force balance") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tests/test_attachment_polish_floor.py b/tests/test_attachment_polish_floor.py new file mode 100644 index 00000000..4a788885 --- /dev/null +++ b/tests/test_attachment_polish_floor.py @@ -0,0 +1,116 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Copyright (c) 2026 Jae Hoon Seo, SMI Lab, Inha University +"""The discrete attachment polish accepts a residual floor as the line's own static solve does. + +A 920 m suspended finite-EI cable is clamped at its anchor along -x, so that it arrives in a +tight bend (the deck mesh is refined about fivefold there), and carries one clump weight. The +warm-started solves of the attachment polish stall on a residual floor at a few times the tight +static tolerance (the smeared equilibrium of some of these lines is itself accepted at its +floor), and the polish failed. The clump mass (400 and 1600 kg) and its arc position (450 and +760 m) are swept. Every run must reach the discrete equilibrium without a fallback note, and its +end forces must balance the line's submerged weight and the clump's weight to 1e-5 of the +fairlead tension. + +usage: test_attachment_polish_floor.py --exe --output +""" + +from __future__ import annotations + +import argparse +import math +import os +import subprocess +import sys +from pathlib import Path + +DECK = """--------------------- CableDyn Input File ------------------------------------ +Suspended finite-EI cable clamped at its anchor in a tight bend, with one clump weight +--------------------- LINE TYPES --------------------------------------- +TypeName Diam Mass EA BA EI Cd_n Cd_t Ca_n Ca_t +(-) (m) (kg/m) (N) (N-s) (N-m2) (-) (-) (-) (-) +cab 0.26 91.0 9.3e8 0.0 2.5e4 1.2 0.01 1.0 0.0 +--------------------- POINTS ------------------------------------------- +ID Type X Y Z +(-) (-) (m) (m) (m) +1 Coupled 0.0 0.0 -10.0 +2 Fixed 915.0 0.0 -171.0 +--------------------- LINES -------------------------------------------- +ID NodeA NodeB Outputs +(-) (-) (-) (-) +1 1 2 - +--------------------- SECTIONS ----------------------------------------- +LineID LineType Length NumSegs +(-) (-) (m) (-) +1 cab 920.0 127 +--------------------- END CONNECTIONS ------------------------------- +LineID End Stiffness EzX EzY EzZ +(-) (-) (N-m/rad) (-) (-) (-) +1 B Rigid -1.0 0.0 0.0 +--------------------- ATTACHMENTS ---------------------------------- +LineID ArcLength Mass Volume CdA Ca CdAx +(-) (m) (kg) (m^3) (m^2) (-) (m^2) +1 {arc} {mass} 0.0 0.44 1.0 0.25 +--------------------- OPTIONS ------------------------------------------ +0.01 dtM +0.0 TMax +--------------------- OUTPUTS ------------------------------------------ +FairTen1 +Point1Fx +Point1Fy +Point1Fz +Point2Fx +Point2Fy +Point2Fz +--------------------- need this line ----------------------------------- +""" + +G, RHO = 9.80665, 1025.0 +W_LINE = (91.0 - RHO * math.pi * 0.26**2 / 4.0) * G * 920.0 +MASS = ["400.0", "1600.0"] +ARC = ["450.0", "760.0"] + + +def main() -> int: + ap = argparse.ArgumentParser() + ap.add_argument("--exe", required=True) + ap.add_argument("--output", required=True) + a = ap.parse_args() + out = Path(a.output) + out.mkdir(parents=True, exist_ok=True) + env = dict(os.environ) + env.setdefault("OPENBLAS_NUM_THREADS", "1") + failures = [] + for mass in MASS: + for arc in ARC: + name = "clump_%s_%s" % (mass, arc) + deck = out / (name + ".dat") + deck.write_text(DECK.format(mass=mass, arc=arc), encoding="utf-8", newline="\n") + root = out / name + p = subprocess.run([a.exe, str(deck), str(root)], capture_output=True, text=True, env=env, + cwd=str(out)) + log = p.stdout + p.stderr + if p.returncode != 0: + failures.append("mass %s arc %s: exit %d: %s" % (mass, arc, p.returncode, log[-400:])) + continue + if "after a failed Newton solve" in log: + failures.append("mass %s arc %s: the polish fell back after a failed Newton solve" % (mass, arc)) + rows = Path(str(root) + ".out").read_text(encoding="utf-8").splitlines() + names = rows[1].split() + vals = [float(v) for v in rows[2].split()] + f = {n: vals[names.index(n)] for n in names[1:]} + sx = f["Point1Fx"] + f["Point2Fx"] + sy = f["Point1Fy"] + f["Point2Fy"] + sz = f["Point1Fz"] + f["Point2Fz"] + W_LINE + float(mass) * G + err = math.sqrt(sx * sx + sy * sy + sz * sz) / f["FairTen1"] + if err > 1.0e-5: + failures.append("mass %s arc %s: end forces miss the weight by %.3e of the fairlead tension" + % (mass, arc, err)) + print("clamped cable with a clump: %d runs, %d failures" % (len(MASS) * len(ARC), len(failures))) + for f in failures: + print("FAIL:", f) + return 1 if failures else 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tests/test_bend_stiffener.f90 b/tests/test_bend_stiffener.f90 index c7a9b6b6..9a0fae19 100644 --- a/tests/test_bend_stiffener.f90 +++ b/tests/test_bend_stiffener.f90 @@ -36,6 +36,7 @@ PROGRAM test_bend_stiffener CALL case_cylinder() CALL case_cone() + CALL case_row_boundary_roundoff() CALL case_node_stiffness() CALL case_grammar() CALL case_coupled() @@ -143,6 +144,31 @@ SUBROUTINE case_cone() 'cone: bare elements unchanged') END SUBROUTINE case_cone + SUBROUTINE case_row_boundary_roundoff() + !! Two stiffener rows meeting inside an element (a 0.4 m cylinder, then a cone) cover it in two + !! parts whose sum can exceed the element length by round-off. Divided by a soft cable's + !! EI, that excess once made the compliance negative and the element EI negative. Swept + !! over the cable EI and the element length (the second length is that of the shipped + !! lazy-wave example, 68.114 m in 448 elements). + REAL(wp), PARAMETER :: EI_C(5) = [1.0e-300_wp, 1.0e-12_wp, 1.0e-3_wp, 1.0_wp, 2.0e4_wp] + REAL(wp), PARAMETER :: L_ELEM(3) = [0.15_wp, 68.114_wp/448.0_wp, 0.3_wp/7.0_wp] + REAL(wp), PARAMETER :: OD_ROOT(3) = [0.45_wp, 10.0_wp, 1.0e6_wp] + REAL(wp) :: stf(8, 2), l0(40), ei(40), mpl(40), dv(40) + INTEGER :: i, j, k + DO k = 1, SIZE(OD_ROOT) + stf(:, 1) = [1.0_wp, 0.0_wp, 0.4_wp, OD_ROOT(k), OD_ROOT(k), 0.17_wp, 5.0e7_wp, 1150.0_wp] + stf(:, 2) = [1.0_wp, 0.4_wp, 4.0_wp, OD_ROOT(k), 0.18_wp, 0.17_wp, 5.0e7_wp, 1150.0_wp] + DO j = 1, SIZE(L_ELEM) + DO i = 1, SIZE(EI_C) + l0 = L_ELEM(j); ei = EI_C(i); mpl = 36.7_wp; dv = 0.16_wp + CALL CD_Stiffener_Overlay(stf, l0, dv, ei=ei, mpl=mpl) + CALL require(ALL(ei >= EI_C(i)*(1.0_wp - 1.0e-12_wp)) .AND. ALL(ei < HUGE(ei)), & + 'row boundary: every element EI is at least the cable EI and finite') + END DO + END DO + END DO + END SUBROUTINE case_row_boundary_roundoff + SUBROUTINE case_node_stiffness() !! Ten 1 m elements, line type EI_C on the first six and 2 EI_C beyond, under a cylinder over !! 0-2 m (OD 0.6), a cone over 2-5 m (0.6 -> 0.3) and a cone over 5-7.5 m (0.25 -> 0.22), diff --git a/tests/test_c_api.f90 b/tests/test_c_api.f90 index f324badb..f8d827e6 100644 --- a/tests/test_c_api.f90 +++ b/tests/test_c_api.f90 @@ -59,7 +59,7 @@ SUBROUTINE case_version() abi_version = -1_C_INT msg = 'x' CALL CableDyn_GetVersion(major, minor, patch, abi_version) - CALL require(major == 0_C_INT .AND. minor == 4_C_INT .AND. patch == 1_C_INT .AND. abi_version == 1_C_INT, & + CALL require(major == 0_C_INT .AND. minor == 4_C_INT .AND. patch == 2_C_INT .AND. abi_version == 1_C_INT, & 'c-api-version:tuple') CALL CableDyn_GetVersionString(C_LOC(msg), INT(SIZE(msg), C_INT)) CALL require(INDEX(c_text(msg), 'CableDyn') == 1 .AND. INDEX(c_text(msg), 'C-ABI 1') > 0, & diff --git a/tests/test_check_example_fallbacks.py b/tests/test_check_example_fallbacks.py index 059b3933..2657832f 100644 --- a/tests/test_check_example_fallbacks.py +++ b/tests/test_check_example_fallbacks.py @@ -125,6 +125,20 @@ def main() -> int: status, text = run_scan(command, [taken, other], root / "mixed", coretype="Prescott") check(status == 1 and "ran Haswell" in text, "one wrong run fails", failures, text) + # The shipped decks: the top-level decks and those of the MoorDyn-C kinematics folders, + # with distinct names (each writes its outputs under its own name), and no auxiliary file. + shipped = scan.example_decks(examples.resolve()) + names = [deck.name for deck in shipped] + folders = {deck.parent.name for deck in shipped} + check( + "chain_wavekin7_currents1.dat" in names + and len(set(names)) == len(names) + and not folders & {"data", "openfast"}, + "the scan collects every shipped deck once", + failures, + "\n".join(str(deck) for deck in shipped), + ) + # The real driver and OpenBLAS: a kernel that does not exist cannot be confirmed. real = io.StringIO() with contextlib.redirect_stdout(real): diff --git a/tests/test_composite_string_modes.py b/tests/test_composite_string_modes.py new file mode 100644 index 00000000..f0c8f752 --- /dev/null +++ b/tests/test_composite_string_modes.py @@ -0,0 +1,236 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Copyright (c) 2026 Jae Hoon Seo, SMI Lab, Inha University +"""Modal analysis (OPTION nModes) of a composite line against the two-section string. + +A horizontal line 50 m deep, its ends 100 m apart, is built from two EI = 0 sections: 40 m of a +0.2 m line and 60 m of a 0.1 m line, each almost neutrally buoyant (its dry mass 1.00001 times +the displaced water), so the line hangs straight under its tension T (about 20 kN, set by the +stretch). With the normal added mass (Ca_n 1) the transverse mass per length of section i is +M_i = m_i + rhoW A_i, four times as large on the thick section, so the transverse wave travels +at c_i = sqrt(T/M_i) and twice as fast on the thin one. With y = sin(k1 x) on the first section +and sin(k2 (L - x)) on the second (k_i = omega/c_i), continuity of the displacement and of the +slope at the joint gives the natural frequencies as the roots of + + k2 sin(k1 L1) cos(k2 L2) + k1 cos(k1 L1) sin(k2 L2) = 0, + +each twice, in the plane of the sag and out of it. The section lengths are the stretched ones +and the masses per stretched metre; T is the static FairTen1 of the run, which must equal +EA_i (l_i/L_i - 1) of each section (the static stretch, within 1e-6). + +Gates, on 0.5 m and 0.25 m elements: the 16 lowest modes are the 8 lowest roots in pairs; on the +finer mesh every frequency is within 0.1 % of its root, and halving the element length cuts +the largest error by at least three (the lumped string converges at second order). The same +line as one uniform section (the thick line throughout, a root of k L = n pi) passes the same +gates, so the composite roots are not met by accident. + +usage: test_composite_string_modes.py --exe --output +""" + +from __future__ import annotations + +import argparse +import math +import subprocess +import sys +from pathlib import Path + +import numpy as np + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "python")) +from cabledyn import read_output # noqa: E402 + +FAILURES: list[str] = [] +RHO = 1025.0 +SPAN = 100.0 +STRETCH = 1.6e-3 # total static stretch of the line (m) +N_ROOTS = 8 + +DECK = """--------------------- CableDyn Input File ------------------------------------ +composite string modes +--------------------- LINE TYPES --------------------------------------- +TypeName Diam MassDenInAir EA BA/-zeta EI Cd_n Cd_t Ca_n Ca_t +(-) (m) (kg/m) (N) (N-s/-) (N-m^2) (-) (-) (-) (-) +{types} +--------------------- POINTS ------------------------------------------- +ID Type X Y Z Mass Vol CdA Ca +(-) (-) (m) (m) (m) (kg) (m^3) (m^2) (-) +1 Coupled 0.0 0.0 -50.0 0 0 0 0 +2 Fixed 100.0 0.0 -50.0 0 0 0 0 +--------------------- LINES -------------------------------------------- +ID NodeA NodeB Outputs +(-) (-) (-) (-) +1 1 2 - +--------------------- SECTIONS ----------------------------------------- +LineID LineType Length NumSegs +(-) (-) (m) (-) +{sections} +--------------------- OPTIONS ------------------------------------------ +9.80665 g +1025.0 rhoW +200.0 WtrDpth +{modes} nModes +--------------------- OUTPUTS ------------------------------------------ +"FairTen1" +--------------------- need this line ----------------------------------- +""" + + +def check(ok: bool, message: str) -> None: + print(("PASS: " if ok else "FAIL: ") + message) + if not ok: + FAILURES.append(message) + + +class Section: + def __init__(self, name: str, diameter: float, ea: float, length: float) -> None: + self.name = name + self.area = 0.25 * math.pi * diameter**2 + self.diameter = diameter + self.mass = 1.00001 * RHO * self.area # dry mass per unstretched metre + self.ea = ea + self.length = length # stretched length at the static tension (m) + + +def unstretched(sections: list[Section]) -> list[float]: + """Unstretched lengths whose stretch under one tension T totals STRETCH.""" + compliance = sum(s.length / s.ea for s in sections) + tension = STRETCH / compliance + return [s.length / (1.0 + tension / s.ea) for s in sections] + + +def run(exe: Path, folder: Path, sections: list[Section], h: float) -> tuple[float, np.ndarray]: + """Static tension and natural frequencies (Hz) of the line on elements of length ~h.""" + folder.mkdir(parents=True, exist_ok=True) + types = "\n".join( + f"{s.name:10s} {s.diameter:.4f} {s.mass:.6f} {s.ea:.4e} 0.0 0.0 1.2 0.0 1.0 0.0" + for s in sections + ) + rows = "\n".join( + f"1 {s.name:10s} {length:.9f} {round(s.length / h)}" + for s, length in zip(sections, unstretched(sections)) + ) + deck = folder / "deck.dat" + deck.write_text( + DECK.format(types=types, sections=rows, modes=2 * N_ROOTS), encoding="ascii", newline="\n" + ) + result = subprocess.run( + [str(exe), deck.name, str(folder / "run")], + cwd=folder, + capture_output=True, + text=True, + check=False, + ) + if result.returncode != 0: + check(False, f"{folder.name}: driver exit {result.returncode}\n{result.stderr[-2000:]}") + return math.nan, np.array([]) + tension = float(read_output(folder / "run.out").column("FairTen1")[0]) + freqs = [] + for line in (folder / "run.modes.out").read_text().splitlines(): + parts = line.split() + if line.startswith("#") or parts[:1] in (["LineID"], ["(-)"]): + if line.startswith("# Mode shapes"): + break + continue + if len(parts) == 5: + freqs.append(float(parts[2])) + return tension, np.array(freqs) + + +def bisect(function, low: float, high: float) -> float: + """The root of function between low and high, where it changes sign, to round-off.""" + f_low = function(low) + for _ in range(200): + middle = 0.5 * (low + high) + f_middle = function(middle) + if f_middle == 0.0 or high - low <= 1.0e-15 * high: + return middle + if (f_middle < 0.0) == (f_low < 0.0): + low, f_low = middle, f_middle + else: + high = middle + return 0.5 * (low + high) + + +def roots(sections: list[Section], tension: float) -> np.ndarray: + """The N_ROOTS lowest roots (Hz) of the fixed-fixed string of the stretched sections.""" + lengths = [s.length for s in sections] + speeds = [] + for s, l0 in zip(sections, unstretched(sections)): + added = RHO * s.area # Ca_n = 1, per unstretched metre as the dry mass + speeds.append(math.sqrt(tension / ((s.mass + added) * l0 / s.length))) + + def residual(omega: float) -> float: + if len(sections) == 1: + return math.sin(omega / speeds[0] * lengths[0]) + k1, k2 = omega / speeds[0], omega / speeds[1] + l1, l2 = lengths + return k2 * math.sin(k1 * l1) * math.cos(k2 * l2) + k1 * math.cos(k1 * l1) * math.sin( + k2 * l2 + ) + + grid = np.linspace(1.0e-3, 2.0 * math.pi * 2.0, 20001) + values = [residual(w) for w in grid] + found = [ + bisect(residual, grid[i], grid[i + 1]) + for i in range(len(grid) - 1) + if values[i] * values[i + 1] < 0.0 + ] + return np.array(found[:N_ROOTS]) / (2.0 * math.pi) + + +def gate(label: str, exe: Path, out: Path, sections: list[Section]) -> None: + errors = [] + for h in (0.5, 0.25): + tension, freqs = run(exe, out / f"{label}_{h:g}", sections, h) + if freqs.size == 0: + return + for s, l0 in zip(sections, unstretched(sections)): + expected = s.ea * (s.length / l0 - 1.0) + check( + abs(tension / expected - 1.0) < 1.0e-6, + f"{label}, h {h:g} m: static tension {tension:.6g} N is EA (l/L - 1) of " + f"{s.name} ({expected:.6g} N)", + ) + exact = roots(sections, tension) + check( + freqs.size == 2 * N_ROOTS, + f"{label}, h {h:g} m: {freqs.size} modes written", + ) + paired = np.repeat(exact, 2) + error = np.abs(freqs[: paired.size] / paired - 1.0) + errors.append(float(error.max())) + print( + f" {label}, h {h:g} m: roots {np.round(exact, 5)} Hz, largest error {error.max():.3e}" + ) + check(errors[1] < 1.0e-3, f"{label}: on 0.25 m elements within 0.1 % ({errors[1]:.3e})") + check( + errors[0] > 3.0 * errors[1], + f"{label}: halving the elements cuts the error at least threefold " + f"({errors[0]:.3e} -> {errors[1]:.3e})", + ) + + +def main() -> int: + parser = argparse.ArgumentParser() + parser.add_argument("--exe", required=True, type=Path) + parser.add_argument("--output", required=True, type=Path) + args = parser.parse_args() + exe = args.exe.resolve() + out = args.output.resolve() + gate( + "composite", + exe, + out, + [Section("thick", 0.2, 2.0e9, 40.0), Section("thin", 0.1, 1.0e9, 60.0)], + ) + gate("uniform", exe, out, [Section("thick", 0.2, 2.0e9, SPAN)]) + if FAILURES: + print(f"\n{len(FAILURES)} check(s) failed") + return 1 + print("\nall checks passed") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tests/test_deck_driver.f90 b/tests/test_deck_driver.f90 index 224a106d..ea9a142c 100644 --- a/tests/test_deck_driver.f90 +++ b/tests/test_deck_driver.f90 @@ -2166,6 +2166,75 @@ SUBROUTINE check_parser_hardening() CALL require(es_l == CD_DECKDRV_OK, 'caller-driven current deck needs no dtM: '//TRIM(em_l)) IF (es_l == CD_DECKDRV_OK) CALL CD_End_Deck_Aggregate(cagg) END BLOCK + + ! A finite-EI line needs mass: a named input error, not a failure inside the model build. + BLOCK + CHARACTER(*), PARAMETER :: CHAIN_ROW = 'chain 0.252 390.0 1.674e9 -1.0 0.0 1.37 0.64 1.0 0.0' + CHARACTER(*), PARAMETER :: STIFF_ROW = 'stiff 0.252 390.0 1.674e9 -1.0 1.0e4 1.37 0.64 1.0 0.0' + CHARACTER(:), ALLOCATABLE :: body + CHARACTER(1) :: nl + CHARACTER(8), PARAMETER :: MASSES(2) = [CHARACTER(8) :: '0.0', '-1.0'] + INTEGER :: k, m + nl = NEW_LINE('a') + DO m = 1, SIZE(MASSES) + body = hardening_deck(ANCHOR, SECTION, '0.1 dtM'//nl//'0.2 TMax', 'FairTen1') + k = INDEX(body, CHAIN_ROW) + CALL require(k > 0, 'finite-EI mass fixture locates the LINE TYPES row') + IF (k == 0) CYCLE + body = body(1:k - 1)//'chain 0.252 '//TRIM(MASSES(m))//' 1.674e9 -1.0 1.0e4 1.37 0.64 1.0 0.0'// & + body(k + LEN(CHAIN_ROW):) + CALL expect_badinput('deck_hard_finite_mass.dat', body, 'a finite-EI line type of mass '//TRIM(MASSES(m)), & + 'LINE TYPE "chain": MassDenInAir must be > 0 on a finite-EI line') + END DO + body = hardening_deck(ANCHOR, '1 chain 200.0 20'//nl//'1 stiff 210.0 21', '0.1 dtM'//nl//'0.2 TMax', & + 'FairTen1') + k = INDEX(body, CHAIN_ROW) + CALL require(k > 0, 'split-line fixture locates the LINE TYPES row') + IF (k > 0) THEN + ! a line of EI=0 and finite-EI sections is one finite-EI cable, as on the coupled aggregate + body = body(1:k - 1)//CHAIN_ROW//nl//STIFF_ROW//body(k + LEN(CHAIN_ROW):) + CALL write_text_file('deck_hard_split_line.dat', body) + CALL CD_Run_Deck_Driver('deck_hard_split_line.dat', 'deck_hard_split_line', conv_l, es_l, em_l) + CALL require(es_l == CD_DECKDRV_OK .AND. conv_l, 'a line of EI=0 and finite-EI sections runs: '// & + TRIM(em_l)) + END IF + END BLOCK + + ! The last waves or current row sets the sea: a row it overrides leaves nothing behind + ! that the bounds of the effective row are checked against (a JONSWAP gamma under an + ! Airy row, a uniform velocity under a profile row), while the effective row is checked. + BLOCK + CHARACTER(1) :: nl + CHARACTER(*), PARAMETER :: CLOCK = '0.1 dtM'//NEW_LINE('a')//'0.2 TMax' + CHARACTER(64), PARAMETER :: OVERRIDDEN(4) = [CHARACTER(64) :: & + 'jonswap 3.0 10.0 2000.0 0.0 waves', & + 'jonswap 3.0 10.0 2000.0 0.0 waves', & + 'uniform 2000.0 0.0 0.0 current', & + 'airy 2000.0 8.0 0.0 waves'] + CHARACTER(64), PARAMETER :: EFFECTIVE(4) = [CHARACTER(64) :: & + 'airy 2.0 8.0 0.0 waves', 'stream 2.0 8.0 0.0 waves', & + 'profile -30 0.2 0 0 0 0.5 0 0 current', 'none waves'] + INTEGER :: k + nl = NEW_LINE('a') + DO k = 1, SIZE(OVERRIDDEN) + CALL write_text_file('deck_hard_overridden.dat', hardening_deck(ANCHOR, SECTION, CLOCK//nl// & + TRIM(OVERRIDDEN(k))//nl//TRIM(EFFECTIVE(k)), & + 'FairTen1')) + CALL CD_Run_Deck_Driver('deck_hard_overridden.dat', 'deck_hard_overridden', conv_l, es_l, em_l) + CALL require(es_l == CD_DECKDRV_OK .AND. conv_l, '"'//TRIM(OVERRIDDEN(k))//'" overridden by "'// & + TRIM(EFFECTIVE(k))//'" leaves no stale bound: '//TRIM(em_l)) + END DO + CALL expect_badinput('deck_hard_effective_gamma.dat', hardening_deck(ANCHOR, SECTION, CLOCK//nl// & + 'airy 2.0 8.0 0.0 waves'//nl// & + 'jonswap 3.0 10.0 2000.0 0.0 waves', & + 'FairTen1'), & + 'an out-of-range JONSWAP gamma on the effective row', 'gamma <= 1e3') + CALL expect_badinput('deck_hard_effective_current.dat', hardening_deck(ANCHOR, SECTION, CLOCK//nl// & + 'profile -30 0.2 0 0 0 0.5 0 0 current'// & + nl//'uniform 2000.0 0.0 0.0 current', & + 'FairTen1'), & + 'an out-of-range uniform current on the effective row', 'at most 1e3 m/s') + END BLOCK END SUBROUTINE check_parser_hardening FUNCTION rigid6_failure_deck(failure_rows, extra_point) RESULT(body) diff --git a/tests/test_documentation.py b/tests/test_documentation.py index 41ff57c6..8d13059e 100644 --- a/tests/test_documentation.py +++ b/tests/test_documentation.py @@ -287,6 +287,7 @@ def test_every_public_example_is_catalogued(self) -> None: catalogue = (DOC / "examples.rst").read_text(encoding="utf-8") examples = ROOT / "examples" public_inputs = list(examples.glob("*.dat")) + public_inputs += list(examples.glob("moordynC_*/*.dat")) public_inputs += list((examples / "openfast").glob("*.dat")) public_inputs += list((examples / "openfast").glob("*.fst")) for path in public_inputs: diff --git a/tests/test_driver_channels.f90 b/tests/test_driver_channels.f90 index a5758b3e..e8bde6f8 100644 --- a/tests/test_driver_channels.f90 +++ b/tests/test_driver_channels.f90 @@ -323,8 +323,12 @@ SUBROUTINE test_finite_dynamic_channels() ! of every node of the initial state is tensile. CALL require(min_static_tension('chan_fin.static.out') > 0.0_wp, & 'opt-in tensile safety leaves a tensile element-mean state before initialisation') - ! declination channel matches the reported tangent. - CALL require(ABS(v(18) - ref_dec(n4 - n2)) < 1.0e-3_wp, 'finite-EI L1N3Dec matches tangent') + ! The declination channel is the cable's tangent at the node (its tangent DOF), the + ! Declination of the static profile; the chord of the neighbouring nodes is only close to it + ! on this 20-element arch (1.2 deg off). + CALL require(ABS(v(18) - static_declination('chan_fin.static.out', 3)) < 1.0e-5_wp, & + 'finite-EI L1N3Dec is the static profile tangent') + CALL require(ABS(v(18) - ref_dec(n4 - n2)) < 2.0_wp, 'finite-EI L1N3Dec is close to the chord') ! acceleration channel is finite on a dynamic run. CALL require(IEEE_IS_FINITE(v(15)) .AND. IEEE_IS_FINITE(v(16)) .AND. IEEE_IS_FINITE(v(17)), & 'finite-EI acceleration channel is finite') @@ -382,6 +386,33 @@ SUBROUTINE test_finite_straight_bendmom() CALL require(ABS(v(3)) <= 1.0e-6_wp*2.0e5_wp, 'reference-relative BendMom = 0 when the shape equals its reference') END SUBROUTINE test_finite_straight_bendmom + REAL(wp) FUNCTION static_declination(path, want_node) RESULT(dec) + !! The Declination of node want_node of line 1 in a static.out profile; HUGE when unreadable. + CHARACTER(*), INTENT(IN) :: path + INTEGER, INTENT(IN) :: want_node + INTEGER :: u, ios, lineid, node + REAL(wp) :: s, x, y, z, tn, curv, bend, d + CHARACTER(2048) :: buf + dec = HUGE(1.0_wp) + OPEN (NEWUNIT=u, FILE=path, STATUS='OLD', ACTION='READ', IOSTAT=ios) + IF (ios /= 0) RETURN + DO node = 1, 3 + READ (u, '(A)', IOSTAT=ios) buf + END DO + DO + READ (u, '(A)', IOSTAT=ios) buf + IF (ios /= 0) EXIT + IF (LEN_TRIM(buf) == 0) CYCLE + READ (buf, *, IOSTAT=ios) lineid, node, s, x, y, z, tn, curv, bend, d + IF (ios /= 0) EXIT + IF (lineid == 1 .AND. node == want_node) THEN + dec = d + EXIT + END IF + END DO + CLOSE (u) + END FUNCTION static_declination + REAL(wp) FUNCTION min_static_tension(path) RESULT(tmin) !! Smallest node Tension (segment tension) of a static.out profile; -HUGE when unreadable. CHARACTER(*), INTENT(IN) :: path diff --git a/tests/test_ei0_static_floor_cycle.py b/tests/test_ei0_static_floor_cycle.py new file mode 100644 index 00000000..f45c97dd --- /dev/null +++ b/tests/test_ei0_static_floor_cycle.py @@ -0,0 +1,102 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Copyright (c) 2026 Jae Hoon Seo, SMI Lab, Inha University +"""An EI = 0 static solve whose residual cycles inside its round-off floor is converged. + +A suspended three-section line (wire, then two polyester sections, 1151 m, 316 elements) hangs +between a fairlead and an anchor 693 m below it in a 0.67 m/s uniform current. The slack-capable +static stages bring the residual to about 1e-4 N, inside the round-off floor of its nodal forces +(3e-3 N) and above the relative tolerance (2.6e-5 N). Depending on the last digits of the +coordinates the iterates then settle on one value (flat, converged) or alternate between two +(9.49e-5 and 8.77e-5 N), which the flat-stall test never saw: every stage ran out of iterations +and no equilibrium was found. The deck is translated by 32 small offsets, every one of which must +solve and give the same fairlead and anchor tensions to 1e-7. + +usage: test_ei0_static_floor_cycle.py --exe --output +""" + +from __future__ import annotations + +import argparse +import os +import subprocess +import sys +from pathlib import Path + +DECK = """--------------------- CableDyn Input File ------------------------------------ +Suspended three-section line in a uniform current +--------------------- LINE TYPES --------------------------------------- +TypeName Diam Mass EA BA EI Cd_n Cd_t Ca_n Ca_t +(-) (m) (kg/m) (N) (N-s) (N-m2) (-) (-) (-) (-) +t1 0.16489335960471715 135.94910020865282 2447083803.755751 -1.0 0.0 1.2 0.008 1.0 0.0 +t2 0.07370991400051977 7.052224668855406 11019101.045086572 -0.8 0.0 2.0 0.4 1.1 0.15 +t3 0.10037023217840212 13.076279295895747 20431686.399837103 -0.8 0.0 2.0 0.4 1.1 0.15 +--------------------- POINTS ------------------------------------------- +ID Type X Y Z +(-) (-) (m) (m) (m) +1 Coupled {xa!r} {ya!r} -67.45321271085669 +2 Fixed {xb!r} {yb!r} -761.0028936967904 +--------------------- LINES -------------------------------------------- +ID NodeA NodeB Outputs +(-) (-) (-) (-) +1 1 2 - +--------------------- SECTIONS ----------------------------------------- +LineID LineType Length NumSegs +(-) (-) (m) (-) +1 t1 296.3708154484327 127 +1 t2 120.1220550938935 55 +1 t3 734.2263766070876 134 +--------------------- OPTIONS ------------------------------------------ +uniform -0.6393706682921939 -0.20430951085352095 0.0 current +0.01 dtM +0.0 TMax +--------------------- OUTPUTS ------------------------------------------ +FairTen1 +AnchTen1 +--------------------- need this line ----------------------------------- +""" + +A = (-239.01858425733275, -260.87547371415656) +B = (-732.1643435012232, -617.3791587315022) +DX = [0.0, 0.25, 0.5, 1.0, 2.0, 4.0, 8.0, 16.0] +DY = [0.0, 0.3, 3.0, 30.0] + + +def main() -> int: + ap = argparse.ArgumentParser() + ap.add_argument("--exe", required=True) + ap.add_argument("--output", required=True) + a = ap.parse_args() + out = Path(a.output) + out.mkdir(parents=True, exist_ok=True) + env = dict(os.environ) + env.setdefault("OPENBLAS_NUM_THREADS", "1") + failures = [] + ref = None + for dx in DX: + for dy in DY: + name = "shift_%g_%g" % (dx, dy) + deck = out / (name + ".dat") + deck.write_text(DECK.format(xa=A[0] + dx, ya=A[1] + dy, xb=B[0] + dx, yb=B[1] + dy), encoding="utf-8", + newline="\n") + root = out / name + p = subprocess.run([a.exe, str(deck), str(root)], capture_output=True, text=True, env=env, + cwd=str(out)) + if p.returncode != 0: + failures.append("shift (%g, %g): exit %d: %s" % (dx, dy, p.returncode, (p.stdout + p.stderr)[-300:])) + continue + rows = Path(str(root) + ".out").read_text(encoding="utf-8").splitlines() + vals = [float(v) for v in rows[2].split()[1:3]] + if ref is None: + ref = vals + for v, r, ch in zip(vals, ref, ("FairTen1", "AnchTen1")): + if abs(v - r) > 1.0e-7 * abs(ref[0]): + failures.append("shift (%g, %g): %s %.8e differs from %.8e" % (dx, dy, ch, v, r)) + print("translated line in a current: %d runs, %d failures" % (len(DX) * len(DY), len(failures))) + for f in failures: + print("FAIL:", f) + return 1 if failures else 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tests/test_end_tangent_channels.f90 b/tests/test_end_tangent_channels.f90 new file mode 100644 index 00000000..7c5594c7 --- /dev/null +++ b/tests/test_end_tangent_channels.f90 @@ -0,0 +1,163 @@ +! File: tests/test_end_tangent_channels.f90 +! SPDX-License-Identifier: Apache-2.0 +! Copyright (c) 2026 Jae Hoon Seo, SMI Lab, Inha University +PROGRAM test_end_tangent_channels + !! The tangent channels of a finite-EI line read its tangent, the Hermite tangent DOF m = dr/ds + !! of every node (normalised, End A -> End B), not a difference of node positions. A cable is + !! clamped at End A (END CONNECTIONS Rigid) along a set direction, swept over declinations of + !! 120 to 180 deg and azimuths of 0 and 20 deg (a clamp out of the vertical plane of the + !! ends), and pinned (bending-free) at End B. At the clamp FairDecl, FairAngle, FairIncl, + !! L1N1Dec and L1N1Azi equal the clamp's angles to round-off, though the line bends sharply + !! within its first element there; at the pinned end AnchDecl, AnchIncl and the last node's + !! Dec, and at every interior node Dec, equal the angle of the solution's own tangent. On the + !! aggregate route, which the C API and the OpenFAST shell share; the standalone outputs use + !! the same evaluator (check_end_tangent_channels.py). + USE CableDyn_Precision, ONLY: wp + USE CableDyn_OpenFAST_Aggregate, ONLY: CD_AGG_ModuleType, CD_AGG_Init_From_Deck, CD_AGG_End, CD_AGG_OK + USE CableDyn_DeckDriver, ONLY: CD_Eval_Aggregate_Channel + IMPLICIT NONE + + REAL(wp), PARAMETER :: PI = 3.14159265358979323846_wp + REAL(wp), PARAMETER :: TOL_DEG = 1.0e-9_wp + REAL(wp), PARAMETER :: DECLINATIONS(5) = [180.0_wp, 165.0_wp, 150.0_wp, 135.0_wp, 120.0_wp] + REAL(wp), PARAMETER :: AZIMUTHS(2) = [0.0_wp, 20.0_wp] + INTEGER :: nfail, id, ia + REAL(wp) :: worst_clamp, worst_node, worst_chord + ! the case under way + TYPE(CD_AGG_ModuleType) :: agg + CHARACTER(96) :: label + + nfail = 0 + worst_clamp = 0.0_wp + worst_node = 0.0_wp + worst_chord = 0.0_wp + DO id = 1, SIZE(DECLINATIONS) + DO ia = 1, SIZE(AZIMUTHS) + IF (id == 1 .AND. ia > 1) CYCLE ! a vertical clamp has no azimuth + CALL run_case(DECLINATIONS(id), AZIMUTHS(ia)) + END DO + END DO + WRITE (*, '(A,ES10.3,A,ES10.3,A)') 'largest channel error at the clamp ', worst_clamp, & + ' deg, at the other nodes ', worst_node, ' deg' + WRITE (*, '(A,F8.3,A)') 'the node-position difference at the clamp is off by up to ', worst_chord, ' deg' + IF (nfail > 0) THEN + WRITE (*, '(A,I0,A)') 'FAIL: ', nfail, ' check(s) failed' + ERROR STOP 1 + END IF + WRITE (*, '(A)') 'PASS' + +CONTAINS + + SUBROUTINE run_case(dec_clamp, azi_clamp) + REAL(wp), INTENT(IN) :: dec_clamp, azi_clamp + CHARACTER(512) :: em + CHARACTER(64) :: path, ch + REAL(wp) :: ez(3), t(3), dec_m, chord(3) + INTEGER :: es, nn, j, inode + + ez = [SIN(dec_clamp*PI/180.0_wp)*COS(azi_clamp*PI/180.0_wp), & + SIN(dec_clamp*PI/180.0_wp)*SIN(azi_clamp*PI/180.0_wp), COS(dec_clamp*PI/180.0_wp)] + path = 'end_tangent_channels.dat' + CALL write_deck(path, ez) + WRITE (label, '(A,F6.1,A,F5.1,A)') 'clamp declination ', dec_clamp, ' deg, azimuth ', azi_clamp, ' deg' + CALL CD_AGG_Init_From_Deck(agg, TRIM(path), 0.05_wp, es, em) + IF (es /= CD_AGG_OK) THEN + CALL check(.FALSE., TRIM(label)//': init: '//TRIM(em)) + CALL CD_AGG_End(agg, es, em) + RETURN + END IF + ! the clamped End A (the line's last internal node) + CALL expect('FairDecl1', dec_clamp, worst_clamp) + CALL expect('FairAngle1', dec_clamp, worst_clamp) + CALL expect('FairIncl1', dec_clamp - 90.0_wp, worst_clamp) + CALL expect('L1N1Dec', dec_clamp, worst_clamp) + IF (ABS(ez(3)) < 1.0_wp - 1.0e-12_wp) CALL expect('L1N1Azi', azi_clamp, worst_clamp) + nn = agg%cables(1)%line%nn + ! what a difference of node positions gives at the clamp + chord = agg%cables(1)%line%q(6*(nn - 2) + 1:6*(nn - 2) + 3) - agg%cables(1)%line%q(6*(nn - 1) + 1:6*(nn - 1) + 3) + worst_chord = MAX(worst_chord, ABS(ACOS(chord(3)/NORM2(chord))*180.0_wp/PI - dec_clamp)) + ! every other node, the pinned End B included: the angle of the solution's tangent DOF + DO j = 2, nn + inode = nn + 1 - j + t = -agg%cables(1)%line%q(6*(inode - 1) + 4:6*(inode - 1) + 6) + dec_m = ACOS(MAX(-1.0_wp, MIN(1.0_wp, t(3)/NORM2(t))))*180.0_wp/PI + WRITE (ch, '(A,I0,A)') 'L1N', j, 'Dec' + CALL expect(TRIM(ch), dec_m, worst_node, mesh=.TRUE.) + END DO + CALL expect('AnchDecl1', dec_m, worst_node) + CALL expect('AnchIncl1', dec_m - 90.0_wp, worst_node) + CALL CD_AGG_End(agg, es, em) + END SUBROUTINE run_case + + SUBROUTINE expect(name, want, worst, mesh) + !! The channel name of the case's line equals want [deg] to TOL_DEG; worst: the largest error. + CHARACTER(*), INTENT(IN) :: name + REAL(wp), INTENT(IN) :: want + REAL(wp), INTENT(INOUT) :: worst + LOGICAL, INTENT(IN), OPTIONAL :: mesh + REAL(wp) :: v + INTEGER :: ese + CHARACTER(512) :: eme + IF (PRESENT(mesh)) THEN + CALL CD_Eval_Aggregate_Channel(name, agg%has_sys, agg%sys%fast%system, agg%cables, agg%line_is_cable, & + agg%line_obj_index, v, ese, eme, mesh_node=mesh) + ELSE + CALL CD_Eval_Aggregate_Channel(name, agg%has_sys, agg%sys%fast%system, agg%cables, agg%line_is_cable, & + agg%line_obj_index, v, ese, eme) + END IF + IF (ese /= 0) THEN + CALL check(.FALSE., TRIM(label)//': '//name//': '//TRIM(eme)) + RETURN + END IF + worst = MAX(worst, ABS(v - want)) + IF (ABS(v - want) > TOL_DEG) THEN + WRITE (*, '(4A,F14.9,A,F14.9)') ' ', TRIM(label), ': ', name, v, ' deg, the tangent gives ', want + CALL check(.FALSE., TRIM(label)//': '//name//' is the angle of the line tangent') + END IF + END SUBROUTINE expect + + SUBROUTINE write_deck(path, ez) + CHARACTER(*), INTENT(IN) :: path + REAL(wp), INTENT(IN) :: ez(3) + INTEGER :: u + OPEN (NEWUNIT=u, FILE=path, STATUS='REPLACE', ACTION='WRITE') + WRITE (u, '(A)') '--------------------- CableDyn Input File ------------------------------------' + WRITE (u, '(A)') 'tangent channels of a cable clamped at End A' + WRITE (u, '(A)') '--------------------- LINE TYPES ---------------------------------------------' + WRITE (u, '(A)') 'TypeName Diam MassDenInAir EA BA/-zeta 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.2 60.0 1.0e8 -1.0 1.0e4 1.2 0.008 1.0 0.0' + WRITE (u, '(A)') '--------------------- POINTS -------------------------------------------------' + WRITE (u, '(A)') 'ID Type X Y Z Mass Vol CdA Ca' + WRITE (u, '(A)') '(-) (-) (m) (m) (m) (kg) (m^3) (m^2) (-)' + WRITE (u, '(A)') '1 Coupled 0.0 0.0 -10.0 0 0 0 0' + WRITE (u, '(A)') '2 Fixed 80.0 0.0 -80.0 0 0 0 0' + WRITE (u, '(A)') '--------------------- LINES --------------------------------------------------' + WRITE (u, '(A)') 'ID NodeA NodeB Outputs' + WRITE (u, '(A)') '(-) (-) (-) (-)' + WRITE (u, '(A)') '1 1 2 -' + WRITE (u, '(A)') '--------------------- SECTIONS -----------------------------------------------' + WRITE (u, '(A)') 'LineID LineType Length NumSegs' + WRITE (u, '(A)') '(-) (-) (m) (-)' + WRITE (u, '(A)') '1 cable 125.0 100' + WRITE (u, '(A)') '--------------------- END CONNECTIONS ----------------------------------------' + WRITE (u, '(A)') 'LineID End Stiffness EzX EzY EzZ' + WRITE (u, '(A)') '(-) (-) (N-m/rad) (-) (-) (-)' + WRITE (u, '(A,3(1X,ES23.16))') '1 A Rigid', ez + WRITE (u, '(A)') '--------------------- OPTIONS ------------------------------------------------' + WRITE (u, '(A)') '9.80665 g' + WRITE (u, '(A)') '1025.0 rhoW' + WRITE (u, '(A)') '--------------------- OUTPUTS ------------------------------------------------' + WRITE (u, '(A)') 'END' + CLOSE (u) + END SUBROUTINE write_deck + + SUBROUTINE check(ok, label) + LOGICAL, INTENT(IN) :: ok + CHARACTER(*), INTENT(IN) :: label + IF (ok) RETURN + nfail = nfail + 1 + WRITE (*, '(2A)') ' FAIL ', TRIM(label) + END SUBROUTINE check + +END PROGRAM test_end_tangent_channels diff --git a/tests/test_flagship_compression_note.f90 b/tests/test_flagship_compression_note.f90 index 3b53933a..309cd909 100644 --- a/tests/test_flagship_compression_note.f90 +++ b/tests/test_flagship_compression_note.f90 @@ -16,6 +16,8 @@ PROGRAM test_flagship_compression_note !! projected on the nodal tangent. It stays within the end tensions instead of the pointwise !! spikes at the touchdown. !! + !! The chains' negative BA, a damping ratio per segment, carries the axial-damping note only. + !! !! A deck whose finite-EI elements are shorter than sqrt(EI/EA) (the conditioning limit !! of the static Newton system) carries the fine-mesh note; the flagship does not. !! @@ -57,7 +59,8 @@ PROGRAM test_flagship_compression_note DO i = 1, SIZE(agg%init_lines) IF (LEN_TRIM(agg%init_lines(i)%note) > 0) WRITE (*, '(A,I0,2A)') ' line ', agg%init_lines(i)%line_id, & ' note: ', TRIM(agg%init_lines(i)%note) - CALL check(LEN_TRIM(agg%init_lines(i)%note) == 0, 'no static-initialisation note on any line') + ! the chains' negative BA is a damping ratio per segment: only that note of the run + CALL check(only_damping_note(agg%init_lines(i)%note), 'no static-initialisation note on any line') END DO END IF @@ -234,6 +237,21 @@ SUBROUTINE case_weightless_bow_note() CALL CD_AGG_End(light, es_l, em_l) END SUBROUTINE case_weightless_bow_note + LOGICAL FUNCTION only_damping_note(note) RESULT(ok) + !! Every line of note is the axial-damping note of a negative BA (axial_damping_note). + CHARACTER(*), INTENT(IN) :: note + INTEGER :: a, b, n + ok = .TRUE. + n = LEN_TRIM(note) + a = 1 + DO WHILE (a <= n) + b = INDEX(note(a:n), NEW_LINE('a')) + IF (b == 0) b = n - a + 2 + IF (INDEX(note(a:a + b - 2), 'its negative BA is a damping ratio per segment') == 0) ok = .FALSE. + a = a + b + END DO + END FUNCTION only_damping_note + SUBROUTINE check(ok, label) LOGICAL, INTENT(IN) :: ok CHARACTER(*), INTENT(IN) :: label diff --git a/tests/test_graded_mesh_statics.py b/tests/test_graded_mesh_statics.py new file mode 100644 index 00000000..7c59b4fc --- /dev/null +++ b/tests/test_graded_mesh_statics.py @@ -0,0 +1,137 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Copyright (c) 2026 Jae Hoon Seo, SMI Lab, Inha University +"""A finite-EI lazy wave on a strongly graded deck mesh solves in an oblique or cross current. + +The frictional lazy wave of ``tests/data/lazy_wave_touchdown_planar_coarse_att.dat`` keeps the +deck's 4 m elements at its sag bend and 10 m elements at its touchdown, longer than half its +bending length (EI/|w|)^(1/3) = 2.5 m, while its buoyant section (10 or 25 modules over 96 m) is +refined r times. With r = 4 (0.9 m and 1 m elements beside the 4 m and 10 m ones) the static solve +in 0.2 to 0.5 m/s at 45 or 90 deg to the line's plane failed with "the line is already in axial +compression without the current": every route stopped on the deck mesh, and its uniform refinement +by the largest factor (8x, which keeps the grading and refines the short elements as well) stalled +at the start of its stiffness continuation, although the same layout solves on 2 m elements. The +route is now repeated on the mesh refined element by element to the bending-length rule. + +Gates, on the driver's own output: every deck (grading ratios from r = 2 to r = 8, the six r = 4 +decks that failed) exits 0 without a fallback note ("reached after a failed Newton solve", +"stalled", "looser tolerance"), its mean out-of-plane offset has the sign of the current's cross +component, and two of the r = 4 decks agree with the same deck on 2 m elements throughout to +2e-3 of the fairlead tension in every end-force channel. + +usage: test_graded_mesh_statics.py --exe --data --output +""" + +from __future__ import annotations + +import argparse +import math +import re +import subprocess +import sys +from concurrent.futures import ThreadPoolExecutor +from pathlib import Path + +FALLBACK_NOTES = ("reached after a failed Newton solve", "stalled", "looser tolerance") +REFERENCE_TOL = 2.0e-3 +# (speed m/s, heading deg from the line's plane, modules, buoyant-section refinement) +CASES = [ + (0.2, 45, 10, 4), + (0.3, 45, 10, 4), + (0.2, 90, 10, 4), + (0.5, 45, 10, 4), + (0.2, 45, 25, 4), + (0.3, 45, 25, 4), + (0.3, 45, 10, 2), + (0.3, 45, 10, 8), +] +# cases compared with the same deck on 2 m elements throughout +REFERENCED = [(0.3, 45, 10, 4), (0.2, 45, 25, 4)] + + +def deck(data: Path, speed: float, heading: float, n_mod: int, refine: int, fine: bool) -> str: + """The frictional lazy wave with n_mod modules over 80-176 m (the deck's totals).""" + text = (data / "lazy_wave_touchdown_planar_coarse_att.dat").read_text() + pitch = 96.0 / (n_mod - 1) + per_pitch = max(1, round(pitch / 4.0)) + g = 2 if fine else 1 + rows = "4 bare 80.0 %d\n4 bare 96.0 %d\n4 bare 424.0 %d\n" % ( + 20 * g, (n_mod - 1) * per_pitch * refine * g, 170 if fine else 42) + text = re.sub(r"(-+ SECTIONS -+\n.*\n.*\n)(?:4 .*\n)+", lambda m: m.group(1) + rows, text) + s = 25.0 / n_mod + att = "4 80.0:%.10g:176.0 %.6g %.6g %.6g 1.0 0.0\n" % (pitch, 91.32 * s, 0.18378 * s, 1.392 * s) + text = re.sub(r"(-+ ATTACHMENTS -+\n.*\n.*\n)(?:4 .*\n)+", lambda m: m.group(1) + att, text) + th = math.radians(heading) + ux, uy = round(speed * math.cos(th), 12) + 0.0, round(speed * math.sin(th), 12) + 0.0 + text = re.sub(r"^(0\.0 TMax)$", lambda m: m.group(1) + "\nuniform %.12g %.12g 0.0 current" % (ux, uy), + text, count=1, flags=re.M) + text = text.replace("FairTen4\n", "FairTen4\nAnchTen4\n" + "".join( + "Point%d%s\n" % (p, c) for p in (7, 8) for c in ("Fx", "Fy", "Fz"))) + return text + + +def run(exe: str, d: Path, text: str) -> tuple[int, str, dict, float]: + d.mkdir(parents=True, exist_ok=True) + (d / "deck.dat").write_text(text, newline="\n") + p = subprocess.run([exe, "deck.dat", "o"], cwd=d, capture_output=True, text=True, timeout=1800) + row, y = {}, float("nan") + if p.returncode == 0: + lines = [ln for ln in (d / "o.out").read_text().splitlines() if not ln.startswith("#")] + row = dict(zip(lines[0].split(), (float(v) for v in lines[1].split()))) + prof = (d / "o.static.out").read_text().splitlines()[3:] + ys = [float(ln.split()[4]) for ln in prof if ln.strip()] + y = sum(ys) / len(ys) + return p.returncode, p.stdout + p.stderr, row, y + + +def main() -> int: + ap = argparse.ArgumentParser() + ap.add_argument("--exe", required=True) + ap.add_argument("--data", required=True) + ap.add_argument("--output", required=True) + ap.add_argument("--jobs", type=int, default=4) + a = ap.parse_args() + exe = str(Path(a.exe).resolve()) + data, out = Path(a.data), Path(a.output) + jobs = [(c, False) for c in CASES] + [(c, True) for c in REFERENCED] + + def one(job): + (speed, heading, n_mod, refine), fine = job + name = "%s_U%.1f_h%d_N%d_r%d" % (("fine" if fine else "graded"), speed, heading, n_mod, refine) + return job, name, run(exe, out / name, deck(data, speed, heading, n_mod, refine, fine)) + + with ThreadPoolExecutor(a.jobs) as pool: + results = list(pool.map(one, jobs)) + rows = {} + failures = [] + for (case, fine), name, (rc, log, row, y) in results: + notes = [n for n in FALLBACK_NOTES if n in log] + print("%-24s exit %d fallback notes %s FairTen %s mean y %+.4f m" % + (name, rc, notes or "none", "%.1f N" % row["FairTen4"] if row else "-", y)) + rows[(case, fine)] = row + if rc != 0: + failures.append("%s: exit %d\n%s" % (name, rc, log[-1500:])) + elif notes: + failures.append("%s: the static solve needed a fallback (%s)" % (name, ", ".join(notes))) + elif not y > 0.0: + failures.append("%s: mean out-of-plane offset %.3e m against the cross current" % (name, y)) + for case in REFERENCED: + g, f = rows.get((case, False)), rows.get((case, True)) + if not g or not f: + continue + err = max(abs(g[c] - f[c]) for c in f if c != "Time(s)") / f["FairTen4"] + print("U %.1f h %d N %d r %d: graded against 2 m mesh, largest end-force difference %.2e of FairTen" % + (case + (err,))) + if not err <= REFERENCE_TOL: + failures.append("U %.1f h %d N %d r %d: the graded deck misses the 2 m mesh by %.2e of FairTen" % + (case + (err,))) + for f in failures: + print("FAIL: " + f) + if failures: + return 1 + print("PASS: the lazy wave on a graded deck mesh solves in oblique and cross currents") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tests/test_hermite_damped_rest.py b/tests/test_hermite_damped_rest.py new file mode 100644 index 00000000..3cd972cc --- /dev/null +++ b/tests/test_hermite_damped_rest.py @@ -0,0 +1,101 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Copyright (c) 2026 Jae Hoon Seo, SMI Lab, Inha University +"""A heavily damped finite-EI line held at rest stays at rest on every time step. + +A taut 400 m wire (EA = 2.19e9 N, 111 elements) is held at both ends and started from its +static equilibrium. The axial damping coefficient BA is swept over 5e7 to 8e8 N s (2 zeta +EA/omega_1 with zeta from about 0.4 to 6 for its first axial mode, the damping that +``mode1 axialDampingRatio`` gives) and dtM over 0.002, 0.005 and 0.01 s. The damping force +takes the strain rate from the Newmark velocity, whose rounding is gamma/(beta dt) times +that of the coordinates, so at these BA and dtM the residual round-off of a step at rest +lies well above the tolerance on the undamped force scale. Every run must complete (exit +code 0) and keep its end tensions at their static values to 1e-6. + +usage: test_hermite_damped_rest.py --exe --output +""" + +from __future__ import annotations + +import argparse +import os +import subprocess +import sys +from pathlib import Path + +DECK = """--------------------- CableDyn Input File ------------------------------------ +Taut finite-EI line held at rest with a large axial damping coefficient +--------------------- LINE TYPES --------------------------------------- +TypeName Diam Mass EA BA EI Cd_n Cd_t Ca_n Ca_t +(-) (m) (kg/m) (N) (N-s) (N-m2) (-) (-) (-) (-) +wire 0.156 121.7 2.19e9 {ba} 963.0 1.2 0.008 1.0 0.0 +--------------------- POINTS ------------------------------------------- +ID Type X Y Z +(-) (-) (m) (m) (m) +1 Coupled 82.52 80.42 -8.60 +2 Fixed -117.94 395.14 -139.38 +--------------------- LINES -------------------------------------------- +ID NodeA NodeB Outputs +(-) (-) (-) (-) +1 1 2 - +--------------------- SECTIONS ----------------------------------------- +LineID LineType Length NumSegs +(-) (-) (m) (-) +1 wire 400.52 111 +--------------------- OPTIONS ------------------------------------------ +139.38 WtrDpth +2.9e6 kBot +{dt} dtM +{tmax} TMax +--------------------- OUTPUTS ------------------------------------------ +FairTen1 +AnchTen1 +--------------------- need this line ----------------------------------- +""" + +BA = ["5.0e7", "7.0e7", "1.0e8", "1.3e8", "1.6e8", "2.0e8", "3.0e8", "4.0e8", "6.0e8", "8.0e8"] +DT = ["0.002", "0.005", "0.01"] + + +def main() -> int: + ap = argparse.ArgumentParser() + ap.add_argument("--exe", required=True) + ap.add_argument("--output", required=True) + a = ap.parse_args() + out = Path(a.output) + out.mkdir(parents=True, exist_ok=True) + env = dict(os.environ) + env.setdefault("OPENBLAS_NUM_THREADS", "1") + failures = [] + for ba in BA: + for dt in DT: + name = "held_%s_%s" % (ba, dt) + deck = out / (name + ".dat") + deck.write_text(DECK.format(ba=ba, dt=dt, tmax=repr(round(40 * float(dt), 6))), encoding="utf-8", + newline="\n") + root = out / name + p = subprocess.run([a.exe, str(deck), str(root)], capture_output=True, text=True, env=env, + cwd=str(out)) + if p.returncode != 0: + failures.append("BA=%s dtM=%s: exit %d: %s" % (ba, dt, p.returncode, (p.stdout + p.stderr)[-300:])) + continue + rows = Path(str(root) + ".out").read_text(encoding="utf-8").splitlines() + names = rows[1].split() + vals = [[float(v) for v in r.split()] for r in rows[2:] if r.strip()] + if len(vals) != 41: + failures.append("BA=%s dtM=%s: %d output rows, expected 41" % (ba, dt, len(vals))) + continue + for ch in ("FairTen1", "AnchTen1"): + k = names.index(ch) + t0 = vals[0][k] + drift = max(abs(v[k] - t0) for v in vals) / abs(t0) + if drift > 1.0e-6: + failures.append("BA=%s dtM=%s: %s drifts by %.3e of its static value" % (ba, dt, ch, drift)) + print("held damped line: %d runs, %d failures" % (len(BA) * len(DT), len(failures))) + for f in failures: + print("FAIL:", f) + return 1 if failures else 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tests/test_hermite_static_azimuth.py b/tests/test_hermite_static_azimuth.py new file mode 100644 index 00000000..b777e30a --- /dev/null +++ b/tests/test_hermite_static_azimuth.py @@ -0,0 +1,118 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Copyright (c) 2026 Jae Hoon Seo, SMI Lab, Inha University +"""The finite-EI statics of a line do not depend on its azimuth. + +A 3.8 km suspended three-section lazy wave on 540 elements, clamped (Rigid) at its fairlead +along a direction 11 deg out of the vertical plane of its chord, is turned about the vertical +axis. Its first continuation stage fails on the coarse mesh at the clamp and the statics restart +at full stiffness from the catenary seed, an energy descent whose length scatters with the last +digits of the input (1171 to 1661 iterations over 28 azimuths). It was cut at 1600, so the +statics failed at 328.29 and 329 deg and solved elsewhere; it now runs while its residual keeps +falling. Every azimuth (seven across 328 to 329.5 deg and four elsewhere) must solve, with the +same fairlead and anchor tensions to 1e-6. + +usage: test_hermite_static_azimuth.py --exe --output +""" + +from __future__ import annotations + +import argparse +import math +import os +import subprocess +import sys +from pathlib import Path + +DECK = """--------------------- CableDyn Input File ------------------------------------ +Suspended lazy wave clamped at its fairlead out of its chord plane, turned about the vertical +--------------------- LINE TYPES --------------------------------------- +TypeName Diam Mass EA BA EI Cd_n Cd_t Ca_n Ca_t +(-) (m) (kg/m) (N) (N-s) (N-m2) (-) (-) (-) (-) +t1 0.13901651567091225 25.009060114295032 644913120.4893594 -1.0 203482.2288474299 1.2 0.01 1.0 0.0 +t2 0.6428183465278386 200.38465492542826 1054908164.887091 -0.8 38575.24712022166 1.2 0.01 1.0 0.0 +t3 0.07107464816032726 25.258028055571554 454644505.00028795 -1.0 2138.24079651583 1.2 0.008 1.0 0.0 +--------------------- POINTS ------------------------------------------- +ID Type X Y Z +(-) (-) (m) (m) (m) +1 Coupled {xa!r} {ya!r} -63.39980772163334 +2 Fixed {xb!r} {yb!r} -754.4713708188342 +--------------------- LINES -------------------------------------------- +ID NodeA NodeB Outputs +(-) (-) (-) (-) +1 1 2 - +--------------------- SECTIONS ----------------------------------------- +LineID LineType Length NumSegs +(-) (-) (m) (-) +1 t1 1351.43480777781 200 +1 t2 792.1830512136142 140 +1 t3 1678.538077522514 200 +--------------------- END CONNECTIONS ------------------------------- +LineID End Stiffness EzX EzY EzZ +(-) (-) (N-m/rad) (-) (-) (-) +1 A Rigid {ex!r} {ey!r} -0.4254613873973588 +--------------------- OPTIONS ------------------------------------------ +0.01 dtM +0.0 TMax +--------------------- OUTPUTS ------------------------------------------ +FairTen1 +AnchTen1 +--------------------- need this line ----------------------------------- +""" + +A = (14.254910394242287, 60.0359685337248) +B = (-2330.8134158224498, 2012.8230287080746) +EZ = (-0.5700516816811296, 0.702868186821989) +ANGLES = [0.0, 90.0, 200.0, 328.0, 328.29064504314925, 328.5, 328.75, 329.0, 329.25, 329.5, 330.0] + + +def turn(p, th): + c, s = math.cos(math.radians(th)), math.sin(math.radians(th)) + return c * p[0] - s * p[1], s * p[0] + c * p[1] + + +def main() -> int: + ap = argparse.ArgumentParser() + ap.add_argument("--exe", required=True) + ap.add_argument("--output", required=True) + a = ap.parse_args() + out = Path(a.output) + out.mkdir(parents=True, exist_ok=True) + env = dict(os.environ) + env.setdefault("OPENBLAS_NUM_THREADS", "1") + failures = [] + ref = None + for th in ANGLES: + (xa, ya), (xb, yb), (ex, ey) = turn(A, th), turn(B, th), turn(EZ, th) + name = "azimuth_%g" % th + deck = out / (name + ".dat") + deck.write_text( + DECK.format(xa=xa, ya=ya, xb=xb, yb=yb, ex=ex, ey=ey), encoding="utf-8", newline="\n" + ) + root = out / name + p = subprocess.run( + [a.exe, str(deck), str(root)], capture_output=True, text=True, env=env, cwd=str(out) + ) + if p.returncode != 0: + failures.append( + "%g deg: exit %d: %s" % (th, p.returncode, (p.stdout + p.stderr)[-300:]) + ) + continue + rows = Path(str(root) + ".out").read_text(encoding="utf-8").splitlines() + vals = [float(v) for v in rows[2].split()[1:3]] + if ref is None: + ref = vals + for v, r, ch in zip(vals, ref, ("FairTen1", "AnchTen1")): + if abs(v - r) > 1.0e-6 * abs(r): + failures.append("%g deg: %s %.8e differs from %.8e" % (th, ch, v, r)) + print( + "lazy wave turned about the vertical: %d azimuths, %d failures" + % (len(ANGLES), len(failures)) + ) + for f in failures: + print("FAIL:", f) + return 1 if failures else 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tests/test_hermite_viv.f90 b/tests/test_hermite_viv.f90 index a1c75880..698b4534 100644 --- a/tests/test_hermite_viv.f90 +++ b/tests/test_hermite_viv.f90 @@ -73,8 +73,10 @@ PROGRAM test_hermite_viv CALL require(es == CD_HCDYN_OK .AND. model%has_viv, 'VIV installs again: '//TRIM(em)) CALL CD_HermiteCable_Dyn_Set_Waves(model, 1.0_wp, 8.0_wp, 0.0_wp, 100.0_wp, GACC, es, em) CALL require(es /= CD_HCDYN_OK, 'an internal wave family is refused on a VIV cable') - CALL require(ABS(model%viv_phi(NE + 1)) < TINY(1.0_wp) .AND. & - ABS(model%viv_phi(1) - 2.0_wp*PI) < 1.0e-12_wp, 'the phases start at 2 pi i/N from End A') + ! MoorDyn's 2 pi i/N from End A, half a turn on: the material tangent runs from End B to End A + CALL require(ABS(model%viv_phi(NE + 1) - PI) < 1.0e-12_wp .AND. & + ABS(model%viv_phi(NE) - (2.0_wp*PI/REAL(NE, wp) + PI)) < 1.0e-12_wp .AND. & + ABS(model%viv_phi(1) - PI) < 1.0e-12_wp, 'the phases start at 2 pi i/N + pi from End A') ! a drag reconfigured after VIV carries the lift scale and shedding diameter with it BLOCK REAL(wp) :: k0(NE), dn0(NE + 1), hd(NE), hn(NE), ht(NE) diff --git a/tests/test_lapack_guard_pages.c b/tests/test_lapack_guard_pages.c index b55d69c7..172df573 100644 --- a/tests/test_lapack_guard_pages.c +++ b/tests/test_lapack_guard_pages.c @@ -2,14 +2,16 @@ * SPDX-License-Identifier: Apache-2.0 * Copyright (c) 2026 Jae Hoon Seo, SMI Lab, Inha University * - * The modal eigensolves (DSYGV, the dense reference; DSBGVX, the banded production solver) - * called through CableDyn's LAPACK layer -- in Windows GNU builds the run-time forwarders to - * openblas.dll -- with every argument array placed against a no-access page, at its end and, - * in a second pass, at its start. Any read or write outside the arrays the modal code passes - * faults at once and names the call. Sizes cover the test_modal cases and more (n <= 96, half - * band widths 0..11), with the argument sizes CableDyn_Modal uses (WORK 7n and IWORK 5n for - * DSBGVX, the queried LWORK for DSYGV). CTest runs it with OPENBLAS_CORETYPE=Haswell, the - * kernel selected on the hosts where test_modal was seen to fault. + * The modal eigensolves (DSYGV, the dense reference; DSBGVX, the band reduction; DPBTRF and + * DPBTRS, the banded Cholesky factor and solves of the shift-invert Lanczos stage; DSYEV, its + * projected eigenproblem) called through CableDyn's LAPACK layer -- in Windows GNU builds the + * run-time forwarders to openblas.dll -- with every argument array placed against a no-access + * page, at its end and, in a second pass, at its start. Any read or write outside the arrays + * the modal code passes faults at once and names the call. Sizes cover the test_modal cases and + * more (n <= 96, half band widths 0..11), with the argument sizes CableDyn_Modal uses (WORK 7n + * and IWORK 5n for DSBGVX, two right-hand sides for DPBTRS, the queried LWORK for DSYGV and + * DSYEV). CTest runs it with OPENBLAS_CORETYPE=Haswell, the kernel selected on the hosts where + * test_modal was seen to fault. */ #if !defined(_WIN32) #define _DEFAULT_SOURCE @@ -28,6 +30,11 @@ void dsbgvx_(const char *jobz, const char *range, const char *uplo, const int *n const double *vu, const int *il, const int *iu, const double *abstol, int *m, double *w, double *z, const int *ldz, double *work, int *iwork, int *ifail, int *info, size_t jobz_len, size_t range_len, size_t uplo_len); +void dsyev_(const char *jobz, const char *uplo, const int *n, double *a, const int *lda, double *w, double *work, + const int *lwork, int *info, size_t jobz_len, size_t uplo_len); +void dpbtrf_(const char *uplo, const int *n, const int *kd, double *ab, const int *ldab, int *info, size_t uplo_len); +void dpbtrs_(const char *uplo, const int *n, const int *kd, const int *nrhs, const double *ab, const int *ldab, + double *b, const int *ldb, int *info, size_t uplo_len); static char where[96] = "start"; @@ -160,6 +167,25 @@ int main(void) fprintf(stderr, "FAIL: DSYGV n = %d returned INFO = %d\n", n, info); ++failures; } + for (j = 0; j < n; ++j) { + for (i = 0; i <= j; ++i) { + a[i + j * n] = a[j + i * n] = next_random(&state) - 0.5; + } + } + lwork = -1; + snprintf(where, sizeof where, "DSYEV workspace query, n = %d", n); + dsyev_("V", "U", &n, a, &n, w, &query, &lwork, &info, 1, 1); + lwork = (int)query; + if (lwork < 3 * n) { + lwork = 3 * n; + } + work = guarded(sizeof(double) * (size_t)lwork, front); + snprintf(where, sizeof where, "DSYEV, n = %d, %s guard", n, front ? "front" : "end"); + dsyev_("V", "U", &n, a, &n, w, work, &lwork, &info, 1, 1); + if (info != 0) { + fprintf(stderr, "FAIL: DSYEV n = %d returned INFO = %d\n", n, info); + ++failures; + } for (kd = 0; kd <= 11 && kd < n; ++kd) { int ld = kd + 1, il = 1, iu = n < 6 ? n : 6, m = 0, one = 1; double vl = 0.0, vu = 0.0, tol = 4.4501477170144028e-308, q = 0.0, z = 0.0; @@ -183,12 +209,40 @@ int main(void) fprintf(stderr, "FAIL: DSBGVX n = %d kd = %d returned INFO = %d, M = %d\n", n, kd, info, m); ++failures; } + { + int two = 2; + double *fk = guarded(sizeof(double) * (size_t)ld * (size_t)n, front); + double *rhs = guarded(sizeof(double) * 2 * (size_t)n, front); + for (j = 0; j < n; ++j) { + for (i = j - kd > 0 ? j - kd : 0; i <= j; ++i) { + fk[(kd + i - j) + j * ld] = i == j ? 2.0 * n + kd : next_random(&state) - 0.5; + } + rhs[j] = next_random(&state); + rhs[j + n] = next_random(&state); + } + snprintf(where, sizeof where, "DPBTRF, n = %d, kd = %d, %s guard", n, kd, + front ? "front" : "end"); + dpbtrf_("U", &n, &kd, fk, &ld, &info, 1); + if (info != 0) { + fprintf(stderr, "FAIL: DPBTRF n = %d kd = %d returned INFO = %d\n", n, kd, info); + ++failures; + continue; + } + snprintf(where, sizeof where, "DPBTRS, n = %d, kd = %d, %s guard", n, kd, + front ? "front" : "end"); + dpbtrs_("U", &n, &kd, &two, fk, &ld, rhs, &n, &info, 1); + if (info != 0) { + fprintf(stderr, "FAIL: DPBTRS n = %d kd = %d returned INFO = %d\n", n, kd, info); + ++failures; + } + } } } } if (failures != 0) { return 1; } - printf("PASS: DSYGV and DSBGVX stay inside the arrays the modal code passes (n <= 96)\n"); + printf("PASS: DSYGV, DSYEV, DSBGVX, DPBTRF and DPBTRS stay inside the arrays the modal code passes " + "(n <= 96)\n"); return 0; } diff --git a/tests/test_modal.f90 b/tests/test_modal.f90 index a6cdee8f..7fef0e71 100644 --- a/tests/test_modal.f90 +++ b/tests/test_modal.f90 @@ -41,6 +41,8 @@ END FUNCTION blas_config CALL case_hermite_beam() CALL case_hermite_long_beam() CALL case_slack_string() + CALL case_solver_agreement() + CALL case_repeated_frequency() CALL case_irvine() CALL case_deck_hermite_and_rules() IF (nfail > 0) THEN @@ -201,23 +203,35 @@ SUBROUTINE case_hermite_beam() END SUBROUTINE case_hermite_beam SUBROUTINE check_band_against_dense(label, k, m, kb, mb, kd, free, om2_dense) - !! The banded solver on the band form of the dense matrices k, m: the frequencies of the - !! dense reference, and shapes that are M-orthonormal, zero on the held DOFs and satisfy - !! K phi = omega^2 M phi. + !! The banded solver on the band form of the dense matrices k, m, with each eigenvalue + !! stage (the shift-invert Lanczos iteration and the band reduction): the frequencies of + !! the dense reference, and shapes that are M-orthonormal, zero on the held DOFs and + !! satisfy K phi = omega^2 M phi. CHARACTER(*), INTENT(IN) :: label REAL(wp), INTENT(IN) :: k(:, :), m(:, :), kb(:, :), mb(:, :), om2_dense(:) INTEGER, INTENT(IN) :: kd LOGICAL, INTENT(IN) :: free(:) + CALL check_band_method(label//'[lanczos]', k, m, kb, mb, kd, free, om2_dense, CD_MODAL_EIG_LANCZOS) + CALL check_band_method(label//'[band-reduction]', k, m, kb, mb, kd, free, om2_dense, CD_MODAL_EIG_BANDRED) + END SUBROUTINE check_band_against_dense + + SUBROUTINE check_band_method(label, k, m, kb, mb, kd, free, om2_dense, method) + !! check_band_against_dense with one eigenvalue stage, which must be the one used. + CHARACTER(*), INTENT(IN) :: label + REAL(wp), INTENT(IN) :: k(:, :), m(:, :), kb(:, :), mb(:, :), om2_dense(:) + INTEGER, INTENT(IN) :: kd, method + LOGICAL, INTENT(IN) :: free(:) REAL(wp), ALLOCATABLE :: om2(:), sh(:, :), ksh(:, :), msh(:, :), gram(:, :) REAL(wp) :: knorm, fdiff, resid, ortho - INTEGER :: nm, nf, es, j + INTEGER :: nm, nf, es, j, used LOGICAL :: held_zero CHARACTER(256) :: em nm = SIZE(om2_dense) ALLOCATE (om2(nm), sh(SIZE(free), nm)) - CALL CD_Modal_Solve_Band(kb, mb, kd, free, nm, om2, sh, nf, es, em) + CALL CD_Modal_Solve_Band(kb, mb, kd, free, nm, om2, sh, nf, es, em, eig_method=method, eig_used=used) CALL require(es == CD_MODAL_OK .AND. nf == nm, label//':band-solve: '//TRIM(em)) IF (es /= CD_MODAL_OK .OR. nf /= nm) RETURN + CALL require(used == method, label//':eigenvalue-stage-used') knorm = MAXVAL(SUM(ABS(k), 1)) fdiff = 0.0_wp DO j = 1, nm @@ -244,7 +258,7 @@ SUBROUTINE check_band_against_dense(label, k, m, kb, mb, kd, free, om2_dense) CALL require(resid < 1.0e-9_wp, label//':band-shape-residual') CALL require(ortho < 1.0e-8_wp, label//':band-shapes-M-orthonormal') CALL require(held_zero, label//':band-held-dofs-zero') - END SUBROUTINE check_band_against_dense + END SUBROUTINE check_band_method SUBROUTINE case_slack_string() !! A slack tension-only string has no stiffness (K = 0): every frequency is zero and the @@ -252,7 +266,7 @@ SUBROUTINE case_slack_string() INTEGER, PARAMETER :: NE = 20, NN = NE + 1, NM = 6 REAL(wp) :: q(3*NN), l0(NE), ea_(NE), rho_a(NE), om2(NM), gram(NM, NM) REAL(wp), ALLOCATABLE :: kb(:, :), mb(:, :), k(:, :), m(:, :), sh(:, :) - INTEGER :: conn(2, NE), i, es, nf, kd + INTEGER :: conn(2, NE), i, es, nf, kd, used LOGICAL :: free(3*NN) CHARACTER(256) :: em ALLOCATE (k(3*NN, 3*NN), m(3*NN, 3*NN), sh(3*NN, NM)) @@ -280,18 +294,25 @@ SUBROUTINE case_slack_string() gram(i, i) = gram(i, i) - 1.0_wp END DO CALL require(nan_max_abs(gram) < 1.0e-10_wp, 'slack:shapes-M-orthonormal') + ! K = 0 is not positive definite: the Lanczos stage hands over to the band reduction + CALL CD_Modal_Solve_Band(kb, mb, kd, free, NM, om2, sh, nf, es, em, eig_method=CD_MODAL_EIG_LANCZOS, & + eig_used=used) + CALL require(es == CD_MODAL_OK .AND. nf == NM .AND. used == CD_MODAL_EIG_BANDRED, & + 'slack:lanczos-hands-over: '//TRIM(em)) + CALL require(nan_max_abs(om2) < 1.0e-9_wp, 'slack:lanczos-hands-over-zero-frequencies') END SUBROUTINE case_slack_string SUBROUTINE case_hermite_long_beam() !! A pre-tensioned 1024-element beam-string (6150 DOFs, beyond the dense reference): the !! banded solver against the closed-form frequencies; each repeated frequency (the two - !! transverse planes) gets shapes in both planes. + !! transverse planes) gets shapes in both planes. A line this long takes the shift-invert + !! Lanczos eigenvalue stage. INTEGER, PARAMETER :: NE = 1024, NN = NE + 1, NM = 10 REAL(wp), PARAMETER :: L = 500.0_wp, EI = 1.0e6_wp, RHO = 100.0_wp, EPS = 1.0e-4_wp REAL(wp), ALLOCATABLE :: q(:), l0(:), ea(:), eiv(:), rho_a(:), kb(:, :), mb(:, :), sh(:, :) LOGICAL, ALLOCATABLE :: free(:) REAL(wp) :: om2(NM), t, mc, f_exp, f_got, sy, sz - INTEGER :: i, es, kd, nf, j, n + INTEGER :: i, es, kd, nf, j, n, used INTEGER(8) :: c0, c1, rate CHARACTER(256) :: em ALLOCATE (q(6*NN), l0(NE), ea(NE), eiv(NE), rho_a(NE), sh(6*NN, NM), free(6*NN)) @@ -308,10 +329,11 @@ SUBROUTINE case_hermite_long_beam() CALL SYSTEM_CLOCK(c0, rate) CALL CD_Modal_Hermite_Band(q, l0, ea, eiv, rho_a, kd, kb, mb, es, em) CALL require(es == CD_MODAL_OK, 'long-beam:band-matrices: '//TRIM(em)) - CALL CD_Modal_Solve_Band(kb, mb, kd, free, NM, om2, sh, nf, es, em) + CALL CD_Modal_Solve_Band(kb, mb, kd, free, NM, om2, sh, nf, es, em, eig_used=used) CALL SYSTEM_CLOCK(c1) CALL require(es == CD_MODAL_OK .AND. nf == NM, 'long-beam:band-solve: '//TRIM(em)) IF (es /= CD_MODAL_OK .OR. nf /= NM) RETURN + CALL require(used == CD_MODAL_EIG_LANCZOS, 'long-beam:lanczos-eigenvalues') WRITE (*, '(A,I0,A,F8.3,A)') 'long beam: ', COUNT(free), ' free DOFs, banded solve in ', & REAL(c1 - c0, wp)/REAL(rate, wp), ' s' t = 1.0e9_wp*EPS @@ -330,6 +352,160 @@ SUBROUTINE case_hermite_long_beam() END DO END SUBROUTINE case_hermite_long_beam + SUBROUTINE sagged_line(finite_ei, ne, kb, mb, kd, free) + !! A line sagged on a parabola (span 500 m, sag 60 m, stretch 1e-3, ends held) with the + !! Morison added mass: a finite-EI power cable or an EI = 0 chain, in band storage. + LOGICAL, INTENT(IN) :: finite_ei + INTEGER, INTENT(IN) :: ne + REAL(wp), ALLOCATABLE, INTENT(OUT) :: kb(:, :), mb(:, :) + INTEGER, INTENT(OUT) :: kd + LOGICAL, ALLOCATABLE, INTENT(OUT) :: free(:) + REAL(wp), PARAMETER :: SPAN = 500.0_wp, SAG = 60.0_wp, EPS = 1.0e-3_wp + REAL(wp), ALLOCATABLE :: q(:), l0(:), ea(:), ei(:), rho(:), dia(:), can(:), cat(:), wl(:), xs(:), zs(:) + REAL(wp) :: dzdx, tl + INTEGER :: i, nn, es + INTEGER, ALLOCATABLE :: conn(:, :) + CHARACTER(256) :: em + nn = ne + 1 + ALLOCATE (l0(ne), ea(ne), ei(ne), rho(ne), dia(ne), can(ne), cat(ne), xs(0:ne), zs(0:ne)) + DO i = 0, ne + xs(i) = SPAN*REAL(i, wp)/ne + zs(i) = -4.0_wp*SAG*(xs(i)/SPAN)*(1.0_wp - xs(i)/SPAN) + END DO + DO i = 1, ne + l0(i) = SQRT((xs(i) - xs(i - 1))**2 + (zs(i) - zs(i - 1))**2)/(1.0_wp + EPS) + END DO + dia = 0.16_wp + can = 1.0_wp + cat = 0.0_wp + IF (finite_ei) THEN + ALLOCATE (q(6*nn), free(6*nn)) + DO i = 0, ne + dzdx = -4.0_wp*SAG/SPAN*(1.0_wp - 2.0_wp*xs(i)/SPAN) + tl = SQRT(1.0_wp + dzdx**2) + q(6*i + 1:6*i + 6) = [xs(i), 0.0_wp, zs(i), (1.0_wp + EPS)/tl, 0.0_wp, (1.0_wp + EPS)*dzdx/tl] + END DO + ea = 4.69e8_wp + ei = 1.99e4_wp + rho = 36.7_wp + free = .TRUE. + free(1:3) = .FALSE. + free(6*nn - 5:6*nn - 3) = .FALSE. + CALL CD_Modal_Hermite_Band(q, l0, ea, ei, rho, kd, kb, mb, es, em, am_rho=1025.0_wp, am_waterline=0.0_wp, & + am_diam=dia, am_can=can, am_cat=cat) + ELSE + ALLOCATE (q(3*nn), free(3*nn), wl(nn), conn(2, ne)) + DO i = 0, ne + q(3*i + 1:3*i + 3) = [xs(i), 0.0_wp, zs(i)] + END DO + DO i = 1, ne + conn(:, i) = [i, i + 1] + END DO + ea = 8.0e8_wp + rho = 150.0_wp + wl = 0.0_wp + free = .TRUE. + free(1:3) = .FALSE. + free(3*nn - 2:3*nn) = .FALSE. + CALL CD_Modal_Bar_Band(q, conn, l0, ea, rho, .TRUE., kd, kb, mb, es, em, am_rho=1025.0_wp, am_waterline=wl, & + am_diam=dia, am_can=can, am_cat=cat) + END IF + CALL require(es == CD_MODAL_OK, 'sagged-line:band-matrices: '//TRIM(em)) + END SUBROUTINE sagged_line + + SUBROUTINE case_solver_agreement() + !! The two eigenvalue stages on lines of distinct frequencies: a sagged finite-EI line + !! with added mass (300 elements, 1800 free DOFs) and a sagged EI = 0 chain (400 + !! elements, 1197). The production route takes the shift-invert Lanczos stage and gives + !! the frequencies of the band reduction to 1e-10 and the same shapes, with the same + !! signs (the symmetric sag puts equally large components on mirrored nodes: the first + !! one is positive). + INTEGER, PARAMETER :: NM = 20 + REAL(wp), ALLOCATABLE :: kb(:, :), mb(:, :), sh_l(:, :), sh_b(:, :) + LOGICAL, ALLOCATABLE :: free(:) + REAL(wp) :: om2_l(NM), om2_b(NM), fdiff, sdiff, gap + INTEGER :: kd, nf_l, nf_b, es_l, es_b, used, j, icase + CHARACTER(256) :: em + CHARACTER(16) :: label + DO icase = 1, 2 + IF (icase == 1) THEN + label = 'agree-hermite' + CALL sagged_line(.TRUE., 300, kb, mb, kd, free) + ELSE + label = 'agree-chain' + CALL sagged_line(.FALSE., 400, kb, mb, kd, free) + END IF + IF (ALLOCATED(sh_l)) DEALLOCATE (sh_l, sh_b) + ALLOCATE (sh_l(SIZE(free), NM), sh_b(SIZE(free), NM)) + CALL CD_Modal_Solve_Band(kb, mb, kd, free, NM, om2_l, sh_l, nf_l, es_l, em, eig_used=used) + CALL require(es_l == CD_MODAL_OK .AND. nf_l == NM, TRIM(label)//':solve: '//TRIM(em)) + CALL require(used == CD_MODAL_EIG_LANCZOS, TRIM(label)//':lanczos-eigenvalues') + CALL CD_Modal_Solve_Band(kb, mb, kd, free, NM, om2_b, sh_b, nf_b, es_b, em, eig_method=CD_MODAL_EIG_BANDRED) + CALL require(es_b == CD_MODAL_OK .AND. nf_b == NM, TRIM(label)//':band-reduction-solve: '//TRIM(em)) + IF (es_l /= CD_MODAL_OK .OR. es_b /= CD_MODAL_OK .OR. nf_l /= NM .OR. nf_b /= NM) CYCLE + fdiff = 0.0_wp + sdiff = 0.0_wp + DO j = 1, NM + fdiff = MAX(fdiff, ABS(om2_l(j) - om2_b(j))/ABS(om2_b(j))) + gap = HUGE(1.0_wp) + IF (j > 1) gap = MIN(gap, (om2_b(j) - om2_b(j - 1))/om2_b(j)) + IF (j < NM) gap = MIN(gap, (om2_b(j + 1) - om2_b(j))/om2_b(j)) + IF (gap > 1.0e-4_wp) sdiff = MAX(sdiff, nan_max_abs(sh_l(:, j) - sh_b(:, j))/nan_max_abs(sh_b(:, j))) + END DO + WRITE (*, '(A,2ES11.3)') TRIM(label)//': Lanczos vs band reduction, max relative omega^2 and shape '// & + 'differences: ', fdiff, sdiff + CALL require(fdiff <= 1.0e-10_wp, TRIM(label)//':frequencies-equal') + CALL require(sdiff <= 1.0e-8_wp, TRIM(label)//':shapes-and-signs-equal') + END DO + END SUBROUTINE case_solver_agreement + + SUBROUTINE case_repeated_frequency() + !! A frequency repeated six times, three times the Lanczos block: NN nodes of six DOFs + !! joined along a chain by identical springs on each DOF (ends held), K = L (x) I6 with L + !! the chain Laplacian, M = I, eigenvalues 2 k (1 - cos(j pi/(NN + 1))), each sixfold; the + !! 8 lowest modes cut the second value's copies. The Sturm count of the Lanczos stage + !! rejects a run that misses a copy (without it, a single-vector block accepts one): each + !! stage returns every copy, with M-orthonormal shapes. The same lattice shifted to a + !! negative lowest eigenvalue (K - s M, indefinite): the Lanczos stage hands over to the + !! band reduction. + INTEGER, PARAMETER :: NN = 150, NC = 6, N = NC*NN, NM = 8, KD = NC + REAL(wp), PARAMETER :: KS = 1.0e4_wp + REAL(wp), ALLOCATABLE :: kb(:, :), mb(:, :), sh(:, :), gram(:, :) + REAL(wp) :: om2(NM), lam(NM), shift, err + LOGICAL :: free(N) + INTEGER :: i, j, nf, es, used, method, pass + CHARACTER(256) :: em + ALLOCATE (kb(KD + 1, N), mb(KD + 1, N), sh(N, NM)) + free = .TRUE. + DO pass = 1, 2 + shift = 0.0_wp + IF (pass == 2) shift = 3.0_wp*KS*(1.0_wp - COS(PI/REAL(NN + 1, wp))) + kb = 0.0_wp + mb = 0.0_wp + kb(KD + 1, :) = 2.0_wp*KS - shift + kb(1, KD + 1:N) = -KS + mb(KD + 1, :) = 1.0_wp + DO j = 1, NM + lam(j) = 2.0_wp*KS*(1.0_wp - COS(REAL((j + NC - 1)/NC, wp)*PI/REAL(NN + 1, wp))) - shift + END DO + DO method = CD_MODAL_EIG_AUTO, CD_MODAL_EIG_LANCZOS + CALL CD_Modal_Solve_Band(kb, mb, KD, free, NM, om2, sh, nf, es, em, eig_method=method, eig_used=used) + CALL require(es == CD_MODAL_OK .AND. nf == NM, 'repeated:solve: '//TRIM(em)) + IF (es /= CD_MODAL_OK .OR. nf /= NM) CYCLE + err = MAXVAL(ABS(om2 - lam))/MAXVAL(ABS(lam)) + gram = MATMUL(TRANSPOSE(sh), sh) + DO i = 1, NM + gram(i, i) = gram(i, i) - 1.0_wp + END DO + WRITE (*, '(A,I0,A,I0,A,I0,A,2ES11.3)') 'repeated frequency: pass ', pass, ', method ', method, ', used ', & + used, ': omega^2 error, M-orthonormality error ', err, nan_max_abs(gram) + CALL require(err < 1.0e-9_wp, 'repeated:every-copy-found') + CALL require(nan_max_abs(gram) < 1.0e-10_wp, 'repeated:shapes-M-orthonormal') + IF (pass == 2) CALL require(used == CD_MODAL_EIG_BANDRED, 'repeated:indefinite-hands-over') + END DO + END DO + END SUBROUTINE case_repeated_frequency + ! ------------------------------------------------------------------ deck helpers SUBROUTINE read_table(path, marker, ncol, data, nrow) diff --git a/tests/test_modal_negative_note.py b/tests/test_modal_negative_note.py new file mode 100644 index 00000000..ec11e45c --- /dev/null +++ b/tests/test_modal_negative_note.py @@ -0,0 +1,104 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Copyright (c) 2026 Jae Hoon Seo, SMI Lab, Inha University +"""A modal analysis about an unstable static state reports its negative omega^2. + +A short finite-EI cable on a coarse mesh (27 elements) is solved in its vertical plane, where +it is unstable out of the plane: its lowest eigenvalue omega^2 is negative. modes.out must +write that mode with a negative frequency and omega and a period of 0, and the run must print +a note naming the line. On a mesh refined 4x the planar state is stable: every frequency is +positive and the note is absent. + +usage: test_modal_negative_note.py --exe --output +""" + +from __future__ import annotations + +import argparse +import os +import subprocess +import sys +from pathlib import Path + +DECK = """--------------------- CableDyn Input File ------------------------------------ +Finite-EI cable whose planar static state is unstable out of its plane on a coarse mesh +--------------------- LINE TYPES --------------------------------------- +TypeName Diam Mass EA BA EI Cd_n Cd_t Ca_n Ca_t +(-) (m) (kg/m) (N) (N-s) (N-m2) (-) (-) (-) (-) +cab 0.167 45.5 5.72e8 -0.5 9250.0 1.2 0.01 1.0 0.0 +--------------------- POINTS ------------------------------------------- +ID Type X Y Z +(-) (-) (m) (m) (m) +1 Coupled 0.0 0.0 -0.24 +2 Fixed 77.65 0.0 -21.06 +--------------------- LINES -------------------------------------------- +ID NodeA NodeB Outputs +(-) (-) (-) (-) +1 1 2 - +--------------------- SECTIONS ----------------------------------------- +LineID LineType Length NumSegs +(-) (-) (m) (-) +1 cab 90.56 {n} +--------------------- OPTIONS ------------------------------------------ +21.06 WtrDpth +1.5e5 kBot +0.01 dtM +0.0 TMax +4 nModes +--------------------- OUTPUTS ------------------------------------------ +FairTen1 +--------------------- need this line ----------------------------------- +""" + +NOTE = "of its modes have omega^2 < 0" + + +def run(exe: str, out: Path, n: int) -> tuple: + deck = out / ("cable_%d.dat" % n) + deck.write_text(DECK.format(n=n), encoding="utf-8", newline="\n") + root = out / ("cable_%d" % n) + env = dict(os.environ) + env.setdefault("OPENBLAS_NUM_THREADS", "1") + p = subprocess.run([exe, str(deck), str(root)], capture_output=True, text=True, env=env, cwd=str(out)) + if p.returncode != 0: + raise RuntimeError("run with %d elements failed: %s" % (n, (p.stdout + p.stderr)[-400:])) + rows = [] + for ln in Path(str(root) + ".modes.out").read_text(encoding="utf-8").splitlines(): + if ln.startswith("# Mode shapes"): + break + t = ln.split() + if len(t) == 5 and t[0].isdigit(): + rows.append([float(v) for v in t[2:]]) + return rows, p.stdout + p.stderr + + +def main() -> int: + ap = argparse.ArgumentParser() + ap.add_argument("--exe", required=True) + ap.add_argument("--output", required=True) + a = ap.parse_args() + out = Path(a.output) + out.mkdir(parents=True, exist_ok=True) + failures = [] + rows, log = run(a.exe, out, 27) + neg = [r for r in rows if r[0] < 0.0] + if not neg: + failures.append("coarse mesh: no negative frequency (%s)" % rows) + for f, per, om in neg: + if per != 0.0 or om >= 0.0: + failures.append("coarse mesh: negative mode with period %g, omega %g" % (per, om)) + if "line 1: %d %s" % (len(neg), NOTE) not in log: + failures.append("coarse mesh: the run does not note the %d negative mode(s)" % len(neg)) + rows, log = run(a.exe, out, 108) + if any(r[0] <= 0.0 for r in rows): + failures.append("refined mesh: a non-positive frequency (%s)" % rows) + if NOTE in log: + failures.append("refined mesh: the run notes a negative mode") + print("modal negative-mode note: %d failures" % len(failures)) + for f in failures: + print("FAIL:", f) + return 1 if failures else 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tests/test_openfast_aggregate.f90 b/tests/test_openfast_aggregate.f90 index 89809f58..3b472d30 100644 --- a/tests/test_openfast_aggregate.f90 +++ b/tests/test_openfast_aggregate.f90 @@ -563,6 +563,17 @@ SUBROUTINE case_pure_mooring_equals_fmf() LOGICAL :: ca, cf, sa, sf CALL write_volturnus_deck('agg_pure.dat') + ! a host step below the smallest time step (1e-100 s) is refused by name at initialisation + BLOCK + TYPE(CD_AGG_ModuleType) :: tiny_agg + TYPE(CD_FMF_ModuleType) :: tiny_fmf + CALL CD_AGG_Init_From_Deck(tiny_agg, 'agg_pure.dat', 1.0e-200_wp, es, em) + CALL require(es /= CD_AGG_OK .AND. INDEX(em, 'smallest time step, 1e-100 s') > 0, & + 'pure:agg-init refuses dt = 1e-200 s by name: '//TRIM(em)) + CALL CD_FMF_Init_From_Deck(tiny_fmf, 'agg_pure.dat', 1.0e-200_wp, es, em) + CALL require(es /= CD_FMF_OK .AND. INDEX(em, 'smallest time step, 1e-100 s') > 0, & + 'pure:fmf-init refuses dt = 1e-200 s by name: '//TRIM(em)) + END BLOCK CALL CD_AGG_Init_From_Deck(agg, 'agg_pure.dat', DT, es, em) CALL require(es == CD_AGG_OK .AND. CD_AGG_IsInitialized(agg), 'pure:agg-init: '//TRIM(em)) IF (es /= CD_AGG_OK) RETURN @@ -758,7 +769,7 @@ SUBROUTINE case_output_channels() REAL(wp), PARAMETER :: DT = 0.05_wp, EI_BARE = 1.99e4_wp REAL(wp) :: vFairTen2, vAnchTen2, vCurv1N5, vFairAngle1, vBendMom1N5, vTen1N10 REAL(wp) :: vFairDecl1, vFairIncl1 - REAL(wp) :: r1(3), r2(3), kexp, decexp + REAL(wp) :: kexp, decexp REAL(wp), ALLOCATABLE :: tension(:), exact_curvature(:) CALL write_mixed_channels_deck('agg_channels.dat') @@ -859,10 +870,10 @@ SUBROUTINE case_output_channels() END BLOCK CALL CD_HermiteCable_Dyn_Set_Output_Recovery(agg%cables(1)%line, .FALSE.) - ! (c) cable FairAngle1 == declination of the End-A one-sided tangent (deck nodes 1,2). - base = 6*(nnode - 1); r1 = agg%cables(1)%line%q(base + 1:base + 3) - base = 6*(nnode - 2); r2 = agg%cables(1)%line%q(base + 1:base + 3) - decexp = tangent_declination_deg(r2 - r1) + ! (c) cable FairAngle1 == declination of the End-A tangent: the tangent DOF of deck node 1 + ! (internal node nnode), reversed to point End A -> End B. + base = 6*(nnode - 1) + decexp = tangent_declination_deg(-agg%cables(1)%line%q(base + 4:base + 6)) CALL require(ABS(vFairAngle1 - decexp) <= 1.0e-9_wp + 1.0e-6_wp*ABS(decexp), 'chan:FairAngle1-matches-driver') CALL require(vFairDecl1 >= 0.0_wp .AND. vFairDecl1 <= 180.0_wp, 'chan:AnchDecl1-declination-range') CALL require(ABS(vFairIncl1 - (decexp - 90.0_wp)) <= 1.0e-9_wp + 1.0e-6_wp*ABS(decexp), & diff --git a/tests/test_point3_balance_note.py b/tests/test_point3_balance_note.py new file mode 100644 index 00000000..e69bca0e --- /dev/null +++ b/tests/test_point3_balance_note.py @@ -0,0 +1,107 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Copyright (c) 2026 Jae Hoon Seo, SMI Lab, Inha University +"""A Point3 buoy that starts off balance under bodyIC static is noted with its unbalanced force. + +The static solve does not place a Point3 buoy: it starts at its deck position. A 112 t buoy of +259 m^3 on one slack wire leg, 11 m below the surface, starts with about 1.5 MN of net buoyancy +unbalanced. Under the default bodyIC static the run must note it, with the force equal to the +line force on the buoy (Point1F at t = 0) plus its net buoyancy (rhoW Vol - Mass) g to 1e-3, and +with bodyIC deck (an off-balance start on purpose) it must not. + +usage: test_point3_balance_note.py --exe --output +""" + +from __future__ import annotations + +import argparse +import math +import os +import re +import subprocess +import sys +from pathlib import Path + +DECK = """--------------------- CableDyn Input File ------------------------------------ +Point3 buoy on one wire leg, off balance at its deck position +--------------------- LINE TYPES --------------------------------------- +TypeName Diam Mass EA BA EI Cd_n Cd_t Ca_n Ca_t +(-) (m) (kg/m) (N) (N-s) (N-m2) (-) (-) (-) (-) +leg 0.0631 19.93 3.588e8 -0.5 0.0 1.2 0.008 1.0 0.0 +--------------------- BODIES ------------------------------------------- +ID Type X Y Z Roll Pitch Yaw Mass Vol C33 C44 C55 CdA Ca Ixx Iyy Izz +(-) (-) (m) (m) (m) (deg) (deg) (deg) (kg) (m3) (N/m) (Nm/rad) (Nm/rad) (m2) (-) (kgm2) (kgm2) (kgm2) +1 Point3 27.92 -29.39 -11.07 0.0 0.0 0.0 111760.0 258.6 0.0 0.0 0.0 5.56 0.5 683510.0 683510.0 683510.0 +--------------------- POINTS ------------------------------------------- +ID Type X Y Z +(-) (-) (m) (m) (m) +1 Body1 0.0 0.0 0.0 +2 Fixed 166.94 -51.95 -56.85 +--------------------- LINES -------------------------------------------- +ID NodeA NodeB Outputs +(-) (-) (-) (-) +1 1 2 - +--------------------- SECTIONS ----------------------------------------- +LineID LineType Length NumSegs +(-) (-) (m) (-) +1 leg 178.39 23 +--------------------- OPTIONS ------------------------------------------ +56.85 WtrDpth +1.8e5 kBot +0.01 dtM +0.02 TMax +{ic} bodyIC +--------------------- OUTPUTS ------------------------------------------ +Point1Fx +Point1Fy +Point1Fz +--------------------- need this line ----------------------------------- +""" + +NOTE = re.compile(r"BODY 1 \(Point3\) starts at its deck position, which the static solve does not change, " + r"with an unbalanced force of\s+(\S+) N there") +G, RHO = 9.80665, 1025.0 + + +def run(exe: str, out: Path, ic: str) -> tuple: + deck = out / ("buoy_%s.dat" % ic) + deck.write_text(DECK.format(ic=ic), encoding="utf-8", newline="\n") + root = out / ("buoy_%s" % ic) + env = dict(os.environ) + env.setdefault("OPENBLAS_NUM_THREADS", "1") + p = subprocess.run([exe, str(deck), str(root)], capture_output=True, text=True, env=env, cwd=str(out)) + if p.returncode != 0: + raise RuntimeError("bodyIC %s run failed: %s" % (ic, (p.stdout + p.stderr)[-400:])) + rows = Path(str(root) + ".out").read_text(encoding="utf-8").splitlines() + return [float(v) for v in rows[2].split()[1:4]], p.stdout + p.stderr + + +def main() -> int: + ap = argparse.ArgumentParser() + ap.add_argument("--exe", required=True) + ap.add_argument("--output", required=True) + a = ap.parse_args() + out = Path(a.output) + out.mkdir(parents=True, exist_ok=True) + failures = [] + f, log = run(a.exe, out, "static") + m = NOTE.search(log) + if not m: + failures.append("bodyIC static: no note of the unbalanced Point3 buoy") + else: + net = (f[0], f[1], f[2] + (RHO * 258.6 - 111760.0) * G) + expect = math.sqrt(sum(c * c for c in net)) + got = float(m.group(1)) + if abs(got - expect) > 1.0e-3 * expect: + failures.append("bodyIC static: noted force %.4e N, expected %.4e N" % (got, expect)) + _, log = run(a.exe, out, "deck") + if NOTE.search(log): + failures.append("bodyIC deck: the off-balance start is noted") + print("Point3 balance note: %d failures" % len(failures)) + for x in failures: + print("FAIL:", x) + return 1 if failures else 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tests/test_point_static_cycle.py b/tests/test_point_static_cycle.py new file mode 100644 index 00000000..dabbef75 --- /dev/null +++ b/tests/test_point_static_cycle.py @@ -0,0 +1,105 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Copyright (c) 2026 Jae Hoon Seo, SMI Lab, Inha University +"""The static balance of a Connect point does not cycle between trial steps. + +A massless Connect point hangs from a fairlead on a 383 m heavy chain (4.0 kN/m submerged) +and is held by two wires to anchors on the seabed, 860 and 915 m away, one wire 50 m slack, the +other lying nearly taut. Its balance (independent check: elastic catenaries with a frictionless +seabed) lies 5.6 m above the seabed at (-46.28, -215.17, -385.52) m, the chain hanging almost +straight. The point solve accepted a step that raised the force residual a hundredfold when the +Newton step from it was half the current one; near the wires' slack/taut kinks the Newton step +then grew again, and the steps cycled with period four (4e4 N -> 6e6 N -> ...) until the solve +failed from every seed. The deck, translated by 0, 0.5, 7 and 50 m and on twice its mesh, must +solve, with the point within 1.5 m (deck mesh: 11 to 27 m elements, the lumped weight of a chain +element 43 kN) and 0.5 m (refined mesh) of that balance. + +usage: test_point_static_cycle.py --exe --output +""" + +from __future__ import annotations + +import argparse +import math +import os +import subprocess +import sys +from pathlib import Path + +DECK = """--------------------- CableDyn Input File ------------------------------------ +Connect point between a near-vertical heavy chain and two wires on the seabed +--------------------- LINE TYPES --------------------------------------- +TypeName Diam Mass EA BA EI Cd_n Cd_t Ca_n Ca_t +(-) (m) (kg/m) (N) (N-s) (N-m2) (-) (-) (-) (-) +c1 0.27415669765336415 461.64250243121677 1981119080.7852216 -0.5 0.0 2.4 1.15 1.0 0.5 +c2 0.15735867593791983 123.80876446467634 2228557760.3641744 -0.8 0.0 1.2 0.008 1.0 0.0 +--------------------- POINTS ------------------------------------------- +ID Type X Y Z +(-) (-) (m) (m) (m) +1 Connect {p1} -243.72632411372282 +2 Coupled {p2} -3.636762830393616 +3 Fixed {p3} -391.1306916880583 +4 Fixed {p4} -391.1306916880583 +--------------------- LINES -------------------------------------------- +ID NodeA NodeB Outputs +(-) (-) (-) (-) +1 2 1 - +2 1 3 - +3 1 4 - +--------------------- SECTIONS ----------------------------------------- +LineID LineType Length NumSegs +(-) (-) (m) (-) +1 c1 383.1443798528323 {n1} +2 c2 911.6709117895668 {n2} +3 c2 915.0868828891583 {n3} +--------------------- OPTIONS ------------------------------------------ +391.1306916880583 WtrDpth +68564.77991863908 kBot +0.01 dtM +0.02 TMax +--------------------- OUTPUTS ------------------------------------------ +Point1px +Point1py +Point1pz +--------------------- need this line ----------------------------------- +""" + +XY = [(-15.372812272073247, -9.211690291294737), (-33.33826322302139, -226.49112604239878), + (824.7662044985119, -134.65675642308003), (-733.8644971516716, 386.4080560971254)] +BALANCE = (-46.28, -215.17, -385.52) + + +def main() -> int: + ap = argparse.ArgumentParser() + ap.add_argument("--exe", required=True) + ap.add_argument("--output", required=True) + a = ap.parse_args() + out = Path(a.output) + out.mkdir(parents=True, exist_ok=True) + env = dict(os.environ) + env.setdefault("OPENBLAS_NUM_THREADS", "1") + failures = [] + cases = [(dx, 1, 1.5) for dx in (0.0, 0.5, 7.0, 50.0)] + [(0.0, 2, 0.5)] + for dx, f, tol in cases: + pts = {"p%d" % (k + 1): "%r %r" % (x + dx, y) for k, (x, y) in enumerate(XY)} + name = "connect_%g_%d" % (dx, f) + deck = out / (name + ".dat") + deck.write_text(DECK.format(n1=35 * f, n2=34 * f, n3=33 * f, **pts), encoding="utf-8", newline="\n") + root = out / name + p = subprocess.run([a.exe, str(deck), str(root)], capture_output=True, text=True, env=env, cwd=str(out)) + if p.returncode != 0: + failures.append("shift %g, mesh x%d: exit %d: %s" % (dx, f, p.returncode, (p.stdout + p.stderr)[-300:])) + continue + rows = Path(str(root) + ".out").read_text(encoding="utf-8").splitlines() + x, y, z = [float(v) for v in rows[2].split()[1:4]] + d = math.dist((x - dx, y, z), BALANCE) + if d > tol: + failures.append("shift %g, mesh x%d: point %.3f m from the balance (limit %.1f m)" % (dx, f, d, tol)) + print("connect point balance: %d runs, %d failures" % (len(cases), len(failures))) + for m in failures: + print("FAIL:", m) + return 1 if failures else 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tests/test_static_current_balance.f90 b/tests/test_static_current_balance.f90 new file mode 100644 index 00000000..b5e7b449 --- /dev/null +++ b/tests/test_static_current_balance.f90 @@ -0,0 +1,230 @@ +! File: tests/test_static_current_balance.f90 +! SPDX-License-Identifier: Apache-2.0 +! Copyright (c) 2026 Jae Hoon Seo, SMI Lab, Inha University +PROGRAM test_static_current_balance + !! Global force balance of the static equilibrium of a finite-EI cable in a uniform current: + !! the end reactions (the force the line exerts on each end point, CD_HermiteCable_Dyn_End_Force, + !! the FairTen/AnchTen and Point

F quantities) balance the submerged weight and the Morison + !! drag of the converged shape, -F_A - F_B + W + D = 0. D is integrated here independently: + !! the documented law f = rho d Cdn |u_n| u_n / 2 + rho pi d Cdt |u_t| u_t / 2 per unit + !! deformed length on the converged cubic-Hermite centreline (its nodal positions and + !! tangents), by the solver's 3-point Gauss rule and by a 10-point one. The cables are pinned + !! (bending-free) or clamped at End A, in currents of 0.5, 1 and 2 m/s at headings 0, 45, 90 + !! and 180 deg across the vertical plane of the ends, suspended (every component checked) and + !! with a touchdown on a flat seabed (the horizontal components: the floor carries the vertical + !! load), on 100 and 25 elements. With the 3-point rule the balance closes to 1e-7 of the end + !! force on every case (the reactions are those of the equilibrium); with the 10-point rule to + !! 2e-7 on 100 elements and 5e-6 on 25 (the drag quadrature). A current that leaves the line + !! no tension-only equilibrium is refused by name, as the deck is. + USE CableDyn_Precision, ONLY: wp + USE CableDyn_OpenFAST_Aggregate, ONLY: CD_AGG_ModuleType, CD_AGG_Init_From_Deck, CD_AGG_End, CD_AGG_OK + USE CableDyn_HermiteCableDynamic, ONLY: CD_HermiteCable_Dyn_End_Force, CD_HCDYN_OK + IMPLICIT NONE + + REAL(wp), PARAMETER :: PI = 3.14159265358979323846_wp + REAL(wp), PARAMETER :: TOL_SOLVER_RULE = 1.0e-7_wp + INTEGER, PARAMETER :: MESHES(2) = [100, 25] + REAL(wp), PARAMETER :: TOL_EXACT(2) = [2.0e-7_wp, 5.0e-6_wp] + REAL(wp), PARAMETER :: SPEEDS(3) = [0.5_wp, 1.0_wp, 2.0_wp] + REAL(wp), PARAMETER :: HEADINGS(4) = [0.0_wp, 45.0_wp, 90.0_wp, 180.0_wp] + INTEGER :: nfail, n_run, iu, ih, iclamp, itd, n_elem, im + REAL(wp) :: worst3, worst10, tol10 + + nfail = 0 + n_run = 0 + DO im = 1, SIZE(MESHES) + n_elem = MESHES(im) + tol10 = TOL_EXACT(im) + worst3 = 0.0_wp + worst10 = 0.0_wp + DO itd = 0, 1 + DO iclamp = 0, 1 + DO iu = 1, SIZE(SPEEDS) + DO ih = 1, SIZE(HEADINGS) + CALL run_case(iclamp == 1, itd == 1, SPEEDS(iu), HEADINGS(ih)) + END DO + END DO + END DO + END DO + WRITE (*, '(A,I0,A,ES10.3,A,ES10.3,A)') 'on ', n_elem, ' elements, largest relative imbalance ', worst3, & + ' (3-point drag), ', worst10, ' (10-point drag)' + END DO + WRITE (*, '(A,I0)') 'cases solved: ', n_run + IF (nfail > 0) THEN + WRITE (*, '(A,I0,A)') 'FAIL: ', nfail, ' check(s) failed' + ERROR STOP 1 + END IF + WRITE (*, '(A)') 'PASS' + +CONTAINS + + SUBROUTINE run_case(clamp, touchdown, speed, heading) + LOGICAL, INTENT(IN) :: clamp, touchdown + REAL(wp), INTENT(IN) :: speed, heading + TYPE(CD_AGG_ModuleType) :: agg + CHARACTER(512) :: em + CHARACTER(64) :: path + CHARACTER(160) :: label + REAL(wp) :: fa(3), fb(3), weight(3), drag3(3), drag10(3), imb3(3), imb10(3), scale, rel3, rel10 + REAL(wp), ALLOCATABLE :: u_elem(:, :) + INTEGER :: es, e + + path = 'static_current_balance.dat' + CALL write_deck(path, clamp, touchdown, speed, heading) + WRITE (label, '(A,I0,A,L1,A,L1,A,F4.1,A,F6.1)') 'N=', n_elem, ' clamped=', clamp, ' touchdown=', touchdown, & + ' U=', speed, ' heading=', heading + CALL CD_AGG_Init_From_Deck(agg, TRIM(path), 0.05_wp, es, em, deck_current=.TRUE.) + IF (es /= CD_AGG_OK) THEN + IF (INDEX(em, 'no tension-only static equilibrium') > 0 .OR. INDEX(em, 'no physical equilibrium') > 0) THEN + WRITE (*, '(2A)') ' skip ', TRIM(label)//': no tension-only equilibrium in this current' + CALL CD_AGG_End(agg, es, em) + RETURN + END IF + CALL check(.FALSE., TRIM(label)//': init: '//TRIM(em)) + CALL CD_AGG_End(agg, es, em) + RETURN + END IF + ASSOCIATE (ln => agg%cables(1)%line) + CALL CD_HermiteCable_Dyn_End_Force(ln, 1, fa, es, em) + CALL check(es == CD_HCDYN_OK, TRIM(label)//': end force 1: '//TRIM(em)) + CALL CD_HermiteCable_Dyn_End_Force(ln, ln%nn, fb, es, em) + CALL check(es == CD_HCDYN_OK, TRIM(label)//': end force 2: '//TRIM(em)) + weight = [0.0_wp, 0.0_wp, -SUM(ln%w*ln%l0)] + ! the element fluid velocity: the model's uniform current and, with a held field, the mean + ! of the held field at the element's nodes (the deck current of the aggregate) + ALLOCATE (u_elem(3, ln%ne)) + DO e = 1, ln%ne + u_elem(:, e) = ln%current + IF (ln%has_held_field) u_elem(:, e) = u_elem(:, e) + 0.5_wp*(ln%hf_u(:, e) + ln%hf_u(:, e + 1)) + END DO + ! the deck's uniform current, in the cable's frame (turned about z) + CALL check(MAXVAL(ABS(NORM2(u_elem(1:2, :), DIM=1) - speed)) <= 1.0e-12_wp*speed .AND. & + MAXVAL(ABS(u_elem(3, :))) <= 1.0e-12_wp*speed, TRIM(label)//': the cable sees the deck current') + CALL line_drag(ln%q, ln%l0, ln%diam, ln%cdn, ln%cdt, ln%rho_w, u_elem, 3, drag3) + CALL line_drag(ln%q, ln%l0, ln%diam, ln%cdn, ln%cdt, ln%rho_w, u_elem, 10, drag10) + END ASSOCIATE + imb3 = -fa - fb + weight + drag3 + imb10 = -fa - fb + weight + drag10 + IF (touchdown) THEN + imb3(3) = 0.0_wp + imb10(3) = 0.0_wp + END IF + scale = MAX(NORM2(fa), NORM2(fb)) + rel3 = NORM2(imb3)/scale + rel10 = NORM2(imb10)/scale + worst3 = MAX(worst3, rel3) + worst10 = MAX(worst10, rel10) + n_run = n_run + 1 + WRITE (*, '(2A,ES10.3,A,ES10.3,A,ES10.3,A)') ' ', TRIM(label)//': end force ', scale, & + ' N, relative imbalance ', rel3, ' (3-point drag), ', rel10, ' (10-point)' + CALL check(rel3 <= TOL_SOLVER_RULE, TRIM(label)//': the end reactions balance the weight and the drag') + CALL check(rel10 <= tol10, TRIM(label)//': the drag quadrature is converged') + CALL CD_AGG_End(agg, es, em) + END SUBROUTINE run_case + + SUBROUTINE line_drag(q, l0, diam, cdn, cdt, rho, u, order, drag) + !! The documented Morison drag of the still line in the current u (per element), integrated + !! on the cubic-Hermite centreline of q ([r, m] per node) per deformed length by the + !! order-point Gauss rule (3 or 10). + REAL(wp), INTENT(IN) :: q(:), l0(:), diam(:), cdn(:), cdt(:), rho, u(:, :) + INTEGER, INTENT(IN) :: order + REAL(wp), INTENT(OUT) :: drag(3) + REAL(wp), PARAMETER :: X10(5) = [0.1488743389816312_wp, 0.4333953941292472_wp, 0.6794095682990244_wp, & + 0.8650633666889845_wp, 0.9739065285171717_wp] + REAL(wp), PARAMETER :: W10(5) = [0.2955242247147529_wp, 0.2692667193099963_wp, 0.2190863625159820_wp, & + 0.1494513491505806_wp, 0.0666713443086881_wp] + REAL(wp), PARAMETER :: X3 = 0.7745966692414834_wp + REAL(wp) :: xg(10), wg(10), xi, rp(3), sp, t(3), ut(3), un(3), dh(4) + INTEGER :: e, g, s, b, ng + IF (order == 3) THEN + ng = 3 + xg(1:3) = [0.5_wp*(1.0_wp - X3), 0.5_wp, 0.5_wp*(1.0_wp + X3)] + wg(1:3) = [5.0_wp, 8.0_wp, 5.0_wp]/18.0_wp + ELSE + ng = 10 + xg = [0.5_wp*(1.0_wp - X10(5:1:-1)), 0.5_wp*(1.0_wp + X10)] + wg = [0.5_wp*W10(5:1:-1), 0.5_wp*W10] + END IF + drag = 0.0_wp + DO e = 1, SIZE(l0) + b = 6*(e - 1) + DO g = 1, ng + xi = xg(g) + dh = [6.0_wp*xi*xi - 6.0_wp*xi, l0(e)*(3.0_wp*xi*xi - 4.0_wp*xi + 1.0_wp), -6.0_wp*xi*xi + 6.0_wp*xi, & + l0(e)*(3.0_wp*xi*xi - 2.0_wp*xi)] + rp = 0.0_wp + DO s = 1, 2 + rp = rp + dh(2*s - 1)*q(b + 6*(s - 1) + 1:b + 6*(s - 1) + 3) + dh(2*s)*q(b + 6*(s - 1) + 4:b + 6*(s - 1) + 6) + END DO + sp = NORM2(rp) + t = rp/sp + ut = DOT_PRODUCT(u(:, e), t)*t + un = u(:, e) - ut + drag = drag + wg(g)*sp*(0.5_wp*rho*diam(e)*cdn(e)*NORM2(un)*un + 0.5_wp*rho*PI*diam(e)*cdt(e)*NORM2(ut)*ut) + END DO + END DO + END SUBROUTINE line_drag + + SUBROUTINE write_deck(path, clamp, touchdown, speed, heading) + CHARACTER(*), INTENT(IN) :: path + LOGICAL, INTENT(IN) :: clamp, touchdown + REAL(wp), INTENT(IN) :: speed, heading + INTEGER :: u + REAL(wp) :: ux, uy + ux = speed*COS(heading*PI/180.0_wp) + uy = speed*SIN(heading*PI/180.0_wp) + OPEN (NEWUNIT=u, FILE=path, STATUS='REPLACE', ACTION='WRITE') + WRITE (u, '(A)') '--------------------- CableDyn Input File ------------------------------------' + WRITE (u, '(A)') 'static force balance of a cable in a current' + WRITE (u, '(A)') '--------------------- LINE TYPES ---------------------------------------------' + WRITE (u, '(A)') 'TypeName Diam MassDenInAir EA BA/-zeta 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.2 60.0 1.0e8 -1.0 1.0e4 1.2 0.008 1.0 0.0' + WRITE (u, '(A)') '--------------------- POINTS -------------------------------------------------' + WRITE (u, '(A)') 'ID Type X Y Z Mass Vol CdA Ca' + WRITE (u, '(A)') '(-) (-) (m) (m) (m) (kg) (m^3) (m^2) (-)' + WRITE (u, '(A)') '1 Coupled 0.0 0.0 -10.0 0 0 0 0' + IF (touchdown) THEN + WRITE (u, '(A)') '2 Fixed 150.0 0.0 -100.0 0 0 0 0' + ELSE + WRITE (u, '(A)') '2 Fixed 80.0 0.0 -80.0 0 0 0 0' + END IF + WRITE (u, '(A)') '--------------------- LINES --------------------------------------------------' + WRITE (u, '(A)') 'ID NodeA NodeB Outputs' + WRITE (u, '(A)') '(-) (-) (-) (-)' + WRITE (u, '(A)') '1 1 2 -' + WRITE (u, '(A)') '--------------------- SECTIONS -----------------------------------------------' + WRITE (u, '(A)') 'LineID LineType Length NumSegs' + WRITE (u, '(A)') '(-) (-) (m) (-)' + IF (touchdown) THEN + WRITE (u, '(A,I0)') '1 cable 190.0 ', n_elem + ELSE + WRITE (u, '(A,I0)') '1 cable 125.0 ', n_elem + END IF + IF (clamp) THEN + WRITE (u, '(A)') '--------------------- END CONNECTIONS ----------------------------------------' + WRITE (u, '(A)') 'LineID End Stiffness EzX EzY EzZ' + WRITE (u, '(A)') '(-) (-) (N-m/rad) (-) (-) (-)' + WRITE (u, '(A)') '1 A Rigid 0.0 0.0 -1.0' + END IF + WRITE (u, '(A)') '--------------------- OPTIONS ------------------------------------------------' + WRITE (u, '(A)') '9.80665 g' + WRITE (u, '(A)') '1025.0 rhoW' + IF (touchdown) WRITE (u, '(A)') '100.0 WtrDpth' + WRITE (u, '(A)') '0.05 dtM' + WRITE (u, '(A)') '0.0 TMax' + WRITE (u, '(A,2(1X,ES23.16),A)') 'uniform', ux, uy, ' 0.0 current' + WRITE (u, '(A)') '--------------------- OUTPUTS ------------------------------------------------' + WRITE (u, '(A)') 'END' + CLOSE (u) + END SUBROUTINE write_deck + + SUBROUTINE check(ok, label) + LOGICAL, INTENT(IN) :: ok + CHARACTER(*), INTENT(IN) :: label + IF (ok) RETURN + nfail = nfail + 1 + WRITE (*, '(2A)') ' FAIL ', TRIM(label) + END SUBROUTINE check + +END PROGRAM test_static_current_balance diff --git a/tests/test_static_floor_note.py b/tests/test_static_floor_note.py new file mode 100644 index 00000000..69b1251a --- /dev/null +++ b/tests/test_static_floor_note.py @@ -0,0 +1,93 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Copyright (c) 2026 Jae Hoon Seo, SMI Lab, Inha University +"""The static residual-floor note names a residual above the tolerance it says was missed. + +A two-section finite-EI line restrained in torsion (pinned in bending at its fairlead, clamped +at its anchor, 9.7 deg of imposed twist) is polished at the tight static tolerance, which does +not converge, and again at the coupled static tolerance 1e-6, whose last Newton step lands at a +relative residual of 6.9e-9, below the tight 1e-8. The run printed "static residual +floor above the dynamic tolerance 1.00E-08; equilibrium accepted at the relative residual +6.91E-09". Every such note must report a residual above its tolerance, and this run none. + +usage: test_static_floor_note.py --exe --output

+""" + +from __future__ import annotations + +import argparse +import os +import re +import subprocess +import sys +from pathlib import Path + +DECK = """--------------------- CableDyn Input File ------------------------------------ +Two-section finite-EI line restrained in torsion +--------------------- LINE TYPES --------------------------------------- +TypeName Diam Mass EA BA EI GAs GJ Irt Irn Cd_n Cd_t Ca_n Ca_t +(-) (m) (kg/m) (N) (N-s) (N-m2) (-) (-) (-) (-) +t1 0.11958934169215762 24.223380558396716 819311396.4530731 -1.0 13696.958265809739 315119767.8665666 \ +15490.529253648816 0.021652084830305268 0.043304169660610535 1.2 0.01 1.0 0.0 +t2 0.2138970906163321 85.11251138269321 1087874573.7545362 -1.0 2845.9411357014956 418413297.5978985 \ +3005.149240256559 0.2433790421053965 0.486758084210793 1.2 0.01 1.0 0.0 +--------------------- POINTS ------------------------------------------- +ID Type X Y Z +(-) (-) (m) (m) (m) +1 Coupled -22.067725644878863 -43.46036418329759 -11.351640609291547 +2 Fixed 155.09096486699008 -43.46036418329759 -231.01460743349267 +--------------------- LINES -------------------------------------------- +ID NodeA NodeB Outputs +(-) (-) (-) (-) +1 1 2 - +--------------------- SECTIONS ----------------------------------------- +LineID LineType Length NumSegs +(-) (-) (m) (-) +1 t1 246.90435544324012 56 +1 t2 99.25397277211934 56 +--------------------- END CONNECTIONS ------------------------------- +LineID End Stiffness EzX EzY EzZ TorsStiffness NxX NxY NxZ Pretwist +(-) (-) (N-m/rad) (-) (-) (-) (N-m/rad) (-) (-) (-) (deg) +1 A Pinned 0.5000000000000001 0.0 -0.8660254037844386 Rigid 0.0 1.0 0.0 0.0 +1 B Rigid 1.0 0.0 0.0 Rigid 0.0 1.0 0.0 9.686369916584601 +--------------------- OPTIONS ------------------------------------------ +0.01 dtM +0.0 TMax +--------------------- OUTPUTS ------------------------------------------ +FairTen1 +Twist1 +--------------------- need this line ----------------------------------- +""".replace("\\\n", "") + +NOTE = re.compile(r"static residual floor above the dynamic tolerance\s+(\S+); equilibrium accepted at the " + r"relative residual\s+(\S+)\.") + + +def main() -> int: + ap = argparse.ArgumentParser() + ap.add_argument("--exe", required=True) + ap.add_argument("--output", required=True) + a = ap.parse_args() + out = Path(a.output) + out.mkdir(parents=True, exist_ok=True) + deck = out / "twisted.dat" + deck.write_text(DECK, encoding="utf-8", newline="\n") + env = dict(os.environ) + env.setdefault("OPENBLAS_NUM_THREADS", "1") + p = subprocess.run([a.exe, str(deck), str(out / "twisted")], capture_output=True, text=True, env=env, + cwd=str(out)) + log = p.stdout + p.stderr + failures = [] + if p.returncode != 0: + failures.append("exit %d: %s" % (p.returncode, log[-400:])) + for tol, res in NOTE.findall(log): + if float(res) <= float(tol): + failures.append("floor note with a residual %s at or below its tolerance %s" % (res, tol)) + print("static floor note: %d failures" % len(failures)) + for f in failures: + print("FAIL:", f) + return 1 if failures else 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tests/test_static_friction_as_laid.py b/tests/test_static_friction_as_laid.py index 2235fa52..fe743bbe 100644 --- a/tests/test_static_friction_as_laid.py +++ b/tests/test_static_friction_as_laid.py @@ -36,6 +36,13 @@ * ``att_cross`` (a finite-EI line with discrete buoyancy modules on a cross slope): the reference sinks each node under its discrete load, so the module nodes rest on the laid path (no lateral kink, as in the smeared twin) and a march from the static state stays at rest; +* ``shallow_cross`` (a 0.5 m finite-EI cable on a seabed 0.1 m deep, sloping across it): the + reference sinks each node under the load the solver applies there, the dry part of the section + that pierces the surface included, so the run rests on its laid path and a march from the + static state stays at rest; +* ``buoyant_shallow`` (a net-buoyant 0.5 m cable on a flat seabed 0.01 m deep, kBot = 1000): the + reference's dry load, whose full Newton step cycles between a wholly dry and a wholly wet node, + converges with halved steps, and a march from the static state stays at rest; * ``pl_*``: per-line rows win over the global ones (``layAzimuth`` over ``layAzimuth``, ``asLaidTension`` over ``asLaidTension``, in either order), and a row for line 2 leaves line 1 alone; ``aniso_*``: the axial coefficient rules the friction along a laid run; @@ -509,6 +516,73 @@ def kink(y: list) -> float: "att_cross: the module nodes rest on the laid path as closely as in the smeared twin (%.2e <= %.2e m)" % (kd, ks)) + # --- finite-EI cable laid on a shelf shallower than its radius, sloping across it --- + # A light 0.5 m cable rests on a seabed 0.1 m deep (5 degrees across the line): its section + # pierces the surface, and the static solve and the dynamics give back the buoyancy of the dry + # part, about 2.3 times its submerged weight. The friction reference sinks every node under + # that same normal load (the dry part at the node's sunk height), so the laid run rests on its + # laid path, y = 0. A reference sunk under the submerged weight alone would hold the run down + # the slope by the difference of the two sinks times tan(slope), about 0.8 mm, with a spurious + # friction force. Checked: the run's nodes stay within a tenth of that of the laid path + # (about 4e-6 m), and a march from the static state stays at rest. + cdir = root / "shallow_cross" + cdir.mkdir(parents=True, exist_ok=True) + rows = [] + for x in range(-300, 1000, 100): + for y in (-1.0, 1.0): + rows.append("%.1f %.1f %.12g" % (x, y, 0.1 + math.tan(math.radians(5.0)) * y)) + (cdir / "bathy.txt").write_text("\n".join(rows) + "\n", encoding="utf-8", newline="\n") + d_s, m_s = 0.5, 220.0 + w_s = (m_s - RHO * math.pi / 4.0 * d_s * d_s) * G + sc = dict(ei=1.0e4, length=100.0, nseg=50, fair=(100.0, 0.0, -0.095), anch=(0.0, 0.0, -0.1), seabed=sb, + types=f"chain {d_s} {m_s} 1.0e8 -1 1.0e4 1.2 0.008 1 0\n") + rc, log = run(a.exe, cdir, "shallow", deck("shallow cross", **sc)) + check(rc == 0, "shallow_cross converges (rc %d)%s" % (rc, "" if rc == 0 else ": " + log.strip()[-300:])) + if rc == 0: + p = first_row(cdir / "shallow.Line1.p.out") + # the run away from its two held ends, which rest at their deck positions above the + # sunk run and bend it within a few elements of them + y_run = [p[3 * i + 1] for i in range(5, len(p) // 3 - 5)] + # the sink of a node under its submerged weight and under its load with the dry part + kn_l = 1.0e5 * d_s + dry_load = w_s + for _ in range(100): + u = max(-1.0, min(1.0, (-0.1 - dry_load / kn_l) / (0.5 * d_s))) + phi = 1.0 - (math.acos(u) - u * math.sqrt(1.0 - u * u)) / math.pi + dry_load = w_s + phi * RHO * G * math.pi / 4.0 * d_s * d_s + spurious = (dry_load - w_s) / kn_l * math.tan(math.radians(5.0)) + dev = max(abs(y) for y in y_run) + check(dev < 0.1 * spurious, + "shallow_cross: the run rests on its laid path (%.2e m off it, a reference without the dry part " + "would hold it %.2e m off)" % (dev, spurious)) + rc, _ = run(a.exe, cdir, "shallow_rest", deck("shallow cross rest", **sc, tmax=1.0)) + check(rc == 0, "shallow_cross at-rest march runs (rc %d)" % rc) + if rc == 0: + drift = at_rest(cdir, "shallow", "shallow_rest") + check(drift <= REST_TOL, "shallow_cross stays at rest from the static state (drift %.2e)" % drift) + + # --- net-buoyant cable on a flat seabed shallower than its radius, soft seabed --- + # A 0.5 m cable of 180 kg/m floats (its displaced water is 201 kg/m), held on a seabed 0.01 m + # deep with kBot = 1000. A node held off the floor is wholly dry and one sunk under the dry + # load wholly wet, so the full Newton step of the reference's dry load jumps between about + # -208 and 728 N/m; the root (70.3 N/m, a sink of 0.14 m) lies between. Checked: the + # halved steps reach it, the static solve converges, and a march from it stays at rest. + cdir = root / "buoyant_shallow" + cdir.mkdir(parents=True, exist_ok=True) + rows = ["%.1f %.1f 0.01" % (x, y) for x in range(-300, 1000, 100) for y in (-300.0, 300.0)] + (cdir / "bathy.txt").write_text("\n".join(rows) + "\n", encoding="utf-8", newline="\n") + bs = dict(ei=1.0e4, length=100.0, nseg=50, fair=(100.0, 0.0, -0.005), anch=(0.0, 0.0, -0.01), seabed=sb, + types="chain 0.5 180.0 1.0e8 -1 1.0e4 1.2 0.008 1 0\n") + rc, log = run(a.exe, cdir, "buoyant", deck("buoyant shallow", **bs).replace("100000.0 kBot", "1000.0 kBot")) + check(rc == 0, "buoyant_shallow converges (rc %d)%s" % (rc, "" if rc == 0 else ": " + log.strip()[-300:])) + if rc == 0: + rc, _ = run(a.exe, cdir, "buoyant_rest", + deck("buoyant shallow rest", **bs, tmax=1.0).replace("100000.0 kBot", "1000.0 kBot")) + check(rc == 0, "buoyant_shallow at-rest march runs (rc %d)" % rc) + if rc == 0: + drift = at_rest(cdir, "buoyant", "buoyant_rest") + check(drift <= REST_TOL, "buoyant_shallow stays at rest from the static state (drift %.2e)" % drift) + # --- per-line rows, non-default azimuth and tension, anisotropic friction (EI = 0) --- cdir = root / "perline" keys = ("FairTen1", "AnchTen1", "Point1Fx", "Point2Fx", "Point1Fz") diff --git a/tests/test_static_init_sweep.f90 b/tests/test_static_init_sweep.f90 index 5f87ce90..1a31ad31 100644 --- a/tests/test_static_init_sweep.f90 +++ b/tests/test_static_init_sweep.f90 @@ -53,9 +53,10 @@ PROGRAM test_static_init_sweep !! concentrates an O(pi) turn at one node, curv*l0 ~ 2-3. This is the measurable !! version of "reached the smooth branch, not a kinked local equilibrium". !! (4) penetration consistent with the penalty: min z >= -d - (10 |w|_max / kn + 1 mm). - !! An expected-fail list records the known limitations (five 800 m low-EI lazy waves the - !! production initialisation does not solve); an XFAIL case that PASSES also fails the - !! gate, so a fix or a regression is seen. + !! An expected-fail list records the known limitations of this kernel from the trivial + !! seed (four low-EI lazy waves; the deck route solves them, see the list below); an + !! XFAIL case that PASSES is counted and reported, so a fix is seen, and a case off the + !! list that fails fails the gate. USE, INTRINSIC :: IEEE_ARITHMETIC, ONLY: IEEE_IS_FINITE USE CableDyn_Precision, ONLY: wp USE CableDyn_HermiteCableStatic, ONLY: CD_HermiteCable_Static_Solve_Sequenced, & @@ -167,15 +168,17 @@ PROGRAM test_static_init_sweep CALL add_case('g', MERGE(50.0_wp, 400.0_wp, i == 1), -2.0_wp, 1.5_wp, EA0, EI0, KN0, CHI0, FB0) END DO - ! ---- KNOWN-FAIL SET (measured on the full matrix sweep; parameter-matched - ! fail-closed: a matrix edit that orphans an entry is rejected. A solver improvement that - ! flips one to PASS is reported without failing the suite. The remaining cases either - ! exhaust the bounded hierarchy/recovery paths or reach a residual-converged one-element - ! hairpin that the production h*kappa safety gate rejects. Neither class can silently - ! enter dynamics. - ! Continuous whole-element curvature inspection exposes the unresolved hairpin in this - ! low-EI, 800 m fixed mesh. The former nodal metric incorrectly admitted it as smooth. - CALL mark_xfail('b', 800.0_wp, 1.25_wp, 1.5_wp, 5.0e7_wp, 5.0e2_wp, KN0, CHI0, FB0) ! [unresolved] + ! ---- KNOWN-FAIL SET (measured on the full matrix sweep with every OpenBLAS kernel; + ! parameter-matched fail-closed: a matrix edit that orphans an entry is rejected. A solver + ! improvement that flips one to PASS is reported without failing the suite. These four + ! low-EI lazy waves reach, from the trivial seed on this kernel alone, a residual-converged + ! kinked state (a Z of a few elements in mid-water) that the production h*kappa safety gate + ! rejects, so none can silently enter dynamics. A deck never takes this combination for a + ! line with a buoyant section: the deck route seeds it as a lazy wave, starts from the + ! EI = 0 catenary, and refines a kinked state locally. That route solves all four, and the + ! formerly listed 800 m EA = 5e7 N case, on both cable_statics routes, to within 2.4e-4 of + ! an independent EI = 0 catenary where the arch stays submerged: cable_statics_matrix gates + ! them (entries SIS_*). CALL mark_xfail('b', 800.0_wp, 1.25_wp, 1.5_wp, 2.0e9_wp, 5.0e2_wp, KN0, CHI0, FB0) ! [wad] CALL mark_xfail('b', 800.0_wp, 1.25_wp, 1.5_wp, EA0, 5.0e2_wp, KN0, CHI0, FB0) ! [unresolved] CALL mark_xfail('f', 800.0_wp, -1.0_wp, 2.5_wp, EA0, 5.0e2_wp, 3.0e6_wp, CHI0, FB0) ! [wad] diff --git a/tests/test_stiffener_section_equivalence.py b/tests/test_stiffener_section_equivalence.py new file mode 100644 index 00000000..d629f2f6 --- /dev/null +++ b/tests/test_stiffener_section_equivalence.py @@ -0,0 +1,203 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Copyright (c) 2026 Jae Hoon Seo, SMI Lab, Inha University +"""A cylindrical bend stiffener is a section of the combined cable and sleeve. + +The 80 m Gulf of Mexico lazy-wave cable (examples/lozon_gomex80_power_cable_motion.dat, bare +cable D 0.16 m, 36.7 kg/m, EI 1.99e4 N m^2) is clamped at its hang-off 5 deg off its static +tangent, so the root carries a moment, and driven 18 s by the 3 m, 12 s hang-off heave. Its first +2 m are sleeved in two ways: + +* a STIFFENERS row: a cylinder of 0.30 m outer diameter bored to the cable's 0.16 m, E 50 MPa, + 1150 kg/m^3, over the bare cable; +* a 2 m SECTIONS row of a line type with the section's own values, worked out here from the + manual's closed forms: EI = EI_c + E pi/64 (OD^4 - ID^4), mass m_c + rho_s pi/4 (OD^2 - ID^2) + and the displaced diameter sqrt(d^2 + OD^2 - ID^2) (= OD), the drag and added-mass + coefficients of the cable. + +Both decks mesh the 2 m in 20 elements. Gates, in the static start and over the march: the end +tensions, the hang-off angle, the position of a node in the sag bend and the curvature at nodes +under the sleeve and past it agree within 1e-6 of each channel's scale; the root moment of the +section, BendMom1N1 of the section deck, is the sum of the cable's share and the sleeve's, +BendMom1N1 + StfMom1N1 of the stiffener deck, and the cable's share is EI_c/EI of it. The bare +cable clamped the same way carries the static root moment of a tensioned beam whose end is +turned by the angle a, M = a sqrt(EI T) (its bending boundary layer, sqrt(EI/T) = 1.4 m long, +is short against the 180 m bend radius of the catenary), within 2 %; the sleeve must matter: +the static root moment of the section exceeds it by more than 25 %. + +usage: test_stiffener_section_equivalence.py --exe --examples --output +""" + +from __future__ import annotations + +import argparse +import math +import shutil +import subprocess +import sys +from pathlib import Path + +import numpy as np + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "python")) +from cabledyn import read_output # noqa: E402 + +FAILURES: list[str] = [] +RELATIVE = 1.0e-6 +D, MASS, EA, EI = 0.160, 36.70, 4.69e8, 1.99e4 +OD, ID, E_SLEEVE, RHO_SLEEVE, LENGTH = 0.30, 0.16, 5.0e7, 1150.0, 2.0 +EI_SECTION = EI + E_SLEEVE * math.pi / 64.0 * (OD**4 - ID**4) +MASS_SECTION = MASS + RHO_SLEEVE * math.pi / 4.0 * (OD**2 - ID**2) +D_SECTION = math.sqrt(D**2 + OD**2 - ID**2) +TILT = math.radians(5.0) + +DECK = """--------------------- CableDyn Input File ------------------------------------ +stiffener against an equivalent section +--------------------- LINE TYPES --------------------------------------------- +TypeName Diam MassDenInAir EA BA EI Cd_n Cd_t Ca_n Ca_t +(-) (m) (kg/m) (N) (-) (N-m2) (-) (-) (-) (-) +bare 0.160 36.70 4.69e8 0.0 1.99e4 1.2 0.1 1.0 0.0 +buoy 0.290 59.53 4.69e8 0.0 1.99e4 1.2 0.1 1.0 0.0 +sleeved {d_sec:.15g} {m_sec:.15g} 4.69e8 0.0 {ei_sec:.15g} 1.2 0.1 1.0 0.0 +--------------------- POINTS ------------------------------------------------ +ID Type X Y Z +(-) (-) (m) (m) (m) +1 Coupled 5.0 0.0 -14.0 +2 Fixed 125.0 0.0 -80.0 +--------------------- LINES ------------------------------------------------- +ID NodeA NodeB Outputs +(-) (-) (-) (-) +1 1 2 - +--------------------- SECTIONS ---------------------------------------------- +LineID LineType Length NumSegs +(-) (-) (m) (-) +1 {first} 2.0 20 +1 bare 66.114 33 +1 buoy 50.000 25 +1 bare 52.101 26 +{stiffener}--------------------- END CONNECTIONS --------------------------------------- +LineID End Stiffness EzX EzY EzZ +(-) (-) (N-m/rad) (-) (-) (-) +1 A Rigid {ex:.15g} 0.0 {ez:.15g} +--------------------- OPTIONS ----------------------------------------------- +9.80665 g +1025.0 rhoW +80.0 WtrDpth +1.0e5 kBot +1.0e4 cBot +0.05 dtM +18.0 TMax +gomex80_heave_3m_12s_dt005.txt motionFile +--------------------- OUTPUTS ----------------------------------------------- +{outputs} +--------------------- need this line ---------------------------------------- +""" +STIFFENER = """--------------------- STIFFENERS -------------------------------------------- +LineID End Length RootOD TipOD InnerD E Density +(-) (-) (m) (m) (m) (m) (Pa) (kg/m^3) +1 A 2.0 0.30 0.30 0.16 5.0e7 1150 +""" +SHARED = ("FairTen1", "AnchTen1", "FairIncl1", "L1N60px", "L1N60pz", "Curv1N11", "Curv1N30") + + +def check(ok: bool, message: str) -> None: + print(("PASS: " if ok else "FAIL: ") + message) + if not ok: + FAILURES.append(message) + + +def run( + exe: Path, motion: Path, folder: Path, first: str, stiffener: str, outputs: tuple[str, ...] +): + folder.mkdir(parents=True, exist_ok=True) + shutil.copy2(motion, folder / motion.name) + # the clamp turned 5 deg upward from the static hang-off tangent (81.6 deg below horizontal) + angle = math.atan2(0.98922, 0.14641) - TILT + text = DECK.format( + d_sec=D_SECTION, + m_sec=MASS_SECTION, + ei_sec=EI_SECTION, + first=f"{first:9s}", + stiffener=stiffener, + ex=math.cos(angle), + ez=-math.sin(angle), + outputs="\n".join(f'"{name}"' for name in outputs), + ) + deck = folder / "deck.dat" + deck.write_text(text, encoding="ascii", newline="\n") + result = subprocess.run( + [str(exe), deck.name, str(folder / "run")], + cwd=folder, + capture_output=True, + text=True, + check=False, + ) + if result.returncode != 0: + check(False, f"{folder.name}: driver exit {result.returncode}\n{result.stderr[-2000:]}") + return {} + history = read_output(folder / "run.out") + return {name: history.column(name) for name in outputs} + + +def main() -> int: + parser = argparse.ArgumentParser() + parser.add_argument("--exe", required=True, type=Path) + parser.add_argument("--examples", required=True, type=Path) + parser.add_argument("--output", required=True, type=Path) + args = parser.parse_args() + exe = args.exe.resolve() + out = args.output.resolve() + motion = args.examples.resolve() / "data" / "lozon" / "gomex80_heave_3m_12s_dt005.txt" + + sleeve = run( + exe, motion, out / "stiffener", "bare", STIFFENER, (*SHARED, "BendMom1N1", "StfMom1N1") + ) + section = run(exe, motion, out / "section", "sleeved", "", (*SHARED, "BendMom1N1")) + bare = run(exe, motion, out / "bare", "bare", "", ("BendMom1N1", "FairTen1")) + if not (sleeve and section and bare): + return 1 + + for name in SHARED: + a, b = sleeve[name], section[name] + scale = max(float(np.max(np.abs(b))), 1.0e-12) + start = abs(a[0] - b[0]) / scale + march = float(np.max(np.abs(a - b))) / scale + check( + max(start, march) <= RELATIVE, + f"{name}: the stiffener and the section agree (static {start:.2e}, march {march:.2e} " + f"of {scale:.4g}, limit {RELATIVE:g})", + ) + + root = section["BendMom1N1"] + scale = float(np.max(np.abs(root))) + total = sleeve["BendMom1N1"] + sleeve["StfMom1N1"] + worst = float(np.max(np.abs(total - root))) / scale + check( + worst <= RELATIVE, + f"root moment: cable + sleeve shares are the section's moment ({worst:.2e} of {scale:.4g} N m)", + ) + share = float(np.max(np.abs(sleeve["BendMom1N1"] - EI / EI_SECTION * root))) / scale + check( + share <= RELATIVE, + f"root moment: the cable's share is EI_c/EI = {EI / EI_SECTION:.4f} of it ({share:.2e})", + ) + # the bare clamp: a tensioned beam turned by TILT at its end, M = TILT sqrt(EI T) + bare_root = float(bare["BendMom1N1"][0]) + expected = TILT * math.sqrt(EI * float(bare["FairTen1"][0])) + check( + abs(bare_root / expected - 1.0) < 0.02, + f"bare clamp: static root moment {bare_root:.5g} N m is TILT sqrt(EI T) = {expected:.5g}", + ) + check( + root[0] > 1.25 * bare_root, + f"the sleeve stiffens the root: static moment {root[0]:.5g} against {bare_root:.5g} N m", + ) + if FAILURES: + print(f"\n{len(FAILURES)} check(s) failed") + return 1 + print("\nall checks passed") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tests/test_syrope_taut_rest.py b/tests/test_syrope_taut_rest.py new file mode 100644 index 00000000..d26e8001 --- /dev/null +++ b/tests/test_syrope_taut_rest.py @@ -0,0 +1,131 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Copyright (c) 2026 Jae Hoon Seo, SMI Lab, Inha University +"""A taut single-section Syrope rope whose tension varies along it starts at rest. + +Three deep, inclined polyester ropes (481, 850 and 991 m, 330 to 750 m of water) carry their +weight, so the tension falls by up to 15 % from fairlead to anchor. The static start took one +secant EA from the working curve at the rope's mean strain: the elements away from the mean +started off their curve and their slow strains settled the rope at rest (the fairlead tension +moved by 1.2e-4 to 6.1e-4 in 1 s). Each rope, held at rest for 1 s, must keep its end tensions +at their static values to 1e-6. + +usage: test_syrope_taut_rest.py --exe --output +""" + +from __future__ import annotations + +import argparse +import os +import subprocess +import sys +from pathlib import Path + +SETTINGS = """syrope_owc.dat OWC +EXP WCType +0.20 k1 +1.50 k2 +""" + +DECK = """--------------------- CableDyn Input File ------------------------------------ +Taut polyester rope in deep water, held at rest +--------------------- LINE TYPES --------------------------------------- +TypeName Diam Mass EA BA EI Cd_n Cd_t Ca_n Ca_t +(-) (m) (kg/m) (N) (N-s) (N-m2) (-) (-) (-) (-) +rope 0.1438 26.8406 SYROPE:syrope_settings.dat|{alpha}|{beta} {bas}|{bad} 0.0 1.2 0.2 1.0 0.0 +--------------------- POINTS ------------------------------------------- +ID Type X Y Z +(-) (-) (m) (m) (m) +1 Coupled {a} +2 Fixed {b} +--------------------- LINES -------------------------------------------- +ID NodeA NodeB Outputs +(-) (-) (-) (-) +1 1 2 - +--------------------- SECTIONS ----------------------------------------- +LineID LineType Length NumSegs +(-) (-) (m) (-) +1 rope {length} {n} +--------------------- OPTIONS ------------------------------------------ +{depth} WtrDpth +{kbot} kBot +0.01 dtM +1.0 TMax +--------------------- OUTPUTS ------------------------------------------ +FairTen1 +AnchTen1 +--------------------- need this line ----------------------------------- +""" + +ROPES = [ + dict(alpha="1.83494e8", beta="15.9308", bas="2.28256e10", bad="4.81630e5", a="6.0913 -27.1467 -4.6733", + b="185.5774 -660.5800 -751.7888", length="990.9851", n=20, depth="751.7888", kbot="1.829e5"), + dict(alpha="1.89709e8", beta="16.1960", bas="1.31046e9", bad="7.86974e5", a="-6.0871 -36.8963 -4.5814", + b="-360.0368 -124.1505 -328.1981", length="481.3015", n=10, depth="328.1981", kbot="4.494e5"), + dict(alpha="2.67068e8", beta="15.9927", bas="1.06925e10", bad="2.82844e5", a="14.7149 -33.3903 -4.1781", + b="-60.8938 -595.2920 -643.3068", length="849.5532", n=13, depth="643.3068", kbot="1.616e5"), +] + + +# A short vertical rope on a strongly concave curve, T = 1e6 eps^0.4: its secant lies far above +# its tangent, so the per-element tension update overshoots the curve's crossing and reverses +# (it cycled between about 108 and 560 kN and the statics failed); the reversed updates take +# the secant step, and the rope must start at rest in its weight's equilibrium. +CONCAVE = dict(alpha="1.0e8", beta="15.9308", bas="2.28256e10", bad="4.81630e5", a="0.0 0.0 -29.6", + b="0.0 0.0 -50.0", length="20.0", n=2, depth="50.0", kbot="1.0e5") + + +def concave_table() -> str: + rows = ["Strain Tension", "(-) (N)"] + for k in range(61): + rows.append("%r %r" % (0.001 * k, 1.0e6 * (0.001 * k) ** 0.4)) + return "\n".join(rows) + "\n" + + +def owc_table() -> str: + rows = ["Strain Tension", "(-) (N)"] + for k in range(30): + rows.append("%r %r" % (0.00206897 * k, 1.71768e5 * k * (1.0 - 0.012 * k))) + return "\n".join(rows) + "\n" + + +def main() -> int: + ap = argparse.ArgumentParser() + ap.add_argument("--exe", required=True) + ap.add_argument("--output", required=True) + a = ap.parse_args() + out = Path(a.output) + out.mkdir(parents=True, exist_ok=True) + (out / "syrope_settings.dat").write_text(SETTINGS, encoding="utf-8", newline="\n") + (out / "syrope_owc.dat").write_text(owc_table(), encoding="utf-8", newline="\n") + (out / "syrope_settings_concave.dat").write_text(SETTINGS.replace("syrope_owc.dat", "syrope_owc_concave.dat"), + encoding="utf-8", newline="\n") + (out / "syrope_owc_concave.dat").write_text(concave_table(), encoding="utf-8", newline="\n") + env = dict(os.environ) + env.setdefault("OPENBLAS_NUM_THREADS", "1") + failures = [] + cases = [("rope_%d" % k, DECK.format(**rope)) for k, rope in enumerate(ROPES)] + cases.append(("rope_concave", DECK.format(**CONCAVE).replace("syrope_settings.dat", "syrope_settings_concave.dat"))) + for name, text in cases: + deck = out / (name + ".dat") + deck.write_text(text, encoding="utf-8", newline="\n") + root = out / name + p = subprocess.run([a.exe, str(deck), str(root)], capture_output=True, text=True, env=env, cwd=str(out)) + if p.returncode != 0: + failures.append("%s: exit %d: %s" % (name, p.returncode, (p.stdout + p.stderr)[-300:])) + continue + rows = Path(str(root) + ".out").read_text(encoding="utf-8").splitlines() + vals = [[float(v) for v in r.split()] for r in rows[2:] if r.strip()] + for j, ch in ((1, "FairTen1"), (2, "AnchTen1")): + t0 = vals[0][j] + drift = max(abs(v[j] - t0) for v in vals) / abs(t0) + if drift > 1.0e-6: + failures.append("%s: %s drifts by %.3e of its static value" % (name, ch, drift)) + print("taut Syrope ropes at rest: %d ropes, %d failures" % (len(cases), len(failures))) + for f in failures: + print("FAIL:", f) + return 1 if failures else 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tests/test_validation_records.py b/tests/test_validation_records.py index b4085527..967c0cb5 100644 --- a/tests/test_validation_records.py +++ b/tests/test_validation_records.py @@ -177,24 +177,51 @@ def test_bergdahl_refinement_and_waveforms(self) -> None: def test_performance_summary_matches_machine_readable_record(self) -> None: directory = VALIDATION / "performance" rows = load_csv(directory / "performance_summary.csv") + others = load_csv(directory / "wallclock_summary.csv") record = load_json(directory / "performance_metrics.json") - self.assertEqual(len(rows), 9) - self.assertEqual(len(record["rows"]), 9) - lookup = {(row["site"], row["solver"]): row for row in rows} + # L5-DPC: three spans, CableDyn with the GNU development build and the IFX release driver, + # OrcaFlex and MoorDyn-F. + cabledyn_builds = {row["build"] for row in rows if row["solver"] == "CableDyn"} + self.assertEqual(len(cabledyn_builds), 2) + expected = {(site, "CableDyn", build) for site in ("80m", "200m", "800m") for build in cabledyn_builds} + expected |= {(site, solver, solver.lower()) for site in ("80m", "200m", "800m") + for solver in ("OrcaFlex", "MoorDyn-F")} + lookup = {(row["site"], row["solver"], row["build"]): row for row in rows} + self.assertEqual(len(lookup), len(rows)) + self.assertEqual(set(lookup), expected) + self.assertEqual({row["case"] for row in rows}, {"L5-DPC"}) + # L5-V (CableDyn builds and OrcaFlex) and L5-wc (CableDyn builds and MoorDyn-C). + other_lookup = {(row["case"], row["solver"], row["build"]): row for row in others} + self.assertEqual(len(other_lookup), len(others)) self.assertEqual( - set(lookup), - {(site, solver) for site in ("80m", "200m", "800m") for solver in ("CableDyn", "OrcaFlex", "MoorDyn-F")}, + set(other_lookup), + {(case, "CableDyn", build) for case in ("L5-V", "L5-wc") for build in cabledyn_builds} + | {("L5-V", "OrcaFlex", "orcaflex"), ("L5-wc", "MoorDyn-C", "moordyn-c")}, ) - records = {(row["site"], row["solver"]): row for row in record["rows"]} - self.assertEqual(set(records), set(lookup)) - for key, row in lookup.items(): - median = float(row["total_wall_median_s"]) - self.assertLessEqual(float(row["total_wall_min_s"]), median) - self.assertGreaterEqual(float(row["total_wall_max_s"]), median) - assert_close(self, median, records[key]["total_wall_median_s"]) + for table, key_fields, json_rows in ( + (lookup, ("site", "solver", "build"), record["rows"]), + (other_lookup, ("case", "solver", "build"), record["wallclock_rows"]), + ): + records = {tuple(row[field] for field in key_fields): row for row in json_rows} + self.assertEqual(set(records), set(table)) + for key, row in table.items(): + median = float(row["total_wall_median_s"]) + self.assertLessEqual(float(row["total_wall_min_s"]), median) + self.assertGreaterEqual(float(row["total_wall_max_s"]), median) + assert_close(self, median, records[key]["total_wall_median_s"]) + self.assertIn(row["build"], record["codes"]) + for key, row in list(lookup.items()) + list(other_lookup.items()): + if row["solver"] == "CableDyn" and row["subdivided_intervals"]: + self.assertEqual(int(row["subdivided_intervals"]), 0, key) for site in ("80m", "200m", "800m"): - self.assertEqual(int(lookup[(site, "CableDyn")]["subdivided_intervals"]), 0) + for build in cabledyn_builds: + self.assertEqual(int(lookup[(site, "CableDyn", build)]["subdivided_intervals"]), 0) + # The refined MoorDyn-F step is the largest whose halving moves the scored responses < 0.01 %. + checks = record["moordyn_f_step_checks"] + self.assertEqual(len(checks), 3) + for check in checks.values(): + self.assertLess(check["largest_relative_move"], 1.0e-4) if __name__ == "__main__": diff --git a/tests/test_viv_coupled.f90 b/tests/test_viv_coupled.f90 index 9272a1bd..fd9aa2a6 100644 --- a/tests/test_viv_coupled.f90 +++ b/tests/test_viv_coupled.f90 @@ -175,14 +175,21 @@ SUBROUTINE case_seed() INTEGER :: k, pass, nn ! four mesh elements (internal order, End B first) over two deck segments: deck nodes at public ! nodes 1, 3 and 5, so public node 4 lies 3/4 of the way along the second deck segment + ! MoorDyn's i/N from the deck's End A; a line kept in the deck order adds half a turn, as the + ! model's tangent runs against MoorDyn's there (End B to End A) CALL CD_Deck_VIV_Phase_Seed([1.0_wp, 3.0_wp, 2.0_wp, 2.0_wp], .FALSE., seed, deck_map=[1, 3, 5]) want = [1.0_wp, 0.875_wp, 0.5_wp, 0.25_wp, 0.0_wp] - CALL check(MAXVAL(ABS(seed - want)) < 1.0e-14_wp, 'refined mesh: deck nodes keep i/N, added nodes interpolate') + CALL check(MAXVAL(ABS(seed - MODULO(want + 0.5_wp, 1.0_wp))) < 1.0e-14_wp, & + 'refined mesh: deck nodes keep i/N, added nodes interpolate') CALL CD_Deck_VIV_Phase_Seed([1.0_wp, 3.0_wp, 2.0_wp, 2.0_wp], .TRUE., seed, deck_map=[1, 3, 5]) CALL check(MAXVAL(ABS(seed - (1.0_wp - want))) < 1.0e-14_wp, 'a turned-around line counts from its End B') CALL CD_Deck_VIV_Phase_Seed([1.0_wp, 3.0_wp, 2.0_wp, 2.0_wp], .FALSE., seed) - CALL check(MAXVAL(ABS(seed - [4.0_wp, 3.0_wp, 2.0_wp, 1.0_wp, 0.0_wp]/4.0_wp)) < 1.0e-14_wp, & + CALL check(MAXVAL(ABS(seed - [0.5_wp, 0.25_wp, 0.0_wp, 0.75_wp, 0.5_wp])) < 1.0e-14_wp, & 'the deck mesh keeps the node index') + CALL CD_Deck_VIV_Phase_Seed([1.0_wp, 3.0_wp, 2.0_wp, 2.0_wp], .FALSE., seed, zero=.TRUE.) + CALL check(MAXVAL(ABS(seed - 0.5_wp)) < 1.0e-14_wp, 'zero: every phase at 0 in MoorDyn''s frame') + CALL CD_Deck_VIV_Phase_Seed([1.0_wp, 3.0_wp, 2.0_wp, 2.0_wp], .TRUE., seed, zero=.TRUE.) + CALL check(MAXVAL(ABS(seed)) < 1.0e-14_wp, 'zero on a turned-around line') CALL write_deck('viv_coupled_stock.dat', 0.8_wp, anchor_first=.TRUE.) DO pass = 1, 2 IF (.NOT. start(agg, MERGE('viv_coupled.dat ', 'viv_coupled_stock.dat', pass == 1))) RETURN @@ -191,12 +198,17 @@ SUBROUTINE case_seed() worst_cable = 0.0_wp DO k = 2, nn - 1 ! internal node k (k = 1 at the anchor); MoorDyn's node from the deck's End A + ! (half a turn on where the reader keeps the deck order: the model's tangent runs against + ! MoorDyn's there) IF (pass == 1) THEN - worst_line = MAX(worst_line, ABS(agg%sys%fast%system%lines(1)%viv_phi(k) - TWO_PI*REAL(nn - k, wp)/50.0_wp)) - worst_cable = MAX(worst_cable, ABS(agg%cables(1)%line%viv_phi(k) - TWO_PI*REAL(nn - k, wp)/50.0_wp)) + worst_line = MAX(worst_line, turn_gap(agg%sys%fast%system%lines(1)%viv_phi(k), & + TWO_PI*(REAL(nn - k, wp)/50.0_wp + 0.5_wp))) + worst_cable = MAX(worst_cable, turn_gap(agg%cables(1)%line%viv_phi(k), & + TWO_PI*(REAL(nn - k, wp)/50.0_wp + 0.5_wp))) ELSE - worst_line = MAX(worst_line, ABS(agg%sys%fast%system%lines(1)%viv_phi(k) - TWO_PI*REAL(k - 1, wp)/50.0_wp)) - worst_cable = MAX(worst_cable, ABS(agg%cables(1)%line%viv_phi(k) - TWO_PI*REAL(k - 1, wp)/50.0_wp)) + worst_line = MAX(worst_line, turn_gap(agg%sys%fast%system%lines(1)%viv_phi(k), & + TWO_PI*REAL(k - 1, wp)/50.0_wp)) + worst_cable = MAX(worst_cable, turn_gap(agg%cables(1)%line%viv_phi(k), TWO_PI*REAL(k - 1, wp)/50.0_wp)) END IF END DO CALL check(worst_line < 1.0e-12_wp .AND. worst_cable < 1.0e-12_wp, & @@ -206,6 +218,14 @@ SUBROUTINE case_seed() END DO END SUBROUTINE case_seed + PURE REAL(wp) FUNCTION turn_gap(a, b) RESULT(gap) + !! Distance of two phases on the circle (rad). + REAL(wp), INTENT(IN) :: a, b + REAL(wp), PARAMETER :: TWO_PI = 8.0_wp*ATAN(1.0_wp) + gap = MODULO(a - b, TWO_PI) + gap = MIN(gap, TWO_PI - gap) + END FUNCTION turn_gap + LOGICAL FUNCTION start(agg, path) RESULT(ok) !! A host-fluid build of the deck at dt. TYPE(CD_AGG_ModuleType), INTENT(INOUT) :: agg diff --git a/tests/test_viv_lockin.py b/tests/test_viv_lockin.py index 7c9fa788..10cab73b 100644 --- a/tests/test_viv_lockin.py +++ b/tests/test_viv_lockin.py @@ -31,7 +31,15 @@ the same first-mode frequency and shape: at U 0.21 m/s both lock into mode 1 with the same mid-span A/D (within 3 %) and frequency; at U 0.30 m/s the string jumps to mode 2 (mid-span A/D below 0.15) while the cable, whose bending raises f2/f1 to about 3.15, stays in mode 1 - (mid-span A/D above 0.6). + (mid-span A/D above 0.6); +* at U 0.24 m/s, where two lock-in branches coexist, a start from rest with the spread seed settles + in mode 2 as MoorDyn-C v2.7.2 does (x/L 0.24 A/D within 3 % of its 0.574, frequency within one + bin of 0.527 Hz), and VIVphaseSeed zero in mode 1 as MoorDyn-F in OpenFAST v5.0.0 (whose phases + start at zero) does (mid-span A/D within 1 % of its 0.699, frequency within one bin of 0.353 Hz); +* the lift at t = 0, 2 m from the deck's End A, has MoorDyn's direction and size on an EI = 0 line + and a finite-EI cable, whether the deck writes the line fairlead first or anchor first, and the + mid-span response over 60 s is the same on both orders (within 1e-5 m: a node at rest takes + MoorDyn's cross-flow phase in the line's own frame). usage: test_viv_lockin.py --exe --output """ @@ -54,6 +62,10 @@ FAILURES: list[str] = [] MD_AD, MD_F = 0.662, 0.293 # MoorDyn-F reference, mid span +# U 0.24 m/s, where two lock-in branches coexist (VALIDATION.md L2-VIV): MoorDyn-C v2.7.2 (seeded +# phases, RK2, dtM 5e-4 s) settles on mode 2 (quarter span x/L = 0.24: A/D 0.574 at 0.527 Hz); +# MoorDyn-F v2.3.8 (OpenFAST v5.0.0, phases from zero) on mode 1 (mid span: 0.699 at 0.353 Hz) +MDC_Q24, MDC_F24, MDF_M24, MDF_F24 = 0.574, 0.527, 0.699, 0.353 D = 0.1 @@ -151,24 +163,48 @@ def lift_std(path: Path) -> np.ndarray: return data[:, cols].std(axis=0) -def response(path: Path) -> tuple[float, float, float]: - """Mid A/D, mid peak frequency, quarter A/D over 60-120 s.""" +def response(path: Path, mid_name: str = "L1N25PZ", qtr_name: str = "L1N12PZ", + peak_of: str = "mid") -> tuple[float, float, float]: + """Mid A/D, peak frequency (of the mid or the quarter channel), quarter A/D over 60-120 s.""" hist = read_output(path) t = hist.column(hist.channels[0]) mask = t >= 60.0 - mid = hist.column("L1N25PZ")[mask] - qtr = hist.column("L1N12PZ")[mask] + mid = hist.column(mid_name)[mask] + qtr = hist.column(qtr_name)[mask] mid = mid - mid.mean() + qtr = qtr - qtr.mean() + sig = mid if peak_of == "mid" else qtr dt = float(np.median(np.diff(t[mask]))) - freq = np.fft.rfftfreq(mid.size, dt) - power = np.abs(np.fft.rfft(mid * np.hanning(mid.size))) + freq = np.fft.rfftfreq(sig.size, dt) + power = np.abs(np.fft.rfft(sig * np.hanning(sig.size))) return ( math.sqrt(2.0) * float(mid.std()) / D, float(freq[1:][np.argmax(power[1:])]), - math.sqrt(2.0) * float((qtr - qtr.mean()).std()) / D, + math.sqrt(2.0) * float(qtr.std()) / D, ) +def anchor_first(text: str) -> str: + """The deck with End A on the fixed point at x = 0 and End B on the coupled point at x = 100 m: + the same line, which the reader turns around (it runs from its fairlead).""" + a, b = "1 Coupled 0.0 0.0 -50.0", "2 Fixed 100.0 0.0 -50.0" + assert a in text and b in text + return text.replace(a, "1 Fixed 0.0 0.0 -50.0").replace(b, "2 Coupled 100.0 0.0 -50.0") + + +def first_lift(path: Path, x: float, from_end_b: bool) -> float: + """Cross-flow (z) lift at t = 0 at the node nearest x of a V file (public node order).""" + lines = path.read_text().splitlines() + head = next(i for i, line in enumerate(lines) if line.startswith("Time")) + names = lines[head].split("\t") + row = np.array([float(v) for v in lines[head + 1].split()]) + cols = [j for j, name in enumerate(names) if name.endswith("LiftZ(N)")] + xs = np.linspace(0.0, 100.0, len(cols)) + if from_end_b: + xs = xs[::-1] + return float(row[cols[int(np.argmin(np.abs(xs - x)))]]) + + def main() -> int: ap = argparse.ArgumentParser() ap.add_argument("--exe", required=True) @@ -178,7 +214,7 @@ def main() -> int: if out.exists(): shutil.rmtree(out) out.mkdir(parents=True) - for u in (0.15, 0.21, 0.30): + for u in (0.15, 0.21, 0.24, 0.30): (out / f"current_{u}.dat").write_text(CURRENT.format(u=u), encoding="utf-8", newline="\n") # the stiff cable and its equal-frequency string (neutrally buoyant: no sag stiffening) beta = math.pi**2 * 5.0e7 / (5.0e4 * 100.0**2) @@ -195,6 +231,23 @@ def main() -> int: for u in (0.21, 0.30): runs.append((("stiff", u), f"viv_stiff_u{u}", deck(0.01, waterkin=f"current_{u}.dat", **stiff))) runs.append((("string", u), f"viv_string_u{u}", deck(0.01, waterkin=f"current_{u}.dat", **string))) + # the two-branch band at U 0.24 m/s, probed at MoorDyn's mid (deck node 25: N26 here) and + # x/L = 0.24 (node 12: N13): the spread seed, and VIVphaseSeed zero + band = deck(0.01, waterkin="current_0.24.dat").replace("L1N25PZ\nL1N12PZ", "L1N26PZ\nL1N13PZ") + runs.append(("band", "viv_band_u0.24", band)) + runs.append(("band_zero", "viv_band_u0.24_zero", + band.replace("0.25 VIVrmsWindow", "0.25 VIVrmsWindow\nzero VIVphaseSeed"))) + # the lift at t = 0 has MoorDyn's direction whichever end the deck writes first + for ei, tag in ((0.0, "ei0"), (1.0, "fei")): + start = deck(0.01, ei=ei, waterkin="current_0.24.dat", outputs="V").replace("120.0 TMax", + "0.02 TMax") + runs.append((("t0", tag, False), f"viv_t0_{tag}", start)) + runs.append((("t0", tag, True), f"viv_t0_{tag}_anchor_first", anchor_first(start))) + # and the whole response is the same: 60 s at U 0.24 m/s, mid span, either deck order + order = deck(0.01, ei=ei, waterkin="current_0.24.dat").replace( + "L1N25PZ\nL1N12PZ", "L1N26PZ\nL1N13PZ").replace("120.0 TMax", "60.0 TMax") + runs.append((("order", tag, False), f"viv_order_{tag}", order)) + runs.append((("order", tag, True), f"viv_order_{tag}_anchor_first", anchor_first(order))) for _, name, text in runs: (out / f"{name}.dat").write_text(text, encoding="utf-8", newline="\n") env = dict(os.environ, OMP_NUM_THREADS="1") @@ -212,7 +265,16 @@ def run(name: str) -> subprocess.CompletedProcess[str]: print(proc.stdout[-2000:], proc.stderr[-2000:]) check(False, f"{name}: the run completes (exit {proc.returncode})") continue - results[key] = response(out / f"{name}.out") + if isinstance(key, tuple) and key[0] == "t0": + results[key] = first_lift(out / f"{name}.Line1.V.out", 2.0, key[2]) + elif isinstance(key, tuple) and key[0] == "order": + hist = read_output(out / f"{name}.out") + results[key] = hist.column("L1N26PZ") + elif key in ("band", "band_zero"): + results[key] = response(out / f"{name}.out", "L1N26PZ", "L1N13PZ", + "qtr" if key == "band" else "mid") + else: + results[key] = response(out / f"{name}.out") if 0.01 in results: ad, f, qtr = results[0.01] check(abs(ad - MD_AD) <= 0.03 * MD_AD, @@ -267,6 +329,29 @@ def run(name: str) -> subprocess.CompletedProcess[str]: check(a1 > 0.6 and a0 < 0.15, f"U 0.30 m/s: stiff cable stays in mode 1 (mid-span A/D {a1:.3f}), the string jumps to " f"mode 2 (mid-span A/D {a0:.3f})") + if "band" in results: + mid, f, qtr = results["band"] + check(abs(qtr - MDC_Q24) <= 0.03 * MDC_Q24 and abs(f - MDC_F24) <= 1.0 / 60.0 and mid < 0.1, + f"U 0.24 m/s, seeded phases: mode 2, x/L 0.24 A/D {qtr:.3f} at {f:.3f} Hz, mid span {mid:.3f}; " + f"MoorDyn-C {MDC_Q24} at {MDC_F24} Hz (within 3 % and one bin)") + if "band_zero" in results: + mid, f, _ = results["band_zero"] + check(abs(mid - MDF_M24) <= 0.01 * MDF_M24 and abs(f - MDF_F24) <= 1.0 / 60.0, + f"U 0.24 m/s, VIVphaseSeed zero: mode 1, mid-span A/D {mid:.3f} at {f:.3f} Hz; MoorDyn-F " + f"{MDF_M24} at {MDF_F24} Hz (within 1 % and one bin)") + for tag, what in (("ei0", "EI = 0 line"), ("fei", "finite-EI cable")): + a, b = results.get(("t0", tag, False)), results.get(("t0", tag, True)) + if a is not None and b is not None: + check(a > 4.0 and abs(b - a) <= 1.0e-9 * abs(a), + f"{what}: lift at t = 0, 2 m from the deck's End A, {a:+.4f} N fairlead first and " + f"{b:+.4f} N anchor first (MoorDyn's +z, the same on both)") + for tag, what in (("ei0", "EI = 0 line"), ("fei", "finite-EI cable")): + a, b = results.get(("order", tag, False)), results.get(("order", tag, True)) + if a is not None and b is not None and a.size == b.size: + gap = float(np.max(np.abs(a - b))) + check(gap <= 1.0e-5, + f"{what}: mid-span response over 60 s at U 0.24 m/s, fairlead first against anchor first, " + f"within {gap:.1e} m (1e-5 m; amplitude about 1.6e-2 m)") print(f"{len(FAILURES)} failure(s)") return 1 if FAILURES else 0 diff --git a/tests/test_wave_input_equivalence.py b/tests/test_wave_input_equivalence.py new file mode 100644 index 00000000..9d44c333 --- /dev/null +++ b/tests/test_wave_input_equivalence.py @@ -0,0 +1,252 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +# Copyright (c) 2026 Jae Hoon Seo, SMI Lab, Inha University +"""One linear sea through three deck inputs: the line responds the same to each. + +The studless chain of examples/dynamic_chain_waves.dat (410 m in 50 m), its fairlead held 5 m +below the still-water level, runs 40 s in the same sea written three ways, each read by its own +code path. (A node held at the waterline takes no kinematics while the surface is below it, so +its load switches with the sign of the elevation's last bit where a zero crossing falls on a +step: the representations then part by that switch.) + +* the deck's own wave rows: ``airy H T dir waves``, or ``airy H T dir wavetrain`` rows for a sum, + eta = (H/2) cos(k (x cos b + y sin b) - omega t); +* MoorDyn-C ``WaveKin 7``, ``wave_frequencies.txt`` rows ``omega Re Im beta``, each the component + |c| sin(omega t - k d + arg c): the same wave is the row ``omega 0 H/2 b`` (c = i H/2); +* MoorDyn-C ``WaveKin 3``, the elevation record ``wave_elevation.txt`` at the origin, + eta(t) = sum (H/2) cos(omega t), 200 s at dtWave 0.1 s: a whole number of periods of every + component, so its Fourier reduction gives the components back exactly (waves along +X only). + +Cases: a regular 2 m, 10 s wave along +X; a sum of 2 m at 10 s and 1 m at 8 s along +X; the +2 m, 10 s wave travelling at 30 deg to the line (the deck direction in degrees, MoorDyn-C's beta in +radians). Gates: every pair of inputs gives the same fairlead and anchor tensions and the same +node motion over the run, within 1e-6 of each channel's range (the record's Fourier reduction is +exact to round-off). The waves must load the line: each tension moves by more than 1 kN. A sign +error of the phase or the direction, a wrong amplitude convention or a lost component would put +the runs apart by the size of the response, and the gates can see it: the WaveKin 7 wave a +quarter period out of phase (c = H/2), and the oblique wave turned to +X, part from the deck +wave by more than 10 % of a tension range. + +usage: test_wave_input_equivalence.py --exe --output +""" + +from __future__ import annotations + +import argparse +import math +import subprocess +import sys +from pathlib import Path + +import numpy as np + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "python")) +from cabledyn import read_output # noqa: E402 + +FAILURES: list[str] = [] +CHANNELS = ("FairTen1", "AnchTen1", "L1N6px", "L1N6pz", "L1N6py") +RELATIVE = 1.0e-6 + +DECK = """--------------------- CableDyn Input File ------------------------------------ +wave input equivalence: held chain in one linear sea +--------------------- LINE TYPES --------------------------------------- +TypeName Diam MassDenInAir EA BA/-zeta EI Cd_n Cd_t Ca_n Ca_t +(-) (m) (kg/m) (N) (N-s/-) (N-m^2) (-) (-) (-) (-) +chain 0.252 390.0 1.674e9 -1.0 0.0 1.37 0.64 1.0 0.0 +--------------------- POINTS ------------------------------------------- +ID Type X Y Z Mass Vol CdA Ca +(-) (-) (m) (m) (m) (kg) (m^3) (m^2) (-) +1 Fixed 400.0 0.0 -50.0 0 0 0 0 +2 Coupled 0.0 0.0 -5.0 0 0 0 0 +--------------------- LINES -------------------------------------------- +ID NodeA NodeB Outputs +(-) (-) (-) (-) +1 2 1 - +--------------------- SECTIONS ----------------------------------------- +LineID LineType Length NumSegs +(-) (-) (m) (-) +1 chain 410.0 41 +--------------------- OPTIONS ------------------------------------------ +9.80665 g +1025.0 rhoW +50.0 WtrDpth +1.0e5 kBot +1.0e4 cBot +0.05 dtM +40.0 TMax +{options} +--------------------- OUTPUTS ------------------------------------------ +{outputs} +--------------------- need this line ----------------------------------- +""" + + +def check(ok: bool, message: str) -> None: + print(("PASS: " if ok else "FAIL: ") + message) + if not ok: + FAILURES.append(message) + + +def run(exe: Path, folder: Path, options: str, files: dict[str, str]) -> dict[str, np.ndarray]: + """Run the deck with ``options`` and the kinematics ``files`` in ``folder``.""" + folder.mkdir(parents=True, exist_ok=True) + for name, text in files.items(): + (folder / name).write_text(text, encoding="ascii", newline="\n") + deck = folder / "deck.dat" + text = DECK.format(options=options, outputs="\n".join(f'"{c}"' for c in CHANNELS)) + deck.write_text(text, encoding="ascii", newline="\n") + result = subprocess.run( + [str(exe), deck.name, str(folder / "run")], + cwd=folder, + capture_output=True, + text=True, + check=False, + ) + if result.returncode != 0: + check(False, f"{folder.name}: driver exit {result.returncode}\n{result.stderr[-2000:]}") + return {} + history = read_output(folder / "run.out") + return {name: history.column(name) for name in CHANNELS} + + +def frequencies_file(components: list[tuple[float, float, float]]) -> str: + """WaveKin 7 rows for components (H, T, direction in deg): the omega = 0 row first.""" + rows = ["0.0 0.0 0.0 0.0"] + for height, period, direction in sorted(components, key=lambda c: c[1], reverse=True): + omega = 2.0 * math.pi / period + rows.append(f"{omega:.15g} 0.0 {0.5 * height:.15g} {math.radians(direction):.15g}") + return "\n".join(rows) + "\n" + + +def elevation_file(components: list[tuple[float, float, float]]) -> str: + """WaveKin 3 record at the origin: 2001 rows, 0 to 200 s at 0.1 s (waves along +X).""" + rows = [] + for index in range(2001): + t = 0.1 * index + eta = sum(0.5 * h * math.cos(2.0 * math.pi * t / p) for h, p, _d in components) + rows.append(f"{t:.1f} {eta:.15g}") + return "\n".join(rows) + "\n" + + +def compare(case: str, runs: dict[str, dict[str, np.ndarray]]) -> None: + names = list(runs) + reference = runs[names[0]] + if not reference: + return + for name in ("FairTen1", "AnchTen1"): + span = float(np.ptp(reference[name])) + check(span > 1.0e3, f"{case}: the waves load the line ({name} range {span:.4g} N)") + for other in names[1:]: + if not runs[other]: + continue + worst = 0.0 + for name in CHANNELS: + a, b = reference[name], runs[other][name] + scale = max(float(np.ptp(a)), 1.0e-3) + worst = max(worst, float(np.max(np.abs(a - b))) / scale) + check( + worst <= RELATIVE, + f"{case}: {names[0]} and {other} give the same response " + f"(largest difference {worst:.3g} of a channel's range, limit {RELATIVE:g})", + ) + + +def differs(case: str, a: dict[str, np.ndarray], b: dict[str, np.ndarray]) -> None: + """The gates resolve a wrong sea: the tensions of a and b part by more than 10 % of a range.""" + if not a or not b: + return + worst = max( + float(np.max(np.abs(a[name] - b[name]))) / float(np.ptp(a[name])) + for name in ("FairTen1", "AnchTen1") + ) + check(worst > 0.1, f"{case} (largest difference {worst:.3g} of a tension range)") + + +def main() -> int: + parser = argparse.ArgumentParser() + parser.add_argument("--exe", required=True, type=Path) + parser.add_argument("--output", required=True, type=Path) + args = parser.parse_args() + exe = args.exe.resolve() + out = args.output.resolve() + common = "0 rampTime\n" + + # a regular wave along +X: the waves row, WaveKin 7 and WaveKin 3 + regular = [(2.0, 10.0, 0.0)] + airy = run(exe, out / "regular_airy", common + "airy 2.0 10.0 0.0 waves", {}) + compare( + "regular wave", + { + "airy waves": airy, + "WaveKin 7": run( + exe, + out / "regular_wk7", + common + "7 WaterKin", + {"wave_frequencies.txt": frequencies_file(regular)}, + ), + "WaveKin 3": run( + exe, + out / "regular_wk3", + common + "3 WaterKin\n0.1 dtWave", + {"wave_elevation.txt": elevation_file(regular)}, + ), + }, + ) + + # two components along +X: wavetrain rows, WaveKin 7 and WaveKin 3 + bimodal = [(2.0, 10.0, 0.0), (1.0, 8.0, 0.0)] + trains = "\n".join(f"airy {h} {p} {d} wavetrain" for h, p, d in bimodal) + compare( + "two components", + { + "wavetrain rows": run(exe, out / "bimodal_trains", common + trains, {}), + "WaveKin 7": run( + exe, + out / "bimodal_wk7", + common + "7 WaterKin", + {"wave_frequencies.txt": frequencies_file(bimodal)}, + ), + "WaveKin 3": run( + exe, + out / "bimodal_wk3", + common + "3 WaterKin\n0.1 dtWave", + {"wave_elevation.txt": elevation_file(bimodal)}, + ), + }, + ) + + # a wave at 30 deg to the line: the deck direction against MoorDyn-C's beta + oblique = [(2.0, 10.0, 30.0)] + turned = run(exe, out / "oblique_airy", common + "airy 2.0 10.0 30.0 waves", {}) + compare( + "oblique wave", + { + "airy waves": turned, + "WaveKin 7": run( + exe, + out / "oblique_wk7", + common + "7 WaterKin", + {"wave_frequencies.txt": frequencies_file(oblique)}, + ), + }, + ) + + # the gates see a wrong phase and a wrong direction + quadrature = "0.0 0.0 0.0 0.0\n0.628318530717959 1.0 0.0 0.0\n" + shifted = run( + exe, out / "quadrature_wk7", common + "7 WaterKin", {"wave_frequencies.txt": quadrature} + ) + differs( + "a WaveKin 7 wave a quarter period out of phase parts from the deck wave", airy, shifted + ) + differs("the wave along +X parts from the oblique wave", turned, airy) + + if FAILURES: + print(f"\n{len(FAILURES)} check(s) failed") + return 1 + print("\nall checks passed") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/validation/README.md b/validation/README.md index ff577aba..95d2c185 100644 --- a/validation/README.md +++ b/validation/README.md @@ -18,7 +18,7 @@ redistributed. | [`bodies/`](bodies/README.md) | Rigid-body, rod and shared-anchor cases with MoorDyn-C twins, stored references and pass limits | | [`experiments/`](experiments/README.md) | Holcombe et al. (2025) static lazy-wave and Bergdahl et al. (2016) dynamic-chain comparisons | | [`PERFORMANCE_0_1_0.md`](PERFORMANCE_0_1_0.md) | Wall time of CableDyn 0.1.0, MoorDyn-C and MoorDyn-F at equal accuracy on five mooring, cable, buoy and coupled cases | -| [`performance/`](performance/README.md) | Same-host timing of the three spatially resolved lazy-wave cables | +| [`performance/`](performance/README.md) | Same-host wall-clock records of the L5 cases: the resolved lazy-wave spans, the one-hour VolturnUS-S mooring and the tension-only chain | | [`PAPER_REPRODUCTION.md`](PAPER_REPRODUCTION.md) | Every CableDyn result in the journal article, re-run with the release defaults and in paper mode | | [`OPENFAST_DLC_VERIFICATION.md`](OPENFAST_DLC_VERIFICATION.md) | Design-load-case comparison against stock MoorDyn-F in OpenFAST, maintained by NLR (National Laboratory of the Rockies, formerly NREL) | | `scripts/` | Cross-code comparison and reference-generation scripts cited in `VALIDATION.md` | diff --git a/validation/RELEASE_0_4_2.md b/validation/RELEASE_0_4_2.md new file mode 100644 index 00000000..e60a9e22 --- /dev/null +++ b/validation/RELEASE_0_4_2.md @@ -0,0 +1,108 @@ + + +# CableDyn v0.4.2 release record + +This record lists what was built and tested for the v0.4.2 release: the source commit, +toolchains, dependency pins, test results and asset hashes. Case definitions and pass criteria +are in [`VALIDATION.md`](../VALIDATION.md). The OpenFAST and r-test pins, the 23 OpenFAST +patches and the reference LAPACK are those of [v0.4.1](RELEASE_0_4_1.md). + +## Source and pins + +| Item | Value | +| --- | --- | +| CableDyn | `0.4.2` (2026-11-09), C ABI 1, minor extension 4 | +| Source | The release tree (`release/0.4.2` at `98db4a5`, tree `3ff9cce`): dev with #107 to #142, the version and the experiment and L5 records of the release. The assets and the gates below were produced from this tree, or from the version commit `25bdfc1` before it, which has the same sources (the two later commits change only records and documentation); this record is added afterwards | +| OpenFAST base | `2895884d2be01862173c88d70f86b358d2f1a50a`; the 23 patches of [`integration/openfast/patches`](../integration/openfast/patches) applied to a clean checkout by `prepare_openfast_source.ps1` | +| OpenFAST r-test | `dd5feaaaa500ba7283140107806300d551cff0a7` | +| Reference LAPACK/BLAS | 3.12.1, release-tag archive with SHA-256 `2ca6407a001a474d4d4d35f3a61550156050c48016d949f0da0529c0aa052422`, built with IFX for x86-64-v3 (`/fp:precise /arch:CORE-AVX2`) | + +## Toolchains + +| Item | Version | +| --- | --- | +| GNU Fortran (test builds) | conda-forge GCC 16.2.0, with OpenBLAS 0.3.33 and LAPACK from the conda environment | +| Intel Fortran (Windows release) | IFX 2025.3.2, `/fp:precise /arch:CORE-AVX2 /Qfma-` (value-safe floating point, x86-64-v3, no contraction into fused multiply-adds), `/Qauto` (thread-safe local storage) | +| Microsoft C/C++ | Visual Studio 2022 (release workflow) | +| Python wheels | scikit-build-core; cibuildwheel v4.3.3 (Linux `manylinux_2_28`, macOS arm64); IFX static build on Windows (`release/build_windows_wheel.ps1`) | +| Python and packaging | Python 3.13, build 1.6.1, Twine 7.0.0 (release workflow) | + +## Test results + +| Gate | Result | +| --- | --- | +| GNU Release CTest, including the slow tier, on five OpenBLAS kernels (Prescott, Nehalem, Sandybridge, Haswell and Zen through `OPENBLAS_CORETYPE`; Windows, local, fresh build directory) | 405 of 406 on each kernel before the experiment rerun, the one failure being `validation_records`, which requires provenance records that name the release; it passes on the release tree. 0 compiler warnings | +| GNU Debug CTest (`-fcheck=all`), including the slow tier, with the tests' own timeouts (Windows, local, fresh build directory) | 405 of 406, the same `validation_records` row; 0 compiler warnings | +| Example fallback scan (`tests/check_example_fallbacks.py --coretype`, each kernel confirmed by name) | all 65 shipped decks, those of the `moordynC_*` folders included, run on each of the five kernels with no fallback note | +| Python package tests (local, native library and driver of the release tree) | 3016 passed, 47 skipped (platform- and tool-dependent cases) | +| Python distributions (`python -m build python`, `twine check`, release workflow) | both pass; each carries the Apache-2.0 licence; the wheel holds only `cabledyn` and its metadata | +| CI matrix of the release tree (#143 at `98db4a5`) | Linux and Windows, Release and Debug; the Prescott round-off job with the example fallback scan; Python 3.10 and 3.13 on three platforms with coverage and strict type checks; the wheel builds; Sphinx and Read the Docs; all passed. Codex review of the release tree: no findings | +| Sphinx documentation (`-W -n`) | built with no warnings | +| pre-commit, all files | passed | +| Release metadata | `check_release_metadata.py` passed (CableDyn v0.4.2, 2026-11-09) | +| Release-tree audit | Git archive of `98db4a5`: 988 files, SHA-256 `24e465c110f9ac5d7bbd5d1026b92cb9ba0eb277cec0f9eb36fdd1e91e1991d9` | +| Experimental comparisons ([`experiments`](experiments/README.md)) | Holcombe (12 cases) and Bergdahl (30 primary and 8 refinement cases) re-run with a GNU Release build of the release sources (`cabledyn.exe` SHA-256 `0ab8649f0d5532450ff5f99e8277e498ff8f8f24556ef98f46bf2d52fb5417e0`). Both reproduce their summaries, metrics and refinement figures byte for byte. Of the hashed profiles only Holcombe's two static profiles change, in their `Declination` and `Inclination` columns alone: the finite-EI node angles now come from the line's Hermite tangent (#114), which moves them by at most 3.47 deg at the ideal clamp and 0.32 deg at a discrete buoyancy module. The Bergdahl waveform comparison was not re-run (its measured series was not available); its files and metrics are those of v0.3.0, as `provenance.json` states | +| Bodies suite (102 metrics) | 102 of 102 pass with the same GNU Release build | +| OpenFAST build gate (`integration/openfast/openfast_build_gate.ps1`, a GNU double-precision OpenFAST of the release sources; the IEA-15 MW mixed `CompMooring = 5` case in still air, as no turbulent wind file is on the host) | passed: the module compiles, names itself `OpenFAST-v5.0.0-CableDyn-0.4.2` and runs 60 s with finite output | +| OpenFAST linearisation (`validation/scripts/openfast_lin_ab.py`, IEA-15 MW UMaine twin decks and a mixed cable deck) | passed with the release `openfast.exe` (single precision), its log identical to v0.4.1's: CableDyn mooring block symmetric to 7.2e-6; surge stiffness 7.721e4 N/m against MoorDyn-F's 7.716e4 N/m; dominant fairlead-block entries to 1.1e-3 and every entry above 1 % of its block to 2.9e-3; the platform 6×6 stiffness to 1.0e-3 of MoorDyn-F's quasi-static reduction; the lowest nine line-mode frequencies to 0.3 %; the mixed cable deck's point stiffness to its static solves to 1.1e-4. It also passed with the double-precision build (symmetry 7.2e-6, 6×6 to 1.0e-3, cable deck to 1.0e-4) | +| L5 wall-clock records ([`performance`](performance/README.md), `performance_records.py`, one thread, median of three runs after a warm-up) | the release driver takes 1.34 / 2.37 / 4.98 s on the 80 / 200 / 800 m lazy-wave spans (v0.4.1: 1.44 / 2.56 / 5.29 s), 4.30 s on the one-hour VolturnUS-S chain (4.44 s) and 0.197 s on the WD0050 chain (0.200 s), each with its reference response reproduced and with the solver counts of v0.4.1 | +| Wall time of the shipped examples, v0.4.1 vs the release sources (GNU Release builds, same host, one thread, OpenBLAS Haswell kernel, best of two runs in alternating order) | over the 63 decks that both run (two new decks use options v0.4.1 refuses), the geometric-mean ratio is 0.959 and the total falls from 133.2 to 121.4 s; `lazy_wave_modes.dat` takes 0.66 s instead of 4.12 s, six other finite-EI decks 7 to 22 % less, and no deck is slower by more than 5 % | + +The coupled IEA-15 MW throughput figures of `VALIDATION.md` (September 2026, another host) were +not re-measured: the turbulent wind file of those runs is not on the release host. They say so +in place. + +## Windows executable gates + +Every gate of `build_static_windows.ps1` passed in the release workflow (`release-windows-static.yml`, +run 42620906823, on `98db4a5`; the preflight run 42611164798 on `25bdfc1` passed the same gates). The +smoke runs used a system-only `PATH`. + +| Gate | Result | +| --- | --- | +| Compiler | IFX 2025.3.2 (minimum 2025.3) | +| OpenFAST solution build | one pass: 34 projects succeeded, 0 failed | +| `CableDyn_driver.exe` imports | `KERNEL32.dll`, `SHELL32.dll` and `imagehlp.dll` only; stack reserve 268,435,456 bytes; `--version` reports `Build x86-64-v3 (AVX2)` | +| `openfast.exe` imports | `KERNEL32.dll` and `imagehlp.dll` only; `-v` reports `OpenFAST-v5.0.0-CableDyn-0.4.2` | +| Processor check | both executables stop at start with exit 3 and the message on a simulated missing x86-64-v3 feature, in the workflow and again on the downloaded assets | +| Standalone smoke | the shallow-chain static deck (`chain_catenary_shallow_30m.dat`) converges | +| Memory growth over a 10x longer run | 2.6 -> 2.6 MiB (`dynamic_chain_current.dat`), 21.5 -> 21.5 MiB (`lozon_gomex80_power_cable.dat`); limit +16 MiB | +| Exit contract | a run states the exit contract after the banner; a refused input ends stderr with the closing line | +| `CompMooring = 5` smoke | CableDyn banner, `dtM` 0.025 s (one glue step), equilibrium fairlead tensions 2.437 MN, the same as v0.4.1 to every printed digit, normal termination | + +## Clean-machine test + +A self-contained check ran the release assets from a folder whose path holds spaces, an accented +letter and Hangul, with a system-only `PATH`. It checks the checksums of the four files and the +manifest, the start of both executables (both name 0.4.2), every shipped example deck (65, now +including the `moordynC_*` folders, each run from its own folder) with the release +`CableDyn_driver.exe`, four `CompMooring = 5` runs, and the Python wheel in a new virtual +environment, where it imports as 0.4.2 and runs the release driver. The four runs are a 70 s +JONSWAP sea with mixed chains and a cable, a 400 s line failure, a checkpoint at 30 s with a +restart whose last 10 s of output (400 rows) must be bit-identical, and a checkpoint between two +mooring steps (`dtM` = 2 `DT`, at 30.025 s) whose restart must match the rest of the run (200 +rows) bit for bit. All 13 checks passed on the preflight assets and on the final assets. + +## Python distribution + +The PyPI distribution is built by `.github/workflows/wheels.yml`; each wheel is installed into a +clean environment and smoke-tested on its own platform (the library and the driver it carries +load and run a deck, and the driver reports the expected build). The preflight run (42620911318, on `98db4a5`) +built the files below and uploaded them to TestPyPI; the release run rebuilds them from the tag +before the upload. The Windows wheel installed from TestPyPI into a new environment has the preflight checksum and passed `release/smoke_test_wheel.py` (library, driver, build x86-64-v3). + +| File | SHA-256 (preflight) | +| --- | --- | +| `cabledyn-0.4.2.tar.gz` | `046838d064ac730f2f26a969b28a3862a6dce3182ac033df5325f292aed294b5` | +| `cabledyn-0.4.2-py3-none-win_amd64.whl` | `4405bc41fc7f93ae2eaa2762ca7b4b6b8e36a8274315c9c3239b14b67ce6510a` | +| `cabledyn-0.4.2-py3-none-macosx_15_0_arm64.whl` | `8dd32c22831badb4fd536884f077b7149f10c91ff6bdc3fb9ce46114617ad39b` | +| `cabledyn-0.4.2-py3-none-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl` | `e79267e0f80a091bd5aa6908a13981bdacd52221ae006e0babf44d069933cedc` | + +## Assets + +| File | SHA-256 | +| --- | --- | +| `CableDyn_driver.exe` | `c1a8ca25390bec4dc029aee9dd72c92d216c0f4cb26eb4c974aaf87aee734832` | +| `openfast.exe` | `53a0bb6be8311f6afc69e8ac26b529166a068cdf57cecefb90316d15d2a33f35` | +| `cabledyn-0.4.2-py3-none-any.whl` | `296126705668a120def9b5dfde3f825a6eab0ede19a35987f4b0ff84d9d39410` | +| `cabledyn-0.4.2.tar.gz` | `e1cc496568f4a4aec784250a859e3c48fe64bd64af5e3ec66a2befd412623d0d` | diff --git a/validation/experiments/bergdahl/README.md b/validation/experiments/bergdahl/README.md index c7b24c72..485f610e 100644 --- a/validation/experiments/bergdahl/README.md +++ b/validation/experiments/bergdahl/README.md @@ -76,8 +76,8 @@ mean absolute percentage error of 3.11%, a mean bias of +0.47 N, a Pearson corre conditions, halving the nominal element length and the time step changes the mean cycle maximum by no more than 0.29% and 0.27%, respectively. The phase-averaged force histories had RMSEs of 5.93% and 2.56% of the measured force range with 0.3.0; that comparison was not rerun for -0.4.0 or 0.4.1 (its waveform files and metrics are the 0.3.0 run's, `provenance.json`). The -0.4.1 rerun reproduces the 0.4.0 force maxima, metrics and refinement summaries byte for byte. The line's upper +0.4.0, 0.4.1 or 0.4.2 (its waveform files and metrics are the 0.3.0 run's, `provenance.json`). The +0.4.1 and 0.4.2 reruns reproduce the 0.4.0 force maxima, metrics and refinement summaries byte for byte. The line's upper end lies 0.3 m above the still-water level, so 0.4.0's dry weight of the part above the surface changed the results: the RMSE from 1.583 N to 1.577 N and the mean absolute percentage error from 3.13% to 3.11%. The waveform CSVs carry the measured phase averages computed from the diff --git a/validation/experiments/bergdahl/provenance.json b/validation/experiments/bergdahl/provenance.json index 4266d5c2..457f959b 100644 --- a/validation/experiments/bergdahl/provenance.json +++ b/validation/experiments/bergdahl/provenance.json @@ -1,8 +1,8 @@ { - "CableDyn_release": "v0.4.1", - "validation_date": "2026-11-08", + "CableDyn_release": "v0.4.2", + "validation_date": "2026-11-09", "executable_name": "cabledyn.exe", - "executable_sha256": "9b86cbd5abc47d73d535f49dd5952f7805646b190a3744380d0b43849019e10f", + "executable_sha256": "0ab8649f0d5532450ff5f99e8277e498ff8f8f24556ef98f46bf2d52fb5417e0", "compiler": "GNU Fortran 16.2.0", "build_type": "Release", "platform": "Windows 11 x86-64", @@ -22,5 +22,5 @@ "waveform_metrics_sha256": "0fb6015cb30aa2bbb1cd8951b603f9201af50372ee6d3633a72fc70ea5280d1a", "refinement_summary_sha256": "75342ed4f3ebe2d7acb19af56394e24e6ce909bb3df7445bf3a1d884280f9eb6", "waveform_comparison_release": "v0.3.0", - "waveform_comparison_note": "not rerun with 0.4.0 or 0.4.1: the supplement expData.dat was not available when the record was rerun; the waveform files and metrics are those of the v0.3.0 run" + "waveform_comparison_note": "not rerun with 0.4.0, 0.4.1 or 0.4.2: the supplement expData.dat was not available when the record was rerun; the waveform files and metrics are those of the v0.3.0 run" } diff --git a/validation/experiments/holcombe/provenance.json b/validation/experiments/holcombe/provenance.json index 06f401ed..7431f1c2 100644 --- a/validation/experiments/holcombe/provenance.json +++ b/validation/experiments/holcombe/provenance.json @@ -1,8 +1,8 @@ { - "CableDyn_release": "v0.4.1", - "validation_date": "2026-11-08", + "CableDyn_release": "v0.4.2", + "validation_date": "2026-11-09", "executable_name": "cabledyn.exe", - "executable_sha256": "9b86cbd5abc47d73d535f49dd5952f7805646b190a3744380d0b43849019e10f", + "executable_sha256": "0ab8649f0d5532450ff5f99e8277e498ff8f8f24556ef98f46bf2d52fb5417e0", "compiler": "GNU Fortran 16.2.0", "build_type": "Release", "platform": "Windows 11 x86-64", @@ -14,6 +14,6 @@ "marker_curvature_comparison_sha256": "169a2ac11f65f815d75ba84eb6c588693d19971aa524e4b619a34d27a0fb8715", "marker_curvature_summary_sha256": "cd7598043724a79b2bd2f43deac83537319bffc9117f649c92298751236a5a83", "mesh_refinement_summary_sha256": "964fa735d541f5674285fb31aca6053e414b516d579e0b7e41bc5b8cd6286659", - "free_rotation_profile_sha256": "2b76f492fccfc6b3ab1ac02765169d884f377939382ea99b09cba9737ef91b20", - "ideal_clamp_profile_sha256": "69e9fe0e0f445122993c687b1428f140de4ea230d74707d32bdb3fc267be84a4" + "free_rotation_profile_sha256": "9981da7f37c19444562f361e4616a48d4d0a7c77beedcb12f827f35ee9d6239f", + "ideal_clamp_profile_sha256": "f4017c8c5485741fcb9ae81bf0298bd4774381e402717f0967e5028808857038" } diff --git a/validation/performance/PERFORMANCE_AUDIT.md b/validation/performance/PERFORMANCE_AUDIT.md index 4c83b1f5..665fd6a2 100644 --- a/validation/performance/PERFORMANCE_AUDIT.md +++ b/validation/performance/PERFORMANCE_AUDIT.md @@ -1,31 +1,59 @@ -# Same-host computational performance +# Same-host wall times -This page lists the wall times and timing definitions behind the lazy-wave performance -comparison. The protocol is in [README.md](README.md). +This page lists the wall times behind the L5 rows of [`VALIDATION.md`](../../VALIDATION.md) with +their ranges and the timing definitions. The cases, protocol and builds are in +[README.md](README.md); the values come from `performance_summary.csv` and +`wallclock_summary.csv`. -All runs used one thread of an Intel Core i9-13900K. Each value is the median of three measured -runs after one warm-up; the range of the three runs is in brackets. The values come from -`performance_summary.csv`. +All runs used one thread on an AMD Ryzen Threadripper PRO 7965WX under Windows 11 Pro, on +2026-11-08 (OrcaFlex, MoorDyn-F, MoorDyn-C) and 2026-11-09 (CableDyn). Each value is the median of three timed runs after one warm-up; the range of the +three runs is in brackets. `IFX` is the v0.4.2 release driver, `GNU` a GNU Release build of the same source. -| Water depth | CableDyn | OrcaFlex | Refined MoorDyn-F | -| ---: | ---: | ---: | ---: | -| 80 m | 1.55 s (1.55–1.84), 240 elements, 0.05 s | 2.29 s (2.26–2.31), 179 segments, 0.05 s | 249.07 s (249.04–363.90), 208 segments, 0.125 ms | -| 200 m | 4.64 s (4.62–4.69), 480 elements, 0.05 s | 4.56 s (4.51–4.74), 350 segments, 0.05 s | 144.61 s (142.70–214.11), 224 segments, 0.125 ms | -| 800 m | 7.37 s (7.37–7.54), 960 elements, 0.05 s | 23.17 s (23.00–23.42), 1227 segments, 0.05 s | 243.08 s (240.15–249.30), 232 segments, 0.5 ms | +## L5-DPC: pinned-touchdown lazy-wave spans, 60 s -The MoorDyn-F models are refined fourfold, and their time step is the largest at which every -reported response changes by less than 0.01 % when the step is halved. That accuracy -requirement is much stricter than the one normally used in design work, and it sets the -explicit time step. The figures are specific to this host, these models and these settings. +| Water depth | CableDyn (IFX) | CableDyn (GNU) | OrcaFlex 11.6d | Refined MoorDyn-F | +| ---: | ---: | ---: | ---: | ---: | +| 80 m | 1.34 s (1.33–1.35) | 1.91 s (1.91–1.92) | 2.69 s (2.68–2.71) | 326.6 s (323.8–343.3) | +| 200 m | 2.37 s (2.35–2.37) | 3.18 s (3.17–3.21) | 5.31 s (5.18–5.64) | 191.9 s (191.7–193.5) | +| 800 m | 4.98 s (4.92–5.09) | 6.87 s (6.82–6.89) | 27.81 s (27.44–28.15) | 320.7 s (319.3–326.9) | +| Mesh, step | 240 / 480 / 960 elements, 0.05 s | as IFX | 179 / 350 / 1227 segments, 0.05 s | 208 / 224 / 232 segments; 0.125 / 0.125 / 0.5 ms | + +CableDyn's static initialisation takes 0.11 / 0.19 / 0.32 s (IFX) of these totals; it takes +3.04 / 2.75 / 3.27 linear solves per step, and no interval needs recovery subdivision. OrcaFlex's +statics take 0.32 / 0.30 / 2.65 s. The MoorDyn-F total includes its dynamic relaxation to +`threshIC` 1e-5. Halving the MoorDyn-F step moves the scored curvature and tension by at most +0.0005 %, inside the 0.01 % that selects the step; that accuracy requirement is much stricter +than the one normally used in design work, and it sets the explicit step. + +## L5-V: VolturnUS-S chain, one hour + +| | CableDyn (IFX) | CableDyn (GNU) | OrcaFlex 11.6d | +| --- | ---: | ---: | ---: | +| Wall time | 4.30 s (4.26–4.31) | 6.05 s (6.00–6.09) | 19.72 s (19.33–19.74) | +| Model | 50 elements, dt 0.1 s, 3600 s | as IFX | 50 segments, dt 0.1 s, 200 s build-up and 3600 s | + +CableDyn takes 2.03 Newton iterations per step over the 36,000 steps. + +## L5-wc: WD0050 chain, 80 s + +| | CableDyn (IFX) | CableDyn (GNU) | MoorDyn-C v2.7.2 | +| --- | ---: | ---: | ---: | +| Wall time | 0.197 s (0.196–0.201) | 0.268 s (0.268–0.268) | 0.482 s (0.476–0.483) | +| Model | 41 elements, dt 0.05 s | as IFX | 41 segments, RK2, dtM 1 ms, coupling step 0.1 s | + +MoorDyn-C's stepping loop takes 0.452 s of its total. Over the scored 20 s the fairlead tensions +of the two codes differ by 1.35 % in mean and 1.71 % in maximum. ## Timing definitions -- CableDyn and OrcaFlex totals comprise static initialisation and the 60 s dynamic march. -- The MoorDyn-F total is the complete dynamic-driver call, including its dynamic-relaxation - initialisation. The separately timed MoorDyn-F static-only call is a diagnostic and is not - added a second time. +- CableDyn, MoorDyn-F and MoorDyn-C: the wall time of the whole process, from start to exit, + including input, initial condition, dynamics and output. +- OrcaFlex: `CalculateStatics` plus `RunSimulation`, timed inside a fresh Python process; model + building, licence checkout and result extraction are outside the timed interval. +- The static and dynamic split of CableDyn comes from a separate run with `CABLEDYN_PROFILE`. +- Peak working set is that of the whole process; for OrcaFlex it includes the Python + interpreter. -CableDyn used 34, 16 and 8 line-search backtracking trials over the 1,200 timed intervals at -80, 200 and 800 m, respectively. No timed interval required recovery subdivision. +The figures are specific to this host, these models and these settings. diff --git a/validation/performance/README.md b/validation/performance/README.md index f4c78c14..0b283d8a 100644 --- a/validation/performance/README.md +++ b/validation/performance/README.md @@ -1,48 +1,106 @@ -# Lazy-wave cable performance comparison +# Same-host wall-clock records (L5) -This directory records the same-host wall-time comparison of CableDyn, OrcaFlex and MoorDyn-F -on the three spatially resolved Lozon lazy-wave cables. Use it to check the timing figures in -[`VALIDATION.md`](../../VALIDATION.md). +This directory records the same-host wall-clock measurements behind the L5 rows of +[`VALIDATION.md`](../../VALIDATION.md): the matched lazy-wave spans (L5-DPC), the one-hour +VolturnUS-S mooring (L5-V) and the tension-only chain (L5-wc). Every figure comes from +[`validation/scripts/performance_records.py`](../scripts/performance_records.py), which builds the +models, runs and times each code and writes the files below. | File | Contents | | --- | --- | -| `performance_summary.csv` | Per-site, per-solver mesh size, time step, wall and CPU times, memory and Newton statistics | -| `performance_metrics.json` | The same rows in JSON | -| [`PERFORMANCE_AUDIT.md`](PERFORMANCE_AUDIT.md) | Wall times with their ranges, and timing definitions | +| `performance_summary.csv` | L5-DPC: per span, code and build, the mesh, time step, wall and CPU times, memory and solver counts | +| `wallclock_summary.csv` | L5-V and L5-wc in the same columns | +| `performance_metrics.json` | The same rows, the code versions and builds, the host, the date, the responses each timed model reproduced, the MoorDyn-F step checks and the CableDyn driver notes | +| [`PERFORMANCE_AUDIT.md`](PERFORMANCE_AUDIT.md) | Wall times with their ranges, and the timing definitions | | [`ORCAFLEX_MESH_CONVERGENCE.md`](ORCAFLEX_MESH_CONVERGENCE.md) | 800 m OrcaFlex segment-length study; data in `orcaflex_mesh_convergence.csv` | +## Cases + +- **L5-DPC.** The matched 80, 200 and 800 m suspended spans of the L3-6 protocol: hang-off at + (0, 0, −14) m heaved 3 sin(2πt/12) m, touchdown pinned at the static touchdown point, no + seabed in reach, still water, Cdn 1.2, Cdt 0.1, Can 1.0, Cat 0; static initialisation and + 60 s of dynamics. + - CableDyn: driver decks with 240, 480 and 960 cubic-Hermite elements, aligned with the + sections, dt 0.05 s, the default solver settings with the Newton tolerance `1e-4` of the + shipped Lozon decks. The hang-off motion starts at full velocity, as in the L3-6 gate. + - OrcaFlex: the models of `orcaflex_lazywave_dynamic_reference.py`, 0.75 m segments (179, 350 + and 1227 segments; [`ORCAFLEX_MESH_CONVERGENCE.md`](ORCAFLEX_MESH_CONVERGENCE.md)), implicit + dt 0.05 s, a 12 s build-up and 48 s. + - MoorDyn-F: the decks of `moordyn_lazywave_dynamic_reference.py` with the native meshes + refined fourfold (208, 224 and 232 segments), RK4, dtM 0.125 ms at 80 and 200 m and 0.5 ms + at 800 m, its dynamic-relaxation initialisation (`threshIC` 1e-5, `TmaxIC` 900 s) and + 61.5 s of dynamics. These steps are the largest at which halving the step moves every + scored response by less than 0.01 %; the tool re-checks this with `--step-check` + (`moordyn_f_step_checks` in the JSON). The resolved bending modes of the contact-free + cable, not seabed stiffness, set this explicit step. +- **L5-V.** One IEA-15MW VolturnUS-S chain (850 m, 50 elements or segments, 200 m water) with + the fairlead driven for one hour by 5 sin(2πt/90) m of surge and 2 sin(2πt/12) m of heave. + CableDyn runs `examples/iea15mw_volturnus_mooring.dat` with the drive of the + `l3_longduration_mooring` gate (a 100 s half-cosine ramp, dt 0.1 s, 3600 s, no seabed + damping) as a motion file; OrcaFlex runs the model of `orcaflex_longduration_mooring.py` + (implicit dt 0.1 s, 200 s build-up and 3600 s). +- **L5-wc.** The WD0050 grounded chain of `examples/wd0050_chain.dat` (410 m, 41 elements or + segments, 50 m water) under the L2-2 A1 fairlead heave 2 sin(2πt/10) m for 80 s: the 60 s + warm-up and the 20 s scored window of `l2_2_dynamic_parity`. CableDyn runs the deck at + dt 0.05 s. MoorDyn-C runs the same chain through `moordyn_c_driver.cpp` (explicit RK2, + dtM 1 ms, coupling step 0.1 s, its dynamic-relaxation initialisation). + +Before a model is recorded, the tool checks its response against the reference: on L5-DPC the +hang-off tension mean, minimum and maximum over 24–60 s against the OrcaFlex values of the +L3-6 gate (within 2 %), and on L5-V the fairlead tension statistics over 200–3600 s against the +OrcaFlex values of the L3-7 gate (within that gate's bands). The responses are in +`performance_metrics.json`. + ## Protocol -- Models: matched 80, 200 and 800 m suspended spans with a pinned touchdown point, no grounded - tail and no seabed contact. -- Timed work: static initialisation and a 60 s dynamic march. -- Host: one Intel Core i9-13900K processor thread; median of three runs after one warm-up, with - the range retained. -- CableDyn and OrcaFlex use implicit 0.05 s steps. -- MoorDyn-F finite-bending models are refined fourfold and their explicit step is halved until - every reported response changes by less than 0.01%. The retained steps are 0.125 ms at 80 and - 200 m and 0.5 ms at 800 m. These are below the shortest-segment axial transit time because - the resolved bending modes of the contact-free cable, not seabed penalty stiffness, set the - explicit stability limit. -- The 800 m OrcaFlex segment length, 0.75 m, is the converged value from - [`ORCAFLEX_MESH_CONVERGENCE.md`](ORCAFLEX_MESH_CONVERGENCE.md). +- One thread: `OMP_NUM_THREADS = OPENBLAS_NUM_THREADS = 1`, and OrcaFlex `threadCount = 1`. +- Each process at high priority; one warm-up run, then three timed runs. The median and the + range are recorded. +- CableDyn, MoorDyn-F and MoorDyn-C: the wall time of the whole process (input, initial + condition, dynamics and output). OrcaFlex: `CalculateStatics` plus `RunSimulation`, in a + fresh Python process for each run. +- CableDyn's static and dynamic split and its solver counts come from one further run with + `CABLEDYN_PROFILE`. `newton_per_step` is the linear solves per step for the finite-EI spans + and the Newton iterations per line step for the chains. MoorDyn-C's dynamic time is the + stepping loop timed by its driver. +- `host_busy_median` is the busy fraction of all host processors during the timed runs. Other + work was running on the host; the ranges show its effect. ## Provenance -The rows record the host (one thread of an Intel Core i9-13900K), the mesh, the time step and the -timing statistics of each run. The OrcaFlex segment-length study used OrcaFlex 11.6d -([`ORCAFLEX_MESH_CONVERGENCE.md`](ORCAFLEX_MESH_CONVERGENCE.md)). The executables of the three -codes, their build identifiers and the measurement dates were not recorded with the rows, and -the timing models and driver scripts are not included in the repository. Treat the figures as -indicative of this host and these settings; the release timings, with the code versions and -builds used, are in [`PERFORMANCE_0_1_0.md`](../PERFORMANCE_0_1_0.md). - -## Result - -Total times at 80, 200 and 800 m are 1.55, 4.64 and 7.37 s for CableDyn, 2.29, 4.56 and -23.17 s for OrcaFlex, and 249.07, 144.61 and 243.08 s for the refined MoorDyn-F models. The -MoorDyn-F times reflect the explicit step that the fourfold-refined bending mesh requires under -this protocol. The figures are specific to this host, these models and these settings, and do -not apply to the separate tension-only chain benchmark in `VALIDATION.md`. +Measured on an AMD Ryzen Threadripper PRO 7965WX (24 cores), Windows 11 Pro: OrcaFlex, MoorDyn-F and +MoorDyn-C on 2026-11-08, CableDyn 0.4.2 on 2026-11-09. + +| Code | Build | +| --- | --- | +| CableDyn `ifx-release-0.4.2` | the v0.4.2 release `CableDyn_driver.exe` (IFX 2025.3.2, static, `/fp:precise /arch:CORE-AVX2 /Qfma-`, reference LAPACK 3.12.1) | +| CableDyn `gnu-release-0.4.2` | the v0.4.2 source (`release/0.4.2` at `25bdfc1`): GNU Fortran 16.2.0 (conda-forge), CMake `Release` (`-O3`), baseline x86-64, OpenBLAS 0.3.33 | +| OrcaFlex | OrcaFlex 11.6d (OrcFxAPI DLL 11.6d) from Python, `threadCount = 1` | +| MoorDyn-F | MoorDyn v2.3.8 in the OpenFAST v5.0.0 MoorDyn driver: GNU Fortran 16.2.0, CMake `Release` (`-O3`), `DOUBLE_PRECISION=OFF` | +| MoorDyn-C | v2.7.2 release source: `libmoordyn` by GNU g++ 16.2.0, CMake `Release` (`-O3`); `moordyn_c_driver.cpp` by `g++ -O2` | + +The JSON records the driver hashes. The earlier L5-wc figure used MoorDyn-C v2.6.1 through the +same driver (the trace committed in `tests/data/l2_2_external_refs`). Its deck settings were not +recorded, so v2.7.2 runs the deck written by `performance_models.py`; over the scored window it +differs from the committed v2.6.1 trace by 0.37 % in mean and 1.19 % in maximum tension. + +## Reproduce + +From the repository root, with numpy, the OrcFxAPI Python interface on `PYTHONPATH`, the +OpenFAST MoorDyn driver and a MoorDyn-C build: + +```text +python validation/scripts/performance_records.py run --codes cabledyn \ + --cabledyn-driver --cabledyn-label