Line data    Source code

       1             : // SPDX-FileCopyrightText: 2024 PairInteraction Developers
       2             : // SPDX-License-Identifier: LGPL-3.0-or-later
       3             : 
       4             : #include "pairinteraction/ket/KetAtomCreator.hpp"
       5             : 
       6             : #include "pairinteraction/database/Database.hpp"
       7             : #include "pairinteraction/ket/KetAtom.hpp"
       8             : #include "pairinteraction/ket/QuantumNumberNotAvailableError.hpp"
       9             : 
      10             : #include <doctest/doctest.h>
      11             : #include <string>
      12             : 
      13             : namespace pairinteraction {
      14           1 : DOCTEST_TEST_CASE("create a ket for rubidium") {
      15           1 :     Database &database = Database::get_global_instance();
      16           1 :     auto ket = KetAtomCreator(database)
      17           2 :                    .set_species("Rb")
      18           2 :                    .set_quantum_number("n", 60)
      19           2 :                    .set_quantum_number("l", 1)
      20           2 :                    .set_quantum_number("j", 0.5)
      21           2 :                    .set_quantum_number("m", 0.5)
      22           1 :                    .create();
      23           1 :     DOCTEST_CHECK(ket->get_species() == "Rb");
      24           1 :     DOCTEST_CHECK(ket->get_quantum_number("n") == 60);
      25           1 :     DOCTEST_CHECK(ket->get_quantum_number("l") == 1);
      26           1 :     DOCTEST_CHECK(ket->get_quantum_number("f") == 0.5);
      27           1 :     DOCTEST_CHECK(ket->get_quantum_number("j") == 0.5);
      28           1 :     DOCTEST_CHECK(ket->get_quantum_number("m") == 0.5);
      29           1 :     DOCTEST_CHECK(ket->get_quantum_number("s") == 0.5);
      30           1 :     DOCTEST_CHECK(ket->get_quantum_number("parity") == -1); // odd parity
      31           1 : }
      32             : 
      33           1 : DOCTEST_TEST_CASE("create a ket for strontium") {
      34           1 :     Database &database = Database::get_global_instance();
      35           1 :     auto ket = KetAtomCreator(database)
      36           2 :                    .set_species("Sr88_sqdt")
      37           2 :                    .set_quantum_number("n", 60)
      38           2 :                    .set_quantum_number("l", 1)
      39           2 :                    .set_quantum_number("f", 1)
      40           2 :                    .set_quantum_number("m", 0)
      41           2 :                    .set_quantum_number("s", 0)
      42           1 :                    .create();
      43           1 :     DOCTEST_CHECK(ket->get_species() == "Sr88_sqdt");
      44           1 :     DOCTEST_CHECK(ket->get_quantum_number("n") == 60);
      45           1 :     DOCTEST_CHECK(ket->get_quantum_number("f") == 1);
      46           1 :     DOCTEST_CHECK(ket->get_quantum_number("m") == 0);
      47           1 :     DOCTEST_CHECK(ket->get_quantum_number("parity") == -1); // odd parity
      48           1 : }
      49             : 
      50           1 : DOCTEST_TEST_CASE("quantum number std fallback") {
      51           1 :     Database &database = Database::get_global_instance();
      52             : 
      53             :     // n, f, and nu have no "std_<name>" column in the states table, so get_quantum_number_std
      54             :     // falls back to 0.
      55           1 :     auto ket = KetAtomCreator(database)
      56           2 :                    .set_species("Rb")
      57           2 :                    .set_quantum_number("n", 60)
      58           2 :                    .set_quantum_number("l", 0)
      59           2 :                    .set_quantum_number("j", 0.5)
      60           2 :                    .set_quantum_number("m", 0.5)
      61           1 :                    .create();
      62           1 :     DOCTEST_CHECK(ket->get_quantum_number_std("n") == 0);
      63           1 :     DOCTEST_CHECK(ket->get_quantum_number_std("f") == 0);
      64           1 :     DOCTEST_CHECK(ket->get_quantum_number_std("nu") == 0);
      65             : 
      66             :     // For an MQDT ket, quantum numbers that do have a "std_<name>" column report a nonzero spread,
      67             :     // confirming the zeros above come from the fallback and not from a stored value that is zero.
      68           1 :     auto ket_mqdt = KetAtomCreator(database)
      69           2 :                         .set_species("Yb171_mqdt")
      70           2 :                         .set_quantum_number("nu", 60)
      71           2 :                         .set_quantum_number("l", 0)
      72           2 :                         .set_quantum_number("f", 0.5)
      73           2 :                         .set_quantum_number("m", 0.5)
      74           1 :                         .create();
      75           1 :     DOCTEST_CHECK(ket_mqdt->get_quantum_number_std("l") > 0);
      76           1 :     DOCTEST_CHECK(ket_mqdt->get_quantum_number_std("n") == 0);
      77           1 : }
      78             : 
      79           1 : DOCTEST_TEST_CASE("quantum numbers of the coupling schemes") {
      80           1 :     Database &database = Database::get_global_instance();
      81             : 
      82             :     // The backend does not know any of these names; they are whatever the states table provides.
      83           1 :     auto ket = KetAtomCreator(database)
      84           2 :                    .set_species("Rb")
      85           2 :                    .set_quantum_number("n", 60)
      86           2 :                    .set_quantum_number("l", 1)
      87           2 :                    .set_quantum_number("j", 0.5)
      88           2 :                    .set_quantum_number("m", 0.5)
      89           1 :                    .create();
      90          12 :     for (const auto &name : {"l", "s", "j", "l_ryd", "s_ryd", "j_ryd", "l_core", "s_core", "j_core",
      91          13 :                              "i_core", "f_core"}) {
      92          11 :         DOCTEST_CHECK_NOTHROW(ket->get_quantum_number(name));
      93          11 :         DOCTEST_CHECK_NOTHROW(ket->get_quantum_number_std(name));
      94             :     }
      95             : 
      96             :     // The Rydberg electron is a single electron and the core of rubidium is a closed shell.
      97           1 :     DOCTEST_CHECK(ket->get_quantum_number("s_ryd") == 0.5);
      98           1 :     DOCTEST_CHECK(ket->get_quantum_number("j_core") == 0);
      99           1 :     DOCTEST_CHECK(ket->get_quantum_number("s_core") == 0);
     100             : 
     101             :     // Selecting a state by any of these quantum numbers must work
     102           1 :     auto ket_selected = KetAtomCreator(database)
     103           2 :                             .set_species("Rb")
     104           2 :                             .set_quantum_number("n", 60)
     105           2 :                             .set_quantum_number("l", 1)
     106           2 :                             .set_quantum_number("j", 0.5)
     107           2 :                             .set_quantum_number("m", 0.5)
     108           2 :                             .set_quantum_number("s_ryd", 0.5)
     109           1 :                             .create();
     110           1 :     DOCTEST_CHECK(*ket_selected == *ket);
     111           1 : }
     112             : 
     113           1 : DOCTEST_TEST_CASE("unavailable quantum number") {
     114           1 :     Database &database = Database::get_global_instance();
     115           1 :     auto ket = KetAtomCreator(database)
     116           2 :                    .set_species("Rb")
     117           2 :                    .set_quantum_number("n", 60)
     118           2 :                    .set_quantum_number("l", 1)
     119           2 :                    .set_quantum_number("j", 0.5)
     120           2 :                    .set_quantum_number("m", 0.5)
     121           1 :                    .create();
     122             : 
     123             :     // The states table of Rb has no column for this quantum number (here a misspelling of "nui"),
     124           3 :     DOCTEST_CHECK_THROWS_AS(ket->get_quantum_number("nu_i"), QuantumNumberNotAvailableError);
     125           3 :     DOCTEST_CHECK_THROWS_AS(ket->get_quantum_number_std("nu_i"), QuantumNumberNotAvailableError);
     126             : 
     127             :     // The error names the quantum number, so that a caller can react to it.
     128             :     try {
     129           3 :         ket->get_quantum_number("nu_i");
     130           1 :     } catch (const QuantumNumberNotAvailableError &e) {
     131           1 :         DOCTEST_CHECK(e.get_name() == "nu_i");
     132           1 :         DOCTEST_CHECK(std::string(e.what()).find("nu_i") != std::string::npos);
     133           1 :     }
     134           1 : }
     135             : 
     136           1 : DOCTEST_TEST_CASE("test for equality") {
     137           1 :     Database &database = Database::get_global_instance();
     138           1 :     auto ket1 = KetAtomCreator(database)
     139           2 :                     .set_species("Rb")
     140           2 :                     .set_quantum_number("n", 60)
     141           2 :                     .set_quantum_number("l", 1)
     142           2 :                     .set_quantum_number("j", 0.5)
     143           2 :                     .set_quantum_number("m", 0.5)
     144           1 :                     .create();
     145           1 :     auto ket2 = KetAtomCreator(database)
     146           2 :                     .set_species("Rb")
     147           2 :                     .set_quantum_number("n", 60)
     148           2 :                     .set_quantum_number("l", 1)
     149           2 :                     .set_quantum_number("j", 0.5)
     150           2 :                     .set_quantum_number("m", 0.5)
     151           1 :                     .create();
     152           1 :     auto ket3 = KetAtomCreator(database)
     153           2 :                     .set_species("Rb")
     154           2 :                     .set_quantum_number("n", 60)
     155           2 :                     .set_quantum_number("l", 1)
     156           2 :                     .set_quantum_number("j", 1.5)
     157           2 :                     .set_quantum_number("m", 0.5)
     158           1 :                     .create();
     159           1 :     DOCTEST_CHECK(*ket1 == *ket2);
     160           1 :     DOCTEST_CHECK(*ket1 != *ket3);
     161           1 : }
     162             : 
     163             : } // namespace pairinteraction