grid_dist_id_iterator_dec_skin.hpp

/*
 * grid_dist_id_iterator_dec_skin.hpp
 *
 *  Created on: Jan 4, 2017
 *      Author: i-bird
 */

#ifndef SRC_GRID_ITERATORS_GRID_DIST_ID_ITERATOR_DEC_SKIN_HPP_
#define SRC_GRID_ITERATORS_GRID_DIST_ID_ITERATOR_DEC_SKIN_HPP_


#include "grid_dist_id_iterator.hpp"
#include "Grid/grid_dist_util.hpp"
#include "grid_dist_id_iterator_util.hpp"

template<typename Decomposition>
class grid_dist_id_iterator_dec_skin : protected grid_skin_iterator_bc<Decomposition::dims>
{
    size_t a_its_p;

    size_t g_c;

    openfpm::vector<GBoxes<Decomposition::dims>> gdb_ext;

    grid_key_dx_iterator_sub<Decomposition::dims> a_it;

    struct gp_sub
    {
        size_t gc;

        grid_key_dx_iterator_sub<Decomposition::dims> it;

        gp_sub(size_t gc, grid_key_dx_iterator_sub<Decomposition::dims> && it)
        :gc(gc),it(it)
        {}
    };

    openfpm::vector<gp_sub> a_its;

    typename Decomposition::stype spacing[Decomposition::dims];


    void selectValidGrid()
    {
        if (a_its_p < a_its.size())
        {
            g_c = a_its.get(a_its_p).gc;

            a_it.reinitialize(a_its.get(a_its_p).it);
        }
        else
            g_c = gdb_ext.size();
    }

    void construct_sub_it()
    {
        // Construct the sub iterators
        for (size_t i = 0 ; i < 2*Decomposition::dims; i++)
        {
            for (size_t gc = 0 ; gc < gdb_ext.size() ; gc++)
            {
                grid_key_dx<Decomposition::dims> start = this->sub_it[i].getStart();
                grid_key_dx<Decomposition::dims> stop = this->sub_it[i].getStop();

                grid_key_dx<Decomposition::dims> start_c;
                grid_key_dx<Decomposition::dims> stop_c;

                if (compute_subset<Decomposition,false>(gdb_ext,gc,start,stop,start_c,stop_c) == true)
                {
                    // Convert global coordinate start_c stop_c into local
                    // and calculate the grid sizes
                    size_t sz[Decomposition::dims];
                    for (size_t j = 0 ; j < Decomposition::dims ; j++)
                    {sz[j] = gdb_ext.get(gc).GDbox.getHigh(j) + 1;}

                    grid_sm<Decomposition::dims,void> g_sm(sz);

                    // Non empty sub-set
                    a_its.add(gp_sub(gc,grid_key_dx_iterator_sub<Decomposition::dims>(g_sm,start_c,stop_c)));
                }
            }
        }
    }


    public:


    grid_dist_id_iterator_dec_skin(const grid_dist_id_iterator_dec_skin<Decomposition> & tmp)
    :grid_skin_iterator_bc<Decomposition::dims>(tmp),a_its_p(0)
    {
        this->operator=(tmp);
    }

    grid_dist_id_iterator_dec_skin(grid_dist_id_iterator_dec_skin<Decomposition> && tmp)
    :grid_skin_iterator_bc<Decomposition::dims>(tmp),a_its_p(0)
    {
        this->operator=(tmp);
    }

    grid_dist_id_iterator_dec_skin(Decomposition & dec,
                                   const grid_sm<Decomposition::dims,void> & g_sm,
                                   const Box<Decomposition::dims,size_t> & A,
                                   const Box<Decomposition::dims,size_t> & B,
                                   const size_t (& bc)[Decomposition::dims])
    :grid_skin_iterator_bc<Decomposition::dims>(g_sm,A,B,bc),a_its_p(0),g_c(0)
    {
        // From the decomposition construct gdb_ext
        create_gdb_ext<Decomposition::dims,Decomposition>(gdb_ext,dec,g_sm.getSize(),dec.getDomain(),spacing);

        // This iterato only work if A is contained into B
        if (A.isContained(B) == false)
            std::cout << __FILE__ << ":" << __LINE__ << ", Error Box A must be contained into box B" << std::endl;

        // construct sub_iterators
        construct_sub_it();

        // Initialize the current iterator
        // with the first grid
        selectValidGrid();
    }

    ~grid_dist_id_iterator_dec_skin()
    {
    }

    inline grid_dist_id_iterator_dec_skin<Decomposition> & operator++()
    {
        ++a_it;

        // check if a_it is at the end

        if (a_it.isNext() == true)
            return *this;
        else
        {
            // switch to the new grid
            a_its_p++;

            selectValidGrid();
        }

        return *this;
    }

    inline bool isNext()
    {
        // If there are no other grid stop

        if (a_its_p >= a_its.size())
        {return false;}

        return true;
    }

    inline typename Decomposition::stype getSpacing(size_t i)
    {
        return spacing[i];
    }

    inline grid_key_dx<Decomposition::dims> get()
    {
        const grid_dist_key_dx<Decomposition::dims> k = get_int();

        // Get the sub-domain id
        size_t sub_id = k.getSub();

        grid_key_dx<Decomposition::dims> k_glob = k.getKey();

        // shift
        k_glob = k_glob + gdb_ext.get(sub_id).origin;

        return k_glob;
    }

    inline grid_dist_key_dx<Decomposition::dims> get_int()
    {
        return grid_dist_key_dx<Decomposition::dims>(g_c,a_it.get());
    }

    grid_dist_id_iterator_dec_skin<Decomposition> & operator=(const grid_dist_id_iterator_dec_skin<Decomposition> & tmp)
    {
        a_its_p = tmp.a_its_p;
        g_c = tmp.g_c;
        gdb_ext = tmp.gdb_ext;
        a_its = tmp.a_its;

        for (size_t i = 0 ; i < Decomposition::dims ; i++)
            spacing[i] = tmp.spacing[i];

        a_it.reinitialize(tmp.a_it);

        return *this;
    }

    grid_dist_id_iterator_dec_skin<Decomposition> & operator=(grid_dist_id_iterator_dec_skin<Decomposition> && tmp)
    {
        a_its_p = tmp.a_its_p;
        g_c = tmp.g_c;
        gdb_ext = tmp.gdb_ext;
        a_its = tmp.a_its;

        for (size_t i = 0 ; i < Decomposition::dims ; i++)
            spacing[i] = tmp.spacing[i];

        a_it.reinitialize(tmp.a_it);

        return *this;
    }
};


#endif /* SRC_GRID_ITERATORS_GRID_DIST_ID_ITERATOR_DEC_SKIN_HPP_ */