MatOps::TopoDerivativeMatElasticImpl< DIM > Struct Template Reference

Inheritance diagram for MatOps::TopoDerivativeMatElasticImpl< DIM >:

Collaboration diagram for MatOps::TopoDerivativeMatElasticImpl< DIM >:

Public Types
using	A = MatNeohookeanGeneric< TopoMatElasticImpl< DIM > >
Public Types inherited from MatOps::MatNeohookeanGeneric< TopoMatElasticImpl< DIM > >
using	A = TopoMatElasticImpl< DIM >
Public Types inherited from MatOps::PhysicalEquations
using	HookFunction = std::function< MoFEMErrorCode(boost::shared_ptr< MatOpsData >, int, EntityHandle, int)>

Public Member Functions
MoFEMErrorCode	setParams (FEMethod *fe_ptr, int gg) override
MoFEMErrorCode	recordTape () override
Public Member Functions inherited from MatOps::MatNeohookeanGeneric< TopoMatElasticImpl< DIM > >
MoFEMErrorCode	getOptions (MoFEM::Interface *m_field_ptr=nullptr) override
Public Member Functions inherited from MatOps::TopoMatElasticImpl< DIM >
ForcesAndSourcesCore::UserDataOperator *	createOp (boost::shared_ptr< PhysicalEquations > physical_ptr, bool eval_stress, bool eval_tangent, bool update) override
ForcesAndSourcesCore::UserDataOperator *	createOp (boost::shared_ptr< PhysicalEquations > physical_ptr, bool eval_stress, bool eval_tangent, bool update)
ForcesAndSourcesCore::UserDataOperator *	createOp (boost::shared_ptr< PhysicalEquations > physical_ptr, bool eval_stress, bool eval_tangent, bool update)
Public Member Functions inherited from MatOps::MatElastic
	PhysicalEquations ()=delete
	PhysicalEquations (boost::shared_ptr< MatOpsData > mat_ops_data_ptr, int tag, boost::shared_ptr< std::map< int, Range > > tag_vs_range_ptr=nullptr)
Public Member Functions inherited from MatOps::PhysicalEquations
	PhysicalEquations ()=delete
	PhysicalEquations (boost::shared_ptr< MatOpsData > mat_ops_data_ptr, int tag, boost::shared_ptr< std::map< int, Range > > tag_vs_range_ptr=nullptr)
virtual	~PhysicalEquations ()=default
virtual MoFEMErrorCode	evaluateVariable (int tag, EntityHandle entity, int gg)
virtual MoFEMErrorCode	evaluateDerivatives (int tag, EntityHandle entity, int gg)
virtual MoFEMErrorCode	updateState (int tag, EntityHandle entity, int gg)

Additional Inherited Members
Public Attributes inherited from MatOps::PhysicalEquations
HookFunction	hookEvaluateVariable = AdolCEvaluation::evaluateVariable
HookFunction	hookEvaluateDerivatives = AdolCEvaluation::evaluateDerivatives
HookFunction	hookUpdateState = AdolCEvaluation::evaluateVariable
int	tAg
boost::shared_ptr< std::map< int, Range > >	tagVsRangePtr
std::vector< std::pair< Range, std::vector< double > > >	paramVecByRange
boost::shared_ptr< MatOpsData >	matOpsDataPtr
Static Public Attributes inherited from MatOps::MatElastic
static bool	useDeformationGradient
Protected Attributes inherited from MatOps::MatNeohookeanGeneric< TopoMatElasticImpl< DIM > >
double	C10
double	K
std::vector< double >	defaultMaterialParameters

Detailed Description

template<int DIM>
struct MatOps::TopoDerivativeMatElasticImpl< DIM >

Definition at line 165 of file MatNeohookean.cpp.

Member Typedef Documentation

A

template<int DIM>

using MatOps::TopoDerivativeMatElasticImpl< DIM >::A = MatNeohookeanGeneric<TopoMatElasticImpl<DIM> >

Definition at line 167 of file MatNeohookean.cpp.

Member Function Documentation

recordTape()

template<int DIM>

MoFEMErrorCode MatOps::TopoDerivativeMatElasticImpl< DIM >::recordTape ( )

inlineoverridevirtual

Implements MatOps::PhysicalEquations.

Definition at line 201 of file MatNeohookean.cpp.

                                       {
    MoFEMFunctionBegin;
 
    A::matOpsDataPtr->insertCommonData("Jac", MatrixDouble());
    A::matOpsDataPtr->insertCommonData("grad", MatrixDouble());
    A::matOpsDataPtr->insertCommonData("var_grad", MatrixDouble());
    A::matOpsDataPtr->insertActiveData("Jac", MatrixDouble(DIM, DIM));
    A::matOpsDataPtr->insertDependentData("Obj", MatrixDouble(1, 1));
    A::matOpsDataPtr->insertDependentDerivativesData("dObj",
                                                     MatrixDouble(DIM, DIM));
 
    auto t_jac = getFTensor2FromPtr<DIM, DIM>(
        A::matOpsDataPtr->getActiveDataPtr("Jac")->data().data());
    auto &obj = (*A::matOpsDataPtr->getDependentDataPtr("Obj"))(0, 0);
 
    auto t_kd = FTensor::Kronecker_Delta<int>();
 
    FTENSOR_INDEXES(DIM, i, J);
    t_jac(i, J) = t_kd(i, J);
 
    FTensor::Tensor2<adouble, DIM, DIM> tp_F;
    FTensor::Tensor2<adouble, DIM, DIM> tp_var_F;
    FTensor::Tensor2<adouble, DIM, DIM> ta_jac;
    FTensor::Tensor2<adouble, DIM, DIM> ta_F;
    FTensor::Tensor2<adouble, DIM, DIM> ta_P;
    adouble det_aF;
    FTensor::Tensor2<adouble, DIM, DIM> ta_invF;
 
    adouble ta_obj;
    adouble det;
 
    trace_on(A::tAg);
 
    for (int ii = 0; ii < DIM; ++ii) {
      for (int JJ = 0; JJ < DIM; ++JJ) {
        tp_F(ii, JJ) = mkparam(0.);
      }
    }
    for (int ii = 0; ii < DIM; ++ii) {
      for (int JJ = 0; JJ < DIM; ++JJ) {
        tp_var_F(ii, JJ) = mkparam(0.);
      }
    }
    auto p_c10 = mkparam(this->C10);
    auto p_K = mkparam(this->K);
 
    FTENSOR_INDEX(DIM, I);
    FTENSOR_INDEX(DIM, K);
 
    ta_jac(i, J) <<= t_jac(i, J);
    det = determinantTensor(ta_jac);
 
    if (MatElastic::useDeformationGradient) {
      ta_F(i, J) = ta_jac(J, K) * tp_F(i, K);
    } else {
      ta_F(i, J) = ta_jac(J, K) * (tp_F(i, K) + t_kd(i, K));
    }
 
    det_aF = determinantTensor(ta_F);
    CHKERR invertTensor(ta_F, det_aF, ta_invF);
    ta_P(i, I) = 2. * p_c10 * (ta_F(i, I) - ta_invF(i, I)) +
                 p_K * log(det_aF) * ta_invF(i, I);
    ta_obj = det * ta_P(i, I) * ta_jac(I, K) * tp_var_F(i, K);
    ta_obj >>= obj;
 
    trace_off();
 
    MoFEMFunctionReturn(0);
  }

setParams()

template<int DIM>

MoFEMErrorCode MatOps::TopoDerivativeMatElasticImpl< DIM >::setParams ( FEMethod *  fe_ptr, int  gg  )

inlineoverridevirtual

Implements MatOps::PhysicalEquations.

Definition at line 170 of file MatNeohookean.cpp.

                                                              {
    (void)gg;
    std::vector<double> adolc_c_param_vec;
    auto grad = A::matOpsDataPtr->getCommonDataPtr("grad");
    auto var_grad = A::matOpsDataPtr->getCommonDataPtr("var_grad");
    adolc_c_param_vec.reserve(grad->size2() + var_grad->size2() +
                              this->defaultMaterialParameters.size());
 
    for (auto cc = 0; cc < grad->size2(); ++cc) {
      adolc_c_param_vec.push_back((*grad)(gg, cc));
    }
    for (auto cc = 0; cc < var_grad->size2(); ++cc) {
      adolc_c_param_vec.push_back((*var_grad)(gg, cc));
    }
    const auto ent = fe_ptr->getFEEntityHandle();
    for (auto &[range, param_vec] : A::paramVecByRange) {
      if (std::find(range.begin(), range.end(), ent) != range.end()) {
        adolc_c_param_vec.insert(adolc_c_param_vec.end(), param_vec.begin(),
                                 param_vec.end());
        set_param_vec(A::tAg, adolc_c_param_vec.size(),
                      adolc_c_param_vec.data());
        return 0;
      }
    }
    adolc_c_param_vec.insert(adolc_c_param_vec.end(),
                             this->defaultMaterialParameters.begin(),
                             this->defaultMaterialParameters.end());
    set_param_vec(A::tAg, adolc_c_param_vec.size(), adolc_c_param_vec.data());
    return 0;
  }

---

The documentation for this struct was generated from the following file:

• src/materials/impl/MatNeohookean.cpp