Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <array>
       7              : 
       8              : #include "DataStructures/Tensor/TypeAliases.hpp"
       9              : 
      10              : namespace gr::Solutions {
      11              : 
      12              : /*!
      13              :  * \brief The Kerr-Schild radius corresponding to a Boyer-Lindquist radius.
      14              :  *
      15              :  * \details Computes the radius of a surface of constant Boyer-Lindquist radius
      16              :  * as a function of angles.  The input argument `theta_phi` is typically the
      17              :  * output of the `theta_phi_points()` method of a `ylm::Spherepack` object;
      18              :  * i.e., a std::array of two DataVectors containing the values of theta and
      19              :  * phi at each point on a Strahlkorper.
      20              :  *
      21              :  *
      22              :  * Derivation:
      23              :  *
      24              :  * Define spherical coordinates \f$(r,\theta,\phi)\f$ in the usual way
      25              :  * from the Cartesian Kerr-Schild coordinates \f$(x,y,z)\f$
      26              :  * (i.e. \f$x = r \sin\theta \cos\phi\f$ and so on).
      27              :  * Then the relationship between \f$r\f$ and the radial
      28              :  * Boyer-Lindquist coordinate \f$r_{BL}\f$ is
      29              :  * \f[
      30              :  * r_{BL}^2 = \frac{1}{2}(r^2 - a^2)
      31              :  *     + \left(\frac{1}{4}(r^2-a^2)^2 +
      32              :  *             r^2(\vec{a}\cdot \hat{x})^2\right)^{1/2},
      33              :  * \f]
      34              :  * where \f$\vec{a}\f$ is the Kerr spin vector (with units of mass),
      35              :  * \f$\hat{x}\f$ means \f$(x/r,y/r,z/r)\f$, and the dot product is
      36              :  * taken as in flat space.
      37              :  *
      38              :  * We solve the above equation for \f$r^2\f$ as a function of angles,
      39              :  * yielding
      40              :  * \f[
      41              :  *     r^2 = \frac{r_{BL}^2 (r_{BL}^2 + a^2)}
      42              :                   {r_{BL}^2+(\vec{a}\cdot \hat{x})^2},
      43              :  * \f]
      44              :  * where the angles are encoded in \f$\hat x\f$ and everything else on the
      45              :  * right-hand side is constant.
      46              :  */
      47              : template <typename DataType>
      48            1 : Scalar<DataType> kerr_schild_radius_from_boyer_lindquist(
      49              :     const double boyer_lindquist_radius,
      50              :     const std::array<DataType, 2>& theta_phi, double mass,
      51              :     const std::array<double, 3>& dimensionless_spin);
      52              : /*!
      53              :  * \brief The Kerr-Schild radius corresponding to a Kerr horizon.
      54              :  *
      55              :  * \details `kerr_horizon_radius` evaluates \f$r\f$ using the above equation in
      56              :  * the documentation for `kerr_schild_radius_from_boyer_lindquist`, and
      57              :  * using the standard expression for the Boyer-Lindquist radius of the
      58              :  * Kerr horizon:
      59              :  * \f[
      60              :  *   r_{BL} = r_+ = M + \sqrt{M^2-a^2}.
      61              :  * \f]
      62              :  *
      63              :  * \note If the spin is nearly extremal, this function has accuracy
      64              :  *       limited to roughly \f$10^{-8}\f$, because of roundoff amplification
      65              :  *       from computing \f$M + \sqrt{M^2-a^2}\f$.
      66              :  */
      67              : template <typename DataType>
      68            1 : Scalar<DataType> kerr_horizon_radius(
      69              :     const std::array<DataType, 2>& theta_phi, double mass,
      70              :     const std::array<double, 3>& dimensionless_spin);
      71              : 
      72              : }  // namespace gr::Solutions