v0.15.0
Loading...
Searching...
No Matches
EshelbianCore.hpp
Go to the documentation of this file.
1/**
2 * @file EshelbianCore.hpp
3 * @author your name (you@domain.com)
4 * @brief
5 * @version 0.1
6 * @date 2024-12-31
7 *
8 * @copyright Copyright (c) 2024
9 *
10 */
11
13
14 static inline enum SymmetrySelector symmetrySelector = NOT_SYMMETRIC;
15 static inline enum RotSelector rotSelector = LARGE_ROT;
16 static inline enum RotSelector gradApproximator = LARGE_ROT;
17 static inline enum StretchSelector stretchSelector = LOG;
18 static inline PetscBool noStretch = PETSC_FALSE; //< no stretch field
19 static inline PetscBool setSingularity = PETSC_TRUE; //< set singularity
20 static inline PetscBool dynamicRelaxation =
21 PETSC_FALSE; //< switch on/off dynamic relaxation
22 static inline PetscBool crackingOn = PETSC_FALSE; //< cracking on
23 static inline double crackingStartTime = 0; //< time when crack starts to grow
24 static inline int nbJIntegralLevels =
25 0; //< number of levels for J integral evaluation
26 static inline double dynamicTime =
27 0; //< true time used when dynamic relaxation is used.
28 static inline int dynamicStep =
29 0; //< true time used when dynamic relaxation is used.
30 static inline PetscBool l2UserBaseScale = PETSC_TRUE; //< scale L2 user base
31 static inline int addCrackMeshsetId = 1000; //< add crack meshset id
32 static inline double griffithEnergy = 1; ///< Griffith energy
33 static inline enum EnergyReleaseSelector energyReleaseSelector =
34 GRIFFITH_SKELETON; //< energy release selector
35 static inline std::string internalStressTagName =
36 ""; //< internal stress tag name
37 static inline int internalStressInterpOrder =
38 1; //< internal stress interpolation order
39 static inline PetscBool internalStressVoigt =
40 PETSC_FALSE; //< internal stress index notation
41
42 static double exponentBase;
43 static boost::function<double(const double)> f;
44 static boost::function<double(const double)> d_f;
45 static boost::function<double(const double)> dd_f;
46 static boost::function<double(const double)> inv_f;
47 static boost::function<double(const double)> inv_d_f;
48 static boost::function<double(const double)> inv_dd_f;
49
50 static inline constexpr bool use_quadratic_exp = true;
51 static inline constexpr double v_max = 12;
52 static inline constexpr double v_min = -v_max;
53
54 static double f_log_e_quadratic(const double v) {
55 if (v > v_max) {
56 double e = static_cast<double>(std::exp(v_max));
57 double dv = v - v_max;
58 return 0.5 * e * dv * dv + e * dv + e;
59 } else {
60 return static_cast<double>(std::exp(v));
61 }
62 }
63
64 static double d_f_log_e_quadratic(const double v) {
65 if (v > v_max) {
66 double e = static_cast<double>(std::exp(v_max));
67 double dv = v - v_max;
68 return e * dv + e;
69 } else {
70 return static_cast<double>(std::exp(v));
71 }
72 }
73
74 static double dd_f_log_e_quadratic(const double v) {
75 if (v > v_max) {
76 return static_cast<double>(std::exp(v_max));
77 } else {
78 return static_cast<double>(std::exp(v));
79 }
80 }
81
82 static double f_log_e(const double v) {
83 if constexpr(use_quadratic_exp) {
84 return f_log_e_quadratic(v);
85 } else {
86 if (v > v_max)
87 // y = exp(v_max) * v + exp(v_max) * (1 - v_max);
88 // y/exp(v_max) = v + (1 - v_max);
89 // y/exp(v_max) - (1 - v_max) = v;
90 return std::exp(v_max) * v + std::exp(v_max) * (1 - v_max);
91 else
92 return std::exp(v);
93 }
94 }
95 static double d_f_log_e(const double v) {
96 if constexpr (use_quadratic_exp) {
97 return d_f_log_e_quadratic(v);
98 } else {
99 if (v > v_max)
100 return std::exp(v_max);
101 else
102 return std::exp(v);
103 }
104 }
105 static double dd_f_log_e(const double v) {
106 if constexpr (use_quadratic_exp) {
107 return dd_f_log_e_quadratic(v);
108 } else {
109 if (v > v_max)
110 return 0.;
111 else
112 return std::exp(v);
113 }
114 }
115 static double inv_f_log_e(const double v) {
116 if (v > std::exp(v_min))
117 return std::log(v);
118 else
119 // y = exp(v_min) * v + exp(v_min) * (1 - v_min);
120 // y/exp(v_min) = v + (1 - v_min);
121 // y/exp(v_min) - (1 - v_min) = v;
122 return v / exp(v_min) - (1 - v_min);
123 }
124 static double inv_d_f_log_e(const double v) {
125 if (v > std::exp(v_min))
126 return 1. / v;
127 else
128 return 1. / exp(v_min);
129 }
130 static double inv_dd_f_log_e(const double v) {
131 if (v > std::exp(v_min))
132 return -1. / (v * v);
133 else
134 return 0.;
135 }
136
137 static double f_log(const double v) {
138 return pow(EshelbianCore::exponentBase, v);
139 }
140 static double d_f_log(const double v) {
141 return pow(exponentBase, v) * log(EshelbianCore::exponentBase);
142 }
143 static double dd_f_log(const double v) {
144 return pow(EshelbianCore::exponentBase, v) *
146 }
147
148 static double inv_f_log(const double v) {
149 return log(v) / log(EshelbianCore::exponentBase);
150 }
151 static double inv_d_f_log(const double v) {
152 return (1. / v) / log(EshelbianCore::exponentBase);
153 }
154 static double inv_dd_f_log(const double v) {
155 return -(1. / (v * v)) / log(EshelbianCore::exponentBase);
156 }
157
158 static double f_linear(const double v) { return v + 1; }
159 static double d_f_linear(const double v) { return 1; }
160 static double dd_f_linear(const double v) { return 0; }
161
162 static double inv_f_linear(const double v) { return v - 1; }
163 static double inv_d_f_linear(const double v) { return 0; }
164 static double inv_dd_f_linear(const double v) { return 0; }
165
166 /**
167 * \brief Getting interface of core database
168 * @param uuid unique ID of interface
169 * @param iface returned pointer to interface
170 * @return error code
171 */
172 MoFEMErrorCode query_interface(boost::typeindex::type_index type_index,
173 UnknownInterface **iface) const;
174
176
177 boost::shared_ptr<DataAtIntegrationPts> dataAtPts;
178 boost::shared_ptr<PhysicalEquations> physicalEquations;
179 boost::shared_ptr<AnalyticalExprPython> AnalyticalExprPythonPtr;
180
181 boost::shared_ptr<VolumeElementForcesAndSourcesCore> elasticFeRhs;
182 boost::shared_ptr<VolumeElementForcesAndSourcesCore> elasticFeLhs;
183 boost::shared_ptr<FaceElementForcesAndSourcesCore> elasticBcLhs;
184 boost::shared_ptr<FaceElementForcesAndSourcesCore> elasticBcRhs;
185 boost::shared_ptr<ContactTree> contactTreeRhs; ///< Make a contact tree
186
187 SmartPetscObj<DM> dM; ///< Coupled problem all fields
188 SmartPetscObj<DM> dmElastic; ///< Elastic problem
189 SmartPetscObj<DM> dmMaterial; ///< Material problem
190 SmartPetscObj<DM> dmPrjSpatial; ///< Projection spatial displacement
191
192 const std::string piolaStress = "P";
193 // const std::string eshelbyStress = "S";
194 const std::string spatialL2Disp = "wL2";
195 // const std::string materialL2Disp = "WL2";
196 const std::string spatialH1Disp = "wH1";
197 const std::string materialH1Positions = "XH1";
198 const std::string hybridSpatialDisp = "hybridSpatialDisp";
199 // const std::string hybridMaterialDisp = "hybridMaterialDisp";
200 const std::string contactDisp = "contactDisp";
201 const std::string stretchTensor = "u";
202 const std::string rotAxis = "omega";
203 const std::string bubbleField = "bubble";
204
205 const std::string elementVolumeName = "EP";
206 const std::string naturalBcElement = "NATURAL_BC";
207 const std::string skinElement = "SKIN";
208 const std::string skeletonElement = "SKELETON";
209 const std::string contactElement = "CONTACT";
210 // const std::string materialVolumeElement = "MEP";
211 // const std::string materialSkeletonElement = "MATERIAL_SKELETON";
212
214 virtual ~EshelbianCore();
215
216 int spaceOrder = 2;
217 int spaceH1Order = -1;
219 double alphaU = 0;
220 double alphaW = 0;
221 double alphaOmega = 0;
222 double alphaRho = 0;
223
224 int contactRefinementLevels = 1; //< refinement levels for contact integration
225 int frontLayers = 3; //< front layers with material element
226
227 MoFEMErrorCode getOptions();
228
229 boost::shared_ptr<BcDispVec> bcSpatialDispVecPtr;
230 boost::shared_ptr<BcRotVec> bcSpatialRotationVecPtr;
231 boost::shared_ptr<TractionBcVec> bcSpatialTractionVecPtr;
232 boost::shared_ptr<TractionFreeBc> bcSpatialFreeTractionVecPtr;
233 boost::shared_ptr<NormalDisplacementBcVec> bcSpatialNormalDisplacementVecPtr;
234 boost::shared_ptr<AnalyticalDisplacementBcVec>
236 boost::shared_ptr<AnalyticalTractionBcVec> bcSpatialAnalyticalTractionVecPtr;
237 boost::shared_ptr<PressureBcVec> bcSpatialPressureVecPtr;
238 boost::shared_ptr<ExternalStrainVec> externalStrainVecPtr;
239
240 std::map<std::string, boost::shared_ptr<ScalingMethod>> timeScaleMap;
241
242 template <typename BC>
243 MoFEMErrorCode getBc(boost::shared_ptr<BC> &bc_vec_ptr,
244 const std::string block_name, const int nb_attributes) {
246 for (auto it :
247 mField.getInterface<MeshsetsManager>()->getCubitMeshsetPtr(std::regex(
248
249 (boost::format("%s(.*)") % block_name).str()
250
251 ))
252
253 ) {
254 std::vector<double> block_attributes;
255 CHKERR it->getAttributes(block_attributes);
256 if (block_attributes.size() < nb_attributes) {
257 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
258 "In block %s expected %d attributes, but given %ld",
259 it->getName().c_str(), nb_attributes, block_attributes.size());
260 }
261 Range faces;
262 CHKERR it->getMeshsetIdEntitiesByDimension(mField.get_moab(), 2, faces,
263 true);
264 bc_vec_ptr->emplace_back(it->getName(), block_attributes, faces);
265 }
267 }
268
269 MoFEMErrorCode getSpatialDispBc();
270
271 inline MoFEMErrorCode getSpatialRotationBc() {
273 bcSpatialRotationVecPtr = boost::make_shared<BcRotVec>();
274 CHKERR getBc(bcSpatialRotationVecPtr, "SPATIAL_ROTATION_BC", 4);
275 CHKERR getBc(bcSpatialRotationVecPtr, "SPATIAL_ROTATION_AXIS_BC", 7);
276
277 auto ts_rotation =
278 boost::make_shared<DynamicRelaxationTimeScale>("rotation_history.txt");
279 for (auto &bc : *bcSpatialRotationVecPtr) {
280 timeScaleMap[bc.blockName] =
281 GetBlockScalingMethod<DynamicRelaxationTimeScale>::get(
282 ts_rotation, "rotation_history", ".txt", bc.blockName);
283 }
284
286 }
287
288 MoFEMErrorCode getSpatialTractionBc();
289
290 /**
291 * @brief Remove all, but entities where kinematic constrains are applied.
292 *
293 * @param meshset
294 * @param bc_ptr
295 * @param disp_block_set_name
296 * @param rot_block_set_name
297 * @param contact_set_name
298 * @return MoFEMErrorCode
299 */
300 MoFEMErrorCode getTractionFreeBc(const EntityHandle meshset,
301 boost::shared_ptr<TractionFreeBc> &bc_ptr,
302 const std::string contact_set_name);
303
304 inline MoFEMErrorCode
307 boost::shared_ptr<TractionFreeBc>(new TractionFreeBc());
308 return getTractionFreeBc(meshset, bcSpatialFreeTractionVecPtr, "CONTACT");
309 }
310
311 MoFEMErrorCode getExternalStrain();
312
313 MoFEMErrorCode createExchangeVectors(Sev sev);
314
315 MoFEMErrorCode addFields(const EntityHandle meshset = 0);
316 MoFEMErrorCode projectGeometry(const EntityHandle meshset = 0);
317
318 MoFEMErrorCode addVolumeFiniteElement(const EntityHandle meshset = 0);
319 MoFEMErrorCode addBoundaryFiniteElement(const EntityHandle meshset = 0);
320 MoFEMErrorCode addDMs(const BitRefLevel bit = BitRefLevel().set(0),
321 const EntityHandle meshset = 0);
322
323 MoFEMErrorCode addMaterial_HMHHStVenantKirchhoff(const int tape,
324 const double lambda,
325 const double mu,
326 const double sigma_y);
327
328 MoFEMErrorCode addMaterial_HMHMooneyRivlin(const int tape, const double alpha,
329 const double beta,
330 const double lambda,
331 const double sigma_y);
332
333 MoFEMErrorCode addMaterial_HMHNeohookean(const int tape, const double c10,
334 const double K);
335
336 MoFEMErrorCode addMaterial_Hencky(double E, double nu);
337
339 const int tag, const bool do_rhs, const bool do_lhs,
340 const bool calc_rates, SmartPetscObj<Vec> ver_vec,
341 boost::shared_ptr<VolumeElementForcesAndSourcesCore> fe);
342
343 MoFEMErrorCode setVolumeElementOps(
344 const int tag, const bool add_elastic, const bool add_material,
345 boost::shared_ptr<VolumeElementForcesAndSourcesCore> &fe_rhs,
346 boost::shared_ptr<VolumeElementForcesAndSourcesCore> &fe_lhs);
347
348 MoFEMErrorCode
349 setFaceElementOps(const bool add_elastic, const bool add_material,
350 boost::shared_ptr<FaceElementForcesAndSourcesCore> &fe_rhs,
351 boost::shared_ptr<FaceElementForcesAndSourcesCore> &fe_lhs);
352
354
355 boost::shared_ptr<ContactTree> &fe_contact_tree
356
357 );
358
359 MoFEMErrorCode setElasticElementOps(const int tag);
360 MoFEMErrorCode setElasticElementToTs(DM dm);
361
362 friend struct solve_elastic_set_up;
363 MoFEMErrorCode solveElastic(TS ts, Vec x);
364 MoFEMErrorCode solveDynamicRelaxation(TS ts, Vec x);
365
366 MoFEMErrorCode setBlockTagsOnSkin();
367
368 MoFEMErrorCode postProcessResults(const int tag, const std::string file,
369 Vec f_residual = PETSC_NULLPTR,
370 Vec var_vec = PETSC_NULLPTR,
371 std::vector<Tag> tags_to_transfer = {});
372 MoFEMErrorCode
373 postProcessSkeletonResults(const int tag, const std::string file,
374 Vec f_residual = PETSC_NULLPTR,
375 std::vector<Tag> tags_to_transfer = {});
376
377 MoFEMErrorCode calculateCrackArea(
378 boost::shared_ptr<double> area_ptr); // calculate crack area
379
380 MoFEMErrorCode gettingNorms();
381
382 struct SetUpSchur {
383 static boost::shared_ptr<SetUpSchur> createSetUpSchur(
384
385 MoFEM::Interface &m_field, EshelbianCore *ep_core_ptr
386
387 );
388 virtual MoFEMErrorCode setUp(TS) = 0;
389
390 protected:
391 SetUpSchur() = default;
392 };
393
395
396 using TimeScale::TimeScale;
397
398 double getScale(const double time) override {
400 return TimeScale::getScale(EshelbianCore::dynamicTime);
401 } else {
402 return TimeScale::getScale(time);
403 }
404 }
405 };
406
407 MoFEMErrorCode calculateFaceMaterialForce(const int tag, TS ts);
408 MoFEMErrorCode calculateOrientation(const int tag, bool set_orientation);
409 MoFEMErrorCode setNewFrontCoordinates();
410 MoFEMErrorCode addCrackSurfaces(const bool debug = false);
411 MoFEMErrorCode saveOrgCoords();
413
414 boost::shared_ptr<Range> contactFaces;
415 boost::shared_ptr<Range> crackFaces;
416 boost::shared_ptr<Range> frontEdges;
417 boost::shared_ptr<Range> frontAdjEdges;
418 boost::shared_ptr<Range> frontVertices;
419 boost::shared_ptr<Range> skeletonFaces;
420 boost::shared_ptr<Range> materialSkeletonFaces;
421 boost::shared_ptr<Range> maxMovedFaces;
422
423 boost::shared_ptr<ParentFiniteElementAdjacencyFunctionSkeleton<2>>
425
426 BitRefLevel bitAdjParent = BitRefLevel().set(); ///< bit ref level for parent
427 BitRefLevel bitAdjParentMask =
428 BitRefLevel().set(); ///< bit ref level for parent parent
429 BitRefLevel bitAdjEnt = BitRefLevel().set(); ///< bit ref level for parent
430 BitRefLevel bitAdjEntMask =
431 BitRefLevel().set(); ///< bit ref level for parent parent
432
433 SmartPetscObj<Vec> solTSStep;
434
435 CommInterface::EntitiesPetscVector volumeExchange;
436 CommInterface::EntitiesPetscVector faceExchange;
437 CommInterface::EntitiesPetscVector edgeExchange;
438 CommInterface::EntitiesPetscVector vertexExchange;
439
440 std::vector<Tag>
441 listTagsToTransfer; ///< list of tags to transfer to postprocessor
442
443 Mat S = PETSC_NULLPTR; //< Schur complement matrix
444 AO aoS = PETSC_NULLPTR; //< AO for Schur complement matrix
445 SmartPetscObj<IS> crackHybridIs; //< IS for crack hybrid field
446 std::vector<std::string> a00FieldList; //< list of fields for Schur complement
447 std::vector<boost::shared_ptr<Range>>
448 a00RangeList; //< list of ranges for Schur complement
449
450 int nbCrackFaces = 0; //< number of crack faces
451};
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
@ MOFEM_DATA_INCONSISTENCY
Definition definitions.h:31
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
#define CHKERR
Inline error check.
static const bool debug
auto bit
set bit
static double lambda
const double v
phase velocity of light in medium (cm/ns)
double getScale(const double time) override
virtual MoFEMErrorCode setUp(TS)=0
static boost::shared_ptr< SetUpSchur > createSetUpSchur(MoFEM::Interface &m_field, EshelbianCore *ep_core_ptr)
std::vector< boost::shared_ptr< Range > > a00RangeList
MoFEMErrorCode setElasticElementOps(const int tag)
boost::shared_ptr< ExternalStrainVec > externalStrainVecPtr
MoFEMErrorCode addVolumeFiniteElement(const EntityHandle meshset=0)
MoFEMErrorCode addFields(const EntityHandle meshset=0)
boost::shared_ptr< Range > materialSkeletonFaces
static constexpr bool use_quadratic_exp
static enum StretchSelector stretchSelector
boost::shared_ptr< Range > frontAdjEdges
MoFEMErrorCode createCrackSurfaceMeshset()
MoFEMErrorCode addBoundaryFiniteElement(const EntityHandle meshset=0)
const std::string skeletonElement
static double inv_f_linear(const double v)
MoFEMErrorCode getSpatialRotationBc()
boost::shared_ptr< TractionBcVec > bcSpatialTractionVecPtr
boost::shared_ptr< Range > contactFaces
static double dd_f_log_e_quadratic(const double v)
static double dynamicTime
static double dd_f_log(const double v)
BitRefLevel bitAdjEnt
bit ref level for parent
MoFEM::Interface & mField
static constexpr double v_max
const std::string spatialL2Disp
static double inv_d_f_log(const double v)
std::map< std::string, boost::shared_ptr< ScalingMethod > > timeScaleMap
MoFEMErrorCode addMaterial_Hencky(double E, double nu)
friend struct solve_elastic_set_up
static PetscBool l2UserBaseScale
SmartPetscObj< DM > dM
Coupled problem all fields.
boost::shared_ptr< FaceElementForcesAndSourcesCore > elasticBcRhs
static int internalStressInterpOrder
SmartPetscObj< IS > crackHybridIs
MoFEMErrorCode projectGeometry(const EntityHandle meshset=0)
boost::shared_ptr< TractionFreeBc > bcSpatialFreeTractionVecPtr
const std::string materialH1Positions
MoFEMErrorCode setBlockTagsOnSkin()
std::vector< Tag > listTagsToTransfer
list of tags to transfer to postprocessor
boost::shared_ptr< FaceElementForcesAndSourcesCore > elasticBcLhs
static PetscBool crackingOn
MoFEMErrorCode addMaterial_HMHHStVenantKirchhoff(const int tape, const double lambda, const double mu, const double sigma_y)
MoFEMErrorCode addMaterial_HMHMooneyRivlin(const int tape, const double alpha, const double beta, const double lambda, const double sigma_y)
MoFEMErrorCode getTractionFreeBc(const EntityHandle meshset, boost::shared_ptr< TractionFreeBc > &bc_ptr, const std::string contact_set_name)
Remove all, but entities where kinematic constrains are applied.
MoFEMErrorCode setBaseVolumeElementOps(const int tag, const bool do_rhs, const bool do_lhs, const bool calc_rates, SmartPetscObj< Vec > ver_vec, boost::shared_ptr< VolumeElementForcesAndSourcesCore > fe)
MoFEMErrorCode calculateFaceMaterialForce(const int tag, TS ts)
static double griffithEnergy
Griffith energy.
MoFEMErrorCode calculateCrackArea(boost::shared_ptr< double > area_ptr)
boost::shared_ptr< VolumeElementForcesAndSourcesCore > elasticFeRhs
static int dynamicStep
const std::string elementVolumeName
static double dd_f_log_e(const double v)
static enum RotSelector rotSelector
static enum RotSelector gradApproximator
MoFEMErrorCode getBc(boost::shared_ptr< BC > &bc_vec_ptr, const std::string block_name, const int nb_attributes)
CommInterface::EntitiesPetscVector vertexExchange
boost::shared_ptr< BcRotVec > bcSpatialRotationVecPtr
boost::shared_ptr< Range > maxMovedFaces
static PetscBool dynamicRelaxation
const std::string spatialH1Disp
MoFEMErrorCode solveElastic(TS ts, Vec x)
static double d_f_log(const double v)
boost::shared_ptr< NormalDisplacementBcVec > bcSpatialNormalDisplacementVecPtr
static double crackingStartTime
MoFEMErrorCode getOptions()
const std::string piolaStress
MoFEMErrorCode setElasticElementToTs(DM dm)
static double inv_d_f_log_e(const double v)
MoFEMErrorCode gettingNorms()
std::vector< std::string > a00FieldList
MoFEMErrorCode setVolumeElementOps(const int tag, const bool add_elastic, const bool add_material, boost::shared_ptr< VolumeElementForcesAndSourcesCore > &fe_rhs, boost::shared_ptr< VolumeElementForcesAndSourcesCore > &fe_lhs)
MoFEMErrorCode query_interface(boost::typeindex::type_index type_index, UnknownInterface **iface) const
Getting interface of core database.
const std::string bubbleField
MoFEMErrorCode solveDynamicRelaxation(TS ts, Vec x)
boost::shared_ptr< AnalyticalDisplacementBcVec > bcSpatialAnalyticalDisplacementVecPtr
SmartPetscObj< DM > dmMaterial
Material problem.
MoFEMErrorCode calculateOrientation(const int tag, bool set_orientation)
static double inv_f_log(const double v)
boost::shared_ptr< VolumeElementForcesAndSourcesCore > elasticFeLhs
static PetscBool noStretch
MoFEMErrorCode setNewFrontCoordinates()
boost::shared_ptr< ParentFiniteElementAdjacencyFunctionSkeleton< 2 > > parentAdjSkeletonFunctionDim2
boost::shared_ptr< ContactTree > contactTreeRhs
Make a contact tree.
static double exponentBase
MoFEMErrorCode setContactElementRhsOps(boost::shared_ptr< ContactTree > &fe_contact_tree)
static double dd_f_linear(const double v)
MoFEMErrorCode setFaceElementOps(const bool add_elastic, const bool add_material, boost::shared_ptr< FaceElementForcesAndSourcesCore > &fe_rhs, boost::shared_ptr< FaceElementForcesAndSourcesCore > &fe_lhs)
MoFEMErrorCode postProcessSkeletonResults(const int tag, const std::string file, Vec f_residual=PETSC_NULLPTR, std::vector< Tag > tags_to_transfer={})
boost::shared_ptr< AnalyticalExprPython > AnalyticalExprPythonPtr
static boost::function< double(const double)> d_f
boost::shared_ptr< Range > skeletonFaces
boost::shared_ptr< PhysicalEquations > physicalEquations
static boost::function< double(const double)> f
const std::string rotAxis
static double inv_d_f_linear(const double v)
BitRefLevel bitAdjParentMask
bit ref level for parent parent
static double inv_dd_f_log(const double v)
const std::string contactDisp
static std::string internalStressTagName
static enum SymmetrySelector symmetrySelector
CommInterface::EntitiesPetscVector edgeExchange
SmartPetscObj< DM > dmPrjSpatial
Projection spatial displacement.
static boost::function< double(const double)> inv_d_f
boost::shared_ptr< BcDispVec > bcSpatialDispVecPtr
static boost::function< double(const double)> inv_f
const std::string skinElement
static PetscBool internalStressVoigt
static double inv_dd_f_linear(const double v)
MoFEMErrorCode getSpatialTractionFreeBc(const EntityHandle meshset=0)
static double inv_dd_f_log_e(const double v)
MoFEMErrorCode getExternalStrain()
MoFEMErrorCode getSpatialTractionBc()
static PetscBool setSingularity
static double d_f_log_e(const double v)
boost::shared_ptr< AnalyticalTractionBcVec > bcSpatialAnalyticalTractionVecPtr
static double f_log_e_quadratic(const double v)
static int nbJIntegralLevels
MoFEMErrorCode addCrackSurfaces(const bool debug=false)
MoFEMErrorCode addDMs(const BitRefLevel bit=BitRefLevel().set(0), const EntityHandle meshset=0)
MoFEMErrorCode getSpatialDispBc()
BitRefLevel bitAdjParent
bit ref level for parent
MoFEMErrorCode postProcessResults(const int tag, const std::string file, Vec f_residual=PETSC_NULLPTR, Vec var_vec=PETSC_NULLPTR, std::vector< Tag > tags_to_transfer={})
static double d_f_log_e_quadratic(const double v)
CommInterface::EntitiesPetscVector volumeExchange
MoFEMErrorCode saveOrgCoords()
const std::string naturalBcElement
static double f_log_e(const double v)
static constexpr double v_min
virtual ~EshelbianCore()
static int addCrackMeshsetId
static double inv_f_log_e(const double v)
MoFEMErrorCode createExchangeVectors(Sev sev)
boost::shared_ptr< DataAtIntegrationPts > dataAtPts
boost::shared_ptr< Range > crackFaces
boost::shared_ptr< Range > frontVertices
static enum EnergyReleaseSelector energyReleaseSelector
MoFEMErrorCode addMaterial_HMHNeohookean(const int tape, const double c10, const double K)
boost::shared_ptr< PressureBcVec > bcSpatialPressureVecPtr
static double d_f_linear(const double v)
const std::string hybridSpatialDisp
SmartPetscObj< Vec > solTSStep
static double f_log(const double v)
CommInterface::EntitiesPetscVector faceExchange
SmartPetscObj< DM > dmElastic
Elastic problem.
static boost::function< double(const double)> inv_dd_f
EshelbianCore(MoFEM::Interface &m_field)
boost::shared_ptr< Range > frontEdges
static boost::function< double(const double)> dd_f
const std::string stretchTensor
BitRefLevel bitAdjEntMask
bit ref level for parent parent
static double f_linear(const double v)
const std::string contactElement
virtual moab::Interface & get_moab()=0
Deprecated interface functions.
base class for all interface classes
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface reference to pointer of interface.