Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <cstddef>
       7             : #include <optional>
       8             : #include <string>
       9             : #include <tuple>
      10             : #include <type_traits>
      11             : #include <utility>
      12             : #include <vector>
      13             : 
      14             : #include "IO/Observer/Helpers.hpp"
      15             : #include "IO/Observer/ObservationId.hpp"
      16             : #include "IO/Observer/ObserverComponent.hpp"
      17             : #include "IO/Observer/Protocols/ReductionDataFormatter.hpp"
      18             : #include "IO/Observer/ReductionActions.hpp"
      19             : #include "IO/Observer/TypeOfObservation.hpp"
      20             : #include "Options/String.hpp"
      21             : #include "Parallel/ArrayComponentId.hpp"
      22             : #include "Parallel/ArrayIndex.hpp"
      23             : #include "Parallel/GlobalCache.hpp"
      24             : #include "Parallel/Info.hpp"
      25             : #include "Parallel/Invoke.hpp"
      26             : #include "Parallel/Local.hpp"
      27             : #include "Parallel/Reduction.hpp"
      28             : #include "Parallel/TypeTraits.hpp"
      29             : #include "ParallelAlgorithms/EventsAndTriggers/Event.hpp"
      30             : #include "Utilities/Functional.hpp"
      31             : #include "Utilities/ProtocolHelpers.hpp"
      32             : #include "Utilities/Serialization/CharmPupable.hpp"
      33             : #include "Utilities/TMPL.hpp"
      34             : 
      35             : /// \cond
      36             : class TimeDelta;
      37             : namespace PUP {
      38             : class er;
      39             : }  // namespace PUP
      40             : namespace Tags {
      41             : struct TimeStep;
      42             : }  // namespace Tags
      43             : /// \endcond
      44             : 
      45             : namespace Events {
      46             : namespace detail {
      47             : using ObserveTimeStepReductionData = Parallel::ReductionData<
      48             :     Parallel::ReductionDatum<double, funcl::AssertEqual<>>,
      49             :     Parallel::ReductionDatum<size_t, funcl::Plus<>>,
      50             :     Parallel::ReductionDatum<double, funcl::AssertEqual<>>,
      51             :     Parallel::ReductionDatum<double, funcl::Min<>>,
      52             :     Parallel::ReductionDatum<double, funcl::Max<>>,
      53             :     Parallel::ReductionDatum<
      54             :         double, funcl::Plus<>,
      55             :         funcl::Divides<funcl::Literal<1, double>, funcl::Divides<>>,
      56             :         std::index_sequence<1>>,
      57             :     Parallel::ReductionDatum<double, funcl::Min<>>,
      58             :     Parallel::ReductionDatum<double, funcl::Max<>>>;
      59             : 
      60             : struct FormatTimeOutput
      61             :     : tt::ConformsTo<observers::protocols::ReductionDataFormatter> {
      62             :   using reduction_data = ObserveTimeStepReductionData;
      63             :   std::string operator()(double time, size_t num_degrees_of_freedom,
      64             :                          double slab_size, double min_time_step,
      65             :                          double max_time_step, double effective_time_step,
      66             :                          double min_wall_time, double max_wall_time) const;
      67             :   // NOLINTNEXTLINE
      68             :   void pup(PUP::er& p);
      69             : };
      70             : }  // namespace detail
      71             : 
      72             : /*!
      73             :  * \brief %Observe the size of the time steps.
      74             :  *
      75             :  * Writes reduction quantities:
      76             :  * - `%Time`
      77             :  * - `Number of degrees of freedom`
      78             :  * - `%Slab size`
      79             :  * - `Minimum time step`
      80             :  * - `Maximum time step`
      81             :  * - `Effective time step`
      82             :  *
      83             :  * The effective time step is the step size of a global-time-stepping
      84             :  * method that would perform a similar amount of work.  This is the
      85             :  * harmonic mean of the step size over all degrees of freedom:
      86             :  *
      87             :  * \f{equation}
      88             :  * (\Delta t)_{\text{eff}}^{-1} =
      89             :  * \frac{\sum_{i \in \text{dof}} (\Delta t)_i^{-1}}{N_{\text{dof}}}.
      90             :  * \f}
      91             :  *
      92             :  * This corresponds to averaging the number of steps per unit time
      93             :  * taken by all points.
      94             :  *
      95             :  * All values are reported as positive numbers, even for backwards
      96             :  * evolutions.
      97             :  */
      98             : /// @{
      99             : template <typename System,
     100             :           typename = tmpl::conditional_t<
     101             :               tt::is_a_v<tmpl::list, typename System::variables_tag>,
     102             :               typename System::variables_tag,
     103             :               tmpl::list<typename System::variables_tag>>>
     104           1 : class ObserveTimeStep;
     105             : 
     106             : template <typename System, typename... VariablesTags>
     107           0 : class ObserveTimeStep<System, tmpl::list<VariablesTags...>> : public Event {
     108             :  private:
     109           0 :   using ReductionData = Events::detail::ObserveTimeStepReductionData;
     110             : 
     111             :  public:
     112             :   /// The name of the subfile inside the HDF5 file
     113           1 :   struct SubfileName {
     114           0 :     using type = std::string;
     115           0 :     static constexpr Options::String help = {
     116             :         "The name of the subfile inside the HDF5 file without an extension and "
     117             :         "without a preceding '/'."};
     118             :   };
     119             : 
     120           0 :   struct PrintTimeToTerminal {
     121           0 :     using type = bool;
     122           0 :     static constexpr Options::String help = {
     123             :         "Whether to print the time to screen."};
     124             :   };
     125             : 
     126           0 :   struct ObservePerCore {
     127           0 :     using type = bool;
     128           0 :     static constexpr Options::String help = {
     129             :         "Also write the data per-core in a file per-node."};
     130             :   };
     131             : 
     132             :   /// \cond
     133             :   explicit ObserveTimeStep(CkMigrateMessage* /*m*/);
     134             :   using PUP::able::register_constructor;
     135             :   WRAPPED_PUPable_decl_template(ObserveTimeStep);  // NOLINT
     136             :   /// \endcond
     137             : 
     138           0 :   using options = tmpl::list<SubfileName, PrintTimeToTerminal, ObservePerCore>;
     139           0 :   static constexpr Options::String help =
     140             :       "Observe the size of the time steps.\n"
     141             :       "\n"
     142             :       "Writes reduction quantities:\n"
     143             :       "- Time\n"
     144             :       "- Number of degrees of freedom\n"
     145             :       "- Slab size\n"
     146             :       "- Minimum time step\n"
     147             :       "- Maximum time step\n"
     148             :       "- Effective time step\n"
     149             :       "\n"
     150             :       "The effective time step is the step size of a global-time-stepping\n"
     151             :       "method that would perform a similar amount of work.\n"
     152             :       "\n"
     153             :       "All values are reported as positive numbers, even for backwards\n"
     154             :       "evolutions.";
     155             : 
     156           0 :   ObserveTimeStep();
     157           0 :   ObserveTimeStep(const std::string& subfile_name, bool output_time,
     158             :                   bool observe_per_core);
     159             : 
     160           0 :   using observed_reduction_data_tags =
     161             :       observers::make_reduction_data_tags<tmpl::list<ReductionData>>;
     162             : 
     163           0 :   using compute_tags_for_observation_box = tmpl::list<>;
     164             : 
     165           0 :   using return_tags = tmpl::list<>;
     166             :   // We obtain the grid size from the variables, rather than the mesh,
     167             :   // so that this observer is not DG-specific.
     168           0 :   using argument_tags = tmpl::list<::Tags::TimeStep, VariablesTags...>;
     169             : 
     170             :   template <typename ArrayIndex, typename ParallelComponent,
     171             :             typename Metavariables>
     172           0 :   void operator()(const TimeDelta& time_step,
     173             :                   const typename VariablesTags::type&... variables,
     174             :                   Parallel::GlobalCache<Metavariables>& cache,
     175             :                   const ArrayIndex& array_index,
     176             :                   const ParallelComponent* const /*meta*/,
     177             :                   const ObservationValue& observation_value) const {
     178             :     auto [observation_id, legend, reduction_data, formatter] =
     179             :         assemble_data(time_step, variables..., observation_value);
     180             : 
     181             :     auto& local_observer = *Parallel::local_branch(
     182             :         Parallel::get_parallel_component<
     183             :             tmpl::conditional_t<Parallel::is_nodegroup_v<ParallelComponent>,
     184             :                                 observers::ObserverWriter<Metavariables>,
     185             :                                 observers::Observer<Metavariables>>>(cache));
     186             : 
     187             :     Parallel::ArrayComponentId array_component_id{
     188             :         std::add_pointer_t<ParallelComponent>{nullptr},
     189             :         Parallel::ArrayIndex<ArrayIndex>(array_index)};
     190             : 
     191             :     if constexpr (Parallel::is_nodegroup_v<ParallelComponent>) {
     192             :       const std::optional<int> observe_with_core_id =
     193             :           observe_per_core_
     194             :               ? std::make_optional(Parallel::my_node<int>(local_observer))
     195             :               : std::nullopt;
     196             :       Parallel::threaded_action<
     197             :           observers::ThreadedActions::CollectReductionDataOnNode>(
     198             :           local_observer, std::move(observation_id),
     199             :           std::move(array_component_id), subfile_path_, std::move(legend),
     200             :           std::move(reduction_data), std::move(formatter),
     201             :           observe_with_core_id);
     202             :     } else {
     203             :       Parallel::simple_action<observers::Actions::ContributeReductionData>(
     204             :           local_observer, std::move(observation_id),
     205             :           std::move(array_component_id), subfile_path_, std::move(legend),
     206             :           std::move(reduction_data), std::move(formatter), observe_per_core_);
     207             :     }
     208             :   }
     209             : 
     210           0 :   using observation_registration_tags = tmpl::list<>;
     211             :   std::pair<observers::TypeOfObservation, observers::ObservationKey>
     212           0 :   get_observation_type_and_key_for_registration() const;
     213             : 
     214           0 :   using is_ready_argument_tags = tmpl::list<>;
     215             : 
     216             :   template <typename Metavariables, typename ArrayIndex, typename Component>
     217           0 :   bool is_ready(Parallel::GlobalCache<Metavariables>& /*cache*/,
     218             :                 const ArrayIndex& /*array_index*/,
     219             :                 const Component* const /*meta*/) const {
     220             :     return true;
     221             :   }
     222             : 
     223           1 :   bool needs_evolved_variables() const override;
     224             : 
     225             :   // NOLINTNEXTLINE(google-runtime-references)
     226           0 :   void pup(PUP::er& p) override;
     227             : 
     228             :  private:
     229           0 :   auto assemble_data(const TimeDelta& time_step,
     230             :                      const typename VariablesTags::type&... variables,
     231             :                      const ObservationValue& observation_value) const
     232             :       -> std::tuple<observers::ObservationId, std::vector<std::string>,
     233             :                     ReductionData,
     234             :                     std::optional<Events::detail::FormatTimeOutput>>;
     235             : 
     236           0 :   std::string subfile_path_;
     237           0 :   bool output_time_;
     238           0 :   bool observe_per_core_;
     239             : };
     240             : /// @}
     241             : }  // namespace Events