Adamantine vs MALAMUTE/MOOSE

Comparison of two open-source AM simulation frameworks for the TMM surrogate project.

adamantine (ORNL)

C++ thermomechanical simulator for AM based on deal.II, ArborX, Trilinos, and Kokkos. Developed by Turcksin & DeWitt at ORNL.

Citation: Turcksin, B. & DeWitt, S. (2024). “Adamantine 1.0: A Thermomechanical Simulator for Additive Manufacturing.” Journal of Open Source Software, 9(102), 7017. DOI: 10.21105/joss.07017

Capabilities

Domain	Status	Details
Thermal	Fully implemented	Enthalpy-based with mushy zone, radiation, convection
Mechanical	Fully implemented	Thermoelasticity + J2 elastoplasticity, combined isotropic/kinematic hardening
Coupling	One-way	Temperature to stress only; no feedback
Metallurgical	Post-processing only	Computes G, cooling rate, R at solidification front

Key algorithmic features

• Matrix-free FEM (no global matrix assembly)
• AMR via p4est (resolves ~50 um powder on cm-scale parts)
• Element activation via FE_Nothing (zero-DOF cells activated on deposition)
• Explicit time stepping (implicit removed in v1.1)
• GPU support via Kokkos (partial, thermal operator only)
• MPI parallelism for thermal and EnKF; mechanical MPI ongoing
• Built-in Ensemble Kalman Filter for thermal data assimilation

Material states

Template-based system with three specializations:

• SolidLiquidPowder (3 states): Powder Bed Fusion
• SolidLiquid (2 states): Directed Energy Deposition
• Solid (1 state): Fused Deposition Modeling

Metallurgical modeling gaps

adamantine does not have:

• Solid-state phase transformation solvers (JMAK, KM)
• TRIP models
• Microstructure prediction (grain morphology, texture)
• CALPHAD coupling
• CCT/TTT diagram integration

The Microstructure class only computes temperature gradient G, cooling rate, and interface velocity R at the solidification front as post-processing output. No inline prediction of phase fractions or grain structure.

Limitations for TMM

• One-way thermal-to-mechanical coupling only
• No fluid flow in melt pool (no Marangoni, recoil pressure)
• No evaporation modeling
• Isotropic mechanical properties
• Infinitesimal strain assumption
• No creep or viscoplasticity
• No EnKF for mechanical state
• Heavy template parameterization makes runtime extensibility difficult
• No plugin system or Python bindings

MALAMUTE/MOOSE (INL)

MALAMUTE (MOOSE Application Library for Advanced Manufacturing UTilitiEs) built on the MOOSE framework from Idaho National Lab.

Citation: Gaston, D. et al. (2009). “MOOSE: A parallel computational framework for coupled nonlinear multiphysics simulations.” Nuclear Engineering and Design, 239(10).

Capabilities

Domain	Status	Details
Thermal	Full	Conduction, convection, radiation, phase change
Mechanical	Full	J2 plasticity, creep, thermal expansion, damage
Fluid	Full	INS with level set, Marangoni, recoil pressure
Phase field	Full	Allen-Cahn, Cahn-Hilliard, grain growth
Coupling	Fully coupled, fully implicit	All physics in one Newton system

MALAMUTE-specific modules

• MeltPoolHeatSource: Gaussian laser + convection + radiation + vaporization
• INSMeltPoolMaterial: Full INS with surface tension, Marangoni, Darcy permeability, recoil pressure
• LevelSetPhaseChange: Interface velocity from evaporation
• MushyZoneMaterial: Linear solidification model
• DED examples with cylinder geometries

MOOSE modules relevant to TMM

27 modules available. Key ones:

• heat_transfer: Conduction, convection, radiation
• solid_mechanics: Stress, strain, plasticity, creep
• phase_field: Allen-Cahn, Cahn-Hilliard, grain growth
• navier_stokes: INS equations (melt pool)
• level_set: Free surface tracking
• stochastic_tools: UQ, surrogates, ML, active learning

Metallurgical modeling gaps

MALAMUTE/MOOSE also does not have:

• JMAK/KM phase transformation solvers
• TRIP models
• CCT/TTT diagram integration
• CALPHAD coupling (though infrastructure supports it)

However, the MOOSE infrastructure makes implementation significantly easier (see below).

ML/surrogate integration

MOOSE’s stochastic_tools module has extensive surrogate support:

• GaussianProcessSurrogate with active learning
• PODReducedBasisSurrogate
• PolynomialChaos expansion
• LibTorch integration: Load TorchScript models for inference within MOOSE simulations as surrogate material models or BCs
• Samplers: Monte Carlo, Latin Hypercube, Sobol
• Acquisition functions for active learning

Custom physics development

Adding custom physics is straightforward with ~30 pluggable interfaces:

• ADKernel, ADMaterial, ADBoundaryCondition (auto-differentiated)
• Write only the residual; Jacobian computed automatically via MetaPhysicL
• Actions bundle related physics into input-file-activated packages
• MultiApp system for nested sub-applications at different scales
• No recompilation needed for input changes (HIT input files)

Solver infrastructure

• PETSc (direct: SuperLU_dist; iterative: full KSP suite)
• Newton with line search, JFNK available
• Implicit Euler, BDF2, Crank-Nicolson, adaptive time stepping
• MPI domain decomposition via libMesh (scales to >100k cores)
• Thread-parallel assembly via TBB/OpenMP

Comparison matrix

Feature	MALAMUTE/MOOSE	adamantine
FEM library	libMesh (bundled)	deal.II
Linear algebra	PETSc (bundled)	Trilinos + Kokkos
AMR	h-refinement	h/p-refinement
Multiphysics coupling	Fully coupled, implicit	One-way thermal to mech
Melt pool CFD	Yes (INS + level set)	No
Solid mechanics	Full tensor mechanics module	Thermomechanical (J2)
JMAK/KM/TRIP	No (easy to implement)	No (hard to implement)
ML/surrogates	GP, PCE, POD, LibTorch NN	EnKF data assimilation only
GPU support	Limited (PETSc GPU backends)	Kokkos (better GPU path)
Custom physics	~30 interfaces, AD, Actions	C++ class inheritance
Input system	HIT files, no recompilation	C++ hard-coded
Community	~2.3k stars, 15+ years	~54 stars, ~5 years
License	LGPL-2.1	Apache 2.0 + LLVM

Recommendation for TMM surrogate project

Use MALAMUTE/MOOSE as the base solver. Rationale:

1. Fully coupled multiphysics: MOOSE solves all physics in one Newton system. adamantine is one-way coupled only. For TMM, you need bidirectional coupling (stress affects transformation kinetics, transformation strains affect stress).

2. Ease of custom physics: Implementing JMAK/KM/TRIP as MOOSE ADKernel/ADMaterial objects is ~100 LOC per kernel with automatic Jacobians. In adamantine, this requires surgery on the templated time-stepping loop and explicit template instantiation.

3. Built-in ML infrastructure: stochastic_tools provides GP surrogates, active learning, LibTorch integration, and UQ sampling out of the box. adamantine has only EnKF for thermal.

4. MultiApp multiscale: MOOSE’s nested sub-application system enables running microstructure models (phase-field, CA) as sub-apps at quadrature points while the macro thermal-mechanical solve runs on the parent app.

5. No recompilation for experiments: HIT input files allow rapid parameter sweeps without C++ recompilation.

What is lost by choosing MOOSE over adamantine

• Kokkos GPU portability (adamantine has better GPU path)
• Built-in EnKF data assimilation from experimental thermography
• deal.II’s hp-adaptivity (simultaneous h and p refinement)
• Lighter weight codebase (fewer dependencies)

Mitigation

• GPU: PETSc is adding GPU backends (Kokkos, CUDA, HIP). Acceptable for now.
• EnKF: Can implement within MOOSE’s stochastic_tools or use external EnKF library.
• hp-adaptivity: h-refinement in MOOSE is sufficient for AM. p-refinement is rarely needed for thermal problems.

Implementation plan with MALAMUTE

Phase 1: JMAK/KM kernels

1. Implement JMAKPhaseFraction as ADKernel for diffusional transformations (ferrite, pearlite, bainite)
2. Implement KoistinenMarburger as ADKernel for martensite
3. Couple with thermal solver via coupledVar
4. Validate against Gleeble dilatometry data

Phase 2: TRIP coupling

1. Implement LeblondTRIP as ADMaterial computing transformation plasticity strain
2. Couple phase fraction rates to mechanical solver
3. Add volume change eigenstrain from phase transformations
4. Validate against welding residual stress measurements

Phase 3: ML surrogate integration

1. Use MOOSE’s LibTorch integration for neural operator inference
2. Train GNO on MALAMUTE FEM solutions offline
3. Deploy trained model as MOOSE surrogate for accelerated prediction
4. Implement in-situ training loop using MOOSE’s time-stepping

Phase 4: Active learning pipeline

1. Use stochastic_tools active learning GP for initial sampling
2. Extend to neural operator with uncertainty-driven retraining
3. Multi-fidelity: coarse MALAMUTE mesh for exploration, fine for refinement

Key references

1. Turcksin, B. & DeWitt, S. (2024). “Adamantine 1.0.” JOSS, 9(102), 7017.
2. Gaston, D. et al. (2009). “MOOSE: A parallel computational framework.” Nuclear Engineering and Design, 239(10).
3. Franz, Patterson, Turcksin, Schmitz & Page (2026). “Computationally Inexpensive Part-Scale Thermal History.” Int. J. Advanced Manufacturing Technology. DOI: 10.1007/s00170-026-17720-7
4. Prokopenko, A., Arndt, D., Lebrun-Grandié, D. & Turcksin, B. (2025). “The ArborX Library: Version 2.0.” ACM TOMS. DOI: 10.1145/3772288