PageRenderTime 104ms CodeModel.GetById 47ms RepoModel.GetById 1ms app.codeStats 0ms

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

https://bitbucket.org/vijaysm/libmesh
C | 1405 lines | 923 code | 365 blank | 117 comment | 35 complexity | 4c6d010b06ffff21f0ad25834d996200 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. *
  37. * testwtm - test write many ExodusII database files
  38. *
  39. * author - Sandia National Laboratories
  40. * Larry A. Schoof - Original
  41. * Vic Yarberry - Added headers and error logging
  42. * 7/7/93 Modified for use with Exodus 2.00
  43. *
  44. *
  45. * environment - UNIX
  46. *
  47. * entry conditions -
  48. *
  49. * exit conditions -
  50. *
  51. * revision history -
  52. *
  53. * This is a test program for the C binding of the EXODUS II
  54. * database write routines. It tests multiple simultaneous output files.
  55. *
  56. *
  57. *****************************************************************************/
  58. #define EX_TEST_INDIV_NODESET
  59. #define EX_TEST_INDIV_SIDESET
  60. #include <stdlib.h>
  61. #include <stdio.h>
  62. #include "exodusII.h"
  63. #include "netcdf.h"
  64. int main (int argc, char **argv)
  65. {
  66. int exoid, num_dim, num_nodes, num_elem, num_elem_blk;
  67. int exoidm[10], num_dim2, num_nodes2, num_elem2,num_elem_blk2;
  68. int num_elem_in_block[10], num_node_sets, num_nodes_per_elem[10];
  69. int num_elem_in_block2[10], num_node_sets2, num_nodes_per_elem2[10];
  70. int num_side_sets, error;
  71. int num_side_sets2, nexofiles = 5;
  72. int i, j, k, m, n;
  73. int *elem_map, *connect, node_list[100],elem_list[100],side_list[100];
  74. int *elem_map2, *connect2, node_list2[100],elem_list2[100],side_list2[100];
  75. int ebids[10], ids[10];
  76. int ebids2[10], ids2[10];
  77. int num_nodes_per_set[10], num_elem_per_set[10];
  78. int num_nodes_per_set2[10], num_elem_per_set2[10];
  79. int num_df_per_set[10], num_df_per_set2[10];
  80. int df_ind[10], node_ind[10], elem_ind[10];
  81. int df_ind2[10],node_ind2[10],elem_ind2[10];
  82. int num_qa_rec, num_info;
  83. int num_qa_rec2,num_info2;
  84. int num_glo_vars, num_nod_vars, num_ele_vars;
  85. int num_glo_vars2, num_nod_vars2, num_ele_vars2;
  86. int *truth_tab;
  87. int whole_time_step, num_time_steps;
  88. int CPU_word_size,IO_word_size;
  89. int prop_array[2];
  90. float *glob_var_vals, *nodal_var_vals, *elem_var_vals;
  91. float time_value;
  92. float time_value2;
  93. float x[100], y[100], z[100];
  94. float attrib[1], dist_fact[1008];
  95. float attrib2[1], dist_fact2[100];
  96. char *coord_names[3], *qa_record[2][4], *info[3], *var_names[3];
  97. char *coord_names2[3], *qa_record2[2][4], *info2[3], *var_names2[3];
  98. char tmpstr[80];
  99. char *prop_names[2];
  100. char exofname[256];
  101. ex_opts (EX_VERBOSE | EX_ABORT);
  102. /* Specify compute and i/o word size */
  103. CPU_word_size = 0; /* sizeof(float) */
  104. IO_word_size = 4; /* (4 bytes) */
  105. /* create EXODUS II files */
  106. exoid = ex_create ("test.exo", /* filename path */
  107. EX_CLOBBER, /* create mode */
  108. &CPU_word_size, /* CPU float word size in bytes */
  109. &IO_word_size); /* I/O float word size in bytes */
  110. printf ("after ex_create for test.exo, exoid = %d\n", exoid);
  111. printf (" cpu word size: %d io word size: %d\n",CPU_word_size,IO_word_size);
  112. for (n=0; n<nexofiles; n++)
  113. {
  114. sprintf(exofname,"test%d.exo",n);
  115. printf("test file name: %s\n",exofname);
  116. exoidm[n]= ex_create (exofname, /* filename path */
  117. EX_CLOBBER, /* create mode */
  118. &CPU_word_size, /* CPU float word size in bytes */
  119. &IO_word_size); /* I/O float word size in bytes */
  120. printf ("after ex_create for %s, exoid = %d\n", exofname,exoidm[n]);
  121. }
  122. /* ncopts = NC_VERBOSE; */
  123. /* initialize file with parameters */
  124. num_dim = 3;
  125. num_nodes = 26;
  126. num_elem = 5;
  127. num_elem_blk = 5;
  128. num_node_sets = 2;
  129. num_side_sets = 5;
  130. error = ex_put_init (exoid, "This is a test", num_dim, num_nodes, num_elem,
  131. num_elem_blk, num_node_sets, num_side_sets);
  132. printf ("after ex_put_init, error = %d\n", error);
  133. /* initialize file n with parameters */
  134. num_dim2 = 3;
  135. num_nodes2 = 26;
  136. num_elem2 = 5;
  137. num_elem_blk2 = 5;
  138. num_node_sets2 = 2;
  139. num_side_sets2 = 5;
  140. for (n=0; n<nexofiles; n++)
  141. {
  142. sprintf(tmpstr,"This is test %d",n);
  143. error=ex_put_init (exoidm[n],tmpstr,num_dim2,num_nodes2,num_elem2,
  144. num_elem_blk2, num_node_sets2, num_side_sets2);
  145. printf ("after ex_put_init (%d), error = %d\n", n, error);
  146. }
  147. /* write nodal coordinates values and names to database */
  148. /* Quad #1 */
  149. x[0] = 0.0; y[0] = 0.0; z[0] = 0.0;
  150. x[1] = 1.0; y[1] = 0.0; z[1] = 0.0;
  151. x[2] = 1.0; y[2] = 1.0; z[2] = 0.0;
  152. x[3] = 0.0; y[3] = 1.0; z[3] = 0.0;
  153. /* Quad #2 */
  154. x[4] = 1.0; y[4] = 0.0; z[4] = 0.0;
  155. x[5] = 2.0; y[5] = 0.0; z[5] = 0.0;
  156. x[6] = 2.0; y[6] = 1.0; z[6] = 0.0;
  157. x[7] = 1.0; y[7] = 1.0; z[7] = 0.0;
  158. /* Hex #1 */
  159. x[8] = 0.0; y[8] = 0.0; z[8] = 0.0;
  160. x[9] = 10.0; y[9] = 0.0; z[9] = 0.0;
  161. x[10] = 10.0; y[10] = 0.0; z[10] =-10.0;
  162. x[11] = 1.0; y[11] = 0.0; z[11] =-10.0;
  163. x[12] = 1.0; y[12] = 10.0; z[12] = 0.0;
  164. x[13] = 10.0; y[13] = 10.0; z[13] = 0.0;
  165. x[14] = 10.0; y[14] = 10.0; z[14] =-10.0;
  166. x[15] = 1.0; y[15] = 10.0; z[15] =-10.0;
  167. /* Tetra #1 */
  168. x[16] = 0.0; y[16] = 0.0; z[16] = 0.0;
  169. x[17] = 1.0; y[17] = 0.0; z[17] = 5.0;
  170. x[18] = 10.0; y[18] = 0.0; z[18] = 2.0;
  171. x[19] = 7.0; y[19] = 5.0; z[19] = 3.0;
  172. /* Wedge #1 */
  173. x[20] = 3.0; y[20] = 0.0; z[20] = 6.0;
  174. x[21] = 6.0; y[21] = 0.0; z[21] = 0.0;
  175. x[22] = 0.0; y[22] = 0.0; z[22] = 0.0;
  176. x[23] = 3.0; y[23] = 2.0; z[23] = 6.0;
  177. x[24] = 6.0; y[24] = 2.0; z[24] = 2.0;
  178. x[25] = 0.0; y[25] = 2.0; z[25] = 0.0;
  179. error = ex_put_coord (exoid, x, y, z);
  180. printf ("after ex_put_coord, error = %d\n", error);
  181. /* write nodal coordinates values and names to database */
  182. for (n=0; n<nexofiles; n++)
  183. {
  184. error = ex_put_coord (exoidm[n], x, y, z);
  185. printf ("after ex_put_coord (%d), error = %d\n", n,error);
  186. }
  187. coord_names[0] = "xcoor";
  188. coord_names[1] = "ycoor";
  189. coord_names[2] = "zcoor";
  190. error = ex_put_coord_names (exoid, coord_names);
  191. printf ("after ex_put_coord_names, error = %d\n", error);
  192. coord_names2[0] = "xcoor";
  193. coord_names2[1] = "ycoor";
  194. coord_names2[2] = "zcoor";
  195. for (n=0; n<nexofiles; n++)
  196. {
  197. error = ex_put_coord_names (exoidm[n], coord_names2);
  198. printf ("after ex_put_coord_names (%d), error = %d\n", n, error);
  199. }
  200. /* write element order map */
  201. elem_map = (int *) calloc(num_elem, sizeof(int));
  202. for (i=1; i<=num_elem; i++)
  203. {
  204. elem_map[i-1] = i;
  205. }
  206. error = ex_put_map (exoid, elem_map);
  207. printf ("after ex_put_map, error = %d\n", error);
  208. free (elem_map);
  209. elem_map2= (int *) calloc(num_elem2, sizeof(int));
  210. for (i=1; i<=num_elem2; i++)
  211. {
  212. elem_map2[i-1] = i;
  213. }
  214. for (n=0; n<nexofiles; n++)
  215. {
  216. error = ex_put_map (exoidm[n], elem_map2);
  217. printf ("after ex_put_map (%d), error = %d\n", n, error);
  218. }
  219. free (elem_map2);
  220. /* write element block parameters */
  221. num_elem_in_block[0] = 1;
  222. num_elem_in_block[1] = 1;
  223. num_elem_in_block[2] = 1;
  224. num_elem_in_block[3] = 1;
  225. num_elem_in_block[4] = 1;
  226. num_nodes_per_elem[0] = 4; /* elements in block #1 are 4-node quads */
  227. num_nodes_per_elem[1] = 4; /* elements in block #2 are 4-node quads */
  228. num_nodes_per_elem[2] = 8; /* elements in block #3 are 8-node hexes */
  229. num_nodes_per_elem[3] = 4; /* elements in block #3 are 4-node tetras */
  230. num_nodes_per_elem[4] = 6; /* elements in block #3 are 6-node wedges */
  231. ebids[0] = 10;
  232. ebids[1] = 11;
  233. ebids[2] = 12;
  234. ebids[3] = 13;
  235. ebids[4] = 14;
  236. error = ex_put_elem_block (exoid, ebids[0], "quad", num_elem_in_block[0],
  237. num_nodes_per_elem[0], 1);
  238. printf ("after ex_put_elem_block, error = %d\n", error);
  239. error = ex_put_elem_block (exoid, ebids[1], "quad", num_elem_in_block[1],
  240. num_nodes_per_elem[1], 1);
  241. printf ("after ex_put_elem_block, error = %d\n", error);
  242. error = ex_put_elem_block (exoid, ebids[2], "hex", num_elem_in_block[2],
  243. num_nodes_per_elem[2], 1);
  244. printf ("after ex_put_elem_block, error = %d\n", error);
  245. error = ex_put_elem_block (exoid, ebids[3], "tetra", num_elem_in_block[3],
  246. num_nodes_per_elem[3], 1);
  247. printf ("after ex_put_elem_block, error = %d\n", error);
  248. error = ex_put_elem_block (exoid, ebids[4], "wedge", num_elem_in_block[4],
  249. num_nodes_per_elem[4], 1);
  250. printf ("after ex_put_elem_block, error = %d\n", error);
  251. /* write element block properties */
  252. prop_names[0] = "MATL";
  253. prop_names[1] = "DENSITY";
  254. error = ex_put_prop_names(exoid,EX_ELEM_BLOCK,2,prop_names);
  255. printf ("after ex_put_prop_names, error = %d\n", error);
  256. error = ex_put_prop(exoid, EX_ELEM_BLOCK, ebids[0], "MATL", 10);
  257. printf ("after ex_put_prop, error = %d\n", error);
  258. error = ex_put_prop(exoid, EX_ELEM_BLOCK, ebids[1], "MATL", 20);
  259. printf ("after ex_put_prop, error = %d\n", error);
  260. error = ex_put_prop(exoid, EX_ELEM_BLOCK, ebids[2], "MATL", 30);
  261. printf ("after ex_put_prop, error = %d\n", error);
  262. error = ex_put_prop(exoid, EX_ELEM_BLOCK, ebids[3], "MATL", 40);
  263. printf ("after ex_put_prop, error = %d\n", error);
  264. error = ex_put_prop(exoid, EX_ELEM_BLOCK, ebids[4], "MATL", 50);
  265. printf ("after ex_put_prop, error = %d\n", error);
  266. /* files n */
  267. num_elem_in_block2[0] = 1;
  268. num_elem_in_block2[1] = 1;
  269. num_elem_in_block2[2] = 1;
  270. num_elem_in_block2[3] = 1;
  271. num_elem_in_block2[4] = 1;
  272. num_nodes_per_elem2[0] = 4; /* elements in block #1 are 4-node quads */
  273. num_nodes_per_elem2[1] = 4; /* elements in block #2 are 4-node quads */
  274. num_nodes_per_elem2[2] = 8; /* elements in block #3 are 8-node hexes */
  275. num_nodes_per_elem2[3] = 4; /* elements in block #3 are 4-node tetras */
  276. num_nodes_per_elem2[4] = 6; /* elements in block #3 are 6-node wedges */
  277. ebids2[0] = 10;
  278. ebids2[1] = 11;
  279. ebids2[2] = 12;
  280. ebids2[3] = 13;
  281. ebids2[4] = 14;
  282. for (n=0; n<nexofiles; n++)
  283. {
  284. error=ex_put_elem_block(exoidm[n],ebids2[0], "quad", num_elem_in_block2[0],
  285. num_nodes_per_elem2[0], 1);
  286. printf ("after ex_put_elem_block (%d), error = %d\n", n, error);
  287. error=ex_put_elem_block(exoidm[n],ebids2[1], "quad", num_elem_in_block2[1],
  288. num_nodes_per_elem2[1], 1);
  289. printf ("after ex_put_elem_block (%d), error = %d\n", n, error);
  290. error=ex_put_elem_block(exoidm[n],ebids2[2], "hex", num_elem_in_block2[2],
  291. num_nodes_per_elem2[2], 1);
  292. printf ("after ex_put_elem_block (%d), error = %d\n", n, error);
  293. error=ex_put_elem_block(exoidm[n],ebids2[3], "tetra",num_elem_in_block2[3],
  294. num_nodes_per_elem2[3], 1);
  295. printf ("after ex_put_elem_block (%d), error = %d\n", n, error);
  296. error=ex_put_elem_block(exoidm[n],ebids2[4], "wedge",num_elem_in_block2[4],
  297. num_nodes_per_elem2[4], 1);
  298. printf ("after ex_put_elem_block (%d), error = %d\n", n, error);
  299. /* write element block properties */
  300. prop_names[0] = "MATL";
  301. prop_names[1] = "DENSITY";
  302. error = ex_put_prop_names(exoidm[n],EX_ELEM_BLOCK,2,prop_names);
  303. printf ("after ex_put_prop_names (%d), error = %d\n", n, error);
  304. error = ex_put_prop(exoidm[n], EX_ELEM_BLOCK, ebids2[0], "MATL", 100);
  305. printf ("after ex_put_prop (%d), error = %d\n", n, error);
  306. error = ex_put_prop(exoidm[n], EX_ELEM_BLOCK, ebids2[1], "MATL", 200);
  307. printf ("after ex_put_prop (%d), error = %d\n", n, error);
  308. error = ex_put_prop(exoidm[n], EX_ELEM_BLOCK, ebids2[2], "MATL", 300);
  309. printf ("after ex_put_prop (%d), error = %d\n", n, error);
  310. error = ex_put_prop(exoidm[n], EX_ELEM_BLOCK, ebids2[3], "MATL", 400);
  311. printf ("after ex_put_prop (%d), error = %d\n", n, error);
  312. error = ex_put_prop(exoidm[n], EX_ELEM_BLOCK, ebids2[4], "MATL", 500);
  313. printf ("after ex_put_prop (%d), error = %d\n", n, error);
  314. }
  315. /* write element connectivity */
  316. connect = (int *) calloc(8, sizeof(int));
  317. connect[0] = 1; connect[1] = 2; connect[2] = 3; connect[3] = 4;
  318. error = ex_put_elem_conn (exoid, ebids[0], connect);
  319. printf ("after ex_put_elem_conn, error = %d\n", error);
  320. connect[0] = 5; connect[1] = 6; connect[2] = 7; connect[3] = 8;
  321. error = ex_put_elem_conn (exoid, ebids[1], connect);
  322. printf ("after ex_put_elem_conn, error = %d\n", error);
  323. connect[0] = 9; connect[1] = 10; connect[2] = 11; connect[3] = 12;
  324. connect[4] = 13; connect[5] = 14; connect[6] = 15; connect[7] = 16;
  325. error = ex_put_elem_conn (exoid, ebids[2], connect);
  326. printf ("after ex_put_elem_conn, error = %d\n", error);
  327. connect[0] = 17; connect[1] = 18; connect[2] = 19; connect[3] = 20;
  328. error = ex_put_elem_conn (exoid, ebids[3], connect);
  329. printf ("after ex_put_elem_conn, error = %d\n", error);
  330. connect[0] = 21; connect[1] = 22; connect[2] = 23;
  331. connect[3] = 24; connect[4] = 25; connect[5] = 26;
  332. error = ex_put_elem_conn (exoid, ebids[4], connect);
  333. printf ("after ex_put_elem_conn, error = %d\n", error);
  334. free (connect);
  335. for (n=0; n<nexofiles; n++)
  336. {
  337. connect2 = (int *) calloc(8, sizeof(int));
  338. connect2[0] = 1; connect2[1] = 2; connect2[2] = 3; connect2[3] = 4;
  339. error = ex_put_elem_conn (exoidm[n], ebids[0], connect2);
  340. printf ("after ex_put_elem_conn (%d), error = %d\n", n, error);
  341. connect2[0] = 5; connect2[1] = 6; connect2[2] = 7; connect2[3] = 8;
  342. error = ex_put_elem_conn (exoidm[n], ebids[1], connect2);
  343. printf ("after ex_put_elem_conn (%d), error = %d\n", n, error);
  344. connect2[0] = 9; connect2[1] = 10; connect2[2] = 11; connect2[3] = 12;
  345. connect2[4] = 13; connect2[5] = 14; connect2[6] = 15; connect2[7] = 16;
  346. error = ex_put_elem_conn (exoidm[n], ebids2[2], connect2);
  347. printf ("after ex_put_elem_conn (%d), error = %d\n", n, error);
  348. connect2[0] = 17; connect2[1] = 18; connect2[2] = 19; connect2[3] = 20;
  349. error = ex_put_elem_conn (exoidm[n], ebids2[3], connect2);
  350. printf ("after ex_put_elem_conn (%d), error = %d\n", n, error);
  351. connect2[0] = 21; connect2[1] = 22; connect2[2] = 23;
  352. connect2[3] = 24; connect2[4] = 25; connect2[5] = 26;
  353. error = ex_put_elem_conn (exoidm[n], ebids2[4], connect2);
  354. printf ("after ex_put_elem_conn (%d), error = %d\n", n, error);
  355. free (connect2);
  356. }
  357. /* write element block attributes */
  358. attrib[0] = 3.14159;
  359. error = ex_put_elem_attr (exoid, ebids[0], attrib);
  360. printf ("after ex_put_elem_attr, error = %d\n", error);
  361. attrib[0] = 6.14159;
  362. error = ex_put_elem_attr (exoid, ebids[1], attrib);
  363. printf ("after ex_put_elem_attr, error = %d\n", error);
  364. error = ex_put_elem_attr (exoid, ebids[2], attrib);
  365. printf ("after ex_put_elem_attr, error = %d\n", error);
  366. error = ex_put_elem_attr (exoid, ebids[3], attrib);
  367. printf ("after ex_put_elem_attr, error = %d\n", error);
  368. error = ex_put_elem_attr (exoid, ebids[4], attrib);
  369. printf ("after ex_put_elem_attr, error = %d\n", error);
  370. for (n=0; n<nexofiles; n++)
  371. {
  372. attrib2[0] = 3.;
  373. error = ex_put_elem_attr (exoidm[n], ebids[0], attrib2);
  374. printf ("after ex_put_elem_attr (%d), error = %d\n", n, error);
  375. attrib2[0] = 6.;
  376. error = ex_put_elem_attr (exoidm[n], ebids[1], attrib2);
  377. printf ("after ex_put_elem_attr (%d), error = %d\n", n, error);
  378. error = ex_put_elem_attr (exoidm[n], ebids[2], attrib2);
  379. printf ("after ex_put_elem_attr (%d), error = %d\n", n, error);
  380. error = ex_put_elem_attr (exoidm[n], ebids[3], attrib2);
  381. printf ("after ex_put_elem_attr (%d), error = %d\n", n, error);
  382. error = ex_put_elem_attr (exoidm[n], ebids[4], attrib2);
  383. printf ("after ex_put_elem_attr (%d), error = %d\n", n, error);
  384. }
  385. #ifdef EX_TEST_INDIV_NODESET
  386. /* write individual node sets */
  387. error = ex_put_node_set_param (exoid, 20, 5, 5);
  388. printf ("after ex_put_node_set_param, error = %d\n", error);
  389. node_list[0] = 10; node_list[1] = 11; node_list[2] = 12;
  390. node_list[3] = 13; node_list[4] = 14;
  391. dist_fact[0] = 1.0; dist_fact[1] = 2.0; dist_fact[2] = 3.0;
  392. dist_fact[3] = 4.0; dist_fact[4] = 5.0;
  393. error = ex_put_node_set (exoid, 20, node_list);
  394. printf ("after ex_put_node_set, error = %d\n", error);
  395. error = ex_put_node_set_dist_fact (exoid, 20, dist_fact);
  396. printf ("after ex_put_node_set, error = %d\n", error);
  397. error = ex_put_node_set_param (exoid, 21, 3, 3);
  398. printf ("after ex_put_node_set_param, error = %d\n", error);
  399. node_list[0] = 20; node_list[1] = 21; node_list[2] = 22;
  400. dist_fact[0] = 1.1; dist_fact[1] = 2.1; dist_fact[2] = 3.1;
  401. error = ex_put_node_set (exoid, 21, node_list);
  402. printf ("after ex_put_node_set, error = %d\n", error);
  403. error = ex_put_node_set_dist_fact (exoid, 21, dist_fact);
  404. printf ("after ex_put_node_set, error = %d\n", error);
  405. error = ex_put_prop(exoid, EX_NODE_SET, 20, "FACE", 4);
  406. printf ("after ex_put_prop, error = %d\n", error);
  407. error = ex_put_prop(exoid, EX_NODE_SET, 21, "FACE", 5);
  408. printf ("after ex_put_prop, error = %d\n", error);
  409. prop_array[0] = 1000;
  410. prop_array[1] = 2000;
  411. error = ex_put_prop_array(exoid, EX_NODE_SET, "VELOCITY", prop_array);
  412. printf ("after ex_put_prop_array, error = %d\n", error);
  413. /* file 2 */
  414. for (n=0; n<nexofiles; n++)
  415. {
  416. error = ex_put_node_set_param (exoidm[n], 20, 5, 5);
  417. printf ("after ex_put_node_set_param (%d), error = %d\n", n, error);
  418. node_list2[0] = 10; node_list2[1] = 11; node_list2[2] = 12;
  419. node_list2[3] = 13; node_list2[4] = 14;
  420. dist_fact2[0] = 1.0; dist_fact2[1] = 2.0; dist_fact2[2] = 3.0;
  421. dist_fact2[3] = 4.0; dist_fact2[4] = 5.0;
  422. error = ex_put_node_set (exoidm[n], 20, node_list2);
  423. printf ("after ex_put_node_set (%d), error = %d\n", n, error);
  424. error = ex_put_node_set_dist_fact (exoidm[n], 20, dist_fact2);
  425. printf ("after ex_put_node_set (%d), error = %d\n", n, error);
  426. error = ex_put_node_set_param (exoidm[n], 21, 3, 3);
  427. printf ("after ex_put_node_set_param (%d), error = %d\n", n, error);
  428. node_list2[0] = 20; node_list2[1] = 21; node_list2[2] = 22;
  429. dist_fact2[0] = 1.1; dist_fact2[1] = 2.1; dist_fact2[2] = 3.1;
  430. error = ex_put_node_set (exoidm[n], 21, node_list2);
  431. printf ("after ex_put_node_set (%d), error = %d\n", n, error);
  432. error = ex_put_node_set_dist_fact (exoidm[n], 21, dist_fact2);
  433. printf ("after ex_put_node_set (%d), error = %d\n", n, error);
  434. error = ex_put_prop(exoidm[n], EX_NODE_SET, 20, "FACE", 4);
  435. printf ("after ex_put_prop (%d), error = %d\n", n, error);
  436. error = ex_put_prop(exoidm[n], EX_NODE_SET, 21, "FACE", 5);
  437. printf ("after ex_put_prop (%d), error = %d\n", n, error);
  438. prop_array[0] = 1000;
  439. prop_array[1] = 2000;
  440. error = ex_put_prop_array(exoidm[n], EX_NODE_SET, "VELOCITY", prop_array);
  441. printf ("after ex_put_prop (%d), error = %d\n", n, error);
  442. }
  443. #else /* EX_TEST_INDIV_NODESET */
  444. /* write concatenated node sets; this produces the same information as
  445. * the above code which writes individual node sets
  446. */
  447. ids[0] = 20; ids[1] = 21;
  448. num_nodes_per_set[0] = 5; num_nodes_per_set[1] = 3;
  449. node_ind[0] = 0; node_ind[1] = 5;
  450. node_list[0] = 10; node_list[1] = 11; node_list[2] = 12;
  451. node_list[3] = 13; node_list[4] = 14;
  452. node_list[5] = 20; node_list[6] = 21; node_list[7] = 22;
  453. num_df_per_set[0] = 5; num_df_per_set[1] = 3;
  454. df_ind[0] = 0; df_ind[1] = 5;
  455. dist_fact[0] = 1.0; dist_fact[1] = 2.0; dist_fact[2] = 3.0;
  456. dist_fact[3] = 4.0; dist_fact[4] = 5.0;
  457. dist_fact[5] = 1.1; dist_fact[6] = 2.1; dist_fact[7] = 3.1;
  458. error = ex_put_concat_node_sets (exoid, ids, num_nodes_per_set, node_ind,
  459. node_list, dist_fact);
  460. printf ("after ex_put_concat_node_sets, error = %d\n", error);
  461. error = ex_put_prop(exoid, EX_NODE_SET, 20, "FACE", 4);
  462. printf ("after ex_put_prop, error = %d\n", error);
  463. error = ex_put_prop(exoid, EX_NODE_SET, 21, "FACE", 5);
  464. printf ("after ex_put_prop, error = %d\n", error);
  465. prop_array[0] = 1000;
  466. prop_array[1] = 2000;
  467. error = ex_put_prop_array(exoid, EX_NODE_SET, "VELOCITY", prop_array);
  468. printf ("after ex_put_prop_array, error = %d\n", error);
  469. ids2[0] = 20; ids2[1] = 21;
  470. num_nodes_per_set2[0] = 5; num_nodes_per_set2[1] = 3;
  471. node_ind2[0] = 0; node_ind2[1] = 5;
  472. node_list2[0] = 10; node_list2[1] = 11; node_list2[2] = 12;
  473. node_list2[3] = 13; node_list2[4] = 14;
  474. node_list2[5] = 20; node_list2[6] = 21; node_list2[7] = 22;
  475. num_df_per_set2[0] = 5; num_df_per_set2[1] = 3;
  476. df_ind2[0] = 0; df_ind2[1] = 5;
  477. dist_fact2[0] = 1.0; dist_fact2[1] = 2.0; dist_fact2[2] = 3.0;
  478. dist_fact2[3] = 4.0; dist_fact2[4] = 5.0;
  479. dist_fact2[5] = 1.1; dist_fact2[6] = 2.1; dist_fact2[7] = 3.1;
  480. prop_array2[0] = 1000;
  481. prop_array2[1] = 2000;
  482. for (n=0; n<nexofiles; n++)
  483. {
  484. error = ex_put_concat_node_sets (exoidm[n], ids2, num_nodes_per_set2,
  485. num_df_per_set2, node_ind2,
  486. df_ind2, node_list2, dist_fact2);
  487. printf ("after ex_put_concat_node_sets, error = %d\n", error);
  488. error = ex_put_prop(exoidm[n], EX_NODE_SET, 20, "FACE", 4);
  489. printf ("after ex_put_prop, error = %d\n", error);
  490. error = ex_put_prop(exoidm[n], EX_NODE_SET, 21, "FACE", 5);
  491. printf ("after ex_put_prop, error = %d\n", error);
  492. error = ex_put_prop_array(exoidm[n], EX_NODE_SET, "VELOCITY", prop_array2);
  493. printf ("after ex_put_prop_array, error = %d\n", error);
  494. }
  495. #endif /* EX_TEST_INDIV_NODESET */
  496. #ifdef TEST_INDIV_SIDESET
  497. /* write individual side sets */
  498. /* side set #1 - quad */
  499. error = ex_put_side_set_param (exoid, 30, 2, 4);
  500. printf ("after ex_put_side_set_param, error = %d\n", error);
  501. elem_list[0] = 2; elem_list[1] = 2;
  502. side_list[0] = 4; side_list[1] = 2;
  503. dist_fact[0] = 30.0; dist_fact[1] = 30.1; dist_fact[2] = 30.2;
  504. dist_fact[3] = 30.3;
  505. error = ex_put_side_set (exoid, 30, elem_list, side_list);
  506. printf ("after ex_put_side_set, error = %d\n", error);
  507. error = ex_put_side_set_dist_fact (exoid, 30, dist_fact);
  508. printf ("after ex_put_side_set_dist_fact, error = %d\n", error);
  509. /* side set #2 - quad spanning elements */
  510. error = ex_put_side_set_param (exoid, 31, 2, 4);
  511. printf ("after ex_put_side_set_param, error = %d\n", error);
  512. elem_list[0] = 1; elem_list[1] = 2;
  513. side_list[0] = 2; side_list[1] = 3;
  514. dist_fact[0] = 31.0; dist_fact[1] = 31.1; dist_fact[2] = 31.2;
  515. dist_fact[3] = 31.3;
  516. error = ex_put_side_set (exoid, 31, elem_list, side_list);
  517. printf ("after ex_put_side_set, error = %d\n", error);
  518. error = ex_put_side_set_dist_fact (exoid, 31, dist_fact);
  519. printf ("after ex_put_side_set_dist_fact, error = %d\n", error);
  520. /* side set #3 - hex */
  521. error = ex_put_side_set_param (exoid, 32, 7, 0);
  522. printf ("after ex_put_side_set_param, error = %d\n", error);
  523. elem_list[0] = 3; elem_list[1] = 3;
  524. elem_list[2] = 3; elem_list[3] = 3;
  525. elem_list[4] = 3; elem_list[5] = 3;
  526. elem_list[6] = 3;
  527. side_list[0] = 5; side_list[1] = 3;
  528. side_list[2] = 3; side_list[3] = 2;
  529. side_list[4] = 4; side_list[5] = 1;
  530. side_list[6] = 6;
  531. error = ex_put_side_set (exoid, 32, elem_list, side_list);
  532. printf ("after ex_put_side_set, error = %d\n", error);
  533. /* side set #4 - tetras */
  534. error = ex_put_side_set_param (exoid, 33, 4, 0);
  535. printf ("after ex_put_side_set_param, error = %d\n", error);
  536. elem_list[0] = 4; elem_list[1] = 4;
  537. elem_list[2] = 4; elem_list[3] = 4;
  538. side_list[0] = 1; side_list[1] = 2;
  539. side_list[2] = 3; side_list[3] = 4;
  540. error = ex_put_side_set (exoid, 33, elem_list, side_list);
  541. printf ("after ex_put_side_set, error = %d\n", error);
  542. /* side set #5 - wedges */
  543. error = ex_put_side_set_param (exoid, 34, 5, 0);
  544. printf ("after ex_put_side_set_param, error = %d\n", error);
  545. elem_list[0] = 5; elem_list[1] = 5;
  546. elem_list[2] = 5; elem_list[3] = 5;
  547. elem_list[4] = 5;
  548. side_list[0] = 1; side_list[1] = 2;
  549. side_list[2] = 3; side_list[3] = 4;
  550. side_list[4] = 5;
  551. error = ex_put_side_set (exoid, 34, elem_list, side_list);
  552. printf ("after ex_put_side_set, error = %d\n", error);
  553. error = ex_put_prop(exoid, EX_SIDE_SET, 30, "COLOR", 100);
  554. printf ("after ex_put_prop, error = %d\n", error);
  555. error = ex_put_prop(exoid, EX_SIDE_SET, 31, "COLOR", 101);
  556. printf ("after ex_put_prop, error = %d\n", error);
  557. /* file 2 */
  558. for (n=0; n<nexofiles; n++)
  559. {
  560. /* side set 1 */
  561. error = ex_put_side_set_param (exoidm[n], 30, 2, 4);
  562. printf ("after ex_put_side_set_param (%d), error = %d\n", n, error);
  563. elem_list2[0] = 2; elem_list2[1] = 2;
  564. side_list2[0] = 4; side_list2[1] = 2;
  565. dist_fact2[0] = 30.0; dist_fact2[1] = 30.1;
  566. dist_fact2[2] = 30.2; dist_fact2[3] = 30.3;
  567. error = ex_put_side_set (exoidm[n], 30, elem_list2, side_list2);
  568. printf ("after ex_put_side_set (%d), error = %d\n", n, error);
  569. error = ex_put_side_set_dist_fact (exoidm[n], 30, dist_fact2);
  570. printf ("after ex_put_side_set_dist_fact (%d), error = %d\n", n, error);
  571. /* side set 2 */
  572. error = ex_put_side_set_param (exoidm[n], 31, 2, 4);
  573. printf ("after ex_put_side_set_param (%d), error = %d\n", n, error);
  574. elem_list2[0] = 1; elem_list2[1] = 2;
  575. side_list2[0] = 2; side_list2[1] = 3;
  576. dist_fact2[0] = 31.0; dist_fact2[1] = 31.1;
  577. dist_fact2[2] = 31.2; dist_fact2[3] = 31.3;
  578. error = ex_put_side_set (exoidm[n], 31, elem_list2, side_list2);
  579. printf ("after ex_put_side_set (%d), error = %d\n", n, error);
  580. error = ex_put_side_set_dist_fact (exoidm[n], 31, dist_fact2);
  581. printf ("after ex_put_side_set_dist_fact (%d), error = %d\n", n, error);
  582. /* side set #3 - hex */
  583. error = ex_put_side_set_param (exoidm[n], 32, 7, 0);
  584. printf ("after ex_put_side_set_param (%d), error = %d\n", n, error);
  585. elem_list2[0] = 3; elem_list2[1] = 3;
  586. elem_list2[2] = 3; elem_list2[3] = 3;
  587. elem_list2[4] = 3; elem_list2[5] = 3;
  588. elem_list2[6] = 3;
  589. side_list2[0] = 5; side_list2[1] = 3;
  590. side_list2[2] = 3; side_list2[3] = 2;
  591. side_list2[4] = 4; side_list2[5] = 1;
  592. side_list2[6] = 6;
  593. error = ex_put_side_set (exoidm[n], 32, elem_list2, side_list2);
  594. printf ("after ex_put_side_set (%d), error = %d\n", n, error);
  595. /* side set #4 - tetras */
  596. error = ex_put_side_set_param (exoidm[n], 33, 4, 0);
  597. printf ("after ex_put_side_set_param (%d), error = %d\n", n, error);
  598. elem_list2[0] = 4; elem_list2[1] = 4;
  599. elem_list2[2] = 4; elem_list2[3] = 4;
  600. side_list2[0] = 1; side_list2[1] = 2;
  601. side_list2[2] = 3; side_list2[3] = 4;
  602. error = ex_put_side_set (exoidm[n], 33, elem_list2, side_list2);
  603. printf ("after ex_put_side_set (%d), error = %d\n", n, error);
  604. /* side set #5 - wedges */
  605. error = ex_put_side_set_param (exoidm[n], 34, 5, 0);
  606. printf ("after ex_put_side_set_param (%d), error = %d\n", n, error);
  607. elem_list2[0] = 5; elem_list2[1] = 5;
  608. elem_list2[2] = 5; elem_list2[3] = 5;
  609. elem_list2[4] = 5;
  610. side_list2[0] = 1; side_list2[1] = 2;
  611. side_list2[2] = 3; side_list2[3] = 4;
  612. side_list2[4] = 5;
  613. error = ex_put_side_set (exoidm[n], 34, elem_list2, side_list2);
  614. printf ("after ex_put_side_set (%d), error = %d\n", n, error);
  615. error = ex_put_prop(exoidm[n], EX_SIDE_SET, 30, "COLOR", 100);
  616. printf ("after ex_put_prop (%d), error = %d\n", n, error);
  617. error = ex_put_prop(exoidm[n], EX_SIDE_SET, 31, "COLOR", 101);
  618. printf ("after ex_put_prop (%d), error = %d\n", n, error);
  619. }
  620. #else /* TEST_INDIV_SIDESET */
  621. /* write concatenated side sets; this produces the same information as
  622. * the above code which writes individual side sets
  623. */
  624. ids[0] = 30;
  625. ids[1] = 31;
  626. ids[2] = 32;
  627. ids[3] = 33;
  628. ids[4] = 34;
  629. node_list[0] = 8; node_list[1] = 5;
  630. node_list[2] = 6; node_list[3] = 7;
  631. node_list[4] = 2; node_list[5] = 3;
  632. node_list[6] = 7; node_list[7] = 8;
  633. node_list[8] = 9; node_list[9] = 12;
  634. node_list[10] = 11; node_list[11] = 10;
  635. node_list[12] = 11; node_list[13] = 12;
  636. node_list[14] = 16; node_list[15] = 15;
  637. node_list[16] = 16; node_list[17] = 15;
  638. node_list[18] = 11; node_list[19] = 12;
  639. node_list[20] = 10; node_list[21] = 11;
  640. node_list[22] = 15; node_list[23] = 14;
  641. node_list[24] = 13; node_list[25] = 16;
  642. node_list[26] = 12; node_list[27] = 9;
  643. node_list[28] = 14; node_list[29] = 13;
  644. node_list[30] = 9; node_list[31] = 10;
  645. node_list[32] = 16; node_list[33] = 13;
  646. node_list[34] = 14; node_list[35] = 15;
  647. node_list[36] = 17; node_list[37] = 18;
  648. node_list[38] = 20;
  649. node_list[39] = 18; node_list[40] = 19;
  650. node_list[41] = 20;
  651. node_list[42] = 20; node_list[43] = 19;
  652. node_list[44] = 17;
  653. node_list[45] = 19; node_list[46] = 18;
  654. node_list[47] = 17;
  655. node_list[48] = 25; node_list[49] = 24;
  656. node_list[50] = 21; node_list[51] = 22;
  657. node_list[52] = 26; node_list[53] = 25;
  658. node_list[54] = 22; node_list[55] = 23;
  659. node_list[56] = 26; node_list[57] = 23;
  660. node_list[58] = 21; node_list[59] = 24;
  661. node_list[60] = 23; node_list[61] = 22;
  662. node_list[62] = 21;
  663. node_list[63] = 24; node_list[64] = 25;
  664. node_list[65] = 26;
  665. node_ind[0] = 0;
  666. node_ind[1] = 4;
  667. node_ind[2] = 8;
  668. node_ind[3] = 36;
  669. node_ind[4] = 47;
  670. num_elem_per_set[0] = 2;
  671. num_elem_per_set[1] = 2;
  672. num_elem_per_set[2] = 7;
  673. num_elem_per_set[3] = 4;
  674. num_elem_per_set[4] = 5;
  675. num_nodes_per_set[0] = 4;
  676. num_nodes_per_set[1] = 4;
  677. num_nodes_per_set[2] = 28;
  678. num_nodes_per_set[3] = 12;
  679. num_nodes_per_set[4] = 18;
  680. elem_ind[0] = 0;
  681. elem_ind[1] = 2;
  682. elem_ind[2] = 4;
  683. elem_ind[3] = 11;
  684. elem_ind[4] = 15;
  685. elem_list[0] = 2; elem_list[1] = 2;
  686. elem_list[2] = 1; elem_list[3] = 2;
  687. elem_list[4] = 3; elem_list[5] = 3;
  688. elem_list[6] = 3; elem_list[7] = 3;
  689. elem_list[8] = 3; elem_list[9] = 3;
  690. elem_list[10] = 3; elem_list[11] = 4;
  691. elem_list[12] = 4; elem_list[13] = 4;
  692. elem_list[14] = 4; elem_list[15] = 5;
  693. elem_list[16] = 5; elem_list[17] = 5;
  694. elem_list[18] = 5; elem_list[19] = 5;
  695. error = ex_cvt_nodes_to_sides(exoid,
  696. num_elem_per_set,
  697. num_nodes_per_set,
  698. elem_ind,
  699. node_ind,
  700. elem_list,
  701. node_list,
  702. side_list);
  703. printf ("after ex_cvt_nodes_to_sides, error = %d\n", error);
  704. num_df_per_set[0] = 4;
  705. num_df_per_set[1] = 4;
  706. num_df_per_set[2] = 0;
  707. num_df_per_set[3] = 0;
  708. num_df_per_set[4] = 0;
  709. df_ind[0] = 0;
  710. df_ind[1] = 4;
  711. dist_fact[0] = 30.0; dist_fact[1] = 30.1;
  712. dist_fact[2] = 30.2; dist_fact[3] = 30.3;
  713. dist_fact[4] = 31.0; dist_fact[5] = 31.1;
  714. dist_fact[6] = 31.2; dist_fact[7] = 31.3;
  715. error = ex_put_concat_side_sets (exoid, ids, num_elem_per_set,
  716. num_df_per_set, elem_ind, df_ind,
  717. elem_list, side_list, dist_fact);
  718. printf ("after ex_put_concat_side_sets, error = %d\n", error);
  719. error = ex_put_prop(exoid, EX_SIDE_SET, 30, "COLOR", 100);
  720. printf ("after ex_put_prop, error = %d\n", error);
  721. error = ex_put_prop(exoid, EX_SIDE_SET, 31, "COLOR", 101);
  722. printf ("after ex_put_prop, error = %d\n", error);
  723. /* file 2 */
  724. ids2[0] = 30;
  725. ids2[1] = 31;
  726. ids2[2] = 32;
  727. ids2[3] = 33;
  728. ids2[4] = 34;
  729. node_list2[0] = 8; node_list2[1] = 5;
  730. node_list2[2] = 6; node_list2[3] = 7;
  731. node_list2[4] = 2; node_list2[5] = 3;
  732. node_list2[6] = 7; node_list2[7] = 8;
  733. node_list2[8] = 9; node_list2[9] = 12;
  734. node_list2[10] = 11; node_list2[11] = 10;
  735. node_list2[12] = 11; node_list2[13] = 12;
  736. node_list2[14] = 16; node_list2[15] = 15;
  737. node_list2[16] = 16; node_list2[17] = 15;
  738. node_list2[18] = 11; node_list2[19] = 12;
  739. node_list2[20] = 10; node_list2[21] = 11;
  740. node_list2[22] = 15; node_list2[23] = 14;
  741. node_list2[24] = 13; node_list2[25] = 16;
  742. node_list2[26] = 12; node_list2[27] = 9;
  743. node_list2[28] = 14; node_list2[29] = 13;
  744. node_list2[30] = 9; node_list2[31] = 10;
  745. node_list2[32] = 16; node_list2[33] = 13;
  746. node_list2[34] = 14; node_list2[35] = 15;
  747. node_list2[36] = 17; node_list2[37] = 18;
  748. node_list2[38] = 20;
  749. node_list2[39] = 18; node_list2[40] = 19;
  750. node_list2[41] = 20;
  751. node_list2[42] = 20; node_list2[43] = 19;
  752. node_list2[44] = 17;
  753. node_list2[45] = 19; node_list2[46] = 18;
  754. node_list2[47] = 17;
  755. node_list2[48] = 25; node_list2[49] = 24;
  756. node_list2[50] = 21; node_list2[51] = 22;
  757. node_list2[52] = 26; node_list2[53] = 25;
  758. node_list2[54] = 22; node_list2[55] = 23;
  759. node_list2[56] = 26; node_list2[57] = 23;
  760. node_list2[58] = 21; node_list2[59] = 24;
  761. node_list2[60] = 23; node_list2[61] = 22;
  762. node_list2[62] = 21;
  763. node_list2[63] = 24; node_list2[64] = 25;
  764. node_list2[65] = 26;
  765. node_ind2[0] = 0;
  766. node_ind2[1] = 4;
  767. node_ind2[2] = 8;
  768. node_ind2[3] = 36;
  769. node_ind2[4] = 47;
  770. num_elem_per_set2[0] = 2;
  771. num_elem_per_set2[1] = 2;
  772. num_elem_per_set2[2] = 7;
  773. num_elem_per_set2[3] = 4;
  774. num_elem_per_set2[4] = 5;
  775. num_nodes_per_set2[0] = 4;
  776. num_nodes_per_set2[1] = 4;
  777. num_nodes_per_set2[2] = 28;
  778. num_nodes_per_set2[3] = 12;
  779. num_nodes_per_set2[4] = 18;
  780. elem_ind2[0] = 0;
  781. elem_ind2[1] = 2;
  782. elem_ind2[2] = 4;
  783. elem_ind2[3] = 11;
  784. elem_ind2[4] = 15;
  785. elem_list2[0] = 2; elem_list2[1] = 2;
  786. elem_list2[2] = 1; elem_list2[3] = 2;
  787. elem_list2[4] = 3; elem_list2[5] = 3;
  788. elem_list2[6] = 3; elem_list2[7] = 3;
  789. elem_list2[8] = 3; elem_list2[9] = 3;
  790. elem_list2[10] = 3; elem_list2[11] = 4;
  791. elem_list2[12] = 4; elem_list2[13] = 4;
  792. elem_list2[14] = 4; elem_list2[15] = 5;
  793. elem_list2[16] = 5; elem_list2[17] = 5;
  794. elem_list2[18] = 5; elem_list2[19] = 5;
  795. num_df_per_set2[0] = 4;
  796. num_df_per_set2[1] = 4;
  797. num_df_per_set2[2] = 0;
  798. num_df_per_set2[3] = 0;
  799. num_df_per_set2[4] = 0;
  800. df_ind2[0] = 0;
  801. df_ind2[1] = 4;
  802. dist_fact2[0] = 30.0; dist_fact2[1] = 30.1;
  803. dist_fact2[2] = 30.2; dist_fact2[3] = 30.3;
  804. dist_fact2[4] = 31.0; dist_fact2[5] = 31.1;
  805. dist_fact2[6] = 31.2; dist_fact2[7] = 31.3;
  806. for (n=0; n<nexofiles; n++)
  807. {
  808. error = ex_cvt_nodes_to_sides(exoidm[n],
  809. num_elem_per_set2,
  810. num_nodes_per_set2,
  811. elem_ind2,
  812. node_ind2,
  813. elem_list2,
  814. node_list2,
  815. side_list2);
  816. printf ("after ex_cvt_nodes_to_sides (%d), error = %d\n", n, error);
  817. error = ex_put_concat_side_sets (exoidm[n], ids2, num_elem_per_set2,
  818. num_df_per_set2, elem_ind2, df_ind2,
  819. elem_list2, side_list2, dist_fact2);
  820. printf ("after ex_put_concat_side_sets (%d), error = %d\n", n, error);
  821. error = ex_put_prop(exoidm[n], EX_SIDE_SET, 30, "COLOR", 100);
  822. printf ("after ex_put_prop (%d), error = %d\n", n, error);
  823. error = ex_put_prop(exoidm[n], EX_SIDE_SET, 31, "COLOR", 101);
  824. printf ("after ex_put_prop (%d), error = %d\n", n, error);
  825. }
  826. /* END COMMENTED OUT SECTION */
  827. #endif /* TEST_INDIV_SIDESET */
  828. /* write QA records */
  829. num_qa_rec = 2;
  830. qa_record[0][0] = "TESTWTM";
  831. qa_record[0][1] = "testwtm";
  832. qa_record[0][2] = "07/07/93";
  833. qa_record[0][3] = "15:41:33";
  834. qa_record[1][0] = "FASTQ";
  835. qa_record[1][1] = "fastq";
  836. qa_record[1][2] = "07/07/93";
  837. qa_record[1][3] = "16:41:33";
  838. error = ex_put_qa (exoid, num_qa_rec, qa_record);
  839. printf ("after ex_put_qa, error = %d\n", error);
  840. num_qa_rec2 = 2;
  841. qa_record2[0][0] = "TESTWTM";
  842. qa_record2[0][1] = "testwtm";
  843. qa_record2[0][2] = "07/07/93";
  844. qa_record2[0][3] = "15:41:33";
  845. qa_record2[1][0] = "FASTQ";
  846. qa_record2[1][1] = "fastq";
  847. qa_record2[1][2] = "07/07/93";
  848. qa_record2[1][3] = "16:41:33";
  849. for (n=0; n<nexofiles; n++)
  850. {
  851. error = ex_put_qa (exoidm[n], num_qa_rec2, qa_record2);
  852. printf ("after ex_put_qa (%d), error = %d\n", n, error);
  853. }
  854. /* write information records */
  855. num_info = 3;
  856. info[0] = "This is the first information record.";
  857. info[1] = "This is the second information record.";
  858. info[2] = "This is the third information record.";
  859. error = ex_put_info (exoid, num_info, info);
  860. printf ("after ex_put_info, error = %d\n", error);
  861. num_info2 = 3;
  862. info2[0] = "This is the first information record.";
  863. info2[1] = "This is the second information record.";
  864. info2[2] = "This is the third information record.";
  865. for (n=0; n<nexofiles; n++)
  866. {
  867. error = ex_put_info (exoidm[n], num_info2, info2);
  868. printf ("after ex_put_info (%d), error = %d\n", n, error);
  869. }
  870. /* write results variables parameters and names */
  871. num_glo_vars = 1;
  872. var_names[0] = "glo_vars";
  873. error = ex_put_var_param (exoid, "g", num_glo_vars);
  874. printf ("after ex_put_var_param, error = %d\n", error);
  875. error = ex_put_var_names (exoid, "g", num_glo_vars, var_names);
  876. printf ("after ex_put_var_names, error = %d\n", error);
  877. num_glo_vars2 = 1;
  878. var_names2[0] = "glo_vars";
  879. for (n=0; n<nexofiles; n++)
  880. {
  881. error = ex_put_var_param (exoidm[n], "g", num_glo_vars2);
  882. printf ("after ex_put_var_param (%d), error = %d\n", n, error);
  883. error = ex_put_var_names (exoidm[n], "g", num_glo_vars2, var_names2);
  884. printf ("after ex_put_var_names (%d), error = %d\n", n, error);
  885. }
  886. num_nod_vars = 2;
  887. var_names[0] = "nod_var0";
  888. var_names[1] = "nod_var1";
  889. error = ex_put_var_param (exoid, "n", num_nod_vars);
  890. printf ("after ex_put_var_param, error = %d\n", error);
  891. error = ex_put_var_names (exoid, "n", num_nod_vars, var_names);
  892. printf ("after ex_put_var_names, error = %d\n", error);
  893. num_nod_vars2 = 2;
  894. var_names2[0] = "nod_var0";
  895. var_names2[1] = "nod_var1";
  896. for (n=0; n<nexofiles; n++)
  897. {
  898. error = ex_put_var_param (exoidm[n], "n", num_nod_vars2);
  899. printf ("after ex_put_var_param (%d), error = %d\n", n, error);
  900. error = ex_put_var_names (exoidm[n], "n", num_nod_vars2, var_names2);
  901. printf ("after ex_put_var_names (%d), error = %d\n", n, error);
  902. }
  903. num_ele_vars = 3;
  904. var_names[0] = "ele_var0";
  905. var_names[1] = "ele_var1";
  906. var_names[2] = "ele_var2";
  907. error = ex_put_var_param (exoid, "e", num_ele_vars);
  908. printf ("after ex_put_var_param, error = %d\n", error);
  909. error = ex_put_var_names (exoid, "e", num_ele_vars, var_names);
  910. printf ("after ex_put_var_names, error = %d\n", error);
  911. num_ele_vars2 = 3;
  912. var_names2[0] = "ele_var20";
  913. var_names2[1] = "ele_var21";
  914. var_names2[2] = "ele_var22";
  915. for (n=0; n<nexofiles; n++)
  916. {
  917. error = ex_put_var_param (exoidm[n], "e", num_ele_vars2);
  918. printf ("after ex_put_var_param (%d), error = %d\n", n, error);
  919. error = ex_put_var_names (exoidm[n], "e", num_ele_vars, var_names);
  920. printf ("after ex_put_var_names (%d), error = %d\n", n, error);
  921. }
  922. /* write element variable truth table */
  923. truth_tab = (int *) calloc ((num_elem_blk*num_ele_vars), sizeof(int));
  924. k = 0;
  925. for (i=0; i<num_elem_blk; i++)
  926. {
  927. for (j=0; j<num_ele_vars; j++)
  928. {
  929. truth_tab[k++] = 1;
  930. }
  931. }
  932. error = ex_put_elem_var_tab (exoid, num_elem_blk, num_ele_vars, truth_tab);
  933. printf ("after ex_put_elem_var_tab, error = %d\n", error);
  934. for (n=0; n<nexofiles; n++)
  935. {
  936. error=ex_put_elem_var_tab(exoidm[n],num_elem_blk,num_ele_vars,truth_tab);
  937. printf ("after ex_put_elem_var_tab (%d), error = %d\n", n, error);
  938. }
  939. free (truth_tab);
  940. /* for each time step, write the analysis results;
  941. * the code below fills the arrays glob_var_vals,
  942. * nodal_var_vals, and elem_var_vals with values for debugging purposes;
  943. * obviously the analysis code will populate these arrays
  944. */
  945. whole_time_step = 1;
  946. num_time_steps = 10;
  947. glob_var_vals = (float *) calloc (num_glo_vars, sizeof(CPU_word_size));
  948. nodal_var_vals = (float *) calloc (num_nodes, sizeof(CPU_word_size));
  949. elem_var_vals = (float *) calloc (4, sizeof(CPU_word_size));
  950. for (i=0; i<num_time_steps; i++)
  951. {
  952. time_value = (float)(i+1)/100.;
  953. time_value2 = (float)(i+1)/100.;
  954. /* write time value */
  955. error = ex_put_time (exoid, whole_time_step, &time_value);
  956. printf ("after ex_put_time, error = %d\n", error);
  957. for (n=0; n<nexofiles; n++)
  958. {
  959. error = ex_put_time (exoidm[n], whole_time_step, &time_value2);
  960. printf ("after ex_put_time (%d), error = %d\n", n, error);
  961. }
  962. /* write global variables */
  963. for (j=0; j<num_glo_vars; j++)
  964. {
  965. glob_var_vals[j] = (float)(j+2) * time_value;
  966. }
  967. error = ex_put_glob_vars (exoid, whole_time_step, num_glo_vars,
  968. glob_var_vals);
  969. printf ("after ex_put_glob_vars, error = %d\n", error);
  970. for (n=0; n<nexofiles; n++)
  971. {
  972. error = ex_put_glob_vars (exoidm[n], whole_time_step, num_glo_vars,
  973. glob_var_vals);
  974. printf ("after ex_put_glob_vars (%d), error = %d\n", n, error);
  975. }
  976. /* write nodal variables */
  977. for (k=1; k<=num_nod_vars; k++)
  978. {
  979. for (j=0; j<num_nodes; j++)
  980. {
  981. nodal_var_vals[j] = (float)k + ((float)(j+1) * time_value);
  982. }
  983. error = ex_put_nodal_var (exoid, whole_time_step, k, num_nodes,
  984. nodal_var_vals);
  985. printf ("after ex_put_nodal_var, error = %d\n", error);
  986. for (n=0; n<nexofiles; n++)
  987. {
  988. error = ex_put_nodal_var (exoidm[n], whole_time_step, k, num_nodes,
  989. nodal_var_vals);
  990. printf ("after ex_put_nodal_var (%d), error = %d\n", n, error);
  991. }
  992. }
  993. /* write element variables */
  994. for (k=1; k<=num_ele_vars; k++)
  995. {
  996. for (j=0; j<num_elem_blk; j++)
  997. {
  998. for (m=0; m<num_elem_in_block[j]; m++)
  999. {
  1000. elem_var_vals[m] = (float)(k+1) + (float)(j+2) +
  1001. ((float)(m+1)*time_value);
  1002. /* printf("elem_var_vals[%d]: %f\n",m,elem_var_vals[m]); */
  1003. }
  1004. error = ex_put_elem_var (exoid, whole_time_step, k, ebids[j],
  1005. num_elem_in_block[j], elem_var_vals);
  1006. printf ("after ex_put_elem_var, error = %d\n", error);
  1007. for (n=0; n<nexofiles; n++)
  1008. {
  1009. error = ex_put_elem_var (exoidm[n], whole_time_step, k, ebids[j],
  1010. num_elem_in_block[j], elem_var_vals);
  1011. printf ("after ex_put_elem_var (%d), error = %d\n", n, error);
  1012. }
  1013. }
  1014. }
  1015. whole_time_step++;
  1016. /* update the data file; this should be done at the end of every time step
  1017. * to ensure that no data is lost if the analysis dies
  1018. */
  1019. error = ex_update (exoid);
  1020. printf ("after ex_update, error = %d\n", error);
  1021. for (n=0; n<nexofiles; n++)
  1022. {
  1023. error = ex_update (exoidm[n]);
  1024. printf ("after ex_update (%d), error = %d\n", n, error);
  1025. }
  1026. }
  1027. free(glob_var_vals);
  1028. free(nodal_var_vals);
  1029. free(elem_var_vals);
  1030. /* close the EXODUS files
  1031. */
  1032. error = ex_close (exoid);
  1033. printf ("after ex_close, error = %d\n", error);
  1034. for (n=0; n<nexofiles; n++)
  1035. {
  1036. error = ex_close (exoidm[n]);
  1037. printf ("after ex_close (%d), error = %d\n", n, error);
  1038. }
  1039. return 0;
  1040. }