ImplicitSolver.H

Go to the documentation of this file.

/* Copyright 2024 Justin Angus
 *
 * This file is part of WarpX.
 *
 * License: BSD-3-Clause-LBNL
 */
#ifndef Implicit_Solver_H_
#define Implicit_Solver_H_
 
#include "FieldSolver/ImplicitSolvers/WarpXSolverVec.H"
#include "NonlinearSolvers/NonlinearSolverLibrary.H"
 
#include <AMReX_Array.H>
#include <AMReX_REAL.H>
 
class WarpX;
class ImplicitSolver
{
public:
 
    ImplicitSolver() = default;
 
    virtual ~ImplicitSolver() = default;
 
    // Prohibit Move and Copy operations
    ImplicitSolver(const ImplicitSolver&) = delete;
    ImplicitSolver& operator=(const ImplicitSolver&) = delete;
    ImplicitSolver(ImplicitSolver&&) = delete;
    ImplicitSolver& operator=(ImplicitSolver&&) = delete;
 
    //
    // the following routines are called by WarpX
    //
 
    virtual void Define ( WarpX*  a_WarpX ) = 0;
 
    [[nodiscard]] bool IsDefined () const { return m_is_defined; }
 
    virtual void PrintParameters () const = 0;
 
    void GetParticleSolverParams (int&  a_max_particle_iter,
                                  amrex::ParticleReal&  a_particle_tol ) const
    {
        a_max_particle_iter = m_max_particle_iterations;
        a_particle_tol = m_particle_tolerance;
    }
 
    virtual void OneStep ( amrex::Real  a_time,
                           amrex::Real  a_dt,
                           int          a_step ) = 0;
 
    //
    // the following routines are called by the linear and nonlinear solvers
    //
 
    virtual void ComputeRHS ( WarpXSolverVec&  a_RHS,
                        const WarpXSolverVec&  a_E,
                              amrex::Real      a_time,
                              amrex::Real      a_dt,
                              int              a_nl_iter,
                              bool             a_from_jacobian ) = 0;
 
protected:
 
    WarpX* m_WarpX;
 
    bool m_is_defined = false;
 
    NonlinearSolverType m_nlsolver_type;
    std::unique_ptr<NonlinearSolver<WarpXSolverVec,ImplicitSolver>> m_nlsolver;
 
    amrex::ParticleReal m_particle_tolerance = 1.0e-10;
 
    int m_max_particle_iterations = 21;
 
    void parseNonlinearSolverParams( const amrex::ParmParse&  pp )
    {
 
        std::string nlsolver_type_str;
        pp.get("nonlinear_solver", nlsolver_type_str);
 
        if (nlsolver_type_str=="picard") {
            m_nlsolver_type = NonlinearSolverType::Picard;
            m_nlsolver = std::make_unique<PicardSolver<WarpXSolverVec,ImplicitSolver>>();
            m_max_particle_iterations = 1;
            m_particle_tolerance = 0.0;
        }
        else if (nlsolver_type_str=="newton") {
            m_nlsolver_type = NonlinearSolverType::Newton;
            m_nlsolver = std::make_unique<NewtonSolver<WarpXSolverVec,ImplicitSolver>>();
            pp.query("max_particle_iterations", m_max_particle_iterations);
            pp.query("particle_tolerance", m_particle_tolerance);
        }
        else {
            WARPX_ABORT_WITH_MESSAGE(
                "invalid nonlinear_solver specified. Valid options are picard and newton.");
        }
 
    }
 
};
 
#endif