incflo.H

Go to the documentation of this file.

#ifndef INCFLO_H
#define INCFLO_H
 
#include <AMReX_AmrCore.H>
#include <AMReX_MultiFabUtil.H>
#include <AMReX_ParmParse.H>
#include <AMReX_iMultiFab.H>
#include <hydro_NodalProjector.H>
 
#include "src/incflo_enums.H"
#include "src/CFDSim.H"
#include "src/core/SimTime.H"
#include "src/core/FieldRepo.H"
#include "src/overset/OversetOps.H"
 
#include "src/boundary_conditions/field_boundary_fill/ReadERFFunction.H"
class MultiBlockContainer;
namespace kynema_sgf {
namespace pde {
class PDEBase;
}
class RefinementCriteria;
class RefineCriteriaManager;
} // namespace kynema_sgf


class incflo : public amrex::AmrCore
{
public:
    incflo();
    ~incflo() override;
 
    // Initialize multilevel AMR data
    void InitData();
 
    // Evolve solution to final time through repeated calls to Advance()
    void Evolve();
 
    // Tag cells for refinement
    void
    ErrorEst(int lev, amrex::TagBoxArray& tags, amrex::Real time, int ngrow)
        override;
 
    // Make a new level from scratch using provided BoxArray and
    // DistributionMapping Only used during initialization
    void MakeNewLevelFromScratch(
        int lev,
        amrex::Real time,
        const amrex::BoxArray& new_grids,
        const amrex::DistributionMapping& new_dmap) override;
 
    // Make a new level using provided BoxArray and DistributionMapping,
    // and fill with interpolated coarse level data
    void MakeNewLevelFromCoarse(
        int lev,
        amrex::Real time,
        const amrex::BoxArray& ba,
        const amrex::DistributionMapping& dm) override;
 
    // Remake an existing level using provided BoxArray and DistributionMapping,
    // and fill with existing fine and coarse data
    void RemakeLevel(
        int lev,
        amrex::Real time,
        const amrex::BoxArray& ba,
        const amrex::DistributionMapping& dm) override;
 
    // Delete level data
    void ClearLevel(int lev) override;
 
    void init_mesh();
    void init_kynema_sgf_modules();
    void prepare_for_time_integration();
    bool regrid_and_update();
    void pre_advance_stage1();
    void pre_advance_stage2();
    void prepare_time_step();
    void do_advance(int fixed_point_iteration);
    void advance(int fixed_point_iteration);
    void prescribe_advance();
    void post_advance_work();
 
    kynema_sgf::CFDSim& sim() { return m_sim; }
    const kynema_sgf::SimTime& time() const { return m_time; }
    kynema_sgf::FieldRepo& repo() { return m_repo; }
    const kynema_sgf::FieldRepo& repo() const { return m_repo; }
 
    kynema_sgf::pde::PDEBase& icns() { return m_sim.pde_manager().icns(); }
    const kynema_sgf::pde::PDEBase& icns() const
    {
        return m_sim.pde_manager().icns();
    }
    kynema_sgf::pde::PDEMgr::TypeVector& scalar_eqns()
    {
        return m_sim.pde_manager().scalar_eqns();
    }
    const kynema_sgf::pde::PDEMgr::TypeVector& scalar_eqns() const
    {
        return m_sim.pde_manager().scalar_eqns();
    }
 
    kynema_sgf::Field& velocity() const { return m_repo.get_field("velocity"); }
    kynema_sgf::Field& density() const { return m_repo.get_field("density"); }
    kynema_sgf::Field& temperature() const
    {
        return m_repo.get_field("temperature");
    }
    kynema_sgf::Field& pressure() const { return m_repo.get_field("p"); }
    kynema_sgf::Field& grad_p() const { return m_repo.get_field("gp"); }
 
    void compute_dt();
    void compute_prescribe_dt();
    void advance_time() { m_time.advance_time(); }
 
    void ApplyPredictor(
        bool incremental_projection = false, int fixed_point_iteration = 0);
    void ApplyCorrector();
    void ApplyPrescribeStep();
 
    void ApplyProjection(
        amrex::Vector<amrex::MultiFab const*> density,
        amrex::Real time,
        amrex::Real scaling_factor,
        bool incremental);

    void init_physics_and_pde();
 
    void ReadCheckpointFile();
 
    void SetMultiBlockPointer(MultiBlockContainer* mbc) { m_sim.set_mbc(mbc); }
    void set_read_erf(ReadERFFunction fcn)
    {
        m_sim.set_read_erf(std::move(fcn));
    }
 
private:
    //
    // member variables
    //
 
    kynema_sgf::CFDSim m_sim;
    kynema_sgf::SimTime& m_time;
    kynema_sgf::FieldRepo& m_repo;
    kynema_sgf::OversetOps m_ovst_ops;
 
    std::unique_ptr<kynema_sgf::RefineCriteriaManager> m_mesh_refiner;
 
    // Be verbose?
    int m_verbose = 0;
 
    // Initial projection / iterations
    bool m_do_initial_proj = true;
    int m_initial_iterations = 3;
 
    bool m_use_godunov = true;
 
    // Prescribe advection velocity
    bool m_prescribe_vel = false;
 
    // Perform a dry run (0 steps, output plotfile)
    bool m_dry_run = false;
 
    // Fixed point iterations every timestep
    int m_fixed_point_iterations{1};

    amrex::Long m_cell_count{-1};
 
    DiffusionType m_diff_type = DiffusionType::Crank_Nicolson;

    bool m_reconstruct_true_pressure{false};
 
    //
    // end of member variables
    //
 
    amrex::FabFactory<amrex::FArrayBox> const& Factory(int lev) const
    {
        return m_repo.factory(lev);
    }
 
    bool need_divtau() const
    {
        return (m_use_godunov || (DiffusionType::Implicit != m_diff_type));
    }

    //
    // setup
    //
 
    void CheckAndSetUpDryRun();
    void ReadParameters();
    void InitialProjection();
    void InitialIterations();

    //
    // utilities
    //
    void PrintMaxValues(const std::string& header);
    void PrintMaxVelLocations(const std::string& header);
    void PrintMaxVel(int lev) const;
    void PrintMaxGp(int lev) const;
    void CheckForNans(int lev) const;
};
 
#endif