Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <cstddef>
       7             : 
       8             : #include "DataStructures/DataVector.hpp"
       9             : #include "DataStructures/Tensor/Tensor.hpp"
      10             : #include "DataStructures/Variables.hpp"
      11             : #include "Utilities/ErrorHandling/Assert.hpp"
      12             : #include "Utilities/Gsl.hpp"
      13             : #include "Utilities/TMPL.hpp"
      14             : 
      15             : /// \ingroup DataStructuresGroup
      16             : /// Copy a given index of each component of a `Tensor<DataVector>` or
      17             : /// `Variables<DataVector>` into a `Tensor<double>`, single point
      18             : /// `Tensor<DataVector>`, or single-point `Variables<DataVector>`.
      19             : /// Also works with `ComplexDataVector`.
      20             : ///
      21             : /// \note There is no by-value overload extracting to a
      22             : /// `Tensor<DataVector>`.  This is both for the practical reason that
      23             : /// it would be ambiguous with the `Tensor<double>` overload and
      24             : /// because allocating multiple `DataVector`s for the return type
      25             : /// would usually be very inefficient.
      26             : ///
      27             : /// \see overwrite_point
      28             : /// @{
      29             : template <typename VectorType, typename... Structure>
      30           1 : void extract_point(
      31             :     const gsl::not_null<Tensor<typename VectorType::value_type, Structure...>*>
      32             :         destination,
      33             :     const Tensor<VectorType, Structure...>& source, const size_t index) {
      34             :   for (size_t i = 0; i < destination->size(); ++i) {
      35             :     (*destination)[i] = source[i][index];
      36             :   }
      37             : }
      38             : 
      39             : template <typename VectorType, typename... Structure>
      40           1 : Tensor<typename VectorType::value_type, Structure...> extract_point(
      41             :     const Tensor<VectorType, Structure...>& tensor, const size_t index) {
      42             :   Tensor<typename VectorType::value_type, Structure...> result;
      43             :   extract_point(make_not_null(&result), tensor, index);
      44             :   return result;
      45             : }
      46             : 
      47             : template <typename VectorType, typename... Structure>
      48           1 : void extract_point(
      49             :     const gsl::not_null<Tensor<VectorType, Structure...>*> destination,
      50             :     const Tensor<VectorType, Structure...>& source, const size_t index) {
      51             :   ASSERT(destination->begin()->size() == 1,
      52             :          "Output tensor components have wrong size: "
      53             :          << destination->begin()->size());
      54             :   for (size_t i = 0; i < destination->size(); ++i) {
      55             :     (*destination)[i][0] = source[i][index];
      56             :   }
      57             : }
      58             : 
      59             : template <typename... Tags>
      60           1 : void extract_point(
      61             :     const gsl::not_null<Variables<tmpl::list<Tags...>>*> result,
      62             :     const Variables<tmpl::list<Tags...>>& variables, const size_t index) {
      63             :   result->initialize(1);
      64             :   expand_pack((extract_point(
      65             :       make_not_null(&get<Tags>(*result)), get<Tags>(variables), index), 0)...);
      66             : }
      67             : 
      68             : template <typename... Tags>
      69           1 : Variables<tmpl::list<Tags...>> extract_point(
      70             :     const Variables<tmpl::list<Tags...>>& variables, const size_t index) {
      71             :   Variables<tmpl::list<Tags...>> result(1);
      72             :   extract_point(make_not_null(&result), variables, index);
      73             :   return result;
      74             : }
      75             : /// @}
      76             : 
      77             : /// \ingroup DataStructuresGroup
      78             : /// Copy a `Tensor<double>`, single point `Tensor<DataVector>`, or
      79             : /// single-point `Variables<DataVector>` into the given index of each
      80             : /// component of a `Tensor<DataVector>` or `Variables<DataVector>`.
      81             : ///
      82             : /// \see extract_point
      83             : /// @{
      84             : template <typename VectorType, typename... Structure>
      85           1 : void overwrite_point(
      86             :     const gsl::not_null<Tensor<VectorType, Structure...>*> destination,
      87             :     const Tensor<typename VectorType::value_type, Structure...>& source,
      88             :     const size_t index) {
      89             :   for (size_t i = 0; i < destination->size(); ++i) {
      90             :     (*destination)[i][index] = source[i];
      91             :   }
      92             : }
      93             : 
      94             : template <typename VectorType, typename... Structure>
      95           1 : void overwrite_point(
      96             :     const gsl::not_null<Tensor<VectorType, Structure...>*> destination,
      97             :     const Tensor<VectorType, Structure...>& source, const size_t index) {
      98             :   ASSERT(source.begin()->size() == 1,
      99             :          "Cannot overwrite with " << source.begin()->size() << " points.");
     100             :   for (size_t i = 0; i < destination->size(); ++i) {
     101             :     (*destination)[i][index] = source[i][0];
     102             :   }
     103             : }
     104             : 
     105             : template <typename... Tags>
     106           1 : void overwrite_point(
     107             :     const gsl::not_null<Variables<tmpl::list<Tags...>>*> destination,
     108             :     const Variables<tmpl::list<Tags...>>& source, const size_t index) {
     109             :   ASSERT(source.number_of_grid_points() == 1,
     110             :          "Must overwrite with a single point.");
     111             :   expand_pack((overwrite_point(make_not_null(&get<Tags>(*destination)),
     112             :                                extract_point(get<Tags>(source), 0), index),
     113             :                0)...);
     114             : }
     115             : /// @}