Line data    Source code

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