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

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

Inheritance diagram for SimpleContactProblem::OpCalDerIntCompFunSlaveSlave_dX:

Collaboration diagram for SimpleContactProblem::OpCalDerIntCompFunSlaveSlave_dX:

Public Member Functions
MoFEMErrorCode	iNtegrate (EntData &row_data, EntData &col_data)
	Integrates linearisation of the complementarity function at slave face gauss points and assembles components to LHS global matrix. More...

	OpCalDerIntCompFunSlaveSlave_dX (const string lagrange_field_name, const string mesh_nodes_field, boost::shared_ptr< double > cn, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, 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)

Private Attributes
boost::shared_ptr< double >	cNPtr

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 the variation with respect to slave material positions of the complementarity function to fulfill KKT conditions in the integral sense and assembles components to LHS global matrix.

Definition at line 3236 of file SimpleContact.hpp.

Constructor & Destructor Documentation

◆ OpCalDerIntCompFunSlaveSlave_dX()

SimpleContactProblem::OpCalDerIntCompFunSlaveSlave_dX::OpCalDerIntCompFunSlaveSlave_dX	(	const string	lagrange_field_name,
		const string	mesh_nodes_field,
		boost::shared_ptr< double >	cn,
		boost::shared_ptr< CommonDataSimpleContact >	common_data_contact,
		int	row_rank,
		const int	col_rank
	)

inline

Parameters

lagrange_field_name	String of field name for lagrange multipliers for rows
mesh_nodes_field	String of field name for material positions for columns
cn	regularisation/augmentation parameter affecting convergence
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 1)
col_rank	Parameter setting the dimension of the associated field for cols (in this case is 3)

Definition at line 3315 of file SimpleContact.hpp.

         : OpContactALELhs(lagrange_field_name, mesh_nodes_field,
                           common_data_contact, ContactOp::FACESLAVESLAVE,
                           row_rank, col_rank),
           cNPtr(cn) {
       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::OpCalDerIntCompFunSlaveSlave_dX::iNtegrate	(	EntData &	row_data,
		EntData &	col_data
	)

virtual

Integrates linearisation of the complementarity function at slave face gauss points and assembles components to LHS global matrix.

Integrates and assembles the variation with respect to slave spatial positions of the complementarity function to fulfill KKT conditions in the integral sense and assembles components to LHS global matrix.

\[ {\text D}{\overline C(\lambda, \mathbf{x}^{(i)}, \mathbf{X}^{(1)}, \delta \lambda)}[\Delta \mathbf{X}^{(1)}] = \int_{{{\mathcal{T}}^{(1)}_{\xi}}} -\left[ \textrm{D}\mathbf{N}^{(1)}(\mathbf{X}^{(1)})[\Delta\mathbf{X}^{(1)}] - \frac{\mathbf{N}^{(1)}(\mathbf{X}^{(1)})}{||{{\mathbf N}^{(1)}(\xi, \eta)}||} \textrm{D}\mathbf{N}^{(1)}(\mathbf{X}^{(1)})[\Delta\mathbf{X}^{(1)}] \cdot \frac{\mathbf{N}^{(1)}(\mathbf{X}^{(1)})}{||{{\mathbf N}^{(1)}(\xi, \eta)}||} \right] \cdot \left( {\mathbf{x}}^{(1)} - {\mathbf{x}}^{(2)}\right) c_{\text n} \left( 1 + {\text {sign}}\left( \lambda - c_{\text n} g_{\textrm{n}} \right) {\left| \lambda - c_{\text n} g_{\textrm{n}}\right|}^{r-1}\right) \delta{{\lambda}} \,\,{ {\text d} {\xi} {\text d} {\eta}} \\ + \int_{{{\mathcal{T}}^{(1)}_{\xi}}} \overline C(\lambda, \mathbf{x}^{(i)}, \mathbf{X}^{(1)}, \delta \lambda) \textrm{D}\mathbf{N}^{(1)}(\mathbf{X}^{(1)})[\Delta\mathbf{X}^{(1)}] \cdot \frac{\mathbf{N}^{(1)}(\mathbf{X}^{(1)})}{||{{\mathbf N}^{(1)}(\xi, \eta)}||} \delta{{\lambda}} \,\,{ {\text d} {\xi} {\text d} {\eta}} \]

where

\[ \textrm{D}\mathbf{N}^{(1)}(\mathbf{X}^{(1)})[\Delta\mathbf{X}^{(1)}] = \frac{\partial{\Delta\mathbf{X}}^{(1)}} {\partial\xi} \times \frac{\partial {\mathbf{X}}^{(1)}}{\partial\eta} + \frac{\partial{\mathbf{X}}^{(1)}} {\partial\xi} \times \frac{\partial {\Delta\mathbf{X}}^{(1)}}{\partial\eta} \]

where \(\xi, \eta\) are coordinates in the parent space \(({\mathcal{T}}^{(1)}_\xi)\) of the slave surface, \( \lambda\) is the Lagrange multiplier, \(\mathbf{x}^{(i)}\) are the coordinates of the overlapping gauss points at slave and master triangles for \(i = 1\) and \(i = 2\), respectively. Furthermore, \( c_{\text n}\) works as an augmentation parameter and affects convergence, \(r\) is regularisation parameter that here is chosen to be \(r = 1\) and \( g_{\textrm{n}}\) is the gap function evaluated at the slave triangle gauss points as:

\[ g_{\textrm{n}} = - \mathbf{N}(\mathbf{X}^{(1)}) \cdot \left( \mathbf{x}^{(1)} - \mathbf{x}^{(2)} \right) \]

Reimplemented from SimpleContactProblem::OpContactALELhs.

Definition at line 3716 of file SimpleContact.cpp.

                                           {
   MoFEMFunctionBegin;
  
   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();
   int nb_base_fun_col = col_data.getFieldData().size() / 3;
  
   matLhs.resize(nb_base_fun_row, 3 * nb_base_fun_col, false);
   matLhs.clear();
  
   auto get_tensor_vec = [](VectorDouble &n) {
     return FTensor::Tensor1<double *, 3>(&n(0), &n(1), &n(2));
   };
  
   auto get_vec_from_mat = [](MatrixDouble &m, const int r, const int c) {
     return FTensor::Tensor1<double *, 3>(&m(r + 0, c + 0), &m(r + 0, c + 1),
                                          &m(r + 0, c + 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;
   };
  
   auto x_m = getFTensor1FromMat<3>(
       *commonDataSimpleContact->positionAtGaussPtsMasterPtr);
   auto x_s = getFTensor1FromMat<3>(
       *commonDataSimpleContact->positionAtGaussPtsSlavePtr);
   auto t_lagrange_slave =
       getFTensor0FromVec(*commonDataSimpleContact->lagMultAtGaussPtsPtr);
  
   const double length_normal = commonDataSimpleContact->areaSlave;
  
   auto normal_at_gp =
       get_tensor_vec(*commonDataSimpleContact->normalVectorSlavePtr);
  
   auto t_w = getFTensor0IntegrationWeightSlave();
   auto t_1 = get_tensor_vec(*commonDataSimpleContact->tangentOneVectorSlavePtr);
   auto t_2 = get_tensor_vec(*commonDataSimpleContact->tangentTwoVectorSlavePtr);
   auto t_gap_gp = getFTensor0FromVec(*commonDataSimpleContact->gapPtr);
   const double cn_value = *cNPtr.get();
   for (int gg = 0; gg != nb_gauss_pts; ++gg) {
     double val_s = t_w * 0.5;
     auto t_N = col_data.getFTensor1DiffN<2>(gg, 0);
  
     for (int bbc = 0; bbc != nb_base_fun_col; ++bbc) {
       FTensor::Tensor0<double *> t_base_lambda(&row_data.getN()(gg, 0));
  
       for (int bbr = 0; bbr != nb_base_fun_row; ++bbr) {
         const double s = val_s * t_base_lambda;
  
         auto t_d_n = make_vec_der(t_N, t_1, t_2);
  
         auto assemble_mat = get_vec_from_mat(matLhs, bbr, 3 * bbc);
  
         assemble_mat(j) -=
             0.5 *
             (t_d_n(i, j) - normal_at_gp(i) * t_d_n(k, j) * normal_at_gp(k)) *
             (x_s(i) - x_m(i)) * s * cn_value *
             (1 + SimpleContactProblem::Sign(t_lagrange_slave -
                                             cn_value * t_gap_gp));
  
         assemble_mat(j) += t_d_n(i, j) * normal_at_gp(i) * s *
                            SimpleContactProblem::ConstrainFunction(
                                cn_value, t_gap_gp, t_lagrange_slave);
  
         ++t_base_lambda; // update rows
       }
       ++t_N;
     }
  
     ++x_m;
     ++x_s;
     ++t_lagrange_slave;
     ++t_gap_gp;
     ++t_w;
   }
  
   MoFEMFunctionReturn(0);
 }

Member Data Documentation

◆ cNPtr

boost::shared_ptr<double> SimpleContactProblem::OpCalDerIntCompFunSlaveSlave_dX::cNPtr

private

Definition at line 3329 of file SimpleContact.hpp.

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

Public Member Functions

Private Attributes