Interface Properties

The InterfaceProperties module is a cornerstone of the OpenPhase library, responsible for managing the physical properties that govern the behavior of interfaces between different phases and grains. These properties—specifically interface energy (or stiffness) and interface mobility—are crucial as they dictate the driving forces for microstructure evolution, interface morphology, and the kinetics of phase transformations.

The module provides a flexible framework for defining these properties, supporting both isotropic and complex anisotropic models for various crystal symmetries (e.g., cubic, hexagonal). The properties are defined on a pairwise basis for every interacting pair of phases $(\alpha ,\beta )$.

Key Classes and Concepts

• InterfaceEnergyModel: A class that implements various mathematical models to calculate the interface energy ${\sigma }_{\alpha \beta }$ as a function of the interface normal orientation. It distinguishes between:
  • Energy Models: The calculated value is the direct interface energy $\sigma (n)$. This is used in the driving force term for phase evolution.
  • Stiffness Models: The calculated value represents the interface stiffness, which is a combination of the energy and its second derivatives ($\sigma (n)+{\sigma }^{″}(n)$). This is used in the curvature term of the phase-field equation.
• InterfaceMobilityModel: A class that implements models for the interface mobility ${\mu }_{\alpha \beta }$, which can also depend on the interface normal orientation and temperature.
• InterfaceProperties: The main manager class. It holds an InterfaceEnergyModel and an InterfaceMobilityModel for each phase pair $(\alpha ,\beta )$. During a simulation step, its primary role is to populate a grid with the correct energy and mobility values at every point within an interface, which are then used by the solver.

Interface Energy Models

The interface energy, ${\sigma }_{\alpha \beta }(n)$, determines the energy cost per unit area of an interface with a normal vector $n$. OpenPhase implements several models:

• Isotropic (ISO): The energy is constant regardless of orientation.

$$\begin{array}{}\text{(1)}& \sigma (n)={\sigma }_0\end{array}$$

• Cubic (CUBIC, CUBICFULL): For materials with cubic crystal symmetry.
  • Stiffness Model (CUBIC):

$$\begin{array}{}\text{(2)}& \sigma (n)={\sigma }_0(1.0+{ϵ}_{E1}(1.5-2.5(n_x^4+n_y^4+n_z^4)))\end{array}$$

• Energy Model (CUBICFULL):

$$\begin{array}{}\text{(3)}& \sigma (n)={\sigma }_0(1.0+{ϵ}_{E1}(n_x^4+n_y^4+n_z^4))\end{array}$$

• Hexagonal (HEXBOETTGER, HEXSUN, HEXYANG): For materials with hexagonal symmetry, based on different formulations. For example, the Boettger model is:

$$\begin{array}{}\text{(4)}& \sigma (n)={\sigma }_0(1.0-{ϵ}_{E1}(n_x^6-n_y^6-15n_x^4{n}_y^2+15n_y^4{n}_x^2+5n_z^4-5n_z^2+n_z^6))\end{array}$$

• Faceted (FACETED, FACETEDFULL): For materials with strong faceting tendencies. The model finds the facet plane closest to the interface normal and calculates the energy based on the inclination angle $\theta$.
  • Energy Model (FACETEDFULL):

$$\begin{array}{}\text{(5)}& \sigma (\theta )={\sigma }_F\sqrt{{\sin }^2\theta +{ϵ}_{EF}^2{\cos }^2\theta }\end{array}$$

where ${\sigma }_F$ and ${ϵ}_{EF}$ are the energy and anisotropy parameter of the closest facet family.

Interface Mobility Models

The interface mobility, ${\mu }_{\alpha \beta }(n,T)$, scales the rate of interface migration in response to a driving force. It can be anisotropic and temperature-dependent.

The temperature dependence follows an Arrhenius law, where $Q_m$ is the activation energy:

$$\begin{array}{}\text{(6)}& \mu (n,T)={\mu }_{\text{aniso}}(n)\cdot \exp (-\frac{Q_m}{RT})\end{array}$$

The anisotropic part, ${\mu }_{\text{aniso}}(n)$, is described by models analogous to those for interface energy:

• Isotropic (ISO):

$$\begin{array}{}\text{(7)}& {\mu }_{\text{aniso}}(n)={\mu }_0\end{array}$$

• Cubic (CUBIC):

$$\begin{array}{}\text{(8)}& {\mu }_{\text{aniso}}(n)={\mu }_0(1.0-{ϵ}_{M1}(1.5-2.5(n_x^4+n_y^4+n_z^4)))\end{array}$$

• Hexagonal (HEXBOETTGER, HEXSUN, HEXYANG): These models use the same functional forms as their energy counterparts but with mobility parameters (${\mu }_0$, ${ϵ}_{M1}$, etc.).

• Faceted (FACETED):

$$\begin{array}{}\text{(9)}& {\mu }_{\text{aniso}}(n)={\mu }_F({ϵ}_{MF}+(1.0-{ϵ}_{MF})|\tan (\theta )|\tanh (|\tan (\theta ){|}^{-1}))\end{array}$$

where $\theta$ is the inclination angle to the nearest facet, and ${\mu }_F$ and ${ϵ}_{MF}$ are the facet mobility and its anisotropy parameter.

Usage

Input

Interface properties are defined in the InterfaceProperties block of the input file (.opi or .json). Parameters are specified for each pair of phases, identified by _alpha_beta. For example, _0_0 refers to the interface between grains of Phase 0 (a grain boundary), while _0_1 refers to the interface between Phase 0 and Phase 1.

Here is an example .opi configuration for a two-phase system:

@InterfaceProperties
// --- Grain boundaries within Phase 0 (isotropic) ---
$EnergyModel_0_0 Interface energy model : ISO
$Sigma_0_0 Interface energy : 0.5 // [J/m^2]

$MobilityModel_0_0 Interface mobility model : ISO
$Mu_0_0 Interface mobility : 1.0e-8 // [m^4/(J*s)]
$Q_0_0 Activation energy for mobility : 150000 // [J/mol]

// --- Interface between Phase 0 and Phase 1 (anisotropic) ---
$EnergyModel_0_1 Interface energy model : CUBIC
$Sigma_0_1 Interface energy : 0.8
$EpsilonE_0_1 Energy anisotropy parameter : 0.1

$MobilityModel_0_1 Interface mobility model : CUBIC
$Mu_0_1 Interface mobility : 5.0e-9
$EpsilonM_0_1 Mobility anisotropy parameter : -0.2
$Q_0_1 Activation energy for mobility : 200000

Output

The InterfaceProperties module can generate VTK files (.vts) for visualization. If enabled, it will output fields representing the spatially-resolved, averaged interface energy (or stiffness) and mobility at all points within interfaces. This is useful for debugging and analyzing the effect of anisotropy on the simulation.

Example

The following example demonstrates how to set up and use the InterfaceProperties class in a typical simulation loop. It builds on the grain growth example by introducing anisotropy.

#include "Settings.h"
#include "RunTimeControl.h"
#include "DoubleObstacle.h"
#include "PhaseField.h"
#include "Initializations.h"
#include "BoundaryConditions.h"
#include "InterfaceProperties.h"
#include "Temperature.h"

using namespace std;
using namespace openphase;

int main(int argc, char *argv[])
{
    // --- Standard Initialization ---
    std::string InputFile = (argc > 1) ? argv[1] : "ProjectInput.opi";
    
    Settings            OPSettings;
    OPSettings.ReadInput(InputFile);

    RunTimeControl      RTC(OPSettings, InputFile);
    PhaseField          Phi(OPSettings, InputFile);
    DoubleObstacle      DO(OPSettings, InputFile);
    InterfaceProperties IP(OPSettings, InputFile);
    BoundaryConditions  BC(OPSettings, InputFile);
    Temperature         Tx(OPSettings, InputFile);

    // --- Initial Microstructure ---
    // For anisotropy, grains need initial orientations
    int number_of_grains = 100;
    size_t GrainsPhase = 0;
    Initializations::VoronoiTessellation(Phi, BC, number_of_grains, GrainsPhase);
    Initializations::RandomOrientations(Phi);

    // --- Main Time Loop ---
    std::cout << "Entering the Time Loop!!!" << std::endl;
    for(RTC.tStep = RTC.tStart; RTC.tStep <= RTC.nSteps; RTC.IncrementTimeStep())
    {
        // Calculate and set interface properties for the current timestep.
        // This function iterates over all interface points, determines the local
        // interface normal, calculates the orientation-dependent energy and mobility,
        // and stores the values in an internal grid.
        // The version with Temperature also applies the Arrhenius law.
        IP.Set(Phi, Tx, BC);

        // The solver uses the pre-calculated properties from IP to compute phase-field increments.
        DO.CalculatePhaseFieldIncrements(Phi, IP);
        
        Phi.NormalizeIncrements(BC, RTC.dt);
        Phi.MergeIncrements(BC, RTC.dt);

        // --- Output ---
        if (RTC.WriteVTK())
        {
            Phi.WriteVTK(OPSettings, RTC.tStep);
            IP.WriteVTK(OPSettings, RTC.tStep); // Output energy and mobility fields
        }
        // ... other outputs
    }
    return EXIT_SUCCESS;
}

See also: examples

• NormalGG (OpenPhase-main/examples/NormalGG/) — isotropic interface energy / mobility (ISO).
• FacetedGG — FACETED / FACETEDFULL anisotropy.
• SolidificationFeC, SolidificationNiAl — anisotropic interfaces between two solidification phases.

Dependencies

• PhaseField — fields and increments the energy / mobility values are evaluated against.
• DoubleObstacle — primary consumer; takes InterfaceProperties& in its CalculatePhaseFieldIncrements calls.
• BoundaryConditions — applied during IP.Set(Phi, BC).
• Temperature — supplies $T(\mathbf{x})$ for the Arrhenius mobility (IP.Set(Phi, Tx, BC)).
• Settings — phase list and grid metadata.
• InterfaceRegularization — optional stabiliser when interface profiles distort under strong driving forces.