Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include "DataStructures/Tensor/Tensor.hpp"
       7              : #include "Utilities/Gsl.hpp"
       8              : #include "Utilities/MakeWithValue.hpp"
       9              : 
      10              : /// @{
      11              : /*!
      12              :  * \ingroup GeneralRelativityGroup
      13              :  * \brief Computes trace of a rank 3 tensor, which is symmetric in its last two
      14              :  * indices, tracing the symmetric indices.
      15              :  *
      16              :  * \details For example, if \f$ T_{abc} \f$ is a tensor such that \f$T_{abc} =
      17              :  * T_{acb} \f$ then \f$ T_a = g^{bc}T_{abc} \f$ is computed, where \f$ g^{bc}
      18              :  * \f$ is the inverse metric.  Note that indices \f$a,b,c,...\f$ can represent
      19              :  * either spatial or spacetime indices, and can have either valence.  You may
      20              :  * have to add a new instantiation of this template if you need a new use case.
      21              :  */
      22              : template <typename DataType, typename Index0, typename Index1>
      23            1 : void trace_last_indices(
      24              :     gsl::not_null<Tensor<DataType, Symmetry<1>, index_list<Index0>>*>
      25              :         trace_of_tensor,
      26              :     const Tensor<DataType, Symmetry<2, 1, 1>,
      27              :                  index_list<Index0, Index1, Index1>>& tensor,
      28              :     const Tensor<DataType, Symmetry<1, 1>,
      29              :                  index_list<change_index_up_lo<Index1>,
      30              :                             change_index_up_lo<Index1>>>& metric);
      31              : 
      32              : template <typename DataType, typename Index0, typename Index1>
      33            1 : Tensor<DataType, Symmetry<1>, index_list<Index0>> trace_last_indices(
      34              :     const Tensor<DataType, Symmetry<2, 1, 1>,
      35              :                  index_list<Index0, Index1, Index1>>& tensor,
      36              :     const Tensor<DataType, Symmetry<1, 1>,
      37              :                  index_list<change_index_up_lo<Index1>,
      38              :                             change_index_up_lo<Index1>>>& metric) {
      39              :   auto trace_of_tensor =
      40              :       make_with_value<Tensor<DataType, Symmetry<1>, index_list<Index0>>>(metric,
      41              :                                                                          0.);
      42              :   trace_last_indices(make_not_null(&trace_of_tensor), tensor, metric);
      43              :   return trace_of_tensor;
      44              : }
      45              : /// @}
      46              : 
      47              : /// @{
      48              : /*!
      49              :  * \ingroup GeneralRelativityGroup
      50              :  * \brief Computes trace of a rank-2 symmetric tensor.
      51              :  * \details Computes \f$g^{ab}T_{ab}\f$ or \f$g_{ab}T^{ab}\f$ where \f$(a,b)\f$
      52              :  * can be spatial or spacetime indices.
      53              :  */
      54              : template <typename DataType, typename Index0>
      55            1 : void trace(
      56              :     gsl::not_null<Scalar<DataType>*> trace,
      57              :     const Tensor<DataType, Symmetry<1, 1>, index_list<Index0, Index0>>& tensor,
      58              :     const Tensor<DataType, Symmetry<1, 1>,
      59              :                  index_list<change_index_up_lo<Index0>,
      60              :                             change_index_up_lo<Index0>>>& metric);
      61              : 
      62              : template <typename DataType, typename Index0>
      63            1 : Scalar<DataType> trace(
      64              :     const Tensor<DataType, Symmetry<1, 1>, index_list<Index0, Index0>>& tensor,
      65              :     const Tensor<DataType, Symmetry<1, 1>,
      66              :                  index_list<change_index_up_lo<Index0>,
      67              :                             change_index_up_lo<Index0>>>& metric) {
      68              :   Scalar<DataType> trace{};
      69              :   ::trace(make_not_null(&trace), tensor, metric);
      70              :   return trace;
      71              : }
      72              : /// @}