# Phase-Field Fracture Models in PhaseFieldX: Isotropic vs Anisotropic Formulations Explained

> Explore isotropic vs anisotropic phase-field fracture models in PhaseFieldX. Understand key differences in degradation, energy splits, and crack functions to choose the right model for your simulation.

- Repository: [Miguel Castillón/phasefieldx](https://github.com/castillonmiguel/phasefieldx)
- Tags: deep-dive
- Published: 2026-02-26

---

**PhaseFieldX implements multiple phase-field fracture models that differ primarily in degradation type (isotropic vs anisotropic), energy split methods (spectral vs deviatoric), geometric crack functions (AT2, AT1, WU, DOUBLE), and stiffness degradation functions, all configurable through the `Input` class.**

The `castillonmiguel/phasefieldx` repository provides a comprehensive finite element framework for simulating brittle and quasi-brittle failure using phase-field methods. Understanding the available fracture models is essential for accurately capturing material behavior under tension, compression, or cyclic loading, as each formulation handles energy degradation and crack regularization differently.

## Degradation Type: Isotropic vs Anisotropic Fracture Models

The fundamental distinction between fracture models in PhaseFieldX lies in how the **degradation function** `g(φ)` reduces elastic stiffness as the phase-field variable `φ` evolves from 0 (intact material) to 1 (fully broken).

### Isotropic Degradation

In the **isotropic** formulation, the degradation function multiplies the **entire** elastic energy density `ψ(ε(u))`. Both tensile and compressive stiffness degrade equally as damage progresses, which can lead to crack growth under compressive loading. The implementation in [`split_energy_stress_tangent_functions.py`](https://github.com/castillonmiguel/phasefieldx/blob/main/split_energy_stress_tangent_functions.py) handles this by returning the full strain energy without decomposition:

```python
if DataSimulation.degradation == "isotropic":
    return psi(u, DataSimulation.lambda_, DataSimulation.mu)

```

### Anisotropic Degradation

The **anisotropic** formulation degrades only the **tensile** part of the strain energy, leaving the compressive component intact. This prevents non-physical crack growth under compression and is essential for modeling concrete, rock, or ceramic materials. The code splits the energy into positive (`ψ_a`) and negative (`ψ_b`) parts based on the selected split method:

```python
elif DataSimulation.degradation == "anisotropic":
    if DataSimulation.split_energy == "spectral":
        return psi_a_spectral(u, ...)
    elif DataSimulation.split_energy == "deviatoric":
        return psi_a_deviatoric(u, ...)

```

## Energy Split Methods for Anisotropic Models

When using anisotropic degradation, you must specify how to decompose the strain energy into tensile and compressive components. PhaseFieldX provides two distinct approaches in [`split_energy_stress_tangent_functions.py`](https://github.com/castillonmiguel/phasefieldx/blob/main/split_energy_stress_tangent_functions.py).

### Spectral Decomposition

The **spectral** split eigen-decomposes the strain tensor into principal strains. Only positive eigenvalues contribute to the tensile energy `ψ_a`, while negative eigenvalues define the compressive energy `ψ_b`. This approach accurately captures mixed-mode fracture behavior but requires computing eigenvalues and eigenprojectors at each quadrature point.

Implemented in `psi_a_spectral` and `psi_b_spectral` (lines 34-62), this method handles the full spectral decomposition of the strain tensor.

### Deviatoric Split

The **deviatoric** split separates the strain into volumetric and deviatoric parts, taking the positive deviatoric component as the tensile energy. While computationally less expensive than spectral decomposition, this method may produce slightly different results for certain mixed-mode loading states. Both methods yield identical results under pure tension.

The deviatoric implementation appears in `psi_a_deviatoric` and `psi_b_deviatoric` (lines 84-112).

## Geometric Crack Functions

The **geometric crack function** `w(φ)` regularizes the crack surface and determines the profile of the phase-field across the crack. PhaseFieldX supports four variants defined in [`geometric_crack.py`](https://github.com/castillonmiguel/phasefieldx/blob/main/geometric_crack.py):

- **AT2**: Quadratic function `φ²` (default, produces smooth crack profiles)
- **AT1**: Linear function `φ` (yields sharper cracks)
- **WU**: Williams-Urbistondo `2φ - φ²` (intermediate behavior)
- **DOUBLE**: Double-well `16φ²(1-φ)²` (alternative regularization)

Each function has an associated coefficient `c₀` that scales the crack surface energy. The selection occurs in `geometric_crack_function` (lines 24-33) and `geometric_crack_coefficient` (lines 63-71).

## Stiffness Degradation Functions

Beyond the isotropic/anisotropic distinction, PhaseFieldX offers multiple functional forms for the **degradation function** `g(φ)` that controls how stiffness reduces with damage. These are implemented in [`g_degradation_functions.py`](https://github.com/castillonmiguel/phasefieldx/blob/main/g_degradation_functions.py):

- **Quadratic**: `(1-φ)²` (standard formulation)
- **Borden**: Modified quadratic with different convexity properties
- **Alessi**: Alternative form for specific crack nucleation behavior
- **Sargado**: Specialized variant for particular applications

The functions and their derivatives (`dg/dφ`) are defined in lines 12-46 for `g` and lines 53-71 for `dg`.

## Fatigue Degradation Models

For cyclic loading scenarios, PhaseFieldX includes optional **fatigue degradation** that further reduces the crack-driving energy based on accumulated history. When `Data.fatigue=True`, the framework applies an additional fatigue function `f(α̅)` to the degradation term.

Currently, the repository implements an **asymptotic fatigue law** defined in [`fatigue_degradation_functions.py`](https://github.com/castillonmiguel/phasefieldx/blob/main/fatigue_degradation_functions.py) (lines 19-27). Users specify the critical value `fatigue_val` (denoted `α̅_c` in the theory) to control the fatigue threshold.

## Configuring Fracture Models in PhaseFieldX

All fracture model options are exposed through the **`Input`** class, which serves as the central configuration interface. The solver reads these flags during weak form assembly in [`solver_ener_variational.py`](https://github.com/castillonmiguel/phasefieldx/blob/main/solver_ener_variational.py).

### Anisotropic Spectral AT2 Configuration

```python
from phasefieldx.Element.Phase_Field_Fracture.Input import Input

sim = Input(
    degradation="anisotropic",
    split_energy="spectral",
    degradation_function="quadratic",
    case="AT2",
    fatigue=False,
)

```

### Isotropic AT1 with Borden Degradation

```python
sim = Input(
    degradation="isotropic",
    split_energy="no",
    degradation_function="borden",
    case="AT1"
)

```

### Fatigue-Enabled Anisotropic Model

```python
sim = Input(
    degradation="anisotropic",
    split_energy="spectral",
    fatigue=True,
    fatigue_degradation_function="asymptotic",
    fatigue_val=0.056
)

```

The `Input` class definition (lines 31-34 in [`Input.py`](https://github.com/castillonmiguel/phasefieldx/blob/main/Input.py)) documents these attributes, while the solver logic consumes them to assemble the appropriate weak form using the selected fracture model components.

## Summary

- **PhaseFieldX** provides multiple phase-field fracture models configurable via the `Input` class in [`src/phasefieldx/Element/Phase_Field_Fracture/Input.py`](https://github.com/castillonmiguel/phasefieldx/blob/main/src/phasefieldx/Element/Phase_Field_Fracture/Input.py).
- **Degradation type** determines whether the entire elastic energy degrades (isotropic) or only the tensile component (anisotropic), with the latter preventing crack growth under compression.
- **Energy split methods** (spectral vs deviatoric) define how tensile energy is computed for anisotropic models, with spectral decomposition providing higher accuracy for mixed-mode fracture.
- **Geometric crack functions** (`AT2`, `AT1`, `WU`, `DOUBLE`) control crack regularization and surface energy scaling through the [`geometric_crack.py`](https://github.com/castillonmiguel/phasefieldx/blob/main/geometric_crack.py) module.
- **Stiffness degradation functions** (`quadratic`, `borden`, `alessi`, `sargado`) vary how material stiffness reduces with damage evolution.
- **Fatigue models** (asymptotic) enable cyclic loading simulations by introducing history-dependent degradation via [`fatigue_degradation_functions.py`](https://github.com/castillonmiguel/phasefieldx/blob/main/fatigue_degradation_functions.py).

## Frequently Asked Questions

### What is the difference between isotropic and anisotropic phase-field fracture models?

**Isotropic models** degrade the entire elastic energy density uniformly as damage progresses, meaning both tensile and compressive stiffness reduce equally. **Anisotropic models** only degrade the tensile part of the strain energy, leaving the compressive component intact to prevent non-physical crack growth under compression. In PhaseFieldX, this is controlled by the `degradation` parameter in the `Input` class, with the implementation residing in [`split_energy_stress_tangent_functions.py`](https://github.com/castillonmiguel/phasefieldx/blob/main/split_energy_stress_tangent_functions.py).

### When should I use spectral versus deviatoric energy splitting?

Use **spectral decomposition** when simulating mixed-mode fracture where accurate separation of tensile and compressive principal strains is critical, as it eigen-decomposes the strain tensor to identify positive and negative principal values. Use **deviatoric splitting** for computational efficiency in problems dominated by shear or when avoiding the computational cost of eigenvalue calculations is necessary, though results may differ slightly from spectral methods under complex loading states. Both methods are implemented in [`split_energy_stress_tangent_functions.py`](https://github.com/castillonmiguel/phasefieldx/blob/main/split_energy_stress_tangent_functions.py) via `psi_a_spectral` and `psi_a_deviatoric`.

### How do I select the AT1 versus AT2 geometric crack function?

Set the `case` parameter in your `Input` object to `"AT1"` for linear crack regularization (`w(φ) = φ`) or `"AT2"` for quadratic regularization (`w(φ) = φ²`). AT2 is the default and produces smoother crack profiles suitable for most brittle fracture simulations, while AT1 yields sharper cracks with different surface energy scaling through the coefficient `c₀`. These functions are defined in [`geometric_crack.py`](https://github.com/castillonmiguel/phasefieldx/blob/main/geometric_crack.py) in the functions `geometric_crack_function` and `geometric_crack_coefficient`.

### Can I combine fatigue degradation with anisotropic fracture models?

Yes, PhaseFieldX supports combining **fatigue degradation** with both isotropic and anisotropic formulations. Enable this by setting `fatigue=True` in your `Input` object and specifying the fatigue law (currently only `"asymptotic"` is available) along with the critical value `fatigue_val` (denoted `α̅_c`). The fatigue function `f(α̅)` multiplies the standard degradation term `g(φ)` to reduce crack-driving energy based on accumulated cyclic history, as implemented in [`fatigue_degradation_functions.py`](https://github.com/castillonmiguel/phasefieldx/blob/main/fatigue_degradation_functions.py).