SparseGridGpu_iterator.hpp

/*
 * SparseGridGpu_iterator.hpp
 *
 *  Created on: Sep 4, 2019
 *      Author: i-bird
 */
 
#ifndef SPARSEGRIDGPU_ITERATOR_HPP_
#define SPARSEGRIDGPU_ITERATOR_HPP_
 
template<typename SparseGridGpu_type>
class sparse_grid_gpu_index
{
    int cnk_pos_id;
 
    int data_id;
 
    const SparseGridGpu_type & sparseGrid;
 
public:
 
    inline sparse_grid_gpu_index(const SparseGridGpu_type & sparseGrid, int cnk_pos_id, int data_id)
    :sparseGrid(sparseGrid),cnk_pos_id(cnk_pos_id),data_id(data_id)
    {}
 
    inline Point<SparseGridGpu_type::dims,size_t> toPoint() const
    {
        auto indexCnk = sparseGrid.private_get_index_array().template get<0>(cnk_pos_id);
 
        auto coord = sparseGrid.getCoord(indexCnk*sparseGrid.getBlockSize() + data_id);
 
        Point<SparseGridGpu_type::dims,size_t> p;
 
        for (size_t i = 0; i < SparseGridGpu_type::dims ; i++)
        {
            p.get(i) = coord.get(i);
        }
 
        return p;
    }
 
    int get_cnk_pos_id() const
    {
        return cnk_pos_id;
    }
 
    int get_data_id() const
    {
        return data_id;
    }
 
    void set_cnk_pos_id(int cnk_pos_id)
    {
        this->cnk_pos_id = cnk_pos_id;
    }
 
    void set_data_id(int data_id)
    {
        this->data_id = data_id;
    }
 
    inline grid_key_dx<SparseGridGpu_type::dims> operator+(const Point<SparseGridGpu_type::dims,size_t> & p)
    {
        grid_key_dx<SparseGridGpu_type::dims> ret;
        Point<SparseGridGpu_type::dims,size_t> key = toPoint();
 
        for (int i = 0 ; i < SparseGridGpu_type::dims ; i++)
        {
            ret.set_d(i,key.get(i) + p.get(i));
        }
 
        return ret;
    }
 
    inline void set_d(size_t i,int n)
    {
        auto indexCnk = sparseGrid.private_get_index_array().template get<0>(cnk_pos_id);
 
        auto coord = sparseGrid.getCoord(indexCnk*sparseGrid.getBlockSize() + data_id);
 
        coord.set_d(i,n);
 
        auto key = sparseGrid.get_sparse(coord);
 
        cnk_pos_id = key.cnk_pos_id;
        data_id = key.data_id;
    }
 
    /* \brief Return the coordinate in direction i
     *
     * \return the coordinates in direction i
     *
     */
    inline unsigned int get(unsigned int i) const
    {
        auto indexCnk = sparseGrid.private_get_index_array().template get<0>(cnk_pos_id);
 
        return sparseGrid.getCoord(indexCnk*sparseGrid.getBlockSize() + data_id).get(i);
    }
};
 
template<unsigned int dim, typename SparseGridType>
class SparseGridGpu_iterator
{
    unsigned int chunk;
 
    unsigned int pnt;
 
    const SparseGridType * sparseGrid;
 
    typedef typename std::remove_reference<decltype(sparseGrid->private_get_index_array())>::type index_array_type;
 
    typedef typename std::remove_reference<decltype(sparseGrid->private_get_data_array())>::type data_array_type;
 
    const index_array_type * ids;
 
    const data_array_type * data;
 
    //Get the chunk type
    typedef typename boost::mpl::at<typename data_array_type::value_type::type,boost::mpl::int_<0>>::type chunk_type;
 
    //Get the chunk type
    typedef boost::mpl::int_<boost::mpl::size<typename data_array_type::value_type::type>::type::value-1> pMask;
 
    void SelectValid()
    {
        while (pnt < chunk_type::size && data->template get<pMask::value>(chunk)[pnt] == 0)
        {
            pnt++;
        }
 
        while (pnt == chunk_type::size && chunk < ids->size())
        {
            chunk++;
            pnt = 0;
            while (pnt < chunk_type::size && data->template get<pMask::value>(chunk)[pnt] == 0)
            {
                pnt++;
            }
        }
    }
 
public:
 
 
    inline SparseGridGpu_iterator()
    :chunk(0),
     pnt(0),
     sparseGrid(NULL),
     ids(NULL),
     data(NULL)
    {
    }
 
 
    inline SparseGridGpu_iterator(const SparseGridType & sparseGrid)
    :chunk(0),
     pnt(0),
     sparseGrid(&sparseGrid),
     ids(&sparseGrid.private_get_index_array()),
     data(&sparseGrid.private_get_data_array())
    {
        SelectValid();
    }
 
    bool isNext() const
    {
        return chunk < ids->size();
    }
 
    inline SparseGridGpu_iterator<dim,SparseGridType> & operator++()
    {
        ++pnt;
 
        if (pnt >= chunk_type::size)
        {
            ++chunk;
            pnt = 0;
        }
 
        SelectValid();
 
        return *this;
    }
 
    inline sparse_grid_gpu_index<SparseGridType> get() const
    {
        sparse_grid_gpu_index<SparseGridType> spgi(*sparseGrid,chunk,pnt);
 
        return spgi;
    }
 
    inline void reinitialize(const SparseGridGpu_iterator<dim,SparseGridType> & it)
    {
        this->operator=(it);
    }
 
    SparseGridGpu_iterator<dim,SparseGridType> & operator=(const SparseGridGpu_iterator<dim,SparseGridType> & it)
    {
        chunk = it.chunk;
        sparseGrid = it.sparseGrid;
        ids = it.ids;
        data = it.data;
        pnt = it.pnt;
 
        return *this;
    }
};
 
 
#endif /* SPARSEGRIDGPU_ITERATOR_HPP_ */