Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <string>
       7             : 
       8             : #include "DataStructures/DataBox/Tag.hpp"
       9             : #include "DataStructures/Tensor/TypeAliases.hpp"
      10             : #include "Domain/Creators/DomainCreator.hpp"
      11             : #include "Domain/Creators/OptionTags.hpp"
      12             : #include "Domain/Structure/BlockGroups.hpp"
      13             : 
      14             : /// \cond
      15             : class ComplexDataVector;
      16             : class DataVector;
      17             : /// \endcond
      18             : 
      19             : /*!
      20             :  * \ingroup EllipticSystemsGroup
      21             :  * \brief Items related to solving the gravitational self-force of a gravitating
      22             :  * body in a Kerr background.
      23             :  *
      24             :  * \see GrSelfForce::FirstOrderSystem
      25             :  */
      26             : namespace GrSelfForce {
      27             : 
      28           0 : namespace OptionTags {
      29             : 
      30           0 : struct OptionGroup {
      31           0 :   static std::string name() { return "GrSelfForce"; }
      32           0 :   static constexpr Options::String help =
      33             :       "Options for the GR self-force system";
      34             : };
      35             : 
      36           0 : struct NullSlicingBlocks {
      37           0 :   using group = OptionGroup;
      38           0 :   using type = std::vector<std::string>;
      39           0 :   static constexpr Options::String help =
      40             :       "The blocks in which to use null slicing (vtu-slicing).";
      41             : };
      42             : 
      43             : }  // namespace OptionTags
      44             : 
      45             : /// Tags for the GrSelfForce system.
      46           1 : namespace Tags {
      47             : 
      48             : /*!
      49             :  * \brief The complex m-mode field $(\Psi_m)_{ab}$.
      50             :  *
      51             :  * Defined by the m-mode decomposition of the metric perturbation $h_{ab}$:
      52             :  * \begin{equation}
      53             :  * \bar{h}_{ab}(t,r,\theta,\phi) = \sum_{m=-\infty}^{\infty}
      54             :  *   \bar{h}^m_{ab}(r,\theta) e^{im(\phi - \Omega t)}
      55             :  * \end{equation}
      56             :  * and further decomposition with convenient prefactors:
      57             :  * \begin{align*}
      58             :  * &(\Psi_m)_{tt} = r \bar{h}^m_{tt} \\
      59             :  * &(\Psi_m)_{tr} = \frac{\Delta}{r} \bar{h}^m_{tr} \\
      60             :  * &(\Psi_m)_{t\theta} = \bar{h}^m_{t\theta} \\
      61             :  * &(\Psi_m)_{t\phi} = \frac{1}{\sin\theta} \bar{h}^m_{t\phi} \\
      62             :  * &(\Psi_m)_{rr} = \frac{\Delta^2}{r^3} \bar{h}^m_{rr} \\
      63             :  * &(\Psi_m)_{r\theta} = \frac{\Delta}{r^2} \bar{h}^m_{r\theta} \\
      64             :  * &(\Psi_m)_{r\phi} = \frac{\Delta}{r^2\sin\theta} \bar{h}^m_{r\phi} \\
      65             :  * &(\Psi_m)_{\theta\theta} = \frac{1}{r} \bar{h}^m_{\theta\theta} \\
      66             :  * &(\Psi_m)_{\theta\phi} = \frac{1}{r\sin\theta} \bar{h}^m_{\theta\phi} \\
      67             :  * &(\Psi_m)_{\phi\phi} = \frac{1}{r\sin^2\theta} \bar{h}^m_{\phi\phi} \\
      68             :  * \end{align*}
      69             :  */
      70           1 : struct MMode : db::SimpleTag {
      71           0 :   using type = tnsr::aa<ComplexDataVector, 3>;
      72             : };
      73             : 
      74             : /*!
      75             :  * \brief The factor multiplying the angular derivative in the principal part of
      76             :  * the equations.
      77             :  *
      78             :  * This is the factor $\alpha$ that defines the principal part of the equations
      79             :  * and allows to write it in first-order flux form (see
      80             :  * `GrSelfForce::FirstOrderSystem`). This factor is set by the analytic data
      81             :  * class (see `ScalarSelfForce::AnalyticData::CircularOrbit`).
      82             :  */
      83           1 : struct Alpha : db::SimpleTag {
      84           0 :   using type = Scalar<ComplexDataVector>;
      85             : };
      86             : 
      87             : /*!
      88             :  * \brief The factors $\beta_{ab}^{cd}$ multiplying the non-derivative terms in
      89             :  * the equations.
      90             :  */
      91           1 : struct Beta : db::SimpleTag {
      92           0 :   using type = tnsr::aaBB<ComplexDataVector, 3>;
      93             : };
      94             : 
      95             : /*!
      96             :  * \brief The factors $\gamma_{{r_\star}ab}^{cd}$ multiplying the
      97             :  * $r_\star$-derivative terms in the equations.
      98             :  */
      99           1 : struct GammaRstar : db::SimpleTag {
     100           0 :   using type = tnsr::aaBB<ComplexDataVector, 3>;
     101             : };
     102             : 
     103             : /*!
     104             :  * \brief The factors $\gamma_{\theta ab}^{cd}$ multiplying the
     105             :  * $\theta$-derivative terms in the equations.
     106             :  */
     107           1 : struct GammaTheta : db::SimpleTag {
     108           0 :   using type = tnsr::aaBB<ComplexDataVector, 3>;
     109             : };
     110             : 
     111             : /*!
     112             :  * \brief A flag indicating that we are solving for the regularized field in
     113             :  * this element.
     114             :  *
     115             :  * In elements at and around the point mass we use the effective source
     116             :  * approach to split the m-mode field into a singular and a regular field
     117             :  * [Eq. (3.6) in \cite Osburn:2022bby ]:
     118             :  * \begin{equation}
     119             :  * \Psi_m = \Psi_m^\mathcal{P} + \Psi_m^\mathcal{R}
     120             :  * \text{.}
     121             :  * \end{equation}
     122             :  * In these elements, we solve for $\Psi_m^\mathcal{R}$ rather than $\Psi_m$.
     123             :  */
     124           1 : struct FieldIsRegularized : db::SimpleTag {
     125           0 :   using type = bool;
     126             : };
     127             : 
     128             : /*!
     129             :  * \brief The singular field $\Psi_m^\mathcal{P}$.
     130             :  *
     131             :  * Only defined where `FieldIsRegularized` is true.
     132             :  */
     133           1 : struct SingularField : db::SimpleTag {
     134           0 :   using type = tnsr::aa<ComplexDataVector, 3>;
     135             : };
     136             : 
     137             : /*!
     138             :  * \brief The Boyer-Lindquist radius $r$.
     139             :  *
     140             :  * Computed numerically from the tortoise radial coordinate $r_\star$
     141             :  * [see Eq. (2.12) in \cite Osburn:2022bby ].
     142             :  */
     143           1 : struct BoyerLindquistRadius : db::SimpleTag {
     144           0 :   using type = Scalar<DataVector>;
     145             : };
     146             : 
     147             : /*!
     148             :  * \brief Blocks in which we use null slicing (vtu-slicing).
     149             :  */
     150             : template <size_t Dim>
     151           1 : struct NullSlicingBlocks : db::SimpleTag {
     152           0 :   using type = std::vector<size_t>;
     153           0 :   using option_tags = tmpl::list<OptionTags::NullSlicingBlocks,
     154             :                                  domain::OptionTags::DomainCreator<Dim>>;
     155           0 :   static constexpr bool pass_metavariables = false;
     156           0 :   static type create_from_options(
     157             :       const std::vector<std::string>& null_slicing_blocks,
     158             :       const std::unique_ptr<DomainCreator<Dim>>& domain_creator) {
     159             :     return domain::block_ids_from_names(null_slicing_blocks,
     160             :                                         domain_creator->block_names(),
     161             :                                         domain_creator->block_groups());
     162             :   }
     163             : };
     164             : 
     165             : }  // namespace Tags
     166             : }  // namespace GrSelfForce