MatOps::OpEvalMatHuHuImpl< DIM, DomainEleOp > Struct Template Reference

Inheritance diagram for MatOps::OpEvalMatHuHuImpl< DIM, DomainEleOp >:

Collaboration diagram for MatOps::OpEvalMatHuHuImpl< DIM, DomainEleOp >:

Public Member Functions
	OpEvalMatHuHuImpl (boost::shared_ptr< PhysicalEquations > physical_ptr, bool eval_stress, bool eval_tangent)
MoFEMErrorCode	doWork (int side, EntityType type, EntData &data)

Protected Attributes
boost::shared_ptr< PhysicalEquations >	physicalPtr
const bool	evalStress
const bool	evalTangent

Detailed Description

template<int DIM, typename DomainEleOp>
struct MatOps::OpEvalMatHuHuImpl< DIM, DomainEleOp >

Definition at line 150 of file MatHuHu.cpp.

Constructor & Destructor Documentation

OpEvalMatHuHuImpl()

template<int DIM, typename DomainEleOp >

MatOps::OpEvalMatHuHuImpl< DIM, DomainEleOp >::OpEvalMatHuHuImpl ( boost::shared_ptr< PhysicalEquations >  physical_ptr, bool  eval_stress, bool  eval_tangent  )

inline

Definition at line 152 of file MatHuHu.cpp.

      : DomainEleOp("U", DomainEleOp::OPROW), physicalPtr(physical_ptr),
        evalStress(eval_stress), evalTangent(eval_tangent) {}

Member Function Documentation

doWork()

template<int DIM, typename DomainEleOp >

MoFEMErrorCode MatOps::OpEvalMatHuHuImpl< DIM, DomainEleOp >::doWork	(	int	side,
		EntityType	type,
		EntData &	data
	)

Definition at line 166 of file MatHuHu.cpp.

                                                                            {
  MoFEMFunctionBegin;
  int nb_dofs = data.getIndices().size();
  if (!nb_dofs)
    MoFEMFunctionReturnHot(0);
  int nb_integration_pts = data.getN().size1();
  auto *fe_ptr = const_cast<FEMethod *>(this->getFEMethod());
  const auto ent = fe_ptr->getFEEntityHandle();
 
  auto get_tag = [&]() {
    if (physicalPtr->tagVsRangePtr) {
      for (const auto &tag_range_pair : *physicalPtr->tagVsRangePtr) {
        if (tag_range_pair.second.find(ent) != tag_range_pair.second.end()) {
          return tag_range_pair.first;
        }
      }
    }
    return physicalPtr->tAg; // Default tag if no range matches
  };
 
  const int current_tag = get_tag();
 
  auto mat_grad_ptr = physicalPtr->matOpsDataPtr->getCommonDataPtr("grad");
  auto mat_k_ptr = physicalPtr->matOpsDataPtr->getCommonDataPtr("k");
  auto mat_k_dF_ptr = physicalPtr->matOpsDataPtr->getCommonDataPtr("k_dF");
 
#ifndef NDEBUG
  if (!mat_grad_ptr || !mat_k_ptr || !mat_k_dF_ptr) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
            "Missing common data for ADOL-C evaluation");
  }
  if (mat_grad_ptr->size2() != DIM * DIM) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
            "Inconsistent size of gradient matrix for ADOL-C evaluation");
  }
  if (mat_grad_ptr->size1() != nb_integration_pts) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
            "Inconsistent size of gradient matrix data for ADOL-C evaluation");
  }
#endif
 
  using DL = DataLayoutTraits<DataLayout::GaussByCoeffs>;
  auto get_grad_at_pts =
      MatrixSizeHelper<GetFTensor2FromMatType<DIM, DIM, -1, DL>, DL>::get(
          *mat_grad_ptr, nb_integration_pts);
  auto get_k_at_pts =
      MatrixSizeHelper<GetFTensor1FromMatType<1, -1, DL>, DL>::size(
          *mat_k_ptr, nb_integration_pts);
  auto get_k_dF_at_pts =
      MatrixSizeHelper<GetFTensor2FromMatType<DIM, DIM, -1, DL>, DL>::size(
          *mat_k_dF_ptr, nb_integration_pts);
 
  if (evalStress) {
    FTENSOR_INDEX(DIM, i);
    FTENSOR_INDEX(DIM, J);
    FTENSOR_INDEX(DIM, K);
    FTENSOR_INDEX(DIM, L);
 
    auto t_grad_at_pts = get_grad_at_pts();
    auto t_k_at_pts = get_k_at_pts();
 
    auto next = [&]() {
      ++t_grad_at_pts;
      ++t_k_at_pts;
    };
 
    auto t_kd = FTensor::Kronecker_Delta<int>();
 
    for (auto gg = 0; gg != nb_integration_pts; ++gg) {
      auto t_F = getFTensor2FromPtr<DIM, DIM>(
          physicalPtr->matOpsDataPtr->getActiveDataPtr("F")->data().data());
      t_F(i, J) = t_grad_at_pts(i, J) + t_kd(i, J);
      CHKERR physicalPtr->setParams(fe_ptr, gg);
      CHKERR physicalPtr->evaluateVariable(current_tag, ent, gg);
      t_k_at_pts(0) =
          (*physicalPtr->matOpsDataPtr->getDependentDataPtr("k"))(0, 0);
      next();
    }
  }
 
  if (evalTangent) {
    FTENSOR_INDEX(DIM, i);
    FTENSOR_INDEX(DIM, J);
    FTENSOR_INDEX(DIM, k);
    FTENSOR_INDEX(DIM, L);
 
    auto t_grad_at_pts = get_grad_at_pts();
    auto t_k_dF_at_pts = get_k_dF_at_pts();
    auto t_kd = FTensor::Kronecker_Delta<int>();
 
    auto next = [&]() {
      ++t_grad_at_pts;
      ++t_k_dF_at_pts;
    };
 
    for (auto gg = 0; gg != nb_integration_pts; ++gg) {
      auto t_F = getFTensor2FromPtr<DIM, DIM>(
          physicalPtr->matOpsDataPtr->getActiveDataPtr("F")->data().data());
      t_F(i, J) = t_grad_at_pts(i, J) + t_kd(i, J);
      CHKERR physicalPtr->setParams(fe_ptr, gg);
      CHKERR physicalPtr->evaluateDerivatives(current_tag, ent, gg);
      auto t_k_dF = getFTensor2FromPtr<DIM, DIM>(
          physicalPtr->matOpsDataPtr->getDependentDerivativesDataPtr("k_dF")
              ->data()
              .data());
      t_k_dF_at_pts(i, J) = t_k_dF(i, J);
      next();
    }
  }
 
  MoFEMFunctionReturn(0);
}

Member Data Documentation

evalStress

template<int DIM, typename DomainEleOp >

const bool MatOps::OpEvalMatHuHuImpl< DIM, DomainEleOp >::evalStress

protected

Definition at line 161 of file MatHuHu.cpp.

evalTangent

template<int DIM, typename DomainEleOp >

const bool MatOps::OpEvalMatHuHuImpl< DIM, DomainEleOp >::evalTangent

protected

Definition at line 162 of file MatHuHu.cpp.

physicalPtr

template<int DIM, typename DomainEleOp >

boost::shared_ptr<PhysicalEquations> MatOps::OpEvalMatHuHuImpl< DIM, DomainEleOp >::physicalPtr

protected

Definition at line 160 of file MatHuHu.cpp.

---

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

• src/materials/impl/MatHuHu.cpp