WallVTKWriter Class Reference

#include <WallVTKWriter.h>

Inheritance diagram for WallVTKWriter:

Public Member Functions
	WallVTKWriter (WallHandler &wallHandler)
	WallVTKWriter (const WallVTKWriter &)=default
void	getVTKData (VTKContainer &vtk) const
void	writeVTK () const override
std::string	getName () const
void	setWriteWallSurfaceAreaVTK (bool writeWallSurfaceAreaVTK)
bool	getWriteWallSurfaceAreaVTK () const
Public Member Functions inherited from BaseVTKWriter< WallHandler >
	BaseVTKWriter (WallHandler &handler)
	BaseVTKWriter (const BaseVTKWriter &other)
unsigned	getFileCounter () const
void	setFileCounter (unsigned fileCounter)

Protected Member Functions
void	write (std::fstream &file, std::string name, std::function< double(BaseWall *)> f) const
void	writeVTKPoints (std::fstream &file, VTKContainer &vtk) const
void	writeVTKCells (std::fstream &file, VTKContainer &vtk) const
void	writeVTKCellData (std::fstream &file, VTKContainer &vtk) const
void	writeVTKSurfaceArea (std::fstream &file, VTKContainer &vtk) const
	Calculates and writes the surface areas of the cells to the vtu file. More...
Protected Member Functions inherited from BaseVTKWriter< WallHandler >
std::fstream	makeVTKFileWithHeader () const
void	writeVTKFooterAndClose (std::fstream &file) const

Protected Attributes
bool	writeWallSurfaceAreaVTK_ { false }
Protected Attributes inherited from BaseVTKWriter< WallHandler >
WallHandler &	handler_
	particle handler from which the particles should be written More...
unsigned int	fileCounter

Constructor & Destructor Documentation

WallVTKWriter() [1/2]

WallVTKWriter::WallVTKWriter ( WallHandler &  wallHandler )

inlineexplicit

Non-default constructor; sets the handler and fileCounter

                                                     : BaseVTKWriter(wallHandler)
    {}

WallVTKWriter() [2/2]

WallVTKWriter::WallVTKWriter ( const WallVTKWriter &  )

default

Default copy constructor

Member Function Documentation

getName()

std::string WallVTKWriter::getName ( ) const

inline

the name of the class in the restart file

    { return "WallVTKWriter"; }

getVTKData()

void WallVTKWriter::getVTKData

(

VTKContainer &

vtk

)

const

extracts vtk data from the wallHandler and stores it in a VTKContainer

{
    // set capacity of points and cells based on the previous time step
    // the initial values are based on the minimum, which is one triangle per wall
    static unsigned int capacityPoints = 3*handler_.getSize();
    static unsigned int capacityTriangleStrips = handler_.getSize();
    vtk.triangleStrips.reserve(capacityPoints);
    vtk.points.reserve(capacityTriangleStrips);
 
    //add all wall data to the point and cell arrays
    for (const auto& w: handler_)
    {
        w->renderWall(vtk);
    }
 
//    logger(INFO, "size (capacity) of points: % (%), cells: % (%)", vtk.points.size(), capacityPoints, vtk.triangleStrips.size(), capacityTriangleStrips);
 
    //store from previous time step
    capacityPoints = vtk.points.size();
    capacityTriangleStrips = vtk.triangleStrips.size();
}

References BaseHandler< T >::getSize(), BaseVTKWriter< WallHandler >::handler_, VTKContainer::points, and VTKContainer::triangleStrips.

Referenced by writeVTK().

getWriteWallSurfaceAreaVTK()

bool WallVTKWriter::getWriteWallSurfaceAreaVTK

(

)

const

{
    return writeWallSurfaceAreaVTK_;
}

References writeWallSurfaceAreaVTK_.

Referenced by WallHandler::getWriteWallSurfaceAreaVTK().

setWriteWallSurfaceAreaVTK()

void WallVTKWriter::setWriteWallSurfaceAreaVTK

(

bool

writeWallSurfaceAreaVTK

)

{
    writeWallSurfaceAreaVTK_ = writeWallSurfaceAreaVTK;
}

References writeWallSurfaceAreaVTK_.

Referenced by WallHandler::setWriteWallSurfaceAreaVTK().

write()

void WallVTKWriter::write ( std::fstream &  file, std::string  name, std::function< double(BaseWall *)>  f  ) const

protected

{
    file << "  <DataArray type=\"Float32\" Name=\""+ name + "\" format=\"ascii\">\n";
    for (const auto& p: handler_)
    {
        file << '\t' << f(p) << '\n';
    }
    file << "  </DataArray>\n";
}

References BaseVTKWriter< WallHandler >::handler_, and units::name.

writeVTK()

void WallVTKWriter::writeVTK ( ) const

overridevirtual

writes a vtk file

Implements BaseVTKWriter< WallHandler >.

{
    if (PROCESSOR_ID!=0) return;
    std::fstream file = makeVTKFileWithHeader();
    
    VTKContainer vtk;
    getVTKData(vtk);
    file << "<Piece NumberOfPoints=\"" << vtk.points.size()
         << "\" NumberOfCells=\"" << vtk.triangleStrips.size()
         << "\">\n"
         << "<Points>\n";
    writeVTKPoints(file, vtk);
    file << "</Points>\n";
    // this cannot be done right now since we can't math Points/Cells and Walls
    //    file << "<PointData  Vectors=\"vector\">\n";
    //    write(file,"indSpecies",[](BaseWall* w){return w->getIndSpecies();});
    //    file << "</PointData>\n";
    file << "<Cells>\n";
    writeVTKCells(file, vtk);
    file << "</Cells>\n";
    file << "<CellData>\n";
    writeVTKCellData(file, vtk);
    file << "</CellData>\n"
         << "</Piece>\n"
         << "</UnstructuredGrid>\n"
         << "</VTKFile>\n";
    file.close();
}

References getVTKData(), BaseVTKWriter< WallHandler >::makeVTKFileWithHeader(), VTKContainer::points, PROCESSOR_ID, VTKContainer::triangleStrips, writeVTKCellData(), writeVTKCells(), and writeVTKPoints().

Referenced by DPMBase::writeVTKFiles().

writeVTKCellData()

void WallVTKWriter::writeVTKCellData ( std::fstream &  file, VTKContainer &  vtk  ) const

protected

writes the cell data to the vtu file (i.e. surface area)

                                                                              {
    if(writeWallSurfaceAreaVTK_){
        writeVTKSurfaceArea(file, vtk);
    }
}

References writeVTKSurfaceArea(), and writeWallSurfaceAreaVTK_.

Referenced by writeVTK().

writeVTKCells()

void WallVTKWriter::writeVTKCells ( std::fstream &  file, VTKContainer &  vtk  ) const

protected

writes the cell data to the vtu file (i.e. the faces of the mesh displayed in paraview)

{
    file << "  <DataArray type=\"Int32\" Name=\"connectivity\" format=\"ascii\">\n";
    for (const std::vector<double>& c : vtk.triangleStrips)
    {
        file << '\t';
        for (const double& i : c) file << i << ' ';
        file << '\n';
    }
    file << "  </DataArray>\n";
    file << "  <DataArray type=\"Int32\" Name=\"offsets\" format=\"ascii\">\n";
    unsigned count = 0;
    for (const std::vector<double>& c : vtk.triangleStrips)
    {
        count += c.size();
        file << '\t' << count << '\n';
    }
    file << "  </DataArray>\n";
    file << "  <DataArray type=\"UInt8\"  Name=\"types\" format=\"ascii\">\n";
    for (const std::vector<double>& c : vtk.triangleStrips)
    {
        if (c.front() == c.back())
        {
            //polygon
            file << "\t7\n";
        }
        else
        {
            //triangle strips
            file << "\t6\n";
        }
    }
    file << "  </DataArray>\n";
}

References constants::i, and VTKContainer::triangleStrips.

Referenced by writeVTK().

writeVTKPoints()

void WallVTKWriter::writeVTKPoints ( std::fstream &  file, VTKContainer &  vtk  ) const

protected

writes the point data to the vtu file (i.e. the vertices of the mesh displayed in paraview)

{
    file << "  <DataArray type=\"Float32\" Name=\"Position\" NumberOfComponents=\"3\" format=\"ascii\">\n";
    for (const Vec3D& p : vtk.points)
    {
        file << '\t' << p << '\n';
    }
    file << "  </DataArray>\n";
}

References VTKContainer::points.

Referenced by writeVTK().

writeVTKSurfaceArea()

void WallVTKWriter::writeVTKSurfaceArea ( std::fstream &  file, VTKContainer &  vtk  ) const

protected

Calculates and writes the surface areas of the cells to the vtu file.

The calculation is based on the rendered VTKContainer and it takes time. This functionality is diasabled by default and can be enabled using WallHandler::setWriteWallSurfaceAreaVTK().

Parameters

[in]	file	Output filestream
[in]	vtk	Rendered VTKContainer

Todo:

gmb This only needs to be calculated if the mesh changes.

Todo:

gmb Check if it always true.

                                                                                 {
    file << "  <DataArray type=\"Float32\"  Name=\"SurfaceArea\" format=\"ascii\">\n";
    for (const std::vector<double>& strip : vtk.triangleStrips){
        double area = 0;
        for(size_t i = 1; i < strip.size() - 1; i++){
            size_t i1 = static_cast<size_t>(strip.at(i-1));
            size_t i2 = static_cast<size_t>(strip.at(i));
            size_t i3 = static_cast<size_t>(strip.at(i+1));
 
            // strip is a polygon
            if(strip.front() == strip.back() && i == strip.size() - 2){
                break;
            }
 
            Vec3D &p1 = vtk.points.at(i1);
            Vec3D &p2 = vtk.points.at(i2);
            Vec3D &p3 = vtk.points.at(i3);
 
            Vec3D p12 = p2 - p1;
            Vec3D p13 = p3 - p1;
 
            double triangleArea = 0.5 * Vec3D::cross(p12, p13).getLength();
            area += triangleArea;
        }
        file << '\t' << area << '\n';
    }
 
    file << "  </DataArray>\n";
}

References Vec3D::cross(), Vec3D::getLength(), constants::i, VTKContainer::points, and VTKContainer::triangleStrips.

Referenced by writeVTKCellData().

Member Data Documentation

writeWallSurfaceAreaVTK_

bool WallVTKWriter::writeWallSurfaceAreaVTK_ { false }

protected

Referenced by getWriteWallSurfaceAreaVTK(), setWriteWallSurfaceAreaVTK(), and writeVTKCellData().

---

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

• WallVTKWriter.h
• WallVTKWriter.cc