grid_key_dx_iterator_sub_bc.hpp

/*
 * grid_key_dx_iterator_sub_p.hpp
 *
 *  Created on: Dec 15, 2015
 *      Author: i-bird
 */
 
#ifndef OPENFPM_DATA_SRC_GRID_ITERATORS_GRID_KEY_DX_ITERATOR_SUB_BC_HPP_
#define OPENFPM_DATA_SRC_GRID_ITERATORS_GRID_KEY_DX_ITERATOR_SUB_BC_HPP_
 
#include "grid_key_dx_iterator_sub.hpp"
 
template<unsigned int dim, typename stencil=no_stencil, typename linearizer = grid_sm<dim,void>, typename warn=print_warning_on_adjustment<dim,linearizer>>
class grid_key_dx_iterator_sub_bc : public grid_key_dx_iterator_sub<dim,stencil,linearizer,warn>
{
    size_t bc[dim];
 
    size_t act;
 
    std::vector<Box<dim,size_t>> boxes;
 
    bool inline check_invalid(const grid_key_dx<dim> & key, const size_t (& bc)[dim])
    {
        for (size_t i = 0 ; i < dim ; i++)
        {
            if (bc[i] == NON_PERIODIC && key.get(i) != 1)
            {
                return true;
            }
        }
 
        return false;
    }
 
public:
 
 
    grid_key_dx_iterator_sub_bc(const grid_key_dx_iterator_sub_bc & tmp)
    {
        this->operator=(tmp);
 
    }
 
    grid_key_dx_iterator_sub_bc(grid_key_dx_iterator_sub_bc && tmp)
    {
        this->operator=(tmp);
 
    }
 
    grid_key_dx_iterator_sub_bc & operator=(const grid_key_dx_iterator_sub_bc & tmp)
    {
        for (size_t i = 0 ; i < dim ; i++)
            bc[i] = tmp.bc[i];
 
        act = tmp.act;
        boxes = tmp.boxes;
 
        return *this;
    }
 
    grid_key_dx_iterator_sub_bc & operator=(grid_key_dx_iterator_sub_bc && tmp)
    {
        for (size_t i = 0 ; i < dim ; i++)
            bc[i] = tmp.bc[i];
 
        act = tmp.act;
        boxes.swap(tmp.boxes);
 
        return *this;
    }
 
    grid_key_dx_iterator_sub_bc()
    :act(0)
    {
 
    }
 
 
    grid_key_dx_iterator_sub_bc(const linearizer & g,
                                const grid_key_dx<dim> & start,
                                const grid_key_dx<dim> & stop,
                                const size_t (& bc)[dim])
    :act(0)
    {
        Initialize(g,start,stop,bc);
    }
 
    void Initialize(const linearizer & g,
                                         const grid_key_dx<dim> & start ,
                                         const grid_key_dx<dim> & stop,
                                         const size_t (& bc)[dim])
    {
        // copy the boundary conditions
 
        for (size_t i = 0 ; i < dim ; i++)
        {this->bc[i] = bc[i];}
 
        // compile-time array {3,3,3,....}
 
        typedef typename generate_array<size_t,dim, Fill_three>::result NNthree;
 
        // In case of high dimension grid_key_dx_iterator_sub can become exponentially
        // expensive, on the other hand we are expecting that some of the dimensions
        // are cropped by non periodicity, so we adjust the iteration
 
        size_t end_p[dim];
        size_t start_p[dim];
 
        for (size_t i = 0 ; i < dim ; i++)
        {
            if (this->bc[i] == NON_PERIODIC && g.size(i) == 1)
            {start_p[i] = 1; end_p[i] = 1;}
            else
            {start_p[i] = 0; end_p[i] = 2;}
        }
 
        // Generate the sub-grid iterator
 
        grid_sm<dim,void> nn(NNthree::data);
        grid_key_dx_iterator_sub<dim,stencil> it(nn,start_p,end_p);
 
        // Box base
        Box<dim,long int> base_b(start,stop);
 
        // intersect with all the boxes
        while (it.isNext())
        {
            auto key = it.get();
 
            if (check_invalid(key,bc) == true)
            {
                ++it;
                continue;
            }
 
            bool intersect;
 
            // intersection box
            Box<dim,long int> b_int;
            Box<dim,long int> b_out;
 
            for (size_t i = 0 ; i < dim ; i++)
            {
                b_int.setLow(i,(key.get(i)-1)*g.getSize()[i]);
                b_int.setHigh(i,key.get(i)*g.getSize()[i]-1);
            }
 
            intersect = base_b.Intersect(b_int,b_out);
 
            // Bring to 0 and size[i]
            for (size_t i = 0 ; i < dim ; i++)
            {
                if (bc[i] == PERIODIC)
                {
                    b_out.setLow(i,openfpm::math::positive_modulo(b_out.getLow(i),g.size(i)));
                    b_out.setHigh(i,openfpm::math::positive_modulo(b_out.getHigh(i),g.size(i)));
                }
            }
 
            // if intersect add in the box list
            if (intersect == true)
            {boxes.push_back(b_out);}
 
            ++it;
        }
 
        // initialize the first iterator
        if (boxes.size() > 0)
        {grid_key_dx_iterator_sub<dim,stencil,linearizer,warn>::reinitialize(grid_key_dx_iterator_sub<dim>(g,boxes[0].getKP1(),boxes[0].getKP2()));}
    }
 
    grid_key_dx_iterator_sub_bc<dim,stencil,linearizer,warn> & operator++()
    {
        grid_key_dx_iterator_sub<dim,stencil,linearizer,warn>::operator++();
        if (grid_key_dx_iterator_sub<dim,stencil,linearizer,warn>::isNext() == true)
        {
            return *this;
        }
        else
        {
            act++;
            if (act < boxes.size())
            {grid_key_dx_iterator_sub<dim,stencil,linearizer,warn>::reinitialize(grid_key_dx_iterator_sub<dim>(this->getGridInfo(),boxes[act].getKP1(),boxes[act].getKP2()));}
        }
 
        return *this;
    }
 
    inline bool isNext()
    {
        return act < boxes.size();
    }
 
    inline const grid_key_dx<dim> get() const
    {
        return grid_key_dx_iterator_sub<dim,stencil,linearizer,warn>::get();
    }
 
    inline void reset()
    {
        act = 0;
        // initialize the first iterator
        reinitialize(boxes.get(0).getKP1,boxes.get(0).getKP2);
    }
};
 
 
#endif /* OPENFPM_DATA_SRC_GRID_ITERATORS_GRID_KEY_DX_ITERATOR_SUB_BC_HPP_ */