BELFEM 0.9.0
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 — see todo/side_edge_fusing_cut_aware_plan.md, O1.
348 // Physics position ( C. Messe / Prof. Sirous, 2026-08-13 ):
349 // fusing is the mathematically cleaner continuity statement, yet
350 // measured runs converge slower for no better result — the fuse
351 // appears to overconstrain the rim, like enforcing a B·n = 0
352 // that the formulation already fulfills at the boundary. Both
353 // flags therefore stay false
354 bool mFuseEdges = false ;
355 bool mFuseEdgesWhenHavingSideConnectors = false ;
356//------------------------------------------------------------------------------
357 public :
358//------------------------------------------------------------------------------
359
375 ThinShellFactory(
376 Mesh * aMesh,
377 Cell< Node * > & aMasterNodes,
378 Cell< Node * > & aSlaveNodes,
379 Map< string, Material * > * aMaterialMap = nullptr,
380 const bool aCreateGhostFacets = false );
381
382 ~ThinShellFactory();
383
384 ThinShell *
385 create( Protoshell * aProtoShell );
386
387 void
388 flag_periodic_nodes();
389
390 void
391 unflag_periodic_nodes();
392
393//------------------------------------------------------------------------------
394 private :
395//------------------------------------------------------------------------------
396
397 void
398 create_side_connectors(
399 const uint aOrder,
400 Protoshell * aProtoShell,
401 const Cell< id_t > & aBlockIDs,
402 Cell< Layer * > & aLayers,
403 Matrix< real > & aNodeNormals,
404 Cell< Edge* > & aEdges,
405 Cell< Facet * > & aFacets,
406 ThinShell * aThinShell );
407
408//------------------------------------------------------------------------------
409
410 void
411 reset_node_indices();
412
413//------------------------------------------------------------------------------
414
415 void
416 write_normals_to_mesh( Cell< Node * > & aNodes, const Matrix< real > & aNodeNormals );
417
418//------------------------------------------------------------------------------
419
420 void
421 collect_sidesets( const Vector< id_t > & aSideSetIDs, Cell< SideSet * > & aSideSets );
422
423//------------------------------------------------------------------------------
424
425 ElementType
426 collect_facets( Cell< SideSet * > & aSideSets, Cell< Facet * > & aFacets );
427
428//------------------------------------------------------------------------------
429
430 void
431 collect_nodes( Cell< Facet * > & aFacets, Cell< Node * > & aNodes );
432
433//------------------------------------------------------------------------------
434// Begin new Side connector functions
435//------------------------------------------------------------------------------
436
437 void
438 create_edge_map(
439 const key_t aNumNodes,
440 Cell< Edge * > & aEdges,
441 Map< key_t, index_t > & aEdgeMap );
442
443 void
444 create_edge_to_face_map(
445 Cell< Edge * > & aEdges,
446 Cell< Facet * > & aFacets,
447 const Cell< index_t > & aIndices,
448 Map< index_t, std::pair< index_t, int8_t > > & aMap );
449
450 void
451 compute_side_edge_indices(
452 Curve * aCurve,
453 const Map< key_t, index_t > & aEdgeMap,
454 const key_t aNumNodes ,
455 const uint aEdgeOrder,
456 Cell< index_t > & aEdgeIndices );
457
473 void
474 compute_side_authority(
475 Curve * aCurve,
476 Cell< Facet * > & aFacets,
477 Cell< Edge * > & aEdges,
478 const Cell< index_t > & aEdgeIndices,
479 Cell< Node * > & aEdgeSources,
480 Cell< Node * > & aNodeSources );
481
482 void
483 connect_side_edges(
484 Layer * aLayer,
485 Cell< Edge * > & aEdges,
486 const Cell< index_t > & aEdgeIndices,
487 const Cell< Node * > & aEdgeSources );
488
489 void
490 connect_side_edges(
491 SideLayer * aSideLayer,
492 Cell< Edge * > & aEdges,
493 const Cell< index_t > & aEdgeIndices );
494
495 void
496 connect_side_nodes(
497 Cell< Node * > & aSourceNodes,
498 const Cell< Node * > & aAuthorityNodes,
499 Cell< Node * > & aTargetNodes );
500
501//------------------------------------------------------------------------------
502// End new Side connector functions
503//------------------------------------------------------------------------------
504
505 void
506 process_nodes_line2(
507 const Cell< Facet * > & aFacets,
508 const Cell< Node * > & aNodes,
509 Matrix< real > & aNodeNormals );
510
511//------------------------------------------------------------------------------
512
513 void
514 process_nodes_line3(
515 const Cell< Facet * > & aFacets,
516 const Cell< Node * > & aNodes,
517 Matrix< real > & aNodeNormals );
518
519//------------------------------------------------------------------------------
520
521 void
522 process_nodes_tri3(
523 const Cell< Facet * > & aFacets,
524 const Cell< Node * > & aNodes,
525 Matrix< real > & aNodeNormals );
526
527//------------------------------------------------------------------------------
528
529 void
530 process_nodes_tri6(
531 const Cell< Facet * > & aFacets,
532 const Cell< Node * > & aNodes,
533 Matrix< real > & aNodeNormals );
534
535//------------------------------------------------------------------------------
536
537 void
538 compute_distances(
539 const uint aOrder,
540 const Vector< real > & aThicknesses,
541 Vector< real > & aDistances );
542
543//------------------------------------------------------------------------------
544
545 void
546 create_nodes_on_layers(
547 Cell< Node * > & aNodes,
548 const Matrix< real > & aNodeNormals,
549 const Vector< real > & aDistances,
550 Cell< Layer * > & aLayers );
551
552//------------------------------------------------------------------------------
553
554 void
555 create_edges_on_layers(
556 const Cell< Edge * > & aEdges,
557 id_t & aEdgeID,
558 Cell< Layer * > & aLayers );
559
560//------------------------------------------------------------------------------
561
562 void
563 create_faces_on_layers(
564 const Cell< Facet * > & aFacets,
565 id_t & aFaceID,
566 Cell< Layer * > & aLayers );
567
568//------------------------------------------------------------------------------
569
570 void
571 create_temporary_edges(
572 Cell< Node * > & aNodes,
573 Cell< Facet * > & aFacets,
574 Cell< Edge* > & aEdges );
575
576//------------------------------------------------------------------------------
577
578 void
579 create_elements_on_blocks_line2(
580 id_t & aBlockID,
581 id_t & aElementID,
582 Cell< Facet * > & aFacets,
583 Cell< Layer * > & aLayers,
584 Cell< Block * > & aBlocks ) ;
585
586//------------------------------------------------------------------------------
587
588 void
589 create_elements_on_blocks_line3(
590 id_t & aBlockID,
591 id_t & aElementID,
592 Cell< Facet * > & aFacets,
593 Cell< Layer * > & aLayers,
594 Cell< Block * > & aBlocks ) ;
595
596//------------------------------------------------------------------------------
597
598 void
599 create_elements_on_blocks_tri3(
600 id_t & aBlockID,
601 id_t & aElementID,
602 Cell< Facet * > & aFacets,
603 Cell< Layer * > & aLayers,
604 Cell< Block * > & aBlocks ) ;
605
606//------------------------------------------------------------------------------
607
608 void
609 create_elements_on_blocks_tri6(
610 id_t & aBlockID,
611 id_t & aElementID,
612 Cell< Facet * > & aFacets,
613 Cell< Layer * > & aLayers,
614 Cell< Block * > & aBlocks ) ;
615
616//------------------------------------------------------------------------------
617
618 void
619 link_elements_with_edges(
620 Cell< Facet * > & aFacets,
621 Cell< Layer * > & aLayers,
622 Cell< Block * > & aBlocks );
623
624//------------------------------------------------------------------------------
625
626 void
627 link_elements_with_faces(
628 Cell< Layer * > & aLayers,
629 Cell< Block * > & aBlocks );
630
631//------------------------------------------------------------------------------
632
633 void
634 create_buffers(
635 const Cell< string > & aMaterials,
636 Cell< Layer * > & aLayers,
637 Cell< Block * > & aBlocks );
638
639//------------------------------------------------------------------------------
640
641 // ghost facets for normal directions
642 void
643 create_ghost_facets(
644 const uint aOrder,
645 Cell< Facet * > & aFacets,
646 Cell< Layer * > & aLayers,
647 Cell< Block * > & aBlocks );
648
649//------------------------------------------------------------------------------
650
651 id_t
652 max_node_id();
653
654//------------------------------------------------------------------------------
655
656 id_t
657 max_element_id();
658
659//------------------------------------------------------------------------------
660
661 id_t
662 max_block_id();
663
664//------------------------------------------------------------------------------
665
666 real
667 compute_binomial_vectors(
668 Protoshell * aProtoShell,
669 Curve * aCurve,
670 const Matrix< real > & aNormals,
671 Matrix< real > & aBinomials );
672
673 void
674 update_node_edge_tables( Cell< Node * > & aNodes, Cell< Edge * > & aEdges );
675
676 void
677 update_node_facet_tables( Cell< Node * > & aNodes, Cell< Facet * > & aFacets );
678
679 void
680 flag_layer_nodes( Cell< Node * > & aNodes, Cell< Layer * > & aLayers );
681
682 SideSet *
683 create_periodic_sideset(
684 Cell< Block * > & aBlocks,
685 const bool aMaster );
686 };
687 }
688}
689#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
Cell is a wrapper around the standard vector.
Definition cl_Cell.hpp:42
belfem::Cell::set_size
void set_size(const size_t aSize)
Definition cl_Cell.hpp:189
belfem::Cell::first
T & first()
Definition cl_Cell.hpp:318
belfem::Cell::size
size_t size() const
return the size of the Cell
Definition cl_Cell.hpp:181
belfem::Cell::push
void push(const T &aValue)
push an entry to the end of the cell (copy version)
Definition cl_Cell.hpp:262
belfem::Cell::reserve
void reserve(const size_t aSize)
reserve memory
Definition cl_Cell.hpp:251
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:347
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:232
belfem::mesh::Basis::add_source
void add_source(Basis *aSource, const real aWeight=1.0)
Definition cl_Mesh_Basis.cpp:331
belfem::mesh::Basis::number_of_sources
uint number_of_sources() const
Definition cl_Mesh_Basis.hpp:240
belfem::mesh::Basis::allocate_source_container
void allocate_source_container(uint aNumSources)
Definition cl_Mesh_Basis.cpp:308
belfem::mesh::Basis::weight
real weight(const uint aIndex) const
Definition cl_Mesh_Basis.hpp:350
belfem::mesh::Basis::source
Basis * source(const uint aIndex)
Definition cl_Mesh_Basis.hpp:324
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::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:2941
belfem::mesh::ThinShellFactory::unflag_periodic_nodes
void unflag_periodic_nodes()
Definition cl_ThinShellFactory.cpp:2959
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:296
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:349
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:17
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