EshelbianPlasticity::OpConstrainBoundaryL2Lhs_dU Struct Reference

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

Inheritance diagram for EshelbianPlasticity::OpConstrainBoundaryL2Lhs_dU:

Collaboration diagram for EshelbianPlasticity::OpConstrainBoundaryL2Lhs_dU:

Public Member Functions
	OpConstrainBoundaryL2Lhs_dU (const std::string row_field_name, const std::string col_field_name, boost::shared_ptr< ContactOps::CommonData > common_data_ptr, boost::shared_ptr< ContactTree > contact_tree_ptr, boost::shared_ptr< std::map< int, Range > > sdf_map_range_ptr=nullptr)
MoFEMErrorCode	iNtegrate (EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)

Private Attributes
boost::shared_ptr< ContactOps::CommonData >	commonDataPtr
boost::shared_ptr< ContactTree >	contactTreePtr
boost::shared_ptr< std::map< int, Range > >	sdfMapRangePtr

Detailed Description

Examples

EshelbianPlasticity.cpp.

Definition at line 155 of file EshelbianContact.hpp.

Constructor & Destructor Documentation

OpConstrainBoundaryL2Lhs_dU()

EshelbianPlasticity::OpConstrainBoundaryL2Lhs_dU::OpConstrainBoundaryL2Lhs_dU	(	const std::string	row_field_name,
		const std::string	col_field_name,
		boost::shared_ptr< ContactOps::CommonData >	common_data_ptr,
		boost::shared_ptr< ContactTree >	contact_tree_ptr,
		boost::shared_ptr< std::map< int, Range > >	sdf_map_range_ptr = nullptr )

Definition at line 547 of file EshelbianContact.cpp.

    : ContactOps::AssemblyBoundaryEleOp(row_field_name, col_field_name,
                                        ContactOps::BoundaryEleOp::OPROWCOL),
      commonDataPtr(common_data_ptr), contactTreePtr(contact_tree_ptr),
      sdfMapRangePtr(sdf_map_range_ptr) {
 
  sYmm = false;
}

Member Function Documentation

iNtegrate()

MoFEMErrorCode EshelbianPlasticity::OpConstrainBoundaryL2Lhs_dU::iNtegrate	(	EntitiesFieldData::EntData &	row_data,
		EntitiesFieldData::EntData &	col_data )

Definition at line 561 of file EshelbianContact.cpp.

                                                                           {
  MoFEMFunctionBegin;
 
  using namespace ContactOps;
 
  FTensor::Index<'i', 3> i;
  FTensor::Index<'j', 3> j;
  FTensor::Index<'k', 3> k;
 
  auto nb_rows = row_data.getIndices().size();
  auto nb_cols = col_data.getIndices().size();
 
  auto &locMat = AssemblyBoundaryEleOp::locMat;
  locMat.resize(nb_rows, nb_cols, false);
  locMat.clear();
 
  if (nb_cols && nb_rows) {
 
    auto nb_gauss_pts = getGaussPts().size2();
    auto t_w = getFTensor0IntegrationWeight();
    auto t_coords = getFTensor1CoordsAtGaussPts();
    auto t_disp = getFTensor1FromMat<3>(commonDataPtr->contactDisp);
    auto t_traction = getFTensor1FromMat<3>(commonDataPtr->contactTraction);
 
    // placeholder to pass boundary block id to python
    auto [block_id, m_normals_at_pts, v_sdf, m_grad_sdf, m_hess_sdf] =
        getSdf(this, commonDataPtr->contactDisp,
               checkSdf(getFEEntityHandle(), *sdfMapRangePtr), true);
 
    auto t_sdf_v = getFTensor0FromVec(v_sdf);
    auto t_grad_sdf_v = getFTensor1FromMat<3>(m_grad_sdf);
    auto t_hess_sdf_v = getFTensor2SymmetricFromMat<3>(m_hess_sdf);
    auto t_normalized_normal = getFTensor1FromMat<3>(m_normals_at_pts);
 
    auto next = [&]() {
      ++t_w;
      ++t_coords;
      ++t_disp;
      ++t_traction;
      ++t_sdf_v;
      ++t_grad_sdf_v;
      ++t_hess_sdf_v;
      ++t_normalized_normal;
    };
 
    auto face_data_vec_ptr =
        contactTreePtr->findFaceDataVecPtr(getFEEntityHandle());
    auto face_gauss_pts_it = face_data_vec_ptr->begin();
 
    auto t_row_base = row_data.getFTensor0N();
    auto nb_face_functions = row_data.getN().size2() / 3;
    constexpr auto t_kd = FTensor::Kronecker_Delta<int>();
 
    for (size_t gg = 0; gg != nb_gauss_pts; ++gg) {
 
      auto face_data_ptr = contactTreePtr->getFaceDataPtr(face_gauss_pts_it, gg,
                                                          face_data_vec_ptr);
 
      auto check_face_contact = [&]() {
        if (checkSdf(getFEEntityHandle(), *sdfMapRangePtr) != -1)
          return false;
 
        if (face_data_ptr) {
          return true;
        }
        return false;
      };
 
      FTensor::Tensor2<double, 3, 3> t_res_dU;
 
#ifdef ENABLE_PYTHON_BINDING
      double c = 0.;
      if (ContactOps::sdfPythonWeakPtr.lock()) {
        auto tn = t_traction(i) * t_grad_sdf_v(i);
        c = ContactOps::constrain(t_sdf_v, tn);
      }
#else
      constexpr double c = 0;
#endif
 
      if (!c && check_face_contact()) {
        FTensor::Tensor1<double, 3> t_spatial_coords;
        t_spatial_coords(i) = t_coords(i) + t_disp(i);
        constexpr double eps = std::numeric_limits<float>::epsilon();
        for (auto ii = 0; ii < 3; ++ii) {
          FTensor::Tensor1<std::complex<double>, 3> t_spatial_coords_cx{
              t_spatial_coords(0), t_spatial_coords(1), t_spatial_coords(2)};
          t_spatial_coords_cx(ii) += eps * 1i;
          auto t_rhs_tmp =
              multiPointRhs(face_data_ptr, t_coords, t_spatial_coords_cx,
                            t_traction, MultiPointRhsType::U);
          for (int jj = 0; jj != 3; ++jj) {
            auto v = t_rhs_tmp(jj).imag();
            t_res_dU(jj, ii) = v / eps;
          }
        }
 
      } else {
 
#ifdef ENABLE_PYTHON_BINDING
 
        if (ContactOps::sdfPythonWeakPtr.lock()) {
          auto inv_cn = ContactOps::alpha_contact_const;
          t_res_dU(i, j) =
 
              (-c) * (t_hess_sdf_v(i, j) * t_grad_sdf_v(k) * t_traction(k) +
                      t_grad_sdf_v(i) * t_hess_sdf_v(k, j) * t_traction(k))
 
              + (c * inv_cn) * (t_sdf_v * t_hess_sdf_v(i, j) +
 
                                t_grad_sdf_v(j) * t_grad_sdf_v(i));
        } else {
          t_res_dU(i, j) = 0;
        }
#else
        t_res_dU(i, j) = 0;
#endif
      }
 
      auto alpha = t_w * getMeasure();
 
      size_t rr = 0;
      for (; rr != nb_rows / 3; ++rr) {
 
        auto t_mat = getFTensor2FromArray<3, 3, 3>(locMat, 3 * rr);
        auto t_col_base = col_data.getFTensor0N(gg, 0);
 
        for (size_t cc = 0; cc != nb_cols / 3; ++cc) {
          auto beta = alpha * t_row_base * t_col_base;
          t_mat(i, j) -= beta * t_res_dU(i, j);
          ++t_col_base;
          ++t_mat;
        }
 
        ++t_row_base;
      }
      for (; rr < nb_face_functions; ++rr)
        ++t_row_base;
 
      next();
    }
  }
 
  MoFEMFunctionReturn(0);
}

Member Data Documentation

commonDataPtr

boost::shared_ptr<ContactOps::CommonData> EshelbianPlasticity::OpConstrainBoundaryL2Lhs_dU::commonDataPtr

private

Definition at line 167 of file EshelbianContact.hpp.

contactTreePtr

boost::shared_ptr<ContactTree> EshelbianPlasticity::OpConstrainBoundaryL2Lhs_dU::contactTreePtr

private

Definition at line 168 of file EshelbianContact.hpp.

sdfMapRangePtr

boost::shared_ptr<std::map<int, Range> > EshelbianPlasticity::OpConstrainBoundaryL2Lhs_dU::sdfMapRangePtr

private

Definition at line 169 of file EshelbianContact.hpp.

---

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

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