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 <optional>
       9             : #include <string>
      10             : #include <type_traits>
      11             : #include <unordered_map>
      12             : #include <unordered_set>
      13             : 
      14             : #include "DataStructures/DataBox/PrefixHelpers.hpp"
      15             : #include "DataStructures/DataBox/Tag.hpp"
      16             : #include "DataStructures/TaggedTuple.hpp"
      17             : #include "DataStructures/Variables.hpp"
      18             : #include "IO/Logging/Tags.hpp"
      19             : #include "IO/Logging/Verbosity.hpp"
      20             : #include "NumericalAlgorithms/Spectral/Mesh.hpp"
      21             : #include "Options/String.hpp"
      22             : 
      23             : /// \cond
      24             : template <size_t VolumeDim>
      25             : class ElementId;
      26             : /// \endcond
      27             : 
      28             : namespace intrp {
      29             : 
      30           0 : namespace OptionTags {
      31             : /*!
      32             :  * \ingroup OptionGroupsGroup
      33             :  * \brief Groups option tags for InterpolationTargets.
      34             :  */
      35           1 : struct InterpolationTargets {
      36           0 :   static constexpr Options::String help{"Options for interpolation targets"};
      37             : };
      38             : 
      39             : /*!
      40             :  * \ingroup OptionGroupsGroup
      41             :  * \brief Groups option tags for the Interpolator.
      42             :  */
      43           1 : struct Interpolator {
      44           0 :   static constexpr Options::String help{
      45             :       "Options related to the Interpolator parallel component"};
      46             : };
      47             : }  // namespace OptionTags
      48             : 
      49             : /// Tags for items held in the `DataBox` of `InterpolationTarget` or
      50             : /// `Interpolator`.
      51             : namespace Tags {
      52             : /// Tag that determines the verbosity of output from the interpolation target
      53           1 : struct Verbosity : db::SimpleTag {
      54           0 :   using type = ::Verbosity;
      55             : 
      56           0 :   using option_tags =
      57             :       tmpl::list<logging::OptionTags::Verbosity<OptionTags::Interpolator>>;
      58           0 :   static constexpr bool pass_metavariables = false;
      59           0 :   static ::Verbosity create_from_options(const ::Verbosity& verbosity) {
      60             :     return verbosity;
      61             :   }
      62             : };
      63             : 
      64             : /// Keeps track of which points have been filled with interpolated data.
      65             : template <typename TemporalId>
      66           1 : struct IndicesOfFilledInterpPoints : db::SimpleTag {
      67           0 :   using type = std::unordered_map<TemporalId, std::unordered_set<size_t>>;
      68             : };
      69             : 
      70             : /// Keeps track of points that cannot be filled with interpolated data.
      71             : ///
      72             : /// The InterpolationTarget can decide what to do with these points.
      73             : /// In most cases the correct action is to throw an error, but in other
      74             : /// cases one might wish to fill these points with a default value or
      75             : /// take some other action.
      76             : template <typename TemporalId>
      77           1 : struct IndicesOfInvalidInterpPoints : db::SimpleTag {
      78           0 :   using type = std::unordered_map<TemporalId, std::unordered_set<size_t>>;
      79             : };
      80             : 
      81             : /// `temporal_id`s on which to interpolate.
      82             : ///
      83             : /// \note This tag is only used in non-sequential targets
      84             : template <typename TemporalId>
      85           1 : struct TemporalIds : db::SimpleTag {
      86           0 :   using type = std::unordered_set<TemporalId>;
      87             : };
      88             : 
      89             : /// `temporal_id`s that we have already interpolated onto.
      90             : ///  This is used to prevent problems with multiple late calls.
      91             : template <typename TemporalId>
      92           1 : struct CompletedTemporalIds : db::SimpleTag {
      93           0 :   using type = std::deque<TemporalId>;
      94             : };
      95             : 
      96             : /// Holds interpolated variables on an InterpolationTarget.
      97             : template <typename InterpolationTargetTag, typename TemporalId>
      98           1 : struct InterpolatedVars : db::SimpleTag {
      99           0 :   using type = std::unordered_map<
     100             :       TemporalId,
     101             :       Variables<
     102             :           typename InterpolationTargetTag::vars_to_interpolate_to_target>>;
     103             : };
     104             : }  // namespace Tags
     105             : }  // namespace intrp