mul.hpp

/*
 * mul.hpp
 *
 *  Created on: Oct 22, 2015
 *      Author: i-bird
 */
 
#ifndef OPENFPM_NUMERICS_SRC_FINITEDIFFERENCE_MUL_HPP_
#define OPENFPM_NUMERICS_SRC_FINITEDIFFERENCE_MUL_HPP_
 
#include <typeinfo>
#include "util/util_debug.hpp"
#include "util/util_num.hpp"
 
#define HAS_VAL 1
#define HAS_POS_VAL 2
 
template <unsigned int, typename T>
struct has_val
{
    static float call_val()
    {
        std::cerr << "Error the type " << demangle(typeid(T).name()) << "interpreted as constant field, does not have a function val() or val_pos(), please see the numeric examples in Finite Differences for more information\n";
        return 0;
    }
};
 
template <typename T>
struct has_val<HAS_VAL,T>
{
    static decltype(T::val()) call_val()
    {
        return T::val();
    }
};
 
template<typename v_expr>
struct const_mul_functor_value
{
    typedef boost::mpl::size<v_expr> size;
 
    typedef typename boost::mpl::at<v_expr,boost::mpl::int_<size::value-1> >::type last;
 
    std::unordered_map<long int,typename last::stype> & cols;
 
    const grid_sm<last::dims,void> & gs;
 
    const grid_dist_id<last::dims,typename last::stype,aggregate<size_t>,typename last::b_grid::decomposition::extended_type> & g_map;
 
    grid_dist_key_dx<last::dims> & kmap;
 
    typename last::stype coeff;
 
    typename last::stype (& spacing)[last::dims];
 
    const_mul_functor_value(const grid_dist_id<last::dims,typename last::stype,aggregate<size_t>,typename last::b_grid::decomposition::extended_type> & g_map,
                            grid_dist_key_dx<last::dims> & kmap,
                            const grid_sm<last::dims,void> & gs,
                            typename last::stype (& spacing)[last::dims],
                            std::unordered_map<long int,typename last::stype> & cols,
                            typename last::stype coeff)
    :cols(cols),gs(gs),g_map(g_map),kmap(kmap),coeff(coeff),spacing(spacing)
    {};
 
 
 
    template<typename T>
    void operator()(T& t)
    {
        typedef typename boost::mpl::at<v_expr, boost::mpl::int_<T::value> >::type cfield;
 
        coeff *= has_val<is_const_field<cfield>::value * 1,cfield>::call_val();
    }
 
    typename last::stype getCoeff()
    {
        return coeff;
    }
};
 
template<typename ... expr >
struct mul
{
    typedef boost::mpl::vector<expr... > v_expr;
 
    typedef typename boost::mpl::size<v_expr>::type v_sz;
 
    typedef typename boost::mpl::at<v_expr, boost::mpl::int_<v_sz::type::value - 1> >::type Sys_eqs;
 
    inline static void value(const grid_dist_id<Sys_eqs::dims,typename Sys_eqs::stype,aggregate<size_t>,typename Sys_eqs::b_grid::decomposition::extended_type> & g_map,
                             grid_dist_key_dx<Sys_eqs::dims> & kmap,
                             const grid_sm<Sys_eqs::dims,void> & gs,
                             typename Sys_eqs::stype (& spacing )[Sys_eqs::dims],
                             std::unordered_map<long int,typename Sys_eqs::stype > & cols,
                             typename Sys_eqs::stype coeff)
    {
        const_mul_functor_value<v_expr> mfv(g_map,kmap,gs,spacing,cols,coeff);
 
        //
        boost::mpl::for_each_ref< boost::mpl::range_c<int,0,v_sz::type::value - 2> >(mfv);
 
        typedef typename boost::mpl::at< v_expr ,boost::mpl::int_<v_sz::value-2> >::type last_m;
 
        last_m::value(g_map,kmap,gs,spacing,cols,mfv.coeff);
    }
 
    inline static grid_key_dx<Sys_eqs::dims> position(grid_key_dx<Sys_eqs::dims> & pos,
                                                      const grid_sm<Sys_eqs::dims,void> & gs,
                                                      const comb<Sys_eqs::dims> (& s_pos)[Sys_eqs::nvar])
    {
        return boost::mpl::at<v_expr, boost::mpl::int_<v_sz::type::value - 2> >::type::position(pos,gs,s_pos);
    }
};
 
 
#endif /* OPENFPM_NUMERICS_SRC_FINITEDIFFERENCE_MUL_HPP_ */