MatOps::MatNeohookeanGeneric< M > Struct Template Reference

Inheritance diagram for MatOps::MatNeohookeanGeneric< M >:

Collaboration diagram for MatOps::MatNeohookeanGeneric< M >:

Public Types
using	A = M

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

Static Public Member Functions
static double	getShearModulus (const double c10)
static double	getAbaqusD1 (const double K)
static MoFEMErrorCode	validateMaterialParameters (const double c10, const double K, const char *source)

Protected Attributes
double	C10 = 1
double	K = 2
std::vector< double >	defaultMaterialParameters = {C10, K}
std::vector< double >	commandLineParameters

Detailed Description

template<typename M>
struct MatOps::MatNeohookeanGeneric< M >

Definition at line 25 of file MatNeohookean.cpp.

Member Typedef Documentation

A

template<typename M >

using MatOps::MatNeohookeanGeneric< M >::A = M

Definition at line 26 of file MatNeohookean.cpp.

Member Function Documentation

addBlockParameters()

template<typename M >

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

inlineoverride

Definition at line 119 of file MatNeohookean.cpp.

                                                                   {
    MoFEMFunctionBegin;
 
    const auto json_params =
        m_field.getInterface<JsonConfigManager>()->getParamsFromBlockset(
            "MAT_NEOHOOKEAN", block_id);
    std::vector<double> params;
    if (!json_params.empty()) {
      if (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());
      }
      params = {json_params.at("c10"), json_params.at("k")};
    } else {
      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()));
      }
      params = {block_data[0], block_data[1]};
    }
 
    CHKERR validateMaterialParameters(params[0], params[1],
                                      block_name.c_str());
 
    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]
        << " mu = " << getShearModulus(params[0])
        << " Abaqus D1 = " << getAbaqusD1(params[1]);
 
    MoFEMFunctionReturn(0);
  }

getAbaqusD1()

template<typename M >

static double MatOps::MatNeohookeanGeneric< M >::getAbaqusD1 ( const double  K )

inlinestatic

Definition at line 33 of file MatNeohookean.cpp.

                                                   {
    return 2. / K;
  }

getOptions()

template<typename M >

MoFEMErrorCode MatOps::MatNeohookeanGeneric< M >::getOptions ( MoFEM::Interface *  m_field_ptr = nullptr )

inlineoverride

Definition at line 54 of file MatNeohookean.cpp.

                                                                            {
    MoFEMFunctionBegin;
 
    MOFEM_LOG_CHANNEL("WORLD");
 
    if (!A::paramVecByRange.empty()) {
      for (const auto &[range, parameters] : A::paramVecByRange) {
        (void)range;
        if (parameters.size() != 2) {
          SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                  "Neohookean material range needs exactly C10 and K");
        }
        CHKERR validateMaterialParameters(parameters[0], parameters[1],
                                          "preconfigured material range");
      }
      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();
    CHKERR validateMaterialParameters(C10, K, "command-line parameters");
    defaultMaterialParameters = {C10, K};
 
    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
          << " mu = " << getShearModulus(C10)
          << " Abaqus D1 = " << getAbaqusD1(K);
    }
 
    MoFEMFunctionReturn(0);
  }

getShearModulus()

template<typename M >

static double MatOps::MatNeohookeanGeneric< M >::getShearModulus ( const double  c10 )

inlinestatic

Definition at line 29 of file MatNeohookean.cpp.

                                                         {
    return 2. * c10;
  }

validateMaterialParameters()

template<typename M >

static MoFEMErrorCode MatOps::MatNeohookeanGeneric< M >::validateMaterialParameters ( const double  c10, const double  K, const char *  source  )

inlinestatic

Definition at line 37 of file MatNeohookean.cpp.

                                                                       {
    MoFEMFunctionBegin;
    if (!std::isfinite(c10) || c10 <= 0.) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA,
              "Neohookean C10 must be finite and positive in %s", source);
    }
    if (!std::isfinite(K) || K <= 0.) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA,
              "Neohookean bulk modulus K must be finite and positive in %s "
              "(received C10=%.16g, K=%.16g)",
              source, c10, K);
    }
    MoFEMFunctionReturn(0);
  }

Member Data Documentation

C10

template<typename M >

double MatOps::MatNeohookeanGeneric< M >::C10 = 1

protected

Definition at line 160 of file MatNeohookean.cpp.

commandLineParameters

template<typename M >

std::vector<double> MatOps::MatNeohookeanGeneric< M >::commandLineParameters

protected

Definition at line 163 of file MatNeohookean.cpp.

defaultMaterialParameters

template<typename M >

std::vector<double> MatOps::MatNeohookeanGeneric< M >::defaultMaterialParameters = {C10, K}

protected

Definition at line 162 of file MatNeohookean.cpp.

{C10, K};

K

template<typename M >

double MatOps::MatNeohookeanGeneric< M >::K = 2

protected

Definition at line 161 of file MatNeohookean.cpp.

---

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

• src/materials/impl/MatNeohookean.cpp