proteusHdf5 Class Reference

Class to store HDF5 data from Proteus files. More...

Detailed Description

Definition at line 110 of file proteusHdf5.H.

Public Member Functions
	proteusHdf5 (std::string fname, std::string outputFname, std::string edgeSidesetName, std::string exoMeshFName, bool lowOrder=false, bool bndryConst=true)
	Construct Proteus HDF5 object. More...
	~proteusHdf5 ()
void	getVectorNames (std::string name, std::vector< std::string > &stringVector, int numVectors)
	Get names of Proteus vector fields. More...
void	getBlockInfo (Group &group, proteusBlock &myBlock)
	Read information for each Proteus block. More...
void	getBlockXYZ (Group &group, proteusBlock &myBlock)
	Get coordinates of Proteus block. More...
void	getBlockGlobalID (Group &group, proteusBlock &myBlock)
	Get global coordinates of Proteus block. More...
void	getBlockElementData (Group &group, proteusBlock &myBlock)
	Get element data for block. More...
void	getBlockVertexData (Group &group, proteusBlock &myBlock)
	Get vertex data for block. More...
int	getNumBlocks () const
	Get number of blocks in Proteus file. More...
int	getNumDimensions () const
	Get number of spatial dimensions in Proteus file. More...
int	getNumVertexVectors () const
	Get number of vertex vectors in Proteus file. More...
int	getNumElementVectors () const
	Get number of element vectors in Proteus file. More...
int	getCharStringLength () const
	Get character string length of names in Proteus file. More...
void	getBoundaryEdgePts (vtkSmartPointer< vtkPoints > startPts, vtkSmartPointer< vtkPoints > endPts)
	Write boundary condition information to json file. More...
void	getBoundarySideSets (meshBase *myMeshBase, vtkSmartPointer< vtkPoints > startPts, vtkSmartPointer< vtkPoints > endPts, vtkSmartPointer< vtkIdList > sidesetElementIdList, vtkSmartPointer< vtkIdList > sidesetSideIdList)
	Get boundary sidesets of mesh. More...
bool	get2dCellNodeOrder (meshBase *myMeshBase)
	Get normal vector for 2d meshes. More...
int	openFile ()
	Open HDF5 file. More...
int	closeFile ()
	Close HDF5 file. More...
int	readTopDataSet (std::string dsetName, std::string &buffer)
	Read string data from top level HDF5 DataSet. More...
template<class T >
int	readTopDataSet (std::string dsetName, std::vector< T > &buffer)
	Read numeric data from top level HDF5 DataSet. More...
int	readDataSet (DataSet dset, std::string &buffer)
	Read string data from generic HDF5 DataSet. More...
template<class T >
int	readDataSet (DataSet dset, std::vector< T > &buffer)
	Read numeric data from generic HDF5 DataSet. More...
int	readGroup (std::string groupName, Group &group)
	Read existing HDF5 Group. More...
template<class T >
int	readGroupDataSet (std::string dsetName, Group &group, std::vector< T > &buffer)
	Read numeric data from HDF5 group. More...
std::string	getFileName ()
	Get HDF5 filename. More...
template<class T >
void	flattenBuffer2d (std::vector< std::vector< T >> originalBuffer, std::vector< T > &flatBuffer)
	Flatten 2d data buffer. More...
template<class T >
void	unflattenBuffer2d (std::vector< T > flatBuffer, std::vector< std::vector< T >> &originalBuffer)
	Unflatten 2d data buffer. More...
void	exportToVTKMesh ()
	Export to VTK format. More...
vtkSmartPointer< vtkDataSet >	getVTKMesh ()
	Get VTK mesh object. More...
void	exportToMeshBase ()
	Export HDF5 mesh to meshBase object. More...
meshBase *	getMeshBase ()
	Get meshBase object. More...
void	writeVTK ()
	Write mesh to VTK file. More...
void	setFields (meshBase *myMeshBase, std::vector< std::string > dataNames, std::vector< std::vector< double >> data, int pointOrCell)
	Set meshBase field data. More...
void	setNumberOfVertices (int numVertices)
	Set number of vertices in meshBase. More...
void	setNumberOfElements (int numElements)
	Set number of elements in meshBase. More...
void	setNumberOfDimensions (int numDimensions)
	Set number of spatial dimensions in meshBase. More...
void	setCoordinates (std::vector< double > xCrd)
	Set meshBase 1d coordinate data. More...
void	setCoordinates (std::vector< double > xCrd, std::vector< double > yCrd)
	Set meshBase 2d coordinate data. More...
void	setCoordinates (std::vector< double > xCrd, std::vector< double > yCrd, std::vector< double > zCrd)
	Set meshBase 3d coordinate data. More...
void	setConnectivities (std::vector< std::map< int, std::vector< int >>> elementConnectivity)
	Set meshBase element connectivity table. More...
void	setElementTypes (std::vector< int > vtkElementTypes)
	Set VTK element types for each element. More...
void	setElementTypesList (std::vector< int > vtkElementTypesList)
	Set list of each unique type of VTK element in mesh. More...
std::vector< int >	getElementConnectivity (int elementId)
	Get element connectivity for global element ID. More...

Protected Attributes
std::string	h5FileName
	HDF5 filename. More...
std::string	baseH5FileName
	base of HDF5 filename More...
std::string	outputFname
	VTK output filename. More...
int	verb
	verbosity flag More...
H5File	file
	HDF5 file object. More...
vtkSmartPointer< vtkDataSet >	vtkMesh
	VTK DataSet object. More...
meshBase *	myMeshBase
	meshBase object More...
std::vector< double >	xCrd
std::vector< double >	yCrd
std::vector< double >	zCrd
	vector of coordinates More...
std::vector< std::map< int, std::vector< int > > >	elementConnectivity
	element connectivity table More...
int	numVertices
	number of vertices in mesh More...
int	numElements
	number of elements in mesh More...
std::vector< int >	vtkElementTypes
	vector of VTK element type for each element More...
std::vector< int >	vtkElementTypesList
	vector storing list of each unique VTK element type More...

Private Member Functions
void	getBlocks ()
	Read Proteus blocks. More...
void	getControlInformation ()
	Read Proteus control information. More...
void	mergeBlocks ()
	Merge Proteus block together. More...

Private Attributes
bool	lowOrder
	Boolean converting high order cells to low order (useful for visualization) More...
int	numBlocks
	number of Proteus blocks More...
int	numDimensions
	number of spatial dimensions More...
int	numVertexVectors
	number of vertex vector fields in Proteus file More...
int	numElementVectors
	number of element vector fields in Proteus file More...
int	charStringLength
	string length of each Proteus variable name More...
std::vector< std::string >	vertexVectorNames
	vector containing names of vertex vectors More...
std::vector< std::string >	elementVectorNames
	vector containing names of element vectors More...
proteusSuperBlock	mySuperBlock
	global block structure for entire Proteus mesh More...
std::vector< proteusBlock >	proteusBlocks
	vector of all individual Proteus-style blocks More...

Inherits hdf5Reader.

Constructor & Destructor Documentation

proteusHdf5()

proteusHdf5::proteusHdf5	(	std::string	fname,
		std::string	outputFname,
		std::string	edgeSidesetName,
		std::string	exoMeshFName,
		bool	lowOrder = false,
		bool	bndryConst = true
	)

Parameters

fieldFName	Proteus format HDF5 field filename
meshFName	Output VTK mesh filename
edgeSidesetName	Name of sideset written to output Exodus file
exoMeshFName	Output Exodus mesh filename
lowOrder	Boolean converting high order cells to low order
bndryConst	Boolean to employ boundary constraint during refinement

Definition at line 60 of file proteusHdf5.C.

References hdf5Reader::closeFile(), meshBase::convertQuads(), meshBase::Create(), NEM::DRV::TransferDriver::CreateTransferObject(), proteusSuperBlock::elementData, proteusSuperBlock::elementTypes, proteusSuperBlock::elementTypesList, elementVectorNames, hdf5Reader::exportToMeshBase(), hdf5Reader::exportToVTKMesh(), NEM::DRV::ConversionDriver::genExo(), get2dCellNodeOrder(), getBlocks(), getBoundaryEdgePts(), getBoundarySideSets(), getControlInformation(), hdf5Reader::getMeshBase(), getNumDimensions(), getVectorNames(), lowOrder, mergeBlocks(), hdf5Reader::myMeshBase, mySuperBlock, NEM::MSH::New(), numDimensions, proteusSuperBlock::numElements, numElementVectors, numVertexVectors, proteusSuperBlock::numVertices, hdf5Reader::openFile(), meshBase::refineMesh(), hdf5Reader::setConnectivities(), hdf5Reader::setCoordinates(), hdf5Reader::setElementTypes(), hdf5Reader::setElementTypesList(), hdf5Reader::setFields(), meshBase::setMetadata(), hdf5Reader::setNumberOfDimensions(), hdf5Reader::setNumberOfElements(), hdf5Reader::setNumberOfVertices(), proteusSuperBlock::vertexData, vertexVectorNames, proteusSuperBlock::vtkConnectivity, meshBase::write(), proteusSuperBlock::xCrd, proteusSuperBlock::yCrd, and proteusSuperBlock::zCrd.

    : hdf5Reader(fname, meshFname) {
  // Set boolean determining whether to output higher order elements
  // as lower order elements; useful for visualization
  lowOrder = _lowOrder;

  // Open HDF5 file
  openFile();

  // Get file system metadata
  getControlInformation();
  getVectorNames("ELEMENT_VECTOR_NAMES", elementVectorNames, numElementVectors);
  getVectorNames("VERTEX_VECTOR_NAMES", vertexVectorNames, numVertexVectors);

  // Read in each block
  getBlocks();

  // Merge block data
  mergeBlocks();

  // Set HDF5 data
  setNumberOfDimensions(numDimensions);
  setNumberOfVertices(mySuperBlock.numVertices);
  setNumberOfElements(mySuperBlock.numElements);
  setCoordinates(mySuperBlock.xCrd, mySuperBlock.yCrd, mySuperBlock.zCrd);
  setElementTypesList(mySuperBlock.elementTypesList);
  setElementTypes(mySuperBlock.elementTypes);
  setConnectivities(mySuperBlock.vtkConnectivity);

  // Export to VTK file
  exportToVTKMesh();

  // Export to MeshBase
  exportToMeshBase();

  // Get VTK mesh
  myMeshBase = getMeshBase();

  // Add vertex data to meshBase
  setFields(myMeshBase, vertexVectorNames, mySuperBlock.vertexData, 0);

  // Add element data to meshBase
  setFields(myMeshBase, elementVectorNames, mySuperBlock.elementData, 1);

  // If mesh is 2d, get node ordering convention to follow when splitting cells
  bool rhr;
  // true = right-hand rule (projection of normal vector onto z-axis is +)
  // false = left-hand rule (projection of normal vector onto z-axis is -)
  if (getNumDimensions() == 2) {
    std::cout << "Checking 2d cell node order" << std::endl;
    rhr = get2dCellNodeOrder(myMeshBase);
    if (rhr) {
      std::cout << "2d node ordering right-hand rule: +z" << std::endl;
    } else {
      std::cout << "2d node ordering right-hand rule: -z" << std::endl;
    }
  }

  // Create a meshbase with quads removed (converted to tris)
  std::cout << "Removing quad elements (converting to tris) for refinement"
            << std::endl;
  meshBase *myMeshBaseNoQuads = myMeshBase->convertQuads();

  // Check node ordering again after element conversion (all tris)
  if (getNumDimensions() == 2) {
    std::cout << "Checking 2d cell node order" << std::endl;
    rhr = get2dCellNodeOrder(myMeshBaseNoQuads);
    if (rhr) {
      std::cout << "2d node ordering right-hand rule: +z" << std::endl;
    } else {
      std::cout << "2d node ordering right-hand rule: -z" << std::endl;
    }
  }

  std::cout << "Writing meshBase to file" << std::endl;
  myMeshBase->write();

  // Transfer solution onto new mesh
  std::cout << "Performing solution transfer" << std::endl;
  // myMeshBase->transfer(myMeshBaseNoQuads, "Consistent Interpolation");
  auto transfer = NEM::DRV::TransferDriver::CreateTransferObject(
      myMeshBase, myMeshBaseNoQuads, "Consistent Interpolation");
  transfer->run();

  // debug
  // myMeshBase->write();
  // myGmshMeshBase->write();

  // Refine mesh
  myMeshBaseNoQuads->refineMesh("uniform", 0.5, "refined.vtu", true,
                                bndryConst);

  // Read in refined mesh
  meshBase *refinedMeshBase = meshBase::Create("refined.vtu");

  // Write refined mesh to file
  myMeshBaseNoQuads->write();
  // myGmshMeshNoQuads->write();

  // Write to file
  // writeVTK();

  // Check node ordering again after refinement
  if (getNumDimensions() == 2) {
    std::cout << "Checking 2d cell node order" << std::endl;
    rhr = get2dCellNodeOrder(refinedMeshBase);
    if (rhr) {
      std::cout << "2d node ordering right-hand rule: +z" << std::endl;
    } else {
      std::cout << "2d node ordering right-hand rule: -z" << std::endl;
    }
  }

  // Sideset implementation

  // Got coordinates for each boundary edge (two pts)
  vtkSmartPointer<vtkPoints> startPts = vtkSmartPointer<vtkPoints>::New();
  vtkSmartPointer<vtkPoints> endPts = vtkSmartPointer<vtkPoints>::New();
  getBoundaryEdgePts(startPts, endPts);

  // Initialize lists for storing sideset quantities
  vtkSmartPointer<vtkIdList> sidesetElementIdList =
      vtkSmartPointer<vtkIdList>::New();
  vtkSmartPointer<vtkIdList> sidesetSideIdList =
      vtkSmartPointer<vtkIdList>::New();
  // Find elements and sides in meshbase
  // Create two arrays:
  // -one with element ID for sideset cells
  // -one with side ID for each sideset cell
  getBoundarySideSets(refinedMeshBase, startPts, endPts, sidesetElementIdList,
                      sidesetSideIdList);

  // Setting meshbase metadata
  // Set meshbase sideset metadata
  vtkSmartPointer<vtkModelMetadata> sidesetData =
      vtkSmartPointer<vtkModelMetadata>::New();
  vtkSmartPointer<vtkStringArray> sidesetNames =
      vtkSmartPointer<vtkStringArray>::New();
  // currently supports one sideset
  sidesetNames->InsertNextValue(edgeSidesetName);
  sidesetData->SetSideSetNames(sidesetNames);

  // Convert sideset lists into int*
  std::vector<int> _sidesetElementIdList;
  for (int iId = 0; iId < sidesetElementIdList->GetNumberOfIds(); iId++) {
    _sidesetElementIdList.push_back(sidesetElementIdList->GetId(iId));
  }

  std::vector<int> _sidesetSideIdList;
  for (int iId = 0; iId < sidesetSideIdList->GetNumberOfIds(); iId++) {
    _sidesetSideIdList.push_back(sidesetSideIdList->GetId(iId));
  }

  // Set sidesets to meshbase
  sidesetData->SetSideSetElementList(_sidesetElementIdList.data());
  sidesetData->SetSideSetSideList(_sidesetSideIdList.data());
  int sidesetSizes[1] = {
      static_cast<int>(sidesetElementIdList->GetNumberOfIds())};

  sidesetData->SetSideSetSize(sidesetSizes);
  sidesetData->SetNumberOfSideSets(1);
  refinedMeshBase->setMetadata(sidesetData);

  refinedMeshBase->write();

  std::vector<meshBase *> mbVec;
  mbVec.push_back(refinedMeshBase);
  std::string exoName = exoMeshFName;

  NEM::DRV::ConversionDriver::genExo(mbVec, exoName);

  // Close HDF5 file
  closeFile();
}

~proteusHdf5()

proteusHdf5::~proteusHdf5

(

)

Definition at line 237 of file proteusHdf5.C.

{}

Member Function Documentation

closeFile()

int hdf5Reader::closeFile ( )

inherited

Returns

Integer flag: 0 (failure) or 1 (success)

Definition at line 63 of file hdf5Reader.C.

References hdf5Reader::file, and hdf5Reader::h5FileName.

Referenced by proteusHdf5().

                          {
  std::cout << "Closing HDF5 file " << h5FileName << std::endl;

  try {
    // Close HDF5 file
    file.close();
  } catch (FileIException error) {
#if H5_VERS_MAJOR >= 1 && H5_VERS_MINOR >= 8 && H5_VERS_RELEASE >= 20
    error.printErrorStack();
#elif H5_VERS_MAJOR >= 1 && H5_VERS_MINOR >= 10 && H5_VERS_RELEASE >= 2
    error.printErrorStack();
#elif H5_VERS_MAJOR >= 1 && H5_VERS_MINOR >= 11 && H5_VERS_RELEASE >= 0
      error.printErrorStack();
#else
    error.printError();
#endif
    return -1;
  }
  return 0;
}

exportToMeshBase()

void hdf5Reader::exportToMeshBase ( )

inherited

Definition at line 313 of file hdf5Reader.C.

References meshBase::Create(), hdf5Reader::exportToVTKMesh(), hdf5Reader::myMeshBase, and hdf5Reader::outputFname.

Referenced by proteusHdf5(), and hdf5Reader::writeVTK().

                                  {
  std::cout << "Exporting hdf5Reader object to meshBase format..." << std::endl;
  if (!vtkMesh) {
    exportToVTKMesh();
  }
  myMeshBase = meshBase::Create(vtkMesh, outputFname);
}

exportToVTKMesh()

void hdf5Reader::exportToVTKMesh ( )

inherited

Definition at line 241 of file hdf5Reader.C.

References hdf5Reader::getElementConnectivity(), NEM::MSH::New(), hdf5Reader::numDimensions, hdf5Reader::numElements, hdf5Reader::numVertices, points, hdf5Reader::vtkElementTypes, hdf5Reader::xCrd, hdf5Reader::yCrd, and hdf5Reader::zCrd.

Referenced by hdf5Reader::exportToMeshBase(), hdf5Reader::getVTKMesh(), and proteusHdf5().

                                 {
  std::cout << "Exporting hdf5Reader object to VTK format..." << std::endl;

  if (!vtkMesh) {
    // declare vtk dataset
    auto dataSet_tmp = vtkSmartPointer<vtkUnstructuredGrid>::New();

    // points to be pushed into dataSet
    auto points = vtkSmartPointer<vtkPoints>::New();
    // set double precision points
    points->SetDataTypeToDouble();

    // allocate size for vtk point container
    points->SetNumberOfPoints(numVertices);

    if (numDimensions == 2) {
      for (int i = 0; i < numVertices; ++i) {
        points->SetPoint(i, xCrd[i], yCrd[i], 0.0);
      }
    } else {
      for (int i = 0; i < numVertices; ++i) {
        points->SetPoint(i, xCrd[i], yCrd[i], zCrd[i]);
      }
    }
    // add points to vtk mesh data structure
    std::cout << "    setting VTK point data..." << std::endl;
    dataSet_tmp->SetPoints(points);
    // allocate space for elements
    std::cout << "    allocating memory for elements..." << std::endl;
    dataSet_tmp->Allocate(numElements);
    // add the elements
    std::cout << "    adding VTK elements..." << std::endl;
    for (int i = 0; i < numElements; ++i) {
      auto vtkElmIds = vtkSmartPointer<vtkIdList>::New();
      std::vector<int> elmIds(getElementConnectivity(i));
      vtkElmIds->SetNumberOfIds(elmIds.size());
      for (int j = 0; j < elmIds.size(); ++j) {
        vtkElmIds->SetId(j, elmIds[j] - 0);
      }
      switch (vtkElementTypes[i]) {
#if VTK_MAJOR_VERSION > 8 || (VTK_MAJOR_VERSION == 8 && VTK_MINOR_VERSION >= 1)
        case VTK_LAGRANGE_QUADRILATERAL:
          dataSet_tmp->InsertNextCell(VTK_LAGRANGE_QUADRILATERAL, vtkElmIds);
          break;
#endif
        case VTK_QUAD:
          dataSet_tmp->InsertNextCell(VTK_QUAD, vtkElmIds);
          break;
        case VTK_TRIANGLE:
          dataSet_tmp->InsertNextCell(VTK_TRIANGLE, vtkElmIds);
          break;
        default:
          std::cerr << "Unknown element type " << vtkElementTypes[i]
                    << std::endl;
          break;
      }
    }
    // build links - element incidences
    dataSet_tmp->BuildLinks();
    vtkMesh = dataSet_tmp;
  }
}

flattenBuffer2d()

template<class T >

void hdf5Reader::flattenBuffer2d ( std::vector< std::vector< T >>  originalBuffer, std::vector< T > &  flatBuffer  )

inlineinherited

Parameters

originalBuffer	Original unflattened data
flatBuffer	Output flattened data

Definition at line 241 of file hdf5Reader.H.

                                                 {
    // Populate flat buffer
    for (auto bufItr1 = originalBuffer.begin(); bufItr1 != originalBuffer.end();
         bufItr1++) {
      for (auto bufItr2 = (*bufItr1).begin(); bufItr2 != (*bufItr1).end();
           bufItr2++) {
        flatBuffer.push_back(*bufItr2);
      }
    }
  }

get2dCellNodeOrder()

bool proteusHdf5::get2dCellNodeOrder

(

meshBase *

myMeshBase

)

Parameters

myMeshBase

meshBase object of Proteus mesh

Returns

normal vector convention, projection onto positive z-axis: positive (true) or negative (false)

Definition at line 1055 of file proteusHdf5.C.

References meshBase::getDataSet().

Referenced by proteusHdf5().

                                                         {
  std::map<int, bool> rhr;
  for (int iCell = 0; iCell < myMeshBase->getDataSet()->GetNumberOfCells();
       iCell++) {
    // Get first cell
    vtkSmartPointer<vtkCell> testCell =
        myMeshBase->getDataSet()->GetCell(iCell);
    vtkSmartPointer<vtkPoints> cellPts = testCell->GetPoints();
    double pt0[3];
    double pt1[3];
    double pt2[3];
    double vc0[3];
    double vc1[3];
    double vc2[3];
    double zNorm[3] = {0, 0, 1};
    double res;
    if (testCell->GetCellType() == VTK_TRIANGLE) {
      cellPts->GetPoint(0, pt0);
      cellPts->GetPoint(1, pt1);
      cellPts->GetPoint(2, pt2);
      vtkMath::Subtract(pt1, pt0, vc0);
      vtkMath::Subtract(pt2, pt0, vc1);
    } else if (testCell->GetCellType() == VTK_QUAD) {
      cellPts->GetPoint(0, pt0);
      cellPts->GetPoint(1, pt1);
      cellPts->GetPoint(2, pt2);
      vtkMath::Subtract(pt1, pt0, vc0);
      vtkMath::Subtract(pt2, pt0, vc1);
    } else if (testCell->GetCellType() != VTK_QUAD &&
               testCell->GetCellType() != VTK_TRIANGLE) {
      std::cerr << "Only triangular and quadrilateral elements supported."
                << std::endl;
      exit(-1);
    } else {
      continue;
    }
    vtkMath::Cross(vc0, vc1, vc2);
    res = vtkMath::Dot(vc2, zNorm);

    bool ans;
    if (res > 0) {
      ans = true;
    } else {
      ans = false;
    }
    if ((testCell->GetCellType() == VTK_QUAD &&
         rhr.find(VTK_QUAD) == rhr.end()) ||
        (testCell->GetCellType() == VTK_TRIANGLE &&
         rhr.find(VTK_TRIANGLE) == rhr.end())) {
      rhr[testCell->GetCellType()] = ans;
    } else {
      if (rhr[testCell->GetCellType()] != ans) {
        std::cout << "Mismatched ordering for type " << testCell->GetCellType()
                  << ", cell number " << iCell << std::endl;
      }
    }
  }
  bool conv = false;
  for (auto itr = rhr.begin(); itr != rhr.end(); itr++) {
    if (itr == rhr.begin()) {
      conv = itr->second;
    } else {
      if (conv != itr->second) {
        std::cerr << "Error: Mesh contains multiple element types with "
                     "different node ordering."
                  << std::endl;
        exit(-1);
      }
    }
  }
  return conv;
}

getBlockElementData()

void proteusHdf5::getBlockElementData	(	Group &	group,
		proteusBlock &	myBlock
	)

Parameters

group	HDF5 Group object containing data
myBlock	Proteus block object to read

Definition at line 782 of file proteusHdf5.C.

References proteusBlock::elementData, elementVectorNames, proteusBlock::numElements, numElementVectors, hdf5Reader::readGroupDataSet(), and hdf5Reader::unflattenBuffer2d().

Referenced by getBlocks().

                                                                         {
  // Define GlobalID buffer
  int bufDim1 = numElementVectors;
  int bufDim2 = myBlock.numElements;
  int bufDimFlat = bufDim1 * bufDim2;

  // Buffer for HDF read (float)
  std::vector<float> flatBuffer(bufDimFlat, 0.0);

  // Buffer for proteusHDF5 object (2d double)
  std::vector<std::vector<double>> buffer(bufDim1,
                                          std::vector<double>(bufDim2, 0.0));

  // Read dataset from group
  readGroupDataSet("ELEMENTDATA", group, flatBuffer);

  // Convert to double
  std::vector<double> doubleFlatBuffer(flatBuffer.begin(), flatBuffer.end());

  // Unflatten buffer to 2d
  unflattenBuffer2d(doubleFlatBuffer, buffer);
  // Todo: Make this a generic templated function like flattenBuffer() above
  // auto resizedBuffer = unflattenBuffer(flatBuffer);

  // Output info to screen
  std::cout << "   Element Data info:" << std::endl;
  std::cout << "      Read in " << numElementVectors
            << " element data:" << std::endl;
  for (auto edItr = elementVectorNames.begin();
       edItr != elementVectorNames.end(); edItr++) {
    std::cout << "      " << *edItr << std::endl;
  }

  // Assign element data to block
  myBlock.elementData = buffer;
}

getBlockGlobalID()

void proteusHdf5::getBlockGlobalID	(	Group &	group,
		proteusBlock &	myBlock
	)

Parameters

group	HDF5 Group object containing data
myBlock	Proteus block object to read

Definition at line 758 of file proteusHdf5.C.

References proteusBlock::loc2Glob, proteusBlock::numElements, proteusBlock::numVerticesPerElement, and hdf5Reader::readGroupDataSet().

Referenced by getBlocks().

                                                                      {
  // Define GlobalID buffer
  int bufSize = myBlock.numElements * myBlock.numVerticesPerElement;
  std::vector<int> buffer(bufSize, 0);

  // Read dataset from group
  readGroupDataSet("GLOBALID", group, buffer);

  // Output info to screen
  std::cout << "   Global ID info:" << std::endl;
  std::cout << "      Read in "
            << myBlock.numElements * myBlock.numVerticesPerElement
            << " global IDs" << std::endl;

  // Create a map from local to global ID
  std::vector<int> tmpVec;
  for (int iBuf = 0; iBuf < bufSize; iBuf++) {
    tmpVec.push_back(buffer[iBuf]);
  }

  // Assign local to global ID map to block
  myBlock.loc2Glob = tmpVec;
}

getBlockInfo()

void proteusHdf5::getBlockInfo	(	Group &	group,
		proteusBlock &	myBlock
	)

Parameters

group	HDF5 Group object containing data
myBlock	Proteus block object to read

Definition at line 657 of file proteusHdf5.C.

References lowOrder, proteusBlock::numElements, proteusBlock::numVerticesPerElement, proteusBlock::originalVtkElementType, hdf5Reader::readGroupDataSet(), and proteusBlock::vtkElementType.

Referenced by getBlocks().

                                                                  {
  int bufSize = 3;
  std::vector<int> buffer(bufSize, 0);
  readGroupDataSet("INFO", group, buffer);

  std::vector<int> tmpVec;
  for (int iBuf = 0; iBuf < bufSize; iBuf++) {
    tmpVec.push_back(buffer[iBuf]);
  }
  myBlock.numElements = tmpVec[0];
  myBlock.numVerticesPerElement = tmpVec[1];

  // parse element type
  // Note: the element ID numbers below don't match up with the PROTEUS
  // documentation, but have been implemented based on PROTEUS HDF5 test files
  // provided
  if (tmpVec[2] == 162) {
    if (lowOrder) {
#if VTK_MAJOR_VERSION > 8 || (VTK_MAJOR_VERSION == 8 && VTK_MINOR_VERSION >= 1)
      myBlock.originalVtkElementType = VTK_LAGRANGE_QUADRILATERAL;
#else
      myBlock.originalVtkElementType = -1; // older VTK versions don't support
                                           // LAGRANGE_QUADRILATERAL types
#endif
      myBlock.vtkElementType = VTK_QUAD;
    } else {
#if VTK_MAJOR_VERSION > 8 || (VTK_MAJOR_VERSION == 8 && VTK_MINOR_VERSION >= 1)
      myBlock.originalVtkElementType = VTK_LAGRANGE_QUADRILATERAL;
      myBlock.vtkElementType = VTK_LAGRANGE_QUADRILATERAL;
#else
      myBlock.originalVtkElementType = VTK_QUAD;
      myBlock.vtkElementType = VTK_QUAD;
      std::cout << "Warning: VTK version " << vtkVersion::GetVTKSourceVersion()
                << " does not support Lagrange Quadrilateral cells."
                << std::endl;
#endif
    }
  } else if (tmpVec[2] == 160) {
    myBlock.originalVtkElementType = VTK_QUAD;
    myBlock.vtkElementType = VTK_QUAD;
  }
  // else if (tmpVec[2] == 110)
  // It looks like some of the triangle elements in Proteus test files have an
  // element type of 101 instead of 110, as documented in the user manual. I
  // have just added this as an additional element type to catch this.
  else if (tmpVec[2] == 110) {
    myBlock.originalVtkElementType = VTK_TRIANGLE;
    myBlock.vtkElementType = VTK_TRIANGLE;
  } else {
    std::cerr << "Element type not supported: " << tmpVec[2] << std::endl;
    exit(-1);
  }

  // Output info to screen
  std::cout << "   Info:" << std::endl;
  std::cout << "      Number of elements: " << tmpVec[0] << std::endl;
  std::cout << "      Number of vertices per element: "
            << myBlock.numVerticesPerElement << std::endl;
  std::cout << "      VTK element type: " << myBlock.vtkElementType
            << std::endl;
}

getBlocks()

void proteusHdf5::getBlocks ( )

private

Definition at line 308 of file proteusHdf5.C.

References proteusBlock::blockName, getBlockElementData(), getBlockGlobalID(), getBlockInfo(), getBlockVertexData(), getBlockXYZ(), numBlocks, proteusBlocks, and hdf5Reader::readGroup().

Referenced by proteusHdf5().

                            {
  std::cout << "Reading in PROTEUS block data..." << std::endl;

  for (int iBlock = 0; iBlock < numBlocks; iBlock++) {
    // Set PROTEUS convention block name
    std::string blockName = "BLOCK";
    std::string numStr = std::to_string(iBlock + 1); // Proteus blocks 1-indexed
    while (numStr.length() < 12) {
      numStr.insert(0, "0");
    }
    blockName += numStr;
    std::cout << "Reading in " + blockName + "..." << std::endl;

    // Create HDF5 Group object for block
    Group group;
    readGroup(blockName, group);

    // Create block object
    proteusBlock myBlock = proteusBlock();
    myBlock.blockName = blockName;

    // Read block info
    getBlockInfo(group, myBlock);

    // Read coordinates
    getBlockXYZ(group, myBlock);

    // Read global IDs
    getBlockGlobalID(group, myBlock);

    // Read element data
    getBlockElementData(group, myBlock);

    // Read vertex data
    getBlockVertexData(group, myBlock);

    // Push back proteus block into data structure
    proteusBlocks.push_back(myBlock);
  }

  std::cout << "Finished reading PROTEUS block data..." << std::endl;
}

getBlockVertexData()

void proteusHdf5::getBlockVertexData	(	Group &	group,
		proteusBlock &	myBlock
	)

Parameters

group	Vector of Proteus vector field names
myBlock	Number of vector fields

Definition at line 819 of file proteusHdf5.C.

References proteusBlock::numElements, numVertexVectors, proteusBlock::numVerticesPerElement, hdf5Reader::readGroupDataSet(), hdf5Reader::unflattenBuffer2d(), proteusBlock::vertexData, and vertexVectorNames.

Referenced by getBlocks().

                                                                        {
  // Define GlobalID buffer
  int bufDim1 = numVertexVectors;
  int bufDim2 = myBlock.numElements * myBlock.numVerticesPerElement;
  int bufDimFlat = bufDim1 * bufDim2;

  // Buffer for HDF read (float)
  std::vector<float> flatBuffer(bufDimFlat, 0.0);

  // Buffer for proteusHDF5 object (2d double)
  std::vector<std::vector<double>> buffer(bufDim1,
                                          std::vector<double>(bufDim2, 0.0));

  // Read dataset from group
  readGroupDataSet("VERTEXDATA", group, flatBuffer);

  // Convert to double
  std::vector<double> doubleFlatBuffer(flatBuffer.begin(), flatBuffer.end());

  // Unflatten buffer to 2d
  unflattenBuffer2d(doubleFlatBuffer, buffer);

  // Output info to screen
  std::cout << "   Vertex Data info:" << std::endl;
  std::cout << "      Read in " << numVertexVectors
            << " vertex data:" << std::endl;
  for (auto vdItr = vertexVectorNames.begin(); vdItr != vertexVectorNames.end();
       vdItr++) {
    std::cout << "      " << *vdItr << std::endl;
  }

  // Assign vertex data to block
  myBlock.vertexData = buffer;
}

getBlockXYZ()

void proteusHdf5::getBlockXYZ	(	Group &	group,
		proteusBlock &	myBlock
	)

Parameters

group	HDF5 Group object containing data
myBlock	Proteus block object to read

Definition at line 719 of file proteusHdf5.C.

References numDimensions, proteusBlock::numElements, proteusBlock::numVerticesPerElement, hdf5Reader::readGroupDataSet(), and proteusBlock::vertices.

Referenced by getBlocks().

                                                                 {
  // Define xyz buffer
  int bufSize =
      numDimensions * myBlock.numElements * myBlock.numVerticesPerElement;
  std::vector<float> buffer(bufSize, 0);

  // Read dataset from group
  readGroupDataSet("XYZ", group, buffer);

  // Output info to screen
  std::cout << "   Coordinate info:" << std::endl;
  std::cout << "      Read in " << bufSize << " vertex coordinates"
            << std::endl;
  for (int iDim = 0; iDim < numDimensions; iDim++) {
    std::cout << "      " << myBlock.numElements * myBlock.numVerticesPerElement
              << " in dimension " << iDim << std::endl;
  }

  // Convert vertex coordinates into an un-flattened array using row-major
  // ordering
  std::vector<std::vector<std::vector<double>>> tmpVec(
      myBlock.numElements,
      std::vector<std::vector<double>>(
          numDimensions,
          std::vector<double>(myBlock.numVerticesPerElement, 0.0)));
  int tmpInd = 0;
  for (int iElem = 0; iElem < myBlock.numElements; iElem++) {
    for (int iDim = 0; iDim < numDimensions; iDim++) {
      for (int iVert = 0; iVert < myBlock.numVerticesPerElement; iVert++) {
        tmpVec[iElem][iDim][iVert] = double(buffer[tmpInd]);
        tmpInd++;
      }
    }
  }

  // Assign vertex coordinates to block
  myBlock.vertices = tmpVec;
}

getBoundaryEdgePts()

void proteusHdf5::getBoundaryEdgePts	(	vtkSmartPointer< vtkPoints >	startPts,
		vtkSmartPointer< vtkPoints >	endPts
	)

Parameters

myMeshBase	meshBase object of Proteus mesh
edgeSidesetName	Name of sidesetGet boundary edge points of mesh using MAdLib
startPts	list containing first vertex of each boundary edge
endPts	list containing second vertex of each boundary edge

Definition at line 924 of file proteusHdf5.C.

References numDimensions.

Referenced by proteusHdf5().

                                                                        {
  if (numDimensions != 2) {
    std::cerr << "Error: Sidesets only supports for 2D meshes" << std::endl;
    exit(-1);
  }

  MAd::pGModel tmpMdl = NULL;
  MAd::GM_create(&tmpMdl, "");
  MAd::pMesh refinedMadMesh = MAd::M_new(tmpMdl);
  MAd::M_load(refinedMadMesh, "refined.msh");

  MAd::GM_create(&tmpMdl, "");
  MAd::pMesh skinnedMadMesh = MAd::M_new(tmpMdl);

  std::vector<int> regIds;
  refinedMadMesh->skin_me(skinnedMadMesh, regIds);

  MAd::EIter eit = MAd::M_edgeIter(skinnedMadMesh);
  MAd::pEdge pe;
  int edgeId = 0;
  double coord[3];
  while ((pe = MAd::EIter_next(eit))) {
    MAd::pVertex v = MAd::E_vertex(pe, 0);
    coord[0] = v->X;
    coord[1] = v->Y;
    coord[2] = v->Z;
    startPts->InsertPoint(edgeId, coord);

    v = MAd::E_vertex(pe, 1);
    coord[0] = v->X;
    coord[1] = v->Y;
    coord[2] = v->Z;
    endPts->InsertPoint(edgeId, coord);

    edgeId++;
  }
}

getBoundarySideSets()

void proteusHdf5::getBoundarySideSets	(	meshBase *	myMeshBase,
		vtkSmartPointer< vtkPoints >	startPts,
		vtkSmartPointer< vtkPoints >	endPts,
		vtkSmartPointer< vtkIdList >	sidesetElementIdList,
		vtkSmartPointer< vtkIdList >	sidesetSideIdList
	)

Parameters

myMeshBase	meshBase object of Proteus mesh
startPts	list containing first vertex of each boundary edge
endPts	list containing second vertex of each boundary edge
sidesetElementIdList	list containing element IDs for each edge in boundary sideset
sidesetSideIdList	list containing side IDs for each edge in boundary sideset

Definition at line 963 of file proteusHdf5.C.

References meshBase::getDataSet(), and NEM::MSH::New().

Referenced by proteusHdf5().

                                                  {
  // Build up locator
  vtkSmartPointer<vtkPointLocator> pointLocator =
      vtkSmartPointer<vtkPointLocator>::New();
  pointLocator->SetDataSet(myMeshBase->getDataSet());
  pointLocator->BuildLocator();

  // edge Pt iterators
  vtkIdType id1, id2;
  vtkSmartPointer<vtkIdList> cellList1 = vtkSmartPointer<vtkIdList>::New();
  vtkSmartPointer<vtkIdList> cellList2 = vtkSmartPointer<vtkIdList>::New();
  vtkCell *foundCell;
  vtkSmartPointer<vtkIdList> edgeIdListCompare =
      vtkSmartPointer<vtkIdList>::New();
  vtkSmartPointer<vtkIdList> edgeIdListOriginal =
      vtkSmartPointer<vtkIdList>::New();
  vtkSmartPointer<vtkIdList> edgeIdListIntersection =
      vtkSmartPointer<vtkIdList>::New();
  for (int iBndEdge = 0; iBndEdge < startPts->GetNumberOfPoints(); iBndEdge++) {
    // std::cout << "boundary edge: " << iBndEdge << std::endl;
    edgeIdListOriginal->Reset();

    id1 = pointLocator->FindClosestPoint(startPts->GetPoint(iBndEdge));
    id2 = pointLocator->FindClosestPoint(endPts->GetPoint(iBndEdge));

    edgeIdListOriginal->InsertNextId(id1);
    edgeIdListOriginal->InsertNextId(id2);

    myMeshBase->getDataSet()->GetPointCells(id1, cellList1);
    myMeshBase->getDataSet()->GetPointCells(id2, cellList2);

    cellList1->IntersectWith(cellList2);
    if (cellList1->GetNumberOfIds() != 1) {
      std::cerr << "Error: found multiple cells for boundary edge in a 2d mesh"
                << std::endl;
      exit(-1);
    } else {
      sidesetElementIdList->InsertNextId(cellList1->GetId(0));
      // std::cout << "    elem ID = " << cellList1->GetId(0) << std::endl;
      foundCell = myMeshBase->getDataSet()->GetCell(cellList1->GetId(0));
      vtkSmartPointer<vtkIdList> cellPts = vtkSmartPointer<vtkIdList>::New();
      myMeshBase->getDataSet()->GetCellPoints(cellList1->GetId(0), cellPts);
      for (int ipt = 0; ipt < cellPts->GetNumberOfIds(); ipt++) {
        double position[3];
        myMeshBase->getDataSet()->GetPoint(cellPts->GetId(ipt), position);
        // std::cout << "    ipt " << ipt << " position = " << position[0] << ",
        // "
        //          << position[1] << ", " << position[2] << std::endl;
      }
    }

    for (int iCellEdge = 0; iCellEdge < foundCell->GetNumberOfEdges();
         iCellEdge++) {
      edgeIdListCompare = foundCell->GetEdge(iCellEdge)->GetPointIds();

      // Alternate 'intersection' implementation due to pointer issues
      edgeIdListIntersection->Reset();
      for (int iId = 0; iId < edgeIdListOriginal->GetNumberOfIds(); iId++) {
        for (int jId = 0; jId < edgeIdListCompare->GetNumberOfIds(); jId++) {
          if (edgeIdListOriginal->GetId(iId) == edgeIdListCompare->GetId(jId)) {
            edgeIdListIntersection->InsertNextId(
                edgeIdListOriginal->GetId(iId));
          }
        }
      }

      if (edgeIdListIntersection->GetNumberOfIds() == 2) {
        sidesetSideIdList->InsertNextId(iCellEdge);
        // std::cout << "    side ID = " << iCellEdge << std::endl;
        break;
      }
      if (iCellEdge == foundCell->GetNumberOfEdges() - 1) {
        std::cout << "Couldn't find a matching side!" << std::endl;
      }
    }
  }
}

getCharStringLength()

int proteusHdf5::getCharStringLength

(

)

const

Returns

Length of string

Definition at line 1053 of file proteusHdf5.C.

References charStringLength.

{ return (charStringLength); }

getControlInformation()

void proteusHdf5::getControlInformation ( )

private

Definition at line 239 of file proteusHdf5.C.

References charStringLength, numBlocks, numDimensions, numElementVectors, numVertexVectors, and hdf5Reader::readTopDataSet().

Referenced by proteusHdf5().

                                        {
  std::cout << "Reading in PROTEUS control data..." << std::endl;

  // Set control buffer information
  H5std_string dsetName("CONTROL");
  int bufSize = 5;
  std::vector<int> buffer(bufSize, 0);

  // Read dataset
  readTopDataSet(dsetName, buffer);

  // Set control data
  numBlocks = buffer[0];
  numDimensions = buffer[1];
  numVertexVectors = buffer[2];
  numElementVectors = buffer[3];
  charStringLength = buffer[4];

  // Output to info to screen
  std::cout << "  Number of Blocks: " << numBlocks << std::endl;
  std::cout << "  Number of Dimensions: " << numDimensions << std::endl;
  std::cout << "  Number of Vertex Vectors: " << numVertexVectors << std::endl;
  std::cout << "  Number of Element Vectors: " << numElementVectors
            << std::endl;
  std::cout << "  Length of Character String: " << charStringLength
            << std::endl;
}

getElementConnectivity()

std::vector< int > hdf5Reader::getElementConnectivity ( int  elementId )

inherited

Parameters

elementId

Element ID

Returns

Element connectivity table

Definition at line 195 of file hdf5Reader.C.

References hdf5Reader::elementConnectivity, hdf5Reader::vtkElementTypes, and hdf5Reader::vtkElementTypesList.

Referenced by hdf5Reader::exportToVTKMesh().

                                                               {
  int nVerts;
  int connId = -1;
#if VTK_MAJOR_VERSION > 8 || (VTK_MAJOR_VERSION == 8 && VTK_MINOR_VERSION >= 1)
  if (vtkElementTypes[elementId] == VTK_LAGRANGE_QUADRILATERAL) {
    nVerts = 16;
    auto itr = std::find(vtkElementTypesList.begin(), vtkElementTypesList.end(),
                         VTK_LAGRANGE_QUADRILATERAL);
    if (itr != vtkElementTypesList.end()) {
      connId = distance(vtkElementTypesList.begin(), itr);
    }
  } else if (vtkElementTypes[elementId] == VTK_QUAD)
#else
  if (vtkElementTypes[elementId] == VTK_QUAD)
#endif
  {
    nVerts = 4;
    auto itr = std::find(vtkElementTypesList.begin(), vtkElementTypesList.end(),
                         VTK_QUAD);
    if (itr != vtkElementTypesList.end()) {
      connId = distance(vtkElementTypesList.begin(), itr);
    }
  } else if (vtkElementTypes[elementId] == VTK_TRIANGLE) {
    nVerts = 3;
    auto itr = std::find(vtkElementTypesList.begin(), vtkElementTypesList.end(),
                         VTK_TRIANGLE);
    if (itr != vtkElementTypesList.end()) {
      connId = distance(vtkElementTypesList.begin(), itr);
    }
  } else {
    std::cerr << "Element type not supported: " << vtkElementTypes[elementId]
              << std::endl;
    exit(-1);
  }
  if (connId != -1) {
    std::vector<int> subConnectivity(
        elementConnectivity[connId][elementId].begin(),
        elementConnectivity[connId][elementId].begin() + nVerts);
    return subConnectivity;
  } else {
    std::cerr << "Element type " << vtkElementTypes[elementId]
              << " not found in connectivity table" << std::endl;
    exit(-1);
  }
}

getFileName()

std::string hdf5Reader::getFileName ( )

inherited

Returns

HDF5 filename

Definition at line 39 of file hdf5Reader.C.

References hdf5Reader::h5FileName.

{ return h5FileName; }

getMeshBase()

meshBase * hdf5Reader::getMeshBase ( )

inherited

Returns

meshBase object

Definition at line 321 of file hdf5Reader.C.

References hdf5Reader::myMeshBase.

Referenced by proteusHdf5().

{ return myMeshBase; }

getNumBlocks()

int proteusHdf5::getNumBlocks

(

)

const

Returns

Number of blocks

Definition at line 1045 of file proteusHdf5.C.

References numBlocks.

{ return (numBlocks); }

getNumDimensions()

int proteusHdf5::getNumDimensions

(

)

const

Returns

Number of dimensions

Definition at line 1047 of file proteusHdf5.C.

References numDimensions.

Referenced by proteusHdf5().

{ return (numDimensions); }

getNumElementVectors()

int proteusHdf5::getNumElementVectors

(

)

const

Returns

Number of element vectors

Definition at line 1051 of file proteusHdf5.C.

References numElementVectors.

{ return (numElementVectors); }

getNumVertexVectors()

int proteusHdf5::getNumVertexVectors

(

)

const

Returns

Number of vertex vectors

Definition at line 1049 of file proteusHdf5.C.

References numVertexVectors.

{ return (numVertexVectors); }

getVectorNames()

void proteusHdf5::getVectorNames	(	std::string	name,
		std::vector< std::string > &	stringVector,
		int	numVectors
	)

Parameters

name	String description of Proteus vector field names to read
stringVector	Vector of Proteus vector field names
numVectors	Number of vector fields

Definition at line 267 of file proteusHdf5.C.

References charStringLength, and hdf5Reader::readTopDataSet().

Referenced by proteusHdf5().

                                                 {
  std::cout << "Reading in PROTEUS " << name << "..." << std::endl;

  // Set vector buffer information
  H5std_string dsetName(name);
  std::string buffer;

  // Read dataset
  readTopDataSet(dsetName, buffer);

  // Set element vector names
  int bufSize = numVectors * charStringLength;
  std::string tmp = "";
  std::string buf = "";
  int iCharCnt = 0;
  int iChar = 0;
  while (iChar <= bufSize) {
    buf = "";
    buf += buffer[iChar];
    if (!(iCharCnt < charStringLength)) {
      stringVector.push_back(std::string(tmp));
      tmp = "";
      iCharCnt = 0;
    }
    if (buf.compare(" ") != 0) {
      tmp += buffer[iChar];
    }
    iChar++;
    iCharCnt++;
  }

  // Output info to screen
  std::cout << "Found " << name << ":" << std::endl;
  for (auto nameItr = stringVector.begin(); nameItr != stringVector.end();
       nameItr++) {
    std::cout << "  " << *nameItr << std::endl;
  }
}

getVTKMesh()

vtkSmartPointer< vtkDataSet > hdf5Reader::getVTKMesh ( )

inherited

Returns

Pointer to vtkDataSet

Definition at line 304 of file hdf5Reader.C.

References hdf5Reader::exportToVTKMesh(), and hdf5Reader::vtkMesh.

                                                   {
  if (vtkMesh)
    return vtkMesh;
  else {
    exportToVTKMesh();
    return vtkMesh;
  }
}

mergeBlocks()

void proteusHdf5::mergeBlocks ( )

private

Definition at line 351 of file proteusHdf5.C.

References proteusSuperBlock::coordinates, hdf5Reader::elementConnectivity, proteusSuperBlock::elementData, proteusSuperBlock::elements, proteusSuperBlock::elementTypes, proteusSuperBlock::elementTypesList, proteusSuperBlock::maxNumVerticesPerElement, mySuperBlock, numDimensions, proteusSuperBlock::numElements, numElementVectors, numVertexVectors, proteusSuperBlock::numVertices, proteusSuperBlock::originalElementTypesList, proteusBlocks, proteusSuperBlock::vertexData, proteusSuperBlock::vtkConnectivity, proteusSuperBlock::xCrd, proteusSuperBlock::yCrd, and proteusSuperBlock::zCrd.

Referenced by proteusHdf5().

                              {
  std::cout << "Merging PROTEUS block data..." << std::endl;

  // Determine total number of vertices based on maximum global ID
  int numGlobalVertices = 0;

  // Determine total number of elements
  int numGlobalElements = 0;
  int maxNumVerticesPerElement = 0;

  // Determine number of element types
  std::vector<int> elementTypesList;
  std::vector<int> originalElementTypesList;

  for (auto blockItr = proteusBlocks.begin(); blockItr != proteusBlocks.end();
       blockItr++) {
    // Get number of global vertex Ids
    int localMaxVertexId = *std::max_element((*blockItr).loc2Glob.begin(),
                                             (*blockItr).loc2Glob.end());
    if (localMaxVertexId > numGlobalVertices) {
      numGlobalVertices = localMaxVertexId;
    }

    // Accumulate number of global element Ids
    numGlobalElements += (*blockItr).numElements;

    // Get maximum number of vertices per element
    if ((*blockItr).numVerticesPerElement > maxNumVerticesPerElement) {
      maxNumVerticesPerElement = (*blockItr).numVerticesPerElement;
    }

    if (std::find(originalElementTypesList.begin(),
                  originalElementTypesList.end(),
                  (*blockItr).originalVtkElementType) ==
        originalElementTypesList.end()) {
      originalElementTypesList.push_back((*blockItr).originalVtkElementType);
      elementTypesList.push_back((*blockItr).vtkElementType);
    }
  }
  numGlobalVertices++; // global vertices are 0-indexed, so total number is
                       // maxID+1

  // Set superblock info
  mySuperBlock.numVertices = numGlobalVertices;
  mySuperBlock.numElements = numGlobalElements;
  mySuperBlock.maxNumVerticesPerElement = maxNumVerticesPerElement;

  std::cout << "    Found " << numGlobalVertices << " global vertices"
            << std::endl;
  std::cout << "    Found " << numGlobalElements << " global elements"
            << std::endl;

  // Vector to store global vertices
  std::vector<std::vector<double>> coordinates(
      numGlobalVertices, std::vector<double>(numDimensions, 0.0));

  // Vector to store global elements
  std::vector<std::vector<int>> elements(
      numGlobalElements, std::vector<int>(maxNumVerticesPerElement, 0));

  // Map of element to VTK element type
  std::vector<int> elementTypes(numGlobalElements);

  // Vector to store vertex data
  std::vector<std::vector<double>> vertexData(
      numVertexVectors, std::vector<double>(numGlobalVertices, 0.0));

  // Vector to store element data
  std::vector<std::vector<double>> elementData(
      numElementVectors, std::vector<double>(numGlobalElements, 0.0));

  // Instantiate variables for loops below
  int locVertId, globElemId, locElemId;
  int lId, gId, vertNo, dimNo, origId;
  globElemId = 0;

  // Loop over blocks
  std::cout << "    Accumulating mesh information from each block..."
            << std::endl;
  for (auto blockItr = proteusBlocks.begin(); blockItr != proteusBlocks.end();
       blockItr++) {
    std::cout << "        " << (*blockItr).blockName << ":" << std::endl;
    locVertId = 0;
    locElemId = 0;
    // Loop over element coordinates
    for (auto elemItr = (*blockItr).vertices.begin();
         elemItr != (*blockItr).vertices.end(); elemItr++) {
      // Loop over dimension coordinates
      origId = locVertId;
      for (auto dimItr = (*elemItr).begin(); dimItr != (*elemItr).end();
           dimItr++) {
        locVertId = origId;
        dimNo = distance((*elemItr).begin(), dimItr);
        // Loop over vertex coordinates
        for (auto vertItr = (*dimItr).begin(); vertItr != (*dimItr).end();
             vertItr++) {
          vertNo = distance((*dimItr).begin(), vertItr);
          elements[globElemId][vertNo] = (*blockItr).loc2Glob[locVertId];
          coordinates[(*blockItr).loc2Glob[locVertId]][dimNo] = *vertItr;
          locVertId++;
        }
        elementTypes[globElemId] = (*blockItr).vtkElementType;
      }

      // Accumulate element field data
      for (int iElemData = 0; iElemData < numElementVectors; iElemData++) {
        elementData[iElemData][globElemId] =
            (*blockItr).elementData[iElemData][locElemId];
      }

      locElemId++;
      globElemId++;
    }

    // Loop over vertices
    for (auto vertItr = (*blockItr).loc2Glob.begin();
         vertItr != (*blockItr).loc2Glob.end(); vertItr++) {
      lId = distance((*blockItr).loc2Glob.begin(), vertItr);
      gId = *vertItr;
      for (int iVertData = 0; iVertData < numVertexVectors; iVertData++) {
        vertexData[iVertData][gId] = (*blockItr).vertexData[iVertData][lId];
      }
    }

    std::cout << "            " << (*blockItr).vertices.size() << " vertices"
              << std::endl;
    std::cout << "            " << (*blockItr).numElements << " elements"
              << std::endl;
    std::cout << "            " << numVertexVectors << " vertex fields"
              << std::endl;
    std::cout << "            " << numElementVectors << " element fields"
              << std::endl;
  }

  // Re-structure data into separate x,y,z coordinates (todo: could be done in
  // loops above)
  std::cout << "    Separating coordinate arrays into individual dimension "
               "arrays..."
            << std::endl;
  for (auto vertItr = coordinates.begin(); vertItr != coordinates.end();
       vertItr++) {
    mySuperBlock.xCrd.push_back((*vertItr)[0]);
    if (numDimensions > 1) {
      mySuperBlock.yCrd.push_back((*vertItr)[1]);
    }
    if (numDimensions > 2) {
      mySuperBlock.zCrd.push_back((*vertItr)[2]);
    }
  }

  // Convert element connectivity information into a format that is easier to
  // parse for hdf5Reader class. (todo: chould be done in loops above) Main
  // structure shown below: elementConnectivity[element type no][global
  // element id][vertex no] = [global vertex id] elementTypesList[element type
  // no] = vtk element type integer
  std::cout << "    Sorting element connectivities by element type..."
            << std::endl;
  std::vector<std::map<int, std::vector<int>>> elementConnectivity;

  // Loop over original element type list (contains all element types read in
  // across all blocks)
  auto origTypeItr = originalElementTypesList.begin();
  while (origTypeItr != originalElementTypesList.end()) {
    // temporary map for storing connectivity for each element type
    std::map<int, std::vector<int>> tmpElementConnectivity;

    int vertNum, elemId;
    // Loop over elements and their types
    auto elemItr = elements.begin();
    auto elemTypeItr = elementTypes.begin();
    while (elemItr != elements.end() || elemTypeItr != elementTypes.end()) {
      // Get global element id
      elemId = distance(elements.begin(), elemItr);
      // Loop over all vertices of each element
      for (auto vertItr = (*elemItr).begin(); vertItr != (*elemItr).end();
           vertItr++) {
        // Get vertex number
        vertNum = distance((*elemItr).begin(), vertItr);
        // Check element type against each supported type
        if (*elemTypeItr == VTK_QUAD) {
// Remove extra vertices from high-order Lagrange quads if output
// to lower-order quad is desired
#if VTK_MAJOR_VERSION > 8 || (VTK_MAJOR_VERSION == 8 && VTK_MINOR_VERSION >= 1)
          if (*origTypeItr == VTK_LAGRANGE_QUADRILATERAL) {
            if (vertNum == 0 || vertNum == 3 || vertNum == 12 ||
                vertNum == 15) {
              tmpElementConnectivity[elemId].push_back(*vertItr);
            }
          } else {
            tmpElementConnectivity[elemId].push_back(*vertItr);
          }
#else
          if (*origTypeItr == -1) // lower VTK versions don't have
                                  // LAGRANGE_QUADRILATERAL types
          {
            if (vertNum == 0 || vertNum == 3 || vertNum == 12 ||
                vertNum == 15) {
              tmpElementConnectivity[elemId].push_back(*vertItr);
            }
          } else {
            tmpElementConnectivity[elemId].push_back(*vertItr);
          }
#endif
        }
#if VTK_MAJOR_VERSION > 8 || (VTK_MAJOR_VERSION == 8 && VTK_MINOR_VERSION >= 1)
        else if (*elemTypeItr == VTK_LAGRANGE_QUADRILATERAL) {
          tmpElementConnectivity[elemId].push_back(*vertItr);
        }
#endif
        else if (*elemTypeItr == VTK_TRIANGLE) {
          tmpElementConnectivity[elemId].push_back(*vertItr);
        }
      }

      // Increment element and element type iterators
      if (elemItr != elements.end()) {
        ++elemItr;
      }
      if (elemTypeItr != elementTypes.end()) {
        ++elemTypeItr;
      }
    }

    // Push back each inidividual element type connectivity
    // into vector containing all types
    elementConnectivity.push_back(tmpElementConnectivity);

    if (origTypeItr != originalElementTypesList.end()) {
      ++origTypeItr;
    }
  }

  // Re-order vertices per VTK convention
  std::cout << "    Re-ordering element vertices per VTK convention..."
            << std::endl;
  int vertCount;
  int swapVert1 = -1, swapVert2 = -1;
  int connId;
  // If VTK_QUAD, re-order vertices
  auto testIt =
      std::find(elementTypesList.begin(), elementTypesList.end(), VTK_QUAD);
  if (testIt != elementTypesList.end()) {
    std::cout << "        Re-ordering VTK_QUAD element vertices..."
              << std::endl;
    connId = distance(elementTypesList.begin(), testIt);
    for (auto elemIt = elementConnectivity[connId].begin();
         elemIt != elementConnectivity[connId].end(); elemIt++) {
      vertCount = 0;
      for (int i = 0; i < (elemIt->second).size(); i++) {
        if (vertCount == 2) {
          swapVert1 = (elemIt->second)[i];
        }
        if (vertCount == 3) {
          swapVert2 = (elemIt->second)[i];
          (elemIt->second)[i] = swapVert1;
          (elemIt->second)[i - 1] = swapVert2;
          vertCount = -1;
        }
        vertCount++;
      }
    }
  }
  // If VTK_TRI, re-order vertices
  /*
  testIt = std::find(elementTypesList.begin(), elementTypesList.end(),
  VTK_TRIANGLE); if (testIt != elementTypesList.end())
  {
    std::cout << "        Re-ordering VTK_TRIANGLE element vertices..." <<
  std::endl; connId = distance(elementTypesList.begin(), testIt); for (auto
  elemIt = elementConnectivity[connId].begin(); elemIt !=
  elementConnectivity[connId].end(); elemIt++)
    {
      vertCount = 0;
      for (int i = 0; i < (elemIt->second).size(); i++)
      {
        if (vertCount == 1)
        {
          swapVert1 = (elemIt->second)[i];
        }
        if (vertCount == 2)
        {
          swapVert2 = (elemIt->second)[i];
          (elemIt->second)[i] = swapVert1;
          (elemIt->second)[i-1] = swapVert2;
          vertCount = -1;
        }
        vertCount++;
      }
    }
  }
  */

  // Set data in superBlock struct
  std::cout << "    Setting mesh data in PROTEUS superblock..." << std::endl;
  mySuperBlock.coordinates = coordinates;
  mySuperBlock.elements = elements;
  mySuperBlock.vertexData = vertexData;
  mySuperBlock.elementData = elementData;
  mySuperBlock.vtkConnectivity = elementConnectivity;
  mySuperBlock.elementTypesList = elementTypesList;
  mySuperBlock.originalElementTypesList = originalElementTypesList;
  mySuperBlock.elementTypes = elementTypes;

  std::cout << "Finished merging PROTEUS block data..." << std::endl;
}

openFile()

int hdf5Reader::openFile ( )

inherited

Returns

Integer flag: 0 (failure) or 1 (success)

Definition at line 41 of file hdf5Reader.C.

References hdf5Reader::file, and hdf5Reader::h5FileName.

Referenced by proteusHdf5().

                         {
  std::cout << "Opening HDF5 file " << h5FileName << std::endl;

  try {
    // Open HDF5 file
    H5std_string h5FileName_(h5FileName);
    file.openFile(h5FileName_, H5F_ACC_RDWR);
  } catch (FileIException error) {
#if H5_VERS_MAJOR >= 1 && H5_VERS_MINOR >= 8 && H5_VERS_RELEASE >= 20
    error.printErrorStack();
#elif H5_VERS_MAJOR >= 1 && H5_VERS_MINOR >= 10 && H5_VERS_RELEASE >= 2
    error.printErrorStack();
#elif H5_VERS_MAJOR >= 1 && H5_VERS_MINOR >= 11 && H5_VERS_RELEASE >= 0
      error.printErrorStack();
#else
    error.printError();
#endif
    return -1;
  }
  return 0;
}

readDataSet() [1/2]

int hdf5Reader::readDataSet ( DataSet  dset, std::string &  buffer  )

inherited

Parameters

dset	HDF5 dataset
buffer	Buffer into which data is read

Returns

Integer flag: 0 (failure) or 1 (success)

Definition at line 109 of file hdf5Reader.C.

Referenced by hdf5Reader::readTopDataSet().

                                                           {
  try {
    // Get type of data
    DataType dtype = dset.getDataType();
    // Read data
    dset.read(buffer, dtype);
    // Close dataset
    dset.close();
  }
  // catch failure caused by the H5File operations
  catch (DataSetIException error) {
#if H5_VERS_MAJOR >= 1 && H5_VERS_MINOR >= 8 && H5_VERS_RELEASE >= 20
    error.printErrorStack();
#elif H5_VERS_MAJOR >= 1 && H5_VERS_MINOR >= 10 && H5_VERS_RELEASE >= 2
    error.printErrorStack();
#elif H5_VERS_MAJOR >= 1 && H5_VERS_MINOR >= 11 && H5_VERS_RELEASE >= 0
      error.printErrorStack();
#else
    error.printError();
#endif
    return -1;
  }
  return 0;
}

readDataSet() [2/2]

template<class T >

int hdf5Reader::readDataSet ( DataSet  dset, std::vector< T > &  buffer  )

inlineinherited

Parameters

dset	HDF5 dataset
buffer	Buffer into which numeric data is read

Returns

Integer flag: 0 (failure) or 1 (success)

Definition at line 148 of file hdf5Reader.H.

                                                                         {
    try {
      // Get type of data
      DataType dtype = dset.getDataType();
      // Read data
      dset.read(&buffer[0], dtype);
      // Close dataset
      dset.close();
    }
    // catch failure caused by the H5File operations
    catch (DataSetIException error) {
#if H5_VERS_MAJOR >= 1 && H5_VERS_MINOR >= 8 && H5_VERS_RELEASE >= 20
      error.printErrorStack();
#elif H5_VERS_MAJOR >= 1 && H5_VERS_MINOR >= 10 && H5_VERS_RELEASE >= 2
      error.printErrorStack();
#elif H5_VERS_MAJOR >= 1 && H5_VERS_MINOR >= 11 && H5_VERS_RELEASE >= 0
      error.printErrorStack();
#else
      error.printError();
#endif
      return -1;
    }

    return 0;
  }

readGroup()

int hdf5Reader::readGroup ( std::string  groupName, Group &  group  )

inherited

Parameters

groupName	HDF5 group object name
group	HDF5 group object

Returns

Integer flag: 0 (failure) or 1 (success)

Definition at line 135 of file hdf5Reader.C.

References hdf5Reader::file.

Referenced by getBlocks().

                                                           {
  try {
    // Open group
    group = Group(file.openGroup(groupName));
  } catch (FileIException error) {
#if H5_VERS_MAJOR >= 1 && H5_VERS_MINOR >= 8 && H5_VERS_RELEASE >= 20
    error.printErrorStack();
#elif H5_VERS_MAJOR >= 1 && H5_VERS_MINOR >= 10 && H5_VERS_RELEASE >= 2
    error.printErrorStack();
#elif H5_VERS_MAJOR >= 1 && H5_VERS_MINOR >= 11 && H5_VERS_RELEASE >= 0
      error.printErrorStack();
#else
    error.printError();
#endif
    return -1;
  }
  return 0;
}

readGroupDataSet()

template<class T >

int hdf5Reader::readGroupDataSet ( std::string  dsetName, Group &  group, std::vector< T > &  buffer  )

inlineinherited

Parameters

dsetName	DataSet name
group	HDF5 group object
buffer	Buffer into which numeric data is read

Returns

Integer flag: 0 (failure) or 1 (success)

Definition at line 190 of file hdf5Reader.H.

Referenced by getBlockElementData(), getBlockGlobalID(), getBlockInfo(), getBlockVertexData(), and getBlockXYZ().

                                             {
    try {
      // Open dataset
      DataSet dset = group.openDataSet(dsetName);
      // Get type of data
      DataType dtype = dset.getDataType();
      // Read data
      dset.read(&buffer[0], dtype);
      // Close dataset
      dset.close();
    }
    // catch failure caused by the H5File operations
    catch (GroupIException error) {
#if H5_VERS_MAJOR >= 1 && H5_VERS_MINOR >= 8 && H5_VERS_RELEASE >= 20
      error.printErrorStack();
#elif H5_VERS_MAJOR >= 1 && H5_VERS_MINOR >= 10 && H5_VERS_RELEASE >= 2
      error.printErrorStack();
#elif H5_VERS_MAJOR >= 1 && H5_VERS_MINOR >= 11 && H5_VERS_RELEASE >= 0
      error.printErrorStack();
#else
      error.printError();
#endif
      return -1;
    } catch (DataSetIException error) {
#if H5_VERS_MAJOR >= 1 && H5_VERS_MINOR >= 8 && H5_VERS_RELEASE >= 20
      error.printErrorStack();
#elif H5_VERS_MAJOR >= 1 && H5_VERS_MINOR >= 10 && H5_VERS_RELEASE >= 2
      error.printErrorStack();
#elif H5_VERS_MAJOR >= 1 && H5_VERS_MINOR >= 11 && H5_VERS_RELEASE >= 0
      error.printErrorStack();
#else
      error.printError();
#endif
      return -1;
    }

    return 0;
  }

readTopDataSet() [1/2]

int hdf5Reader::readTopDataSet ( std::string  dsetName, std::string &  buffer  )

inherited

Parameters

dsetName	Dataset name
buffer	Buffer into which string data is read

Returns

Integer flag: 0 (failure) or 1 (success)

Definition at line 85 of file hdf5Reader.C.

References hdf5Reader::file, and hdf5Reader::readDataSet().

Referenced by getControlInformation(), and getVectorNames().

                                                                    {
  try {
    // Open dataset
    DataSet dset = file.openDataSet(dsetName);
    // Read dataset
    readDataSet(dset, buffer);
  }
  // catch failure caused by the H5File operations
  catch (FileIException error) {
#if H5_VERS_MAJOR >= 1 && H5_VERS_MINOR >= 8 && H5_VERS_RELEASE >= 20
    error.printErrorStack();
#elif H5_VERS_MAJOR >= 1 && H5_VERS_MINOR >= 10 && H5_VERS_RELEASE >= 2
    error.printErrorStack();
#elif H5_VERS_MAJOR >= 1 && H5_VERS_MINOR >= 11 && H5_VERS_RELEASE >= 0
      error.printErrorStack();
#else
    error.printError();
#endif
    return -1;
  }
  return 0;
}

readTopDataSet() [2/2]

template<class T >

int hdf5Reader::readTopDataSet ( std::string  dsetName, std::vector< T > &  buffer  )

inlineinherited

Parameters

dsetName	Dataset name
buffer	Buffer into which numeric data is read

Returns

Integer flag: 0 (failure) or 1 (success)

Definition at line 115 of file hdf5Reader.H.

                                                               {
    try {
      std::cout << "H5_VERS_MAJOR = " << H5_VERS_MAJOR << std::endl;
      std::cout << "H5_VERS_MINOR = " << H5_VERS_MINOR << std::endl;
      std::cout << "H5_VERS_RELEASE = " << H5_VERS_RELEASE << std::endl;
      std::cout << "H5_VERS_SUBRELEASE = " << H5_VERS_SUBRELEASE << std::endl;
      // Open dataset
      DataSet dset = file.openDataSet(dsetName);
      readDataSet(dset, buffer);
    }
    // catch failure caused by the H5File operations
    catch (FileIException error) {
#if H5_VERS_MAJOR >= 1 && H5_VERS_MINOR >= 8 && H5_VERS_RELEASE >= 20
      error.printErrorStack();
#elif H5_VERS_MAJOR >= 1 && H5_VERS_MINOR >= 10 && H5_VERS_RELEASE >= 2
      error.printErrorStack();
#elif H5_VERS_MAJOR >= 1 && H5_VERS_MINOR >= 11 && H5_VERS_RELEASE >= 0
      error.printErrorStack();
#else
      error.printError();
#endif
      return -1;
    }

    return 0;
  }

setConnectivities()

void hdf5Reader::setConnectivities ( std::vector< std::map< int, std::vector< int >>>  elementConnectivity )

inherited

Parameters

elementConnectivity

Element connectivity table

Definition at line 190 of file hdf5Reader.C.

References hdf5Reader::elementConnectivity.

Referenced by proteusHdf5().

                                                                 {
  elementConnectivity = _elementConnectivity;
}

setCoordinates() [1/3]

void hdf5Reader::setCoordinates ( std::vector< double >  xCrd )

inherited

Parameters

xCrd	vector of x-coordinates

Definition at line 166 of file hdf5Reader.C.

References hdf5Reader::xCrd.

Referenced by proteusHdf5().

{ xCrd = _xCrd; }

setCoordinates() [2/3]

void hdf5Reader::setCoordinates ( std::vector< double >  xCrd, std::vector< double >  yCrd  )

inherited

Parameters

xCrd	vector of x-coordinates
yCrd	vector of y-coordinates

Definition at line 168 of file hdf5Reader.C.

References hdf5Reader::xCrd, and hdf5Reader::yCrd.

                                                         {
  xCrd = _xCrd;
  yCrd = _yCrd;
}

setCoordinates() [3/3]

void hdf5Reader::setCoordinates ( std::vector< double >  xCrd, std::vector< double >  yCrd, std::vector< double >  zCrd  )

inherited

Parameters

xCrd	vector of x-coordinates
yCrd	vector of y-coordinates
zCrd	vector of z-coordinates

Definition at line 174 of file hdf5Reader.C.

References hdf5Reader::xCrd, hdf5Reader::yCrd, and hdf5Reader::zCrd.

                                                         {
  xCrd = _xCrd;
  yCrd = _yCrd;
  zCrd = _zCrd;
}

setElementTypes()

void hdf5Reader::setElementTypes ( std::vector< int >  vtkElementTypes )

inherited

Parameters

vtkElementTypes

Vector of VTK element types for each element

Definition at line 182 of file hdf5Reader.C.

References hdf5Reader::vtkElementTypes.

Referenced by proteusHdf5().

                                                                {
  vtkElementTypes = _vtkElementTypes;
}

setElementTypesList()

void hdf5Reader::setElementTypesList ( std::vector< int >  vtkElementTypesList )

inherited

Parameters

vtkElementTypesList

Vector of each unique VTK element type in mesh

Definition at line 186 of file hdf5Reader.C.

References hdf5Reader::vtkElementTypesList.

Referenced by proteusHdf5().

                                                                        {
  vtkElementTypesList = _vtkElementTypesList;
}

setFields()

void hdf5Reader::setFields ( meshBase *  myMeshBase, std::vector< std::string >  dataNames, std::vector< std::vector< double >>  data, int  pointOrCell  )

inherited

Parameters

myMeshBase	meshBase object
dataNames	Vector of names of data fields
data	Vector storing data
pointOrCell	Boolean indicating point or cell data

Definition at line 323 of file hdf5Reader.C.

References data, meshBase::setCellDataArray(), and meshBase::setPointDataArray().

Referenced by proteusHdf5().

                                            {
  if (pointOrCell == 0) {
    std::cout << "Setting hdf5Reader object point fields..." << std::endl;
  } else if (pointOrCell == 1) {
    std::cout << "Setting hdf5Reader object cell fields..." << std::endl;
  }

  // Set element data
  auto dataNameItr = dataNames.begin();
  auto dataItr = data.begin();
  while (dataNameItr != dataNames.end() || dataItr != data.end()) {
    std::cout << "    " << *dataNameItr << std::endl;

    if (pointOrCell == 0) {
      myMeshBase->setPointDataArray((*dataNameItr).c_str(), *dataItr);
    } else if (pointOrCell == 1) {
      myMeshBase->setCellDataArray((*dataNameItr).c_str(), *dataItr);
    }

    if (dataNameItr != dataNames.end()) {
      dataNameItr++;
    }
    if (dataItr != data.end()) {
      dataItr++;
    }
  }
}

setNumberOfDimensions()

void hdf5Reader::setNumberOfDimensions ( int  numDimensions )

inherited

Parameters

numDimensions

Number of spatial dimensions

Definition at line 162 of file hdf5Reader.C.

References hdf5Reader::numDimensions.

Referenced by proteusHdf5().

                                                         {
  numDimensions = _numDimensions;
}

setNumberOfElements()

void hdf5Reader::setNumberOfElements ( int  numElements )

inherited

Parameters

numElements

Number of elements

Definition at line 158 of file hdf5Reader.C.

References hdf5Reader::numElements.

Referenced by proteusHdf5().

                                                     {
  numElements = _numElements;
}

setNumberOfVertices()

void hdf5Reader::setNumberOfVertices ( int  numVertices )

inherited

Parameters

numVertices

Number of vertices

Definition at line 154 of file hdf5Reader.C.

References hdf5Reader::numVertices.

Referenced by proteusHdf5().

                                                     {
  numVertices = _numVertices;
}

unflattenBuffer2d()

template<class T >

void hdf5Reader::unflattenBuffer2d ( std::vector< T >  flatBuffer, std::vector< std::vector< T >> &  originalBuffer  )

inlineinherited

Parameters

flatBuffer	Original flattened data
originalBuffer	Output unflattened data

Definition at line 258 of file hdf5Reader.H.

References data.

Referenced by getBlockElementData(), and getBlockVertexData().

                                                                  {
    // Populate original buffer
    auto flatItr = flatBuffer.begin();
    for (auto bufItr1 = originalBuffer.begin(); bufItr1 != originalBuffer.end();
         bufItr1++) {
      for (auto bufItr2 = (*bufItr1).begin(); bufItr2 != (*bufItr1).end();
           bufItr2++) {
        *bufItr2 = *flatItr;
        flatItr++;
      }
    }
  }

writeVTK()

void hdf5Reader::writeVTK ( )

inherited

Definition at line 354 of file hdf5Reader.C.

References hdf5Reader::exportToMeshBase(), hdf5Reader::myMeshBase, and meshBase::write().

                          {
  std::cout << "Writing hdf5Reader object to VTK file" << std::endl;
  if (!myMeshBase) {
    exportToMeshBase();
  }
  myMeshBase->write();
}

Member Data Documentation

baseH5FileName

std::string hdf5Reader::baseH5FileName

protectedinherited

Definition at line 373 of file hdf5Reader.H.

charStringLength

int proteusHdf5::charStringLength

private

Definition at line 249 of file proteusHdf5.H.

Referenced by getCharStringLength(), getControlInformation(), and getVectorNames().

elementConnectivity

std::vector<std::map<int, std::vector<int> > > hdf5Reader::elementConnectivity

protectedinherited

Definition at line 383 of file hdf5Reader.H.

Referenced by hdf5Reader::getElementConnectivity(), mergeBlocks(), and hdf5Reader::setConnectivities().

elementVectorNames

std::vector<std::string> proteusHdf5::elementVectorNames

private

Definition at line 255 of file proteusHdf5.H.

Referenced by getBlockElementData(), and proteusHdf5().

file

H5File hdf5Reader::file

protectedinherited

Definition at line 376 of file hdf5Reader.H.

Referenced by hdf5Reader::closeFile(), hdf5Reader::openFile(), hdf5Reader::readGroup(), and hdf5Reader::readTopDataSet().

h5FileName

std::string hdf5Reader::h5FileName

protectedinherited

Definition at line 372 of file hdf5Reader.H.

Referenced by hdf5Reader::closeFile(), hdf5Reader::getFileName(), and hdf5Reader::openFile().

lowOrder

bool proteusHdf5::lowOrder

private

Definition at line 240 of file proteusHdf5.H.

Referenced by getBlockInfo(), and proteusHdf5().

myMeshBase

meshBase* hdf5Reader::myMeshBase

protectedinherited

Definition at line 378 of file hdf5Reader.H.

Referenced by hdf5Reader::exportToMeshBase(), hdf5Reader::getMeshBase(), proteusHdf5(), and hdf5Reader::writeVTK().

mySuperBlock

proteusSuperBlock proteusHdf5::mySuperBlock

private

Definition at line 258 of file proteusHdf5.H.

Referenced by mergeBlocks(), and proteusHdf5().

numBlocks

int proteusHdf5::numBlocks

private

Definition at line 244 of file proteusHdf5.H.

Referenced by getBlocks(), getControlInformation(), and getNumBlocks().

numDimensions

int proteusHdf5::numDimensions

private

Definition at line 245 of file proteusHdf5.H.

Referenced by getBlockXYZ(), getBoundaryEdgePts(), getControlInformation(), getNumDimensions(), mergeBlocks(), and proteusHdf5().

numElements

int hdf5Reader::numElements

protectedinherited

Definition at line 385 of file hdf5Reader.H.

Referenced by hdf5Reader::exportToVTKMesh(), and hdf5Reader::setNumberOfElements().

numElementVectors

int proteusHdf5::numElementVectors

private

Definition at line 247 of file proteusHdf5.H.

Referenced by getBlockElementData(), getControlInformation(), getNumElementVectors(), mergeBlocks(), and proteusHdf5().

numVertexVectors

int proteusHdf5::numVertexVectors

private

Definition at line 246 of file proteusHdf5.H.

Referenced by getBlockVertexData(), getControlInformation(), getNumVertexVectors(), mergeBlocks(), and proteusHdf5().

numVertices

int hdf5Reader::numVertices

protectedinherited

Definition at line 384 of file hdf5Reader.H.

Referenced by hdf5Reader::exportToVTKMesh(), and hdf5Reader::setNumberOfVertices().

outputFname

std::string hdf5Reader::outputFname

protectedinherited

Definition at line 374 of file hdf5Reader.H.

Referenced by hdf5Reader::exportToMeshBase().

proteusBlocks

std::vector<proteusBlock> proteusHdf5::proteusBlocks

private

Definition at line 261 of file proteusHdf5.H.

Referenced by getBlocks(), and mergeBlocks().

verb

int hdf5Reader::verb

protectedinherited

Definition at line 375 of file hdf5Reader.H.

vertexVectorNames

std::vector<std::string> proteusHdf5::vertexVectorNames

private

Definition at line 253 of file proteusHdf5.H.

Referenced by getBlockVertexData(), and proteusHdf5().

vtkElementTypes

std::vector<int> hdf5Reader::vtkElementTypes

protectedinherited

Definition at line 388 of file hdf5Reader.H.

Referenced by hdf5Reader::exportToVTKMesh(), hdf5Reader::getElementConnectivity(), and hdf5Reader::setElementTypes().

vtkElementTypesList

std::vector<int> hdf5Reader::vtkElementTypesList

protectedinherited

Definition at line 389 of file hdf5Reader.H.

Referenced by hdf5Reader::getElementConnectivity(), and hdf5Reader::setElementTypesList().

vtkMesh

vtkSmartPointer<vtkDataSet> hdf5Reader::vtkMesh

protectedinherited

Definition at line 377 of file hdf5Reader.H.

Referenced by hdf5Reader::getVTKMesh().

xCrd

std::vector<double> hdf5Reader::xCrd

protectedinherited

Definition at line 381 of file hdf5Reader.H.

Referenced by hdf5Reader::exportToVTKMesh(), and hdf5Reader::setCoordinates().

yCrd

std::vector<double> hdf5Reader::yCrd

protectedinherited

Definition at line 381 of file hdf5Reader.H.

Referenced by hdf5Reader::exportToVTKMesh(), and hdf5Reader::setCoordinates().

zCrd

std::vector<double> hdf5Reader::zCrd

protectedinherited

Definition at line 381 of file hdf5Reader.H.

Referenced by hdf5Reader::exportToVTKMesh(), and hdf5Reader::setCoordinates().

---

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

• proteusHdf5.H
• proteusHdf5.C