MaterialLib::Solids::LinearElasticTransverseIsotropic< DisplacementDim > Class Template Reference

Detailed Description

template<int DisplacementDim>
class MaterialLib::Solids::LinearElasticTransverseIsotropic< DisplacementDim >

Linear transverse isotropic elastic model.

The parameters of the linear transverse isotropic elastic model are

• $E_{i}$, the Young’s modulus within the plane of isotropy,
• $E_{a}$, the Young’s modulus w.r.t. the direction of anisotropy,
• $\nu_{ii}$, the Poisson’s ratio within the plane of isotropy,
• $\nu_{ia}$, the Poisson ratio perpendicular to the plane of isotropy, due to strain in the plane of isotropy,
• $G_{ia}$, the shear modulus between directions of isotropy and anisotropy.

where the subscript $i$ means isotropy, and the subscript $a$ means anisotropy.

With the given parameter, the in-plane shear modulus, $G_{ii}$ is computed as

$$G_{ii} = \frac{E_{i}}{2(1+\nu_{ii})},$$

while the in-plane Poisson ratio, $\nu_{ai}$, which is due to the strain perpendicular to the plane of isotropy, is calculated by the following equation:

$$\nu_{ai} = \nu_{ia} \frac{E_{a}}{E_{i}}.$$

For 3D problems, assuming the plane of isotropy to be spanned by the basis vectors $\mathbf{e}_1$ and $\mathbf{e}_2$, respectively, and the direction of anisotropy is defined by the basis vector $\mathbf{e}_3$, the following relations hold:

$$\begin{eqnarray*} E_{i} &=& E_1 & =& E_2, \\ E_{a} &=& E_3, & &\\ \nu_{ii} &=& \nu_{12} & =& \nu_{21}, \\ \nu_{ia} &=& \nu_{13} & =& \nu_{23}, \\ \nu_{ai} &=& \nu_{31} & =& \nu_{32}, \\ G_{ia} &=& G_{13} & =& G_{23},\\ G_{ai} &=& G_{ia}. & & \end{eqnarray*}$$

Under such assumption, the matrix form of the elastic tensor for strain and stress in the Kelvin vector in the local system is

$$\begin{bmatrix} a_{ii} & b_{ii} &b_{ai} & 0 & 0 & 0\\ b_{ii} & a_{ii} &b_{ai} & 0 & 0 & 0\\ b_{ai} & b_{ai} &a_{ai} & 0 & 0 & 0\\ 0 & 0 & 0 & 2 c_{ii} & 0 & 0\\ 0 & 0 & 0 & 0 & 2 c_{ai} & 0\\ 0 & 0 & 0 & 0 & 0 & 2 c_{ai} \end{bmatrix}.$$

The matrix elements are:

$$\begin{eqnarray*} a_{ii} &=& \frac{1-\nu_{ia}\nu_{ai}}{E_{i} E_{a} D}, \\ a_{ai} &=& \frac{1-\nu_{ii}^2}{E_{i}^2 D}, \\ b_{ii} &=& \frac{\nu_{ii}+\nu_{ia}\nu_{ai}}{E_{i} E_{a} D}, \\ b_{ai} &=& \frac{\nu_{ia}(1+\nu_{ii})}{E_{i}^2 D}, \\ c_{ii} &=& \frac{E_{i}}{2(1+\nu_{ii})}, \\ c_{ai} &=& G_{ia}, \end{eqnarray*}$$

with

$$D = \frac{(1+\nu_{ii})(1-\nu_{ii}-2\nu_{ia}\nu_{ai})}{E_{i}^2E_{a}}.$$

(also see Chapter 9.1 in [22]).

For plane strain problems, assuming the direction of anisotropy is defined by the basis vector $\mathbf{e}_1$, the plane of isotropy to be spanned by the basis vector $\mathbf{e}_0$ and the unit off-plane direction $\mathbf{e}_2$, the following relations hold:

$$\begin{eqnarray*} E_{i} &=& E_1 & =& E_3, \\ E_{a} &=& E_2, & &\\ \nu_{ii} &=& \nu_{13} & =& \nu_{31}, \\ \nu_{ia} &=& \nu_{32} & =& \nu_{12}, \\ \nu_{ai} &=& \nu_{23} & =& \nu_{21}, \\ G_{ia} &=& G_{32} & =& G_{12},\\ G_{ai} &=& G_{ia}. & & \end{eqnarray*}$$

Based on this assumption, the matrix form of the elastic tensor for strain and stress in the Kelvin vector in the local system is

$$\begin{bmatrix} a_{ii} & b_{ai} &b_{ii} & 0\\ b_{ai} & a_{ai} &b_{ai} & 0\\ b_{ii} & b_{ai} &a_{ii} & 0\\ 0 & 0 & 0 & 2 c_{ai} \end{bmatrix}$$

for plane strain problems.

Note

This model requires the definition of a local coordinate system. A local coordinate system can be defined with explicit or implicit bases. The unit norm to the transverse isotropy plane must be input as the parameter value for the base "basis_vector_1" for a 2D local coordinate system, or for the base "basis_vector_2" for a 3D local coordinate system.

See also

ParameterLib::CoordinateSystem.

Definition at line 124 of file LinearElasticTransverseIsotropic.h.

#include <LinearElasticTransverseIsotropic.h>

Inheritance diagram for MaterialLib::Solids::LinearElasticTransverseIsotropic< DisplacementDim >:

Collaboration diagram for MaterialLib::Solids::LinearElasticTransverseIsotropic< DisplacementDim >:

Public Types
using	KelvinVector
using	KelvinMatrix
using	P = ParameterLib::Parameter<double>
Public Types inherited from MaterialLib::Solids::MechanicsBase< DisplacementDim >
using	KelvinVector
using	KelvinMatrix

Public Member Functions
	LinearElasticTransverseIsotropic (P const &E_i, P const &E_a, P const &nu_ii, P const &nu_ia, P const &G_ia, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system)
double	computeFreeEnergyDensity (double const, ParameterLib::SpatialPosition const &, double const, KelvinVector const &eps, KelvinVector const &sigma, typename MechanicsBase< DisplacementDim >::MaterialStateVariables const &) const override
std::optional< std::tuple< typename MechanicsBase< DisplacementDim >::KelvinVector, std::unique_ptr< typename MechanicsBase< DisplacementDim >::MaterialStateVariables >, typename MechanicsBase< DisplacementDim >::KelvinMatrix > >	integrateStress (MaterialPropertyLib::VariableArray const &variable_array_prev, MaterialPropertyLib::VariableArray const &variable_array, double const t, ParameterLib::SpatialPosition const &x, double const dt, typename MechanicsBase< DisplacementDim >::MaterialStateVariables const &material_state_variables) const override
KelvinMatrix	getElasticTensor (double const t, ParameterLib::SpatialPosition const &x, double const T) const
double	getBulkModulus (double const t, ParameterLib::SpatialPosition const &x, KelvinMatrix const *const) const override
LinearElasticTransverseIsotropic< 2 >::KelvinMatrix	getElasticTensor (double const t, ParameterLib::SpatialPosition const &x, double const) const
LinearElasticTransverseIsotropic< 3 >::KelvinMatrix	getElasticTensor (double const t, ParameterLib::SpatialPosition const &x, double const) const
Public Member Functions inherited from MaterialLib::Solids::MechanicsBase< DisplacementDim >
virtual std::unique_ptr< MaterialStateVariables >	createMaterialStateVariables () const
virtual void	initializeInternalStateVariables (double const, ParameterLib::SpatialPosition const &, typename MechanicsBase< DisplacementDim >::MaterialStateVariables &) const
virtual std::optional< std::tuple< KelvinVector, std::unique_ptr< MaterialStateVariables >, KelvinMatrix > >	integrateStress (MaterialPropertyLib::VariableArray const &variable_array_prev, MaterialPropertyLib::VariableArray const &variable_array, double const t, ParameterLib::SpatialPosition const &x, double const dt, MaterialStateVariables const &material_state_variables) const =0
virtual std::vector< InternalVariable >	getInternalVariables () const
virtual ConstitutiveModel	getConstitutiveModel () const
	Gets the type of constitutive model.
virtual double	getTemperatureRelatedCoefficient (double const, double const, ParameterLib::SpatialPosition const &, double const, double const) const
virtual double	computeFreeEnergyDensity (double const t, ParameterLib::SpatialPosition const &x, double const dt, KelvinVector const &eps, KelvinVector const &sigma, MaterialStateVariables const &material_state_variables) const =0
virtual	~MechanicsBase ()=default

Static Public Attributes
static int const	KelvinVectorSize

Protected Attributes
P const &	E_i_p_
	It is the in-plane Young’s modulus, $E_{i}$.
P const &	E_a_p_
P const &	nu_ii_p_
	It is the in-plane Poisson’s ratio, $\nu_{ii}$.
P const &	nu_ia_p_
P const &	G_ia_p_
std::optional< ParameterLib::CoordinateSystem > const &	local_coordinate_system_

Private Member Functions
KelvinMatrix	getElasticTensorLeftTopCorner (double const t, ParameterLib::SpatialPosition const &x) const

Member Typedef Documentation

KelvinMatrix

template<int DisplacementDim>

using MaterialLib::Solids::LinearElasticTransverseIsotropic< DisplacementDim >::KelvinMatrix

Initial value:

 
        MathLib::KelvinVector::KelvinMatrixType<DisplacementDim>

Definition at line 131 of file LinearElasticTransverseIsotropic.h.

KelvinVector

template<int DisplacementDim>

using MaterialLib::Solids::LinearElasticTransverseIsotropic< DisplacementDim >::KelvinVector

Initial value:

 
        MathLib::KelvinVector::KelvinVectorType<DisplacementDim>

Definition at line 129 of file LinearElasticTransverseIsotropic.h.

P

template<int DisplacementDim>

using MaterialLib::Solids::LinearElasticTransverseIsotropic< DisplacementDim >::P = ParameterLib::Parameter<double>

Definition at line 134 of file LinearElasticTransverseIsotropic.h.

Constructor & Destructor Documentation

LinearElasticTransverseIsotropic()

template<int DisplacementDim>

MaterialLib::Solids::LinearElasticTransverseIsotropic< DisplacementDim >::LinearElasticTransverseIsotropic ( P const & E_i, P const & E_a, P const & nu_ii, P const & nu_ia, P const & G_ia, std::optional< ParameterLib::CoordinateSystem > const & local_coordinate_system )

inline

Definition at line 136 of file LinearElasticTransverseIsotropic.h.

        : E_i_p_(E_i),
          E_a_p_(E_a),
          nu_ii_p_(nu_ii),
          nu_ia_p_(nu_ia),
          G_ia_p_(G_ia),
          local_coordinate_system_(local_coordinate_system)
    {
    }

Member Function Documentation

computeFreeEnergyDensity()

template<int DisplacementDim>

double MaterialLib::Solids::LinearElasticTransverseIsotropic< DisplacementDim >::computeFreeEnergyDensity ( double const , ParameterLib::SpatialPosition const & , double const , KelvinVector const & eps, KelvinVector const & sigma, typename MechanicsBase< DisplacementDim >::MaterialStateVariables const &  ) const

inlineoverride

Definition at line 150 of file LinearElasticTransverseIsotropic.h.

    {
        return eps.dot(sigma) / 2;
    }

getBulkModulus()

template<int DisplacementDim>

double MaterialLib::Solids::LinearElasticTransverseIsotropic< DisplacementDim >::getBulkModulus ( double const t, ParameterLib::SpatialPosition const & x, KelvinMatrix const * const  ) const

inlineoverridevirtual

Reimplemented from MaterialLib::Solids::MechanicsBase< DisplacementDim >.

Definition at line 179 of file LinearElasticTransverseIsotropic.h.

    {
        const double E_i = E_i_p_(t, x)[0];
        const double E_a = E_a_p_(t, x)[0];
        const double nu_i = nu_ii_p_(t, x)[0];
        const double nu_ia = nu_ia_p_(t, x)[0];
 
        // Average Young's modulus
        double const E_av = 2. * E_i / 3. + E_a / 3.;
 
        // Poisson ratio in the plane of isotropy, due to the strain
        // perpendicular to the plane of isotropy.  nu_ai=nu_ia*E_a/E_i
        const double nu_ai = nu_ia * E_a / E_i;
 
        // Average Poisson ratio
        //    12     13    21   23   31    32
        //    ai     ai    ia   ii   ia    ii
        const double nu_av = (nu_ai + nu_ia + nu_i) / 3.0;
 
        return E_av / 3 / (1 - 2 * nu_av);
    }

References MaterialLib::Solids::LinearElasticTransverseIsotropic< DisplacementDim >::E_a_p_, MaterialLib::Solids::LinearElasticTransverseIsotropic< DisplacementDim >::E_i_p_, MaterialLib::Solids::LinearElasticTransverseIsotropic< DisplacementDim >::nu_ia_p_, and MaterialLib::Solids::LinearElasticTransverseIsotropic< DisplacementDim >::nu_ii_p_.

getElasticTensor() [1/3]

template<int DisplacementDim>

KelvinMatrix MaterialLib::Solids::LinearElasticTransverseIsotropic< DisplacementDim >::getElasticTensor	(	double const	t,
		ParameterLib::SpatialPosition const &	x,
		double const	T ) const

getElasticTensor() [2/3]

LinearElasticTransverseIsotropic< 2 >::KelvinMatrix MaterialLib::Solids::LinearElasticTransverseIsotropic< 2 >::getElasticTensor	(	double const	t,
		ParameterLib::SpatialPosition const &	x,
		double const	) const

Definition at line 104 of file LinearElasticTransverseIsotropic.cpp.

{
    using namespace MathLib::KelvinVector;
 
    double const G_a = G_ia_p_(t, x)[0];
    double const c_ai = G_a;
 
    KelvinMatrixType<2> C_ortho = getElasticTensorLeftTopCorner(t, x);
 
    C_ortho.template bottomRightCorner<1, 1>().diagonal() << 2 * c_ai;
 
    auto const Q = [this, &x]() -> KelvinMatrixType<2>
    {
        if (!local_coordinate_system_)
        {
            return KelvinMatrixType<2>::Identity();
        }
 
        Eigen::Matrix<double, 2, 2> R = Eigen::Matrix<double, 2, 2>::Identity();
        R.template topLeftCorner<2, 2>().noalias() =
            local_coordinate_system_->transformation<2>(x);
        return fourthOrderRotationMatrix(R);
    }();
 
    // Rotate the forth-order tenser in Kelvin mapping with Q*C_ortho*Q^T and
    // return the top left corner block of size 4x4 for two-dimensional case.
    return Q * C_ortho * Q.transpose();
}

getElasticTensor() [3/3]

LinearElasticTransverseIsotropic< 3 >::KelvinMatrix MaterialLib::Solids::LinearElasticTransverseIsotropic< 3 >::getElasticTensor	(	double const	t,
		ParameterLib::SpatialPosition const &	x,
		double const	) const

Definition at line 137 of file LinearElasticTransverseIsotropic.cpp.

{
    using namespace MathLib::KelvinVector;
 
    double const E_i = E_i_p_(t, x)[0];
    double const nu_i = nu_ii_p_(t, x)[0];
    double const G_a = G_ia_p_(t, x)[0];
 
    double const c_ii = E_i / (2.0 * (1 + nu_i));
    double const c_ai = G_a;
 
    KelvinMatrixType<3> C_ortho = getElasticTensorLeftTopCorner(t, x);
 
    C_ortho.template bottomRightCorner<3, 3>().diagonal() << 2.0 * c_ii,
        2 * c_ai, 2 * c_ai;
 
    auto const Q = [this, &x]() -> KelvinMatrixType<3>
    {
        if (!local_coordinate_system_)
        {
            return KelvinMatrixType<3>::Identity();
        }
        Eigen::Matrix3d R = Eigen::Matrix3d::Identity();
        R.template topLeftCorner<3, 3>().noalias() =
            local_coordinate_system_->transformation<3>(x);
        return fourthOrderRotationMatrix(R);
    }();
 
    // Rotate the forth-order tenser in Kelvin mapping with Q*C_ortho*Q^T and
    // return the 6x6 matrix for in the three-dimensional case.
    return Q * C_ortho * Q.transpose();
}

getElasticTensorLeftTopCorner()

template<int DisplacementDim>

LinearElasticTransverseIsotropic< DisplacementDim >::KelvinMatrix MaterialLib::Solids::LinearElasticTransverseIsotropic< DisplacementDim >::getElasticTensorLeftTopCorner ( double const t, ParameterLib::SpatialPosition const & x ) const

private

Definition at line 57 of file LinearElasticTransverseIsotropic.cpp.

{
    using namespace MathLib::KelvinVector;
    double const E_i = E_i_p_(t, x)[0];
    double const E_a = E_a_p_(t, x)[0];
    double const nu_i = nu_ii_p_(t, x)[0];
    double const nu_ia = nu_ia_p_(t, x)[0];
 
    double const nu_ai = nu_ia * (E_a / E_i);
 
    double const nu_ia_p_nu_ai = nu_ia * nu_ai;
    double const nu_i_p2 = nu_i * nu_i;
    double const E_i_p2 = E_i * E_i;
    // 1/D
    double const one_over_D =
        (E_i_p2 * E_a) / (1.0 - nu_i_p2 - 2.0 * (1.0 + nu_i) * nu_ia_p_nu_ai);
 
    double const fac1 = one_over_D / (E_i * E_a);
    double const fac2 = one_over_D / E_i_p2;
    double const a_ii = (1.0 - nu_ia_p_nu_ai) * fac1;
    double const a_ai = (1.0 - nu_i_p2) * fac2;
    double const b_ii = (nu_i + nu_ia_p_nu_ai) * fac1;
    double const b_ai = (nu_ia * (1.0 + nu_i)) * fac2;
 
    KelvinMatrixType<DisplacementDim> C_ortho =
        KelvinMatrixType<DisplacementDim>::Zero();
 
    if (DisplacementDim == 2)
    {
        // The following data are set based on the condition that the direction
        // of anisotropy is parallel to the second base (base2) of the 2D local
        // coordinate system.
        C_ortho.template topLeftCorner<3, 3>() << a_ii, b_ai, b_ii, b_ai, a_ai,
            b_ai, b_ii, b_ai, a_ii;
 
        return C_ortho;
    }
    C_ortho.template topLeftCorner<3, 3>() << a_ii, b_ii, b_ai, b_ii, a_ii,
        b_ai, b_ai, b_ai, a_ai;
 
    return C_ortho;
}

integrateStress()

template<int DisplacementDim>

std::optional< std::tuple< typename MechanicsBase< DisplacementDim >::KelvinVector, std::unique_ptr< typename MechanicsBase< DisplacementDim >::MaterialStateVariables >, typename MechanicsBase< DisplacementDim >::KelvinMatrix > > MaterialLib::Solids::LinearElasticTransverseIsotropic< DisplacementDim >::integrateStress ( MaterialPropertyLib::VariableArray const & variable_array_prev, MaterialPropertyLib::VariableArray const & variable_array, double const t, ParameterLib::SpatialPosition const & x, double const dt, typename MechanicsBase< DisplacementDim >::MaterialStateVariables const & material_state_variables ) const

override

Definition at line 29 of file LinearElasticTransverseIsotropic.cpp.

{
    auto const& eps_m = std::get<MPL::SymmetricTensor<DisplacementDim>>(
        variable_array.mechanical_strain);
    auto const& eps_m_prev = std::get<MPL::SymmetricTensor<DisplacementDim>>(
        variable_array_prev.mechanical_strain);
    auto const& sigma_prev = std::get<MPL::SymmetricTensor<DisplacementDim>>(
        variable_array_prev.stress);
    auto const& T = variable_array_prev.temperature;
 
    KelvinMatrix C = getElasticTensor(t, x, T);
 
    KelvinVector sigma = sigma_prev + C * (eps_m - eps_m_prev);
 
    return {std::make_tuple(
        sigma,
        std::make_unique<
            typename MechanicsBase<DisplacementDim>::MaterialStateVariables>(),
        C)};
}

References MaterialPropertyLib::VariableArray::mechanical_strain, MaterialPropertyLib::VariableArray::stress, and MaterialPropertyLib::VariableArray::temperature.

Member Data Documentation

E_a_p_

template<int DisplacementDim>

P const& MaterialLib::Solids::LinearElasticTransverseIsotropic< DisplacementDim >::E_a_p_

protected

It is the Young’s modulus w.r.t. the direction of anisotropy, $E_{a}$.

Definition at line 208 of file LinearElasticTransverseIsotropic.h.

Referenced by MaterialLib::Solids::LinearElasticTransverseIsotropic< DisplacementDim >::getBulkModulus().

E_i_p_

template<int DisplacementDim>

P const& MaterialLib::Solids::LinearElasticTransverseIsotropic< DisplacementDim >::E_i_p_

protected

It is the in-plane Young’s modulus, $E_{i}$.

Definition at line 205 of file LinearElasticTransverseIsotropic.h.

Referenced by MaterialLib::Solids::LinearElasticTransverseIsotropic< DisplacementDim >::getBulkModulus().

G_ia_p_

template<int DisplacementDim>

P const& MaterialLib::Solids::LinearElasticTransverseIsotropic< DisplacementDim >::G_ia_p_

protected

It is the shear modulus between directions of isotropy and anisotropy, $G_{ia}$.

Definition at line 216 of file LinearElasticTransverseIsotropic.h.

KelvinVectorSize

template<int DisplacementDim>

int const MaterialLib::Solids::LinearElasticTransverseIsotropic< DisplacementDim >::KelvinVectorSize

static

Initial value:

=
        MathLib::KelvinVector::kelvin_vector_dimensions(DisplacementDim)

Definition at line 127 of file LinearElasticTransverseIsotropic.h.

local_coordinate_system_

template<int DisplacementDim>

std::optional<ParameterLib::CoordinateSystem> const& MaterialLib::Solids::LinearElasticTransverseIsotropic< DisplacementDim >::local_coordinate_system_

protected

Definition at line 218 of file LinearElasticTransverseIsotropic.h.

nu_ia_p_

template<int DisplacementDim>

P const& MaterialLib::Solids::LinearElasticTransverseIsotropic< DisplacementDim >::nu_ia_p_

protected

It is the Poisson ratio perpendicular to the plane of isotropy, due to strain in the plane of isotropy, $\nu_{ia}$.

Definition at line 213 of file LinearElasticTransverseIsotropic.h.

Referenced by MaterialLib::Solids::LinearElasticTransverseIsotropic< DisplacementDim >::getBulkModulus().

nu_ii_p_

template<int DisplacementDim>

P const& MaterialLib::Solids::LinearElasticTransverseIsotropic< DisplacementDim >::nu_ii_p_

protected

It is the in-plane Poisson’s ratio, $\nu_{ii}$.

Definition at line 210 of file LinearElasticTransverseIsotropic.h.

Referenced by MaterialLib::Solids::LinearElasticTransverseIsotropic< DisplacementDim >::getBulkModulus().

---

The documentation for this class was generated from the following files:

• MaterialLib/SolidModels/LinearElasticTransverseIsotropic.h
• MaterialLib/SolidModels/LinearElasticTransverseIsotropic.cpp