SpectralSolver.H

Go to the documentation of this file.

/* Copyright 2019-2020 Maxence Thevenet, Remi Lehe, Edoardo Zoni
 *
 * This file is part of WarpX.
 *
 * License: BSD-3-Clause-LBNL
 */
#ifndef WARPX_SPECTRAL_SOLVER_H_
#define WARPX_SPECTRAL_SOLVER_H_
 
#include "SpectralSolver_fwd.H"
 
#include "SpectralAlgorithms/SpectralBaseAlgorithm.H"
#include "SpectralFieldData.H"
 
#include <ablastr/utils/Enums.H>
 
#include <AMReX_Array.H>
#include <AMReX_REAL.H>
#include <AMReX_RealVect.H>
 
#include <AMReX_BaseFwd.H>
 
#include <array>
#include <memory>
 
#ifdef WARPX_USE_FFT
class SpectralSolver
{
    public:
 
        SpectralSolver (int lev,
                        const amrex::BoxArray& realspace_ba,
                        const amrex::DistributionMapping& dm,
                        int norder_x,
                        int norder_y,
                        int norder_z,
                        ablastr::utils::enums::GridType grid_type,
                        const amrex::Vector<amrex::Real>& v_galilean,
                        const amrex::Vector<amrex::Real>& v_comoving,
                        amrex::RealVect dx,
                        amrex::Real dt,
                        bool pml,
                        bool periodic_single_box,
                        bool update_with_rho,
                        bool fft_do_time_averaging,
                        int psatd_solution_type,
                        int J_in_time,
                        int rho_in_time,
                        bool dive_cleaning,
                        bool divb_cleaning);
 
        void ForwardTransform (int lev,
                               const amrex::MultiFab& mf,
                               int field_index,
                               int i_comp = 0);
 
        void BackwardTransform( int lev,
                                amrex::MultiFab& mf,
                                int field_index,
                                const amrex::IntVect& fill_guards,
                                int i_comp=0 );
 
        void pushSpectralFields();
 
        void ComputeSpectralDivE ( int lev,
                                   const std::array<std::unique_ptr<amrex::MultiFab>,3>& Efield,
                                   amrex::MultiFab& divE ) {
            algorithm->ComputeSpectralDivE( lev, field_data, Efield, divE );
        }
 
        void CurrentCorrection ()
        {
            algorithm->CurrentCorrection(field_data);
        }
 
        void VayDeposition ()
        {
            algorithm->VayDeposition(field_data);
        }
 
        void CopySpectralDataComp (const int src_comp, const int dest_comp)
        {
            // The last two arguments represent the number of components and
            // the number of ghost cells to perform this operation
            Copy(field_data.fields, field_data.fields, src_comp, dest_comp, 1, 0);
        }
 
        void ZeroOutDataComp (const int icomp)
        {
            // The last argument represents the number of components to perform this operation
            field_data.fields.setVal(0., icomp, 1);
        }
 
        void ScaleDataComp (const int icomp, const amrex::Real scale_factor)
        {
            // The last argument represents the number of components to perform this operation
            field_data.fields.mult(scale_factor, icomp, 1);
        }
 
        SpectralFieldIndex m_spectral_index;
 
    protected:
 
        amrex::IntVect m_fill_guards;
 
    private:
 
        void ReadParameters ();
 
        // Store field in spectral space and perform the Fourier transforms
        SpectralFieldData field_data;
 
        // Defines field update equation in spectral space and the associated coefficients.
        // SpectralBaseAlgorithm is a base class; this pointer is meant to point
        // to an instance of a sub-class defining a specific algorithm
        std::unique_ptr<SpectralBaseAlgorithm> algorithm;
};
#endif // WARPX_USE_FFT
#endif // WARPX_SPECTRAL_SOLVER_H_