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