grid_common.hpp

/*
 * grid_common.hpp
 *
 *  Created on: Oct 31, 2015
 *      Author: i-bird
 */
 
#ifndef OPENFPM_DATA_SRC_GRID_GRID_COMMON_HPP_
#define OPENFPM_DATA_SRC_GRID_GRID_COMMON_HPP_
 
#include <type_traits>
#include "util/tokernel_transformation.hpp"
 
template<typename aggrT_src, typename local_grids_type>
struct setBackground_impl
{
    aggrT_src & bck;
 
    local_grids_type & loc_grid;
 
    inline setBackground_impl(aggrT_src & bck, local_grids_type & loc_grid)
    :bck(bck),loc_grid(loc_grid)
    {};
 
    template<typename T>
    inline void operator()(T& t)
    {
        for (size_t i = 0 ; i < loc_grid.size() ; i++)
        {
            loc_grid.get(i).template setBackgroundValue<T::value>(bck.template get<T::value>());
        }
    }
};
 
 
 
template<typename T, typename T_ker, typename type_prp, template<typename> class layout_base , int is_vector>
struct call_recursive_destructor_if_vector
{
    template<typename mem_type, typename obj_type> static void destruct(mem_type * mem, obj_type & obj)
    {
        size_t sz = mem->size() / sizeof(type_prp);
        // The type of device and the type on host does not match (in general)
        // So we have to convert before transfer
 
        mem_type tmp;
 
        tmp.allocate(mem->size());
 
        mem->deviceToHost(tmp);
        T_ker * ptr = static_cast<T_ker *>(tmp.getPointer());
 
        for(size_t i = 0 ; i < sz ; i++)
        {
            ptr->~T_ker();
            ++ptr;
        }
    }
};
 
template<typename T, typename T_ker, typename type_prp ,template<typename> class layout_base>
struct call_recursive_destructor_if_vector<T,T_ker,type_prp,layout_base,0>
{
    template<typename mem_type,typename obj_type> static void destruct(mem_type * mem, obj_type & obj)
    {}
};
 
template<typename T, typename T_ker, typename type_prp ,template<typename> class layout_base>
struct call_recursive_destructor_if_vector<T,T_ker,type_prp,layout_base,3>
{
    template<typename mem_type,typename obj_type> static void destruct(mem_type * mem, obj_type & obj)
    {}
};
 
template<typename T, typename T_ker, typename type_prp ,template<typename> class layout_base>
struct call_recursive_destructor_if_vector<T,T_ker,type_prp,layout_base,4>
{
    template<typename mem_type,typename obj_type> static void destruct(mem_type * mem, obj_type & obj)
    {}
};
 
 
template<unsigned int dim, typename S, typename Memory>
struct copy_cpu_encap
{
    grid_key_dx<dim> & key;
 
    S & grid_dst;
 
    typedef typename S::value_type obj_type;
 
    typedef typename S::value_type::type ov_seq;
 
    const encapc<1,obj_type,Memory> & obj;
 
    inline copy_cpu_encap(grid_key_dx<dim> & key, S & grid_dst, const encapc<1,obj_type,Memory> & obj)
    :key(key),grid_dst(grid_dst),obj(obj){};
 
 
#ifdef SE_CLASS1
    inline copy_cpu_encap(grid_key_dx<dim> & key, S & grid_dst, const encapc<1,obj_type,Memory> && obj)
    :key(key),grid_dst(grid_dst),obj(obj)
    {std::cerr << "Error: " <<__FILE__ << ":" << __LINE__ << " Passing a temporal object";};
#endif
 
    template<typename T>
    inline void operator()(T& t) const
    {
        // Remove the reference from the type to copy
        typedef typename boost::remove_reference<decltype(grid_dst.template get<T::value>(key))>::type copy_rtype;
 
        meta_copy<copy_rtype>::meta_copy_(obj.template get<T::value>(),grid_dst.template get<T::value>(key));
    }
};
 
 
template<typename T>
struct mem_reference
{
    typedef T& type;
};
 
enum rem_copy_opt
{
    NONE_OPT = 0,
    PHASE1 = 0,
    PHASE2 = 1,
    PHASE3 = 2,
    // This option indicate that the geometrical structure of the sparse-grid has not changed
    KEEP_GEOMETRY = 4,
};
 
#endif /* OPENFPM_DATA_SRC_GRID_GRID_COMMON_HPP_ */