dg_base_state.hpp

#ifndef PHILIP_DG_BASE_STATE_HPP
#define PHILIP_DG_BASE_STATE_HPP

#include <deal.II/distributed/tria.h>

#include "dg_base.hpp"
#include "parameters/all_parameters.h"
namespace PHiLiP {

/*  Contains the objects and functions that need to be templated on the number of state variables.
 */
#if PHILIP_DIM==1 // dealii::parallel::distributed::Triangulation<dim> does not work for 1D
template <int dim, int nstate, typename real, typename MeshType = dealii::Triangulation<dim>>
#else
template <int dim, int nstate, typename real, typename MeshType = dealii::parallel::distributed::Triangulation<dim>>
#endif
class DGBaseState : public DGBase<dim, real, MeshType>
{
   protected:
    using Triangulation = typename DGBase<dim,real,MeshType>::Triangulation;

   public:
    using DGBase<dim,real,MeshType>::all_parameters; 

    DGBaseState(
        const Parameters::AllParameters *const parameters_input,
        const unsigned int degree,
        const unsigned int max_degree_input,
        const unsigned int grid_degree_input,
        const std::shared_ptr<Triangulation> triangulation_input);

    std::shared_ptr < Physics::PhysicsBase<dim, nstate, real > > pde_physics_double;
    std::shared_ptr < Physics::ModelBase<dim, nstate, real > > pde_model_double;
    std::unique_ptr < NumericalFlux::NumericalFluxConvective<dim, nstate, real > > conv_num_flux_double;
    std::unique_ptr < NumericalFlux::NumericalFluxDissipative<dim, nstate, real > > diss_num_flux_double;
    std::shared_ptr <ArtificialDissipationBase<dim,nstate>> artificial_dissip;

    std::shared_ptr < Physics::PhysicsBase<dim, nstate, FadType > > pde_physics_fad;
    std::shared_ptr < Physics::ModelBase<dim, nstate, FadType > > pde_model_fad;
    std::unique_ptr < NumericalFlux::NumericalFluxConvective<dim, nstate, FadType > > conv_num_flux_fad;
    std::unique_ptr < NumericalFlux::NumericalFluxDissipative<dim, nstate, FadType > > diss_num_flux_fad;

    std::shared_ptr < Physics::PhysicsBase<dim, nstate, RadType > > pde_physics_rad;
    std::shared_ptr < Physics::ModelBase<dim, nstate, RadType > > pde_model_rad;
    std::unique_ptr < NumericalFlux::NumericalFluxConvective<dim, nstate, RadType > > conv_num_flux_rad;
    std::unique_ptr < NumericalFlux::NumericalFluxDissipative<dim, nstate, RadType > > diss_num_flux_rad;

    std::shared_ptr < Physics::PhysicsBase<dim, nstate, FadFadType > > pde_physics_fad_fad;
    std::shared_ptr < Physics::ModelBase<dim, nstate, FadFadType > > pde_model_fad_fad;
    std::unique_ptr < NumericalFlux::NumericalFluxConvective<dim, nstate, FadFadType > > conv_num_flux_fad_fad;
    std::unique_ptr < NumericalFlux::NumericalFluxDissipative<dim, nstate, FadFadType > > diss_num_flux_fad_fad;

    std::shared_ptr < Physics::PhysicsBase<dim, nstate, RadFadType > > pde_physics_rad_fad;
    std::shared_ptr < Physics::ModelBase<dim, nstate, RadFadType > > pde_model_rad_fad;
    std::unique_ptr < NumericalFlux::NumericalFluxConvective<dim, nstate, RadFadType > > conv_num_flux_rad_fad;
    std::unique_ptr < NumericalFlux::NumericalFluxDissipative<dim, nstate, RadFadType > > diss_num_flux_rad_fad;

    void set_physics(
        std::shared_ptr< Physics::PhysicsBase<dim, nstate, real       > > pde_physics_double_input,
        std::shared_ptr< Physics::PhysicsBase<dim, nstate, FadType    > > pde_physics_fad_input,
        std::shared_ptr< Physics::PhysicsBase<dim, nstate, RadType    > > pde_physics_rad_input,
        std::shared_ptr< Physics::PhysicsBase<dim, nstate, FadFadType > > pde_physics_fad_fad_input,
        std::shared_ptr< Physics::PhysicsBase<dim, nstate, RadFadType > > pde_physics_rad_fad_input);

    void allocate_model_variables();

    void update_model_variables();

    void set_use_auxiliary_eq();

   protected:

    real evaluate_CFL (std::vector< std::array<real,nstate> > soln_at_q, const real artificial_dissipation, const real cell_diameter, const unsigned int cell_degree);


    void reset_numerical_fluxes();
}; // end of DGBaseState class

}  // namespace PHiLiP

#endif  // PHILIP_DG_BASE_STATE_HPP