Line data    Source code

       1           1 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : /// \file
       5             : /// Defines classes representing tensor indices
       6             : 
       7             : #pragma once
       8             : 
       9             : #include <cstddef>
      10             : #include <ostream>
      11             : #include <string>
      12             : #include <type_traits>
      13             : 
      14             : #include "Utilities/Literals.hpp"  // IWYU pragma: keep
      15             : #include "Utilities/TMPL.hpp"
      16             : 
      17             : /// \ingroup TensorGroup
      18             : /// Whether a \ref SpacetimeIndex "TensorIndexType" is covariant or
      19             : /// contravariant
      20           1 : enum class UpLo {
      21             :   /// Contravariant, or Upper index
      22             :   Up,
      23             :   /// Covariant, or Lower index
      24             :   Lo
      25             : };
      26             : 
      27             : /// \cond HIDDEN_SYMBOLS
      28             : inline std::ostream& operator<<(std::ostream& os, const UpLo& ul) {
      29             :   return os << (ul == UpLo::Up ? "Up"s : "Lo"s);
      30             : }
      31             : /// \endcond
      32             : 
      33             : /// \ingroup TensorGroup
      34             : /// Indicates the ::Frame that a \ref SpacetimeIndex "TensorIndexType"
      35             : /// is in.
      36           1 : namespace Frame {
      37             : /// \ingroup TensorGroup
      38             : /// Marks a Frame as being "physical" in the sense that it is meaningful to
      39             : /// evaluate an analytic solution in that frame.
      40           1 : struct FrameIsPhysical {};
      41             : 
      42           0 : struct BlockLogical {};
      43           0 : struct ElementLogical {};
      44           0 : struct Fluid {};
      45           0 : struct Grid {};
      46           0 : struct Inertial : FrameIsPhysical {};
      47           0 : struct Distorted {};
      48             : /// Represents an index that is not in a known frame, e.g. some internal
      49             : /// intermediate frame that is irrelevant to the interface.
      50           1 : struct NoFrame {};
      51             : 
      52             : /// Represents a spherical-coordinate frame that is associated with a
      53             : /// Cartesian frame, e.g. \f$(r,\theta,\phi)\f$ associated with the Inertial
      54             : /// frame, as used on an apparent horizon or a wave-extraction surface.
      55             : template <typename CartesianFrame>
      56           1 : struct Spherical {};
      57             : 
      58             : /// \ingroup TensorGroup
      59             : /// Returns std::true_type if the frame is "physical" in the sense that it is
      60             : /// meaningful to evaluate an analytic solution in that frame.
      61             : /// \example
      62             : /// \snippet Test_Tensor.cpp is_frame_physical
      63             : template <typename CheckFrame>
      64           1 : using is_frame_physical =
      65             :     std::integral_constant<bool,
      66             :                            std::is_base_of<FrameIsPhysical, CheckFrame>::value>;
      67             : 
      68             : /// \ingroup TensorGroup
      69             : /// Returns true if the frame is "physical" in the sense that it is
      70             : /// meaningful to evaluate an analytic solution in that frame.
      71             : /// \example
      72             : /// \snippet Test_Tensor.cpp is_frame_physical
      73             : template <typename CheckFrame>
      74           1 : constexpr bool is_frame_physical_v = is_frame_physical<CheckFrame>::value;
      75             : 
      76             : /// \cond HIDDEN_SYMBOLS
      77             : inline std::ostream& operator<<(std::ostream& os,
      78             :                                 const Frame::BlockLogical& /*meta*/) {
      79             :   return os << "BlockLogical";
      80             : }
      81             : inline std::ostream& operator<<(std::ostream& os,
      82             :                                 const Frame::ElementLogical& /*meta*/) {
      83             :   return os << "ElementLogical";
      84             : }
      85             : inline std::ostream& operator<<(std::ostream& os,
      86             :                                 const Frame::Fluid& /*meta*/) {
      87             :   return os << "Fluid";
      88             : }
      89             : inline std::ostream& operator<<(std::ostream& os,
      90             :                                 const Frame::Grid& /*meta*/) {
      91             :   return os << "Grid";
      92             : }
      93             : inline std::ostream& operator<<(std::ostream& os,
      94             :                                 const Frame::Inertial& /*meta*/) {
      95             :   return os << "Inertial";
      96             : }
      97             : inline std::ostream& operator<<(std::ostream& os,
      98             :                                 const Frame::Distorted& /*meta*/) {
      99             :   return os << "Distorted";
     100             : }
     101             : inline std::ostream& operator<<(std::ostream& os,
     102             :                                 const Frame::NoFrame& /*meta*/) {
     103             :   return os << "NoFrame";
     104             : }
     105             : /// \endcond
     106             : 
     107             : /// \ingroup TensorGroup
     108             : /// The frame-dependent prefix used when constructing the string returned by the
     109             : /// name function of a tag.
     110             : ///
     111             : /// For Frame::Inertial it is the empty string, otherwise, it is the name of
     112             : /// the Frame followed by an underscore (as the name will be used in I/O).
     113             : /// \example
     114             : /// \snippet Hydro/Test_Tags.cpp prefix_example
     115             : template <typename Fr>
     116           1 : inline std::string prefix();
     117             : 
     118             : /// \cond HIDDEN_SYMBOLS
     119             : template <>
     120             : inline std::string prefix<Frame::BlockLogical>() {
     121             :   return "BlockLogical_";
     122             : }
     123             : 
     124             : template <>
     125             : inline std::string prefix<Frame::ElementLogical>() {
     126             :   return "ElementLogical_";
     127             : }
     128             : 
     129             : template <>
     130             : inline std::string prefix<Frame::Fluid>() {
     131             :   return "Fluid_";
     132             : }
     133             : 
     134             : template <>
     135             : inline std::string prefix<Frame::Grid>() {
     136             :   return "Grid_";
     137             : }
     138             : 
     139             : template <>
     140             : inline std::string prefix<Frame::Inertial>() {
     141             :   return "";
     142             : }
     143             : 
     144             : template <>
     145             : inline std::string prefix<Frame::Distorted>() {
     146             :   return "Distorted_";
     147             : }
     148             : /// \endcond
     149             : }  // namespace Frame
     150             : 
     151             : /// \ingroup TensorGroup
     152             : /// Indicates whether the \ref SpacetimeIndex "TensorIndexType" is
     153             : /// Spatial or Spacetime
     154           1 : enum class IndexType : char {
     155             :   /// The \ref SpatialIndex "TensorIndexType" is purely spatial
     156             :   Spatial,
     157             :   /// The \ref SpacetimeIndex "TensorIndexType" is a spacetime index
     158             :   Spacetime
     159             : };
     160             : 
     161             : /// \cond HIDDEN_SYMBOLS
     162             : inline std::ostream& operator<<(std::ostream& os, const IndexType& index_type) {
     163             :   return os << (index_type == IndexType::Spatial ? "Spatial" : "Spacetime");
     164             : }
     165             : /// \endcond
     166             : 
     167             : namespace Tensor_detail {
     168             : /// \ingroup TensorGroup
     169             : /// A ::TensorIndexType holds information about what type of index an index of a
     170             : /// Tensor is. It holds the information about the number of spatial dimensions,
     171             : /// whether the index is covariant or contravariant (::UpLo), the ::Frame the
     172             : /// index is in, and whether the Index is Spatial or Spacetime.
     173             : /// \tparam SpatialDim the spatial dimensionality of the TensorIndex
     174             : /// \tparam Ul either UpLo::Up or UpLo::Lo for contra or covariant
     175             : /// \tparam Fr the Frame the TensorIndex is in
     176             : /// \tparam Index either IndexType::Spatial or IndexType::Spacetime
     177             : template <size_t SpatialDim, UpLo Ul, typename Fr, IndexType Index>
     178             : struct TensorIndexType {
     179             :   static_assert(SpatialDim > 0,
     180             :                 "Cannot have a spatial dimensionality less than 1 (one) in a "
     181             :                 "TensorIndexType");
     182             :   using value_type = decltype(SpatialDim);
     183             :   static constexpr value_type dim =
     184             :       Index == IndexType::Spatial ? SpatialDim
     185             :                                   : SpatialDim + static_cast<value_type>(1);
     186             :   // value is here just so that some generic metafunctions can retrieve the dim
     187             :   // easily
     188             :   static constexpr value_type value = dim;
     189             :   static constexpr UpLo ul = Ul;
     190             :   using Frame = Fr;
     191             :   static constexpr IndexType index_type = Index;
     192             : };
     193             : }  // namespace Tensor_detail
     194             : 
     195             : /// \ingroup TensorGroup
     196             : /// A SpatialIndex holds information about the number of spatial
     197             : /// dimensions, whether the index is covariant or contravariant (::UpLo), and
     198             : /// the ::Frame the index is in.
     199             : /// \tparam SpatialDim the spatial dimensionality of the \ref
     200             : /// SpatialIndex "TensorIndexType"
     201             : /// \tparam Ul either UpLo::Up or UpLo::Lo for contra or covariant
     202             : /// \tparam Fr the ::Frame the \ref SpatialIndex "TensorIndexType"
     203             : /// is in
     204             : template <size_t SpatialDim, UpLo Ul, typename Fr>
     205           1 : using SpatialIndex =
     206             :     Tensor_detail::TensorIndexType<SpatialDim, Ul, Fr, IndexType::Spatial>;
     207             : 
     208             : /// \ingroup TensorGroup
     209             : /// A SpacetimeIndex holds information about the number of spatial
     210             : /// dimensions, whether the index is covariant or contravariant (::UpLo), and
     211             : /// the ::Frame the index is in.
     212             : ///
     213             : /// \tparam SpatialDim the spatial dimensionality of the \ref
     214             : /// SpacetimeIndex "TensorIndexType"
     215             : /// \tparam Ul either UpLo::Up or UpLo::Lo for contra or covariant
     216             : /// \tparam Fr the ::Frame the \ref SpacetimeIndex "TensorIndexType"
     217             : /// is in
     218             : template <size_t SpatialDim, UpLo Ul, typename Fr>
     219           1 : using SpacetimeIndex =
     220             :     Tensor_detail::TensorIndexType<SpatialDim, Ul, Fr, IndexType::Spacetime>;
     221             : 
     222             : namespace tt {
     223             : /// @{
     224             : /// \ingroup TensorGroup TypeTraitsGroup
     225             : /// Inherits from std::true_type if T is a \ref SpacetimeIndex
     226             : /// "TensorIndexType"
     227             : /// \tparam T the type to check
     228             : template <typename T>
     229           1 : struct is_tensor_index_type : std::false_type {};
     230             : /// \cond HIDDEN_SYMBOLS
     231             : template <size_t SpatialDim, UpLo Ul, typename Fr, IndexType Index>
     232             : struct is_tensor_index_type<
     233             :     Tensor_detail::TensorIndexType<SpatialDim, Ul, Fr, Index>>
     234             :     : std::true_type {};
     235             : /// \endcond
     236             : /// \see is_tensor_index_type
     237             : template <typename T>
     238           1 : using is_tensor_index_type_t = typename is_tensor_index_type<T>::type;
     239             : /// @}
     240             : }  // namespace tt
     241             : 
     242             : /// \ingroup TensorGroup
     243             : /// Change the \ref SpacetimeIndex "TensorIndexType" to be covariant
     244             : /// if it's contravariant and vice-versa
     245             : ///
     246             : /// Here is an example of how to use ::change_index_up_lo
     247             : /// \snippet Test_Tensor.cpp change_up_lo
     248             : ///
     249             : /// \tparam Index the \ref SpacetimeIndex "TensorIndexType" to change
     250             : template <typename Index>
     251           1 : using change_index_up_lo = Tensor_detail::TensorIndexType<
     252             :     Index::index_type == IndexType::Spatial ? Index::value : Index::value - 1,
     253             :     Index::ul == UpLo::Up ? UpLo::Lo : UpLo::Up, typename Index::Frame,
     254             :     Index::index_type>;
     255             : 
     256             : template <typename... Ts>
     257           0 : using index_list = tmpl::list<Ts...>;
     258             : 
     259             : /// \ingroup TensorGroup
     260             : /// Change the \ref SpacetimeIndex "TensorIndexType" to be spacetime
     261             : /// if it's spatial and vice versa
     262             : ///
     263             : /// \tparam Index the \ref SpacetimeIndex "TensorIndexType" to change
     264             : template <typename Index>
     265           1 : using change_index_type = Tensor_detail::TensorIndexType<
     266             :     Index::index_type == IndexType::Spatial ? Index::dim : Index::dim - 1,
     267             :     Index::ul, typename Index::Frame,
     268             :     Index::index_type == IndexType::Spatial ? IndexType::Spacetime
     269             :                                             : IndexType::Spatial>;