static void get_reference (void)
{
int n, narrays, na, dim;
cgsize_t vec[12];
CGNS_ENUMT(DataType_t) datatype;
CGNS_ENUMT(AngleUnits_t) angle;
int aloc = 0, units[5];
char name[33];
static char *refnames[4] = {
"Mach",
"AngleofAttack",
"Reynolds",
"TimeLatest"
};
reference[0] = 0.5; /* Mach Number */
reference[1] = 0.0; /* angle of attack */
reference[2] = 1.0e6; /* Reynolds Number */
reference[3] = 0.0; /* time */
if (cg_goto (cgnsfn, cgnsbase, "ReferenceState_t", 1, "end") ||
cg_narrays (&narrays) || narrays < 1)
return;
for (na = 1; na <= narrays; na++) {
if (cg_array_info (na, name, &datatype, &dim, vec))
FATAL ("get_reference", NULL);
if (dim != 1 || vec[0] != 1) continue;
for (n = 0; n < 4; n++) {
if (!strcmp (refnames[n], name)) {
if (cg_array_read_as (na, CGNS_ENUMV(RealDouble), &reference[n]))
FATAL ("get_reference", NULL);
if (n == 1) aloc = na;
break;
}
}
}
/* angle of attack units */
if (aloc) {
if (cg_goto (cgnsfn, cgnsbase, "ReferenceState_t", 1,
"DataArray_t", aloc, "end"))
FATAL ("get_reference", NULL);
if (read_units (units))
angle = (CGNS_ENUMT(AngleUnits_t))units[4];
else
angle = (CGNS_ENUMT(AngleUnits_t))baseunits[4];
if (angle == CGNS_ENUMV(Radian))
reference[1] *= 57.29578;
}
}
static void write_q_formatted (char *qfile)
{
int nz, i, j, n, k, nk, np;
FILE *fp;
printf ("\nwriting formatted Q file to %s\n", qfile);
if (NULL == (fp = fopen (qfile, "w+"))) {
fprintf (stderr, "couldn't open <%s> for writing\n", qfile);
exit (1);
}
if (mblock || nblocks > 1)
fprintf (fp, "%d\n", nblocks);
for (nz = 0; nz < nZones; nz++) {
if (Zones[nz].type == CGNS_ENUMV(Structured))
fprintf (fp, "%d %d %d\n", (int)Zones[nz].dim[0],
(int)Zones[nz].dim[1], (int)Zones[nz].dim[2]);
}
for (nz = 0; nz < nZones; nz++) {
if (Zones[nz].type == CGNS_ENUMV(Structured)) {
printf (" zone %d ... ", nz+1);
fflush (stdout);
fprintf (fp, "%#g %#g %#g %#g\n", reference[0], reference[1],
reference[2], reference[3]);
compute_solution (nz);
if (whole) {
np = (int)Zones[nz].nverts;
nk = 1;
}
else {
np = (int)(Zones[nz].dim[0] * Zones[nz].dim[1]);
nk = (int)Zones[nz].dim[2];
}
for (k = 0; k < nk; k++) {
i = k * np;
for (j = 0; j < 5; j++) {
for (n = 0; n < np; n++) {
if (n) putc ((n % 5) == 0 ? '\n' : ' ', fp);
fprintf (fp, "%#g", q[j][i+n]);
}
putc ('\n', fp);
}
}
puts ("done");
}
}
fclose (fp);
}
static int check_solution (int nz)
{
int nf, flags = 0;
SOLUTION *sol;
if (!read_zone_solution (nz+1) ||
usesol > Zones[nz].nsols) return 0;
sol = &Zones[nz].sols[usesol-1];
if (sol->nflds < 5 || (sol->location != CGNS_ENUMV(Vertex) &&
sol->location != CGNS_ENUMV(CellCenter))) return 0;
for (nf = 0; nf < sol->nflds; nf++) {
if (!strcmp (sol->flds[nf].name, "Density")) {
flags |= 0x01;
continue;
}
if (!strcmp (sol->flds[nf].name, "VelocityX") ||
!strcmp (sol->flds[nf].name, "MomentumX")) {
flags |= 0x02;
continue;
}
if (!strcmp (sol->flds[nf].name, "VelocityY") ||
!strcmp (sol->flds[nf].name, "MomentumY")) {
flags |= 0x04;
continue;
}
if (!strcmp (sol->flds[nf].name, "VelocityZ") ||
!strcmp (sol->flds[nf].name, "MomentumZ")) {
flags |= 0x08;
continue;
}
if (!strcmp (sol->flds[nf].name, "Pressure") ||
!strcmp (sol->flds[nf].name, "EnergyStagnationDensity")) {
flags |= 0x10;
continue;
}
}
return (flags & 0x1f) == 0x1f ? 1 : 0;
}
static void count_elements (int nz, cgsize_t *nelems, int *elemtype)
{
int ns, et;
cgsize_t n, nn, ne, nb = 0, nt = 0;
ZONE *z = &Zones[nz];
if (z->esets == NULL)
read_zone_element (nz+1);
for (ns = 0; ns < z->nesets; ns++) {
ne = z->esets[ns].end - z->esets[ns].start + 1;
et = z->esets[ns].type;
if (et == CGNS_ENUMV(MIXED)) {
for (n = 0, nn = 0; nn < ne; nn++) {
et = (int)z->esets[ns].conn[n++];
if (et < CGNS_ENUMV(NODE) || et > CGNS_ENUMV(HEXA_27))
FATAL (NULL, "unrecognized element type");
if (et >= CGNS_ENUMV(TETRA_4)) {
if (et > CGNS_ENUMV(TETRA_10))
nb++;
else
nt++;
}
n += element_node_counts[et];
}
continue;
}
if (et >= CGNS_ENUMV(TETRA_4) && et <= CGNS_ENUMV(HEXA_27)) {
if (et > CGNS_ENUMV(TETRA_10))
nb += ne;
else
nt += ne;
}
}
if (nt + nb == 0)
FATAL (NULL, "no volume elements in the zone");
*nelems = nt + nb;
*elemtype = nb ? 3 : 2;
}
int main(int argc, char* argv[]) {
/* Initialize varaibles */
initialize(&argc,&argv);
/* Time the creation of a file */
t0 = MPI_Wtime();
DEBUG_PRINT(("[%d]cgp_open\n",comm_rank))
if (cgp_open("benchmark.cgns", CG_MODE_WRITE, &fn))
cgp_error_exit();
t1 = MPI_Wtime();
doTimer("File Open", t1-t0);
/* Time the creation of a base */
t0 = MPI_Wtime();
DEBUG_PRINT(("[%d]cg_base_write\n",comm_rank))
if (cg_base_write(fn, "Base 1", 3, 3, &B))
cgp_error_exit();
t1 = MPI_Wtime();
doTimer("Base Write", t1-t0);
/* Time the creation of a zone */
t0 = MPI_Wtime();
DEBUG_PRINT(("[%d]cg_zone_write\n",comm_rank))
if (cg_zone_write(fn, B, "Zone 1", nijk, CGNS_ENUMV(Structured), &Z))
cgp_error_exit();
t1 = MPI_Wtime();
doTimer("Zone Write", t1-t0);
/* Time the creation of coordinates X */
t0 = MPI_Wtime();
DEBUG_PRINT(("[%d]cgp_coord_write X\n",comm_rank))
if (cgp_coord_write(fn,B,Z,CGNS_ENUMV(RealDouble),"CoordinateX",&C))
cgp_error_exit();
t1 = MPI_Wtime();
doTimer("Coord X Write", t1-t0);
/* Time the write speed of coordinates X */
MPI_Barrier(MPI_COMM_WORLD);
t0 = MPI_Wtime();
DEBUG_PRINT(("[%d]cgp_coord_write_data X\n",comm_rank))
if (cgp_coord_write_data(fn,B,Z,C,min,max,x))
cgp_error_exit();
t1 = MPI_Wtime();
MPI_Barrier(MPI_COMM_WORLD);
ta = MPI_Wtime();
doTimer("Coord X Write Data", t1-t0);
doBandwidth("Coord X Write Data", t1-t0);
doBandwidthAgg("Coord X Write Data", ta-t0);
/* Time the creation of coordinates Y */
t0 = MPI_Wtime();
DEBUG_PRINT(("[%d]cgp_coord_write Y\n",comm_rank))
if (cgp_coord_write(fn,B,Z,CGNS_ENUMV(RealDouble),"CoordinateY",&C))
cgp_error_exit();
t1 = MPI_Wtime();
doTimer("Coord Y Write", t1-t0);
/* Time the write speed of coordinates Y */
MPI_Barrier(MPI_COMM_WORLD);
t0 = MPI_Wtime();
DEBUG_PRINT(("[%d]cgp_coord_write_data Y\n",comm_rank))
if (cgp_coord_write_data(fn,B,Z,C,min,max,y))
cgp_error_exit();
t1 = MPI_Wtime();
MPI_Barrier(MPI_COMM_WORLD);
ta = MPI_Wtime();
doTimer("Coord Y Write Data", t1-t0);
doBandwidth("Coord Y Write Data", t1-t0);
doBandwidthAgg("Coord Y Write Data", ta-t0);
/* Time the creation of coordinates Z */
t0 = MPI_Wtime();
DEBUG_PRINT(("[%d]cgp_coord_write Z\n",comm_rank))
if (cgp_coord_write(fn,B,Z,CGNS_ENUMV(RealDouble),"CoordinateZ",&C))
cgp_error_exit();
t1 = MPI_Wtime();
doTimer("Coord Z Write", t1-t0);
/* Time the write speed of coordinates Z */
MPI_Barrier(MPI_COMM_WORLD);
t0 = MPI_Wtime();
DEBUG_PRINT(("[%d]cgp_coord_write_data Z\n",comm_rank))
if (cgp_coord_write_data(fn,B,Z,C,min,max,z))
cgp_error_exit();
t1 = MPI_Wtime();
MPI_Barrier(MPI_COMM_WORLD);
ta = MPI_Wtime();
doTimer("Coord Z Write Data", t1-t0);
doBandwidth("Coord Z Write Data", t1-t0);
doBandwidthAgg("Coord Z Write Data", ta-t0);
/* Time closing of the file */
t0 = MPI_Wtime();
DEBUG_PRINT(("[%d]cgp_close\n",comm_rank))
if (cgp_close(fn))
cgp_error_exit();
t1 = MPI_Wtime();
doTimer("File Close", t1-t0);
finalize();
return 0;
}
/* 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;
}
int main (int argc, char *argv[])
{
int n, ib, nb, is, nz, celldim, phydim;
cgsize_t imax;
char basename[33];
if (argc < 2)
print_usage (usgmsg, NULL);
ib = 0;
basename[0] = 0;
while ((n = getargs (argc, argv, options)) > 0) {
switch (n) {
case 's':
mblock = 0;
break;
case 'p':
whole = 0;
break;
case 'n':
use_iblank = 0;
break;
case 'f':
case 'u':
format = n;
break;
case 'd':
use_double = 1;
break;
case 'b':
ib = atoi (argarg);
break;
case 'B':
strncpy (basename, argarg, 32);
basename[32] = 0;
break;
case 'g':
gamma = atof (argarg);
if (gamma <= 1.0)
FATAL (NULL, "invalid value for gamma");
break;
case 'w':
weighting = 1;
break;
case 'S':
usesol = atoi (argarg);
break;
}
}
if (argind > argc - 2)
print_usage (usgmsg, "CGNSfile and/or XYZfile not given");
if (!file_exists (argv[argind]))
FATAL (NULL, "CGNSfile does not exist or is not a file");
/* open CGNS file */
printf ("reading CGNS file from %s\n", argv[argind]);
nb = open_cgns (argv[argind], 1);
if (!nb)
FATAL (NULL, "no bases found in CGNS file");
if (*basename && 0 == (ib = find_base (basename)))
FATAL (NULL, "specified base not found");
if (ib > nb) FATAL (NULL, "base index out of range");
cgnsbase = ib ? ib : 1;
if (cg_base_read (cgnsfn, cgnsbase, basename, &celldim, &phydim))
FATAL (NULL, NULL);
if (celldim != 3 || phydim != 3)
FATAL (NULL, "cell and/or physical dimension must be 3");
printf (" using base %d - %s\n", cgnsbase, basename);
read_zones ();
for (nz = 0; nz < nZones; nz++) {
if (Zones[nz].type == CGNS_ENUMV(Structured)) {
/* verify we can write out using ints */
for (n = 0; n < 3; n++) {
if (Zones[nz].dim[n] > CG_MAX_INT32)
FATAL(NULL, "zone dimensions too large for integer");
}
if (whole) {
if (Zones[nz].nverts > CG_MAX_INT32)
FATAL(NULL, "zone too large to write as whole using an integer");
}
else {
if (Zones[nz].dim[0]*Zones[nz].dim[1] > CG_MAX_INT32)
FATAL(NULL, "zone too large to write using an integer");
}
nblocks++;
}
}
if (!nblocks) FATAL (NULL, "no structured zones found");
/* read the nodes */
printf ("reading %d zones\n", nblocks);
ib = is = 0;
imax = 0;
for (nz = 0; nz < nZones; nz++) {
if (Zones[nz].type == CGNS_ENUMV(Structured)) {
printf (" zone %d - %s ... ", nz+1, Zones[nz].name);
fflush (stdout);
read_zone_grid (nz+1);
ib += read_zone_interface (nz+1);
is += check_solution (nz);
if (imax < Zones[nz].nverts) imax = Zones[nz].nverts;
puts ("done");
}
}
if (!ib) use_iblank = 0;
if (use_iblank) {
iblank = (int *) malloc ((size_t)imax * sizeof(int));
if (NULL == iblank)
FATAL (NULL, "malloc failed for iblank array");
}
/* write Plot3d XYZ file */
if (format == 'f')
write_xyz_formatted (argv[++argind]);
else if (format == 'u')
write_xyz_unformatted (argv[++argind]);
else
write_xyz_binary (argv[++argind]);
if (use_iblank) free (iblank);
/* write solution file */
if (++argind < argc) {
if (is != nblocks) {
fprintf (stderr, "solution file is not being written since not\n");
fprintf (stderr, "all the blocks contain a complete solution\n");
cg_close (cgnsfn);
exit (1);
}
for (n = 0; n < 5; n++) {
q[n] = (double *) malloc ((size_t)imax * sizeof(double));
if (NULL == q[n])
FATAL (NULL, "malloc failed for solution working array");
}
get_reference ();
if (format == 'f')
write_q_formatted (argv[argind]);
else if (format == 'u')
write_q_unformatted (argv[argind]);
else
write_q_binary (argv[argind]);
}
cg_close (cgnsfn);
return 0;
}
static void read_q (BINARYIO *bf)
{
int i, k, n, nk, nz, np, nv, nmax;
int *indices;
void *data;
SOLUTION *sol;
FIELD *flds;
double qq, rho;
static char *fldnames[] = {
"Density",
"MomentumX",
"MomentumY",
"MomentumZ",
"EnergyStagnationDensity",
"VelocityX",
"VelocityY",
"VelocityZ",
"Pressure"
};
/* get number of grid blocks */
if (mblock) {
bf_getints (bf, 1, &nz);
if (nz != nZones)
FATAL ("read_q", "number of blocks not the same as the XYZ file");
}
/* read indices for grids */
indices = (int *) malloc (3 * nZones * sizeof(int));
if (NULL == indices)
FATAL ("read_q", "malloc failed for grid indices");
bf_getints (bf, 3 * nZones, indices);
for (nz = 0; nz < nZones; nz++) {
for (n = 0; n < 3; n++) {
if (indices[3*nz+n] != Zones[nz].dim[n])
FATAL ("read_q", "mismatch in block sizes");
}
}
free (indices);
/* create solution data arrays */
for (nmax = 0, nz = 0; nz < nZones; nz++) {
np = whole ? (int)Zones[nz].nverts : (int)(Zones[nz].dim[0] * Zones[nz].dim[1]);
if (nmax < np) nmax = np;
sol = new_solution (1);
strcpy (sol->name, "FlowSolution");
sol->location = CGNS_ENUMV(Vertex);
sol->size = Zones[nz].nverts;
sol->nflds = 5;
sol->flds = new_field (5, sol->size);
for (nv = 0; nv < 5; nv++) {
strcpy (sol->flds[nv].name, fldnames[nv]);
sol->flds[nv].datatype = is_double ? CGNS_ENUMV(RealDouble) : CGNS_ENUMV(RealSingle);
}
Zones[nz].nsols = 1;
Zones[nz].sols = sol;
}
if (nmax < 4) nmax = 4;
if (is_double)
data = (void *) malloc (nmax * sizeof(double));
else
data = (void *) malloc (nmax * sizeof(float));
if (NULL == data)
FATAL ("read_q", "malloc failed for solution working array");
/* read the solution data */
for (nz = 0; nz < nZones; nz++) {
printf ("reading block %d solution ...", nz+1);
fflush (stdout);
if (is_double) {
bf_getdoubles (bf, 4, data);
if (0 == nz) {
for (n = 0; n < 4; n++)
reference[n] = ((double *)data)[n];
}
}
else {
bf_getfloats (bf, 4, data);
if (0 == nz) {
for (n = 0; n < 4; n++)
reference[n] = ((float *)data)[n];
}
}
if (whole) {
np = (int)Zones[nz].nverts;
nk = 1;
}
else {
np = (int)(Zones[nz].dim[0] * Zones[nz].dim[1]);
nk = (int)Zones[nz].dim[2];
}
flds = Zones[nz].sols->flds;
for (k = 0; k < nk; k++) {
i = k * np;
for (nv = 0; nv < 5; nv++) {
if (is_double) {
bf_getdoubles (bf, np, data);
for (n = 0; n < np; n++)
flds[nv].data[n+i] = ((double *)data)[n];
}
else {
bf_getfloats (bf, np, data);
for (n = 0; n < np; n++)
flds[nv].data[n+i] = ((float *)data)[n];
}
}
}
if (convert) {
for (nv = 1; nv < 5; nv++)
strcpy (flds[nv].name, fldnames[4+nv]);
for (n = 0; n < Zones[nz].nverts; n++) {
rho = flds[0].data[n];
for (qq = 0.0, nv = 1; nv < 4; nv++) {
flds[nv].data[n] /= rho;
qq += flds[nv].data[n] * flds[nv].data[n];
}
flds[4].data[n] = (gamma - 1.0) *
(flds[4].data[n] - 0.5 * rho * qq);
}
}
puts (" done");
}
free (data);
}
static int *volume_elements (int nz, cgsize_t *nelems, int *elemtype)
{
int i, np, ns, nt, et;
int *elems;
cgsize_t n, nn, ne;
ZONE *z = &Zones[nz];
count_elements (nz, &ne, &nt);
*nelems = ne;
*elemtype = nt;
elems = (int *) malloc ((size_t)ne * (1 << nt) * sizeof(int));
if (NULL == elems)
FATAL (NULL, "malloc failed for elements");
for (np = 0, ns = 0; ns < z->nesets; ns++) {
ne = z->esets[ns].end - z->esets[ns].start + 1;
et = z->esets[ns].type;
if (et < CGNS_ENUMV(TETRA_4) || et > CGNS_ENUMV(MIXED)) continue;
for (n = 0, nn = 0; nn < ne; nn++) {
if (z->esets[ns].type == CGNS_ENUMV(MIXED))
et = (int)z->esets[ns].conn[n++];
switch (et) {
case CGNS_ENUMV(TETRA_4):
case CGNS_ENUMV(TETRA_10):
if (nt == 2) {
for (i = 0; i < 4; i++)
elems[np++] = (int)z->esets[ns].conn[n+i];
}
else {
for (i = 0; i < 3; i++)
elems[np++] = (int)z->esets[ns].conn[n+i];
elems[np++] = (int)z->esets[ns].conn[n+2];
for (i = 0; i < 4; i++)
elems[np++] = (int)z->esets[ns].conn[n+3];
}
break;
case CGNS_ENUMV(PYRA_5):
case CGNS_ENUMV(PYRA_14):
for (i = 0; i < 4; i++)
elems[np++] = (int)z->esets[ns].conn[n+i];
for (i = 0; i < 4; i++)
elems[np++] = (int)z->esets[ns].conn[n+4];
break;
case CGNS_ENUMV(PENTA_6):
case CGNS_ENUMV(PENTA_15):
case CGNS_ENUMV(PENTA_18):
for (i = 0; i < 3; i++)
elems[np++] = (int)z->esets[ns].conn[n+i];
elems[np++] = (int)z->esets[ns].conn[n+2];
for (i = 3; i < 6; i++)
elems[np++] = (int)z->esets[ns].conn[n+i];
elems[np++] = (int)z->esets[ns].conn[n+5];
break;
case CGNS_ENUMV(HEXA_8):
case CGNS_ENUMV(HEXA_20):
case CGNS_ENUMV(HEXA_27):
for (i = 0; i < 8; i++)
elems[np++] = (int)z->esets[ns].conn[n+i];
break;
}
n += element_node_counts[et];
}
}
return elems;
}
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;
}
static void write_xyz_formatted (char *xyzfile)
{
int n, k, nk, nz, np, *ib;
VERTEX *verts;
FILE *fp;
printf ("\nwriting formatted XYZ file to %s\n", xyzfile);
if (use_iblank) printf (" with iblank array\n");
if (NULL == (fp = fopen (xyzfile, "w+"))) {
fprintf (stderr, "couldn't open <%s> for writing\n", xyzfile);
exit (1);
}
if (mblock || nblocks > 1)
fprintf (fp, "%d\n", nblocks);
for (nz = 0; nz < nZones; nz++) {
if (Zones[nz].type == CGNS_ENUMV(Structured))
fprintf (fp, "%d %d %d\n", (int)Zones[nz].dim[0],
(int)Zones[nz].dim[1], (int)Zones[nz].dim[2]);
}
for (nz = 0; nz < nZones; nz++) {
if (Zones[nz].type == CGNS_ENUMV(Structured)) {
printf (" zone %d - %d x %d x %d ... ", nz+1,
(int)Zones[nz].dim[0], (int)Zones[nz].dim[1],
(int)Zones[nz].dim[2]);
fflush (stdout);
if (use_iblank) compute_iblank (nz);
if (whole) {
np = (int)Zones[nz].nverts;
nk = 1;
}
else {
np = (int)(Zones[nz].dim[0] * Zones[nz].dim[1]);
nk = (int)Zones[nz].dim[2];
}
for (k = 0; k < nk; k++) {
verts = &Zones[nz].verts[k*np];
for (n = 0; n < np; n++) {
if (n) putc ((n % 5) == 0 ? '\n' : ' ', fp);
fprintf (fp, "%#g", verts[n].x);
}
putc ('\n', fp);
for (n = 0; n < np; n++) {
if (n) putc ((n % 5) == 0 ? '\n' : ' ', fp);
fprintf (fp, "%#g", verts[n].y);
}
putc ('\n', fp);
for (n = 0; n < np; n++) {
if (n) putc ((n % 5) == 0 ? '\n' : ' ', fp);
fprintf (fp, "%#g", verts[n].z);
}
putc ('\n', fp);
if (use_iblank) {
ib = &iblank[k*np];
for (n = 0; n < np; n++, ib++) {
if (n && (n % 10) == 0)
putc ('\n', fp);
fprintf (fp, "%5d", *ib);
}
putc ('\n', fp);
}
}
puts ("done");
}
}
fclose (fp);
}
static void write_xyz_unformatted (char *xyzfile)
{
int n, i, ierr, *indices;
int nz, k, nk, np;
char buff[129];
VERTEX *verts;
void *xyz;
float *xyzf;
double *xyzd;
printf ("\nwriting unformatted XYZ file to %s\n", xyzfile);
printf (" in %s-precision", use_double ? "double" : "single");
if (use_iblank) printf (" with iblank array");
putchar ('\n');
for (np = 0, nz = 0; nz < nZones; nz++) {
if (Zones[nz].type == CGNS_ENUMV(Structured)) {
nk = whole ? (int)Zones[nz].nverts :
(int)(Zones[nz].dim[0] * Zones[nz].dim[1]);
if (np < nk) np = nk;
}
}
indices = (int *) malloc (3 * nblocks * sizeof(int));
if (use_double) {
xyz = (void *) malloc (3 * np * sizeof(double));
xyzd = (double *)xyz;
}
else {
xyz = (void *) malloc (3 * np * sizeof(float));
xyzf = (float *)xyz;
}
if (NULL == indices || NULL == xyz)
FATAL ("write_xyx_unformatted", "malloc failed for working arrays");
unlink (xyzfile);
strcpy (buff, xyzfile);
for (n = (int)strlen(buff); n < 128; n++)
buff[n] = ' ';
buff[128] = 0;
n = 0;
OPENF (&n, buff, 128);
if (mblock || nblocks > 1) {
n = 1;
WRITEIF (&n, &nblocks, &ierr);
}
for (n = 0, nz = 0; nz < nZones; nz++) {
if (Zones[nz].type == CGNS_ENUMV(Structured)) {
for (i = 0; i < 3; i++)
indices[n++] = (int)Zones[nz].dim[i];
}
}
WRITEIF (&n, indices, &ierr);
for (nz = 0; nz < nZones; nz++) {
if (Zones[nz].type == CGNS_ENUMV(Structured)) {
printf (" zone %d - %d x %d x %d ... ", nz+1,
(int)Zones[nz].dim[0], (int)Zones[nz].dim[1],
(int)Zones[nz].dim[2]);
fflush (stdout);
if (use_iblank) compute_iblank (nz);
if (whole) {
np = (int)Zones[nz].nverts;
nk = 1;
}
else {
np = (int)(Zones[nz].dim[0] * Zones[nz].dim[1]);
nk = (int)Zones[nz].dim[2];
}
for (k = 0; k < nk; k++) {
verts = &Zones[nz].verts[k*np];
if (use_double) {
for (i = 0, n = 0; n < np; n++)
xyzd[i++] = verts[n].x;
for (n = 0; n < np; n++)
xyzd[i++] = verts[n].y;
for (n = 0; n < np; n++)
xyzd[i++] = verts[n].z;
if (use_iblank)
WRITEGDF (&np, xyzd, &iblank[k*np], &ierr);
else
WRITEDF (&i, xyzd, &ierr);
}
else {
for (i = 0, n = 0; n < np; n++)
xyzf[i++] = (float)verts[n].x;
for (n = 0; n < np; n++)
xyzf[i++] = (float)verts[n].y;
for (n = 0; n < np; n++)
xyzf[i++] = (float)verts[n].z;
if (use_iblank)
WRITEGFF (&np, xyzf, &iblank[k*np], &ierr);
else
WRITEFF (&i, xyzf, &ierr);
}
}
puts ("done");
}
}
CLOSEF ();
free (indices);
free (xyz);
}
static void write_xyz_binary (char *xyzfile)
{
int nz, i, dims[3];
int n, k, nk, np;
VERTEX *verts;
void *xyz;
float *xyzf;
double *xyzd;
FILE *fp;
printf ("\nwriting binary XYZ file to %s\n", xyzfile);
printf (" in %s-precision", use_double ? "double" : "single");
if (use_iblank) printf (" with iblank array");
putchar ('\n');
for (np = 0, nz = 0; nz < nZones; nz++) {
if (Zones[nz].type == CGNS_ENUMV(Structured)) {
nk = whole ? (int)Zones[nz].nverts :
(int)(Zones[nz].dim[0] * Zones[nz].dim[1]);
if (np < nk) np = nk;
}
}
if (use_double) {
xyz = (void *) malloc (np * sizeof(double));
xyzd = (double *)xyz;
}
else {
xyz = (void *) malloc (np * sizeof(float));
xyzf = (float *)xyz;
}
if (NULL == xyz)
FATAL ("write_xyx_binary", "malloc failed for working arrays");
if (NULL == (fp = fopen (xyzfile, "w+b"))) {
fprintf (stderr, "couldn't open <%s> for writing\n", xyzfile);
exit (1);
}
if (mblock || nblocks > 1)
fwrite (&nblocks, sizeof(int), 1, fp);
for (nz = 0; nz < nZones; nz++) {
if (Zones[nz].type == CGNS_ENUMV(Structured)) {
for (i = 0; i < 3; i++)
dims[i] = (int)Zones[nz].dim[i];
fwrite (dims, sizeof(int), 3, fp);
}
}
for (nz = 0; nz < nZones; nz++) {
if (Zones[nz].type == CGNS_ENUMV(Structured)) {
printf (" zone %d - %d x %d x %d ... ", nz+1,
(int)Zones[nz].dim[0], (int)Zones[nz].dim[1],
(int)Zones[nz].dim[2]);
fflush (stdout);
if (use_iblank) compute_iblank (nz);
if (whole) {
np = (int)Zones[nz].nverts;
nk = 1;
}
else {
np = (int)(Zones[nz].dim[0] * Zones[nz].dim[1]);
nk = (int)Zones[nz].dim[2];
}
for (k = 0; k < nk; k++) {
verts = &Zones[nz].verts[k*np];
if (use_double) {
for (n = 0; n < np; n++)
xyzd[n] = verts[n].x;
fwrite (xyzd, sizeof(double), np, fp);
for (n = 0; n < np; n++)
xyzd[n] = verts[n].y;
fwrite (xyzd, sizeof(double), np, fp);
for (n = 0; n < np; n++)
xyzd[n] = verts[n].z;
fwrite (xyzd, sizeof(double), np, fp);
}
else {
for (n = 0; n < np; n++)
xyzf[n] = (float)verts[n].x;
fwrite (xyzf, sizeof(float), np, fp);
for (n = 0; n < np; n++)
xyzf[n] = (float)verts[n].y;
fwrite (xyzf, sizeof(float), np, fp);
for (n = 0; n < np; n++)
xyzf[n] = (float)verts[n].z;
fwrite (xyzf, sizeof(float), np, fp);
}
if (use_iblank)
fwrite (&iblank[k*np], sizeof(int), np, fp);
}
puts ("done");
}
}
fclose (fp);
free (xyz);
}
int main (int argc, char *argv[])
{
int n, ib = 0, nb, flags = 0, has_q = 0;
BINARYIO *bf;
static char basename[33] = "Base";
if (argc < 3)
print_usage (usgmsg, NULL);
/* get options */
while ((n = getargs (argc, argv, options)) > 0) {
switch (n) {
case 'f':
flags &= ~OPEN_FORTRAN;
flags |= OPEN_ASCII;
break;
case 'u':
flags &= ~OPEN_ASCII;
flags |= OPEN_FORTRAN;
break;
case 's':
mblock = 0;
break;
case 'p':
whole = 0;
break;
case 'i':
use_iblank = 1;
/* fall through */
case 'n':
has_iblank = 1;
break;
case 'd':
is_double = 1;
break;
case 'M':
flags &= ~MACH_UNKNOWN;
flags |= get_machine (argarg);
break;
case 'b':
ib = atoi (argarg);
break;
case 'B':
strncpy (basename, argarg, 32);
basename[32] = 0;
break;
case 'g':
gamma = atof (argarg);
if (gamma <= 1.0)
FATAL (NULL, "invalid value for gamma");
break;
case 'c':
convert = 1;
break;
}
}
if (argind > argc - 2)
print_usage (usgmsg, "XYZfile and/or CGNSfile not given");
/* read Plot3d file */
printf ("reading PLOT3D grid file %s\n", argv[argind]);
printf (" as %s-block %s", mblock ? "multi" : "single",
flags == OPEN_ASCII ? "ASCII" :
(flags == OPEN_FORTRAN ? "FORTRAN unformatted" : "binary"));
if (has_iblank) printf (" with iblank array");
putchar ('\n');
if (!file_exists (argv[argind]))
FATAL (NULL, "XYZ file does not exist or is not a file");
if (NULL == (bf = bf_open (argv[argind], flags | OPEN_READ))) {
fprintf (stderr, "can't open <%s> for reading", argv[argind]);
exit (1);
}
read_xyz (bf);
bf_close (bf);
if (use_iblank) build_interfaces ();
/* read solution file if given */
if (++argind < argc-1) {
printf ("\nreading PLOT3D solution file %s\n", argv[argind]);
if (!file_exists (argv[argind]))
FATAL (NULL, "Solution file does not exist or is not a file");
if (NULL == (bf = bf_open (argv[argind], flags | OPEN_READ))) {
fprintf (stderr, "can't open <%s> for reading", argv[argind]);
exit (1);
}
read_q (bf);
bf_close (bf);
argind++;
has_q = 1;
}
/* open CGNS file */
printf ("\nwriting CGNS file to %s\n", argv[argind]);
nb = open_cgns (argv[argind], 0);
if (ib) {
if (ib > nb)
FATAL (NULL, "specified base index out of range");
if (cg_base_read (cgnsfn, ib, basename, &n, &n))
FATAL (NULL, NULL);
}
if (cg_base_write (cgnsfn, basename, 3, 3, &cgnsbase) ||
cg_goto (cgnsfn, cgnsbase, "end") ||
cg_dataclass_write (CGNS_ENUMV(NormalizedByUnknownDimensional)))
FATAL (NULL, NULL);
printf (" output to base %d - %s\n", cgnsbase, basename);
write_zones ();
for (n = 1; n <= nZones; n++) {
printf ("writing zone %d ... grid", n);
fflush (stdout);
write_zone_grid (n);
write_zone_interface (n);
if (has_q) {
printf (", solution");
fflush (stdout);
write_zone_solution (n, 1);
write_solution_field (n, 1, 0);
}
puts (" done");
}
if (has_q) write_reference ();
cg_close (cgnsfn);
return 0;
}
static void write_reference (void)
{
int n;
cgsize_t cnt = 1;
CGNS_ENUMT(DataType_t) datasize;
float ref[4];
void *mach, *alpha, *rey, *time;
printf ("writing reference state...");
fflush (stdout);
if (cg_goto (cgnsfn, cgnsbase, "end") ||
cg_state_write ("PLOT3D reference state"))
FATAL ("write_reference", NULL);
if (is_double) {
datasize = CGNS_ENUMV(RealDouble);
mach = (void *)&reference[0];
alpha = (void *)&reference[1];
rey = (void *)&reference[2];
time = (void *)&reference[3];
}
else {
for (n = 0; n < 4; n++)
ref[n] = (float)reference[n];
datasize = CGNS_ENUMV(RealSingle);
mach = (void *)&ref[0];
alpha = (void *)&ref[1];
rey = (void *)&ref[2];
time = (void *)&ref[3];
}
if (cg_goto (cgnsfn, cgnsbase, "ReferenceState_t", 1, "end") ||
cg_array_write ("Mach", datasize, 1, &cnt, mach) ||
cg_goto (cgnsfn, cgnsbase, "ReferenceState_t", 1,
"DataArray_t", 1, "end") ||
cg_dataclass_write (CGNS_ENUMV(NondimensionalParameter)))
FATAL ("write_reference", NULL);
if (cg_goto (cgnsfn, cgnsbase, "ReferenceState_t", 1, "end") ||
cg_array_write ("AngleofAttack", datasize, 1, &cnt, alpha) ||
cg_goto (cgnsfn, cgnsbase, "ReferenceState_t", 1,
"DataArray_t", 2, "end") ||
cg_dataclass_write (CGNS_ENUMV(Dimensional)) ||
cg_units_write (CGNS_ENUMV(MassUnitsNull), CGNS_ENUMV(LengthUnitsNull), CGNS_ENUMV(TimeUnitsNull),
CGNS_ENUMV(TemperatureUnitsNull), CGNS_ENUMV(Degree)))
FATAL ("write_reference", NULL);
if (cg_goto (cgnsfn, cgnsbase, "ReferenceState_t", 1, "end") ||
cg_array_write ("Reynolds", datasize, 1, &cnt, rey) ||
cg_goto (cgnsfn, cgnsbase, "ReferenceState_t", 1,
"DataArray_t", 3, "end") ||
cg_dataclass_write (CGNS_ENUMV(NondimensionalParameter)))
FATAL ("write_reference", NULL);
if (cg_goto (cgnsfn, cgnsbase, "ReferenceState_t", 1, "end") ||
cg_array_write ("TimeLatest", datasize, 1, &cnt, time) ||
cg_goto (cgnsfn, cgnsbase, "ReferenceState_t", 1,
"DataArray_t", 4, "end") ||
cg_dataclass_write (CGNS_ENUMV(Dimensional)) ||
cg_units_write (CGNS_ENUMV(MassUnitsNull), CGNS_ENUMV(LengthUnitsNull),
CGNS_ENUMV(Second), CGNS_ENUMV(TemperatureUnitsNull), CGNS_ENUMV(AngleUnitsNull)))
FATAL ("write_reference", NULL);
puts (" done");
}
int main(int argc, char* argv[]) {
int k;
int F;
int B;
int *Z, *E, *S, *A;
int *Cx, *Cy, *Cz;
int *Fu, *Fv, *Fw;
cgsize_t nijk[3];
cgsize_t min, max;
double T0,T1;
double Tw0,Tw1;
double Tr0,Tr1;
double t0,t1;
initialize(&argc,&argv);
Z = (int *)malloc(10*zc*sizeof(int));
E = Z + zc;
S = E + zc;
A = S + zc;
Cx = A + zc;
Cy = Cx + zc;
Cz = Cy + zc;
Fu = Cz + zc;
Fv = Fu + zc;
Fw = Fv + zc;
if (cgp_open("thesis_benchmark.cgns", CG_MODE_WRITE, &F) ||
cg_base_write(F,"Base",3,3,&B))
cgp_error_exit();
nijk[0] = Nl*ppz;
nijk[1] = Nl*ppz;
nijk[2] = 0;
for(k=0;k<zc;k++) {
char zonename[100+1];
sprintf(zonename,"%s %d","Zone",k);
if (cg_zone_write(F,B,zonename,nijk,CGNS_ENUMV(Unstructured),&(Z[k])) ||
cgp_coord_write(F,B,Z[k],CGNS_ENUMV(RealDouble),"CoordinateX",&(Cx[k])) ||
cgp_coord_write(F,B,Z[k],CGNS_ENUMV(RealDouble),"CoordinateY",&(Cy[k])) ||
cgp_coord_write(F,B,Z[k],CGNS_ENUMV(RealDouble),"CoordinateZ",&(Cz[k])) ||
cgp_section_write(F,B,Z[k],"Elements",CGNS_ENUMV(NODE),1,Nl*ppz,0,&(E[k])) ||
cg_sol_write(F,B,Z[k],"Solution",CGNS_ENUMV(Vertex),&S[k]) ||
cgp_field_write(F,B,Z[k],S[k],CGNS_ENUMV(RealDouble),"MomentumX",&(Fu[k])) ||
cgp_field_write(F,B,Z[k],S[k],CGNS_ENUMV(RealDouble),"MomentumY",&(Fv[k])) ||
cgp_field_write(F,B,Z[k],S[k],CGNS_ENUMV(RealDouble),"MomentumZ",&(Fw[k])))
cgp_error_exit();
if (cg_goto(F,B,zonename,0,NULL) ||
cg_user_data_write("User Data") ||
cg_gorel(F, "User Data", 0, NULL) ||
cgp_array_write("phi",CGNS_ENUMV(RealDouble),1,nijk,&A[k]))
cgp_error_exit();
}
MPI_Barrier(MPI_COMM_WORLD);
T0 = MPI_Wtime();
Tw0 = MPI_Wtime();
/* Writes */
MPI_Barrier(MPI_COMM_WORLD);
t0 = MPI_Wtime();
for(k=0;k<zpp;k++) {
min = subzones[k]*Nl+1;
max = (subzones[k]+1)*Nl;
if (cgp_coord_write_data(F,B,Z[zones[k]],Cx[zones[k]],&min,&max,x) ||
cgp_coord_write_data(F,B,Z[zones[k]],Cy[zones[k]],&min,&max,y) ||
cgp_coord_write_data(F,B,Z[zones[k]],Cz[zones[k]],&min,&max,z))
cgp_error_exit();
}
MPI_Barrier(MPI_COMM_WORLD);
t1 = MPI_Wtime();
if(comm_rank==0) {
printf("Coords Write\n");
printf("\tTime=%lf\n",t1-t0);
printf("\tBandwidth=%lf\n",3.0*data_size/(t1-t0));
}
MPI_Barrier(MPI_COMM_WORLD);
t0 = MPI_Wtime();
for(k=0;k<zpp;k++) {
min = subzones[k]*Nl+1;
max = (subzones[k]+1)*Nl;
if (cgp_field_write_data(F,B,Z[zones[k]],S[zones[k]],Fu[zones[k]],&min,&max,u) ||
cgp_field_write_data(F,B,Z[zones[k]],S[zones[k]],Fv[zones[k]],&min,&max,v) ||
cgp_field_write_data(F,B,Z[zones[k]],S[zones[k]],Fw[zones[k]],&min,&max,w))
cgp_error_exit();
}
MPI_Barrier(MPI_COMM_WORLD);
t1 = MPI_Wtime();
if(comm_rank==0) {
printf("Solutions Write\n");
printf("\tTime=%lf\n",t1-t0);
printf("\tBandwidth=%lf\n",3.0*data_size/(t1-t0));
}
MPI_Barrier(MPI_COMM_WORLD);
t0 = MPI_Wtime();
for(k=0;k<zpp;k++) {
min = subzones[k]*Nl+1;
max = (subzones[k]+1)*Nl;
if (cg_goto(F,B,"Zone_t",Z[zones[k]],
"UserDefinedData_t",1,NULL) ||
cgp_array_write_data(A[zones[k]],&min,&max,h))
cgp_error_exit();
}
MPI_Barrier(MPI_COMM_WORLD);
t1 = MPI_Wtime();
if(comm_rank==0) {
printf("Arrays Write\n");
printf("\tTime=%lf\n",t1-t0);
printf("\tBandwidth=%lf\n",data_size/(t1-t0));
}
MPI_Barrier(MPI_COMM_WORLD);
t0 = MPI_Wtime();
for(k=0;k<zpp;k++) {
min = subzones[k]*Nl+1;
max = (subzones[k]+1)*Nl;
if (cgp_elements_write_data(F,B,Z[zones[k]],E[zones[k]],min,max,e))
cgp_error_exit();
}
MPI_Barrier(MPI_COMM_WORLD);
t1 = MPI_Wtime();
if(comm_rank==0) {
printf("Elements Write\n");
printf("\tTime=%lf\n",t1-t0);
printf("\tBandwidth=%lf\n",((double) sizeof(int))/((double) sizeof(double))*data_size/(t1-t0));
}
MPI_Barrier(MPI_COMM_WORLD);
Tw1 = MPI_Wtime();
if(comm_rank==0) {
printf("Total Write Time=%lf\n",Tw1-Tw0);
printf("Total Write Bandwidth=%lf\n",(6.0+((double) sizeof(int))/((double) sizeof(double)))*data_size/(Tw1-Tw0));
}
MPI_Barrier(MPI_COMM_WORLD);
t0 = MPI_Wtime();
cgp_close(F);
MPI_Barrier(MPI_COMM_WORLD);
t1 = MPI_Wtime();
if(comm_rank==0) printf("Close_Time=%lf\n",t1-t0);
/*=======
*=Reads=
*=======*/
if (cgp_open("thesis_benchmark.cgns", CG_MODE_READ, &F))
cgp_error_exit();
MPI_Barrier(MPI_COMM_WORLD);
Tr0 = MPI_Wtime();
MPI_Barrier(MPI_COMM_WORLD);
t0 = MPI_Wtime();
for(k=0;k<zpp;k++) {
min = subzones[k]*Nl+1;
max = (subzones[k]+1)*Nl;
if (cgp_coord_read_data(F,B,Z[zones[k]],Cx[zones[k]],&min,&max,x) ||
cgp_coord_read_data(F,B,Z[zones[k]],Cy[zones[k]],&min,&max,y) ||
cgp_coord_read_data(F,B,Z[zones[k]],Cz[zones[k]],&min,&max,z))
cgp_error_exit();
}
MPI_Barrier(MPI_COMM_WORLD);
t1 = MPI_Wtime();
if(comm_rank==0) {
printf("Coords Read\n");
printf("\tTime=%lf\n",t1-t0);
printf("\tBandwidth=%lf\n",3.0*data_size/(t1-t0));
}
MPI_Barrier(MPI_COMM_WORLD);
t0 = MPI_Wtime();
for(k=0;k<zpp;k++) {
min = subzones[k]*Nl+1;
max = (subzones[k]+1)*Nl;
if (cgp_field_read_data(F,B,Z[zones[k]],S[zones[k]],Fu[zones[k]],&min,&max,u) ||
cgp_field_read_data(F,B,Z[zones[k]],S[zones[k]],Fv[zones[k]],&min,&max,v) ||
cgp_field_read_data(F,B,Z[zones[k]],S[zones[k]],Fw[zones[k]],&min,&max,w))
cgp_error_exit();
}
MPI_Barrier(MPI_COMM_WORLD);
t1 = MPI_Wtime();
if(comm_rank==0) {
printf("Solutions Read\n");
printf("\tTime=%lf\n",t1-t0);
printf("\tBandwidth=%lf\n",3.0*data_size/(t1-t0));
}
MPI_Barrier(MPI_COMM_WORLD);
t0 = MPI_Wtime();
for(k=0;k<zpp;k++) {
min = subzones[k]*Nl+1;
max = (subzones[k]+1)*Nl;
if (cg_goto(F,B,"Zone_t",Z[zones[k]],
"UserDefinedData_t",1,NULL) ||
cgp_array_read_data(A[zones[k]],&min,&max,h))
cgp_error_exit();
}
MPI_Barrier(MPI_COMM_WORLD);
t1 = MPI_Wtime();
if(comm_rank==0) {
printf("Arrays Read\n");
printf("\tTime=%lf\n",t1-t0);
printf("\tBandwidth=%lf\n",data_size/(t1-t0));
}
MPI_Barrier(MPI_COMM_WORLD);
t0 = MPI_Wtime();
for(k=0;k<zpp;k++) {
min = subzones[k]*Nl+1;
max = (subzones[k]+1)*Nl;
if (cgp_elements_read_data(F,B,Z[zones[k]],E[zones[k]],min,max,e))
cgp_error_exit();
}
MPI_Barrier(MPI_COMM_WORLD);
t1 = MPI_Wtime();
if(comm_rank==0) {
printf("Elements Read\n");
printf("\tTime=%lf\n",t1-t0);
printf("\tBandwidth=%lf\n",((double) sizeof(int))/((double) sizeof(double))*data_size/(t1-t0));
}
MPI_Barrier(MPI_COMM_WORLD);
Tr1 = MPI_Wtime();
if(comm_rank==0) {
printf("Total Read Time=%lf\n",Tr1-Tr0);
printf("Total Read Bandwidth=%lf\n",(6.0+((double) sizeof(int))/((double) sizeof(double)))*data_size/(Tr1-Tr0));
}
MPI_Barrier(MPI_COMM_WORLD);
t0 = MPI_Wtime();
cgp_close(F);
MPI_Barrier(MPI_COMM_WORLD);
t1 = MPI_Wtime();
if(comm_rank==0) printf("Close_Time=%lf\n",t1-t0);
MPI_Barrier(MPI_COMM_WORLD);
T1 = MPI_Wtime();
if(comm_rank==0) {
printf("Total Time=%lf\n",T1-T0);
}
finalize();
return 0;
}
Shared::Shared()
{
m_supported_element_types.reserve(9);
m_supported_element_types.push_back("cf3.mesh.LagrangeP1.Line1D");
m_supported_element_types.push_back("cf3.mesh.LagrangeP1.Line2D");
m_supported_element_types.push_back("cf3.mesh.LagrangeP1.Line3D");
m_supported_element_types.push_back("cf3.mesh.LagrangeP1.Triag2D");
m_supported_element_types.push_back("cf3.mesh.LagrangeP1.Triag3D");
m_supported_element_types.push_back("cf3.mesh.LagrangeP1.Quad2D");
m_supported_element_types.push_back("cf3.mesh.LagrangeP1.Quad3D");
m_supported_element_types.push_back("cf3.mesh.LagrangeP1.Tetra3D");
m_supported_element_types.push_back("cf3.mesh.LagrangeP1.Hexa3D");
m_elemtype_CGNS_to_CF[CGNS_ENUMV( BAR_2 ) ] = "cf3.mesh.LagrangeP1.Line";
m_elemtype_CGNS_to_CF[CGNS_ENUMV( TRI_3 ) ] = "cf3.mesh.LagrangeP1.Triag";
m_elemtype_CGNS_to_CF[CGNS_ENUMV( QUAD_4) ] = "cf3.mesh.LagrangeP1.Quad";
m_elemtype_CGNS_to_CF[CGNS_ENUMV( TETRA_4)] = "cf3.mesh.LagrangeP1.Tetra";
m_elemtype_CGNS_to_CF[CGNS_ENUMV( HEXA_8 )] = "cf3.mesh.LagrangeP1.Hexa";
m_elemtype_CF3_to_CGNS["cf3.mesh.LagrangeP1.Line1D" ] = CGNS_ENUMV( BAR_2 );
m_elemtype_CF3_to_CGNS["cf3.mesh.LagrangeP1.Line2D" ] = CGNS_ENUMV( BAR_2 );
m_elemtype_CF3_to_CGNS["cf3.mesh.LagrangeP1.Line3D" ] = CGNS_ENUMV( BAR_2 );
m_elemtype_CF3_to_CGNS["cf3.mesh.LagrangeP1.Triag2D"] = CGNS_ENUMV( TRI_3 );
m_elemtype_CF3_to_CGNS["cf3.mesh.LagrangeP1.Triag3D"] = CGNS_ENUMV( TRI_3 );
m_elemtype_CF3_to_CGNS["cf3.mesh.LagrangeP1.Quad2D" ] = CGNS_ENUMV( QUAD_4 );
m_elemtype_CF3_to_CGNS["cf3.mesh.LagrangeP1.Quad3D" ] = CGNS_ENUMV( QUAD_4 );
m_elemtype_CF3_to_CGNS["cf3.mesh.LagrangeP1.Tetra3D"] = CGNS_ENUMV( TETRA_4 );
m_elemtype_CF3_to_CGNS["cf3.mesh.LagrangeP1.Hexa3D" ] = CGNS_ENUMV( HEXA_8 );
}
static void compute_solution (int nz)
{
int n, nf, loc[5], con[5];
double vel2;
SOLUTION *sol = &Zones[nz].sols[usesol-1];
for (n = 0; n < 5; n++)
loc[n] = -1;
for (nf = 0; nf < sol->nflds; nf++) {
if (!strcmp (sol->flds[nf].name, "Density")) {
loc[0] = nf;
con[0] = 0;
}
else if (!strcmp (sol->flds[nf].name, "VelocityX")) {
if (loc[1] >= 0) continue;
loc[1] = nf;
con[1] = 1;
}
else if (!strcmp (sol->flds[nf].name, "MomentumX")) {
loc[1] = nf;
con[1] = 0;
}
else if (!strcmp (sol->flds[nf].name, "VelocityY")) {
if (loc[2] >= 0) continue;
loc[2] = nf;
con[2] = 1;
}
else if (!strcmp (sol->flds[nf].name, "MomentumY")) {
loc[2] = nf;
con[2] = 0;
}
else if (!strcmp (sol->flds[nf].name, "VelocityZ")) {
if (loc[3] >= 0) continue;
loc[3] = nf;
con[3] = 1;
}
else if (!strcmp (sol->flds[nf].name, "MomentumZ")) {
loc[3] = nf;
con[3] = 0;
}
else if (!strcmp (sol->flds[nf].name, "Pressure")) {
if (loc[4] >= 0) continue;
loc[4] = nf;
con[4] = 1;
}
else if (!strcmp (sol->flds[nf].name, "EnergyStagnationDensity")) {
loc[4] = nf;
con[4] = 0;
}
else
continue;
read_solution_field (nz+1, usesol, nf+1);
}
if (sol->location != CGNS_ENUMV(Vertex))
cell_vertex_solution (nz+1, usesol, weighting);
for (nf = 0; nf < 5; nf++) {
for (n = 0; n < sol->size; n++)
q[nf][n] = sol->flds[loc[nf]].data[n];
}
for (nf = 1; nf <= 3; nf++) {
if (con[nf]) {
for (n = 0; n < sol->size; n++)
q[nf][n] *= q[0][n];
}
}
if (con[4]) {
for (n = 0; n < sol->size; n++) {
vel2 = 0.0;
for (nf = 1; nf <= 3; nf++)
vel2 += (q[nf][n] * q[nf][n]);
q[4][n] = q[4][n] / (gamma - 1.0) + 0.5 * vel2 / q[0][n];
}
}
}
static void write_q_binary (char *qfile)
{
int i, j, n, k, nk, nz, np, dim[3];
float qf[4];
FILE *fp;
printf ("\nwriting binary Q file to %s\n", qfile);
printf (" in %s-precision\n", use_double ? "double" : "single");
if (NULL == (fp = fopen (qfile, "w+b"))) {
fprintf (stderr, "couldn't open <%s> for writing\n", qfile);
exit (1);
}
if (mblock || nblocks > 1)
fwrite (&nblocks, sizeof(int), 1, fp);
for (nz = 0; nz < nZones; nz++) {
if (Zones[nz].type == CGNS_ENUMV(Structured)) {
for (i = 0; i < 3; i++)
dim[i] = (int)Zones[nz].dim[i];
fwrite (dim, sizeof(int), 3, fp);
}
}
for (nz = 0; nz < nZones; nz++) {
if (Zones[nz].type == CGNS_ENUMV(Structured)) {
printf (" zone %d ... ", nz+1);
fflush (stdout);
compute_solution (nz);
if (whole) {
np = (int)Zones[nz].nverts;
nk = 1;
}
else {
np = (int)(Zones[nz].dim[0] * Zones[nz].dim[1]);
nk = (int)Zones[nz].dim[2];
}
if (use_double) {
fwrite (reference, sizeof(double), 4, fp);
for (k = 0; k < nk; k++) {
for (i = 0; i < 5; i++)
fwrite (&q[i][k*np], sizeof(double), np, fp);
}
}
else {
for (n = 0; n < 4; n++)
qf[n] = (float)reference[n];
fwrite (qf, sizeof(float), 4, fp);
for (k = 0; k < nk; k++) {
for (i = 0; i < 5; i++) {
j = k * np;
for (n = 0; n < np; n++, j++) {
qf[0] = (float)q[i][j];
fwrite (qf, sizeof(float), 1, fp);
}
}
}
}
puts ("done");
}
}
fclose (fp);
}
static void write_q_unformatted (char *qfile)
{
int np, nk, nz, nq, ierr;
int i, j, k, n, *indices;
char buff[129];
void *qdata;
float *qf = 0;
double *qd = 0;
printf ("\nwriting unformatted Q file to %s\n", qfile);
printf (" in %s-precision\n", use_double ? "double" : "single");
for (np = 0, nz = 0; nz < nZones; nz++) {
if (Zones[nz].type == CGNS_ENUMV(Structured)) {
nk = whole ? (int)Zones[nz].nverts :
(int)(Zones[nz].dim[0] * Zones[nz].dim[1]);
if (np < nk) np = nk;
}
}
indices = (int *) malloc (3 * nblocks * sizeof(int));
if (use_double) {
qdata = (void *) malloc (5 * np * sizeof(double));
qd = (double *)qdata;
}
else {
qdata = (void *) malloc (5 * np * sizeof(float));
qf = (float *)qdata;
}
if (NULL == indices || NULL == qdata)
FATAL ("write_q_unformatted", "malloc failed for working arrays");
unlink (qfile);
strcpy (buff, qfile);
for (n = (int)strlen(buff); n < 128; n++)
buff[n] = ' ';
buff[128] = 0;
n = 0;
OPENF (&n, buff, 128);
if (mblock || nblocks > 1) {
n = 1;
WRITEIF (&n, &nblocks, &ierr);
}
for (np = 0, nz = 0; nz < nZones; nz++) {
if (Zones[nz].type == CGNS_ENUMV(Structured)) {
for (n = 0; n < 3; n++)
indices[np++] = (int)Zones[nz].dim[n];
}
}
WRITEIF (&np, indices, &ierr);
for (nz = 0; nz < nZones; nz++) {
if (Zones[nz].type == CGNS_ENUMV(Structured)) {
printf (" zone %d ... ", nz+1);
fflush (stdout);
compute_solution (nz);
if (whole) {
np = (int)Zones[nz].nverts;
nk = 1;
}
else {
np = (int)(Zones[nz].dim[0] * Zones[nz].dim[1]);
nk = (int)Zones[nz].dim[2];
}
if (use_double) {
n = 4;
WRITEDF (&n, reference, &ierr);
for (k = 0; k < nk; k++) {
for (nq = 0, j = 0; j < 5; j++) {
i = k * np;
for (n = 0; n < np; n++, i++)
qd[nq++] = q[j][i];
}
WRITEDF (&nq, qd, &ierr);
}
}
else {
for (n = 0; n < 4; n++)
qf[n] = (float)reference[n];
WRITEFF (&n, qf, &ierr);
for (k = 0; k < nk; k++) {
for (nq = 0, j = 0; j < 5; j++) {
i = k * np;
for (n = 0; n < np; n++, i++)
qf[nq++] = (float)q[j][i];
}
WRITEFF (&nq, qf, &ierr);
}
}
puts ("done");
}
}
CLOSEF ();
free (indices);
free (qdata);
}
int main (int argc, char *argv[])
{
int i, n, ib, nb, nz, nv, celldim, phydim;
int nn, type, *elems = 0, idata[5];
cgsize_t ne;
char *p, basename[33], title[65];
float value, *var;
SOLUTION *sol;
FILE *fp;
if (argc < 2)
print_usage (usgmsg, NULL);
ib = 0;
basename[0] = 0;
while ((n = getargs (argc, argv, options)) > 0) {
switch (n) {
case 'a':
ascii = 1;
break;
case 'b':
ib = atoi (argarg);
break;
case 'B':
strncpy (basename, argarg, 32);
basename[32] = 0;
break;
case 'w':
weighting = 1;
break;
case 'S':
usesol = atoi (argarg);
break;
}
}
if (argind > argc - 2)
print_usage (usgmsg, "CGNSfile and/or Tecplotfile not given");
if (!file_exists (argv[argind]))
FATAL (NULL, "CGNSfile does not exist or is not a file");
/* open CGNS file */
printf ("reading CGNS file from %s\n", argv[argind]);
nb = open_cgns (argv[argind], 1);
if (!nb)
FATAL (NULL, "no bases found in CGNS file");
if (*basename && 0 == (ib = find_base (basename)))
FATAL (NULL, "specified base not found");
if (ib > nb) FATAL (NULL, "base index out of range");
cgnsbase = ib ? ib : 1;
if (cg_base_read (cgnsfn, cgnsbase, basename, &celldim, &phydim))
FATAL (NULL, NULL);
if (celldim != 3 || phydim != 3)
FATAL (NULL, "cell and physical dimension must be 3");
printf (" using base %d - %s\n", cgnsbase, basename);
if (NULL == (p = strrchr (argv[argind], '/')) &&
NULL == (p = strrchr (argv[argind], '\\')))
strncpy (title, argv[argind], sizeof(title));
else
strncpy (title, ++p, sizeof(title));
title[sizeof(title)-1] = 0;
if ((p = strrchr (title, '.')) != NULL)
*p = 0;
read_zones ();
if (!nZones)
FATAL (NULL, "no zones in the CGNS file");
/* verify dimensions fit in an integer */
for (nz = 0; nz < nZones; nz++) {
if (Zones[nz].nverts > CG_MAX_INT32)
FATAL(NULL, "zone size too large to write with integers");
if (Zones[nz].type == CGNS_ENUMV(Unstructured)) {
count_elements (nz, &ne, &type);
if (ne > CG_MAX_INT32)
FATAL(NULL, "too many elements to write with integers");
}
}
nv = 3 + check_solution ();
/* open Tecplot file */
printf ("writing %s Tecplot data to <%s>\n",
ascii ? "ASCII" : "binary", argv[++argind]);
if (NULL == (fp = fopen (argv[argind], ascii ? "w+" : "w+b")))
FATAL (NULL, "couldn't open Tecplot output file");
/* write file header */
if (ascii)
fprintf (fp, "TITLE = \"%s\"\n", title);
else {
fwrite ("#!TDV75 ", 1, 8, fp);
i = 1;
write_ints (fp, 1, &i);
write_string (fp, title);
}
/* write variables */
if (ascii) {
fprintf (fp, "VARIABLES = \"X\", \"Y\", \"Z\"");
if (usesol) {
sol = Zones->sols;
for (n = 0; n < sol->nflds; n++)
fprintf (fp, ",\n\"%s\"", sol->flds[n].name);
}
}
else {
write_ints (fp, 1, &nv);
write_string (fp, "X");
write_string (fp, "Y");
write_string (fp, "Z");
if (usesol) {
sol = Zones->sols;
for (n = 0; n < sol->nflds; n++)
write_string (fp, sol->flds[n].name);
}
}
/* write zones */
if (!ascii) {
for (nz = 0; nz < nZones; nz++) {
if (Zones[nz].type == CGNS_ENUMV(Structured)) {
idata[0] = 0; /* BLOCK */
idata[1] = -1; /* color not specified */
idata[2] = (int)Zones[nz].dim[0];
idata[3] = (int)Zones[nz].dim[1];
idata[4] = (int)Zones[nz].dim[2];
}
else {
count_elements (nz, &ne, &type);
idata[0] = 2; /* FEBLOCK */
idata[1] = -1; /* color not specified */
idata[2] = (int)Zones[nz].dim[0];
idata[3] = (int)ne;
idata[4] = type;
}
value = 299.0;
write_floats (fp, 1, &value);
write_string (fp, Zones[nz].name);
write_ints (fp, 5, idata);
}
value = 357.0;
write_floats (fp, 1, &value);
}
for (nz = 0; nz < nZones; nz++) {
printf (" zone %d...", nz+1);
fflush (stdout);
read_zone_grid (nz+1);
ne = 0;
type = 2;
nn = (int)Zones[nz].nverts;
var = (float *) malloc (nn * sizeof(float));
if (NULL == var)
FATAL (NULL, "malloc failed for temp float array");
if (Zones[nz].type == CGNS_ENUMV(Unstructured))
elems = volume_elements (nz, &ne, &type);
if (ascii) {
if (Zones[nz].type == CGNS_ENUMV(Structured))
fprintf (fp, "\nZONE T=\"%s\", I=%d, J=%d, K=%d, F=BLOCK\n",
Zones[nz].name, (int)Zones[nz].dim[0],
(int)Zones[nz].dim[1], (int)Zones[nz].dim[2]);
else
fprintf (fp, "\nZONE T=\"%s\", N=%d, E=%d, F=FEBLOCK, ET=%s\n",
Zones[nz].name, nn, (int)ne, type == 2 ? "TETRAHEDRON" : "BRICK");
}
else {
value = 299.0;
write_floats (fp, 1, &value);
i = 0;
write_ints (fp, 1, &i);
i = 1;
for (n = 0; n < nv; n++)
write_ints (fp, 1, &i);
}
for (n = 0; n < nn; n++)
var[n] = (float)Zones[nz].verts[n].x;
write_floats (fp, nn, var);
for (n = 0; n < nn; n++)
var[n] = (float)Zones[nz].verts[n].y;
write_floats (fp, nn, var);
for (n = 0; n < nn; n++)
var[n] = (float)Zones[nz].verts[n].z;
write_floats (fp, nn, var);
if (usesol) {
read_solution_field (nz+1, usesol, 0);
sol = &Zones[nz].sols[usesol-1];
if (sol->location != CGNS_ENUMV(Vertex))
cell_vertex_solution (nz+1, usesol, weighting);
for (nv = 0; nv < sol->nflds; nv++) {
for (n = 0; n < nn; n++)
var[n] = (float)sol->flds[nv].data[n];
write_floats (fp, nn, var);
}
}
free (var);
if (Zones[nz].type == CGNS_ENUMV(Unstructured)) {
if (!ascii) {
i = 0;
write_ints (fp, 1, &i);
}
nn = 1 << type;
for (i = 0, n = 0; n < ne; n++, i += nn)
write_ints (fp, nn, &elems[i]);
free (elems);
}
puts ("done");
}
fclose (fp);
cg_close (cgnsfn);
return 0;
}
static void read_xyz (BINARYIO *bf)
{
int i, k, n, nk, nz, np, nmax;
int *indices, *iblank;
void *xyz;
VERTEX *verts;
/* get number of grid blocks */
if (mblock) {
bf_getints (bf, 1, &nZones);
if (nZones < 1 || nZones > 100000) {
fprintf (stderr, "found %d blocks\n", nZones);
fprintf (stderr, "file type and/or format is probably incorrect\n");
bf_close (bf);
exit (1);
}
}
else
nZones = 1;
printf ("reading %d grid blocks\n", nZones);
/* read indices for grids */
indices = (int *) malloc (3 * nZones * sizeof(int));
if (NULL == indices)
FATAL ("read_xyz", "malloc failed for grid indices");
bf_getints (bf, 3 * nZones, indices);
/* create zone structures */
Zones = new_zone (nZones);
for (nmax = 0, nz = 0; nz < nZones; nz++) {
Zones[nz].type = CGNS_ENUMV(Structured);
for (np = 1, n = 0; n < 3; n++) {
nk = indices[3 * nz + n];
Zones[nz].dim[n] = nk;
np *= nk;
}
Zones[nz].vertflags = 7;
Zones[nz].datatype = is_double ? CGNS_ENUMV(RealDouble) : CGNS_ENUMV(RealSingle);
Zones[nz].nverts = np;
Zones[nz].verts = new_vertex (np);
nk = whole ? (int)Zones[nz].nverts : (int)(Zones[nz].dim[0] * Zones[nz].dim[1]);
if (nmax < nk) nmax = nk;
}
free (indices);
if (is_double)
xyz = (void *) malloc (3 * nmax * sizeof(double));
else
xyz = (void *) malloc (3 * nmax * sizeof(float));
if (NULL == xyz)
FATAL ("read_xyz", "malloc failed for coordinate working array");
if (has_iblank) {
iblank = (int *) malloc (nmax * sizeof(int));
if (NULL == iblank)
FATAL ("read_xyz", "malloc failed for iblank array");
}
else
use_iblank = 0;
/* read the grid blocks */
for (nz = 0; nz < nZones; nz++) {
printf ("reading block %d grid %dx%dx%d ...", nz+1,
(int)Zones[nz].dim[0], (int)Zones[nz].dim[1],
(int)Zones[nz].dim[2]);
fflush (stdout);
if (whole) {
np = (int)Zones[nz].nverts;
nk = 1;
}
else {
np = (int)(Zones[nz].dim[0] * Zones[nz].dim[1]);
nk = (int)Zones[nz].dim[2];
}
verts = Zones[nz].verts;
for (k = 0; k < nk; k++) {
if (is_double)
bf_getdoubles (bf, 3 * np, xyz);
else
bf_getfloats (bf, 3 * np, xyz);
if (has_iblank)
bf_getints (bf, np, iblank);
if (is_double) {
for (i = 0, n = 0; n < np; n++, i++)
verts[n].x = ((double *)xyz)[i];
for (n = 0; n < np; n++, i++)
verts[n].y = ((double *)xyz)[i];
for (n = 0; n < np; n++, i++)
verts[n].z = ((double *)xyz)[i];
}
else {
for (i = 0, n = 0; n < np; n++, i++)
verts[n].x = ((float *)xyz)[i];
for (n = 0; n < np; n++, i++)
verts[n].y = ((float *)xyz)[i];
for (n = 0; n < np; n++, i++)
verts[n].z = ((float *)xyz)[i];
}
for (n = 0; n < np; n++, verts++)
verts->id = use_iblank ? iblank[n] : 1;
}
puts (" done");
}
free (xyz);
if (has_iblank) free (iblank);
}
