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 <optional>
       9             : #include <pup.h>
      10             : #include <utility>
      11             : #include <vector>
      12             : 
      13             : #include "DataStructures/DataBox/Prefixes.hpp"
      14             : #include "DataStructures/Tensor/Tensor.hpp"
      15             : #include "PointwiseFunctions/GeneralRelativity/Tags.hpp"
      16             : #include "PointwiseFunctions/Hydro/Tags.hpp"
      17             : #include "Utilities/Serialization/CharmPupable.hpp"
      18             : #include "Utilities/TMPL.hpp"
      19             : #include "Utilities/TaggedTuple.hpp"
      20             : 
      21           0 : namespace ray_tracing {
      22             : 
      23             : /*!
      24             :  * \brief Abstract base class for background spacetimes in the ray tracer.
      25             :  *
      26             :  * Derived classes have to provide spacetime quantities at a given point on
      27             :  * request, e.g. by evaluating an analytic spacetime or by interpolating numeric
      28             :  * data from a file. The `initialize` function can be used to set up the
      29             :  * background spacetime, e.g. by reading data from a file. Then, the background
      30             :  * spacetime should be valid within the bounds returned by the `time_bounds`
      31             :  * function.
      32             :  */
      33           1 : class BackgroundSpacetime : public PUP::able {
      34             :  protected:
      35           0 :   static constexpr size_t Dim = 3;
      36           0 :   using DataType = double;
      37           0 :   using Frame = ::Frame::Inertial;
      38           0 :   using DerivLapse =
      39             :       ::Tags::deriv<gr::Tags::Lapse<DataType>, tmpl::size_t<Dim>, Frame>;
      40           0 :   using DerivShift =
      41             :       ::Tags::deriv<gr::Tags::Shift<DataType, Dim>, tmpl::size_t<Dim>, Frame>;
      42           0 :   using DerivInvSpatialMetric =
      43             :       ::Tags::deriv<gr::Tags::InverseSpatialMetric<DataType, Dim, Frame>,
      44             :                     tmpl::size_t<Dim>, Frame>;
      45           0 :   using DerivSpatialMetric =
      46             :       ::Tags::deriv<gr::Tags::SpatialMetric<DataType, Dim, Frame>,
      47             :                     tmpl::size_t<Dim>, Frame>;
      48             : 
      49           0 :   BackgroundSpacetime() = default;
      50             : 
      51             :  public:
      52           0 :   ~BackgroundSpacetime() override = default;
      53             : 
      54             :   /// \cond
      55             :   explicit BackgroundSpacetime(CkMigrateMessage* msg) : PUP::able(msg) {}
      56             :   WRAPPED_PUPable_abstract(BackgroundSpacetime);
      57             :   /// \endcond
      58             : 
      59             :   /// Copies the background spacetime. Must call `initialize` on the clone
      60             :   /// before using it.
      61           1 :   virtual auto get_clone() const -> std::unique_ptr<BackgroundSpacetime> = 0;
      62             : 
      63             :   /*!
      64             :    * \brief Initialize the background spacetime, e.g. by reading data from a
      65             :    * file.
      66             :    *
      67             :    * This function is called before the first call to `variables()`. It is
      68             :    * valid to call `initialize` again with new time bounds. Derived classes
      69             :    * must guarantee that the `variables` function can be called from other
      70             :    * threads while `initialize` is running (e.g. loading new data from files),
      71             :    * but only with times within the overlap of the previous and the new time
      72             :    * bounds.
      73             :    *
      74             :    * \param time_bounds The time bounds for which to initialize the
      75             :    * background spacetime. The spacetime should be valid for all times in this
      76             :    * range.
      77             :    */
      78           1 :   virtual void initialize(
      79             :       [[maybe_unused]] const std::array<double, 2> time_bounds) {}
      80             : 
      81             :   /// Time bounds for which the background spacetime is valid. The `variables`
      82             :   /// function can be called for any time in this range (inclusive).
      83           1 :   virtual std::array<double, 2> time_bounds() const {
      84             :     return {-std::numeric_limits<double>::infinity(),
      85             :             std::numeric_limits<double>::infinity()};
      86             :   }
      87             : 
      88             :   /// These tags can be retrieved from the background spacetime. They are
      89             :   /// required to evaluate the `gr::geodesic_equation`.
      90           1 :   using tags = tmpl::list<gr::Tags::Lapse<DataType>, DerivLapse,
      91             :                           gr::Tags::Shift<DataType, Dim, Frame>, DerivShift,
      92             :                           gr::Tags::InverseSpatialMetric<DataType, Dim, Frame>,
      93             :                           DerivInvSpatialMetric,
      94             :                           gr::Tags::ExtrinsicCurvature<DataType, Dim, Frame>>;
      95             : 
      96             :   /*!
      97             :    * \brief Returns all spacetime variables at a given point in space and time.
      98             :    *
      99             :    * This function must be thread-safe.
     100             :    *
     101             :    * \param x Spatial coordinates
     102             :    * \param t Time
     103             :    * \param block_order Optional priority order for processing blocks during
     104             :    * interpolation. If specified, it will be updated to push the block in which
     105             :    * the point was found to the front. Can be empty, in which case it will be
     106             :    * initially set to the default order. See `block_logical_coordinates` for
     107             :    * more details.
     108             :    */
     109           1 :   virtual tuples::tagged_tuple_from_typelist<tags> variables(
     110             :       const tnsr::I<DataType, Dim, Frame>& x, double t,
     111             :       std::optional<gsl::not_null<std::vector<size_t>*>> block_order =
     112             :           std::nullopt) const = 0;
     113             : };
     114             : 
     115             : }  // namespace ray_tracing