hyperbolic_system.h

Go to the documentation of this file.

//
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// Copyright (C) 2023 - 2024 by the ryujin authors
//
 
#pragma once
 
#include <convenience_macros.h>
#include <discretization.h>
#include <multicomponent_vector.h>
#include <patterns_conversion.h>
#include <simd.h>
#include <state_vector.h>
 
#include <deal.II/base/parameter_acceptor.h>
#include <deal.II/base/tensor.h>
 
#include <array>
#include <functional>
 
namespace ryujin
{
  namespace Skeleton
  {
    template <int dim, typename Number>
    class HyperbolicSystemView;
 
    class HyperbolicSystem final : public dealii::ParameterAcceptor
    {
    public:
      static inline const std::string problem_name =
          "Skeleton Hyperbolic System";
 
      HyperbolicSystem(const std::string &subsection = "/HyperbolicSystem")
          : ParameterAcceptor(subsection)
      {
      }
 
      template <int dim, typename Number>
      auto view() const
      {
        return HyperbolicSystemView<dim, Number>{*this};
      }
 
    private:
      template <int dim, typename Number>
      friend class HyperbolicSystemView;
    }; /* HyperbolicSystem */
 
 
    template <int dim, typename Number>
    class HyperbolicSystemView
    {
    public:
      HyperbolicSystemView(const HyperbolicSystem &hyperbolic_system)
          : hyperbolic_system_(hyperbolic_system)
      {
      }
 
      template <int dim2, typename Number2>
      auto view() const
      {
        return HyperbolicSystemView<dim2, Number2>{hyperbolic_system_};
      }
 
    private:
      const HyperbolicSystem &hyperbolic_system_;
 
 
    public:
 
      using ScalarNumber = typename get_value_type<Number>::type;
 
      static constexpr unsigned int problem_dimension = 1;
 
      using state_type = dealii::Tensor<1, problem_dimension, Number>;
 
      using flux_type =
          dealii::Tensor<1, problem_dimension, dealii::Tensor<1, dim, Number>>;
 
      using flux_contribution_type = flux_type;
 
      static inline const auto component_names =
          []() -> std::array<std::string, problem_dimension> {
        if constexpr (dim == 1)
          return {"u"};
        else if constexpr (dim == 2)
          return {"u"};
        else if constexpr (dim == 3)
          return {"u"};
        __builtin_trap();
      }();
 
      static inline const auto primitive_component_names =
          []() -> std::array<std::string, problem_dimension> {
        if constexpr (dim == 1)
          return {"u"};
        else if constexpr (dim == 2)
          return {"u"};
        else if constexpr (dim == 3)
          return {"u"};
        __builtin_trap();
      }();
 
      static constexpr unsigned int n_precomputed_values = 0;
 
      using precomputed_type = std::array<Number, n_precomputed_values>;
 
      static inline const auto precomputed_names =
          std::array<std::string, n_precomputed_values>{};
 
      static constexpr unsigned int n_initial_precomputed_values = 0;
 
      using initial_precomputed_type =
          std::array<Number, n_initial_precomputed_values>;
 
      static inline const auto initial_precomputed_names =
          std::array<std::string, n_initial_precomputed_values>{};
 
      using StateVector = Vectors::
          StateVector<ScalarNumber, problem_dimension, n_precomputed_values>;
 
      using HyperbolicVector =
          Vectors::MultiComponentVector<ScalarNumber, problem_dimension>;
 
      using PrecomputedVector =
          Vectors::MultiComponentVector<ScalarNumber, n_precomputed_values>;
 
      using InitialPrecomputedVector =
          Vectors::MultiComponentVector<ScalarNumber,
                                        n_initial_precomputed_values>;
 
 
 
      static constexpr unsigned int n_precomputation_cycles = 0;
 
      template <typename DISPATCH, typename SPARSITY>
      void precomputation_loop(unsigned int /*cycle*/,
                               const DISPATCH &dispatch_check,
                               const SPARSITY & /*sparsity_simd*/,
                               StateVector & /*state_vector*/,
                               unsigned int /*left*/,
                               unsigned int /*right*/) const = delete;
 
 
 
      bool is_admissible(const state_type & /*U*/) const
      {
        return true;
      }
 
 
 
      template <typename Lambda>
      state_type apply_boundary_conditions(
          const dealii::types::boundary_id /*id*/,
          const state_type &U,
          const dealii::Tensor<1, dim, Number> & /*normal*/,
          const Lambda & /*get_dirichlet_data*/) const
      {
        return U;
      }
 
 
 
      flux_contribution_type
      flux_contribution(const PrecomputedVector & /*pv*/,
                        const InitialPrecomputedVector & /*piv*/,
                        const unsigned int /*i*/,
                        const state_type & /*U_i*/) const
      {
        return flux_contribution_type{};
      }
 
      flux_contribution_type
      flux_contribution(const PrecomputedVector & /*pv*/,
                        const InitialPrecomputedVector & /*piv*/,
                        const unsigned int * /*js*/,
                        const state_type & /*U_j*/) const
      {
        return flux_contribution_type{};
      }
 
      state_type
      flux_divergence(const flux_contribution_type & /*flux_i*/,
                      const flux_contribution_type & /*flux_j*/,
                      const dealii::Tensor<1, dim, Number> & /*c_ij*/) const
      {
        return state_type{};
      }
 
      static constexpr bool have_high_order_flux = false;
 
      state_type high_order_flux_divergence(
          const flux_contribution_type &,
          const flux_contribution_type &,
          const dealii::Tensor<1, dim, Number> &) const = delete;
 
 
 
      static constexpr bool have_source_terms = false;
 
      state_type nodal_source(const PrecomputedVector & /*pv*/,
                              const unsigned int /*i*/,
                              const state_type & /*U_i*/,
                              const ScalarNumber /*tau*/) const = delete;
 
      state_type nodal_source(const PrecomputedVector & /*pv*/,
                              const unsigned int * /*js*/,
                              const state_type & /*U_j*/,
                              const ScalarNumber /*tau*/) const = delete;
 
 
 
      template <typename ST>
      state_type expand_state(const ST &state) const
      {
        return state;
      }
 
      state_type from_primitive_state(const state_type &primitive_state) const
      {
        return primitive_state;
      }
 
      state_type to_primitive_state(const state_type &state) const
      {
        return state;
      }
 
      template <typename Lambda>
      state_type apply_galilei_transform(const state_type &state,
                                         const Lambda & /*lambda*/) const
      {
        return state;
      }
 
    }; /* HyperbolicSystemView */
  }    // namespace Skeleton
} // namespace ryujin