staggered_dist_grid.hpp

/*
 * staggered_grid.hpp
 *
 *  Created on: Aug 19, 2015
 *      Author: i-bird
 */
 
#ifndef SRC_GRID_STAGGERED_DIST_GRID_HPP_
#define SRC_GRID_STAGGERED_DIST_GRID_HPP_
 
#include "Grid/grid_dist_id.hpp"
#include "staggered_dist_grid_util.hpp"
#include "VTKWriter/VTKWriter.hpp"
#include "staggered_dist_grid_copy.hpp"
#include <boost/mpl/vector_c.hpp>
 
template<unsigned int dim, typename St, typename T, typename Decomposition=CartDecomposition<dim,St>,typename Memory=HeapMemory , typename device_grid=grid_cpu<dim,T>>
class staggered_grid_dist : public grid_dist_id<dim,St,T,Decomposition,Memory,device_grid>
{
    openfpm::vector<comb<dim>> c_prp[T::max_prop_real];
 
public:
 
    typedef T value_type;
 
    typedef typename grid_dist_id<dim,St,T,Decomposition,Memory,device_grid>::decomposition decomposition;
 
    static const unsigned int dims = dim;
 
    template<typename H> staggered_grid_dist(const grid_dist_id<dim,St,H,typename Decomposition::base_type,Memory,grid_cpu<dim,H>> & g,
                                      const Ghost<dim,long int> & gh,
                                      Box<dim,size_t> ext)
    :grid_dist_id<dim,St,T,Decomposition,Memory,device_grid>(g,gh,ext)
    {
    }
 
    staggered_grid_dist(const size_t (& g_sz)[dim],
                        const Box<dim,St> & domain,
                        const Ghost<dim,St> & ghost)
    :grid_dist_id<dim,St,T,Decomposition,Memory,device_grid>(g_sz,domain,ghost)
    {}
 
    staggered_grid_dist(const size_t (& g_sz)[dim],
                        const Box<dim,St> & domain,
                        const Ghost<dim,long int> & ghost)
    :grid_dist_id<dim,St,T,Decomposition,Memory,device_grid>(g_sz,domain,ghost)
    {}
 
    staggered_grid_dist(const size_t (& g_sz)[dim],const Box<dim,St> & domain,
                 const Ghost<dim,long int> & g, const periodicity<dim> & p)
    :grid_dist_id<dim,St,T,Decomposition,Memory,device_grid>(g_sz,domain,g,p)
    {
    }
 
    staggered_grid_dist(const Decomposition & dec, const size_t (& g_sz)[dim],
                 const Ghost<dim,long int> & g)
    :grid_dist_id<dim,St,T,Decomposition,Memory,device_grid>(dec,g_sz,g)
    {}
 
    staggered_grid_dist(const Decomposition & dec,
                 const size_t (& g_sz)[dim],
                 const Ghost<dim,St> & ghost)
    :grid_dist_id<dim,St,T,Decomposition,Memory,device_grid>(dec,g_sz,ghost)
    {}
 
    template<unsigned int p> void setStagPosition(openfpm::vector<comb<dim>> & cmb)
    {
#ifdef SE_CLASS1
        if (extends< typename boost::mpl::at<typename T::type,boost::mpl::int_<p> >::type >::mul() > cmb.size())
            std::cerr << __FILE__ << ":" << __LINE__ << " error properties has " << extends< typename boost::mpl::at<typename T::type,boost::mpl::int_<p> >::type >::mul() << " components, but " << cmb.size() << "has been defined \n";
#endif
        c_prp[p] = cmb;
    }
 
    void setDefaultStagPosition()
    {
        // for each properties
 
        stag_set_position<dim,typename T::type_real> ssp(c_prp);
 
        boost::mpl::for_each_ref< boost::mpl::range_c<int,0,T::max_prop_real> >(ssp);
    }
 
    template<typename Grid_dst ,unsigned int ... pos> bool to_normal(Grid_dst & g_dst, const Padding<dim> & pd, const long int (& start)[dim], const long int (& stop)[dim])
    {
        // interpolation points for each property
        openfpm::vector<std::vector<comb<dim>>> interp_pos[sizeof...(pos)];
 
        typedef boost::mpl::vector_c<unsigned int,pos ... > v_pos_type;
 
        interp_points<dim,T::max_prop_real,v_pos_type,typename Grid_dst::value_type::type> itp(interp_pos,c_prp);
        boost::mpl::for_each_ref<v_pos_type>(itp);
 
        // shift the start and stop by the padding
        grid_key_dx<dim> start_k = grid_key_dx<dim>(start);
        grid_key_dx<dim> stop_k = grid_key_dx<dim>(stop);
 
        // sub-grid iterator over the grid map
        auto g_map_it = this->getSubDomainIterator(start_k,stop_k);
 
        // Iterator over the destination grid
        auto g_dst_it = g_dst.getDomainIterator();
 
        // Check that the 2 iterator has the same size
        checkIterator<Grid_dst,decltype(g_map_it),decltype(g_dst_it)>(g_map_it,g_dst_it);
 
        while (g_map_it.isNext() == true)
        {
            typedef typename to_boost_vmpl<pos...>::type vid;
            typedef boost::mpl::size<vid> v_size;
 
            auto key_src = g_map_it.get();
 
            // destination point
            auto key_dst = g_dst_it.get();
 
            // Transform this id into an id for the Eigen vector
 
            interp_ele<vid,Grid_dst,typename std::remove_reference<decltype(*this)>::type,sizeof...(pos)> cp(key_dst,g_dst,*this,key_src,interp_pos);
 
            // For each property in the target grid
            boost::mpl::for_each_ref<boost::mpl::range_c<int,0,v_size::value>>(cp);
 
            ++g_map_it;
            ++g_dst_it;
        }
 
        return true;
    }
 
    const openfpm::vector<comb<dim>>  (& getStagPositions()) [T::max_prop]
    {
        return c_prp;
    }
 
    void write(std::string str)
    {
        stag_create_and_add_grid<dim,staggered_grid_dist<dim,St,T,Decomposition,Memory,device_grid>,St> sgw(*this, this->getVC().getProcessUnitID());
 
        boost::mpl::for_each_ref< boost::mpl::range_c<int,0,T::max_prop> >(sgw);
    }
 
    bool is_staggered_prop(size_t prp)
    {
        return c_prp[prp].size() != 0;
    }
 
    bool is_staggered() const
    {
        return true;
    }
 
    friend class stag_create_and_add_grid<dim,staggered_grid_dist<dim,St,T,Decomposition,Memory,device_grid>,St>;
};
 
#endif /* SRC_GRID_STAGGERED_DIST_GRID_HPP_ */