Line data    Source code

       1            1 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : /// \file
       5              : /// Defines DataBox tags for the curved scalar wave system
       6              : 
       7              : #pragma once
       8              : 
       9              : #include <cstddef>
      10              : #include <string>
      11              : 
      12              : #include "DataStructures/DataBox/Tag.hpp"
      13              : #include "DataStructures/Tensor/TypeAliases.hpp"
      14              : #include "Evolution/Systems/CurvedScalarWave/TagsDeclarations.hpp"
      15              : 
      16              : /// \cond
      17              : class DataVector;
      18              : template <class>
      19              : class Variables;
      20              : /// \endcond
      21              : 
      22              : /// \brief Option tags for the curved scalar wave system.
      23              : namespace CurvedScalarWave::OptionTags {}
      24              : 
      25              : namespace CurvedScalarWave::Tags {
      26              : 
      27              : /*!
      28              :  * \brief The scalar field.
      29              :  */
      30            1 : struct Psi : db::SimpleTag {
      31            0 :   using type = Scalar<DataVector>;
      32              : };
      33              : 
      34              : /*!
      35              :  * \brief The conjugate momentum of the scalar field.
      36              :  *
      37              :  * \details Its definition comes from requiring it to be the future-directed
      38              :  * time derivative of the scalar field \f$\Psi\f$ in curved spacetime, see
      39              :  * \cite Scheel2003vs , Eq. 2.16:
      40              :  *
      41              :  * \f{align}
      42              :  * \Pi :=& -n^a \partial_a \Psi \\
      43              :  *     =&  \frac{1}{\alpha}\left(\beta^k \partial_k \Psi -
      44              :  * {\partial_t\Psi}\right),\\ \f}
      45              :  *
      46              :  * where \f$n^a\f$ is the unit normal to spatial slices of the spacetime
      47              :  * foliation, \f$\alpha\f$ is the lapse and \f$\beta^i\f$ is the shift vector.
      48              :  */
      49            1 : struct Pi : db::SimpleTag {
      50            0 :   using type = Scalar<DataVector>;
      51              : };
      52              : 
      53              : /*!
      54              :  * \brief Auxiliary variable which is analytically the spatial derivative of the
      55              :  * scalar field.
      56              :  * \details If \f$\Psi\f$ is the scalar field then we define
      57              :  * \f$\Phi_{i} = \partial_i \Psi\f$
      58              :  */
      59              : template <size_t SpatialDim, typename Frame>
      60            1 : struct Phi : db::SimpleTag {
      61            0 :   using type = tnsr::i<DataVector, SpatialDim, Frame>;
      62              : };
      63              : 
      64            0 : struct ConstraintGamma1 : db::SimpleTag {
      65            0 :   using type = Scalar<DataVector>;
      66              : };
      67              : 
      68            0 : struct ConstraintGamma2 : db::SimpleTag {
      69            0 :   using type = Scalar<DataVector>;
      70              : };
      71              : 
      72              : /*!
      73              :  * \brief Tag for the one-index constraint of the scalar wave
      74              :  * system in curved spacetime.
      75              :  *
      76              :  * For details on how this is defined and computed, see
      77              :  * `OneIndexConstraintCompute`.
      78              :  */
      79              : template <size_t SpatialDim>
      80            1 : struct OneIndexConstraint : db::SimpleTag {
      81            0 :   using type = tnsr::i<DataVector, SpatialDim, Frame::Inertial>;
      82              : };
      83              : /*!
      84              :  * \brief Tag for the two-index constraint of the scalar wave
      85              :  * system in curved spacetime.
      86              :  *
      87              :  * For details on how this is defined and computed, see
      88              :  * `TwoIndexConstraintCompute`.
      89              :  */
      90              : template <size_t SpatialDim>
      91            1 : struct TwoIndexConstraint : db::SimpleTag {
      92            0 :   using type = tnsr::ij<DataVector, SpatialDim, Frame::Inertial>;
      93              : };
      94              : 
      95              : /// @{
      96              : /// \brief Tags corresponding to the characteristic fields of the
      97              : /// scalar-wave system in curved spacetime.
      98              : ///
      99              : /// \details For details on how these are defined and computed, \see
     100              : /// CharacteristicSpeedsCompute
     101            1 : struct VPsi : db::SimpleTag {
     102            0 :   using type = Scalar<DataVector>;
     103              : };
     104              : template <size_t Dim>
     105            0 : struct VZero : db::SimpleTag {
     106            0 :   using type = tnsr::i<DataVector, Dim, Frame::Inertial>;
     107              : };
     108            0 : struct VPlus : db::SimpleTag {
     109            0 :   using type = Scalar<DataVector>;
     110              : };
     111            0 : struct VMinus : db::SimpleTag {
     112            0 :   using type = Scalar<DataVector>;
     113              : };
     114              : /// @}
     115              : 
     116              : template <size_t Dim>
     117            0 : struct CharacteristicSpeeds : db::SimpleTag {
     118            0 :   using type = std::array<DataVector, 4>;
     119              : };
     120              : 
     121            0 : struct LargestCharacteristicSpeed : db::SimpleTag {
     122            0 :   using type = double;
     123              : };
     124              : 
     125              : template <size_t Dim>
     126            0 : struct CharacteristicFields : db::SimpleTag {
     127            0 :   using type = Variables<tmpl::list<VPsi, VZero<Dim>, VPlus, VMinus>>;
     128              : };
     129              : 
     130              : template <size_t Dim>
     131            0 : struct EvolvedFieldsFromCharacteristicFields : db::SimpleTag {
     132            0 :   using type = Variables<tmpl::list<Psi, Pi, Phi<Dim>>>;
     133              : };
     134              : }  // namespace CurvedScalarWave::Tags