OOFEM 3.0
Loading...
Searching...
No Matches
refinedelement.C
Go to the documentation of this file.
1/*
2 *
3 * ##### ##### ###### ###### ### ###
4 * ## ## ## ## ## ## ## ### ##
5 * ## ## ## ## #### #### ## # ##
6 * ## ## ## ## ## ## ## ##
7 * ## ## ## ## ## ## ## ##
8 * ##### ##### ## ###### ## ##
9 *
10 *
11 * OOFEM : Object Oriented Finite Element Code
12 *
13 * Copyright (C) 1993 - 2025 Borek Patzak
14 *
15 *
16 *
17 * Czech Technical University, Faculty of Civil Engineering,
18 * Department of Structural Mechanics, 166 29 Prague, Czech Republic
19 *
20 * This library is free software; you can redistribute it and/or
21 * modify it under the terms of the GNU Lesser General Public
22 * License as published by the Free Software Foundation; either
23 * version 2.1 of the License, or (at your option) any later version.
24 *
25 * This program is distributed in the hope that it will be useful,
26 * but WITHOUT ANY WARRANTY; without even the implied warranty of
27 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
28 * Lesser General Public License for more details.
29 *
30 * You should have received a copy of the GNU Lesser General Public
31 * License along with this library; if not, write to the Free Software
32 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
33 */
34
35#include "refinedelement.h"
36#include "element.h"
37#include "node.h"
38#include "dof.h"
39#include "mathfem.h"
40
41#include <cstdarg>
42#include <cstdlib> // For abort
44
45namespace oofem {
46RefinedElement :: RefinedElement(Domain *d, int elem, int level) : fineNodeList(0), boundaryFlag()
47 // Constructor
48{
49 Element *element;
50 int nodes, sides, dim, len;
51
52 this->elementId = elem;
53
54 element = d->giveElement(elem);
55 nodes = element->giveNumberOfDofManagers();
56 sides = element->giveNumberOfBoundarySides();
57 dim = element->giveSpatialDimension();
58
59 len = 1;
60 while ( dim-- ) {
61 len *= ( level + 2 );
62 }
63
64 fineNodeList.resize(nodes);
65 for ( int inode = 0; inode < nodes; inode++ ) {
66 fineNodeList[inode].resize(len);
67 }
68
69 this->boundaryFlag.resize(sides);
70 // this -> boundaryFlag.zero();
71}
72
73
74
75RefinedElement :: ~RefinedElement()
76// Destructor.
77{ }
78
79
80IntArray *
81RefinedElement :: giveFineNodeArray(int node)
82{
83 return & this->fineNodeList[node-1];
84}
85
86
87void
88RefinedElement :: giveBoundaryFlagArray(int inode, Element *element, IntArray &answer)
89{
90 /* note: number of connected edges must correspond to edge ordering in face_ed_nd and quad_ed_nd (see refinedmesh.C);
91 * ordering of edges at a particular node is given by fine node ordering {m = 0, n = 0};
92 * 1-based indexing is used contrary to 0-based indexing in refinedmesh.C */
93
94 static int face_con_ed [ 3 ] [ 2 ] = { { 3, 1 }, { 1, 2 }, { 2, 3 } };
95 static int quad_con_ed [ 4 ] [ 2 ] = { { 4, 1 }, { 1, 2 }, { 2, 3 }, { 3, 4 } };
96
97 /* note: number of connected faces must correspond to face ordering in tetra_fc_nd and hexa_fc_nd (see refinedmesh.C);
98 * ordering of faces at a particular node is given by fine node ordering {m = 0, n = 0, k = 0};
99 * 1-based indexing is used contrary to 0-based indexing in refinedmesh.C */
100
101 static int tetra_con_fc [ 4 ] [ 3 ] = { { 4, 2, 1 }, { 2, 3, 1 }, { 3, 4, 1 }, { 3, 2, 4 } };
102 static int hexa_con_fc [ 8 ] [ 3 ] = { { 5, 2, 1 }, { 2, 3, 1 }, { 3, 4, 1 }, { 4, 5, 1 }, { 2, 5, 6 }, { 3, 2, 6 }, { 4, 3, 6 }, { 5, 4, 6 } };
103
104 int i, dim, *con = NULL;
105
106#ifdef DEBUG
107 if ( inode > element->giveNumberOfNodes() ) {
108 abort();
109 }
110
111#endif
112
113 answer.resize( dim = element->giveSpatialDimension() );
114
115 switch ( element->giveGeometryType() ) {
116 case EGT_line_1:
117 case EGT_line_2:
118 answer.at(1) = boundaryFlag.at(inode);
119 return;
120
121 break;
122 case EGT_triangle_1:
123 case EGT_triangle_2:
124 con = face_con_ed [ inode - 1 ];
125 break;
126 case EGT_quad_1:
127 // case EGT_quad_2:
128 con = quad_con_ed [ inode - 1 ];
129 break;
130 case EGT_tetra_1:
131 // case EGT_tetra_2:
132 con = tetra_con_fc [ inode - 1 ];
133 break;
134 case EGT_hexa_1:
135 // case EGT_hexa_2:
136 con = hexa_con_fc [ inode - 1 ];
137 break;
138 default:
139 OOFEM_ERROR("Unsupported geometry type");
140 }
141
142 for ( i = 0; i < dim; i++ ) {
143 answer.at(i + 1) = boundaryFlag.at(con [ i ]);
144 }
145}
146
147
148
149bool
150RefinedElement :: giveBcDofArray1D(int inode, Element *element, IntArray &sideBcDofId, int &sideNumBc, TimeStep *tStep)
151{
152 static int edge_con_nd [ 2 ] = {
153 2, 1
154 };
155
156 int nodeNumBc;
157 Node *node;
158 IntArray nodeBcDofId;
159
160 node = element->giveNode(inode);
161
162 nodeNumBc = 0;
163 nodeBcDofId.resize( node->giveNumberOfDofs() );
164 for ( Dof *dof: *node ) {
165 if ( dof->hasBc(tStep) != 0 ) {
166 nodeBcDofId.at(++nodeNumBc) = dof->giveDofID();
167 }
168 }
169
170 if ( nodeNumBc == 0 ) {
171 return false;
172 }
173
174 sideNumBc = this->giveCompatibleBcDofArray(element->giveNode(edge_con_nd [ inode - 1 ]), node, nodeBcDofId, nodeNumBc,
175 sideBcDofId, VM_Total, tStep);
176 return true;
177}
178
179
180bool
181RefinedElement :: giveBcDofArray2D(int inode, Element *element, std::vector< IntArray > &sideBcDofIdList, IntArray &sideNumBc, TimeStep *tStep)
182{
183 /* note: ordering of connected nodes is given by fine node ordering {m = 0, n = 0};
184 * 1-based indexing is used contrary to 0-based indexing in refinedmesh.C */
185
186 static int face_con_nd [ 3 ] [ 2 ] = { { 3, 2 }, { 1, 3 }, { 2, 1 } };
187 static int quad_con_nd [ 4 ] [ 2 ] = { { 4, 2 }, { 1, 3 }, { 2, 4 }, { 3, 1 } };
188
189 int *con = NULL, iside, nodeNumBc;
190 Node *node;
191 IntArray nodeBcDofId;
192
193 node = element->giveNode(inode);
194
195 nodeNumBc = 0;
196 nodeBcDofId.resize( node->giveNumberOfDofs() );
197 for ( Dof *dof: *node ) {
198 if ( dof->hasBc(tStep) != 0 ) {
199 nodeBcDofId.at(++nodeNumBc) = dof->giveDofID();
200 }
201 }
202
203 if ( nodeNumBc == 0 ) {
204 return false;
205 }
206
207 switch ( element->giveGeometryType() ) {
208 case EGT_triangle_1:
209 case EGT_triangle_2:
210 con = face_con_nd [ inode - 1 ];
211 break;
212 case EGT_quad_1:
213 // case EGT_quad_2:
214 con = quad_con_nd [ inode - 1 ];
215 break;
216 default:
217 OOFEM_ERROR("Unsupported geometry type");
218 }
219
220 for ( iside = 0; iside < 2; iside++ ) {
221 sideNumBc.at(iside + 1) = this->giveCompatibleBcDofArray(element->giveNode(con [ iside ]),
222 node, nodeBcDofId, nodeNumBc,
223 sideBcDofIdList[iside],
224 VM_Total, tStep);
225 }
226
227 return true;
228}
229
230
231bool
232RefinedElement :: giveBcDofArray3D(int inode, Element *element, std::vector< IntArray > &sideBcDofIdList, IntArray &sideNumBc,
233 std::vector< IntArray > &faceBcDofIdList, IntArray &faceNumBc, TimeStep *tStep)
234{
235 /* note: ordering of connected nodes is given by fine node ordering {n = k = 0, m = k = 0, m = n = 0};
236 * 1-based indexing is used contrary to 0-based indexing in refinedmesh.C */
237
238 static int tetra_con_nd [ 4 ] [ 3 ] = { { 2, 3, 4 }, { 3, 1, 4 }, { 1, 2, 4 }, { 1, 3, 2 } };
239 static int hexa_con_nd [ 8 ] [ 3 ] = { { 2, 4, 5 }, { 3, 1, 6 }, { 4, 2, 7 }, { 1, 3, 8 }, { 8, 6, 1 }, { 5, 7, 2 }, { 6, 8, 3 }, { 7, 5, 4 } };
240
241 /* note: number of connected faces must correspond to face ordering in tetra_fc_nd and hexa_fc_nd;
242 * ordering of faces at a particular node is given by fine node ordering {m = 0, n = 0, k = 0};
243 * 1-based indexing is used contrary to 0-based indexing in refinedmesh.C */
244
245 static int tetra_con_fc [ 4 ] [ 3 ] = { { 4, 2, 1 }, { 2, 3, 1 }, { 3, 4, 1 }, { 3, 2, 4 } };
246 static int hexa_con_fc [ 8 ] [ 3 ] = { { 5, 2, 1 }, { 2, 3, 1 }, { 3, 4, 1 }, { 4, 5, 1 }, { 2, 5, 6 }, { 3, 2, 6 }, { 4, 3, 6 }, { 5, 4, 6 } };
247
248 /* note: ordering of nodes on faces is irrelevant;
249 * 1-based indexing is used contrary to 0-based indexing in refinedmesh.C */
250
251 static int tetra_fc_nd [ 4 ] [ 3 ] = { { 1, 2, 3 }, { 1, 2, 4 }, { 2, 3, 4 }, { 3, 1, 4 } };
252 static int hexa_fc_nd [ 6 ] [ 4 ] = { { 1, 2, 3, 4 }, { 1, 2, 6, 5 }, { 2, 3, 7, 6 }, { 3, 4, 8, 7 }, { 4, 1, 5, 8 }, { 8, 7, 6, 5 } };
253
254 int *con = NULL, iside, iface, jnode, nodeNumBc, fcNumBc;
255 Node *node;
256 IntArray nodeBcDofId, faceBcDofId;
257 bool hasBc = false;
258
259 node = element->giveNode(inode);
260
261 nodeNumBc = 0;
262 nodeBcDofId.resize( node->giveNumberOfDofs() );
263 for ( Dof *dof: *node ) {
264 if ( dof->hasBc(tStep) != 0 ) {
265 nodeBcDofId.at(++nodeNumBc) = dof->giveDofID();
266 }
267 }
268
269 if ( nodeNumBc == 0 ) {
270 return false;
271 }
272
273 switch ( element->giveGeometryType() ) {
274 case EGT_tetra_1:
275 // case EGT_tetra_2:
276 con = tetra_con_nd [ inode - 1 ];
277 break;
278 case EGT_hexa_1:
279 // case EGT_hexa_2:
280 con = hexa_con_nd [ inode - 1 ];
281 break;
282 default:
283 OOFEM_ERROR("Unsupported geometry type");
284 }
285
286 for ( iside = 0; iside < 3; iside++ ) {
287 sideNumBc.at(iside + 1) = this->giveCompatibleBcDofArray(element->giveNode(con [ iside ]),
288 node, nodeBcDofId, nodeNumBc,
289 sideBcDofIdList[iside],
290 VM_Total, tStep);
291 if ( sideNumBc.at(iside + 1) != 0 ) {
292 hasBc = true;
293 }
294 }
295
296 if ( hasBc == true ) {
297 faceBcDofId.resize(nodeNumBc);
298
299 switch ( element->giveGeometryType() ) {
300 case EGT_tetra_1:
301 // case EGT_tetra_2:
302
303 for ( int i = 0; i < 3; i++ ) { // there are always 3 faces at a node
304 iface = tetra_con_fc [ inode - 1 ] [ i ];
305 fcNumBc = nodeNumBc;
306 for ( int idof = 1; idof <= fcNumBc; idof++ ) {
307 faceBcDofId.at(idof) = nodeBcDofId.at(idof);
308 }
309
310 for ( int j = 0; j < 3; j++ ) { // there 3 nodes per face
311 jnode = tetra_fc_nd [ iface - 1 ] [ j ];
312 if ( jnode == inode ) {
313 continue;
314 }
315
316 fcNumBc = this->giveCompatibleBcDofArray(element->giveNode(jnode), node, faceBcDofId, fcNumBc,
317 faceBcDofIdList[i],
318 VM_Total, tStep);
319 for ( int idof = 1; idof <= fcNumBc; idof++ ) {
320 faceBcDofId.at(idof) = faceBcDofIdList[i].at(idof);
321 }
322 }
323
324 faceNumBc.at(i + 1) = fcNumBc;
325 }
326
327 break;
328 case EGT_hexa_1:
329 // case EGT_hexa_2:
330
331 for ( int i = 0; i < 3; i++ ) { // there are always 3 faces at a node
332 iface = hexa_con_fc [ inode - 1 ] [ i ];
333 fcNumBc = nodeNumBc;
334 for ( int idof = 1; idof <= fcNumBc; idof++ ) {
335 faceBcDofId.at(idof) = nodeBcDofId.at(idof);
336 }
337
338 for ( int j = 0; j < 4; j++ ) { // there 4 nodes per face
339 jnode = hexa_fc_nd [ iface - 1 ] [ j ];
340 if ( jnode == inode ) {
341 continue;
342 }
343
344 fcNumBc = this->giveCompatibleBcDofArray(element->giveNode(jnode), node, faceBcDofId, fcNumBc,
345 faceBcDofIdList[i],
346 VM_Total, tStep);
347 for ( int idof = 1; idof <= fcNumBc; idof++ ) {
348 faceBcDofId.at(idof) = faceBcDofIdList[i].at(idof);
349 }
350 }
351
352 faceNumBc.at(i + 1) = fcNumBc;
353 }
354
355 break;
356 default:
357 OOFEM_ERROR("Unsupported geometry type");
358 }
359 }
360
361 return true;
362}
363
364
365
366bool
367RefinedElement :: giveBoundaryLoadArray1D(int inode, Element *element, IntArray &boundaryLoadArray)
368{
369 int iload, loads, bloads;
370 IntArray *loadArray;
371
372 if ( ( loads = ( loadArray = element->giveBoundaryLoadArray() )->giveSize() ) == 0 ) {
373 return false;
374 }
375
376#ifdef DEBUG
377 if ( loads / 2 * 2 != loads ) {
378 abort();
379 }
380
381#endif
382
383 boundaryLoadArray.resize(loads);
384 bloads = 0;
385
386 for ( iload = 1; iload <= loads; iload += 2 ) {
387 if ( loadArray->at(iload + 1) != 1 ) {
388 continue;
389 }
390
391 bloads += 2;
392 boundaryLoadArray.at(bloads - 1) = loadArray->at(iload);
393 boundaryLoadArray.at(bloads) = 1;
394 }
395
396 boundaryLoadArray.resize(bloads);
397
398 return true;
399}
400
401
402
403bool
404RefinedElement :: giveBoundaryLoadArray2D(int inode, Element *element, std::vector< IntArray > &boundaryLoadList)
405{
406 /* note: number of connected edges must correspond to OOFEM element side numbering;
407 * ordering of edges at a particular node is given by fine node ordering {m = 0, n = 0};
408 * 1-based indexing is used */
409
410 static int face_con_ed [ 3 ] [ 2 ] = { { 3, 1 }, { 1, 2 }, { 2, 3 } };
411 static int quad_con_ed [ 4 ] [ 2 ] = { { 4, 1 }, { 1, 2 }, { 2, 3 }, { 3, 4 } };
412
413 static int fine_quad_side [ 2 ] = {
414 4, 1
415 }; // {m = 0, n = 0}
416
417 int iside, iload, loads, bloads, side, *con = NULL;
418 IntArray *loadArray;
419
420 if ( ( loads = ( loadArray = element->giveBoundaryLoadArray() )->giveSize() ) == 0 ) {
421 return false;
422 }
423
424#ifdef DEBUG
425 if ( loads / 2 * 2 != loads ) {
426 abort();
427 }
428
429#endif
430
431 switch ( element->giveGeometryType() ) {
432 case EGT_triangle_1:
433 case EGT_triangle_2:
434 con = face_con_ed [ inode - 1 ];
435 break;
436 case EGT_quad_1:
437 // case EGT_quad_2:
438 con = quad_con_ed [ inode - 1 ];
439 break;
440 default:
441 OOFEM_ERROR("Unsupported geometry type");
442 }
443
444 for ( iside = 0; iside < 2; iside++ ) {
445 IntArray &boundaryLoadArray = boundaryLoadList[iside];
446 boundaryLoadArray.resize(loads);
447 bloads = 0;
448
449 side = con [ iside ];
450 for ( iload = 1; iload <= loads; iload += 2 ) {
451 if ( loadArray->at(iload + 1) != side ) {
452 continue;
453 }
454
455 bloads += 2;
456 boundaryLoadArray.at(bloads - 1) = loadArray->at(iload);
457 boundaryLoadArray.at(bloads) = fine_quad_side [ iside ];
458 }
459
460 boundaryLoadArray.resize(bloads);
461 }
462
463 return true;
464}
465
466
467
468bool
469RefinedElement :: giveBoundaryLoadArray3D(int inode, Element *element, std::vector< IntArray > &boundaryLoadList)
470{
471 /* note: number of connected faces must correspond to OOFEM element side numbering;
472 * ordering of faces at a particular node is given by fine node ordering {m = 0, n = 0, k = 0};
473 * 1-based indexing is used */
474
475 static int tetra_con_fc [ 4 ] [ 3 ] = { { 4, 2, 1 }, { 2, 3, 1 }, { 3, 4, 1 }, { 3, 2, 4 } };
476 static int hexa_con_fc [ 8 ] [ 3 ] = { { 6, 3, 1 }, { 3, 4, 1 }, { 4, 5, 1 }, { 5, 6, 1 }, { 3, 6, 2 }, { 4, 3, 2 }, { 5, 4, 2 }, { 6, 5, 2 } };
477
478 static int fine_hexa_side [ 3 ] = {
479 6, 3, 1
480 }; // {m = 0, n = 0, k = 0}
481
482 int iside, iload, loads, bloads, side, *con = NULL;
483 IntArray *loadArray;
484
485 if ( ( loads = ( loadArray = element->giveBoundaryLoadArray() )->giveSize() ) == 0 ) {
486 return false;
487 }
488
489#ifdef DEBUG
490 if ( loads / 2 * 2 != loads ) {
491 abort();
492 }
493
494#endif
495
496 switch ( element->giveGeometryType() ) {
497 case EGT_tetra_1:
498 // case EGT_tetra_2:
499 con = tetra_con_fc [ inode - 1 ];
500 break;
501 case EGT_hexa_1:
502 // case EGT_hexa_2:
503 con = hexa_con_fc [ inode - 1 ];
504 break;
505 default:
506 OOFEM_ERROR("Unsupported geometry type");
507 }
508
509 for ( iside = 0; iside < 3; iside++ ) {
510 IntArray &boundaryLoadArray = boundaryLoadList[iside];
511 boundaryLoadArray.resize(loads);
512 bloads = 0;
513
514 side = con [ iside ];
515 for ( iload = 1; iload <= loads; iload += 2 ) {
516 if ( loadArray->at(iload + 1) != side ) {
517 continue;
518 }
519
520 bloads += 2;
521 boundaryLoadArray.at(bloads - 1) = loadArray->at(iload);
522 boundaryLoadArray.at(bloads) = fine_hexa_side [ iside ];
523 }
524
525 boundaryLoadArray.resize(bloads);
526 }
527
528 return true;
529}
530
531int
532RefinedElement :: giveCompatibleBcDofArray(Node *master_node, Node *slave_node, IntArray &dofIDArray, int dofs,
533 IntArray &answer, ValueModeType mode, TimeStep *tStep)
534{
535 FloatMatrix *Lcs, *nodeLcs, trFromNodeLcsToLcs;
536 bool compatibleCS, newLcs, newNodeLcs;
537 double epsilon = 1.0e-9;
538 int compDofs = 0;
539 DofIDItem dofId;
540 double bcValue;
541 int bcId;
542
543 newLcs = newNodeLcs = false;
544 compatibleCS = true;
545
546 Lcs = master_node->giveLocalCoordinateTriplet();
547 nodeLcs = slave_node->giveLocalCoordinateTriplet();
548 if ( Lcs != NULL || nodeLcs != NULL ) {
549 // check the compatibility of CSs
550
551 if ( Lcs == NULL ) {
552 Lcs = new FloatMatrix(3, 3);
553 Lcs->zero();
554 Lcs->at(1, 1) = Lcs->at(2, 2) = Lcs->at(3, 3) = 1.0;
555 newLcs = true;
556 }
557
558 if ( nodeLcs == NULL ) {
559 nodeLcs = new FloatMatrix(3, 3);
560 nodeLcs->zero();
561 nodeLcs->at(1, 1) = nodeLcs->at(2, 2) = nodeLcs->at(3, 3) = 1.0;
562 newNodeLcs = true;
563 }
564
565 trFromNodeLcsToLcs.beProductTOf(* Lcs, * nodeLcs);
566
567 if ( newLcs == true ) {
568 delete Lcs;
569 }
570
571 if ( newNodeLcs == true ) {
572 delete nodeLcs;
573 }
574
575 for ( int i = 1; i <= 3; i++ ) {
576 if ( fabs(trFromNodeLcsToLcs.at(i, i) - 1.0) > epsilon ) {
577 compatibleCS = false;
578 break;
579 }
580 }
581 }
582
583 answer.resize(dofs);
584
585 if ( compatibleCS == true ) {
586 for ( int i = 1; i <= dofs; i++ ) {
587 Dof *nodeDof = slave_node->giveDofWithID( dofIDArray.at(i) );
588
589#ifdef DEBUG
590 if ( nodeDof->hasBc(tStep) == false ) {
591 OOFEM_ERROR("dof has no BC");
592 }
593
594#endif
595
596 dofId = nodeDof->giveDofID();
597 bcId = nodeDof->giveBcId();
598 bcValue = nodeDof->giveBcValue(mode, tStep);
599
600 for ( Dof *dof: *master_node ) {
601 if ( dof->hasBc(tStep) == false ) {
602 continue;
603 }
604
605 if ( dof->giveDofID() != dofId ) {
606 continue;
607 }
608
609 if ( dof->giveBcId() == bcId ) {
610 answer.at(++compDofs) = dofIDArray.at(i);
611 break;
612 }
613
614 if ( dof->giveBcValue(mode, tStep) == bcValue ) {
615 answer.at(++compDofs) = dofIDArray.at(i);
616 break;
617 }
618 }
619 }
620 }
621
622 /*
623 * else{
624 * if(orthogonal == true){
625 * }
626 * else{
627 * }
628 * }
629 */
630
631 answer.resize(compDofs);
632
633 return ( compDofs );
634}
635
636
637std :: string RefinedElement :: errorInfo(const char *func) const
638{
639 return std :: string("RefinedElement::") + func + ", number: " + std::to_string(this->elementId);
640}
641} // end namespace oofem
oofem::DofManager::giveNumberOfDofs
int giveNumberOfDofs() const
Definition dofmanager.C:287
oofem::DofManager::giveDofWithID
Dof * giveDofWithID(int dofID) const
Definition dofmanager.C:127
oofem::Dof::giveDofID
DofIDItem giveDofID() const
Definition dof.h:276
oofem::Dof::giveBcValue
virtual double giveBcValue(ValueModeType mode, TimeStep *tStep)
Definition dof.C:120
oofem::Dof::hasBc
virtual bool hasBc(TimeStep *tStep)=0
oofem::Dof::giveBcId
virtual int giveBcId()=0
oofem::Domain::giveElement
Element * giveElement(int n)
Definition domain.C:165
oofem::Element::giveNode
Node * giveNode(int i) const
Definition element.h:629
oofem::Element::giveNumberOfBoundarySides
virtual int giveNumberOfBoundarySides()
Returns number of boundaries (entities of element_dimension-1: points, edges, surfaces).
Definition element.C:1430
oofem::Element::giveSpatialDimension
virtual int giveSpatialDimension()
Definition element.C:1391
oofem::Element::giveNumberOfNodes
virtual int giveNumberOfNodes() const
Definition element.h:703
oofem::Element::giveBoundaryLoadArray
IntArray * giveBoundaryLoadArray()
Returns array containing load numbers of boundary loads acting on element.
Definition element.C:420
oofem::Element::giveNumberOfDofManagers
virtual int giveNumberOfDofManagers() const
Definition element.h:695
oofem::Element::giveGeometryType
virtual Element_Geometry_Type giveGeometryType() const =0
oofem::FloatMatrix::beProductTOf
void beProductTOf(const FloatMatrix &a, const FloatMatrix &b)
Definition floatmatrix.C:431
oofem::FloatMatrix::zero
void zero()
Zeroes all coefficient of receiver.
Definition floatmatrix.C:1064
oofem::FloatMatrix::at
double at(std::size_t i, std::size_t j) const
Definition floatmatrix.h:221
oofem::IntArray::resize
void resize(int n)
Definition intarray.C:73
oofem::IntArray::at
int & at(std::size_t i)
Definition intarray.h:104
oofem::Node::giveLocalCoordinateTriplet
FloatMatrix * giveLocalCoordinateTriplet()
Definition node.h:149
oofem::RefinedElement::giveCompatibleBcDofArray
int giveCompatibleBcDofArray(Node *master_node, Node *slave_node, IntArray &dofIDArray, int dofs, IntArray &answer, ValueModeType mode, TimeStep *tStep)
Definition refinedelement.C:532
oofem::RefinedElement::fineNodeList
std::vector< IntArray > fineNodeList
Definition refinedelement.h:53
OOFEM_ERROR
#define OOFEM_ERROR(...)
Definition error.h:79
This page is part of the OOFEM-3.0 documentation. Copyright Copyright (C) 1994-2025 Borek Patzak Bořek Patzák
Project e-mail: oofem@fsv.cvut.cz
Generated at for OOFEM by doxygen 1.15.0 written by Dimitri van Heesch, © 1997-2011