olb::VTUpointWriter< T, W, 2 > Class Template Reference

#include <vtuPointWriter.h>

Collaboration diagram for olb::VTUpointWriter< T, W, 2 >:

Public Member Functions
	VTUpointWriter (std::string const name, bool binary=false)
void	createMasterFile ()
void	write (std::size_t iT, std::vector< Vector< T, 2 > > &new_positions)
	write function to call during runtime, also accepts additional points during call
void	write (std::size_t iT)
void	addFunctor (AnalyticalF2D< T, W > &f, const std::string &name)
	accepts functors to write out
void	addFunctor (AnalyticalF2D< T, W > &f)
void	addFunctor (SuperF2D< T, W > &f, const std::string &name)
void	addFunctor (SuperF2D< T, W > &f)
void	addPoint (Vector< T, 2 > &new_position)
	functions to add multiple or single points.
void	addPoints (std::vector< olb::Vector< T, 2 > > &new_positions)

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, SuperF2D< T, W > &f)
	interpolates and writes functors stored at functors
void	writeAnalyticalFunctor (const std::string &fullName, std::ofstream &fout, AnalyticalF2D< T, W > &f)
void	writePosition (std::ofstream &fout)
	writes coordinates of points to plot

Protected Attributes
std::string	_name
std::vector< SuperF2D< T, W > * >	functors
std::vector< AnalyticalF2D< T, W > * >	functorsA
std::vector< Vector< T, 2 > >	pos
bool	_binary
OstreamManager	clout

Detailed Description

template<typename T, typename W>
class olb::VTUpointWriter< T, W, 2 >

Definition at line 39 of file vtuPointWriter.h.

Constructor & Destructor Documentation

VTUpointWriter()

template<typename T , typename W >

olb::VTUpointWriter< T, W, 2 >::VTUpointWriter	(	std::string const	name,
		bool	binary = false )

Definition at line 35 of file vtuPointWriter.hh.

  : _name( name ), _binary( binary ),
    clout(std::cout, "VTUpointWriter2D")
{}

Member Function Documentation

addFunctor() [1/4]

template<typename T , typename W >

void olb::VTUpointWriter< T, W, 2 >::addFunctor

(

AnalyticalF2D< T, W > &

f

)

Definition at line 47 of file vtuPointWriter.hh.

                                                             {
  functorsA.push_back(&f);
}

addFunctor() [2/4]

template<typename T , typename W >

void olb::VTUpointWriter< T, W, 2 >::addFunctor	(	AnalyticalF2D< T, W > &	f,
		const std::string &	name )

accepts functors to write out

Definition at line 41 of file vtuPointWriter.hh.

                                                                                    {
  f.getName() = name;
  functorsA.push_back(&f);
}

References olb::GenericF< T, S >::getName().

Here is the call graph for this function:

addFunctor() [3/4]

template<typename T , typename W >

void olb::VTUpointWriter< T, W, 2 >::addFunctor

(

SuperF2D< T, W > &

f

)

Definition at line 58 of file vtuPointWriter.hh.

                                                        {
  functors.push_back(&f);
}

addFunctor() [4/4]

template<typename T , typename W >

void olb::VTUpointWriter< T, W, 2 >::addFunctor	(	SuperF2D< T, W > &	f,
		const std::string &	name )

Definition at line 52 of file vtuPointWriter.hh.

                                                                               {
  f.getName() = name;
  functors.push_back(&f);
}

References olb::GenericF< T, S >::getName().

Here is the call graph for this function:

addPoint()

template<typename T , typename W >

void olb::VTUpointWriter< T, W, 2 >::addPoint

(

Vector< T, 2 > &

new_position

)

functions to add multiple or single points.

Definition at line 70 of file vtuPointWriter.hh.

                                                               {
  pos.push_back(new_position);
}

addPoints()

template<typename T , typename W >

void olb::VTUpointWriter< T, W, 2 >::addPoints

(

std::vector< olb::Vector< T, 2 > > &

new_positions

)

Definition at line 63 of file vtuPointWriter.hh.

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

closePVD()

template<typename T , typename W >

void olb::VTUpointWriter< T, W, 2 >::closePVD ( const std::string & fullNamePVD )

protected

Definition at line 149 of file vtuPointWriter.hh.

{
  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();
}

closeVTU()

template<typename T , typename W >

void olb::VTUpointWriter< T, W, 2 >::closeVTU ( const std::string & fullNamePiece )

protected

performes </ImageData> and </VTKFile>

Definition at line 183 of file vtuPointWriter.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 , typename W >

void olb::VTUpointWriter< T, W, 2 >::createMasterFile

(

)

Definition at line 124 of file vtuPointWriter.hh.

{
  std::string fullNamePVDmaster = singleton::directories().getVtkOutDir()
                                  + createFileName(_name) + "_master.pvd";
  preamblePVD(fullNamePVDmaster);
  closePVD(fullNamePVDmaster);
 
}

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

Here is the call graph for this function:

dataArray()

template<typename T , typename W >

void olb::VTUpointWriter< T, W, 2 >::dataArray ( const std::string & fullName )

protected

Definition at line 228 of file vtuPointWriter.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]);
  }
 
  fout << "</PointData>" << std::endl;
  fout << "<CellData /> " << std::endl;
  fout << "<Cells>" << std::endl;
  fout << "<DataArray type=\"Int32\" Name=\"connectivity\" format=\"ascii\">"
       << std::endl;
  for ( int i=0; i < 1; ++i){
    for ( unsigned long j=0; j<pos.size(); ++j){
      fout << j << " ";
    }
  }
  fout << "</DataArray>" << std::endl;
  fout << "<DataArray type=\"Int32\" Name=\"offsets\" format=\"ascii\">"
       << std::endl;
  for ( int i=0; i < 1; ++i){
    for ( unsigned long j=1; j <= pos.size(); ++j){
      fout << j << " ";
    }
  }
  fout << "</DataArray>" << std::endl;
  fout << "<DataArray type=\"UInt8\" Name=\"types\" format=\"ascii\">"
       << std::endl;
    for ( unsigned long j=0; j < pos.size(); ++j){
      fout << 1 << " ";
    }
  fout << "</DataArray>" << std::endl;
  fout << "</Cells>" << std::endl;
  fout << "<Points>" << std::endl;
  writePosition( fout );
  fout << "</Points>" << std::endl;
  fout << "</Piece>" << std::endl;
 
  fout.close();
}

dataPVD()

template<typename T , typename W >

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

protected

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

Definition at line 197 of file vtuPointWriter.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 , typename W >

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

protected

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

Definition at line 210 of file vtuPointWriter.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 form 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;
  }
}

preamblePVD()

template<typename T , typename W >

void olb::VTUpointWriter< T, W, 2 >::preamblePVD ( const std::string & fullNamePVD )

protected

Definition at line 134 of file vtuPointWriter.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=\"0.1\" "
       << "byte_order=\"LittleEndian\">\n" << "<Collection>\n";
  fout.close();
}

preambleVTU()

template<typename T , typename W >

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

protected

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

Definition at line 163 of file vtuPointWriter.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=\"0.1\" byte_order=\"LittleEndian\">"
      << std::endl;
  fout << "<UnstructuredGrid>" << std::endl;
  fout << "<Piece NumberOfPoints=\"" << num
       << "\" NumberOfCells=\"" << num << "\">"
       << std::endl;
  fout << "<PointData Vectors=\"Particles\">" << std::endl;
  fout.close();
}

write() [1/2]

template<typename T , typename W >

void olb::VTUpointWriter< T, W, 2 >::write

(

std::size_t

iT

)

write() [2/2]

template<typename T , typename W >

void olb::VTUpointWriter< T, W, 2 >::write	(	std::size_t	iT,
		std::vector< Vector< T, 2 > > &	new_positions )

write function to call during runtime, also accepts additional points during call

writeAnalyticalFunctor()

template<typename T , typename W >

void olb::VTUpointWriter< T, W, 2 >::writeAnalyticalFunctor ( const std::string & fullName, std::ofstream & fout, AnalyticalF2D< T, W > & f )

protected

Definition at line 301 of file vtuPointWriter.hh.

                                                                                                                        {
  int dimF = f.getTargetDim();
  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();
  }
  size_t num = pos.size();
 
  std::ofstream ofstr(fullName.c_str(),
                      std::ios::out | std::ios::app | std::ios::binary);
  size_t binarySize = size_t( num*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, num);
  T* val = new T[dimF]();
  for ( size_t j=0; j < num; ++j){
      T point[2]= {pos[j][0],pos[j][1]};
      for (int i = 0; i < dimF; i++){
        f(val,point);
        const float helper=float(val[i]);
        if(!_binary){
          fout << helper << " ";
        }
        else{
          dataEncoder.encode(&helper, 1);
        }
      }
  }
  delete[] val;
 
  ofstr.close();
  if(_binary){
    fout.open(fullName.c_str(), std::ios::out | std::ios::app);
  }
  fout << "</DataArray>" << std::endl;
 
}

References olb::Base64Encoder< T >::encode(), olb::GenericF< T, S >::getName(), and olb::GenericF< T, S >::getTargetDim().

Here is the call graph for this function:

writeFunctor()

template<typename T , typename W >

void olb::VTUpointWriter< T, W, 2 >::writeFunctor ( const std::string & fullName, std::ofstream & fout, SuperF2D< T, W > & f )

protected

interpolates and writes functors stored at functors

Definition at line 293 of file vtuPointWriter.hh.

                                                                                                         {
 
  AnalyticalFfromSuperF2D<T> interpolateF( f, true );
  writeAnalyticalFunctor( fullName, fout , interpolateF );
 
}

writePosition()

template<typename T , typename W >

void olb::VTUpointWriter< T, W, 2 >::writePosition ( std::ofstream & fout )

protected

writes coordinates of points to plot

Definition at line 280 of file vtuPointWriter.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] << " 0.0 ";
    }
  fout << "</DataArray>" << std::endl;
}

Member Data Documentation

_binary

template<typename T , typename W >

bool olb::VTUpointWriter< T, W, 2 >::_binary

protected

Definition at line 45 of file vtuPointWriter.h.

_name

template<typename T , typename W >

std::string olb::VTUpointWriter< T, W, 2 >::_name

protected

Definition at line 41 of file vtuPointWriter.h.

clout

template<typename T , typename W >

OstreamManager olb::VTUpointWriter< T, W, 2 >::clout

mutableprotected

Definition at line 46 of file vtuPointWriter.h.

functors

template<typename T , typename W >

std::vector<SuperF2D<T,W>*> olb::VTUpointWriter< T, W, 2 >::functors

protected

Definition at line 42 of file vtuPointWriter.h.

functorsA

template<typename T , typename W >

std::vector<AnalyticalF2D<T,W>*> olb::VTUpointWriter< T, W, 2 >::functorsA

protected

Definition at line 43 of file vtuPointWriter.h.

pos

template<typename T , typename W >

std::vector<Vector<T,2> > olb::VTUpointWriter< T, W, 2 >::pos

protected

Definition at line 44 of file vtuPointWriter.h.

---

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

• src/io/vtuPointWriter.h
• src/io/vtuPointWriter.hh