Line data    Source code

       1             : // SPDX-FileCopyrightText: 2024 PairInteraction Developers
       2             : // SPDX-License-Identifier: LGPL-3.0-or-later
       3             : 
       4             : #include "pairinteraction/diagonalize/diagonalize.hpp"
       5             : 
       6             : #include "pairinteraction/system/SystemAtom.hpp"
       7             : #include "pairinteraction/system/SystemPair.hpp"
       8             : #include "pairinteraction/utils/Range.hpp"
       9             : #include "pairinteraction/utils/TaskControl.hpp"
      10             : 
      11             : #include <complex>
      12             : #include <cstddef>
      13             : #include <oneapi/tbb.h>
      14             : #include <optional>
      15             : 
      16             : namespace pairinteraction {
      17             : 
      18             : template <typename Derived>
      19           3 : void diagonalize(std::initializer_list<std::reference_wrapper<Derived>> systems,
      20             :                  const DiagonalizerInterface<typename Derived::scalar_t> &diagonalizer,
      21             :                  std::optional<typename Derived::real_t> min_eigenenergy,
      22             :                  std::optional<typename Derived::real_t> max_eigenenergy, double rtol,
      23             :                  bool sort_by_energy) {
      24           3 :     set_task_status("Diagonalizing systems...");
      25           3 :     oneapi::tbb::parallel_for(
      26           9 :         oneapi::tbb::blocked_range(systems.begin(), systems.end()), [&](const auto &range) {
      27          12 :             for (auto &system : range) {
      28           6 :                 system.get().diagonalize(diagonalizer, min_eigenenergy, max_eigenenergy, rtol,
      29             :                                          sort_by_energy);
      30           6 :                 set_task_status("Finished diagonalizing one system...", true);
      31             :             }
      32             :         });
      33           3 : }
      34             : 
      35             : template <typename Derived>
      36           0 : void diagonalize(std::vector<Derived> &systems,
      37             :                  const DiagonalizerInterface<typename Derived::scalar_t> &diagonalizer,
      38             :                  std::optional<typename Derived::real_t> min_eigenenergy,
      39             :                  std::optional<typename Derived::real_t> max_eigenenergy, double rtol,
      40             :                  bool sort_by_energy) {
      41           0 :     set_task_status("Diagonalizing systems...");
      42           0 :     oneapi::tbb::parallel_for(oneapi::tbb::blocked_range(systems.begin(), systems.end()),
      43           0 :                               [&](const auto &range) {
      44           0 :                                   for (auto &system : range) {
      45           0 :                                       system.diagonalize(diagonalizer, min_eigenenergy,
      46             :                                                          max_eigenenergy, rtol, sort_by_energy);
      47           0 :                                       set_task_status("Finished diagonalizing one system...", true);
      48             :                                   }
      49             :                               });
      50           0 : }
      51             : 
      52             : template <typename Derived>
      53          79 : void diagonalize(std::vector<std::reference_wrapper<Derived>> systems,
      54             :                  const DiagonalizerInterface<typename Derived::scalar_t> &diagonalizer,
      55             :                  std::optional<typename Derived::real_t> min_eigenenergy,
      56             :                  std::optional<typename Derived::real_t> max_eigenenergy, double rtol,
      57             :                  bool sort_by_energy) {
      58          79 :     set_task_status("Diagonalizing systems...");
      59          79 :     oneapi::tbb::parallel_for(
      60         673 :         oneapi::tbb::blocked_range(systems.begin(), systems.end()), [&](const auto &range) {
      61        1190 :             for (auto &system : range) {
      62         594 :                 system.get().diagonalize(diagonalizer, min_eigenenergy, max_eigenenergy, rtol,
      63             :                                          sort_by_energy);
      64         595 :                 set_task_status("Finished diagonalizing one system...", true);
      65             :             }
      66             :         });
      67          79 : }
      68             : 
      69             : // Explicit instantiations
      70             : // NOLINTBEGIN(bugprone-macro-parentheses, cppcoreguidelines-macro-usage)
      71             : #define INSTANTIATE_DIAGONALIZE_HELPER(SCALAR, TYPE)                                               \
      72             :     template void diagonalize(std::initializer_list<std::reference_wrapper<TYPE<SCALAR>>> systems, \
      73             :                               const DiagonalizerInterface<TYPE<SCALAR>::scalar_t> &diagonalizer,   \
      74             :                               std::optional<TYPE<SCALAR>::real_t> min_eigenenergy,                 \
      75             :                               std::optional<TYPE<SCALAR>::real_t> max_eigenenergy, double rtol,    \
      76             :                               bool sort_by_energy);                                                \
      77             :     template void diagonalize(std::vector<TYPE<SCALAR>> &systems,                                  \
      78             :                               const DiagonalizerInterface<TYPE<SCALAR>::scalar_t> &diagonalizer,   \
      79             :                               std::optional<TYPE<SCALAR>::real_t> min_eigenenergy,                 \
      80             :                               std::optional<TYPE<SCALAR>::real_t> max_eigenenergy, double rtol,    \
      81             :                               bool sort_by_energy);                                                \
      82             :     template void diagonalize(std::vector<std::reference_wrapper<TYPE<SCALAR>>> systems,           \
      83             :                               const DiagonalizerInterface<TYPE<SCALAR>::scalar_t> &diagonalizer,   \
      84             :                               std::optional<TYPE<SCALAR>::real_t> min_eigenenergy,                 \
      85             :                               std::optional<TYPE<SCALAR>::real_t> max_eigenenergy, double rtol,    \
      86             :                               bool sort_by_energy);
      87             : #define INSTANTIATE_DIAGONALIZE(SCALAR)                                                            \
      88             :     INSTANTIATE_DIAGONALIZE_HELPER(SCALAR, SystemAtom)                                             \
      89             :     INSTANTIATE_DIAGONALIZE_HELPER(SCALAR, SystemPair)
      90             : // NOLINTEND(bugprone-macro-parentheses, cppcoreguidelines-macro-usage)
      91             : 
      92             : INSTANTIATE_DIAGONALIZE(double)
      93             : INSTANTIATE_DIAGONALIZE(std::complex<double>)
      94             : 
      95             : #undef INSTANTIATE_DIAGONALIZE_HELPER
      96             : #undef INSTANTIATE_DIAGONALIZE
      97             : 
      98             : } // namespace pairinteraction