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             : 
       8             : #include "DataStructures/DataBox/Tag.hpp"
       9             : #include "DataStructures/Tensor/Tensor.hpp"
      10             : #include "Evolution/Systems/NewtonianEuler/Tags.hpp"
      11             : #include "PointwiseFunctions/Hydro/EquationsOfState/EquationOfState.hpp"
      12             : #include "PointwiseFunctions/Hydro/Tags.hpp"
      13             : #include "Utilities/Gsl.hpp"
      14             : #include "Utilities/TMPL.hpp"
      15             : 
      16             : namespace NewtonianEuler {
      17             : /// @{
      18             : /*!
      19             :  * Compute the Newtonian sound speed squared
      20             :  * \f$c_s^2 = \chi + p\kappa / \rho^2\f$, where
      21             :  * \f$p\f$ is the fluid pressure, \f$\rho\f$ is the mass density,
      22             :  * \f$\chi = (\partial p/\partial\rho)_\epsilon\f$ and
      23             :  * \f$\kappa = (\partial p/ \partial \epsilon)_\rho\f$, where
      24             :  * \f$\epsilon\f$ is the specific internal energy.
      25             :  */
      26             : template <typename DataType, size_t ThermodynamicDim>
      27           1 : void sound_speed_squared(
      28             :     gsl::not_null<Scalar<DataType>*> result,
      29             :     const Scalar<DataType>& mass_density,
      30             :     const Scalar<DataType>& specific_internal_energy,
      31             :     const EquationsOfState::EquationOfState<false, ThermodynamicDim>&
      32             :         equation_of_state);
      33             : 
      34             : template <typename DataType, size_t ThermodynamicDim>
      35           1 : Scalar<DataType> sound_speed_squared(
      36             :     const Scalar<DataType>& mass_density,
      37             :     const Scalar<DataType>& specific_internal_energy,
      38             :     const EquationsOfState::EquationOfState<false, ThermodynamicDim>&
      39             :         equation_of_state);
      40             : /// @}
      41             : 
      42             : namespace Tags {
      43             : /// Compute item for the sound speed \f$c_s\f$.
      44             : ///
      45             : /// Can be retrieved using `NewtonianEuler::Tags::SoundSpeed`
      46             : template <typename DataType>
      47           1 : struct SoundSpeedCompute : SoundSpeed<DataType>, db::ComputeTag {
      48           0 :   using argument_tags = tmpl::list<hydro::Tags::SoundSpeedSquared<DataType>>;
      49             : 
      50           0 :   using return_type = Scalar<DataType>;
      51             : 
      52           0 :   static void function(const gsl::not_null<Scalar<DataType>*> result,
      53             :                        const Scalar<DataType>& sound_speed_squared) {
      54             :     get(*result) = sqrt(get(sound_speed_squared));
      55             :   }
      56             : 
      57           0 :   using base = SoundSpeed<DataType>;
      58             : };
      59             : 
      60             : /// Compute item for the sound speed squared \f$c_s^2\f$.
      61             : /// \see NewtonianEuler::sound_speed_squared
      62             : ///
      63             : /// Can be retrieved using `NewtonianEuler::Tags::SoundSpeedSquared`
      64             : template <typename DataType>
      65           1 : struct SoundSpeedSquaredCompute : hydro::Tags::SoundSpeedSquared<DataType>,
      66             :                                   db::ComputeTag {
      67           0 :   using argument_tags =
      68             :       tmpl::list<hydro::Tags::RestMassDensity<DataType>,
      69             :                  hydro::Tags::SpecificInternalEnergy<DataType>,
      70             :                  hydro::Tags::EquationOfState<false, 2>>;
      71             : 
      72           0 :   using return_type = Scalar<DataType>;
      73             : 
      74             :   template <typename EquationOfStateType>
      75           0 :   static void function(const gsl::not_null<Scalar<DataType>*> result,
      76             :                        const Scalar<DataType>& mass_density,
      77             :                        const Scalar<DataType>& specific_internal_energy,
      78             :                        const EquationOfStateType& equation_of_state) {
      79             :     sound_speed_squared(result, mass_density, specific_internal_energy,
      80             :                         equation_of_state);
      81             :   }
      82             : 
      83           0 :   using base = hydro::Tags::SoundSpeedSquared<DataType>;
      84             : };
      85             : }  // namespace Tags
      86             : }  // namespace NewtonianEuler