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::Vector3< T > >
 
struct  VTKTrait< uint16_t >
 
struct  VTKTrait< uint32_t >
 
struct  VTKTrait< uint64_t >
 
struct  VTKTrait< uint8_t >
 

Typedefs

typedef internal::BlockCellDataWriter BlockCellDataWriterInterface
 
typedef std::function< void() > OutputFunction
 
typedef std::function< void(std::vector< shared_ptr< BlockCellDataWriterInterface > > &writers, std::map< std::string, VTKOutput::CellFilter > &filters, std::map< std::string, VTKOutput::BeforeFunction > &beforeFunctions) > RegisterVTKOutputFunction
 

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< VTKOutputcreateVTKOutput_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< VTKOutputcreateVTKOutput_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< VTKOutputcreateVTKOutput_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< VTKOutputcreateVTKOutput_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< VTKOutputcreateVTKOutput_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< VTKOutputcreateVTKOutput_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< VTKOutputcreateVTKOutput_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< VTKOutputcreateVTKOutput_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

typedef std::function< void () > walberla::vtk::OutputFunction
typedef std::function< void ( std::vector< shared_ptr< BlockCellDataWriterInterface > > & writers, std::map< std::string, VTKOutput::CellFilter > & filters, std::map< std::string, VTKOutput::BeforeFunction > & beforeFunctions ) > walberla::vtk::RegisterVTKOutputFunction

Function Documentation

static void walberla::vtk::addStates ( Set< SUID > &  set,
const std::string &  string 
)
static
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
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
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
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
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
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
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
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
uint_t walberla::vtk::determineWriteFrequency ( const real_t  dt_SI,
const uint_t  fps 
)
inline
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 
)
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 
)
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 
)
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 
)
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
outputFunctionsThe output functions which correspond to the just created VTKOutput objects
registerVTKOutputFunctionA 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
storageThe structured block storage the VTKOutput object shall be associated with
configThe configuration
configBlockNameName of the block in the configuration that is used to setup the VTK output
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 
)
template<typename T >
shared_ptr< BlockCellDataWriterScalingAdapter<T> > walberla::vtk::makeBlockCellDataWriterScalingAdapter ( const std::string &  id,
const shared_ptr< T > &  base,
typename T::value_type  factor 
)
static std::vector< std::string > walberla::vtk::splitList ( const std::string &  string)
static
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
template<typename T >
void walberla::vtk::toStream ( std::ostream &  os,
const T  value 
)
inline
template<>
void walberla::vtk::toStream ( std::ostream &  os,
const int8_t  value 
)
inline
template<>
void walberla::vtk::toStream ( std::ostream &  os,
const uint8_t  value 
)
inline
template<typename T >
std::string walberla::vtk::typeToString ( )
inline
VTKOutput::WriteCollectors walberla::vtk::writeCollectorFiles ( const shared_ptr< VTKOutput > &  vtk,
const bool  barrier 
)
inline
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
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
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
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
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