{ "cells": [ { "cell_type": "markdown", "id": "53666302", "metadata": {}, "source": [ "# 20 · Quadratic (P2) finite elements in 3D — a beam sagging under gravity\n", "\n", "Tutorial [12](12_p2_finite_elements.ipynb) introduced quadratic (**P2**) triangles in 2D.\n", "Here we take the *same* P2 toolchain into **3D tetrahedra** and run a classic test:\n", "a beam **pinned at one end** that **sags under its own weight**.\n", "\n", "The whole point of P2 is that displacements vary *quadratically* inside each\n", "element, so the element can **bend** — its edges and faces become curved. A\n", "cantilever under gravity is exactly the kind of bending-dominated problem where\n", "that extra richness pays off, so it makes a perfect 3D showcase.\n", "\n", "Everything below uses the regular `simkit` P2 building blocks, each of which now\n", "works for tets just as it does for triangles:\n", "\n", "| step | function | what it does |\n", "|------|----------|--------------|\n", "| promote mesh | `linear_to_quadratic_elements` | add an edge-midpoint node to every edge → 10-node tets |\n", "| quadrature | `gauss_legendre_quadrature` | per-element cubature points (barycentric) + weights |\n", "| deformation | `deformation_jacobian_p2` | sparse operator → one $F$ **per cubature point** |\n", "| mass | `p2_massmatrix` | consistent mass over the 10-node set |\n", "| gravity | `p2_gravity_force` | body force distributed by the consistent mass |\n", "\n", "The elastic energy, the Newton solver and the Dirichlet pin are the **ordinary\n", "P1 code** — P2 changes only how $F$ and the mass are assembled." ] }, { "cell_type": "code", "execution_count": 1, "id": "01649aa3", "metadata": { "execution": { "iopub.execute_input": "2026-06-09T05:31:02.172770Z", "iopub.status.busy": "2026-06-09T05:31:02.172682Z", "iopub.status.idle": "2026-06-09T05:31:02.678604Z", "shell.execute_reply": "2026-06-09T05:31:02.678337Z" } }, "outputs": [], "source": [ "%matplotlib inline\n", "import numpy as np\n", "import scipy as sp\n", "import matplotlib.pyplot as plt\n", "from mpl_toolkits.mplot3d.art3d import Poly3DCollection\n", "from matplotlib.animation import FuncAnimation\n", "import simkit\n", "import simkit.energies as energies\n", "from simkit.solvers import newton_solver\n", "import utils\n", "\n", "np.set_printoptions(precision=4, suppress=True)" ] }, { "cell_type": "markdown", "id": "aa2b127d", "metadata": {}, "source": [ "## A standardized P2 tet simulator\n", "\n", "`P2TetBeam` follows the usual simulator recipe, but its `__init__` does the extra\n", "P2 **precompute** in-class (there is no `utils.precompute` for P2 operators): it\n", "promotes the linear mesh, builds the cubature rule, the per-cubature deformation\n", "operator `J2`, the consistent mass matrix `M`, the gravity force `f_g`, and the\n", "Dirichlet pin `Q, b`.\n", "\n", "The static potential we minimize is\n", "\n", "$$\n", "\\Phi(x) = \\underbrace{\\Psi_\\text{neo-Hookean}(F(x))}_{\\text{elastic}}\n", " \\;+\\; \\underbrace{\\tfrac12 x^\\top Q x + b^\\top x}_{\\text{pin}}\n", " \\;-\\; \\underbrace{f_g^\\top x}_{\\text{gravity}}.\n", "$$\n", "\n", "`energy / gradient / hessian` sum those three terms **one per line**, exactly as\n", "the Newton solver wants them, and `solve()` runs the static equilibrium. The\n", "elastic functions are the **unchanged** element-tier neo-Hookean energies — they\n", "just receive the stacked per-cubature `F` and per-cubature `vol`, treating each\n", "cubature point as a pseudo-element. The dynamic `step()` adds an inertial\n", "backward-Euler term on top of the same potential." ] }, { "cell_type": "code", "execution_count": 2, "id": "03953d7c", "metadata": { "execution": { "iopub.execute_input": "2026-06-09T05:31:02.679825Z", "iopub.status.busy": "2026-06-09T05:31:02.679735Z", "iopub.status.idle": "2026-06-09T05:31:02.683402Z", "shell.execute_reply": "2026-06-09T05:31:02.683192Z" } }, "outputs": [], "source": [ "class P2TetBeam:\n", " \"\"\"P2 tetrahedral beam: neo-Hookean elastic + Dirichlet pin + gravity,\n", " solved statically or stepped with backward-Euler inertia via Newton.\"\"\"\n", "\n", " def __init__(self, X, T, ym=1.2e4, pr=0.45, rho=1.0, grav=-9.8, gamma=1e8):\n", " self.X, self.T = X, T\n", " self.n1, self.dim = X.shape\n", " dim = self.dim\n", "\n", " # --- promote the linear tet mesh to 10-node P2 tets ---\n", " self.V2, self.T2 = simkit.linear_to_quadratic_elements(X, T)\n", " self.n2 = self.V2.shape[0]\n", "\n", " # --- quadrature + P2 operators (the in-class precompute) ---\n", " bary, w = simkit.gauss_legendre_quadrature(X, T, order=2)\n", " self.bary = bary\n", " self.J2 = simkit.deformation_jacobian_p2(self.V2, self.T2, bary, w)\n", " self.vol2 = w.reshape(-1, 1) # per-cubature \"vol\"\n", " self.M = sp.sparse.kron(simkit.p2_massmatrix(self.V2, self.T2, bary, w, rho=rho),\n", " sp.sparse.eye(dim)).tocsc()\n", " self.f_g = simkit.p2_gravity_force(self.V2, self.T2, bary, w, a=grav, rho=rho).reshape(-1, 1)\n", "\n", " # --- per-cubature Lame parameters ---\n", " mu0, lam0 = simkit.ympr_to_lame(ym, pr)\n", " nb = self.vol2.shape[0]\n", " self.mu = np.full((nb, 1), mu0)\n", " self.lam = np.full((nb, 1), lam0)\n", "\n", " # --- Dirichlet pin: every P2 node on the x = x_min face ---\n", " self.pin = np.where(self.V2[:, 0] <= self.V2[:, 0].min() + 1e-9)[0]\n", " self.Q, self.b = simkit.dirichlet_penalty(self.pin, self.V2[self.pin], self.n2, gamma=gamma)\n", "\n", " # --- backward-Euler inertia helper (driven by step) ---\n", " self.inertia = utils.Inertia(self.M, h=0.02)\n", "\n", " # ---- static potential: elastic + pin + gravity ----\n", " def energy(self, x):\n", " xn, xc = x.reshape(-1, self.dim), x.reshape(-1, 1)\n", " E_elastic = energies.macklin_mueller_neo_hookean_energy_x(xn, self.J2, self.mu, self.lam, self.vol2)\n", " E_pin = 0.5 * (xc.T @ (self.Q @ xc))[0, 0] + (self.b.T @ xc)[0, 0]\n", " E_gravity = -(self.f_g.T @ xc)[0, 0]\n", " return E_elastic + E_pin + E_gravity\n", "\n", " def gradient(self, x):\n", " xn, xc = x.reshape(-1, self.dim), x.reshape(-1, 1)\n", " g_elastic = energies.macklin_mueller_neo_hookean_gradient_x(xn, self.J2, self.mu, self.lam, self.vol2)\n", " g_pin = self.Q @ xc + self.b\n", " g_gravity = -self.f_g\n", " return g_elastic + g_pin + g_gravity\n", "\n", " def hessian(self, x):\n", " xn = x.reshape(-1, self.dim)\n", " H_elastic = energies.macklin_mueller_neo_hookean_hessian_x(xn, self.J2, self.mu, self.lam, self.vol2, psd=True)\n", " H_pin = self.Q\n", " return H_elastic + H_pin\n", "\n", " def solve(self, x0=None, max_iter=300, tolerance=1e-9):\n", " x0 = self.V2.reshape(-1, 1).copy() if x0 is None else x0\n", " sol = newton_solver(x0, self.energy, self.gradient, self.hessian,\n", " max_iter=max_iter, tolerance=tolerance)\n", " return sol.reshape(self.n2, self.dim)\n", "\n", " def step(self, x_n, v_n, h=0.02, max_iter=30, tolerance=1e-7):\n", " # backward-Euler: add inertia 1/(2h^2)||x - x_tilde||_M^2 to the static potential.\n", " self.inertia.h = h\n", " self.inertia.update(x_n, v_n)\n", "\n", " def E(x):\n", " E_static = self.energy(x)\n", " E_inertia = self.inertia.energy(x.reshape(-1, 1))\n", " return E_static + E_inertia\n", "\n", " def G(x):\n", " g_static = self.gradient(x)\n", " g_inertia = self.inertia.gradient(x.reshape(-1, 1))\n", " return g_static + g_inertia\n", "\n", " def H(x):\n", " H_static = self.hessian(x)\n", " H_inertia = self.inertia.hessian(x.reshape(-1, 1))\n", " return H_static + H_inertia\n", "\n", " return newton_solver(x_n.copy(), E, G, H, max_iter=max_iter, tolerance=tolerance)" ] }, { "cell_type": "markdown", "id": "d296c475", "metadata": {}, "source": [ "## 1 · A tetrahedral beam, promoted to P2\n", "\n", "We start from an ordinary linear tet mesh of a long thin brick (`utils.tetrahedralized_grid`,\n", "5 tets per voxel). Building the simulator promotes it with `linear_to_quadratic_elements`,\n", "which inserts one new node at the **midpoint of every edge** and rebuilds the\n", "connectivity so each tet lists its 4 corners followed by its 6 edge-midpoints — a\n", "**10-node** P2 tet.\n", "\n", "Midpoint nodes are *shared* between neighbouring tets, so the P2 mesh stays\n", "conforming. And because each new node sits exactly on an edge midpoint, the\n", "rest-shape map is still affine per element (the reference→rest Jacobian is\n", "constant), which is what keeps `deformation_jacobian_p2` a fixed sparse matrix." ] }, { "cell_type": "code", "execution_count": 3, "id": "a0b64eb2", "metadata": { "execution": { "iopub.execute_input": "2026-06-09T05:31:02.684345Z", "iopub.status.busy": "2026-06-09T05:31:02.684290Z", "iopub.status.idle": "2026-06-09T05:31:02.701603Z", "shell.execute_reply": "2026-06-09T05:31:02.701407Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "P1 (linear): 45 nodes, 80 tets (4 nodes each), 135 dofs\n", "P2 (quadratic): 209 nodes, 80 tets (10 nodes each), 627 dofs\n", "same elements, but every P2 tet now carries 6 extra edge-midpoint nodes\n" ] } ], "source": [ "# Long, slender beam along x; gravity will pull it down in -y.\n", "X, T = utils.tetrahedralized_grid(nx=5, ny=3, nz=3, width=5.0, height=0.4, depth=0.4)\n", "\n", "beam = P2TetBeam(X, T)\n", "V2, T2 = beam.V2, beam.T2\n", "n1, dim = beam.n1, beam.dim\n", "n2 = beam.n2\n", "\n", "print(f\"P1 (linear): {n1:4d} nodes, {T.shape[0]} tets ({T.shape[1]} nodes each), {n1*dim} dofs\")\n", "print(f\"P2 (quadratic): {n2:4d} nodes, {T2.shape[0]} tets ({T2.shape[1]} nodes each), {n2*dim} dofs\")\n", "print(\"same elements, but every P2 tet now carries 6 extra edge-midpoint nodes\")" ] }, { "cell_type": "markdown", "id": "59d5eadd", "metadata": {}, "source": [ "## 2 · Quadrature and the P2 operators\n", "\n", "A linear (P1) tet has a **single constant** deformation gradient $F$. A quadratic\n", "tet does not: P2 shape-function gradients are *linear* in position, so $F$ varies\n", "*inside* the element. We therefore integrate the energy with a **quadrature rule**\n", "and evaluate $F$ at every cubature point. The simulator already built these in its\n", "`__init__`:\n", "\n", "- `gauss_legendre_quadrature(X, T, order=2)` returns the barycentric cubature\n", " points `bary` and physical weights `w` (each `w[e]` sums to the tet volume).\n", " Order 2 is enough for a neo-Hookean stiffness.\n", "- `deformation_jacobian_p2` builds the constant sparse operator `J2` with\n", " `F = (J2 @ x).reshape(-1, dim, dim)` giving **one $F$ per cubature point**\n", " ($t \\cdot n_\\text{quad}$ blocks). The per-cubature weights play the role of the\n", " energy's `vol`.\n", "- `p2_massmatrix` / `p2_gravity_force` build the **consistent** mass matrix over\n", " the 10-node set and the gravitational body force it implies.\n", "\n", "Let us sanity-check that the 3D operators are wired up correctly:" ] }, { "cell_type": "code", "execution_count": 4, "id": "9d636314", "metadata": { "execution": { "iopub.execute_input": "2026-06-09T05:31:02.702427Z", "iopub.status.busy": "2026-06-09T05:31:02.702377Z", "iopub.status.idle": "2026-06-09T05:31:02.704596Z", "shell.execute_reply": "2026-06-09T05:31:02.704413Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "cubature points : 80 tets x 4 pts = 320 F blocks\n", "F at rest == I : True\n", "total mass : 0.8000 (== rho*volume = 0.8000)\n", "total gravity y : -7.8400 (== rho*g*volume = -7.8400)\n" ] } ], "source": [ "RHO, GRAV = 1.0, -9.8\n", "\n", "F_rest = (beam.J2 @ V2.reshape(-1, 1)).reshape(-1, dim, dim)\n", "print(\"cubature points :\", beam.bary.shape[0], \"tets x\", beam.bary.shape[1], \"pts =\", beam.J2.shape[0] // (dim*dim), \"F blocks\")\n", "print(\"F at rest == I :\", np.allclose(F_rest, np.eye(dim)))\n", "print(\"total mass :\", f\"{beam.M.sum()/dim:.4f} (== rho*volume = {RHO*simkit.volume(X,T).sum():.4f})\")\n", "print(\"total gravity y :\", f\"{beam.f_g.reshape(-1,dim)[:,1].sum():.4f} (== rho*g*volume = {RHO*GRAV*simkit.volume(X,T).sum():.4f})\")" ] }, { "cell_type": "markdown", "id": "c7f298c6", "metadata": {}, "source": [ "## 3 · Pin one end and solve the static gravity equilibrium\n", "\n", "We clamp the slab of nodes at the minimum-$x$ face with a stiff quadratic\n", "**Dirichlet penalty** (`dirichlet_penalty` returns `Q, b` with penalty energy\n", "$\\tfrac12 x^\\top Q x + b^\\top x$); the simulator set this up in its `__init__`.\n", "\n", "Minimizing the static potential $\\Phi$ with Newton's method (PSD-projected\n", "Hessian + line search) gives the shape the beam settles into. The free tip drops\n", "far below the clamped root — a textbook cantilever droop." ] }, { "cell_type": "code", "execution_count": 5, "id": "0a73f0e6", "metadata": { "execution": { "iopub.execute_input": "2026-06-09T05:31:02.705441Z", "iopub.status.busy": "2026-06-09T05:31:02.705398Z", "iopub.status.idle": "2026-06-09T05:31:02.942233Z", "shell.execute_reply": "2026-06-09T05:31:02.942036Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "pinned 25 P2 nodes on the x = -2.50 face\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "free-tip vertical position: -2.786 (rest was -0.000)\n", "max nodal displacement : 2.854\n", "min det(F) : 0.963 (>0 → no inverted elements)\n" ] } ], "source": [ "print(f\"pinned {beam.pin.size} P2 nodes on the x = {V2[:,0].min():.2f} face\")\n", "\n", "sol = beam.solve()\n", "\n", "tip = np.where(V2[:, 0] >= V2[:, 0].max() - 1e-9)[0] # nodes at the free end\n", "print(f\"free-tip vertical position: {sol[tip,1].mean():+.3f} (rest was {V2[tip,1].mean():+.3f})\")\n", "print(f\"max nodal displacement : {np.abs(sol - V2).max():.3f}\")\n", "detF = np.linalg.det((beam.J2 @ sol.reshape(-1,1)).reshape(-1, dim, dim))\n", "print(f\"min det(F) : {detF.min():.3f} (>0 → no inverted elements)\")" ] }, { "cell_type": "markdown", "id": "b3e3e13a", "metadata": {}, "source": [ "## Rendering P2 in 3D — *true curved* surfaces\n", "\n", "A P2 tet face is a **curved quadratic patch**, not a flat triangle. To draw it\n", "honestly we take each boundary face's 6 P2 nodes (3 corners + 3 edge-midpoints)\n", "and evaluate the P2 triangle shape functions on a refined sub-grid of the\n", "reference triangle — sampling the real curved surface. (Compare with P1, where\n", "the only option is flat triangles.)\n", "\n", "The helpers below extract the boundary faces of the tet mesh once, then map any\n", "nodal configuration `U2` to a set of small surface triangles tracing the curved\n", "geometry." ] }, { "cell_type": "code", "execution_count": 6, "id": "7ec72089", "metadata": { "execution": { "iopub.execute_input": "2026-06-09T05:31:02.943174Z", "iopub.status.busy": "2026-06-09T05:31:02.943120Z", "iopub.status.idle": "2026-06-09T05:31:02.946564Z", "shell.execute_reply": "2026-06-09T05:31:02.946376Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "80 boundary faces\n" ] } ], "source": [ "# --- boundary faces of the tet mesh, with their 6 P2 nodes ---------------------\n", "# Tet local edges (matches simkit's P2 node order): nodes 4..9 are these midpoints.\n", "_EDGE2NODE = {(0, 1): 4, (0, 2): 5, (0, 3): 6, (1, 2): 7, (1, 3): 8, (2, 3): 9}\n", "_TET_FACES = [(1, 2, 3), (0, 2, 3), (0, 1, 3), (0, 1, 2)]\n", "\n", "def p2_boundary_faces(T2):\n", " # (n_faces, 6) global P2 node indices for each surface triangle.\n", " count = {}\n", " for el in np.asarray(T2):\n", " for f in _TET_FACES:\n", " key = tuple(sorted(int(el[c]) for c in f))\n", " count[key] = count.get(key, 0) + 1\n", " faces6 = []\n", " for el in np.asarray(T2):\n", " for f in _TET_FACES:\n", " key = tuple(sorted(int(el[c]) for c in f))\n", " if count[key] != 1: # interior face shared by two tets → skip\n", " continue\n", " a, b, c = sorted(f) # triangle P2 order: [c0,c1,c2, m01,m12,m20]\n", " faces6.append([int(el[i]) for i in\n", " (a, b, c, _EDGE2NODE[(a, b)], _EDGE2NODE[(b, c)], _EDGE2NODE[(a, c)])])\n", " return np.array(faces6)\n", "\n", "def patch_basis(nsub):\n", " # Refined reference-triangle samples: P2 basis matrix W and sub-triangulation.\n", " pts, idx = [], {}\n", " for i in range(nsub + 1):\n", " for j in range(nsub + 1 - i):\n", " idx[(i, j)] = len(pts); pts.append((i / nsub, j / nsub))\n", " pts = np.array(pts)\n", " L = np.column_stack([1 - pts[:, 0] - pts[:, 1], pts[:, 0], pts[:, 1]])\n", " W = np.array([simkit.p2_shape_functions(Li, 3)[0] for Li in L]) # (S, 6)\n", " tris = []\n", " for i in range(nsub):\n", " for j in range(nsub - i):\n", " tris.append([idx[(i, j)], idx[(i + 1, j)], idx[(i, j + 1)]])\n", " if j < nsub - i - 1:\n", " tris.append([idx[(i + 1, j)], idx[(i + 1, j + 1)], idx[(i, j + 1)]])\n", " return W, np.array(tris)\n", "\n", "FACES6 = p2_boundary_faces(T2)\n", "print(f\"{FACES6.shape[0]} boundary faces\")\n", "\n", "def curved_surface(U2, W, tris):\n", " # Map nodal positions U2 to (n_poly, 3, 3) curved surface triangles.\n", " P = np.einsum(\"sk,fkd->fsd\", W, U2[FACES6]) # (n_faces, S, 3) sampled patch\n", " return P[:, tris].reshape(-1, 3, 3)\n", "\n", "def setup_3d(ax, title):\n", " ax.set_xlim(-2.7, 2.7); ax.set_ylim(-3.4, 0.7); ax.set_zlim(-0.8, 0.8)\n", " ax.set_box_aspect((5.4, 4.1, 1.6)); ax.view_init(elev=12, azim=-72)\n", " ax.set_xlabel(\"x\"); ax.set_ylabel(\"y (gravity ↓)\"); ax.set_zlabel(\"z\")\n", " ax.set_title(title, fontsize=11)" ] }, { "cell_type": "markdown", "id": "90e5990a", "metadata": {}, "source": [ "Now draw the rest beam (ghost) and the sagged equilibrium (solid), both with\n", "their genuine curved P2 faces." ] }, { "cell_type": "code", "execution_count": 7, "id": "65b6281d", "metadata": { "execution": { "iopub.execute_input": "2026-06-09T05:31:02.947452Z", "iopub.status.busy": "2026-06-09T05:31:02.947402Z", "iopub.status.idle": "2026-06-09T05:31:03.138538Z", "shell.execute_reply": "2026-06-09T05:31:03.138337Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "W4, tris4 = patch_basis(4) # fine subdivision for a crisp still image\n", "\n", "fig = plt.figure(figsize=(10, 4.6))\n", "ax = fig.add_subplot(111, projection=\"3d\")\n", "ax.add_collection3d(Poly3DCollection(curved_surface(V2, W4, tris4),\n", " facecolor=utils.MESH_FACE, edgecolor=\"none\", alpha=0.18))\n", "ax.add_collection3d(Poly3DCollection(curved_surface(sol, W4, tris4),\n", " facecolor=\"#fc9272\", edgecolor=(0.3, 0, 0, 0.25),\n", " lw=0.25, alpha=0.97))\n", "setup_3d(ax, \"P2 cantilever: rest (ghost) vs gravity equilibrium (curved faces)\")\n", "fig.tight_layout()\n", "fig.savefig(\"media/20_p2_beam_static.png\", dpi=120, bbox_inches=\"tight\")\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "4e5f8ae4", "metadata": {}, "source": [ "## 4 · Watch it fall — dynamic backward-Euler\n", "\n", "Static equilibrium is the end state; the dynamics are just as easy. Each step is\n", "a backward-Euler solve that adds the inertial term\n", "$\\tfrac{1}{2h^2}\\lVert x - \\tilde x\\rVert_M^2$ (with $\\tilde x = x_n + h v_n$) to\n", "the same potential — the consistent P2 mass matrix `M` is what makes this a P2\n", "time step. `P2TetBeam.step` builds those inertia-augmented closures and\n", "Newton-solves them. We release the beam from rest and let it swing down and\n", "settle." ] }, { "cell_type": "code", "execution_count": 8, "id": "28543567", "metadata": { "execution": { "iopub.execute_input": "2026-06-09T05:31:03.139520Z", "iopub.status.busy": "2026-06-09T05:31:03.139464Z", "iopub.status.idle": "2026-06-09T05:31:05.571131Z", "shell.execute_reply": "2026-06-09T05:31:05.570847Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "24 animation frames; settled tip y = -4.019\n" ] } ], "source": [ "h, nsteps, stride = 0.02, 70, 3\n", "\n", "U = V2.reshape(-1, 1).copy()\n", "Vv = np.zeros_like(U)\n", "frames = [V2.copy()]\n", "for s in range(nsteps):\n", " U_next = beam.step(U, Vv, h=h)\n", " Vv = (U_next - U) / h\n", " U = U_next\n", " if (s + 1) % stride == 0:\n", " frames.append(U.reshape(n2, dim).copy())\n", "\n", "print(f\"{len(frames)} animation frames; settled tip y = {frames[-1][tip,1].mean():+.3f}\")" ] }, { "cell_type": "code", "execution_count": 9, "id": "a17882ee", "metadata": { "execution": { "iopub.execute_input": "2026-06-09T05:31:05.572173Z", "iopub.status.busy": "2026-06-09T05:31:05.572107Z", "iopub.status.idle": "2026-06-09T05:31:06.693046Z", "shell.execute_reply": "2026-06-09T05:31:06.692804Z" } }, "outputs": [ { "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Animate the curved P2 surface as the beam swings down (coarser subdivision for speed).\n", "W2, tris2 = patch_basis(2)\n", "\n", "fig = plt.figure(figsize=(8.5, 4.4))\n", "ax = fig.add_subplot(111, projection=\"3d\")\n", "ghost = Poly3DCollection(curved_surface(V2, W2, tris2),\n", " facecolor=utils.MESH_FACE, edgecolor=\"none\", alpha=0.12)\n", "beam_poly = Poly3DCollection(curved_surface(frames[0], W2, tris2),\n", " facecolor=\"#fc9272\", edgecolor=(0.3, 0, 0, 0.25), lw=0.2, alpha=0.97)\n", "ax.add_collection3d(ghost); ax.add_collection3d(beam_poly)\n", "setup_3d(ax, \"P2 beam released under gravity (backward Euler)\")\n", "\n", "def update(i):\n", " beam_poly.set_verts(curved_surface(frames[i], W2, tris2))\n", " return ()\n", "\n", "anim = FuncAnimation(fig, update, frames=len(frames), interval=1000/24, blit=False)\n", "fig.tight_layout()\n", "utils.show_video(fig, anim, \"media/20_p2_beam_fall.mp4\", fps=24)" ] }, { "cell_type": "markdown", "id": "65cbd57a", "metadata": {}, "source": [ "## 5 · P1 vs P2 — same mesh, more accurate bending\n", "\n", "Finally, solve the *identical* problem with ordinary **linear** tets on the same\n", "`(X, T)` and compare. Bending is where low-order elements struggle: linear tets\n", "**lock**, coming out far too stiff, so their tip barely moves. The P2 mesh — same\n", "elements, same material — bends much more realistically, and it does so with\n", "*genuinely curved* geometry that no amount of flat-triangle subdivision can\n", "reproduce." ] }, { "cell_type": "code", "execution_count": 10, "id": "6d33ed21", "metadata": { "execution": { "iopub.execute_input": "2026-06-09T05:31:06.694117Z", "iopub.status.busy": "2026-06-09T05:31:06.694061Z", "iopub.status.idle": "2026-06-09T05:31:06.728942Z", "shell.execute_reply": "2026-06-09T05:31:06.728734Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "P1 tip drop: 0.417 (135 dofs)\n", "P2 tip drop: 2.786 (627 dofs) -> P2 deflects 568% more (P1 locks)\n" ] } ], "source": [ "# --- P1 (linear) static equilibrium on the same mesh ---\n", "mu0, lam0 = simkit.ympr_to_lame(1.2e4, 0.45)\n", "J1 = simkit.deformation_jacobian(X, T)\n", "vol1 = simkit.volume(X, T)\n", "fg1 = simkit.gravity_force(X, T, a=GRAV, rho=RHO).reshape(-1, 1)\n", "pin1 = np.where(X[:, 0] <= X[:, 0].min() + 1e-9)[0]\n", "Q1, b1 = simkit.dirichlet_penalty(pin1, X[pin1], n1, gamma=1e8)\n", "mu1 = np.full((vol1.shape[0], 1), mu0)\n", "lam1 = np.full((vol1.shape[0], 1), lam0)\n", "\n", "def E1(x):\n", " xn, xc = x.reshape(-1, dim), x.reshape(-1, 1)\n", " E_elastic = energies.macklin_mueller_neo_hookean_energy_x(xn, J1, mu1, lam1, vol1)\n", " E_pin = 0.5 * (xc.T @ (Q1 @ xc))[0, 0] + (b1.T @ xc)[0, 0]\n", " E_gravity = -(fg1.T @ xc)[0, 0]\n", " return E_elastic + E_pin + E_gravity\n", "\n", "def G1(x):\n", " xn, xc = x.reshape(-1, dim), x.reshape(-1, 1)\n", " g_elastic = energies.macklin_mueller_neo_hookean_gradient_x(xn, J1, mu1, lam1, vol1)\n", " g_pin = Q1 @ xc + b1\n", " g_gravity = -fg1\n", " return g_elastic + g_pin + g_gravity\n", "\n", "def H1(x):\n", " xn = x.reshape(-1, dim)\n", " H_elastic = energies.macklin_mueller_neo_hookean_hessian_x(xn, J1, mu1, lam1, vol1, psd=True)\n", " H_pin = Q1\n", " return H_elastic + H_pin\n", "\n", "sol1 = newton_solver(X.reshape(-1, 1).copy(), E1, G1, H1,\n", " max_iter=300, tolerance=1e-9).reshape(n1, dim)\n", "\n", "tip1 = np.where(X[:, 0] >= X[:, 0].max() - 1e-9)[0]\n", "d1 = V2[tip,1].mean() - sol1[tip1,1].mean()\n", "d2 = V2[tip,1].mean() - sol[tip,1].mean()\n", "print(f\"P1 tip drop: {d1:.3f} ({n1*dim} dofs)\")\n", "print(f\"P2 tip drop: {d2:.3f} ({n2*dim} dofs) -> P2 deflects {100*(d2-d1)/d1:.0f}% more (P1 locks)\")" ] }, { "cell_type": "code", "execution_count": 11, "id": "c7ca60f2", "metadata": { "execution": { "iopub.execute_input": "2026-06-09T05:31:06.729906Z", "iopub.status.busy": "2026-06-09T05:31:06.729850Z", "iopub.status.idle": "2026-06-09T05:31:06.975141Z", "shell.execute_reply": "2026-06-09T05:31:06.974927Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# P1 drawn with its native flat boundary triangles; P2 with its true curved faces.\n", "def p1_boundary_polys(U1):\n", " count = {}\n", " for el in T:\n", " for f in _TET_FACES:\n", " key = tuple(sorted(int(el[c]) for c in f)); count[key] = count.get(key, 0) + 1\n", " polys = []\n", " for el in T:\n", " for f in _TET_FACES:\n", " key = tuple(sorted(int(el[c]) for c in f))\n", " if count[key] == 1:\n", " polys.append(U1[list(key)])\n", " return polys\n", "\n", "fig = plt.figure(figsize=(12, 4.6))\n", "axL = fig.add_subplot(121, projection=\"3d\")\n", "axL.add_collection3d(Poly3DCollection(p1_boundary_polys(X),\n", " facecolor=utils.MESH_FACE, edgecolor=\"none\", alpha=0.15))\n", "axL.add_collection3d(Poly3DCollection(p1_boundary_polys(sol1),\n", " facecolor=\"#9ecae1\", edgecolor=(0, 0, 0.3, 0.3), lw=0.3, alpha=0.97))\n", "setup_3d(axL, f\"P1 linear — flat faces, locks (tip drop {d1:.2f})\")\n", "\n", "axR = fig.add_subplot(122, projection=\"3d\")\n", "axR.add_collection3d(Poly3DCollection(curved_surface(V2, W4, tris4),\n", " facecolor=utils.MESH_FACE, edgecolor=\"none\", alpha=0.15))\n", "axR.add_collection3d(Poly3DCollection(curved_surface(sol, W4, tris4),\n", " facecolor=\"#fc9272\", edgecolor=(0.3, 0, 0, 0.25), lw=0.25, alpha=0.97))\n", "setup_3d(axR, f\"P2 quadratic — curved faces (tip drop {d2:.2f})\")\n", "\n", "fig.suptitle(\"Same tets, same material, same gravity: P2 bends; P1 locks\", fontsize=12)\n", "fig.tight_layout()\n", "fig.savefig(\"media/20_p1_vs_p2_beam.png\", dpi=120, bbox_inches=\"tight\")\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "1795edc1", "metadata": {}, "source": [ "## Takeaways\n", "\n", "- The entire P2 stack — `linear_to_quadratic_elements`, `gauss_legendre_quadrature`,\n", " `deformation_jacobian_p2`, `p2_massmatrix`, `p2_gravity_force` — works in **3D\n", " on tets** exactly as it does on 2D triangles; only the node count per element\n", " (10 vs 6) changes.\n", "- P2 evaluates **one deformation gradient per cubature point**, so the energy\n", " integral becomes a quadrature sum. The elastic energy, the Newton solver and\n", " the Dirichlet pin are the **unchanged P1 code**.\n", "- On a bending-dominated cantilever, linear tets **lock** (too stiff) while the\n", " quadratic mesh deflects realistically and renders with **true curved\n", " geometry** — the defining advantage of P2." ] } ], "metadata": { "kernelspec": { "display_name": "simkit", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.13.9" } }, "nbformat": 4, "nbformat_minor": 5 }