guess_table.hpp

Go to the documentation of this file.

#ifndef GUESS_TABLE_HPP
#define GUESS_TABLE_HPP

extern "C" void init_guess_table_from_cpp(int n, int list_len, int* nguess_2, double* grid_guess_min, double* grid_guess_max, double* grid_inv_guess_d, int* list, int* xtable, int* count);

// Guess table
template<class Device>
struct GuessTable{
    int n;
    RZBounds bounds;
    double inv_d1;
    double inv_d2;
    View<int*,CLayout,Device> list;
    View<int**,CLayout,Device> xtable;
    View<int**,CLayout,Device> count;

    GuessTable(){}

    // Create a mirror with a different device type
    template<class Device2>
    inline GuessTable<Device2> mirror() const{
        GuessTable<Device2> m;

        m.n = n;
        m.bounds = bounds;
        m.inv_d1 = inv_d1;
        m.inv_d2 = inv_d2;

        m.list = my_mirror_view(list, Device2());
        mirror_copy(m.list, list);

        m.xtable = my_mirror_view(xtable, Device2());
        mirror_copy(m.xtable, xtable);

        m.count = my_mirror_view(count, Device2());
        mirror_copy(m.count, count);

        return m;
    }

    GuessTable(const RZBounds& bounds_in, const View<RZPair*,CLayout,Device>& gx, const View<Vertex*,CLayout,Device>& nodes, int guess_table_size)
      : n(guess_table_size),
        bounds(bounds_in),
        inv_d1(n/bounds.get_r_width()),
        inv_d2(n/bounds.get_z_width()),
        xtable( "guess_xtable", n,n),
        count( "guess_count", n,n)
    {

        if(is_rank_zero()){
            printf("\ninit_grid: Guess min %1.15e  %1.15e", bounds.min_r, bounds.min_z);
            printf("\ninit_grid: Guess max %1.15e  %1.15e", bounds.max_r, bounds.max_z);
        }

        int ntriangle = nodes.size();
        int nnode = gx.size();

        // Set up guess_xtable
        int nguess_2[2];
        nguess_2[0] = n;
        nguess_2[1] = n;

        double grid_guess_max[2];
        grid_guess_max[0] = bounds.max_r; grid_guess_max[1] = bounds.max_z;
        double grid_guess_min[2];
        grid_guess_min[0] = bounds.min_r; grid_guess_min[1] = bounds.min_z;

        // Calculated
        double grid_guess_d = (bounds.max_r - bounds.min_r)/n;
        double grid_inv_guess_d[2];
        grid_inv_guess_d[0] = inv_d1; grid_inv_guess_d[1] = inv_d2;

        View<int**, HostType> guess_xtable_tmp(NoInit("guess_xtable_tmp"),n,n);
        View<int**, HostType> guess_count_tmp(NoInit("guess_count_tmp"),n,n);

        int list_len;
        init_guess_xtable_fort( nguess_2, grid_guess_max, grid_guess_min, grid_inv_guess_d, &ntriangle, &nnode, gx.data(),
                                nodes.data(), guess_xtable_tmp.data(), guess_count_tmp.data(), &list_len);

        // Allocate guess_list_tmp after getting length from init_guess_xtable_fort
        View<int*, HostType> guess_list_tmp(NoInit("guess_list_tmp"),list_len);

        init_guess_list_fort( nguess_2, grid_guess_max, grid_guess_min, grid_inv_guess_d, &ntriangle, &nnode, gx.data(),
                                         nodes.data(), guess_list_tmp.data(), guess_xtable_tmp.data(), guess_count_tmp.data(),&list_len);

        // Initialize list here because the list length is determined in init_guess_xtable_fort
        list = View<int*,CLayout,Device>( "guess_list", list_len);

        Kokkos::deep_copy(xtable, guess_xtable_tmp);
        Kokkos::deep_copy(count, guess_count_tmp);
        Kokkos::deep_copy(list, guess_list_tmp);


#ifndef NO_FORTRAN_MODULES
        init_guess_table_from_cpp(n, list_len, nguess_2, grid_guess_min, grid_guess_max, grid_inv_guess_d, list.data(), xtable.data(), count.data());
#endif
    }
};

#endif