grid_dist_key.hpp

#ifndef GRID_DIST_KEY_DX_HPP
#define GRID_DIST_KEY_DX_HPP

#include "Grid/map_grid.hpp"
template<unsigned int dim, typename base_key = grid_key_dx<dim>>
class grid_dist_key_dx;

template<bool impl, typename grid_key_base, unsigned int dim>
class move_impl
{
public:
    static grid_dist_key_dx<dim,grid_key_base> move(grid_key_base & key, size_t sub, size_t i, int s)
    {
        key.set_d(i,key.get(i) + s);
        return grid_dist_key_dx<dim,grid_key_base>(sub,key);
    }
};

template<typename grid_key_base, unsigned int dim>
class move_impl<false,grid_key_base,dim>
{
public:
    static grid_dist_key_dx<dim> move(grid_key_base & key, size_t sub, size_t i, int s)
    {
        std::cout << __FILE__ << ":" << __LINE__ << " Error move a key is not supported"
                " directly acting on the grid key, please use the move function from the grid method" << std::endl;

        grid_key_dx<dim> zero;
        zero.zero();

        return grid_dist_key_dx<dim>(0,zero);
    }
};


template<unsigned int dim, typename base_key>
class grid_dist_key_dx
{

    size_t g_c;


    base_key key;

public:

    inline void setSub(size_t sub)
    {
        g_c = sub;
    }

    inline size_t getSub() const
    {
        return g_c;
    }

    inline base_key getKey() const
    {
        return key;
    }


    inline base_key & getKeyRef()
    {
        return key;
    }

    inline const base_key & getKeyRef() const
    {
        return key;
    }

    /* \brief Check if two key are the same
     *
     * \param key_t key to check
     *
     * \return true if the two key are equal
     *
     */

    inline bool operator==(const grid_dist_key_dx<dim> & key_t)
    {
        if (g_c != key_t.g_c)
            return false;

        // Check the two key index by index

        return getKey() == key_t.getKey();
    }

    inline grid_dist_key_dx<dim,base_key> move(size_t i,int s) const
    {
        auto key = getKey();

        return move_impl<has_set_d<base_key>::value,
                 decltype(this->getKey()),
                 dim>::move(key,getSub(),i,s);
    }

    inline grid_dist_key_dx<dim> move(const comb<dim> & c) const
    {
        grid_key_dx<dim> key = getKey();
        for (size_t i = 0 ; i < dim ; i++)
            key.set_d(i,key.get(i) + c[i]);
        return grid_dist_key_dx<dim>(getSub(),key);
    }

    inline grid_dist_key_dx(int g_c, const base_key & key)
    :g_c(g_c),key(key)
    {
    }

    inline grid_dist_key_dx(){}

    std::string to_string()
    {
        std::stringstream str;

        str << "sub_domain=" << g_c << " ";

        for (size_t i = 0 ; i < dim ; i++)
            str << "x[" << i << "]=" << key.get(i) << " ";

        str << "\n";

        return str.str();
    }
};

class grid_dist_lin_dx
{
    size_t g_c;

    size_t key;

public:

    inline void setSub(size_t sub)
    {
        g_c = sub;
    }

    inline size_t getSub() const
    {
        return g_c;
    }

    inline size_t getKey() const
    {
        return key;
    }


    inline size_t & getKeyRef()
    {
        return key;
    }

    /* \brief Check if two key are the same
     *
     * \param key_t key to check
     *
     * \return true if the two key are equal
     *
     */

    inline bool operator==(const grid_dist_lin_dx & key_t)
    {
        if (g_c != key_t.g_c)
            return false;

        // Check the two key index by index

        return getKey() == key_t.getKey();
    }


    inline grid_dist_lin_dx(int g_c, size_t key)
    :g_c(g_c),key(key)
    {
    }

    inline grid_dist_lin_dx(){}

    std::string to_string()
    {
        std::stringstream str;

        str << "sub_domain=" << g_c << " ";
        str << "lin_id=" << key << " ";

        str << "\n";

        return str.str();
    }
};

template<typename device_grid>
class grid_dist_g_dx
{
    device_grid * dg;

    size_t key;

public:

    inline device_grid * getSub() const
    {
        return dg;
    }


    inline size_t getKey() const
    {
        return key;
    }


    inline size_t & getKeyRef()
    {
        return key;
    }

    /* \brief Check if two key are the same
     *
     * \param key_t key to check
     *
     * \return true if the two key are equal
     *
     */

    inline bool operator==(const grid_dist_g_dx & key_t)
    {
        if (dg != key_t.dg)
            return false;

        // Check the two key index by index

        return getKey() == key_t.getKey();
    }


    inline grid_dist_g_dx(device_grid * dg, size_t key)
    :dg(dg),key(key)
    {
    }

    inline grid_dist_g_dx(){}

    std::string to_string()
    {
        std::stringstream str;

        str << "sub_domain=" << dg << " ";
        str << "lin_id=" << key << " ";

        str << "\n";

        return str.str();
    }
};

#endif