Solver Reference

Each solver card shows its numerical scheme, AD strategy, and Tesseract schema; per-(solver, problem) exclusions and explained anomalies come from the problem configs and are listed alongside. Click Inputs / Outputs on any solver to expand its field tables. The ∂ column marks fields that support automatic differentiation (VJP/JVP).

Legend. Each card shows a Numerics: line — the discretization followed by the numerical method — and three badge categories: language (backend / runtime), AD: strategy (autodiff / adjoint / hybrid / forward-only), and GPU on GPU-capable solvers.

Navier–Stokes (Grid)

Exponax

Numerics: Spectral, ETDRK

jax AD: autodiff GPU

Upstream docs: https://fkoehler.site/exponax/

Path: mosaic/tesseracts/navier-stokes-grid/exponax

Image: exponax_navier_stokes_grid

Exponential time-differencing Runge–Kutta (ETDRK) spectral integrator for 3D Navier–Stokes, enforcing incompressibility to machine precision by construction. Gradients via JAX source-transformation AD

Inputs / Outputs

Inputs

Field	Type	∂	Description
v0	GridVectorField	✓	Initial velocity field, shape (N, N, 1, 2). Default: 64×64 divergence-free random vortex field (seed=42).
viscosity	Array[(1,), Float32]	✓	Kinematic viscosity ν.
dt	Array[(1,), Float32]	✓	Timestep size.
steps	int		Number of timesteps. Total simulated time = steps × dt.
domain_extent	float		Side length of the square periodic domain.
boundary_conditions	GridBC		Per-face boundary conditions. Default: all periodic.
obstacle	GridObstacle | None		Optional solid obstacle embedded in the domain (no-slip walls).
inflow_profile	Array[(None,), Float32] | None	✓	1-D inlet velocity profile u_x(y), shape (N,). When provided, overrides the x_lo Dirichlet BC with a spatially-varying inlet. u_y is set to zero. Used for inflow-profile optimisation (e.g. cylinder drag minimisation).
drag	Array[(1,), Float32]	✓	Linear drag coefficient
order	int		ETDRK time integration order (0-4)
kolmogorov_forcing	bool		Enable Kolmogorov sinusoidal body forcing for sustained turbulence
injection_mode	int		Wavenumber at which energy is injected (Kolmogorov forcing)
injection_scale	Array[(1,), Float32]	✓	Amplitude of the Kolmogorov body forcing

Outputs

Field	Type	∂	Description
result	GridVectorField	✓	Final velocity field, same shape as v0.
drag	Array[(1,), Float32] | None		x-direction drag force on the embedded obstacle, shape (1,). Computed as the surface integral of pressure and viscous stress: F_x = ∮_S (p n_x − μ (∂u/∂n)_x) dS. None when no obstacle is present.

INS.jl

Numerics: Finite Volume, Projection, RK4

julia AD: autodiff

Upstream docs: https://agdestein.github.io/IncompressibleNavierStokes.jl/dev/

Path: mosaic/tesseracts/navier-stokes-grid/ins-jl

Image: ins_navier_stokes_grid

Julia staggered finite-volume solver with spectral pressure projection and RK4 time integration; run on CPU in this benchmark (the library itself also supports CUDA via KernelAbstractions.jl). Differentiates through the time loop via Zygote.jl reverse-mode AD.

Inputs / Outputs

Inputs

Field	Type	∂	Description
v0	GridVectorField	✓	Initial velocity field, shape (N, N, 1, 2). Default: 64×64 divergence-free random vortex field (seed=42).
viscosity	Array[(1,), Float32]	✓	Kinematic viscosity ν.
dt	Array[(1,), Float32]	✓	Timestep size.
steps	int		Number of timesteps. Total simulated time = steps × dt.
domain_extent	float		Side length of the square periodic domain.
boundary_conditions	GridBC		Per-face boundary conditions. Default: all periodic.
obstacle	GridObstacle | None		Optional solid obstacle embedded in the domain (no-slip walls).
inflow_profile	Array[(None,), Float32] | None	✓	1-D inlet velocity profile u_x(y), shape (N,). When provided, overrides the x_lo Dirichlet BC with a spatially-varying inlet. u_y is set to zero. Used for inflow-profile optimisation (e.g. cylinder drag minimisation).

Outputs

Field	Type	∂	Description
result	GridVectorField	✓	Final velocity field, same shape as v0.
drag	Array[(1,), Float32] | None		x-direction drag force on the embedded obstacle, shape (1,). Computed as the surface integral of pressure and viscous stress: F_x = ∮_S (p n_x − μ (∂u/∂n)_x) dS. None when no obstacle is present.

jax-cfd

Numerics: Finite Difference, Projection, semi-implicit

jax AD: autodiff GPU

Upstream docs: https://github.com/google/jax-cfd

Path: mosaic/tesseracts/navier-stokes-grid/jax-cfd

Image: jax_cfd_navier_stokes_grid

JAX-native incompressible Navier–Stokes solver on a staggered MAC grid with finite-difference advection and spectral FFT pressure projection. Gradients via JAX source-transformation AD through the time loop.

Inputs / Outputs

Inputs

Field	Type	∂	Description
v0	GridVectorField	✓	Initial velocity field, shape (N, N, 1, 2). Default: 64×64 divergence-free random vortex field (seed=42).
viscosity	Array[(1,), Float32]	✓	Kinematic viscosity ν.
dt	Array[(1,), Float32]	✓	Timestep size.
steps	int		Number of timesteps. Total simulated time = steps × dt.
domain_extent	float		Side length of the square periodic domain.
boundary_conditions	GridBC		Per-face boundary conditions. Default: all periodic.
obstacle	GridObstacle | None		Optional solid obstacle embedded in the domain (no-slip walls).
inflow_profile	Array[(None,), Float32] | None		1-D inlet velocity profile u_x(y), shape (N,). When provided, overrides the x_lo Dirichlet BC with a spatially-varying inlet. u_y is set to zero. Used for inflow-profile optimisation (e.g. cylinder drag minimisation).
density	Array[(1,), Float32]	✓	Density of the fluid
inner_steps	int		Solver sub-iterations per timestep (higher = more accurate pressure solve)

Outputs

Field	Type	∂	Description
result	GridVectorField	✓	Final velocity field, same shape as v0.
drag	Array[(1,), Float32] | None		x-direction drag force on the embedded obstacle, shape (1,). Computed as the surface integral of pressure and viscous stress: F_x = ∮_S (p n_x − μ (∂u/∂n)_x) dS. None when no obstacle is present.

OpenFOAM

Numerics: Finite Volume, PISO/PIMPLE, Euler

cpp AD: forward-only

Upstream docs: https://www.openfoam.com/documentation/overview

Path: mosaic/tesseracts/navier-stokes-grid/openfoam

Image: openfoam_navier_stokes_grid

OpenFOAM icoFoam PISO solver run as a forward-only reference baseline (C++ subprocess). No reverse-mode AD; used to anchor cross-solver comparisons.

Inputs / Outputs

Inputs

Field	Type	∂	Description
v0	GridVectorField		Initial velocity field, shape (N, N, 1, 2). Default: 64×64 divergence-free random vortex field (seed=42).
viscosity	Array[(1,), Float32]		Kinematic viscosity ν.
dt	Array[(1,), Float32]		Timestep size.
steps	int		Number of timesteps. Total simulated time = steps × dt.
domain_extent	float		Side length of the square periodic domain.
boundary_conditions	GridBC		Per-face boundary conditions. Default: all periodic.
obstacle	GridObstacle | None		Optional solid obstacle embedded in the domain (no-slip walls).
inflow_profile	Array[(None,), Float32] | None		1-D inlet velocity profile u_x(y), shape (N,). When provided, overrides the x_lo Dirichlet BC with a spatially-varying inlet. u_y is set to zero. Used for inflow-profile optimisation (e.g. cylinder drag minimisation).

Outputs

Field	Type	∂	Description
result	GridVectorField		Final velocity field, same shape as v0.
drag	Array[(1,), Float32] | None		x-direction drag force on the embedded obstacle, shape (1,). Computed as the surface integral of pressure and viscous stress: F_x = ∮_S (p n_x − μ (∂u/∂n)_x) dS. None when no obstacle is present.

PhiFlow

Numerics: Finite Difference, Semi-Lagrangian, Euler

jax AD: hybrid GPU

Upstream docs: https://tum-pbs.github.io/PhiFlow/

Path: mosaic/tesseracts/navier-stokes-grid/phiflow

Image: phiflow_navier_stokes_grid

Semi-Lagrangian advection with CG pressure projection, unconditionally stable at large dt. Gradients via JAX autodiff combined with analytic adjoint rules through the same simulation code.

Inputs / Outputs

Inputs

Field	Type	∂	Description
v0	GridVectorField	✓	Initial velocity field, shape (N, N, 1, 2). Default: 64×64 divergence-free random vortex field (seed=42).
viscosity	Array[(1,), Float32]	✓	Kinematic viscosity ν.
dt	Array[(1,), Float32]	✓	Timestep size.
steps	int		Number of timesteps. Total simulated time = steps × dt.
domain_extent	float		Side length of the square periodic domain.
boundary_conditions	GridBC		Per-face boundary conditions. Default: all periodic.
obstacle	GridObstacle | None		Optional solid obstacle embedded in the domain (no-slip walls).
inflow_profile	Array[(None,), Float32] | None	✓	1-D inlet velocity profile u_x(y), shape (N,). When provided, overrides the x_lo Dirichlet BC with a spatially-varying inlet. u_y is set to zero. Used for inflow-profile optimisation (e.g. cylinder drag minimisation).

Outputs

Field	Type	∂	Description
result	GridVectorField	✓	Final velocity field, same shape as v0.
drag	Array[(1,), Float32] | None	✓	x-direction drag force on the embedded obstacle, shape (1,). Computed as the surface integral of pressure and viscous stress: F_x = ∮_S (p n_x − μ (∂u/∂n)_x) dS. None when no obstacle is present.

PICT

Numerics: Finite Volume, PISO, BDF1

pytorch AD: autodiff GPU

Upstream docs: https://github.com/tum-pbs/PICT

Path: mosaic/tesseracts/navier-stokes-grid/pict

Image: pict_navier_stokes_grid

GPU-accelerated differentiable PISO solver built on PyTorch with custom CUDA kernels (PISOtorch). VJP w.r.t. v0, inflow_profile, and viscosity flows through the PISO time loop via PISOtorch_diff (tracks VELOCITY, BOUNDARY_VELOCITY, and VISCOSITY gradients). dt is a Python scalar consumed at construction time; zero gradients are returned for it.

Inputs / Outputs

Inputs

Field	Type	∂	Description
v0	GridVectorField	✓	Initial velocity field, shape (N, N, 1, 2). Default: 64×64 divergence-free random vortex field (seed=42).
viscosity	Array[(1,), Float32]	✓	Kinematic viscosity ν.
dt	Array[(1,), Float32]		Timestep size.
steps	int		Number of timesteps. Total simulated time = steps × dt.
domain_extent	float		Side length of the square periodic domain.
boundary_conditions	GridBC		Per-face boundary conditions. Default: all periodic.
obstacle	GridObstacle | None		Optional solid obstacle embedded in the domain (no-slip walls).
inflow_profile	Array[(None,), Float32] | None	✓	1-D inlet velocity profile u_x(y), shape (N,). When provided, overrides the x_lo Dirichlet BC with a spatially-varying inlet. u_y is set to zero. Used for inflow-profile optimisation (e.g. cylinder drag minimisation).

Outputs

Field	Type	∂	Description
result	GridVectorField	✓	Final velocity field, same shape as v0.
drag	Array[(1,), Float32] | None	✓	x-direction drag force on the embedded obstacle, shape (1,). Computed as the surface integral of pressure and viscous stress: F_x = ∮_S (p n_x − μ (∂u/∂n)_x) dS. None when no obstacle is present.

Warp-NS

Numerics: Finite Difference, IPCS, SSP-RK3

warp AD: autodiff GPU

Upstream docs: https://github.com/NVIDIA/warp

Path: mosaic/tesseracts/navier-stokes-grid/warp-ns

Image: warp_ns_navier_stokes_grid

IPCS projection scheme implemented in NVIDIA Warp CUDA kernels with FFT pressure Poisson on periodic domains. Gradients via wp.Tape kernel-level VJP.

Inputs / Outputs

Inputs

Field	Type	∂	Description
v0	GridVectorField	✓	Initial velocity field, shape (N, N, 1, 2). Default: 64×64 divergence-free random vortex field (seed=42).
viscosity	Array[(1,), Float32]	✓	Kinematic viscosity ν.
dt	Array[(1,), Float32]	✓	Timestep size.
steps	int		Number of timesteps. Total simulated time = steps × dt.
domain_extent	float		Side length of the square periodic domain.
boundary_conditions	GridBC		Per-face boundary conditions. Default: all periodic.
obstacle	GridObstacle | None		Optional solid obstacle embedded in the domain (no-slip walls).
inflow_profile	Array[(None,), Float32] | None		1-D inlet velocity profile u_x(y), shape (N,). When provided, overrides the x_lo Dirichlet BC with a spatially-varying inlet. u_y is set to zero. Used for inflow-profile optimisation (e.g. cylinder drag minimisation).
num_iters_poisson	int		Minimum number of Jacobi iterations per 2-D streamfunction Poisson solve. The solver auto-scales to max(this value, min(4*N², 8000)) at runtime, so convergence is maintained across grid sizes N=16..128 without manual tuning. For N≥128 with production accuracy, a multigrid or FFT Poisson solver is recommended as Jacobi is capped at 8000 iterations.
num_iters_poisson_3d	int		Number of Jacobi iterations per 3-D pressure Poisson solve. 800 iterations is adequate for N≤32; increase for larger grids.

Outputs

Field	Type	∂	Description
result	GridVectorField	✓	Final velocity field, same shape as v0.
drag	Array[(1,), Float32] | None		x-direction drag force on the embedded obstacle, shape (1,). Computed as the surface integral of pressure and viscous stress: F_x = ∮_S (p n_x − μ (∂u/∂n)_x) dS. None when no obstacle is present.

XLB

Numerics: Lattice Boltzmann, Streaming

jax AD: autodiff GPU

Upstream docs: https://github.com/Autodesk/XLB

Path: mosaic/tesseracts/navier-stokes-grid/xlb

Image: xlb_navier_stokes_grid

JAX-accelerated lattice Boltzmann solver (D2Q9 / D3Q19) with BGK or KBC collision, running the streaming/collision loop on GPU. Gradients via source-transformation AD; recovers incompressible Navier–Stokes only to O(Ma²) via Chapman–Enskog expansion.

Inputs / Outputs

Inputs

Field	Type	∂	Description
v0	GridVectorField	✓	Initial velocity field, shape (N, N, 1, 2). Default: 64×64 divergence-free random vortex field (seed=42).
viscosity	Array[(1,), Float32]	✓	Kinematic viscosity ν.
dt	Array[(1,), Float32]	✓	Timestep size.
steps	int		Number of timesteps. Total simulated time = steps × dt.
domain_extent	float		Side length of the square periodic domain.
boundary_conditions	GridBC		Per-face boundary conditions. Default: all periodic.
obstacle	GridObstacle | None		Optional solid obstacle embedded in the domain (no-slip walls).
inflow_profile	Array[(None,), Float32] | None	✓	1-D inlet velocity profile u_x(y), shape (N,). When provided, overrides the x_lo Dirichlet BC with a spatially-varying inlet. u_y is set to zero. Used for inflow-profile optimisation (e.g. cylinder drag minimisation).

Outputs

Field	Type	∂	Description
result	GridVectorField	✓	Final velocity field, same shape as v0.
drag	Array[(1,), Float32] | None	✓	x-direction drag force on the embedded obstacle, shape (1,). Computed as the surface integral of pressure and viscous stress: F_x = ∮_S (p n_x − μ (∂u/∂n)_x) dS. None when no obstacle is present.

XLB 3D surrogate

Numerics: Learned, shared 5-step 3D FNO, 20-step rollout, viscous skip, Helmholtz projection

jax AD: autodiff GPU

Upstream docs: https://github.com/pasteurlabs/mosaic

Path: mosaic/tesseracts/navier-stokes-grid/xlb-3d-surrogate

Image: xlb_3d_surrogate_navier_stokes_grid

Differentiable autoregressive full-field surrogate of XLB for the fixed N=16 3D initial-condition recovery task. One periodic Fourier neural operator advances the complete velocity by five XLB steps and is reused for a 20-macro-step rollout.

Inputs / Outputs

Inputs

Field	Type	∂	Description
v0	GridVectorField	✓	Initial velocity field, shape (N, N, 1, 2). Default: 64×64 divergence-free random vortex field (seed=42).
viscosity	Array[(1,), Float32]		Kinematic viscosity ν.
dt	Array[(1,), Float32]		Timestep size.
steps	int		Number of timesteps. Total simulated time = steps × dt.
domain_extent	float		Side length of the square periodic domain.
boundary_conditions	GridBC		Per-face boundary conditions. Default: all periodic.
obstacle	GridObstacle | None		Optional solid obstacle embedded in the domain (no-slip walls).
inflow_profile	Array[(None,), Float32] | None		1-D inlet velocity profile u_x(y), shape (N,). When provided, overrides the x_lo Dirichlet BC with a spatially-varying inlet. u_y is set to zero. Used for inflow-profile optimisation (e.g. cylinder drag minimisation).

Outputs

Field	Type	∂	Description
result	GridVectorField	✓	Final velocity field, same shape as v0.
drag	Array[(1,), Float32] | None		x-direction drag force on the embedded obstacle, shape (1,). Computed as the surface integral of pressure and viscous stress: F_x = ∮_S (p n_x − μ (∂u/∂n)_x) dS. None when no obstacle is present.

XLB surrogate

Numerics: Learned, POD decoder, residual MLP

jax AD: autodiff GPU

Upstream docs: https://github.com/pasteurlabs/mosaic

Path: mosaic/tesseracts/navier-stokes-grid/xlb-surrogate

Image: xlb_surrogate_navier_stokes_grid

Differentiable full-field surrogate of XLB for the fixed N=32, Re=20 cylinder-flow drag-optimization task. A POD decoder reconstructs the final velocity and RANS traction fields; drag is evaluated with Mosaic’s canonical surface integral.

Inputs / Outputs

Inputs

Field	Type	∂	Description
v0	GridVectorField		Initial velocity field, shape (N, N, 1, 2). Default: 64×64 divergence-free random vortex field (seed=42).
viscosity	Array[(1,), Float32]		Kinematic viscosity ν.
dt	Array[(1,), Float32]		Timestep size.
steps	int		Number of timesteps. Total simulated time = steps × dt.
domain_extent	float		Side length of the square periodic domain.
boundary_conditions	GridBC		Per-face boundary conditions. Default: all periodic.
obstacle	GridObstacle | None		Optional solid obstacle embedded in the domain (no-slip walls).
inflow_profile	Array[(None,), Float32] | None	✓	1-D inlet velocity profile u_x(y), shape (N,). When provided, overrides the x_lo Dirichlet BC with a spatially-varying inlet. u_y is set to zero. Used for inflow-profile optimisation (e.g. cylinder drag minimisation).

Outputs

Field	Type	∂	Description
result	GridVectorField	✓	Final velocity field, same shape as v0.
drag	Array[(1,), Float32] | None	✓	x-direction drag force on the embedded obstacle, shape (1,). Computed as the surface integral of pressure and viscous stress: F_x = ∮_S (p n_x − μ (∂u/∂n)_x) dS. None when no obstacle is present.

Structural mechanics

deal.II

Numerics: Finite Element, Direct (spsolve)

cpp AD: forward-only

Upstream docs: https://www.dealii.org/

Path: mosaic/tesseracts/structural-mesh/dealii-structural

Image: dealii_structural_mesh

deal.II Q1 trilinear hexahedral FEM linear-elasticity solver via C++ subprocess (UMFPACK direct). Forward-only — reference implementation for cross-framework validation.

Inputs / Outputs

Inputs

Field	Type	∂	Description
rho	Array[(None,), Float32]		Per-cell density field, shape (n_max_cells,). Active slice = rho[:hex_mesh.n_faces]. Values in [0, 1]: 0 = void, 1 = solid.
boundary_conditions	MeshBC		Mesh boundary conditions. dirichlet.mask/values prescribe displacement (values shape (n_groups, 3), None → zero); neumann.mask/values prescribe surface traction (values shape (n_groups, 3)).
hex_mesh	HexMesh		Hexahedral mesh (8-node hex elements). n_points / n_faces give the active slice sizes.
E_max	float		Young’s modulus of the fully solid material [MPa].
nu	float		Poisson’s ratio.
xmin	float		Void stiffness ratio (E_min = xmin * E_max).
penal	float		SIMP penalisation exponent (E(ρ) = E_min + (E_max−E_min)·ρ^penal).

Outputs

Field	Type	∂	Description
compliance	Array[(), Float32]		Structural compliance C = F^T U (scalar). Minimising compliance is equivalent to maximising stiffness.

FEniCS

Numerics: Finite Element, GMRES+AMG

fenics AD: adjoint

Upstream docs: https://fenicsproject.org/

Path: mosaic/tesseracts/structural-mesh/fenics-structural

Image: fenics_structural_mesh

FEniCS/DOLFIN CG1 FEM linear-elasticity solver with SIMP penalisation. Gradient ∂C/∂ρ via dolfin-adjoint tape replay (discrete adjoint derived at the variational level via UFL).

Inputs / Outputs

Inputs

Field	Type	∂	Description
rho	Array[(None,), Float32]	✓	Per-cell density field, shape (n_max_cells,). Active slice = rho[:hex_mesh.n_faces]. Values in [0, 1]: 0 = void, 1 = solid.
boundary_conditions	MeshBC		Mesh boundary conditions. dirichlet.mask/values prescribe displacement (values shape (n_groups, 3), None → zero); neumann.mask/values prescribe surface traction (values shape (n_groups, 3)).
hex_mesh	HexMesh		Hexahedral mesh (8-node hex elements). n_points / n_faces give the active slice sizes.
E_max	float		Young’s modulus of the fully solid material.
nu	float		Poisson’s ratio.
xmin	float		Void stiffness ratio (E_min = xmin * E_max).
penal	float		SIMP penalisation exponent (E(rho) = E_min + (E_max-E_min)*rho^penal).

Outputs

Field	Type	∂	Description
compliance	Array[(), Float32]	✓	Structural compliance C = F^T U (scalar). Minimising compliance is equivalent to maximising stiffness.

Firedrake

Numerics: Finite Element, GMRES+AMG

firedrake AD: adjoint

Upstream docs: https://www.firedrakeproject.org/

Path: mosaic/tesseracts/structural-mesh/firedrake-structural

Image: firedrake_structural_mesh

Firedrake CG1 FEM linear-elasticity solver with SIMP penalisation. Gradient ∂C/∂ρ via firedrake-adjoint (pyadjoint ReducedFunctional) — an independent tape-based discrete adjoint complement to FEniCS.

Inputs / Outputs

Inputs

Field	Type	∂	Description
rho	Array[(None,), Float32]	✓	Per-cell density field, shape (n_max_cells,). Active slice = rho[:hex_mesh.n_faces]. Values in [0, 1]: 0 = void, 1 = solid.
boundary_conditions	MeshBC		Mesh boundary conditions. dirichlet.mask/values prescribe displacement (values shape (n_groups, 3), None → zero); neumann.mask/values prescribe surface traction (values shape (n_groups, 3)).
hex_mesh	HexMesh		Hexahedral mesh (8-node hex elements). n_points / n_faces give the active slice sizes.
E_max	float		Young’s modulus of the fully solid material.
nu	float		Poisson’s ratio.
xmin	float		Void stiffness ratio (E_min = xmin * E_max).
penal	float		SIMP penalisation exponent (E(rho) = E_min + (E_max-E_min)*rho^penal).

Outputs

Field	Type	∂	Description
compliance	Array[(), Float32]	✓	Structural compliance C = F^T U (scalar). Minimising compliance is equivalent to maximising stiffness.

JAX-FEM

Numerics: Finite Element, Direct (UMFPACK)

jax AD: hybrid GPU

Upstream docs: https://github.com/deepmodeling/jax-fem

Path: mosaic/tesseracts/structural-mesh/jax-fem

Image: jax_fem_structural_mesh

JAX-FEM HEX8 linear-elasticity solver with SIMP stiffness E(ρ) = E_min + (E_max − E_min)·ρ^penal. Gradient ∂C/∂ρ via JAX automatic differentiation through the linear FE solve (hybrid implicit-function-theorem adjoint).

Inputs / Outputs

Inputs

Field	Type	∂	Description
rho	Array[(None,), Float32]	✓	Per-cell density field, shape (n_max_cells,). Active slice = rho[:hex_mesh.n_faces]. Values in [0, 1]: 0 = void, 1 = solid.
boundary_conditions	MeshBC		Mesh boundary conditions. dirichlet.mask/values prescribe displacement (values shape (n_groups, 3), None → zero); neumann.mask/values prescribe surface traction (values shape (n_groups, 3)).
hex_mesh	HexMesh		Hexahedral mesh (8-node hex elements). n_points / n_faces give the active slice sizes.

Outputs

Field	Type	∂	Description
compliance	Array[(), Float32]	✓	Structural compliance C = F^T U (scalar). Minimising compliance is equivalent to maximising stiffness.

TopOpt.jl

Numerics: Finite Element, Direct (CHOLMOD)

julia AD: adjoint

Upstream docs: https://github.com/JuliaTopOpt/TopOpt.jl

Path: mosaic/tesseracts/structural-mesh/topopt-jl

Image: topopt_jl_structural_grid

TopOpt.jl HEX8 FEM linear-elasticity solver with SIMP penalisation, Julia + Ferrite.jl backend. Gradient ∂C/∂ρ via analytical SIMP adjoint sensitivity computed alongside the forward solve.

Inputs / Outputs

Inputs

Field	Type	∂	Description
rho	Array[(None,), Float32]	✓	Per-cell density field, shape (n_max_cells,). Active slice = rho[:hex_mesh.n_faces]. Values in [0, 1]: 0 = void, 1 = solid.
boundary_conditions	MeshBC		Mesh boundary conditions. dirichlet.mask/values prescribe displacement (values shape (n_groups, 3), None → zero); neumann.mask/values prescribe surface traction (values shape (n_groups, 3)).
hex_mesh	HexMesh		Hexahedral mesh (8-node hex elements). n_points / n_faces give the active slice sizes.
E	float		Young’s modulus of the solid material.
nu	float		Poisson’s ratio.
xmin	float		Minimum density (void stiffness) to prevent singular stiffness matrix.

Outputs

Field	Type	∂	Description
compliance	Array[(), Float32]	✓	Structural compliance C = F^T U (scalar). Minimising compliance is equivalent to maximising stiffness.

Heat transfer

deal.II

Numerics: Finite Element, Direct (spsolve)

cpp AD: forward-only

Upstream docs: https://www.dealii.org/

Path: mosaic/tesseracts/thermal-mesh/dealii-heat

Image: dealii_heat_thermal_mesh

deal.II Q1 trilinear hexahedral FEM heat-conduction solver with SIMP conductivity (C++ subprocess, UMFPACK direct). Forward-only — reference implementation for cross-framework validation.

Inputs / Outputs

Inputs

Field	Type	∂	Description
rho	Array[(None,), Float32]		Per-cell density field, shape (n_max_cells,). Active slice = rho[:hex_mesh.n_faces]. ρ=1 → fully conducting, ρ=0 → insulating.
source	Array[(None,), Float32]		Per-element volumetric heat source (W/m³), shape (n_cells,). Active slice = source[:hex_mesh.n_faces]. Zero by default (topology-optimisation mode; no body heat source).
target_temperature	Array[(None,), Float32]		Per-node target temperature for the inverse (source-identification) objective, shape (n_nodes,). identification_error =
boundary_conditions	MeshBC		Mesh boundary conditions. dirichlet.mask/values prescribe temperature (values shape (n_groups, 1), None → zero); neumann.mask/values prescribe heat flux (values shape (n_groups, 1)).
hex_mesh	HexMesh		Hexahedral mesh (8-node hex elements). n_points / n_faces give the active slice sizes.
k_max	float		Maximum thermal conductivity (fully solid material).
p_exp	float		SIMP penalisation exponent p (k(ρ) = k_min + (k_max−k_min)·ρ^p).

Outputs

Field	Type	∂	Description
thermal_compliance	Array[(), Float32]		Total thermal compliance C = ∮_Γ_N q_n · T dΓ (scalar). Equals the work done by the Neumann heat flux on the temperature field.
identification_error	Array[(), Float32]		Source-identification objective:

FEniCS

Numerics: Finite Element, GMRES+AMG

fenics AD: adjoint

Upstream docs: https://fenicsproject.org/

Path: mosaic/tesseracts/thermal-mesh/fenics-heat

Image: fenics_heat_thermal_mesh

FEniCS P1 FEM heat-conduction solver with SIMP penalisation. Gradients (∂C/∂ρ, ∂C/∂source) via dolfin-adjoint tape replay.

Inputs / Outputs

Inputs

Field	Type	∂	Description
rho	Array[(None,), Float32]	✓	Per-cell density field, shape (n_max_cells,). Active slice = rho[:hex_mesh.n_faces]. ρ=1 → fully conducting, ρ=0 → insulating.
source	Array[(None,), Float32]	✓	Per-element volumetric heat source (W/m³), shape (n_cells,). Active slice = source[:hex_mesh.n_faces]. Zero by default (topology-optimisation mode; no body heat source).
target_temperature	Array[(None,), Float32]		Per-node target temperature for the inverse (source-identification) objective, shape (n_nodes,). identification_error =
boundary_conditions	MeshBC		Mesh boundary conditions. dirichlet.mask/values prescribe temperature (values shape (n_groups, 1), None → zero); neumann.mask/values prescribe heat flux (values shape (n_groups, 1)).
hex_mesh	HexMesh		Hexahedral mesh (8-node hex elements). n_points / n_faces give the active slice sizes.
k_max	float		Maximum thermal conductivity (fully solid/conducting material).
p_exp	float		SIMP penalisation exponent p (k(ρ) = k_min + (k_max−k_min)·ρ^p).

Outputs

Field	Type	∂	Description
thermal_compliance	Array[(), Float32]	✓	Total thermal compliance C = ∮_Γ_N q_n · T dΓ (scalar). Equals the work done by the Neumann heat flux on the temperature field.
identification_error	Array[(), Float32]	✓	Source-identification objective:

Firedrake

Numerics: Finite Element, GMRES+AMG

firedrake AD: adjoint

Upstream docs: https://www.firedrakeproject.org/

Path: mosaic/tesseracts/thermal-mesh/firedrake-heat

Image: firedrake_heat_thermal_mesh

Firedrake P1 FEM heat-conduction solver with SIMP penalisation. Gradients (∂C/∂ρ, ∂C/∂source) via firedrake-adjoint, complementing the FEniCS reference.

Inputs / Outputs

Inputs

Field	Type	∂	Description
rho	Array[(None,), Float32]	✓	Per-cell density field, shape (n_max_cells,). Active slice = rho[:hex_mesh.n_faces]. ρ=1 → fully conducting, ρ=0 → insulating.
source	Array[(None,), Float32]	✓	Per-element volumetric heat source (W/m³), shape (n_cells,). Active slice = source[:hex_mesh.n_faces]. Zero by default (topology-optimisation mode; no body heat source).
target_temperature	Array[(None,), Float32]		Per-node target temperature for the inverse (source-identification) objective, shape (n_nodes,). identification_error =
boundary_conditions	MeshBC		Mesh boundary conditions. dirichlet.mask/values prescribe temperature (values shape (n_groups, 1), None → zero); neumann.mask/values prescribe heat flux (values shape (n_groups, 1)).
hex_mesh	HexMesh		Hexahedral mesh (8-node hex elements). n_points / n_faces give the active slice sizes.
k_max	float		Maximum thermal conductivity (fully solid/conducting material).
p_exp	float		SIMP penalisation exponent p (k(ρ) = k_min + (k_max−k_min)·ρ^p).

Outputs

Field	Type	∂	Description
thermal_compliance	Array[(), Float32]	✓	Total thermal compliance C = ∮_Γ_N q_n · T dΓ (scalar). Equals the work done by the Neumann heat flux on the temperature field.
identification_error	Array[(), Float32]	✓	Source-identification objective:

JAX-FEM

Numerics: Finite Element, Direct (UMFPACK)

jax AD: hybrid GPU

Upstream docs: https://github.com/deepmodeling/jax-fem

Path: mosaic/tesseracts/thermal-mesh/jax-fem

Image: jax_fem_thermal_mesh

JAX-FEM HEX8 steady-state heat-conduction solver with SIMP conductivity and optional volumetric source. Gradients ∂C/∂ρ and ∂C/∂source via JAX autodiff through the linear FE solve (hybrid implicit-function-theorem adjoint)

Inputs / Outputs

Inputs

Field	Type	∂	Description
rho	Array[(None,), Float32]	✓	Per-cell density field, shape (n_max_cells,). Active slice = rho[:hex_mesh.n_faces]. ρ=1 → fully conducting, ρ=0 → insulating.
source	Array[(None,), Float32]	✓	Per-element volumetric heat source (W/m³), shape (n_cells,). Active slice = source[:hex_mesh.n_faces]. Zero by default (topology-optimisation mode; no body heat source).
target_temperature	Array[(None,), Float32]		Per-node target temperature for the inverse (source-identification) objective, shape (n_nodes,). identification_error =
boundary_conditions	MeshBC		Mesh boundary conditions. dirichlet.mask/values prescribe temperature (values shape (n_groups, 1), None → zero); neumann.mask/values prescribe heat flux (values shape (n_groups, 1)).
hex_mesh	HexMesh		Hexahedral mesh (8-node hex elements). n_points / n_faces give the active slice sizes.

Outputs

Field	Type	∂	Description
thermal_compliance	Array[(), Float32]	✓	Total thermal compliance C = ∮_Γ_N q_n · T dΓ (scalar). Equals the work done by the Neumann heat flux on the temperature field.
identification_error	Array[(), Float32]	✓	Source-identification objective:

torch-fem

Numerics: Finite Element, Direct (spsolve)

pytorch AD: autodiff GPU

Upstream docs: https://github.com/meyer-nils/torch-fem

Path: mosaic/tesseracts/thermal-mesh/torch-fem-thermal

Image: torch_fem_thermal_mesh

torch-fem SolidHeat HEX8 heat-conduction solver with IsotropicConductivity3D SIMP material — the first PyTorch backend in thermal-mesh. Gradients via PyTorch autograd through the FE solve; GPU-native.

Inputs / Outputs

Inputs

Field	Type	∂	Description
rho	Array[(None,), Float32]	✓	Per-cell density field, shape (n_max_cells,). Active slice = rho[:hex_mesh.n_faces]. ρ=1 → fully conducting, ρ=0 → insulating.
source	Array[(None,), Float32]	✓	Per-element volumetric heat source (W/m³), shape (n_cells,). Active slice = source[:hex_mesh.n_faces]. Zero by default (topology-optimisation mode; no body heat source).
target_temperature	Array[(None,), Float32]		Per-node target temperature for the inverse (source-identification) objective, shape (n_nodes,). identification_error =
boundary_conditions	MeshBC		Mesh boundary conditions. dirichlet.mask/values prescribe temperature (values shape (n_groups, 1), None → zero); neumann.mask/values prescribe heat flux (values shape (n_groups, 1)).
hex_mesh	HexMesh		Hexahedral mesh (8-node hex elements). n_points / n_faces give the active slice sizes.
k_max	float		Maximum thermal conductivity (fully solid material).
p_exp	float		SIMP penalisation exponent p (k(ρ) = k_min + (k_max−k_min)·ρ^p).

Outputs

Field	Type	∂	Description
thermal_compliance	Array[(), Float32]	✓	Total thermal compliance C = ∮_Γ_N q_n · T dΓ (scalar). Equals the work done by the Neumann heat flux on the temperature field.
identification_error	Array[(), Float32]	✓	Source-identification objective: