00001 #include <stdio.h>
00002 #include <stdlib.h>
00003 #include <string.h>
00004 #include <math.h>
00005 #ifndef _WIN32
00006 # include <unistd.h>
00007 #endif
00008 #include "cgnslib.h"
00009
00010 int CellDim = 3, PhyDim = 3;
00011 int cgfile, cgbase, cgzone, cggrid, cgsect, cgsol, cgfld;
00012
00013 int size[9] = {5, 5, 5, 4, 4, 4, 0, 0, 0};
00014 int rind[6] = {0, 0, 0, 0, 1, 1};
00015
00016 #define NUM_I (size[0] + rind[0] + rind[1])
00017 #define NUM_J (size[1] + rind[2] + rind[3])
00018 #define NUM_K (size[2] + rind[4] + rind[5])
00019
00020 #define INDEX(I,J,K) ((I) + NUM_I * ((J) + NUM_J * (K)))
00021
00022 int num_coord;
00023 float *xcoord, *ycoord, *zcoord;
00024 int *nmap;
00025
00026 int num_element, *elements;
00027
00028 float *solution;
00029
00030 static void compute_coord (n, i, j, k)
00031 {
00032 xcoord[n] = (float)(i - rind[0]);
00033 ycoord[n] = (float)(j - rind[2]);
00034 zcoord[n] = (float)(k - rind[4]);
00035 }
00036
00037 static void compute_element (ne, i, j, k)
00038 {
00039 int n = ne << 3;
00040
00041 elements[n++] = nmap[INDEX(i, j, k)];
00042 elements[n++] = nmap[INDEX(i+1, j, k)];
00043 elements[n++] = nmap[INDEX(i+1, j+1, k)];
00044 elements[n++] = nmap[INDEX(i, j+1, k)];
00045 elements[n++] = nmap[INDEX(i, j, k+1)];
00046 elements[n++] = nmap[INDEX(i+1, j, k+1)];
00047 elements[n++] = nmap[INDEX(i+1, j+1, k+1)];
00048 elements[n] = nmap[INDEX(i, j+1, k+1)];
00049 }
00050
00051 int main (int argc, char *argv[])
00052 {
00053 int n, nn, i, j, k, ni, nj, nk;
00054 int dims[3], grind[2], erind[2];
00055
00056 if (argc > 1) {
00057 n = 0;
00058 if (argv[1][n] == '-') n++;
00059 if (argv[1][n] == 'a' || argv[1][n] == 'A')
00060 nn = CG_FILE_ADF;
00061 else if (argv[1][n] == 'h' || argv[1][n] == 'H')
00062 nn = CG_FILE_HDF5;
00063 else if (argv[1][n] == 'x' || argv[1][n] == 'X')
00064 nn = CG_FILE_XML;
00065 else {
00066 fprintf(stderr, "unknown option\n");
00067 exit (1);
00068 }
00069 if (cg_set_file_type(nn))
00070 cg_error_exit();
00071 }
00072
00073 num_coord = NUM_I * NUM_J * NUM_K;
00074 num_element = (NUM_I - 1) * (NUM_J - 1) * (NUM_K - 1);
00075 xcoord = (float *) malloc(4 * num_coord * sizeof(float));
00076 nmap = (int *) malloc((num_coord + 8 * num_element) * sizeof(int));
00077 if (NULL == xcoord || NULL == nmap) {
00078 fprintf(stderr, "malloc failed for data\n");
00079 exit(1);
00080 }
00081 ycoord = xcoord + num_coord;
00082 zcoord = ycoord + num_coord;
00083 solution = zcoord + num_coord;
00084 elements = nmap + num_coord;
00085
00086 for (n = 0; n < num_coord; n++)
00087 solution[n] = (float)n;
00088
00089 unlink("rind.cgns");
00090 if (cg_open("rind.cgns", CG_MODE_WRITE, &cgfile))
00091 cg_error_exit();
00092
00093
00094
00095 printf ("writing structured base with rind\n");
00096 fflush (stdout);
00097
00098 for (n = 0, k = 0; k < NUM_K; k++) {
00099 for (j = 0; j < NUM_J; j++) {
00100 for (i = 0; i < NUM_I; i++) {
00101 compute_coord(n++, i, j, k);
00102 }
00103 }
00104 }
00105
00106 if (cg_base_write(cgfile, "Structured", CellDim, PhyDim, &cgbase) ||
00107 cg_goto(cgfile, cgbase, "end") ||
00108 cg_dataclass_write(NormalizedByUnknownDimensional) ||
00109 cg_zone_write(cgfile, cgbase, "Zone", size, Structured, &cgzone))
00110 cg_error_exit();
00111
00112
00113
00114
00115
00116 dims[0] = NUM_I;
00117 dims[1] = NUM_J;
00118 dims[2] = NUM_K;
00119
00120 if (cg_grid_write(cgfile, cgbase, cgzone, "GridCoordinates", &cggrid) ||
00121 cg_goto(cgfile, cgbase, "Zone_t", cgzone,
00122 "GridCoordinates_t", cggrid, "end") ||
00123 cg_rind_write(rind) ||
00124 cg_array_write("CoordinateX", RealSingle, 3, dims, xcoord) ||
00125 cg_array_write("CoordinateY", RealSingle, 3, dims, ycoord) ||
00126 cg_array_write("CoordinateZ", RealSingle, 3, dims, zcoord))
00127 cg_error_exit();
00128
00129
00130
00131
00132
00133 if (cg_sol_write(cgfile, cgbase, cgzone, "VertexSolution",
00134 Vertex, &cgsol) ||
00135 cg_goto(cgfile, cgbase, "Zone_t", cgzone,
00136 "FlowSolution_t", cgsol, "end") ||
00137 cg_rind_write(rind) ||
00138 cg_field_write(cgfile, cgbase, cgzone, cgsol, RealSingle,
00139 "Density", solution, &cgfld))
00140 cg_error_exit();
00141
00142
00143
00144 printf ("writing unstructured base with rind\n");
00145 fflush (stdout);
00146
00147
00148
00149
00150
00151
00152
00153 ni = size[0] + rind[0];
00154 nj = size[1] + rind[2];
00155 nk = size[2] + rind[4];
00156
00157 for (n = 0, i = 0; i < rind[0]; i++) {
00158 for (k = 0; k < NUM_K; k++) {
00159 for (j = 0; j < NUM_J; j++) {
00160 compute_coord (n, i, j, k);
00161 nn = INDEX(i, j, k);
00162 nmap[nn] = ++n;
00163 }
00164 }
00165 }
00166 for (j = 0; j < rind[2]; j++) {
00167 for (k = 0; k < NUM_K; k++) {
00168 for (i = rind[0]; i < ni; i++) {
00169 compute_coord (n, i, j, k);
00170 nn = INDEX(i, j, k);
00171 nmap[nn] = ++n;
00172 }
00173 }
00174 }
00175 for (k = 0; k < rind[4]; k++) {
00176 for (j = rind[2]; j < nj; j++) {
00177 for (i = rind[0]; i < ni; i++) {
00178 compute_coord (n, i, j, k);
00179 nn = INDEX(i, j, k);
00180 nmap[nn] = ++n;
00181 }
00182 }
00183 }
00184 grind[0] = n;
00185
00186 for (k = rind[4]; k < nk; k++) {
00187 for (j = rind[2]; j < nj; j++) {
00188 for (i = rind[0]; i < ni; i++) {
00189 compute_coord (n, i, j, k);
00190 nn = INDEX(i, j, k);
00191 nmap[nn] = ++n;
00192 }
00193 }
00194 }
00195 grind[1] = num_coord - n;
00196
00197 for (i = ni; i < NUM_I; i++) {
00198 for (k = 0; k < NUM_K; k++) {
00199 for (j = 0; j < NUM_J; j++) {
00200 compute_coord (n, i, j, k);
00201 nn = INDEX(i, j, k);
00202 nmap[nn] = ++n;
00203 }
00204 }
00205 }
00206 for (j = nj; j < NUM_J; j++) {
00207 for (k = 0; k < NUM_K; k++) {
00208 for (i = rind[0]; i < ni; i++) {
00209 compute_coord (n, i, j, k);
00210 nn = INDEX(i, j, k);
00211 nmap[nn] = ++n;
00212 }
00213 }
00214 }
00215 for (k = nk; k < NUM_K; k++) {
00216 for (j = rind[2]; j < nj; j++) {
00217 for (i = rind[0]; i < ni; i++) {
00218 compute_coord (n, i, j, k);
00219 nn = INDEX(i, j, k);
00220 nmap[nn] = ++n;
00221 }
00222 }
00223 }
00224
00225
00226
00227
00228
00229 for (n = 0, i = 0; i < rind[0]; i++) {
00230 for (k = 0; k < NUM_K - 1; k++) {
00231 for (j = 0; j < NUM_J - 1; j++) {
00232 compute_element(n++, i, j, k);
00233 }
00234 }
00235 }
00236 for (j = 0; j < rind[2]; j++) {
00237 for (k = 0; k < NUM_K - 1; k++) {
00238 for (i = rind[0]; i < ni - 1; i++) {
00239 compute_element(n++, i, j, k);
00240 }
00241 }
00242 }
00243 for (k = 0; k < rind[4]; k++) {
00244 for (j = rind[2]; j < nj - 1; j++) {
00245 for (i = rind[0]; i < ni - 1; i++) {
00246 compute_element(n++, i, j, k);
00247 }
00248 }
00249 }
00250 erind[0] = n;
00251
00252 for (k = rind[4]; k < nk - 1; k++) {
00253 for (j = rind[2]; j < nj - 1; j++) {
00254 for (i = rind[0]; i < ni - 1; i++) {
00255 compute_element(n++, i, j, k);
00256 }
00257 }
00258 }
00259 erind[1] = num_element - n;
00260
00261 for (i = ni - 1; i < NUM_I - 1; i++) {
00262 for (k = 0; k < NUM_K - 1; k++) {
00263 for (j = 0; j < NUM_J - 1; j++) {
00264 compute_element(n++, i, j, k);
00265 }
00266 }
00267 }
00268 for (j = nj - 1; j < NUM_J - 1; j++) {
00269 for (k = 0; k < NUM_K - 1; k++) {
00270 for (i = rind[0]; i < ni - 1; i++) {
00271 compute_element(n++, i, j, k);
00272 }
00273 }
00274 }
00275 for (k = nk - 1; k < NUM_K - 1; k++) {
00276 for (j = rind[2]; j < nj - 1; j++) {
00277 for (i = rind[0]; i < ni - 1; i++) {
00278 compute_element(n++, i, j, k);
00279 }
00280 }
00281 }
00282
00283
00284
00285
00286
00287 dims[0] = num_coord - grind[0] - grind[1];
00288 dims[1] = num_element - erind[0] - erind[1];
00289 dims[2] = 0;
00290
00291 if (cg_base_write(cgfile, "Unstructured", CellDim, PhyDim, &cgbase) ||
00292 cg_goto(cgfile, cgbase, "end") ||
00293 cg_dataclass_write(NormalizedByUnknownDimensional) ||
00294 cg_zone_write(cgfile, cgbase, "Zone", dims, Unstructured, &cgzone) ||
00295 cg_grid_write(cgfile, cgbase, cgzone, "GridCoordinates", &cggrid) ||
00296 cg_goto(cgfile, cgbase, "Zone_t", cgzone,
00297 "GridCoordinates_t", cggrid, "end") ||
00298 cg_rind_write(grind) ||
00299 cg_array_write("CoordinateX", RealSingle, 1, &num_coord, xcoord) ||
00300 cg_array_write("CoordinateY", RealSingle, 1, &num_coord, ycoord) ||
00301 cg_array_write("CoordinateZ", RealSingle, 1, &num_coord, zcoord))
00302 cg_error_exit();
00303
00304
00305
00306
00307 if (cg_section_write(cgfile, cgbase, cgzone, "Elements", HEXA_8,
00308 1, num_element, 0, elements, &cgsect) ||
00309 cg_goto(cgfile, cgbase, "Zone_t", cgzone,
00310 "Elements_t", cgsect, "end") ||
00311 cg_rind_write(erind))
00312 cg_error_exit();
00313
00314
00315
00316 if (cg_sol_write(cgfile, cgbase, cgzone, "VertexSolution",
00317 Vertex, &cgsol) ||
00318 cg_goto(cgfile, cgbase, "Zone_t", cgzone,
00319 "FlowSolution_t", cgsol, "end") ||
00320 cg_rind_write(grind) ||
00321 cg_field_write(cgfile, cgbase, cgzone, cgsol, RealSingle,
00322 "Density", solution, &cgfld))
00323 cg_error_exit();
00324
00325 cg_close(cgfile);
00326 return 0;
00327 }
00328