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 <string>
       8             : 
       9             : #include "DataStructures/DataBox/Tag.hpp"
      10             : #include "DataStructures/Tensor/TypeAliases.hpp"
      11             : #include "Evolution/Systems/NewtonianEuler/Sources/Source.hpp"
      12             : #include "Evolution/Systems/NewtonianEuler/TagsDeclarations.hpp"
      13             : #include "Evolution/Tags.hpp"
      14             : #include "Options/String.hpp"
      15             : 
      16             : /// \cond
      17             : class DataVector;
      18             : /// \endcond
      19             : 
      20             : namespace NewtonianEuler {
      21             : /// %OptionTags for the conservative formulation of the Newtonian Euler system
      22           1 : namespace OptionTags {
      23             : template <size_t Dim>
      24           0 : struct SourceTerm {
      25           0 :   using type = std::unique_ptr<NewtonianEuler::Sources::Source<Dim>>;
      26           0 :   static constexpr Options::String help = "The source term to be used.";
      27           0 :   using group = ::evolution::OptionTags::SystemGroup;
      28             : };
      29             : }  // namespace OptionTags
      30             : 
      31             : /// %Tags for the conservative formulation of the Newtonian Euler system
      32             : namespace Tags {
      33             : /// The mass density of the fluid (as a conservative variable).
      34           1 : struct MassDensityCons : db::SimpleTag {
      35           0 :   using type = Scalar<DataVector>;
      36             : };
      37             : 
      38             : /// The momentum density of the fluid.
      39             : template <size_t Dim, typename Fr>
      40           1 : struct MomentumDensity : db::SimpleTag {
      41           0 :   using type = tnsr::I<DataVector, Dim, Fr>;
      42           0 :   static std::string name() { return Frame::prefix<Fr>() + "MomentumDensity"; }
      43             : };
      44             : 
      45             : /// The energy density of the fluid.
      46           1 : struct EnergyDensity : db::SimpleTag {
      47           0 :   using type = Scalar<DataVector>;
      48             : };
      49             : 
      50             : /// The sound speed.
      51             : template <typename DataType>
      52           1 : struct SoundSpeed : db::SimpleTag {
      53           0 :   using type = Scalar<DataType>;
      54             : };
      55             : 
      56             : /// The characteristic speeds.
      57             : template <size_t Dim>
      58           1 : struct CharacteristicSpeeds : db::SimpleTag {
      59           0 :   using type = std::array<DataVector, Dim + 2>;
      60             : };
      61             : 
      62             : /// @{
      63             : /// The characteristic fields of the NewtonianEuler system.
      64           1 : struct VMinus : db::SimpleTag {
      65           0 :   using type = Scalar<DataVector>;
      66             : };
      67             : template <size_t Dim>
      68           0 : struct VMomentum : db::SimpleTag {
      69           0 :   using type = tnsr::I<DataVector, Dim>;
      70             : };
      71           0 : struct VPlus : db::SimpleTag {
      72           0 :   using type = Scalar<DataVector>;
      73             : };
      74             : /// @}
      75             : 
      76             : /// The internal energy density.
      77             : template <typename DataType>
      78           1 : struct InternalEnergyDensity : db::SimpleTag {
      79           0 :   using type = Scalar<DataType>;
      80             : };
      81             : 
      82             : /// The kinetic energy density.
      83             : template <typename DataType>
      84           1 : struct KineticEnergyDensity : db::SimpleTag {
      85           0 :   using type = Scalar<DataType>;
      86             : };
      87             : 
      88             : /// The local Mach number of the flow
      89             : template <typename DataType>
      90           1 : struct MachNumber : db::SimpleTag {
      91           0 :   using type = Scalar<DataType>;
      92             : };
      93             : 
      94             : /// The ram pressure of the fluid.
      95             : template <typename DataType, size_t Dim, typename Fr>
      96           1 : struct RamPressure : db::SimpleTag {
      97           0 :   using type = tnsr::II<DataType, Dim, Fr>;
      98           0 :   static std::string name() { return Frame::prefix<Fr>() + "RamPressure"; }
      99             : };
     100             : 
     101             : /// The specific kinetic energy.
     102             : template <typename DataType>
     103           1 : struct SpecificKineticEnergy : db::SimpleTag {
     104           0 :   using type = Scalar<DataType>;
     105             : };
     106             : 
     107             : /// The source term in the evolution equations
     108             : template <size_t Dim>
     109           1 : struct SourceTerm : db::SimpleTag {
     110           0 :   using type = std::unique_ptr<NewtonianEuler::Sources::Source<Dim>>;
     111             : 
     112           0 :   using option_tags = tmpl::list<OptionTags::SourceTerm<Dim>>;
     113             : 
     114           0 :   static constexpr bool pass_metavariables = false;
     115           0 :   static type create_from_options(const type& source_term) {
     116             :     return source_term->get_clone();
     117             :   }
     118             : };
     119             : 
     120             : }  // namespace Tags
     121             : }  // namespace NewtonianEuler