ANYfeSolver 0.5.0a1__py3-none-any.whl

anyfesolver/_b2_attachment_elimination_dev.py

@@ -0,0 +1,261 @@
+"""Bounded physical-patch attachment elimination of the actual stored KKT.
+
+Five-row physical laws remain unchanged. Six beam coordinates can be removed
+only when existing grouped patch rows give independent local right/left blocks.
+No global nullspace/inverse, symmetrization, new solver or physical threshold.
+"""
+from fractions import Fraction
+from hashlib import sha256
+import numpy as np
+from scipy import sparse
+from .linalg import MatrixClass, factorize_cached
+
+MAX_PATCH_NODES = 16
+MAX_LOCAL_SUPPORT = 6*MAX_PATCH_NODES
+MAX_PREPARED_BYTES = 512*1024**2  # Eligibility/storage screen; legacy fallback.
+
+
+def _independent_rows(block):
+    """Exact represented local rank proof only, at most 80x6 coefficients."""
+    basis, selected = {}, []
+    for index, values in enumerate(block):
+        row = [Fraction(float(value)) for value in values]
+        for pivot in sorted(basis):
+            value = row[pivot]
+            if value:
+                row = [a-value*b for a, b in zip(row, basis[pivot])]
+        pivot = next((i for i, value in enumerate(row) if value), None)
+        if pivot is not None:
+            value = row[pivot]
+            basis[pivot] = [entry/value for entry in row]
+            selected.append(index)
+        if len(selected) == 6:
+            return tuple(selected)
+    return ()
+
+
+def _bytes(matrix):
+    return matrix.data.nbytes+matrix.indices.nbytes+matrix.indptr.nbytes
+
+
+def _row_product_upper(matrix, right_row_counts):
+    return [sum(right_row_counts[int(j)] for j in matrix.indices[first:last])
+            for first, last in zip(matrix.indptr[:-1], matrix.indptr[1:])]
+
+
+def _reduced_operator(left, k, right, jbeta, cbeta):
+    # The storage screen bounds K@P, not L@K. Keep this association explicit:
+    # raw nonsymmetric J/C can give L and P different sparse supports.
+    kp = k @ right
+    return sparse.bmat(((left @ kp, left @ jbeta), (cbeta @ right, None)), format="csc")
+
+
+class AttachmentElimination:
+    """Immutable owner-local maps, with one reused existing global factor."""
+    def __init__(self, k, j, c, primal_free, beam_columns, remaining_rows,
+                 anchor_rows, right, left, inverse_right, inverse_left,
+                 reduced, diagnostics):
+        self.k, self.j, self.c = k, j, c
+        self.free, self.beam = primal_free, beam_columns
+        self.beta, self.alpha = remaining_rows, anchor_rows
+        self.right, self.left = right, left
+        self.inverse_right, self.inverse_left = inverse_right, inverse_left
+        self.reduced, self.info = reduced, diagnostics
+        self.primal_count, self.constraint_count = k.shape[0], c.shape[0]
+        for array in (self.free, self.beam, self.beta, self.alpha,
+                      *self.inverse_right, *self.inverse_left):
+            array.setflags(write=False)
+
+    def factorize(self):
+        handle = factorize_cached(self.reduced, MatrixClass.GENERAL)
+        return EliminatedHandle(self, handle)
+
+    def _local_action(self, inverses, values):
+        result = np.empty_like(values)
+        for group, inverse in enumerate(inverses):
+            rows = slice(6*group, 6*group+6)
+            result[rows] = inverse @ values[rows]
+        return result
+
+    def solve(self, handle, rhs):
+        rhs = np.asarray(rhs, dtype=float)
+        total = self.primal_count+self.constraint_count
+        if rhs.ndim not in (1, 2) or rhs.shape[0] != total or not np.isfinite(rhs).all():
+            raise RuntimeError("finite full attachment right-hand side required")
+        single = rhs.ndim == 1
+        values = rhs[:, None] if single else rhs
+        f, d = values[:self.primal_count], values[self.primal_count:]
+        lift = np.zeros_like(f)
+        lift[self.beam] = self._local_action(self.inverse_right, d[self.alpha])
+        reduced_rhs = np.vstack((self.left @ (f-self.k @ lift),
+                                 d[self.beta]-self.c[self.beta] @ lift))
+        if not np.isfinite(lift).all() or not np.isfinite(reduced_rhs).all():
+            raise RuntimeError("attachment affine elimination is not representable")
+        solved = handle.solve(reduced_rhs[:, 0] if single else reduced_rhs)
+        solved = np.asarray(solved, dtype=float)
+        solved = solved[:, None] if single else solved
+        primal = self.right @ solved[:len(self.free)]+lift
+        multipliers = np.empty((self.constraint_count, values.shape[1]))
+        multipliers[self.beta] = solved[len(self.free):]
+        anchor_rhs = f[self.beam]-(self.k @ primal)[self.beam]-(self.j[:, self.beta] @ multipliers[self.beta])[self.beam]
+        multipliers[self.alpha] = self._local_action(self.inverse_left, anchor_rhs)
+        result = np.vstack((primal, multipliers))
+        if not np.isfinite(result).all():
+            raise RuntimeError("attachment recovery is not representable")
+        return result[:, 0] if single else result
+
+
+class EliminatedHandle:
+    def __init__(self, maps, handle):
+        self.maps, self.handle = maps, handle
+
+    def __getattr__(self, name):
+        return getattr(self.handle, name)
+
+    def solve(self, rhs):
+        return self.maps.solve(self.handle, rhs)
+
+    def solve_many(self, rhs):
+        return self.solve(rhs)
+
+    def diagnostics(self):
+        return {**self.handle.diagnostics(), "attachment_elimination": dict(self.maps.info),
+                "restored_shape": [self.maps.primal_count+self.maps.constraint_count]*2}
+
+
+def prepare_attachment_elimination(matrix, primal_count, transformation, incidences):
+    """Return maps/reason; ineligibility never narrows existing model admission.
+
+    Caller admits only physical static, no points/H/body/spectral. Input bytes
+    are copied and the operator/support signature is fixed once, never per load.
+    Arbitrary constraint RHS, including original-target correction, is retained.
+    """
+    a = matrix.tocsr(copy=True)
+    t = transformation.tocsr(copy=True)
+    a.eliminate_zeros(); t.eliminate_zeros()
+    a.sort_indices(); t.sort_indices()
+    n, m = primal_count, a.shape[0]-primal_count
+    if n <= 0 or a.shape != (n+m, n+m) or m <= 0 or t.shape[1] != n or not np.isfinite(a.data).all():
+        return None, "invalid_local_layout"
+    if np.any(a[n:, n:].data != 0.):
+        return None, "nonzero_multiplier_compliance"
+    groups = {}
+    for item in incidences:
+        if item.row_count != 5:
+            return None, "not_five_row_physical_incidence"
+        groups.setdefault(item.footprint_id, []).append(item)
+    if not groups or sum(5*len(items) for items in groups.values()) != m:
+        return None, "incomplete_physical_incidence"
+    inventory = [i.row_start+v for items in groups.values() for i in items for v in range(5)]
+    if set(inventory) != set(range(m)) or len(inventory) != len(set(inventory)):
+        return None, "invalid_physical_row_inventory"
+    k, j, c = a[:n, :n].tocsr(), a[:n, n:].tocsr(), a[n:, :n].tocsr()
+    tc = t.tocsc()
+    selected_beam, selected_rows, used_shell, used_beam = [], [], set(), set()
+    inverses_b, inverses_d, local = [], [], []
+    for items in groups.values():
+        if len(items) > MAX_PATCH_NODES or len({i.shell_node for i in items}) != len(items):
+            return None, "bounded_patch_incidence_required"
+        shell_slots = {int(v) for i in items for v in i.shell_slots}
+        beam_slots = tuple(map(int, items[0].beam_slots))
+        if (len(beam_slots) != 6 or any(tuple(i.beam_slots) != beam_slots for i in items) or
+                used_shell.intersection(shell_slots) or used_beam.intersection(beam_slots)):
+            return None, "overlapping_attachment_blocks"
+        columns = []
+        for slot in beam_slots:
+            if slot < 0 or slot >= t.shape[0]:
+                return None, "invalid_beam_coordinate_inventory"
+            start, stop = t.indptr[slot:slot+2]
+            if stop-start != 1 or t.data[start] != 1.:
+                return None, "fully_free_beam_selector_required"
+            column = int(t.indices[start])
+            if tc.indptr[column+1]-tc.indptr[column] != 1:
+                return None, "beam_coordinate_shared_by_affine_map"
+            columns.append(column)
+        if len(set(columns)) != 6:
+            return None, "distinct_beam_coordinates_required"
+        rows = np.array([i.row_start+v for i in items for v in range(5)], dtype=int)
+        if np.any(rows < 0) or np.any(rows >= m):
+            return None, "invalid_physical_row_inventory"
+        rank_rows = _independent_rows(c[rows][:, columns].toarray())
+        if not rank_rows:
+            return None, "local_position_director_rank_deficient"
+        alpha = rows[np.array(rank_rows)]
+        b = c[alpha][:, columns].toarray()
+        d = j[columns][:, alpha].toarray()
+        if not _independent_rows(d):
+            return None, "local_left_block_rank_deficient"
+        outside = np.setdiff1d(np.arange(m), rows, assume_unique=True)
+        if c[outside][:, columns].nnz:
+            return None, "foreign_right_attachment_coupling"
+        if j[columns][:, outside].nnz:
+            return None, "foreign_left_attachment_coupling"
+        try:
+            ib, id_ = np.linalg.solve(b, np.eye(6)), np.linalg.solve(d, np.eye(6))
+        except np.linalg.LinAlgError:
+            return None, "local_binary64_solve_unresolved"
+        if not np.isfinite(ib).all() or not np.isfinite(id_).all():
+            return None, "local_elimination_unrepresentable"
+        selected_beam.extend(columns); selected_rows.extend(map(int, alpha))
+        used_shell.update(shell_slots); used_beam.update(beam_slots)
+        inverses_b.append(ib); inverses_d.append(id_)
+        local.append((np.array(columns), alpha, rows))
+    beam, alpha = np.array(selected_beam), np.array(selected_rows)
+    if len(set(alpha)) != len(alpha):
+        return None, "overlapping_constraint_rows"
+    free = np.setdiff1d(np.arange(n), beam, assume_unique=True)
+    beta = np.setdiff1d(np.arange(m), alpha, assume_unique=True)
+    pr, pc, pv = list(map(int, free)), list(range(len(free))), [1.]*len(free)
+    lr, lc, lv = list(range(len(free))), list(map(int, free)), [1.]*len(free)
+    used_support = set()
+    for (columns, anchors, rows), ib, id_ in zip(local, inverses_b, inverses_d):
+        right_part = c[anchors][:, free].tocsr()
+        touched_right = np.unique(right_part.indices)
+        left_part = j[free][:, anchors].tocsr()
+        touched_left = np.unique(left_part.tocoo().row)
+        support = set(map(int, touched_right)) | set(map(int, touched_left))
+        all_constraint_support = set(map(int, c[rows][:, free].indices))
+        if len(support | all_constraint_support) > MAX_LOCAL_SUPPORT or used_support.intersection(support | all_constraint_support):
+            return None, "overlapping_or_unbounded_affine_patch_support"
+        used_support.update(support | all_constraint_support)
+        z = -ib @ right_part[:, touched_right].toarray()
+        y = -left_part[touched_left].toarray() @ id_
+        for i, column in enumerate(columns):
+            for at, value in zip(touched_right, z[i]):
+                if value != 0.:
+                    pr.append(int(column)); pc.append(int(at)); pv.append(float(value))
+        for i, at in enumerate(touched_left):
+            for column, value in zip(columns, y[i]):
+                if value != 0.:
+                    lr.append(int(at)); lc.append(int(column)); lv.append(float(value))
+    right = sparse.coo_matrix((pv, (pr, pc)), shape=(n, len(free))).tocsr()
+    left = sparse.coo_matrix((lv, (lr, lc)), shape=(len(free), n)).tocsr()
+    if not np.isfinite(right.data).all() or not np.isfinite(left.data).all():
+        return None, "affine_maps_unrepresentable"
+    kp_rows = _row_product_upper(k, list(map(int, np.diff(right.indptr))))
+    kk_upper = min(len(free)**2, sum(_row_product_upper(left, kp_rows)))
+    jbeta = j[:, beta].tocsr(); cbeta = c[beta].tocsr()
+    jj_upper = min(len(free)*len(beta), sum(_row_product_upper(left, list(map(int, np.diff(jbeta.indptr))))))
+    cc_upper = min(len(free)*len(beta), sum(_row_product_upper(cbeta, list(map(int, np.diff(right.indptr))))))
+    estimated_bytes = sum(map(_bytes, (a, k, j, c, right, left)))+24*(kk_upper+jj_upper+cc_upper+sum(kp_rows))
+    if estimated_bytes > MAX_PREPARED_BYTES:
+        return None, "bounded_sparse_preparation_storage_exceeded"
+    reduced = _reduced_operator(left, k, right, jbeta, cbeta)
+    reduced.eliminate_zeros(); reduced.sort_indices()
+    if not np.isfinite(reduced.data).all():
+        return None, "reduced_operator_unrepresentable"
+    signature = sha256()
+    for operand in (a, t):
+        signature.update(repr(operand.shape).encode())
+        for values in (operand.data, operand.indices, operand.indptr):
+            signature.update(values.tobytes())
+    info = {"groups": len(groups), "eliminated_primal": len(beam), "eliminated_multipliers": len(alpha),
+            "retained_constraints": len(beta), "full_shape": a.shape, "reduced_shape": reduced.shape,
+            "full_nnz": a.nnz, "reduced_nnz": reduced.nnz, "right_map_nnz": right.nnz,
+            "left_map_nnz": left.nnz, "estimated_sparse_array_bytes_with_product_nnz_bound": estimated_bytes,
+            "prepared_operator_bytes": sum(map(_bytes, (k, j, c, right, left, reduced))),
+            "storage_scope": "sparse arrays/product nnz screen; excludes Python containers, allocator temporaries and factor fill; not a process RSS upper bound",
+            "operator_support_signature": signature.hexdigest(), "raw_left_right_distinct": True,
+            "factor_fill_bytes": "not estimated or measured", "qualification": False}
+    return AttachmentElimination(k, j, c, free, beam, beta, alpha, right, left,
+                                 tuple(inverses_b), tuple(inverses_d), reduced, info), "eligible"

anyfesolver/_b2_f10_f11_point_attachment.py

@@ -0,0 +1,163 @@
+"""Private reference-linearized B2/finite-shell-support point experiment.
+
+The shell port is the least-squares rigid motion of three or four *physical* vertex
+translations. Its finite support, coordinates and weights are explicit; no
+isolated drilling rotation, penalty, shell stiffness or public MPC is inferred.
+The beam port uses the physical B2 member's sectional station trace. The
+constraint differential comes from the existing objective master-frame joint
+at its stress-free reference. This is a G0 development operator only.
+"""
+
+from dataclasses import dataclass
+
+import numpy as np
+
+from ._b2_physical_linear_definition import PhysicalB2Member
+from ._ge_beam3_pose_joint import RigidPoseJoint
+
+
+LAW_ID = "B2_FINITE_Q4_POINT_REFERENCE_LINEAR_V1_DEV"
+S3_LAW_ID = "B2_FINITE_S3_POINT_REFERENCE_LINEAR_V1_DEV"
+
+
+def _skew(v):
+    return np.array([[0., -v[2], v[1]], [v[2], 0., -v[0]],
+                     [-v[1], v[0], 0.]])
+
+
+def _finite(value, shape, label):
+    a = np.asarray(value, dtype=float)
+    if a.shape != shape or not np.isfinite(a).all():
+        raise ValueError(f"finite {label} with shape {shape} required")
+    return a.copy()
+
+
+@dataclass(frozen=True)
+class ReferencePointLaw:
+    shell_reference_m: np.ndarray
+    beam_reference_m: np.ndarray
+    shell_port: np.ndarray
+    beam_port: np.ndarray
+    constraint: np.ndarray
+    reference_frames: np.ndarray
+    law_id: str = ""
+    production_qualified: bool = False
+    beam_constraint_differential: np.ndarray | None = None
+
+    def __post_init__(self):
+        port_shape = np.asarray(self.shell_port).shape
+        if (len(port_shape) != 2 or port_shape[0] != 6 or
+                port_shape[1] not in (18, 24)):
+            raise ValueError("three- or four-vertex physical shell port required")
+        shell_width = port_shape[1]
+        expected_id = S3_LAW_ID if shell_width == 18 else LAW_ID
+        if self.law_id and self.law_id != expected_id:
+            raise ValueError("point law identity does not match shell support")
+        object.__setattr__(self, "law_id", expected_id)
+        for name, shape in (("shell_reference_m", (3,)),
+                            ("beam_reference_m", (3,)),
+                            ("shell_port", (6, shell_width)),
+                            ("beam_port", (6, 12)),
+                            ("constraint", (6, shell_width+12)),
+                            ("reference_frames", (2, 3, 3))):
+            owned = _finite(getattr(self, name), shape, name)
+            # A bytes-backed view cannot be made writable by a caller, so
+            # the reference curvature cannot drift from its stored rows.
+            sealed = np.frombuffer(owned.tobytes(), dtype=np.float64).reshape(shape)
+            object.__setattr__(self, name, sealed)
+        if self.beam_constraint_differential is not None:
+            owned = _finite(self.beam_constraint_differential, (6, 6), "beam pose differential")
+            object.__setattr__(self, "beam_constraint_differential",
+                               np.frombuffer(owned.tobytes(), dtype=float).reshape(6, 6))
+
+    def gap(self, shell_displacement, beam_displacement):
+        shell = _finite(shell_displacement, (self.shell_port.shape[1],),
+                        "shell displacement")
+        beam = _finite(beam_displacement, (12,), "beam displacement")
+        return self.constraint @ np.r_[shell, beam]
+
+    def multiplier_work(self, shell_displacement, beam_displacement, multiplier):
+        lam = _finite(multiplier, (6,), "point multiplier")
+        return float(lam @ self.gap(shell_displacement, beam_displacement))
+
+    def forces(self, multiplier):
+        lam = _finite(multiplier, (6,), "point multiplier")
+        action = self.constraint.T @ lam
+        shell_width = self.shell_port.shape[1]
+        return action[:shell_width], action[shell_width:]
+
+    def candidate_prestress_curvature(self, multiplier):
+        """Reference Hessian of objective multiplier work through affine ports.
+
+        This is a private conservative spectral candidate.  The ordinary
+        reference-linear static gap and stiffness remain affine.
+        """
+        lam = _finite(multiplier, (6,), "point multiplier")
+        positions = np.stack((self.shell_reference_m, self.beam_reference_m))
+        joint = RigidPoseJoint(positions, self.reference_frames)
+        pose = joint.evaluate(positions, self.reference_frames, lam)
+        shell_width = self.shell_port.shape[1]
+        port = np.zeros((12, shell_width+12))
+        port[:6, :shell_width] = self.shell_port
+        port[6:, shell_width:] = self.beam_port
+        return np.array(port.T @ pose.chart_hessian[:12, :12] @ port,
+                        copy=True)
+
+
+def compile_reference_point(member: PhysicalB2Member, shell_vertices_m, *,
+                            station: float, offset_local_m=(0., 0., 0.)):
+    """Return six affine rows for one finite shell support and B2 station.
+
+    Shell DOFs are three or four [ux,uy,uz,rx,ry,rz] tuples. The shell port's rigid
+    translation/rotation is the equal-vertex-weight fit of the *nodal
+    translations*. Rotational shell DOFs still enter the actual shell stiffness;
+    they are deliberately not identified with an unsupported nodal drill.
+    """
+    if not isinstance(member, PhysicalB2Member):
+        raise ValueError("owned physical B2 member required")
+    shape = np.asarray(shell_vertices_m).shape
+    if shape not in ((3, 3), (4, 3)):
+        raise ValueError("three or four shell vertices required")
+    x = _finite(shell_vertices_m, shape, "shell vertices")
+    if type(station) not in (int, float) or not np.isfinite(station) or not 0. <= station <= 1.:
+        raise ValueError("normalized B2 station in [0,1] required")
+    origin = x.mean(axis=0)
+    radius = x-origin
+    fit = np.zeros((3*len(x), 6))
+    for i, r in enumerate(radius):
+        fit[3*i:3*i+3, :3] = np.eye(3)
+        fit[3*i:3*i+3, 3:] = -_skew(r)
+    if np.linalg.matrix_rank(fit) != 6:
+        raise ValueError("finite noncollinear shell point support required")
+    # Equal weights identify the actual support vertices. A least-squares
+    # fit is a kinematic port; shell constitutive stiffness is supplied outside.
+    left = np.linalg.solve(fit.T @ fit, fit.T)
+    shell_port = np.zeros((6, 6*len(x)))
+    for i in range(len(x)):
+        shell_port[:, 6*i:6*i+3] = left[:, 3*i:3*i+3]
+    trace = member.trace_global(np.zeros(12), stations=(float(station),),
+                                offset_local_m=offset_local_m)
+    beam_port = trace.jacobian[0].copy()
+    point = trace.reference_points_m[0].copy()
+    normal = np.cross(x[1]-x[0], x[-1]-x[0])
+    area_scale = np.linalg.norm(normal)
+    diameter = max(np.linalg.norm(a-b) for a in x for b in x)
+    if area_scale <= 1e-12*diameter**2:
+        raise ValueError("nondegenerate shell reference plane required")
+    normal /= area_scale
+    if max(abs((vertex-origin)@normal) for vertex in x) > 1e-10*diameter:
+        raise ValueError("planar shell point support required")
+    tangent = x[1]-x[0]
+    tangent /= np.linalg.norm(tangent)
+    side = np.cross(normal, tangent)
+    shell_frame = np.column_stack((tangent, side, normal))
+    beam_frame = member.local_frame_rows().T
+    reference_positions = np.array((origin, point))
+    reference_frames = np.array((shell_frame, beam_frame))
+    joint = RigidPoseJoint(reference_positions, reference_frames)
+    derivative = joint.evaluate(reference_positions, reference_frames,
+                                np.zeros(6)).constraint_jacobian
+    constraint = np.column_stack((derivative[:, :6] @ shell_port,
+                                  derivative[:, 6:] @ beam_port))
+    return ReferencePointLaw(origin, point, shell_port, beam_port, constraint,
+                             reference_frames, beam_constraint_differential=derivative[:, 6:])

anyfesolver/_b2_loaded_point_trace_dev.py

@@ -0,0 +1,173 @@
+"""Member-local compilation for the explicit fixed-end loaded-point policy.
+
+B maps local PORT pose to constraint channels, without an offset shift. External
+port wrench is -B.T*lambda. FixedEndLoadBubbleMaps owns the offset work maps;
+section actions shift port moment to the axis once. Green blocks are B_i G_ij
+B_j.T, including every same-member pair. No global dense operator is created.
+Energy uses compiled, segmented polynomial pose samples, not recovered strains.
+"""
+from fractions import Fraction
+
+import numpy as np
+
+from ._b2_physical_flexibility_linear import (
+    RepresentabilityError, _array, _float, _matmul, _multiply, _transpose,
+)
+from ._b2_physical_load_bubbles import (
+    FixedEndLoadBubbleMaps, _axis_bubble, _axis_wrench, _poly_value,
+)
+
+
+def _rational(matrix):
+    return tuple(tuple(Fraction(float(v)) for v in row) for row in matrix)
+
+
+def _owned(array):
+    value = np.asarray(array, dtype=float)
+    if not np.isfinite(value).all():
+        raise RepresentabilityError("loaded-point map is not representable")
+    return np.frombuffer(value.tobytes(), dtype=float).reshape(value.shape)
+
+
+def checked_sparse_action(matrix, values):
+    """Retain actual stored contribution sums without an absolute unit floor."""
+    rational = tuple(Fraction(float(v)) for v in values)
+    result, scale = [], []
+    for row in range(matrix.shape[0]):
+        low, high = matrix.indptr[row:row+2]
+        products = tuple(Fraction(float(coefficient))*rational[index]
+                         for coefficient, index in zip(matrix.data[low:high], matrix.indices[low:high]))
+        result.append(sum(products)); scale.append(sum(abs(v) for v in products))
+    return _array(result), _array(scale)
+
+
+class LoadedPointMember:
+    """Compile once for one member; cache only requested observation maps."""
+
+    def __init__(self, member, entries, *, body_enabled):
+        self.member = member
+        self.entries = tuple(entries)
+        self.point_indices = tuple(entry[0] for entry in entries)
+        self.stations = tuple(float(entry[1]) for entry in entries)
+        self.offsets = tuple(tuple(float(v) for v in entry[2]) for entry in entries)
+        self.port_constraints = tuple(_owned(entry[3]) for entry in entries)
+        self._constraints = tuple(_rational(value) for value in self.port_constraints)
+        self._recovery_maps = {}
+        knots = (0.,) + tuple(sorted({s for s in self.stations if 0. < s < 1.})) + (1.,)
+        nodes, weights = np.polynomial.legendre.leggauss(4)
+        quadrature, measure = [], []
+        for left, right in zip(knots, knots[1:]):
+            quadrature.extend(left+(right-left)*(nodes+1.)/2.)
+            measure.extend(float(member.operator.length)*(right-left)*weights/2.)
+        self.quadrature_stations = tuple(map(float, quadrature))
+        self.quadrature_weights = _owned(measure)
+        self.maps = FixedEndLoadBubbleMaps(member.operator,
+            stations=self.stations+self.quadrature_stations,
+            point_stations=self.stations,
+            observation_offsets_local_m=self.offsets+((0., 0., 0.),)*len(quadrature),
+            point_offsets_local_m=self.offsets)
+        count = len(entries)
+        compliance = np.zeros((6*count, 6*count))
+        for i in range(count):
+            for j in range(i, count):
+                green = _rational(self.maps.point_compliance[6*i:6*i+6, 6*j:6*j+6])
+                block = _array(_matmul(_matmul(self._constraints[i], green),
+                                       _transpose(self._constraints[j])))
+                compliance[6*i:6*i+6, 6*j:6*j+6] = block
+                compliance[6*j:6*j+6, 6*i:6*i+6] = block.T
+        self.constraint_compliance = _owned(compliance)
+        body = np.zeros((6, 3))
+        if body_enabled:
+            with np.errstate(over="ignore", invalid="ignore"):
+                body = (member.definition.mass.matrix_at_reference_axis()[:, :3]
+                        @ member.definition.local_frame_rows())
+        self.body_wrench_map = _owned(body)
+        self._body_wrench = _rational(body)
+        constraint_body = []
+        for i in range(count):
+            pose = _rational(self.maps.uniform_pose_map[i])
+            constraint_body.extend(_matmul(_matmul(self._constraints[i], pose), self._body_wrench))
+        self._body_constraint = tuple(tuple(row) for row in constraint_body)
+        self.body_constraint_map = _owned(_array(constraint_body).reshape(6*count, 3))
+
+    def body_uniform(self, acceleration):
+        if acceleration is None:
+            return np.zeros(6)
+        return _array(_multiply(self._body_wrench, tuple(Fraction(float(v)) for v in acceleration)))
+
+    def body_constraint(self, acceleration):
+        if acceleration is None:
+            return np.zeros(6*len(self.entries)), np.zeros(6*len(self.entries))
+        values = tuple(Fraction(float(v)) for v in acceleration)
+        result = _array(_multiply(self._body_constraint, values))
+        scale = _array(tuple(sum(abs(a*b) for a, b in zip(row, values))
+                             for row in self._body_constraint))
+        return result, scale
+
+    def port_wrenches(self, multipliers):
+        return np.asarray(tuple(-_array(_multiply(_transpose(matrix),
+            tuple(Fraction(float(v)) for v in multipliers[6*index:6*index+6])))
+            for matrix, index in zip(self._constraints, self.point_indices))).reshape(-1, 6)
+
+    def section_actions(self, point_wrenches):
+        result = []
+        for station, offset, wrench in zip(self.stations, self.offsets, point_wrenches):
+            if 0. < station < 1.:
+                shifted = _axis_wrench(tuple(Fraction(float(v)) for v in wrench),
+                                       tuple(Fraction(v) for v in offset))
+                result.append((station, _array(shifted)))
+        return tuple(result)
+
+    def bubble_state(self, acceleration, multipliers):
+        uniform = self.body_uniform(acceleration)
+        points = self.port_wrenches(multipliers)
+        response = self.maps.evaluate(uniform, point_wrenches=points)
+        work = Fraction(0)
+        count = len(self.entries)
+        for wrench, pose in zip(points, response.pose[:count]):
+            work += sum(Fraction(float(a))*Fraction(float(b)) for a, b in zip(wrench, pose))
+        for weight, pose in zip(self.quadrature_weights, response.pose[count:]):
+            work += Fraction(float(weight))*sum(Fraction(float(a))*Fraction(float(b))
+                                               for a, b in zip(uniform, pose))
+        energy = _float(work/2)
+        if energy < 0.:
+            raise RepresentabilityError("loaded-point bubble energy is negative")
+        return uniform, points, energy
+
+    def recover_pose(self, local, stations, uniform, point_wrenches):
+        stations = tuple(float(v) for v in stations)
+        operator = self.member.operator
+        if stations not in self._recovery_maps:
+            # Use the canonical exact bubble kernel; do not compile another Green
+            # matrix or integrate the final recovered section strains each case.
+            basis = tuple(tuple(Fraction(int(i == j)) for i in range(6)) for j in range(6))
+            zero = (Fraction(0),)*6
+            uniform_maps, point_maps = [], []
+            for value in stations:
+                at = Fraction(value)
+                columns = tuple(_axis_bubble(operator.length, operator._compliance,
+                    _multiply(operator._uniform_load_map, unit), unit, at) for unit in basis)
+                uniform_maps.append(tuple(tuple(columns[c][r] for c in range(6)) for r in range(6)))
+                sources = []
+                for j, source in enumerate(self.stations):
+                    columns = tuple(_axis_bubble(operator.length, operator._compliance,
+                        tuple(self.maps._point_equivalent_exact[r][j][c] for r in range(12)),
+                        zero, at, Fraction(source),
+                        _axis_wrench(unit, tuple(Fraction(v) for v in self.offsets[j])))
+                        for c, unit in enumerate(basis))
+                    sources.append(tuple(tuple(columns[c][r] for c in range(6)) for r in range(6)))
+                point_maps.append(tuple(sources))
+            self._recovery_maps[stations] = (tuple(uniform_maps), tuple(point_maps))
+        uniform_maps, point_maps = self._recovery_maps[stations]
+        w = tuple(Fraction(float(v)) for v in uniform)
+        points = tuple(tuple(Fraction(float(v)) for v in row) for row in point_wrenches)
+        nodal = tuple(Fraction(float(v)) for v in local)
+        poses = []
+        for at, body, ports in zip(stations, uniform_maps, point_maps):
+            homogeneous = tuple(sum(_poly_value(poly, Fraction(at))*value for poly, value in zip(row, nodal))
+                                for row in operator._trace_polynomials)
+            loaded = _multiply(body, w)
+            for matrix, wrench in zip(ports, points):
+                loaded = [a+b for a, b in zip(loaded, _multiply(matrix, wrench))]
+            poses.append(tuple(a+b for a, b in zip(homogeneous, loaded)))
+        return _array(poses).reshape(len(stations), 6)