CellNNIterator.hpp

/*
 * CellNNIterator.hpp
 *
 *  Created on: Mar 26, 2015
 *      Author: i-bird
 */

#ifndef CELLNNITERATOR_FULL_HPP_
#define CELLNNITERATOR_FULL_HPP_

#include "util/mathutil.hpp"
#include "NN/CellList/NNc_array.hpp"

#define FULL openfpm::math::pow(3,dim)
#define SYM  openfpm::math::pow(3,dim)/2 + 1
#define CRS openfpm::math::pow(2,dim)

#define NO_CHECK 1
#define SAFE 2

template<unsigned int dim, typename Cell,int NNc_size, unsigned int impl>
class CellNNIterator
{
protected:

    const typename Cell::Mem_type_type::loc_index * start_id;

    const typename Cell::Mem_type_type::loc_index * stop_id;

    size_t NNc_id;

    const long int cell;

    size_t cell_id;

    Cell & cl;

    const NNc_array<dim,NNc_size> & NNc;

    inline void selectValid()
    {
        while (start_id == stop_id)
        {
            NNc_id++;

            // No more Cell
            if (NNc_id >= NNc_size) return;

            cell_id = NNc[NNc_id] + cell;

            start_id = &cl.getStartId(cell_id);
            stop_id = &cl.getStopId(cell_id);
        }
    }

private:


public:

    inline CellNNIterator(size_t cell, const NNc_array<dim,NNc_size> &NNc, Cell & cl)
    :NNc_id(0),cell(cell),cell_id(NNc[NNc_id] + cell),cl(cl),NNc(NNc)
    {
        start_id = &cl.getStartId(cell_id);
        stop_id = &cl.getStopId(cell_id);
        selectValid();
    }

    inline bool isNext()
    {
        if (NNc_id >= NNc_size)
            return false;
        return true;
    }

    inline CellNNIterator & operator++()
    {
        start_id++;

        selectValid();

        return *this;
    }

    inline const typename Cell::Mem_type_type::loc_index & get()
    {
        return cl.get_lin(start_id);
    }

    inline const typename Cell::Mem_type_type::loc_index & get() const
    {
        return cl.get_lin(start_id);
    }
};


template<unsigned int dim, typename Cell,int NNc_size, unsigned int impl> class CellNNIteratorSym : public CellNNIterator<dim,Cell,NNc_size,impl>
{
    size_t p;

    const openfpm::vector<Point<dim,typename Cell::stype>> & v;

    inline void selectValid()
    {
        if (this->NNc[this->NNc_id] == 0)
        {
            while (this->start_id < this->stop_id)
            {
                size_t q = this->cl.get_lin(this->start_id);
                for (long int i = dim-1 ; i >= 0 ; i--)
                {
                    if (v.template get<0>(p)[i] < v.template get<0>(q)[i])
                        return;
                    else if (v.template get<0>(p)[i] > v.template get<0>(q)[i])
                        goto next;
                }
                if (q >= p) return;
next:
                this->start_id++;
            }

            CellNNIterator<dim,Cell,NNc_size,impl>::selectValid();
        }
        else
        {
            CellNNIterator<dim,Cell,NNc_size,impl>::selectValid();
        }
    }

public:

    inline CellNNIteratorSym(size_t cell, size_t p, const NNc_array<dim,NNc_size> &NNc, Cell & cl, const openfpm::vector<Point<dim,typename Cell::stype>> & v)
    :CellNNIterator<dim,Cell,NNc_size,impl>(cell,NNc,cl),p(p),v(v)
    {
        selectValid();
    }


    inline CellNNIteratorSym<dim,Cell,NNc_size,impl> & operator++()
    {
        this->start_id++;

        selectValid();

        return *this;
    }
};

template<unsigned int dim, typename Cell,int NNc_size, unsigned int impl> class CellNNIteratorSymMP : public CellNNIterator<dim,Cell,NNc_size,impl>
{
    size_t p;

    const openfpm::vector<Point<dim,typename Cell::stype>> & v_p1;

    const openfpm::vector<Point<dim,typename Cell::stype>> & v_p2;

    inline void selectValid()
    {
        if (this->NNc[this->NNc_id] == 0)
        {
            while (this->start_id < this->stop_id)
            {
                size_t q = this->cl.get_lin(this->start_id);
                for (long int i = dim-1 ; i >= 0 ; i--)
                {
                    if (v_p1.template get<0>(p)[i] < v_p2.template get<0>(q)[i])
                        return;
                    else if (v_p1.template get<0>(p)[i] > v_p2.template get<0>(q)[i])
                        goto next;
                }
                if (q >= p) return;
next:
                this->start_id++;
            }

            CellNNIterator<dim,Cell,NNc_size,impl>::selectValid();
        }
        else
        {
            CellNNIterator<dim,Cell,NNc_size,impl>::selectValid();
        }
    }

public:

    inline CellNNIteratorSymMP(size_t cell,
                               size_t p,
                               const NNc_array<dim,NNc_size> &NNc,
                               Cell & cl,
                               const openfpm::vector<Point<dim,typename Cell::stype>> & v_p1,
                               const openfpm::vector<Point<dim,typename Cell::stype>> & v_p2)
    :CellNNIterator<dim,Cell,NNc_size,impl>(cell,NNc,cl),p(p),v_p1(v_p1),v_p2(v_p2)
    {
        selectValid();
    }


    inline CellNNIteratorSymMP<dim,Cell,NNc_size,impl> & operator++()
    {
        this->start_id++;

        selectValid();

        return *this;
    }
};

template<typename Cell> class CellIterator
{
    Cell & cl;

    size_t ele_id;

    const long int cell;

public:

    inline CellIterator(const size_t cell, Cell & cl)
    :cl(cl),ele_id(0),cell(cell)
    {
    }

    inline bool isNext()
    {
        return cl.getNelements(cell) > ele_id;
    }

    inline CellIterator & operator++()
    {
        ele_id++;

        return *this;
    }

    inline typename Cell::value_type & get()
    {
        return cl.get(cell,ele_id);
    }

    inline const typename Cell::value_type & get() const
    {
        return cl.get(cell,ele_id);
    }
};

#include "CellNNIteratorRuntime.hpp"

#endif /* CELLNNITERATOR_FULL_HPP_ */