Matadi
Material Definition with Automatic Differentiation
Install / Use
/learn @adtzlr/MatadiREADME
matADi is a 3.9+ Python package for the definition of a constitutive hyperelastic material formulation by a strain energy density function. Both gradient (stress) and hessian (elasticity tensor) are carried out by Automatic Differentiation (AD) using casADi [1] as a backend. A high-level interface for hyperelastic materials based on the deformation gradient exists. Several isotropic hyperelastic material formulations like the Neo-Hookean or the Ogden model are included in the model library. Gradient and hessian methods allow input data with trailing axes which is especially useful for Python-based finite element modules, e.g. scikit-fem or FElupe. Mixed-field formulations suitable for nearly-incompressible material behavior are supported as well as single-field formulations based on the deformation gradient. A numerical lab is included to run, plot and analyze homogeneous uniaxial, equi-biaxial, planar shear and simple shear load cases.
Installation
Install matADi from PyPI via pip.
pip install matadi
Usage
First, a symbolic variable on which our strain energy function will be based on has to be created.
Note: A variable of matADi is an instance of a symbolic variable of casADi (casadi.SX.sym). Most (but not all) of matadi.math functions are simple links to (symbolic) casADi-functions.
from matadi import Variable, Material
from matadi.math import det, transpose, trace
F = Variable("F", 3, 3)
Next, take your favorite paper on hyperelasticity or be creative and define your own strain energy density function as a function of some variables x (where x is always a list of variables).
def neohooke(x, C10=0.5, bulk=200.0):
"""Strain energy density function of a nearly-incompressible
Neo-Hookean isotropic hyperelastic material formulation."""
F = x[0]
J = det(F)
C = transpose(F) @ F
return C10 * (J ** (-2 / 3) * trace(C) - 3) + bulk * (J - 1) ** 2 / 2
With this simple Python function at hand, we create an instance of a Material, which allows extra args and kwargs to be passed to our strain energy function. This instance now enables the evaluation of both gradient (stress) and hessian (elasticity) via methods based on automatic differentiation - optionally also on input data containing trailing axes. If necessary, the strain energy density function itself will be evaluated on input data with optional trailing axes by the function method.
Mat = Material(
x=[F],
fun=neohooke,
kwargs={"C10": 0.5, "bulk": 10.0},
)
# init some random deformation gradients
import numpy as np
defgrad = np.random.rand(3, 3, 5, 100) - 0.5
for a in range(3):
defgrad[a, a] += 1.0
W = Mat.function([defgrad])[0]
P = Mat.gradient([defgrad])[0]
A = Mat.hessian([defgrad])[0]
In a similar way, gradient-vector-products and hessian-vector-products are accessible via gradient_vector_product and hessian_vector_product methods, respectively.
v = np.random.rand(3, 3, 5, 100) - 0.5
u = np.random.rand(3, 3, 5, 100) - 0.5
W = Mat.function([defgrad])[0]
dW = Mat.gradient_vector_product([defgrad], [v])[0]
DdW = Mat.hessian_vector_product([defgrad], [v], [u])[0]
Template classes for hyperelasticity
matADi provides several template classes suitable for hyperelastic materials. Some isotropic hyperelastic material formulations are located in matadi.models (see list below). These strain energy functions have to be passed as the fun argument into an instance of MaterialHyperelastic. Usage is exactly the same as described above. To convert a hyperelastic material based on the deformation gradient into a mixed three-field formulation suitable for nearly-incompressible behavior (displacements, pressure and volume ratio) an instance of a MaterialHyperelastic class has to be passed to ThreeFieldVariation. For plane strain or plane stress use MaterialHyperelasticPlaneStrain, MaterialHyperelasticPlaneStressIncompressible or MaterialHyperelasticPlaneStressLinearElastic instead of MaterialHyperelastic. For plane strain displacements, pressure and volume ratio mixed-field formulations use ThreeFieldVariationPlaneStrain. For a two-field formulation (displacements, pressure) use TwoFieldVariation on top of MaterialHyperelastic.
from matadi import MaterialHyperelastic, ThreeFieldVariation
from matadi.models import neo_hooke
# init some random data
pressure = np.random.rand(5, 100)
volratio = np.random.rand(5, 100) / 10 + 1
kwargs = {"C10": 0.5, "bulk": 20.0}
NH = MaterialHyperelastic(fun=neo_hooke, **kwargs)
W = NH.function([defgrad])[0]
P = NH.gradient([defgrad])[0]
A = NH.hessian([defgrad])[0]
NH_upJ = ThreeFieldVariation(NH)
W_upJ = NH_upJ.function([defgrad, pressure, volratio])
P_upJ = NH_upJ.gradient([defgrad, pressure, volratio])
A_upJ = NH_upJ.hessian([defgrad, pressure, volratio])
The output of NH_upJ.gradient([defgrad, pressure, volratio]) is a list with gradients of the functional as [dWdF, dWdp, dWdJ]. Hessian entries are provided as a list of upper triangle entries, e.g. NH_upJ.hessian([defgrad, pressure, volratio]) returns [d2WdFdF, d2WdFdp, d2WdFdJ, d2Wdpdp, d2WdpdJ, d2WdJdJ].
Available isotropic hyperelastic material models:
- Linear Elastic (code)
- Saint Venant Kirchhoff (code)
- Neo-Hooke (code)
- Mooney-Rivlin (code)
- Yeoh (code)
- Third-Order-Deformation (James-Green-Simpson) (code)
- Ogden (code)
- Arruda-Boyce (code)
- Extended-Tube (code)
- Van-der-Waals (Kilian) (code)
Available anisotropic hyperelastic material models:
- Fiber (code)
- Fiber-family (+/- combination of single Fiber) (code)
- Holzapfel Gasser Ogden (code)
Available micro-sphere hyperelastic frameworks (Miehe, Göktepe, Lulei) [2]:
Available [
