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