morphogen.fracture.phasefield

Brittle fracture of voxel images by the phase-field method: cracks that start, branch and merge in a periodic microstructure without being meshed or tracked.

A field d (0: sound, 1: broken) regularizes the cracks over the length l (Francfort & Marigo 1998; Bourdin, Francfort & Marigo 2000): the energy of the cell is

E(u, d) = int g(d) psi(eps(u)) dV + int G_c gamma(d, grad d) dV, g(d) = (1 - d)^2 + k,

with the crack density gamma = d^2 / (2 l) + l |grad d|^2 / 2 (the model AT2: the damage grows from the first load) or gamma = 3/8 (d / l + l |grad d|^2) (AT1: elastic up to the stress sqrt(3 G_c E / (8 l)) in uniaxial tension), whose integral tends to the area of the cracks as l vanishes: the work to break the cell is the toughness G_c times that area, whatever the voxels, provided they resolve l (linear elements over-estimate it by the factor 1 + h / (2 l), h their size: at least two voxels per length).

The problem is solved by alternate minimization (Bourdin et al. 2000): at each step of a loading path, until the damage no longer moves,

  1. the displacement at fixed damage: the periodic elastic problem of the voxels of the FFT solver (morphogen.homogenization.fft), each voxel with its stiffness times g of its damage (conjugate gradients preconditioned in Fourier space, the reference medium scaled by the degradation of the nodes; the macroscopic components prescribed as stresses are condensed);

  2. the damage at fixed displacement: (G_c / l + 2 psi+) d - G_c l lap(d) = 2 psi+ (AT2) with psi+ the tensile energy of each voxel, under the bound that the damage does not decrease (irreversibility, by a primal-dual active set: the obstacle problem of AT1, whose damage is zero below its elastic limit and whose cracks have the finite width 4 l); trilinear elements with a lumped reaction, conjugate gradients. With irreversibility="history" the bound is replaced by the largest psi+ reached at each voxel (the history field of Miehe, Hofacker & Welschinger 2010): simpler, but it widens the cracks and over-estimates their energy.

The stress is degraded as a whole (sigma = g(d) C : eps: the hybrid formulation of Ambati, Gerasimov & De Lorenzis 2015, linear at fixed damage) while the energy that drives the damage is its tensile part only: all of it (split="none"), the spectral split of Miehe et al. ("spectral": lambda <tr eps>+^2 / 2 + mu sum <eps_i>+^2, by default) or the volumetric one of Amor et al. ("volumetric": K <tr eps>+^2 / 2 + mu dev eps : dev eps), so that compression does not break. Each phase has its toughness; the phases without one do not break (their stiffness is not degraded), the voids carry neither stress nor cracks. Initial cracks are voxels given as broken: the damage of their nodes is held at 1.

The results are those of a loading path (the macroscopic stress and strain in time), with the mean damage, the regularized area of the cracks and the energies; the strength of the cell (its largest stress) and its work of fracture are quantities for the statistics of representative volumes (PhaseFieldResult.strength(), PhaseFieldResult.work()).

In finite strains (rubbers, foams, soft tissues): morphogen.fracture. phasefield_finite, the same damage problem with the energy of the deformation gradient and the nonlinear FFT solver for the displacement.

morphogen.fracture.phasefield.MODELS = ('AT2', 'AT1')

(c_w, the local term) of gamma = (w(d) / l + l |grad d|^2) / c_w

Type:

Models of the crack density

morphogen.fracture.phasefield.SPLITS = ('spectral', 'volumetric', 'none')

Splits of the energy that drives the damage

class morphogen.fracture.phasefield.PhaseField(toughness: float | dict, length: float, model: str = 'AT2', split: str = 'spectral', residual: float = 1e-06, irreversibility: str = 'bound')[source]

Bases: object

The fracture of the phases of a sample: toughness, the critical energy release rate G_c of all the phases (one value) or of each (a mapping phase -> G_c; the phases left out do not break), the regularization length l (at least two voxels), the model (MODELS), the split of the driving energy (SPLITS), the residual stiffness k of a broken voxel and the irreversibility: "bound" (the damage of each node never decreases) or "history" (the largest driving energy reached; see the module).

classmethod from_config(spec) → PhaseField[source]

A mapping of the parameters of PhaseField.

of(phase: int) → float | None[source]

The toughness of a phase (None: it does not break).

critical_stress(modulus: float) → float[source]

The largest stress of a homogeneous bar of modulus modulus (that of its loading: Young’s modulus in uniaxial stress) and of this toughness (one value): 9/16 sqrt(E G_c / (3 l)) (AT2), sqrt(3 E G_c / (8 l)) (AT1).

class morphogen.fracture.phasefield.PhaseFieldResult(name: str, bc: str, path: LoadingPath, times: ndarray, strain: ndarray, stress: ndarray, temperature: ndarray, plastic: ndarray, phases: dict = <factory>, iterations: ndarray = <factory>, info: dict = <factory>, fields: dict = <factory>, support: object | None = None, kinematics: str = 'small', cauchy: ndarray | None = None, log_strain: ndarray | None = None, porosity: ndarray | None = None, series: dict = <factory>, scalars: dict = <factory>, orientation: ndarray | None = None, damage: ndarray | None = None, crack_surface: ndarray | None = None, elastic_energy: ndarray | None = None, fracture_energy: ndarray | None = None)[source]

Bases: PathResult

The response of a cell that breaks along a loading path: a PathResult (the macroscopic strain and stress at the times; its variable plastic is the mean damage of the phases that break, as that of each phase in phases) with the damage (the same), the regularized area of the cracks per unit volume (crack_surface), the elastic and fracture energies per unit volume, and the alternate minimizations of each step (iterations). With fields: the damage, strain and stress of the voxels at chosen times. strength() is the strength of the cell and work() the work done on it: with the stored energy released, more than the fracture energy when the cell breaks at once (the cracks of a brittle cell run faster than its loading).

class morphogen.fracture.phasefield.PhaseFieldProblem(image: VoxelImage, materials: dict[int, Material], fracture, *, initial=None, grains=None, orientations=None, tol: float = 1e-07, staggered_tol: float = 0.001, max_staggered: int = 200)[source]

Bases: object

The brittle fracture of a periodic voxel image (see the module): materials of its phases (elastic; the crystals turned by the orientations of their grains), fracture (PhaseField, or a mapping of its parameters), initial: the voxels broken from the start (a boolean array of the shape of the image). tol: the relative residual of the conjugate gradients; staggered_tol: the largest change of the damage that ends the alternate minimization of a step, of at most max_staggered iterations.

fixed

those of the voxels broken from the start

Type:

the nodes held at d = 1

degradation(d: ndarray | None = None) → ndarray[source]

g of each voxel for the nodal damage d (the current one by default): 1 in the phases that do not break.

crack_surface(d: ndarray | None = None, weight: ndarray | None = None) → float[source]

The regularized area of the cracks, int gamma(d, grad d) dV over the phases that break; with weight (the toughness of the voxels), the fracture energy.

run(path, *, name: str = 'path', fields=False, monitor=None) → PhaseFieldResult[source]

Follow a loading path (LoadingPath, or a mapping for it; its components prescribed as strains or as stresses, with a change of temperature): PhaseFieldResult. fields: true for the damage, strain and stress of the voxels at the end of each segment of the path, "steps" at the end of each step, or a list of times of its steps. monitor(time, records so far) after each step; a true value ends the path there.

morphogen.fracture.phasefield.phase_field_fracture(image: VoxelImage, materials: dict[int, Material], fracture, path, *, name: str = 'path', fields=False, kinematics: str = 'small', **options) → PhaseFieldResult[source]

The response of a periodic voxel image that breaks along a loading path: a PhaseFieldProblem (its options: initial, grains, orientations, tol, staggered_tol, max_staggered) run along path; with kinematics="finite", in finite strains (FinitePhaseFieldProblem: hyperelastic or elastic phases, nominal strains and stresses, its options).