v0.14.0
Loading...
Searching...
No Matches
Classes | Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | List of all members
EshelbianPlasticity::EshelbianCore Struct Reference

#include <users_modules/eshelbian_plasticty/src/EshelbianPlasticity.hpp>

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

Classes

struct  SetUpSchur
 

Public Member Functions

MoFEMErrorCode query_interface (boost::typeindex::type_index type_index, UnknownInterface **iface) const
 Getting interface of core database. More...
 
 EshelbianCore (MoFEM::Interface &m_field)
 
virtual ~EshelbianCore ()
 
MoFEMErrorCode getOptions ()
 
template<typename BC >
MoFEMErrorCode getBc (boost::shared_ptr< BC > &bc_vec_ptr, const std::string block_name, const int nb_attributes)
 
MoFEMErrorCode getSpatialDispBc ()
 [Getting norms] More...
 
MoFEMErrorCode getSpatialRotationBc ()
 
MoFEMErrorCode getSpatialTractionBc ()
 
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. More...
 
MoFEMErrorCode getSpatialTractionFreeBc (const EntityHandle meshset=0)
 
MoFEMErrorCode addFields (const EntityHandle meshset=0)
 
MoFEMErrorCode addVolumeFiniteElement (const EntityHandle meshset=0)
 
MoFEMErrorCode addBoundaryFiniteElement (const EntityHandle meshset=0)
 
MoFEMErrorCode addDMs (const BitRefLevel bit=BitRefLevel().set(0))
 
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 addMaterial_Hencky (double E, double nu)
 
MoFEMErrorCode setBaseVolumeElementOps (const int tag, const bool do_rhs, const bool do_lhs, boost::shared_ptr< VolumeElementForcesAndSourcesCore > &fe)
 
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 setFaceElementOps (const bool add_elastic, const bool add_material, boost::shared_ptr< FaceElementForcesAndSourcesCore > &fe_rhs, boost::shared_ptr< FaceElementForcesAndSourcesCore > &fe_lhs)
 
MoFEMErrorCode setContactElementOps (boost::shared_ptr< ContactTree > &fe_contact_tree, boost::shared_ptr< FaceElementForcesAndSourcesCore > &fe_rhs, boost::shared_ptr< FaceElementForcesAndSourcesCore > &fe_lhs)
 
MoFEMErrorCode setElasticElementOps (const int tag)
 
MoFEMErrorCode setElasticElementToTs (DM dm)
 
MoFEMErrorCode solveElastic (TS ts, Mat m, Vec f, Vec x)
 
MoFEMErrorCode postProcessResults (const int tag, const std::string file)
 
MoFEMErrorCode gettingNorms ()
 [Getting norms] More...
 
- Public Member Functions inherited from MoFEM::UnknownInterface
virtual MoFEMErrorCode query_interface (boost::typeindex::type_index type_index, UnknownInterface **iface) const =0
 
template<class IFACE >
MoFEMErrorCode registerInterface (bool error_if_registration_failed=true)
 Register interface. More...
 
template<class IFACE >
MoFEMErrorCode getInterface (IFACE *&iface) const
 Get interface refernce to pointer of interface. More...
 
template<class IFACE >
MoFEMErrorCode getInterface (IFACE **const iface) const
 Get interface pointer to pointer of interface. More...
 
template<class IFACE , typename boost::enable_if< boost::is_pointer< IFACE >, int >::type = 0>
IFACE getInterface () const
 Get interface pointer to pointer of interface. More...
 
template<class IFACE , typename boost::enable_if< boost::is_reference< IFACE >, int >::type = 0>
IFACE getInterface () const
 Get reference to interface. More...
 
template<class IFACE >
IFACE * getInterface () const
 Function returning pointer to interface. More...
 
virtual ~UnknownInterface ()=default
 

Static Public Member Functions

static double f_log (const double v)
 
static double d_f_log (const double v)
 
static double dd_f_log (const double v)
 
static double inv_f_log (const double v)
 
static double inv_d_f_log (const double v)
 
static double inv_dd_f_log (const double v)
 
static double f_linear (const double v)
 
static double d_f_linear (const double v)
 
static double dd_f_linear (const double v)
 
static double inv_f_linear (const double v)
 
static double inv_d_f_linear (const double v)
 
static double inv_dd_f_linear (const double v)
 
- Static Public Member Functions inherited from MoFEM::UnknownInterface
static MoFEMErrorCode getLibVersion (Version &version)
 Get library version. More...
 
static MoFEMErrorCode getFileVersion (moab::Interface &moab, Version &version)
 Get database major version. More...
 
static MoFEMErrorCode setFileVersion (moab::Interface &moab, Version version=Version(MoFEM_VERSION_MAJOR, MoFEM_VERSION_MINOR, MoFEM_VERSION_BUILD))
 Get database major version. More...
 
static MoFEMErrorCode getInterfaceVersion (Version &version)
 Get database major version. More...
 

Public Attributes

MoFEM::InterfacemField
 
boost::shared_ptr< DataAtIntegrationPtsdataAtPts
 
boost::shared_ptr< PhysicalEquationsphysicalEquations
 
boost::shared_ptr< VolumeElementForcesAndSourcesCore > elasticFeRhs
 
boost::shared_ptr< VolumeElementForcesAndSourcesCore > elasticFeLhs
 
boost::shared_ptr< FaceElementForcesAndSourcesCoreelasticBcLhs
 
boost::shared_ptr< FaceElementForcesAndSourcesCoreelasticBcRhs
 
boost::shared_ptr< FaceElementForcesAndSourcesCorecontactRhs
 
boost::shared_ptr< ContactTreecontactTreeRhs
 Make a contact treee. More...
 
SmartPetscObj< DM > dM
 Coupled problem all fields. More...
 
SmartPetscObj< DM > dmElastic
 Elastic problem. More...
 
SmartPetscObj< DM > dmPrjSpatial
 Projection spatial displacement. More...
 
const std::string piolaStress
 
const std::string eshelbyStress
 
const std::string spatialL2Disp
 
const std::string spatialH1Disp
 
const std::string materialL2Disp
 
const std::string stretchTensor
 
const std::string rotAxis
 
const std::string materialGradient
 
const std::string tauField
 
const std::string lambdaField
 
const std::string bubbleField
 
const std::string elementVolumeName
 
const std::string naturalBcElement
 
const std::string essentialBcElement
 
const std::string skinElement
 
const std::string contactElement
 
int spaceOrder
 
int spaceH1Order
 
int materialOrder
 
double alphaU
 
double alphaW
 
double alphaRho
 
double precEps
 
double precEpsOmega
 
double precEpsW
 
boost::shared_ptr< BcDispVecbcSpatialDispVecPtr
 
boost::shared_ptr< BcRotVecbcSpatialRotationVecPtr
 
boost::shared_ptr< TractionBcVecbcSpatialTraction
 
boost::shared_ptr< TractionFreeBcbcSpatialFreeTraction
 

Static Public Attributes

static enum RotSelector rotSelector
 
static enum RotSelector gradApperoximator
 
static enum StretchSelector stretchSelector
 
static double exponentBase = exp(1)
 
static boost::function< double(const double)> f = EshelbianCore::f_log
 
static boost::function< double(const double)> d_f
 
static boost::function< double(const double)> dd_f
 
static boost::function< double(const double)> inv_f
 
static boost::function< double(const double)> inv_d_f
 
static boost::function< double(const double)> inv_dd_f
 

Detailed Description

Examples
ep.cpp.

Definition at line 823 of file EshelbianPlasticity.hpp.

Constructor & Destructor Documentation

◆ EshelbianCore()

EshelbianPlasticity::EshelbianCore::EshelbianCore ( MoFEM::Interface m_field)
Examples
EshelbianPlasticity.cpp.

Definition at line 91 of file EshelbianPlasticity.cpp.

92 : mField(m_field), piolaStress("P"), eshelbyStress("S"),
93 spatialL2Disp("wL2"), spatialH1Disp("wH1"), materialL2Disp("W"),
94 stretchTensor("u"), rotAxis("omega"), materialGradient("G"),
95 tauField("TAU"), lambdaField("LAMBDA"), bubbleField("BUBBLE"),
96 elementVolumeName("EP"), naturalBcElement("NATURAL_BC"),
97 essentialBcElement("ESSENTIAL_BC"), skinElement("SKIN_ELEMENT"),
98 contactElement("CONTACT_ELEMENT") {
99
100 ierr = getOptions();
101 CHKERRABORT(PETSC_COMM_WORLD, ierr);
102}
static MoFEMErrorCodeGeneric< PetscErrorCode > ierr
Definition: Exceptions.hpp:76

◆ ~EshelbianCore()

EshelbianPlasticity::EshelbianCore::~EshelbianCore ( )
virtualdefault

Member Function Documentation

◆ addBoundaryFiniteElement()

MoFEMErrorCode EshelbianPlasticity::EshelbianCore::addBoundaryFiniteElement ( const EntityHandle  meshset = 0)
Examples
ep.cpp.

Definition at line 396 of file EshelbianPlasticity.cpp.

396 {
398
399 auto bc_elements_add_to_range = [&](const std::string block_name, Range &r) {
401
402 auto mesh_mng = mField.getInterface<MeshsetsManager>();
403 auto bcs = mesh_mng->getCubitMeshsetPtr(
404
405 std::regex((boost::format("%s(.*)") % block_name).str())
406
407 );
408
409 for (auto bc : bcs) {
410 Range faces;
411 CHKERR bc->getMeshsetIdEntitiesByDimension(mField.get_moab(), 2, faces,
412 true);
413 r.merge(faces);
414 }
415
417 };
418
419 // set finite element fields
420 auto add_field_to_fe = [this](const std::string fe,
421 const std::string field_name) {
427 };
428
429 Range natural_bc_elements;
431 for (auto &v : *bcSpatialDispVecPtr) {
432 natural_bc_elements.merge(v.faces);
433 }
434 }
436 for (auto &v : *bcSpatialRotationVecPtr) {
437 natural_bc_elements.merge(v.faces);
438 }
439 }
440 Range essentail_bc_elements;
441 if (bcSpatialTraction) {
442 for (auto &v : *bcSpatialTraction) {
443 essentail_bc_elements.merge(v.faces);
444 }
445 }
446
448 CHKERR mField.add_ents_to_finite_element_by_type(natural_bc_elements, MBTRI,
450 CHKERR add_field_to_fe(naturalBcElement, piolaStress);
451 // CHKERR add_field_to_fe(naturalBcElement, eshelbyStress);
453
455 CHKERR mField.add_ents_to_finite_element_by_type(essentail_bc_elements, MBTRI,
457 CHKERR add_field_to_fe(essentialBcElement, piolaStress);
458 // CHKERR add_field_to_fe(essentialBcElement, eshelbyStress);
460
461 auto get_skin = [&]() {
462 Range body_ents;
463 CHKERR mField.get_moab().get_entities_by_dimension(0, SPACE_DIM, body_ents);
464 Skinner skin(&mField.get_moab());
465 Range skin_ents;
466 CHKERR skin.find_skin(0, body_ents, false, skin_ents);
467 return skin_ents;
468 };
469
470 auto filter_true_skin = [&](auto &&skin) {
471 Range boundary_ents;
472 ParallelComm *pcomm =
473 ParallelComm::get_pcomm(&mField.get_moab(), MYPCOMM_INDEX);
474 CHKERR pcomm->filter_pstatus(skin, PSTATUS_SHARED | PSTATUS_MULTISHARED,
475 PSTATUS_NOT, -1, &boundary_ents);
476 return boundary_ents;
477 };
478
479 auto skin = filter_true_skin(get_skin());
480
483 CHKERR add_field_to_fe(skinElement, piolaStress);
484 CHKERR add_field_to_fe(skinElement, spatialH1Disp);
485 // CHKERR add_field_to_fe(skinElement, eshelbyStress);
487
488 Range contact_range;
489 CHKERR bc_elements_add_to_range("CONTACT", contact_range);
490 MOFEM_LOG("EP", Sev::inform) << "Contact elements " << contact_range.size();
491
495 CHKERR add_field_to_fe(contactElement, piolaStress);
497
499}
constexpr int SPACE_DIM
@ MF_ZERO
Definition: definitions.h:98
#define MYPCOMM_INDEX
default communicator number PCOMM
Definition: definitions.h:215
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:346
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:416
#define CHKERR
Inline error check.
Definition: definitions.h:535
virtual MoFEMErrorCode add_finite_element(const std::string &fe_name, enum MoFEMTypes bh=MF_EXCL, int verb=DEFAULT_VERBOSITY)=0
add finite element
virtual MoFEMErrorCode build_finite_elements(int verb=DEFAULT_VERBOSITY)=0
Build finite elements.
virtual MoFEMErrorCode modify_finite_element_add_field_col(const std::string &fe_name, const std::string name_row)=0
set field col which finite element use
virtual MoFEMErrorCode add_ents_to_finite_element_by_type(const EntityHandle entities, const EntityType type, const std::string &name, const bool recursive=true)=0
add entities to finite element
virtual MoFEMErrorCode modify_finite_element_add_field_data(const std::string &fe_name, const std::string name_filed)=0
set finite element field data
virtual MoFEMErrorCode modify_finite_element_add_field_row(const std::string &fe_name, const std::string name_row)=0
set field row which finite element use
#define MOFEM_LOG(channel, severity)
Log.
Definition: LogManager.hpp:308
MoFEMErrorCode getCubitMeshsetPtr(const int ms_id, const CubitBCType cubit_bc_type, const CubitMeshSets **cubit_meshset_ptr) const
get cubit meshset
const double v
phase velocity of light in medium (cm/ns)
int r
Definition: sdf.py:8
constexpr auto field_name
boost::shared_ptr< BcRotVec > bcSpatialRotationVecPtr
boost::shared_ptr< BcDispVec > bcSpatialDispVecPtr
boost::shared_ptr< TractionBcVec > bcSpatialTraction
virtual moab::Interface & get_moab()=0
Interface for managing meshsets containing materials and boundary conditions.
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface refernce to pointer of interface.

◆ addDMs()

MoFEMErrorCode EshelbianPlasticity::EshelbianCore::addDMs ( const BitRefLevel  bit = BitRefLevel().set(0))
Examples
ep.cpp.

Definition at line 501 of file EshelbianPlasticity.cpp.

501 {
503
504 // find adjacencies between finite elements and dofs
506
507 // Create coupled problem
508 dM = createDM(mField.get_comm(), "DMMOFEM");
509 CHKERR DMMoFEMCreateMoFEM(dM, &mField, "ESHELBY_PLASTICITY", bit,
510 BitRefLevel().set());
512 CHKERR DMMoFEMSetIsPartitioned(dM, PETSC_TRUE);
518 mField.getInterface<ProblemsManager>()->buildProblemFromFields = PETSC_TRUE;
519 CHKERR DMSetUp(dM);
520 mField.getInterface<ProblemsManager>()->buildProblemFromFields = PETSC_FALSE;
521
522 auto remove_dofs_on_essential_spatial_stress_boundary =
523 [&](const std::string prb_name) {
525 for (int d : {0, 1, 2})
527 prb_name, piolaStress, (*bcSpatialFreeTraction)[d], d, d, 0,
530 };
531 CHKERR remove_dofs_on_essential_spatial_stress_boundary("ESHELBY_PLASTICITY");
532
533 // Create elastic sub-problem
534 dmElastic = createDM(mField.get_comm(), "DMMOFEM");
535 CHKERR DMMoFEMCreateSubDM(dmElastic, dM, "ELASTIC_PROBLEM");
549 CHKERR DMSetUp(dmElastic);
550
551 CHKERR mField.getInterface<ProblemsManager>()->addFieldToEmptyFieldBlocks(
552 "ELASTIC_PROBLEM", spatialL2Disp, stretchTensor);
553 CHKERR mField.getInterface<ProblemsManager>()->addFieldToEmptyFieldBlocks(
554 "ELASTIC_PROBLEM", stretchTensor, spatialL2Disp);
555 CHKERR mField.getInterface<ProblemsManager>()->addFieldToEmptyFieldBlocks(
556 "ELASTIC_PROBLEM", spatialL2Disp, rotAxis);
557 CHKERR mField.getInterface<ProblemsManager>()->addFieldToEmptyFieldBlocks(
558 "ELASTIC_PROBLEM", rotAxis, spatialL2Disp);
559 CHKERR mField.getInterface<ProblemsManager>()->addFieldToEmptyFieldBlocks(
560 "ELASTIC_PROBLEM", spatialL2Disp, bubbleField);
561 CHKERR mField.getInterface<ProblemsManager>()->addFieldToEmptyFieldBlocks(
562 "ELASTIC_PROBLEM", bubbleField, spatialL2Disp);
563 CHKERR mField.getInterface<ProblemsManager>()->addFieldToEmptyFieldBlocks(
564 "ELASTIC_PROBLEM", bubbleField, bubbleField);
565 // CHKERR mField.getInterface<ProblemsManager>()->addFieldToEmptyFieldBlocks(
566 // "ELASTIC_PROBLEM", piolaStress, piolaStress);
567 CHKERR mField.getInterface<ProblemsManager>()->addFieldToEmptyFieldBlocks(
568 "ELASTIC_PROBLEM", bubbleField, piolaStress);
569 CHKERR mField.getInterface<ProblemsManager>()->addFieldToEmptyFieldBlocks(
570 "ELASTIC_PROBLEM", piolaStress, bubbleField);
571 {
572 PetscSection section;
573 CHKERR mField.getInterface<ISManager>()->sectionCreate("ELASTIC_PROBLEM",
574 &section);
575 CHKERR DMSetSection(dmElastic, section);
576 CHKERR DMSetGlobalSection(dmElastic, section);
577 CHKERR PetscSectionDestroy(&section);
578 }
579
580 dmPrjSpatial = createDM(mField.get_comm(), "DMMOFEM");
581 CHKERR DMMoFEMCreateSubDM(dmPrjSpatial, dM, "PROJECT_SPATIAL");
587 CHKERR DMSetUp(dmPrjSpatial);
588
590 ->pushMarkDOFsOnEntities<DisplacementCubitBcData>(
591 "PROJECT_SPATIAL", spatialH1Disp, true, false);
592
594}
@ QUIET
Definition: definitions.h:208
@ NOISY
Definition: definitions.h:211
#define MAX_DOFS_ON_ENTITY
Maximal number of DOFs on entity.
Definition: definitions.h:236
PetscErrorCode DMMoFEMSetIsPartitioned(DM dm, PetscBool is_partitioned)
Definition: DMMoFEM.cpp:1109
PetscErrorCode DMMoFEMCreateSubDM(DM subdm, DM dm, const char problem_name[])
Must be called by user to set Sub DM MoFEM data structures.
Definition: DMMoFEM.cpp:219
PetscErrorCode DMMoFEMAddElement(DM dm, std::string fe_name)
add element to dm
Definition: DMMoFEM.cpp:483
PetscErrorCode DMMoFEMSetSquareProblem(DM dm, PetscBool square_problem)
set squared problem
Definition: DMMoFEM.cpp:442
PetscErrorCode DMMoFEMCreateMoFEM(DM dm, MoFEM::Interface *m_field_ptr, const char problem_name[], const MoFEM::BitRefLevel bit_level, const MoFEM::BitRefLevel bit_mask=MoFEM::BitRefLevel().set())
Must be called by user to set MoFEM data structures.
Definition: DMMoFEM.cpp:118
PetscErrorCode DMMoFEMAddSubFieldRow(DM dm, const char field_name[])
Definition: DMMoFEM.cpp:242
MoFEMErrorCode removeDofsOnEntities(const std::string problem_name, const std::string field_name, const Range ents, const int lo_coeff=0, const int hi_coeff=MAX_DOFS_ON_ENTITY, const int lo_order=0, const int hi_order=100, int verb=VERBOSE, const bool debug=false)
Remove DOFs from problem.
auto bit
set bit
const Tensor1_Expr< const dTensor0< T, Dim, i >, typename promote< T, double >::V, Dim, i > d(const Tensor0< T * > &a, const Index< i, Dim > index, const Tensor1< int, Dim > &d_ijk, const Tensor1< double, Dim > &d_xyz)
Definition: dTensor0.hpp:27
std::bitset< BITREFLEVEL_SIZE > BitRefLevel
Bit structure attached to each entity identifying to what mesh entity is attached.
Definition: Types.hpp:40
PetscErrorCode DMMoFEMSetDestroyProblem(DM dm, PetscBool destroy_problem)
Definition: DMMoFEM.cpp:424
auto createDM(MPI_Comm comm, const std::string dm_type_name)
Creates smart DM object.
SmartPetscObj< DM > dM
Coupled problem all fields.
SmartPetscObj< DM > dmElastic
Elastic problem.
boost::shared_ptr< TractionFreeBc > bcSpatialFreeTraction
SmartPetscObj< DM > dmPrjSpatial
Projection spatial displacement.
Simple interface for fast problem set-up.
Definition: BcManager.hpp:25
virtual MoFEMErrorCode build_adjacencies(const Range &ents, int verb=DEFAULT_VERBOSITY)=0
build adjacencies
virtual MPI_Comm & get_comm() const =0
Section manager is used to create indexes and sections.
Definition: ISManager.hpp:23
Problem manager is used to build and partition problems.

◆ addFields()

MoFEMErrorCode EshelbianPlasticity::EshelbianCore::addFields ( const EntityHandle  meshset = 0)
Examples
ep.cpp.

Definition at line 223 of file EshelbianPlasticity.cpp.

223 {
225
226 Range tets;
227 CHKERR mField.get_moab().get_entities_by_type(meshset, MBTET, tets);
228 Range tets_skin_part;
229 Skinner skin(&mField.get_moab());
230 CHKERR skin.find_skin(0, tets, false, tets_skin_part);
231 ParallelComm *pcomm =
232 ParallelComm::get_pcomm(&mField.get_moab(), MYPCOMM_INDEX);
233 Range tets_skin;
234 CHKERR pcomm->filter_pstatus(tets_skin_part,
235 PSTATUS_SHARED | PSTATUS_MULTISHARED,
236 PSTATUS_NOT, -1, &tets_skin);
237
239 for (auto &v : *bcSpatialDispVecPtr) {
240 tets_skin = subtract(tets_skin, v.faces);
241 }
243 for (auto &v : *bcSpatialRotationVecPtr) {
244 tets_skin = subtract(tets_skin, v.faces);
245 }
247 for (auto &v : *bcSpatialTraction) {
248 tets_skin = subtract(tets_skin, v.faces);
249 }
250
251 auto subtract_faces_where_displacements_are_applied =
252 [&](const std::string block_name) {
254 auto msh_mng = mField.getInterface<MeshsetsManager>();
255 auto reg_exp = std::regex((boost::format("%s(.*)") % block_name).str());
256 for (auto m : msh_mng->getCubitMeshsetPtr(reg_exp)) {
257 Range faces;
258 CHKERR m->getMeshsetIdEntitiesByDimension(mField.get_moab(),
259 SPACE_DIM - 1, faces, true);
260 tets_skin = subtract(tets_skin, faces);
261 MOFEM_LOG("EP", Sev::inform)
262 << "Subtracting " << m->getName() << " " << faces.size();
263 }
265 };
266 CHKERR subtract_faces_where_displacements_are_applied("CONTACT");
267
268 Range faces;
269 CHKERR mField.get_moab().get_adjacencies(tets, 2, true, faces,
270 moab::Interface::UNION);
271 Range faces_not_on_the_skin = subtract(faces, tets_skin);
272
273 auto add_hdiv_field = [&](const std::string field_name, const int order,
274 const int dim) {
277 MB_TAG_SPARSE, MF_ZERO);
279 CHKERR mField.set_field_order(meshset, MBTET, field_name, order);
280 CHKERR mField.set_field_order(faces_not_on_the_skin, field_name, order);
283 };
284
285 auto add_l2_field = [this, meshset](const std::string field_name,
286 const int order, const int dim) {
289 MB_TAG_DENSE, MF_ZERO);
291 CHKERR mField.set_field_order(meshset, MBTET, field_name, order);
293 };
294
295 auto add_h1_field = [this, meshset](const std::string field_name,
296 const int order, const int dim) {
299 MB_TAG_DENSE, MF_ZERO);
301 CHKERR mField.set_field_order(meshset, MBVERTEX, field_name, 1);
302 CHKERR mField.set_field_order(meshset, MBEDGE, field_name, order);
303 CHKERR mField.set_field_order(meshset, MBTRI, field_name, order);
304 CHKERR mField.set_field_order(meshset, MBTET, field_name, order);
306 };
307
308 auto add_bubble_field = [this, meshset](const std::string field_name,
309 const int order, const int dim) {
312 MF_ZERO);
313 // Modify field
314 auto field_ptr = mField.get_field_structure(field_name);
315 auto field_order_table =
316 const_cast<Field *>(field_ptr)->getFieldOrderTable();
317 auto get_cgg_bubble_order_zero = [](int p) { return 0; };
318 auto get_cgg_bubble_order_tet = [](int p) {
320 };
321 field_order_table[MBVERTEX] = get_cgg_bubble_order_zero;
322 field_order_table[MBEDGE] = get_cgg_bubble_order_zero;
323 field_order_table[MBTRI] = get_cgg_bubble_order_zero;
324 field_order_table[MBTET] = get_cgg_bubble_order_tet;
326 CHKERR mField.set_field_order(meshset, MBTRI, field_name, order);
327 CHKERR mField.set_field_order(meshset, MBTET, field_name, order);
329 };
330
331 // spatial fields
332 CHKERR add_hdiv_field(piolaStress, spaceOrder, 3);
333 CHKERR add_bubble_field(bubbleField, spaceOrder, 1);
334 CHKERR add_l2_field(spatialL2Disp, spaceOrder - 1, 3);
335 CHKERR add_l2_field(rotAxis, spaceOrder - 1, 3);
336 CHKERR add_l2_field(stretchTensor, spaceOrder, 6);
337
338 // material fields
339 // CHKERR add_hdiv_field(eshelbyStress, materialOrder, 3);
340 // CHKERR add_l2_field(materialGradient, materialOrder - 1, 9);
341 // CHKERR add_l2_field(materialL2Disp, materialOrder - 1, 3);
342 // CHKERR add_l2_field(tauField, materialOrder - 1, 1);
343 // CHKERR add_l2_field(lambdaField, materialOrder - 1, 1);
344
345 // Add history filedes
346 // CHKERR add_l2_field(materialGradient + "0", materialOrder - 1, 9);
347
348 // spatial displacement
349 CHKERR add_h1_field(spatialH1Disp, spaceH1Order, 3);
350
352
354}
static Index< 'p', 3 > p
#define NBVOLUMETET_CCG_BUBBLE(P)
Bubble function for CGG H div space.
@ AINSWORTH_LEGENDRE_BASE
Ainsworth Cole (Legendre) approx. base .
Definition: definitions.h:60
@ USER_BASE
user implemented approximation base
Definition: definitions.h:68
@ DEMKOWICZ_JACOBI_BASE
Definition: definitions.h:66
@ L2
field with C-1 continuity
Definition: definitions.h:88
@ H1
continuous field
Definition: definitions.h:85
@ HDIV
field with continuous normal traction
Definition: definitions.h:87
constexpr int order
const int dim
FTensor::Index< 'm', SPACE_DIM > m
virtual const Field * get_field_structure(const std::string &name, enum MoFEMTypes bh=MF_EXIST) const =0
get field structure
virtual MoFEMErrorCode build_fields(int verb=DEFAULT_VERBOSITY)=0
virtual MoFEMErrorCode set_field_order(const EntityHandle meshset, const EntityType type, const std::string &name, const ApproximationOrder order, int verb=DEFAULT_VERBOSITY)=0
Set order approximation of the entities in the field.
virtual MoFEMErrorCode add_ents_to_field_by_type(const Range &ents, const EntityType type, const std::string &name, int verb=DEFAULT_VERBOSITY)=0
Add entities to field meshset.
virtual MoFEMErrorCode add_field(const std::string &name, const FieldSpace space, const FieldApproximationBase base, const FieldCoefficientsNumber nb_of_coefficients, const TagType tag_type=MB_TAG_SPARSE, const enum MoFEMTypes bh=MF_EXCL, int verb=DEFAULT_VERBOSITY)=0
Add field.
Provide data structure for (tensor) field approximation.

◆ addMaterial_Hencky()

MoFEMErrorCode EshelbianPlasticity::EshelbianCore::addMaterial_Hencky ( double  E,
double  nu 
)
Examples
ep.cpp.

Definition at line 623 of file EshelbianADOL-C.cpp.

623 {
625 physicalEquations = boost::make_shared<HMHHencky>(mField, E, nu);
627}
boost::shared_ptr< PhysicalEquations > physicalEquations

◆ addMaterial_HMHHStVenantKirchhoff()

MoFEMErrorCode EshelbianPlasticity::EshelbianCore::addMaterial_HMHHStVenantKirchhoff ( const int  tape,
const double  lambda,
const double  mu,
const double  sigma_y 
)
Examples
ep.cpp.

Definition at line 446 of file EshelbianADOL-C.cpp.

448 {
450 physicalEquations = boost::make_shared<HMHStVenantKirchhoff>(lambda, mu);
451 CHKERR physicalEquations->recordTape(tape, nullptr);
453}
static double lambda

◆ addMaterial_HMHMooneyRivlin()

MoFEMErrorCode EshelbianPlasticity::EshelbianCore::addMaterial_HMHMooneyRivlin ( const int  tape,
const double  alpha,
const double  beta,
const double  lambda,
const double  sigma_y 
)
Examples
ep.cpp.

Definition at line 455 of file EshelbianADOL-C.cpp.

457 {
460 boost::make_shared<HMHPMooneyRivlinWriggersEq63>(alpha, beta, lambda);
461 CHKERR physicalEquations->recordTape(tape, nullptr);
463}

◆ addVolumeFiniteElement()

MoFEMErrorCode EshelbianPlasticity::EshelbianCore::addVolumeFiniteElement ( const EntityHandle  meshset = 0)
Examples
ep.cpp.

Definition at line 357 of file EshelbianPlasticity.cpp.

357 {
359
360 // set finite element fields
361 auto add_field_to_fe = [this](const std::string fe,
362 const std::string field_name) {
368 };
369
374
375 CHKERR add_field_to_fe(elementVolumeName, piolaStress);
376 CHKERR add_field_to_fe(elementVolumeName, bubbleField);
377 // CHKERR add_field_to_fe(elementVolumeName, eshelbyStress);
378 CHKERR add_field_to_fe(elementVolumeName, stretchTensor);
379 CHKERR add_field_to_fe(elementVolumeName, rotAxis);
380 CHKERR add_field_to_fe(elementVolumeName, spatialL2Disp);
381 CHKERR add_field_to_fe(elementVolumeName, stretchTensor);
382 CHKERR add_field_to_fe(elementVolumeName, spatialH1Disp);
383 // CHKERR add_field_to_fe(elementVolumeName, materialGradient);
384 // CHKERR mField.modify_finite_element_add_field_data(elementVolumeName,
385 // materialGradient +
386 // "0");
387 }
388
389 // build finite elements data structures
391
393}
virtual bool check_finite_element(const std::string &name) const =0
Check if finite element is in database.

◆ d_f_linear()

static double EshelbianPlasticity::EshelbianCore::d_f_linear ( const double  v)
inlinestatic

Definition at line 859 of file EshelbianPlasticity.hpp.

859{ return 1; }

◆ d_f_log()

static double EshelbianPlasticity::EshelbianCore::d_f_log ( const double  v)
inlinestatic
Examples
EshelbianPlasticity.cpp.

Definition at line 840 of file EshelbianPlasticity.hpp.

840 {
841 return pow(exponentBase, v) * log(EshelbianCore::exponentBase);
842 }

◆ dd_f_linear()

static double EshelbianPlasticity::EshelbianCore::dd_f_linear ( const double  v)
inlinestatic

Definition at line 860 of file EshelbianPlasticity.hpp.

860{ return 0; }

◆ dd_f_log()

static double EshelbianPlasticity::EshelbianCore::dd_f_log ( const double  v)
inlinestatic
Examples
EshelbianPlasticity.cpp.

Definition at line 843 of file EshelbianPlasticity.hpp.

◆ f_linear()

static double EshelbianPlasticity::EshelbianCore::f_linear ( const double  v)
inlinestatic

Definition at line 858 of file EshelbianPlasticity.hpp.

858{ return v + 1; }

◆ f_log()

static double EshelbianPlasticity::EshelbianCore::f_log ( const double  v)
inlinestatic
Examples
EshelbianPlasticity.cpp.

Definition at line 837 of file EshelbianPlasticity.hpp.

837 {
838 return pow(EshelbianCore::exponentBase, v);
839 }

◆ getBc()

template<typename BC >
MoFEMErrorCode EshelbianPlasticity::EshelbianCore::getBc ( boost::shared_ptr< BC > &  bc_vec_ptr,
const std::string  block_name,
const int  nb_attributes 
)
inline

Definition at line 930 of file EshelbianPlasticity.hpp.

931 {
933 for (auto it :
934 mField.getInterface<MeshsetsManager>()->getCubitMeshsetPtr(std::regex(
935
936 (boost::format("%s(.*)") % block_name).str()
937
938 ))
939
940 ) {
941 std::vector<double> block_attributes;
942 CHKERR it->getAttributes(block_attributes);
943 if (block_attributes.size() != nb_attributes) {
944 SETERRQ3(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
945 "In block %s expected %d attributes, but given %d",
946 it->getName().c_str(), nb_attributes, block_attributes.size());
947 }
948 Range faces;
949 CHKERR it->getMeshsetIdEntitiesByDimension(mField.get_moab(), 2, faces,
950 true);
951 bc_vec_ptr->emplace_back(it->getName(), block_attributes, faces);
952 }
954 }
@ MOFEM_DATA_INCONSISTENCY
Definition: definitions.h:31

◆ getOptions()

MoFEMErrorCode EshelbianPlasticity::EshelbianCore::getOptions ( )

Definition at line 106 of file EshelbianPlasticity.cpp.

106 {
108 const char *list_rots[] = {"small", "moderate", "large"};
109 PetscInt choice_rot = EshelbianCore::rotSelector;
110 PetscInt choice_grad = EshelbianCore::gradApperoximator;
111
112 const char *list_stretches[] = {"linear", "log"};
113 PetscInt choice_stretch = StretchSelector::LOG;
114
115 CHKERR PetscOptionsBegin(PETSC_COMM_WORLD, "", "Eshelbian plasticity",
116 "none");
117
118 spaceOrder = 2;
119 CHKERR PetscOptionsInt("-space_order", "approximation oder for space", "",
120 spaceOrder, &spaceOrder, PETSC_NULL);
121 spaceH1Order = -1;
122 CHKERR PetscOptionsInt("-space_h1_order", "approximation oder for space", "",
123 spaceH1Order, &spaceH1Order, PETSC_NULL);
124
125 materialOrder = 1;
126 CHKERR PetscOptionsInt("-material_order", "approximation oder for material",
127 "", materialOrder, &materialOrder, PETSC_NULL);
128
129 alphaU = 0;
130 CHKERR PetscOptionsScalar("-viscosity_alpha_u", "viscosity", "", alphaU,
131 &alphaU, PETSC_NULL);
132
133 alphaW = 0;
134 CHKERR PetscOptionsScalar("-viscosity_alpha_w", "viscosity", "", alphaW,
135 &alphaW, PETSC_NULL);
136
137 alphaRho = 0;
138 CHKERR PetscOptionsScalar("-density_alpha_rho", "density", "", alphaRho,
139 &alphaRho, PETSC_NULL);
140
141 precEps = 0;
142 CHKERR PetscOptionsScalar("-preconditioner_eps", "preconditioner_eps", "",
143 precEps, &precEps, PETSC_NULL);
144
145 precEpsOmega = 0;
146 CHKERR PetscOptionsScalar("-preconditioner_eps_omega", "preconditioner_eps",
147 "", precEpsOmega, &precEpsOmega, PETSC_NULL);
148 precEpsW = 0;
149 CHKERR PetscOptionsScalar("-preconditioner_eps_w", "preconditioner_eps", "",
150 precEpsW, &precEpsW, PETSC_NULL);
151
152 CHKERR PetscOptionsEList("-rotations", "rotations", "", list_rots,
153 LARGE_ROT + 1, list_rots[choice_rot], &choice_rot,
154 PETSC_NULL);
155 CHKERR PetscOptionsEList("-grad", "gradient of defomation approximator", "",
156 list_rots, LARGE_ROT + 1, list_rots[choice_grad],
157 &choice_grad, PETSC_NULL);
158
159 CHKERR PetscOptionsScalar("-exponent_base", "exponent_base", "", exponentBase,
160 &EshelbianCore::exponentBase, PETSC_NULL);
161 CHKERR PetscOptionsEList(
162 "-stretches", "stretches", "", list_stretches, StretchSelector::LOG + 1,
163 list_stretches[choice_stretch], &choice_stretch, PETSC_NULL);
164
165 ierr = PetscOptionsEnd();
166 CHKERRG(ierr);
167
168 EshelbianCore::rotSelector = static_cast<RotSelector>(choice_rot);
169 EshelbianCore::gradApperoximator = static_cast<RotSelector>(choice_grad);
170 EshelbianCore::stretchSelector = static_cast<StretchSelector>(choice_stretch);
171
180 break;
188 break;
189 default:
190 SETERRQ(mField.get_comm(), MOFEM_DATA_INCONSISTENCY, "Unknown stretch");
191 break;
192 };
193
195 precEpsW += precEps;
196
197 MOFEM_LOG("EP", Sev::inform) << "spaceOrder " << spaceOrder;
198 MOFEM_LOG("EP", Sev::inform) << "spaceH1Order " << spaceH1Order;
199 MOFEM_LOG("EP", Sev::inform) << "materialOrder " << materialOrder;
200 MOFEM_LOG("EP", Sev::inform) << "alphaU " << alphaU;
201 MOFEM_LOG("EP", Sev::inform) << "alphaW " << alphaW;
202 MOFEM_LOG("EP", Sev::inform) << "alphaRho " << alphaRho;
203 MOFEM_LOG("EP", Sev::inform) << "precEps " << precEps;
204 MOFEM_LOG("EP", Sev::inform) << "precEpsOmega " << precEpsOmega;
205 MOFEM_LOG("EP", Sev::inform) << "precEpsW " << precEpsW;
206 MOFEM_LOG("EP", Sev::inform)
207 << "Rotations " << list_rots[EshelbianCore::rotSelector];
208 MOFEM_LOG("EP", Sev::inform) << "Gradient of deformation "
210 if (exponentBase != exp(1))
211 MOFEM_LOG("EP", Sev::inform)
212 << "Base exponent " << EshelbianCore::exponentBase;
213 else
214 MOFEM_LOG("EP", Sev::inform) << "Base exponent e";
215 MOFEM_LOG("EP", Sev::inform) << "Stretch " << list_stretches[choice_stretch];
216
217 if (spaceH1Order == -1)
219
221}
#define CHKERRG(n)
Check error code of MoFEM/MOAB/PETSc function.
Definition: definitions.h:483
static double inv_d_f_linear(const double v)
static boost::function< double(const double)> dd_f
static boost::function< double(const double)> inv_f
static boost::function< double(const double)> inv_dd_f
static boost::function< double(const double)> inv_d_f
static double inv_f_log(const double v)
static double inv_d_f_log(const double v)
static double d_f_linear(const double v)
static double dd_f_log(const double v)
static enum StretchSelector stretchSelector
static double inv_dd_f_log(const double v)
static boost::function< double(const double)> d_f
static double d_f_log(const double v)
static double inv_dd_f_linear(const double v)
static boost::function< double(const double)> f
static double dd_f_linear(const double v)
static double f_linear(const double v)
static double f_log(const double v)
static double inv_f_linear(const double v)

◆ getSpatialDispBc()

MoFEMErrorCode EshelbianPlasticity::EshelbianCore::getSpatialDispBc ( )

[Getting norms]

Examples
ep.cpp.

Definition at line 1530 of file EshelbianPlasticity.cpp.

1530 {
1532
1533 auto bc_mng = mField.getInterface<BcManager>();
1534 CHKERR bc_mng->pushMarkDOFsOnEntities<DisplacementCubitBcData>(
1535 "", piolaStress, false, false);
1536
1537 bcSpatialDispVecPtr = boost::make_shared<BcDispVec>();
1538
1539 for (auto bc : bc_mng->getBcMapByBlockName()) {
1540 if (auto disp_bc = bc.second->dispBcPtr) {
1541
1542 MOFEM_LOG("EP", Sev::noisy) << *disp_bc;
1543
1544 std::vector<double> block_attributes(6, 0.);
1545 if (disp_bc->data.flag1 == 1) {
1546 block_attributes[0] = disp_bc->data.value1;
1547 block_attributes[3] = 1;
1548 }
1549 if (disp_bc->data.flag2 == 1) {
1550 block_attributes[1] = disp_bc->data.value2;
1551 block_attributes[4] = 1;
1552 }
1553 if (disp_bc->data.flag3 == 1) {
1554 block_attributes[2] = disp_bc->data.value3;
1555 block_attributes[5] = 1;
1556 }
1557 auto faces = bc.second->bcEnts.subset_by_dimension(2);
1558 bcSpatialDispVecPtr->emplace_back(bc.first, block_attributes, faces);
1559 }
1560 }
1561
1562 // old way of naming blocksets for displacement BCs
1563 CHKERR getBc(bcSpatialDispVecPtr, "SPATIAL_DISP_BC", 6);
1564
1566}
MoFEMErrorCode getBc(boost::shared_ptr< BC > &bc_vec_ptr, const std::string block_name, const int nb_attributes)
Definition of the displacement bc data structure.
Definition: BCData.hpp:72

◆ getSpatialRotationBc()

MoFEMErrorCode EshelbianPlasticity::EshelbianCore::getSpatialRotationBc ( )
inline
Examples
ep.cpp.

Definition at line 958 of file EshelbianPlasticity.hpp.

958 {
959 bcSpatialRotationVecPtr = boost::make_shared<BcRotVec>();
960 return getBc(bcSpatialRotationVecPtr, "SPATIAL_ROTATION_BC", 4);
961 }

◆ getSpatialTractionBc()

MoFEMErrorCode EshelbianPlasticity::EshelbianCore::getSpatialTractionBc ( )
Examples
ep.cpp.

Definition at line 1568 of file EshelbianPlasticity.cpp.

1568 {
1570
1571 auto bc_mng = mField.getInterface<BcManager>();
1572 CHKERR bc_mng->pushMarkDOFsOnEntities<ForceCubitBcData>("", piolaStress,
1573 false, false);
1574
1575 bcSpatialTraction = boost::make_shared<TractionBcVec>();
1576
1577 for (auto bc : bc_mng->getBcMapByBlockName()) {
1578 if (auto force_bc = bc.second->forceBcPtr) {
1579 std::vector<double> block_attributes(6, 0.);
1580 block_attributes[0] = -force_bc->data.value3 * force_bc->data.value1;
1581 block_attributes[3] = 1;
1582 block_attributes[1] = -force_bc->data.value4 * force_bc->data.value1;
1583 block_attributes[4] = 1;
1584 block_attributes[2] = -force_bc->data.value5 * force_bc->data.value1;
1585 block_attributes[5] = 1;
1586 auto faces = bc.second->bcEnts.subset_by_dimension(2);
1587 bcSpatialTraction->emplace_back(bc.first, block_attributes, faces);
1588 }
1589 }
1590
1591 CHKERR getBc(bcSpatialTraction, "SPATIAL_TRACTION_BC", 6);
1592
1594}
Definition of the force bc data structure.
Definition: BCData.hpp:135

◆ getSpatialTractionFreeBc()

MoFEMErrorCode EshelbianPlasticity::EshelbianCore::getSpatialTractionFreeBc ( const EntityHandle  meshset = 0)
inline
Examples
ep.cpp.

Definition at line 980 of file EshelbianPlasticity.hpp.

980 {
982 boost::shared_ptr<TractionFreeBc>(new TractionFreeBc());
983 return getTractionFreeBc(meshset, bcSpatialFreeTraction, "CONTACT");
984 }
std::vector< Range > TractionFreeBc
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.

◆ gettingNorms()

MoFEMErrorCode EshelbianPlasticity::EshelbianCore::gettingNorms ( )

[Getting norms]

Definition at line 1469 of file EshelbianPlasticity.cpp.

1469 {
1471
1472 auto post_proc_norm_fe =
1473 boost::make_shared<VolumeElementForcesAndSourcesCore>(mField);
1474
1475 auto post_proc_norm_rule_hook = [](int, int, int p) -> int {
1476 return 2 * (p);
1477 };
1478 post_proc_norm_fe->getRuleHook = post_proc_norm_rule_hook;
1479
1480 post_proc_norm_fe->getUserPolynomialBase() =
1481 boost::shared_ptr<BaseFunction>(new CGGUserPolynomialBase());
1482
1484 post_proc_norm_fe->getOpPtrVector(), {L2, H1, HDIV});
1485
1486 enum NORMS { U_NORM_L2 = 0, U_NORM_H1, PIOLA_NORM, U_ERROR_L2, LAST_NORM };
1487 auto norms_vec =
1488 createVectorMPI(mField.get_comm(), LAST_NORM, PETSC_DETERMINE);
1489 CHKERR VecZeroEntries(norms_vec);
1490
1491 auto u_l2_ptr = boost::make_shared<MatrixDouble>();
1492 auto u_h1_ptr = boost::make_shared<MatrixDouble>();
1493 post_proc_norm_fe->getOpPtrVector().push_back(
1495 post_proc_norm_fe->getOpPtrVector().push_back(
1497 post_proc_norm_fe->getOpPtrVector().push_back(
1498 new OpCalcNormL2Tensor1<SPACE_DIM>(u_l2_ptr, norms_vec, U_NORM_L2));
1499 post_proc_norm_fe->getOpPtrVector().push_back(
1500 new OpCalcNormL2Tensor1<SPACE_DIM>(u_h1_ptr, norms_vec, U_NORM_H1));
1501 post_proc_norm_fe->getOpPtrVector().push_back(
1502 new OpCalcNormL2Tensor1<SPACE_DIM>(u_l2_ptr, norms_vec, U_ERROR_L2,
1503 u_h1_ptr));
1504
1505 auto piola_ptr = boost::make_shared<MatrixDouble>();
1506 post_proc_norm_fe->getOpPtrVector().push_back(
1508 post_proc_norm_fe->getOpPtrVector().push_back(
1509 new OpCalcNormL2Tensor2<3, 3>(piola_ptr, norms_vec, PIOLA_NORM));
1510
1512 *post_proc_norm_fe);
1513
1514 CHKERR VecAssemblyBegin(norms_vec);
1515 CHKERR VecAssemblyEnd(norms_vec);
1516 const double *norms;
1517 CHKERR VecGetArrayRead(norms_vec, &norms);
1518 MOFEM_LOG("EP", Sev::inform) << "norm_u: " << std::sqrt(norms[U_NORM_L2]);
1519 MOFEM_LOG("EP", Sev::inform) << "norm_u_h1: " << std::sqrt(norms[U_NORM_H1]);
1520 MOFEM_LOG("EP", Sev::inform)
1521 << "norm_error_u_l2: " << std::sqrt(norms[U_ERROR_L2]);
1522 MOFEM_LOG("EP", Sev::inform)
1523 << "norm_piola: " << std::sqrt(norms[PIOLA_NORM]);
1524 CHKERR VecRestoreArrayRead(norms_vec, &norms);
1525
1527}
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.
auto createVectorMPI(MPI_Comm comm, PetscInt n, PetscInt N)
Create MPI Vector.
Add operators pushing bases from local to physical configuration.
Get norm of input MatrixDouble for Tensor1.
Get norm of input MatrixDouble for Tensor2.
Calculate tenor field using vectorial base, i.e. Hdiv/Hcurl.
Get values at integration pts for tensor filed rank 1, i.e. vector field.

◆ getTractionFreeBc()

MoFEMErrorCode EshelbianPlasticity::EshelbianCore::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.

Parameters
meshset
bc_ptr
disp_block_set_name
rot_block_set_name
contact_set_name
Returns
MoFEMErrorCode

Definition at line 641 of file EshelbianPlasticity.cpp.

643 {
645
646 // get skin from all tets
647 Range tets;
648 CHKERR mField.get_moab().get_entities_by_type(meshset, MBTET, tets);
649 Range tets_skin_part;
650 Skinner skin(&mField.get_moab());
651 CHKERR skin.find_skin(0, tets, false, tets_skin_part);
652 ParallelComm *pcomm =
653 ParallelComm::get_pcomm(&mField.get_moab(), MYPCOMM_INDEX);
654 Range tets_skin;
655 CHKERR pcomm->filter_pstatus(tets_skin_part,
656 PSTATUS_SHARED | PSTATUS_MULTISHARED,
657 PSTATUS_NOT, -1, &tets_skin);
658
659 bc_ptr->resize(3);
660 for (int dd = 0; dd != 3; ++dd)
661 (*bc_ptr)[dd] = tets_skin;
662
664 for (auto &v : *bcSpatialDispVecPtr) {
665 if (v.flags[0])
666 (*bc_ptr)[0] = subtract((*bc_ptr)[0], v.faces);
667 if (v.flags[1])
668 (*bc_ptr)[1] = subtract((*bc_ptr)[1], v.faces);
669 if (v.flags[2])
670 (*bc_ptr)[2] = subtract((*bc_ptr)[2], v.faces);
671 }
672
674 for (auto &v : *bcSpatialRotationVecPtr) {
675 (*bc_ptr)[0] = subtract((*bc_ptr)[0], v.faces);
676 (*bc_ptr)[1] = subtract((*bc_ptr)[1], v.faces);
677 (*bc_ptr)[2] = subtract((*bc_ptr)[2], v.faces);
678 }
679
680 // remove contact
682 std::regex((boost::format("%s(.*)") % contact_set_name).str()))) {
683 Range faces;
684 CHKERR m->getMeshsetIdEntitiesByDimension(mField.get_moab(), 2, faces,
685 true);
686 (*bc_ptr)[0] = subtract((*bc_ptr)[0], faces);
687 (*bc_ptr)[1] = subtract((*bc_ptr)[1], faces);
688 (*bc_ptr)[2] = subtract((*bc_ptr)[2], faces);
689 }
690
691 // for (int dd = 0; dd != 3; ++dd) {
692 // EntityHandle meshset;
693 // CHKERR mField.get_moab().create_meshset(MESHSET_SET, meshset);
694 // CHKERR mField.get_moab().add_entities(meshset, (*bc_ptr)[dd]);
695 // std::string file_name = disp_block_set_name +
696 // "_traction_free_bc_" + boost::lexical_cast<std::string>(dd) + ".vtk";
697 // CHKERR mField.get_moab().write_file(file_name.c_str(), " VTK ", "",
698 // &meshset, 1);
699 // CHKERR mField.get_moab().delete_entities(&meshset, 1);
700 // }
701
703}
const Tensor2_symmetric_Expr< const ddTensor0< T, Dim, i, j >, typename promote< T, double >::V, Dim, i, j > dd(const Tensor0< T * > &a, const Index< i, Dim > index1, const Index< j, Dim > index2, const Tensor1< int, Dim > &d_ijk, const Tensor1< double, Dim > &d_xyz)
Definition: ddTensor0.hpp:33

◆ inv_d_f_linear()

static double EshelbianPlasticity::EshelbianCore::inv_d_f_linear ( const double  v)
inlinestatic

Definition at line 863 of file EshelbianPlasticity.hpp.

863{ return 0; }

◆ inv_d_f_log()

static double EshelbianPlasticity::EshelbianCore::inv_d_f_log ( const double  v)
inlinestatic
Examples
EshelbianPlasticity.cpp.

Definition at line 851 of file EshelbianPlasticity.hpp.

851 {
852 return (1. / v) / log(EshelbianCore::exponentBase);
853 }

◆ inv_dd_f_linear()

static double EshelbianPlasticity::EshelbianCore::inv_dd_f_linear ( const double  v)
inlinestatic

Definition at line 864 of file EshelbianPlasticity.hpp.

864{ return 0; }

◆ inv_dd_f_log()

static double EshelbianPlasticity::EshelbianCore::inv_dd_f_log ( const double  v)
inlinestatic
Examples
EshelbianPlasticity.cpp.

Definition at line 854 of file EshelbianPlasticity.hpp.

854 {
855 return -(1. / (v * v)) / log(EshelbianCore::exponentBase);
856 }

◆ inv_f_linear()

static double EshelbianPlasticity::EshelbianCore::inv_f_linear ( const double  v)
inlinestatic

Definition at line 862 of file EshelbianPlasticity.hpp.

862{ return v - 1; }

◆ inv_f_log()

static double EshelbianPlasticity::EshelbianCore::inv_f_log ( const double  v)
inlinestatic
Examples
EshelbianPlasticity.cpp.

Definition at line 848 of file EshelbianPlasticity.hpp.

848 {
849 return log(v) / log(EshelbianCore::exponentBase);
850 }

◆ postProcessResults()

MoFEMErrorCode EshelbianPlasticity::EshelbianCore::postProcessResults ( const int  tag,
const std::string  file 
)

Definition at line 1401 of file EshelbianPlasticity.cpp.

1402 {
1404
1405 if (!dataAtPts) {
1406 dataAtPts =
1407 boost::shared_ptr<DataAtIntegrationPts>(new DataAtIntegrationPts());
1408 }
1409
1411 auto contact_common_data_ptr = boost::make_shared<ContactOps::CommonData>();
1412
1413 auto domain_ops = [&](auto &fe) {
1415 fe.getUserPolynomialBase() =
1416 boost::shared_ptr<BaseFunction>(new CGGUserPolynomialBase());
1418 {HDIV, H1, L2});
1419 fe.getOpPtrVector().push_back(new OpCalculateHVecTensorField<3, 3>(
1420 piolaStress, dataAtPts->getApproxPAtPts()));
1421 fe.getOpPtrVector().push_back(new OpCalculateHTensorTensorField<3, 3>(
1422 bubbleField, dataAtPts->getApproxPAtPts(), MBMAXTYPE));
1423 fe.getOpPtrVector().push_back(new OpCalculateTensor2SymmetricFieldValues<3>(
1424 stretchTensor, dataAtPts->getLogStretchTensorAtPts(), MBTET));
1425 fe.getOpPtrVector().push_back(new OpCalculateVectorFieldValues<3>(
1426 rotAxis, dataAtPts->getRotAxisAtPts(), MBTET));
1427 fe.getOpPtrVector().push_back(new OpCalculateVectorFieldValues<3>(
1428 spatialL2Disp, dataAtPts->getSmallWL2AtPts(), MBTET));
1429 fe.getOpPtrVector().push_back(new OpCalculateVectorFieldValues<3>(
1430 spatialH1Disp, dataAtPts->getSmallWH1AtPts()));
1431 fe.getOpPtrVector().push_back(new OpCalculateVectorFieldGradient<3, 3>(
1432 spatialH1Disp, dataAtPts->getSmallWGradH1AtPts()));
1433 // evaluate derived quantities
1434 fe.getOpPtrVector().push_back(
1435 new OpCalculateRotationAndSpatialGradient(dataAtPts));
1436
1437 // evaluate integration points
1438 fe.getOpPtrVector().push_back(physicalEquations->returnOpJacobian(
1439 tag, true, false, dataAtPts, physicalEquations));
1440
1441 // contact
1442 fe.getOpPtrVector().push_back(new OpCalculateVectorFieldValues<SPACE_DIM>(
1443 spatialL2Disp, contact_common_data_ptr->contactDispPtr()));
1444
1446 };
1447
1450 CHKERR domain_ops(*(op_loop_side->getSideFEPtr()));
1451 post_proc.getOpPtrVector().push_back(op_loop_side);
1452 post_proc.getOpPtrVector().push_back(new OpPostProcDataStructure(
1453 post_proc.getPostProcMesh(), post_proc.getMapGaussPts(), spatialL2Disp,
1454 dataAtPts));
1455
1456 // contact
1457 post_proc.getOpPtrVector().push_back(new OpTreeSearch(
1458 contactTreeRhs, contact_common_data_ptr, &post_proc.getPostProcMesh(),
1459 &post_proc.getMapGaussPts()));
1460
1462 contactTreeRhs.get());
1463 CHKERR DMoFEMLoopFiniteElements(dM, skinElement.c_str(), &post_proc);
1464 CHKERR post_proc.writeFile(file.c_str());
1466}
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:572
boost::shared_ptr< DataAtIntegrationPts > dataAtPts
boost::shared_ptr< ContactTree > contactTreeRhs
Make a contact treee.
Calculate tenor field using tensor base, i.e. Hdiv/Hcurl.
Calculate symmetric tensor field values at integration pts.
Get field gradients at integration pts for scalar filed rank 0, i.e. vector field.
Element used to execute operators on side of the element.

◆ query_interface()

MoFEMErrorCode EshelbianPlasticity::EshelbianCore::query_interface ( boost::typeindex::type_index  type_index,
UnknownInterface **  iface 
) const

Getting interface of core database.

Parameters
uuidunique ID of interface
ifacereturned pointer to interface
Returns
error code
Examples
EshelbianPlasticity.cpp.

Definition at line 73 of file EshelbianPlasticity.cpp.

74 {
75 *iface = const_cast<EshelbianCore *>(this);
76 return 0;
77}
EshelbianCore(MoFEM::Interface &m_field)

◆ setBaseVolumeElementOps()

MoFEMErrorCode EshelbianPlasticity::EshelbianCore::setBaseVolumeElementOps ( const int  tag,
const bool  do_rhs,
const bool  do_lhs,
boost::shared_ptr< VolumeElementForcesAndSourcesCore > &  fe 
)

Definition at line 827 of file EshelbianPlasticity.cpp.

829 {
831 fe = boost::make_shared<VolumeElementForcesAndSourcesCore>(mField);
832
833 fe->getUserPolynomialBase() =
834 boost::shared_ptr<BaseFunction>(new CGGUserPolynomialBase());
836 {HDIV, H1, L2});
837
838 // set integration rule
839 fe->getRuleHook = VolRule();
840
841 if (!dataAtPts) {
842 dataAtPts =
843 boost::shared_ptr<DataAtIntegrationPts>(new DataAtIntegrationPts());
844 dataAtPts->physicsPtr = physicalEquations;
845 }
846
847 // calculate fields values
848 fe->getOpPtrVector().push_back(new OpCalculateHVecTensorField<3, 3>(
849 piolaStress, dataAtPts->getApproxPAtPts()));
850 fe->getOpPtrVector().push_back(new OpCalculateHTensorTensorField<3, 3>(
851 bubbleField, dataAtPts->getApproxPAtPts(), MBMAXTYPE));
852 fe->getOpPtrVector().push_back(new OpCalculateHVecTensorDivergence<3, 3>(
853 piolaStress, dataAtPts->getDivPAtPts()));
854 fe->getOpPtrVector().push_back(new OpCalculateTensor2SymmetricFieldValues<3>(
855 stretchTensor, dataAtPts->getLogStretchTensorAtPts(), MBTET));
856 fe->getOpPtrVector().push_back(new OpCalculateVectorFieldValues<3>(
857 rotAxis, dataAtPts->getRotAxisAtPts(), MBTET));
858 fe->getOpPtrVector().push_back(new OpCalculateVectorFieldValues<3>(
859 spatialL2Disp, dataAtPts->getSmallWL2AtPts(), MBTET));
860
861 // velocities
862 fe->getOpPtrVector().push_back(new OpCalculateVectorFieldValuesDot<3>(
863 spatialL2Disp, dataAtPts->getSmallWL2DotAtPts(), MBTET));
864 fe->getOpPtrVector().push_back(
866 stretchTensor, dataAtPts->getLogStretchDotTensorAtPts(), MBTET));
867 fe->getOpPtrVector().push_back(new OpCalculateVectorFieldValuesDot<3>(
868 rotAxis, dataAtPts->getRotAxisDotAtPts(), MBTET));
869
870 // acceleration
871 if (std::abs(alphaRho) > std::numeric_limits<double>::epsilon()) {
872 fe->getOpPtrVector().push_back(new OpCalculateVectorFieldValuesDotDot<3>(
873 spatialL2Disp, dataAtPts->getSmallWL2DotDotAtPts(), MBTET));
874 }
875
876 // H1 displacements
877 fe->getOpPtrVector().push_back(new OpCalculateVectorFieldValues<3>(
878 spatialH1Disp, dataAtPts->getSmallWH1AtPts()));
879 fe->getOpPtrVector().push_back(new OpCalculateVectorFieldGradient<3, 3>(
880 spatialH1Disp, dataAtPts->getSmallWGradH1AtPts()));
881
882 // calculate other derived quantities
883 fe->getOpPtrVector().push_back(
884 new OpCalculateRotationAndSpatialGradient(dataAtPts));
885
886 // evaluate integration points
887 fe->getOpPtrVector().push_back(physicalEquations->returnOpJacobian(
888 tag, do_rhs, do_lhs, dataAtPts, physicalEquations));
889
891}
Calculate divergence of tonsorial field using vectorial base.
Calculate symmetric tensor field rates ant integratio pts.
Approximate field values for given petsc vector.
Set integration rule.

◆ setContactElementOps()

MoFEMErrorCode EshelbianPlasticity::EshelbianCore::setContactElementOps ( boost::shared_ptr< ContactTree > &  fe_contact_tree,
boost::shared_ptr< FaceElementForcesAndSourcesCore > &  fe_rhs,
boost::shared_ptr< FaceElementForcesAndSourcesCore > &  fe_lhs 
)

Contact requires that body is marked

Definition at line 1026 of file EshelbianPlasticity.cpp.

1029 {
1031
1032 /** Contact requires that body is marked */
1033 auto get_body_range = [this](auto name) {
1034 map<int, Range> map;
1035
1036 for (auto m_ptr :
1038
1039 (boost::format("%s(.*)") % name).str()
1040
1041 ))
1042
1043 ) {
1044 Range ents;
1045 CHK_MOAB_THROW(m_ptr->getMeshsetIdEntitiesByDimension(mField.get_moab(),
1046 3, ents, true),
1047 "by dim");
1048 map[m_ptr->getMeshsetId()] = ents;
1049 }
1050
1051 return map;
1052 };
1053
1054 auto get_map_skin = [this](auto &&map) {
1055 ParallelComm *pcomm =
1056 ParallelComm::get_pcomm(&mField.get_moab(), MYPCOMM_INDEX);
1057
1058 Skinner skin(&mField.get_moab());
1059 for(auto &m : map) {
1060 Range skin_faces;
1061 CHKERR skin.find_skin(0, m.second, false, skin_faces);
1062 CHK_MOAB_THROW(pcomm->filter_pstatus(skin_faces,
1063 PSTATUS_SHARED | PSTATUS_MULTISHARED,
1064 PSTATUS_NOT, -1, nullptr),
1065 "filter");
1066 m.second.swap(skin_faces);
1067 }
1068 return map;
1069 };
1070
1071 /* The above code is written in C++ and it appears to be defining and using
1072 various operations on boundary elements and side elements. */
1075
1076 fe_rhs = boost::make_shared<BoundaryEle>(mField);
1077 fe_lhs = boost::make_shared<BoundaryEle>(mField);
1078 fe_rhs->getRuleHook = FaceRule();
1079 fe_lhs->getRuleHook = FaceRule();
1080
1082 {HDIV});
1084 {HDIV});
1085
1086 auto adj_cache =
1087 boost::make_shared<ForcesAndSourcesCore::UserDataOperator::AdjCache>();
1088
1089 auto get_op_side = [&](auto disp_ptr, auto col_ent_data_ptr) {
1091 auto op_loop_side = new OpLoopSide<SideEle>(
1092 mField, elementVolumeName, SPACE_DIM, Sev::noisy, adj_cache);
1093 op_loop_side->getSideFEPtr()->getUserPolynomialBase() =
1094 boost::shared_ptr<BaseFunction>(new CGGUserPolynomialBase());
1096 op_loop_side->getOpPtrVector(), {HDIV, H1, L2});
1097 op_loop_side->getOpPtrVector().push_back(
1099 if (col_ent_data_ptr != nullptr) {
1100 op_loop_side->getOpPtrVector().push_back(
1102 spatialL2Disp, col_ent_data_ptr));
1103 }
1104 return op_loop_side;
1105 };
1106
1107 auto add_ops_lhs = [&](auto &pip) {
1109 auto col_ent_data_ptr = boost::make_shared<EntitiesFieldData::EntData>();
1110 auto contact_common_data_ptr = boost::make_shared<ContactOps::CommonData>();
1111 pip.push_back(get_op_side(contact_common_data_ptr->contactDispPtr(),
1112 col_ent_data_ptr));
1114 piolaStress, contact_common_data_ptr->contactTractionPtr()));
1116 piolaStress, contact_common_data_ptr, col_ent_data_ptr,
1117 fe_contact_tree));
1119 piolaStress, contact_common_data_ptr, fe_contact_tree));
1121 };
1122
1123 auto add_contact_three = [&]() {
1125 auto tree_moab_ptr = boost::make_shared<moab::Core>();
1126 fe_contact_tree =
1127 boost::make_shared<ContactTree>(mField, tree_moab_ptr, spaceOrder,
1128 get_map_skin(get_body_range("BODY")));
1129 auto contact_common_data_ptr = boost::make_shared<ContactOps::CommonData>();
1130
1132 auto op_loop_side = new OpLoopSide<SideEle>(
1133 mField, elementVolumeName, SPACE_DIM, Sev::noisy, adj_cache);
1134 op_loop_side->getSideFEPtr()->getUserPolynomialBase() =
1135 boost::shared_ptr<BaseFunction>(new CGGUserPolynomialBase());
1137 op_loop_side->getOpPtrVector(), {HDIV, H1, L2});
1138 op_loop_side->getOpPtrVector().push_back(
1140 spatialL2Disp, contact_common_data_ptr->contactDispPtr()));
1141 auto col_ent_data_ptr = boost::make_shared<EntitiesFieldData::EntData>();
1142 op_loop_side->getOpPtrVector().push_back(
1144 col_ent_data_ptr));
1145
1146 fe_contact_tree->getOpPtrVector().push_back(op_loop_side);
1147
1148 auto u_h1_ptr = boost::make_shared<MatrixDouble>();
1149 fe_contact_tree->getOpPtrVector().push_back(
1151 fe_contact_tree->getOpPtrVector().push_back(new OpMoveNode(
1152 fe_contact_tree, contact_common_data_ptr, u_h1_ptr, col_ent_data_ptr));
1154 };
1155
1156 auto add_ops_rhs = [&](auto &pip) {
1158 auto contact_common_data_ptr = boost::make_shared<ContactOps::CommonData>();
1160 piolaStress, contact_common_data_ptr->contactTractionPtr()));
1161 pip.push_back(
1162 get_op_side(contact_common_data_ptr->contactDispPtr(), nullptr));
1163 pip.push_back(new OpTreeSearch(fe_contact_tree, contact_common_data_ptr,
1164 nullptr, nullptr));
1166 piolaStress, contact_common_data_ptr, fe_contact_tree));
1168 };
1169
1170 CHKERR add_contact_three();
1171 CHKERR add_ops_lhs(fe_lhs->getOpPtrVector());
1172 CHKERR add_ops_rhs(fe_rhs->getOpPtrVector());
1173
1175}
ElementsAndOps< SPACE_DIM >::BoundaryEle BoundaryEle
#define CHK_MOAB_THROW(err, msg)
Check error code of MoAB function and throw MoFEM exception.
Definition: definitions.h:576
ElementsAndOps< SPACE_DIM >::SideEle SideEle
Definition: plastic.cpp:61
Set integration rule to boundary elements.
Calculate trace of vector (Hdiv/Hcurl) space.
Base volume element used to integrate on skeleton.

◆ setElasticElementOps()

MoFEMErrorCode EshelbianPlasticity::EshelbianCore::setElasticElementOps ( const int  tag)
Examples
ep.cpp.

Definition at line 1177 of file EshelbianPlasticity.cpp.

1177 {
1181
1182 auto adj_cache =
1183 boost::make_shared<ForcesAndSourcesCore::UserDataOperator::AdjCache>();
1184
1185 auto get_op_contact_bc = [&]() {
1187 auto op_loop_side = new OpLoopSide<SideEle>(
1188 mField, contactElement, SPACE_DIM - 1, Sev::noisy, adj_cache);
1189 return op_loop_side;
1190 };
1191
1192 auto op_contact_bc = get_op_contact_bc();
1193 elasticFeLhs->getOpPtrVector().push_back(op_contact_bc);
1195 op_contact_bc->getSideFEPtr());
1197}
boost::shared_ptr< FaceElementForcesAndSourcesCore > elasticBcLhs
boost::shared_ptr< VolumeElementForcesAndSourcesCore > elasticFeLhs
boost::shared_ptr< VolumeElementForcesAndSourcesCore > elasticFeRhs
MoFEMErrorCode setContactElementOps(boost::shared_ptr< ContactTree > &fe_contact_tree, boost::shared_ptr< FaceElementForcesAndSourcesCore > &fe_rhs, boost::shared_ptr< FaceElementForcesAndSourcesCore > &fe_lhs)
MoFEMErrorCode setFaceElementOps(const bool add_elastic, const bool add_material, boost::shared_ptr< FaceElementForcesAndSourcesCore > &fe_rhs, boost::shared_ptr< FaceElementForcesAndSourcesCore > &fe_lhs)
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)
boost::shared_ptr< FaceElementForcesAndSourcesCore > contactRhs
boost::shared_ptr< FaceElementForcesAndSourcesCore > elasticBcRhs

◆ setElasticElementToTs()

MoFEMErrorCode EshelbianPlasticity::EshelbianCore::setElasticElementToTs ( DM  dm)
Examples
ep.cpp.

Definition at line 1199 of file EshelbianPlasticity.cpp.

1199 {
1201 boost::shared_ptr<FEMethod> null;
1202 boost::shared_ptr<FeTractionBc> spatial_traction_bc(
1203 new FeTractionBc(mField, piolaStress, bcSpatialTraction));
1204
1205 if (std::abs(alphaRho) > std::numeric_limits<double>::epsilon()) {
1206
1207 CHKERR DMMoFEMTSSetI2Function(dm, DM_NO_ELEMENT, null, spatial_traction_bc,
1208 null);
1210 null);
1212 null);
1216 spatial_traction_bc);
1218 null);
1220 null);
1221
1222 } else {
1223 CHKERR DMMoFEMTSSetIFunction(dm, DM_NO_ELEMENT, null, spatial_traction_bc,
1224 null);
1226 null);
1228 null);
1232 spatial_traction_bc);
1234 null);
1236 null);
1237 }
1239}
#define DM_NO_ELEMENT
Definition: DMMoFEM.hpp:10
PetscErrorCode DMMoFEMTSSetIFunction(DM dm, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
set TS implicit function evaluation function
Definition: DMMoFEM.cpp:786
PetscErrorCode DMMoFEMTSSetIJacobian(DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
set TS Jacobian evaluation function
Definition: DMMoFEM.cpp:839
PetscErrorCode DMMoFEMTSSetI2Jacobian(DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
set TS Jacobian evaluation function
Definition: DMMoFEM.cpp:1003
PetscErrorCode DMMoFEMTSSetI2Function(DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
set TS implicit function evaluation function
Definition: DMMoFEM.cpp:961

◆ setFaceElementOps()

MoFEMErrorCode EshelbianPlasticity::EshelbianCore::setFaceElementOps ( const bool  add_elastic,
const bool  add_material,
boost::shared_ptr< FaceElementForcesAndSourcesCore > &  fe_rhs,
boost::shared_ptr< FaceElementForcesAndSourcesCore > &  fe_lhs 
)

Definition at line 998 of file EshelbianPlasticity.cpp.

1001 {
1003
1004 fe_rhs = boost::make_shared<FaceElementForcesAndSourcesCore>(mField);
1005 fe_lhs = boost::make_shared<FaceElementForcesAndSourcesCore>(mField);
1006
1007 // set integration rule
1008 fe_rhs->getRuleHook = FaceRule();
1009 fe_lhs->getRuleHook = FaceRule();
1010
1012 {HDIV});
1014 {HDIV});
1015
1016 if (add_elastic) {
1017 fe_rhs->getOpPtrVector().push_back(
1018 new OpDispBc(piolaStress, dataAtPts, bcSpatialDispVecPtr));
1019 fe_rhs->getOpPtrVector().push_back(
1020 new OpRotationBc(piolaStress, dataAtPts, bcSpatialRotationVecPtr));
1021 }
1022
1024}

◆ setVolumeElementOps()

MoFEMErrorCode EshelbianPlasticity::EshelbianCore::setVolumeElementOps ( const int  tag,
const bool  add_elastic,
const bool  add_material,
boost::shared_ptr< VolumeElementForcesAndSourcesCore > &  fe_rhs,
boost::shared_ptr< VolumeElementForcesAndSourcesCore > &  fe_lhs 
)

Definition at line 893 of file EshelbianPlasticity.cpp.

896 {
898
899 auto time_scale = boost::make_shared<TimeScale>();
900
901 // Right hand side
902 CHKERR setBaseVolumeElementOps(tag, true, false, fe_rhs);
903
904 // elastic
905 if (add_elastic) {
906 fe_rhs->getOpPtrVector().push_back(
907 new OpSpatialEquilibrium(spatialL2Disp, dataAtPts, alphaW, alphaRho));
908 fe_rhs->getOpPtrVector().push_back(
909 new OpSpatialRotation(rotAxis, dataAtPts));
910 fe_rhs->getOpPtrVector().push_back(
911 new OpSpatialPhysical(stretchTensor, dataAtPts, alphaU));
912 fe_rhs->getOpPtrVector().push_back(
913 new OpSpatialConsistencyP(piolaStress, dataAtPts));
914 fe_rhs->getOpPtrVector().push_back(
915 new OpSpatialConsistencyBubble(bubbleField, dataAtPts));
916 fe_rhs->getOpPtrVector().push_back(
917 new OpSpatialConsistencyDivTerm(piolaStress, dataAtPts));
918
919 // Body forces
920 using BodyNaturalBC =
922 Assembly<PETSC>::LinearForm<GAUSS>;
923 using OpBodyForce =
924 BodyNaturalBC::OpFlux<NaturalMeshsetType<BLOCKSET>, 1, 3>;
925 CHKERR BodyNaturalBC::AddFluxToPipeline<OpBodyForce>::add(
926 fe_rhs->getOpPtrVector(), mField, "w", {time_scale}, "BODY_FORCE",
927 Sev::inform);
928 }
929
930 // Left hand side
931 CHKERR setBaseVolumeElementOps(tag, true, true, fe_lhs);
932
933 // elastic
934 if (add_elastic) {
935
936 const bool symmetric_system =
938
939 fe_lhs->getOpPtrVector().push_back(new OpSpatialPhysical_du_du(
941 fe_lhs->getOpPtrVector().push_back(new OpSpatialPhysical_du_dP(
943 fe_lhs->getOpPtrVector().push_back(new OpSpatialPhysical_du_dBubble(
945 if (!symmetric_system) {
946 fe_lhs->getOpPtrVector().push_back(new OpSpatialPhysical_du_domega(
948 }
949
950 fe_lhs->getOpPtrVector().push_back(new OpSpatialEquilibrium_dw_dP(
952 fe_lhs->getOpPtrVector().push_back(new OpSpatialEquilibrium_dw_dw(
954
955 fe_lhs->getOpPtrVector().push_back(new OpSpatialConsistency_dP_domega(
956 piolaStress, rotAxis, dataAtPts, symmetric_system));
957 fe_lhs->getOpPtrVector().push_back(new OpSpatialConsistency_dBubble_domega(
958 bubbleField, rotAxis, dataAtPts, symmetric_system));
959
960 if (!symmetric_system) {
961 fe_lhs->getOpPtrVector().push_back(new OpSpatialRotation_domega_dP(
962 rotAxis, piolaStress, dataAtPts, false));
963 fe_lhs->getOpPtrVector().push_back(new OpSpatialRotation_domega_dBubble(
964 rotAxis, bubbleField, dataAtPts, false));
965 fe_lhs->getOpPtrVector().push_back(
966 new OpSpatialRotation_domega_domega(rotAxis, rotAxis, dataAtPts));
967 }
968
969 // Stabilisation
970 if constexpr (A == AssemblyType::SCHUR) {
971 // Note that we assemble to AMat, however Assembly<SCHUR> assemble by
972 // default to PMat
973 using OpMassStab =
976 if (precEpsOmega > std::numeric_limits<double>::epsilon()) {
977 fe_lhs->getOpPtrVector().push_back(
978 new OpMassStab(rotAxis, rotAxis, [this](double, double, double) {
979 return precEpsOmega;
980 }));
981 }
982 if (std::abs(alphaRho + alphaW) <
983 std::numeric_limits<double>::epsilon()) {
984
985 fe_lhs->getOpPtrVector().push_back(new OpMassStab(
987 [this](double, double, double) { return precEpsW; }));
988 }
989 }
990
991 if (add_material) {
992 }
993 }
994
996}
FormsIntegrators< DomainEleOp >::Assembly< USER_ASSEMBLE >::LinearForm< GAUSS >::OpSource< 1, 3 > OpBodyForce
constexpr AssemblyType A
MoFEMErrorCode setBaseVolumeElementOps(const int tag, const bool do_rhs, const bool do_lhs, boost::shared_ptr< VolumeElementForcesAndSourcesCore > &fe)
Natural boundary conditions.
Definition: Natural.hpp:57

◆ solveElastic()

MoFEMErrorCode EshelbianPlasticity::EshelbianCore::solveElastic ( TS  ts,
Mat  m,
Vec  f,
Vec  x 
)
Examples
ep.cpp.

Definition at line 1245 of file EshelbianPlasticity.cpp.

1245 {
1247
1248#ifdef PYTHON_SFD
1249
1250 boost::shared_ptr<ContactOps::SDFPython> sdf_python_ptr;
1251
1252 auto file_exists = [](std::string myfile) {
1253 std::ifstream file(myfile.c_str());
1254 if (file) {
1255 return true;
1256 }
1257 return false;
1258 };
1259
1260 if (file_exists("sdf.py")) {
1261 MOFEM_LOG("EP", Sev::inform) << "sdf.py file found";
1262 sdf_python_ptr = boost::make_shared<ContactOps::SDFPython>();
1263 CHKERR sdf_python_ptr->sdfInit("sdf.py");
1264 ContactOps::sdfPythonWeakPtr = sdf_python_ptr;
1265 } else {
1266 MOFEM_LOG("EP", Sev::warning) << "sdf.py file NOT found";
1267 }
1268#else
1269#endif
1270
1271 boost::shared_ptr<TsCtx> ts_ctx;
1273
1274 CHKERR TSMonitorSet(ts, TsMonitorSet, ts_ctx.get(), PETSC_NULL);
1275
1276 boost::shared_ptr<FEMethod> monitor_ptr(new EshelbianMonitor(*this));
1277 ts_ctx->getLoopsMonitor().push_back(
1279
1280 CHKERR TSAppendOptionsPrefix(ts, "elastic_");
1281 CHKERR TSSetFromOptions(ts);
1282
1283 CHKERR TSSetDM(ts, dmElastic);
1284
1285 SNES snes;
1286 CHKERR TSGetSNES(ts, &snes);
1287
1288 PetscViewerAndFormat *vf;
1289 CHKERR PetscViewerAndFormatCreate(PETSC_VIEWER_STDOUT_WORLD,
1290 PETSC_VIEWER_DEFAULT, &vf);
1291 CHKERR SNESMonitorSet(
1292 snes,
1293 (MoFEMErrorCode(*)(SNES, PetscInt, PetscReal, void *))SNESMonitorFields,
1294 vf, (MoFEMErrorCode(*)(void **))PetscViewerAndFormatDestroy);
1295
1296 PetscSection section;
1297 CHKERR DMGetSection(dmElastic, &section);
1298 int num_fields;
1299 CHKERR PetscSectionGetNumFields(section, &num_fields);
1300 for (int ff = 0; ff != num_fields; ff++) {
1301 const char *field_name;
1302 CHKERR PetscSectionGetFieldName(section, ff, &field_name);
1303 MOFEM_LOG_C("EP", Sev::inform, "Field %d name %s", ff, field_name);
1304 }
1305
1306 CHKERR DMoFEMMeshToLocalVector(dmElastic, x, INSERT_VALUES, SCATTER_FORWARD);
1307
1308 CHKERR VecGhostUpdateBegin(x, INSERT_VALUES, SCATTER_FORWARD);
1309 CHKERR VecGhostUpdateEnd(x, INSERT_VALUES, SCATTER_FORWARD);
1310
1311 // Adding field split solver
1312 boost::shared_ptr<SetUpSchur> schur_ptr;
1313
1314 if constexpr (A == AssemblyType::SCHUR) {
1315
1316 auto p = matDuplicate(m, MAT_DO_NOT_COPY_VALUES);
1317
1318 auto ts_ctx_ptr = getDMTsCtx(dmElastic);
1319 ts_ctx_ptr->zeroMatrix = false;
1320
1321 // If density is larger than zero, use dynamic time solver
1322 if (std::abs(alphaRho) > std::numeric_limits<double>::epsilon()) {
1323 CHKERR TSSetI2Function(ts, f, PETSC_NULL, PETSC_NULL);
1324 CHKERR TSSetI2Jacobian(ts, m, p, PETSC_NULL, PETSC_NULL);
1325 } else {
1326 CHKERR TSSetIFunction(ts, f, PETSC_NULL, PETSC_NULL);
1327 CHKERR TSSetIJacobian(ts, m, p, PETSC_NULL, PETSC_NULL);
1328 }
1329
1330 KSP ksp;
1331 CHKERR SNESGetKSP(snes, &ksp);
1332 PC pc;
1333 CHKERR KSPGetPC(ksp, &pc);
1334 schur_ptr = SetUpSchur::createSetUpSchur(
1335 mField, SmartPetscObj<Mat>(m, true), p, &*this);
1336 CHKERR schur_ptr->setUp(ksp);
1337
1338 elasticFeLhs->preProcessHook = [&]() {
1340 *(elasticFeLhs->matAssembleSwitch) = false;
1341 CHKERR schur_ptr->preProc();
1343 };
1344 elasticFeLhs->postProcessHook = [&]() {
1347 };
1348 elasticBcLhs->preProcessHook = [&]() {
1351 };
1352 elasticBcLhs->preProcessHook = [&]() {
1354 *(elasticBcLhs->matAssembleSwitch) = false;
1355 CHKERR schur_ptr->postProc();
1357 };
1358 }
1359
1360 if (std::abs(alphaRho) > std::numeric_limits<double>::epsilon()) {
1361 Vec xx;
1362 CHKERR VecDuplicate(x, &xx);
1363 CHKERR VecZeroEntries(xx);
1364 CHKERR TS2SetSolution(ts, x, xx);
1365 CHKERR VecDestroy(&xx);
1366 } else {
1367 CHKERR TSSetSolution(ts, x);
1368 }
1369
1370 CHKERR TSSetUp(ts);
1371 CHKERR TSSetPreStep(ts, TSElasticPostStep::preStepFun);
1372 CHKERR TSSetPostStep(ts, TSElasticPostStep::postStepFun);
1374 CHKERR TSSolve(ts, PETSC_NULL);
1376
1377 // CHKERR TSGetSNES(ts, &snes);
1378 int lin_solver_iterations;
1379 CHKERR SNESGetLinearSolveIterations(snes, &lin_solver_iterations);
1380 MOFEM_LOG("EP", Sev::inform)
1381 << "Number of linear solver iterations " << lin_solver_iterations;
1382
1383 PetscBool test_cook_flg = PETSC_FALSE;
1384 CHKERR PetscOptionsGetBool(PETSC_NULL, "", "-test_cook", &test_cook_flg,
1385 PETSC_NULL);
1386 if (test_cook_flg) {
1387 constexpr int expected_lin_solver_iterations = 11;
1388 // if (lin_solver_iterations != expected_lin_solver_iterations)
1389 // SETERRQ2(
1390 // PETSC_COMM_SELF, MOFEM_ATOM_TEST_INVALID,
1391 // "Expected number of iterations is different than expected %d !=
1392 // %d", lin_solver_iterations, expected_lin_solver_iterations);
1393 }
1394
1396
1398}
#define MOFEM_LOG_C(channel, severity, format,...)
Definition: LogManager.hpp:311
PetscErrorCode DMoFEMMeshToLocalVector(DM dm, Vec l, InsertMode mode, ScatterMode scatter_mode)
set local (or ghosted) vector values on mesh for partition only
Definition: DMMoFEM.cpp:509
PetscErrorCode DMMoFEMGetTsCtx(DM dm, MoFEM::TsCtx **ts_ctx)
get MoFEM::TsCtx data structure
Definition: DMMoFEM.cpp:1128
MoFEM::TsCtx * ts_ctx
Definition: level_set.cpp:1884
const FTensor::Tensor2< T, Dim, Dim > Vec
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
Definition: Exceptions.hpp:56
PetscErrorCode TsMonitorSet(TS ts, PetscInt step, PetscReal t, Vec u, void *ctx)
Set monitor for TS solver.
Definition: TsCtx.cpp:221
auto getDMTsCtx(DM dm)
Get TS context data structure used by DM.
Definition: DMMoFEM.hpp:1045
PetscErrorCode PetscOptionsGetBool(PetscOptions *, const char pre[], const char name[], PetscBool *bval, PetscBool *set)
SmartPetscObj< Mat > matDuplicate(Mat mat, MatDuplicateOption op)
static boost::shared_ptr< SetUpSchur > createSetUpSchur(MoFEM::Interface &m_field, SmartPetscObj< Mat > m, SmartPetscObj< Mat > p, EshelbianCore *ep_core_ptr)
MoFEMErrorCode gettingNorms()
[Getting norms]
intrusive_ptr for managing petsc objects
FEMethodsSequence & getLoopsMonitor()
Get the loops to do Monitor object.
Definition: TsCtx.hpp:108
static MoFEMErrorCode postStepInitialise(EshelbianCore *ep_ptr)
static MoFEMErrorCode postStepDestroy()
static MoFEMErrorCode preStepFun(TS ts)
static MoFEMErrorCode postStepFun(TS ts)

Member Data Documentation

◆ alphaRho

double EshelbianPlasticity::EshelbianCore::alphaRho

Definition at line 917 of file EshelbianPlasticity.hpp.

◆ alphaU

double EshelbianPlasticity::EshelbianCore::alphaU

Definition at line 915 of file EshelbianPlasticity.hpp.

◆ alphaW

double EshelbianPlasticity::EshelbianCore::alphaW

Definition at line 916 of file EshelbianPlasticity.hpp.

◆ bcSpatialDispVecPtr

boost::shared_ptr<BcDispVec> EshelbianPlasticity::EshelbianCore::bcSpatialDispVecPtr

Definition at line 924 of file EshelbianPlasticity.hpp.

◆ bcSpatialFreeTraction

boost::shared_ptr<TractionFreeBc> EshelbianPlasticity::EshelbianCore::bcSpatialFreeTraction

Definition at line 927 of file EshelbianPlasticity.hpp.

◆ bcSpatialRotationVecPtr

boost::shared_ptr<BcRotVec> EshelbianPlasticity::EshelbianCore::bcSpatialRotationVecPtr

Definition at line 925 of file EshelbianPlasticity.hpp.

◆ bcSpatialTraction

boost::shared_ptr<TractionBcVec> EshelbianPlasticity::EshelbianCore::bcSpatialTraction

Definition at line 926 of file EshelbianPlasticity.hpp.

◆ bubbleField

const std::string EshelbianPlasticity::EshelbianCore::bubbleField

Definition at line 901 of file EshelbianPlasticity.hpp.

◆ contactElement

const std::string EshelbianPlasticity::EshelbianCore::contactElement

Definition at line 907 of file EshelbianPlasticity.hpp.

◆ contactRhs

boost::shared_ptr<FaceElementForcesAndSourcesCore> EshelbianPlasticity::EshelbianCore::contactRhs

Definition at line 884 of file EshelbianPlasticity.hpp.

◆ contactTreeRhs

boost::shared_ptr<ContactTree> EshelbianPlasticity::EshelbianCore::contactTreeRhs

Make a contact treee.

Definition at line 885 of file EshelbianPlasticity.hpp.

◆ d_f

boost::function< double(const double)> EshelbianPlasticity::EshelbianCore::d_f
static
Initial value:
Examples
EshelbianOperators.cpp, and EshelbianPlasticity.cpp.

Definition at line 831 of file EshelbianPlasticity.hpp.

◆ dataAtPts

boost::shared_ptr<DataAtIntegrationPts> EshelbianPlasticity::EshelbianCore::dataAtPts

Definition at line 877 of file EshelbianPlasticity.hpp.

◆ dd_f

boost::function< double(const double)> EshelbianPlasticity::EshelbianCore::dd_f
static
Initial value:
Examples
EshelbianOperators.cpp, and EshelbianPlasticity.cpp.

Definition at line 832 of file EshelbianPlasticity.hpp.

◆ dM

SmartPetscObj<DM> EshelbianPlasticity::EshelbianCore::dM

Coupled problem all fields.

Definition at line 887 of file EshelbianPlasticity.hpp.

◆ dmElastic

SmartPetscObj<DM> EshelbianPlasticity::EshelbianCore::dmElastic

Elastic problem.

Examples
ep.cpp.

Definition at line 888 of file EshelbianPlasticity.hpp.

◆ dmPrjSpatial

SmartPetscObj<DM> EshelbianPlasticity::EshelbianCore::dmPrjSpatial

Projection spatial displacement.

Definition at line 889 of file EshelbianPlasticity.hpp.

◆ elasticBcLhs

boost::shared_ptr<FaceElementForcesAndSourcesCore> EshelbianPlasticity::EshelbianCore::elasticBcLhs

Definition at line 882 of file EshelbianPlasticity.hpp.

◆ elasticBcRhs

boost::shared_ptr<FaceElementForcesAndSourcesCore> EshelbianPlasticity::EshelbianCore::elasticBcRhs

Definition at line 883 of file EshelbianPlasticity.hpp.

◆ elasticFeLhs

boost::shared_ptr<VolumeElementForcesAndSourcesCore> EshelbianPlasticity::EshelbianCore::elasticFeLhs

Definition at line 881 of file EshelbianPlasticity.hpp.

◆ elasticFeRhs

boost::shared_ptr<VolumeElementForcesAndSourcesCore> EshelbianPlasticity::EshelbianCore::elasticFeRhs

Definition at line 880 of file EshelbianPlasticity.hpp.

◆ elementVolumeName

const std::string EshelbianPlasticity::EshelbianCore::elementVolumeName

Definition at line 903 of file EshelbianPlasticity.hpp.

◆ eshelbyStress

const std::string EshelbianPlasticity::EshelbianCore::eshelbyStress

Definition at line 892 of file EshelbianPlasticity.hpp.

◆ essentialBcElement

const std::string EshelbianPlasticity::EshelbianCore::essentialBcElement

Definition at line 905 of file EshelbianPlasticity.hpp.

◆ exponentBase

double EshelbianPlasticity::EshelbianCore::exponentBase = exp(1)
static
Examples
EshelbianPlasticity.cpp.

Definition at line 829 of file EshelbianPlasticity.hpp.

◆ f

boost::function< double(const double)> EshelbianPlasticity::EshelbianCore::f = EshelbianCore::f_log
static

◆ gradApperoximator

enum RotSelector EshelbianPlasticity::EshelbianCore::gradApperoximator
static

◆ inv_d_f

boost::function< double(const double)> EshelbianPlasticity::EshelbianCore::inv_d_f
static
Initial value:
Examples
EshelbianPlasticity.cpp.

Definition at line 834 of file EshelbianPlasticity.hpp.

◆ inv_dd_f

boost::function< double(const double)> EshelbianPlasticity::EshelbianCore::inv_dd_f
static
Initial value:
Examples
EshelbianPlasticity.cpp.

Definition at line 835 of file EshelbianPlasticity.hpp.

◆ inv_f

boost::function< double(const double)> EshelbianPlasticity::EshelbianCore::inv_f
static
Initial value:
Examples
EshelbianOperators.cpp, and EshelbianPlasticity.cpp.

Definition at line 833 of file EshelbianPlasticity.hpp.

◆ lambdaField

const std::string EshelbianPlasticity::EshelbianCore::lambdaField

Definition at line 900 of file EshelbianPlasticity.hpp.

◆ materialGradient

const std::string EshelbianPlasticity::EshelbianCore::materialGradient

Definition at line 898 of file EshelbianPlasticity.hpp.

◆ materialL2Disp

const std::string EshelbianPlasticity::EshelbianCore::materialL2Disp

Definition at line 895 of file EshelbianPlasticity.hpp.

◆ materialOrder

int EshelbianPlasticity::EshelbianCore::materialOrder

Definition at line 914 of file EshelbianPlasticity.hpp.

◆ mField

MoFEM::Interface& EshelbianPlasticity::EshelbianCore::mField

Definition at line 875 of file EshelbianPlasticity.hpp.

◆ naturalBcElement

const std::string EshelbianPlasticity::EshelbianCore::naturalBcElement

Definition at line 904 of file EshelbianPlasticity.hpp.

◆ physicalEquations

boost::shared_ptr<PhysicalEquations> EshelbianPlasticity::EshelbianCore::physicalEquations

Definition at line 878 of file EshelbianPlasticity.hpp.

◆ piolaStress

const std::string EshelbianPlasticity::EshelbianCore::piolaStress

Definition at line 891 of file EshelbianPlasticity.hpp.

◆ precEps

double EshelbianPlasticity::EshelbianCore::precEps

Definition at line 918 of file EshelbianPlasticity.hpp.

◆ precEpsOmega

double EshelbianPlasticity::EshelbianCore::precEpsOmega

Definition at line 919 of file EshelbianPlasticity.hpp.

◆ precEpsW

double EshelbianPlasticity::EshelbianCore::precEpsW

Definition at line 920 of file EshelbianPlasticity.hpp.

◆ rotAxis

const std::string EshelbianPlasticity::EshelbianCore::rotAxis

Definition at line 897 of file EshelbianPlasticity.hpp.

◆ rotSelector

enum RotSelector EshelbianPlasticity::EshelbianCore::rotSelector
static

◆ skinElement

const std::string EshelbianPlasticity::EshelbianCore::skinElement

Definition at line 906 of file EshelbianPlasticity.hpp.

◆ spaceH1Order

int EshelbianPlasticity::EshelbianCore::spaceH1Order

Definition at line 913 of file EshelbianPlasticity.hpp.

◆ spaceOrder

int EshelbianPlasticity::EshelbianCore::spaceOrder

Definition at line 912 of file EshelbianPlasticity.hpp.

◆ spatialH1Disp

const std::string EshelbianPlasticity::EshelbianCore::spatialH1Disp

Definition at line 894 of file EshelbianPlasticity.hpp.

◆ spatialL2Disp

const std::string EshelbianPlasticity::EshelbianCore::spatialL2Disp

Definition at line 893 of file EshelbianPlasticity.hpp.

◆ stretchSelector

enum StretchSelector EshelbianPlasticity::EshelbianCore::stretchSelector
static

◆ stretchTensor

const std::string EshelbianPlasticity::EshelbianCore::stretchTensor

Definition at line 896 of file EshelbianPlasticity.hpp.

◆ tauField

const std::string EshelbianPlasticity::EshelbianCore::tauField

Definition at line 899 of file EshelbianPlasticity.hpp.


The documentation for this struct was generated from the following files: