PDEBase.H

Go to the documentation of this file.

#ifndef PDEBASE_H
#define PDEBASE_H
 
#include <string>
 
#include "amr-wind/core/Factory.H"
#include "amr-wind/core/CollMgr.H"
#include "amr-wind/equation_systems/PDEFields.H"
#include "amr-wind/core/FieldDescTypes.H"
#include "amr-wind/incflo_enums.H"
 
namespace amr_wind {
 
class CFDSim;
 
namespace pde {


class PDEBase : public Factory<PDEBase, CFDSim&>
{
public:
    ~PDEBase() override = default;

    virtual PDEFields& fields() = 0;
    virtual const PDEFields& fields() const = 0;

    virtual void initialize() = 0;

    virtual void post_regrid_actions() = 0;

    virtual void compute_source_term(const FieldState fstate) = 0;

    virtual void compute_mueff(const FieldState fstate) = 0;

    virtual void compute_diffusion_term(const FieldState fstate) = 0;

    virtual void pre_advection_actions(const FieldState fstate) = 0;

    virtual void compute_advection_term(const FieldState fstate) = 0;

    virtual void compute_predictor_rhs(const DiffusionType difftype) = 0;

    virtual void compute_corrector_rhs(const DiffusionType difftype) = 0;

    virtual void solve(const amrex::Real dt) = 0;

    virtual void post_solve_actions() = 0;
 
    virtual void improve_explicit_diffusion(const amrex::Real dt) = 0;

    static std::string base_identifier() { return "PDESystem"; }
};

class PDEMgr : public CollMgr<PDEMgr, PDEBase>
{
public:
    explicit PDEMgr(CFDSim& sim);
 
    ~PDEMgr() = default;

    PDEBase& icns() { return *m_icns; }
    const PDEBase& icns() const { return *m_icns; }

    PDEBase& register_icns();

    PDEBase& register_transport_pde(const std::string& pde_name);

    void advance_states();

    void prepare_boundaries();

    void density_check();

    void fillpatch_state_fields(
        const amrex::Real time, const FieldState fstate = FieldState::New);

    TypeVector& scalar_eqns() { return m_obj_vec; }
    const TypeVector& scalar_eqns() const { return m_obj_vec; }

    bool has_pde(const std::string& pde_name) const;
 
    int num_ghost_state() const;
 
    bool constant_density() const { return m_constant_density; }
 
    std::string scheme() const { return m_scheme; }
 
private:
    CFDSim& m_sim;

    std::unique_ptr<PDEBase> m_icns;

    std::string m_scheme;

    bool m_use_godunov{true};

    bool m_constant_density{true};
};
 
} // namespace pde
} // namespace amr_wind
 
#endif /* PDEBASE_H */