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> struct periodicity
{
    size_t bc[dim];
};
 
template<unsigned int dim> struct periodicity_int
{
    int bc[dim];
};
 
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()
    {
        r_sub = (size_t)-1;
        cmb.zero();
 
        sub = (size_t)-1;
    }
};
 
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> using Box_map = aggregate<Box<dim,T>,long int>;
 
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_ */