OpContactTools::OpConstrainBoundaryLhs_dU Struct Reference

#include <users_modules/multifield_plasticity/src/ContactOperators.hpp>

Inheritance diagram for OpContactTools::OpConstrainBoundaryLhs_dU:

Collaboration diagram for OpContactTools::OpConstrainBoundaryLhs_dU:

Public Member Functions
	OpConstrainBoundaryLhs_dU (const std::string row_field_name, const std::string col_field_name, boost::shared_ptr< CommonData > common_data_ptr)
MoFEMErrorCode	iNtegrate (EntData &row_data, EntData &col_data)

Private Attributes
boost::shared_ptr< CommonData >	commonDataPtr

Detailed Description

Definition at line 52 of file ContactOperators.hpp.

Constructor & Destructor Documentation

OpConstrainBoundaryLhs_dU()

OpContactTools::OpConstrainBoundaryLhs_dU::OpConstrainBoundaryLhs_dU	(	const std::string	row_field_name,
		const std::string	col_field_name,
		boost::shared_ptr< CommonData >	common_data_ptr
	)

Definition at line 298 of file ContactOperators.hpp.

    : BoundaryEleOpAssembly(row_field_name, col_field_name, OPROWCOL),
      commonDataPtr(common_data_ptr) {
  sYmm = false;
}

Member Function Documentation

iNtegrate()

MoFEMErrorCode OpContactTools::OpConstrainBoundaryLhs_dU::iNtegrate	(	EntData &	row_data,
		EntData &	col_data
	)

Definition at line 305 of file ContactOperators.hpp.

                                                                       {
  MoFEMFunctionBegin;
 
  const size_t nb_gauss_pts = getGaussPts().size2();
  const size_t row_nb_dofs = row_data.getIndices().size();
  const size_t col_nb_dofs = col_data.getIndices().size();
 
  if (row_nb_dofs && col_nb_dofs) {
 
 
    auto t_normal = getFTensor1Normal();
    const double ls = sqrt(t_normal(i) * t_normal(i));
    t_normal(i) /= ls;
 
    auto t_disp = getFTensor1FromMat<3>(*(commonDataPtr->mDispPtr));
    auto t_traction =
        getFTensor1FromMat<3>(*(commonDataPtr->contactTractionPtr));
    auto t_coords = getFTensor1CoordsAtGaussPts();
 
    auto t_w = getFTensor0IntegrationWeight();
    auto t_row_base = row_data.getFTensor1N<3>();
    size_t nb_face_functions = row_data.getN().size2() / 3;
 
    auto t_contact_normal =
        getFTensor1FromMat<3>(*(commonDataPtr->contactNormalPtr));
    auto t_gap = getFTensor0FromVec(*(commonDataPtr->contactGapPtr));
    auto t_gap_diff =
        getFTensor1FromMat<3>(*(commonDataPtr->contactGapDiffPtr));
    auto t_diff_normal =
        getFTensor2FromMat<3, 3>(*(commonDataPtr->contactNormalDiffPtr));
    Tensor1<double, 3> t1;
    auto &cn = (*cache).cn_cont;
 
    for (size_t gg = 0; gg != nb_gauss_pts; ++gg) {
 
      const double alpha = t_w * getMeasure();
 
      if (getNormalsAtGaussPts().size1() == nb_gauss_pts) {
        VectorDouble n = getNormalsAtGaussPts(gg);
        auto t_n = getFTensor1FromPtr<3>(&*n.data().begin());
        t_normal(i) = t_n(i) / sqrt(t_n(j) * t_n(j));
      }
 
      Tensor3<double, 3, 3, 3> t_diff_contact_tangent_tensor;
      t_diff_contact_tangent_tensor(i, j, k) =
          -t_diff_normal(i, k) * t_contact_normal(j) -
          t_contact_normal(i) * t_diff_normal(j, k);
 
      Tensor2<double, 3, 3> t_P;
      t_P(i, j) = t_contact_normal(i) * t_contact_normal(j);
 
      Tensor2<double, 3, 3> t_Q;
      t_Q(i, j) = kronecker_delta(i, j) - t_P(i, j);
      const double gap_0 = gap0(t_gap, t_disp, t_contact_normal);
 
      t1(i) = t_contact_normal(i) - 0.5 * t_gap_diff(i) +
              0.5 * cn * t_traction(j) * t_diff_normal(i, j) +
              t_disp(j) * t_diff_normal(i, j) +
              0.5 * sign(t_gap + cn * t_traction(k) * t_contact_normal(k)) *
                  (t_gap_diff(i) + cn * t_traction(j) * t_diff_normal(i, j));
 
      auto constrain = constraint(
          gap_0, t_gap, normal_traction(t_traction, t_contact_normal));
      size_t rr = 0;
      for (; rr != row_nb_dofs / 3; ++rr) {
 
        auto t_mat = getFTensor2FromArray<3, 3, 3>(locMat, 3 * rr);
        const double row_base = t_row_base(i) * t_normal(i);
 
        auto t_col_base = col_data.getFTensor0N(gg, 0);
 
        for (size_t cc = 0; cc != col_nb_dofs / 3; ++cc) {
          const double beta = alpha * row_base * t_col_base;
 
          // linearisation of t_rhs_constrains(i)
          t_mat(i, j) -= beta * t_contact_normal(i) * t1(j);
          t_mat(i, j) -= (beta * constrain) * t_diff_normal(i, j);
 
          // // linearisation of t_rhs_tangent_disp(i)
          t_mat(i, j) -= beta * t_Q(i, j);
          t_mat(i, k) -=
              beta * t_diff_contact_tangent_tensor(i, j, k) * t_disp(j);
 
          // // linearisation of  t_rhs_tangent_traction(i);
          t_mat(i, k) += beta * t_diff_contact_tangent_tensor(i, j, k) *
                         (*cache).cn_cont * t_traction(j);
 
          ++t_col_base;
          ++t_mat;
        }
        ++t_row_base;
      }
      for (; rr < nb_face_functions; ++rr)
        ++t_row_base;
 
      ++t_contact_normal;
      ++t_gap;
      ++t_gap_diff;
      ++t_diff_normal;
      ++t_disp;
      ++t_traction;
      ++t_coords;
      ++t_w;
    }
 
  }
 
  MoFEMFunctionReturn(0);
}

Member Data Documentation

commonDataPtr

boost::shared_ptr<CommonData> OpContactTools::OpConstrainBoundaryLhs_dU::commonDataPtr

private

Definition at line 60 of file ContactOperators.hpp.

---

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

• users_modules/multifield_plasticity/src/ContactOperators.hpp