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