int main() { int index_file,index_base,index_zone,nbocos,ib; int normalindex[3],ndataset; int i,normallist; char boconame[33]; BCType_t ibocotype; PointSetType_t iptset; DataType_t normaldatatype; cgsize_t npts,normallistflag; cgsize_t ipnts[maxpnts][3]; /* READ BOUNDARY CONDITIONS FROM EXISTING CGNS FILE */ /* open CGNS file for read-only */ if (cg_open("grid_c.cgns",CG_MODE_READ,&index_file)) cg_error_exit(); /* we know there is only one base (real working code would check!) */ index_base=1; /* we know there is only one zone (real working code would check!) */ index_zone=1; /* find out number of BCs that exist under this zone */ cg_nbocos(index_file,index_base,index_zone,&nbocos); /* do loop over the total number of BCs */ for (ib=1; ib <= nbocos; ib++) { /* get BC info */ cg_boco_info(index_file,index_base,index_zone,ib,boconame,&ibocotype, &iptset,&npts,normalindex,&normallistflag,&normaldatatype,&ndataset); if (iptset != PointList) { printf("\nError. For this program, BCs must be set up as PointList type %s\n", PointSetTypeName[iptset]); return 1; } printf("\nBC number: %i\n",ib); printf(" name= %s\n",boconame); printf(" type= %s\n",BCTypeName[ibocotype]); printf(" no of pts= %i\n",(int)npts); if (npts > maxpnts) { printf("\nError. Must increase maxpnts to at least %i\n",(int)npts); return 1; } /* read point list in here (nothing done with them in this program) */ cg_boco_read(index_file,index_base,index_zone,ib,ipnts[0],&normallist); printf(" (these points read here, but only some printed out:)\n"); for (i=0; i < 10; i++) { printf(" ipnts[%i][0], [%i][1], [%i][2]=%i,%i,%i\n", i,i,i,(int)ipnts[i][0],(int)ipnts[i][1],(int)ipnts[i][2]); } } /* close CGNS file */ cg_close(index_file); printf("\nSuccessfully read BCs (PointList format) from file grid_c.cgns\n"); 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; }
/*@ DMPlexCreateCGNS - Create a DMPlex mesh from a CGNS file ID. Collective on comm Input Parameters: + comm - The MPI communicator . cgid - The CG id associated with a file and obtained using cg_open - interpolate - Create faces and edges in the mesh Output Parameter: . dm - The DM object representing the mesh Note: http://www.grc.nasa.gov/WWW/cgns/CGNS_docs_current/index.html Level: beginner .keywords: mesh,CGNS .seealso: DMPlexCreate(), DMPlexCreateExodus() @*/ PetscErrorCode DMPlexCreateCGNS(MPI_Comm comm, PetscInt cgid, PetscBool interpolate, DM *dm) { #if defined(PETSC_HAVE_CGNS) PetscMPIInt num_proc, rank; PetscSection coordSection; Vec coordinates; PetscScalar *coords; PetscInt *cellStart, *vertStart; PetscInt coordSize, v; PetscErrorCode ierr; /* Read from file */ char basename[CGIO_MAX_NAME_LENGTH+1]; char buffer[CGIO_MAX_NAME_LENGTH+1]; int dim = 0, physDim = 0, numVertices = 0, numCells = 0; int nzones = 0; #endif PetscFunctionBegin; #if defined(PETSC_HAVE_CGNS) ierr = MPI_Comm_rank(comm, &rank);CHKERRQ(ierr); ierr = MPI_Comm_size(comm, &num_proc);CHKERRQ(ierr); ierr = DMCreate(comm, dm);CHKERRQ(ierr); ierr = DMSetType(*dm, DMPLEX);CHKERRQ(ierr); /* Open CGNS II file and read basic informations on rank 0, then broadcast to all processors */ if (!rank) { int nbases, z; ierr = cg_nbases(cgid, &nbases);CHKERRQ(ierr); if (nbases > 1) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_LIB,"CGNS file must have a single base, not %d\n",nbases); ierr = cg_base_read(cgid, 1, basename, &dim, &physDim);CHKERRQ(ierr); ierr = cg_nzones(cgid, 1, &nzones);CHKERRQ(ierr); ierr = PetscCalloc2(nzones+1, &cellStart, nzones+1, &vertStart);CHKERRQ(ierr); for (z = 1; z <= nzones; ++z) { cgsize_t sizes[3]; /* Number of vertices, number of cells, number of boundary vertices */ ierr = cg_zone_read(cgid, 1, z, buffer, sizes);CHKERRQ(ierr); numVertices += sizes[0]; numCells += sizes[1]; cellStart[z] += sizes[1] + cellStart[z-1]; vertStart[z] += sizes[0] + vertStart[z-1]; } for (z = 1; z <= nzones; ++z) { vertStart[z] += numCells; } } ierr = MPI_Bcast(basename, CGIO_MAX_NAME_LENGTH+1, MPI_CHAR, 0, comm);CHKERRQ(ierr); ierr = MPI_Bcast(&dim, 1, MPI_INT, 0, comm);CHKERRQ(ierr); ierr = MPI_Bcast(&nzones, 1, MPI_INT, 0, comm);CHKERRQ(ierr); ierr = PetscObjectSetName((PetscObject) *dm, basename);CHKERRQ(ierr); ierr = DMSetDimension(*dm, dim);CHKERRQ(ierr); ierr = DMPlexSetChart(*dm, 0, numCells+numVertices);CHKERRQ(ierr); /* Read zone information */ if (!rank) { int z, c, c_loc, v, v_loc; /* Read the cell set connectivity table and build mesh topology CGNS standard requires that cells in a zone be numbered sequentially and be pairwise disjoint. */ /* First set sizes */ for (z = 1, c = 0; z <= nzones; ++z) { ZoneType_t zonetype; int nsections; ElementType_t cellType; cgsize_t start, end; int nbndry, parentFlag; PetscInt numCorners; ierr = cg_zone_type(cgid, 1, z, &zonetype);CHKERRQ(ierr); if (zonetype == Structured) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_LIB,"Can only handle Unstructured zones for CGNS"); ierr = cg_nsections(cgid, 1, z, &nsections);CHKERRQ(ierr); if (nsections > 1) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_LIB,"CGNS file must have a single section, not %d\n",nsections); ierr = cg_section_read(cgid, 1, z, 1, buffer, &cellType, &start, &end, &nbndry, &parentFlag);CHKERRQ(ierr); /* This alone is reason enough to bludgeon every single CGNDS developer, this must be what they describe as the "idiocy of crowds" */ if (cellType == MIXED) { cgsize_t elementDataSize, *elements; PetscInt off; ierr = cg_ElementDataSize(cgid, 1, z, 1, &elementDataSize);CHKERRQ(ierr); ierr = PetscMalloc1(elementDataSize, &elements);CHKERRQ(ierr); ierr = cg_elements_read(cgid, 1, z, 1, elements, NULL);CHKERRQ(ierr); for (c_loc = start, off = 0; c_loc <= end; ++c_loc, ++c) { switch (elements[off]) { case TRI_3: numCorners = 3;break; case QUAD_4: numCorners = 4;break; case TETRA_4: numCorners = 4;break; case HEXA_8: numCorners = 8;break; default: SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Invalid cell type %d", (int) elements[off]); } ierr = DMPlexSetConeSize(*dm, c, numCorners);CHKERRQ(ierr); off += numCorners+1; } ierr = PetscFree(elements);CHKERRQ(ierr); } else { switch (cellType) { case TRI_3: numCorners = 3;break; case QUAD_4: numCorners = 4;break; case TETRA_4: numCorners = 4;break; case HEXA_8: numCorners = 8;break; default: SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Invalid cell type %d", (int) cellType); } for (c_loc = start; c_loc <= end; ++c_loc, ++c) { ierr = DMPlexSetConeSize(*dm, c, numCorners);CHKERRQ(ierr); } } } ierr = DMSetUp(*dm);CHKERRQ(ierr); for (z = 1, c = 0; z <= nzones; ++z) { ElementType_t cellType; cgsize_t *elements, elementDataSize, start, end; int nbndry, parentFlag; PetscInt *cone, numc, numCorners, maxCorners = 27; ierr = cg_section_read(cgid, 1, z, 1, buffer, &cellType, &start, &end, &nbndry, &parentFlag);CHKERRQ(ierr); numc = end - start; /* This alone is reason enough to bludgeon every single CGNDS developer, this must be what they describe as the "idiocy of crowds" */ ierr = cg_ElementDataSize(cgid, 1, z, 1, &elementDataSize);CHKERRQ(ierr); ierr = PetscMalloc2(elementDataSize,&elements,maxCorners,&cone);CHKERRQ(ierr); ierr = cg_elements_read(cgid, 1, z, 1, elements, NULL);CHKERRQ(ierr); if (cellType == MIXED) { /* CGNS uses Fortran-based indexing, sieve uses C-style and numbers cell first then vertices. */ for (c_loc = 0, v = 0; c_loc <= numc; ++c_loc, ++c) { switch (elements[v]) { case TRI_3: numCorners = 3;break; case QUAD_4: numCorners = 4;break; case TETRA_4: numCorners = 4;break; case HEXA_8: numCorners = 8;break; default: SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Invalid cell type %d", (int) elements[v]); } ++v; for (v_loc = 0; v_loc < numCorners; ++v_loc, ++v) { cone[v_loc] = elements[v]+numCells-1; } /* Tetrahedra are inverted */ if (elements[v] == TETRA_4) { PetscInt tmp = cone[0]; cone[0] = cone[1]; cone[1] = tmp; } /* Hexahedra are inverted */ if (elements[v] == HEXA_8) { PetscInt tmp = cone[5]; cone[5] = cone[7]; cone[7] = tmp; } ierr = DMPlexSetCone(*dm, c, cone);CHKERRQ(ierr); ierr = DMPlexSetLabelValue(*dm, "zone", c, z);CHKERRQ(ierr); } } else { switch (cellType) { case TRI_3: numCorners = 3;break; case QUAD_4: numCorners = 4;break; case TETRA_4: numCorners = 4;break; case HEXA_8: numCorners = 8;break; default: SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Invalid cell type %d", (int) cellType); } /* CGNS uses Fortran-based indexing, sieve uses C-style and numbers cell first then vertices. */ for (c_loc = 0, v = 0; c_loc <= numc; ++c_loc, ++c) { for (v_loc = 0; v_loc < numCorners; ++v_loc, ++v) { cone[v_loc] = elements[v]+numCells-1; } /* Tetrahedra are inverted */ if (cellType == TETRA_4) { PetscInt tmp = cone[0]; cone[0] = cone[1]; cone[1] = tmp; } /* Hexahedra are inverted, and they give the top first */ if (cellType == HEXA_8) { PetscInt tmp = cone[5]; cone[5] = cone[7]; cone[7] = tmp; } ierr = DMPlexSetCone(*dm, c, cone);CHKERRQ(ierr); ierr = DMPlexSetLabelValue(*dm, "zone", c, z);CHKERRQ(ierr); } } ierr = PetscFree2(elements,cone);CHKERRQ(ierr); } } ierr = DMPlexSymmetrize(*dm);CHKERRQ(ierr); ierr = DMPlexStratify(*dm);CHKERRQ(ierr); if (interpolate) { DM idm = NULL; ierr = DMPlexInterpolate(*dm, &idm);CHKERRQ(ierr); /* Maintain zone label */ { DMLabel label; ierr = DMPlexRemoveLabel(*dm, "zone", &label);CHKERRQ(ierr); if (label) {ierr = DMPlexAddLabel(idm, label);CHKERRQ(ierr);} } ierr = DMDestroy(dm);CHKERRQ(ierr); *dm = idm; } /* Read coordinates */ ierr = DMGetCoordinateSection(*dm, &coordSection);CHKERRQ(ierr); ierr = PetscSectionSetNumFields(coordSection, 1);CHKERRQ(ierr); ierr = PetscSectionSetFieldComponents(coordSection, 0, dim);CHKERRQ(ierr); ierr = PetscSectionSetChart(coordSection, numCells, numCells + numVertices);CHKERRQ(ierr); for (v = numCells; v < numCells+numVertices; ++v) { ierr = PetscSectionSetDof(coordSection, v, dim);CHKERRQ(ierr); ierr = PetscSectionSetFieldDof(coordSection, v, 0, dim);CHKERRQ(ierr); } ierr = PetscSectionSetUp(coordSection);CHKERRQ(ierr); ierr = PetscSectionGetStorageSize(coordSection, &coordSize);CHKERRQ(ierr); ierr = VecCreate(comm, &coordinates);CHKERRQ(ierr); ierr = PetscObjectSetName((PetscObject) coordinates, "coordinates");CHKERRQ(ierr); ierr = VecSetSizes(coordinates, coordSize, PETSC_DETERMINE);CHKERRQ(ierr); ierr = VecSetType(coordinates,VECSTANDARD);CHKERRQ(ierr); ierr = VecGetArray(coordinates, &coords);CHKERRQ(ierr); if (!rank) { PetscInt off = 0; float *x[3]; int z, d; ierr = PetscMalloc3(numVertices,&x[0],numVertices,&x[1],numVertices,&x[2]);CHKERRQ(ierr); for (z = 1; z <= nzones; ++z) { DataType_t datatype; cgsize_t sizes[3]; /* Number of vertices, number of cells, number of boundary vertices */ cgsize_t range_min[3] = {1, 1, 1}; cgsize_t range_max[3] = {1, 1, 1}; int ngrids, ncoords; ierr = cg_zone_read(cgid, 1, z, buffer, sizes);CHKERRQ(ierr); range_max[0] = sizes[0]; ierr = cg_ngrids(cgid, 1, z, &ngrids);CHKERRQ(ierr); if (ngrids > 1) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_LIB,"CGNS file must have a single grid, not %d\n",ngrids); ierr = cg_ncoords(cgid, 1, z, &ncoords);CHKERRQ(ierr); if (ncoords != dim) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_LIB,"CGNS file must have a coordinate array for each dimension, not %d\n",ncoords); for (d = 0; d < dim; ++d) { ierr = cg_coord_info(cgid, 1, z, 1+d, &datatype, buffer);CHKERRQ(ierr); ierr = cg_coord_read(cgid, 1, z, buffer, RealSingle, range_min, range_max, x[d]);CHKERRQ(ierr); } if (dim > 0) { for (v = 0; v < sizes[0]; ++v) coords[(v+off)*dim+0] = x[0][v]; } if (dim > 1) { for (v = 0; v < sizes[0]; ++v) coords[(v+off)*dim+1] = x[1][v]; } if (dim > 2) { for (v = 0; v < sizes[0]; ++v) coords[(v+off)*dim+2] = x[2][v]; } off += sizes[0]; } ierr = PetscFree3(x[0],x[1],x[2]);CHKERRQ(ierr); } ierr = VecRestoreArray(coordinates, &coords);CHKERRQ(ierr); ierr = DMSetCoordinatesLocal(*dm, coordinates);CHKERRQ(ierr); ierr = VecDestroy(&coordinates);CHKERRQ(ierr); /* Read boundary conditions */ if (!rank) { DMLabel label; BCType_t bctype; DataType_t datatype; PointSetType_t pointtype; cgsize_t *points; PetscReal *normals; int normal[3]; char *bcname = buffer; cgsize_t npoints, nnormals; int z, nbc, bc, c, ndatasets; for (z = 1; z <= nzones; ++z) { ierr = cg_nbocos(cgid, 1, z, &nbc);CHKERRQ(ierr); for (bc = 1; bc <= nbc; ++bc) { ierr = cg_boco_info(cgid, 1, z, bc, bcname, &bctype, &pointtype, &npoints, normal, &nnormals, &datatype, &ndatasets);CHKERRQ(ierr); ierr = DMPlexCreateLabel(*dm, bcname);CHKERRQ(ierr); ierr = DMPlexGetLabel(*dm, bcname, &label);CHKERRQ(ierr); ierr = PetscMalloc2(npoints, &points, nnormals, &normals);CHKERRQ(ierr); ierr = cg_boco_read(cgid, 1, z, bc, points, (void *) normals);CHKERRQ(ierr); if (pointtype == ElementRange) { /* Range of cells: assuming half-open interval since the documentation sucks */ for (c = points[0]; c < points[1]; ++c) { ierr = DMLabelSetValue(label, c - cellStart[z-1], 1);CHKERRQ(ierr); } } else if (pointtype == ElementList) { /* List of cells */ for (c = 0; c < npoints; ++c) { ierr = DMLabelSetValue(label, points[c] - cellStart[z-1], 1);CHKERRQ(ierr); } } else if (pointtype == PointRange) { GridLocation_t gridloc; /* List of points: Oh please, someone get the CGNS developers away from a computer. This is unconscionable. */ ierr = cg_goto(cgid, 1, "Zone_t", z, "BC_t", bc, "end");CHKERRQ(ierr); ierr = cg_gridlocation_read(&gridloc);CHKERRQ(ierr); /* Range of points: assuming half-open interval since the documentation sucks */ for (c = points[0]; c < points[1]; ++c) { if (gridloc == Vertex) {ierr = DMLabelSetValue(label, c - vertStart[z-1], 1);CHKERRQ(ierr);} else {ierr = DMLabelSetValue(label, c - cellStart[z-1], 1);CHKERRQ(ierr);} } } else if (pointtype == PointList) { GridLocation_t gridloc; /* List of points: Oh please, someone get the CGNS developers away from a computer. This is unconscionable. */ ierr = cg_goto(cgid, 1, "Zone_t", z, "BC_t", bc, "end"); ierr = cg_gridlocation_read(&gridloc); for (c = 0; c < npoints; ++c) { if (gridloc == Vertex) {ierr = DMLabelSetValue(label, points[c] - vertStart[z-1], 1);CHKERRQ(ierr);} else {ierr = DMLabelSetValue(label, points[c] - cellStart[z-1], 1);CHKERRQ(ierr);} } } else SETERRQ1(comm, PETSC_ERR_SUP, "Unsupported point set type %d", (int) pointtype); ierr = PetscFree2(points, normals);CHKERRQ(ierr); } } ierr = PetscFree2(cellStart, vertStart);CHKERRQ(ierr); } #else SETERRQ(comm, PETSC_ERR_SUP, "This method requires CGNS support. Reconfigure using --with-cgns-dir"); #endif PetscFunctionReturn(0); }