Fracture, contact and fatigue¶
Microstructures break along loading paths, up to fracture. Cracks nucleate and merge in voxel images (the phase field, in small or finite strains), or grow in meshes (stress intensity factors, cohesive zones), through polycrystals and any morphology. Surfaces touch and rub (contact, self-contact and Coulomb’s friction): the walls of the pores of a cell that densifies, a sample between platens or under an indenter. The interfaces of the phases of a cell debond along a path (cohesive zones on its torus). The stresses of a cycle are judged by criteria of multiaxial fatigue (Crossland, Sines, Dang Van, Findley, Matake): where a cell would start to crack, and its factor of safety. The tutorial on fracture and the tutorial on contact and damage follow these steps on small problems; the damage of the phases themselves (crack bands, Lemaitre, Mazars) and the micromorphic damage are behaviours (Behaviours along loading paths).
Phase field of fracture¶
The phase field of brittle fracture runs on voxel images (homogenize(..., fracture=...): AT1 and AT2, a toughness per phase; in finite strains with
nonlinear: {kinematics: finite}, for hyperelastic phases), beside the cracks, cohesive
zones and ductile damage of morphogen.fracture. In a configuration,
homogenization.fracture ({toughness: ..., length: ...}) makes the loading paths
break the voxels by the phase-field method; the
tutorial on a rubber tears a cracked strip at the stretch of Rivlin
and Thomas, and the guide to the physics compares the routes.
Cohesive zones and cracks¶
morphogen.fracture opens the interfaces of a tetrahedral mesh (between phases, or
along chosen faces) and gives them cohesive zone elements, in small or finite strains:
from morphogen.fracture import Bilinear, CohesiveProblem, insert_interfaces
opened, interfaces = insert_interfaces(mesh, "phases") # debonding of the particles
law = Bilinear(
stiffness=1e5,
normal_strength=30.0,
shear_strength=40.0,
mode_I=0.3,
mode_II=0.6,
eta=2.0, # Benzeggagh-Kenane mixity
)
problem = CohesiveProblem(opened, interfaces, materials, law, kinematics="finite")
result = problem.run(
[(bottom, [0, 1, 2], 0.0), (top, 2, 1.0)], load=0.05, steps=50, viscosity=1e-4, fields=True
)
problem.write("debonding", result) # the bulk and the interfaces (damage), VTU
Laws: bilinear mixed-mode and the exponential law of Ortiz & Pandolfi; helpers: the
length of the cohesive zone, the strength of coarse meshes (Turon et al.), the double
cantilever beam (dcb_specimen) and its corrected beam theory (dcb_beam_theory).
Cracks (morphogen.fracture.lefm): planar cracks by level sets, their energy release
rate on conforming meshes remeshed at each step (MMG, as Z-cracks) or by XFEM (jump and
branch enrichments of linear tetrahedra), and their growth by Paris’ law or Griffith:
from morphogen.fracture import Crack, propagate, xfem_work
crack = Crack("penny", centre, normal=(0, 0, 1), size=2.0)
growth = propagate(
xfem_work(mesh, material, forces, supports),
crack,
young=E,
poisson=nu,
increment=0.5,
steps=10,
paris=(C, m),
)
Mixed modes, in small or finite strains (morphogen.fracture.mixed): the energy release
rate along the front by the G-θ method (exact for the neo-Hookean body of finite strains),
the factors of modes I, II and III by interaction integrals, the frictionless contact of
the lips, and kinked cracks remeshed by MMG at each step, growing in the direction of
Erdogan & Sih:
from morphogen.fracture import KinkedCrack, crack_mesh, propagate_kinked, solve_crack
solution = solve_crack(
mesh, crack, material, supports, forces=loads, kinematics="finite", contact=True
)
modes = solution.modes(stations=5) # K_I, K_II, K_III, G, G_I, G_II, G_III along the front
crack = KinkedCrack(((0.0, 16.0, 0.0), (4.5, 16.0, 0.0))) # mouth to front, front along z
growth = propagate_kinked(
lambda c: crack_mesh(lower, upper, c, size=0.5),
crack,
material,
supports,
forces=loads,
increment=1.5,
steps=10,
paris=(C, m),
)
Cracks of any surface and front (morphogen.fracture.surface): the surface swept by the
successive positions of a front, closed (a crack inside the body) or open (through, edge
and surface cracks), each point of which advances by its own amount and kinks by its own
angle; the mesh is refined around the front alone:
from morphogen.fracture import SurfaceCrack, crack_mesh, propagate_front
crack = SurfaceCrack.ellipse(centre, normal=(0.5, 0, 0.87), a=1.0, b=0.6) # inclined
mesh_of = lambda c: crack_mesh(lower, upper, c, size=0.6, front_size=0.08)
growth = propagate_front(
mesh_of,
crack,
material,
supports,
forces=loads,
increment=0.3,
steps=5,
stations=12,
paris=(C, m),
)
growth.rows() # per step: area, K_I, K_II, K_III along the front, kink angles, cycles
growth.cracks[-1].points # rows x stations x 3: the surface, its last row the front
Inelastic solids (morphogen.fracture.bulk): the crack solvers take the behaviours of
morphoGen’s points as their bulk (von Mises elasto-viscoplasticity, with Hencky’s
logarithmic strains in finite strains; crystal plasticity with the orientations of the
grains; MFront laws) and give the driving forces of dissipative solids:
steel = Material(
young=210e3,
poisson=0.3,
plasticity={"yield": 300.0, "hardening": 1e3, "norton": {"K": 50.0, "n": 5.0}},
)
solution = solve_crack(mesh, crack, steel, grips, kinematics="finite", steps=20)
solution.release_rate(energy="work") # the J of the deformation theory (Begley-Landes)
solution.release_rate(energy="tip") # the driving force at the tip (configurational forces)
# the grain boundaries
opened, boundaries = insert_interfaces(
polycrystal, faces=lambda c: c[:, 0] > -1e9, sides=polycrystal.cell
)
problem = CohesiveProblem(opened, boundaries, {0: crystal}, law, kinematics="finite")
result = problem.run(grips, 0.02, steps=40, duration=1.0) # result.work: loads, bulk, interfaces
Ductile growth on meshes rebuilt at each advance (morphogen.fracture.ductile): the state
of the points (internal variables, dissipated energy, stresses) and the displacement move
from mesh to mesh, the lips apart, the body is brought back to equilibrium, and the crack
advances when its driving force at the tip reaches a toughness, or the porosity of its GTN
points a critical value; the far J at each advance draws the resistance curve:
from morphogen.fracture import KinkedCrack, crack_mesh, propagate_ductile, solve_crack
growth = propagate_ductile(
lambda c: crack_mesh(lower, upper, c, size=1.0),
crack,
steel,
grips,
load_step=0.25,
increment=1.5,
steps=5,
toughness=30.0,
kinematics="finite",
transfer="nearest",
)
advance, resistance = growth.resistance() # the R-curve (far J against the advance)
moved = solve_crack(new_mesh, longer_crack, steel, grips, 1.2, initial=solution) # one transfer
A polycrystal grows its crack through its grains: the crack meshes carry the grains of a tessellation and their orientations, and the state of each grain moves within the grain from one mesh to the next:
mesh_of = lambda c: crack_mesh(lower, upper, c, size=0.4, grains=tessellation)
growth = propagate_ductile(
mesh_of,
KinkedCrack(((0, 4, 0), (2.5, 4, 0))),
crystal,
grips,
load_step=1e-3,
increment=1.0,
steps=3,
toughness=0.6,
)
Any morphology can be cracked: the crack meshes carry its phases (the materials, in
mesh.phase) and the sides of the crack apart (mesh.side), as staircases or conforming
to the level set of a two-phase morphology (MMG cuts the grid along it once, then each
crack cuts that mesh and remeshes it), its void phases left out. Stiff inclusions deflect
the crack, soft ones and pores attract it, and a front reaching a pore runs through it;
the state of inelastic points moves material by material:
from morphogen.fracture import phase_mesh
phases = phase_mesh(micro, lower, upper, 0.5) # cut along its level set, once
mesh_of = lambda c: crack_mesh(lower, upper, c, size=0.5, morphology=phases, voids=[1])
growth = propagate_kinked(
mesh_of,
crack,
{0: matrix, 1: Material(void=True)},
held,
forces=tension,
increment=0.75,
steps=4,
)
The phases and their interfaces have toughnesses of their own: each advance is the
candidate of the largest G(θ)/Γ(θ), the kink of the bulk or a path along an interface
met within an increment (the first-order kinked factors of Cotterell & Rice), so that a
crack turns along interfaces weaker than about a quarter of the phases (He & Hutchinson),
climbs a staircase through the weak boundaries of a brick-and-mortar structure, and
needs a higher load to enter a tough phase:
from morphogen.fracture import Toughness
growth = propagate_kinked(
mesh_of,
crack,
{0: mortar, 1: tablets},
held,
forces=tension,
increment=0.5,
steps=6,
toughness=Toughness({0: 1.0, 1: 4.0}, interfaces=0.2),
)
growth.rows() # each advance: path (bulk or interface), G / toughness, critical load
Interfaces that debond¶
The interfaces of the phases of a periodic cell (or the boundaries of its grains) open, break, close again and rub along a loading path (theory notes §84): cohesive interface elements inserted on the torus of the cell, so that an interface that crosses a face goes on in the next cell.
from morphogen.fracture import Bilinear, CohesiveCell
law = Bilinear(
stiffness=1e7,
normal_strength=30.0,
shear_strength=30.0,
mode_I=0.05,
mode_II=0.05,
friction=0.3,
)
cell = CohesiveCell(mesh, materials, law, viscosity=0.02) # faces="phases", "grains", pairs
res = cell.run({"times": [0, 1, 2], "increments": [24, 8], "strain": {"11": [0, 0.03, 0]}})
res.stress, res.series["debonded_area"], res.series["interface_opening"]
In a configuration, homogenization: {nonlinear: {interfaces: {normal_strength: 30, mode_I: 0.05, friction: 0.3, viscosity: 0.02}}} (the template
homogenization_debonding: glass beads that debond from their matrix, soft in tension
and nearly whole again in compression); on the command line, morphogen homogenize ... --interfaces normal_strength:30,mode_I:0.05,friction:0.3,viscosity:0.02. A bead lets go
at once: the viscosity (a time of the path) slows the damage and lets the steps
through. Each pair of phases may have its law ({(0, 1): law, (0, 2): other}; laws: {0-1: {...}}), and faces: grains makes the grain boundaries of a polycrystal cohesive (the
template homogenization_intergranular: a crack crosses the cell from boundary to
boundary, and the work that broke it is the fracture energy times the area of the
crack). The fields of the path map the damage and the opening of the interfaces. In the
graphical interface, the box Interfaces of the tool Loading path of a morphology.
Contact, self-contact and friction¶
morphogen.contact keeps the surfaces of a mesh out of each other, out of themselves and
out of rigid obstacles, with Coulomb’s friction, in small or finite strains
(theory notes §82): the integration points of the faces against the
nearest point of the surface that they face, a penalty or the augmented Lagrangian;
with points="nodes", the nodes of the faces instead, for bodies that meet by their
corners and edges.
from morphogen.contact import ContactProblem, Obstacle, Pair, Surface
skin = Surface.of(mesh) # the free faces of the mesh
walls = Pair(skin, friction=0.3) # a surface against itself
punch = Obstacle.sphere(skin, centre, radius, motion=(0, 0, -0.1))
problem = ContactProblem(mesh, materials, [walls], [punch])
result = problem.run(prescribed, steps=20) # forces, areas, pressures, works
The walls of the pores of a periodic cell close on themselves, and on their images
through the faces of the cell, along a loading path (ContactCell; in a configuration,
homogenization: {nonlinear: {contact: {friction: 0.3}}}; the template
homogenization_contact). Two tests come ready-made: a sample between two platens, and
under an indenter, whose force reads its modulus:
from morphogen.contact import compression, indentation
crush = compression(mesh, materials, -0.2, friction=0.1) # stress against strain
crush.modulus, crush.tangent(), crush.self_area # stiffer as the walls close
dent = indentation(mesh, materials, 0.05, indenter="sphere", radius=10.0, unload=True)
dent.modulus, dent.layer_modulus(poisson=0.3), dent.hardness # Hertz; with the base
morphogen compress foam.json --size 0.2 --material 0=void 1=young:1000,poisson:0.3 \
--strain -0.3 --friction 0.1 --fields crushed
morphogen indent block.vtu --material 0=young:1000,poisson:0.3 --depth 0.05 --radius 10 \
--unload --poisson 0.3
High-cycle fatigue¶
In the high-cycle regime a cell stays elastic, and whether a point lasts is read from the cycle of its stress (theory notes §85): the amplitude of its deviator (the radius of the smallest hypersphere that holds its path) and a normal or hydrostatic stress, in a criterion calibrated on two fatigue limits of the phase.
from morphogen.homogenization import DangVan, homogenize, path_fatigue
cycle = {"times": [0, 1, 2, 3], "increments": [1, 2, 2], "stress": {"11": [0, 40, -40, 40]}}
out = homogenize(mesh, materials, properties=[], paths={"cycle": cycle}, fields="steps")
alloy = DangVan.from_limits(bending=110.0, torsion=80.0) # or Crossland, Sines, Findley, Matake
res = path_fatigue(out["cycle.periodic"], {0: alloy}, cycle=(1, 3)) # a criterion per phase
res.utilization # of each point: its equivalent stress over its limit
res.largest, res.safety, res.fraction() # of the cell; the share of its volume beyond the limit
In a configuration, homogenization: {fatigue: {criterion: dang_van, bending: 110, torsion: 80, cycle: [1, 3]}} writes the map of the utilization beside the curve of the
path and adds fatigue_utilization, fatigue_safety and fatigue_beyond to the
results (the template homogenization_fatigue: pores in a cast alloy; a spherical pore
doubles the stress at its equator, where the utilization is the largest). In the
graphical interface, the box Fatigue of the tool Loading path of a morphology.