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             : 
      12             : #include "Evolution/Systems/RadiationTransport/Tags.hpp"
      13             : 
      14             : class DataVector;
      15             : 
      16             : /// Namespace for all radiation transport algorithms
      17             : namespace RadiationTransport {
      18             : /// Namespace for the grey-M1 radiation transport scheme
      19             : namespace M1Grey {
      20             : /// %Tags for the evolution of neutrinos using a grey M1 scheme.
      21             : namespace Tags {
      22             : 
      23             : /// The characteristic speeds
      24           1 : struct CharacteristicSpeeds : db::SimpleTag {
      25           0 :   using type = std::array<DataVector, 4>;
      26             : };
      27             : 
      28             : /// The densitized energy density of neutrinos of a given species
      29             : /// \f${\tilde E}\f$
      30             : template <typename Fr, class Species>
      31           1 : struct TildeE : db::SimpleTag {
      32           0 :   using type = Scalar<DataVector>;
      33           0 :   static std::string name() {
      34             :     return Frame::prefix<Fr>() + "TildeE_" + neutrinos::get_name(Species{});
      35             :   }
      36             : };
      37             : 
      38             : /// The densitized momentum density of neutrinos of a given species
      39             : /// \f${\tilde S_i}\f$
      40             : template <typename Fr, class Species>
      41           1 : struct TildeS : db::SimpleTag {
      42           0 :   using type = tnsr::i<DataVector, 3, Fr>;
      43           0 :   static std::string name() {
      44             :     return Frame::prefix<Fr>() + "TildeS_" + neutrinos::get_name(Species{});
      45             :   }
      46             : };
      47             : 
      48             : /// The densitized pressure tensor of neutrinos of a given species
      49             : /// \f${\tilde P^{ij}}\f$
      50             : /// computed from \f${\tilde E}\f$, \f${\tilde S_i}\f$ using the M1 closure
      51             : template <typename Fr, class Species>
      52           1 : struct TildeP : db::SimpleTag {
      53           0 :   using type = tnsr::II<DataVector, 3, Fr>;
      54           0 :   static std::string name() {
      55             :     return Frame::prefix<Fr>() + "TildeP_" + neutrinos::get_name(Species{});
      56             :   }
      57             : };
      58             : 
      59             : /// The upper index momentum density of a neutrino species.
      60             : ///
      61             : /// This tag does not know the species of neutrinos being used.
      62             : /// \f${\tilde S^i}\f$
      63             : template <typename Fr>
      64           1 : struct TildeSVector : db::SimpleTag {
      65           0 :   using type = tnsr::I<DataVector, 3, Fr>;
      66           0 :   static std::string name() { return Frame::prefix<Fr>() + "TildeSVector"; }
      67             : };
      68             : 
      69             : /// The M1 closure factor of neutrinos of
      70             : /// a given species \f${\xi}\f$
      71             : template <class Species>
      72           1 : struct ClosureFactor : db::SimpleTag {
      73           0 :   using type = Scalar<DataVector>;
      74           0 :   static std::string name() {
      75             :     return "ClosureFactor_" + neutrinos::get_name(Species{});
      76             :   }
      77             : };
      78             : 
      79             : /// The fluid-frame densitized energy density of neutrinos of
      80             : /// a given species \f${\tilde J}\f$
      81             : template <class Species>
      82           1 : struct TildeJ : db::SimpleTag {
      83           0 :   using type = Scalar<DataVector>;
      84           0 :   static std::string name() {
      85             :     return "TildeJ_" + neutrinos::get_name(Species{});
      86             :   }
      87             : };
      88             : 
      89             : /// The normal component of the fluid-frame momentum density of neutrinos of
      90             : /// a given species \f${\tilde H}^a t_a\f$
      91             : template <class Species>
      92           1 : struct TildeHNormal : db::SimpleTag {
      93           0 :   using type = Scalar<DataVector>;
      94           0 :   static std::string name() {
      95             :     return "TildeHNormal_" + neutrinos::get_name(Species{});
      96             :   }
      97             : };
      98             : 
      99             : /// The spatial components of the fluid-frame momentum density of neutrinos of
     100             : /// a given species \f${\tilde H}^a {\gamma}_{ia}\f$
     101             : template <typename Fr, class Species>
     102           1 : struct TildeHSpatial : db::SimpleTag {
     103           0 :   using type = tnsr::i<DataVector, 3, Fr>;
     104           0 :   static std::string name() {
     105             :     return Frame::prefix<Fr>() + "TildeHSpatial_" +
     106             :            neutrinos::get_name(Species{});
     107             :   }
     108             : };
     109             : 
     110             : /// The emissivity of the fluid for neutrinos of a given species.
     111             : ///
     112             : /// By convention, this is the emitted energy per unit volume.
     113             : template <class Species>
     114           1 : struct GreyEmissivity : db::SimpleTag {
     115           0 :   using type = Scalar<DataVector>;
     116           0 :   static std::string name() {
     117             :     return "GreyEmissivity_" + neutrinos::get_name(Species{});
     118             :   }
     119             : };
     120             : 
     121             : /// The absorption opacity of the fluid for neutrinos of a
     122             : /// given species.
     123             : ///
     124             : /// As c=1, this is both the absorption per unit length
     125             : /// and per unit time.
     126             : template <class Species>
     127           1 : struct GreyAbsorptionOpacity : db::SimpleTag {
     128           0 :   using type = Scalar<DataVector>;
     129           0 :   static std::string name() {
     130             :     return "GreyAbsorptionOpacity_" + neutrinos::get_name(Species{});
     131             :   }
     132             : };
     133             : 
     134             : /// The scattering opacity of the fluid for neutrinos of a
     135             : /// given species.
     136             : ///
     137             : /// As c=1, this is both the absorption per unit length and per unit time.
     138             : template <class Species>
     139           1 : struct GreyScatteringOpacity : db::SimpleTag {
     140           0 :   using type = Scalar<DataVector>;
     141           0 :   static std::string name() {
     142             :     return "GreyScatteringOpacity_" + neutrinos::get_name(Species{});
     143             :   }
     144             : };
     145             : 
     146             : /// The normal component of the source term coupling the M1 and hydro equations.
     147             : ///
     148             : /// This is the source term for the evolution of \f${\tilde E}\f$ (by
     149             : /// convention, added with a positive sign to \f${\tilde E}\f$ and a negative
     150             : /// sign to the hydro variable \f${\tilde \tau}\f$)
     151             : template <class Species>
     152           1 : struct M1HydroCouplingNormal : db::SimpleTag {
     153           0 :   using type = Scalar<DataVector>;
     154           0 :   static std::string name() {
     155             :     return "M1HydroCouplingNormal_" + neutrinos::get_name(Species{});
     156             :   }
     157             : };
     158             : 
     159             : /// The spatial components of source term coupling the M1 and hydro equations.
     160             : ///
     161             : /// i.e. \f${\tilde G}^a \gamma_{ia}\f$.
     162             : /// This is the source term for the evolution of \f${\tilde S}_i\f$ (by
     163             : /// convention, added with a positive sign to the neutrino \f${\tilde S}_i\f$
     164             : /// and a negative sign to the hydro variable \f${\tilde S}_i\f$)
     165             : template <typename Fr, class Species>
     166           1 : struct M1HydroCouplingSpatial : db::SimpleTag {
     167           0 :   using type = tnsr::i<DataVector, 3, Fr>;
     168           0 :   static std::string name() {
     169             :     return Frame::prefix<Fr>() + "M1HydroCouplingSpatial_" +
     170             :            neutrinos::get_name(Species{});
     171             :   }
     172             : };
     173             : 
     174             : }  // namespace Tags
     175             : }  // namespace M1Grey
     176             : }  // namespace RadiationTransport