grid_dist_key.hpp

#ifndef GRID_DIST_KEY_DX_HPP
#define GRID_DIST_KEY_DX_HPP

template<unsigned int dim>
class grid_dist_key_dx
{

    size_t g_c;


    grid_key_dx<dim> key;

public:

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

    inline size_t getSub() const
    {
        return g_c;
    }

    inline grid_key_dx<dim> getKey() const
    {
        return key;
    }


    inline grid_key_dx<dim> & 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_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> move(size_t i,size_t s) const
    {
        grid_key_dx<dim> key = getKey();
        key.set_d(i,key.get(i) + s);
        return grid_dist_key_dx<dim>(getSub(),key);
    }

    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 grid_key_dx<dim> & 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()
    {
        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