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 <string>
       8             : #include <vector>
       9             : 
      10             : #include "DataStructures/ComplexDataVector.hpp"
      11             : #include "DataStructures/DataVector.hpp"
      12             : #include "DataStructures/Tensor/TypeAliases.hpp"
      13             : #include "Domain/Tags.hpp"
      14             : #include "Elliptic/BoundaryConditions/BoundaryCondition.hpp"
      15             : #include "Elliptic/BoundaryConditions/BoundaryConditionType.hpp"
      16             : #include "Options/String.hpp"
      17             : #include "Utilities/Gsl.hpp"
      18             : #include "Utilities/TMPL.hpp"
      19             : 
      20           0 : namespace GrSelfForce::BoundaryConditions {
      21             : 
      22             : /*!
      23             :  * \brief Angular boundary conditions for the m-mode metric perturbations.
      24             :  *
      25             :  * The angular boundary conditions are determined by enforcing regularity of
      26             :  * the metric perturbation at the poles $\theta=0,\pi$:
      27             :  * \begin{align}
      28             :  *   &\Psi_{m=1}^{0,1,4,7,8,9} = 0 \\
      29             :  *   &\partial_\theta \Psi_{m=1}^{2,3,5,6} = 0 \\
      30             :  *   &\Psi_{m=2}^{0,1,2,3,4,5,6} = 0 \\
      31             :  *   &\partial_\theta \Psi_{m=2}^{7,8,9} = 0 \\
      32             :  *   &\Psi_{m>2} = 0 \\
      33             :  * \end{align}
      34             :  * The ordering of components in $\Psi$ here is:
      35             :  * $\{tt,tr,t\theta,t\phi,rr,r\theta,r\phi,\theta\theta,\theta\phi,\phi\phi\}$.
      36             :  */
      37           1 : class Angular : public elliptic::BoundaryConditions::BoundaryCondition<2> {
      38             :  private:
      39           0 :   using Base = elliptic::BoundaryConditions::BoundaryCondition<2>;
      40           0 :   using GradTensorType =
      41             :       TensorMetafunctions::prepend_spatial_index<tnsr::aa<ComplexDataVector, 3>,
      42             :                                                  2, UpLo::Lo, Frame::Inertial>;
      43             : 
      44             :  public:
      45           0 :   struct MModeNumber {
      46           0 :     static constexpr Options::String help =
      47             :         "Mode number 'm' of the metric perturbation";
      48           0 :     using type = int;
      49             :   };
      50             : 
      51           0 :   static constexpr Options::String help = "Angular boundary condition";
      52           0 :   using options = tmpl::list<MModeNumber>;
      53             : 
      54           0 :   Angular() = default;
      55           0 :   Angular(const Angular&) = default;
      56           0 :   Angular& operator=(const Angular&) = default;
      57           0 :   Angular(Angular&&) = default;
      58           0 :   Angular& operator=(Angular&&) = default;
      59           0 :   ~Angular() override = default;
      60             : 
      61           0 :   explicit Angular(int m_mode_number);
      62             : 
      63           0 :   int m_mode_number() const { return m_mode_number_; }
      64             : 
      65             :   /// \cond
      66             :   explicit Angular(CkMigrateMessage* m);
      67             :   using PUP::able::register_constructor;
      68             :   WRAPPED_PUPable_decl_template(Angular);
      69             :   /// \endcond
      70             : 
      71           0 :   std::unique_ptr<domain::BoundaryConditions::BoundaryCondition> get_clone()
      72             :       const override {
      73             :     return std::make_unique<Angular>(*this);
      74             :   }
      75             : 
      76           0 :   std::vector<elliptic::BoundaryConditionType> boundary_condition_types()
      77             :       const override {
      78             :     // For m > 0 some tensor components are Neumann-type and others Dirichlet.
      79             :     // The boundary condition type is currently only used for the
      80             :     // `MinusLaplacian` subdomain preconditioner, so its effectiveness will be
      81             :     // lower unless we extend this function to return a type for each tensor
      82             :     // component.
      83             :     return {m_mode_number_ == 0 ? elliptic::BoundaryConditionType::Neumann
      84             :                                 : elliptic::BoundaryConditionType::Dirichlet};
      85             :   }
      86             : 
      87           0 :   using argument_tags = tmpl::list<>;
      88           0 :   using volume_tags = tmpl::list<>;
      89             : 
      90           0 :   void apply(
      91             :       gsl::not_null<tnsr::aa<ComplexDataVector, 3>*> field,
      92             :       gsl::not_null<tnsr::aa<ComplexDataVector, 3>*> n_dot_field_gradient,
      93             :       const GradTensorType& deriv_field) const;
      94             : 
      95           0 :   using argument_tags_linearized = tmpl::list<>;
      96           0 :   using volume_tags_linearized = tmpl::list<>;
      97             : 
      98           0 :   void apply_linearized(
      99             :       gsl::not_null<tnsr::aa<ComplexDataVector, 3>*> field_correction,
     100             :       gsl::not_null<tnsr::aa<ComplexDataVector, 3>*>
     101             :           n_dot_field_correction_gradient,
     102             :       const GradTensorType& deriv_field_correction) const;
     103             : 
     104             :   // NOLINTNEXTLINE
     105           0 :   void pup(PUP::er& p) override;
     106             : 
     107             :  private:
     108           0 :   friend bool operator==(const Angular& lhs, const Angular& rhs);
     109             : 
     110           0 :   int m_mode_number_{};
     111             : };
     112             : 
     113           0 : bool operator!=(const Angular& lhs, const Angular& rhs);
     114             : 
     115             : }  // namespace GrSelfForce::BoundaryConditions