MatOps::MatNeohookean< DIM > Struct Template Reference

Inheritance diagram for MatOps::MatNeohookean< DIM >:

Collaboration diagram for MatOps::MatNeohookean< 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 &m_field, const std::string &block_name, int block_id, 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	C10 = 1
double	K = 1
std::vector< double >	commandLineParameters

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::MatNeohookean< DIM >

Definition at line 14 of file MatNeohookean.cpp.

Member Typedef Documentation

A

template<int DIM>

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

Definition at line 17 of file MatNeohookean.cpp.

Member Function Documentation

addBlockParameters()

template<int DIM>

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

inlineoverridevirtual

Reimplemented from MatOps::PhysicalEquations.

Definition at line 71 of file MatNeohookean.cpp.

                                                                   {
    MoFEMFunctionBegin;
 
    const auto json_params =
        m_field.getInterface<JsonConfigManager>()->getParamsFromBlockset(
            "MAT_NEOHOOKEAN", block_id);
    if (!json_params.empty() && (json_params.size() != 2 ||
                                 json_params.find("c10") == json_params.end() ||
                                 json_params.find("k") == json_params.end())) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
              "Neohookean JSON block %s needs exactly C10 and K attributes",
              block_name.c_str());
    }
 
    if (block_data.size() < 2) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
              "Neohookean block %s has %d attributes; expected C10 and K",
              block_name.c_str(), static_cast<int>(block_data.size()));
    }
    std::vector<double> params = {block_data[0], block_data[1]};
 
    A::paramVecByRange.push_back({block_entities, params});
 
    MOFEM_TAG_AND_LOG("WORLD", Sev::inform, "MatBlock for Neohookean")
        << block_name << " C10 = " << params[0] << " K = " << params[1];
 
    MoFEMFunctionReturn(0);
  }

getOptions()

template<int DIM>

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

inlineoverridevirtual

Implements MatOps::PhysicalEquations.

Definition at line 19 of file MatNeohookean.cpp.

                                                                            {
    MoFEMFunctionBegin;
 
    MOFEM_LOG_CHANNEL("WORLD");
 
    if (!A::paramVecByRange.empty()) {
      MoFEMFunctionReturnHot(0);
    }
 
    PetscOptionsBegin(PETSC_COMM_WORLD, "neo_hookean_", "", "none");
    CHKERR PetscOptionsScalar("-c10", "C10", "", C10, &C10, PETSC_NULLPTR);
    CHKERR PetscOptionsScalar("-K", "Bulk modulus K", "", K, &K,
                              PETSC_NULLPTR);
    PetscOptionsEnd();
 
    std::string block_name = "MAT_NEOHOOKEAN";
 
    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);
    }
 
    if (A::paramVecByRange.empty()) {
      commandLineParameters = {C10, K};
      MOFEM_TAG_AND_LOG("WORLD", Sev::inform,
                        "Command line Neohookean parameters")
          << "C10 = " << C10 << " K = " << K;
    }
 
    MoFEMFunctionReturn(0);
  }

recordTape()

template<int DIM>

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

inlineoverridevirtual

Implements MatOps::PhysicalEquations.

Definition at line 122 of file MatNeohookean.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);
 
    t_F(i, J) = 0;
 
    FTensor::Tensor2<adouble, DIM, DIM> ta_F;
    FTensor::Tensor2<adouble, DIM, DIM> ta_P;
 
    adouble det_aF;
    FTensor::Tensor2<adouble, DIM, DIM> ta_invF;
 
    trace_on(A::tAg);
    auto p_c10 = mkparam(C10);
    auto p_K = mkparam(K);
 
    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_P(i, I) = 2. * p_c10 * (ta_F(i, I) - ta_invF(i, I)) +
                 p_K * log(det_aF) * ta_invF(i, I);
 
    ta_P(i, I) >>= t_P(i, I);
 
    trace_off();
 
    MoFEMFunctionReturn(0);
  }

setParams()

template<int DIM>

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

inlineoverridevirtual

Implements MatOps::PhysicalEquations.

Definition at line 102 of file MatNeohookean.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;
      }
    }
    // command line overrides block parameters
    if (!commandLineParameters.empty()) {
      set_param_vec(A::tAg, commandLineParameters.size(),
                    commandLineParameters.data());
      return 0;
    }
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "Neohookean material parameters not found for entity %lu",
            static_cast<unsigned long>(ent));
  }

Member Data Documentation

C10

template<int DIM>

double MatOps::MatNeohookean< DIM >::C10 = 1

protected

Definition at line 180 of file MatNeohookean.cpp.

commandLineParameters

template<int DIM>

std::vector<double> MatOps::MatNeohookean< DIM >::commandLineParameters

protected

Definition at line 182 of file MatNeohookean.cpp.

K

template<int DIM>

double MatOps::MatNeohookean< DIM >::K = 1

protected

Definition at line 181 of file MatNeohookean.cpp.

---

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

• src/materials/impl/MatNeohookean.cpp