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             : #include <iosfwd>
       8             : #include <string>
       9             : #include <utility>
      10             : #include <variant>
      11             : #include <vector>
      12             : 
      13             : #include "DataStructures/DataVector.hpp"
      14             : #include "NumericalAlgorithms/Spectral/Basis.hpp"
      15             : #include "NumericalAlgorithms/Spectral/Quadrature.hpp"
      16             : #include "Utilities/GetOutput.hpp"
      17             : 
      18             : /// \cond
      19             : namespace PUP {
      20             : class er;
      21             : }  // namespace PUP
      22             : template <size_t Dim>
      23             : struct ElementId;
      24             : template <size_t Dim>
      25             : struct Mesh;
      26             : /// \endcond
      27             : 
      28             : /*!
      29             :  * \ingroup DataStructuresGroup
      30             :  * \brief An untyped tensor component with a name for observation.
      31             :  *
      32             :  * The name should be just the name of the tensor component, such as 'Psi_xx'.
      33             :  * It must not include any slashes ('/').
      34             :  */
      35           1 : struct TensorComponent {
      36           0 :   TensorComponent() = default;
      37           0 :   TensorComponent(std::string in_name, DataVector in_data);
      38           0 :   TensorComponent(std::string in_name, std::vector<float> in_data);
      39             : 
      40             :   // NOLINTNEXTLINE(google-runtime-references)
      41           0 :   void pup(PUP::er& p);
      42           0 :   std::string name{};
      43           0 :   std::variant<DataVector, std::vector<float>> data{};
      44             : };
      45             : 
      46           0 : std::ostream& operator<<(std::ostream& os, const TensorComponent& t);
      47             : 
      48           0 : bool operator==(const TensorComponent& lhs, const TensorComponent& rhs);
      49             : 
      50           0 : bool operator!=(const TensorComponent& lhs, const TensorComponent& rhs);
      51             : 
      52             : /*!
      53             :  * \ingroup DataStructuresGroup
      54             :  * \brief Holds tensor components on a grid, to be written into an H5 file
      55             :  */
      56           1 : struct ElementVolumeData {
      57           0 :   ElementVolumeData() = default;
      58           0 :   ElementVolumeData(std::string element_name_in,
      59             :                     std::vector<TensorComponent> components,
      60             :                     std::vector<size_t> extents_in,
      61             :                     std::vector<Spectral::Basis> basis_in,
      62             :                     std::vector<Spectral::Quadrature> quadrature_in);
      63             :   template <size_t Dim>
      64           0 :   ElementVolumeData(const ElementId<Dim>& element_id,
      65             :                     std::vector<TensorComponent> components,
      66             :                     const Mesh<Dim>& mesh);
      67             : 
      68             :   // NOLINTNEXTLINE(google-runtime-references)
      69           0 :   void pup(PUP::er& p);
      70             :   /// Name of the grid (should be human-readable). For standard volume data this
      71             :   /// name must be the string representation of an ElementId, such as
      72             :   /// [B0,(L0I1,L0I0,L3I2)]. Code that reads the volume data may rely on this
      73             :   /// pattern to reconstruct the ElementId.
      74           1 :   std::string element_name{};
      75             :   /// All tensor components on the grid
      76           1 :   std::vector<TensorComponent> tensor_components{};
      77             :   /// Number of grid points in every dimension of the grid
      78           1 :   std::vector<size_t> extents{};
      79             :   /// Spectral::Basis in every dimension of the grid
      80           1 :   std::vector<Spectral::Basis> basis{};
      81             :   /// Spectral::Quadrature in every dimension of the grid
      82           1 :   std::vector<Spectral::Quadrature> quadrature{};
      83             : };
      84             : 
      85           0 : bool operator==(const ElementVolumeData& lhs, const ElementVolumeData& rhs);
      86           0 : bool operator!=(const ElementVolumeData& lhs, const ElementVolumeData& rhs);