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 <limits>
       8              : #include <string>
       9              : #include <vector>
      10              : 
      11              : #include "Options/Context.hpp"
      12              : #include "Options/String.hpp"
      13              : #include "Utilities/TMPL.hpp"
      14              : 
      15              : /// \cond
      16              : namespace PUP {
      17              : class er;
      18              : }  // namespace PUP
      19              : /// \endcond
      20              : 
      21              : namespace grmhd::ValenciaDivClean {
      22              : 
      23              : /// Options to be passed to the Con2Prim algorithm.
      24              : /// Currently, we simply set a threshold for tildeD
      25              : /// below which the inversion is not performed and
      26              : /// the density is set to atmosphere values.
      27            1 : class PrimitiveFromConservativeOptions {
      28              :  public:
      29            0 :   struct CutoffDForInversion {
      30            0 :     static std::string name() { return "CutoffDForInversion"; }
      31            0 :     static constexpr Options::String help{
      32              :         "Value of density times Lorentz factor below which we skip "
      33              :         "conservative to primitive inversion."};
      34            0 :     using type = double;
      35            0 :     static type lower_bound() { return 0.0; }
      36              :   };
      37              : 
      38            0 :   struct DensityWhenSkippingInversion {
      39            0 :     static std::string name() { return "DensityWhenSkippingInversion"; }
      40            0 :     static constexpr Options::String help{
      41              :         "Value of density when we skip conservative to primitive inversion."};
      42            0 :     using type = double;
      43            0 :     static type lower_bound() { return 0.0; }
      44              :   };
      45              : 
      46            0 :   struct KastaunMaxLorentzFactor {
      47            0 :     static constexpr Options::String help{
      48              :         "The maximum Lorentz allowed during primitive recovery when using the "
      49              :         "Kastaun schemes."};
      50            0 :     using type = double;
      51            0 :     static type lower_bound() { return 1.0; }
      52              :   };
      53              : 
      54            0 :   using options = tmpl::list<CutoffDForInversion, DensityWhenSkippingInversion,
      55              :                              KastaunMaxLorentzFactor>;
      56              : 
      57            0 :   static constexpr Options::String help{
      58              :       "Options given to conservative to primitive inversion."};
      59              : 
      60            0 :   PrimitiveFromConservativeOptions() = default;
      61              : 
      62            0 :   PrimitiveFromConservativeOptions(double cutoff_d_for_inversion,
      63              :                                    double density_when_skipping_inversion,
      64              :                                    double kastaun_max_lorentz_factor,
      65              :                                    const Options::Context& context = {});
      66              : 
      67            0 :   void pup(PUP::er& p);
      68              : 
      69            0 :   double cutoff_d_for_inversion() const { return cutoff_d_for_inversion_; }
      70            0 :   double density_when_skipping_inversion() const {
      71              :     return density_when_skipping_inversion_;
      72              :   }
      73            0 :   double kastaun_max_lorentz_factor() const {
      74              :     return kastaun_max_lorentz_factor_;
      75              :   }
      76              : 
      77              :  private:
      78            0 :   friend bool operator==(const PrimitiveFromConservativeOptions& lhs,
      79              :                          const PrimitiveFromConservativeOptions& rhs);
      80              : 
      81            0 :   double cutoff_d_for_inversion_ = std::numeric_limits<double>::signaling_NaN();
      82            0 :   double density_when_skipping_inversion_ =
      83              :       std::numeric_limits<double>::signaling_NaN();
      84            0 :   double kastaun_max_lorentz_factor_ =
      85              :       std::numeric_limits<double>::signaling_NaN();
      86              : };
      87              : 
      88            0 : bool operator!=(const PrimitiveFromConservativeOptions& lhs,
      89              :                 const PrimitiveFromConservativeOptions& rhs);
      90              : 
      91              : }  // namespace grmhd::ValenciaDivClean