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