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           3 :     set_task_status("Diagonalizing systems...");
      24           3 :     oneapi::tbb::parallel_for(
      25           9 :         oneapi::tbb::blocked_range(systems.begin(), systems.end()), [&](const auto &range) {
      26          12 :             for (auto &system : range) {
      27           6 :                 system.get().diagonalize(diagonalizer, min_eigenenergy, max_eigenenergy, rtol);
      28           6 :                 set_task_status("Finished diagonalizing one system...", true);
      29             :             }
      30             :         });
      31           3 : }
      32             : 
      33             : template <typename Derived>
      34           0 : void diagonalize(std::vector<Derived> &systems,
      35             :                  const DiagonalizerInterface<typename Derived::scalar_t> &diagonalizer,
      36             :                  std::optional<typename Derived::real_t> min_eigenenergy,
      37             :                  std::optional<typename Derived::real_t> max_eigenenergy, double rtol) {
      38           0 :     set_task_status("Diagonalizing systems...");
      39           0 :     oneapi::tbb::parallel_for(
      40           0 :         oneapi::tbb::blocked_range(systems.begin(), systems.end()), [&](const auto &range) {
      41           0 :             for (auto &system : range) {
      42           0 :                 system.diagonalize(diagonalizer, min_eigenenergy, max_eigenenergy, rtol);
      43           0 :                 set_task_status("Finished diagonalizing one system...", true);
      44             :             }
      45             :         });
      46           0 : }
      47             : 
      48             : template <typename Derived>
      49          89 : void diagonalize(std::vector<std::reference_wrapper<Derived>> systems,
      50             :                  const DiagonalizerInterface<typename Derived::scalar_t> &diagonalizer,
      51             :                  std::optional<typename Derived::real_t> min_eigenenergy,
      52             :                  std::optional<typename Derived::real_t> max_eigenenergy, double rtol) {
      53          89 :     set_task_status("Diagonalizing systems...");
      54          89 :     oneapi::tbb::parallel_for(
      55         696 :         oneapi::tbb::blocked_range(systems.begin(), systems.end()), [&](const auto &range) {
      56        1214 :             for (auto &system : range) {
      57         607 :                 system.get().diagonalize(diagonalizer, min_eigenenergy, max_eigenenergy, rtol);
      58         607 :                 set_task_status("Finished diagonalizing one system...", true);
      59             :             }
      60             :         });
      61          89 : }
      62             : 
      63             : // Explicit instantiations
      64             : // NOLINTBEGIN(bugprone-macro-parentheses, cppcoreguidelines-macro-usage)
      65             : #define INSTANTIATE_DIAGONALIZE_HELPER(SCALAR, TYPE)                                               \
      66             :     template void diagonalize(std::initializer_list<std::reference_wrapper<TYPE<SCALAR>>> systems, \
      67             :                               const DiagonalizerInterface<TYPE<SCALAR>::scalar_t> &diagonalizer,   \
      68             :                               std::optional<TYPE<SCALAR>::real_t> min_eigenenergy,                 \
      69             :                               std::optional<TYPE<SCALAR>::real_t> max_eigenenergy, double rtol);   \
      70             :     template void diagonalize(std::vector<TYPE<SCALAR>> &systems,                                  \
      71             :                               const DiagonalizerInterface<TYPE<SCALAR>::scalar_t> &diagonalizer,   \
      72             :                               std::optional<TYPE<SCALAR>::real_t> min_eigenenergy,                 \
      73             :                               std::optional<TYPE<SCALAR>::real_t> max_eigenenergy, double rtol);   \
      74             :     template void diagonalize(std::vector<std::reference_wrapper<TYPE<SCALAR>>> systems,           \
      75             :                               const DiagonalizerInterface<TYPE<SCALAR>::scalar_t> &diagonalizer,   \
      76             :                               std::optional<TYPE<SCALAR>::real_t> min_eigenenergy,                 \
      77             :                               std::optional<TYPE<SCALAR>::real_t> max_eigenenergy, double rtol);
      78             : #define INSTANTIATE_DIAGONALIZE(SCALAR)                                                            \
      79             :     INSTANTIATE_DIAGONALIZE_HELPER(SCALAR, SystemAtom)                                             \
      80             :     INSTANTIATE_DIAGONALIZE_HELPER(SCALAR, SystemPair)
      81             : // NOLINTEND(bugprone-macro-parentheses, cppcoreguidelines-macro-usage)
      82             : 
      83             : INSTANTIATE_DIAGONALIZE(double)
      84             : INSTANTIATE_DIAGONALIZE(std::complex<double>)
      85             : 
      86             : #undef INSTANTIATE_DIAGONALIZE_HELPER
      87             : #undef INSTANTIATE_DIAGONALIZE
      88             : 
      89             : } // namespace pairinteraction