rename

Author: andrinr

examples/ansys/optim_bars.ipynb renamed to examples/ansys/pyvista_jaxfem.ipynb

@@ -854,7 +854,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 72,
+   "execution_count": null,
    "id": "0ddca0dd",
    "metadata": {},
    "outputs": [],
@@ -921,8 +921,6 @@
     "    dirichlet_values = jnp.array([0.0])\n",
     "    van_neumann_values = jnp.array([[0.0, 0.0, 0.1]])\n",
     "\n",
-    "    # Instead of passing all inputs and trying to stop_gradient on them,\n",
-    "    # we need to wrap the tesseract call to only allow gradients w.r.t. rho\n",
     "    c = apply_tesseract(\n",
     "        fem_tess,\n",
     "        {\n",

examples/ansys/optim_bars_pymapdl.ipynb renamed to examples/ansys/pyvista_pymapdl.ipynb

@@ -70,8 +70,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# The PyMAPDL Host (X.X.X.X IP Address) and Port (XXX) are pulled from the environment \n",
+    "# The PyMAPDL Host (X.X.X.X IP Address) and Port (XXX) are pulled from the environment\n",
     "import os\n",
+    "\n",
     "HOST = os.getenv(\"MAPDL_HOST\")\n",
     "if HOST is None:\n",
     "    raise ValueError(\n",
@@ -83,7 +84,7 @@
     "    raise ValueError(\n",
     "        \"Unable to read $MAPDL_PORT from the environment. \"\n",
     "        + \"Use 'export MAPDL_PORT=X' for the port of your MAPDL Instance.\"\n",
-    "    )\n"
+    "    )"
    ]
   },
   {
@@ -112,7 +113,7 @@
     "import matplotlib.pyplot as plt\n",
     "from tesseract_core import Tesseract\n",
     "from tesseract_core.runtime.experimental import TesseractReference\n",
-    "from utils import hex_to_pyvista, plot_grid, plot_grid_slice, plot_mesh, stop_grads_int\n",
+    "from utils import hex_to_pyvista, plot_grid, plot_grid_slice, plot_mesh\n",
     "\n",
     "from tesseract_jax import apply_tesseract"
    ]
@@ -466,12 +467,12 @@
     }
    ],
    "source": [
-    "import pyvista as pv\n",
     "import numpy as np\n",
+    "import pyvista as pv\n",
     "\n",
     "grid = pv.ImageData(\n",
     "    dimensions=np.array((Nx, Ny, Nz)) + 1,\n",
-    "    origin=(-Lx / 2, -Ly / 2, -Lz  / 2),\n",
+    "    origin=(-Lx / 2, -Ly / 2, -Lz / 2),\n",
     "    spacing=(Lx / Nx, Ly / Ny, Lz / Nz),  # These are the cell sizes along each axis\n",
     ")\n",
     "# repeated casts will eventually expose cell_connectivitiy\n",
@@ -541,7 +542,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "id": "9ea51a40",
    "metadata": {
     "editable": true,
@@ -572,6 +573,7 @@
     "    Args:\n",
     "        mesh: Dictionary containing 'points' array.\n",
     "        Lx: Size of the domain in x-direction.\n",
+    "        Ly: Size of the domain in y-direction.\n",
     "        Lz: Size of the domain in z-direction.\n",
     "\n",
     "    Returns:\n",
@@ -582,7 +584,7 @@
     "\n",
     "    dirichlet_mask = pts[:, 0] <= -Lx / 2\n",
     "    # von Neumann condition (select nodes at x=Lx with constraints on y and z)\n",
-    "    x_lim = Lx/2\n",
+    "    x_lim = Lx / 2\n",
     "    y_min = -0.1 * Ly\n",
     "    y_max = 0.1 * Ly\n",
     "    z_min = -0.1 * Lz\n",
@@ -599,7 +601,6 @@
     "        ),\n",
     "    )\n",
     "\n",
-    "\n",
     "    return dirichlet_mask, van_neumann_mask\n",
     "\n",
     "\n",
@@ -653,7 +654,7 @@
    "outputs": [],
    "source": [
     "# load the Finite Element Method Tesseract\n",
-    "fem_tess = Tesseract.from_tesseract_api(\"pymapdl_tess/tesseract_api.py\")\n"
+    "fem_tess = Tesseract.from_tesseract_api(\"pymapdl_tess/tesseract_api.py\")"
    ]
   },
   {
@@ -877,7 +878,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": null,
    "id": "6c1dae2f",
    "metadata": {},
    "outputs": [],
@@ -942,16 +943,16 @@
     "\n",
     "    van_neumann_mask = jax.lax.stop_gradient(van_neumann_mask)\n",
     "    dirichlet_mask = jax.lax.stop_gradient(dirichlet_mask)\n",
-    "    dirichlet_values = jnp.array([0.0])\n",
-    "    van_neumann_values = jnp.array([[0.0, 0.0, 0.1]])\n",
+    "    # dirichlet_values = jnp.array([0.0])\n",
+    "    # van_neumann_values = jnp.array([[0.0, 0.0, 0.1]])\n",
     "\n",
-    "    # Instead of passing all inputs and trying to stop_gradient on them,\n",
-    "    # we need to wrap the tesseract call to only allow gradients w.r.t. rho\n",
     "    # TODO unify this framework\n",
     "    dirichlet_idx = np.where(dirichlet_mask)[0]\n",
     "    von_neumann_idx = np.where(van_neumann_mask)[0]\n",
-    "    von_neumann_values = np.array([0, 0.0, 0.1]) + np.zeros((von_neumann_idx.shape[0], 3))\n",
-    "    \n",
+    "    von_neumann_values = np.array([0, 0.0, 0.1]) + np.zeros(\n",
+    "        (von_neumann_idx.shape[0], 3)\n",
+    "    )\n",
+    "\n",
     "    # TODO again note the transpose on rho!\n",
     "    rho_for_fea = rho_grid.T.reshape((hex_mesh[\"faces\"].shape[0], 1))\n",
     "\n",
@@ -973,14 +974,11 @@
     "        },\n",
     "    )[\"compliance\"]\n",
     "\n",
-    "    return c, {\n",
-    "        \"sdf\": sdf,\n",
-    "        \"rho_grid\": rho_grid\n",
-    "    }\n",
+    "    return c, {\"sdf\": sdf, \"rho_grid\": rho_grid}\n",
     "\n",
     "\n",
     "identity_and_store_grads.defvjp(identity_fwd, identity_bwd)\n",
-    "grad_fn = jax.value_and_grad(loss, has_aux=True)\n"
+    "grad_fn = jax.value_and_grad(loss, has_aux=True)"
    ]
   },
   {
@@ -1200,11 +1198,11 @@
     "for i in range(num_tests):\n",
     "    print(i)\n",
     "    params_up = params.at[i].add(FD_delta)\n",
-    "    (fupp, _), _ = grad_fn(params_up, iteration=i*2)\n",
+    "    (fupp, _), _ = grad_fn(params_up, iteration=i * 2)\n",
     "\n",
     "    if run_central_difference:\n",
     "        params_down = params.at[i].subtract(2.0 * FD_delta)\n",
-    "        (fdown, _), _ = grad_fn(params_down, iteration=i*2+1)\n",
+    "        (fdown, _), _ = grad_fn(params_down, iteration=i * 2 + 1)\n",
     "        FD_grads[i] = (fupp - fdown) / FD_delta / 2.0\n",
     "\n",
     "    else:\n",
@@ -1235,7 +1233,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": null,
    "id": "849a7559-90fc-4531-a0ed-54bf4a1c7817",
    "metadata": {
     "editable": true,
@@ -1248,16 +1246,17 @@
    "source": [
     "import mmapy\n",
     "import numpy as np\n",
-    "from tesseract_core.runtime import Array, Differentiable, Float32, Int32\n",
+    "from tesseract_core.runtime import Array, Float32, Int32\n",
     "\n",
     "\n",
     "class MMAOptimizer:\n",
     "    \"\"\"A wrapper for the MMA optimizer from mmapy.\n",
-    "    github.com/arjendeetman/GCMMA-MMA-Python\n",
+    "\n",
+    "    Source is github.com/arjendeetman/GCMMA-MMA-Python.\n",
     "    mmapy is a pretty barebones implementation of MMA in python. It should work for now.\n",
     "    Alternatives to consider:\n",
     "    - github.com/LLNL/pyMMAopt\n",
-    "    - pyopt.org/reference/optimizers.mma.html\n",
+    "    - pyopt.org/reference/optimizers.mma.html.\n",
     "\n",
     "    \"\"\"\n",
     "\n",
@@ -1317,7 +1316,9 @@
     "        if iteration == 1:\n",
     "            self.objective_scale_factor = np.abs(self.objective_scale / objective_value)\n",
     "        objective_value *= self.objective_scale_factor\n",
-    "        objective_gradient = np.asarray(objective_gradient) * self.objective_scale_factor\n",
+    "        objective_gradient = (\n",
+    "            np.asarray(objective_gradient) * self.objective_scale_factor\n",
+    "        )\n",
     "\n",
     "        # the bounds dont necessarily change every iteration\n",
     "        if x_min is None:\n",
@@ -1335,7 +1336,7 @@
     "        )\n",
     "\n",
     "        # calculate the next iteration of x\n",
-    "        xmma, ymma, zmma, lam, xsi, eta, mu, zet, s, low, upp = mmapy.mmasub(\n",
+    "        xmma, _ymma, _zmma, _lam, _xsi, _eta, _mu, _zet, _s, low, upp = mmapy.mmasub(\n",
     "            self.m,\n",
     "            self.n,\n",
     "            iteration,\n",
@@ -1378,7 +1379,9 @@
     "        constraint_gradients: Array[(None, None), Float32] = None,\n",
     "    ) -> None:\n",
     "        def check_shape(shape: tuple, expected_shape: tuple, name: str) -> None:\n",
-    "            if (len(shape)==1) or (shape[0] != expected_shape[0] or shape[1] != expected_shape[1]):\n",
+    "            if (len(shape) == 1) or (\n",
+    "                shape[0] != expected_shape[0] or shape[1] != expected_shape[1]\n",
+    "            ):\n",
     "                raise TypeError(\n",
     "                    f\"MMAError: The '{name}' was expected to have shape {expected_shape} but has shape {shape}.\"\n",
     "                )\n",
@@ -1393,12 +1396,12 @@
     "        if constraint_gradients is not None:\n",
     "            check_shape(\n",
     "                constraint_gradients.shape, (self.m, self.n), \"constraint gradients\"\n",
-    "            )\n"
+    "            )"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": null,
    "id": "39e30381",
    "metadata": {
     "editable": true,
@@ -1739,12 +1742,12 @@
     "delta_x = 0.0\n",
     "delta_y = 0.0\n",
     "delta_z = Lz / 3\n",
-    "eps = 1.e-3 # a small value to ease numerics\n",
+    "eps = 1.0e-3  # a small value to ease numerics\n",
     "bar_params = np.array(initial_params).reshape(n_chains, n_edges_per_chain + 1, 3)\n",
     "param_min = bar_params - eps\n",
     "param_max = bar_params + eps\n",
     "for bar_idx, bar in enumerate(bar_params):\n",
-    "    for coord_idx, xyz in enumerate(bar):\n",
+    "    for coord_idx, _xyz in enumerate(bar):\n",
     "        for i, delta in enumerate([delta_x, delta_y, delta_z]):\n",
     "            param_min[bar_idx][coord_idx][i] -= delta\n",
     "            param_max[bar_idx][coord_idx][i] += delta\n",
@@ -1762,24 +1765,31 @@
     "loss_hist = []\n",
     "params_hist = []\n",
     "aux_hist = []\n",
-    "optimizer = MMAOptimizer(initial_params[:,None], param_min, param_max, num_constraints, x_update_limit=x_update_limit)\n",
+    "optimizer = MMAOptimizer(\n",
+    "    initial_params[:, None],\n",
+    "    param_min,\n",
+    "    param_max,\n",
+    "    num_constraints,\n",
+    "    x_update_limit=x_update_limit,\n",
+    ")\n",
     "\n",
     "\n",
     "for i in range(n_steps):\n",
     "    (loss_value, aux), grads = grad_fn(params, iteration=i)\n",
     "    print(loss_value)\n",
     "    print(params)\n",
     "    print(grads)\n",
-    "    np_grads = np.array(grads[:,None])\n",
-    "    np_params = np.array(params[:,None])\n",
-    "    np_params = optimizer.calculate_next_x(loss_value, np_grads, g, dgdx, i+1, np_params)\n",
+    "    np_grads = np.array(grads[:, None])\n",
+    "    np_params = np.array(params[:, None])\n",
+    "    np_params = optimizer.calculate_next_x(\n",
+    "        loss_value, np_grads, g, dgdx, i + 1, np_params\n",
+    "    )\n",
     "    params = jnp.array(np_params.flatten())\n",
-    "        \n",
+    "\n",
     "    loss_hist.append(loss_value)\n",
     "    params_hist.append(params)\n",
     "    aux_hist.append(aux)\n",
     "\n",
-    "\n",
     "    print(f\"Iteration {i + 1}, Loss: {loss_value:.4f}\")"
    ]
   },
@@ -1845,7 +1855,9 @@
     "    mesh = hex_mesh\n",
     "    rho_dot = grad_storage[i + 2000][1][: len(mesh[\"faces\"])]\n",
     "    pv_mesh = hex_to_pyvista(\n",
-    "        mesh[\"points\"], mesh[\"faces\"], {\"rho\": aux_hist[i][\"rho_grid\"].T.flatten(), \"rho_dot\": rho_dot.T.flatten()}\n",
+    "        mesh[\"points\"],\n",
+    "        mesh[\"faces\"],\n",
+    "        {\"rho\": aux_hist[i][\"rho_grid\"].T.flatten(), \"rho_dot\": rho_dot.T.flatten()},\n",
     "    )\n",
     "    pv_mesh.save(f\"vtks/fem_shapeopt_mesh{i + 1}.vtk\")"
    ]
@@ -1882,9 +1894,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "tesseract-jax",
+   "display_name": "fem",
    "language": "python",
-   "name": "tesseract-jax"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -1896,7 +1908,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.13.5"
+   "version": "3.13.9"
   }
  },
  "nbformat": 4,