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 <AMReX_Array.H>
#include <AMReX_REAL.H>
#include <AMReX_RealVect.H>

#include <AMReX_BaseFwd.H>

#include <array>
#include <memory>

#ifdef WARPX_USE_PSATD

class SpectralSolver
{
    public:

        SpectralSolver (const int lev,
                        const amrex::BoxArray& realspace_ba,
                        const amrex::DistributionMapping& dm,
                        const int norder_x, const int norder_y,
                        const int norder_z, const bool nodal,
                        const amrex::IntVect& fill_guards,
                        const amrex::Array<amrex::Real,3>& v_galilean,
                        const amrex::Array<amrex::Real,3>& v_comoving,
                        const amrex::RealVect dx,
                        const amrex::Real dt,
                        const bool pml,
                        const bool periodic_single_box,
                        const bool update_with_rho,
                        const bool fft_do_time_averaging,
                        const bool J_linear_in_time,
                        const bool dive_cleaning,
                        const bool divb_cleaning);

        void ForwardTransform( const int lev,
                               const amrex::MultiFab& mf,
                               const int field_index,
                               const int i_comp=0 );

        void BackwardTransform( const int lev,
                                amrex::MultiFab& mf,
                                const int field_index,
                                const int i_comp=0 );

        void pushSpectralFields();

        void ComputeSpectralDivE ( const int lev,
                                   const std::array<std::unique_ptr<amrex::MultiFab>,3>& Efield,
                                   amrex::MultiFab& divE ) {
            algorithm->ComputeSpectralDivE( lev, field_data, Efield, divE );
        }

        void CurrentCorrection ( const int lev,
                                 std::array<std::unique_ptr<amrex::MultiFab>,3>& current,
                                 const std::unique_ptr<amrex::MultiFab>& rho ) {
            algorithm->CurrentCorrection( lev, field_data, current, rho );
        }

        void VayDeposition (const int lev, std::array<std::unique_ptr<amrex::MultiFab>,3>& current)
        {
            algorithm->VayDeposition(lev, field_data, current);
        }

        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_PSATD
#endif // WARPX_SPECTRAL_SOLVER_H_