PointIteratorSkin.hpp

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

#ifndef OPENFPM_NUMERICS_SRC_DRAW_POINTITERATORSKIN_HPP_
#define OPENFPM_NUMERICS_SRC_DRAW_POINTITERATORSKIN_HPP_

#include "Grid/Iterators/grid_dist_id_iterator_dec_skin.hpp"

#define RETURN_A 1
#define RETURN_B 2

template<unsigned int dim, typename T, typename Decomposition>
class PointIteratorSkin: protected grid_dist_id_iterator_dec_skin<Decomposition>
{
    Point<dim,T> ap;

    openfpm::vector<Box<dim,T>> sub_domainA;

    Box<dim,T> domain;

    T sp[dim];

    static Box<dim,long int> getAB(size_t (& gs)[dim], const Box<dim,T> & dom, const Box<dim,T> & sub_domA , const Box<dim,T> & sub_domB, T (& sp)[dim], size_t AB)
    {
        for (size_t i = 0 ; i < dim ; i++)
            sp[i] = (dom.getHigh(i) - dom.getLow(i)) / (gs[i] -1);

        Box<dim,long int> box;

        for (size_t i = 0 ; i < dim ; i++)
        {
            size_t Ast = std::ceil( (sub_domA.getLow(i) - dom.getLow(i)) / sp[i] ) - 1;
            size_t Asp = std::floor( (sub_domA.getHigh(i) - dom.getLow(i)) / sp[i] ) + 1;

            size_t Bst = std::ceil( (sub_domB.getLow(i) - dom.getLow(i)) / sp[i] );
            size_t Bsp = std::floor( (sub_domB.getHigh(i) - dom.getLow(i)) / sp[i] );

            // grid_dist_id_iterator_dec_skin only work if A is contained into B
            Ast = (Ast < Bst)?Bst:Ast;
            Asp = (Asp > Bsp)?Bsp:Asp;

            if (AB == RETURN_A)
            {
                box.setLow(i,Ast);
                box.setHigh(i,Asp);
            }
            else
            {
                box.setLow(i,Bst);
                box.setHigh(i,Bsp);
            }
        }

        return box;
    }

    void calculateAp()
    {
        if (grid_dist_id_iterator_dec_skin<Decomposition>::isNext() == false)
            return;

        grid_key_dx<dim> key = grid_dist_id_iterator_dec_skin<Decomposition>::get();

        for (size_t i = 0 ; i < dim ; i++)
            ap.get(i) = key.get(i) * sp[i] + domain.getLow(i);
    }


    bool isValidPoint()
    {
        bool valid = true;

        for (size_t i = 0 ; i < sub_domainA.size() ; i++)
        {
            if (Box<dim,T>(sub_domainA.get(i)).isInside(ap) == true)
                valid = false;
        }

        return valid;
    }

public:

    PointIteratorSkin( Decomposition & dec,
                       size_t (& sz)[dim],
                       const Box<dim,T> & domain,
                       const Box<dim,T> & sub_A,
                       const Box<dim,T> & sub_B,
                       size_t (& bc)[dim])
    :grid_dist_id_iterator_dec_skin<Decomposition>(dec, sz, getAB(sz,domain,sub_A,sub_B,sp,RETURN_A),
     getAB(sz,domain,sub_A,sub_B,sp,RETURN_B), bc),
     domain(domain)
    {
        sub_domainA.add(sub_A);
        calculateAp();
    }

    Point<dim,T> & get()
    {
        return ap;
    }

    PointIteratorSkin & operator++()
    {
        grid_dist_id_iterator_dec_skin<Decomposition>::operator++();

        calculateAp();

        while (grid_dist_id_iterator_dec_skin<Decomposition>::isNext() && isValidPoint() == false)
        {
            grid_dist_id_iterator_dec_skin<Decomposition>::operator++();

            calculateAp();
        }

        return *this;
    }

    bool isNext()
    {
        return grid_dist_id_iterator_dec_skin<Decomposition>::isNext();
    }

    PointIteratorSkin<dim,T,Decomposition> & operator=(PointIteratorSkin<dim,T,Decomposition> & p)
    {
        grid_dist_id_iterator_dec_skin<Decomposition>::operator=(p);

        ap = p.ap;
        sub_domainA = p.sub_domainA;
        domain = p.domain;

        for (size_t i = 0 ; i < dim; i++)
            sp[i] = p.sp[i];

        return *this;
    }

    void addBoxA(const Box<dim,double> & BoxA)
    {
        sub_domainA.add(BoxA);
    }
};



#endif /* OPENFPM_NUMERICS_SRC_DRAW_POINTITERATORSKIN_HPP_ */