floating-dynamics 0.1.0__tar.gz

floating_dynamics-0.1.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,142 @@
+# 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/pyproject.toml

@@ -0,0 +1,42 @@
+[project]
+name = "floating-dynamics"
+dynamic = ["version"]
+description = "Two-dimensional dynamics of floating bodies, including the free-surface effect of liquid cargo."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Christian Hill" }]
+requires-python = ">=3.10"
+keywords = ["ship stability", "free-surface effect", "metacentric height",
+            "buoyancy", "simulation"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Education",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Physics",
+]
+# Matplotlib is needed only for the command-line animation (drawing.py and
+# free_surface.py), not for the simulations or the scenario API.
+dependencies = ["numpy", "scipy"]
+
+[project.optional-dependencies]
+animation = ["matplotlib"]
+test = ["pytest"]
+
+[project.scripts]
+free-surface = "floating_dynamics.free_surface:main"
+
+[project.urls]
+Homepage = "https://github.com/xnx/floating-dynamics"
+Issues = "https://github.com/xnx/floating-dynamics/issues"
+
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.dynamic]
+version = { attr = "floating_dynamics.__version__" }
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

floating_dynamics-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

floating_dynamics-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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))