planetmodel 1.0.0__tar.gz

planetmodel-1.0.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, David Al-Attar
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

planetmodel-1.0.0/PKG-INFO

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: planetmodel
+Version: 1.0.0
+Summary: Spherically layered planetary models: reference bodies, fields, mappings and meshes
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Keywords: geophysics,seismology,planetary models,PREM,spectral elements,meshing
+Author: David Al-Attar
+Author-email: da380@cam.ac.uk
+Requires-Python: >=3.12
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Physics
+Provides-Extra: harmonics
+Provides-Extra: meshing
+Provides-Extra: mfem
+Provides-Extra: netcdf
+Provides-Extra: notebook
+Provides-Extra: plot
+Requires-Dist: ducc0 (>=0.41) ; extra == "harmonics"
+Requires-Dist: gmsh (>=4.13) ; extra == "meshing"
+Requires-Dist: ipykernel (>=6.29) ; extra == "notebook"
+Requires-Dist: matplotlib (>=3.11,<4) ; extra == "plot"
+Requires-Dist: mfem (>=4.8) ; extra == "mfem"
+Requires-Dist: netCDF4 (>=1.7) ; extra == "netcdf"
+Requires-Dist: numpy (>=2.5,<3)
+Requires-Dist: pyshtools (>=4.14) ; extra == "harmonics"
+Requires-Dist: scipy (>=1.18,<2)
+Project-URL: Homepage, https://github.com/da380/planetmodel
+Project-URL: Repository, https://github.com/da380/planetmodel
+Description-Content-Type: text/markdown
+
+# planetmodel
+
+Spherically layered planetary models: a skeleton of boundary radii, a
+geometry that places it in the physical world through one continuous
+mapping, fields on each layer, and the meshes that hand a model to a
+solver.
+
+The library covers the skeleton, the geometry and its mappings; fields
+on one interval with an exact polynomial algebra; the model with its
+units, named model types (PREM from its polynomials, simple layered
+models, any mineos deck) and the mixins that complete them with moduli,
+velocities, gravity and linear rheologies; a radial spectral-element
+mesh; 2D and 3D meshes via gmsh with a manifest and export to MFEM; and
+two sub-packages that consume the radial mesh: `planetmodel.loading`
+solves the loading and tidal problem and gives Love numbers, and
+`planetmodel.randomfield` draws Matern random fields on balls, annuli
+and layers. A netCDF file for 3D models is next.
+
+## The ideas
+
+**A skeleton.** A strictly increasing list of boundary radii, possibly
+starting above zero for a shell. It answers geometric questions
+(intervals, where a radius lies, with the two sides of a boundary left to
+the caller) and supports surgery: refine, truncate, hollow, extend,
+coarsen.
+
+**A geometry.** A skeleton, one mapping from the reference ball to the
+physical body, and the names of layers and interfaces. The mapping must
+be orientation-preserving, continuous, and kinked only on skeleton
+boundaries; a geometry checks those invariants when it is built. The
+shipped mapping is the radial stretch `m(X) = (r + h) e_r` driven by any
+callable `h(r, theta, phi)`, with closed forms for its deformation
+gradient, Jacobian, validity, inverse and linearisation; any object with
+`__call__`, `deformation_gradient` and `jacobian` is a mapping.
+
+**A field on one interval.** Data on one layer: an interval, a character
+(the tensor rank and weight that say how it transforms), a name, and
+`evaluate(r, theta, phi, *, frame)` giving components in the local
+spherical frame or in Cartesian ones. A discontinuity is two layers
+asked separately. Radial fields sit on layer functions whose algebra is
+exact on polynomials, so PREM's moduli `rho v^2` are exact polynomials;
+analytic formulas, pointwise compositions, and fields pushed forward
+through a mapping are fields too. A field may be complex-valued, which
+is what a model frozen at a frequency holds.
+
+**One model class.** A geometry with a bag of fields on every layer.
+What a name means comes from the shipped vocabulary or the specs a model
+is given. A model type (`PREM`, `LayeredIsotropicElastic`, `MineosModel`,
+or your own) is a class derived from `Model` alone; the mixins of
+`planetmodel.behaviours` add the shared derivations as methods, written
+once as free functions: the Love moduli beside the velocities, the
+elastic tensor and its Voigt average, gravity, and the constant-Q and
+Maxwell rheologies frozen at a frequency.
+
+**Units in one place.** The model's `Scales` say what one stored unit
+is in SI, and `converted` re-expresses the whole model by name, exactly
+for polynomials; `G` is read in the model's units. Nothing else names a
+unit: radii are numbers, every tolerance is relative, and the meshers
+hand the geometry's numbers to gmsh unchanged.
+
+**Two meshers.** `planetmodel.mesh1d` lays Gauss-Lobatto-Legendre
+elements along the radius with every skeleton boundary an element
+boundary, evaluates a model's fields and gravity on its nodes, and
+samples a model on an angular grid. `planetmodel.mesh3d` meshes a
+geometry, full or hollow, in 2D or 3D, with shells outside it, writes a
+JSON manifest saying what every attribute means, and exports the mesh,
+the mapping's displacement and the model's fields to MFEM.
+
+**Executable contracts.** `planetmodel.testing` holds one `check_*`
+function per protocol; the shipped implementations and yours are held to
+the same call.
+
+## Installing
+
+```
+pip install planetmodel                     # numpy and scipy only
+pip install 'planetmodel[meshing]'          # 2D and 3D meshes via gmsh
+pip install 'planetmodel[mfem]'             # export to MFEM (PyMFEM)
+pip install 'planetmodel[harmonics]'        # grid transforms via pyshtools and ducc0
+pip install 'planetmodel[plot]'             # matplotlib, for the figures
+pip install 'planetmodel[notebook]'         # ipykernel, to run tutorials cell by cell
+```
+
+Python 3.12 or later. Nothing optional is imported by `import
+planetmodel`.
+
+## Twelve lines
+
+```python
+import numpy as np
+from planetmodel import PREM, RadialMesh, flattening, gravity
+
+m = PREM()                                                  # exact polynomials, SI
+oc, mantle = m.layer("outer_core"), m.layer("lowermost_mantle")
+cmb = m.geometry.interface("cmb").radius
+print(oc["rho"](cmb), mantle["rho"](cmb), m.is_fluid("outer_core"))  # both sides
+print(m.elastic_moduli("lowermost_mantle")(cmb, 0.3, 0.0)[:3, :3] / 1e9)  # Voigt, GPa
+print(gravity(m, [cmb, 6371e3]), m.moduli_at("lower_mantle", 2 * np.pi / 3600)["L"](5e6))
+
+nd = m.nondimensionalised().stretched(flattening(1 / 300, rmax=1.0))
+mesh = RadialMesh(nd, ngll=5, drmax=0.05)
+print(nd.G, mesh.nodal(nd, "rho").shape, nd.geometry.validity())
+```
+
+## Where to go next
+
+- `examples/tutorials/`: twelve walkthroughs, from a skeleton to Love
+  numbers, random fields and deck files, each a `# %%` script that runs
+  headless.
+- `src/planetmodel/mesh3d/manifest.py`: the manifest beside every mesh,
+  its schema described from the consumer's side.
+- `CONTRIBUTING.md`: the development setup, the hooks, the test
+  selections and how a release is made.
+
+## Tests
+
+```
+poetry run pytest                                   # the fast suite
+poetry run pytest -m "not slow"                     # with gmsh and MFEM
+poetry run ruff check .
+```
+
+## Licence
+
+BSD-3
+

planetmodel-1.0.0/README.md

@@ -0,0 +1,125 @@
+# planetmodel
+
+Spherically layered planetary models: a skeleton of boundary radii, a
+geometry that places it in the physical world through one continuous
+mapping, fields on each layer, and the meshes that hand a model to a
+solver.
+
+The library covers the skeleton, the geometry and its mappings; fields
+on one interval with an exact polynomial algebra; the model with its
+units, named model types (PREM from its polynomials, simple layered
+models, any mineos deck) and the mixins that complete them with moduli,
+velocities, gravity and linear rheologies; a radial spectral-element
+mesh; 2D and 3D meshes via gmsh with a manifest and export to MFEM; and
+two sub-packages that consume the radial mesh: `planetmodel.loading`
+solves the loading and tidal problem and gives Love numbers, and
+`planetmodel.randomfield` draws Matern random fields on balls, annuli
+and layers. A netCDF file for 3D models is next.
+
+## The ideas
+
+**A skeleton.** A strictly increasing list of boundary radii, possibly
+starting above zero for a shell. It answers geometric questions
+(intervals, where a radius lies, with the two sides of a boundary left to
+the caller) and supports surgery: refine, truncate, hollow, extend,
+coarsen.
+
+**A geometry.** A skeleton, one mapping from the reference ball to the
+physical body, and the names of layers and interfaces. The mapping must
+be orientation-preserving, continuous, and kinked only on skeleton
+boundaries; a geometry checks those invariants when it is built. The
+shipped mapping is the radial stretch `m(X) = (r + h) e_r` driven by any
+callable `h(r, theta, phi)`, with closed forms for its deformation
+gradient, Jacobian, validity, inverse and linearisation; any object with
+`__call__`, `deformation_gradient` and `jacobian` is a mapping.
+
+**A field on one interval.** Data on one layer: an interval, a character
+(the tensor rank and weight that say how it transforms), a name, and
+`evaluate(r, theta, phi, *, frame)` giving components in the local
+spherical frame or in Cartesian ones. A discontinuity is two layers
+asked separately. Radial fields sit on layer functions whose algebra is
+exact on polynomials, so PREM's moduli `rho v^2` are exact polynomials;
+analytic formulas, pointwise compositions, and fields pushed forward
+through a mapping are fields too. A field may be complex-valued, which
+is what a model frozen at a frequency holds.
+
+**One model class.** A geometry with a bag of fields on every layer.
+What a name means comes from the shipped vocabulary or the specs a model
+is given. A model type (`PREM`, `LayeredIsotropicElastic`, `MineosModel`,
+or your own) is a class derived from `Model` alone; the mixins of
+`planetmodel.behaviours` add the shared derivations as methods, written
+once as free functions: the Love moduli beside the velocities, the
+elastic tensor and its Voigt average, gravity, and the constant-Q and
+Maxwell rheologies frozen at a frequency.
+
+**Units in one place.** The model's `Scales` say what one stored unit
+is in SI, and `converted` re-expresses the whole model by name, exactly
+for polynomials; `G` is read in the model's units. Nothing else names a
+unit: radii are numbers, every tolerance is relative, and the meshers
+hand the geometry's numbers to gmsh unchanged.
+
+**Two meshers.** `planetmodel.mesh1d` lays Gauss-Lobatto-Legendre
+elements along the radius with every skeleton boundary an element
+boundary, evaluates a model's fields and gravity on its nodes, and
+samples a model on an angular grid. `planetmodel.mesh3d` meshes a
+geometry, full or hollow, in 2D or 3D, with shells outside it, writes a
+JSON manifest saying what every attribute means, and exports the mesh,
+the mapping's displacement and the model's fields to MFEM.
+
+**Executable contracts.** `planetmodel.testing` holds one `check_*`
+function per protocol; the shipped implementations and yours are held to
+the same call.
+
+## Installing
+
+```
+pip install planetmodel                     # numpy and scipy only
+pip install 'planetmodel[meshing]'          # 2D and 3D meshes via gmsh
+pip install 'planetmodel[mfem]'             # export to MFEM (PyMFEM)
+pip install 'planetmodel[harmonics]'        # grid transforms via pyshtools and ducc0
+pip install 'planetmodel[plot]'             # matplotlib, for the figures
+pip install 'planetmodel[notebook]'         # ipykernel, to run tutorials cell by cell
+```
+
+Python 3.12 or later. Nothing optional is imported by `import
+planetmodel`.
+
+## Twelve lines
+
+```python
+import numpy as np
+from planetmodel import PREM, RadialMesh, flattening, gravity
+
+m = PREM()                                                  # exact polynomials, SI
+oc, mantle = m.layer("outer_core"), m.layer("lowermost_mantle")
+cmb = m.geometry.interface("cmb").radius
+print(oc["rho"](cmb), mantle["rho"](cmb), m.is_fluid("outer_core"))  # both sides
+print(m.elastic_moduli("lowermost_mantle")(cmb, 0.3, 0.0)[:3, :3] / 1e9)  # Voigt, GPa
+print(gravity(m, [cmb, 6371e3]), m.moduli_at("lower_mantle", 2 * np.pi / 3600)["L"](5e6))
+
+nd = m.nondimensionalised().stretched(flattening(1 / 300, rmax=1.0))
+mesh = RadialMesh(nd, ngll=5, drmax=0.05)
+print(nd.G, mesh.nodal(nd, "rho").shape, nd.geometry.validity())
+```
+
+## Where to go next
+
+- `examples/tutorials/`: twelve walkthroughs, from a skeleton to Love
+  numbers, random fields and deck files, each a `# %%` script that runs
+  headless.
+- `src/planetmodel/mesh3d/manifest.py`: the manifest beside every mesh,
+  its schema described from the consumer's side.
+- `CONTRIBUTING.md`: the development setup, the hooks, the test
+  selections and how a release is made.
+
+## Tests
+
+```
+poetry run pytest                                   # the fast suite
+poetry run pytest -m "not slow"                     # with gmsh and MFEM
+poetry run ruff check .
+```
+
+## Licence
+
+BSD-3

planetmodel-1.0.0/pyproject.toml

@@ -0,0 +1,82 @@
+[project]
+name = "planetmodel"
+version = "1.0.0"
+description = "Spherically layered planetary models: reference bodies, fields, mappings and meshes"
+keywords = ["geophysics", "seismology", "planetary models", "PREM", "spectral elements", "meshing"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Physics",
+]
+authors = [
+    {name = "David Al-Attar",email = "da380@cam.ac.uk"}
+]
+readme = "README.md"
+license = "BSD-3-Clause"
+license-files = ["LICENSE"]
+requires-python = ">=3.12"
+dependencies = [
+    "numpy>=2.5,<3",
+    "scipy>=1.18,<2",
+]
+
+[project.urls]
+Homepage = "https://github.com/da380/planetmodel"
+Repository = "https://github.com/da380/planetmodel"
+
+[project.optional-dependencies]
+meshing = ["gmsh>=4.13"]
+mfem = ["mfem>=4.8"]
+netcdf = ["netCDF4>=1.7"]
+plot = ["matplotlib>=3.11,<4"]
+notebook = ["ipykernel>=6.29"]
+harmonics = ["pyshtools (>=4.14)", "ducc0 (>=0.41)"]
+
+[dependency-groups]
+dev = [
+    "pytest>=9",
+    "ruff>=0.6",
+    "pre-commit (>=4)",
+    "pytest-cov (>=6)",
+]
+
+[tool.poetry]
+packages = [{include = "planetmodel", from = "src"}]
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+norecursedirs = ["archive", ".*", "build", "dist"]
+# The fast suite is the default: it needs numpy and scipy alone, and the
+# `plot` and `harmonics` extras where installed.  `-m "not slow"` adds the
+# gmsh unit geometries and the MFEM exports, `-m ""` everything.
+addopts = "-m 'not gmsh and not mfem and not slow'"
+markers = [
+    "slow: long-running tests (minutes); deselect with -m 'not slow'",
+    "gmsh: requires the optional gmsh dependency (planetmodel[meshing])",
+    "mfem: requires PyMFEM (planetmodel[mfem])",
+    "harmonics: requires pyshtools (planetmodel[harmonics])",
+]
+
+[tool.ruff]
+line-length = 88
+src = ["src", "tests"]
+extend-exclude = ["archive"]
+
+[tool.ruff.lint]
+select = ["E", "F", "W"]
+# Deliberate house style, not defects:
+#   E741  `l` is the spherical-harmonic degree and `I` an integral -- the
+#         standard symbols in this field, used consistently throughout.
+#   E702  paired assignments to symmetric matrix entries are written on one
+#         line so the symmetry is visible.
+#   E731  short lambdas bound to names read as the mathematical definitions
+#         they are (fitters, coefficient functions).
+ignore = ["E741", "E702", "E731"]

planetmodel-1.0.0/src/planetmodel/__init__.py

@@ -0,0 +1,208 @@
+"""planetmodel: spherically layered planetary models, and their meshes.
+
+A model is a skeleton of boundary radii, a geometry that places the
+skeleton in the physical world through one continuous mapping, and a
+bag of fields on each layer.  This package holds the skeleton and the
+geometry, the mappings that place them, the fields and the model, the
+catalogue of named models, and the meshers that hand a model to a
+solver.  Every internal is numbers: the model alone carries units.
+
+Modules reached by name, one level down:
+
+  frames       the local spherical frame, tensors moved between frames, Voigt
+  materials    velocity and moduli conversions, the elastic field, what a
+               layer's fields imply (fluidity, moduli)
+  rheology     what a layer's rheology fields imply, and a model frozen at
+               a frequency with complex moduli
+  units        Dimensions, Scales and the dimension constants
+  vocabulary   the shipped field names, their characters and dimensions
+  behaviours   the free functions as methods: `layer_method` and the mixins
+  catalogue    PREM, LayeredIsotropicElastic and MineosModel, model types
+  deck         tabulated models: decks, their formats, fields by interpolation
+  sampling     a model on a radial mesh times an angular grid
+  harmonics    real spherical harmonics; grid transforms via pyshtools (optional)
+  plotting     radial profiles drawn one way, radius upward (matplotlib, optional)
+  mesh1d       radial spectral-element meshes (GLL), nodal values, gravity
+  mesh3d       2D and 3D meshes via gmsh, and MFEM export
+  loading      the loading and tidal problem on a radial mesh: Love numbers
+  randomfield  Matern random fields on balls, annuli and layers
+  testing      the executable contracts, `check_field` and its kin
+"""
+
+from .behaviours import (
+    ConstantQ,
+    Elastic,
+    SelfGravitating,
+    Viscoelastic,
+    layer_method,
+    with_moduli,
+    with_velocities,
+)
+from .catalogue import PREM, LayeredIsotropicElastic, MineosModel
+from .character import DENSITY, ELASTIC, SCALAR, STRESS, VECTOR, Character, Symmetry
+from .deck import (
+    MINEOS,
+    Deck,
+    DeckFormat,
+    Tabulated,
+    deck_layers,
+    read_deck,
+    write_deck,
+)
+from .displacement import (
+    CallableDisplacement,
+    RadialDisplacement,
+    ZeroDisplacement,
+    as_displacement,
+    flattening,
+    layer_linear,
+)
+from .fields import (
+    AnalyticField,
+    ComposedField,
+    Field,
+    FieldBase,
+    RadialField,
+    constant_field,
+)
+from .geometry import Geometry, InterfaceInfo, LayerInfo
+from .harmonics import analyse_grid, real_harmonics, synthesise, synthesise_grid
+from .layerfunction import (
+    LayerFunction,
+    NumericLayer,
+    PolynomialLayer,
+    as_layer_function,
+    constant_layer,
+    polynomial_fit,
+    polynomial_layer,
+)
+from .mapping import (
+    IdentityMapping,
+    Mapping,
+    MappingBase,
+    MappingPerturbation,
+    RadialStretch,
+    ScaledMapping,
+    ValidityReport,
+    outer_radius_of,
+    validity_lattice,
+)
+from .materials import ElasticField, elastic_moduli, is_fluid, kappa_mu, moduli
+from .mesh1d import RadialMesh
+from .mesh1d.gravity import gravity, gravity_fields, mass
+from .model import Layer, Model
+from .pushforward import PulledBackField, PushedForwardField, pull_back, push_forward
+from .rheology import (
+    dispersive_moduli,
+    frozen,
+    frozen_moduli,
+    is_viscoelastic,
+    reference_omega,
+)
+from .sampling import AngularGrid, Sample, equiangular, gauss_legendre, sample
+from .skeleton import CoarseningMap, Location, Skeleton
+from .units import EARTH_MEAN_DENSITY, G_SI, Dimensions, Scales
+from .vocabulary import CONSTANTS, VOCABULARY, Constant, FieldSpec
+from . import testing  # noqa: F401
+
+__version__ = "1.0.0"
+
+__all__ = [
+    "Skeleton",
+    "Location",
+    "CoarseningMap",
+    "Geometry",
+    "LayerInfo",
+    "InterfaceInfo",
+    "Mapping",
+    "MappingBase",
+    "IdentityMapping",
+    "RadialStretch",
+    "ScaledMapping",
+    "ValidityReport",
+    "MappingPerturbation",
+    "validity_lattice",
+    "outer_radius_of",
+    "RadialDisplacement",
+    "ZeroDisplacement",
+    "CallableDisplacement",
+    "as_displacement",
+    "RadialMesh",
+    "Character",
+    "SCALAR",
+    "DENSITY",
+    "VECTOR",
+    "STRESS",
+    "ELASTIC",
+    "Symmetry",
+    "LayerFunction",
+    "PolynomialLayer",
+    "NumericLayer",
+    "as_layer_function",
+    "polynomial_layer",
+    "constant_layer",
+    "polynomial_fit",
+    "Field",
+    "FieldBase",
+    "RadialField",
+    "AnalyticField",
+    "ComposedField",
+    "constant_field",
+    "ElasticField",
+    "is_fluid",
+    "moduli",
+    "elastic_moduli",
+    "kappa_mu",
+    "is_viscoelastic",
+    "frozen_moduli",
+    "dispersive_moduli",
+    "frozen",
+    "reference_omega",
+    "push_forward",
+    "pull_back",
+    "PushedForwardField",
+    "PulledBackField",
+    "Dimensions",
+    "Scales",
+    "G_SI",
+    "EARTH_MEAN_DENSITY",
+    "FieldSpec",
+    "Constant",
+    "VOCABULARY",
+    "CONSTANTS",
+    "Layer",
+    "Model",
+    "layer_method",
+    "with_moduli",
+    "with_velocities",
+    "Elastic",
+    "ConstantQ",
+    "SelfGravitating",
+    "Viscoelastic",
+    "PREM",
+    "LayeredIsotropicElastic",
+    "MineosModel",
+    "Deck",
+    "DeckFormat",
+    "MINEOS",
+    "read_deck",
+    "write_deck",
+    "deck_layers",
+    "Tabulated",
+    "flattening",
+    "layer_linear",
+    "AngularGrid",
+    "Sample",
+    "sample",
+    "gauss_legendre",
+    "equiangular",
+    "real_harmonics",
+    "synthesise",
+    "synthesise_grid",
+    "analyse_grid",
+    "gravity",
+    "mass",
+    "gravity_fields",
+    "testing",
+    "__version__",
+]