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