waLBerla 7.2
Loading...
Searching...
No Matches
Classes | Public Types | Public Member Functions | Private Types | Private Member Functions | Private Attributes | Friends | List of all members
walberla::vtk::VTKOutput Class Reference

#include <VTKOutput.h>

+ Inheritance diagram for walberla::vtk::VTKOutput:

Classes

struct  SamplingCell
 
struct  VertexCompare
 
class  VTKGEN
 
class  Write
 
class  WriteCollectors
 

Public Types

using BeforeFunction = std::function<void ()>
 
using CellFilter = std::function<void (CellSet &, const IBlock &, const StructuredBlockStorage &, const uint_t)>
 

Public Member Functions

 ~VTKOutput ()
 
void setInitialWriteCallsToSkip (const uint_t initialWriteCallsToSkip)
 
void addBeforeFunction (BeforeFunction f)
 
void addAABBInclusionFilter (const AABB &aabb)
 
void addAABBExclusionFilter (const AABB &aabb)
 
void addCellInclusionFilter (CellFilter f)
 
void addCellExclusionFilter (CellFilter f)
 
void addCellDataWriter (const shared_ptr< BlockCellDataWriterInterface > &writer)
 
void setSamplingResolution (const real_t spacing)
 
void setSamplingResolution (const real_t dx, const real_t dy, const real_t dz)
 
void write (const bool immediatelyWriteCollectors=true, const int simultaneousIOOperations=0, const Set< SUID > &requiredStates=Set< SUID >::emptySet(), const Set< SUID > &incompatibleStates=Set< SUID >::emptySet())
 
void forceWrite (uint_t number, const bool immediatelyWriteCollectors=true, const int simultaneousIOOperations=0, const Set< SUID > &requiredStates=Set< SUID >::emptySet(), const Set< SUID > &incompatibleStates=Set< SUID >::emptySet())
 
void writeCollectors (const bool barrier)
 
void forceWriteNextStep ()
 
- Public Member Functions inherited from walberla::NonCopyable
 NonCopyable (const NonCopyable &)=delete
 
NonCopyable & operator= (const NonCopyable &)=delete
 

Private Types

using VTKUID = UID<VTKGEN>
 
using Vertex = std::tuple<cell_idx_t, cell_idx_t, cell_idx_t>
 
using VertexCoord = std::tuple<real_t, real_t, real_t>
 
using Index = int32_t
 

Private Member Functions

 VTKOutput (const BlockStorage &sbs, const std::string &identifier, const uint_t writeFrequency, const std::string &baseFolder, const std::string &executionFolder, const bool continuousNumbering, const bool binary, const bool littleEndian, const bool useMPIIO, const uint_t initialExecutionCount=0)
 creates a VTKOutput object that is supposed to output the domain decomposition
 
 VTKOutput (const StructuredBlockStorage &sbs, const std::string &identifier, const uint_t writeFrequency, const std::string &baseFolder, const std::string &executionFolder, const bool continuousNumbering, const bool binary, const bool littleEndian, const bool useMPIIO, const uint_t ghostLayers, const bool forcePVTU, const uint_t initialExecutionCount=0, const bool amrFileFormat=false, const bool oneFilePerProcess=false)
 creates a VTKOutput object that is supposed to output block data/cell data
 
 VTKOutput (const shared_ptr< PointDataSource > &pds, const std::string &identifier, const uint_t writeFrequency, const std::string &baseFolder, const std::string &executionFolder, const bool continuousNumbering, const bool binary, const bool littleEndian, const bool useMPIIO, const uint_t initialExecutionCount=0)
 creates a VTKOutput object that is supposed to output arbitrary point data
 
 VTKOutput (const shared_ptr< PolylineDataSource > &pds, const std::string &identifier, const uint_t writeFrequency, const std::string &baseFolder, const std::string &executionFolder, const bool continuousNumbering, const bool binary, const bool littleEndian, const bool useMPIIO, const uint_t initialExecutionCount=0)
 creates a VTKOutput object that is supposed to output arbitrary polyline data
 
void init (const std::string &identifier)
 
void writeDomainDecomposition (const std::string &path, const Set< SUID > &requiredStates, const Set< SUID > &incompatibleStates) const
 
void writeDomainDecompositionPieces (std::ostream &ofs, const Set< SUID > &requiredStates, const Set< SUID > &incompatibleStates) const
 
void computeOutputPoints (std::vector< Vector3< real_t > > &points, std::vector< bool > &outputPoint, uint_t &numberOfPoints) const
 
void writePointDataPieceHelper (const std::vector< Vector3< real_t > > &points, const std::vector< bool > &outputPoint, const uint_t numberOfPoints, std::ostream &ofs) const
 
void writePointData (const std::string &path)
 
void writePointDataPieces (std::ostream &ofs)
 
void computeOutputPolylines (std::vector< std::vector< Vector3< real_t > > > &lines, std::vector< std::vector< bool > > &outputPolylinePoint, std::vector< size_t > &polylineSize, uint_t &numberOfPolylines, uint_t &numberOfPolylinePoints) const
 
void writePolylineDataPieceHelper (const std::vector< std::vector< Vector3< real_t > > > &lines, const std::vector< std::vector< bool > > &outputPolylinePoint, const std::vector< size_t > &polylineSize, const uint_t numberOfPolylines, const uint_t numberOfPolylinePoints, std::ostream &ofs) const
 
void writePolylineData (const std::string &path)
 
void writePolylineDataPieces (std::ostream &ofs)
 
void computeVTUCells (const IBlock &block, CellVector &cellsOut) const
 
void writeBlocks (const std::string &path, const Set< SUID > &requiredStates, const Set< SUID > &incompatibleStates)
 
void writeBlockPieces (std::ostream &oss, const Set< SUID > &requiredStates, const Set< SUID > &incompatibleStates)
 
void writeVTI (std::ostream &ofs, const IBlock &block) const
 
void writeVTI_sampling (std::ostream &ofs, const IBlock &block) const
 
void writeVTIPiece (std::ostream &ofs, const IBlock &block) const
 
void writeVTIPiece_sampling (std::ostream &ofs, const IBlock &block) const
 
void writeVTU (std::ostream &ofs, const IBlock &block, const CellVector &cells) const
 
void writeVTU_sampling (std::ostream &ofs, const IBlock &block, const CellVector &cells) const
 
void writeParallelVTU (std::ostream &ofs, const Set< SUID > &requiredStates, const Set< SUID > &incompatibleStates) const
 
void writeVTUPiece (std::ostream &ofs, const IBlock &block, const CellVector &cells) const
 
void writeVTUPiece_sampling (std::ostream &ofs, const IBlock &block, const CellVector &cells) const
 
void writeVTUHeader (std::ofstream &ofs, const uint_t numberOfCells, const std::vector< VertexCoord > &vc, const std::vector< Index > &ci) const
 
void writeVTUHeaderPiece (std::ostream &ofs, const uint_t numberOfCells, const std::vector< VertexCoord > &vc, const std::vector< Index > &ci) const
 
uint8_t ghostLayerNr (const IBlock &block, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z) const
 
std::vector< SamplingCell > getSamplingCells (const IBlock &block, const CellVector &cells) const
 
void writeCellData (std::ostream &ofs, const IBlock &block, const CellVector &cells) const
 
void writeCellData (std::ostream &ofs, const Set< SUID > &requiredStates, const Set< SUID > &incompatibleStates) const
 
void writeCellData (std::ostream &ofs, const IBlock &block, const std::vector< SamplingCell > &cells) const
 
void writePVD ()
 
void writeVTHBSeries ()
 
void writePVTI (const uint_t collector) const
 
void writePVTI_sampled (const uint_t collector) const
 
void writeVTHB (const uint_t collector) const
 
void writePVTU (const uint_t collector) const
 
bool writeCombinedVTI (std::string localPart, const uint_t collector) const
 
bool writeCombinedVTI_sampled (std::string localPart, const uint_t collector) const
 
bool writeCombinedVTU (std::string localPart, const uint_t collector) const
 
void getFilenames (std::vector< filesystem::path > &blocks, const uint_t collector) const
 
void getFilenamesSortedByLevel (std::vector< std::vector< filesystem::path > > &blocks, const uint_t collector) const
 
void writePPointData (std::ofstream &ofs) const
 
void writePCellData (std::ofstream &ofs) const
 
CellInterval getSampledCellInterval (const AABB &aabb) const
 

Private Attributes

std::string identifier_
 
std::vector< BeforeFunction > beforeFunctions_
 
const BlockStorage *const unstructuredBlockStorage_
 
const StructuredBlockStorage *const blockStorage_
 
const shared_ptr< PointDataSource > pointDataSource_
 
const shared_ptr< PolylineDataSource > polylineDataSource_
 
const std::string baseFolder_
 
const std::string executionFolder_
 
uint_t executionCounter_
 
uint_t initialWriteCallsToSkip_
 
const uint_t writeFrequency_
 
const bool continuousNumbering_
 
std::streampos pvdEnd_
 
std::vector< uint_t > allCollectors_
 
std::vector< uint_t > collectorsToWrite_
 
const bool binary_
 
const std::string format_
 
const std::string endianness_
 
const bool useMPIIO_
 
const bool outputDomainDecomposition_
 
real_t samplingDx_
 
real_t samplingDy_
 
real_t samplingDz_
 
const bool forcePVTU_
 
bool configured_
 
bool uniformGrid_
 
bool amrFileFormat_
 
bool oneFilePerProcess_
 
const uint_t ghostLayers_
 
std::vector< AABB > aabbInclusionFilters_
 
std::vector< AABB > aabbExclusionFilters_
 
std::vector< CellFilter > cellInclusionFunctions_
 
std::vector< CellFilter > cellExclusionFunctions_
 
std::vector< shared_ptr< BlockCellDataWriterInterface > > cellDataWriter_
 
bool writeNextStep_
 

Friends

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)
 creates a VTKOutput object that is supposed to output the domain decomposition
 
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, const bool amrFileFormat=false, const bool oneFilePerProcess=false)
 creates a VTKOutput object that is supposed to output block data/cell data
 
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)
 creates a VTKOutput object that is supposed to output arbitrary point data
 
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)
 creates a VTKOutput object that is supposed to output arbitrary polyline data
 

Additional Inherited Members

- Protected Member Functions inherited from walberla::NonCopyable
 NonCopyable ()=default
 
 ~NonCopyable ()=default
 

Member Typedef Documentation

◆ BeforeFunction

using walberla::vtk::VTKOutput::BeforeFunction = std::function<void ()>

◆ CellFilter

using walberla::vtk::VTKOutput::CellFilter = std::function<void (CellSet &, const IBlock &, const StructuredBlockStorage &, const uint_t)>

◆ Index

using walberla::vtk::VTKOutput::Index = int32_t
private

◆ Vertex

using walberla::vtk::VTKOutput::Vertex = std::tuple<cell_idx_t, cell_idx_t, cell_idx_t>
private

◆ VertexCoord

using walberla::vtk::VTKOutput::VertexCoord = std::tuple<real_t, real_t, real_t>
private

◆ VTKUID

using walberla::vtk::VTKOutput::VTKUID = UID<VTKGEN>
private

Constructor & Destructor Documentation

◆ ~VTKOutput()

walberla::vtk::VTKOutput::~VTKOutput ( )

◆ VTKOutput() [1/4]

walberla::vtk::VTKOutput::VTKOutput ( const BlockStorage & sbs,
const std::string & identifier,
const uint_t writeFrequency,
const std::string & baseFolder,
const std::string & executionFolder,
const bool continuousNumbering,
const bool binary,
const bool littleEndian,
const bool useMPIIO,
const uint_t initialExecutionCount = 0 )
private

creates a VTKOutput object that is supposed to output the domain decomposition

◆ VTKOutput() [2/4]

walberla::vtk::VTKOutput::VTKOutput ( const StructuredBlockStorage & sbs,
const std::string & identifier,
const uint_t writeFrequency,
const std::string & baseFolder,
const std::string & executionFolder,
const bool continuousNumbering,
const bool binary,
const bool littleEndian,
const bool useMPIIO,
const uint_t ghostLayers,
const bool forcePVTU,
const uint_t initialExecutionCount = 0,
const bool amrFileFormat = false,
const bool oneFilePerProcess = false )
private

creates a VTKOutput object that is supposed to output block data/cell data

◆ VTKOutput() [3/4]

walberla::vtk::VTKOutput::VTKOutput ( const shared_ptr< PointDataSource > & pds,
const std::string & identifier,
const uint_t writeFrequency,
const std::string & baseFolder,
const std::string & executionFolder,
const bool continuousNumbering,
const bool binary,
const bool littleEndian,
const bool useMPIIO,
const uint_t initialExecutionCount = 0 )
private

creates a VTKOutput object that is supposed to output arbitrary point data

◆ VTKOutput() [4/4]

walberla::vtk::VTKOutput::VTKOutput ( const shared_ptr< PolylineDataSource > & pds,
const std::string & identifier,
const uint_t writeFrequency,
const std::string & baseFolder,
const std::string & executionFolder,
const bool continuousNumbering,
const bool binary,
const bool littleEndian,
const bool useMPIIO,
const uint_t initialExecutionCount = 0 )
private

creates a VTKOutput object that is supposed to output arbitrary polyline data

Member Function Documentation

◆ addAABBExclusionFilter()

void walberla::vtk::VTKOutput::addAABBExclusionFilter ( const AABB & aabb)
inline

◆ addAABBInclusionFilter()

void walberla::vtk::VTKOutput::addAABBInclusionFilter ( const AABB & aabb)
inline

◆ addBeforeFunction()

void walberla::vtk::VTKOutput::addBeforeFunction ( BeforeFunction f)
inline

◆ addCellDataWriter()

void walberla::vtk::VTKOutput::addCellDataWriter ( const shared_ptr< BlockCellDataWriterInterface > & writer)
inline

◆ addCellExclusionFilter()

void walberla::vtk::VTKOutput::addCellExclusionFilter ( CellFilter f)
inline

◆ addCellInclusionFilter()

void walberla::vtk::VTKOutput::addCellInclusionFilter ( CellFilter f)
inline

◆ computeOutputPoints()

void walberla::vtk::VTKOutput::computeOutputPoints ( std::vector< Vector3< real_t > > & points,
std::vector< bool > & outputPoint,
uint_t & numberOfPoints ) const
private

◆ computeOutputPolylines()

void walberla::vtk::VTKOutput::computeOutputPolylines ( std::vector< std::vector< Vector3< real_t > > > & lines,
std::vector< std::vector< bool > > & outputPolylinePoint,
std::vector< size_t > & polylineSize,
uint_t & numberOfPolylines,
uint_t & numberOfPolylinePoints ) const
private

◆ computeVTUCells()

void walberla::vtk::VTKOutput::computeVTUCells ( const IBlock & block,
CellVector & cellsOut ) const
private

◆ forceWrite()

void walberla::vtk::VTKOutput::forceWrite ( uint_t number,
const bool immediatelyWriteCollectors = true,
const int simultaneousIOOperations = 0,
const Set< SUID > & requiredStates = Set<SUID>::emptySet(),
const Set< SUID > & incompatibleStates = Set<SUID>::emptySet() )

◆ forceWriteNextStep()

void walberla::vtk::VTKOutput::forceWriteNextStep ( )
inline

◆ getFilenames()

void walberla::vtk::VTKOutput::getFilenames ( std::vector< filesystem::path > & blocks,
const uint_t collector ) const
private

◆ getFilenamesSortedByLevel()

void walberla::vtk::VTKOutput::getFilenamesSortedByLevel ( std::vector< std::vector< filesystem::path > > & blocks,
const uint_t collector ) const
private

◆ getSampledCellInterval()

CellInterval walberla::vtk::VTKOutput::getSampledCellInterval ( const AABB & aabb) const
private

◆ getSamplingCells()

std::vector< VTKOutput::SamplingCell > walberla::vtk::VTKOutput::getSamplingCells ( const IBlock & block,
const CellVector & cells ) const
private

◆ ghostLayerNr()

uint8_t walberla::vtk::VTKOutput::ghostLayerNr ( const IBlock & block,
const cell_idx_t x,
const cell_idx_t y,
const cell_idx_t z ) const
private

◆ init()

void walberla::vtk::VTKOutput::init ( const std::string & identifier)
private

◆ setInitialWriteCallsToSkip()

void walberla::vtk::VTKOutput::setInitialWriteCallsToSkip ( const uint_t initialWriteCallsToSkip)
inline

◆ setSamplingResolution() [1/2]

void walberla::vtk::VTKOutput::setSamplingResolution ( const real_t dx,
const real_t dy,
const real_t dz )
inline

◆ setSamplingResolution() [2/2]

void walberla::vtk::VTKOutput::setSamplingResolution ( const real_t spacing)
inline

◆ write()

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

◆ writeBlockPieces()

void walberla::vtk::VTKOutput::writeBlockPieces ( std::ostream & oss,
const Set< SUID > & requiredStates,
const Set< SUID > & incompatibleStates )
private

◆ writeBlocks()

void walberla::vtk::VTKOutput::writeBlocks ( const std::string & path,
const Set< SUID > & requiredStates,
const Set< SUID > & incompatibleStates )
private

◆ writeCellData() [1/3]

void walberla::vtk::VTKOutput::writeCellData ( std::ostream & ofs,
const IBlock & block,
const CellVector & cells ) const
private

◆ writeCellData() [2/3]

void walberla::vtk::VTKOutput::writeCellData ( std::ostream & ofs,
const IBlock & block,
const std::vector< SamplingCell > & cells ) const
private

◆ writeCellData() [3/3]

void walberla::vtk::VTKOutput::writeCellData ( std::ostream & ofs,
const Set< SUID > & requiredStates,
const Set< SUID > & incompatibleStates ) const
private

◆ writeCollectors()

void walberla::vtk::VTKOutput::writeCollectors ( const bool barrier)

◆ writeCombinedVTI()

bool walberla::vtk::VTKOutput::writeCombinedVTI ( std::string localPart,
const uint_t collector ) const
private

◆ writeCombinedVTI_sampled()

bool walberla::vtk::VTKOutput::writeCombinedVTI_sampled ( std::string localPart,
const uint_t collector ) const
private

◆ writeCombinedVTU()

bool walberla::vtk::VTKOutput::writeCombinedVTU ( std::string localPart,
const uint_t collector ) const
private

◆ writeDomainDecomposition()

void walberla::vtk::VTKOutput::writeDomainDecomposition ( const std::string & path,
const Set< SUID > & requiredStates,
const Set< SUID > & incompatibleStates ) const
private

◆ writeDomainDecompositionPieces()

void walberla::vtk::VTKOutput::writeDomainDecompositionPieces ( std::ostream & ofs,
const Set< SUID > & requiredStates,
const Set< SUID > & incompatibleStates ) const
private

◆ writeParallelVTU()

void walberla::vtk::VTKOutput::writeParallelVTU ( std::ostream & ofs,
const Set< SUID > & requiredStates,
const Set< SUID > & incompatibleStates ) const
private

◆ writePCellData()

void walberla::vtk::VTKOutput::writePCellData ( std::ofstream & ofs) const
private

◆ writePointData()

void walberla::vtk::VTKOutput::writePointData ( const std::string & path)
private

◆ writePointDataPieceHelper()

void walberla::vtk::VTKOutput::writePointDataPieceHelper ( const std::vector< Vector3< real_t > > & points,
const std::vector< bool > & outputPoint,
const uint_t numberOfPoints,
std::ostream & ofs ) const
private

◆ writePointDataPieces()

void walberla::vtk::VTKOutput::writePointDataPieces ( std::ostream & ofs)
private

◆ writePolylineData()

void walberla::vtk::VTKOutput::writePolylineData ( const std::string & path)
private

◆ writePolylineDataPieceHelper()

void walberla::vtk::VTKOutput::writePolylineDataPieceHelper ( const std::vector< std::vector< Vector3< real_t > > > & lines,
const std::vector< std::vector< bool > > & outputPolylinePoint,
const std::vector< size_t > & polylineSize,
const uint_t numberOfPolylines,
const uint_t numberOfPolylinePoints,
std::ostream & ofs ) const
private

◆ writePolylineDataPieces()

void walberla::vtk::VTKOutput::writePolylineDataPieces ( std::ostream & ofs)
private

◆ writePPointData()

void walberla::vtk::VTKOutput::writePPointData ( std::ofstream & ofs) const
private

◆ writePVD()

void walberla::vtk::VTKOutput::writePVD ( )
private

◆ writePVTI()

void walberla::vtk::VTKOutput::writePVTI ( const uint_t collector) const
private

◆ writePVTI_sampled()

void walberla::vtk::VTKOutput::writePVTI_sampled ( const uint_t collector) const
private

◆ writePVTU()

void walberla::vtk::VTKOutput::writePVTU ( const uint_t collector) const
private

◆ writeVTHB()

void walberla::vtk::VTKOutput::writeVTHB ( const uint_t collector) const
private

◆ writeVTHBSeries()

void walberla::vtk::VTKOutput::writeVTHBSeries ( )
private

◆ writeVTI()

void walberla::vtk::VTKOutput::writeVTI ( std::ostream & ofs,
const IBlock & block ) const
private

◆ writeVTI_sampling()

void walberla::vtk::VTKOutput::writeVTI_sampling ( std::ostream & ofs,
const IBlock & block ) const
private

◆ writeVTIPiece()

void walberla::vtk::VTKOutput::writeVTIPiece ( std::ostream & ofs,
const IBlock & block ) const
private

◆ writeVTIPiece_sampling()

void walberla::vtk::VTKOutput::writeVTIPiece_sampling ( std::ostream & ofs,
const IBlock & block ) const
private

◆ writeVTU()

void walberla::vtk::VTKOutput::writeVTU ( std::ostream & ofs,
const IBlock & block,
const CellVector & cells ) const
private

◆ writeVTU_sampling()

void walberla::vtk::VTKOutput::writeVTU_sampling ( std::ostream & ofs,
const IBlock & block,
const CellVector & cells ) const
private

◆ writeVTUHeader()

void walberla::vtk::VTKOutput::writeVTUHeader ( std::ofstream & ofs,
const uint_t numberOfCells,
const std::vector< VertexCoord > & vc,
const std::vector< Index > & ci ) const
private

◆ writeVTUHeaderPiece()

void walberla::vtk::VTKOutput::writeVTUHeaderPiece ( std::ostream & ofs,
const uint_t numberOfCells,
const std::vector< VertexCoord > & vc,
const std::vector< Index > & ci ) const
private

◆ writeVTUPiece()

void walberla::vtk::VTKOutput::writeVTUPiece ( std::ostream & ofs,
const IBlock & block,
const CellVector & cells ) const
private

◆ writeVTUPiece_sampling()

void walberla::vtk::VTKOutput::writeVTUPiece_sampling ( std::ostream & ofs,
const IBlock & block,
const CellVector & cells ) const
private

Friends And Related Symbol Documentation

◆ createVTKOutput_BlockData

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,
const bool amrFileFormat = false,
const bool oneFilePerProcess = false )
friend

creates a VTKOutput object that is supposed to output block data/cell data

◆ createVTKOutput_DomainDecomposition

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 )
friend

creates a VTKOutput object that is supposed to output the domain decomposition

◆ createVTKOutput_PointData

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 )
friend

creates a VTKOutput object that is supposed to output arbitrary point data

◆ createVTKOutput_PolylineData

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 )
friend

creates a VTKOutput object that is supposed to output arbitrary polyline data

Member Data Documentation

◆ aabbExclusionFilters_

std::vector< AABB > walberla::vtk::VTKOutput::aabbExclusionFilters_
private

◆ aabbInclusionFilters_

std::vector< AABB > walberla::vtk::VTKOutput::aabbInclusionFilters_
private

◆ allCollectors_

std::vector< uint_t > walberla::vtk::VTKOutput::allCollectors_
private

◆ amrFileFormat_

bool walberla::vtk::VTKOutput::amrFileFormat_
private

◆ baseFolder_

const std::string walberla::vtk::VTKOutput::baseFolder_
private

◆ beforeFunctions_

std::vector< BeforeFunction > walberla::vtk::VTKOutput::beforeFunctions_
private

◆ binary_

const bool walberla::vtk::VTKOutput::binary_
private

◆ blockStorage_

const StructuredBlockStorage* const walberla::vtk::VTKOutput::blockStorage_
private

◆ cellDataWriter_

std::vector< shared_ptr< BlockCellDataWriterInterface > > walberla::vtk::VTKOutput::cellDataWriter_
private

◆ cellExclusionFunctions_

std::vector< CellFilter > walberla::vtk::VTKOutput::cellExclusionFunctions_
private

◆ cellInclusionFunctions_

std::vector< CellFilter > walberla::vtk::VTKOutput::cellInclusionFunctions_
private

◆ collectorsToWrite_

std::vector< uint_t > walberla::vtk::VTKOutput::collectorsToWrite_
private

◆ configured_

bool walberla::vtk::VTKOutput::configured_
private

◆ continuousNumbering_

const bool walberla::vtk::VTKOutput::continuousNumbering_
private

◆ endianness_

const std::string walberla::vtk::VTKOutput::endianness_
private

◆ executionCounter_

uint_t walberla::vtk::VTKOutput::executionCounter_
private

◆ executionFolder_

const std::string walberla::vtk::VTKOutput::executionFolder_
private

◆ forcePVTU_

const bool walberla::vtk::VTKOutput::forcePVTU_
private

◆ format_

const std::string walberla::vtk::VTKOutput::format_
private

◆ ghostLayers_

const uint_t walberla::vtk::VTKOutput::ghostLayers_
private

◆ identifier_

std::string walberla::vtk::VTKOutput::identifier_
private

◆ initialWriteCallsToSkip_

uint_t walberla::vtk::VTKOutput::initialWriteCallsToSkip_
private

◆ oneFilePerProcess_

bool walberla::vtk::VTKOutput::oneFilePerProcess_
private

◆ outputDomainDecomposition_

const bool walberla::vtk::VTKOutput::outputDomainDecomposition_
private

◆ pointDataSource_

const shared_ptr< PointDataSource > walberla::vtk::VTKOutput::pointDataSource_
private

◆ polylineDataSource_

const shared_ptr< PolylineDataSource > walberla::vtk::VTKOutput::polylineDataSource_
private

◆ pvdEnd_

std::streampos walberla::vtk::VTKOutput::pvdEnd_
private

◆ samplingDx_

real_t walberla::vtk::VTKOutput::samplingDx_
private

◆ samplingDy_

real_t walberla::vtk::VTKOutput::samplingDy_
private

◆ samplingDz_

real_t walberla::vtk::VTKOutput::samplingDz_
private

◆ uniformGrid_

bool walberla::vtk::VTKOutput::uniformGrid_
private

◆ unstructuredBlockStorage_

const BlockStorage* const walberla::vtk::VTKOutput::unstructuredBlockStorage_
private

◆ useMPIIO_

const bool walberla::vtk::VTKOutput::useMPIIO_
private

◆ writeFrequency_

const uint_t walberla::vtk::VTKOutput::writeFrequency_
private

◆ writeNextStep_

bool walberla::vtk::VTKOutput::writeNextStep_
private
The documentation for this class was generated from the following files: