Université de Liège

Faculté des Sciences Appliquées

Département Aérospatiale & Mécanique
LTAS – Milieux Continus & Thermomécanique

M AT L IB v.3 Reference Manual

L. Stainier

January 29, 2007

LTAS-MCT Tél: +32-(0)4-366.91.52

1 chemin des chevreuils Fax: +32-(0)4-366.91.41
B-4000 Liège Courriel: L.Stainier@ulg.ac.be
Chapter 1

Universal Interface

1.1 Introduction

Constitutive models represent a fundamental element in computational solid mechanics codes. These models
tend to include more and more physics (i.e. more or less explicit considerations of underlying micromecha-
nisms), and thus become more and more complex. This increasing complexity in turn reinforce the interest of
developing code-independent libraries of constitutive models, which could facilitate collaborations and “free
circulation” of models.

M AT L IB is an attempt to propose such a code-independent library of constitutive models. But a critical prelimi-
nary step to the design of this library is the definition of a unique interface accomodating all constitutive models
in solid (thermo)mechanics. The interface proposed here is based on the description of constitutive relations
in a standard thermodynamic framework, where irreversible mechanisms are modeled by internal variables.
Hence, the interface proposes a data structure storing the thermodynamic state of the material. The main role
of constitutive models in the context of a numerical simulation will be to update the internal variables from a
known state to a subsequent state (later in time or loading) where only external variables are known. In addi-
tion, the model should be able to compute forces thermodynamically associated to external variables (and the
sensitivity of the former to the latter). The interface imposes that implementations should provide this kind of
functionality.

Specific care was also taken to allow for interactions between coupled computations (such as thermal and me-
chanical). Coupled problems can be solved through different types of numerical schemes, going from strongly
coupled approaches with simultaneous resolution of all fields, to weakly coupled approaches with sequential
resolution, passing by intermediate solutions such as strongly coupled by staggered solution schemes. The
proposed interface was designed to be compatible with all these various algorithms.

1.2 Material properties

The first part of the interface regards the material properties, or material parameters, data structure. The adopted
data structure is described in Box 1. Its features are the following:

• The properties can be of type integer, real (double precision), a function of one variable, or a generic
Property type, which allows to include more complex data types, such as a pre-computed Hooke
matrix in elasticity. Complex data types are typically used internally only, and they will normally not
appear in an input file. This list might be extended in the future (e.g. to include multi-variable functions);
CHAPTER 1. UNIVERSAL INTERFACE 2

• The properties are referenced by keywords. This choice, instead of indices as is often the case in other
frameworks, allows for a lot of modularity. Indeed, it is our goal that elements of existing models can be
combined to create new models. The management of the respective properties of each of these elements
is transparent when using keywords, whereas it incurs a greatly increased complexity when using indices,
hence our choice.

The choice and format of keywords is left open, and is of course dependent of the particular implementations
of constitutive models. But it is suggested to follow as much as possible the MIGtionary proposed in [?].

/**
* Class containing a set of material properties.
*/
class MaterialProperties {

public:

// get material’s name

std::string getName() const;

// get property associated to keyword

Property& getProperty(const std::string&) const
throw (NoSuchPropertyException);
int getIntegerProperty(const std::string&) const
throw (NoSuchPropertyException);
double getDoubleProperty(const std::string&) const
throw (NoSuchPropertyException);
Function& getFunctionProperty(const std::string&) const
throw (NoSuchPropertyException);

// set property associated to keyword

void setProperty(const std::string&,Property&);
void setProperty(const std::string&,int);
void setProperty(const std::string&,double);
void setProperty(const std::string&,Function&);

// read from an input stream

void readFrom(std::istream&) throw (SyntaxError);
};

Box 1: The material properties data structure

Three exception types are associated with the MaterialProperties class:

• NoSuchPropertyException;

• SyntaxError;

• and InvalidPropertyException.

The first exception type is thrown when a request is made, through one of the getProperty() methods,
for a property which has not been loaded before in the data structure. In other words, this exception is thrown
when the requested keyword is not found in the table of properties. The second one is thrown when the method
CHAPTER 1. UNIVERSAL INTERFACE 3

readFrom() encounters problems with the format/syntax of the input stream, which depends on the particular
implementation of this interface (the syntax used by M AT L IB is described in section 1.6). The last one can be
thrown when a constitutive model implementation considers that a material property has been given a value
outside of the acceptable range. More comments on this are given in section 1.4.

1.3 Material state

The second part of the interface is a data structure containing the information about the state of the material at a
given computation point (e.g. an integration point of a finite element). The nature of this information is defined
by the thermodynamical framework in which we put ourselves. The state of the material is thus determined
by a set of external variables, plus a set of internal variables describing local irreversible processes (such as
plastic deformation). The nature of external variables depends on the class of problem considered. In the case
of solid mechanics, for example, the external variable is the gradient of deformation. The exact content of the
external variables array is listed in details in Appendix A, for the various classes of problems considered in
M AT L IB. The nature of internal variables depends on the specificities of each constitutive model, as described
in Chapter 2. As their name indicates, the library could actually be used without any knowledge of the detail
of these internal variables (the size of the array is the only information practically needed, and it is provided by
the interface, see section 1.4). Thermodynamics associates forces to these external and internal variables: for
example, in the case of solid mechanics, the force thermodynamically associated to the gradient of deformation
is the (first Piola-Kirchhoff) stress tensor. The role of the constitutive model is then to relate the evolution of
external variables to the evolution of their associated forces, at all times.

In most field theories, the external variable is the gradient of the unknown field, while the associated force can
be interpreted as a flux. We have adopted this nomenclature in our definition of the data structure representing
the material state, as detailed in Box 2. Note that we have included the thermodynamical forces in this data
structure, though the set of external and internal variables theoretically suffices to completely describe the state
of the material. The motivation for this redundancy is twofold. First it offers a convenient way of storing and
transmitting information to the rest of the code (finite elements, . . . ). Indeed, in a typical computation, the
thermodynamical forces are the main element of information which is expected from the constitutive model.
Second, some formulations work with constitutive equations in rate form only, and thus do not allow to derive
the forces from the external variables at a given time without performing the integration over the whole previous
history. Storing the forces then allows to avoid this tedious operation, and to perform the integration on the
current time step only. A typical example of this kind of formulation is hypoelasticity.

The data composing the MaterialState class are declared of type MatLibArray, which is in fact a
typedef to some internal data structure of M AT L IB. Should this internal data structure be changed, the
interface would remain the same. A list of relevant methods for the user is given in Box 3. As can be seen
from this interface, assignment and access operators include range control, throwing runtime exceptions from
the standard C++ library. Method resize() can be used to set or change the size of an array, e.g. to the
size provided by the constitutive model for the external and/or internal variables (the default size of an array is
zero).

1.4 Constitutive model

The core of the interface is of course the virtual base class for constitutive models. This base class is described
in Box 4. This structure assumes there are three levels of interaction with constitutive models:

• First, the constitutive model should provide informations about the type of external and internal variables
CHAPTER 1. UNIVERSAL INTERFACE 4

/**
* Class describing the state of a material point.
*/
class MaterialState {

public:

// external variables
MatLibArray grad;

// associated forces
MatLibArray flux;

// internal variables
MatLibArray internal;
};

Box 2: The material state data structure

it handles. Since we have chosen to externally manipulate these quantities as arrays, the main piece of in-
formation whis is needed is the size of these arrays. This can be obtained from the methods nExtVar()
and nIntVar();

• Then, the constitutive model has an important role in preprocessing the material data, checking that these
have acceptable values and that the set is complete for the model under consideration, as well as complet-
ing this set with auxilliary parameters. This preprocessing is done by the method checkProperties(),
which can throw exceptions of type InvalidPropertyException, as described in section 1.2. One
should always make sure that this method is called before proceeding to the actual computations;

• Finally, the main role of the constitutive model is to update the state of the material. But before updating
the state, this one should be properly initialized, which can be done through the method initState().
This method will set the external and internal values to proper initial values (corresponding to a “virgin”
state of the material).

There is a fourth level of interaction with the constitutive model. It is not essential to the proper functionning
of the system, but is instead intended for self-documentation purposes. This capacity can be useful to write
a generic post-processing tool, for example, or to check consistency between finite element formulations and
constitutive model. These self-documenting utility methods describe the segmentation of external and internal
variable arrays in actual data types (scalar, vector, tensor, ...). These data types are described by the enum
ConstitutiveModel::VariableType, which can take values as listed in Table 1.1. The presence of a
specific 2D type for tensors is explained as follows: tensors describing the bulk mechanical behaviour of solids
always have a full diagonal, independently of the geometrical context (see appendix A), but for reduced models,
such as in shells, a strictly bidimensional tensor type is useful.

The updateState() method is of course the main component of the constitutive model interface. Given
material properties and external parameters, this method updates the state of the material from a known set to
a partially unknown set. Typically, only the gradient is known for the final state, and this has to be completed
by updating internal variables (which allows to compute fluxes). Optionally, the consistent tangent operator
(derivatives of the fluxes with respect to gradients, accounting for the incremental nature of the problem) can
be computed. Alternatively, the tangent operator can be computed independently of any material state update.
The tangent operator is stored in a data structure of generic type MatLibMatrix described in Box 5. This
type is actually a typedef to some internal data type, and functions similarly to MatLibArray.
CHAPTER 1. UNIVERSAL INTERFACE 5

/**
* Class describing the array type for MatLib.
*/
class MatLibArray {

public:

// constructor
MatLibArray(size_t = 0);

// copy constructor
MatLibArray(const MatLibArray&);

// assignment operators
MatLibArray& operator=(const MatLibArray&) throw (std::range_error);
MatLibArray& operator=(double);

// access operators
double operator()(size_t) const throw (std::out_of_range);
double& operator()(size_t) throw (std::out_of_range);

// resize array
void resize(size_t);
};

Box 3: Interface for MatLibArray

Two additional methods are provided for constitutive models. The first one, rotateProperties(), allows
to take into account a possible initial anisotropy of the material. It will modify material properties (normally
given in some natural axes system) in function of the given orientation (the rotation operator transforms the
global axes into the local –or material– axes). Another method, updateProperties(), allows to modifiy
material properties in function of some external parameter set (such as room temperature). External parameters
are stored in the dictionary-type data structure ParameterSet, working on the basis of keywords. External
parameters are also passed to the updateState() method. Finally, two other useful methods, not shown in
Box 4, are provided:
bool ConstitutiveModel::isLinear() const indicates if the constitutive model is linear;
bool ConstitutiveModel::isStandard() const indicates if the constitutive model is variational.

Variational constitutive models have the additional property that, in a constitutive update step, the external
forces can be derived from an incremental potential. In this case, the update method can be replaced by another

Table 1.1: Data types for external and internal variables

TYPE SCALAR scalar

TYPE VECTOR vector (always 3 components)
TYPE SYM TENSOR tensor with symmetric storage
TYPE TENSOR tensor with full storage
TYPE SYM TENSOR 2D symmetric 2D tensor (3 components)
TYPE TENSOR 2D 2D tensor (4 components)
TYPE NONE none of the above
CHAPTER 1. UNIVERSAL INTERFACE 6

/**
* Virtual base class for constitutive models.
*/
class ConstitutiveModel {

public:

// check consistency of material properties

void checkProperties(MaterialProperties&,std::ostream* = 0)
throw (InvalidPropertyException);

// apply rotation to material properties

void rotateProperties(MaterialProperties&,const Rotation&);

// update properties in function of external parameters

void updateProperties(MaterialProperties&,const ParameterSet&);

// how many external variables ?

unsigned int nExtVar() const;

// self-documenting utilities
unsigned int nExtVarBundled() const;
VariableType typeExtVar(unsigned int) const;
unsigned int indexExtVar(unsigned int) const;
std::string labelExtVar(unsigned int) const;
std::string labelExtForce(unsigned int) const;

// how many internal variables ?

unsigned int nIntVar() const;

// self-documenting utilities
unsigned int nIntVarBundled() const;
VariableType typeIntVar(unsigned int) const;
unsigned int indexIntVar(unsigned int) const;
std::string labelIntVar(unsigned int) const;

// initialize the state of the material

void initState(const MaterialProperties&,MaterialState&);

// update the state of the material (with option to compute tangents)

void updateState(const MaterialProperties&,const ParameterSet&,
const MaterialState&,MaterialState&,double,
MatLibMatrix&,bool);

// compute material tangents (without updating)

void computeTangent(const MaterialProperties&,const ParameterSet&,
const MaterialState&,MaterialState&,double,
MatLibMatrix&);
};

Box 4: Constitutive model interface

CHAPTER 1. UNIVERSAL INTERFACE 7

/**
* Class describing the (square) matrix type for MatLib.
*/
class MatLibMatrix {

public:

// constructor
MatLibMatrix(size_t = 0);

// copy constructor
MatLibMatrix(const MatLibMatrix&);

// assignment operators
MatLibMatrix& operator=(const MatLibMatrix&) throw (std::range_error);
MatLibMatrix& operator=(double);

// access operators
double operator()(size_t,size_t) const throw (std::out_of_range);
double& operator()(size_t,size_t) throw (std::out_of_range);

// resize matrix
void resize(size_t);
};

Box 5: Interface for MatLibMatrix

which computes the value of the incremental potential and its derivatives. Thus, when the model is variational, it
should normally also implement the interface described in Box 6. As its name indicates, this method computes
the incremental energy, with the option to compute its first and second derivatives with respect to external
variables (forces and consistent tangents, respectively).

/**
* Additional interface for standard materials.
*/
class StandardMaterial : virtual public ConstitutiveModel {

public:

// compute the incremental potential

double incrementalPotential(const MaterialProperties&,const ParameterSet&,
const MaterialState&,MaterialState&,
double,MatLibMatrix&,bool,bool);
};

Box 6: Interface for variational constitutive models

1.5 Model dictionary

All implemented constitutive models normally register themselves automatically into a model dictionary. This
dictionary associates specific models to keywords, documented later in this document. In practice, the model
CHAPTER 1. UNIVERSAL INTERFACE 8

dictionary is a class providing a static factory method for constitutive models:

ConstitutiveModel* ModelDictionary::build(const std::string& key,

unsigned int d = 3)
throw (NoSuchModelException);

A call to this method will create a new instance of the constitutive model associated to the keyword key in 1D,
2D or 3D, according to the specified dimension d. From there, it is up to the user to take care of the object
(don’t forget to delete it when you will not reference it anymore).

1.6 Material properties file format

The method MaterialProperties::readFrom() allows to load a set of material properties from a

formatted text file. The format effectively used in M AT L IB is described here.

The first line must always contain the material’s name, i.e. the string which will be returned by getName().
Aside of that, the file can include white lines or comment lines. These begin by one of the comment characters
(! or #), possibly after white spaces of tabs. Only one property can be defined on each line, with the following
general format:

KEYWORD = value (type)

White spaces are not necessary, the actual separators being the equal sign and the parentheses. Upper case is
preferred for the keyword but it is not mandatory (i.e. the reader automatically sets all characters in upper case).
The type is either int, real or function, the generic Property type having no meaning at this level. In
the case of integer and real types, the value is just the number assigned to the property. In the case of functions,
two formats are possible. A first possibility is to directly specify the function in the properties file in a tabulated
format:

FUNCTION_KEYWORD = [ x1, f1 ; x2, f2 ; x3, f3 ; ...] (function)

The function will then be interpolated between the given points, in a piecewise linear fashion. Another possi-
bility, useful for long lists of points, is to refer to an external file (suggested extension: .fct):

FUNCTION_KEYWORD = "file.fct" (function)

The external file should itself be formatted in the following way: the first line is reserved for a label string, and
each following line corresponds to one point, x and f being separated by blank spaces or tabs. The function is
also interpolated between these points in a piecewise fashion.
Chapter 2

Constitutive Models

2.1 Equations of state

The volumic behaviour of solids (i.e. the evolution of pressure with changes in volume) is sometimes better
described separately from the overall bulk behaviour. This is for example the case when dealing with high-
pressure states. By analogy to gasses and fluids, the relation between pressure and volume (plus temperature,
usually) is called an equation of state. Often, it can be put in the form of a potential, of which the pressure
derives:
0
p(J) = JWeos (J) or p(J, T ) = J∂J Weos (J, T ) (2.1)
where J = V /V0 is the scalar jacobian of deformation, and p the hydrostatic tension (negative pressure). The
(isothermal) bulk modulus is then given by
∂p  0 00

K(J) = J = J Weos (J) + JWeos (J) (2.2)
∂J

2.1.1 Standard equation of state

Under moderate loading conditions, solids are usually considered to have a deformation-independent bulk
modulus. This is the case with the following equation of state potential, valid in isothermal settings:
Weos (J) = 21 K0 (log J)2 (2.3)
where K0 is a constant material property. Temperature-dependence can be introduced by making the bulk
modulus K0 a function of T .

Table 2.1: Material properties for standard e.o.s. model

Symbol Keyword Type S.I. Unit

K0 BULK MODULUS (real) [Pa]

2.2 Elasticity

First, we will consider elastic constitutive models, corresponding to non-dissipative mechanical behaviour.
Elastic solids (or solids in the elastic range) do not present any residual deformation upon unloading. In a
CHAPTER 2. CONSTITUTIVE MODELS 10

standard thermodynamic description, the (mechanical) state of an elastic material is thus entirely defined by
the deformation gradient F [?]. The behaviour of the elastic solid is then described by the free energy density
(per unit volume) W (F ). Additional considerations on frame invariance and objectivity lead to the conclusion
that the free energy must be a function of the right Cauchy-Green deformation tensor C only (again, see [?] for
more details). The class of constitutive models following this description is labelled hyperelasticity.

In the case of small perturbations from the initial state, both the behaviour and the measure of deformation can
be linearized. The resulting class of constitutive models is labelled linear elasticity.

Finally, an alternative approach to modelling non-dissipative elastic behaviour in the presence of large strains
and rotations is based on a rate description of constitutive equations. This class of constitutive models is labelled
hypoelasticity.

2.2.1 Hyperelasticity

2.2.1.a Decomposition in volumic and deviatoric behaviours

All hyperelastic constitutive models can be combined with any equation of state (e.o.s.) through the following
additive decomposition of the free energy:
√
W (C) = Weos (J) + Wdev (C̄) with J = det C and C̄ = J −2/3 C (2.4)

where Weos (J) is a potential function of the scalar jacobian of deformation J, describing the volumic behaviour
(cf. section 2.1), while Wdev is a hyperelastic stored energy function of the distorsion C̄ (such as those described
in the following).

The second Piola-Kirchhoff (PK2) stress tensor is then given by

∂W ∂Wdev
0
= J −2/3 S̄ + JWeos (J) − 31 S̄ · C̄ C −1


S=2 with S̄ = 2 (2.5)
∂C ∂ C̄
which can be rewritten as
S = J −2/3 DEV[S̄] + JWeos
0
(J)C −1 (2.6)
where DEV[•] = (•) − 31 (• · C)C −1 is the material deviatoric operator. The material tangents are given by

∂2W
MIJKL = 4
∂CIJ ∂CKL
−1 −1
= J −4/3 M̄IJKL − 13 J −2/3 M̄IJM N C̄M N CKL


+ CIJ M̄KLM N C̄M N
−1 −1 (2.7)
− 32 J −2/3 S̄IJ CKL


+ CIJ S̄KL
0 00

 −1 −1
+ 91 C̄ · M̄ · C̄ + 29 S̄ · C̄ + J Weos

(J) + JWeos (J) CIJ CKL
0 −1 −1 −1 −1
(J) − 13 S̄ · C̄ CIK



− JWeos CJL + CIL CJK

∂ 2 Wdev
with M̄ = 4 .
∂ C̄∂ C̄

2.2.1.b Hencky models

The family of Hencky models are described by a stored energy function which is quadratic in logarithmic
strains:
W (C) = 21  · H ·  with  = 21 log[C] (2.8)
CHAPTER 2. CONSTITUTIVE MODELS 11

where the 4th-order tensor H is a Hooke tensor, as defined in linear elasticity (see section 2.2.2). The second
Piola-Kirchhoff (PK2) stress tensor is then given by

∂W ∂ log[C] ∂ log[C]
S=2 = (H · ) · =σ· (2.9)
∂C ∂C ∂C
where σ = H ·  is a “small-strain” type stress tensor. Note that this expression for the stress (2.9) differs
from other approaches aiming at extending small-strain models to the finite deformation range. Comparing for
example with the approach of Cuitiño and Ortiz [1], one can clearly see the presence of an additional factor
coming from the derivative of the logarithmic strain. The material tangents are then given by

∂2W ∂ log[C]M N ∂ log[C]P Q ∂ log[C]M N

MIJKL = 4 = HM N P Q + 2σM N (2.10)
∂CIJ ∂CKL ∂CIJ ∂CKL ∂CIJ ∂CKL

Different material symmetries are then modeled by an appropriate choice of Hooke tensor, as detailed in the
section on linear elasticity (2.2.2). Here we will simply list the material properties and their associated keyword
for the various cases implemented in M AT L IB.

Isotropy Material properties for isotropic hyperelasticity of Hencky type are listed in Table 2.2.

Table 2.2: Material properties for isotropic finite elasticity Hencky model (3 alternative sets)

Model keyword = ISOTROPIC HYPERELASTICITY

Symbol Keyword Type S.I. Unit
λ0 1ST LAME CONSTANT (real) [Pa]
µ0 2ND LAME CONSTANT (real) [Pa]
G0 SHEAR MODULUS (real) [Pa]
K0 BULK MODULUS (real) [Pa]
E0 YOUNG MODULUS (real) [Pa]
ν0 POISSON COEFFICIENT (real) [-]

Orthotropy

2.2.1.c Neohookean model

The neohookean model is described by the following stored energy function of the right Cauchy-Green defor-
mation tensor:
√
W (C) = 12 λ0 (log J)2 − µ0 log J + 21 µ0 (tr[C] − 3) with J = det C (2.11)

where λ0 and µ0 are the first and second Lamé constants, respectively. In the above expression the original
potential (for incompressible behaviour) has been augmented by a volumic part allowing for compressible
behaviours.

The second Piola-Kirchhoff (PK2) stress tensor is then given by

∂W
= λ0 log J C −1 + µ0 δ − C −1


S=2 (2.12)
∂C
CHAPTER 2. CONSTITUTIVE MODELS 12

where δ is the identity tensor. In the spatial configuration, the Cauchy stress tensor is given by

σ = J −1 F SF T = λ0 J −1 log J δ + µ0 J −1 (b − δ) (2.13)

where b = F F T is the Finger deformation tensor. If we consider small deviations from the reference configu-
ration, we can obtain the following linearized expressions:

J ' 1 + tr[] (2.14)

log J ' tr[] (2.15)
b ' δ + 2 (2.16)

and
σ ' λ0 tr[]δ + 2µ0  (2.17)
which is nothing else than the standard stress-strain relation of linear elasticity (Hooke’s law) in terms of the
Lamé coefficients, hence the name of the present model. Finally, note that in the finite strain regime, the
stress-strain relation (2.13) can be more interestingly rewritten in terms of the Kirchhoff stress tensor:

τ = Jσ = λ0 log J δ + 2µ0 e (2.18)

where e = 21 (b − δ).

The material tangents are given by

∂2W −1 −1 −1 −1 −1 −1


MIJKL = 4 = λ0 CIJ CKL + (µ0 − λ0 log J) CIK CJL + CIL CJK (2.19)
∂CIJ ∂CKL
The material part of the spatial tangents are obtained by
(M )
Cijkl = J −1 FiI FjJ FkK FlL MIJKL
(2.20)
= λ(J) δij δkl + µ(J) (δik δjl + δil δjk )

which is a Hooke tensor with effective (deformation-dependent) properties λ(J) = J −1 λ0 and µ(J) =
J −1 (µ0 − λ0 log J). Obviously, λ(1) = λ0 and µ(1) = µ0 , and in the case of incompressible behaviour
for example, the spatial tangents are exactly equal to the Hooke tensor.

Lamé constants λ0 and µ0 can be expressed in terms of other commonly used material parameters:
ν0 E0
λ0 = = K0 − 23 G0 (2.21)
(1 + ν0 )(1 − 2ν0 )
E0
µ0 = = G0 (2.22)
2(1 + ν0 )
where E0 is Young’s modulus, ν0 Poisson’s coefficient, G0 the shear modulus and K0 the bulk modulus.
Keywords for this model in M AT L IB are listed in Table 2.3.

2.2.2 Linear elasticity

In the case of small displacements and rotations (small strains), the above models can be linearized around the
initial configuration. In this context, all measures of strain and stress become equivalent, and we will work with
the symmetric strain  ≈ F − I and the Cauchy stress σ.

The linear elastic behavior is characterized by a quadratic energy function, which takes the general form
1
W () = 2 ·H· (2.23)
CHAPTER 2. CONSTITUTIVE MODELS 13

Table 2.3: Material properties for neohookean model (3 alternative sets)

Model keyword = NEOHOOKEAN

Symbol Keyword Type S.I. Unit
λ0 1ST LAME CONSTANT (real) [Pa]
µ0 2ND LAME CONSTANT (real) [Pa]
E0 YOUNG MODULUS (real) [Pa]
ν0 POISSON COEFFICIENT (real) [-]
G0 SHEAR MODULUS (real) [Pa]
K0 BULK MODULUS (real) [Pa]

where the 4th-order tensor H is known as the Hooke tensor. Without loss of generality, we may assume that the
Hooke tensor has properties of major and minor symmetry :

Hijkl = Hklij and Hijkl = Hjikl = Hijlk = Hjilk (2.24)

Given these properties, any linear elastic material will be completely characterized by at most 21 independent
coefficients. Finally, the stress tensor is given by

∂W
σ= =H· (2.25)
∂
and the material tangents
∂2W
M= ≡H (2.26)
∂2
are constant.

2.2.2.a Isotropic elasticity

In the case of isotropic elastic materials (behavior completely independent of sample orientation), the Hooke
tensor is defined by two coefficients:
H = 3λ0 K + 2µ0 I (2.27)
where Iijkl = 12 (δik δjl + δil δjk ) is the 4th-order identity, Kijkl = 13 δij δkl , and λ0 and µ0 are the first and second
Lamé constants, respectively. Alternatively, it can be written in terms of the bulk modulus K0 and the shear
modulus G0 :
H = 3K0 K + 2G0 J (2.28)
where J ≡ I − K.

Taking into account the following properties:

J ·  = dev[] =  − 31 tr[]I and K ·  = 13 tr[]I (2.29)

the elastic energy can be rewritten

W () = 21 λ0 (tr[])2 + µ0 ( · ) = 21 K0 (tr[])2 + G0 (dev[] · dev[]) (2.30)

Similarly, the stress can be rewritten

σ = λ0 tr[]I + 2µ0  = K0 tr[]I + 2G0 dev[] (2.31)

CHAPTER 2. CONSTITUTIVE MODELS 14

All the above material constants can also be expressed in terms of Young’s modulus E0 and Poisson’s coefficient
ν0 :
ν0 E0
λ0 = K0 − 32 G0 = (2.32)
(1 + ν0 )(1 − 2ν0 )
E0
µ0 = G0 = (2.33)
2(1 + ν0 )

Keywords for this model in M AT L IB are listed in Table 2.4.

Table 2.4: Material properties for linear isotropic elasticity model (3 alternative sets)

Model keyword = ISOTROPIC ELASTICITY

Symbol Keyword Type S.I. Unit
λ0 1ST LAME CONSTANT (real) [Pa]
µ0 2ND LAME CONSTANT (real) [Pa]
G0 SHEAR MODULUS (real) [Pa]
K0 BULK MODULUS (real) [Pa]
E0 YOUNG MODULUS (real) [Pa]
ν0 POISSON COEFFICIENT (real) [-]

2.2.2.b Cubic elasticity

Structural tensor for materials with cubic symmetry:

   
(2) (2) (2) (2) (2) (2) (2) (2) (2) (2) (2) (2)
S = e1 ⊗ e2 + e2 ⊗ e3 + e3 ⊗ e1 − e2 ⊗ e1 + e3 ⊗ e2 + e1 ⊗ e3 (2.34)

(2)
where ei (i = 1, 2, 3) are the natural axes of the cubic system, and ei = ei ⊗ ei (no sum). Let’s also define
the 4th-order tensor Jc such that Jcijkl = 13 Smnij Smnkl . The Hooke tensor of cubic materials is then given by:

H = 3K0 K + 2G00 J + 2(G0 − G00 )Jc (2.35)

The 3 elastic constants K0 , G0 and G00 can be related to the classical constants for cubic elasticity through the
following relations:

C11 = K0 + 43 G0 (2.36)
2
C12 = K0 − 3 G0 (2.37)
C44 = G00 (2.38)

The level of anisotropy can be measured by the anisotropy factor H = 2C44 + C12 − C11 = 2(G00 − G0 ).

Obviously, in this case, tensors Jc and H are dependent on the initial orientation of the material. From the
above, we can see that the stored energy function can alternatively be expressed as an isotropic (orientation-
independent) function of  and (S · ).

2.2.2.c Orthotropic elasticity

2.2.3 Hypoelasticity
CHAPTER 2. CONSTITUTIVE MODELS 15

2.3 Viscoelasticity

Viscoelastic materials are characterized by the existence of a non-equilibrium component to the strain (i.e. the
existence of a rate of deformations in the presence of non-zero constant states of stress) and/or the existence of
residual deformations upon unloading. These permanent deformations can be permanent or time-decaying, but
the critical difference with plastic behavior, described in a subsequent section (2.4), is the absence of a yield
limit. In other words, no elastic domain can be defined for viscoelastic models.

2.3.1 Variational viscoelasticity

The variational viscoelasticity models implemented in M AT L IB are based on the variational formulation for
finite viscoelasticity proposed by Fancello et al. [2]. Here, we will briefly summarize the main features of this
formulation.

We place ourselves in the framework of a local state approach to solid mechanics, where the mechanical state
at a given material point is entirely described by the gradient of deformation F and a suitably chosen set of
internal variables Q representing the past history of deformation.

Viscoelastic solids are characterized by the existence of inelastic deformations F v , or viscous deformations,
representative of internal accommodation mechanisms. One therefore has, locally,

F = F eF v (2.39)

This multiplicative elastic-plastic kinematics was first suggested by Sidoroff [?].

2.3.2 Kelvin-Voigt viscoelasticity

The Kelvin-Voigt model of viscoelasticity is one of the simplest models in the category. It includes rate-
sensitivity from the onset (instantaneous stress) but cannot reproduce permanent deformations. It does not
involve any internal variables. It is thus decribed by two potentials: a Helmholtz free energy W (C) and a
dissipation pseudo-potential φ∗ (D; F ). The (first Piola-Kirchhoff) stress tensor is then given by:

∂W ∂φ∗ ∂W ∂φ∗
P = (C) + (D; F ) = 2F + (D; F )F −T (2.40)
∂F ∂ Ḟ ∂C ∂D

2.3.2.a Isotropic Kelvin-Voigt finite viscoelasticity

For an isotropic material, the Helmholtz free energy can be chosen among any of the models defined for
isotropic hyperelasticity. A possible choice is to take a Hencky potential (quadratic in logarithmic strains) with
the isotropic Hooke tensor. Regarding the dissipation pseudo-potential, a simple option is to take it quadratic
in D:
φ∗ (D) = 21 D · Hv · D (2.41)
Material parameters corresponding to this specific model are given in Table 2.5.

2.3.2.b Orthotropic Kelvin-Voigt finite viscoelasticity

CHAPTER 2. CONSTITUTIVE MODELS 16

Table 2.5: Material properties for finite isotropic Kelvin-Voigt viscoelasticity model (3 alternative sets)

Model keyword = ISOTROPIC KV VISCOHYPERELASTICITY

Symbol Keyword Type S.I. Unit
λ0 1ST LAME CONSTANT (real) [Pa]
µ0 2ND LAME CONSTANT (real) [Pa]
(v)
λ0 VISCOUS 1ST LAME CONSTANT (real) [Pa]
(v)
µ0 VISCOUS 2ND LAME CONSTANT (real) [Pa]
G0 SHEAR MODULUS (real) [Pa]
K0 BULK MODULUS (real) [Pa]
(v)
G0 VISCOUS SHEAR MODULUS (real) [Pa]
(v)
K0 VISCOUS BULK MODULUS (real) [Pa]
E0 YOUNG MODULUS (real) [Pa]
ν0 POISSON COEFFICIENT (real) [-]
(v)
E0 VISCOUS YOUNG MODULUS (real) [Pa]
(v)
ν0 VISCOUS POISSON COEFFICIENT (real) [-]

2.4 Plasticity

The distinguishing characteristic of plasticity is the existence of a permanent residual deformation upon un-
loading, provided that the solid was strained beyond a critical yield limit. Plastic behaviour is thus clearly
irreversible. In other words, plastic solids (i.e. solids in the plastic range) exhibit a memory effect, which, in a
standard thermodynamic description, is modelled by internal variables.

Plasticity in (poly)crystalline solids (e.g. metals) is linked to the existence of lattice defects, called dislocations,
and their motion. These dislocations can slide on specific crystalline planes and in specific directions (slip
systems) determined by the structure of the lattice (e.g. f.c.c., b.c.c., h.c.p.) [?]. Crystal plasticity models
describe the plastic flow at the lattice level, using slip strains and dislocation densities associated to each slip
system.

Plasticity can also be described at a larger scale, aggregating the behaviour of many individual crystalline grains
into a macroscopic homogenized model. Different approaches are then possible to model the plastic flow. In the
following we will specifically consider Mises and Tresca models of plasticity. Note that this type of plasticity
models is also suitable to describe non-crystalline materials, such as soils, rocks or concrete.

2.4.1 Variational plasticity

The variational plasticity models implemented in M AT L IB are based on the variational formulation for finite
plasticity initially proposed by Ortiz and Stainier [?]. Here, we will briefly summarize the main features of this
formulation.

We place ourselves in the framework of a local state approach to solid mechanics, where the mechanical state
at a given material point is entirely described by the gradient of deformation F and a suitably chosen set of
internal variables Q representing the past history of deformation.

Elastoplastic solids are characterized by the existence of a certain class of deformations F p , or plastic defor-
mations, which leave the crystal lattice undistorted and unrotated, and, consequently, induce no long-range
CHAPTER 2. CONSTITUTIVE MODELS 17

stresses. In addition to the plastic deformation F p , some degree of lattice distortion F e , or elastic deformation,
may also be expected in general. One therefore has, locally,

F = F eF p (2.42)

This multiplicative elastic-plastic kinematics was first suggested by Lee [?], and further developped and used
by many others.

2.4.2 Variational crystal plasticity

2.4.3 Variational Mises plasticity

2.4.3.a General description

2.4.3.b Linearized model

2.4.3.c Isotropic finite Mises plasticity

Appendices
Appendix A

Data Structures

A.1 Mechanics

For mechanical models, the MaterialState arrays contain the components of strain (grad) and stress
(flux) tensors. The exact nature of these tensors depends on the kinematic assumptions taken.

A.1.1 Finite strains

In finite strains models, the strain tensor considered is the gradient of deformation F . Its components are stored
in an array rowwise (C-style):

(3D) : grad = {F11 , F12 , F13 , F21 , F22 , F23 , F31 , F32 , F33 } (A.1)
(2D) : grad = {F11 , F12 , F21 , F22 , F33 } (A.2)
(1D) : grad = {F11 , F22 , F33 } (A.3)

Similarly, the stress tensor considered is that conjugate to the gradient of deformation, i.e. the first Piola-
Kirchhoff stress tensor P :

(3D) : flux = {P11 , P12 , P13 , P21 , P22 , P23 , P31 , P32 , P33 } (A.4)
(2D) : flux = {P11 , P12 , P21 , P22 , P33 } (A.5)
(1D) : flux = {P11 , P22 , P33 } (A.6)

In 2D and 1D, all components not stored in the above arrays always remain equal to zero. Note that other
stress tensors can be computed from the gradient of deformation and the first Piola-Kirchhoff stress tensors, as
indicated in Table A.1.

A.1.2 Linearized kinematics

In linearized kinematics (small strains), the strain tensor considered is the symmetric engineering strain tensor
. Its lower-triangular components are stored in an array rowwise (C-style):

(3D) : grad = {11 , γ12 , 22 , γ13 , γ23 , 33 } (A.7)

(2D) : grad = {11 , γ12 , 22 , 33 } (A.8)
(1D) : grad = {11 , 22 , 33 } (A.9)
APPENDIX A. DATA STRUCTURES 20

Table A.1: Conversion table for different stress measures (J = det F )

P S τ σ
P – P = FS P = τ F −T P = JσF −T
S S = F −1 P – S = F −1 τ F −T S = JF −1 τ F −T
τ τ = PFT τ = F SF T – τ = Jσ
σ σ = J −1 P F T σ = J −1 F SF T σ = J −1 τ –

∂ui ∂u
with the strain ij = 12 ( ∂xj
+ ∂xji ) and the shear strain γij = 2ij (i 6= j). Similarly, the stress tensor considered
is that conjugate to the deformation, i.e. the Cauchy stress tensor σ:

(3D) : flux = {σ11 , σ12 , σ22 , σ13 , σ23 , σ33 } (A.10)

(2D) : flux = {σ11 , σ12 , σ22 , σ33 } (A.11)
(1D) : flux = {σ11 , σ22 , σ33 } (A.12)

In 2D and 1D, all components not stored in the above arrays always remain equal to zero. This convention
allows to compute the energy by performing a scalar product of the two arrays: σ ·  ≡ flux · grad.
Appendix B

Tensor algebra

B.1 Algorithm for polar decomposition

For some constitutive formulations, it is necessary to perform a polar decomposition of the gradient of defor-
mation into a rotation and a stretch tensor:
F = RU (B.1)
where R is an orthogonal tensor (RRT = I) and U is a symmetric positive semidefinite tensor, called the
right stretch tensor (one can also define a left stretch tensor V such that F = V R). The polar decomposition
theorem shows that this decomposition is unique [?, ?].

In 3 dimensions, a closed-form algorithm for the polar decomposition has been given by Simo and Hughes
[?], which is based on a unified, singularity-free expression to compute U from the right Cauchy-Green tensor
C [?, ?]. In 2 dimensions, thanks to the specific form of the rotation tensor, a much more simple and direct
algorithm can be devised. Since
    
F11 F12 R1 R2 U11 U12
= (B.2)
F21 F22 −R2 R1 U12 U22

with R12 + R22 = 1, one can write

V1 = F11 + F22 = R1 (U11 + U22 ) (B.3)

V2 = F12 − F21 = R2 (U11 + U22 ) (B.4)

and
V1 V2
R1 = p R2 = p (B.5)
V12 + V22 V12 + V22
which yields the rotation tensor (R33 = 1). From there, one easily gets the stretch tensor:
    
U11 U12 R1 −R2 F11 F12
= (B.6)
U12 U22 R2 R1 F21 F22
Bibliography

[1] A. M. Cuitino and M. Ortiz. A material-independent method for extending stress update algorithms from
small-strain plasticity to finite plasticity with multiplicative kinematics. Engineering Computations, 9:437–
451, 1992.

[2] E. Fancello, J. P. Ponthot, and L. Stainier. A variational formulation of constitutive models and up-
dates in non-linear finite viscoelasticity. International Journal for Numerical Methods in Engineering,
65(11):1831–1864, 2006.