00001 #include <stdio.h>
00002 #include <stdlib.h>
00003 #include <string.h>
00004 #ifndef _WIN32
00005 # include <unistd.h>
00006 #endif
00007 #include "cgnslib.h"
00008
00009 #define NUM_SIDE 5
00010 #define NUM_RANDOM 10
00011
00012 float *xcoord;
00013 float *ycoord;
00014 float *zcoord;
00015 float *fbuf;
00016
00017 int *elements;
00018 int *faces;
00019 int *parent;
00020 int *ptmp;
00021 int *ibuf, *pbuf;
00022
00023 #define NODE_INDEX(I,J,K) ((I)+NUM_SIDE*(((J)-1)+NUM_SIDE*((K)-1)))
00024 #define CELL_INDEX(I,J,K) ((I)+(NUM_SIDE-1)*(((J)-1)+(NUM_SIDE-1)*((K)-1)))
00025
00026 int irandom(int imin, int imax) {
00027 float r = (float)rand() / (float)RAND_MAX;
00028 int i = imin + (int)(r * (float)(imax - imin));
00029 if (i < imin) return imin;
00030 if (i > imax) return imax;
00031 return i;
00032 }
00033
00034 void get_parent(int rmin, int rmax, int nelems, int nfaces) {
00035 int i, j, k, n, nn, np;
00036
00037 np = rmax - rmin + 1;
00038 nn = rmin - nelems - 1;
00039 for (n = 0, j = 0; j < 4; j++) {
00040 k = j * nfaces + nn;
00041 for (i = 0; i < np; i++)
00042 ptmp[n++] = parent[k++];
00043 }
00044 }
00045
00046 int mixed_offset(int num, int nelems) {
00047 int offset;
00048 int nmixed = nelems << 1;
00049
00050 if (--num < nmixed) {
00051 int i = num >> 1;
00052 offset = 14 * i;
00053 if (num != (i << 1)) offset += 5;
00054 }
00055 else
00056 offset = 14 * nelems + 5 * (num - nmixed);
00057 return offset;
00058 }
00059
00060 int main (int argc, char **argv)
00061 {
00062 int n, i, j, k, nn, nf, np;
00063 int nnodes, nelems, nfaces;
00064 int cgfile, cgbase, cgzone, cgcoord, cgsect, cgsol, cgfld;
00065 int size[3], rmin, rmax;
00066 char name[33];
00067 ElementType_t type;
00068 static char *fname = "partial.cgns";
00069
00070 if (argc > 1) {
00071 n = 0;
00072 if (argv[1][n] == '-') n++;
00073 if (argv[1][n] == 'a' || argv[1][n] == 'A')
00074 nn = CG_FILE_ADF;
00075 else if (argv[1][n] == 'h' || argv[1][n] == 'H')
00076 nn = CG_FILE_HDF5;
00077 else if (argv[1][n] == 'x' || argv[1][n] == 'X')
00078 nn = CG_FILE_XML;
00079 else {
00080 fprintf(stderr, "unknown option\n");
00081 exit (1);
00082 }
00083 if (cg_set_file_type(nn))
00084 cg_error_exit();
00085 }
00086
00087 nnodes = NUM_SIDE * NUM_SIDE * NUM_SIDE;
00088 xcoord = (float *) malloc (4 * nnodes * sizeof(float));
00089 ycoord = xcoord + nnodes;
00090 zcoord = ycoord + nnodes;
00091 fbuf = zcoord + nnodes;
00092
00093 for (n = 0, k = 1; k <= NUM_SIDE; k++) {
00094 for (j = 1; j <= NUM_SIDE; j++) {
00095 for (i = 1; i <= NUM_SIDE; i++) {
00096 xcoord[n] = (float)i;
00097 ycoord[n] = (float)j;
00098 zcoord[n] = (float)k;
00099 n++;
00100 }
00101 }
00102 }
00103
00104 nelems = (NUM_SIDE - 1) * (NUM_SIDE - 1) * (NUM_SIDE - 1);
00105 elements = (int *) malloc (16 * nelems * sizeof(int));
00106 ibuf = elements + 8 * nelems;
00107
00108 for (n = 0, k = 1; k < NUM_SIDE; k++) {
00109 for (j = 1; j < NUM_SIDE; j++) {
00110 for (i = 1; i < NUM_SIDE; i++) {
00111 nn = NODE_INDEX(i, j, k);
00112 elements[n++] = nn;
00113 elements[n++] = nn + 1;
00114 elements[n++] = nn + 1 + NUM_SIDE;
00115 elements[n++] = nn + NUM_SIDE;
00116 nn += NUM_SIDE * NUM_SIDE;
00117 elements[n++] = nn;
00118 elements[n++] = nn + 1;
00119 elements[n++] = nn + 1 + NUM_SIDE;
00120 elements[n++] = nn + NUM_SIDE;
00121 }
00122 }
00123 }
00124
00125 nfaces = 6 * (NUM_SIDE - 1) * (NUM_SIDE - 1);
00126 faces = (int *) malloc (18 * nfaces * sizeof(int));
00127 parent = faces + 4 * nfaces;
00128 ptmp = parent + 4 * nfaces;
00129 pbuf = ptmp + 4 * nfaces;
00130
00131 for (n = 0; n < 4 * nfaces; n++)
00132 parent[n] = 0;
00133 np = nf = 0;
00134 n = 2 * nfaces;
00135
00136 i = 1;
00137 for (k = 1; k < NUM_SIDE; k++) {
00138 for (j = 1; j < NUM_SIDE; j++) {
00139 nn = NODE_INDEX(i, j, k);
00140 faces[nf++] = nn;
00141 faces[nf++] = nn + NUM_SIDE * NUM_SIDE;
00142 faces[nf++] = nn + NUM_SIDE * (NUM_SIDE + 1);
00143 faces[nf++] = nn + NUM_SIDE;
00144 parent[np] = CELL_INDEX(i, j, k);
00145 parent[np+n] = 5;
00146 np++;
00147 }
00148 }
00149 i = NUM_SIDE;
00150 for (k = 1; k < NUM_SIDE; k++) {
00151 for (j = 1; j < NUM_SIDE; j++) {
00152 nn = NODE_INDEX(i, j, k);
00153 faces[nf++] = nn;
00154 faces[nf++] = nn + NUM_SIDE;
00155 faces[nf++] = nn + NUM_SIDE * (NUM_SIDE + 1);
00156 faces[nf++] = nn + NUM_SIDE * NUM_SIDE;
00157 parent[np] = CELL_INDEX(i-1, j, k);
00158 parent[np+n] = 3;
00159 np++;
00160 }
00161 }
00162 j = 1;
00163 for (k = 1; k < NUM_SIDE; k++) {
00164 for (i = 1; i < NUM_SIDE; i++) {
00165 nn = NODE_INDEX(i, j, k);
00166 faces[nf++] = nn;
00167 faces[nf++] = nn + 1;
00168 faces[nf++] = nn + 1 + NUM_SIDE * NUM_SIDE;
00169 faces[nf++] = nn + NUM_SIDE * NUM_SIDE;
00170 parent[np] = CELL_INDEX(i, j, k);
00171 parent[np+n] = 2;
00172 np++;
00173 }
00174 }
00175 j = NUM_SIDE;
00176 for (k = 1; k < NUM_SIDE; k++) {
00177 for (i = 1; i < NUM_SIDE; i++) {
00178 nn = NODE_INDEX(i, j, k);
00179 faces[nf++] = nn;
00180 faces[nf++] = nn + NUM_SIDE * NUM_SIDE;
00181 faces[nf++] = nn + 1 + NUM_SIDE * NUM_SIDE;
00182 faces[nf++] = nn + 1;
00183 parent[np] = CELL_INDEX(i, j-1, k);
00184 parent[np+n] = 4;
00185 np++;
00186 }
00187 }
00188 k = 1;
00189 for (j = 1; j < NUM_SIDE; j++) {
00190 for (i = 1; i < NUM_SIDE; i++) {
00191 nn = NODE_INDEX(i, j, k);
00192 faces[nf++] = nn;
00193 faces[nf++] = nn + NUM_SIDE;
00194 faces[nf++] = nn + NUM_SIDE + 1;
00195 faces[nf++] = nn + 1;
00196 parent[np] = CELL_INDEX(i, j, k);
00197 parent[np+n] = 1;
00198 np++;
00199 }
00200 }
00201 k = NUM_SIDE;
00202 for (j = 1; j < NUM_SIDE; j++) {
00203 for (i = 1; i < NUM_SIDE; i++) {
00204 nn = NODE_INDEX(i, j, k);
00205 faces[nf++] = nn;
00206 faces[nf++] = nn + 1;
00207 faces[nf++] = nn + NUM_SIDE + 1;
00208 faces[nf++] = nn + NUM_SIDE;
00209 parent[np] = CELL_INDEX(i, j, k-1);
00210 parent[np+n] = 6;
00211 np++;
00212 }
00213 }
00214
00215 unlink (fname);
00216 printf ("creating CGNS file %s\n", fname);
00217 if (cg_open (fname, CG_MODE_WRITE, &cgfile) ||
00218 cg_base_write (cgfile, "Base", 3, 3, &cgbase))
00219 cg_error_exit ();
00220
00221
00222
00223 puts("\nwriting zone with partial write");
00224
00225 size[0] = nnodes;
00226 size[1] = nelems;
00227 size[2] = 0;
00228
00229 if (cg_zone_write (cgfile, cgbase, "Zone", size, Unstructured, &cgzone))
00230 cg_error_exit();
00231
00232
00233
00234 np = NUM_SIDE * NUM_SIDE;
00235 for (k = 0; k < NUM_SIDE; k += 2) {
00236 n = k * np;
00237 rmin = n + 1;
00238 rmax = n + np;
00239 printf("coordinates %d -> %d\n", rmin, rmax);
00240 if (cg_coord_partial_write(cgfile, cgbase, cgzone, RealSingle,
00241 "CoordinateX", &rmin, &rmax, &xcoord[n], &cgcoord) ||
00242 cg_coord_partial_write(cgfile, cgbase, cgzone, RealSingle,
00243 "CoordinateY", &rmin, &rmax, &ycoord[n], &cgcoord) ||
00244 cg_coord_partial_write(cgfile, cgbase, cgzone, RealSingle,
00245 "CoordinateZ", &rmin, &rmax, &zcoord[n], &cgcoord))
00246 cg_error_exit();
00247 }
00248
00249
00250
00251 np = (NUM_SIDE - 1) * (NUM_SIDE - 1);
00252 for (k = 1; k < NUM_SIDE; k += 2) {
00253 nn = (k - 1) * np;
00254 n = nn << 3;
00255 rmin = nn + 1;
00256 rmax = nn + np;
00257 printf("elements %d -> %d\n", rmin, rmax);
00258 if (cg_section_partial_write(cgfile, cgbase, cgzone, "Elements",
00259 HEXA_8, rmin, rmax, 0, &elements[n], &cgsect))
00260 cg_error_exit();
00261 }
00262
00263
00264
00265 for (k = 0; k < 6; k += 2) {
00266 nn = k * np;
00267 n = nn << 2;
00268 rmin = nn + 1 + nelems;
00269 rmax = nn + np + nelems;
00270 get_parent(rmin, rmax, nelems, nfaces);
00271 printf("faces %d -> %d\n", rmin, rmax);
00272 if (cg_section_partial_write(cgfile, cgbase, cgzone, "Faces",
00273 QUAD_4, rmin, rmax, 0, &faces[n], &cgsect) ||
00274 cg_parent_data_partial_write(cgfile, cgbase, cgzone, cgsect,
00275 rmin, rmax, ptmp))
00276 cg_error_exit();
00277 }
00278
00279
00280
00281 if (cg_sol_write(cgfile, cgbase, cgzone, "Solution", Vertex, &cgsol))
00282 cg_error_exit();
00283
00284 puts("field -> 1,3,5,7 ...");
00285 for (n = 0; n < nnodes; n += 2) {
00286 rmin = n + 1;
00287 rmax = n + 1;
00288 if (cg_field_partial_write(cgfile, cgbase, cgzone, cgsol,
00289 RealSingle, "Field", &rmin, &rmax, &xcoord[n], &cgfld))
00290 cg_error_exit();
00291 }
00292
00293 puts ("closing and reopening in modify mode");
00294 cg_close (cgfile);
00295
00296 if (cg_open (fname, CG_MODE_MODIFY, &cgfile))
00297 cg_error_exit ();
00298
00299
00300
00301 np = NUM_SIDE * NUM_SIDE;
00302 for (k = 1; k < NUM_SIDE; k += 2) {
00303 n = k * np;
00304 rmin = n + 1;
00305 rmax = n + np;
00306 printf("coordinates %d -> %d\n", rmin, rmax);
00307 if (cg_coord_partial_write(cgfile, cgbase, cgzone, RealSingle,
00308 "CoordinateX", &rmin, &rmax, &xcoord[n], &cgcoord) ||
00309 cg_coord_partial_write(cgfile, cgbase, cgzone, RealSingle,
00310 "CoordinateY", &rmin, &rmax, &ycoord[n], &cgcoord) ||
00311 cg_coord_partial_write(cgfile, cgbase, cgzone, RealSingle,
00312 "CoordinateZ", &rmin, &rmax, &zcoord[n], &cgcoord))
00313 cg_error_exit();
00314 }
00315
00316
00317
00318 np = (NUM_SIDE - 1) * (NUM_SIDE - 1);
00319 for (k = 2; k < NUM_SIDE; k += 2) {
00320 nn = (k - 1) * np;
00321 n = nn << 3;
00322 rmin = nn + 1;
00323 rmax = nn + np;
00324 printf("elements %d -> %d\n", rmin, rmax);
00325 if (cg_section_partial_write(cgfile, cgbase, cgzone, "Elements",
00326 HEXA_8, rmin, rmax, 0, &elements[n], &cgsect))
00327 cg_error_exit();
00328 }
00329
00330
00331
00332 for (k = 1; k < 6; k += 2) {
00333 nn = k * np;
00334 n = nn << 2;
00335 rmin = nn + 1 + nelems;
00336 rmax = nn + np + nelems;
00337 get_parent(rmin, rmax, nelems, nfaces);
00338 printf("faces %d -> %d\n", rmin, rmax);
00339 if (cg_section_partial_write(cgfile, cgbase, cgzone, "Faces",
00340 QUAD_4, rmin, rmax, 0, &faces[n], &cgsect) ||
00341 cg_parent_data_partial_write(cgfile, cgbase, cgzone, cgsect,
00342 rmin, rmax, ptmp))
00343 cg_error_exit();
00344 }
00345
00346
00347
00348 puts("field -> 2,4,6,8 ...");
00349 for (n = 1; n < nnodes; n += 2) {
00350 rmin = n + 1;
00351 rmax = n + 1;
00352 if (cg_field_partial_write(cgfile, cgbase, cgzone, cgsol,
00353 RealSingle, "Field", &rmin, &rmax, &xcoord[n], &cgfld))
00354 cg_error_exit();
00355 }
00356
00357 #if NUM_RANDOM > 0
00358
00359
00360
00361 printf("doing random modification\n");
00362
00363 for (k = 0; k < NUM_RANDOM; k++) {
00364 rmin = irandom(1, nnodes);
00365 rmax = irandom(1, nnodes);
00366 if (rmin > rmax) {
00367 n = rmin;
00368 rmin = rmax;
00369 rmax = n;
00370 }
00371 n = rmin - 1;
00372 printf("coordinates %d -> %d\n", rmin, rmax);
00373 if (cg_coord_partial_write(cgfile, cgbase, cgzone, RealSingle,
00374 "CoordinateX", &rmin, &rmax, &xcoord[n], &cgcoord) ||
00375 cg_coord_partial_write(cgfile, cgbase, cgzone, RealSingle,
00376 "CoordinateY", &rmin, &rmax, &ycoord[n], &cgcoord) ||
00377 cg_coord_partial_write(cgfile, cgbase, cgzone, RealSingle,
00378 "CoordinateZ", &rmin, &rmax, &zcoord[n], &cgcoord))
00379 cg_error_exit();
00380 }
00381
00382 for (k = 0; k < NUM_RANDOM; k++) {
00383 rmin = irandom(1, nelems);
00384 rmax = irandom(1, nelems);
00385 if (rmin > rmax) {
00386 n = rmin;
00387 rmin = rmax;
00388 rmax = n;
00389 }
00390 n = (rmin - 1) << 3;
00391 printf("elements %d -> %d\n", rmin, rmax);
00392 if (cg_section_partial_write(cgfile, cgbase, cgzone, "Elements",
00393 HEXA_8, rmin, rmax, 0, &elements[n], &cgsect))
00394 cg_error_exit();
00395 }
00396
00397 for (k = 0; k < NUM_RANDOM; k++) {
00398 rmin = irandom(1, nfaces);
00399 rmax = irandom(1, nfaces);
00400 if (rmin > rmax) {
00401 n = rmin;
00402 rmin = rmax;
00403 rmax = n;
00404 }
00405 nn = rmin - 1;
00406 n = nn << 2;
00407 rmin += nelems;
00408 rmax += nelems;
00409 get_parent(rmin, rmax, nelems, nfaces);
00410 printf("faces %d -> %d\n", rmin, rmax);
00411 if (cg_section_partial_write(cgfile, cgbase, cgzone, "Faces",
00412 QUAD_4, rmin, rmax, 0, &faces[n], &cgsect) ||
00413 cg_parent_data_partial_write(cgfile, cgbase, cgzone, cgsect,
00414 rmin, rmax, ptmp))
00415 cg_error_exit();
00416 }
00417
00418 for (k = 0; k < NUM_RANDOM; k++) {
00419 rmin = irandom(1, nnodes);
00420 rmax = irandom(1, nnodes);
00421 if (rmin > rmax) {
00422 n = rmin;
00423 rmin = rmax;
00424 rmax = n;
00425 }
00426 n = rmin - 1;
00427 printf("field %d -> %d\n", rmin, rmax);
00428 if (cg_field_partial_write(cgfile, cgbase, cgzone, cgsol,
00429 RealSingle, "Field", &rmin, &rmax, &xcoord[n], &cgfld))
00430 cg_error_exit();
00431 }
00432
00433 #endif
00434
00435
00436
00437 puts("checking the data");
00438
00439 nn = 0;
00440
00441
00442
00443 rmin = 1;
00444 rmax = nnodes;
00445 if (cg_coord_read(cgfile, cgbase, cgzone, "CoordinateX",
00446 RealSingle, &rmin, &rmax, fbuf))
00447 cg_error_exit();
00448 for (np = 0, n = 0; n < nnodes; n++) {
00449 if (fbuf[n] != xcoord[n]) np++;
00450 }
00451 nn += np;
00452 if (np) printf("%d differences in CoordinateX\n", np);
00453
00454 if (cg_coord_read(cgfile, cgbase, cgzone, "CoordinateY",
00455 RealSingle, &rmin, &rmax, fbuf))
00456 cg_error_exit();
00457 for (np = 0, n = 0; n < nnodes; n++) {
00458 if (fbuf[n] != ycoord[n]) np++;
00459 }
00460 nn += np;
00461 if (np) printf("%d differences in CoordinateY\n", np);
00462
00463 if (cg_coord_read(cgfile, cgbase, cgzone, "CoordinateZ",
00464 RealSingle, &rmin, &rmax, fbuf))
00465 cg_error_exit();
00466 for (np = 0, n = 0; n < nnodes; n++) {
00467 if (fbuf[n] != zcoord[n]) np++;
00468 }
00469 nn += np;
00470 if (np) printf("%d differences in CoordinateZ\n", np);
00471
00472
00473
00474 if (cg_section_read(cgfile, cgbase, cgzone, 1, name,
00475 &type, &i, &j, &k, &n) ||
00476 cg_elements_read(cgfile, cgbase, cgzone, 1, ibuf, NULL))
00477 cg_error_exit();
00478 if (strcmp(name, "Elements") || type != HEXA_8 || i != 1 ||
00479 j != nelems || k != 0 || n != 0) {
00480 nn++;
00481 puts("differences in Elements");
00482 }
00483 for (np = 0, n = 0; n < 8*nelems; n++) {
00484 if (elements[n] != ibuf[n]) np++;
00485 }
00486 nn += np;
00487 if (np) printf("%d differences in Elements connectivity\n", np);
00488
00489
00490
00491 if (cg_section_read(cgfile, cgbase, cgzone, 2, name,
00492 &type, &i, &j, &k, &n) ||
00493 cg_elements_read(cgfile, cgbase, cgzone, 2, ibuf, pbuf))
00494 cg_error_exit();
00495 if (strcmp(name, "Faces") || type != QUAD_4 || i != (nelems+1) ||
00496 j != (nelems+nfaces) || k != 0 || n != 1) {
00497 nn++;
00498 puts("differences in Faces");
00499 }
00500 for (np = 0, n = 0; n < 4*nfaces; n++) {
00501 if (faces[n] != ibuf[n]) np++;
00502 }
00503 nn += np;
00504 if (np) printf("%d differences in Faces connectivity\n", np);
00505
00506 for (np = 0, n = 0; n < 4*nfaces; n++) {
00507 if (parent[n] != pbuf[n]) np++;
00508 }
00509 nn += np;
00510 if (np) printf("%d differences in Faces parent data\n", np);
00511
00512
00513
00514 if (cg_field_read(cgfile, cgbase, cgzone, 1, "Field",
00515 RealSingle, &rmin, &rmax, fbuf))
00516 cg_error_exit();
00517 for (np = 0, n = 0; n < nnodes; n++) {
00518 if (fbuf[n] != xcoord[n]) np++;
00519 }
00520 nn += np;
00521 if (np) printf("%d differences in Field\n", np);
00522
00523 if (nn == 0) puts("no diferences");
00524
00525 #if NUM_RANDOM > 0
00526
00527
00528
00529 puts("doing random reads/checks");
00530
00531 for (k = 0; k < NUM_RANDOM; k++) {
00532 rmin = irandom(1, nnodes);
00533 rmax = irandom(1, nnodes);
00534 if (rmin > rmax) {
00535 n = rmin;
00536 rmin = rmax;
00537 rmax = n;
00538 }
00539 printf("coordinates %d -> %d\n", rmin, rmax);
00540 n = rmin - 1;
00541 np = 0;
00542 nn = rmax - rmin + 1;
00543 if (cg_coord_read(cgfile, cgbase, cgzone, "CoordinateX",
00544 RealSingle, &rmin, &rmax, fbuf))
00545 cg_error_exit();
00546 for (i = 0; i < nn; i++) {
00547 if (fbuf[i] != xcoord[n+i]) np++;
00548 }
00549
00550 if (cg_coord_read(cgfile, cgbase, cgzone, "CoordinateY",
00551 RealSingle, &rmin, &rmax, fbuf))
00552 cg_error_exit();
00553 for (i = 0; i < nn; i++) {
00554 if (fbuf[i] != ycoord[n+i]) np++;
00555 }
00556
00557 if (cg_coord_read(cgfile, cgbase, cgzone, "CoordinateZ",
00558 RealSingle, &rmin, &rmax, fbuf))
00559 cg_error_exit();
00560 for (i = 0; i < nn; i++) {
00561 if (fbuf[i] != zcoord[n+i]) np++;
00562 }
00563 if (np) printf("%d differences in Coordinates\n", np);
00564 }
00565
00566 for (k = 0; k < NUM_RANDOM; k++) {
00567 rmin = irandom(1, nelems);
00568 rmax = irandom(1, nelems);
00569 if (rmin > rmax) {
00570 n = rmin;
00571 rmin = rmax;
00572 rmax = n;
00573 }
00574 n = (rmin - 1) << 3;
00575 nn = (rmax - rmin + 1) << 3;
00576 printf("elements %d -> %d\n", rmin, rmax);
00577 if (cg_ElementPartialSize(cgfile, cgbase, cgzone, 1,
00578 rmin, rmax, &np) ||
00579 cg_elements_partial_read(cgfile, cgbase, cgzone, 1,
00580 rmin, rmax, ibuf, NULL))
00581 cg_error_exit();
00582 if (np != nn) puts("diference in element data size");
00583 for (np = 0, i = 0; i < nn; i++) {
00584 if (ibuf[i] != elements[n+i]) np++;
00585 }
00586 if (np) printf("%d differences in element connectivity\n", np);
00587 }
00588
00589 for (k = 0; k < NUM_RANDOM; k++) {
00590 rmin = irandom(1, nfaces);
00591 rmax = irandom(1, nfaces);
00592 if (rmin > rmax) {
00593 n = rmin;
00594 rmin = rmax;
00595 rmax = n;
00596 }
00597 n = (rmin - 1) << 2;
00598 nn = (rmax - rmin + 1) << 2;
00599 rmin += nelems;
00600 rmax += nelems;
00601 get_parent(rmin, rmax, nelems, nfaces);
00602 printf("faces %d -> %d\n", rmin, rmax);
00603 if (cg_ElementPartialSize(cgfile, cgbase, cgzone, 2,
00604 rmin, rmax, &np) ||
00605 cg_elements_partial_read(cgfile, cgbase, cgzone, 2,
00606 rmin, rmax, ibuf, pbuf))
00607 cg_error_exit();
00608 if (np != nn) puts("diference in face data size");
00609 for (np = 0, i = 0; i < nn; i++) {
00610 if (ibuf[i] != faces[n+i]) np++;
00611 }
00612 if (np) printf("%d differences in face connectivity\n", np);
00613 for (np = 0, i = 0; i < nn; i++) {
00614 if (pbuf[i] != ptmp[i]) np++;
00615 }
00616 if (np) printf("%d differences in face parent data\n", np);
00617 }
00618
00619 for (k = 0; k < NUM_RANDOM; k++) {
00620 rmin = irandom(1, nnodes);
00621 rmax = irandom(1, nnodes);
00622 if (rmin > rmax) {
00623 n = rmin;
00624 rmin = rmax;
00625 rmax = n;
00626 }
00627 n = rmin - 1;
00628 nn = rmax - rmin + 1;
00629 printf("field %d -> %d\n", rmin, rmax);
00630 if (cg_field_read(cgfile, cgbase, cgzone, 1, "Field",
00631 RealSingle, &rmin, &rmax, fbuf))
00632 cg_error_exit();
00633 for (np = 0, i = 0; i < nn; i++) {
00634 if (fbuf[i] != xcoord[n+i]) np++;
00635 }
00636 if (np) printf("%d differences in field data\n", np);
00637 }
00638
00639 #endif
00640
00641 puts("deleting Elements and Faces and creating Mixed");
00642
00643
00644
00645 if (cg_goto(cgfile, cgbase, "Zone_t", 1, NULL) ||
00646 cg_delete_node("Elements") || cg_delete_node("Faces"))
00647 cg_error_exit();
00648
00649
00650
00651 nn = (nelems << 3) + nelems + (nfaces << 2) + nfaces;
00652 ptmp = (int *) malloc (2 * nn * sizeof(int));
00653
00654 i = j = n = 0;
00655 for (nf = 0; nf < nelems; nf++) {
00656 ptmp[n++] = QUAD_4;
00657 for (k = 0; k < 4; k++)
00658 ptmp[n++] = faces[j++];
00659 ptmp[n++] = HEXA_8;
00660 for (k = 0; k < 8; k++)
00661 ptmp[n++] = elements[i++];
00662 }
00663 while (nf++ < nfaces) {
00664 ptmp[n++] = QUAD_4;
00665 for (k = 0; k < 4; k++)
00666 ptmp[n++] = faces[j++];
00667 }
00668
00669 free (elements);
00670 elements = ptmp;
00671 ibuf = elements + nn;
00672
00673
00674
00675 np = nelems + nfaces;
00676 nn = np << 2;
00677 ptmp = (int *) malloc (3 * nn * sizeof(int));
00678
00679 for (n = 0; n < nfaces; n++)
00680 parent[n] <<= 1;
00681
00682 for (n = 0; n < nn; n++)
00683 ptmp[n] = 0;
00684 for (n = 0, j = 0; j < 4; j++) {
00685 k = j * np;
00686 for (i = 0; i < nelems; i++) {
00687 ptmp[k] = parent[n++];
00688 k += 2;
00689 }
00690 while (i++ < nfaces)
00691 ptmp[k++] = parent[n++];
00692 }
00693
00694 free(faces);
00695 parent = ptmp;
00696 ptmp = parent + nn;
00697 pbuf = ptmp + nn;
00698
00699 rmin = 2 * nelems + 1;
00700 rmax = np;
00701 n = mixed_offset(rmin, nelems);
00702 get_parent(rmin, rmax, 0, np);
00703
00704 printf("mixed %d -> %d\n", rmin, rmax);
00705 if (cg_section_partial_write(cgfile, cgbase, cgzone, "Mixed",
00706 MIXED, rmin, rmax, 0, &elements[n], &cgsect) ||
00707 cg_parent_data_partial_write(cgfile, cgbase, cgzone, cgsect,
00708 rmin, rmax, ptmp))
00709 cg_error_exit();
00710
00711 printf("mixed %d -> %d (2 at a time)\n", 1, nelems << 1);
00712 for (i = 0; i < nelems; i++) {
00713 rmin = (i << 1) + 1;
00714 rmax = rmin + 1;
00715 n = mixed_offset(rmin, nelems);
00716 get_parent(rmin, rmax, 0, np);
00717 if (cg_section_partial_write(cgfile, cgbase, cgzone, "Mixed",
00718 MIXED, rmin, rmax, 0, &elements[n], &cgsect) ||
00719 cg_parent_data_partial_write(cgfile, cgbase, cgzone, cgsect,
00720 rmin, rmax, ptmp))
00721 cg_error_exit();
00722 }
00723
00724 #if NUM_RANDOM > 0
00725
00726
00727
00728 puts("doing random writes");
00729
00730 for (k = 0; k < NUM_RANDOM; k++) {
00731 rmin = irandom(1, np);
00732 rmax = irandom(1, np);
00733 if (rmin > rmax) {
00734 n = rmin;
00735 rmin = rmax;
00736 rmax = n;
00737 }
00738 n = mixed_offset(rmin, nelems);
00739 get_parent(rmin, rmax, 0, np);
00740 printf("mixed %d -> %d\n", rmin, rmax);
00741 if (cg_section_partial_write(cgfile, cgbase, cgzone, "Mixed",
00742 MIXED, rmin, rmax, 0, &elements[n], &cgsect) ||
00743 cg_parent_data_partial_write(cgfile, cgbase, cgzone, cgsect,
00744 rmin, rmax, ptmp))
00745 cg_error_exit();
00746 }
00747
00748 #endif
00749
00750 puts("checking the data");
00751
00752 if (cg_section_read(cgfile, cgbase, cgzone, cgsect, name,
00753 &type, &i, &j, &k, &n) ||
00754 cg_elements_read(cgfile, cgbase, cgzone, cgsect, ibuf, pbuf))
00755 cg_error_exit();
00756 if (strcmp(name, "Mixed") || type != MIXED || i != 1 ||
00757 j != np || k != 0 || n != 1) {
00758 puts("differences in Mixed");
00759 }
00760 nn = mixed_offset(np, nelems);
00761 for (i = 0, n = 0; n < nn; n++) {
00762 if (elements[n] != ibuf[n]) i++;
00763 }
00764 if (i) printf("%d differences in Mixed connectivity\n", i);
00765
00766 nn = (nelems + nfaces) << 2;
00767 for (i = 0, n = 0; n < nn; n++) {
00768 if (parent[n] != pbuf[n]) i++;
00769 }
00770 if (i) printf("%d differences in Mixed parent data\n", i);
00771
00772 #if NUM_RANDOM > 0
00773
00774
00775
00776 puts("doing random reads/checks");
00777
00778 for (k = 0; k < NUM_RANDOM; k++) {
00779 rmin = irandom(1, np);
00780 rmax = irandom(1, np);
00781 if (rmin > rmax) {
00782 n = rmin;
00783 rmin = rmax;
00784 rmax = n;
00785 }
00786 n = mixed_offset(rmin, nelems);
00787 nn = mixed_offset(rmax + 1, nelems) - n;
00788 get_parent(rmin, rmax, 0, np);
00789 printf("mixed %d -> %d\n", rmin, rmax);
00790 if (cg_ElementPartialSize(cgfile, cgbase, cgzone, cgsect,
00791 rmin, rmax, &nf) ||
00792 cg_elements_partial_read(cgfile, cgbase, cgzone, cgsect,
00793 rmin, rmax, ibuf, pbuf))
00794 cg_error_exit();
00795 if (nf != nn) puts("diference in mixed data size");
00796 for (nf = 0, i = 0; i < nn; i++) {
00797 if (ibuf[i] != elements[n+i]) nf++;
00798 }
00799 if (nf) printf("%d differences in mixed connectivity\n", nf);
00800 nn = (rmax - rmin + 1) << 2;
00801 for (nf = 0, i = 0; i < nn; i++) {
00802 if (pbuf[i] != ptmp[i]) nf++;
00803 }
00804 if (nf) printf("%d differences in mixed parent data\n", nf);
00805 }
00806
00807 #endif
00808
00809 puts ("closing file");
00810 cg_close (cgfile);
00811
00812 return 0;
00813 }
00814