Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <limits>
       7             : #include <pup.h>
       8             : #include <string>
       9             : 
      10             : #include "DataStructures/DataVector.hpp"
      11             : #include "DataStructures/Tensor/Tensor.hpp"
      12             : #include "Options/String.hpp"
      13             : #include "PointwiseFunctions/ScalarTensor/ScalarGaussBonnet/CouplingFunctions/CouplingFunction.hpp"
      14             : #include "Utilities/Gsl.hpp"
      15             : #include "Utilities/Serialization/CharmPupable.hpp"
      16             : #include "Utilities/TMPL.hpp"
      17             : 
      18             : namespace ScalarTensor::sgb::CouplingFunctions {
      19             : 
      20             : /*!
      21             :  * \brief Coupling function of exponential type.
      22             :  *
      23             :  * \details The functional form of this coupling is
      24             :  * \f$F[\Psi] = \lambda e^{\gamma \Psi}\f$, where both \f$\lambda\f$ and
      25             :  * \f$\gamma\f$ are dimensionless.
      26             :  *
      27             :  * In the case of exponential coupling the theory does not admit the Kerr metric
      28             :  * as a stationary solution, and spontaneous scalarization cannot take place.
      29             :  * For this type of coupling the theory is also referred to as
      30             :  * _Einstein-dilaton-Gauss-Bonnet_.
      31             :  */
      32           1 : class Exponential : public CouplingFunction {
      33             :  public:
      34           0 :   static constexpr Options::String help = {
      35             :       "Coupling function of exponential type"};
      36             : 
      37           0 :   struct Lambda {
      38           0 :     using type = double;
      39           0 :     static constexpr Options::String help = {
      40             :         "The numerical dimensionless coefficient in front of the exponential"};
      41           0 :     static std::string name() { return "lambda"; }
      42             :   };
      43             : 
      44           0 :   struct Gamma {
      45           0 :     using type = double;
      46           0 :     static constexpr Options::String help = {
      47             :         "The numerical dimensionless coefficient in the exponent"};
      48           0 :     static std::string name() { return "gamma"; }
      49             :   };
      50             : 
      51           0 :   using options = tmpl::list<Lambda, Gamma>;
      52             : 
      53           0 :   Exponential() = default;
      54           0 :   Exponential(double lambda, double gamma);
      55           0 :   Exponential(const Exponential&) = default;
      56           0 :   Exponential& operator=(const Exponential&) = default;
      57           0 :   Exponential(Exponential&&) = default;
      58           0 :   Exponential& operator=(Exponential&&) = default;
      59           0 :   ~Exponential() override = default;
      60             : 
      61           0 :   explicit Exponential(CkMigrateMessage* m) : CouplingFunction(m) {}
      62           0 :   WRAPPED_PUPable_decl_template(Exponential);
      63           0 :   void pup(PUP::er& p) override;
      64             : 
      65           0 :   double get_lambda() const { return lambda_; }
      66           0 :   double get_gamma() const { return gamma_; }
      67             : 
      68             :  protected:
      69             :   /*!
      70             :    * \brief Specialization of the function that evaluates the coupling function
      71             :    * on a scalar field profile.
      72             :    *
      73             :    * It returns the profile \f$F[\Psi] = \lambda e^{- \gamma \Psi}\f$.
      74             :    */
      75           1 :   void coupling_function_impl(
      76             :       gsl::not_null<Scalar<DataVector>*> function_values,
      77             :       const Scalar<DataVector>& scalar_field) const override;
      78             : 
      79             :   /*!
      80             :    * \brief Specialization of the function that evaluates the first functional
      81             :    * derivative of the coupling function on a scalar field profile.
      82             :    *
      83             :    * It returns the profile
      84             :    * \f$\frac{\delta F[\Psi]}{\delta \Psi}
      85             :    * = - \gamma \lambda e^{- \gamma \Psi}\f$.
      86             :    */
      87           1 :   void coupling_function_prime_impl(
      88             :       gsl::not_null<Scalar<DataVector>*> function_values,
      89             :       const Scalar<DataVector>& scalar_field) const override;
      90             : 
      91             :   /*!
      92             :    * \brief Specialization of the function that evaluates the second functional
      93             :    * derivative of the coupling function on a scalar field profile.
      94             :    *
      95             :    * It returns the profile
      96             :    * \f$\frac{\delta^2 F[\Psi]}{\delta \Psi^2}
      97             :    * = \gamma^2 \lambda e^{- \gamma \Psi}\f$.
      98             :    */
      99           1 :   void coupling_function_prime_prime_impl(
     100             :       gsl::not_null<Scalar<DataVector>*> function_values,
     101             :       const Scalar<DataVector>& scalar_field) const override;
     102             : 
     103             :  private:
     104             :   /*!
     105             :    * \brief Coupling constant \f$\lambda\f$, appearing as a global factor in
     106             :    * the coupling function.
     107             :    */
     108           1 :   double lambda_{std::numeric_limits<double>::signaling_NaN()};
     109             : 
     110             :   /*!
     111             :    * \brief Coupling constant \f$\gamma\f$, appearing in the exponent of
     112             :    * the coupling function.
     113             :    */
     114           1 :   double gamma_{std::numeric_limits<double>::signaling_NaN()};
     115             : };
     116             : 
     117             : }  // namespace ScalarTensor::sgb::CouplingFunctions