ParticleItCRS_Cells.hpp

/*
 * CellListIterator_CRS.hpp
 *
 *  Created on: Nov 14, 2016
 *      Author: i-bird
 */

#ifndef OPENFPM_DATA_SRC_NN_CELLLIST_PARTICLEITCRS_CELLS_HPP_
#define OPENFPM_DATA_SRC_NN_CELLLIST_PARTICLEITCRS_CELLS_HPP_

#include "CellNNIterator.hpp"
#include "CellList_util.hpp"
#include "NN/CellList/NNc_array.hpp"

template<unsigned int dim>
struct subsub
{
    grid_key_dx<dim> subsub;

    openfpm::vector<grid_key_dx<dim>> NN_subsub;
};

template<unsigned int dim>
struct subsub_lin
{
    size_t subsub;

    openfpm::vector<long int> NN_subsub;
};

template<unsigned int dim,typename CellListType, typename vector_pos_type> class ParticleItCRS_Cells
{
private:

    const typename CellListType::Mem_type_type::loc_index * start;

    const typename CellListType::Mem_type_type::loc_index * stop;

    size_t cid;

    const long int * NNc;

    long int NNc_size;

    size_t dom_or_anom;

    const openfpm::vector<size_t> &dom_cell;

    const openfpm::vector<subsub_lin<dim>> &anom_dom_cell;

    //
    //   * * *
    //     x *
    //
    const NNc_array<dim,openfpm::math::pow(3,dim)/2+1> & NNc_sym;

    CellListType & cli;

    void selectValid()
    {
        while (start == stop)
        {
            cid++;

            size_t s_cell;
            if (dom_or_anom == 0)
            {
                if (cid >= dom_cell.size())
                {
                    dom_or_anom = 1;
                    cid = 0;

                    // Terminate if we do not have anom cell
                    if (anom_dom_cell.size() == 0)
                    {
                        dom_or_anom = 2;
                        return;
                    }

                    s_cell = anom_dom_cell.get(cid).subsub;
                }
                else
                    s_cell = dom_cell.get(cid);
            }
            else
            {
                if (cid >= anom_dom_cell.size())
                {
                    dom_or_anom = 2;
                    return;
                }

                s_cell = anom_dom_cell.get(cid).subsub;
            }

            // Get the starting particle
            start = &cli.getStartId(s_cell);

            // Get the stop particle
            stop = &cli.getStopId(s_cell);
        }
    }

public:

    ParticleItCRS_Cells(CellListType & cli,
                     const openfpm::vector<size_t> & dom_cell,
                     const openfpm::vector<subsub_lin<dim>> & anom_dom_cell,
                     const NNc_array<dim,openfpm::math::pow(3,dim)/2+1> & NNc_sym)
    :cid(0),NNc(NULL),NNc_size(0),dom_or_anom(0),dom_cell(dom_cell),anom_dom_cell(anom_dom_cell),NNc_sym(NNc_sym),cli(cli)
    {
        size_t s_cell;
        if (dom_cell.size() != 0)
            s_cell = dom_cell.get(0);
        else if (anom_dom_cell.size() != 0)
        {
            s_cell = anom_dom_cell.get(0).subsub;
            dom_or_anom = 1;
        }
        else
        {
            dom_or_anom = 2;

            start = NULL;
            stop = NULL;

            return;
        }

        // Get the starting particle
        start = &cli.getStartId(s_cell);

        // Get the stop particle
        stop = &cli.getStopId(s_cell);

        selectValid();
    }

    ParticleItCRS_Cells & operator++()
    {
        ++start;

        selectValid();

        return *this;
    }

    bool isNext()
    {
        return dom_or_anom != 2;
    }

    size_t get()
    {
        return *start;
    }


    typename CellListType::SymNNIterator getNNIteratorCSR(const vector_pos_type & v) const
    {
        if (dom_or_anom == 0)
        {return typename CellListType::SymNNIterator(dom_cell.get(cid),*start,NNc_sym.getPointer(),openfpm::math::pow(3,dim)/2+1,cli,v);}
        else
        {return typename CellListType::SymNNIterator(anom_dom_cell.get(cid).subsub,
                                                        *start,
                                                        &anom_dom_cell.get(cid).NN_subsub.get(0),
                                                        anom_dom_cell.get(cid).NN_subsub.size(),
                                                        cli,
                                                        v);}
    }

    typename CellListType::SymNNIterator getNNIteratorCSRM(const vector_pos_type & pos ,
                                                           const openfpm::vector<pos_v<vector_pos_type>> & v) const
    {
        if (dom_or_anom == 0)
            return typename CellListType::SymNNIterator(dom_cell.get(cid),CellListType::getV(*start),CellListType::getP(*start),NNc_sym.getPointer(),openfpm::math::pow(3,dim)/2+1,cli,pos,v);
        else
            return typename CellListType::SymNNIterator(anom_dom_cell.get(cid).subsub,CellListType::getV(*start),CellListType::getP(*start),&anom_dom_cell.get(cid).NN_subsub.get(0),anom_dom_cell.get(cid).NN_subsub.size(),cli,pos,v);
    }
};


#endif /* OPENFPM_DATA_SRC_NN_CELLLIST_PARTICLEITCRS_CELLS_HPP_ */