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"
 
// 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> density00_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 use_fsa_den, bool is_electrons)
      : is_electrons(is_electrons),
        use_current(use_current),
          // Host views
          density_h("density_h", nphi, nnode),
          density0_h("density0_h", nnode),
          density00_h("density00_h", use_fsa_den ? nnode : 0),
          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> rhs_offset0_h; 
 
    View<double*,CLayout,HostType> cden00_1d_h;
 
    Charges(){}
 
    Charges(const Grid<DeviceType>& grid, const Simulation<DeviceType>& sml, int nrho)
      : electron(sml.explicit_electromagnetic, grid.nnode, (sml.is_XGCa ? 1 : 2), 0,    grid.psi00.n, !grid.axisymmetric, true),
        ion(     sml.explicit_electromagnetic, grid.nnode, (sml.is_XGCa ? 1 : 2), nrho, grid.psi00.n, !grid.axisymmetric, false),
        rhs_offset0_h("rhs_offset0_h", grid.nnode),
        cden00_1d_h("cden00_1d_h", grid.psi00.n)
    {}
 
    void read_checkpoint_files(const XGC_IO_Stream& stream){
        // Check whether variable is present in the checkpoint
        bool is_present_edensity0 = XGC_IO::is_present<double>(stream, "edensity0");
        bool is_present_rhs_offset0 = XGC_IO::is_present<double>(stream, "rhs_offset0");
 
        if(!is_present_edensity0 && !is_present_rhs_offset0){
            return;
        }
        
        // Object to manage adding parameters/data and writing them
        XGC_IO xgc_io;
 
        if(is_present_edensity0){ // for backward compatibility despite the version of restart file.
            xgc_io.add(
                IOArray("edensity0", rhs_offset0_h)
            );
        }
        else if(is_present_rhs_offset0){
            xgc_io.add(
                IOArray("rhs_offset0", rhs_offset0_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("rhs_offset0", rhs_offset0_h)
        );
 
        // Write data
        xgc_io.write(stream);
    }
};
 
#endif