Line data Source code
1 : // SPDX-FileCopyrightText: 2024 Pairinteraction Developers
2 : // SPDX-License-Identifier: LGPL-3.0-or-later
3 :
4 : #include "./Basis.py.hpp"
5 :
6 : #include "pairinteraction/basis/Basis.hpp"
7 : #include "pairinteraction/basis/BasisAtom.hpp"
8 : #include "pairinteraction/basis/BasisAtomCreator.hpp"
9 : #include "pairinteraction/basis/BasisPair.hpp"
10 : #include "pairinteraction/basis/BasisPairCreator.hpp"
11 : #include "pairinteraction/database/Database.hpp"
12 : #include "pairinteraction/interfaces/TransformationBuilderInterface.hpp"
13 : #include "pairinteraction/ket/KetAtom.hpp"
14 : #include "pairinteraction/ket/KetPair.hpp"
15 : #include "pairinteraction/system/SystemAtom.hpp"
16 :
17 : #include <nanobind/eigen/sparse.h>
18 : #include <nanobind/nanobind.h>
19 : #include <nanobind/stl/complex.h>
20 : #include <nanobind/stl/set.h>
21 : #include <nanobind/stl/shared_ptr.h>
22 : #include <nanobind/stl/string.h>
23 : #include <nanobind/stl/vector.h>
24 :
25 : namespace nb = nanobind;
26 : using namespace pairinteraction;
27 :
28 : template <typename T>
29 4 : static void declare_basis(nb::module_ &m, std::string const &type_name) {
30 4 : std::string pyclass_name = "Basis" + type_name;
31 : using scalar_t = typename Basis<T>::scalar_t;
32 4 : nb::class_<Basis<T>, TransformationBuilderInterface<scalar_t>> pyclass(m, pyclass_name.c_str());
33 4 : pyclass.def("get_kets", &Basis<T>::get_kets)
34 4 : .def("get_ket", &Basis<T>::get_ket)
35 4 : .def("get_state", &Basis<T>::get_state)
36 4 : .def("get_number_of_states", &Basis<T>::get_number_of_states)
37 4 : .def("get_number_of_kets", &Basis<T>::get_number_of_kets)
38 4 : .def("get_quantum_number_f", &Basis<T>::get_quantum_number_f)
39 4 : .def("get_quantum_number_m", &Basis<T>::get_quantum_number_m)
40 4 : .def("get_parity", &Basis<T>::get_parity)
41 4 : .def("get_coefficients", nb::overload_cast<>(&Basis<T>::get_coefficients, nb::const_))
42 4 : .def("set_coefficients", &Basis<T>::set_coefficients)
43 4 : .def("get_transformation", &Basis<T>::get_transformation)
44 4 : .def("get_rotator", &Basis<T>::get_rotator)
45 4 : .def("get_sorter", &Basis<T>::get_sorter)
46 4 : .def("get_indices_of_blocks", &Basis<T>::get_indices_of_blocks)
47 4 : .def("get_sorter_without_checks", &Basis<T>::get_sorter_without_checks)
48 4 : .def("get_indices_of_blocks_without_checks",
49 4 : &Basis<T>::get_indices_of_blocks_without_checks)
50 4 : .def(
51 : "transformed",
52 4 : nb::overload_cast<const Transformation<scalar_t> &>(&Basis<T>::transformed, nb::const_))
53 4 : .def("transformed", nb::overload_cast<const Sorting &>(&Basis<T>::transformed, nb::const_))
54 4 : .def("get_amplitudes",
55 4 : nb::overload_cast<std::shared_ptr<const typename Basis<T>::ket_t>>(
56 : &Basis<T>::get_amplitudes, nb::const_))
57 4 : .def("get_amplitudes",
58 4 : nb::overload_cast<std::shared_ptr<const T>>(&Basis<T>::get_amplitudes, nb::const_))
59 4 : .def("get_overlaps",
60 4 : nb::overload_cast<std::shared_ptr<const typename Basis<T>::ket_t>>(
61 : &Basis<T>::get_overlaps, nb::const_))
62 4 : .def("get_overlaps",
63 4 : nb::overload_cast<std::shared_ptr<const T>>(&Basis<T>::get_overlaps, nb::const_))
64 4 : .def("get_matrix_elements",
65 4 : nb::overload_cast<std::shared_ptr<const typename Basis<T>::ket_t>, OperatorType, int>(
66 : &Basis<T>::get_matrix_elements, nb::const_))
67 4 : .def("get_matrix_elements",
68 4 : nb::overload_cast<std::shared_ptr<const T>, OperatorType, int>(
69 : &Basis<T>::get_matrix_elements, nb::const_))
70 4 : .def("get_corresponding_state",
71 4 : nb::overload_cast<size_t>(&Basis<T>::get_corresponding_state, nb::const_))
72 4 : .def("get_corresponding_state",
73 4 : nb::overload_cast<std::shared_ptr<const typename Basis<T>::ket_t>>(
74 : &Basis<T>::get_corresponding_state, nb::const_))
75 4 : .def("get_corresponding_state_index",
76 4 : nb::overload_cast<size_t>(&Basis<T>::get_corresponding_state_index, nb::const_))
77 4 : .def("get_corresponding_state_index",
78 4 : nb::overload_cast<std::shared_ptr<const typename Basis<T>::ket_t>>(
79 : &Basis<T>::get_corresponding_state_index, nb::const_))
80 4 : .def("get_corresponding_ket",
81 4 : nb::overload_cast<size_t>(&Basis<T>::get_corresponding_ket, nb::const_))
82 4 : .def("get_corresponding_ket",
83 4 : nb::overload_cast<std::shared_ptr<const T>>(&Basis<T>::get_corresponding_ket,
84 : nb::const_))
85 4 : .def("get_corresponding_ket_index",
86 4 : nb::overload_cast<size_t>(&Basis<T>::get_corresponding_ket_index, nb::const_))
87 : .def("get_corresponding_ket_index",
88 4 : nb::overload_cast<std::shared_ptr<const T>>(&Basis<T>::get_corresponding_ket_index,
89 : nb::const_));
90 4 : }
91 :
92 : template <typename T>
93 2 : static void declare_basis_atom(nb::module_ &m, std::string const &type_name) {
94 2 : std::string pyclass_name = "BasisAtom" + type_name;
95 2 : nb::class_<BasisAtom<T>, Basis<BasisAtom<T>>> pyclass(m, pyclass_name.c_str());
96 2 : }
97 :
98 : template <typename T>
99 2 : static void declare_basis_atom_creator(nb::module_ &m, std::string const &type_name) {
100 2 : std::string pyclass_name = "BasisAtomCreator" + type_name;
101 4 : nb::class_<BasisAtomCreator<T>> pyclass(m, pyclass_name.c_str());
102 4 : pyclass.def(nb::init<>())
103 2 : .def("set_species", &BasisAtomCreator<T>::set_species)
104 2 : .def("restrict_energy", &BasisAtomCreator<T>::restrict_energy)
105 2 : .def("restrict_quantum_number_f", &BasisAtomCreator<T>::restrict_quantum_number_f)
106 2 : .def("restrict_quantum_number_m", &BasisAtomCreator<T>::restrict_quantum_number_m)
107 2 : .def("restrict_parity", &BasisAtomCreator<T>::restrict_parity)
108 2 : .def("restrict_quantum_number_n", &BasisAtomCreator<T>::restrict_quantum_number_n)
109 2 : .def("restrict_quantum_number_nu", &BasisAtomCreator<T>::restrict_quantum_number_nu)
110 2 : .def("restrict_quantum_number_nui", &BasisAtomCreator<T>::restrict_quantum_number_nui)
111 2 : .def("restrict_quantum_number_l", &BasisAtomCreator<T>::restrict_quantum_number_l)
112 2 : .def("restrict_quantum_number_s", &BasisAtomCreator<T>::restrict_quantum_number_s)
113 2 : .def("restrict_quantum_number_j", &BasisAtomCreator<T>::restrict_quantum_number_j)
114 2 : .def("restrict_quantum_number_l_ryd", &BasisAtomCreator<T>::restrict_quantum_number_l_ryd)
115 2 : .def("restrict_quantum_number_j_ryd", &BasisAtomCreator<T>::restrict_quantum_number_j_ryd)
116 2 : .def("append_ket", &BasisAtomCreator<T>::append_ket)
117 2 : .def("create", &BasisAtomCreator<T>::create);
118 2 : }
119 :
120 : template <typename T>
121 2 : static void declare_basis_pair(nb::module_ &m, std::string const &type_name) {
122 2 : std::string pyclass_name = "BasisPair" + type_name;
123 2 : nb::class_<BasisPair<T>, Basis<BasisPair<T>>> pyclass(m, pyclass_name.c_str());
124 : pyclass
125 2 : .def("get_amplitudes",
126 2 : nb::overload_cast<std::shared_ptr<const KetAtom>, std::shared_ptr<const KetAtom>>(
127 : &BasisPair<T>::get_amplitudes, nb::const_))
128 2 : .def("get_amplitudes",
129 : nb::overload_cast<std::shared_ptr<const BasisAtom<T>>,
130 2 : std::shared_ptr<const BasisAtom<T>>>(&BasisPair<T>::get_amplitudes,
131 : nb::const_))
132 2 : .def("get_overlaps",
133 2 : nb::overload_cast<std::shared_ptr<const KetAtom>, std::shared_ptr<const KetAtom>>(
134 : &BasisPair<T>::get_overlaps, nb::const_))
135 2 : .def("get_overlaps",
136 : nb::overload_cast<std::shared_ptr<const BasisAtom<T>>,
137 2 : std::shared_ptr<const BasisAtom<T>>>(&BasisPair<T>::get_overlaps,
138 : nb::const_))
139 2 : .def("get_matrix_elements",
140 : nb::overload_cast<std::shared_ptr<const BasisPair<T>>, OperatorType, OperatorType, int,
141 2 : int>(&BasisPair<T>::get_matrix_elements, nb::const_))
142 2 : .def("get_matrix_elements",
143 : nb::overload_cast<std::shared_ptr<const BasisAtom<T>>,
144 : std::shared_ptr<const BasisAtom<T>>, OperatorType, OperatorType, int,
145 2 : int>(&BasisPair<T>::get_matrix_elements, nb::const_))
146 2 : .def("get_matrix_elements",
147 : nb::overload_cast<std::shared_ptr<const typename BasisPair<T>::ket_t>, OperatorType,
148 2 : OperatorType, int, int>(&BasisPair<T>::get_matrix_elements,
149 : nb::const_))
150 : .def("get_matrix_elements",
151 : nb::overload_cast<std::shared_ptr<const KetAtom>, std::shared_ptr<const KetAtom>,
152 2 : OperatorType, OperatorType, int, int>(
153 : &BasisPair<T>::get_matrix_elements, nb::const_));
154 2 : }
155 :
156 : template <typename T>
157 2 : static void declare_basis_pair_creator(nb::module_ &m, std::string const &type_name) {
158 2 : std::string pyclass_name = "BasisPairCreator" + type_name;
159 4 : nb::class_<BasisPairCreator<T>> pyclass(m, pyclass_name.c_str());
160 4 : pyclass.def(nb::init<>())
161 2 : .def("add", &BasisPairCreator<T>::add)
162 2 : .def("restrict_energy", &BasisPairCreator<T>::restrict_energy)
163 2 : .def("restrict_quantum_number_m", &BasisPairCreator<T>::restrict_quantum_number_m)
164 2 : .def("restrict_product_of_parities", &BasisPairCreator<T>::restrict_product_of_parities)
165 2 : .def("create", &BasisPairCreator<T>::create);
166 2 : }
167 :
168 1 : void bind_basis(nb::module_ &m) {
169 1 : declare_basis<BasisAtom<double>>(m, "BasisAtomReal");
170 1 : declare_basis<BasisAtom<std::complex<double>>>(m, "BasisAtomComplex");
171 1 : declare_basis_atom<double>(m, "Real");
172 1 : declare_basis_atom<std::complex<double>>(m, "Complex");
173 1 : declare_basis_atom_creator<double>(m, "Real");
174 1 : declare_basis_atom_creator<std::complex<double>>(m, "Complex");
175 :
176 1 : declare_basis<BasisPair<double>>(m, "BasisPairReal");
177 1 : declare_basis<BasisPair<std::complex<double>>>(m, "BasisPairComplex");
178 1 : declare_basis_pair<double>(m, "Real");
179 1 : declare_basis_pair<std::complex<double>>(m, "Complex");
180 1 : declare_basis_pair_creator<double>(m, "Real");
181 1 : declare_basis_pair_creator<std::complex<double>>(m, "Complex");
182 1 : }
|
