common.hpp

/*
 * basic.hpp
 *
 *  Created on: Aug 8, 2015
 *      Author: i-bird
 */

#ifndef SRC_DECOMPOSITION_COMMON_HPP_
#define SRC_DECOMPOSITION_COMMON_HPP_

#define UNIQUE 1
#define MULTIPLE 2

#include "Vector/map_vector.hpp"

template<unsigned int dim, typename T>
struct Box_loc_sub
{
    Box<dim,T> bx;

    size_t sub;

    comb<dim> cmb;

    Box_loc_sub()
    :sub(0)
    {
        cmb.zero();
    };

    Box_loc_sub(const Box<dim,T> & bx, size_t sub, const comb<dim> & cmb)
    :bx(bx),sub(sub),cmb(cmb)
    {};

    Box_loc_sub operator=(const Box<dim,T> & box)
    {
        ::Box<dim,T>::operator=(box);

        return *this;
    }


};

template<unsigned int dim, typename T>
struct Box_sub
{
    Box<dim,T> bx;

    size_t sub;

    size_t id;

    size_t r_sub;

    comb<dim> cmb;

    Box_sub()
    {
        cmb.zero();
    }
};

template<unsigned int dim, typename T>
struct Box_sub_k
{
    Box<dim,T> bx;

    size_t sub;

    comb<dim> cmb;

    long int k;

    Box_sub_k()
    :sub(0),k(-1)
    {
        cmb.zero();
    }
};

template<unsigned int dim, typename T>
struct lBox_dom
{
    openfpm::vector_std< Box_sub_k<dim,T> > ebx;

    openfpm::vector_std< Box_sub_k<dim,T>> ibx;
};

template<unsigned int dim, typename T>
struct Box_proc
{
    openfpm::vector<::Box<dim,T>> bx;

    openfpm::vector<::Box<dim,T>> nbx;


    size_t proc;
};

template<unsigned int dim, typename T>
struct Box_dom
{
    openfpm::vector_std< Box_sub<dim,T> > ebx;

    openfpm::vector_std< Box_sub<dim,T> > ibx;
};

// It store the sub-domain sent by the near processors
template<unsigned int dim, typename T>
struct N_box
{
    size_t id;

    typename openfpm::vector<::Box<dim,T>> bx;

    openfpm::vector<comb<dim>> pos;

    size_t n_real_sub;

    openfpm::vector<size_t> r_sub;

    N_box()
    :id((size_t)-1),n_real_sub(0)
    {};

    N_box(const N_box<dim,T> & b)
    :id((size_t)-1),n_real_sub(0)
    {
        this->operator=(b);
    }

    N_box(N_box<dim,T> && b)
    :id((size_t)-1),n_real_sub(0)
    {
        this->operator=(b);
    }

    N_box<dim,T> & operator=(const N_box<dim,T> & ele)
    {
        id = ele.id;
        bx = ele.bx;
        pos = ele.pos;
        n_real_sub = ele.n_real_sub;
        r_sub = ele.r_sub;

        return * this;
    }

    N_box<dim,T> & operator=(N_box<dim,T> && ele)
    {
        id = ele.id;
        bx.swap(ele.bx);
        pos.swap(ele.pos);
        n_real_sub = ele.n_real_sub;
        r_sub.swap(ele.r_sub);

        return * this;
    }

    bool operator==(const N_box<dim,T> & ele) const
    {
        if (id != ele.id)
            return false;

        if (pos != ele.pos)
            return false;

        if (r_sub != ele.r_sub)
            return false;

        if (n_real_sub != ele.n_real_sub)
            return false;

        return bx == ele.bx;
    }

    bool operator!=(const N_box<dim,T> & ele) const
    {
        return ! this->operator==(ele);
    }
};

template<unsigned int dim, typename T>
struct p_box
{
    ::Box<dim,T> box;
    size_t lc_proc;
    size_t proc;

    size_t shift_id;

    bool operator==(const p_box & pb)
    {
        return pb.lc_proc == lc_proc;
    }
};

#endif /* SRC_DECOMPOSITION_COMMON_HPP_ */