BELFEM 0.9.3
Berkeley Lab Finite Element Framework
Loading...
Searching...
No Matches
cl_ThinShellFactory.hpp
Go to the documentation of this file.
1/*
2 * BELFEM -- The Berkeley Lab Finite Element Framework
3 * Copyright (c) 2026, The Regents of the University of California,
4 * through Lawrence Berkeley National Laboratory (subject to receipt of any required
5 * approvals from the U.S. Dept. of Energy). All rights reserved.
6 *
7 * Developers: Christian Messe, Gregory Giard
8 *
9 * See the top-level LICENSE file for the complete license and disclaimer.
10 */
11
12#ifndef CL_FEM_THINSHELLFACTORY_HPP
13#define CL_FEM_THINSHELLFACTORY_HPP
14
15#include "cl_Mesh.hpp"
16#include "cl_ThinShell.hpp"
17#include "cl_Input_Section.hpp"
18#include "cl_Protoshell.hpp"
19#include "cl_Material.hpp"
20
21namespace belfem
22{
23 namespace mesh
24 {
25 class ThinShellFactory
26 {
27 const proc_t mCommRank ;
28 const uint mNumDimensions ;
29 Mesh * mMesh ;
30 Map< string, Material * > * mMaterialMap ;
31 id_t mMaxGroupID ;
32 id_t mMaxElementID ;
33 id_t mMaxNodeID ;
34
35 Cell< Node * > & mMasterNodes ;
36 Cell< Node * > & mSlaveNodes ;
37 Cell< index_t > mNodeIndices ;
38
39 struct Layer
40 {
41 bool hasDuplicates = false ;
42 Cell< Node * > Nodes ;
43 Cell< Edge * > Edges ;
44 Cell< Edge * > EdgeDuplicates ;
45 Cell< Face * > Faces ;
46 Cell< Face * > FaceDuplicates ;
47 Cell< Facet * > GhostFacets ;
48 };
49
50 struct SideLayer
51 {
52 const real Sign ;
53 Cell< Node * > InnerNodes ;
54 Cell< Node * > InnerNodeReference ;
55 Cell< Node * > OuterNodes ;
56 Cell< Edge * > InnerEdges ;
57 Cell< Edge * > InnerEdgeReference ;
58 Cell< Edge * > OuterEdges ;
59 Cell< Edge * > InnerEdgeDuplicates ;
60 Cell< Edge * > InnerEdgeDuplicateReference ;
61 Cell< Edge * > OuterEdgeDuplicates ;
62
63 SideLayer(
64 const real aSign,
65 Curve * aCurve,
66 Layer * aLayer,
67 Cell< Edge * > & aReferenceEdges,
68 const Cell< index_t > & aEdgeIndices,
69 const Matrix< real > & aBinomials,
70 const real aCoatingThickness,
71 id_t & aMaxNodeID,
72 id_t & aMaxEdgeID,
73 const bool aFuseSideEdges )
74 : Sign ( aSign )
75 {
76 // collect the inner edges and their UNIQUE nodes: shared
77 // edge endpoints must appear exactly once, otherwise the
78 // slot containers get null holes and the index backup
79 // stores an already-overwritten temp index on the second
80 // occurrence
81 uint tNumNodesPerEdge = aLayer->Edges.first()->number_of_nodes() ;
82 InnerNodeReference.reserve( aEdgeIndices.size() * tNumNodesPerEdge );
83 InnerEdgeReference.reserve( aEdgeIndices.size() );
84 for ( index_t e : aEdgeIndices )
85 {
86 aLayer->Edges( e )->unflag_nodes( 7 ); // flag 7 is arbitrary, just want to make sure
87 // we don't collide with other flags
88 }
89 for ( index_t e : aEdgeIndices )
90 {
91 Edge * tEdge = aLayer->Edges( e );
92 InnerEdgeReference.push( tEdge );
93 for ( uint k=0; k<tEdge->number_of_nodes(); ++k )
94 {
95 Node * tNode = tEdge->node( k );
96 if ( ! tNode->is_flagged( 7 ) )
97 {
98 tNode->flag( 7 );
99 InnerNodeReference.push( tNode );
100 }
101 }
102 }
103 for ( index_t e : aEdgeIndices )
104 {
105 aLayer->Edges( e )->unflag_nodes( 7 );
106 }
107
108 // collect inner edge duplicates if they exist
109 if ( aLayer->hasDuplicates )
110 {
111 InnerEdgeDuplicateReference.reserve( aEdgeIndices.size() );
112 for ( index_t e : aEdgeIndices )
113 {
114 InnerEdgeDuplicateReference.push( aLayer->EdgeDuplicates( e ) );
115 }
116 }
117
118 // backup node indices and unflag
119 index_t tCount = 0 ;
120 Cell< index_t > tNodeIndices( InnerNodeReference.size(), 0 );
121 for ( Node * tNode : InnerNodeReference )
122 {
123 tNodeIndices( tCount ) = tNode->index();
124 tNode->set_index( tCount++ );
125 }
126
127 // create the node duplicates
128 InnerNodes.set_size( InnerNodeReference.size(), nullptr );
129 OuterNodes.set_size( InnerNodeReference.size(), nullptr );
130
131 index_t tEdgeOrder = InnerEdgeReference.first()->number_of_nodes() - 1 ;
132
133 Vector< real > tX( 3 );
134 Vector< real > tB( 3 );
135
136 tCount = 0 ;
137 index_t off = 0 ;
138
139 // temporary work container for node duplicates
140 Cell< Node * > tSwap ;
141
142 for ( Edge * tEdge : InnerEdgeReference )
143 {
144 Edge * tRef = aReferenceEdges( aEdgeIndices( tCount++ ) );
145
146 bool tIsReversed = tRef->node( 1 )->original() == aCurve->nodes()( off )->original();
147
148 BELFEM_ASSERT( tIsReversed || tRef->node( 0 )->original() == aCurve->nodes()( off )->original(),
149 "Can't determine edge orientation along curve %lu",
150 ( long unsigned int ) aCurve->id() );
151
152 for ( uint k=0; k<tEdge->number_of_nodes(); ++k )
153 {
154 Node * tNode = tEdge->node( k );
155
156 if ( OuterNodes( tNode->index() ) == nullptr )
157 {
158 switch ( k )
159 {
160 case 0 :
161 {
162 tB = tIsReversed ? aBinomials.col( off + tEdgeOrder ) : aBinomials.col( off );
163 break ;
164 }
165 case 1 :
166 {
167 tB = tIsReversed ? aBinomials.col( off ) : aBinomials.col( off + tEdgeOrder );
168 break ;
169 }
170 case 2 :
171 {
172 tB = aBinomials.col( off + 1 );
173 break ;
174 }
175 default:
176 {
177 BELFEM_ERROR( false, "not implemented" );
178 }
179 }
180
181 tNode->get_coords( tX );
182
183 Node * tDupI = new Node( ++aMaxNodeID, tX( 0 ), tX( 1 ), tX( 2 ) );
184 tX += aSign * tB * aCoatingThickness ;
185
186 Node * tOrg0 = tNode->original();
187
188 uint n = tOrg0->number_of_duplicates();
189 if ( n > 0 )
190 {
191 tSwap.set_size( n, nullptr );
192 for ( uint d=0; d<n; ++d )
193 {
194 tSwap( d ) = tOrg0->duplicate( d );
195 }
196 tOrg0->reset_duplicate_container();
197 tOrg0->allocate_duplicate_container( n+1 );
198 for ( Node * tDup : tSwap )
199 {
200 tOrg0->add_duplicate( tDup );
201 }
202 }
203 else
204 {
205 tOrg0->allocate_duplicate_container( 1 );
206 }
207 tOrg0->add_duplicate( tDupI );
208 tDupI->set_original( tOrg0 );
209
210 Node * tDupO = new Node( ++aMaxNodeID, tX( 0 ), tX( 1 ), tX( 2 ) );
211
212
213 Node * tOrg = tRef->node( k );
214
215 if ( tOrg->is_hanging() )
216 {
217 tDupI->allocate_source_container( tOrg->number_of_sources() );
218 tDupO->allocate_source_container( tOrg->number_of_sources() );
219 for ( uint s=0; s<tOrg->number_of_sources(); ++s )
220 {
221 tDupI->add_source( tOrg->source( s ), tOrg->weight( s ) );
222 tDupO->add_source( tOrg->source( s ), tOrg->weight( s ) );
223 }
224 }
225 else
226 {
227 tDupO->allocate_source_container( 1 );
228 tDupO->add_source( tOrg );
229 tDupI->allocate_source_container( 1 );
230 tDupI->add_source( tOrg );
231 }
232 InnerNodes( tNode->index() ) = tDupI ;
233 OuterNodes( tNode->index() ) = tDupO ;
234 }
235 }
236
237 off += tEdgeOrder ;
238 }
239
240 // create the decoupled edge copies. The references are the
241 // SOURCE and must never receive pushes ( self-pushing a
242 // range-iterated Cell reallocates and dangles the loop )
243 for ( uint d=0; d<2; ++d )
244 {
245 Cell< Edge * > & tReferenceEdges = d==0 ? InnerEdgeReference : InnerEdgeDuplicateReference ;
246 Cell< Edge * > & tInnerEdges = d==0 ? InnerEdges : InnerEdgeDuplicates ;
247 Cell< Edge * > & tOuterEdges = d==0 ? OuterEdges : OuterEdgeDuplicates ;
248
249 tInnerEdges.reserve( tReferenceEdges.size() );
250 tOuterEdges.reserve( tReferenceEdges.size() );
251
252 tCount = 0 ;
253 for ( Edge * tEdge : tReferenceEdges )
254 {
255 Edge * tDupI = new Edge();
256 tDupI->set_id( ++aMaxEdgeID );
257 tDupI->allocate_node_container( tEdge->number_of_nodes() );
258 for ( uint k=0; k<tEdge->number_of_nodes(); ++k )
259 {
260 // duplicate-sheet edges ( d == 1 ) reference the
261 // duplicate-sheet nodes, which were not in the
262 // gather: resolve the slot through their
263 // per-layer original ( the primary-sheet node ).
264 // Both twin edges share the wall node copies
265 Node * tSlotNode = d == 0 ?
266 tEdge->node( k ) : tEdge->node( k )->original() ;
267 tDupI->insert_node( InnerNodes( tSlotNode->index() ), k );
268 }
269 if ( tEdge->is_hanging() )
270 {
271 tDupI->allocate_source_container( tEdge->number_of_sources() );
272 for ( uint s=0; s<tEdge->number_of_sources(); ++s )
273 {
274 tDupI->add_source( tEdge->source( s ), tEdge->weight( s ) );
275 }
276 }
277 else
278 {
279 tDupI->allocate_source_container( 1 );
280 tDupI->add_source( tEdge, 1.0 );
281 }
282
283 tInnerEdges.push( tDupI );
284
285 Edge * tDupO = new Edge();
286 tDupO->set_id( ++aMaxEdgeID );
287 tDupO->allocate_node_container( tEdge->number_of_nodes() );
288 for ( uint k=0; k<tEdge->number_of_nodes(); ++k )
289 {
290 // slot resolution as for the inner copy above
291 Node * tSlotNode = d == 0 ?
292 tEdge->node( k ) : tEdge->node( k )->original() ;
293 tDupO->insert_node( OuterNodes( tSlotNode->index() ), k );
294 }
295 tOuterEdges.push( tDupO );
296
297 // fusing the outer side edges
298 if( aFuseSideEdges )
299 {
300 // layer edge copies carry no index of their own
301 Edge * tOrg = aReferenceEdges( aEdgeIndices( tCount++ ) );
302 tDupO->allocate_source_container( tOrg->number_of_nodes() );
303 for ( uint k=0; k<tOrg->number_of_nodes(); ++k )
304 {
305 // weights are computed later in
306 // DofData::create_dofwise_t_matrices_master()
307 tDupO->add_source( tOrg->node( k ) );
308 }
309 }
310 }
311
312 if ( ! aLayer->hasDuplicates ) break ;
313 }
314
315 // restore node indices; outer nodes mirror the
316 // shell-local index of their inner partner
317 tCount = 0 ;
318 for ( Node * tNode : InnerNodeReference )
319 {
320 tNode->set_index( tNodeIndices( tCount ) );
321 InnerNodes( tCount )->set_index( tNodeIndices( tCount ) );
322 OuterNodes( tCount )->set_index( tNodeIndices( tCount ) );
323 ++tCount ;
324 }
325
326 }
327
328 ~SideLayer() = default ;
329 };
330
334 real mConnectorWidth = 0.0 ;
336 bool mCreateGhostFacets = false ;
338 bool mCreateSideConnectors = false ;
339 bool mConnectorsForAllLayers = true ;
340
341 Map< key_t , index_t > mEdgeMap ;
342
343 // experimental switch that fuses the side edges to the air trace.
344 // off: free rims ( validated legacy ). The fuse is branch-coherent
345 // since the single-authority fix, but suppresses the through-
346 // thickness branch transition where the upper and lower cuts
347 // differ. TODO(cm): finish or remove the fuse; the plan is
348 // todo/deferred/side_edge_fusing_cut_aware_plan.md.
349 // Physics position:
350 // fusing is the mathematically cleaner continuity statement, yet
351 // measured runs converge slower for no better result — the fuse
352 // appears to overconstrain the rim, like enforcing a B·n = 0
353 // that the formulation already fulfills at the boundary. Both
354 // flags therefore stay false
355 bool mFuseEdges = false ;
356 bool mFuseEdgesWhenHavingSideConnectors = false ;
357//------------------------------------------------------------------------------
358 public :
359//------------------------------------------------------------------------------
360
376 ThinShellFactory(
377 Mesh * aMesh,
378 Cell< Node * > & aMasterNodes,
379 Cell< Node * > & aSlaveNodes,
380 Map< string, Material * > * aMaterialMap = nullptr,
381 const bool aCreateGhostFacets = false );
382
383 ~ThinShellFactory();
384
385 ThinShell *
386 create( Protoshell * aProtoShell );
387
388 void
389 flag_periodic_nodes();
390
391 void
392 unflag_periodic_nodes();
393
402 static void
403 update_node_facet_tables( Cell< Node * > & aNodes, Cell< Facet * > & aFacets );
404
405//------------------------------------------------------------------------------
406 private :
407//------------------------------------------------------------------------------
408
409 void
410 create_side_connectors(
411 const uint aOrder,
412 Protoshell * aProtoShell,
413 const Cell< id_t > & aBlockIDs,
414 Cell< Layer * > & aLayers,
415 Matrix< real > & aNodeNormals,
416 Cell< Edge* > & aEdges,
417 Cell< Facet * > & aFacets,
418 ThinShell * aThinShell );
419
420//------------------------------------------------------------------------------
421
422 void
423 reset_node_indices();
424
425//------------------------------------------------------------------------------
426
427 void
428 write_normals_to_mesh( Cell< Node * > & aNodes, const Matrix< real > & aNodeNormals );
429
430//------------------------------------------------------------------------------
431
432 void
433 collect_sidesets( const Vector< id_t > & aSideSetIDs, Cell< SideSet * > & aSideSets );
434
435//------------------------------------------------------------------------------
436
437 ElementType
438 collect_facets( Cell< SideSet * > & aSideSets, Cell< Facet * > & aFacets );
439
440//------------------------------------------------------------------------------
441
442 void
443 collect_nodes( Cell< Facet * > & aFacets, Cell< Node * > & aNodes );
444
445//------------------------------------------------------------------------------
446// Begin new Side connector functions
447//------------------------------------------------------------------------------
448
449 void
450 create_edge_map(
451 const key_t aNumNodes,
452 Cell< Edge * > & aEdges,
453 Map< key_t, index_t > & aEdgeMap );
454
455 void
456 create_edge_to_face_map(
457 Cell< Edge * > & aEdges,
458 Cell< Facet * > & aFacets,
459 const Cell< index_t > & aIndices,
460 Map< index_t, std::pair< index_t, int8_t > > & aMap );
461
462 void
463 compute_side_edge_indices(
464 Curve * aCurve,
465 const Map< key_t, index_t > & aEdgeMap,
466 const key_t aNumNodes ,
467 const uint aEdgeOrder,
468 Cell< index_t > & aEdgeIndices );
469
485 void
486 compute_side_authority(
487 Curve * aCurve,
488 Cell< Facet * > & aFacets,
489 Cell< Edge * > & aEdges,
490 const Cell< index_t > & aEdgeIndices,
491 Cell< Node * > & aEdgeSources,
492 Cell< Node * > & aNodeSources );
493
494 void
495 connect_side_edges(
496 Layer * aLayer,
497 Cell< Edge * > & aEdges,
498 const Cell< index_t > & aEdgeIndices,
499 const Cell< Node * > & aEdgeSources );
500
501 void
502 connect_side_edges(
503 SideLayer * aSideLayer,
504 Cell< Edge * > & aEdges,
505 const Cell< index_t > & aEdgeIndices );
506
507 void
508 connect_side_nodes(
509 Cell< Node * > & aSourceNodes,
510 const Cell< Node * > & aAuthorityNodes,
511 Cell< Node * > & aTargetNodes );
512
513//------------------------------------------------------------------------------
514// End new Side connector functions
515//------------------------------------------------------------------------------
516
517 void
518 process_nodes_line2(
519 const Cell< Facet * > & aFacets,
520 const Cell< Node * > & aNodes,
521 Matrix< real > & aNodeNormals );
522
523//------------------------------------------------------------------------------
524
525 void
526 process_nodes_line3(
527 const Cell< Facet * > & aFacets,
528 const Cell< Node * > & aNodes,
529 Matrix< real > & aNodeNormals );
530
531//------------------------------------------------------------------------------
532
533 void
534 process_nodes_tri3(
535 const Cell< Facet * > & aFacets,
536 const Cell< Node * > & aNodes,
537 Matrix< real > & aNodeNormals );
538
539//------------------------------------------------------------------------------
540
541 void
542 process_nodes_tri6(
543 const Cell< Facet * > & aFacets,
544 const Cell< Node * > & aNodes,
545 Matrix< real > & aNodeNormals );
546
547//------------------------------------------------------------------------------
548
549 void
550 compute_distances(
551 const uint aOrder,
552 const Vector< real > & aThicknesses,
553 Vector< real > & aDistances );
554
555//------------------------------------------------------------------------------
556
557 void
558 create_nodes_on_layers(
559 Cell< Node * > & aNodes,
560 const Matrix< real > & aNodeNormals,
561 const Vector< real > & aDistances,
562 Cell< Layer * > & aLayers );
563
564//------------------------------------------------------------------------------
565
566 void
567 create_edges_on_layers(
568 const Cell< Edge * > & aEdges,
569 id_t & aEdgeID,
570 Cell< Layer * > & aLayers );
571
572//------------------------------------------------------------------------------
573
574 void
575 create_faces_on_layers(
576 const Cell< Facet * > & aFacets,
577 id_t & aFaceID,
578 Cell< Layer * > & aLayers );
579
580//------------------------------------------------------------------------------
581
582 void
583 create_temporary_edges(
584 Cell< Node * > & aNodes,
585 Cell< Facet * > & aFacets,
586 Cell< Edge* > & aEdges );
587
588//------------------------------------------------------------------------------
589
590 void
591 create_elements_on_blocks_line2(
592 id_t & aBlockID,
593 id_t & aElementID,
594 Cell< Facet * > & aFacets,
595 Cell< Layer * > & aLayers,
596 Cell< Block * > & aBlocks ) ;
597
598//------------------------------------------------------------------------------
599
600 void
601 create_elements_on_blocks_line3(
602 id_t & aBlockID,
603 id_t & aElementID,
604 Cell< Facet * > & aFacets,
605 Cell< Layer * > & aLayers,
606 Cell< Block * > & aBlocks ) ;
607
608//------------------------------------------------------------------------------
609
610 void
611 create_elements_on_blocks_tri3(
612 id_t & aBlockID,
613 id_t & aElementID,
614 Cell< Facet * > & aFacets,
615 Cell< Layer * > & aLayers,
616 Cell< Block * > & aBlocks ) ;
617
618//------------------------------------------------------------------------------
619
620 void
621 create_elements_on_blocks_tri6(
622 id_t & aBlockID,
623 id_t & aElementID,
624 Cell< Facet * > & aFacets,
625 Cell< Layer * > & aLayers,
626 Cell< Block * > & aBlocks ) ;
627
628//------------------------------------------------------------------------------
629
630 void
631 link_elements_with_edges(
632 Cell< Facet * > & aFacets,
633 Cell< Layer * > & aLayers,
634 Cell< Block * > & aBlocks );
635
636//------------------------------------------------------------------------------
637
638 void
639 link_elements_with_faces(
640 Cell< Layer * > & aLayers,
641 Cell< Block * > & aBlocks );
642
643//------------------------------------------------------------------------------
644
645 void
646 create_buffers(
647 const Cell< string > & aMaterials,
648 Cell< Layer * > & aLayers,
649 Cell< Block * > & aBlocks );
650
651//------------------------------------------------------------------------------
652
653 // ghost facets for normal directions
654 void
655 create_ghost_facets(
656 const uint aOrder,
657 Cell< Facet * > & aFacets,
658 Cell< Layer * > & aLayers,
659 Cell< Block * > & aBlocks );
660
661//------------------------------------------------------------------------------
662
663 id_t
664 max_node_id();
665
666//------------------------------------------------------------------------------
667
668 id_t
669 max_element_id();
670
671//------------------------------------------------------------------------------
672
673 id_t
674 max_block_id();
675
676//------------------------------------------------------------------------------
677
678 real
679 compute_binomial_vectors(
680 Protoshell * aProtoShell,
681 Curve * aCurve,
682 const Matrix< real > & aNormals,
683 Matrix< real > & aBinomials );
684
685 void
686 update_node_edge_tables( Cell< Node * > & aNodes, Cell< Edge * > & aEdges );
687
688 void
689 flag_layer_nodes( Cell< Node * > & aNodes, Cell< Layer * > & aLayers );
690
691 SideSet *
692 create_periodic_sideset(
693 Cell< Block * > & aBlocks,
694 const bool aMaster );
695 };
696 }
697}
698#endif //CL_FEM_THINSHELLFACTORY_HPP
BELFEM_ERROR
#define BELFEM_ERROR(aCheck,...)
Definition assert.hpp:264
BELFEM_ASSERT
#define BELFEM_ASSERT(aCheck,...)
Definition assert.hpp:244
cl_Input_Section.hpp
cl_Material.hpp
cl_Mesh.hpp
cl_Protoshell.hpp
cl_ThinShell.hpp
belfem::Cell
A bounds-checked wrapper around std::vector.
Definition cl_Cell.hpp:45
belfem::Cell::set_size
void set_size(const size_t aSize)
New elements are value-initialized ( zero for arithmetic T, nullptr for pointers ).
Definition cl_Cell.hpp:199
belfem::Cell::first
T & first()
Definition cl_Cell.hpp:309
belfem::Cell::size
size_t size() const
Definition cl_Cell.hpp:189
belfem::Cell::push
void push(const T &aValue)
Definition cl_Cell.hpp:265
belfem::Cell::reserve
void reserve(const size_t aSize)
Definition cl_Cell.hpp:257
belfem::Map
Hash map (unordered key-value).
Definition cl_Map.hpp:75
belfem::Matrix::col
auto col(const size_t aColIndex) -> decltype(mMatrix.col(aColIndex))
Definition cl_AR_Matrix.hpp:325
belfem::Mesh
Top-level container for all mesh entities.
Definition cl_Mesh.hpp:60
belfem::Protoshell
Thin shell configuration object for electromagnetic simulations.
Definition cl_Protoshell.hpp:41
belfem::graph::Vertex::index
virtual index_t index() const
Definition cl_Graph_Vertex.hpp:234
belfem::graph::Vertex::set_id
void set_id(const id_t aID)
Definition cl_Graph_Vertex.hpp:210
belfem::graph::Vertex::flag
virtual void flag(const uint8_t aIndex=0)
Definition cl_Graph_Vertex.hpp:273
belfem::graph::Vertex::is_flagged
virtual bool is_flagged(const uint8_t aIndex=0) const
Definition cl_Graph_Vertex.hpp:293
belfem::mesh::Basis::is_hanging
bool is_hanging() const
Definition cl_Mesh_Basis.hpp:266
belfem::mesh::Basis::add_source
void add_source(Basis *aSource, const real aWeight=1.0)
Definition cl_Mesh_Basis.cpp:318
belfem::mesh::Basis::number_of_sources
uint number_of_sources() const
Definition cl_Mesh_Basis.hpp:274
belfem::mesh::Basis::allocate_source_container
void allocate_source_container(uint aNumSources)
Definition cl_Mesh_Basis.cpp:295
belfem::mesh::Basis::weight
real weight(const uint aIndex) const
Definition cl_Mesh_Basis.hpp:414
belfem::mesh::Basis::source
Basis * source(const uint aIndex)
Definition cl_Mesh_Basis.hpp:388
belfem::mesh::Curve
Definition cl_Curve.hpp:27
belfem::mesh::Curve::nodes
Cell< Node * > & nodes()
Definition cl_Curve.hpp:155
belfem::mesh::Curve::id
id_t id() const
Definition cl_Curve.hpp:143
belfem::mesh::Edge
Special Edge class for NEDELEC-Type elements.
Definition cl_Edge.hpp:30
belfem::mesh::Edge::Edge
Edge()
Definition cl_Edge.cpp:20
belfem::mesh::Node
Definition cl_Node.hpp:30
belfem::mesh::Node::reset_duplicate_container
void reset_duplicate_container()
Definition cl_Node.hpp:277
belfem::mesh::Node::add_duplicate
void add_duplicate(Node *aNode)
Definition cl_Node.hpp:289
belfem::mesh::Node::get_coords
void get_coords(Vector< real > &aCoords)
Definition cl_Node.hpp:369
belfem::mesh::Node::allocate_duplicate_container
void allocate_duplicate_container(const uint aSize)
Definition cl_Node.hpp:259
belfem::mesh::Node::Node
Node(const id_t &aID, const real aX=0.0, const real aY=0.0, const real aZ=0.0)
Definition cl_Node.cpp:21
belfem::mesh::Node::original
Node * original()
returns the original of this node
Definition cl_Node.hpp:318
belfem::mesh::Node::number_of_duplicates
uint number_of_duplicates() const
returns the number of duplicates of this node
Definition cl_Node.hpp:226
belfem::mesh::Node::duplicate
Node * duplicate(const uint aIndex)
returns duplicates of this node
Definition cl_Node.hpp:245
belfem::mesh::Node::set_original
void set_original(Node *aNode)
Definition cl_Node.hpp:297
belfem::mesh::SideSet
Definition cl_SideSet.hpp:29
belfem::mesh::ThinShellFactory::update_node_facet_tables
static void update_node_facet_tables(Cell< Node * > &aNodes, Cell< Facet * > &aFacets)
rebuilds the facet containers of every node of aNodes, of its original and of all duplicates of that ...
Definition cl_ThinShellFactory.cpp:2728
belfem::mesh::ThinShellFactory::create
ThinShell * create(Protoshell *aProtoShell)
Definition cl_ThinShellFactory.cpp:70
belfem::mesh::ThinShellFactory::ThinShellFactory
ThinShellFactory(Mesh *aMesh, Cell< Node * > &aMasterNodes, Cell< Node * > &aSlaveNodes, Map< string, Material * > *aMaterialMap=nullptr, const bool aCreateGhostFacets=false)
Definition cl_ThinShellFactory.cpp:31
belfem::mesh::ThinShellFactory::flag_periodic_nodes
void flag_periodic_nodes()
Definition cl_ThinShellFactory.cpp:2818
belfem::mesh::ThinShellFactory::unflag_periodic_nodes
void unflag_periodic_nodes()
Definition cl_ThinShellFactory.cpp:2836
belfem::mesh::ThinShell
the thin shell class is a data container needed to link element masters and slaves to thin shell bloc...
Definition cl_ThinShell.hpp:31
belfem::mesh::Vertex::number_of_nodes
uint number_of_nodes() const override
Definition cl_Vertex.hpp:298
belfem::mesh::Vertex::allocate_node_container
void allocate_node_container(const uint aCounter=0)
Definition cl_Vertex.cpp:65
belfem::mesh::Vertex::node
Node * node(const uint aIndex) override
Definition cl_Vertex.hpp:359
belfem::mesh::Vertex::insert_node
void insert_node(Node *aNode, const uint aIndex)
Definition cl_Vertex.cpp:97
belfem::mesh
Definition cl_EF_EdgeFunction.hpp:24
belfem
USER GUIDES:
Definition cl_Capacitor.cpp:16
belfem::uint
unsigned int uint
Definition typedefs.hpp:30
belfem::id_t
unsigned int id_t
Definition typedefs.hpp:41
belfem::proc_t
int proc_t
Definition commtypes.hpp:29
belfem::ElementType
ElementType
Element types.
Definition Mesh_Enums.hpp:27
belfem::key_t
long long unsigned int key_t
Definition typedefs.hpp:43
belfem::index_t
uint32_t index_t
Definition typedefs.hpp:52
belfem::real
double real
Definition typedefs.hpp:36