floating-dynamics 0.1.0__py3-none-any.whl

floating_dynamics/__init__.py

@@ -0,0 +1,4 @@
+"""Two-dimensional dynamics of floating bodies, including the free-surface
+effect of liquid cargo."""
+
+__version__ = '0.1.0'

floating_dynamics/__main__.py

@@ -0,0 +1,5 @@
+"""Run the free-surface demonstration with python -m floating_dynamics."""
+
+from .free_surface import main
+
+main()

floating_dynamics/body.py

@@ -0,0 +1,282 @@
+"""The dynamics of a two-dimensional body floating in the sea.
+
+The model is a cross-section of a long body, so every area is really a volume
+per unit length and every "area density" is a mass per unit length: with
+lengths in m and densities in t.m-3, masses are in tonnes, moments of inertia
+in t.m2 and forces in kN, per metre of the body's length. The sea surface is
+the line y = 0, and the sea lies below it.
+
+The body is rigid, apart from any liquid it carries in its compartments. Its
+outline determines its buoyancy; its mass, M, centre of mass, G, and moment
+of inertia, Iz, are given separately (for a ship, they depend on how it is
+built and loaded), or calculated for a body of uniform density.
+
+The body's state is the vector y = (X, Y, theta, U, V, omega):
+    (X, Y) is the position of G (excluding any liquid) in world coordinates;
+    theta is its angle of rotation, anticlockwise, from its initial shape;
+    (U, V) is the velocity of G and omega = dtheta/dt its angular velocity.
+
+Gravity acts at G and buoyancy acts at the centre of buoyancy, B: the centroid
+of the submerged part of the outline. The body is assumed to be watertight:
+the whole of its outline displaces water, however deeply it is submerged.
+
+The liquid in each compartment is treated quasi-statically: its surface is
+always level, and its weight acts at its centroid, which moves across the
+compartment as the body rolls (the "free-surface effect"). This is a good
+approximation if the liquid sloshes quickly compared with the body's roll
+(see sloshing_period). The liquid moves with the body as it heaves and, for
+its moment of inertia, it is treated as a point mass at its centroid.
+
+The surrounding water is modelled crudely, by:
+    added mass: the body must accelerate some water along with it, which is
+        modelled by increasing its mass for linear motion, and its moment of
+        inertia for rotation, by a fraction of themselves;
+    damping: the water resists motion (and carries energy away in waves),
+        which is modelled by linear damping of the linear and angular
+        velocities at fixed rates.
+
+"""
+
+import numpy as np
+from scipy.optimize import brentq
+from .geometry import (area, make_ccw, centroid, second_moment, transform,
+                       clip_below, fill, cross2)
+
+# Acceleration due to gravity, m.s-2.
+g = 9.81
+# Density of sea water, t.m-3.
+RHO_SEA = 1.027
+
+
+def mass_properties(poly, rho):
+    """Return the mass, centre of mass and Iz of polygon poly of density rho.
+
+    Iz is the moment of inertia about the centre of mass.
+
+    """
+
+    xy = make_ccw(np.asarray(poly, dtype=float))
+    G = centroid(xy)
+    return rho * area(xy), G, rho * second_moment(xy, G)
+
+
+def combine(*parts):
+    """Return the mass, centre of mass and Iz of a body made of parts.
+
+    Each part is a tuple (M, G, Iz) of its mass, centre of mass and moment of
+    inertia about its centre of mass; the combined Iz is about the combined
+    centre of mass (by the parallel axis theorem).
+
+    """
+
+    M = sum(p[0] for p in parts)
+    G = sum(p[0] * np.asarray(p[1]) for p in parts) / M
+    Iz = sum(p[2] + p[0] * np.sum((np.asarray(p[1]) - G)**2) for p in parts)
+    return M, G, Iz
+
+
+class Compartment:
+    """A tank fixed in the body, holding a liquid whose surface stays level."""
+
+    def __init__(self, tank, A_liquid, rho):
+        """Initialize the compartment.
+
+        tank is a sequence of (x, y) vertices in the same coordinates as the
+        body's outline; it holds a liquid of area A_liquid and density rho.
+
+        """
+
+        self.tank = make_ccw(np.asarray(tank, dtype=float))
+        if not 0 <= A_liquid <= area(self.tank):
+            raise ValueError('The liquid does not fit in the tank.')
+        self.A_liquid, self.rho = A_liquid, rho
+        self.M = rho * A_liquid
+
+    def upright_liquid(self):
+        """Return the polygon of the liquid when the body is upright."""
+        return fill(self.tank, self.A_liquid)
+
+    def sloshing_period(self):
+        """Return the period of the liquid's slowest sloshing mode (s).
+
+        The liquid is approximated, when upright, as a rectangle as wide as
+        its free surface and of the same area, for which the angular
+        frequency of the slowest mode is sqrt((pi.g/b).tanh(pi.h/b)).
+
+        """
+
+        liquid = self.upright_liquid()
+        top = np.isclose(liquid[:, 1], liquid[:, 1].max())
+        b = np.ptp(liquid[top, 0])
+        h = self.A_liquid / b
+        return 2 * np.pi / np.sqrt(np.pi * g / b * np.tanh(np.pi * h / b))
+
+
+class FloatingBody:
+    """A body with a polygonal outline, carrying liquid in compartments."""
+
+    def __init__(self, outline, M, G, Iz, compartments=(), rho_water=RHO_SEA,
+                 added_mass=0, added_inertia=0, heave_damping=0,
+                 roll_damping=0):
+        """Initialize the body.
+
+        outline is a sequence of (x, y) vertices for the body's shape. M is
+        its mass, G the position of its centre of mass (in the same
+        coordinates as outline) and Iz its moment of inertia about G, all
+        excluding the liquid in compartments, a sequence of Compartment
+        objects.
+
+        added_mass and added_inertia are the fractions by which the mass
+        (including the liquid) and Iz (excluding it) are increased by the
+        water which moves with the body. The damping rates (s-1) apply to the
+        linear and angular velocities, respectively.
+
+        """
+
+        xy = make_ccw(np.asarray(outline, dtype=float))
+        self.A = area(xy)
+        self.M, self.Iz = M, Iz
+        # The body's outline and tanks in its own frame of reference, with G
+        # at the origin.
+        self.G0 = np.asarray(G, dtype=float)
+        self.xy0 = xy - self.G0
+        self.compartments = compartments
+        self.tanks0 = [c.tank - self.G0 for c in compartments]
+        self.M_total = M + sum(c.M for c in compartments)
+        self.rho_water = rho_water
+        self.added_mass, self.added_inertia = added_mass, added_inertia
+        self.heave_damping, self.roll_damping = heave_damping, roll_damping
+
+    @classmethod
+    def uniform(cls, poly, rho, **kwargs):
+        """Return a solid body of uniform density rho with outline poly."""
+        return cls(poly, *mass_properties(poly, rho), **kwargs)
+
+    def to_world(self, xy, X, theta):
+        """Return polygon xy, in the outline's coordinates, in the world.
+
+        The body's G is at X, and it is rotated by theta.
+
+        """
+
+        return transform(np.asarray(xy) - self.G0, theta, X)
+
+    def world(self, X, theta):
+        """Return the body's outline with G at X, rotated by theta."""
+        return transform(self.xy0, theta, X)
+
+    def hydrostatics(self, X, theta):
+        """Return the submerged polygon, its area and the centre of buoyancy.
+
+        If the body is out of the water, the centre of buoyancy is None.
+
+        """
+
+        submerged = clip_below(self.world(X, theta))
+        A_sub = area(submerged)
+        B = centroid(submerged) if A_sub > 0 else None
+        return submerged, A_sub, B
+
+    def liquids(self, X, theta):
+        """Return the liquid in each compartment with G at X, rotated by theta.
+
+        The return value is a list of (polygon, mass, centroid) for each
+        compartment with any liquid in it.
+
+        """
+
+        out = []
+        for c, tank0 in zip(self.compartments, self.tanks0):
+            if c.M > 0:
+                liquid = fill(transform(tank0, theta, X), c.A_liquid)
+                out.append((liquid, c.M, centroid(liquid)))
+        return out
+
+    def centre_of_mass(self, X, theta):
+        """Return the centre of mass of the body and its liquid."""
+        parts = [(self.M, X, 0)] + [(M_l, G_l, 0) for _, M_l, G_l
+                                    in self.liquids(X, theta)]
+        return combine(*parts)[1]
+
+    def equilibrium_height(self, theta):
+        """Return the height of G at which the body floats at angle theta.
+
+        At this height the buoyant force balances the body's weight, but
+        there is a torque on it unless B lies directly below (or above) the
+        centre of mass of the body and its liquid.
+
+        """
+
+        A_float = self.M_total / self.rho_water
+        if A_float >= self.A:
+            raise ValueError('The body is too heavy to float.')
+        y = transform(self.xy0, theta)[:, 1]
+        def excess_area(Y):
+            return area(clip_below(self.world((0, Y), theta))) - A_float
+        return brentq(excess_area, -y.max(), -y.min())
+
+    def torque(self, X, theta):
+        """Return the torque about G and the moment of inertia about G.
+
+        The torque is due to buoyancy and to the weight of the liquid; the
+        moment of inertia excludes the added inertia.
+
+        """
+
+        G = np.asarray(X)
+        _, A_sub, B = self.hydrostatics(G, theta)
+        Fb = np.array((0, self.rho_water * A_sub * g))
+        tau = cross2(B - G, Fb) if B is not None else 0
+        Iz = self.Iz
+        # The weight of each liquid acts at its centroid, G_l.
+        for _, M_l, G_l in self.liquids(G, theta):
+            r = G_l - G
+            tau += cross2(r, (0, -M_l * g))
+            Iz += M_l * r @ r
+        return tau, Iz
+
+    def righting_lever(self, theta):
+        """Return the righting lever, GZ, of the body floating at angle theta.
+
+        GZ is the horizontal distance between the lines of action of the
+        weight and the buoyancy: it is positive if the resulting couple turns
+        the body back towards theta = 0.
+
+        """
+
+        X = (0, self.equilibrium_height(theta))
+        tau, _ = self.torque(X, theta)
+        return -np.sign(theta) * tau / (self.M_total * g)
+
+    def metacentric_height(self, dtheta=1e-4):
+        """Return the metacentric height, GM, for small angles of heel.
+
+        This is the slope of the righting lever curve at theta = 0, and so
+        includes the free-surface effect of any liquid.
+
+        """
+
+        return self.righting_lever(dtheta) / dtheta
+
+    def roll_period(self):
+        """Return the period of small, undamped rolls, or None if GM <= 0."""
+        GM = self.metacentric_height()
+        if GM <= 0:
+            return None
+        _, Iz = self.torque((0, self.equilibrium_height(0)), 0)
+        Iz += self.added_inertia * self.Iz
+        return 2 * np.pi * np.sqrt(Iz / (self.M_total * g * GM))
+
+    def rhs(self, t, y):
+        """Return dy/dt for the state vector y, for scipy's solve_ivp."""
+        X, Y, theta, U, V, omega = y
+        G = np.array((X, Y))
+        _, A_sub, _ = self.hydrostatics(G, theta)
+        tau, Iz = self.torque(G, theta)
+
+        F = np.array((0, (self.rho_water * A_sub - self.M_total) * g))
+        a = F / (self.M_total * (1 + self.added_mass))
+        alpha = tau / (Iz + self.added_inertia * self.Iz)
+        a -= self.heave_damping * np.array((U, V))
+        alpha -= self.roll_damping * omega
+        return np.array((U, V, omega, a[0], a[1], alpha))

floating_dynamics/drawing.py

@@ -0,0 +1,130 @@
+"""Draw and animate ships rolling in the sea."""
+
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib import animation
+
+SEA_COLOUR = '#8888ff'
+HULL_COLOUR = '#666666'
+TANK_COLOUR = 'white'
+CARGO_COLOUR = '#a0d6b4'
+G_COLOUR, B_COLOUR = 'r', 'b'
+
+
+class ShipView:
+    """The artists depicting a Ship on an Axes, updated for each state."""
+
+    def __init__(self, ax, ship):
+        self.ship = ship
+        body = ship.body
+        self.hull = ax.add_patch(plt.Polygon(body.xy0, fc=HULL_COLOUR,
+                                             ec='k', zorder=1))
+        self.tanks = [ax.add_patch(plt.Polygon(tank, fc=TANK_COLOUR,
+                                   ec='k', lw=0.5, zorder=2))
+                      for tank in ship.tanks]
+        self.solids = [ax.add_patch(plt.Polygon(solid, fc=CARGO_COLOUR,
+                                    ec='k', lw=0.5, hatch='///', zorder=2))
+                       for solid in ship.solid_cargo]
+        self.liquids = [ax.add_patch(plt.Polygon(np.zeros((3, 2)),
+                                     fc=CARGO_COLOUR, ec='none', zorder=2))
+                        for c in body.compartments if c.M > 0]
+        # The sea is drawn translucently over the ship, to show the waterline.
+        xmin, xmax = ax.get_xlim()
+        ymin, _ = ax.get_ylim()
+        ax.add_patch(plt.Rectangle((xmin, ymin), xmax - xmin, -ymin,
+                                   fc=SEA_COLOUR, alpha=0.5, zorder=3))
+        # The lines of action of the weight, through the centre of mass of
+        # the ship and its cargo, and of the buoyancy: the distance between
+        # them is the righting lever, GZ.
+        self.G_line = ax.axvline(0, c=G_COLOUR, ls='--', lw=1, zorder=4)
+        self.B_line = ax.axvline(0, c=B_COLOUR, ls='--', lw=1, zorder=4)
+        self.G = ax.add_patch(plt.Circle((0, 0), 0.3, fc=G_COLOUR, zorder=5))
+        self.B = ax.add_patch(plt.Circle((0, 0), 0.3, fc=B_COLOUR, zorder=5))
+        self.text = ax.text(0.03, 0.95, '', transform=ax.transAxes, va='top')
+
+    def update(self, state):
+        """Update the artists for the state vector state; return them."""
+        body = self.ship.body
+        X, theta = state[:2], state[2]
+        self.hull.set_xy(body.world(X, theta))
+        for patch, tank in zip(self.tanks, self.ship.tanks):
+            patch.set_xy(body.to_world(tank, X, theta))
+        for patch, solid in zip(self.solids, self.ship.solid_cargo):
+            patch.set_xy(body.to_world(solid, X, theta))
+        for patch, (liquid, _, _) in zip(self.liquids,
+                                         body.liquids(X, theta)):
+            patch.set_xy(liquid)
+        G = body.centre_of_mass(X, theta)
+        _, _, B = body.hydrostatics(X, theta)
+        self.G.center, self.B.center = G, B
+        self.G_line.set_xdata((G[0], G[0]))
+        self.B_line.set_xdata((B[0], B[0]))
+        self.text.set_text(f'heel {int(round(np.degrees(theta)))}°')
+        return [self.hull, *self.tanks, *self.solids, *self.liquids,
+                self.G_line, self.B_line, self.G, self.B, self.text]
+
+
+def animate(ships, t, states, speed=1):
+    """Return a FuncAnimation of the ships side by side, and their heel.
+
+    states is a list of the arrays of states of each ship at times t; the
+    animation plays at speed times real time.
+
+    """
+
+    # Fix the plot limits so that every ship fits throughout.
+    all_xy = np.vstack([ship.body.world(s[:2], s[2])
+                        for ship, ship_states in zip(ships, states)
+                        for s in ship_states])
+    (xmin, ymin), (xmax, ymax) = all_xy.min(axis=0) - 2, all_xy.max(axis=0) + 2
+
+    n = len(ships)
+    fig = plt.figure(figsize=(max(4 * n, 6), 7), layout='constrained')
+    grid = fig.add_gridspec(2, n, height_ratios=(2, 1))
+    views = []
+    for i, ship in enumerate(ships):
+        ax = fig.add_subplot(grid[0, i])
+        ax.set_xlim(xmin, xmax)
+        ax.set_ylim(ymin, ymax)
+        ax.set_aspect('equal')
+        ax.set_title(ship.title)
+        ax.set_xlabel('x / m')
+        if i == 0:
+            ax.set_ylabel('y / m')
+        views.append(ShipView(ax, ship))
+
+    # The angle of heel of each ship against time, on a scale which shows the
+    # rolling of the stable ships: any ship which capsizes leaves the plot,
+    # unless every ship capsizes.
+    ax = fig.add_subplot(grid[1, :])
+    heel_max = 10
+    any_stable = False
+    for ship, ship_states in zip(ships, states):
+        heel = np.degrees(ship_states[:, 2])
+        label = ship.title
+        if np.abs(heel).max() > 90:
+            label += ' (capsizes)'
+        else:
+            any_stable = True
+            heel_max = max(heel_max, 1.5 * np.abs(heel).max())
+        ax.plot(t, heel, label=label)
+    if not any_stable:
+        heel_max = 1.1 * max(np.degrees(np.abs(s[:, 2])).max() for s in states)
+    ax.axhline(0, c='k', lw=0.5)
+    ax.set_xlim(t[0], t[-1])
+    ax.set_ylim(-heel_max, heel_max)
+    ax.set_xlabel('t / s')
+    ax.set_ylabel('heel / °')
+    ax.legend(loc='upper right')
+    cursor = ax.axvline(0, c='k', lw=1)
+
+    def update(i):
+        cursor.set_xdata((t[i], t[i]))
+        artists = [cursor]
+        for view, ship_states in zip(views, states):
+            artists.extend(view.update(ship_states[i]))
+        return artists
+
+    interval = (t[1] - t[0]) * 1000 / speed
+    return animation.FuncAnimation(fig, update, len(t), blit=True,
+                                   interval=interval)

floating_dynamics/free_surface.py

@@ -0,0 +1,97 @@
+"""Animate the free-surface effect on a small ship carrying cargo.
+
+Three identical coasters carry the same mass of cargo in their cargo spaces:
+as a solid; as a liquid with a free surface across the whole space; and as a
+liquid divided into tanks by longitudinal bulkheads (two, unless --tanks says
+otherwise). Each is heeled slightly (by a gust, say) and released. The
+liquid's free surface reduces the ship's metacentric height, GM: across the
+whole cargo space, it makes GM negative and the ship capsizes. Dividing the
+space into n tanks reduces the effect by a factor of n^2.
+
+Run without a filename to show the animation, or pass one (e.g.
+free-surface.mp4) to save it instead. Use --cargo to show only some of the
+ships, e.g. --cargo free, or --cargo solid --cargo divided.
+
+The cargo is 2.5 m of water by default. With --density, but not --depth, the
+cargo has the same mass whatever its density, so --density 13.6 compares
+mercury with water: its free-surface effect is 13.6 times as large.
+
+"""
+
+import argparse
+import sys
+from .scenario import Scenario, run
+from .ships import CARGOES, CoasterDesign
+
+
+def describe(ship_result):
+    """Print the ship's small-angle stability and its liquids' sloshing."""
+    s = ship_result.summary()
+    roll = f"{s['roll_period']:.1f} s" if s['roll_period'] else 'none (unstable)'
+    print(f"{ship_result.ship.title}: GM = {s['GM']:.2f} m, "
+          f"roll period {roll}")
+    for T in s['sloshing_periods']:
+        print(f'    sloshing period {T:.1f} s')
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog='free-surface', description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument('filename', nargs='?',
+                        help='save the animation to this file')
+    parser.add_argument('--cargo', action='append', choices=CARGOES,
+                        help='how the cargo is carried: solid, free (liquid) '
+                             'or divided (liquid in tanks); repeat it for '
+                             'more than one (default: all three)')
+    parser.add_argument('--heel', type=float, default=5,
+                        help='initial angle of heel (degrees, default 5)')
+    parser.add_argument('--density', type=float, default=1.0,
+                        help='density of the cargo (t/m3, default 1.0: '
+                             'water; mercury is 13.6)')
+    parser.add_argument('--depth', type=float,
+                        help='depth of cargo in the cargo space (m; default '
+                             '2.5 m of water, or the same mass of cargo of '
+                             'another density)')
+    parser.add_argument('--tanks', type=int, default=2,
+                        help='number of tanks in the divided cargo space '
+                             '(default 2)')
+    parser.add_argument('--duration', type=float, default=60,
+                        help='duration of the simulation (s, default 60)')
+    parser.add_argument('--speed', type=float, default=2,
+                        help='playback speed relative to real time (default 2)')
+    args = parser.parse_args()
+
+    # Matplotlib is an optional dependency, needed only here.
+    try:
+        import matplotlib.pyplot as plt
+        from .drawing import animate
+    except ImportError:
+        sys.exit("The animation needs Matplotlib: "
+                 "pip install 'floating-dynamics[animation]'")
+
+    # Unless its depth is given, carry the same mass of cargo whatever its
+    # density, so that different cargoes can be compared.
+    default = CoasterDesign()
+    depth = args.depth or (default.cargo_depth * default.cargo_density
+                           / args.density)
+    scenario = Scenario.from_dict({
+        'cargoes': args.cargo or list(CARGOES),
+        'heel': args.heel, 'duration': args.duration,
+        'design': {'cargo_depth': depth, 'cargo_density': args.density,
+                   'tanks': args.tanks},
+    })
+    print(f'Cargo: {args.density:g} t/m3, {depth:.2f} m deep')
+    result = run(scenario)
+    for ship_result in result.ships:
+        describe(ship_result)
+
+    ani = animate([r.ship for r in result.ships], result.t,
+                  [r.states for r in result.ships], args.speed)
+    if args.filename:
+        ani.save(args.filename)
+    else:
+        plt.show()
+
+
+if __name__ == '__main__':
+    main()

floating_dynamics/geometry.py

@@ -0,0 +1,119 @@
+"""Geometry of two-dimensional polygons.
+
+A polygon is an (N,2) NumPy array of its vertex coordinates, (x, y). The
+first vertex is *not* repeated at the end: the edge from the last vertex back
+to the first is implied. Polygons may be concave, but their edges must not
+cross.
+
+"""
+
+import numpy as np
+from scipy.optimize import brentq
+
+
+def _cross_terms(xy):
+    """Return x_i, y_i, x_{i+1}, y_{i+1} and x_i.y_{i+1} - x_{i+1}.y_i."""
+    x, y = xy.T
+    xn, yn = np.roll(x, -1), np.roll(y, -1)
+    return x, y, xn, yn, x * yn - xn * y
+
+
+def area(xy):
+    """Return the signed area of polygon xy (the "shoelace" formula).
+
+    The area is positive if the vertices are ordered anticlockwise. A
+    polygon with fewer than three vertices has zero area.
+
+    """
+
+    if len(xy) < 3:
+        return 0.0
+    *_, c = _cross_terms(xy)
+    return np.sum(c) / 2
+
+
+def make_ccw(xy):
+    """Return polygon xy with its vertices ordered anticlockwise."""
+    return xy[::-1] if area(xy) < 0 else xy
+
+
+def centroid(xy):
+    """Return the centroid (centre of mass at uniform density) of polygon xy."""
+    A = area(xy)
+    if A == 0:
+        raise ValueError('The centroid of a polygon with zero area is undefined.')
+    x, y, xn, yn, c = _cross_terms(xy)
+    return np.array((np.sum((x + xn) * c), np.sum((y + yn) * c))) / 6 / A
+
+
+def second_moment(xy, P=(0, 0)):
+    """Return the polar second moment of area of polygon xy about point P.
+
+    This is the integral of r^2 over the polygon's area, where r is the
+    distance from P; multiply by the area density to get the moment of inertia
+    about an axis through P perpendicular to the plane. The polygon is assumed
+    to be ordered anticlockwise (otherwise the result is negative).
+
+    """
+
+    x, y, xn, yn, c = _cross_terms(xy - np.asarray(P))
+    Ix = np.sum(c * (y**2 + y * yn + yn**2)) / 12
+    Iy = np.sum(c * (x**2 + x * xn + xn**2)) / 12
+    # Perpendicular axis theorem.
+    return Ix + Iy
+
+
+def rotation_matrix(theta):
+    """Return the matrix for an anticlockwise rotation by theta radians."""
+    s, c = np.sin(theta), np.cos(theta)
+    return np.array(((c, -s), (s, c)))
+
+
+def transform(xy, theta, X=(0, 0)):
+    """Rotate polygon xy by theta about the origin, then translate it by X."""
+    return xy @ rotation_matrix(theta).T + np.asarray(X)
+
+
+def clip_below(xy, level=0.0):
+    """Return the part of polygon xy which lies at or below y = level.
+
+    This is the Sutherland-Hodgman algorithm for a single half-plane. If xy
+    is concave and crosses the line more than twice, the pieces below it are
+    returned as one polygon joined by zero-width "bridges" along y = level:
+    these do not change its area or centroid. If no part of xy is below the
+    line, an empty (0,2) array is returned.
+
+    """
+
+    out = []
+    for P, Q in zip(xy, np.roll(xy, -1, axis=0)):
+        P_below, Q_below = P[1] <= level, Q[1] <= level
+        if P_below:
+            out.append(P)
+        if P_below != Q_below:
+            # This edge crosses the line: add the crossing point.
+            out.append(P + (level - P[1]) / (Q[1] - P[1]) * (Q - P))
+    return np.array(out).reshape(-1, 2)
+
+
+def fill(xy, A):
+    """Return the polygon of a liquid of area A settled in container xy.
+
+    The liquid's surface is level (y = constant), and the liquid is assumed to
+    be connected: if xy is concave, all of its pockets fill to the same level.
+    If A is no less than the area of xy, the liquid fills all of it.
+
+    """
+
+    if A <= 0:
+        return np.empty((0, 2))
+    if A >= area(xy):
+        return xy
+    y = xy[:, 1]
+    level = brentq(lambda h: area(clip_below(xy, h)) - A, y.min(), y.max())
+    return clip_below(xy, level)
+
+
+def cross2(r, F):
+    """Return the z-component of the cross product of 2D vectors r and F."""
+    return r[0] * F[1] - r[1] * F[0]

floating_dynamics/scenario.py

@@ -0,0 +1,170 @@
+"""Set up and run free-surface simulations, returning their results as data.
+
+This is the interface for programs (such as a web page running Pyodide) that
+draw the results themselves: Scenario.from_dict takes the parameters as a
+dict, and Result.to_dict returns everything needed to draw the ships, frame
+by frame, as plain lists, dicts and floats (which convert directly to JSON or
+to JavaScript objects).
+
+Polygons are lists of [x, y] vertices (m). Each ship's outline, tanks and
+solid cargo are given once, in the ship's own frame with its centre of mass G
+at the origin; to draw frame i, rotate them by theta[i] (rad, anticlockwise)
+and translate them by (X[i], Y[i]). The liquids, centre of mass of the ship
+and cargo and centre of buoyancy are given in world coordinates for each
+frame. The sea surface is y = 0.
+
+"""
+
+from dataclasses import dataclass, field, fields, asdict
+import numpy as np
+from .ships import coaster, CoasterDesign, CARGOES
+from .simulation import simulate
+
+
+@dataclass
+class Scenario:
+    """The parameters of a simulation of one or more loaded coasters."""
+
+    design: CoasterDesign = field(default_factory=CoasterDesign)
+    # Which ways of loading the cargo to simulate (keys of CARGOES).
+    cargoes: tuple = tuple(CARGOES)
+    # The initial angle of heel (degrees), the duration of the simulation
+    # and the time between frames (s).
+    heel: float = 5
+    duration: float = 60
+    dt: float = 0.1
+
+    @classmethod
+    def from_dict(cls, d):
+        """Return a Scenario from a dict, e.g. {'heel': 10, 'design': {...}}.
+
+        Missing parameters take their default values; unknown ones raise
+        ValueError.
+
+        """
+
+        d = dict(d)
+        design = d.pop('design', {})
+        _check_keys(cls, d, exclude=('design',))
+        _check_keys(CoasterDesign, design)
+        if 'cargoes' in d:
+            d['cargoes'] = tuple(d['cargoes'])
+        return cls(design=CoasterDesign(**design), **d)
+
+    def to_dict(self):
+        """Return the scenario's parameters as a dict."""
+        d = asdict(self)
+        d['cargoes'] = list(self.cargoes)
+        return d
+
+    def validate(self):
+        """Raise ValueError if the parameters are not sensible."""
+        self.design.validate()
+        for cargo in self.cargoes:
+            if cargo not in CARGOES:
+                raise ValueError(f'Unknown cargo: {cargo}')
+        if not -90 < self.heel < 90:
+            raise ValueError('The initial heel must be between -90 and 90 '
+                             'degrees.')
+        if self.dt <= 0 or self.duration < self.dt:
+            raise ValueError('The duration must be at least one time step.')
+
+
+def _check_keys(cls, d, exclude=()):
+    """Raise ValueError if dict d has keys which are not fields of cls."""
+    names = {f.name for f in fields(cls)} - set(exclude)
+    unknown = set(d) - names
+    if unknown:
+        raise ValueError(f'Unknown parameters for {cls.__name__}: '
+                         + ', '.join(sorted(unknown)))
+
+
+def _polygon(xy, decimals=3):
+    return np.round(xy, decimals).tolist()
+
+
+@dataclass
+class ShipResult:
+    """The simulated motion of one loaded ship."""
+
+    cargo: str
+    ship: object
+    t: np.ndarray
+    states: np.ndarray
+
+    def summary(self):
+        """Return the ship's small-angle stability, as a dict."""
+        body = self.ship.body
+        roll_period = body.roll_period()
+        return {
+            'GM': float(body.metacentric_height()),
+            'roll_period': float(roll_period) if roll_period else None,
+            'sloshing_periods': [float(c.sloshing_period())
+                                 for c in body.compartments],
+            'capsizes': bool(np.abs(self.states[:, 2]).max() > np.pi / 2),
+        }
+
+    def to_dict(self):
+        """Return the ship's geometry and motion, frame by frame."""
+        body = self.ship.body
+        X, Y, theta = self.states[:, :3].T
+        G, B, liquids = [], [], []
+        for x, y, th in zip(X, Y, theta):
+            G.append(body.centre_of_mass((x, y), th))
+            B.append(body.hydrostatics((x, y), th)[2])
+            liquids.append([_polygon(liquid)
+                            for liquid, _, _ in body.liquids((x, y), th)])
+        return {
+            'cargo': self.cargo,
+            'title': self.ship.title,
+            **self.summary(),
+            'outline': _polygon(body.xy0),
+            'tanks': [_polygon(tank - body.G0) for tank in self.ship.tanks],
+            'solids': [_polygon(solid - body.G0)
+                       for solid in self.ship.solid_cargo],
+            'X': np.round(X, 4).tolist(),
+            'Y': np.round(Y, 4).tolist(),
+            'theta': np.round(theta, 5).tolist(),
+            'G': _polygon(G),
+            'B': _polygon(B),
+            'liquids': liquids,
+        }
+
+
+@dataclass
+class Result:
+    """The results of running a Scenario."""
+
+    scenario: Scenario
+    ships: list
+
+    @property
+    def t(self):
+        return self.ships[0].t
+
+    def to_dict(self):
+        """Return the scenario and the results for every ship as a dict."""
+        return {'scenario': self.scenario.to_dict(),
+                't': np.round(self.t, 4).tolist(),
+                'ships': [ship.to_dict() for ship in self.ships]}
+
+
+def run(scenario=None, progress=None):
+    """Run the simulations for scenario (by default, Scenario()).
+
+    progress, if given, is called as progress(i, n) after each of the n ships
+    has been simulated. Returns a Result.
+
+    """
+
+    scenario = scenario or Scenario()
+    scenario.validate()
+    results = []
+    for i, cargo in enumerate(scenario.cargoes):
+        ship = coaster(cargo, scenario.design)
+        t, states = simulate(ship.body, np.radians(scenario.heel),
+                             scenario.duration, scenario.dt)
+        results.append(ShipResult(cargo, ship, t, states))
+        if progress:
+            progress(i + 1, len(scenario.cargoes))
+    return Result(scenario, results)

floating_dynamics/ships.py

@@ -0,0 +1,164 @@
+"""Ship cross-sections and the ways they can be loaded.
+
+A ship's midship section is described in coordinates with the keel at y = 0
+and the centreline at x = 0. Its lightship (the empty ship: steel,
+machinery, outfit) is described as naval architects describe it, by its mass,
+the height of its centre of mass above the keel (KG) and its radius of
+gyration for roll, rather than by the shapes of its parts.
+
+"""
+
+from dataclasses import dataclass, field
+import numpy as np
+from .body import FloatingBody, Compartment, mass_properties, combine
+
+
+def midship_section(beam, depth, bilge_radius, n=8):
+    """Return the outline of a box-shaped section with rounded bilges.
+
+    The bilges are approximated by arcs of n straight segments.
+
+    """
+
+    phi = np.linspace(-np.pi / 2, 0, n + 1)
+    r = bilge_radius
+    starboard = np.column_stack((beam / 2 - r + r * np.cos(phi),
+                                 r + r * np.sin(phi)))
+    port = starboard[::-1] * (-1, 1)
+    deck = [(beam / 2, depth), (-beam / 2, depth)]
+    return np.vstack((starboard, deck, port))
+
+
+def rectangle(x0, y0, x1, y1):
+    """Return the rectangle with corners (x0, y0) and (x1, y1)."""
+    return np.array(((x0, y0), (x1, y0), (x1, y1), (x0, y1)), dtype=float)
+
+
+@dataclass
+class Ship:
+    """A loaded ship: its FloatingBody and the shapes needed to draw it."""
+
+    title: str
+    body: FloatingBody
+    # Polygons (in the section's coordinates) of all the cargo spaces, and
+    # of any solid cargo in them.
+    tanks: list = field(default_factory=list)
+    solid_cargo: list = field(default_factory=list)
+
+
+@dataclass
+class CoasterDesign:
+    """The design and loading of a small coaster.
+
+    Lengths are in m, densities in t.m-3 and masses in t per metre of the
+    ship's length. The defaults give a GM of 1.0 m with solid cargo.
+
+    """
+
+    # The midship section: its beam, depth to the main deck and bilge radius.
+    beam: float = 16
+    depth: float = 9
+    bilge_radius: float = 2
+    # The cargo space, between the double bottom, wing tanks and deck:
+    # its half-width and the heights of its floor and ceiling above the keel.
+    hold_half_width: float = 6
+    hold_bottom: float = 1.5
+    hold_top: float = 8.5
+    # The lightship's mass, KG and radius of gyration for roll (if None,
+    # 0.4 times the beam, a typical value).
+    lightship_mass: float = 66
+    lightship_kg: float = 7.0
+    roll_gyradius: float | None = None
+    # The cargo's depth in the cargo space when upright, and its density.
+    cargo_depth: float = 2.5
+    cargo_density: float = 1.0
+    # The number of tanks, separated by longitudinal bulkheads, into which the
+    # cargo space is divided when the cargo is 'divided'.
+    tanks: int = 2
+    # Hydrodynamic coefficients: the added mass for heave (as a fraction of
+    # the ship's mass) and the added moment of inertia for roll (as a fraction
+    # of the lightship's), and damping rates (s-1), for damping ratios of
+    # about 0.3 in heave and 0.07 in roll.
+    added_mass: float = 1.0
+    added_inertia: float = 0.2
+    heave_damping: float = 0.5
+    roll_damping: float = 0.07
+
+    def validate(self):
+        """Raise ValueError if the design is not physically sensible."""
+        positive = ('beam', 'depth', 'lightship_mass', 'cargo_density',
+                    'hold_half_width')
+        for name in positive:
+            if getattr(self, name) <= 0:
+                raise ValueError(f'{name} must be positive.')
+        if not 0 <= self.bilge_radius <= min(self.beam / 2, self.depth):
+            raise ValueError('The bilge radius does not fit the section.')
+        if self.hold_half_width > self.beam / 2 - self.bilge_radius:
+            raise ValueError('The cargo space is wider than the flat of '
+                             'the hull.')
+        if not 0 <= self.hold_bottom < self.hold_top <= self.depth:
+            raise ValueError('The cargo space must lie between the keel '
+                             'and the main deck.')
+        if not 0 < self.cargo_depth <= self.hold_top - self.hold_bottom:
+            raise ValueError('The cargo does not fit in the cargo space.')
+        if self.tanks < 1 or self.tanks != int(self.tanks):
+            raise ValueError('The number of tanks must be a positive '
+                             'integer.')
+        if self.roll_gyradius is not None and self.roll_gyradius <= 0:
+            raise ValueError('roll_gyradius must be positive.')
+
+
+CARGOES = {
+    'solid': 'Solid cargo',
+    'free': 'Liquid cargo',
+    'divided': 'Liquid cargo, divided tank',
+}
+
+
+def coaster(cargo='free', design=None):
+    """Return the coaster carrying cargo of the same mass in different ways.
+
+    design is a CoasterDesign (by default, CoasterDesign()). The cargo fills
+    its cargo space to design.cargo_depth, when upright, and is either:
+        'solid': solid (a liquid frozen solid, say), so it cannot move;
+        'free': a liquid with a free surface across the whole cargo space;
+        'divided': a liquid in a cargo space divided into design.tanks
+                   tanks by longitudinal watertight bulkheads.
+
+    """
+
+    d = design or CoasterDesign()
+    d.validate()
+    outline = midship_section(d.beam, d.depth, d.bilge_radius)
+    k = d.roll_gyradius or 0.4 * d.beam
+    lightship = (d.lightship_mass, (0, d.lightship_kg),
+                 d.lightship_mass * k**2)
+    hydrodynamics = {'added_mass': d.added_mass,
+                     'added_inertia': d.added_inertia,
+                     'heave_damping': d.heave_damping,
+                     'roll_damping': d.roll_damping}
+    x0, x1 = -d.hold_half_width, d.hold_half_width
+    y0, y1 = d.hold_bottom, d.hold_top
+    space = rectangle(x0, y0, x1, y1)
+    A_cargo = (x1 - x0) * d.cargo_depth
+
+    if cargo == 'solid':
+        solid = rectangle(x0, y0, x1, y0 + d.cargo_depth)
+        M, G, Iz = combine(lightship, mass_properties(solid, d.cargo_density))
+        body = FloatingBody(outline, M, G, Iz, **hydrodynamics)
+        return Ship(CARGOES[cargo], body, [space], [solid])
+    if cargo == 'free':
+        tanks = [space]
+    elif cargo == 'divided':
+        x = np.linspace(x0, x1, d.tanks + 1)
+        tanks = [rectangle(xa, y0, xb, y1) for xa, xb in zip(x[:-1], x[1:])]
+    else:
+        raise ValueError(f'Unknown cargo: {cargo}')
+    compartments = [Compartment(tank, A_cargo / len(tanks), d.cargo_density)
+                    for tank in tanks]
+    body = FloatingBody(outline, *lightship, compartments=compartments,
+                        **hydrodynamics)
+    title = CARGOES[cargo]
+    if cargo == 'divided' and d.tanks != 2:
+        title = f'Liquid cargo, {d.tanks} tanks'
+    return Ship(title, body, tanks)

floating_dynamics/simulation.py

@@ -0,0 +1,22 @@
+"""Integrate the motion of a floating body."""
+
+import numpy as np
+from scipy.integrate import solve_ivp
+
+
+def simulate(body, theta0, t_max, dt):
+    """Integrate the motion of body, released from rest at angle theta0.
+
+    The body starts floating at its equilibrium height for theta0. Its state
+    is returned at intervals of dt up to time t_max (s), as the arrays t and
+    states, whose rows are the state vectors (X, Y, theta, U, V, omega).
+
+    """
+
+    y0 = (0, body.equilibrium_height(theta0), theta0, 0, 0, 0)
+    t = np.arange(0, t_max + dt / 2, dt)
+    sol = solve_ivp(body.rhs, (0, t_max), y0, t_eval=t, max_step=dt,
+                    rtol=1e-6, atol=1e-8)
+    if not sol.success:
+        raise RuntimeError(sol.message)
+    return sol.t, sol.y.T

floating_dynamics-0.1.0.dist-info/METADATA

@@ -0,0 +1,167 @@
+Metadata-Version: 2.4
+Name: floating-dynamics
+Version: 0.1.0
+Summary: Two-dimensional dynamics of floating bodies, including the free-surface effect of liquid cargo.
+Author: Christian Hill
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/xnx/floating-dynamics
+Project-URL: Issues, https://github.com/xnx/floating-dynamics/issues
+Keywords: ship stability,free-surface effect,metacentric height,buoyancy,simulation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Provides-Extra: animation
+Requires-Dist: matplotlib; extra == "animation"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# floating-dynamics
+
+Two-dimensional dynamics of ships floating in the sea (cross-sections, per
+metre of length), including the *free-surface effect* of liquid cargo.
+
+The demonstration compares three identical coasters carrying the same mass of
+cargo: as a solid, as a liquid free to move across the whole hold, and as a
+liquid divided into tanks. Each is heeled slightly and released. The liquid's
+free surface reduces the ship's metacentric height, GM, so the ship with the
+undivided hold capsizes, while dividing the hold into n tanks reduces the
+effect by a factor of n².
+
+With the default cargo, 2.5 m of water (30 t per metre of the ship's
+length), heeled by 5°:
+
+| Cargo              | GM      | Roll period | Outcome            |
+|--------------------|---------|-------------|--------------------|
+| Solid              | 1.00 m  | 13.2 s      | rolls, and settles |
+| Liquid             | −0.50 m | –           | capsizes in ~12 s  |
+| Liquid, two tanks  | 0.63 m  | 16.5 s      | rolls, and settles |
+
+## Trying it out
+
+Install it with the animation extra (which adds Matplotlib), and run the
+demonstration:
+
+    pip install 'floating-dynamics[animation]'
+    free-surface
+
+or, with [uv](https://docs.astral.sh/uv/), without installing anything:
+
+    uvx --from 'floating-dynamics[animation]' free-surface
+
+Options choose which ships to show, and set the initial heel, the cargo's
+density and depth and the number of tanks, or save the animation instead of
+showing it:
+
+    free-surface --cargo free                      # one ship
+    free-surface --cargo solid --cargo divided     # two of them
+    free-surface --heel 10 --depth 2 --tanks 3
+    free-surface --density 13.6                    # mercury
+    free-surface free-surface.mp4                  # save the animation
+    free-surface --help
+
+`python -m floating_dynamics` does the same as `free-surface`.
+
+### Denser cargoes
+
+`--density` sets the cargo's density in t/m³. Unless `--depth` is also
+given, the cargo's mass stays the same (2.5 m of water would weigh 13.6 times
+as much as mercury, and sink the ship), so its depth is reduced instead. The
+free-surface effect depends on the width of the liquid's surface but not its
+depth, so for the same mass of cargo it grows in proportion to the density:
+
+| Cargo (30 t/m)     | Water: GM | Outcome           | Mercury: GM | Outcome           |
+|--------------------|-----------|-------------------|-------------|-------------------|
+| Solid              | 1.00 m    | stable            | 1.37 m      | stable            |
+| Liquid             | −0.50 m   | capsizes in ~12 s | −19.0 m     | capsizes in ~4.5 s |
+| Liquid, two tanks  | 0.63 m    | stable            | −3.7 m      | lolls at about 24° |
+
+The mercury in two tanks makes GM negative, but the ship does not capsize: it
+heels until its wider waterline makes up the difference, and settles at an
+*angle of loll*. A layer of mercury only 0.18 m deep sloshes slowly, though,
+so these timings are less reliable than water's (see Assumptions).
+
+## Using it from Python
+
+`floating_dynamics.scenario` sets the parameters, runs the simulations and
+returns the results as plain data (lists, dicts and floats), for programs
+which draw the ships themselves, such as a web page running
+[Pyodide](https://pyodide.org):
+
+```python
+from floating_dynamics.scenario import Scenario, run
+
+scenario = Scenario.from_dict({'heel': 10, 'cargoes': ['free', 'divided'],
+                               'design': {'cargo_depth': 2, 'tanks': 3}})
+result = run(scenario)
+for ship in result.ships:
+    print(ship.ship.title, ship.summary())
+data = result.to_dict()        # JSON-serialisable
+```
+
+The main parameters, with their defaults, are:
+
+| Parameter              | Default                       | Meaning                                       |
+|------------------------|-------------------------------|-----------------------------------------------|
+| `cargoes`              | `['solid', 'free', 'divided']`| which ships to simulate                       |
+| `heel`                 | 5                             | initial heel (degrees)                        |
+| `duration`, `dt`       | 60, 0.1                       | length of the simulation, time per frame (s)  |
+| `design.cargo_depth`   | 2.5                           | depth of cargo when upright (m)               |
+| `design.cargo_density` | 1.0                           | density of cargo (t/m³)                       |
+| `design.tanks`         | 2                             | number of tanks for the `'divided'` cargo     |
+
+Unlike `free-surface --density`, setting `cargo_density` here does not change
+the depth: set `cargo_depth` too to keep the mass the same. The ship's
+dimensions, lightship mass and hydrodynamic coefficients are also fields of
+`CoasterDesign` (in `floating_dynamics.ships`), with comments. Unknown or
+unphysical parameters raise `ValueError`. The format of the results is
+described in `scenario.py`. Only NumPy and SciPy are needed for this.
+
+## Modules
+
+- `geometry`: polygon area, centroid, second moment, clipping and filling.
+- `body`: `FloatingBody` (hydrostatics, equations of motion, righting lever,
+  metacentric height) and `Compartment` (a tank of liquid).
+- `ships`: a coaster's midship section and its three ways of carrying cargo.
+- `simulation`: integrating the motion with SciPy's `solve_ivp`.
+- `scenario`: the parameters and results, as plain data.
+- `drawing`: animating ships side by side, with their heel against time.
+- `free_surface`: the command-line demonstration.
+
+## Assumptions
+
+- The motion is two-dimensional: a cross-section of a long ship, rolling and
+  heaving but not pitching.
+- The liquid's surface stays level (quasi-static). This is reasonable while
+  the liquid sloshes much faster than the ship rolls; the demonstration
+  prints both periods. Shallow layers slosh slowly (the 0.18 m of mercury
+  above takes 18 s across the whole hold), and then the real liquid would lag
+  behind the roll, so the motion would develop more slowly. Whether the ship
+  is stable depends only on GM, which is unaffected.
+- The hull is watertight up to its main deck: there is no flooding, so a
+  capsized ship floats upside down.
+- The surrounding water is represented by added mass and linear damping.
+
+## Development
+
+    git clone https://github.com/xnx/floating-dynamics
+    cd floating-dynamics
+    pip install -e '.[animation,test]'
+    pytest
+
+The editable install (`-e`) uses the source files directly, so changes take
+effect without reinstalling. To run the demonstration without installing at
+all, from the project folder:
+
+    PYTHONPATH=src python -m floating_dynamics
+
+## Licence
+
+MIT: see `LICENSE`.

floating_dynamics-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+floating_dynamics/__init__.py,sha256=bKqlRxPA5Nu6GmlmgcT5xiSmtsj77XP3bvq05yycI6Y,125
+floating_dynamics/__main__.py,sha256=9ymqIlAO3w0bsd6IbDK8oUpZ8gLsCBNSBWin5Jo1948,115
+floating_dynamics/body.py,sha256=b0KoJ4FLDsgEdQ6-laCdug4iAfDcLlUHGERgJlNVvlo,10926
+floating_dynamics/drawing.py,sha256=XaOTvvsJUrMfNmQB_SyJkkPgfZrG1hO3r3oG2CWxxk8,5433
+floating_dynamics/free_surface.py,sha256=FTdoQU0U_X2qeUku9paQ_n94hEr7wb7y_mK-L-2HNis,4350
+floating_dynamics/geometry.py,sha256=Y0W2YX2wGpyJ5c95H_ynq-eBLrW-J6TwQnUlu_sSCXM,3812
+floating_dynamics/scenario.py,sha256=r8tAXiBcRygr8TGhXj3GQ6JOHLS6a2HgtkcJowL6-64,5938
+floating_dynamics/ships.py,sha256=CbQF_3C8a0PaKdUo1LLqSBT4NOBpevt1ADC4nhkzFBg,6672
+floating_dynamics/simulation.py,sha256=JrUsjrflqKYVI0fZ0b7R2OQqiBUGbqslf68q_0JMLjU,762
+floating_dynamics-0.1.0.dist-info/licenses/LICENSE,sha256=fwbJgWO5bKz_xUdjqMYqZpZFe_S4cz1gS9j8chkHd_o,1071
+floating_dynamics-0.1.0.dist-info/METADATA,sha256=BfRxS8Myhen0NlfdhV30C5Sk_qxX-nw5Q2mx4Yb9SjI,7657
+floating_dynamics-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+floating_dynamics-0.1.0.dist-info/entry_points.txt,sha256=cQaTG-MWizDUAyqPOPlYsy8s8yVWIO3VaAKqTEE_IUA,69
+floating_dynamics-0.1.0.dist-info/top_level.txt,sha256=pWFiphkvjolW_yfF6DGO9sU9trEJuqOSjIsyrRPA1Yg,18
+floating_dynamics-0.1.0.dist-info/RECORD,,

floating_dynamics-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

floating_dynamics-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+free-surface = floating_dynamics.free_surface:main

floating_dynamics-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Christian Hill
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

floating_dynamics-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+floating_dynamics