AdolCOps::AdolCNeohookean< DIM > Struct Template Reference

Inheritance diagram for AdolCOps::AdolCNeohookean< DIM >:

Collaboration diagram for AdolCOps::AdolCNeohookean< DIM >:

Public Types
using	A = AdolCElasticImpl< DIM >

Public Member Functions
MoFEMErrorCode	getOptions (MoFEM::Interface *m_field_ptr=nullptr) override
MoFEMErrorCode	setParams (EntityHandle ent, int gg) override
MoFEMErrorCode	recordTape () override
Public Member Functions inherited from AdolCOps::AdolCElasticImpl< DIM >
ForcesAndSourcesCore::UserDataOperator *	createOp (boost::shared_ptr< PhysicalEquations > physical_ptr, bool eval_stress, bool eval_tangent) override
ForcesAndSourcesCore::UserDataOperator *	createOp (boost::shared_ptr< PhysicalEquations > physical_ptr, bool eval_stress, bool eval_tangent)
ForcesAndSourcesCore::UserDataOperator *	createOp (boost::shared_ptr< PhysicalEquations > physical_ptr, bool eval_stress, bool eval_tangent)
	PhysicalEquations ()=delete
	PhysicalEquations (boost::shared_ptr< ADolCData > adolc_data_ptr, int tag, boost::shared_ptr< std::map< int, Range > > tag_vs_range_ptr=nullptr)
Public Member Functions inherited from AdolCOps::PhysicalEquations
	PhysicalEquations ()=delete
	PhysicalEquations (boost::shared_ptr< ADolCData > adolc_data_ptr, int tag, boost::shared_ptr< std::map< int, Range > > tag_vs_range_ptr=nullptr)
virtual	~PhysicalEquations ()=default
MoFEMErrorCode	setActiveContinuousVector ()
MoFEMErrorCode	setDependentContinuousVector ()
MoFEMErrorCode	setDependentDerivativesContinuousVector ()
MoFEMErrorCode	getActiveContinuousVector ()
MoFEMErrorCode	getDependentContinuousVector ()
MoFEMErrorCode	getDependentDerivativesContinuousVector ()

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

Additional Inherited Members
Public Attributes inherited from AdolCOps::PhysicalEquations
int	tAg
boost::shared_ptr< std::map< int, Range > >	tagVsRangePtr
std::vector< std::pair< Range, std::vector< double > > >	paramVecByRange
boost::shared_ptr< ADolCData >	adolcDataPtr
std::vector< double >	activeVariables
std::vector< double >	dependentVariables
std::vector< double >	dependentVariablesDerivatives

Detailed Description

template<int DIM>
struct AdolCOps::AdolCNeohookean< DIM >

Definition at line 14 of file AdolCNeohookean.cpp.

Member Typedef Documentation

A

template<int DIM>

using AdolCOps::AdolCNeohookean< DIM >::A = AdolCElasticImpl<DIM>

Definition at line 17 of file AdolCNeohookean.cpp.

Member Function Documentation

getOptions()

template<int DIM>

MoFEMErrorCode AdolCOps::AdolCNeohookean< DIM >::getOptions ( MoFEM::Interface *  m_field_ptr = nullptr )

inlineoverridevirtual

Implements AdolCOps::PhysicalEquations.

Definition at line 19 of file AdolCNeohookean.cpp.

                                                                            {
    MoFEMFunctionBegin;
 
    MOFEM_LOG_CHANNEL("WORLD");
 
    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();
 
    MOFEM_TAG_AND_LOG("WORLD", Sev::inform, "Default Neohookean parameters:")
        << " C10 = " << C10 << " K = " << K;
    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);
      if (block_data.size() < 2) {
        CHK_THROW_MESSAGE(MOFEM_DATA_INCONSISTENCY,
                          "Expected that block has two attribute");
      }
      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;
      };
 
      A::paramVecByRange.push_back(
          {get_block_ents(), {block_data[0], block_data[1]}});
 
      MOFEM_TAG_AND_LOG("WORLD", Sev::inform, "MatBlock for Neohookean")
          << *m << " C10 = " << block_data[0] << " K = " << block_data[1];
    }
 
    MoFEMFunctionReturn(0);
  };

recordTape()

template<int DIM>

MoFEMErrorCode AdolCOps::AdolCNeohookean< DIM >::recordTape ( )

inlineoverridevirtual

Implements AdolCOps::PhysicalEquations.

Definition at line 80 of file AdolCNeohookean.cpp.

                                       {
    MoFEMFunctionBegin;
 
    A::adolcDataPtr->insertCommonData("grad", MatrixDouble(DIM * DIM, 1));
    A::adolcDataPtr->insertCommonData("P", MatrixDouble(DIM * DIM, 1));
    A::adolcDataPtr->insertCommonData("P_dF",
                                      MatrixDouble(DIM * DIM, DIM * DIM));
 
    A::adolcDataPtr->insertActiveData("F", MatrixDouble(DIM, DIM));
    A::adolcDataPtr->insertDependentData("P", MatrixDouble(DIM, DIM));
    A::adolcDataPtr->insertDependentDerivativesData(
        "P_dF", MatrixDouble(DIM * DIM, DIM * DIM));
 
    auto t_F = getFTensor2FromPtr<DIM, DIM>(
        A::adolcDataPtr->getActiveDataPtr("F")->data().data());
    auto t_P = getFTensor2FromPtr<DIM, DIM>(
        A::adolcDataPtr->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
    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 AdolCOps::AdolCNeohookean< DIM >::setParams ( EntityHandle  ent, int  gg  )

inlineoverridevirtual

Implements AdolCOps::PhysicalEquations.

Definition at line 68 of file AdolCNeohookean.cpp.

                                                              {
    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;
  }

Member Data Documentation

C10

template<int DIM>

double AdolCOps::AdolCNeohookean< DIM >::C10 = 1

protected

Definition at line 135 of file AdolCNeohookean.cpp.

defaultMaterialParameters

template<int DIM>

std::vector<double> AdolCOps::AdolCNeohookean< DIM >::defaultMaterialParameters = {C10, K}

protected

Definition at line 137 of file AdolCNeohookean.cpp.

{C10, K};

K

template<int DIM>

double AdolCOps::AdolCNeohookean< DIM >::K = 1

protected

Definition at line 136 of file AdolCNeohookean.cpp.

---

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

• src/adolc/impl/AdolCNeohookean.cpp