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             : 
      10             : #include <complex>
      11             : #include <oneapi/tbb.h>
      12             : #include <optional>
      13             : 
      14             : namespace pairinteraction {
      15             : 
      16             : template <typename Derived>
      17           2 : void diagonalize(std::initializer_list<std::reference_wrapper<Derived>> systems,
      18             :                  const DiagonalizerInterface<typename Derived::scalar_t> &diagonalizer,
      19             :                  std::optional<typename Derived::real_t> min_eigenenergy,
      20             :                  std::optional<typename Derived::real_t> max_eigenenergy, double rtol) {
      21           2 :     oneapi::tbb::parallel_for(
      22          14 :         oneapi::tbb::blocked_range(systems.begin(), systems.end()), [&](const auto &range) {
      23           8 :             for (auto &system : range) {
      24           4 :                 system.get().diagonalize(diagonalizer, min_eigenenergy, max_eigenenergy, rtol);
      25             :             }
      26             :         });
      27           2 : }
      28             : 
      29             : template <typename Derived>
      30          10 : void diagonalize(std::vector<Derived> &systems,
      31             :                  const DiagonalizerInterface<typename Derived::scalar_t> &diagonalizer,
      32             :                  std::optional<typename Derived::real_t> min_eigenenergy,
      33             :                  std::optional<typename Derived::real_t> max_eigenenergy, double rtol) {
      34          10 :     oneapi::tbb::parallel_for(
      35          70 :         oneapi::tbb::blocked_range(systems.begin(), systems.end()), [&](const auto &range) {
      36         120 :             for (auto &system : range) {
      37          60 :                 system.diagonalize(diagonalizer, min_eigenenergy, max_eigenenergy, rtol);
      38             :             }
      39             :         });
      40          10 : }
      41             : 
      42             : template <typename Derived>
      43           0 : void diagonalize(std::vector<std::reference_wrapper<Derived>> systems,
      44             :                  const DiagonalizerInterface<typename Derived::scalar_t> &diagonalizer,
      45             :                  std::optional<typename Derived::real_t> min_eigenenergy,
      46             :                  std::optional<typename Derived::real_t> max_eigenenergy, double rtol) {
      47           0 :     oneapi::tbb::parallel_for(
      48           0 :         oneapi::tbb::blocked_range(systems.begin(), systems.end()), [&](const auto &range) {
      49           0 :             for (auto &system : range) {
      50           0 :                 system.get().diagonalize(diagonalizer, min_eigenenergy, max_eigenenergy, rtol);
      51             :             }
      52             :         });
      53           0 : }
      54             : 
      55             : // Explicit instantiations
      56             : // NOLINTBEGIN(bugprone-macro-parentheses, cppcoreguidelines-macro-usage)
      57             : #define INSTANTIATE_DIAGONALIZE_HELPER(SCALAR, TYPE)                                               \
      58             :     template void diagonalize(std::initializer_list<std::reference_wrapper<TYPE<SCALAR>>> systems, \
      59             :                               const DiagonalizerInterface<TYPE<SCALAR>::scalar_t> &diagonalizer,   \
      60             :                               std::optional<TYPE<SCALAR>::real_t> min_eigenenergy,                 \
      61             :                               std::optional<TYPE<SCALAR>::real_t> max_eigenenergy, double rtol);   \
      62             :     template void diagonalize(std::vector<TYPE<SCALAR>> &systems,                                  \
      63             :                               const DiagonalizerInterface<TYPE<SCALAR>::scalar_t> &diagonalizer,   \
      64             :                               std::optional<TYPE<SCALAR>::real_t> min_eigenenergy,                 \
      65             :                               std::optional<TYPE<SCALAR>::real_t> max_eigenenergy, double rtol);   \
      66             :     template void diagonalize(std::vector<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             : #define INSTANTIATE_DIAGONALIZE(SCALAR)                                                            \
      71             :     INSTANTIATE_DIAGONALIZE_HELPER(SCALAR, SystemAtom)                                             \
      72             :     INSTANTIATE_DIAGONALIZE_HELPER(SCALAR, SystemPair)
      73             : // NOLINTEND(bugprone-macro-parentheses, cppcoreguidelines-macro-usage)
      74             : 
      75             : INSTANTIATE_DIAGONALIZE(double)
      76             : INSTANTIATE_DIAGONALIZE(std::complex<double>)
      77             : 
      78             : #undef INSTANTIATE_DIAGONALIZE_HELPER
      79             : #undef INSTANTIATE_DIAGONALIZE
      80             : 
      81             : } // namespace pairinteraction