olb::SuperVTMwriter3D< T, OUT_T, W > Class Template Reference

SuperVTMwriter3D writes any SuperF3D to vtk-based output files. More...

#include <superVtmWriter3D.h>

Collaboration diagram for olb::SuperVTMwriter3D< T, OUT_T, W >:

Public Member Functions
	SuperVTMwriter3D (const std::string &name, int overlap=1, bool binary=true, bool compress=true)
	Construct writer for functor output.
	SuperVTMwriter3D (CuboidGeometry3D< T > &cGeometry, const std::string &name, int overlap=1, bool binary=true, bool compress=true)
	Construct writer for CuboidGeometry3D debugging.
void	write (int iT=0)
	writes functors stored in pointerVec every process writes a vti file with data for each of its cuboids the vti files are linked in a pvd file
void	writePVD (int iT)
	writes only the linking pvd file for timestep iT, blocks must be written separately (e.g. asynchronously)
void	writeGlobalVTI (int iT, int iC)
	writes the vti file for cuboid iC at timestep iT
void	writeVTI (int iT, int iCloc)
	writes the vti file for cuboid iCloc at timestep iT
void	write (SuperF3D< T, W > &f, int iT=0)
	writes functor instantaneously, same vti-pvd file structure as above
void	write (std::shared_ptr< SuperF3D< T, W > > ptr_f, int iT=0)
void	createMasterFile ()
	have to be called before calling write(int iT=0), since it creates
void	addFunctor (SuperF3D< T, W > &f)
	put functor to _pointerVec to simplify writing process of several functors
void	addFunctor (SuperF3D< T, W > &f, const std::string &functorName)
	put functor with specific name to _pointerVec to simplify writing process of several functors
void	clearAddedFunctors ()
	to clear stored functors, not yet used due to lack of necessity
std::string	getName () const
	getter for _name

Detailed Description

template<typename T, typename OUT_T = float, typename W = T>
class olb::SuperVTMwriter3D< T, OUT_T, W >

SuperVTMwriter3D writes any SuperF3D to vtk-based output files.

In .pvd files, there are only links/references to a VTKmultiblock file 'vtm'

.pvd file structure the time series is represented by different 'vtm' files.

.vtm file This file links cuboids ('vti') and represents the entire data of a single timestep.

Definition at line 51 of file superVtmWriter3D.h.

Constructor & Destructor Documentation

SuperVTMwriter3D() [1/2]

template<typename T , typename OUT_T , typename W >

olb::SuperVTMwriter3D< T, OUT_T, W >::SuperVTMwriter3D	(	const std::string &	name,
		int	overlap = 1,
		bool	binary = true,
		bool	compress = true )

Construct writer for functor output.

Definition at line 54 of file superVtmWriter3D.hh.

  : clout( std::cout,"SuperVTMwriter3D" ), _createFile(false), _name(name), _overlap(overlap), _binary(binary), _compress(compress)
{
  static_assert(std::is_same_v<OUT_T, float> || std::is_same_v<OUT_T, double>,
              "OUT_T must be either float or double");
}

SuperVTMwriter3D() [2/2]

template<typename T , typename OUT_T , typename W >

olb::SuperVTMwriter3D< T, OUT_T, W >::SuperVTMwriter3D	(	CuboidGeometry3D< T > &	cGeometry,
		const std::string &	name,
		int	overlap = 1,
		bool	binary = true,
		bool	compress = true )

Construct writer for CuboidGeometry3D debugging.

Definition at line 62 of file superVtmWriter3D.hh.

  : SuperVTMwriter3D(name, overlap, binary, compress)
{
  _cGeometry = &cGeometry;
}

Member Function Documentation

addFunctor() [1/2]

template<typename T , typename OUT_T , typename W >

void olb::SuperVTMwriter3D< T, OUT_T, W >::addFunctor

(

SuperF3D< T, W > &

f

)

put functor to _pointerVec to simplify writing process of several functors

Definition at line 257 of file superVtmWriter3D.hh.

{
  _pointerVec.push_back(&f);
}

addFunctor() [2/2]

template<typename T , typename OUT_T , typename W >

void olb::SuperVTMwriter3D< T, OUT_T, W >::addFunctor	(	SuperF3D< T, W > &	f,
		const std::string &	functorName )

put functor with specific name to _pointerVec to simplify writing process of several functors

Definition at line 263 of file superVtmWriter3D.hh.

{
  f.getName() = functorName;
  _pointerVec.push_back(&f);
}

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

Here is the call graph for this function:

clearAddedFunctors()

template<typename T , typename OUT_T , typename W >

void olb::SuperVTMwriter3D< T, OUT_T, W >::clearAddedFunctors

(

)

to clear stored functors, not yet used due to lack of necessity

Definition at line 270 of file superVtmWriter3D.hh.

{
  _pointerVec.clear();
}

createMasterFile()

template<typename T , typename OUT_T , typename W >

void olb::SuperVTMwriter3D< T, OUT_T, W >::createMasterFile

(

)

have to be called before calling write(int iT=0), since it creates

Definition at line 241 of file superVtmWriter3D.hh.

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

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:

getName()

template<typename T , typename OUT_T , typename W >

std::string olb::SuperVTMwriter3D< T, OUT_T, W >::getName

(

)

const

getter for _name

Definition at line 276 of file superVtmWriter3D.hh.

{
  return _name;
}

write() [1/3]

template<typename T , typename OUT_T , typename W >

void olb::SuperVTMwriter3D< T, OUT_T, W >::write

(

int

iT = 0

)

writes functors stored in pointerVec every process writes a vti file with data for each of its cuboids the vti files are linked in a pvd file

Definition at line 70 of file superVtmWriter3D.hh.

{
  // update to prevent gaps between vti files / cuboids
  for (SuperF3D<T,W>* f : _pointerVec) {
    f->getSuperStructure().communicate();
  }
 
  // to get first element _pointerVec
  // problem if functors with different SuperStructure are stored
  // since till now, there is only one origin
  const auto it_begin = _pointerVec.cbegin();
  if (!_cGeometry && it_begin == _pointerVec.end()) {
    throw std::runtime_error("No functor to write");
  }
  CuboidGeometry3D<T> const& cGeometry = _cGeometry ? *_cGeometry : (**it_begin).getSuperStructure().getCuboidGeometry();
 
  // PVD, owns all
  writePVD(iT);
  if (_cGeometry) {
    // Write globally if cuboid geometry is provided
    for (int iC = 0; iC < cGeometry.getNc(); ++iC) {
      writeGlobalVTI(iT, iC);
    }
  } else {
    LoadBalancer<T>& load = (**it_begin).getSuperStructure().getLoadBalancer();
    // VTI, each process writes its cuboids
    for (int iCloc = 0; iCloc < load.size(); iCloc++) {
      writeVTI(iT, iCloc);
    }
  }
}

References olb::CuboidGeometry3D< T >::getNc(), and olb::LoadBalancer< T >::size().

Here is the call graph for this function:

write() [2/3]

template<typename T , typename OUT_T , typename W >

void olb::SuperVTMwriter3D< T, OUT_T, W >::write	(	std::shared_ptr< SuperF3D< T, W > >	ptr_f,
		int	iT = 0 )

Definition at line 235 of file superVtmWriter3D.hh.

{
  write(*ptr_f, iT);
}

write() [3/3]

template<typename T , typename OUT_T , typename W >

void olb::SuperVTMwriter3D< T, OUT_T, W >::write	(	SuperF3D< T, W > &	f,
		int	iT = 0 )

writes functor instantaneously, same vti-pvd file structure as above

Definition at line 183 of file superVtmWriter3D.hh.

{
  CuboidGeometry3D<T> const& cGeometry = f.getSuperStructure().getCuboidGeometry();
  LoadBalancer<T>& load = f.getSuperStructure().getLoadBalancer();
  // no gaps between vti files (cuboids)
  f.getSuperStructure().communicate();
  const T delta = cGeometry.getMotherCuboid().getDeltaR();
 
  int rank = 0;
#ifdef PARALLEL_MODE_MPI
  rank = singleton::mpi().getRank();
#endif
 
  // write a pvd file, which links all vti files
  // each vti file is written by one thread, which may own severals cuboids
  if ( rank == 0 ) {
    // master only
    const std::string pathVTM = singleton::directories().getVtkOutDir()
                                + createFileName( f.getName(), iT )  + ".vtm";
 
    preambleVTM(pathVTM);
    for (int iC = 0; iC < cGeometry.getNc(); iC++) {
      const std::string nameVTI = "data/" + createFileName( f.getName(), iT, iC) + ".vti";
      // puts name of .vti piece to a .pvd file [fullNamePVD]
      dataVTM( iC, pathVTM, nameVTI );
    }
    closeVTM(pathVTM);
  } // master only
 
  for (int iCloc = 0; iCloc < load.size(); iCloc++) {
    // get piece/whole extent
    const Vector<int,3> extent0(-_overlap,-_overlap,-_overlap);
    const Vector<int,3> extent1( cGeometry.get(load.glob(iCloc)).getExtent());
 
    const std::string fullNameVTI = singleton::directories().getVtkOutDir() + "data/"
                                    + createFileName( f.getName(), iT, load.glob(iCloc) ) + ".vti";
 
    // get dimension/extent for each cuboid
    const int originLatticeR[4] = {load.glob(iCloc),0,0,0};
    T originPhysR[3] = {T()};
    cGeometry.getPhysR(originPhysR,originLatticeR);
 
    preambleVTI(fullNameVTI, extent0, (extent1+_overlap-1.), originPhysR, delta);
 
    dataArray(fullNameVTI, f, load.glob(iCloc), extent1);
    closePiece(fullNameVTI);
    closeVTI(fullNameVTI);
  } // cuboid
}

References olb::SuperStructure< T, D >::communicate(), olb::createFileName(), olb::singleton::directories(), olb::CuboidGeometry3D< T >::get(), olb::SuperStructure< T, D >::getCuboidGeometry(), olb::SuperStructure< T, D >::getLoadBalancer(), olb::CuboidGeometry3D< T >::getMotherCuboid(), olb::GenericF< T, S >::getName(), olb::CuboidGeometry3D< T >::getNc(), olb::CuboidGeometry3D< T >::getPhysR(), olb::singleton::MpiManager::getRank(), olb::SuperF3D< T, W >::getSuperStructure(), olb::singleton::Directories::getVtkOutDir(), olb::LoadBalancer< T >::glob(), olb::singleton::mpi(), and olb::LoadBalancer< T >::size().

Here is the call graph for this function:

writeGlobalVTI()

template<typename T , typename OUT_T , typename W >

void olb::SuperVTMwriter3D< T, OUT_T, W >::writeGlobalVTI	(	int	iT,
		int	iC )

writes the vti file for cuboid iC at timestep iT

Definition at line 128 of file superVtmWriter3D.hh.

{
  const auto it_begin = _pointerVec.cbegin();
  CuboidGeometry3D<T> const& cGeometry = _cGeometry ? *_cGeometry : (**it_begin).getSuperStructure().getCuboidGeometry();
  const T delta = cGeometry.getMotherCuboid().getDeltaR();
 
  // get piece/whole extent
  const Vector<int,3> extent0(-_overlap,-_overlap,-_overlap);
  const Vector<int,3> extent1(cGeometry.get(iC).getExtent());
 
  const std::string fullNameVTI = singleton::directories().getVtkOutDir() + "data/"
                                + createFileName(_name, iT, iC) + ".vti";
 
  // get dimension/extent for each cuboid
  const int originLatticeR[4] = {iC,0,0,0};
  T originPhysR[3] = {T()};
  cGeometry.getPhysR(originPhysR,originLatticeR);
 
  preambleVTI(fullNameVTI, extent0, (extent1+_overlap-1), originPhysR, delta);
  for (auto it : _pointerVec) {
    dataArray(fullNameVTI, *it, iC, extent1);
  }
  closePiece(fullNameVTI);
  closeVTI(fullNameVTI);
}

References olb::createFileName(), olb::singleton::directories(), olb::CuboidGeometry3D< T >::get(), olb::CuboidGeometry3D< T >::getMotherCuboid(), olb::CuboidGeometry3D< T >::getPhysR(), and olb::singleton::Directories::getVtkOutDir().

Here is the call graph for this function:

writePVD()

template<typename T , typename OUT_T , typename W >

void olb::SuperVTMwriter3D< T, OUT_T, W >::writePVD

(

int

iT

)

writes only the linking pvd file for timestep iT, blocks must be written separately (e.g. asynchronously)

Definition at line 103 of file superVtmWriter3D.hh.

{
  // to get first element _pointerVec
  // problem if functors with different SuperStructure are stored
  // since till now, there is only one origin
  const auto it_begin = _pointerVec.cbegin();
  CuboidGeometry3D<T> const& cGeometry = _cGeometry ? *_cGeometry : (**it_begin).getSuperStructure().getCuboidGeometry();
 
  // PVD, owns all
  if (singleton::mpi().isMainProcessor()) {
    const std::string pathPVD = singleton::directories().getVtkOutDir()
                              + createFileName(_name) + ".pvd";
    dataPVDmaster(iT, pathPVD, "data/" + createFileName(_name, iT) + ".vtm");
 
    const std::string pathVTM = singleton::directories().getVtkOutDir()
                              + "data/" + createFileName(_name, iT) + ".vtm";
    preambleVTM(pathVTM);
    for (int iC = 0; iC < cGeometry.getNc(); iC++) {
      dataVTM(iC, pathVTM, createFileName(_name, iT, iC) + ".vti" );
    }
    closeVTM(pathVTM);
  }
}

References olb::createFileName(), olb::singleton::directories(), olb::CuboidGeometry3D< T >::getNc(), olb::singleton::Directories::getVtkOutDir(), and olb::singleton::mpi().

Here is the call graph for this function:

writeVTI()

template<typename T , typename OUT_T , typename W >

void olb::SuperVTMwriter3D< T, OUT_T, W >::writeVTI	(	int	iT,
		int	iCloc )

writes the vti file for cuboid iCloc at timestep iT

Definition at line 155 of file superVtmWriter3D.hh.

{
  const auto it_begin = _pointerVec.cbegin();
  CuboidGeometry3D<T> const& cGeometry = (**it_begin).getSuperStructure().getCuboidGeometry();
  LoadBalancer<T>& load = (**it_begin).getSuperStructure().getLoadBalancer();
  const T delta = cGeometry.getMotherCuboid().getDeltaR();
 
  // get piece/whole extent
  const Vector<int,3> extent0(-_overlap,-_overlap,-_overlap);
  const Vector<int,3> extent1(cGeometry.get(load.glob(iCloc)).getExtent());
 
  const std::string fullNameVTI = singleton::directories().getVtkOutDir() + "data/"
                                + createFileName(_name, iT, load.glob(iCloc)) + ".vti";
 
  // get dimension/extent for each cuboid
  const int originLatticeR[4] = {load.glob(iCloc),0,0,0};
  T originPhysR[3] = {T()};
  cGeometry.getPhysR(originPhysR,originLatticeR);
 
  preambleVTI(fullNameVTI, extent0, (extent1+_overlap-1), originPhysR, delta);
  for (auto it : _pointerVec) {
    dataArray(fullNameVTI, *it, load.glob(iCloc), extent1);
  }
  closePiece(fullNameVTI);
  closeVTI(fullNameVTI);
}

References olb::createFileName(), olb::singleton::directories(), olb::CuboidGeometry3D< T >::get(), olb::CuboidGeometry3D< T >::getMotherCuboid(), olb::CuboidGeometry3D< T >::getPhysR(), olb::singleton::Directories::getVtkOutDir(), and olb::LoadBalancer< T >::glob().

Here is the call graph for this function:

---

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

• src/io/superVtmWriter3D.h
• src/io/superVtmWriter3D.hh