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/Tensor/TypeAliases.hpp"
       9             : #include "Utilities/Gsl.hpp"
      10             : 
      11             : /// \cond
      12             : class DataVector;
      13             : template <size_t>
      14             : class Mesh;
      15             : 
      16             : namespace EquationsOfState {
      17             : template <bool, size_t>
      18             : class EquationOfState;
      19             : }  // namespace EquationsOfState
      20             : /// \endcond
      21             : 
      22             : namespace NewtonianEuler::Limiters {
      23             : 
      24             : /// \ingroup LimitersGroup
      25             : /// \brief Encodes the action taken by `flatten_solution`
      26           0 : enum class FlattenerAction {
      27             :   NoOp = 0,
      28             :   ScaledSolution = 1,
      29             :   SetSolutionToMean = 2,
      30             : };
      31             : 
      32             : /// \ingroup LimitersGroup
      33             : /// \brief Scale a NewtonianEuler solution around its mean to remove pointwise
      34             : /// positivity violations.
      35             : ///
      36             : /// If the solution has points with negative density, scales the solution
      37             : /// to make these points positive again. For each component \f$u\f$ of the
      38             : /// solution, the scaling takes the form
      39             : /// \f$u \to \bar{u} + \theta (u - \bar{u})\f$,
      40             : /// where \f$\bar{u}\f$ is the cell-average value of \f$u\f$, and \f$\theta\f$
      41             : /// is a factor less than 1, chosen to restore positive density.
      42             : /// The cell averages in this implementation are computed in inertial
      43             : /// coordinates, so the flattener is conservative even on deformed grids.
      44             : ///
      45             : /// A scaling of this form used to restore positivity is usually called a
      46             : /// flattener (we use this name) or a bounds-preserving filter. Note that the
      47             : /// scaling approach only works if the cell-averaged solution is itself
      48             : /// physical, in other words, if the cell-averaged density is positive.
      49             : ///
      50             : /// After checking for (and correcting) negative densities, if the equation of
      51             : /// state is two-dimensional, then the pressure is also checked for positivity.
      52             : /// If negative pressures are found, each solution component is set to its mean
      53             : /// (this is equivalent to \f$\theta = 0\f$ in the scaling form above).
      54             : /// In principle, a less aggressive scaling could be used, but solving for the
      55             : /// correct \f$\theta\f$ in this case is more involved.
      56             : template <size_t VolumeDim>
      57           1 : FlattenerAction flatten_solution(
      58             :     gsl::not_null<Scalar<DataVector>*> mass_density_cons,
      59             :     gsl::not_null<tnsr::I<DataVector, VolumeDim>*> momentum_density,
      60             :     gsl::not_null<Scalar<DataVector>*> energy_density,
      61             :     const Mesh<VolumeDim>& mesh,
      62             :     const Scalar<DataVector>& det_logical_to_inertial_jacobian,
      63             :     const EquationsOfState::EquationOfState<false, 2>& equation_of_state);
      64             : 
      65             : }  // namespace NewtonianEuler::Limiters