OpFaceSideMaterialForce Struct Reference

#include "users_modules/eshelbian_plasticity/src/EshelbianOperators.hpp"

Inheritance diagram for OpFaceSideMaterialForce:

Collaboration diagram for OpFaceSideMaterialForce:

Public Types
using	OP = VolumeElementForcesAndSourcesCoreOnSide::UserDataOperator

Public Member Functions
	OpFaceSideMaterialForce (boost::shared_ptr< DataAtIntegrationPts > data_ptr)
MoFEMErrorCode	doWork (int side, EntityType type, EntData &data)

Private Attributes
boost::shared_ptr< DataAtIntegrationPts >	dataAtPts
	data at integration pts

Detailed Description

Examples

EshelbianPlasticity.cpp.

Definition at line 927 of file EshelbianOperators.hpp.

Member Typedef Documentation

OP

using OpFaceSideMaterialForce::OP = VolumeElementForcesAndSourcesCoreOnSide::UserDataOperator

Definition at line 931 of file EshelbianOperators.hpp.

Constructor & Destructor Documentation

OpFaceSideMaterialForce()

OpFaceSideMaterialForce::OpFaceSideMaterialForce ( boost::shared_ptr< DataAtIntegrationPts >  data_ptr )

inline

Definition at line 933 of file EshelbianOperators.hpp.

      : OP(NOSPACE, OPSPACE), dataAtPts(data_ptr) {}

Member Function Documentation

doWork()

MoFEMErrorCode OpFaceSideMaterialForce::doWork	(	int	side,
		EntityType	type,
		EntData &	data
	)

Examples

EshelbianOperators.cpp.

Definition at line 3324 of file EshelbianOperators.cpp.

                                                       {
  MoFEMFunctionBegin;
 
  FTENSOR_INDEX(SPACE_DIM, i);
  FTENSOR_INDEX(SPACE_DIM, j);
  FTENSOR_INDEX(SPACE_DIM, k);
  FTENSOR_INDEX(SPACE_DIM, l);
  FTENSOR_INDEX(SPACE_DIM, m);
  FTENSOR_INDEX(SPACE_DIM, n);
  FTENSOR_INDEX(SPACE_DIM, J);
  FTENSOR_INDEX(SPACE_DIM, I);
  FTENSOR_INDEX(SPACE_DIM, K);
 
  dataAtPts->faceMaterialForceAtPts.resize(3, getGaussPts().size2(), false);
  dataAtPts->normalPressureAtPts.resize(getGaussPts().size2(), false);
  if (getNinTheLoop() == 0) {
    dataAtPts->faceMaterialForceAtPts.clear();
    dataAtPts->normalPressureAtPts.clear();
  }
  auto loop_size = getLoopSize();
  if (loop_size == 1) {
    auto numebered_fe_ptr = getSidePtrFE()->numeredEntFiniteElementPtr;
    auto pstatus = numebered_fe_ptr->getPStatus();
    if (pstatus & (PSTATUS_SHARED | PSTATUS_MULTISHARED)) {
      loop_size = 2;
    }
  }
 
  constexpr auto t_kd = FTensor::Kronecker_Delta_symmetric<double>();
 
  auto t_normal = getFTensor1NormalsAtGaussPts();
  auto t_T = getFTensor1FromMat<SPACE_DIM>(
      dataAtPts->faceMaterialForceAtPts); //< face material force
  auto t_p =
      getFTensor0FromVec(dataAtPts->normalPressureAtPts); //< normal pressure
  auto t_P = getFTensor2FromMat<SPACE_DIM, SPACE_DIM>(dataAtPts->approxPAtPts);
  auto t_grad_u_gamma =
      getFTensor2FromMat<SPACE_DIM, SPACE_DIM>(dataAtPts->gradHybridDispAtPts);
  auto t_strain =
      getFTensor2SymmetricFromMat<SPACE_DIM>(dataAtPts->logStretchTensorAtPts);
  auto t_omega = getFTensor1FromMat<3>(dataAtPts->rotAxisAtPts);
 
  FTensor::Tensor1<double, SPACE_DIM> t_N;
  FTensor::Tensor2<double, SPACE_DIM, SPACE_DIM> t_A;
  FTensor::Tensor2<double, SPACE_DIM, SPACE_DIM> t_R;
  FTensor::Tensor2<double, SPACE_DIM, SPACE_DIM> t_grad_u;
  FTensor::Tensor2<double, SPACE_DIM, SPACE_DIM> t_PM;
  FTensor::Tensor2<double, SPACE_DIM, SPACE_DIM> t_QM;
 
  auto next = [&]() {
    ++t_normal;
    ++t_P;
    ++t_omega;
    ++t_grad_u_gamma;
    ++t_strain;
    ++t_T;
    ++t_p;
  };
 
  switch (EshelbianCore::energyReleaseSelector) {
  case GRIFFITH_FORCE:
    for (auto gg = 0; gg != getGaussPts().size2(); ++gg) {
      t_N(I) = t_normal(I);
      t_N.normalize();
 
      t_A(i, j) = levi_civita(i, j, k) * t_omega(k);
      t_R(i, k) = t_kd(i, k) + t_A(i, k);
 
      t_grad_u(i, j) = t_R(i, j) + t_strain(i, j);
      t_T(I) +=
          t_N(J) * (t_grad_u(i, I) * t_P(i, J)) / loop_size;
      // note that works only for Hooke material, for nonlinear material we need
      // strain energy expressed by stress
      t_T(I) -= t_N(I) * ((t_strain(i, K) * t_P(i, K)) / 2.) / loop_size;
 
      t_p += t_N(I) * (t_N(J) * (t_grad_u_gamma(i, I) * t_P(i, J))) / loop_size;
 
      next();
    }
    break;
  case GRIFFITH_SKELETON:
    for (auto gg = 0; gg != getGaussPts().size2(); ++gg) {
      t_N(I) = t_normal(I);
      t_N.normalize();
 
      // t_PM(i, j) = t_N(i) * t_N(j);
 
      // t_A(i, j) =
      //     t_PM(i, m) * (levi_civita(m, l, k) * t_omega(k)) * t_PM(l, j) +
      //     (t_grad_u_gamma(i, j) - t_grad_u_gamma(j, i));
      // // t_A(i, j) = levi_civita(i, j, k) * t_omega(k);
 
 
      // t_R(i, k) = t_kd(i, k) + t_A(i, k);
 
      t_grad_u(i, j) = t_kd(i, j) +
                       (t_grad_u_gamma(i, j) - t_grad_u_gamma(j, i)) / 2. +
                       t_strain(i, j);
 
      t_T(I) += t_N(J) * (t_grad_u(i, I) * t_P(i, J)) / loop_size;
      // note that works only for Hooke material, for nonlinear material we need
      // strain energy expressed by stress
      t_T(I) -= t_N(I) * ((t_strain(i, K) * t_P(i, K)) / 2.) / loop_size;
 
      // calculate nominal face pressure 
      t_p += t_N(I) * (t_N(J) * (t_grad_u_gamma(i, I) * t_P(i, J))) / loop_size;
 
      next();
    }
    break;
 
  default:
    SETERRQ(PETSC_COMM_WORLD, MOFEM_NOT_IMPLEMENTED,
            "Grffith energy release "
            "selector not implemented");
  };
 
#ifndef NDEBUG
  auto side_fe_ptr = getSidePtrFE();
  auto side_fe_mi_ptr = side_fe_ptr->numeredEntFiniteElementPtr;
  auto pstatus = side_fe_mi_ptr->getPStatus();
  if (pstatus) {
    auto owner = side_fe_mi_ptr->getOwnerProc();
    MOFEM_LOG("SELF", Sev::noisy)
        << "OpFaceSideMaterialForce: owner proc is not 0, owner proc: " << owner
        << " " << getPtrFE()->mField.get_comm_rank() << " n in the loop "
        << getNinTheLoop() << " loop size " << getLoopSize();
  }
#endif // NDEBUG
 
  MoFEMFunctionReturn(0);
}

Member Data Documentation

dataAtPts

boost::shared_ptr<DataAtIntegrationPts> OpFaceSideMaterialForce::dataAtPts

private

data at integration pts

Definition at line 940 of file EshelbianOperators.hpp.

---

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

• users_modules/eshelbian_plasticity/src/EshelbianOperators.hpp
• users_modules/eshelbian_plasticity/src/impl/EshelbianOperators.cpp