SpECTRE Documentation Coverage Report
Current view: top level - Evolution/Systems/ScalarWave - Tags.hpp Hit Total Coverage
Commit: b1342d46f40e2d46bbd11d0cef68fd973031a24b Lines: 4 38 10.5 %
Date: 2020-09-24 20:24:42
Legend: Lines: hit not hit

          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 scalar wave system
       6             : 
       7             : #pragma once
       8             : 
       9             : #include <cstddef>
      10             : #include <string>
      11             : 
      12             : #include "DataStructures/DataBox/Prefixes.hpp"
      13             : #include "DataStructures/DataBox/Tag.hpp"
      14             : #include "DataStructures/Tensor/TypeAliases.hpp"
      15             : #include "Evolution/Systems/ScalarWave/TagsDeclarations.hpp"
      16             : 
      17             : class DataVector;
      18             : 
      19             : namespace ScalarWave {
      20           0 : struct Psi : db::SimpleTag {
      21           0 :   using type = Scalar<DataVector>;
      22           0 :   static std::string name() noexcept { return "Psi"; }
      23             : };
      24             : 
      25           0 : struct Pi : db::SimpleTag {
      26           0 :   using type = Scalar<DataVector>;
      27           0 :   static std::string name() noexcept { return "Pi"; }
      28             : };
      29             : 
      30             : template <size_t Dim>
      31           0 : struct Phi : db::SimpleTag {
      32           0 :   using type = tnsr::i<DataVector, Dim, Frame::Inertial>;
      33           0 :   static std::string name() noexcept { return "Phi"; }
      34             : };
      35             : 
      36             : namespace Tags {
      37           0 : struct ConstraintGamma2 : db::SimpleTag {
      38           0 :   using type = Scalar<DataVector>;
      39           0 :   static std::string name() noexcept { return "ConstraintGamma2"; }
      40             : };
      41             : 
      42             : /*!
      43             :  * \brief Tag for the one-index constraint of the ScalarWave system
      44             :  *
      45             :  * For details on how this is defined and computed, see
      46             :  * `OneIndexConstraintCompute`.
      47             :  */
      48             : template <size_t Dim>
      49           1 : struct OneIndexConstraint : db::SimpleTag {
      50           0 :   using type = tnsr::i<DataVector, Dim, Frame::Inertial>;
      51             : };
      52             : /*!
      53             :  * \brief Tag for the two-index constraint of the ScalarWave system
      54             :  *
      55             :  * For details on how this is defined and computed, see
      56             :  * `TwoIndexConstraintCompute`.
      57             :  */
      58             : template <size_t Dim>
      59           1 : struct TwoIndexConstraint : db::SimpleTag {
      60           0 :   using type = tnsr::ij<DataVector, Dim, Frame::Inertial>;
      61             : };
      62             : 
      63             : // @{
      64             : /// \brief Tags corresponding to the characteristic fields of the flat-spacetime
      65             : /// scalar-wave system.
      66             : ///
      67             : /// \details For details on how these are defined and computed, \see
      68             : /// CharacteristicSpeedsCompute
      69           1 : struct VPsi : db::SimpleTag {
      70           0 :   using type = Scalar<DataVector>;
      71           0 :   static std::string name() noexcept { return "VPsi"; }
      72             : };
      73             : template <size_t Dim>
      74           0 : struct VZero : db::SimpleTag {
      75           0 :   using type = tnsr::i<DataVector, Dim, Frame::Inertial>;
      76           0 :   static std::string name() noexcept { return "VZero"; }
      77             : };
      78           0 : struct VPlus : db::SimpleTag {
      79           0 :   using type = Scalar<DataVector>;
      80           0 :   static std::string name() noexcept { return "VPlus"; }
      81             : };
      82           0 : struct VMinus : db::SimpleTag {
      83           0 :   using type = Scalar<DataVector>;
      84           0 :   static std::string name() noexcept { return "VMinus"; }
      85             : };
      86             : // @}
      87             : 
      88             : template <size_t Dim>
      89           0 : struct CharacteristicSpeeds : db::SimpleTag {
      90           0 :   using type = std::array<DataVector, 4>;
      91           0 :   static std::string name() noexcept { return "CharacteristicSpeeds"; }
      92             : };
      93             : 
      94             : template <size_t Dim>
      95           0 : struct CharacteristicFields : db::SimpleTag {
      96           0 :   using type = Variables<tmpl::list<VPsi, VZero<Dim>, VPlus, VMinus>>;
      97           0 :   static std::string name() noexcept { return "CharacteristicFields"; }
      98             : };
      99             : 
     100             : template <size_t Dim>
     101           0 : struct EvolvedFieldsFromCharacteristicFields : db::SimpleTag {
     102           0 :   using type = Variables<tmpl::list<Psi, Pi, Phi<Dim>>>;
     103           0 :   static std::string name() noexcept {
     104             :     return "EvolvedFieldsFromCharacteristicFields";
     105             :   }
     106             : };
     107             : }  // namespace Tags
     108             : }  // namespace ScalarWave

Generated by: LCOV version 1.14