v0.14.0
Loading...
Searching...
No Matches
FEMultiIndices.cpp
Go to the documentation of this file.
1/** \file FEMultiIndices.cpp
2 * \brief Multi-index containers for finite elements
3 */
4
5namespace MoFEM {
6
7constexpr int FiniteElement::ent_shift; // EntityHandle size
8
25constexpr std::array<const DefaultElementAdjacency::DefEntTypeMap *, MBMAXTYPE>
27
29 moab::Interface &moab, const Field &field, const EntFiniteElement &fe,
30 std::vector<EntityHandle> &adjacency) {
32 switch (field.getSpace()) {
33 case H1:
34 adjacency.push_back(fe.getEnt());
35 // build side table
36 for (auto ent : adjacency)
37 fe.getSideNumberPtr(ent);
38 break;
39 case NOFIELD: {
40 CHKERR moab.get_entities_by_handle(field.getMeshset(), adjacency, false);
41 for (auto ent : adjacency) {
43 .insert(boost::shared_ptr<SideNumber>(new SideNumber(ent, -1, 0, 0)));
44 }
45 } break;
46 default:
47 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
48 "this field is not implemented for VERTEX finite element");
49 }
50
52}
53
55DefaultElementAdjacency::defaultEdge(moab::Interface &moab, const Field &field,
56 const EntFiniteElement &fe,
57 std::vector<EntityHandle> &adjacency) {
59 EntityHandle fe_ent = fe.getEnt();
60 // Range nodes;
61 switch (field.getSpace()) {
62 case H1:
63 CHKERR moab.get_connectivity(&fe_ent, 1, adjacency, true);
64 case L2:
65 case HCURL:
66 adjacency.push_back(fe_ent);
67 // build side table
68 for (auto e : adjacency)
69 fe.getSideNumberPtr(e);
70 break;
71 case NOFIELD: {
72 CHKERR moab.get_entities_by_handle(field.getMeshset(), adjacency, false);
73 for (auto e : adjacency) {
75 .insert(boost::shared_ptr<SideNumber>(new SideNumber(e, -1, 0, 0)));
76 }
77 } break;
78 default:
79 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
80 "this field is not implemented for EDGE finite element");
81 }
82
84}
85
87DefaultElementAdjacency::defaultFace(moab::Interface &moab, const Field &field,
88 const EntFiniteElement &fe,
89 std::vector<EntityHandle> &adjacency) {
91 // Range nodes,edges;
92 const EntityHandle fe_ent = fe.getEnt();
93 switch (field.getSpace()) {
94 case H1:
95 CHKERR moab.get_connectivity(&fe_ent, 1, adjacency, true);
96 case HCURL:
97 CHKERR moab.get_adjacencies(&fe_ent, 1, 1, false, adjacency,
98 moab::Interface::UNION);
99 case HDIV:
100 case L2:
101 adjacency.push_back(fe_ent);
102 // build side table
103 for (auto ent : adjacency)
104 fe.getSideNumberPtr(ent);
105 break;
106 case NOFIELD: {
107 CHKERR moab.get_entities_by_handle(field.getMeshset(), adjacency, false);
108 for (auto ent : adjacency) {
109 const_cast<SideNumber_multiIndex &>(fe.getSideNumberTable())
110 .insert(boost::shared_ptr<SideNumber>(new SideNumber(ent, -1, 0, 0)));
111 }
112 } break;
113 default:
114 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
115 "this field is not implemented for TRI finite element");
116 }
117
119}
120
122 moab::Interface &moab, const Field &field, const EntFiniteElement &fe,
123 std::vector<EntityHandle> &adjacency) {
125 EntityHandle fe_ent = fe.getEnt();
126 switch (field.getSpace()) {
127 case H1:
128 CHKERR moab.get_connectivity(&fe_ent, 1, adjacency, true);
129 case HCURL:
130 CHKERR moab.get_adjacencies(&fe_ent, 1, 1, false, adjacency,
131 moab::Interface::UNION);
132 case HDIV:
133 CHKERR moab.get_adjacencies(&fe_ent, 1, 2, false, adjacency,
134 moab::Interface::UNION);
135 case L2:
136 adjacency.push_back(fe_ent);
137 // build side table
138 for (auto ent : adjacency)
139 fe.getSideNumberPtr(ent);
140 break;
141 case NOFIELD: {
142 CHKERR moab.get_entities_by_handle(field.getMeshset(), adjacency, false);
143 for (auto ent : adjacency) {
144 const_cast<SideNumber_multiIndex &>(fe.getSideNumberTable())
145 .insert(boost::shared_ptr<SideNumber>(new SideNumber(ent, -1, 0, 0)));
146 }
147 } break;
148 default:
149 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
150 "this field is not implemented for TRI finite element");
151 }
152
154}
155
157DefaultElementAdjacency::defaultPrism(moab::Interface &moab, const Field &field,
158 const EntFiniteElement &fe,
159 std::vector<EntityHandle> &adjacency) {
161 const EntityHandle prism = fe.getEnt();
162 Range nodes;
163 // initialize side sets
164 fe.getRefElement()->getSideNumberPtr(prism);
165 EntityHandle face_side3, face_side4;
166 CHKERR moab.side_element(prism, 2, 3, face_side3);
167 CHKERR moab.side_element(prism, 2, 4, face_side4);
168 fe.getRefElement()->getSideNumberPtr(face_side3);
169 fe.getRefElement()->getSideNumberPtr(face_side4);
170 for (int qq = 0; qq < 3; qq++) {
171 EntityHandle quad = 0;
172 rval = moab.side_element(prism, 2, qq, quad);
173 if (rval != MB_SUCCESS || quad == 0)
174 continue;
175 int side_number, sense, offset;
176 rval = moab.side_number(prism, quad, side_number, sense, offset);
177 if (side_number == -1 || rval != MB_SUCCESS)
178 continue;
179 const_cast<SideNumber_multiIndex &>(fe.getSideNumberTable())
180 .insert(boost::shared_ptr<SideNumber>(
181 new SideNumber(quad, side_number, sense, offset)));
182 }
183 int ee = 0;
184 for (; ee < 3; ee++) {
185 EntityHandle edge = 0;
186 CHKERR moab.side_element(prism, 1, ee, edge);
187 boost::shared_ptr<SideNumber> side_ptr =
188 fe.getRefElement()->getSideNumberPtr(edge);
189 if (side_ptr->side_number != ee) {
190 SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
191 "data inconsistency for edge %d while in FE datastructure is "
192 "numbered %d.",
193 ee, side_ptr->side_number);
194 }
195 CHKERR moab.side_element(prism, 1, 6 + ee, edge);
196 side_ptr = fe.getRefElement()->getSideNumberPtr(edge);
197 if (side_ptr->side_number != ee + 6) {
198 if (side_ptr->side_number != ee) {
199 SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
200 "data inconsistency for edge %d while in FE datastructure "
201 "is numbered %d.",
202 ee, side_ptr->side_number);
203 } else {
204 side_ptr->brother_side_number = ee + 6;
205 }
206 }
207 }
208 for (; ee < 6; ee++) {
209 EntityHandle edge = 0;
210 rval = moab.side_element(prism, 1, ee, edge);
211 if (rval != MB_SUCCESS || edge == 0)
212 continue;
213 int side_number, sense, offset;
214 rval = moab.side_number(prism, edge, side_number, sense, offset);
215 if (side_number == -1 || rval != MB_SUCCESS)
216 continue;
217 const_cast<SideNumber_multiIndex &>(fe.getSideNumberTable())
218 .insert(boost::shared_ptr<SideNumber>(
219 new SideNumber(edge, side_number, sense, offset)));
220 }
221 int nn = 0;
222 for (; nn < 3; nn++) {
223 EntityHandle node;
224 CHKERR moab.side_element(prism, 0, nn, node);
225 boost::shared_ptr<SideNumber> side_ptr =
226 fe.getRefElement()->getSideNumberPtr(node);
227 if (side_ptr->side_number != nn) {
228 SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
229 "data inconsistency for node %d while in FE datastructure is "
230 "numbered %d.",
231 nn, side_ptr->side_number);
232 }
233 CHKERR moab.side_element(prism, 0, nn + 3, node);
234 side_ptr = fe.getRefElement()->getSideNumberPtr(node);
235 if (side_ptr->side_number != nn + 3) {
236 if (side_ptr->side_number != nn) {
237 SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
238 "data inconsistency for node %d while in FE datastructure is "
239 "numbered %d.",
240 nn, side_ptr->side_number);
241 } else {
242 side_ptr->brother_side_number = nn + 3;
243 }
244 }
245 }
246
247 // get adjacencies
248 SideNumber_multiIndex &side_table = fe.getRefElement()->getSideNumberTable();
249 switch (field.getSpace()) {
250 case H1:
251 // moab.get_connectivity(&prism,1,nodes,true);
252 // use get adjacencies, this will allow take in account adjacencies set user
253 CHKERR moab.get_adjacencies(&prism, 1, 0, false, nodes,
254 moab::Interface::UNION);
255 {
256 Range topo_nodes;
257 CHKERR moab.get_connectivity(&prism, 1, topo_nodes, true);
258 Range mid_nodes;
259 CHKERR moab.get_connectivity(&prism, 1, mid_nodes, false);
260 mid_nodes = subtract(mid_nodes, topo_nodes);
261 nodes = subtract(nodes, mid_nodes);
262 }
263 adjacency.insert(adjacency.end(), nodes.begin(), nodes.end());
264 case HCURL: {
265 auto siit = side_table.get<0>().lower_bound(get_id_for_min_type<MBEDGE>());
266 auto hi_siit =
267 side_table.get<0>().upper_bound(get_id_for_max_type<MBEDGE>());
268 for (; siit != hi_siit; siit++)
269 adjacency.push_back(siit->get()->ent);
270 }
271 case HDIV: {
272 auto siit = side_table.get<0>().lower_bound(get_id_for_min_type<MBTRI>());
273 auto hi_siit =
274 side_table.get<0>().upper_bound(get_id_for_max_type<MBQUAD>());
275 for (; siit != hi_siit; siit++)
276 adjacency.push_back(siit->get()->ent);
277 }
278 case L2:
279 adjacency.push_back(prism);
280 break;
281 case NOFIELD: {
282 CHKERR moab.get_entities_by_handle(field.getMeshset(), adjacency, false);
283 for (auto ent : adjacency) {
284 const_cast<SideNumber_multiIndex &>(fe.getSideNumberTable())
285 .insert(boost::shared_ptr<SideNumber>(new SideNumber(ent, -1, 0, 0)));
286 }
287 } break;
288 default:
289 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
290 "this field is not implemented for TRI finite element");
291 }
293}
294
296 moab::Interface &moab, const Field &field, const EntFiniteElement &fe,
297 std::vector<EntityHandle> &adjacency) {
299 EntityHandle fe_ent = fe.getEnt();
300 // resolve recursively all ents in the meshset
301 switch (field.getSpace()) {
302 case H1:
303 CHKERR moab.get_entities_by_type(fe_ent, MBVERTEX, adjacency, true);
304 case HCURL:
305 CHKERR moab.get_entities_by_type(fe_ent, MBEDGE, adjacency, true);
306 case HDIV:
307 CHKERR moab.get_entities_by_dimension(fe_ent, 2, adjacency, true);
308 case L2:
309 CHKERR moab.get_entities_by_dimension(fe_ent, 3, adjacency, true);
310 break;
311 case NOFIELD: {
312 CHKERR moab.get_entities_by_handle(field.getMeshset(), adjacency, false);
313 for (auto ent : adjacency) {
314 const_cast<SideNumber_multiIndex &>(fe.getSideNumberTable())
315 .insert(boost::shared_ptr<SideNumber>(new SideNumber(ent, -1, 0, 0)));
316 }
317 } break;
318 default:
319 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED, "not implemented");
320 }
322}
323
324// FiniteElement
325FiniteElement::FiniteElement(moab::Interface &moab, const EntityHandle _meshset)
326 : meshset(_meshset) {
327 Tag th_FEId;
328 CHK_MOAB_THROW(moab.tag_get_handle("_FEId", th_FEId), "get tag");
330 moab.tag_get_by_ptr(th_FEId, &meshset, 1, (const void **)&tagId),
331 "get tag data");
332 Tag th_FEName;
333 CHK_MOAB_THROW(moab.tag_get_handle("_FEName", th_FEName), "get tag");
334 CHK_MOAB_THROW(moab.tag_get_by_ptr(th_FEName, &meshset, 1,
335 (const void **)&tagName, &tagNameSize),
336 "get tag data");
337 Tag th_FEIdCol, th_FEIdRow, th_FEIdData;
338 CHK_MOAB_THROW(moab.tag_get_handle("_FEIdCol", th_FEIdCol), "get_tag");
339 CHK_MOAB_THROW(moab.tag_get_by_ptr(th_FEIdCol, &meshset, 1,
340 (const void **)&tag_BitFieldId_col_data),
341 "get tag data");
342 CHK_MOAB_THROW(moab.tag_get_handle("_FEIdRow", th_FEIdRow), "get tag");
343 CHK_MOAB_THROW(moab.tag_get_by_ptr(th_FEIdRow, &meshset, 1,
344 (const void **)&tag_BitFieldId_row_data),
345 "get tag data");
346 CHK_MOAB_THROW(moab.tag_get_handle("_FEIdData", th_FEIdData), "get tag");
347 CHK_MOAB_THROW(moab.tag_get_by_ptr(th_FEIdData, &meshset, 1,
348 (const void **)&tag_BitFieldId_data),
349 "get tag data");
350
359
360 feUId = static_cast<UId>(getBitNumber()) << ent_shift;
361}
362
363std::ostream &operator<<(std::ostream &os, const FiniteElement &e) {
364 os << e.getNameRef() << " fe_id " << e.getId().to_ulong() << " f_id_row "
365 << e.getBitFieldIdRow() << " f_id_col " << e.getBitFieldIdCol()
366 << " BitFEId_data " << e.getBitFieldIdData();
367 return os;
368}
369
371 boost::shared_ptr<FiniteElement> &fe) {
372 *static_cast<BitFieldId *>(fe->tag_BitFieldId_col_data) |= fIdCol;
373}
374
376 boost::shared_ptr<FiniteElement> &fe) {
377 *static_cast<BitFieldId *>(fe->tag_BitFieldId_row_data) |= fIdRow;
378}
379
381 boost::shared_ptr<FiniteElement> &fe) {
382 *static_cast<BitFieldId *>(fe->tag_BitFieldId_data) |= fIdData;
383}
384
386 boost::shared_ptr<FiniteElement> &fe) {
387 *static_cast<BitFieldId *>(fe->tag_BitFieldId_col_data) &= fIdCol.flip();
388}
389
391 boost::shared_ptr<FiniteElement> &fe) {
392 *static_cast<BitFieldId *>(fe->tag_BitFieldId_row_data) &= fIdRow.flip();
393}
394
396 boost::shared_ptr<FiniteElement> &fe) {
397 *static_cast<BitFieldId *>(fe->tag_BitFieldId_data) &= fIdData.flip();
398}
399
401 boost::shared_ptr<FiniteElement> &fe) {
402 static_cast<BitFieldId *>(fe->tag_BitFieldId_col_data)->reset();
403}
404
406 boost::shared_ptr<FiniteElement> &fe) {
407 static_cast<BitFieldId *>(fe->tag_BitFieldId_row_data)->reset();
408}
409
411 boost::shared_ptr<FiniteElement> &fe) {
412 static_cast<BitFieldId *>(fe->tag_BitFieldId_data)->reset();
413}
414
415// FiniteElement data
417 const boost::shared_ptr<RefElement> &ref_finite_element,
418 const boost::shared_ptr<FiniteElement> &fe_ptr)
420 ref_finite_element),
421 dataFieldEnts(new FieldEntity_vector_view()),
422 rowFieldEnts(new FieldEntity_vector_view()),
423 colFieldEnts(new FieldEntity_vector_view()) {}
424
425std::ostream &operator<<(std::ostream &os, const EntFiniteElement &e) {
426 os << *e.getFiniteElementPtr() << std::endl;
427 os << *e.sPtr;
428 return os;
429}
430
432EntFiniteElement::getElementAdjacency(const boost::shared_ptr<Field> field_ptr,
433 std::vector<EntityHandle> &adjacency) {
434 moab::Interface &moab = getRefEntityPtr()->getBasicDataPtr()->moab;
436 const EntFiniteElement *this_fe_ptr = this;
437 if (getFiniteElementPtr()->elementAdjacencyTable[getEntType()] == NULL)
438 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED, "not implemented");
439 CHKERR getFiniteElementPtr()->elementAdjacencyTable[getEntType()](
440 moab, *field_ptr, *this_fe_ptr, adjacency);
442}
443
444/**
445 * \Construct indexed finite element
446 */
448 const boost::shared_ptr<EntFiniteElement> &sptr)
449 : interface_EntFiniteElement<EntFiniteElement>(sptr), part(-1){};
450
451boost::weak_ptr<FENumeredDofEntity>
453 auto comp = [idx](const auto &a) { return a->getPetscGlobalDofIdx() == idx; };
454
455 for (auto &it : getRowFieldEnts()) {
456 if (auto e = it.lock()) {
457 if (auto cache = e->entityCacheColDofs.lock()) {
458 auto dit = std::find_if(cache->loHi[0], cache->loHi[1], comp);
459 if (dit != cache->loHi[1])
460 return boost::reinterpret_pointer_cast<FENumeredDofEntity>(*dit);
461 } else
462 THROW_MESSAGE("Cache not set");
463 }
464 }
465
466 return boost::weak_ptr<FENumeredDofEntity>();
467}
468
469boost::weak_ptr<FENumeredDofEntity>
471
472 auto comp = [idx](const auto &a) { return a->getPetscGlobalDofIdx() == idx; };
473
474 for (auto &it : getColFieldEnts()) {
475 if (auto e = it.lock()) {
476 if (auto cache = e->entityCacheColDofs.lock()) {
477 auto dit = std::find_if(cache->loHi[0], cache->loHi[1], comp);
478 if (dit != cache->loHi[1])
479 return boost::reinterpret_pointer_cast<FENumeredDofEntity>(*dit);
480 } else
481 THROW_MESSAGE("Cache not set");
482 }
483 }
484
485 return boost::weak_ptr<FENumeredDofEntity>();
486}
487
488std::ostream &operator<<(std::ostream &os, const NumeredEntFiniteElement &e) {
489 os << "part " << e.part << " " << *(e.getEntFiniteElement());
490 return os;
491}
492
493template <typename ENTSVIEW, typename DOFSVIEW, typename EXTRACTOR,
494 typename INSERTER>
495inline static MoFEMErrorCode
496get_cache_data_dofs_view(ENTSVIEW &ents_view, DOFSVIEW &dofs_view,
497 EXTRACTOR &&extractor, INSERTER &&inserter) {
499
500 auto hint = dofs_view->end();
501 using ValType = typename std::remove_reference<decltype(**hint)>::type;
502
503 for (auto &it : *ents_view) {
504 if (auto e = it.lock()) {
505
506 if (auto cache = extractor(e).lock())
507 for (auto dit = cache->loHi[0]; dit != cache->loHi[1]; ++dit)
508 hint = inserter(dofs_view, hint,
509 boost::reinterpret_pointer_cast<ValType>(*dit));
510 else
511 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "Cache not set");
512 }
513 }
514
516}
517
518boost::shared_ptr<FEDofEntity_multiIndex>
521 struct Extractor {
522 boost::weak_ptr<EntityCacheDofs>
523 operator()(boost::shared_ptr<FieldEntity> &e) {
524 return e->entityCacheDataDofs;
525 }
526 };
527
528 struct Inserter {
529 FEDofEntity_multiIndex::iterator
530 operator()(boost::shared_ptr<FEDofEntity_multiIndex> &dofs_view,
531 FEDofEntity_multiIndex::iterator &hint,
532 boost::shared_ptr<FEDofEntity> &&dof) {
533 return dofs_view->emplace_hint(hint, dof);
534 }
535 };
536
537 auto data_dofs = boost::make_shared<FEDofEntity_multiIndex>();
538 if (get_cache_data_dofs_view(dataFieldEnts, data_dofs, Extractor(),
539 Inserter()))
540 THROW_MESSAGE("data_dofs can not be created");
541 return data_dofs;
542};
543
544boost::shared_ptr<std::vector<boost::shared_ptr<FEDofEntity>>>
547
548 struct Extractor {
549 boost::weak_ptr<EntityCacheDofs>
550 operator()(boost::shared_ptr<FieldEntity> &e) {
551 return e->entityCacheDataDofs;
552 }
553 };
554
555 struct Inserter {
556 using Vec = std::vector<boost::shared_ptr<FEDofEntity>>;
557 using It = Vec::iterator;
558 It operator()(boost::shared_ptr<Vec> &dofs_view, It &hint,
559 boost::shared_ptr<FEDofEntity> &&dof) {
560 dofs_view->emplace_back(dof);
561 return dofs_view->end();
562 }
563 };
564
565 auto data_vector_dofs =
566 boost::make_shared<std::vector<boost::shared_ptr<FEDofEntity>>>();
567 if (get_cache_data_dofs_view(dataFieldEnts, data_vector_dofs, Extractor(),
568 Inserter()))
569 THROW_MESSAGE("dataDofs can not be created");
570
571 return data_vector_dofs;
572};
573
574boost::shared_ptr<FENumeredDofEntity_multiIndex>
577
578 struct Extractor {
579 boost::weak_ptr<EntityCacheNumeredDofs>
580 operator()(boost::shared_ptr<FieldEntity> &e) {
581 return e->entityCacheRowDofs;
582 }
583 };
584
585 struct Inserter {
587 using It = Idx::iterator;
588 It operator()(boost::shared_ptr<Idx> &dofs_view, It &hint,
589 boost::shared_ptr<FENumeredDofEntity> &&dof) {
590 return dofs_view->emplace_hint(hint, dof);
591 }
592 };
593
594 auto row_dofs = boost::make_shared<FENumeredDofEntity_multiIndex>();
595 if (get_cache_data_dofs_view(getRowFieldEntsPtr(), row_dofs, Extractor(),
596 Inserter()))
597 THROW_MESSAGE("row_dofs can not be created");
598
599 return row_dofs;
600}
601
602boost::shared_ptr<FENumeredDofEntity_multiIndex>
605
606 struct Extractor {
607 boost::weak_ptr<EntityCacheNumeredDofs>
608 operator()(boost::shared_ptr<FieldEntity> &e) {
609 return e->entityCacheColDofs;
610 }
611 };
612
613 struct Inserter {
615 using It = Idx::iterator;
616 It operator()(boost::shared_ptr<Idx> &dofs_view, It &hint,
617 boost::shared_ptr<FENumeredDofEntity> &&dof) {
618 return dofs_view->emplace_hint(hint, dof);
619 }
620 };
621
622 auto col_dofs = boost::make_shared<FENumeredDofEntity_multiIndex>();
623 if (get_cache_data_dofs_view(getColFieldEntsPtr(), col_dofs, Extractor(),
624 Inserter()))
625 THROW_MESSAGE("col_dofs can not be created");
626
627 return col_dofs;
628}
629
630} // namespace MoFEM
constexpr double a
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:447
@ L2
field with C-1 continuity
Definition: definitions.h:88
@ NOFIELD
scalar or vector of scalars describe (no true field)
Definition: definitions.h:84
@ H1
continuous field
Definition: definitions.h:85
@ HCURL
field with continuous tangents
Definition: definitions.h:86
@ HDIV
field with continuous normal traction
Definition: definitions.h:87
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:346
#define CHK_MOAB_THROW(err, msg)
Check error code of MoAB function and throw MoFEM exception.
Definition: definitions.h:576
@ MOFEM_DATA_INCONSISTENCY
Definition: definitions.h:31
@ MOFEM_NOT_IMPLEMENTED
Definition: definitions.h:32
#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
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:440
#define THROW_MESSAGE(msg)
Throw MoFEM exception.
Definition: definitions.h:561
multi_index_container< boost::shared_ptr< FENumeredDofEntity >, indexed_by< ordered_unique< tag< Unique_mi_tag >, const_mem_fun< FENumeredDofEntity::interface_type_DofEntity, UId, &FENumeredDofEntity::getLocalUniqueId > >, ordered_non_unique< tag< Ent_mi_tag >, const_mem_fun< FENumeredDofEntity::interface_type_DofEntity, EntityHandle, &FENumeredDofEntity::getEnt > > > > FENumeredDofEntity_multiIndex
MultiIndex container keeps FENumeredDofEntity.
multi_index_container< boost::shared_ptr< SideNumber >, indexed_by< ordered_unique< member< SideNumber, EntityHandle, &SideNumber::ent > >, ordered_non_unique< composite_key< SideNumber, const_mem_fun< SideNumber, EntityType, &SideNumber::getEntType >, member< SideNumber, signed char, &SideNumber::side_number > > > > > SideNumber_multiIndex
SideNumber_multiIndex for SideNumber.
BlockParamData * cache
static MoFEMErrorCodeGeneric< moab::ErrorCode > rval
Definition: Exceptions.hpp:74
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
Definition: Exceptions.hpp:56
std::bitset< BITFIELDID_SIZE > BitFieldId
Field Id.
Definition: Types.hpp:42
uint128_t UId
Unique Id.
Definition: Types.hpp:31
implementation of Data Operators for Forces and Sources
Definition: Common.hpp:10
std::ostream & operator<<(std::ostream &os, const EntitiesFieldData::EntData &e)
std::vector< boost::weak_ptr< FieldEntity > > FieldEntity_vector_view
static MoFEMErrorCode get_cache_data_dofs_view(ENTSVIEW &ents_view, DOFSVIEW &dofs_view, EXTRACTOR &&extractor, INSERTER &&inserter)
static constexpr DefEntTypeMap defVertexTypeMap
static constexpr DefEntTypeMap defEdgeTypeMap
std::array< bool, MBMAXTYPE > DefEntTypeMap
static constexpr DefEntTypeMap defQuadTypeMap
static constexpr DefEntTypeMap defTriTypeMap
static MoFEMErrorCode defaultMeshset(Interface &moab, const Field &field, const EntFiniteElement &fe, std::vector< EntityHandle > &adjacency)
static MoFEMErrorCode defaultVertex(Interface &moab, const Field &field, const EntFiniteElement &fe, std::vector< EntityHandle > &adjacency)
static MoFEMErrorCode defaultVolume(Interface &moab, const Field &field, const EntFiniteElement &fe, std::vector< EntityHandle > &adjacency)
static constexpr std::array< const DefEntTypeMap *, MBMAXTYPE > defTypeMap
static constexpr DefEntTypeMap defTetTypeMap
static constexpr DefEntTypeMap defHexTypeMap
static constexpr DefEntTypeMap defMeshsetTypeMap
static MoFEMErrorCode defaultEdge(Interface &moab, const Field &field, const EntFiniteElement &fe, std::vector< EntityHandle > &adjacency)
static MoFEMErrorCode defaultPrism(Interface &moab, const Field &field, const EntFiniteElement &fe, std::vector< EntityHandle > &adjacency)
static MoFEMErrorCode defaultFace(Interface &moab, const Field &field, const EntFiniteElement &fe, std::vector< EntityHandle > &adjacency)
static constexpr DefEntTypeMap defPrismTypeMap
Finite element data for entity.
EntFiniteElement(const boost::shared_ptr< RefElement > &ref_finite_element, const boost::shared_ptr< FiniteElement > &fe_ptr)
boost::shared_ptr< std::vector< boost::shared_ptr< FEDofEntity > > > getDataVectorDofsPtr() const
Get data data dos multi-index structure.
boost::shared_ptr< FieldEntity_vector_view > dataFieldEnts
boost::shared_ptr< FEDofEntity_multiIndex > getDataDofsPtr() const
Get the Data Dofs Ptr object.
MoFEMErrorCode getElementAdjacency(const boost::shared_ptr< Field > field_ptr, std::vector< EntityHandle > &adjacency)
Provide data structure for (tensor) field approximation.
EntityHandle getMeshset() const
Get field meshset.
FieldSpace getSpace() const
Get field approximation space.
void operator()(boost::shared_ptr< FiniteElement > &fe)
void operator()(boost::shared_ptr< FiniteElement > &fe)
void operator()(boost::shared_ptr< FiniteElement > &fe)
void operator()(boost::shared_ptr< FiniteElement > &fe)
void operator()(boost::shared_ptr< FiniteElement > &fe)
void operator()(boost::shared_ptr< FiniteElement > &fe)
void operator()(boost::shared_ptr< FiniteElement > &fe)
void operator()(boost::shared_ptr< FiniteElement > &fe)
void operator()(boost::shared_ptr< FiniteElement > &fe)
Finite element definition.
BitFieldId * tag_BitFieldId_col_data
tag stores col id_id for fields
void * tagName
ptr to tag storing FE name
unsigned int getBitNumber() const
Get bit identifying this element.
BitFieldId * tag_BitFieldId_data
tag stores data id_id for fields
BitFEId * tagId
ptr to tag storing FE id
BitFieldId getBitFieldIdRow() const
Get field ids on rows.
BitFEId getId() const
Get finite element id.
FiniteElement(Interface &moab, const EntityHandle _meshset)
BitFieldId * tag_BitFieldId_row_data
tag stores row id_id for fields
static constexpr int ent_shift
boost::string_ref getNameRef() const
Get finite element name.
BitFieldId getBitFieldIdData() const
Get field ids on data.
BitFieldId getBitFieldIdCol() const
Get field ids on columns.
int tagNameSize
numer of characters in FE name
EntityHandle meshset
meshset stores FE ents
std::array< ElementAdjacencyFunct, MBMAXTYPE > elementAdjacencyTable
Table of functions retrieving adjacencies for finite element User can alter and change default behavi...
Partitioned (Indexed) Finite Element in Problem.
boost::weak_ptr< FENumeredDofEntity > getRowDofsByPetscGlobalDofIdx(const int idx) const
get FE dof by petsc index
boost::weak_ptr< FENumeredDofEntity > getColDofsByPetscGlobalDofIdx(const int idx) const
get FE dof by petsc index
NumeredEntFiniteElement(const boost::shared_ptr< EntFiniteElement > &sptr)
boost::shared_ptr< EntFiniteElement > & getEntFiniteElement() const
boost::shared_ptr< FENumeredDofEntity_multiIndex > getRowDofsPtr() const
get FE dof on row
boost::shared_ptr< FENumeredDofEntity_multiIndex > getColDofsPtr() const
get FE dof on column
unsigned int part
Partition number.
keeps data about abstract refined finite element
keeps information about side number for the finite element
interface to EntFiniteElement
boost::shared_ptr< FieldEntity_vector_view > & getColFieldEntsPtr() const
boost::shared_ptr< FieldEntity_vector_view > & getRowFieldEntsPtr() const
const boost::shared_ptr< RefElement > & getRefElement() const
boost::shared_ptr< FE > & getFiniteElementPtr() const
const boost::shared_ptr< SideNumber > & getSideNumberPtr(const EntityHandle ent) const
boost::shared_ptr< RefEntity > & getRefEntityPtr() const
SideNumber_multiIndex & getSideNumberTable() const
boost::shared_ptr< T > & getRefElement() const