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 "Parallel/Protocols/ElementRegistrar.hpp"
       9             : #include "Parallel/Protocols/RegistrationMetavariables.hpp"
      10             : #include "Utilities/ErrorHandling/Error.hpp"
      11             : #include "Utilities/ProtocolHelpers.hpp"
      12             : #include "Utilities/TMPL.hpp"
      13             : #include "Utilities/TypeTraits/CreateHasTypeAlias.hpp"
      14             : 
      15             : /// \cond
      16             : namespace db {
      17             : template <typename DbTagList>
      18             : class DataBox;
      19             : }  // namespace db
      20             : namespace Parallel {
      21             : template <typename Metavariables>
      22             : class GlobalCache;
      23             : }  // namespace Parallel
      24             : /// \endcond
      25             : 
      26             : namespace Parallel {
      27             : namespace detail {
      28             : CREATE_HAS_TYPE_ALIAS(registration)
      29             : CREATE_HAS_TYPE_ALIAS_V(registration)
      30             : }  // namespace detail
      31             : 
      32             : /// @{
      33             : /// \brief (De)register an array element for specified actions
      34             : ///
      35             : /// \details Array elements are (de)registered with actions on components that
      36             : /// need to know which elements are contributing data before the action can be
      37             : /// executed.  If array elements are migrated (e.g. during load balancing),
      38             : /// or are created/destroyed (e.g. during adaptive mesh refinement), these
      39             : /// functions must be called in order to (un)register (old) new elements.
      40             : /// The list of registration actions is obtained from
      41             : /// `Metavariables::registration::element_registrars`.
      42             : ///
      43             : /// \see Parallel::protocols::RegistrationMetavariables
      44             : /// \see Parallel::protocols::ElementRegistrar
      45             : template <typename ParallelComponent, typename DbTagList,
      46             :           typename Metavariables, typename ArrayIndex>
      47           1 : void deregister_element(db::DataBox<DbTagList>& box,
      48             :                         Parallel::GlobalCache<Metavariables>& cache,
      49             :                         const ArrayIndex& array_index) {
      50             :   if constexpr (detail::has_registration_v<Metavariables>) {
      51             :     static_assert(tt::assert_conforms_to_v<
      52             :                   typename Metavariables::registration,
      53             :                   Parallel::protocols::RegistrationMetavariables>);
      54             :     using element_registrars =
      55             :         typename Metavariables::registration::element_registrars;
      56             :     if constexpr (tmpl::has_key<element_registrars, ParallelComponent>::value) {
      57             :       tmpl::for_each<tmpl::at<element_registrars, ParallelComponent>>(
      58             :           [&box, &cache, &array_index](auto registration_v) {
      59             :             using registration = typename decltype(registration_v)::type;
      60             :             static_assert(tt::assert_conforms_to_v<
      61             :                           registration, Parallel::protocols::ElementRegistrar>);
      62             :             registration::template perform_deregistration<ParallelComponent>(
      63             :                 box, cache, array_index);
      64             :           });
      65             :     }
      66             :   }
      67             : }
      68             : 
      69             : template <typename ParallelComponent, typename DbTagList,
      70             :           typename Metavariables, typename ArrayIndex>
      71           1 : void register_element(db::DataBox<DbTagList>& box,
      72             :                       Parallel::GlobalCache<Metavariables>& cache,
      73             :                       const ArrayIndex& array_index) {
      74             :   if constexpr (detail::has_registration_v<Metavariables>) {
      75             :     static_assert(tt::assert_conforms_to_v<
      76             :                   typename Metavariables::registration,
      77             :                   Parallel::protocols::RegistrationMetavariables>);
      78             :     using element_registrars =
      79             :         typename Metavariables::registration::element_registrars;
      80             :     if constexpr (tmpl::has_key<element_registrars, ParallelComponent>::value) {
      81             :       tmpl::for_each<tmpl::at<element_registrars, ParallelComponent>>(
      82             :           [&box, &cache, &array_index](auto registration_v) {
      83             :             using registration = typename decltype(registration_v)::type;
      84             :             static_assert(tt::assert_conforms_to_v<
      85             :                           registration, Parallel::protocols::ElementRegistrar>);
      86             :             registration::template perform_registration<ParallelComponent>(
      87             :                 box, cache, array_index);
      88             :           });
      89             :     }
      90             :   }
      91             : }
      92             : /// @}
      93             : }  // namespace Parallel