ie_loc_ghost.hpp

/*
 * ie_ghost.hpp
 *
 *  Created on: Aug 8, 2015
 *      Author: i-bird
 */

#ifndef SRC_DECOMPOSITION_GHOST_DEC_IE_GHOST_HPP_
#define SRC_DECOMPOSITION_GHOST_DEC_IE_GHOST_HPP_

#include "Space/Shape/Box.hpp"
#include "Space/Ghost.hpp"
#include "Space/SpaceBox.hpp"
#include "common.hpp"
#include "VTKWriter/VTKWriter.hpp"
#include "nn_processor.hpp"

template<unsigned int dim, typename T, template <typename> class layout_base, typename Memory>
class ie_loc_ghost
{
    openfpm::vector<lBox_dom<dim,T>> loc_ghost_box;

    openfpm::vector<Box_loc_sub<dim,T>> sub_domains_tmp;

    void create_loc_ghost_ebox(Ghost<dim,T> & ghost,
                               openfpm::vector<SpaceBox<dim,T>,Memory,layout_base> & sub_domains,
                               openfpm::vector<Box_loc_sub<dim,T>> & sub_domains_prc)
    {
        comb<dim> zero;
        zero.zero();

        loc_ghost_box.resize(sub_domains.size());

        // For each sub-domain
        for (size_t i = 0 ; i < sub_domains.size() ; i++)
        {
            SpaceBox<dim,T> sub_with_ghost = sub_domains.get(i);

            // enlarge the sub-domain with the ghost
            sub_with_ghost.enlarge(ghost);

            // intersect with the other local sub-domains
            for (size_t j = 0 ; j < sub_domains_prc.size() ; j++)
            {
                size_t rj = sub_domains_prc.get(j).sub;

                if (rj == i && sub_domains_prc.get(j).cmb == zero)
                    continue;

                ::Box<dim,T> bi;

                bool intersect = sub_with_ghost.Intersect(sub_domains_prc.get(j).bx,bi);

                if (intersect == true)
                {
                    Box_sub_k<dim,T> b;
                    b.sub = rj;
                    b.bx = bi;
                    b.cmb = sub_domains_prc.get(j).cmb;

                    // local external ghost box
                    loc_ghost_box.get(i).ebx.add(b);

                    // search this box in the internal box of the sub-domain j
                    for (size_t k = 0; k < loc_ghost_box.get(rj).ibx.size() ; k++)
                    {
                        if (loc_ghost_box.get(rj).ibx.get(k).sub == i && loc_ghost_box.get(rj).ibx.get(k).cmb == sub_domains_prc.get(j).cmb.operator-())
                        {
                            loc_ghost_box.get(rj).ibx.get(k).k = loc_ghost_box.get(i).ebx.size()-1;
                            loc_ghost_box.get(i).ebx.last().k = k;
                            break;
                        }
                    }
                }
            }
        }
    }

    void create_loc_ghost_ibox(Ghost<dim,T> & ghost,
                               openfpm::vector<SpaceBox<dim,T>,Memory,layout_base> & sub_domains,
                               openfpm::vector<Box_loc_sub<dim,T>> & sub_domains_prc)
    {
        comb<dim> zero;
        zero.zero();

        loc_ghost_box.resize(sub_domains.size());

        // For each sub-domain
        for (size_t i = 0 ; i < sub_domains.size() ; i++)
        {
            // intersect with the others local sub-domains
            for (size_t j = 0 ; j < sub_domains_prc.size() ; j++)
            {
                SpaceBox<dim,T> sub_with_ghost = sub_domains_prc.get(j).bx;
                size_t rj = sub_domains_prc.get(j).sub;

                // Avoid to intersect the box with itself
                if (rj == i && sub_domains_prc.get(j).cmb == zero)
                    continue;

                // enlarge the sub-domain with the ghost
                sub_with_ghost.enlarge(ghost);

                ::Box<dim,T> bi;

                bool intersect = sub_with_ghost.Intersect(::SpaceBox<dim,T>(sub_domains.get(i)),bi);

                if (intersect == true)
                {
                    Box_sub_k<dim,T> b;
                    b.sub = rj;
                    b.bx = bi;
                    b.k = -1;
                    b.cmb = sub_domains_prc.get(j).cmb;

                    loc_ghost_box.get(i).ibx.add(b);
                }
            }
        }
    }

    void applyBC(openfpm::vector<Box_loc_sub<dim,T>> & sub_domains, const Box<dim,T> & domain, const Ghost<dim,T> & ghost, const size_t (&bc)[dim])
    {
        HyperCube<dim> hyp;

        // first we create boxes at the border of the domain used to detect the sub-domain
        // that must be adjusted, each of this boxes define a shift in case of periodic boundary condition
        for (long int i = dim-1 ; i >= 0 ; i--)
        {
            std::vector<comb<dim>> cmbs = hyp.getCombinations_R_bc(i,bc);

            for (size_t j = 0 ; j < cmbs.size() ; j++)
            {
                if (nn_prcs<dim,T,layout_base,Memory>::check_valid(cmbs[j],bc) == false)
                    continue;

                Box<dim,T> bp;
                Point<dim,T> shift;

                for (size_t k = 0 ; k < dim ; k++)
                {
                    switch (cmbs[j][k])
                    {
                    case 1:
                        bp.setLow(k,domain.getHigh(k)+ghost.getLow(k));
                        bp.setHigh(k,domain.getHigh(k));
                        shift.get(k) = -domain.getHigh(k)+domain.getLow(k);
                        break;
                    case 0:
                        bp.setLow(k,domain.getLow(k));
                        bp.setHigh(k,domain.getHigh(k));
                        shift.get(k) = 0;
                        break;
                    case (char)-1:
                        bp.setLow(k,domain.getLow(k));
                        bp.setHigh(k,ghost.getHigh(k));
                        shift.get(k) = domain.getHigh(k)-domain.getLow(k);
                        break;
                    }
                }

                // Detect all the sub-domain involved, shift them and add to the list
                // Detection is performed intersecting the sub-domains with the ghost
                // parts near the domain borders
                for (size_t k = 0 ; k < sub_domains.size() ; k++)
                {
                    Box<dim,T> sub = sub_domains.get(k).bx;
                    Box<dim,T> b_int;

                    if (sub.Intersect(bp,b_int) == true)
                    {
                        sub += shift;
                        add_subdomain(Box_loc_sub<dim,T>(sub,k,cmbs[j]));
                    }
                }
            }
        }

        flush(sub_domains);
    }



    inline void add_subdomain(const Box_loc_sub<dim,T> & bx)
    {
        sub_domains_tmp.add(bx);
    }

    void flush(openfpm::vector<Box_loc_sub<dim,T>> & sub_domains)
    {
        for (size_t i = 0 ; i < sub_domains_tmp.size() ; i++)
        {
            sub_domains.add(sub_domains_tmp.get(i));
        }

        sub_domains_tmp.clear();
    }

public:

    void create(openfpm::vector<SpaceBox<dim,T>,Memory,layout_base> & sub_domains, Box<dim,T> & domain , Ghost<dim,T> & ghost , const size_t (&bc)[dim] )
    {
        // It will store local sub-domains + borders
        openfpm::vector<Box_loc_sub<dim,T>> sub_domains_prc;

        comb<dim> zero;
        zero.zero();

        // Copy sub_domains into sub_domains_prc
        for (size_t i = 0 ; i < sub_domains.size() ; i++)
        {
            Box_loc_sub<dim,T> bls(SpaceBox<dim,T>(sub_domains.get(i)),i,zero);
            sub_domains_prc.add(bls);
            sub_domains_prc.last().sub = i;
        }

        applyBC(sub_domains_prc,domain,ghost,bc);

        create_loc_ghost_ibox(ghost,sub_domains,sub_domains_prc);
        create_loc_ghost_ebox(ghost,sub_domains,sub_domains_prc);
    }

    ie_loc_ghost()  {};

    ie_loc_ghost(const ie_loc_ghost<dim,T,layout_base,Memory> & ilg)
    {
        this->operator=(ilg);
    };

    ie_loc_ghost(ie_loc_ghost<dim,T,layout_base,Memory> && ilg)
    {
        this->operator=(ilg);
    }

    ie_loc_ghost<dim,T,layout_base,Memory> & operator=(const ie_loc_ghost<dim,T,layout_base,Memory> & ilg)
    {
        loc_ghost_box = ilg.loc_ghost_box;
        return *this;
    }

    ie_loc_ghost<dim,T,layout_base,Memory> & operator=(ie_loc_ghost<dim,T,layout_base,Memory> && ilg)
    {
        loc_ghost_box.swap(ilg.loc_ghost_box);
        return *this;
    }

    template<template <typename> class layout_base2, typename Memory2>
    ie_loc_ghost<dim,T,layout_base,Memory> & operator=(const ie_loc_ghost<dim,T,layout_base2,Memory2> & ilg)
    {
        loc_ghost_box = ilg.private_get_loc_ghost_box();
        return *this;
    }

    template<template <typename> class layout_base2, typename Memory2>
    ie_loc_ghost<dim,T,layout_base,Memory> & operator=(ie_loc_ghost<dim,T,layout_base2,Memory2> && ilg)
    {
        loc_ghost_box.swap(ilg.private_get_loc_ghost_box());
        return *this;
    }

    inline openfpm::vector<lBox_dom<dim,T>> & private_get_loc_ghost_box()
    {
        return loc_ghost_box;
    }

    inline size_t getNLocalSub()
    {
        return loc_ghost_box.size();
    }

    inline size_t getLocalNEGhost(size_t id)
    {
        return loc_ghost_box.get(id).ebx.size();
    }

    inline size_t getLocalNIGhost(size_t id)
    {
        return loc_ghost_box.get(id).ibx.size();
    }

    inline size_t getLocalIGhostE(size_t i, size_t j)
    {
        return loc_ghost_box.get(i).ibx.get(j).k;
    }

    inline const ::Box<dim,T> & getLocalIGhostBox(size_t i, size_t j) const
    {
        return loc_ghost_box.get(i).ibx.get(j).bx;
    }

    inline const comb<dim> & getLocalIGhostPos(size_t i, size_t j) const
    {
        return loc_ghost_box.get(i).ibx.get(j).cmb;
    }

    inline const ::Box<dim,T> & getLocalEGhostBox(size_t i, size_t j) const
    {
        return loc_ghost_box.get(i).ebx.get(j).bx;
    }

    inline const comb<dim> & getLocalEGhostPos(size_t i, size_t j) const
    {
        return loc_ghost_box.get(i).ebx.get(j).cmb;
    }

    inline size_t getLocalIGhostSub(size_t i, size_t k) const
    {
        return loc_ghost_box.get(i).ibx.get(k).sub;
    }

    inline size_t getLocalEGhostSub(size_t i, size_t k) const
    {
        return loc_ghost_box.get(i).ebx.get(k).sub;
    }

    bool write(std::string output, size_t p_id) const
    {
        // Copy the Box_sub_k into a vector of boxes
        openfpm::vector<openfpm::vector<Box<dim,T>>> vv5;

        for (size_t p = 0 ; p < loc_ghost_box.size() ; p++)
        {
            vv5.add();
            for (size_t i = 0 ; i < loc_ghost_box.get(p).ibx.size() ; i++)
                vv5.last().add(loc_ghost_box.get(p).ibx.get(i).bx);
        }

        VTKWriter<openfpm::vector<Box<dim,T>>,VECTOR_BOX> vtk_box5;
        for (size_t p = 0 ; p < vv5.size() ; p++)
        {
            vtk_box5.add(vv5.get(p));
        }
        vtk_box5.write(output + std::string("local_internal_ghost_") + std::to_string(p_id) + std::string(".vtk"));

        // Copy the Box_sub_k into a vector of boxes
        openfpm::vector<openfpm::vector<Box<dim,T>>> vv6;

        for (size_t p = 0 ; p < loc_ghost_box.size() ; p++)
        {
            vv6.add();
            for (size_t i = 0 ; i < loc_ghost_box.get(p).ebx.size() ; i++)
                vv6.last().add(loc_ghost_box.get(p).ebx.get(i).bx);
        }

        VTKWriter<openfpm::vector<Box<dim,T>>,VECTOR_BOX> vtk_box6;
        for (size_t p = 0 ; p < vv6.size() ; p++)
        {
            vtk_box6.add(vv6.get(p));
        }
        vtk_box6.write(output + std::string("local_external_ghost_") + std::to_string(p_id) + std::string(".vtk"));

        return true;
    }

    bool check_consistency(size_t n_sub)
    {
        for (size_t i = 0 ; i < loc_ghost_box.size() ; i++)
        {
            for (size_t j = 0 ; j < loc_ghost_box.get(i).ibx.size() ; j++)
            {
                if (loc_ghost_box.get(i).ibx.get(j).k == -1)
                {
                    std::cout << __FILE__ << ":" << __LINE__ << " Error: inconsistent decomposition no ibx link" << "\n";
                    return false;
                }

                size_t k = loc_ghost_box.get(i).ibx.get(j).k;
                size_t sub = loc_ghost_box.get(i).ibx.get(j).sub;

                if (loc_ghost_box.get(sub).ebx.get(k).k != (long int)j)
                {
                    std::cout << __FILE__ << ":" << __LINE__ << " Error: inconsistent link between an external ghost box and an internal ghost box" << "\n";
                    return false;
                }
            }
        }

        return true;
    }

    bool is_equal(ie_loc_ghost<dim,T,layout_base,Memory> & ilg)
    {
        if (ilg.loc_ghost_box.size() != loc_ghost_box.size())
            return false;

        // Explore all the subdomains
        for (size_t i = 0 ; i < loc_ghost_box.size() ; i++)
        {
            if (getLocalNIGhost(i) != ilg.getLocalNIGhost(i))
                return false;

            if (getLocalNEGhost(i) != ilg.getLocalNEGhost(i))
                return false;

            for (size_t j = 0 ; j < getLocalNIGhost(i) ; j++)
            {
                if (getLocalIGhostE(i,j) != ilg.getLocalIGhostE(i,j))
                    return false;
                if (getLocalIGhostBox(i,j) != ilg.getLocalIGhostBox(i,j))
                    return false;
                if (getLocalIGhostSub(i,j) != ilg.getLocalIGhostSub(i,j))
                    return false;
            }
            for (size_t j = 0 ; j < getLocalNEGhost(i) ; j++)
            {
                if (getLocalEGhostBox(i,j) != ilg.getLocalEGhostBox(i,j))
                    return false;
                if (getLocalEGhostSub(i,j) != ilg.getLocalEGhostSub(i,j))
                    return false;
            }

        }

        return true;
    }



    bool is_equal_ng(ie_loc_ghost<dim,T,layout_base,Memory> & ilg)
    {
        return true;
    }

    void reset()
    {
        loc_ghost_box.clear();
        sub_domains_tmp.clear();
    }
};


#endif /* SRC_DECOMPOSITION_GHOST_DEC_IE_GHOST_HPP_ */