v0.14.0
SimpleContact.hpp
Go to the documentation of this file.
1 /** \file SimpleContact.hpp
2  \brief Header file for simple contact element implementation
3 */
4 
5 /* This file is part of MoFEM.
6  * MoFEM is free software: you can redistribute it and/or modify it under
7  * the terms of the GNU Lesser General Public License as published by the
8  * Free Software Foundation, either version 3 of the License, or (at your
9  * option) any later version.
10  *
11  * MoFEM is distributed in the hope that it will be useful, but WITHOUT
12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
14  * License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with MoFEM. If not, see <http://www.gnu.org/licenses/>. */
18 
19 #ifndef __SIMPLE_CONTACT__
20 #define __SIMPLE_CONTACT__
21 
22 /** \brief Set of functions declaring elements and setting operators
23  * to apply contact conditions between surfaces with matching
24  * meshes \ingroup simple_contact_problem
25  */
26 
28 
29  using ContactEle = ContactPrismElementForcesAndSourcesCore;
32  using FaceUserDataOperator =
34 
35  struct LoadScale : public MethodForForceScaling {
36 
37  static double lAmbda;
38 
41  nf *= lAmbda;
43  }
44  };
45 
46  static inline double Sign(double x);
47 
48  static inline bool State(const double cn, const double g, const double l);
49 
50  static inline bool StateALM(const double cn, const double g, const double l);
51 
52  static inline double ConstrainFunction(const double cn, const double g,
53  const double l);
54 
55  static inline double ConstrainFunction_dg(const double cn, const double g,
56  const double l);
57 
58  static inline double ConstrainFunction_dl(const double cn, const double g,
59  const double l);
60 
61  static constexpr double TOL = 1e-8;
62  static constexpr int LAGRANGE_RANK = 1;
63  static constexpr int POSITION_RANK = 3;
64 
65  static constexpr double ALM_TOL = 1e-14;
66 
68  Range pRisms; // All boundary surfaces
69  };
70 
71  map<int, SimpleContactPrismsData>
72  setOfSimpleContactPrism; ///< maps side set id with appropriate FluxData
73 
75 
76  struct SimpleContactElement : public ContactEle {
77 
80  SmartPetscObj<Vec> contactStateVec;
81 
82  SimpleContactElement(MoFEM::Interface &m_field, bool newton_cotes = false)
83  : ContactEle(m_field), mField(m_field), newtonCotes(newton_cotes),
84  contactStateVec() {}
85 
88  if (snes_ctx == CTX_SNESSETFUNCTION && contactStateVec) {
89  CHKERR VecAssemblyBegin(contactStateVec);
90  CHKERR VecAssemblyEnd(contactStateVec);
91 
92  CHKERR VecZeroEntries(contactStateVec);
93  }
95  }
96 
99 
100  if (snes_ctx != CTX_SNESSETFUNCTION || !contactStateVec)
102 
103  CHKERR VecAssemblyBegin(contactStateVec);
104  CHKERR VecAssemblyEnd(contactStateVec);
105 
106  const double *array;
107  CHKERR VecGetArrayRead(contactStateVec, &array);
108  if (mField.get_comm_rank() == 0)
109 
110  MOFEM_LOG_C("WORLD", Sev::verbose,
111  " Active Gauss pts: %d out of %d", (int)array[0],
112  (int)array[1]);
113 
114  CHKERR VecRestoreArrayRead(contactStateVec, &array);
115 
117  }
118 
119  int getRule(int order) {
120  if (newtonCotes)
121  return -1;
122  else
123  return 2 * order;
124  }
125 
126  virtual MoFEMErrorCode setGaussPts(int order);
127 
129  };
130 
131  /**
132  * @brief Class used to convect integration points on slave and master, and to
133  * calculate directional direvatives of change integration position point as
134  * variation os spatial positions on contact surfaces.
135  *
136  */
138  : public boost::enable_shared_from_this<ConvectSlaveIntegrationPts> {
139 
141  string spat_pos, string mat_pos)
142  : fePtr(fe_ptr), sparialPositionsField(spat_pos),
143  materialPositionsField(mat_pos) {}
144 
145  template <bool CONVECT_MASTER> MoFEMErrorCode convectSlaveIntegrationPts();
146 
147  inline boost::shared_ptr<MatrixDouble> getDiffKsiSpatialMaster() {
148  return boost::shared_ptr<MatrixDouble>(shared_from_this(),
149  &diffKsiMaster);
150  }
151 
152  inline boost::shared_ptr<MatrixDouble> getDiffKsiSpatialSlave() {
153  return boost::shared_ptr<MatrixDouble>(shared_from_this(), &diffKsiSlave);
154  }
155 
156  private:
158 
159  const string sparialPositionsField;
161 
170 
173  };
174 
175  /**
176  * @brief Element used to integrate on slave surfaces. It convects integration
177  * points on slaves, so that quantities like gap from master are evaluated at
178  * correct points.
179  *
180  */
182 
184  string mat_pos, bool newton_cotes = false)
185  : SimpleContactElement(m_field, newton_cotes),
186  convectPtr(new ConvectSlaveIntegrationPts(this, spat_pos, mat_pos)) {}
187 
188  inline boost::shared_ptr<ConvectSlaveIntegrationPts> getConvectPtr() {
189  return convectPtr;
190  }
191 
192  int getRule(int order) { return -1; }
193 
195 
196  protected:
197  boost::shared_ptr<ConvectSlaveIntegrationPts> convectPtr;
198  };
199 
200  /**
201  * @brief Element used to integrate on master surfaces. It convects
202  * integration points on slaves, so that quantities like Lagrange multiplier
203  * from master are evaluated at correct points.
204  *
205  */
208 
209  int getRule(int order) { return -1; }
210 
212  };
213 
214  /**
215  * @brief Function that adds field data for spatial positions and Lagrange
216  * multipliers to rows and columns, provides access to field data and adds
217  * prism entities to element.
218  *
219  * @param element_name String for the element name
220  * @param field_name String of field name for spatial
221  * position
222  * @param lagrange_field_name String of field name for Lagrange
223  * multipliers
224  * @param mesh_node_field_name String of field name for material
225  * positions
226  * @param range_slave_master_prisms Range for prism entities used to create
227  * contact elements
228  * @return Error code
229  *
230  */
232  const string element_name, const string field_name,
233  const string lagrange_field_name, Range &range_slave_master_prisms,
234  bool eigen_pos_flag = false,
235  const string eigen_node_field_name = "EIGEN_SPATIAL_POSITIONS") {
237 
238  CHKERR mField.add_finite_element(element_name, MF_ZERO);
239 
240  if (range_slave_master_prisms.size() > 0) {
241 
243  lagrange_field_name);
244 
246  field_name);
247 
249  lagrange_field_name);
250 
252  field_name);
253 
255  lagrange_field_name);
256 
257  if (eigen_pos_flag)
259  element_name, eigen_node_field_name);
260 
262  field_name);
263 
265  "MESH_NODE_POSITIONS");
266 
267  setOfSimpleContactPrism[1].pRisms = range_slave_master_prisms;
268 
269  // Adding range_slave_master_prisms to Element element_name
271  range_slave_master_prisms, MBPRISM, element_name);
272  }
273 
275  }
276 
277  /**
278  * @brief Function that adds field data for spatial positions and Lagrange
279  * multipliers to rows and columns, provides access to field data and adds
280  * prism entities to element.
281  *
282  * @param element_name String for the element name
283  * @param field_name String of field name for spatial
284  * position
285  * @param lagrange_field_name String of field name for Lagrange
286  * multipliers
287  * @param mesh_node_field_name String of field name for material
288  * positions
289  * @param range_slave_master_prisms Range for prism entities used to create
290  * contact elements
291  * @return Error code
292  *
293  */
295  const string element_name, const string field_name,
296  const string mesh_node_field_name, const string lagrange_field_name,
297  Range &range_slave_master_prisms, bool eigen_pos_flag = false,
298  const string eigen_node_field_name = "EIGEN_SPATIAL_POSITIONS") {
300 
301  CHKERR mField.add_finite_element(element_name, MF_ZERO);
302 
303  if (range_slave_master_prisms.size() > 0) {
304 
306  lagrange_field_name);
307 
309  field_name);
311  mesh_node_field_name);
312 
314  lagrange_field_name);
316  field_name);
318  mesh_node_field_name);
319 
321  lagrange_field_name);
322 
323  if (eigen_pos_flag)
325  element_name, eigen_node_field_name);
326 
328  field_name);
329 
331  mesh_node_field_name);
332 
333  setOfSimpleContactPrism[1].pRisms = range_slave_master_prisms;
334 
335  Range ents_to_add = range_slave_master_prisms;
336  Range current_ents_with_fe;
338  current_ents_with_fe);
339  Range ents_to_remove;
340  ents_to_remove = subtract(current_ents_with_fe, ents_to_add);
342  ents_to_remove);
343  CHKERR mField.add_ents_to_finite_element_by_type(ents_to_add, MBPRISM,
344  element_name);
345  }
346 
348  }
349 
350  /**
351  * @brief Function that adds a new finite element for contact post-processing
352  *
353  * @param element_name String for the element name
354  * @param spatial_field_name String of field name for spatial position
355  * @param lagrange_field_name String of field name for Lagrange multipliers
356  * @param mesh_pos_field_name String of field name for mesh node positions
357  * @param range_slave_tris Range for slave triangles of contact elements
358  * @return Error code
359  *
360  */
361  MoFEMErrorCode addPostProcContactElement(const string element_name,
362  const string spatial_field_name,
363  const string lagrange_field_name,
364  const string mesh_pos_field_name,
365  Range &slave_tris) {
367 
368  CHKERR mField.add_finite_element(element_name, MF_ZERO);
369 
370  if (slave_tris.size() > 0) {
371 
372  // C row as Lagrange_mul and col as SPATIAL_POSITION
374  lagrange_field_name);
375 
377  spatial_field_name);
378 
379  // CT col as Lagrange_mul and row as SPATIAL_POSITION
381  lagrange_field_name);
382 
384  spatial_field_name);
385 
386  // data
388  lagrange_field_name);
389 
391  spatial_field_name);
392 
394  mesh_pos_field_name);
395 
396  // Adding slave_tris to Element element_name
398  element_name);
399  }
400 
402  }
403 
405  : public boost::enable_shared_from_this<CommonDataSimpleContact> {
406 
407  boost::shared_ptr<VectorDouble> augmentedLambdasPtr;
408  boost::shared_ptr<MatrixDouble> positionAtGaussPtsMasterPtr;
409  boost::shared_ptr<MatrixDouble> positionAtGaussPtsSlavePtr;
410  boost::shared_ptr<MatrixDouble> gradKsiPositionAtGaussPtsPtr;
411  boost::shared_ptr<MatrixDouble> gradKsiLambdaAtGaussPtsPtr;
412 
413  boost::shared_ptr<VectorDouble> lagMultAtGaussPtsPtr;
414  boost::shared_ptr<VectorDouble> gapPtr;
415  boost::shared_ptr<VectorDouble> lagGapProdPtr;
416 
417  boost::shared_ptr<VectorDouble> tangentOneVectorSlavePtr;
418  boost::shared_ptr<VectorDouble> tangentTwoVectorSlavePtr;
419  boost::shared_ptr<VectorDouble> tangentOneVectorMasterPtr;
420  boost::shared_ptr<VectorDouble> tangentTwoVectorMasterPtr;
421 
422  boost::shared_ptr<VectorDouble> normalVectorSlavePtr;
423  boost::shared_ptr<VectorDouble> normalVectorMasterPtr;
424 
425  boost::shared_ptr<MatrixDouble> hMat;
426  boost::shared_ptr<MatrixDouble> FMat;
427  boost::shared_ptr<MatrixDouble> HMat;
428  boost::shared_ptr<MatrixDouble> invHMat;
429  boost::shared_ptr<VectorDouble> detHVec;
430 
431  boost::shared_ptr<VectorDouble> gaussPtsStatePtr;
432 
433  double areaSlave;
434  double areaMaster;
435 
439 
440  SmartPetscObj<Vec> gaussPtsStateVec;
441  SmartPetscObj<Vec> contactAreaVec;
442 
444  augmentedLambdasPtr = boost::make_shared<VectorDouble>();
445  positionAtGaussPtsMasterPtr = boost::make_shared<MatrixDouble>();
446  positionAtGaussPtsSlavePtr = boost::make_shared<MatrixDouble>();
447  gradKsiPositionAtGaussPtsPtr = boost::make_shared<MatrixDouble>();
448  gradKsiLambdaAtGaussPtsPtr = boost::make_shared<MatrixDouble>();
449  lagMultAtGaussPtsPtr = boost::make_shared<VectorDouble>();
450 
451  gapPtr = boost::make_shared<VectorDouble>();
452  lagGapProdPtr = boost::make_shared<VectorDouble>();
453  normalVectorSlavePtr = boost::make_shared<VectorDouble>();
454  normalVectorMasterPtr = boost::make_shared<VectorDouble>();
455 
456  hMat = boost::make_shared<MatrixDouble>();
457  FMat = boost::make_shared<MatrixDouble>();
458  HMat = boost::make_shared<MatrixDouble>();
459  invHMat = boost::make_shared<MatrixDouble>();
460  detHVec = boost::make_shared<VectorDouble>();
461 
462  tangentOneVectorSlavePtr = boost::make_shared<VectorDouble>();
463  tangentTwoVectorSlavePtr = boost::make_shared<VectorDouble>();
464  tangentOneVectorMasterPtr = boost::make_shared<VectorDouble>();
465  tangentTwoVectorMasterPtr = boost::make_shared<VectorDouble>();
466 
467  gaussPtsStatePtr = boost::make_shared<VectorDouble>();
468 
469  int local_size = (mField.get_comm_rank() == 0)
471  : 0;
476  }
477 
478  private:
480  };
481 
482  double cnValue;
484  boost::shared_ptr<double> cnValuePtr;
486 
488  boost::shared_ptr<double> cn_value,
489  bool newton_cotes = false)
490  : mField(m_field), cnValuePtr(cn_value), newtonCotes(newton_cotes) {
491  cnValue = *cnValuePtr.get();
492  }
493 
494  struct OpContactMaterialLhs : public ContactOp {
495 
496  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
497  boost::shared_ptr<VolumeElementForcesAndSourcesCoreOnContactPrismSide>
499  string sideFeName;
500 
504 
508 
511 
512  int rankRow;
513  int rankCol;
514 
515  MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type,
516  EntityType col_type, EntData &row_data,
517  EntData &col_data);
518 
519  virtual MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data) {
522  }
523 
524  MoFEMErrorCode aSsemble(EntData &row_data, EntData &col_data);
525 
527  const string field_name_1, const string field_name_2,
528  boost::shared_ptr<CommonDataSimpleContact> common_data_contact,
529  const ContactOp::FaceType face_type, const int rank_row,
530  const int rank_col,
531  boost::shared_ptr<VolumeElementForcesAndSourcesCoreOnContactPrismSide>
532  side_fe = NULL,
533  const string side_fe_name = "")
534  : ContactOp(field_name_1, field_name_2, UserDataOperator::OPROWCOL,
535  face_type),
536  commonDataSimpleContact(common_data_contact), rankRow(rank_row),
537  rankCol(rank_col), sideFe(side_fe), sideFeName(side_fe_name) {
538  sYmm = false; // This will make sure to loop over all entities
539  }
540  };
541 
542  /// \brief Operator used as base struct for
543  /// OpContactTractionSlaveSlave_dX,
544  /// OpContactTractionMasterSlave_dX,
545  /// OpContactTractionMasterMaster_dX and
546  /// OpCalDerIntCompFunSlaveSlave_dX
547  struct OpContactALELhs : public ContactOp {
548 
549  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
550 
554 
558 
561 
562  int rankRow;
563  int rankCol;
564 
565  MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type,
566  EntityType col_type, EntData &row_data,
567  EntData &col_data);
568 
569  virtual MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data) {
572  }
573 
574  MoFEMErrorCode aSsemble(EntData &row_data, EntData &col_data);
575 
577  const string field_name_1, const string field_name_2,
578  boost::shared_ptr<CommonDataSimpleContact> common_data_contact,
579  const ContactOp::FaceType face_type, const int rank_row,
580  const int rank_col)
581  : ContactOp(field_name_1, field_name_2, UserDataOperator::OPROWCOL,
582  face_type),
583  commonDataSimpleContact(common_data_contact), rankRow(rank_row),
584  rankCol(rank_col) {
585  sYmm = false; // This will make sure to loop over all entities
586  }
587  };
588 
589  /// \brief Operator used as base struct for
590  /// OpContactMaterialVolOnSideLhs_dX_dx OpContactMaterialVolOnSideLhs_dX_dX
591  /// operators that use side volume element adjacent to current contact prism
592  /// needed to evaluate of deformation gradient tensor derivative
593 
597 
599 
600  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
601 
604 
608 
611 
612  boost::shared_ptr<VectorDouble> tangentOne;
613  boost::shared_ptr<VectorDouble> tangentTwo;
614 
615  boost::shared_ptr<VectorDouble> normalVector;
616  double aRea;
617 
618  MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type,
619  EntityType col_type,
620  EntitiesFieldData::EntData &row_data,
621  EntitiesFieldData::EntData &col_data);
622  virtual MoFEMErrorCode
624  EntitiesFieldData::EntData &col_data) {
627  }
628 
630  EntitiesFieldData::EntData &col_data);
631 
632  /**
633  * @brief LHS-operator for the contact element (material configuration)
634  *
635  * @param field_name_1 String of field name for spatial
636  * positions for rows
637  * @param field_name_2 String of field name for spatial
638  * positions for columns
639  * @param common_data_contact Pointer to the common data for
640  * simple contact element
641  * @param is_master Bool parameter to distinguish
642  * between master and slave sides
643  */
645  const string field_name_1, const string field_name_2,
646  boost::shared_ptr<CommonDataSimpleContact> common_data_contact,
647  const bool is_master)
648  : MoFEM::VolumeElementForcesAndSourcesCoreOnContactPrismSide::
649  UserDataOperator(field_name_1, field_name_2,
650  UserDataOperator::OPROWCOL),
651  commonDataSimpleContact(common_data_contact), isMaster(is_master) {
652  sYmm = false; // This will make sure to loop over all entities
653  normalVector = boost::make_shared<VectorDouble>();
654  tangentOne = boost::make_shared<VectorDouble>();
655  tangentTwo = boost::make_shared<VectorDouble>();
656  }
657 
658  private:
659  bool isMaster;
660  };
661 
662  /// \brief Computes, for reference configuration, normal to slave face that is
663  /// common to all gauss points
664  struct OpGetNormalSlave : public ContactOp {
665 
666  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
668  const string field_name,
669  boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
670  : ContactOp(field_name, UserDataOperator::OPCOL, ContactOp::FACESLAVE),
671  commonDataSimpleContact(common_data_contact) {}
672  /**
673  * @brief Evaluates unit normal vector to the slave surface vector based on
674  * reference base coordinates
675  *
676  * Computes normal vector based on reference base coordinates based on mesh
677  * (moab vertices) coordinates:
678  *
679  * \f[
680  * {\mathbf N}^{(1)}({\boldsymbol{\chi}}(\xi, \eta)) =
681  * \frac{\partial\mathbf{X}(\xi, \eta)}{\partial\xi}\times\frac{\partial
682  * \mathbf{X}(\xi, \eta)}
683  * {\partial\eta}
684  * \f]
685  *
686  * where \f${\boldsymbol{\chi}}^{(1)}(\xi, \eta)\f$ is the vector of
687  * reference coordinates at the gauss point on slave surface with parent
688  * coordinates \f$\xi\f$ and \f$\eta\f$ evaluated according to
689  *
690  * \f[
691  * {\boldsymbol{\chi}}(\xi, \eta) =
692  * \sum\limits^{3}_{i = 1}
693  * N_i(\xi, \eta){{\boldsymbol{\chi}}}_i
694  * \f]
695  *
696  * where \f$ N_i \f$ is the shape function corresponding to the \f$
697  * i-{\rm{th}}\f$ degree of freedom in the reference configuration
698  * \f${{\boldsymbol{\chi}}}^{(1)}_i\f$ corresponding to the 3 nodes of the
699  * triangular slave face.
700  *
701  */
702  MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
703  };
704 
705  /// \brief Computes, for reference configuration, normal to master face that
706  /// is common to all gauss points
707  struct OpGetNormalMaster : public ContactOp {
708 
709  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
711  const string field_name,
712  boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
713  : ContactOp(field_name, UserDataOperator::OPCOL, ContactOp::FACEMASTER),
714  commonDataSimpleContact(common_data_contact) {}
715 
716  /**
717  * @brief Evaluates unit normal vector to the master surface vector based on
718  * reference base coordinates
719  *
720  * Computes normal vector based on reference base coordinates based on mesh
721  * (moab vertices) coordinates:
722  *
723  * \f[
724  * {\mathbf N}^{(2)}({\mathbf\chi}(\xi, \eta)) =
725  * \frac{\partial\mathbf{X}(\xi, \eta)}{\partial\xi}\times\frac{\partial
726  * \mathbf{X}(\xi, \eta)}
727  * {\partial\eta}
728  * \f]
729  *
730  * where \f${\mathbf\chi}(\xi, \eta)\f$ is the vector of reference
731  * coordinates at the gauss point on master surface with parent coordinates
732  * \f$\xi\f$ and \f$\eta\f$ evaluated according to
733  *
734  * \f[
735  * {\mathbf\chi}(\xi, \eta) =
736  * \sum\limits^{3}_{i = 1}
737  * N_i(\xi, \eta){\overline{\mathbf\chi}}_i
738  * \f]
739  *
740  * where \f$ N_i \f$ is the shape function corresponding to the \f$
741  * i-{\rm{th}}\f$ degree of freedom in the reference configuration
742  * \f${\overline{\mathbf\chi}}_i\f$ corresponding to the 3 nodes of the
743  * triangular master face.
744  *
745  */
746  MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
747  };
748 
749  /**
750  * @brief Operator for the simple contact element
751  *
752  * Calculates the spacial coordinates of the gauss points of master triangle.
753  *
754  */
756 
757  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
759  const string field_name,
760  boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
761  : ContactOp(field_name, UserDataOperator::OPCOL, ContactOp::FACEMASTER),
762  commonDataSimpleContact(common_data_contact) {}
763 
764  MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
765  };
766 
767  /**
768  * @brief Operator for the simple contact element
769  *
770  * Calculates the spacial coordinates of the gauss points of master triangle.
771  *
772  */
774 
775  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
777  const string field_name,
778  boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
779  : ContactOp(field_name, UserDataOperator::OPCOL, ContactOp::FACEMASTER),
780  commonDataSimpleContact(common_data_contact) {}
781 
782  MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
783  };
784 
785  /**
786  * @brief Operator for the simple contact element
787  *
788  * Calculates the spacial coordinates of the gauss points of master triangle.
789  *
790  */
792 
793  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
795  const string field_name,
796  boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
797  : ContactOp(field_name, UserDataOperator::OPCOL, ContactOp::FACEMASTER),
798  commonDataSimpleContact(common_data_contact) {}
799 
800  MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
801  };
802 
803  /**
804  * @brief Operator for the simple contact element
805  *
806  * Calculates the spacial coordinates of the gauss points of slave triangle.
807  *
808  */
810 
811  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
813  const string field_name,
814  boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
815  : ContactOp(field_name, UserDataOperator::OPCOL, ContactOp::FACESLAVE),
816  commonDataSimpleContact(common_data_contact) {}
817 
818  MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
819  };
820 
821  /**
822  * @brief Operator for the simple contact element
823  *
824  * Calculates the spacial coordinates of the gauss points of slave triangle.
825  *
826  */
828 
829  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
831  const string field_name,
832  boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
833  : ContactOp(field_name, UserDataOperator::OPCOL, ContactOp::FACESLAVE),
834  commonDataSimpleContact(common_data_contact) {}
835 
836  MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
837  };
838 
839  /**
840  * @brief Operator for the simple contact element
841  *
842  * Calculates the spacial coordinates of the gauss points of slave triangle.
843  *
844  */
846 
847  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
849  const string field_name,
850  boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
851  : ContactOp(field_name, UserDataOperator::OPCOL, ContactOp::FACESLAVE),
852  commonDataSimpleContact(common_data_contact) {}
853 
854  MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
855  };
856 
857  /**
858  * @brief Operator for the simple contact element
859  *
860  * Calculates gap function at the gauss points on the slave triangle.
861  *
862  */
863  struct OpGetGapSlave : public ContactOp {
864 
865  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
867  const string field_name, // ign: does it matter??
868  boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
869  : ContactOp(field_name, UserDataOperator::OPROW, ContactOp::FACESLAVE),
870  commonDataSimpleContact(common_data_contact) {}
871 
872  /**
873  * @brief Evaluates gap function at slave face gauss points
874  *
875  * Computes gap function at slave face gauss points:
876  *
877  * \f[
878  * g_{\textrm{n}} = - \mathbf{n}(\mathbf{x}^{(1)}) \cdot \left(
879  * \mathbf{x}^{(1)} - \mathbf{x}^{(2)} \right)
880  * \f]
881  * where \f$\mathbf{n}(\mathbf{x}^{(1)})\f$ is the outward normal vector at
882  * the slave triangle gauss points, \f$\mathbf{x}^{(1)}\f$ and
883  * \f$\mathbf{x}^{(2)}\f$ are the spatial coordinates of the overlapping
884  * gauss points located at the slave and master triangles, respectively.
885  *
886  *
887  */
888  MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
889  };
890 
891  /**
892  * @brief Operator for the simple contact element
893  *
894  * Calculates Lagrange multipliers at the gauss points on the slave triangle.
895  *
896  */
898 
899  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
901  const string lagrange_field_name,
902  boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
903  : ContactOp(lagrange_field_name, UserDataOperator::OPROW,
904  ContactOp::FACESLAVE),
905  commonDataSimpleContact(common_data_contact) {}
906 
907  MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
908  };
909 
910  /**
911  * @brief Operator for the simple contact element for Augmented Lagrangian
912  * Method
913  *
914  * Calculates Augmented Lagrange Multipliers at the gauss points on the slave
915  * triangle.
916  *
917  */
920 
922  const string field_name,
923  boost::shared_ptr<CommonDataSimpleContact> common_data_contact,
924  const double cn)
925  : ContactOp(field_name, UserDataOperator::OPCOL, ContactOp::FACESLAVE),
926  commonDataSimpleContact(common_data_contact), cN(cn) {}
927 
928  MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
929 
930  private:
931  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
932  const double cN;
933  };
934 
935  /**
936  * @brief Operator for the simple contact element
937  *
938  * Calculates the product of Lagrange multipliers with gaps evaluated at the
939  * gauss points on the slave triangle.
940  *
941  */
943 
944  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
946  const string lagrange_field_name,
947  boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
948  : ContactOp(lagrange_field_name, UserDataOperator::OPROW,
949  ContactOp::FACESLAVE),
950  commonDataSimpleContact(common_data_contact) {}
951 
952  MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
953  };
954 
955  /**
956  * @brief RHS-operator for the simple contact element
957  *
958  * Integrates Lagrange multipliers virtual work on
959  * master surface and assemble components to RHS global vector.
960  *
961  */
963 
965  const string field_name,
966  boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
967  : ContactOp(field_name, UserDataOperator::OPROW, ContactOp::FACEMASTER),
968  commonDataSimpleContact(common_data_contact) {}
969 
970  /**
971  * @brief Integrates Lagrange multipliers virtual work on
972  * master surface and assembles to global RHS vector
973  *
974  * Integrates Lagrange multipliers virtual work \f$ \delta
975  * W_{\text c}\f$ on master surface and assembles components to global RHS
976  * vector
977  *
978  * \f[
979  * {\delta
980  * W^{(2)}_{\text c}(\lambda,
981  * \delta \mathbf{x}^{(2)}}) \,\, =
982  * - \int_{{\gamma}^{(1)}_{\text c}} \lambda \mathbf{n}(\mathbf{x}^{(1)})
983  * \cdot \delta{\mathbf{x}^{(2)}}
984  * \,\,{ {\text d} {\gamma}}
985  * \f]
986  *
987  * where \f${\gamma}^{(1)}_{\text c}\f$ is the surface integration domain
988  * of the slave surface, \f$ \lambda\f$ is the Lagrange multiplier,
989  * \f$\mathbf{n}(\mathbf{x}^{(1)})\f$ is the outward normal vector at the
990  * slave triangle gauss points, \f$\mathbf{x}^{(2)}\f$ are the coordinates
991  * of the overlapping gauss points at master triangles.
992  */
993  MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
994 
995  private:
996  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
998  };
999 
1000  /**
1001  * @brief RHS-operator for the simple contact element
1002  *
1003  * Integrates Lagrange multipliers virtual work on
1004  * slave surface and assembles components to the RHS global vector.
1005  *
1006  */
1008 
1010  const string field_name,
1011  boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
1012  : ContactOp(field_name, UserDataOperator::OPROW, ContactOp::FACESLAVE),
1013  commonDataSimpleContact(common_data_contact) {}
1014 
1015  /**
1016  * @brief Integrates Lagrange multipliers virtual work on
1017  * slave surface and assembles components to the RHS global vector.
1018  *
1019  * Integrates Lagrange multipliers virtual work \f$ \delta
1020  * W_{\text c}\f$ on slave surface and assembles components to the RHS
1021  * global vector
1022  *
1023  * \f[
1024  * {\delta
1025  * W^{(1)}_{\text c}(\lambda,
1026  * \delta \mathbf{x}^{(1)}}) \,\, =
1027  * \int_{{\gamma}^{(1)}_{\text c}} \lambda \mathbf{n}(\mathbf{x}^{(1)})
1028  * \cdot \delta{\mathbf{x}^{(1)}}
1029  * \,\,{ {\text d} {\gamma}}
1030  * \f]
1031  * where \f${\gamma}^{(1)}_{\text c}\f$ is the surface integration domain
1032  * of the slave surface, \f$\mathbf{n}(\mathbf{x}^{(1)})\f$ is the outward
1033  * normal vector at the slave triangle gauss points, \f$ \lambda\f$ is the
1034  * Lagrange multiplier, \f$\mathbf{x}^{(1)}\f$ are the coordinates of the
1035  * overlapping gauss points at slave triangles.
1036  */
1037  MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
1038 
1039  private:
1040  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
1042  };
1043 
1044  /**
1045  * @brief RHS-operator for the simple contact element
1046  *
1047  * Integrates Augmented Lagrange multipliers virtual work on
1048  * master surface and assemble components to RHS global vector.
1049  *
1050  */
1053 
1055  const string field_name,
1056  boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
1057  : ContactPrismElementForcesAndSourcesCore::UserDataOperator(
1058  field_name, UserDataOperator::OPCOL,
1059  ContactPrismElementForcesAndSourcesCore::UserDataOperator::
1060  FACEMASTER),
1061  commonDataSimpleContact(common_data_contact) {}
1062  /**
1063  * @brief Integrates Lagrange multipliers virtual work on
1064  * slave surface and assembles components to the RHS global vector.
1065  *
1066  * Integrates Lagrange multipliers virtual work \f$ \delta
1067  * W_{\text c}\f$ on slave surface and assembles components to the RHS
1068  * global vector
1069  *
1070  * \f[
1071  * {\delta
1072  * W^{(2)}_{\text c}(\lambda,
1073  * \delta \mathbf{x}^{(2)}}) \,\, =
1074  * \left\{ \begin{array}{ll}
1075  * \int_{{\gamma}^{(1)}_{\text c}} (\lambda + c_{\textrm n} g_{\textrm{n}})
1076  * \mathbf{n}(\mathbf{x}^{(1)}) \cdot \delta{\mathbf{x}^{(2)}}
1077  * \,\,{ {\text d} {\gamma}} & \lambda + c_{\text n} g_{\textrm{n}}\leq 0 \\
1078  * 0 & \lambda + c_{\text n} g_{\textrm{n}} > 0 \\
1079  * \end{array}
1080  * \right.
1081  * \f]
1082  * where \f${\gamma}^{(1)}_{\text c}\f$ is the surface integration domain
1083  * of the slave surface, \f$ \lambda\f$ is the Lagrange multiplier, \f$
1084  * c_{\textrm n}\f$ is the regularisation/augmentation parameter of stress
1085  * dimensions, \f$ g_{\textrm{n}}\f$ is the value of gap at the associated
1086  * gauss point, \f$\mathbf{x}^{(2)}\f$ are the coordinates of the
1087  * overlapping gauss points at master triangles.
1088  */
1089  MoFEMErrorCode doWork(int side, EntityType type,
1091 
1092  private:
1093  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
1095  };
1096 
1097  /**
1098  * @brief RHS-operator for the simple contact element
1099  *
1100  * Integrates Augmented Lagrange multipliers virtual work on
1101  * slave surface and assembles components to the RHS global vector.
1102  *
1103  */
1106 
1108  const string field_name,
1109  boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
1110  : ContactPrismElementForcesAndSourcesCore::UserDataOperator(
1111  field_name, UserDataOperator::OPCOL,
1112  ContactPrismElementForcesAndSourcesCore::UserDataOperator::
1113  FACESLAVE),
1114  commonDataSimpleContact(common_data_contact) {}
1115 
1116  /**
1117  * @brief Integrates Lagrange multipliers virtual work on
1118  * slave surface and assembles components to the RHS global vector.
1119  *
1120  * Integrates Lagrange multipliers virtual work \f$ \delta
1121  * W_{\text c}\f$ on slave surface and assembles components to the RHS
1122  * global vector
1123  *
1124  * \f[
1125  * {\delta
1126  * W^{(1)}_{\text c}(\lambda,
1127  * \delta \mathbf{x}^{(1)}}) \,\, =
1128  * - \left\{ \begin{array}{ll}
1129  * \int_{{\gamma}^{(1)}_{\text c}} (\lambda + c_{\textrm n} g_{\textrm{n}})
1130  * \mathbf{n}(\mathbf{x}^{(1)}) \cdot \delta{\mathbf{x}^{(1)}}
1131  * \,\,{ {\text d} {\gamma}} & \lambda + c_{\text n} g_{\textrm{n}}\leq 0 \\
1132  * 0 & \lambda + c_{\text n} g_{\textrm{n}} > 0 \\
1133  * \end{array}
1134  * \right.
1135  * \f]
1136  *
1137  * where \f${\gamma}^{(1)}_{\text c}\f$ is the surface integration domain
1138  * of the slave surface, \f$ \lambda\f$ is the Lagrange multiplier, \f$
1139  * c_{\textrm n}\f$ is the regularisation/augmentation parameter of stress
1140  * dimensions, \f$ g_{\textrm{n}}\f$ is the value of gap at the associated
1141  * gauss point, \f$\mathbf{x}^{(1)}\f$ are the coordinates of the
1142  * overlapping gauss points at slave triangles.
1143  */
1144  MoFEMErrorCode doWork(int side, EntityType type,
1146 
1147  private:
1148  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
1150  };
1151 
1152  /**
1153  * @brief RHS-operator for the simple contact element
1154  *
1155  * Integrates complementarity function that fulfills KKT
1156  * conditions over slave contact area and assembles components of the RHS
1157  * vector.
1158  *
1159  */
1161 
1163  const string lagrange_field_name,
1164  boost::shared_ptr<CommonDataSimpleContact> common_data_contact,
1165  boost::shared_ptr<double> cn)
1166  : ContactOp(lagrange_field_name, UserDataOperator::OPCOL,
1167  ContactOp::FACESLAVE),
1168  commonDataSimpleContact(common_data_contact), cNPtr(cn) {}
1169 
1170  /**
1171  * @brief Integrates the complementarity function at slave
1172  * face gauss points and assembles components to the RHS global vector.
1173  *
1174  * Integrates the complementarity function to fulfil KKT
1175  * conditions in the integral sense and assembles components to the RHS
1176  * global vector
1177  *
1178  * \f[
1179  * {\overline C(\lambda, \mathbf{x}^{(i)},
1180  * \delta \lambda)} = \int_{{\gamma}^{(1)}_{\text
1181  * c}} \left( \lambda + c_{\text n} g_{\textrm{n}} - \dfrac{1}{r}{\left|
1182  * \lambda - c_{\text n} g_{\textrm{n}}\right|}^{r}\right) \delta{{\lambda}}
1183  * \,\,{ {\text d} {\gamma}}
1184  * \f]
1185  * where \f${\gamma}^{(1)}_{\text c}\f$ is the surface integration domain
1186  * of the slave surface, \f$ \lambda\f$ is the Lagrange multiplier,
1187  * \f$\mathbf{x}^{(i)}\f$ are the coordinates of the overlapping gauss
1188  * points at slave and master triangles for \f$i = 1\f$ and \f$i = 2\f$,
1189  * respectively. Furthermore, \f$ c_{\text n}\f$ works as an augmentation
1190  * parameter and affects convergence, \f$r\f$ is regularisation parameter
1191  * that can be chosen in \f$[1, 1.1]\f$ (\f$r = 1\f$) is the default
1192  * value) and \f$ g_{\textrm{n}}\f$ is the gap function evaluated at the
1193  * slave triangle gauss points as: \f[ g_{\textrm{n}} = -
1194  * \mathbf{n}(\mathbf{x}^{(1)}) \cdot \left( \mathbf{x}^{(1)} -
1195  * \mathbf{x}^{(2)} \right) \f]
1196  */
1197  MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
1198 
1199  private:
1200  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
1201  boost::shared_ptr<double> cNPtr;
1203  };
1204 
1205  /**
1206  * @brief RHS-operator for the simple contact element for Augmented Lagrangian
1207  * Method
1208  *
1209  * Integrates ALM constraints that fulfill KKT
1210  * conditions over slave contact area and assembles components of the RHS
1211  * vector.
1212  *
1213  */
1216 
1218  const string lagrange_field_name,
1219  boost::shared_ptr<CommonDataSimpleContact> common_data_contact,
1220  const double cn)
1221  : ContactPrismElementForcesAndSourcesCore::UserDataOperator(
1222  lagrange_field_name, UserDataOperator::OPCOL,
1223  ContactOp::FACESLAVE),
1224  commonDataSimpleContact(common_data_contact), cN(cn) {}
1225 
1226  MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
1227 
1228  /**
1229  * @brief Integrates KKT conditions for Augmented Lagrangian
1230  formulation at slave
1231  * face gauss points and assembles components to the RHS global vector.
1232  *
1233  * Integrates the Augmented Lagrangian multipliers formulation to fulfil KKT
1234  * conditions in the integral sense and assembles components to the RHS
1235  * global vector
1236  *
1237  * \f[
1238  * {\overline C(\lambda, \mathbf{x}^{(i)},
1239  * \delta \lambda)} =
1240  * \left\{ \begin{array}{ll}
1241  * \int_{{\gamma}^{(1)}_{\text c}} g_{\textrm{n}} \delta{{\lambda}}
1242  * \,\,{ {\text d} {\gamma}} & \lambda + c_{\text n} g_{\textrm{n}}\leq 0 \\
1243  \int_{{\gamma}^{(1)}_{\text
1244  * c}} -\dfrac{1}{c_{\text n}} \lambda \delta{{\lambda}}
1245  * \,\,{ {\text d} {\gamma}} & \lambda + c_{\text n} g_{\textrm{n}}> 0 \\
1246  * \end{array}
1247  * \right.
1248  * \f]
1249  *
1250  *
1251  * where \f${\gamma}^{(1)}_{\text c}\f$ is the surface integration domain
1252  * of the slave surface, \f$ \lambda\f$ is the Lagrange multiplier,
1253  * \f$\mathbf{x}^{(i)}\f$ are the coordinates of the overlapping gauss
1254  * points at slave and master triangles for \f$i = 1\f$ and \f$i = 2\f$,
1255  * respectively. Furthermore, \f$ c_{\text n}\f$ works as an augmentation
1256  * parameter and affects convergence, \f$r\f$ is regularisation parameter
1257  * that can be chosen in \f$[1, 1.1]\f$ (\f$r = 1\f$) is the default
1258  * value) and \f$ g_{\textrm{n}}\f$ is the gap function evaluated at the
1259  * slave triangle gauss points as: \f[ g_{\textrm{n}} = -
1260  * \mathbf{n}(\mathbf{x}^{(1)}) \cdot \left( \mathbf{x}^{(1)} -
1261  * \mathbf{x}^{(2)} \right) \f]
1262  */
1263  private:
1264  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
1265  const double cN;
1267  };
1268 
1269  /**
1270  * @brief LHS-operator for the simple contact element
1271  *
1272  * Integrates Lagrange multipliers virtual
1273  * work, \f$ \delta W_{\text c}\f$ derivative with respect to Lagrange
1274  * multipliers on master side and assembles components of the RHS vector.
1275  *
1276  */
1278 
1280  const string field_name, const string lagrange_field_name,
1281  boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
1282  : ContactOp(field_name, lagrange_field_name, UserDataOperator::OPROWCOL,
1283  ContactOp::FACEMASTERSLAVE),
1284  commonDataSimpleContact(common_data_contact) {
1285  sYmm = false; // This will make sure to loop over all intities (e.g.
1286  // for order=2 it will make doWork to loop 16 time)
1287  }
1288 
1289  /**
1290  * @brief Integrates Lagrange multipliers virtual
1291  * work, \f$ \delta W_{\text c}\f$ derivative with respect to Lagrange
1292  * multipliers with respect to Lagrange multipliers on master side and
1293  * assembles components to LHS global matrix.
1294  *
1295  * Computes linearisation of integrated on slave side complementarity
1296  * function and assembles derivative of Lagrange multipliers virtual work
1297  * \f$ \delta W_{\text c}\f$ with respect to Lagrange multipliers and
1298  * assembles components to LHS global matrix
1299  *
1300  * \f[
1301  * {\text D} {\delta
1302  * W^{(2)}_{\text c}(\lambda,
1303  * \delta \mathbf{x}^{(2)}})[\Delta \lambda]
1304  * \,\, =
1305  * \int_{{\gamma}^{(1)}_{\text c}} \Delta \lambda
1306  * \delta{\mathbf{x}^{(2)}}
1307  * \,\,{ {\text d} {\gamma}}
1308  * \f]
1309  * where \f${\gamma}^{(1)}_{\text c}\f$ is the surface integration domain
1310  * of the slave surface, \f$ \lambda\f$ is the Lagrange multiplier,
1311  * \f$\mathbf{x}^{(2)}\f$ are the coordinates of the overlapping gauss
1312  * points at master triangles.
1313  */
1314  MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type,
1315  EntityType col_type, EntData &row_data,
1316  EntData &col_data);
1317 
1318  private:
1319  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
1321  };
1322 
1323  /**
1324  * @brief LHS-operator for the simple contact element
1325  *
1326  * Integrates Lagrange multipliers virtual
1327  * work, \f$ \delta W_{\text c}\f$ derivative with respect to Lagrange
1328  * multipliers with respect to Lagrange multipliers on slave side side and
1329  * assembles components to LHS global matrix.
1330  *
1331  */
1333 
1335  const string field_name, const string lagrange_field_name,
1336  boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
1337  : ContactOp(field_name, lagrange_field_name, UserDataOperator::OPROWCOL,
1338  ContactOp::FACESLAVESLAVE),
1339  commonDataSimpleContact(common_data_contact) {
1340  sYmm = false; // This will make sure to loop over all intities (e.g.
1341  // for order=2 it will make doWork to loop 16 time)
1342  }
1343 
1344  /**
1345  * @brief Integrates and assembles Lagrange multipliers virtual
1346  * work, \f$ \delta W_{\text c}\f$ derivative with respect to Lagrange
1347  * multipliers with respect to Lagrange multipliers on slave side and
1348  * assembles components to LHS global matrix.
1349  *
1350  * Computes linearisation of integrated on slave side complementarity
1351  * function and assembles Lagrange multipliers virtual work, \f$ \delta
1352  * W_{\text c}\f$ with respect to Lagrange multipliers
1353  *
1354  * \f[
1355  * {\text D} {\delta
1356  * W^{(1)}_{\text c}(\lambda,
1357  * \delta \mathbf{x}^{(1)}})[\Delta \lambda]
1358  * \,\, =
1359  * \int_{{\gamma}^{(1)}_{\text c}} -\Delta \lambda
1360  * \delta{\mathbf{x}^{(1)}}
1361  * \,\,{ {\text d} {\gamma}}
1362  * \f]
1363  * where \f${\gamma}^{(1)}_{\text c}\f$ is the surface integration domain
1364  * of the slave surface, \f$ \lambda\f$ is the Lagrange multiplier,
1365  * \f$\mathbf{x}^{(1)}\f$ are the coordinates of the overlapping gauss
1366  * points at slave triangles.
1367  */
1368  MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type,
1369  EntityType col_type, EntData &row_data,
1370  EntData &col_data);
1371 
1372  private:
1373  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
1375  };
1376 
1377  /**
1378  * @brief LHS-operator for the simple contact element
1379  *
1380  * Integrates variation of the complementarity function
1381  * with respect to Lagrange multipliers to fulfils KKT conditions
1382  * in the integral sense on slave side and assembles
1383  * components to LHS global matrix.
1384  *
1385  */
1387 
1389  const string lagrange_field_name,
1390  boost::shared_ptr<CommonDataSimpleContact> common_data_contact,
1391  boost::shared_ptr<double> cn)
1392  : ContactOp(lagrange_field_name, UserDataOperator::OPROWCOL,
1393  ContactOp::FACESLAVESLAVE),
1394  commonDataSimpleContact(common_data_contact), cNPtr(cn) {
1395  sYmm = false; // This will make sure to loop over all entities (e.g.
1396  // for order=2 it will make doWork to loop 16 time)
1397  }
1398 
1399  /**
1400  * @brief Integrates the complementarity function at slave
1401  * face gauss points and assembles
1402  * components to LHS global matrix.
1403  *
1404  * Integrates variation of the complementarity function
1405  * with respect to Lagrange multipliers to fulfils KKT conditions
1406  * in the integral sense nd assembles
1407  * components to LHS global matrix.
1408  *
1409  * \f[
1410  * {\text D}{\overline C(\lambda, \mathbf{x}^{(i)},
1411  * \delta \lambda)}[\Delta \lambda] = \int_{{\gamma}^{(1)}_{\text
1412  * c}} \Delta \lambda \left( 1 - {\text {sign}}\left( \lambda - c_{\text n}
1413  * g_{\textrm{n}} \right) {\left| \lambda - c_{\text n}
1414  * g_{\textrm{n}}\right|}^{r-1}\right) \delta{{\lambda}}
1415  * \,\,{ {\text d} {\gamma}}
1416  * \f]
1417  * where \f${\gamma}^{(1)}_{\text c}\f$ is the surface integration domain
1418  * of the slave surface, \f$ \lambda\f$ is the Lagrange multiplier,
1419  * \f$\mathbf{x}^{(i)}\f$ are the coordinates of the overlapping gauss
1420  * points at slave and master triangles for \f$i = 1\f$ and \f$i = 2\f$,
1421  * respectively. Furthermore, \f$ c_{\text n}\f$ works as an augmentation
1422  * parameter and affects convergence, \f$r\f$ is regularisation parameter
1423  * that can be chosen in \f$[1, 1.1]\f$ (\f$r = 1\f$) is the default
1424  * value and \f$ g_{\textrm{n}}\f$ is the gap function evaluated at the
1425  * slave triangle gauss points as: \f[ g_{\textrm{n}} = -
1426  * \mathbf{n}(\mathbf{x}^{(1)}) \cdot \left( \mathbf{x}^{(1)} -
1427  * \mathbf{x}^{(2)} \right) \f]
1428  */
1429  MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type,
1430  EntityType col_type, EntData &row_data,
1431  EntData &col_data);
1432 
1433  private:
1434  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
1435  boost::shared_ptr<double> cNPtr;
1437  };
1438 
1439  /**
1440  * @brief LHS-operator for the simple contact element
1441  *
1442  * Integrates the variation with respect to master spatial
1443  * positions of the complementarity function to fulfill KKT conditions in
1444  * the integral senseand assembles
1445  * components to LHS global matrix.
1446  *
1447  */
1449 
1451  const string lagrange_field_name, const string field_name,
1452  boost::shared_ptr<CommonDataSimpleContact> common_data_contact,
1453  boost::shared_ptr<double> cn)
1454  : ContactOp(lagrange_field_name, field_name, UserDataOperator::OPROWCOL,
1455  ContactOp::FACESLAVEMASTER),
1456  commonDataSimpleContact(common_data_contact), cNPtr(cn) {
1457  sYmm = false; // This will make sure to loop over all entities (e.g.
1458  // for order=2 it will make doWork to loop 16 time)
1459  }
1460 
1461  /**
1462  * @brief Integrates linearisation of the complementarity function at slave
1463  * face gauss points and assembles
1464  * components to LHS global matrix.
1465  *
1466  * Integrates the variation with respect to master spatial
1467  * positions of the complementarity function to fulfill KKT conditions in
1468  * the integral sense and assembles
1469  * components to LHS global matrix.
1470  *
1471  * \f[
1472  * {\text D}{\overline C(\lambda, \mathbf{x}^{(i)},
1473  * \delta \lambda)}[\Delta \mathbf{x}^{(2)}] = \int_{{\gamma}^{(1)}_{\text
1474  * c}} \Delta \mathbf{x}^{(2)} \cdot
1475  * \mathbf{n}(\mathbf{x}^{(1)}) c_{\text n} \left( 1 + {\text {sign}}\left(
1476  * \lambda - c_{\text n} g_{\textrm{n}} \right)
1477  * {\left| \lambda - c_{\text n}
1478  * g_{\textrm{n}}\right|}^{r-1}\right) \delta{{\lambda}}
1479  * \,\,{ {\text d} {\gamma}}
1480  * \f]
1481  * where \f${\gamma}^{(1)}_{\text c}\f$ is the surface integration domain
1482  * of the slave surface, \f$ \lambda\f$ is the Lagrange multiplier,
1483  * \f$\mathbf{x}^{(i)}\f$ are the coordinates of the overlapping gauss
1484  * points at slave and master triangles for \f$i = 1\f$ and \f$i = 2\f$,
1485  * respectively. Furthermore, \f$ c_{\text n}\f$ works as an augmentation
1486  * parameter and affects convergence, \f$r\f$ is regularisation parameter
1487  * that can be chosen in \f$[1, 1.1]\f$ (\f$r = 1\f$ is the default
1488  * value) and \f$ g_{\textrm{n}}\f$ is the gap function evaluated at the
1489  * slave triangle gauss points as: \f[ g_{\textrm{n}} = -
1490  * \mathbf{n}(\mathbf{x}^{(1)}) \cdot \left( \mathbf{x}^{(1)} -
1491  * \mathbf{x}^{(2)} \right) \f]
1492  */
1493  MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type,
1494  EntityType col_type, EntData &row_data,
1495  EntData &col_data);
1496 
1497  private:
1498  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
1499  boost::shared_ptr<double> cNPtr;
1501  };
1502 
1503  /**
1504  * @brief LHS-operator for the simple contact element
1505  *
1506  * Integrates the variation with respect to slave spatial
1507  * positions of the complementarity function to fulfill KKT conditions in
1508  * the integral sense and assembles
1509  * components to LHS global matrix.
1510  *
1511  */
1513 
1515  const string lagrange_field_name, const string field_name,
1516  boost::shared_ptr<CommonDataSimpleContact> common_data_contact,
1517  boost::shared_ptr<double> cn)
1518  : ContactOp(lagrange_field_name, field_name, UserDataOperator::OPROWCOL,
1519  ContactOp::FACESLAVESLAVE),
1520  cNPtr(cn), commonDataSimpleContact(common_data_contact) {
1521  sYmm = false; // This will make sure to loop over all entities (e.g.
1522  // for order=2 it will make doWork to loop 16 time)
1523  }
1524 
1525  /**
1526  * @brief Integrates linearisation of the complementarity
1527  * function at slave face gauss points and assembles
1528  * components to LHS global matrix.
1529  *
1530  * Integrates and assembles the variation with respect to slave spatial
1531  * positions of the complementarity function to fulfill KKT conditions in
1532  * the integral sense and assembles
1533  * components to LHS global matrix.
1534  *
1535  * \f[
1536  * {\text D}{\overline C(\lambda, \mathbf{x}^{(i)},
1537  * \delta \lambda)}[\Delta \mathbf{x}^{(1)}] = \int_{{\gamma}^{(1)}_{\text
1538  * c}} -\Delta \mathbf{x}^{(1)} \cdot
1539  * \mathbf{n}(\mathbf{x}^{(1)}) c_{\text n} \left( 1 + {\text
1540  * {sign}}\left( \lambda - c_{\text n} g_{\textrm{n}} \right)
1541  * {\left| \lambda - c_{\text n}
1542  * g_{\textrm{n}}\right|}^{r-1}\right) \delta{{\lambda}}
1543  * \,\,{ {\text d} {\gamma}}
1544  * \f]
1545  * where \f${\gamma}^{(1)}_{\text c}\f$ is the surface integration domain
1546  * of the slave surface, \f$ \lambda\f$ is the Lagrange multiplier,
1547  * \f$\mathbf{x}^{(i)}\f$ are the coordinates of the overlapping gauss
1548  * points at slave and master triangles for \f$i = 1\f$ and \f$i = 2\f$,
1549  * respectively. Furthermore, \f$ c_{\text n}\f$ works as an augmentation
1550  * parameter and affects convergence, \f$r\f$ is regularisation parameter
1551  * that can be chosen in \f$[1, 1.1]\f$ (\f$r = 1\f$ is the default
1552  * value) and \f$ g_{\textrm{n}}\f$ is the gap function evaluated at the
1553  * slave triangle gauss points as: \f[ g_{\textrm{n}} = -
1554  * \mathbf{n}(\mathbf{x}^{(1)}) \cdot \left( \mathbf{x}^{(1)} -
1555  * \mathbf{x}^{(2)} \right) \f]
1556  */
1557  MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type,
1558  EntityType col_type, EntData &row_data,
1559  EntData &col_data);
1560 
1561  private:
1562  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
1563  boost::shared_ptr<double> cNPtr;
1565  };
1566 
1567  /**
1568  * @brief LHS-operator for the simple contact element with Augmented
1569  * Lagrangian Method
1570  *
1571  * Integrates Lagrange multipliers virtual
1572  * work, \f$ \delta W_{\text c}\f$ derivative with respect to Lagrange
1573  * multipliers on master side and assembles components of the LHS global
1574  * matrix.
1575  *
1576  */
1579 
1581  const string field_name, const string lagrange_field_name,
1582  boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
1583  : ContactOp(field_name, lagrange_field_name, UserDataOperator::OPROWCOL,
1584  ContactOp::FACEMASTERSLAVE),
1585  commonDataSimpleContact(common_data_contact) {
1586  sYmm = false; // This will make sure to loop over all intities (e.g.
1587  // for order=2 it will make doWork to loop 16 time)
1588  }
1589 
1590  /**
1591  * @brief Integrates virtual work on master side
1592  * , \f$ \delta W_{\text c}\f$, derivative with respect to Lagrange
1593  * multipliers on slave side and
1594  * assembles its components to LHS global matrix.
1595  *
1596  * Computes linearisation of virtual work on master side integrated on the
1597  * slave side and assembles the components of its derivative over Lagrange
1598  * multipliers.
1599  *
1600  * \f[
1601  * {\text D} {\delta
1602  * W^{(2)}_{\text c}(\lambda,
1603  * \delta \mathbf{x}^{(2)}})[\Delta \lambda]
1604  * \,\,
1605  * =
1606  * \left\{ \begin{array}{ll}
1607  * \int_{{\gamma}^{(1)}_{\text c}} \Delta \lambda
1608  * \mathbf{n}(\mathbf{x}^{(1)}) \cdot \delta{\mathbf{x}^{(2)}}\,\,{ {\text
1609  * d}
1610  * {\gamma}} & \lambda + c_{\text n}
1611  * g_{\textrm{n}}\leq 0 \\
1612  * 0 & \lambda + c_{\text n} g_{\textrm{n}}> 0 \\
1613  * \end{array}
1614  * \right.
1615  * \f]
1616  * where \f${\gamma}^{(1)}_{\text c}\f$ is the surface integration domain
1617  * of the slave surface, \f$ \lambda\f$ is the Lagrange multiplier,
1618  * \f$\mathbf{x}^{(2)}\f$ are the coordinates of the overlapping gauss
1619  * points at master triangles, \f$
1620  * c_{\textrm n}\f$ is the regularisation/augmentation parameter of stress
1621  * dimensions and \f$ g_{\textrm{n}}\f$ is the gap evaluated on the
1622  * corresponding slave side.
1623  */
1624  MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type,
1625  EntityType col_type, EntData &row_data,
1626  EntData &col_data);
1627 
1628  private:
1629  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
1631  };
1632 
1633  /**
1634  * @brief LHS-operator for the simple contact element with Augmented
1635  * Lagrangian Method
1636  *
1637  * Integrates Lagrange multipliers virtual
1638  * work, \f$ \delta W_{\text c}\f$ derivative with respect to Lagrange
1639  * multipliers on slave side and assembles components of the LHS matrix.
1640  *
1641  */
1644 
1646  const string field_name, const string lagrange_field_name,
1647  boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
1648  : ContactOp(field_name, lagrange_field_name, UserDataOperator::OPROWCOL,
1649  ContactOp::FACESLAVESLAVE),
1650  commonDataSimpleContact(common_data_contact) {
1651  sYmm = false; // This will make sure to loop over all intities (e.g.
1652  // for order=2 it will make doWork to loop 16 time)
1653  }
1654 
1655  /**
1656  * @brief Integrates virtual work on slave side
1657  * , \f$ \delta W_{\text c}\f$, derivative with respect to Lagrange
1658  * multipliers on slave side and
1659  * assembles its components to LHS global matrix.
1660  *
1661  * Computes linearisation of virtual work on slave side integrated on the
1662  * slave side and assembles the components of its derivative over Lagrange
1663  * multipliers.
1664  *
1665  * \f[
1666  * {\text D} {\delta
1667  * W^{(1)}_{\text c}(\lambda,
1668  * \delta \mathbf{x}^{(1)}})[\Delta \lambda]
1669  * \,\,
1670  * =
1671  * \left\{ \begin{array}{ll}
1672  * \int_{{\gamma}^{(1)}_{\text c}} - \Delta \lambda {\mathbf{n}}_{\rm c}
1673  * \cdot \delta{\mathbf{x}^{(1)}}\,\,{ {\text d} {\gamma}} & \lambda +
1674  * c_{\text n}
1675  * g_{\textrm{n}}\leq 0 \\
1676  * 0 & \lambda + c_{\text n} g_{\textrm{n}}> 0 \\
1677  * \end{array}
1678  * \right.
1679  * \f]
1680  * where \f${\gamma}^{(1)}_{\text c}\f$ is the surface integration domain
1681  * of the slave surface, \f$ \lambda\f$ is the Lagrange multiplier,
1682  * \f$\mathbf{x}^{(1)}\f$ are the coordinates of the overlapping gauss
1683  * points at master triangles, \f$
1684  * c_{\textrm n}\f$ is the regularisation/augmentation parameter of stress
1685  * dimensions and \f$ g_{\textrm{n}}\f$ is the gap evaluated on the
1686  * corresponding slave side.
1687  */
1688  MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type,
1689  EntityType col_type, EntData &row_data,
1690  EntData &col_data);
1691 
1692  private:
1693  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
1695  };
1696 
1697  /**
1698  * @brief LHS-operator for the simple contact element with Augmented
1699  * Lagrangian Method
1700  *
1701  * Integrates Lagrange multipliers virtual
1702  * work, \f$ \delta W_{\text c}\f$ derivative with respect to spatial
1703  * positions on master side and assembles components of the LHS matrix.
1704  *
1705  */
1708 
1710  const string field_name, const string field_name_2,
1711  const double cn_value,
1712  boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
1713  : ContactPrismElementForcesAndSourcesCore::UserDataOperator(
1714  field_name, field_name_2, UserDataOperator::OPROWCOL,
1715  ContactPrismElementForcesAndSourcesCore::UserDataOperator::
1716  FACEMASTERMASTER),
1717  cN(cn_value), commonDataSimpleContact(common_data_contact) {
1718  sYmm = false; // This will make sure to loop over all intities (e.g.
1719  // for order=2 it will make doWork to loop 16 time)
1720  }
1721 
1722  /**
1723  * @brief Integrates virtual work on master side
1724  * , \f$ \delta W_{\text c}\f$, derivative with respect to spatial positions
1725  * of the master side and assembles its components to LHS global matrix.
1726  *
1727  * Computes linearisation of integrated on slave side complementarity
1728  * function and assembles Lagrange multipliers virtual work \f$ \delta
1729  * W_{\text c}\f$ on master side with respect to spatial positions of the
1730  * master side and assembles components to LHS global matrix
1731  *
1732  * \f[
1733  * {\text D} {\delta
1734  * W^{(2)}_{\text c}(\lambda,
1735  * \delta \mathbf{x}^{(2)}})[\Delta {\mathbf{x}^{(2)}}]
1736  * \,\,
1737  * =
1738  * \left\{ \begin{array}{ll}
1739  * \int_{{\gamma}^{(1)}_{\text c}} c_{\textrm n}\Delta
1740  * {\mathbf{x}^{(2)}} \cdot [{\mathbf{n}}_{\rm c} \otimes {\mathbf{n}}_{\rm
1741  * c}] \cdot \delta{\mathbf{x}^{(2)}}\,\,{ {\text d} {\gamma}} & \lambda +
1742  * c_{\text n}
1743  * g_{\textrm{n}}\leq 0 \\
1744  * 0 & \lambda + c_{\text n} g_{\textrm{n}}> 0 \\
1745  * \end{array}
1746  * \right.
1747  * \f]
1748  * where \f${\gamma}^{(1)}_{\text c}\f$ is the surface integration domain
1749  * of the slave surface, \f$ \lambda\f$ is the Lagrange multiplier,
1750  * \f$\mathbf{x}^{(2)}\f$ are the coordinates of the overlapping gauss
1751  * points at master triangles, \f$
1752  * c_{\textrm n}\f$ is the regularisation/augmentation parameter of stress
1753  * dimensions and \f$ g_{\textrm{n}}\f$ is the gap evaluated on the
1754  * corresponding slave side.
1755  */
1756  MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type,
1757  EntityType col_type,
1758  EntitiesFieldData::EntData &row_data,
1759  EntitiesFieldData::EntData &col_data);
1760 
1761  private:
1762  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
1763  const double cN;
1765  };
1766 
1767  /**
1768  * @brief LHS-operator for the simple contact element with Augmented
1769  * Lagrangian Method
1770  *
1771  * Integrates Lagrange multipliers virtual
1772  * work, \f$ \delta W_{\text c}\f$ derivative with respect to spatial
1773  * positions on master side and assembles components of the LHS matrix.
1774  *
1775  */
1778 
1780  const string field_name, const string field_name_2,
1781  const double cn_value,
1782  boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
1783  : ContactPrismElementForcesAndSourcesCore::UserDataOperator(
1784  field_name, field_name_2, UserDataOperator::OPROWCOL,
1785  ContactPrismElementForcesAndSourcesCore::UserDataOperator::
1786  FACEMASTERSLAVE),
1787  cN(cn_value), commonDataSimpleContact(common_data_contact) {
1788  sYmm = false; // This will make sure to loop over all intities (e.g.
1789  // for order=2 it will make doWork to loop 16 time)
1790  }
1791 
1792  /**
1793  * @brief Integrates virtual work on master side
1794  * , \f$ \delta W_{\text c}\f$ derivative with respect to spatial positions
1795  * on slave side and
1796  * assembles its components to LHS global matrix.
1797  *
1798  * Computes linearisation of virtual work on master side integrated on the
1799  * slave side and assembles the components of its derivative over spatial
1800  * positions on slave side
1801  *
1802  * \f[
1803  * {\text D} {\delta
1804  * W^{(2)}_{\text c}(\lambda,
1805  * \delta \mathbf{x}^{(2)}})[\Delta {\mathbf{x}^{(1)}}]
1806  * \,\,
1807  * =
1808  * \left\{ \begin{array}{ll}
1809  * \int_{{\gamma}^{(1)}_{\text c}} -c_{\textrm n}\Delta
1810  * {\mathbf{x}^{(1)}} \cdot [{\mathbf{n}}_{\rm c} \otimes {\mathbf{n}}_{\rm
1811  * c}] \cdot \delta{\mathbf{x}^{(2)}}\,\,{ {\text d} {\gamma}} & \lambda +
1812  * c_{\text n}
1813  * g_{\textrm{n}}\leq 0 \\
1814  * 0 & \lambda + c_{\text n} g_{\textrm{n}}> 0 \\
1815  * \end{array}
1816  * \right.
1817  * \f]
1818  * where \f${\gamma}^{(1)}_{\text c}\f$ is the surface integration domain
1819  * of the slave surface, \f$ \lambda\f$ is the Lagrange multiplier,
1820  * \f$\mathbf{x}^{(2)}\f$ and \f$\mathbf{x}^{(1)}\f$ are the coordinates of
1821  * the overlapping gauss points at master and slave triangles, respectively.
1822  * Also, \f$ c_{\textrm n}\f$ is
1823  * the regularisation/augmentation parameter of stress dimensions and \f$
1824  * g_{\textrm{n}}\f$ is the gap evaluated on the corresponding slave side.
1825  */
1826  MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type,
1827  EntityType col_type,
1828  EntitiesFieldData::EntData &row_data,
1829  EntitiesFieldData::EntData &col_data);
1830 
1831  private:
1832  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
1833  const double cN;
1835  };
1836 
1837  /**
1838  * @brief LHS-operator for the simple contact element with Augmented
1839  * Lagrangian Method
1840  *
1841  * Integrates Spatial position on slave side multipliers virtual
1842  * work, \f$ \delta W_{\text c}\f$ derivative with respect to spatial
1843  * positions on master side and assembles components of the LHS matrix.
1844  *
1845  */
1848 
1850  const string field_name, const string field_name_2,
1851  const double cn_value,
1852  boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
1853  : ContactPrismElementForcesAndSourcesCore::UserDataOperator(
1854  field_name, field_name_2, UserDataOperator::OPROWCOL,
1855  ContactPrismElementForcesAndSourcesCore::UserDataOperator::
1856  FACESLAVESLAVE),
1857  cN(cn_value), commonDataSimpleContact(common_data_contact) {
1858  sYmm = false; // This will make sure to loop over all intities (e.g.
1859  // for order=2 it will make doWork to loop 16 time)
1860  }
1861 
1862  /**
1863  * @brief Integrates virtual
1864  * work on slave side, \f$ \delta W_{\text c}\f$, derivative with respect to
1865  * slave spatial positions and assembles its components to LHS global
1866  * matrix.
1867  *
1868  * Computes linearisation of virtual work on slave side integrated on the
1869  * slave side and assembles the components of its derivative over Lagrange
1870  * multipliers.
1871  *
1872  * \f[
1873  * {\text D} {\delta
1874  * W^{(1)}_{\text c}(\lambda,
1875  * \delta \mathbf{x}^{(1)}})[\Delta {\mathbf{x}^{(1)}}]
1876  * \,\,
1877  * =
1878  * \left\{ \begin{array}{ll}
1879  * \int_{{\gamma}^{(1)}_{\text c}} c_{\textrm n}\Delta
1880  * {\mathbf{x}^{(1)}} \cdot [{\mathbf{n}}_{\rm c} \otimes {\mathbf{n}}_{\rm
1881  * c}] \cdot \delta{\mathbf{x}^{(1)}}\,\,{ {\text d} {\gamma}} & \lambda +
1882  * c_{\text n}
1883  * g_{\textrm{n}}\leq 0 \\
1884  * 0 & \lambda + c_{\text n} g_{\textrm{n}}> 0 \\
1885  * \end{array}
1886  * \right.
1887  * \f]
1888  * where \f${\gamma}^{(1)}_{\text c}\f$ is the surface integration domain
1889  * of the slave surface, \f$ \lambda\f$ is the Lagrange multiplier,
1890  * \f$\mathbf{x}^{(1)}\f$ are the coordinates of
1891  * the overlapping gauss points at slave triangles, respectively.
1892  * Also, \f$ c_{\textrm n}\f$ is
1893  * the regularisation/augmentation parameter of stress dimensions and \f$
1894  * g_{\textrm{n}}\f$ is the gap evaluated on the corresponding slave side.
1895  */
1896  MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type,
1897  EntityType col_type,
1898  EntitiesFieldData::EntData &row_data,
1899  EntitiesFieldData::EntData &col_data);
1900 
1901  private:
1902  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
1903  const double cN;
1905  };
1906 
1907  /**
1908  * @brief LHS-operator for the simple contact element with Augmented
1909  * Lagrangian Method
1910  *
1911  * Integrates virtual work of spatial position on slave side,
1912  * \f$ \delta W_{\text c}\f$, derivative with respect to spatial
1913  * positions on master side and assembles its components to the global LHS
1914  * matrix.
1915  *
1916  */
1919 
1921  const string field_name, const string field_name_2,
1922  const double cn_value,
1923  boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
1924  : ContactPrismElementForcesAndSourcesCore::UserDataOperator(
1925  field_name, field_name_2, UserDataOperator::OPROWCOL,
1926  ContactPrismElementForcesAndSourcesCore::UserDataOperator::
1927  FACESLAVEMASTER),
1928  cN(cn_value), commonDataSimpleContact(common_data_contact) {
1929  sYmm = false; // This will make sure to loop over all intities (e.g.
1930  // for order=2 it will make doWork to loop 16 time)
1931  }
1932 
1933  /**
1934  * @brief Integrates virtual work on slave side,
1935  * \f$ \delta W_{\text c}\f$, derivative with respect to spatial
1936  * positions on master side and assembles its components to the global LHS
1937  * matrix.
1938  *
1939  * Computes linearisation of virtual work of spatial position on slave side
1940  * , \f$ \delta W_{\text c}\f$, over master side spatial positions and
1941  * assembles its components to LHS global matrix
1942  *
1943  * \f[
1944  * {\text D} {\delta
1945  * W^{(1)}_{\text c}(\lambda,
1946  * \Delta \mathbf{x}^{(2)}})[\delta {\mathbf{x}^{(1)}}]
1947  * \,\,
1948  * =
1949  * \left\{ \begin{array}{ll}
1950  * \int_{{\gamma}^{(1)}_{\text c}} -c_{\textrm n}\Delta
1951  * {\mathbf{x}^{(2)}}\cdot [{\mathbf{n}}_{\rm c} \otimes {\mathbf{n}}_{\rm
1952  * c}] \cdot \delta{\mathbf{x}^{(1)}}\,\,{ {\text d} {\gamma}} & \lambda +
1953  * c_{\text n}
1954  * g_{\textrm{n}}\leq 0 \\
1955  * 0 & \lambda + c_{\text n} g_{\textrm{n}}> 0 \\
1956  * \end{array}
1957  * \right.
1958  * \f]
1959  * where \f${\gamma}^{(1)}_{\text c}\f$ is the surface integration domain
1960  * of the slave surface, \f$ \lambda\f$ is the Lagrange multiplier,
1961  * \f$\mathbf{x}^{(2)}\f$ and \f$\mathbf{x}^{(1)}\f$ are the coordinates of
1962  * the overlapping gauss points at master and slave triangles, respectively.
1963  * Also, \f$ c_{\textrm n}\f$ is
1964  * the regularisation/augmentation parameter of stress dimensions and \f$
1965  * g_{\textrm{n}}\f$ is the gap evaluated on the corresponding slave side.
1966  */
1967  MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type,
1968  EntityType col_type,
1969  EntitiesFieldData::EntData &row_data,
1970  EntitiesFieldData::EntData &col_data);
1971 
1972  private:
1973  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
1974  const double cN;
1976  };
1977 
1978  /**
1979  * @brief LHS-operator for the simple contact element
1980  *
1981  * Integrates variation of the conditions that fulfil KKT conditions
1982  * with respect to Lagrange multipliers
1983  * on slave side and assembles
1984  * components to LHS global matrix.
1985  *
1986  */
1988 
1990  const string lagrange_field_name,
1991  boost::shared_ptr<CommonDataSimpleContact> common_data_contact,
1992  const double cn)
1993  : ContactOp(lagrange_field_name, UserDataOperator::OPROWCOL,
1994  ContactOp::FACESLAVESLAVE),
1995  commonDataSimpleContact(common_data_contact), cN(cn) {
1996  sYmm = false; // This will make sure to loop over all entities (e.g.
1997  // for order=2 it will make doWork to loop 16 time)
1998  }
1999 
2000  /**
2001  * @brief Integrates the conditions that fulfil KKT conditions at slave
2002  * face gauss points and assembles
2003  * components to LHS global matrix.
2004  *
2005  * Integrates variation of the expresion that fulfils KKT conditions
2006  * with respect to Lagrange multipliers
2007  * and assembles
2008  * components to LHS global matrix.
2009  *
2010  * \f[
2011  * {\text D}{\overline C(\lambda, \mathbf{x}^{(1)},
2012  * \delta \lambda)}[\Delta \lambda] =
2013  * \left\{ \begin{array}{ll}
2014  * 0 & \lambda + c_{\text n}
2015  * g_{\textrm{n}}\leq 0 \\
2016  * \int_{{\gamma}^{(1)}_{\text c}} -\dfrac{1}{c_{\text n}} \Delta \lambda
2017  * \delta{\lambda}\,\,{ {\text d} {\gamma}} & \lambda + c_{\text
2018  * n} g_{\textrm{n}}> 0 \\
2019  * \end{array}
2020  * \right.
2021  * \f]
2022  * where \f${\gamma}^{(1)}_{\text c}\f$ is the surface integration domain
2023  * of the slave surface, \f$ \lambda\f$ is the Lagrange multiplier,
2024  * \f$\mathbf{x}^{(i)}\f$ are the coordinates of the overlapping gauss
2025  * points at slave and master triangles for \f$i = 1\f$ and \f$i = 2\f$,
2026  * respectively. Furthermore, \f$ c_{\text n}\f$ works as an augmentation
2027  * parameter and affects convergence, and \f$ g_{\textrm{n}}\f$
2028  * is the gap function evaluated at the
2029  * slave triangle gauss points as: \f[ g_{\textrm{n}} = -
2030  * \mathbf{n}(\mathbf{x}^{(1)}) \cdot \left( \mathbf{x}^{(1)} -
2031  * \mathbf{x}^{(2)} \right) \f]
2032  */
2033  MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type,
2034  EntityType col_type, EntData &row_data,
2035  EntData &col_data);
2036 
2037  private:
2038  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
2039  const double cN;
2041  };
2042 
2043  /**
2044  * @brief LHS-operator for the simple contact element
2045  *
2046  * Integrates variation on the slave sid the conditions that fulfil KKT
2047  * conditions with respect to Spatial positions on the master side and
2048  * assembles components to LHS global matrix.
2049  *
2050  */
2052 
2054  const string field_name, const string lagrange_field_name,
2055  boost::shared_ptr<CommonDataSimpleContact> common_data_contact,
2056  const double cn)
2057  : ContactOp(lagrange_field_name, field_name, UserDataOperator::OPROWCOL,
2058  ContactOp::FACESLAVEMASTER),
2059  commonDataSimpleContact(common_data_contact), cN(cn) {
2060  sYmm = false; // This will make sure to loop over all entities (e.g.
2061  // for order=2 it will make doWork to loop 16 time)
2062  }
2063 
2064  /**
2065  * @brief Integrates the conditions that fulfil KKT conditions at master
2066  * face gauss points and assembles
2067  * components to LHS global matrix.
2068  *
2069  * Integrates variation of the expresion that fulfils KKT conditions
2070  * with respect to spatial positions
2071  * in the integral sense and assembles
2072  * components to LHS global matrix.
2073  *
2074  * \f[
2075  * {\text D}{\overline C(\lambda, \mathbf{x}^{(1)},
2076  * \delta \lambda)}[\Delta \mathbf{x}^{(2)}] =
2077  * \left\{ \begin{array}{ll}
2078  * \int_{{\gamma}^{(1)}_{\text c}} c_{\text n} \Delta \mathbf{x}^{(2)}
2079  * \cdot {\mathbf{n}}_{\rm c} \delta{\lambda}\,\,{ {\text d} {\gamma}} &
2080  * \lambda + c_{\text n}
2081  * g_{\textrm{n}}\leq 0 \\
2082  * 0 & \lambda + c_{\text
2083  * n} g_{\textrm{n}}> 0 \\
2084  * \end{array}
2085  * \right.
2086  * \f]
2087  * where \f${\gamma}^{(1)}_{\text c}\f$ is the surface integration domain
2088  * of the slave surface, \f$ \lambda\f$ is the Lagrange multiplier,
2089  * \f$\mathbf{x}^{(1)}\f$ are the coordinates of the overlapping gauss
2090  * points at slave and master triangles for \f$i = 1\f$ and \f$i = 2\f$,
2091  * respectively. Furthermore, \f$ c_{\text n}\f$ works as an augmentation
2092  * parameter and affects convergence, and \f$ g_{\textrm{n}}\f$
2093  * is the gap function evaluated at the
2094  * slave triangle gauss points as: \f[ g_{\textrm{n}} = -
2095  * \mathbf{n}(\mathbf{x}^{(1)}) \cdot \left( \mathbf{x}^{(1)} -
2096  * \mathbf{x}^{(2)} \right) \f]
2097  */
2098  MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type,
2099  EntityType col_type, EntData &row_data,
2100  EntData &col_data);
2101 
2102  private:
2103  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
2104  const double cN;
2106  };
2107 
2108  /**
2109  * @brief LHS-operator for the simple contact element
2110  *
2111  * Integrates on the slave side variation of the conditions that fulfil KKT
2112  * conditions with respect to Spatial positions on the slave side and
2113  * assembles components to LHS global matrix.
2114  *
2115  */
2117 
2119  const string field_name, const string lagrange_field_name,
2120  boost::shared_ptr<CommonDataSimpleContact> common_data_contact,
2121  const double cn)
2122  : ContactOp(lagrange_field_name, field_name, UserDataOperator::OPROWCOL,
2123  ContactOp::FACESLAVESLAVE),
2124  cN(cn), commonDataSimpleContact(common_data_contact) {
2125  sYmm = false; // This will make sure to loop over all entities (e.g.
2126  // for order=2 it will make doWork to loop 16 time)
2127  }
2128 
2129  /**
2130  * @brief Integrates the conditions that fulfil KKT conditions at slave
2131  * face gauss points and assembles
2132  * components to LHS global matrix.
2133  *
2134  * Integrates variation of the expresion that fulfils KKT conditions
2135  * with respect to spatial positions
2136  * on slave side
2137  * components to LHS global matrix.
2138  *
2139  * \f[
2140  * {\text D}{\overline C(\lambda, \mathbf{x}^{(1)},
2141  * \delta \lambda)}[\Delta \mathbf{x}^{(1)}] =
2142  * \left\{ \begin{array}{ll}
2143  * \int_{{\gamma}^{(1)}_{\text c}} -c_{\text n} \Delta \mathbf{x}^{(1)}
2144  * \cdot
2145  * {\mathbf{n}}_{\rm c} \delta{\lambda}\,\,{ {\text d} {\gamma}} & \lambda +
2146  * c_{\text n}
2147  * g_{\textrm{n}}\leq 0 \\
2148  * 0 & \lambda + c_{\text
2149  * n} g_{\textrm{n}}> 0 \\
2150  * \end{array}
2151  * \right.
2152  * \f]
2153  * where \f${\gamma}^{(1)}_{\text c}\f$ is the surface integration domain
2154  * of the slave surface, \f$ \lambda\f$ is the Lagrange multiplier,
2155  * \f$\mathbf{x}^{(1)}\f$ are the coordinates of the overlapping gauss
2156  * points at slave and master triangles for \f$i = 1\f$ and \f$i = 2\f$,
2157  * respectively. Furthermore, \f$ c_{\text n}\f$ works as an augmentation
2158  * parameter and affects convergence, and \f$ g_{\textrm{n}}\f$
2159  * is the gap function evaluated at the
2160  * slave triangle gauss points as: \f[ g_{\textrm{n}} = -
2161  * \mathbf{n}(\mathbf{x}^{(1)}) \cdot \left( \mathbf{x}^{(1)} -
2162  * \mathbf{x}^{(2)} \right) \f]
2163  */
2164  MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type,
2165  EntityType col_type, EntData &row_data,
2166  EntData &col_data);
2167 
2168  private:
2169  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
2170  const double cN;
2172  };
2173 
2174  /**
2175  * \brief Choice of the contact prism side to put the state tag on
2176  */
2177  enum StateTagSide { NO_TAG = 0, MASTER_SIDE = 1, SLAVE_SIDE = 2 };
2178 
2179  /**
2180  * @brief Operator for the simple contact element
2181  *
2182  * Prints to .vtk file pre-calculated gaps, Lagrange multipliers and their
2183  * product the gauss points on the slave triangle.
2184  *
2185  */
2186  struct OpMakeVtkSlave : public ContactOp {
2187 
2189  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
2193 
2195  boost::shared_ptr<CommonDataSimpleContact> common_data,
2196  moab::Interface &moab_out,
2197  StateTagSide state_tag_side = NO_TAG,
2198  Range post_proc_surface = Range())
2199  : ContactOp(field_name, UserDataOperator::OPROW, ContactOp::FACESLAVE),
2200  mField(m_field), commonDataSimpleContact(common_data),
2201  moabOut(moab_out), stateTagSide(state_tag_side),
2202  postProcSurface(post_proc_surface) {}
2203 
2204  MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
2205  };
2206 
2207  struct OpMakeTestTextFile : public ContactOp {
2208 
2210  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
2211  ofstream &mySplit;
2212 
2214  boost::shared_ptr<CommonDataSimpleContact> common_data,
2215  ofstream &_my_split)
2216  : ContactOp(field_name, UserDataOperator::OPROW, ContactOp::FACESLAVE),
2217  mField(m_field), commonDataSimpleContact(common_data),
2218  mySplit(_my_split) {
2219  mySplit << fixed << setprecision(8);
2220  mySplit << "[0] Lagrange multiplier [1] Gap" << endl;
2221  }
2222 
2223  MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
2224  };
2225 
2226  /**
2227  * @brief Function for the simple contact element for C function or ALM
2228  * approach that sets the user data RHS-operators
2229  *
2230  * @param fe_rhs_simple_contact Pointer to the FE instance for RHS
2231  * @param common_data_simple_contact Pointer to the common data for simple
2232  * contact element
2233  * @param field_name String of field name for spatial
2234  * positions
2235  * @param lagrange_field_name String of field name for Lagrange
2236  * multipliers
2237  * @param is_alm bool flag to determine choice of
2238  * approach between ALM or C function to solve frictionless problem
2239  * @param is_eigen_pos_field bool flag to determine choice of
2240  * whether eigen displacements have to be taken into account
2241  * @param eigen_pos_field_name String of field name for eigen spatial
2242  * position
2243  * @return Error code
2244  *
2245  */
2247  boost::shared_ptr<SimpleContactElement> fe_rhs_simple_contact,
2248  boost::shared_ptr<CommonDataSimpleContact> common_data_simple_contact,
2249  string field_name, string lagrange_field_name, bool is_alm = false,
2250  bool is_eigen_pos_field = false,
2251  string eigen_pos_field_name = "EIGEN_SPATIAL_POSITIONS",
2252  bool use_reference_coordinates = false);
2253 
2254  /**
2255  * @brief Function for the simple contact element for C function or ALM
2256  * approach that sets the user data
2257  * LHS-operators
2258  *
2259  * @param fe_lhs_simple_contact Pointer to the FE instance for LHS
2260  * @param common_data_simple_contact Pointer to the common data for simple
2261  * contact element
2262  * @param field_name String of field name for spatial
2263  * positions
2264  * @param lagrange_field_name String of field name for Lagrange
2265  * multipliers
2266  * @param is_alm bool flag to determine choice of
2267  * approach between ALM or C function to solve frictionless problem default is
2268  * false
2269  * @param is_eigen_pos_field bool flag to determine choice of
2270  * whether eigen displacements have to be taken into account
2271  * @param eigen_pos_field_name String of field name for eigen spatial
2272  * position
2273  * @return Error code
2274  *
2275  */
2277  boost::shared_ptr<SimpleContactElement> fe_lhs_simple_contact,
2278  boost::shared_ptr<CommonDataSimpleContact> common_data_simple_contact,
2279  string field_name, string lagrange_field_name, bool is_alm = false,
2280  bool is_eigen_pos_field = false,
2281  string eigen_pos_field_name = "EIGEN_SPATIAL_POSITIONS",
2282  bool use_reference_coordinates = false);
2283 
2284  /**
2285  * @copydoc SimpleContactProblem::setContactOperatorsLhs
2286  *
2287  * \note This overloaded variant add additional operators for convected
2288  * integration points.
2289  *
2290  */
2292  boost::shared_ptr<ConvectMasterContactElement> fe_lhs_simple_contact,
2293  boost::shared_ptr<CommonDataSimpleContact> common_data_simple_contact,
2294  string field_name, string lagrange_field_name, bool is_alm = false,
2295  bool is_eigen_pos_field = false,
2296  string eigen_pos_field_name = "EIGEN_SPATIAL_POSITIONS",
2297  bool use_reference_coordinates = false);
2298 
2300  boost::shared_ptr<SimpleContactElement> fe_lhs_simple_contact,
2301  boost::shared_ptr<CommonDataSimpleContact> common_data_simple_contact,
2302  string field_name, string lagrange_field_name, bool is_alm = false,
2303  bool is_eigen_pos_field = false,
2304  string eigen_pos_field_name = "EIGEN_SPATIAL_POSITIONS",
2305  bool use_reference_coordinates = false);
2306 
2308  boost::shared_ptr<SimpleContactElement> fe_lhs_simple_contact,
2309  boost::shared_ptr<CommonDataSimpleContact> common_data_simple_contact,
2310  string field_name, string lagrange_field_name, bool is_alm = false,
2311  bool is_eigen_pos_field = false,
2312  string eigen_pos_field_name = "EIGEN_SPATIAL_POSITIONS",
2313  bool use_reference_coordinates = false);
2314 
2316  boost::shared_ptr<ConvectSlaveContactElement> fe_lhs_simple_contact,
2317  boost::shared_ptr<CommonDataSimpleContact> common_data_simple_contact,
2318  string field_name, string lagrange_field_name, bool is_alm = false,
2319  bool is_eigen_pos_field = false,
2320  string eigen_pos_field_name = "EIGEN_SPATIAL_POSITIONS",
2321  bool use_reference_coordinates = false);
2322 
2323  /**
2324  * @brief Function for the simple contact element that sets the user data
2325  * post processing operators
2326  *
2327  * @param fe_post_proc_simple_contact Pointer to the FE instance for post
2328  * processing
2329  * @param common_data_simple_contact Pointer to the common data for simple
2330  * contact element
2331  * @param field_name String of field name for spatial
2332  * positions
2333  * @param lagrange_field_name String of field name for Lagrange
2334  * multipliers
2335  * @param moab_out MOAB interface used to output
2336  * values at integration points
2337  * @param alm_flag bool flag to determine choice of
2338  * approach between ALM or C function to solve frictionless problem
2339  * @param is_eigen_pos_field bool flag to determine choice of
2340  * whether eigen displacements have to be taken into account
2341  * @param eigen_pos_field_name String of field name for eigen spatial
2342  * position
2343  * @return Error code
2344  *
2345  */
2347  boost::shared_ptr<SimpleContactElement> fe_post_proc_simple_contact,
2348  boost::shared_ptr<CommonDataSimpleContact> common_data_simple_contact,
2349  MoFEM::Interface &m_field, string field_name, string lagrange_field_name,
2350  moab::Interface &moab_out, bool alm_flag = false,
2351  bool is_eigen_pos_field = false,
2352  string eigen_pos_field_name = "EIGEN_SPATIAL_POSITIONS",
2353  bool use_reference_coordinates = false,
2354  StateTagSide state_tag_side = NO_TAG);
2355 
2356  /**
2357  * @brief Calculate tangent operator for contact force for change of
2358  * integration point positions, as result of change os spatial positions.
2359  *
2360  */
2362 
2363  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
2364 
2366  const string row_field_name, const string col_field_name,
2367  boost::shared_ptr<CommonDataSimpleContact> common_data_contact,
2368  const ContactOp::FaceType face_type,
2369  boost::shared_ptr<MatrixDouble> diff_convect)
2370  : ContactOp(row_field_name, col_field_name, UserDataOperator::OPROWCOL,
2371  face_type),
2372  commonDataSimpleContact(common_data_contact),
2373  diffConvect(diff_convect) {
2374  sYmm = false;
2375  }
2376 
2377  MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type,
2378  EntityType col_type, EntData &row_data,
2379  EntData &col_data);
2380 
2381  private:
2383  boost::shared_ptr<MatrixDouble> diffConvect;
2384  };
2385 
2386  /**
2387  * @brief Evaluate gradient position on reference master surface.
2388  *
2389  */
2391 
2393  const string field_name,
2394  boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
2395  : ContactOp(field_name, UserDataOperator::OPROW, ContactOp::FACEMASTER),
2396  commonDataSimpleContact(common_data_contact) {}
2397 
2398  MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
2399 
2400  private:
2401  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
2402  };
2403 
2404  /**
2405  * @brief Evaluate gradient of Lagrange multipliers on reference slave surface
2406  *
2407  */
2409 
2411  const string field_name,
2412  boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
2413  : ContactOp(field_name, UserDataOperator::OPROW, ContactOp::FACESLAVE),
2414  commonDataSimpleContact(common_data_contact) {}
2415 
2416  MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
2417 
2418  private:
2419  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
2420  };
2421 
2422  /**
2423  * @brief Tangent opeerator for contrains equation for change of spatial
2424  * positions on master and slave.
2425  *
2426  */
2428 
2430  const string lagrange_field_name, const string field_name,
2431  boost::shared_ptr<CommonDataSimpleContact> common_data_contact,
2432  boost::shared_ptr<double> cn, const ContactOp::FaceType face_type,
2433  boost::shared_ptr<MatrixDouble> diff_convect)
2434  : ContactOp(lagrange_field_name, field_name, UserDataOperator::OPROWCOL,
2435  face_type),
2436  commonDataSimpleContact(common_data_contact), cNPtr(cn),
2437  diffConvect(diff_convect) {
2438  sYmm = false;
2439  }
2440 
2441  MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type,
2442  EntityType col_type, EntData &row_data,
2443  EntData &col_data);
2444 
2445  private:
2447  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
2448  boost::shared_ptr<double> cNPtr;
2449  boost::shared_ptr<MatrixDouble> diffConvect;
2450  };
2451 
2452  /**
2453  * @brief Operator for computing deformation gradients in side volumes
2454  *
2455  */
2457  : public VolumeElementForcesAndSourcesCoreOnContactPrismSide::
2459 
2460  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
2462 
2463  MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
2464 
2466  const string field_name,
2467  boost::shared_ptr<CommonDataSimpleContact> common_data_contact,
2468  bool ho_geometry = false)
2469  : VolumeElementForcesAndSourcesCoreOnContactPrismSide::UserDataOperator(
2470  field_name, UserDataOperator::OPROW),
2471  commonDataSimpleContact(common_data_contact),
2472  hoGeometry(ho_geometry) {
2473  doEdges = false;
2474  doQuads = false;
2475  doTris = false;
2476  doTets = false;
2477  doPrisms = false;
2478  sYmm = false;
2479  };
2480  };
2481 
2482  /**
2483  * @brief Trigers operators for side volume
2484  * element on slave side for evaluation of the RHS contact
2485  * traction in the material configuration on either slave or master surface
2486  */
2488 
2489  boost::shared_ptr<VolumeElementForcesAndSourcesCoreOnContactPrismSide>
2491  string sideFeName;
2492  const ContactOp::FaceType faceType;
2493  /**
2494  * @brief Operator that trigers the pipeline to loop over the side volume
2495  *element operators that is adjacent to the slave side.
2496  **/
2497 
2499  const string field_name,
2500  boost::shared_ptr<VolumeElementForcesAndSourcesCoreOnContactPrismSide>
2501  side_fe,
2502  const string &side_fe_name, const ContactOp::FaceType face_type)
2503  : ContactOp(field_name, UserDataOperator::OPCOL, face_type),
2504  sideFe(side_fe), sideFeName(side_fe_name), faceType(face_type) {}
2505 
2506  MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
2507  };
2508 
2509  /**
2510  * @brief RHS - operator for the contact element (material configuration)
2511  * Integrates virtual work of contact traction in the material
2512  *configuration on master surface.
2513  **/
2515 
2517 
2518  int nbRows; ///< number of dofs on rows
2519  int nbIntegrationPts; ///< number of integration points
2520 
2521  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
2523 
2524  /**
2525  * @brief Integrates virtual work of contact traction in the material
2526  * configuration.
2527  *
2528  * Virtual work of the contact traction corresponding to a test function
2529  * of the material configuration \f$(\delta{\mathbf{X}}^{(2)})\f$:
2530  *
2531  * \f[
2532  * \delta W^\text{material}_p({\mathbf{x}}^{(2)}, {\mathbf{X}}^{(2)},
2533  * \delta{\mathbf{X}}^{(2)}, \lambda) =
2534  * -\int\limits_\mathcal{T^{\rm{(2)}}} \lambda
2535  * \left\{{\left( \mathbf{F}^{(2)} \right)}^{\intercal}\cdot
2536  * \mathbf{N}({\mathbf{X}}^{(2)}) \right\} \cdot \delta{\mathbf{X}}^{(2)}\,
2537  * \textrm{d}\mathcal{T^{\rm {(2)}}} =
2538  * -\int\limits_{\mathcal{T^{\rm{(2)}}}_{\xi}} \lambda
2539  * \left\{{\left( \mathbf{F}^{(2)} \right)}^{\intercal}\cdot
2540  * \left(\frac{\partial\mathbf{X}^{(2)}}
2541  * {\partial\xi}\times\frac{\partial {\mathbf{X}}^{(2)}}
2542  * {\partial\eta}\right) \right\} \cdot \delta{\mathbf{X}}^{(2)}\,
2543  * \textrm{d}\xi\textrm{d}\eta \f]
2544  *
2545  * where \f$(2)\f$ denotes that variables are evaluated on master side, \f$
2546  * \lambda \f$ is contact traction on master surface,
2547  * \f${\mathbf{N}}({\mathbf{X}}^{(2)})\f$ is a normal to the face in the
2548  * material configuration, \f$\xi, \eta\f$ are coordinates in the parent
2549  * space \f$({\mathcal{T}}^{(2)}_\xi)\f$ and \f$\mathbf{F}^{(2)}\f$ is the
2550  * deformation gradient:
2551  *
2552  * \f[
2553  * \mathbf{F}^{(2)} =
2554  * \mathbf{h}({\mathbf{x}}^{(2)})\,\mathbf{H}({\mathbf{X}}^{(2)})^{-1} =
2555  * \frac{\partial{\mathbf{x}}^{(2)}}{\partial{\boldsymbol{\chi}}^{(2)}}
2556  * \frac{\partial{\boldsymbol{\chi}}^{(2)}}{\partial{\mathbf{X}}^{(2)}}
2557  * \f]
2558  *
2559  * where \f$\mathbf{h}\f$ and \f$\mathbf{H}\f$ are the gradients of the
2560  * spatial and material maps, respectively, and \f$\boldsymbol{\chi}\f$
2561  * are the reference coordinates.
2562  *
2563  */
2564 
2565  MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
2566  MoFEMErrorCode iNtegrate(EntData &row_data);
2567  MoFEMErrorCode aSsemble(EntData &row_data);
2568 
2570  const string field_name,
2571  boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
2572  : ContactOp(field_name, UserDataOperator::OPROW, ContactOp::FACEMASTER),
2573  commonDataSimpleContact(common_data_contact) {}
2574  };
2575 
2576  /**
2577  * @brief RHS - operator for the contact element (material configuration)
2578  * Integrates virtual work of contact traction in the material configuration
2579  *on slave surface.
2580  **/
2582 
2584 
2585  int nbRows; ///< number of dofs on rows
2586  int nbIntegrationPts; ///< number of integration points
2587 
2588  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
2590 
2591  /**
2592  * @brief Integrates virtual work of contact traction in the material
2593  * configuration.
2594  *
2595  * Virtual work of the contact traction corresponding to a test function
2596  * of the material configuration \f$(\delta{\mathbf{X}}^{(1)})\f$:
2597  *
2598  * \f[
2599  * \delta W^\text{material}_p({\mathbf{x}}^{(1)}, {\mathbf{X}}^{(1)},
2600  * {\delta\mathbf{X}}^{(1)}, \lambda) =
2601  * -\int\limits_{{\mathcal{T}}^{(1)}} \lambda
2602  * \left\{{\left( \mathbf{F}^{(1)} \right)}^{\intercal}\cdot
2603  * \mathbf{N}({\mathbf{X}}^{(1)}) \right\} \cdot \delta{\mathbf{X}}^{(1)}\,
2604  * \textrm{d}{\mathcal{T}}^{(1)} =
2605  * -\int\limits_{{\mathcal{T}}^{(1)}_{\xi}} \lambda
2606  * \left\{{\left( \mathbf{F}^{(1)} \right)}^{\intercal}\cdot
2607  * \left(\frac{\partial\mathbf{X}^{(1)}}
2608  * {\partial\xi}\times\frac{\partial {\mathbf{X}}^{(1)}}
2609  * {\partial\eta}\right) \right\} \cdot \delta{\mathbf{X}}^{(1)}\,
2610  * \textrm{d}\xi\textrm{d}\eta \f]
2611  *
2612  * where \f(1)\f denotes that variables are evaluated on slave side \f$
2613  * \lambda \f$ is contact traction on slave surface,
2614  * \f${\mathbf{N}}({\mathbf{X}}^{(1)})\f$ is a normal to the face in the
2615  * material configuration, \f$\xi, \eta\f$ are coordinates in the parent
2616  * space \f$({\mathcal{T}}^{(1)}_\xi)\f$ and \f$\mathbf{F}\f$ is the
2617  * deformation gradient:
2618  *
2619  * \f[
2620  * {\mathbf{F}}^{(1)} =
2621  * {\mathbf{h}}({\mathbf{x}}^{(1)})\,\mathbf{H}({\mathbf{X}}^{(1)})^{-1} =
2622  * \frac{\partial{\mathbf{x}}^{(1)}}{\partial{\boldsymbol{\chi}}^{(1)}}
2623  * \frac{\partial{\boldsymbol{\chi}}^{(1)}}{\partial{\mathbf{X}}^{(1)}}
2624  * \f]
2625  *
2626  * where \f$\mathbf{h}\f$ and \f$\mathbf{H}\f$ are the gradients of the
2627  * spatial and material maps, respectively, and \f$\boldsymbol{\chi}\f$
2628  * are the reference coordinates.
2629  *
2630  */
2631 
2632  MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
2633  MoFEMErrorCode iNtegrate(EntData &row_data);
2634  MoFEMErrorCode aSsemble(EntData &row_data);
2635 
2637  const string field_name,
2638  boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
2639  : ContactOp(field_name, UserDataOperator::OPROW, ContactOp::FACESLAVE),
2640  commonDataSimpleContact(common_data_contact) {}
2641  };
2642 
2643  /// \brief Computes, for material configuration, normal to slave face that
2644  /// is common to all gauss points
2645  struct OpGetNormalSlaveALE : public ContactOp {
2646 
2647  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
2649  const string field_name,
2650  boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
2651  : ContactOp(field_name, UserDataOperator::OPCOL, ContactOp::FACESLAVE),
2652  commonDataSimpleContact(common_data_contact) {}
2653 
2654  /**
2655  * @brief Evaluates unit normal vector to the slave surface vector based on
2656  * material base coordinates
2657  *
2658  * Computes normal vector based on material base coordinates based on mesh
2659  * (moab vertices) coordinates:
2660  *
2661  * \f[
2662  * {\mathbf N}^{(1)}({\mathbf X}^{(1)}(\xi, \eta)) =
2663  * \frac{\partial\mathbf{X}^{(1)}(\xi,
2664  * \eta)}{\partial\xi}\times\frac{\partial \mathbf{X}^{(1)}(\xi, \eta)}
2665  * {\partial\eta}
2666  * \f]
2667  *
2668  * where \f${\mathbf X}^{(1)}(\xi, \eta)\f$ is the vector of material
2669  * coordinates at the gauss point on slave surface with parent coordinates
2670  * \f$\xi\f$ and \f$\eta\f$ evaluated according to
2671  *
2672  * \f[
2673  * {\mathbf X}^{(1)}(\xi, \eta) =
2674  * \sum\limits^{3}_{i = 1}
2675  * N_i(\xi, \eta){\overline{\mathbf X}}^{(1)}_i
2676  * \f]
2677  *
2678  * where \f$ N_i \f$ is the shape function corresponding to the \f$
2679  * i-{\rm{th}}\f$ degree of freedom in the material configuration
2680  * \f${\overline{\mathbf X}}^{(1)}_i\f$ corresponding to the 3 nodes of the
2681  * triangular slave face.
2682  *
2683  */
2684  MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
2685  };
2686 
2687  /// \brief Computes, for material configuration, normal to master face that
2688  /// is common to all gauss points
2690 
2691  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
2693  const string field_name,
2694  boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
2695  : ContactOp(field_name, UserDataOperator::OPCOL, ContactOp::FACEMASTER),
2696  commonDataSimpleContact(common_data_contact) {}
2697 
2698  /**
2699  * @brief Evaluates unit normal vector to the master surface vector based on
2700  * material base coordinates
2701  *
2702  * Computes normal vector based on material base coordinates based on mesh
2703  * (moab vertices) coordinates:
2704  *
2705  * \f[
2706  * {\mathbf N}^{(2)}({\mathbf X}(\xi, \eta)) =
2707  * \frac{\partial\mathbf{X}(\xi, \eta)}{\partial\xi}\times\frac{\partial
2708  * \mathbf{X}(\xi, \eta)}
2709  * {\partial\eta}
2710  * \f]
2711  *
2712  * where \f${\mathbf X}(\xi, \eta)\f$ is the vector of material
2713  * coordinates at the gauss point on master surface with parent coordinates
2714  * \f$\xi\f$ and \f$\eta\f$ evaluated according to
2715  *
2716  * \f[
2717  * {\mathbf X}(\xi, \eta) =
2718  * \sum\limits^{3}_{i = 1}
2719  * N_i(\xi, \eta){\bar{\mathbf X}}_i
2720  * \f]
2721  *
2722  * where \f$ N_i \f$ is the shape function corresponding to the \f$
2723  * i-{\rm{th}}\f$ degree of freedom in the material configuration
2724  * \f${{\mathbf {\tilde X} }}_i\f$ corresponding to the 3 nodes of the
2725  * triangular master face.
2726  *
2727  */
2728  MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
2729  };
2730 
2731  /**
2732  * @brief LHS-operator for the contact element (material configuration)
2733  *
2734  * Computes linearisation of normal vector from the expression for
2735  * material traction contribution with respect to material coordinates on
2736  * master side.
2737  *
2738  */
2740 
2741  /**
2742  * @brief Compute part of the left-hand side
2743  *
2744  * Computes the linearisation of the material component
2745  * with respect to a variation of material coordinates
2746  * \f$(\Delta{\mathbf{X}}^{(2)})\f$:
2747  *
2748  * \f[
2749  * \textrm{D} \delta W^\text{(2)}_{\rm{material}}({\mathbf{x}}^{(2)},
2750  * {\mathbf{X}}^{(2)}, \delta{\mathbf{x}}^{(2)})
2751  * [\Delta{\mathbf{X}}^{(2)}] = -\int\limits_{\mathcal{T}^{(2)}_{\xi}}
2752  * \lambda \, \mathbf{F}^{\intercal}\cdot \left[
2753  * \frac{\partial{\mathbf{X}}^{(2)}}
2754  * {\partial\xi} \cdot \left(\frac{\partial\Delta
2755  * {\mathbf{X}}^{(2)}}{\partial\eta}\times\delta{\mathbf{x}}^{(2)}\right)
2756  * -\frac{\partial{\mathbf{X}}^{(2)}}
2757  * {\partial\eta} \cdot \left(\frac{\partial\Delta
2758  * {\mathbf{X}}^{(2)}}{\partial\xi}\times
2759  * \delta{\mathbf{x}}^{(2)}\right)\right] \textrm{d}\xi\textrm{d}\eta
2760  * \f]
2761  *
2762  * Here superscript \f$(2)\f$ denotes
2763  * master side coordinates and surfaces. Moreover,
2764  * \f$\lambda\f$ is the lagrange multiplier.
2765  */
2766  MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data);
2767 
2768  /**
2769  *
2770  * @param mesh_nodes_field_row String of field name for
2771  * material positions for rows
2772  * @param mesh_nodes_field_col String of field name for
2773  * material positions for columns
2774  * @param common_data_contact Pointer to the common data for
2775  * simple contact element
2776  * @param row_rank Parameter setting the
2777  * dimension of the associated field for rows (in this case is 3)
2778  * @param col_rank Parameter setting the
2779  * dimension of the associated field for cols (in this case is 3)
2780  *
2781  */
2783  const string mesh_nodes_field_row, const string mesh_nodes_field_col,
2784  boost::shared_ptr<CommonDataSimpleContact> common_data_contact,
2785  const int row_rank, const int col_rank)
2786  : OpContactMaterialLhs(mesh_nodes_field_row, mesh_nodes_field_col,
2787  common_data_contact, ContactOp::FACEMASTERMASTER,
2788  row_rank, col_rank) {
2789  sYmm = false; // This will make sure to loop over all intities (e.g.
2790  // for order=2 it will make doWork to loop 16 time)
2791  }
2792  };
2793 
2794  /**
2795  * @brief LHS-operator for the contact element (material configuration)
2796  *
2797  * Computes linearisation of normal vector from the expression for
2798  * material traction contribution with respect to material coordinates on
2799  * slave side.
2800  *
2801  */
2803  /**
2804  * @brief Compute part of the left-hand side
2805  *
2806  * Computes the linearisation of the material component
2807  * with respect to a variation of material coordinates
2808  * \f$(\Delta{\mathbf{X}}^{(1)})\f$:
2809  *
2810  * \f[
2811  * \textrm{D} \delta W^\text{(1)}_{\rm{material}}({\mathbf{x}}^{(1)},
2812  * {\mathbf{X}}^{(1)}, \delta{\mathbf{x}}^{(1)})
2813  * [\Delta{\mathbf{X}}^{(1)}] = -\int\limits_{\mathcal{T}^{(1)}_{\xi}}
2814  * \lambda \, \mathbf{F}^{\intercal}\cdot \left[
2815  * \frac{\partial{\mathbf{X}}^{(1)}}
2816  * {\partial\xi} \cdot \left(\frac{\partial\Delta
2817  * {\mathbf{X}}^{(1)}}{\partial\eta}\times\delta{\mathbf{x}}^{(1)}\right)
2818  * -\frac{\partial{\mathbf{X}}^{(1)}}
2819  * {\partial\eta} \cdot \left(\frac{\partial\Delta
2820  * {\mathbf{X}}^{(1)}}{\partial\xi}\times
2821  * \delta{\mathbf{x}}^{(1)}\right)\right] \textrm{d}\xi\textrm{d}\eta
2822  * \f]
2823  *
2824  * Here superscript \f$(1)\f$ denotes
2825  * slave side coordinates and surfaces. Moreover,
2826  * \f$\lambda\f$ is the lagrange multiplier.
2827  */
2828  MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data);
2829 
2830  /**
2831  *
2832  * @param mesh_nodes_field_row String of field name for
2833  * material positions for rows
2834  * @param mesh_nodes_field_col String of field name for
2835  * material positions for columns
2836  * @param common_data_contact Pointer to the common data for
2837  * simple contact element
2838  * @param row_rank Parameter setting the
2839  * dimension of the associated field for rows (in this case is 3)
2840  * @param col_rank Parameter setting the
2841  * dimension of the associated field for cols (in this case is 3)
2842  *
2843  */
2845  const string mesh_nodes_field_row, const string mesh_nodes_field_col,
2846  boost::shared_ptr<CommonDataSimpleContact> common_data_contact,
2847  const int row_rank, const int col_rank)
2848  : OpContactMaterialLhs(mesh_nodes_field_row, mesh_nodes_field_col,
2849  common_data_contact, ContactOp::FACESLAVESLAVE,
2850  row_rank, col_rank) {
2851  sYmm = false; // This will make sure to loop over all intities (e.g.
2852  // for order=2 it will make doWork to loop 16 time)
2853  }
2854  };
2855 
2856  /**
2857  * @brief LHS-operator for the contact element (material configuration)
2858  *
2859  * Computes linearisation of the expression for material
2860  * traction contribution with respect to material coordinates on
2861  * master side.
2862  *
2863  */
2865  : public OpContactMaterialLhs {
2866 
2867  /**
2868  * @brief Compute part of the left-hand side
2869  *
2870  * Computes the linearisation of the material component of contact
2871  * tractions on master side with respect to a variation of lagrange
2872  * multipliers \f$(\Delta\lambda)\f$:
2873  *
2874  * \f[
2875  * \delta W^\text{material}_p({\mathbf{x}}^{(2)}, {\mathbf{X}}^{(2)},
2876  * \delta{\mathbf{X}}^{(2)}, \lambda)[\Delta\lambda] =
2877  * -\int\limits_{{\mathcal{T}}^{(2)}} \Delta\lambda
2878  * \left\{{\left( \mathbf{F}^{(2)} \right)}^{\intercal}\cdot
2879  * \mathbf{N}({\mathbf{X}}^{(2)}) \right\} \cdot
2880  * \delta{\mathbf{X}}^{(2)}\, \textrm{d}{\mathcal{T}}^{(2)} =
2881  * -\int\limits_{{\mathcal{T}}^{(2)}_{\xi}} \Delta\lambda
2882  * \left\{{\left( \mathbf{F}^{(2)} \right)}^{\intercal}\cdot
2883  * \left(\frac{\partial\mathbf{X}^{(2)}}
2884  * {\partial\xi}\times\frac{\partial {\mathbf{X}}^{(2)}}
2885  * {\partial\eta}\right) \right\} \cdot \delta{\mathbf{X}}^{(2)}\,
2886  * \textrm{d}\xi\textrm{d}\eta \f]
2887  *
2888  * where \f$(2)\f$ denotes that the variable belongs to the master side,
2889  * \f$ \lambda \f$ is contact traction on slave surface,
2890  * \f${\mathbf{N}}({\mathbf{X}}^{(2)})\f$ is a normal to the face in the
2891  * material configuration, \f$\xi, \eta\f$ are coordinates in the parent
2892  * space \f$({\mathcal{T}}^{(2)}_\xi)\f$ and \f${\mathbf{F}}^{(2)}\f$ is
2893  * the deformation gradient:
2894  *
2895  * \f[
2896  * {\mathbf{F}}^{(2)} =
2897  * \mathbf{h}({\mathbf{x}}^{(2)})\,\mathbf{H}({\mathbf{X}}^{(2)})^{-1} =
2898  * \frac{\partial{\mathbf{x}}^{(2)}}{\partial{\boldsymbol{\chi}}^{(2)}}
2899  * \frac{\partial{\boldsymbol{\chi}}^{(2)}}{\partial{\mathbf{X}}^{(2)}}
2900  * \f]
2901  *
2902  * where \f$\mathbf{h}\f$ and \f$\mathbf{H}\f$ are the gradients of the
2903  * spatial and material maps, respectively, and \f$\boldsymbol{\chi}\f$
2904  * are the reference coordinates.
2905  *
2906  */
2907 
2908  MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data);
2909 
2910  /**
2911  *
2912  * @param mesh_nodes_field_row String of field name for
2913  * material positions for rows
2914  * @param lagrange_field_name String of field name for
2915  * lagrange field name for columns
2916  * @param common_data_contact Pointer to the common data for
2917  * simple contact element
2918  * @param row_rank Parameter setting the
2919  * dimension of the associated field for rows (in this case is 3)
2920  * @param col_rank Parameter setting the
2921  * dimension of the associated field for cols (in this case is 1)
2922  *
2923  */
2925  const string mesh_nodes_field_row, const string lagrange_field_name,
2926  boost::shared_ptr<CommonDataSimpleContact> common_data_contact,
2927  const int row_rank, const int col_rank)
2928  : OpContactMaterialLhs(mesh_nodes_field_row, lagrange_field_name,
2929  common_data_contact, ContactOp::FACEMASTERSLAVE,
2930  row_rank, col_rank) {
2931  sYmm = false; // This will make sure to loop over all intities (e.g.
2932  // for order=2 it will make doWork to loop 16 time)
2933  }
2934  };
2935 
2936  /**
2937  * @brief LHS-operator for the contact element (material configuration)
2938  *
2939  * Computes linearisation of the expression for material
2940  * traction contribution with respect to material coordinates on slave
2941  * side.
2942  *
2943  */
2945  : public OpContactMaterialLhs {
2946 
2947  /**
2948  * @brief Compute part of the left-hand side
2949  *
2950  * Computes the linearisation of the material component of contact
2951  * tractions on slave side with respect to a variation of lagrange
2952  * multipliers \f$(\Delta\lambda)\f$:
2953  *
2954  * \f[
2955  * \delta W^\text{material}_p({\mathbf{x}}^{(1)}, {\mathbf{X}}^{(1)},
2956  * \delta{\mathbf{X}}^{(1)}, \lambda)[\Delta\lambda] =
2957  * -\int\limits_{{\mathcal{T}}^{(1)}} \Delta\lambda
2958  * \left\{{\left( {\mathbf{F}}^{(1)}\right) }^{\intercal}\cdot
2959  * \mathbf{N}({\mathbf{X}}^{(1)}) \right\} \cdot
2960  * \delta{\mathbf{X}}^{(1)}\, \textrm{d}{\mathcal{T}}^{(1)} =
2961  * -\int\limits_{{\mathcal{T}}^{(1)}_{\xi}} \Delta\lambda
2962  * \left\{{\left( {\mathbf{F}}^{(1)}\right) }^{\intercal}\cdot
2963  * \left(\frac{\partial\mathbf{X}^{(1)}}
2964  * {\partial\xi}\times\frac{\partial {\mathbf{X}}^{(1)}}
2965  * {\partial\eta}\right) \right\} \cdot \delta{\mathbf{X}}^{(1)}\,
2966  * \textrm{d}\xi\textrm{d}\eta \f]
2967  *
2968  * where \f$(1)\f$ denotes that the corresponding variable belongs to
2969  * the slave side \f$ \lambda \f$ is contact traction on slave surface,
2970  * \f${\mathbf{N}}({\mathbf{X}}^{(1)})\f$ is a normal to the face in the
2971  * material configuration, \f$\xi, \eta\f$ are coordinates in the parent
2972  * space \f$({\mathcal{T}}^{(1)}_\xi)\f$ and \f${\mathbf{F}}^{(1)}\f$ is
2973  * the deformation gradient:
2974  *
2975  * \f[
2976  * {\mathbf{F}}^{(1)} =
2977  * \mathbf{h}({\mathbf{x}}^{(1)})\,\mathbf{H}({\mathbf{X}}^{(1)})^{-1} =
2978  * \frac{\partial{\mathbf{x}}^{(1)}}{\partial{\boldsymbol{\chi}}^{(1)}}
2979  * \frac{\partial{\boldsymbol{\chi}}^{(1)}}{\partial{\mathbf{X}}^{(1)}}
2980  * \f]
2981  *
2982  * where \f$\mathbf{h}\f$ and \f$\mathbf{H}\f$ are the gradients of the
2983  * spatial and material maps, respectively, and \f$\boldsymbol{\chi}\f$
2984  * are the reference coordinates.
2985  *
2986  */
2987  MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data);
2988 
2989  /**
2990  *
2991  * @param mesh_nodes_field_row String of field name for
2992  * material positions for rows
2993  * @param lagrange_field_name String of field name for
2994  * lagrange multipliers for columns
2995  * @param common_data_contact Pointer to the common data for
2996  * simple contact element
2997  * @param row_rank Parameter setting the
2998  * dimension of the associated field for rows (in this case is 3)
2999  * @param col_rank Parameter setting the
3000  * dimension of the associated field for cols (in this case is q)
3001  *
3002  */
3004  const string mesh_nodes_field_row, const string lagrange_field_name,
3005  boost::shared_ptr<CommonDataSimpleContact> common_data_contact,
3006  const int row_rank, const int col_rank)
3007  : OpContactMaterialLhs(mesh_nodes_field_row, lagrange_field_name,
3008  common_data_contact, ContactOp::FACESLAVESLAVE,
3009  row_rank, col_rank) {
3010  sYmm = false; // This will make sure to loop over all intities (e.g.
3011  // for order=2 it will make doWork to loop 16 time)
3012  }
3013  };
3014 
3015  /**
3016  * @brief LHS-operator for the simple contact element
3017  *
3018  * Integrates Lagrange multipliers virtual
3019  * work, \f$ \delta W_{\text c}\f$ derivative with respect to material
3020  * positions on slave side and assembles components of the RHS vector.
3021  *
3022  */
3024 
3025  /**
3026  * @brief Integrates Lagrange multipliers virtual
3027  * work, \f$ \delta W_{\text c}\f$ derivative with respect to material
3028  * positions on slave side and assembles components to LHS global
3029  * matrix.
3030  *
3031  *
3032  * \f[
3033  * \textrm{D} \delta W_{\rm{c}}({\mathbf{x}}^{(1)},
3034  * {\mathbf{X}}^{(1)}, \delta{\mathbf{x}}^{(1)})
3035  * [\Delta{\mathbf{X}}^{(1)}] = \int\limits_{\mathcal{T}^{(1)}_{\xi}}
3036  * \lambda \, \left[
3037  * \frac{\partial{\mathbf{X}}^{(1)}}
3038  * {\partial\xi} \cdot \left(\frac{\partial\Delta
3039  * {\mathbf{X}}^{(1)}}{\partial\eta}\times\delta{\mathbf{x}}^{(1)}\right)
3040  * -\frac{\partial{\mathbf{X}}^{(1)}}
3041  * {\partial\eta} \cdot \left(\frac{\partial\Delta
3042  * {\mathbf{X}}^{(1)}}{\partial\xi}\times
3043  * \delta{\mathbf{x}}^{(1)}\right)\right] \textrm{d}\xi\textrm{d}\eta
3044  * \f]
3045  *
3046  * Here superscript \f$(1)\f$ denotes slave
3047  * side coordinates and surfaces, respectively. Moreover,
3048  * \f$\lambda\f$ is the lagrange multiplier.
3049  */
3050  MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data);
3051 
3052  /**
3053  *
3054  * @param field_name String of field name for
3055  * spatial positions for rows
3056  * @param mesh_nodes_field String of field name for
3057  * material positions for columns
3058  * @param common_data_contact Pointer to the common data for
3059  * simple contact element
3060  * @param row_rank Parameter setting the
3061  * dimension of the associated field for rows (in this case is 3)
3062  * @param col_rank Parameter setting the
3063  * dimension of the associated field for cols (in this case is 3)
3064  *
3065  */
3067  const string field_name, const string mesh_nodes_field,
3068  boost::shared_ptr<CommonDataSimpleContact> common_data_contact,
3069  const int row_rank, const int col_rank)
3070  : OpContactALELhs(field_name, mesh_nodes_field, common_data_contact,
3071  ContactOp::FACESLAVESLAVE, row_rank, col_rank) {
3072  sYmm = false; // This will make sure to loop over all intities (e.g.
3073  // for order=2 it will make doWork to loop 16 time)
3074  }
3075  };
3076 
3077  /**
3078  * @brief LHS-operator for the simple contact element
3079  *
3080  * Integrates Lagrange multipliers virtual
3081  * work on master side, \f$ \delta W_{\text c}\f$ derivative with respect
3082  * to material positions on slave side and assembles components of the RHS
3083  * vector.
3084  *
3085  */
3087 
3088  /**
3089  * @brief Integrates Lagrange multipliers virtual
3090  * work on master side, \f$ \delta W_{\text c}\f$ derivative with
3091  * respect to material positions on slave side and assembles components
3092  * to LHS global matrix.
3093  *
3094  *
3095  * \f[
3096  * \textrm{D} \delta W_{\rm{c}}({\mathbf{x}}^{(2)},
3097  * {\mathbf{X}}^{(2)}, \lambda, \delta{\mathbf{x}}^{(2)})
3098  * [\Delta{\mathbf{X}}^{(1)}] = -\int\limits_{\mathcal{T}^{(2)}_{\xi}}
3099  * \lambda \, \left[
3100  * \textrm{D}\mathbf{N}^{(1)}(\mathbf{X}^{(1)})[\Delta\mathbf{X}^{(1)}]
3101  * \frac{1}{||{{\mathbf N}^{(1)}(\xi,
3102  * \eta)}||} -
3103  * \frac{{\mathbf N}^{(1)}(\xi,
3104  * \eta)}{{\left(||{{\mathbf N}^{(1)}(\xi,
3105  * \eta)}|| \right)}^{3}}
3106  * \textrm{D}\mathbf{N}^{(1)}(\mathbf{X}^{(1)})[\Delta\mathbf{X}^{(1)}]
3107  * \cdot {{\mathbf N}^{(1)}(\xi,
3108  * \eta)}
3109  * \right] \cdot \delta{\mathbf{x}}^{(1)}
3110  *
3111  * {||{{\mathbf N}^{(2)}(\xi, \eta)}||}
3112  * \textrm{d}\xi\textrm{d}\eta
3113  * \f]
3114  *
3115  *
3116  * Where
3117  *
3118  * \f[
3119  * \textrm{D}\mathbf{N}^{(1)}(\mathbf{X}^{(1)})[\Delta\mathbf{X}^{(1)}]
3120  * = \frac{\partial{\Delta\mathbf{X}}^{(1)}}
3121  * {\partial\xi} \times \frac{\partial
3122  * {\mathbf{X}}^{(1)}}{\partial\eta}
3123  * + \frac{\partial{\mathbf{X}}^{(1)}}
3124  * {\partial\xi} \times \frac{\partial
3125  * {\Delta\mathbf{X}}^{(1)}}{\partial\eta}
3126  * \f]
3127  *
3128  * Here superscripts \f$(1)\f$ and \f$(2)\f$ denote slave and master
3129  * side coordinates and surfaces, respectively. Moreover,
3130  * \f$\lambda\f$ is the lagrange multiplier.
3131  */
3132  MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data);
3133 
3134  /**
3135  *
3136  * @param field_name String of field name for
3137  * spatial positions for rows
3138  * @param mesh_nodes_field String of field name for
3139  * material positions for columns
3140  * @param common_data_contact Pointer to the common data for
3141  * simple contact element
3142  * @param row_rank Parameter setting the
3143  * dimension of the associated field for rows (in this case is 3)
3144  * @param col_rank Parameter setting the
3145  * dimension of the associated field for cols (in this case is 3)
3146  *
3147  */
3149  const string field_name, const string mesh_nodes_field,
3150  boost::shared_ptr<CommonDataSimpleContact> common_data_contact,
3151  const int row_rank, const int col_rank)
3152  : OpContactALELhs(field_name, mesh_nodes_field, common_data_contact,
3153  ContactOp::FACEMASTERSLAVE, row_rank, col_rank) {
3154  sYmm = false; // This will make sure to loop over all intities (e.g.
3155  // for order=2 it will make doWork to loop 16 time)
3156  }
3157  };
3158 
3159  /**
3160  * @brief LHS-operator for the simple contact element
3161  *
3162  * Integrates Lagrange multipliers virtual
3163  * work on master side, \f$ \delta W_{\text c}\f$ derivative with respect
3164  * to material positions on master side and assembles components of the RHS
3165  * vector.
3166  *
3167  */
3169 
3170  /**
3171  * @brief Integrates Lagrange multipliers virtual
3172  * work on master side, \f$ \delta W_{\text c}\f$ derivative with
3173  * respect to material positions on master side and assembles components
3174  * to LHS global matrix.
3175  *
3176  *
3177  * \f[
3178  * \textrm{D} \delta W_{\rm{c}}({\mathbf{x}}^{(2)},
3179  * {\mathbf{X}}^{(2)}, \lambda, \delta{\mathbf{x}}^{(2)})
3180  * [\Delta{\mathbf{X}}^{(2)}] = -\int\limits_{\mathcal{T}^{(2)}_{\xi}}
3181  * \lambda \,
3182  * \frac{{\mathbf N}^{(1)}(\xi, \eta)}{||{{\mathbf N}^{(1)}(\xi,
3183  * \eta)}||} \left[ \frac{\partial{\mathbf{X}}^{(2)}}
3184  * {\partial\xi} \cdot \left(\frac{\partial\Delta
3185  * {\mathbf{X}}^{(2)}}{\partial\eta}\times\delta{\mathbf{x}}^{(2)}\right)
3186  * -\frac{\partial{\mathbf{X}}^{(2)}}
3187  * {\partial\eta} \cdot \left(\frac{\partial\Delta
3188  * {\mathbf{X}}^{(2)}}{\partial\xi}\times
3189  * \delta{\mathbf{x}}^{(2)}\right)\right] \cdot \frac{{\mathbf
3190  * N}^{(2)}(\xi, \eta)}{||{{\mathbf N}^{(2)}(\xi, \eta)}||}
3191  * \textrm{d}\xi\textrm{d}\eta
3192  * \f]
3193  *
3194  *
3195  *
3196  * Here superscript \f$(1)\f$ and \f$(2)\f$ denote slave and master
3197  * side coordinates and surfaces, respectively. Moreover,
3198  * \f$\lambda\f$ is the lagrange multiplier.
3199  */
3200  MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data);
3201 
3202  /**
3203  *
3204  * @param field_name String of field name for
3205  * spatial positions for rows
3206  * @param mesh_nodes_field String of field name for
3207  * material positions for columns
3208  * @param common_data_contact Pointer to the common data for
3209  * simple contact element
3210  * @param row_rank Parameter setting the
3211  * dimension of the associated field for rows (in this case is 3)
3212  * @param col_rank Parameter setting the
3213  * dimension of the associated field for cols (in this case is 3)
3214  *
3215  */
3217  const string field_name, const string mesh_nodes_field,
3218  boost::shared_ptr<CommonDataSimpleContact> common_data_contact,
3219  const int row_rank, const int col_rank)
3220  : OpContactALELhs(field_name, mesh_nodes_field, common_data_contact,
3221  ContactOp::FACEMASTERMASTER, row_rank, col_rank) {
3222  sYmm = false; // This will make sure to loop over all intities (e.g.
3223  // for order=2 it will make doWork to loop 16 time)
3224  }
3225  };
3226 
3227  /**
3228  * @brief LHS-operator for the simple contact element
3229  *
3230  * Integrates the variation with respect to slave material
3231  * positions of the complementarity function to fulfill KKT conditions in
3232  * the integral sense and assembles
3233  * components to LHS global matrix.
3234  *
3235  */
3237 
3238  /**
3239  * @brief Integrates linearisation of the complementarity
3240  * function at slave face gauss points and assembles
3241  * components to LHS global matrix.
3242  *
3243  * Integrates and assembles the variation with respect to slave spatial
3244  * positions of the complementarity function to fulfill KKT conditions
3245  * in the integral sense and assembles components to LHS global matrix.
3246  *
3247  * \f[
3248  * {\text D}{\overline C(\lambda, \mathbf{x}^{(i)}, \mathbf{X}^{(1)},
3249  * \delta \lambda)}[\Delta \mathbf{X}^{(1)}] =
3250  * \int_{{{\mathcal{T}}^{(1)}_{\xi}}} -\left[
3251  * \textrm{D}\mathbf{N}^{(1)}(\mathbf{X}^{(1)})[\Delta\mathbf{X}^{(1)}]
3252  * - \frac{\mathbf{N}^{(1)}(\mathbf{X}^{(1)})}{||{{\mathbf
3253  * N}^{(1)}(\xi, \eta)}||}
3254  * \textrm{D}\mathbf{N}^{(1)}(\mathbf{X}^{(1)})[\Delta\mathbf{X}^{(1)}]
3255  * \cdot \frac{\mathbf{N}^{(1)}(\mathbf{X}^{(1)})}{||{{\mathbf
3256  * N}^{(1)}(\xi, \eta)}||}
3257  * \right] \cdot \left( {\mathbf{x}}^{(1)} -
3258  * {\mathbf{x}}^{(2)}\right) c_{\text n} \left( 1 +
3259  * {\text {sign}}\left( \lambda - c_{\text n} g_{\textrm{n}} \right)
3260  * {\left| \lambda - c_{\text n}
3261  * g_{\textrm{n}}\right|}^{r-1}\right) \delta{{\lambda}}
3262  * \,\,{ {\text d} {\xi} {\text d} {\eta}} \\
3263  * + \int_{{{\mathcal{T}}^{(1)}_{\xi}}}
3264  * \overline C(\lambda, \mathbf{x}^{(i)}, \mathbf{X}^{(1)},
3265  * \delta \lambda)
3266  * \textrm{D}\mathbf{N}^{(1)}(\mathbf{X}^{(1)})[\Delta\mathbf{X}^{(1)}]
3267  * \cdot \frac{\mathbf{N}^{(1)}(\mathbf{X}^{(1)})}{||{{\mathbf
3268  * N}^{(1)}(\xi, \eta)}||}
3269  * \delta{{\lambda}}
3270  * \,\,{ {\text d} {\xi} {\text d} {\eta}}
3271  * \f]
3272  *
3273  * where
3274  * \f[
3275  * \textrm{D}\mathbf{N}^{(1)}(\mathbf{X}^{(1)})[\Delta\mathbf{X}^{(1)}]
3276  * = \frac{\partial{\Delta\mathbf{X}}^{(1)}}
3277  * {\partial\xi} \times \frac{\partial
3278  * {\mathbf{X}}^{(1)}}{\partial\eta}
3279  * + \frac{\partial{\mathbf{X}}^{(1)}}
3280  * {\partial\xi} \times \frac{\partial
3281  * {\Delta\mathbf{X}}^{(1)}}{\partial\eta}
3282  * \f]
3283  *
3284  * where \f$\xi, \eta\f$ are coordinates in the parent
3285  * space \f$({\mathcal{T}}^{(1)}_\xi)\f$ of the slave surface,
3286  * \f$ \lambda\f$ is the Lagrange
3287  * multiplier, \f$\mathbf{x}^{(i)}\f$ are the coordinates of the
3288  * overlapping gauss points at slave and master triangles for \f$i =
3289  * 1\f$ and \f$i = 2\f$, respectively. Furthermore, \f$ c_{\text n}\f$
3290  * works as an augmentation parameter and affects convergence, \f$r\f$
3291  * is regularisation parameter that here is chosen to be
3292  * \f$r = 1\f$ and \f$ g_{\textrm{n}}\f$ is the
3293  * gap function evaluated at the slave triangle gauss points as: \f[
3294  * g_{\textrm{n}} = - \mathbf{N}(\mathbf{X}^{(1)}) \cdot \left(
3295  * \mathbf{x}^{(1)} - \mathbf{x}^{(2)} \right) \f]
3296  */
3297  MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data);
3298 
3299  /**
3300  *
3301  * @param lagrange_field_name String of field name for
3302  * lagrange multipliers for rows
3303  * @param mesh_nodes_field String of field name for
3304  * material positions for columns
3305  * @param cn regularisation/augmentation
3306  * parameter affecting convergence
3307  * @param common_data_contact Pointer to the common data for
3308  * simple contact element
3309  * @param row_rank Parameter setting the
3310  * dimension of the associated field for rows (in this case is 1)
3311  * @param col_rank Parameter setting the
3312  * dimension of the associated field for cols (in this case is 3)
3313  *
3314  */
3316  const string lagrange_field_name, const string mesh_nodes_field,
3317  boost::shared_ptr<double> cn,
3318  boost::shared_ptr<CommonDataSimpleContact> common_data_contact,
3319  int row_rank, const int col_rank)
3320  : OpContactALELhs(lagrange_field_name, mesh_nodes_field,
3321  common_data_contact, ContactOp::FACESLAVESLAVE,
3322  row_rank, col_rank),
3323  cNPtr(cn) {
3324  sYmm = false; // This will make sure to loop over all intities (e.g.
3325  // for order=2 it will make doWork to loop 16 time)
3326  }
3327 
3328  private:
3329  boost::shared_ptr<double> cNPtr;
3330  };
3331 
3332  /**
3333  * @brief LHS-operator (material configuration) on the side volume of
3334  * either master or slave side
3335  *
3336  * Computes the linearisation of the material component
3337  * with respect to a variation of material coordinates on the side
3338  * volume for either master or slave side.
3339  *
3340  */
3343 
3344  /**
3345  * @brief Integrates over a face contribution from a side volume
3346  *
3347  * Computes linearisation of the material component
3348  * with respect to a variation of material coordinates:
3349  *
3350  * \f[
3351  * \textrm{D} \delta W^\text{(i)}_{\rm{material}}({\mathbf{x}}^{(i)},
3352  * {\mathbf{X}}^{(i)}, \delta{\mathbf{x}}^{(i)})
3353  * [\Delta{\mathbf{X}}^{(i)}] = \int\limits_{{\mathcal{T}}^{(i)}_{\xi}}
3354  * \lambda \left\{\left[
3355  * {\mathbf{h}({\mathbf{x}}^{(i)})}\,{\mathbf{H}^{-1}({\mathbf{X}}^{(i)})}\,\frac{\partial\Delta\mathbf{X}}
3356  * {\partial{\boldsymbol{\chi}}^{(i)}}\,\mathbf{H}^{-1}({\mathbf{X}}^{(i)})
3357  * \right]^{\intercal}\cdot\left(\frac{\partial{\mathbf{X}}^{(i)}}{\partial\xi}
3358  * \times\frac{\partial{\mathbf{X}}^{(i)}}{\partial\eta}\right)\right\}
3359  * \cdot \delta{\mathbf{X}}^{(i)}\, \textrm{d}\xi\textrm{d}\eta
3360  * \f]
3361  *
3362  * where \f$i\f$ denoted either master or slave side.
3363  */
3364 
3365  MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data);
3366 
3367  /**
3368  *
3369  * @param field_name_1 String of field name for spatial
3370  * positions for rows
3371  * @param field_name_2 String of field name for spatial
3372  * positions for columns
3373  * @param common_data_contact Pointer to the common data for
3374  * simple contact element
3375  * @param is_master Bool parameter to distinguish
3376  * between master and slave sides
3377  *
3378  */
3380  const string field_name_1, const string field_name_2,
3381  boost::shared_ptr<CommonDataSimpleContact> common_data_contact,
3382  const bool is_master)
3383  : OpContactMaterialVolOnSideLhs(field_name_1, field_name_2,
3384  common_data_contact, is_master) {
3385  sYmm = false; // This will make sure to loop over all entities
3386  };
3387  };
3388 
3389  /**
3390  * @brief LHS-operator for the contact element (material configuration)
3391  *
3392  * Computes linearisation of normal vector from the expression for
3393  * material traction contribution with respect to material coordinates on
3394  * slave or master side.
3395  *
3396  */
3399 
3400  /**
3401  * @brief Compute part of the left-hand side
3402  *
3403  * Computes the linearisation of the material component
3404  * with respect to a variation of material coordinates
3405  * \f$(\Delta{\mathbf{X}}^{(i)})\f$:
3406  *
3407  * \f[
3408  * \textrm{D} \delta W^\text{(i)}_{\rm{material}}({\mathbf{x}}^{(i)},
3409  * {\mathbf{X}}^{(i)}, \delta{\mathbf{x}}^{(i)})
3410  * [\Delta{\mathbf{X}}^{(i)}] = -\int\limits_{\mathcal{T}^{(i)}_{\xi}}
3411  * \lambda \, \mathbf{F}^{\intercal}\cdot \left[
3412  * \frac{\partial{\mathbf{X}}^{(i)}}
3413  * {\partial\xi} \cdot \left(\frac{\partial\Delta
3414  * {\mathbf{X}}^{(i)}}{\partial\eta}\times\delta{\mathbf{x}}^{(i)}\right)
3415  * -\frac{\partial{\mathbf{X}}^{(i)}}
3416  * {\partial\eta} \cdot \left(\frac{\partial\Delta
3417  * {\mathbf{X}}^{(i)}}{\partial\xi}\times
3418  * \delta{\mathbf{x}}^{(i)}\right)\right] \textrm{d}\xi\textrm{d}\eta
3419  * \f]
3420  *
3421  * Here superscript \f$(i)\f$ is either equal to 1 or 2 denoting slave
3422  * or master side coordinates and surfaces, respectively. Moreover,
3423  * \f$\lambda\f$ is the lagrange multiplier.
3424  */
3426  EntitiesFieldData::EntData &col_data);
3427 
3428  /**
3429  * @brief LHS-operator for the contact element (material configuration)
3430  *
3431  * @param field_name_1 String of field name for spatial
3432  * positions for rows
3433  * @param field_name_2 String of field name for spatial
3434  * positions for columns
3435  * @param common_data_contact Pointer to the common data for
3436  * simple contact element
3437  * @param is_master Bool parameter to distinguish
3438  * between master and slave sides
3439  *
3440  */
3442  const string field_name_1, const string field_name_2,
3443  boost::shared_ptr<CommonDataSimpleContact> common_data_contact,
3444  const bool is_master)
3445  : OpContactMaterialVolOnSideLhs(field_name_1, field_name_2,
3446  common_data_contact, is_master) {
3447  sYmm = false; // This will make sure to loop over all entities
3448  };
3449  };
3450 
3451  /**
3452  * @brief Function for the simple contact element that sets the user data
3453  * post processing operators
3454  *
3455  * @param fe_post_proc_simple_contact Pointer to the FE instance for post
3456  * processing
3457  * @param common_data_simple_contact Pointer to the common data for
3458  * simple contact element
3459  * @param field_name String of field name for spatial
3460  * positions
3461  * @param mesh_node_field_name String of field name for material
3462  * positions
3463  * @param lagrange_field_name String of field name for Lagrange
3464  * multipliers
3465  * @param side_fe_name String of 3D element adjacent to
3466  * the present contact element
3467  * @return Error code
3468  *
3469  */
3471  boost::shared_ptr<SimpleContactElement> fe_rhs_simple_contact_ale,
3472  boost::shared_ptr<CommonDataSimpleContact> common_data_simple_contact,
3473  const string field_name, const string mesh_node_field_name,
3474  const string lagrange_field_name, const string side_fe_name);
3475 
3476  /**
3477  * @brief Function for the simple contact element that sets the user data
3478  * LHS-operators
3479  *
3480  * @param fe_lhs_simple_contact_ale Pointer to the FE instance for LHS
3481  * @param common_data_simple_contact Pointer to the common data for
3482  * simple contact element
3483  * @param field_name String of field name for spatial
3484  * positions
3485  * @param mesh_node_field_name String of field name for material
3486  * positions
3487  * @param lagrange_field_name String of field name for Lagrange
3488  * multipliers
3489  * @param side_fe_name String of 3D element adjacent to the
3490  * present contact element
3491  * @return Error code
3492  *
3493  */
3495  boost::shared_ptr<SimpleContactElement> fe_lhs_simple_contact_ale,
3496  boost::shared_ptr<CommonDataSimpleContact> common_data_simple_contact,
3497  const string field_name, const string mesh_node_field_name,
3498  const string lagrange_field_name, const string side_fe_name);
3499 
3500  /**
3501  * @brief Function for the simple contact element that sets the user data
3502  * LHS-operators
3503  *
3504  * @param fe_lhs_simple_contact_ale Pointer to the FE instance for LHS
3505  * @param common_data_simple_contact Pointer to the common data for
3506  * simple contact element
3507  * @param field_name String of field name for spatial
3508  * positions
3509  * @param mesh_node_field_name String of field name for material
3510  * positions
3511  * @param lagrange_field_name String of field name for Lagrange
3512  * multipliers
3513  * @return Error code
3514  *
3515  */
3517  boost::shared_ptr<SimpleContactElement> fe_lhs_simple_contact_ale,
3518  boost::shared_ptr<CommonDataSimpleContact> common_data_simple_contact,
3519  const string field_name, const string mesh_node_field_name,
3520  const string lagrange_field_name, bool is_eigen_pos_field = false,
3521  string eigen_pos_field_name = "EIGEN_SPATIAL_POSITIONS");
3522 
3523  struct OpGetGaussPtsState : public ContactOp {
3524 
3526  const string lagrange_field_name,
3527  boost::shared_ptr<CommonDataSimpleContact> common_data_contact,
3528  const double cn, const bool alm_flag = false)
3529  : ContactOp(lagrange_field_name, UserDataOperator::OPCOL,
3530  ContactOp::FACESLAVE),
3531  commonDataSimpleContact(common_data_contact), cN(cn),
3532  almFlag(alm_flag) {}
3533 
3534  MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
3535 
3536  private:
3537  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
3538  const double cN;
3539  const bool almFlag;
3541  };
3542 
3543  struct OpGetContactArea : public ContactOp {
3544 
3546  const string lagrange_field_name,
3547  boost::shared_ptr<CommonDataSimpleContact> common_data_contact,
3548  const double cn, const bool alm_flag = false,
3549  Range post_proc_surface = Range(), double post_proc_gap_tol = 0.)
3550  : ContactOp(lagrange_field_name, UserDataOperator::OPCOL,
3551  ContactOp::FACESLAVE),
3552  commonDataSimpleContact(common_data_contact), cN(cn),
3553  almFlag(alm_flag), postProcSurface(post_proc_surface),
3554  postProcGapTol(post_proc_gap_tol) {}
3555 
3556  MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
3557 
3558  private:
3559  boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
3560  const double cN;
3561  const bool almFlag;
3565  };
3566 };
3567 
3568 double SimpleContactProblem::Sign(double x) {
3569  if (x == 0)
3570  return 0;
3571  else if (x > 0)
3572  return 1;
3573  else
3574  return -1;
3575 };
3576 
3577 bool SimpleContactProblem::State(const double cn, const double g,
3578  const double l) {
3579  return ((cn * g) <= l);
3580 }
3581 
3582 bool SimpleContactProblem::StateALM(const double cn, const double g,
3583  const double l) {
3584  return ((l + cn * g) < 0. || abs(l + cn * g) < ALM_TOL);
3585 }
3586 
3587 double SimpleContactProblem::ConstrainFunction(const double cn, const double g,
3588  const double l) {
3589  if ((cn * g) <= l)
3590  return cn * g;
3591  else
3592  return l;
3593 }
3594 
3596  const double g,
3597  const double l) {
3598  return cn * (1 + Sign(l - cn * g)) / static_cast<double>(2);
3599 }
3600 
3602  const double g,
3603  const double l) {
3604  return (1 + Sign(cn * g - l)) / static_cast<double>(2);
3605 }
3606 
3607 #endif
MoFEMFunctionReturnHot
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:447
SimpleContactProblem::CommonDataSimpleContact::gaussPtsStateVec
SmartPetscObj< Vec > gaussPtsStateVec
Definition: SimpleContact.hpp:440
SimpleContactProblem::setContactOperatorsRhs
MoFEMErrorCode setContactOperatorsRhs(boost::shared_ptr< SimpleContactElement > fe_rhs_simple_contact, boost::shared_ptr< CommonDataSimpleContact > common_data_simple_contact, string field_name, string lagrange_field_name, bool is_alm=false, bool is_eigen_pos_field=false, string eigen_pos_field_name="EIGEN_SPATIAL_POSITIONS", bool use_reference_coordinates=false)
Function for the simple contact element for C function or ALM approach that sets the user data RHS-op...
Definition: SimpleContact.cpp:2399
SimpleContactProblem::OpContactMaterialSlaveSlaveLhs_dX_dLagmult
LHS-operator for the contact element (material configuration)
Definition: SimpleContact.hpp:2944
SimpleContactProblem::CommonDataSimpleContact::tangentTwoVectorMasterPtr
boost::shared_ptr< VectorDouble > tangentTwoVectorMasterPtr
Definition: SimpleContact.hpp:420
SimpleContactProblem::OpCalDerIntCompFunOverSpatPosSlaveMaster::cNPtr
boost::shared_ptr< double > cNPtr
Definition: SimpleContact.hpp:1499
SimpleContactProblem::OpCalContactAugmentedTractionOverLambdaSlaveSlave
LHS-operator for the simple contact element with Augmented Lagrangian Method.
Definition: SimpleContact.hpp:1642
SimpleContactProblem::OpContactMaterialSlaveSlaveLhs_dX_dLagmult::OpContactMaterialSlaveSlaveLhs_dX_dLagmult
OpContactMaterialSlaveSlaveLhs_dX_dLagmult(const string mesh_nodes_field_row, const string lagrange_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, const int row_rank, const int col_rank)
Definition: SimpleContact.hpp:3003
SimpleContactProblem::OpCalContactAugmentedTractionOverLambdaMasterSlave::OpCalContactAugmentedTractionOverLambdaMasterSlave
OpCalContactAugmentedTractionOverLambdaMasterSlave(const string field_name, const string lagrange_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Definition: SimpleContact.hpp:1580
SimpleContactProblem::cnValue
double cnValue
Definition: SimpleContact.hpp:482
SimpleContactProblem::OpContactALELhs::aSsemble
MoFEMErrorCode aSsemble(EntData &row_data, EntData &col_data)
Definition: SimpleContact.cpp:3957
SimpleContactProblem::OpContactALELhs::row_nb_dofs
int row_nb_dofs
Definition: SimpleContact.hpp:555
SimpleContactProblem::OpContactTractionMasterSlave_dX::OpContactTractionMasterSlave_dX
OpContactTractionMasterSlave_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)
Definition: SimpleContact.hpp:3148
SimpleContactProblem::OpCalContactTractionOnSlave::OpCalContactTractionOnSlave
OpCalContactTractionOnSlave(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Definition: SimpleContact.hpp:1009
SimpleContactProblem::OpCalContactTractionOnSlave::vecF
VectorDouble vecF
Definition: SimpleContact.hpp:1041
SimpleContactProblem::OpContactMaterialVolOnSideLhs::nb_gauss_pts
int nb_gauss_pts
Definition: SimpleContact.hpp:607
MoFEM::EntitiesFieldData::EntData
Data on single entity (This is passed as argument to DataOperator::doWork)
Definition: EntitiesFieldData.hpp:127
SimpleContactProblem::ConstrainFunction_dg
static double ConstrainFunction_dg(const double cn, const double g, const double l)
Definition: SimpleContact.hpp:3595
SimpleContactProblem::OpCalDerIntCompFunOverSpatPosSlaveMaster::NN
MatrixDouble NN
Definition: SimpleContact.hpp:1500
SimpleContactProblem::OpGetGaussPtsState::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:3537
SimpleContactProblem::OpContactMaterialLhs::rowIndices
VectorInt rowIndices
Definition: SimpleContact.hpp:502
SimpleContactProblem::OpCalMatForcesALEMaster::nbRows
int nbRows
number of dofs on rows
Definition: SimpleContact.hpp:2518
g
constexpr double g
Definition: shallow_wave.cpp:63
SimpleContactProblem::OpCalContactAugmentedTractionOverSpatialSlaveSlave::NN
MatrixDouble NN
Definition: SimpleContact.hpp:1904
SimpleContactProblem::OpCalContactTractionOverLambdaSlaveSlave::NN
MatrixDouble NN
Definition: SimpleContact.hpp:1374
SimpleContactProblem::OpCalculateDeformation
Operator for computing deformation gradients in side volumes.
Definition: SimpleContact.hpp:2456
SimpleContactProblem::OpContactALELhs::rowIndices
VectorInt rowIndices
Definition: SimpleContact.hpp:552
SimpleContactProblem::OpCalMatForcesALESlave::nbRows
int nbRows
number of dofs on rows
Definition: SimpleContact.hpp:2585
SimpleContactProblem::OpGapConstraintAugmentedOverSpatialMaster::cN
const double cN
Definition: SimpleContact.hpp:2104
SimpleContactProblem::CommonDataSimpleContact::hMat
boost::shared_ptr< MatrixDouble > hMat
Definition: SimpleContact.hpp:425
SimpleContactProblem::OpGetGaussPtsState::vecR
VectorDouble vecR
Definition: SimpleContact.hpp:3540
SimpleContactProblem::OpGetContactArea::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Definition: SimpleContact.cpp:4672
SimpleContactProblem::OpGetGapSlave::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Evaluates gap function at slave face gauss points.
Definition: SimpleContact.cpp:686
SimpleContactProblem::OpContactALELhs::rankCol
int rankCol
Definition: SimpleContact.hpp:563
SimpleContactProblem::OpGapConstraintAugmentedOverSpatialSlave
LHS-operator for the simple contact element.
Definition: SimpleContact.hpp:2116
SimpleContactProblem::ConvectSlaveIntegrationPts::getDiffKsiSpatialMaster
boost::shared_ptr< MatrixDouble > getDiffKsiSpatialMaster()
Definition: SimpleContact.hpp:147
SimpleContactProblem::CommonDataSimpleContact::gapPtr
boost::shared_ptr< VectorDouble > gapPtr
Definition: SimpleContact.hpp:414
SimpleContactProblem::OpGetLagMulAtGaussPtsSlave::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Definition: SimpleContact.cpp:729
SimpleContactProblem::ConvectSlaveIntegrationPts::slaveMaterialCoords
MatrixDouble slaveMaterialCoords
Definition: SimpleContact.hpp:165
SimpleContactProblem::OpContactALELhs::doWork
MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type, EntityType col_type, EntData &row_data, EntData &col_data)
Definition: SimpleContact.cpp:3841
SimpleContactProblem::OpGetNormalMaster::OpGetNormalMaster
OpGetNormalMaster(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Definition: SimpleContact.hpp:710
SimpleContactProblem::OpContactMaterialLhs::OpContactMaterialLhs
OpContactMaterialLhs(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, boost::shared_ptr< VolumeElementForcesAndSourcesCoreOnContactPrismSide > side_fe=NULL, const string side_fe_name="")
Definition: SimpleContact.hpp:526
SimpleContactProblem::OpCalIntCompFunSlave::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:1200
SimpleContactProblem::OpCalDerIntCompFunOverSpatPosSlaveSlave::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:1562
SimpleContactProblem::OpCalContactAugmentedTractionOverSpatialSlaveMaster::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:1973
SimpleContactProblem::OpCalDerIntCompFunSlaveSlave_dX::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)
Definition: SimpleContact.hpp:3315
SimpleContactProblem::OpLhsConvectIntegrationPtsConstrainMasterGap::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:2447
SimpleContactProblem::OpContactMaterialVolOnSideLhs::row_nb_dofs
int row_nb_dofs
Definition: SimpleContact.hpp:605
SimpleContactProblem::OpLhsConvectIntegrationPtsConstrainMasterGap::matLhs
MatrixDouble matLhs
Definition: SimpleContact.hpp:2446
SimpleContactProblem::OpGapConstraintAugmentedOverSpatialMaster::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:2103
SimpleContactProblem::FaceUserDataOperator
FaceElementForcesAndSourcesCore::UserDataOperator FaceUserDataOperator
Definition: SimpleContact.hpp:33
SimpleContactProblem::OpCalMatForcesALEMaster::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Integrates virtual work of contact traction in the material configuration.
Definition: SimpleContact.cpp:3142
SimpleContactProblem::CommonDataSimpleContact::areaMaster
double areaMaster
Definition: SimpleContact.hpp:434
SimpleContactProblem::StateALM
static bool StateALM(const double cn, const double g, const double l)
Definition: SimpleContact.hpp:3582
SimpleContactProblem::OpContactALELhs::nb_base_fun_col
int nb_base_fun_col
Definition: SimpleContact.hpp:560
SimpleContactProblem::OpGetMatPosForDisplAtGaussPtsSlave::OpGetMatPosForDisplAtGaussPtsSlave
OpGetMatPosForDisplAtGaussPtsSlave(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Definition: SimpleContact.hpp:830
SimpleContactProblem::SimpleContactElement::ConvectSlaveIntegrationPts
friend ConvectSlaveIntegrationPts
Definition: SimpleContact.hpp:128
SimpleContactProblem::OpGetContactArea::OpGetContactArea
OpGetContactArea(const string lagrange_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, const double cn, const bool alm_flag=false, Range post_proc_surface=Range(), double post_proc_gap_tol=0.)
Definition: SimpleContact.hpp:3545
SimpleContactProblem::OpCalContactTractionOverLambdaMasterSlave::NN
MatrixDouble NN
Definition: SimpleContact.hpp:1320
SimpleContactProblem::OpGapConstraintAugmentedOverSpatialMaster::doWork
MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type, EntityType col_type, EntData &row_data, EntData &col_data)
Integrates the conditions that fulfil KKT conditions at master face gauss points and assembles compon...
Definition: SimpleContact.cpp:1016
SimpleContactProblem::OpContactMaterialVolOnSideLhs::col_nb_dofs
int col_nb_dofs
Definition: SimpleContact.hpp:606
SimpleContactProblem::OpContactMaterialVolOnSideLhs::tangentOne
boost::shared_ptr< VectorDouble > tangentOne
Definition: SimpleContact.hpp:612
SimpleContactProblem::mField
MoFEM::Interface & mField
Definition: SimpleContact.hpp:485
SimpleContactProblem::OpCalContactAugmentedTractionOverSpatialSlaveSlave::cN
const double cN
Definition: SimpleContact.hpp:1903
SimpleContactProblem::OpCalDerIntCompFunOverSpatPosSlaveMaster::OpCalDerIntCompFunOverSpatPosSlaveMaster
OpCalDerIntCompFunOverSpatPosSlaveMaster(const string lagrange_field_name, const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, boost::shared_ptr< double > cn)
Definition: SimpleContact.hpp:1450
SimpleContactProblem::OpCalMatForcesALEMaster::iNtegrate
MoFEMErrorCode iNtegrate(EntData &row_data)
Definition: SimpleContact.cpp:3169
SimpleContactProblem::ConvectSlaveContactElement
Element used to integrate on master surfaces. It convects integration points on slaves,...
Definition: SimpleContact.hpp:206
SimpleContactProblem::OpContactMaterialVolOnSideLhs::doWork
MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type, EntityType col_type, EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
Definition: SimpleContact.cpp:4356
SimpleContactProblem::OpCalContactAugmentedTractionOverSpatialSlaveSlave::doWork
MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type, EntityType col_type, EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
Integrates virtual work on slave side, , derivative with respect to slave spatial positions and assem...
Definition: SimpleContact.cpp:1337
SimpleContactProblem::OpContactMaterialLhs::nb_base_fun_col
int nb_base_fun_col
Definition: SimpleContact.hpp:510
SimpleContactProblem::OpMakeTestTextFile::mySplit
ofstream & mySplit
Definition: SimpleContact.hpp:2211
MoFEM::CoreInterface::get_comm
virtual MPI_Comm & get_comm() const =0
SimpleContactProblem::OpGetNormalMasterALE::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:2691
SimpleContactProblem::ConvectSlaveIntegrationPts::diffKsiMaster
MatrixDouble diffKsiMaster
Definition: SimpleContact.hpp:171
SimpleContactProblem::OpCalDerIntCompFunSlaveSlave_dX::cNPtr
boost::shared_ptr< double > cNPtr
Definition: SimpleContact.hpp:3329
MoFEM::CoreInterface::modify_finite_element_add_field_row
virtual MoFEMErrorCode modify_finite_element_add_field_row(const std::string &fe_name, const std::string name_row)=0
set field row which finite element use
SimpleContactProblem::OpCalDerIntCompFunSlaveSlave_dX
LHS-operator for the simple contact element.
Definition: SimpleContact.hpp:3236
SimpleContactProblem::OpCalContactTractionOnMaster::OpCalContactTractionOnMaster
OpCalContactTractionOnMaster(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Definition: SimpleContact.hpp:964
SimpleContactProblem::OpCalAugmentedTractionRhsSlave::vecF
VectorDouble vecF
Definition: SimpleContact.hpp:1149
SimpleContactProblem::OpContactMaterialVolOnSideLhs_dX_dX::iNtegrate
MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
Compute part of the left-hand side.
Definition: SimpleContact.cpp:4038
SimpleContactProblem::OpGapConstraintAugmentedOverSpatialSlave::doWork
MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type, EntityType col_type, EntData &row_data, EntData &col_data)
Integrates the conditions that fulfil KKT conditions at slave face gauss points and assembles compone...
Definition: SimpleContact.cpp:1095
SimpleContactProblem::SimpleContactPrismsData
Definition: SimpleContact.hpp:67
SimpleContactProblem::SimpleContactElement::SimpleContactElement
SimpleContactElement(MoFEM::Interface &m_field, bool newton_cotes=false)
Definition: SimpleContact.hpp:82
SimpleContactProblem::OpCalculateGradLambdaXi::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:2419
SimpleContactProblem::OpLagGapProdGaussPtsSlave::OpLagGapProdGaussPtsSlave
OpLagGapProdGaussPtsSlave(const string lagrange_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Definition: SimpleContact.hpp:945
ContactEle
SimpleContactProblem::OpContactMaterialMasterOnFaceLhs_dX_dX::iNtegrate
MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data)
Compute part of the left-hand side.
Definition: SimpleContact.cpp:4105
SimpleContactProblem::Sign
static double Sign(double x)
Definition: SimpleContact.hpp:3568
MoFEM::createSmartVectorMPI
DEPRECATED auto createSmartVectorMPI(MPI_Comm comm, PetscInt n, PetscInt N)
Definition: PetscSmartObj.hpp:209
SimpleContactProblem::OpCalAugmentedTractionRhsMaster::OpCalAugmentedTractionRhsMaster
OpCalAugmentedTractionRhsMaster(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Definition: SimpleContact.hpp:1054
SimpleContactProblem::OpGetGaussPtsState::cN
const double cN
Definition: SimpleContact.hpp:3538
SimpleContactProblem::OpCalMatForcesALESlave::nbIntegrationPts
int nbIntegrationPts
number of integration points
Definition: SimpleContact.hpp:2586
SimpleContactProblem::OpGetNormalSlave
Computes, for reference configuration, normal to slave face that is common to all gauss points.
Definition: SimpleContact.hpp:664
SimpleContactProblem::OpGetMatPosForDisplAtGaussPtsMaster
Operator for the simple contact element.
Definition: SimpleContact.hpp:773
SimpleContactProblem::OpCalContactAugmentedTractionOverLambdaMasterSlave::NN
MatrixDouble NN
Definition: SimpleContact.hpp:1630
SimpleContactProblem::OpContactMaterialLhs::rankCol
int rankCol
Definition: SimpleContact.hpp:513
SimpleContactProblem::OpCalMatForcesALESlave::vecF
VectorDouble vecF
Definition: SimpleContact.hpp:2589
SimpleContactProblem::OpCalContactAugmentedTractionOverSpatialMasterMaster::OpCalContactAugmentedTractionOverSpatialMasterMaster
OpCalContactAugmentedTractionOverSpatialMasterMaster(const string field_name, const string field_name_2, const double cn_value, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Definition: SimpleContact.hpp:1709
SimpleContactProblem::OpGetContactArea::almFlag
const bool almFlag
Definition: SimpleContact.hpp:3561
MoFEM::Exceptions::MoFEMErrorCode
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
Definition: Exceptions.hpp:56
SimpleContactProblem::StateTagSide
StateTagSide
Choice of the contact prism side to put the state tag on.
Definition: SimpleContact.hpp:2177
SimpleContactProblem::OpContactMaterialVolOnSideLhs::aSsemble
MoFEMErrorCode aSsemble(EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
Definition: SimpleContact.cpp:4402
SimpleContactProblem::OpContactMaterialVolOnSideLhs_dX_dX
LHS-operator for the contact element (material configuration)
Definition: SimpleContact.hpp:3397
SimpleContactProblem::ConvectSlaveIntegrationPts::convectSlaveIntegrationPts
MoFEMErrorCode convectSlaveIntegrationPts()
Definition: SimpleContact.cpp:56
SimpleContactProblem::OpGetNormalSlaveALE
Computes, for material configuration, normal to slave face that is common to all gauss points.
Definition: SimpleContact.hpp:2645
MoFEM::Types::MatrixDouble
UBlasMatrix< double > MatrixDouble
Definition: Types.hpp:77
SimpleContactProblem::OpGapConstraintAugmentedOverSpatialMaster::NN
MatrixDouble NN
Definition: SimpleContact.hpp:2105
SimpleContactProblem::OpContactALELhs::iNtegrate
virtual MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data)
Definition: SimpleContact.hpp:569
SimpleContactProblem::OpCalContactAugmentedTractionOverSpatialMasterMaster::doWork
MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type, EntityType col_type, EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
Integrates virtual work on master side , , derivative with respect to spatial positions of the master...
Definition: SimpleContact.cpp:1169
SimpleContactProblem::ConvectSlaveIntegrationPts::sparialPositionsField
const string sparialPositionsField
Definition: SimpleContact.hpp:159
SimpleContactProblem::OpCalContactAugmentedTractionOverSpatialSlaveMaster
LHS-operator for the simple contact element with Augmented Lagrangian Method.
Definition: SimpleContact.hpp:1917
SimpleContactProblem::OpGetMatPosForDisplAtGaussPtsSlave::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:829
SimpleContactProblem::OpContactMaterialSlaveOnFaceLhs_dX_dX::OpContactMaterialSlaveOnFaceLhs_dX_dX
OpContactMaterialSlaveOnFaceLhs_dX_dX(const string mesh_nodes_field_row, const string mesh_nodes_field_col, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, const int row_rank, const int col_rank)
Definition: SimpleContact.hpp:2844
SimpleContactProblem::OpContactMaterialLhs::aSsemble
MoFEMErrorCode aSsemble(EntData &row_data, EntData &col_data)
Definition: SimpleContact.cpp:3921
SimpleContactProblem::OpMakeTestTextFile
Definition: SimpleContact.hpp:2207
SimpleContactProblem::OpCalContactAugmentedTractionOverSpatialMasterMaster::NN
MatrixDouble NN
Definition: SimpleContact.hpp:1764
MoFEM::CoreInterface::get_comm_rank
virtual int get_comm_rank() const =0
SimpleContactProblem::OpGapConstraintAugmentedOverLambda::OpGapConstraintAugmentedOverLambda
OpGapConstraintAugmentedOverLambda(const string lagrange_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, const double cn)
Definition: SimpleContact.hpp:1989
SimpleContactProblem::OpCalMatForcesALEMaster::rowIndices
VectorInt rowIndices
Definition: SimpleContact.hpp:2516
SimpleContactProblem::OpGetPositionAtGaussPtsSlave::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Definition: SimpleContact.cpp:570
SimpleContactProblem::OpContactMaterialVolOnSideLhs::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:600
SimpleContactProblem::ConvectSlaveIntegrationPts::masterN
MatrixDouble masterN
Definition: SimpleContact.hpp:169
SimpleContactProblem::OpGetMatPosForDisplAtGaussPtsMaster::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:775
SimpleContactProblem::ConstrainFunction_dl
static double ConstrainFunction_dl(const double cn, const double g, const double l)
Definition: SimpleContact.hpp:3601
SimpleContactProblem::OpGapConstraintAugmentedOverSpatialSlave::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:2169
SimpleContactProblem::CommonDataSimpleContact::HMat
boost::shared_ptr< MatrixDouble > HMat
Definition: SimpleContact.hpp:427
SimpleContactProblem::setContactOperatorsLhsALE
MoFEMErrorCode setContactOperatorsLhsALE(boost::shared_ptr< SimpleContactElement > fe_lhs_simple_contact_ale, boost::shared_ptr< CommonDataSimpleContact > common_data_simple_contact, const string field_name, const string mesh_node_field_name, const string lagrange_field_name, bool is_eigen_pos_field=false, string eigen_pos_field_name="EIGEN_SPATIAL_POSITIONS")
Function for the simple contact element that sets the user data LHS-operators.
Definition: SimpleContact.cpp:4611
SimpleContactProblem::OpCalContactTractionOnMaster
RHS-operator for the simple contact element.
Definition: SimpleContact.hpp:962
SimpleContactProblem::OpGapConstraintAugmentedRhs::vecR
VectorDouble vecR
Definition: SimpleContact.hpp:1266
SimpleContactProblem::CommonDataSimpleContact::invHMat
boost::shared_ptr< MatrixDouble > invHMat
Definition: SimpleContact.hpp:428
SimpleContactProblem::OpGetNormalMaster::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Evaluates unit normal vector to the master surface vector based on reference base coordinates.
Definition: SimpleContact.cpp:420
SimpleContactProblem::OpGapConstraintAugmentedOverLambda::doWork
MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type, EntityType col_type, EntData &row_data, EntData &col_data)
Integrates the conditions that fulfil KKT conditions at slave face gauss points and assembles compone...
Definition: SimpleContact.cpp:953
SimpleContactProblem::LoadScale::lAmbda
static double lAmbda
Definition: SimpleContact.hpp:37
SimpleContactProblem::OpGetDeformationFieldForDisplAtGaussPtsMaster::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Definition: SimpleContact.cpp:534
SimpleContactProblem::OpLhsConvectIntegrationPtsContactTraction::matLhs
MatrixDouble matLhs
Definition: SimpleContact.hpp:2382
SimpleContactProblem::LoadScale::scaleNf
MoFEMErrorCode scaleNf(const FEMethod *fe, VectorDouble &nf)
Definition: SimpleContact.hpp:39
SimpleContactProblem::OpContactTractionSlaveSlave_dX
LHS-operator for the simple contact element.
Definition: SimpleContact.hpp:3023
SimpleContactProblem::OpCalMatForcesALESlave::rowIndices
VectorInt rowIndices
Definition: SimpleContact.hpp:2583
SimpleContactProblem::CommonDataSimpleContact::normalVectorSlavePtr
boost::shared_ptr< VectorDouble > normalVectorSlavePtr
Definition: SimpleContact.hpp:422
SimpleContactProblem::cnValuePtr
boost::shared_ptr< double > cnValuePtr
Definition: SimpleContact.hpp:484
SimpleContactProblem::OpCalDerIntCompFunOverLambdaSlaveSlave::cNPtr
boost::shared_ptr< double > cNPtr
Definition: SimpleContact.hpp:1435
SimpleContactProblem::OpContactMaterialLhs
Definition: SimpleContact.hpp:494
SimpleContactProblem::OpContactMaterialVolOnSideLhs_dX_dX::OpContactMaterialVolOnSideLhs_dX_dX
OpContactMaterialVolOnSideLhs_dX_dX(const string field_name_1, const string field_name_2, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, const bool is_master)
LHS-operator for the contact element (material configuration)
Definition: SimpleContact.hpp:3441
SimpleContactProblem::OpCalculateDeformation::hoGeometry
bool hoGeometry
Definition: SimpleContact.hpp:2461
SimpleContactProblem::OpCalDerIntCompFunOverSpatPosSlaveMaster
LHS-operator for the simple contact element.
Definition: SimpleContact.hpp:1448
SimpleContactProblem::OpCalContactAugmentedTractionOverSpatialSlaveMaster::doWork
MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type, EntityType col_type, EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
Integrates virtual work on slave side, , derivative with respect to spatial positions on master side ...
Definition: SimpleContact.cpp:1421
SimpleContactProblem::OpContactALELhs::matLhs
MatrixDouble matLhs
Definition: SimpleContact.hpp:551
SimpleContactProblem::OpGetPositionAtGaussPtsMaster::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:757
SimpleContactProblem::OpContactMaterialVolOnSideLhs_dX_dx
LHS-operator (material configuration) on the side volume of either master or slave side.
Definition: SimpleContact.hpp:3341
SimpleContactProblem::CommonDataSimpleContact::mField
MoFEM::Interface & mField
Definition: SimpleContact.hpp:479
SimpleContactProblem::OpGapConstraintAugmentedOverSpatialSlave::NN
MatrixDouble NN
Definition: SimpleContact.hpp:2171
SimpleContactProblem::OpGetContactArea::postProcGapTol
double postProcGapTol
Definition: SimpleContact.hpp:3564
SimpleContactProblem::OpGetNormalSlave::OpGetNormalSlave
OpGetNormalSlave(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Definition: SimpleContact.hpp:667
SimpleContactProblem::OpCalAugmentedTractionRhsSlave::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:1148
SimpleContactProblem::OpGetDeformationFieldForDisplAtGaussPtsSlave::OpGetDeformationFieldForDisplAtGaussPtsSlave
OpGetDeformationFieldForDisplAtGaussPtsSlave(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Definition: SimpleContact.hpp:848
SimpleContactProblem::OpContactMaterialVolOnSideLhs::normalVector
boost::shared_ptr< VectorDouble > normalVector
Definition: SimpleContact.hpp:615
order
constexpr int order
Definition: dg_projection.cpp:18
SimpleContactProblem::OpCalMatForcesALESlave
RHS - operator for the contact element (material configuration) Integrates virtual work of contact tr...
Definition: SimpleContact.hpp:2581
SimpleContactProblem::OpCalContactAugmentedTractionOverSpatialMasterSlave
LHS-operator for the simple contact element with Augmented Lagrangian Method.
Definition: SimpleContact.hpp:1776
SimpleContactProblem::OpGapConstraintAugmentedOverSpatialMaster
LHS-operator for the simple contact element.
Definition: SimpleContact.hpp:2051
MoFEM::DeprecatedCoreInterface
Deprecated interface functions.
Definition: DeprecatedCoreInterface.hpp:16
SimpleContactProblem::OpGapConstraintAugmentedRhs::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Definition: SimpleContact.cpp:1685
SimpleContactProblem::addContactElement
MoFEMErrorCode addContactElement(const string element_name, const string field_name, const string lagrange_field_name, Range &range_slave_master_prisms, bool eigen_pos_flag=false, const string eigen_node_field_name="EIGEN_SPATIAL_POSITIONS")
Function that adds field data for spatial positions and Lagrange multipliers to rows and columns,...
Definition: SimpleContact.hpp:231
SimpleContactProblem::OpLoopForSideOfContactPrism
Trigers operators for side volume element on slave side for evaluation of the RHS contact traction in...
Definition: SimpleContact.hpp:2487
SimpleContactProblem::OpMakeTestTextFile::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Definition: SimpleContact.cpp:2369
SimpleContactProblem::OpCalContactTractionOverLambdaSlaveSlave::doWork
MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type, EntityType col_type, EntData &row_data, EntData &col_data)
Integrates and assembles Lagrange multipliers virtual work, derivative with respect to Lagrange mult...
Definition: SimpleContact.cpp:1927
SimpleContactProblem::OpLhsConvectIntegrationPtsContactTraction
Calculate tangent operator for contact force for change of integration point positions,...
Definition: SimpleContact.hpp:2361
MoFEM::Interface
DeprecatedCoreInterface Interface
Definition: Interface.hpp:1975
SimpleContactProblem::CommonDataSimpleContact::detHVec
boost::shared_ptr< VectorDouble > detHVec
Definition: SimpleContact.hpp:429
SimpleContactProblem::OpContactMaterialVolOnSideLhs::tangentTwo
boost::shared_ptr< VectorDouble > tangentTwo
Definition: SimpleContact.hpp:613
SimpleContactProblem::OpMakeVtkSlave::OpMakeVtkSlave
OpMakeVtkSlave(MoFEM::Interface &m_field, string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data, moab::Interface &moab_out, StateTagSide state_tag_side=NO_TAG, Range post_proc_surface=Range())
Definition: SimpleContact.hpp:2194
SimpleContactProblem::OpCalContactTractionOnSlave
RHS-operator for the simple contact element.
Definition: SimpleContact.hpp:1007
SimpleContactProblem::OpCalContactAugmentedTractionOverSpatialMasterSlave::OpCalContactAugmentedTractionOverSpatialMasterSlave
OpCalContactAugmentedTractionOverSpatialMasterSlave(const string field_name, const string field_name_2, const double cn_value, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Definition: SimpleContact.hpp:1779
SimpleContactProblem::OpCalContactAugmentedTractionOverLambdaSlaveSlave::doWork
MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type, EntityType col_type, EntData &row_data, EntData &col_data)
Integrates virtual work on slave side , , derivative with respect to Lagrange multipliers on slave si...
Definition: SimpleContact.cpp:878
SimpleContactProblem::OpGetPositionAtGaussPtsMaster::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Definition: SimpleContact.cpp:453
SimpleContactProblem::OpContactMaterialLhs::rankRow
int rankRow
Definition: SimpleContact.hpp:512
SimpleContactProblem::OpGetContactArea::postProcSurface
Range postProcSurface
Definition: SimpleContact.hpp:3563
SimpleContactProblem::OpGetContactArea
Definition: SimpleContact.hpp:3543
SimpleContactProblem::OpCalDerIntCompFunOverSpatPosSlaveSlave::NN
MatrixDouble NN
Definition: SimpleContact.hpp:1564
SimpleContactProblem::OpLagGapProdGaussPtsSlave
Operator for the simple contact element.
Definition: SimpleContact.hpp:942
SimpleContactProblem::ConvectSlaveIntegrationPts::ConvectSlaveIntegrationPts
ConvectSlaveIntegrationPts(SimpleContactElement *const fe_ptr, string spat_pos, string mat_pos)
Definition: SimpleContact.hpp:140
SimpleContactProblem::CommonDataSimpleContact::lagMultAtGaussPtsPtr
boost::shared_ptr< VectorDouble > lagMultAtGaussPtsPtr
Definition: SimpleContact.hpp:413
SimpleContactProblem::OpLhsConvectIntegrationPtsContactTraction::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:2363
SimpleContactProblem::OpGetGapSlave
Operator for the simple contact element.
Definition: SimpleContact.hpp:863
MoFEM::CoreInterface::add_ents_to_finite_element_by_type
virtual MoFEMErrorCode add_ents_to_finite_element_by_type(const EntityHandle entities, const EntityType type, const std::string &name, const bool recursive=true)=0
add entities to finite element
SimpleContactProblem::ConvectMasterContactElement::setGaussPts
MoFEMErrorCode setGaussPts(int order)
Definition: SimpleContact.cpp:370
SimpleContactProblem::SimpleContactElement::getRule
int getRule(int order)
Definition: SimpleContact.hpp:119
SimpleContactProblem::OpGapConstraintAugmentedOverLambda
LHS-operator for the simple contact element.
Definition: SimpleContact.hpp:1987
SimpleContactProblem::OpGetLagMulAtGaussPtsSlave
Operator for the simple contact element.
Definition: SimpleContact.hpp:897
SimpleContactProblem::OpCalMatForcesALEMaster::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:2521
SimpleContactProblem::OpLagGapProdGaussPtsSlave::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:944
SimpleContactProblem::OpCalDerIntCompFunOverSpatPosSlaveMaster::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:1498
SimpleContactProblem::OpCalMatForcesALESlave::iNtegrate
MoFEMErrorCode iNtegrate(EntData &row_data)
Definition: SimpleContact.cpp:3272
SimpleContactProblem::OpLoopForSideOfContactPrism::sideFeName
string sideFeName
Definition: SimpleContact.hpp:2491
FEMethod
CHKERR
#define CHKERR
Inline error check.
Definition: definitions.h:535
SimpleContactProblem::OpGapConstraintAugmentedRhs::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Integrates KKT conditions for Augmented Lagrangian formulation at slave face gauss points and assembl...
Definition: SimpleContact.hpp:1264
SimpleContactProblem::OpCalculateGradPositionXi::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:2401
SimpleContactProblem::OpCalDerIntCompFunOverSpatPosSlaveSlave::OpCalDerIntCompFunOverSpatPosSlaveSlave
OpCalDerIntCompFunOverSpatPosSlaveSlave(const string lagrange_field_name, const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, boost::shared_ptr< double > cn)
Definition: SimpleContact.hpp:1514
SimpleContactProblem::OpCalIntCompFunSlave::vecR
VectorDouble vecR
Definition: SimpleContact.hpp:1202
SimpleContactProblem::OpMakeVtkSlave::postProcSurface
Range postProcSurface
Definition: SimpleContact.hpp:2192
MoFEM::CoreInterface::remove_ents_from_finite_element
virtual MoFEMErrorCode remove_ents_from_finite_element(const std::string name, const EntityHandle meshset, const EntityType type, int verb=DEFAULT_VERBOSITY)=0
remove entities from given refinement level to finite element database
SimpleContactProblem::OpContactMaterialVolOnSideLhs_dX_dx::iNtegrate
MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data)
Integrates over a face contribution from a side volume.
Definition: SimpleContact.cpp:3974
MoFEM::CoreInterface::add_finite_element
virtual MoFEMErrorCode add_finite_element(const std::string &fe_name, enum MoFEMTypes bh=MF_EXCL, int verb=DEFAULT_VERBOSITY)=0
add finite element
SimpleContactProblem::OpCalContactTractionOverLambdaSlaveSlave
LHS-operator for the simple contact element.
Definition: SimpleContact.hpp:1332
SimpleContactProblem::OpCalculateGradPositionXi::OpCalculateGradPositionXi
OpCalculateGradPositionXi(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Definition: SimpleContact.hpp:2392
SimpleContactProblem::OpGetMatPosForDisplAtGaussPtsMaster::OpGetMatPosForDisplAtGaussPtsMaster
OpGetMatPosForDisplAtGaussPtsMaster(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Definition: SimpleContact.hpp:776
SimpleContactProblem::ConvectSlaveIntegrationPts::getDiffKsiSpatialSlave
boost::shared_ptr< MatrixDouble > getDiffKsiSpatialSlave()
Definition: SimpleContact.hpp:152
SimpleContactProblem::OpCalDerIntCompFunOverLambdaSlaveSlave::doWork
MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type, EntityType col_type, EntData &row_data, EntData &col_data)
Integrates the complementarity function at slave face gauss points and assembles components to LHS gl...
Definition: SimpleContact.cpp:1992
ContactOp
SimpleContactProblem::OpCalMatForcesALEMaster::vecF
VectorDouble vecF
Definition: SimpleContact.hpp:2522
SimpleContactProblem::OpGetLagMulAtGaussPtsSlave::OpGetLagMulAtGaussPtsSlave
OpGetLagMulAtGaussPtsSlave(const string lagrange_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Definition: SimpleContact.hpp:900
SimpleContactProblem::ConvectMasterContactElement::ConvectMasterContactElement
ConvectMasterContactElement(MoFEM::Interface &m_field, string spat_pos, string mat_pos, bool newton_cotes=false)
Definition: SimpleContact.hpp:183
SimpleContactProblem::OpCalMatForcesALEMaster::aSsemble
MoFEMErrorCode aSsemble(EntData &row_data)
Definition: SimpleContact.cpp:3218
SimpleContactProblem::OpGetGaussPtsState::almFlag
const bool almFlag
Definition: SimpleContact.hpp:3539
SimpleContactProblem::SimpleContactProblem
SimpleContactProblem(MoFEM::Interface &m_field, boost::shared_ptr< double > cn_value, bool newton_cotes=false)
Definition: SimpleContact.hpp:487
MoFEM
implementation of Data Operators for Forces and Sources
Definition: Common.hpp:10
MoFEM::CoreInterface::modify_finite_element_add_field_col
virtual MoFEMErrorCode modify_finite_element_add_field_col(const std::string &fe_name, const std::string name_row)=0
set field col which finite element use
SimpleContactProblem::OpGetAugmentedLambdaSlave::OpGetAugmentedLambdaSlave
OpGetAugmentedLambdaSlave(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, const double cn)
Definition: SimpleContact.hpp:921
SimpleContactProblem::OpContactMaterialLhs::col_nb_dofs
int col_nb_dofs
Definition: SimpleContact.hpp:506
SimpleContactProblem::OpContactTractionMasterSlave_dX::iNtegrate
MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data)
Integrates Lagrange multipliers virtual work on master side, derivative with respect to material pos...
Definition: SimpleContact.cpp:3530
SimpleContactProblem::CommonDataSimpleContact::FMat
boost::shared_ptr< MatrixDouble > FMat
Definition: SimpleContact.hpp:426
SimpleContactProblem::OpGapConstraintAugmentedRhs
RHS-operator for the simple contact element for Augmented Lagrangian Method.
Definition: SimpleContact.hpp:1214
SimpleContactProblem::ConvectSlaveIntegrationPts::diffKsiSlave
MatrixDouble diffKsiSlave
Definition: SimpleContact.hpp:172
MoFEM::VolumeElementForcesAndSourcesCoreOnContactPrismSide
Base volume element used to integrate on contact surface (could be extended to other volume elements)
Definition: VolumeElementForcesAndSourcesCoreOnContactPrismSide.hpp:23
SimpleContactProblem::SimpleContactElement::postProcess
MoFEMErrorCode postProcess()
Definition: SimpleContact.hpp:97
SimpleContactProblem::OpCalDerIntCompFunOverLambdaSlaveSlave::NN
MatrixDouble NN
Definition: SimpleContact.hpp:1436
SimpleContactProblem::OpLhsConvectIntegrationPtsContactTraction::diffConvect
boost::shared_ptr< MatrixDouble > diffConvect
Definition: SimpleContact.hpp:2383
SimpleContactProblem::OpContactMaterialVolOnSideLhs::iNtegrate
virtual MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
Definition: SimpleContact.hpp:623
MoFEM::ForcesAndSourcesCore::UserDataOperator
Definition: ForcesAndSourcesCore.hpp:549
SimpleContactProblem::OpMakeTestTextFile::OpMakeTestTextFile
OpMakeTestTextFile(MoFEM::Interface &m_field, string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data, ofstream &_my_split)
Definition: SimpleContact.hpp:2213
SimpleContactProblem::OpLoopForSideOfContactPrism::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Definition: SimpleContact.cpp:3121
MOFEM_LOG_C
#define MOFEM_LOG_C(channel, severity, format,...)
Definition: LogManager.hpp:311
SimpleContactProblem::OpCalContactTractionOnMaster::vecF
VectorDouble vecF
Definition: SimpleContact.hpp:997
SimpleContactProblem::OpContactTractionSlaveSlave_dX::OpContactTractionSlaveSlave_dX
OpContactTractionSlaveSlave_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)
Definition: SimpleContact.hpp:3066
SimpleContactProblem::OpCalDerIntCompFunSlaveSlave_dX::iNtegrate
MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data)
Integrates linearisation of the complementarity function at slave face gauss points and assembles com...
Definition: SimpleContact.cpp:3716
convert.type
type
Definition: convert.py:64
SimpleContactProblem::OpCalContactTractionOverLambdaSlaveSlave::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:1373
SimpleContactProblem::OpCalIntCompFunSlave::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Integrates the complementarity function at slave face gauss points and assembles components to the RH...
Definition: SimpleContact.cpp:1643
SimpleContactProblem::OpMakeVtkSlave::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Definition: SimpleContact.cpp:2197
SimpleContactProblem::OpGetPositionAtGaussPtsSlave::OpGetPositionAtGaussPtsSlave
OpGetPositionAtGaussPtsSlave(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Definition: SimpleContact.hpp:812
SimpleContactProblem::OpCalContactAugmentedTractionOverLambdaMasterSlave::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:1629
SimpleContactProblem::OpContactMaterialMasterOnFaceLhs_dX_dX
LHS-operator for the contact element (material configuration)
Definition: SimpleContact.hpp:2739
SimpleContactProblem::CommonDataSimpleContact::forcesOnlyOnEntitiesCol
Range forcesOnlyOnEntitiesCol
Definition: SimpleContact.hpp:437
SimpleContactProblem::setContactOperatorsRhsALEMaterial
MoFEMErrorCode setContactOperatorsRhsALEMaterial(boost::shared_ptr< SimpleContactElement > fe_rhs_simple_contact_ale, boost::shared_ptr< CommonDataSimpleContact > common_data_simple_contact, const string field_name, const string mesh_node_field_name, const string lagrange_field_name, const string side_fe_name)
Function for the simple contact element that sets the user data post processing operators.
Definition: SimpleContact.cpp:4435
SimpleContactProblem::OpContactTractionMasterSlave_dX
LHS-operator for the simple contact element.
Definition: SimpleContact.hpp:3086
SimpleContactProblem::CommonDataSimpleContact::forcesOnlyOnEntitiesRow
Range forcesOnlyOnEntitiesRow
Definition: SimpleContact.hpp:436
SimpleContactProblem::OpGetDeformationFieldForDisplAtGaussPtsMaster::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:793
SimpleContactProblem::NO_TAG
@ NO_TAG
Definition: SimpleContact.hpp:2177
SimpleContactProblem::OpGetNormalMaster::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:709
SimpleContactProblem::OpCalContactAugmentedTractionOverSpatialSlaveMaster::OpCalContactAugmentedTractionOverSpatialSlaveMaster
OpCalContactAugmentedTractionOverSpatialSlaveMaster(const string field_name, const string field_name_2, const double cn_value, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Definition: SimpleContact.hpp:1920
SimpleContactProblem::OpCalDerIntCompFunOverSpatPosSlaveSlave::cNPtr
boost::shared_ptr< double > cNPtr
Definition: SimpleContact.hpp:1563
SimpleContactProblem::OpCalAugmentedTractionRhsSlave::OpCalAugmentedTractionRhsSlave
OpCalAugmentedTractionRhsSlave(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Definition: SimpleContact.hpp:1107
SimpleContactProblem::OpCalMatForcesALESlave::aSsemble
MoFEMErrorCode aSsemble(EntData &row_data)
Definition: SimpleContact.cpp:3309
SimpleContactProblem::OpCalculateGradLambdaXi::OpCalculateGradLambdaXi
OpCalculateGradLambdaXi(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Definition: SimpleContact.hpp:2410
SimpleContactProblem::OpMakeVtkSlave::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:2189
SimpleContactProblem::OpGetMatPosForDisplAtGaussPtsSlave::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Definition: SimpleContact.cpp:613
SimpleContactProblem::OpContactMaterialVolOnSideLhs::OpContactMaterialVolOnSideLhs
OpContactMaterialVolOnSideLhs(const string field_name_1, const string field_name_2, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, const bool is_master)
LHS-operator for the contact element (material configuration)
Definition: SimpleContact.hpp:644
SimpleContactProblem::addContactElementALE
MoFEMErrorCode addContactElementALE(const string element_name, const string field_name, const string mesh_node_field_name, const string lagrange_field_name, Range &range_slave_master_prisms, bool eigen_pos_flag=false, const string eigen_node_field_name="EIGEN_SPATIAL_POSITIONS")
Function that adds field data for spatial positions and Lagrange multipliers to rows and columns,...
Definition: SimpleContact.hpp:294
SimpleContactProblem::OpCalContactAugmentedTractionOverSpatialMasterMaster::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:1762
SimpleContactProblem::OpCalDerIntCompFunOverSpatPosSlaveMaster::doWork
MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type, EntityType col_type, EntData &row_data, EntData &col_data)
Integrates linearisation of the complementarity function at slave face gauss points and assembles com...
Definition: SimpleContact.cpp:2049
SimpleContactProblem::OpGetContactArea::cN
const double cN
Definition: SimpleContact.hpp:3560
SimpleContactProblem::OpGetPositionAtGaussPtsMaster
Operator for the simple contact element.
Definition: SimpleContact.hpp:755
SimpleContactProblem::OpGetDeformationFieldForDisplAtGaussPtsMaster::OpGetDeformationFieldForDisplAtGaussPtsMaster
OpGetDeformationFieldForDisplAtGaussPtsMaster(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Definition: SimpleContact.hpp:794
SimpleContactProblem::OpGetDeformationFieldForDisplAtGaussPtsSlave::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:847
SimpleContactProblem::OpMakeVtkSlave::moabOut
moab::Interface & moabOut
Definition: SimpleContact.hpp:2190
SimpleContactProblem::OpCalDerIntCompFunOverSpatPosSlaveSlave
LHS-operator for the simple contact element.
Definition: SimpleContact.hpp:1512
SimpleContactProblem::CommonDataSimpleContact::ACTIVE
@ ACTIVE
Definition: SimpleContact.hpp:438
SimpleContactProblem::OpContactMaterialLhs::iNtegrate
virtual MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data)
Definition: SimpleContact.hpp:519
SimpleContactProblem::OpGetContactArea::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:3559
SimpleContactProblem::ConvectSlaveIntegrationPts::slaveSpatialCoords
MatrixDouble slaveSpatialCoords
Definition: SimpleContact.hpp:164
SimpleContactProblem::SimpleContactElement::preProcess
MoFEMErrorCode preProcess()
Definition: SimpleContact.hpp:86
SimpleContactProblem::ConvectSlaveIntegrationPts::slaveN
MatrixDouble slaveN
Definition: SimpleContact.hpp:168
SimpleContactProblem::setMasterForceOperatorsRhs
MoFEMErrorCode setMasterForceOperatorsRhs(boost::shared_ptr< SimpleContactElement > fe_lhs_simple_contact, boost::shared_ptr< CommonDataSimpleContact > common_data_simple_contact, string field_name, string lagrange_field_name, bool is_alm=false, bool is_eigen_pos_field=false, string eigen_pos_field_name="EIGEN_SPATIAL_POSITIONS", bool use_reference_coordinates=false)
Definition: SimpleContact.cpp:2473
SimpleContactProblem::OpGetAugmentedLambdaSlave::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:931
SimpleContactProblem::OpCalAugmentedTractionRhsMaster
RHS-operator for the simple contact element.
Definition: SimpleContact.hpp:1051
SimpleContactProblem::OpMakeTestTextFile::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:2210
SimpleContactProblem::OpContactMaterialLhs::nb_base_fun_row
int nb_base_fun_row
Definition: SimpleContact.hpp:509
SimpleContactProblem::setContactOperatorsLhsALEMaterial
MoFEMErrorCode setContactOperatorsLhsALEMaterial(boost::shared_ptr< SimpleContactElement > fe_lhs_simple_contact_ale, boost::shared_ptr< CommonDataSimpleContact > common_data_simple_contact, const string field_name, const string mesh_node_field_name, const string lagrange_field_name, const string side_fe_name)
Function for the simple contact element that sets the user data LHS-operators.
Definition: SimpleContact.cpp:4512
SimpleContactProblem::setContactOperatorsLhs
MoFEMErrorCode setContactOperatorsLhs(boost::shared_ptr< SimpleContactElement > fe_lhs_simple_contact, boost::shared_ptr< CommonDataSimpleContact > common_data_simple_contact, string field_name, string lagrange_field_name, bool is_alm=false, bool is_eigen_pos_field=false, string eigen_pos_field_name="EIGEN_SPATIAL_POSITIONS", bool use_reference_coordinates=false)
Function for the simple contact element for C function or ALM approach that sets the user data LHS-op...
Definition: SimpleContact.cpp:2540
SimpleContactProblem::CommonDataSimpleContact
Definition: SimpleContact.hpp:404
SimpleContactProblem::OpCalContactAugmentedTractionOverSpatialSlaveSlave::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:1902
SimpleContactProblem::OpCalDerIntCompFunOverLambdaSlaveSlave
LHS-operator for the simple contact element.
Definition: SimpleContact.hpp:1386
SimpleContactProblem::ConvectSlaveIntegrationPts::spatialCoords
VectorDouble spatialCoords
Definition: SimpleContact.hpp:162
SimpleContactProblem::CommonDataSimpleContact::areaSlave
double areaSlave
Definition: SimpleContact.hpp:433
SimpleContactProblem::ConvectSlaveIntegrationPts
Class used to convect integration points on slave and master, and to calculate directional direvative...
Definition: SimpleContact.hpp:137
SimpleContactProblem::SimpleContactPrismsData::pRisms
Range pRisms
Definition: SimpleContact.hpp:68
MethodForForceScaling
Class used to scale loads, f.e. in arc-length control.
Definition: MethodForForceScaling.hpp:11
SimpleContactProblem
Set of functions declaring elements and setting operators to apply contact conditions between surface...
Definition: SimpleContact.hpp:27
SimpleContactProblem::newtonCotes
bool newtonCotes
Definition: SimpleContact.hpp:483
SimpleContactProblem::OpGetGapSlave::OpGetGapSlave
OpGetGapSlave(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Definition: SimpleContact.hpp:866
SimpleContactProblem::CommonDataSimpleContact::gradKsiPositionAtGaussPtsPtr
boost::shared_ptr< MatrixDouble > gradKsiPositionAtGaussPtsPtr
Definition: SimpleContact.hpp:410
SimpleContactProblem::ALM_TOL
static constexpr double ALM_TOL
Definition: SimpleContact.hpp:65
SimpleContactProblem::OpCalContactAugmentedTractionOverSpatialMasterSlave::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:1832
SimpleContactProblem::OpCalContactAugmentedTractionOverSpatialMasterSlave::cN
const double cN
Definition: SimpleContact.hpp:1833
SimpleContactProblem::OpGetGaussPtsState::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Definition: SimpleContact.cpp:3869
SimpleContactProblem::OpGetNormalMasterALE::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Evaluates unit normal vector to the master surface vector based on material base coordinates.
Definition: SimpleContact.cpp:3394
SimpleContactProblem::OpCalMatForcesALESlave::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Integrates virtual work of contact traction in the material configuration.
Definition: SimpleContact.cpp:3245
SimpleContactProblem::SimpleContactElement
Definition: SimpleContact.hpp:76
SimpleContactProblem::OpGetNormalSlave::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Evaluates unit normal vector to the slave surface vector based on reference base coordinates.
Definition: SimpleContact.cpp:384
SimpleContactProblem::OpGetDeformationFieldForDisplAtGaussPtsSlave::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Definition: SimpleContact.cpp:650
SimpleContactProblem::OpCalAugmentedTractionRhsMaster::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:1093
SimpleContactProblem::OpCalContactAugmentedTractionOverLambdaSlaveSlave::NN
MatrixDouble NN
Definition: SimpleContact.hpp:1694
SimpleContactProblem::OpGetPositionAtGaussPtsSlave
Operator for the simple contact element.
Definition: SimpleContact.hpp:809
SimpleContactProblem::OpContactTractionMasterMaster_dX::iNtegrate
MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data)
Integrates Lagrange multipliers virtual work on master side, derivative with respect to material pos...
Definition: SimpleContact.cpp:3621
SimpleContactProblem::OpGetLagMulAtGaussPtsSlave::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:899
SimpleContactProblem::ConvectMasterContactElement::getRule
int getRule(int order)
Definition: SimpleContact.hpp:192
SimpleContactProblem::OpGapConstraintAugmentedRhs::cN
const double cN
Definition: SimpleContact.hpp:1265
SimpleContactProblem::OpContactALELhs::col_nb_dofs
int col_nb_dofs
Definition: SimpleContact.hpp:556
SimpleContactProblem::OpGetGaussPtsState::OpGetGaussPtsState
OpGetGaussPtsState(const string lagrange_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, const double cn, const bool alm_flag=false)
Definition: SimpleContact.hpp:3525
SimpleContactProblem::OpContactMaterialVolOnSideLhs::rowIndices
VectorInt rowIndices
Definition: SimpleContact.hpp:602
SimpleContactProblem::OpCalContactAugmentedTractionOverSpatialMasterMaster
LHS-operator for the simple contact element with Augmented Lagrangian Method.
Definition: SimpleContact.hpp:1706
SimpleContactProblem::OpLhsConvectIntegrationPtsConstrainMasterGap::diffConvect
boost::shared_ptr< MatrixDouble > diffConvect
Definition: SimpleContact.hpp:2449
SimpleContactProblem::OpContactMaterialVolOnSideLhs::nb_base_fun_row
int nb_base_fun_row
Definition: SimpleContact.hpp:609
SimpleContactProblem::OpLhsConvectIntegrationPtsContactTraction::OpLhsConvectIntegrationPtsContactTraction
OpLhsConvectIntegrationPtsContactTraction(const string row_field_name, const string col_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, const ContactOp::FaceType face_type, boost::shared_ptr< MatrixDouble > diff_convect)
Definition: SimpleContact.hpp:2365
SimpleContactProblem::OpContactMaterialLhs::colIndices
VectorInt colIndices
Definition: SimpleContact.hpp:503
SimpleContactProblem::OpCalculateGradLambdaXi
Evaluate gradient of Lagrange multipliers on reference slave surface.
Definition: SimpleContact.hpp:2408
SimpleContactProblem::OpCalIntCompFunSlave::OpCalIntCompFunSlave
OpCalIntCompFunSlave(const string lagrange_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, boost::shared_ptr< double > cn)
Definition: SimpleContact.hpp:1162
SimpleContactProblem::OpLoopForSideOfContactPrism::OpLoopForSideOfContactPrism
OpLoopForSideOfContactPrism(const string field_name, boost::shared_ptr< VolumeElementForcesAndSourcesCoreOnContactPrismSide > side_fe, const string &side_fe_name, const ContactOp::FaceType face_type)
Operator that trigers the pipeline to loop over the side volume element operators that is adjacent to...
Definition: SimpleContact.hpp:2498
SimpleContactProblem::OpCalculateDeformation::OpCalculateDeformation
OpCalculateDeformation(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, bool ho_geometry=false)
Definition: SimpleContact.hpp:2465
SimpleContactProblem::OpCalMatForcesALEMaster::nbIntegrationPts
int nbIntegrationPts
number of integration points
Definition: SimpleContact.hpp:2519
SimpleContactProblem::OpGetMatPosForDisplAtGaussPtsSlave
Operator for the simple contact element.
Definition: SimpleContact.hpp:827
SimpleContactProblem::OpContactMaterialSlaveOnFaceLhs_dX_dX
LHS-operator for the contact element (material configuration)
Definition: SimpleContact.hpp:2802
SimpleContactProblem::SimpleContactElement::contactStateVec
SmartPetscObj< Vec > contactStateVec
Definition: SimpleContact.hpp:80
SimpleContactProblem::OpCalContactTractionOverLambdaMasterSlave::doWork
MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type, EntityType col_type, EntData &row_data, EntData &col_data)
Integrates Lagrange multipliers virtual work, derivative with respect to Lagrange multipliers with r...
Definition: SimpleContact.cpp:1738
SimpleContactProblem::OpGapConstraintAugmentedOverSpatialSlave::cN
const double cN
Definition: SimpleContact.hpp:2170
EntData
EntitiesFieldData::EntData EntData
Definition: child_and_parent.cpp:37
field_name
constexpr auto field_name
Definition: poisson_2d_homogeneous.cpp:13
SimpleContactProblem::OpGetDeformationFieldForDisplAtGaussPtsSlave
Operator for the simple contact element.
Definition: SimpleContact.hpp:845
SimpleContactProblem::OpCalDerIntCompFunOverSpatPosSlaveSlave::doWork
MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type, EntityType col_type, EntData &row_data, EntData &col_data)
Integrates linearisation of the complementarity function at slave face gauss points and assembles com...
Definition: SimpleContact.cpp:2127
SimpleContactProblem::OpGetAugmentedLambdaSlave
Operator for the simple contact element for Augmented Lagrangian Method.
Definition: SimpleContact.hpp:918
SimpleContactProblem::OpCalContactAugmentedTractionOverSpatialSlaveSlave::OpCalContactAugmentedTractionOverSpatialSlaveSlave
OpCalContactAugmentedTractionOverSpatialSlaveSlave(const string field_name, const string field_name_2, const double cn_value, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Definition: SimpleContact.hpp:1849
MoFEM::CoreInterface::get_finite_element_entities_by_handle
virtual MoFEMErrorCode get_finite_element_entities_by_handle(const std::string name, Range &ents) const =0
get entities in the finite element by handle
SimpleContactProblem::OpCalContactAugmentedTractionOverLambdaSlaveSlave::OpCalContactAugmentedTractionOverLambdaSlaveSlave
OpCalContactAugmentedTractionOverLambdaSlaveSlave(const string field_name, const string lagrange_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Definition: SimpleContact.hpp:1645
SimpleContactProblem::OpContactMaterialSlaveOnFaceLhs_dX_dX::iNtegrate
MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data)
Compute part of the left-hand side.
Definition: SimpleContact.cpp:4173
SimpleContactProblem::OpCalAugmentedTractionRhsSlave::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntitiesFieldData::EntData &data)
Integrates Lagrange multipliers virtual work on slave surface and assembles components to the RHS glo...
Definition: SimpleContact.cpp:1803
SimpleContactProblem::OpContactMaterialLhs::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:496
SimpleContactProblem::OpCalIntCompFunSlave::cNPtr
boost::shared_ptr< double > cNPtr
Definition: SimpleContact.hpp:1201
SimpleContactProblem::OpContactMaterialLhs::doWork
MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type, EntityType col_type, EntData &row_data, EntData &col_data)
Definition: SimpleContact.cpp:3811
SimpleContactProblem::OpCalMatForcesALEMaster::OpCalMatForcesALEMaster
OpCalMatForcesALEMaster(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Definition: SimpleContact.hpp:2569
SimpleContactProblem::ConvectMasterContactElement::convectPtr
boost::shared_ptr< ConvectSlaveIntegrationPts > convectPtr
Definition: SimpleContact.hpp:197
SimpleContactProblem::OpGetNormalSlave::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:666
SimpleContactProblem::OpLagGapProdGaussPtsSlave::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Definition: SimpleContact.cpp:1503
SimpleContactProblem::LoadScale
Definition: SimpleContact.hpp:35
SimpleContactProblem::OpMakeTestTextFile::mField
MoFEM::Interface & mField
Definition: SimpleContact.hpp:2209
SimpleContactProblem::CommonDataSimpleContact::positionAtGaussPtsMasterPtr
boost::shared_ptr< MatrixDouble > positionAtGaussPtsMasterPtr
Definition: SimpleContact.hpp:408
SimpleContactProblem::OpGetPositionAtGaussPtsSlave::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:811
SimpleContactProblem::SimpleContactElement::mField
MoFEM::Interface & mField
Definition: SimpleContact.hpp:78
SimpleContactProblem::POSITION_RANK
static constexpr int POSITION_RANK
Definition: SimpleContact.hpp:63
SimpleContactProblem::OpMakeVtkSlave::stateTagSide
StateTagSide stateTagSide
Definition: SimpleContact.hpp:2191
Range
SimpleContactProblem::OpLhsConvectIntegrationPtsConstrainMasterGap::cNPtr
boost::shared_ptr< double > cNPtr
Definition: SimpleContact.hpp:2448
SimpleContactProblem::OpContactMaterialVolOnSideLhs_dX_dx::OpContactMaterialVolOnSideLhs_dX_dx
OpContactMaterialVolOnSideLhs_dX_dx(const string field_name_1, const string field_name_2, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, const bool is_master)
Definition: SimpleContact.hpp:3379
SimpleContactProblem::OpCalContactAugmentedTractionOverLambdaSlaveSlave::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:1693
SimpleContactProblem::OpCalculateGradPositionXi
Evaluate gradient position on reference master surface.
Definition: SimpleContact.hpp:2390
SimpleContactProblem::ConvectSlaveIntegrationPts::masterMaterialCoords
MatrixDouble masterMaterialCoords
Definition: SimpleContact.hpp:167
SimpleContactProblem::LAGRANGE_RANK
static constexpr int LAGRANGE_RANK
Definition: SimpleContact.hpp:62
SimpleContactProblem::OpContactMaterialVolOnSideLhs::isMaster
bool isMaster
Definition: SimpleContact.hpp:659
MF_ZERO
@ MF_ZERO
Definition: definitions.h:98
SimpleContactProblem::OpContactALELhs::colIndices
VectorInt colIndices
Definition: SimpleContact.hpp:553
SimpleContactProblem::OpGetNormalMaster
Computes, for reference configuration, normal to master face that is common to all gauss points.
Definition: SimpleContact.hpp:707
SimpleContactProblem::OpGetGaussPtsState
Definition: SimpleContact.hpp:3523
SimpleContactProblem::OpCalContactTractionOnMaster::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:996
SimpleContactProblem::OpCalContactAugmentedTractionOverSpatialSlaveMaster::cN
const double cN
Definition: SimpleContact.hpp:1974
SimpleContactProblem::OpContactMaterialVolOnSideLhs::aRea
double aRea
Definition: SimpleContact.hpp:616
SimpleContactProblem::OpCalContactTractionOverLambdaSlaveSlave::OpCalContactTractionOverLambdaSlaveSlave
OpCalContactTractionOverLambdaSlaveSlave(const string field_name, const string lagrange_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Definition: SimpleContact.hpp:1334
SimpleContactProblem::ConvectMasterContactElement::getConvectPtr
boost::shared_ptr< ConvectSlaveIntegrationPts > getConvectPtr()
Definition: SimpleContact.hpp:188
SimpleContactProblem::OpGapConstraintAugmentedOverLambda::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:2038
SimpleContactProblem::OpContactMaterialLhs::row_nb_dofs
int row_nb_dofs
Definition: SimpleContact.hpp:505
SimpleContactProblem::OpCalDerIntCompFunOverLambdaSlaveSlave::OpCalDerIntCompFunOverLambdaSlaveSlave
OpCalDerIntCompFunOverLambdaSlaveSlave(const string lagrange_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, boost::shared_ptr< double > cn)
Definition: SimpleContact.hpp:1388
SimpleContactProblem::OpCalAugmentedTractionRhsMaster::vecF
VectorDouble vecF
Definition: SimpleContact.hpp:1094
SimpleContactProblem::ConvectSlaveIntegrationPts::masterSpatialCoords
MatrixDouble masterSpatialCoords
Definition: SimpleContact.hpp:166
SimpleContactProblem::OpContactALELhs::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:549
SimpleContactProblem::SimpleContactElement::setGaussPts
virtual MoFEMErrorCode setGaussPts(int order)
Definition: SimpleContact.cpp:29
SimpleContactProblem::OpCalContactTractionOverLambdaMasterSlave::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:1319
SimpleContactProblem::OpCalContactTractionOnSlave::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:1040
SimpleContactProblem::OpCalContactAugmentedTractionOverLambdaMasterSlave
LHS-operator for the simple contact element with Augmented Lagrangian Method.
Definition: SimpleContact.hpp:1577
SimpleContactProblem::CommonDataSimpleContact::TOTAL
@ TOTAL
Definition: SimpleContact.hpp:438
SimpleContactProblem::OpCalMatForcesALESlave::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:2588
SimpleContactProblem::OpContactMaterialLhs::sideFe
boost::shared_ptr< VolumeElementForcesAndSourcesCoreOnContactPrismSide > sideFe
Definition: SimpleContact.hpp:498
SimpleContactProblem::OpCalculateGradPositionXi::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Definition: SimpleContact.cpp:2954
UserDataOperator
ForcesAndSourcesCore::UserDataOperator UserDataOperator
Definition: HookeElement.hpp:75
SimpleContactProblem::addPostProcContactElement
MoFEMErrorCode addPostProcContactElement(const string element_name, const string spatial_field_name, const string lagrange_field_name, const string mesh_pos_field_name, Range &slave_tris)
Function that adds a new finite element for contact post-processing.
Definition: SimpleContact.hpp:361
MoFEM::Types::VectorInt
UBlasVector< int > VectorInt
Definition: Types.hpp:67
SimpleContactProblem::OpMakeVtkSlave
Operator for the simple contact element.
Definition: SimpleContact.hpp:2186
SimpleContactProblem::OpGetNormalSlaveALE::OpGetNormalSlaveALE
OpGetNormalSlaveALE(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Definition: SimpleContact.hpp:2648
SimpleContactProblem::TOL
static constexpr double TOL
Definition: SimpleContact.hpp:61
SimpleContactProblem::ConvectSlaveIntegrationPts::fePtr
SimpleContactElement *const fePtr
Definition: SimpleContact.hpp:157
SimpleContactProblem::OpContactMaterialMasterSlaveLhs_dX_dLagmult::OpContactMaterialMasterSlaveLhs_dX_dLagmult
OpContactMaterialMasterSlaveLhs_dX_dLagmult(const string mesh_nodes_field_row, const string lagrange_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, const int row_rank, const int col_rank)
Definition: SimpleContact.hpp:2924
SimpleContactProblem::CommonDataSimpleContact::gaussPtsStatePtr
boost::shared_ptr< VectorDouble > gaussPtsStatePtr
Definition: SimpleContact.hpp:431
SimpleContactProblem::OpContactMaterialMasterSlaveLhs_dX_dLagmult::iNtegrate
MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data)
Compute part of the left-hand side.
Definition: SimpleContact.cpp:4241
SimpleContactProblem::CommonDataSimpleContact::gradKsiLambdaAtGaussPtsPtr
boost::shared_ptr< MatrixDouble > gradKsiLambdaAtGaussPtsPtr
Definition: SimpleContact.hpp:411
SimpleContactProblem::OpGapConstraintAugmentedOverSpatialSlave::OpGapConstraintAugmentedOverSpatialSlave
OpGapConstraintAugmentedOverSpatialSlave(const string field_name, const string lagrange_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, const double cn)
Definition: SimpleContact.hpp:2118
SimpleContactProblem::ConvectMasterContactElement
Element used to integrate on slave surfaces. It convects integration points on slaves,...
Definition: SimpleContact.hpp:181
SimpleContactProblem::OpCalContactAugmentedTractionOverSpatialSlaveMaster::NN
MatrixDouble NN
Definition: SimpleContact.hpp:1975
SimpleContactProblem::OpContactMaterialLhs::matLhs
MatrixDouble matLhs
Definition: SimpleContact.hpp:501
SimpleContactProblem::OpLoopForSideOfContactPrism::faceType
const ContactOp::FaceType faceType
Definition: SimpleContact.hpp:2492
SimpleContactProblem::OpGetNormalSlaveALE::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Evaluates unit normal vector to the slave surface vector based on material base coordinates.
Definition: SimpleContact.cpp:3337
SimpleContactProblem::OpContactMaterialMasterSlaveLhs_dX_dLagmult
LHS-operator for the contact element (material configuration)
Definition: SimpleContact.hpp:2864
MoFEM::CoreInterface::modify_finite_element_add_field_data
virtual MoFEMErrorCode modify_finite_element_add_field_data(const std::string &fe_name, const std::string name_filed)=0
set finite element field data
SimpleContactProblem::CommonDataSimpleContact::contactAreaVec
SmartPetscObj< Vec > contactAreaVec
Definition: SimpleContact.hpp:441
SimpleContactProblem::OpCalculateGradLambdaXi::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Definition: SimpleContact.cpp:2841
SimpleContactProblem::OpCalDerIntCompFunOverLambdaSlaveSlave::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:1434
SimpleContactProblem::OpGetGapSlave::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:865
SimpleContactProblem::OpContactTractionSlaveSlave_dX::iNtegrate
MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data)
Integrates Lagrange multipliers virtual work, derivative with respect to material positions on slave...
Definition: SimpleContact.cpp:3450
MoFEM::Types::VectorDouble
UBlasVector< double > VectorDouble
Definition: Types.hpp:68
SimpleContactProblem::OpContactMaterialVolOnSideLhs::colIndices
VectorInt colIndices
Definition: SimpleContact.hpp:603
SimpleContactProblem::OpGetDeformationFieldForDisplAtGaussPtsMaster
Operator for the simple contact element.
Definition: SimpleContact.hpp:791
SimpleContactProblem::OpLhsConvectIntegrationPtsConstrainMasterGap::doWork
MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type, EntityType col_type, EntData &row_data, EntData &col_data)
Definition: SimpleContact.cpp:2987
SimpleContactProblem::OpGapConstraintAugmentedOverSpatialMaster::OpGapConstraintAugmentedOverSpatialMaster
OpGapConstraintAugmentedOverSpatialMaster(const string field_name, const string lagrange_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, const double cn)
Definition: SimpleContact.hpp:2053
SimpleContactProblem::OpGetContactArea::vecR
VectorDouble vecR
Definition: SimpleContact.hpp:3562
SimpleContactProblem::OpCalAugmentedTractionRhsSlave
RHS-operator for the simple contact element.
Definition: SimpleContact.hpp:1104
SimpleContactProblem::OpGapConstraintAugmentedOverLambda::cN
const double cN
Definition: SimpleContact.hpp:2039
SimpleContactProblem::setMasterForceOperatorsLhs
MoFEMErrorCode setMasterForceOperatorsLhs(boost::shared_ptr< SimpleContactElement > fe_lhs_simple_contact, boost::shared_ptr< CommonDataSimpleContact > common_data_simple_contact, string field_name, string lagrange_field_name, bool is_alm=false, bool is_eigen_pos_field=false, string eigen_pos_field_name="EIGEN_SPATIAL_POSITIONS", bool use_reference_coordinates=false)
Definition: SimpleContact.cpp:2640
SimpleContactProblem::OpGapConstraintAugmentedRhs::OpGapConstraintAugmentedRhs
OpGapConstraintAugmentedRhs(const string lagrange_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, const double cn)
Definition: SimpleContact.hpp:1217
SimpleContactProblem::ConvectSlaveIntegrationPts::materialPositionsField
const string materialPositionsField
Definition: SimpleContact.hpp:160
SimpleContactProblem::OpCalculateDeformation::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:2460
SimpleContactProblem::CommonDataSimpleContact::tangentOneVectorMasterPtr
boost::shared_ptr< VectorDouble > tangentOneVectorMasterPtr
Definition: SimpleContact.hpp:419
SimpleContactProblem::ConvectSlaveIntegrationPts::materialCoords
VectorDouble materialCoords
Definition: SimpleContact.hpp:163
SimpleContactProblem::ConvectSlaveContactElement::getRule
int getRule(int order)
Definition: SimpleContact.hpp:209
SimpleContactProblem::OpContactALELhs::rankRow
int rankRow
Definition: SimpleContact.hpp:562
SimpleContactProblem::OpGetAugmentedLambdaSlave::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Definition: SimpleContact.cpp:763
SimpleContactProblem::OpGetAugmentedLambdaSlave::cN
const double cN
Definition: SimpleContact.hpp:932
SimpleContactProblem::OpContactALELhs::nb_gauss_pts
int nb_gauss_pts
Definition: SimpleContact.hpp:557
SimpleContactProblem::OpGetNormalMasterALE
Computes, for material configuration, normal to master face that is common to all gauss points.
Definition: SimpleContact.hpp:2689
SimpleContactProblem::OpContactALELhs::nb_base_fun_row
int nb_base_fun_row
Definition: SimpleContact.hpp:559
SimpleContactProblem::OpContactTractionMasterMaster_dX::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)
Definition: SimpleContact.hpp:3216
SimpleContactProblem::OpLhsConvectIntegrationPtsContactTraction::doWork
MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type, EntityType col_type, EntData &row_data, EntData &col_data)
Definition: SimpleContact.cpp:2873
SimpleContactProblem::CommonDataSimpleContact::CommonDataSimpleContact
CommonDataSimpleContact(MoFEM::Interface &m_field)
Definition: SimpleContact.hpp:443
SimpleContactProblem::setContactOperatorsForPostProc
MoFEMErrorCode setContactOperatorsForPostProc(boost::shared_ptr< SimpleContactElement > fe_post_proc_simple_contact, boost::shared_ptr< CommonDataSimpleContact > common_data_simple_contact, MoFEM::Interface &m_field, string field_name, string lagrange_field_name, moab::Interface &moab_out, bool alm_flag=false, bool is_eigen_pos_field=false, string eigen_pos_field_name="EIGEN_SPATIAL_POSITIONS", bool use_reference_coordinates=false, StateTagSide state_tag_side=NO_TAG)
Function for the simple contact element that sets the user data post processing operators.
Definition: SimpleContact.cpp:2772
SimpleContactProblem::ConvectSlaveContactElement::setGaussPts
MoFEMErrorCode setGaussPts(int order)
Definition: SimpleContact.cpp:378
SimpleContactProblem::CommonDataSimpleContact::tangentTwoVectorSlavePtr
boost::shared_ptr< VectorDouble > tangentTwoVectorSlavePtr
Definition: SimpleContact.hpp:418
SimpleContactProblem::setOfSimpleContactPrism
map< int, SimpleContactPrismsData > setOfSimpleContactPrism
maps side set id with appropriate FluxData
Definition: SimpleContact.hpp:72
SimpleContactProblem::OpContactMaterialMasterOnFaceLhs_dX_dX::OpContactMaterialMasterOnFaceLhs_dX_dX
OpContactMaterialMasterOnFaceLhs_dX_dX(const string mesh_nodes_field_row, const string mesh_nodes_field_col, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, const int row_rank, const int col_rank)
Definition: SimpleContact.hpp:2782
SimpleContactProblem::OpCalIntCompFunSlave
RHS-operator for the simple contact element.
Definition: SimpleContact.hpp:1160
SimpleContactProblem::OpLoopForSideOfContactPrism::sideFe
boost::shared_ptr< VolumeElementForcesAndSourcesCoreOnContactPrismSide > sideFe
Definition: SimpleContact.hpp:2490
SimpleContactProblem::OpCalContactAugmentedTractionOverSpatialSlaveSlave
LHS-operator for the simple contact element with Augmented Lagrangian Method.
Definition: SimpleContact.hpp:1846
SimpleContactProblem::CommonDataSimpleContact::tangentOneVectorSlavePtr
boost::shared_ptr< VectorDouble > tangentOneVectorSlavePtr
Definition: SimpleContact.hpp:417
SimpleContactProblem::OpContactMaterialVolOnSideLhs::nb_base_fun_col
int nb_base_fun_col
Definition: SimpleContact.hpp:610
SimpleContactProblem::SLAVE_SIDE
@ SLAVE_SIDE
Definition: SimpleContact.hpp:2177
SimpleContactProblem::OpLhsConvectIntegrationPtsConstrainMasterGap::OpLhsConvectIntegrationPtsConstrainMasterGap
OpLhsConvectIntegrationPtsConstrainMasterGap(const string lagrange_field_name, const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, boost::shared_ptr< double > cn, const ContactOp::FaceType face_type, boost::shared_ptr< MatrixDouble > diff_convect)
Definition: SimpleContact.hpp:2429
SimpleContactProblem::CommonDataSimpleContact::augmentedLambdasPtr
boost::shared_ptr< VectorDouble > augmentedLambdasPtr
Definition: SimpleContact.hpp:407
SimpleContactProblem::OpLhsConvectIntegrationPtsConstrainMasterGap
Tangent opeerator for contrains equation for change of spatial positions on master and slave.
Definition: SimpleContact.hpp:2427
SimpleContactProblem::OpCalContactAugmentedTractionOverSpatialMasterMaster::cN
const double cN
Definition: SimpleContact.hpp:1763
SimpleContactProblem::OpCalContactAugmentedTractionOverSpatialMasterSlave::doWork
MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type, EntityType col_type, EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
Integrates virtual work on master side , derivative with respect to spatial positions on slave side ...
Definition: SimpleContact.cpp:1253
SimpleContactProblem::OpCalContactTractionOverLambdaMasterSlave::OpCalContactTractionOverLambdaMasterSlave
OpCalContactTractionOverLambdaMasterSlave(const string field_name, const string lagrange_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Definition: SimpleContact.hpp:1279
SimpleContactProblem::OpGetPositionAtGaussPtsMaster::OpGetPositionAtGaussPtsMaster
OpGetPositionAtGaussPtsMaster(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Definition: SimpleContact.hpp:758
SimpleContactProblem::State
static bool State(const double cn, const double g, const double l)
Definition: SimpleContact.hpp:3577
SimpleContactProblem::CommonDataSimpleContact::VecElements
VecElements
Definition: SimpleContact.hpp:438
MoFEMFunctionReturn
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:416
SimpleContactProblem::OpCalContactAugmentedTractionOverLambdaMasterSlave::doWork
MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type, EntityType col_type, EntData &row_data, EntData &col_data)
Integrates virtual work on master side , , derivative with respect to Lagrange multipliers on slave s...
Definition: SimpleContact.cpp:804
SimpleContactProblem::OpContactMaterialLhs::sideFeName
string sideFeName
Definition: SimpleContact.hpp:499
SimpleContactProblem::OpCalculateDeformation::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Definition: SimpleContact.cpp:3081
SimpleContactProblem::OpContactMaterialLhs::nb_gauss_pts
int nb_gauss_pts
Definition: SimpleContact.hpp:507
SimpleContactProblem::OpGetMatPosForDisplAtGaussPtsMaster::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Definition: SimpleContact.cpp:497
SimpleContactProblem::OpGetNormalSlaveALE::commonDataSimpleContact
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Definition: SimpleContact.hpp:2647
SimpleContactProblem::ConstrainFunction
static double ConstrainFunction(const double cn, const double g, const double l)
Definition: SimpleContact.hpp:3587
SimpleContactProblem::OpCalContactTractionOverLambdaMasterSlave
LHS-operator for the simple contact element.
Definition: SimpleContact.hpp:1277
SimpleContactProblem::OpContactMaterialSlaveSlaveLhs_dX_dLagmult::iNtegrate
MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data)
Compute part of the left-hand side.
Definition: SimpleContact.cpp:4299
SimpleContactProblem::OpCalContactTractionOnMaster::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Integrates Lagrange multipliers virtual work on master surface and assembles to global RHS vector.
Definition: SimpleContact.cpp:1535
SimpleContactProblem::CommonDataSimpleContact::normalVectorMasterPtr
boost::shared_ptr< VectorDouble > normalVectorMasterPtr
Definition: SimpleContact.hpp:423
SimpleContactProblem::MASTER_SIDE
@ MASTER_SIDE
Definition: SimpleContact.hpp:2177
MoFEMFunctionBegin
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:346
l
FTensor::Index< 'l', 3 > l
Definition: matrix_function.cpp:21
SimpleContactProblem::CommonDataSimpleContact::LAST_ELEMENT
@ LAST_ELEMENT
Definition: SimpleContact.hpp:438
SimpleContactProblem::SimpleContactElement::newtonCotes
bool newtonCotes
Definition: SimpleContact.hpp:79
SimpleContactProblem::OpCalMatForcesALESlave::OpCalMatForcesALESlave
OpCalMatForcesALESlave(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Definition: SimpleContact.hpp:2636
SimpleContactProblem::OpContactMaterialVolOnSideLhs
Operator used as base struct for OpContactMaterialVolOnSideLhs_dX_dx OpContactMaterialVolOnSideLhs_dX...
Definition: SimpleContact.hpp:594
SimpleContactProblem::OpContactTractionMasterMaster_dX
LHS-operator for the simple contact element.
Definition: SimpleContact.hpp:3168
SimpleContactProblem::OpCalContactAugmentedTractionOverSpatialMasterSlave::NN
MatrixDouble NN
Definition: SimpleContact.hpp:1834
SimpleContactProblem::OpContactALELhs
Operator used as base struct for OpContactTractionSlaveSlave_dX, OpContactTractionMasterSlave_dX,...
Definition: SimpleContact.hpp:547
SimpleContactProblem::OpCalContactTractionOnSlave::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Integrates Lagrange multipliers virtual work on slave surface and assembles components to the RHS glo...
Definition: SimpleContact.cpp:1589
SimpleContactProblem::OpGetNormalMasterALE::OpGetNormalMasterALE
OpGetNormalMasterALE(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Definition: SimpleContact.hpp:2692
SimpleContactProblem::OpCalAugmentedTractionRhsMaster::doWork
MoFEMErrorCode doWork(int side, EntityType type, EntitiesFieldData::EntData &data)
Integrates Lagrange multipliers virtual work on slave surface and assembles components to the RHS glo...
Definition: SimpleContact.cpp:1862
SimpleContactProblem::OpGapConstraintAugmentedOverLambda::NN
MatrixDouble NN
Definition: SimpleContact.hpp:2040
SimpleContactProblem::CommonDataSimpleContact::positionAtGaussPtsSlavePtr
boost::shared_ptr< MatrixDouble > positionAtGaussPtsSlavePtr
Definition: SimpleContact.hpp:409
SimpleContactProblem::CommonDataSimpleContact::lagGapProdPtr
boost::shared_ptr< VectorDouble > lagGapProdPtr
Definition: SimpleContact.hpp:415
SimpleContactProblem::OpCalMatForcesALEMaster
RHS - operator for the contact element (material configuration) Integrates virtual work of contact tr...
Definition: SimpleContact.hpp:2514
SimpleContactProblem::OpMakeVtkSlave::mField
MoFEM::Interface & mField
Definition: SimpleContact.hpp:2188
SimpleContactProblem::OpContactALELhs::OpContactALELhs
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)
Definition: SimpleContact.hpp:576
SimpleContactProblem::OpContactMaterialVolOnSideLhs::matLhs
MatrixDouble matLhs
Definition: SimpleContact.hpp:598