NeoHookan equation. More...

#include "users_modules/basic_finite_elements/nonlinear_elastic_materials/src/NeoHookean.hpp"

Inheritance diagram for NeoHookean< TYPE >:

Collaboration diagram for NeoHookean< TYPE >:

Public Types
using	PiolaKirchoffI

Public Member Functions
	NeoHookean ()

MoFEMErrorCode	NeoHooke_PiolaKirchhoffII ()
	calculate second Piola Kirchhoff

virtual MoFEMErrorCode	calculateP_PiolaKirchhoffI (const NonlinearElasticElement::BlockData block_data, boost::shared_ptr< const NumeredEntFiniteElement > fe_ptr)
	Function overload to implement user material.

MoFEMErrorCode	NeoHookean_ElasticEnergy ()
	calculate elastic energy density

MoFEMErrorCode	calculateElasticEnergy (const NonlinearElasticElement::BlockData block_data, boost::shared_ptr< const NumeredEntFiniteElement > fe_ptr)
	Calculate elastic energy density.

Public Member Functions inherited from NonlinearElasticElement::FunctionsToCalculatePiolaKirchhoffI< TYPE >
	FunctionsToCalculatePiolaKirchhoffI ()

virtual	~FunctionsToCalculatePiolaKirchhoffI ()=default

MoFEMErrorCode	calculateC_CauchyDeformationTensor ()

MoFEMErrorCode	calculateE_GreenStrain ()

MoFEMErrorCode	calculateS_PiolaKirchhoffII ()

virtual MoFEMErrorCode	calculateCauchyStress (const BlockData block_data, boost::shared_ptr< const NumeredEntFiniteElement > fe_ptr)
	Function overload to implement user material.

virtual MoFEMErrorCode	setUserActiveVariables (int &nb_active_variables)
	add additional active variables

virtual MoFEMErrorCode	setUserActiveVariables (VectorDouble &activeVariables)
	Add additional independent variables More complex physical models depend on gradient of defamation and some additional variables. For example can depend on temperature. This function adds additional independent variables to the model.

virtual MoFEMErrorCode	calculatesIGma_EshelbyStress (const BlockData block_data, boost::shared_ptr< const NumeredEntFiniteElement > fe_ptr)
	Calculate Eshelby stress.

virtual MoFEMErrorCode	getDataOnPostProcessor (std::map< std::string, std::vector< VectorDouble > > &field_map, std::map< std::string, std::vector< MatrixDouble > > &grad_map)
	Do operations when pre-process.

Public Attributes
TYPE	detC

TYPE	logJ

MatrixBoundedArray< TYPE, 9 >	invC

FTensor::Tensor2< FTensor::PackPtr< TYPE *, 0 >, 3, 3 >	t_invC

FTensor::Index< 'i', 3 >	i

FTensor::Index< 'j', 3 >	j

FTensor::Index< 'k', 3 >	k

Public Attributes inherited from NonlinearElasticElement::FunctionsToCalculatePiolaKirchhoffI< TYPE >
FTensor::Index< 'i', 3 >	i

FTensor::Index< 'j', 3 >	j

FTensor::Index< 'k', 3 >	k

double	lambda

double	mu

MatrixBoundedArray< TYPE, 9 >	F

MatrixBoundedArray< TYPE, 9 >	C

MatrixBoundedArray< TYPE, 9 >	E

MatrixBoundedArray< TYPE, 9 >	S

MatrixBoundedArray< TYPE, 9 >	invF

MatrixBoundedArray< TYPE, 9 >	P

MatrixBoundedArray< TYPE, 9 >	sIGma

MatrixBoundedArray< TYPE, 9 >	h

MatrixBoundedArray< TYPE, 9 >	H

MatrixBoundedArray< TYPE, 9 >	invH

MatrixBoundedArray< TYPE, 9 >	sigmaCauchy

FTensor::Tensor2< FTensor::PackPtr< TYPE *, 0 >, 3, 3 >	t_F

FTensor::Tensor2< FTensor::PackPtr< TYPE *, 0 >, 3, 3 >	t_C

FTensor::Tensor2< FTensor::PackPtr< TYPE *, 0 >, 3, 3 >	t_E

FTensor::Tensor2< FTensor::PackPtr< TYPE *, 0 >, 3, 3 >	t_S

FTensor::Tensor2< FTensor::PackPtr< TYPE *, 0 >, 3, 3 >	t_invF

FTensor::Tensor2< FTensor::PackPtr< TYPE *, 0 >, 3, 3 >	t_P

FTensor::Tensor2< FTensor::PackPtr< TYPE *, 0 >, 3, 3 >	t_sIGma

FTensor::Tensor2< FTensor::PackPtr< TYPE *, 0 >, 3, 3 >	t_h

FTensor::Tensor2< FTensor::PackPtr< TYPE *, 0 >, 3, 3 >	t_H

FTensor::Tensor2< FTensor::PackPtr< TYPE *, 0 >, 3, 3 >	t_invH

FTensor::Tensor2< FTensor::PackPtr< TYPE *, 0 >, 3, 3 >	t_sigmaCauchy

TYPE	J

TYPE	eNergy

TYPE	detH

TYPE	detF

int	gG
	Gauss point number.

CommonData *	commonDataPtr

MoFEM::VolumeElementForcesAndSourcesCore::UserDataOperator *	opPtr
	pointer to finite element tetrahedral operator

Additional Inherited Members
Static Protected Member Functions inherited from NonlinearElasticElement::FunctionsToCalculatePiolaKirchhoffI< TYPE >
static auto	resizeAndSet (MatrixBoundedArray< TYPE, 9 > &m)

Detailed Description

template<typename TYPE>
struct NeoHookean< TYPE >

NeoHookan equation.

Examples: NeoHookean.hpp.

Definition at line 16 of file NeoHookean.hpp.

Member Typedef Documentation

◆ PiolaKirchoffI

template<typename TYPE >

using NeoHookean< TYPE >::PiolaKirchoffI

Initial value:

NonlinearElasticElement::FunctionsToCalculatePiolaKirchhoffI<TYPE>

NonlinearElasticElement::FunctionsToCalculatePiolaKirchhoffI

Implementation of elastic (non-linear) St. Kirchhoff equation.

Definition NonLinearElasticElement.hpp:130

Examples: NeoHookean.hpp.

Definition at line 20 of file NeoHookean.hpp.

Constructor & Destructor Documentation

◆ NeoHookean()

template<typename TYPE >

NeoHookean< TYPE >::NeoHookean ( )

inline

Examples: NeoHookean.hpp.

Definition at line 23 of file NeoHookean.hpp.

24 : NonlinearElasticElement::FunctionsToCalculatePiolaKirchhoffI<TYPE>(),

25 t_invC(PiolaKirchoffI::resizeAndSet(invC)) {}

NeoHookean::invC

MatrixBoundedArray< TYPE, 9 > invC

Definition NeoHookean.hpp:29

NeoHookean::t_invC

FTensor::Tensor2< FTensor::PackPtr< TYPE *, 0 >, 3, 3 > t_invC

Definition NeoHookean.hpp:30

NonlinearElasticElement::FunctionsToCalculatePiolaKirchhoffI::resizeAndSet

static auto resizeAndSet(MatrixBoundedArray< TYPE, 9 > &m)

Definition NonLinearElasticElement.hpp:336

Member Function Documentation

◆ calculateElasticEnergy()

template<typename TYPE >

MoFEMErrorCode NeoHookean< TYPE >::calculateElasticEnergy	(	const NonlinearElasticElement::BlockData	block_data,
		boost::shared_ptr< const NumeredEntFiniteElement >	fe_ptr )

inlinevirtual

Calculate elastic energy density.

\[\Psi = \frac{1}{2}\lambda(\textrm{tr}[\mathbf{E}])^2+\mu\mathbf{E}:\mathbf{E}\]

Reimplemented from NonlinearElasticElement::FunctionsToCalculatePiolaKirchhoffI< TYPE >.

Examples: NeoHookean.hpp.

Definition at line 94 of file NeoHookean.hpp.

                                                             {
    MoFEMFunctionBegin;
 
    this->lambda = LAMBDA(block_data.E, block_data.PoissonRatio);
    this->mu = MU(block_data.E, block_data.PoissonRatio);
    CHKERR this->calculateC_CauchyDeformationTensor();
    this->J = determinantTensor3by3(this->F);
    CHKERR this->NeoHookean_ElasticEnergy();
 
    MoFEMFunctionReturn(0);
  }

◆ calculateP_PiolaKirchhoffI()

template<typename TYPE >

virtual MoFEMErrorCode NeoHookean< TYPE >::calculateP_PiolaKirchhoffI	(	const NonlinearElasticElement::BlockData	block_data,
		boost::shared_ptr< const NumeredEntFiniteElement >	fe_ptr )

inlinevirtual

Function overload to implement user material.

Calculation of Piola Kirchhoff I is implemented by user. Tangent matrix user implemented physical equation is calculated using automatic differentiation.

\(\mathbf{S} = \lambda\textrm{tr}[\mathbf{E}]\mathbf{I}+2\mu\mathbf{E}\)

Notes:
Number of actual Gauss point is accessed from variable gG.
Access to operator data structures is available by variable opPtr.
Access to common data is by commonDataPtr.

Parameters

block_data	used to give access to material parameters
fe_ptr	pointer to element data structures

For details look to:
NONLINEAR CONTINUUM MECHANICS FOR FINITE ELEMENT ANALYSIS, Javier Bonet, Richard D. Wood

Reimplemented from NonlinearElasticElement::FunctionsToCalculatePiolaKirchhoffI< TYPE >.

Examples: NeoHookean.hpp.

Definition at line 62 of file NeoHookean.hpp.

                                                             {
    MoFEMFunctionBegin;
 
    this->lambda = LAMBDA(block_data.E, block_data.PoissonRatio);
    this->mu = MU(block_data.E, block_data.PoissonRatio);
    CHKERR this->calculateC_CauchyDeformationTensor();
    CHKERR this->NeoHooke_PiolaKirchhoffII();
 
    this->t_P(i, j) = this->t_F(i, k) * this->t_S(k, j);
 
    MoFEMFunctionReturn(0);
  }

◆ NeoHooke_PiolaKirchhoffII()

template<typename TYPE >

MoFEMErrorCode NeoHookean< TYPE >::NeoHooke_PiolaKirchhoffII ( )

inline

calculate second Piola Kirchhoff

\(\mathbf{S} = \mu(\mathbf{I}-\mathbf{C}^{-1})+\lambda(\ln{J})\mathbf{C}^{-1}\)

For details look to:
NONLINEAR CONTINUUM MECHANICS FOR FINITE ELEMENT ANALYSIS, Javier Bonet, Richard D. Wood

Examples: NeoHookean.hpp.

Definition at line 46 of file NeoHookean.hpp.

                                             {
    MoFEMFunctionBeginHot;
 
    detC = determinantTensor3by3(this->C);
    CHKERR invertTensor3by3(this->C, detC, invC);
    this->J = determinantTensor3by3(this->F);
 
    logJ = log(sqrt(this->J * this->J));
    constexpr auto t_kd = FTensor::Kronecker_Delta<double>();
 
    this->t_S(i, j) = this->mu * (t_kd(i, j) - t_invC(i, j)) +
                      (this->lambda * logJ) * t_invC(i, j);
 
    MoFEMFunctionReturnHot(0);
  }

◆ NeoHookean_ElasticEnergy()

template<typename TYPE >

MoFEMErrorCode NeoHookean< TYPE >::NeoHookean_ElasticEnergy ( )

inline

calculate elastic energy density

For details look to:
NONLINEAR CONTINUUM MECHANICS FOR FINITE ELEMENT ANALYSIS, Javier Bonet, Richard D. Wood

Examples: NeoHookean.hpp.

Definition at line 85 of file NeoHookean.hpp.

                                            {
    MoFEMFunctionBegin;
    this->eNergy = this->t_C(i, i);
    this->eNergy = 0.5 * this->mu * (this->eNergy - 3);
    logJ = log(sqrt(this->J * this->J));
    this->eNergy += -this->mu * logJ + 0.5 * this->lambda * pow(logJ, 2);
    MoFEMFunctionReturn(0);
  }