SimpleContactProblem::OpContactTractionMasterMaster_dX Struct Reference

LHS-operator for the simple contact element. More...

#include <users_modules/mortar_contact/src/SimpleContact.hpp>

Inheritance diagram for SimpleContactProblem::OpContactTractionMasterMaster_dX:

Collaboration diagram for SimpleContactProblem::OpContactTractionMasterMaster_dX:

Public Member Functions
MoFEMErrorCode	iNtegrate (EntData &row_data, EntData &col_data)
	Integrates Lagrange multipliers virtual work on master side, \( \delta W_{\text c}\) derivative with respect to material positions on master side and assembles components to LHS global matrix. More...
	OpContactTractionMasterMaster_dX (const string field_name, const string mesh_nodes_field, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, const int row_rank, const int col_rank)
Public Member Functions inherited from SimpleContactProblem::OpContactALELhs
MoFEMErrorCode	doWork (int row_side, int col_side, EntityType row_type, EntityType col_type, EntData &row_data, EntData &col_data)
MoFEMErrorCode	aSsemble (EntData &row_data, EntData &col_data)
	OpContactALELhs (const string field_name_1, const string field_name_2, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, const ContactOp::FaceType face_type, const int rank_row, const int rank_col)

Additional Inherited Members
Public Attributes inherited from SimpleContactProblem::OpContactALELhs
boost::shared_ptr< CommonDataSimpleContact >	commonDataSimpleContact
MatrixDouble	matLhs
VectorInt	rowIndices
VectorInt	colIndices
int	row_nb_dofs
int	col_nb_dofs
int	nb_gauss_pts
int	nb_base_fun_row
int	nb_base_fun_col
int	rankRow
int	rankCol

Detailed Description

LHS-operator for the simple contact element.

Integrates Lagrange multipliers virtual work on master side, \( \delta W_{\text c}\) derivative with respect to material positions on master side and assembles components of the RHS vector.

Definition at line 3168 of file SimpleContact.hpp.

Constructor & Destructor Documentation

OpContactTractionMasterMaster_dX()

SimpleContactProblem::OpContactTractionMasterMaster_dX::OpContactTractionMasterMaster_dX ( const string  field_name, const string  mesh_nodes_field, boost::shared_ptr< CommonDataSimpleContact >  common_data_contact, const int  row_rank, const int  col_rank  )

inline

Parameters

field_name	String of field name for spatial positions for rows
mesh_nodes_field	String of field name for material positions for columns
common_data_contact	Pointer to the common data for simple contact element
row_rank	Parameter setting the dimension of the associated field for rows (in this case is 3)
col_rank	Parameter setting the dimension of the associated field for cols (in this case is 3)

Definition at line 3216 of file SimpleContact.hpp.

        : OpContactALELhs(field_name, mesh_nodes_field, common_data_contact,
                          ContactOp::FACEMASTERMASTER, row_rank, col_rank) {
      sYmm = false; // This will make sure to loop over all intities (e.g.
                    // for order=2 it will make doWork to loop 16 time)
    }

Member Function Documentation

iNtegrate()

MoFEMErrorCode SimpleContactProblem::OpContactTractionMasterMaster_dX::iNtegrate ( EntData &  row_data, EntData &  col_data  )

virtual

Integrates Lagrange multipliers virtual work on master side, \( \delta W_{\text c}\) derivative with respect to material positions on master side and assembles components to LHS global matrix.

\[ \textrm{D} \delta W_{\rm{c}}({\mathbf{x}}^{(2)}, {\mathbf{X}}^{(2)}, \lambda, \delta{\mathbf{x}}^{(2)}) [\Delta{\mathbf{X}}^{(2)}] = -\int\limits_{\mathcal{T}^{(2)}_{\xi}} \lambda \, \frac{{\mathbf N}^{(1)}(\xi, \eta)}{||{{\mathbf N}^{(1)}(\xi, \eta)}||} \left[ \frac{\partial{\mathbf{X}}^{(2)}} {\partial\xi} \cdot \left(\frac{\partial\Delta {\mathbf{X}}^{(2)}}{\partial\eta}\times\delta{\mathbf{x}}^{(2)}\right) -\frac{\partial{\mathbf{X}}^{(2)}} {\partial\eta} \cdot \left(\frac{\partial\Delta {\mathbf{X}}^{(2)}}{\partial\xi}\times \delta{\mathbf{x}}^{(2)}\right)\right] \cdot \frac{{\mathbf N}^{(2)}(\xi, \eta)}{||{{\mathbf N}^{(2)}(\xi, \eta)}||} \textrm{d}\xi\textrm{d}\eta \]

Here superscript \((1)\) and \((2)\) denote slave and master side coordinates and surfaces, respectively. Moreover, \(\lambda\) is the lagrange multiplier.

Reimplemented from SimpleContactProblem::OpContactALELhs.

Definition at line 3621 of file SimpleContact.cpp.

                                          {
  MoFEMFunctionBegin;
 
  // Both sides are needed since both sides contribute their shape
  // function to the stiffness matrix
  const int nb_row = row_data.getIndices().size();
  if (!nb_row)
    MoFEMFunctionReturnHot(0);
  const int nb_col = col_data.getIndices().size();
  if (!nb_col)
    MoFEMFunctionReturnHot(0);
  const int nb_gauss_pts = row_data.getN().size1();
 
  int nb_base_fun_row = row_data.getFieldData().size() / 3;
  int nb_base_fun_col = col_data.getFieldData().size() / 3;
 
  auto get_tensor_from_mat = [](MatrixDouble &m, const int r, const int c) {
    return FTensor::Tensor2<double *, 3, 3>(
        &m(r + 0, c + 0), &m(r + 0, c + 1), &m(r + 0, c + 2), &m(r + 1, c + 0),
        &m(r + 1, c + 1), &m(r + 1, c + 2), &m(r + 2, c + 0), &m(r + 2, c + 1),
        &m(r + 2, c + 2));
  };
 
  auto get_tensor_vec = [](VectorDouble &n) {
    return FTensor::Tensor1<double *, 3>(&n(0), &n(1), &n(2));
  };
 
  auto get_tensor_vec_3 = [&](VectorDouble3 &n) {
    return FTensor::Tensor1<double *, 3>(&n(0), &n(1), &n(2));
  };
 
  FTensor::Index<'i', 3> i;
  FTensor::Index<'j', 3> j;
  FTensor::Index<'k', 3> k;
 
  auto make_vec_der = [&](auto t_N, auto t_1, auto t_2) {
    FTensor::Tensor2<double, 3, 3> t_n;
    t_n(i, j) = 0;
    t_n(i, j) += FTensor::levi_civita(i, j, k) * t_2(k) * t_N(0);
    t_n(i, j) -= FTensor::levi_civita(i, j, k) * t_1(k) * t_N(1);
    return t_n;
  };
 
  matLhs.resize(3 * nb_base_fun_row, 3 * nb_base_fun_col, false);
  matLhs.clear();
 
  auto lagrange_slave =
      getFTensor0FromVec(*commonDataSimpleContact->lagMultAtGaussPtsPtr);
 
  auto t_1 =
      get_tensor_vec(*commonDataSimpleContact->tangentOneVectorMasterPtr);
  auto t_2 =
      get_tensor_vec(*commonDataSimpleContact->tangentTwoVectorMasterPtr);
 
  auto t_w = getFTensor0IntegrationWeightMaster();
 
  auto t_const_unit_master =
      get_tensor_vec(*(commonDataSimpleContact->normalVectorMasterPtr));
 
  auto t_const_unit_slave =
      get_tensor_vec(*(commonDataSimpleContact->normalVectorSlavePtr));
 
  const double area_m = commonDataSimpleContact->areaMaster;
  const double area_s = commonDataSimpleContact->areaSlave;
 
  for (int gg = 0; gg != nb_gauss_pts; ++gg) {
 
    auto t_N = col_data.getFTensor1DiffN<2>(gg, 0);
 
    for (int bbc = 0; bbc != nb_base_fun_col; ++bbc) {
      const double mult_m = 0.5 * t_w * lagrange_slave;
      FTensor::Tensor0<double *> t_base_master(&row_data.getN()(gg, 0));
 
      for (int bbr = 0; bbr != nb_base_fun_row; ++bbr) {
        const double s = mult_m * t_base_master;
 
        auto t_d_n = make_vec_der(t_N, t_1, t_2);
 
        auto t_assemble_s = get_tensor_from_mat(matLhs, 3 * bbr, 3 * bbc);
 
        t_assemble_s(i, j) -=
            s * t_d_n(k, j) * t_const_unit_master(k) * t_const_unit_slave(i);
 
        ++t_base_master; // update rows
      }
      ++t_N;
    }
    ++lagrange_slave;
    ++t_w;
  }
 
  MoFEMFunctionReturn(0);
}

---

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

• users_modules/mortar_contact/src/SimpleContact.hpp
• users_modules/mortar_contact/src/impl/SimpleContact.cpp