Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <array>
       7             : #include <cstddef>
       8             : #include <utility>
       9             : 
      10             : #include "DataStructures/Tensor/Expressions/SpatialSpacetimeIndex.hpp"
      11             : #include "DataStructures/Tensor/Expressions/TensorIndexTransformation.hpp"
      12             : #include "DataStructures/Tensor/Expressions/TimeIndex.hpp"
      13             : #include "DataStructures/Tensor/Structure.hpp"
      14             : #include "DataStructures/Tensor/Symmetry.hpp"
      15             : #include "Utilities/Algorithm.hpp"
      16             : #include "Utilities/TMPL.hpp"
      17             : 
      18             : namespace tenex {
      19             : /*!
      20             :  * \ingroup TensorExpressionsGroup
      21             :  * \brief Determines and stores a LHS tensor's symmetry and index list from a
      22             :  * RHS tensor expression and desired LHS index order
      23             :  *
      24             :  * \details Given the generic index order of a RHS TensorExpression and the
      25             :  * generic index order of the desired LHS Tensor, this creates a mapping between
      26             :  * the two that is then used to determine the (potentially reordered) ordering
      27             :  * of the elements of the desired LHS Tensor`s ::Symmetry, typelist of
      28             :  * \ref SpacetimeIndex "TensorIndexType"s, and Tensor_detail::Structure. This
      29             :  * struct is used to determine the LHS Tensor's properties when they are not
      30             :  * supplied by the user: when a user uses the `evaluate` overload that returns
      31             :  * the LHS as opposed to the overload that takes an empty LHS Tensor as an
      32             :  * argument.
      33             :  *
      34             :  * Note: If a generic spatial index is used for a spacetime index in the RHS
      35             :  * tensor, its corresponding index in the LHS tensor type will be a spatial
      36             :  * index with the same valence, frame, and number of spatial dimensions. If a
      37             :  * concrete time index is used for a spacetime index in the RHS tensor, the
      38             :  * index will not appear in the LHS tensor (i.e. there will NOT be a
      39             :  * corresponding LHS index where only the time index of that index has been
      40             :  * computed and its spatial indices are empty). Therefore, the
      41             :  * `LhsTensorIndexList` may not contain time indices (`ti::t` nor `ti::T`).
      42             :  *
      43             :  * @tparam RhsTensorIndexList the typelist of TensorIndex of the RHS
      44             :  * TensorExpression
      45             :  * @tparam LhsTensorIndexList the typelist of TensorIndexs of the desired LHS
      46             :  * tensor
      47             :  * @tparam RhsSymmetry the ::Symmetry of the RHS indices
      48             :  * @tparam RhsTensorIndexTypeList the RHS TensorExpression's typelist of
      49             :  * \ref SpacetimeIndex "TensorIndexType"s
      50             :  */
      51             : template <typename RhsTensorIndexList, typename LhsTensorIndexList,
      52             :           typename RhsSymmetry, typename RhsTensorIndexTypeList,
      53             :           size_t NumLhsIndices = tmpl::size<LhsTensorIndexList>::value,
      54             :           size_t NumRhsIndices = tmpl::size<RhsTensorIndexList>::value,
      55             :           typename LhsIndexSequence = std::make_index_sequence<NumLhsIndices>>
      56           1 : struct LhsTensorSymmAndIndices;
      57             : 
      58             : template <typename... RhsTensorIndices, typename... LhsTensorIndices,
      59             :           std::int32_t... RhsSymm, typename RhsTensorIndexTypeList,
      60             :           size_t NumLhsIndices, size_t NumRhsIndices, size_t... LhsInts>
      61             : struct LhsTensorSymmAndIndices<
      62             :     tmpl::list<RhsTensorIndices...>, tmpl::list<LhsTensorIndices...>,
      63             :     tmpl::integral_list<std::int32_t, RhsSymm...>, RhsTensorIndexTypeList,
      64             :     NumLhsIndices, NumRhsIndices, std::index_sequence<LhsInts...>> {
      65             :   static_assert((... and (not tt::is_time_index<LhsTensorIndices>::value)),
      66             :                 "LHS generic indices cannot contain the concrete time index.");
      67             :   // LHS generic indices, RHS generic indices, and the mapping between them
      68             :   static constexpr std::array<size_t, NumLhsIndices> lhs_tensorindex_values = {
      69             :       {LhsTensorIndices::value...}};
      70             :   static constexpr std::array<size_t, NumRhsIndices> rhs_tensorindex_values = {
      71             :       {RhsTensorIndices::value...}};
      72             :   static constexpr std::array<size_t, NumLhsIndices> rhs_to_lhs_map =
      73             :       compute_tensorindex_transformation(rhs_tensorindex_values,
      74             :                                          lhs_tensorindex_values);
      75             : 
      76             :   // Compute symmetry of RHS after spacetime indices using generic spatial
      77             :   // indices are swapped for spatial indices
      78             :   static constexpr std::array<std::int32_t, NumRhsIndices> rhs_symmetry = {
      79             :       {RhsSymm...}};
      80             :   using rhs_spatial_spacetime_index_positions_ =
      81             :       detail::spatial_spacetime_index_positions<
      82             :           RhsTensorIndexTypeList, tmpl::list<RhsTensorIndices...>>;
      83             :   using make_list_type = std::conditional_t<
      84             :       tmpl::size<rhs_spatial_spacetime_index_positions_>::value == 0, size_t,
      85             :       rhs_spatial_spacetime_index_positions_>;
      86             :   static constexpr auto rhs_spatial_spacetime_index_positions =
      87             :       make_array_from_list<make_list_type>();
      88             :   static constexpr std::array<std::int32_t, NumRhsIndices>
      89             :       rhs_spatial_spacetime_index_symmetry =
      90             :           detail::get_spatial_spacetime_index_symmetry(
      91             :               rhs_symmetry, rhs_spatial_spacetime_index_positions);
      92             : 
      93             :   // Compute index list of RHS after spacetime indices using generic spatial
      94             :   // indices are made nonsymmetric to other indices
      95             :   using rhs_spatial_spacetime_tensorindextype_list =
      96             :       detail::replace_spatial_spacetime_indices<
      97             :           RhsTensorIndexTypeList, rhs_spatial_spacetime_index_positions_>;
      98             : 
      99             :   // Desired LHS Tensor's Symmetry, typelist of TensorIndexTypes, and Structure
     100             :   using symmetry = Symmetry<
     101             :       rhs_spatial_spacetime_index_symmetry[rhs_to_lhs_map[LhsInts]]...>;
     102             :   using tensorindextype_list =
     103             :       tmpl::list<tmpl::at_c<rhs_spatial_spacetime_tensorindextype_list,
     104             :                             rhs_to_lhs_map[LhsInts]>...>;
     105             :   using structure =
     106             :       Tensor_detail::Structure<symmetry,
     107             :                                tmpl::at_c<tensorindextype_list, LhsInts>...>;
     108             : };
     109             : }  // namespace tenex