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_ */