EshelbianPlasticity::HMHHencky::OpCalculateStretchFromStress Struct Reference

Inheritance diagram for EshelbianPlasticity::HMHHencky::OpCalculateStretchFromStress:

Collaboration diagram for EshelbianPlasticity::HMHHencky::OpCalculateStretchFromStress:

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

Private Attributes
boost::shared_ptr< DataAtIntegrationPts >	dataAtPts
	data at integration pts More...
boost::shared_ptr< HMHHencky >	henckyPtr

Detailed Description

Definition at line 155 of file Hencky.cpp.

Constructor & Destructor Documentation

OpCalculateStretchFromStress()

EshelbianPlasticity::HMHHencky::OpCalculateStretchFromStress::OpCalculateStretchFromStress	(	boost::shared_ptr< DataAtIntegrationPts >	data_ptr,
		boost::shared_ptr< HMHHencky >	hencky_ptr
	)

Definition at line 824 of file Hencky.cpp.

    : VolUserDataOperator(NOSPACE, OPSPACE), dataAtPts(data_ptr),
      henckyPtr(hencky_ptr) {}

Member Function Documentation

doWork()

MoFEMErrorCode EshelbianPlasticity::HMHHencky::OpCalculateStretchFromStress::doWork	(	int	side,
		EntityType	type,
		EntData &	data
	)

Definition at line 830 of file Hencky.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);
 
  auto nb_integration_pts = dataAtPts->approxPAtPts.size2();
#ifdef NDEBUG
  if (nb_integration_pts != getGaussPts().size2()) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "inconsistent number of integration points");
  }
#endif // NDEBUG
 
  auto get_D = [&]() {
    MoFEMFunctionBegin;
    for (auto &b : henckyPtr->blockData) {
 
      if (b.blockEnts.find(getFEEntityHandle()) != b.blockEnts.end()) {
        dataAtPts->mu = b.bulkModulusK;
        dataAtPts->lambda = b.bulkModulusK;
        CHKERR henckyPtr->getMatDPtr(
            dataAtPts->getMatDPtr(), dataAtPts->getMatAxiatorDPtr(),
            dataAtPts->getMatDeviatorDPtr(), b.bulkModulusK, b.shearModulusG);
        MoFEMFunctionReturnHot(0);
      }
    }
 
    const auto E = henckyPtr->E;
    const auto nu = henckyPtr->nu;
 
    double bulk_modulus_K = E / (3 * (1 - 2 * nu));
    double shear_modulus_G = E / (2 * (1 + nu));
 
    dataAtPts->mu = shear_modulus_G;
    dataAtPts->lambda = bulk_modulus_K;
 
    CHKERR henckyPtr->getMatDPtr(
        dataAtPts->getMatDPtr(), dataAtPts->getMatAxiatorDPtr(),
        dataAtPts->getMatDeviatorDPtr(), bulk_modulus_K, shear_modulus_G);
    MoFEMFunctionReturn(0);
  };
 
  auto get_invert_D = [&]() {
    MoFEMFunctionBegin;
    dataAtPts->matInvD.resize(size_symm, size_symm, false);
    noalias(dataAtPts->matInvD) = dataAtPts->matD;
    CHKERR computeMatrixInverse(dataAtPts->matInvD);
    MoFEMFunctionReturn(0);
  };
 
  CHKERR get_D();
  CHKERR get_invert_D();
 
  dataAtPts->logStretchTensorAtPts.resize(size_symm, nb_integration_pts, false);
 
  auto t_log_u =
      getFTensor2SymmetricFromMat<3>(dataAtPts->logStretchTensorAtPts);
  auto t_approx_P =
      getFTensor2FromMat<SPACE_DIM, SPACE_DIM>(dataAtPts->approxPAtPts);
  auto t_inv_D = getFTensor4DdgFromPtr<SPACE_DIM, SPACE_DIM, 0>(
      &*dataAtPts->matInvD.data().begin());
 
  // note: add rotation, so we can extract rigid body motion, work then with
  // symmetric part.
  for (auto gg = 0; gg != nb_integration_pts; ++gg) {
    t_log_u(i, j) = t_inv_D(i, j, k, l) * t_approx_P(k, l);
    ++t_log_u;
    ++t_approx_P;
    ++t_inv_D;
  }
 
  MoFEMFunctionReturn(0);
}

Member Data Documentation

dataAtPts

boost::shared_ptr<DataAtIntegrationPts> EshelbianPlasticity::HMHHencky::OpCalculateStretchFromStress::dataAtPts

private

data at integration pts

Definition at line 163 of file Hencky.cpp.

henckyPtr

boost::shared_ptr<HMHHencky> EshelbianPlasticity::HMHHencky::OpCalculateStretchFromStress::henckyPtr

private

Definition at line 164 of file Hencky.cpp.

---

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

• users_modules/eshelbian_plasticit/src/impl/Hencky.cpp