FrontISTR  5.7.0
Large-scale structural analysis program with finit element method
hecmw_mesh_hash_sort.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 <stdio.h>
7 #include <stdlib.h>
8 #include <string.h>
9 #include <assert.h>
10 #include <errno.h>
11 #include <math.h>
12 
13 #include "hecmw_msgno.h"
14 #include "hecmw_malloc.h"
15 #include "hecmw_error.h"
16 
17 #include "hecmw_part_define.h"
18 #include "hecmw_mesh_hash_sort.h"
19 
20 #define EDGE_INC_FACTOR (1.2)
21 
22 #define TSUF_INC_FACTOR (1.1)
23 
24 #define QSUF_INC_FACTOR (1.1)
25 
26 struct hecmw_mesh_hash_link {
27  int key;
28 
29  struct hecmw_mesh_hash_link *next;
30 };
31 
32 static long long int n_edge = 0;
33 
34 static int *__edge_node = NULL;
35 
36 static struct hecmw_mesh_hash_link **e_hash_tbl = NULL;
37 
38 static size_t e_hash_size;
39 
40 static size_t e_buf_size;
41 
42 static int n_tsuf = 0;
43 
44 static int *__tsuf_node = NULL;
45 
46 static struct hecmw_mesh_hash_link **t_hash_tbl = NULL;
47 
48 static size_t t_hash_size;
49 
50 static size_t t_buf_size;
51 
52 static int n_qsuf = 0;
53 
54 static int *__qsuf_node = NULL;
55 
56 static struct hecmw_mesh_hash_link **q_hash_tbl = NULL;
57 
58 static size_t q_hash_size;
59 
60 static size_t q_buf_size;
61 
62 struct hecmw_edge_node {
63  int *node1;
64 
65  int *node2;
66 };
67 
68 struct hecmw_tsuf_node {
69  int *node1;
70 
71  int *node2;
72 
73  int *node3;
74 };
75 
76 struct hecmw_qsuf_node {
77  int *node1;
78 
79  int *node2;
80 
81  int *node3;
82 
83  int *node4;
84 };
85 
86 static struct hecmw_edge_node *edge_node = NULL;
87 
88 static struct hecmw_tsuf_node *tsuf_node = NULL;
89 
90 static struct hecmw_qsuf_node *qsuf_node = NULL;
91 
92 /*================================================================================================*/
93 
94 extern int HECMW_mesh_hsort_edge_init(int n_node, int n_elem) {
95  size_t size;
96  long long int i;
97 
98  if (n_node <= 0) {
99  HECMW_set_error(HECMW_PART_E_INV_ARG, "n_node=%d", n_node);
100  goto error;
101  }
102  if (n_elem <= 0) {
103  HECMW_set_error(HECMW_PART_E_INV_ARG, "n_elem=%d", n_elem);
104  goto error;
105  }
106 
107  if (n_node < 1000000 && n_elem < 1000000) {
108  e_hash_size = (n_node > n_elem) ? n_node : n_elem;
109  e_buf_size = (n_node > n_elem) ? 10 * n_node : 10 * n_elem;
110  } else {
111  e_hash_size = (n_node > n_elem) ? n_node : n_elem;
112  e_buf_size = (n_node > n_elem) ? n_node : n_elem;
113  }
114 
115  edge_node =
116  (struct hecmw_edge_node *)HECMW_malloc(sizeof(struct hecmw_edge_node));
117  if (edge_node == NULL) {
118  HECMW_set_error(errno, "");
119  goto error;
120  } else {
121  edge_node->node1 = NULL;
122  edge_node->node2 = NULL;
123  }
124  edge_node->node1 = (int *)HECMW_malloc(sizeof(int) * e_buf_size);
125  if (edge_node->node1 == NULL) {
126  HECMW_set_error(errno, "");
127  goto error;
128  }
129  edge_node->node2 = (int *)HECMW_malloc(sizeof(int) * e_buf_size);
130  if (edge_node->node2 == NULL) {
131  HECMW_set_error(errno, "");
132  goto error;
133  }
134 
135  size = sizeof(struct hecmw_mesh_hash_link *) * e_hash_size;
136  e_hash_tbl = (struct hecmw_mesh_hash_link **)HECMW_malloc(size);
137  if (e_hash_tbl == NULL) {
138  HECMW_set_error(errno, "");
139  goto error;
140  } else {
141  for (i = 0; i < e_hash_size; i++) {
142  e_hash_tbl[i] = NULL;
143  }
144  }
145 
146  n_edge = 0;
147 
148  return 0;
149 
150 error:
151  HECMW_mesh_hsort_edge_final();
152 
153  return -1;
154 }
155 
156 extern int HECMW_mesh_hsort_tsuf_init(int n_node, int n_elem) {
157  size_t size;
158  long long int i;
159 
160  if (n_node <= 0) {
161  HECMW_set_error(HECMW_PART_E_INV_ARG, "n_node=%d", n_node);
162  goto error;
163  }
164  if (n_elem <= 0) {
165  HECMW_set_error(HECMW_PART_E_INV_ARG, "n_elem=%d", n_elem);
166  goto error;
167  }
168 
169  if (n_node < 1000000 && n_elem < 1000000) {
170  t_hash_size = (n_node > n_elem) ? n_node : n_elem;
171  t_buf_size = (n_node > n_elem) ? 4 * n_node : 4 * n_elem;
172  } else {
173  t_hash_size = (n_node > n_elem) ? n_node : n_elem;
174  t_buf_size = (n_node > n_elem) ? n_node : n_elem;
175  }
176 
177  tsuf_node =
178  (struct hecmw_tsuf_node *)HECMW_malloc(sizeof(struct hecmw_tsuf_node));
179  if (tsuf_node == NULL) {
180  HECMW_set_error(errno, "");
181  goto error;
182  } else {
183  tsuf_node->node1 = NULL;
184  tsuf_node->node2 = NULL;
185  tsuf_node->node3 = NULL;
186  }
187  tsuf_node->node1 = (int *)HECMW_malloc(sizeof(int) * t_buf_size);
188  if (tsuf_node->node1 == NULL) {
189  HECMW_set_error(errno, "");
190  goto error;
191  }
192  tsuf_node->node2 = (int *)HECMW_malloc(sizeof(int) * t_buf_size);
193  if (tsuf_node->node2 == NULL) {
194  HECMW_set_error(errno, "");
195  goto error;
196  }
197  tsuf_node->node3 = (int *)HECMW_malloc(sizeof(int) * t_buf_size);
198  if (tsuf_node->node3 == NULL) {
199  HECMW_set_error(errno, "");
200  goto error;
201  }
202 
203  size = sizeof(struct hecmw_mesh_hash_link *) * t_hash_size;
204  t_hash_tbl = (struct hecmw_mesh_hash_link **)HECMW_malloc(size);
205  if (t_hash_tbl == NULL) {
206  HECMW_set_error(errno, "");
207  goto error;
208  } else {
209  for (i = 0; i < t_hash_size; i++) {
210  t_hash_tbl[i] = NULL;
211  }
212  }
213 
214  n_tsuf = 0;
215 
216  return 0;
217 
218 error:
219  HECMW_mesh_hsort_tsuf_final();
220 
221  return -1;
222 }
223 
224 extern int HECMW_mesh_hsort_qsuf_init(int n_node, int n_elem) {
225  size_t size;
226  long long int i;
227 
228  if (n_node <= 0) {
229  HECMW_set_error(HECMW_PART_E_INV_ARG, "n_node=%d", n_node);
230  goto error;
231  }
232  if (n_elem <= 0) {
233  HECMW_set_error(HECMW_PART_E_INV_ARG, "n_elem=%d", n_elem);
234  goto error;
235  }
236 
237  if (n_node < 1000000 && n_elem < 1000000) {
238  q_hash_size = (n_node > n_elem) ? n_node : n_elem;
239  q_buf_size = (n_node > n_elem) ? 5 * n_node : 5 * n_elem;
240  } else {
241  q_hash_size = (n_node > n_elem) ? n_node : n_elem;
242  q_buf_size = (n_node > n_elem) ? n_node : n_elem;
243  }
244 
245  qsuf_node =
246  (struct hecmw_qsuf_node *)HECMW_malloc(sizeof(struct hecmw_qsuf_node));
247  if (qsuf_node == NULL) {
248  HECMW_set_error(errno, "");
249  goto error;
250  } else {
251  qsuf_node->node1 = NULL;
252  qsuf_node->node2 = NULL;
253  qsuf_node->node3 = NULL;
254  qsuf_node->node4 = NULL;
255  }
256  qsuf_node->node1 = (int *)HECMW_malloc(sizeof(int) * q_buf_size);
257  if (qsuf_node->node1 == NULL) {
258  HECMW_set_error(errno, "");
259  goto error;
260  }
261  qsuf_node->node2 = (int *)HECMW_malloc(sizeof(int) * q_buf_size);
262  if (qsuf_node->node2 == NULL) {
263  HECMW_set_error(errno, "");
264  goto error;
265  }
266  qsuf_node->node3 = (int *)HECMW_malloc(sizeof(int) * q_buf_size);
267  if (qsuf_node->node3 == NULL) {
268  HECMW_set_error(errno, "");
269  goto error;
270  }
271  qsuf_node->node4 = (int *)HECMW_malloc(sizeof(int) * q_buf_size);
272  if (qsuf_node->node4 == NULL) {
273  HECMW_set_error(errno, "");
274  goto error;
275  }
276 
277  size = sizeof(struct hecmw_mesh_hash_link *) * q_hash_size;
278  q_hash_tbl = (struct hecmw_mesh_hash_link **)HECMW_malloc(size);
279  if (q_hash_tbl == NULL) {
280  HECMW_set_error(errno, "");
281  goto error;
282  } else {
283  for (i = 0; i < q_hash_size; i++) {
284  q_hash_tbl[i] = NULL;
285  }
286  }
287 
288  n_qsuf = 0;
289 
290  return 0;
291 
292 error:
293  HECMW_mesh_hsort_qsuf_final();
294 
295  return -1;
296 }
297 
298 /*================================================================================================*/
299 
300 extern int HECMW_mesh_hsort_edge_realloc(void) {
301  size_t new_buf_size;
302 
303  new_buf_size = (size_t)(e_buf_size * EDGE_INC_FACTOR);
304 
305  edge_node->node1 =
306  (int *)HECMW_realloc(edge_node->node1, sizeof(int) * new_buf_size);
307  if (edge_node->node1 == NULL) {
308  HECMW_set_error(errno, "");
309  goto error;
310  }
311  edge_node->node2 =
312  (int *)HECMW_realloc(edge_node->node2, sizeof(int) * new_buf_size);
313  if (edge_node->node2 == NULL) {
314  HECMW_set_error(errno, "");
315  goto error;
316  }
317 
318  e_buf_size = new_buf_size;
319 
320  return 0;
321 
322 error:
323  HECMW_mesh_hsort_edge_final();
324 
325  return -1;
326 }
327 
328 extern int HECMW_mesh_hsort_tsuf_realloc(void) {
329  size_t new_buf_size;
330 
331  new_buf_size = (size_t)(t_buf_size * TSUF_INC_FACTOR);
332 
333  tsuf_node->node1 =
334  (int *)HECMW_realloc(tsuf_node->node1, sizeof(int) * new_buf_size);
335  if (tsuf_node->node1 == NULL) {
336  HECMW_set_error(errno, "");
337  goto error;
338  }
339  tsuf_node->node2 =
340  (int *)HECMW_realloc(tsuf_node->node2, sizeof(int) * new_buf_size);
341  if (tsuf_node->node2 == NULL) {
342  HECMW_set_error(errno, "");
343  goto error;
344  }
345  tsuf_node->node3 =
346  (int *)HECMW_realloc(tsuf_node->node3, sizeof(int) * new_buf_size);
347  if (tsuf_node->node3 == NULL) {
348  HECMW_set_error(errno, "");
349  goto error;
350  }
351 
352  t_buf_size = new_buf_size;
353 
354  return 0;
355 
356 error:
357  HECMW_mesh_hsort_tsuf_final();
358 
359  return -1;
360 }
361 
362 extern int HECMW_mesh_hsort_qsuf_realloc(void) {
363  size_t new_buf_size;
364 
365  new_buf_size = (size_t)(q_buf_size * QSUF_INC_FACTOR);
366 
367  qsuf_node->node1 =
368  (int *)HECMW_realloc(qsuf_node->node1, sizeof(int) * new_buf_size);
369  if (qsuf_node->node1 == NULL) {
370  HECMW_set_error(errno, "");
371  goto error;
372  }
373  qsuf_node->node2 =
374  (int *)HECMW_realloc(qsuf_node->node2, sizeof(int) * new_buf_size);
375  if (qsuf_node->node2 == NULL) {
376  HECMW_set_error(errno, "");
377  goto error;
378  }
379  qsuf_node->node3 =
380  (int *)HECMW_realloc(qsuf_node->node3, sizeof(int) * new_buf_size);
381  if (qsuf_node->node3 == NULL) {
382  HECMW_set_error(errno, "");
383  goto error;
384  }
385  qsuf_node->node4 =
386  (int *)HECMW_realloc(qsuf_node->node4, sizeof(int) * new_buf_size);
387  if (qsuf_node->node4 == NULL) {
388  HECMW_set_error(errno, "");
389  goto error;
390  }
391 
392  q_buf_size = new_buf_size;
393 
394  return 0;
395 
396 error:
397  HECMW_mesh_hsort_qsuf_final();
398 
399  return -1;
400 }
401 
402 /*================================================================================================*/
403 
404 extern long long int HECMW_mesh_hsort_edge_get_n(void) { return n_edge; }
405 
406 extern int HECMW_mesh_hsort_tsuf_get_n(void) { return n_tsuf; }
407 
408 extern int HECMW_mesh_hsort_qsuf_get_n(void) { return n_qsuf; }
409 
410 /*------------------------------------------------------------------------------------------------*/
411 
412 extern int *HECMW_mesh_hsort_edge_get_v(void) {
413  long long int i;
414 
415  __edge_node = (int *)HECMW_malloc(sizeof(int) * n_edge * 2);
416  if (__edge_node == NULL) {
417  HECMW_set_error(errno, "");
418  goto error;
419  }
420 
421  for (i = 0; i < n_edge; i++) {
422  __edge_node[2 * i] = edge_node->node1[i];
423  __edge_node[2 * i + 1] = edge_node->node2[i];
424  }
425 
426  return __edge_node;
427 
428 error:
429  HECMW_free(__edge_node);
430  __edge_node = NULL;
431  HECMW_mesh_hsort_edge_final();
432 
433  return NULL;
434 }
435 
436 extern int *HECMW_mesh_hsort_tsuf_get_v(void) {
437  int i;
438 
439  __tsuf_node = (int *)HECMW_malloc(sizeof(int) * n_tsuf * 3);
440  if (__tsuf_node == NULL) {
441  HECMW_set_error(errno, "");
442  goto error;
443  }
444 
445  for (i = 0; i < n_tsuf; i++) {
446  __tsuf_node[3 * i] = tsuf_node->node1[i];
447  __tsuf_node[3 * i + 1] = tsuf_node->node2[i];
448  __tsuf_node[3 * i + 2] = tsuf_node->node3[i];
449  }
450 
451  return __tsuf_node;
452 
453 error:
454  HECMW_free(__tsuf_node);
455  __tsuf_node = NULL;
456  HECMW_mesh_hsort_tsuf_final();
457 
458  return NULL;
459 }
460 
461 extern int *HECMW_mesh_hsort_qsuf_get_v(void) {
462  int i;
463 
464  __qsuf_node = (int *)HECMW_malloc(sizeof(int) * n_qsuf * 4);
465  if (__qsuf_node == NULL) {
466  HECMW_set_error(errno, "");
467  goto error;
468  }
469 
470  for (i = 0; i < n_qsuf; i++) {
471  __qsuf_node[4 * i] = qsuf_node->node1[i];
472  __qsuf_node[4 * i + 1] = qsuf_node->node2[i];
473  __qsuf_node[4 * i + 2] = qsuf_node->node3[i];
474  __qsuf_node[4 * i + 3] = qsuf_node->node4[i];
475  }
476 
477  return __qsuf_node;
478 
479 error:
480  HECMW_free(__qsuf_node);
481  HECMW_mesh_hsort_qsuf_final();
482 
483  return NULL;
484 }
485 
486 /*================================================================================================*/
487 
488 extern void HECMW_mesh_hsort_edge_final(void) {
489  if (e_hash_tbl) {
490  long long int i;
491  struct hecmw_mesh_hash_link *p, *q;
492  for (i = 0; i < e_hash_size; i++) {
493  if (e_hash_tbl[i]) {
494  for (q = e_hash_tbl[i], p = e_hash_tbl[i]; p; p = q) {
495  q = q->next;
496  HECMW_free(p);
497  }
498  e_hash_tbl[i] = NULL;
499  }
500  }
501  HECMW_free(e_hash_tbl);
502  }
503  if (edge_node) {
504  HECMW_free(edge_node->node1);
505  HECMW_free(edge_node->node2);
506  }
507  HECMW_free(edge_node);
508 
509  e_hash_tbl = NULL;
510  edge_node = NULL;
511 }
512 
513 extern void HECMW_mesh_hsort_tsuf_final(void) {
514  if (t_hash_tbl) {
515  long long int i;
516  struct hecmw_mesh_hash_link *p, *q;
517  for (i = 0; i < t_hash_size; i++) {
518  if (t_hash_tbl[i]) {
519  for (q = t_hash_tbl[i], p = t_hash_tbl[i]; p; p = q) {
520  q = q->next;
521  HECMW_free(p);
522  }
523  t_hash_tbl[i] = NULL;
524  }
525  }
526  HECMW_free(t_hash_tbl);
527  }
528  if (tsuf_node) {
529  HECMW_free(tsuf_node->node1);
530  HECMW_free(tsuf_node->node2);
531  HECMW_free(tsuf_node->node3);
532  }
533  HECMW_free(tsuf_node);
534 
535  t_hash_tbl = NULL;
536  tsuf_node = NULL;
537 }
538 
539 extern void HECMW_mesh_hsort_qsuf_final(void) {
540  struct hecmw_mesh_hash_link *p, *q;
541  long long int i;
542 
543  if (q_hash_tbl) {
544  for (i = 0; i < q_hash_size; i++) {
545  if (q_hash_tbl[i]) {
546  for (q = q_hash_tbl[i], p = q_hash_tbl[i]; p; p = q) {
547  q = q->next;
548  HECMW_free(p);
549  }
550  q_hash_tbl[i] = NULL;
551  }
552  }
553  HECMW_free(q_hash_tbl);
554  }
555  if (qsuf_node) {
556  HECMW_free(qsuf_node->node1);
557  HECMW_free(qsuf_node->node2);
558  HECMW_free(qsuf_node->node3);
559  HECMW_free(qsuf_node->node4);
560  }
561  HECMW_free(qsuf_node);
562 
563  q_hash_tbl = NULL;
564  qsuf_node = NULL;
565 }
566 
567 /*================================================================================================*/
568 
569 static void reorder_node_edge(int m1, int m2, int *n1, int *n2) {
570  if (m1 < m2) {
571  *n1 = m1;
572  *n2 = m2;
573  } else {
574  *n1 = m2;
575  *n2 = m1;
576  }
577 }
578 
579 static void reorder_node_tsuf(int m1, int m2, int m3, int *n1, int *n2,
580  int *n3) {
581  int l1, l2, l3;
582 
583  if (m1 < m2) {
584  l1 = m1;
585  l2 = m2;
586  } else {
587  l1 = m2;
588  l2 = m1;
589  }
590 
591  if (m3 < l1) {
592  *n1 = m3;
593  l3 = l1;
594  } else {
595  *n1 = l1;
596  l3 = m3;
597  }
598 
599  if (l2 < l3) {
600  *n2 = l2;
601  *n3 = l3;
602  } else {
603  *n2 = l3;
604  *n3 = l2;
605  }
606 }
607 
608 static void reorder_node_qsuf(int m1, int m2, int m3, int m4, int *n1, int *n2,
609  int *n3, int *n4) {
610  int l1, l2, l3, l4, l5, l6;
611 
612  if (m1 < m2) {
613  l1 = m1;
614  l2 = m2;
615  } else {
616  l1 = m2;
617  l2 = m1;
618  }
619 
620  if (m3 < m4) {
621  l3 = m3;
622  l4 = m4;
623  } else {
624  l3 = m4;
625  l4 = m3;
626  }
627 
628  if (l1 < l3) {
629  *n1 = l1;
630  l5 = l3;
631  } else {
632  *n1 = l3;
633  l5 = l1;
634  }
635 
636  if (l2 > l4) {
637  *n4 = l2;
638  l6 = l4;
639  } else {
640  *n4 = l4;
641  l6 = l2;
642  }
643 
644  if (l5 < l6) {
645  *n2 = l5;
646  *n3 = l6;
647  } else {
648  *n2 = l6;
649  *n3 = l5;
650  }
651 }
652 
653 /*================================================================================================*/
654 
655 extern long long int HECMW_mesh_hsort_edge(int node1, int node2) {
656  int n1, n2, m1, m2;
657  long long int eid;
658  int idx;
659  size_t ndot;
660  struct hecmw_mesh_hash_link *p;
661 
662  reorder_node_edge(node1, node2, &n1, &n2);
663 
664  ndot = ((size_t)n1 % e_hash_size) + ((size_t)n2 % e_hash_size);
665  idx = ndot % e_hash_size;
666 
667  for (p = e_hash_tbl[idx]; p; p = p->next) {
668  eid = p->key;
669  reorder_node_edge(edge_node->node1[eid], edge_node->node2[eid], &m1, &m2);
670  if ((n1 == m1) && (n2 == m2)) {
671  return eid + 1;
672  }
673  }
674 
675  p = (struct hecmw_mesh_hash_link *)HECMW_malloc(
676  sizeof(struct hecmw_mesh_hash_link));
677  if (p == NULL) {
678  HECMW_set_error(errno, "");
679  goto error;
680  }
681  p->next = e_hash_tbl[idx];
682  e_hash_tbl[idx] = p;
683 
684  if (n_edge >= e_buf_size) {
685  if (HECMW_mesh_hsort_edge_realloc()) {
686  goto error;
687  }
688  }
689 
690  eid = n_edge;
691  p->key = eid;
692  edge_node->node1[eid] = node1;
693  edge_node->node2[eid] = node2;
694  n_edge++;
695 
696  return eid + 1;
697 
698 error:
699  HECMW_mesh_hsort_edge_final();
700 
701  return -1;
702 }
703 
704 extern int HECMW_mesh_hsort_tsuf(int node1, int node2, int node3) {
705  int n1, n2, n3, m1, m2, m3;
706  int tid;
707  long long int idx;
708  size_t ndot1, ndot;
709  struct hecmw_mesh_hash_link *p;
710 
711  reorder_node_tsuf(node1, node2, node3, &n1, &n2, &n3);
712 
713  ndot1 = ((size_t)n1 % t_hash_size) * ((size_t)n2 % t_hash_size);
714  ndot = ((size_t)n3 % t_hash_size) * (ndot1 % t_hash_size);
715  idx = ndot % t_hash_size;
716 
717  for (p = t_hash_tbl[idx]; p; p = p->next) {
718  tid = p->key;
719  reorder_node_tsuf(tsuf_node->node1[tid], tsuf_node->node2[tid],
720  tsuf_node->node3[tid], &m1, &m2, &m3);
721  if ((n1 == m1) && (n2 == m2) && (n3 == m3)) {
722  return tid + 1;
723  }
724  }
725 
726  p = (struct hecmw_mesh_hash_link *)HECMW_malloc(
727  sizeof(struct hecmw_mesh_hash_link));
728  if (p == NULL) {
729  HECMW_set_error(errno, "");
730  goto error;
731  }
732  p->next = t_hash_tbl[idx];
733  t_hash_tbl[idx] = p;
734 
735  if (n_tsuf >= t_buf_size) {
736  if (HECMW_mesh_hsort_tsuf_realloc()) {
737  goto error;
738  }
739  }
740 
741  tid = n_tsuf;
742  p->key = tid;
743  p->next = NULL;
744  tsuf_node->node1[tid] = node1;
745  tsuf_node->node2[tid] = node2;
746  tsuf_node->node3[tid] = node3;
747  n_tsuf++;
748 
749  return tid + 1;
750 
751 error:
752  HECMW_mesh_hsort_tsuf_final();
753 
754  return -1;
755 }
756 
757 extern int HECMW_mesh_hsort_qsuf(int node1, int node2, int node3, int node4) {
758  int n1, n2, n3, n4, m1, m2, m3, m4;
759  int qid;
760  long long int idx;
761  size_t ndot1, ndot2, ndot;
762  struct hecmw_mesh_hash_link *p;
763 
764  reorder_node_qsuf(node1, node2, node3, node4, &n1, &n2, &n3, &n4);
765 
766  ndot1 = (n1 % q_hash_size) * (n2 % q_hash_size);
767  ndot2 = (n3 % q_hash_size) * (n4 % q_hash_size);
768  ndot = (ndot1 % q_hash_size) * (ndot2 % q_hash_size);
769  idx = ndot % q_hash_size;
770 
771  for (p = q_hash_tbl[idx]; p; p = p->next) {
772  qid = p->key;
773  reorder_node_qsuf(qsuf_node->node1[qid], qsuf_node->node2[qid],
774  qsuf_node->node3[qid], qsuf_node->node4[qid], &m1, &m2,
775  &m3, &m4);
776 
777  if ((n1 == m1) && (n2 == m2) && (n3 == m3) && (n4 == m4)) {
778  return qid + 1;
779  }
780  }
781 
782  p = (struct hecmw_mesh_hash_link *)HECMW_malloc(
783  sizeof(struct hecmw_mesh_hash_link));
784  if (p == NULL) {
785  HECMW_set_error(errno, "");
786  goto error;
787  }
788  p->next = q_hash_tbl[idx];
789  q_hash_tbl[idx] = p;
790 
791  if (n_qsuf >= q_buf_size) {
792  if (HECMW_mesh_hsort_qsuf_realloc()) {
793  goto error;
794  }
795  }
796 
797  qid = n_qsuf;
798  p->key = qid;
799  qsuf_node->node1[qid] = node1;
800  qsuf_node->node2[qid] = node2;
801  qsuf_node->node3[qid] = node3;
802  qsuf_node->node4[qid] = node3;
803  n_qsuf++;
804 
805  return qid + 1;
806 
807 error:
808  HECMW_mesh_hsort_qsuf_final();
809 
810  return -1;
811 }
hecmw_edge_node::node2
int * node2
Definition: hecmw_mesh_hash_sort.c:65
hecmw_malloc.h
HECMW_mesh_hsort_tsuf_get_n
int HECMW_mesh_hsort_tsuf_get_n(void)
Definition: hecmw_mesh_hash_sort.c:406
HECMW_realloc
#define HECMW_realloc(ptr, size)
Definition: hecmw_malloc.h:22
hecmw_qsuf_node::node2
int * node2
Definition: hecmw_mesh_hash_sort.c:79
hecmw_tsuf_node::node1
int * node1
Definition: hecmw_mesh_hash_sort.c:69
HECMW_mesh_hsort_edge_get_n
long long int HECMW_mesh_hsort_edge_get_n(void)
Definition: hecmw_mesh_hash_sort.c:404
HECMW_malloc
#define HECMW_malloc(size)
Definition: hecmw_malloc.h:20
HECMW_mesh_hsort_qsuf_realloc
int HECMW_mesh_hsort_qsuf_realloc(void)
Definition: hecmw_mesh_hash_sort.c:362
HECMW_mesh_hsort_tsuf
int HECMW_mesh_hsort_tsuf(int node1, int node2, int node3)
Definition: hecmw_mesh_hash_sort.c:704
HECMW_mesh_hsort_tsuf_init
int HECMW_mesh_hsort_tsuf_init(int n_node, int n_elem)
Definition: hecmw_mesh_hash_sort.c:156
HECMW_mesh_hsort_qsuf_get_n
int HECMW_mesh_hsort_qsuf_get_n(void)
Definition: hecmw_mesh_hash_sort.c:408
HECMW_mesh_hsort_tsuf_final
void HECMW_mesh_hsort_tsuf_final(void)
Definition: hecmw_mesh_hash_sort.c:513
hecmw_tsuf_node::node2
int * node2
Definition: hecmw_mesh_hash_sort.c:71
hecmw_error.h
HECMW_mesh_hsort_edge_init
int HECMW_mesh_hsort_edge_init(int n_node, int n_elem)
Definition: hecmw_mesh_hash_sort.c:94
HECMW_mesh_hsort_edge
long long int HECMW_mesh_hsort_edge(int node1, int node2)
Definition: hecmw_mesh_hash_sort.c:655
HECMW_mesh_hsort_tsuf_realloc
int HECMW_mesh_hsort_tsuf_realloc(void)
Definition: hecmw_mesh_hash_sort.c:328
hecmw_qsuf_node::node3
int * node3
Definition: hecmw_mesh_hash_sort.c:81
hecmw_mesh_hash_link::next
struct hecmw_mesh_hash_link * next
Definition: hecmw_mesh_hash_sort.c:29
HECMW_mesh_hsort_qsuf_get_v
int * HECMW_mesh_hsort_qsuf_get_v(void)
Definition: hecmw_mesh_hash_sort.c:461
hecmw_edge_node
Definition: hecmw_mesh_hash_sort.c:62
hecmw_mesh_hash_link
Definition: hecmw_mesh_hash_sort.c:26
hecmw_msgno.h
hecmw_tsuf_node::node3
int * node3
Definition: hecmw_mesh_hash_sort.c:73
hecmw_qsuf_node::node1
int * node1
Definition: hecmw_mesh_hash_sort.c:77
hecmw_tsuf_node
Definition: hecmw_mesh_hash_sort.c:68
HECMW_mesh_hsort_edge_get_v
int * HECMW_mesh_hsort_edge_get_v(void)
Definition: hecmw_mesh_hash_sort.c:412
HECMW_mesh_hsort_tsuf_get_v
int * HECMW_mesh_hsort_tsuf_get_v(void)
Definition: hecmw_mesh_hash_sort.c:436
HECMW_PART_E_INV_ARG
#define HECMW_PART_E_INV_ARG
Definition: hecmw_part_define.h:61
HECMW_mesh_hsort_edge_realloc
int HECMW_mesh_hsort_edge_realloc(void)
Definition: hecmw_mesh_hash_sort.c:300
hecmw_part_define.h
HECMW_mesh_hsort_qsuf_init
int HECMW_mesh_hsort_qsuf_init(int n_node, int n_elem)
Definition: hecmw_mesh_hash_sort.c:224
QSUF_INC_FACTOR
#define QSUF_INC_FACTOR
Definition: hecmw_mesh_hash_sort.c:24
HECMW_mesh_hsort_qsuf_final
void HECMW_mesh_hsort_qsuf_final(void)
Definition: hecmw_mesh_hash_sort.c:539
hecmw_qsuf_node::node4
int * node4
Definition: hecmw_mesh_hash_sort.c:83
TSUF_INC_FACTOR
#define TSUF_INC_FACTOR
Definition: hecmw_mesh_hash_sort.c:22
HECMW_set_error
int HECMW_set_error(int errorno, const char *fmt,...)
Definition: hecmw_error.c:37
HECMW_mesh_hsort_edge_final
void HECMW_mesh_hsort_edge_final(void)
Definition: hecmw_mesh_hash_sort.c:488
EDGE_INC_FACTOR
#define EDGE_INC_FACTOR
Definition: hecmw_mesh_hash_sort.c:20
hecmw_mesh_hash_sort.h
NULL
#define NULL
Definition: hecmw_io_nastran.c:30
hecmw_qsuf_node
Definition: hecmw_mesh_hash_sort.c:76
HECMW_free
#define HECMW_free(ptr)
Definition: hecmw_malloc.h:24
hecmw_edge_node::node1
int * node1
Definition: hecmw_mesh_hash_sort.c:63
hecmw_mesh_hash_link::key
int key
Definition: hecmw_mesh_hash_sort.c:27
HECMW_mesh_hsort_qsuf
int HECMW_mesh_hsort_qsuf(int node1, int node2, int node3, int node4)
Definition: hecmw_mesh_hash_sort.c:757