loadpath 0.1.1__py3-none-any.whl

loadpath/mma.py

@@ -0,0 +1,214 @@
+"""
+The Method of Moving Asymptotes (Svanberg 1987; the 2007 formulation in
+"MMA and GCMMA — two methods for nonlinear optimization"), written for
+loadpath from the published method so it stays MIT.
+
+MMA is what lets an optimization carry real constraints (a stress limit, a
+deflection limit, several at once) instead of the single volume constraint
+optimality criteria can handle. Each iteration builds a convex separable
+approximation of the problem around the current design, using moving
+asymptotes that tighten when the design oscillates and relax when it moves
+steadily, and solves it exactly with a primal-dual interior-point method.
+The problem solved is
+
+    minimize    f0(x) + a0 z + sum_i (c_i y_i + 0.5 d_i y_i^2)
+    subject to  f_i(x) - a_i z - y_i <= 0,   xmin <= x <= xmax,
+                y_i >= 0, z >= 0
+
+with the usual choice a0 = 1, a_i = 0, d_i = 1 and large c_i, which makes
+the artificial y_i zero whenever the real constraints can be met.
+
+Sized for topology optimization: n (design cells) is large and m
+(constraints) is small, so the Newton steps solve an m x m system.
+"""
+from __future__ import annotations
+
+import numpy as np
+
+__all__ = ["MMA"]
+
+
+class MMA:
+    def __init__(self, n, m, xmin=0.0, xmax=1.0, move=0.2, c=1000.0, asyinit=0.5,
+                 asyincr=1.2, asydecr=0.7):
+        self.n, self.m = n, m
+        self.xmin = np.broadcast_to(np.asarray(xmin, float), (n,)).copy()
+        self.xmax = np.broadcast_to(np.asarray(xmax, float), (n,)).copy()
+        self.move = move
+        self.a0 = 1.0
+        self.a = np.zeros(m)
+        self.c = np.full(m, float(c))
+        self.d = np.ones(m)
+        self.asyinit, self.asyincr, self.asydecr = asyinit, asyincr, asydecr
+        self.xold1 = None
+        self.xold2 = None
+        self.low = None
+        self.upp = None
+        self.iter = 0
+
+    def tighten(self, factor):
+        """Pull the asymptotes toward the last design by `factor`: a more
+        curved, more conservative model for the next step (what GCMMA's
+        inner loop does, without its extra function evaluations)."""
+        if self.xold1 is not None and self.low is not None:
+            self.low = self.xold1 - factor * (self.xold1 - self.low)
+            self.upp = self.xold1 + factor * (self.upp - self.xold1)
+
+    def update(self, x, f0, df0, f, df):
+        """One MMA step from design x with objective value/gradient (f0, df0)
+        and constraint values/gradients (f: (m,), df: (m, n)). Returns the new
+        design."""
+        xmin, xmax = self.xmin, self.xmax
+        # Non-finite values (a solve that broke down) would turn the whole
+        # subproblem NaN; read them as a large violation and stay in bounds.
+        x = np.clip(np.nan_to_num(np.asarray(x, float), nan=0.5), xmin, xmax)
+        f = np.nan_to_num(np.asarray(f, float).reshape(self.m), nan=1e6, posinf=1e6, neginf=-1e6)
+        df = np.nan_to_num(np.asarray(df, float).reshape(self.m, self.n), nan=0.0, posinf=1e6, neginf=-1e6)
+        df0 = np.nan_to_num(np.asarray(df0, float), nan=0.0, posinf=1e6, neginf=-1e6)
+        self.iter += 1
+        span = xmax - xmin
+        if self.iter <= 2 or self.low is None:
+            self.low = x - self.asyinit * span
+            self.upp = x + self.asyinit * span
+        else:
+            zzz = (x - self.xold1) * (self.xold1 - self.xold2)
+            factor = np.ones(self.n)
+            factor[zzz > 0] = self.asyincr
+            factor[zzz < 0] = self.asydecr
+            self.low = x - factor * (self.xold1 - self.low)
+            self.upp = x + factor * (self.upp - self.xold1)
+            self.low = np.clip(self.low, x - 10 * span, x - 0.01 * span)
+            self.upp = np.clip(self.upp, x + 0.01 * span, x + 10 * span)
+        low, upp = self.low, self.upp
+        albefa = 0.1
+        alfa = np.maximum.reduce([low + albefa * (x - low), x - self.move * span, xmin])
+        beta = np.minimum.reduce([upp - albefa * (upp - x), x + self.move * span, xmax])
+
+        raa0 = 1e-5
+        xmami = np.maximum(span, 1e-5)
+        ux1 = upp - x
+        xl1 = x - low
+        ux2, xl2 = ux1 * ux1, xl1 * xl1
+        p0 = np.maximum(df0, 0.0)
+        q0 = np.maximum(-df0, 0.0)
+        pq0 = 0.001 * (p0 + q0) + raa0 / xmami
+        p0 = (p0 + pq0) * ux2
+        q0 = (q0 + pq0) * xl2
+        P = np.maximum(df, 0.0)
+        Q = np.maximum(-df, 0.0)
+        PQ = 0.001 * (P + Q) + raa0 / xmami
+        P = (P + PQ) * ux2
+        Q = (Q + PQ) * xl2
+        b = P @ (1.0 / ux1) + Q @ (1.0 / xl1) - f
+
+        with np.errstate(divide="ignore", invalid="ignore"):
+            xnew = self._subsolv(low, upp, alfa, beta, p0, q0, P, Q, b)
+        if not np.all(np.isfinite(xnew)):
+            # the interior point broke down: keep those variables in place
+            xnew = np.where(np.isfinite(xnew), xnew, x)
+        xnew = np.clip(xnew, alfa, beta)
+        self.xold2 = self.xold1 if self.xold1 is not None else x.copy()
+        self.xold1 = x.copy()
+        return xnew
+
+    def _subsolv(self, low, upp, alfa, beta, p0, q0, P, Q, b, epsimin=1e-7):
+        m = self.m
+        a0, a, c, d = self.a0, self.a, self.c, self.d
+        x = 0.5 * (alfa + beta)
+        y = np.ones(m)
+        z = 1.0
+        lam = np.ones(m)
+        xsi = np.maximum(1.0 / (x - alfa), 1.0)
+        eta = np.maximum(1.0 / (beta - x), 1.0)
+        mu = np.maximum(1.0, 0.5 * c)
+        zet = 1.0
+        s = np.ones(m)
+        epsi = 1.0
+
+        def residual(x, y, z, lam, xsi, eta, mu, zet, s, epsi):
+            ux1 = upp - x
+            xl1 = x - low
+            plam = p0 + P.T @ lam
+            qlam = q0 + Q.T @ lam
+            gvec = P @ (1.0 / ux1) + Q @ (1.0 / xl1)
+            dpsidx = plam / (ux1 * ux1) - qlam / (xl1 * xl1)
+            r = np.concatenate([
+                dpsidx - xsi + eta,
+                c + d * y - mu - lam,
+                [a0 - zet - a @ lam],
+                gvec - a * z - y + s - b,
+                xsi * (x - alfa) - epsi,
+                eta * (beta - x) - epsi,
+                mu * y - epsi,
+                [zet * z - epsi],
+                lam * s - epsi,
+            ])
+            return r
+
+        while epsi > epsimin:
+            r = residual(x, y, z, lam, xsi, eta, mu, zet, s, epsi)
+            norm = np.linalg.norm(r)
+            rmax = np.abs(r).max()
+            it = 0
+            while rmax > 0.9 * epsi and it < 200:
+                it += 1
+                ux1 = upp - x
+                xl1 = x - low
+                ux2, xl2 = ux1 * ux1, xl1 * xl1
+                ux3, xl3 = ux1 * ux2, xl1 * xl2
+                plam = p0 + P.T @ lam
+                qlam = q0 + Q.T @ lam
+                gvec = P @ (1.0 / ux1) + Q @ (1.0 / xl1)
+                GG = P / ux2 - Q / xl2
+                dpsidx = plam / ux2 - qlam / xl2
+                delx = dpsidx - epsi / (x - alfa) + epsi / (beta - x)
+                dely = c + d * y - lam - epsi / y
+                delz = a0 - a @ lam - epsi / z
+                dellam = gvec - a * z - y - b + epsi / lam
+                diagx = 2.0 * (plam / ux3 + qlam / xl3) + xsi / (x - alfa) + eta / (beta - x)
+                diagy = d + mu / y
+                diaglamyi = s / lam + 1.0 / diagy
+                blam = dellam + dely / diagy - GG @ (delx / diagx)
+                alam = np.diag(diaglamyi) + (GG / diagx) @ GG.T
+                aa = np.zeros((m + 1, m + 1))
+                aa[:m, :m] = alam
+                aa[:m, m] = a
+                aa[m, :m] = a
+                aa[m, m] = -zet / z
+                sol = np.linalg.solve(aa, np.concatenate([blam, [delz]]))
+                dlam, dz = sol[:m], sol[m]
+                dx = -delx / diagx - (GG.T @ dlam) / diagx
+                dy = -dely / diagy + dlam / diagy
+                dxsi = -xsi + epsi / (x - alfa) - xsi * dx / (x - alfa)
+                deta = -eta + epsi / (beta - x) + eta * dx / (beta - x)
+                dmu = -mu + epsi / y - mu * dy / y
+                dzet = -zet + epsi / z - zet * dz / z
+                ds = -s + epsi / lam - s * dlam / lam
+
+                xx = np.concatenate([y, [z], lam, xsi, eta, mu, [zet], s])
+                dxx = np.concatenate([dy, [dz], dlam, dxsi, deta, dmu, [dzet], ds])
+                stmxx = np.max(-1.01 * dxx / xx)
+                stmalfa = np.max(-1.01 * dx / (x - alfa))
+                stmbeta = np.max(1.01 * dx / (beta - x))
+                steg = 1.0 / max(stmalfa, stmbeta, stmxx, 1.0)
+                old = (x, y, z, lam, xsi, eta, mu, zet, s)
+                for _ in range(50):
+                    x = old[0] + steg * dx
+                    y = old[1] + steg * dy
+                    z = old[2] + steg * dz
+                    lam = old[3] + steg * dlam
+                    xsi = old[4] + steg * dxsi
+                    eta = old[5] + steg * deta
+                    mu = old[6] + steg * dmu
+                    zet = old[7] + steg * dzet
+                    s = old[8] + steg * ds
+                    r = residual(x, y, z, lam, xsi, eta, mu, zet, s, epsi)
+                    newnorm = np.linalg.norm(r)
+                    if newnorm < 2.0 * norm:
+                        break
+                    steg /= 2.0
+                norm = newnorm
+                rmax = np.abs(r).max()
+            epsi *= 0.1
+        self.lam = lam
+        return x

loadpath/modal.py

@@ -0,0 +1,210 @@
+"""
+Natural frequencies, mode shapes and damping, on the same voxel hex mesh.
+
+A part that shakes (a motor mount, an arm link carrying a gripper, a sensor
+bracket on a printer gantry) fails by resonance long before its static
+safety factor says it should: if a mode sits near the excitation the
+response is the static one times 1/(2 zeta). This module finds the modes:
+
+- `modal_analysis`: the generalized eigenproblem K phi = omega^2 M phi with
+  the consistent-free lumped mass (each cell's mass split over its 8 nodes),
+  per-cell modulus and density, so a homogenized graded lattice (modulus
+  E C rho^n, density rho_s rho) is analysed exactly like a solid. Point
+  masses (a motor, a gripper) attach to nodes. Returns frequencies (Hz),
+  modes, and each mode's effective mass fraction per axis (how much of
+  the part a base shake in that direction moves).
+- `transmissibility`: base-to-part amplification of a single mode at a
+  forcing frequency, with modal damping zeta = eta / 2 from the material's
+  loss factor (LOSS_FACTOR).
+
+On damping: a part made of one linear viscoelastic material has the modal
+loss factor of that material whatever its shape (every mode stores its
+energy in the same material), so a lattice of PA12 damps like solid PA12.
+Lattices raise damping only through something else: a second, lossy
+material (a TPU lattice, a TPU-filled core), friction, or unfused powder
+left in the cells (particle damping, large but unmodelled here). What a
+lattice does change is where the modes are: E/rho drops as rho^(n-1), so a
+lattice core lowers frequencies, which is what an isolator wants and a
+stiff bracket does not.
+
+Units: mm, N, MPa, g/cm^3 for density (converted to tonne/mm^3, which with
+N and mm gives seconds), kg for point masses, Hz out.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+import scipy.sparse as sp
+
+from .fem import HexMesh, Stiffness
+
+__all__ = ["ModalResult", "modal_analysis", "transmissibility", "base_transmissibility", "LOSS_FACTOR", "loss_factor", "vibration_report"]
+
+# Room-temperature loss factor (tan delta) near 10-100 Hz, typical values
+# from DMA data sheets and literature; rough (+-50%), and strongly
+# temperature dependent near Tg.
+LOSS_FACTOR = {
+    "pla": 0.015, "petg": 0.02, "abs": 0.02, "asa": 0.02, "pc": 0.012, "pa12": 0.04, "pa11": 0.05,
+    "pa12-gb": 0.03, "pa12-cf": 0.03, "tpu": 0.12, "resin-rigid": 0.03, "resin-tough": 0.05,
+    "alsi10mg": 0.002, "ti64": 0.002, "316l": 0.002, "aluminum": 0.001, "steel": 0.001,
+}
+
+
+def loss_factor(material) -> float:
+    name = getattr(material, "name", str(material)).lower()
+    return LOSS_FACTOR.get(name, 0.02)
+
+
+@dataclass
+class ModalResult:
+    frequencies: np.ndarray          # Hz, ascending
+    modes: np.ndarray                # (n_dof, k), mass-normalized
+    mass: float                      # kg, the part plus point masses
+    participation: np.ndarray        # (k, 3) effective mass fraction per axis
+    mass_vector: np.ndarray | None = None    # (n_dof,) lumped mass per dof, tonnes
+
+    def to_dict(self, eta: float | None = None) -> dict:
+        out = {"frequencies": [round(float(f), 2) for f in self.frequencies], "mass": round(self.mass, 5),
+               "massFraction": [[round(float(x), 3) for x in row] for row in self.participation]}
+        if eta is not None:
+            out["lossFactor"] = eta
+            out["dampingRatio"] = round(eta / 2.0, 4)
+            out["resonantAmplification"] = round(1.0 / eta, 1)
+        return out
+
+
+def _lumped_mass(mesh: HexMesh, density):
+    rho = np.broadcast_to(np.asarray(density, float), (mesh.n_elem,)) * 1e-9     # g/cm^3 -> t/mm^3
+    m_node = np.zeros(mesh.n_nodes)
+    np.add.at(m_node, mesh.enode, (rho * mesh.pitch ** 3 / 8.0)[:, None])
+    return m_node
+
+
+def modal_analysis(mesh: HexMesh, modulus, density, nu: float, fixed: np.ndarray, n_modes: int = 6,
+                   point_masses: list | None = None) -> ModalResult:
+    """Lowest `n_modes` natural frequencies (Hz) of a voxel model.
+
+    modulus: E per element (MPa) or scalar; density: g/cm^3 per element or
+    scalar; fixed: bool per dof (clamped). point_masses: [(node_ids, kg)],
+    each spread evenly over its nodes (all three directions)."""
+    from scipy.sparse.linalg import eigsh
+
+    fixed = np.asarray(fixed, bool)
+    st = Stiffness(mesh, nu, fixed)
+    k = st.assemble(np.broadcast_to(np.asarray(modulus, float), (mesh.n_elem,)))
+    m_node = _lumped_mass(mesh, density)
+    for nodes, kg in point_masses or []:
+        nodes = np.asarray(nodes, np.int64)
+        m_node[nodes] += kg * 1e-3 / len(nodes)
+    m = np.repeat(m_node, 3)
+    free = np.flatnonzero(~fixed)
+    kf = k[free][:, free].tocsc()
+    mf = m[free]
+    nm = min(n_modes, len(free) - 2)
+    if len(free) <= 120_000:
+        w, v = eigsh(kf, k=nm, M=sp.diags(mf).tocsc(), sigma=0.0, which="LM")
+    else:
+        # big models: LOBPCG on the mass-scaled operator with an AMG preconditioner
+        from scipy.sparse.linalg import lobpcg
+
+        from .fem import amg_solver
+
+        ml = amg_solver(kf.tocsr())
+        x0 = np.random.default_rng(0).standard_normal((len(free), nm + 4))
+        w, v = lobpcg(kf, x0, B=sp.diags(mf), M=ml.aspreconditioner(), largest=False, tol=1e-6, maxiter=400)
+        w, v = w[:nm], v[:, :nm]
+    order = np.argsort(w)
+    w, v = np.maximum(w[order], 0.0), v[:, order]
+    # mass-normalize (phi^T M phi = 1)
+    v = v / np.sqrt(np.einsum("ik,i,ik->k", v, mf, v))[None, :]
+    modes = np.zeros((mesh.n_dof, nm))
+    modes[free] = v
+    total = m_node.sum()
+    part = np.zeros((nm, 3))
+    for a in range(3):
+        r = np.zeros(mesh.n_dof)
+        r[a::3] = 1.0
+        g = (v * (mf * r[free])[:, None]).sum(axis=0)          # participation factor phi^T M r
+        part[:, a] = g ** 2 / total
+    return ModalResult(np.sqrt(w) / (2 * np.pi), modes, float(total * 1e3), part, m)
+
+
+def transmissibility(f_forcing, f_natural, eta: float):
+    """Base-excitation transmissibility |X / Y| of one mode with structural
+    damping (loss factor eta): 1 / eta at resonance, below 1 above
+    sqrt(2) f_n (isolation)."""
+    r2 = (np.asarray(f_forcing, float) / f_natural) ** 2
+    return np.sqrt((1 + eta ** 2) / ((1 - r2) ** 2 + eta ** 2))
+
+
+def base_transmissibility(res: ModalResult, dofs, axis: int, freqs, eta: float, fixed=None,
+                          stiffness_scale=None) -> np.ndarray:
+    """|absolute motion / base motion| at the given dofs (averaged, as complex
+    numbers) for a base shaken along `axis` (0, 1, 2) at each frequency, by
+    modal superposition with structural damping eta. The base is the
+    clamped dofs; `fixed` (bool per dof) leaves their mass out of the
+    participation factors. Truncated to the computed modes, so it holds up
+    to well below the highest of them. stiffness_scale (one per frequency)
+    multiplies every mode's stiffness at that frequency: a viscoelastic
+    mount that stiffens with frequency (viscoelastic.dynamic_factor over its
+    value where the modes were computed)."""
+    m = res.mass_vector.copy()
+    if fixed is not None:
+        m[np.asarray(fixed, bool)] = 0.0
+    r = np.zeros(len(m))
+    r[axis::3] = 1.0
+    gam = res.modes.T @ (m * r)                                  # participation factors
+    phi = res.modes[np.asarray(dofs, np.int64)].mean(axis=0)      # (k,)
+    wr2 = (2 * np.pi * res.frequencies) ** 2
+    w2 = (2 * np.pi * np.asarray(freqs, float))[:, None] ** 2
+    if stiffness_scale is not None:
+        wr2 = wr2[None, :] * np.asarray(stiffness_scale, float)[:, None]
+    drive = 1.0 if np.all(np.asarray(dofs) % 3 == axis) else 0.0
+    wr2 = np.broadcast_to(wr2, (w2.shape[0], len(gam)))
+    rel = (phi * gam)[None, :] * w2 / (wr2 - w2 + 1j * eta * wr2)
+    return np.abs(drive + rel.sum(axis=1))
+
+
+def vibration_report(graph, spec: dict, material) -> dict:
+    """The field graph's `vibration` block: modes of the `envelope` filled
+    with the `lattice` at `density` (homogenized: E C rho^n, rho_s rho),
+    clamped inside the `fixed` solid, with point masses."""
+    from .impact import sample_core
+    from .lattice import sheet_modulus
+
+    kind = spec.get("lattice", "gyroid")
+    inside, rho, lo, h = sample_core(graph, spec["envelope"], spec.get("density"), float(spec.get("pitch", 1.0)))
+    ijk = np.argwhere(inside)
+    mesh = HexMesh(ijk, h, lo)
+    r = rho[inside]
+    mod = float(material.E) * sheet_modulus(kind, r)
+    dens = float(material.density) * r
+
+    def nodes_in(node):
+        return np.flatnonzero(graph.evaluate(mesh.node_xyz, node) <= 0.5 * h)
+
+    fixed = np.zeros(mesh.n_dof, bool)
+    fn = nodes_in(spec["fixed"])
+    if len(fn) == 0:
+        raise ValueError(f"vibration: no nodes inside the fixed node {spec['fixed']!r}")
+    for a in range(3):
+        fixed[3 * fn + a] = True
+    pm = []
+    for p in spec.get("pointMasses", []):
+        nn = nodes_in(p["region"])
+        if len(nn) == 0:
+            raise ValueError(f"vibration: point mass region {p['region']!r} has no nodes")
+        pm.append((nn, float(p["mass"])))
+    res = modal_analysis(mesh, mod, dens, float(material.nu), fixed, int(spec.get("modes", 6)), pm)
+    eta = float(spec.get("lossFactor", loss_factor(material)))
+    out = {"lattice": kind, "cells": int(mesh.n_elem), **res.to_dict(eta)}
+    f1 = float(res.frequencies[0])
+    if spec.get("minFrequency") is not None:
+        out["minFrequency"] = float(spec["minFrequency"])
+        out["ok"] = bool(f1 >= float(spec["minFrequency"]))
+    if spec.get("excitation") is not None:
+        fx = float(spec["excitation"])
+        out["excitation"] = fx
+        out["transmissibility"] = round(float(max(transmissibility(fx, f, eta) for f in res.frequencies)), 2)
+    return out