distribution.hpp

Go to the documentation of this file.

#ifndef DISTRIBUTION_HPP
#define DISTRIBUTION_HPP

#include <Kokkos_Core.hpp>
#include "space_settings.hpp"
#include "globals.hpp"
#include "velocity_grid.hpp"
#include "domain_decomposition.hpp"

template<class Device>
struct Distribution{

    // Suffix _h to distinguish the host versions
    // Local Domain arrays
    View<double***,CLayout, Kokkos::HostSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged>> f0g_h;
    View<double***,CLayout,Device> f0g;

    View<double*,Kokkos::HostSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged>> fg_temp_ev_h;
    View<double*,CLayout,Device> fg_temp_ev;

    View<double*,Kokkos::HostSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged>> fg_flow_h;
    View<double*,CLayout,Device> fg_flow;

    View<double*,Kokkos::HostSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged>> fg_vth_inv_h;
    View<double*,CLayout,Device> fg_vth_inv;


    View<double*,Kokkos::HostSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged>> grid_vol_h;
    View<double*,CLayout,Device> grid_vol;

    View<double*,Kokkos::HostSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged>> grid_vol_vonly_h;
    View<double*,CLayout,Device> grid_vol_vonly;

    View<double*,Kokkos::HostSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged>> inv_grid_vol_h;
    View<double*,CLayout,Device> inv_grid_vol;

    // following strucutre variables are related to f_Maxwellian
    View<double*,Kokkos::HostSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged>> temp_ev_h;
    View<double*,CLayout,Device> temp_ev;

    View<double*,Kokkos::HostSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged>> flow_h;
    View<double*,CLayout,Device> flow;

    View<double*,Kokkos::HostSpace, Kokkos::MemoryTraits<Kokkos::Unmanaged>> den_h;
    View<double*,CLayout,Device> den;

    // Plane Domain arrays
    View<double*,CLayout,HostType, Kokkos::MemoryTraits<Kokkos::Unmanaged>> delta_n_h;
    View<double*,CLayout,Device> delta_n;

    View<double*,CLayout,HostType, Kokkos::MemoryTraits<Kokkos::Unmanaged>> delta_u_h;
    View<double*,CLayout,Device> delta_u;

    View<double*,CLayout,HostType, Kokkos::MemoryTraits<Kokkos::Unmanaged>> delta_T_h;
    View<double*,CLayout,Device> delta_T;

    View<double*,CLayout, HostType> den_global_h;
    View<double*,CLayout,Device> den_global;

    View<double*,CLayout, HostType> temp_global_h;
    View<double*,CLayout,Device> temp_global;

    View<double*,CLayout, HostType> flow_global_h;
    View<double*,CLayout,Device> flow_global;

    bool fg_temp_global_assigned=false; // flag to check fg_temp_global is assigned
    View<double*,CLayout, HostType> fg_temp_global_h;
    View<double*,CLayout,Device> fg_temp_global;

    Distribution(){}

    void f0g_send_to_device(){
        f0g = View<double***,CLayout,Device>(NoInit("f0g"), f0g_h.layout());
        Kokkos::deep_copy(f0g, f0g_h);
    }

    void fg_temp_ev_send_to_device(){
        fg_temp_ev = View<double*,CLayout,Device>(NoInit("fg_temp_ev"), fg_temp_ev_h.layout());
        Kokkos::deep_copy(fg_temp_ev, fg_temp_ev_h);
    }

    void fg_flow_send_to_device(){
        fg_flow = View<double*,CLayout,Device>(NoInit("fg_flow"), fg_flow_h.layout());
        Kokkos::deep_copy(fg_flow, fg_flow_h);
    }

    void fg_vth_inv_send_to_device(){
        fg_vth_inv = View<double*,CLayout,Device>(NoInit("fg_vth_inv"), fg_vth_inv_h.layout());
        Kokkos::deep_copy(fg_vth_inv, fg_vth_inv_h);
    }

    void temp_ev_send_to_device(){
        temp_ev = View<double*,CLayout,Device>(NoInit("temp_ev"), temp_ev_h.layout());
        Kokkos::deep_copy(temp_ev, temp_ev_h);
    }

    void den_send_to_device(){
        den = View<double*,CLayout,Device>(NoInit("den"), den_h.layout());
        Kokkos::deep_copy(den, den_h);
    }

    void flow_send_to_device(){
        flow = View<double*,CLayout,Device>(NoInit("flow"), flow_h.layout());
        Kokkos::deep_copy(flow, flow_h);
    }

    void grid_vol_send_to_device(){
        grid_vol = View<double*,CLayout,Device>(NoInit("grid_vol"), grid_vol_h.layout());
        Kokkos::deep_copy(grid_vol, grid_vol_h);
    }
    
    void grid_vol_vonly_send_to_device(){
        grid_vol_vonly = View<double*,CLayout,Device>(NoInit("grid_vol_vonly"), grid_vol_vonly_h.layout());
        Kokkos::deep_copy(grid_vol_vonly, grid_vol_vonly_h);
    }
    
    void inv_grid_vol_send_to_device(){
        inv_grid_vol = View<double*,CLayout,Device>(NoInit("inv_grid_vol"), inv_grid_vol_h.layout());
        Kokkos::deep_copy(inv_grid_vol, inv_grid_vol_h);
    }
    
    void delta_n_send_to_device(){
        delta_n = View<double*,CLayout,Device>(NoInit("delta_n"), delta_n_h.layout());
        Kokkos::deep_copy(delta_n, delta_n_h);
    }

    void delta_u_send_to_device(){
        delta_u = View<double*,CLayout,Device>(NoInit("delta_u"), delta_u_h.layout());
        Kokkos::deep_copy(delta_u, delta_u_h);
    }

    void delta_T_send_to_device(){
        delta_T = View<double*,CLayout,Device>(NoInit("delta_T"), delta_T_h.layout());
        Kokkos::deep_copy(delta_T, delta_T_h);
    }

    void den_global_send_to_device(){
        den_global = View<double*,CLayout,Device>(NoInit("den_global"), den_global_h.layout());
        Kokkos::deep_copy(den_global, den_global_h);
    }

    void temp_global_send_to_device(){
        temp_global = View<double*,CLayout,Device>(NoInit("temp_global"), temp_global_h.layout());
        Kokkos::deep_copy(temp_global, temp_global_h);
    }

    void flow_global_send_to_device(){
        flow_global = View<double*,CLayout,Device>(NoInit("flow_global"), flow_global_h.layout());
        Kokkos::deep_copy(flow_global, flow_global_h);
    }

    void fg_temp_global_send_to_device(){
        fg_temp_global = View<double*,CLayout,Device>(NoInit("fg_temp_global"), fg_temp_global_h.layout());
        Kokkos::deep_copy(fg_temp_global, fg_temp_global_h);
    }

    // Deallocates all device views (doesn't matter if they are already deallocated)
    void deallocate_device_views(){
        f0g = View<double***,CLayout,Device>();

        fg_temp_ev = View<double*,CLayout,Device>();
        fg_flow = View<double*,CLayout,Device>();
        fg_vth_inv = View<double*,CLayout,Device>();

        grid_vol = View<double*,CLayout,Device>();
        grid_vol_vonly = View<double*,CLayout,Device>();
        inv_grid_vol = View<double*,CLayout,Device>();

        //F_M below
        temp_ev = View<double*,CLayout,Device>();
        flow = View<double*,CLayout,Device>();
        den = View<double*,CLayout,Device>();

        delta_n = View<double*,CLayout,Device>();
        delta_u = View<double*,CLayout,Device>();
        delta_T = View<double*,CLayout,Device>();

        den_global = View<double*,CLayout,Device>();
        temp_global = View<double*,CLayout,Device>();
    }
};
#endif