flow_solver_case_base.h

#ifndef __FLOW_SOLVER_CASE_BASE__
#define __FLOW_SOLVER_CASE_BASE__

// for FlowSolver class:
#include <deal.II/base/table_handler.h>
#include <deal.II/distributed/shared_tria.h>
#include <deal.II/distributed/tria.h>

#include "dg/dg_base.hpp"
#include "parameters/all_parameters.h"
#include "physics/initial_conditions/initial_condition_function.h"
#include "ode_solver/ode_solver_base.h"

namespace PHiLiP {
namespace FlowSolver {

#if PHILIP_DIM==1
using Triangulation = dealii::Triangulation<PHILIP_DIM>;
#else
using Triangulation = dealii::parallel::distributed::Triangulation<PHILIP_DIM>;
#endif

template <int dim, int nspecies, int nstate>
class FlowSolverCaseBase
{
public:
    explicit FlowSolverCaseBase(const Parameters::AllParameters *const parameters_input);

    std::shared_ptr<InitialConditionFunction<dim,nspecies,nstate,double>> initial_condition_function; 

    virtual ~FlowSolverCaseBase() = default;

    void display_flow_solver_setup(std::shared_ptr<DGBase<dim,nspecies,double>> dg) const;

    virtual std::shared_ptr<Triangulation> generate_grid() const = 0;

    virtual void set_higher_order_grid(std::shared_ptr <DGBase<dim, nspecies, double>> dg) const;

    virtual void compute_unsteady_data_and_write_to_table(
            const std::shared_ptr <ODE::ODESolverBase<dim, nspecies, double>> ode_solver, 
            const std::shared_ptr <DGBase<dim, nspecies, double>> dg,
            const std::shared_ptr<dealii::TableHandler> unsteady_data_table,
            const bool do_write_unsteady_data_table_file);

    virtual double get_constant_time_step(std::shared_ptr <DGBase<dim, nspecies, double>> dg) const;

    virtual double get_adaptive_time_step(std::shared_ptr <DGBase<dim, nspecies, double>> dg) const;

    virtual double get_adaptive_time_step_initial(std::shared_ptr <DGBase<dim, nspecies, double>> dg);

    virtual void steady_state_postprocessing(std::shared_ptr <DGBase<dim, nspecies, double>> dg) const;

    virtual void compute_time_averaged_solution(
        const std::shared_ptr <ODE::ODESolverBase<dim, nspecies, double>> ode_solver,
        const std::shared_ptr <DGBase<dim, nspecies, double>> dg,
        const double time_step);

    virtual void compute_Reynolds_stress(
        const std::shared_ptr <ODE::ODESolverBase<dim, nspecies, double>> ode_solver,
        const std::shared_ptr <DGBase<dim, nspecies, double>> dg,
        const double time_step);

    void set_time_step(const double time_step_input);

    virtual void modify_dg_object(std::shared_ptr <DGBase<dim, nspecies, double>> dg) const;
    
protected:
    const Parameters::AllParameters all_param; 
    const MPI_Comm mpi_communicator; 
    const int mpi_rank; 
    const int n_mpi; 


    dealii::ConditionalOStream pcout;

public:
    void add_value_to_data_table(
            const double value,
            const std::string value_string,
            const std::shared_ptr <dealii::TableHandler> data_table) const;

protected:
    virtual void display_additional_flow_case_specific_parameters() const = 0;

    double get_time_step() const;

private:
    std::string get_pde_string() const;

    std::string get_flow_case_string() const;

    double time_step;
};

} // FlowSolver namespace
} // PHiLiP namespace

#endif