WallHandler.cc

Go to the documentation of this file.

//Copyright (c) 2013-2014, The MercuryDPM Developers Team. All rights reserved.
//For the list of developers, see <http://www.MercuryDPM.org/Team>.
//
//Redistribution and use in source and binary forms, with or without
//modification, are permitted provided that the following conditions are met:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name MercuryDPM nor the
//    names of its contributors may be used to endorse or promote products
//    derived from this software without specific prior written permission.
//
//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
//ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
//WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
//DISCLAIMED. IN NO EVENT SHALL THE MERCURYDPM DEVELOPERS TEAM BE LIABLE FOR ANY
//DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
//(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
//ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
//(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


#include <Math/Helpers.h>
#include "WallHandler.h"
#include "Walls/BaseWall.h"
#include "Walls/CylindricalWall.h"
#include "Walls/AxisymmetricIntersectionOfWalls.h"
#include "Walls/IntersectionOfWalls.h"
#include "Walls/InfiniteWall.h"
#include "Walls/InfiniteWallWithHole.h"
#include "Walls/Screw.h"
#include "Walls/Coil.h"
#include "DPMBase.h"

WallHandler::WallHandler()
{
    clear();
    logger(DEBUG, "WallHandler::WallHandler() finished");
}

WallHandler::WallHandler(const WallHandler& WH)
{
    clear();
    setDPMBase(WH.getDPMBase());
    copyContentsFromOtherHandler(WH);
    logger(DEBUG, "WallHandler::WallHandler(const WallHandler &WH) finished");
}

WallHandler WallHandler::operator =(const WallHandler& rhs)
{
    if(this != &rhs)
    {
        clear();
        setDPMBase(rhs.getDPMBase());
        copyContentsFromOtherHandler(rhs);
    }
    logger(DEBUG, "WallHandler::operator = (const WallHandler& rhs) finished");
    return *this;
}

WallHandler::~WallHandler()
{
    logger(DEBUG, "WallHandler::~WallHandler() finished");
}

void WallHandler::addObject(BaseWall* W)
{
    if (W->getSpecies() == nullptr)
    {
        logger(WARN, "WARNING: The wall with ID % that is added in WallHandler::addObject "
                "does not have a species yet. Please make sure that you have "
                "set the species somewhere in the driver code.", W->getId());
    }
    //Puts the wall in the Wall list
    BaseHandler<BaseWall>::addObject(W);
    //set the particleHandler pointer
    W->setHandler(this);
}

void WallHandler::readObject(std::istream& is)
{
    std::string type;
    is >> type;

    logger.log(Log::DEBUG, "WallHandler::readObject(is): reading type %.", type);
    const SpeciesHandler& sH = getDPMBase()->speciesHandler;

    if (type == "CylindricalWall")
    {
        CylindricalWall wall;
        is >> wall;
        wall.setSpecies(sH.getObject(wall.getIndSpecies()));
        copyAndAddObject(wall);
    }
    else if (type == "AxisymmetricIntersectionOfWalls")
    {
        AxisymmetricIntersectionOfWalls wall;
        is >> wall;
        wall.setSpecies(sH.getObject(wall.getIndSpecies()));
        copyAndAddObject(wall);
    }
    else if (type == "IntersectionOfWalls")
    {
        IntersectionOfWalls wall;
        is >> wall;
        wall.setSpecies(sH.getObject(wall.getIndSpecies()));
        copyAndAddObject(wall);
    }
    else if (type == "InfiniteWall")
    {
        InfiniteWall wall;
        is >> wall;
        wall.setSpecies(sH.getObject(wall.getIndSpecies()));
        copyAndAddObject(wall);
    }
    else if (type == "InfiniteWallWithHole")
    {
        InfiniteWallWithHole wall;
        is >> wall;
        wall.setSpecies(sH.getObject(wall.getIndSpecies()));
        copyAndAddObject(wall);
    }
    else if (type == "Screw")
    {
        Screw wall;
        is >> wall;
        wall.setSpecies(sH.getObject(wall.getIndSpecies()));
        copyAndAddObject(wall);
    }
    else if (type == "Coil")
    {
        Coil wall;
        is >> wall;
        wall.setSpecies(sH.getObject(wall.getIndSpecies()));
        copyAndAddObject(wall);
    }
    //for backward compatibility (before svnversion ~2360)
    else if (type == "numFiniteWalls")
    {
        readOldObject(is);
    }
    else if (type == "TriolietScrew"||type == "TriolietBaseScrew"||type=="RestrictedWall") {
        logger(WARN, "Wall type: % cannot be restarted and is ignored", type);
        InfiniteWall wall;
        wall.setSpecies(sH.getObject(0));
        copyAndAddObject(wall);
    }
    else if (!getDPMBase()->readUserDefinedWall(type,is))
    {
        logger(ERROR, "Wall type: % not understood in restart file", type);
    }
}

void WallHandler::readOldObject(std::istream& is)
{
    //read in next line
    std::stringstream line(std::stringstream::in | std::stringstream::out);
    helpers::getLineFromStringStream(is, line);
    logger(VERBOSE, line.str());

    std::string dummy;
    unsigned int numWalls;
    Mdouble position;
    Vec3D normal;
    line >> numWalls;

    if (numWalls == 0)
    {
        InfiniteWall wall;
        wall.setSpecies(getDPMBase()->speciesHandler.getObject(0));        
        line >> dummy >> normal >> dummy >> position;
        wall.set(normal, position*normal);
        copyAndAddObject(wall);
    }
    else
    {
        IntersectionOfWalls wall;
        wall.setSpecies(getDPMBase()->speciesHandler.getObject(0));        
        for (unsigned int i = 0; i < numWalls; ++i)
        {
            line >> dummy >> normal >> dummy >> position;
            wall.addObject(normal, position*normal);
        }
        copyAndAddObject(wall);
    }
}

std::string WallHandler::getName() const
{
    return "WallHandler";
}

void WallHandler::writeVTK() const
{
    VTKContainer vtk;
    
    //set capacity of points and cells based on the previous time step
    static unsigned int capacityPoints = 0;
    static unsigned int capacityTriangleStrips = 0;

    vtk.triangleStrips.reserve(capacityPoints);
    vtk.points.reserve(capacityTriangleStrips);
    
    //add all wall data to the point and cell arrays
    for (const auto& w: *this)
    {
        w->writeVTK(vtk);
        logger(DEBUG, "points: %, cells: ", vtk.points.size(), vtk.triangleStrips.size());
    }    

    //write
    writeVTKFile(vtk);
}

void WallHandler::writeVTKFile (const VTKContainer vtk) const
{
//    logger(INFO, "%, writing vtk file, points: %, cells: %",
//           getDPMBase()->getTime(), vtk.points.size(), vtk.triangleStrips.size());
    static unsigned fileCounter = 0;
    const std::string fileName = getDPMBase()->getName() + "Wall_" +
            std::to_string(fileCounter++) + ".vtu";
    logger(INFO, "writing % (t=%, N=%)", fileName, getDPMBase()->getTime(), this->getNumberOfObjects());

    std::fstream file;
    file.open(fileName.c_str(), std::ios::out);
    if (file.fail())
    {
        logger(WARN,  "Error in writeToFile: file % could not be opened", fileName);
    }
    file << "<?xml version=\"1.0\"?>\n\n";
    file << "<VTKFile type=\"UnstructuredGrid\" version=\"0.1\" byte_order=\"LittleEndian\">\n";
    file << "<UnstructuredGrid>\n";
    file << "<Piece NumberOfPoints=\"" << vtk.points.size() << "\" NumberOfCells=\"" << vtk.triangleStrips.size() << "\">\n";
    file << "<Points>\n";
    file << "  <DataArray type=\"Float32\" Name=\"Position\" NumberOfComponents=\"3\" format=\"ascii\">\n";
    for (const Vec3D& p : vtk.points)
    {
        file << '\t' << p << '\n';
    }
    file << "  </DataArray>\n";
    file << "</Points>\n";
    file << "<Cells>\n";
    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";
    file << "</Cells>\n";
    file << "</Piece>\n";
    file << "</UnstructuredGrid>\n";
    file << "</VTKFile>\n";
    file.close();
}

void WallHandler::writeVTKBoundingBox() const
{
    const std::string fileName = getDPMBase()->getName() + "BoundingBox.vtu";
    logger(INFO, "% writing vtk file for bounding box: %",
           getDPMBase()->getTime(), fileName);
    std::fstream file;
    file.open(fileName.c_str(), std::ios::out);
    if (file.fail())
    {
        logger(WARN, "Error in writeToFile: file could not be opened");
    }
    file << "<?xml version=\"1.0\"?>\n\n";
    file << "<VTKFile type=\"UnstructuredGrid\" version=\"0.1\" byte_order=\"LittleEndian\">\n";
    file << "<UnstructuredGrid>\n";
    file << "<Piece NumberOfPoints=\"8\" NumberOfCells=\"1\">\n";
    file << "<Points>\n";
    file << "  <DataArray type=\"Float32\" Name=\"Position\" NumberOfComponents=\"3\" format=\"ascii\">\n";
    Vec3D P[2] = {getDPMBase()->getMax(), getDPMBase()->getMin()};
    for (unsigned i = 0; i < 2; i++)
    {
        for (unsigned j = 0; j < 2; j++)
        {
            for (unsigned k = 0; k < 2; k++)
            {
                Vec3D p = Vec3D(P[i].X, P[j].Y, P[k].Z);
                file << '\t' << p << '\n';
            }
        }
    }
    file << "  </DataArray>\n";
    file << "</Points>\n";
    file << "<Cells>\n";
    file <<
    "  <DataArray type=\"Int32\" Name=\"connectivity\" format=\"ascii\">\n";
    file << "\t0 1 3 2 0 4 5 1 5 7 3 7 6 2 6 4\n";
    file << "  </DataArray>\n";
    file << "  <DataArray type=\"Int32\" Name=\"offsets\" format=\"ascii\">\n";
    file <<
    "\t16\n"; //offset into the connectivity array for the end of each cell.
    file << "  </DataArray>\n";
    file << "  <DataArray type=\"UInt8\"  Name=\"types\" format=\"ascii\">\n";
    file << "\t4\n";
    file << "  </DataArray>\n";
    file << "</Cells>\n";
    file << "</Piece>\n";
    file << "</UnstructuredGrid>\n";
    file << "</VTKFile>\n";
    file.close();
}