FrontISTR 5.2.0
Large-scale structural analysis program with finit element method
Loading...
Searching...
No Matches
hecmw_vis_patch_const.c
Go to the documentation of this file.
1/*****************************************************************************
2 * Copyright (c) 2019 FrontISTR Commons
3 * This software is released under the MIT License, see LICENSE.txt
4 *****************************************************************************/
5
7
8#include <stdio.h>
9#include <stdlib.h>
10#include <math.h>
11#include "hecmw_vis_mem_util.h"
12#include "hecmw_vis_calc_attr.h"
13#include "hecmw_malloc.h"
14
15int merge_vol_iso(int iso_type, Cell *cell, double falpha,
16 Cube_polygons *alpha_cube, double fbeta,
17 Cube_polygons *beta_cube, int bdflag, int *sum_verts,
18 Point **CS_verts_tail, Point **CS_verts_refer,
19 Point **CS_verts_head, Polygon **CS_polys_tail) {
20 int i;
21 int *alpha_verts, *beta_verts;
22 int *alpha_iso, *beta_iso;
23 int alpha_vident[VERTEX_KIND], beta_vident[VERTEX_KIND];
24
25 alpha_verts = alpha_cube->verts;
26 alpha_iso = *alpha_cube->isosurf;
27 for (i = 0; i < VERTEX_KIND; i++) {
28 alpha_vident[i] = 0;
29 }
30 beta_verts = beta_cube->verts;
31 beta_iso = *beta_cube->isosurf;
32 for (i = 0; i < VERTEX_KIND; i++) {
33 beta_vident[i] = 0;
34 }
35
36 if (!iso_type) {
37 /* make isosurface , iso_type = 0 */
38 if (alpha_iso[0] != -1) {
39 for (i = 0; i < alpha_cube->verts_num; i++) {
40 if (alpha_verts[i] < 200) {
41 if (!(alpha_vident[i] = get_vert_ident(
42 alpha_verts[i], cell, falpha, sum_verts, CS_verts_tail,
43 CS_verts_refer, CS_verts_head, bdflag))) {
44 fprintf(stderr, "Error: Cannot get vertex index.\n");
45
46 return 0;
47 }
48 }
49 }
50 i = 0;
51 do {
52 (*CS_polys_tail)->type = 0;
53 (*CS_polys_tail)->plist = (int *)HECMW_calloc(4, sizeof(int));
54 (*CS_polys_tail)->plist[0] = 3;
55 (*CS_polys_tail)->plist[1] = alpha_vident[alpha_iso[i++]];
56 (*CS_polys_tail)->plist[2] = alpha_vident[alpha_iso[i++]];
57 (*CS_polys_tail)->plist[3] = alpha_vident[alpha_iso[i++]];
58 (*CS_polys_tail)->bdflag = bdflag;
59 (*CS_polys_tail)->elem_id[0] = cell->elem_id[0];
60 (*CS_polys_tail)->elem_id[1] = cell->elem_id[1];
61
62 if ((*CS_polys_tail)->nextpolygon == NULL) {
63 if (((*CS_polys_tail)->nextpolygon = alloc_polygons(POLYGON_PACK)) ==
64 NULL) {
65 fprintf(stderr, "Cannot allocate memory.\n");
66 return 0;
67 }
68 }
69 *CS_polys_tail = (*CS_polys_tail)->nextpolygon;
70 } while (alpha_iso[i] != -1);
71 }
72#ifdef BCUBE
73 if (beta_iso[0] != -1) {
74 for (i = 0; i < beta_cube->verts_num; i++) {
75 if (beta_verts[i] < 100) {
76 beta_vident[i] = alpha_vident[i];
77 }
78 }
79 i = 0;
80 do {
81 (*CS_polys_tail)->type = 1;
82 (*CS_polys_tail)->plist = (int *)HECMW_calloc(4, sizeof(int));
83 (*CS_polys_tail)->plist[0] = 3;
84 (*CS_polys_tail)->plist[1] = beta_vident[beta_iso[i++]];
85 (*CS_polys_tail)->plist[2] = beta_vident[beta_iso[i++]];
86 (*CS_polys_tail)->plist[3] = beta_vident[beta_iso[i++]];
87 (*CS_polys_tail)->bdflag = bdflag;
88 (*CS_polys_tail)->elem_id[0] = cell->elem_id[0];
89 (*CS_polys_tail)->elem_id[1] = cell->elem_id[1];
90 if ((*CS_polys_tail)->nextpolygon == NULL) {
91 if (((*CS_polys_tail)->nextpolygon = alloc_polygons(POLYGON_PACK)) ==
92 NULL) {
93 return 0;
94 }
95 }
96 *CS_polys_tail = (*CS_polys_tail)->nextpolygon;
97 } while (beta_iso[i] != -1);
98 }
99#endif
100 return 1;
101 }
102 return 1; /* *** 2007/12/26 S. Ito *** */
103}
104
105int get_edge_index(int bound_index, int vert_index) {
106 int edge_index;
107
108 switch (bound_index) {
109 case 0:
110 switch (vert_index) {
111 case 200:
112 edge_index = 0;
113 break;
114 case 201:
115 edge_index = 1;
116 break;
117 case 202:
118 edge_index = 2;
119 break;
120 case 203:
121 edge_index = 3;
122 break;
123 }
124 break;
125 case 1:
126 switch (vert_index) {
127 case 201:
128 edge_index = 9;
129 break;
130 case 205:
131 edge_index = 5;
132 break;
133 case 206:
134 edge_index = 11;
135 break;
136 case 202:
137 edge_index = 1;
138 break;
139 }
140 break;
141 case 2:
142 switch (vert_index) {
143 case 205:
144 edge_index = 4;
145 break;
146 case 204:
147 edge_index = 7;
148 break;
149 case 207:
150 edge_index = 6;
151 break;
152 case 206:
153 edge_index = 5;
154 break;
155 }
156 break;
157 case 3:
158 switch (vert_index) {
159 case 204:
160 edge_index = 8;
161 break;
162 case 200:
163 edge_index = 3;
164 break;
165 case 203:
166 edge_index = 10;
167 break;
168 case 207:
169 edge_index = 7;
170 break;
171 }
172 break;
173 case 4:
174 switch (vert_index) {
175 case 203:
176 edge_index = 2;
177 break;
178 case 202:
179 edge_index = 11;
180 break;
181 case 206:
182 edge_index = 6;
183 break;
184 case 207:
185 edge_index = 10;
186 break;
187 }
188 break;
189 case 5:
190 switch (vert_index) {
191 case 204:
192 edge_index = 4;
193 break;
194 case 205:
195 edge_index = 9;
196 break;
197 case 201:
198 edge_index = 0;
199 break;
200 case 200:
201 edge_index = 8;
202 break;
203 }
204 break;
205 }
206
207 return edge_index;
208}
209
210int get_vert_ident(int pindex, Cell *cell, double fvalue, int *sum_verts,
211 Point **CS_verts_tail, Point **CS_verts_refer,
212 Point **CS_verts_head, int bdflag) {
213 int table_no;
214 int pident;
215 double cdata;
216 Fgeom pgeom;
217
218 get_point_geom(pindex, cell, fvalue, &pgeom, &cdata, 1);
219 table_no = 0;
220
221 CS_verts_refer[table_no] = CS_verts_head[table_no];
222
223 if (pindex < 100) {
224 pident = search_verts_table(&pgeom, CS_verts_refer, bdflag, table_no);
225 if (pident) {
226 return pident;
227 }
228 } else if (pindex >= 200) {
229 fvalue = cell->s_data[pindex - 200];
230 cdata = cell->c_data[pindex - 200];
231 pident = search_verts_table(&pgeom, CS_verts_refer, bdflag, table_no);
232 if (pident) {
233 return pident;
234 }
235 }
236 pident = ++(*sum_verts);
237
238 add_verts_table(CS_verts_tail, table_no, pident, fvalue, cdata, &pgeom,
239 bdflag);
240
241 return pident;
242}
243
244int search_verts_table(Fgeom *pgeom, Point **CS_verts_refer, int bdflag,
245 int table_no) {
246 Point *CS_verts;
247
248 CS_verts = CS_verts_refer[table_no];
249
250 while (CS_verts->ident) {
251 if ((fabs(CS_verts->geom.x - pgeom->x) < EPSILON) &&
252 (fabs(CS_verts->geom.y - pgeom->y) < EPSILON) &&
253 (fabs(CS_verts->geom.z - pgeom->z) < EPSILON)) {
254 if ((CS_verts->info == 1) || (CS_verts->info == 0)) {
255 if (bdflag < 0) {
256 CS_verts->info = -1;
257 } else if (bdflag >= 1024) {
258 CS_verts->info = 2;
259 } else if (bdflag != HEX_FACE_INDEX) {
260 CS_verts->info = 1;
261 } else {
262 CS_verts->info = 0;
263 }
264 } else if (CS_verts->info == 2) {
265 if (bdflag < 0) CS_verts->info = -1;
266 }
267 return CS_verts->ident;
268 }
269 CS_verts = CS_verts->nextpoint;
270 }
271 return 0;
272}
273
274int add_verts_table(Point **CS_verts_tail, int table_no, int pident,
275 double pfield, double cdata, Fgeom *pgeom, int bdflag) {
276 CS_verts_tail[table_no]->ident = pident;
277 CS_verts_tail[table_no]->field = pfield;
278 CS_verts_tail[table_no]->cdata = cdata;
279 CS_verts_tail[table_no]->geom = *pgeom;
280
281 if (bdflag < 0) {
282 CS_verts_tail[table_no]->info = -1;
283 } else if (bdflag >= 1024) {
284 CS_verts_tail[table_no]->info = 2;
285 } else if (bdflag != HEX_FACE_INDEX) {
286 CS_verts_tail[table_no]->info = 1;
287 } else {
288 CS_verts_tail[table_no]->info = 0;
289 }
290
291 if (CS_verts_tail[table_no]->nextpoint == NULL) {
292 if ((CS_verts_tail[table_no]->nextpoint = alloc_verts(VERTEX_PACK)) ==
293 NULL) {
294 fprintf(stderr, "Cannot allocate memory.\n");
295 return 0;
296 }
297 }
298 CS_verts_tail[table_no] = CS_verts_tail[table_no]->nextpoint;
299
300 return pident;
301}
302
303int check_vertex(Cell *cell, double fvalue, Cube_polygons *cube_polys) {
304 int i;
305 int flag;
306 int verts_num;
307 int *verts;
308
309 flag = 0;
310 verts_num = cube_polys->verts_num;
311 verts = cube_polys->verts;
312
313 if (cell->s_data[0] == fvalue) {
314 for (i = 0; i < verts_num; i++) {
315 if ((verts[i] == 0) || (verts[i] == 3) || (verts[i] == 8) ||
316 (verts[i] == 100)) {
317 verts[i] = 200;
318 flag++;
319 }
320 }
321 }
322 if (cell->s_data[1] == fvalue) {
323 for (i = 0; i < verts_num; i++) {
324 if ((verts[i] == 0) || (verts[i] == 1) || (verts[i] == 9) ||
325 (verts[i] == 101)) {
326 verts[i] = 201;
327 flag++;
328 }
329 }
330 }
331 if (cell->s_data[2] == fvalue) {
332 for (i = 0; i < verts_num; i++) {
333 if ((verts[i] == 1) || (verts[i] == 2) || (verts[i] == 11) ||
334 (verts[i] == 102)) {
335 verts[i] = 202;
336 flag++;
337 }
338 }
339 }
340 if (cell->s_data[3] == fvalue) {
341 for (i = 0; i < verts_num; i++) {
342 if ((verts[i] == 2) || (verts[i] == 3) || (verts[i] == 10) ||
343 (verts[i] == 103)) {
344 verts[i] = 203;
345 flag++;
346 }
347 }
348 }
349 if (cell->s_data[4] == fvalue) {
350 for (i = 0; i < verts_num; i++) {
351 if ((verts[i] == 4) || (verts[i] == 7) || (verts[i] == 8) ||
352 (verts[i] == 102)) {
353 verts[i] = 204;
354 flag++;
355 }
356 }
357 }
358 if (cell->s_data[5] == fvalue) {
359 for (i = 0; i < verts_num; i++) {
360 if ((verts[i] == 4) || (verts[i] == 5) || (verts[i] == 9) ||
361 (verts[i] == 103)) {
362 verts[i] = 205;
363 flag++;
364 }
365 }
366 }
367 if (cell->s_data[6] == fvalue) {
368 for (i = 0; i < verts_num; i++) {
369 if ((verts[i] == 5) || (verts[i] == 6) || (verts[i] == 11) ||
370 (verts[i] == 100)) {
371 verts[i] = 206;
372 flag++;
373 }
374 }
375 }
376 if (cell->s_data[7] == fvalue) {
377 for (i = 0; i < verts_num; i++) {
378 if ((verts[i] == 6) || (verts[i] == 7) || (verts[i] == 10) ||
379 (verts[i] == 101)) {
380 verts[i] = 207;
381 flag++;
382 }
383 }
384 }
385
386 return flag;
387}
#define NULL
#define HECMW_calloc(nmemb, size)
Definition: hecmw_malloc.h:21
#define HEX_FACE_INDEX
Definition: hecmw_repart.h:23
#define VERTEX_KIND
#define POLYGON_PACK
#define VERTEX_PACK
int get_point_geom(int point_index, Cell *cell, double fvalue, Fgeom *point_geom, double *cdata, int disamb_flag)
#define EPSILON
Point * alloc_verts(int num)
Polygon * alloc_polygons(int num)
int add_verts_table(Point **CS_verts_tail, int table_no, int pident, double pfield, double cdata, Fgeom *pgeom, int bdflag)
int merge_vol_iso(int iso_type, Cell *cell, double falpha, Cube_polygons *alpha_cube, double fbeta, Cube_polygons *beta_cube, int bdflag, int *sum_verts, Point **CS_verts_tail, Point **CS_verts_refer, Point **CS_verts_head, Polygon **CS_polys_tail)
int search_verts_table(Fgeom *pgeom, Point **CS_verts_refer, int bdflag, int table_no)
int get_vert_ident(int pindex, Cell *cell, double fvalue, int *sum_verts, Point **CS_verts_tail, Point **CS_verts_refer, Point **CS_verts_head, int bdflag)
int check_vertex(Cell *cell, double fvalue, Cube_polygons *cube_polys)
int get_edge_index(int bound_index, int vert_index)
int verts[VERTEX_KIND]
struct _point_struct * nextpoint
struct _polygon_struct * nextpolygon