Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <cmath>
       7             : #include <cstddef>
       8             : #include <string>
       9             : #include <vector>
      10             : 
      11             : #include "DataStructures/ComplexModalVector.hpp"
      12             : #include "IO/H5/AccessType.hpp"
      13             : #include "IO/H5/File.hpp"
      14             : 
      15             : /// \cond
      16             : class ComplexDataVector;
      17             : /// \endcond
      18             : 
      19             : namespace Cce {
      20             : /*!
      21             :  * \brief The dataset string associated with each scalar that will be output
      22             :  * from the `Cce::Tags::worldtube_boundary_tags_for_writing` list (from the tags
      23             :  * within the BoundaryPrefix).
      24             :  */
      25             : template <typename Tag>
      26           1 : std::string dataset_label_for_tag();
      27             : 
      28             : /*!
      29             :  * \brief Class that standardizes the output of our worldtube data into the
      30             :  * Bondi modal format that the CharacteristicExtract executable can read in.
      31             :  *
      32             :  * \details Takes Bondi nodal data in `fill_data_to_write` and gives the modal
      33             :  * data as a `std::vector<double>` with the time as the 0th component. The \p
      34             :  * output_l_max that this class is constructed with is the LMax that will be
      35             :  * written to disk.
      36             :  */
      37           1 : class WorldtubeModeRecorder {
      38             :  public:
      39           0 :   WorldtubeModeRecorder();
      40           0 :   WorldtubeModeRecorder(size_t output_l_max, const std::string& h5_filename);
      41             : 
      42             :   /// @{
      43             :   /*!
      44             :    * \brief Writes bondi modal data to the given \p subfile_path
      45             :    *
      46             :    * \details If nodal data is given (ComplexDataVector), uses `swsh_transform`
      47             :    * to transform the data and `libsharp_to_goldberg_modes` to convert the
      48             :    * libsharp formatted array into modes.
      49             :    *
      50             :    * There are exactly half the number of modes for \p Spin = 0 quantities as
      51             :    * their are for \p Spin != 0 because we don't include imaginary or m=0 for \p
      52             :    * Spin = 0.
      53             :    *
      54             :    * The \p data_l_max is the LMax of the \p nodal_data or \p modal_data and
      55             :    * must be >= \p output_l_max that this class was constructed with. A
      56             :    * restriction operation will be performed on the data before it is written,
      57             :    * if necessary.
      58             :    */
      59             :   template <int Spin>
      60           1 :   void append_modal_data(const std::string& subfile_path, double time,
      61             :                          const ComplexDataVector& nodal_data,
      62             :                          size_t data_l_max);
      63             :   template <int Spin>
      64           1 :   void append_modal_data(const std::string& subfile_path, double time,
      65             :                          const ComplexModalVector& modal_data,
      66             :                          size_t data_l_max);
      67             :   /// @}
      68             : 
      69             :   /// @{
      70             :   /// The legend for writing dat files for both spin = 0 (real) and spin != 0
      71             :   /// (all) quantities.
      72           1 :   const std::vector<std::string>& all_legend() const;
      73           1 :   const std::vector<std::string>& real_legend() const;
      74             :   /// @}
      75             : 
      76             :  private:
      77           0 :   size_t data_to_write_size(bool is_real) const;
      78           0 :   std::vector<std::string> build_legend(bool is_real) const;
      79           0 :   void check_data_l_max(size_t data_l_max) const;
      80             : 
      81           0 :   size_t output_l_max_{};
      82           0 :   h5::H5File<h5::AccessType::ReadWrite> output_file_;
      83           0 :   std::vector<std::string> all_legend_;
      84           0 :   std::vector<std::string> real_legend_;
      85           0 :   std::vector<double> data_to_write_buffer_;
      86           0 :   ComplexModalVector goldberg_mode_buffer_;
      87             : };
      88             : }  // namespace Cce