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 "Evolution/Systems/GeneralizedHarmonic/ConstraintDamping/DampingFunction.hpp"
      11             : #include "Options/String.hpp"
      12             : 
      13             : /// \cond
      14             : namespace gh::OptionTags {
      15             : struct Group;
      16             : }  // namespace gh::OptionTags
      17             : /// \endcond
      18             : 
      19             : namespace gh::ConstraintDamping {
      20           0 : namespace OptionTags {
      21             : template <size_t VolumeDim, typename Fr>
      22           0 : struct DampingFunctionGamma0 {
      23           0 :   using type =
      24             :       std::unique_ptr<::gh::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<::gh::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<::gh::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           0 : 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             :       ::gh::ConstraintDamping::DampingFunction<VolumeDim, Fr>;
      82           0 :   using type = std::unique_ptr<DampingFunctionType>;
      83           0 :   using option_tags =
      84             :       tmpl::list<::gh::ConstraintDamping::OptionTags::DampingFunctionGamma0<
      85             :           VolumeDim, Fr>>;
      86             : 
      87           0 :   static constexpr bool pass_metavariables = false;
      88           0 :   static type create_from_options(const type& damping_function) {
      89             :     return damping_function->get_clone();
      90             :   }
      91             : };
      92             : 
      93             : /*!
      94             :  * \brief A DampingFunction to compute the constraint damping parameter
      95             :  * \f$\gamma_0\f$.
      96             :  */
      97             : template <size_t VolumeDim, typename Fr>
      98           1 : struct DampingFunctionGamma1 : db::SimpleTag {
      99           0 :   using DampingFunctionType =
     100             :       ::gh::ConstraintDamping::DampingFunction<VolumeDim, Fr>;
     101           0 :   using type = std::unique_ptr<DampingFunctionType>;
     102           0 :   using option_tags =
     103             :       tmpl::list<::gh::ConstraintDamping::OptionTags::DampingFunctionGamma1<
     104             :           VolumeDim, Fr>>;
     105             : 
     106           0 :   static constexpr bool pass_metavariables = false;
     107           0 :   static type create_from_options(const type& damping_function) {
     108             :     return damping_function->get_clone();
     109             :   }
     110             : };
     111             : 
     112             : /*!
     113             :  * \brief A DampingFunction to compute the constraint damping parameter
     114             :  * \f$\gamma_0\f$.
     115             :  */
     116             : template <size_t VolumeDim, typename Fr>
     117           1 : struct DampingFunctionGamma2 : db::SimpleTag {
     118           0 :   using DampingFunctionType =
     119             :       ::gh::ConstraintDamping::DampingFunction<VolumeDim, Fr>;
     120           0 :   using type = std::unique_ptr<DampingFunctionType>;
     121           0 :   using option_tags =
     122             :       tmpl::list<::gh::ConstraintDamping::OptionTags::DampingFunctionGamma2<
     123             :           VolumeDim, Fr>>;
     124             : 
     125           0 :   static constexpr bool pass_metavariables = false;
     126           0 :   static type create_from_options(const type& damping_function) {
     127             :     return damping_function->get_clone();
     128             :   }
     129             : };
     130             : }  // namespace Tags
     131             : }  // namespace gh::ConstraintDamping