DiFfRG::def::HasWaveSpeed Concept Reference

Concept that any wave-speed strategy must satisfy. More...

#include <abstract_wave_speed.hh>

Concept definition

template<typename T>
concept DiFfRG::def::HasWaveSpeed = 
        
        requires(const std::array<FV::KurganovTadmor::internal::JacobianMatrix<double, 1>, 1> &J1_plus,
                 const std::array<FV::KurganovTadmor::internal::JacobianMatrix<double, 1>, 1> &J1_minus) {
          {
            T::template compute_speeds<double, 1, 1>(J1_plus, J1_minus)
          } -> std::same_as<std::array<double, 1>>;
        } &&
        
        requires(const std::array<FV::KurganovTadmor::internal::JacobianMatrix<double, 2>, 2> &J2_plus,
                 const std::array<FV::KurganovTadmor::internal::JacobianMatrix<double, 2>, 2> &J2_minus) {
          {
            T::template compute_speeds<double, 2, 2>(J2_plus, J2_minus)
          } -> std::same_as<std::array<double, 2>>;
        } &&
        
        requires(const std::array<FV::KurganovTadmor::internal::JacobianMatrix<double, 1>, 1> &J1_plus,
                 const std::array<FV::KurganovTadmor::internal::JacobianMatrix<double, 1>, 1> &J1_minus,
                 const FV::KurganovTadmor::internal::HessianTensor<double, 1, 1> &H1_plus,
                 const FV::KurganovTadmor::internal::HessianTensor<double, 1, 1> &H1_minus) {
          {
            T::template compute_selected_speed_derivatives<double, 1, 1>(J1_plus, J1_minus, H1_plus, H1_minus)
          } -> std::same_as<std::pair<std::array<std::array<double, 1>, 1>, std::array<std::array<double, 1>, 1>>>;
        } &&
        
        requires(const std::array<FV::KurganovTadmor::internal::JacobianMatrix<double, 2>, 2> &J2_plus,
                 const std::array<FV::KurganovTadmor::internal::JacobianMatrix<double, 2>, 2> &J2_minus,
                 const FV::KurganovTadmor::internal::HessianTensor<double, 2, 2> &H2_plus,
                 const FV::KurganovTadmor::internal::HessianTensor<double, 2, 2> &H2_minus) {
          {
            T::template compute_selected_speed_derivatives<double, 2, 2>(J2_plus, J2_minus, H2_plus, H2_minus)
          } -> std::same_as<std::pair<std::array<std::array<double, 2>, 2>, std::array<std::array<double, 2>, 2>>>;
        }

Detailed Description

Concept that any wave-speed strategy must satisfy.

A wave-speed class must provide:

• compute_speeds: given plus/minus Jacobians, return per-dimension wave speeds.
• compute_selected_speed_derivatives: return the differentiated speed for the side selected by the maximum spectral radius.

New wave-speed strategies only need to satisfy this concept:

struct MyWaveSpeed
{
  template <typename NumberType, int dim, size_t n_components>
  static std::array<NumberType, dim>
  compute_speeds(
      const std::array<FV::KurganovTadmor::internal::JacobianMatrix<NumberType, n_components>, dim> &J_plus,
      const std::array<FV::KurganovTadmor::internal::JacobianMatrix<NumberType, n_components>, dim> &J_minus);
 
  template <typename NumberType, int dim, size_t n_components>
  static std::pair<std::array<std::array<NumberType, n_components>, dim>,
                   std::array<std::array<NumberType, n_components>, dim>>
  compute_selected_speed_derivatives(
      const std::array<FV::KurganovTadmor::internal::JacobianMatrix<NumberType, n_components>, dim> &J_plus,
      const std::array<FV::KurganovTadmor::internal::JacobianMatrix<NumberType, n_components>, dim> &J_minus,
      const FV::KurganovTadmor::internal::HessianTensor<NumberType, dim, n_components> &H_plus,
      const FV::KurganovTadmor::internal::HessianTensor<NumberType, dim, n_components> &H_minus);
};
static_assert(HasWaveSpeed<MyWaveSpeed>);