fluxfem 0.1.4__py3-none-any.whl → 0.2.1__py3-none-any.whl

fluxfem-0.2.1.dist-info/METADATA

@@ -0,0 +1,314 @@
+Metadata-Version: 2.1
+Name: fluxfem
+Version: 0.2.1
+Summary: FluxFEM: A weak-form-centric differentiable finite element framework in JAX
+License: Apache-2.0
+Author: Kohei Watanabe
+Author-email: koheitech001@gmail.com
+Requires-Python: >=3.12,<3.14
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: cpu
+Provides-Extra: cuda12
+Provides-Extra: petsc
+Requires-Dist: jax (>=0.8.2,<0.9.0) ; extra == "cpu" or extra == "cuda12"
+Requires-Dist: jax-cuda12-pjrt (==0.8.2) ; extra == "cuda12"
+Requires-Dist: jax-cuda12-plugin (==0.8.2) ; extra == "cuda12"
+Requires-Dist: jaxlib (>=0.8.2,<0.9.0) ; extra == "cpu" or extra == "cuda12"
+Requires-Dist: matplotlib (>=3.10.7,<4.0.0)
+Requires-Dist: meshio (>=5.3.5,<6.0.0)
+Requires-Dist: petsc4py (==3.23.6) ; extra == "petsc"
+Requires-Dist: pyproject (>=1!0.1.2,<1!0.2.0)
+Requires-Dist: pyproject-toml (>=0.1.0,<0.2.0)
+Requires-Dist: pyvista (>=0.46.4,<0.47.0)
+Description-Content-Type: text/markdown
+
+[![PyPI version](https://img.shields.io/pypi/v/fluxfem.svg?cacheSeconds=60)](https://pypi.org/project/fluxfem/)
+[![License: Apache-2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+[![Python Version](https://img.shields.io/pypi/pyversions/fluxfem.svg)](https://pypi.org/project/fluxfem/)
+![CI](https://github.com/kevin-tofu/fluxfem/actions/workflows/python-tests.yml/badge.svg)
+![CI](https://github.com/kevin-tofu/fluxfem/actions/workflows/sphinx.yml/badge.svg)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.18055465.svg)](https://doi.org/10.5281/zenodo.18055465)
+
+
+# FluxFEM
+A weak-form-centric differentiable finite element framework in JAX,
+where variational forms are treated as first-class, differentiable programs.
+
+## Examples and Features
+<table>
+  <tr>
+    <td align="center"><b>Example 1: Diffusion</b></td>
+    <td align="center"><b>Example 2: Neo Neohookean Hyper Elasticity</b></td>
+  </tr>
+  <tr>
+    <td align="center">
+      <img src="https://media.githubusercontent.com/media/kevin-tofu/fluxfem/main/assets/diffusion_mms_timeseries.gif" alt="Diffusion-mms" width="400">
+    </td>
+    <td align="center">
+      <img src="https://media.githubusercontent.com/media/kevin-tofu/fluxfem/main/assets/Neo-Hookean-deformedx20000.png" alt="Neo-Hookean" width="400">
+    </td>
+  </tr>
+</table>
+
+
+## Features
+- Built on JAX, enabling automatic differentiation with grad, jit, vmap, and related transformations.
+- Weak-form–centric API that keeps formulations close to code; weak forms are represented as expression trees and compiled into element kernels, enabling automatic differentiation of residuals, tangents, and objectives.
+- Two assembly approaches: tensor-based (scikit-fem–style) assembly and weak-form-based assembly.
+- Handles both linear and nonlinear analyses with AD in JAX.
+- Optional PETSc/PETSc-shell solvers via `petsc4py` for scalable linear solves (add `fluxfem[petsc]`).
+
+## Usage 
+
+This library provides two assembly approaches.
+
+- A tensor-based assembly, where trial and test functions are represented explicitly as element-level tensors and assembled accordingly (in the style of scikit-fem).
+- A weak-form-based assembly, where the variational form is written symbolically and compiled before assembly.
+
+The two approaches are functionally equivalent and share the same element-level execution model,
+but they differ in how you author the weak form. The example below mirrors the paper's diffusion
+case and makes the distinction explicit with `jnp`.
+
+
+## Assembly Flow
+All expressions are first compiled into an element-level evaluation plan,
+which operates on quadrature-point–major tensors.
+This plan is then executed independently for each element during assembly.
+
+As a result, both assembly approaches:
+- use the same quadrature-major (q, a, i) data layout,
+- perform element-local tensor contractions,
+- and are fully compatible with JAX transformations such as `jit`, `vmap`, and automatic differentiation.
+
+### kernel-based assembly (explicit JIT units)
+If you want to control JIT boundaries explicitly, build a JIT-compiled element kernel
+and pass it to `space.assemble`. The kernel must return the integrated element
+contribution (not the quadrature integrand). For untagged raw kernels, pass `kind=`.
+
+```Python
+import fluxfem as ff
+import jax
+import jax.numpy as jnp
+
+space = ff.make_hex_space(mesh, dim=1, intorder=2)
+
+# bilinear: kernel(ctx) -> (n_ldofs, n_ldofs)
+ker_K = ff.make_element_bilinear_kernel(ff.diffusion_form, 1.0, jit=True)
+K = space.assemble(ff.diffusion_form, 1.0, kernel=ker_K)
+
+# linear: kernel(ctx) -> (n_ldofs,)
+def linear_kernel(ctx):
+    integrand = ff.scalar_body_force_form(ctx, 2.0)
+    wJ = ctx.w * ctx.test.detJ
+    return (integrand * wJ[:, None]).sum(axis=0)
+
+ker_F = jax.jit(linear_kernel)
+F = space.assemble(ff.scalar_body_force_form, 2.0, kernel=ker_F)
+```
+
+### tensor-based vs weak-form-based (diffusion example)
+
+#### tensor-based assembly
+The tensor-based assembly provides an explicit, low-level formulation with element kernels written using jax.numpy.(`jnp`).
+```Python
+import fluxfem as ff
+import jax.numpy as jnp
+
+@ff.kernel(kind="bilinear", domain="volume")
+def diffusion_form(ctx: ff.FormContext, kappa):
+    # ctx.test.gradN / ctx.trial.gradN: (n_qp, n_nodes, dim)
+    # output tensor: (n_qp, n_nodes, n_nodes)
+    return kappa * jnp.einsum("qia,qja->qij", ctx.test.gradN, ctx.trial.gradN)
+
+space = ff.make_hex_space(mesh, dim=3, intorder=2)
+params = ff.Params(kappa=1.0)
+K_ts = space.assemble(diffusion_form, params=params.kappa)
+```
+
+#### weak-form-based assembly
+In the weak-form-based assembly, the variational formulation itself is the primary object.
+The expression below defines a symbolic computation graph, which is later compiled and executed at the element level.
+
+```Python
+import fluxfem as ff
+import fluxfem.helpers_wf as h_wf
+
+space = ff.make_hex_space(mesh, dim=3, intorder=2)
+params = ff.Params(kappa=1.0)
+
+# u, v are symbolic trial/test fields (weak-form DSL objects).
+# u.grad / v.grad are symbolic nodes (expression tree), not numeric arrays.
+# dOmega() is the integral measure; the whole expression is compiled before assembly.
+form_wf = ff.BilinearForm.volume(
+    lambda u, v, p: p.kappa * (v.grad @ u.grad) * h_wf.dOmega()
+).get_compiled()
+
+K_wf = space.assemble(form_wf, params=params)
+```
+
+### Linear Elasticity assembly (weak-form based assembly)
+
+```Python
+import fluxfem as ff
+import fluxfem.helpers_wf as h_wf
+
+space = ff.make_hex_space(mesh, dim=3, intorder=2)
+D = ff.isotropic_3d_D(1.0, 0.3)
+
+form_wf = ff.BilinearForm.volume(
+    lambda u, v, D: h_wf.ddot(v.sym_grad, D @ u.sym_grad) * h_wf.dOmega()
+).get_compiled()
+
+K = space.assemble(form_wf, params=D)
+```
+
+### Neo-Hookean residual assembly (weak-form DSL)
+Below is a Neo-Hookean hyperelasticity example written in weak form.
+The residual is expressed symbolically and compiled into element-level kernels executed per element.
+No manual derivation of tangent operators is required; consistent tangents (Jacobians) for Newton-type solvers are obtained automatically via JAX AD.
+
+```Python
+def neo_hookean_residual_wf(v, u, params):
+    mu = params["mu"]
+    lam = params["lam"]
+    F = h_wf.I(3) + h_wf.grad(u)  # deformation gradient
+    C = h_wf.matmul(h_wf.transpose(F), F)
+    C_inv = h_wf.inv(C)
+    J = h_wf.det(F)
+
+    S = mu * (h_wf.I(3) - C_inv) + lam * h_wf.log(J) * C_inv
+    dE = 0.5 * (h_wf.matmul(h_wf.grad(v), F) + h_wf.transpose(h_wf.matmul(h_wf.grad(v), F)))
+    return h_wf.ddot(S, dE) * h_wf.dOmega()
+
+res_form = ff.ResidualForm.volume(neo_hookean_residual_wf).get_compiled()
+```
+
+
+### autodiff + jit compile
+
+You can differentiate through the solve and JIT compile the hot path.
+The inverse diffusion tutorial shows this pattern:
+
+```Python
+def loss_theta(theta):
+    kappa = jnp.exp(theta)
+    u = solve_u_jit(kappa, traction_true)
+    diff = u[obs_idx_j] - u_obs[obs_idx_j]
+    return 0.5 * jnp.mean(diff * diff)
+
+solve_u_jit = jax.jit(solve_u)
+loss_theta_jit = jax.jit(loss_theta)
+grad_fn = jax.jit(jax.grad(loss_theta))
+```
+
+### FESpace vs FESpacePytree
+
+Use `FESpace` for standard workflows with a fixed mesh. When you need to carry
+the space through JAX transformations (e.g., shape optimization where mesh
+coordinates are part of the computation), use `FESpacePytree` via
+`make_*_space_pytree(...)`. This keeps the mesh/basis in the pytree so
+`jax.jit`/`jax.grad` can see geometry changes.
+
+### Mixed systems
+
+Mixed problems can be assembled from residual blocks and solved as a coupled system.
+
+```Python
+import fluxfem as ff
+import jax.numpy as jnp
+
+mixed = ff.MixedFESpace({"u": space_u, "p": space_p})
+residuals = ff.make_mixed_residuals(
+    u=res_u,  # (v, u, params) -> Expr
+    p=res_p,  # (q, u, params) -> Expr
+)
+problem = ff.MixedProblem(mixed, residuals, params=ff.Params(alpha=1.0))
+
+u0 = jnp.zeros(mixed.n_dofs)
+R = problem.assemble_residual(u0)
+J = problem.assemble_jacobian(u0, return_flux_matrix=True)
+```
+
+### Block assembly
+
+For constraints like contact problems (e.g., adding Lagrange multipliers), build
+a block matrix explicitly:
+
+```Python
+from fluxfem import solver as ff_solver
+
+# Example blocks from contact coupling
+K_uu = ...
+K_cc = ...
+K_uc = ...
+
+blocks = ff_solver.make_block_matrix(
+    diag=ff_solver.block_diag(u=K_uu, c=K_cc),
+    rel={("u", "c"): K_uc},
+    sizes={"u": K_uu.shape[0], "c": K_cc.shape[0]},
+    symmetric=True,
+    transpose_rule="T",
+)
+
+# Lazy container; assemble when you need the global matrix.
+K = blocks.assemble()
+```
+
+FluxFEM also provides contact utilities like `ContactSurfaceSpace` to build constraint contributions.
+
+
+## Documentation
+
+Full documentation, tutorials, and API reference are hosted at [this site](https://fluxfem.readthedocs.io/en/latest/).
+
+## Tutorials
+
+- `tutorials/linearelastic_tensile_bar.py` (linear elasticity, weak-form assembly)
+- `tutorials/neo_hookean_cantilever.py` (nonlinear hyperelasticity)
+- `tutorials/thermoelastic_bar_1d.py` / `tutorials/thermoelastic_bar_1d_mixed.py` (thermoelastic coupling)
+- `tutorials/petsc_shell_poisson_demo.py` (PETSc shell solver integration; see also `tutorials/petsc_shell_poisson_pmat_demo.py`)
+
+## Setup
+
+You can install **FluxFEM** either via **pip** or **Poetry**.
+
+#### Supported Python Versions
+
+FluxFEM supports **Python 3.11–3.13**:
+
+
+**Choose one of the following methods:**
+
+### Using pip
+```bash
+pip install fluxfem
+pip install "fluxfem[cuda12]" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
+```
+
+### Using poetry
+```bash
+poetry add fluxfem
+poetry add fluxfem[cuda12]
+```
+
+## PETSc Integration
+
+Optional PETSc-based solvers are available via `petsc4py`. Enable with the extra:
+
+```bash
+poetry add fluxfem --extras "petsc"
+```
+
+Note: newer `petsc4py` expects PETSc builds that include the `PetscRegressor`
+API. If your PETSc build does not have it, `petsc4py` will fail to compile. In
+that case, rebuild PETSc with regressor support or pin `petsc4py` to a version
+compatible with your PETSc build.
+
+GPU note: this repo currently tests CUDA via the `cuda12` extra only. Other CUDA
+versions are not covered by CI and may require manual JAX installation.
+
+## Acknowledgements
+I acknowledge the open-source software, libraries, and communities that made this work possible.
+

fluxfem-0.2.1.dist-info/RECORD

@@ -0,0 +1,59 @@
+fluxfem/__init__.py,sha256=hHJEJ4P89uDvziScw-hzs82MIt-K5OBGFgF5ojoI9B4,7846
+fluxfem/core/__init__.py,sha256=av60HQ0K8oaLko0vKc_GNsNs35TayR8BPGp463GKFN4,10898
+fluxfem/core/assembly.py,sha256=CTgI5KZhXx5PnvPHMZQRKg0GdhwqNm4EvPggF_SHwAY,46971
+fluxfem/core/basis.py,sha256=Awru1LcXgukQsP5scWn6i6PsqszvIFa_k7UM-ShbThQ,32435
+fluxfem/core/context_types.py,sha256=67Q_qPG8DZ6B6pYN-RzibhNsHBZfhQtkX0kfnfW46Qc,1405
+fluxfem/core/data.py,sha256=_byAZTasIGGwNRU3gqw_ZZR1HMVLJpk9gix2AI3AJWk,1818
+fluxfem/core/dtypes.py,sha256=FnJ98C3yIibaatN-wmLO3ksI6XabA7G3rI_SOxPmko8,251
+fluxfem/core/forms.py,sha256=uC5WxG3h3G7I9FxNRVvA8JLVpJP-QjNZtj8fjxavqVE,7697
+fluxfem/core/interp.py,sha256=v9HzkYgQnEqf6GnB9tXqfrNk0N7YsmPcZBfNGNUU3b8,2004
+fluxfem/core/mixed_assembly.py,sha256=4lL15AsKV4KA-D_mhwc_zXyIhff1fwMkYj4iPWDbDwk,8513
+fluxfem/core/mixed_space.py,sha256=VbQyz1iwrk5-UfvxNmlVHS1mPy5WnCTSzBQXNUbMA68,14203
+fluxfem/core/mixed_weakform.py,sha256=7WmleuB9-o2PFr4Mbwh7Dk19PZ2VNudWoFXlugACd80,2878
+fluxfem/core/solver.py,sha256=OOKiEsW9j4BPCtwgIYyaUHh0Bw5dAd975aGl2izOYqQ,3772
+fluxfem/core/space.py,sha256=DQ2hvqz226lnrKlIHc617LGiwdup_6pgfCx53DgdjWA,23606
+fluxfem/core/weakform.py,sha256=54ntcT-ysR3sVwRS2bgVeP6AslMgIgxVkwi3SrMAKiE,71229
+fluxfem/helpers_ts.py,sha256=T3HCqXniF116lvznq0b7CDUok5_yZZc8l9XtlE81yvg,221
+fluxfem/helpers_wf.py,sha256=pA8bprvbdXZL_qourm07xaJAsGyNnAP8wXmJf8fOj-k,2158
+fluxfem/mesh/__init__.py,sha256=u2CzTjFxj_CRbi18FezIDh73k_lan_3wGBifTkdJH4w,2418
+fluxfem/mesh/base.py,sha256=CAZwHp4lQzVKQe2TiWKG2-ktXWuC7AAURxIPR9pI7rU,22750
+fluxfem/mesh/contact.py,sha256=8Uy2UGaUB7z_3OuRJ8Jdn7DET1Bq-X0GGEV9bn0LYtA,30059
+fluxfem/mesh/dtypes.py,sha256=FnJ98C3yIibaatN-wmLO3ksI6XabA7G3rI_SOxPmko8,251
+fluxfem/mesh/hex.py,sha256=VhH0THJMHPhNtwAvqBjIaeNMzBUd8SWzkih2FcR1NWc,12455
+fluxfem/mesh/io.py,sha256=j6EM7AQ9xiDGAc8I_q9t5vkLIGuuezF3uc1kTvCXmb0,3119
+fluxfem/mesh/mortar.py,sha256=nfy8TyncDmyAgx71E2XNEu4Iv5joLU9Wu8vWVdV3WeM,151395
+fluxfem/mesh/predicate.py,sha256=7O9kcKYg_OPtwhqYVdA-j9LQYtcG2Nl781UupKm6U-A,1505
+fluxfem/mesh/supermesh.py,sha256=bKHERAB4vMkeiuT6wFAoKPKbv-O-8C2crrvJkaRW1ak,10463
+fluxfem/mesh/surface.py,sha256=FJgIvLS8WJElpA7dL9_D2wMh7NZgE0gtfLCBw3g8NJY,11179
+fluxfem/mesh/tet.py,sha256=8ijEdjxOrO4mghIApKqIkOwgcIJKNSIL65uGuYHF1-s,10191
+fluxfem/physics/__init__.py,sha256=gUrVF1FSiSVZezqRGvKSTcZDH79Ty3opiJ9-H1gycqY,1426
+fluxfem/physics/diffusion.py,sha256=T3jIGqnuaoSMB8q9x6qNwY23V55-lQGb6ome_WQnOS8,537
+fluxfem/physics/elasticity/__init__.py,sha256=4pAqAstT9T20pY5q417c9FQAarq_T8g2hpqDtrUDkcw,1061
+fluxfem/physics/elasticity/hyperelastic.py,sha256=S61yQYzu5Njowx9QF2qsMOr8pY7Mz5dIhsW-GPev-90,3964
+fluxfem/physics/elasticity/linear.py,sha256=mUayoQ4buWCkqyWC7NfanNjYtoNFiVyzaQjHdfzEIjs,2413
+fluxfem/physics/elasticity/materials.py,sha256=f2y7_nY3KMSmD2-G4znondAOvh-XDvJD_-zcE2EZcKw,977
+fluxfem/physics/elasticity/stress.py,sha256=1JY4ZKZglcst3Tot7uOvAsaGydJUuwRFFvaft3Fghg8,1181
+fluxfem/physics/operators.py,sha256=cuMNoUFSnBtyjCbR-VANrJapvwWVObVQZDCm0ot5L4Q,3289
+fluxfem/physics/postprocess.py,sha256=A6VQq_XBKd75rZbP_mqLR--zUd3Dw_XQfjYX4PID1_M,4860
+fluxfem/solver/__init__.py,sha256=KIQ0RTyjer-flCewrTGu80IX6d1OKnO1HwIn2JmQVL0,2492
+fluxfem/solver/bc.py,sha256=IJa9WmAkeLu73fmxppEZRXfB-1o_B-9tQ8uKXZHdxFU,16649
+fluxfem/solver/block_matrix.py,sha256=9egC5bZcgx3sDUJpAt4jEPy_GgQ-hArvPWSFLnFos18,10825
+fluxfem/solver/block_system.py,sha256=Fy1AuALQZg7uxpseGVDrzRGBf9EYAjOi0Sj-3rDsAH0,18620
+fluxfem/solver/cg.py,sha256=scydBIRdHXG9QOtRQfQG9pL4ITxjFaTIkdYPHjQEZgM,11826
+fluxfem/solver/dirichlet.py,sha256=0ERvZd1XBySQAWV9n_QY2VZN8xOdaUNOgL-vn2DwUnI,15560
+fluxfem/solver/history.py,sha256=y-37QPJqPFKFBRdWUrng6OwYyHZRRcPaRtF8yuqpnDc,1034
+fluxfem/solver/newton.py,sha256=Q8y2e0M05fgKVx8VCnths0XtWkLSVEbea2dU2hdLJvQ,24184
+fluxfem/solver/petsc.py,sha256=Kk4vxQrfxD5D_wc3z8dFHg-77KH_FaMY2JB4oCM5wLM,15221
+fluxfem/solver/preconditioner.py,sha256=ijnhSA54rUeN1KCpW_SJFlANsR2dccPnC5-n6VEg0MU,3781
+fluxfem/solver/result.py,sha256=DLLyaHVJ9NYotDqFD0IHlhxg9Hbs726bepqCG_59t94,3256
+fluxfem/solver/solve_runner.py,sha256=uBwZpwIeyYXhXFE6Wr1qlywl4z9ExMCoG4Sagsn_D8U,31413
+fluxfem/solver/solver.py,sha256=pkxYOncGkK1t1L9GcZwW4BwDsc31StUFplIK3QS_cYo,6157
+fluxfem/solver/sparse.py,sha256=8Ji1xkWPqLfy2xZv1ejhJhxILeH8G1peh5Lf_X16oxw,12757
+fluxfem/tools/__init__.py,sha256=S7flze8kfHABc0fdhGgdELzKO8aeBCrDbwRUE3aTGpA,95
+fluxfem/tools/jit.py,sha256=x8MS-RWJfafT9A5bhPLa80quR0dYREvikfmWqNHbxBE,1445
+fluxfem/tools/timer.py,sha256=pCL2T4Vi2M00wi5eVey75QGglZVRiZW3i31rL2ll25U,23145
+fluxfem/tools/visualizer.py,sha256=x7i2_ABpXEP4ixPSiqStNM8lR0HZbaAuViCSF7W-p-U,3854
+fluxfem-0.2.1.dist-info/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+fluxfem-0.2.1.dist-info/METADATA,sha256=Mi6PAmMFKYpcv9c0NOrcXx6V-DvMYEF45SF0RX_RlNM,11366
+fluxfem-0.2.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+fluxfem-0.2.1.dist-info/RECORD,,

fluxfem-0.1.4.dist-info/METADATA

@@ -1,127 +0,0 @@
-Metadata-Version: 2.1
-Name: fluxfem
-Version: 0.1.4
-Summary: FluxFEM: A weak-form-centric differentiable finite element framework in JAX
-License: Apache-2.0
-Author: Kohei Watanabe
-Author-email: koheitech001@gmail.com
-Requires-Python: >=3.11,<3.14
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: jax (>=0.8.2,<0.9.0)
-Requires-Dist: jaxlib (>=0.8.2,<0.9.0)
-Requires-Dist: matplotlib (>=3.10.7,<4.0.0)
-Requires-Dist: meshio (>=5.3.5,<6.0.0)
-Requires-Dist: pyvista (>=0.46.4,<0.47.0)
-Description-Content-Type: text/markdown
-
-[![PyPI version](https://img.shields.io/pypi/v/fluxfem.svg?cacheSeconds=60)](https://pypi.org/project/fluxfem/)
-[![License: Apache-2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
-[![Python Version](https://img.shields.io/pypi/pyversions/fluxfem.svg)](https://pypi.org/project/fluxfem/)
-![CI](https://github.com/kevin-tofu/fluxfem/actions/workflows/python-tests.yml/badge.svg)
-![CI](https://github.com/kevin-tofu/fluxfem/actions/workflows/sphinx.yml/badge.svg)
-[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.18055465.svg)](https://doi.org/10.5281/zenodo.18055465)
-
-
-# FluxFEM
- A weak-form-centric differentiable finite element framework in JAX
-
-## Examples and Features
-<table>
-  <tr>
-    <td align="center"><b>Example 1: Diffusion</b></td>
-    <td align="center"><b>Example 2: Neo Neohookean Hyper Elasticity</b></td>
-  </tr>
-  <tr>
-    <td align="center">
-      <img src="https://media.githubusercontent.com/media/kevin-tofu/fluxfem/main/assets/diffusion_mms_timeseries.gif" alt="Diffusion-mms" width="400">
-    </td>
-    <td align="center">
-      <img src="https://media.githubusercontent.com/media/kevin-tofu/fluxfem/main/assets/Neo-Hookean-deformedx20000.png" alt="Neo-Hookean" width="400">
-    </td>
-  </tr>
-</table>
-
-
-## Features
-- Built on JAX, enabling automatic differentiation with grad, jit, vmap, and related transformations.
-- Weak-form–centric API that keeps formulations close to code; weak forms are represented as expression trees and compiled to element kernels.
-- Two assembly approaches: weak-form-based assembly and a tensor-based (scikit-fem–style) assembly.
-- Handles both linear and nonlinear analyses with AD in JAX.
-
-## Usage 
-
-This library provides two assembly approaches.
-
-- A weak-form-based assembly, where the variational form is written and assembled directly.  
-- A tensor-based assembly, where trial and test functions are represented explicitly as tensors and assembled accordingly (in the style of scikit-fem).  
-The first approach offers simplicity and convenience, as mathematical expressions can be written almost directly in code.
-However, for more complex operations, the second approach can be easier to implement in practice.
-This is because the weak-form-based assembly is ultimately transformed into the tensor-based representation internally during computation.
-
-## Weak Form Compile Flow
-Weak-form expressions are compiled into an evaluation plan and then executed per element.
-
-### weak-form-based assembly
-```Python
-import fluxfem as ff
-import fluxfem.helpers_wf as h_wf
-
-space = ff.make_hex_space(mesh, dim=3, intorder=2)
-D = ff.isotropic_3d_D(1.0, 0.3)
-bilinear_form = ff.BilinearForm.volume(
-    lambda u, v, D: h_wf.ddot(v.sym_grad, h_wf.matmul_std(D, u.sym_grad)) * h_wf.dOmega()
-)
-K_wf = space.assemble_bilinear_form(
-    bilinear_form.get_compiled(),
-    params=D,
-)
-```
-
-### tensor-based assembly (scikit-fem-style)
-
-```Python
-import fluxfem as ff
-import numpy as np
-import fluxfem.helpers_ts as h_ts
-
-def linear_elasticity_form(ctx: ff.FormContext, D: np.ndarray) -> ff.jnp.ndarray:
-        Bu = h_ts.sym_grad(ctx.trial)
-        Bv = h_ts.sym_grad(ctx.test)
-        return h_ts.ddot(Bv, D, Bu)
-
-
-space = ff.make_hex_space(mesh, dim=3, intorder=2)
-D = ff.isotropic_3d_D(1.0, 0.3)
-K = space.assemble_bilinear_form(linear_elasticity_form, params=D)
-```
-
-## Documentation
-
-
-## SetUp
-
-You can install **FluxFEM** either via **pip** or **Poetry**.
-
-#### Supported Python Versions
-
-FluxFEM supports **Python 3.11–3.13**:
-
-
-**Choose one of the following methods:**
-
-### Using pip
-```bash
-pip install fluxfem
-```
-
-### Using poetry
-```bash
-poetry add fluxfem
-```
-
-## Acknowledgements
- I acknoldege everythings that made this work possible.
-

fluxfem-0.1.4.dist-info/RECORD

@@ -1,48 +0,0 @@
-fluxfem/__init__.py,sha256=VXd7BM-dOt74bF_W8NumTMlE7lCrz3jTwoCFNZnpDW0,6122
-fluxfem/core/__init__.py,sha256=LzHXumR__i656SEmZuGZa09TqTDltTzMIyBBbN1GOKs,8156
-fluxfem/core/assembly.py,sha256=yhc14y4XWvmBpiLun2eH9k1mjAsNmpTbHPJS2VJFO3M,25370
-fluxfem/core/basis.py,sha256=ZxTQUAEC2UBuvxGhiSqAPjVnUwP_nIptY_b9Wn2etak,32113
-fluxfem/core/context_types.py,sha256=QGv1oc_9Crn3vztyPy_uUN0TpmDkgH5HPrhYzZ_kuys,663
-fluxfem/core/data.py,sha256=_byAZTasIGGwNRU3gqw_ZZR1HMVLJpk9gix2AI3AJWk,1818
-fluxfem/core/dtypes.py,sha256=WQ_wfJW_R8Mty76mS7h-R2xgCokraEWjsUvjeKYmVJU,118
-fluxfem/core/forms.py,sha256=qDaN750oiH44aSReVbOISBR9IsWSEnsv1gxHB7We_D0,7374
-fluxfem/core/interp.py,sha256=v9HzkYgQnEqf6GnB9tXqfrNk0N7YsmPcZBfNGNUU3b8,2004
-fluxfem/core/solver.py,sha256=nNpb90ddZq8Ek6XPerlKzV4YWtC5ZgEcsRv4KeoFIug,3770
-fluxfem/core/space.py,sha256=jj4koa6_7lBBtXWGrF1CehOBKWg--uUW_7q8pB2EFCk,13902
-fluxfem/core/weakform.py,sha256=ux4gZukZZBMO6vUegjOn_oaQ2l-nwQMO9L2D98LFh6E,41249
-fluxfem/helpers_ts.py,sha256=T3HCqXniF116lvznq0b7CDUok5_yZZc8l9XtlE81yvg,221
-fluxfem/helpers_wf.py,sha256=InXhYr0WqyibiNWRJllAPf23sluTyaGSJApbv-Yn8b0,632
-fluxfem/mesh/__init__.py,sha256=3ECN0qsVzOnEGTHfrWJ2PV7RJUbSboow1ewfpknI4F4,927
-fluxfem/mesh/base.py,sha256=cxfv-m-0qQq3UL4aM0YUJEiAyVrKmtSszwe8rE7PQyQ,10448
-fluxfem/mesh/hex.py,sha256=diFF6AngLpA9OllbaPAT00P_0YR4vMVgpc04_IqOLv8,12420
-fluxfem/mesh/io.py,sha256=3Nx5WLFP9gG_Ruks4F7jSTVGnc_i5qcxkLBQkQhsmhk,2984
-fluxfem/mesh/predicate.py,sha256=7O9kcKYg_OPtwhqYVdA-j9LQYtcG2Nl781UupKm6U-A,1505
-fluxfem/mesh/surface.py,sha256=mmtePb1ptd9BSbD79oyPnQwiKadpyVO41xSHDr2XylE,9176
-fluxfem/mesh/tet.py,sha256=Yjmx_2UsCxO_rl0Jr60au5zccBVWLJvAaGEzhLCi_LA,9768
-fluxfem/physics/__init__.py,sha256=gUrVF1FSiSVZezqRGvKSTcZDH79Ty3opiJ9-H1gycqY,1426
-fluxfem/physics/diffusion.py,sha256=gBRKMuhWGnp7wSlbqYKn2WDKvBrVdtCQKV8-qBabmw4,462
-fluxfem/physics/elasticity/__init__.py,sha256=4pAqAstT9T20pY5q417c9FQAarq_T8g2hpqDtrUDkcw,1061
-fluxfem/physics/elasticity/hyperelastic.py,sha256=uDZIgSeVJ1JgIf5aEFzFyng6qcDHP-seoHNH_aUA4Zg,3364
-fluxfem/physics/elasticity/linear.py,sha256=upiX8Qq5v8J0Y-Lhq8OsIFnwQ_AnJc9nJj0g0vWeNcg,2074
-fluxfem/physics/elasticity/materials.py,sha256=f2y7_nY3KMSmD2-G4znondAOvh-XDvJD_-zcE2EZcKw,977
-fluxfem/physics/elasticity/stress.py,sha256=i3TypnLB-Hhd3UsV2tftOCjF1-KNNpnVEy8rYqT2wIM,1135
-fluxfem/physics/operators.py,sha256=LgEvtcDvhskd7BokVsX_wtzceoI2zrLYyB5HWsUBFg4,3009
-fluxfem/physics/postprocess.py,sha256=7NKcSJO_Himw1WTJgM4YWxf1KkjGuBwojxY_0Vwy9Ow,4418
-fluxfem/solver/__init__.py,sha256=WkQRDWVIxqXuRGrbizl0KVkr7a_yY0jWlsTDI66gaiE,1133
-fluxfem/solver/bc.py,sha256=EYrvQbTMQG2WxHbJYJD2nefxwrpiGS7p8ant6R3APgU,15555
-fluxfem/solver/cg.py,sha256=3fLtK3oUpR7lQtRPPtE64-PHUjeIp3pDuMZZqVdCXfk,8974
-fluxfem/solver/dirichlet.py,sha256=MCXgpJ9lAF7NrK2NeuCxVWgOVfCiPeswIYhbadkwh-Q,3982
-fluxfem/solver/history.py,sha256=HhKSmo2B1GaBYEsrifxQxeaeRMiaqm5f6g6DNz5Qb0U,764
-fluxfem/solver/newton.py,sha256=aeSQ1ET9dc-xU6HJWn6KNrEg0FA49nSXsoaYuW5BTvM,16251
-fluxfem/solver/result.py,sha256=LDtazqofyBmA0pd3zE5eadgKwW053HRcOwJ5k7ClbsA,2357
-fluxfem/solver/solve_runner.py,sha256=MCwmHUKnJCX_mFDPFKNp-_yMbviWln5s56ENWZvOj4c,20974
-fluxfem/solver/solver.py,sha256=kqXz2qW50gyyFQagUePgNiFcgsLVA94H99_8sHZWiyo,5162
-fluxfem/solver/sparse.py,sha256=wyT_XBIMYD2Nrw_ko8FkaPzLWnLm25M41wF2Z2YAbZk,7550
-fluxfem/tools/__init__.py,sha256=S7flze8kfHABc0fdhGgdELzKO8aeBCrDbwRUE3aTGpA,95
-fluxfem/tools/jit.py,sha256=WVThoNs2XD8ZVCeyLjBgbFaZXHot5RK_RNzvvAjSaew,1110
-fluxfem/tools/timer.py,sha256=fvMrKqjOT2S_DoGlTYC5L5TtBnoLS4zyiAZtJVJGt0o,22848
-fluxfem/tools/visualizer.py,sha256=aDqSgtX9xOu120-zCzJfwlCOUmxjL_kJ6kAvj27-H14,3733
-fluxfem-0.1.4.dist-info/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-fluxfem-0.1.4.dist-info/METADATA,sha256=hn8uJc3N47pozgegKrVvXCbdFhTQX6sbuLLdpnhQT7U,4463
-fluxfem-0.1.4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-fluxfem-0.1.4.dist-info/RECORD,,