FrontISTR  5.9.0
Large-scale structural analysis program with finit element method
hecmw_dlb_elem_sr_adapt.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_repart.h"
7 
8 extern struct hecmwST_local_mesh *mesh;
9 extern struct hecmwST_result_data *data;
10 extern struct hecmwST_local_mesh *new_mesh;
11 extern struct hecmwST_result_data *new_data;
12 extern int stack_part_send_recv(int neibpetot, int *neibpe, int *stack_import,
13  int *stack_export, HECMW_Comm repart_comm,
14  int my_rank);
15 extern int stack_whole_send_recv(int pesize, int *stack_import,
16  int *stack_export, HECMW_Comm repart_comm,
17  int my_rank);
18 
19 extern int int_part_send_recv(int n, int neibpetot, int *neibpe,
20  int *stack_import, int *nod_import,
21  int *stack_export, int *nod_export, int *x,
22  HECMW_Comm repart_comm, int my_rank);
23 extern int double_part_send_recv(int n, int neibpetot, int *neibpe,
24  int *stack_import, int *nod_import,
25  int *stack_export, int *nod_export, double *x,
26  HECMW_Comm repart_comm, int my_rank);
27 extern void int_whole_send_recv(int n1, int n2, int pesize, int *stack_import,
28  int *nod_import, int *stack_export,
29  int *nod_export, int *x, int *y,
30  HECMW_Comm repart_comm, int my_rank);
31 extern void double_whole_send_recv(int n1, int n2, int pesize,
32  int *stack_import, int *nod_import,
33  int *stack_export, int *nod_export,
34  double *x, double *y, HECMW_Comm repart_comm,
35  int my_rank);
36 
37 extern void int2_whole_send_recv(int n1, int n2, int pesize, int *stack_import,
38  int *stack_export, int *x, int *y,
39  HECMW_Comm repart_comm, int my_rank);
40 extern void int3_whole_send_recv(int n1, int n2, int pesize, int *stack_import,
41  int *stack_export, int *x, int *y,
42  HECMW_Comm repart_comm, int my_rank);
43 extern void double2_whole_send_recv(int n1, int n2, int pesize,
44  int *stack_import, int *stack_export,
45  double *x, double *y,
46  HECMW_Comm repart_comm, int my_rank);
47 extern void whole_copy_array(int *recv_elem_num, int *global_recv_elem_num,
48  int mynode, int pesize, HECMW_Comm repart_comm);
49 
50 void mesh_migration_adapt(int mynode, int pesize, Result_part *result,
51  int *vtxdist)
52 
53 {
54  int *send_elem_num, *send_elem, *recv_elem_num, *recv_elem, *recv_parent_num,
55  *count_elem, *send_parent, *send_parent_num, *count_parent;
56  int *flag_hit, *flag_elem_hit;
57  int ncon, id_elem;
58  int i, j, k, m;
59  int *tmp_int_send, *tmp_int_recv, *tmp2_int_send, *tmp2_int_recv;
60  int *new_part;
61  int *tmp_stack_send, *tmp_stack_recv, *tmp_neibpe, tmp_int, tmp_sum;
62  int *send_ptr_num, *send_ptr_parent_num, *recv_ptr_num, *recv_ptr_parent_num;
63  int *global_index, *global_index_hit;
64  int *send_node_num, *recv_node_num, *send_node, *recv_node;
65  int *tmp_node, *count_node, *tmp_send, *tmp_recv;
66  int *import_index, *export_index, *count_index, *export_node, *import_node;
67  int import_n_neighbor_pe, export_n_neighbor_pe, *import_neighbor_pe,
68  *export_neighbor_pe;
69  /* int *import2_index, *export2_index, *export2_node, *import2_node;
70  */
71  int *tmp_int_nodeid, *tmp2_int_nodeid;
72  double *tmp_node_d, *recv_node_d, *tmp2_node_d, *recv2_node_d, *tmp_send_d,
73  *tmp_recv_d, *tmp2_send_d, *tmp2_recv_d;
74  int *tmp_node_i, *recv_node_i, *tmp2_node_i, *recv2_node_i;
75  HECMW_Status stat;
76  FILE *test_fp, *test_fp2;
77  char test_file[128];
78  int min_pe, tmp_pe, local_nid;
79  int nvtxs, tmp_nvtxs, tmp_peid, tmp_lid;
80  int *new_elem, *global_recv_elem_num, *global_recv_parent_num;
81  int *send_adapt_parent, *recv_adapt_parent, *send_tmp, *recv_tmp,
82  *send_tmp_num, *recv_tmp_num, *send_adapt_ptype, *count_num;
83  int t_elem, l_child, new_l_child;
84  int *inter_elem, *send_adapt_child, *recv_adapt_child, *send_adapt_child_num,
85  *recv_adapt_child_num, *send_index_child, *recv_index_child;
86  int *send2_adapt_child_num, *recv2_adapt_child_num;
87  int *send_inter, *recv_inter, *send_inter_num, *recv_inter_num,
88  *global_recv_inter_num;
89  int *send_parent_inter, *recv_parent_inter, *send_parent_inter_num,
90  *recv_parent_inter_num, *global_recv_parent_inter_num;
91  int init_flag, new_elemid;
92  int *tmp_elem_grp, num_grp_item, *tmp_surf_grp, *tmp_surf_id, *tmp2_surf_id;
93  Tmp_grp_inf *tmp_grp;
94  int *new_nelem_dist;
95  int tn_component;
96  int *new_vtxdist;
97  int *new2old, *count_elem_index, *new_tmp, *new_tmp2, *old2new;
98  double t1, t2;
99  const size_t name_buf_size = 128;
100 
101  if (mynode == 0) {
102  t1 = HECMW_Wtime();
103  }
104 
105 #ifdef TEST
106  snprintf(test_file, sizeof(test_file), "test3.%d", mynode);
107  test_fp = fopen(test_file, "w");
108  if (test_fp == NULL) {
109  fprintf(stderr, "Cannot open test_file\n");
110  exit(EXIT_FAILURE);
111  }
112 #endif
113 /* fprintf(test_fp, "%d\n", mesh->ne_internal);
114  for(i=0;i<mesh->ne_internal;i++)
115  fprintf(test_fp, "%d %d\n", mesh->elem_internal_list[i],
116  mesh->adapt_type[mesh->elem_internal_list[i]]);
117  fprintf(test_fp, "%d %d\n", mesh->n_node, mesh->nn_internal);
118 
119  fprintf(test_fp, "%d \n", mesh->n_neighbor_pe);
120  for(i=0;i<mesh->n_neighbor_pe;i++)
121  fprintf(test_fp, "%d ", mesh->neighbor_pe[i]);
122  fprintf(test_fp, "\n");
123  for(i=0;i<mesh->n_neighbor_pe+1;i++)
124  fprintf(test_fp, "%d ", mesh->import_index[i]);
125  fprintf(test_fp, "\n");
126  for(i=0;i<mesh->n_neighbor_pe+1;i++)
127  fprintf(test_fp, "%d ", mesh->export_index[i]);
128  fprintf(test_fp, "\n");
129  for(i=0;i<mesh->import_index[mesh->n_neighbor_pe];i++)
130  fprintf(test_fp, "%d\n", mesh->import_item[i]);
131  fprintf(test_fp, "export node*****\n");
132  for(i=0;i<mesh->export_index[mesh->n_neighbor_pe];i++)
133  fprintf(test_fp, "%d\n", mesh->export_item[i]);
134 */
135 /*
136  fprintf(test_fp, "in PE %d n_elem=%d ne_internal=%d\n", mynode,
137  mesh->n_elem, mesh->ne_internal);
138  for(i=0;i<mesh->n_elem;i++)
139  fprintf(test_fp, "i=%d %d %d %d %d %d %d\n", i, mesh->elem_ID[i*2],
140  mesh->elem_ID[i*2+1], mesh->adapt_parent[i*2], mesh->adapt_parent[i*2+1],
141  mesh->adapt_type[i], mesh->elem_node_index[i]);
142  fclose(test_fp);
143 */
144 #ifdef test
145  snprintf(test_file, sizeof(test_file), "test5.%d", mynode);
146  test_fp2 = fopen(test_file, "w");
147  if (test_fp2 == NULL) HECMW_dlb_print_exit("Cannot open test_file\n");
148 #endif
149 
150  /* 1: first update new partition to include import nodes */
151 
152  new_part = (int *)calloc(mesh->n_node, sizeof(int));
153  if (new_part == NULL) HECMW_dlb_memory_exit("new_part");
154  for (i = 0; i < mesh->nn_internal; i++) new_part[i] = result->part[i];
155  int_part_send_recv(mesh->n_node, mesh->n_neighbor_pe, mesh->neighbor_pe,
156  mesh->import_index, mesh->import_item, mesh->export_index,
157  mesh->export_item, new_part, mesh->HECMW_COMM, mynode);
158  free(result->part);
159  result->part = new_part;
160  new_elem = (int *)calloc(mesh->n_elem, sizeof(int));
161  if (new_elem == NULL) HECMW_dlb_memory_exit("new_elem");
162  inter_elem = (int *)calloc(mesh->n_elem, sizeof(int));
163  /* tmp_int=0;
164  */
165  for (i = 0; i < mesh->n_elem; i++) {
166  inter_elem[i] = -1;
167  if (mesh->elem_ID[i * 2 + 1] == mynode) {
168  inter_elem[mesh->elem_ID[i * 2] - 1] = i;
169  /* tmp_int++;
170  */
171  }
172  }
173  /* fprintf(test_fp, "ne_internal====%d\n", mesh->ne_internal);
174  for(i=0;i<mesh->n_elem;i++)
175  fprintf(test_fp, "%d %d %d %d\n", i, inter_elem[i],
176  mesh->elem_ID[i*2], mesh->elem_ID[i*2+1]);
177  fclose(test_fp);
178  */
179  for (i = 0; i < mesh->n_elem; i++) new_elem[i] = -1;
180  if (pesize > 1)
181  HECMW_Allreduce(&mesh->n_elem, &t_elem, 1, HECMW_INT, HECMW_SUM,
182  mesh->HECMW_COMM);
183  else
184  t_elem = mesh->n_elem;
185 
186  /* send_parent_num=(int *)calloc(pesize+1, sizeof(int)); */
187  send_elem_num = (int *)calloc(pesize + 1, sizeof(int));
188  send_inter_num = (int *)calloc(pesize + 1, sizeof(int));
189  recv_elem_num = (int *)calloc(pesize + 1, sizeof(int));
190  recv_inter_num = (int *)calloc(pesize + 1, sizeof(int));
191  if ((send_elem_num == NULL) || (send_inter_num == NULL) ||
192  (recv_elem_num == NULL) || (recv_inter_num == NULL))
193  HECMW_dlb_memory_exit("send_elem_num ");
194  flag_hit = (int *)calloc(pesize, sizeof(int));
195  flag_elem_hit = (int *)calloc(mesh->n_elem, sizeof(int));
196  if ((flag_hit == NULL) || (flag_elem_hit == NULL))
197  HECMW_dlb_memory_exit("flag_hit");
198 
199  for (i = 0; i < pesize + 1; i++) {
200  send_elem_num[i] = 0;
201  send_inter_num[i] = 0;
202  recv_elem_num[i] = 0;
203  recv_inter_num[i] = 0;
204  }
205 
206  for (i = 0; i < mesh->n_elem; i++) {
207  for (j = 0; j < pesize; j++) flag_hit[j] = 0;
208  init_flag = pesize;
209  if ((mesh->elem_ID[i * 2 + 1] == mynode) && (mesh->adapt_type[i] == 0)) {
210  long long jj;
211  ncon = mesh->elem_node_index[i + 1] - mesh->elem_node_index[i];
212  for (jj = mesh->elem_node_index[i]; jj < mesh->elem_node_index[i + 1];
213  jj++) {
214  if (flag_hit[result->part[mesh->elem_node_item[jj] - 1]] == 0) {
215  flag_hit[result->part[mesh->elem_node_item[jj] - 1]] = 1;
216  send_elem_num[result->part[mesh->elem_node_item[jj] - 1] + 1]++;
217  if (result->part[mesh->elem_node_item[jj] - 1] < init_flag)
218  init_flag = result->part[mesh->elem_node_item[jj] - 1];
219  }
220  }
221  send_inter_num[init_flag + 1]++;
222  }
223  }
224  /* for(i=1;i<pesize+1;i++)
225  fprintf(stderr, "in PE %d the number send to PE %d is
226  %d\n", mynode, i, send_elem_num[i]);
227  */
228 
229  for (i = 1; i < pesize + 1; i++) {
230  send_elem_num[i] = send_elem_num[i - 1] + send_elem_num[i];
231  send_inter_num[i] = send_inter_num[i - 1] + send_inter_num[i];
232  }
233  /*
234  for(i=0;i<pesize+1;i++)
235  fprintf(stderr, "PE %d: send %d is %d\n", mynode, i,
236  send_elem_num[i]);
237  */
238  HECMW_Barrier(mesh->HECMW_COMM);
239 
240  stack_whole_send_recv(pesize, send_elem_num, recv_elem_num, mesh->HECMW_COMM,
241  mynode);
242  stack_whole_send_recv(pesize, send_inter_num, recv_inter_num,
243  mesh->HECMW_COMM, mynode);
244  /*
245  for(i=0;i<pesize+1;i++)
246  fprintf(stderr, "PE %d: recv %d is %d\n", mynode, i,
247  recv_elem_num[i]);
248  */
249 
250  global_recv_elem_num = (int *)calloc(pesize * (pesize + 1), sizeof(int));
251  global_recv_inter_num = (int *)calloc(pesize * (pesize + 1), sizeof(int));
252  if ((global_recv_elem_num == NULL) || (global_recv_inter_num == NULL))
253  HECMW_dlb_memory_exit("global_recv_elem_num");
254  whole_copy_array(recv_elem_num, global_recv_elem_num, mynode, pesize,
255  mesh->HECMW_COMM);
256  whole_copy_array(recv_inter_num, global_recv_inter_num, mynode, pesize,
257  mesh->HECMW_COMM);
258  /* for(i=1;i<pesize+1;i++)
259  fprintf(stderr, "AFTER--in PE0 the number send to PE
260  %d is %d\n", i, send_elem_num[i]);
261  */
262  if (send_elem_num[pesize] > 0) {
263  send_elem = (int *)calloc(send_elem_num[pesize], sizeof(int));
264  count_elem = (int *)calloc(pesize, sizeof(int));
265  count_num = (int *)calloc(pesize, sizeof(int));
266  send_inter = (int *)calloc(send_elem_num[pesize], sizeof(int));
267 
268  if ((send_elem == NULL) || (count_elem == NULL))
269  HECMW_dlb_memory_exit("send_elem and count_elem");
270  for (i = 0; i < pesize; i++) {
271  count_elem[i] = 0;
272  count_num[i] = 0;
273  }
274  }
275  for (i = 0; i < mesh->n_elem; i++) {
276  for (j = 0; j < pesize; j++) flag_hit[j] = 0;
277  init_flag = pesize;
278  if ((mesh->elem_ID[i * 2 + 1] == mynode) && (mesh->adapt_type[i] == 0)) {
279  long long jj;
280  ncon = mesh->elem_node_index[i + 1] - mesh->elem_node_index[i];
281  for (jj = mesh->elem_node_index[i]; jj < mesh->elem_node_index[i + 1];
282  jj++) {
283  if (flag_hit[result->part[mesh->elem_node_item[jj] - 1]] == 0) {
284  flag_hit[result->part[mesh->elem_node_item[jj] - 1]] = 1;
285  send_elem[send_elem_num[result->part[mesh->elem_node_item[jj] - 1]] +
286  count_elem[result->part[mesh->elem_node_item[jj] - 1]]] = i;
287  count_elem[result->part[mesh->elem_node_item[jj] - 1]]++;
288  if (result->part[mesh->elem_node_item[jj] - 1] < init_flag)
289  init_flag = result->part[mesh->elem_node_item[jj] - 1];
290  }
291  }
292  new_elemid = init_flag * t_elem +
293  global_recv_inter_num[init_flag * (pesize + 1) + mynode] +
294  count_num[init_flag];
295  new_elem[i] = new_elemid;
296  /* new_elemid=init_flag*t_elem+global_recv_elem_num[init_flag*(pesize+1)+mynode]+count_elem[init_flag]-1;
297  new_elem[i]=new_elemid;
298  */
299  count_num[init_flag]++;
300  }
301  }
302  for (i = 0; i < send_elem_num[pesize]; i++)
303  send_inter[i] = new_elem[send_elem[i]];
304 
305  /* -------start finding parent information ----------------*/
306  /* find all the parents which need be sent */
307  send_parent_num = (int *)calloc(pesize + 1, sizeof(int));
308  send_parent_inter_num = (int *)calloc(pesize + 1, sizeof(int));
309  recv_parent_num = (int *)calloc(pesize + 1, sizeof(int));
310  recv_parent_inter_num = (int *)calloc(pesize + 1, sizeof(int));
311 
312  for (i = 0; i < pesize + 1; i++) {
313  send_parent_num[i] = 0;
314  send_parent_inter_num[i] = 0;
315  }
316  for (i = 0; i < mesh->n_elem; i++) flag_elem_hit[i] = 0;
317  for (j = 0; j < pesize; j++) {
318  send_parent_num[j + 1] = 0;
319  for (k = send_elem_num[j]; k < send_elem_num[j + 1]; k++) {
320  id_elem = send_elem[k];
321  while ((mesh->adapt_parent[id_elem * 2] > 0) &&
322  (mesh->adapt_parent[id_elem * 2 + 1] == mynode) &&
323  (flag_elem_hit[mesh->adapt_parent[id_elem * 2] - 1] == 0)) {
324  flag_elem_hit[mesh->adapt_parent[id_elem * 2] - 1] = 1;
325  send_parent_num[j + 1]++;
326  id_elem = inter_elem[mesh->adapt_parent[id_elem * 2] - 1];
327  }
328  }
329  }
330 
331  for (i = 1; i < pesize + 1; i++) {
332  send_parent_num[i] = send_parent_num[i - 1] + send_parent_num[i];
333  }
334 
335  recv_parent_num = (int *)calloc(pesize + 1, sizeof(int));
336  if (recv_parent_num == NULL) HECMW_dlb_memory_exit("recv_parent_num");
337  stack_whole_send_recv(pesize, send_parent_num, recv_parent_num,
338  mesh->HECMW_COMM, mynode);
339  global_recv_parent_num = (int *)calloc(pesize * (pesize + 1), sizeof(int));
340  if (global_recv_parent_num == NULL)
341  HECMW_dlb_memory_exit("global_recv_parent_num");
342  whole_copy_array(recv_parent_num, global_recv_parent_num, mynode, pesize,
343  mesh->HECMW_COMM);
344 
345  send_parent = (int *)calloc(send_parent_num[pesize], sizeof(int));
346  send_parent_inter = (int *)calloc(send_parent_num[pesize], sizeof(int));
347  count_parent = (int *)calloc(pesize, sizeof(int));
348 
349  if ((send_parent == NULL) || (count_parent == NULL))
350  HECMW_dlb_memory_exit("send_parent and count_parent");
351  /* to keep each parent just occur once in all PEs */
352  for (i = 0; i < mesh->n_elem; i++) flag_elem_hit[i] = 0;
353  for (j = 0; j < pesize; j++) {
354  count_parent[j] = 0;
355  for (k = send_elem_num[j]; k < send_elem_num[j + 1]; k++) {
356  id_elem = send_elem[k];
357  while ((mesh->adapt_parent[id_elem * 2] > 0) &&
358  (mesh->adapt_parent[id_elem * 2 + 1] == mynode) &&
359  (flag_elem_hit[mesh->adapt_parent[id_elem * 2] - 1] == 0)) {
360  flag_elem_hit[mesh->adapt_parent[id_elem * 2] - 1] = 1;
361  send_parent[send_parent_num[j] + count_parent[j]] =
362  inter_elem[mesh->adapt_parent[id_elem * 2] - 1];
363  /* send_parent_inter[send_parent_num[j]+count_parent[j]]=j*t_elem+global_recv_inter_num[j*(pesize+1)+pesize]+global_recv_parent_num[j*(pesize+1)+
364  mynode]+count_parent[j];
365  */
366 
367  count_parent[j]++;
368 
369  new_elem[inter_elem[mesh->adapt_parent[id_elem * 2] - 1]] =
370  j * t_elem + global_recv_inter_num[j * (pesize + 1) + pesize] +
371  global_recv_parent_num[j * (pesize + 1) + mynode] +
372  count_parent[j] - 1;
373 
374  id_elem = inter_elem[mesh->adapt_parent[id_elem * 2] - 1];
375  }
376  }
377  }
378  for (i = 0; i < send_parent_num[pesize]; i++) {
379  send_parent_inter[i] = new_elem[send_parent[i]];
380  if (send_parent_inter[i] < 0)
381  HECMW_dlb_print_exit("There is something wrong with send_parent_inter");
382  }
383  /* ------------------- start sending parent information ----------------*/
384 
385  send_tmp_num = (int *)calloc(pesize + 1, sizeof(int));
386  recv_tmp_num = (int *)calloc(pesize + 1, sizeof(int));
387  if ((send_tmp_num == NULL) || (recv_tmp_num == NULL))
388  HECMW_dlb_memory_exit("send_tmp_num");
389  if (send_elem_num[pesize] > 0) {
390  send_adapt_parent = (int *)calloc(send_elem_num[pesize], sizeof(int));
391  send_adapt_ptype = (int *)calloc(send_elem_num[pesize], sizeof(int));
392  if ((send_adapt_parent == NULL) || (send_adapt_ptype == NULL))
393  HECMW_dlb_memory_exit("send_adapt_parent");
394  }
395 
396  for (i = 0; i < pesize + 1; i++) send_tmp_num[i] = 0;
397 
398  for (i = 0; i < send_elem_num[pesize]; i++) {
399  if (mesh->adapt_parent[send_elem[i] * 2 + 1] < 0)
400  send_adapt_parent[i] = -1;
401  else if (mesh->adapt_parent[send_elem[i] * 2 + 1] != mynode)
402  send_tmp_num[mesh->adapt_parent[send_elem[i] * 2 + 1] + 1]++;
403  else if (new_elem[inter_elem[mesh->adapt_parent[send_elem[i] * 2] - 1]] !=
404  -1)
405  send_adapt_parent[i] =
406  new_elem[inter_elem[mesh->adapt_parent[send_elem[i] * 2] - 1]];
407  else if (new_elem[inter_elem[mesh->adapt_parent[send_elem[i] * 2] - 1]] ==
408  -1) {
409  fprintf(stderr, "There is something wrong with parent information\n");
410  fprintf(stderr, "i=%d, send_elem[i]=%d parent is %d PE=%d\n", i,
411  send_elem[i], mesh->adapt_parent[send_elem[i] * 2] - 1,
412  mesh->adapt_parent[send_elem[i] * 2]);
413  HECMW_dlb_print_exit("Error in parent finding");
414  }
415  }
416  for (i = 1; i < pesize + 1; i++) {
417  send_tmp_num[i] = send_tmp_num[i - 1] + send_tmp_num[i];
418  }
419 
420  stack_whole_send_recv(pesize, send_tmp_num, recv_tmp_num, mesh->HECMW_COMM,
421  mynode);
422 
423  for (i = 0; i < pesize; i++) count_num[i] = 0;
424  if (send_tmp_num[pesize] > 0) {
425  send_tmp = (int *)calloc(send_tmp_num[pesize], sizeof(int));
426  if (send_tmp == NULL) HECMW_dlb_memory_exit("send_tmp");
427  }
428  if (recv_tmp_num[pesize] > 0) {
429  recv_tmp = (int *)calloc(recv_tmp_num[pesize], sizeof(int));
430  if (recv_tmp == NULL) HECMW_dlb_memory_exit("send_tmp, recv_tmp");
431  }
432  for (i = 0; i < send_elem_num[pesize]; i++) {
433  if (mesh->adapt_parent[send_elem[i] * 2 + 1] < 0)
434  send_adapt_parent[i] = -1;
435  else if (mesh->adapt_parent[send_elem[i] * 2 + 1] != mynode) {
436  send_tmp[send_tmp_num[mesh->adapt_parent[send_elem[i] * 2 + 1]] +
437  count_num[mesh->adapt_parent[send_elem[i] * 2 + 1]]] =
438  inter_elem[mesh->adapt_parent[send_elem[i] * 2] - 1];
439  count_num[mesh->adapt_parent[send_elem[i] * 2 + 1]]++;
440  }
441  }
442 
443  if (send_tmp_num[pesize] > 0)
444  int2_whole_send_recv(send_tmp_num[pesize], recv_tmp_num[pesize], pesize,
445  recv_tmp_num, send_tmp_num, send_tmp, recv_tmp,
446  mesh->HECMW_COMM, mynode);
447  HECMW_Barrier(mesh->HECMW_COMM);
448  for (i = 0; i < recv_tmp_num[pesize]; i++) {
449  if (new_elem[recv_tmp[i]] == -1)
450  HECMW_dlb_print_exit("There is something wrong in parent inf");
451  else
452  recv_tmp[i] = new_elem[recv_tmp[i]];
453  }
454  if (send_tmp_num[pesize] > 0)
455  int2_whole_send_recv(recv_tmp_num[pesize], send_tmp_num[pesize], pesize,
456  send_tmp_num, recv_tmp_num, recv_tmp, send_tmp,
457  mesh->HECMW_COMM, mynode);
458 
459  for (i = 0; i < pesize; i++) count_num[i] = 0;
460  for (i = 0; i < send_elem_num[pesize]; i++) {
461  if (mesh->adapt_parent[send_elem[i] * 2 + 1] < 0) {
462  send_adapt_parent[i] = -1;
463  send_adapt_ptype[i] = -1;
464  } else if (mesh->adapt_parent[send_elem[i] * 2 + 1] != mynode) {
465  send_adapt_parent[i] =
466  send_tmp[send_tmp_num[mesh->adapt_parent[send_elem[i] * 2 + 1]] +
467  count_num[mesh->adapt_parent[send_elem[i] * 2 + 1]]];
468  send_adapt_ptype[i] = mesh->adapt_parent_type[send_elem[i]];
469 
470  count_num[mesh->adapt_parent[send_elem[i] * 2 + 1]]++;
471  } else if (new_elem[inter_elem[mesh->adapt_parent[send_elem[i] * 2] - 1]] !=
472  -1) {
473  send_adapt_parent[i] =
474  new_elem[inter_elem[mesh->adapt_parent[send_elem[i] * 2] - 1]];
475  send_adapt_ptype[i] = mesh->adapt_parent_type[send_elem[i]];
476  } else if (new_elem[inter_elem[mesh->adapt_parent[send_elem[i] * 2] - 1]] ==
477  -1)
478  HECMW_dlb_print_exit("There is something wrong with parent information");
479  }
480  if (recv_elem_num[pesize] > 0) {
481  tmp_int_recv = (int *)calloc(recv_elem_num[pesize], sizeof(int));
482  if (tmp_int_recv == NULL) HECMW_dlb_memory_exit("tmp_int_recv");
483  int2_whole_send_recv(send_elem_num[pesize], recv_elem_num[pesize], pesize,
484  recv_elem_num, send_elem_num, send_adapt_parent,
485  tmp_int_recv, mesh->HECMW_COMM, mynode);
486  }
487  /* new mesh whole inf. copy */
488  /* for(i=0;i<mesh->n_elem;i++) {
489  if(new_elem[i]==-1)
490  fprintf(stderr, "Wrong in new elem: %d %d\n", mynode, i);
491  HECMW_dlb_print_exit("check");
492  }
493  */
494  new_mesh->hecmw_n_file = mesh->hecmw_n_file;
495  new_mesh->files = (char **)calloc(mesh->hecmw_n_file, sizeof(char *));
496  for (i = 9; i < mesh->hecmw_n_file; i++)
497  new_mesh->files[i] = (char *)calloc(name_buf_size, sizeof(char));
498 
499  snprintf(new_mesh->header, sizeof(new_mesh->header), "%s", mesh->header);
500  snprintf(new_mesh->gridfile, sizeof(new_mesh->gridfile), "%s", mesh->gridfile);
501  new_mesh->hecmw_flag_adapt = mesh->hecmw_flag_adapt;
502  new_mesh->hecmw_flag_initcon = mesh->hecmw_flag_initcon;
503  new_mesh->hecmw_flag_parttype = mesh->hecmw_flag_parttype;
504  new_mesh->hecmw_flag_partdepth = mesh->hecmw_flag_partdepth;
505  new_mesh->hecmw_flag_version = mesh->hecmw_flag_version;
506  new_mesh->zero_temp = mesh->zero_temp;
507  new_mesh->n_dof = mesh->n_dof;
508  new_mesh->n_dof_grp = mesh->n_dof_grp;
509 
510  new_mesh->n_elem = recv_elem_num[pesize] + recv_parent_num[pesize];
511  new_mesh->n_elem_type = mesh->n_elem_type;
512  new_mesh->n_elem_mat_ID = mesh->n_elem_mat_ID;
513  if (new_mesh->n_elem <= 0) HECMW_dlb_print_exit("Error: New mesh: n_elem==0");
514  new_mesh->adapt_parent = (int *)calloc(new_mesh->n_elem * 2, sizeof(int));
515  if (new_mesh->adapt_parent == NULL)
516  HECMW_dlb_memory_exit("new_mesh: adaption_parent");
517  new_mesh->adapt_parent_type = (int *)calloc(new_mesh->n_elem, sizeof(int));
518  if (new_mesh->adapt_parent_type == NULL)
519  HECMW_dlb_memory_exit("new_mesh: adapt_parent_type");
520  for (i = 0; i < recv_elem_num[pesize]; i++) {
521  if (tmp_int_recv[i] == -1) {
522  new_mesh->adapt_parent[i * 2] = 0;
523  new_mesh->adapt_parent[i * 2 + 1] = -1;
524  } else {
525  new_mesh->adapt_parent[i * 2] = (tmp_int_recv[i] % t_elem) + 1;
526  new_mesh->adapt_parent[i * 2 + 1] = tmp_int_recv[i] / t_elem;
527  }
528  }
529  int2_whole_send_recv(send_elem_num[pesize], recv_elem_num[pesize], pesize,
530  recv_elem_num, send_elem_num, send_adapt_ptype,
531  tmp_int_recv, mesh->HECMW_COMM, mynode);
532  for (i = 0; i < recv_elem_num[pesize]; i++)
533  new_mesh->adapt_parent_type[i] = tmp_int_recv[i];
534  if (send_tmp_num[pesize] > 0) free(send_tmp);
535  if (recv_tmp_num[pesize] > 0) free(recv_tmp);
536  if (send_elem_num[pesize] > 0) {
537  free(send_adapt_parent);
538  free(send_adapt_ptype);
539  }
540  if (send_parent_num[pesize] > 0) {
541  send_adapt_parent = (int *)calloc(send_parent_num[pesize], sizeof(int));
542  send_adapt_ptype = (int *)calloc(send_parent_num[pesize], sizeof(int));
543  if ((send_adapt_parent == NULL) || (send_adapt_ptype == NULL))
544  HECMW_dlb_memory_exit("send_adapt_parent");
545  }
546 
547  for (i = 0; i < pesize + 1; i++) send_tmp_num[i] = 0;
548 
549  for (i = 0; i < send_parent_num[pesize]; i++) {
550  if (mesh->adapt_parent[send_parent[i] * 2 + 1] < 0)
551  send_adapt_parent[i] = -1;
552  else if (mesh->adapt_parent[send_parent[i] * 2 + 1] != mynode)
553  send_tmp_num[mesh->adapt_parent[send_parent[i] * 2 + 1] + 1]++;
554  else if (new_elem[inter_elem[mesh->adapt_parent[send_parent[i] * 2] - 1]] !=
555  -1)
556  send_adapt_parent[i] =
557  new_elem[inter_elem[mesh->adapt_parent[send_parent[i] * 2] - 1]];
558  else if (new_elem[inter_elem[mesh->adapt_parent[send_parent[i] * 2] - 1]] ==
559  -1)
560  HECMW_dlb_print_exit("There is something wrong with parent information");
561  }
562  for (i = 1; i < pesize + 1; i++) {
563  send_tmp_num[i] = send_tmp_num[i - 1] + send_tmp_num[i];
564  }
565 
566  stack_whole_send_recv(pesize, send_tmp_num, recv_tmp_num, mesh->HECMW_COMM,
567  mynode);
568 
569  for (i = 0; i < pesize; i++) count_num[i] = 0;
570  if (send_tmp_num[pesize] > 0) {
571  send_tmp = (int *)calloc(send_tmp_num[pesize], sizeof(int));
572  if (send_tmp == NULL) HECMW_dlb_memory_exit("send_tmp, recv_tmp");
573  }
574  if (recv_tmp_num[pesize] > 0) {
575  recv_tmp = (int *)calloc(recv_tmp_num[pesize], sizeof(int));
576  if (recv_tmp == NULL) HECMW_dlb_memory_exit("send_tmp, recv_tmp");
577  }
578  for (i = 0; i < send_parent_num[pesize]; i++) {
579  if (mesh->adapt_parent[send_parent[i] * 2 + 1] < 0)
580  send_adapt_parent[i] = -1;
581  else if (mesh->adapt_parent[send_parent[i] * 2 + 1] != mynode) {
582  send_tmp[send_tmp_num[mesh->adapt_parent[send_parent[i] * 2 + 1]] +
583  count_num[mesh->adapt_parent[send_parent[i] * 2 + 1]]] =
584  inter_elem[mesh->adapt_parent[send_parent[i] * 2] - 1];
585  count_num[mesh->adapt_parent[send_parent[i] * 2 + 1]]++;
586  }
587  }
588  if (send_tmp_num[pesize] > 0)
589  int2_whole_send_recv(send_tmp_num[pesize], recv_tmp_num[pesize], pesize,
590  recv_tmp_num, send_tmp_num, send_tmp, recv_tmp,
591  mesh->HECMW_COMM, mynode);
592  for (i = 0; i < recv_tmp_num[pesize]; i++) {
593  if (new_elem[recv_tmp[i]] == -1)
594  HECMW_dlb_print_exit("There is something wrong in parent inf");
595  else
596  recv_tmp[i] = new_elem[recv_tmp[i]];
597  }
598  if (send_tmp_num[pesize] > 0)
599  int2_whole_send_recv(recv_tmp_num[pesize], send_tmp_num[pesize], pesize,
600  send_tmp_num, recv_tmp_num, recv_tmp, send_tmp,
601  mesh->HECMW_COMM, mynode);
602 
603  for (i = 0; i < pesize; i++) count_num[i] = 0;
604  for (i = 0; i < send_parent_num[pesize]; i++) {
605  if (mesh->adapt_parent[send_parent[i] * 2 + 1] < 0) {
606  send_adapt_parent[i] = -1;
607  send_adapt_ptype[i] = -1;
608  } else if (mesh->adapt_parent[send_parent[i] * 2 + 1] != mynode) {
609  send_adapt_parent[i] =
610  send_tmp[send_tmp_num[mesh->adapt_parent[send_parent[i] * 2 + 1]] +
611  count_num[mesh->adapt_parent[send_parent[i] * 2 + 1]]];
612  send_adapt_ptype[i] = mesh->adapt_parent_type[send_parent[i]];
613 
614  count_num[mesh->adapt_parent[send_parent[i] * 2 + 1]]++;
615  } else if (new_elem[inter_elem[mesh->adapt_parent[send_parent[i] * 2] -
616  1]] != -1) {
617  send_adapt_parent[i] =
618  new_elem[inter_elem[mesh->adapt_parent[send_parent[i] * 2] - 1]];
619  send_adapt_ptype[i] = mesh->adapt_parent_type[send_parent[i]];
620  } else if (new_elem[inter_elem[mesh->adapt_parent[send_parent[i] * 2] -
621  1]] == -1)
622  HECMW_dlb_print_exit("There is something wrong with parent information");
623  }
624 
625  tmp2_int_recv = (int *)calloc(recv_parent_num[pesize], sizeof(int));
626  if (tmp2_int_recv == NULL) HECMW_dlb_memory_exit("tmp2_int_recv");
627  int2_whole_send_recv(send_parent_num[pesize], recv_parent_num[pesize], pesize,
628  recv_parent_num, send_parent_num, send_adapt_parent,
629  tmp2_int_recv, mesh->HECMW_COMM, mynode);
630 
631  for (i = 0; i < recv_parent_num[pesize]; i++) {
632  if (tmp2_int_recv[i] == -1) {
633  new_mesh->adapt_parent[(i + recv_elem_num[pesize]) * 2] = 0;
634  new_mesh->adapt_parent[(i + recv_elem_num[pesize]) * 2 + 1] = -1;
635  } else {
636  new_mesh->adapt_parent[(i + recv_elem_num[pesize]) * 2] =
637  (tmp2_int_recv[i] % t_elem) + 1;
638  new_mesh->adapt_parent[(i + recv_elem_num[pesize]) * 2 + 1] =
639  tmp2_int_recv[i] / t_elem;
640  }
641  }
642  int2_whole_send_recv(send_parent_num[pesize], recv_parent_num[pesize], pesize,
643  recv_parent_num, send_parent_num, send_adapt_ptype,
644  tmp2_int_recv, mesh->HECMW_COMM, mynode);
645  for (i = 0; i < recv_parent_num[pesize]; i++)
646  new_mesh->adapt_parent_type[i + recv_elem_num[pesize]] = tmp2_int_recv[i];
647  if (send_tmp_num[pesize] > 0) free(send_tmp);
648  if (recv_tmp_num[pesize] > 0) free(recv_tmp);
649  if (send_parent_num[pesize] > 0) {
650  free(send_adapt_parent);
651  free(send_adapt_ptype);
652  }
653  HECMW_Barrier(mesh->HECMW_COMM);
654 
655  /* ------------- start migration child information ------------------ */
656  send_adapt_child_num = (int *)calloc(pesize + 1, sizeof(int));
657  for (j = 0; j < pesize + 1; j++) send_adapt_child_num[j] = 0;
658  for (j = 0; j < pesize; j++) {
659  for (i = send_elem_num[j]; i < send_elem_num[j + 1]; i++)
660  send_adapt_child_num[j + 1] +=
661  mesh->adapt_children_index[send_elem[i] + 1] -
662  mesh->adapt_children_index[send_elem[i]];
663  }
664  for (i = 1; i < pesize + 1; i++) {
665  send_adapt_child_num[i] =
666  send_adapt_child_num[i - 1] + send_adapt_child_num[i];
667  }
668 
669  send_adapt_child = (int *)calloc(send_adapt_child_num[pesize], sizeof(int));
670  send_index_child = (int *)calloc(send_elem_num[pesize], sizeof(int));
671  if ((send_adapt_child == NULL) || (send_index_child == NULL))
672  HECMW_dlb_memory_exit("send_adapt_child, send_index_child");
673 
674  for (i = 0; i < pesize + 1; i++) send_tmp_num[i] = 0;
675  tmp_int = -1;
676  for (i = 0; i < send_elem_num[pesize]; i++) {
677  for (j = mesh->adapt_children_index[send_elem[i]];
678  j < mesh->adapt_children_index[send_elem[i] + 1]; j++) {
679  tmp_int++;
680  if (mesh->adapt_children_item[j * 2 + 1] < 0)
681  send_adapt_child[tmp_int] = -1;
682  else if (mesh->adapt_children_item[j * 2 + 1] != mynode)
683  send_tmp_num[mesh->adapt_children_item[j * 2 + 1] + 1]++;
684  else if (new_elem[inter_elem[mesh->adapt_children_item[j * 2] - 1]] != -1)
685  send_adapt_child[tmp_int] =
686  new_elem[inter_elem[mesh->adapt_children_item[j * 2] - 1]];
687  else if (new_elem[inter_elem[mesh->adapt_children_item[j * 2] - 1]] ==
688  -1) {
689  fprintf(stderr, "There is something wrong with child information\n");
690  fprintf(stderr, "i=%d, send_elem[i]=%d child is %d PE=%d\n", i,
691  send_elem[i], mesh->adapt_children_item[j * 2] - 1,
692  mesh->adapt_children_item[j * 2 + 1]);
693  HECMW_dlb_print_exit("Error: in finding children inf");
694  }
695  }
696  }
697  for (i = 1; i < pesize + 1; i++) {
698  send_tmp_num[i] = send_tmp_num[i - 1] + send_tmp_num[i];
699  }
700 
701  stack_whole_send_recv(pesize, send_tmp_num, recv_tmp_num, mesh->HECMW_COMM,
702  mynode);
703  for (i = 0; i < pesize; i++) count_num[i] = 0;
704  if (send_tmp_num[pesize] > 0) {
705  send_tmp = (int *)calloc(send_tmp_num[pesize], sizeof(int));
706  if (send_tmp == NULL) HECMW_dlb_memory_exit("send_tmp");
707  }
708  if (recv_tmp_num[pesize] > 0) {
709  recv_tmp = (int *)calloc(recv_tmp_num[pesize], sizeof(int));
710  if (recv_tmp == NULL) HECMW_dlb_memory_exit("recv_tmp");
711  }
712  tmp_int = -1;
713  for (i = 0; i < send_elem_num[pesize]; i++) {
714  for (j = mesh->adapt_children_index[send_elem[i]];
715  j < mesh->adapt_children_index[send_elem[i] + 1]; j++) {
716  tmp_int++;
717  if (mesh->adapt_children_item[j * 2 + 1] < 0)
718  send_adapt_child[tmp_int] = -1;
719  else if (mesh->adapt_children_item[j * 2 + 1] != mynode) {
720  send_tmp[send_tmp_num[mesh->adapt_children_item[j * 2 + 1]] +
721  count_num[mesh->adapt_children_item[j * 2 + 1]]] =
722  inter_elem[mesh->adapt_children_item[j * 2] - 1];
723  count_num[mesh->adapt_children_item[j * 2 + 1]]++;
724  }
725  }
726  }
727  if (send_tmp_num[pesize] > 0)
728  int2_whole_send_recv(send_tmp_num[pesize], recv_tmp_num[pesize], pesize,
729  recv_tmp_num, send_tmp_num, send_tmp, recv_tmp,
730  mesh->HECMW_COMM, mynode);
731  for (i = 0; i < recv_tmp_num[pesize]; i++) {
732  if (new_elem[recv_tmp[i]] == -1)
733  HECMW_dlb_print_exit("There is something wrong in children inf");
734  else
735  recv_tmp[i] = new_elem[recv_tmp[i]];
736  }
737  if (send_tmp_num[pesize] > 0)
738  int2_whole_send_recv(recv_tmp_num[pesize], send_tmp_num[pesize], pesize,
739  send_tmp_num, recv_tmp_num, recv_tmp, send_tmp,
740  mesh->HECMW_COMM, mynode);
741 
742  for (i = 0; i < pesize; i++) count_num[i] = 0;
743  tmp_int = -1;
744  for (i = 0; i < send_elem_num[pesize]; i++) {
745  send_index_child[i] = mesh->adapt_children_index[send_elem[i] + 1] -
746  mesh->adapt_children_index[send_elem[i]];
747  for (j = mesh->adapt_children_index[send_elem[i]];
748  j < mesh->adapt_children_index[send_elem[i] + 1]; j++) {
749  tmp_int++;
750  if (mesh->adapt_children_item[j * 2 + 1] < 0) {
751  send_adapt_child[tmp_int] = -1;
752  } else if (mesh->adapt_children_item[j * 2 + 1] != mynode) {
753  send_adapt_child[tmp_int] =
754  send_tmp[send_tmp_num[mesh->adapt_children_item[j * 2 + 1]] +
755  count_num[mesh->adapt_children_item[j * 2 + 1]]];
756  count_num[mesh->adapt_children_item[j * 2 + 1]]++;
757  } else if (new_elem[inter_elem[mesh->adapt_children_item[j * 2] - 1]] !=
758  -1)
759  send_adapt_child[tmp_int] =
760  new_elem[inter_elem[mesh->adapt_children_item[j * 2] - 1]];
761  else if (new_elem[inter_elem[mesh->adapt_children_item[j * 2] - 1]] ==
762  -1) {
763  fprintf(stderr, "There is something wrong with child information\n");
764  fprintf(stderr, "i=%d, send_elem[i]=%d child is %d PE=%d\n", i,
765  send_elem[i], mesh->adapt_children_item[j * 2] - 1,
766  mesh->adapt_children_item[j * 2 + 1]);
767  HECMW_dlb_print_exit("There is something wrong in children inf");
768  }
769  }
770  }
771 
772  recv_adapt_child_num = (int *)calloc(pesize + 1, sizeof(int));
773  if (recv_adapt_child_num == NULL)
774  HECMW_dlb_memory_exit("recv_adapt_child_num");
775 
776  stack_whole_send_recv(pesize, send_adapt_child_num, recv_adapt_child_num,
777  mesh->HECMW_COMM, mynode);
778  recv_adapt_child = (int *)calloc(recv_adapt_child_num[pesize], sizeof(int));
779  if (recv_adapt_child == NULL) HECMW_dlb_memory_exit("recv_adapt_child");
780  int2_whole_send_recv(
781  send_adapt_child_num[pesize], recv_adapt_child_num[pesize], pesize,
782  recv_adapt_child_num, send_adapt_child_num, send_adapt_child,
783  recv_adapt_child, mesh->HECMW_COMM, mynode);
784 
785  int2_whole_send_recv(send_elem_num[pesize], recv_elem_num[pesize], pesize,
786  recv_elem_num, send_elem_num, send_index_child,
787  tmp_int_recv, mesh->HECMW_COMM, mynode);
788 
789  /*--------first find child number in send_parent --------------- */
790 
791  send2_adapt_child_num = (int *)calloc(pesize + 1, sizeof(int));
792  for (j = 0; j < pesize + 1; j++) send2_adapt_child_num[j] = 0;
793  for (j = 0; j < pesize; j++) {
794  for (i = send_parent_num[j]; i < send_parent_num[j + 1]; i++)
795  send2_adapt_child_num[j + 1] +=
796  mesh->adapt_children_index[send_parent[i] + 1] -
797  mesh->adapt_children_index[send_parent[i]];
798  }
799  for (i = 1; i < pesize + 1; i++) {
800  send2_adapt_child_num[i] =
801  send2_adapt_child_num[i - 1] + send2_adapt_child_num[i];
802  }
803  recv2_adapt_child_num = (int *)calloc(pesize + 1, sizeof(int));
804  if (recv2_adapt_child_num == NULL)
805  HECMW_dlb_memory_exit("recv2_adapt_child_num");
806 
807  stack_whole_send_recv(pesize, send2_adapt_child_num, recv2_adapt_child_num,
808  mesh->HECMW_COMM, mynode);
809  new_mesh->adapt_children_item = (int *)calloc(
810  2 * (recv_adapt_child_num[pesize] + recv2_adapt_child_num[pesize]),
811  sizeof(int));
812  if (new_mesh->adapt_children_item == NULL)
813  HECMW_dlb_memory_exit("new_mesh: adapt_children_item");
814  new_mesh->adapt_children_index =
815  (int *)calloc(new_mesh->n_elem + 1, sizeof(int));
816  if (new_mesh->adapt_children_index == NULL)
817  HECMW_dlb_memory_exit("new_mesh: adapt_children_index");
818  /*
819  new_l_child=recv_adapt_child_num[pesize]+recv2_adapt_child_num[pesize];
820  */
821 
822  for (i = 0; i < recv_adapt_child_num[pesize]; i++) {
823  if (recv_adapt_child[i] == -1) {
824  new_mesh->adapt_children_item[i * 2] = 0;
825  new_mesh->adapt_children_item[i * 2 + 1] = -1;
826  } else {
827  new_mesh->adapt_children_item[i * 2] = (recv_adapt_child[i] % t_elem) + 1;
828  new_mesh->adapt_children_item[i * 2 + 1] = recv_adapt_child[i] / t_elem;
829  }
830  }
831  new_mesh->adapt_children_index[0] = 0;
832  for (i = 0; i < recv_elem_num[pesize]; i++)
833  new_mesh->adapt_children_index[i + 1] =
834  new_mesh->adapt_children_index[i] + tmp_int_recv[i];
835  if (send_tmp_num[pesize] > 0) free(send_tmp);
836  if (recv_tmp_num[pesize] > 0) free(recv_tmp);
837  if (send_elem_num[pesize] > 0) {
838  free(send_adapt_child);
839  free(recv_adapt_child);
840  free(send_index_child);
841  }
842 
843  send_adapt_child = (int *)calloc(send2_adapt_child_num[pesize], sizeof(int));
844  send_index_child = (int *)calloc(send_parent_num[pesize], sizeof(int));
845  if ((send_adapt_child == NULL) || (send_index_child == NULL))
846  HECMW_dlb_memory_exit("send_adapt_child, send_index_child");
847 
848  for (i = 0; i < pesize + 1; i++) send_tmp_num[i] = 0;
849  tmp_int = -1;
850  for (i = 0; i < send_parent_num[pesize]; i++) {
851  for (j = mesh->adapt_children_index[send_parent[i]];
852  j < mesh->adapt_children_index[send_parent[i] + 1]; j++) {
853  tmp_int++;
854  if (mesh->adapt_children_item[j * 2 + 1] < 0)
855  send_adapt_child[tmp_int] = -1;
856  else if (mesh->adapt_children_item[j * 2 + 1] != mynode)
857  send_tmp_num[mesh->adapt_children_item[j * 2 + 1] + 1]++;
858  else if (new_elem[inter_elem[mesh->adapt_children_item[j * 2] - 1]] != -1)
859  send_adapt_child[tmp_int] =
860  new_elem[inter_elem[mesh->adapt_children_item[j * 2] - 1]];
861  else if (new_elem[inter_elem[mesh->adapt_children_item[j * 2] - 1]] ==
862  -1) {
863  fprintf(stderr, "There is something wrong with child information\n");
864  fprintf(stderr, "in PE %d i=%d, send_parent[i]=%d child is %d PE=%d\n",
865  mynode, i, send_parent[i], mesh->adapt_children_item[j * 2] - 1,
866  mesh->adapt_children_item[j * 2 + 1]);
867  HECMW_dlb_print_exit("Error in finding children inf");
868  }
869  }
870  }
871  for (i = 1; i < pesize + 1; i++) {
872  send_tmp_num[i] = send_tmp_num[i - 1] + send_tmp_num[i];
873  }
874 
875  stack_whole_send_recv(pesize, send_tmp_num, recv_tmp_num, mesh->HECMW_COMM,
876  mynode);
877  for (i = 0; i < pesize; i++) count_num[i] = 0;
878  if (send_tmp_num[pesize] > 0) {
879  send_tmp = (int *)calloc(send_tmp_num[pesize], sizeof(int));
880  if (send_tmp == NULL) HECMW_dlb_memory_exit("send_tmp");
881  }
882  if (recv_tmp_num[pesize] > 0) {
883  recv_tmp = (int *)calloc(recv_tmp_num[pesize], sizeof(int));
884  if (recv_tmp == NULL) HECMW_dlb_memory_exit("recv_tmp");
885  }
886  tmp_int = -1;
887  for (i = 0; i < send_parent_num[pesize]; i++) {
888  for (j = mesh->adapt_children_index[send_parent[i]];
889  j < mesh->adapt_children_index[send_parent[i] + 1]; j++) {
890  tmp_int++;
891  if (mesh->adapt_children_item[j * 2 + 1] < 0)
892  send_adapt_child[tmp_int] = -1;
893  else if (mesh->adapt_children_item[j * 2 + 1] != mynode) {
894  send_tmp[send_tmp_num[mesh->adapt_children_item[j * 2 + 1]] +
895  count_num[mesh->adapt_children_item[j * 2 + 1]]] =
896  inter_elem[mesh->adapt_children_item[j * 2] - 1];
897  count_num[mesh->adapt_children_item[j * 2 + 1]]++;
898  }
899  }
900  }
901  if (send_tmp_num[pesize] > 0)
902  int2_whole_send_recv(send_tmp_num[pesize], recv_tmp_num[pesize], pesize,
903  recv_tmp_num, send_tmp_num, send_tmp, recv_tmp,
904  mesh->HECMW_COMM, mynode);
905  for (i = 0; i < recv_tmp_num[pesize]; i++) {
906  if (new_elem[recv_tmp[i]] == -1)
907  HECMW_dlb_print_exit("There is something wrong in parents' children inf");
908  else
909  recv_tmp[i] = new_elem[recv_tmp[i]];
910  }
911  if (send_tmp_num[pesize] > 0)
912  int2_whole_send_recv(recv_tmp_num[pesize], send_tmp_num[pesize], pesize,
913  send_tmp_num, recv_tmp_num, recv_tmp, send_tmp,
914  mesh->HECMW_COMM, mynode);
915 
916  for (i = 0; i < pesize; i++) count_num[i] = 0;
917  tmp_int = -1;
918  for (i = 0; i < send_parent_num[pesize]; i++) {
919  send_index_child[i] = mesh->adapt_children_index[send_parent[i] + 1] -
920  mesh->adapt_children_index[send_parent[i]];
921  for (j = mesh->adapt_children_index[send_parent[i]];
922  j < mesh->adapt_children_index[send_parent[i] + 1]; j++) {
923  tmp_int++;
924  if (mesh->adapt_children_item[j * 2 + 1] < 0) {
925  send_adapt_child[tmp_int] = -1;
926  } else if (mesh->adapt_children_item[j * 2 + 1] != mynode) {
927  send_adapt_child[tmp_int] =
928  send_tmp[send_tmp_num[mesh->adapt_children_item[j * 2 + 1]] +
929  count_num[mesh->adapt_children_item[j * 2 + 1]]];
930  count_num[mesh->adapt_children_item[j * 2 + 1]]++;
931  } else if (new_elem[inter_elem[mesh->adapt_children_item[j * 2] - 1]] !=
932  -1)
933  send_adapt_child[tmp_int] =
934  new_elem[inter_elem[mesh->adapt_children_item[j * 2] - 1]];
935  else if (new_elem[inter_elem[mesh->adapt_children_item[j * 2] - 1]] ==
936  -1) {
937  fprintf(stderr, "There is something wrong with child information\n");
938  fprintf(stderr, "i=%d, send_elem[i]=%d child is %d PE=%d\n", i,
939  send_parent[i], mesh->adapt_children_item[j * 2] - 1,
940  mesh->adapt_children_item[j * 2 + 1]);
941  HECMW_dlb_print_exit("ERROR in finding parent elements' children inf");
942  }
943  }
944  }
945 
946  recv_adapt_child = (int *)calloc(recv2_adapt_child_num[pesize], sizeof(int));
947  if (recv_adapt_child == NULL) HECMW_dlb_memory_exit("recv_adapt_child");
948  int2_whole_send_recv(
949  send2_adapt_child_num[pesize], recv2_adapt_child_num[pesize], pesize,
950  recv2_adapt_child_num, send2_adapt_child_num, send_adapt_child,
951  recv_adapt_child, mesh->HECMW_COMM, mynode);
952 
953  int2_whole_send_recv(send_parent_num[pesize], recv_parent_num[pesize], pesize,
954  recv_parent_num, send_parent_num, send_index_child,
955  tmp2_int_recv, mesh->HECMW_COMM, mynode);
956 
957  for (i = 0; i < recv2_adapt_child_num[pesize]; i++) {
958  if (recv_adapt_child[i] == -1) {
959  new_mesh->adapt_children_item[(i + recv_adapt_child_num[pesize]) * 2] = 0;
960  new_mesh
961  ->adapt_children_item[(i + recv_adapt_child_num[pesize]) * 2 + 1] =
962  -1;
963  } else {
964  new_mesh->adapt_children_item[(i + recv_adapt_child_num[pesize]) * 2] =
965  (recv_adapt_child[i] % t_elem) + 1;
966  new_mesh
967  ->adapt_children_item[(i + recv_adapt_child_num[pesize]) * 2 + 1] =
968  recv_adapt_child[i] / t_elem;
969  }
970  }
971  new_mesh->adapt_children_index[recv_elem_num[pesize] + 1] =
972  new_mesh->adapt_children_index[recv_elem_num[pesize]] + tmp2_int_recv[0];
973  for (i = 1; i < recv_parent_num[pesize]; i++)
974  new_mesh->adapt_children_index[i + 1 + recv_elem_num[pesize]] =
975  new_mesh->adapt_children_index[i + recv_elem_num[pesize]] +
976  tmp2_int_recv[i];
977  if (send_tmp_num[pesize] > 0) free(send_tmp);
978  if (recv_tmp_num[pesize] > 0) free(recv_tmp);
979  if (send_parent_num[pesize] > 0) {
980  free(send_adapt_child);
981  free(recv_adapt_child);
982  free(send_index_child);
983  }
984 
985  /*---------------send elem_id --------------------------------*/
986 
987  if (new_mesh->n_elem > 0) {
988  new_mesh->elem_ID = (int *)calloc(2 * new_mesh->n_elem, sizeof(int));
989  if (new_mesh->elem_ID == NULL) HECMW_dlb_memory_exit("new_mesh: elem_id");
990  }
991 
992  tmp_int_send = (int *)calloc(send_elem_num[pesize] + 1, sizeof(int));
993 
994  if (tmp_int_send == NULL) HECMW_dlb_memory_exit("tmp_int_send ");
995  if (send_elem_num[pesize] > 0) {
996  for (i = 0; i < send_elem_num[pesize]; i++) tmp_int_send[i] = send_inter[i];
997  }
998  tmp_int_recv = (int *)calloc(recv_elem_num[pesize] + 1, sizeof(int));
999  if (tmp_int_recv == NULL) HECMW_dlb_memory_exit("tmp_int_recv");
1000 
1001  int2_whole_send_recv(send_elem_num[pesize], recv_elem_num[pesize], pesize,
1002  recv_elem_num, send_elem_num, tmp_int_send, tmp_int_recv,
1003  mesh->HECMW_COMM, mynode);
1004  if (recv_elem_num[pesize] > 0) {
1005  for (i = 0; i < recv_elem_num[pesize]; i++) {
1006  new_mesh->elem_ID[i * 2] = (tmp_int_recv[i] % t_elem) + 1;
1007  new_mesh->elem_ID[i * 2 + 1] = tmp_int_recv[i] / t_elem;
1008  }
1009  }
1010  tmp2_int_send = (int *)calloc(send_parent_num[pesize], sizeof(int));
1011  if (tmp2_int_send == NULL) HECMW_dlb_memory_exit("tmp2_int_send");
1012 
1013  for (i = 0; i < send_parent_num[pesize]; i++)
1014  tmp2_int_send[i] = send_parent_inter[i];
1015  int2_whole_send_recv(send_parent_num[pesize], recv_parent_num[pesize], pesize,
1016  recv_parent_num, send_parent_num, tmp2_int_send,
1017  tmp2_int_recv, mesh->HECMW_COMM, mynode);
1018  for (i = 0; i < recv_parent_num[pesize]; i++) {
1019  new_mesh->elem_ID[(i + recv_elem_num[pesize]) * 2] =
1020  (tmp2_int_recv[i] % t_elem) + 1;
1021  new_mesh->elem_ID[(i + recv_elem_num[pesize]) * 2 + 1] =
1022  tmp2_int_recv[i] / t_elem;
1023  }
1024 
1025  if (mynode == 0) fprintf(stderr, "Finish sending elem_id\n");
1026  if (mesh->n_elem > 0) {
1027  free(new_elem);
1028  free(send_inter);
1029  free(send_parent_inter);
1030  }
1031  /* ------ generate elem_internal_list and global_elem_id -------------- */
1032  new_mesh->ne_internal = recv_inter_num[pesize] + recv_parent_num[pesize];
1033  new_mesh->elem_internal_list =
1034  (int *)calloc(new_mesh->ne_internal, sizeof(int));
1035  if (new_mesh->elem_internal_list == NULL)
1036  HECMW_dlb_memory_exit("new_mesh: elem_internal_list");
1037  new_nelem_dist = (int *)calloc(pesize + 1, sizeof(int));
1038  if (new_nelem_dist == NULL) HECMW_dlb_memory_exit("new_nelem_dist");
1039  if (mynode == 0) {
1040  new_nelem_dist[0] = 0;
1041  new_nelem_dist[1] = new_mesh->ne_internal;
1042  tmp_sum = new_mesh->ne_internal;
1043  for (i = 1; i < pesize; i++) {
1044  HECMW_Recv(&tmp_int, 1, HECMW_INT, i, HECMW_ANY_TAG, mesh->HECMW_COMM,
1045  &stat);
1046  tmp_sum += tmp_int;
1047  new_nelem_dist[i + 1] = tmp_sum;
1048  }
1049  for (i = 1; i < pesize; i++)
1050  HECMW_Send(new_nelem_dist, pesize + 1, HECMW_INT, i, 0, mesh->HECMW_COMM);
1051  } else {
1052  HECMW_Send(&new_mesh->ne_internal, 1, HECMW_INT, 0, 0, mesh->HECMW_COMM);
1053  HECMW_Recv(new_nelem_dist, pesize + 1, HECMW_INT, 0, HECMW_ANY_TAG,
1054  mesh->HECMW_COMM, &stat);
1055  }
1056  new_mesh->global_elem_ID = (int *)calloc(new_mesh->n_elem, sizeof(int));
1057  if (new_mesh->global_elem_ID == NULL)
1058  HECMW_dlb_memory_exit("new_mesh: global_elem_ID");
1059 
1060  tmp_int = 0;
1061  for (i = 0; i < new_mesh->n_elem; i++) {
1062  new_mesh->global_elem_ID[i] =
1063  new_nelem_dist[new_mesh->elem_ID[i * 2 + 1]] + new_mesh->elem_ID[i * 2];
1064  if (new_mesh->elem_ID[i * 2 + 1] == mynode) {
1065  new_mesh->elem_internal_list[tmp_int] = i + 1;
1066  tmp_int++;
1067  }
1068  }
1069 
1070  /*---------------send elem_type --------------------------------*/
1071  if (new_mesh->n_elem > 0) {
1072  new_mesh->elem_type = (int *)calloc(new_mesh->n_elem, sizeof(int));
1073  if (new_mesh->elem_type == NULL)
1074  HECMW_dlb_memory_exit("new_mesh: elem_type");
1075  }
1076  if (send_elem_num[pesize] > 0) {
1077  for (i = 0; i < send_elem_num[pesize]; i++)
1078  tmp_int_send[i] = mesh->elem_type[send_elem[i]];
1079  }
1080  int2_whole_send_recv(send_elem_num[pesize], recv_elem_num[pesize], pesize,
1081  recv_elem_num, send_elem_num, tmp_int_send, tmp_int_recv,
1082  mesh->HECMW_COMM, mynode);
1083  for (i = 0; i < recv_elem_num[pesize]; i++)
1084  new_mesh->elem_type[i] = tmp_int_recv[i];
1085  for (i = 0; i < send_parent_num[pesize]; i++)
1086  tmp2_int_send[i] = mesh->elem_type[send_parent[i]];
1087  int2_whole_send_recv(send_parent_num[pesize], recv_parent_num[pesize], pesize,
1088  recv_parent_num, send_parent_num, tmp2_int_send,
1089  tmp2_int_recv, mesh->HECMW_COMM, mynode);
1090  for (i = 0; i < recv_parent_num[pesize]; i++)
1091  new_mesh->elem_type[i + recv_elem_num[pesize]] = tmp2_int_recv[i];
1092  if (mynode == 0) fprintf(stderr, "Finish sending elem_type\n");
1093 
1094  if (new_mesh->n_elem > 0) {
1095  new_mesh->section_ID = (int *)calloc(new_mesh->n_elem, sizeof(int));
1096  if (new_mesh->section_ID == NULL)
1097  HECMW_dlb_memory_exit("new_mesh: section_ID");
1098  }
1099  if (send_elem_num[pesize] > 0) {
1100  for (i = 0; i < send_elem_num[pesize]; i++)
1101  tmp_int_send[i] = mesh->section_ID[send_elem[i]];
1102  }
1103  int2_whole_send_recv(send_elem_num[pesize], recv_elem_num[pesize], pesize,
1104  recv_elem_num, send_elem_num, tmp_int_send, tmp_int_recv,
1105  mesh->HECMW_COMM, mynode);
1106  for (i = 0; i < recv_elem_num[pesize]; i++)
1107  new_mesh->section_ID[i] = tmp_int_recv[i];
1108  for (i = 0; i < send_parent_num[pesize]; i++)
1109  tmp2_int_send[i] = mesh->section_ID[send_parent[i]];
1110  int2_whole_send_recv(send_parent_num[pesize], recv_parent_num[pesize], pesize,
1111  recv_parent_num, send_parent_num, tmp2_int_send,
1112  tmp2_int_recv, mesh->HECMW_COMM, mynode);
1113  for (i = 0; i < recv_parent_num[pesize]; i++)
1114  new_mesh->section_ID[i + recv_elem_num[pesize]] = tmp2_int_recv[i];
1115  if (mynode == 0) fprintf(stderr, "Finish sending section_ID\n");
1116 
1117  /* ---------- send material inf. ---------------- */
1118  if (new_mesh->n_elem > 0) {
1119  if (mesh->elem_mat_int_val != NULL) {
1120  new_mesh->elem_mat_int_val =
1121  (double *)calloc(new_mesh->n_elem, sizeof(double));
1122  if (new_mesh->elem_mat_int_val == NULL)
1123  HECMW_dlb_memory_exit("new_mesh: elem_mat_int_val");
1124  tmp_send_d = (double *)calloc(send_elem_num[pesize] + 1, sizeof(double));
1125  tmp_recv_d = (double *)calloc(recv_elem_num[pesize] + 1, sizeof(double));
1126  if (tmp_send_d == NULL) HECMW_dlb_memory_exit("tmp_send_d");
1127  if (send_elem_num[pesize] > 0) {
1128  for (i = 0; i < send_elem_num[pesize]; i++)
1129  tmp_send_d[i] = mesh->elem_mat_int_val[send_elem[i]];
1130  }
1131  double2_whole_send_recv(send_elem_num[pesize], recv_elem_num[pesize],
1132  pesize, recv_elem_num, send_elem_num, tmp_send_d,
1133  tmp_recv_d, mesh->HECMW_COMM, mynode);
1134  for (i = 0; i < recv_elem_num[pesize]; i++)
1135  new_mesh->elem_mat_int_val[i] = tmp_recv_d[i];
1136  free(tmp_send_d);
1137  free(tmp_recv_d);
1138  tmp2_send_d =
1139  (double *)calloc(send_parent_num[pesize] + 1, sizeof(double));
1140  tmp2_recv_d =
1141  (double *)calloc(recv_parent_num[pesize] + 1, sizeof(double));
1142  if (tmp2_send_d == NULL) HECMW_dlb_memory_exit("tmp2_send_d");
1143 
1144  for (i = 0; i < send_parent_num[pesize]; i++)
1145  tmp2_send_d[i] = mesh->elem_mat_int_val[send_parent[i]];
1146  double2_whole_send_recv(send_parent_num[pesize], recv_parent_num[pesize],
1147  pesize, recv_parent_num, send_parent_num,
1148  tmp2_send_d, tmp2_recv_d, mesh->HECMW_COMM,
1149  mynode);
1150  for (i = 0; i < recv_parent_num[pesize]; i++)
1151  new_mesh->elem_mat_int_val[i + recv_elem_num[pesize]] = tmp2_recv_d[i];
1152  free(tmp2_send_d);
1153  free(tmp2_recv_d);
1154  }
1155  }
1156  if (new_mesh->n_elem > 0) {
1157  new_mesh->elem_mat_ID_index =
1158  (int *)calloc(new_mesh->n_elem + 1, sizeof(int));
1159  new_mesh->elem_mat_ID_item = (int *)calloc(new_mesh->n_elem, sizeof(int));
1160  if ((new_mesh->elem_mat_ID_index == NULL) ||
1161  (new_mesh->elem_mat_ID_item == NULL))
1162  HECMW_dlb_memory_exit("new_mesh: elem_mat_ID_index, elem_mat_ID_item");
1163  new_mesh->elem_mat_ID_index[0] = 0;
1164  for (i = 0; i < new_mesh->n_elem; i++) {
1165  new_mesh->elem_mat_ID_item[i] = 1;
1166  new_mesh->elem_mat_ID_index[i + 1] = i + 1;
1167  }
1168  }
1169 
1170  if (mynode == 0) fprintf(stderr, "Finish sending elem_material inf\n");
1171 
1172  /*---------------send adaptation_level --------------------------------*/
1173  new_mesh->coarse_grid_level = mesh->coarse_grid_level;
1174  new_mesh->n_adapt = mesh->n_adapt;
1175  new_mesh->adapt_level = (int *)calloc(new_mesh->n_elem, sizeof(int));
1176  if (new_mesh->adapt_level == NULL)
1177  HECMW_dlb_memory_exit("new_mesh: adapt_level");
1178 
1179  for (i = 0; i < send_elem_num[pesize]; i++)
1180  tmp_int_send[i] = mesh->adapt_level[send_elem[i]];
1181  int2_whole_send_recv(send_elem_num[pesize], recv_elem_num[pesize], pesize,
1182  recv_elem_num, send_elem_num, tmp_int_send, tmp_int_recv,
1183  mesh->HECMW_COMM, mynode);
1184  for (i = 0; i < recv_elem_num[pesize]; i++)
1185  new_mesh->adapt_level[i] = tmp_int_recv[i];
1186 
1187  for (i = 0; i < send_parent_num[pesize]; i++)
1188  tmp2_int_send[i] = mesh->adapt_level[send_parent[i]];
1189  int2_whole_send_recv(send_parent_num[pesize], recv_parent_num[pesize], pesize,
1190  recv_parent_num, send_parent_num, tmp2_int_send,
1191  tmp2_int_recv, mesh->HECMW_COMM, mynode);
1192  for (i = 0; i < recv_parent_num[pesize]; i++)
1193  new_mesh->adapt_level[i + recv_elem_num[pesize]] = tmp2_int_recv[i];
1194  if (mynode == 0) fprintf(stderr, "Finish sending adaptation_level\n");
1195  /*---------------send adaptation_type --------------------------------*/
1196  new_mesh->adapt_type = (int *)calloc(new_mesh->n_elem, sizeof(int));
1197  if (new_mesh->adapt_type == NULL)
1198  HECMW_dlb_memory_exit("new_mesh: adapt_type");
1199 
1200  for (i = 0; i < send_elem_num[pesize]; i++)
1201  tmp_int_send[i] = mesh->adapt_type[send_elem[i]];
1202  int2_whole_send_recv(send_elem_num[pesize], recv_elem_num[pesize], pesize,
1203  recv_elem_num, send_elem_num, tmp_int_send, tmp_int_recv,
1204  mesh->HECMW_COMM, mynode);
1205  for (i = 0; i < recv_elem_num[pesize]; i++)
1206  new_mesh->adapt_type[i] = tmp_int_recv[i];
1207 
1208  for (i = 0; i < send_parent_num[pesize]; i++)
1209  tmp2_int_send[i] = mesh->adapt_type[send_parent[i]];
1210  int2_whole_send_recv(send_parent_num[pesize], recv_parent_num[pesize], pesize,
1211  recv_parent_num, send_parent_num, tmp2_int_send,
1212  tmp2_int_recv, mesh->HECMW_COMM, mynode);
1213  for (i = 0; i < recv_parent_num[pesize]; i++)
1214  new_mesh->adapt_type[i + recv_elem_num[pesize]] = tmp2_int_recv[i];
1215  if (mynode == 0) fprintf(stderr, "Finish sending adaptation_type\n");
1216 
1217  /* send wheniwasrefined elem ------------- */
1218  new_mesh->when_i_was_refined_elem =
1219  (int *)calloc(new_mesh->n_elem, sizeof(int));
1220  if (new_mesh->when_i_was_refined_elem == NULL)
1221  HECMW_dlb_memory_exit("new_mesh: when_i_was_refined_elem");
1222 
1223  for (i = 0; i < send_elem_num[pesize]; i++)
1224  tmp_int_send[i] = mesh->when_i_was_refined_elem[send_elem[i]];
1225  int2_whole_send_recv(send_elem_num[pesize], recv_elem_num[pesize], pesize,
1226  recv_elem_num, send_elem_num, tmp_int_send, tmp_int_recv,
1227  mesh->HECMW_COMM, mynode);
1228  for (i = 0; i < recv_elem_num[pesize]; i++)
1229  new_mesh->when_i_was_refined_elem[i] = tmp_int_recv[i];
1230 
1231  for (i = 0; i < send_parent_num[pesize]; i++)
1232  tmp2_int_send[i] = mesh->when_i_was_refined_elem[send_parent[i]];
1233  int2_whole_send_recv(send_parent_num[pesize], recv_parent_num[pesize], pesize,
1234  recv_parent_num, send_parent_num, tmp2_int_send,
1235  tmp2_int_recv, mesh->HECMW_COMM, mynode);
1236  for (i = 0; i < recv_parent_num[pesize]; i++)
1237  new_mesh->when_i_was_refined_elem[i + recv_elem_num[pesize]] =
1238  tmp2_int_recv[i];
1239  if (mynode == 0) fprintf(stderr, "Finish sending when_i_was_refined_elem\n");
1240 
1241  /* ------- send elem_index -------- */
1242  if (new_mesh->n_elem > 0) {
1243  new_mesh->elem_node_index =
1244  (long long *)calloc(new_mesh->n_elem + 1, sizeof(long long));
1245  if (new_mesh->elem_node_index == NULL)
1246  HECMW_dlb_memory_exit("new_mesh: elem_node_index");
1247  }
1248  for (i = 0; i < send_elem_num[pesize]; i++)
1249  tmp_int_send[i] = (int)(mesh->elem_node_index[send_elem[i] + 1] -
1250  mesh->elem_node_index[send_elem[i]]);
1251  int2_whole_send_recv(send_elem_num[pesize], recv_elem_num[pesize], pesize,
1252  recv_elem_num, send_elem_num, tmp_int_send, tmp_int_recv,
1253  mesh->HECMW_COMM, mynode);
1254  for (i = 0; i < send_parent_num[pesize]; i++)
1255  tmp2_int_send[i] = (int)(mesh->elem_node_index[send_parent[i] + 1] -
1256  mesh->elem_node_index[send_parent[i]]);
1257  int2_whole_send_recv(send_parent_num[pesize], recv_parent_num[pesize], pesize,
1258  recv_parent_num, send_parent_num, tmp2_int_send,
1259  tmp2_int_recv, mesh->HECMW_COMM, mynode);
1260 
1261  if (new_mesh->n_elem > 0) {
1262  new_mesh->elem_node_index[0] = 0;
1263  for (i = 0; i < recv_elem_num[pesize]; i++)
1264  new_mesh->elem_node_index[i + 1] =
1265  new_mesh->elem_node_index[i] + tmp_int_recv[i];
1266  for (i = 0; i < recv_parent_num[pesize]; i++)
1267  new_mesh->elem_node_index[recv_elem_num[pesize] + 1 + i] =
1268  tmp2_int_recv[i] +
1269  new_mesh->elem_node_index[recv_elem_num[pesize] + i];
1270  }
1271 
1272  if (mynode == 0) fprintf(stderr, "Finish sending elem_node_index\n");
1273  /* -------------- send elem_node_item -------------------------------------
1274  */
1275  send_ptr_num = (int *)calloc(pesize + 1, sizeof(int));
1276  send_ptr_parent_num = (int *)calloc(pesize + 1, sizeof(int));
1277  recv_ptr_num = (int *)calloc(pesize + 1, sizeof(int));
1278  recv_ptr_parent_num = (int *)calloc(pesize + 1, sizeof(int));
1279  if ((send_ptr_num == NULL) || (send_ptr_parent_num == NULL) ||
1280  (recv_ptr_num == NULL) || (recv_ptr_parent_num == NULL))
1281  HECMW_dlb_memory_exit("send_recv_ptr_num, send_recv_parent_ptr_num");
1282  for (i = 0; i < pesize + 1; i++) {
1283  send_ptr_num[i] = 0;
1284  send_ptr_parent_num[i] = 0;
1285  }
1286  for (i = 1; i < pesize + 1; i++) {
1287  for (j = send_elem_num[i - 1]; j < send_elem_num[i]; j++)
1288  send_ptr_num[i] += tmp_int_send[j];
1289  }
1290  for (i = 1; i < pesize + 1; i++)
1291  send_ptr_num[i] = send_ptr_num[i - 1] + send_ptr_num[i];
1292  for (i = 1; i < pesize + 1; i++) {
1293  for (j = send_parent_num[i - 1]; j < send_parent_num[i]; j++)
1294  send_ptr_parent_num[i] += tmp2_int_send[j];
1295  }
1296  for (i = 1; i < pesize + 1; i++)
1297  send_ptr_parent_num[i] =
1298  send_ptr_parent_num[i - 1] + send_ptr_parent_num[i];
1299 
1300  stack_whole_send_recv(pesize, send_ptr_num, recv_ptr_num, mesh->HECMW_COMM,
1301  mynode);
1302  stack_whole_send_recv(pesize, send_ptr_parent_num, recv_ptr_parent_num,
1303  mesh->HECMW_COMM, mynode);
1304 
1305  new_mesh->node_group =
1306  (struct hecmwST_node_grp *)calloc(1, sizeof(struct hecmwST_node_grp));
1307  new_mesh->elem_group =
1308  (struct hecmwST_elem_grp *)calloc(1, sizeof(struct hecmwST_elem_grp));
1309  new_mesh->surf_group =
1310  (struct hecmwST_surf_grp *)calloc(1, sizeof(struct hecmwST_surf_grp));
1311 
1312  new_mesh->node_group->n_grp = mesh->node_group->n_grp;
1313  new_mesh->elem_group->n_grp = mesh->elem_group->n_grp;
1314  new_mesh->surf_group->n_grp = mesh->surf_group->n_grp;
1315  if (mesh->node_group->n_grp > 0) {
1316  new_mesh->node_group->grp_name =
1317  (char **)calloc(mesh->node_group->n_grp, sizeof(char *));
1318  for (m = 0; m < mesh->node_group->n_grp; m++) {
1319  new_mesh->node_group->grp_name[m] = (char *)calloc(name_buf_size, sizeof(char));
1320  if (new_mesh->node_group->grp_name[m] == NULL)
1321  HECMW_dlb_memory_exit("new_mesh: grp_name");
1322  snprintf(new_mesh->node_group->grp_name[m], name_buf_size, "%s",
1323  mesh->node_group->grp_name[m]);
1324  }
1325  }
1326  if (mesh->elem_group->n_grp > 0) {
1327  new_mesh->elem_group->grp_name =
1328  (char **)calloc(mesh->elem_group->n_grp, sizeof(char *));
1329  for (m = 0; m < mesh->elem_group->n_grp; m++) {
1330  new_mesh->elem_group->grp_name[m] = (char *)calloc(name_buf_size, sizeof(char));
1331  if (new_mesh->elem_group->grp_name[m] == NULL)
1332  HECMW_dlb_memory_exit("new_mesh: grp_name");
1333  snprintf(new_mesh->elem_group->grp_name[m], name_buf_size, "%s",
1334  mesh->elem_group->grp_name[m]);
1335  }
1336  }
1337  if (mesh->surf_group->n_grp > 0) {
1338  new_mesh->surf_group->grp_name =
1339  (char **)calloc(mesh->surf_group->n_grp, sizeof(char *));
1340  for (m = 0; m < mesh->surf_group->n_grp; m++) {
1341  new_mesh->surf_group->grp_name[m] = (char *)calloc(name_buf_size, sizeof(char));
1342  if (new_mesh->surf_group->grp_name[m] == NULL)
1343  HECMW_dlb_memory_exit("new_mesh: grp_name");
1344  snprintf(new_mesh->surf_group->grp_name[m], name_buf_size, "%s",
1345  mesh->surf_group->grp_name[m]);
1346  }
1347  }
1348 
1349  if (new_mesh->elem_group->n_grp > 0) {
1350  tmp_grp =
1351  (Tmp_grp_inf *)calloc(new_mesh->elem_group->n_grp, sizeof(Tmp_grp_inf));
1352  if (tmp_grp == NULL) HECMW_dlb_memory_exit("tmp_grp");
1353  /*
1354  tmp_int_send=(int *)calloc(send_elem_num[pesize]+1,
1355  sizeof(int));
1356  if(tmp_int_send==NULL)
1357  HECMW_dlb_memory_exit("tmp_int_send ");
1358  tmp_int_recv=(int *)calloc(recv_elem_num[pesize]+1,
1359  sizeof(int));
1360  if(tmp_int_recv==NULL)
1361  HECMW_dlb_memory_exit("tmp_int_recv");
1362  tmp2_int_send=(int *)calloc(send_parent_num[pesize]+1,
1363  sizeof(int));
1364  if(tmp2_int_send==NULL)
1365  HECMW_dlb_memory_exit("tmp2_int_send ");
1366  tmp2_int_recv=(int *)calloc(recv_parent_num[pesize]+1,
1367  sizeof(int));
1368  if(tmp2_int_recv==NULL)
1369  HECMW_dlb_memory_exit("tmp2_int_recv");
1370  */
1371 
1372  for (m = 0; m < new_mesh->elem_group->n_grp; m++)
1373  tmp_grp[m].num_of_item = 0;
1374  for (m = 0; m < new_mesh->elem_group->n_grp; m++) {
1375  if (m == 0) {
1376  tmp_elem_grp = (int *)calloc(mesh->n_elem, sizeof(int));
1377  if (tmp_elem_grp == NULL) HECMW_dlb_memory_exit("tmp_elem_grp");
1378  }
1379  for (i = 0; i < mesh->n_elem; i++) tmp_elem_grp[i] = 0;
1380  if ((mesh->elem_group->grp_index[m + 1] -
1381  mesh->elem_group->grp_index[m]) > 0) {
1382  for (i = mesh->elem_group->grp_index[m];
1383  i < mesh->elem_group->grp_index[m + 1]; i++)
1384  tmp_elem_grp[mesh->elem_group->grp_item[i] - 1] = 1;
1385  }
1386  if (send_elem_num[pesize] > 0) {
1387  for (i = 0; i < send_elem_num[pesize]; i++)
1388  tmp_int_send[i] = tmp_elem_grp[send_elem[i]];
1389  int2_whole_send_recv(send_elem_num[pesize], recv_elem_num[pesize],
1390  pesize, recv_elem_num, send_elem_num, tmp_int_send,
1391  tmp_int_recv, mesh->HECMW_COMM, mynode);
1392  }
1393  if (send_parent_num[pesize] > 0) {
1394  for (i = 0; i < send_parent_num[pesize]; i++)
1395  tmp2_int_send[i] = tmp_elem_grp[send_parent[i]];
1396  int2_whole_send_recv(send_parent_num[pesize], recv_parent_num[pesize],
1397  pesize, recv_parent_num, send_parent_num,
1398  tmp2_int_send, tmp2_int_recv, mesh->HECMW_COMM,
1399  mynode);
1400  }
1401  num_grp_item = 0;
1402  for (i = 0; i < recv_elem_num[pesize]; i++) {
1403  if (tmp_int_recv[i] == 1) num_grp_item++;
1404  }
1405  for (i = 0; i < recv_parent_num[pesize]; i++) {
1406  if (tmp2_int_recv[i] == 1) num_grp_item++;
1407  }
1408  tmp_grp[m].num_of_item = num_grp_item;
1409  if (num_grp_item > 0) {
1410  tmp_grp[m].item = (int *)calloc(num_grp_item, sizeof(int));
1411  if (tmp_grp[m].item == NULL) HECMW_dlb_memory_exit("tmp_grp:item");
1412  tmp_int = 0;
1413  for (i = 0; i < recv_elem_num[pesize]; i++) {
1414  if (tmp_int_recv[i] == 1) {
1415  tmp_grp[m].item[tmp_int] = i + 1;
1416  tmp_int++;
1417  }
1418  }
1419  for (i = 0; i < recv_parent_num[pesize]; i++) {
1420  if (tmp2_int_recv[i] == 1) {
1421  tmp_grp[m].item[tmp_int] = recv_elem_num[pesize] + i + 1;
1422  tmp_int++;
1423  }
1424  }
1425  }
1426  }
1427 
1428  free(tmp_elem_grp);
1429  num_grp_item = 0;
1430  for (m = 0; m < new_mesh->elem_group->n_grp; m++)
1431  num_grp_item += tmp_grp[m].num_of_item;
1432  new_mesh->elem_group->grp_index =
1433  (int *)calloc(new_mesh->elem_group->n_grp + 1, sizeof(int));
1434  if (new_mesh->elem_group->grp_index == NULL)
1435  HECMW_dlb_memory_exit("new_mesh: elem_grp: grp_index");
1436  new_mesh->elem_group->grp_index[0] = 0;
1437  for (m = 0; m < new_mesh->elem_group->n_grp; m++)
1438  new_mesh->elem_group->grp_index[m + 1] =
1439  new_mesh->elem_group->grp_index[m] + tmp_grp[m].num_of_item;
1440  if (num_grp_item > 0) {
1441  new_mesh->elem_group->grp_item = (int *)calloc(num_grp_item, sizeof(int));
1442  if (new_mesh->elem_group->grp_item == NULL)
1443  HECMW_dlb_memory_exit("new_mesh: elem_grp: grp_item");
1444  tmp_int = 0;
1445  for (m = 0; m < new_mesh->elem_group->n_grp; m++) {
1446  for (i = 0; i < tmp_grp[m].num_of_item; i++) {
1447  new_mesh->elem_group->grp_item[tmp_int] = tmp_grp[m].item[i];
1448  tmp_int++;
1449  }
1450  }
1451  }
1452  for (m = 0; m < new_mesh->elem_group->n_grp; m++) {
1453  if (tmp_grp[m].num_of_item > 0) free(tmp_grp[m].item);
1454  }
1455  free(tmp_grp);
1456  if (mynode == 0) fprintf(stderr, "Finish generating new elem_grp inf.\n");
1457  }
1458 
1459  if (new_mesh->surf_group->n_grp > 0) {
1460  tmp_grp =
1461  (Tmp_grp_inf *)calloc(new_mesh->surf_group->n_grp, sizeof(Tmp_grp_inf));
1462  if (tmp_grp == NULL) HECMW_dlb_memory_exit("tmp_grp");
1463 
1464  tmp_surf_id = (int *)calloc(recv_elem_num[pesize] + 1, sizeof(int));
1465  if (tmp_surf_id == NULL) HECMW_dlb_memory_exit("tmp_surf_id");
1466  tmp2_surf_id = (int *)calloc(recv_parent_num[pesize] + 1, sizeof(int));
1467  if (tmp2_surf_id == NULL) HECMW_dlb_memory_exit("tmp2_surf_id");
1468 
1469  for (m = 0; m < new_mesh->surf_group->n_grp; m++)
1470  tmp_grp[m].num_of_item = 0;
1471  for (m = 0; m < new_mesh->surf_group->n_grp; m++) {
1472  if (m == 0) {
1473  tmp_elem_grp = (int *)calloc(mesh->n_elem, sizeof(int));
1474  if (tmp_elem_grp == NULL) HECMW_dlb_memory_exit("tmp_elem_grp");
1475  tmp_surf_grp = (int *)calloc(mesh->n_elem, sizeof(int));
1476  if (tmp_surf_grp == NULL) HECMW_dlb_memory_exit("tmp_surf_grp");
1477  }
1478  for (i = 0; i < mesh->n_elem; i++) tmp_elem_grp[i] = 0;
1479  for (i = 0; i < mesh->n_elem; i++) tmp_surf_grp[i] = -1;
1480  if ((mesh->surf_group->grp_index[m + 1] -
1481  mesh->surf_group->grp_index[m]) > 0) {
1482  for (i = mesh->surf_group->grp_index[m];
1483  i < mesh->surf_group->grp_index[m + 1]; i++) {
1484  tmp_elem_grp[mesh->surf_group->grp_item[i * 2] - 1] = 1;
1485  tmp_surf_grp[mesh->surf_group->grp_item[i * 2] - 1] =
1486  mesh->surf_group->grp_item[i * 2 + 1];
1487  }
1488  }
1489  if (send_elem_num[pesize] > 0) {
1490  for (i = 0; i < send_elem_num[pesize]; i++)
1491  tmp_int_send[i] = tmp_elem_grp[send_elem[i]];
1492  int2_whole_send_recv(send_elem_num[pesize], recv_elem_num[pesize],
1493  pesize, recv_elem_num, send_elem_num, tmp_int_send,
1494  tmp_int_recv, mesh->HECMW_COMM, mynode);
1495  for (i = 0; i < send_elem_num[pesize]; i++)
1496  tmp_int_send[i] = tmp_surf_grp[send_elem[i]];
1497  int2_whole_send_recv(send_elem_num[pesize], recv_elem_num[pesize],
1498  pesize, recv_elem_num, send_elem_num, tmp_int_send,
1499  tmp_surf_id, mesh->HECMW_COMM, mynode);
1500  }
1501  if (send_parent_num[pesize] > 0) {
1502  for (i = 0; i < send_parent_num[pesize]; i++)
1503  tmp2_int_send[i] = tmp_elem_grp[send_parent[i]];
1504  int2_whole_send_recv(send_parent_num[pesize], recv_parent_num[pesize],
1505  pesize, recv_parent_num, send_parent_num,
1506  tmp2_int_send, tmp2_int_recv, mesh->HECMW_COMM,
1507  mynode);
1508  for (i = 0; i < send_parent_num[pesize]; i++)
1509  tmp2_int_send[i] = tmp_surf_grp[send_parent[i]];
1510  int2_whole_send_recv(send_parent_num[pesize], recv_parent_num[pesize],
1511  pesize, recv_parent_num, send_parent_num,
1512  tmp2_int_send, tmp2_surf_id, mesh->HECMW_COMM,
1513  mynode);
1514  }
1515  num_grp_item = 0;
1516  for (i = 0; i < recv_elem_num[pesize]; i++) {
1517  if (tmp_int_recv[i] == 1) num_grp_item++;
1518  }
1519  for (i = 0; i < recv_parent_num[pesize]; i++) {
1520  if (tmp2_int_recv[i] == 1) num_grp_item++;
1521  }
1522  tmp_grp[m].num_of_item = num_grp_item;
1523  if (num_grp_item > 0) {
1524  tmp_grp[m].item = (int *)calloc(num_grp_item * 2, sizeof(int));
1525  if (tmp_grp[m].item == NULL) HECMW_dlb_memory_exit("tmp_grp:item");
1526  tmp_int = 0;
1527  for (i = 0; i < recv_elem_num[pesize]; i++) {
1528  if (tmp_int_recv[i] == 1) {
1529  tmp_grp[m].item[tmp_int * 2] = i + 1;
1530  tmp_grp[m].item[tmp_int * 2 + 1] = tmp_surf_id[i];
1531  tmp_int++;
1532  }
1533  }
1534  for (i = 0; i < recv_parent_num[pesize]; i++) {
1535  if (tmp2_int_recv[i] == 1) {
1536  tmp_grp[m].item[tmp_int * 2] = recv_elem_num[pesize] + i + 1;
1537  tmp_grp[m].item[tmp_int * 2 + 1] = tmp2_surf_id[i];
1538 
1539  tmp_int++;
1540  }
1541  }
1542  }
1543  }
1544 
1545  free(tmp_elem_grp);
1546  free(tmp_surf_grp);
1547  free(tmp2_surf_id);
1548  free(tmp_surf_id);
1549  num_grp_item = 0;
1550  for (m = 0; m < new_mesh->surf_group->n_grp; m++)
1551  num_grp_item += tmp_grp[m].num_of_item;
1552  new_mesh->surf_group->grp_index =
1553  (int *)calloc(new_mesh->surf_group->n_grp + 1, sizeof(int));
1554  if (new_mesh->surf_group->grp_index == NULL)
1555  HECMW_dlb_memory_exit("new_mesh: surf_grp: grp_index");
1556  new_mesh->surf_group->grp_index[0] = 0;
1557  for (m = 0; m < new_mesh->surf_group->n_grp; m++)
1558  new_mesh->surf_group->grp_index[m + 1] =
1559  new_mesh->surf_group->grp_index[m] + tmp_grp[m].num_of_item;
1560  if (num_grp_item > 0) {
1561  new_mesh->surf_group->grp_item =
1562  (int *)calloc(num_grp_item * 2, sizeof(int));
1563  if (new_mesh->surf_group->grp_item == NULL)
1564  HECMW_dlb_memory_exit("new_mesh: surf_grp: grp_item");
1565  tmp_int = 0;
1566  for (m = 0; m < new_mesh->surf_group->n_grp; m++) {
1567  for (i = 0; i < tmp_grp[m].num_of_item; i++) {
1568  new_mesh->surf_group->grp_item[tmp_int * 2] = tmp_grp[m].item[i * 2];
1569  new_mesh->surf_group->grp_item[tmp_int * 2 + 1] =
1570  tmp_grp[m].item[i * 2 + 1];
1571  tmp_int++;
1572  }
1573  }
1574  }
1575  for (m = 0; m < new_mesh->surf_group->n_grp; m++) {
1576  if (tmp_grp[m].num_of_item > 0) free(tmp_grp[m].item);
1577  }
1578  free(tmp_grp);
1579  if (mynode == 0) fprintf(stderr, "Finish generating new surf_grp inf.\n");
1580  }
1581 
1582  if (tmp_int_send != NULL) free(tmp_int_send);
1583  if (tmp2_int_send != NULL) free(tmp2_int_send);
1584 
1585  /* recv_index_int=0;
1586  for(i=0;i<recv_elem_num[pesize];i++)
1587  recv_index_int+=tmp_int_recv[i];
1588  recv2_index_int=0;
1589  for(i=0;i<recv_parent_num[pesize];i++)
1590  recv2_index_int+=tmp2_int_recv[i];
1591 */
1592  if (tmp_int_recv != NULL) free(tmp_int_recv);
1593  if (tmp2_int_recv != NULL) free(tmp2_int_recv);
1594  tmp_int_send = (int *)calloc(send_ptr_num[pesize], sizeof(int));
1595  tmp_int_nodeid = (int *)calloc(recv_ptr_num[pesize], sizeof(int));
1596 
1597  if ((tmp_int_send == NULL) || (tmp_int_nodeid == NULL))
1598  HECMW_dlb_memory_exit("tmp_int_send, tmp_int_nodeid for ptr_elem sending");
1599  /* for(i=0;i<pesize+1;i++)
1600  fprintf(stderr, "vtxdist=== %d ", vtxdist[i]);
1601  fprintf(stderr, "\n");
1602  */
1603  tmp_int = 0;
1604  {
1605  long long jj;
1606  for (i = 0; i < send_elem_num[pesize]; i++) {
1607  for (jj = mesh->elem_node_index[send_elem[i]];
1608  jj < mesh->elem_node_index[send_elem[i] + 1]; jj++) {
1609  tmp_int_send[tmp_int] =
1610  mesh->node_ID[(mesh->elem_node_item[jj] - 1) * 2] - 1 +
1611  vtxdist[mesh->node_ID[(mesh->elem_node_item[jj] - 1) * 2 + 1]];
1612  tmp_int++;
1613  }
1614  }
1615  }
1616 
1617  int2_whole_send_recv(send_ptr_num[pesize], recv_ptr_num[pesize], pesize,
1618  recv_ptr_num, send_ptr_num, tmp_int_send, tmp_int_nodeid,
1619  mesh->HECMW_COMM, mynode);
1620  tmp2_int_send = (int *)calloc(send_ptr_parent_num[pesize], sizeof(int));
1621  tmp2_int_nodeid = (int *)calloc(recv_ptr_parent_num[pesize], sizeof(int));
1622 
1623  if ((tmp2_int_send == NULL) || (tmp2_int_nodeid == NULL))
1624  HECMW_dlb_memory_exit("tmp_int_send, tmp_int_nodeid for ptr_elem sending");
1625  tmp_int = 0;
1626  {
1627  long long jj;
1628  for (i = 0; i < send_parent_num[pesize]; i++) {
1629  for (jj = mesh->elem_node_index[send_parent[i]];
1630  jj < mesh->elem_node_index[send_parent[i] + 1]; jj++) {
1631  tmp2_int_send[tmp_int] =
1632  mesh->node_ID[(mesh->elem_node_item[jj] - 1) * 2] - 1 +
1633  vtxdist[mesh->node_ID[(mesh->elem_node_item[jj] - 1) * 2 + 1]];
1634  tmp_int++;
1635  }
1636  }
1637  }
1638 
1639  int2_whole_send_recv(send_ptr_parent_num[pesize], recv_ptr_parent_num[pesize],
1640  pesize, recv_ptr_parent_num, send_ptr_parent_num,
1641  tmp2_int_send, tmp2_int_nodeid, mesh->HECMW_COMM,
1642  mynode);
1643  free(tmp_int_send);
1644  free(tmp2_int_send);
1645 
1646  HECMW_Barrier(mesh->HECMW_COMM);
1647 
1648  /* --------- start to find import_nodes according to tmp_int_nodeid,
1649  * tmp_int_peid, tmp_int_repart -------*/
1650  /* first building global_index according to node redistribution */
1651  send_node_num = (int *)calloc(pesize + 1, sizeof(int));
1652  count_node = (int *)calloc(pesize, sizeof(int));
1653  send_node = (int *)calloc(mesh->nn_internal, sizeof(int));
1654  recv_node_num = (int *)calloc(pesize + 1, sizeof(int));
1655  if ((send_node_num == NULL) || (count_node == NULL) || (send_node == NULL) ||
1656  (recv_node_num == NULL))
1657  HECMW_dlb_memory_exit(
1658  "send_node_num, count_node, send_node, and recv_node_num");
1659  for (i = 0; i < pesize + 1; i++) {
1660  send_node_num[i] = 0;
1661  }
1662  for (i = 0; i < mesh->nn_internal; i++) {
1663  send_node_num[result->part[i] + 1]++;
1664  }
1665  for (i = 1; i < pesize + 1; i++)
1666  send_node_num[i] = send_node_num[i - 1] + send_node_num[i];
1667  for (i = 0; i < pesize; i++) count_node[i] = 0;
1668  for (i = 0; i < mesh->nn_internal; i++) {
1669  send_node[send_node_num[result->part[i]] + count_node[result->part[i]]] = i;
1670  count_node[result->part[i]]++;
1671  }
1672  tmp_node = (int *)calloc(send_node_num[pesize] + 1, sizeof(int));
1673  for (i = 0; i < send_node_num[pesize]; i++)
1674  tmp_node[i] = vtxdist[mynode] + send_node[i];
1675 
1676  stack_whole_send_recv(pesize, send_node_num, recv_node_num, mesh->HECMW_COMM,
1677  mynode);
1678  recv_node = (int *)calloc(recv_node_num[pesize] + 1, sizeof(int));
1679  if (recv_node == NULL) HECMW_dlb_memory_exit("recv_elem");
1680  int2_whole_send_recv(send_node_num[pesize], recv_node_num[pesize], pesize,
1681  recv_node_num, send_node_num, tmp_node, recv_node,
1682  mesh->HECMW_COMM, mynode);
1683  global_index = (int *)calloc(result->t_node, sizeof(int));
1684  global_index_hit = (int *)calloc(result->t_node, sizeof(int));
1685  if ((global_index == NULL) || (global_index_hit == NULL))
1686  HECMW_dlb_memory_exit("global_index");
1687  for (i = 0; i < result->t_node; i++) {
1688  global_index[i] = -1;
1689  global_index_hit[i] = -1;
1690  }
1691  for (i = 0; i < recv_node_num[pesize]; i++) {
1692  if (recv_node[i] >= result->t_node)
1693  HECMW_dlb_print_exit("!!!! wrong in recv_node");
1694  global_index[recv_node[i]] = mynode * result->t_node + i;
1695  global_index_hit[recv_node[i]] = i;
1696  }
1697  free(tmp_node);
1698 
1699  /*
1700  if(mynode>=0) {
1701  */
1702  if (mynode == 0) {
1703  tmp_recv = (int *)calloc(result->t_node, sizeof(int));
1704  if (tmp_recv == NULL) HECMW_dlb_memory_exit("tmp_recv");
1705  for (i = 1; i < pesize; i++) {
1706  HECMW_Recv(tmp_recv, result->t_node, HECMW_INT, i, HECMW_ANY_TAG,
1707  mesh->HECMW_COMM, &stat);
1708  for (j = 0; j < result->t_node; j++) {
1709  if (tmp_recv[j] >= 0) global_index[j] = tmp_recv[j];
1710  }
1711  }
1712  free(tmp_recv);
1713  for (i = 1; i < pesize; i++)
1714  HECMW_Send(global_index, result->t_node, HECMW_INT, i, 0,
1715  mesh->HECMW_COMM);
1716  } else {
1717  HECMW_Send(global_index, result->t_node, HECMW_INT, 0, 0, mesh->HECMW_COMM);
1718  HECMW_Recv(global_index, result->t_node, HECMW_INT, 0, HECMW_ANY_TAG,
1719  mesh->HECMW_COMM, &stat);
1720  }
1721 
1722  /* for(i=0;i<result->t_node;i++)
1723  fprintf(test_fp, "%d\n", global_index[i]);
1724  fclose(test_fp);
1725  */
1726  import_index = (int *)calloc(pesize + 1, sizeof(int));
1727  if (import_index == NULL) HECMW_dlb_memory_exit("import_index");
1728  for (i = 0; i < pesize + 1; i++) import_index[i] = 0;
1729  for (i = 0; i < recv_ptr_num[pesize]; i++) {
1730  tmp_int = tmp_int_nodeid[i];
1731  if (tmp_int >= result->t_node) {
1732  fprintf(stderr, "There is something wrong with data: i=%d tmp_int=%d\n",
1733  i, tmp_int);
1734  HECMW_dlb_print_exit("Please check again");
1735  }
1736  if (global_index_hit[tmp_int] == -1) {
1737  global_index_hit[tmp_int] = -2;
1738  m = global_index[tmp_int] / result->t_node;
1739  import_index[m + 1]++;
1740  }
1741  }
1742  for (i = 0; i < recv_ptr_parent_num[pesize]; i++) {
1743  tmp_int = tmp2_int_nodeid[i];
1744  if (tmp_int >= result->t_node) {
1745  fprintf(stderr, "There is something wrong with data: i=%d tmp_int=%d\n",
1746  i, tmp_int);
1747  HECMW_dlb_print_exit("Please check again");
1748  }
1749  if (global_index_hit[tmp_int] == -1) {
1750  global_index_hit[tmp_int] = -2;
1751  m = global_index[tmp_int] / result->t_node;
1752  import_index[m + 1]++;
1753  }
1754  }
1755  for (i = 1; i < pesize + 1; i++)
1756  import_index[i] = import_index[i - 1] + import_index[i];
1757  count_index = (int *)calloc(pesize, sizeof(int));
1758  for (i = 0; i < pesize; i++) count_index[i] = 0;
1759  for (i = 0; i < result->t_node; i++) {
1760  global_index_hit[i] = -1;
1761  }
1762  for (i = 0; i < recv_node_num[pesize]; i++) {
1763  global_index_hit[recv_node[i]] = i;
1764  }
1765  free(recv_node);
1766  /* ********original mesh free
1767  free(mesh->node_id);
1768 
1769 
1770  */
1771  new_mesh->n_node = recv_node_num[pesize] + import_index[pesize];
1772  new_mesh->node_dof_index =
1773  (int *)calloc(new_mesh->n_dof_grp + 1, sizeof(int));
1774  if (new_mesh->node_dof_index == NULL)
1775  HECMW_dlb_memory_exit("new_mesh: node_dof_index");
1776  new_mesh->node_dof_index[0] = 0;
1777  new_mesh->node_dof_index[1] = new_mesh->n_node;
1778  new_mesh->node_dof_item = (int *)calloc(new_mesh->n_dof_grp, sizeof(int));
1779  if (new_mesh->node_dof_item == NULL)
1780  HECMW_dlb_memory_exit("new_mesh: node_dof_item");
1781  for (i = 0; i < new_mesh->n_dof_grp; i++)
1782  new_mesh->node_dof_item[i] = mesh->node_dof_item[i];
1783 
1784  new_mesh->nn_internal = recv_node_num[pesize];
1785  new_mesh->n_dof = mesh->n_dof;
1786  new_mesh->n_dof_grp = mesh->n_dof_grp;
1787  new_mesh->node_ID = (int *)calloc(2 * new_mesh->n_node, sizeof(int));
1788  if (new_mesh->node_ID == NULL) HECMW_dlb_memory_exit("new_mesh: node_ID");
1789  for (i = 0; i < recv_node_num[pesize]; i++) {
1790  new_mesh->node_ID[i * 2 + 1] = mynode;
1791  new_mesh->node_ID[i * 2] = i + 1;
1792  }
1793  if ((recv_ptr_num[pesize] + recv_ptr_parent_num[pesize]) > 0) {
1794  new_mesh->elem_node_item = (int *)calloc(
1795  recv_ptr_num[pesize] + recv_ptr_parent_num[pesize], sizeof(int));
1796 
1797  if (new_mesh->elem_node_item == NULL)
1798  HECMW_dlb_memory_exit("new_mesh: elem_node_item");
1799  for (i = 0; i < recv_ptr_num[pesize]; i++) {
1800  tmp_int = tmp_int_nodeid[i];
1801  if (global_index_hit[tmp_int] != -1) {
1802  new_mesh->elem_node_item[i] = global_index_hit[tmp_int];
1803  } else {
1804  m = global_index[tmp_int] / result->t_node;
1805  global_index_hit[tmp_int] =
1806  new_mesh->nn_internal + import_index[m] + count_index[m];
1807  new_mesh->elem_node_item[i] = global_index_hit[tmp_int];
1808  new_mesh->node_ID[global_index_hit[tmp_int] * 2] =
1809  (global_index[tmp_int] % result->t_node) + 1;
1810  new_mesh->node_ID[global_index_hit[tmp_int] * 2 + 1] =
1811  global_index[tmp_int] / result->t_node;
1812  count_index[m]++;
1813  }
1814  }
1815  for (i = 0; i < recv_ptr_parent_num[pesize]; i++) {
1816  tmp_int = tmp2_int_nodeid[i];
1817  if (global_index_hit[tmp_int] != -1) {
1818  new_mesh->elem_node_item[i + recv_ptr_num[pesize]] =
1819  global_index_hit[tmp_int];
1820  } else {
1821  m = global_index[tmp_int] / result->t_node;
1822  global_index_hit[tmp_int] =
1823  new_mesh->nn_internal + import_index[m] + count_index[m];
1824  new_mesh->elem_node_item[i + recv_ptr_num[pesize]] =
1825  global_index_hit[tmp_int];
1826  new_mesh->node_ID[global_index_hit[tmp_int] * 2] =
1827  (global_index[tmp_int] % result->t_node) + 1;
1828  new_mesh->node_ID[global_index_hit[tmp_int] * 2 + 1] =
1829  global_index[tmp_int] / result->t_node;
1830  count_index[m]++;
1831  }
1832  }
1833  }
1834  for (i = 0; i < recv_ptr_num[pesize] + recv_ptr_parent_num[pesize]; i++)
1835  new_mesh->elem_node_item[i] += 1;
1836 
1837  new_mesh->elem_internal_list =
1838  (int *)calloc(new_mesh->ne_internal, sizeof(int));
1839  if (new_mesh->elem_internal_list == NULL)
1840  HECMW_dlb_memory_exit("new_mesh: elem_internal_list");
1841  for (i = 0; i < new_mesh->ne_internal; i++)
1842  new_mesh->elem_internal_list[i] = 0;
1843  new_mesh->ne_internal = 0;
1844  /* for(i=0;i<recv_elem_num[pesize];i++) {
1845  min_pe=mynode;
1846  for(j=new_smesh->index_elem[i];j<new_smesh->index_elem[i+1];j++)
1847  {
1848  local_nid=new_smesh->ptr_elem[j]-1;
1849  tmp_pe=new_smesh->node_id[new_smesh->n_node+local_nid];
1850  if(tmp_pe<min_pe)
1851  min_pe=tmp_pe;
1852  }
1853  if(min_pe==mynode) {
1854  new_smesh->ne_internal++;
1855  new_smesh->ne_internal_list[i]=1;
1856  }
1857  }
1858  */
1859 
1860  for (i = 0; i < new_mesh->n_elem; i++) {
1861  if (new_mesh->elem_ID[i * 2 + 1] == mynode) {
1862  new_mesh->elem_internal_list[new_mesh->ne_internal] = i + 1;
1863  new_mesh->ne_internal++;
1864  }
1865  }
1866  /*
1867  fprintf(stderr, "In pe %d ne_internal=%d n_elem=%d t_elem=%d\n", mynode,
1868  new_mesh->ne_internal, new_mesh->n_elem,
1869  t_elem);
1870  */
1871  tmp_int = 0;
1872  for (i = 1; i < pesize + 1; i++) {
1873  if ((import_index[i] - import_index[i - 1]) > 0) tmp_int++;
1874  }
1875  import_n_neighbor_pe = tmp_int;
1876  import_neighbor_pe = (int *)calloc(tmp_int, sizeof(int));
1877 
1878  tmp_int = -1;
1879  for (i = 1; i < pesize + 1; i++) {
1880  if ((import_index[i] - import_index[i - 1]) > 0) {
1881  tmp_int++;
1882  import_neighbor_pe[tmp_int] = i - 1;
1883  }
1884  }
1885  export_index = (int *)calloc(pesize + 1, sizeof(int));
1886  stack_whole_send_recv(pesize, import_index, export_index, mesh->HECMW_COMM,
1887  mynode);
1888  export_node = (int *)calloc(export_index[pesize] + 1, sizeof(int));
1889  tmp_send = (int *)calloc(import_index[pesize] + 1, sizeof(int));
1890  if (tmp_send == NULL) HECMW_dlb_memory_exit("tmp_send");
1891  for (i = 0; i < import_index[pesize]; i++)
1892  tmp_send[i] = new_mesh->node_ID[(new_mesh->nn_internal + i) * 2];
1893  /*
1894  for(i=0;i<vis_pesize+1;i++)
1895  fprintf(test_fp, "%d ", import_index[i]);
1896  fprintf(test_fp, "\n");
1897  for(i=0;i<import_index[vis_pesize];i++)
1898  fprintf(test_fp, "%d %d\n", tmp_send[i],
1899  new_smesh->node_ID[(new_smesh->nn_internal+i)*2+1]);
1900  fclose(test_fp);
1901  */
1902 
1903  int2_whole_send_recv(import_index[pesize], export_index[pesize], pesize,
1904  export_index, import_index, tmp_send, export_node,
1905  mesh->HECMW_COMM, mynode);
1906 
1907  /* for(i=0;i<pesize+1;i++)
1908  fprintf(test_fp2, "%d ", export_index[i]);
1909  fprintf(test_fp2, "\n");
1910  for(i=0;i<export_index[pesize];i++)
1911  fprintf(test_fp2, "%d \n", export_node[i]);
1912  */
1913 
1914  tmp_int = 0;
1915  for (i = 1; i < pesize + 1; i++) {
1916  if ((export_index[i] - export_index[i - 1]) > 0) tmp_int++;
1917  }
1918  export_n_neighbor_pe = tmp_int;
1919  export_neighbor_pe = (int *)calloc(tmp_int, sizeof(int));
1920  tmp_int = -1;
1921  for (i = 1; i < pesize + 1; i++) {
1922  if ((export_index[i] - export_index[i - 1]) > 0) {
1923  tmp_int++;
1924  export_neighbor_pe[tmp_int] = i - 1;
1925  }
1926  }
1927 
1928  if (export_n_neighbor_pe > import_n_neighbor_pe) {
1929  new_mesh->n_neighbor_pe = export_n_neighbor_pe;
1930  new_mesh->neighbor_pe = (int *)calloc(new_mesh->n_neighbor_pe, sizeof(int));
1931  for (i = 0; i < new_mesh->n_neighbor_pe; i++)
1932  new_mesh->neighbor_pe[i] = export_neighbor_pe[i];
1933  } else {
1934  new_mesh->n_neighbor_pe = import_n_neighbor_pe;
1935  new_mesh->neighbor_pe = (int *)calloc(new_mesh->n_neighbor_pe, sizeof(int));
1936  for (i = 0; i < new_mesh->n_neighbor_pe; i++)
1937  new_mesh->neighbor_pe[i] = import_neighbor_pe[i];
1938  }
1939  /* free(import_neighbor_pe);
1940  free(export_neighbor_pe);
1941 */
1942  new_mesh->export_index =
1943  (int *)calloc(new_mesh->n_neighbor_pe + 1, sizeof(int));
1944  new_mesh->import_index =
1945  (int *)calloc(new_mesh->n_neighbor_pe + 1, sizeof(int));
1946  new_mesh->export_index[0] = 0;
1947  new_mesh->import_index[0] = 0;
1948  for (i = 0; i < new_mesh->n_neighbor_pe; i++) {
1949  new_mesh->export_index[i + 1] = export_index[new_mesh->neighbor_pe[i] + 1];
1950  new_mesh->import_index[i + 1] = import_index[new_mesh->neighbor_pe[i] + 1];
1951  }
1952  if (import_index[pesize] > 0) {
1953  new_mesh->import_item = (int *)calloc(import_index[pesize], sizeof(int));
1954  if (new_mesh->import_item == NULL)
1955  HECMW_dlb_memory_exit("new_mesh: import_item");
1956  }
1957  for (i = 0; i < import_index[pesize]; i++)
1958  new_mesh->import_item[i] = new_mesh->nn_internal + i + 1;
1959  if (export_index[pesize] > 0) {
1960  new_mesh->export_item = (int *)calloc(export_index[pesize], sizeof(int));
1961  if (new_mesh->export_item == NULL)
1962  HECMW_dlb_memory_exit("new_mesh: export_item");
1963  }
1964  for (i = 0; i < export_index[pesize]; i++)
1965  new_mesh->export_item[i] = export_node[i];
1966  free(global_index_hit);
1967 
1968  HECMW_Barrier(mesh->HECMW_COMM);
1969 
1970  /*
1971  }
1972  */ /* end of if(mynode in VIS_COMM) */
1973 
1974  /* ----------------sending node information --------------------- */
1975 
1976  if (new_mesh->n_node > 0) {
1977  new_mesh->node = (double *)calloc(3 * new_mesh->n_node, sizeof(double));
1978  if (new_mesh->node == NULL) HECMW_dlb_memory_exit("new_mesh: node");
1979  }
1980 
1981  tmp_node_d = (double *)calloc(send_node_num[pesize] + 1, sizeof(double));
1982  recv_node_d = (double *)calloc(recv_node_num[pesize] + 1, sizeof(double));
1983  tmp2_node_d = (double *)calloc(export_index[pesize] + 1, sizeof(double));
1984  recv2_node_d = (double *)calloc(import_index[pesize] + 1, sizeof(double));
1985  if ((tmp_node_d == NULL) || (recv_node_d == NULL) || (tmp2_node_d == NULL) ||
1986  (recv2_node_d == NULL))
1987  HECMW_dlb_memory_exit("new_mesh: recv_node");
1988  for (j = 0; j < 3; j++) {
1989  for (i = 0; i < recv_node_num[pesize]; i++) recv_node_d[i] = 0.0;
1990  for (i = 0; i < send_node_num[pesize]; i++)
1991  tmp_node_d[i] = mesh->node[send_node[i] * 3 + j];
1992  double2_whole_send_recv(send_node_num[pesize], recv_node_num[pesize],
1993  pesize, recv_node_num, send_node_num, tmp_node_d,
1994  recv_node_d, mesh->HECMW_COMM, mynode);
1995  for (i = 0; i < export_index[pesize]; i++)
1996  tmp2_node_d[i] = recv_node_d[export_node[i] - 1];
1997 
1998  double2_whole_send_recv(export_index[pesize], import_index[pesize], pesize,
1999  import_index, export_index, tmp2_node_d,
2000  recv2_node_d, mesh->HECMW_COMM, mynode);
2001  for (i = 0; i < new_mesh->nn_internal; i++)
2002  new_mesh->node[i * 3 + j] = recv_node_d[i];
2003  for (i = 0; i < import_index[pesize]; i++)
2004  new_mesh->node[(i + new_mesh->nn_internal) * 3 + j] = recv2_node_d[i];
2005  }
2006 
2007  /*
2008  fprintf(stderr, "n_node=%d nn_internal=%d recv_node_num=%d
2009  import_index_num=%d\n", new_mesh->n_node, new_mesh->nn_internal,
2010  recv_node_num[pesize],
2011  new_mesh->import_index[new_mesh->n_neighbor_pe]);
2012  */
2013  /*
2014  global_comm_table->send_node_num=send_node_num;
2015  global_comm_table->recv_node_num=recv_node_num;
2016 
2017  global_comm_table->send_node=send_node;
2018  if(mynode>=mesh_pesize) {
2019  global_comm_table->import_index=import_index;
2020  global_comm_table->export_index=export_index;
2021  global_comm_table->export_node=export_node;
2022  }
2023  */
2024  /* free(node->data);
2025  */
2026  free(tmp_int_nodeid);
2027  free(tmp2_int_nodeid);
2028 
2029  /* --------------------start sending result data ---------------------- */
2030  new_data->nn_component = data->nn_component;
2031  new_data->ne_component = data->ne_component;
2032  if (new_data->nn_component > 0) {
2033  new_data->nn_dof = (int *)calloc(new_data->nn_component, sizeof(int));
2034  new_data->node_label =
2035  (char **)calloc(new_data->nn_component, sizeof(char *));
2036  for (i = 0; i < new_data->nn_component; i++)
2037  new_data->node_label[i] = (char *)calloc(name_buf_size, sizeof(char));
2038  if (new_data->nn_dof == NULL) HECMW_dlb_memory_exit("new_data: nn_dof");
2039  for (i = 0; i < new_data->nn_component; i++) {
2040  new_data->nn_dof[i] = data->nn_dof[i];
2041  snprintf(new_data->node_label[i], name_buf_size, "%s", data->node_label[i]);
2042  }
2043  }
2044  if (new_data->ne_component > 0) {
2045  new_data->ne_dof = (int *)calloc(new_data->ne_component, sizeof(int));
2046  new_data->elem_label =
2047  (char **)calloc(new_data->ne_component, sizeof(char *));
2048  for (i = 0; i < new_data->ne_component; i++)
2049  new_data->elem_label[i] = (char *)calloc(name_buf_size, sizeof(char));
2050  if (new_data->ne_dof == NULL) HECMW_dlb_memory_exit("new_data: ne_dof");
2051  for (i = 0; i < new_data->ne_component; i++) {
2052  new_data->ne_dof[i] = data->ne_dof[i];
2053  snprintf(new_data->elem_label[i], name_buf_size, "%s", data->elem_label[i]);
2054  }
2055  }
2056  if (new_data->nn_component > 0) {
2057  tn_component = 0;
2058  for (i = 0; i < new_data->nn_component; i++)
2059  tn_component += new_data->nn_dof[i];
2060  new_data->node_val_item =
2061  (double *)calloc(tn_component * new_mesh->n_node, sizeof(double));
2062  if (new_data->node_val_item == NULL)
2063  HECMW_dlb_memory_exit("new_data: node_val_item");
2064  for (j = 0; j < tn_component; j++) {
2065  for (i = 0; i < send_node_num[pesize]; i++)
2066  tmp_node_d[i] = data->node_val_item[send_node[i] * tn_component + j];
2067 
2068  double2_whole_send_recv(send_node_num[pesize], recv_node_num[pesize],
2069  pesize, recv_node_num, send_node_num, tmp_node_d,
2070  recv_node_d, mesh->HECMW_COMM, mynode);
2071  for (i = 0; i < export_index[pesize]; i++)
2072  tmp2_node_d[i] = recv_node_d[export_node[i] - 1];
2073 
2074  double2_whole_send_recv(export_index[pesize], import_index[pesize],
2075  pesize, import_index, export_index, tmp2_node_d,
2076  recv2_node_d, mesh->HECMW_COMM, mynode);
2077  for (i = 0; i < new_mesh->nn_internal; i++)
2078  new_data->node_val_item[i * tn_component + j] = recv_node_d[i];
2079  for (i = 0; i < import_index[pesize]; i++)
2080  new_data
2081  ->node_val_item[(i + new_mesh->nn_internal) * tn_component + j] =
2082  recv2_node_d[i];
2083  }
2084  }
2085 
2086  free(tmp_node_d);
2087  free(recv_node_d);
2088  free(tmp2_node_d);
2089  free(recv2_node_d);
2090  new_mesh->when_i_was_refined_node =
2091  (int *)calloc(new_mesh->n_node, sizeof(int));
2092  if (new_mesh->when_i_was_refined_node == NULL)
2093  HECMW_dlb_memory_exit("new_mesh: when_i_was_refined_node");
2094  tmp_node_i = (int *)calloc(send_node_num[pesize] + 1, sizeof(int));
2095  recv_node_i = (int *)calloc(recv_node_num[pesize] + 1, sizeof(int));
2096  tmp2_node_i = (int *)calloc(export_index[pesize] + 1, sizeof(int));
2097  recv2_node_i = (int *)calloc(import_index[pesize] + 1, sizeof(int));
2098  if ((tmp_node_i == NULL) || (recv_node_i == NULL))
2099  HECMW_dlb_memory_exit("new_mesh: when_i_was_refined_node");
2100  for (i = 0; i < recv_node_num[pesize]; i++) recv_node_i[i] = -1;
2101  for (i = 0; i < send_node_num[pesize]; i++)
2102  tmp_node_i[i] = mesh->when_i_was_refined_node[send_node[i]];
2103 
2104  int2_whole_send_recv(send_node_num[pesize], recv_node_num[pesize], pesize,
2105  recv_node_num, send_node_num, tmp_node_i, recv_node_i,
2106  mesh->HECMW_COMM, mynode);
2107  for (i = 0; i < export_index[pesize]; i++)
2108  tmp2_node_i[i] = recv_node_i[export_node[i] - 1];
2109 
2110  int2_whole_send_recv(export_index[pesize], import_index[pesize], pesize,
2111  import_index, export_index, tmp2_node_i, recv2_node_i,
2112  mesh->HECMW_COMM, mynode);
2113  for (i = 0; i < new_mesh->nn_internal; i++)
2114  new_mesh->when_i_was_refined_node[i] = recv_node_i[i];
2115  for (i = 0; i < import_index[pesize]; i++)
2116  new_mesh->when_i_was_refined_node[i + new_mesh->nn_internal] =
2117  recv2_node_i[i];
2118 
2119  if (new_mesh->node_group->n_grp > 0) {
2120  tmp_grp =
2121  (Tmp_grp_inf *)calloc(new_mesh->node_group->n_grp, sizeof(Tmp_grp_inf));
2122  if (tmp_grp == NULL) HECMW_dlb_memory_exit("tmp_grp");
2123 
2124  for (m = 0; m < new_mesh->node_group->n_grp; m++)
2125  tmp_grp[m].num_of_item = 0;
2126  for (m = 0; m < new_mesh->node_group->n_grp; m++) {
2127  if (m == 0) {
2128  tmp_elem_grp = (int *)calloc(mesh->nn_internal, sizeof(int));
2129  if (tmp_elem_grp == NULL) HECMW_dlb_memory_exit("tmp_elem_grp");
2130  }
2131  for (i = 0; i < mesh->nn_internal; i++) tmp_elem_grp[i] = 0;
2132  if ((mesh->node_group->grp_index[m + 1] -
2133  mesh->node_group->grp_index[m]) > 0) {
2134  for (i = mesh->node_group->grp_index[m];
2135  i < mesh->node_group->grp_index[m + 1]; i++) {
2136  if (mesh->node_group->grp_item[i] <= mesh->nn_internal)
2137  tmp_elem_grp[mesh->node_group->grp_item[i] - 1] = 1;
2138  }
2139  }
2140  for (i = 0; i < recv_node_num[pesize]; i++) recv_node_i[i] = -1;
2141  for (i = 0; i < send_node_num[pesize]; i++)
2142  tmp_node_i[i] = tmp_elem_grp[send_node[i]];
2143 
2144  int2_whole_send_recv(send_node_num[pesize], recv_node_num[pesize], pesize,
2145  recv_node_num, send_node_num, tmp_node_i,
2146  recv_node_i, mesh->HECMW_COMM, mynode);
2147  for (i = 0; i < export_index[pesize]; i++)
2148  tmp2_node_i[i] = recv_node_i[export_node[i] - 1];
2149 
2150  int2_whole_send_recv(export_index[pesize], import_index[pesize], pesize,
2151  import_index, export_index, tmp2_node_i,
2152  recv2_node_i, mesh->HECMW_COMM, mynode);
2153  num_grp_item = 0;
2154  for (i = 0; i < new_mesh->nn_internal; i++) {
2155  if (recv_node_i[i] == 1) num_grp_item++;
2156  }
2157  for (i = 0; i < import_index[pesize]; i++) {
2158  if (recv2_node_i[i] == 1) num_grp_item++;
2159  }
2160  tmp_grp[m].num_of_item = num_grp_item;
2161  if (num_grp_item > 0) {
2162  tmp_grp[m].item = (int *)calloc(num_grp_item, sizeof(int));
2163  if (tmp_grp[m].item == NULL) HECMW_dlb_memory_exit("tmp_grp:item");
2164  tmp_int = 0;
2165  for (i = 0; i < new_mesh->nn_internal; i++) {
2166  if (recv_node_i[i] == 1) {
2167  tmp_grp[m].item[tmp_int] = i + 1;
2168  tmp_int++;
2169  }
2170  }
2171  for (i = 0; i < import_index[pesize]; i++) {
2172  if (recv2_node_i[i] == 1) {
2173  tmp_grp[m].item[tmp_int] = new_mesh->nn_internal + i + 1;
2174  tmp_int++;
2175  }
2176  }
2177  }
2178  }
2179 
2180  free(tmp_elem_grp);
2181  num_grp_item = 0;
2182  for (m = 0; m < new_mesh->node_group->n_grp; m++)
2183  num_grp_item += tmp_grp[m].num_of_item;
2184  new_mesh->node_group->grp_index =
2185  (int *)calloc(new_mesh->node_group->n_grp + 1, sizeof(int));
2186  if (new_mesh->node_group->grp_index == NULL)
2187  HECMW_dlb_memory_exit("new_mesh: node_grp: grp_index");
2188  new_mesh->node_group->grp_index[0] = 0;
2189  for (m = 0; m < new_mesh->node_group->n_grp; m++)
2190  new_mesh->node_group->grp_index[m + 1] =
2191  new_mesh->node_group->grp_index[m] + tmp_grp[m].num_of_item;
2192  if (num_grp_item > 0) {
2193  new_mesh->node_group->grp_item = (int *)calloc(num_grp_item, sizeof(int));
2194  if (new_mesh->node_group->grp_item == NULL)
2195  HECMW_dlb_memory_exit("new_mesh: node_grp: grp_item");
2196  tmp_int = 0;
2197  for (m = 0; m < new_mesh->node_group->n_grp; m++) {
2198  for (i = 0; i < tmp_grp[m].num_of_item; i++) {
2199  new_mesh->node_group->grp_item[tmp_int] = tmp_grp[m].item[i];
2200  tmp_int++;
2201  }
2202  }
2203  }
2204  for (m = 0; m < new_mesh->node_group->n_grp; m++) {
2205  if (tmp_grp[m].num_of_item > 0) free(tmp_grp[m].item);
2206  }
2207  free(tmp_grp);
2208  if (mynode == 0) fprintf(stderr, "Finish generating new node_grp inf.\n");
2209  }
2210 
2211  free(tmp_node_i);
2212  free(tmp2_node_i);
2213  free(recv_node_i);
2214  free(recv2_node_i);
2215 
2216  nvtxs = new_mesh->nn_internal;
2217  new_vtxdist = (int *)calloc(pesize + 1, sizeof(int));
2218 
2219  if (mynode == 0) {
2220  new_vtxdist[0] = 0;
2221  new_vtxdist[1] = nvtxs;
2222  tmp_sum = nvtxs;
2223  for (i = 1; i < pesize; i++) {
2224  HECMW_Recv(&tmp_nvtxs, 1, HECMW_INT, i, HECMW_ANY_TAG, mesh->HECMW_COMM,
2225  &stat);
2226  tmp_sum += tmp_nvtxs;
2227  new_vtxdist[i + 1] = tmp_sum;
2228  }
2229  for (i = 1; i < pesize; i++)
2230  HECMW_Send(new_vtxdist, pesize + 1, HECMW_INT, i, 0, mesh->HECMW_COMM);
2231  } else {
2232  HECMW_Send(&nvtxs, 1, HECMW_INT, 0, 0, mesh->HECMW_COMM);
2233  HECMW_Recv(new_vtxdist, pesize + 1, HECMW_INT, 0, HECMW_ANY_TAG,
2234  mesh->HECMW_COMM, &stat);
2235  }
2236  new_mesh->global_node_ID = (int *)calloc(new_mesh->n_node, sizeof(int));
2237  if (new_mesh->global_node_ID == NULL)
2238  HECMW_dlb_print_exit("new_mesh: global_node_ID");
2239  for (i = 0; i < new_mesh->n_node; i++)
2240  new_mesh->global_node_ID[i] =
2241  new_vtxdist[new_mesh->node_ID[i * 2 + 1]] + new_mesh->node_ID[i * 2];
2242  free(new_vtxdist);
2243  /*
2244  for(i=0;i<result->t_node;i++)
2245  global_new2old[i]=-1;
2246 
2247  for(i=0; i<result->t_node;i++) {
2248  tmp_peid=global_index[i] / result->t_node;
2249  tmp_lid=global_index[i] % result->t_node;
2250  global_new2old[new_vtxdist[tmp_peid]+tmp_lid]=i;
2251  }
2252  */
2253  free(global_index);
2254  /* set new data structure */
2255  /* if(mynode>=mesh_pesize) {
2256  new_data->node_val_item=(double *)calloc(new_smesh->n_node,
2257  sizeof(double));
2258  if(new_data->node_val_item==NULL)
2259  HECMW_dlb_memory_exit("new_data: node_val_item");
2260  }
2261  */
2262 
2263  if (new_mesh->n_elem_type > 1) {
2264  new2old = (int *)calloc(new_mesh->n_elem, sizeof(int));
2265  if (new2old == NULL) HECMW_dlb_memory_exit("new2old");
2266  new_mesh->elem_type_index =
2267  (int *)calloc(new_mesh->n_elem_type + 1, sizeof(int));
2268  if (new_mesh->elem_type_index == NULL)
2269  HECMW_dlb_memory_exit("new_mesh: elem_type_index");
2270  for (i = 0; i < new_mesh->n_elem_type + 1; i++)
2271  new_mesh->elem_type_index[i] = 0;
2272  new_mesh->elem_type_item =
2273  (int *)calloc(new_mesh->n_elem_type, sizeof(int));
2274  if (new_mesh->elem_type_item == NULL)
2275  HECMW_dlb_memory_exit("new_mesh: elem_type_item");
2276  for (i = 0; i < new_mesh->n_elem_type; i++)
2277  new_mesh->elem_type_item[i] = mesh->elem_type_item[i];
2278 
2279  for (i = 0; i < new_mesh->n_elem; i++) {
2280  for (j = 0; j < new_mesh->n_elem_type; j++) {
2281  if (new_mesh->elem_type[i] == new_mesh->elem_type_item[j]) {
2282  new_mesh->elem_type_index[j + 1]++;
2283  break;
2284  }
2285  }
2286  }
2287  for (j = 1; j < new_mesh->n_elem_type + 1; j++)
2288  new_mesh->elem_type_index[j] += new_mesh->elem_type_index[j - 1];
2289  /*
2290  fprintf(stderr, "new_mesh: elem_type_index= %d %d %d\n",
2291  new_mesh->elem_type_index[0], new_mesh->elem_type_index[1],
2292  new_mesh->elem_type_index[2]);
2293  */
2294  count_elem_index = (int *)calloc(new_mesh->n_elem_type, sizeof(int));
2295  if (count_elem_index == NULL)
2296  HECMW_dlb_memory_exit("new_mesh: count_elem_index");
2297  for (i = 0; i < new_mesh->n_elem_type; i++) count_elem_index[i] = 0;
2298  for (i = 0; i < new_mesh->n_elem; i++) {
2299  for (j = 0; j < new_mesh->n_elem_type; j++) {
2300  if (new_mesh->elem_type[i] == new_mesh->elem_type_item[j]) {
2301  new2old[i] = new_mesh->elem_type_index[j] + count_elem_index[j];
2302  count_elem_index[j]++;
2303  break;
2304  }
2305  }
2306  }
2307  free(count_elem_index);
2308  new_tmp = (int *)calloc(new_mesh->n_elem, sizeof(int));
2309  if (new_tmp == NULL) HECMW_dlb_memory_exit("new_tmp");
2310  for (i = 0; i < new_mesh->n_elem; i++)
2311  new_tmp[i] = new_mesh->elem_type[new2old[i]];
2312  free(new_mesh->elem_type);
2313  new_mesh->elem_type = new_tmp;
2314  new_tmp = (int *)calloc(new_mesh->n_elem, sizeof(int));
2315  if (new_tmp == NULL) HECMW_dlb_memory_exit("new_tmp");
2316  for (i = 0; i < new_mesh->n_elem; i++)
2317  new_tmp[i] = new_mesh->section_ID[new2old[i]];
2318  free(new_mesh->section_ID);
2319  new_mesh->section_ID = new_tmp;
2320  new_tmp = (int *)calloc(new_mesh->n_elem, sizeof(int));
2321  if (new_tmp == NULL) HECMW_dlb_memory_exit("new_tmp");
2322  for (i = 0; i < new_mesh->n_elem; i++)
2323  new_tmp[i] = new_mesh->elem_mat_ID_item[new2old[i]];
2324  free(new_mesh->elem_mat_ID_item);
2325  new_mesh->elem_mat_ID_item = new_tmp;
2326 
2327  /*
2328  fprintf(test_fp, "n_node=%d n_elem=%d nn_internal=%d ne_internal=%d\n",
2329  new_mesh->n_node, new_mesh->n_elem,
2330  new_mesh->nn_internal, new_mesh->ne_internal);
2331  for(i=0;i<new_mesh->n_elem;i++)
2332  fprintf(test_fp, "%d %d\n", i,
2333  new_mesh->elem_node_index[i+1]-new_mesh->elem_node_index[i]);
2334  fclose(test_fp);
2335  */
2336 
2337  {
2338  long long *new_idx_tmp, *new_idx_tmp2, jj;
2339  new_idx_tmp2 = (long long *)calloc(new_mesh->n_elem + 1, sizeof(long long));
2340  for (i = 0; i < new_mesh->n_elem + 1; i++)
2341  new_idx_tmp2[i] = new_mesh->elem_node_index[i];
2342  new_idx_tmp = (long long *)calloc(new_mesh->n_elem, sizeof(long long));
2343  if (new_idx_tmp == NULL) HECMW_dlb_memory_exit("new_idx_tmp");
2344  for (i = 0; i < new_mesh->n_elem; i++)
2345  new_idx_tmp[i] = new_mesh->elem_node_index[new2old[i] + 1] -
2346  new_mesh->elem_node_index[new2old[i]];
2347  for (i = 1; i < new_mesh->n_elem + 1; i++)
2348  new_mesh->elem_node_index[i] =
2349  new_mesh->elem_node_index[i - 1] + new_idx_tmp[i - 1];
2350  free(new_idx_tmp);
2351  new_tmp =
2352  (int *)calloc(new_mesh->elem_node_index[new_mesh->n_elem], sizeof(int));
2353  if (new_tmp == NULL) HECMW_dlb_memory_exit("new_tmp");
2354  for (i = 0; i < new_mesh->n_elem; i++) {
2355  for (jj = new_idx_tmp2[new2old[i]]; jj < new_idx_tmp2[new2old[i] + 1]; jj++) {
2356  new_tmp[new_mesh->elem_node_index[i] + jj - new_idx_tmp2[new2old[i]]] =
2357  new_mesh->elem_node_item[jj];
2358  }
2359  }
2360  free(new_mesh->elem_node_item);
2361  new_mesh->elem_node_item = new_tmp;
2362  free(new_idx_tmp2);
2363  }
2364  new_tmp = (int *)calloc(new_mesh->n_elem * 2, sizeof(int));
2365  if (new_tmp == NULL) HECMW_dlb_memory_exit("new_tmp");
2366  for (i = 0; i < new_mesh->n_elem; i++) {
2367  new_tmp[i * 2] = new_mesh->elem_ID[new2old[i] * 2];
2368  new_tmp[i * 2 + 1] = new_mesh->elem_ID[new2old[i] * 2 + 1];
2369  }
2370  free(new_mesh->elem_ID);
2371  new_mesh->elem_ID = new_tmp;
2372  new_tmp = (int *)calloc(new_mesh->n_elem, sizeof(int));
2373  if (new_tmp == NULL) HECMW_dlb_memory_exit("new_tmp");
2374  for (i = 0; i < new_mesh->n_elem; i++)
2375  new_tmp[i] = new_mesh->global_elem_ID[new2old[i]];
2376  free(new_mesh->global_elem_ID);
2377  new_mesh->global_elem_ID = new_tmp;
2378 #ifdef TEST
2379  for (i = 0; i < new_mesh->n_elem; i++)
2380  fprintf(test_fp, "i= %d elem_ID=%d %d\n", i, new_mesh->elem_ID[i * 2],
2381  new_mesh->elem_ID[i * 2 + 1]);
2382  fclose(test_fp);
2383 #endif
2384  old2new = (int *)calloc(new_mesh->n_elem, sizeof(int));
2385  if (old2new == NULL) HECMW_dlb_memory_exit("old2new");
2386  for (i = 0; i < new_mesh->n_elem; i++) old2new[new2old[i]] = i;
2387  new_mesh->ne_internal = 0;
2388  for (i = 0; i < new_mesh->n_elem; i++) {
2389  if (new_mesh->elem_ID[i * 2 + 1] == mynode) {
2390  new_mesh->elem_internal_list[new_mesh->ne_internal] = i + 1;
2391  new_mesh->ne_internal++;
2392  }
2393  }
2394 
2395  new_mesh->my_rank = mesh->my_rank;
2396  new_mesh->zero = mesh->zero;
2397  new_mesh->PETOT = mesh->PETOT;
2398  new_mesh->PEsmpTOT = mesh->PEsmpTOT;
2399  new_mesh->errnof = mesh->errnof;
2400  HECMW_Comm_dup(mesh->HECMW_COMM, &new_mesh->HECMW_COMM);
2401  new_mesh->n_subdomain = mesh->n_subdomain;
2402 
2403  new_mesh->shared_index =
2404  (int *)calloc(new_mesh->n_neighbor_pe + 1, sizeof(int));
2405  if (new_mesh->shared_index == NULL)
2406  HECMW_dlb_memory_exit("new_mesh: shared_index");
2407  for (i = 0; i < new_mesh->n_neighbor_pe + 1; i++)
2408  new_mesh->shared_index[i] = 0;
2409 
2410  new_tmp = (int *)calloc(new_mesh->n_elem, sizeof(int));
2411  if (new_tmp == NULL) HECMW_dlb_memory_exit("new_tmp");
2412  for (i = 0; i < new_mesh->n_elem; i++)
2413  new_tmp[i] = new_mesh->when_i_was_refined_elem[new2old[i]];
2414  free(new_mesh->when_i_was_refined_elem);
2415  new_mesh->when_i_was_refined_elem = new_tmp;
2416 
2417  new_tmp = (int *)calloc(new_mesh->n_elem, sizeof(int));
2418  if (new_tmp == NULL) HECMW_dlb_memory_exit("new_tmp");
2419  for (i = 0; i < new_mesh->n_elem; i++)
2420  new_tmp[i] = new_mesh->adapt_parent_type[new2old[i]];
2421  free(new_mesh->adapt_parent_type);
2422  new_mesh->adapt_parent_type = new_tmp;
2423 
2424  new_tmp = (int *)calloc(new_mesh->n_elem, sizeof(int));
2425  if (new_tmp == NULL) HECMW_dlb_memory_exit("new_tmp");
2426  for (i = 0; i < new_mesh->n_elem; i++)
2427  new_tmp[i] = new_mesh->adapt_type[new2old[i]];
2428  free(new_mesh->adapt_type);
2429  new_mesh->adapt_type = new_tmp;
2430 
2431  new_tmp = (int *)calloc(new_mesh->n_elem, sizeof(int));
2432  if (new_tmp == NULL) HECMW_dlb_memory_exit("new_tmp");
2433  for (i = 0; i < new_mesh->n_elem; i++)
2434  new_tmp[i] = new_mesh->adapt_level[new2old[i]];
2435  free(new_mesh->adapt_level);
2436  new_mesh->adapt_level = new_tmp;
2437 
2438  new_tmp = (int *)calloc(new_mesh->n_elem * 2, sizeof(int));
2439  if (new_tmp == NULL) HECMW_dlb_memory_exit("new_tmp");
2440  for (i = 0; i < new_mesh->n_elem; i++) {
2441  new_tmp[i * 2] = new_mesh->adapt_parent[new2old[i] * 2];
2442  new_tmp[i * 2 + 1] = new_mesh->adapt_parent[new2old[i] * 2 + 1];
2443  }
2444  free(new_mesh->adapt_parent);
2445  new_mesh->adapt_parent = new_tmp;
2446 
2447  new_tmp2 = (int *)calloc(new_mesh->n_elem + 1, sizeof(int));
2448  for (i = 0; i < new_mesh->n_elem + 1; i++)
2449  new_tmp2[i] = new_mesh->adapt_children_index[i];
2450  new_tmp = (int *)calloc(new_mesh->n_elem, sizeof(int));
2451  if (new_tmp == NULL) HECMW_dlb_memory_exit("new_tmp");
2452  for (i = 0; i < new_mesh->n_elem; i++)
2453  new_tmp[i] = new_mesh->adapt_children_index[new2old[i] + 1] -
2454  new_mesh->adapt_children_index[new2old[i]];
2455  for (i = 1; i < new_mesh->n_elem + 1; i++)
2456  new_mesh->adapt_children_index[i] =
2457  new_mesh->adapt_children_index[i - 1] + new_tmp[i - 1];
2458  free(new_tmp);
2459  new_tmp = (int *)calloc(
2460  new_mesh->adapt_children_index[new_mesh->n_elem] * 2, sizeof(int));
2461  if (new_tmp == NULL) HECMW_dlb_memory_exit("new_tmp");
2462  for (i = 0; i < new_mesh->n_elem; i++) {
2463  for (j = new_tmp2[new2old[i]]; j < new_tmp2[new2old[i] + 1]; j++) {
2464  new_tmp[(new_mesh->adapt_children_index[i] + j - new_tmp2[new2old[i]]) *
2465  2] = new_mesh->adapt_children_item[j * 2];
2466  new_tmp[(new_mesh->adapt_children_index[i] + j - new_tmp2[new2old[i]]) *
2467  2 +
2468  1] = new_mesh->adapt_children_item[j * 2 + 1];
2469  }
2470  }
2471  free(new_mesh->adapt_children_item);
2472  new_mesh->adapt_children_item = new_tmp;
2473  free(new_tmp2);
2474  if (mesh->section != NULL) {
2475  new_mesh->section =
2476  (struct hecmwST_section *)calloc(1, sizeof(struct hecmwST_section));
2477  if (new_mesh->section == NULL) HECMW_dlb_memory_exit("new_mesh: section");
2478  new_mesh->section->n_sect = mesh->section->n_sect;
2479  new_mesh->section->sect_type =
2480  (int *)calloc(new_mesh->section->n_sect, sizeof(int));
2481  new_mesh->section->sect_opt =
2482  (int *)calloc(new_mesh->section->n_sect, sizeof(int));
2483  if ((new_mesh->section->sect_type == NULL) ||
2484  (new_mesh->section->sect_opt == NULL))
2485  HECMW_dlb_memory_exit("new_mesh: section");
2486  new_mesh->section->sect_mat_ID_index =
2487  (int *)calloc(new_mesh->section->n_sect + 1, sizeof(int));
2488  new_mesh->section->sect_mat_ID_item = (int *)calloc(
2489  mesh->section->sect_mat_ID_index[mesh->section->n_sect], sizeof(int));
2490  for (i = 0; i < mesh->section->n_sect; i++)
2491  new_mesh->section->sect_type[i] = mesh->section->sect_type[i];
2492  for (i = 0; i < mesh->section->n_sect; i++)
2493  new_mesh->section->sect_opt[i] = mesh->section->sect_opt[i];
2494  for (i = 0; i < mesh->section->n_sect + 1; i++)
2495  new_mesh->section->sect_mat_ID_index[i] =
2496  mesh->section->sect_mat_ID_index[i];
2497  for (i = 0; i < mesh->section->sect_mat_ID_index[mesh->section->n_sect];
2498  i++)
2499  new_mesh->section->sect_mat_ID_item[i] =
2500  mesh->section->sect_mat_ID_item[i];
2501  new_mesh->section->sect_I_index =
2502  (int *)calloc(new_mesh->section->n_sect + 1, sizeof(int));
2503  new_mesh->section->sect_R_index =
2504  (int *)calloc(new_mesh->section->n_sect + 1, sizeof(int));
2505 
2506  for (i = 0; i < mesh->section->n_sect + 1; i++)
2507  new_mesh->section->sect_I_index[i] = mesh->section->sect_I_index[i];
2508  for (i = 0; i < mesh->section->n_sect + 1; i++)
2509  new_mesh->section->sect_R_index[i] = mesh->section->sect_R_index[i];
2510  new_mesh->section->sect_I_item = (int *)calloc(
2511  new_mesh->section->sect_I_index[new_mesh->section->n_sect],
2512  sizeof(int));
2513  new_mesh->section->sect_R_item = (double *)calloc(
2514  new_mesh->section->sect_R_index[new_mesh->section->n_sect],
2515  sizeof(double));
2516  for (i = 0;
2517  i < new_mesh->section->sect_I_index[new_mesh->section->n_sect]; i++)
2518  new_mesh->section->sect_I_item[i] = mesh->section->sect_I_item[i];
2519  for (i = 0;
2520  i < new_mesh->section->sect_R_index[new_mesh->section->n_sect]; i++)
2521  new_mesh->section->sect_R_item[i] = mesh->section->sect_R_item[i];
2522  }
2523  if (mesh->material != NULL) {
2524  new_mesh->material =
2525  (struct hecmwST_material *)calloc(1, sizeof(struct hecmwST_material));
2526  if (new_mesh->material == NULL)
2527  HECMW_dlb_memory_exit("new_mesh: material");
2528  new_mesh->material->n_mat = mesh->material->n_mat;
2529  new_mesh->material->n_mat_item = mesh->material->n_mat_item;
2530  new_mesh->material->n_mat_subitem = mesh->material->n_mat_subitem;
2531  new_mesh->material->n_mat_table = mesh->material->n_mat_table;
2532  new_mesh->material->mat_name =
2533  (char **)calloc(new_mesh->material->n_mat, sizeof(char *));
2534  if (new_mesh->material->mat_name == NULL)
2535  HECMW_dlb_memory_exit("new_mesh: material");
2536  for (i = 0; i < new_mesh->material->n_mat; i++) {
2537  new_mesh->material->mat_name[i] = (char *)calloc(name_buf_size, sizeof(char));
2538  snprintf(new_mesh->material->mat_name[i], name_buf_size, "%s",
2539  mesh->material->mat_name[i]);
2540  }
2541  new_mesh->material->mat_item_index =
2542  (int *)calloc(new_mesh->material->n_mat + 1, sizeof(int));
2543  new_mesh->material->mat_subitem_index =
2544  (int *)calloc(new_mesh->material->n_mat_item + 1, sizeof(int));
2545  new_mesh->material->mat_table_index =
2546  (int *)calloc(new_mesh->material->n_mat_subitem + 1, sizeof(int));
2547  if ((new_mesh->material->mat_item_index == NULL) ||
2548  (new_mesh->material->mat_subitem_index == NULL) ||
2549  (new_mesh->material->mat_table_index == NULL))
2550  HECMW_dlb_memory_exit("new_mesh: material");
2551  for (i = 0; i < new_mesh->material->n_mat + 1; i++)
2552  new_mesh->material->mat_item_index[i] =
2553  mesh->material->mat_item_index[i];
2554  for (i = 0; i < new_mesh->material->n_mat_item + 1; i++)
2555  new_mesh->material->mat_subitem_index[i] =
2556  mesh->material->mat_subitem_index[i];
2557  for (i = 0; i < new_mesh->material->n_mat_subitem + 1; i++)
2558  new_mesh->material->mat_table_index[i] =
2559  mesh->material->mat_table_index[i];
2560  new_mesh->material->mat_val = (double *)calloc(
2561  new_mesh->material
2562  ->mat_table_index[new_mesh->material->n_mat_subitem],
2563  sizeof(double));
2564  new_mesh->material->mat_temp = (double *)calloc(
2565  new_mesh->material
2566  ->mat_table_index[new_mesh->material->n_mat_subitem],
2567  sizeof(double));
2568  if ((new_mesh->material->mat_val == NULL) ||
2569  (new_mesh->material->mat_temp == NULL))
2570  HECMW_dlb_memory_exit("new_mesh: material");
2571  for (i = 0; i < new_mesh->material
2572  ->mat_table_index[new_mesh->material->n_mat_subitem];
2573  i++) {
2574  new_mesh->material->mat_val[i] = mesh->material->mat_val[i];
2575  new_mesh->material->mat_temp[i] = mesh->material->mat_temp[i];
2576  }
2577  }
2578  if (mesh->mpc != NULL) {
2579  new_mesh->mpc =
2580  (struct hecmwST_mpc *)calloc(1, sizeof(struct hecmwST_mpc));
2581  if (new_mesh->mpc == NULL) HECMW_dlb_memory_exit("new_mesh: mpc");
2582  new_mesh->mpc->n_mpc = mesh->mpc->n_mpc;
2583  if (new_mesh->mpc->n_mpc != 0) {
2584  new_mesh->mpc->mpc_index =
2585  (int *)calloc(new_mesh->mpc->n_mpc + 1, sizeof(int));
2586  new_mesh->mpc->mpc_item = (int *)calloc(
2587  mesh->mpc->mpc_index[new_mesh->mpc->n_mpc], sizeof(int));
2588  new_mesh->mpc->mpc_dof = (int *)calloc(
2589  mesh->mpc->mpc_index[new_mesh->mpc->n_mpc], sizeof(int));
2590  new_mesh->mpc->mpc_val = (double *)calloc(
2591  mesh->mpc->mpc_index[new_mesh->mpc->n_mpc], sizeof(double));
2592  for (i = 0; i < mesh->mpc->n_mpc + 1; i++)
2593  new_mesh->mpc->mpc_index[i] = mesh->mpc->mpc_index[i];
2594  for (i = 0; i < mesh->mpc->n_mpc; i++) {
2595  new_mesh->mpc->mpc_item[i] = mesh->mpc->mpc_item[i];
2596  new_mesh->mpc->mpc_dof[i] = mesh->mpc->mpc_dof[i];
2597  new_mesh->mpc->mpc_val[i] = mesh->mpc->mpc_val[i];
2598  }
2599  }
2600  }
2601  if (mesh->amp != NULL) {
2602  new_mesh->amp = (struct hecmwST_amplitude *)calloc(
2603  1, sizeof(struct hecmwST_amplitude));
2604  if (new_mesh->amp == NULL) HECMW_dlb_memory_exit("new_mesh: amp");
2605  new_mesh->amp->n_amp = mesh->amp->n_amp;
2606  if (new_mesh->amp->n_amp != 0) {
2607  new_mesh->amp->amp_type_definition =
2608  (int *)calloc(mesh->amp->n_amp, sizeof(int));
2609  new_mesh->amp->amp_type_time =
2610  (int *)calloc(mesh->amp->n_amp, sizeof(int));
2611  new_mesh->amp->amp_type_value =
2612  (int *)calloc(mesh->amp->n_amp, sizeof(int));
2613  new_mesh->amp->amp_index =
2614  (int *)calloc(mesh->amp->n_amp + 1, sizeof(int));
2615  new_mesh->amp->amp_val = (double *)calloc(
2616  mesh->amp->amp_index[mesh->amp->n_amp], sizeof(double));
2617  new_mesh->amp->amp_table = (double *)calloc(
2618  mesh->amp->amp_index[mesh->amp->n_amp], sizeof(double));
2619  if ((new_mesh->amp->amp_type_definition == NULL) ||
2620  (new_mesh->amp->amp_type_time == NULL) ||
2621  (new_mesh->amp->amp_type_value == NULL) ||
2622  (new_mesh->amp->amp_index == NULL) ||
2623  (new_mesh->amp->amp_val == NULL) ||
2624  (new_mesh->amp->amp_table == NULL))
2625  HECMW_dlb_memory_exit("new_mesh: amp");
2626  for (i = 0; i < mesh->amp->n_amp; i++) {
2627  new_mesh->amp->amp_type_definition[i] =
2628  mesh->amp->amp_type_definition[i];
2629  new_mesh->amp->amp_type_time[i] = mesh->amp->amp_type_time[i];
2630  new_mesh->amp->amp_type_value[i] = mesh->amp->amp_type_value[i];
2631  }
2632  for (i = 0; i < mesh->amp->n_amp + 1; i++)
2633  new_mesh->amp->amp_index[i] = mesh->amp->amp_index[i];
2634  for (i = 0; i < mesh->amp->amp_index[mesh->amp->n_amp]; i++) {
2635  new_mesh->amp->amp_val[i] = mesh->amp->amp_val[i];
2636  new_mesh->amp->amp_table[i] = mesh->amp->amp_table[i];
2637  }
2638  }
2639  }
2640 
2641  if (new_mesh->elem_group->n_grp > 0) {
2642  if (new_mesh->elem_group->grp_index[new_mesh->elem_group->n_grp] > 0) {
2643  new_tmp = (int *)calloc(
2644  new_mesh->elem_group->grp_index[new_mesh->elem_group->n_grp],
2645  sizeof(int));
2646  for (i = 0;
2647  i < new_mesh->elem_group->grp_index[new_mesh->elem_group->n_grp];
2648  i++)
2649  new_tmp[i] = old2new[new_mesh->elem_group->grp_item[i] - 1] + 1;
2650  free(new_mesh->elem_group->grp_item);
2651  new_mesh->elem_group->grp_item = new_tmp;
2652  }
2653  }
2654 
2655  if (new_mesh->surf_group->n_grp > 0) {
2656  if (new_mesh->surf_group->grp_index[new_mesh->surf_group->n_grp] > 0) {
2657  new_tmp = (int *)calloc(
2658  new_mesh->surf_group->grp_index[new_mesh->surf_group->n_grp] * 2,
2659  sizeof(int));
2660  for (i = 0;
2661  i < new_mesh->surf_group->grp_index[new_mesh->surf_group->n_grp];
2662  i++) {
2663  new_tmp[i * 2] =
2664  old2new[new_mesh->surf_group->grp_item[i * 2] - 1] + 1;
2665  new_tmp[i * 2 + 1] = new_mesh->surf_group->grp_item[i * 2 + 1];
2666  }
2667  free(new_mesh->surf_group->grp_item);
2668  new_mesh->surf_group->grp_item = new_tmp;
2669  }
2670  }
2671  } else {
2672  new_mesh->elem_type_index = (int *)calloc(2, sizeof(int));
2673  if (new_mesh->elem_type_index == NULL)
2674  HECMW_dlb_memory_exit("new_mesh: elem_type_index");
2675  for (i = 0; i < new_mesh->n_elem_type + 1; i++)
2676  new_mesh->elem_type_index[i] = 0;
2677  new_mesh->elem_type_item =
2678  (int *)calloc(new_mesh->n_elem_type, sizeof(int));
2679  if (new_mesh->elem_type_item == NULL)
2680  HECMW_dlb_memory_exit("new_mesh: elem_type_item");
2681  for (i = 0; i < new_mesh->n_elem_type; i++)
2682  new_mesh->elem_type_item[i] = mesh->elem_type_item[i];
2683  new_mesh->elem_type_index[1] = new_mesh->n_elem;
2684 
2685  /*
2686  fprintf(stderr, "new_mesh: elem_type_index= %d %d %d\n",
2687  new_mesh->elem_type_index[0], new_mesh->elem_type_index[1],
2688  new_mesh->elem_type_index[2]);
2689  */
2690 
2691  /*
2692  for(i=0;i<new_mesh->n_elem;i++)
2693  fprintf(test_fp, "i= %d elem_ID=%d %d\n", i,
2694  new_mesh->elem_ID[i*2], new_mesh->elem_ID[i*2+1]);
2695  fclose(test_fp);
2696  */
2697  new_mesh->my_rank = mesh->my_rank;
2698  new_mesh->zero = mesh->zero;
2699  new_mesh->PETOT = mesh->PETOT;
2700  new_mesh->PEsmpTOT = mesh->PEsmpTOT;
2701  new_mesh->errnof = mesh->errnof;
2702  HECMW_Comm_dup(mesh->HECMW_COMM, &new_mesh->HECMW_COMM);
2703  new_mesh->n_subdomain = mesh->n_subdomain;
2704 
2705  new_mesh->shared_index =
2706  (int *)calloc(new_mesh->n_neighbor_pe + 1, sizeof(int));
2707  if (new_mesh->shared_index == NULL)
2708  HECMW_dlb_memory_exit("new_mesh: shared_index");
2709  for (i = 0; i < new_mesh->n_neighbor_pe + 1; i++)
2710  new_mesh->shared_index[i] = 0;
2711 
2712  if (mesh->section != NULL) {
2713  new_mesh->section =
2714  (struct hecmwST_section *)calloc(1, sizeof(struct hecmwST_section));
2715  if (new_mesh->section == NULL) HECMW_dlb_memory_exit("new_mesh: section");
2716  new_mesh->section->n_sect = mesh->section->n_sect;
2717  new_mesh->section->sect_type =
2718  (int *)calloc(new_mesh->section->n_sect, sizeof(int));
2719  new_mesh->section->sect_opt =
2720  (int *)calloc(new_mesh->section->n_sect, sizeof(int));
2721  if ((new_mesh->section->sect_type == NULL) ||
2722  (new_mesh->section->sect_opt == NULL))
2723  HECMW_dlb_memory_exit("new_mesh: section");
2724  new_mesh->section->sect_mat_ID_index =
2725  (int *)calloc(new_mesh->section->n_sect + 1, sizeof(int));
2726  new_mesh->section->sect_mat_ID_item = (int *)calloc(
2727  mesh->section->sect_mat_ID_index[mesh->section->n_sect], sizeof(int));
2728  for (i = 0; i < mesh->section->n_sect; i++)
2729  new_mesh->section->sect_type[i] = mesh->section->sect_type[i];
2730  for (i = 0; i < mesh->section->n_sect; i++)
2731  new_mesh->section->sect_opt[i] = mesh->section->sect_opt[i];
2732  for (i = 0; i < mesh->section->n_sect + 1; i++)
2733  new_mesh->section->sect_mat_ID_index[i] =
2734  mesh->section->sect_mat_ID_index[i];
2735  for (i = 0; i < mesh->section->sect_mat_ID_index[mesh->section->n_sect];
2736  i++)
2737  new_mesh->section->sect_mat_ID_item[i] =
2738  mesh->section->sect_mat_ID_item[i];
2739  new_mesh->section->sect_I_index =
2740  (int *)calloc(new_mesh->section->n_sect + 1, sizeof(int));
2741  new_mesh->section->sect_R_index =
2742  (int *)calloc(new_mesh->section->n_sect + 1, sizeof(int));
2743 
2744  for (i = 0; i < mesh->section->n_sect + 1; i++)
2745  new_mesh->section->sect_I_index[i] = mesh->section->sect_I_index[i];
2746  for (i = 0; i < mesh->section->n_sect + 1; i++)
2747  new_mesh->section->sect_R_index[i] = mesh->section->sect_R_index[i];
2748  }
2749  if (mesh->material != NULL) {
2750  new_mesh->material =
2751  (struct hecmwST_material *)calloc(1, sizeof(struct hecmwST_material));
2752  if (new_mesh->material == NULL)
2753  HECMW_dlb_memory_exit("new_mesh: material");
2754  new_mesh->material->n_mat = mesh->material->n_mat;
2755  new_mesh->material->n_mat_item = mesh->material->n_mat_item;
2756  new_mesh->material->n_mat_subitem = mesh->material->n_mat_subitem;
2757  new_mesh->material->n_mat_table = mesh->material->n_mat_table;
2758  new_mesh->material->mat_name =
2759  (char **)calloc(new_mesh->material->n_mat, sizeof(char *));
2760  if (new_mesh->material->mat_name == NULL)
2761  HECMW_dlb_memory_exit("new_mesh: material");
2762  for (i = 0; i < new_mesh->material->n_mat; i++) {
2763  new_mesh->material->mat_name[i] = (char *)calloc(name_buf_size, sizeof(char));
2764  snprintf(new_mesh->material->mat_name[i], name_buf_size, "%s",
2765  mesh->material->mat_name[i]);
2766  }
2767  new_mesh->material->mat_item_index =
2768  (int *)calloc(new_mesh->material->n_mat + 1, sizeof(int));
2769  new_mesh->material->mat_subitem_index =
2770  (int *)calloc(new_mesh->material->n_mat_item + 1, sizeof(int));
2771  new_mesh->material->mat_table_index =
2772  (int *)calloc(new_mesh->material->n_mat_subitem + 1, sizeof(int));
2773  if ((new_mesh->material->mat_item_index == NULL) ||
2774  (new_mesh->material->mat_subitem_index == NULL) ||
2775  (new_mesh->material->mat_table_index == NULL))
2776  HECMW_dlb_memory_exit("new_mesh: material");
2777  for (i = 0; i < new_mesh->material->n_mat + 1; i++)
2778  new_mesh->material->mat_item_index[i] =
2779  mesh->material->mat_item_index[i];
2780  for (i = 0; i < new_mesh->material->n_mat_item + 1; i++)
2781  new_mesh->material->mat_subitem_index[i] =
2782  mesh->material->mat_subitem_index[i];
2783  for (i = 0; i < new_mesh->material->n_mat_subitem + 1; i++)
2784  new_mesh->material->mat_table_index[i] =
2785  mesh->material->mat_table_index[i];
2786  new_mesh->material->mat_val = (double *)calloc(
2787  new_mesh->material
2788  ->mat_table_index[new_mesh->material->n_mat_subitem],
2789  sizeof(double));
2790  new_mesh->material->mat_temp = (double *)calloc(
2791  new_mesh->material
2792  ->mat_table_index[new_mesh->material->n_mat_subitem],
2793  sizeof(double));
2794  if ((new_mesh->material->mat_val == NULL) ||
2795  (new_mesh->material->mat_temp == NULL))
2796  HECMW_dlb_memory_exit("new_mesh: material");
2797  for (i = 0; i < new_mesh->material
2798  ->mat_table_index[new_mesh->material->n_mat_subitem];
2799  i++) {
2800  new_mesh->material->mat_val[i] = mesh->material->mat_val[i];
2801  new_mesh->material->mat_temp[i] = mesh->material->mat_temp[i];
2802  }
2803  }
2804  if (mesh->mpc != NULL) {
2805  new_mesh->mpc =
2806  (struct hecmwST_mpc *)calloc(1, sizeof(struct hecmwST_mpc));
2807  if (new_mesh->mpc == NULL) HECMW_dlb_memory_exit("new_mesh: mpc");
2808  new_mesh->mpc->n_mpc = mesh->mpc->n_mpc;
2809  if (new_mesh->mpc->n_mpc != 0) {
2810  new_mesh->mpc->mpc_index =
2811  (int *)calloc(new_mesh->mpc->n_mpc + 1, sizeof(int));
2812  new_mesh->mpc->mpc_item = (int *)calloc(
2813  mesh->mpc->mpc_index[new_mesh->mpc->n_mpc], sizeof(int));
2814  new_mesh->mpc->mpc_dof = (int *)calloc(
2815  mesh->mpc->mpc_index[new_mesh->mpc->n_mpc], sizeof(int));
2816  new_mesh->mpc->mpc_val = (double *)calloc(
2817  mesh->mpc->mpc_index[new_mesh->mpc->n_mpc], sizeof(double));
2818  for (i = 0; i < mesh->mpc->n_mpc + 1; i++)
2819  new_mesh->mpc->mpc_index[i] = mesh->mpc->mpc_index[i];
2820  for (i = 0; i < mesh->mpc->n_mpc; i++) {
2821  new_mesh->mpc->mpc_item[i] = mesh->mpc->mpc_item[i];
2822  new_mesh->mpc->mpc_dof[i] = mesh->mpc->mpc_dof[i];
2823  new_mesh->mpc->mpc_val[i] = mesh->mpc->mpc_val[i];
2824  }
2825  }
2826  }
2827  if (mesh->amp != NULL) {
2828  new_mesh->amp = (struct hecmwST_amplitude *)calloc(
2829  1, sizeof(struct hecmwST_amplitude));
2830  if (new_mesh->amp == NULL) HECMW_dlb_memory_exit("new_mesh: amp");
2831  new_mesh->amp->n_amp = mesh->amp->n_amp;
2832  if (new_mesh->amp->n_amp != 0) {
2833  new_mesh->amp->amp_type_definition =
2834  (int *)calloc(mesh->amp->n_amp, sizeof(int));
2835  new_mesh->amp->amp_type_time =
2836  (int *)calloc(mesh->amp->n_amp, sizeof(int));
2837  new_mesh->amp->amp_type_value =
2838  (int *)calloc(mesh->amp->n_amp, sizeof(int));
2839  new_mesh->amp->amp_index =
2840  (int *)calloc(mesh->amp->n_amp + 1, sizeof(int));
2841  new_mesh->amp->amp_val = (double *)calloc(
2842  mesh->amp->amp_index[mesh->amp->n_amp], sizeof(double));
2843  new_mesh->amp->amp_table = (double *)calloc(
2844  mesh->amp->amp_index[mesh->amp->n_amp], sizeof(double));
2845  if ((new_mesh->amp->amp_type_definition == NULL) ||
2846  (new_mesh->amp->amp_type_time == NULL) ||
2847  (new_mesh->amp->amp_type_value == NULL) ||
2848  (new_mesh->amp->amp_index == NULL) ||
2849  (new_mesh->amp->amp_val == NULL) ||
2850  (new_mesh->amp->amp_table == NULL))
2851  HECMW_dlb_memory_exit("new_mesh: amp");
2852  for (i = 0; i < mesh->amp->n_amp; i++) {
2853  new_mesh->amp->amp_type_definition[i] =
2854  mesh->amp->amp_type_definition[i];
2855  new_mesh->amp->amp_type_time[i] = mesh->amp->amp_type_time[i];
2856  new_mesh->amp->amp_type_value[i] = mesh->amp->amp_type_value[i];
2857  }
2858  for (i = 0; i < mesh->amp->n_amp + 1; i++)
2859  new_mesh->amp->amp_index[i] = mesh->amp->amp_index[i];
2860  for (i = 0; i < mesh->amp->amp_index[mesh->amp->n_amp]; i++) {
2861  new_mesh->amp->amp_val[i] = mesh->amp->amp_val[i];
2862  new_mesh->amp->amp_table[i] = mesh->amp->amp_table[i];
2863  }
2864  }
2865  }
2866  }
2867  new_mesh->node_internal_list =
2868  (int *)calloc(new_mesh->nn_internal, sizeof(int));
2869  if (new_mesh->node_internal_list == NULL)
2870  HECMW_dlb_memory_exit("node_internal_list");
2871  for (i = 0; i < new_mesh->nn_internal; i++)
2872  new_mesh->node_internal_list[i] = i;
2873  if (mynode == 0) {
2874  t2 = HECMW_Wtime();
2875  fprintf(stderr,
2876  "Finish migration now. The time cost for migration and generating "
2877  "new mesh is %lf\n",
2878  t2 - t1);
2879  }
2880  return;
2881 }
if
if(!(yy_init))
Definition: hecmw_ablex.c:1823
HECMW_Allreduce
int HECMW_Allreduce(void *sendbuf, void *recvbuf, int count, HECMW_Datatype datatype, HECMW_Op op, HECMW_Comm comm)
Definition: hecmw_comm.c:404
HECMW_Send
int HECMW_Send(void *buffer, int count, HECMW_Datatype datatype, int dest, int tag, HECMW_Comm comm)
Definition: hecmw_comm.c:201
HECMW_Barrier
int HECMW_Barrier(HECMW_Comm comm)
Definition: hecmw_comm.c:95
HECMW_Recv
int HECMW_Recv(void *buffer, int count, HECMW_Datatype datatype, int source, int tag, HECMW_Comm comm, HECMW_Status *status)
Definition: hecmw_comm.c:251
HECMW_Comm_dup
int HECMW_Comm_dup(HECMW_Comm comm, HECMW_Comm *new_comm)
Definition: hecmw_comm.c:56
HECMW_INT
#define HECMW_INT
Definition: hecmw_config.h:48
HECMW_Status
MPI_Status HECMW_Status
Definition: hecmw_config.h:36
HECMW_Comm
MPI_Comm HECMW_Comm
Definition: hecmw_config.h:30
HECMW_SUM
#define HECMW_SUM
Definition: hecmw_config.h:60
HECMW_ANY_TAG
int HECMW_ANY_TAG
Definition: hecmw_dlb_comm_util.h:7
new_data
struct hecmwST_result_data * new_data
Definition: hecmw_repart.h:76
whole_copy_array
void whole_copy_array(int *recv_elem_num, int *global_recv_elem_num, int mynode, int pesize, HECMW_Comm repart_comm)
Definition: hecmw_dlb_comm_util.c:100
int2_whole_send_recv
void int2_whole_send_recv(int n1, int n2, int pesize, int *stack_import, int *stack_export, int *x, int *y, HECMW_Comm repart_comm, int my_rank)
Definition: hecmw_dlb_comm_util.c:519
double2_whole_send_recv
void double2_whole_send_recv(int n1, int n2, int pesize, int *stack_import, int *stack_export, double *x, double *y, HECMW_Comm repart_comm, int my_rank)
Definition: hecmw_dlb_comm_util.c:592
stack_whole_send_recv
int stack_whole_send_recv(int pesize, int *stack_import, int *stack_export, HECMW_Comm repart_comm, int my_rank)
Definition: hecmw_dlb_comm_util.c:173
int_whole_send_recv
void int_whole_send_recv(int n1, int n2, int pesize, int *stack_import, int *nod_import, int *stack_export, int *nod_export, int *x, int *y, HECMW_Comm repart_comm, int my_rank)
Definition: hecmw_dlb_comm_util.c:421
new_mesh
struct hecmwST_local_mesh * new_mesh
Definition: hecmw_repart.h:72
int3_whole_send_recv
void int3_whole_send_recv(int n1, int n2, int pesize, int *stack_import, int *stack_export, int *x, int *y, HECMW_Comm repart_comm, int my_rank)
Definition: hecmw_dlb_comm_util.c:664
int_part_send_recv
int int_part_send_recv(int n, int neibpetot, int *neibpe, int *stack_import, int *nod_import, int *stack_export, int *nod_export, int *x, HECMW_Comm repart_comm, int my_rank)
Definition: hecmw_dlb_comm_util.c:260
mesh_migration_adapt
void mesh_migration_adapt(int mynode, int pesize, Result_part *result, int *vtxdist)
Definition: hecmw_dlb_elem_sr_adapt.c:50
double_part_send_recv
int double_part_send_recv(int n, int neibpetot, int *neibpe, int *stack_import, int *nod_import, int *stack_export, int *nod_export, double *x, HECMW_Comm repart_comm, int my_rank)
Definition: hecmw_dlb_comm_util.c:336
mesh
struct hecmwST_local_mesh * mesh
Definition: hecmw_repart.h:71
stack_part_send_recv
int stack_part_send_recv(int neibpetot, int *neibpe, int *stack_import, int *stack_export, HECMW_Comm repart_comm, int my_rank)
Definition: hecmw_dlb_comm_util.c:128
data
struct hecmwST_result_data * data
Definition: neu_reporter.cpp:18
double_whole_send_recv
void double_whole_send_recv(int n1, int n2, int pesize, int *stack_import, int *nod_import, int *stack_export, int *nod_export, double *x, double *y, HECMW_Comm repart_comm, int my_rank)
Definition: hecmw_dlb_comm_util.c:705
HECMW_dlb_print_exit
void HECMW_dlb_print_exit(char *var)
Definition: hecmw_dlb_mem_util.c:17
HECMW_dlb_memory_exit
void HECMW_dlb_memory_exit(char *var)
Definition: hecmw_dlb_mem_util.c:8
NULL
#define NULL
Definition: hecmw_io_nastran.c:30
hecmw_repart.h
repart_comm
int repart_comm
Definition: hecmw_repart.h:70
HECMW_Wtime
double HECMW_Wtime(void)
Definition: hecmw_time.c:8
_result_partition_struct
Definition: hecmw_repart.h:52
_result_partition_struct::part
int * part
Definition: hecmw_repart.h:55
_result_partition_struct::t_node
int t_node
Definition: hecmw_repart.h:54
_tmp_grp_inf
Definition: hecmw_repart.h:29
_tmp_grp_inf::item
int * item
Definition: hecmw_repart.h:31
_tmp_grp_inf::num_of_item
int num_of_item
Definition: hecmw_repart.h:30
hecmwST_amplitude
Definition: hecmw_struct.h:57
hecmwST_amplitude::amp_type_definition
int * amp_type_definition
Definition: hecmw_struct.h:61
hecmwST_amplitude::amp_val
double * amp_val
Definition: hecmw_struct.h:71
hecmwST_amplitude::n_amp
int n_amp
Definition: hecmw_struct.h:58
hecmwST_amplitude::amp_type_time
int * amp_type_time
Definition: hecmw_struct.h:64
hecmwST_amplitude::amp_index
int * amp_index
Definition: hecmw_struct.h:70
hecmwST_amplitude::amp_type_value
int * amp_type_value
Definition: hecmw_struct.h:67
hecmwST_amplitude::amp_table
double * amp_table
Definition: hecmw_struct.h:72
hecmwST_elem_grp
Definition: hecmw_struct.h:92
hecmwST_elem_grp::grp_name
char ** grp_name
Definition: hecmw_struct.h:94
hecmwST_elem_grp::grp_item
int * grp_item
Definition: hecmw_struct.h:96
hecmwST_elem_grp::n_grp
int n_grp
Definition: hecmw_struct.h:93
hecmwST_elem_grp::grp_index
int * grp_index
Definition: hecmw_struct.h:95
hecmwST_local_mesh
Definition: hecmw_struct.h:139
hecmwST_local_mesh::section
struct hecmwST_section * section
Definition: hecmw_struct.h:245
hecmwST_local_mesh::n_node
int n_node
Definition: hecmw_struct.h:161
hecmwST_local_mesh::adapt_children_item
int * adapt_children_item
Definition: hecmw_struct.h:235
hecmwST_local_mesh::elem_mat_ID_index
int * elem_mat_ID_index
Definition: hecmw_struct.h:198
hecmwST_local_mesh::hecmw_n_file
int hecmw_n_file
Definition: hecmw_struct.h:155
hecmwST_local_mesh::export_item
int * export_item
Definition: hecmw_struct.h:220
hecmwST_local_mesh::n_elem_type
int n_elem_type
Definition: hecmw_struct.h:192
hecmwST_local_mesh::export_index
int * export_index
Definition: hecmw_struct.h:219
hecmwST_local_mesh::node
double * node
Definition: hecmw_struct.h:170
hecmwST_local_mesh::n_subdomain
int n_subdomain
Definition: hecmw_struct.h:214
hecmwST_local_mesh::hecmw_flag_initcon
int hecmw_flag_initcon
Definition: hecmw_struct.h:141
hecmwST_local_mesh::elem_internal_list
int * elem_internal_list
Definition: hecmw_struct.h:187
hecmwST_local_mesh::neighbor_pe
int * neighbor_pe
Definition: hecmw_struct.h:216
hecmwST_local_mesh::elem_ID
int * elem_ID
Definition: hecmw_struct.h:189
hecmwST_local_mesh::elem_mat_int_val
double * elem_mat_int_val
Definition: hecmw_struct.h:203
hecmwST_local_mesh::hecmw_flag_partdepth
int hecmw_flag_partdepth
Definition: hecmw_struct.h:146
hecmwST_local_mesh::elem_type_index
int * elem_type_index
Definition: hecmw_struct.h:193
hecmwST_local_mesh::adapt_type
int * adapt_type
Definition: hecmw_struct.h:230
hecmwST_local_mesh::adapt_parent_type
int * adapt_parent_type
Definition: hecmw_struct.h:229
hecmwST_local_mesh::adapt_children_index
int * adapt_children_index
Definition: hecmw_struct.h:234
hecmwST_local_mesh::ne_internal
int ne_internal
Definition: hecmw_struct.h:186
hecmwST_local_mesh::amp
struct hecmwST_amplitude * amp
Definition: hecmw_struct.h:248
hecmwST_local_mesh::elem_type
int * elem_type
Definition: hecmw_struct.h:191
hecmwST_local_mesh::adapt_parent
int * adapt_parent
Definition: hecmw_struct.h:233
hecmwST_local_mesh::elem_node_item
int * elem_node_item
Definition: hecmw_struct.h:196
hecmwST_local_mesh::elem_mat_ID_item
int * elem_mat_ID_item
Definition: hecmw_struct.h:199
hecmwST_local_mesh::material
struct hecmwST_material * material
Definition: hecmw_struct.h:246
hecmwST_local_mesh::node_dof_item
int * node_dof_item
Definition: hecmw_struct.h:175
hecmwST_local_mesh::n_neighbor_pe
int n_neighbor_pe
Definition: hecmw_struct.h:215
hecmwST_local_mesh::global_node_ID
int * global_node_ID
Definition: hecmw_struct.h:168
hecmwST_local_mesh::section_ID
int * section_ID
Definition: hecmw_struct.h:197
hecmwST_local_mesh::import_item
int * import_item
Definition: hecmw_struct.h:218
hecmwST_local_mesh::mpc
struct hecmwST_mpc * mpc
Definition: hecmw_struct.h:247
hecmwST_local_mesh::node_group
struct hecmwST_node_grp * node_group
Definition: hecmw_struct.h:249
hecmwST_local_mesh::zero_temp
double zero_temp
Definition: hecmw_struct.h:158
hecmwST_local_mesh::import_index
int * import_index
Definition: hecmw_struct.h:217
hecmwST_local_mesh::hecmw_flag_version
int hecmw_flag_version
Definition: hecmw_struct.h:147
hecmwST_local_mesh::surf_group
struct hecmwST_surf_grp * surf_group
Definition: hecmw_struct.h:251
hecmwST_local_mesh::n_elem_mat_ID
int n_elem_mat_ID
Definition: hecmw_struct.h:200
hecmwST_local_mesh::node_internal_list
int * node_internal_list
Definition: hecmw_struct.h:165
hecmwST_local_mesh::errnof
int errnof
Definition: hecmw_struct.h:213
hecmwST_local_mesh::elem_node_index
long long * elem_node_index
Definition: hecmw_struct.h:195
hecmwST_local_mesh::coarse_grid_level
int coarse_grid_level
Definition: hecmw_struct.h:225
hecmwST_local_mesh::n_elem
int n_elem
Definition: hecmw_struct.h:184
hecmwST_local_mesh::gridfile
char gridfile[HECMW_FILENAME_LEN+1]
Definition: hecmw_struct.h:154
hecmwST_local_mesh::header
char header[HECMW_HEADER_LEN+1]
Definition: hecmw_struct.h:157
hecmwST_local_mesh::PETOT
int PETOT
Definition: hecmw_struct.h:210
hecmwST_local_mesh::hecmw_flag_parttype
int hecmw_flag_parttype
Definition: hecmw_struct.h:142
hecmwST_local_mesh::HECMW_COMM
HECMW_Comm HECMW_COMM
Definition: hecmw_struct.h:209
hecmwST_local_mesh::node_dof_index
int * node_dof_index
Definition: hecmw_struct.h:174
hecmwST_local_mesh::elem_group
struct hecmwST_elem_grp * elem_group
Definition: hecmw_struct.h:250
hecmwST_local_mesh::adapt_level
int * adapt_level
Definition: hecmw_struct.h:231
hecmwST_local_mesh::PEsmpTOT
int PEsmpTOT
Definition: hecmw_struct.h:211
hecmwST_local_mesh::nn_internal
int nn_internal
Definition: hecmw_struct.h:164
hecmwST_local_mesh::zero
int zero
Definition: hecmw_struct.h:208
hecmwST_local_mesh::elem_type_item
int * elem_type_item
Definition: hecmw_struct.h:194
hecmwST_local_mesh::when_i_was_refined_node
int * when_i_was_refined_node
Definition: hecmw_struct.h:227
hecmwST_local_mesh::files
char ** files
Definition: hecmw_struct.h:156
hecmwST_local_mesh::shared_index
int * shared_index
Definition: hecmw_struct.h:221
hecmwST_local_mesh::n_dof
int n_dof
Definition: hecmw_struct.h:171
hecmwST_local_mesh::node_ID
int * node_ID
Definition: hecmw_struct.h:167
hecmwST_local_mesh::my_rank
int my_rank
Definition: hecmw_struct.h:212
hecmwST_local_mesh::n_dof_grp
int n_dof_grp
Definition: hecmw_struct.h:172
hecmwST_local_mesh::n_adapt
int n_adapt
Definition: hecmw_struct.h:226
hecmwST_local_mesh::when_i_was_refined_elem
int * when_i_was_refined_elem
Definition: hecmw_struct.h:228
hecmwST_local_mesh::hecmw_flag_adapt
int hecmw_flag_adapt
Definition: hecmw_struct.h:140
hecmwST_local_mesh::global_elem_ID
int * global_elem_ID
Definition: hecmw_struct.h:190
hecmwST_material
Definition: hecmw_struct.h:35
hecmwST_material::mat_item_index
int * mat_item_index
Definition: hecmw_struct.h:41
hecmwST_material::mat_subitem_index
int * mat_subitem_index
Definition: hecmw_struct.h:42
hecmwST_material::n_mat
int n_mat
Definition: hecmw_struct.h:36
hecmwST_material::mat_val
double * mat_val
Definition: hecmw_struct.h:44
hecmwST_material::mat_table_index
int * mat_table_index
Definition: hecmw_struct.h:43
hecmwST_material::mat_name
char ** mat_name
Definition: hecmw_struct.h:40
hecmwST_material::n_mat_subitem
int n_mat_subitem
Definition: hecmw_struct.h:38
hecmwST_material::mat_temp
double * mat_temp
Definition: hecmw_struct.h:45
hecmwST_material::n_mat_item
int n_mat_item
Definition: hecmw_struct.h:37
hecmwST_material::n_mat_table
int n_mat_table
Definition: hecmw_struct.h:39
hecmwST_mpc
Definition: hecmw_struct.h:48
hecmwST_mpc::mpc_dof
int * mpc_dof
Definition: hecmw_struct.h:52
hecmwST_mpc::n_mpc
int n_mpc
Definition: hecmw_struct.h:49
hecmwST_mpc::mpc_val
double * mpc_val
Definition: hecmw_struct.h:53
hecmwST_mpc::mpc_index
int * mpc_index
Definition: hecmw_struct.h:50
hecmwST_mpc::mpc_item
int * mpc_item
Definition: hecmw_struct.h:51
hecmwST_node_grp
Definition: hecmw_struct.h:75
hecmwST_node_grp::grp_name
char ** grp_name
Definition: hecmw_struct.h:77
hecmwST_node_grp::grp_index
int * grp_index
Definition: hecmw_struct.h:78
hecmwST_node_grp::n_grp
int n_grp
Definition: hecmw_struct.h:76
hecmwST_node_grp::grp_item
int * grp_item
Definition: hecmw_struct.h:79
hecmwST_result_data
Definition: hecmw_result.h:11
hecmwST_result_data::nn_component
int nn_component
Definition: hecmw_result.h:13
hecmwST_result_data::node_label
char ** node_label
Definition: hecmw_result.h:19
hecmwST_result_data::ne_component
int ne_component
Definition: hecmw_result.h:14
hecmwST_result_data::elem_label
char ** elem_label
Definition: hecmw_result.h:20
hecmwST_result_data::ne_dof
int * ne_dof
Definition: hecmw_result.h:17
hecmwST_result_data::nn_dof
int * nn_dof
Definition: hecmw_result.h:16
hecmwST_result_data::node_val_item
double * node_val_item
Definition: hecmw_result.h:22
hecmwST_section
Definition: hecmw_struct.h:11
hecmwST_section::sect_I_index
int * sect_I_index
Definition: hecmw_struct.h:29
hecmwST_section::sect_opt
int * sect_opt
Definition: hecmw_struct.h:20
hecmwST_section::sect_R_item
double * sect_R_item
Definition: hecmw_struct.h:32
hecmwST_section::sect_I_item
int * sect_I_item
Definition: hecmw_struct.h:30
hecmwST_section::sect_type
int * sect_type
Definition: hecmw_struct.h:14
hecmwST_section::sect_mat_ID_index
int * sect_mat_ID_index
Definition: hecmw_struct.h:27
hecmwST_section::sect_mat_ID_item
int * sect_mat_ID_item
Definition: hecmw_struct.h:28
hecmwST_section::sect_R_index
int * sect_R_index
Definition: hecmw_struct.h:31
hecmwST_section::n_sect
int n_sect
Definition: hecmw_struct.h:12
hecmwST_surf_grp
Definition: hecmw_struct.h:106
hecmwST_surf_grp::grp_item
int * grp_item
Definition: hecmw_struct.h:111
hecmwST_surf_grp::grp_name
char ** grp_name
Definition: hecmw_struct.h:108
hecmwST_surf_grp::n_grp
int n_grp
Definition: hecmw_struct.h:107
hecmwST_surf_grp::grp_index
int * grp_index
Definition: hecmw_struct.h:109