v0.15.0
Loading...
Searching...
No Matches
Static Public Member Functions | Static Private Attributes | List of all members
TSElasticPostStep Struct Reference
Collaboration diagram for TSElasticPostStep:
[legend]

Static Public Member Functions

static MoFEMErrorCode postStepInitialise (EshelbianCore *ep_ptr)
 
static MoFEMErrorCode postStepDestroy ()
 
static MoFEMErrorCode preStepFun (TS ts)
 
static MoFEMErrorCode postStepFun (TS ts)
 

Static Private Attributes

static SmartPetscObj< KSP > prjKsp
 
static SmartPetscObj< Vec > prjD
 
static SmartPetscObj< Vec > prjF
 
static SmartPetscObj< DM > prjDM
 
static EshelbianCore * epPtr
 
static boost::shared_ptr< FEMethod > preProcRhs
 

Detailed Description

Definition at line 9 of file TSElasticPostStep.cpp.

Member Function Documentation

◆ postStepDestroy()

static MoFEMErrorCode TSElasticPostStep::postStepDestroy ( )
inlinestatic
Examples
EshelbianPlasticity.cpp.

Definition at line 85 of file TSElasticPostStep.cpp.

85 {
86 MoFEMFunctionBegin;
87 prjKsp.reset();
88 prjD.reset();
89 prjF.reset();
90 prjDM.reset();
91 preProcRhs.reset();
92 MoFEMFunctionReturn(0);
93 };
MoFEMFunctionBegin
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition definitions.h:359
MoFEMFunctionReturn
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition definitions.h:432
TSElasticPostStep::prjD
static SmartPetscObj< Vec > prjD
Definition TSElasticPostStep.cpp:266
TSElasticPostStep::prjF
static SmartPetscObj< Vec > prjF
Definition TSElasticPostStep.cpp:267
TSElasticPostStep::prjKsp
static SmartPetscObj< KSP > prjKsp
Definition TSElasticPostStep.cpp:265
TSElasticPostStep::preProcRhs
static boost::shared_ptr< FEMethod > preProcRhs
Definition TSElasticPostStep.cpp:271
TSElasticPostStep::prjDM
static SmartPetscObj< DM > prjDM
Definition TSElasticPostStep.cpp:268

◆ postStepFun()

static MoFEMErrorCode TSElasticPostStep::postStepFun ( TS ts)
inlinestatic
Examples
EshelbianPlasticity.cpp.

Definition at line 223 of file TSElasticPostStep.cpp.

223 {
224 MoFEMFunctionBegin;
225
226 double time;
227 CHKERR TSGetTime(ts, &time);
228
229 MOFEM_LOG("EP", Sev::inform) << "Solve H1 post-step";
230 CHKERR VecZeroEntries(prjF);
231 CHKERR KSPSolve(prjKsp, prjF, prjD);
232 CHKERR VecGhostUpdateBegin(prjD, INSERT_VALUES, SCATTER_FORWARD);
233 CHKERR VecGhostUpdateEnd(prjD, INSERT_VALUES, SCATTER_FORWARD);
234 CHKERR DMoFEMMeshToLocalVector(prjDM, prjD, INSERT_VALUES, SCATTER_REVERSE);
235
236 if (EshelbianCore::crackingOn) {
237 switch (EshelbianCore::energyReleaseSelector) {
238 case GRIFFITH_FORCE:
239 case GRIFFITH_SKELETON:
240 MOFEM_LOG("EP", Sev::inform) << "Calculate Griffith force";
241 CHKERR epPtr->calculateFaceMaterialForce(1, ts);
242 break;
243 default:
244 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
245 "Energy release selector not handled");
246 };
247 if (EshelbianCore::crackingStartTime < time) {
248 MOFEM_LOG("EP", Sev::inform) << "Calculate faces orientation";
249
250 CHKERR epPtr->calculateOrientation(1, true);
251 }
252 }
253
254
255 // double time;
256 // CHKERR TSGetTime(ts, &time);
257 // preProcRhs->ts_t = time;
258 // CHKERR DMoFEMPreProcessFiniteElements(prjDM, preProcRhs.get());
259 CHKERR VecZeroEntries(epPtr->solTSStep);
260
261 MoFEMFunctionReturn(0);
262 };
MOFEM_DATA_INCONSISTENCY
@ MOFEM_DATA_INCONSISTENCY
Definition definitions.h:31
CHKERR
#define CHKERR
Inline error check.
Definition definitions.h:551
MoFEM::DMoFEMMeshToLocalVector
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:514
MOFEM_LOG
#define MOFEM_LOG(channel, severity)
Log.
Definition LogManager.hpp:316
EshelbianCore::crackingOn
static PetscBool crackingOn
Definition EshelbianCore.hpp:22
EshelbianCore::calculateFaceMaterialForce
MoFEMErrorCode calculateFaceMaterialForce(const int tag, TS ts)
EshelbianCore::crackingStartTime
static double crackingStartTime
Definition EshelbianCore.hpp:23
EshelbianCore::calculateOrientation
MoFEMErrorCode calculateOrientation(const int tag, bool set_orientation)
EshelbianCore::energyReleaseSelector
static enum EnergyReleaseSelector energyReleaseSelector
Definition EshelbianCore.hpp:33
EshelbianCore::solTSStep
SmartPetscObj< Vec > solTSStep
Definition EshelbianCore.hpp:433
TSElasticPostStep::epPtr
static EshelbianCore * epPtr
Definition TSElasticPostStep.cpp:269

◆ postStepInitialise()

static MoFEMErrorCode TSElasticPostStep::postStepInitialise ( EshelbianCore * ep_ptr)
inlinestatic
Examples
EshelbianPlasticity.cpp.

Definition at line 11 of file TSElasticPostStep.cpp.

11 {
12 MoFEMFunctionBegin;
13
14 epPtr = ep_ptr;
15
16 auto create_post_step_ksp = [&]() {
17 auto ksp = createKSP(epPtr->mField.get_comm());
18
19 auto set_up = [&]() {
20 MoFEMFunctionBegin;
21 using DomainEle = VolumeElementForcesAndSourcesCore;
22 using DomainEleOp = DomainEle::UserDataOperator;
23 using OpDomainMass = FormsIntegrators<DomainEleOp>::Assembly<
24 PETSC>::BiLinearForm<GAUSS>::OpMass<1, 3>;
25 using OpRhs = FormsIntegrators<DomainEleOp>::Assembly<
26 PETSC>::LinearForm<GAUSS>::OpBaseTimesVector<1, 3, 1>;
27 auto fe_lhs = boost::make_shared<DomainEle>(ep_ptr->mField);
28 auto fe_rhs = boost::make_shared<DomainEle>(ep_ptr->mField);
29
30 fe_lhs->getUserPolynomialBase() =
31 boost::shared_ptr<BaseFunction>(new CGGUserPolynomialBase());
32 fe_rhs->getUserPolynomialBase() =
33 boost::shared_ptr<BaseFunction>(new CGGUserPolynomialBase());
34 CHKERR
35 EshelbianPlasticity::AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(
36 fe_lhs->getOpPtrVector(), {L2}, ep_ptr->materialH1Positions,
37 ep_ptr->frontAdjEdges);
38 CHKERR
39 EshelbianPlasticity::AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(
40 fe_rhs->getOpPtrVector(), {L2}, ep_ptr->materialH1Positions,
41 ep_ptr->frontAdjEdges);
42
43 fe_lhs->getOpPtrVector().push_back(
44 new OpDomainMass(ep_ptr->spatialH1Disp, ep_ptr->spatialH1Disp));
45 auto w_ptr = boost::make_shared<MatrixDouble>();
46 fe_rhs->getOpPtrVector().push_back(
47 new OpCalculateVectorFieldValues<3>(ep_ptr->spatialL2Disp, w_ptr));
48 fe_rhs->getOpPtrVector().push_back(
49 new OpRhs(ep_ptr->spatialH1Disp, w_ptr));
50
51 CHKERR DMMoFEMKSPSetComputeOperators(ep_ptr->dmPrjSpatial,
52 ep_ptr->elementVolumeName, fe_lhs,
53 nullptr, nullptr);
54 CHKERR DMMoFEMKSPSetComputeRHS(ep_ptr->dmPrjSpatial,
55 ep_ptr->elementVolumeName, fe_rhs,
56 nullptr, nullptr);
57
58 // preProcRhs = boost::make_shared<FEMethod>();
59 // struct MinusOne : public ScalingMethod {
60 // double getScale(const double time) { return -time; }
61 // };
62 // preProcRhs->preProcessHook = EssentialPreProc<DisplacementCubitBcData>(
63 // ep_ptr->mField, preProcRhs, {boost::make_shared<MinusOne>()});
64
65 CHKERR KSPAppendOptionsPrefix(ksp, "prjspatial_");
66 CHKERR KSPSetFromOptions(ksp);
67 CHKERR KSPSetDM(ksp, ep_ptr->dmPrjSpatial);
68 CHKERR KSPSetUp(ksp);
69 MoFEMFunctionReturn(0);
70 };
71
72 CHK_THROW_MESSAGE(set_up(), "set up");
73
74 return ksp;
75 };
76
77 prjKsp = create_post_step_ksp();
78 prjD = createDMVector(ep_ptr->dmPrjSpatial);
79 prjF = vectorDuplicate(prjD);
80 prjDM = ep_ptr->dmPrjSpatial;
81
82 MoFEMFunctionReturn(0);
83 };
OpDomainMass
FormsIntegrators< DomainEleOp >::Assembly< PETSC >::BiLinearForm< GAUSS >::OpMass< 1, FIELD_DIM > OpDomainMass
Definition child_and_parent.cpp:52
DomainEle
ElementsAndOps< SPACE_DIM >::DomainEle DomainEle
[Define dimension]
Definition child_and_parent.cpp:34
CHK_THROW_MESSAGE
#define CHK_THROW_MESSAGE(err, msg)
Check and throw MoFEM exception.
Definition definitions.h:612
MoFEM::DMMoFEMKSPSetComputeRHS
PetscErrorCode DMMoFEMKSPSetComputeRHS(DM dm, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
Set compute operator for KSP solver via sub-matrix and IS.
Definition DMMoFEM.cpp:627
MoFEM::createDMVector
auto createDMVector(DM dm)
Get smart vector from DM.
Definition DMMoFEM.hpp:1102
MoFEM::DMMoFEMKSPSetComputeOperators
PetscErrorCode DMMoFEMKSPSetComputeOperators(DM dm, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
Set KSP operators and push mofem finite element methods.
Definition DMMoFEM.cpp:668
MoFEM::PETSC
@ PETSC
Definition FormsIntegrators.hpp:105
MoFEM::createKSP
auto createKSP(MPI_Comm comm)
Definition PetscSmartObj.hpp:269
MoFEM::vectorDuplicate
SmartPetscObj< Vec > vectorDuplicate(Vec vec)
Create duplicate vector of smart vector.
Definition PetscSmartObj.hpp:223
EshelbianCore::frontAdjEdges
boost::shared_ptr< Range > frontAdjEdges
Definition EshelbianCore.hpp:417
EshelbianCore::mField
MoFEM::Interface & mField
Definition EshelbianCore.hpp:175
EshelbianCore::spatialL2Disp
const std::string spatialL2Disp
Definition EshelbianCore.hpp:194
EshelbianCore::materialH1Positions
const std::string materialH1Positions
Definition EshelbianCore.hpp:197
EshelbianCore::elementVolumeName
const std::string elementVolumeName
Definition EshelbianCore.hpp:205
EshelbianCore::spatialH1Disp
const std::string spatialH1Disp
Definition EshelbianCore.hpp:196
EshelbianCore::dmPrjSpatial
SmartPetscObj< DM > dmPrjSpatial
Projection spatial displacement.
Definition EshelbianCore.hpp:190
MoFEM::CoreInterface::get_comm
virtual MPI_Comm & get_comm() const =0

◆ preStepFun()

static MoFEMErrorCode TSElasticPostStep::preStepFun ( TS ts)
inlinestatic
Examples
EshelbianPlasticity.cpp.

Definition at line 95 of file TSElasticPostStep.cpp.

95 {
96 MoFEMFunctionBegin;
97 MOFEM_LOG("EP", Sev::inform) << "Pre step";
98
99 double time;
100 CHKERR TSGetTime(ts, &time);
101
102 if (EshelbianCore::crackingOn && EshelbianCore::crackingStartTime < time) {
103
104 auto debug_crack = [&]() {
105 MoFEMFunctionBegin;
106
107 PetscBool debug_crack_mesh = PETSC_FALSE;
108 CHKERR PetscOptionsGetBool(PETSC_NULLPTR, "", "-debug_crack_mesh",
109 &debug_crack_mesh, PETSC_NULLPTR);
110 if (debug_crack_mesh) {
111
112 auto get_meshsets_from_block =
113 [](MoFEM::Interface &m_field, std::string block_name, int dim,
114 std::vector<EntityHandle> r) {
115
116 auto mesh_mng = m_field.getInterface<MeshsetsManager>();
117 auto bcs = mesh_mng->getCubitMeshsetPtr(
118
119 std::regex((boost::format("%s(.*)") % block_name).str())
120
121 );
122
123 for (auto bc : bcs) {
124 r.push_back(bc->getMeshset());
125 }
126
127 return r;
128 };
129
130 if (epPtr->mField.get_comm_rank() == 0) {
131
132 if (epPtr->maxMovedFaces) {
133 CHKERR epPtr->mField.getInterface<MeshsetsManager>()
134 ->addEntitiesToMeshset(BLOCKSET, epPtr->addCrackMeshsetId,
135 *epPtr->maxMovedFaces);
136 }
137
138 auto meshset_ptr = get_temp_meshset_ptr(epPtr->mField.get_moab());
139 Range tets;
140 CHKERR epPtr->mField.get_moab().get_entities_by_dimension(
141 *meshset_ptr, 3, tets);
142 CHKERR epPtr->mField.get_moab().add_entities(*meshset_ptr, tets);
143
144 std::vector<EntityHandle> meshsets;
145 meshsets.push_back(*meshset_ptr);
146
147 meshsets =
148 get_meshsets_from_block(epPtr->mField, "CRACK", 2, meshsets);
149 meshsets =
150 get_meshsets_from_block(epPtr->mField, "FRONT", 1, meshsets);
151 meshsets =
152 get_meshsets_from_block(epPtr->mField, "EDGE", 1, meshsets);
153
154 int time_step = 0;
155 CHKERR TSGetStepNumber(ts, &time_step);
156 std::string file_name =
157 "crack_meshsets_" + std::to_string(time_step) + ".h5m";
158 CHKERR epPtr->mField.get_moab().write_file(
159 file_name.c_str(), "MOAB", nullptr, meshsets.data());
160 }
161 }
162
163 MoFEMFunctionReturn(0);
164 };
165
166 CHKERR epPtr->setNewFrontCoordinates();
167 CHKERR debug_crack();
168 CHKERR epPtr->addCrackSurfaces();
169 CHKERR epPtr->projectGeometry();
170 }
171
172 Vec T;
173 CHKERR TSGetSolution(ts, &T);
174
175 auto zero_filled = [&](auto name) {
176 MoFEMFunctionBegin;
177 auto is_mng = epPtr->mField.getInterface<ISManager>();
178 SmartPetscObj<IS> is;
179 CHKERR is_mng->isCreateProblemFieldAndRankLocal(
180 "ELASTIC_PROBLEM", ROW, name, 0, MAX_DOFS_ON_ENTITY, is);
181 const int *index_ptr;
182 CHKERR ISGetIndices(is, &index_ptr);
183 int size;
184 CHKERR ISGetLocalSize(is, &size);
185 double *a;
186 CHKERR VecGetArray(T, &a);
187 for (auto i = 0; i != size; i++) {
188 a[index_ptr[i]] = 0;
189 }
190 CHKERR VecRestoreArray(T, &a);
191 CHKERR ISRestoreIndices(is, &index_ptr);
192 MoFEMFunctionReturn(0);
193 };
194
195 switch (EshelbianCore::gradApproximator) {
196 case NO_H1_CONFIGURATION:
197 break;
198 case LARGE_ROT:
199 MOFEM_LOG("EP", Sev::verbose) << "Zeroing (large) fields";
200 CHKERR zero_filled(epPtr->stretchTensor);
201 CHKERR zero_filled(epPtr->rotAxis);
202 break;
203 case MODERATE_ROT:
204 MOFEM_LOG("EP", Sev::verbose) << "Zeroing (moderate) fields";
205 CHKERR zero_filled(epPtr->stretchTensor);
206 CHKERR zero_filled(epPtr->rotAxis);
207 break;
208 case SMALL_ROT:
209 MOFEM_LOG("EP", Sev::verbose) << "Zeroing (small) fields";
210 CHKERR zero_filled(epPtr->stretchTensor);
211 CHKERR zero_filled(epPtr->rotAxis);
212 break;
213 }
214
215 CHKERR VecCopy(T, epPtr->solTSStep);
216 CHKERR VecGhostUpdateBegin(epPtr->solTSStep, INSERT_VALUES,
217 SCATTER_FORWARD);
218 CHKERR VecGhostUpdateEnd(epPtr->solTSStep, INSERT_VALUES, SCATTER_FORWARD);
219
220 MoFEMFunctionReturn(0);
221 }
a
constexpr double a
Definition approx_sphere.cpp:30
ROW
@ ROW
Definition definitions.h:136
MAX_DOFS_ON_ENTITY
#define MAX_DOFS_ON_ENTITY
Maximal number of DOFs on entity.
Definition definitions.h:249
BLOCKSET
@ BLOCKSET
Definition definitions.h:161
i
FTensor::Index< 'i', SPACE_DIM > i
Definition hcurl_divergence_operator_2d.cpp:27
MoFEM::PetscOptionsGetBool
PetscErrorCode PetscOptionsGetBool(PetscOptions *, const char pre[], const char name[], PetscBool *bval, PetscBool *set)
Definition DeprecatedPetsc.hpp:182
MoFEM::get_temp_meshset_ptr
auto get_temp_meshset_ptr(moab::Interface &moab)
Create smart pointer to temporary meshset.
Definition Templates.hpp:1920
sdf.r
int r
Definition sdf.py:8
EshelbianCore::projectGeometry
MoFEMErrorCode projectGeometry(const EntityHandle meshset=0)
EshelbianCore::gradApproximator
static enum RotSelector gradApproximator
Definition EshelbianCore.hpp:16
EshelbianCore::maxMovedFaces
boost::shared_ptr< Range > maxMovedFaces
Definition EshelbianCore.hpp:421
EshelbianCore::setNewFrontCoordinates
MoFEMErrorCode setNewFrontCoordinates()
EshelbianCore::rotAxis
const std::string rotAxis
Definition EshelbianCore.hpp:202
EshelbianCore::addCrackSurfaces
MoFEMErrorCode addCrackSurfaces(const bool debug=false)
EshelbianCore::addCrackMeshsetId
static int addCrackMeshsetId
Definition EshelbianCore.hpp:31
EshelbianCore::stretchTensor
const std::string stretchTensor
Definition EshelbianCore.hpp:201
MoFEM::CoreInterface::get_moab
virtual moab::Interface & get_moab()=0
MoFEM::CoreInterface::get_comm_rank
virtual int get_comm_rank() const =0
MoFEM::DeprecatedCoreInterface
Deprecated interface functions.
Definition DeprecatedCoreInterface.hpp:16
MoFEM::UnknownInterface::getInterface
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface reference to pointer of interface.
Definition UnknownInterface.hpp:93

Member Data Documentation

◆ epPtr

EshelbianCore * TSElasticPostStep::epPtr
staticprivate

Definition at line 269 of file TSElasticPostStep.cpp.

◆ preProcRhs

boost::shared_ptr< FEMethod > TSElasticPostStep::preProcRhs
staticprivate

Definition at line 271 of file TSElasticPostStep.cpp.

◆ prjD

SmartPetscObj< Vec > TSElasticPostStep::prjD
staticprivate

Definition at line 266 of file TSElasticPostStep.cpp.

◆ prjDM

SmartPetscObj< DM > TSElasticPostStep::prjDM
staticprivate

Definition at line 268 of file TSElasticPostStep.cpp.

◆ prjF

SmartPetscObj< Vec > TSElasticPostStep::prjF
staticprivate

Definition at line 267 of file TSElasticPostStep.cpp.

◆ prjKsp

SmartPetscObj< KSP > TSElasticPostStep::prjKsp
staticprivate

Definition at line 265 of file TSElasticPostStep.cpp.

The documentation for this struct was generated from the following file:
Generated by Doxygen 1.12.0 and hosted at University of Glasgow