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)
 
 
template<unsigned int dim, typename Cell,int NNc_size>
class CellNNIterator
{
protected:
 
    const typename Cell::Mem_type_type::local_index_type * start_id;
 
    const typename Cell::Mem_type_type::local_index_type * stop_id;
 
    size_t NNc_id;
 
    const long int cell;
 
    size_t cell_id;
 
    Cell & cl;
 
    const NNc_array<dim,NNc_size> & NNc;
 
    __attribute__((always_inline)) 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:
 
    __attribute__((always_inline)) 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();
    }
 
    __attribute__((always_inline)) inline bool isNext()
    {
        if (NNc_id >= NNc_size)
            return false;
        return true;
    }
 
    __attribute__((always_inline)) inline CellNNIterator & operator++()
    {
        start_id++;
 
        selectValid();
 
        return *this;
    }
 
    __attribute__((always_inline)) inline const typename Cell::Mem_type_type::local_index_type & get()
    {
        return cl.get_lin(start_id);
    }
 
    __attribute__((always_inline)) inline const typename Cell::Mem_type_type::local_index_type & get() const
    {
        return cl.get_lin(start_id);
    }
};
 
 
template<unsigned int dim, typename Cell, typename vector_pos_type,int NNc_size>
class CellNNIteratorSymLocal
{
    size_t p;
 
    const vector_pos_type & v;
 
    const typename Cell::Mem_type_type::local_index_type * start_id;
 
    const typename Cell::Mem_type_type::local_index_type * stop_id;
 
    size_t NNc_id;
 
    const long int cell;
 
    size_t cell_id;
 
    Cell & cl;
 
    const NNc_array<dim,NNc_size> & NNc;
 
    __attribute__((always_inline)) inline void IterateOwnCell()
    {
        while (start_id < stop_id)
        {
 
            size_t q = cl.get_lin(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:
            start_id++;
        }
    }
 
 
    __attribute__((always_inline)) inline void selectValid()
    {
        if (NNc[NNc_id] == 0)
            IterateOwnCell();
 
        while (start_id == stop_id)
        {
            // No more Cell
            if (++NNc_id >= NNc_size) return;
 
            cell_id = NNc[NNc_id] + cell;
 
            if (NNc[NNc_id] == 0)
            {
                start_id = &(cl.getStartId(cell_id));
                stop_id = &(cl.getStopId(cell_id));
                IterateOwnCell();
 
            } else if (NNc[NNc_id] < 0) {
                start_id = &(cl.getGhostId(cell_id));
                stop_id = &(cl.getStopId(cell_id));
            } else {
                start_id = &(cl.getStartId(cell_id));
                stop_id = &(cl.getStopId(cell_id));
            }
        }
    }
 
public:
    __attribute__((always_inline)) inline const typename Cell::Mem_type_type::local_index_type & get()
    {
        return cl.get_lin(start_id);
    }
 
    __attribute__((always_inline)) inline const typename Cell::Mem_type_type::local_index_type & get() const
    {
        return cl.get_lin(start_id);
    }
 
 
    __attribute__((always_inline)) inline CellNNIteratorSymLocal(size_t cell, size_t p,
        const NNc_array<dim,NNc_size> &NNc, Cell & cl,
        const vector_pos_type & v)
    : NNc_id(0),cell(cell),
    cell_id(NNc[NNc_id] + cell),
    cl(cl),NNc(NNc),
    p(p),v(v)
    {
        if (NNc[NNc_id] < 0) {
            start_id = &(cl.getGhostId(cell_id));
            stop_id = &(cl.getStopId(cell_id));
        } else {
            start_id = &(cl.getStartId(cell_id));
            stop_id = &(cl.getStopId(cell_id));
        }
 
        selectValid();
    }
 
    __attribute__((always_inline)) inline CellNNIteratorSymLocal<dim,Cell,vector_pos_type,NNc_size> & operator++()
    {
        start_id++;
 
        selectValid();
 
        return *this;
    }
 
    __attribute__((always_inline)) inline bool isNext()
    {
        if (NNc_id >= NNc_size)
            return false;
        return true;
    }
};
 
template<unsigned int dim, typename Cell, typename vector_pos_type,int NNc_size>
class CellNNIteratorSym : public CellNNIterator<dim,Cell,NNc_size>
{
    size_t p;
 
    const vector_pos_type & v;
 
    __attribute__((always_inline)) 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>::selectValid();
        }
        else
        {
            CellNNIterator<dim,Cell,NNc_size>::selectValid();
        }
    }
 
public:
 
    __attribute__((always_inline)) inline CellNNIteratorSym(size_t cell, size_t p, const NNc_array<dim,NNc_size> &NNc, Cell & cl, const vector_pos_type & v)
    :CellNNIterator<dim,Cell,NNc_size>(cell,NNc,cl),p(p),v(v)
    {
        selectValid();
    }
 
 
    __attribute__((always_inline)) inline CellNNIteratorSym<dim,Cell,vector_pos_type,NNc_size> & operator++()
    {
        this->start_id++;
 
        selectValid();
 
        return *this;
    }
};
 
template<unsigned int dim, typename Cell, typename vector_pos_type , int NNc_size>
class CellNNIteratorSymMP : public CellNNIterator<dim,Cell,NNc_size>
{
    size_t p;
 
    const vector_pos_type & v_p1;
 
    const vector_pos_type & v_p2;
 
    __attribute__((always_inline)) 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>::selectValid();
        }
        else
        {
            CellNNIterator<dim,Cell,NNc_size>::selectValid();
        }
    }
 
public:
 
    __attribute__((always_inline)) inline CellNNIteratorSymMP(size_t cell,
                               size_t p,
                               const NNc_array<dim,NNc_size> &NNc,
                               Cell & cl,
                               const vector_pos_type & v_p1,
                               const vector_pos_type & v_p2)
    :CellNNIterator<dim,Cell,NNc_size>(cell,NNc,cl),p(p),v_p1(v_p1),v_p2(v_p2)
    {
        selectValid();
    }
 
 
    __attribute__((always_inline)) inline CellNNIteratorSymMP<dim,Cell,vector_pos_type,NNc_size> & operator++()
    {
        this->start_id++;
 
        selectValid();
 
        return *this;
    }
};
 
template<typename Cell> class CellIterator
{
    Cell & cl;
 
    size_t ele_id;
 
    const long int cell;
 
public:
 
    __attribute__((always_inline)) inline CellIterator(const size_t cell, Cell & cl)
    :cl(cl),ele_id(0),cell(cell)
    {
    }
 
    __attribute__((always_inline)) inline bool isNext()
    {
        return cl.getNelements(cell) > ele_id;
    }
 
    __attribute__((always_inline)) inline CellIterator & operator++()
    {
        ele_id++;
 
        return *this;
    }
 
    __attribute__((always_inline)) inline typename Cell::value_type & get()
    {
        return cl.get(cell,ele_id);
    }
 
    __attribute__((always_inline)) inline const typename Cell::value_type & get() const
    {
        return cl.get(cell,ele_id);
    }
};
 
#include "NN/CellList/CellNNIteratorRuntime.hpp"
 
#endif /* CELLNNITERATOR_FULL_HPP_ */