Debian Codegraph @

dune/uggrid/gm/elements.cc

raw
1 // SPDX-FileCopyrightText: Copyright © DUNE Project contributors, see file LICENSE.md in module root
2 // SPDX-License-Identifier: LGPL-2.1-or-later
3 // -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
4 // vi: set et ts=4 sw=2 sts=2:
5 /****************************************************************************/
6 /* */
7 /* File: elements.c */
8 /* */
9 /* Purpose: implements a general element concept */
10 /* */
11 /* Author: Peter Bastian, Stefan Lang */
12 /* Institut fuer Computeranwendungen III */
13 /* Universitaet Stuttgart */
14 /* Pfaffenwaldring 27 */
15 /* 70569 Stuttgart */
16 /* email: [email protected] */
17 /* */
18 /* History: 24.03.95 begin, ug version 3.0 */
19 /* 18.03.96 ug3.1 */
20 /* */
21 /* Remarks: */
22 /* */
23 /****************************************************************************/
24
25 #include <config.h>
26 #include <cassert>
27
28 #include <dune/uggrid/ugdevices.h>
29
30 #include "gm.h"
31 #include "ugm.h"
32
33 #ifdef ModelP
34 #include <dune/uggrid/parallel/dddif/parallel.h>
35 #endif
36
37 #include "elements.h"
38
39 USING_UG_NAMESPACE
40 USING_UGDIM_NAMESPACE
41
42 /****************************************************************************/
43 /* */
44 /* defines in the following order */
45 /* */
46 /* compile time constants defining static data size (i.e. arrays) */
47 /* other constants */
48 /* macros */
49 /* */
50 /****************************************************************************/
51
52 /****************************************************************************/
53 /* */
54 /* data structures used in this source file (exported data structures are */
55 /* in the corresponding include file!) */
56 /* */
57 /****************************************************************************/
58
59 /****************************************************************************/
60 /* */
61 /* definition of exported global variables */
62 /* */
63 /****************************************************************************/
64
65 GENERAL_ELEMENT * NS_DIM_PREFIX element_descriptors[TAGS];
66
67 /****************************************************************************/
68 /* */
69 /* definition of local variables */
70 /* */
71 /****************************************************************************/
72
73 #ifdef UG_DIM_2
74 static GENERAL_ELEMENT def_triangle = {
75 .tag = TRIANGLE,
76 .sides_of_elem = 3,
77 .corners_of_elem = 3,
78 .local_corner = {{0.0,0.0},{1.0,0.0},{0.0,1.0}},
79 .edges_of_elem = 3,
80 .edges_of_side = {1,1,1,-1},
81 .corners_of_side = {2,2,2,-1},
82 .edge_of_side = {{0},{1},{2},{-1}},
83 .corner_of_side = {{0,1},{1,2},{2,0},{-1,-1}},
84 .corner_of_edge = {{0,1},{1,2},{2,0},{-1,-1}},
85 .inner_size = offsetof(triangle,bnds),
86 .bnd_size = sizeof(triangle)
87 } ;
88
89 static GENERAL_ELEMENT def_quadrilateral = {
90 .tag = QUADRILATERAL,
91 .sides_of_elem = 4,
92 .corners_of_elem = 4,
93 .local_corner = {{0.0,0.0},{1.0,0.0},{1.0,1.0},{0.0,1.0}},
94 .edges_of_elem = 4,
95 .edges_of_side = {1,1,1,1},
96 .corners_of_side = {2,2,2,2},
97 .edge_of_side = {{0},{1},{2},{3}},
98 .corner_of_side = {{0,1},{1,2},{2,3},{3,0}},
99 .corner_of_edge = {{0,1},{1,2},{2,3},{3,0}},
100 .inner_size = offsetof(quadrilateral,bnds),
101 .bnd_size = sizeof(quadrilateral)
102 } ;
103 #endif
104
105 #ifdef UG_DIM_3
106 static GENERAL_ELEMENT def_tetrahedron = {
107 .tag = TETRAHEDRON,
108 .sides_of_elem = 4,
109 .corners_of_elem = 4,
110 .local_corner = {{0.0,0.0,0.0},{1.0,0.0,0.0},{0.0,1.0,0.0},{0.0,0.0,1.0}},
111 .edges_of_elem = 6,
112 .edges_of_side = {3,3,3,3,-1,-1},
113 .corners_of_side = {3,3,3,3,-1,-1},
114 .edge_of_side = {{2,1,0,-1},{1,5,4,-1},{3,5,2,-1},{0,4,3,-1}},
115 .corner_of_side = {{0,2,1,-1},{1,2,3,-1},{0,3,2,-1},{0,1,3,-1}},
116 .corner_of_edge = {{0,1},{1,2},{0,2},{0,3},{1,3},{2,3}},
117 .inner_size = offsetof(tetrahedron,bnds),
118 .bnd_size = sizeof(tetrahedron)
119 } ;
120
121 static GENERAL_ELEMENT def_pyramid = {
122 .tag = PYRAMID,
123 .sides_of_elem = 5,
124 .corners_of_elem = 5,
125 .local_corner = {{0.0,0.0,0.0},{1.0,0.0,0.0},{1.0,1.0,0.0},{0.0,1.0,0.0},{0.0,0.0,1.0}},
126 .edges_of_elem = 8,
127 .edges_of_side = {4,3,3,3,3,-1},
128 .corners_of_side = {4,3,3,3,3,-1},
129 .edge_of_side = {{3,2,1,0},{0,5,4,-1},{1,6,5,-1},{2,7,6,-1},{3,4,7,-1}},
130 .corner_of_side = {{0,3,2,1},{0,1,4,-1},{1,2,4,-1},{2,3,4,-1},{3,0,4,-1}},
131 .corner_of_edge = {{0,1},{1,2},{2,3},{3,0},{0,4},{1,4},{2,4},{3,4}},
132 .inner_size = offsetof(pyramid,bnds),
133 .bnd_size = sizeof(pyramid)
134 } ;
135
136 static GENERAL_ELEMENT def_prism = {
137 .tag = PRISM,
138 .sides_of_elem = 5,
139 .corners_of_elem = 6,
140 .local_corner = {{0.0,0.0,0.0},{1.0,0.0,0.0},{0.0,1.0,0.0},
141 {0.0,0.0,1.0},{1.0,0.0,1.0},{0.0,1.0,1.0}},
142 .edges_of_elem = 9,
143 .edges_of_side = {3,4,4,4,3,-1},
144 .corners_of_side = {3,4,4,4,3,-1},
145 .edge_of_side = {{2,1,0,-1},{0,4,6,3},{1,5,7,4},{2,3,8,5},{6,7,8,-1}},
146 .corner_of_side = {{0,2,1,-1},{0,1,4,3},{1,2,5,4},{2,0,3,5},{3,4,5,-1}},
147 .corner_of_edge = {{0,1},{1,2},{2,0},{0,3},{1,4},{2,5},{3,4},{4,5},{5,3}},
148 .inner_size = offsetof(prism,bnds),
149 .bnd_size = sizeof(prism)
150 } ;
151
152 static GENERAL_ELEMENT def_hexahedron = {
153 .tag = HEXAHEDRON,
154 .sides_of_elem = 6,
155 .corners_of_elem = 8,
156 .local_corner = {{0.0,0.0,0.0},{1.0,0.0,0.0},
157 {1.0,1.0,0.0},{0.0,1.0,0.0},
158 {0.0,0.0,1.0},{1.0,0.0,1.0},
159 {1.0,1.0,1.0},{0.0,1.0,1.0}},
160 .edges_of_elem = 12,
161 .edges_of_side = {4,4,4,4,4,4},
162 .corners_of_side = {4,4,4,4,4,4},
163 .edge_of_side = {{3,2,1,0},{0,5,8,4},{1,6,9,5},{2,7,10,6},{3,4,11,7},{8,9,10,11}},
164 .corner_of_side = {{0,3,2,1},{0,1,5,4},{1,2,6,5},{2,3,7,6},{3,0,4,7},{4,5,6,7}},
165 .corner_of_edge = {{0,1},{1,2},{2,3},{3,0},{0,4},{1,5},{2,6},{3,7},{4,5},{5,6},{6,7},{7,4}},
166 .inner_size = offsetof(hexahedron,bnds),
167 .bnd_size = sizeof(hexahedron)
168 } ;
169 #endif
170
171 /****************************************************************************/
172 /** \brief Compute index fields for a given element type
173
174 \param el pointer to an element description
175
176 This function processes a topology description of an element type and computes
177 index mappings. Currently descriptions for triangles,
178 quadrilaterals and tetrahedra are included. Hexahedral elements have been implemented
179 in a prototype version.
180
181 CAUTION: The above data structure is filled UP TO appropriate sizes for memory allocation
182 as well as offsets in the 'refs' array of the 'generic_element'! For complete filling
183 you will have to call 'ProcessElementDescription'
184
185 Only the following components of the GENERAL_ELEMENT structure must be provided.
186 All other components are derived from the given information.
187
188 . tag - New tag for the element which will be delivered by the 'TAG' macro.
189 . sides_of_elem - Number of sides for that element type.
190 . corners_of_elem - Number of corners for that element type.
191 . edges_of_elem - Number of edges for that element type.
192 . edges_of_side - Number of edges for each side.
193 . corners_of_side - Number of corners of each side.
194 . edge_of_side[s][e] - The edges are numbered in the element and in each side of the
195 element. This array provides a mapping that tells you the number of edge 'e' of side
196 's' with respect to the numbering in the element.
197 . corner_of_side[s][c] - The corners edges are numbered in the element and in each side of the
198 element. This array provides a mapping that tells you the number of corner 'c' of side
199 's' with respect to the numbering in the element.
200 . corner_of_edge[e][c] - Tells you the number of corner 'c' in edge 'e' with respect
201 to the numbering in the element.
202 */
203 /****************************************************************************/
204
205 static INT ProcessElementDescription (GENERAL_ELEMENT *el)
206 {
207 INT i,j,k;
208
209 INT tag = el->tag;
210
211 /* derive additional index fields */
212
213 /* edge_with_corners(i,j) : number of edge between corners i and j, -1 if no such edge ex. */
214 for (i=0; i<MAX_CORNERS_OF_ELEM; i++)
215 for (j=0; j<MAX_CORNERS_OF_ELEM; j++) el->edge_with_corners[i][j] = -1;
216 for (i=0; i<el->edges_of_elem; i++)
217 {
218 el->edge_with_corners[el->corner_of_edge[i][0]][el->corner_of_edge[i][1]] = i;
219 el->edge_with_corners[el->corner_of_edge[i][1]][el->corner_of_edge[i][0]] = i;
220 }
221
222 /* side_with_edge(i,j) : edge i is an edge of side side_with_edge(i,j) */
223 for (i=0; i<MAX_EDGES_OF_ELEM; i++)
224 for (j=0; j<MAX_SIDES_OF_EDGE; j++) el->side_with_edge[i][j] = -1;
225 for (k=0; k<el->edges_of_elem; k++)
226 {
227 const INT from = el->corner_of_edge[k][0];
228 const INT to = el->corner_of_edge[k][1];
229
230 for (i=0; i<el->sides_of_elem; i++) {
231 INT n = el->corners_of_side[i];
232 for (j=0; j<n; j++)
233 {
234 if ((el->corner_of_side[i][j]==from)&&(el->corner_of_side[i][(j+1)%n]==to))
235 el->side_with_edge[k][1] = i;
236 if ((el->corner_of_side[i][j]==to)&&(el->corner_of_side[i][(j+1)%n]==from))
237 el->side_with_edge[k][0] = i;
238 }
239 }
240 }
241
242 /* corner_of_side_inv(i,j) : j is number of a corner in the element. Then this
243 array returns the local number of this corner within side i or -1 if side i
244 does not contain this corner. */
245 for (i=0; i<MAX_SIDES_OF_ELEM; i++)
246 for (j=0; j<MAX_CORNERS_OF_ELEM; j++) el->corner_of_side_inv[i][j] = -1;
247 for (i=0; i<el->sides_of_elem; i++)
248 for (j=0; j<el->corners_of_side[i]; j++)
249 {
250 const INT n = el->corner_of_side[i][j];
251 el->corner_of_side_inv[i][n] = j;
252 }
253
254 /* edges_of_corner(i,j) : i is a number of a corner within the element, then
255 edges_of_corner(i,j) gives the number of an edge adjacent to corner i or -1 */
256 for (i=0; i<MAX_CORNERS_OF_ELEM; i++)
257 for (j=0; j<MAX_EDGES_OF_ELEM; j++) el->edges_of_corner[i][j] = -1;
258 for (i=0; i<el->edges_of_elem; i++)
259 for (j=0; j<CORNERS_OF_EDGE; j++)
260 {
261 const INT n = el->corner_of_edge[i][j];
262 for (k=0; k<MAX_EDGES_OF_ELEM; k++)
263 if (el->edges_of_corner[n][k]<0)
264 {
265 el->edges_of_corner[n][k] = i;
266 break;
267 }
268 }
269
270
271 /* fields not valid for all elements */
272
273 /* corner_opp_to_side(i) */
274 for (i=0; i<MAX_SIDES_OF_ELEM; i++)
275 el->corner_opp_to_side[i] = -1;
276
277 /* opposite_edge(i) */
278 for (i=0; i<MAX_EDGES_OF_ELEM; i++)
279 el->opposite_edge[i] = -1;
280
281 /* side_opp_to_corner(i) */
282 for (i=0; i<MAX_CORNERS_OF_ELEM; i++)
283 el->side_opp_to_corner[i] = -1;
284
285 /* edge_of_corner(i,j) */
286 for (i=0; i<MAX_CORNERS_OF_ELEM; i++)
287 for (j=0; j<MAX_EDGES_OF_ELEM; j++)
288 el->edge_of_corner[i][j] = -1;
289
290 /* edge_of_corner(i,j) */
291 for (i=0; i<el->edges_of_elem; i++) {
292 for (j=0; j<CORNERS_OF_EDGE; j++) {
293 if (el->corner_of_edge[i][j] >=0) {
294 for (k=0; k<el->edges_of_elem; k++)
295 if (el->edge_of_corner[el->corner_of_edge[i][j]][k] < 0)
296 break;
297 assert(k<el->edges_of_elem);
298 el->edge_of_corner[el->corner_of_edge[i][j]][k] = i;
299 }
300 }
301 }
302
303 #ifdef UG_DIM_2
304 switch (tag)
305 {
306 case TRIANGLE :
307 /* corner_opp_to_side(i) */
308 /* is not defined! */
309
310 /* opposite_edge(i) */
311 /* is not defined! */
312
313 /* side_opp_to_corner(i) */
314 /* is not defined! */
315
316 break;
317
318 case QUADRILATERAL :
319 /* corner_opp_to_side(i) */
320 /* is not defined! */
321
322 /* opposite_edge(i) */
323 for (i=0; i<el->edges_of_elem; i++) {
324 INT n = 0;
325 for (j=0; j<CORNERS_OF_EDGE; j++) {
326 for (k=0; k<el->edges_of_elem; k++) {
327 if (el->edges_of_corner[el->corner_of_edge[i][j]][k] >= 0)
328 n |= (0x1<<(el->edges_of_corner[el->corner_of_edge[i][j]][k]));
329 }
330 }
331 for (j=0; j<el->edges_of_elem; j++)
332 if (((n>>j) & 0x1) == 0)
333 break;
334 assert(j<el->edges_of_elem);
335
336 el->opposite_edge[i] = j;
337 }
338
339 /* side_opp_to_corner(i) */
340 /* is not defined! */
341
342 break;
343 }
344 #endif
345
346 #ifdef UG_DIM_3
347 /* edge_of_two_sides(i,j) */
348 for (i=0; i<MAX_SIDES_OF_ELEM; i++)
349 for (j=0; j<MAX_SIDES_OF_ELEM; j++)
350 el->edge_of_two_sides[i][j] = -1;
351
352 switch (tag)
353 {
354 case TETRAHEDRON :
355
356 /* corner_opp_to_side(i) */
357 for (i=0; i<el->sides_of_elem; i++) {
358 INT n = 0;
359 for (j=0; j<el->corners_of_side[i]; j++) {
360 n |= (0x1<<(el->corner_of_side[i][j]));
361 }
362 for (j=0; j<el->corners_of_elem; j++) {
363 if (((n>>j) & 0x1) == 0)
364 break;
365 }
366 assert(j<el->corners_of_elem);
367 el->corner_opp_to_side[i] = j;
368 }
369
370 /* opposite_edge(i) */
371 for (i=0; i<el->edges_of_elem; i++) {
372 INT n = 0;
373 for (j=0; j<CORNERS_OF_EDGE; j++) {
374 for (k=0; k<el->edges_of_elem; k++) {
375 if (el->edges_of_corner[el->corner_of_edge[i][j]][k] >= 0)
376 n |= (0x1<<(el->edges_of_corner[el->corner_of_edge[i][j]][k]));
377 }
378 }
379 for (j=0; j<el->edges_of_elem; j++)
380 if (((n>>j) & 0x1) == 0)
381 break;
382 assert(j<el->edges_of_elem);
383
384 el->opposite_edge[i] = j;
385 }
386
387 /* side_opp_to_corner(i) */
388 for (i=0; i<el->corners_of_elem; i++) {
389 for (j=0; j<el->sides_of_elem; j++) {
390 INT n = 0;
391 for (k=0; k<el->corners_of_side[j]; k++)
392 n |= (0x1<<(el->corner_of_side[j][k]));
393 if (((n>>i) & 0x1) == 0) {
394 el->side_opp_to_corner[i] = j;
395 break;
396 }
397 }
398 assert(j<el->sides_of_elem);
399 }
400
401 break;
402
403 case PYRAMID :
404
405 /* corner_opp_to_side(i) */
406 for (i=0; i<el->sides_of_elem; i++) {
407 if (el->corners_of_side[i] == 4) {
408 INT n = 0;
409 for (j=0; j<el->corners_of_side[i]; j++) {
410 n |= (0x1<<(el->corner_of_side[i][j]));
411 }
412 for (j=0; j<el->corners_of_elem; j++) {
413 if (((n>>j) & 0x1) == 0)
414 break;
415 }
416 assert(j<el->corners_of_elem);
417 el->corner_opp_to_side[i] = j;
418 }
419 }
420
421 /* opposite_edge(i) */
422 /* is not defined! */
423
424 /* side_opp_to_corner(i) */
425 for (i=0; i<el->corners_of_elem; i++) {
426 for (j=0; j<el->sides_of_elem; j++) {
427 INT n = 0;
428 for (k=0; k<el->corners_of_side[j]; k++)
429 n |= (0x1<<(el->corner_of_side[j][k]));
430 if (((n>>i) & 0x1) == 0) {
431 el->side_opp_to_corner[i] = j;
432 break;
433 }
434 }
435 assert(j<el->sides_of_elem);
436 }
437
438 break;
439
440 case PRISM :
441
442 /* corner_opp_to_side(i) */
443 /* is not defined! */
444
445 /* opposite_edge(i) */
446 /* is not defined! */
447
448 /* side_opp_to_corner(i) */
449 /* is not defined! */
450
451 break;
452
453 case HEXAHEDRON :
454
455 /* corner_opp_to_side(i) */
456 /* is not defined! */
457
458 /* opposite_edge(i) */
459 for (i=0; i<el->edges_of_elem; i++) {
460 INT n = 0;
461 for (j=0; j<CORNERS_OF_EDGE; j++) {
462 const INT n1 = el->corner_of_edge[i][j];
463 for (k=0; k<el->edges_of_elem; k++) {
464 if (el->edges_of_corner[n1][k] >= 0) {
465 n |= (0x1<<(el->edges_of_corner[n1][k]));
466 for (INT l=0; l<CORNERS_OF_EDGE; l++) {
467 const INT n2 = el->corner_of_edge[el->edges_of_corner[n1][k]][l];
468 if (n2 != n1) {
469 for (INT m=0; m<el->edges_of_elem; m++) {
470 if (el->edges_of_corner[n2][m] >= 0)
471 n |= (0x1<<(el->edges_of_corner[n2][m]));
472 }
473 }
474 }
475 }
476 }
477 }
478 for (k=0; k<el->edges_of_elem; k++)
479 if (((n>>k) & 0x1) == 0)
480 break;
481 assert(k<el->edges_of_elem);
482
483 el->opposite_edge[i] = k;
484 }
485
486 /* side_opp_to_corner(i) */
487 /* is not defined! */
488
489 break;
490 }
491
492 for (i=0; i<el->sides_of_elem; i++)
493 for (j=0; j<el->sides_of_elem; j++)
494 for (k=0; k<el->edges_of_side[i]; k++)
495 for (INT l=0; l<el->edges_of_side[j]; l++)
496 if (el->edge_of_side[i][k] == el->edge_of_side[j][l])
497 {
498 assert( (i==j) || (el->edge_of_two_sides[i][j]==-1) ||
499 (el->edge_of_two_sides[i][j]==el->edge_of_side[i][k]) );
500 el->edge_of_two_sides[i][j] = el->edge_of_side[i][k];
501 }
502 #endif
503
504 /* make description globally available */
505 element_descriptors[tag] = el;
506
507 /* get a free object id for free list */
508 if (el->mapped_inner_objt < 0)
509 el->mapped_inner_objt = GetFreeOBJT();
510 if (el->mapped_inner_objt < 0) return(GM_ERROR);
511
512 if (el->mapped_bnd_objt < 0)
513 el->mapped_bnd_objt = GetFreeOBJT();
514 if (el->mapped_bnd_objt < 0) return(GM_ERROR);
515
516 return(GM_OK);
517 }
518
519 /****************************************************************************/
520 /** \brief Initialize topological information for element types
521
522 This function initializes topological information for element types and
523 is called once during startup. Add your initialization of a new element
524 type here.
525
526 \return <ul>
527 <li> GM_OK if ok </li>
528 <li> GM_ERROR if error occurred </li>
529 </ul>
530 */
531 /****************************************************************************/
532
533 INT NS_DIM_PREFIX InitElementTypes()
534 {
535 INT err;
536
537 #ifdef UG_DIM_2
538 err = ProcessElementDescription(&def_triangle);
539 if (err!=GM_OK)
540 return err;
541 err = ProcessElementDescription(&def_quadrilateral);
542 if (err!=GM_OK)
543 return err;
544 #endif
545
546 #ifdef UG_DIM_3
547 err = ProcessElementDescription(&def_tetrahedron);
548 if (err!=GM_OK)
549 return err;
550 err = ProcessElementDescription(&def_pyramid);
551 if (err!=GM_OK)
552 return err;
553 err = ProcessElementDescription(&def_prism);
554 if (err!=GM_OK)
555 return err;
556 err = ProcessElementDescription(&def_hexahedron);
557 if (err!=GM_OK)
558 return err;
559 #endif
560
561 return (0);
562 }