Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <cstddef>
       7              : 
       8              : #include "DataStructures/DataBox/Tag.hpp"
       9              : #include "DataStructures/Tensor/TypeAliases.hpp"
      10              : #include "PointwiseFunctions/GeneralRelativity/Tags.hpp"
      11              : #include "Utilities/TMPL.hpp"
      12              : 
      13              : /// \cond
      14              : namespace gsl {
      15              : template <typename>
      16              : struct not_null;
      17              : }  // namespace gsl
      18              : /// \endcond
      19              : 
      20              : namespace gr {
      21              : 
      22              : /// @{
      23              : /*!
      24              :  * \brief Computes the Pontryagin scalar in vacuum.
      25              :  *
      26              :  * \details The Pontryagin scalar in vacuum is given by
      27              :  * \begin{align}
      28              :  *   \mathcal{P} &\equiv {^{\star} C}_{abcd} C^{abcd} \\
      29              :  *    &= - 16 E_{ab} B^{ab} ~,
      30              :  * \end{align}
      31              :  * where $ C_{abcd} $ it the Weyl tensor (with dual $ {^\star} C}_{abcd} $) in 4
      32              :  * spacetime dimensions. Here it is computed in terms of the electric ($
      33              :  * E_{ab} $) and magnetic ($ B_{ab} $) parts of the Weyl scalar, with the
      34              :  * conventions used here for ($ \{E_{ab}, B_{ab}\} $).
      35              :  *
      36              :  * \see `gr::Tags::WeylMagnetic` and `gr::Tags::WeylElectric`
      37              :  *
      38              :  */
      39              : template <typename Frame>
      40            1 : void pontryagin_scalar_in_vacuum(
      41              :     gsl::not_null<Scalar<DataVector>*> pontryagin_scalar,
      42              :     const tnsr::ii<DataVector, 3, Frame>& weyl_electric,
      43              :     const tnsr::ii<DataVector, 3, Frame>& weyl_magnetic,
      44              :     const tnsr::II<DataVector, 3, Frame>& inverse_spatial_metric);
      45              : 
      46              : template <typename Frame>
      47            1 : Scalar<DataVector> pontryagin_scalar_in_vacuum(
      48              :     const tnsr::ii<DataVector, 3, Frame>& weyl_electric,
      49              :     const tnsr::ii<DataVector, 3, Frame>& weyl_magnetic,
      50              :     const tnsr::II<DataVector, 3, Frame>& inverse_spatial_metric);
      51              : /// @}
      52              : 
      53              : /// @{
      54              : /*!
      55              :  * \brief Computes Gauss-Bonnet scalar in vacuum.
      56              :  *
      57              :  * \details The Gauss-Bonnet scalar in vacuum is given by
      58              :  * \begin{align}
      59              :  *   \mathcal{G} &\equiv R_{abcd} R^{abcd} - 4 R_{ab} R^{ab} + R^2
      60              :  *    &= C_{abcd} C^{abcd}
      61              :  *    &= 8 (E_{ab} E^{ab} - B_{ab} B^{ab}) ~,
      62              :  * \end{align}
      63              :  * where $ R_{abcd} $, $ R_{ab} $, $ R $ $ C_{abcd} $ are the Riemann tensor,
      64              :  * Ricci tensor, Ricci scalar and Weyl tensor in 4 spacetime dimensions. The
      65              :  * Gauss-Bonnet scalar in vacuum can be computed in terms of the electric ($
      66              :  * E_{ab} $) and magnetic ($ B_{ab} $) parts of the Weyl tensor.
      67              :  *
      68              :  * \see `gr::Tags::WeylMagnetic` and `gr::Tags::WeylElectric`
      69              :  *
      70              :  */
      71            1 : void gauss_bonnet_scalar_in_vacuum(
      72              :     gsl::not_null<Scalar<DataVector>*> gb_scalar,
      73              :     const Scalar<DataVector>& weyl_electric_scalar,
      74              :     const Scalar<DataVector>& weyl_magnetic_scalar);
      75              : 
      76            1 : Scalar<DataVector> gauss_bonnet_scalar_in_vacuum(
      77              :     const Scalar<DataVector>& weyl_electric_scalar,
      78              :     const Scalar<DataVector>& weyl_magnetic_scalar);
      79              : /// @}
      80              : 
      81              : }  // namespace gr
      82              : 
      83              : namespace gr::Tags {
      84              : /// @{
      85              : /*!
      86              :  * \brief Tags for the PontryaginScalar in vacuum.
      87              :  *
      88              :  * The tags are tested in Test_CurvatureScalarComputeTags.cpp
      89              :  */
      90              : template <typename DataType>
      91            1 : struct PontryaginScalar : db::SimpleTag {
      92            0 :   using type = Scalar<DataType>;
      93              : };
      94              : 
      95              : template <typename DataType, size_t Dim, typename Frame>
      96            0 : struct PontryaginScalarCompute : PontryaginScalar<DataType>, db::ComputeTag {
      97            0 :   using argument_tags =
      98              :       tmpl::list<gr::Tags::WeylElectric<DataType, Dim, Frame>,
      99              :                  gr::Tags::WeylMagnetic<DataType, Dim, Frame>,
     100              :                  gr::Tags::InverseSpatialMetric<DataType, Dim, Frame>>;
     101            0 :   using return_type = Scalar<DataType>;
     102            0 :   static constexpr auto function = static_cast<void (*)(
     103              :       gsl::not_null<Scalar<DataType>*>, const tnsr::ii<DataType, Dim, Frame>&,
     104              :       const tnsr::ii<DataType, Dim, Frame>&,
     105              :       const tnsr::II<DataType, Dim, Frame>&)>(
     106              :       &gr::pontryagin_scalar_in_vacuum<Frame>);
     107            0 :   using base = PontryaginScalar<DataType>;
     108              : };
     109              : /// @{
     110              : 
     111              : /// @{
     112              : /*!
     113              :  * \brief Tags for the Gauss Bonnet Scalar in vacuum.
     114              :  *
     115              :  * The tags are tested in Test_CurvatureScalarComputeTags.cpp
     116              :  */
     117              : template <typename DataType>
     118            1 : struct GaussBonnetScalar : db::SimpleTag {
     119            0 :   using type = Scalar<DataType>;
     120              : };
     121              : 
     122              : template <typename DataType>
     123            0 : struct GaussBonnetScalarCompute : GaussBonnetScalar<DataType>, db::ComputeTag {
     124            0 :   using argument_tags = tmpl::list<gr::Tags::WeylElectricScalar<DataType>,
     125              :                                    gr::Tags::WeylMagneticScalar<DataType>>;
     126            0 :   using return_type = Scalar<DataType>;
     127            0 :   static constexpr auto function =
     128              :       static_cast<void (*)(gsl::not_null<Scalar<DataType>*>,
     129              :                            const Scalar<DataType>&, const Scalar<DataType>&)>(
     130              :           &gr::gauss_bonnet_scalar_in_vacuum);
     131            0 :   using base = GaussBonnetScalar<DataType>;
     132              : };
     133              : /// @}
     134              : }  // namespace gr::Tags