SparseGrid_iterator.hpp

/*
 * SparseGrid_iterator.hpp
 *
 *  Created on: Oct 24, 2017
 *      Author: i-bird
 */

#ifndef OPENFPM_DATA_SRC_SPARSEGRID_SPARSEGRID_ITERATOR_HPP_
#define OPENFPM_DATA_SRC_SPARSEGRID_SPARSEGRID_ITERATOR_HPP_

class grid_key_sparse_lin_dx
{
    size_t chunk;

    size_t lin_id;

public:

    inline grid_key_sparse_lin_dx(size_t chunk, size_t lin_id)
    :chunk(chunk),lin_id(lin_id)
    {

    }

    inline size_t getChunk() const
    {
        return chunk;
    }

    inline size_t getPos() const
    {
        return lin_id;
    }
};


template<unsigned int n_ele>
inline void fill_mask(short unsigned int (& mask_it)[n_ele],
               const unsigned char (& mask)[n_ele],
               int & mask_nele)
{
    mask_nele = 0;

    for (size_t i = 0 ; i < n_ele ; i++)
    {
        if (mask[i] & 1)
        {
            mask_it[mask_nele] = i;
            mask_nele++;
        }
    }
}

template<unsigned int dim, unsigned int n_ele>
inline void fill_mask_box(short unsigned int (& mask_it)[n_ele],
               const unsigned char (& mask)[n_ele],
               size_t & mask_nele,
               Box<dim,size_t> & bx,
               const grid_key_dx<dim> (& loc_grid)[n_ele])
{
    mask_nele = 0;

    for (size_t i = 0 ; i < n_ele ; i++)
    {
        size_t id = i;

        bool is_inside = true;
        // we check the point is inside inte
        for (size_t j = 0 ; j < dim ; j++)
        {
            if (loc_grid[id].get(j) < (long int)bx.getLow(j) ||
                loc_grid[id].get(j) > (long int)bx.getHigh(j))
            {
                is_inside = false;

                break;
            }
        }

        if (is_inside == true && (mask[i] & 1))
        {
            mask_it[mask_nele] = id;
            mask_nele++;
        }
    }
}

template<unsigned int n_ele>
struct mheader
{
    unsigned char mask[n_ele];
};


template<unsigned int dim>
struct cheader
{
    grid_key_dx<dim> pos;

    int nele;
};

template<unsigned dim, unsigned int n_ele>
class grid_key_sparse_dx_iterator_sub
{
    const static int cnk_pos = 0;
    const static int cnk_nele = 1;
    const static int cnk_mask = 2;

    const openfpm::vector<mheader<n_ele>> * header_mask;

    const openfpm::vector<cheader<dim>> * header_inf;

    const grid_key_dx<dim> (* lin_id_pos)[n_ele];

    size_t chunk_id;

    size_t mask_nele;

    size_t mask_it_pnt;

    grid_key_dx<dim> start;

    grid_key_dx<dim> stop;

    Box<dim,size_t> bx;

    size_t sz_cnk[dim];

    short unsigned int mask_it[n_ele];

    void SelectValidAndFill_mask_it()
    {
        mask_it_pnt = 0;
        mask_nele = 0;

        while (mask_nele == 0 && chunk_id < header_inf->size())
        {
            auto & mask = header_mask->get(chunk_id).mask;

            Box<dim,size_t> cnk_box;

            for (size_t i = 0 ; i < dim ; i++)
            {
                cnk_box.setLow(i,header_inf->get(chunk_id).pos.get(i));
                cnk_box.setHigh(i,header_inf->get(chunk_id).pos.get(i) + sz_cnk[i] - 1);
            }

            Box<dim,size_t> inte;

            if (bx.Intersect(cnk_box,inte) == true)
            {
                inte -= header_inf->get(chunk_id).pos.toPoint();
                fill_mask_box<dim,n_ele>(mask_it,mask,mask_nele,inte,*lin_id_pos);
            }
            else
            {mask_nele = 0;}

            chunk_id = (mask_nele == 0)?chunk_id + 1:chunk_id;

        }
    }

public:

    grid_key_sparse_dx_iterator_sub()   {};

    grid_key_sparse_dx_iterator_sub(const openfpm::vector<mheader<n_ele>> & header_mask,
                                const openfpm::vector<cheader<dim>> & header_inf,
                                const grid_key_dx<dim> (& lin_id_pos)[n_ele],
                                const grid_key_dx<dim> & start,
                                const grid_key_dx<dim> & stop,
                                const size_t (& sz_cnk)[dim])
    :header_mask(&header_mask),header_inf(&header_inf),lin_id_pos(&lin_id_pos),chunk_id(1),
     mask_nele(0),mask_it_pnt(0),start(start),stop(stop)
    {
        for (size_t i = 0 ; i < dim ; i++)
        {
            this->sz_cnk[i] = sz_cnk[i];

            bx.setLow(i,start.get(i));
            bx.setHigh(i,stop.get(i));
        }

        SelectValidAndFill_mask_it();
    }

    inline void reinitialize(const grid_key_sparse_dx_iterator_sub<dim,n_ele> & g_s_it)
    {
        header_inf = g_s_it.header_inf;
        header_mask = g_s_it.header_mask;
        lin_id_pos = g_s_it.lin_id_pos;
        chunk_id = g_s_it.chunk_id;
        mask_nele = g_s_it.mask_nele;
        mask_it_pnt = g_s_it.mask_it_pnt;
        start = g_s_it.start;
        stop = g_s_it.stop;
        bx = g_s_it.bx;
        for (size_t i = 0 ; i < dim ; i++)
        {sz_cnk[i] = g_s_it.sz_cnk[i];}

        memcpy(mask_it,g_s_it.mask_it,sizeof(short unsigned int)*n_ele);
    }

    inline grid_key_sparse_dx_iterator_sub<dim,n_ele> & operator++()
    {
        mask_it_pnt++;

        if (mask_it_pnt < mask_nele)
        {
            return *this;
        }

        chunk_id++;
        mask_it_pnt = 0;

        if (chunk_id < header_inf->size())
        {
            SelectValidAndFill_mask_it();
        }

        return *this;
    }


    inline grid_key_dx<dim> get() const
    {
        grid_key_dx<dim> k_pos;

        size_t lin_id = mask_it[mask_it_pnt];

        for (size_t i = 0 ; i < dim ; i++)
        {
            k_pos.set_d(i,(*lin_id_pos)[lin_id].get(i) + header_inf->get(chunk_id).pos.get(i));
        }

        return k_pos;
    }

    inline grid_key_sparse_lin_dx getKeyF()
    {
        return grid_key_sparse_lin_dx(chunk_id,mask_it[mask_it_pnt]);
    }

    bool isNext()
    {
        return chunk_id < header_inf->size();
    }

    const grid_key_dx<dim> & getStart() const
    {
        return start;
    }

    const grid_key_dx<dim> & getStop() const
    {
        return stop;
    }

    const openfpm::vector<cheader<dim>> * private_get_header_inf() const
    {return header_inf;}

    const openfpm::vector<mheader<n_ele>> * private_get_header_mask() const
    {return header_mask;}

    const grid_key_dx<dim> (* private_get_lin_id_pos() const)[n_ele]
    {return lin_id_pos;}

    size_t private_get_chunk_id() const
    {return chunk_id;}

    size_t private_get_mask_nele() const
    {return mask_nele;}


    size_t private_get_mask_it_pnt() const
    {return mask_it_pnt;}

    const short unsigned int (& private_get_mask_it() const) [n_ele]
    {
        return mask_it;
    }
};

template<unsigned dim, unsigned int n_ele>
class grid_key_sparse_dx_iterator
{
    const openfpm::vector<mheader<n_ele>> * header_mask;

    const openfpm::vector<cheader<dim>> * header_inf;

    const grid_key_dx<dim> (* lin_id_pos)[n_ele];

    size_t chunk_id;

    int mask_nele;

    size_t mask_it_pnt;

    short unsigned int mask_it[n_ele];

    void SelectValidAndFill_mask_it()
    {
        mask_nele = 0;
        mask_it_pnt = 0;

        while (mask_nele == 0 && chunk_id < header_inf->size())
        {
            auto & mask = header_mask->get(chunk_id).mask;

            fill_mask<n_ele>(mask_it,mask,mask_nele);

            chunk_id = (mask_nele == 0)?chunk_id + 1:chunk_id;

        }
    }

public:

    grid_key_sparse_dx_iterator()   {};

    grid_key_sparse_dx_iterator(const openfpm::vector<mheader<n_ele>> * header_mask,
                                const openfpm::vector<cheader<dim>> * header_inf,
                                const grid_key_dx<dim> (* lin_id_pos)[n_ele])
    :header_mask(header_mask),header_inf(header_inf),lin_id_pos(lin_id_pos),chunk_id(1),mask_nele(0),mask_it_pnt(0)
    {
        SelectValidAndFill_mask_it();
    }

    inline grid_key_sparse_dx_iterator<dim,n_ele> & operator++()
    {
        mask_it_pnt++;

        if (mask_it_pnt < mask_nele)
        {
            return *this;
        }

        chunk_id++;
        mask_it_pnt = 0;

        if (chunk_id < header_inf->size())
        {
            SelectValidAndFill_mask_it();
        }

        return *this;
    }

    inline void reinitialize(const grid_key_sparse_dx_iterator<dim,n_ele> & g_s_it)
    {
        header_mask = g_s_it.header_mask;
        header_inf = g_s_it.header_inf;
        lin_id_pos = g_s_it.lin_id_pos;
        chunk_id = g_s_it.chunk_id;
        mask_nele = g_s_it.mask_nele;
        mask_it_pnt = g_s_it.mask_it_pnt;

        memcpy(mask_it,g_s_it.mask_it,sizeof(short unsigned int)*n_ele);
    }

    inline void reinitialize(const grid_key_sparse_dx_iterator_sub<dim,n_ele> & g_s_it)
    {
        header_mask = g_s_it.private_get_header_mask();
        header_inf = g_s_it.private_get_header_inf();
        lin_id_pos = g_s_it.private_get_lin_id_pos();
        chunk_id = 0;

        SelectValidAndFill_mask_it();
    }

    inline grid_key_sparse_lin_dx getKeyF()
    {
        return grid_key_sparse_lin_dx(chunk_id,mask_it[mask_it_pnt]);
    }

    inline grid_key_dx<dim> get() const
    {
        grid_key_dx<dim> k_pos;

        size_t lin_id = mask_it[mask_it_pnt];

        for (size_t i = 0 ; i < dim ; i++)
        {
            k_pos.set_d(i,(*lin_id_pos)[lin_id].get(i) + header_inf->get(chunk_id).pos.get(i));
        }

        return k_pos;
    }

    bool isNext()
    {
        return chunk_id < header_inf->size();
    }
};

#endif /* OPENFPM_DATA_SRC_SPARSEGRID_SPARSEGRID_ITERATOR_HPP_ */