grid_key_dx_iterator.hpp

/*
 * grid_key_dx_iterator.hpp
 *
 *  Created on: Dec 15, 2015
 *      Author: i-bird
 */
 
#ifndef OPENFPM_DATA_SRC_GRID_ITERATORS_GRID_KEY_DX_ITERATOR_HPP_
#define OPENFPM_DATA_SRC_GRID_ITERATORS_GRID_KEY_DX_ITERATOR_HPP_
 
#include "Grid/grid_sm.hpp"
#include "stencil_type.hpp"
 
template<unsigned int dim, typename stencil=no_stencil, typename linearizer = grid_sm<dim,void>>
class grid_key_dx_iterator
{
#ifdef SE_CLASS1
    // Actual status of the iterator, when the iterator is not initialized cannot be used
    // and reinitialize must be called
    bool initialized = false;
#endif
 
    linearizer grid_base;
 
    inline size_t get_gk(size_t i) const
    {
        return gk.get(i);
    }
 
protected:
 
    grid_key_dx<dim> gk;
 
    stencil stl_code;
 
public:
 
    grid_key_dx_iterator()
    {
#ifdef SE_CLASS1
        initialized = false;
#endif
    }
 
    grid_key_dx_iterator(const grid_key_dx_iterator<dim> & g_it)
    : grid_base(g_it.grid_base)
    {
 
        for (size_t i = 0 ; i < dim ; i++)
        {
            gk.set_d(i,g_it.get_gk(i));
        }
 
        stl_code = g_it.stl_code;
 
#ifdef SE_CLASS1
        initialized = true;
#endif
    }
 
    template<typename grid_lin>
    grid_key_dx_iterator(const grid_lin & g,
                         const grid_key_dx<dim> (& stencil_pnt)[stencil::nsp])
    :grid_base(g)
    {
        reset();
 
        grid_key_dx<dim> zero;
        for (size_t i = 0 ; i < dim ; i++)  {zero.set_d(i,0);}
 
        // calculate the offsets for the stencil code
        stl_code.calc_offsets(g,zero,stencil_pnt);
 
#ifdef SE_CLASS1
        initialized = true;
#endif
    }
 
    grid_key_dx_iterator(const grid_key_dx<dim> (& stencil_pnt)[stencil::nsp])
    {
        // calculate the offsets for the stencil code
        stl_code.set_stencil(stencil_pnt);
    }
 
    grid_key_dx_iterator(const linearizer & g)
    : grid_base(g)
    {
        reset();
 
#ifdef SE_CLASS1
        initialized = true;
#endif
    }
 
    inline grid_key_dx_iterator<dim> operator=(const grid_key_dx_iterator<dim> & key_it)
    {
        grid_base = key_it.grid_base;
 
 
        for (size_t i = 0 ; i < dim ; i++)
        {gk.set_d(i,key_it.get_gk(i));}
 
        return *this;
    }
 
    inline grid_key_dx_iterator<dim,stencil,linearizer> & operator++()
    {
 
        size_t id = gk.get(0);
        gk.set_d(0,id+1);
 
        stl_code.increment();
 
 
        size_t i = 0;
        for ( ; i < dim-1 ; i++)
        {
            /* coverity[dead_error_begin] */
            size_t id = gk.get(i);
            if (id >= grid_base.size(i))
            {
                // ! overflow, increment the next index
 
                size_t idr = gk.get(i);
                gk.set_d(i,0);
                id = gk.get(i+1);
                gk.set_d(i+1,id+1);
 
                stl_code.adjust_offset(i,idr,grid_base);
            }
            else
            {
                break;
            }
        }
 
        return *this;
    }
 
    inline void set(int d, size_t sz)
    {
        // set the counter dim to sz
 
        gk.set_d(d,sz);
    }
 
    template<unsigned int id> inline size_t getStencil() const
    {
        return stl_code.template getStencil<id>();
    }
 
    inline bool isNext()
    {
        if (gk.get(dim-1) < (long int)grid_base.size(dim-1))
        {
 
            return true;
        }
 
        return false;
    }
 
    inline const grid_key_dx<dim> & get() const
    {
        return gk;
    }
 
    inline void reinitialize(const grid_key_dx_iterator<dim> & key)
    {
        grid_base = key.getGridInfo();
        reset();
    }
 
    inline const linearizer & getGridInfo() const
    {
        return grid_base;
    }
 
    inline void reset()
    {
        // Initialize to 0 the index
 
        for (size_t i = 0 ; i < dim ; i++)
        {gk.set_d(i,0);}
 
        // here we check if grid have a size equal to zero or negative
        // in this case the grid has no points
 
        for (size_t i = 0 ; i < dim ; i++)
        {
            // If the size of the grid is zero in any dimension set the iterator
            // to the end point
            if (grid_base.size(i) == 0)
                gk.set_d(dim-1,grid_base.size(dim-1));
        }
    }
 
    void calc_stencil_offset(const grid_key_dx<dim> & start_p)
    {
        // calculate the offsets for the stencil code
        stl_code.calc_offsets(grid_base,start_p);
    }
 
    grid_key_dx<dim> getStart()
    {
        grid_key_dx<dim> zero;
        zero.zero();
        return zero;
    }
 
 
    grid_key_dx<dim> getStop()
    {
        grid_key_dx<dim> stop;
 
        for (size_t i = 0 ; i < dim ; i++)
        {
            stop.set_d(i,grid_base.size(i) - 1);
        }
 
        return stop;
    }
 
    inline size_t getVolume()
    {
        return Box<dim,long int>::getVolumeKey(getStart().k, getStop().k);
    }
 
 
};
 
 
#endif /* OPENFPM_DATA_SRC_GRID_ITERATORS_GRID_KEY_DX_ITERATOR_HPP_ */