ANYfeSolver 0.5.0a1__py3-none-any.whl

anyfesolver/general_contact/beam_curve_end_geometry.py

@@ -0,0 +1,254 @@
+"""Exact affine-path certificates for physical B3 endpoint projection.
+
+This developmental sufficient condition requires globally positive F_t for
+F(t)=(r(t)-p).r_t(t). It deliberately leaves nonconvex distance profiles
+unresolved. Full physical-curve regularity, common time subdivision, topology,
+reciprocity and analytic work (b3_distance_jet) remain caller-owned.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from fractions import Fraction
+import heapq
+import math
+from numbers import Integral
+
+from .beam_curve_pair import CurvePairGapCertificate
+from .beam_temporal_bounds import _split
+from .capped_cylinder import _restrict, _sqrt_bound
+from .sphere_temporal_bounds import _axis, _squared_bounds, _squared_controls
+
+
+@dataclass(frozen=True)
+class EndpointInterval:
+    """Fixed closest branch and strict source ownership on the entire path.
+
+    Negative ownership means source-cap ownership; positive means side
+    ownership. Open certificates use zero ownership and bounds [0,1].
+    Target endpoint indices use B3 nodal order [start,mid,end]: 0 or 2.
+    Parameter bounds are exact rational target coordinates in [0,1].
+    """
+    open: bool
+    ownership: int
+    target_endpoint: int | None
+    parameter_lower: Fraction
+    parameter_upper: Fraction
+
+
+def _rational(value):
+    if isinstance(value, Fraction):
+        return value
+    if isinstance(value, Integral):
+        return Fraction(int(value))
+    value = float(value)
+    if not math.isfinite(value):
+        raise ValueError('B3 endpoint geometry must be finite')
+    return Fraction.from_float(value)
+
+
+def _positions(values):
+    result = tuple(tuple(_rational(value) for value in row) for row in values)
+    if len(result) != 3 or any(len(row) != 3 for row in result):
+        raise ValueError('B3 endpoint geometry requires three 3D nodal positions')
+    return result
+
+
+def _curve_controls(positions):
+    # Exact Q2 nodal-to-Bernstein conversion; never discard curvature modes.
+    return tuple((a, 2*b-(a+c)/2, c) for a, b, c in zip(*positions))
+
+
+def _outward_float(value, direction):
+    result = float(value)
+    if not math.isfinite(result):
+        raise ArithmeticError('B3 curve gap bound is not representable')
+    result = math.nextafter(result, direction)
+    if not math.isfinite(result):
+        raise ArithmeticError('B3 outward curve gap bound is not representable')
+    return result
+
+
+def certify_curve_pair_gap(a, b, radius, *, accuracy, maximum_cells,
+                           maximum_depth):
+    """Bound the complete two-Q2-curve minimum gap with exact tensor controls.
+
+    Relative controls A(s)-B(t) have degree (2,2); squared distance has degree
+    (4,4). Every patch lower bound is the maximum of the exact coordinate-box
+    lower bound, its squared-distance Bernstein minimum and zero. Actual
+    corners and centre supply only an upper bound. Best-first refinement ends
+    when all remaining patch lower distances are within the dimensional
+    accuracy of the best sampled upper distance. Pruning requires a proved
+    inability to improve that sampled minimum, never a sampled lower bound.
+    The certificate's minimum_sampled_gap is rounded outward upwards and its
+    conservative_lower_gap downwards. Their reported width is <= accuracy.
+    Complete curve regularity and scientific acceptance remain caller-owned.
+    """
+    first, second = map(_curve_controls, map(_positions, (a, b)))
+    radius, accuracy = _rational(radius), _rational(accuracy)
+    if radius <= 0 or accuracy <= 0:
+        raise ValueError('B3 curve gap radius and accuracy must be positive')
+    if (type(maximum_cells) is not int or maximum_cells < 1
+            or type(maximum_depth) is not int or maximum_depth < 0):
+        raise ValueError('B3 curve gap cell/depth budgets are invalid')
+    controls = tuple(tuple(tuple(x-y for y in other) for x in lane)
+                     for lane, other in zip(first, second))
+    squared = _squared_controls(controls)
+    lower, upper = _squared_bounds(controls, squared)
+    heap = [(lower, 0, 0, controls, squared)]
+    checked, serial = 1, 0
+    while True:
+        lower = min(heap[0][0], upper) if heap else upper
+        lower_root, upper_root = _sqrt_bound(lower), _sqrt_bound(upper, True)
+        if upper_root-lower_root <= accuracy:
+            lo = _outward_float(lower_root-radius, -math.inf)
+            hi = _outward_float(upper_root-radius, math.inf)
+            if _rational(hi)-_rational(lo) <= accuracy:
+                return CurvePairGapCertificate(hi, lo, checked, float(accuracy))
+            if not heap or lower == upper:
+                raise MemoryError('B3 curve gap accuracy is below report precision')
+        if checked+2 > maximum_cells:
+            raise MemoryError('B3 exact curve gap cell budget exhausted')
+        _, _, depth, controls, squared = heapq.heappop(heap)
+        if depth >= maximum_depth:
+            raise MemoryError('B3 exact curve gap depth budget exhausted')
+        axis = _axis(controls)
+        pairs = tuple(_split(lane, axis) for lane in controls)
+        squared_pair = _split(squared, axis)
+        for side in (0, 1):
+            child = tuple(pair[side] for pair in pairs)
+            child_squared = squared_pair[side]
+            child_lower, candidate = _squared_bounds(child, child_squared)
+            checked += 1
+            upper = min(upper, candidate)
+            # Discarded support cannot lower the actual global minimum.
+            if child_lower < upper:
+                serial += 1
+                heapq.heappush(heap, (child_lower, serial, depth+1,
+                                      child, child_squared))
+
+
+def _values(tensor):
+    return tuple(value for row in tensor for value in row)
+
+
+def _space_derivative(tensor):
+    degree = len(tensor)-1
+    return tuple(tuple(degree*(b-a) for a, b in zip(first, last))
+                 for first, last in zip(tensor, tensor[1:]))
+
+
+def _dot_tensor(first, second):
+    # Polarization reuses the existing exact tensor multiplication engine.
+    plus = tuple(tuple(tuple(a+b for a, b in zip(row, other))
+                       for row, other in zip(lane, target))
+                 for lane, target in zip(first, second))
+    minus = tuple(tuple(tuple(a-b for a, b in zip(row, other))
+                        for row, other in zip(lane, target))
+                  for lane, target in zip(first, second))
+    a, b = _squared_controls(plus), _squared_controls(minus)
+    return tuple(tuple((x-y)/4 for x, y in zip(row, other))
+                 for row, other in zip(a, b))
+
+
+def _interior_bracket(stationarity):
+    """Enclose all temporal roots using strict exact Bernstein sign bounds.
+
+    Each search refines target coordinate only. A midpoint whose time hull
+    crosses zero cannot move the certified edge. Twelve steps are a finite
+    developmental bound; inability to resolve ownership is returned to caller.
+    """
+    bounds = []
+    for lower in (True, False):
+        left, right = Fraction(0), Fraction(1)
+        current = stationarity
+        certified = left if lower else right
+        for _ in range(12):
+            first, last = _split(current, 0)
+            middle = (left+right)/2
+            values = first[-1]
+            sign_proved = max(values) < 0 if lower else min(values) > 0
+            if lower:
+                if sign_proved:
+                    certified, left, current = middle, middle, last
+                else:
+                    right, current = middle, first
+            else:
+                if sign_proved:
+                    certified, right, current = middle, middle, first
+                else:
+                    left, current = middle, last
+        bounds.append(certified)
+    return tuple(bounds)
+
+
+def _restrict_space(vector, left, right):
+    # All spatial lanes have degree two. The bracket is dyadic, so _restrict's
+    # scalar conversion is exact; geometry controls themselves stay rational.
+    return tuple(tuple(zip(*_restrict(tuple(zip(*lane)), left, right)))
+                 for lane in vector)
+
+
+def endpoint_interval(source0, source1, target0, target1, endpoint, radius):
+    """Return a whole affine-path certificate, or None when unresolved.
+
+    Distance squared has exact tensor degree (4,2) in target coordinate and
+    time. Its first derivative divided by two is F; its second derivative
+    divided by two is F_t. Positive controls for F_t prove strict convexity
+    over the full target, making strict endpoint signs a unique branch proof.
+    Ownership uses (p-r).outward_actual_B3_tangent on time x root bracket.
+    No path samples establish admission. Active projection/ownership ties
+    fail closed; a globally open distance certificate may bypass such ties.
+    """
+    if endpoint not in (0, 2):
+        raise ValueError('B3 endpoint index must be 0 or 2')
+    source0, source1, target0, target1 = map(
+        _positions, (source0, source1, target0, target1))
+    radius = _rational(radius)
+    if radius < 0:
+        raise ValueError('combined radius must be nonnegative')
+    first, last = _curve_controls(target0), _curve_controls(target1)
+    # r(t,time)-p(time), spatial-major tensor controls per Cartesian lane.
+    relative = tuple(tuple((a-source0[endpoint][axis],
+                            b-source1[endpoint][axis])
+                           for a, b in zip(first[axis], last[axis]))
+                     for axis in range(3))
+    near = []
+    for lane in relative:
+        low, high = min(_values(lane)), max(_values(lane))
+        near.append(low if low > 0 else -high if high < 0 else Fraction(0))
+    if sum(value*value for value in near) >= radius*radius:
+        return EndpointInterval(True, 0, None, Fraction(0), Fraction(1))
+    squared = _squared_controls(relative)
+    if min(_values(squared)) >= radius*radius:
+        return EndpointInterval(True, 0, None, Fraction(0), Fraction(1))
+    stationarity = tuple(tuple(value/2 for value in row)
+                         for row in _space_derivative(squared))
+    curvature = _space_derivative(stationarity)
+    if min(_values(curvature)) <= 0:
+        return None
+    if min(stationarity[0]) > 0:
+        target_endpoint, left, right = 0, Fraction(0), Fraction(0)
+    elif max(stationarity[-1]) < 0:
+        target_endpoint, left, right = 2, Fraction(1), Fraction(1)
+    elif max(stationarity[0]) < 0 and min(stationarity[-1]) > 0:
+        target_endpoint = None
+        left, right = _interior_bracket(stationarity)
+    else:
+        return None
+    source_first, source_last = map(_curve_controls, (source0, source1))
+    direction = -1 if endpoint == 0 else 1
+    index = 0 if endpoint == 0 else 1
+    outward = tuple((direction*2*(a[index+1]-a[index]),
+                      direction*2*(b[index+1]-b[index]))
+                     for a, b in zip(source_first, source_last))
+    separation = tuple(tuple(tuple(-value for value in row) for row in lane)
+                       for lane in _restrict_space(relative, left, right))
+    tangent = tuple((lane, lane, lane) for lane in outward)
+    ownership = _values(_dot_tensor(separation, tangent))
+    if min(ownership) > 0:
+        sign = 1
+    elif max(ownership) < 0:
+        sign = -1
+    else:
+        return None
+    return EndpointInterval(False, sign, target_endpoint, left, right)

anyfesolver/general_contact/beam_curve_ends.py

@@ -0,0 +1,237 @@
+"""Physical-end point work on classical quadratic curves, opt-in development.
+
+Distributed work and its curvature-dependent distance Hessian remain owned by
+beam_curve_pair. Closed ambiguous projections/ownership are explicit non-success.
+"""
+from dataclasses import dataclass
+from fractions import Fraction
+from types import SimpleNamespace
+
+import numpy as np
+from scipy import sparse
+
+from .beam_curve_pair_static import B3PairManager, validate_b3_pair_contact
+from .beam_curve_pair import b3_distance_jet, closest_on_b3
+from .beam_pair_ends import _line_definition, _EndPairResults
+from .beam_end_topology import physical_beam_ends
+from .beam_plane import _beam_types
+from .beam_end_radial_geometry import regular_curve_path
+from .capped_cylinder import _sqrt_bound
+from .core import ContactSolverSettings, ContactValidationReport
+
+PROFILE = 'CLASSICAL_B2_B3_ROUND_TUBE_QUADRATIC_PHYSICAL_ENDS_STATIC_DEV_V1'
+
+
+def validate_curve_beam_ends(model, definition, settings=None):
+    if tuple(map(len, (definition.surfaces, definition.rigid_bodies,
+                       definition.interactions))) != (2, 0, 1):
+        return ContactValidationReport('invalid', ('two single-cell beam surfaces required',), PROFILE)
+    if any(s.beam_end_caps != 'hemisphere' for s in definition.surfaces) or (
+            definition.interactions[0].endpoint_stiffness is None):
+        return ContactValidationReport('invalid', ('hemisphere ends need explicit endpoint_stiffness N/m',), PROFILE)
+    report = validate_b3_pair_contact(model, _line_definition(definition), settings)
+    return ContactValidationReport(report.status, report.issues, PROFILE)
+
+
+@dataclass(frozen=True)
+class _CurveEndResults(_EndPairResults):
+    def to_dict(self):
+        return {**super().to_dict(),
+                'minimum_gap_kind': 'conservative_full_quadratic_curve_lower_bound',
+                'geometry_kinematics': 'quadratic_curve_unique_convex_endpoint_projection_v1'}
+
+
+class BeamCurveEndManager(B3PairManager):
+    def __init__(self, model, definition, settings=None, initial_displacement=None):
+        controls = ContactSolverSettings() if settings is None else settings
+        report = validate_curve_beam_ends(model, definition, controls)
+        if not report.valid:
+            raise ValueError('unsupported quadratic physical ends: ' + '; '.join(report.issues))
+        super().__init__(model, _line_definition(definition), controls, initial_displacement)
+        self.definition = definition
+        self.profile = PROFILE
+        self.end_caps = 'hemisphere'
+        self.endpoint_stiffness = definition.interactions[0].endpoint_stiffness
+        self.elements = tuple(model.mesh.elements[s.element_ids[0]] for s in definition.surfaces)
+        self.ends = []
+        for surface, element in zip(definition.surfaces, self.elements):
+            cell = SimpleNamespace(element_id=surface.element_ids[0], node_ids=element.node_ids)
+            local = physical_beam_ends(model, (cell,), _beam_types()).values()
+            self.ends.append(tuple(sorted(0 if i == 0 else 2 for _, i, _ in local)))
+        self.ends = tuple(self.ends)
+
+    def _endpoint_work(self, positions):
+        from .beam_curve_end_geometry import endpoint_interval
+        E = 0.; f = np.zeros(18); K = np.zeros((18, 18)); fields = []; seen = set()
+        certificates = {(side, endpoint): endpoint_interval(
+            positions[side], positions[side], positions[1-side], positions[1-side],
+            endpoint, self.radius) for side in (0, 1) for endpoint in self.ends[side]}
+        for side in (0, 1):
+            source, target = positions[side], positions[1-side]
+            for endpoint in self.ends[side]:
+                proof = certificates[side, endpoint]
+                if proof is None:
+                    raise ValueError('quadratic physical-end projection/ownership is unresolved')
+                node = self.elements[side].node_ids[0 if endpoint == 0 else -1]
+                row = {'source_surface': self.definition.surfaces[side].name,
+                       'source_element_id': self.definition.surfaces[side].element_ids[0],
+                       'source_node_id': int(node), 'state': 'open'}
+                if proof.open:
+                    projection = closest_on_b3(source[endpoint], target)
+                    row['gap'] = projection.distance-self.radius
+                    fields.append(row); continue
+                station = b3_distance_jet(source, target, endpoint/2, self.radius,
+                                         source_is_a=side == 0)
+                t = station.target_parameter
+                if not float(proof.parameter_lower) <= t <= float(proof.parameter_upper):
+                    raise ValueError('quadratic numerical projection leaves its certified bracket')
+                if proof.target_endpoint is not None:
+                    # Literal IEEE geometry, cancellation-resistant activation.
+                    separation = tuple(Fraction.from_float(float(x))-Fraction.from_float(float(y))
+                        for x, y in zip(source[endpoint], target[proof.target_endpoint]))
+                    squared = sum(value*value for value in separation)
+                    radius = Fraction.from_float(self.radius)
+                    root = _sqrt_bound(squared, upper=True)
+                    difference = squared-radius*radius
+                    gap = float(difference/(root+radius))
+                    if gap == 0 and difference != 0:
+                        raise ValueError('quadratic endpoint activation conversion underflows')
+                else:
+                    gap = station.gap
+                    scale = max(self.radius, np.max(np.abs(source)), np.max(np.abs(target)), 1.)
+                    if abs(gap) <= 256*np.finfo(float).eps*scale:
+                        raise ValueError('quadratic interior activation sign is unresolved at roundoff')
+                row.update(gap=gap, target_coordinate=t,
+                           target_element_id=self.definition.surfaces[1-side].element_ids[0])
+                if gap >= 0:
+                    fields.append(row); continue
+                if proof.ownership > 0:
+                    row['state'] = 'side_owned'; fields.append(row); continue
+                other = proof.target_endpoint
+                if other is not None:
+                    if other not in self.ends[1-side]:
+                        raise ValueError('quadratic cap projects to a nonphysical selected target end')
+                    reverse = certificates[1-side, other]
+                    if reverse is None or reverse.open or reverse.ownership >= 0 or (
+                            reverse.target_endpoint != endpoint):
+                        raise ValueError('quadratic active cap/cap partner is not reciprocal')
+                    key = tuple(sorted(((side, endpoint), (1-side, other))))
+                    row.update(feature_kind='end_end', target_node_id=int(
+                        self.elements[1-side].node_ids[0 if other == 0 else -1]))
+                else:
+                    key = (side, endpoint, 'interior')
+                    row['feature_kind'] = 'end_interior'
+                if key in seen:
+                    row['state'] = 'reciprocal_owned_once'; fields.append(row); continue
+                seen.add(key)
+                ke = self.endpoint_stiffness
+                E += .5*ke*gap*gap
+                f += ke*gap*station.gradient
+                K += ke*(np.outer(station.gradient, station.gradient)+gap*station.hessian)
+                row.update(state='active', endpoint_force_N=-ke*gap)
+                fields.append(row)
+        return E, f, K, tuple(fields), len(seen)
+
+    def evaluate(self, displacement, *, tangent=True):
+        positions = self._positions(displacement)
+        if not all(regular_curve_path(p, p, self.settings.maximum_swept_subdivisions)
+                   for p in positions):
+            raise ValueError('quadratic physical-end curve regularity is unresolved')
+        endpoint, ef, eK, fields, active = self._endpoint_work(positions)
+        force, K, line = super().evaluate(displacement, tangent=tangent)
+        dofs = np.r_[self.dofs[0].reshape(-1), self.dofs[1].reshape(-1)]
+        np.add.at(force, dofs, self.assembly_map.T@ef)
+        if tangent:
+            rows, cols = np.meshgrid(dofs, dofs, indexing='ij')
+            local = self.assembly_map.T@eK@self.assembly_map
+            K += sparse.coo_matrix((local.ravel(), (rows.ravel(), cols.ravel())),
+                                  shape=(self.n_dof, self.n_dof)).tocsr()
+        forces = tuple(-ef[i*9:(i+1)*9].reshape(3, 3) for i in (0, 1))
+        wrench = [tuple(np.asarray(old)+np.sum(values, axis=0)) for old, values in
+                  zip((line.beam_a_force, line.beam_b_force), forces)]
+        moments = [tuple(np.asarray(old)+np.sum(np.cross(p, values), axis=0)) for old, p, values
+                   in zip((line.beam_a_moment, line.beam_b_moment), positions, forces)]
+        result = _CurveEndResults(self.profile, line.minimum_gap, line.contact_energy+endpoint,
+            line.active_source_intervals, line.integration_points, line.maximum_integration_relative_error,
+            *wrench, *moments, line.gap_tolerance_met, self.stiffness,
+            line.contact_energy, endpoint, self.endpoint_stiffness,
+            sum(map(len, self.ends)), active, fields)
+        return force, K, result
+
+    def _endpoint_path_admissible(self, first, last):
+        from .beam_curve_end_geometry import endpoint_interval
+        def rational(poses):
+            return tuple(np.array([[Fraction.from_float(float(x)) for x in row]
+                                   for row in p], dtype=object) for p in poses)
+        def certify(a, b, depth):
+            proofs = {(side, endpoint): endpoint_interval(a[side], b[side],
+                a[1-side], b[1-side], endpoint, self.radius)
+                for side in (0, 1) for endpoint in self.ends[side]}
+            fixed = all(proof is not None for proof in proofs.values())
+            if fixed:
+                for (side, endpoint), proof in proofs.items():
+                    if proof.open or proof.ownership > 0 or proof.target_endpoint is None:
+                        continue
+                    other = proof.target_endpoint
+                    reverse = proofs.get((1-side, other))
+                    if reverse is None or reverse.open or reverse.ownership >= 0 or (
+                            reverse.target_endpoint != endpoint):
+                        fixed = False; break
+                if fixed:
+                    return True
+            if depth >= self.settings.maximum_swept_subdivisions:
+                return False
+            mid = tuple((x+y)/2 for x, y in zip(a, b))
+            return certify(a, mid, depth+1) and certify(mid, b, depth+1)
+        return certify(rational(first), rational(last), 0)
+
+    def _gap_certificate(self, positions):
+        from .beam_curve_end_geometry import certify_curve_pair_gap
+        return certify_curve_pair_gap(*positions, self.radius,
+            accuracy=self.settings.beam_pair_gap_accuracy,
+            maximum_cells=self.settings.maximum_beam_pair_gap_cells,
+            maximum_depth=self.settings.maximum_beam_pair_gap_depth)
+
+    def _certificate(self, displacement):
+        return self._gap_certificate(self._positions(displacement))
+
+    def _swept_admissible(self, start, end):
+        first, last = self._positions(start), self._positions(end)
+        if not all(regular_curve_path(a, b, self.settings.maximum_swept_subdivisions)
+                   for a, b in zip(first, last)):
+            return False
+        from .beam_curve_end_geometry import _curve_controls
+        q0, q1 = [tuple(np.array([[Fraction.from_float(float(x)) for x in row]
+                                  for row in p], dtype=object) for p in poses)
+                  for poses in (first, last)]
+        delta = tuple(b-a for a, b in zip(q0, q1))
+        velocities = tuple(np.array(_curve_controls(p), dtype=object).T for p in delta)
+        speed = max(_sqrt_bound(sum((x-y)**2 for x, y in zip(a, b)), upper=True)
+                    for a in velocities[0] for b in velocities[1])
+        tol = Fraction.from_float(self.gap_tolerance)
+        def gap(t):
+            return self._gap_certificate(tuple(a+t*d for a, d in zip(q0, delta))).conservative_lower_gap
+        g0, g1 = gap(Fraction(0)), gap(Fraction(1))
+        if g0 < -self.gap_tolerance:
+            raise ValueError('committed quadratic physical-end gap exceeds tolerance')
+        if g1 < -self.gap_tolerance:
+            return False
+        def certify(left, right, gl, gr, depth):
+            if min(Fraction.from_float(gl), Fraction.from_float(gr))-speed*(right-left)/2 >= -tol:
+                return True
+            if depth >= self.settings.maximum_swept_subdivisions:
+                return False
+            middle = (left+right)/2; gm = gap(middle)
+            if gm < -self.gap_tolerance:
+                return False
+            return (certify(left, middle, gl, gm, depth+1)
+                    and certify(middle, right, gm, gr, depth+1))
+        return certify(Fraction(0), Fraction(1), g0, g1, 0) and self._endpoint_path_admissible(first, last)
+
+    def restart_contract(self):
+        return {**super().restart_contract(),
+                'endpoint_stiffness': self.endpoint_stiffness,
+                'physical_ends': [[int(e.node_ids[0 if i == 0 else -1]) for i in ends]
+                                  for e, ends in zip(self.elements, self.ends)],
+                'point_law': 'unique_quadratic_owned_end_end_or_end_interior_v1',
+                'geometry_revision': 'exact_tensor_gap_convex_projection_ownership_affine_path_v1'}