Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <type_traits>
       7             : 
       8             : #include "DataStructures/DataBox/DataBox.hpp"
       9             : #include "DataStructures/Tensor/TypeAliases.hpp"
      10             : #include "Utilities/TMPL.hpp"
      11             : 
      12             : /// \cond
      13             : struct DataVector;
      14             : /// \endcond
      15             : 
      16           1 : namespace intrp::protocols {
      17             : /*!
      18             :  * \brief A protocol for the type alias `compute_target_points` found in an
      19             :  * InterpolationTargetTag.
      20             :  *
      21             :  * \details A struct conforming to the `ComputeTargetPoints` protocol must have
      22             :  *
      23             :  * - a type alias `is_sequential` that is either `std::true_type` or
      24             :  *   `std::false_type` which indicates if interpolations depend on previous
      25             :  *   interpolations' results. It is assumed in the interpolation framework that
      26             :  *   only horizon finds are sequential (e.y. anything that uses the
      27             :  *   `intrp::Interpolator` component is a sequential horizon find).
      28             :  *
      29             :  * - a type alias `frame` that denotes the frame the target points are computed
      30             :  *   in
      31             :  *
      32             :  * - a function `points` with signature matching the one in the example that
      33             :  *   will compute the points in the given `frame` (with or without the `const &`
      34             :  *   on the box argument).
      35             :  *
      36             :  * A struct that conforms to this protocol can optionally have any of these
      37             :  * members as well:
      38             :  *
      39             :  * - a type alias `simple_tags` that list simple tags to be added to the DataBox
      40             :  *   of the InterpolationTarget
      41             :  *
      42             :  * - a type alias `compute_tags` that list compute tags to be added to the
      43             :  *   DataBox of the InterpolationTarget
      44             :  *
      45             :  * - a type alias `const_global_cache_tags` with tags to be put in the
      46             :  *   GlobalCache
      47             :  *
      48             :  * - a function `initialize` with signature matching the one in the example that
      49             :  *   is run during the Initialization phase of the InterpolationTarget and can
      50             :  *   initialize any of the `simple_tags` added.
      51             :  *
      52             :  * Here is an example of a class that conforms to this protocols:
      53             :  *
      54             :  * \snippet Helpers/ParallelAlgorithms/Interpolation/Examples.hpp ComputeTargetPoints
      55             :  */
      56           1 : struct ComputeTargetPoints {
      57             :   template <typename ConformingType>
      58           0 :   struct test {
      59             :     struct DummyMetavariables;
      60           0 :     struct DummyTag : db::SimpleTag {
      61           0 :       using type = int;
      62             :     };
      63             : 
      64           0 :     using is_sequential = typename ConformingType::is_sequential;
      65             :     static_assert(std::is_same_v<is_sequential, std::true_type> or
      66             :                   std::is_same_v<is_sequential, std::false_type>);
      67             : 
      68           0 :     using frame = typename ConformingType::frame;
      69             :     // We don't check the initialize() function because it is optional
      70             :   };
      71             : };
      72             : }  // namespace intrp::protocols