ANYfeSolver 0.5.0a1__py3-none-any.whl

anyfesolver/_ge_beam3_generalized_ellipsoid_section.py

@@ -0,0 +1,215 @@
+"""Private six-resultant associated ellipsoid section, not a fibre/J2 adapter."""
+from dataclasses import dataclass
+from decimal import Decimal as D, localcontext
+from hashlib import sha256
+from time import monotonic
+import numpy as np
+from ._ge_beam3_fibre_section import _owned,_number,canonical
+from ._ge_beam3_station_resultant_cell import dec,pair,mv,dot,solve,ident,cholesky
+from ._ge_beam3_effective_deadline import effective_deadline_seconds
+
+POLICY='GE_BEAM3_SIX_RESULTANT_ASSOCIATED_ELLIPSOID_HARDENING_V1'
+MEASURE='NATIVE_GENERALIZED_STRAIN_AND_REFERENCE_SECTION_RESULTANT_WORK'
+RECOVERY='RESULTANT_LEVEL_ONLY_NO_FIBRE_STRESSES_SUPPLIED'
+
+
+def _pair(x):
+    high,low=pair([x]);return high[0],low[0]
+
+
+def _parts(values,shape):
+    a,b=pair(values)
+    return _owned(np.array(a).reshape(shape),shape),_owned(np.array(b).reshape(shape),shape)
+
+
+def _unpair(value):
+    if type(value) is not tuple or len(value)!=2:raise ValueError('exact paired section scalar')
+    x=dec(value[0])+dec(value[1])
+    if _pair(x)!=value:raise ValueError('normalized paired section scalar')
+    return x
+
+
+@dataclass(frozen=True)
+class GeneralizedHistory:
+    section_identity: str
+    plastic: tuple
+    accumulated: tuple
+
+
+@dataclass(frozen=True)
+class GeneralizedResponse:
+    origin: GeneralizedHistory
+    history: GeneralizedHistory
+    strain: np.ndarray
+    strain_low: np.ndarray
+    resultants: np.ndarray
+    resultants_low: np.ndarray
+    tangent: np.ndarray
+    tangent_low: np.ndarray
+    compliance: np.ndarray
+    compliance_low: np.ndarray
+    dual_potential: tuple
+    incremental_potential: tuple
+    stored_energy: tuple
+    dissipation: tuple
+    plastic_increment: tuple
+    branch: str
+    derivative_kind: str
+    section_identity: str
+    recovery_status: str=RECOVERY
+    production_qualified: bool=False
+
+
+class EllipsoidalGeneralizedSection:
+    """C and M are explicit SPD work-coordinate tensors; H and Y are positive.
+
+    q(s)=sqrt(s.T M s). Flow is dz=dlambda*M*s/q and dp=dlambda.
+    The complete complementary incremental potential is
+    .5*s.T*C^-1*s + z0.s + max(q-Y-H*p0,0)^2/(2H).
+    This is a declared resultant law, never an inferred physical fibre model.
+    """
+    __slots__=('elastic','metric','yield_force','hardening','identity','_c','_m','_s','_compiled','_sealed')
+
+    def __setattr__(self,name,value):
+        if getattr(self,'_sealed',False):raise AttributeError('generalized section is immutable')
+        object.__setattr__(self,name,value)
+
+    def __init__(self,elastic,metric,yield_force,hardening):
+        self.elastic=_owned(elastic,(6,6));self.metric=_owned(metric,(6,6))
+        self.yield_force=_number(yield_force);self.hardening=_number(hardening)
+        if self.yield_force<=0 or self.hardening<=0:raise ValueError('positive yield and hardening required')
+        if not np.array_equal(self.elastic,self.elastic.T) or not np.array_equal(self.metric,self.metric.T):
+            raise ValueError('exact symmetric generalized tensors required')
+        with localcontext() as ctx:
+            ctx.prec=80
+            self._c=tuple(tuple(D.from_float(float(v)) for v in row) for row in self.elastic)
+            self._m=tuple(tuple(D.from_float(float(v)) for v in row) for row in self.metric)
+            cholesky(self._c);cholesky(self._m)
+            self._s=tuple(map(tuple,solve([list(row) for row in self._c],ident(6),lambda:None)))
+        self._compiled=(self._c,self._m,self._s)
+        self.identity=sha256(canonical(self.descriptor())).hexdigest();self._sealed=True
+
+    def descriptor(self):
+        return dict(policy=POLICY,measure=MEASURE,elastic=self.elastic,metric=self.metric,
+            yield_force=self.yield_force,hardening=self.hardening,recovery=RECOVERY)
+
+    def guard(self):
+        if sha256(canonical(self.descriptor())).hexdigest()!=self.identity:raise ValueError('generalized section authority changed')
+        if any(a is not b for a,b in zip((self._c,self._m,self._s),self._compiled)):
+            raise ValueError('generalized section compiled authority changed')
+
+    def virgin(self):
+        self.guard();return GeneralizedHistory(self.identity,((0.,0.),)*6,(0.,0.))
+
+    def _origin(self,origin):
+        if type(origin) is not GeneralizedHistory or origin.section_identity!=self.identity or type(origin.plastic) is not tuple or len(origin.plastic)!=6:
+            raise ValueError('owned six-component section history required')
+        z=list(map(_unpair,origin.plastic));p=_unpair(origin.accumulated)
+        if p<0:raise ValueError('nonnegative accumulated section increment')
+        # This point law permits an explicitly supplied initial plastic offset.
+        # Reachability from virgin state belongs to its authenticated history chain.
+        return z,p
+
+    def _dual(self,s,z0,p0):
+        h=dec(self.hardening);y=dec(self.yield_force);ms=mv(self._m,s);q=dot(s,ms).sqrt();radius=y+h*p0
+        lam=max(D(0),(q-radius)/h);z=z0[:];comp=[list(row) for row in self._s]
+        if lam:
+            n=[v/q for v in ms];z=[a+lam*b for a,b in zip(z0,n)]
+            for i in range(6):
+                for j in range(6):comp[i][j]+=n[i]*n[j]/h+lam*(self._m[i][j]-n[i]*n[j])/q
+        elastic=mv(self._s,s);e=[a+b for a,b in zip(elastic,z)]
+        p=p0+lam;ue=dot(s,elastic)/2
+        dual=ue+dot(z0,s)+max(D(0),q-radius)**2/(2*h)
+        potential=ue+h*(p*p-p0*p0)/2+y*lam
+        branch='PLASTIC' if lam else ('YIELD_BOUNDARY' if q==radius else 'ELASTIC')
+        return e,comp,z,p,lam,dual,potential,ue+h*p*p/2,y*lam,branch
+
+    def response(self,values,*,origin=None,control='strain'):
+        self.guard()
+        if control not in ('strain','resultant'):raise ValueError('explicit strain or resultant section control')
+        data=_owned(values,(6,));origin=self.virgin() if origin is None else origin
+        captured=canonical(origin);started=monotonic()
+        def check():
+            if monotonic()-started>effective_deadline_seconds(15.):raise RuntimeError('generalized section response deadline')
+            self.guard()
+        with localcontext() as ctx:
+            ctx.prec=80;z0,p0=self._origin(origin);v=list(map(lambda x:D.from_float(float(x)),data))
+            if control=='resultant':s=v
+            else:
+                target=[a-b for a,b in zip(v,z0)];s=mv(self._c,target)
+                radius=dec(self.yield_force)+dec(self.hardening)*p0;q=dot(s,mv(self._m,s)).sqrt()
+                if q>radius:
+                    left=D(0);right=1/dec(self.hardening)
+                    for iteration in range(256):
+                        check();tau=(left+right)/2
+                        matrix=[[self._s[i][j]+tau*self._m[i][j] for j in range(6)] for i in range(6)]
+                        s=[row[0] for row in solve(matrix,[[x] for x in target],check)]
+                        q=dot(s,mv(self._m,s)).sqrt();g=q*(1-dec(self.hardening)*tau)-radius
+                        if abs(g)<=D('1e-60')*max(D(1),radius):break
+                        if g>0:left=tau
+                        else:right=tau
+                    else:raise RuntimeError('generalized section return-map iteration limit')
+            e,comp,z,p,lam,dual,potential,stored,dissipation,branch=self._dual(s,z0,p0)
+            if control=='strain' and max(abs(a-b) for a,b in zip(e,v))>D('1e-50')*max(D(1),*(abs(x) for x in v)):
+                raise ValueError('generalized section primal return mismatch')
+            cholesky(comp);tangent=solve(comp,ident(6),check)
+            ep=_parts(e,(6,));sp=_parts(s,(6,))
+            cp=_parts([x for row in comp for x in row],(6,6));tp=_parts([x for row in tangent for x in row],(6,6))
+            result=GeneralizedResponse(origin,GeneralizedHistory(self.identity,tuple(map(_pair,z)),_pair(p)),*ep,*sp,*tp,*cp,
+                _pair(dual),_pair(potential),_pair(stored),_pair(dissipation),_pair(lam),branch,
+                'SEMISMOOTH_ELASTIC_SELECTION' if branch=='YIELD_BOUNDARY' else 'CLASSICAL_SMOOTH_BRANCH',self.identity)
+        check()
+        if canonical(origin)!=captured:raise ValueError('generalized origin changed during response')
+        return result
+
+
+@dataclass(frozen=True)
+class SectionProposal:
+    token: object
+    response: GeneralizedResponse
+
+
+class GeneralizedStation:
+    """Local transaction building block; global beam integration is separate."""
+    __slots__=('_section','_history','_epoch','_pending','_accepted')
+
+    def __init__(self,section):
+        if type(section) is not EllipsoidalGeneralizedSection:raise ValueError('exact generalized section')
+        self._section=section;self._history=section.virgin();self._epoch=0;self._pending=None;self._accepted=None
+
+    @property
+    def section(self):return self._section
+
+    @property
+    def history(self):return self._history
+
+    @property
+    def epoch(self):return self._epoch
+
+    def trial(self,strain):
+        self._pending=None
+        data=_owned(strain,(6,));response=self.section.response(data,origin=self.history)
+        proposal=SectionProposal(object(),response);self._pending=(proposal,data,self.history)
+        return proposal
+
+    def discard(self,proposal):
+        if self._pending is None or self._pending[0] is not proposal:raise ValueError('foreign or stale section proposal')
+        self._pending=None
+
+    def commit(self,proposal):
+        if self._pending is None or self._pending[0] is not proposal:raise ValueError('foreign or stale section proposal')
+        _,data,origin=self._pending
+        self._pending=None
+        if canonical(origin)!=canonical(self.history):raise ValueError('section origin changed before commit')
+        response=self.section.response(data,origin=origin)
+        if canonical(proposal.response)!=canonical(response):raise ValueError('section proposal response mutated')
+        self._history=response.history;self._epoch+=1;self._accepted=(data,origin,response,self.epoch)
+        return self.history
+
+    def replay(self):
+        if self._accepted is None:raise ValueError('no accepted generalized section response')
+        data,origin,response,epoch=self._accepted
+        if self.epoch!=epoch or canonical(self.history)!=canonical(response.history):raise ValueError('accepted section state changed')
+        made=self.section.response(data,origin=origin)
+        if canonical(made)!=canonical(response):raise ValueError('accepted generalized response replay mismatch')
+        return made

anyfesolver/_ge_beam3_generalized_static_boundary.py

@@ -0,0 +1,233 @@
+"""Private static reduction with spatial couples per reference arclength.
+
+The physical field is U_cell R0(s). Its spatial virtual rotation is the cell
+rotation variation, so distributed couples act on the internal cell rotations.
+They have no general SO(3) potential. No public element/state route is changed.
+"""
+from dataclasses import dataclass
+from decimal import localcontext
+from math import fsum
+from time import monotonic
+import numpy as np
+from scipy import linalg
+from ._ge_beam3_retained_generalized import RetainedGeneralizedOperator
+from ._ge_beam3_generalized_cell import GeneralizedCellHistory
+from ._ge_beam3_fibre_line_work import evaluate as line_work
+from ._ge_beam3_p5.algebra import rotation, skew
+from ._ge_beam3_p5.arrays import _array, _frames
+from ._ge_beam3_p5.chart import exp_chart_terms
+from ._ge_beam3_p5_seeded.core import sha
+from ._native_reference_modal import _owned
+from ._ge_beam3_effective_deadline import effective_deadline_seconds
+
+POLICY = 'GE_BEAM3_GENERALIZED_REFERENCE_SPATIAL_DISTRIBUTED_COUPLE_STATIC_V1'
+
+
+@dataclass(frozen=True)
+class GeneralizedStaticTrial:
+    rotations: np.ndarray
+    resultants: np.ndarray
+    residual: np.ndarray
+    spatial_jacobian: np.ndarray
+    internal_lift: np.ndarray
+    full_residual: np.ndarray
+    conservative_residual: np.ndarray
+    conservative_hessian: np.ndarray
+    full_spatial_jacobian: np.ndarray
+    applied_couple: np.ndarray
+    history: GeneralizedCellHistory
+    conservative_part_value: float
+    internal_error: float
+    iterations: int
+    input_sha256: str
+    conservative_potential: bool = False
+    conservative_spectral_authority: bool = False
+    production_qualified: bool = False
+    dynamic_reduction_authorized: bool = False
+
+
+def cell_couple_load(operator, spatial_density):
+    if type(operator) is not RetainedGeneralizedOperator:
+        raise ValueError('exact generalized retained operator required')
+    operator.guard()
+    density = _array(spatial_density, (3,), 'spatial reference couple density')
+    result = np.zeros(42)
+    for cell in (0, 1):
+        measure = fsum(row[3] for row in operator.stations if row[0] == cell)
+        if not np.isfinite(measure) or measure <= 0.:
+            raise ValueError('positive distributed couple reference measure')
+        with np.errstate(over='ignore', invalid='ignore'):
+            result[18+3*cell:21+3*cell] = measure*density
+    with np.errstate(over='ignore', invalid='ignore'):
+        norm = float(np.linalg.norm(result))
+    if not np.isfinite(result).all() or not np.isfinite(norm):
+        raise ValueError('distributed couple load exceeds finite norm range')
+    operator.guard()
+    return _owned(result)
+
+
+def spatial_jacobian(conservative_residual, conservative_hessian):
+    """Derivative of Rc-G, where G is fixed in spatial residual components.
+
+    Rc is the conservative material-minus-dead-line-work residual, NOT Rc-G.
+    Hc is its Exp-chart Hessian. D G=0 for this reference spatial load policy.
+    """
+    residual = _array(conservative_residual, (42,), 'conservative residual')
+    jacobian = _array(conservative_hessian, (42, 42), 'conservative Hessian')
+    for start in (3, 9, 15, 18, 21):
+        jacobian[start:start+3, start:start+3] -= .5*skew(residual[start:start+3])
+    return _owned(jacobian)
+
+
+def chart_pullback(force, jacobian, increments):
+    """Pull back a general spatial condensed Jacobian, without symmetrizing."""
+    force = _array(force, (18,), 'condensed spatial force')
+    jacobian = _array(jacobian, (18, 18), 'condensed spatial Jacobian')
+    increments = _array(increments, (3, 3), 'nodal rotation chart increments')
+    chart = np.eye(18)
+    extra = np.zeros((18, 18))
+    for node, vector in enumerate(increments):
+        start = 6*node+3
+        a, da = exp_chart_terms(vector)
+        chart[start:start+3, start:start+3] = a
+        for k in range(3):
+            extra[start:start+3, start+k] = da[:, :, k].T@force[start:start+3]
+    result = chart.T@force
+    tangent = chart.T@jacobian@chart+extra
+    if not np.isfinite(result).all() or not np.isfinite(tangent).all():
+        raise ValueError('nonfinite distributed couple chart response')
+    return _owned(result), _owned(tangent), _owned(chart)
+
+
+def _interior_residual_secant(base, rejected, fraction):
+    """Propose an interior residual-line minimizer; this is NOT acceptance.
+
+    Both residuals use the same frozen Newton inverse. Common normalization
+    avoids overflow in the dot products and leaves the minimizer unchanged.
+    There is no empirical damping floor or material-specific coefficient.
+    """
+    base = np.asarray(base, dtype=float)
+    rejected = np.asarray(rejected, dtype=float)
+    if (base.shape != (24,) or rejected.shape != (24,)
+            or not np.isfinite(base).all() or not np.isfinite(rejected).all()
+            or not np.isfinite(fraction) or not 0. < fraction <= 1.):
+        raise ValueError('invalid distributed static secant input')
+    scale = max(float(np.max(np.abs(base))), float(np.max(np.abs(rejected))))
+    if scale == 0.:
+        raise ValueError('degenerate distributed static secant residual')
+    z = base/scale
+    difference = rejected/scale-z
+    denominator = float(difference@difference)
+    if denominator == 0.:
+        raise ValueError('degenerate distributed static secant direction')
+    interior = -float(z@difference)/denominator
+    proposed = float(fraction*interior)
+    if not np.isfinite(proposed) or not 0. < interior < 1. or not 0. < proposed < fraction:
+        raise ValueError('distributed static secant is not strictly interior')
+    return proposed
+
+
+def solve_distributed_static(operator, positions, position_low, nodal_frames, *, origin,
+                             initial_rotations, initial_resultants, spatial_line_force,
+                             spatial_couple_density, check=None, max_iterations=24):
+    if type(operator) is not RetainedGeneralizedOperator or type(origin) is not GeneralizedCellHistory:
+        raise ValueError('exact retained operator and explicit accepted cell origin required')
+    if type(max_iterations) is not int or not 0 <= max_iterations <= 24:
+        raise ValueError('bounded distributed static internal iterations')
+    if check is not None and not callable(check):
+        raise ValueError('callable distributed static boundary check')
+    started = monotonic()
+    operator.guard()
+    with localcontext() as context:
+        context.prec = 80
+        operator.cell._origins(origin)
+    x = _array(positions, (3, 3), 'distributed static positions')
+    low = _array(position_low, (3, 3), 'distributed static low positions')
+    q = _frames(nodal_frames, 3, 'distributed static nodal frames')
+    u = _frames(initial_rotations, 2, 'distributed static seed rotations').copy()
+    p = _array(initial_resultants, (18,), 'distributed static seed resultants').copy()
+    load = _array(spatial_line_force, (3,), 'explicit spatial reference line force')
+    density = _array(spatial_couple_density, (3,), 'explicit spatial reference couple density')
+    applied = cell_couple_load(operator, density)
+    identity = sha(dict(policy=POLICY, operator=operator.identity, positions=x, position_low=low,
+                        nodal_frames=q, origin=origin, line_force=load, couple_density=density,
+                        applied_couple=applied, initial_rotations=u, initial_resultants=p))
+    length = float(np.linalg.norm(operator.reference.coordinates[-1]-operator.reference.coordinates[0]))
+    if not np.isfinite(length) or length <= 0.:
+        raise ValueError('positive distributed static characteristic length')
+    scale = np.r_[np.full(12, length), np.ones(12)]
+
+    def safe():
+        if check is not None:
+            check()
+        operator.guard()
+        if monotonic()-started > effective_deadline_seconds(60.):
+            raise RuntimeError('distributed static internal boundary deadline')
+
+    def evaluate(rotations, forces):
+        safe()
+        e = operator.evaluate(x, low, q, rotations, forces, origin=origin, check=safe)
+        rc = e.residual.copy()
+        h = e.hessian+e.hessian_low
+        value = e.potential
+        if np.any(load):
+            w = line_work(operator.reference, x, low, rotations, load, order=operator.order)
+            rc -= w.gradient
+            h = h-w.hessian
+            value -= w.value
+        net = rc-applied
+        error = float(np.linalg.norm(net[18:]/scale))
+        if not np.isfinite(error):
+            raise ValueError('nonfinite distributed static residual norm')
+        return e, rc, h, net, float(value), error
+
+    pending_secant = None
+    for iteration in range(max_iterations+1):
+        e, rc, h, net, value, error = evaluate(u, p)
+        if pending_secant is not None:
+            old_factor, old_norm = pending_secant
+            merit = float(np.linalg.norm(linalg.lu_solve(old_factor, net[18:], check_finite=True)))
+            if not np.isfinite(merit) or not (error <= 1e-11 or merit < old_norm):
+                raise ValueError('distributed static secant failed actual decrease')
+            pending_secant = None
+        jac = spatial_jacobian(rc, h)
+        if error <= 1e-11:
+            lift = -linalg.solve(jac[18:, 18:], jac[18:, :18], assume_a='gen', check_finite=True)
+            condensed = jac[:18, :18]+jac[:18, 18:]@lift
+            if not np.isfinite(condensed).all():
+                raise ValueError('nonfinite distributed static Schur response')
+            safe()
+            return GeneralizedStaticTrial(_owned(u), _owned(p), _owned(net[:18]), _owned(condensed),
+                _owned(lift), _owned(net), _owned(rc), _owned(h), _owned(jac), applied,
+                e.history, value, error, iteration, identity)
+        if iteration == max_iterations:
+            raise ValueError('distributed static internal equilibrium iteration limit')
+        factor = linalg.lu_factor(jac[18:, 18:], check_finite=True)
+        step = linalg.lu_solve(factor, -net[18:], check_finite=True)
+        norm = float(np.linalg.norm(step))
+        if not np.isfinite(step).all() or not np.isfinite(norm) or norm == 0.:
+            raise ValueError('invalid distributed static internal step')
+        angle = max(np.linalg.norm(step[:3]), np.linalg.norm(step[3:6]))
+        fraction = min(1., .45*np.pi/max(float(angle), np.finfo(float).tiny))
+        for cut in range(9):
+            safe()
+            delta = step*(fraction*.5**cut)
+            trial_u = np.array([rotation(delta[3*c:3*c+3])@u[c] for c in (0, 1)])
+            trial_p = p+delta[6:]
+            _, _, _, changed, _, metric = evaluate(trial_u, trial_p)
+            preconditioned = linalg.lu_solve(factor, changed[18:], check_finite=True)
+            merit = float(np.linalg.norm(preconditioned))
+            if not np.isfinite(merit):
+                raise ValueError('nonfinite distributed static internal merit')
+            if metric <= 1e-11 or merit < norm:
+                u, p = trial_u, trial_p
+                break
+        else:
+            # The next outer evaluation is already in the existing budget.
+            # Keep this proposal private until its actual decrease is checked.
+            fraction = _interior_residual_secant(-step, preconditioned, fraction*.5**8)
+            delta = step*fraction
+            u = np.array([rotation(delta[3*c:3*c+3])@u[c] for c in (0, 1)])
+            p = p+delta[6:]
+            pending_secant = (factor, norm)
+    raise AssertionError('unreachable distributed static state')

anyfesolver/_ge_beam3_lifted_kinetic_factor.py

@@ -0,0 +1,26 @@
+"""Private retained-cell kinetic factor at rest, without a dense mass root.
+
+The spatial velocity is I*v - skew(U*lift)*omega, with body components
+in U*R0. These are the preserved lifted-inertia equations; nodal rotation
+traces have exactly zero inertia. No cell condensation or mass floor.
+"""
+import numpy as np
+from ._ge_beam3_p5.arrays import _frames
+from ._ge_beam3_p5.algebra import skew
+from ._ge_beam3_p5_centered.mass import _CenteredRestInertia
+from ._native_reference_modal import _owned
+
+
+def current_lifted_kinetic_factor(reference, section_inertia, rotations, *, order):
+    cells = _frames(rotations, 2, 'current cell rotations')
+    source = _CenteredRestInertia(reference, section_inertia, order=order)
+    root = np.linalg.cholesky(source.section_mass).T
+    rows = []
+    for cell, left, right, t, frame, offset, measure in source._stations:
+        q = cells[cell]@frame; lift = cells[cell]@offset
+        velocity = np.zeros((6, 24)); slot = slice(18+3*cell, 21+3*cell)
+        velocity[:3, 6*left:6*left+3] = (1-t)*np.eye(3)
+        velocity[:3, 6*right:6*right+3] = t*np.eye(3)
+        velocity[:3, slot] = -skew(lift); velocity[3:, slot] = np.eye(3)
+        rows.append(np.sqrt(measure)*root@np.kron(np.eye(2), q).T@velocity)
+    return _owned(np.vstack(rows))

anyfesolver/_ge_beam3_line_fibre_modes.py

@@ -0,0 +1,121 @@
+"""Private at-rest spectra of accepted conservative reference-line-load states.
+
+Retain the external potential Hessian -lambda W'' of the lifted physical line.
+The accepted load and plastic coordinates are fixed during elastic perturbation.
+No finite-velocity dynamics, follower moments, nonlinear continuation, checkpoint
+conversion or buckling load-factor qualification is provided by this module.
+"""
+from dataclasses import dataclass
+from hashlib import sha256
+from time import monotonic
+import json
+import numpy as np
+from scipy.linalg import block_diag
+
+from ._ge_beam3_fibre_line_program import Context
+from ._ge_beam3_fibre_line_work import ReferenceLineForces, evaluate as line_work
+from ._ge_beam3_retained_fibre_modes import (
+    FROZEN, ALGORITHMIC, Packet as FibrePacket, Analysis as FibreAnalysis, compliance_factor,
+)
+from ._ge_beam3_lifted_kinetic_factor import current_lifted_kinetic_factor
+from ._native_exact_shift_chain_modes import solve_factor_chain_modes
+from ._native_reference_modal import _owned
+from ._ge_beam3_p5_seeded.core import sha
+from .control import cancellation_safe_point
+
+
+SCHEMA='GE_BEAM3_CONSERVATIVE_LINE_FIBRE_FIXED_LOAD_SPECTRA_V1'
+
+
+@dataclass(frozen=True)
+class Packet(FibrePacket):
+    external_potential_hessian: np.ndarray | None = None
+
+
+def prepare(model,program,checkpoint,section_inertias,*,line_forces,material_policy,
+            expected_checkpoint_sha256=None,cancellation_token=None,coordinate_limit=80,max_coordinates=256):
+    if type(line_forces) is not ReferenceLineForces: raise ValueError('explicit conservative reference line-force pattern')
+    if type(coordinate_limit) is not int or coordinate_limit not in (80,128,256):
+        raise ValueError('explicit admitted spectral coordinate limit')
+    if type(max_coordinates) is not int or max_coordinates not in (256,512):
+        raise ValueError('explicit admitted retained coordinate limit')
+    if material_policy not in (FROZEN,ALGORITHMIC): raise ValueError('explicit spectral material policy')
+    started=monotonic()
+    def local_check():
+        cancellation_safe_point(cancellation_token,'line-fibre-modes.construct')
+        if monotonic()-started>120.: raise TimeoutError('line-fibre spectral construction deadline')
+    local_check()
+    if type(checkpoint) is not bytes: raise ValueError('immutable canonical line-force checkpoint')
+    context=Context(model,program,line_forces=line_forces,check=local_check,max_coordinates=max_coordinates)
+    state,_=context.restore(checkpoint,expected_sha256=expected_checkpoint_sha256)
+    parameter=0. if state.completed_targets==0 else program.targets[state.completed_targets-1]
+    def guard():
+        local_check(); context.guard()
+    layout=context.layout; n=layout.nodal_count+6*len(context.probes)
+    if n>coordinate_limit: raise ValueError('bounded standalone line-load spectrum required')
+    if (type(section_inertias) is not dict or any(type(i) is not int for i in section_inertias)
+            or set(section_inertias)!={i for i,_ in layout.elements}):
+        raise ValueError('one explicit section inertia per element')
+    inertias={i:_owned(v) for i,v in section_inertias.items()}
+    forces={row[0]:row[1:] for row in line_forces.rows}
+    g=np.zeros((n,n)); external=np.zeros((n,n)); lefts=[]; rights=[]; kinetics=[]
+    mechanical=state.mechanical
+    for index,((eid,element),probe) in enumerate(zip(layout.elements,context.probes)):
+        guard(); nodes=layout.nodes[index]
+        response=probe.evaluate(mechanical.positions[nodes],mechanical.position_low[nodes],
+            mechanical.nodal_frames[nodes],mechanical.cell_rotations[index],mechanical.resultants[index],
+            origin=state.origins[index],check=local_check)
+        left=compliance_factor(probe,json.loads(response.material),state.origins[index],state.histories[index],
+            mechanical.resultants[index],policy=material_policy,check=local_check)
+        slots=list(element.get_dof_mapping(model.mesh))+list(range(layout.nodal_count+6*index,layout.nodal_count+6*index+6))
+        j=response.hessian[24:,:24]; right=np.zeros((36,n)); right[:,slots]=np.vstack((j,j))
+        g[np.ix_(slots,slots)]+=response.hessian[:24,:24]
+        if eid in forces:
+            work=line_work(probe.reference,mechanical.positions[nodes],mechanical.position_low[nodes],
+                mechanical.cell_rotations[index],forces[eid],order=probe.order)
+            external[np.ix_(slots,slots)]-=parameter*work.hessian[:24,:24]
+        local=current_lifted_kinetic_factor(probe.reference,inertias[eid],mechanical.cell_rotations[index],order=probe.order)
+        kinetic=np.zeros((len(local),n)); kinetic[:,slots]=local
+        lefts.append(left); rights.append(right); kinetics.append(kinetic)
+    g+=external
+    nodal_free=tuple(i for i in range(layout.nodal_count) if i not in layout.fixed)
+    free=nodal_free+tuple(range(layout.nodal_count,n)); algebraic=tuple(i for i in nodal_free if i%6>=3)
+    left,right,kinetic=block_diag(*lefts),np.vstack(rights),np.vstack(kinetics)
+    if np.any(kinetic[:,algebraic]): raise ValueError('nodal rotation traces must have zero inertia')
+    if not np.isfinite(g).all() or not np.isfinite(external).all(): raise ValueError('finite total potential Hessian')
+    identity=sha(dict(schema=SCHEMA,equilibrium_load_parameter=parameter,line_forces=line_forces.descriptor(),
+        perturbation_load_policy='FIXED_ACCEPTED_REFERENCE_ARCLENGTH_SPATIAL_DEAD_FORCE',
+        checkpoint_sha256=sha256(checkpoint).hexdigest(),material_policy=material_policy,
+        operators=[p.identity for p in context.probes],left=left,right=right,geometric=g,
+        external_potential_hessian=external,kinetic=kinetic,free=free,algebraic=algebraic,inertias=inertias,
+        spectral_coordinate_limit=coordinate_limit,retained_coordinate_limit=max_coordinates))
+    guard()
+    return Packet(_owned(left),_owned(right),_owned(g),_owned(kinetic),free,algebraic,identity,material_policy,
+        external_potential_hessian=_owned(external)),guard,parameter
+
+
+@dataclass(frozen=True)
+class Analysis(FibreAnalysis):
+    equilibrium_load_parameter: float = 0.
+    perturbation_load_policy: str = 'FIXED_ACCEPTED_REFERENCE_ARCLENGTH_SPATIAL_DEAD_FORCE'
+    external_potential_hessian_included: bool = True
+    checkpoint_converted: bool = False
+
+
+def solve_modes(model,program,checkpoint,section_inertias,*,line_forces,material_policy,bounds,
+                num_modes=6,root_width=1e-10,expected_checkpoint_sha256=None,cancellation_token=None,
+                coordinate_limit=80,exact_dimension_limit=64,max_coordinates=256):
+    if type(exact_dimension_limit) is not int or exact_dimension_limit not in (64,96,160):
+        raise ValueError('explicit admitted exact-inertia dimension limit')
+    packet,guard,parameter=prepare(model,program,checkpoint,section_inertias,line_forces=line_forces,
+        material_policy=material_policy,expected_checkpoint_sha256=expected_checkpoint_sha256,
+        cancellation_token=cancellation_token,coordinate_limit=coordinate_limit,max_coordinates=max_coordinates)
+    modes=solve_factor_chain_modes(packet.left,packet.right,packet.geometric,packet.kinetic,
+        packet.free,packet.algebraic,bounds=bounds,num_modes=num_modes,root_width=root_width,
+        cancellation_token=cancellation_token,exact_dimension_limit=exact_dimension_limit)
+    guard()
+    interpretation=('ELASTIC_PERTURBATIONS_WITH_PLASTIC_COORDINATES_FIXED' if material_policy==FROZEN else
+        'LAST_INCREMENT_OPERATOR_ONLY_NOT_PHYSICAL_VIBRATION_AUTHORITY')
+    return packet,Analysis(material_policy,interpretation,modes.eigenvalues,modes.full_modes,modes.numerical_brackets,
+        modes.spectral_residual,modes.original_ritz_residual,modes.full_backward_residual,packet.identity,
+        sha256(checkpoint).hexdigest(),equilibrium_load_parameter=parameter)