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
void	setCGWidth (double cgWidth)
Public Member Functions inherited from BaseVTKWriter< WallHandler >
	BaseVTKWriter (WallHandler &handler)
	BaseVTKWriter (const BaseVTKWriter &other)
unsigned	getFileCounter () const
void	setFileCounter (unsigned fileCounter)
void	setOutputDirectory (const std::string &dir)
const std::string &	getOutputDirectory () const
std::string	getFileName () const

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	writeVTKPointData (std::fstream &file, VTKContainer &vtk) const
void	writeCGFields (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 }
double	cgWidth_ = 0.0
Protected Attributes inherited from BaseVTKWriter< WallHandler >
WallHandler &	handler_
	particle handler from which the particles should be written More...
unsigned int	fileCounter
std::string	outputDirectory_

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, VTKContainer::triangleStrips, and w.

Referenced by writeVTK().

getWriteWallSurfaceAreaVTK()

bool WallVTKWriter::getWriteWallSurfaceAreaVTK

(

)

const

{
    return writeWallSurfaceAreaVTK_;
}

References writeWallSurfaceAreaVTK_.

Referenced by WallHandler::getWriteWallSurfaceAreaVTK().

setCGWidth()

void WallVTKWriter::setCGWidth ( double  cgWidth )

inline

                                    {
        cgWidth_ = std::max(0.0,cgWidth);
        if (cgWidth==0.0) {
            logger(INFO, "CG Width set to zero; no CG data is written to the VTU files");
        }
    }

References cgWidth_, INFO, logger, and max.

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 f(), BaseVTKWriter< WallHandler >::handler_, plotDoE::name, and p.

writeCGFields()

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

protected

writes data from coarse-graining to the vtu file.

                                                                           {
    logger.assert_debug(handler_.getDPMBase(),"DPMBase not found");
    ParticleHandler& particleHandler = handler_.getDPMBase()->particleHandler;
    file << "  <DataArray type=\"Float32\"  Name=\"NearbyMass\" format=\"ascii\">\n";
    for (const auto& point : vtk.points){
        double mass = 0;
        for (auto& particle : particleHandler) {
            //implement a simple Heaviside function
            if (Vec3D::getDistance(particle->getPosition(),point)<cgWidth_) {
                mass += particle->getMass();
            }
        }
        file << '\t' << mass << '\n';
    }
    file << "  </DataArray>\n";
    file << "  <DataArray type=\"Float32\"  Name=\"NearbyParticles\" format=\"ascii\">\n";
    for (const auto& point : vtk.points){
        double number = 0;
        for (auto& particle : particleHandler) {
            //implement a simple Heaviside function
            if (Vec3D::getDistance(particle->getPosition(),point)<cgWidth_) {
                number ++;
            }
        }
        file << '\t' << number << '\n';
    }
    file << "  </DataArray>\n";
}

References cgWidth_, Vec3D::getDistance(), BaseHandler< T >::getDPMBase(), BaseVTKWriter< WallHandler >::handler_, logger, DPMBase::particleHandler, and VTKContainer::points.

Referenced by writeVTKPointData().

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";
    file << "<PointData>\n";
    writeVTKPointData(file, vtk);
    file << "</PointData>\n";
    file << "</Piece>\n"
         << "</UnstructuredGrid>\n"
         << "</VTKFile>\n";
    file.close();
}

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

Referenced by DPMBase::writeVTKFiles().

writeVTKCellData()

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

protected

writes 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 calibrate::c, i, and VTKContainer::triangleStrips.

Referenced by writeVTK().

writeVTKPointData()

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

protected

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

                                                                               {
    if (cgWidth_>0) {
        writeCGFields(file, vtk);
    }
}

References cgWidth_, and writeCGFields().

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 p, and 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(), i, p1, VTKContainer::points, and VTKContainer::triangleStrips.

Referenced by writeVTKCellData().

Member Data Documentation

cgWidth_

double WallVTKWriter::cgWidth_ = 0.0

protected

Referenced by setCGWidth(), writeCGFields(), and writeVTKPointData().

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