Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <iomanip>
       7             : #include <ios>
       8             : #include <limits>
       9             : #include <sstream>
      10             : 
      11             : #include "DataStructures/DataBox/DataBox.hpp"
      12             : #include "Parallel/GlobalCache.hpp"
      13             : #include "Parallel/Printf/Printf.hpp"
      14             : #include "ParallelAlgorithms/Interpolation/Tags.hpp"
      15             : #include "Utilities/PrettyType.hpp"
      16             : #include "Utilities/TMPL.hpp"
      17             : 
      18             : namespace deadlock {
      19             : /*!
      20             :  * \brief Simple action to print deadlock info on an interpolation target.
      21             :  *
      22             :  * \details This will print the following information for all temporal ids
      23             :  * stored in `intrp::Tags::TemporalIds`.
      24             :  *
      25             :  * - `intrp::Tags::IndicesOfFilledInterpPoints`
      26             :  * - `intrp::Tags::IndicesOfInvalidInterpPoints1
      27             :  * - Size of `intrp::Tags::InterpolatedVars`
      28             :  */
      29           1 : struct PrintInterpolationTarget {
      30             :   template <typename ParallelComponent, typename DbTags, typename Metavariables,
      31             :             typename ArrayIndex>
      32           0 :   static void apply(const db::DataBox<DbTags>& box,
      33             :                     const Parallel::GlobalCache<Metavariables>& /*cache*/,
      34             :                     const ArrayIndex& /*array_index*/,
      35             :                     const std::string& file_name) {
      36             :     std::stringstream ss{};
      37             :     ss << std::setprecision(std::numeric_limits<double>::digits10 + 4)
      38             :        << std::scientific;
      39             : 
      40             :     using TargetTag = typename ParallelComponent::interpolation_target_tag;
      41             :     using TemporalId = typename TargetTag::temporal_id::type;
      42             : 
      43             :     const auto stream_points = [&](const TemporalId& temporal_id) {
      44             :       const auto& filled_indices =
      45             :           db::get<intrp::Tags::IndicesOfFilledInterpPoints<TemporalId>>(box);
      46             :       const auto& invalid_indices =
      47             :           db::get<intrp::Tags::IndicesOfInvalidInterpPoints<TemporalId>>(box);
      48             :       const auto& interpolated_vars =
      49             :           db::get<intrp::Tags::InterpolatedVars<TargetTag, TemporalId>>(box);
      50             : 
      51             :       const size_t expected_size =
      52             :           interpolated_vars.at(temporal_id).number_of_grid_points();
      53             :       const size_t filled_size = filled_indices.count(temporal_id) > 0
      54             :                                      ? filled_indices.at(temporal_id).size()
      55             :                                      : 0_st;
      56             :       const size_t invalid_size = invalid_indices.count(temporal_id) > 0
      57             :                                       ? invalid_indices.at(temporal_id).size()
      58             :                                       : 0_st;
      59             : 
      60             :       ss << "Total points expected = " << expected_size
      61             :          << ", valid points received = " << filled_size
      62             :          << ", invalid points received " << invalid_size << ". ";
      63             :     };
      64             : 
      65             :     const auto& temporal_ids =
      66             :         db::get<intrp::Tags::TemporalIds<TemporalId>>(box);
      67             : 
      68             :     if (temporal_ids.empty()) {
      69             :       ss << pretty_type::name<TargetTag>() << ", No temporal ids.";
      70             :       Parallel::printf("%s\n", ss.str());
      71             :       return;
      72             :     }
      73             : 
      74             :     ss << "========== BEGIN TARGET " << pretty_type::name<TargetTag>()
      75             :        << " ==========\n";
      76             : 
      77             :     for (const auto& temporal_id : temporal_ids) {
      78             :       ss << "Temporal id " << temporal_id << ", ";
      79             : 
      80             :       stream_points(temporal_id);
      81             : 
      82             :       ss << "\n";
      83             :     }
      84             : 
      85             :     ss << "========== END TARGET " << pretty_type::name<TargetTag>()
      86             :        << " ============\n";
      87             : 
      88             :     Parallel::fprintf(file_name, "%s\n", ss.str());
      89             :   }
      90             : };
      91             : }  // namespace deadlock