planetmodel 1.2.0__tar.gz → 1.2.3__tar.gz

{planetmodel-1.2.0 → planetmodel-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: planetmodel
-Version: 1.2.0
+Version: 1.2.3
 Summary: Spherically layered planetary models: reference bodies, fields, mappings and meshes
 License-Expression: BSD-3-Clause
 License-File: LICENSE

{planetmodel-1.2.0 → planetmodel-1.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "planetmodel"
-version = "1.2.0"
+version = "1.2.3"
 description = "Spherically layered planetary models: reference bodies, fields, mappings and meshes"
 keywords = ["geophysics", "seismology", "planetary models", "PREM", "spectral elements", "meshing"]
 classifiers = [

{planetmodel-1.2.0 → planetmodel-1.2.3}/src/planetmodel/__init__.py

@@ -89,7 +89,7 @@ from .mapping import (
 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 .model import CoarseningFit, Layer, Model
 from .pushforward import PulledBackField, PushedForwardField, pull_back, push_forward
 from .rheology import (
     dispersive_moduli,
@@ -104,12 +104,13 @@ from .units import EARTH_MEAN_DENSITY, G_SI, Dimensions, Scales
 from .vocabulary import CONSTANTS, VOCABULARY, Constant, FieldSpec
 from . import testing  # noqa: F401
 
-__version__ = "1.2.0"
+__version__ = "1.2.3"
 
 __all__ = [
     "Skeleton",
     "Location",
     "CoarseningMap",
+    "CoarseningFit",
     "Geometry",
     "LayerInfo",
     "InterfaceInfo",

{planetmodel-1.2.0 → planetmodel-1.2.3}/src/planetmodel/behaviours.py

@@ -31,18 +31,18 @@ type derived from `Model` alone.  The transformations `isotropic`,
 from __future__ import annotations
 
 import functools
-from collections.abc import Callable, Mapping
+from collections.abc import Callable, Iterable, Mapping, Sequence
 from typing import TYPE_CHECKING, Any
 
 import numpy as np
 
 from . import materials, rheology
-from .character import SCALAR
+from .character import DENSITY, SCALAR
 from .fields import ComposedField, Field
 from .mesh1d.gravity import gravity, gravity_fields, mass
 
 if TYPE_CHECKING:
-    from .model import Model
+    from .model import CoarseningFit, Model
 
 __all__ = ["layer_method", "with_moduli", "with_velocities", "Elastic", "ConstantQ",
            "SelfGravitating", "Viscoelastic", "ELASTIC_FAMILIES", "elastic_family"]
@@ -69,6 +69,25 @@ def elastic_family(name: str) -> tuple[str, ...]:
                    f"{list(materials.ELASTIC_NAMES)}")
 
 
+def _description_family(model: Model, group: Sequence[int]) -> tuple[str, ...]:
+    """The elastic names a merged group is refit through: the first
+    description every layer of the group holds, velocities preferred
+    since their products keep the derived moduli exact polynomials."""
+    held = set.intersection(*(set(model.layer(i).names) for i in group))
+    if "rho" in held and ({"vp", "vs"} <= held or {"vpv", "vsv"} <= held):
+        return tuple(nm for nm in VELOCITY_NAMES if nm in held)
+    five = materials.MODULI_NAMES[materials.Symmetry.VTI]
+    if set(five) <= held:
+        return five
+    iso = materials.MODULI_NAMES[materials.Symmetry.ISOTROPIC]
+    if set(iso) <= held:
+        return iso
+    raise ValueError(
+        f"merged layers {list(group)} share no complete elastic description "
+        "in velocities or moduli (perhaps only 'elastic_moduli'); keep the "
+        "interface, or re-describe the layers first")
+
+
 def layer_method[T](fn: Callable[..., T]) -> Callable[..., T]:
     """`fn(layer, *args, **kwargs)` as a method `model.fn(which, *args, **kwargs)`.
 
@@ -191,6 +210,39 @@ class Elastic:
             return out
         return out.replaced(layers=layers)
 
+    def coarsened(self: Model, *, keep: Iterable[int | str] | None = None,
+                  drop: Iterable[int | str] | None = None, degree: int = 3,
+                  n: int = 64) -> tuple[Model, CoarseningFit]:
+        """`Model.coarsened` with the elastic description kept consistent.
+
+        Each merged group is refit through its base description alone,
+        rho with the velocities where every merged layer holds them
+        (the five then follow as exact polynomial products of the
+        fits), else the five Love moduli, else kappa and mu; the other
+        elastic names are dropped before the fit and derived again
+        from the fitted description, so the coarse model satisfies the
+        elastic relations exactly.  A group whose layers share no such
+        description (one speaking only through `elastic_moduli`, say)
+        is refused.  Layers left whole are untouched.
+        """
+        from .model import Model
+        _, cmap = self._coarsening(keep=keep, drop=drop)
+        layers = [dict(layer.fields) for layer in self.layers]
+        merged = [group for group in cmap.layers if len(group) > 1]
+        for group in merged:
+            family = _description_family(self, group)
+            for i in group:
+                layers[i] = {k: f for k, f in layers[i].items()
+                             if k not in materials.ELASTIC_NAMES or k in family}
+        stripped = self.replaced(layers=layers, check=False)
+        coarse, fit = Model.coarsened(stripped, keep=keep, drop=drop,
+                                      degree=degree, n=n)
+        out = [dict(layer.fields) for layer in coarse.layers]
+        for j, group in enumerate(fit.map.layers):
+            if len(group) > 1:
+                out[j] = with_velocities(with_moduli(out[j]))
+        return coarse.replaced(layers=out), fit
+
     def isotropic(self: Model) -> Model:
         """The model with every elastic description replaced by its Voigt
         average: each layer keeps rho and everything that is not an
@@ -246,9 +298,10 @@ class SelfGravitating:
     density on every layer: the reference body's, computed on each call
     and never stored, as numbers by `gravity` and `mass`, as one radial
     field per layer by `gravity_fields`, and as a copy of the model
-    holding that field under the vocabulary name `g` by `with_gravity`.
-    A density that depends on direction is refused, and the geometry's
-    mapping does not enter (see `mesh1d.gravity`)."""
+    holding that field under the vocabulary name `g` by `with_gravity`;
+    `with_stratification` attaches d rho / d Phi_0 = rho'(r) / g(r) to
+    the fluid layers.  A density that depends on direction is refused,
+    and the geometry's mapping does not enter (see `mesh1d.gravity`)."""
 
     gravity = gravity
     mass = mass
@@ -268,6 +321,48 @@ class SelfGravitating:
             layers.append({**layer.fields, name: field})
         return self.replaced(layers=layers)
 
+    def with_stratification(self: Model, *, name: str = "drho_dphi0",
+                            replace: bool = False) -> Model:
+        """The model with the stratification of its fluid layers,
+        d rho / d Phi_0 = rho'(r) / g(r), attached to each of them
+        under `name`; solid layers, and layers whose fluidity cannot
+        be read, are left alone, and a model with no fluid layer is
+        refused.  rho' is exact where the density is polynomial; the
+        field is zero where g vanishes (the centre).  A fluid layer
+        already holding `name` is refused unless `replace`."""
+        fields = gravity_fields(self)
+        layers = []
+        n_fluid = 0
+        for layer, g in zip(self.layers, fields):
+            try:
+                fluid = materials.is_fluid(layer)
+            except KeyError:
+                fluid = False
+            if not fluid:
+                layers.append(dict(layer.fields))
+                continue
+            if name in layer and not replace:
+                raise ValueError(
+                    f"layer {layer.index} ({layer.name!r}) already holds {name!r}; "
+                    "pass replace=True to replace it")
+            rho = layer["rho"]
+            if not hasattr(rho, "derivative"):
+                raise ValueError(
+                    f"layer {layer.index} ({layer.name!r}) holds a rho that "
+                    "cannot state its radial derivative, so its "
+                    "stratification cannot be formed")
+            n_fluid += 1
+            strat = ComposedField(
+                lambda d, a: np.where(a != 0.0, d, 0.0)
+                / np.where(a != 0.0, a, 1.0),
+                (rho.derivative(nu=1), g), character=DENSITY, name=name)
+            layers.append({**layer.fields, name: strat})
+        if not n_fluid:
+            raise ValueError(
+                "no fluid layer: the stratification d rho / d Phi_0 is a "
+                "property of fluids, and no layer of this model is one")
+        return self.replaced(layers=layers)
+
 
 class Viscoelastic:
     """The rheology read from the fields: a layer's viscoelasticity, the

{planetmodel-1.2.0 → planetmodel-1.2.3}/src/planetmodel/catalogue.py

@@ -21,8 +21,9 @@ velocity are isotropic and get vph = vpv, vsh = vsv and eta = 1 as
 exact constants; the fluid outer core and ocean hold no qmu; the
 elastic values are those at a reference period of 1 s.
 
-`LayeredIsotropicElastic` builds an isotropic model of constant exact
-layers from a few numbers, a fluid layer being one with vs = 0; its
+`LayeredIsotropicElastic` builds an isotropic model of exact layers
+from a few numbers per layer, a constant or the coefficients of a
+polynomial in r / scale, a fluid layer being one with vs = 0; its
 `homogeneous` classmethod is the one-layer case.
 
 `MineosModel` is the model of a mineos deck, PREM's own tabulation
@@ -199,16 +200,20 @@ class PREM(Elastic, ConstantQ, SelfGravitating, Viscoelastic, Model):
 
 
 class LayeredIsotropicElastic(Elastic, SelfGravitating, Model):
-    """An isotropic model of constant layers between `boundaries`.
+    """An isotropic model of exact polynomial layers between `boundaries`.
 
     `boundaries` are the skeleton's, centre outward (an inner radius
     above zero gives a hollow model); `rho`, `vp` and `vs` give one
-    value per layer, and a layer with vs = 0 is fluid.  `name` is the
-    model's.
+    entry per layer, a number for a constant or a sequence of ascending
+    polynomial coefficients in r / scale, and a layer with vs = 0
+    throughout is fluid.  `name` is the model's.
     """
 
-    def __init__(self, boundaries: Sequence[float], *, rho: Sequence[float],
-                 vp: Sequence[float], vs: Sequence[float],
+    def __init__(self, boundaries: Sequence[float], *,
+                 rho: Sequence[float | Sequence[float]],
+                 vp: Sequence[float | Sequence[float]],
+                 vs: Sequence[float | Sequence[float]],
+                 scale: float = 1.0,
                  layer_names: Sequence[str | None] | None = None,
                  interface_names: Sequence[str | None] | None = None,
                  scales: Scales = Scales.SI, name: str | None = None) -> None:
@@ -222,11 +227,18 @@ class LayeredIsotropicElastic(Elastic, SelfGravitating, Model):
         layers = []
         for i in range(sk.nlayers):
             iv = sk.interval(i)
-            layers.append({
-                "rho": constant_field(iv, rho[i], character=DENSITY, name="rho"),
-                "vp": constant_field(iv, vp[i], name="vp"),
-                "vs": constant_field(iv, vs[i], name="vs"),
-            })
+            fields = {}
+            for key, character in (("rho", DENSITY), ("vp", SCALAR),
+                                   ("vs", SCALAR)):
+                value = values[key][i]
+                if np.isscalar(value):
+                    fields[key] = constant_field(iv, float(value),
+                                                 character=character, name=key)
+                else:
+                    fields[key] = RadialField(
+                        iv, polynomial_layer(iv, value, scale=scale),
+                        character=character, name=key)
+            layers.append(fields)
         super().__init__(geometry, layers, scales=scales, name=name)
 
     @classmethod

{planetmodel-1.2.0 → planetmodel-1.2.3}/src/planetmodel/fields.py

@@ -365,6 +365,23 @@ class RadialField(FieldBase):
             raise ValueError(f"{self!r} has {self._fs.size} components; use functions")
         return self._fs[()]
 
+    @property
+    def radial_degree(self) -> int | None:
+        """The least polynomial degree in r reproducing every component
+        throughout the interval, or None where a component is not a
+        single polynomial piece (interior breakpoints, or not a
+        polynomial at all)."""
+        worst = 0
+        for idx in np.ndindex(self._fs.shape):
+            p = getattr(self._fs[idx], "ppoly", None)
+            if p is None or p.x.size != 2:
+                return None
+            c = p.c[:, 0]
+            nonzero = np.flatnonzero(c != 0.0)
+            if nonzero.size:
+                worst = max(worst, int(c.size - 1 - nonzero[0]))
+        return worst
+
     def _values(self, r: np.ndarray, theta: np.ndarray | None,
                 phi: np.ndarray | None) -> np.ndarray:
         if not self._fs.shape:

{planetmodel-1.2.0 → planetmodel-1.2.3}/src/planetmodel/mesh3d/__init__.py

@@ -29,13 +29,14 @@ from . import manifest
 from .export import ExportResult, export_mfem, export_mfem_mesh
 from .layered import build_layered_mesh
 from .offset import build_offset_mesh
-from .spec import (AngularResolution, InterfaceSizing, MeshResult, MeshSpec,
-                   PerInterface, Shell, SizingRule, UniformInterfaces,
-                   ValidationReport)
+from .spec import (AngularResolution, CappedInterfaces, InterfaceSizing,
+                   MeshResult, MeshSpec, PerInterface, Shell, SizingRule,
+                   UniformInterfaces, ValidationReport)
 
 __all__ = [
     "MeshSpec", "MeshResult", "Shell", "InterfaceSizing", "SizingRule",
-    "AngularResolution", "UniformInterfaces", "PerInterface",
-    "ValidationReport", "build_layered_mesh", "build_offset_mesh",
-    "export_mfem_mesh", "export_mfem", "ExportResult", "manifest",
+    "AngularResolution", "UniformInterfaces", "CappedInterfaces",
+    "PerInterface", "ValidationReport", "build_layered_mesh",
+    "build_offset_mesh", "export_mfem_mesh", "export_mfem", "ExportResult",
+    "manifest",
 ]

{planetmodel-1.2.0 → planetmodel-1.2.3}/src/planetmodel/mesh3d/_sizing.py

@@ -1,11 +1,20 @@
 """Telling gmsh how finely to resolve each interface.
 
-One Distance field per interface, each wrapped in a Threshold that
-grows the element size from `size` at the boundary to `far_size` over
+One distance per interface, each wrapped in a Threshold that grows the
+element size from `size` at the boundary to `far_size` over
 `decay_width`, and a single Min over all of them so every point takes
-the finest requirement that applies to it.  A single Distance field
-over every boundary could only express one size for all of them, which
-is what a layered domain does not want.
+the finest requirement that applies to it.  A single distance to every
+boundary could only express one size for all of them, which is what a
+layered domain does not want.
+
+Every interface is a full circle or sphere when it is meshed, of radius
+R about a centre c, so the distance to it is | |x - c| - R | and is
+given to gmsh in closed form.  gmsh's own Distance field is not used:
+it measures the distance to a sampling of the entity by points, which
+on the interface itself is zero at the points and about half their
+spacing between them, and the Threshold turns that into an element size
+that ripples along the interface and is on average coarser than the one
+asked for, the more so the shorter the decay width.
 """
 from __future__ import annotations
 
@@ -15,6 +24,7 @@ import gmsh
 import numpy as np
 from numpy.typing import ArrayLike
 
+from ._orient import Centres
 from ._tagging import Tagging
 from .spec import InterfaceSizing
 
@@ -22,25 +32,29 @@ __all__ = ["apply_size_fields", "apply_mesh_options",
            "check_sizing_resolves_spans", "check_sizing_scale"]
 
 
-def apply_size_fields(tagging: Tagging, sizes: Mapping[int, InterfaceSizing]) -> int:
+def apply_size_fields(tagging: Tagging, sizes: Mapping[int, InterfaceSizing], *,
+                      centres: Centres | None = None) -> int:
     """Build the background size field from per-interface sizings.
 
     `sizes` maps interface index to InterfaceSizing, in the lengths the
-    geometry is drawn in.  Returns the tag of the field set as the
-    background.
+    geometry is drawn in.  `centres` maps a surface's entity tag to its
+    centre where that is not the origin.  Returns the tag of the field
+    set as the background.
     """
     if not sizes:
         raise ValueError("no sizing given: every interface needs one")
 
-    entity_key = "SurfacesList" if tagging.dimension == 3 else "CurvesList"
+    centres = centres or {}
     thresholds: list[float] = []
 
-    for i, face in enumerate(tagging.faces):
+    for i, (face, radius) in enumerate(zip(tagging.faces, tagging.radii)):
         sizing = sizes.get(i)
         if sizing is None:
             raise ValueError(f"no sizing for interface {i}")
-        dist = gmsh.model.mesh.field.add("Distance")
-        gmsh.model.mesh.field.setNumbers(dist, entity_key, [float(face)])
+        dist = gmsh.model.mesh.field.add("MathEval")
+        gmsh.model.mesh.field.setString(
+            dist, "F", _distance_to_sphere(centres.get(face, (0.0, 0.0, 0.0)),
+                                           radius))
 
         thr = gmsh.model.mesh.field.add("Threshold")
         gmsh.model.mesh.field.setNumber(thr, "InField", dist)
@@ -56,6 +70,17 @@ def apply_size_fields(tagging: Tagging, sizes: Mapping[int, InterfaceSizing]) ->
     return combined
 
 
+def _distance_to_sphere(centre: ArrayLike, radius: float) -> str:
+    """The distance | |x - c| - R | as an expression gmsh evaluates.
+
+    Each number is written with the digits that round-trip and in
+    brackets, so a sign or an exponent is read as part of it.
+    """
+    cx, cy, cz = (float(c) for c in np.asarray(centre, dtype=float))
+    return (f"Fabs(Sqrt((x-({cx!r}))^2+(y-({cy!r}))^2+(z-({cz!r}))^2)"
+            f"-({float(radius)!r}))")
+
+
 def apply_mesh_options(*, order: int, algorithm_2d: int, algorithm_3d: int,
                        size_min: float, size_max: float) -> None:
     """Set the meshing options that go with a background size field.
@@ -111,7 +136,8 @@ def check_sizing_resolves_spans(boundaries: ArrayLike,
             "the sizing is too coarse for this domain's thinnest layers, and "
             "gmsh would fail with an unrelated-looking PLC error:\n  - "
             + "\n  - ".join(problems)
-            + "\nRefine the sizing, or coarsen the geometry so the thin "
+            + "\nRefine the sizing, cap it against thin layers "
+              "(CappedInterfaces), or coarsen the geometry so the thin "
               "layers are merged.")
     return problems
 

{planetmodel-1.2.0 → planetmodel-1.2.3}/src/planetmodel/mesh3d/export.py

@@ -42,7 +42,7 @@ manifest's `mesh.read_options` says so in the form a C++ reader passes on.
 from __future__ import annotations
 
 import dataclasses
-from collections.abc import Iterable
+from collections.abc import Iterable, Sequence
 from collections.abc import Mapping as MappingOf
 from dataclasses import KW_ONLY, dataclass, field
 from pathlib import Path
@@ -55,12 +55,13 @@ from numpy.typing import ArrayLike
 from ..character import VECTOR, Character
 from ..fields import stored_shape
 from ..mapping import IdentityMapping, Mapping
+from ..materials import is_fluid
 from ..units import LENGTH
 from . import manifest
 from .spec import DELIVERIES, MeshResult
 
 if TYPE_CHECKING:
-    from ..model import Model
+    from ..model import Layer, Model
 
 __all__ = ["ExportResult", "export_mfem_mesh", "export_mfem",
            "jacobian_report", "MESH_READ_OPTIONS"]
@@ -248,8 +249,8 @@ def _displacement_at(mapping: Mapping, X: ArrayLike, *, scale: float) -> np.ndar
 
 
 def _field_entry(name: str, path: str | Path, fes: Any, *, character: Character,
-                 dimensions: Any, si: bool, layers: Iterable[int]
-                 ) -> manifest.FieldEntry:
+                 dimensions: Any, si: bool, layers: Iterable[int],
+                 radial_degree: int | None = None) -> manifest.FieldEntry:
     """One `fields[]` record: where the GridFunction is and which space it
     lives in, and what its values are."""
     mfem = _mfem()
@@ -258,7 +259,7 @@ def _field_entry(name: str, path: str | Path, fes: Any, *, character: Character,
     return manifest.FieldEntry.from_field(
         name, path, fe_space=fes.FEColl().Name(), vdim=int(fes.GetVDim()),
         ordering=ordering, character=character, dimensions=dimensions, si=si,
-        layers=layers)
+        layers=layers, radial_degree=radial_degree)
 
 
 def export_mfem_mesh(result: MeshResult, path_base: str | Path, *,
@@ -439,6 +440,93 @@ def _field_values(model: Model, name: str, X: np.ndarray,
     return values
 
 
+def _fluidity(layer: Layer) -> bool | None:
+    """The layer's fluidity, or None where its fields do not say."""
+    try:
+        return bool(is_fluid(layer))
+    except KeyError:
+        return None
+
+
+def _interface_kind(below: int, above: int, in_model: Sequence[bool],
+                    fluid: Sequence[bool | None]) -> str | None:
+    """One of `manifest.KINDS` for an interface between the 0-based
+    layers `below` and `above` (-1 outside), or None where the model
+    does not say."""
+    b = below != -1 and in_model[below]
+    a = above != -1 and in_model[above]
+    if b and a:
+        fb, fa = fluid[below], fluid[above]
+        if fb is None or fa is None:
+            return None
+        if fb and fa:
+            return "fluid-fluid"
+        return "fluid-solid" if fb or fa else "solid-solid"
+    if b or a:
+        return "free"
+    return "outer" if above == -1 else None
+
+
+def _side_value(model: Model, layer: int, in_model: Sequence[bool], name: str,
+                radius: float) -> float | None:
+    """`name` just inside the 0-based `layer` at `radius`, where it is
+    a real scalar radial value there; None otherwise."""
+    if layer == -1 or not in_model[layer]:
+        return None
+    fields = model.layer(layer)
+    if name not in fields:
+        return None
+    field = fields[name]
+    if field.character.rank != 0 or not getattr(field, "is_radial", False):
+        return None
+    value = np.asarray(field(radius))
+    if np.iscomplexobj(value):
+        return None
+    return float(value)
+
+
+def _radial_degree(model: Model, name: str) -> int | None:
+    """The degree in r reproducing `name` within every layer holding
+    it, or None for a field of higher rank or one without a single
+    degree on some layer."""
+    if _character_of(model, name).rank != 0:
+        return None
+    degrees = []
+    for i in model.layers_with(name):
+        d = getattr(model.layer(i)[name], "radial_degree", None)
+        if d is None:
+            return None
+        degrees.append(int(d))
+    return max(degrees)
+
+
+def _annotate_from_model(card: manifest.MeshManifest, model: Model,
+                         names: Iterable[str]) -> None:
+    """Write what the model says onto the manifest's skeleton records.
+
+    `fluid` on every layer (False for a shell, None where the fields do
+    not say), `kind` on every interface from those flags, and `values`
+    on every interface: the one-sided values of each of `names` that is
+    a real scalar radial field, absent sides null.
+    """
+    in_model = [bool(e["in_geometry"]) for e in card.layers]
+    fluid = [_fluidity(model.layer(e["attribute"] - 1)) if in_model[i] else False
+             for i, e in enumerate(card.layers)]
+    for entry, f in zip(card.layers, fluid):
+        entry["fluid"] = f
+    names = list(names)
+    for entry in card.interfaces:
+        below, above = (int(k) for k in entry["between_layers"])
+        entry["kind"] = _interface_kind(below, above, in_model, fluid)
+        values = {}
+        for name in names:
+            pair = [_side_value(model, k, in_model, name, entry["radius"])
+                    for k in (below, above)]
+            if any(v is not None for v in pair):
+                values[name] = pair
+        entry["values"] = values or None
+
+
 def export_mfem(result: MeshResult, path_base: str | Path, *, model: Model,
                 fields: Iterable[str] | None = None, delivery: str = "physical",
                 order: int | None = None) -> ExportResult:
@@ -461,9 +549,15 @@ def export_mfem(result: MeshResult, path_base: str | Path, *, model: Model,
     sit on the geometry the mesh was built from: the same skeleton to
     the model's geometry's `rtol`; a mesh not built from a geometry is
     refused.  The manifest gains one `fields[]` record per name, saying
-    the file, the space to read it into, the character, the unit and the
-    layers on which the values mean anything, and `scales` and
-    `constants` blocks from the model.
+    the file, the space to read it into, the character, the unit, the
+    layers on which the values mean anything and, for a scalar field
+    polynomial in r, the degree that reproduces it (`radial_degree`);
+    and `scales` and `constants` blocks from the model.  What the model
+    says about the skeleton is written onto its records: `fluid` on
+    every layer (the vanishing of shear in the exported description;
+    False for a shell, null where the fields do not say), `kind` on
+    every interface, and `values`, the one-sided values there of every
+    exported real scalar radial field.
     """
     mfem = _mfem()
     _check_model_sits_on(result, model)
@@ -499,7 +593,7 @@ def export_mfem(result: MeshResult, path_base: str | Path, *, model: Model,
         entries.append(_field_entry(
             name, path, fes, character=_character_of(model, name),
             dimensions=None if spec is None else spec.dimensions, si=si,
-            layers=holders[name]))
+            layers=holders[name], radial_degree=_radial_degree(model, name)))
 
     card = manifest.read(export.manifest_path)
     for entry in card.fields:
@@ -508,6 +602,7 @@ def export_mfem(result: MeshResult, path_base: str | Path, *, model: Model,
     card.fields.extend(dataclasses.asdict(e) for e in entries)
     card.scales = manifest.scales_block(model.scales)
     card.constants = manifest.constants_block(model)
+    _annotate_from_model(card, model, written)
     manifest.validate_structure(card)
     manifest_path = manifest.write(path_base, card)
     return dataclasses.replace(export, manifest_path=manifest_path,

{planetmodel-1.2.0 → planetmodel-1.2.3}/src/planetmodel/mesh3d/layered.py

@@ -7,10 +7,10 @@ reference one, concentric spheres with the geometry's names as
 attributes: gmsh meshes the skeleton and nothing else, and the
 geometry's mapping is applied later, at the MFEM export, where a
 displacement is a vector in the mesh's own nodal space.  Then CAD,
-tagging, sizing, meshing at order 1, orientation, curving, validation,
-and only then anything is written.  A mesh that fails its checks and
-exists anyway looks finished, so nothing reaches disk before
-validation.
+tagging, sizing, meshing at order 1, optimisation of the linear mesh,
+orientation, curving, validation, and only then anything is written.
+A mesh that fails its checks and exists anyway looks finished, so
+nothing reaches disk before validation.
 
 With shells and a non-identity mapping the mapping must be defined and
 orientation-preserving out to the outer boundary of the computational
@@ -145,6 +145,12 @@ def build_layered_mesh(spec: MeshSpec, path: str | Path, *, verbose: bool = Fals
         gmsh.model.mesh.generate(d)
         timings["mesh"] = clock() - t0
 
+        if d == 3 and spec.optimise:
+            t0 = clock()
+            for method in spec.optimise:
+                gmsh.model.mesh.optimize(method)
+            timings["optimise"] = clock() - t0
+
         t0 = clock()
         orient_mesh(d)
         raise_order(d, spec.order)