Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <array>
       7              : #include <cstddef>
       8              : #include <string>
       9              : #include <utility>
      10              : 
      11              : #include "DataStructures/DataBox/Tag.hpp"
      12              : #include "DataStructures/DataBox/TagName.hpp"
      13              : #include "Domain/Structure/DirectionalIdMap.hpp"
      14              : #include "NumericalAlgorithms/DiscontinuousGalerkin/SimpleMortarData.hpp"
      15              : #include "NumericalAlgorithms/Spectral/SegmentSize.hpp"
      16              : #include "Options/String.hpp"
      17              : #include "Utilities/PrettyType.hpp"
      18              : 
      19              : /// Functionality related to discontinuous Galerkin schemes
      20              : namespace dg {}
      21              : 
      22              : namespace Tags {
      23              : /// \ingroup DataBoxTagsGroup
      24              : /// \ingroup DiscontinuousGalerkinGroup
      25              : /// Data on mortars, indexed by a DirectionalId
      26              : template <typename Tag, size_t VolumeDim>
      27            1 : struct Mortars : db::PrefixTag, db::SimpleTag {
      28            0 :   using tag = Tag;
      29            0 :   using type = DirectionalIdMap<VolumeDim, typename Tag::type>;
      30              : };
      31              : 
      32              : /// \ingroup DataBoxTagsGroup
      33              : /// \ingroup DiscontinuousGalerkinGroup
      34              : /// Size of a mortar, relative to the element face.  That is, the part
      35              : /// of the face that it covers.
      36              : template <size_t Dim>
      37            1 : struct MortarSize : db::SimpleTag {
      38            0 :   using type = std::array<Spectral::SegmentSize, Dim>;
      39              : };
      40              : }  // namespace Tags
      41              : 
      42              : namespace OptionTags {
      43              : /*!
      44              :  * \ingroup OptionGroupsGroup
      45              :  * \brief Holds the `OptionTags::NumericalFlux` option in the input file
      46              :  */
      47            1 : struct NumericalFluxGroup {
      48            0 :   static std::string name() { return "NumericalFlux"; }
      49            0 :   static constexpr Options::String help = "The numerical flux scheme";
      50              : };
      51              : 
      52              : /*!
      53              :  * \ingroup OptionTagsGroup
      54              :  * \brief The option tag that retrieves the parameters for the numerical
      55              :  * flux from the input file
      56              :  */
      57              : template <typename NumericalFluxType>
      58            1 : struct NumericalFlux {
      59            0 :   static std::string name() { return pretty_type::name<NumericalFluxType>(); }
      60            0 :   static constexpr Options::String help = "Options for the numerical flux";
      61            0 :   using type = NumericalFluxType;
      62            0 :   using group = NumericalFluxGroup;
      63              : };
      64              : }  // namespace OptionTags
      65              : 
      66              : namespace Tags {
      67              : /*!
      68              :  * \brief The global cache tag for the numerical flux
      69              :  */
      70              : template <typename NumericalFluxType>
      71            1 : struct NumericalFlux : db::SimpleTag {
      72            0 :   using type = NumericalFluxType;
      73            0 :   using option_tags =
      74              :       tmpl::list<::OptionTags::NumericalFlux<NumericalFluxType>>;
      75              : 
      76            0 :   static constexpr bool pass_metavariables = false;
      77            0 :   static NumericalFluxType create_from_options(
      78              :       const NumericalFluxType& numerical_flux) {
      79              :     return numerical_flux;
      80              :   }
      81              : };
      82              : }  // namespace Tags