NNc_array.hpp

/*
 * NNc_array.hpp
 *
 *  Created on: Feb 6, 2018
 *      Author: i-bird
 */
 
#ifndef OPENFPM_DATA_SRC_NN_CELLLIST_NNC_ARRAY_HPP_
#define OPENFPM_DATA_SRC_NN_CELLLIST_NNC_ARRAY_HPP_
 
#include "Grid/grid_sm.hpp"
#include <boost/mpl/bool.hpp>
 
template<unsigned int dim>
struct as_array_nnc
{
    typedef boost::mpl::bool_< dim < 10 > type;
};
 
/* \brief NNc_array
 *
 * \param size
 *
 */
template<unsigned int dim, unsigned int size, bool thr = as_array_nnc<dim>::type::value>
class NNc_array
{
    long int NNc_arr[size];
 
    grid_sm<dim,void> gs;
 
public:
 
    void set_size(const size_t (& sz)[dim])
    {
        gs.setDimensions(sz);
    }
 
    inline const long int & operator[](size_t i) const
    {
        return NNc_arr[i];
    }
 
    inline long int & operator[](size_t i)
    {
        return NNc_arr[i];
    }
 
    void init_full()
    {
        typedef typename generate_array<size_t,dim, Fill_zero>::result NNzero;
        typedef typename generate_array<size_t,dim, Fill_two>::result NNtwo;
        typedef typename generate_array<size_t,dim, Fill_one>::result NNone;
 
        // Generate the sub-grid iterator
 
        grid_key_dx_iterator_sub<dim> gr_sub3(gs,NNzero::data,NNtwo::data);
 
        // Calculate the NNc array
 
        size_t middle = gs.LinId(NNone::data);
        size_t i = 0;
        while (gr_sub3.isNext())
        {
            NNc_arr[i] = (long int)gs.LinId(gr_sub3.get()) - middle;
 
            ++gr_sub3;
            i++;
        }
    }
 
 
    void init_sym()
    {
        // compile-time array {0,0,0,....}  {2,2,2,...} {1,1,1,...}
 
        typedef typename generate_array<size_t,dim, Fill_zero>::result NNzero;
        typedef typename generate_array<size_t,dim, Fill_two>::result NNtwo;
        typedef typename generate_array<size_t,dim, Fill_one>::result NNone;
 
        size_t middle = gs.LinId(NNone::data);
 
        // Generate the sub-grid iterator
 
        grid_key_dx_iterator_sub<dim> gr_sub3(gs,NNzero::data,NNtwo::data);
 
        // Calculate the NNc_sym array
 
        size_t i = 0;
        while (gr_sub3.isNext())
        {
            auto key = gr_sub3.get();
 
            size_t lin = gs.LinId(key);
 
            // Only the first half is considered
            if (lin < middle)
            {
                ++gr_sub3;
                continue;
            }
 
            NNc_arr[i] = lin - middle;
 
            ++gr_sub3;
            i++;
        }
    }
 
    void init_sym_local()
    {
        this->init_full();
    }
 
    const long int * getPointer() const
    {
        return NNc_arr;
    }
 
    NNc_array<dim,size,thr> & operator=(const NNc_array<dim,size,thr> & nnc)
    {
        std::copy(&nnc.NNc_arr[0],&nnc.NNc_arr[size],&NNc_arr[0]);
        gs = nnc.gs;
 
        return *this;
    }
 
    void swap(NNc_array<dim,size,thr> & nnc)
    {
        gs.swap(nnc.gs);
 
        long int NNc_full_tmp[openfpm::math::pow(3,dim)];
 
        std::copy(&nnc.NNc_arr[0],&nnc.NNc_arr[size],&NNc_full_tmp[0]);
        std::copy(&NNc_arr[0],&NNc_arr[size],&nnc.NNc_arr[0]);
        std::copy(&NNc_full_tmp[0],&NNc_full_tmp[size],&NNc_arr[0]);
    }
};
 
/* \brief NNc_array
 *
 * It encapsulate a 3^{dim} array containing the neighborhood cells-id
 *
 * \tparam dim dimensionality
 * \tparam size total number of neighborhood cells
 *
 */
template<unsigned int dim, unsigned int size>
class NNc_array<dim,size,false>
{
    grid_sm<dim,void> gs;
 
    grid_sm<dim,void> gs_base;
 
    size_t sub_off;
    size_t sym_mid;
 
    bool full_or_sym;
 
public:
 
    void set_size(const size_t (& sz)[dim])
    {
        typedef typename generate_array<size_t,dim, Fill_three>::result NNthree;
 
        gs.setDimensions(sz);
        gs_base.setDimensions(NNthree::data);
 
        typedef typename generate_array<size_t,dim, Fill_one>::result NNone;
        sub_off = gs.LinId(NNone::data);
        sym_mid = gs_base.LinId(NNone::data);
    }
 
    long int operator[](size_t i) const
    {
        if (full_or_sym == true)
        {
            grid_key_dx<dim> key = gs_base.InvLinId(i);
            return gs.LinId(key) - sub_off;
        }
 
        grid_key_dx<dim> key = gs_base.InvLinId(i + sym_mid);
        return gs.LinId(key) - sub_off;
    }
 
    void init_full()
    {
        full_or_sym = true;
    }
 
    void init_sym()
    {
        full_or_sym = false;
    }
 
    void init_sym_local()
    {
        full_or_sym = false;
    }
 
    const long int * getPointer() const
    {
        std::cerr << __FILE__ << ":" << __LINE__ << " error dimension is too high to use this type of neighborhood" << std::endl;
        return NULL;
    }
 
    NNc_array<dim,size,false> & operator=(const NNc_array<dim,size,false> & nnc)
    {
        gs = nnc.gs;
        gs_base = nnc.gs_base;
        sub_off = nnc.sub_off;
        sym_mid = nnc.sym_mid;
 
        full_or_sym = nnc.full_or_sym;
 
        return *this;
    }
 
    void swap(NNc_array<dim,size,false> & nnc)
    {
        gs.swap(nnc.gs);
        gs_base.swap(nnc.gs_base);
 
        size_t sub_off_tmp = sub_off;
        sub_off = nnc.sub_off;
        nnc.sub_off = sub_off_tmp;
 
        size_t sym_mid_tmp = sym_mid;
        sym_mid = nnc.sym_mid;
        nnc.sym_mid = sym_mid_tmp;
 
        bool full_or_sym_tmp = full_or_sym;
        full_or_sym = nnc.full_or_sym;
        nnc.full_or_sym = full_or_sym_tmp;
    }
};
 
 
#endif /* OPENFPM_DATA_SRC_NN_CELLLIST_NNC_ARRAY_HPP_ */