Capabilities¶

mufem uses a high-performance finite-element core. It has a strong focus on scalability, automation, and reproducibility. The architecture targets large-scale simulation campaigns, research workflows, and industrial engineering applications in equal measure.

Core Discretization Engine¶

The numerical core is MFEM, a mature, openly developed finite-element library. From it, mufem inherits:

High-order finite elements on unstructured meshes in 2D and 3D.
Native discretizations in \(H^1\), \(H(\mathrm{curl})\), \(H(\mathrm{div})\), and \(L^2\) — the function spaces that electromagnetics and coupled multiphysics actually live in.
Parallel domain decomposition with MPI, with scalable algebraic multigrid and a broad library of preconditioners on top.

These foundations let mufem stay accurate and well-conditioned at scale. It does not rely on ad-hoc stabilization at the application layer.

High-Order Accuracy¶

mufem supports true high-order methods end-to-end:

Isoparametric, curved higher-order geometry that follows the actual domain rather than a faceted approximation.
High-order basis functions matched consistently across the function spaces above.
Consistent integration rules for nonlinear material models, so quadrature error does not silently dominate the solution.

The practical results are less numerical dispersion, faster convergence under refinement, and fewer elements for a given target accuracy. This matters most for curved domains, rotating machinery, and wave-propagation problems.

Refinement in mufem is local, parallel, and works with the rest of the solver stack:

Local \(h\)-refinement driven by error indicators or user criteria.
Hanging-node conformity, so refinement does not force the mesh into a fully conforming subdivision.
Refinement that operates correctly on partitioned, MPI-distributed meshes.

With this you can resolve singular fields, skin effects, boundary layers, and local nonlinearities accurately. You do not need to commit to a globally fine mesh in advance.

Native Python Interface¶

A mufem case is a Python script, not a configuration file fed to a black-box binary:

You define problems, materials, and boundary conditions directly through the Python API.
Model parameters are first-class Python objects — readable, scriptable, and inspectable from the same process.
The simulation lives inside the scientific Python ecosystem. So you can use NumPy, SciPy, pandas, and ML frameworks for pre- and post-processing, with no translation layers.

This makes mufem a natural fit for parameter sweeps, optimization loops, and AI-driven simulation pipelines. In these, the simulation is one part of a larger automated workflow.

Performance Portability¶

The same problem definition can run on very different hardware:

Multi-core CPUs for development and small studies.
Distributed-memory clusters with MPI for production runs.
GPU execution through MFEM's device backends where available.

In practice this covers laptop prototyping, workstation engineering studies, and HPC campaigns without rewriting the case.

Cartesian Meshes and Implicit Geometry¶

Alongside conventional unstructured meshes, mufem supports a structured-Cartesian path combined with implicit geometry:

Hex-dominant discretizations that play well with high-order bases and vectorized kernels.
Cut-cell integration workflows that resolve embedded boundaries without re-meshing.
Level-set driven material definitions, so geometry can be a smooth design variable instead of a discrete topology choice.
Efficient geometry parameterization for batched or differentiable workflows.

This path is very useful for parametric studies, topology variations, and optimization. Here, a re-mesh of every configuration would otherwise dominate the cost.