Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <string>
       7             : 
       8             : #include "DataStructures/DataBox/Tag.hpp"
       9             : #include "DataStructures/DataBox/TagName.hpp"
      10             : #include "DataStructures/SpinWeighted.hpp"
      11             : #include "DataStructures/Tags/TempTensor.hpp"
      12             : #include "DataStructures/Tensor/Metafunctions.hpp"
      13             : #include "DataStructures/Tensor/TypeAliases.hpp"
      14             : 
      15             : /// \cond
      16             : class DataVector;
      17             : class ModalVector;
      18             : class ComplexDataVector;
      19             : class ComplexModalVector;
      20             : /// \endcond
      21             : 
      22             : namespace Tags {
      23             : /// Given the `Tag` holding a `Tensor<DataVector, ...>`, swap the
      24             : /// `DataVector` with a `double`.
      25             : template <typename Tag>
      26           1 : struct Mean : db::SimpleTag, db::PrefixTag {
      27           0 :   using tag = Tag;
      28             :   static_assert(std::is_same_v<typename Tag::type::type, DataVector>,
      29             :                 "The Mean tag should only be used on tags that hold "
      30             :                 "Tensors of DataVectors");
      31           0 :   using type = TensorMetafunctions::swap_type<double, typename Tag::type>;
      32             : };
      33             : 
      34             : /// Given the `NodalTag` holding a `Tensor<DataVector, ...>`, swap the
      35             : /// `DataVector` with a `ModalVector`.
      36             : template <typename NodalTag>
      37           1 : struct Modal : db::SimpleTag, db::PrefixTag {
      38           0 :   using tag = NodalTag;
      39             :   static_assert(std::is_same_v<typename NodalTag::type::type, DataVector>,
      40             :                 "The Modal tag should only be used on tags that hold "
      41             :                 "Tensors of DataVectors");
      42           0 :   using type =
      43             :       TensorMetafunctions::swap_type<ModalVector, typename NodalTag::type>;
      44             : };
      45             : 
      46             : /// Given a Tag with a `type` of `Tensor<VectorType, ...>`, acts as a new
      47             : /// version of the tag with `type` of `Tensor<SpinWeighted<VectorType,
      48             : /// SpinConstant::value>, ...>`, which is the preferred tensor type associated
      49             : /// with spin-weighted quantities. Here, `SpinConstant` must be a
      50             : /// `std::integral_constant` or similar type wrapper for a compile-time
      51             : /// constant, in order to work properly with DataBox utilities.
      52             : /// \note There are restrictions of which vector types can be wrapped
      53             : /// by SpinWeighted in a Tensor, so some `Tag`s that have valid `type`s may
      54             : /// give rise to compilation errors when used as `Tags::SpinWeighted<Tag,
      55             : /// SpinConstant>`. If you find such trouble, consult the whitelist of possible
      56             : /// Tensor storage types in `Tensor.hpp`.
      57             : template <typename Tag, typename SpinConstant>
      58           1 : struct SpinWeighted : db::PrefixTag, db::SimpleTag {
      59             :   static_assert(not is_any_spin_weighted_v<typename Tag::type::type>,
      60             :                 "The SpinWeighted tag should only be used to create a "
      61             :                 "spin-weighted version of a non-spin-weighted tag. The "
      62             :                 "provided tag already has a spin-weighted type");
      63           0 :   using type = TensorMetafunctions::swap_type<
      64             :       ::SpinWeighted<typename Tag::type::type, SpinConstant::value>,
      65             :       typename Tag::type>;
      66           0 :   using tag = Tag;
      67           0 :   static std::string name() {
      68             :     return "SpinWeighted(" + db::tag_name<Tag>() + ", " +
      69             :            std::to_string(SpinConstant::value) + ")";
      70             :   }
      71             : };
      72             : 
      73             : /// Succinct alias for often-used nodal spin-weighted temp tag
      74             : template <size_t index, int spin>
      75           1 : using TempSpinWeightedScalar =
      76             :     SpinWeighted<TempScalar<index, ComplexDataVector>,
      77             :                  std::integral_constant<int, spin>>;
      78             : 
      79             : /// Succinct alias for often-used modal spin-weighted temp tag
      80             : template <size_t index, int spin>
      81           1 : using ModalTempSpinWeightedScalar =
      82             :     SpinWeighted<TempScalar<index, ComplexModalVector>,
      83             :                  std::integral_constant<int, spin>>;
      84             : 
      85             : namespace detail {
      86             : template <typename LhsType, typename RhsType>
      87             : using product_t =
      88             :     Scalar<::SpinWeighted<ComplexDataVector,
      89             :                           LhsType::type::spin + RhsType::type::spin>>;
      90             : }  // namespace detail
      91             : 
      92             : /// A prefix tag representing the product of two other tags. Note that if
      93             : /// non-spin-weighted types are needed in this tag, the type alias
      94             : /// `detail::product_t` should be generalized to give a reasonable type for
      95             : /// those cases, or template specializations should be constructed for this tag.
      96             : template <typename LhsTag, typename RhsTag>
      97           1 : struct Multiplies : db::PrefixTag, db::SimpleTag {
      98           0 :   using type = detail::product_t<typename LhsTag::type, typename RhsTag::type>;
      99           0 :   using tag = LhsTag;
     100           0 :   static std::string name() {
     101             :     return "Multiplies(" + db::tag_name<LhsTag>() + ", " +
     102             :            db::tag_name<RhsTag>() + ")";
     103             :   }
     104             : };
     105             : 
     106             : }  // namespace Tags