Line data    Source code

       1           1 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : /// \file
       5             : /// Defines class ExcisionSphere.
       6             : 
       7             : #pragma once
       8             : 
       9             : #include <cstddef>
      10             : #include <iosfwd>
      11             : #include <limits>
      12             : #include <memory>
      13             : #include <optional>
      14             : #include <unordered_map>
      15             : 
      16             : #include "DataStructures/Tensor/Tensor.hpp"
      17             : #include "Domain/CoordinateMaps/CoordinateMap.hpp"
      18             : #include "Domain/Structure/Direction.hpp"
      19             : #include "Domain/Structure/ElementId.hpp"
      20             : 
      21             : /// \cond
      22             : namespace Frame {
      23             : struct Grid;
      24             : struct Inertial;
      25             : }  // namespace Frame
      26             : namespace PUP {
      27             : class er;
      28             : }  // namespace PUP
      29             : /// \endcond
      30             : 
      31             : /// \ingroup ComputationalDomainGroup
      32             : /// The excision sphere information of a computational domain.
      33             : /// The excision sphere is assumed to be a coordinate sphere in the
      34             : /// grid frame.
      35             : ///
      36             : /// \tparam VolumeDim the volume dimension.
      37             : template <size_t VolumeDim>
      38           1 : class ExcisionSphere {
      39             :  public:
      40             :   /// Constructor
      41             :   ///
      42             :   /// \param radius the radius of the excision sphere in the
      43             :   /// computational domain.
      44             :   /// \param center the coordinate center of the excision sphere
      45             :   /// in the computational domain.
      46             :   /// \param abutting_directions the set of blocks that touch the excision
      47             :   /// sphere, along with the direction in which they touch it.
      48           1 :   ExcisionSphere(
      49             :       double radius, tnsr::I<double, VolumeDim, Frame::Grid> center,
      50             :       std::unordered_map<size_t, Direction<VolumeDim>> abutting_directions);
      51             : 
      52             :   /// Default constructor needed for Charm++ serialization.
      53           1 :   ExcisionSphere() = default;
      54           0 :   ~ExcisionSphere() = default;
      55           0 :   ExcisionSphere(const ExcisionSphere<VolumeDim>& /*rhs*/);
      56           0 :   ExcisionSphere(ExcisionSphere<VolumeDim>&& /*rhs*/) = default;
      57           0 :   ExcisionSphere<VolumeDim>& operator=(
      58             :       const ExcisionSphere<VolumeDim>& /*rhs*/);
      59           0 :   ExcisionSphere<VolumeDim>& operator=(ExcisionSphere<VolumeDim>&& /*rhs*/) =
      60             :       default;
      61             : 
      62             :   /// \brief Add time dependent coordinate maps to the ExcisionSphere
      63             :   ///
      64             :   /// \note There is no actual mesh that is inside an excision sphere, but this
      65             :   /// region moves along with the domain just the same. Meaning that we
      66             :   /// should be able to take a point inside the excision sphere and map it to
      67             :   /// the Inertial frame.
      68           1 :   void inject_time_dependent_maps(
      69             :       std::unique_ptr<
      70             :           domain::CoordinateMapBase<Frame::Grid, Frame::Inertial, VolumeDim>>
      71             :           moving_mesh_grid_to_inertial_map);
      72             : 
      73             :   /// \brief The map going from the last time independent frame to the frame in
      74             :   /// which the equations are solved. Only used when `is_time_dependent()` is
      75             :   /// true.
      76             :   const domain::CoordinateMapBase<Frame::Grid, Frame::Inertial, VolumeDim>&
      77           1 :   moving_mesh_grid_to_inertial_map() const;
      78             : 
      79             :   /// \brief Return whether or not time dependent maps have been injected
      80           1 :   bool is_time_dependent() const { return grid_to_inertial_map_ != nullptr; }
      81             : 
      82             :   /// The radius of the ExcisionSphere.
      83           1 :   double radius() const { return radius_; }
      84             : 
      85             :   /// The coordinate center of the ExcisionSphere.
      86           1 :   const tnsr::I<double, VolumeDim, Frame::Grid>& center() const {
      87             :     return center_;
      88             :   }
      89             : 
      90             :   /// The set of blocks that touch the excision sphere, along with the direction
      91             :   /// in which they touch it
      92           1 :   const std::unordered_map<size_t, Direction<VolumeDim>>& abutting_directions()
      93             :       const {
      94             :     return abutting_directions_;
      95             :   }
      96             :   /// Checks whether an element abuts the excision sphere. If it does, returns
      97             :   /// the corresponding direction. Else, `nullopt` is returned.
      98           1 :   std::optional<Direction<VolumeDim>> abutting_direction(
      99             :       const ElementId<VolumeDim>& element_id) const;
     100             : 
     101             :   // NOLINTNEXTLINE(google-runtime-references)
     102           0 :   void pup(PUP::er& p);
     103             : 
     104             :  private:
     105             :   template <size_t LocalVolumeDim>
     106             :   // NOLINTNEXTLINE(readability-redundant-declaration)
     107           0 :   friend bool operator==(const ExcisionSphere<LocalVolumeDim>& lhs,
     108             :                          const ExcisionSphere<LocalVolumeDim>& rhs);
     109             : 
     110           0 :   double radius_{std::numeric_limits<double>::signaling_NaN()};
     111           0 :   tnsr::I<double, VolumeDim, Frame::Grid> center_{
     112             :       std::numeric_limits<double>::signaling_NaN()};
     113           0 :   std::unordered_map<size_t, Direction<VolumeDim>> abutting_directions_{};
     114             :   std::unique_ptr<
     115             :       domain::CoordinateMapBase<Frame::Grid, Frame::Inertial, VolumeDim>>
     116           0 :       grid_to_inertial_map_{};
     117             : };
     118             : 
     119             : template <size_t VolumeDim>
     120           0 : std::ostream& operator<<(std::ostream& os,
     121             :                          const ExcisionSphere<VolumeDim>& excision_sphere);
     122             : 
     123             : template <size_t VolumeDim>
     124           0 : bool operator!=(const ExcisionSphere<VolumeDim>& lhs,
     125             :                 const ExcisionSphere<VolumeDim>& rhs);