CFDSim.H

Go to the documentation of this file.

#ifndef CFDSIM_H
#define CFDSIM_H
 
#include "AMReX_AmrCore.H"
#include "amr-wind/core/SimTime.H"
#include "amr-wind/core/FieldRepo.H"
#include "amr-wind/equation_systems/PDEBase.H"
#include "amr-wind/core/Physics.H"
#include "amr-wind/core/MeshMap.H"
#include "amr-wind/helics.H"
 
namespace amr_wind {
class IOManager;
class PostProcessManager;
class OversetManager;
class ExtSolverMgr;
class HelicsStorage;
 
namespace turbulence {
class TurbulenceModel;
}
 
class CFDSim
{
public:
    explicit CFDSim(amrex::AmrCore& mesh);
 
    ~CFDSim();
 
    amrex::AmrCore& mesh() { return m_mesh; }
    const amrex::AmrCore& mesh() const { return m_mesh; }
 
    SimTime& time() { return m_time; }
    const SimTime& time() const { return m_time; }
 
    FieldRepo& repo() { return m_repo; }
    FieldRepo& repo() const { return m_repo; }
 
    pde::PDEMgr& pde_manager() { return m_pde_mgr; }
    const pde::PDEMgr& pde_manager() const { return m_pde_mgr; }
 
    PhysicsMgr& physics_manager() { return m_physics_mgr; }
    const PhysicsMgr& physics_manager() const { return m_physics_mgr; }
 
    PhysicsMgr::TypeVector& physics() { return m_physics_mgr.objects(); }
    const PhysicsMgr::TypeVector& physics() const
    {
        return m_physics_mgr.objects();
    }
 
    turbulence::TurbulenceModel& turbulence_model() { return *m_turbulence; }
    const turbulence::TurbulenceModel& turbulence_model() const
    {
        return *m_turbulence;
    }
 
    IOManager& io_manager() { return *m_io_mgr; }
    const IOManager& io_manager() const { return *m_io_mgr; }
 
    PostProcessManager& post_manager() { return *m_post_mgr; }
    const PostProcessManager& post_manager() const { return *m_post_mgr; }
 
    OversetManager* overset_manager() { return m_overset_mgr.get(); }
    const OversetManager* overset_manager() const
    {
        return m_overset_mgr.get();
    }
 
    MeshMap* mesh_mapping() { return m_mesh_map.get(); }
    const MeshMap* mesh_mapping() const { return m_mesh_map.get(); }
 
    ExtSolverMgr& ext_solver_manager() { return *m_ext_solver_mgr; }
    const ExtSolverMgr& ext_solver_manager() const { return *m_ext_solver_mgr; }
 
    HelicsStorage& helics() { return *m_helics; }
    const HelicsStorage& helics() const { return *m_helics; }
 
    bool has_overset() const;
 
    void create_turbulence_model();
 
    void init_physics();
 
    void activate_overset();
 
    void activate_mesh_map();
 
    bool has_mesh_mapping() const { return m_mesh_mapping; }
 
    void set_during_overset_advance(const bool flag)
    {
        m_during_overset_advance = flag;
    }
 
    bool is_during_overset_advance() const { return m_during_overset_advance; }
 
    bool is_anelastic() const;
 
private:
    amrex::AmrCore& m_mesh;
 
    SimTime m_time;
 
    mutable FieldRepo m_repo;
 
    pde::PDEMgr m_pde_mgr;
 
    PhysicsMgr m_physics_mgr;
 
    std::unique_ptr<turbulence::TurbulenceModel> m_turbulence;
 
    std::unique_ptr<IOManager> m_io_mgr;
 
    std::unique_ptr<PostProcessManager> m_post_mgr;
 
    std::unique_ptr<OversetManager> m_overset_mgr;
 
    std::unique_ptr<MeshMap> m_mesh_map;
 
    std::unique_ptr<ExtSolverMgr> m_ext_solver_mgr;
 
    std::unique_ptr<HelicsStorage> m_helics;
 
    bool m_mesh_mapping{false};
 
    // State of solver - know if during an overset timestep or not
    bool m_during_overset_advance{false};
};
 
} // namespace amr_wind
 
#endif /* CFDSIM_H */