CuPyMag: GPU-Accelerated Finite-Element Micromagnetics with Magnetostriction

CuPyMag is an open-source, GPU-accelerated Python framework that leverages finite elements and magnetoelastic coupling to achieve up to two orders of magnitude speedup over CPU codes, enabling efficient, large-scale micromagnetic simulations of realistic defect geometries and nanoscale structures.

The Gist

Imagine you are trying to predict how a giant, invisible magnetic field behaves inside a piece of metal. This isn't just a simple magnet; it's a complex material where the magnetic properties are tangled with the physical shape of the metal, tiny defects (like microscopic bubbles or cracks), and even the stress you put on it.

This is the world of micromagnetics. For scientists, simulating this is like trying to predict the weather for every single molecule in a storm cloud simultaneously. It requires solving millions of complex math equations at once. Usually, this takes days or weeks on powerful supercomputers, and even then, the models are often too simple to handle real-world shapes.

Enter CuPyMag. Think of CuPyMag as a "magic wand" that turns this weeks-long nightmare into a three-hour coffee break.

Here is how it works, broken down into simple concepts:

1. The Problem: The "Staircase" vs. The "Smooth Curve"

Imagine you are trying to draw a perfect circle on a grid of square graph paper.

• Old Methods (FDM): The old way of doing these simulations was like drawing that circle on graph paper. You have to approximate the curve using little square steps. It looks jagged, like a staircase. If your material has a round defect or a curved crack, the old software gets confused, creating fake "magnetic charges" at the jagged edges.
• The New Method (FEM): CuPyMag uses Finite Elements. Instead of square graph paper, imagine using a net made of flexible, irregular triangles and shapes that can wrap perfectly around a curve. It fits the shape of the metal and its defects exactly, no matter how weird they are.

2. The Engine: The GPU as a "Super-Factory"

Most computers have a CPU (the brain) and a GPU (the graphics card).

• The CPU is like a brilliant professor who can solve one incredibly hard math problem at a time, very carefully.
• The GPU is like a factory floor with 10,000 workers. Each worker is not very smart, but they can all do simple math tasks at the exact same time.

The Innovation:
Most scientific software sends the "hard problems" to the professor (CPU) and waits. CuPyMag sends the entire factory floor (GPU) to work.

• The Workflow: The "professor" (CPU) sets up the blueprint once. Then, the "factory" (GPU) takes over completely. It calculates the magnetic fields, the physical stress, and the movement of the material all at once, without stopping to ask the professor for help. This minimizes the time wasted shuttling data back and forth.

3. The Secret Sauce: "Magnetostriction" and "The Ellipsoid Trick"

Real materials don't just have magnetic fields; they change shape when magnetized (like a rubber band stretching), and they change magnetism when you squeeze them. This is called magnetostriction.

• The Challenge: Calculating this is like trying to solve a puzzle where the pieces change shape while you are solving it. It's computationally expensive.
• CuPyMag's Solution: It solves the "shape puzzle" and the "magnetism puzzle" together, instantly, on the GPU.

Also, magnetic fields stretch out forever (like a smell spreading through a house). Calculating the effect of the whole room is hard. CuPyMag uses a mathematical shortcut called the Ellipsoid Theorem. Imagine the magnetic object is inside a giant, invisible egg shape. The math allows the software to calculate the "far-away" effects of the egg shape instantly, so it only has to focus on the messy details inside the object.

4. The Result: Speed and Stability

The paper shows that CuPyMag is 10 to 100 times faster than previous methods.

• The Analogy: If an old computer was a snail trying to cross a field, CuPyMag is a cheetah.
• The "Gauss-Seidel" Trick: To keep the simulation stable (so it doesn't crash or explode with errors), CuPyMag uses a special stepping method. It's like walking across a frozen lake. Instead of taking tiny, nervous steps (which takes forever), it takes confident, long strides (up to 11 picoseconds at a time) without falling through the ice.

Why Does This Matter?

Before CuPyMag, scientists had to choose between:

1. Speed: Fast simulations, but only for simple, blocky shapes (like Lego bricks).
2. Accuracy: Accurate simulations for complex shapes, but they took forever to run.

CuPyMag gives you both.

• It can simulate a piece of metal with a 3-million-node mesh (a very high-resolution model) in under 3 hours on a single modern graphics card.
• It allows engineers to design better hard drives, more efficient motors, and advanced sensors by testing "what-if" scenarios with complex defects and stresses that were previously too hard to calculate.

In a nutshell: CuPyMag is a new, open-source tool that uses the massive parallel power of graphics cards to simulate how magnets behave in complex, real-world shapes, turning days of calculation into hours, and helping us design better technology.

Technical Summary

1. Problem Statement

Micromagnetic simulations are essential for understanding magnetization dynamics, domain structures, and hysteresis in materials. However, existing open-source tools face significant limitations:

• Geometric Constraints: Popular GPU-accelerated tools (e.g., MuMax3, magnum.np) rely on the Finite Difference Method (FDM). FDM struggles with arbitrary shapes and complex boundary conditions, often resulting in "staircased" boundaries that introduce spurious magnetic charges.
• Computational Bottlenecks: Flexible tools using the Finite Element Method (FEM) (e.g., Nmag, magnum.fe) are typically CPU-bound. They lack the parallelism required for large-scale simulations, making them inefficient for problems involving millions of nodes.
• Missing Physics: Many existing codes lack comprehensive magnetoelastic coupling (the interaction between magnetization and mechanical strain) and accurate modeling of far-field demagnetization effects in complex geometries.
• Scalability: Solving coupled multiphysics equations (magnetostatics, mechanical equilibrium, and Landau-Lifshitz-Gilbert dynamics) on unstructured meshes with high resolution is computationally prohibitive on CPUs.

2. Methodology

CuPyMag addresses these challenges through a GPU-resident, tensorized workflow built on Python and the CuPy library.

Core Architecture

• GPU-Resident Workflow: After an initial one-time setup (matrix assembly) on the CPU using Numba (JIT-compiled), all subsequent operations (assembly of right-hand sides, spatial derivatives, volume averages, and linear solves) occur entirely on the GPU. This minimizes CPU-GPU data transfer overhead.
• Tensorized Operations: Key operations are implemented using CuPy's BLAS-accelerated backend, leveraging thousands of GPU cores for parallel execution.
• Discretization: Uses unstructured finite-element meshes (linear hexahedral and tetrahedral elements) to handle arbitrary defect geometries and curved boundaries naturally.

Governing Equations & Physics

The framework solves the minimization of total free energy $\Psi$, which includes:

1. Exchange Energy: Gradient energy terms.
2. Anisotropy Energy: Magnetocrystalline anisotropy.
3. Magnetoelastic Energy: Coupling between magnetization ($m$) and strain ($E$) via spontaneous strain $E_0(m)$.
4. Zeeman Energy: Interaction with external fields.
5. Demagnetization Energy: Long-range dipolar interactions.

Key Numerical Strategies:

• Ellipsoid Theorem: To handle far-field demagnetization effects efficiently, the magnetization and fields are decomposed into spatially varying local perturbations and homogeneous volume averages. The global demagnetization factor is applied to the average field, while local variations are solved via Poisson-type equations on the mesh.
• Gauss-Seidel Projection Method (GSPM): Used for time integration of the Landau-Lifshitz-Gilbert (LLG) equation. This implicit method ensures numerical stability with large time steps (up to 11 ps) and converts the non-linear LLG update into solving a single type of well-conditioned Poisson-type PDE per step.
• Linear Solvers: Uses Conjugate Gradient (CG) solvers without preconditioners. The system matrices are symmetric positive-definite (after pinning degrees of freedom), ensuring convergence.

3. Key Contributions

• First Open-Source GPU-Accelerated FEM Micromagnetics: CuPyMag bridges the gap between the geometric flexibility of FEM and the high throughput of GPU computing.
• Comprehensive Magnetoelastic Coupling: It explicitly solves for mechanical equilibrium at every time step, accounting for the mutual influence of magnetization and strain fields, a feature often missing in other open-source packages.
• High-Performance Implementation:
  • Utilizes Numba for rapid CPU-based matrix assembly.
  • Employs CuPy for fully tensorized GPU operations.
  • Achieves a 2–3× speedup in double precision on NVIDIA H200 GPUs compared to A100s.
• Accessibility: Written entirely in Python using widely adopted libraries (CuPy, Numba), ensuring cross-platform compatibility (Linux/Windows) and ease of installation via pip or conda.

4. Results & Performance Benchmarks

The authors benchmarked CuPyMag on NVIDIA A100 and H200 GPUs against CPU-based PETSc solvers.

• Speedup: GPU solvers achieve a 1–2 orders of magnitude speedup over CPU counterparts.
• Scalability:
  • Assembly Time: Scales linearly with problem size (up to >2M nodes).
  • Solver Time: Scales linearly to sub-linearly with problem size, indicating high GPU utilization and that the code is memory-bound rather than compute-bound.
  • Large-Scale Simulation: Successfully simulated a hysteresis loop for a system with 3 million nodes (including complex defect geometries) in under 3 hours on a single H200 GPU.
• Time Integration Efficiency:
  • GSPM allows stable time steps of 5–11 ps (significantly larger than typical explicit methods).
  • Requires only 1–3 Conjugate Gradient iterations per step for the GSPM PDE, and 40–200 iterations for magnetostatic/mechanical equilibrium, without preconditioning.
• Physical Validation:
  • Reproduced known domain patterns (needle-to-stripe transitions) for cuboid, spherical, and ellipsoidal defects.
  • Demonstrated that magnetoelastic coupling significantly alters coercivity and domain patterns (e.g., stress-induced domain rotation in Galfenol), validating the necessity of the coupled physics approach.

5. Significance

• Enabling Realistic Simulations: CuPyMag allows researchers to simulate realistic material defects (pores, inclusions) with curved boundaries at the nanoscale, which was previously computationally infeasible with FEM on CPUs.
• Materials Discovery: The ability to perform high-throughput simulations on large parameter spaces (e.g., varying defect shapes, stress conditions, and alloy compositions) accelerates the discovery of materials with optimized magnetic properties (e.g., low coercivity in soft magnets).
• Multiphysics Integration: By successfully integrating magnetostriction and far-field effects, CuPyMag provides a more accurate physical model for functional magnetic materials like spintronic devices, sensors, and actuators.
• Future-Proofing: The modular, Python-based architecture makes it easy to extend to new physics (e.g., higher-order elements, multi-GPU scaling via MPI) and adapt to diverse applications beyond micromagnetics.

In summary, CuPyMag represents a significant leap forward in computational micromagnetics, combining the geometric flexibility of FEM with the raw power of modern GPUs to solve large-scale, multiphysics problems that were previously out of reach.