ti-runtime 0.2.1__py3-none-any.whl

ti_runtime/__init__.py

@@ -0,0 +1,49 @@
+"""ti-runtime — neutral Taichi runtime for MechDSL-generated code (PlanJune14 PJ-0).
+
+Seams + primitives only; algorithmic bodies are generated by algo2code and injected.
+See the module-level READMEs for the Seams & Bodies contract.
+"""
+
+from __future__ import annotations
+
+__version__ = "0.2.1"
+
+from . import fields, hex8, seams, tensor_ti, vector_ops
+from .seams import (
+    AccelSolve,
+    DiagonalPreconditioner,
+    IdentityPreconditioner,
+    Integrator,
+    LinearSolveContext,
+    Operator,
+    PreconditionerBase,
+    Solver,
+    TimeIntegrationContext,
+)
+from .vector_ops import axpy, copy, dot, ediv, norm2, scal, vec_add, xpay, zero
+
+__all__ = [
+    "AccelSolve",
+    "DiagonalPreconditioner",
+    "IdentityPreconditioner",
+    "Integrator",
+    "LinearSolveContext",
+    "Operator",
+    "PreconditionerBase",
+    "Solver",
+    "TimeIntegrationContext",
+    "axpy",
+    "copy",
+    "dot",
+    "ediv",
+    "fields",
+    "hex8",
+    "norm2",
+    "scal",
+    "seams",
+    "tensor_ti",
+    "vec_add",
+    "vector_ops",
+    "xpay",
+    "zero",
+]

ti_runtime/fields.py

@@ -0,0 +1,44 @@
+"""Field allocation + ``ti.init`` boilerplate (PlanJune14 PJ-0).
+
+The minimal runtime preamble generated code (and the test harness) targets:
+choose a backend, allocate the standard field kinds. Kept deliberately thin —
+heavy field-registry / domain-manager machinery from NumerixWeave is *not*
+harvested (PlanJune14 "avoid" list).
+"""
+
+from __future__ import annotations
+
+import taichi as ti
+
+_ARCH = {
+    "cpu": ti.cpu,
+    "gpu": ti.gpu,
+    "cuda": ti.cuda,
+    "metal": ti.metal,
+    "vulkan": ti.vulkan,
+}
+
+
+def init(arch: str = "cpu", default_fp=ti.f64, **kwargs) -> None:
+    """Initialise Taichi for a named backend (``cpu``/``gpu``/``cuda``/``metal``)."""
+    if arch not in _ARCH:
+        raise ValueError(f"Unknown arch {arch!r}; expected one of {sorted(_ARCH)}.")
+    ti.init(arch=_ARCH[arch], default_fp=default_fp, **kwargs)
+
+
+def vector_field(dim: int, n: int, dtype=ti.f64):
+    """``n`` nodes × ``dim`` dof (e.g. displacement, force, residual)."""
+    return ti.Vector.field(dim, dtype=dtype, shape=n)
+
+
+def scalar_field(n: int, dtype=ti.f64):
+    return ti.field(dtype=dtype, shape=n)
+
+
+def matrix_field(rows: int, cols: int, shape, dtype=ti.f64):
+    return ti.Matrix.field(rows, cols, dtype=dtype, shape=shape)
+
+
+def index_field(shape, dtype=ti.i32):
+    """Integer field, e.g. element→node connectivity."""
+    return ti.field(dtype=dtype, shape=shape)

ti_runtime/hex8.py

@@ -0,0 +1,53 @@
+"""Hex8 reference element: shape functions, gradients, quadrature (PlanJune14 PJ-0).
+
+Trilinear 8-node hexahedron with 2×2×2 Gauss quadrature — the minimal element
+the SVK spike (PJ-1) and the matrix-free tangent operator build on. Shape
+functions/gradients are ``@ti.func`` (call from a kernel); quadrature tables are
+Python constants iterated with ``ti.static``. Standard node ordering (corner
+signs below). Adapted from NumerixWeave ``apps/tifem`` ``Ref_elements/HEX8``.
+"""
+
+import taichi as ti
+
+N_NODES = 8
+DIM = 3
+N_QP = 8
+
+# Natural-coordinate corner signs (standard Hex8 node ordering).
+_CORNERS = (
+    (-1.0, -1.0, -1.0),
+    (1.0, -1.0, -1.0),
+    (1.0, 1.0, -1.0),
+    (-1.0, 1.0, -1.0),
+    (-1.0, -1.0, 1.0),
+    (1.0, -1.0, 1.0),
+    (1.0, 1.0, 1.0),
+    (-1.0, 1.0, 1.0),
+)
+
+_G = 1.0 / (3.0**0.5)
+# 2×2×2 Gauss points (corner sign pattern, scaled by 1/√3) and unit weights.
+QUAD_POINTS = tuple((sx * _G, sy * _G, sz * _G) for (sx, sy, sz) in _CORNERS)
+QUAD_WEIGHTS = (1.0,) * N_QP
+
+
+@ti.func
+def shape(xi, eta, zeta):
+    """Trilinear shape functions at natural coords → ``ti.Vector(8)``."""
+    N = ti.Vector.zero(ti.f64, 8)
+    for a in ti.static(range(8)):
+        sx, sy, sz = ti.static(_CORNERS[a])
+        N[a] = 0.125 * (1.0 + sx * xi) * (1.0 + sy * eta) * (1.0 + sz * zeta)
+    return N
+
+
+@ti.func
+def shape_grad_natural(xi, eta, zeta):
+    """``∂N_a/∂(ξ,η,ζ)`` → ``ti.Matrix(8, 3)``."""
+    dN = ti.Matrix.zero(ti.f64, 8, 3)
+    for a in ti.static(range(8)):
+        sx, sy, sz = ti.static(_CORNERS[a])
+        dN[a, 0] = 0.125 * sx * (1.0 + sy * eta) * (1.0 + sz * zeta)
+        dN[a, 1] = 0.125 * sy * (1.0 + sx * xi) * (1.0 + sz * zeta)
+        dN[a, 2] = 0.125 * sz * (1.0 + sx * xi) * (1.0 + sy * eta)
+    return dN

ti_runtime/seams.py

@@ -0,0 +1,303 @@
+"""Injection plumbing — the *seams* generated bodies plug into (PlanJune14 PJ-0).
+
+MechDSL owns the stable wrappers; algo2code generates the bodies. The same
+``LinearSolveContext`` applies *whatever* operator / preconditioner / solver was
+injected, so the plumbing is algorithm-agnostic.
+
+A matrix-free operator is an in-place callable ``apply(out, x) -> None`` computing
+``out = A @ x`` over Taichi fields (typically a generated ``@ti.kernel``).
+Preconditioner protocol mirrors NumerixWeave ``tisolvers``: ``apply(z, r)`` sets
+``z = M^{-1} r``.
+"""
+
+import math
+from collections.abc import Callable
+
+import taichi as ti
+
+from . import vector_ops as vops
+
+# out = A @ x, in place.
+OperatorApply = Callable[..., None]
+
+
+@ti.data_oriented
+class PreconditionerBase:
+    """SPD preconditioner interface: ``apply(z, r)`` sets ``z = M^{-1} r``."""
+
+    def apply(self, z, r) -> None:
+        raise NotImplementedError
+
+    def assemble(self) -> None:
+        """Rebuild internal state from the current operator/tangent.
+
+        No-op for stateless preconditioners (Identity, point-Jacobi); stateful
+        ones (block-Jacobi) override.
+        """
+
+
+@ti.data_oriented
+class IdentityPreconditioner(PreconditionerBase):
+    """``M = I`` — unpreconditioned."""
+
+    def apply(self, z, r) -> None:
+        vops.copy(z, r)
+
+
+@ti.data_oriented
+class DiagonalPreconditioner(PreconditionerBase):
+    """Point-Jacobi: ``M = diag(d)``, ``M^{-1} = diag(1/d)``.
+
+    ``diag`` is a Taichi field of the same layout as the vectors; division is
+    guarded by ``max(d, eps)`` to avoid NaN on a zero/near-zero diagonal.
+    """
+
+    def __init__(self, diag: ti.template(), eps: float = 1e-12):
+        self.diag = diag
+        self.eps = eps
+
+    @ti.kernel
+    def _apply(self, z: ti.template(), r: ti.template(), eps: float):
+        for I in ti.grouped(r):
+            z[I] = r[I] / ti.max(self.diag[I], eps)
+
+    def apply(self, z, r) -> None:
+        self._apply(z, r, self.eps)
+
+
+class Operator:
+    """Holds the injected matrix-free operator ``apply(out, x): out = A @ x``."""
+
+    def __init__(self) -> None:
+        self._apply: OperatorApply | None = None
+
+    def set_apply(self, fn: OperatorApply) -> "Operator":
+        self._apply = fn
+        return self
+
+    def apply(self, out, x) -> None:
+        if self._apply is None:
+            raise RuntimeError("Operator has no body injected; call set_apply(...) first.")
+        self._apply(out, x)
+
+
+class Solver:
+    """Holds an injected (generated) solver body ``solve(ctx, b, x, ...)``."""
+
+    def __init__(self) -> None:
+        self._solve: Callable[..., object] | None = None
+
+    def set_solve(self, fn: Callable[..., object]) -> "Solver":
+        self._solve = fn
+        return self
+
+    def solve(self, *args, **kwargs):
+        if self._solve is None:
+            raise RuntimeError("Solver has no body injected; call set_solve(...) first.")
+        return self._solve(*args, **kwargs)
+
+
+class LinearSolveContext:
+    """The plumbing a generated linear solver targets.
+
+    Bundles the injected matrix-free operator and preconditioner; the generated
+    solver body calls :meth:`apply_A` / :meth:`apply_preconditioner` plus the
+    :mod:`ti_runtime.vector_ops` primitives. Defaults to the identity
+    preconditioner (unpreconditioned).
+    """
+
+    def __init__(self) -> None:
+        self.operator = Operator()
+        self.preconditioner: PreconditionerBase = IdentityPreconditioner()
+        self.solver = Solver()
+
+    def set_operator(self, fn: OperatorApply) -> "LinearSolveContext":
+        self.operator.set_apply(fn)
+        return self
+
+    def set_preconditioner(self, precond: PreconditionerBase) -> "LinearSolveContext":
+        self.preconditioner = precond
+        return self
+
+    def set_solver(self, fn: Callable[..., object]) -> "LinearSolveContext":
+        self.solver.set_solve(fn)
+        return self
+
+    def apply_A(self, out, x) -> None:
+        self.operator.apply(out, x)
+
+    def apply_preconditioner(self, z, r) -> None:
+        self.preconditioner.apply(z, r)
+
+
+# ── Time-integration seam ────────────────────────────────────────────────────
+#
+# The temporal analogue of LinearSolveContext: a generated *time integrator*
+# (e.g. a Newmark-beta step transpiled from its LaTeX algorithm spec) plugs
+# into a stable wrapper here, exactly as a generated linear solver plugs into
+# set_solver. The wrapper is integrator-agnostic — it applies *whatever* step
+# body was injected (Newmark-beta, central difference, HHT, ...).
+#
+# An integrator step is an in-place callable advancing the dynamic state one
+# step. The seam-injected acceleration solve mirrors the matrix-free operator:
+# accel_solve(u_pred, v_pred, a_out) sets a_out = a_{n+1} (out LAST), folding the
+# mass/damping/stiffness/external-force data — the box itself stays
+# mass-/material-agnostic, just as the PCG box is operator-agnostic.
+
+# (u, v, a, accel_solve, dt, beta, gamma) -> (u, v, a); advances state in place.
+IntegratorStep = Callable[..., object]
+
+# accel_solve(u_pred, v_pred, a_out): a_out = a_{n+1}, in place (out LAST).
+# Returns an optional status: ``None`` for a solve that cannot fail
+# (e.g. an elementwise SDOF/diagonal-mass solve), or a convergence flag for an
+# iterative solve (a falsy flag == not converged). TimeIntegrationContext.step
+# consumes it to roll back and fail loud rather than advancing on a bad solve.
+AccelSolveApply = Callable[..., object]
+
+
+class Integrator:
+    """Holds an injected (generated) time-integrator step body.
+
+    The body advances ``(u, v, a)`` one step in place, calling the injected
+    acceleration solve plus the :mod:`ti_runtime.vector_ops` primitives — the
+    shape ``dev/algorithms/newmark.tex`` transpiles to.
+    """
+
+    def __init__(self) -> None:
+        self._step: IntegratorStep | None = None
+
+    def set_step(self, fn: IntegratorStep) -> "Integrator":
+        self._step = fn
+        return self
+
+    def step(self, *args, **kwargs):
+        if self._step is None:
+            raise RuntimeError("Integrator has no body injected; call set_integrator(...) first.")
+        return self._step(*args, **kwargs)
+
+
+class AccelSolve:
+    """Holds the injected acceleration solve ``apply(u_pred, v_pred, a_out)``.
+
+    Sets ``a_out = a_{n+1}`` — the solution of
+    ``(M + gamma*dt*C + beta*dt^2*K) a_{n+1} = F_{n+1} - C*v_pred - K*u_pred``.
+    For an SDOF / diagonal-mass problem this is an elementwise solve; for a full
+    FEM system it is itself a (linear) solve. Matrix-free: the wrapper applies
+    whatever callable was injected.
+    """
+
+    def __init__(self) -> None:
+        self._apply: AccelSolveApply | None = None
+
+    def set_apply(self, fn: AccelSolveApply) -> "AccelSolve":
+        self._apply = fn
+        return self
+
+    def apply(self, u_pred, v_pred, a_out) -> object:
+        if self._apply is None:
+            raise RuntimeError("AccelSolve has no body injected; call set_accel_solve(...) first.")
+        # Forward the injected solve's return value: a convergence status
+        # when the solve is iterative, else ``None``. The caller (step) decides.
+        return self._apply(u_pred, v_pred, a_out)
+
+
+class TimeIntegrationContext:
+    """The plumbing a generated time integrator targets (PlanJune14 P6-1).
+
+    The temporal twin of :class:`LinearSolveContext`. Bundles the injected
+    acceleration solve and the injected integrator step; the generated step body
+    calls :meth:`apply_accel_solve` (the matrix-free seam) plus the
+    :mod:`ti_runtime.vector_ops` primitives. :meth:`step` advances the dynamic
+    state ``(u, v, a)`` one step in place by applying the injected integrator,
+    with no NumPy in the hot path.
+
+    Parameters ``dt`` / ``beta`` / ``gamma`` are the Newmark step controls; they
+    default to the average-acceleration scheme (``beta = 1/4``, ``gamma = 1/2``)
+    — unconditionally stable, second-order, no algorithmic damping.
+    """
+
+    def __init__(self, dt: float = 1.0, beta: float = 0.25, gamma: float = 0.5) -> None:
+        self.integrator = Integrator()
+        self.accel = AccelSolve()
+        self.dt = dt
+        self.beta = beta
+        self.gamma = gamma
+
+    def set_integrator(self, fn: IntegratorStep) -> "TimeIntegrationContext":
+        self.integrator.set_step(fn)
+        return self
+
+    def set_accel_solve(self, fn: AccelSolveApply) -> "TimeIntegrationContext":
+        self.accel.set_apply(fn)
+        return self
+
+    def apply_accel_solve(self, u_pred, v_pred, a_out) -> object:
+        return self.accel.apply(u_pred, v_pred, a_out)
+
+    def step(self, u, v, a):
+        """Advance the state ``(u, v, a)`` one step via the injected integrator.
+
+        Wires the seam conventions to the generated body's callable arguments:
+        the integrator's ``solve_a(u_pred, v_pred, a_out)`` argument is bound to
+        :meth:`apply_accel_solve` (the injected acceleration solve), and the
+        ``(dt, beta, gamma)`` controls come from this context. Returns whatever
+        the generated step returns (typically ``(u, v, a)``).
+
+        Fail-loud contract (WI-3). The step is committed only if the injected
+        acceleration solve succeeded and the advanced state is finite. Before
+        stepping we snapshot ``(u, v, a)``; if the injected solve **raises**
+        (e.g. the WI-2 seam PCG on non-convergence), **reports** a falsy
+        convergence status, or the advanced acceleration is **non-finite**, we
+        restore the snapshot and raise ``RuntimeError`` rather than leaving the
+        dynamic state half-advanced on a bad solve. This mirrors the host
+        Newton driver's snapshot/rollback + isfinite guard (newton.py). P6-1 is
+        not yet production-wired, so this establishes the contract without
+        redesigning the matrix-free body; the per-step snapshot is a
+        step-boundary archival copy (the same ``.to_numpy()`` round-trip the
+        P6-1 tests use at step boundaries), not a hot-path operation.
+        """
+        # Step-boundary snapshot for rollback (not the generated hot path).
+        u_snap = u.to_numpy()
+        v_snap = v.to_numpy()
+        a_snap = a.to_numpy()
+
+        def _restore() -> None:
+            u.from_numpy(u_snap)
+            v.from_numpy(v_snap)
+            a.from_numpy(a_snap)
+
+        status: dict[str, object] = {}
+
+        def accel_solve(u_pred, v_pred, a_out):
+            status["accel"] = self.apply_accel_solve(u_pred, v_pred, a_out)
+
+        try:
+            result = self.integrator.step(u, v, a, accel_solve, self.dt, self.beta, self.gamma)
+        except Exception:
+            # A raising solve (e.g. the seam-injected PCG) may have left state
+            # half-advanced -- restore before propagating.
+            _restore()
+            raise
+
+        # A reported non-convergence status (a falsy flag that is not ``None``;
+        # ``None`` means "no status / cannot fail", e.g. an elementwise solve).
+        accel_status = status.get("accel")
+        if accel_status is not None and not accel_status:
+            _restore()
+            raise RuntimeError(
+                "Time-integration acceleration solve did not converge "
+                f"(status={accel_status!r}); restored the pre-step state rather "
+                "than advancing (u, v, a) on a non-converged acceleration."
+            )
+
+        # Non-finite advanced acceleration poisons all subsequent steps; catch
+        # it here (mirrors the Newton driver's isfinite residual guard).
+        if not math.isfinite(vops.norm2(a)):
+            _restore()
+            raise RuntimeError(
+                "Time-integration step produced a non-finite acceleration "
+                "(||a|| is NaN/Inf); restored the pre-step state rather than "
+                "advancing on a corrupt acceleration."
+            )
+
+        return result

ti_runtime/tensor_ti.py

@@ -0,0 +1,93 @@
+"""Tier-1 tensor / kinematics ``@ti.func`` helpers (PlanJune14 PJ-0).
+
+The building blocks generated constitutive / element code calls — kept as
+``@ti.func`` so they inline cheaply and don't burn JIT budget. Conventions follow
+MechDSL ``dev/design_docs/07-CONVENTIONS.md``: spatial/material 3×3 tensors, Voigt
+order ``[xx, yy, zz, xy, xz, yz]``, **tensorial** (unscaled shears), metric
+``G = diag(1,1,1,2,2,2)``. Harvested/adapted from NumerixWeave ``ticonstit``.
+
+These are ``@ti.func`` — call them from inside a ``@ti.kernel``.
+"""
+
+import taichi as ti
+
+mat3 = ti.types.matrix(3, 3, ti.f64)
+vec6 = ti.types.vector(6, ti.f64)
+
+
+@ti.func
+def identity3() -> mat3:
+    return ti.Matrix.identity(ti.f64, 3)
+
+
+@ti.func
+def det3(A) -> ti.f64:
+    """Determinant of a 3×3 matrix."""
+    return A.determinant()
+
+
+@ti.func
+def inv3(A) -> mat3:
+    """Inverse of a 3×3 matrix."""
+    return A.inverse()
+
+
+@ti.func
+def deformation_gradient(grad_u) -> mat3:
+    """``F = I + ∂u_i/∂X_J`` from the material displacement gradient (3×3)."""
+    return ti.Matrix.identity(ti.f64, 3) + grad_u
+
+
+@ti.func
+def jacobian(F) -> ti.f64:
+    """``J = det(F)``."""
+    return F.determinant()
+
+
+@ti.func
+def right_cauchy_green(F) -> mat3:
+    """``C = F^T F``."""
+    return F.transpose() @ F
+
+
+@ti.func
+def green_lagrange(F) -> mat3:
+    """``E = ½(F^T F − I)``."""
+    return 0.5 * (F.transpose() @ F - ti.Matrix.identity(ti.f64, 3))
+
+
+@ti.func
+def trace3(A) -> ti.f64:
+    return A[0, 0] + A[1, 1] + A[2, 2]
+
+
+@ti.func
+def deviatoric(A) -> mat3:
+    """Deviatoric part ``A − (tr A / 3) I``."""
+    p = (A[0, 0] + A[1, 1] + A[2, 2]) / 3.0
+    return A - p * ti.Matrix.identity(ti.f64, 3)
+
+
+@ti.func
+def von_mises(S) -> ti.f64:
+    """von Mises equivalent stress ``sqrt(3/2 · s:s)`` of a symmetric 3×3 ``S``."""
+    s = deviatoric(S)
+    return ti.sqrt(1.5 * (s * s).sum())
+
+
+@ti.func
+def to_voigt(S) -> vec6:
+    """Symmetric 3×3 → Voigt-6 ``[xx, yy, zz, xy, xz, yz]`` (unscaled shears)."""
+    return ti.Vector([S[0, 0], S[1, 1], S[2, 2], S[0, 1], S[0, 2], S[1, 2]], dt=ti.f64)
+
+
+@ti.func
+def from_voigt(v) -> mat3:
+    """Voigt-6 → symmetric 3×3 (off-diagonals not doubled — tensorial)."""
+    return ti.Matrix([[v[0], v[3], v[4]], [v[3], v[1], v[5]], [v[4], v[5], v[2]]], dt=ti.f64)
+
+
+@ti.func
+def double_contract(A, B) -> ti.f64:
+    """Full tensor double contraction ``A:B`` of two 3×3 tensors."""
+    return (A * B).sum()

ti_runtime/vector_ops.py

@@ -0,0 +1,88 @@
+"""Vector-primitive ``@ti.kernel`` operations (PlanJune14 PJ-0).
+
+Layout-agnostic primitives over Taichi *vector* fields (``ti.Vector.field(d)``),
+the shape FEM degrees-of-freedom use. Generated solvers call these instead of
+re-emitting their own (PlanJune14 PJ-2).
+
+The scalar coefficient ``a`` is a **runtime ``float`` argument**, not
+``ti.template()`` — annotating a Python scalar as ``ti.template()`` bakes the
+value into the compiled kernel, triggering a fresh JIT per distinct value
+(observed as 100k+ kernel variants in tight Krylov loops). Harvested from
+NumerixWeave ``tisolvers``.
+"""
+
+import taichi as ti
+
+
+@ti.kernel
+def copy(dst: ti.template(), src: ti.template()):
+    """``dst <- src`` (elementwise)."""
+    for I in ti.grouped(src):
+        dst[I] = src[I]
+
+
+@ti.kernel
+def axpy(y: ti.template(), a: float, x: ti.template()):
+    """``y <- y + a*x``."""
+    for I in ti.grouped(y):
+        y[I] += a * x[I]
+
+
+@ti.kernel
+def xpay(x: ti.template(), a: float, y: ti.template()):
+    """``x <- a*x + y`` (the CG search-direction update)."""
+    for I in ti.grouped(x):
+        x[I] = a * x[I] + y[I]
+
+
+@ti.kernel
+def scal(x: ti.template(), a: float):
+    """``x <- a*x``."""
+    for I in ti.grouped(x):
+        x[I] = a * x[I]
+
+
+@ti.kernel
+def _dot(x: ti.template(), y: ti.template()) -> ti.f64:
+    s = 0.0
+    for I in ti.grouped(x):
+        s += x[I].dot(y[I])
+    return s
+
+
+def dot(x, y) -> float:
+    """Euclidean inner product ``x . y`` over a vector field (returns a float)."""
+    return float(_dot(x, y))
+
+
+def norm2(x) -> float:
+    """Euclidean 2-norm ``||x||_2``."""
+    return float(_dot(x, x)) ** 0.5
+
+
+@ti.kernel
+def vec_add(out: ti.template(), a: float, x: ti.template(), b: float, y: ti.template()):
+    """``out[I] = a*x[I] + b*y[I]`` (AXPBY, elementwise over any field shape)."""
+    for I in ti.grouped(out):
+        out[I] = a * x[I] + b * y[I]
+
+
+def zero(x) -> None:
+    """Zero a field in place."""
+    x.fill(0.0)
+
+
+@ti.kernel
+def ediv(z: ti.template(), r: ti.template(), d: ti.template(), eps: float):
+    """Elementwise guarded divide: ``z[I] = r[I] / max(d[I], eps)``.
+
+    Point-Jacobi preconditioner kernel (PlanJune14 P4-1): applies M^{-1} r
+    where M = diag(d).  The ``eps`` guard prevents division by zero on a
+    near-zero diagonal; the caller is responsible for choosing a physically
+    appropriate value (default: 1e-12).
+
+    Layout-agnostic: works for any ``ti.Vector.field`` or scalar ``ti.field``
+    where element-wise max and division are defined.
+    """
+    for I in ti.grouped(r):
+        z[I] = r[I] / ti.max(d[I], eps)

ti_runtime-0.2.1.dist-info/METADATA

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: ti-runtime
+Version: 0.2.1
+Summary: Neutral Taichi runtime: vector primitives, Tier-1 @ti.func helpers, and solver/operator injection seams for MechDSL-generated code
+Project-URL: Repository, https://github.com/CEmM2/MechDSL
+Author: Shmuel Osovski
+License-Expression: MIT
+License-File: LICENSE
+Keywords: fem,kernels,matrix-free,runtime,taichi
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: <3.14,>=3.11
+Requires-Dist: taichi>=1.7
+Description-Content-Type: text/markdown
+
+# ti-runtime
+
+Neutral Taichi runtime for **MechDSL** (PlanJune14, PJ-0).
+
+This package is the *seam + primitive* layer of the "Seams & Bodies" architecture:
+
+> MechDSL owns the **seams + primitives** (this package); algo2code generates the
+> **bodies** (solvers, preconditioners, constitutive updates, time integrators)
+> from LaTeX, injected into these seams.
+
+It contains only stable infrastructure — nothing algorithmic is hardcoded here:
+
+| Module | Contents |
+|---|---|
+| `vector_ops` | `@ti.kernel` vector primitives: `copy / axpy / xpay / scal / zero / dot / norm2` |
+| `tensor_ti`  | Tier-1 `@ti.func` helpers: `det3 / inv3 / F→C→E→J / Voigt / deviatoric / von_mises` |
+| `seams`      | injection plumbing: `Operator`, `PreconditionerBase`/`Identity`/`Diagonal`, `Solver`, `LinearSolveContext` |
+| `fields`     | `ti.init` + field-allocation boilerplate |
+| `hex8`       | Hex8 shape functions, natural-coord gradients, 2×2×2 Gauss quadrature (test harness / element operators) |
+
+## Provenance & invariants
+
+- **One-time harvest** (PlanJune14 D-B) — adapted from NumerixWeave
+  (`libs/tisolvers`, `libs/ticonstit`, `apps/tifem`); no ongoing sync.
+- **Portable output** (D-D) — generated artifacts depend on `ti_runtime`, never on
+  `mechdsl`, so they can later feed NumerixWeave / MOOSE / MFEM.
+- **Conventions** follow MechDSL `dev/design_docs/07-CONVENTIONS.md`: Voigt order
+  `[xx, yy, zz, xy, xz, yz]`, tensorial (unscaled shears), metric `diag(1,1,1,2,2,2)`.
+
+## Operator / solver contract
+
+A matrix-free operator is an in-place callable `apply(out, x) -> None` computing
+`out = A @ x` over Taichi fields. Inject it and run a (generated) solver against it:
+
+```python
+ctx = LinearSolveContext()
+ctx.set_operator(my_tangent_matvec)        # out = K(u) @ x, matrix-free @ti.kernel
+ctx.set_preconditioner(DiagonalPreconditioner(diag))
+# a generated PCG body calls ctx.apply_A / ctx.apply_preconditioner + vector_ops
+```

ti_runtime-0.2.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+ti_runtime/__init__.py,sha256=b_wiD-TDvRIjisDaEbQG1f_Okm68g_JBwExxMQWgCPg,1057
+ti_runtime/fields.py,sha256=nPF-iF0uVZa-mau1lTz3ow8xGP9uqsCd5tGDZZjC3g4,1381
+ti_runtime/hex8.py,sha256=LdpIrAhqkQmGdkOtOsqC-jBSAmjwElz5bb-mfjtRE_E,1765
+ti_runtime/seams.py,sha256=KkkJWJKzMtw3RXjdvZAPWLOVheMzz3lqSLAqcKJgYmI,11907
+ti_runtime/tensor_ti.py,sha256=OjXJQvJzI4IGOLni5XJyGiGx0qK4eLB3GWuYrH0RrQg,2432
+ti_runtime/vector_ops.py,sha256=i3F6bnWRgmMYzjCpDlO7R06VQ-cJ1DFFArUe9ivJllc,2584
+ti_runtime-0.2.1.dist-info/METADATA,sha256=aWU6QMF-Ldg4SVPZP9ganWAuE3PTFDLSR-opOtJ9IfQ,2657
+ti_runtime-0.2.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+ti_runtime-0.2.1.dist-info/licenses/LICENSE,sha256=09AX3cq_TtJwbbZ00zsqmmGL_p_FINJ4l8asH_rhVhk,1071
+ti_runtime-0.2.1.dist-info/RECORD,,

ti_runtime-0.2.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

ti_runtime-0.2.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shmuel Osovski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.