Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <array>
       7              : #include <cstdint>
       8              : #include <hdf5.h>
       9              : #include <string>
      10              : #include <vector>
      11              : 
      12              : #include "IO/H5/Object.hpp"
      13              : #include "IO/H5/OpenGroup.hpp"
      14              : 
      15              : /// \cond
      16              : class DataVector;
      17              : /// \endcond
      18              : 
      19              : namespace h5 {
      20              : /*!
      21              :  * \ingroup HDF5Group
      22              :  * \brief An equation of state table subfile written inside an H5 file.
      23              :  *
      24              :  * ### Data Layout
      25              :  *
      26              :  * To be consistent with the CompOSE ASCII table format, the data is stored in a
      27              :  * last independent variable varies fastest. For example, if you had independent
      28              :  * variables \f$\rho\f$, \f$T\f$, and \f$Y_e\f$, then \f$Y_e\f$ varies fastest
      29              :  * while \f$\rho\f$ varies slowest.
      30              :  */
      31            1 : class EosTable : public h5::Object {
      32              :  public:
      33            0 :   static std::string extension() { return ".eos"; }
      34              : 
      35              :   /// Constructor used when writing a new equation of state.
      36            1 :   EosTable(bool subfile_exists, detail::OpenGroup&& group, hid_t location,
      37              :            const std::string& name,
      38              :            std::vector<std::string> independent_variable_names,
      39              :            std::vector<std::array<double, 2>> independent_variable_bounds,
      40              :            std::vector<size_t> independent_variable_number_of_points,
      41              :            std::vector<bool> independent_variable_uses_log_spacing,
      42              :            bool beta_equilibrium, uint32_t version = 1);
      43              : 
      44              :   /// Constructor used when reading in an equation of state.
      45            1 :   EosTable(bool subfile_exists, detail::OpenGroup&& group, hid_t location,
      46              :            const std::string& name);
      47              : 
      48            0 :   EosTable(const EosTable& /*rhs*/) = delete;
      49            0 :   EosTable& operator=(const EosTable& /*rhs*/) = delete;
      50            0 :   EosTable(EosTable&& /*rhs*/) = delete;             // NOLINT
      51            0 :   EosTable& operator=(EosTable&& /*rhs*/) = delete;  // NOLINT
      52              : 
      53            0 :   ~EosTable() override = default;
      54              : 
      55              :   /*!
      56              :    * \returns the header of the EosTable file
      57              :    */
      58            1 :   const std::string& get_header() const { return header_; }
      59              : 
      60              :   /*!
      61              :    * \returns the user-specified version number of the EosTable file
      62              :    *
      63              :    * \note h5::Version returns a uint32_t, so we return one here too for the
      64              :    * version
      65              :    */
      66            1 :   uint32_t get_version() const { return version_; }
      67              : 
      68            1 :   const std::string& subfile_path() const override { return path_; }
      69              : 
      70              :   /*!
      71              :    * \brief Write a thermodynamic quantity to disk.
      72              :    */
      73            1 :   void write_quantity(std::string name, const DataVector& data);
      74              : 
      75              :   /*!
      76              :    * \brief Read a thermodynamic quantity to disk.
      77              :    */
      78            1 :   DataVector read_quantity(const std::string& name) const;
      79              : 
      80              :   /// The available thermodynamic quantities.
      81            1 :   const std::vector<std::string> available_quantities() const {
      82              :     return available_quantities_;
      83              :   }
      84              : 
      85              :   /// Number of independent variables.
      86            1 :   size_t number_of_independent_variables() const {
      87              :     return independent_variable_names_.size();
      88              :   }
      89              : 
      90              :   /// Names of the independent variables.
      91            1 :   const std::vector<std::string>& independent_variable_names() const {
      92              :     return independent_variable_names_;
      93              :   }
      94              : 
      95              :   /// Lower and upper bounds of the independent variables.
      96            1 :   const std::vector<std::array<double, 2>>& independent_variable_bounds()
      97              :       const {
      98              :     return independent_variable_bounds_;
      99              :   }
     100              : 
     101              :   /// The number of points for each of the independent variables.
     102            1 :   const std::vector<size_t>& independent_variable_number_of_points() const {
     103              :     return independent_variable_number_of_points_;
     104              :   }
     105              : 
     106              :   /// Whether each independent variable is in log spacing. Linear spacing is
     107              :   /// used if `false`.
     108            1 :   const std::vector<bool>& independent_variable_uses_log_spacing() const {
     109              :     return independent_variable_uses_log_spacing_;
     110              :   }
     111              : 
     112              :   /// `true` if the EOS is in beta equilibrium.
     113            1 :   bool beta_equilibrium() const { return beta_equilibrium_; }
     114              : 
     115              :  private:
     116            0 :   detail::OpenGroup group_{};
     117            0 :   std::string name_{};
     118            0 :   std::string path_{};
     119            0 :   uint32_t version_{};
     120            0 :   detail::OpenGroup eos_table_group_{};
     121            0 :   std::string header_{};
     122              : 
     123            0 :   std::vector<std::string> independent_variable_names_{};
     124            0 :   std::vector<std::array<double, 2>> independent_variable_bounds_{};
     125            0 :   std::vector<size_t> independent_variable_number_of_points_{};
     126            0 :   std::vector<bool> independent_variable_uses_log_spacing_{};
     127            0 :   bool beta_equilibrium_ = false;
     128            0 :   std::vector<std::string> available_quantities_{};
     129              : };
     130              : }  // namespace h5