v0.14.0
Public Types | Public Member Functions | Protected Attributes | List of all members
EshelbianPlasticity::OpTreeSearch Struct Reference

#include <users_modules/eshelbian_plasticit/src/EshelbianContact.hpp>

Inheritance diagram for EshelbianPlasticity::OpTreeSearch:
[legend]
Collaboration diagram for EshelbianPlasticity::OpTreeSearch:
[legend]

Public Types

using UOP = FaceElementForcesAndSourcesCore::UserDataOperator
 

Public Member Functions

 OpTreeSearch (boost::shared_ptr< ContactTree > contact_tree_ptr, boost::shared_ptr< ContactOps::CommonData > common_data_ptr, boost::shared_ptr< MatrixDouble > u_h1_ptr, Range r, moab::Interface *post_proc_mesh_ptr, std::vector< EntityHandle > *map_gauss_pts_ptr)
 
MoFEMErrorCode doWork (int side, EntityType type, EntitiesFieldData::EntData &data)
 

Protected Attributes

boost::shared_ptr< ContactTreecontactTreePtr
 
boost::shared_ptr< ContactOps::CommonDatacommonDataPtr
 
boost::shared_ptr< MatrixDouble > uH1Ptr
 
moab::Interface * postProcMeshPtr = nullptr
 
std::vector< EntityHandle > * mapGaussPtsPtr = nullptr
 
Range contactRange
 

Detailed Description

Definition at line 237 of file EshelbianContact.hpp.

Member Typedef Documentation

◆ UOP

Definition at line 239 of file EshelbianContact.hpp.

Constructor & Destructor Documentation

◆ OpTreeSearch()

EshelbianPlasticity::OpTreeSearch::OpTreeSearch ( boost::shared_ptr< ContactTree contact_tree_ptr,
boost::shared_ptr< ContactOps::CommonData common_data_ptr,
boost::shared_ptr< MatrixDouble >  u_h1_ptr,
Range  r,
moab::Interface *  post_proc_mesh_ptr,
std::vector< EntityHandle > *  map_gauss_pts_ptr 
)

Definition at line 1127 of file EshelbianContact.cpp.

1136  : UOP(NOSPACE, UOP::OPSPACE), contactTreePtr(contact_tree_ptr),
1137  commonDataPtr(common_data_ptr), uH1Ptr(u_h1_ptr),
1138  postProcMeshPtr(post_proc_mesh_ptr), mapGaussPtsPtr(map_gauss_pts_ptr),
1139  contactRange(r) {}

Member Function Documentation

◆ doWork()

MoFEMErrorCode EshelbianPlasticity::OpTreeSearch::doWork ( int  side,
EntityType  type,
EntitiesFieldData::EntData data 
)

Definition at line 1141 of file EshelbianContact.cpp.

1142  {
1144 
1145  auto &m_field = getPtrFE()->mField;
1146  auto fe_ent = getNumeredEntFiniteElementPtr()->getEnt();
1147  auto fe_id = id_from_handle(fe_ent);
1148 
1149  if (contactRange.find(fe_ent) == contactRange.end())
1151 
1154 
1155  const auto nb_gauss_pts = getGaussPts().size2();
1156 
1157  auto t_disp_h1 = getFTensor1FromMat<3>(*uH1Ptr);
1158  auto t_coords = getFTensor1CoordsAtGaussPts();
1159  auto t_traction = getFTensor1FromMat<3>(commonDataPtr->contactTraction);
1160 
1161  auto next = [&]() {
1162  ++t_disp_h1;
1163  ++t_traction;
1164  ++t_coords;
1165  };
1166 
1167  auto get_ele_centre = [i](auto t_ele_coords) {
1168  FTensor::Tensor1<double, 3> t_ele_center;
1169  t_ele_center(i) = 0;
1170  for (int nn = 0; nn != 3; nn++) {
1171  t_ele_center(i) += t_ele_coords(i);
1172  ++t_ele_coords;
1173  }
1174  t_ele_center(i) /= 3;
1175  return t_ele_center;
1176  };
1177 
1178  auto get_ele_radius = [i](auto t_ele_center, auto t_ele_coords) {
1180  t_n0(i) = t_ele_center(i) - t_ele_coords(i);
1181  return t_n0.l2();
1182  };
1183 
1184  auto get_face_conn = [this](auto face) {
1185  const EntityHandle *conn;
1186  int num_nodes;
1187  CHK_MOAB_THROW(contactTreePtr->getPostProcMesh().get_connectivity(
1188  face, conn, num_nodes, true),
1189  "get conn");
1190  if (num_nodes != 3) {
1191  CHK_THROW_MESSAGE(MOFEM_DATA_INCONSISTENCY, "face is not a triangle");
1192  }
1193  return conn;
1194  };
1195 
1196  auto get_face_coords = [this](auto conn) {
1197  std::array<double, 9> coords;
1198  CHKERR contactTreePtr->getPostProcMesh().get_coords(conn, 3, coords.data());
1199  return coords;
1200  };
1201 
1202  auto get_closet_face = [this](auto *point_ptr, auto r) {
1203  FTensor::Tensor1<double, 3> t_point_out;
1204  std::vector<EntityHandle> faces_out;
1206  contactTreePtr->getTreeSurfPtr()->sphere_intersect_triangles(
1207  point_ptr, r / 8, contactTreePtr->getRootSetSurf(), faces_out),
1208  "get closest faces");
1209  return faces_out;
1210  };
1211 
1212  auto get_faces_out = [this](auto *point_ptr, auto *unit_ray_ptr, auto radius,
1213  auto eps) {
1214  std::vector<double> distances_out;
1215  std::vector<EntityHandle> faces_out;
1217 
1218  contactTreePtr->getTreeSurfPtr()->ray_intersect_triangles(
1219  distances_out, faces_out, contactTreePtr->getRootSetSurf(), eps,
1220  point_ptr, unit_ray_ptr, &radius),
1221 
1222  "get closest faces");
1223  return std::make_pair(faces_out, distances_out);
1224  };
1225 
1226  auto get_normal = [](auto &ele_coords) {
1227  FTensor::Tensor1<double, 3> t_normal;
1228  Tools::getTriNormal(ele_coords.data(), &t_normal(0));
1229  return t_normal;
1230  };
1231 
1232  auto make_map = [&](auto &face_out, auto &face_dist, auto &t_ray_point,
1233  auto &t_unit_ray, auto &t_master_coord) {
1236  std::map<double, EntityHandle> m;
1237  for (auto ii = 0; ii != face_out.size(); ++ii) {
1238  auto face_conn = get_face_conn(face_out[ii]);
1239  auto face_coords = get_face_coords(face_conn);
1240  auto t_face_normal = get_normal(face_coords);
1241  t_face_normal.normalize();
1243  t_x(i) = t_ray_point(i) + t_unit_ray(i) * face_dist[ii];
1245  t_chi(i, j) =
1246  t_x(i) * t_face_normal(j) - t_master_coord(i) * t_unit_ray(j);
1247  if (t_unit_ray(i) * t_face_normal(i) > std::cos(M_PI / 3)) {
1248  auto dot = std::sqrt(t_chi(i, j) * t_chi(i, j));
1249  m[dot] = face_out[ii];
1250  }
1251  }
1252  return m;
1253  };
1254 
1255  auto get_tag_data = [this](auto tag, auto face, auto &vec) {
1257  int tag_length;
1258  CHKERR contactTreePtr->getPostProcMesh().tag_get_length(tag, tag_length);
1259  vec.resize(tag_length);
1260  CHKERR contactTreePtr->getPostProcMesh().tag_get_data(tag, &face, 1,
1261  &*vec.begin());
1263  };
1264 
1265  auto create_tag = [this](const std::string tag_name, const int size) {
1266  double def_VAL[] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
1267  Tag th;
1268  if (postProcMeshPtr) {
1269  CHKERR postProcMeshPtr->tag_get_handle(
1270  tag_name.c_str(), size, MB_TYPE_DOUBLE, th,
1271  MB_TAG_CREAT | MB_TAG_SPARSE, def_VAL);
1272  CHKERR postProcMeshPtr->tag_clear_data(th, &*mapGaussPtsPtr->begin(),
1273  mapGaussPtsPtr->size(), def_VAL);
1274  }
1275  return th;
1276  };
1277 
1278  auto set_float_precision = [](const double x) {
1279  if (std::abs(x) < std::numeric_limits<float>::epsilon())
1280  return 0.;
1281  else
1282  return x;
1283  };
1284 
1285  // scalars
1286  auto save_scal_tag = [&](auto &th, auto v, const int gg) {
1288  if (postProcMeshPtr) {
1289  v = set_float_precision(v);
1290  CHKERR postProcMeshPtr->tag_set_data(th, &(*mapGaussPtsPtr)[gg], 1, &v);
1291  }
1293  };
1294 
1295  // adjacencies
1296  auto get_fe_adjacencies = [this](auto fe_ent) {
1297  Range adj_faces;
1298  CHK_MOAB_THROW(getFaceFE()->mField.get_moab().get_adjacencies(
1299  &fe_ent, 1, 2, false, adj_faces, moab::Interface::UNION),
1300  "get adj");
1301  std::set<int> adj_ids;
1302  for (auto f : adj_faces) {
1303  adj_ids.insert(id_from_handle(f));
1304  }
1305  return adj_ids;
1306  };
1307 
1308  auto get_face_id = [this](auto face) {
1309  int id;
1310  if (contactTreePtr->getPostProcMesh().tag_get_data(
1311  contactTreePtr->thEleId, &face, 1, &id) == MB_SUCCESS) {
1312  return id;
1313  }
1314  return -1;
1315  };
1316 
1317  auto get_body_id = [this](auto face) {
1318  int id;
1319  if (contactTreePtr->getPostProcMesh().tag_get_data(
1320  contactTreePtr->thBodyId, &face, 1, &id) == MB_SUCCESS) {
1321  return id;
1322  }
1323  return -1;
1324  };
1325 
1326  auto get_face_part = [this](auto face) {
1327  ParallelComm *pcomm_post_proc_mesh = ParallelComm::get_pcomm(
1328  &(contactTreePtr->getPostProcMesh()), MYPCOMM_INDEX);
1329  int part;
1330  if (contactTreePtr->getPostProcMesh().tag_get_data(
1331  pcomm_post_proc_mesh->part_tag(), &face, 1, &part) == MB_SUCCESS) {
1332  return part;
1333  }
1334  return -1;
1335  };
1336 
1337  auto check_face = [&](auto face, auto fe_id, auto part) {
1338  auto face_id = get_face_id(face);
1339  auto face_part = get_face_part(face);
1340  if (face_id == fe_id && face_part == part)
1341  return true;
1342  return false;
1343  };
1344 
1345  // vectors
1346  VectorDouble3 v(3);
1347  FTensor::Tensor1<FTensor::PackPtr<double *, 0>, 3> t_v(&v[0], &v[1], &v[2]);
1348  auto save_vec_tag = [&](auto &th, auto &t_d, const int gg) {
1350  if (postProcMeshPtr) {
1351  t_v(i) = t_d(i);
1352  for (auto &a : v.data())
1353  a = set_float_precision(a);
1354  CHKERR postProcMeshPtr->tag_set_data(th, &(*mapGaussPtsPtr)[gg], 1,
1355  &*v.data().begin());
1356  }
1358  };
1359 
1360  Tag th_mark = create_tag("contact_mark", 1);
1361  Tag th_mark_slave = create_tag("contact_mark_slave", 1);
1362  Tag th_body_id = create_tag("contact_body_id", 1);
1363  Tag th_gap = create_tag("contact_gap", 1);
1364  Tag th_tn_master = create_tag("contact_tn_master", 1);
1365  Tag th_tn_slave = create_tag("contact_tn_slave", 1);
1366  Tag th_contact_traction = create_tag("contact_traction", 3);
1367  Tag th_contact_traction_master = create_tag("contact_traction_master", 3);
1368  Tag th_contact_traction_slave = create_tag("contact_traction_slave", 3);
1369  Tag th_c = create_tag("contact_c", 1);
1370  Tag th_normal = create_tag("contact_normal", 3);
1371  Tag th_dist = create_tag("contact_dip", 3);
1372 
1373  auto t_ele_centre = get_ele_centre(getFTensor1Coords());
1374  auto ele_radius = get_ele_radius(t_ele_centre, getFTensor1Coords());
1375 
1376  contactTreePtr->shadowDataMap.clear();
1377  auto &shadow_vec = contactTreePtr->shadowDataMap[fe_ent];
1378  shadow_vec.clear();
1379 
1380  auto adj_fe_ids = get_fe_adjacencies(fe_ent);
1381 
1382  for (auto gg = 0; gg != nb_gauss_pts; ++gg) {
1383 
1384  FTensor::Tensor1<double, 3> t_spatial_coords;
1385  t_spatial_coords(i) = t_coords(i) + t_disp_h1(i);
1386 
1387  if (postProcMeshPtr) {
1388  CHKERR save_vec_tag(th_contact_traction, t_traction, gg);
1389  }
1390 
1391  auto faces_close = get_closet_face(&t_spatial_coords(0), ele_radius);
1392  for (auto face_close : faces_close) {
1393  if (check_face(face_close, fe_id, m_field.get_comm_rank())) {
1394 
1395  auto body_id = get_body_id(face_close);
1396 
1397  auto master_face_conn = get_face_conn(face_close);
1398  std::array<double, 9> master_coords;
1399  CHKERR contactTreePtr->getPostProcMesh().tag_get_data(
1400  contactTreePtr->thSmallX, master_face_conn, 3,
1401  master_coords.data());
1402  std::array<double, 9> master_traction;
1403  CHKERR contactTreePtr->getPostProcMesh().tag_get_data(
1404  contactTreePtr->thTraction, master_face_conn, 3,
1405  master_traction.data());
1406  auto t_normal_face_close = get_normal(master_coords);
1407  t_normal_face_close.normalize();
1408 
1409  if (postProcMeshPtr) {
1410  double m = 1;
1411  CHKERR save_scal_tag(th_mark, m, gg);
1412  CHKERR save_scal_tag(th_body_id, static_cast<double>(body_id), gg);
1413  CHKERR save_vec_tag(th_normal, t_normal_face_close, gg);
1414  CHKERR save_vec_tag(th_contact_traction, t_traction, gg);
1415  }
1416 
1417  FTensor::Tensor1<double, 3> t_unit_ray;
1418  t_unit_ray(i) = -t_normal_face_close(i);
1419  FTensor::Tensor1<double, 3> t_ray_point;
1420  t_ray_point(i) =
1421  t_spatial_coords(i) -
1422  t_unit_ray(i) * ContactOps::airplane_ray_distance * ele_radius;
1423 
1424  constexpr double eps = 1e-3;
1425  auto [faces_out, faces_dist] =
1426  get_faces_out(&t_ray_point(0), &t_unit_ray(0),
1427  2 * ContactOps::airplane_ray_distance * ele_radius,
1428  eps * ele_radius);
1429 
1430  auto m = make_map(faces_out, faces_dist, t_ray_point, t_unit_ray,
1431  t_spatial_coords);
1432  for (auto m_it = m.begin(); m_it != m.end(); ++m_it) {
1433  auto face = m_it->second;
1434  if (face != face_close) {
1435 
1436  if (
1437 
1438  body_id != get_body_id(face) &&
1439  (adj_fe_ids.find(get_face_id(face)) == adj_fe_ids.end() ||
1440  get_face_part(face) != m_field.get_comm_rank())
1441 
1442  ) {
1443 
1444  shadow_vec.push_back(ContactTree::FaceData());
1445  shadow_vec.back().gaussPtNb = gg;
1446 
1447  auto slave_face_conn = get_face_conn(face);
1448  std::array<double, 9> slave_coords;
1449  CHKERR contactTreePtr->getPostProcMesh().tag_get_data(
1450  contactTreePtr->thSmallX, slave_face_conn, 3,
1451  slave_coords.data());
1452  auto t_normal_face = get_normal(slave_coords);
1453  std::array<double, 9> slave_tractions;
1454  CHKERR contactTreePtr->getPostProcMesh().tag_get_data(
1455  contactTreePtr->thTraction, slave_face_conn, 3,
1456  slave_tractions.data());
1457 
1458  auto t_master_point =
1459  getFTensor1FromPtr<3>(shadow_vec.back().masterPoint.data());
1460  auto t_slave_point =
1461  getFTensor1FromPtr<3>(shadow_vec.back().slavePoint.data());
1462  auto t_ray_point_data =
1463  getFTensor1FromPtr<3>(shadow_vec.back().rayPoint.data());
1464  auto t_unit_ray_data =
1465  getFTensor1FromPtr<3>(shadow_vec.back().unitRay.data());
1466 
1467  t_slave_point(i) = t_ray_point(i) + m_it->first * t_unit_ray(i);
1468 
1469  auto eval_position = [&](auto &&t_elem_coords, auto &&t_point) {
1470  std::array<double, 2> loc_coords;
1472  Tools::getLocalCoordinatesOnReferenceThreeNodeTri(
1473  &t_elem_coords(0, 0), &t_point(0), 1,
1474  loc_coords.data()),
1475  "get local coords");
1476  FTensor::Tensor1<double, 3> t_shape_fun;
1477  CHK_THROW_MESSAGE(Tools::shapeFunMBTRI<0>(&t_shape_fun(0),
1478  &loc_coords[0],
1479  &loc_coords[1], 1),
1480  "calc shape fun");
1483  FTensor::Tensor1<double, 3> t_point_out;
1484  t_point_out(i) = t_shape_fun(j) * t_elem_coords(j, i);
1485  return t_point_out;
1486  };
1487 
1488  auto t_master_point_updated = eval_position(
1489  getFTensor2FromPtr<3, 3>(master_coords.data()),
1490  getFTensor1FromPtr<3>(shadow_vec.back().masterPoint.data()));
1491  t_master_point(i) = t_master_point_updated(i);
1492 
1493  auto t_slave_point_updated = eval_position(
1494  getFTensor2FromPtr<3, 3>(slave_coords.data()),
1495  getFTensor1FromPtr<3>(shadow_vec.back().slavePoint.data()));
1496  t_slave_point(i) = t_slave_point_updated(i);
1497 
1498  t_ray_point_data(i) = t_ray_point(i);
1499  t_unit_ray_data(i) = t_unit_ray(i);
1500 
1501  std::copy(master_coords.begin(), master_coords.end(),
1502  shadow_vec.back().masterPointNodes.begin());
1503  std::copy(master_traction.begin(), master_traction.end(),
1504  shadow_vec.back().masterTractionNodes.begin());
1505  std::copy(slave_coords.begin(), slave_coords.end(),
1506  shadow_vec.back().slavePointNodes.begin());
1507  std::copy(slave_tractions.begin(), slave_tractions.end(),
1508  shadow_vec.back().slaveTractionNodes.begin());
1509 
1510  shadow_vec.back().eleRadius = ele_radius;
1511 
1512  // CHKERR get_tag_data(contactTreePtr->thIds, face,
1513  // shadow_vec.back().dofsSlaveIds);
1514  // CHKERR get_tag_data(contactTreePtr->thCoeff, face,
1515  // shadow_vec.back().dofsSlaveCoeff);
1516  // CHKERR get_tag_data(contactTreePtr->thBases, face,
1517  // shadow_vec.back().baseSlaveFuncs);
1518 
1519  if (postProcMeshPtr) {
1520  auto [gap, tn_master, tn_slave, c, t_master_traction,
1521  t_slave_traction] =
1522  multiGetGap(&(shadow_vec.back()), t_spatial_coords);
1523  FTensor::Tensor1<double, 3> t_gap_vec;
1524  t_gap_vec(i) = t_slave_point(i) - t_spatial_coords(i);
1525  CHKERR save_scal_tag(th_gap, gap, gg);
1526  CHKERR save_scal_tag(th_tn_master, tn_master, gg);
1527  CHKERR save_scal_tag(th_tn_slave, tn_slave, gg);
1528  CHKERR save_scal_tag(th_c, c, gg);
1529  double m = 1;
1530  CHKERR save_scal_tag(th_mark_slave, m, gg);
1531  CHKERR save_vec_tag(th_dist, t_gap_vec, gg);
1532  CHKERR save_vec_tag(th_contact_traction_master,
1533  t_master_traction, gg);
1534  CHKERR save_vec_tag(th_contact_traction_slave, t_slave_traction,
1535  gg);
1536  }
1537 
1538  break;
1539  }
1540  }
1541  }
1542  break;
1543  }
1544  }
1545  next();
1546  }
1547 
1549 }

Member Data Documentation

◆ commonDataPtr

boost::shared_ptr<ContactOps::CommonData> EshelbianPlasticity::OpTreeSearch::commonDataPtr
protected

Definition at line 254 of file EshelbianContact.hpp.

◆ contactRange

Range EshelbianPlasticity::OpTreeSearch::contactRange
protected

Definition at line 260 of file EshelbianContact.hpp.

◆ contactTreePtr

boost::shared_ptr<ContactTree> EshelbianPlasticity::OpTreeSearch::contactTreePtr
protected

Definition at line 253 of file EshelbianContact.hpp.

◆ mapGaussPtsPtr

std::vector<EntityHandle>* EshelbianPlasticity::OpTreeSearch::mapGaussPtsPtr = nullptr
protected

Definition at line 258 of file EshelbianContact.hpp.

◆ postProcMeshPtr

moab::Interface* EshelbianPlasticity::OpTreeSearch::postProcMeshPtr = nullptr
protected

Definition at line 257 of file EshelbianContact.hpp.

◆ uH1Ptr

boost::shared_ptr<MatrixDouble> EshelbianPlasticity::OpTreeSearch::uH1Ptr
protected

Definition at line 255 of file EshelbianContact.hpp.


The documentation for this struct was generated from the following files:
NOSPACE
@ NOSPACE
Definition: definitions.h:83
MoFEMFunctionReturnHot
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:460
ContactOps::airplane_ray_distance
double airplane_ray_distance
Definition: EshelbianContact.hpp:25
CHK_MOAB_THROW
#define CHK_MOAB_THROW(err, msg)
Check error code of MoAB function and throw MoFEM exception.
Definition: definitions.h:589
MoFEM::id_from_handle
auto id_from_handle(const EntityHandle h)
Definition: Templates.hpp:1890
MYPCOMM_INDEX
#define MYPCOMM_INDEX
default communicator number PCOMM
Definition: definitions.h:228
EshelbianPlasticity::OpTreeSearch::UOP
FaceElementForcesAndSourcesCore::UserDataOperator UOP
Definition: EshelbianContact.hpp:239
MoFEM::Types::VectorDouble3
VectorBoundedArray< double, 3 > VectorDouble3
Definition: Types.hpp:92
FTensor::Tensor1< double, 3 >
EntityHandle
CHK_THROW_MESSAGE
#define CHK_THROW_MESSAGE(err, msg)
Check and throw MoFEM exception.
Definition: definitions.h:609
FTensor::Tensor1::l2
T l2() const
Definition: Tensor1_value.hpp:84
MoFEM::th
Tag th
Definition: Projection10NodeCoordsOnField.cpp:122
EshelbianPlasticity::OpTreeSearch::contactTreePtr
boost::shared_ptr< ContactTree > contactTreePtr
Definition: EshelbianContact.hpp:253
EshelbianPlasticity::OpTreeSearch::contactRange
Range contactRange
Definition: EshelbianContact.hpp:260
sdf.r
int r
Definition: sdf.py:8
FTensor::Tensor2< double, 3, 3 >
c
const double c
speed of light (cm/ns)
Definition: initial_diffusion.cpp:39
CHKERR
#define CHKERR
Inline error check.
Definition: definitions.h:548
EshelbianPlasticity::OpTreeSearch::postProcMeshPtr
moab::Interface * postProcMeshPtr
Definition: EshelbianContact.hpp:257
a
constexpr double a
Definition: approx_sphere.cpp:30
i
FTensor::Index< 'i', SPACE_DIM > i
Definition: hcurl_divergence_operator_2d.cpp:27
FTensor::Index< 'i', 3 >
v
const double v
phase velocity of light in medium (cm/ns)
Definition: initial_diffusion.cpp:40
Range
face_coords
static const double face_coords[4][9]
Definition: forces_and_sources_h1_continuity_check.cpp:13
EshelbianPlasticity::OpTreeSearch::uH1Ptr
boost::shared_ptr< MatrixDouble > uH1Ptr
Definition: EshelbianContact.hpp:255
HenckyOps::f
auto f
Definition: HenckyOps.hpp:15
j
FTensor::Index< 'j', 3 > j
Definition: matrix_function.cpp:19
eps
static const double eps
Definition: check_base_functions_derivatives_on_tet.cpp:11
MOFEM_DATA_INCONSISTENCY
@ MOFEM_DATA_INCONSISTENCY
Definition: definitions.h:31
EshelbianPlasticity::multiGetGap
auto multiGetGap(ContactTree::FaceData *face_data_ptr, FTensor::Tensor1< T1, 3 > &t_spatial_coords)
Definition: EshelbianContact.cpp:173
EshelbianPlasticity::OpTreeSearch::mapGaussPtsPtr
std::vector< EntityHandle > * mapGaussPtsPtr
Definition: EshelbianContact.hpp:258
m
FTensor::Index< 'm', 3 > m
Definition: shallow_wave.cpp:80
MoFEMFunctionReturn
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:429
EshelbianPlasticity::OpTreeSearch::commonDataPtr
boost::shared_ptr< ContactOps::CommonData > commonDataPtr
Definition: EshelbianContact.hpp:254
MoFEMFunctionBegin
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:359