HDF5OrthoWriter Class Reference

#include <hdf5orthowriter.h>

Inheritance diagram for HDF5OrthoWriter:

[legend]

Collaboration diagram for HDF5OrthoWriter:

[legend]

List of all members.

Public Member Functions
void	writeMesh (string meshName, OrthoMesh &mesh)
void	writeDataSet (const VecDouble &vec, std::string datasetName, std::string triaId)
void	writeScalarField (const VecDouble &vec, std::string fieldName, std::string triaId="")
void	writeCoarseMesh (string triaName, OrthoMesh &mesh, unsigned blkX, unsigned blkY, unsigned blkZ)
void	writeCoarseMeshWithWells (string triaName, OrthoMesh &mesh, unsigned blkX, unsigned blkY, unsigned blkZ)
void	createGroup (std::string str)
void	close ()
void	supressOutput ()
Static Public Member Functions
static HDF5OrthoWriter &	getHDF5OrthoWriter ()
Protected Member Functions
	HDF5OrthoWriter ()
	~HDF5OrthoWriter ()
Static Protected Attributes
static HDF5OrthoWriter *	ptr = NULL
Private Member Functions
void	collapseCellBlock (OrthoMesh::Cell_It &cell, unsigned blX, unsigned blY, unsigned blZ, StackVector< 8, unsigned > &verts)
unsigned	adjustBlockSize (unsigned nElems, unsigned blkSize)
Private Attributes
std::string	_defaultMesh
bool	_supress_output

---

Detailed Description

Definition at line 12 of file hdf5orthowriter.h.

---

Constructor & Destructor Documentation

HDF5OrthoWriter::HDF5OrthoWriter

(

)

[protected]

Definition at line 9 of file hdf5orthowriter.cpp.

{
  this->_supress_output=false;
}

HDF5OrthoWriter::~HDF5OrthoWriter

(

)

[protected]

Definition at line 16 of file hdf5orthowriter.cpp.

{
  std::string file=getFileName();
  if (!file.empty())
  {
    XdmfWriter xdmf;
    xdmf.writeXdmf(file);
  }
  
}

---

Member Function Documentation

unsigned HDF5OrthoWriter::adjustBlockSize	(	unsigned	nElems,
		unsigned	blkSize
	)			[private]

Definition at line 528 of file hdf5orthowriter.cpp.

{
  for (unsigned Itry=blkSize;Itry<=nElems;Itry++)
  {
    if (nElems%Itry == 0)
      return Itry;
  }
  return nElems;
}

void HDF5OrthoWriter::close

(

)

Reimplemented from HDF5Writer.

Definition at line 539 of file hdf5orthowriter.cpp.

{
  std::string file=getFileName();
  HDF5Writer::close();
  printf("File:   %s\n",file.c_str());
  if (!file.empty())
  {
    printf("Writing xdmf\n");
    XdmfWriter xdmf;
    xdmf.writeXdmf(file);
  }
 
}

void HDF5OrthoWriter::collapseCellBlock	(	OrthoMesh::Cell_It &	cell,
		unsigned	blX,
		unsigned	blY,
		unsigned	blZ,
		StackVector< 8, unsigned > &	verts
	)			[private]

First of all, this is a private method using just for collapsing blocks of cells and it is used by the writeSparseTriangulation method. Given a cell c1, the method returns the vertices of a block of blX x blY x blZ cells where c1 is the lower left front cell of the block (i.e The cell of lowest coordinates values).If the block cannto be formed due to a hole in the domain or because c1 is near the boundary, the method returns an exception.

Parameters:

	mesh
	cell
	blX
	blY
	blZ
	verts

Returns:

Definition at line 279 of file hdf5orthowriter.cpp.

 {
   
   blX--;
   blY--;
   blZ--;
   unsigned r1,r2,r3,r4,r5,r6,r7;
   OrthoMesh::Cell_It c1=cell;
  verts[VERTEX_000]=cell->vertex_index(VERTEX_000);

  r1=c1->advance(RIGHT_CELL,blX);
  verts[VERTEX_100]=c1->vertex_index(VERTEX_100);

  r2=c1->advance(BACK_CELL,blY);
  verts[VERTEX_110]=c1->vertex_index(VERTEX_110);

  r3=c1->advance(LEFT_CELL,blX);
  verts[VERTEX_010]=c1->vertex_index(VERTEX_010);

  c1=cell;
  r4=c1->advance(UP_CELL,blZ);
  verts[VERTEX_001]=c1->vertex_index(VERTEX_001);

  r5=c1->advance(RIGHT_CELL,blX);
  verts[VERTEX_101]=c1->vertex_index(VERTEX_101);

  r6=c1->advance(BACK_CELL,blY);
  verts[VERTEX_111]=c1->vertex_index(VERTEX_111);

  r7=c1->advance(LEFT_CELL,blX);
  verts[VERTEX_011]=c1->vertex_index(VERTEX_011);

  if (r1!=blX || r2 != blY || r3 != blX || r4 != blZ ||
      r5!=blX || r6 != blY || r7 != blX)
  {
    throw new Exception("HDF5DealWriter: Method reach the boundary while collapsing a block cell"); 
  }
}

void HDF5OrthoWriter::createGroup

(

std::string

str

)

Definition at line 473 of file hdf5orthowriter.cpp.

{
  hid_t aux;
  H5Eset_auto2(H5E_DEFAULT,NULL,stdout);
  aux = H5Gopen1(getFile(),str.c_str());
  H5Eset_auto2(H5E_DEFAULT,(herr_t (*)(hid_t,void*))   &H5Eprint,stdout);
  if (aux >= 0)
  {
    H5Gclose(aux);
    return;
  }
  else
  {
    H5Gclose(H5Gcreate1(getFile(),str.c_str(),H5P_DEFAULT));
  }
}

HDF5OrthoWriter & HDF5OrthoWriter::getHDF5OrthoWriter

(

)

[static]

Definition at line 33 of file hdf5orthowriter.cpp.

{
  if (ptr == NULL)
    ptr=new HDF5OrthoWriter();
  return *ptr;
    
}

void HDF5OrthoWriter::supressOutput

(

)

Definition at line 554 of file hdf5orthowriter.cpp.

{
  _supress_output=true;
}

void HDF5OrthoWriter::writeCoarseMesh	(	string	triaName,
		OrthoMesh &	mesh,
		unsigned	blkX,
		unsigned	blkY,
		unsigned	blkZ
	)

Definition at line 321 of file hdf5orthowriter.cpp.

{
  if (blkX == 1 && blkY == 1 && blkZ == 1)
    return writeMesh(triaName,mesh);

  if (!mesh.getWells().empty())
  {
    return writeCoarseMeshWithWells(triaName,mesh,blkX,blkY,blkZ);
  }
  
  putMeshIntoDictionary(triaName,mesh.numVertices(),mesh.numCells());
  
  unsigned offX = blkX-1;
  unsigned offY = blkY-1;
  unsigned offZ = blkZ-1;
  unsigned dX,dZ,dY;
  unsigned nX,nY,nZ;
  nX = mesh.numElemX()/blkX + ((mesh.numElemX()%blkX == 0) ? 0 : 1);
  nY = mesh.numElemY()/blkY + ((mesh.numElemY()%blkY == 0) ? 0 : 1);
  nZ = mesh.numElemZ()/blkZ + ((mesh.numElemZ()%blkZ == 0) ? 0 : 1);

  
  std::vector<Verts> cells;
  cells.reserve(nX*nY*nZ);
  Verts verts;
  
  
  OrthoMesh::Cell_It cellZ = mesh.begin_cell();
  while(1) {
    OrthoMesh::Cell_It aux = cellZ;
    dZ = aux->advance(UP_CELL,offZ);
    OrthoMesh::Cell_It cellY=cellZ;
    while(1)
    {
      aux=cellY;
      dY=aux->advance(BACK_CELL,offY);
      OrthoMesh::Cell_It cellX=cellY;
      while(1)
      {
        aux=cellX;
        dX=aux->advance(RIGHT_CELL,offX);
        collapseCellBlock(cellX,dX+1,dY+1,dZ+1,verts);
        cells.push_back(verts);
        cellX->advance(RIGHT_CELL,dX);
        if (!cellX->advance(RIGHT_CELL))
          break;
      }
      cellY->advance(BACK_CELL,dY);
      if (!cellY->advance(BACK_CELL))
          break;
    }
    cellY->advance(UP_CELL,dZ);
    if (!cellZ->advance(UP_CELL))
      break;
  }



  
  std::vector<unsigned> vI(mesh.numVertices(),UINT_MAX);
  for(unsigned i=0;i<cells.size();i++)
  {
    for(unsigned j=0;j<8;j++)
      vI[cells[i][j]]=1;
  }
  unsigned acum=0;
  for (unsigned i=0;i<vI.size();i++)
  {
    if (vI[i] != UINT_MAX)
      vI[i]=acum++;
  }
  for(unsigned i=0;i<cells.size();i++)
    for(unsigned j=0;j<8;j++)
    {
      cells[i][j]=vI[cells[i][j]];
    }
  std::vector<hsize_t> vActiveVert;
  vActiveVert.reserve(acum);
  for(unsigned i=0;i<vI.size();i++)
  {
    if (vI[i] != UINT_MAX)
      vActiveVert.push_back(i);
  }
  getTriaInformation(triaName).setActiveVertices(vActiveVert);

  /*
  for(unsigned i=0;i<cells.size();i++)
  {
    printf("%d) ",i);
    for(unsigned j=0;j<8;j++)
      printf("%d ",cells[i][j]);
    printf("\n");
  }
  */

  //Criar Grupo
  char strPath[500];
  sprintf(strPath,"/Triangulations/%s",triaName.c_str());
  hid_t triaGroup=H5Gcreate1(getFile(),strPath,0);
  H5LTset_attribute_string(getFile(),strPath,"Type","GRID_3D");

  
  hsize_t dim[]={vActiveVert.size(),3};
  hid_t dataspace = H5Screate_simple(2,dim,NULL);
  hid_t datatype  = H5Tcopy(H5T_NATIVE_DOUBLE);
  H5Tset_order(datatype,H5T_ORDER_LE);
  hid_t dataset = H5Dcreate1(triaGroup, "vertices", datatype, dataspace, H5P_DEFAULT);

  int nSteps = vActiveVert.size()/HDF5_BUFF_SIZE;
  hsize_t count[]={HDF5_BUFF_SIZE,3};
  hsize_t offset[]={0,0};
  double buff[HDF5_BUFF_SIZE][3];
  unsigned k=0;
  for (int i=0;i<=nSteps;i++)
  {
    int MaxJ = (i==nSteps) ? (vActiveVert.size() % HDF5_BUFF_SIZE) : HDF5_BUFF_SIZE;
    count[0]=MaxJ;
    for (int j=0;j<MaxJ;j++)
    {
      Point3D P = mesh.get_vertice(vActiveVert[k])->getPoint();
      buff[j][0]= P[0];
      buff[j][1]= P[1];
      buff[j][2]= P[2];
      k++;
    }
    writeInChunks(dataset,offset,count,buff);
    offset[0]+=MaxJ;
  }
  H5Sclose(dataspace);
  H5Tclose(datatype);
  H5Dclose(dataset);

  dim[0]=cells.size();
  dim[1]=8;
  dataspace = H5Screate_simple(2,dim,NULL);
  datatype  = H5Tcopy(H5T_NATIVE_UINT);
  H5Tset_order(datatype,H5T_ORDER_LE);
  dataset = H5Dcreate1(triaGroup, "connections", datatype, dataspace, H5P_DEFAULT);
  H5Dwrite(dataset,H5T_NATIVE_UINT,H5S_ALL,H5S_ALL,H5P_DEFAULT, &(cells[0][0]));

  H5Sclose(dataspace);
  H5Tclose(datatype);
  H5Dclose(dataset);
  H5Gclose(triaGroup);
  
    

}

void HDF5OrthoWriter::writeCoarseMeshWithWells	(	string	triaName,
		OrthoMesh &	mesh,
		unsigned	blkX,
		unsigned	blkY,
		unsigned	blkZ
	)

Definition at line 493 of file hdf5orthowriter.cpp.

{
  if (blkX == 1 && blkY == 1 && blkZ == 1)
    return writeMesh(triaName,mesh);

  unsigned nX = mesh.numElemX();
  unsigned nY = mesh.numElemY();
  unsigned nZ = mesh.numElemZ();

  blkX=adjustBlockSize(nX,blkX); 
  blkY=adjustBlockSize(nY,blkY);
  blkZ=adjustBlockSize(nZ,blkZ);
  printf("Adjusting blocks steps for mesh %s\n",triaName.c_str());
  printf("Block X: %u\n",blkX);
  printf("Block Y: %u\n",blkY);
  printf("Block Z: %u\n",blkZ);
 
  OrthoMesh newMesh(mesh.getP(),mesh.getQ(),nX/blkX,nY/blkY,nZ/blkZ);
  VecWellInfo wells=mesh.getWells();
  for (unsigned i=0;i<wells.size();i++)
  wells[i].adjustBoundaryWithGrid(newMesh.getDX());
  newMesh.putWells(wells);
  writeMesh(triaName,newMesh);

  getTriaInformation(triaName).n_vertices=mesh.numVertices();
  getTriaInformation(triaName).n_cells=mesh.numCells();
  std::vector<hsize_t> map(newMesh.numVertices(),UINT_MAX);
  for (OrthoMesh::Vertex_It vIt = newMesh.begin_vertice();vIt != newMesh.end_vertice();vIt++)
  {
    map[vIt->index()]=mesh.getNearestVertice(vIt->getPoint())->index();
  }
  getTriaInformation(triaName).setActiveVertices(map);
}

void HDF5OrthoWriter::writeDataSet	(	const VecDouble &	vec,
		std::string	datasetName,
		std::string	triaId
	)

Definition at line 197 of file hdf5orthowriter.cpp.

{
  if (_supress_output)
    return;
  H5Eset_auto2(H5E_DEFAULT,(herr_t (*)(hid_t,void*))   &exitA,stdout);

  //If the user did not give the name of the mesh
 //use the last registered mesh
 if (triaId == "")
 {
   triaId = this->getNameOfLastRegisteredTriangulation();
 }

 if (!(getTriaInformation(triaId).n_vertices == vec.size() ||
       getTriaInformation(triaId).n_cells == vec.size()))
 {
   printf("Error %d != %d || %d\n",vec.size(),getTriaInformation(triaId).n_vertices,getTriaInformation(triaId).n_cells);
 }
 assert(getTriaInformation(triaId).n_vertices == vec.size() ||
        getTriaInformation(triaId).n_cells == vec.size());
 assert(getFile() != -1);


  
  //Now write the dataset.
  //Create the dataset
  hid_t datatype  = H5Tcopy(H5T_NATIVE_DOUBLE);
  H5Tset_order(datatype,H5T_ORDER_LE);

  struct TriaInformation &triaInfo = getTriaInformation(triaId);
  if (!triaInfo.isCollapsed())  //pV==NULL means that we are writting the original mesh
  {

    hsize_t dim[]={vec.size()};
    hid_t dataspace = H5Screate_simple(1,dim,NULL);
    hid_t dataset = H5Dcreate1(getFile(), datasetName.c_str(), datatype, dataspace, H5P_DEFAULT);
    //Copy the data.
    H5Dwrite(dataset,H5T_NATIVE_DOUBLE,H5S_ALL,H5S_ALL,H5P_DEFAULT, vec.begin());

    //Close the resources.3
    H5Sclose(dataspace);
    H5Tclose(datatype);
    H5Dclose(dataset);
  }
  else
  {
    hsize_t dim[]={triaInfo.getActiveVertices().size()};
    hid_t dataspace = H5Screate_simple(1,dim,NULL);
    hid_t dataset = H5Dcreate1(getFile(), datasetName.c_str(), datatype, dataspace, H5P_DEFAULT);
    hsize_t memDim[]={vec.size()};
    hid_t memDataSpace = H5Screate_simple(1,memDim,NULL);
    H5Sselect_elements(memDataSpace,H5S_SELECT_SET,
                       triaInfo.getActiveVertices().size(),
                       &(triaInfo.getActiveVertices()[0]));
    //Copy the data.
    H5Dwrite(dataset,H5T_NATIVE_DOUBLE,memDataSpace,H5S_ALL,H5P_DEFAULT, vec.begin());

    //Close the resources.3
    H5Sclose(dataspace);
    H5Tclose(datatype);
    H5Sclose(memDataSpace);
    H5Dclose(dataset);

  }
  
  //Set attributes
  H5LTset_attribute_string(getFile(),datasetName.c_str(),"Triangulation",triaId.c_str());
  this->writeContextVariables(datasetName);


  
}

void HDF5OrthoWriter::writeMesh	(	string	meshName,
		OrthoMesh &	mesh
	)

Definition at line 44 of file hdf5orthowriter.cpp.

{
  if (_supress_output)
    return;

  if (_defaultMesh.empty())
    _defaultMesh=meshName;
  assert(getFile() != -1);
  double buff[HDF5_BUFF_SIZE][3];
  int buff_int[HDF5_BUFF_SIZE][8];
  
  putMeshIntoDictionary(meshName,mesh.numVertices(),mesh.numCells());
  
  //Criar Grupo
  char strPath[500];
  sprintf(strPath,"/Triangulations/%s",meshName.c_str());
  hid_t triaGroup=H5Gcreate1(getFile(),strPath,0);

  H5LTset_attribute_string(getFile(),strPath,"Type","GRID_3D");
  HDF5OrthoInfo info(mesh.getP(),mesh.getQ(),mesh.numElemX(),mesh.numElemY(),mesh.numElemZ(),mesh.getWells());
  info.writeOrthoMeshInfo(triaGroup);

  
  
  hsize_t dim[]={mesh.numVertices(),3};
  hid_t dataspace = H5Screate_simple(2,dim,NULL);
  hid_t datatype  = H5Tcopy(H5T_NATIVE_DOUBLE);
  H5Tset_order(datatype,H5T_ORDER_LE);
  hid_t dataset = H5Dcreate1(triaGroup, "vertices", datatype, dataspace, H5P_DEFAULT);

  int nSteps = mesh.numVertices()/HDF5_BUFF_SIZE;
  hsize_t count[]={HDF5_BUFF_SIZE,3};
  hsize_t offset[]={0,0};
  OrthoMesh::Vertex_It vIt = mesh.begin_vertice();
  for (int i=0;i<=nSteps;i++)
  {
    int MaxJ = (i==nSteps) ? (mesh.numVertices() % HDF5_BUFF_SIZE) : HDF5_BUFF_SIZE;
    count[0]=MaxJ;
    for (int j=0;j<MaxJ;j++)
    {
      Point3D p =vIt->getPoint();
      buff[j][0]= p[0];
      buff[j][1]= p[1];
      buff[j][2]= p[2];
      vIt++;
    }
    writeInChunks(dataset,offset,count,buff);
    offset[0]+=MaxJ;
  }
  H5Sclose(dataspace);
  H5Tclose(datatype);
  H5Dclose(dataset);

  dim[0]=mesh.numCells();
  dim[1]=8;
  dataspace = H5Screate_simple(2,dim,NULL);
  datatype  = H5Tcopy(H5T_NATIVE_INT);
  H5Tset_order(datatype,H5T_ORDER_LE);
  dataset = H5Dcreate1(triaGroup, "connections", datatype, dataspace, H5P_DEFAULT);


  nSteps = mesh.numCells()/HDF5_BUFF_SIZE;
  count[1]=8;
  offset[0]=0;
  OrthoMesh::Cell_It cell = mesh.begin_cell(),
    endc = mesh.end_cell();

  for (int i=0;i<=nSteps;i++)
  {
    int MaxJ = (i==nSteps) ? (mesh.numCells() % HDF5_BUFF_SIZE) : HDF5_BUFF_SIZE;
    count[0]=MaxJ;
    //Write the cell points conectivity. The order of the cell vertex
    //is like vtkVOXEL 
    for (int j=0;j<MaxJ;j++)
    {
      buff_int[j][0]= cell->vertex_index(VERTEX_000);
      buff_int[j][1]= cell->vertex_index(VERTEX_100);
      buff_int[j][2]= cell->vertex_index(VERTEX_010);
      buff_int[j][3]= cell->vertex_index(VERTEX_110);
      buff_int[j][4]= cell->vertex_index(VERTEX_001);
      buff_int[j][5]= cell->vertex_index(VERTEX_101);
      buff_int[j][6]= cell->vertex_index(VERTEX_011);
      buff_int[j][7]= cell->vertex_index(VERTEX_111);
      cell++;
    }
    writeInChunks(dataset,offset,count,buff_int);
    offset[0]+=MaxJ;
  }
  H5Sclose(dataspace);
  H5Tclose(datatype);
  H5Dclose(dataset);
  H5Gclose(triaGroup);

}

void HDF5OrthoWriter::writeScalarField	(	const VecDouble &	vec,
		std::string	fieldName,
		std::string	triaId = ""
	)

Definition at line 140 of file hdf5orthowriter.cpp.

{
  if (_supress_output)
    return;

  //Set the dataset name
  char datasetName[1000];
  char datasetGroup[1000];
  char attValue[10];

  //If the user did not give the name of the mesh
  //use the last registered mesh
 if (triaId == "")
 {
   triaId = _defaultMesh;
 }

  //Validation of the parameters
 validateField(triaId,sFieldName);

  //Now get the counter of this field and increment it. 
  unsigned refCount = getFieldCount(sFieldName);
  if (refCount == 0)
  {
     //This field is new, create a directory entry for the field name and initialize the counter
    sprintf(datasetName,"/DataSets/%s",sFieldName.c_str());
    H5Gclose(H5Gcreate1(getFile(),datasetName,0));    
  }
  double min,max;
  NumericMethods::vectorMinMaxValues(vec,min,max);
  getFieldInfo(sFieldName).updateMinMaxValues(min,max);
  
    
  sprintf(datasetName,"/DataSets/%s/%s_%d",sFieldName.c_str(),sFieldName.c_str(),getFieldCount(sFieldName));



  //write it
  writeDataSet(vec,datasetName,triaId);


  sprintf(datasetGroup,"/DataSets/%s",sFieldName.c_str());
  sprintf(attValue,"%d",refCount+1);
  setAtt(datasetGroup,"NFields",attValue); 
  setAtt(datasetGroup,"Max",getFieldInfo(sFieldName).max);
  setAtt(datasetGroup,"Min",getFieldInfo(sFieldName).min);
  
  //Increment the field count
  incFieldCount(sFieldName);
}

---

Member Data Documentation

std::string HDF5OrthoWriter::_defaultMesh [private]

Definition at line 17 of file hdf5orthowriter.h.

bool HDF5OrthoWriter::_supress_output [private]

Definition at line 18 of file hdf5orthowriter.h.

HDF5OrthoWriter * HDF5OrthoWriter::ptr = NULL [static, protected]

Definition at line 20 of file hdf5orthowriter.h.

---

The documentation for this class was generated from the following files:

• hdf5orthowriter.h
• hdf5orthowriter.cpp