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 1142 of file EshelbianContact.cpp.

1151  : UOP(NOSPACE, UOP::OPSPACE), contactTreePtr(contact_tree_ptr),
1152  commonDataPtr(common_data_ptr), uH1Ptr(u_h1_ptr),
1153  postProcMeshPtr(post_proc_mesh_ptr), mapGaussPtsPtr(map_gauss_pts_ptr),
1154  contactRange(r) {}

Member Function Documentation

◆ doWork()

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

Definition at line 1156 of file EshelbianContact.cpp.

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

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:177
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