64 {
65
67
68 try {
69
70 moab::Core mb_instance;
71 moab::Interface &moab = mb_instance;
72
73
76
77
78 enum bases { AINSWORTH, DEMKOWICZ, LASBASETOP };
79 const char *list_bases[] = {"ainsworth", "demkowicz"};
80 PetscBool flg;
81 PetscInt choice_base_value = AINSWORTH;
83 LASBASETOP, &choice_base_value, &flg);
84 if (flg != PETSC_TRUE)
87 if (choice_base_value == AINSWORTH)
89 else if (choice_base_value == DEMKOWICZ)
93 PETSC_NULLPTR);
94
95
96 DMType dm_name = "DMMOFEM";
98
99
100 auto core_log = logging::core::get();
101 core_log->add_sink(
105
106
108
109
111
113
120
122
123
125
127
128 auto get_skin = [&]() {
131 body_ents);
134 CHKERR skin.find_skin(0, body_ents,
false, skin_ents);
135 return skin_ents;
136 };
137
140 ParallelComm *pcomm =
142 CHKERR pcomm->filter_pstatus(skin, PSTATUS_SHARED | PSTATUS_MULTISHARED,
143 PSTATUS_NOT, -1, &boundary_ents);
144 return boundary_ents;
145 };
146
150
151
153
157 CHKERR bc_mng->removeBlockDOFsOnEntities(
159
160 auto project_ho_geometry = [&]() {
162 return m_field.
loop_dofs(
"GEOMETRY", ent_method);
163 };
164 CHKERR project_ho_geometry();
165
166
168
170
171
172 pip_mng->getOpDomainLhsPipeline().clear();
173 pip_mng->getOpDomainRhsPipeline().clear();
174
175
176 auto rule = [&](int, int, int p) { return 2 * p + 2; };
177 CHKERR pip_mng->setDomainRhsIntegrationRule(rule);
178 CHKERR pip_mng->setDomainLhsIntegrationRule(rule);
179 CHKERR pip_mng->setBoundaryRhsIntegrationRule(rule);
180
182 {{"U", {-1, 1}}, {"SIGMA", {-1, 1}}});
184 SCATTER_REVERSE);
185
186
187
188 auto jacobian = [&](
double r) {
190 return 2 * M_PI * r;
191 else
192 return 1.;
193 };
194
196 return jacobian(r);
197 };
199 return -jacobian(r);
200 };
201
202 auto post_proc = [&](auto dm, auto f_res, auto out_name) {
204 auto post_proc_fe =
205 boost::make_shared<PostProcBrokenMeshInMoab<DomainEle>>(m_field);
206
208
209 auto sigma_ptr = boost::make_shared<MatrixDouble>();
210 post_proc_fe->getOpPtrVector().push_back(
212 sigma_ptr));
213 auto u_ptr = boost::make_shared<MatrixDouble>();
214 post_proc_fe->getOpPtrVector().push_back(
216
217 post_proc_fe->getOpPtrVector().push_back(
218
220
221 post_proc_fe->getPostProcMesh(), post_proc_fe->getMapGaussPts(),
222 {}, {{"U", u_ptr}}, {{"SIGMA", sigma_ptr}}, {})
223
224 );
225
227 SCATTER_REVERSE);
229 post_proc_fe);
230 post_proc_fe->writeFile(out_name);
232 };
233
234 auto test_consistency_of_domain_and_bdy_integrals = [&]() {
236 using OpMixDivURhs =
238 GAUSS>::OpMixDivTimesU<3, SPACE_DIM, SPACE_DIM, COORD_TYPE>;
245
248
253
254 auto ops_rhs_interior = [&](auto &pip) {
257 "GEOMETRY");
258 auto u_ptr = boost::make_shared<MatrixDouble>();
259 auto grad_u_ptr = boost::make_shared<MatrixDouble>();
262 "U", grad_u_ptr));
263
264 pip.push_back(new OpMixDivURhs("SIGMA", u_ptr, beta_domain));
265 pip.push_back(
266 new OpMixLambdaGradURhs("SIGMA", grad_u_ptr, beta_domain));
267
268 auto sigma_ptr = boost::make_shared<MatrixDouble>();
269 auto sigma_div_ptr = boost::make_shared<MatrixDouble>();
272 "SIGMA", sigma_div_ptr));
274 "SIGMA", sigma_ptr));
275 pip.push_back(
276 new OpMixUTimesDivLambdaRhs("U", sigma_div_ptr, beta_domain));
277 pip.push_back(new OpMixUTimesLambdaRhs("U", sigma_ptr, beta_domain));
278
280 };
281
282 auto ops_rhs_boundary = [&](auto &pip) {
285 "GEOMETRY");
286 auto u_ptr = boost::make_shared<MatrixDouble>();
288 auto traction_ptr = boost::make_shared<MatrixDouble>();
290 "SIGMA", traction_ptr));
291
292
293
295 pip.push_back(new OpMixNormalLambdaURhs("SIGMA", u_ptr, beta_bdy));
296 pip.push_back(new OpUTimeTractionRhs("U", traction_ptr, beta_bdy));
298 };
299
300 CHKERR ops_rhs_interior(pip_mng->getOpDomainRhsPipeline());
301 CHKERR ops_rhs_boundary(pip_mng->getOpBoundaryRhsPipeline());
302
304 pip_mng->getDomainRhsFE()->f =
f;
305 pip_mng->getBoundaryRhsFE()->f =
f;
306
308
310 simple->getDomainFEName(),
311 pip_mng->getDomainRhsFE());
313 simple->getBoundaryFEName(),
314 pip_mng->getBoundaryRhsFE());
315
316 CHKERR VecAssemblyBegin(f);
318
319 double f_nrm2;
320 CHKERR VecNorm(f, NORM_2, &f_nrm2);
321
322 MOFEM_LOG(
"ATOM", Sev::inform) <<
"f_norm2 = " << f_nrm2;
323 if (std::fabs(f_nrm2) > 1e-10) {
325 "tensor_divergence_operator_res_vec.h5m");
327 }
328
330 };
331
332
333
334 auto test_lhs_ops = [&]() {
340
341 auto op_lhs_domain = [&](auto &pip) {
344 "GEOMETRY");
345
346 auto unity = []() { return 1; };
347 pip.push_back(
348 new OpMixDivULhs("SIGMA", "U", unity, beta_domain, true, false));
349 pip.push_back(
350 new OpLambdaGraULhs("SIGMA", "U", unity, beta_domain, true, false));
352 };
353
354 CHKERR op_lhs_domain(pip_mng->getOpDomainLhsPipeline());
355
356 auto diff_x = opt->setRandomFields(
simple->getDM(),
357 {{"U", {-1, 1}}, {"SIGMA", {-1, 1}}});
358 constexpr double eps = 1e-5;
359 auto diff_res = opt->checkCentralFiniteDifference(
360 simple->getDM(),
simple->getDomainFEName(), pip_mng->getDomainRhsFE(),
363
364
365
366 double fnorm_res;
367 CHKERR VecNorm(diff_res, NORM_2, &fnorm_res);
368 MOFEM_LOG_C(
"ATOM", Sev::inform,
"Test Lhs OPs %3.4e", fnorm_res);
369 if (std::fabs(fnorm_res) > 1e-8)
371
373 };
374
375 CHKERR test_consistency_of_domain_and_bdy_integrals();
377 }
379
381}
static auto filter_true_skin(MoFEM::Interface &m_field, Range &&skin)
#define MOFEM_LOG_C(channel, severity, format,...)
void simple(double P1[], double P2[], double P3[], double c[], const int N)
#define CATCH_ERRORS
Catch errors.
#define MAX_DOFS_ON_ENTITY
Maximal number of DOFs on entity.
FieldApproximationBase
approximation base
@ AINSWORTH_LEGENDRE_BASE
Ainsworth Cole (Legendre) approx. base nme:nme847.
@ HDIV
field with continuous normal traction
#define MYPCOMM_INDEX
default communicator number PCOMM
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
@ MOFEM_ATOM_TEST_INVALID
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
#define CHKERR
Inline error check.
PetscErrorCode DMoFEMMeshToLocalVector(DM dm, Vec l, InsertMode mode, ScatterMode scatter_mode)
set local (or ghosted) vector values on mesh for partition only
PetscErrorCode DMRegister_MoFEM(const char sname[])
Register MoFEM problem.
PetscErrorCode DMoFEMLoopFiniteElements(DM dm, const char fe_name[], MoFEM::FEMethod *method, CacheTupleWeakPtr cache_ptr=CacheTupleSharedPtr())
Executes FEMethod for finite elements in DM.
auto createDMVector(DM dm)
Get smart vector from DM.
static LoggerType & setLog(const std::string channel)
Set ans resset chanel logger.
#define MOFEM_LOG(channel, severity)
Log.
#define MOFEM_LOG_TAG(channel, tag)
Tag channel.
virtual MoFEMErrorCode loop_dofs(const Problem *problem_ptr, const std::string &field_name, RowColData rc, DofMethod &method, int lower_rank, int upper_rank, int verb=DEFAULT_VERBOSITY)=0
Make a loop over dofs.
PetscErrorCode PetscOptionsGetInt(PetscOptions *, const char pre[], const char name[], PetscInt *ivalue, PetscBool *set)
PetscErrorCode PetscOptionsGetEList(PetscOptions *, const char pre[], const char name[], const char *const *list, PetscInt next, PetscInt *value, PetscBool *set)
OpPostProcMapInMoab< SPACE_DIM, SPACE_DIM > OpPPMap
Add operators pushing bases from local to physical configuration.
Simple interface for fast problem set-up.
MoFEMErrorCode removeBlockDOFsOnEntities(const std::string problem_name, const std::string block_name, const std::string field_name, int lo, int hi, bool get_low_dim_ents=true, bool is_distributed_mesh=true)
Remove DOFs from problem.
virtual moab::Interface & get_moab()=0
static MoFEMErrorCode Initialize(int *argc, char ***args, const char file[], const char help[])
Initializes the MoFEM database PETSc, MOAB and MPI.
static MoFEMErrorCode Finalize()
Checks for options to be called at the conclusion of the program.
Deprecated interface functions.
static boost::shared_ptr< SinkType > createSink(boost::shared_ptr< std::ostream > stream_ptr, std::string comm_filter)
Create a sink object.
static boost::shared_ptr< std::ostream > getStrmWorld()
Get the strm world object.
Calculate divergence of tonsorial field using vectorial base.
Calculate tenor field using vectorial base, i.e. Hdiv/Hcurl.
Calculate trace of vector (Hdiv/Hcurl) space.
Get field gradients at integration pts for scalar field rank 0, i.e. vector field.
Get values at integration pts for tensor field rank 1, i.e. vector field.
Post post-proc data at points from hash maps.
Calculate directional derivative of the right hand side and compare it with tangent matrix derivative...
SmartPetscObj< Vec > setRandomFields(SmartPetscObj< DM > dm, std::vector< RandomFieldData > random_fields, boost::shared_ptr< Range > ents=nullptr)
Generate random fields.
PipelineManager interface.
Projection of edge entities with one mid-node on hierarchical basis.
Simple interface for fast problem set-up.
MoFEMErrorCode getOptions()
get options
intrusive_ptr for managing petsc objects
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface reference to pointer of interface.
constexpr FieldSpace HDIV_SPACE
constexpr CoordinateTypes COORD_TYPE