Inheritance diagram for MatOps::MatMooneyRivlinWriggersEq63< DIM >:

Collaboration diagram for MatOps::MatMooneyRivlinWriggersEq63< DIM >:

Public Types
using	A = MatElasticImpl< DIM >

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

Public Member Functions
MoFEMErrorCode	getOptions (MoFEM::Interface *m_field_ptr=nullptr) override

MoFEMErrorCode	addBlockParameters (MoFEM::Interface &, const std::string &block_name, int, const Range &block_entities, const std::vector< double > &block_data) override

MoFEMErrorCode	setParams (FEMethod *fe_ptr, int gg) override

MoFEMErrorCode	recordTape () override

Public Member Functions inherited from MatOps::MatElasticImpl< 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)

Protected Attributes
double	alpha = 1

double	beta = 1

double	lambda = 1

double	epsilon = 0

std::vector< double >	defaultMaterialParameters

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

Detailed Description

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

Definition at line 15 of file MatMooneyRivlinWriggersEq63.cpp.

Member Typedef Documentation

◆ A

template<int DIM>

using MatOps::MatMooneyRivlinWriggersEq63< DIM >::A = MatElasticImpl<DIM>

Definition at line 18 of file MatMooneyRivlinWriggersEq63.cpp.

Member Function Documentation

◆ addBlockParameters()

template<int DIM>

MoFEMErrorCode MatOps::MatMooneyRivlinWriggersEq63< DIM >::addBlockParameters	(	MoFEM::Interface &	,
		const std::string &	block_name,
		int	,
		const Range &	block_entities,
		const std::vector< double > &	block_data
	)

inlineoverridevirtual

Reimplemented from MatOps::PhysicalEquations.

Definition at line 72 of file MatMooneyRivlinWriggersEq63.cpp.

                                                                   {
    MoFEMFunctionBegin;
 
    if (block_data.size() < 4) {
      CHK_THROW_MESSAGE(MOFEM_DATA_INCONSISTENCY,
                        "Expected that block has four attributes (alpha, "
                        "beta, lambda, epsilon), but given " +
                            std::to_string(block_data.size()));
    }
    std::vector<double> params = {block_data[0], block_data[1], block_data[2],
                                  block_data[3]};
 
    A::paramVecByRange.push_back({block_entities, params});
 
    MOFEM_TAG_AND_LOG("WORLD", Sev::inform, "MatBlock for Mooney-Rivlin")
        << block_name << " alpha = " << params[0] << " beta = " << params[1]
        << " lambda = " << params[2] << " epsilon = " << params[3];
 
    MoFEMFunctionReturn(0);
  }

◆ getOptions()

template<int DIM>

MoFEMErrorCode MatOps::MatMooneyRivlinWriggersEq63< DIM >::getOptions ( MoFEM::Interface * m_field_ptr = nullptr )

inlineoverridevirtual

Implements MatOps::PhysicalEquations.

Definition at line 20 of file MatMooneyRivlinWriggersEq63.cpp.

                                                                            {
    MoFEMFunctionBegin;
 
    MOFEM_LOG_CHANNEL("WORLD");
 
    PetscOptionsBegin(PETSC_COMM_WORLD, "mooneyrivlin_", "", "none");
    CHKERR PetscOptionsScalar("-alpha", "Alpha", "", alpha, &alpha,
                              PETSC_NULLPTR);
    CHKERR PetscOptionsScalar("-beta", "Beta", "", beta, &beta, PETSC_NULLPTR);
 
    CHKERR PetscOptionsScalar("-lambda", "Lambda", "", lambda, &lambda,
                              PETSC_NULLPTR);
 
    CHKERR PetscOptionsScalar("-epsilon", "Epsilon", "", epsilon, &epsilon,
                              PETSC_NULLPTR);
    PetscOptionsEnd();
 
    MOFEM_TAG_AND_LOG("WORLD", Sev::inform, "Default Mooney-Rivlin parameters:")
        << " alpha = " << alpha << " beta = " << beta << " lambda = " << lambda
        << " epsilon = " << epsilon;
    defaultMaterialParameters = {alpha, beta, lambda, epsilon};
 
    std::string block_name = "MAT_MOONEY_RIVLIN";
 
    for (auto &m :
 
         m_field_ptr->getInterface<MeshsetsManager>()->
 
         getCubitMeshsetPtr(
             std::regex((boost::format("%s(.*)") % block_name).str()))
 
    ) {
 
      std::vector<double> block_data;
      CHKERR m->getAttributes(block_data);
      auto get_block_ents = [&]() {
        Range ents;
        CHK_MOAB_THROW(m_field_ptr->get_moab().get_entities_by_handle(
                           m->meshset, ents, true),
                       "can not get block entities");
        return ents;
      };
 
      CHKERR addBlockParameters(*m_field_ptr, m->getName(),
                                m->getMeshsetId(), get_block_ents(),
                                block_data);
    }
 
    MoFEMFunctionReturn(0);
  };

◆ recordTape()

template<int DIM>

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

inlineoverridevirtual

Implements MatOps::PhysicalEquations.

Definition at line 109 of file MatMooneyRivlinWriggersEq63.cpp.

                                       {
    MoFEMFunctionBegin;
 
    A::matOpsDataPtr->insertCommonData("grad", MatrixDouble());
    A::matOpsDataPtr->insertCommonData("P", MatrixDouble());
    A::matOpsDataPtr->insertCommonData("P_dF", MatrixDouble());
 
    A::matOpsDataPtr->insertActiveData("F", MatrixDouble());
    A::matOpsDataPtr->insertDependentData("P", MatrixDouble());
    A::matOpsDataPtr->insertDependentDerivativesData("P_dF", MatrixDouble());
 
    A::matOpsDataPtr->getActiveDataPtr("F")->resize(DIM, DIM, false);
    A::matOpsDataPtr->getDependentDataPtr("P")->resize(DIM, DIM, false);
 
    auto t_F = getFTensor2FromPtr<DIM, DIM>(
        A::matOpsDataPtr->getActiveDataPtr("F")->data().data());
    auto t_P = getFTensor2FromPtr<DIM, DIM>(
        A::matOpsDataPtr->getDependentDataPtr("P")->data().data());
 
    auto t_kd = FTensor::Kronecker_Delta<int>();
 
    FTENSOR_INDEX(DIM, i);
    FTENSOR_INDEX(DIM, j);
    FTENSOR_INDEX(DIM, I);
    FTENSOR_INDEX(DIM, J);
    FTENSOR_INDEX(DIM, k);
    FTENSOR_INDEX(DIM, K);
 
    t_F(i, J) = 0;
 
    FTensor::Tensor2<adouble, DIM, DIM> ta_F;
    FTensor::Tensor2<adouble, DIM, DIM> ta_P;
    FTensor::Tensor2<adouble, DIM, DIM> ta_Cof;
    FTensor::Tensor2<adouble, DIM, DIM> ta_BF;
    FTensor::Tensor2<adouble, DIM, DIM> ta_BCof;
    adouble ta_Bj, A, B;
 
    adouble det_aF;
    FTensor::Tensor2<adouble, DIM, DIM> ta_invF;
 
    trace_on(A::tAg);
    auto p_alpha = mkparam(alpha);
    auto p_beta = mkparam(beta);
    auto p_lambda = mkparam(lambda);
    auto p_epsilon = mkparam(epsilon);
 
    ta_F(i, J) <<= t_F(i, J);
    // assume that gradient from approximated displacement, that why we add diagonal
    if (!MatElastic::useDeformationGradient) {
      ta_F(i, J) += t_kd(i, J);
    }
 
    det_aF = determinantTensor(ta_F);
    CHKERR invertTensor(ta_F, det_aF, ta_invF);
 
    ta_Cof(i, I) = det_aF * ta_invF(I, i);
 
    A = ta_F(k, K) * ta_F(k, K);
    B = ta_Cof(k, K) * ta_Cof(k, K);
 
    ta_BF(i, I) = 4 * alpha * (A * ta_F(i, I));
    ta_BCof(i, I) = 4 * beta * (B * ta_Cof(i, I));
    ta_Bj = (-12 * alpha - 24 * beta) / det_aF +
            0.5 * (lambda / epsilon) *
                (pow(det_aF, epsilon - 1) - pow(det_aF, -epsilon - 1));
 
    ta_P(i, I) = ta_BF(i, I);
    ta_P(i, I) += (levi_civita(i, j, k) * ta_BCof(j, J)) *
                  (levi_civita(I, J, K) * ta_F(k, K));
    ta_P(i, I) += ta_Cof(i, I) * ta_Bj;
 
    // Set dependent variables to ADOL-C
    ta_P(i, I) >>= t_P(i, I);
 
    trace_off();
 
    MoFEMFunctionReturn(0);
  }

◆ setParams()

template<int DIM>

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

inlineoverridevirtual

Implements MatOps::PhysicalEquations.

Definition at line 95 of file MatMooneyRivlinWriggersEq63.cpp.

                                                              {
    (void)gg;
    const auto ent = fe_ptr->getFEEntityHandle();
    for (auto &[range, param_vec] : A::paramVecByRange) {
      if (std::find(range.begin(), range.end(), ent) != range.end()) {
        set_param_vec(A::tAg, param_vec.size(), param_vec.data());
        return 0;
      }
    }
    set_param_vec(A::tAg, defaultMaterialParameters.size(),
                  defaultMaterialParameters.data());
    return 0;
  }