PageRenderTime 54ms CodeModel.GetById 19ms RepoModel.GetById 0ms app.codeStats 0ms

/contrib/exodusii/5.22b/exodus/cbind/test/testrdd.c

https://bitbucket.org/vijaysm/libmesh
C | 900 lines | 579 code | 208 blank | 113 comment | 83 complexity | cdf187aae666892d606ee6d7dc223677 MD5 | raw file
Possible License(s): LGPL-2.1, BSD-3-Clause, GPL-3.0, MPL-2.0-no-copyleft-exception, GPL-2.0
  1. /*
  2. * Copyright (c) 2005 Sandia Corporation. Under the terms of Contract
  3. * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Governement
  4. * retains certain rights in this software.
  5. *
  6. * Redistribution and use in source and binary forms, with or without
  7. * modification, are permitted provided that the following conditions are
  8. * met:
  9. *
  10. * * Redistributions of source code must retain the above copyright
  11. * notice, this list of conditions and the following disclaimer.
  12. *
  13. * * Redistributions in binary form must reproduce the above
  14. * copyright notice, this list of conditions and the following
  15. * disclaimer in the documentation and/or other materials provided
  16. * with the distribution.
  17. *
  18. * * Neither the name of Sandia Corporation nor the names of its
  19. * contributors may be used to endorse or promote products derived
  20. * from this software without specific prior written permission.
  21. *
  22. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23. * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24. * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  25. * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  26. * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  27. * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  28. * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  29. * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  30. * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  31. * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  32. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33. *
  34. */
  35. /******************************************************************************
  36. * testrdd - read exodus file test.exo created by testwt - double precision
  37. *
  38. * author - Sandia National Laboratories
  39. * Larry A. Schoof - Original
  40. *
  41. *
  42. * environment - UNIX
  43. *
  44. * entry conditions -
  45. * input parameters:
  46. * int exoid exodus file id
  47. *
  48. * exit conditions -
  49. *
  50. * revision history -
  51. *
  52. * Original L. A. Schoof
  53. * 04/05/93 V.R. Yarberry - revised so that output resembles Fortran version
  54. * 06/25/93 VRY - revised to match 2.00 API.
  55. *
  56. *****************************************************************************/
  57. #include <stdlib.h>
  58. #include <stdio.h>
  59. #include "netcdf.h"
  60. #include "exodusII.h"
  61. int main (int argc, char **argv)
  62. {
  63. int exoid, num_dim, num_nodes, num_elem, num_elem_blk, num_node_sets;
  64. int num_side_sets, error;
  65. int i, j, k, node_ctr;
  66. int *elem_map, *connect, *node_list, *node_ctr_list, *elem_list, *side_list;
  67. int *ids;
  68. int *num_nodes_per_set, *num_elem_per_set;
  69. int *num_df_per_set;
  70. int *node_ind, *elem_ind, *df_ind, num_qa_rec, num_info;
  71. int num_glo_vars, num_nod_vars, num_ele_vars;
  72. int *truth_tab;
  73. int num_time_steps;
  74. int *num_elem_in_block, *num_nodes_per_elem, *num_attr;
  75. int num_nodes_in_set, num_elem_in_set;
  76. int num_sides_in_set, num_df_in_set;
  77. int list_len = 0;
  78. int elem_list_len = 0;
  79. int node_list_len = 0;
  80. int df_list_len = 0;
  81. int node_num, time_step, var_index, beg_time, end_time, elem_num;
  82. int CPU_word_size,IO_word_size;
  83. int num_props, prop_value, *prop_values;
  84. double time_value, *time_values, *var_values;
  85. double *x, *y, *z;
  86. double attrib[1], *dist_fact;
  87. float version, fdum;
  88. char *coord_names[3], *qa_record[2][4], *info[3], *var_names[3];
  89. char title[MAX_LINE_LENGTH+1], elem_type[MAX_STR_LENGTH+1];
  90. char *cdum = 0;
  91. char *prop_names[3];
  92. CPU_word_size = 8; /* sizeof(double) */
  93. IO_word_size = 0; /* use what is stored in file */
  94. ex_opts (EX_VERBOSE | EX_ABORT );
  95. /* open EXODUS II files */
  96. exoid = ex_open ("test.exo", /* filename path */
  97. EX_READ, /* access mode = READ */
  98. &CPU_word_size, /* CPU word size */
  99. &IO_word_size, /* IO word size */
  100. &version); /* ExodusII library version */
  101. printf ("\nafter ex_open\n");
  102. if (exoid < 0) exit(1);
  103. printf ("test.exo is an EXODUSII file; version %4.2f\n",
  104. version);
  105. printf (" CPU word size %1d\n",CPU_word_size);
  106. printf (" I/O word size %1d\n",IO_word_size);
  107. /* ncopts = NC_VERBOSE; */
  108. /* read database parameters */
  109. error = ex_get_init (exoid, title, &num_dim, &num_nodes, &num_elem,
  110. &num_elem_blk, &num_node_sets, &num_side_sets);
  111. printf ("after ex_get_init, error = %3d\n", error);
  112. printf ("database parameters:\n");
  113. printf ("title = '%s'\n",title);
  114. printf ("num_dim = %3d\n",num_dim);
  115. printf ("num_nodes = %3d\n",num_nodes);
  116. printf ("num_elem = %3d\n",num_elem);
  117. printf ("num_elem_blk = %3d\n",num_elem_blk);
  118. printf ("num_node_sets = %3d\n",num_node_sets);
  119. printf ("num_side_sets = %3d\n",num_side_sets);
  120. /* read nodal coordinates values and names from database */
  121. x = (double *) calloc(num_nodes, sizeof(double));
  122. y = (double *) calloc(num_nodes, sizeof(double));
  123. if (num_dim >= 3)
  124. z = (double *) calloc(num_nodes, sizeof(double));
  125. else
  126. z = 0;
  127. error = ex_get_coord (exoid, x, y, z);
  128. printf ("\nafter ex_get_coord, error = %3d\n", error);
  129. printf ("x coords = \n");
  130. for (i=0; i<num_nodes; i++)
  131. {
  132. printf ("%5.1f\n", x[i]);
  133. }
  134. printf ("y coords = \n");
  135. for (i=0; i<num_nodes; i++)
  136. {
  137. printf ("%5.1f\n", y[i]);
  138. }
  139. if (num_dim >= 3)
  140. {
  141. printf ("z coords = \n");
  142. for (i=0; i<num_nodes; i++)
  143. {
  144. printf ("%5.1f\n", z[i]);
  145. }
  146. }
  147. /*
  148. error = ex_get_1_coord (exoid, 2, x, y, z);
  149. printf ("\nafter ex_get_1_coord, error = %3d\n", error);
  150. printf ("x coord of node 2 = \n");
  151. printf ("%f \n", x[0]);
  152. printf ("y coord of node 2 = \n");
  153. printf ("%f \n", y[0]);
  154. */
  155. free (x);
  156. free (y);
  157. if (num_dim >= 3)
  158. free (z);
  159. for (i=0; i<num_dim; i++)
  160. {
  161. coord_names[i] = (char *) calloc ((MAX_STR_LENGTH+1), sizeof(char));
  162. }
  163. error = ex_get_coord_names (exoid, coord_names);
  164. printf ("\nafter ex_get_coord_names, error = %3d\n", error);
  165. printf ("x coord name = '%s'\n", coord_names[0]);
  166. printf ("y coord name = '%s'\n", coord_names[1]);
  167. for (i=0; i<num_dim; i++)
  168. free(coord_names[i]);
  169. /* read element order map */
  170. elem_map = (int *) calloc(num_elem, sizeof(int));
  171. error = ex_get_map (exoid, elem_map);
  172. printf ("\nafter ex_get_map, error = %3d\n", error);
  173. for (i=0; i<num_elem; i++)
  174. {
  175. printf ("elem_map(%d) = %d \n", i, elem_map[i]);
  176. }
  177. free (elem_map);
  178. /* read element block parameters */
  179. ids = (int *) calloc(num_elem_blk, sizeof(int));
  180. num_elem_in_block = (int *) calloc(num_elem_blk, sizeof(int));
  181. num_nodes_per_elem = (int *) calloc(num_elem_blk, sizeof(int));
  182. num_attr = (int *) calloc(num_elem_blk, sizeof(int));
  183. error = ex_get_elem_blk_ids (exoid, ids);
  184. printf ("\nafter ex_get_elem_blk_ids, error = %3d\n", error);
  185. for (i=0; i<num_elem_blk; i++)
  186. {
  187. error = ex_get_elem_block (exoid, ids[i], elem_type,
  188. &(num_elem_in_block[i]),
  189. &(num_nodes_per_elem[i]), &(num_attr[i]));
  190. printf ("\nafter ex_get_elem_block, error = %d\n", error);
  191. printf ("element block id = %2d\n",ids[i]);
  192. printf ("element type = '%s'\n", elem_type);
  193. printf ("num_elem_in_block = %2d\n",num_elem_in_block[i]);
  194. printf ("num_nodes_per_elem = %2d\n",num_nodes_per_elem[i]);
  195. printf ("num_attr = %2d\n",num_attr[i]);
  196. }
  197. /* read element block properties */
  198. error = ex_inquire (exoid, EX_INQ_EB_PROP, &num_props, &fdum, cdum);
  199. printf ("\nafter ex_inquire, error = %d\n", error);
  200. printf ("\nThere are %2d properties for each element block\n", num_props);
  201. for (i=0; i<num_props; i++)
  202. {
  203. prop_names[i] = (char *) calloc ((MAX_STR_LENGTH+1), sizeof(char));
  204. }
  205. error = ex_get_prop_names(exoid,EX_ELEM_BLOCK,prop_names);
  206. printf ("after ex_get_prop_names, error = %d\n", error);
  207. for (i=0; i<num_props; i++)
  208. {
  209. for (j=0; j<num_elem_blk; j++)
  210. {
  211. error = ex_get_prop(exoid, EX_ELEM_BLOCK, ids[j], prop_names[i],
  212. &prop_value);
  213. if (error == 0)
  214. printf ("element block %2d, property(%2d): '%s'= %5d\n",
  215. j+1, i+1, prop_names[i], prop_value);
  216. else
  217. printf ("after ex_get_prop, error = %d\n", error);
  218. }
  219. }
  220. for (i=0; i<num_props; i++)
  221. free(prop_names[i]);
  222. /* read element connectivity */
  223. for (i=0; i<num_elem_blk; i++)
  224. {
  225. connect = (int *) calloc((num_nodes_per_elem[i] * num_elem_in_block[i]),
  226. sizeof(int));
  227. error = ex_get_elem_conn (exoid, ids[i], connect);
  228. printf ("\nafter ex_get_elem_conn, error = %d\n", error);
  229. printf ("connect array for elem block %2d\n", ids[i]);
  230. for (j=0; j<num_nodes_per_elem[i]; j++)
  231. {
  232. printf ("%3d\n", connect[j]);
  233. }
  234. /*
  235. error = ex_get_1_elem_conn (exoid, 1, ids[i], connect);
  236. printf ("\nafter ex_get_elem_conn, error = %d\n", error);
  237. printf ("node list for first element of element block %d \n ", ids[i]);
  238. for (j=0; j<num_nodes_per_elem[i]; j++)
  239. {
  240. printf ("%d \n", connect[j]);
  241. }
  242. */
  243. free (connect);
  244. }
  245. /* read element block attributes */
  246. for (i=0; i<num_elem_blk; i++)
  247. {
  248. error = ex_get_elem_attr (exoid, ids[i], attrib);
  249. printf ("\n after ex_get_elem_attr, error = %d\n", error);
  250. if (error == 0)
  251. printf ("element block %d attributes = %10.8f\n", ids[i], *attrib);
  252. }
  253. free (ids);
  254. free (num_nodes_per_elem);
  255. free (num_attr);
  256. /* read individual node sets */
  257. ids = (int *) calloc(num_node_sets, sizeof(int));
  258. error = ex_get_node_set_ids (exoid, ids);
  259. printf ("\nafter ex_get_node_set_ids, error = %3d\n", error);
  260. for (i=0; i<num_node_sets; i++)
  261. {
  262. error = ex_get_node_set_param (exoid, ids[i],
  263. &num_nodes_in_set, &num_df_in_set);
  264. printf ("\nafter ex_get_node_set_param, error = %3d\n", error);
  265. printf ("\nnode set %2d parameters: \n", ids[i]);
  266. printf ("num_nodes = %2d\n", num_nodes_in_set);
  267. node_list = (int *) calloc(num_nodes_in_set, sizeof(int));
  268. dist_fact = (double *) calloc(num_nodes_in_set, sizeof(double));
  269. error = ex_get_node_set (exoid, ids[i], node_list);
  270. printf ("\nafter ex_get_node_set, error = %3d\n", error);
  271. if (num_df_in_set > 0)
  272. {
  273. error = ex_get_node_set_dist_fact (exoid, ids[i], dist_fact);
  274. printf ("\nafter ex_get_node_set_dist_fact, error = %3d\n", error);
  275. }
  276. printf ("\nnode list for node set %2d\n", ids[i]);
  277. for (j=0; j<num_nodes_in_set; j++)
  278. {
  279. printf ("%3d\n", node_list[j]);
  280. }
  281. if (num_df_in_set > 0)
  282. {
  283. printf ("dist factors for node set %2d\n", ids[i]);
  284. for (j=0; j<num_nodes_in_set; j++)
  285. {
  286. printf ("%5.2f\n", dist_fact[j]);
  287. }
  288. }
  289. else
  290. printf ("no dist factors for node set %2d\n", ids[i]);
  291. free (node_list);
  292. free (dist_fact);
  293. }
  294. free(ids);
  295. /* read node set properties */
  296. error = ex_inquire (exoid, EX_INQ_NS_PROP, &num_props, &fdum, cdum);
  297. printf ("\nafter ex_inquire, error = %d\n", error);
  298. printf ("\nThere are %2d properties for each node set\n", num_props);
  299. for (i=0; i<num_props; i++)
  300. {
  301. prop_names[i] = (char *) calloc ((MAX_STR_LENGTH+1), sizeof(char));
  302. }
  303. prop_values = (int *) calloc (num_node_sets, sizeof(int));
  304. error = ex_get_prop_names(exoid,EX_NODE_SET,prop_names);
  305. printf ("after ex_get_prop_names, error = %d\n", error);
  306. for (i=0; i<num_props; i++)
  307. {
  308. error = ex_get_prop_array(exoid, EX_NODE_SET, prop_names[i],
  309. prop_values);
  310. if (error == 0)
  311. for (j=0; j<num_node_sets; j++)
  312. printf ("node set %2d, property(%2d): '%s'= %5d\n",
  313. j+1, i+1, prop_names[i], prop_values[j]);
  314. else
  315. printf ("after ex_get_prop_array, error = %d\n", error);
  316. }
  317. for (i=0; i<num_props; i++)
  318. free(prop_names[i]);
  319. free(prop_values);
  320. /* read concatenated node sets; this produces the same information as
  321. * the above code which reads individual node sets
  322. */
  323. error = ex_inquire (exoid, EX_INQ_NODE_SETS, &num_node_sets, &fdum, cdum);
  324. printf ("\nafter ex_inquire, error = %3d\n",error);
  325. ids = (int *) calloc(num_node_sets, sizeof(int));
  326. num_nodes_per_set = (int *) calloc(num_node_sets, sizeof(int));
  327. num_df_per_set = (int *) calloc(num_node_sets, sizeof(int));
  328. node_ind = (int *) calloc(num_node_sets, sizeof(int));
  329. df_ind = (int *) calloc(num_node_sets, sizeof(int));
  330. error = ex_inquire (exoid, EX_INQ_NS_NODE_LEN, &list_len, &fdum, cdum);
  331. printf ("\nafter ex_inquire: EX_INQ_NS_NODE_LEN = %d, error = %3d\n",
  332. list_len, error);
  333. node_list = (int *) calloc(list_len, sizeof(int));
  334. error = ex_inquire (exoid, EX_INQ_NS_DF_LEN, &list_len, &fdum, cdum);
  335. printf ("\nafter ex_inquire: EX_INQ_NS_DF_LEN = %d, error = %3d\n",
  336. list_len, error);
  337. dist_fact = (double *) calloc(list_len, sizeof(double));
  338. error = ex_get_concat_node_sets (exoid,ids,num_nodes_per_set,num_df_per_set,
  339. node_ind, df_ind, node_list, dist_fact);
  340. printf ("\nafter ex_get_concat_node_sets, error = %3d\n", error);
  341. printf ("\nconcatenated node set info\n");
  342. printf ("ids = \n");
  343. for (i=0; i<num_node_sets; i++) printf ("%3d\n", ids[i]);
  344. printf ("num_nodes_per_set = \n");
  345. for (i=0; i<num_node_sets; i++) printf ("%3d\n", num_nodes_per_set[i]);
  346. printf ("node_ind = \n");
  347. for (i=0; i<num_node_sets; i++) printf ("%3d\n", node_ind[i]);
  348. printf ("node_list = \n");
  349. for (i=0; i<list_len; i++) printf ("%3d\n", node_list[i]);
  350. printf ("dist_fact = \n");
  351. for (i=0; i<list_len; i++) printf ("%5.3f\n", dist_fact[i]);
  352. free (ids);
  353. free (num_nodes_per_set);
  354. free (df_ind);
  355. free (node_ind);
  356. free (num_df_per_set);
  357. free (node_list);
  358. free (dist_fact);
  359. /* read individual side sets */
  360. ids = (int *) calloc(num_side_sets, sizeof(int));
  361. error = ex_get_side_set_ids (exoid, ids);
  362. printf ("\nafter ex_get_side_set_ids, error = %3d\n", error);
  363. for (i=0; i<num_side_sets; i++)
  364. {
  365. error = ex_get_side_set_param (exoid, ids[i], &num_sides_in_set,
  366. &num_df_in_set);
  367. printf ("\nafter ex_get_side_set_param, error = %3d\n", error);
  368. printf ("side set %2d parameters:\n",ids[i]);
  369. printf ("num_sides = %3d\n",num_sides_in_set);
  370. printf ("num_dist_factors = %3d\n", num_df_in_set);
  371. /* Note: The # of elements is same as # of sides! */
  372. num_elem_in_set = num_sides_in_set;
  373. elem_list = (int *) calloc(num_elem_in_set, sizeof(int));
  374. side_list = (int *) calloc(num_sides_in_set, sizeof(int));
  375. node_ctr_list = (int *) calloc(num_elem_in_set, sizeof(int));
  376. node_list = (int *) calloc(num_elem_in_set*21, sizeof(int));
  377. dist_fact = (double *) calloc(num_df_in_set, sizeof(double));
  378. error = ex_get_side_set (exoid, ids[i], elem_list, side_list);
  379. printf ("\nafter ex_get_side_set, error = %3d\n", error);
  380. error = ex_get_side_set_node_list (exoid, ids[i], node_ctr_list,
  381. node_list);
  382. printf ("\nafter ex_get_side_set_node_list, error = %3d\n", error);
  383. if (num_df_in_set > 0)
  384. {
  385. error = ex_get_side_set_dist_fact (exoid, ids[i], dist_fact);
  386. printf ("\nafter ex_get_side_set_dist_fact, error = %3d\n", error);
  387. }
  388. printf ("element list for side set %2d\n", ids[i]);
  389. for (j=0; j<num_elem_in_set; j++)
  390. {
  391. printf ("%3d\n", elem_list[j]);
  392. }
  393. printf ("side list for side set %2d\n", ids[i]);
  394. for (j=0; j<num_sides_in_set; j++)
  395. {
  396. printf ("%3d\n", side_list[j]);
  397. }
  398. node_ctr = 0;
  399. printf ("node list for side set %2d\n", ids[i]);
  400. for (k=0; k<num_elem_in_set; k++)
  401. {
  402. for (j=0; j<node_ctr_list[k]; j++)
  403. {
  404. printf ("%3d\n", node_list[node_ctr+j]);
  405. }
  406. node_ctr += node_ctr_list[k];
  407. }
  408. if (num_df_in_set > 0)
  409. {
  410. printf ("dist factors for side set %2d\n", ids[i]);
  411. for (j=0; j<num_df_in_set; j++)
  412. {
  413. printf ("%5.3f\n", dist_fact[j]);
  414. }
  415. }
  416. else
  417. printf ("no dist factors for side set %2d\n", ids[i]);
  418. free (elem_list);
  419. free (side_list);
  420. free (node_ctr_list);
  421. free (node_list);
  422. free (dist_fact);
  423. }
  424. /* read side set properties */
  425. error = ex_inquire (exoid, EX_INQ_SS_PROP, &num_props, &fdum, cdum);
  426. printf ("\nafter ex_inquire, error = %d\n", error);
  427. printf ("\nThere are %2d properties for each side set\n", num_props);
  428. for (i=0; i<num_props; i++)
  429. {
  430. prop_names[i] = (char *) calloc ((MAX_STR_LENGTH+1), sizeof(char));
  431. }
  432. error = ex_get_prop_names(exoid,EX_SIDE_SET,prop_names);
  433. printf ("after ex_get_prop_names, error = %d\n", error);
  434. for (i=0; i<num_props; i++)
  435. {
  436. for (j=0; j<num_side_sets; j++)
  437. {
  438. error = ex_get_prop(exoid, EX_SIDE_SET, ids[j], prop_names[i],
  439. &prop_value);
  440. if (error == 0)
  441. printf ("side set %2d, property(%2d): '%s'= %5d\n",
  442. j+1, i+1, prop_names[i], prop_value);
  443. else
  444. printf ("after ex_get_prop, error = %d\n", error);
  445. }
  446. }
  447. for (i=0; i<num_props; i++)
  448. free(prop_names[i]);
  449. free (ids);
  450. error = ex_inquire (exoid, EX_INQ_SIDE_SETS, &num_side_sets, &fdum, cdum);
  451. printf ("\nafter ex_inquire: EX_INQ_SIDE_SETS = %d, error = %d\n",
  452. num_side_sets, error);
  453. if (num_side_sets > 0)
  454. {
  455. error = ex_inquire(exoid, EX_INQ_SS_ELEM_LEN, &elem_list_len, &fdum, cdum);
  456. printf ("\nafter ex_inquire: EX_INQ_SS_ELEM_LEN = %d, error = %d\n",
  457. elem_list_len, error);
  458. error = ex_inquire(exoid, EX_INQ_SS_NODE_LEN, &node_list_len, &fdum, cdum);
  459. printf ("\nafter ex_inquire: EX_INQ_SS_NODE_LEN = %d, error = %d\n",
  460. node_list_len, error);
  461. error = ex_inquire(exoid, EX_INQ_SS_DF_LEN, &df_list_len, &fdum, cdum);
  462. printf ("\nafter ex_inquire: EX_INQ_SS_DF_LEN = %d, error = %d\n",
  463. df_list_len, error);
  464. }
  465. /* read concatenated side sets; this produces the same information as
  466. * the above code which reads individual side sets
  467. */
  468. /* concatenated side set read */
  469. ids = (int *) calloc(num_side_sets, sizeof(int));
  470. num_elem_per_set = (int *) calloc(num_side_sets, sizeof(int));
  471. num_df_per_set = (int *) calloc(num_side_sets, sizeof(int));
  472. elem_ind = (int *) calloc(num_side_sets, sizeof(int));
  473. df_ind = (int *) calloc(num_side_sets, sizeof(int));
  474. elem_list = (int *) calloc(elem_list_len, sizeof(int));
  475. side_list = (int *) calloc(elem_list_len, sizeof(int));
  476. dist_fact = (double *) calloc(df_list_len, sizeof(double));
  477. error = ex_get_concat_side_sets (exoid, ids, num_elem_per_set,
  478. num_df_per_set, elem_ind, df_ind,
  479. elem_list, side_list, dist_fact);
  480. printf ("\nafter ex_get_concat_side_sets, error = %3d\n", error);
  481. printf ("concatenated side set info\n");
  482. printf ("ids = \n");
  483. for (i=0; i<num_side_sets; i++) printf ("%3d\n", ids[i]);
  484. printf ("num_elem_per_set = \n");
  485. for (i=0; i<num_side_sets; i++) printf ("%3d\n", num_elem_per_set[i]);
  486. printf ("num_dist_per_set = \n");
  487. for (i=0; i<num_side_sets; i++) printf ("%3d\n", num_df_per_set[i]);
  488. printf ("elem_ind = \n");
  489. for (i=0; i<num_side_sets; i++) printf ("%3d\n", elem_ind[i]);
  490. printf ("dist_ind = \n");
  491. for (i=0; i<num_side_sets; i++) printf ("%3d\n", df_ind[i]);
  492. printf ("elem_list = \n");
  493. for (i=0; i<elem_list_len; i++) printf ("%3d\n", elem_list[i]);
  494. printf ("side_list = \n");
  495. for (i=0; i<elem_list_len; i++) printf ("%3d\n", side_list[i]);
  496. printf ("dist_fact = \n");
  497. for (i=0; i<df_list_len; i++) printf ("%5.3f\n", dist_fact[i]);
  498. free (ids);
  499. free (num_elem_per_set);
  500. free (num_df_per_set);
  501. free (df_ind);
  502. free (elem_ind);
  503. free (elem_list);
  504. free (side_list);
  505. free (dist_fact);
  506. /* end of concatenated side set read */
  507. /* read QA records */
  508. ex_inquire (exoid, EX_INQ_QA, &num_qa_rec, &fdum, cdum);
  509. for (i=0; i<num_qa_rec; i++)
  510. {
  511. for (j=0; j<4; j++)
  512. {
  513. qa_record[i][j] = (char *) calloc ((MAX_STR_LENGTH+1), sizeof(char));
  514. }
  515. }
  516. error = ex_get_qa (exoid, qa_record);
  517. printf ("\nafter ex_get_qa, error = %3d\n", error);
  518. printf ("QA records = \n");
  519. for (i=0; i<num_qa_rec; i++)
  520. {
  521. for (j=0; j<4; j++)
  522. {
  523. printf (" '%s'\n", qa_record[i][j]);
  524. free(qa_record[i][j]);
  525. }
  526. }
  527. /* read information records */
  528. error = ex_inquire (exoid, EX_INQ_INFO, &num_info, &fdum, cdum);
  529. printf ("\nafter ex_inquire, error = %3d\n", error);
  530. for (i=0; i<num_info; i++)
  531. {
  532. info[i] = (char *) calloc ((MAX_LINE_LENGTH+1), sizeof(char));
  533. }
  534. error = ex_get_info (exoid, info);
  535. printf ("\nafter ex_get_info, error = %3d\n", error);
  536. printf ("info records = \n");
  537. for (i=0; i<num_info; i++)
  538. {
  539. printf (" '%s'\n", info[i]);
  540. free(info[i]);
  541. }
  542. /* read global variables parameters and names */
  543. error = ex_get_var_param (exoid, "g", &num_glo_vars);
  544. printf ("\nafter ex_get_var_param, error = %3d\n", error);
  545. for (i=0; i<num_glo_vars; i++)
  546. {
  547. var_names[i] = (char *) calloc ((MAX_STR_LENGTH+1), sizeof(char));
  548. }
  549. error = ex_get_var_names (exoid, "g", num_glo_vars, var_names);
  550. printf ("\nafter ex_get_var_names, error = %3d\n", error);
  551. printf ("There are %2d global variables; their names are :\n",
  552. num_glo_vars);
  553. for (i=0; i<num_glo_vars; i++)
  554. {
  555. printf (" '%s'\n", var_names[i]);
  556. free(var_names[i]);
  557. }
  558. /* read nodal variables parameters and names */
  559. error = ex_get_var_param (exoid, "n", &num_nod_vars);
  560. printf ("\nafter ex_get_var_param, error = %3d\n", error);
  561. for (i=0; i<num_nod_vars; i++)
  562. {
  563. var_names[i] = (char *) calloc ((MAX_STR_LENGTH+1), sizeof(char));
  564. }
  565. error = ex_get_var_names (exoid, "n", num_nod_vars, var_names);
  566. printf ("\nafter ex_get_var_names, error = %3d\n", error);
  567. printf ("There are %2d nodal variables; their names are :\n", num_nod_vars);
  568. for (i=0; i<num_nod_vars; i++)
  569. {
  570. printf (" '%s'\n", var_names[i]);
  571. free(var_names[i]);
  572. }
  573. /* read element variables parameters and names */
  574. error = ex_get_var_param (exoid, "e", &num_ele_vars);
  575. printf ("\nafter ex_get_var_param, error = %3d\n", error);
  576. for (i=0; i<num_ele_vars; i++)
  577. {
  578. var_names[i] = (char *) calloc ((MAX_STR_LENGTH+1), sizeof(char));
  579. }
  580. error = ex_get_var_names (exoid, "e", num_ele_vars, var_names);
  581. printf ("\nafter ex_get_var_names, error = %3d\n", error);
  582. printf ("There are %2d element variables; their names are :\n",
  583. num_ele_vars);
  584. for (i=0; i<num_ele_vars; i++)
  585. {
  586. printf (" '%s'\n", var_names[i]);
  587. free(var_names[i]);
  588. }
  589. /* read element variable truth table */
  590. truth_tab = (int *) calloc ((num_elem_blk*num_ele_vars), sizeof(int));
  591. error = ex_get_elem_var_tab (exoid, num_elem_blk, num_ele_vars, truth_tab);
  592. printf ("\nafter ex_get_elem_var_tab, error = %3d\n", error);
  593. printf ("This is the element variable truth table:\n");
  594. k = 0;
  595. for (i=0; i<num_elem_blk*num_ele_vars; i++)
  596. {
  597. printf ("%2d\n", truth_tab[k++]);
  598. }
  599. free (truth_tab);
  600. /* determine how many time steps are stored */
  601. error = ex_inquire (exoid, EX_INQ_TIME, &num_time_steps, &fdum, cdum);
  602. printf ("\nafter ex_inquire, error = %3d\n", error);
  603. printf ("There are %2d time steps in the database.\n", num_time_steps);
  604. /* read time value at one time step */
  605. time_step = 3;
  606. error = ex_get_time (exoid, time_step, &time_value);
  607. printf ("\nafter ex_get_time, error = %3d\n", error);
  608. printf ("time value at time step %2d = %5.3f\n", time_step, time_value);
  609. /* read time values at all time steps */
  610. time_values = (double *) calloc (num_time_steps, sizeof(double));
  611. error = ex_get_all_times (exoid, time_values);
  612. printf ("\nafter ex_get_all_times, error = %3d\n", error);
  613. printf ("time values at all time steps are:\n");
  614. for (i=0; i<num_time_steps; i++) printf ("%5.3f\n", time_values[i]);
  615. free (time_values);
  616. /* read all global variables at one time step */
  617. var_values = (double *) calloc (num_glo_vars, sizeof(double));
  618. error = ex_get_glob_vars (exoid, time_step, num_glo_vars, var_values);
  619. printf ("\nafter ex_get_glob_vars, error = %3d\n", error);
  620. printf ("global variable values at time step %2d\n", time_step);
  621. for (i=0; i<num_glo_vars; i++) printf ("%5.3f\n", var_values[i]);
  622. free (var_values);
  623. /* read a single global variable through time */
  624. var_index = 1;
  625. beg_time = 1;
  626. end_time = -1;
  627. var_values = (double *) calloc (num_time_steps, sizeof(double));
  628. error = ex_get_glob_var_time (exoid, var_index, beg_time, end_time,
  629. var_values);
  630. printf ("\nafter ex_get_glob_var_time, error = %3d\n", error);
  631. printf ("global variable %2d values through time:\n", var_index);
  632. for (i=0; i<num_time_steps; i++) printf ("%5.3f\n", var_values[i]);
  633. free (var_values);
  634. /* read a nodal variable at one time step */
  635. var_values = (double *) calloc (num_nodes, sizeof(double));
  636. error = ex_get_nodal_var (exoid, time_step, var_index, num_nodes,
  637. var_values);
  638. printf ("\nafter ex_get_nodal_var, error = %3d\n", error);
  639. printf ("nodal variable %2d values at time step %2d\n", var_index,
  640. time_step);
  641. for (i=0; i<num_nodes; i++) printf ("%5.3f\n", var_values[i]);
  642. free (var_values);
  643. /* read a nodal variable through time */
  644. var_values = (double *) calloc (num_time_steps, sizeof(double));
  645. node_num = 1;
  646. error = ex_get_nodal_var_time (exoid, var_index, node_num, beg_time,
  647. end_time, var_values);
  648. printf ("\nafter ex_get_nodal_var_time, error = %3d\n", error);
  649. printf ("nodal variable %2d values for node %2d through time:\n", var_index,
  650. node_num);
  651. for (i=0; i<num_time_steps; i++) printf ("%5.3f\n", var_values[i]);
  652. free (var_values);
  653. /* read an element variable at one time step */
  654. ids = (int *) calloc(num_elem_blk, sizeof(int));
  655. error = ex_get_elem_blk_ids (exoid, ids);
  656. printf ("\n after ex_get_elem_blk_ids, error = %3d\n", error);
  657. for (i=0; i<num_elem_blk; i++)
  658. {
  659. var_values = (double *) calloc (num_elem_in_block[i], sizeof(double));
  660. error = ex_get_elem_var (exoid, time_step, var_index, ids[i],
  661. num_elem_in_block[i], var_values);
  662. printf ("\nafter ex_get_elem_var, error = %3d\n", error);
  663. if (!error)
  664. {
  665. printf
  666. ("element variable %2d values of element block %2d at time step %2d\n",
  667. var_index, ids[i], time_step);
  668. for (j=0; j<num_elem_in_block[i]; j++)
  669. printf ("%5.3f\n", var_values[j]);
  670. }
  671. free (var_values);
  672. }
  673. free (num_elem_in_block);
  674. free(ids);
  675. /* read an element variable through time */
  676. var_values = (double *) calloc (num_time_steps, sizeof(double));
  677. var_index = 2;
  678. elem_num = 2;
  679. error = ex_get_elem_var_time (exoid, var_index, elem_num, beg_time,
  680. end_time, var_values);
  681. printf ("\nafter ex_get_elem_var_time, error = %3d\n", error);
  682. printf ("element variable %2d values for element %2d through time:\n",
  683. var_index, elem_num);
  684. for (i=0; i<num_time_steps; i++) printf ("%5.3f\n", var_values[i]);
  685. free (var_values);
  686. error = ex_close (exoid);
  687. printf ("\nafter ex_close, error = %3d\n", error);
  688. return 0;
  689. }