Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <array>
       7              : #include <string>
       8              : 
       9              : #include "Options/String.hpp"
      10              : #include "Utilities/TMPL.hpp"
      11              : 
      12              : /// \cond
      13              : namespace PUP {
      14              : class er;
      15              : }  // namespace PUP
      16              : /// \endcond
      17              : 
      18              : namespace gh::gauges {
      19              : /*!
      20              :  * \brief A struct holding the parameters for initializing damped harmonic gauge
      21              :  *
      22              :  * If UseRollon is true, the gauge transitions ("rolls on") to damped
      23              :  * harmonic from the initial data gauge; otherwise, the gauge begins
      24              :  * immediately in damped harmonic gauge.
      25              :  */
      26              : template <bool UseRollon>
      27            1 : struct DhGaugeParameters;
      28              : 
      29              : /// \cond
      30              : template <>
      31              : struct DhGaugeParameters<true> {
      32              :   double rollon_start;
      33              :   double rollon_window;
      34              :   double spatial_decay_width;
      35              :   std::array<double, 3> amplitudes;
      36              :   std::array<int, 3> exponents;
      37              : 
      38              :   static constexpr Options::String help{
      39              :       "A struct holding the parameters for initializing damped harmonic "
      40              :       "gauge, including a roll-on from the initial gauge."};
      41              : 
      42              :   /// The rollon start time
      43              :   struct RollOnStartTime {
      44              :     using type = double;
      45              :     static constexpr Options::String help{
      46              :         "Simulation time to start rolling on the damped harmonic gauge"};
      47              :   };
      48              : 
      49              :   /// The width of the Gaussian for the gauge rollon
      50              :   struct RollOnTimeWindow {
      51              :     using type = double;
      52              :     static constexpr Options::String help{
      53              :         "The width of the Gaussian that controls how quickly the gauge is "
      54              :         "rolled on."};
      55              :   };
      56              : 
      57              :   /// The width of the Gaussian for the spatial decay of the damped harmonic
      58              :   /// gauge.
      59              :   struct SpatialDecayWidth {
      60              :     using type = double;
      61              :     static constexpr Options::String help{
      62              :         "Spatial width of weight function used in the damped harmonic "
      63              :         "gauge."};
      64              :   };
      65              : 
      66              :   /// The amplitudes for the L1, L2, and S terms, respectively, for the damped
      67              :   /// harmonic gauge.
      68              :   struct Amplitudes {
      69              :     using type = std::array<double, 3>;
      70              :     static constexpr Options::String help{
      71              :         "Amplitudes [AL1, AL2, AS] for the damped harmonic gauge."};
      72              :   };
      73              : 
      74              :   /// The exponents for the L1, L2, and S terms, respectively, for the damped
      75              :   /// harmonic gauge.
      76              :   struct Exponents {
      77              :     using type = std::array<int, 3>;
      78              :     static constexpr Options::String help{
      79              :         "Exponents [eL1, eL2, eS] for the damped harmonic gauge."};
      80              :   };
      81              : 
      82              :   using options = tmpl::list<RollOnStartTime, RollOnTimeWindow,
      83              :                              SpatialDecayWidth, Amplitudes, Exponents>;
      84              : 
      85              :   DhGaugeParameters(double start, double window, double width,
      86              :                     const std::array<double, 3>& amps,
      87              :                     const std::array<int, 3>& exps);
      88              : 
      89              :   DhGaugeParameters() = default;
      90              : 
      91              :   // NOLINTNEXTLINE(google-runtime-references)
      92              :   void pup(PUP::er& p);
      93              : };
      94              : 
      95              : template <>
      96              : struct DhGaugeParameters<false> {
      97              :   double spatial_decay_width;
      98              :   std::array<double, 3> amplitudes;
      99              :   std::array<int, 3> exponents;
     100              : 
     101              :   static constexpr Options::String help{
     102              :       "A struct holding the parameters for initializing damped harmonic "
     103              :       "gauge with no roll-on from the initial gauge."};
     104              : 
     105              :   /// The width of the Gaussian for the spatial decay of the damped harmonic
     106              :   /// gauge.
     107              :   struct SpatialDecayWidth {
     108              :     using type = double;
     109              :     static constexpr Options::String help{
     110              :         "Spatial width of weight function used in the damped harmonic "
     111              :         "gauge."};
     112              :   };
     113              : 
     114              :   /// The amplitudes for the L1, L2, and S terms, respectively, for the damped
     115              :   /// harmonic gauge.
     116              :   struct Amplitudes {
     117              :     using type = std::array<double, 3>;
     118              :     static constexpr Options::String help{
     119              :         "Amplitudes [AL1, AL2, AS] for the damped harmonic gauge."};
     120              :   };
     121              : 
     122              :   /// The exponents for the L1, L2, and S terms, respectively, for the damped
     123              :   /// harmonic gauge.
     124              :   struct Exponents {
     125              :     using type = std::array<int, 3>;
     126              :     static constexpr Options::String help{
     127              :         "Exponents [eL1, eL2, eS] for the damped harmonic gauge."};
     128              :   };
     129              : 
     130              :   using options = tmpl::list<SpatialDecayWidth, Amplitudes, Exponents>;
     131              : 
     132              :   DhGaugeParameters(double width, const std::array<double, 3>& amps,
     133              :                     const std::array<int, 3>& exps);
     134              : 
     135              :   DhGaugeParameters() = default;
     136              : 
     137              :   // NOLINTNEXTLINE(google-runtime-references)
     138              :   void pup(PUP::er& p);
     139              : };
     140              : /// \endcond
     141              : }  // namespace gh::gauges