walberla::vtk Namespace Reference

Namespaces
	internal

Classes
class	AABBCellFilter
	Implementation of a cell filter based on an axis-aligned bounding box. More...
class	Base64Writer
	Class for encoding VTK compatible base64 data streams. More...
class	BlockCellDataWriter
	Interface that is used by VTKOutput in order to write data to VTK files. More...
class	BlockCellDataWriterScalingAdapter
struct	CaseInsensitiveCompare
class	CellBBCellFilter
	Implementation of a cell filter based on a cell bounding box. More...
class	ChainedFilter
class	DumpBlockStructureLevel
class	DumpBlockStructureProcess
class	PointDataSource
class	PolylineDataSource
struct	SelectableOutputFunction
class	VTKOutput
struct	VTKTrait
struct	VTKTrait< double >
struct	VTKTrait< float >
struct	VTKTrait< int16_t >
struct	VTKTrait< int32_t >
struct	VTKTrait< int64_t >
struct	VTKTrait< int8_t >
struct	VTKTrait< math::Rot3< T > >
struct	VTKTrait< math::Vector3< T > >
struct	VTKTrait< std::array< T, N > >
struct	VTKTrait< uint16_t >
struct	VTKTrait< uint32_t >
struct	VTKTrait< uint64_t >
struct	VTKTrait< uint8_t >

Typedefs
using	BlockCellDataWriterInterface = internal::BlockCellDataWriter
using	OutputFunction = std::function< void()>
using	RegisterVTKOutputFunction = std::function< void(std::vector< shared_ptr< BlockCellDataWriterInterface > > &, std::map< std::string, VTKOutput::CellFilter > &, std::map< std::string, VTKOutput::BeforeFunction > &)>

Functions
template<typename T >
shared_ptr< BlockCellDataWriterScalingAdapter< T > >	makeBlockCellDataWriterScalingAdapter (const std::string &id, const shared_ptr< T > &base, typename T::value_type factor)
template<typename T >
static void	splitVector (T &x, T &y, T &z, const Config::BlockHandle &bb, const std::string &vertex, const std::string &errorMsg)
static std::vector< std::string >	splitList (const std::string &string)
static void	addStates (Set< SUID > &set, const std::string &string)
void	initializeVTKOutput (std::map< std::string, SelectableOutputFunction > &outputFunctions, const shared_ptr< const StructuredBlockStorage > &storage, const shared_ptr< Config > &config, const std::string &configBlockName, const std::vector< shared_ptr< BlockCellDataWriterInterface > > &writers, const std::map< std::string, VTKOutput::CellFilter > &filters, const std::map< std::string, VTKOutput::BeforeFunction > &beforeFunctions)
void	initializeVTKOutput (std::map< std::string, SelectableOutputFunction > &outputFunctions, const shared_ptr< const StructuredBlockStorage > &storage, const Config::BlockHandle &parentBlockHandle, const std::string &configBlockName, const std::vector< shared_ptr< BlockCellDataWriterInterface > > &_writers, const std::map< std::string, VTKOutput::CellFilter > &_filters, const std::map< std::string, VTKOutput::BeforeFunction > &_beforeFunctions)
void	initializeVTKOutput (std::map< std::string, SelectableOutputFunction > &outputFunctions, const shared_ptr< const StructuredBlockStorage > &storage, const shared_ptr< Config > &config, const std::vector< shared_ptr< BlockCellDataWriterInterface > > &writers, const std::map< std::string, VTKOutput::CellFilter > &filters, const std::map< std::string, VTKOutput::BeforeFunction > &beforeFunctions)
void	initializeVTKOutput (std::map< std::string, SelectableOutputFunction > &outputFunctions, const shared_ptr< const StructuredBlockStorage > &storage, const Config::BlockHandle &parentBlockHandle, const std::vector< shared_ptr< BlockCellDataWriterInterface > > &writers, const std::map< std::string, VTKOutput::CellFilter > &filters, const std::map< std::string, VTKOutput::BeforeFunction > &beforeFunctions)
void	initializeVTKOutput (std::map< std::string, SelectableOutputFunction > &outputFunctions, const RegisterVTKOutputFunction &registerVTKOutputFunction, const shared_ptr< const StructuredBlockStorage > &storage, const shared_ptr< Config > &config, const std::string &configBlockName)
	Function for initializing VTKOutput objects from file and creating their corresponding output functions. More...
void	initializeVTKOutput (std::map< std::string, SelectableOutputFunction > &outputFunctions, const RegisterVTKOutputFunction &registerVTKOutputFunction, const shared_ptr< const StructuredBlockStorage > &storage, const Config::BlockHandle &parentBlockHandle, const std::string &configBlockName)
template<typename T >
void	toStream (std::ostream &os, const T value)
template<>
void	toStream (std::ostream &os, const int8_t value)
template<>
void	toStream (std::ostream &os, const uint8_t value)
template<typename T >
std::string	typeToString ()
uint_t	determineWriteFrequency (const real_t dt_SI, const uint_t fps)
shared_ptr< VTKOutput >	createVTKOutput_DomainDecomposition (const BlockStorage &bs, const std::string &identifier=std::string("domain_decomposition"), const uint_t writeFrequency=1, const std::string &baseFolder=std::string("vtk_out"), const std::string &executionFolder=std::string("simulation_step"), const bool continuousNumbering=false, const bool binary=true, const bool littleEndian=true, const bool useMPIIO=true, const uint_t initialExecutionCount=0)
shared_ptr< VTKOutput >	createVTKOutput_DomainDecomposition (const StructuredBlockStorage &sbs, const std::string &identifier=std::string("domain_decomposition"), const uint_t writeFrequency=1, const std::string &baseFolder=std::string("vtk_out"), const std::string &executionFolder=std::string("simulation_step"), const bool continuousNumbering=false, const bool binary=true, const bool littleEndian=true, const bool useMPIIO=true, const uint_t initialExecutionCount=0)
shared_ptr< VTKOutput >	createVTKOutput_DomainDecomposition (const shared_ptr< const BlockStorage > &sbs, const std::string &identifier=std::string("domain_decomposition"), const uint_t writeFrequency=1, const std::string &baseFolder=std::string("vtk_out"), const std::string &executionFolder=std::string("simulation_step"), const bool continuousNumbering=false, const bool binary=true, const bool littleEndian=true, const bool useMPIIO=true, const uint_t initialExecutionCount=0)
shared_ptr< VTKOutput >	createVTKOutput_DomainDecomposition (const shared_ptr< const StructuredBlockStorage > &sbs, const std::string &identifier=std::string("domain_decomposition"), const uint_t writeFrequency=1, const std::string &baseFolder=std::string("vtk_out"), const std::string &executionFolder=std::string("simulation_step"), const bool continuousNumbering=false, const bool binary=true, const bool littleEndian=true, const bool useMPIIO=true, const uint_t initialExecutionCount=0)
shared_ptr< VTKOutput >	createVTKOutput_BlockData (const StructuredBlockStorage &sbs, const std::string &identifier=std::string("block_data"), const uint_t writeFrequency=1, const uint_t ghostLayers=0, const bool forcePVTU=false, const std::string &baseFolder=std::string("vtk_out"), const std::string &executionFolder=std::string("simulation_step"), const bool continuousNumbering=false, const bool binary=true, const bool littleEndian=true, const bool useMPIIO=true, const uint_t initialExecutionCount=0)
shared_ptr< VTKOutput >	createVTKOutput_BlockData (const shared_ptr< const StructuredBlockStorage > &sbs, const std::string &identifier=std::string("block_data"), const uint_t writeFrequency=1, const uint_t ghostLayers=0, const bool forcePVTU=false, const std::string &baseFolder=std::string("vtk_out"), const std::string &executionFolder=std::string("simulation_step"), const bool continuousNumbering=false, const bool binary=true, const bool littleEndian=true, const bool useMPIIO=true, const uint_t initialExecutionCount=0)
shared_ptr< VTKOutput >	createVTKOutput_PointData (const shared_ptr< PointDataSource > pds, const std::string &identifier=std::string("point_data"), const uint_t writeFrequency=1, const std::string &baseFolder=std::string("vtk_out"), const std::string &executionFolder=std::string("simulation_step"), const bool continuousNumbering=false, const bool binary=true, const bool littleEndian=true, const bool useMPIIO=true, const uint_t initialExecutionCount=0)
shared_ptr< VTKOutput >	createVTKOutput_PolylineData (const shared_ptr< PolylineDataSource > pds, const std::string &identifier=std::string("point_data"), const uint_t writeFrequency=1, const std::string &baseFolder=std::string("vtk_out"), const std::string &executionFolder=std::string("simulation_step"), const bool continuousNumbering=false, const bool binary=true, const bool littleEndian=true, const bool useMPIIO=true, const uint_t initialExecutionCount=0)
void	writeDomainDecomposition (const StructuredBlockStorage &sbs, const std::string &identifier=std::string("domain_decomposition"), const std::string &baseFolder=std::string("vtk_out"), const std::string &executionFolder=std::string("write_call"), const bool binary=true, const bool littleEndian=true, const int simultaneousIOOperations=0, const Set< SUID > &requiredStates=Set< SUID >::emptySet(), const Set< SUID > &incompatibleStates=Set< SUID >::emptySet(), bool useMPIIO=true)
void	writeDomainDecomposition (const BlockStorage &bs, const std::string &identifier=std::string("domain_decomposition"), const std::string &baseFolder=std::string("vtk_out"), const std::string &executionFolder=std::string("write_call"), const bool binary=true, const bool littleEndian=true, const int simultaneousIOOperations=0, const Set< SUID > &requiredStates=Set< SUID >::emptySet(), const Set< SUID > &incompatibleStates=Set< SUID >::emptySet(), bool useMPIIO=true)
void	writeDomainDecomposition (const shared_ptr< const BlockStorage > &bs, const std::string &identifier=std::string("domain_decomposition"), const std::string &baseFolder=std::string("vtk_out"), const std::string &executionFolder=std::string("write_call"), const bool binary=true, const bool littleEndian=true, const int simultaneousIOOperations=0, const Set< SUID > &requiredStates=Set< SUID >::emptySet(), const Set< SUID > &incompatibleStates=Set< SUID >::emptySet(), bool useMPIIO=true)
void	writeDomainDecomposition (const shared_ptr< const StructuredBlockStorage > &sbs, const std::string &identifier=std::string("domain_decomposition"), const std::string &baseFolder=std::string("vtk_out"), const std::string &executionFolder=std::string("write_call"), const bool binary=true, const bool littleEndian=true, const int simultaneousIOOperations=0, const Set< SUID > &requiredStates=Set< SUID >::emptySet(), const Set< SUID > &incompatibleStates=Set< SUID >::emptySet(), bool useMPIIO=true)
VTKOutput::Write	writeFiles (const shared_ptr< VTKOutput > &vtk, const bool immediatelyWriteCollectors=true, const int simultaneousIOOperations=0, const Set< SUID > &requiredStates=Set< SUID >::emptySet(), const Set< SUID > &incompatibleStates=Set< SUID >::emptySet())
VTKOutput::WriteCollectors	writeCollectorFiles (const shared_ptr< VTKOutput > &vtk, const bool barrier)

Typedef Documentation

BlockCellDataWriterInterface

using walberla::vtk::BlockCellDataWriterInterface = typedef internal::BlockCellDataWriter

OutputFunction

using walberla::vtk::OutputFunction = typedef std::function<void ()>

RegisterVTKOutputFunction

using walberla::vtk::RegisterVTKOutputFunction = typedef std::function<void (std::vector<shared_ptr<BlockCellDataWriterInterface> > &, std::map<std::string, VTKOutput::CellFilter> &, std::map<std::string, VTKOutput::BeforeFunction> &)>

Function Documentation

addStates()

static void walberla::vtk::addStates ( Set< SUID > &  set, const std::string &  string  )

static

createVTKOutput_BlockData() [1/2]

shared_ptr<VTKOutput> walberla::vtk::createVTKOutput_BlockData ( const shared_ptr< const StructuredBlockStorage > &  sbs, const std::string &  identifier = std::string("block_data"), const uint_t  writeFrequency = 1, const uint_t  ghostLayers = 0, const bool  forcePVTU = false, const std::string &  baseFolder = std::string("vtk_out"), const std::string &  executionFolder = std::string("simulation_step"), const bool  continuousNumbering = false, const bool  binary = true, const bool  littleEndian = true, const bool  useMPIIO = true, const uint_t  initialExecutionCount = 0  )

inline

createVTKOutput_BlockData() [2/2]

shared_ptr<VTKOutput> walberla::vtk::createVTKOutput_BlockData ( const StructuredBlockStorage &  sbs, const std::string &  identifier = std::string("block_data"), const uint_t  writeFrequency = 1, const uint_t  ghostLayers = 0, const bool  forcePVTU = false, const std::string &  baseFolder = std::string("vtk_out"), const std::string &  executionFolder = std::string("simulation_step"), const bool  continuousNumbering = false, const bool  binary = true, const bool  littleEndian = true, const bool  useMPIIO = true, const uint_t  initialExecutionCount = 0  )

inline

createVTKOutput_DomainDecomposition() [1/4]

shared_ptr<VTKOutput> walberla::vtk::createVTKOutput_DomainDecomposition ( const BlockStorage &  bs, const std::string &  identifier = std::string("domain_decomposition"), const uint_t  writeFrequency = 1, const std::string &  baseFolder = std::string("vtk_out"), const std::string &  executionFolder = std::string("simulation_step"), const bool  continuousNumbering = false, const bool  binary = true, const bool  littleEndian = true, const bool  useMPIIO = true, const uint_t  initialExecutionCount = 0  )

inline

createVTKOutput_DomainDecomposition() [2/4]

shared_ptr<VTKOutput> walberla::vtk::createVTKOutput_DomainDecomposition ( const shared_ptr< const BlockStorage > &  sbs, const std::string &  identifier = std::string("domain_decomposition"), const uint_t  writeFrequency = 1, const std::string &  baseFolder = std::string("vtk_out"), const std::string &  executionFolder = std::string("simulation_step"), const bool  continuousNumbering = false, const bool  binary = true, const bool  littleEndian = true, const bool  useMPIIO = true, const uint_t  initialExecutionCount = 0  )

inline

createVTKOutput_DomainDecomposition() [3/4]

shared_ptr<VTKOutput> walberla::vtk::createVTKOutput_DomainDecomposition ( const shared_ptr< const StructuredBlockStorage > &  sbs, const std::string &  identifier = std::string("domain_decomposition"), const uint_t  writeFrequency = 1, const std::string &  baseFolder = std::string("vtk_out"), const std::string &  executionFolder = std::string("simulation_step"), const bool  continuousNumbering = false, const bool  binary = true, const bool  littleEndian = true, const bool  useMPIIO = true, const uint_t  initialExecutionCount = 0  )

inline

createVTKOutput_DomainDecomposition() [4/4]

shared_ptr<VTKOutput> walberla::vtk::createVTKOutput_DomainDecomposition ( const StructuredBlockStorage &  sbs, const std::string &  identifier = std::string("domain_decomposition"), const uint_t  writeFrequency = 1, const std::string &  baseFolder = std::string("vtk_out"), const std::string &  executionFolder = std::string("simulation_step"), const bool  continuousNumbering = false, const bool  binary = true, const bool  littleEndian = true, const bool  useMPIIO = true, const uint_t  initialExecutionCount = 0  )

inline

createVTKOutput_PointData()

shared_ptr<VTKOutput> walberla::vtk::createVTKOutput_PointData ( const shared_ptr< PointDataSource >  pds, const std::string &  identifier = std::string("point_data"), const uint_t  writeFrequency = 1, const std::string &  baseFolder = std::string("vtk_out"), const std::string &  executionFolder = std::string("simulation_step"), const bool  continuousNumbering = false, const bool  binary = true, const bool  littleEndian = true, const bool  useMPIIO = true, const uint_t  initialExecutionCount = 0  )

inline

createVTKOutput_PolylineData()

shared_ptr<VTKOutput> walberla::vtk::createVTKOutput_PolylineData ( const shared_ptr< PolylineDataSource >  pds, const std::string &  identifier = std::string("point_data"), const uint_t  writeFrequency = 1, const std::string &  baseFolder = std::string("vtk_out"), const std::string &  executionFolder = std::string("simulation_step"), const bool  continuousNumbering = false, const bool  binary = true, const bool  littleEndian = true, const bool  useMPIIO = true, const uint_t  initialExecutionCount = 0  )

inline

determineWriteFrequency()

uint_t walberla::vtk::determineWriteFrequency ( const real_t  dt_SI, const uint_t  fps  )

inline

initializeVTKOutput() [1/6]

void walberla::vtk::initializeVTKOutput	(	std::map< std::string, SelectableOutputFunction > &	outputFunctions,
		const RegisterVTKOutputFunction &	registerVTKOutputFunction,
		const shared_ptr< const StructuredBlockStorage > &	storage,
		const Config::BlockHandle &	parentBlockHandle,
		const std::string &	configBlockName
	)

initializeVTKOutput() [2/6]

void walberla::vtk::initializeVTKOutput	(	std::map< std::string, SelectableOutputFunction > &	outputFunctions,
		const RegisterVTKOutputFunction &	registerVTKOutputFunction,
		const shared_ptr< const StructuredBlockStorage > &	storage,
		const shared_ptr< Config > &	config,
		const std::string &	configBlockName
	)

Function for initializing VTKOutput objects from file and creating their corresponding output functions.

This initialization function reads data stored in a configuration file, uses this data to create VTKOutput objects, and finally constructs corresponding output functions which then are returned via the parameter "outputFunctions". The returned output functions all have the signature "void (void)". Calling such an output function initiates one output of the associated VTKOutput object.

VTK via Configuration File

For reading VTK setup information from a configuration file, the structure of the configuration file must look like as follows:

VTK // every sub block of VTK corresponds to one VTKOutput object that is created
{
   [name] // identifier for this VTKOutput object
   {
      simultaneousIOOperations [integer value]; // max. number of files that are written
                                                // in parallel (optional, default=0 [=disabled])
 
      initialExecutionCount   [integer value]; // optional, default=0
      initialWriteCallsToSkip [integer value]; // optional, default=0
      writeFrequency          [integer value]; // output frequency = number of times "writeBlocks" must be
                                               // called for triggering an output (optional, default=1)
                                               // 0 disables output
      forcePVTU               [boolean];       // if true, (P)VTU files are created, and not (P)VTI files
                                               // (optional, default=false)
      ghostLayers             [integer value]; // number of ghost layers (optional, default=0)
 
      baseFolder      [directory]; // base directory (optional, default=vtk_out)
      executionFolder [directory]; // base directory for each time step, directory path is given relative
                                   // to baseFolder (optional, default=simulation_step)
 
      outputDomainDecomposition [boolean]; // if true, the domain decomposition is written to file
                                           // specifying cell filters and block cell data writers is
                                           // not allowed! (optional, default=false)
      continuousNumbering       [boolean]; // if false, the actual time step is preserved
                                           // (optional, default=false)
      binary                    [boolean]; // if false, ascii files are written (optional, default=true)
      littleEndian              [boolean]; // switch between little and big endianness (optional, default=true)
 
      useMPIIO                  [boolean]; // use MPI I/O to write only one file per time step
                                           // (optional, default=true)
 
      // You can either specify "samplingResolution" or "samplingDx", "samplingDy", and "samplingDz"
      samplingResolution [floating point value]; // "samplingResolution VALUE" has the same effect as
                                                 // setting "samplingDx", "samplingDy", and "samplingDz" to VALUE
      samplingDx         [floating point value]; // forces the output to use this dx (= cell x-spacing)
      samplingDy         [floating point value]; // forces the output to use this dy (= cell y-spacing)
      samplingDz         [floating point value]; // forces the output to use this dz (= cell z-spacing)
 
      before_functions // (OPTIONAL, APPLICATION-DEPENDENT!)
      {
         [NameOfTheFirstFunction];   // the mapping of this name to a function pointer/functor is
         [NameOfTheSecondFunction];  // done by the RegisterVTKOutputFunction "registerVTKOutputFunction"
         [...]                       // which must be implemented by the user
      }
 
      // AABB filters are OPTIONAL. AABB filters are sub blocks that must start with "AABB_filter".
      // AABB filters can be selected as either inclusion or exclusion filters. In order to select an
      // AABB filter "AABB_filter_XXX" as inclusion/exclusion filter, its name/identifier (in this
      // example: "AABB_filter_XXX") must be added to the list of inclusion/exclusion filters in
      // the sub block inclusion_filters/inclusion_filters.
 
      AABB_filter_0
      {
         min < [x: floating point value], [y: floating point value], [z: floating point value] >;
         max < [x: floating point value], [y: floating point value], [z: floating point value] >;
      }
      // AABB_filter_1
      // {
      //    min < [x: floating point value], [y: floating point value], [z: floating point value] >;
      //    max < [x: floating point value], [y: floating point value], [z: floating point value] >;
      // }
      // AABB_filter_2 { ... }
      // AABB_filter_* { ... }
 
      // CellBB filters are OPTIONAL. CellBB filters are sub blocks that must start with "CellBB_filter".
      // CellBB filters can be selected as either inclusion or exclusion filters. In order to select an
      // CellBB filter "CellBB_filter_XXX" as inclusion/exclusion filter, its name/identifier (in this
      // example: "CellBB_filter_XXX") must be added to the list of inclusion/exclusion filters in
      // the sub block inclusion_filters/inclusion_filters.
      // CellBB filters are AABB filters that are defined using discrete (!) global cell coordinates.
 
      CellBB_filter_0
      {
         level [integer value]; // the cell level to which the following coordinates correspond to
                                // (optional, default=0)
         min < [x: integer value], [y: integer value], [z: integer value] >;
         max < [x: integer value], [y: integer value], [z: integer value] >;
      }
      // CellBB_filter_1
      // {
      //    min < [x: integer value], [y: integer value], [z: integer value] >;
      //    max < [x: integer value], [y: integer value], [z: integer value] >;
      // }
      // CellBB_filter_2 { ... }
      // CellBB_filter_* { ... }
 
      // In terms of set theory: all filters listed as inclusion filters are "added" together,
      // resulting in a union of all filters.
 
      inclusion_filters // (OPTIONAL, APPLICATION-DEPENDENT!)
      {
         [NameOfTheFirstFilter];   // the mapping of this name to an inclusion filter is
         [NameOfTheSecondFilter];  // done by the RegisterVTKOutputFunction "registerVTKOutputFunction"
         [...]                     // which must be implemented by the user
 
         // In terms of set theory: combining filters results in an intersection of these filters.
         combine [NameOfAFilter],[NameOfAnotherFilter],[NameOfYetAnotherFilter],[...];
      }
 
      // In terms of set theory: all filters listed as exclusion filters are "added" together,
      // resulting in a union of all filters.
 
      exclusion_filters // (OPTIONAL, APPLICATION-DEPENDENT!)
      {
         [NameOfTheFirstFilter];   // the mapping of this name to an exclusion filter is
         [NameOfTheSecondFilter];  // done by the RegisterVTKOutputFunction "registerVTKOutputFunction"
         [...]                     // which must be implemented by the user
 
         // In terms of set theory: combining filters results in an intersection of these filters.
         combine [NameOfAFilter],[NameOfAnotherFilter],[NameOfYetAnotherFilter],[...];
      }
 
      writers // (AT LEAST ONE IS MANDATORY [exception: if outputDomainDecomposition == true,
              // no writers are allowed!], APPLICATION-DEPENDENT!)
      {
         [NameOfTheFirstWriter];  // the mapping of this name to a writer is
         [NameOfTheSecondWriter]; // done by the RegisterVTKOutputFunction "registerVTKOutputFunction"
         [...]                    // which must be implemented by the user
      }
 
      requiredGlobalStates      [SUID identifier #1], [SUID identifier #2], ...; // (optional, default=[none])
      incompatibleGlobalStates  [SUID identifier #1], [SUID identifier #2], ...; // (optional, default=[none])
      requiredBlockStates       [SUID identifier #1], [SUID identifier #2], ...; // (optional, default=[none])
      incompatibleBlockStates   [SUID identifier #1], [SUID identifier #2], ...; // (optional, default=[none])
   }
 
   [name of another VTK output object]
   {
      [...]
   }
 
} // VTK

Parameters

outputFunctions	The output functions which correspond to the just created VTKOutput objects
registerVTKOutputFunction	A function pointer that the user must provide and that is used for registering cell filters and block data writers which then can be referenced in the configuration file and which are used to assemble the VTKOutput objects
storage	The structured block storage the VTKOutput object shall be associated with
config	The configuration
configBlockName	Name of the block in the configuration that is used to setup the VTK output

initializeVTKOutput() [3/6]

void walberla::vtk::initializeVTKOutput	(	std::map< std::string, SelectableOutputFunction > &	outputFunctions,
		const shared_ptr< const StructuredBlockStorage > &	storage,
		const Config::BlockHandle &	parentBlockHandle,
		const std::string &	configBlockName,
		const std::vector< shared_ptr< BlockCellDataWriterInterface > > &	_writers,
		const std::map< std::string, VTKOutput::CellFilter > &	_filters,
		const std::map< std::string, VTKOutput::BeforeFunction > &	_beforeFunctions
	)

initializeVTKOutput() [4/6]

void walberla::vtk::initializeVTKOutput	(	std::map< std::string, SelectableOutputFunction > &	outputFunctions,
		const shared_ptr< const StructuredBlockStorage > &	storage,
		const Config::BlockHandle &	parentBlockHandle,
		const std::vector< shared_ptr< BlockCellDataWriterInterface > > &	writers,
		const std::map< std::string, VTKOutput::CellFilter > &	filters,
		const std::map< std::string, VTKOutput::BeforeFunction > &	beforeFunctions
	)

initializeVTKOutput() [5/6]

void walberla::vtk::initializeVTKOutput	(	std::map< std::string, SelectableOutputFunction > &	outputFunctions,
		const shared_ptr< const StructuredBlockStorage > &	storage,
		const shared_ptr< Config > &	config,
		const std::string &	configBlockName,
		const std::vector< shared_ptr< BlockCellDataWriterInterface > > &	writers,
		const std::map< std::string, VTKOutput::CellFilter > &	filters,
		const std::map< std::string, VTKOutput::BeforeFunction > &	beforeFunctions
	)

initializeVTKOutput() [6/6]

void walberla::vtk::initializeVTKOutput	(	std::map< std::string, SelectableOutputFunction > &	outputFunctions,
		const shared_ptr< const StructuredBlockStorage > &	storage,
		const shared_ptr< Config > &	config,
		const std::vector< shared_ptr< BlockCellDataWriterInterface > > &	writers,
		const std::map< std::string, VTKOutput::CellFilter > &	filters,
		const std::map< std::string, VTKOutput::BeforeFunction > &	beforeFunctions
	)

makeBlockCellDataWriterScalingAdapter()

template<typename T >

shared_ptr< BlockCellDataWriterScalingAdapter<T> > walberla::vtk::makeBlockCellDataWriterScalingAdapter	(	const std::string &	id,
		const shared_ptr< T > &	base,
		typename T::value_type	factor
	)

splitList()

static std::vector< std::string > walberla::vtk::splitList ( const std::string &  string )

static

splitVector()

template<typename T >

static void walberla::vtk::splitVector ( T &  x, T &  y, T &  z, const Config::BlockHandle &  bb, const std::string &  vertex, const std::string &  errorMsg  )

static

toStream() [1/3]

template<>

void walberla::vtk::toStream ( std::ostream &  os, const int8_t  value  )

inline

toStream() [2/3]

template<typename T >

void walberla::vtk::toStream ( std::ostream &  os, const T  value  )

inline

toStream() [3/3]

template<>

void walberla::vtk::toStream ( std::ostream &  os, const uint8_t  value  )

inline

typeToString()

template<typename T >

std::string walberla::vtk::typeToString ( )

inline

writeCollectorFiles()

VTKOutput::WriteCollectors walberla::vtk::writeCollectorFiles ( const shared_ptr< VTKOutput > &  vtk, const bool  barrier  )

inline

writeDomainDecomposition() [1/4]

void walberla::vtk::writeDomainDecomposition ( const BlockStorage &  bs, const std::string &  identifier = std::string("domain_decomposition"), const std::string &  baseFolder = std::string("vtk_out"), const std::string &  executionFolder = std::string("write_call"), const bool  binary = true, const bool  littleEndian = true, const int  simultaneousIOOperations = 0, const Set< SUID > &  requiredStates = Set<SUID>::emptySet(), const Set< SUID > &  incompatibleStates = Set<SUID>::emptySet(), bool  useMPIIO = true  )

inline

writeDomainDecomposition() [2/4]

void walberla::vtk::writeDomainDecomposition ( const shared_ptr< const BlockStorage > &  bs, const std::string &  identifier = std::string("domain_decomposition"), const std::string &  baseFolder = std::string("vtk_out"), const std::string &  executionFolder = std::string("write_call"), const bool  binary = true, const bool  littleEndian = true, const int  simultaneousIOOperations = 0, const Set< SUID > &  requiredStates = Set<SUID>::emptySet(), const Set< SUID > &  incompatibleStates = Set<SUID>::emptySet(), bool  useMPIIO = true  )

inline

writeDomainDecomposition() [3/4]

void walberla::vtk::writeDomainDecomposition ( const shared_ptr< const StructuredBlockStorage > &  sbs, const std::string &  identifier = std::string("domain_decomposition"), const std::string &  baseFolder = std::string("vtk_out"), const std::string &  executionFolder = std::string("write_call"), const bool  binary = true, const bool  littleEndian = true, const int  simultaneousIOOperations = 0, const Set< SUID > &  requiredStates = Set<SUID>::emptySet(), const Set< SUID > &  incompatibleStates = Set<SUID>::emptySet(), bool  useMPIIO = true  )

inline

writeDomainDecomposition() [4/4]

void walberla::vtk::writeDomainDecomposition ( const StructuredBlockStorage &  sbs, const std::string &  identifier = std::string("domain_decomposition"), const std::string &  baseFolder = std::string("vtk_out"), const std::string &  executionFolder = std::string("write_call"), const bool  binary = true, const bool  littleEndian = true, const int  simultaneousIOOperations = 0, const Set< SUID > &  requiredStates = Set<SUID>::emptySet(), const Set< SUID > &  incompatibleStates = Set<SUID>::emptySet(), bool  useMPIIO = true  )

inline

writeFiles()

VTKOutput::Write walberla::vtk::writeFiles ( const shared_ptr< VTKOutput > &  vtk, const bool  immediatelyWriteCollectors = true, const int  simultaneousIOOperations = 0, const Set< SUID > &  requiredStates = Set<SUID>::emptySet(), const Set< SUID > &  incompatibleStates = Set<SUID>::emptySet()  )

inline