Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include "DataStructures/DataBox/Tag.hpp"
       7             : #include "DataStructures/DataVector.hpp"
       8             : #include "DataStructures/Tensor/Tensor.hpp"
       9             : #include "NumericalAlgorithms/DiscontinuousGalerkin/Formulation.hpp"
      10             : #include "NumericalAlgorithms/Spectral/Quadrature.hpp"
      11             : #include "Options/String.hpp"
      12             : #include "Utilities/ErrorHandling/Error.hpp"
      13             : #include "Utilities/TMPL.hpp"
      14             : 
      15             : namespace elliptic::dg {
      16             : /// Option tags related to elliptic discontinuous Galerkin schemes
      17           1 : namespace OptionTags {
      18             : 
      19           0 : struct Discretization {
      20           0 :   static constexpr Options::String help =
      21             :       "Options for the discretization of the elliptic equations";
      22             : };
      23             : 
      24           0 : struct DiscontinuousGalerkin {
      25           0 :   using group = Discretization;
      26           0 :   static constexpr Options::String help =
      27             :       "Options for the discontinuous Galerkin discretization";
      28             : };
      29             : 
      30           0 : struct PenaltyParameter {
      31           0 :   using type = double;
      32           0 :   static constexpr Options::String help =
      33             :       "The prefactor to the penalty term of the numerical flux. Values closer "
      34             :       "to one lead to better-conditioned problems, but on curved meshes the "
      35             :       "penalty parameter may need to be increased to keep the problem "
      36             :       "well-defined.";
      37           0 :   using group = DiscontinuousGalerkin;
      38             : };
      39             : 
      40           0 : struct Massive {
      41           0 :   using type = bool;
      42           0 :   static constexpr Options::String help =
      43             :       "Whether or not to multiply the DG operator with the mass matrix. "
      44             :       "Massive DG operators can be easier to solve because they are symmetric, "
      45             :       "or at least closer to symmetry";
      46           0 :   using group = DiscontinuousGalerkin;
      47             : };
      48             : 
      49           0 : struct Quadrature {
      50           0 :   using type = Spectral::Quadrature;
      51           0 :   static constexpr Options::String help =
      52             :       "The quadrature method used, which determines the distribution of points "
      53             :       "on the grid. Gauss-Lobatto points have a point at the boundary and "
      54             :       "Gauss points do not. Other quadratures are not currently supported.";
      55           0 :   using group = DiscontinuousGalerkin;
      56             : };
      57             : 
      58           0 : struct Formulation {
      59           0 :   using type = ::dg::Formulation;
      60           0 :   static constexpr Options::String help =
      61             :       "The DG formulation to use (strong or weak).";
      62           0 :   using group = DiscontinuousGalerkin;
      63             : };
      64             : 
      65             : }  // namespace OptionTags
      66             : 
      67             : /// DataBox tags related to elliptic discontinuous Galerkin schemes
      68             : namespace Tags {
      69             : 
      70             : /*!
      71             :  * \brief The prefactor to the penalty term of the numerical flux
      72             :  *
      73             :  * \see elliptic::dg::penalty
      74             :  */
      75           1 : struct PenaltyParameter : db::SimpleTag {
      76           0 :   using type = double;
      77           0 :   static constexpr bool pass_metavariables = false;
      78           0 :   using option_tags = tmpl::list<OptionTags::PenaltyParameter>;
      79           0 :   static double create_from_options(const double value) { return value; }
      80             : };
      81             : 
      82             : /*!
      83             :  * \brief The penalty factor in internal penalty fluxes
      84             :  *
      85             :  * \see elliptic::dg::penalty
      86             :  */
      87           1 : struct PenaltyFactor : db::SimpleTag {
      88           0 :   using type = Scalar<DataVector>;
      89             : };
      90             : 
      91             : /// Whether or not to multiply the DG operator with the mass matrix. Massive DG
      92             : /// operators can be easier to solve because they are symmetric, or at least
      93             : /// closer to symmetry.
      94           1 : struct Massive : db::SimpleTag {
      95           0 :   using type = bool;
      96           0 :   static constexpr bool pass_metavariables = false;
      97           0 :   using option_tags = tmpl::list<OptionTags::Massive>;
      98           0 :   static bool create_from_options(const bool value) { return value; }
      99             : };
     100             : 
     101             : /// The quadrature method used for the elliptic DG discretization
     102           1 : struct Quadrature : db::SimpleTag {
     103           0 :   using type = Spectral::Quadrature;
     104           0 :   static constexpr bool pass_metavariables = false;
     105           0 :   using option_tags = tmpl::list<OptionTags::Quadrature>;
     106           0 :   static type create_from_options(const type value) {
     107             :     if (not(value == Spectral::Quadrature::Gauss or
     108             :             value == Spectral::Quadrature::GaussLobatto)) {
     109             :       ERROR_NO_TRACE(
     110             :           "Choose Gauss or Gauss-Lobatto quadrature for elliptic DG "
     111             :           "discretizations.");
     112             :     }
     113             :     return value;
     114             :   }
     115             : };
     116             : 
     117             : /// The DG formulation to use (strong or weak)
     118           1 : struct Formulation : db::SimpleTag {
     119           0 :   using type = ::dg::Formulation;
     120           0 :   static constexpr bool pass_metavariables = false;
     121           0 :   using option_tags = tmpl::list<OptionTags::Formulation>;
     122           0 :   static type create_from_options(const type value) { return value; }
     123             : };
     124             : 
     125             : }  // namespace Tags
     126             : }  // namespace elliptic::dg