CellNNIteratorRuntime.hpp

/*
 * CellNNIteratorRuntime.hpp
 *
 *  Created on: Nov 18, 2016
 *      Author: i-bird
 */

#ifndef OPENFPM_DATA_SRC_NN_CELLLIST_CELLNNITERATORRUNTIME_HPP_
#define OPENFPM_DATA_SRC_NN_CELLLIST_CELLNNITERATORRUNTIME_HPP_

#include "util/mathutil.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 RUNTIME -1

template<unsigned int dim, typename Cell,unsigned int impl>
class CellNNIterator<dim,Cell,RUNTIME,impl>
{
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;

    size_t NNc_size;

    const long int cell;

    size_t cell_id;

    Cell & cl;

    const long int * 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 long int * NNc, size_t NNc_size, Cell & cl)
    :NNc_id(0),NNc_size(NNc_size),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::loc_index & get()
    {
        return cl.get_lin(start_id);
    }
};


template<unsigned int dim, typename Cell,typename vector_pos_type, unsigned int impl>
class CellNNIteratorSym<dim,Cell,vector_pos_type,RUNTIME,impl> : public CellNNIterator<dim,Cell,RUNTIME,impl>
{
    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,RUNTIME,impl>::selectValid();
        }
        else
        {
            CellNNIterator<dim,Cell,RUNTIME,impl>::selectValid();
        }
    }

public:

    __attribute__((always_inline)) inline CellNNIteratorSym(size_t cell,
                             size_t p,
                             const long int * NNc,
                             size_t NNc_size,
                             Cell & cl,
                             const vector_pos_type & v)
    :CellNNIterator<dim,Cell,RUNTIME,impl>(cell,NNc,NNc_size,cl),p(p),v(v)
    {
        if (this->NNc_id >= this->NNc_size)
            return;

        selectValid();
    }


    __attribute__((always_inline)) inline CellNNIteratorSym<dim,Cell,vector_pos_type,RUNTIME,impl> & operator++()
    {
        this->start_id++;

        selectValid();

        return *this;
    }
};

#endif /* OPENFPM_DATA_SRC_NN_CELLLIST_CELLNNITERATORRUNTIME_HPP_ */