v0.15.5
Loading...
Searching...
No Matches
Public Member Functions | Protected Member Functions | List of all members
ArcLengthExample Struct Reference

#include "tutorials/vec-9_arc_length/src/ArcLengthExample.hpp"

Inheritance diagram for ArcLengthExample:
[legend]
Collaboration diagram for ArcLengthExample:
[legend]

Public Member Functions

 ArcLengthExample (MoFEM::Interface &m_field)
 
MoFEMErrorCode runProblem ()
 [Run problem]
 
- Public Member Functions inherited from NonlinearElasticExample
 NonlinearElasticExample (MoFEM::Interface &m_field)
 
MoFEMErrorCode runProblem ()
 [Run problem]
 

Protected Member Functions

MoFEMErrorCode ArcLengthSolve ()
 [Run problem]
 
MoFEMErrorCode checkResults ()
 [Arc Length Solve]
 
- Protected Member Functions inherited from NonlinearElasticExample
MoFEMErrorCode readMesh ()
 [Run problem]
 
MoFEMErrorCode setupProblem ()
 [Read mesh]
 
MoFEMErrorCode boundaryCondition ()
 [Set up problem]
 
MoFEMErrorCode assembleSystemHencky ()
 [Boundary condition]
 
MoFEMErrorCode assembleSystemAdolc ()
 
MoFEMErrorCode opTest ()
 [Push operators to pipeline]
 
MoFEMErrorCode TsSolve ()
 [TS Solve]
 
MoFEMErrorCode gettingNorms ()
 [TS Solve]
 
MoFEMErrorCode outputResults ()
 [Getting norms]
 
MoFEMErrorCode checkResults ()
 [Postprocessing results]
 

Additional Inherited Members

- Static Protected Member Functions inherited from NonlinearElasticExample
static auto get_skin (MoFEM::Interface &m_field, Range body_ents)
 
static auto filter_true_skin (MoFEM::Interface &m_field, Range &&skin)
 
- Protected Attributes inherited from NonlinearElasticExample
MoFEM::Interface & mField
 
boost::shared_ptr< DomainEle > reactionFe
 
boost::shared_ptr< PostProcEleDomain > postProcDomainFe
 
boost::shared_ptr< PostProcEleBdy > postProcBdyFe
 
PetscBool useAdolcMaterial = PETSC_FALSE
 
std::vector< Tag > listTagsToTransfer
 list of tags to transfer to postprocessor
 
boost::shared_ptr< AdolCOps::PhysicalEquations > physicalEquationsPtr
 
boost::shared_ptr< AdolCOps::PhysicalEquations > physicalHuHuPtr
 
- Static Protected Attributes inherited from NonlinearElasticExample
static constexpr int modelType
 

Detailed Description

Examples
mofem/tutorials/vec-9_arc_length/arc_length.cpp, and mofem/tutorials/vec-9_arc_length/src/ArcLengthExample.hpp.

Definition at line 13 of file ArcLengthExample.hpp.

Constructor & Destructor Documentation

◆ ArcLengthExample()

ArcLengthExample::ArcLengthExample ( MoFEM::Interface &  m_field)
inline

Definition at line 15 of file ArcLengthExample.hpp.

16 : NonlinearElasticExample(m_field) {}

Member Function Documentation

◆ ArcLengthSolve()

MoFEMErrorCode ArcLengthExample::ArcLengthSolve ( )
protected

[Run problem]

[Arc Length Solve]

[Define gravity vector]

Examples
mofem/tutorials/vec-9_arc_length/src/ArcLengthExample.hpp.

Definition at line 61 of file ArcLengthExample.hpp.

61 {
62 MoFEMFunctionBegin;
63 auto *simple = mField.getInterface<Simple>();
64 auto *pipeline_mng = mField.getInterface<PipelineManager>();
65
66 auto dm = simple->getDM();
67 auto snes = pipeline_mng->createSNES();
68 ExampleTimeScale::snesPtr = snes;
69
70 PetscBool post_proc_vol;
71 PetscBool post_proc_skin;
72
73 if constexpr (SPACE_DIM == 2) {
74 post_proc_vol = PETSC_TRUE;
75 post_proc_skin = PETSC_FALSE;
76 } else {
77 post_proc_vol = PETSC_FALSE;
78 post_proc_skin = PETSC_TRUE;
79 }
80 CHKERR PetscOptionsGetBool(PETSC_NULLPTR, "", "-post_proc_vol",
81 &post_proc_vol, PETSC_NULLPTR);
82 CHKERR PetscOptionsGetBool(PETSC_NULLPTR, "", "-post_proc_skin",
83 &post_proc_skin, PETSC_NULLPTR);
84
85 // Setup postprocessing
86 auto create_post_proc_fe = [dm, this, simple, post_proc_vol,
87 post_proc_skin]() {
88 auto post_proc_ele_domain = [dm, this](auto &pip_domain) {
89 CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(pip_domain, {H1},
90 "GEOMETRY");
91 auto common_ptr = commonDataFactory<SPACE_DIM, GAUSS, DomainEleOp>(
92 mField, pip_domain, "U", "MAT_ELASTIC", Sev::inform);
93 return common_ptr;
94 };
95
96 auto post_proc_map = [this](auto &pip, auto u_ptr, auto common_ptr) {
97 MoFEMFunctionBegin;
98
99 using OpPPMap = OpPostProcMapInMoab<SPACE_DIM, SPACE_DIM>;
100
101 auto X_ptr = boost::make_shared<MatrixDouble>();
102
103 pip->getOpPtrVector().push_back(
104 new OpCalculateVectorFieldValues<SPACE_DIM>("GEOMETRY", X_ptr));
105
106 pip->getOpPtrVector().push_back(
107
108 new OpPPMap(pip->getPostProcMesh(), pip->getMapGaussPts(), {},
109 {{"U", u_ptr}, {"GEOMETRY", X_ptr}},
110 {{"GRAD", common_ptr->matGradPtr},
111 {"FIRST_PIOLA", common_ptr->getMatFirstPiolaStress()}},
112 {}));
113 MoFEMFunctionReturn(0);
114 };
115
116 auto push_post_proc_bdy = [dm, this, simple, post_proc_skin,
117 &post_proc_ele_domain,
118 &post_proc_map](auto &pip_bdy) {
119 if (post_proc_skin == PETSC_FALSE)
120 return boost::shared_ptr<PostProcEleBdy>();
121
122 auto u_ptr = boost::make_shared<MatrixDouble>();
123 pip_bdy->getOpPtrVector().push_back(
124 new OpCalculateVectorFieldValues<SPACE_DIM>("U", u_ptr));
125 auto op_loop_side =
126 new OpLoopSide<SideEle>(mField, simple->getDomainFEName(), SPACE_DIM);
127 auto common_ptr = post_proc_ele_domain(op_loop_side->getOpPtrVector());
128 pip_bdy->getOpPtrVector().push_back(op_loop_side);
129
130 CHKERR post_proc_map(pip_bdy, u_ptr, common_ptr);
131
132 return pip_bdy;
133 };
134
135 auto push_post_proc_domain = [dm, this, simple, post_proc_vol,
136 &post_proc_ele_domain,
137 &post_proc_map](auto &pip_domain) {
138 if (post_proc_vol == PETSC_FALSE)
139 return boost::shared_ptr<PostProcEleDomain>();
140
141 auto u_ptr = boost::make_shared<MatrixDouble>();
142 pip_domain->getOpPtrVector().push_back(
143 new OpCalculateVectorFieldValues<SPACE_DIM>("U", u_ptr));
144 auto common_ptr = post_proc_ele_domain(pip_domain->getOpPtrVector());
145
146 CHKERR post_proc_map(pip_domain, u_ptr, common_ptr);
147
148 return pip_domain;
149 };
150
151 auto post_proc_fe_domain = boost::make_shared<PostProcEleDomain>(mField);
152 auto post_proc_fe_bdy = boost::make_shared<PostProcEleBdy>(mField);
153
154 return std::make_pair(push_post_proc_domain(post_proc_fe_domain),
155 push_post_proc_bdy(post_proc_fe_bdy));
156 };
157
158 auto add_arc_length_load_tangent_operator = [&](auto snes) {
159 MoFEMFunctionBegin;
160 auto bdy_pipeline = boost::make_shared<BoundaryEle>(mField);
161 auto domain_pipeline = boost::make_shared<DomainEle>(mField);
162
163 auto integration_rule = [](int, int, int approx_order) {
164 return 2 * (approx_order - 1);
165 };
166 bdy_pipeline->getRuleHook = integration_rule;
167 domain_pipeline->getRuleHook = integration_rule;
168
169 struct TimeOne : TimeScale {
170 double getScale(const double) override { return -1.; }
171 };
172 auto time_one = boost::make_shared<TimeOne>();
173
174 // The trick is here, that is assumed that load is applied linearly
175 // proportional to the load factor (time in this case). So derivative of the
176 // load with respect to the load factor is the same as the load at time
177 // = 1.0
178
179 CHKERR BoundaryNaturalBC::AddFluxToPipeline<OpForce>::add(
180 bdy_pipeline->getOpPtrVector(), mField, "U", {time_one}, "FORCE",
181 "PRESSURE", Sev::inform);
182 //! [Define gravity vector]
183 CHKERR DomainNaturalBC::AddFluxToPipeline<OpBodyForce>::add(
184 domain_pipeline->getOpPtrVector(), mField, "U", {time_one},
185 "BODY_FORCE", Sev::inform);
186
187 auto snes_ctx_ptr = getDMSnesCtx(simple->getDM());
188 snes_ctx_ptr->getLoadTangent().push_back(
189 {simple->getBoundaryFEName(), bdy_pipeline});
190 snes_ctx_ptr->getLoadTangent().push_back(
191 {simple->getDomainFEName(), domain_pipeline});
192
193 auto time_scale = boost::make_shared<ExampleTimeScale>();
194
195 auto pre_proc_ptr = boost::make_shared<FEMethod>();
196 auto get_bc_hook_rhs = [this, pre_proc_ptr, time_scale]() {
197 MoFEMFunctionBeginHot;
198 CHKERR EssentialPreProc<DisplacementCubitBcData>(mField, pre_proc_ptr,
199 {time_scale}, false)();
200 MoFEMFunctionReturnHot(0);
201 };
202 pre_proc_ptr->preProcessHook = get_bc_hook_rhs;
203 snes_ctx_ptr->getPreProcLoadTangent().push_back(pre_proc_ptr);
204 auto post_proc_rhs_ptr = boost::make_shared<FEMethod>();
205 auto get_post_proc_hook_rhs = [this, post_proc_rhs_ptr]() {
206 MoFEMFunctionBegin;
207 CHKERR EssentialPostProcRhs<DisplacementCubitBcData>(
208 mField, post_proc_rhs_ptr, 0.)();
209 MoFEMFunctionReturn(0);
210 };
211 post_proc_rhs_ptr->postProcessHook = get_post_proc_hook_rhs;
212 snes_ctx_ptr->getPostProcLoadTangent().push_back(post_proc_rhs_ptr);
213
214 CHKERR SNESNewtonALSetFunction(snes, SnesLoadTangent, snes_ctx_ptr.get());
215
216 MoFEMFunctionReturn(0);
217 };
218
219 auto add_extra_finite_elements_to_solver_pipelines = [&]() {
220 MoFEMFunctionBegin;
221
222 auto pre_proc_ptr = boost::make_shared<FEMethod>();
223 auto post_proc_rhs_ptr = boost::make_shared<FEMethod>();
224 auto post_proc_lhs_ptr = boost::make_shared<FEMethod>();
225
226 auto time_scale = boost::make_shared<ExampleTimeScale>();
227
228 auto get_bc_hook_rhs = [this, pre_proc_ptr, time_scale]() {
229 MoFEMFunctionBeginHot;
230 CHKERR EssentialPreProc<DisplacementCubitBcData>(mField, pre_proc_ptr,
231 {time_scale}, false)();
232 MoFEMFunctionReturnHot(0);
233 };
234
235 pre_proc_ptr->preProcessHook = get_bc_hook_rhs;
236
237 auto get_post_proc_hook_rhs = [this, post_proc_rhs_ptr]() {
238 MoFEMFunctionBegin;
239 CHKERR EssentialPreProcReaction<DisplacementCubitBcData>(
240 mField, post_proc_rhs_ptr, nullptr, Sev::verbose)();
241 CHKERR EssentialPostProcRhs<DisplacementCubitBcData>(
242 mField, post_proc_rhs_ptr, 1.)();
243 MoFEMFunctionReturn(0);
244 };
245 auto get_post_proc_hook_lhs = [this, post_proc_lhs_ptr]() {
246 MoFEMFunctionBegin;
247 CHKERR EssentialPostProcLhs<DisplacementCubitBcData>(
248 mField, post_proc_lhs_ptr, 1.)();
249 MoFEMFunctionReturn(0);
250 };
251 post_proc_rhs_ptr->postProcessHook = get_post_proc_hook_rhs;
252 post_proc_lhs_ptr->postProcessHook = get_post_proc_hook_lhs;
253
254 // This is low level pushing finite elements (pipelines) to solver
255 auto snes_ctx_ptr = getDMSnesCtx(simple->getDM());
256 snes_ctx_ptr->getPreProcComputeRhs().push_front(pre_proc_ptr);
257 snes_ctx_ptr->getPreProcSetOperators().push_front(pre_proc_ptr);
258 snes_ctx_ptr->getPostProcComputeRhs().push_back(post_proc_rhs_ptr);
259 snes_ctx_ptr->getPostProcSetOperators().push_back(post_proc_lhs_ptr);
260 MoFEMFunctionReturn(0);
261 };
262
263 auto set_log_and_post_hook = [this](auto post_proc_fe, auto post_proc_bdy) {
264 MoFEMFunctionBegin;
265
266 auto make_vtk = [this, post_proc_fe, post_proc_bdy](auto iter,
267 auto cache_ptr) {
268 MoFEMFunctionBegin;
269 auto simple = mField.getInterface<Simple>();
270 auto dm = simple->getDM();
271 if (post_proc_fe) {
272 CHKERR DMoFEMLoopFiniteElements(dm, "dFE", post_proc_fe, cache_ptr);
273 CHKERR post_proc_fe->writeFile(
274 "out_step_" + boost::lexical_cast<std::string>(iter) + ".h5m");
275 }
276 if (post_proc_bdy) {
277 CHKERR DMoFEMLoopFiniteElements(dm, "bFE", post_proc_bdy, cache_ptr);
278 CHKERR post_proc_bdy->writeFile(
279 "out_skin_" + boost::lexical_cast<std::string>(iter) + ".h5m");
280 }
281 MoFEMFunctionReturn(0);
282 };
283
284 auto hook = [this, make_vtk](SNES snes, Vec x, Vec F,
285 boost::shared_ptr<CacheTuple> cache_ptr,
286 void *ctx) -> MoFEMErrorCode {
287 MoFEMFunctionBegin;
288
289 double atol, rtol, stol;
290 int maxit, maxf;
291 CHKERR SNESGetTolerances(snes, &atol, &rtol, &stol, &maxit, &maxf);
292
293 double lambda;
294 CHKERR SNESNewtonALGetLoadParameter(snes, &lambda);
295
296 double nrm;
297 CHKERR VecNorm(F, NORM_2, &nrm);
298
299 int iter;
300 CHKERR SNESGetIterationNumber(snes, &iter);
301 SNESConvergedReason reason;
302 CHKERR SNESGetConvergedReason(snes, &reason);
303 MOFEM_LOG_C("EXAMPLE", Sev::inform,
304 "SNES iteration %d, reason %d nrm2 %g lambda %g", iter,
305 reason, nrm, lambda);
306
307 CHKERR make_vtk(iter, cache_ptr);
308
309 MoFEMFunctionReturn(0);
310 };
311
312 auto simple = mField.getInterface<Simple>();
313 auto snes_ctx_ptr = getDMSnesCtx(simple->getDM());
314 snes_ctx_ptr->getRhsHook() = hook;
315
316 MoFEMFunctionReturn(0);
317 };
318
319 // Set arc length solver
320 auto D = createDMVector(simple->getDM());
321 CHKERR SNESSetType(snes, SNESNEWTONLS);
322 CHKERR SNESSetFromOptions(snes);
323
324 auto B = createDMMatrix(dm);
325 CHKERR SNESSetJacobian(snes, B, B, PETSC_NULLPTR, PETSC_NULLPTR);
326 // Add extra finite elements to SNES solver pipelines to resolve essential
327 // boundary conditions
328 CHKERR add_extra_finite_elements_to_solver_pipelines();
329 CHKERR add_arc_length_load_tangent_operator(snes);
330
331 auto [post_proc_fe, post_proc_bdy] = create_post_proc_fe();
332 CHKERR set_log_and_post_hook(post_proc_fe, post_proc_bdy);
333
334 CHKERR SNESSolve(snes, PETSC_NULLPTR, D);
335
336 MoFEMFunctionReturn(0);
337}
MOFEM_LOG_C
#define MOFEM_LOG_C(channel, severity, format,...)
Definition LogManager.hpp:319
simple
void simple(double P1[], double P2[], double P3[], double c[], const int N)
Definition acoustic.cpp:69
SPACE_DIM
constexpr int SPACE_DIM
Definition child_and_parent.cpp:17
MoFEMFunctionReturnHot
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition definitions.h:463
H1
@ H1
continuous field
Definition definitions.h:85
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
CHKERR
#define CHKERR
Inline error check.
Definition definitions.h:551
MoFEMFunctionBeginHot
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition definitions.h:456
F
@ F
Definition free_surface.cpp:625
integration_rule
auto integration_rule
Definition free_surface.cpp:207
MoFEM::DMoFEMLoopFiniteElements
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:576
MoFEM::createDMVector
auto createDMVector(DM dm, RowColData rc=RowColData::COL)
Get smart vector from DM.
Definition DMMoFEM.hpp:1237
MoFEM::createDMMatrix
auto createDMMatrix(DM dm)
Get smart matrix from DM.
Definition DMMoFEM.hpp:1194
lambda
static double lambda
Definition incompressible_elasticity.cpp:181
D
double D
Definition initial_diffusion.cpp:44
EigenMatrix::Vec
const FTensor::Tensor2< T, Dim, Dim > Vec
Definition MatrixFunction.hpp:64
MoFEM::PetscOptionsGetBool
PetscErrorCode PetscOptionsGetBool(PetscOptions *, const char pre[], const char name[], PetscBool *bval, PetscBool *set)
Definition DeprecatedPetsc.hpp:182
MoFEM::getDMSnesCtx
auto getDMSnesCtx(DM dm)
Get SNES context data structure used by DM.
Definition DMMoFEM.hpp:1265
OpPPMap
OpPostProcMapInMoab< SPACE_DIM, SPACE_DIM > OpPPMap
Definition photon_diffusion.cpp:29
approx_order
static constexpr int approx_order
Definition prism_polynomial_approximation.cpp:14
MoFEM::UnknownInterface::getInterface
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface reference to pointer of interface.
Definition UnknownInterface.hpp:93

◆ checkResults()

MoFEMErrorCode ArcLengthExample::checkResults ( )
protected

[Arc Length Solve]

[Check]

Examples
mofem/tutorials/vec-9_arc_length/src/ArcLengthExample.hpp.

Definition at line 341 of file ArcLengthExample.hpp.

341 {
342 MoFEMFunctionBegin;
343 PetscInt test_nb = 0;
344 PetscBool test_flg = PETSC_FALSE;
345 CHKERR PetscOptionsGetInt(PETSC_NULLPTR, "", "-test", &test_nb, &test_flg);
346
347 if (test_flg) {
348 auto simple = mField.getInterface<Simple>();
349 auto T = createDMVector(simple->getDM());
350 CHKERR DMoFEMMeshToLocalVector(simple->getDM(), T, INSERT_VALUES,
351 SCATTER_FORWARD);
352 double nrm2;
353 CHKERR VecNorm(T, NORM_2, &nrm2);
354 MOFEM_LOG("EXAMPLE", Sev::verbose) << "Regression norm " << nrm2;
355 double regression_value = 0;
356 switch (test_nb) {
357 case 1:
358 regression_value = 1.215134e-04;
359 break;
360 default:
361 SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID, "Wrong test number.");
362 break;
363 }
364 if (fabs(nrm2 - regression_value) > 1e-2)
365 SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
366 "Regression test field; wrong norm value. %6.4e != %6.4e", nrm2,
367 regression_value);
368 }
369 MoFEMFunctionReturn(0);
370}
MOFEM_ATOM_TEST_INVALID
@ MOFEM_ATOM_TEST_INVALID
Definition definitions.h:40
MoFEM::DMoFEMMeshToLocalVector
PetscErrorCode DMoFEMMeshToLocalVector(DM dm, Vec l, InsertMode mode, ScatterMode scatter_mode, RowColData rc=RowColData::COL)
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
MoFEM::PetscOptionsGetInt
PetscErrorCode PetscOptionsGetInt(PetscOptions *, const char pre[], const char name[], PetscInt *ivalue, PetscBool *set)
Definition DeprecatedPetsc.hpp:142

◆ runProblem()

MoFEMErrorCode ArcLengthExample::runProblem ( )

[Run problem]

Examples
mofem/tutorials/vec-9_arc_length/src/ArcLengthExample.hpp.

Definition at line 26 of file ArcLengthExample.hpp.

26 {
27 MoFEMFunctionBegin;
28
29 CHKERR readMesh();
30 CHKERR setupProblem();
31 CHKERR boundaryCondition();
32
33 PetscBool test_op = PETSC_FALSE;
34 CHKERR PetscOptionsGetBool(PETSC_NULLPTR, "", "-test_op", &test_op,
35 PETSC_NULLPTR);
36
37 if (useAdolcMaterial == PETSC_TRUE) {
38 CHKERR assembleSystemAdolc();
39 if (test_op == PETSC_TRUE) {
40 CHKERR opTest();
41 }
42 } else {
43 CHKERR assembleSystemHencky();
44 if (test_op == PETSC_TRUE) {
45 CHKERR opTest();
46 }
47 }
48
49 CHKERR ArcLengthSolve();
50 CHKERR gettingNorms();
51 CHKERR outputResults();
52 CHKERR checkResults();
53
54 ExampleTimeScale::snesPtr.reset();
55
56 MoFEMFunctionReturn(0);
57}
ArcLengthExample::checkResults
MoFEMErrorCode checkResults()
[Arc Length Solve]
Definition ArcLengthExample.hpp:341
ArcLengthExample::ArcLengthSolve
MoFEMErrorCode ArcLengthSolve()
[Run problem]
Definition ArcLengthExample.hpp:61
NonlinearElasticExample::setupProblem
MoFEMErrorCode setupProblem()
[Read mesh]
Definition NonlinearElasticExample.hpp:123
NonlinearElasticExample::readMesh
MoFEMErrorCode readMesh()
[Run problem]
Definition NonlinearElasticExample.hpp:113
NonlinearElasticExample::assembleSystemHencky
MoFEMErrorCode assembleSystemHencky()
[Boundary condition]
Definition NonlinearElasticExample.hpp:315
NonlinearElasticExample::boundaryCondition
MoFEMErrorCode boundaryCondition()
[Set up problem]
Definition NonlinearElasticExample.hpp:273
NonlinearElasticExample::opTest
MoFEMErrorCode opTest()
[Push operators to pipeline]
Definition NonlinearElasticExample.hpp:433
NonlinearElasticExample::outputResults
MoFEMErrorCode outputResults()
[Getting norms]
Definition NonlinearElasticExample.hpp:824
NonlinearElasticExample::gettingNorms
MoFEMErrorCode gettingNorms()
[TS Solve]
Definition NonlinearElasticExample.hpp:745
The documentation for this struct was generated from the following file:
Generated by Doxygen 1.9.8 and hosted at University of Glasgow