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_ */