SpECTRE Documentation Coverage Report
Current view: top level - PointwiseFunctions/Hydro/EquationsOfState - EquationOfState.hpp Hit Total Coverage
Commit: cd74d65bdc718fd7e344eaec61dc6334dd4d366b Lines: 42 67 62.7 %
Date: 2022-08-12 23:56:47
Legend: Lines: hit not hit

          Line data    Source code
       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <boost/preprocessor/arithmetic/sub.hpp>
       7             : #include <boost/preprocessor/list/for_each.hpp>
       8             : #include <boost/preprocessor/punctuation/comma_if.hpp>
       9             : #include <boost/preprocessor/repetition/repeat.hpp>
      10             : #include <boost/preprocessor/tuple/enum.hpp>
      11             : #include <boost/preprocessor/tuple/to_list.hpp>
      12             : 
      13             : #include "DataStructures/DataVector.hpp"
      14             : #include "DataStructures/Tensor/Tensor.hpp"
      15             : #include "Parallel/CharmPupable.hpp"
      16             : #include "Utilities/TMPL.hpp"
      17             : #include "Utilities/TypeTraits.hpp"
      18             : 
      19             : /// \cond
      20             : namespace EquationsOfState {
      21             : template <bool IsRelativistic>
      22             : class DarkEnergyFluid;
      23             : template <typename ColdEquationOfState>
      24             : class HybridEos;
      25             : template <bool IsRelativistic>
      26             : class IdealFluid;
      27             : template <bool IsRelativistic>
      28             : class PolytropicFluid;
      29             : class Spectral;
      30             : template <typename LowDensityEoS>
      31             : class Enthalpy;
      32             : }  // namespace EquationsOfState
      33             : /// \endcond
      34             : 
      35             : /// Contains all equations of state, including base class
      36             : namespace EquationsOfState {
      37             : 
      38             : namespace detail {
      39             : template <bool IsRelativistic, size_t ThermodynamicDim>
      40             : struct DerivedClasses {};
      41             : 
      42             : template <>
      43             : struct DerivedClasses<true, 1> {
      44             :   using type = tmpl::list<Spectral, Enthalpy<Spectral>, PolytropicFluid<true>>;
      45             : };
      46             : 
      47             : template <>
      48             : struct DerivedClasses<false, 1> {
      49             :   using type = tmpl::list<PolytropicFluid<false>>;
      50             : };
      51             : 
      52             : template <>
      53             : struct DerivedClasses<true, 2> {
      54             :   using type = tmpl::list<DarkEnergyFluid<true>, IdealFluid<true>,
      55             :                           HybridEos<PolytropicFluid<true>>>;
      56             : };
      57             : 
      58             : template <>
      59             : struct DerivedClasses<false, 2> {
      60             :   using type = tmpl::list<IdealFluid<false>, HybridEos<PolytropicFluid<false>>>;
      61             : };
      62             : 
      63             : }  // namespace detail
      64             : 
      65             : /*!
      66             :  * \ingroup EquationsOfStateGroup
      67             :  * \brief Base class for equations of state depending on whether or not the
      68             :  * system is relativistic, and the number of independent thermodynamic variables
      69             :  * (`ThermodynamicDim`) needed to determine the pressure.
      70             :  *
      71             :  * The template parameter `IsRelativistic` is `true` for relativistic equations
      72             :  * of state and `false` for non-relativistic equations of state.
      73             :  */
      74             : template <bool IsRelativistic, size_t ThermodynamicDim>
      75           1 : class EquationOfState;
      76             : 
      77             : /*!
      78             :  * \ingroup EquationsOfStateGroup
      79             :  * \brief Base class for equations of state which need one thermodynamic
      80             :  * variable in order to determine the pressure.
      81             :  *
      82             :  * The template parameter `IsRelativistic` is `true` for relativistic equations
      83             :  * of state and `false` for non-relativistic equations of state.
      84             :  */
      85             : template <bool IsRelativistic>
      86           1 : class EquationOfState<IsRelativistic, 1> : public PUP::able {
      87             :  public:
      88           0 :   static constexpr bool is_relativistic = IsRelativistic;
      89           0 :   static constexpr size_t thermodynamic_dim = 1;
      90           0 :   using creatable_classes =
      91             :       typename detail::DerivedClasses<IsRelativistic, 1>::type;
      92             : 
      93           0 :   EquationOfState() = default;
      94           0 :   EquationOfState(const EquationOfState&) = default;
      95           0 :   EquationOfState& operator=(const EquationOfState&) = default;
      96           0 :   EquationOfState(EquationOfState&&) = default;
      97           0 :   EquationOfState& operator=(EquationOfState&&) = default;
      98           0 :   ~EquationOfState() override = default;
      99             : 
     100           0 :   explicit EquationOfState(CkMigrateMessage* msg) : PUP::able(msg) {}
     101             : 
     102           0 :   WRAPPED_PUPable_abstract(EquationOfState);  // NOLINT
     103             : 
     104             :   /// @{
     105             :   /*!
     106             :    * Computes the pressure \f$p\f$ from the rest mass density \f$\rho\f$.
     107             :    */
     108           1 :   virtual Scalar<double> pressure_from_density(
     109             :       const Scalar<double>& /*rest_mass_density*/) const = 0;
     110           1 :   virtual Scalar<DataVector> pressure_from_density(
     111             :       const Scalar<DataVector>& /*rest_mass_density*/) const = 0;
     112             :   /// @}
     113             : 
     114             :   /// @{
     115             :   /*!
     116             :    * Computes the rest mass density \f$\rho\f$ from the specific enthalpy
     117             :    * \f$h\f$.
     118             :    */
     119           1 :   virtual Scalar<double> rest_mass_density_from_enthalpy(
     120             :       const Scalar<double>& /*specific_enthalpy*/) const = 0;
     121           1 :   virtual Scalar<DataVector> rest_mass_density_from_enthalpy(
     122             :       const Scalar<DataVector>& /*specific_enthalpy*/) const = 0;
     123             :   /// @}
     124             : 
     125             :   /// @{
     126             :   /*!
     127             :    * Computes the specific internal energy \f$\epsilon\f$ from the rest mass
     128             :    * density \f$\rho\f$.
     129             :    */
     130           1 :   virtual Scalar<double> specific_internal_energy_from_density(
     131             :       const Scalar<double>& /*rest_mass_density*/) const = 0;
     132           1 :   virtual Scalar<DataVector> specific_internal_energy_from_density(
     133             :       const Scalar<DataVector>& /*rest_mass_density*/) const = 0;
     134             :   /// @}
     135             : 
     136             :   /// @{
     137             :   /*!
     138             :    * Computes the temperature \f$T\f$ from the rest mass
     139             :    * density \f$\rho\f$.
     140             :    */
     141           1 :   virtual Scalar<double> temperature_from_density(
     142             :       const Scalar<double>& /*rest_mass_density*/) const {
     143             :     return Scalar<double>{0.0};
     144             :   }
     145           1 :   virtual Scalar<DataVector> temperature_from_density(
     146             :       const Scalar<DataVector>& rest_mass_density) const {
     147             :     return Scalar<DataVector>{DataVector{get(rest_mass_density).size(), 0.0}};
     148             :   }
     149             :   /// @}
     150             : 
     151             :   /// @{
     152             :   /*!
     153             :    * Computes the temperature \f$\T\f$ from the specific internal energy
     154             :    * \f$\epsilon\f$.
     155             :    */
     156           1 :   virtual Scalar<double> temperature_from_specific_internal_energy(
     157             :       const Scalar<double>& /*specific_internal_energy*/) const {
     158             :     return Scalar<double>{0.0};
     159             :   }
     160           1 :   virtual Scalar<DataVector> temperature_from_specific_internal_energy(
     161             :       const Scalar<DataVector>& specific_internal_energy) const {
     162             :     return Scalar<DataVector>{
     163             :         DataVector{get(specific_internal_energy).size(), 0.0}};
     164             :   }
     165             :   /// @}
     166             : 
     167             :   /// @{
     168             :   /*!
     169             :    * Computes \f$\chi=\partial p / \partial \rho\f$ from \f$\rho\f$, where
     170             :    * \f$p\f$ is the pressure and \f$\rho\f$ is the rest mass density.
     171             :    */
     172           1 :   virtual Scalar<double> chi_from_density(
     173             :       const Scalar<double>& /*rest_mass_density*/) const = 0;
     174           1 :   virtual Scalar<DataVector> chi_from_density(
     175             :       const Scalar<DataVector>& /*rest_mass_density*/) const = 0;
     176             :   /// @}
     177             : 
     178             :   /// @{
     179             :   /*!
     180             :    * Computes \f$\kappa p/\rho^2=(p/\rho^2)\partial p / \partial \epsilon\f$
     181             :    * from \f$\rho\f$, where \f$p\f$ is the pressure, \f$\rho\f$ is the rest mass
     182             :    * density, and \f$\epsilon\f$ is the specific internal energy.
     183             :    *
     184             :    * The reason for not returning just
     185             :    * \f$\kappa=\partial p / \partial \epsilon\f$ is to avoid division by zero
     186             :    * for small values of \f$\rho\f$ when assembling the speed of sound with
     187             :    * some equations of state.
     188             :    */
     189           1 :   virtual Scalar<double> kappa_times_p_over_rho_squared_from_density(
     190             :       const Scalar<double>& /*rest_mass_density*/) const = 0;
     191           1 :   virtual Scalar<DataVector> kappa_times_p_over_rho_squared_from_density(
     192             :       const Scalar<DataVector>& /*rest_mass_density*/) const = 0;
     193             : 
     194             :   /// The lower bound of the rest mass density that is valid for this EOS
     195           1 :   virtual double rest_mass_density_lower_bound() const = 0;
     196             : 
     197             :   /// The upper bound of the rest mass density that is valid for this EOS
     198           1 :   virtual double rest_mass_density_upper_bound() const = 0;
     199             : 
     200             :   /// The lower bound of the specific internal energy that is valid for this EOS
     201             :   /// at the given rest mass density \f$\rho\f$
     202           1 :   virtual double specific_internal_energy_lower_bound(
     203             :       const double rest_mass_density) const = 0;
     204             : 
     205             :   /// The upper bound of the specific internal energy that is valid for this EOS
     206             :   /// at the given rest mass density \f$\rho\f$
     207           1 :   virtual double specific_internal_energy_upper_bound(
     208             :       const double rest_mass_density) const = 0;
     209             : 
     210             :   /// The lower bound of the specific enthalpy that is valid for this EOS
     211           1 :   virtual double specific_enthalpy_lower_bound() const = 0;
     212             : };
     213             : 
     214             : /*!
     215             :  * \ingroup EquationsOfStateGroup
     216             :  * \brief Base class for equations of state which need two independent
     217             :  * thermodynamic variables in order to determine the pressure.
     218             :  *
     219             :  * The template parameter `IsRelativistic` is `true` for relativistic equations
     220             :  * of state and `false` for non-relativistic equations of state.
     221             :  */
     222             : template <bool IsRelativistic>
     223           1 : class EquationOfState<IsRelativistic, 2> : public PUP::able {
     224             :  public:
     225           0 :   static constexpr bool is_relativistic = IsRelativistic;
     226           0 :   static constexpr size_t thermodynamic_dim = 2;
     227           0 :   using creatable_classes =
     228             :       typename detail::DerivedClasses<IsRelativistic, 2>::type;
     229             : 
     230           0 :   EquationOfState() = default;
     231           0 :   EquationOfState(const EquationOfState&) = default;
     232           0 :   EquationOfState& operator=(const EquationOfState&) = default;
     233           0 :   EquationOfState(EquationOfState&&) = default;
     234           0 :   EquationOfState& operator=(EquationOfState&&) = default;
     235           0 :   ~EquationOfState() override = default;
     236             : 
     237           0 :   explicit EquationOfState(CkMigrateMessage* msg) : PUP::able(msg) {}
     238             : 
     239           0 :   WRAPPED_PUPable_abstract(EquationOfState);  // NOLINT
     240             : 
     241             :   /// @{
     242             :   /*!
     243             :    * Computes the pressure \f$p\f$ from the rest mass density \f$\rho\f$ and the
     244             :    * specific internal energy \f$\epsilon\f$.
     245             :    */
     246           1 :   virtual Scalar<double> pressure_from_density_and_energy(
     247             :       const Scalar<double>& /*rest_mass_density*/,
     248             :       const Scalar<double>& /*specific_internal_energy*/) const = 0;
     249           1 :   virtual Scalar<DataVector> pressure_from_density_and_energy(
     250             :       const Scalar<DataVector>& /*rest_mass_density*/,
     251             :       const Scalar<DataVector>& /*specific_internal_energy*/) const = 0;
     252             :   /// @}
     253             : 
     254             :   /// @{
     255             :   /*!
     256             :    * Computes the pressure \f$p\f$ from the rest mass density \f$\rho\f$ and the
     257             :    * specific enthalpy \f$h\f$.
     258             :    */
     259           1 :   virtual Scalar<double> pressure_from_density_and_enthalpy(
     260             :       const Scalar<double>& /*rest_mass_density*/,
     261             :       const Scalar<double>& /*specific_enthalpy*/) const = 0;
     262           1 :   virtual Scalar<DataVector> pressure_from_density_and_enthalpy(
     263             :       const Scalar<DataVector>& /*rest_mass_density*/,
     264             :       const Scalar<DataVector>& /*specific_enthalpy*/) const = 0;
     265             :   /// @}
     266             : 
     267             :   /// @{
     268             :   /*!
     269             :    * Computes the specific internal energy \f$\epsilon\f$ from the rest mass
     270             :    * density \f$\rho\f$ and the pressure \f$p\f$.
     271             :    */
     272           1 :   virtual Scalar<double> specific_internal_energy_from_density_and_pressure(
     273             :       const Scalar<double>& /*rest_mass_density*/,
     274             :       const Scalar<double>& /*pressure*/) const = 0;
     275           1 :   virtual Scalar<DataVector> specific_internal_energy_from_density_and_pressure(
     276             :       const Scalar<DataVector>& /*rest_mass_density*/,
     277             :       const Scalar<DataVector>& /*pressure*/) const = 0;
     278             :   /// @}
     279             : 
     280             :   /// @{
     281             :   /*!
     282             :    * Computes the temperature \f$T\f$ from the rest mass
     283             :    * density \f$\rho\f$ and the specific internal energy \f$\epsilon\f$.
     284             :    */
     285           1 :   virtual Scalar<double> temperature_from_density_and_energy(
     286             :       const Scalar<double>& /*rest_mass_density*/,
     287             :       const Scalar<double>& /*specific_internal_energy*/) const = 0;
     288           1 :   virtual Scalar<DataVector> temperature_from_density_and_energy(
     289             :       const Scalar<DataVector>& /*rest_mass_density*/,
     290             :       const Scalar<DataVector>& /*specific_internal_energy*/) const = 0;
     291             :   /// @}
     292             : 
     293             :   /// @{
     294             :   /*!
     295             :    * Computes the specific internal energy \f$\epsilon\f$ from the rest mass
     296             :    * density \f$\rho\f$ and the temperature \f$T\f$.
     297             :    */
     298           1 :   virtual Scalar<double> specific_internal_energy_from_density_and_temperature(
     299             :       const Scalar<double>& /*rest_mass_density*/,
     300             :       const Scalar<double>& /*temperature*/) const = 0;
     301             :   virtual Scalar<DataVector>
     302           1 :   specific_internal_energy_from_density_and_temperature(
     303             :       const Scalar<DataVector>& /*rest_mass_density*/,
     304             :       const Scalar<DataVector>& /*temperature*/) const = 0;
     305             :   /// @}
     306             : 
     307             :   /// @{
     308             :   /*!
     309             :    * Computes \f$\chi=\partial p / \partial \rho\f$ from the \f$\rho\f$ and
     310             :    * \f$\epsilon\f$, where \f$p\f$ is the pressure, \f$\rho\f$ is the rest mass
     311             :    * density, and \f$\epsilon\f$ is the specific internal energy.
     312             :    */
     313           1 :   virtual Scalar<double> chi_from_density_and_energy(
     314             :       const Scalar<double>& /*rest_mass_density*/,
     315             :       const Scalar<double>& /*specific_internal_energy*/) const = 0;
     316           1 :   virtual Scalar<DataVector> chi_from_density_and_energy(
     317             :       const Scalar<DataVector>& /*rest_mass_density*/,
     318             :       const Scalar<DataVector>& /*specific_internal_energy*/) const = 0;
     319             :   /// @}
     320             : 
     321             :   /// @{
     322             :   /*!
     323             :    * Computes \f$\kappa p/\rho^2=(p/\rho^2)\partial p / \partial \epsilon\f$
     324             :    * from \f$\rho\f$ and \f$\epsilon\f$, where \f$p\f$ is the pressure,
     325             :    * \f$\rho\f$ is the rest mass density, and \f$\epsilon\f$ is the specific
     326             :    * internal energy.
     327             :    *
     328             :    * The reason for not returning just
     329             :    * \f$\kappa=\partial p / \partial \epsilon\f$ is to avoid division by zero
     330             :    * for small values of \f$\rho\f$ when assembling the speed of sound with
     331             :    * some equations of state.
     332             :    */
     333           1 :   virtual Scalar<double> kappa_times_p_over_rho_squared_from_density_and_energy(
     334             :       const Scalar<double>& /*rest_mass_density*/,
     335             :       const Scalar<double>& /*specific_internal_energy*/) const = 0;
     336             :   virtual Scalar<DataVector>
     337           1 :   kappa_times_p_over_rho_squared_from_density_and_energy(
     338             :       const Scalar<DataVector>& /*rest_mass_density*/,
     339             :       const Scalar<DataVector>& /*specific_internal_energy*/) const = 0;
     340             :   /// @}
     341             : 
     342             :   /// The lower bound of the rest mass density that is valid for this EOS
     343           1 :   virtual double rest_mass_density_lower_bound() const = 0;
     344             : 
     345             :   /// The upper bound of the rest mass density that is valid for this EOS
     346           1 :   virtual double rest_mass_density_upper_bound() const = 0;
     347             : 
     348             :   /// The lower bound of the specific internal energy that is valid for this EOS
     349             :   /// at the given rest mass density \f$\rho\f$
     350           1 :   virtual double specific_internal_energy_lower_bound(
     351             :       const double rest_mass_density) const = 0;
     352             : 
     353             :   /// The upper bound of the specific internal energy that is valid for this EOS
     354             :   /// at the given rest mass density \f$\rho\f$
     355           1 :   virtual double specific_internal_energy_upper_bound(
     356             :       const double rest_mass_density) const = 0;
     357             : 
     358             :   /// The lower bound of the specific enthalpy that is valid for this EOS
     359           1 :   virtual double specific_enthalpy_lower_bound() const = 0;
     360             : };
     361             : }  // namespace EquationsOfState
     362             : 
     363             : /// \cond
     364             : #define EQUATION_OF_STATE_FUNCTIONS_1D                      \
     365             :   (pressure_from_density, rest_mass_density_from_enthalpy,  \
     366             :    specific_internal_energy_from_density, chi_from_density, \
     367             :    kappa_times_p_over_rho_squared_from_density)
     368             : 
     369             : #define EQUATION_OF_STATE_FUNCTIONS_2D                                   \
     370             :   (pressure_from_density_and_energy, pressure_from_density_and_enthalpy, \
     371             :    specific_internal_energy_from_density_and_pressure,                   \
     372             :    temperature_from_density_and_energy,                                  \
     373             :    specific_internal_energy_from_density_and_temperature,                \
     374             :    chi_from_density_and_energy,                                          \
     375             :    kappa_times_p_over_rho_squared_from_density_and_energy)
     376             : 
     377             : #define EQUATION_OF_STATE_ARGUMENTS_EXPAND(z, n, type) \
     378             :   BOOST_PP_COMMA_IF(n) const Scalar<type>&
     379             : 
     380             : #define EQUATION_OF_STATE_FORWARD_DECLARE_MEMBERS_HELPER(r, DIM,        \
     381             :                                                          FUNCTION_NAME) \
     382             :   Scalar<double> FUNCTION_NAME(BOOST_PP_REPEAT(                         \
     383             :       DIM, EQUATION_OF_STATE_ARGUMENTS_EXPAND, double)) const override; \
     384             :   Scalar<DataVector> FUNCTION_NAME(BOOST_PP_REPEAT(                     \
     385             :       DIM, EQUATION_OF_STATE_ARGUMENTS_EXPAND, DataVector)) const override;
     386             : 
     387             : /// \endcond
     388             : 
     389             : /*!
     390             :  * \ingroup EquationsOfStateGroup
     391             :  * \brief Macro used to generate forward declarations of member functions in
     392             :  * derived classes
     393             :  */
     394           1 : #define EQUATION_OF_STATE_FORWARD_DECLARE_MEMBERS(DERIVED, DIM)               \
     395             :   BOOST_PP_LIST_FOR_EACH(                                                     \
     396             :       EQUATION_OF_STATE_FORWARD_DECLARE_MEMBERS_HELPER, DIM,                  \
     397             :       BOOST_PP_TUPLE_TO_LIST(BOOST_PP_TUPLE_ELEM(                             \
     398             :           BOOST_PP_SUB(DIM, 1),                                               \
     399             :           (EQUATION_OF_STATE_FUNCTIONS_1D, EQUATION_OF_STATE_FUNCTIONS_2D)))) \
     400             :                                                                               \
     401             :   /* clang-tidy: do not use non-const references */                           \
     402             :   void pup(PUP::er& p) override; /* NOLINT */                                 \
     403             :                                                                               \
     404             :   explicit DERIVED(CkMigrateMessage* msg);
     405             : 
     406             : /// \cond
     407             : #define EQUATION_OF_STATE_FORWARD_ARGUMENTS(z, n, unused) \
     408             :   BOOST_PP_COMMA_IF(n) arg##n
     409             : 
     410             : #define EQUATION_OF_STATE_ARGUMENTS_EXPAND_NAMED(z, n, type) \
     411             :   BOOST_PP_COMMA_IF(n) const Scalar<type>& arg##n
     412             : 
     413             : #define EQUATION_OF_STATE_MEMBER_DEFINITIONS_HELPER(                        \
     414             :     TEMPLATE, DERIVED, DATA_TYPE, DIM, FUNCTION_NAME)                       \
     415             :   TEMPLATE                                                                  \
     416             :   Scalar<DATA_TYPE> DERIVED::FUNCTION_NAME(BOOST_PP_REPEAT(                 \
     417             :       DIM, EQUATION_OF_STATE_ARGUMENTS_EXPAND_NAMED, DATA_TYPE)) const {    \
     418             :     return FUNCTION_NAME##_impl(                                            \
     419             :         BOOST_PP_REPEAT(DIM, EQUATION_OF_STATE_FORWARD_ARGUMENTS, UNUSED)); \
     420             :   }
     421             : 
     422             : #define EQUATION_OF_STATE_MEMBER_DEFINITIONS_HELPER_2(r, ARGS, FUNCTION_NAME) \
     423             :   EQUATION_OF_STATE_MEMBER_DEFINITIONS_HELPER(                                \
     424             :       BOOST_PP_TUPLE_ELEM(0, ARGS), BOOST_PP_TUPLE_ELEM(1, ARGS),             \
     425             :       BOOST_PP_TUPLE_ELEM(2, ARGS), BOOST_PP_TUPLE_ELEM(3, ARGS),             \
     426             :       FUNCTION_NAME)
     427             : /// \endcond
     428             : 
     429             : #define EQUATION_OF_STATE_MEMBER_DEFINITIONS(TEMPLATE, DERIVED, DATA_TYPE, \
     430           0 :                                              DIM)                          \
     431             :   BOOST_PP_LIST_FOR_EACH(                                                  \
     432             :       EQUATION_OF_STATE_MEMBER_DEFINITIONS_HELPER_2,                       \
     433             :       (TEMPLATE, DERIVED, DATA_TYPE, DIM),                                 \
     434             :       BOOST_PP_TUPLE_TO_LIST(BOOST_PP_TUPLE_ELEM(                          \
     435             :           BOOST_PP_SUB(DIM, 1),                                            \
     436             :           (EQUATION_OF_STATE_FUNCTIONS_1D, EQUATION_OF_STATE_FUNCTIONS_2D))))
     437             : 
     438             : /// \cond
     439             : #define EQUATION_OF_STATE_FORWARD_DECLARE_MEMBER_IMPLS_HELPER(r, DIM,        \
     440             :                                                               FUNCTION_NAME) \
     441             :   template <class DataType>                                                  \
     442             :   Scalar<DataType> FUNCTION_NAME##_impl(BOOST_PP_REPEAT(                     \
     443             :       DIM, EQUATION_OF_STATE_ARGUMENTS_EXPAND, DataType)) const;
     444             : /// \endcond
     445             : 
     446           0 : #define EQUATION_OF_STATE_FORWARD_DECLARE_MEMBER_IMPLS(DIM)       \
     447             :   BOOST_PP_LIST_FOR_EACH(                                         \
     448             :       EQUATION_OF_STATE_FORWARD_DECLARE_MEMBER_IMPLS_HELPER, DIM, \
     449             :       BOOST_PP_TUPLE_TO_LIST(BOOST_PP_TUPLE_ELEM(                 \
     450             :           BOOST_PP_SUB(DIM, 1),                                   \
     451             :           (EQUATION_OF_STATE_FUNCTIONS_1D, EQUATION_OF_STATE_FUNCTIONS_2D))))

Generated by: LCOV version 1.14