olb::VTUsurfaceWriter< T > Class Template Reference

#include <vtuSurfaceWriter.h>

Collaboration diagram for olb::VTUsurfaceWriter< T >:

Public Member Functions
	VTUsurfaceWriter (std::string name, CuboidDecomposition3D< T > &cuboidDecomposition, LoadBalancer< T > &loadBalancer, bool binary=false)
void	createMasterFile ()
void	write (std::size_t iT)
	writes vtu files and assigns values
void	addPoint (Vector< T, 3 > &new_position)
	Add single location to output set.
void	addPoints (std::vector< Vector< T, 3 > > &new_positions)
	Add multiple locations to output set.
void	addConnectivity (std::vector< std::vector< int > > &connections)
	Define connectivity between previously-added output points, rendering them a surface.
void	addSTL (STLreader< T > &stlReader)
	Add full STL surface as output surface.
void	addFunctor (AnalyticalF3D< T, T > &f)
	Schedule analytical functor for output.
void	addFunctor (SuperF3D< T, T > &f)
	Schedule lattice functor for output (interpolates)

Protected Member Functions
void	preamblePVD (const std::string &fullNamePVD)
void	closePVD (const std::string &fullNamePVD)
void	preambleVTU (const std::string &fullName, int num)
	performes <VTKFile ...>, <ImageData ...> and <PieceExtent ...>
void	closeVTU (const std::string &fullNamePiece)
	performes </ImageData> and </VTKFile>
void	dataPVD (int iT, int i, const std::string &fullNamePVD, const std::string &namePiece)
	performes <DataSet timestep= ... file=namePiece >
void	dataPVDmaster (int iT, int i, const std::string &fullNamePVDMaster, const std::string &namePiece)
	performes <DataSet timestep= ... file=namePiece >
void	dataArray (const std::string &fullName)
void	writeFunctor (const std::string &fullName, std::ofstream &fout, SuperF3D< T, T > &f)
	interpolates and writes functors stored at functors
void	writeAnalyticalFunctor (const std::string &fullName, std::ofstream &fout, AnalyticalF3D< T, T > &f)
	writes functors.
void	writePosition (std::ofstream &fout)
	writes coordinates of points
std::vector< std::vector< T > >	removeDuplicates (const std::vector< std::vector< T > > &points)
	removes duplicates from points, needed for STL files
std::vector< std::vector< int > >	mapTrianglesToIndices (STLreader< T > &stlReader)

Static Protected Member Functions
static bool	areVectorsEqual (const std::vector< T > &v1, const std::vector< T > &v2, T epsilon=1e-6)

Protected Attributes
std::string	_name
std::vector< SuperF3D< T, T > * >	_functors
std::vector< AnalyticalF3D< T, T > * >	_functorsA
std::vector< Vector< T, 3 > >	pos
std::vector< std::vector< int > >	connectivity
CuboidDecomposition3D< T > &	_cuboidDecomposition
LoadBalancer< T > &	_loadBalancer
bool	_binary
OstreamManager	clout

Detailed Description

template<typename T>
class olb::VTUsurfaceWriter< T >

Definition at line 36 of file vtuSurfaceWriter.h.

Constructor & Destructor Documentation

VTUsurfaceWriter()

template<typename T >

olb::VTUsurfaceWriter< T >::VTUsurfaceWriter	(	std::string	name,
		CuboidDecomposition3D< T > &	cuboidDecomposition,
		LoadBalancer< T > &	loadBalancer,
		bool	binary = false )

Definition at line 36 of file vtuSurfaceWriter.hh.

    : _name(name)
    , _cuboidDecomposition(cuboidDecomposition)
    , _loadBalancer(loadBalancer)
    , _binary(binary)
    , clout(std::cout, "VTUsurfaceWriter3D")
{}

Member Function Documentation

addConnectivity()

template<typename T >

void olb::VTUsurfaceWriter< T >::addConnectivity

(

std::vector< std::vector< int > > &

connections

)

Define connectivity between previously-added output points, rendering them a surface.

Definition at line 72 of file vtuSurfaceWriter.hh.

{
  for (unsigned long i = 0; i < connections.size(); i++) {
    connectivity.push_back(connections[i]);
  }
}

addFunctor() [1/2]

template<typename T >

void olb::VTUsurfaceWriter< T >::addFunctor

(

AnalyticalF3D< T, T > &

f

)

Schedule analytical functor for output.

Definition at line 46 of file vtuSurfaceWriter.hh.

{
  _functorsA.push_back(&f);
}

addFunctor() [2/2]

template<typename T >

void olb::VTUsurfaceWriter< T >::addFunctor

(

SuperF3D< T, T > &

f

)

Schedule lattice functor for output (interpolates)

Definition at line 52 of file vtuSurfaceWriter.hh.

{
  _functors.push_back(&f);
}

addPoint()

template<typename T >

void olb::VTUsurfaceWriter< T >::addPoint

(

Vector< T, 3 > &

new_position

)

Add single location to output set.

Definition at line 66 of file vtuSurfaceWriter.hh.

{
  pos.push_back(new_position);
}

addPoints()

template<typename T >

void olb::VTUsurfaceWriter< T >::addPoints

(

std::vector< Vector< T, 3 > > &

new_positions

)

Add multiple locations to output set.

Definition at line 58 of file vtuSurfaceWriter.hh.

{
  for (unsigned long i = 0; i < new_positions.size(); i++) {
    pos.push_back(new_positions[i]);
  }
}

addSTL()

template<typename T >

void olb::VTUsurfaceWriter< T >::addSTL

(

STLreader< T > &

stlReader

)

Add full STL surface as output surface.

Definition at line 509 of file vtuSurfaceWriter.hh.

{
  STLmesh<T>                  mesh = stlReader.getMesh();
  std::vector<std::vector<T>> points;
 
  // Collect points from triangles
  for (const STLtriangle<T>& triangle : mesh.getTriangles()) {
    std::vector<T> pt = {triangle.point[0][0], triangle.point[0][1], triangle.point[0][2]};
    points.push_back(pt);
    pt = {triangle.point[1][0], triangle.point[1][1], triangle.point[1][2]};
    points.push_back(pt);
    pt = {triangle.point[2][0], triangle.point[2][1], triangle.point[2][2]};
    points.push_back(pt);
  }
  // Remove duplicate points
  points = removeDuplicates(points);
 
  // Add points to pos
  for (const std::vector<T>& point : points) {
    pos.push_back(Vector<T, 3>(point[0], point[1], point[2]));
  }
 
  std::vector<std::vector<int>> indexedTriangles = mapTrianglesToIndices(stlReader);
  for (const auto& tri : indexedTriangles) {
    connectivity.push_back(tri);
  }
}

References olb::STLreader< T >::getMesh(), and olb::STLmesh< T >::getTriangles().

Here is the call graph for this function:

areVectorsEqual()

template<typename T >

bool olb::VTUsurfaceWriter< T >::areVectorsEqual ( const std::vector< T > & v1, const std::vector< T > & v2, T epsilon = 1e-6 )

staticprotected

Definition at line 452 of file vtuSurfaceWriter.hh.

{
  for (std::size_t i = 0; i < v1.size(); ++i) {
    if (std::fabs(v1[i] - v2[i]) > epsilon) {
      return false;
    }
  }
  return true;
}

closePVD()

template<typename T >

void olb::VTUsurfaceWriter< T >::closePVD ( const std::string & fullNamePVD )

protected

Definition at line 199 of file vtuSurfaceWriter.hh.

{
  int rank = 0;
#ifdef PARALLEL_MODE_MPI
  rank = singleton::mpi().getRank();
#endif
  if (rank == 0) {
 
    std::ofstream fout(fullNamePVD.c_str(), std::ios::app);
    if (!fout) {
      clout << "Error: could not open " << fullNamePVD << std::endl;
    }
    fout << "</Collection>\n";
    fout << "</VTKFile>\n";
    fout.close();
  }
}

References olb::singleton::MpiManager::getRank(), and olb::singleton::mpi().

Here is the call graph for this function:

closeVTU()

template<typename T >

void olb::VTUsurfaceWriter< T >::closeVTU ( const std::string & fullNamePiece )

protected

performes </ImageData> and </VTKFile>

Definition at line 130 of file vtuSurfaceWriter.hh.

{
  std::ofstream fout(fullNamePiece.c_str(), std::ios::app);
  if (!fout) {
    clout << "Error: could not open " << fullNamePiece << std::endl;
  }
  fout << "</UnstructuredGrid>\n";
  fout << "</VTKFile>\n";
  fout.close();
}

createMasterFile()

template<typename T >

void olb::VTUsurfaceWriter< T >::createMasterFile

(

)

Definition at line 171 of file vtuSurfaceWriter.hh.

{
  int rank = 0;
#ifdef PARALLEL_MODE_MPI
  rank = singleton::mpi().getRank();
#endif
  if (rank == 0) {
    std::string fullNamePVDmaster = singleton::directories().getVtkOutDir() + createFileName(_name) + ".pvd";
    preamblePVD(fullNamePVDmaster);
    closePVD(fullNamePVDmaster);
  }
}

References olb::createFileName(), olb::singleton::directories(), olb::singleton::MpiManager::getRank(), olb::singleton::Directories::getVtkOutDir(), and olb::singleton::mpi().

Here is the call graph for this function:

dataArray()

template<typename T >

void olb::VTUsurfaceWriter< T >::dataArray ( const std::string & fullName )

protected

Definition at line 218 of file vtuSurfaceWriter.hh.

{
 
  std::ofstream fout(fullName.c_str(), std::ios::app);
  if (!fout) {
    clout << "Error: could not open " << fullName << std::endl;
  }
 
  for (unsigned long i = 0; i < _functors.size(); i++) {
    writeFunctor(fullName, fout, *_functors[i]);
  }
 
  for (unsigned long i = 0; i < _functorsA.size(); i++) {
    writeAnalyticalFunctor(fullName, fout, *_functorsA[i]);
  }
  // master writes points and connectivity
  int rank = 0;
#ifdef PARALLEL_MODE_MPI
  rank = singleton::mpi().getRank();
#endif
  if (rank == 0) {
    fout << "</PointData>" << std::endl;
    fout << "<CellData /> " << std::endl;
    fout << "<Cells>" << std::endl;
    fout << "<DataArray type=\"Int32\" Name=\"connectivity\" format=\"ascii\">" << std::endl;
    // if there are no connections between the points, connectivity simply counts up
    if (connectivity.size() == 0) {
      for (int i = 0; i < 1; ++i) {
        for (unsigned long j = 0; j < pos.size(); ++j) {
          fout << j << " ";
        }
      }
    }
    // if there are connections, connectivity is written out
    else {
      for (int i = 0; i < 1; ++i) {
        for (unsigned long j = 0; j < connectivity.size(); ++j) {
          for (unsigned long k = 0; k < connectivity[j].size(); ++k) {
            fout << connectivity[j][k] << " ";
          }
          if (j % 2 == 0) {
            fout << std::endl;
          }
        }
      }
    }
 
    fout << "</DataArray>" << std::endl;
    fout << "<DataArray type=\"Int32\" Name=\"offsets\" format=\"ascii\">" << std::endl;
    // if there are no connections, offsets just count up
    if (connectivity.size() == 0) {
      for (std::size_t i = 0; i < 1; ++i) {
        for (unsigned long j = 1; j <= connectivity.size(); ++j) {
          fout << j << " ";
          if (j % 6 == 0) {
            fout << std::endl;
          }
        }
      }
      // if connections are present, offset is multiplied by 3
    }
    else { //connectivity.size() != 0
      for (std::size_t i = 0; i < 1; ++i) {
        for (unsigned long j = 1; j <= connectivity.size(); ++j) {
          fout << j * 3 << " ";
          if (j % 6 == 0) {
            fout << std::endl;
          }
        }
      }
    }
    // Connected points have the type 5, unconnected points have the type 3
    fout << "</DataArray>" << std::endl;
    fout << "<DataArray type=\"UInt8\" Name=\"types\" format=\"ascii\">" << std::endl;
    if (connectivity.size() != 0) {
      for (unsigned long j = 0; j < connectivity.size(); ++j) {
        fout << 5 << " ";
        if (j % 6 == 0) {
          fout << std::endl;
        }
      }
    }
    else {
      for (unsigned long j = 0; j < pos.size(); ++j) {
        fout << 3 << " ";
        if (j % 6 == 0) {
          fout << std::endl;
        }
      }
    }
    // write out all coordinates of points
    fout << "</DataArray>" << std::endl;
    fout << "</Cells>" << std::endl;
    fout << "<Points>" << std::endl;
    writePosition(fout);
    fout << "</Points>" << std::endl;
    fout << "</Piece>" << std::endl;
 
    fout.close();
  }
}

References olb::singleton::MpiManager::getRank(), and olb::singleton::mpi().

Here is the call graph for this function:

dataPVD()

template<typename T >

void olb::VTUsurfaceWriter< T >::dataPVD ( int iT, int i, const std::string & fullNamePVD, const std::string & namePiece )

protected

performes <DataSet timestep= ... file=namePiece >

Definition at line 142 of file vtuSurfaceWriter.hh.

{
  std::ofstream fout(fullNamePVD.c_str(), std::ios::app);
  if (!fout) {
    clout << "Error: could not open " << fullNamePVD << std::endl;
  }
  fout << "<DataSet timestep=\"" << iT << "\" " << "group=\"\" part=\" " << i << "\" " << "file=\"" << namePiece
       << "\"/>\n";
  fout.close();
}

dataPVDmaster()

template<typename T >

void olb::VTUsurfaceWriter< T >::dataPVDmaster ( int iT, int i, const std::string & fullNamePVDMaster, const std::string & namePiece )

protected

performes <DataSet timestep= ... file=namePiece >

Definition at line 154 of file vtuSurfaceWriter.hh.

{
  std::ofstream fout(fullNamePVDMaster.c_str(), std::ios::in | std::ios::out | std::ios::ate);
  if (fout) {
    fout.seekp(-25, std::ios::end); // jump -25 from the end of file to overwrite closePVD
    fout << "<DataSet timestep=\"" << iT << "\" " << "group=\"\" part=\" " << i << "\" " << "file=\"" << namePiece
         << "\"/>\n";
    fout.close();
    closePVD(fullNamePVDMaster);
  }
  else {
    clout << "Error: could not open " << fullNamePVDMaster << std::endl;
  }
}

mapTrianglesToIndices()

template<typename T >

std::vector< std::vector< int > > olb::VTUsurfaceWriter< T >::mapTrianglesToIndices ( STLreader< T > & stlReader )

protected

Definition at line 463 of file vtuSurfaceWriter.hh.

{
  STLmesh<T> mesh = stlReader.getMesh();
 
  struct VectorHash {
    std::size_t operator()(const std::vector<T>& v) const
    {
      return std::hash<T>()(v[0]) ^ std::hash<T>()(v[1]) ^ std::hash<T>()(v[2]);
    }
  };
 
  struct VectorEqual {
    bool operator()(const std::vector<T>& a, const std::vector<T>& b) const { return areVectorsEqual(a, b); }
  };
 
  std::unordered_map<std::vector<T>, int, VectorHash, VectorEqual> pointIndexMap;
  std::vector<std::vector<int>>                                    indexedTriangles;
 
  // Create a map from points to their indices
  for (std::size_t i = 0; i < pos.size(); ++i) {
    pointIndexMap[{pos[i][0], pos[i][1], pos[i][2]}] = i;
  }
 
  // Map each triangle's points to their indices
  for (const STLtriangle<T>& triangle : mesh.getTriangles()) {
    std::vector<int> indices(3);
    for (int j = 0; j < 3; ++j) {
      std::vector<T> pt = {triangle.point[j][0], triangle.point[j][1], triangle.point[j][2]};
      auto           it = pointIndexMap.find(pt);
      if (it != pointIndexMap.end()) {
        indices[j] = it->second;
      }
      else {
        // Handle the case where the point is not found (should not happen if removeDuplicates worked correctly)
        indices[j] = -1; // Invalid index
      }
    }
    if (indices[0] != -1 && indices[1] != -1 && indices[2] != -1) {
      indexedTriangles.push_back(indices);
    }
  }
 
  return indexedTriangles;
}

References olb::STLreader< T >::getMesh(), and olb::STLmesh< T >::getTriangles().

Here is the call graph for this function:

preamblePVD()

template<typename T >

void olb::VTUsurfaceWriter< T >::preamblePVD ( const std::string & fullNamePVD )

protected

Definition at line 185 of file vtuSurfaceWriter.hh.

{
  std::ofstream fout(fullNamePVD.c_str(), std::ios::trunc);
  if (!fout) {
    clout << "Error: could not open " << fullNamePVD << std::endl;
  }
  fout << "<?xml version=\"1.0\"?>\n";
  fout << "<VTKFile type=\"Collection\" version=\"1.0\" "
       << "byte_order=\"LittleEndian\">\n"
       << "<Collection>\n";
  fout.close();
}

preambleVTU()

template<typename T >

void olb::VTUsurfaceWriter< T >::preambleVTU ( const std::string & fullName, int num )

protected

performes <VTKFile ...>, <ImageData ...> and <PieceExtent ...>

Definition at line 115 of file vtuSurfaceWriter.hh.

{
  std::ofstream fout(fullName.c_str(), std::ios::trunc);
  if (!fout) {
    clout << "Error: could not open " << fullName << std::endl;
  }
  fout << "<?xml version=\"1.0\"?>" << std::endl << std::flush;
  fout << "<VTKFile type=\"UnstructuredGrid\" version=\"1.0\" byte_order=\"LittleEndian\">" << std::endl;
  fout << "<UnstructuredGrid>" << std::endl;
  fout << "<Piece NumberOfPoints=\"" << num << "\" NumberOfCells=\"" << connectivity.size() << "\">" << std::endl;
  fout << "<PointData Vectors=\"Particles\">" << std::endl;
  fout.close();
}

removeDuplicates()

template<typename T >

std::vector< std::vector< T > > olb::VTUsurfaceWriter< T >::removeDuplicates ( const std::vector< std::vector< T > > & points )

protected

removes duplicates from points, needed for STL files

Definition at line 432 of file vtuSurfaceWriter.hh.

{
  struct VectorHash {
    std::size_t operator()(const std::vector<T>& v) const
    {
      return std::hash<T>()(v[0]) ^ std::hash<T>()(v[1]) ^ std::hash<T>()(v[2]);
    }
  };
 
  struct VectorEqual {
    bool operator()(const std::vector<T>& a, const std::vector<T>& b) const
    {
      return a[0] == b[0] && a[1] == b[1] && a[2] == b[2];
    }
  };
  std::unordered_set<std::vector<T>, VectorHash, VectorEqual> uniquePoints(points.begin(), points.end());
  return std::vector<std::vector<T>>(uniquePoints.begin(), uniquePoints.end());
}

write()

template<typename T >

void olb::VTUsurfaceWriter< T >::write

(

std::size_t

iT

)

writes vtu files and assigns values

Definition at line 81 of file vtuSurfaceWriter.hh.

{
  int rank = 0;
#ifdef PARALLEL_MODE_MPI
  rank = singleton::mpi().getRank();
#endif
 
  for (SuperF3D<T, T>* f : _functors) {
    f->getSuperStructure().communicate();
  }
  std::string fullNamePVDmaster = singleton::directories().getVtkOutDir() + createFileName(_name) + ".pvd";
  std::string namePiece         = "data/" + createFileName(_name, iT, 0) + ".vtu";
 
  if (rank == 0) {
    // puts name of .vti piece to a .pvd file [fullNamePVD]
    // adds a namePiece to master.pvd file.
    // To do so we overwrite closePVD() and add new entry.
    dataPVDmaster(iT, 1, fullNamePVDmaster, namePiece);
  }
 
  //VTU data files
 
  std::string fullNameVTU = singleton::directories().getVtkOutDir() + "data/" + createFileName(_name, iT, 0) + ".vtu";
  if (rank == 0) {
    preambleVTU(fullNameVTU, pos.size());
  }
  //writes data arrays into vtu file. All ranks are needed for this
  this->dataArray(fullNameVTU);
  if (rank == 0) {
    closeVTU(fullNameVTU);
  }
}

References olb::createFileName(), olb::singleton::directories(), olb::singleton::MpiManager::getRank(), olb::singleton::Directories::getVtkOutDir(), and olb::singleton::mpi().

Here is the call graph for this function:

writeAnalyticalFunctor()

template<typename T >

void olb::VTUsurfaceWriter< T >::writeAnalyticalFunctor ( const std::string & fullName, std::ofstream & fout, AnalyticalF3D< T, T > & f )

protected

writes functors.

Definition at line 340 of file vtuSurfaceWriter.hh.

{
  std::size_t dimF = f.getTargetDim();
 
  //Header DataArray, ascii or Base64 binary
  int rank = 0;
#ifdef PARALLEL_MODE_MPI
  rank = singleton::mpi().getRank();
#endif
 
  if (rank == 0) {
    if (!_binary) {
      fout << "<DataArray type=\"Float32\" Name=\"" << f.getName() << "\" NumberOfComponents=\"" << dimF << "\">"
           << std::endl;
    }
    else if (_binary) {
      fout << "<DataArray type=\"Float32\" Name=\"" << f.getName()
           << "\" format=\"binary\" encoding=\"base64\" NumberOfComponents=\"" << dimF << "\">" << std::endl;
    }
  }
 
  if (_binary) {
    fout.close();
  }
  std::size_t                 numPoints = pos.size();
  std::ofstream               ofstr(fullName.c_str(), std::ios::out | std::ios::app | std::ios::binary);
  size_t                      binarySize = size_t(numPoints * dimF * sizeof(float));
  Base64Encoder<unsigned int> sizeEncoder(ofstr, 1);
  unsigned int                uintBinarySize = (unsigned int)binarySize;
  if (_binary) {
    sizeEncoder.encode(&uintBinarySize, 1);
  }
  Base64Encoder<float> dataEncoder(ofstr, numPoints);
 
  std::vector<T> vals(dimF * numPoints, 0);
 
  T* val = new T[dimF];
 
  for (std::size_t j = 0; j < numPoints; ++j) {
    if (_loadBalancer.isLocal(_cuboidDecomposition.getC(pos[j]).value())) {
      f(val, pos[j].data());
 
      for (std::size_t i = 0; i < dimF; ++i) {
        vals[i * numPoints + j] = val[i];
      }
    }
  }
#ifdef PARALLEL_MODE_MPI
  // reduce the values to the master, then master writes them to the file
  std::vector<T> valsCummulated(dimF * numPoints, 0);
  singleton::mpi().reduceVect(vals, valsCummulated, MPI_SUM);
 
  if (rank == 0) {
    for (std::size_t j = 0; j < numPoints; ++j) {
      for (std::size_t i = 0; i < dimF; ++i) {
        if (!_binary) {
          fout << valsCummulated[i * numPoints + j] << " ";
        }
        else {
          const float helper = float(valsCummulated[j]);
          dataEncoder.encode(&helper, 1);
        }
      }
    }
  }
#endif
#ifndef PARALLEL_MODE_MPI
  // write the values to the file
  for (std::size_t j = 0; j < numPoints; ++j) {
    for (std::size_t i = 0; i < dimF; ++i) {
      if (!_binary) {
        fout << vals[i * numPoints + j] << " ";
      }
      else {
        const float helper = float(vals[i * numPoints + j]);
        dataEncoder.encode(&helper, 1);
      }
    }
  }
#endif
 
  if (_binary) {
    ofstr.close();
    fout.open(fullName.c_str(), std::ios::out | std::ios::app);
  }
  if (rank == 0) {
    fout << "</DataArray>" << std::endl;
  }
}

References olb::Base64Encoder< T >::encode(), olb::GenericF< T, S >::getName(), olb::singleton::MpiManager::getRank(), olb::GenericF< T, S >::getTargetDim(), olb::singleton::mpi(), and olb::singleton::MpiManager::reduceVect().

Here is the call graph for this function:

writeFunctor()

template<typename T >

void olb::VTUsurfaceWriter< T >::writeFunctor ( const std::string & fullName, std::ofstream & fout, SuperF3D< T, T > & f )

protected

interpolates and writes functors stored at functors

Definition at line 333 of file vtuSurfaceWriter.hh.

{
  AnalyticalFfromSuperF3D<T> interpolateF(f, false);
  writeAnalyticalFunctor(fullName, fout, interpolateF);
}

writePosition()

template<typename T >

void olb::VTUsurfaceWriter< T >::writePosition ( std::ofstream & fout )

protected

writes coordinates of points

Definition at line 321 of file vtuSurfaceWriter.hh.

{
  fout << "<DataArray type=\"Float32\" Name=\"Point\" NumberOfComponents=\"" << 3 << "\">" << std::endl;
 
  int num = pos.size();
  for (int j = 0; j < num; ++j) {
    fout << pos[j][0] << " " << pos[j][1] << " " << pos[j][2] << " " << std::endl;
  }
  fout << "</DataArray>" << std::endl;
}

Member Data Documentation

_binary

template<typename T >

bool olb::VTUsurfaceWriter< T >::_binary

protected

Definition at line 45 of file vtuSurfaceWriter.h.

_cuboidDecomposition

template<typename T >

CuboidDecomposition3D<T>& olb::VTUsurfaceWriter< T >::_cuboidDecomposition

protected

Definition at line 43 of file vtuSurfaceWriter.h.

_functors

template<typename T >

std::vector<SuperF3D<T, T>*> olb::VTUsurfaceWriter< T >::_functors

protected

Definition at line 39 of file vtuSurfaceWriter.h.

_functorsA

template<typename T >

std::vector<AnalyticalF3D<T, T>*> olb::VTUsurfaceWriter< T >::_functorsA

protected

Definition at line 40 of file vtuSurfaceWriter.h.

_loadBalancer

template<typename T >

LoadBalancer<T>& olb::VTUsurfaceWriter< T >::_loadBalancer

protected

Definition at line 44 of file vtuSurfaceWriter.h.

_name

template<typename T >

std::string olb::VTUsurfaceWriter< T >::_name

protected

Definition at line 38 of file vtuSurfaceWriter.h.

clout

template<typename T >

OstreamManager olb::VTUsurfaceWriter< T >::clout

protected

Definition at line 47 of file vtuSurfaceWriter.h.

connectivity

template<typename T >

std::vector<std::vector<int> > olb::VTUsurfaceWriter< T >::connectivity

protected

Definition at line 42 of file vtuSurfaceWriter.h.

pos

template<typename T >

std::vector<Vector<T, 3> > olb::VTUsurfaceWriter< T >::pos

protected

Definition at line 41 of file vtuSurfaceWriter.h.

---

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

• src/io/vtuSurfaceWriter.h
• src/io/vtuSurfaceWriter.hh