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              : 
       8              : #include "DataStructures/DataBox/DataBox.hpp"
       9              : #include "Domain/FunctionsOfTime/OutputTimeBounds.hpp"
      10              : #include "Domain/FunctionsOfTime/Tags.hpp"
      11              : #include "Parallel/GlobalCache.hpp"
      12              : #include "Parallel/Info.hpp"
      13              : #include "Parallel/ParallelComponentHelpers.hpp"
      14              : #include "Parallel/Printf/Printf.hpp"
      15              : 
      16              : namespace control_system::Tags {
      17              : struct MeasurementTimescales;
      18              : }  // namespace control_system::Tags
      19              : 
      20              : namespace deadlock {
      21              : /*!
      22              :  * \brief Simple action that will print the `domain::Tags::FunctionsOfTime` and
      23              :  * `control_system::Tags::MeasurementTimescales` (if it exists) time bounds for
      24              :  * each node of a simulation.
      25              :  */
      26            1 : struct PrintFunctionsOfTime {
      27              :   template <typename ParallelComponent, typename DbTags, typename Metavariables,
      28              :             typename ArrayIndex>
      29            0 :   static void apply(db::DataBox<DbTags>& /*box*/,
      30              :                     Parallel::GlobalCache<Metavariables>& cache,
      31              :                     const ArrayIndex& /*array_index*/,
      32              :                     const std::string& file_name) {
      33              :     const auto& functions_of_time =
      34              :         Parallel::get<::domain::Tags::FunctionsOfTime>(cache);
      35              :     const std::string time_bounds =
      36              :         ::domain::FunctionsOfTime::output_time_bounds(functions_of_time);
      37              : 
      38              :     if constexpr (Parallel::is_in_global_cache<
      39              :                       Metavariables,
      40              :                       control_system::Tags::MeasurementTimescales>) {
      41              :       const auto& measurement_timescales =
      42              :           Parallel::get<control_system::Tags::MeasurementTimescales>(cache);
      43              :       const std::string measurement_time_bounds =
      44              :           ::domain::FunctionsOfTime::output_time_bounds(measurement_timescales);
      45              : 
      46              :       Parallel::fprintf(
      47              :           file_name,
      48              :           "Node %zu\nFunctionsOfTime:\n%s\n\nMeasurementTimescales:\n%s\n",
      49              :           Parallel::my_node<size_t>(cache), time_bounds,
      50              :           measurement_time_bounds);
      51              :     } else {
      52              :       Parallel::fprintf(file_name, "Node %zu\nFunctionsOfTime:%s\n",
      53              :                         Parallel::my_node<size_t>(cache), time_bounds);
      54              :     }
      55              :   }
      56              : };
      57              : }  // namespace deadlock