charge.hpp

Go to the documentation of this file.

#ifndef CHARGE_HPP
#define CHARGE_HPP
#include "space_settings.hpp"
#include "electric_field.hpp"
#include "xgc_io.hpp"

extern "C" void set_cden00_1d_fort(int npsi00, double* cden00_1d_h);

// Charge class
template<class Device, KinType KT>
class Charge {
    public:

    bool is_electrons;
    bool use_current; 

    // Host views
    View<double**,CLayout,HostType> density_h;
    View<double*,CLayout,HostType> density0_h;
    View<double*,CLayout,HostType> den00_1d_h;

    View<double**,CLayout,HostType> jpar_h;
    View<double*,CLayout,HostType> jpar0_h;
    
    View<double**,CLayout,HostType> den_f0_h;

    // Device views
    GridField<Device, VarType::Scalar,PIT_GLOBAL, TorType::OnePlane, KT, SCATTER_TYPE_GLOBAL> density; 
    GridField<Device, VarType::Scalar,PIT_GLOBAL, TorType::OnePlane, KT, SCATTER_TYPE_GLOBAL> jpar;    

    // Unmanaged View of the device views, for access when transposed
    View<double***,CLayout,Device,Kokkos::MemoryTraits<Kokkos::Unmanaged>> den_rho_ff;
    View<double***,CLayout,Device,Kokkos::MemoryTraits<Kokkos::Unmanaged>> jpar_rho_ff;

    // Default constructor
    Charge(){}

    // Constructor
    Charge(bool use_current, int nnode, int nphi, int nrho, int npsi00, bool is_electrons)
      : is_electrons(is_electrons),
        use_current(use_current),
          // Host views
          density_h("density_h", nphi, nnode),
          density0_h("density0_h", nnode),
          den00_1d_h("den00_1d_h", npsi00),

          jpar_h("jpar_h", nphi, use_current ? nnode : 0),
          jpar0_h("jpar0_h", use_current ? nnode : 0),

          den_f0_h("den_f0_h", nrho+1, nnode),

          // Device views
          density("density", 1, nrho, nnode), // nphi=1
          den_rho_ff((double*)(density.data()), nrho+1, nphi, nnode),

          jpar("jpar", 1, nrho, use_current ? nnode : 0), // nphi=1
          jpar_rho_ff((double*)(jpar.data()), nrho+1, nphi, use_current ? nnode : 0)
    {}

    void reset_to_zero(){
        density.reset_to_zero();
        if(use_current) jpar.reset_to_zero();
    }
};

struct Charges{
    Charge<DeviceType, KinType::DriftKin> electron;
    Charge<DeviceType, KinType::GyroKin> ion;

    View<double*,CLayout,HostType> cden00_1d_h;

    Charges(const Grid<DeviceType>& grid, const Simulation<DeviceType>& sml, int nrho){
        int nphi = (sml.is_XGCa ? 1 : 2);
        electron = Charge<DeviceType,KinType::DriftKin>(sml.explicit_electromagnetic, grid.nnode, nphi, 0, grid.psi00.n, true);
        ion = Charge<DeviceType,KinType::GyroKin>(sml.explicit_electromagnetic, grid.nnode, nphi, nrho, grid.psi00.n, false);
        cden00_1d_h = View<double*,CLayout,HostType>("cden00_1d_h", grid.psi00.n);
#ifndef NO_FORTRAN_MODULES
        set_cden00_1d_fort(grid.psi00.n, cden00_1d_h.data());
#endif
    }

    void read_checkpoint_files(const XGC_IO_Stream& stream){
        // Check whether variable is present in the checkpoint
        if(!XGC_IO::is_present<double>(stream, "edensity0")){
            return;
        }
        
        // Object to manage adding parameters/data and writing them
        XGC_IO xgc_io;

        xgc_io.add(
            IOArray("edensity0", electron.density0_h),
            IOArray("eden00_1d", electron.den00_1d_h)
        );
        
        // Read data
        xgc_io.read(stream);
    }

    void write_checkpoint_files(const XGC_IO_Stream& stream) const{
        // Object to manage adding parameters/data and writing them
        XGC_IO xgc_io;

        xgc_io.add(
            IOArray("edensity0", electron.density0_h),
            IOArray("eden00_1d", electron.den00_1d_h)
        );

        // Write data
        xgc_io.write(stream);
    }
};

#endif