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 <memory>
       8              : #include <string>
       9              : 
      10              : #include "DataStructures/SpinWeighted.hpp"
      11              : #include "DataStructures/Tensor/TypeAliases.hpp"
      12              : #include "Evolution/Systems/Cce/Initialize/InitializeJ.hpp"
      13              : #include "Utilities/Gsl.hpp"
      14              : #include "Utilities/Serialization/CharmPupable.hpp"
      15              : #include "Utilities/TMPL.hpp"
      16              : 
      17              : /// \cond
      18              : class ComplexDataVector;
      19              : /// \endcond
      20              : 
      21              : namespace Cce {
      22              : namespace InitializeJ {
      23              : 
      24              : /*!
      25              :  * \brief Initialize \f$J\f$ on the first hypersurface to be vanishing, finding
      26              :  * the appropriate angular coordinates to be continuous with the provided
      27              :  * worldtube boundary data.
      28              :  *
      29              :  * \details Internally, this performs an iterative solve for the angular
      30              :  * coordinates necessary to give rise to a vanishing gauge-transformed J on the
      31              :  * worldtube boundary. The parameters for the iterative procedure are determined
      32              :  * by options `ZeroNonSmooth::AngularCoordinateTolerance` and
      33              :  * `ZeroNonSmooth::MaxIterations`. The resulting `J` will necessarily
      34              :  * have vanishing first radial derivative, and so will typically not be smooth
      35              :  * (only continuous) with the provided Cauchy data at the worldtube boundary.
      36              :  */
      37            1 : struct ZeroNonSmooth : InitializeJ<false> {
      38            0 :   struct AngularCoordinateTolerance {
      39            0 :     using type = double;
      40            0 :     static std::string name() { return "AngularCoordTolerance"; }
      41            0 :     static constexpr Options::String help = {
      42              :         "Tolerance of initial angular coordinates for CCE"};
      43            0 :     static type lower_bound() { return 1.0e-14; }
      44            0 :     static type upper_bound() { return 1.0e-3; }
      45            0 :     static type suggested_value() { return 1.0e-10; }
      46              :   };
      47              : 
      48            0 :   struct MaxIterations {
      49            0 :     using type = size_t;
      50            0 :     static constexpr Options::String help = {
      51              :         "Number of linearized inversion iterations."};
      52            0 :     static type lower_bound() { return 10; }
      53            0 :     static type upper_bound() { return 1000; }
      54            0 :     static type suggested_value() { return 300; }
      55              :   };
      56              : 
      57            0 :   struct RequireConvergence {
      58            0 :     using type = bool;
      59            0 :     static constexpr Options::String help = {
      60              :         "If true, initialization will error if it hits MaxIterations"};
      61            0 :     static type suggested_value() { return true; }
      62              :   };
      63            0 :   using options =
      64              :       tmpl::list<AngularCoordinateTolerance, MaxIterations, RequireConvergence>;
      65              : 
      66            0 :   static constexpr Options::String help = {
      67              :       "Initialization process where J is set so Psi0 is vanishing\n"
      68              :       "(roughly a no incoming radiation condition)"};
      69              : 
      70            0 :   WRAPPED_PUPable_decl_template(ZeroNonSmooth);  // NOLINT
      71            0 :   explicit ZeroNonSmooth(CkMigrateMessage* /*unused*/) {}
      72              : 
      73            0 :   ZeroNonSmooth(double angular_coordinate_tolerance, size_t max_iterations,
      74              :                 bool require_convergence = false);
      75              : 
      76            0 :   ZeroNonSmooth() = default;
      77              : 
      78            0 :   std::unique_ptr<InitializeJ> get_clone() const override;
      79              : 
      80            0 :   void operator()(
      81              :       gsl::not_null<Scalar<SpinWeighted<ComplexDataVector, 2>>*> j,
      82              :       gsl::not_null<tnsr::i<DataVector, 3>*> cartesian_cauchy_coordinates,
      83              :       gsl::not_null<
      84              :           tnsr::i<DataVector, 2, ::Frame::Spherical<::Frame::Inertial>>*>
      85              :           angular_cauchy_coordinates,
      86              :       const Scalar<SpinWeighted<ComplexDataVector, 2>>& boundary_j,
      87              :       const Scalar<SpinWeighted<ComplexDataVector, 2>>& boundary_dr_j,
      88              :       const Scalar<SpinWeighted<ComplexDataVector, 0>>& r,
      89              :       const Scalar<SpinWeighted<ComplexDataVector, 0>>& beta, size_t l_max,
      90              :       size_t number_of_radial_points,
      91              :       gsl::not_null<Parallel::NodeLock*> hdf5_lock) const;
      92              : 
      93            0 :   void pup(PUP::er& p) override;
      94              : 
      95              :  private:
      96            0 :   double angular_coordinate_tolerance_ = 1.0e-10;
      97            0 :   size_t max_iterations_ = 300;
      98            0 :   bool require_convergence_ = false;
      99              : };
     100              : }  // namespace InitializeJ
     101              : }  // namespace Cce