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 <mutex>
       8              : #include <string>
       9              : #include <unordered_map>
      10              : #include <vector>
      11              : 
      12              : #include "DataStructures/DataBox/DataBox.hpp"
      13              : #include "IO/H5/AccessType.hpp"
      14              : #include "IO/H5/Cce.hpp"
      15              : #include "IO/H5/File.hpp"
      16              : #include "IO/Observer/Helpers.hpp"
      17              : #include "IO/Observer/Tags.hpp"
      18              : #include "Parallel/GlobalCache.hpp"
      19              : #include "Parallel/NodeLock.hpp"
      20              : #include "Utilities/Algorithm.hpp"
      21              : #include "Utilities/ConstantExpressions.hpp"
      22              : #include "Utilities/ErrorHandling/Assert.hpp"
      23              : #include "Utilities/Gsl.hpp"
      24              : 
      25              : namespace Cce::Actions {
      26              : /*!
      27              :  * \brief Write a single row of data into an `h5::Cce` subfile within an H5
      28              :  * file.
      29              :  *
      30              :  * \details This action can be called as either a threaded action or a local
      31              :  * synchronous action. In both cases, invoke this action on the
      32              :  * `observers::ObserverWriter` component on node 0. You must pass the following
      33              :  * arguments when invoking this action
      34              :  *
      35              :  * - `subfile_name`: the name of the `h5::Cce` subfile in the HDF5 file.
      36              :  * - `l_max`: the number of spherical harmonics of the data
      37              :  * - `data`: a `std::unordered_map<std::string, std::vector<double>>` where the
      38              :  *   keys are the names of all the bondi quantities to write and the data are
      39              :  *   the spherical harmonic coefficients. See `h5::Cce` for exactly what names
      40              :  *   need to be used and the layout of the data.
      41              :  *
      42              :  * \note If you want to write data into an `h5::Dat` file, use
      43              :  * `observers::ThreadedActions::WriteReductionDataRow`.
      44              :  */
      45            1 : struct WriteScriBondiQuantities {
      46              :   /// \brief The apply call for the threaded action
      47              :   template <typename ParallelComponent, typename DbTagsList,
      48              :             typename Metavariables, typename ArrayIndex>
      49            1 :   static void apply(db::DataBox<DbTagsList>& box,
      50              :                     Parallel::GlobalCache<Metavariables>& cache,
      51              :                     const ArrayIndex& /*array_index*/,
      52              :                     const gsl::not_null<Parallel::NodeLock*> node_lock,
      53              :                     const std::string& subfile_name, const size_t l_max,
      54              :                     std::unordered_map<std::string, std::vector<double>> data) {
      55              :     apply<ParallelComponent>(box, node_lock, cache, subfile_name, l_max,
      56              :                              std::move(data));
      57              :   }
      58              : 
      59              :   // The local synchronous action
      60            0 :   using return_type = void;
      61              : 
      62              :   /// \brief The apply call for the local synchronous action
      63              :   template <typename ParallelComponent, typename DbTagList,
      64              :             typename Metavariables>
      65            1 :   static return_type apply(
      66              :       db::DataBox<DbTagList>& box,
      67              :       const gsl::not_null<Parallel::NodeLock*> /*node_lock*/,
      68              :       Parallel::GlobalCache<Metavariables>& cache,
      69              :       const std::string& subfile_name, const size_t l_max,
      70              :       std::unordered_map<std::string, std::vector<double>> data) {
      71              :     auto& reduction_file_lock =
      72              :         db::get_mutable_reference<observers::Tags::H5FileLock>(
      73              :             make_not_null(&box));
      74              :     const std::lock_guard hold_lock(reduction_file_lock);
      75              : 
      76              :     // Make sure all data is the proper size
      77              :     ASSERT(
      78              :         alg::all_of(data,
      79              :                     [&l_max](const auto& name_and_data) {
      80              :                       return name_and_data.second.size() ==
      81              :                              2 * square(l_max + 1) + 1;
      82              :                     }),
      83              :         "Some data sent to WriteScriBondiQuantities is not of the proper size "
      84              :             << 2 * square(l_max + 1) + 1);
      85              : 
      86              :     const std::string input_source = observers::input_source_from_cache(cache);
      87              :     const std::string& reduction_file_prefix =
      88              :         Parallel::get<observers::Tags::ReductionFileName>(cache);
      89              :     h5::H5File<h5::AccessType::ReadWrite> h5file(reduction_file_prefix + ".h5",
      90              :                                                  true, input_source);
      91              :     constexpr size_t version_number = 0;
      92              :     auto& cce_file =
      93              :         h5file.try_insert<h5::Cce>(subfile_name, l_max, version_number);
      94              :     cce_file.append(data);
      95              :   }
      96              : };
      97              : }  // namespace Cce::Actions