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_case_table.h"
7 
8 #include <math.h>
9 #include "hecmw_vis_intersection_find.h"
10 
p2h(int i)11 int p2h(int i) {
12   if (i == 0)
13     return 0;
14   else if (i == 1)
15     return 1;
16   else if (i == 2)
17     return 2;
18   else if (i == 3)
19     return 2;
20   else if (i == 4)
21     return 3;
22   else if (i == 5)
23     return 4;
24   else if (i == 6)
25     return 5;
26   else if (i == 7)
27     return 5;
28   return 0;
29 }
30 
get_data(Surface * sff,struct hecmwST_local_mesh * mesh,struct hecmwST_result_data * data,int elemID,Cell * cell,int tn_component)31 int get_data(Surface *sff, struct hecmwST_local_mesh *mesh,
32              struct hecmwST_result_data *data, int elemID, Cell *cell,
33              int tn_component) {
34   int i, j;
35   int nodeID;
36   int c_base, s_base;
37   double c[13], s[13];
38   int tmp_int;
39   double tmp_d;
40 
41   c_base = 0;
42 
43   if (sff->display_way != 4) {
44     for (i = 0; i < sff->color_comp; i++) {
45       c_base += data->nn_dof[i];
46     }
47   }
48   if (sff->surface_style == 2) {
49     s_base = 0;
50     for (i = 0; i < sff->data_comp; i++) s_base += data->nn_dof[i];
51   }
52 
53   /*  set field data of voxel in cube  */
54   if ((mesh->elem_type[elemID] == 361) || (mesh->elem_type[elemID] == 362)) {
55     for (i = 0; i < HEX_N_NODE; i++) {
56       nodeID = mesh->elem_node_item[mesh->elem_node_index[elemID] + i];
57       if (sff->display_way != 4) {
58         if ((data->nn_dof[sff->color_comp] > 1) && (sff->color_subcomp == 0)) {
59           tmp_d = 0.0;
60           for (j = 0; j < data->nn_dof[sff->color_comp]; j++) {
61             c[j] =
62                 data->node_val_item[(nodeID - 1) * tn_component + c_base + j];
63             tmp_d += c[j] * c[j];
64           }
65           cell->c_data[i] = sqrt(tmp_d);
66         } else if ((data->nn_dof[sff->color_comp] > 1) &&
67                    (sff->color_subcomp != 0))
68           cell->c_data[i] =
69               data->node_val_item[(nodeID - 1) * tn_component + c_base +
70                                   (sff->color_subcomp - 1)];
71         else if (data->nn_dof[sff->color_comp] == 1)
72           cell->c_data[i] =
73               data->node_val_item[(nodeID - 1) * tn_component + c_base];
74 
75       } else if (sff->display_way == 4)
76         cell->c_data[i] = sff->specified_color;
77 
78       cell->axis[i * 3]     = mesh->node[(nodeID - 1) * 3];
79       cell->axis[i * 3 + 1] = mesh->node[(nodeID - 1) * 3 + 1];
80       cell->axis[i * 3 + 2] = mesh->node[(nodeID - 1) * 3 + 2];
81 
82       if (sff->surface_style == 2) {
83         if ((data->nn_dof[sff->data_comp] > 1) && (sff->data_subcomp == 0)) {
84           tmp_d = 0.0;
85           for (j = 0; j < data->nn_dof[sff->data_comp]; j++) {
86             s[j] =
87                 data->node_val_item[(nodeID - 1) * tn_component + s_base + j];
88             tmp_d += s[j] * s[j];
89           }
90           cell->s_data[i] = sqrt(tmp_d);
91         } else if ((data->nn_dof[sff->data_comp] > 1) &&
92                    (sff->data_subcomp != 0))
93           cell->s_data[i] =
94               data->node_val_item[(nodeID - 1) * tn_component + s_base +
95                                   (sff->data_subcomp - 1)];
96         else if (data->nn_dof[sff->data_comp] == 1)
97           cell->s_data[i] =
98               data->node_val_item[(nodeID - 1) * tn_component + s_base];
99       } else if (sff->surface_style == 3)
100 
101         cell->s_data[i] =
102             get_value_equ(sff->cont_equ, sff->cross_type, cell->axis[i * 3],
103                           cell->axis[i * 3 + 1], cell->axis[i * 3 + 2]);
104     }
105   } else if ((mesh->elem_type[elemID] == 351) ||
106              (mesh->elem_type[elemID] == 352)) {
107     for (i = 0; i < 8; i++) {
108       tmp_int = p2h(i);
109       nodeID  = mesh->elem_node_item[mesh->elem_node_index[elemID] + tmp_int];
110       if (sff->display_way != 4) {
111         if ((data->nn_dof[sff->color_comp] > 1) && (sff->color_subcomp == 0)) {
112           tmp_d = 0.0;
113           for (j = 0; j < data->nn_dof[sff->color_comp]; j++) {
114             c[j] =
115                 data->node_val_item[(nodeID - 1) * tn_component + c_base + j];
116             tmp_d += c[j] * c[j];
117           }
118           cell->c_data[i] = sqrt(tmp_d);
119         } else if ((data->nn_dof[sff->color_comp] > 1) &&
120                    (sff->color_subcomp != 0))
121           cell->c_data[i] =
122               data->node_val_item[(nodeID - 1) * tn_component + c_base +
123                                   (sff->color_subcomp - 1)];
124         else if (data->nn_dof[sff->color_comp] == 1)
125           cell->c_data[i] =
126               data->node_val_item[(nodeID - 1) * tn_component + c_base];
127 
128       } else if (sff->display_way == 4)
129         cell->c_data[i] = sff->specified_color;
130 
131       cell->axis[i * 3]     = mesh->node[(nodeID - 1) * 3];
132       cell->axis[i * 3 + 1] = mesh->node[(nodeID - 1) * 3 + 1];
133       cell->axis[i * 3 + 2] = mesh->node[(nodeID - 1) * 3 + 2];
134 
135       if (sff->surface_style == 2) {
136         if ((data->nn_dof[sff->data_comp] > 1) && (sff->data_subcomp == 0)) {
137           tmp_d = 0.0;
138           for (j = 0; j < data->nn_dof[sff->data_comp]; j++) {
139             s[j] =
140                 data->node_val_item[(nodeID - 1) * tn_component + s_base + j];
141             tmp_d += s[j] * s[j];
142           }
143           cell->s_data[i] = sqrt(tmp_d);
144         } else if ((data->nn_dof[sff->data_comp] > 1) &&
145                    (sff->data_subcomp != 0))
146           cell->s_data[i] =
147               data->node_val_item[(nodeID - 1) * tn_component + s_base +
148                                   (sff->data_subcomp - 1)];
149         else if (data->nn_dof[sff->data_comp] == 1)
150           cell->s_data[i] =
151               data->node_val_item[(nodeID - 1) * tn_component + s_base];
152       } else if (sff->surface_style == 3)
153 
154         cell->s_data[i] =
155             get_value_equ(sff->cont_equ, sff->cross_type, cell->axis[i * 3],
156                           cell->axis[i * 3 + 1], cell->axis[i * 3 + 2]);
157     }
158   }
159 
160   cell->elem_id[0] = mesh->elem_ID[elemID * 2];
161   cell->elem_id[1] = mesh->elem_ID[elemID * 2 + 1];
162 
163   return 1;
164 }
165 
get_value_equ(double cont_equ[10],int cross_type,double x,double y,double z)166 double get_value_equ(double cont_equ[10], int cross_type, double x, double y,
167                      double z)
168 
169 {
170   double value;
171   if (cross_type == 1)
172     value = cont_equ[0] * x + cont_equ[1] * y + cont_equ[2] * z + cont_equ[3];
173   else if (cross_type == 2)
174     value = cont_equ[0] * x * x + cont_equ[1] * y * y + cont_equ[2] * z * z +
175             cont_equ[3] * x * y + cont_equ[4] * y * z + cont_equ[5] * x * z +
176             cont_equ[6] * x + cont_equ[7] * y + cont_equ[8] * z + cont_equ[9];
177   else {
178     fprintf(stderr, "The value of cross type is wrong\n");
179     return (-1);
180   }
181   return (value);
182 }
183 
184 /*  make the boundary patches of interval volumes in each cube  */
make_tile(struct hecmwST_local_mesh * mesh,Cell * cell,double fvalue,int CS_type,Cube_polygons * cube_polys,int disamb_flag)185 int make_tile(struct hecmwST_local_mesh *mesh, Cell *cell, double fvalue,
186               int CS_type, Cube_polygons *cube_polys, int disamb_flag) {
187   int index, config;
188 
189   /*  decide the configuration of volume in cube  */
190   index = 0;
191   if (!CS_type) {
192     /*  when alpha volume  */
193     index |= (cell->s_data[0] >= fvalue) ? (int)1 : (int)0;
194     index |= (cell->s_data[1] >= fvalue) ? (int)2 : (int)0;
195     index |= (cell->s_data[2] >= fvalue) ? (int)4 : (int)0;
196     index |= (cell->s_data[3] >= fvalue) ? (int)8 : (int)0;
197     index |= (cell->s_data[4] >= fvalue) ? (int)16 : (int)0;
198     index |= (cell->s_data[5] >= fvalue) ? (int)32 : (int)0;
199     index |= (cell->s_data[6] >= fvalue) ? (int)64 : (int)0;
200     index |= (cell->s_data[7] >= fvalue) ? (int)128 : (int)0;
201   } else {
202     /*  when beta volume  */
203     index |= (cell->s_data[0] < fvalue) ? (int)1 : (int)0;
204     index |= (cell->s_data[1] < fvalue) ? (int)2 : (int)0;
205     index |= (cell->s_data[2] < fvalue) ? (int)4 : (int)0;
206     index |= (cell->s_data[3] < fvalue) ? (int)8 : (int)0;
207     index |= (cell->s_data[4] < fvalue) ? (int)16 : (int)0;
208     index |= (cell->s_data[5] < fvalue) ? (int)32 : (int)0;
209     index |= (cell->s_data[6] < fvalue) ? (int)64 : (int)0;
210     index |= (cell->s_data[7] < fvalue) ? (int)128 : (int)0;
211   }
212 
213   /*  make tile data of cube  */
214   if (!index) return 0;
215   if ((config = get_config_info(index)) > 0) {
216     switch (config) {
217       case 1:
218         case1_tiler_hex(index, cube_polys);
219         break;
220       case 2:
221         case2_tiler_hex(index, cube_polys);
222         break;
223       case 3:
224         case3_tiler_hex(mesh, cell, fvalue, CS_type, index, cube_polys,
225                         disamb_flag);
226         break;
227       case 4:
228         case4_tiler_hex(index, cube_polys);
229         break;
230       case 5:
231         case5_tiler_hex(index, cube_polys);
232         break;
233       case 6:
234         case6_tiler_hex(mesh, cell, fvalue, CS_type, index, cube_polys,
235                         disamb_flag);
236         break;
237       case 7:
238         case7_tiler_hex(mesh, cell, fvalue, CS_type, index, cube_polys,
239                         disamb_flag);
240         break;
241       case 8:
242         case8_tiler_hex(index, cube_polys);
243         break;
244       case 9:
245         case9_tiler_hex(index, cube_polys);
246         break;
247       case 10:
248         case10_tiler_hex(mesh, cell, fvalue, CS_type, index, cube_polys,
249                          disamb_flag);
250         break;
251       case 11:
252         case11_tiler_hex(index, cube_polys);
253         break;
254       case 12:
255         case12_tiler_hex(mesh, cell, fvalue, CS_type, index, cube_polys,
256                          disamb_flag);
257         break;
258       case 13:
259         case13_tiler_hex(mesh, cell, fvalue, CS_type, index, cube_polys,
260                          disamb_flag);
261         break;
262       case 14:
263         case14_tiler_hex(index, cube_polys);
264         break;
265     }
266   } else {
267     switch (config) {
268       case 0:
269         case0opp_tiler_hex(cube_polys);
270         break;
271       case -1:
272         case1opp_tiler_hex(index, cube_polys);
273         break;
274       case -2:
275         case2opp_tiler_hex(index, cube_polys);
276         break;
277       case -3:
278         case3opp_tiler_hex(mesh, cell, fvalue, CS_type, index, cube_polys,
279                            disamb_flag);
280         break;
281       case -4:
282         case4opp_tiler_hex(index, cube_polys);
283         break;
284       case -5:
285         case5opp_tiler_hex(index, cube_polys);
286         break;
287       case -6:
288         case6opp_tiler_hex(mesh, cell, fvalue, CS_type, index, cube_polys,
289                            disamb_flag);
290         break;
291       case -7:
292         case7opp_tiler_hex(mesh, cell, fvalue, CS_type, index, cube_polys,
293                            disamb_flag);
294         break;
295       case -8:
296         case8opp_tiler_hex(index, cube_polys);
297         break;
298       case -9:
299         case9opp_tiler_hex(index, cube_polys);
300         break;
301       case -10:
302         case10opp_tiler_hex(mesh, cell, fvalue, CS_type, index, cube_polys,
303                             disamb_flag);
304         break;
305       case -11:
306         case11opp_tiler_hex(index, cube_polys);
307         break;
308       case -12:
309         case12opp_tiler_hex(mesh, cell, fvalue, CS_type, index, cube_polys,
310                             disamb_flag);
311         break;
312       case -13:
313         case13opp_tiler_hex(mesh, cell, fvalue, CS_type, index, cube_polys,
314                             disamb_flag);
315         break;
316       case -14:
317         case14opp_tiler_hex(index, cube_polys);
318         break;
319     }
320   }
321 
322   return index;
323 }
324 
325 /*  decide the cube configuration  */
get_config_info(int index)326 int get_config_info(int index) {
327   static int config_list[256] = {
328       0,   1,   1,   2,  1,   3,   2,   5,   1,   2,   3,  5,   2,   5,   5,
329       8,   1,   2,   3,  5,   4,   6,   6,   -14, 3,   5,  7,   -9,  6,   11,
330       12,  -5,  1,   3,  2,   5,   3,   7,   5,   -9,  4,  6,   6,   11,  6,
331       12,  -14, -5,  2,  5,   5,   8,   6,   12,  11,  -5, 6,   -14, 12,  -5,
332       10,  -6,  -6,  -2, 1,   4,   3,   6,   2,   6,   5,  11,  3,   6,   7,
333       12,  5,   -14, -9, -5,  3,   6,   7,   12,  6,   10, 12,  -6,  7,   12,
334       -13, -7,  12,  -6, -7,  -3,  2,   6,   5,   -14, 5,  12,  8,   -5,  6,
335       10,  12,  -6,  11, -6,  -5,  -2,  5,   11,  -9,  -5, -14, -6,  -5,  -2,
336       12,  -6,  -7,  -3, -6,  -4,  -3,  -1,  1,   3,   4,  6,   3,   7,   6,
337       -12, 2,   5,   6,  14,  5,   9,   -11, -5,  2,   5,  6,   -11, 6,   -12,
338       -10, -6,  5,   -8, -12, -5,  14,  -5,  -6,  -2,  3,  7,   6,   -12, 7,
339       13,  -12, -7,  6,  -12, -10, -6,  -12, -7,  -6,  -3, 5,   9,   14,  -5,
340       -12, -7,  -6,  -3, -11, -5,  -6,  -2,  -6,  -3,  -4, -1,  2,   6,   6,
341       -10, 5,   -12, 14, -6,  5,   -11, -12, -6,  -8,  -5, -5,  -2,  5,   14,
342       -12, -6,  -11, -6, -6,  -4,  9,   -5,  -7,  -3,  -5, -2,  -3,  -1,  5,
343       -12, -11, -6,  9,  -7,  -5,  -3,  14,  -6,  -6,  -4, -5,  -3,  -2,  -1,
344       -8,  -5,  -5,  -2, -5,  -3,  -2,  -1,  -5,  -2,  -3, -1,  -2,  -1,  -1,
345       0};
346 
347   return config_list[index];
348 }
349