int main (int argc, char *argv[])
{
int j, n;
cgsize_t ne;
int fnum, bnum, znum, snum, cnum;
cgsize_t size[3];
float exp[5];
char *outfile = "elemtest.cgns";
unlink (outfile);
if (cg_open (outfile, CG_MODE_WRITE, &fnum) ||
cg_base_write (fnum, "Base", 3, 3, &bnum) ||
cg_goto(fnum, bnum, NULL) ||
cg_dataclass_write(CGNS_ENUMV(NormalizedByDimensional)))
cg_error_exit ();
for (n = 0; n < 5; n++)
exp[n] = (float)0.0;
exp[1] = (float)1.0;
/* zone with linear elements */
size[0] = 11;
size[1] = 12;
size[2] = 0;
if (cg_zone_write (fnum, bnum, "1:Linear", size,
CGNS_ENUMV(Unstructured), &znum) ||
cg_coord_write (fnum, bnum, znum, CGNS_ENUMV(RealDouble),
"CoordinateX", xc, &cnum) ||
cg_goto(fnum, bnum, "Zone_t", znum, "GridCoordinates", 0,
"CoordinateX", 0, NULL) ||
cg_exponents_write(CGNS_ENUMV(RealSingle), exp) ||
cg_coord_write (fnum, bnum, znum, CGNS_ENUMV(RealDouble),
"CoordinateY", yc, &cnum) ||
cg_gopath(fnum, "../CoordinateY") ||
cg_exponents_write(CGNS_ENUMV(RealSingle), exp) ||
cg_coord_write (fnum, bnum, znum, CGNS_ENUMV(RealDouble),
"CoordinateZ", zc, &cnum) ||
cg_gopath(fnum, "../CoordinateZ") ||
cg_exponents_write(CGNS_ENUMV(RealSingle), exp))
cg_error_exit ();
ne = j = 0;
/* NGON_n first so polyhedra face references are correct */
if (cg_section_write (fnum, bnum, znum, "NGON_n", CGNS_ENUMV(NGON_n),
ne+1, ne+npoly, 0, poly, &snum))
cg_error_exit();
ne += npoly;
/* NODE */
if (cg_section_write (fnum, bnum, znum, "NODE", CGNS_ENUMV(NODE),
ne+1, ne+1, 0, node, &snum))
cg_error_exit ();
ne++;
elems[j++] = (int)CGNS_ENUMV(NODE);
elems[j++] = node[0];
/* BAR_2 */
if (cg_section_write (fnum, bnum, znum, "BAR_2", CGNS_ENUMV(BAR_2),
ne+1, ne+1, 0, bar, &snum))
cg_error_exit ();
ne++;
elems[j++] = (int)CGNS_ENUMV(BAR_2);
for (n = 0; n < 2; n++)
elems[j++] = bar[n];
/* TRI_3 */
if (cg_section_write (fnum, bnum, znum, "TRI_3", CGNS_ENUMV(TRI_3),
ne+1, ne+1, 0, tri, &snum))
cg_error_exit ();
ne++;
elems[j++] = (int)CGNS_ENUMV(TRI_3);
for (n = 0; n < 3; n++)
elems[j++] = tri[n];
/* QUAD_4 */
if (cg_section_write (fnum, bnum, znum, "QUAD_4", CGNS_ENUMV(QUAD_4),
ne+1, ne+1, 0, quad9, &snum))
cg_error_exit ();
ne++;
elems[j++] = (int)CGNS_ENUMV(QUAD_4);
for (n = 0; n < 4; n++)
elems[j++] = quad9[n];
/* TETRA_4 */
if (cg_section_write (fnum, bnum, znum, "TETRA_4", CGNS_ENUMV(TETRA_4),
ne+1, ne+1, 0, tetra, &snum))
cg_error_exit ();
ne++;
elems[j++] = (int)CGNS_ENUMV(TETRA_4);
for (n = 0; n < 4; n++)
elems[j++] = tetra[n];
/* PYRA_5 */
if (cg_section_write (fnum, bnum, znum, "PYRA_5", CGNS_ENUMV(PYRA_5),
ne+1, ne+1, 0, pyra, &snum))
cg_error_exit ();
ne++;
elems[j++] = (int)CGNS_ENUMV(PYRA_5);
for (n = 0; n < 5; n++)
elems[j++] = pyra[n];
/* PENTA_6 */
if (cg_section_write (fnum, bnum, znum, "PENTA_6", CGNS_ENUMV(PENTA_6),
ne+1, ne+1, 0, penta, &snum))
cg_error_exit ();
ne++;
elems[j++] = (int)CGNS_ENUMV(PENTA_6);
for (n = 0; n < 6; n++)
elems[j++] = penta[n];
/* HEXA_8 */
if (cg_section_write (fnum, bnum, znum, "HEXA_8", CGNS_ENUMV(HEXA_8),
ne+1, ne+1, 0, hexa, &snum))
cg_error_exit ();
ne++;
elems[j++] = (int)CGNS_ENUMV(HEXA_8);
for (n = 0; n < 8; n++)
elems[j++] = hexa[n];
/* MIXED */
if (cg_section_write (fnum, bnum, znum, "MIXED", CGNS_ENUMV(MIXED),
ne+1, ne+8, 0, elems, &snum))
cg_error_exit ();
ne += 8;
/* NFACE_n */
if (cg_section_write (fnum, bnum, znum, "NFACE_n", CGNS_ENUMV(NFACE_n),
ne+1, ne+nface, 0, face, &snum))
cg_error_exit ();
/* zone with quadratic elements */
size[0] = 42;
size[1] = 8;
size[2] = 0;
if (cg_zone_write (fnum, bnum, "2:Quadratic", size,
CGNS_ENUMV(Unstructured), &znum) ||
cg_coord_write (fnum, bnum, znum, CGNS_ENUMV(RealDouble),
"CoordinateX", xc, &cnum) ||
cg_goto(fnum, bnum, "Zone_t", znum, "GridCoordinates", 0,
"CoordinateX", 0, NULL) ||
cg_exponents_write(CGNS_ENUMV(RealSingle), exp) ||
cg_coord_write (fnum, bnum, znum, CGNS_ENUMV(RealDouble),
"CoordinateY", yc, &cnum) ||
cg_gopath(fnum, "../CoordinateY") ||
cg_exponents_write(CGNS_ENUMV(RealSingle), exp) ||
cg_coord_write (fnum, bnum, znum, CGNS_ENUMV(RealDouble),
"CoordinateZ", zc, &cnum) ||
cg_gopath(fnum, "../CoordinateZ") ||
cg_exponents_write(CGNS_ENUMV(RealSingle), exp))
cg_error_exit ();
ne = j = 0;
/* BAR_3 */
if (cg_section_write (fnum, bnum, znum, "BAR_3", CGNS_ENUMV(BAR_3),
ne+1, ne+1, 0, bar, &snum))
cg_error_exit ();
ne++;
elems[j++] = (int)CGNS_ENUMV(BAR_3);
for (n = 0; n < 3; n++)
elems[j++] = bar[n];
/* TRI_6 */
if (cg_section_write (fnum, bnum, znum, "TRI_6", CGNS_ENUMV(TRI_6),
ne+1, ne+1, 0, tri, &snum))
cg_error_exit ();
ne++;
elems[j++] = (int)CGNS_ENUMV(TRI_6);
for (n = 0; n < 6; n++)
elems[j++] = tri[n];
/* QUAD_8 */
if (cg_section_write (fnum, bnum, znum, "QUAD_8", CGNS_ENUMV(QUAD_8),
ne+1, ne+1, 0, quad9, &snum))
cg_error_exit ();
ne++;
elems[j++] = (int)CGNS_ENUMV(QUAD_8);
for (n = 0; n < 8; n++)
elems[j++] = quad9[n];
/* TETRA_10 */
if (cg_section_write (fnum, bnum, znum, "TETRA_10", CGNS_ENUMV(TETRA_10),
ne+1, ne+1, 0, tetra, &snum))
cg_error_exit ();
ne++;
elems[j++] = (int)CGNS_ENUMV(TETRA_10);
for (n = 0; n < 10; n++)
elems[j++] = tetra[n];
/* PYRA_13 */
if (cg_section_write (fnum, bnum, znum, "PYRA_13", CGNS_ENUMV(PYRA_13),
ne+1, ne+1, 0, pyra, &snum))
cg_error_exit ();
ne++;
elems[j++] = (int)CGNS_ENUMV(PYRA_13);
for (n = 0; n < 13; n++)
elems[j++] = pyra[n];
/* PENTA_15 */
if (cg_section_write (fnum, bnum, znum, "PENTA_15", CGNS_ENUMV(PENTA_15),
ne+1, ne+1, 0, penta, &snum))
cg_error_exit ();
ne++;
elems[j++] = (int)CGNS_ENUMV(PENTA_15);
for (n = 0; n < 15; n++)
elems[j++] = penta[n];
/* HEXA_20 */
if (cg_section_write (fnum, bnum, znum, "HEXA_20", CGNS_ENUMV(HEXA_20),
ne+1, ne+1, 0, hexa, &snum))
cg_error_exit ();
ne++;
elems[j++] = (int)CGNS_ENUMV(HEXA_20);
for (n = 0; n < 20; n++)
elems[j++] = hexa[n];
/* MIXED */
if (cg_section_write (fnum, bnum, znum, "MIXED", CGNS_ENUMV(MIXED),
ne+1, ne+7, 0, elems, &snum))
cg_error_exit ();
ne += 7;
/* zone with quadratic elements with mid-nodes */
size[0] = 42;
size[1] = 8;
size[2] = 0;
if (cg_zone_write (fnum, bnum, "3:Quadratic with mid-nodes", size,
CGNS_ENUMV(Unstructured), &znum) ||
cg_coord_write (fnum, bnum, znum, CGNS_ENUMV(RealDouble),
"CoordinateX", xc, &cnum) ||
cg_goto(fnum, bnum, "Zone_t", znum, "GridCoordinates", 0,
"CoordinateX", 0, NULL) ||
cg_exponents_write(CGNS_ENUMV(RealSingle), exp) ||
cg_coord_write (fnum, bnum, znum, CGNS_ENUMV(RealDouble),
"CoordinateY", yc, &cnum) ||
cg_gopath(fnum, "../CoordinateY") ||
cg_exponents_write(CGNS_ENUMV(RealSingle), exp) ||
cg_coord_write (fnum, bnum, znum, CGNS_ENUMV(RealDouble),
"CoordinateZ", zc, &cnum) ||
cg_gopath(fnum, "../CoordinateZ") ||
cg_exponents_write(CGNS_ENUMV(RealSingle), exp))
cg_error_exit ();
ne = j = 0;
/* QUAD_9 */
if (cg_section_write (fnum, bnum, znum, "QUAD_9", CGNS_ENUMV(QUAD_9),
ne+1, ne+1, 0, quad9, &snum))
cg_error_exit ();
ne++;
elems[j++] = (int)CGNS_ENUMV(QUAD_9);
for (n = 0; n < 9; n++)
elems[j++] = quad9[n];
/* TETRA_10 */
if (cg_section_write (fnum, bnum, znum, "TETRA_10", CGNS_ENUMV(TETRA_10),
ne+1, ne+1, 0, tetra, &snum))
cg_error_exit ();
ne++;
elems[j++] = (int)CGNS_ENUMV(TETRA_10);
for (n = 0; n < 10; n++)
elems[j++] = tetra[n];
/* PYRA_14 */
if (cg_section_write (fnum, bnum, znum, "PYRA_14", CGNS_ENUMV(PYRA_14),
ne+1, ne+1, 0, pyra, &snum))
cg_error_exit ();
ne++;
elems[j++] = (int)CGNS_ENUMV(PYRA_14);
for (n = 0; n < 14; n++)
elems[j++] = pyra[n];
/* PENTA_18 */
if (cg_section_write (fnum, bnum, znum, "PENTA_18", CGNS_ENUMV(PENTA_18),
ne+1, ne+1, 0, penta, &snum))
cg_error_exit ();
ne++;
elems[j++] = (int)CGNS_ENUMV(PENTA_18);
for (n = 0; n < 18; n++)
elems[j++] = penta[n];
/* HEXA_27 */
if (cg_section_write (fnum, bnum, znum, "HEXA_27", CGNS_ENUMV(HEXA_27),
ne+1, ne+1, 0, hexa, &snum))
cg_error_exit ();
ne++;
elems[j++] = (int)CGNS_ENUMV(HEXA_27);
for (n = 0; n < 27; n++)
elems[j++] = hexa[n];
/* MIXED */
if (cg_section_write (fnum, bnum, znum, "MIXED", CGNS_ENUMV(MIXED),
ne+1, ne+5, 0, elems, &snum))
cg_error_exit ();
ne += 5;
/* zone with cubic elements */
size[0] = 55;
size[1] = 8;
size[2] = 0;
if (cg_zone_write (fnum, bnum, "4:Cubic", size,
CGNS_ENUMV(Unstructured), &znum) ||
cg_coord_write (fnum, bnum, znum, CGNS_ENUMV(RealDouble),
"CoordinateX", x3, &cnum) ||
cg_goto(fnum, bnum, "Zone_t", znum, "GridCoordinates", 0,
"CoordinateX", 0, NULL) ||
cg_exponents_write(CGNS_ENUMV(RealSingle), exp) ||
cg_coord_write (fnum, bnum, znum, CGNS_ENUMV(RealDouble),
"CoordinateY", y3, &cnum) ||
cg_gopath(fnum, "../CoordinateY") ||
cg_exponents_write(CGNS_ENUMV(RealSingle), exp) ||
cg_coord_write (fnum, bnum, znum, CGNS_ENUMV(RealDouble),
"CoordinateZ", zc, &cnum) ||
cg_gopath(fnum, "../CoordinateZ") ||
cg_exponents_write(CGNS_ENUMV(RealSingle), exp))
cg_error_exit ();
ne = j = 0;
/* BAR_4 */
if (cg_section_write (fnum, bnum, znum, "BAR_4", CGNS_ENUMV(BAR_4),
ne+1, ne+1, 0, bar4, &snum))
cg_error_exit ();
ne++;
elems[j++] = (int)CGNS_ENUMV(BAR_4);
for (n = 0; n < 4; n++)
elems[j++] = bar4[n];
/* TRI_9 */
if (cg_section_write (fnum, bnum, znum, "TRI_9", CGNS_ENUMV(TRI_9),
ne+1, ne+1, 0, tri9, &snum))
cg_error_exit ();
ne++;
elems[j++] = (int)CGNS_ENUMV(TRI_9);
for (n = 0; n < 9; n++)
elems[j++] = tri9[n];
/* QUAD_12 */
if (cg_section_write (fnum, bnum, znum, "QUAD_12", CGNS_ENUMV(QUAD_12),
ne+1, ne+1, 0, quad12, &snum))
cg_error_exit ();
ne++;
elems[j++] = (int)CGNS_ENUMV(QUAD_12);
for (n = 0; n < 12; n++)
elems[j++] = quad12[n];
/* TETRA_16 */
if (cg_section_write (fnum, bnum, znum, "TETRA_16", CGNS_ENUMV(TETRA_16),
ne+1, ne+1, 0, tetra16, &snum))
cg_error_exit ();
ne++;
elems[j++] = (int)CGNS_ENUMV(TETRA_16);
for (n = 0; n < 16; n++)
elems[j++] = tetra16[n];
/* PYRA_21 */
if (cg_section_write (fnum, bnum, znum, "PYRA_21", CGNS_ENUMV(PYRA_21),
ne+1, ne+1, 0, pyra21, &snum))
cg_error_exit ();
ne++;
elems[j++] = (int)CGNS_ENUMV(PYRA_21);
for (n = 0; n < 21; n++)
elems[j++] = pyra21[n];
/* PENTA_24 */
if (cg_section_write (fnum, bnum, znum, "PENTA_24", CGNS_ENUMV(PENTA_24),
ne+1, ne+1, 0, penta24, &snum))
cg_error_exit ();
ne++;
elems[j++] = (int)CGNS_ENUMV(PENTA_24);
for (n = 0; n < 24; n++)
elems[j++] = penta24[n];
/* HEXA_32 */
if (cg_section_write (fnum, bnum, znum, "HEXA_32", CGNS_ENUMV(HEXA_32),
ne+1, ne+1, 0, hexa32, &snum))
cg_error_exit ();
ne++;
elems[j++] = (int)CGNS_ENUMV(HEXA_32);
for (n = 0; n < 32; n++)
elems[j++] = hexa32[n];
/* MIXED */
if (cg_section_write (fnum, bnum, znum, "MIXED", CGNS_ENUMV(MIXED),
ne+1, ne+7, 0, elems, &snum))
cg_error_exit ();
ne += 7;
if (cg_close (fnum)) cg_error_exit ();
return 0;
}
int main (int argc, char **argv)
{
int n, nz, nzones = 50;
double start, finish;
char name[33], linkpath[33];
char fname[33], linkfile[33];
for (n = 0; n < 3; n++) {
size[n] = NUM_SIDE;
size[n+3] = NUM_SIDE - 1;
size[n+6] = 0;
}
if (argc > 1)
nzones = atoi (argv[1]);
printf ("number of zones = %d\n", nzones);
for (nz = 1; nz <= nzones; nz++) {
sprintf (fname, "zone%d.cgns", nz);
unlink (fname);
}
printf ("creating zones ...");
fflush (stdout);
start = elapsed_time ();
for (nz = 1; nz <= nzones; nz++) {
sprintf (fname, "zone%d.cgns", nz);
if (cg_open (fname, CG_MODE_WRITE, &cgfile) ||
cg_base_write (cgfile, "Base", 3, 3, &cgbase) ||
cg_zone_write (cgfile, cgbase, "Zone", size, Structured,
&cgzone) ||
cg_coord_write(cgfile, cgbase, cgzone, RealSingle,
"CoordinateX", coord, &cgcoord) ||
cg_coord_write(cgfile, cgbase, cgzone, RealSingle,
"CoordinateY", coord, &cgcoord) ||
cg_coord_write(cgfile, cgbase, cgzone, RealSingle,
"CoordinateZ", coord, &cgcoord))
cg_error_exit();
if (cg_close(cgfile)) cg_error_exit();
}
finish = elapsed_time ();
printf (" %g secs\n", finish - start);
strcpy (fname, "links.cgns");
unlink (fname);
strcpy (linkpath, "/Base/Zone");
printf ("creating link file ...");
fflush (stdout);
start = elapsed_time ();
if (cg_open (fname, CG_MODE_WRITE, &cgfile) ||
cg_base_write (cgfile, "Base", 3, 3, &cgbase))
cg_error_exit();
for (nz = 1; nz <= nzones; nz++) {
sprintf (name, "Zone%d", nz);
sprintf (linkfile, "zone%d.cgns", nz);
if (cg_goto (cgfile, cgbase, "end") ||
cg_link_write (name, linkfile, linkpath))
cg_error_exit();
}
cg_close (cgfile);
finish = elapsed_time ();
printf (" %g secs\n", finish - start);
printf ("file size = %g Mb\n", file_size(fname));
printf ("opening link file ...");
fflush (stdout);
start = elapsed_time ();
if (cg_open (fname, CG_MODE_READ, &cgfile)) cg_error_exit();
finish = elapsed_time ();
printf (" %g secs\n", finish - start);
cg_close (cgfile);
#if 0
printf ("opening link file ...");
fflush (stdout);
start = elapsed_time ();
if (cg_open (fname, CG_MODE_READ, &cgfile)) cg_error_exit();
finish = elapsed_time ();
printf (" %g secs\n", finish - start);
cg_close (cgfile);
#endif
return 0;
}
int main (int argc, char **argv)
{
int n, i, j, k, nuser, dim = 1;
int cgfile, cgbase, cgzone, cgcoord, cgdset;
int size[9];
int ptlist[3] = {1, 2, 3};
int ptrange[6] = {1, 1, 1, 2, 2, 2};
int bcpoints[6], bcfaces[6];
static char *fname = "gotest.cgns";
char name[33];
float data1 = 1;
float data2 = 2;
float exponents[8], rate[3], center[3];
GridLocation_t gridloc;
int ordinal, ndata, cgfam, cgbc, nunits, nexps;
int elecflag, magnflag, condflag, dirichlet, neumann;
PointSetType_t pttype;
DataClass_t dclass;
DataType_t dtype;
BCType_t bctype;
MassUnits_t mass;
LengthUnits_t length;
TimeUnits_t time;
TemperatureUnits_t temp;
AngleUnits_t angle;
ElectricCurrentUnits_t current;
SubstanceAmountUnits_t amount;
LuminousIntensityUnits_t intensity;
ModelType_t elecmodel;
ModelType_t magnmodel;
ModelType_t emconduct;
/* errors and warnings go to error_exit */
cg_configure(CG_CONFIG_ERROR, (void *)error_exit);
for (n = 0; n < 8; n++)
exponents[n] = (float)n;
for (n = 0; n < 3; n++) {
rate[n] = (float)n;
center[n] = (float)n;
}
for (n = 0; n < NUM_SIDE*NUM_SIDE*NUM_SIDE; n++)
coord[n] = (float)n;
unlink (fname);
printf ("creating CGNS file %s\n", fname);
cg_open (fname, CG_MODE_WRITE, &cgfile);
cg_base_write (cgfile, "Base", 3, 3, &cgbase);
/* write electomagnetics model under base */
puts ("writing electromagnetics");
cg_goto(cgfile, cgbase, NULL);
cg_equationset_write (3);
cg_goto(cgfile, cgbase, "FlowEquationSet_t", 1, NULL);
cg_model_write("EMElectricFieldModel_t", Voltage);
cg_model_write("EMMagneticFieldModel_t", Interpolated);
cg_model_write("EMConductivityModel_t", Equilibrium_LinRessler);
/* write rotating coordinates under family_t */
puts ("writing family/rotating");
cg_family_write(cgfile, cgbase, "Family", &cgfam);
/* go to a named node */
cg_goto(cgfile, cgbase, "Family", 0, NULL);
cg_rotating_write (rate, center);
/* write BCDataSet under FamilyBC_t */
puts("writing FamilyBCDataSet");
cg_fambc_write(cgfile, cgbase, cgfam, "FamilyBC", BCWall, &cgbc);
/* relative go to */
cg_gorel(cgfile, "FamilyBC_t", cgbc, NULL);
cg_bcdataset_write ("FamilyBCDataSet", BCWallInviscid, Dirichlet);
/* write user data under base */
puts("writing user defined data under base");
/* relative path */
cg_gopath (cgfile, "../..");
cg_user_data_write ("User");
/* absolute path */
cg_gopath (cgfile, "/Base/User");
cg_gridlocation_write (CellCenter);
cg_famname_write ("Family");
cg_ordinal_write (0);
cg_array_write ("Data1", RealSingle, 1, &dim, &data1);
cg_array_write ("Data2", RealSingle, 1, &dim, &data2);
for (n = 1; n <= 2; n++) {
cg_goto (cgfile, cgbase, "User", 0, "DataArray_t", n, "end");
cg_dataclass_write (Dimensional);
cg_units_write (Kilogram, Meter, Second, Kelvin, Radian);
cg_exponents_write (RealSingle, exponents);
}
/* this should fail since ptset not allowed as child of
user data, except below a zone_t node */
cg_configure(CG_CONFIG_ERROR, NULL);
if (cg_ptset_write (PointList, 1, ptlist) == CG_OK)
printf ("WHAT!! - ptset should not work under base/userdata\n");
cg_configure(CG_CONFIG_ERROR, (void *)error_exit);
/* write zone */
puts("writing zone");
for (n = 0; n < 3; n++) {
size[n] = NUM_SIDE;
size[n+3] = NUM_SIDE - 1;
size[n+6] = 0;
}
cg_zone_write (cgfile, cgbase, "Zone", size, Structured, &cgzone);
cg_coord_write(cgfile, cgbase, cgzone, RealSingle,
"CoordinateX", coord, &cgcoord);
cg_coord_write(cgfile, cgbase, cgzone, RealSingle,
"CoordinateY", coord, &cgcoord);
cg_coord_write(cgfile, cgbase, cgzone, RealSingle,
"CoordinateZ", coord, &cgcoord);
/* create a BC node with point range and Dirichlet node*/
puts("writing Dirichlet BC with vertex range");
for (n = 0; n < 3; n++) {
bcpoints[n] = 1;
bcpoints[n+3] = NUM_SIDE;
bcfaces[n] = 1;
bcfaces[n+3] = NUM_SIDE - 1;
}
bcpoints[5] = bcfaces[5] = 1;
cg_boco_write (cgfile, cgbase, cgzone, "BC", BCWall,
PointList, 1, bcpoints, &cgbc);
cg_dataset_write (cgfile, cgbase, cgzone, cgbc,
"DataSet", BCWallViscous, &cgdset);
cg_bcdata_write (cgbase, cgfile, cgzone, cgbc, cgdset, Dirichlet);
/* create Dirichlet data at faces */
puts("writing Dirichlet data at faces");
cg_gopath (cgfile, "/Base/Zone/ZoneBC/BC/DataSet");
cg_gridlocation_write (KFaceCenter);
cg_ptset_write (PointRange, 2, bcfaces);
size[0] = (NUM_SIDE - 1) * (NUM_SIDE - 1);
cg_gorel (cgfile, "BCData_t", Dirichlet, NULL);
cg_array_write ("Data", RealSingle, 1, size, coord);
/* write recursive user data */
puts("writing recursive user defined data under zone");
cg_goto(cgfile, cgbase, "Zone", 0, NULL);
for (i = 1; i <= 4; i++) {
sprintf (name, "User%d", i);
cg_user_data_write (name);
cg_gorel(cgfile, name, 0, NULL);
cg_gridlocation_write (CellCenter);
cg_famname_write ("Family");
cg_ordinal_write (i);
cg_ptset_write (PointList, 1, ptlist);
cg_array_write ("Data1", RealSingle, 1, &dim, &data1);
cg_array_write ("Data2", RealSingle, 1, &dim, &data2);
for (n = 1; n <= 2; n++) {
cg_gorel (cgfile, "DataArray_t", n, "end");
cg_dataclass_write (Dimensional);
cg_unitsfull_write (Kilogram, Meter, Second, Kelvin, Radian,
Ampere, Mole, Candela);
cg_expfull_write (RealSingle, exponents);
cg_gopath (cgfile, "..");
}
for (j = 1; j <= 3; j++) {
sprintf (name, "User%d.%d", i, j);
cg_user_data_write (name);
cg_gopath (cgfile, name);
cg_gridlocation_write (Vertex);
cg_famname_write ("Family");
cg_ordinal_write (i + j);
cg_ptset_write (PointRange, 2, ptrange);
cg_array_write ("Data1", RealSingle, 1, &dim, &data1);
cg_array_write ("Data2", RealSingle, 1, &dim, &data2);
for (n = 1; n <= 2; n++) {
cg_gorel (cgfile, "DataArray_t", n, "end");
cg_dataclass_write (Dimensional);
cg_unitsfull_write (Kilogram, Meter, Second, Kelvin,
Radian, Ampere, Mole, Candela);
cg_expfull_write (RealSingle, exponents);
cg_gorel (cgfile, "..", 0, NULL);
}
for (k = 1; k <= 2; k++) {
sprintf (name, "User%d.%d.%d", i, j, k);
cg_user_data_write (name);
cg_gorel (cgfile, name, 0, NULL);
cg_array_write ("Data1", RealSingle, 1, &dim, &data1);
cg_array_write ("Data2", RealSingle, 1, &dim, &data2);
for (n = 1; n <= 2; n++) {
cg_gorel (cgfile, "DataArray_t", n, "end");
cg_dataclass_write (Dimensional);
cg_unitsfull_write (Kilogram, Meter, Second, Kelvin,
Radian, Ampere, Mole, Candela);
cg_expfull_write (RealSingle, exponents);
cg_gopath (cgfile, "..");
}
for (n = 1; n <= 2; n++) {
sprintf (name, "User%d.%d.%d.%d", i, j, k, n);
cg_user_data_write (name);
cg_gopath (cgfile, name);
cg_array_write ("Data1", RealSingle, 1, &dim, &data1);
cg_array_write ("Data2", RealSingle, 1, &dim, &data2);
cg_gopath (cgfile, "..");
}
cg_gopath (cgfile, "..");
}
cg_gopath (cgfile, "..");
}
cg_gopath (cgfile, "..");
}
puts ("closing and reopening in read mode");
cg_close (cgfile);
/* read file and check values */
cg_configure(CG_CONFIG_ERROR, NULL);
if (cg_open (fname, CG_MODE_READ, &cgfile))
cg_error_exit ();
cgbase = cgzone = 1;
/* check electomagnetics model under base */
puts ("checking electromagnetics");
if (cg_goto(cgfile, cgbase, NULL) ||
cg_equationset_elecmagn_read(&elecflag, &magnflag, &condflag) ||
cg_goto(cgfile, cgbase, "FlowEquationSet_t", 1, NULL) ||
cg_model_read ("EMElectricFieldModel_t", &elecmodel) ||
cg_model_read ("EMMagneticFieldModel_t", &magnmodel) ||
cg_model_read ("EMConductivityModel_t", &emconduct))
cg_error_exit();
CHECK ("ElectricFieldFlag", elecflag == 1);
CHECK ("ElectricFieldModel", elecmodel == Voltage);
CHECK ("MagneticFieldFlag", magnflag == 1);
CHECK ("MagneticFieldModel", magnmodel == Interpolated);
CHECK ("EMConductivityFlag", condflag == 1);
CHECK ("EMConductivityModel", emconduct == Equilibrium_LinRessler);
/* check rotating coordinates under family_t */
puts ("checking family/rotating");
if (cg_goto(cgfile, cgbase, "Family_t", 1, NULL) ||
cg_rotating_read (rate, center))
cg_error_exit();
for (n = 0; n < 3; n++) {
CHECK ("rotation rate", rate[n] == (float)n);
CHECK ("rotation center", center[n] == (float)n);
}
/* check BCDataSet under FamilyBC_t */
puts("checking FamilyBCDataSet");
*name = 0;
if (cg_goto(cgfile, cgbase, "Family_t", 1, "FamilyBC_t", 1, NULL) ||
cg_bcdataset_info(&ndata) ||
cg_bcdataset_read (1, name, &bctype, &dirichlet, &neumann))
cg_error_exit();
CHECK("bcdataset_info", ndata == 1);
CHECK("bcdatset name", strcmp(name, "FamilyBCDataSet") == 0);
CHECK("bcdatset type", bctype == BCWallInviscid);
CHECK("bcdatset dirichlet", dirichlet == 1);
CHECK("bcdatset neumann", neumann == 0);
/* check BC data */
puts("checking BC data");
if (cg_boco_info (cgfile, cgbase, cgzone, 1, name, &bctype, &pttype,
&n, size, &i, &dtype, &ndata))
cg_error_exit();
CHECK("BC_t name", strcmp(name, "BC") == 0);
CHECK("BC_t type", bctype == BCWall);
CHECK("BC_t pntset type", pttype == PointList);
CHECK("BC_t npnts", n == 1);
if (cg_dataset_read (cgfile, cgbase, cgzone, 1, 1, name,
&bctype, &dirichlet, &neumann) ||
cg_goto (cgfile, cgbase, "Zone_t", 1, "ZoneBC_t", 1, "BC_t", 1,
"BCDataSet_t", 1, NULL) ||
cg_gridlocation_read (&gridloc) ||
cg_ptset_info (&pttype, &n))
cg_error_exit();
CHECK("BCDataSet_t name", strcmp(name, "DataSet") == 0);
CHECK("BCDataSet_t type", bctype == BCWallViscous);
CHECK("BCDataSet_t location", gridloc == KFaceCenter);
CHECK("BCDataSet_t pntset type", pttype == PointRange);
CHECK("BC_t npnts", n == 2);
CHECK("BCDataSet_t dirichlet", dirichlet == 1);
CHECK("BCDataSet_t neumann", neumann == 0);
/* check user defined data */
puts("checking user defined data");
*name = 0;
if (cg_goto (cgfile, cgbase, "UserDefinedData_t", 1, "end") ||
cg_gridlocation_read (&gridloc) ||
cg_famname_read (name) ||
cg_ordinal_read (&ordinal) ||
cg_narrays (&ndata))
cg_error_exit ();
CHECK ("gridlocation", gridloc == CellCenter);
CHECK ("famname", strcmp (name, "Family") == 0);
CHECK ("ordinal", ordinal == 0);
CHECK ("narrays", ndata == 2);
if (cg_goto (cgfile, cgbase, "Zone_t", cgzone, "end") ||
cg_nuser_data (&nuser))
cg_error_exit ();
CHECK ("nuserdata", nuser == 4);
for (i = 1; i <= 4; i++) {
*name = 0;
if (cg_goto (cgfile, cgbase, "Zone_t", cgzone,
"UserDefinedData_t", i, "end") ||
cg_gridlocation_read (&gridloc) ||
cg_famname_read (name) ||
cg_ordinal_read (&ordinal) ||
cg_ptset_info (&pttype, &n) ||
cg_ptset_read (ptlist) ||
cg_narrays (&ndata) ||
cg_nuser_data (&nuser))
cg_error_exit ();
CHECK ("gridlocation", gridloc == CellCenter);
CHECK ("famname", strcmp (name, "Family") == 0);
CHECK ("ordinal", ordinal == i);
CHECK ("pointtype", pttype == PointList);
CHECK ("npoints", n == 1);
CHECK ("narrays", ndata == 2);
CHECK ("nuserdata", nuser == 3);
for (j = 1; j <= 3; j++) {
*name = 0;
if (cg_goto (cgfile, cgbase, "Zone_t", cgzone,
"UserDefinedData_t", i,
"UserDefinedData_t", j, "end") ||
cg_gridlocation_read (&gridloc) ||
cg_famname_read (name) ||
cg_ordinal_read (&ordinal) ||
cg_ptset_info (&pttype, &n) ||
cg_ptset_read (ptlist) ||
cg_narrays (&ndata) ||
cg_nuser_data (&nuser))
cg_error_exit ();
CHECK ("gridlocation", gridloc == Vertex);
CHECK ("famname", strcmp (name, "Family") == 0);
CHECK ("ordinal", ordinal == (i + j));
CHECK ("pointtype", pttype == PointRange);
CHECK ("npoints", n == 2);
CHECK ("narrays", ndata == 2);
CHECK ("nuserdata", nuser == 2);
for (n = 1; n <= 2; n++) {
if (cg_goto (cgfile, cgbase, "Zone_t", cgzone,
"UserDefinedData_t", i,
"UserDefinedData_t", j,
"DataArray_t", n, "end") ||
cg_dataclass_read (&dclass) ||
cg_nunits (&nunits) ||
cg_unitsfull_read (&mass, &length, &time, &temp, &angle,
¤t, &amount, &intensity) ||
cg_nexponents (&nexps) ||
cg_expfull_read (exponents))
cg_error_exit ();
CHECK ("dataclass", dclass == Dimensional);
CHECK ("nunits", nunits == 8);
CHECK ("massunits", mass == Kilogram);
CHECK ("lengthunits", length == Meter);
CHECK ("timeunits", time == Second);
CHECK ("tempunits", temp == Kelvin);
CHECK ("angleunits", angle == Radian);
CHECK ("currentunits", current == Ampere);
CHECK ("amountunits", amount == Mole);
CHECK ("intensityunits", intensity == Candela);
CHECK ("nexponents", nexps == 8);
for (n = 0; n < 8; n++)
CHECK ("exponents", exponents[n] == (float)n);
}
}
}
if (cg_goto (cgfile, cgbase, "Zone_t", cgzone,
"UserDefinedData_t", 2, "UserDefinedData_t", 2,
"UserDefinedData_t", 2, "UserDefinedData_t", 1, "end") ||
cg_narrays (&ndata) ||
cg_nuser_data (&nuser) ||
cg_array_info (2, name, &dtype, &n, &dim) ||
cg_array_read (1, &data1) ||
cg_array_read (2, &data2))
cg_error_exit ();
CHECK ("narrays", ndata == 2);
CHECK ("nuserdata", nuser == 0);
CHECK ("arrayname", strcmp (name, "Data2") == 0);
CHECK ("datatype", dtype == RealSingle);
CHECK ("ndims", n == 1);
CHECK ("dims", dim == 1);
CHECK ("data1", data1 == 1.0);
CHECK ("data2", data2 == 2.0);
/* read partial units/exponents as full */
puts("checking units and exponents");
if (cg_goto(cgfile, cgbase, "UserDefinedData_t", 1,
"DataArray_t", 1, NULL) ||
cg_nunits (&nunits) ||
cg_unitsfull_read (&mass, &length, &time, &temp, &angle,
¤t, &amount, &intensity) ||
cg_nexponents (&nexps) ||
cg_expfull_read (exponents))
cg_error_exit ();
CHECK ("nunits", nunits == 5);
CHECK ("massunits", mass == Kilogram);
CHECK ("lengthunits", length == Meter);
CHECK ("timeunits", time == Second);
CHECK ("tempunits", temp == Kelvin);
CHECK ("angleunits", angle == Radian);
CHECK ("currentunits", current == 0);
CHECK ("amountunits", amount == 0);
CHECK ("intensityunits", intensity == 0);
CHECK ("nexponents", nexps == 5);
for (n = 0; n < 5; n++)
CHECK ("exponents", exponents[n] == (float)n);
for (n = 6; n < 8; n++)
CHECK ("exponents", exponents[n] == (float)0.0);
/* read full units/exponents as partial */
if (cg_goto(cgfile, cgbase, "Zone_t", 1, "UserDefinedData_t", 1,
"DataArray_t", 1, NULL) ||
cg_nunits (&nunits) ||
cg_units_read (&mass, &length, &time, &temp, &angle) ||
cg_nexponents (&nexps) ||
cg_exponents_read (exponents))
cg_error_exit ();
CHECK ("nunits", nunits == 8);
CHECK ("massunits", mass == Kilogram);
CHECK ("lengthunits", length == Meter);
CHECK ("timeunits", time == Second);
CHECK ("tempunits", temp == Kelvin);
CHECK ("angleunits", angle == Radian);
CHECK ("nexponents", nexps == 8);
for (n = 0; n < 5; n++)
CHECK ("exponents", exponents[n] == (float)n);
puts ("closing file and reopening in modify mode");
cg_close (cgfile);
/* delete userdata node */
if (cg_open (fname, CG_MODE_MODIFY, &cgfile))
cg_error_exit ();
puts ("deleting user defined data and checking");
if (cg_goto (cgfile, 1, "Zone_t", 1,
"UserDefinedData_t", 3,
"UserDefinedData_t", 2,
"UserDefinedData_t", 1, "end") ||
cg_nuser_data (&nuser))
cg_error_exit ();
CHECK ("nuserdata", nuser == 2);
if (cg_delete_node ("User3.2.1.1") ||
cg_nuser_data (&nuser))
cg_error_exit ();
CHECK ("nuserdata", nuser == 1);
/* don't compress file on close */
cg_configure(CG_CONFIG_COMPRESS, (void *)0);
puts ("closing file");
cg_close (cgfile);
return 0;
}
void COutput::SetCGNS_Coordinates(CConfig *config, CGeometry *geometry, unsigned short iZone) {
#ifdef HAVE_CGNS
/*--- local CGNS variables ---*/
int cgns_file, cgns_coord, element_dims, physical_dims, cgns_err;
unsigned long iExtIter = config->GetExtIter();
string base_file, buffer, elements_name;
stringstream name, results_file;
bool unsteady = config->GetUnsteady_Simulation();
cgsize_t isize[3][1];
/*--- Create CGNS base file name ---*/
base_file = config->GetFlow_FileName();
/*--- Add CGNS extension. ---*/
base_file = base_file.append(".cgns");
/*--- Create CGNS results file name ---*/
if (unsteady) {
buffer = config->GetFlow_FileName();
results_file.str(string()); results_file << buffer;
if (((int)iExtIter >= 0) && ((int)iExtIter < 10)) results_file << "_0000" << iExtIter;
if (((int)iExtIter >= 10) && ((int)iExtIter < 100)) results_file << "_000" << iExtIter;
if (((int)iExtIter >= 100) && ((int)iExtIter < 1000)) results_file << "_00" << iExtIter;
if (((int)iExtIter >= 1000) && ((int)iExtIter < 10000)) results_file << "_0" << iExtIter;
if ((int)iExtIter >= 10000) results_file << iExtIter;
results_file << ".cgns";
}
/*--- Write base file if not already done ---*/
if (!wrote_base_file) {
/*--- Write base file ---*/
cgns_err = cg_open((char *)base_file.c_str(), CG_MODE_MODIFY, &cgns_file);
if (cgns_err) cg_error_print();
element_dims = geometry->GetnDim(); // Currently (release 2.0) only all-2D or all-3D zones permitted
physical_dims = element_dims;
isize[0][0] = (cgsize_t)nGlobal_Poin; // vertex size
isize[1][0] = (cgsize_t)nGlobal_Elem; // cell size
isize[2][0] = 0; // boundary vertex size (zero if elements not sorted)
cgns_err = cg_goto(cgns_file, cgns_base,"Zone_t", cgns_zone,"end");
if (cgns_err) cg_error_print();
//
// cgns_err = cg_goto(cgns_file, cgns_base, cgns_zone,"end");
// if (cgns_err) cg_error_print();
/*--- write CGNS node coordinates ---*/
cgns_err = cg_coord_write(cgns_file, cgns_base, cgns_zone, RealDouble,"x", Coords[0], &cgns_coord);
if (cgns_err) cg_error_print();
cgns_err = cg_coord_write(cgns_file, cgns_base, cgns_zone, RealDouble,"y", Coords[1], &cgns_coord);
if (cgns_err) cg_error_print();
if (geometry->GetnDim() == 3) {
cgns_err = cg_coord_write(cgns_file, cgns_base, cgns_zone, RealDouble,"z", Coords[2], &cgns_coord);
if (cgns_err) cg_error_print();
}
cgns_err = cg_close(cgns_file);
if (cgns_err) cg_error_print();
wrote_base_file = true;
}
/*--- Set up results file for this time step if necessary ---*/
if (unsteady) {
cgns_err = cg_open((char *)results_file.str().c_str(), CG_MODE_WRITE, &cgns_file);
element_dims = geometry->GetnDim(); // Currently only all-2D or all-3D zones permitted
physical_dims = element_dims;
/*--- write CGNS base data (one base assumed currently) ---*/
cgns_err = cg_base_write(cgns_file,"SU2 Base", element_dims, physical_dims, &cgns_base_results);
if (cgns_err) cg_error_print();
isize[0][0] = (cgsize_t)geometry->GetGlobal_nPointDomain(); // vertex size
isize[1][0] = (cgsize_t)nGlobal_Elem; // cell size
isize[2][0] = 0; // boundary vertex size (zero if elements not sorted)
/*--- write CGNS zone data ---*/
cgns_err = cg_zone_write(cgns_file, cgns_base_results,"SU2 Zone", isize[0],Unstructured, &cgns_zone_results);
if (cgns_err) cg_error_print();
cgns_err = cg_goto(cgns_file, cgns_base_results,"Zone_t", cgns_zone_results,"end");
if (cgns_err) cg_error_print();
/*--- Write CGNS node coordinates, if appliciable ---*/
if (config->GetGrid_Movement()) {
/*--- write CGNS node coordinates ---*/
cgns_err = cg_coord_write(cgns_file, cgns_base_results, cgns_zone_results, RealDouble,"x", Coords[0], &cgns_coord);
if (cgns_err) cg_error_print();
cgns_err = cg_coord_write(cgns_file, cgns_base_results, cgns_zone_results, RealDouble,"y", Coords[1], &cgns_coord);
if (cgns_err) cg_error_print();
if (geometry->GetnDim() == 3) {
cgns_err = cg_coord_write(cgns_file, cgns_base_results, cgns_zone_results, RealDouble,"z", Coords[2], &cgns_coord);
if (cgns_err) cg_error_print();
}
}
else {
/*--- Write a CGNS link for the node coordinates ---*/
cgns_err = cg_link_write("GridCoordinates",(char *)base_file.c_str(),"/SU2 Base/SU2 Zone/GridCoordinates");
if (cgns_err) cg_error_print();
}
/*--- Write a CGNS link for each element type connectivity ---*/
if (nGlobal_Tria > 0) cgns_err = cg_link_write("Triangle Elements",(char *)base_file.c_str(),"/SU2 Base/SU2 Zone/Triangle Elements");
if (nGlobal_Quad > 0) cgns_err = cg_link_write("Quadrilateral Elements",(char *)base_file.c_str(),"/SU2 Base/SU2 Zone/Quadrilateral Elements");
if (nGlobal_Tetr > 0) cgns_err = cg_link_write("Tetrahedral Elements",(char *)base_file.c_str(),"/SU2 Base/SU2 Zone/Tetrahedral Elements");
if (nGlobal_Hexa > 0) cgns_err = cg_link_write("Hexahedral Elements",(char *)base_file.c_str(),"/SU2 Base/SU2 Zone/Hexahedral Elements");
if (nGlobal_Pyra > 0) cgns_err = cg_link_write("Pyramid Elements",(char *)base_file.c_str(),"/SU2 Base/SU2 Zone/Pyramid Elements");
if (nGlobal_Pris > 0) cgns_err = cg_link_write("Prism Elements",(char *)base_file.c_str(),"/SU2 Base/SU2 Zone/Prism Elements");
if (nGlobal_Line > 0) cgns_err = cg_link_write("Line Elements",(char *)base_file.c_str(),"/SU2 Base/SU2 Zone/Line Elements");
if (cgns_err) cg_error_print();
/*--- Close CGNS file ---*/
cgns_err = cg_close(cgns_file);
if (cgns_err) cg_error_print();
}
#else // Not built with CGNS support
cout << "CGNS file requested but SU2 was built without CGNS support. No file written" << "\n";
#endif
}
/* override compute function */
int writeToCgns::compute(const char *) {
//declarations
//----------------------------------------------------------------------------
char port[256];
int nElem;
int nConn;
int nCoords;
int index_file;
int ier;
//input ports and casts
const coDistributedObject* obj;
const coDoUnstructuredGrid* inGrid;
const coDoIntArr* inInletElementNodes;
const coDoIntArr* inOutletElementNodes;
const coDoIntArr* inShroudElementNodes;
const coDoIntArr* inShroudExtElementNodes;
const coDoIntArr* inFrictlessElementNodes;
const coDoIntArr* inPsbladeElementNodes;
const coDoIntArr* inSsbladeElementNodes;
const coDoIntArr* inWallElementNodes;
const coDoIntArr* inSsleperiodicElementNodes;
const coDoIntArr* inPsleperiodicElementNodes;
const coDoIntArr* inSsteperiodicElementNodes;
const coDoIntArr* inPsteperiodicElementNodes;
const coDoIntArr* inRrinletElementNodes;
const coDoIntArr* inRroutletElementNodes;
const coDoIntArr* inHubAllElementNodes;
const coDoIntArr* inShroudAllElementNodes;
const coDoSet* inBoundaryElementFaces;
//grid attributes
int* tList;
int* elem;
int* conn;
cgsize_t* intHelper;
float* xCoord;
float* yCoord;
float* zCoord;
int nPoly;
int nCorn;
int* corn;
int* poly;
int ii;
int base_i;
int baseCFX_i;
int zone_i;
int zoneCFX_i;
int coord_i;
int section_i;
int tmpCounter;
int gElemCounter;
int boco_i;
cgsize_t* ptrToCgsize;
cgsize_t cgsize[3][3];
int nNodesFace;
int nElemInlet;
int nElemOutlet;
int nElemWall;
int nElemFrictless;
int nElemShroud;
int nElemShroudExt;
int nElemPsblade;
int nElemSsblade;
int nElemSsleperiodic;
int nElemPsleperiodic;
int nElemSsteperiodic;
int nElemPsteperiodic;
int nElemRrinlet;
int nElemRroutlet;
int nElemHubAll;
int nElemShroudAll;
int nNodesInlet;
int nNodesOutlet;
int nNodesWall;
int nNodesFrictless;
int nNodesShroud;
int nNodesShroudExt;
int nNodesPsblade;
int nNodesSsblade;
int nNodesSsleperiodic;
int nNodesPsleperiodic;
int nNodesSsteperiodic;
int nNodesPsteperiodic;
int nNodesRrinlet;
int nNodesRroutlet;
int nNodesHubAll;
int nNodesShroudAll;
int nNodesFaceInlet;
int nNodesFaceOutlet;
int nNodesFaceWall;
int nNodesFaceFrictless;
int nNodesFaceShroud;
int nNodesFaceShroudExt;
int nNodesFacePsblade;
int nNodesFaceSsblade;
int nNodesFaceSsleperiodic;
int nNodesFacePsleperiodic;
int nNodesFaceSsteperiodic;
int nNodesFacePsteperiodic;
int nNodesFaceRrinlet;
int nNodesFaceRroutlet;
int nNodesFaceHubAll;
int nNodesFaceShroudAll;
int nObjects;
const coDistributedObject *const *objSet;
//----------------------------------------------------------------------------
// initialize
//----------------------------------------------------------------------------
gElemCounter = 0;
//----------------------------------------------------------------------------
//get input port and do some type checks
//----------------------------------------------------------------------------
//check ports and cast to expected types
//grid
obj = p_inputPort_grid->getCurrentObject();
if (!obj) {
sendError("did not receive object at port %s", p_inputPort_grid->getName());
return FAILURE;
}
else {
inGrid = dynamic_cast<const coDoUnstructuredGrid *>(obj);
//check that cast was successful
if (!inGrid){
sendError("received wrong object type at port %s", p_inputPort_grid->getName());
return FAILURE;
}
}
//boundary element faces
obj = p_inputPort_boundaryElementFaces->getCurrentObject();
if (!obj) {
sendInfo("did not receive object at port %s", p_inputPort_boundaryElementFaces->getName());
}
else {
inBoundaryElementFaces = dynamic_cast<const coDoSet *>(obj);
objSet = inBoundaryElementFaces->getAllElements(&nObjects);
inInletElementNodes = dynamic_cast<const coDoIntArr *>(objSet[0]);
inOutletElementNodes = dynamic_cast<const coDoIntArr *>(objSet[1]);
inShroudElementNodes = dynamic_cast<const coDoIntArr *>(objSet[2]);
inShroudExtElementNodes = dynamic_cast<const coDoIntArr *>(objSet[3]);
inFrictlessElementNodes = dynamic_cast<const coDoIntArr *>(objSet[4]);
inPsbladeElementNodes = dynamic_cast<const coDoIntArr *>(objSet[5]);
inSsbladeElementNodes = dynamic_cast<const coDoIntArr *>(objSet[6]);
inWallElementNodes = dynamic_cast<const coDoIntArr *>(objSet[7]);
inSsleperiodicElementNodes = dynamic_cast<const coDoIntArr *>(objSet[8]);
inPsleperiodicElementNodes = dynamic_cast<const coDoIntArr *>(objSet[9]);
inSsteperiodicElementNodes = dynamic_cast<const coDoIntArr *>(objSet[10]);
inPsteperiodicElementNodes = dynamic_cast<const coDoIntArr *>(objSet[11]);
inRrinletElementNodes = dynamic_cast<const coDoIntArr *>(objSet[12]);
inRroutletElementNodes = dynamic_cast<const coDoIntArr *>(objSet[13]);
inHubAllElementNodes = dynamic_cast<const coDoIntArr *>(objSet[14]);
inShroudAllElementNodes = dynamic_cast<const coDoIntArr *>(objSet[15]);
nNodesInlet = inInletElementNodes->getDimension(1);
nNodesOutlet = inOutletElementNodes->getDimension(1);
nNodesWall = inWallElementNodes->getDimension(1);
nNodesFrictless = inFrictlessElementNodes->getDimension(1);
nNodesShroud = inShroudElementNodes->getDimension(1);
nNodesShroudExt = inShroudExtElementNodes->getDimension(1);
nNodesPsblade = inPsbladeElementNodes->getDimension(1);
nNodesSsblade = inSsbladeElementNodes->getDimension(1);
nNodesSsleperiodic = inSsleperiodicElementNodes->getDimension(1);
nNodesPsleperiodic = inPsleperiodicElementNodes->getDimension(1);
nNodesSsteperiodic = inSsteperiodicElementNodes->getDimension(1);
nNodesPsteperiodic = inPsteperiodicElementNodes->getDimension(1);
nNodesRrinlet = inRrinletElementNodes->getDimension(1);
nNodesRroutlet = inRroutletElementNodes->getDimension(1);
nNodesHubAll = inHubAllElementNodes->getDimension(1);
nNodesShroudAll = inShroudAllElementNodes->getDimension(1);
elem = inInletElementNodes->getAddress();
nNodesFaceInlet = *elem;
elem = inOutletElementNodes->getAddress();
nNodesFaceOutlet = *elem;
elem = inWallElementNodes->getAddress();
nNodesFaceWall = *elem;
elem = inFrictlessElementNodes->getAddress();
nNodesFaceFrictless = *elem;
elem = inShroudElementNodes->getAddress();
nNodesFaceShroud = *elem;
elem = inShroudExtElementNodes->getAddress();
nNodesFaceShroudExt = *elem;
elem = inPsbladeElementNodes->getAddress();
nNodesFacePsblade = *elem;
elem = inSsbladeElementNodes->getAddress();
nNodesFaceSsblade = *elem;
elem = inSsleperiodicElementNodes->getAddress();
nNodesFaceSsleperiodic = *elem;
elem = inPsleperiodicElementNodes->getAddress();
nNodesFacePsleperiodic = *elem;
elem = inSsteperiodicElementNodes->getAddress();
nNodesFaceSsteperiodic = *elem;
elem = inPsteperiodicElementNodes->getAddress();
nNodesFacePsteperiodic = *elem;
elem = inRrinletElementNodes->getAddress();
nNodesFaceRrinlet = *elem;
elem = inRroutletElementNodes->getAddress();
nNodesFaceRroutlet = *elem;
elem = inHubAllElementNodes->getAddress();
nNodesFaceHubAll = *elem;
elem = inShroudAllElementNodes->getAddress();
nNodesFaceShroudAll = *elem;
nElemInlet = nNodesInlet/nNodesFaceInlet;
nElemOutlet = nNodesOutlet/nNodesFaceOutlet;
nElemShroud = nNodesShroud/nNodesFaceShroud;
nElemShroudExt = nNodesShroudExt/nNodesFaceShroudExt;
nElemFrictless = nNodesFrictless/nNodesFaceFrictless;
nElemPsblade = nNodesPsblade/nNodesFacePsblade;
nElemSsblade = nNodesSsblade/nNodesFaceSsblade;
nElemWall = nNodesWall/nNodesFaceWall;
nElemSsleperiodic = nNodesSsleperiodic/nNodesFaceSsleperiodic;
nElemPsleperiodic = nNodesPsleperiodic/nNodesFacePsleperiodic;
nElemSsteperiodic = nNodesSsteperiodic/nNodesFaceSsteperiodic;
nElemPsteperiodic = nNodesPsteperiodic/nNodesFacePsteperiodic;
nElemRrinlet = nNodesRrinlet/nNodesFaceRrinlet;
nElemRroutlet = nNodesRroutlet/nNodesFaceRroutlet;
nElemHubAll = nNodesHubAll/nNodesFaceHubAll;
nElemShroudAll = nNodesShroudAll/nNodesFaceShroudAll;
//check that cast was successful
if (!inBoundaryElementFaces){
sendError("received wrong object type at port %s", p_inputPort_boundaryElementFaces->getName());
return FAILURE;
}
}
/* -------------------------------------------------------------------------*/
/* inGrid --> unstructured grid */
/* */
/* start to write inGrid into cgns file */
/* -------------------------------------------------------------------------*/
//write out short info about mesh
inGrid->getGridSize(&nElem, &nConn, &nCoords);
sendInfo("nElements = %i", nElem);
sendInfo("nConnectivities = %i", nConn);
sendInfo("nCoordinates = %i", nCoords);
//get addresses and type list
inGrid->getAddresses(&elem, &conn, &xCoord, &yCoord, &zCoord);
if (inGrid->hasTypeList()) {
inGrid->getTypeList(&tList);
}
/* debug output ///////////////////////////////////////////////////////////// */
// //write out type list
// if (inGrid->hasTypeList()){
// inGrid->getTypeList(&tList);
// for (ii=0;ii<nElem;ii++){
// cout << "tList[" << ii << "]" << "=(" << *(tList+ii) << endl;
// }
// }
// //write out elements
// for (ii=0;ii<nElem;ii++){
// cout << "elem[" << ii << "]" << "=(" << *(elem+ii) << endl;
// }
//write out coordinates
// for (ii=0;ii<nCoords;ii++){
// cout << "coord[" << ii << "]" << "=(" << *(xCoord+ii) << "," << *(yCoord+ii) << "," << *(zCoord+ii) << ")" << endl;
// }
// //write out conectivities
// for (ii=0;ii<nConn;ii++){
// cout << "conn[" << ii << "]" << "=(" << *(conn+ii) << endl;
// }
/* ////////////////////////////////////////////////////////////////////////// */
//write cgns file
//----------------------------------------------------------------------------
//open cgns file**************************************************************
ier = cg_open(cgns_filebrowser->getValue(), CG_MODE_WRITE, &index_file);
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
cout << "cgns file opened ..." << endl;
//
// base
//
//write base******************************************************************
ier = cg_base_write(index_file, "base", 3, 3, &base_i);
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
cout << "base written ..." << endl;
// write zones****************************************************************
cgsize[0][0] = nCoords;
cgsize[0][1] = nElem;
cgsize[0][2] = 0;
ptrToCgsize = &cgsize[0][0];
ier = cg_zone_write(index_file, base_i, "runner", ptrToCgsize, CGNS_ENUMV(Unstructured), &zone_i);
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
cout << "runner written ..." << endl;
// write grid coordinates*****************************************************
ier = cg_coord_write(index_file, base_i, zone_i, CGNS_ENUMV(RealSingle), "CoordinateX", xCoord, &coord_i);
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
cout << "coordinate x written ..." << endl;
ier = cg_coord_write(index_file, base_i, zone_i, CGNS_ENUMV(RealSingle), "CoordinateY", yCoord, &coord_i);
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
cout << "coordinate y written ..." << endl;
ier = cg_coord_write(index_file, base_i, zone_i, CGNS_ENUMV(RealSingle), "CoordinateZ", zCoord, &coord_i);
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
cout << "coordinate z written ..." << endl;
//write connectivities for 8-node-hexa grid***********************************
intHelper = new cgsize_t[nConn];
for (ii=0;ii<nConn;ii++){
*(intHelper+ii) = *(conn+ii);
*(intHelper+ii) = *(intHelper+ii)+1;
}
ier = cg_section_write(index_file, base_i, zone_i, "Elem", CGNS_ENUMV(HEXA_8), \
gElemCounter+1, nElem, 0, intHelper, §ion_i);
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
gElemCounter = gElemCounter + nElem;
delete intHelper;
cout << "Elem written ..." << endl;
//write inlet*****************************************************************
elem = inInletElementNodes->getAddress();
//increment nodes
elem = elem+1;
intHelper = new cgsize_t[nNodesInlet];
for (ii=0;ii<nNodesInlet;ii++){
*(intHelper+ii) = *(elem+ii);
*(intHelper+ii) = *(intHelper+ii)+1;
}
ier = cg_section_write(index_file, base_i, zone_i, "inlet", CGNS_ENUMV(QUAD_4), \
gElemCounter+1, gElemCounter+nElemInlet, 0, intHelper, \
§ion_i);
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
delete intHelper;
gElemCounter = gElemCounter + nElemInlet;
cout << "inlet written ... " << endl;
//write outlet****************************************************************
elem = inOutletElementNodes->getAddress();
//increment nodes
elem = elem+1;
intHelper = new cgsize_t[nNodesOutlet];
for (ii=0;ii<nNodesOutlet;ii++){
*(intHelper+ii) = *(elem+ii);
*(intHelper+ii) = *(intHelper+ii)+1;
}
ier = cg_section_write(index_file, base_i, zone_i, "outlet", CGNS_ENUMV(QUAD_4), \
gElemCounter+1, gElemCounter+nElemOutlet, 0, intHelper, \
§ion_i);
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
delete intHelper;
gElemCounter = gElemCounter + nElemOutlet;
cout << "outlet written ... " << endl;
//write wall******************************************************************
elem = inWallElementNodes->getAddress();
//increment nodes
elem = elem+1;
intHelper = new cgsize_t[nNodesWall];
for (ii=0;ii<nNodesWall;ii++){
*(intHelper+ii) = *(elem+ii);
*(intHelper+ii) = *(intHelper+ii)+1;
}
ier = cg_section_write(index_file, base_i, zone_i, "wall", CGNS_ENUMV(QUAD_4), \
gElemCounter+1, gElemCounter+nElemWall, 0, intHelper, \
§ion_i);
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
delete intHelper;
gElemCounter = gElemCounter + nElemWall;
cout << "wall written ... " << endl;
//write frictless*************************************************************
elem = inFrictlessElementNodes->getAddress();
//increment nodes
elem = elem+1;
intHelper = new cgsize_t[nNodesFrictless];
for (ii=0;ii<nNodesFrictless;ii++){
*(intHelper+ii) = *(elem+ii);
*(intHelper+ii) = *(intHelper+ii)+1;
}
ier = cg_section_write(index_file, base_i, zone_i, "frictless", CGNS_ENUMV(QUAD_4), \
gElemCounter+1, gElemCounter+nElemFrictless, 0, intHelper, \
§ion_i);
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
delete intHelper;
gElemCounter = gElemCounter + nElemFrictless;
cout << "frictless written ... " << endl;
//write shroud****************************************************************
elem = inShroudElementNodes->getAddress();
//increment nodes
elem = elem+1;
intHelper = new cgsize_t[nNodesShroud];
for (ii=0;ii<nNodesShroud;ii++){
*(intHelper+ii) = *(elem+ii);
*(intHelper+ii) = *(intHelper+ii)+1;
}
ier = cg_section_write(index_file, base_i, zone_i, "shroud", CGNS_ENUMV(QUAD_4), \
gElemCounter+1, gElemCounter+nElemShroud, 0, intHelper, \
§ion_i);
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
delete intHelper;
gElemCounter = gElemCounter + nElemShroud;
cout << "shroud written ... " << endl;
//write shroudExt*************************************************************
elem = inShroudExtElementNodes->getAddress();
//increment nodes
elem = elem+1;
intHelper = new cgsize_t[nNodesShroudExt];
for (ii=0;ii<nNodesShroudExt;ii++){
*(intHelper+ii) = *(elem+ii);
*(intHelper+ii) = *(intHelper+ii)+1;
}
ier = cg_section_write(index_file, base_i, zone_i, "shroudExt", CGNS_ENUMV(QUAD_4), \
gElemCounter+1, gElemCounter+nElemShroudExt, 0, intHelper, \
§ion_i);
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
delete intHelper;
gElemCounter = gElemCounter + nElemShroudExt;
cout << "shroudExt written ... " << endl;
//write psblade***************************************************************
elem = inPsbladeElementNodes->getAddress();
//increment nodes
elem = elem+1;
intHelper = new cgsize_t[nNodesPsblade];
for (ii=0;ii<nNodesPsblade;ii++){
*(intHelper+ii) = *(elem+ii);
*(intHelper+ii) = *(intHelper+ii)+1;
}
ier = cg_section_write(index_file, base_i, zone_i, "psblade", CGNS_ENUMV(QUAD_4), \
gElemCounter+1, gElemCounter+nElemPsblade, 0, intHelper, \
§ion_i);
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
delete intHelper;
gElemCounter = gElemCounter + nElemPsblade;
cout << "psblade written ... " << endl;
//write ssblade***************************************************************
elem = inSsbladeElementNodes->getAddress();
//increment nodes
elem = elem+1;
intHelper = new cgsize_t[nNodesSsblade];
for (ii=0;ii<nNodesSsblade;ii++){
*(intHelper+ii) = *(elem+ii);
*(intHelper+ii) = *(intHelper+ii)+1;
}
ier = cg_section_write(index_file, base_i, zone_i, "ssblade", CGNS_ENUMV(QUAD_4), \
gElemCounter+1, gElemCounter+nElemSsblade, 0, intHelper, \
§ion_i);
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
delete intHelper;
gElemCounter = gElemCounter + nElemSsblade;
cout << "ssblade written ... " << endl;
//write ssleperiodic**********************************************************
elem = inSsleperiodicElementNodes->getAddress();
//increment nodes
elem = elem+1;
intHelper = new cgsize_t[nNodesSsleperiodic];
for (ii=0;ii<nNodesSsleperiodic;ii++){
*(intHelper+ii) = *(elem+ii);
*(intHelper+ii) = *(intHelper+ii)+1;
}
ier = cg_section_write(index_file, base_i, zone_i, "ssleperiodic", CGNS_ENUMV(QUAD_4), \
gElemCounter+1, gElemCounter+nElemSsleperiodic, 0, intHelper, \
§ion_i);
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
delete intHelper;
gElemCounter = gElemCounter + nElemSsleperiodic;
cout << "ssleperiodic written ... " << endl;
//write psleperiodic**********************************************************
elem = inPsleperiodicElementNodes->getAddress();
//increment nodes
elem = elem+1;
intHelper = new cgsize_t[nNodesPsleperiodic];
for (ii=0;ii<nNodesPsleperiodic;ii++){
*(intHelper+ii) = *(elem+ii);
*(intHelper+ii) = *(intHelper+ii)+1;
}
ier = cg_section_write(index_file, base_i, zone_i, "psleperiodic", CGNS_ENUMV(QUAD_4), \
gElemCounter+1, gElemCounter+nElemPsleperiodic, 0, intHelper, \
§ion_i);
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
delete intHelper;
gElemCounter = gElemCounter + nElemPsleperiodic;
cout << "psleperiodic written ... " << endl;
//write ssteperiodic**********************************************************
elem = inSsteperiodicElementNodes->getAddress();
//increment nodes
elem = elem+1;
intHelper = new cgsize_t[nNodesSsteperiodic];
for (ii=0;ii<nNodesSsteperiodic;ii++){
*(intHelper+ii) = *(elem+ii);
*(intHelper+ii) = *(intHelper+ii)+1;
}
ier = cg_section_write(index_file, base_i, zone_i, "ssteperiodic", CGNS_ENUMV(QUAD_4), \
gElemCounter+1, gElemCounter+nElemSsteperiodic, 0, intHelper, \
§ion_i);
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
delete intHelper;
gElemCounter = gElemCounter + nElemSsteperiodic;
cout << "ssteperiodic written ... " << endl;
//write psteperiodic**********************************************************
elem = inPsteperiodicElementNodes->getAddress();
//increment nodes
elem = elem+1;
intHelper = new cgsize_t[nNodesPsteperiodic];
for (ii=0;ii<nNodesPsteperiodic;ii++){
*(intHelper+ii) = *(elem+ii);
*(intHelper+ii) = *(intHelper+ii)+1;
}
ier = cg_section_write(index_file, base_i, zone_i, "psteperiodic", CGNS_ENUMV(QUAD_4), \
gElemCounter+1, gElemCounter+nElemPsteperiodic, 0, intHelper, \
§ion_i);
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
delete intHelper;
gElemCounter = gElemCounter + nElemPsteperiodic;
cout << "psteperiodic written ... " << endl;
//write rrinlet***************************************************************
elem = inRrinletElementNodes->getAddress();
//increment nodes
elem = elem+1;
intHelper = new cgsize_t[nNodesRrinlet];
for (ii=0;ii<nNodesRrinlet;ii++){
*(intHelper+ii) = *(elem+ii);
*(intHelper+ii) = *(intHelper+ii)+1;
}
ier = cg_section_write(index_file, base_i, zone_i, "rrinlet", CGNS_ENUMV(QUAD_4), \
gElemCounter+1, gElemCounter+nElemRrinlet, 0, intHelper, \
§ion_i);
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
delete intHelper;
gElemCounter = gElemCounter + nElemRrinlet;
cout << "rrinlet written ... " << endl;
//write rroutlet**************************************************************
elem = inRroutletElementNodes->getAddress();
//increment nodes
elem = elem+1;
intHelper = new cgsize_t[nNodesRroutlet];
for (ii=0;ii<nNodesRroutlet;ii++){
*(intHelper+ii) = *(elem+ii);
*(intHelper+ii) = *(intHelper+ii)+1;
}
ier = cg_section_write(index_file, base_i, zone_i, "rroutlet", CGNS_ENUMV(QUAD_4), \
gElemCounter+1, gElemCounter+nElemRroutlet, 0, intHelper, \
§ion_i);
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
delete intHelper;
gElemCounter = gElemCounter + nElemRroutlet;
cout << "rroutlet written ... " << endl;
//write hubAll****************************************************************
elem = inHubAllElementNodes->getAddress();
//increment nodes
elem = elem+1;
intHelper = new cgsize_t[nNodesHubAll];
for (ii=0;ii<nNodesHubAll;ii++){
*(intHelper+ii) = *(elem+ii);
*(intHelper+ii) = *(intHelper+ii)+1;
}
ier = cg_section_write(index_file, base_i, zone_i, "hubAll", CGNS_ENUMV(QUAD_4), \
gElemCounter+1, gElemCounter+nElemHubAll, 0, intHelper, \
§ion_i);
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
delete intHelper;
gElemCounter = gElemCounter + nElemHubAll;
cout << "hubAll written ... " << endl;
//write shroudAll*************************************************************
elem = inShroudAllElementNodes->getAddress();
//increment nodes
elem = elem+1;
intHelper = new cgsize_t[nNodesShroudAll];
for (ii=0;ii<nNodesShroudAll;ii++){
*(intHelper+ii) = *(elem+ii);
*(intHelper+ii) = *(intHelper+ii)+1;
}
ier = cg_section_write(index_file, base_i, zone_i, "shroudAll", CGNS_ENUMV(QUAD_4), \
gElemCounter+1, gElemCounter+nElemShroudAll, 0, intHelper, \
§ion_i);
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
delete intHelper;
gElemCounter = gElemCounter + nElemShroudAll;
cout << "shroudAll written ... " << endl;
//write periodic suction******************************************************
elem = inSsleperiodicElementNodes->getAddress();
//increment nodes
elem = elem+1;
intHelper = new cgsize_t[nNodesSsleperiodic+nNodesSsteperiodic];
tmpCounter = 0;
for (ii=0;ii<nNodesSsleperiodic;ii++){
*(intHelper+tmpCounter) = *(elem+ii);
*(intHelper+tmpCounter) = *(intHelper+tmpCounter)+1;
tmpCounter = tmpCounter + 1;
}
elem = inSsteperiodicElementNodes->getAddress();
//increment nodes
elem = elem+1;
for (ii=0;ii<nNodesSsteperiodic;ii++){
*(intHelper+tmpCounter) = *(elem+ii);
*(intHelper+tmpCounter) = *(intHelper+tmpCounter)+1;
tmpCounter = tmpCounter + 1;
}
ier = cg_section_write(index_file, base_i, zone_i, "periodic_suction", CGNS_ENUMV(QUAD_4), \
gElemCounter+1, gElemCounter+nElemSsleperiodic+nElemSsteperiodic, 0, intHelper, \
§ion_i);
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
delete intHelper;
gElemCounter = gElemCounter + nElemSsleperiodic + nElemSsteperiodic;
cout << "peridic_suction written ... " << endl;
//write periodic pressure*****************************************************
elem = inPsleperiodicElementNodes->getAddress();
//increment nodes
elem = elem+1;
intHelper = new cgsize_t[nNodesPsleperiodic+nNodesPsteperiodic];
tmpCounter = 0;
for (ii=0;ii<nNodesPsleperiodic;ii++){
*(intHelper+tmpCounter) = *(elem+ii);
*(intHelper+tmpCounter) = *(intHelper+tmpCounter)+1;
tmpCounter = tmpCounter + 1;
}
elem = inPsteperiodicElementNodes->getAddress();
//increment nodes
elem = elem+1;
for (ii=0;ii<nNodesPsteperiodic;ii++){
*(intHelper+tmpCounter) = *(elem+ii);
*(intHelper+tmpCounter) = *(intHelper+tmpCounter)+1;
tmpCounter = tmpCounter + 1;
}
ier = cg_section_write(index_file, base_i, zone_i, "periodic_pressure", CGNS_ENUMV(QUAD_4), \
gElemCounter+1, gElemCounter+nElemPsleperiodic+nElemPsteperiodic, 0, intHelper, \
§ion_i);
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
delete intHelper;
gElemCounter = gElemCounter + nElemPsleperiodic + nElemPsteperiodic;
cout << "peridic pressure written ... " << endl;
//
// baseCFX
//
//write base******************************************************************
ier = cg_base_write(index_file, "baseCFX", 3, 3, &baseCFX_i);
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
cout << "baseCFX written ..." << endl;
// write zones****************************************************************
cgsize[0][0] = nCoords;
cgsize[0][1] = nElem;
cgsize[0][2] = 0;
ptrToCgsize = &cgsize[0][0];
ier = cg_zone_write(index_file, baseCFX_i, "runner", ptrToCgsize, CGNS_ENUMV(Unstructured), &zone_i);
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
cout << "runner written ..." << endl;
ier = cg_goto(index_file, baseCFX_i, "runner", 0, "end");
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
ier = cg_link_write("GridCoordinates", "", "/base/runner/GridCoordinates");
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
cout << "coordinates linked ..." << endl;
//connectivities
ier = cg_goto(index_file, baseCFX_i, "runner", 0, "end");
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
ier = cg_link_write("Elem", "", "/base/runner/Elem");
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
cout << "Elem linked ..." << endl;
//write inlet*****************************************************************
ier = cg_goto(index_file, baseCFX_i, "runner", 0, "end");
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
ier = cg_link_write("inlet", "", "/base/runner/inlet");
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
cout << "inlet linked ..." << endl;
//write outlet****************************************************************
ier = cg_goto(index_file, baseCFX_i, "runner", 0, "end");
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
ier = cg_link_write("outlet", "", "/base/runner/outlet");
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
cout << "outlet linked ..." << endl;
//write psblade***************************************************************
ier = cg_goto(index_file, baseCFX_i, "runner", 0, "end");
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
ier = cg_link_write("blade_pressure", "", "/base/runner/psblade");
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
cout << "psblade linked ..." << endl;
//write ssblade***************************************************************
ier = cg_goto(index_file, baseCFX_i, "runner", 0, "end");
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
ier = cg_link_write("blade_suction", "", "/base/runner/ssblade");
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
cout << "ssblade linked ..." << endl;
//write hubAll****************************************************************
ier = cg_goto(index_file, baseCFX_i, "runner", 0, "end");
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
ier = cg_link_write("hub", "", "/base/runner/hubAll");
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
cout << "hubAll linked ..." << endl;
//write shroudAll*************************************************************
ier = cg_goto(index_file, baseCFX_i, "runner", 0, "end");
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
ier = cg_link_write("shroud", "", "/base/runner/shroudAll");
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
cout << "shroudAll linked ..." << endl;
//write periodic suction******************************************************
ier = cg_goto(index_file, baseCFX_i, "runner", 0, "end");
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
ier = cg_link_write("periodic_suction", "", "/base/runner/periodic_suction");
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
cout << "periodic_suction linked ..." << endl;
//write periodic pressure*****************************************************
ier = cg_goto(index_file, baseCFX_i, "runner", 0, "end");
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
ier = cg_link_write("periodic_pressure", "", "/base/runner/periodic_pressure");
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
cout << "periodic_pressure linked ..." << endl;
//close cgns file*************************************************************
ier = cg_close(index_file);
if(ier) {
sendError("%s", cg_get_error());
return FAILURE;
}
//----------------------------------------------------------------------------
sendInfo("grid successfully converted to cgns");
return SUCCESS;
}
