VTKWriter_grids.hpp

/*
 * VTKWriter_grids.hpp
 *
 *  Created on: May 5, 2015
 *      Author: Pietro Incardona
 */
 
#ifndef VTKWRITER_GRIDS_HPP_
#define VTKWRITER_GRIDS_HPP_
 
#include <boost/mpl/pair.hpp>
#include "VTKWriter_grids_util.hpp"
#include "is_vtk_writable.hpp"
 
template <typename Grid, typename St>
class ele_g
{
public:
 
    typedef Grid value_type;
 
    ele_g(const Grid & g, const Point<Grid::dims,St> & offset, const Point<Grid::dims,St> & spacing, const Box<Grid::dims,St> & dom)
    :g(g),offset(offset),spacing(spacing),dom(dom)
    {}
 
    std::string dataset;
    const Grid & g;
    Point<Grid::dims,St> offset;
    // spacing of the grid
    Point<Grid::dims,St> spacing;
    // Part of the grid that is real domain
    Box<Grid::dims,size_t> dom;
};
 
 
 
template<typename ele_g, typename St>
struct prop_out_g
{
    std::string & v_out;
 
    const openfpm::vector_std< ele_g > & vg;
 
    file_type ft;
 
    const openfpm::vector<std::string> & prop_names;
 
    prop_out_g(std::string & v_out, const openfpm::vector_std< ele_g > & vg, const openfpm::vector<std::string> & prop_names ,file_type ft)
    :v_out(v_out),vg(vg),ft(ft),prop_names(prop_names)
    {};
 
    template<typename T>
    void operator()(T& t) const
    {
        typedef typename boost::mpl::at<typename ele_g::value_type::value_type::type,boost::mpl::int_<T::value>>::type ptype;
        typedef typename std::remove_all_extents<ptype>::type base_ptype;
 
        meta_prop<boost::mpl::int_<T::value> ,ele_g,St, ptype, is_vtk_writable<base_ptype>::value > m(vg,v_out,prop_names,ft);
    }
 
    void lastProp()
    {
        // Create point data properties
        v_out += "SCALARS domain float\n";
 
        // Default lookup table
        v_out += "LOOKUP_TABLE default\n";
 
        // Produce point data
        for (size_t k = 0 ; k < vg.size() ; k++)
        {
            auto it = vg.get(k).g.getIterator();
 
            // if there is the next element
            while (it.isNext())
            {
                if (ft == file_type::ASCII)
                {
                    if (vg.get(k).dom.isInside(it.get().toPoint()) == true)
                    {
                        float flag = 1.0;
                        flag += vg.get(k).g.getFlag(it.get()) * 2;
                        v_out += std::to_string(flag) + "\n";
                    }
                    else
                    {
                        float flag = 0.0;
                        flag += vg.get(k).g.getFlag(it.get()) * 2;
                        v_out += std::to_string(flag) + "\n";
                    }
                }
                else
                {
                    if (vg.get(k).dom.isInside(it.get().toPoint()) == true)
                    {
                        float flag = 1.0;
                        flag = swap_endian_lt(flag);
                        v_out.append((const char *)&flag,sizeof(flag));
                    }
                    else
                    {
                        float flag = 0.0;
                        flag = swap_endian_lt(flag);
                        v_out.append((const char *)&flag,sizeof(flag));
                    }
                }
 
                // increment the iterator and counter
                ++it;
            }
        }
    }
};
 
template <typename pair>
class VTKWriter<pair,VECTOR_GRIDS>
{
 
    openfpm::vector< ele_g<typename pair::first,typename pair::second> > vg;
    size_t get_total()
    {
        size_t tot = 0;
 
        for (size_t i = 0 ; i < vg.size() ; i++)
        {
            tot += vg.get(i).g.size();
        }
        return tot;
    }
 
    std::string get_vertex_properties_list()
    {
        std::string v_out;
 
        // write the number of vertex
        v_out += "VERTICES " + std::to_string(get_total()) + " " + std::to_string(get_total() * 2) + "\n";
 
        // return the vertex properties string
        return v_out;
    }
 
    std::string get_point_properties_list()
    {
        std::string v_out;
 
        // write the number of vertex
        if (std::is_same<typename pair::second,float>::value == true)
        {v_out += "POINTS " + std::to_string(get_total()) + " float" + "\n";}
        else
        {v_out += "POINTS " + std::to_string(get_total()) + " double" + "\n";}
 
        // return the vertex properties string
        return v_out;
    }
 
    std::string get_point_list(file_type ft)
    {
        std::stringstream v_out;
 
        if (std::is_same<typename pair::second,float>::value == true)
        {v_out << std::setprecision(7);}
        else
        {v_out << std::setprecision(16);}
 
 
        for (size_t i = 0 ; i < vg.size() ; i++)
        {
            auto it = vg.get(i).g.getIterator();
 
            Box<pair::first::dims,typename pair::second> dom;
 
            // if there is the next element
            while (it.isNext())
            {
                Point<pair::first::dims,typename pair::second> p;
                p = it.get().toPoint();
                p = pmul(p,vg.get(i).spacing) + vg.get(i).offset;
 
                output_point<pair::first::dims,typename pair::second>(p,v_out,ft);
 
                // increment the iterator and counter
                ++it;
            }
        }
 
        // return the vertex list
        return v_out.str();
    }
 
    std::string get_vertex_list(file_type ft)
    {
        std::string v_out;
 
        size_t k = 0;
 
        for (size_t i = 0 ; i < vg.size() ; i++)
        {
            auto it = vg.get(i).g.getIterator();
 
            while (it.isNext())
            {
                output_vertex(k,v_out,ft);
 
                ++k;
                ++it;
            }
        }
        // return the vertex list
        return v_out;
    }
 
    std::string get_point_data_header()
    {
        std::string v_out;
 
        v_out += "POINT_DATA " + std::to_string(get_total()) + "\n";
 
        return v_out;
    }
 
public:
 
    VTKWriter()
    {}
 
    void add(const typename pair::first & g,
             const Point<pair::first::dims,typename pair::second> & offset,
             const Point<pair::first::dims,typename pair::second> & spacing,
             const Box<pair::first::dims,typename pair::second> & dom)
    {
        ele_g<typename pair::first,typename pair::second> t(g,offset,spacing,dom);
 
        vg.add(t);
    }
 
    template<int prp = -1> bool write(std::string file,
                                      const openfpm::vector<std::string> & prop_names,
                                      std::string f_name = "grids",
                                      file_type ft = file_type::ASCII)
    {
        // Header for the vtk
        std::string vtk_header;
        // Point list of the VTK
        std::string point_list;
        // Vertex list of the VTK
        std::string vertex_list;
        // Graph header
        std::string vtk_binary_or_ascii;
        // vertex properties header
        std::string point_prop_header;
        // edge properties header
        std::string vertex_prop_header;
        // Data point header
        std::string point_data_header;
        // Data point
        std::string point_data;
 
        // VTK header
        vtk_header = "# vtk DataFile Version 3.0\n"
                     + f_name + "\n";
 
        // Choose if binary or ASCII
        if (ft == file_type::ASCII)
        {vtk_header += "ASCII\n";}
        else
        {vtk_header += "BINARY\n";}
 
        // Data type for graph is DATASET POLYDATA
        vtk_header += "DATASET POLYDATA\n";
 
        // point properties header
        point_prop_header = get_point_properties_list();
 
        // Get point list
        point_list = get_point_list(ft);
 
        // vertex properties header
        vertex_prop_header = get_vertex_properties_list();
 
        // Get vertex list
        vertex_list = get_vertex_list(ft);
 
        // Get the point data header
        point_data_header = get_point_data_header();
 
        // For each property in the vertex type produce a point data
 
        prop_out_g< ele_g<typename pair::first,typename pair::second>, typename pair::second > pp(point_data, vg, prop_names, ft);
 
        if (prp == -1)
        {boost::mpl::for_each< boost::mpl::range_c<int,0, pair::first::value_type::max_prop> >(pp);}
        else
        {boost::mpl::for_each< boost::mpl::range_c<int,prp, prp> >(pp);}
 
        // Add the last property
        pp.lastProp();
 
 
        // write the file
        std::ofstream ofs(file);
 
        // Check if the file is open
        if (ofs.is_open() == false)
        {std::cerr << "Error cannot create the VTK file: " + file + "\n";}
 
        ofs << vtk_header << point_prop_header << point_list <<
                vertex_prop_header << vertex_list << point_data_header << point_data;
 
        // Close the file
 
        ofs.close();
 
        // Completed succefully
        return true;
    }
};
 
 
#endif /* VTKWRITER_GRAPH_HPP_ */