v0.14.0
Public Types | Public Member Functions | Public Attributes | List of all members
EshelbianMonitor Struct Reference
Inheritance diagram for EshelbianMonitor:
[legend]
Collaboration diagram for EshelbianMonitor:
[legend]

Public Types

using Ele = ForcesAndSourcesCore
 
using VolEle = VolumeElementForcesAndSourcesCore
 
using VolOp = VolumeElementForcesAndSourcesCore::UserDataOperator
 
using SetPtsData = FieldEvaluatorInterface::SetPtsData
 
using PtsHashMap = std::map< std::string, std::array< double, 3 > >
 
using FaceSideEle = PipelineManager::ElementsAndOpsByDim< SPACE_DIM >::FaceSideEle
 

Public Member Functions

 EshelbianMonitor (EshelbianCore &ep)
 
MoFEMErrorCode preProcess ()
 
MoFEMErrorCode operator() ()
 
MoFEMErrorCode postProcess ()
 

Public Attributes

EshelbianCore & eP
 
boost::shared_ptr< SetPtsData > dataFieldEval
 
boost::shared_ptr< VolEle > volPostProcEnergy
 
boost::shared_ptr< double > gEnergy
 
PtsHashMap ptsHashMap
 

Detailed Description

Definition at line 6 of file EshelbianMonitor.cpp.

Member Typedef Documentation

◆ Ele

using EshelbianMonitor::Ele = ForcesAndSourcesCore

Definition at line 8 of file EshelbianMonitor.cpp.

◆ FaceSideEle

using EshelbianMonitor::FaceSideEle = PipelineManager::ElementsAndOpsByDim<SPACE_DIM>::FaceSideEle

Definition at line 14 of file EshelbianMonitor.cpp.

◆ PtsHashMap

using EshelbianMonitor::PtsHashMap = std::map<std::string, std::array<double, 3> >

Definition at line 12 of file EshelbianMonitor.cpp.

◆ SetPtsData

using EshelbianMonitor::SetPtsData = FieldEvaluatorInterface::SetPtsData

Definition at line 11 of file EshelbianMonitor.cpp.

◆ VolEle

using EshelbianMonitor::VolEle = VolumeElementForcesAndSourcesCore

Definition at line 9 of file EshelbianMonitor.cpp.

◆ VolOp

using EshelbianMonitor::VolOp = VolumeElementForcesAndSourcesCore::UserDataOperator

Definition at line 10 of file EshelbianMonitor.cpp.

Constructor & Destructor Documentation

◆ EshelbianMonitor()

EshelbianMonitor::EshelbianMonitor ( EshelbianCore &  ep)
inline

Definition at line 22 of file EshelbianMonitor.cpp.

23  : eP(ep), dataFieldEval(ep.mField.getInterface<FieldEvaluatorInterface>()
24  ->getData<VolEle>()),
25  volPostProcEnergy(new VolEle(ep.mField)), gEnergy(new double) {
26  ierr = ep.mField.getInterface<FieldEvaluatorInterface>()->buildTree3D(
27  dataFieldEval, "EP");
28  CHKERRABORT(PETSC_COMM_WORLD, ierr);
29 
30  auto no_rule = [](int, int, int) { return -1; };
31 
32  auto set_element_for_field_eval = [&]() {
33  MoFEMFunctionBegin;
34  boost::shared_ptr<Ele> vol_ele(dataFieldEval->feMethodPtr.lock());
35  vol_ele->getRuleHook = no_rule;
36  vol_ele->getUserPolynomialBase() =
37  boost::make_shared<CGGUserPolynomialBase>();
38  EshelbianPlasticity::AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(
39  vol_ele->getOpPtrVector(), {HDIV, H1, L2}, eP.materialH1Positions,
40  ep.frontAdjEdges);
41 
42  auto piola_scale_ptr = boost::make_shared<double>(1.0);
43  vol_ele->getOpPtrVector().push_back(
44  eP.physicalEquations->returnOpSetScale(piola_scale_ptr,
45  eP.physicalEquations));
46  vol_ele->getOpPtrVector().push_back(new OpCalculateHVecTensorField<3, 3>(
47  eP.piolaStress, eP.dataAtPts->getApproxPAtPts(), piola_scale_ptr));
48  vol_ele->getOpPtrVector().push_back(
49  new OpCalculateHTensorTensorField<3, 3>(
50  eP.bubbleField, eP.dataAtPts->getApproxPAtPts(), piola_scale_ptr,
51  SmartPetscObj<Vec>(), MBMAXTYPE));
52  if (EshelbianCore::noStretch) {
53  vol_ele->getOpPtrVector().push_back(
54  eP.physicalEquations->returnOpCalculateStretchFromStress(
55  eP.dataAtPts, eP.physicalEquations));
56  } else {
57  vol_ele->getOpPtrVector().push_back(
58  new OpCalculateTensor2SymmetricFieldValues<3>(
59  eP.stretchTensor, eP.dataAtPts->getLogStretchTensorAtPts(),
60  MBTET));
61  }
62  vol_ele->getOpPtrVector().push_back(new OpCalculateVectorFieldValues<3>(
63  eP.rotAxis, eP.dataAtPts->getRotAxisAtPts(), MBTET));
64  vol_ele->getOpPtrVector().push_back(new OpCalculateVectorFieldValues<3>(
65  eP.rotAxis, eP.dataAtPts->getRotAxis0AtPts(), eP.solTSStep, MBTET));
66  vol_ele->getOpPtrVector().push_back(new OpCalculateVectorFieldValues<3>(
67  eP.spatialL2Disp, eP.dataAtPts->getSmallWL2AtPts(), MBTET));
68 
69  // H1 displacements
70  vol_ele->getOpPtrVector().push_back(new OpCalculateVectorFieldValues<3>(
71  eP.spatialH1Disp, eP.dataAtPts->getSmallWH1AtPts()));
72  vol_ele->getOpPtrVector().push_back(
73  new OpCalculateVectorFieldGradient<3, 3>(
74  eP.spatialH1Disp, eP.dataAtPts->getSmallWGradH1AtPts()));
75 
76  vol_ele->getOpPtrVector().push_back(
77  new OpCalculateRotationAndSpatialGradient(eP.dataAtPts));
78  MoFEMFunctionReturn(0);
79  };
80 
81  auto set_element_for_post_process_energy = [&]() {
82  MoFEMFunctionBegin;
83  // volPostProcEnergy->getRuleHook = VolRule();
84  volPostProcEnergy->getRuleHook = [](int, int, int) { return -1; };
85  volPostProcEnergy->setRuleHook =
86  SetIntegrationAtFrontVolume(eP.frontVertices, eP.frontAdjEdges);
87 
88  auto bubble_cache = boost::make_shared<CGGUserPolynomialBase::CachePhi>(
89  0, 0, MatrixDouble());
90  volPostProcEnergy->getUserPolynomialBase() =
91  boost::make_shared<CGGUserPolynomialBase>(bubble_cache);
92  EshelbianPlasticity::AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(
93  volPostProcEnergy->getOpPtrVector(), {HDIV, H1, L2},
94  eP.materialH1Positions, ep.frontAdjEdges);
95  auto piola_scale_ptr = boost::make_shared<double>(1.0);
96  volPostProcEnergy->getOpPtrVector().push_back(
97  eP.physicalEquations->returnOpSetScale(piola_scale_ptr,
98  eP.physicalEquations));
99  volPostProcEnergy->getOpPtrVector().push_back(
100  new OpCalculateHVecTensorField<3, 3>(eP.piolaStress,
101  eP.dataAtPts->getApproxPAtPts(),
102  piola_scale_ptr));
103  volPostProcEnergy->getOpPtrVector().push_back(
104  new OpCalculateHTensorTensorField<3, 3>(
105  eP.bubbleField, eP.dataAtPts->getApproxPAtPts(), piola_scale_ptr,
106  SmartPetscObj<Vec>(), MBMAXTYPE));
107  if (eP.noStretch) {
108  volPostProcEnergy->getOpPtrVector().push_back(
109  eP.physicalEquations->returnOpCalculateStretchFromStress(
110  eP.dataAtPts, eP.physicalEquations));
111  } else {
112  volPostProcEnergy->getOpPtrVector().push_back(
113  new OpCalculateTensor2SymmetricFieldValues<3>(
114  eP.stretchTensor, eP.dataAtPts->getLogStretchTensorAtPts(),
115  MBTET));
116  }
117  volPostProcEnergy->getOpPtrVector().push_back(
118  new OpCalculateVectorFieldValues<3>(
119  eP.rotAxis, eP.dataAtPts->getRotAxisAtPts(), MBTET));
120  volPostProcEnergy->getOpPtrVector().push_back(
121  new OpCalculateVectorFieldValues<3>(eP.rotAxis,
122  eP.dataAtPts->getRotAxis0AtPts(),
123  eP.solTSStep, MBTET));
124 
125  volPostProcEnergy->getOpPtrVector().push_back(
126  new OpCalculateVectorFieldGradient<3, 3>(
127  eP.spatialH1Disp, eP.dataAtPts->getSmallWGradH1AtPts()));
128  volPostProcEnergy->getOpPtrVector().push_back(
129  new OpCalculateRotationAndSpatialGradient(eP.dataAtPts));
130 
131  if (auto op = eP.physicalEquations->returnOpCalculateEnergy(eP.dataAtPts,
132  gEnergy)) {
133  volPostProcEnergy->getOpPtrVector().push_back(op);
134  }
135 
136  MoFEMFunctionReturn(0);
137  };
138 
139  auto reads_post_proc_data = [](PtsHashMap &pts_hash_map) {
140  MoFEMFunctionBegin;
141  std::ifstream file(
142  "points.txt"); // Open the file with the name "data.txt"
143 
144  if (!file.is_open()) {
145  MoFEMFunctionReturnHot(0);
146  }
147 
148  std::string line;
149 
150  while (std::getline(file, line)) {
151  std::istringstream iss(line);
152  std::string col1;
153  double col2, col3, col4;
154 
155  if (iss >> col1 >> col2 >> col3 >> col4) {
156  MOFEM_LOG("EP", Sev::verbose) << "Read: " << col1 << ", " << col2
157  << ", " << col3 << ", " << col4;
158  pts_hash_map[col1] = {col2, col3, col4};
159  } else {
160  MOFEM_LOG("EP", Sev::error) << "Error parsing line: " << line;
161  }
162  }
163 
164  file.close(); // Close the file
165  MoFEMFunctionReturn(0);
166  };
167 
168  CHK_THROW_MESSAGE(set_element_for_field_eval(), "set element for field");
169  CHK_THROW_MESSAGE(set_element_for_post_process_energy(),
170  "set element for post energy");
171 
172  PetscBool test_cook_flg = PETSC_FALSE;
173  CHK_THROW_MESSAGE(PetscOptionsGetBool(PETSC_NULL, "", "-test_cook_pts",
174  &test_cook_flg, PETSC_NULL),
175  "get post proc points");
176  if (test_cook_flg) {
177  ptsHashMap["Point A"] = {48., 60., 4.999};
178  ptsHashMap["Point B"] = {48. / 2., 44. + (60. - 44.) / 2., 0.};
179  ptsHashMap["Point C"] = {48. / 2., (44. - 0.) / 2., 0.};
180  }
181  CHK_MOAB_THROW(reads_post_proc_data(ptsHashMap), "read post proc points");
182  }

Member Function Documentation

◆ operator()()

MoFEMErrorCode EshelbianMonitor::operator() ( )
inline

Definition at line 186 of file EshelbianMonitor.cpp.

186 { return 0; }

◆ postProcess()

MoFEMErrorCode EshelbianMonitor::postProcess ( )
inline

Definition at line 188 of file EshelbianMonitor.cpp.

188  {
189  MoFEMFunctionBegin;
190 
191  MOFEM_LOG("EP", Sev::inform) << "Monitor postProcess";
192 
193  // Get boundary faces marked in blocks name "SPATIAL_DISP_...".
194  auto get_ents_on_mesh_skin = [&]() {
195 
196  std::map<std::string, Range> boundary_entities_vec;
197  Range boundary_entities;
198  for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(eP.mField, BLOCKSET, it)) {
199  std::string meshset_name = it->getName();
200  std::string block_name_disp = "SPATIAL_DISP";
201  std::string block_name_fix = "FIX";
202  if (meshset_name.compare(0, block_name_disp.size(), block_name_disp) == 0 ||
203  meshset_name.compare(0, block_name_fix.size(), block_name_fix) == 0) {
204  CHKERR it->getMeshsetIdEntitiesByDimension(eP.mField.get_moab(), 2,
205  boundary_entities, true);
206  // Add vertices to boundary entities
207  boundary_entities_vec[meshset_name] = boundary_entities;
208  boundary_entities.clear();
209  }
210  }
211  return boundary_entities_vec;
212  };
213 
214  auto boundary_entities_vec = get_ents_on_mesh_skin();
215 
216  std::vector<std::tuple<std::string, Range, std::array<double, 6>>>
217  reactionForces;
218  for (const auto &pair : boundary_entities_vec) {
219  reactionForces.push_back(
220  std::make_tuple(pair.first, pair.second,
221  std::array<double, 6>{0.0, 0.0, 0.0, 0.0, 0.0, 0.0}));
222  }
223 
224  auto integration_rule_face = [](int, int, int approx_order) {
225  return 2 * approx_order + 1;
226  };
227  auto face_fe =
228  boost::make_shared<FaceElementForcesAndSourcesCore>(eP.mField);
229  auto no_rule = [](int, int, int) { return -1; };
230  face_fe->getRuleHook = integration_rule_face;
231  CHKERR
232  EshelbianPlasticity::AddHOOps<SPACE_DIM - 1, SPACE_DIM, SPACE_DIM>::add(
233  face_fe->getOpPtrVector(), {L2}, eP.materialH1Positions,
234  eP.frontAdjEdges);
235 
236  auto op_side =
237  new OpLoopSide<FaceSideEle>(eP.mField, "EP", SPACE_DIM, Sev::noisy);
238  face_fe->getOpPtrVector().push_back(op_side);
239  auto side_fe_ptr = op_side->getSideFEPtr();
240  auto base_ptr =
241  boost::make_shared<EshelbianPlasticity::CGGUserPolynomialBase>();
242  side_fe_ptr->getUserPolynomialBase() = base_ptr;
243  CHKERR EshelbianPlasticity::AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(
244  side_fe_ptr->getOpPtrVector(), {H1, HDIV, L2}, eP.materialH1Positions,
245  eP.frontAdjEdges);
246  auto piola_scale_ptr = boost::make_shared<double>(1.0);
247  side_fe_ptr->getOpPtrVector().push_back(
248  eP.physicalEquations->returnOpSetScale(piola_scale_ptr,
249  eP.physicalEquations));
250  side_fe_ptr->getOpPtrVector().push_back(
251  new OpCalculateHVecTensorField<SPACE_DIM, SPACE_DIM>(
252  eP.piolaStress, eP.dataAtPts->getApproxPAtPts(), piola_scale_ptr));
253  side_fe_ptr->getOpPtrVector().push_back(
254  new OpCalculateHTensorTensorField<3, 3>(
255  eP.bubbleField, eP.dataAtPts->getApproxPAtPts(), MBMAXTYPE));
256  side_fe_ptr->getOpPtrVector().push_back(
257  new OpCalculateTractionFromSideEl(eP.dataAtPts));
258  side_fe_ptr->getOpPtrVector().push_back(new OpCalculateVectorFieldValues<3>(
259  eP.spatialL2Disp, eP.dataAtPts->getSmallWL2AtPts(), MBTET));
260  for (auto &[name, ents, reaction_vec] : reactionForces) {
261  face_fe->getOpPtrVector().push_back(new OpCalculateReactionForces(
262  eP.dataAtPts, name, ents, reaction_vec));
263  }
264 
265  CHKERR eP.mField.loop_finite_elements(problemPtr->getName(), eP.skinElement,
266  *face_fe);
267 
268  for (auto &[name, ents, reaction_vec] : reactionForces) {
269  std::array<double, 6> block_reaction_force{0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
270 
271  MPI_Allreduce(reaction_vec.data(), &block_reaction_force, 6, MPI_DOUBLE,
272  MPI_SUM, eP.mField.get_comm());
273 
274  for (auto &force : block_reaction_force) {
275  if (std::abs(force) < 1e-12) {
276  force = 0.0;
277  }
278  }
279  MOFEM_LOG_C(
280  "EP", Sev::inform,
281  "Step %d time %3.4g Block %s Reaction force [%3.6e, %3.6e, %3.6e]",
282  ts_step, ts_t, name.c_str(), block_reaction_force[0],
283  block_reaction_force[1], block_reaction_force[2]);
284  MOFEM_LOG_C("EP", Sev::inform,
285  "Step %d time %3.4g Block %s Moment [%3.6e, %3.6e, %3.6e]",
286  ts_step, ts_t, name.c_str(), block_reaction_force[3],
287  block_reaction_force[4], block_reaction_force[5]);
288  }
289 
290  auto get_step = [](auto ts_step) {
291  std::ostringstream ss;
292  ss << boost::str(boost::format("%d") % static_cast<int>(ts_step));
293  std::string s = ss.str();
294  return s;
295  };
296 
297  if (ts_u) {
298  PetscViewer viewer;
299  CHKERR PetscViewerBinaryOpen(
300  PETSC_COMM_WORLD, ("restart_" + get_step(ts_step) + ".dat").c_str(),
301  FILE_MODE_WRITE, &viewer);
302  CHKERR VecView(ts_u, viewer);
303  CHKERR PetscViewerDestroy(&viewer);
304  }
305 
306  CHKERR eP.postProcessResults(1, "out_sol_elastic_" + get_step(ts_step) +
307  ".h5m");
308 
309  // Loop boundary elements with traction boundary conditions
310  *gEnergy = 0;
311  TetPolynomialBase::switchCacheBaseOn<HDIV>({volPostProcEnergy.get()});
312  CHKERR eP.mField.loop_finite_elements(problemPtr->getName(), "EP",
313  *volPostProcEnergy);
314  TetPolynomialBase::switchCacheBaseOff<HDIV>({volPostProcEnergy.get()});
315 
316  double body_energy = 0;
317  MPI_Allreduce(gEnergy.get(), &body_energy, 1, MPI_DOUBLE, MPI_SUM,
318  eP.mField.get_comm());
319  MOFEM_LOG_C("EP", Sev::inform, "Step %d time %3.4g strain energy %3.6e",
320  ts_step, ts_t, body_energy);
321 
322  auto post_proc_at_points = [&](std::array<double, 3> point,
323  std::string str) {
324  MoFEMFunctionBegin;
325 
326  dataFieldEval->setEvalPoints(point.data(), point.size() / 3);
327 
328  struct OpPrint : public VolOp {
329 
330  EshelbianCore &eP;
331  std::array<double, 3> point;
332  std::string str;
333 
334  OpPrint(EshelbianCore &ep, std::array<double, 3> &point,
335  std::string &str)
336  : VolOp(ep.spatialL2Disp, VolOp::OPROW), eP(ep), point(point),
337  str(str) {}
338 
339  MoFEMErrorCode doWork(int side, EntityType type,
340  EntitiesFieldData::EntData &data) {
341  MoFEMFunctionBegin;
342  if (type == MBTET) {
343  if (getGaussPts().size2()) {
344 
345  auto t_h = getFTensor2FromMat<3, 3>(eP.dataAtPts->hAtPts);
346  auto t_approx_P =
347  getFTensor2FromMat<3, 3>(eP.dataAtPts->approxPAtPts);
348 
349  FTensor::Index<'i', 3> i;
350  FTensor::Index<'j', 3> j;
351  FTensor::Index<'k', 3> k;
352  const double jac = determinantTensor3by3(t_h);
353  FTensor::Tensor2<double, 3, 3> t_cauchy;
354  t_cauchy(i, j) = (1. / jac) * (t_approx_P(i, k) * t_h(j, k));
355 
356  auto add = [&]() {
357  std::ostringstream s;
358  s << str << " elem " << getFEEntityHandle() << " ";
359  return s.str();
360  };
361 
362  auto print_tensor = [](auto &t) {
363  std::ostringstream s;
364  s << t;
365  return s.str();
366  };
367 
368  std::ostringstream print;
369  MOFEM_LOG("EPSYNC", Sev::inform)
370  << add() << "comm rank " << eP.mField.get_comm_rank();
371  MOFEM_LOG("EPSYNC", Sev::inform)
372  << add() << "point " << getVectorAdaptor(point.data(), 3);
373  MOFEM_LOG("EPSYNC", Sev::inform)
374  << add() << "coords at gauss pts " << getCoordsAtGaussPts();
375  MOFEM_LOG("EPSYNC", Sev::inform)
376  << add() << "w " << eP.dataAtPts->wL2AtPts;
377  MOFEM_LOG("EPSYNC", Sev::inform)
378  << add() << "Piola " << eP.dataAtPts->approxPAtPts;
379  MOFEM_LOG("EPSYNC", Sev::inform)
380  << add() << "Cauchy " << print_tensor(t_cauchy);
381  }
382  }
383  MoFEMFunctionReturn(0);
384  }
385  };
386 
387  if (auto fe_ptr = dataFieldEval->feMethodPtr.lock()) {
388 
389  fe_ptr->getOpPtrVector().push_back(new OpPrint(eP, point, str));
390  CHKERR eP.mField.getInterface<FieldEvaluatorInterface>()
391  ->evalFEAtThePoint3D(point.data(), 1e-12, problemPtr->getName(),
392  "EP", dataFieldEval, eP.mField.get_comm_rank(),
393  eP.mField.get_comm_rank(), nullptr, MF_EXIST,
394  QUIET);
395  fe_ptr->getOpPtrVector().pop_back();
396  }
397 
398  MoFEMFunctionReturn(0);
399  };
400 
401  // Points for Cook beam
402  for (auto &pts : ptsHashMap) {
403  CHKERR post_proc_at_points(pts.second, pts.first);
404  MOFEM_LOG_SEVERITY_SYNC(eP.mField.get_comm(), Sev::inform);
405  }
406 
407  MoFEMFunctionReturn(0);
408  }

◆ preProcess()

MoFEMErrorCode EshelbianMonitor::preProcess ( )
inline

Definition at line 184 of file EshelbianMonitor.cpp.

184 { return 0; }

Member Data Documentation

◆ dataFieldEval

boost::shared_ptr<SetPtsData> EshelbianMonitor::dataFieldEval

Definition at line 17 of file EshelbianMonitor.cpp.

◆ eP

EshelbianCore& EshelbianMonitor::eP

Definition at line 16 of file EshelbianMonitor.cpp.

◆ gEnergy

boost::shared_ptr<double> EshelbianMonitor::gEnergy

Definition at line 19 of file EshelbianMonitor.cpp.

◆ ptsHashMap

PtsHashMap EshelbianMonitor::ptsHashMap

Definition at line 20 of file EshelbianMonitor.cpp.

◆ volPostProcEnergy

boost::shared_ptr<VolEle> EshelbianMonitor::volPostProcEnergy

Definition at line 18 of file EshelbianMonitor.cpp.

The documentation for this struct was generated from the following file:
MoFEMFunctionReturnHot
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:460
MoFEM::UnknownInterface::getInterface
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface reference to pointer of interface.
Definition: UnknownInterface.hpp:93
CHK_MOAB_THROW
#define CHK_MOAB_THROW(err, msg)
Check error code of MoAB function and throw MoFEM exception.
Definition: definitions.h:589
MoFEM::CoreInterface::loop_finite_elements
virtual MoFEMErrorCode loop_finite_elements(const std::string problem_name, const std::string &fe_name, FEMethod &method, boost::shared_ptr< NumeredEntFiniteElement_multiIndex > fe_ptr=nullptr, MoFEMTypes bh=MF_EXIST, CacheTupleWeakPtr cache_ptr=CacheTupleSharedPtr(), int verb=DEFAULT_VERBOSITY)=0
Make a loop over finite elements.
MOFEM_LOG_SEVERITY_SYNC
#define MOFEM_LOG_SEVERITY_SYNC(comm, severity)
Synchronise "SYNC" on curtain severity level.
Definition: LogManager.hpp:352
EshelbianCore::spatialL2Disp
const std::string spatialL2Disp
Definition: EshelbianCore.hpp:102
EshelbianCore::noStretch
static PetscBool noStretch
Definition: EshelbianCore.hpp:18
MoFEM::CoreInterface::get_comm
virtual MPI_Comm & get_comm() const =0
EshelbianMonitor::PtsHashMap
std::map< std::string, std::array< double, 3 > > PtsHashMap
Definition: EshelbianMonitor.cpp:12
CHK_THROW_MESSAGE
#define CHK_THROW_MESSAGE(err, msg)
Check and throw MoFEM exception.
Definition: definitions.h:609
MoFEM::Exceptions::MoFEMErrorCode
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
Definition: Exceptions.hpp:56
MoFEM::Types::MatrixDouble
UBlasMatrix< double > MatrixDouble
Definition: Types.hpp:77
MoFEM::CoreInterface::get_comm_rank
virtual int get_comm_rank() const =0
EshelbianCore::frontVertices
boost::shared_ptr< Range > frontVertices
Definition: EshelbianCore.hpp:287
EshelbianCore::physicalEquations
boost::shared_ptr< PhysicalEquations > physicalEquations
Definition: EshelbianCore.hpp:87
FTensor::Tensor2< double, 3, 3 >
EshelbianMonitor::ptsHashMap
PtsHashMap ptsHashMap
Definition: EshelbianMonitor.cpp:20
CHKERR
#define CHKERR
Inline error check.
Definition: definitions.h:548
EshelbianMonitor::volPostProcEnergy
boost::shared_ptr< VolEle > volPostProcEnergy
Definition: EshelbianMonitor.cpp:18
MoFEM::CoreInterface::get_moab
virtual moab::Interface & get_moab()=0
SPACE_DIM
constexpr int SPACE_DIM
Definition: child_and_parent.cpp:16
EshelbianCore::rotAxis
const std::string rotAxis
Definition: EshelbianCore.hpp:110
MoFEM::getVectorAdaptor
auto getVectorAdaptor(T1 ptr, const size_t n)
Get Vector adaptor.
Definition: Templates.hpp:31
MOFEM_LOG_C
#define MOFEM_LOG_C(channel, severity, format,...)
Definition: LogManager.hpp:311
convert.type
type
Definition: convert.py:64
EshelbianCore::materialH1Positions
const std::string materialH1Positions
Definition: EshelbianCore.hpp:105
EshelbianCore::spatialH1Disp
const std::string spatialH1Disp
Definition: EshelbianCore.hpp:104
EshelbianCore::mField
MoFEM::Interface & mField
Definition: EshelbianCore.hpp:84
EshelbianMonitor::gEnergy
boost::shared_ptr< double > gEnergy
Definition: EshelbianMonitor.cpp:19
t
constexpr double t
plate stiffness
Definition: plate.cpp:58
MoFEM::VolumeElementForcesAndSourcesCore
Volume finite element base.
Definition: VolumeElementForcesAndSourcesCore.hpp:26
i
FTensor::Index< 'i', SPACE_DIM > i
Definition: hcurl_divergence_operator_2d.cpp:27
EshelbianCore::stretchTensor
const std::string stretchTensor
Definition: EshelbianCore.hpp:109
EshelbianMonitor::eP
EshelbianCore & eP
Definition: EshelbianMonitor.cpp:16
MoFEM::VolumeElementForcesAndSourcesCore::UserDataOperator
Definition: VolumeElementForcesAndSourcesCore.hpp:109
EntData
EntitiesFieldData::EntData EntData
Definition: child_and_parent.cpp:37
FTensor::Index< 'i', 3 >
OpCalculateRotationAndSpatialGradient
Definition: EshelbianOperators.hpp:173
MoFEM::determinantTensor3by3
static auto determinantTensor3by3(T &t)
Calculate the determinant of a 3x3 matrix or a tensor of rank 2.
Definition: Templates.hpp:1540
Range
OpCalculateTractionFromSideEl
Definition: EshelbianOperators.hpp:187
MOFEM_LOG
#define MOFEM_LOG(channel, severity)
Log.
Definition: LogManager.hpp:308
_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_
#define _IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(MESHSET_MANAGER, CUBITBCTYPE, IT)
Iterator that loops over a specific Cubit MeshSet having a particular BC meshset in a moFEM field.
Definition: MeshsetsManager.hpp:71
EshelbianCore::postProcessResults
MoFEMErrorCode postProcessResults(const int tag, const std::string file, Vec f_residual=PETSC_NULL, Vec var_vec=PETSC_NULL, std::vector< Tag > tags_to_transfer={})
Definition: EshelbianPlasticity.cpp:3148
EshelbianCore::bubbleField
const std::string bubbleField
Definition: EshelbianCore.hpp:111
EshelbianCore::frontAdjEdges
boost::shared_ptr< Range > frontAdjEdges
Definition: EshelbianCore.hpp:286
BLOCKSET
@ BLOCKSET
Definition: definitions.h:161
j
FTensor::Index< 'j', 3 > j
Definition: matrix_function.cpp:19
approx_order
int approx_order
Definition: test_broken_space.cpp:54
EshelbianCore::skinElement
const std::string skinElement
Definition: EshelbianCore.hpp:115
EshelbianMonitor::VolEle
VolumeElementForcesAndSourcesCore VolEle
Definition: EshelbianMonitor.cpp:9
MoFEM::Exceptions::ierr
static MoFEMErrorCodeGeneric< PetscErrorCode > ierr
Definition: Exceptions.hpp:76
EshelbianCore::piolaStress
const std::string piolaStress
Definition: EshelbianCore.hpp:100
EshelbianMonitor::dataFieldEval
boost::shared_ptr< SetPtsData > dataFieldEval
Definition: EshelbianMonitor.cpp:17
QUIET
@ QUIET
Definition: definitions.h:221
OpCalculateReactionForces
Definition: EshelbianOperators.hpp:204
EshelbianCore::dataAtPts
boost::shared_ptr< DataAtIntegrationPts > dataAtPts
Definition: EshelbianCore.hpp:86
k
FTensor::Index< 'k', 3 > k
Definition: matrix_function.cpp:20
EshelbianCore::solTSStep
SmartPetscObj< Vec > solTSStep
Definition: EshelbianCore.hpp:302
MF_EXIST
@ MF_EXIST
Definition: definitions.h:113
convert.int
int
Definition: convert.py:64
MoFEMFunctionReturn
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:429
OpCalculateVectorFieldGradient
MoFEMFunctionBegin
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:359
MoFEM::PetscOptionsGetBool
PetscErrorCode PetscOptionsGetBool(PetscOptions *, const char pre[], const char name[], PetscBool *bval, PetscBool *set)
Definition: DeprecatedPetsc.hpp:182
EshelbianCore
Definition: EshelbianCore.hpp:12
Generated by Doxygen 1.8.17 and hosted at University of Glasgow