v0.16.0
Loading...
Searching...
No Matches
Functions | Variables
testing_jacobian_of_surface_pressure_element.cpp File Reference
#include <BasicFiniteElements.hpp>

Go to the source code of this file.

Functions

int main (int argc, char *argv[])
 

Variables

static char help [] = "\n"
 

Function Documentation

◆ main()

int main ( int  argc,
char *  argv[] 
)

Definition at line 19 of file testing_jacobian_of_surface_pressure_element.cpp.

19 {
20
21 // Initialize MoFEM
22 MoFEM::Core::Initialize(&argc, &argv, (char *)0, help);
23
24 // Create mesh database
25 moab::Core mb_instance; // create database
26 moab::Interface &moab = mb_instance; // create interface to database
27
28 try {
29 // Create MoFEM database and link it to MoAB
30 MoFEM::Core core(moab);
31 MoFEM::Interface &m_field = core;
32
33 PetscInt order_x = 2;
34 PetscInt order_X = 2;
35 PetscBool flg = PETSC_TRUE;
36
37 PetscBool test_jacobian = PETSC_FALSE;
38 CHKERR PetscOptionsGetBool(PETSC_NULLPTR, "", "-test_jacobian", &test_jacobian,
39 PETSC_NULLPTR);
40 CHKERR PetscOptionsGetInt(PETSC_NULLPTR, PETSC_NULLPTR, "-order_spat", &order_x,
41 &flg);
42 CHKERR PetscOptionsGetInt(PETSC_NULLPTR, PETSC_NULLPTR, "-order_mat", &order_X,
43 &flg);
44
45 CHKERR DMRegister_MoFEM("DMMOFEM");
46
47 Simple *si = m_field.getInterface<MoFEM::Simple>();
48
49 CHKERR si->getOptions();
50 CHKERR si->loadFile();
51 CHKERR si->addDomainField("SPATIAL_POSITION", H1, AINSWORTH_LOBATTO_BASE,
52 3);
53 CHKERR si->addBoundaryField("SPATIAL_POSITION", H1, AINSWORTH_LOBATTO_BASE,
54 3);
55 CHKERR si->setFieldOrder("SPATIAL_POSITION", order_x);
56
57 CHKERR si->addDomainField("MESH_NODE_POSITIONS", H1,
58 AINSWORTH_LEGENDRE_BASE, 3);
59 CHKERR si->addBoundaryField("MESH_NODE_POSITIONS", H1,
60 AINSWORTH_LEGENDRE_BASE, 3);
61 CHKERR si->setFieldOrder("MESH_NODE_POSITIONS", order_X);
62
63 Range triangle_springs;
64 for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(m_field, BLOCKSET, it)) {
65 if (it->getName().compare(0, 9, "SPRING_BC") == 0) {
66 CHKERR m_field.get_moab().get_entities_by_type(it->meshset, MBTRI,
67 triangle_springs, true);
68 }
69 }
70
71 // Add spring boundary condition applied on surfaces.
72 CHKERR MetaSpringBC::addSpringElements(m_field, "SPATIAL_POSITION",
73 "MESH_NODE_POSITIONS");
74 CHKERR MetaSpringBC::addSpringElementsALE(
75 m_field, "SPATIAL_POSITION", "MESH_NODE_POSITIONS", triangle_springs);
76 si->getOtherFiniteElements().push_back("SPRING");
77 si->getOtherFiniteElements().push_back("SPRING_ALE");
78 CHKERR si->setUp();
79
80 // create DM
81 DM dm;
82 CHKERR si->getDM(&dm);
83
84 PetscRandom rctx;
85 PetscRandomCreate(PETSC_COMM_WORLD, &rctx);
86
87 auto set_coord = [&](VectorAdaptor &&field_data, double *x, double *y,
88 double *z) {
89 MoFEMFunctionBegin;
90 double value;
91 double scale = 0.5;
92 PetscRandomGetValue(rctx, &value);
93 field_data[0] = (*x) + (value - 0.5) * scale;
94 PetscRandomGetValue(rctx, &value);
95 field_data[1] = (*y) + (value - 0.5) * scale;
96 PetscRandomGetValue(rctx, &value);
97 field_data[2] = (*z) + (value - 0.5) * scale;
98 MoFEMFunctionReturn(0);
99 };
100
101 CHKERR m_field.getInterface<FieldBlas>()->setVertexDofs(set_coord,
102 "SPATIAL_POSITION");
103 CHKERR m_field.getInterface<FieldBlas>()->setVertexDofs(
104 set_coord, "MESH_NODE_POSITIONS");
105
106 PetscRandomDestroy(&rctx);
107
108 boost::shared_ptr<NeumannForcesSurface> surfacePressure(
109 new NeumannForcesSurface(m_field));
110
111 boost::shared_ptr<NeumannForcesSurface::MyTriangleFE> fe_rhs_ptr(
112 surfacePressure, &(surfacePressure->getLoopFe()));
113 boost::shared_ptr<NeumannForcesSurface::MyTriangleFE> fe_lhs_ptr(
114 surfacePressure, &(surfacePressure->getLoopFeLhs()));
115 boost::shared_ptr<NeumannForcesSurface::MyTriangleFE> fe_mat_rhs_ptr(
116 surfacePressure, &(surfacePressure->getLoopFeMatRhs()));
117 boost::shared_ptr<NeumannForcesSurface::MyTriangleFE> fe_mat_lhs_ptr(
118 surfacePressure, &(surfacePressure->getLoopFeMatLhs()));
119
120 CHKERR AddHOOps<2, 3, 3>::add(fe_rhs_ptr->getOpPtrVector(), {},
121 "MESH_NODE_POSITIONS");
122 CHKERR AddHOOps<2, 3, 3>::add(fe_lhs_ptr->getOpPtrVector(), {},
123 "MESH_NODE_POSITIONS");
124 CHKERR AddHOOps<2, 3, 3>::add(fe_mat_rhs_ptr->getOpPtrVector(), {},
125 "MESH_NODE_POSITIONS");
126 CHKERR AddHOOps<2, 3, 3>::add(fe_mat_lhs_ptr->getOpPtrVector(), {},
127 "MESH_NODE_POSITIONS");
128
129 boost::shared_ptr<NeumannForcesSurface> surfaceForce(
130 new NeumannForcesSurface(m_field));
131
132 boost::shared_ptr<NeumannForcesSurface::MyTriangleFE>
133 fe_rhs_surface_force_ptr(surfaceForce, &(surfaceForce->getLoopFe()));
134 boost::shared_ptr<NeumannForcesSurface::MyTriangleFE>
135 fe_lhs_surface_force_ptr(surfaceForce, &(surfaceForce->getLoopFeLhs()));
136 boost::shared_ptr<NeumannForcesSurface::MyTriangleFE>
137 fe_mat_rhs_surface_force_ptr(surfaceForce,
138 &(surfaceForce->getLoopFeMatRhs()));
139 boost::shared_ptr<NeumannForcesSurface::MyTriangleFE>
140 fe_mat_lhs_surface_force_ptr(surfaceForce,
141 &(surfaceForce->getLoopFeMatLhs()));
142
143 CHKERR AddHOOps<2, 3, 3>::add(
144 fe_rhs_surface_force_ptr->getOpPtrVector(), {},
145 "MESH_NODE_POSITIONS");
146 CHKERR AddHOOps<2, 3, 3>::add(
147 fe_lhs_surface_force_ptr->getOpPtrVector(), {},
148 "MESH_NODE_POSITIONS");
149 CHKERR AddHOOps<2, 3, 3>::add(
150 fe_mat_rhs_surface_force_ptr->getOpPtrVector(), {},
151 "MESH_NODE_POSITIONS");
152 CHKERR AddHOOps<2, 3, 3>::add(
153 fe_mat_lhs_surface_force_ptr->getOpPtrVector(), {},
154 "MESH_NODE_POSITIONS");
155
156 Range nodes;
157 CHKERR moab.get_entities_by_type(0, MBVERTEX, nodes, false);
158
159 nodes.pop_front();
160 nodes.pop_back();
161
162 boost::shared_ptr<NeumannForcesSurface::DataAtIntegrationPts> dataAtPts =
163 boost::make_shared<NeumannForcesSurface::DataAtIntegrationPts>();
164
165 dataAtPts->forcesOnlyOnEntitiesRow = nodes;
166
167 for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(m_field, BLOCKSET, bit)) {
168 if (bit->getName().compare(0, 8, "PRESSURE") == 0) {
169 CHKERR surfacePressure->addPressure("SPATIAL_POSITION", PETSC_NULLPTR,
170 bit->getMeshsetId(), true, true);
171 CHKERR surfacePressure->addPressureAle(
172 "SPATIAL_POSITION", "MESH_NODE_POSITIONS", dataAtPts,
173 si->getDomainFEName(), PETSC_NULLPTR, PETSC_NULLPTR, bit->getMeshsetId(),
174 true, true);
175 }
176 }
177
178 const string block_set_force_name("FORCE");
179 // search for block named FORCE and add its attributes to FORCE_FE element
180 for (_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(m_field, NODESET | FORCESET,
181 bit)) {
182 CHKERR surfaceForce->addForce("SPATIAL_POSITION", PETSC_NULLPTR,
183 (bit->getMeshsetId()), true, false);
184 CHKERR surfaceForce->addForceAle(
185 "SPATIAL_POSITION", "MESH_NODE_POSITIONS", dataAtPts,
186 si->getDomainFEName(), PETSC_NULLPTR, PETSC_NULLPTR, bit->getMeshsetId(),
187 true, false, false);
188 }
189
190 for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(m_field, BLOCKSET, it)) {
191 if (it->getName().compare(0, block_set_force_name.length(),
192 block_set_force_name) == 0) {
193 CHKERR surfaceForce->addForce("SPATIAL_POSITION", PETSC_NULLPTR,
194 (it->getMeshsetId()), true, true);
195 CHKERR surfaceForce->addForceAle(
196 "SPATIAL_POSITION", "MESH_NODE_POSITIONS", dataAtPts,
197 si->getDomainFEName(), PETSC_NULLPTR, PETSC_NULLPTR, it->getMeshsetId(),
198 true, true, false);
199 }
200 }
201
202 // Implementation of spring element
203 // Create new instances of face elements for springs
204 boost::shared_ptr<FaceElementForcesAndSourcesCore> fe_spring_lhs_ptr(
205 new FaceElementForcesAndSourcesCore(m_field));
206 boost::shared_ptr<FaceElementForcesAndSourcesCore> fe_spring_rhs_ptr(
207 new FaceElementForcesAndSourcesCore(m_field));
208 CHKERR MetaSpringBC::setSpringOperators(
209 m_field, fe_spring_lhs_ptr, fe_spring_rhs_ptr, "SPATIAL_POSITION",
210 "MESH_NODE_POSITIONS");
211
212 boost::shared_ptr<FaceElementForcesAndSourcesCore> fe_spring_lhs_ale_ptr_dx(
213 new FaceElementForcesAndSourcesCore(m_field));
214 boost::shared_ptr<FaceElementForcesAndSourcesCore> fe_spring_lhs_ale_ptr_dX(
215 new FaceElementForcesAndSourcesCore(m_field));
216
217 boost::shared_ptr<FaceElementForcesAndSourcesCore> fe_spring_rhs_ale_ptr(
218 new FaceElementForcesAndSourcesCore(m_field));
219
220 boost::shared_ptr<MetaSpringBC::DataAtIntegrationPtsSprings>
221 data_at_spring_gp =
222 boost::make_shared<MetaSpringBC::DataAtIntegrationPtsSprings>(
223 m_field);
224
225 Range spring_ale_nodes;
226 CHKERR moab.get_connectivity(triangle_springs, spring_ale_nodes, true);
227
228 data_at_spring_gp->forcesOnlyOnEntitiesRow = spring_ale_nodes;
229
230 CHKERR MetaSpringBC::setSpringOperatorsMaterial(
231 m_field, fe_spring_lhs_ale_ptr_dx, fe_spring_lhs_ale_ptr_dX,
232 fe_spring_rhs_ale_ptr, data_at_spring_gp, "SPATIAL_POSITION",
233 "MESH_NODE_POSITIONS", si->getDomainFEName());
234
235 CHKERR DMMoFEMSNESSetJacobian(dm, "SPRING", fe_spring_lhs_ptr, PETSC_NULLPTR,
236 PETSC_NULLPTR);
237 CHKERR DMMoFEMSNESSetFunction(dm, "SPRING", fe_spring_rhs_ptr, PETSC_NULLPTR,
238 PETSC_NULLPTR);
239
240 CHKERR DMMoFEMSNESSetJacobian(dm, "SPRING_ALE", fe_spring_lhs_ale_ptr_dx,
241 PETSC_NULLPTR, PETSC_NULLPTR);
242 CHKERR DMMoFEMSNESSetJacobian(dm, "SPRING_ALE", fe_spring_lhs_ale_ptr_dX,
243 PETSC_NULLPTR, PETSC_NULLPTR);
244 CHKERR DMMoFEMSNESSetFunction(dm, "SPRING_ALE", fe_spring_rhs_ale_ptr,
245 PETSC_NULLPTR, PETSC_NULLPTR);
246
247 CHKERR DMMoFEMSNESSetJacobian(dm, si->getBoundaryFEName(), fe_lhs_ptr,
248 nullptr, nullptr);
249 CHKERR DMMoFEMSNESSetFunction(dm, si->getBoundaryFEName(), fe_rhs_ptr,
250 nullptr, nullptr);
251
252 CHKERR DMMoFEMSNESSetJacobian(dm, si->getBoundaryFEName(), fe_mat_lhs_ptr,
253 nullptr, nullptr);
254 CHKERR DMMoFEMSNESSetFunction(dm, si->getBoundaryFEName(), fe_mat_rhs_ptr,
255 nullptr, nullptr);
256
257 // Surface force ALE
258 CHKERR DMMoFEMSNESSetJacobian(dm, si->getBoundaryFEName(),
259 fe_lhs_surface_force_ptr, nullptr, nullptr);
260 CHKERR DMMoFEMSNESSetFunction(dm, si->getBoundaryFEName(),
261 fe_rhs_surface_force_ptr, nullptr, nullptr);
262
263 CHKERR DMMoFEMSNESSetJacobian(dm, si->getBoundaryFEName(),
264 fe_mat_lhs_surface_force_ptr, nullptr,
265 nullptr);
266 CHKERR DMMoFEMSNESSetFunction(dm, si->getBoundaryFEName(),
267 fe_mat_rhs_surface_force_ptr, nullptr,
268 nullptr);
269
270 Vec x, f;
271 CHKERR DMCreateGlobalVector(dm, &x);
272 CHKERR VecDuplicate(x, &f);
273 CHKERR VecSetOption(f, VEC_IGNORE_NEGATIVE_INDICES, PETSC_TRUE);
274 CHKERR DMoFEMMeshToLocalVector(dm, x, INSERT_VALUES, SCATTER_FORWARD);
275
276 Mat A, fdA;
277 CHKERR DMCreateMatrix(dm, &A);
278 CHKERR MatDuplicate(A, MAT_DO_NOT_COPY_VALUES, &fdA);
279
280 if (test_jacobian == PETSC_TRUE) {
281 char testing_options[] =
282 "-snes_test_jacobian -snes_test_jacobian_display "
283 "-snes_no_convergence_test -snes_atol 0 -snes_rtol 0 -snes_max_it 1 ";
284 //"-pc_type none";
285 CHKERR PetscOptionsInsertString(NULL, testing_options);
286 } else {
287 char testing_options[] = "-snes_no_convergence_test -snes_atol 0 "
288 "-snes_rtol 0 "
289 "-snes_max_it 1 ";
290 //"-pc_type none";
291 CHKERR PetscOptionsInsertString(NULL, testing_options);
292 }
293
294 SNES snes;
295 CHKERR SNESCreate(PETSC_COMM_WORLD, &snes);
296 MoFEM::SnesCtx *snes_ctx;
297 CHKERR DMMoFEMGetSnesCtx(dm, &snes_ctx);
298 CHKERR SNESSetFunction(snes, f, SnesRhs, snes_ctx);
299 CHKERR SNESSetJacobian(snes, A, A, SnesMat, snes_ctx);
300 CHKERR SNESSetFromOptions(snes);
301
302 CHKERR SNESSolve(snes, NULL, x);
303
304 if (test_jacobian == PETSC_FALSE) {
305 double nrm_A0;
306 CHKERR MatNorm(A, NORM_INFINITY, &nrm_A0);
307
308 char testing_options_fd[] = "-snes_fd";
309 CHKERR PetscOptionsInsertString(NULL, testing_options_fd);
310
311 CHKERR SNESSetFunction(snes, f, SnesRhs, snes_ctx);
312 CHKERR SNESSetJacobian(snes, fdA, fdA, SnesMat, snes_ctx);
313 CHKERR SNESSetFromOptions(snes);
314
315 CHKERR SNESSolve(snes, NULL, x);
316 CHKERR MatAXPY(A, -1, fdA, SUBSET_NONZERO_PATTERN);
317
318 double nrm_A;
319 CHKERR MatNorm(A, NORM_INFINITY, &nrm_A);
320 PetscPrintf(PETSC_COMM_WORLD, "Matrix norms %3.4e %3.4e\n", nrm_A,
321 nrm_A / nrm_A0);
322 nrm_A /= nrm_A0;
323
324 const double tol = 1e-7;
325 if (nrm_A > tol) {
326 SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
327 "Difference between hand-calculated tangent matrix and finite "
328 "difference matrix is too big");
329 }
330 }
331
332 CHKERR VecDestroy(&x);
333 CHKERR VecDestroy(&f);
334 CHKERR MatDestroy(&A);
335 CHKERR MatDestroy(&fdA);
336 CHKERR SNESDestroy(&snes);
337
338 // destroy DM
339 CHKERR DMDestroy(&dm);
340 }
341 CATCH_ERRORS;
342
343 // finish work cleaning memory, getting statistics, etc
344 MoFEM::Core::Finalize();
345
346 return 0;
347}
CATCH_ERRORS
#define CATCH_ERRORS
Catch errors.
Definition definitions.h:385
AINSWORTH_LEGENDRE_BASE
@ AINSWORTH_LEGENDRE_BASE
Ainsworth Cole (Legendre) approx. base .
Definition definitions.h:60
AINSWORTH_LOBATTO_BASE
@ AINSWORTH_LOBATTO_BASE
Definition definitions.h:62
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
FORCESET
@ FORCESET
Definition definitions.h:164
NODESET
@ NODESET
Definition definitions.h:159
BLOCKSET
@ BLOCKSET
Definition definitions.h:161
MOFEM_ATOM_TEST_INVALID
@ MOFEM_ATOM_TEST_INVALID
Definition definitions.h:40
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
MoFEM::DMMoFEMSNESSetFunction
PetscErrorCode DMMoFEMSNESSetFunction(DM dm, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
set SNES residual evaluation function
Definition DMMoFEM.cpp:708
MoFEM::DMMoFEMSNESSetJacobian
PetscErrorCode DMMoFEMSNESSetJacobian(DM dm, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
set SNES Jacobian evaluation function
Definition DMMoFEM.cpp:749
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::DMRegister_MoFEM
PetscErrorCode DMRegister_MoFEM(const char sname[])
Register MoFEM problem.
Definition DMMoFEM.cpp:43
MoFEM::DMMoFEMGetSnesCtx
PetscErrorCode DMMoFEMGetSnesCtx(DM dm, MoFEM::SnesCtx **snes_ctx)
get MoFEM::SnesCtx data structure
Definition DMMoFEM.cpp:1084
_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_
#define _IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(MESHSET_MANAGER, CUBITBCTYPE, IT)
Iterator that loops over a specific Cubit MeshSet in a moFEM field.
Definition MeshsetsManager.hpp:72
_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_
#define _IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(MESHSET_MANAGER, CUBITBCTYPE, IT)
Iterator that loops over a specific Cubit MeshSet having a particular BC meshset in a moFEM field.
Definition MeshsetsManager.hpp:94
bit
auto bit
set bit
Definition hanging_node_approx.cpp:75
tol
double tol
Definition mesh_smoothing.cpp:23
EigenMatrix::Vec
const FTensor::Tensor2< T, Dim, Dim > Vec
Definition MatrixFunction.hpp:64
MoFEM::Types::VectorAdaptor
VectorShallowArrayAdaptor< double > VectorAdaptor
Definition Types.hpp:115
MoFEM::SnesMat
PetscErrorCode SnesMat(SNES snes, Vec x, Mat A, Mat B, void *ctx)
This is MoFEM implementation for the left hand side (tangent matrix) evaluation in SNES solver.
Definition SnesCtx.cpp:491
MoFEM::PetscOptionsGetInt
PetscErrorCode PetscOptionsGetInt(PetscOptions *, const char pre[], const char name[], PetscInt *ivalue, PetscBool *set)
Definition DeprecatedPetsc.hpp:142
MoFEM::SnesRhs
PetscErrorCode SnesRhs(SNES snes, Vec x, Vec f, void *ctx)
This is MoFEM implementation for the right hand side (residual vector) evaluation in SNES solver.
Definition SnesCtx.cpp:227
MoFEM::PetscOptionsGetBool
PetscErrorCode PetscOptionsGetBool(PetscOptions *, const char pre[], const char name[], PetscBool *bval, PetscBool *set)
Definition DeprecatedPetsc.hpp:182
A
constexpr AssemblyType A
Definition operators_tests.cpp:30
MetaSpringBC::setSpringOperators
static MoFEMErrorCode setSpringOperators(MoFEM::Interface &m_field, boost::shared_ptr< FaceElementForcesAndSourcesCore > fe_spring_lhs_ptr, boost::shared_ptr< FaceElementForcesAndSourcesCore > fe_spring_rhs_ptr, const std::string field_name, const std::string mesh_nodals_positions="MESH_NODE_POSITIONS", double stiffness_scale=1.)
Implementation of spring element. Set operators to calculate LHS and RHS.
Definition SpringElement.cpp:1178
MetaSpringBC::addSpringElementsALE
static MoFEMErrorCode addSpringElementsALE(MoFEM::Interface &m_field, const std::string field_name, const std::string mesh_nodals_positions, Range &spring_triangles)
Declare spring element in ALE.
Definition SpringElement.cpp:1154
MetaSpringBC::addSpringElements
static MoFEMErrorCode addSpringElements(MoFEM::Interface &m_field, const std::string field_name, const std::string mesh_nodals_positions="MESH_NODE_POSITIONS")
Declare spring element.
Definition SpringElement.cpp:1127
MetaSpringBC::setSpringOperatorsMaterial
static MoFEMErrorCode setSpringOperatorsMaterial(MoFEM::Interface &m_field, boost::shared_ptr< FaceElementForcesAndSourcesCore > fe_spring_lhs_ptr_dx, boost::shared_ptr< FaceElementForcesAndSourcesCore > fe_spring_lhs_ptr_dX, boost::shared_ptr< FaceElementForcesAndSourcesCore > fe_spring_rhs_ptr, boost::shared_ptr< DataAtIntegrationPtsSprings > data_at_integration_pts, const std::string field_name, const std::string mesh_nodals_positions, std::string side_fe_name)
Implementation of spring element. Set operators to calculate LHS and RHS.
Definition SpringElement.cpp:1223
MoFEM::AddHOOps
Add operators pushing bases from local to physical configuration.
Definition HODataOperators.hpp:642
MoFEM::CoreInterface::get_moab
virtual moab::Interface & get_moab()=0
MoFEM::CoreTmp< 0 >
Core (interface) class.
Definition Core.hpp:83
MoFEM::CoreTmp< 0 >::Initialize
static MoFEMErrorCode Initialize(int *argc, char ***args, const char file[], const char help[])
Initializes the MoFEM database PETSc, MOAB and MPI.
Definition Core.cpp:68
MoFEM::CoreTmp< 0 >::Finalize
static MoFEMErrorCode Finalize()
Checks for options to be called at the conclusion of the program.
Definition Core.cpp:123
MoFEM::DeprecatedCoreInterface
Deprecated interface functions.
Definition DeprecatedCoreInterface.hpp:16
MoFEM::FieldBlas
Basic algebra on fields.
Definition FieldBlas.hpp:21
MoFEM::Simple
Simple interface for fast problem set-up.
Definition Simple.hpp:27
MoFEM::Simple::addDomainField
MoFEMErrorCode addDomainField(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_ZERO, int verb=-1)
Add field on domain.
Definition Simple.cpp:261
MoFEM::Simple::getBoundaryFEName
const std::string getBoundaryFEName() const
Get the Boundary FE Name.
Definition Simple.hpp:436
MoFEM::Simple::loadFile
MoFEMErrorCode loadFile(const std::string options, const std::string mesh_file_name, LoadFileFunc loadFunc=defaultLoadFileFunc)
Load mesh file.
Definition Simple.cpp:191
MoFEM::Simple::addBoundaryField
MoFEMErrorCode addBoundaryField(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_ZERO, int verb=-1)
Add field on boundary.
Definition Simple.cpp:355
MoFEM::Simple::getOtherFiniteElements
std::vector< std::string > & getOtherFiniteElements()
Get the Other Finite Elements.
Definition Simple.hpp:508
MoFEM::Simple::getOptions
MoFEMErrorCode getOptions()
get options
Definition Simple.cpp:180
MoFEM::Simple::getDM
MoFEMErrorCode getDM(DM *dm)
Get DM.
Definition Simple.cpp:799
MoFEM::Simple::setFieldOrder
MoFEMErrorCode setFieldOrder(const std::string field_name, const int order, const Range *ents=NULL)
Set field order.
Definition Simple.cpp:575
MoFEM::Simple::setUp
MoFEMErrorCode setUp(const PetscBool is_partitioned=PETSC_TRUE)
Setup problem.
Definition Simple.cpp:735
MoFEM::Simple::getDomainFEName
const std::string getDomainFEName() const
Get the Domain FE Name.
Definition Simple.hpp:429
MoFEM::SnesCtx
Interface for nonlinear (SNES) solver.
Definition SnesCtx.hpp:15
MoFEM::UnknownInterface::getInterface
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface reference to pointer of interface.
Definition UnknownInterface.hpp:93
NeumannForcesSurface
Finite element and operators to apply force/pressures applied to surfaces.
Definition SurfacePressure.hpp:14
help
static char help[]
Definition testing_jacobian_of_surface_pressure_element.cpp:17
scale
double scale
Definition plastic.cpp:124

Variable Documentation

◆ help

char help[] = "\n"
static

Definition at line 17 of file testing_jacobian_of_surface_pressure_element.cpp.

Generated by Doxygen 1.9.8 and hosted at University of Glasgow