FrontISTR  5.7.0
Large-scale structural analysis program with finit element method
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 
6 #include "hecmw_vis_patch_const.h"
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 
15 int 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 
105 int 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 
210 int 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 
244 int 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 
274 int 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 
303 int 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 }
hecmw_malloc.h
_fgeom_struct::z
double z
Definition: hecmw_vis_SF_geom.h:182
POLYGON_PACK
#define POLYGON_PACK
Definition: hecmw_vis_SF_geom.h:33
hecmw_vis_mem_util.h
add_verts_table
int add_verts_table(Point **CS_verts_tail, int table_no, int pident, double pfield, double cdata, Fgeom *pgeom, int bdflag)
Definition: hecmw_vis_patch_const.c:274
_point_struct::geom
Fgeom geom
Definition: hecmw_vis_SF_geom.h:202
hecmw_vis_patch_const.h
VERTEX_KIND
#define VERTEX_KIND
Definition: hecmw_vis_SF_geom.h:35
_cube_polygons_struct::verts
int verts[VERTEX_KIND]
Definition: hecmw_vis_SF_geom.h:241
_cell_struct::elem_id
int elem_id[2]
Definition: hecmw_vis_SF_geom.h:258
_point_struct::nextpoint
struct _point_struct * nextpoint
Definition: hecmw_vis_SF_geom.h:206
_cell_struct::s_data
double s_data[8]
Definition: hecmw_vis_SF_geom.h:254
_point_struct::cdata
double cdata
Definition: hecmw_vis_SF_geom.h:200
_point_struct::field
double field
Definition: hecmw_vis_SF_geom.h:199
get_edge_index
int get_edge_index(int bound_index, int vert_index)
Definition: hecmw_vis_patch_const.c:105
get_vert_ident
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)
Definition: hecmw_vis_patch_const.c:210
_fgeom_struct
Definition: hecmw_vis_SF_geom.h:179
_cube_polygons_struct::verts_num
int verts_num
Definition: hecmw_vis_SF_geom.h:240
search_verts_table
int search_verts_table(Fgeom *pgeom, Point **CS_verts_refer, int bdflag, int table_no)
Definition: hecmw_vis_patch_const.c:244
HECMW_calloc
#define HECMW_calloc(nmemb, size)
Definition: hecmw_malloc.h:21
HEX_FACE_INDEX
#define HEX_FACE_INDEX
Definition: hecmw_repart.h:23
_polygon_struct
Definition: hecmw_vis_SF_geom.h:209
_cell_struct::c_data
double c_data[8]
Definition: hecmw_vis_SF_geom.h:255
_cell_struct
Definition: hecmw_vis_SF_geom.h:252
check_vertex
int check_vertex(Cell *cell, double fvalue, Cube_polygons *cube_polys)
Definition: hecmw_vis_patch_const.c:303
hecmw_vis_calc_attr.h
_point_struct::info
int info
Definition: hecmw_vis_SF_geom.h:205
_cube_polygons_struct
Definition: hecmw_vis_SF_geom.h:239
_point_struct
Definition: hecmw_vis_SF_geom.h:197
get_point_geom
int get_point_geom(int point_index, Cell *cell, double fvalue, Fgeom *point_geom, double *cdata, int disamb_flag)
Definition: hecmw_vis_calc_attr.c:18
EPSILON
#define EPSILON
Definition: hecmw_vis_color_mapping.c:10
_cube_polygons_struct::isosurf
int ** isosurf
Definition: hecmw_vis_SF_geom.h:242
alloc_verts
Point * alloc_verts(int num)
Definition: hecmw_vis_mem_util.c:32
merge_vol_iso
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)
Definition: hecmw_vis_patch_const.c:15
NULL
#define NULL
Definition: hecmw_io_nastran.c:30
_polygon_struct::nextpolygon
struct _polygon_struct * nextpolygon
Definition: hecmw_vis_SF_geom.h:212
_fgeom_struct::y
double y
Definition: hecmw_vis_SF_geom.h:181
VERTEX_PACK
#define VERTEX_PACK
Definition: hecmw_vis_SF_geom.h:31
alloc_polygons
Polygon * alloc_polygons(int num)
Definition: hecmw_vis_mem_util.c:51
_point_struct::ident
int ident
Definition: hecmw_vis_SF_geom.h:198
_fgeom_struct::x
double x
Definition: hecmw_vis_SF_geom.h:180