Inheritance diagram for MatOps::MatStVenantKirchhoff< DIM >:

Collaboration diagram for MatOps::MatStVenantKirchhoff< 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	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	E = 1

double	nu = 0.25

std::vector< double >	defaultMaterialParameters = {E, nu}

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

Definition at line 15 of file MatStVenantKirchhoff.cpp.

Member Typedef Documentation

◆ A

template<int DIM>

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

Definition at line 18 of file MatStVenantKirchhoff.cpp.

Member Function Documentation

◆ getOptions()

template<int DIM>

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

inlineoverridevirtual

Implements MatOps::PhysicalEquations.

Definition at line 20 of file MatStVenantKirchhoff.cpp.

                                                                            {
    MoFEMFunctionBegin;
 
    MOFEM_LOG_CHANNEL("WORLD");
 
    PetscOptionsBegin(PETSC_COMM_WORLD, "stvenant_", "", "none");
    CHKERR PetscOptionsScalar("-young_modulus", "Young modulus", "", E, &E,
                              PETSC_NULLPTR);
    CHKERR PetscOptionsScalar("-poisson_ratio", "poisson ratio", "", nu, &nu,
                              PETSC_NULLPTR);
    PetscOptionsEnd();
 
    MOFEM_TAG_AND_LOG("WORLD", Sev::inform,
                      "Default StVenantKirchhoff parameters:")
        << " E = " << E << " nu = " << nu;
    defaultMaterialParameters = {E, nu};
 
    std::string block_name = "MAT_STVENANTKIRCHHOFF";
 
    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 StVenantKirchhoff")
          << *m << " E = " << block_data[0] << " nu = " << block_data[1];
    }
 
    MoFEMFunctionReturn(0);
  };

◆ recordTape()

template<int DIM>

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

inlineoverridevirtual

Implements MatOps::PhysicalEquations.

Definition at line 86 of file MatStVenantKirchhoff.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;
    FTensor::Tensor2<adouble, DIM, DIM> ta_C;
    FTensor::Tensor2<adouble, DIM, DIM> ta_E;
    FTensor::Tensor2<adouble, DIM, DIM> ta_S;
 
    adouble trE;
 
    trace_on(A::tAg);
    auto p_E = mkparam(E);
    auto p_nu = mkparam(nu);
 
    const auto calc_lambda = [](const auto &young_modulus,
                                const auto &poisson_ratio) {
      const auto nu_value = 1 * poisson_ratio;
      return (young_modulus * nu_value) /
             ((1. + nu_value) * (1. - 2. * nu_value));
    };
 
    const auto calc_mu = [](const auto &young_modulus,
                            const auto &poisson_ratio) {
      const auto nu_value = 1 * poisson_ratio;
      return 0.5 * (young_modulus / (1. + nu_value));
    };
 
    auto lambda = calc_lambda(p_E, p_nu);
    auto mu = calc_mu(p_E, p_nu);
 
    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);
    }
 
    ta_C(I, J) = ta_F(i, I) * ta_F(i, J);
    ta_E(I, J) = (ta_C(I, J) -  t_kd(I, J))/2.;
 
    // Stress Piola II
    trE = ta_E(I, I);
    ta_S(I, J) = (2 * mu) * ta_E(I, J) + lambda * trE * t_kd(I, J);
    // Stress Piola I
    ta_P(i, J) = ta_F(i, I) * ta_S(I, J);
 
    ta_P(i, I) >>= t_P(i, I);
 
    trace_off();
 
    MoFEMFunctionReturn(0);
  }

◆ setParams()

template<int DIM>

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

inlineoverridevirtual

Implements MatOps::PhysicalEquations.

Definition at line 72 of file MatStVenantKirchhoff.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;
  }