v0.14.0
Public Member Functions | Private Attributes | List of all members
ContactOps::Monitor Struct Reference

#include <users_modules/tutorials/adv-1/src/PostProcContact.hpp>

Inheritance diagram for ContactOps::Monitor:
[legend]
Collaboration diagram for ContactOps::Monitor:
[legend]

Public Member Functions

 Monitor (SmartPetscObj< DM > &dm, boost::shared_ptr< GenericElementInterface > mfront_interface=nullptr, bool is_axisymmetric=false)
 
MoFEMErrorCode preProcess ()
 
MoFEMErrorCode operator() ()
 
MoFEMErrorCode postProcess ()
 
MoFEMErrorCode setScatterVectors (std::tuple< SmartPetscObj< Vec >, SmartPetscObj< VecScatter >> ux_scatter, std::tuple< SmartPetscObj< Vec >, SmartPetscObj< VecScatter >> uy_scatter, std::tuple< SmartPetscObj< Vec >, SmartPetscObj< VecScatter >> uz_scatter)
 

Private Attributes

SmartPetscObj< DM > dM
 
std::tuple< SmartPetscObj< Vec >, SmartPetscObj< VecScatter > > uXScatter
 
std::tuple< SmartPetscObj< Vec >, SmartPetscObj< VecScatter > > uYScatter
 
std::tuple< SmartPetscObj< Vec >, SmartPetscObj< VecScatter > > uZScatter
 
boost::shared_ptr< moab::Core > postProcMesh = boost::make_shared<moab::Core>()
 
boost::shared_ptr< PostProcEleDomain > postProcDomainFe
 
boost::shared_ptr< PostProcEleBdy > postProcBdyFe
 
boost::shared_ptr< BoundaryEle > integrateTraction
 
moab::Core mbVertexPostproc
 
moab::Interface & moabVertex
 
double lastTime
 
double deltaTime
 
int sTEP
 
boost::shared_ptr< GenericElementInterface > mfrontInterface
 

Detailed Description

Definition at line 28 of file PostProcContact.hpp.

Constructor & Destructor Documentation

◆ Monitor()

ContactOps::Monitor::Monitor ( SmartPetscObj< DM > &  dm,
boost::shared_ptr< GenericElementInterface >  mfront_interface = nullptr,
bool  is_axisymmetric = false 
)
inline

Definition at line 30 of file PostProcContact.hpp.

33  : dM(dm), moabVertex(mbVertexPostproc), sTEP(0),
34  mfrontInterface(mfront_interface) {
35 
36  MoFEM::Interface *m_field_ptr;
37  CHKERR DMoFEMGetInterfacePtr(dM, &m_field_ptr);
38 
39  using OpPPMap = OpPostProcMapInMoab<SPACE_DIM, SPACE_DIM>;
40 
41  struct OpScale : public ForcesAndSourcesCore::UserDataOperator {
42  OpScale(boost::shared_ptr<MatrixDouble> m_ptr, double s)
43  : ForcesAndSourcesCore::UserDataOperator(NOSPACE, OPSPACE),
44  mPtr(m_ptr), scale(s) {}
45  MoFEMErrorCode doWork(int, EntityType, EntitiesFieldData::EntData &) {
46  *mPtr *= 1./scale;
47  return 0;
48  }
49 
50  private:
51  boost::shared_ptr<MatrixDouble> mPtr;
52  double scale;
53  };
54 
55  auto push_domain_ops = [&](auto &pip) {
56  CHK_THROW_MESSAGE((AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(
57  pip, {H1, HDIV}, "GEOMETRY")),
58  "Apply base transform");
59  auto henky_common_data_ptr =
60  commonDataFactory<SPACE_DIM, GAUSS, DomainEleOp>(
61  *m_field_ptr, pip, "U", "MAT_ELASTIC", Sev::inform);
62  auto contact_stress_ptr = boost::make_shared<MatrixDouble>();
63  pip.push_back(new OpCalculateHVecTensorField<SPACE_DIM, SPACE_DIM>(
64  "SIGMA", contact_stress_ptr));
65  pip.push_back(new OpScale(contact_stress_ptr, scale));
66  return std::make_tuple(henky_common_data_ptr, contact_stress_ptr);
67  };
68 
69  auto push_bdy_ops = [&](auto &pip) {
70  // evaluate traction
71  auto common_data_ptr = boost::make_shared<ContactOps::CommonData>();
72  pip.push_back(new OpCalculateVectorFieldValues<SPACE_DIM>(
73  "U", common_data_ptr->contactDispPtr()));
74  pip.push_back(new OpCalculateHVecTensorTrace<SPACE_DIM, BoundaryEleOp>(
75  "SIGMA", common_data_ptr->contactTractionPtr()));
76  pip.push_back(new OpScale(common_data_ptr->contactTractionPtr(), scale));
77  using C = ContactIntegrators<BoundaryEleOp>;
78  pip.push_back(new typename C::template OpEvaluateSDF<SPACE_DIM, GAUSS>(
79  common_data_ptr));
80  return common_data_ptr;
81  };
82 
83  auto get_domain_pip = [&](auto &pip)
84  -> boost::ptr_deque<ForcesAndSourcesCore::UserDataOperator> & {
85  if constexpr (SPACE_DIM == 3) {
86  auto op_loop_side = new OpLoopSide<SideEle>(
87  *m_field_ptr, "dFE", SPACE_DIM, Sev::noisy,
88  boost::make_shared<
89  ForcesAndSourcesCore::UserDataOperator::AdjCache>());
90  pip.push_back(op_loop_side);
91  return op_loop_side->getOpPtrVector();
92  } else {
93  return pip;
94  }
95  };
96 
97  auto get_post_proc_domain_fe = [&]() {
98  auto post_proc_fe =
99  boost::make_shared<PostProcEleDomain>(*m_field_ptr, postProcMesh);
100  auto &pip = post_proc_fe->getOpPtrVector();
101 
102  auto [henky_common_data_ptr, contact_stress_ptr] =
103  push_domain_ops(get_domain_pip(pip));
104 
105  auto u_ptr = boost::make_shared<MatrixDouble>();
106  pip.push_back(new OpCalculateVectorFieldValues<SPACE_DIM>("U", u_ptr));
107  auto X_ptr = boost::make_shared<MatrixDouble>();
108  pip.push_back(
109  new OpCalculateVectorFieldValues<SPACE_DIM>("GEOMETRY", X_ptr));
110 
111 
112 
113  pip.push_back(
114 
115  new OpPPMap(
116 
117  post_proc_fe->getPostProcMesh(), post_proc_fe->getMapGaussPts(),
118 
119  {},
120  {
121 
122  {"U", u_ptr}, {"GEOMETRY", X_ptr}
123 
124  },
125  {
126 
127  {"SIGMA", contact_stress_ptr},
128 
129  {"G", henky_common_data_ptr->matGradPtr},
130 
131  {"P2", henky_common_data_ptr->getMatFirstPiolaStress()}
132 
133  },
134  {}
135 
136  )
137 
138  );
139 
140  if (SPACE_DIM == 3) {
141 
142  CHK_THROW_MESSAGE((AddHOOps<SPACE_DIM - 1, SPACE_DIM, SPACE_DIM>::add(
143  pip, {HDIV}, "GEOMETRY")),
144  "Apply transform");
145  auto common_data_ptr = push_bdy_ops(pip);
146 
147  pip.push_back(
148 
149  new OpPPMap(
150 
151  post_proc_fe->getPostProcMesh(), post_proc_fe->getMapGaussPts(),
152 
153  {{"SDF", common_data_ptr->sdfPtr()},
154  {"CONSTRAINT_CONTACT", common_data_ptr->constraintPtr()}},
155 
156  {
157 
158  {"TRACTION_CONTACT", common_data_ptr->contactTractionPtr()},
159  {"GRAD_SDF", common_data_ptr->gradSdfPtr()}
160 
161  },
162 
163  {},
164 
165  {{"HESS_SDF", common_data_ptr->hessSdfPtr()}}
166 
167  )
168 
169  );
170  }
171 
172  return post_proc_fe;
173  };
174 
175  auto get_post_proc_bdy_fe = [&]() {
176  auto post_proc_fe =
177  boost::make_shared<PostProcEleBdy>(*m_field_ptr, postProcMesh);
178  auto &pip = post_proc_fe->getOpPtrVector();
179 
180  CHK_THROW_MESSAGE((AddHOOps<SPACE_DIM - 1, SPACE_DIM, SPACE_DIM>::add(
181  pip, {HDIV}, "GEOMETRY")),
182  "Apply transform");
183  auto common_data_ptr = push_bdy_ops(pip);
184 
185  // create OP which run element on side
186  auto op_loop_side = new OpLoopSide<SideEle>(
187  *m_field_ptr, "dFE", SPACE_DIM, Sev::noisy,
188  boost::make_shared<
189  ForcesAndSourcesCore::UserDataOperator::AdjCache>());
190  pip.push_back(op_loop_side);
191 
192  auto [henky_common_data_ptr, contact_stress_ptr] =
193  push_domain_ops(op_loop_side->getOpPtrVector());
194 
195  auto X_ptr = boost::make_shared<MatrixDouble>();
196  pip.push_back(
197  new OpCalculateVectorFieldValues<SPACE_DIM>("GEOMETRY", X_ptr));
198 
199  pip.push_back(
200 
201  new OpPPMap(
202 
203  post_proc_fe->getPostProcMesh(), post_proc_fe->getMapGaussPts(),
204 
205  {{"SDF", common_data_ptr->sdfPtr()},
206  {"CONSTRAINT_CONTACT", common_data_ptr->constraintPtr()}},
207 
208  {{"U", common_data_ptr->contactDispPtr()},
209  {"GEOMETRY", X_ptr},
210  {"TRACTION_CONTACT", common_data_ptr->contactTractionPtr()},
211  {"GRAD_SDF", common_data_ptr->gradSdfPtr()}
212 
213  },
214 
215  {},
216 
217  {{"HESS_SDF", common_data_ptr->hessSdfPtr()}}
218 
219  )
220 
221  );
222 
223  return post_proc_fe;
224  };
225 
226  auto get_integrate_traction = [&]() {
227  auto integrate_traction = boost::make_shared<BoundaryEle>(*m_field_ptr);
228  auto common_data_ptr = boost::make_shared<ContactOps::CommonData>();
229  CHK_THROW_MESSAGE(
230  (AddHOOps<SPACE_DIM - 1, SPACE_DIM, SPACE_DIM>::add(
231  integrate_traction->getOpPtrVector(), {HDIV}, "GEOMETRY")),
232  "Apply transform");
233  // We have to integrate on curved face geometry, thus integration weight
234  // have to adjusted.
235  integrate_traction->getOpPtrVector().push_back(
236  new OpSetHOWeightsOnSubDim<SPACE_DIM>());
237  integrate_traction->getRuleHook = [](int, int, int approx_order) {
238  return 2 * approx_order + geom_order - 1;
239  };
240 
241  CHK_THROW_MESSAGE(
242  (opFactoryCalculateTraction<SPACE_DIM, GAUSS, BoundaryEleOp>(
243  integrate_traction->getOpPtrVector(), "SIGMA", is_axisymmetric)),
244  "push operators to calculate traction");
245 
246  return integrate_traction;
247  };
248 
249  postProcDomainFe = get_post_proc_domain_fe();
250  if constexpr (SPACE_DIM == 2)
251  postProcBdyFe = get_post_proc_bdy_fe();
252  integrateTraction = get_integrate_traction();
253  }

Member Function Documentation

◆ operator()()

MoFEMErrorCode ContactOps::Monitor::operator() ( )
inline

Definition at line 256 of file PostProcContact.hpp.

256 { return 0; }

◆ postProcess()

MoFEMErrorCode ContactOps::Monitor::postProcess ( )
inline

Definition at line 258 of file PostProcContact.hpp.

258  {
259  MoFEMFunctionBegin;
260  MoFEM::Interface *m_field_ptr;
261  CHKERR DMoFEMGetInterfacePtr(dM, &m_field_ptr);
262 
263  auto post_proc = [&]() {
264  MoFEMFunctionBegin;
265 
266  if (!mfrontInterface) {
267  auto post_proc_begin =
268  boost::make_shared<PostProcBrokenMeshInMoabBaseBegin>(*m_field_ptr,
269  postProcMesh);
270  auto post_proc_end =
271  boost::make_shared<PostProcBrokenMeshInMoabBaseEnd>(*m_field_ptr,
272  postProcMesh);
273 
274  CHKERR DMoFEMPreProcessFiniteElements(dM,
275  post_proc_begin->getFEMethod());
276  if (!postProcBdyFe) {
277  postProcDomainFe->copyTs(*this); // this here is a Monitor
278  CHKERR DMoFEMLoopFiniteElements(dM, "bFE", postProcDomainFe);
279  } else {
280  postProcDomainFe->copyTs(*this); // this here is a Monitor
281  postProcBdyFe->copyTs(*this);
282  CHKERR DMoFEMLoopFiniteElements(dM, "dFE", postProcDomainFe);
283  CHKERR DMoFEMLoopFiniteElements(dM, "bFE", postProcBdyFe);
284  }
285  CHKERR DMoFEMPostProcessFiniteElements(dM,
286  post_proc_end->getFEMethod());
287 
288  CHKERR post_proc_end->writeFile(
289  "out_contact_" + boost::lexical_cast<std::string>(sTEP) + ".h5m");
290  } else {
291  CHKERR mfrontInterface->updateElementVariables();
292  CHKERR mfrontInterface->postProcessElement(ts_step);
293  }
294 
295  MoFEMFunctionReturn(0);
296  };
297 
298  auto calculate_traction = [&] {
299  MoFEMFunctionBegin;
300  CHKERR VecZeroEntries(CommonData::totalTraction);
301  CHKERR DMoFEMLoopFiniteElements(dM, "bFE", integrateTraction);
302  CHKERR VecAssemblyBegin(CommonData::totalTraction);
303  CHKERR VecAssemblyEnd(CommonData::totalTraction);
304  MoFEMFunctionReturn(0);
305  };
306 
307  auto calculate_reactions = [&]() {
308  MoFEMFunctionBegin;
309 
310  auto res = createDMVector(dM);
311 
312  auto assemble_domain = [&]() {
313  MoFEMFunctionBegin;
314  auto fe_rhs = boost::make_shared<DomainEle>(*m_field_ptr);
315  auto &pip = fe_rhs->getOpPtrVector();
316  fe_rhs->f = res;
317 
318  auto integration_rule = [](int, int, int approx_order) {
319  return 2 * approx_order + geom_order - 1;
320  };
321  fe_rhs->getRuleHook = integration_rule;
322 
323  CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(pip, {H1},
324  "GEOMETRY");
325  CHKERR HenckyOps::opFactoryDomainRhs<SPACE_DIM, PETSC, IT, DomainEleOp>(
326  *m_field_ptr, pip, "U", "MAT_ELASTIC", Sev::inform);
327  CHKERR DMoFEMLoopFiniteElements(dM, "dFE", fe_rhs);
328  MoFEMFunctionReturn(0);
329  };
330 
331  auto assemble_boundary = [&]() {
332  MoFEMFunctionBegin;
333  auto fe_rhs = boost::make_shared<BoundaryEle>(*m_field_ptr);
334  auto &pip = fe_rhs->getOpPtrVector();
335  fe_rhs->f = res;
336 
337  auto integration_rule = [](int, int, int approx_order) {
338  return 2 * approx_order + geom_order - 1;
339  };
340  fe_rhs->getRuleHook = integration_rule;
341 
342  CHKERR AddHOOps<SPACE_DIM - 1, SPACE_DIM, SPACE_DIM>::add(pip, {},
343  "GEOMETRY");
344  // We have to integrate on curved face geometry, thus integration weight
345  // have to adjusted.
346  pip.push_back(new OpSetHOWeightsOnSubDim<SPACE_DIM>());
347 
348  auto u_disp = boost::make_shared<MatrixDouble>();
349  pip.push_back(new OpCalculateVectorFieldValues<SPACE_DIM>("U", u_disp));
350  pip.push_back(
351  new OpSpringRhs("U", u_disp, [this](double, double, double) {
352  return spring_stiffness;
353  }));
354 
355  CHKERR DMoFEMLoopFiniteElements(dM, "bFE", fe_rhs);
356 
357  MoFEMFunctionReturn(0);
358  };
359 
360  CHKERR assemble_domain();
361  CHKERR assemble_boundary();
362 
363  auto fe_post_proc_ptr = boost::make_shared<FEMethod>();
364  auto get_post_proc_hook_rhs = [this, fe_post_proc_ptr, res,
365  m_field_ptr]() {
366  MoFEMFunctionBegin;
367  CHKERR EssentialPreProcReaction<DisplacementCubitBcData>(
368  *m_field_ptr, fe_post_proc_ptr, res)();
369  MoFEMFunctionReturn(0);
370  };
371  fe_post_proc_ptr->postProcessHook = get_post_proc_hook_rhs;
372  CHKERR DMoFEMPostProcessFiniteElements(dM, fe_post_proc_ptr.get());
373 
374  MoFEMFunctionReturn(0);
375  };
376 
377  auto print_max_min = [&](auto &tuple, const std::string msg) {
378  MoFEMFunctionBegin;
379  CHKERR VecScatterBegin(std::get<1>(tuple), ts_u, std::get<0>(tuple),
380  INSERT_VALUES, SCATTER_FORWARD);
381  CHKERR VecScatterEnd(std::get<1>(tuple), ts_u, std::get<0>(tuple),
382  INSERT_VALUES, SCATTER_FORWARD);
383  double max, min;
384  CHKERR VecMax(std::get<0>(tuple), PETSC_NULL, &max);
385  CHKERR VecMin(std::get<0>(tuple), PETSC_NULL, &min);
386  MOFEM_LOG_C("CONTACT", Sev::inform, "%s time %3.4e min %3.4e max %3.4e",
387  msg.c_str(), ts_t, min, max);
388  MoFEMFunctionReturn(0);
389  };
390 
391  auto print_traction = [&](const std::string msg) {
392  MoFEMFunctionBegin;
393  MoFEM::Interface *m_field_ptr;
394  CHKERR DMoFEMGetInterfacePtr(dM, &m_field_ptr);
395  if (!m_field_ptr->get_comm_rank()) {
396  const double *t_ptr;
397  CHKERR VecGetArrayRead(CommonData::totalTraction, &t_ptr);
398  MOFEM_LOG_C("CONTACT", Sev::inform, "%s time %3.4e %3.4e %3.4e %3.4e",
399  msg.c_str(), ts_t, t_ptr[0], t_ptr[1], t_ptr[2]);
400  CHKERR VecRestoreArrayRead(CommonData::totalTraction, &t_ptr);
401  }
402  MoFEMFunctionReturn(0);
403  };
404 
405  int se = 1;
406  CHKERR PetscOptionsGetInt(PETSC_NULL, "", "-save_every", &se, PETSC_NULL);
407 
408  if (!(ts_step % se)) {
409  MOFEM_LOG("CONTACT", Sev::inform)
410  << "Write file at time " << ts_t << " write step " << sTEP;
411  CHKERR post_proc();
412  }
413  CHKERR calculate_traction();
414  CHKERR calculate_reactions();
415 
416  CHKERR print_max_min(uXScatter, "Ux");
417  CHKERR print_max_min(uYScatter, "Uy");
418  if (SPACE_DIM == 3)
419  CHKERR print_max_min(uZScatter, "Uz");
420  CHKERR print_traction("Contact force");
421 
422  ++sTEP;
423 
424  MoFEMFunctionReturn(0);
425  }

◆ preProcess()

MoFEMErrorCode ContactOps::Monitor::preProcess ( )
inline

Definition at line 255 of file PostProcContact.hpp.

255 { return 0; }

◆ setScatterVectors()

MoFEMErrorCode ContactOps::Monitor::setScatterVectors ( std::tuple< SmartPetscObj< Vec >, SmartPetscObj< VecScatter >>  ux_scatter,
std::tuple< SmartPetscObj< Vec >, SmartPetscObj< VecScatter >>  uy_scatter,
std::tuple< SmartPetscObj< Vec >, SmartPetscObj< VecScatter >>  uz_scatter 
)
inline

Definition at line 427 of file PostProcContact.hpp.

430  {
431  MoFEMFunctionBegin;
432  uXScatter = ux_scatter;
433  uYScatter = uy_scatter;
434  uZScatter = uz_scatter;
435  MoFEMFunctionReturn(0);
436  }

Member Data Documentation

◆ deltaTime

double ContactOps::Monitor::deltaTime
private

Definition at line 455 of file PostProcContact.hpp.

◆ dM

SmartPetscObj<DM> ContactOps::Monitor::dM
private

Definition at line 439 of file PostProcContact.hpp.

◆ integrateTraction

boost::shared_ptr<BoundaryEle> ContactOps::Monitor::integrateTraction
private

Definition at line 449 of file PostProcContact.hpp.

◆ lastTime

double ContactOps::Monitor::lastTime
private

Definition at line 454 of file PostProcContact.hpp.

◆ mbVertexPostproc

moab::Core ContactOps::Monitor::mbVertexPostproc
private

Definition at line 451 of file PostProcContact.hpp.

◆ mfrontInterface

boost::shared_ptr<GenericElementInterface> ContactOps::Monitor::mfrontInterface
private

Definition at line 458 of file PostProcContact.hpp.

◆ moabVertex

moab::Interface& ContactOps::Monitor::moabVertex
private

Definition at line 452 of file PostProcContact.hpp.

◆ postProcBdyFe

boost::shared_ptr<PostProcEleBdy> ContactOps::Monitor::postProcBdyFe
private

Definition at line 447 of file PostProcContact.hpp.

◆ postProcDomainFe

boost::shared_ptr<PostProcEleDomain> ContactOps::Monitor::postProcDomainFe
private

Definition at line 446 of file PostProcContact.hpp.

◆ postProcMesh

boost::shared_ptr<moab::Core> ContactOps::Monitor::postProcMesh = boost::make_shared<moab::Core>()
private

Definition at line 444 of file PostProcContact.hpp.

◆ sTEP

int ContactOps::Monitor::sTEP
private

Definition at line 456 of file PostProcContact.hpp.

◆ uXScatter

std::tuple<SmartPetscObj<Vec>, SmartPetscObj<VecScatter> > ContactOps::Monitor::uXScatter
private

Definition at line 440 of file PostProcContact.hpp.

◆ uYScatter

std::tuple<SmartPetscObj<Vec>, SmartPetscObj<VecScatter> > ContactOps::Monitor::uYScatter
private

Definition at line 441 of file PostProcContact.hpp.

◆ uZScatter

std::tuple<SmartPetscObj<Vec>, SmartPetscObj<VecScatter> > ContactOps::Monitor::uZScatter
private

Definition at line 442 of file PostProcContact.hpp.

The documentation for this struct was generated from the following file:
NOSPACE
@ NOSPACE
Definition: definitions.h:83
ContactOps::Monitor::postProcBdyFe
boost::shared_ptr< PostProcEleBdy > postProcBdyFe
Definition: PostProcContact.hpp:447
spring_stiffness
double spring_stiffness
Definition: contact.cpp:131
H1
@ H1
continuous field
Definition: definitions.h:85
is_axisymmetric
PetscBool is_axisymmetric
Definition: contact.cpp:137
CHK_THROW_MESSAGE
#define CHK_THROW_MESSAGE(err, msg)
Check and throw MoFEM exception.
Definition: definitions.h:596
MoFEM::Exceptions::MoFEMErrorCode
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
Definition: Exceptions.hpp:56
ContactOps::Monitor::mfrontInterface
boost::shared_ptr< GenericElementInterface > mfrontInterface
Definition: PostProcContact.hpp:458
MoFEM::CoreInterface::get_comm_rank
virtual int get_comm_rank() const =0
ContactOps::Monitor::sTEP
int sTEP
Definition: PostProcContact.hpp:456
ContactOps::Monitor::postProcMesh
boost::shared_ptr< moab::Core > postProcMesh
Definition: PostProcContact.hpp:444
ContactOps::Monitor::uXScatter
std::tuple< SmartPetscObj< Vec >, SmartPetscObj< VecScatter > > uXScatter
Definition: PostProcContact.hpp:440
geom_order
int geom_order
Order if fixed.
Definition: plastic.cpp:188
MoFEM::DeprecatedCoreInterface
Deprecated interface functions.
Definition: DeprecatedCoreInterface.hpp:16
ContactOps::Monitor::mbVertexPostproc
moab::Core mbVertexPostproc
Definition: PostProcContact.hpp:451
approx_order
static constexpr int approx_order
Definition: prism_polynomial_approximation.cpp:14
ContactOps::Monitor::moabVertex
moab::Interface & moabVertex
Definition: PostProcContact.hpp:452
CHKERR
#define CHKERR
Inline error check.
Definition: definitions.h:535
ContactOps::scale
double scale
Definition: EshelbianContact.hpp:22
ContactOps::Monitor::uZScatter
std::tuple< SmartPetscObj< Vec >, SmartPetscObj< VecScatter > > uZScatter
Definition: PostProcContact.hpp:442
MoFEM::createDMVector
auto createDMVector(DM dm)
Get smart vector from DM.
Definition: DMMoFEM.hpp:1018
SPACE_DIM
constexpr int SPACE_DIM
Definition: child_and_parent.cpp:16
ContactOps::Monitor::dM
SmartPetscObj< DM > dM
Definition: PostProcContact.hpp:439
ContactOps::CommonData::totalTraction
static SmartPetscObj< Vec > totalTraction
Definition: ContactOps.hpp:28
MoFEM::ForcesAndSourcesCore::UserDataOperator
Definition: ForcesAndSourcesCore.hpp:549
MOFEM_LOG_C
#define MOFEM_LOG_C(channel, severity, format,...)
Definition: LogManager.hpp:311
OpSpringRhs
FormsIntegrators< BoundaryEleOp >::Assembly< AT >::LinearForm< IT >::OpBaseTimesVector< 1, SPACE_DIM, 1 > OpSpringRhs
Definition: contact.cpp:120
OpPPMap
OpPostProcMapInMoab< SPACE_DIM, SPACE_DIM > OpPPMap
Definition: photon_diffusion.cpp:29
ContactOps::Monitor::postProcDomainFe
boost::shared_ptr< PostProcEleDomain > postProcDomainFe
Definition: PostProcContact.hpp:446
MoFEM::DMoFEMPreProcessFiniteElements
PetscErrorCode DMoFEMPreProcessFiniteElements(DM dm, MoFEM::FEMethod *method)
execute finite element method for each element in dm (problem)
Definition: DMMoFEM.cpp:550
MoFEM::DMoFEMPostProcessFiniteElements
PetscErrorCode DMoFEMPostProcessFiniteElements(DM dm, MoFEM::FEMethod *method)
execute finite element method for each element in dm (problem)
Definition: DMMoFEM.cpp:560
EntData
EntitiesFieldData::EntData EntData
Definition: child_and_parent.cpp:37
integration_rule
auto integration_rule
Definition: free_surface.cpp:185
MOFEM_LOG
#define MOFEM_LOG(channel, severity)
Log.
Definition: LogManager.hpp:308
MoFEM::DMoFEMGetInterfacePtr
PetscErrorCode DMoFEMGetInterfacePtr(DM dm, MoFEM::Interface **m_field_ptr)
Get pointer to MoFEM::Interface.
Definition: DMMoFEM.cpp:418
UserDataOperator
ForcesAndSourcesCore::UserDataOperator UserDataOperator
Definition: HookeElement.hpp:75
ContactOps::Monitor::integrateTraction
boost::shared_ptr< BoundaryEle > integrateTraction
Definition: PostProcContact.hpp:449
ContactOps::Monitor::uYScatter
std::tuple< SmartPetscObj< Vec >, SmartPetscObj< VecScatter > > uYScatter
Definition: PostProcContact.hpp:441
MoFEM::DMoFEMLoopFiniteElements
PetscErrorCode DMoFEMLoopFiniteElements(DM dm, const char fe_name[], MoFEM::FEMethod *method, CacheTupleWeakPtr cache_ptr=CacheTupleSharedPtr())
Executes FEMethod for finite elements in DM.
Definition: DMMoFEM.cpp:590
convert.int
int
Definition: convert.py:64
MoFEM::PetscOptionsGetInt
PetscErrorCode PetscOptionsGetInt(PetscOptions *, const char pre[], const char name[], PetscInt *ivalue, PetscBool *set)
Definition: DeprecatedPetsc.hpp:142
MoFEMFunctionReturn
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:416
HDIV
@ HDIV
field with continuous normal traction
Definition: definitions.h:87
MoFEMFunctionBegin
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:346
MoFEM::OpPostProcMapInMoab
Post post-proc data at points from hash maps.
Definition: PostProcBrokenMeshInMoabBase.hpp:698
Generated by Doxygen 1.8.17 and hosted at University of Glasgow