Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <cstddef>
       7             : #include <memory>
       8             : 
       9             : #include "DataStructures/DataBox/Prefixes.hpp"
      10             : #include "Options/String.hpp"
      11             : #include "PointwiseFunctions/ConstraintDamping/DampingFunction.hpp"
      12             : 
      13             : /// \cond
      14             : namespace gh::OptionTags {
      15             : struct Group;
      16             : }  // namespace gh::OptionTags
      17             : /// \endcond
      18             : 
      19             : namespace gh {
      20             : namespace OptionTags {
      21             : template <size_t VolumeDim, typename Fr>
      22           0 : struct DampingFunctionGamma0 {
      23           0 :   using type =
      24             :       std::unique_ptr<::ConstraintDamping::DampingFunction<VolumeDim, Fr>>;
      25           0 :   static constexpr Options::String help{
      26             :       "DampingFunction for damping parameter gamma0"};
      27           0 :   using group = gh::OptionTags::Group;
      28             : };
      29             : 
      30             : template <size_t VolumeDim, typename Fr>
      31           0 : struct DampingFunctionGamma1 {
      32           0 :   using type =
      33             :       std::unique_ptr<::ConstraintDamping::DampingFunction<VolumeDim, Fr>>;
      34           0 :   static constexpr Options::String help{
      35             :       "DampingFunction for damping parameter gamma1"};
      36           0 :   using group = gh::OptionTags::Group;
      37             : };
      38             : 
      39             : template <size_t VolumeDim, typename Fr>
      40           0 : struct DampingFunctionGamma2 {
      41           0 :   using type =
      42             :       std::unique_ptr<::ConstraintDamping::DampingFunction<VolumeDim, Fr>>;
      43           0 :   static constexpr Options::String help{
      44             :       "DampingFunction for damping parameter gamma2"};
      45           0 :   using group = gh::OptionTags::Group;
      46             : };
      47             : }  // namespace OptionTags
      48             : 
      49             : namespace Tags {
      50             : /*!
      51             :  * \brief Constraint dammping parameter \f$\gamma_0\f$ for the generalized
      52             :  * harmonic system (cf. \cite Lindblom2005qh).
      53             :  */
      54           1 : struct ConstraintGamma0 : db::SimpleTag {
      55           0 :   using type = Scalar<DataVector>;
      56             : };
      57             : 
      58             : /*!
      59             :  * \brief Constraint dammping parameter \f$\gamma_1\f$ for the generalized
      60             :  * harmonic system (cf. \cite Lindblom2005qh).
      61             :  */
      62           1 : struct ConstraintGamma1 : db::SimpleTag {
      63           0 :   using type = Scalar<DataVector>;
      64             : };
      65             : 
      66             : /*!
      67             :  * \brief Constraint dammping parameter \f$\gamma_2\f$ for the generalized
      68             :  * harmonic system (cf. \cite Lindblom2005qh).
      69             :  */
      70           1 : struct ConstraintGamma2 : db::SimpleTag {
      71           0 :   using type = Scalar<DataVector>;
      72             : };
      73             : 
      74             : /*!
      75             :  * \brief A DampingFunction to compute the constraint damping parameter
      76             :  * \f$\gamma_0\f$.
      77             :  */
      78             : template <size_t VolumeDim, typename Fr>
      79           1 : struct DampingFunctionGamma0 : db::SimpleTag {
      80           0 :   using DampingFunctionType =
      81             :       ::ConstraintDamping::DampingFunction<VolumeDim, Fr>;
      82           0 :   using type = std::unique_ptr<DampingFunctionType>;
      83           0 :   using option_tags =
      84             :       tmpl::list<::gh::OptionTags::DampingFunctionGamma0<VolumeDim, Fr>>;
      85             : 
      86           0 :   static constexpr bool pass_metavariables = false;
      87           0 :   static type create_from_options(const type& damping_function) {
      88             :     return damping_function->get_clone();
      89             :   }
      90             : };
      91             : 
      92             : /*!
      93             :  * \brief A DampingFunction to compute the constraint damping parameter
      94             :  * \f$\gamma_0\f$.
      95             :  */
      96             : template <size_t VolumeDim, typename Fr>
      97           1 : struct DampingFunctionGamma1 : db::SimpleTag {
      98           0 :   using DampingFunctionType =
      99             :       ::ConstraintDamping::DampingFunction<VolumeDim, Fr>;
     100           0 :   using type = std::unique_ptr<DampingFunctionType>;
     101           0 :   using option_tags =
     102             :       tmpl::list<::gh::OptionTags::DampingFunctionGamma1<VolumeDim, Fr>>;
     103             : 
     104           0 :   static constexpr bool pass_metavariables = false;
     105           0 :   static type create_from_options(const type& damping_function) {
     106             :     return damping_function->get_clone();
     107             :   }
     108             : };
     109             : 
     110             : /*!
     111             :  * \brief A DampingFunction to compute the constraint damping parameter
     112             :  * \f$\gamma_0\f$.
     113             :  */
     114             : template <size_t VolumeDim, typename Fr>
     115           1 : struct DampingFunctionGamma2 : db::SimpleTag {
     116           0 :   using DampingFunctionType =
     117             :       ::ConstraintDamping::DampingFunction<VolumeDim, Fr>;
     118           0 :   using type = std::unique_ptr<DampingFunctionType>;
     119           0 :   using option_tags =
     120             :       tmpl::list<::gh::OptionTags::DampingFunctionGamma2<VolumeDim, Fr>>;
     121             : 
     122           0 :   static constexpr bool pass_metavariables = false;
     123           0 :   static type create_from_options(const type& damping_function) {
     124             :     return damping_function->get_clone();
     125             :   }
     126             : };
     127             : }  // namespace Tags
     128             : }  // namespace gh