v0.14.0
Loading...
Searching...
No Matches
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;
30 using ContactOp = ContactPrismElementForcesAndSourcesCore::UserDataOperator;
31 using EntData = EntitiesFieldData::EntData;
33 FaceElementForcesAndSourcesCore::UserDataOperator;
34
36
37 static double lAmbda;
38
39 MoFEMErrorCode scaleNf(const FEMethod *fe, VectorDouble &nf) {
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
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),
85
86 MoFEMErrorCode preProcess() {
88 if (snes_ctx == CTX_SNESSETFUNCTION && contactStateVec) {
89 CHKERR VecAssemblyBegin(contactStateVec);
90 CHKERR VecAssemblyEnd(contactStateVec);
91
92 CHKERR VecZeroEntries(contactStateVec);
93 }
95 }
96
97 MoFEMErrorCode postProcess() {
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(),
150 }
151
152 inline boost::shared_ptr<MatrixDouble> getDiffKsiSpatialSlave() {
153 return boost::shared_ptr<MatrixDouble>(shared_from_this(), &diffKsiSlave);
154 }
155
156 private:
158
161
162 VectorDouble spatialCoords;
163 VectorDouble materialCoords;
164 MatrixDouble slaveSpatialCoords;
168 MatrixDouble slaveN;
169 MatrixDouble masterN;
170
171 MatrixDouble diffKsiMaster;
172 MatrixDouble diffKsiSlave;
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
194 MoFEMErrorCode setGaussPts(int order);
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
211 MoFEMErrorCode setGaussPts(int order);
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 */
231 MoFEMErrorCode addContactElement(
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
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 */
294 MoFEMErrorCode addContactElementALE(
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
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);
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
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;
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;
472 gaussPtsStateVec = createSmartVectorMPI(
474 contactAreaVec = createSmartVectorMPI(
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
495
496 boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
497 boost::shared_ptr<VolumeElementForcesAndSourcesCoreOnContactPrismSide>
500
501 MatrixDouble matLhs;
502 VectorInt rowIndices;
503 VectorInt colIndices;
504
508
511
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
551 MatrixDouble matLhs;
552 VectorInt rowIndices;
553 VectorInt colIndices;
554
558
561
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
598 MatrixDouble matLhs;
599
600 boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
601
602 VectorInt rowIndices;
603 VectorInt colIndices;
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
623 iNtegrate(EntitiesFieldData::EntData &row_data,
624 EntitiesFieldData::EntData &col_data) {
627 }
628
629 MoFEMErrorCode aSsemble(EntitiesFieldData::EntData &row_data,
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:
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 */
919 : public ContactPrismElementForcesAndSourcesCore::UserDataOperator {
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;
997 VectorDouble vecF;
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;
1041 VectorDouble vecF;
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 */
1052 : public ContactPrismElementForcesAndSourcesCore::UserDataOperator {
1053
1055 const string field_name,
1056 boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
1057 : ContactPrismElementForcesAndSourcesCore::UserDataOperator(
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,
1090 EntitiesFieldData::EntData &data);
1091
1092 private:
1093 boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
1094 VectorDouble vecF;
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 */
1105 : public ContactPrismElementForcesAndSourcesCore::UserDataOperator {
1106
1108 const string field_name,
1109 boost::shared_ptr<CommonDataSimpleContact> common_data_contact)
1110 : ContactPrismElementForcesAndSourcesCore::UserDataOperator(
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,
1145 EntitiesFieldData::EntData &data);
1146
1147 private:
1148 boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
1149 VectorDouble vecF;
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;
1202 VectorDouble vecR;
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 */
1215 : public ContactPrismElementForcesAndSourcesCore::UserDataOperator {
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;
1266 VectorDouble vecR;
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;
1320 MatrixDouble NN;
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;
1374 MatrixDouble NN;
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;
1436 MatrixDouble NN;
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;
1500 MatrixDouble NN;
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;
1564 MatrixDouble NN;
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 */
1578 : public ContactPrismElementForcesAndSourcesCore::UserDataOperator {
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;
1630 MatrixDouble NN;
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 */
1643 : public ContactPrismElementForcesAndSourcesCore::UserDataOperator {
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;
1694 MatrixDouble NN;
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 */
1707 : public ContactPrismElementForcesAndSourcesCore::UserDataOperator {
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;
1764 MatrixDouble NN;
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 */
1777 : public ContactPrismElementForcesAndSourcesCore::UserDataOperator {
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;
1834 MatrixDouble NN;
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 */
1847 : public ContactPrismElementForcesAndSourcesCore::UserDataOperator {
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;
1904 MatrixDouble NN;
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 */
1918 : public ContactPrismElementForcesAndSourcesCore::UserDataOperator {
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;
1975 MatrixDouble NN;
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;
2040 MatrixDouble NN;
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;
2105 MatrixDouble NN;
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;
2171 MatrixDouble NN;
2172 };
2173
2174 /**
2175 * \brief Choice of the contact prism side to put the state tag on
2176 */
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;
2190 moab::Interface &moabOut;
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
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 */
2246 MoFEMErrorCode setContactOperatorsRhs(
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 */
2276 MoFEMErrorCode setContactOperatorsLhs(
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 */
2291 MoFEMErrorCode setContactOperatorsLhs(
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
2299 MoFEMErrorCode setMasterForceOperatorsRhs(
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
2307 MoFEMErrorCode setMasterForceOperatorsLhs(
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
2315 MoFEMErrorCode setMasterForceOperatorsLhs(
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 */
2346 MoFEMErrorCode setContactOperatorsForPostProc(
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:
2382 MatrixDouble matLhs;
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:
2446 MatrixDouble matLhs;
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(
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>
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
2516 VectorInt rowIndices;
2517
2518 int nbRows; ///< number of dofs on rows
2519 int nbIntegrationPts; ///< number of integration points
2520
2521 boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
2522 VectorDouble vecF;
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
2583 VectorInt rowIndices;
2584
2585 int nbRows; ///< number of dofs on rows
2586 int nbIntegrationPts; ///< number of integration points
2587
2588 boost::shared_ptr<CommonDataSimpleContact> commonDataSimpleContact;
2589 VectorDouble vecF;
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
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 */
3425 MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data,
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 */
3470 MoFEMErrorCode setContactOperatorsRhsALEMaterial(
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 */
3494 MoFEMErrorCode setContactOperatorsLhsALEMaterial(
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 */
3516 MoFEMErrorCode setContactOperatorsLhsALE(
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
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;
3540 VectorDouble vecR;
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;
3562 VectorDouble vecR;
3565 };
3566};
3567
3569 if (x == 0)
3570 return 0;
3571 else if (x > 0)
3572 return 1;
3573 else
3574 return -1;
3575};
3576
3577bool SimpleContactProblem::State(const double cn, const double g,
3578 const double l) {
3579 return ((cn * g) <= l);
3580}
3581
3582bool 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
3587double 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
ForcesAndSourcesCore::UserDataOperator UserDataOperator
#define MOFEM_LOG_C(channel, severity, format,...)
Definition: LogManager.hpp:311
@ MF_ZERO
Definition: definitions.h:98
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:447
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:346
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:416
#define CHKERR
Inline error check.
Definition: definitions.h:535
constexpr int order
virtual MoFEMErrorCode add_finite_element(const std::string &fe_name, enum MoFEMTypes bh=MF_EXCL, int verb=DEFAULT_VERBOSITY)=0
add finite element
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
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
virtual MoFEMErrorCode modify_finite_element_add_field_data(const std::string &fe_name, const std::string name_filed)=0
set finite element field data
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
virtual MoFEMErrorCode get_finite_element_entities_by_handle(const std::string name, Range &ents) const =0
get entities in the finite element by handle
FTensor::Index< 'l', 3 > l
implementation of Data Operators for Forces and Sources
Definition: Common.hpp:10
constexpr auto field_name
constexpr double g
Class used to scale loads, f.e. in arc-length control.
virtual MPI_Comm & get_comm() const =0
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
virtual int get_comm_rank() const =0
Deprecated interface functions.
Data on single entity (This is passed as argument to DataOperator::doWork)
Base volume element used to integrate on contact surface (could be extended to other volume elements)...
boost::shared_ptr< MatrixDouble > hMat
boost::shared_ptr< VectorDouble > normalVectorSlavePtr
boost::shared_ptr< MatrixDouble > FMat
boost::shared_ptr< MatrixDouble > HMat
boost::shared_ptr< VectorDouble > lagMultAtGaussPtsPtr
boost::shared_ptr< VectorDouble > lagGapProdPtr
boost::shared_ptr< MatrixDouble > gradKsiLambdaAtGaussPtsPtr
boost::shared_ptr< VectorDouble > detHVec
boost::shared_ptr< VectorDouble > augmentedLambdasPtr
boost::shared_ptr< MatrixDouble > gradKsiPositionAtGaussPtsPtr
boost::shared_ptr< VectorDouble > gaussPtsStatePtr
boost::shared_ptr< VectorDouble > tangentOneVectorMasterPtr
CommonDataSimpleContact(MoFEM::Interface &m_field)
boost::shared_ptr< MatrixDouble > positionAtGaussPtsSlavePtr
boost::shared_ptr< VectorDouble > normalVectorMasterPtr
boost::shared_ptr< MatrixDouble > positionAtGaussPtsMasterPtr
boost::shared_ptr< VectorDouble > gapPtr
boost::shared_ptr< VectorDouble > tangentTwoVectorSlavePtr
boost::shared_ptr< VectorDouble > tangentOneVectorSlavePtr
boost::shared_ptr< MatrixDouble > invHMat
boost::shared_ptr< VectorDouble > tangentTwoVectorMasterPtr
Element used to integrate on slave surfaces. It convects integration points on slaves,...
ConvectMasterContactElement(MoFEM::Interface &m_field, string spat_pos, string mat_pos, bool newton_cotes=false)
boost::shared_ptr< ConvectSlaveIntegrationPts > getConvectPtr()
boost::shared_ptr< ConvectSlaveIntegrationPts > convectPtr
Element used to integrate on master surfaces. It convects integration points on slaves,...
Class used to convect integration points on slave and master, and to calculate directional direvative...
boost::shared_ptr< MatrixDouble > getDiffKsiSpatialSlave()
boost::shared_ptr< MatrixDouble > getDiffKsiSpatialMaster()
ConvectSlaveIntegrationPts(SimpleContactElement *const fe_ptr, string spat_pos, string mat_pos)
MoFEMErrorCode scaleNf(const FEMethod *fe, VectorDouble &nf)
RHS-operator for the simple contact element.
MoFEMErrorCode doWork(int side, EntityType type, EntitiesFieldData::EntData &data)
Integrates Lagrange multipliers virtual work on slave surface and assembles components to the RHS glo...
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
OpCalAugmentedTractionRhsMaster(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
RHS-operator for the simple contact element.
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
MoFEMErrorCode doWork(int side, EntityType type, EntitiesFieldData::EntData &data)
Integrates Lagrange multipliers virtual work on slave surface and assembles components to the RHS glo...
OpCalAugmentedTractionRhsSlave(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
LHS-operator for the simple contact element with Augmented Lagrangian Method.
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...
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
OpCalContactAugmentedTractionOverLambdaMasterSlave(const string field_name, const string lagrange_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
LHS-operator for the simple contact element with Augmented Lagrangian Method.
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...
OpCalContactAugmentedTractionOverLambdaSlaveSlave(const string field_name, const string lagrange_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
LHS-operator for the simple contact element with Augmented Lagrangian Method.
OpCalContactAugmentedTractionOverSpatialMasterMaster(const string field_name, const string field_name_2, const double cn_value, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
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...
LHS-operator for the simple contact element with Augmented Lagrangian Method.
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 ...
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
OpCalContactAugmentedTractionOverSpatialMasterSlave(const string field_name, const string field_name_2, const double cn_value, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
LHS-operator for the simple contact element with Augmented Lagrangian Method.
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 ...
OpCalContactAugmentedTractionOverSpatialSlaveMaster(const string field_name, const string field_name_2, const double cn_value, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
LHS-operator for the simple contact element with Augmented Lagrangian Method.
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
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...
OpCalContactAugmentedTractionOverSpatialSlaveSlave(const string field_name, const string field_name_2, const double cn_value, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
RHS-operator for the simple contact element.
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Integrates Lagrange multipliers virtual work on master surface and assembles to global RHS vector.
OpCalContactTractionOnMaster(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
RHS-operator for the simple contact element.
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Integrates Lagrange multipliers virtual work on slave surface and assembles components to the RHS glo...
OpCalContactTractionOnSlave(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
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...
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
OpCalContactTractionOverLambdaMasterSlave(const string field_name, const string lagrange_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
LHS-operator for the simple contact element.
OpCalContactTractionOverLambdaSlaveSlave(const string field_name, const string lagrange_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
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...
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
LHS-operator for the simple contact element.
OpCalDerIntCompFunOverLambdaSlaveSlave(const string lagrange_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, boost::shared_ptr< double > cn)
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...
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
LHS-operator for the simple contact element.
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
OpCalDerIntCompFunOverSpatPosSlaveMaster(const string lagrange_field_name, const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, boost::shared_ptr< double > cn)
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...
LHS-operator for the simple contact element.
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
OpCalDerIntCompFunOverSpatPosSlaveSlave(const string lagrange_field_name, const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, boost::shared_ptr< double > cn)
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...
LHS-operator for the simple contact element.
MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data)
Integrates linearisation of the complementarity function at slave face gauss points and assembles com...
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)
RHS-operator for the simple contact element.
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
OpCalIntCompFunSlave(const string lagrange_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, boost::shared_ptr< double > cn)
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Integrates the complementarity function at slave face gauss points and assembles components to the RH...
RHS - operator for the contact element (material configuration) Integrates virtual work of contact tr...
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Integrates virtual work of contact traction in the material configuration.
int nbIntegrationPts
number of integration points
MoFEMErrorCode iNtegrate(EntData &row_data)
OpCalMatForcesALEMaster(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
MoFEMErrorCode aSsemble(EntData &row_data)
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
RHS - operator for the contact element (material configuration) Integrates virtual work of contact tr...
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
int nbIntegrationPts
number of integration points
Operator for computing deformation gradients in side volumes.
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
OpCalculateDeformation(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, bool ho_geometry=false)
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Evaluate gradient of Lagrange multipliers on reference slave surface.
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
OpCalculateGradLambdaXi(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Evaluate gradient position on reference master surface.
OpCalculateGradPositionXi(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Operator used as base struct for OpContactTractionSlaveSlave_dX, OpContactTractionMasterSlave_dX,...
virtual MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data)
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type, EntityType col_type, EntData &row_data, EntData &col_data)
MoFEMErrorCode aSsemble(EntData &row_data, EntData &col_data)
OpContactALELhs(const string field_name_1, const string field_name_2, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, const ContactOp::FaceType face_type, const int rank_row, const int rank_col)
MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type, EntityType col_type, EntData &row_data, EntData &col_data)
MoFEMErrorCode aSsemble(EntData &row_data, EntData &col_data)
boost::shared_ptr< VolumeElementForcesAndSourcesCoreOnContactPrismSide > sideFe
virtual MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data)
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="")
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
LHS-operator for the contact element (material configuration)
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)
MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data)
Compute part of the left-hand side.
LHS-operator for the contact element (material configuration)
MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data)
Compute part of the left-hand side.
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)
LHS-operator for the contact element (material configuration)
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)
MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data)
Compute part of the left-hand side.
LHS-operator for the contact element (material configuration)
MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data)
Compute part of the left-hand side.
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)
LHS-operator for the contact element (material configuration)
MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
Compute part of the left-hand side.
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)
LHS-operator (material configuration) on the side volume of either master or slave side.
MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data)
Integrates over a face contribution from a side volume.
OpContactMaterialVolOnSideLhs_dX_dx(const string field_name_1, const string field_name_2, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, const bool is_master)
Operator used as base struct for OpContactMaterialVolOnSideLhs_dX_dx OpContactMaterialVolOnSideLhs_dX...
boost::shared_ptr< VectorDouble > normalVector
MoFEMErrorCode aSsemble(EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
boost::shared_ptr< VectorDouble > tangentOne
MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type, EntityType col_type, EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
virtual MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
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)
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
boost::shared_ptr< VectorDouble > tangentTwo
LHS-operator for the simple contact element.
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)
MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data)
Integrates Lagrange multipliers virtual work on master side, derivative with respect to material pos...
LHS-operator for the simple contact element.
MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data)
Integrates Lagrange multipliers virtual work on master side, derivative with respect to material pos...
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)
LHS-operator for the simple contact element.
MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data)
Integrates Lagrange multipliers virtual work, derivative with respect to material positions on slave...
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)
LHS-operator for the simple contact element.
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
OpGapConstraintAugmentedOverLambda(const string lagrange_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, const double cn)
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...
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...
OpGapConstraintAugmentedOverSpatialMaster(const string field_name, const string lagrange_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, const double cn)
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
LHS-operator for the simple contact element.
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
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...
OpGapConstraintAugmentedOverSpatialSlave(const string field_name, const string lagrange_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, const double cn)
RHS-operator for the simple contact element for Augmented Lagrangian Method.
OpGapConstraintAugmentedRhs(const string lagrange_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, const double cn)
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Integrates KKT conditions for Augmented Lagrangian formulation at slave face gauss points and assembl...
Operator for the simple contact element for Augmented Lagrangian Method.
OpGetAugmentedLambdaSlave(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, const double cn)
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
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.)
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
OpGetDeformationFieldForDisplAtGaussPtsMaster(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
OpGetDeformationFieldForDisplAtGaussPtsSlave(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Operator for the simple contact element.
OpGetGapSlave(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Evaluates gap function at slave face gauss points.
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
OpGetGaussPtsState(const string lagrange_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact, const double cn, const bool alm_flag=false)
Operator for the simple contact element.
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
OpGetLagMulAtGaussPtsSlave(const string lagrange_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Operator for the simple contact element.
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
OpGetMatPosForDisplAtGaussPtsMaster(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Operator for the simple contact element.
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
OpGetMatPosForDisplAtGaussPtsSlave(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Evaluates unit normal vector to the master surface vector based on material base coordinates.
OpGetNormalMasterALE(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Computes, for reference configuration, normal to master face that is common to all gauss points.
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Evaluates unit normal vector to the master surface vector based on reference base coordinates.
OpGetNormalMaster(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Evaluates unit normal vector to the slave surface vector based on material base coordinates.
OpGetNormalSlaveALE(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Computes, for reference configuration, normal to slave face that is common to all gauss points.
OpGetNormalSlave(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Evaluates unit normal vector to the slave surface vector based on reference base coordinates.
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Operator for the simple contact element.
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
OpGetPositionAtGaussPtsMaster(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Operator for the simple contact element.
OpGetPositionAtGaussPtsSlave(const string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Operator for the simple contact element.
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
OpLagGapProdGaussPtsSlave(const string lagrange_field_name, boost::shared_ptr< CommonDataSimpleContact > common_data_contact)
Tangent opeerator for contrains equation for change of spatial positions on master and slave.
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)
MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type, EntityType col_type, EntData &row_data, EntData &col_data)
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Calculate tangent operator for contact force for change of integration point positions,...
MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type, EntityType col_type, EntData &row_data, EntData &col_data)
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
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)
Trigers operators for side volume element on slave side for evaluation of the RHS contact traction in...
boost::shared_ptr< VolumeElementForcesAndSourcesCoreOnContactPrismSide > sideFe
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...
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
OpMakeTestTextFile(MoFEM::Interface &m_field, string field_name, boost::shared_ptr< CommonDataSimpleContact > common_data, ofstream &_my_split)
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
Operator for the simple contact element.
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())
boost::shared_ptr< CommonDataSimpleContact > commonDataSimpleContact
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
virtual MoFEMErrorCode setGaussPts(int order)
SimpleContactElement(MoFEM::Interface &m_field, bool newton_cotes=false)
Set of functions declaring elements and setting operators to apply contact conditions between surface...
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...
MoFEM::Interface & mField
static double ConstrainFunction_dg(const double cn, const double g, const double l)
static constexpr int POSITION_RANK
SimpleContactProblem(MoFEM::Interface &m_field, boost::shared_ptr< double > cn_value, bool newton_cotes=false)
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.
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...
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)
static double Sign(double x)
static double ConstrainFunction(const double cn, const double g, const double l)
static constexpr double TOL
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.
StateTagSide
Choice of the contact prism side to put the state tag on.
static constexpr double ALM_TOL
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.
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.
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,...
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)
map< int, SimpleContactPrismsData > setOfSimpleContactPrism
maps side set id with appropriate FluxData
ContactPrismElementForcesAndSourcesCore::UserDataOperator ContactOp
static double ConstrainFunction_dl(const double cn, const double g, const double l)
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.
static constexpr int LAGRANGE_RANK
boost::shared_ptr< double > cnValuePtr
static bool StateALM(const double cn, const double g, const double l)
static bool State(const double cn, const double g, const double l)
FaceElementForcesAndSourcesCore::UserDataOperator FaceUserDataOperator
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,...