shape-plotters 0.1.0__py3-none-any.whl

shape_plotters/core/nodes.py

@@ -0,0 +1,23 @@
+"""Shared Gauss-Legendre node set — WMMM's dense grid (GL-2048 in x = cos θ).
+
+Shape-independent, computed once at import, read-only: the Python mirror of
+WMMM's program_run_time_constants_mod node-set metadata. Renders evaluate
+R and dR/dθ at THETA; quadrature.py integrates with W (integrands with a
+sin θ factor absorb it into dx = -sin θ dθ). GL is an open rule — no θ = 0/π
+nodes — so pole values come from the libraries' analytic pole radii.
+"""
+from __future__ import annotations
+
+import numpy as np
+
+N_NODES = 2048
+
+_x, _w = np.polynomial.legendre.leggauss(N_NODES)
+X = _x[::-1].copy()           # cos(theta), descending +1 -> -1: exact GL abscissas
+W = _w[::-1].copy()           # weights paired with THETA's ordering
+THETA = np.arccos(X)          # ascending, strictly inside (0, pi)
+SIN_THETA = np.sqrt(1.0 - X * X)
+
+for _arr in (X, W, THETA, SIN_THETA):
+    _arr.setflags(write=False)
+del _x, _w, _arr

shape_plotters/core/quadrature.py

@@ -0,0 +1,41 @@
+"""GL dot-product shape integrals on the shared node set (shape_plotters/core/nodes.py).
+
+Spectrally exact — the same scheme as WMMM's dense set: every integrand
+carries a sin(theta) factor that the x = cos(theta) substitution absorbs.
+Arrays must be sampled on nodes.THETA; theta is accepted for interface
+stability and checked against the node set.
+"""
+from __future__ import annotations
+
+import numpy as np
+
+from shape_plotters.core import nodes
+from shape_plotters.core.result import Array
+
+
+def _require_node_set(theta: Array) -> None:
+    if theta.shape != nodes.THETA.shape:
+        raise ValueError(
+            f"expected the shared GL node set ({nodes.N_NODES} nodes), got {theta.shape}")
+
+
+def volume(theta: Array, radius: Array) -> float:
+    """V = (2*pi/3) * sum w_i R_i^3 (star-convex body)."""
+    _require_node_set(theta)
+    return float((2.0 * np.pi / 3.0) * np.sum(nodes.W * radius**3))
+
+
+def surface_area(theta: Array, radius: Array, dr_dtheta: Array) -> float:
+    """S = 2*pi * sum w_i R_i sqrt(R_i^2 + R'_i^2), with lib-exact R'."""
+    _require_node_set(theta)
+    return float(2.0 * np.pi * np.sum(
+        nodes.W * radius * np.sqrt(radius**2 + dr_dtheta**2)))
+
+
+def z_cm(theta: Array, radius: Array) -> float:
+    """z_cm = (pi/2) * sum w_i R_i^4 x_i / V; 0 if V <= 0."""
+    _require_node_set(theta)
+    v = volume(theta, radius)
+    if v <= 0.0:
+        return 0.0
+    return float((np.pi / 2.0) * np.sum(nodes.W * radius**4 * nodes.X) / v)

shape_plotters/core/result.py

@@ -0,0 +1,92 @@
+"""Render contract: what a parameterization render gives the engine.
+
+Everything in ShapeResult is in R0 units (dimensionless). The engine owns
+display units (fm toggle) and applies R0 = 1.16 * A^(1/3) only at draw time.
+
+A render must expose:
+    name: str
+    slider_specs: list[SliderSpec]
+    toggles: list[ToggleSpec]
+    has_extra_panel: bool                # True -> engine draws rho(z) + drho_dz panel
+    compute(params: dict[str, float], toggles: dict[str, bool]) -> ShapeResult
+    filename(z: int, n: int, params: dict[str, float]) -> str
+    energy_requests(params: dict[str, float], result: ShapeResult)
+        -> list[EnergyRequest]           # WMMM computations for this shape(s)
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+import numpy.typing as npt
+
+Array = npt.NDArray[np.float64]
+
+
+@dataclass(frozen=True)
+class SliderSpec:
+    key: str
+    label: str
+    vmin: float
+    vmax: float
+    vinit: float
+    step: float
+    markers: tuple[float, ...] = ()   # practical-limit lines (red dotted)
+
+
+@dataclass(frozen=True)
+class ToggleSpec:
+    key: str
+    label: str
+    default: bool
+
+
+@dataclass(frozen=True)
+class EnergyRequest:
+    """One WMMM point computation the engine should run on an Energy click.
+
+    Renders own the physics semantics (how many shapes are on screen and in
+    which parameter convention); the engine just iterates requests. Carries
+    no wmmm dependency — shape_plotters/core/energy.py resolves it.
+    """
+    label: str                 # stats-block header; mirrors the plot legend
+    param_type: str            # "legendre" | "fos"
+    shape: tuple[float, ...]   # raw slider values in WMMM's convention
+    com_correction: bool       # WMMM's beta_10_com_shift flag
+
+
+@dataclass(frozen=True)
+class NeckInfo:
+    z: float        # R0 units
+    rho: float      # R0 units
+    depth: float    # 1 - rho_neck / (lower of the two lobe maxima)
+    source: str     # "lib" (FoS) or "py heuristic" (beta)
+
+
+@dataclass(frozen=True)
+class ShapeResult:
+    status: int                    # 0 = valid; engine greys the plot otherwise
+    status_name: str               # symbolic name from the package Status IntEnum
+    message: str
+    theta: Array                   # shared GL node set (shape_plotters/core/nodes.py)
+    radius: Array                  # R(theta), R0 units
+    z: Array                       # profile axis, R0 units
+    rho: Array                     # rho(z), R0 units
+    drho_dz: Array | None          # lib-native (FoS); None for beta
+    neck: NeckInfo | None
+    scalars: dict[str, float]      # lib-native, R0 units where dimensional
+    length_keys: frozenset[str]    # which scalars scale with the fm toggle
+    dr_dtheta: Array                 # lib-exact analytic dR/dθ, scaled like radius
+    r_north: float                   # analytic R(0), R0 units, scaled like radius
+    r_south: float                   # analytic R(pi), R0 units, scaled like radius
+    z_cm: float                      # true-shape COM in the cross-section frame, R0 units
+    # Optional orange cross-section overlay (beta's COM-corrected shape).
+    # Pre-closed cartesian outline in R0 units; the engine draws it when set.
+    overlay_z: Array | None = None
+    overlay_rho: Array | None = None
+    overlay_z_cm: float = 0.0
+    overlay_ok: bool = True           # False => corrected shape is invalid; grey the overlay
+
+    @property
+    def ok(self) -> bool:
+        return self.status == 0

shape_plotters/core/widgets.py

@@ -0,0 +1,68 @@
+"""Parameterization-independent matplotlib widget helpers."""
+from __future__ import annotations
+
+from typing import Callable
+
+import matplotlib
+from matplotlib.figure import Figure
+from matplotlib.widgets import Button, Slider, TextBox
+
+
+class SliderRow:
+    """Slider with -/+ nudge buttons and optional practical-limit markers.
+
+    Extracted from ShapePlotterFoSFitter's create_slider. The grey line marks
+    the reset value; red dotted lines mark practical limits.
+    """
+
+    def __init__(self, fig: Figure, y_pos: float, label: str, vmin: float,
+                 vmax: float, vinit: float, step: float,
+                 markers: tuple[float, ...] = ()) -> None:
+        ax_dec = fig.add_axes((0.20, y_pos, 0.016, 0.024))
+        ax_sl = fig.add_axes((0.25, y_pos, 0.45, 0.024))
+        ax_inc = fig.add_axes((0.73, y_pos, 0.016, 0.024))
+        self.slider = Slider(ax_sl, label, vmin, vmax, valinit=vinit, valstep=step)
+        self.btn_dec = Button(ax_dec, "-")
+        self.btn_inc = Button(ax_inc, "+")
+        self.slider.ax.vlines(vinit, 0, 1, color="k", alpha=0.3, linewidth=1)
+        if markers:
+            self.slider.ax.vlines(list(markers), 0, 1, color="r", linestyle=":",
+                                  alpha=0.7, linewidth=1.5)
+        self._step = step
+        self.btn_dec.on_clicked(lambda _event: self._nudge(-self._step))
+        self.btn_inc.on_clicked(lambda _event: self._nudge(+self._step))
+
+    def _nudge(self, delta: float) -> None:
+        new = self.slider.val + delta
+        if self.slider.valmin <= new <= self.slider.valmax:
+            self.slider.set_val(new)
+
+
+class IntTextBox:
+    """TextBox accepting positive ints; reverts to the last good value otherwise."""
+
+    def __init__(self, fig: Figure, rect: tuple[float, float, float, float],
+                 label: str, initial: int, on_change: Callable[[], None]) -> None:
+        self.box = TextBox(fig.add_axes(rect), label, initial=str(initial))
+        if matplotlib.__version__.startswith("3.11"):
+            # mpl 3.11.0 regression: TextBox._resize is wrapped by
+            # _call_with_reparented_event, which reads event.inaxes — absent on
+            # ResizeEvent — so every window resize logs an AttributeError.
+            # Replace the connection (last one made in TextBox.__init__),
+            # keeping the intended stop-typing-on-resize behavior.
+            fig.canvas.mpl_disconnect(self.box._cids[-1])
+            fig.canvas.mpl_connect("resize_event", lambda _e: self.box.stop_typing())
+        self.value = int(initial)
+        self._on_change = on_change
+        self.box.on_submit(self._submit)
+
+    def _submit(self, text: str) -> None:
+        try:
+            v = int(text)
+            if v <= 0:
+                raise ValueError(text)
+        except ValueError:
+            self.box.set_val(str(self.value))  # re-fires _submit with the old value
+            return
+        self.value = v
+        self._on_change()

shape_plotters/renders/beta.py

@@ -0,0 +1,166 @@
+"""Beta (Legendre) render over the beta_parameterization package.
+
+GL-native: R(theta) and analytic dR/dtheta come from the library's cached
+tier evaluated on the shared GL-2048 primary theta set (shape_plotters/core/nodes.py) —
+in sync with the energy model's dense grid. One read-only cache serves every
+call; each call resolves from its betas, so the cache may be shared across
+threads. Volume conservation and the COM correction are per-call library
+options: radii, dR/dtheta and the polar radii arrive pre-scaled, and
+resolve_shape reports the applied volume_factor. The neck is
+the Python display-only heuristic (shape_plotters/core/neck.py) — graduating it into the
+library is recorded future work.
+
+Two shapes are drawn. The default (blue) shape uses beta10 (= the beta1 slider,
+the l=1 dipole term) as set. The COM-corrected (orange) overlay ignores that
+slider value and uses corrected_beta10 — the dipole the library computes from
+beta2..beta8 to place the center of mass at the origin —
+shown only when corrected_beta10 differs from the slider beta1 by more than
+the overlay threshold (the two shapes then genuinely differ).
+
+Fast-math precondition: params must be finite. Sliders only emit finite
+values, so no screening happens here.
+"""
+from __future__ import annotations
+
+import numpy as np
+import beta_parameterization as bp
+
+from shape_plotters.core import nodes, quadrature
+from shape_plotters.core.neck import find_neck_indices, neck_depth
+from shape_plotters.core.result import EnergyRequest, NeckInfo, ShapeResult, SliderSpec
+
+N_BETAS = 8
+# WMMM's legendre parameterization takes 8 betas, all slider-driven.
+WMMM_N_LEGENDRE_PARAMS = 8
+# The COM-corrected shape coincides with the slider shape when the corrected
+# dipole equals the slider beta1 (beta10 is a shape parameter, not a
+# translation knob); below this |corrected_beta10 - beta1| the orange overlay
+# is suppressed (slider units).
+OVERLAY_BETA10_THRESHOLD = 0.001
+
+
+class BetaRender:
+    name = "beta"
+    has_extra_panel = False
+    # Legend labels for the engine's orange overlay artists (the COM-corrected
+    # shape reuses the same drawing channel as the FoS R(θ) overlay).
+    overlay_label = "COM corrected"
+    overlay_zcm_label = "z_cm (corrected)"
+    # Ranges from the old ShapePlotter: beta1 (-1.6, 1.6), beta2 (0, 4), rest (-2, 2).
+    slider_specs = [
+        SliderSpec("beta1", "β1", -1.6, 1.6, 0.0, 0.01),
+        SliderSpec("beta2", "β2", 0.0, 4.0, 0.0, 0.01),
+    ] + [SliderSpec(f"beta{i}", f"β{i}", -2.0, 2.0, 0.0, 0.01) for i in range(3, N_BETAS + 1)]
+    toggles = []
+
+    def __init__(self) -> None:
+        # The blue (raw) and orange (COM-corrected) shapes share the cache;
+        # they differ only in the per-call apply_com option.
+        self._cache = bp.Cache(N_BETAS, nodes.THETA)
+
+    def compute(self, params: dict[str, float], toggles: dict[str, bool]) -> ShapeResult:
+        betas = [params[f"beta{i}"] for i in range(1, N_BETAS + 1)]
+        # Default (blue) shape: the slider betas as-is, including the slider beta10.
+        resolved = self._cache.resolve_shape(betas, conserve_volume=True)
+        rd = (self._cache.radius_and_derivative(betas, conserve_volume=True)
+              if resolved.ok else None)
+        ok = rd is not None and rd.ok
+
+        vol_factor = 1.0
+        if ok:
+            # Radii, derivative and poles arrive pre-scaled by the library's
+            # volume factor (conserve_volume=True); no Python rescaling.
+            radii = rd.radii
+            dr_dtheta = rd.dr_dtheta
+            r_north = resolved.r_north
+            r_south = resolved.r_south
+            vol_factor = resolved.volume_factor
+            # The slider shape's COM sits on the z axis at z_cm (nonzero for
+            # asymmetric betas — the red marker shows the offset).
+            z_cm = quadrature.z_cm(nodes.THETA, radii)
+            z = radii * nodes.X
+            rho = radii * nodes.SIN_THETA
+        else:
+            radii = np.zeros(nodes.N_NODES)
+            dr_dtheta = np.zeros(nodes.N_NODES)
+            r_north = r_south = z_cm = 0.0
+            # Unchecked path: keeps R(theta) even where it goes negative, so
+            # the broken (self-crossing) outline still draws — the engine
+            # greys it — instead of the shape collapsing to a point. Unscaled
+            # by design: invalid shapes get no volume conservation.
+            grid = self._cache.radius_grid_unchecked(betas)
+            z = grid.radii * nodes.X
+            rho = grid.radii * nodes.SIN_THETA
+
+        neck = None
+        if ok:
+            hit = find_neck_indices(rho)
+            if hit is not None:
+                i_neck, i_a, i_b = hit
+                neck = NeckInfo(z=float(z[i_neck]), rho=float(rho[i_neck]),
+                                depth=neck_depth(rho, i_neck, i_a, i_b),
+                                source="py heuristic")
+
+        scalars: dict[str, float] = {"vol_factor": vol_factor}
+        # COM-corrected (orange) overlay: beta10 recomputed from beta2..beta8 to
+        # center the COM. Built only when it differs from the slider shape
+        # (|corrected_beta10 - beta1| > threshold); below that the two coincide.
+        overlay_z = overlay_rho = None
+        overlay_z_cm = 0.0
+        overlay_ok = True
+        corrected = self._cache.resolve_shape(betas, conserve_volume=True, apply_com=True)
+        if corrected.ok:
+            scalars["corrected_beta10"] = corrected.corrected_beta10
+            if ok and abs(corrected.corrected_beta10 - betas[0]) > OVERLAY_BETA10_THRESHOLD:
+                rd_c = self._cache.radius_and_derivative(
+                    betas, conserve_volume=True, apply_com=True)
+                if rd_c.ok:
+                    radii_c = rd_c.radii
+                    z_c = radii_c * nodes.X
+                    rho_c = radii_c * nodes.SIN_THETA
+                    # Close at the analytic poles (the engine's convention);
+                    # corrected.r_north/r_south are already volume-scaled.
+                    rn_c, rs_c = corrected.r_north, corrected.r_south
+                    first, last = (-rs_c, rn_c) if z_c[0] < z_c[-1] else (rn_c, -rs_c)
+                    overlay_z = np.concatenate(([first], z_c, [last]))
+                    overlay_rho = np.concatenate(([0.0], rho_c, [0.0]))
+                    overlay_z_cm = quadrature.z_cm(nodes.THETA, radii_c)
+        elif ok and corrected.status == bp.Status.interior_negative:
+            # The COM-centering beta10 exists (poles fine, COM converged) but
+            # the corrected shape is interior-negative — the library catches
+            # this at resolve_shape, because the volume factor is computed
+            # after validation. Draw the near-miss greyed via the unchecked
+            # path so it stays visible instead of the overlay silently
+            # vanishing. apply_com is explicit: without it this is the
+            # uncorrected shape.
+            grid_c = self._cache.radius_grid_unchecked(betas, apply_com=True)
+            overlay_z = grid_c.radii * nodes.X
+            overlay_rho = grid_c.radii * nodes.SIN_THETA
+            overlay_ok = False
+
+        primary = rd if resolved.ok else resolved
+        return ShapeResult(
+            status=int(primary.status), status_name=primary.status.name,
+            message=primary.message,
+            theta=nodes.THETA, radius=radii, z=z, rho=rho, drho_dz=None,
+            neck=neck, scalars=scalars, length_keys=frozenset(),
+            dr_dtheta=dr_dtheta, r_north=r_north, r_south=r_south, z_cm=z_cm,
+            overlay_z=overlay_z, overlay_rho=overlay_rho, overlay_z_cm=overlay_z_cm,
+            overlay_ok=overlay_ok)
+
+    def filename(self, z: int, n: int, params: dict[str, float]) -> str:
+        betas = "_".join(f"{params[f'beta{i}']:.2f}" for i in range(1, N_BETAS + 1))
+        return f"{z}_{n}_{betas}.png"
+
+    def energy_requests(self, params: dict[str, float],
+                        result: ShapeResult) -> list[EnergyRequest]:
+        """WMMM requests: the slider (blue) shape, plus the COM-corrected
+        (orange) shape when the overlay is on screen. WMMM recomputes beta10
+        itself under com_correction=True, so both carry the same betas."""
+        shape = tuple(params[f"beta{i}"] for i in range(1, N_BETAS + 1)) \
+            + (0.0,) * (WMMM_N_LEGENDRE_PARAMS - N_BETAS)
+        requests = [EnergyRequest("slider", "legendre", shape, com_correction=False)]
+        if result.overlay_z is not None:
+            requests.append(
+                EnergyRequest("COM corrected", "legendre", shape, com_correction=True))
+        return requests

shape_plotters/renders/fos.py

@@ -0,0 +1,107 @@
+"""FoS render over the fos_parameterization package.
+
+rho(z)-native (lib-exact drho_dz, lib-native neck); R(theta) and analytic
+dR/dtheta come from the library's cached tier on the shared GL-2048 set
+(shape_plotters/core/nodes.py) — in sync with the energy model's dense grid. The cache
+evaluates R(theta) in the total-shift frame internally, so no z_shift
+plumbing. Neck position/radius are lib values on the cache's u-grid; only
+the displayed depth reuses the shared peak analysis on the display profile.
+The cache is read-only and every call resolves from params, so it may be
+shared across threads. A separated shape draws its fragments from the
+unchecked profile; the checked statuses still decide validity.
+
+Fast-math precondition: params must be finite. Sliders only emit finite
+values, so no screening happens here.
+"""
+from __future__ import annotations
+
+import numpy as np
+import fos_parameterization as fp
+
+from shape_plotters.core import nodes
+from shape_plotters.core.neck import find_neck_indices, neck_depth
+from shape_plotters.core.result import EnergyRequest, NeckInfo, ShapeResult, SliderSpec, ToggleSpec
+
+# rho(z) display-panel resolution (native COM-frame profile) — a display
+# choice, not a calculation grid: the GL theta-nodes sample the star-convex
+# frame and cannot replace it. Tier-1 call: display density is a consumer
+# choice the cache's u-grid must not dictate.
+N_PROFILE_POINTS = 721
+N_RHO_GRID = 7201   # cache u-grid — WMMM's N_FOS_RHO_GRID_POINTS
+PARAM_KEYS = ("c", "a3", "a4", "a5", "a6", "a7", "a8")
+
+
+class FoSRender:
+    name = "fos"
+    has_extra_panel = True
+    # Ranges and practical-limit markers from ShapePlotterFoSFitter.
+    slider_specs = [
+        SliderSpec("c", "c", 0.5, 3.5, 1.0, 0.01, markers=(1.0, 3.0)),
+        SliderSpec("a3", "a3", -0.6, 0.6, 0.0, 0.01, markers=(0.0, 0.5)),
+        SliderSpec("a4", "a4", -0.75, 0.75, 0.0, 0.01, markers=(-0.2, 0.72)),
+    ] + [SliderSpec(f"a{i}", f"a{i}", -0.5, 0.5, 0.0, 0.01, markers=(-0.2, 0.2))
+         for i in range(5, 9)]
+    toggles: list[ToggleSpec] = []
+
+    def __init__(self) -> None:
+        # One read-only cache: max_params 7, WMMM-parity u-grid, GL-2048 thetas.
+        self._cache = fp.Cache(len(PARAM_KEYS), N_RHO_GRID, nodes.THETA)
+
+    def compute(self, params: dict[str, float], toggles: dict[str, bool]) -> ShapeResult:
+        arr = [params[k] for k in PARAM_KEYS]
+        shp = self._cache.shape(arr)
+        rd = self._cache.radius_and_derivative(arr) if shp.ok else None
+        prof = fp.rho_z_grid(arr, N_PROFILE_POINTS)
+        ok = shp.ok and rd is not None and rd.ok and prof.ok
+        # A separated shape fails the checked profile with rho_negative; draw
+        # its fragments from the unchecked profile (rho = 0 in the void). The
+        # checked results keep deciding ok, status and title.
+        drawn = (fp.rho_z_grid_unchecked(arr, N_PROFILE_POINTS)
+                 if prof.status == fp.Status.rho_negative else prof)
+
+        if ok:
+            radii, dr_dtheta = rd.radii, rd.dr_dtheta
+        else:
+            radii = np.zeros(nodes.N_NODES)
+            dr_dtheta = np.zeros(nodes.N_NODES)
+
+        primary = shp if not shp.ok else (rd if not rd.ok else prof)
+
+        # Cylindrical path carries its own rho-negative gate (2.0.0 gating
+        # asymmetry): separated shapes fail inside neck(); non-star-convex
+        # and beak-marginal shapes still yield a lib neck.
+        neck_info = None
+        nk = self._cache.neck(arr)
+        if nk.ok and nk.found and nk.rho_neck > 0.0:
+            depth = 0.0
+            if drawn.ok:
+                hit = find_neck_indices(drawn.rho)
+                if hit is not None:
+                    depth = neck_depth(drawn.rho, *hit)
+            neck_info = NeckInfo(z=nk.z_neck, rho=nk.rho_neck,
+                                 depth=depth, source="lib")
+        # The FoS shape is COM-centered by definition (rho_z_grid is the COM
+        # frame). The R(θ) representation carries the star-convexity shift, so its
+        # own COM is offset — the engine draws that overlay separately.
+        return ShapeResult(
+            status=int(primary.status), status_name=primary.status.name,
+            message=primary.message,
+            theta=nodes.THETA, radius=radii,
+            z=drawn.z, rho=drawn.rho, drho_dz=drawn.drho_dz,
+            neck=neck_info,
+            scalars={"z_shift": shp.z_shift, "a2": fp.a2(arr)},
+            length_keys=frozenset({"z_shift"}),
+            dr_dtheta=dr_dtheta, r_north=shp.r_north, r_south=shp.r_south, z_cm=0.0)
+
+    def filename(self, z: int, n: int, params: dict[str, float]) -> str:
+        return (f"fos_shape_Z{z}_N{n}_c{params['c']:.2f}"
+                + "".join(f"_a{i}{params[f'a{i}']:.2f}" for i in range(3, 9))
+                + ".png")
+
+    def energy_requests(self, params: dict[str, float],
+                        result: ShapeResult) -> list[EnergyRequest]:
+        """One request — the FoS dashed overlay is a reframing of the same
+        shape, not a second shape; com_correction is inert on the FoS path."""
+        return [EnergyRequest("FoS", "fos",
+                              tuple(params[k] for k in PARAM_KEYS),
+                              com_correction=True)]

shape_plotters-0.1.0.dist-info/METADATA

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: shape-plotters
+Version: 0.1.0
+Summary: Interactive matplotlib plotters for axially symmetric nuclear shapes (beta, FoS)
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/AleksanderAugustyn/shape-plotters
+Project-URL: Repository, https://github.com/AleksanderAugustyn/shape-plotters
+Project-URL: Changelog, https://github.com/AleksanderAugustyn/shape-plotters/blob/master/CHANGELOG.md
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.0
+Requires-Dist: scipy>=1.13
+Requires-Dist: matplotlib>=3.8.4
+Requires-Dist: beta-parameterization==4.0.1
+Requires-Dist: fos-parameterization==3.0.0
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Dynamic: license-file
+
+# shape-plotters
+
+Interactive matplotlib plotters for axially symmetric nuclear shapes. Move a
+slider and the shape, its derivative and its integral properties update. One
+shared engine draws the figure; each shape parameterization is a render module.
+
+| render | parameterization | sliders | library |
+|---|---|---|---|
+| `beta` | spherical-harmonic (Legendre) expansion | β1–β8 | [beta-parameterization](https://github.com/AleksanderAugustyn/beta-parameterization) |
+| `fos` | Fourier-over-Spheroid | c, a3–a8 | [fos-parameterization](https://github.com/AleksanderAugustyn/fos-parameterization) |
+
+The shapes are not re-implemented here. R(θ) and the analytic dR/dθ come from
+the compiled libraries, evaluated on a 2048-node Gauss-Legendre grid in cos θ.
+That is the dense grid of the WMMM macroscopic-microscopic energy model, so
+the plot shows exactly the shape the model evaluates.
+
+## What the figure shows
+
+- **R(θ) and dR/dθ**, and the **cross-section** ρ(z) with equal axes. The FoS
+  render adds a ρ(z) panel with the library's dρ/dz.
+- **Stats:** volume, surface and centre of mass by Gauss-Legendre quadrature,
+  the neck position, radius and depth, and the fragment volume and mass split
+  at the neck.
+- **Overlays** (orange, dashed): for beta, the centre-of-mass corrected shape
+  when its β1 differs from the slider value; for FoS, the R(θ) star-convex
+  representation when its centre of mass is shifted.
+- **Scission bands:** the neck-radius range 1.2–1.5 fm, shaded.
+- **Invalid shapes** stay on screen, greyed, with the library's status as the
+  panel title.
+
+Controls: ± nudge buttons on every slider, an fm / R₀ unit toggle with Z and N
+boxes (R₀ = 1.16 A^(1/3) fm), Reset, and Save (300 dpi PNG named after the
+parameters, written to the current directory). Red dotted marks on the FoS
+sliders are practical limits.
+
+## Requirements
+
+- Linux x86-64. The parameterization libraries ship manylinux wheels only;
+  WSL2 with WSLg works.
+- Python 3.10 or newer with a matplotlib GUI backend. Tk is the default
+  (`python3-tk` on Debian/Ubuntu).
+
+## Install
+
+    pip install shape-plotters
+
+or `pipx install shape-plotters` to get the command without touching another
+environment. The parameterization libraries come along as prebuilt wheels
+(Fortran shared library and libgfortran bundled), pinned to the exact versions
+each render is written against.
+
+Under WSL, keep the virtual environment on the Linux filesystem, not under
+`/mnt/c`. The Windows drive is a 9P mount; a venv there makes matplotlib
+rendering sluggish (~5× slower).
+
+## Run
+
+    shape-plotters beta
+    shape-plotters fos
+
+`python -m shape_plotters beta` does the same.
+
+## Energy button
+
+An Energy button appears when a Python package named `wmmm` is importable. It
+prints the WMMM energies of the shape on screen. WMMM is not public yet and is
+not a dependency: without it the button is absent and nothing else changes.
+This repository contains the calling convention only, no model code, data or
+output.
+
+## Development
+
+    git clone https://github.com/AleksanderAugustyn/shape-plotters.git
+    cd shape-plotters
+    python3 -m venv ~/.venvs/shape-plotters
+    source ~/.venvs/shape-plotters/bin/activate
+    pip install -e ".[test]"
+    python -m pytest
+
+The WMMM smoke tests skip when `wmmm` is not installed. The frame-time budgets
+in `tests/test_perf.py` assume a venv on the Linux filesystem.
+
+    shape_plotters/cli.py          entry point and render registry
+    shape_plotters/core/           engine, widgets, quadrature, neck and fragment helpers
+    shape_plotters/core/result.py  the render contract (what a render gives the engine)
+    shape_plotters/renders/        one module per parameterization
+    tests/                         pytest suite, including frame-time budgets
+
+A new parameterization is a new module in `shape_plotters/renders/` that
+implements the render contract, plus one registry entry in `cli.py` and a
+pinned library in `pyproject.toml`. The engine needs no change.
+
+Releases are cut by pushing a version tag such as `0.1.0`; the `wheels`
+workflow builds, tests and publishes to PyPI.
+
+## License
+
+MIT, see [LICENSE](https://github.com/AleksanderAugustyn/shape-plotters/blob/master/LICENSE).
+Changes are recorded in
+[CHANGELOG.md](https://github.com/AleksanderAugustyn/shape-plotters/blob/master/CHANGELOG.md).

shape_plotters-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+shape_plotters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+shape_plotters/__main__.py,sha256=jEE_3YQRcSTsewHe2AA_6rp2nCYEf_zp-AK7KKRjIq0,44
+shape_plotters/cli.py,sha256=msJyvJMn8z0r4OO25k2pgddbxfSC2u0TA8-wdIRrDE0,699
+shape_plotters/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+shape_plotters/core/energy.py,sha256=x2rJPM5XQdUQDbLMAe8JirsicZd4blnQpMJI83qte-k,3328
+shape_plotters/core/engine.py,sha256=rnhgebjKbcj1wPxLpZXCtPuwDyTPFH5GYwJoWUjuHb8,21481
+shape_plotters/core/fragments.py,sha256=nTHZex17cvSJywHL1M2OMxRygNe6VgFPJFUdDaGLV_Y,2721
+shape_plotters/core/neck.py,sha256=tQIHcFT55JFyoLQKmWekHGOfkqsqWHRGlVGoE_yT7RI,1356
+shape_plotters/core/nodes.py,sha256=8kqgGqCN0foSgjA6W4ij_5z8MMHY0QdvDpYT5LvXKf8,927
+shape_plotters/core/quadrature.py,sha256=_jKz1Y_GG-gxLwHAwPop0az99Q0rAwPSvZScUrBztG4,1473
+shape_plotters/core/result.py,sha256=fRInQWY0h0fwCbOI2sUjO9L3N86AD8-e_moU-hkhsPg,3495
+shape_plotters/core/widgets.py,sha256=DkZmJdq8vpmOpDUEcLHn-tAajz4_614b3lZsDJA76P4,2949
+shape_plotters/renders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+shape_plotters/renders/beta.py,sha256=sXwzF87DG8vbgrGI2MV-qRxxqCp9JgFLDip_m4lj4qA,8611
+shape_plotters/renders/fos.py,sha256=xT4rfQy-u_xsjyb3C0d-dFQnT3nF9MOgIkeN7Ck6xak,5233
+shape_plotters-0.1.0.dist-info/licenses/LICENSE,sha256=TOWvwhGul1VrJu1mvCr4ROOVhUyrLLeyMrHlz43kvbM,1076
+shape_plotters-0.1.0.dist-info/METADATA,sha256=jswckpQ6D2Q6deO1B29ZFcStt-GTZKgONRRs5mTYXpM,5133
+shape_plotters-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+shape_plotters-0.1.0.dist-info/entry_points.txt,sha256=c9-sRNkE0HDFY-Cmoz-bYQnZbZ2uEKypBzlqdbTygHU,59
+shape_plotters-0.1.0.dist-info/top_level.txt,sha256=zNeTjJBofeWO2t8wqtCJhAm_sdGGTrLQokCA_sp1WCY,15
+shape_plotters-0.1.0.dist-info/RECORD,,

shape_plotters-0.1.0.dist-info/WHEEL

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

shape_plotters-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+shape-plotters = shape_plotters.cli:main