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