Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <string>
       7              : #include <type_traits>
       8              : 
       9              : #include "ParallelAlgorithms/Interpolation/InterpolationTargetDetail.hpp"
      10              : #include "ParallelAlgorithms/Interpolation/Protocols/ComputeTargetPoints.hpp"
      11              : #include "ParallelAlgorithms/Interpolation/Protocols/ComputeVarsToInterpolate.hpp"
      12              : #include "ParallelAlgorithms/Interpolation/Protocols/PostInterpolationCallback.hpp"
      13              : #include "Utilities/ProtocolHelpers.hpp"
      14              : 
      15              : namespace intrp::protocols {
      16              : namespace detail {
      17              : // if_alias_exists_assert_conforms_to::value will always be `true` because we
      18              : // want the static assert in the protocol to pass regardless of if the
      19              : // `compute_vars_to_interpolate` alias exists in the conforming type. It's just
      20              : // that if the alias does exist, there's an additional static assert to ensure
      21              : // that the alias conforms to the ComputeVarsToInterpolate protocol
      22              : template <typename ConformingType, bool HasAlias>
      23              : struct if_alias_exists_assert_conforms_to;
      24              : 
      25              : template <typename ConformingType>
      26              : struct if_alias_exists_assert_conforms_to<ConformingType, false> {
      27              :   static constexpr bool value = true;
      28              : };
      29              : 
      30              : template <typename ConformingType>
      31              : struct if_alias_exists_assert_conforms_to<ConformingType, true> {
      32              :   static constexpr bool value = true;
      33              :   static_assert(tt::assert_conforms_to_v<
      34              :                 typename ConformingType::compute_vars_to_interpolate,
      35              :                 ComputeVarsToInterpolate>);
      36              : };
      37              : 
      38              : template <typename ConformingType, bool HasAlias>
      39              : constexpr bool if_alias_exists_assert_conforms_to_v =
      40              :     if_alias_exists_assert_conforms_to<ConformingType, HasAlias>::value;
      41              : }  // namespace detail
      42              : 
      43              : /*!
      44              :  * \brief A protocol for `InterpolationTargetTag`s that are used in the
      45              :  * intrp::InterpolationTarget parallel component.
      46              :  *
      47              :  * \details A struct conforming to the `InterpolationTargetTag` protocol must
      48              :  * have
      49              :  *
      50              :  * - a type alias `temporal_id` to a tag that tells the interpolation target
      51              :  *   what values of time to use (for example, `::Tags::Time`).
      52              :  *
      53              :  * - a type alias `vars_to_interpolate_to_target` which is a `tmpl::list` of
      54              :  *   tags describing variables to interpolate. Will be used to construct a
      55              :  *   `Variables`.
      56              :  *
      57              :  * - a type alias `compute_items_on_target` which is a `tmpl::list` of compute
      58              :  *   items that uses `vars_to_interpolate_to_target` as input.
      59              :  *
      60              :  * - a type alias `compute_target_points` that conforms to the
      61              :  *   intrp::protocols::ComputeTargetPoints protocol. This will compute the
      62              :  *   points on the surface that we are interpolating onto.
      63              :  *
      64              :  * - a type alias `post_interpolation_callbacks` which is a `tmpl::list` where
      65              :  *   every element of that list conforms to the
      66              :  *   intrp::protocols::PostInterpolationCallback protocol. Only one callback
      67              :  *   with the signature with `gsl::not_null` for both the DataBox and
      68              :  *   GlobalCache (see `intrp::protocols::PostInterpolationCallback`) is allowed
      69              :  *   in this list. Furthermore, if a callback with this signature is in the
      70              :  *   list, it must also be the *only* callback in the list. After the
      71              :  *   interpolation is complete, call this struct's `apply` function.
      72              :  *
      73              :  * A struct conforming to this protocol can also optionally have
      74              :  *
      75              :  * - a type alias `compute_vars_to_interpolate` that conforms to the
      76              :  *   intrp::protocols::ComputeVarsToInterpolate protocol. This is a struct that
      77              :  *   computes quantities in the volume that are required to compute different
      78              :  *   quantities on the surface we are interpolating to.
      79              :  *
      80              :  * - a type alias `interpolating_component` to the parallel component that will
      81              :  *   be interpolating to the interpolation target. Only needed when *not* using
      82              :  *   the Interpolator ParallelComponent.
      83              :  *
      84              :  * An example of a struct that conforms to this protocol is
      85              :  *
      86              :  * \snippet Helpers/ParallelAlgorithms/Interpolation/Examples.hpp InterpolationTargetTag
      87              :  */
      88            1 : struct InterpolationTargetTag {
      89              :   template <typename ConformingType>
      90            0 :   struct test {
      91            0 :     using temporal_id = typename ConformingType::temporal_id;
      92              : 
      93            0 :     using vars_to_interpolate_to_target =
      94              :         typename ConformingType::vars_to_interpolate_to_target;
      95              : 
      96              :     // If the conforming type has a `compute_vars_to_interpolate` alias, make
      97              :     // sure it conforms to the ComputeVarsToInterpolate protocol, otherwise just
      98              :     // return true
      99              :     static_assert(detail::if_alias_exists_assert_conforms_to_v<
     100              :                   ConformingType,
     101              :                   InterpolationTarget_detail::has_compute_vars_to_interpolate_v<
     102              :                       ConformingType>>);
     103              : 
     104            0 :     using compute_items_on_target =
     105              :         typename ConformingType::compute_items_on_target;
     106              : 
     107            0 :     using compute_target_points =
     108              :         typename ConformingType::compute_target_points;
     109              :     static_assert(
     110              :         tt::assert_conforms_to_v<compute_target_points, ComputeTargetPoints>);
     111              : 
     112            0 :     using post_interpolation_callbacks =
     113              :         typename ConformingType::post_interpolation_callbacks;
     114              :     static_assert(tmpl::all<post_interpolation_callbacks,
     115              :                             tt::assert_conforms_to<
     116              :                                 tmpl::_1, PostInterpolationCallback>>::value);
     117              :   };
     118              : };
     119              : }  // namespace intrp::protocols