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 <sstream>
       8             : #include <string>
       9             : #include <vector>
      10             : 
      11             : #include "Parallel/GlobalCache.hpp"
      12             : #include "Parallel/Info.hpp"
      13             : #include "Utilities/ErrorHandling/Assert.hpp"
      14             : #include "Utilities/Numeric.hpp"
      15             : #include "Utilities/StdHelpers.hpp"
      16             : 
      17             : namespace domain {
      18             : /// Returns a `std::string` with diagnostic information about how elements and
      19             : /// grid points are distributed on the nodes and cores.
      20             : template <typename Metavariables>
      21           1 : std::string diagnostic_info(const size_t total_number_of_blocks,
      22             :                             const Parallel::GlobalCache<Metavariables>& cache,
      23             :                             const std::vector<size_t>& elements_per_core,
      24             :                             const std::vector<size_t>& elements_per_node,
      25             :                             const std::vector<size_t>& grid_points_per_core,
      26             :                             const std::vector<size_t>& grid_points_per_node) {
      27             :   const size_t total_number_of_elements =
      28             :       alg::accumulate(elements_per_node, 0_st);
      29             :   const size_t total_number_of_grid_points =
      30             :       alg::accumulate(grid_points_per_node, 0_st);
      31             :   const size_t number_of_cores = Parallel::number_of_procs<size_t>(cache);
      32             :   const size_t number_of_nodes = Parallel::number_of_nodes<size_t>(cache);
      33             : 
      34             :   // Sanity checks
      35             :   ASSERT(total_number_of_elements == alg::accumulate(elements_per_core, 0_st),
      36             :          "Number of elements determined from elements_per_core ("
      37             :              << alg::accumulate(elements_per_core, 0_st)
      38             :              << ") does not match number of elements determined from "
      39             :                 "elements_per_node ("
      40             :              << total_number_of_elements << ").");
      41             :   ASSERT(total_number_of_grid_points ==
      42             :              alg::accumulate(grid_points_per_core, 0_st),
      43             :          "Number of grid points determined from grid_points_per_core ("
      44             :              << alg::accumulate(grid_points_per_core, 0_st)
      45             :              << ") does not match number of grid points determined from "
      46             :                 "grid points_per_node ("
      47             :              << total_number_of_grid_points << ").");
      48             :   ASSERT(number_of_cores == elements_per_core.size(),
      49             :          "Number of cores determined from elements_per_core ("
      50             :              << elements_per_core.size()
      51             :              << ") does not match number of cores determined from "
      52             :                 "global cache ("
      53             :              << number_of_cores << ").");
      54             :   ASSERT(number_of_cores == grid_points_per_core.size(),
      55             :          "Number of cores determined from grid_points_per_core ("
      56             :              << grid_points_per_core.size()
      57             :              << ") does not match number of cores determined from "
      58             :                 "global cache ("
      59             :              << number_of_cores << ").");
      60             :   ASSERT(number_of_nodes == elements_per_node.size(),
      61             :          "Number of nodes determined from elements_per_node ("
      62             :              << elements_per_node.size()
      63             :              << ") does not match number of nodes determined from "
      64             :                 "global cache ("
      65             :              << number_of_nodes << ").");
      66             :   ASSERT(number_of_nodes == grid_points_per_node.size(),
      67             :          "Number of nodes determined from grid_points_per_node ("
      68             :              << grid_points_per_node.size()
      69             :              << ") does not match number of nodes determined from "
      70             :                 "global cache ("
      71             :              << number_of_nodes << ").");
      72             : 
      73             :   using ::operator<<;
      74             :   std::stringstream ss{};
      75             :   ss << "----- Domain Info -----\n"
      76             :      << "Total blocks: " << total_number_of_blocks << "\n"
      77             :      << "Total elements: " << total_number_of_elements << "\n"
      78             :      << "Total grid points: " << total_number_of_grid_points << "\n"
      79             :      << "Number of cores: " << number_of_cores << "\n"
      80             :      << "Number of nodes: " << number_of_nodes << "\n"
      81             :      << "Elements per core: " << elements_per_core << "\n"
      82             :      << "Elements per node: " << elements_per_node << "\n"
      83             :      << "Grid points per core: " << grid_points_per_core << "\n"
      84             :      << "Grid points per node: " << grid_points_per_node << "\n"
      85             :      << "-----------------------\n";
      86             : 
      87             :   return ss.str();
      88             : }
      89             : }  // namespace domain