int main()
{
float x[21*17*9],y[21*17*9],z[21*17*9];
cgsize_t isize[3][1],ielem[20*16*8][8];
int index_file,index_base,index_zone;
cgsize_t irmin,irmax,istart,iend;
int nsections,index_sect,nbndry,iparent_flag;
cgsize_t iparentdata;
char zonename[33],sectionname[33];
ElementType_t itype;
/* READ X, Y, Z GRID POINTS FROM 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;
/* get zone size (and name - although not needed here) */
cg_zone_read(index_file,index_base,index_zone,zonename,isize[0]);
/* lower range index */
irmin=1;
/* upper range index of vertices */
irmax=isize[0][0];
/* read grid coordinates */
cg_coord_read(index_file,index_base,index_zone,"CoordinateX",
RealSingle,&irmin,&irmax,x);
cg_coord_read(index_file,index_base,index_zone,"CoordinateY",
RealSingle,&irmin,&irmax,y);
cg_coord_read(index_file,index_base,index_zone,"CoordinateZ",
RealSingle,&irmin,&irmax,z);
/* find out how many sections */
cg_nsections(index_file,index_base,index_zone,&nsections);
printf("\nnumber of sections=%i\n",nsections);
/* read element connectivity */
for (index_sect=1; index_sect <= nsections; index_sect++)
{
cg_section_read(index_file,index_base,index_zone,index_sect,sectionname,
&itype,&istart,&iend,&nbndry,&iparent_flag);
printf("\nReading section data...\n");
printf(" section name=%s\n",sectionname);
printf(" section type=%s\n",ElementTypeName[itype]);
printf(" istart,iend=%i, %i\n",(int)istart,(int)iend);
if (itype == HEXA_8)
{
printf(" reading element data for this element\n");
cg_elements_read(index_file,index_base,index_zone,index_sect,ielem[0], \
&iparentdata);
}
else
{
printf(" not reading element data for this element\n");
}
}
/* close CGNS file */
cg_close(index_file);
printf("\nSuccessfully read unstructured grid from file grid_c.cgns\n");
printf(" for example, element 1 is made up of nodes: %i, %i, %i, %i, %i, %i, %i, %i\n",
(int)ielem[0][0],(int)ielem[0][1],(int)ielem[0][2],(int)ielem[0][3],
(int)ielem[0][4],(int)ielem[0][5],(int)ielem[0][6],(int)ielem[0][7]);
printf(" x,y,z of node 357 are: %f, %f, %f\n",x[357],y[357],z[357]);
printf(" x,y,z of node 1357 are: %f, %f, %f\n",x[1357],y[1357],z[1357]);
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);
}
ErrorCode ReadCGNS::load_file(const char* filename,
const EntityHandle * /*file_set*/,
const FileOptions& opts,
const ReaderIface::SubsetList* subset_list,
const Tag* file_id_tag)
{
int num_material_sets = 0;
const int* material_set_list = 0;
if (subset_list) {
if (subset_list->tag_list_length > 1 &&
!strcmp(subset_list->tag_list[0].tag_name, MATERIAL_SET_TAG_NAME)) {
MB_SET_ERR(MB_UNSUPPORTED_OPERATION, "CGNS supports subset read only by material ID");
}
material_set_list = subset_list->tag_list[0].tag_values;
num_material_sets = subset_list->tag_list[0].num_tag_values;
}
ErrorCode result;
geomSets.clear();
result = mbImpl->tag_get_handle(GLOBAL_ID_TAG_NAME, 1, MB_TYPE_INTEGER,
globalId, MB_TAG_DENSE | MB_TAG_CREAT, 0);
if (MB_SUCCESS != result)
return result;
// Create set for more convienient check for material set ids
std::set<int> blocks;
for (const int* mat_set_end = material_set_list + num_material_sets;
material_set_list != mat_set_end; ++material_set_list)
blocks.insert(*material_set_list);
// Map of ID->handle for nodes
std::map<long, EntityHandle> node_id_map;
// Save filename to member variable so we don't need to pass as an argument
// to called functions
fileName = filename;
// Process options; see src/FileOptions.hpp for API for FileOptions class, and doc/metadata_info.doc for
// a description of various options used by some of the readers in MOAB
result = process_options(opts);MB_CHK_SET_ERR(result, fileName << ": problem reading options");
// Open file
int filePtr = 0;
cg_open(filename, CG_MODE_READ, &filePtr);
if (filePtr <= 0) {
MB_SET_ERR(MB_FILE_DOES_NOT_EXIST, fileName << ": fopen returned error");
}
// Read number of verts, elements, sets
long num_verts = 0, num_elems = 0, num_sets = 0;
int num_bases = 0, num_zones = 0, num_sections = 0;
char zoneName[128];
cgsize_t size[3];
mesh_dim = 3; // Default to 3D
// Read number of bases;
cg_nbases(filePtr, &num_bases);
if (num_bases > 1) {
MB_SET_ERR(MB_NOT_IMPLEMENTED, fileName << ": support for number of bases > 1 not implemented");
}
for (int indexBase = 1; indexBase <= num_bases; ++indexBase) {
// Get the number of zones/blocks in current base.
cg_nzones(filePtr, indexBase, &num_zones);
if (num_zones > 1) {
MB_SET_ERR(MB_NOT_IMPLEMENTED, fileName << ": support for number of zones > 1 not implemented");
}
for (int indexZone = 1; indexZone <= num_zones; ++indexZone) {
// Get zone name and size.
cg_zone_read(filePtr, indexBase, indexZone, zoneName, size);
// Read number of sections/Parts in current zone.
cg_nsections(filePtr, indexBase, indexZone, &num_sections);
num_verts = size[0];
num_elems = size[1];
num_sets = num_sections;
std::cout << "\nnumber of nodes = " << num_verts;
std::cout << "\nnumber of elems = " << num_elems;
std::cout << "\nnumber of parts = " << num_sets << std::endl;
// //////////////////////////////////
// Read Nodes
// Allocate nodes; these are allocated in one shot, get contiguous handles starting with start_handle,
// and the reader is passed back double*'s pointing to MOAB's native storage for vertex coordinates
// for those verts
std::vector<double*> coord_arrays;
EntityHandle handle = 0;
result = readMeshIface->get_node_coords(3, num_verts, MB_START_ID, handle,
coord_arrays);MB_CHK_SET_ERR(result, fileName << ": Trouble reading vertices");
// Fill in vertex coordinate arrays
cgsize_t beginPos = 1, endPos = num_verts;
// Read nodes coordinates.
cg_coord_read(filePtr, indexBase, indexZone, "CoordinateX",
RealDouble, &beginPos, &endPos, coord_arrays[0]);
cg_coord_read(filePtr, indexBase, indexZone, "CoordinateY",
RealDouble, &beginPos, &endPos, coord_arrays[1]);
cg_coord_read(filePtr, indexBase, indexZone, "CoordinateZ",
RealDouble, &beginPos, &endPos, coord_arrays[2]);
// CGNS seems to always include the Z component, even if the mesh is 2D.
// Check if Z is zero and determine mesh dimension.
// Also create the node_id_map data.
double sumZcoord = 0.0;
double eps = 1.0e-12;
for (long i = 0; i < num_verts; ++i, ++handle) {
int index = i + 1;
node_id_map.insert(std::pair<long, EntityHandle>(index, handle)).second;
sumZcoord += *(coord_arrays[2] + i);
}
if (std::abs(sumZcoord) <= eps) mesh_dim = 2;
// Create reverse map from handle to id
std::vector<int> ids(num_verts);
std::vector<int>::iterator id_iter = ids.begin();
std::vector<EntityHandle> handles(num_verts);
std::vector<EntityHandle>::iterator h_iter = handles.begin();
for (std::map<long, EntityHandle>::iterator i = node_id_map.begin();
i != node_id_map.end(); ++i, ++id_iter, ++h_iter) {
*id_iter = i->first;
* h_iter = i->second;
}
// Store IDs in tags
result = mbImpl->tag_set_data(globalId, &handles[0], num_verts, &ids[0]);
if (MB_SUCCESS != result)
return result;
if (file_id_tag) {
result = mbImpl->tag_set_data(*file_id_tag, &handles[0], num_verts, &ids[0]);
if (MB_SUCCESS != result)
return result;
}
ids.clear();
handles.clear();
// //////////////////////////////////
// Read elements data
EntityType ent_type;
long section_offset = 0;
// Define which mesh parts are volume families.
// Mesh parts with volumeID[X] = 0 are boundary parts.
std::vector<int> volumeID(num_sections, 0);
for (int section = 0; section < num_sections; ++section) {
ElementType_t elemsType;
int iparent_flag, nbndry;
char sectionName[128];
int verts_per_elem;
int cgSection = section + 1;
cg_section_read(filePtr, indexBase, indexZone, cgSection, sectionName,
&elemsType, &beginPos, &endPos, &nbndry, &iparent_flag);
size_t section_size = endPos - beginPos + 1;
// Read element description in current section
switch (elemsType) {
case BAR_2:
ent_type = MBEDGE;
verts_per_elem = 2;
break;
case TRI_3:
ent_type = MBTRI;
verts_per_elem = 3;
if (mesh_dim == 2)
volumeID[section] = 1;
break;
case QUAD_4:
ent_type = MBQUAD;
verts_per_elem = 4;
if (mesh_dim == 2)
volumeID[section] = 1;
break;
case TETRA_4:
ent_type = MBTET;
verts_per_elem = 4;
if (mesh_dim == 3)
volumeID[section] = 1;
break;
case PYRA_5:
ent_type = MBPYRAMID;
verts_per_elem = 5;
if (mesh_dim == 3) volumeID[section] = 1;
break;
case PENTA_6:
ent_type = MBPRISM;
verts_per_elem = 6;
if (mesh_dim == 3) volumeID[section] = 1;
break;
case HEXA_8:
ent_type = MBHEX;
verts_per_elem = 8;
if (mesh_dim == 3) volumeID[section] = 1;
break;
case MIXED:
ent_type = MBMAXTYPE;
verts_per_elem = 0;
break;
default:
MB_SET_ERR(MB_INDEX_OUT_OF_RANGE, fileName << ": Trouble determining element type");
}
if (elemsType == TETRA_4 || elemsType == PYRA_5 || elemsType == PENTA_6 || elemsType == HEXA_8 ||
elemsType == TRI_3 || elemsType == QUAD_4 || ((elemsType == BAR_2) && mesh_dim == 2)) {
// Read connectivity into conn_array directly
cgsize_t iparentdata;
cgsize_t connDataSize;
// Get number of entries on the connectivity list for this section
cg_ElementDataSize(filePtr, indexBase, indexZone, cgSection, &connDataSize);
// Need a temporary vector to later cast to conn_array.
std::vector<cgsize_t> elemNodes(connDataSize);
cg_elements_read(filePtr, indexBase, indexZone, cgSection, &elemNodes[0], &iparentdata);
// //////////////////////////////////
// Create elements, sets and tags
create_elements(sectionName, file_id_tag,
ent_type, verts_per_elem, section_offset, section_size , elemNodes);
} // Homogeneous mesh type
else if (elemsType == MIXED) {
// We must first sort all elements connectivities into continuous vectors
cgsize_t connDataSize;
cgsize_t iparentdata;
cg_ElementDataSize(filePtr, indexBase, indexZone, cgSection, &connDataSize);
std::vector< cgsize_t > elemNodes(connDataSize);
cg_elements_read(filePtr, indexBase, indexZone, cgSection, &elemNodes[0], &iparentdata);
std::vector<cgsize_t> elemsConn_EDGE;
std::vector<cgsize_t> elemsConn_TRI, elemsConn_QUAD;
std::vector<cgsize_t> elemsConn_TET, elemsConn_PYRA, elemsConn_PRISM, elemsConn_HEX;
cgsize_t count_EDGE, count_TRI, count_QUAD;
cgsize_t count_TET, count_PYRA, count_PRISM, count_HEX;
// First, get elements count for current section
count_EDGE = count_TRI = count_QUAD = 0;
count_TET = count_PYRA = count_PRISM = count_HEX = 0;
int connIndex = 0;
for (int i = beginPos; i <= endPos; i++) {
elemsType = ElementType_t(elemNodes[connIndex]);
// Get current cell node count.
cg_npe(elemsType, &verts_per_elem);
switch (elemsType) {
case BAR_2:
count_EDGE += 1;
break;
case TRI_3:
count_TRI += 1;
break;
case QUAD_4:
count_QUAD += 1;
break;
case TETRA_4:
count_TET += 1;
break;
case PYRA_5:
count_PYRA += 1;
break;
case PENTA_6:
count_PRISM += 1;
break;
case HEXA_8:
count_HEX += 1;
break;
default:
MB_SET_ERR(MB_INDEX_OUT_OF_RANGE, fileName << ": Trouble determining element type");
}
connIndex += (verts_per_elem + 1); // Add one to skip next element descriptor
}
if (count_EDGE > 0) elemsConn_EDGE.resize(count_EDGE * 2);
if (count_TRI > 0) elemsConn_TRI.resize(count_TRI * 3);
if (count_QUAD > 0) elemsConn_QUAD.resize(count_QUAD * 4);
if (count_TET > 0) elemsConn_TET.resize(count_TET * 4);
if (count_PYRA > 0) elemsConn_PYRA.resize(count_PYRA * 5);
if (count_PRISM > 0) elemsConn_PRISM.resize(count_PRISM * 6);
if (count_HEX > 0) elemsConn_HEX.resize(count_HEX * 8);
// Grab mixed section elements connectivity
int idx_edge, idx_tri, idx_quad;
int idx_tet, idx_pyra, idx_prism, idx_hex;
idx_edge = idx_tri = idx_quad = 0;
idx_tet = idx_pyra = idx_prism = idx_hex = 0;
connIndex = 0;
for (int i = beginPos; i <= endPos; i++) {
elemsType = ElementType_t(elemNodes[connIndex]);
// Get current cell node count.
cg_npe(elemsType, &verts_per_elem);
switch (elemsType) {
case BAR_2:
for (int j = 0; j < 2; ++j)
elemsConn_EDGE[idx_edge + j] = elemNodes[connIndex + j + 1];
idx_edge += 2;
break;
case TRI_3:
for (int j = 0; j < 3; ++j)
elemsConn_TRI[idx_tri + j] = elemNodes[connIndex + j + 1];
idx_tri += 3;
break;
case QUAD_4:
for (int j = 0; j < 4; ++j)
elemsConn_QUAD[idx_quad + j] = elemNodes[connIndex + j + 1];
idx_quad += 4;
break;
case TETRA_4:
for (int j = 0; j < 4; ++j)
elemsConn_TET[idx_tet + j] = elemNodes[connIndex + j + 1];
idx_tet += 4;
break;
case PYRA_5:
for (int j = 0; j < 5; ++j)
elemsConn_PYRA[idx_pyra + j] = elemNodes[connIndex + j + 1];
idx_pyra += 5;
break;
case PENTA_6:
for (int j = 0; j < 6; ++j)
elemsConn_PRISM[idx_prism + j] = elemNodes[connIndex + j + 1];
idx_prism += 6;
break;
case HEXA_8:
for (int j = 0; j < 8; ++j)
elemsConn_HEX[idx_hex + j] = elemNodes[connIndex + j + 1];
idx_hex += 8;
break;
default:
MB_SET_ERR(MB_INDEX_OUT_OF_RANGE, fileName << ": Trouble determining element type");
}
connIndex += (verts_per_elem + 1); // Add one to skip next element descriptor
}
// //////////////////////////////////
// Create elements, sets and tags
if (count_EDGE > 0)
create_elements(sectionName, file_id_tag, MBEDGE, 2, section_offset, count_EDGE, elemsConn_EDGE);
if (count_TRI > 0)
create_elements(sectionName, file_id_tag, MBTRI, 3, section_offset, count_TRI, elemsConn_TRI);
if (count_QUAD > 0)
create_elements(sectionName, file_id_tag, MBQUAD, 4, section_offset, count_QUAD, elemsConn_QUAD);
if (count_TET > 0)
create_elements(sectionName, file_id_tag, MBTET, 4, section_offset, count_TET, elemsConn_TET);
if (count_PYRA > 0)
create_elements(sectionName, file_id_tag, MBPYRAMID, 5, section_offset, count_PYRA, elemsConn_PYRA);
if (count_PRISM > 0)
create_elements(sectionName, file_id_tag, MBPRISM, 6, section_offset, count_PRISM, elemsConn_PRISM);
if (count_HEX > 0)
create_elements(sectionName, file_id_tag, MBHEX, 8, section_offset, count_HEX, elemsConn_HEX);
} // Mixed mesh type
} // num_sections
cg_close(filePtr);
return result;
} // indexZone for
} // indexBase for
return MB_SUCCESS;
}
