Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <optional>
       7              : #include <tuple>
       8              : #include <utility>
       9              : 
      10              : #include "DataStructures/DataBox/DataBox.hpp"
      11              : #include "Evolution/Systems/Cce/GaugeTransformBoundaryData.hpp"
      12              : #include "Evolution/Systems/Cce/OptionTags.hpp"
      13              : #include "Evolution/Systems/Cce/PreSwshDerivatives.hpp"
      14              : #include "Evolution/Systems/Cce/PrecomputeCceDependencies.hpp"
      15              : #include "Evolution/Systems/Cce/SwshDerivatives.hpp"
      16              : #include "Evolution/Systems/Cce/Tags.hpp"
      17              : #include "Parallel/AlgorithmExecution.hpp"
      18              : #include "Parallel/GlobalCache.hpp"
      19              : #include "Parallel/Invoke.hpp"
      20              : 
      21              : namespace Cce {
      22              : namespace Actions {
      23              : 
      24              : /*!
      25              :  * \ingroup ActionsGroup
      26              :  * \brief Prepare the input quantities in the \ref DataBoxGroup for the
      27              :  * evaluation of the hypersurface integral used to compute `BondiTag`.
      28              :  *
      29              :  * \details Internally this calls the
      30              :  * `mutate_all_pre_swsh_derivatives_for_tag<BondiTag>()` and
      31              :  * `mutate_all_swsh_derivatives_for_tag<BondiTag>()` utility functions, which
      32              :  * determine which quantities are necessary for each of the hypersurface
      33              :  * computations.
      34              :  */
      35              : template <typename BondiTag>
      36            1 : struct CalculateIntegrandInputsForTag {
      37              :   template <typename DbTags, typename... InboxTags, typename Metavariables,
      38              :             typename ArrayIndex, typename ActionList,
      39              :             typename ParallelComponent>
      40            0 :   static Parallel::iterable_action_return_t apply(
      41              :       db::DataBox<DbTags>& box,
      42              :       const tuples::TaggedTuple<InboxTags...>& /*inboxes*/,
      43              :       const Parallel::GlobalCache<Metavariables>& /*cache*/,
      44              :       const ArrayIndex& /*array_index*/, const ActionList /*meta*/,
      45              :       const ParallelComponent* const /*meta*/) {
      46              :     mutate_all_pre_swsh_derivatives_for_tag<BondiTag>(make_not_null(&box));
      47              :     mutate_all_swsh_derivatives_for_tag<BondiTag>(make_not_null(&box));
      48              :     return {Parallel::AlgorithmExecution::Continue, std::nullopt};
      49              :   }
      50              : };
      51              : 
      52              : /*!
      53              :  * \ingroup ActionsGroup
      54              :  * \brief Perform all of the computations for dependencies of the hypersurface
      55              :  * equations that do not themselves depend on any hypersurface integrations.
      56              :  *
      57              :  * \details This is to be called as a 'pre-computation' step prior to looping
      58              :  * over the hypersurface integration set. Internally, this uses
      59              :  * `Cce::GaugeAdjustedBoundaryValue<Tag>` and
      60              :  * `Cce::mutate_all_precompute_cce_dependencies
      61              :  * <Tags::EvolutionGaugeBoundaryValue>()`
      62              :  * to calculate the requisite dependencies.
      63              :  */
      64            1 : struct PrecomputeGlobalCceDependencies {
      65              :   template <typename... DbTags, typename... InboxTags, typename Metavariables,
      66              :             typename ArrayIndex, typename ActionList,
      67              :             typename ParallelComponent>
      68            0 :   static Parallel::iterable_action_return_t apply(
      69              :       db::DataBox<tmpl::list<DbTags...>>& box,
      70              :       const tuples::TaggedTuple<InboxTags...>& /*inboxes*/,
      71              :       const Parallel::GlobalCache<Metavariables>& /*cache*/,
      72              :       const ArrayIndex& /*array_index*/, const ActionList /*meta*/,
      73              :       const ParallelComponent* const /*meta*/) {
      74              :     tmpl::for_each<gauge_adjustments_setup_tags>([&box](auto tag_v) {
      75              :       using tag = typename decltype(tag_v)::type;
      76              :       db::mutate_apply<GaugeAdjustedBoundaryValue<tag>>(make_not_null(&box));
      77              :     });
      78              :     mutate_all_precompute_cce_dependencies<Tags::EvolutionGaugeBoundaryValue>(
      79              :         make_not_null(&box));
      80              :     return {Parallel::AlgorithmExecution::Continue, std::nullopt};
      81              :   }
      82              : };
      83              : 
      84              : }  // namespace Actions
      85              : }  // namespace Cce