Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <array>
       7             : #include <cstddef>
       8             : #include <optional>
       9             : #include <string>
      10             : #include <utility>
      11             : #include <vector>
      12             : 
      13             : #include "DataStructures/DataBox/DataBox.hpp"
      14             : #include "DataStructures/DataBox/ObservationBox.hpp"
      15             : #include "Domain/Structure/ElementId.hpp"
      16             : #include "Domain/Tags.hpp"
      17             : #include "IO/Observer/Helpers.hpp"
      18             : #include "IO/Observer/ObservationId.hpp"
      19             : #include "IO/Observer/ObserverComponent.hpp"
      20             : #include "IO/Observer/Protocols/ReductionDataFormatter.hpp"
      21             : #include "IO/Observer/ReductionActions.hpp"
      22             : #include "IO/Observer/TypeOfObservation.hpp"
      23             : #include "Options/String.hpp"
      24             : #include "Parallel/GlobalCache.hpp"
      25             : #include "Parallel/Reduction.hpp"
      26             : #include "ParallelAlgorithms/EventsAndTriggers/Event.hpp"
      27             : #include "Utilities/TMPL.hpp"
      28             : 
      29             : namespace PUP {
      30             : class er;
      31             : }  // namespace PUP
      32             : 
      33             : namespace amr::Events {
      34             : namespace detail {
      35             : using AmrStatsReductionData = Parallel::ReductionData<
      36             :     // Observation value / time
      37             :     Parallel::ReductionDatum<double, funcl::AssertEqual<>>,
      38             :     // Total number of elements
      39             :     Parallel::ReductionDatum<size_t, funcl::Plus<>>,
      40             :     // Total number of grid points
      41             :     Parallel::ReductionDatum<size_t, funcl::Plus<>>,
      42             :     // Number of grid points per dimension: total, min, max
      43             :     Parallel::ReductionDatum<std::vector<size_t>,
      44             :                              funcl::ElementWise<funcl::Plus<>>>,
      45             :     Parallel::ReductionDatum<std::vector<size_t>,
      46             :                              funcl::ElementWise<funcl::Min<>>>,
      47             :     Parallel::ReductionDatum<std::vector<size_t>,
      48             :                              funcl::ElementWise<funcl::Max<>>>>;
      49             : 
      50             : struct FormatAmrStatsOutput
      51             :     : tt::ConformsTo<observers::protocols::ReductionDataFormatter> {
      52             :   using reduction_data = AmrStatsReductionData;
      53             :   std::string operator()(double time, size_t total_num_elements,
      54             :                          size_t total_num_points,
      55             :                          const std::vector<size_t>& num_points_per_dim,
      56             :                          const std::vector<size_t>& min_points_per_dim,
      57             :                          const std::vector<size_t>& max_points_per_dim) const;
      58             :   // NOLINTNEXTLINE
      59             :   void pup(PUP::er& p);
      60             : };
      61             : }  // namespace detail
      62             : 
      63             : /*!
      64             :  * \ingroup AmrGroup
      65             :  * \brief Observes AMR statistics, such as number of elements and grid points
      66             :  */
      67             : template <size_t Dim>
      68           1 : class ObserveAmrStats : public Event {
      69             :  public:
      70           0 :   struct PrintToTerminal {
      71           0 :     using type = bool;
      72           0 :     static constexpr Options::String help = {
      73             :         "Whether to print reduction info to terminal."};
      74             :   };
      75           0 :   struct ObservePerCore {
      76           0 :     using type = bool;
      77           0 :     static constexpr Options::String help = {
      78             :         "Also write reduction observations per-core in a file per-node."};
      79             :   };
      80             : 
      81             :   /// \cond
      82             :   explicit ObserveAmrStats(CkMigrateMessage* m);
      83             :   using PUP::able::register_constructor;
      84             :   WRAPPED_PUPable_decl_template(ObserveAmrStats);  // NOLINT
      85             :   /// \endcond
      86             : 
      87           0 :   using options = tmpl::list<PrintToTerminal, ObservePerCore>;
      88           0 :   static constexpr Options::String help = {"Observe AMR statistics"};
      89             : 
      90           0 :   ObserveAmrStats();
      91           0 :   ObserveAmrStats(bool print_to_terminal, bool observe_per_core);
      92             : 
      93           0 :   using observed_reduction_data_tags = observers::make_reduction_data_tags<
      94             :       tmpl::list<detail::AmrStatsReductionData>>;
      95             : 
      96           0 :   using compute_tags_for_observation_box = tmpl::list<>;
      97           0 :   using argument_tags = tmpl::list<domain::Tags::Mesh<Dim>>;
      98           0 :   using return_tags = tmpl::list<>;
      99             : 
     100             :   template <typename Metavariables, typename ParallelComponent>
     101           0 :   void operator()(const Mesh<Dim>& mesh,
     102             :                   Parallel::GlobalCache<Metavariables>& cache,
     103             :                   const ElementId<Dim>& element_id,
     104             :                   const ParallelComponent* const /*meta*/,
     105             :                   const ObservationValue& observation_value) const {
     106             :     const auto& mesh_extents = mesh.extents();
     107             :     const std::vector<size_t> mesh_extents_vec{mesh_extents.begin(),
     108             :                                                mesh_extents.end()};
     109             :     detail::AmrStatsReductionData reduction_data{observation_value.value,
     110             :                                                  1_st,
     111             :                                                  mesh.number_of_grid_points(),
     112             :                                                  mesh_extents_vec,
     113             :                                                  mesh_extents_vec,
     114             :                                                  mesh_extents_vec};
     115             :     std::vector<std::string> legend{observation_value.name, "NumElements",
     116             :                                     "TotalNumPoints"};
     117             :     std::vector<std::string> legend_num_p;
     118             :     std::vector<std::string> legend_min_p;
     119             :     std::vector<std::string> legend_max_p;
     120             :     legend_num_p.reserve(Dim);
     121             :     legend_min_p.reserve(Dim);
     122             :     legend_max_p.reserve(Dim);
     123             :     for (size_t d = 0; d < Dim; ++d) {
     124             :       legend_num_p.push_back("NumPointsPerDim_" + std::to_string(d));
     125             :       legend_min_p.push_back("MinPointsPerDim_" + std::to_string(d));
     126             :       legend_max_p.push_back("MaxPointsPerDim_" + std::to_string(d));
     127             :     }
     128             :     legend.insert(legend.end(), legend_num_p.begin(), legend_num_p.end());
     129             :     legend.insert(legend.end(), legend_min_p.begin(), legend_min_p.end());
     130             :     legend.insert(legend.end(), legend_max_p.begin(), legend_max_p.end());
     131             : 
     132             :     auto& local_observer = *Parallel::local_branch(
     133             :         Parallel::get_parallel_component<
     134             :             tmpl::conditional_t<Parallel::is_nodegroup_v<ParallelComponent>,
     135             :                                 observers::ObserverWriter<Metavariables>,
     136             :                                 observers::Observer<Metavariables>>>(cache));
     137             :     observers::ObservationId observation_id{observation_value.value,
     138             :                                             subfile_path_ + ".dat"};
     139             :     Parallel::ArrayComponentId array_component_id{
     140             :         std::add_pointer_t<ParallelComponent>{nullptr},
     141             :         Parallel::ArrayIndex<ElementId<Dim>>(element_id)};
     142             :     auto formatter = print_to_terminal_
     143             :                          ? std::make_optional(detail::FormatAmrStatsOutput{})
     144             :                          : std::nullopt;
     145             :     if constexpr (Parallel::is_nodegroup_v<ParallelComponent>) {
     146             :       const std::optional<int> observe_with_core_id =
     147             :           observe_per_core_
     148             :               ? std::make_optional(Parallel::my_node<int>(local_observer))
     149             :               : std::nullopt;
     150             :       Parallel::threaded_action<
     151             :           observers::ThreadedActions::CollectReductionDataOnNode>(
     152             :           local_observer, std::move(observation_id),
     153             :           std::move(array_component_id), subfile_path_, std::move(legend),
     154             :           std::move(reduction_data), std::move(formatter),
     155             :           observe_with_core_id);
     156             :     } else {
     157             :       Parallel::simple_action<observers::Actions::ContributeReductionData>(
     158             :           local_observer, std::move(observation_id),
     159             :           std::move(array_component_id), subfile_path_, std::move(legend),
     160             :           std::move(reduction_data), std::move(formatter), observe_per_core_);
     161             :     }
     162             :   }
     163             : 
     164           0 :   using observation_registration_tags = tmpl::list<>;
     165             : 
     166             :   std::optional<
     167             :       std::pair<observers::TypeOfObservation, observers::ObservationKey>>
     168           0 :   get_observation_type_and_key_for_registration() const {
     169             :     return {{observers::TypeOfObservation::Reduction,
     170             :              observers::ObservationKey(subfile_path_ + ".dat")}};
     171             :   }
     172             : 
     173           0 :   using is_ready_argument_tags = tmpl::list<>;
     174             : 
     175             :   template <typename Metavariables, typename ArrayIndex, typename Component>
     176           0 :   bool is_ready(Parallel::GlobalCache<Metavariables>& /*cache*/,
     177             :                 const ArrayIndex& /*array_index*/,
     178             :                 const Component* const /*meta*/) const {
     179             :     return true;
     180             :   }
     181             : 
     182           1 :   bool needs_evolved_variables() const override { return false; }
     183             : 
     184             :   // NOLINTNEXTLINE(google-runtime-references)
     185           0 :   void pup(PUP::er& p) override;
     186             : 
     187             :  private:
     188           0 :   bool print_to_terminal_{false};
     189           0 :   bool observe_per_core_{false};
     190           0 :   std::string subfile_path_{"Amr"};
     191             : };
     192             : }  // namespace amr::Events