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 <deque>
       8             : #include <map>
       9             : #include <memory>
      10             : #include <optional>
      11             : #include <tuple>
      12             : 
      13             : #include "DataStructures/LinkedMessageId.hpp"
      14             : #include "DataStructures/Tensor/Tensor.hpp"
      15             : #include "DataStructures/Tensor/TypeAliases.hpp"
      16             : #include "DataStructures/Variables.hpp"
      17             : #include "Evolution/Systems/Cce/InterfaceManagers/GhInterfaceManager.hpp"
      18             : #include "Evolution/Systems/GeneralizedHarmonic/Tags.hpp"
      19             : #include "NumericalAlgorithms/Interpolation/SpanInterpolator.hpp"
      20             : #include "Options/String.hpp"
      21             : #include "PointwiseFunctions/GeneralRelativity/Tags.hpp"
      22             : #include "Time/TimeStepId.hpp"
      23             : #include "Utilities/Serialization/CharmPupable.hpp"
      24             : #include "Utilities/Serialization/PupStlCpp17.hpp"
      25             : #include "Utilities/TMPL.hpp"
      26             : 
      27             : namespace Cce::InterfaceManagers {
      28             : 
      29             : /*!
      30             :  * \brief Implementation of a `GhInterfaceManager` that provides data according
      31             :  * to interpolation between provided GH data.
      32             :  *
      33             :  * \details This class receives data from the Generalized Harmonic system
      34             :  * sufficient to perform interpolation to arbitrary times required by CCE. From
      35             :  * the Generalized Harmonic system, it receives the spacetime metric \f$g_{a
      36             :  * b}\f$ and Generalized Harmonic \f$\Phi_{i a b}\f$ and \f$\Pi_{ab}\f$ and the
      37             :  * current time via `GhLocalTimeStepping::insert_gh_data()`. The CCE
      38             :  * system supplies requests for time steps via
      39             :  * `GhLocalTimeStepping::request_gh_data()` and receives interpolated boundary
      40             :  * data via `GhLocalTimeStepping::retrieve_and_remove_first_ready_gh_data()`.
      41             :  */
      42           1 : class GhLocalTimeStepping : public GhInterfaceManager {
      43             :  public:
      44           0 :   struct BoundaryInterpolator {
      45           0 :     using type = std::unique_ptr<intrp::SpanInterpolator>;
      46           0 :     static constexpr Options::String help = {
      47             :         "Interpolator for computing CCE data from GH time points"};
      48             :   };
      49             : 
      50           0 :   static constexpr Options::String help{
      51             :       "Interpolate data from the GH system to generate CCE inputs"};
      52             : 
      53           0 :   using options = tmpl::list<BoundaryInterpolator>;
      54             : 
      55           0 :   GhLocalTimeStepping() = default;
      56           0 :   GhLocalTimeStepping(const GhLocalTimeStepping& rhs)
      57             :       : gh_data_{rhs.gh_data_},
      58             :         requests_{rhs.requests_},
      59             :         latest_removed_{rhs.latest_removed_} {
      60             :     if (rhs.interpolator_.get() != nullptr) {
      61             :       interpolator_ = rhs.interpolator_->get_clone();
      62             :     }
      63             :   }
      64             : 
      65           0 :   explicit GhLocalTimeStepping(
      66             :       std::unique_ptr<intrp::SpanInterpolator> interpolator)
      67             :       : interpolator_{std::move(interpolator)} {}
      68           0 :   GhLocalTimeStepping& operator=(const GhLocalTimeStepping& rhs) {
      69             :     if (rhs.interpolator_.get() != nullptr) {
      70             :       interpolator_ = rhs.interpolator_->get_clone();
      71             :     }
      72             :     gh_data_ = rhs.gh_data_;
      73             :     requests_ = rhs.requests_;
      74             :     latest_removed_ = rhs.latest_removed_;
      75             :     return *this;
      76             :   }
      77             : 
      78           0 :   explicit GhLocalTimeStepping(CkMigrateMessage* /*unused*/) {}
      79             : 
      80           0 :   WRAPPED_PUPable_decl_template(GhLocalTimeStepping);  // NOLINT
      81             : 
      82           0 :   std::unique_ptr<GhInterfaceManager> get_clone() const override;
      83             : 
      84             :   /// \brief Store the provided data set to prepare for interpolation.
      85           1 :   void insert_gh_data(const LinkedMessageId<double>& time_and_previous,
      86             :                       const tnsr::aa<DataVector, 3>& spacetime_metric,
      87             :                       const tnsr::iaa<DataVector, 3>& phi,
      88             :                       const tnsr::aa<DataVector, 3>& pi);
      89             : 
      90             :   /// \brief Store the next time step that will be required by the CCE system to
      91             :   /// proceed with the evolution.
      92           1 :   void request_gh_data(const TimeStepId& time_id) override;
      93             : 
      94             :   /// \brief Return a `std::optional` of either the dense-output data at the
      95             :   /// least recently requested time, or `std::nullopt` if not enough GH data has
      96             :   /// been supplied yet.
      97           1 :   auto retrieve_and_remove_first_ready_gh_data()
      98             :       -> std::optional<std::tuple<TimeStepId, gh_variables>> override;
      99             : 
     100             :   /// The number of requests that have been submitted and not yet retrieved.
     101           1 :   size_t number_of_pending_requests() const override {
     102             :     return requests_.size();
     103             :   }
     104             : 
     105             :   /// \brief  The number of times for which data from the GH system is stored.
     106           1 :   size_t number_of_gh_times() const override { return gh_data_.size(); }
     107             : 
     108             :   /// Serialization for Charm++.
     109           1 :   void pup(PUP::er& p) override;
     110             : 
     111             :  private:
     112           0 :   void clean_up_gh_data();
     113             : 
     114             :   std::map<::LinkedMessageId<double>, gh_variables,
     115             :            LinkedMessageIdLessComparator<double>>
     116           0 :       gh_data_;
     117           0 :   std::set<TimeStepId> requests_;
     118           0 :   std::unique_ptr<intrp::SpanInterpolator> interpolator_;
     119           0 :   std::optional<double> latest_removed_ = std::nullopt;
     120             : };
     121             : }  // namespace Cce::InterfaceManagers