Benchmarking of Massively Parallel Phase-Field Codes for Directional Solidification

This paper presents a comprehensive benchmark comparing a GPU-accelerated finite-difference phase-field code (GPU-PF) and a CPU-parallelized finite-element adaptive-mesh code (PRISMS-PF) for simulating directional solidification of Al-Cu and SCN-camphor alloys under experimentally relevant conditions, validating their accuracy in predicting dendritic morphology and tip dynamics while evaluating their computational performance to support integrated computational materials engineering workflows.

The Gist

Imagine you are trying to predict how a frozen lake forms ice crystals, or how metal cools down to become a strong beam. Scientists use a special kind of computer simulation called a "Phase-Field" model to do this. Think of these models as digital weather forecasts for solidifying materials. Instead of predicting rain, they predict how tiny tree-like structures (called dendrites) grow inside a liquid as it turns solid.

However, just like there are different weather models (some run on supercomputers, some on laptops; some use different math), there are different computer codes to run these simulations. The big question is: Do they all tell the same story?

This paper is a "taste test" or a racing competition between two very different computer codes designed to simulate how materials solidify. The goal was to see if they produce the same results when fed the exact same recipe and ingredients.

The Two Racers

The authors compared two distinct "racing cars" (computer codes):

1. The GPU-PF (The Speedster): This code is built for GPUs (the powerful graphics cards found in gaming computers). It uses a "finite difference" method, which is like looking at a grid of square tiles. It's incredibly fast and efficient, especially when you have a lot of them working together. It's designed to crunch numbers at lightning speed.
2. The PRISMS-PF (The Precision Navigator): This code is built for CPUs (the standard processors in most computers) and uses a "finite element" method with adaptive meshing. Imagine this as a map that zooms in and out. It uses a coarse grid for empty space but automatically adds tiny, high-detail tiles only where the action is happening (like right at the edge of the growing crystal). It's more flexible but requires more computing power to manage.

The Race Track: Real-World Conditions

Usually, these codes are tested on simple, idealized tracks (like a perfect circle in a vacuum). But the authors wanted to see how they performed on a real, bumpy race track.

They used data from NASA's experiments on the International Space Station. In space, there is no gravity, so the liquid metal doesn't swirl around (convection); it just sits there and freezes purely by diffusion. This creates a "clean" environment to test the codes. They simulated two scenarios:

• The Sprint: Aluminum-Copper alloy freezing very quickly (like a high-speed race).
• The Marathon: A transparent organic alloy freezing slowly in microgravity (like a long-distance run).

The Results: Do They Agree?

The authors ran both codes side-by-side and checked three things:

1. The Shape of the Ice: Did both codes draw the same crystal shapes?

   • Verdict: Yes. When the starting conditions were set up correctly, both codes drew nearly identical crystal patterns. The "trees" grew in the same directions, split at the same times, and had the same spacing. It was like two different artists drawing the same tree from the same photo; the result was indistinguishable.

2. The "Chaos" Trap: The authors discovered a tricky pitfall. If you start the simulation with a very specific, unstable wobble, the system becomes chaotic (like the "Butterfly Effect"). In this state, tiny differences in the math cause the two codes to diverge wildly, growing completely different trees.

   • Lesson: To get a fair comparison, you have to start the race with a stable setup. Once they fixed the starting conditions, the codes agreed perfectly again.

3. The Speed: Who finished the race faster?

   • Verdict: The GPU-PF (Speedster) was generally faster, especially when using multiple GPUs working together. It handled the "speed" of the simulation very well.
   • The PRISMS-PF (Precision Navigator) was slightly slower but showed it could handle the job well on standard computer clusters. It proved that you don't need a super-expensive graphics card to get accurate results, though it takes more time.

The Big Takeaway

This paper is a quality control check. It proves that:

• You can trust these different computer codes to give you the same answer if you set them up correctly.
• The "Speedster" (GPU) is great for massive, fast simulations.
• The "Precision Navigator" (CPU/Adaptive) is great for flexibility and detailed resolution.
• Both are now ready to be used as reliable tools for ICME (Integrated Computational Materials Engineering). This is a framework where engineers use computer models to design better materials (like stronger airplane parts or better batteries) without having to build and break physical prototypes first.

In short, the authors built a standardized test track and showed that two very different types of simulation engines can drive it with the same precision, giving scientists confidence to use them for real-world material design.

Technical Summary

1. Problem Statement

Integrated Computational Materials Engineering (ICME) requires the integration of physics-based models across multiple scales to predict material properties. However, simulating alloy solidification at experimentally relevant length (millimeters) and time (seconds) scales remains a significant computational barrier.

• The Challenge: While numerous Phase-Field (PF) codes exist (e.g., PRISMS-PF, MOOSE, GPU-PF), they often employ different numerical formulations (Finite Element vs. Finite Difference), discretization schemes (adaptive vs. uniform), and parallelization strategies (CPU vs. GPU).
• The Gap: Existing benchmarks typically focus on idealized, small-scale, or simplified cases that do not reflect the computational and modeling challenges of real-world experiments. There is a lack of rigorous, "apples-to-apples" comparisons between flexible modular frameworks and performance-optimized codes under experimentally validated conditions.
• Specific Goal: To quantitatively benchmark two distinct state-of-the-art PF implementations—GPU-PF (finite-difference, uniform mesh, GPU-accelerated) and PRISMS-PF (finite-element, adaptive mesh, CPU-parallelized)—under identical physical models and experimentally relevant conditions.

2. Methodology

A. Unified Physical Model

To ensure a fair comparison, both codes were forced to solve the same quantitative phase-field formulation for dilute alloy solidification:

• Model: The one-sided dilute alloy model by Echebarria et al., incorporating an anti-trapping current to eliminate spurious solute trapping.
• Approximation: The "thin-interface" approximation was used to recover the sharp-interface limit via matched asymptotic analysis.
• Physics: The system solves coupled partial differential equations for the phase field ($\phi$) and dimensionless supersaturation ($U$), governed by a Lyapunov functional.
• Boundary Conditions: The Frozen Temperature Approximation (FTA) was applied, assuming a fixed 1D temperature gradient.

B. Benchmark Systems

Two distinct material systems were simulated to test different regimes:

1. Al-3wt%Cu (2D): High-velocity solidification. Used as a baseline for rapid convergence testing on consumer-grade hardware.
2. SCN-0.46wt% Camphor (2D & 3D): Microgravity directional solidification based on NASA DECLIC-DSI-R experiments. This system eliminates buoyancy-driven convection, providing a "clean" benchmark for validating tip dynamics, primary spacing, and morphology against spaceflight data.

C. Numerical Implementations

• GPU-PF:
  • Method: Finite Difference Method (FDM) on structured, uniform grids.
  • Hardware: CUDA-accelerated on NVIDIA V100 GPUs.
  • Features: Uses a preconditioned phase field ($\psi$) to improve stability at coarse resolutions and large time steps. Employs isotropic discretization in 2D to mitigate lattice anisotropy.
• PRISMS-PF:
  • Method: Finite Element Method (FEM) with Adaptive Mesh Refinement (AMR).
  • Hardware: MPI-parallelized on AMD EPYC CPUs.
  • Features: Uses a matrix-free approach with sum-factorization and Gauss-Lobatto quadrature. Supports arbitrary geometries and higher-order accuracy.

D. Experimental Design

The authors specifically designed initial conditions to challenge numerical robustness:

• Chaotic vs. Non-Chaotic Regimes: They demonstrated that certain initial perturbations (long-wavelength) lead to chaotic dynamics where small numerical differences amplify exponentially, making direct comparison impossible.
• Stable Regime: They identified specific initial conditions (shorter wavelength perturbations) that yield stable, periodic dendritic arrays, allowing for meaningful quantitative comparison of tip radius and spacing.

3. Key Contributions

1. First "Apples-to-Apples" Benchmark: The study provides the first rigorous comparison of a high-performance, hard-coded GPU solver (GPU-PF) against a flexible, open-source, adaptive FEM framework (PRISMS-PF) using an identical physical model.
2. Validation Against Spaceflight Data: The benchmarks are directly validated against NASA's DECLIC-DSI-R microgravity data, moving beyond idealized theoretical benchmarks to experimentally relevant scenarios.
3. Insight into Numerical Chaos: The paper highlights a critical finding: initial conditions dictate comparability. It demonstrates that simulations of directional solidification can exhibit chaotic sensitivity to initial perturbations. If the initial condition excites unstable modes, the solutions diverge exponentially, rendering code comparisons ill-posed.
4. Performance Scaling Analysis: A detailed analysis of strong scaling and computational efficiency across different hardware architectures (GPU vs. CPU) and domain sizes.

4. Results

A. Morphological and Quantitative Agreement

• 2D Al-Cu: Both codes showed excellent agreement in interface evolution, including tip splitting and side-branching, validating the GPU implementation against the converged FEM result.
• 2D & 3D SCN-Camphor:
  • When using chaotic initial conditions (long wavelength), the codes diverged significantly due to sensitivity to numerical noise.
  • When using stable initial conditions (shorter wavelength, $n=6$), the codes achieved near-perfect agreement.
  • Tip Radius: The dendrite tip radius ($\rho$) differed by only 4.3% ($\rho_{GPU} = 13.30 W_0$ vs. $\rho_{PRISMS} = 13.87 W_0$).
  • Root Mean Square Difference (RMSD): The difference between longitudinal tip profiles was $0.63 W_0$, which is less than a single grid spacing, confirming convergence at the tip scale.
  • Primary Spacing: Both codes predicted a stable primary spacing of $\Lambda \approx 200 \mu m$, falling within the theoretically predicted stability band for the SCN-Camphor system.

B. Computational Performance

• GPU-PF:
  • Demonstrated superior throughput for large domains.
  • Achieved sublinear scaling on multi-GPU setups but maintained high efficiency due to the ability to use larger time steps (enabled by preconditioning).
  • For a full 3D domain, 4 GPUs completed the simulation in 3.08 hours.
• PRISMS-PF:
  • Demonstrated near-ideal scaling up to 256 cores, but scaling efficiency dropped at higher core counts (2048 cores) due to communication overhead and mesh adaptivity complexity.
  • Required significantly more time for the same 3D domain: 6.42 hours on 2048 cores.
  • Excels in resolving sharp features and handling interface misorientation relative to the grid without the need for isotropic stencils.

5. Significance and Conclusion

This work establishes a practical framework for assessing phase-field code performance in ICME workflows.

• For ICME: It validates that both flexible open-source tools (PRISMS-PF) and optimized in-house codes (GPU-PF) can reproduce experimental reality with high fidelity, provided the physical model is consistent and initial conditions are chosen to avoid chaotic divergence.
• For Code Development: It underscores the trade-offs in code architecture:
  • GPU-PF is ideal for high-throughput, large-scale screening where uniform grids are acceptable.
  • PRISMS-PF is superior for problems requiring adaptive resolution, complex geometries, or high-order accuracy near interfaces.
• Future Outlook: The authors call for standardized benchmarks to facilitate the integration of PF models with machine learning and experimental pipelines. The data and code used in this study are publicly available to support reproducibility and further development in the community.

In summary, the paper successfully bridges the gap between theoretical phase-field modeling and experimental validation, proving that modern massively parallel codes can accurately predict microstructural evolution in space-relevant solidification conditions.