Interface Law

cRacklet has several interfacial behavior implemented which are described in this section. These law are listed in FractureLawType.

Mixed-mode cohesive law

This cohesive law has its strength decreasing linearly with the opening. The opening considered here is the norm of the opening displacement, thus taking into account both normal and shear componenets. The critical displacement δc is the critical displacement required to transition from the peak stress τc to the residual value τr (By default is 0). The shear and normal components can be prescribed independantly. While the norm of the opening ||δ|| is lower than δc, the strength is given by:

τstr=(τcτr)(1||δ||/δc)

If ||δ|| is larger than δc, the strength is given by:

τstr=τr

Friction law for cohesive law

In addition to the mixed-mode cohesive law, one can defined a friction law to handle cases when the surfaces are in contact with each others.

Coulomb friction

The shear strength is given by the normal stress σyy multiplied by a constant friction coefficient μ

τstr=σyyμ

Regularized Coulomb friction

The classical formulation of Coulomb friction might result in ill-posedness of the friction problem. A simplified regularization is thus implemented, based on Prakash (1998) and Rubin and Ampuero (2007) . The contact pressure is regularized as:

˜σyydt=1t(˜σyyσyy)

with t a regularization parameter. The strength is computed as

τstr=˜σyyμ

Rate and state friction

The rate and state framework involve two functionnals: one for the friction coefficient f(v,ϕ) and one evolution law for the state variable ˙ϕ=g(v,ϕ). Several variations of the friction law and the evolution law are available in cRacklet. Their exact formulations are summarized here:

Pure Weakening Formulation

This formulation is based on the one originaly proposed by Dieterich (1979) and Ruina (1983) :

f(v,ϕ)=f0+alog(v/v)+bf0log(ϕ/ϕ)

Standard Formulation

This formulation is a modified version of the original formulation proposed by Dieterich (1979) and Ruina (1983) , with the addition of +1 in the logarithm.

f(v,ϕ)=f0+alog(1+v/v)+bf0log(1+ϕ/ϕ)

Regularized Formulation

This formulation is a generic N-shape friction law, as supported by experimental observations Bar-Sinai & al. (2014) . See Brener & al. (2018) for a discussion of the physical sense of each term and the comparison with more conventional rate and state friction law.. The steady-state friction is strenghtening at low and high velocities, and has a velocity-weakening branch at intermediate velocities.

f(v,ϕ)=(1+blog(1+ϕϕ))(f0(1+v20/v2)+alog(1+vv))

Regularized Weakening

This formulation is derived from the N-shape one, with the omission of the +1 term in the log of ϕ term, resulting in the absence of the velocity-strengthening branch at high velocites.

f(v,ϕ)=(1+blog(ϕϕ))(f0(1+v20/v2)+alog(1+vv))

Aging Law

The original aging law proposed by Dieterich (1979).

g(ϕ)=1vϕD

Regularized Aging Law

A regularization of the slip law, ensuring that for vanishingly small steady-state velocity the value of the state ϕ saturates to a finite value D/v after long times instead of diverging.

g(ϕ)=1vϕD1+(vv)2

Slip Law

The slip law proposed by Ruina (1983).

g(ϕ)=vϕDlog(vϕD)

Custom interface law

If you want to use a constitutive law that is not implemented in cRacklet, you will need to code it in C++. Please consider creating a merge request for your contribution in GitLab with appropriate documentation if you think that the constitutive behavior you implemented could be used by the community.

If you want to add an evolution law or a friction law that is part of the rate and state framework (depends on a state variable and the sliding velocity), you can define a simple Struct as done in the file rate_and_state_formulations.hh.

Adding a rate and state evolution law

For an evolution law, you need to define the evolution law g(ϕ) as the operator () and the evaluation of g(ϕ) in steady state as the method getSteadyState. In addition, you will need to create an initialization function for the class RateAndStateLaw that allocates a shared pointer to an object of your new “struct” (should be similar to initStateEvolution).

Adding a rate and state friction law

For a friction law, you need to define the friction law f(v,ϕ) as the operator (), the derivative of the friction coefficient with respect to the velocity f(v,ϕ)/v as the method getTangent, the derivative of the steady-state friction coefficient with respect to the steady velocity f(vss)/vss as the method getSteadyTangent, and a method that computes the state value satisfying steady state as getStableState. In addition, an initialization function for the class RateAndStateLaw that allocates a shared pointer to an object of your new “struc” should be defined, similarly to initStandardFormulation.

To create the interface itself, you should create a new entry in the enum FractureLawType with your new law, and create a templated version of the method createUniformInterface and createHeterogeneousInterface for the class Interfacer.

Creating a custom constitutive law

If you want to define a constitutive law that is neither a cohesive law (strength depends only on opening) nor is defined in the rate and state framework (friction depends on velocity and a state variable), you will need to create a new class. This class should inherit from InterfaceLaw and you need to define the following method:

  • initInterfaceConditions: computes the interface fields for the initial conditions.
  • updateInterfaceConditions: computes the interface fields after the displacement has been updated according to the explicit time stepping and the dynamic stresses computed based on the displacement history.
  • restart: save or load the fields required to restart a simulation. This should only concern additional fields used for the constitutive behavior implemented, as the displacement and velocity fields are handled by the mother class.

To solve for the interface fields, you can take inspiration from the classes CohesiveLaw or RateAndStateLaw. With the class CohesiveLaw, the system is well defined and the velocity is directly expressed in terms of the loading, the dynamic stresses and the material parameters. The normal and shear velocities are computed independently. The strength of the interface has to be evaluated against the stress to assess if interface opening is occuring. The RateAndStateLaw however uses an iterative Newton-Raphson procedure to find the value of the velocity and the state variable to satisfy that the interfacial stress is always equal to the strength.

To create the interface itself, you should create a new entry in the enum FractureLawType with your new law, and create a templated version of the method createUniformInterface and createHeterogeneousInterface for the class Interfacer.