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