electric_field.hpp

Go to the documentation of this file.

#ifndef ELECTRIC_FIELD_HPP
#define ELECTRIC_FIELD_HPP
#include "space_settings.hpp"
#include "grid.hpp"
#include "linear_weights.hpp"
#include "local_fields.hpp"

//Struct used for E_phi_ff, dAs_phi_ff, dAh_phi_ff, As_phi_ff, Ah_phi_ff. 3 vector components, 2 contributing planes 
struct VectorFieldPlanes {
    double V[3][2];
};

// Same as VectorFieldPlanes, but the dimensions are reversed. Should remove this when possible - ALS
struct InvVectorFieldPlanes {
    double V[2][3];
};

//Struct used for E00_ff. 2 vector components, 2 contributing planes
struct Vector2DFieldPlanes {
    double V[2][2];
};

//Struct used for ddpotdt_phi, As_phi_ff, Ah_phi_ff, Ah_cv for EM.  2 contributing planes
struct ScalarFieldPlanes {
    double S[2];
}; 

// Struct used for E_rho. 2 vector components (r,z) --> can be combined to ScalarFieldPlanes
struct FieldXGCa {
    double E[2];
};

// Electric field class
template<class Device>
struct ElectricField {

    // Dimensions
    int nnode;
    int nphi;
    int nrho;

    // Field variables
    bool turb_efield;      

#ifdef XGC1
    Kokkos::View<VectorFieldPlanes**,Kokkos::LayoutRight,Device> E_phi_ff;
    Kokkos::View<InvVectorFieldPlanes**,Kokkos::LayoutRight,Device> E_rho_ff;
    Kokkos::View<ScalarFieldPlanes*,Kokkos::LayoutRight,Device> dpot_ff;
#ifdef DELTAF_CONV
    Kokkos::View<Vector2DFieldPlanes*,Kokkos::LayoutRight,Device> E00_ff;
    Kokkos::View<ScalarFieldPlanes**,Kokkos::LayoutRight,Device> ddpotdt_phi;
#endif
#ifdef EXPLICIT_EM
    //For EM
    Kokkos::View<VectorFieldPlanes**,Kokkos::LayoutRight,Device> dAh_phi_ff;
    Kokkos::View<InvVectorFieldPlanes**,Kokkos::LayoutRight,Device> dAh_rho_ff;
    Kokkos::View<ScalarFieldPlanes**,Kokkos::LayoutRight,Device> Ah_phi_ff;
    Kokkos::View<ScalarFieldPlanes**,Kokkos::LayoutRight,Device> Ah_rho_ff;
    Kokkos::View<VectorFieldPlanes**,Kokkos::LayoutRight,Device> dAs_phi_ff;
    Kokkos::View<InvVectorFieldPlanes**,Kokkos::LayoutRight,Device> dAs_rho_ff;
    Kokkos::View<ScalarFieldPlanes**,Kokkos::LayoutRight,Device> As_phi_ff;
    Kokkos::View<ScalarFieldPlanes**,Kokkos::LayoutRight,Device> As_rho_ff;
    Kokkos::View<ScalarFieldPlanes**,Kokkos::LayoutRight,Device> Ah_cv_phi_ff;
    Kokkos::View<ScalarFieldPlanes**,Kokkos::LayoutRight,Device> Epar_em_phi_ff;
    Kokkos::View<ScalarFieldPlanes**,Kokkos::LayoutRight,Device> Epar_em_rho_ff;

    Kokkos::View<double*,Kokkos::LayoutRight,Device> dpot_n0;
#endif // end of EXPLICIT_EM
#else
    Kokkos::View<FieldXGCa**,Kokkos::LayoutRight,Device> E_rho;
    Kokkos::View<double*,Kokkos::LayoutRight,Device> dpot;
#endif

    // Default constructor
    ElectricField(){}


    ElectricField(bool turb_efield_in, int nnode_in, int nphi_in, int nrho_in) :
#ifdef XGC1
      E_phi_ff("E_phi_ff",0,0),
      E_rho_ff("E_rho_ff",0,0),
#  ifdef DELTAF_CONV 
      E00_ff("E00_ff",nnode_in),
      ddpotdt_phi("ddpotdt_phi",0,0),
#  endif
#  ifdef EXPLICIT_EM
      dAs_phi_ff("dAs_phi_ff",0,0),
      dAs_rho_ff("dAs_rho_ff",0,0),
      dAh_phi_ff("dAh_phi_ff",0,0),
      dAh_rho_ff("dAh_rho_ff",0,0),
      As_phi_ff("As_phi_ff",0,0),
      As_rho_ff("As_rho_ff",0,0),
      Ah_phi_ff("Ah_phi_ff",0,0),
      Ah_rho_ff("Ah_rho_ff",0,0),
      Ah_cv_phi_ff("Ah_cv_phi_ff",0,0),
      Epar_em_phi_ff("Epar_em_phi_ff",0,0),
      Epar_em_rho_ff("Epar_em_rho_ff",0,0),
      dpot_n0("dpot_n0",nnode_in),
#  endif
      dpot_ff("dpot_ff",nnode_in),
#else
      E_rho("E_rho",nnode_in,nrho+1),
      dpot("dpot",nnode_in),
#endif
      turb_efield(turb_efield_in),
      nnode(nnode_in),
      nphi(nphi_in),
      nrho(nrho_in)
    {}

#ifdef XGC1
    // Resizes allocations for large arrays that have a phi dimension (i.e used for electron push)
    void allocate_phi_fields_on_device(){
        Kokkos::resize(E_phi_ff,nphi, nnode);
#  ifdef DELTAF_CONV 
        Kokkos::resize(ddpotdt_phi,nphi,nnode);
#  endif
#  ifdef EXPLICIT_EM
        Kokkos::resize(dAs_phi_ff,nphi,nnode);
        Kokkos::resize(dAh_phi_ff,nphi,nnode);
        Kokkos::resize(As_phi_ff,nphi,nnode);
        Kokkos::resize(Ah_phi_ff,nphi,nnode);
        Kokkos::resize(Ah_cv_phi_ff,nphi,nnode);
        Kokkos::resize(Epar_em_phi_ff,nphi,nnode);
#  endif
    }

    // Resizes allocations that have a phi dimension to 0, to make room for other data on the device
    void deallocate_phi_fields_on_device(){
        Kokkos::resize(E_phi_ff,0,0);
#  ifdef DELTAF_CONV
        Kokkos::resize(ddpotdt_phi,0,0);
#  endif
#  ifdef EXPLICIT_EM
        Kokkos::resize(dAs_phi_ff,0,0);
        Kokkos::resize(dAh_phi_ff,0,0);
        Kokkos::resize(As_phi_ff,0,0);
        Kokkos::resize(Ah_phi_ff,0,0);
        Kokkos::resize(Ah_cv_phi_ff,0,0);
        Kokkos::resize(Epar_em_phi_ff,0,0);
#  endif
    }

    // Resizes allocations for large arrays that have a rho dimension (i.e used for ions)
    void allocate_rho_fields_on_device(){
        Kokkos::resize(E_rho_ff, nnode,nrho+1);
#  ifdef EXPLICIT_EM
        Kokkos::resize(dAs_rho_ff,nnode,nrho+1);
        Kokkos::resize(dAh_rho_ff,nnode,nrho+1);
        Kokkos::resize(As_rho_ff,nnode,nrho+1);
        Kokkos::resize(Ah_rho_ff,nnode,nrho+1);
        Kokkos::resize(Epar_em_rho_ff,nnode,nrho+1);
#  endif
    }

    // Resizes allocations that have a rho dimension to 0, to make room for other data on the device
    void deallocate_rho_fields_on_device(){
        Kokkos::resize(E_rho_ff,0,0);
#  ifdef EXPLICIT_EM
        Kokkos::resize(dAs_rho_ff,0,0);
        Kokkos::resize(dAh_rho_ff,0,0);
        Kokkos::resize(As_rho_ff,0,0);
        Kokkos::resize(Ah_rho_ff,0,0);
        Kokkos::resize(Epar_em_rho_ff,0,0);
#  endif
    }

#  ifdef EXPLICIT_EM
    /* Set of functions used to allocate/deallocate gpu memory for Ah during particle scatters */
    // Resizes allocation of Ah_cv
    void allocate_Ah_cv_on_device(){
        Kokkos::resize(Ah_cv_phi_ff,nphi,nnode);
    }

    // Resizes Ah_cv to 0
    void deallocate_Ah_cv_on_device(){
        Kokkos::resize(Ah_cv_phi_ff,0,0);
    }

    void allocate_Ah_phi_ff_on_device(){
        Kokkos::resize(Ah_phi_ff,nphi,nnode);
    }

    // Resizes Ah_phi_ff to 0
    void deallocate_Ah_phi_ff_on_device(){
        Kokkos::resize(Ah_phi_ff,0,0);
    }

    // Resizes allocation of Ah_rho_ff
    void allocate_Ah_rho_ff_on_device(){
        Kokkos::resize(Ah_rho_ff,nnode,nrho+1);
    }

    // Resizes Ah_rho_ff to 0
    void deallocate_Ah_rho_ff_on_device(){
        Kokkos::resize(Ah_rho_ff,0,0);
    }
#  endif
#endif

};

#endif