Line data    Source code

       1            1 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : /// \file
       5              : /// Defines DataBox tags for the ScalarGaussBonnet system.
       6              : 
       7              : #pragma once
       8              : 
       9              : #include <string>
      10              : 
      11              : #include "DataStructures/DataBox/Tag.hpp"
      12              : #include "DataStructures/Tensor/EagerMath/DotProduct.hpp"
      13              : #include "DataStructures/Tensor/TypeAliases.hpp"
      14              : #include "Elliptic/Systems/Xcts/Tags.hpp"
      15              : #include "Evolution/Systems/CurvedScalarWave/Tags.hpp"
      16              : #include "NumericalAlgorithms/LinearOperators/PartialDerivatives.hpp"
      17              : #include "Options/Options.hpp"
      18              : #include "Options/String.hpp"
      19              : #include "PointwiseFunctions/GeneralRelativity/Tags.hpp"
      20              : 
      21              : /// \cond
      22              : class DataVector;
      23              : /// \endcond
      24              : 
      25              : namespace sgb {
      26              : /// Tags related to solving the scalar equation in sGB gravity.
      27            1 : namespace OptionTags {
      28              : 
      29            0 : struct OptionGroup {
      30            0 :   static std::string name() { return "ScalarGaussBonnet"; }
      31            0 :   static constexpr Options::String help =
      32              :       "Options for elliptic solve in sGB gravity.";
      33              : };
      34              : 
      35            0 : struct Epsilon2 {
      36            0 :   static std::string name() { return "Epsilon2"; }
      37            0 :   using type = double;
      38            0 :   using group = OptionGroup;
      39            0 :   static constexpr Options::String help{
      40              :       "Epsilon2 (quadratic term) for the coupling function."};
      41              : };
      42              : 
      43            0 : struct Epsilon4 {
      44            0 :   static std::string name() { return "Epsilon4"; }
      45            0 :   using type = double;
      46            0 :   using group = OptionGroup;
      47            0 :   static constexpr Options::String help{
      48              :       "Epsilon4 (quartic term) for the coupling function."};
      49              : };
      50              : 
      51            0 : struct RolloffLocation {
      52            0 :   static std::string name() { return "RolloffLocation"; }
      53            0 :   using type = double;
      54            0 :   using group = OptionGroup;
      55            0 :   static constexpr Options::String help{
      56              :       "Location of center of tanh function for rolling off the shift."};
      57              : };
      58              : 
      59            0 : struct RolloffRate {
      60            0 :   static std::string name() { return "RolloffRate"; }
      61            0 :   using type = double;
      62            0 :   using group = OptionGroup;
      63            0 :   static constexpr Options::String help{
      64              :       "Rate of roll off for rolling off the shift."};
      65              : };
      66              : 
      67              : }  // namespace OptionTags
      68            0 : namespace Tags {
      69              : 
      70              : /*!
      71              :  * \brief Epsilon2 (quadratic term) for the coupling function.
      72              :  */
      73            1 : struct Epsilon2 : db::SimpleTag {
      74            0 :   using type = double;
      75            0 :   using option_tags = tmpl::list<OptionTags::Epsilon2>;
      76            0 :   static constexpr bool pass_metavariables = false;
      77            0 :   static double create_from_options(const double epsilon) { return epsilon; }
      78              : };
      79              : 
      80              : /*!
      81              :  * \brief Epsilon4 (quartic term) for the coupling function.
      82              :  */
      83            1 : struct Epsilon4 : db::SimpleTag {
      84            0 :   using type = double;
      85            0 :   using option_tags = tmpl::list<OptionTags::Epsilon4>;
      86            0 :   static constexpr bool pass_metavariables = false;
      87            0 :   static double create_from_options(const double epsilon) { return epsilon; }
      88              : };
      89              : 
      90              : /*!
      91              :  * \brief Location of center of tanh function for rolling off the shift.
      92              :  */
      93            1 : struct RolloffLocation : db::SimpleTag {
      94            0 :   using type = double;
      95            0 :   using option_tags = tmpl::list<OptionTags::RolloffLocation>;
      96            0 :   static constexpr bool pass_metavariables = false;
      97            0 :   static double create_from_options(const double rolloff_location) {
      98              :     return rolloff_location;
      99              :   }
     100              : };
     101              : 
     102              : /*!
     103              :  * \brief Rate of roll off for rolling off the shift.
     104              :  */
     105            1 : struct RolloffRate : db::SimpleTag {
     106            0 :   using type = double;
     107            0 :   using option_tags = tmpl::list<OptionTags::RolloffRate>;
     108            0 :   static constexpr bool pass_metavariables = false;
     109            0 :   static double create_from_options(const double rolloff_rate) {
     110              :     return rolloff_rate;
     111              :   }
     112              : };
     113              : 
     114              : /*!
     115              :  * \brief The scalar field $\Psi$.
     116              :  */
     117            1 : struct Psi : db::SimpleTag {
     118            0 :   using type = Scalar<DataVector>;
     119              : };
     120              : 
     121              : /*!
     122              :  * \brief Rolled-off shift (i.e. the shift used in computing the fluxes).
     123              :  */
     124            1 : struct RolledOffShift : db::SimpleTag {
     125            0 :   using type = tnsr::I<DataVector, 3, Frame::Inertial>;
     126              : };
     127              : 
     128              : /*!
     129              :  * \brief Pi computed using the rolled-off shift.
     130              :  */
     131            1 : struct PiWithRolledOffShift : db::SimpleTag {
     132            0 :   using type = Scalar<DataVector>;
     133              : };
     134              : }  // namespace Tags
     135              : }  // namespace sgb