Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <iosfwd>
       7             : 
       8             : /// \cond
       9             : namespace Options {
      10             : class Option;
      11             : template <typename T>
      12             : struct create_from_yaml;
      13             : }  // namespace Options
      14             : /// \endcond
      15             : 
      16             : namespace dg {
      17             : /*!
      18             :  * \ingroup DiscontinuousGalerkinGroup
      19             :  * \brief The DG formulation to use
      20             :  *
      21             :  * - The `StrongInertial` formulation is also known as the integrate then
      22             :  *   transform formulation. The "Inertial" part of the name refers to the fact
      23             :  *   that the integration is done over the physical/inertial coordinates, while
      24             :  *   the "strong" part refers to the fact that the boundary correction terms are
      25             :  *   zero if the solution is continuous at the interfaces.
      26             :  *   See \cite Teukolsky2015ega for an overview.
      27             :  * - The `WeakInertial` formulation is also known as the integrate then
      28             :  *   transform formulation. The "Inertial" part of the name refers to the fact
      29             :  *   that the integration is done over the physical/inertial coordinates, while
      30             :  *   the "weak" part refers to the fact that the boundary correction terms are
      31             :  *   non-zero even if the solution is continuous at the interfaces.
      32             :  *   See \cite Teukolsky2015ega for an overview.
      33             :  * - The `StrongLogical` formulation is also known as the transform then
      34             :  *   integrate formulation. The "logical" part of the name refers to the fact
      35             :  *   that the integration is done over the logical coordinates, while the
      36             :  *   "strong" part refers to the fact that the boundary correction terms are
      37             :  *   zero if the solution is continuous at the interfaces. This formulation
      38             :  *   arises from the `StrongInertial` formulation by moving the Jacobians that
      39             :  *   appear when computing the divergence of fluxes into the divergence so the
      40             :  *   divergence is computed in logical coordinates:
      41             :  *   \begin{equation}
      42             :  *     \partial_i F^i = \frac{1}{J} \partial_\hat{\imath} J F^\hat{\imath}
      43             :  *   \end{equation}
      44             :  *   where $J$ is the Jacobian determinant and $\hat{\imath}$ are the logical
      45             :  *   coordinates. This is possible because of the "metric identities"
      46             :  *   \begin{equation}
      47             :  *    \partial_\hat{\imath} \left(J \frac{\partial \xi^\hat{\imath}}
      48             :  *    {\partial x^i}\right) = 0.
      49             :  *   \end{equation}
      50             :  *   See also `dg::metric_identity_det_jac_times_inv_jac` for details and for
      51             :  *   functions that compute the Jacobians so they satisfy the metric identities
      52             :  *   numerically (which may or may not be useful or necessary).
      53             :  */
      54           0 : enum class Formulation { StrongInertial, WeakInertial, StrongLogical };
      55             : 
      56           0 : std::ostream& operator<<(std::ostream& os, Formulation t);
      57             : }  // namespace dg
      58             : 
      59             : /// \cond
      60             : template <>
      61             : struct Options::create_from_yaml<dg::Formulation> {
      62             :   template <typename Metavariables>
      63             :   static dg::Formulation create(const Options::Option& options) {
      64             :     return create<void>(options);
      65             :   }
      66             : };
      67             : 
      68             : template <>
      69             : dg::Formulation Options::create_from_yaml<dg::Formulation>::create<void>(
      70             :     const Options::Option& options);
      71             : /// \endcond