Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <boost/rational.hpp>
       7              : #include <cstddef>
       8              : #include <vector>
       9              : 
      10              : #include "DataStructures/DataBox/DataBox.hpp"
      11              : #include "Domain/Amr/Helpers.hpp"
      12              : #include "Domain/Structure/ElementId.hpp"
      13              : #include "IO/Logging/Tags.hpp"
      14              : #include "IO/Logging/Verbosity.hpp"
      15              : #include "Parallel/AlgorithmExecution.hpp"
      16              : #include "Parallel/ArrayCollection/IsDgElementCollection.hpp"
      17              : #include "Parallel/GetSection.hpp"
      18              : #include "Parallel/GlobalCache.hpp"
      19              : #include "Parallel/Printf/Printf.hpp"
      20              : #include "Parallel/Reduction.hpp"
      21              : #include "ParallelAlgorithms/Amr/Actions/Component.hpp"
      22              : #include "ParallelAlgorithms/Amr/Actions/RunAmrDiagnostics.hpp"
      23              : #include "ParallelAlgorithms/Amr/Tags.hpp"
      24              : #include "Utilities/GetOutput.hpp"
      25              : #include "Utilities/Serialization/PupBoost.hpp"
      26              : #include "Utilities/StdHelpers.hpp"
      27              : 
      28              : namespace amr::Actions {
      29              : 
      30              : /// \brief Send AMR diagnostics about Element%s to amr::Component
      31              : ///
      32              : /// Sends the following:
      33              : /// - The fraction of a Block volume (in the logical coordinate frame) covered
      34              : ///   by the Element
      35              : /// - One, in order to count the number of Element%s
      36              : /// - The number of grid points
      37              : /// - The refinement level in each logical dimension
      38              : /// - The number of grid points in each logical dimension
      39              : ///
      40              : /// The information is sent to amr::Component which runs the action
      41              : /// amr::Actions::RunAmrDiagnostics after all Element%s have contributed to the
      42              : /// reduction
      43            1 : struct SendAmrDiagnostics {
      44            0 :   using const_global_cache_tags =
      45              :       tmpl::list<logging::Tags::Verbosity<amr::OptionTags::AmrGroup>>;
      46              : 
      47            0 :   using ReductionData = Parallel::ReductionData<
      48              :       // Grid index
      49              :       Parallel::ReductionDatum<size_t, funcl::AssertEqual<>>,
      50              :       // fraction of Block volume
      51              :       Parallel::ReductionDatum<boost::rational<size_t>, funcl::Plus<>>,
      52              :       // number of elements
      53              :       Parallel::ReductionDatum<size_t, funcl::Plus<>>,
      54              :       // number of grid points
      55              :       Parallel::ReductionDatum<size_t, funcl::Plus<>>,
      56              :       // average refinement level by dimension
      57              :       Parallel::ReductionDatum<
      58              :           std::vector<double>, funcl::ElementWise<funcl::Plus<>>,
      59              :           funcl::ElementWise<funcl::Divides<>>, std::index_sequence<2>>,
      60              :       // average number of grid points by dimension
      61              :       Parallel::ReductionDatum<
      62              :           std::vector<double>, funcl::ElementWise<funcl::Plus<>>,
      63              :           funcl::ElementWise<funcl::Divides<>>, std::index_sequence<2>>>;
      64              : 
      65              :   template <typename DbTagList, typename... InboxTags, typename Metavariables,
      66              :             size_t Dim, typename ActionList, typename ParallelComponent>
      67            0 :   static Parallel::iterable_action_return_t apply(
      68              :       db::DataBox<DbTagList>& box,
      69              :       tuples::TaggedTuple<InboxTags...>& /*inboxes*/,
      70              :       const Parallel::GlobalCache<Metavariables>& cache,
      71              :       const ElementId<Dim>& element_id, const ActionList /*meta*/,
      72              :       const ParallelComponent* /*meta*/) {
      73              :     if constexpr (Parallel::is_dg_element_collection_v<ParallelComponent>) {
      74              :       ERROR("Reductions are not yet implemented for nodegroup arrays.");
      75              :     } else {
      76              :       const auto& mesh = db::get<::domain::Tags::Mesh<Dim>>(box);
      77              :       const auto& my_proxy =
      78              :           Parallel::get_parallel_component<ParallelComponent>(
      79              :               cache)[element_id];
      80              :       const auto& target_proxy =
      81              :           Parallel::get_parallel_component<amr::Component<Metavariables>>(
      82              :               cache);
      83              :       std::vector<double> refinement_levels_by_dim(Dim);
      84              :       std::vector<double> extents_by_dim(Dim);
      85              :       const auto refinement_levels = element_id.refinement_levels();
      86              :       for (size_t d = 0; d < Dim; ++d) {
      87              :         refinement_levels_by_dim[d] = gsl::at(refinement_levels, d);
      88              :         extents_by_dim[d] = mesh.extents(d);
      89              :       }
      90              :       if (db::get<logging::Tags::Verbosity<amr::OptionTags::AmrGroup>>(box) >=
      91              :           Verbosity::Debug) {
      92              :         Parallel::printf("%s h-refinement %s, p-refinement %s\n",
      93              :                          get_output(element_id), get_output(refinement_levels),
      94              :                          get_output(mesh.extents()));
      95              :         if constexpr (Metavariables::amr::keep_coarse_grids) {
      96              :           const auto& parent_id = db::get<amr::Tags::ParentId<Dim>>(box);
      97              :           const auto& child_ids = db::get<amr::Tags::ChildIds<Dim>>(box);
      98              :           Parallel::printf("%s parent %s, children %s\n",
      99              :                            get_output(element_id), get_output(parent_id),
     100              :                            get_output(child_ids));
     101              :         }
     102              :       }
     103              :       auto& grid_index_section = Parallel::get_section<
     104              :           ParallelComponent,
     105              :           tmpl::conditional_t<Metavariables::amr::keep_coarse_grids,
     106              :                               amr::Tags::GridIndex, void>>(make_not_null(&box));
     107              :       Parallel::contribute_to_reduction<amr::Actions::RunAmrDiagnostics>(
     108              :           ReductionData{element_id.grid_index(),
     109              :                         amr::fraction_of_block_volume(element_id), 1,
     110              :                         mesh.number_of_grid_points(), refinement_levels_by_dim,
     111              :                         extents_by_dim},
     112              :           my_proxy, target_proxy, make_not_null(&grid_index_section));
     113              :     }
     114              :     return {Parallel::AlgorithmExecution::Continue, std::nullopt};
     115              :   }
     116              : };
     117              : }  // namespace amr::Actions