DistGraphFactory.hpp

/*
 * DistGraphFactory.hpp
 *
 *  Created on: Dec 03, 2015
 *      Author: Antonio Leo
 */

#ifndef DISTGRAPHFACTORYOLD_HPP_
#define DISTGRAPHFACTORYOLD_HPP_

#include "VCluster/VCluster.hpp"
#include "Vector/map_vector.hpp"
#include "Graph/map_graph.hpp"
#include "Grid/grid_sm.hpp"
#include "Space/Shape/Box.hpp"
#include "Space/Shape/HyperCube.hpp"
#include "parmetis.h"

template<unsigned int dim, typename dT, typename G_v, typename v, int impl>
class fill_prop_v
{
    const dT (&szd)[dim];

    grid_key_dx<dim> & gk;

    G_v & g_v;

    const grid_sm<dim, void> & gs;

public:

    fill_prop_v(G_v & g_v, const dT (&szd)[dim], grid_key_dx<dim> & gk, const grid_sm<dim, void> & gs) :
            szd(szd), gk(gk), g_v(g_v), gs(gs)
    {
    }

    template<typename T>
    void operator()(T& t) const
    {
        typedef typename boost::fusion::result_of::at<v, boost::mpl::int_<T::value>>::type t_val;

        g_v.template get<t_val::value>() = gk.get(T::value) * szd[T::value];
    }
};


template<unsigned int dim, typename dT, typename G_v, typename v>
class fill_prop_v<dim, dT, G_v, v, 0>
{

public:

    fill_prop_v(G_v & g_v, const dT (&szd)[dim], grid_key_dx<dim> & gk, const grid_sm<dim, void> & gs)
    {
    }

    template<typename T>
    void operator()(T& t) const
    {
    }
};

template<unsigned int dim, typename dT, typename G_v, typename v>
class fill_prop_v<dim, dT, G_v, v, 2>
{

    const dT (&szd)[dim];

    grid_key_dx<dim> & gk;

    G_v & g_v;

    const grid_sm<dim, void> & gs;

public:

    fill_prop_v(G_v & g_v, const dT (&szd)[dim], grid_key_dx<dim> & gk, const grid_sm<dim, void> & gs)
    :szd(szd), gk(gk), g_v(g_v), gs(gs)
    {
    }

    template<typename T>
    void operator()(T& t) const
    {
        typedef typename boost::fusion::result_of::at<v, boost::mpl::int_<0>>::type t_val;
        typedef typename boost::mpl::at<typename G_v::T_type::type,t_val>::type s_type;

        for (size_t i = 0 ; i < std::extent<s_type>::value ; i++)
            g_v.template get<t_val::value>()[i] = 0.0;

        for (size_t i = 0 ; i < dim ; i++)
            g_v.template get<t_val::value>()[i] = gk.get(i) * static_cast<float>(szd[i]);
    }
};

template<int i, typename p, typename Graph, int ... pos>
struct fill_prop_v_by_type
{

    typedef typename boost::mpl::at<p, boost::mpl::int_<0>>::type v_element;
    typedef typename boost::mpl::at<typename Graph::V_type::type, v_element>::type pos_prop_type;

    enum
    {
        value = ((sizeof...(pos) != 0) * (std::is_array<pos_prop_type>::value + 1))
    };

};

template<typename p, typename Graph, int ... pos>
struct fill_prop_v_by_type<0, p, Graph, pos...>
{
    enum
    {
        value = 0
    };

};

template<unsigned int dim, typename Graph, int se, typename T, unsigned int dim_c, int ... pos>
class DistGraph_constr_impl
{
public:
    static Graph construct(const size_t (&sz)[dim], Box<dim, T> dom)
    {
        Vcluster &v_cl = create_vcluster();

        // Calculate the size of the hyper-cubes on each dimension
        T szd[dim];

        for (size_t i = 0; i < dim; i++)
        {
            szd[i] = (dom.getHigh(i) - dom.getLow(i)) / sz[i];
        }


        HyperCube<dim> hc;

        // Construct a grid info

        grid_sm<dim, void> g(sz);

        size_t p_id = v_cl.getProcessUnitID();

        size_t Np = v_cl.getProcessingUnits();

        size_t mod_v = g.size() % Np;
        size_t div_v = g.size() / Np;

        openfpm::vector<idx_t> vtxdist(v_cl.getProcessingUnits() + 1);

        for (int i = 0; i <= Np; i++)
        {
            if (i < mod_v)
                vtxdist.get(i) = (div_v + 1) * (i);
            else
                vtxdist.get(i) = (div_v) * (i) + mod_v;
        }

        size_t gp_size = vtxdist.get(p_id + 1) - vtxdist.get(p_id);

        Graph gp(gp_size);

        gp.initDistributionVector(vtxdist);

        /******************
         *
         * Create the edges and fill spatial
         * information properties
         *
         ******************/

        grid_key_dx_iterator<dim> k_it(g);

        size_t local_it = 0;


        while (k_it.isNext())
        {
            size_t v_id = g.LinId(k_it.get());

            if (v_id < vtxdist.get(p_id + 1) && v_id >= vtxdist.get(p_id))
            {

                grid_key_dx<dim> key = k_it.get();

                // Vertex object

                auto obj = gp.vertex(local_it);

                typedef typename to_boost_vmpl<pos...>::type p;

                // vertex spatial properties functor

                fill_prop_v<dim, T, decltype(gp.vertex(local_it)), typename to_boost_vmpl<pos...>::type, fill_prop_v_by_type<sizeof...(pos), p, Graph, pos...>::value> flp(obj, szd, key, g);

                // fill properties

                boost::mpl::for_each<boost::mpl::range_c<int, 0, sizeof...(pos)> >(flp);

                // set map global to local in the graph, needed because vertex is already created without addVertex method

                gp.setGlobalMap(v_id, local_it, v_id);

                // Get the combinations of dimension d

                for (size_t d = dim - 1; d >= dim_c; d--)
                {
                    // create the edges for that dimension

                    std::vector<comb<dim>> c = hc.getCombinations_R(d);

                    // for each combination calculate a safe linearization and create an edge

                    for (size_t j = 0; j < c.size(); j++)
                    {
                        // Calculate the element size

                        T ele_sz = 0;

                        // for each dimension multiply and reduce

                        for (size_t s = 0; s < dim; s++)
                        {
                            ele_sz += szd[s] * abs(c[j][s]);
                        }

                        // Calculate the end point vertex id
                        // Calculate the start point id

                        size_t start_v = local_it;
                        size_t end_v = g.template LinId<CheckExistence>(key, c[j].getComb());

                        // check if the end_v is valid globally
                        if (end_v < g.size())
                        {
                            // Add an edge and set the the edge property to the size of the face (communication weight)
                            gp.template addEdge<NoCheck>(start_v, end_v).template get<se>() = ele_sz;
                        }
                    }
                }
                ++local_it;
            }
            ++k_it;
        }

        return gp;
    }
};

template<unsigned int dim, typename Graph, typename T, unsigned int dim_c, int ... pos>
class DistGraph_constr_impl<dim, Graph, NO_EDGE, T, dim_c, pos...>
{
public:
    static Graph construct(const size_t (&sz)[dim], Box<dim, T> dom)
    {
        Vcluster &v_cl = create_vcluster();

        // Calculate the size of the hyper-cubes on each dimension

        T szd[dim];

        for (size_t i = 0; i < dim; i++)
        {
            szd[i] = (dom.getHigh(i) - dom.getLow(i)) / sz[i];
        }


        HyperCube<dim> hc;

        // Construct a grid info

        grid_sm<dim, void> g(sz);

        size_t p_id = v_cl.getProcessUnitID();

        size_t Np = v_cl.getProcessingUnits();

        size_t mod_v = g.size() % Np;
        size_t div_v = g.size() / Np;

        openfpm::vector<idx_t> vtxdist(v_cl.getProcessingUnits() + 1);

        for (size_t i = 0; i <= Np; i++)
        {
            if (i < mod_v)
                vtxdist.get(i) = (div_v + 1) * (i);
            else
                vtxdist.get(i) = (div_v) * (i) + mod_v;
        }

        size_t gp_size = vtxdist.get(p_id + 1) - vtxdist.get(p_id);

        Graph gp(gp_size);

        gp.initDistributionVector(vtxdist);

        /******************
         *
         * Create the edges and fill spatial
         * information properties
         *
         ******************/

        grid_key_dx_iterator<dim> k_it(g);

        size_t local_it = 0;


        while (k_it.isNext())
        {
            size_t v_id = g.LinId(k_it.get());

            if (v_id < (size_t)vtxdist.get(p_id + 1) && v_id >= (size_t)vtxdist.get(p_id))
            {
                grid_key_dx<dim> key = k_it.get();

                // Vertex object
                auto obj = gp.vertex(local_it);

                typedef typename to_boost_vmpl<pos...>::type p;

                // vertex spatial properties functor

                fill_prop_v<dim, T, decltype(gp.vertex(local_it)), typename to_boost_vmpl<pos...>::type, fill_prop_v_by_type<sizeof...(pos), p, Graph, pos...>::value> flp(obj, szd, key, g);

                // fill properties

                boost::mpl::for_each<boost::mpl::range_c<int, 0, sizeof...(pos)> >(flp);

                // set map global to local in the graph, needed because vertex is already created without addVertex method

                gp.setGlobalMap(v_id, local_it, v_id);

                // Get the combinations of dimension d

                for (size_t d = dim - 1; d >= dim_c; d--)
                {
                    // create the edges for that dimension

                    std::vector<comb<dim>> c = hc.getCombinations_R(d);

                    // for each combination calculate a safe linearization and create an edge

                    for (size_t j = 0; j < c.size(); j++)
                    {
                        // Calculate the element size

                        T ele_sz = 0;

                        // for each dimension multiply and reduce

                        for (size_t s = 0; s < dim; s++)
                        {
                            ele_sz += szd[s] * abs(c[j][s]);
                        }

                        // Calculate the end point vertex id
                        // Calculate the start point id

                        size_t start_v = local_it;
                        size_t end_v = g.template LinId<CheckExistence>(key, c[j].getComb());

                        // check if the end_v is valid globally
                        if (end_v < g.size())
                        {
                            // Add an edge and set the the edge property to the size of the face (communication weight)
                            gp.addEdge(start_v, end_v, v_id, end_v);
                        }
                    }
                }
                ++local_it;
            }
            ++k_it;
        }
        return gp;
    }
};

template<unsigned int dim, typename Graph>
class DistGraphFactory
{

public:

    template<int se, typename T, unsigned int dim_c, int ... pos>
    static Graph construct(const size_t (&sz)[dim], Box<dim, T> dom)
    {
        return DistGraph_constr_impl<dim, Graph, se, T, dim_c, pos...>::construct(sz, dom);
    }
};

#endif /* DISTGRAPHFACTORY_HPP_ */