SphericalYeeAlgorithm.H

Go to the documentation of this file.

/* Copyright 2020 Remi Lehe
 *
 * This file is part of WarpX.
 *
 * License: BSD-3-Clause-LBNL
 */
 
#ifndef WARPX_FINITE_DIFFERENCE_ALGORITHM_SPHERICAL_YEE_H_
#define WARPX_FINITE_DIFFERENCE_ALGORITHM_SPHERICAL_YEE_H_
 
#include "Utils/WarpXConst.H"
 
#include <AMReX.H>
#include <AMReX_Array4.H>
#include <AMReX_Gpu.H>
#include <AMReX_REAL.H>
 
#include <array>
#include <cmath>
 

struct SphericalYeeAlgorithm {
 
    static void InitializeStencilCoefficients (
        std::array<amrex::Real,3>& cell_size,
        amrex::Vector<amrex::Real>& stencil_coefs_r) {
 
        using namespace amrex::literals;
        // Store the inverse cell size along each direction in the coefficients
        stencil_coefs_r.resize(1);
        stencil_coefs_r[0] = 1._rt/cell_size[0];  // 1./dr
    }

    static amrex::Real ComputeMaxDt (amrex::Real const * const dx) {
        using namespace amrex::literals;
        // The numerical value of the max Dt below was determined empirically (for one case)
        const amrex::Real delta_t = 0.78_rt * dx[0] / PhysConst::c;
        return delta_t;
    }

    static amrex::IntVect GetMaxGuardCell () {
        // The spherical solver requires one guard cell in each dimension
        return amrex::IntVect{AMREX_D_DECL(1,1,1)};
    }

    AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    static amrex::Real UpwardDrr_over_r (
        amrex::Array4<amrex::Real const> const& F,
        amrex::Real const r, amrex::Real const dr,
        amrex::Real const * const coefs_r, int const n_coefs_r,
        int const i, int const j, int const k, int const comp ) {
 
        using namespace amrex::literals;
        amrex::ignore_unused(n_coefs_r);
 
        amrex::Real const inv_dr = coefs_r[0];
        return 1._rt/r * inv_dr*( (r+0.5_rt*dr)*F(i+1,j,k,comp) - (r-0.5_rt*dr)*F(i,j,k,comp) );
    }

    AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    static amrex::Real DownwardDrr2_over_r2 (
        amrex::Array4<amrex::Real const> const& F,
        amrex::Real const r, amrex::Real const dr,
        amrex::Real const * const coefs_r, int const n_coefs_r,
        int const i, int const j, int const k, int const comp ) {
 
        using namespace amrex::literals;
        amrex::ignore_unused(n_coefs_r);
 
        amrex::Real const inv_dr = coefs_r[0];
        amrex::Real const rph = r + 0.5_rt*dr;
        amrex::Real const rmh = r - 0.5_rt*dr;
        return 1._rt/(r*r) * inv_dr*( rph*rph*F(i,j,k,comp) - rmh*rmh*F(i-1,j,k,comp) );
    }

    AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    static amrex::Real DownwardDrr_over_r (
        amrex::Array4<amrex::Real const> const& F,
        amrex::Real const r, amrex::Real const dr,
        amrex::Real const * const coefs_r, int const n_coefs_r,
        int const i, int const j, int const k, int const comp ) {
 
        using namespace amrex::literals;
        amrex::ignore_unused(n_coefs_r);
 
        amrex::Real const inv_dr = coefs_r[0];
        return 1._rt/r * inv_dr*( (r+0.5_rt*dr)*F(i,j,k,comp) - (r-0.5_rt*dr)*F(i-1,j,k,comp) );
    }

    AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    static amrex::Real UpwardDr (
        amrex::Array4<amrex::Real const> const& F,
        amrex::Real const * const coefs_r, int const n_coefs_r,
        int const i, int const j, int const k, int const comp ) {
 
        amrex::ignore_unused(n_coefs_r);
 
        amrex::Real const inv_dr = coefs_r[0];
        return inv_dr*( F(i+1,j,k,comp) - F(i,j,k,comp) );
    }

    AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    static amrex::Real DownwardDr (
        amrex::Array4<amrex::Real const> const& F,
        amrex::Real const * const coefs_r, int const n_coefs_r,
        int const i, int const j, int const k, int const comp ) {
 
        amrex::ignore_unused(n_coefs_r);
 
        amrex::Real const inv_dr = coefs_r[0];
        return inv_dr*( F(i,j,k,comp) - F(i-1,j,k,comp) );
    }
 
};
 
#endif // WARPX_FINITE_DIFFERENCE_ALGORITHM_SPHERICAL_YEE_H_