v0.15.0
Loading...
Searching...
No Matches
Public Types | Static Public Member Functions | Static Public Attributes | List of all members
MoFEM::DefaultElementAdjacency Struct Reference
MoFEM » Finite elements structures and multi-indices

default adjacency map More...

#include "src/multi_indices/FEMultiIndices.hpp"

Collaboration diagram for MoFEM::DefaultElementAdjacency:
[legend]

Public Types

using DefEntTypeMap = std::array< bool, MBMAXTYPE >
 

Static Public Member Functions

static MoFEMErrorCode defaultVertex (Interface &moab, const Field &field, const EntFiniteElement &fe, std::vector< EntityHandle > &adjacency)
 
static MoFEMErrorCode defaultEdge (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 MoFEMErrorCode defaultVolume (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 defaultMeshset (Interface &moab, const Field &field, const EntFiniteElement &fe, std::vector< EntityHandle > &adjacency)
 
static bool getDefTypeMap (const EntityType fe_type, const EntityType ent_type)
 

Static Public Attributes

static constexpr DefEntTypeMap defVertexTypeMap
 
static constexpr DefEntTypeMap defEdgeTypeMap
 
static constexpr DefEntTypeMap defTriTypeMap
 
static constexpr DefEntTypeMap defQuadTypeMap
 
static constexpr DefEntTypeMap defTetTypeMap
 
static constexpr DefEntTypeMap defHexTypeMap
 
static constexpr DefEntTypeMap defPrismTypeMap
 
static constexpr DefEntTypeMap defMeshsetTypeMap
 
static constexpr std::array< const DefEntTypeMap *, MBMAXTYPE > defTypeMap
 

Detailed Description

default adjacency map

Definition at line 176 of file FEMultiIndices.hpp.

Member Typedef Documentation

◆ DefEntTypeMap

using MoFEM::DefaultElementAdjacency::DefEntTypeMap = std::array<bool, MBMAXTYPE>

Definition at line 197 of file FEMultiIndices.hpp.

Member Function Documentation

◆ defaultEdge()

MoFEMErrorCode MoFEM::DefaultElementAdjacency::defaultEdge ( Interface &  moab,
const Field &  field,
const EntFiniteElement &  fe,
std::vector< EntityHandle > &  adjacency 
)
static

Definition at line 99 of file FEMultiIndices.cpp.

101 {
102 MoFEMFunctionBegin;
103 EntityHandle fe_ent = fe.getEnt();
104 // Range nodes;
105 switch (field.getSpace()) {
106 case H1:
107 CHKERR moab.get_connectivity(&fe_ent, 1, adjacency, true);
108 case HCURL:
109 case L2:
110 adjacency.push_back(fe_ent);
111 // build side table
112 for (auto e : adjacency)
113 fe.getSideNumberPtr(e);
114 break;
115 case NOFIELD: {
116 auto adjacency_meshset =
117 FiniteElement::getNoFieldAdjacencyMeshset(moab, fe_ent, field);
118 CHKERR moab.get_entities_by_handle(adjacency_meshset, adjacency, false);
119 for (auto e : adjacency) {
120 const_cast<SideNumber_multiIndex &>(fe.getSideNumberTable())
121 .insert(boost::shared_ptr<SideNumber>(new SideNumber(e, -1, 0, 0)));
122 }
123 } break;
124 default:
125 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
126 "this field is not implemented for EDGE finite element");
127 }
128
129 MoFEMFunctionReturn(0);
130}
L2
@ L2
field with C-1 continuity
Definition definitions.h:88
NOFIELD
@ NOFIELD
scalar or vector of scalars describe (no true field)
Definition definitions.h:84
H1
@ H1
continuous field
Definition definitions.h:85
HCURL
@ HCURL
field with continuous tangents
Definition definitions.h:86
MoFEMFunctionBegin
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition definitions.h:359
MOFEM_NOT_IMPLEMENTED
@ MOFEM_NOT_IMPLEMENTED
Definition definitions.h:32
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
SideNumber_multiIndex
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.
Definition RefEntsMultiIndices.hpp:101
MoFEM::FiniteElement::getNoFieldAdjacencyMeshset
static EntityHandle getNoFieldAdjacencyMeshset(moab::Interface &moab, EntityHandle fe_ent, const Field &field)
Get the No Field adjacency meshset from finite element entity.
Definition FEMultiIndices.cpp:60

◆ defaultFace()

MoFEMErrorCode MoFEM::DefaultElementAdjacency::defaultFace ( Interface &  moab,
const Field &  field,
const EntFiniteElement &  fe,
std::vector< EntityHandle > &  adjacency 
)
static

Definition at line 133 of file FEMultiIndices.cpp.

135 {
136 MoFEMFunctionBegin;
137 // Range nodes,edges;
138 const EntityHandle fe_ent = fe.getEnt();
139 switch (field.getSpace()) {
140 case H1:
141 CHKERR moab.get_connectivity(&fe_ent, 1, adjacency, true);
142 case HCURL:
143 CHKERR moab.get_adjacencies(&fe_ent, 1, 1, false, adjacency,
144 moab::Interface::UNION);
145 case HDIV:
146 case L2:
147 adjacency.push_back(fe_ent);
148 // build side table
149 for (auto ent : adjacency)
150 fe.getSideNumberPtr(ent);
151 break;
152 case NOFIELD: {
153 auto adjacency_meshset =
154 FiniteElement::getNoFieldAdjacencyMeshset(moab, fe_ent, field);
155 CHKERR moab.get_entities_by_handle(adjacency_meshset, adjacency, false);
156 for (auto ent : adjacency) {
157 const_cast<SideNumber_multiIndex &>(fe.getSideNumberTable())
158 .insert(boost::shared_ptr<SideNumber>(new SideNumber(ent, -1, 0, 0)));
159 }
160 } break;
161 default:
162 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
163 "this field is not implemented for TRI finite element");
164 }
165
166 MoFEMFunctionReturn(0);
167}
HDIV
@ HDIV
field with continuous normal traction
Definition definitions.h:87

◆ defaultMeshset()

MoFEMErrorCode MoFEM::DefaultElementAdjacency::defaultMeshset ( Interface &  moab,
const Field &  field,
const EntFiniteElement &  fe,
std::vector< EntityHandle > &  adjacency 
)
static

Definition at line 347 of file FEMultiIndices.cpp.

349 {
350 MoFEMFunctionBegin;
351
352#ifndef NDEBUG
353 if (fe.getEntType() != MBENTITYSET)
354 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
355 "Finite element is not of type MBENTITYSET");
356#endif
357
358 // resolve recursively all ents in the meshset
359 switch (field.getSpace()) {
360 case H1:
361 case HCURL:
362 case HDIV:
363 case L2:
364 // H1, HCURL, HDIV, L2 we not suppose to access those from OP, so that why
365 // sign -1. That is to optimism efficiency
366 CHKERR moab.get_entities_by_handle(fe.getEnt(), adjacency, false);
367 for (auto ent : adjacency) {
368 const_cast<SideNumber_multiIndex &>(fe.getSideNumberTable())
369 .insert(boost::shared_ptr<SideNumber>(new SideNumber(ent, -1, 0, 0)));
370 }
371 break;
372 case NOFIELD: {
373 auto adjacency_meshset =
374 FiniteElement::getNoFieldAdjacencyMeshset(moab, fe.getEnt(), field);
375 CHKERR moab.get_entities_by_handle(adjacency_meshset, adjacency, false);
376 for (auto ent : adjacency) {
377 const_cast<SideNumber_multiIndex &>(fe.getSideNumberTable())
378 .insert(boost::shared_ptr<SideNumber>(new SideNumber(ent, -1, 0, 0)));
379 }
380 } break;
381 default:
382 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED, "not implemented");
383 }
384 MoFEMFunctionReturn(0);
385}
MOFEM_DATA_INCONSISTENCY
@ MOFEM_DATA_INCONSISTENCY
Definition definitions.h:31

◆ defaultPrism()

MoFEMErrorCode MoFEM::DefaultElementAdjacency::defaultPrism ( Interface &  moab,
const Field &  field,
const EntFiniteElement &  fe,
std::vector< EntityHandle > &  adjacency 
)
static

Definition at line 207 of file FEMultiIndices.cpp.

209 {
210 MoFEMFunctionBegin;
211 const EntityHandle prism = fe.getEnt();
212 Range nodes;
213 // initialize side sets
214 fe.getRefElement()->getSideNumberPtr(prism);
215 EntityHandle face_side3, face_side4;
216 CHKERR moab.side_element(prism, 2, 3, face_side3);
217 CHKERR moab.side_element(prism, 2, 4, face_side4);
218 fe.getRefElement()->getSideNumberPtr(face_side3);
219 fe.getRefElement()->getSideNumberPtr(face_side4);
220 for (int qq = 0; qq < 3; qq++) {
221 EntityHandle quad = 0;
222 rval = moab.side_element(prism, 2, qq, quad);
223 if (rval != MB_SUCCESS || quad == 0)
224 continue;
225 int side_number, sense, offset;
226 rval = moab.side_number(prism, quad, side_number, sense, offset);
227 if (side_number == -1 || rval != MB_SUCCESS)
228 continue;
229 const_cast<SideNumber_multiIndex &>(fe.getSideNumberTable())
230 .insert(boost::shared_ptr<SideNumber>(
231 new SideNumber(quad, side_number, sense, offset)));
232 }
233 int ee = 0;
234 for (; ee < 3; ee++) {
235 EntityHandle edge = 0;
236 CHKERR moab.side_element(prism, 1, ee, edge);
237 boost::shared_ptr<SideNumber> side_ptr =
238 fe.getRefElement()->getSideNumberPtr(edge);
239 if (side_ptr->side_number != ee) {
240 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
241 "data inconsistency for edge %d while in FE data structure is "
242 "numbered %d.",
243 ee, side_ptr->side_number);
244 }
245 CHKERR moab.side_element(prism, 1, 6 + ee, edge);
246 side_ptr = fe.getRefElement()->getSideNumberPtr(edge);
247 if (side_ptr->side_number != ee + 6) {
248 if (side_ptr->side_number != ee) {
249 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
250 "data inconsistency for edge %d while in FE data structure "
251 "is numbered %d.",
252 ee, side_ptr->side_number);
253 } else {
254 side_ptr->brother_side_number = ee + 6;
255 }
256 }
257 }
258 for (; ee < 6; ee++) {
259 EntityHandle edge = 0;
260 rval = moab.side_element(prism, 1, ee, edge);
261 if (rval != MB_SUCCESS || edge == 0)
262 continue;
263 int side_number, sense, offset;
264 rval = moab.side_number(prism, edge, side_number, sense, offset);
265 if (side_number == -1 || rval != MB_SUCCESS)
266 continue;
267 const_cast<SideNumber_multiIndex &>(fe.getSideNumberTable())
268 .insert(boost::shared_ptr<SideNumber>(
269 new SideNumber(edge, side_number, sense, offset)));
270 }
271 int nn = 0;
272 for (; nn < 3; nn++) {
273 EntityHandle node;
274 CHKERR moab.side_element(prism, 0, nn, node);
275 boost::shared_ptr<SideNumber> side_ptr =
276 fe.getRefElement()->getSideNumberPtr(node);
277 if (side_ptr->side_number != nn) {
278 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
279 "data inconsistency for node %d while in FE datastructure is "
280 "numbered %d.",
281 nn, side_ptr->side_number);
282 }
283 CHKERR moab.side_element(prism, 0, nn + 3, node);
284 side_ptr = fe.getRefElement()->getSideNumberPtr(node);
285 if (side_ptr->side_number != nn + 3) {
286 if (side_ptr->side_number != nn) {
287 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
288 "data inconsistency for node %d while in FE datastructure is "
289 "numbered %d.",
290 nn, side_ptr->side_number);
291 } else {
292 side_ptr->brother_side_number = nn + 3;
293 }
294 }
295 }
296
297 // get adjacencies
298 SideNumber_multiIndex &side_table = fe.getRefElement()->getSideNumberTable();
299 switch (field.getSpace()) {
300 case H1:
301 // moab.get_connectivity(&prism,1,nodes,true);
302 // use get adjacencies, this will allow take in account adjacencies set user
303 CHKERR moab.get_adjacencies(&prism, 1, 0, false, nodes,
304 moab::Interface::UNION);
305 {
306 Range topo_nodes;
307 CHKERR moab.get_connectivity(&prism, 1, topo_nodes, true);
308 Range mid_nodes;
309 CHKERR moab.get_connectivity(&prism, 1, mid_nodes, false);
310 mid_nodes = subtract(mid_nodes, topo_nodes);
311 nodes = subtract(nodes, mid_nodes);
312 }
313 adjacency.insert(adjacency.end(), nodes.begin(), nodes.end());
314 case HCURL: {
315 auto siit = side_table.get<0>().lower_bound(get_id_for_min_type<MBEDGE>());
316 auto hi_siit =
317 side_table.get<0>().upper_bound(get_id_for_max_type<MBEDGE>());
318 for (; siit != hi_siit; siit++)
319 adjacency.push_back(siit->get()->ent);
320 }
321 case HDIV: {
322 auto siit = side_table.get<0>().lower_bound(get_id_for_min_type<MBTRI>());
323 auto hi_siit =
324 side_table.get<0>().upper_bound(get_id_for_max_type<MBQUAD>());
325 for (; siit != hi_siit; siit++)
326 adjacency.push_back(siit->get()->ent);
327 }
328 case L2:
329 adjacency.push_back(prism);
330 break;
331 case NOFIELD: {
332 auto adjacency_meshset =
333 FiniteElement::getNoFieldAdjacencyMeshset(moab, prism, field);
334 CHKERR moab.get_entities_by_handle(adjacency_meshset, adjacency, false);
335 for (auto ent : adjacency) {
336 const_cast<SideNumber_multiIndex &>(fe.getSideNumberTable())
337 .insert(boost::shared_ptr<SideNumber>(new SideNumber(ent, -1, 0, 0)));
338 }
339 } break;
340 default:
341 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
342 "this field is not implemented for TRI finite element");
343 }
344 MoFEMFunctionReturn(0);
345}
MoFEM::Exceptions::rval
static MoFEMErrorCodeGeneric< moab::ErrorCode > rval
Definition Exceptions.hpp:74

◆ defaultVertex()

MoFEMErrorCode MoFEM::DefaultElementAdjacency::defaultVertex ( Interface &  moab,
const Field &  field,
const EntFiniteElement &  fe,
std::vector< EntityHandle > &  adjacency 
)
static

Definition at line 70 of file FEMultiIndices.cpp.

72 {
73 MoFEMFunctionBegin;
74 switch (field.getSpace()) {
75 case H1:
76 adjacency.push_back(fe.getEnt());
77 // build side table
78 for (auto ent : adjacency)
79 fe.getSideNumberPtr(ent);
80 break;
81 case NOFIELD: {
82 auto adjacency_meshset =
83 FiniteElement::getNoFieldAdjacencyMeshset(moab, fe.getEnt(), field);
84 CHKERR moab.get_entities_by_handle(adjacency_meshset, adjacency, false);
85 for (auto ent : adjacency) {
86 const_cast<SideNumber_multiIndex &>(fe.getSideNumberTable())
87 .insert(boost::shared_ptr<SideNumber>(new SideNumber(ent, -1, 0, 0)));
88 }
89 } break;
90 default:
91 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
92 "this field is not implemented for VERTEX finite element");
93 }
94
95 MoFEMFunctionReturn(0);
96}

◆ defaultVolume()

MoFEMErrorCode MoFEM::DefaultElementAdjacency::defaultVolume ( Interface &  moab,
const Field &  field,
const EntFiniteElement &  fe,
std::vector< EntityHandle > &  adjacency 
)
static

Definition at line 169 of file FEMultiIndices.cpp.

171 {
172 MoFEMFunctionBegin;
173 EntityHandle fe_ent = fe.getEnt();
174 switch (field.getSpace()) {
175 case H1:
176 CHKERR moab.get_connectivity(&fe_ent, 1, adjacency, true);
177 case HCURL:
178 CHKERR moab.get_adjacencies(&fe_ent, 1, 1, false, adjacency,
179 moab::Interface::UNION);
180 case HDIV:
181 CHKERR moab.get_adjacencies(&fe_ent, 1, 2, false, adjacency,
182 moab::Interface::UNION);
183 case L2:
184 adjacency.push_back(fe_ent);
185 // build side table
186 for (auto ent : adjacency)
187 fe.getSideNumberPtr(ent);
188 break;
189 case NOFIELD: {
190 auto adjacency_meshset =
191 FiniteElement::getNoFieldAdjacencyMeshset(moab, fe_ent, field);
192 CHKERR moab.get_entities_by_handle(adjacency_meshset, adjacency, false);
193 for (auto ent : adjacency) {
194 const_cast<SideNumber_multiIndex &>(fe.getSideNumberTable())
195 .insert(boost::shared_ptr<SideNumber>(new SideNumber(ent, -1, 0, 0)));
196 }
197 } break;
198 default:
199 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
200 "this field is not implemented for TRI finite element");
201 }
202
203 MoFEMFunctionReturn(0);
204}

◆ getDefTypeMap()

static bool MoFEM::DefaultElementAdjacency::getDefTypeMap ( const EntityType  fe_type,
const EntityType  ent_type 
)
inlinestatic

Definition at line 352 of file FEMultiIndices.hpp.

353 {
354 if (auto ptr = defTypeMap[fe_type])
355 return (*ptr)[ent_type];
356 THROW_MESSAGE("DefTypeMap is not defined by this element. This is propably "
357 "new implementation, and has to be implemented");
358 return false;
359 }
THROW_MESSAGE
#define THROW_MESSAGE(msg)
Throw MoFEM exception.
Definition definitions.h:577
MoFEM::DefaultElementAdjacency::defTypeMap
static constexpr std::array< const DefEntTypeMap *, MBMAXTYPE > defTypeMap
Definition FEMultiIndices.hpp:335

Member Data Documentation

◆ defEdgeTypeMap

constexpr DefaultElementAdjacency::DefEntTypeMap MoFEM::DefaultElementAdjacency::defEdgeTypeMap
staticconstexpr
Initial value:
= {
true,
true,
false,
false,
false,
false,
false,
false,
false,
false,
false,
false
}

Definition at line 216 of file FEMultiIndices.hpp.

216 {
217 // clang-format off
218 true, // MBVERTEX
219 true, // MBEDGE
220 false, // MBTRI
221 false, // MBQUAD
222 false, // MBPOLYGON
223 false, // MBTET
224 false, // MBPYRAMID
225 false, // MBPRISM
226 false, // MBKNIFE
227 false, // MBHEX
228 false, // MBPOLYHEDRON
229 false // MBENTITYSET
230 // clang-format on
231 };

◆ defHexTypeMap

constexpr DefaultElementAdjacency::DefEntTypeMap MoFEM::DefaultElementAdjacency::defHexTypeMap
staticconstexpr
Initial value:
= {
true,
true,
false,
true,
false,
false,
false,
false,
false,
true,
false,
false
}

Definition at line 284 of file FEMultiIndices.hpp.

284 {
285 // clang-format off
286 true, // MBVERTEX
287 true, // MBEDGE
288 false, // MBTRI
289 true, // MBQUAD
290 false, // MBPOLYGON
291 false, // MBTET
292 false, // MBPYRAMID
293 false, // MBPRISM
294 false, // MBKNIFE
295 true, // MBHEX
296 false, // MBPOLYHEDRON
297 false // MBENTITYSET
298 // clang-format on
299 };

◆ defMeshsetTypeMap

constexpr DefaultElementAdjacency::DefEntTypeMap MoFEM::DefaultElementAdjacency::defMeshsetTypeMap
staticconstexpr
Initial value:
= {
true,
true,
true,
true,
true,
true,
true,
true,
true,
true,
true,
true
}

Definition at line 318 of file FEMultiIndices.hpp.

318 {
319 // clang-format off
320 true, // MBVERTEX
321 true, // MBEDGE
322 true, // MBTRI
323 true, // MBQUAD
324 true, // MBPOLYGON
325 true, // MBTET
326 true, // MBPYRAMID
327 true, // MBPRISM
328 true, // MBKNIFE
329 true, // MBHEX
330 true, // MBPOLYHEDRON
331 true // MBENTITYSET
332 // clang-format on
333 };

◆ defPrismTypeMap

constexpr DefaultElementAdjacency::DefEntTypeMap MoFEM::DefaultElementAdjacency::defPrismTypeMap
staticconstexpr
Initial value:
= {
true,
true,
true,
true,
false,
false,
false,
true,
false,
false,
false,
false
}

Definition at line 301 of file FEMultiIndices.hpp.

301 {
302 // clang-format off
303 true, // MBVERTEX
304 true, // MBEDGE
305 true, // MBTRI
306 true, // MBQUAD
307 false, // MBPOLYGON
308 false, // MBTET
309 false, // MBPYRAMID
310 true, // MBPRISM
311 false, // MBKNIFE
312 false, // MBHEX
313 false, // MBPOLYHEDRON
314 false // MBENTITYSET
315 // clang-format on
316 };

◆ defQuadTypeMap

constexpr DefaultElementAdjacency::DefEntTypeMap MoFEM::DefaultElementAdjacency::defQuadTypeMap
staticconstexpr
Initial value:
= {
true,
true,
false,
true,
false,
false,
false,
false,
false,
false,
false,
false
}

Definition at line 250 of file FEMultiIndices.hpp.

250 {
251 // clang-format off
252 true, // MBVERTEX
253 true, // MBEDGE
254 false, // MBTRI
255 true, // MBQUAD
256 false, // MBPOLYGON
257 false, // MBTET
258 false, // MBPYRAMID
259 false, // MBPRISM
260 false, // MBKNIFE
261 false, // MBHEX
262 false, // MBPOLYHEDRON
263 false // MBENTITYSET
264 // clang-format on
265 };

◆ defTetTypeMap

constexpr DefaultElementAdjacency::DefEntTypeMap MoFEM::DefaultElementAdjacency::defTetTypeMap
staticconstexpr
Initial value:
= {
true,
true,
true,
false,
false,
true,
false,
false,
false,
false,
false,
false
}

Definition at line 267 of file FEMultiIndices.hpp.

267 {
268 // clang-format off
269 true, // MBVERTEX
270 true, // MBEDGE
271 true, // MBTRI
272 false, // MBQUAD
273 false, // MBPOLYGON
274 true, // MBTET
275 false, // MBPYRAMID
276 false, // MBPRISM
277 false, // MBKNIFE
278 false, // MBHEX
279 false, // MBPOLYHEDRON
280 false // MBENTITYSET
281 // clang-format on
282 };

◆ defTriTypeMap

constexpr DefaultElementAdjacency::DefEntTypeMap MoFEM::DefaultElementAdjacency::defTriTypeMap
staticconstexpr
Initial value:
= {
true,
true,
true,
false,
false,
false,
false,
false,
false,
false,
false,
false
}

Definition at line 233 of file FEMultiIndices.hpp.

233 {
234 // clang-format off
235 true, // MBVERTEX
236 true, // MBEDGE
237 true, // MBTRI
238 false, // MBQUAD
239 false, // MBPOLYGON
240 false, // MBTET
241 false, // MBPYRAMID
242 false, // MBPRISM
243 false, // MBKNIFE
244 false, // MBHEX
245 false, // MBPOLYHEDRON
246 false // MBENTITYSET
247 // clang-format on
248 };

◆ defTypeMap

constexpr std::array< const DefaultElementAdjacency::DefEntTypeMap *, MBMAXTYPE > MoFEM::DefaultElementAdjacency::defTypeMap
staticconstexpr
Initial value:
= {
&defVertexTypeMap,
&defEdgeTypeMap,
&defTriTypeMap,
&defQuadTypeMap,
nullptr,
&defTetTypeMap,
nullptr,
&defPrismTypeMap,
nullptr,
&defHexTypeMap,
nullptr,
&defMeshsetTypeMap
}
MoFEM::DefaultElementAdjacency::defVertexTypeMap
static constexpr DefEntTypeMap defVertexTypeMap
Definition FEMultiIndices.hpp:199
MoFEM::DefaultElementAdjacency::defEdgeTypeMap
static constexpr DefEntTypeMap defEdgeTypeMap
Definition FEMultiIndices.hpp:216
MoFEM::DefaultElementAdjacency::defQuadTypeMap
static constexpr DefEntTypeMap defQuadTypeMap
Definition FEMultiIndices.hpp:250
MoFEM::DefaultElementAdjacency::defTriTypeMap
static constexpr DefEntTypeMap defTriTypeMap
Definition FEMultiIndices.hpp:233
MoFEM::DefaultElementAdjacency::defTetTypeMap
static constexpr DefEntTypeMap defTetTypeMap
Definition FEMultiIndices.hpp:267
MoFEM::DefaultElementAdjacency::defHexTypeMap
static constexpr DefEntTypeMap defHexTypeMap
Definition FEMultiIndices.hpp:284
MoFEM::DefaultElementAdjacency::defMeshsetTypeMap
static constexpr DefEntTypeMap defMeshsetTypeMap
Definition FEMultiIndices.hpp:318
MoFEM::DefaultElementAdjacency::defPrismTypeMap
static constexpr DefEntTypeMap defPrismTypeMap
Definition FEMultiIndices.hpp:301

Definition at line 335 of file FEMultiIndices.hpp.

335 {
336 // clang-format off
337 &defVertexTypeMap, // MBVERTEX
338 &defEdgeTypeMap, // MBEDGE
339 &defTriTypeMap, // MBTRI
340 &defQuadTypeMap, // MBQUAD
341 nullptr, // MBPOLYGON
342 &defTetTypeMap, // MBTET
343 nullptr, // MBPYRAMID
344 &defPrismTypeMap, // MBPRISM
345 nullptr, // MBKNIFE
346 &defHexTypeMap, // MBHEX
347 nullptr, // MBPOLYHEDRON
348 &defMeshsetTypeMap // MBENTITYSET
349 // clang-format on
350 };

◆ defVertexTypeMap

constexpr DefaultElementAdjacency::DefEntTypeMap MoFEM::DefaultElementAdjacency::defVertexTypeMap
staticconstexpr
Initial value:
= {
true,
false,
false,
false,
false,
false,
false,
false,
false,
false,
false,
false
}

Definition at line 199 of file FEMultiIndices.hpp.

199 {
200 // clang-format off
201 true, // MBVERTEX
202 false, // MBEDGE
203 false, // MBTRI
204 false, // MBQUAD
205 false, // MBPOLYGON
206 false, // MBTET
207 false, // MBPYRAMID
208 false, // MBPRISM
209 false, // MBKNIFE
210 false, // MBHEX
211 false, // MBPOLYHEDRON
212 false // MBENTITYSET
213 // clang-format on
214 };
The documentation for this struct was generated from the following files:
Generated by Doxygen 1.9.8 and hosted at University of Glasgow