diff --git a/include/integratorxx/atomic_densities/SlaterAtomicShell.hpp b/include/integratorxx/atomic_densities/SlaterAtomicShell.hpp new file mode 100644 index 0000000..92a27f8 --- /dev/null +++ b/include/integratorxx/atomic_densities/SlaterAtomicShell.hpp @@ -0,0 +1,391 @@ +#pragma once +#include +#include +#include +#include + +class SlaterTypeAtomicShell { + using int_container = std::vector; + using real_container = std::vector; + + /// Angular momentum + unsigned int angular_momentum_; + /// Exponents + real_container exponents_; + /// Principal quantum numbers + int_container quantum_numbers_; + /// Contraction coefficients + real_container orbital_coefficients_; + /// Alpha orbital occupations + int_container alpha_occupations_; + /// Beta orbital occupations + int_container beta_occupations_; + /// Normalization coefficients + real_container normalization_; + + public: + /// Dummy constructor + SlaterTypeAtomicShell() = default; + /// Constructor + SlaterTypeAtomicShell(unsigned int angular_momentum, + const real_container &exponents, + const int_container &quantum_numbers, + const real_container &coefficients, + const int_container &alpha_occupations, + const int_container &beta_occupations) + : angular_momentum_(angular_momentum), + exponents_(exponents), + quantum_numbers_(quantum_numbers), + orbital_coefficients_(coefficients), + alpha_occupations_(alpha_occupations), + beta_occupations_(beta_occupations) { + // Size checks + assert(exponents_.size() == quantum_numbers_.size()); + assert(alpha_occupations_.size() == beta_occupations_.size()); + assert(alpha_occupations_.size() * exponents_.size() == + orbital_coefficients_.size()); + // Basis function normalization factors; include angular factor here for + // simplicity + normalization_.resize(exponents_.size()); + for(size_t ix = 0; ix < exponents_.size(); ix++) { + normalization_[ix] = + std::pow(2.0 * exponents_[ix], quantum_numbers_[ix] + 0.5) / + std::sqrt(4.0 * M_PI * + IntegratorXX::factorial(2 * quantum_numbers_[ix])); + } + }; + + /// Evaluate number of basis functions + size_t number_of_basis_functions() const { return exponents_.size(); } + + /// Evaluate number of orbitals + size_t number_of_orbitals() const { return alpha_occupations_.size(); } + + /// Evaluates the basis functions + void evaluate_basis_functions(double r, double *array) { + for(size_t ix = 0; ix < exponents_.size(); ix++) { + array[ix] = normalization_[ix] * std::pow(r, quantum_numbers_[ix] - 1) * + std::exp(-exponents_[ix] * r); + } + } + + /// Evaluates the basis function gradients + void evaluate_basis_function_gradients(double r, double *array) { + for(size_t ix = 0; ix < exponents_.size(); ix++) { + array[ix] = -exponents_[ix] * std::pow(r, quantum_numbers_[ix] - 1); + if(quantum_numbers_[ix] > 0) { + array[ix] += + (quantum_numbers_[ix] - 1) * std::pow(r, quantum_numbers_[ix] - 2); + } + array[ix] *= normalization_[ix] * std::exp(-exponents_[ix] * r); + } + } + + /// Evaluates the basis function second derivatives + void evaluate_basis_function_laplacians(double r, double *array) { + for(size_t ix = 0; ix < exponents_.size(); ix++) { + array[ix] = exponents_[ix] * exponents_[ix] * + std::pow(r, quantum_numbers_[ix] - 1); + if(quantum_numbers_[ix] > 1) { + array[ix] -= 2.0 * exponents_[ix] * (quantum_numbers_[ix] - 1) * + std::pow(r, quantum_numbers_[ix] - 2); + if(quantum_numbers_[ix] > 2) { + array[ix] += (quantum_numbers_[ix] * quantum_numbers_[ix] - + 3 * quantum_numbers_[ix] + 2) * + std::pow(r, quantum_numbers_[ix] - 3); + } + } + array[ix] *= normalization_[ix] * std::exp(-exponents_[ix] * r); + } + } + + /// Evaluates the orbitals' values + void evaluate_orbitals(const double *bf, double *orbs) { + for(size_t iorb = 0; iorb < alpha_occupations_.size(); iorb++) { + orbs[iorb] = 0.0; + for(size_t ix = 0; ix < exponents_.size(); ix++) + orbs[iorb] += + bf[ix] * orbital_coefficients_[iorb * exponents_.size() + ix]; + } + } + + /// Helper to evaluate electron densities + double evaluate_density(const double *orbs, const int_container &occs) { + double density = 0.0; + for(size_t iorb = 0; iorb < occs.size(); iorb++) { + density += occs[iorb] * orbs[iorb] * orbs[iorb]; + } + return density; + } + + /// Helper to evaluate electron density gradient + double evaluate_density_gradient(const double *orbs, const double *dorbs, + const int_container &occs) { + double gradient = 0.0; + for(size_t iorb = 0; iorb < occs.size(); iorb++) { + gradient += 2.0 * occs[iorb] * orbs[iorb] * dorbs[iorb]; + } + return gradient; + } + + /// Helper to evaluate electron density gradient + double evaluate_tau(double r, const double *orbs, const double *dorbs, + const int_container &occs) { + double tau = 0.0; + for(size_t iorb = 0; iorb < occs.size(); iorb++) { + tau += occs[iorb] * (dorbs[iorb] * dorbs[iorb] + + angular_momentum_ * (angular_momentum_ + 1) * + orbs[iorb] * orbs[iorb] / (r * r)); + } + tau *= 0.5; + return tau; + } + + /// Helper to evaluate electron density laplacian + double evaluate_density_laplacian(double r, const double *orbs, + const double *dorbs, const double *lorbs, + const int_container &occs) { + double lapl = 0.0; + for(size_t iorb = 0; iorb < occs.size(); iorb++) { + lapl += 2.0 * occs[iorb] * + (dorbs[iorb] * dorbs[iorb] + orbs[iorb] * lorbs[iorb] + + 2.0 / r * orbs[iorb] * dorbs[iorb]); + } + return lapl; + } + + /// Evaluates alpha electron density from computed orbitals + double evaluate_alpha_density(const double *orbs) { + return evaluate_density(orbs, alpha_occupations_); + } + + /// Evaluates beta electron density from computed orbitals + double evaluate_beta_density(const double *orbs) { + return evaluate_density(orbs, beta_occupations_); + } + + /// Evaluates alpha electron density from computed orbitals + double evaluate_alpha_density_gradient(const double *orbs, + const double *dorbs) { + return evaluate_density_gradient(orbs, dorbs, alpha_occupations_); + } + + /// Evaluates beta electron density from computed orbitals + double evaluate_beta_density_gradient(const double *orbs, + const double *dorbs) { + return evaluate_density_gradient(orbs, dorbs, beta_occupations_); + } + + /// Evaluates alpha electron density from computed orbitals + double evaluate_alpha_tau(double r, const double *orbs, const double *dorbs) { + return evaluate_tau(r, orbs, dorbs, alpha_occupations_); + } + + /// Evaluates beta electron density from computed orbitals + double evaluate_beta_tau(double r, const double *orbs, const double *dorbs) { + return evaluate_tau(r, orbs, dorbs, beta_occupations_); + } + + /// Evaluates alpha electron density from computed orbitals + double evaluate_alpha_density_laplacian(double r, const double *orbs, + const double *dorbs, + const double *lorbs) { + return evaluate_density_laplacian(r, orbs, dorbs, lorbs, + alpha_occupations_); + } + + /// Evaluates beta electron density from computed orbitals + double evaluate_beta_density_laplacian(double r, const double *orbs, + const double *dorbs, + const double *lorbs) { + return evaluate_density_laplacian(r, orbs, dorbs, lorbs, beta_occupations_); + } + + /// Return angular momentum + auto angular_momentum() const { return angular_momentum_; } + + /// Return pointer to quantum number array + auto *exponents_data() const { return exponents_.data(); } + /// Fetch quantum number of i:th basis function + auto exponent(size_t i) const { return exponents_[i]; } + + /// Return pointer to quantum number array + auto *quantum_numbers_data() const { return quantum_numbers_.data(); } + /// Fetch quantum number of i:th basis function + auto quantum_number(size_t i) const { return quantum_numbers_[i]; } + + /// Return pointer to orbital coefficients for ix:th exponent + auto *orbital_coefficients_data() const { + return orbital_coefficients_.data(); + } + /// Fetch orbital coefficient of ix:th basis function in iorb:th orbital + auto quantum_number(size_t ix, size_t iorb) const { + return orbital_coefficients_[iorb * exponents_.size() + ix]; + } +}; + +class SlaterTypeAtom { + /// Atomic number + unsigned int Z_; + /// Shells + std::vector shells_; + + public: + /// Constructor + SlaterTypeAtom(unsigned int Z, + const std::vector &shells) + : Z_(Z), shells_(shells){}; + /// Deconstructor + ~SlaterTypeAtom(){}; + + /// Determine maximum number of basis functions + auto maximum_number_of_basis_functions() { + size_t max_bf = 0; + for(auto shell : shells_) + max_bf = std::max(max_bf, shell.number_of_basis_functions()); + return max_bf; + } + + /// Determine maximum number of orbitals + auto maximum_number_of_orbitals() { + size_t max_orb = 0; + for(auto shell : shells_) + max_orb = std::max(max_orb, shell.number_of_orbitals()); + return max_orb; + } + + /// Get shells + auto shells() const { return shells_; } + /// Get i:th shell + auto shell(size_t i) const { return shells_[i]; } +}; + +/// Helper class for evaluating orbitals +class SlaterEvaluator { + /// Atom + SlaterTypeAtom atom_; + /// Array for basis function data + std::vector bf_; + /// Array for basis function gradient data + std::vector df_; + /// Array for basis function laplacian data + std::vector lf_; + + /// Array for orbital data + std::vector orbs_; + /// Array for orbital gradient data + std::vector dorbs_; + /// Array for orbital laplacian data + std::vector lorbs_; + + public: + SlaterEvaluator(const SlaterTypeAtom &atom) : atom_(atom) { + bf_.resize(atom_.maximum_number_of_basis_functions()); + df_.resize(atom_.maximum_number_of_basis_functions()); + lf_.resize(atom_.maximum_number_of_basis_functions()); + orbs_.resize(atom_.maximum_number_of_orbitals()); + dorbs_.resize(atom_.maximum_number_of_orbitals()); + lorbs_.resize(atom_.maximum_number_of_orbitals()); + } + + /// Evaluate density + double evaluate_alpha_density(double r) { + double density = 0.0; + for(auto shell : atom_.shells()) { + shell.evaluate_basis_functions(r, bf_.data()); + shell.evaluate_orbitals(bf_.data(), orbs_.data()); + density += shell.evaluate_alpha_density(orbs_.data()); + } + return density; + } + /// Evaluate density + double evaluate_beta_density(double r) { + double density = 0.0; + for(auto shell : atom_.shells()) { + shell.evaluate_basis_functions(r, bf_.data()); + shell.evaluate_orbitals(bf_.data(), orbs_.data()); + density += shell.evaluate_beta_density(orbs_.data()); + } + return density; + } + /// Evaluate density gradient + double evaluate_alpha_density_gradient(double r) { + double gradient = 0.0; + for(auto shell : atom_.shells()) { + shell.evaluate_basis_functions(r, bf_.data()); + shell.evaluate_basis_function_gradients(r, df_.data()); + shell.evaluate_orbitals(bf_.data(), orbs_.data()); + shell.evaluate_orbitals(df_.data(), dorbs_.data()); + gradient += + shell.evaluate_alpha_density_gradient(orbs_.data(), dorbs_.data()); + } + return gradient; + } + /// Evaluate density gradient + double evaluate_beta_density_gradient(double r) { + double gradient = 0.0; + for(auto shell : atom_.shells()) { + shell.evaluate_basis_functions(r, bf_.data()); + shell.evaluate_basis_function_gradients(r, df_.data()); + shell.evaluate_orbitals(bf_.data(), orbs_.data()); + shell.evaluate_orbitals(df_.data(), dorbs_.data()); + gradient += + shell.evaluate_beta_density_gradient(orbs_.data(), dorbs_.data()); + } + return gradient; + } + /// Evaluate kinetic energy density + double evaluate_alpha_tau(double r) { + double tau = 0.0; + for(auto shell : atom_.shells()) { + shell.evaluate_basis_functions(r, bf_.data()); + shell.evaluate_basis_function_gradients(r, df_.data()); + shell.evaluate_orbitals(bf_.data(), orbs_.data()); + shell.evaluate_orbitals(df_.data(), dorbs_.data()); + tau += shell.evaluate_alpha_tau(r, orbs_.data(), dorbs_.data()); + } + return tau; + } + /// Evaluate kinetic energy density + double evaluate_beta_tau(double r) { + double tau = 0.0; + for(auto shell : atom_.shells()) { + shell.evaluate_basis_functions(r, bf_.data()); + shell.evaluate_basis_function_gradients(r, df_.data()); + shell.evaluate_orbitals(bf_.data(), orbs_.data()); + shell.evaluate_orbitals(df_.data(), dorbs_.data()); + tau += shell.evaluate_beta_tau(r, orbs_.data(), dorbs_.data()); + } + return tau; + } + /// Evaluate density laplacian + double evaluate_alpha_density_laplacian(double r) { + double lapl = 0.0; + for(auto shell : atom_.shells()) { + shell.evaluate_basis_functions(r, bf_.data()); + shell.evaluate_basis_function_gradients(r, df_.data()); + shell.evaluate_basis_function_laplacians(r, lf_.data()); + shell.evaluate_orbitals(bf_.data(), orbs_.data()); + shell.evaluate_orbitals(df_.data(), dorbs_.data()); + shell.evaluate_orbitals(lf_.data(), lorbs_.data()); + lapl += shell.evaluate_alpha_density_laplacian( + r, orbs_.data(), dorbs_.data(), lorbs_.data()); + } + return lapl; + } + /// Evaluate density laplacian + double evaluate_beta_density_laplacian(double r) { + double lapl = 0.0; + for(auto shell : atom_.shells()) { + shell.evaluate_basis_functions(r, bf_.data()); + shell.evaluate_basis_function_gradients(r, df_.data()); + shell.evaluate_basis_function_laplacians(r, lf_.data()); + shell.evaluate_orbitals(bf_.data(), orbs_.data()); + shell.evaluate_orbitals(df_.data(), dorbs_.data()); + shell.evaluate_orbitals(lf_.data(), lorbs_.data()); + lapl += shell.evaluate_beta_density_laplacian( + r, orbs_.data(), dorbs_.data(), lorbs_.data()); + } + return lapl; + } +}; diff --git a/include/integratorxx/atomic_densities/k00heavy.hpp b/include/integratorxx/atomic_densities/k00heavy.hpp new file mode 100644 index 0000000..299b0ce --- /dev/null +++ b/include/integratorxx/atomic_densities/k00heavy.hpp @@ -0,0 +1,3807 @@ +#include "SlaterAtomicShell.hpp" +#include +static const std::map k00heavy{ + {55, + SlaterTypeAtom( + 55, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Cs + * + * Etot=-7553.933536555 Ekin=7553.933539793 + */ + SlaterTypeAtomicShell( + 0, + std::vector{72.432562, 54.152961, 44.781947, 26.827713, + 24.294310, 13.933326, 11.953711, 5.980958, + 4.692356, 2.500713, 1.798027, 0.588383, + 0.390475}, + std::vector{1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0377623, 0.9551564, 0.0098484, 0.0016466, -0.0009236, + 0.0007609, -0.0006588, 0.0002115, -0.0001554, 0.0000453, + -0.0000218, 0.0000036, -0.0000021, 0.0103858, -0.3460218, + -0.2411602, 0.9740101, 0.2843564, 0.0266942, -0.0151287, + 0.0018900, -0.0013985, 0.0003806, -0.0001726, 0.0000280, + -0.0000164, -0.0044410, 0.1549825, 0.1176682, -0.4700583, + -0.3799401, 0.4918863, 0.7577563, 0.0371581, -0.0170224, + 0.0030623, -0.0013938, 0.0002044, -0.0001189, 0.0008170, + -0.0695741, -0.0581946, 0.2253993, 0.1903026, 0.1358413, + -1.1867227, 1.1149583, 0.2712921, 0.0032891, 0.0004197, + -0.0000297, 0.0000144, -0.0005962, 0.0263093, 0.0209939, + -0.0827492, -0.0742903, -0.0825567, 0.5211043, -0.4306240, + -0.4760294, 0.7797928, 0.5114934, 0.0007642, 0.0000802, + -0.0000189, -0.0057221, -0.0051315, 0.0194272, 0.0158226, + 0.0253313, -0.1272332, 0.1068061, 0.1109156, -0.1899775, + -0.1956432, 1.0078373, 0.0502065}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 0}), + SlaterTypeAtomicShell( + 1, + std::vector{45.866789, 27.025862, 23.215568, 18.118816, + 14.399860, 10.231415, 5.932205, 4.962671, + 2.159681, 1.445617}, + std::vector{2, 2, 3, 4, 3, 3, 3, 4, 3, 3}, + std::vector{ + 0.0210501, 0.8198700, 0.1878594, 0.0093039, -0.0058215, + 0.0008863, -0.0003720, 0.0000783, -0.0000195, 0.0000078, + -0.0073758, -0.3941551, -0.3249796, -0.3910175, 1.3221003, + 0.3695076, 0.0035781, 0.0003709, -0.0001195, 0.0000376, + 0.0037098, 0.1755499, 0.2250350, 0.3933548, -0.9500830, + -0.4769754, 1.0868046, 0.2793788, 0.0095076, -0.0019457, + -0.0015482, -0.0576959, -0.0958059, -0.1917067, 0.4178221, + 0.1571339, -0.4645357, -0.2648592, 0.7363377, 0.4728437}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{32.852137, 18.354403, 14.523221, 10.312620, + 7.919345, 5.157647, 3.330606}, + std::vector{3, 3, 4, 4, 4, 4, 4}, + std::vector{ + 0.0074132, 0.4361883, 0.4775524, 0.1684697, 0.0012654, + 0.0011730, -0.0002517, -0.0025615, -0.1930536, -0.2057559, + -0.1179374, 0.4341816, 0.6417053, 0.1309576}, + std::vector{5, 5}, std::vector{5, 5})})}, + {56, + SlaterTypeAtom( + 56, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ba + * + * Etot=-7883.543708638 Ekin=7883.543713832 + */ + SlaterTypeAtomicShell( + 0, + std::vector{73.408386, 55.121608, 45.589826, 27.288659, + 24.735741, 14.154755, + 12.256065, 6.196423, 5.035677, 2.516335, + 1.862701, + 0.807625, + 0.594012}, + std::vector{1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0389526, 0.9543018, 0.0093847, 0.0017129, -0.0009738, + 0.0008856, -0.0007812, 0.0002732, -0.0002040, 0.0000567, + -0.0000347, 0.0000098, -0.0000055, 0.0107795, -0.3471179, + -0.2417351, 0.9799271, 0.2791374, 0.0276330, -0.0165055, + 0.0022935, -0.0017122, 0.0004395, -0.0002562, 0.0000700, + -0.0000390, -0.0045627, 0.1559313, 0.1185820, -0.4750104, + -0.3811963, 0.5106202, 0.7406760, 0.0433847, -0.0213837, + 0.0034288, -0.0019941, 0.0005034, -0.0002781, 0.0008967, + -0.0707771, -0.0591276, 0.2298952, 0.1937714, 0.1718973, + -1.2473274, 1.0716014, 0.3266426, 0.0074697, -0.0016966, + 0.0003105, -0.0001590, -0.0006995, 0.0281535, 0.0223137, + -0.0884563, -0.0798378, -0.1036767, 0.5754007, -0.3781625, + -0.5843751, 1.0042665, 0.3002312, -0.0031825, 0.0015204, + 0.0000743, -0.0075747, -0.0064325, 0.0248914, 0.0212647, + 0.0352075, -0.1683729, 0.1084627, 0.1781953, -0.3055246, + -0.2247028, 0.6849016, 0.4392419}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{46.966097, 27.608616, 23.743389, 18.568484, + 14.716154, 10.415319, 6.176644, 5.202768, + 2.231317, 1.527034}, + std::vector{2, 2, 3, 4, 3, 3, 3, 4, 3, 3}, + std::vector{ + 0.0199630, 0.8182538, 0.1904196, 0.0088858, -0.0051839, + 0.0007757, -0.0003682, 0.0000721, -0.0000163, 0.0000067, + -0.0070187, -0.3947519, -0.3291007, -0.3918549, 1.3375133, + 0.3584581, 0.0017990, 0.0008247, -0.0002131, 0.0000801, + 0.0035009, 0.1783800, 0.2243391, 0.3801198, -0.9427099, + -0.5023057, 1.0980750, 0.2931051, 0.0099021, -0.0025364, + -0.0015386, -0.0628028, -0.0999990, -0.1931070, 0.4335618, + 0.1814481, -0.5040309, -0.3034165, 0.9052275, 0.3249073}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{33.450500, 18.748779, 14.846820, 10.453672, + 8.414827, 5.487808, 3.614287}, + std::vector{3, 3, 4, 4, 4, 4, 4}, + std::vector{ + 0.0073496, 0.4383067, 0.4826192, 0.1653351, -0.0045282, + 0.0016290, -0.0003184, -0.0025622, -0.1985296, -0.2122128, + -0.1491822, 0.4345895, 0.6594324, 0.1440156}, + std::vector{5, 5}, std::vector{5, 5})})}, + {57, + SlaterTypeAtom( + 57, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for La + * + * Etot=-8221.066556283 Ekin=8221.066541731 + */ + SlaterTypeAtomicShell( + 0, + std::vector{74.686053, 56.122632, 46.442201, 27.670889, + 25.126010, 14.473285, + 12.560364, 6.313598, 5.148584, 2.721675, + 2.038687, + 0.883413, + 0.635998}, + std::vector{1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0384678, 0.9548115, 0.0093450, 0.0016865, -0.0009857, + 0.0009338, -0.0008241, 0.0003035, -0.0002386, 0.0000725, + -0.0000422, 0.0000100, -0.0000053, 0.0108460, -0.3474916, + -0.2418844, 0.9908451, 0.2675671, 0.0269573, -0.0162263, + 0.0023328, -0.0018301, 0.0005168, -0.0002856, 0.0000651, + -0.0000345, -0.0044792, 0.1564427, 0.1194892, -0.4829444, + -0.3807365, 0.5082533, 0.7480968, 0.0462103, -0.0245112, + 0.0044155, -0.0024153, 0.0005026, -0.0002636, 0.0009017, + -0.0717595, -0.0600463, 0.2358324, 0.1960109, 0.1936691, + -1.2891416, 1.1570722, 0.2494980, 0.0088541, -0.0019452, + 0.0003166, -0.0001533, -0.0006996, 0.0293811, 0.0234359, + -0.0936850, -0.0832184, -0.1201522, 0.6173143, -0.4092386, + -0.6346075, 0.9794392, 0.3763127, -0.0009352, 0.0005842, + 0.0000873, -0.0081334, -0.0068875, 0.0269649, 0.0228346, + 0.0409068, -0.1849423, 0.1174919, 0.2053043, -0.3094400, + -0.2554968, 0.6378111, 0.4924238}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{47.922059, 28.166523, 24.260607, 19.029118, + 15.044910, 10.575140, 6.469568, 5.487832, + 2.366537, 1.608197}, + std::vector{2, 2, 3, 4, 3, 3, 3, 4, 3, 3}, + std::vector{ + 0.0193450, 0.8174909, 0.1917262, 0.0096392, -0.0060774, + 0.0009764, -0.0004492, 0.0000934, -0.0000188, 0.0000078, + -0.0068441, -0.3957572, -0.3352747, -0.3994825, 1.3629184, + 0.3473940, -0.0010579, 0.0015722, -0.0003336, 0.0001188, + 0.0033712, 0.1812977, 0.2245080, 0.3689578, -0.9380633, + -0.5341449, 1.0971261, 0.3260132, 0.0106450, -0.0026039, + -0.0015792, -0.0662802, -0.1073381, -0.2062746, 0.4672205, + 0.1921000, -0.5131835, -0.3558958, 0.9597379, 0.2950228}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{34.153392, 19.107963, 15.073064, 10.165703, + 8.440305, 5.562649, 3.651979, 2.027158, + 1.145554}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4}, + std::vector{ + 0.0071691, 0.4435003, 0.4991228, 0.1664653, -0.0306542, + 0.0040676, -0.0009574, 0.0001670, -0.0000470, -0.0026035, + -0.2047753, -0.2288931, -0.1460586, 0.4917533, 0.6480873, + 0.1079708, -0.0009317, 0.0004376, 0.0008930, 0.0532214, + 0.0670341, 0.0017020, -0.0905339, -0.2726263, 0.1020024, + 0.6374399, 0.4288175}, + std::vector{5, 5, 1}, std::vector{5, 5, 0})})}, + {58, + SlaterTypeAtom( + 58, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ce + * + * Etot=-8566.872534154 Ekin=8566.872517249 + */ + SlaterTypeAtomicShell( + 0, + std::vector{76.035150, 57.131650, 47.312853, 28.060473, + 25.534699, 14.844127, + 12.885759, 6.492214, 5.307661, 2.782600, + 2.081217, + 0.887910, + 0.637379}, + std::vector{1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0376052, 0.9556282, 0.0093994, 0.0016381, -0.0009821, + 0.0009419, -0.0008262, 0.0002999, -0.0002334, 0.0000677, + -0.0000392, 0.0000091, -0.0000049, 0.0107790, -0.3476280, + -0.2419226, 1.0004787, 0.2569709, 0.0260744, -0.0155549, + 0.0021674, -0.0016915, 0.0004570, -0.0002506, 0.0000564, + -0.0000302, -0.0044017, 0.1569281, 0.1200773, -0.4896624, + -0.3811291, 0.4864992, 0.7747351, 0.0470196, -0.0247076, + 0.0042198, -0.0022984, 0.0004719, -0.0002501, 0.0008657, + -0.0722714, -0.0605894, 0.2401257, 0.1969862, 0.2168735, + -1.3220929, 1.1380184, 0.2727868, 0.0089997, -0.0019725, + 0.0003165, -0.0001554, -0.0006832, 0.0294582, 0.0235511, + -0.0949849, -0.0833279, -0.1304826, 0.6301005, -0.3975369, + -0.6363608, 0.9581058, 0.3886994, -0.0008409, 0.0005322, + 0.0000765, -0.0079963, -0.0068019, 0.0268485, 0.0223828, + 0.0432763, -0.1853049, 0.1125496, 0.2002120, -0.2950350, + -0.2517460, 0.6409955, 0.4839873}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{48.894058, 28.719833, 24.767523, 19.481959, + 15.389248, 10.857138, 6.613655, 5.604644, + 2.429195, 1.653439}, + std::vector{2, 2, 3, 4, 3, 3, 3, 4, 3, 3}, + std::vector{ + 0.0187269, 0.8172122, 0.1924309, 0.0094797, -0.0058948, + 0.0009451, -0.0004340, 0.0000906, -0.0000183, 0.0000076, + -0.0066093, -0.3971550, -0.3368059, -0.3913859, 1.3526985, + 0.3503363, -0.0002937, 0.0013787, -0.0002953, 0.0001038, + 0.0033058, 0.1827283, 0.2298495, 0.3749904, -0.9533053, + -0.5320395, 1.1076889, 0.3150168, 0.0104913, -0.0025236, + -0.0015015, -0.0665316, -0.1062708, -0.1994035, 0.4571237, + 0.1966320, -0.5222579, -0.3418279, 0.9355328, 0.3161997}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{34.797518, 19.516555, 15.424922, 10.345200, + 8.740820, 5.744808, 3.775249, 2.115986, + 1.206276}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4}, + std::vector{ + 0.0070376, 0.4447579, 0.5004222, 0.1696865, -0.0375941, + 0.0043832, -0.0009669, 0.0001884, -0.0000430, -0.0025580, + -0.2071363, -0.2323262, -0.1642383, 0.5088511, 0.6495648, + 0.1106898, -0.0007505, 0.0004208, 0.0009051, 0.0559465, + 0.0703054, 0.0049159, -0.0975771, -0.2837080, 0.1053767, + 0.6459785, 0.4170737}, + std::vector{5, 5, 1}, std::vector{5, 5, 0}), + SlaterTypeAtomicShell( + 3, + std::vector{17.373634, 10.034791, 6.709780, 4.338091, + 2.673664, 1.640385}, + std::vector{4, 4, 4, 4, 4, 4}, + std::vector{0.0177006, 0.1365710, 0.3091707, 0.4158549, + 0.2672594, 0.0601619}, + std::vector{1}, std::vector{0})})}, + {59, + SlaterTypeAtom( + 59, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Pr + * + * Etot=-8921.180897012 Ekin=8921.180886172 + */ + SlaterTypeAtomicShell( + 0, + std::vector{77.213125, 58.122933, 48.167912, 28.433887, + 25.933524, 15.251111, + 13.207237, 6.750698, 5.502002, 2.702642, + 1.995310, + .841438, .611222}, + std::vector{1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + .0376499, .9557010, .0092343, .0016371, -.0010022, + .0009467, -.0008191, .0002733, -.0001985, .0000502, + -.0000304, .0000082, -.0000046, .0108983, -.3481710, + -.2418347, 1.0115134, .2449625, .0246909, -.0143684, + .0018340, -.0013517, .0003180, -.0001820, .0000476, + -.0000267, -.0043920, .1575551, .1206346, -.4971190, + -.3813994, .4629302, .8038196, .0450050, -.0213752, + .0030739, -.0017702, .0004272, -.0002371, .0008225, + -.0724435, -.0608708, .2436858, .1967026, .2274656, + -1.3357974, 1.0161559, .3972320, .0081288, -.0019072, + .0003368, -.0001744, -.0006740, .0285561, .0227874, + -.0929677, -.0805468, -.1282231, .6109707, -.3492546, + -.6005642, .9556300, .3345544, -.0027194, .0013289, + .0000526, -.0073721, -.0063336, .0251877, .0204885, + .0410044, -.1719888, .0974255, .1729180, -.2741263, + -.2231271, .6723950, .4428469}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{49.831272, 29.252859, 25.247558, 19.914715, + 15.733819, 11.166918, + 6.703596, 5.617816, 2.408498, 1.640987}, + std::vector{2, 2, 3, 4, 3, 3, 3, 4, 3, 3}, + std::vector{ + .0182506, .8181224, .1917130, .0086566, -.0050404, + .0007869, -.0003688, .0000711, -.0000157, .0000064, + -.0063976, -.3992170, -.3374234, -.3805638, 1.3368613, + .3555301, .0015074, .0009560, -.0002001, .0000753, + .0033056, .1830785, .2394952, .3950785, -.9908079, + -.5075423, 1.1129261, .2958506, .0097956, -.0024030, + -.0013716, -.0638256, -.1005273, -.1839208, .4259839, + .1906235, -.5127085, -.2874084, .8606492, .3611511}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{35.619597, 20.021927, 15.934469, 11.161212, + 9.030128, 5.920706, 3.876835}, + std::vector{3, 3, 4, 4, 4, 4, 4}, + std::vector{.0066338, .4398358, .4880190, .1598971, + -.0086233, .0020821, -.0002350, -.0023388, + -.2045953, -.2250791, -.1425974, .4642317, + .6491539, .1281533}, + std::vector{5, 5}, std::vector{5, 5}), + SlaterTypeAtomicShell( + 3, + std::vector{17.604838, 10.118322, 6.763135, 4.400819, + 2.713060, 1.655041}, + std::vector{4, 4, 4, 4, 4, 4}, + std::vector{.0185309, .1480404, .3037790, .4000376, + .2727691, .0745447}, + std::vector{3}, std::vector{0})})}, + {60, + SlaterTypeAtom( + 60, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Nd + * + * Etot=-9283.882809548 Ekin=9283.882848169 + */ + SlaterTypeAtomicShell( + 0, + std::vector{78.361307, 59.111063, 49.001140, 28.814173, + 26.316115, 15.655808, + 13.516398, 6.921522, 5.627842, 2.762145, + 2.037392, + .850786, .615797}, + std::vector{1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + .0378429, .9556506, .0090421, .0016354, -.0010230, + .0009556, -.0008153, .0002690, -.0001937, .0000488, + -.0000294, .0000078, -.0000044, .0111258, -.3488668, + -.2420985, 1.0226469, .2334393, .0231393, -.0131121, + .0016188, -.0011939, .0002816, -.0001597, .0000411, + -.0000231, -.0044024, .1581856, .1214622, -.5048756, + -.3818831, .4461988, .8268196, .0446912, -.0208780, + .0029967, -.0017147, .0004069, -.0002265, .0008100, + -.0729348, -.0614854, .2482935, .1974919, .2320015, + -1.3485372, 1.0099906, .4064609, .0080325, -.0018486, + .0003235, -.0001680, -.0006654, .0286086, .0229323, + -.0943298, -.0805002, -.1296090, .6139224, -.3508113, + -.5932509, .9369835, .3490434, -.0025198, .0012478, + .0000452, -.0073010, -.0063113, .0252948, .0202072, + .0409215, -.1708823, .0971663, .1681601, -.2640111, + -.2239823, .6708350, .4418762}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{51.237254, 30.065452, 26.130120, 20.429427, + 15.899519, 11.386007, + 6.861663, 5.735242, 2.462338, 1.673724}, + std::vector{2, 2, 3, 4, 3, 3, 3, 4, 3, 3}, + std::vector{ + .0164601, .8035708, .2083421, .0139202, -.0096932, + .0016627, -.0005323, .0001241, -.0000275, .0000112, + -.0057896, -.3928941, -.3100781, -.3068321, 1.2428157, + .3438432, .0016777, .0008998, -.0001784, .0000665, + .0030793, .1806683, .2186397, .3457904, -.9362265, + -.4956144, 1.1195556, .2923328, .0094955, -.0022809, + -.0012579, -.0626388, -.0893607, -.1580780, .3934053, + .1872411, -.5150285, -.2798843, .8465628, .3724328}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{36.662542, 20.546525, 16.415952, 11.670571, + 9.170058, 6.047923, 3.955445}, + std::vector{3, 3, 4, 4, 4, 4, 4}, + std::vector{.0060074, .4344613, .4832125, .1636239, + -.0015963, .0016940, -.0001440, -.0020978, + -.2033551, -.2257071, -.1270196, .4575776, + .6421118, .1233852}, + std::vector{5, 5}, std::vector{5, 5}), + SlaterTypeAtomicShell( + 3, + std::vector{18.028978, 10.369350, 6.872231, 4.452468, + 2.749827, 1.693471}, + std::vector{4, 4, 4, 4, 4, 4}, + std::vector{.0188220, .1567141, .3214716, .3974978, + .2554202, .0651307}, + std::vector{4}, std::vector{0})})}, + {61, + SlaterTypeAtom( + 61, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Pm + * + * Etot=-9655.098830139 Ekin=9655.09879353 + */ + SlaterTypeAtomicShell( + 0, + std::vector{79.583280, 60.106967, 49.855683, 29.205148, + 26.715753, 16.060435, + 13.827036, 7.090212, 5.751454, 2.821153, + 2.078318, + .860376, .620681}, + std::vector{1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + .0376526, .9559125, .0089390, .0016233, -.0010368, + .0009579, -.0008066, .0002632, -.0001882, .0000473, + -.0000283, .0000075, -.0000042, .0111847, -.3492519, + -.2422344, 1.0321402, .2232796, .0220210, -.0121807, + .0014615, -.0010782, .0002550, -.0001433, .0000364, + -.0000205, -.0043759, .1587153, .1220530, -.5114229, + -.3828191, .4295021, .8492604, .0445228, -.0204945, + .0029425, -.0016728, .0003918, -.0002186, .0007878, + -.0733649, -.0619522, .2522198, .1984142, .2371947, + -1.3608166, 1.0041199, .4147918, .0079073, -.0017734, + .0003072, -.0001598, -.0006554, .0286388, .0230076, + -.0953906, -.0805159, -.1310700, .6163120, -.3517813, + -.5863252, .9190020, .3631372, -.0023696, .0011947, + .0000384, -.0072301, -.0062736, .0253323, .0199607, + .0408704, -.1697186, .0967379, .1637899, -.2546519, + -.2247685, .6676054, .4428291}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{52.707402, 30.902387, 26.993566, 20.940024, + 16.041755, 11.552711, + 7.065332, 5.888728, 2.506045, 1.698957}, + std::vector{2, 2, 3, 4, 3, 3, 3, 4, 3, 3}, + std::vector{ + .0147527, .7884088, .2253351, .0180510, -.0130505, + .0025479, -.0007215, .0001780, -.0000385, .0000158, + -.0051943, -.3862441, -.2912606, -.2464740, 1.1777153, + .3245239, .0011625, .0010222, -.0001788, .0000670, + .0028290, .1781089, .2021721, .3006727, -.8940152, + -.4860081, 1.1177006, .3047514, .0096049, -.0023172, + -.0011446, -.0613855, -.0809755, -.1365237, .3700526, + .1830755, -.5101101, -.2793934, .8395816, .3742202}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{37.170325, 20.912933, 16.725468, 11.821550, + 9.400657, 6.192424, 4.043059}, + std::vector{3, 3, 4, 4, 4, 4, 4}, + std::vector{.0060717, .4380676, .4860553, .1587847, + -.0044951, .0019419, -.0001365, -.0021350, + -.2062821, -.2297059, -.1275702, .4678161, + .6400471, .1212457}, + std::vector{5, 5}, std::vector{5, 5}), + SlaterTypeAtomicShell( + 3, + std::vector{18.396071, 10.595185, 7.014692, 4.559395, + 2.824301, 1.742054}, + std::vector{4, 4, 4, 4, 4, 4}, + std::vector{.0193596, .1648643, .3278102, .3914749, + .2477985, .0628556}, + std::vector{5}, std::vector{0})})}, + {62, + SlaterTypeAtom( + 62, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Sm + * + * Etot=-10034.952404095 Ekin=10034.952363946 + */ + SlaterTypeAtomicShell( + 0, + std::vector{80.553966, 61.076422, 50.677558, 29.587248, + 27.096630, 16.477257, + 14.129532, 7.261204, 5.877176, 2.877709, + 2.119230, + .868757, .624307}, + std::vector{1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + .0387559, .9551018, .0085391, .0016798, -.0010909, + .0009905, -.0008191, .0002650, -.0001879, .0000471, + -.0000281, .0000072, -.0000041, .0115616, -.3502588, + -.2423404, 1.0428324, .2122095, .0207848, -.0111736, + .0013239, -.0009784, .0002325, -.0001298, .0000325, + -.0000183, -.0044441, .1594399, .1227711, -.5188718, + -.3836314, .4172064, .8680290, .0441635, -.0199835, + .0028620, -.0016202, .0003727, -.0002083, .0007837, + -.0738288, -.0624809, .2565352, .1991848, .2350371, + -1.3655623, .9947914, .4263414, .0078087, -.0017186, + .0002928, -.0001526, -.0006638, .0286847, .0230812, + -.0965237, -.0804862, -.1288094, .6145362, -.3500220, + -.5809364, .9002921, .3772017, -.0019767, .0010134, + .0000340, -.0071665, -.0062414, .0254052, .0197176, + .0398236, -.1675405, .0955977, .1600779, -.2453857, + -.2257178, .6681294, .4401656}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{54.405756, 31.824093, 27.897446, 21.470139, + 16.141744, 11.669037, + 7.244475, 6.017516, 2.554320, 1.728467}, + std::vector{2, 2, 3, 4, 3, 3, 3, 4, 3, 3}, + std::vector{ + .0128293, .7698796, .2458547, .0215147, -.0153342, + .0034048, -.0009285, .0002346, -.0000502, .0000206, + -.0045170, -.3777737, -.2770595, -.1890108, 1.1256312, + .2977482, .0004111, .0011476, -.0001809, .0000676, + .0025373, .1745975, .1892418, .2602644, -.8695162, + -.4636421, 1.1226711, .3081420, .0094603, -.0022605, + -.0010145, -.0597995, -.0740265, -.1167911, .3530641, + .1747008, -.5093662, -.2753301, .8271293, .3829636}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{38.244436, 21.430627, 17.191602, 12.265523, + 9.551774, 6.314693, 4.118198}, + std::vector{3, 3, 4, 4, 4, 4, 4}, + std::vector{.0054904, .4333531, .4830415, .1629644, + -.0005188, .0017426, -.0000812, -.0019121, + -.2050253, -.2309239, -.1176802, .4670507, + .6332190, .1172183}, + std::vector{5, 5}, std::vector{5, 5}), + SlaterTypeAtomicShell( + 3, + std::vector{18.738213, 10.788462, 7.107954, 4.631628, + 2.885482, 1.789754}, + std::vector{4, 4, 4, 4, 4, 4}, + std::vector{.0200298, .1755422, .3376071, .3829486, + .2371633, .0595922}, + std::vector{6}, std::vector{0})})}, + {63, + SlaterTypeAtom( + 63, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Eu + * + * Etot=-10423.542874688 Ekin=10423.542867402 + */ + SlaterTypeAtomicShell( + 0, + std::vector{81.559162, 62.048937, 51.485471, 29.994154, + 27.481309, 16.892730, + 14.428066, 7.444558, 6.018308, 2.917280, + 2.138866, + .880123, .630366}, + std::vector{1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + .0396890, .9544307, .0081860, .0017165, -.0011322, + .0010130, -.0008238, .0002645, -.0001849, .0000451, + -.0000270, .0000071, -.0000040, .0119594, -.3512656, + -.2428338, 1.0520637, .2032609, .0193237, -.0100344, + .0011419, -.0008437, .0001963, -.0001096, .0000280, + -.0000157, -.0045411, .1601771, .1236103, -.5254346, + -.3855261, .4084007, .8832894, .0437972, -.0193454, + .0026807, -.0015265, .0003602, -.0002005, .0007967, + -.0742787, -.0630478, .2603338, .2004215, .2311582, + -1.3684340, .9726206, .4507848, .0078115, -.0017536, + .0003050, -.0001583, -.0006835, .0287203, .0231432, + -.0973770, -.0806542, -.1254172, .6111545, -.3401159, + -.5809316, .9022193, .3687225, -.0022276, .0011189, + .0000407, -.0071187, -.0061940, .0253892, .0196043, + .0382502, -.1647640, .0916990, .1588445, -.2450158, + -.2191528, .6585999, .4488125}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{55.791864, 32.553763, 28.575313, 21.951895, + 16.334643, 11.814935, + 7.399224, 6.128648, 2.600679, 1.754749}, + std::vector{2, 2, 3, 4, 3, 3, 3, 4, 3, 3}, + std::vector{ + -.0117778, -.7617137, -.2549446, -.0223334, .0155142, + -.0036625, .0010064, -.0002539, .0000541, -.0000221, + -.0041233, -.3747002, -.2722306, -.1611394, 1.1079101, + .2797576, -.0000781, .0012103, -.0001777, .0000658, + .0023670, .1735450, .1859051, .2449422, -.8751312, + -.4421369, 1.1289997, .3050669, .0091511, -.0021527, + -.0009353, -.0590199, -.0714562, -.1080914, .3491886, + .1669613, -.5100191, -.2681361, .8166134, .3902818}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{39.027658, 21.857710, 17.561048, 12.522999, + 9.746916, 6.446731, 4.199686}, + std::vector{3, 3, 4, 4, 4, 4, 4}, + std::vector{.0052766, .4336767, .4838806, .1616225, + -.0008665, .0018418, -.0000649, -.0018367, + -.2060677, -.2337758, -.1135126, .4720152, + .6290323, .1150725}, + std::vector{5, 5}, std::vector{5, 5}), + SlaterTypeAtomicShell( + 3, + std::vector{19.096807, 11.001211, 7.210563, 4.694780, + 2.936420, 1.834357}, + std::vector{4, 4, 4, 4, 4, 4}, + std::vector{.0205530, .1846057, .3482363, .3767843, + .2258755, .0551175}, + std::vector{7}, std::vector{0})})}, + {64, + SlaterTypeAtom( + 64, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Gd + * + * Etot=-10820.661019091 Ekin=10820.661050178 + */ + SlaterTypeAtomicShell( + 0, + std::vector{82.305311, 62.993249, 52.253869, 30.386501, + 27.824867, 17.377886, + 14.723820, 7.512262, 6.078866, 3.063994, + 2.257096, + .960339, .672792}, + std::vector{1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + .0420691, .9525147, .0075650, .0018127, -.0012151, + .0010492, -.0008261, .0002810, -.0002049, .0000547, + -.0000322, .0000079, -.0000042, .0127455, -.3529691, + -.2433260, 1.0631018, .1928545, .0173924, -.0084947, + .0009599, -.0007538, .0001965, -.0001073, .0000255, + -.0000134, -.0047526, .1611296, .1246522, -.5333925, + -.3878813, .3944648, .9061253, .0442898, -.0207889, + .0032025, -.0017757, .0003860, -.0002006, .0008158, + -.0749927, -.0639987, .2658271, .2019952, .2180020, + -1.3635768, 1.0571236, .3667872, .0076058, -.0015560, + .0002614, -.0001249, -.0006954, .0296509, .0241160, + -.1019239, -.0830467, -.1230900, .6247937, -.3808640, + -.5910739, .9236428, .3786176, -.0009589, .0005687, + .0000720, -.0076424, -.0065899, .0273059, .0211034, + .0377354, -.1725984, .1024853, .1735755, -.2672035, + -.2292665, .6108239, .5067429}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{57.230537, 33.299220, 29.261658, 22.463074, + 16.519189, 11.855231, + 7.661230, 6.362660, 2.703895, 1.822405}, + std::vector{2, 2, 3, 4, 3, 3, 3, 4, 3, 3}, + std::vector{ + -.0107638, -.7530522, -.2644268, -.0232697, .0156807, + -.0040411, .0012300, -.0003029, .0000604, -.0000245, + -.0037609, -.3712357, -.2695431, -.1395232, 1.1051456, + .2563903, -.0029274, .0017308, -.0002516, .0000884, + .0021707, .1731237, .1816029, .2230787, -.8724022, + -.4477478, 1.1346508, .3269394, .0093536, -.0021750, + -.0008905, -.0607787, -.0726016, -.1059017, .3667072, + .1675361, -.5211082, -.3039613, .8732748, .3499930}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{39.152619, 21.988128, 17.542793, 11.762997, + 9.278723, 6.234138, 3.901196, 2.198174, + 1.221245}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4}, + std::vector{.0058312, .4511434, .5051879, .1405776, + -.0234851, .0048487, -.0008887, .0002546, + -.0000519, -.0022044, -.2162180, -.2541038, + -.0324071, .5331148, .5676620, .0610118, + -.0017668, .0005846, .0007132, .0525862, + .0679004, -.0155780, -.1157790, -.2227439, + .1736178, .6154078, .4040166}, + std::vector{5, 5, 1}, std::vector{5, 5, 0}), + SlaterTypeAtomicShell( + 3, + std::vector{19.447696, 11.191024, 7.273950, 4.772530, + 3.057018, 1.968402}, + std::vector{4, 4, 4, 4, 4, 4}, + std::vector{.0218561, .2029585, .3742865, .3664927, + .1923501, .0339587}, + std::vector{7}, std::vector{0})})}, + {65, + SlaterTypeAtom( + 65, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Tb + * + * Etot=-11226.568217318 Ekin=11226.568261475 + */ + SlaterTypeAtomicShell( + 0, + std::vector{82.955621, 63.922571, 53.013606, 30.826568, + 28.227966, 17.761599, + 15.016489, 7.765122, 6.248189, 3.045055, + 2.229203, + .897151, .638579}, + std::vector{1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + .0452054, .9499453, .0067962, .0019517, -.0013129, + .0011244, -.0008721, .0002783, -.0001927, .0000474, + -.0000278, .0000071, -.0000040, .0136258, -.3548982, + -.2438222, 1.0702648, .1867396, .0163019, -.0077514, + .0008069, -.0006163, .0001480, -.0000800, .0000197, + -.0000111, -.0050593, .1622609, .1254358, -.5386782, + -.3907340, .3943828, .9117981, .0428487, -.0184814, + .0026016, -.0014516, .0003282, -.0001840, .0009068, + -.0753986, -.0643232, .2681317, .2034375, .2148288, + -1.3650382, .9739416, .4528382, .0076038, -.0015951, + .0002707, -.0001415, -.0007520, .0289568, .0234413, + -.0995665, -.0812468, -.1166801, .6043303, -.3466537, + -.5667808, .8621931, .4046273, -.0015104, .0008117, + .0000358, -.0070193, -.0061792, .0255178, .0192677, + .0352488, -.1598223, .0922544, .1509373, -.2266379, + -.2229462, .6582115, .4448412}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{58.126052, 33.821695, 29.746277, 22.877678, + 16.799271, 12.072159, + 7.731577, 6.372903, 2.702424, 1.813396}, + std::vector{2, 2, 3, 4, 3, 3, 3, 4, 3, 3}, + std::vector{ + -.0106348, -.7549762, -.2623843, -.0224033, .0148464, + -.0037819, .0011143, -.0002743, .0000575, -.0000232, + -.0036890, -.3733774, -.2685920, -.1312788, 1.1033909, + .2498091, -.0021355, .0015753, -.0002137, .0000794, + .0021731, .1737835, .1845775, .2302509, -.9025598, + -.4113325, 1.1412611, .3045854, .0088570, -.0020157, + -.0008451, -.0585001, -.0693617, -.0989059, .3513294, + .1567666, -.5125455, -.2594673, .7981467, .4043243}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{40.387469, 22.687984, 18.290794, 13.044187, + 10.138627, 6.712861, 4.356704}, + std::vector{3, 3, 4, 4, 4, 4, 4}, + std::vector{.0050433, .4351764, .4843027, .1588657, + -.0012129, .0019648, -.0000206, -.0017594, + -.2086718, -.2387275, -.1056786, .4812813, + .6223791, .1096804}, + std::vector{5, 5}, std::vector{5, 5}), + SlaterTypeAtomicShell( + 3, + std::vector{19.867646, 11.479325, 7.441491, 4.767002, + 2.941008, 1.819700}, + std::vector{4, 4, 4, 4, 4, 4}, + std::vector{.0209293, .1976790, .3669672, .3710036, + .2112048, .0497230}, + std::vector{7}, std::vector{2})})}, + {66, + SlaterTypeAtom( + 66, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Dy + * + * Etot=-11641.452434124 Ekin=11641.452478555 + */ + SlaterTypeAtomicShell( + 0, + std::vector{84.058350, 64.905516, 53.852289, 31.254498, + 28.652782, 18.158666, + 15.320686, 7.950956, 6.399325, 3.084138, + 2.248827, + 0.909579, + 0.645319}, + std::vector{1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0456124, 0.9496808, 0.0065964, 0.0019682, -0.0013408, + 0.0011406, -0.0008745, 0.0002767, -0.0001893, 0.0000450, + -0.0000266, 0.0000069, -0.0000039, 0.0138031, -0.3554674, + -0.2440576, 1.0763439, 0.1804221, 0.0159297, -0.0074477, + 0.0007724, -0.0005872, 0.0001371, -0.0000745, 0.0000188, + -0.0000106, -0.0051222, 0.1628540, 0.1258387, -0.5428898, + -0.3929768, 0.3862794, 0.9245936, 0.0431967, -0.0183353, + 0.0024917, -0.0014010, 0.0003255, -0.0001816, 0.0009207, + -0.0757814, -0.0646217, 0.2706353, 0.2048257, 0.2174741, + -1.3728822, 0.9482582, 0.4800065, 0.0078998, -0.0017609, + 0.0003075, -0.0001606, -0.0007742, 0.0290014, 0.0234188, + -0.1000013, -0.0815748, -0.1164825, 0.6039473, -0.3328408, + -0.5720507, 0.8671143, 0.3940960, -0.0017677, 0.0009200, + 0.0000434, -0.0069760, -0.0061130, 0.0253974, 0.0192024, + 0.0346744, -0.1580676, 0.0875092, 0.1512232, -0.2273023, + -0.2162505, 0.6464777, 0.4559743}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{59.112075, 34.352966, 30.233389, 23.326779, + 17.106021, 12.284446, 7.875620, 6.482252, + 2.749806, 1.839803}, + std::vector{2, 2, 3, 4, 3, 3, 3, 4, 3, 3}, + std::vector{ + -0.0104042, -0.7565815, -0.2607540, -0.0214832, 0.0138536, + -0.0035127, 0.0010424, -0.0002533, 0.0000528, -0.0000212, + -0.0036024, -0.3751913, -0.2694833, -0.1283118, 1.1055833, + 0.2464471, -0.0022252, 0.0015820, -0.0002079, 0.0000770, + 0.0021261, 0.1750186, 0.1867129, 0.2316143, -0.9162493, + -0.4015155, 1.1447599, 0.3002177, 0.0086526, -0.0019415, + -0.0008202, -0.0585701, -0.0694616, -0.0976878, 0.3520368, + 0.1541107, -0.5132046, -0.2526782, 0.7902752, 0.4098413}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{41.304364, 23.145620, 18.693305, 13.360685, + 10.318990, 6.838979, 4.431722}, + std::vector{3, 3, 4, 4, 4, 4, 4}, + std::vector{ + 0.0047386, 0.4338284, 0.4838213, 0.1597852, -0.0004311, + 0.0019629, 0.0000036, -0.0016462, -0.2087639, -0.2407385, + -0.1008913, 0.4844709, 0.6180159, 0.1070867}, + std::vector{5, 5}, std::vector{5, 5}), + SlaterTypeAtomicShell( + 3, + std::vector{20.228223, 11.715340, 7.580714, 4.847854, + 2.987440, 1.843671}, + std::vector{4, 4, 4, 4, 4, 4}, + std::vector{0.0212461, 0.2033083, 0.3708166, 0.3668227, + 0.2073854, 0.0494468}, + std::vector{7}, std::vector{3})})}, + {67, + SlaterTypeAtom( + 67, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ho + * + * Etot=-12065.289636642 Ekin=12065.289643677 + */ + SlaterTypeAtomicShell( + 0, + std::vector{84.799047, 65.843872, 54.615194, 31.642320, + 28.972112, 18.655894, + 15.595011, 8.081194, 6.468844, 3.164079, + 2.308228, + .914799, .647160}, + std::vector{1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + .0483583, .9473867, .0059912, .0020644, -.0014304, + .0011756, -.0008685, .0002780, -.0001905, .0000472, + -.0000272, .0000068, -.0000039, .0146698, -.3572651, + -.2445157, 1.0873835, .1700867, .0140956, -.0060929, + .0005810, -.0004634, .0001153, -.0000605, .0000146, + -.0000083, -.0053234, .1637502, .1269166, -.5509785, + -.3967369, .3865806, .9349763, .0415528, -.0174159, + .0024777, -.0013585, .0002998, -.0001686, .0009448, + -.0762302, -.0653208, .2751828, .2066239, .1935223, + -1.3552079, .9751924, .4539978, .0072734, -.0014130, + .0002387, -.0001250, -.0007785, .0290376, .0236160, + -.1013500, -.0817966, -.1057265, .5939760, -.3528306, + -.5509131, .8306542, .4313372, -.0009608, .0005702, + .0000274, -.0069061, -.0061358, .0255711, .0189805, + .0317524, -.1543042, .0925957, .1434569, -.2126818, + -.2242576, .6537366, .4460854}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{60.023728, 34.882305, 30.725141, 23.756830, + 17.381020, 12.417609, + 8.055475, 6.614935, 2.795860, 1.865851}, + std::vector{2, 2, 3, 4, 3, 3, 3, 4, 3, 3}, + std::vector{ + -.0102617, -.7580560, -.2591686, -.0208891, .0132584, + -.0034159, .0010577, -.0002506, .0000515, -.0000207, + -.0035312, -.3769851, -.2691004, -.1227144, 1.1111100, + .2370956, -.0035498, .0018335, -.0002393, .0000896, + .0021014, .1761713, .1878514, .2306072, -.9323641, + -.3936912, 1.1471586, .3051253, .0086517, -.0019296, + -.0008060, -.0586073, -.0694273, -.0965567, .3557015, + .1506828, -.5109746, -.2509516, .7824373, .4148456}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{42.149351, 23.588381, 19.082168, 13.653646, + 10.485149, 6.956310, 4.500166}, + std::vector{3, 3, 4, 4, 4, 4, 4}, + std::vector{.0045106, .4332153, .4836694, .1599460, + -.0000752, .0019829, .0000215, -.0015664, + -.2091486, -.2429797, -.0949831, .4890742, + .6125045, .1037768}, + std::vector{5, 5}, std::vector{5, 5}), + SlaterTypeAtomicShell( + 3, + std::vector{20.613942, 11.971861, 7.727813, 4.914573, + 3.010806, 1.850632}, + std::vector{4, 4, 4, 4, 4, 4}, + std::vector{.0213636, .2073761, .3760613, .3657866, + .2027725, .0472901}, + std::vector{7}, std::vector{4})})}, + {68, + SlaterTypeAtom( + 68, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Er + * + * Etot=-12498.152612131 Ekin=12498.152587436 + */ + SlaterTypeAtomicShell( + 0, + std::vector{85.931072, 66.831633, 55.449578, 32.064174, + 29.377976, 19.035249, + 15.883516, 8.283918, 6.636024, 3.191019, + 2.316595, + .928801, .654626}, + std::vector{1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + .0485327, .9473026, .0058697, .0020520, -.0014402, + .0011818, -.0008654, .0002750, -.0001851, .0000437, + -.0000256, .0000066, -.0000037, .0148697, -.3578143, + -.2448440, 1.0938547, .1634661, .0137503, -.0058781, + .0005687, -.0004488, .0001073, -.0000571, .0000144, + -.0000081, -.0053451, .1642338, .1274811, -.5556567, + -.3991710, .3885230, .9384419, .0416494, -.0170165, + .0022935, -.0012783, .0002947, -.0001643, .0009742, + -.0765923, -.0656094, .2777018, .2085325, .1902680, + -1.3586755, .9392049, .4924208, .0076897, -.0016570, + .0002905, -.0001516, -.0008132, .0290884, .0235773, + -.1017614, -.0824307, -.1029788, .5916649, -.3328291, + -.5615885, .8476603, .4077025, -.0015197, .0008116, + .0000424, -.0068744, -.0060613, .0254395, .0190296, + .0305394, -.1521397, .0861686, .1455416, -.2177604, + -.2139872, .6387876, .4611723}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{61.043988, 35.420505, 31.217644, 24.193456, + 17.664179, 12.614001, + 8.181173, 6.710377, 2.843177, 1.891215}, + std::vector{2, 2, 3, 4, 3, 3, 3, 4, 3, 3}, + std::vector{ + -.0100085, -.7592956, -.2579810, -.0201252, .0124806, + -.0032226, .0010046, -.0002378, .0000490, -.0000195, + -.0034223, -.3785849, -.2686831, -.1158590, 1.1102095, + .2316312, -.0035060, .0017996, -.0002289, .0000850, + .0020480, .1772395, .1892615, .2303926, -.9471917, + -.3773797, 1.1517595, .2965331, .0083375, -.0018204, + -.0007816, -.0586251, -.0692608, -.0947614, .3567340, + .1459313, -.5129247, -.2426016, .7757857, .4197790}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{42.909407, 24.019173, 19.467034, 13.956931, + 10.665832, 7.079897, 4.572507}, + std::vector{3, 3, 4, 4, 4, 4, 4}, + std::vector{.0043587, .4330911, .4827766, .1599957, + .0005929, .0019566, .0000476, -.0015138, + -.2097478, -.2446104, -.0905378, .4925467, + .6084119, .1013647}, + std::vector{5, 5}, std::vector{5, 5}), + SlaterTypeAtomicShell( + 3, + std::vector{21.070163, 12.313465, 7.999007, 5.097240, + 3.114795, 1.896657}, + std::vector{4, 4, 4, 4, 4, 4}, + std::vector{.0209572, .2040170, .3705399, .3674417, + .2081652, .0511807}, + std::vector{7}, std::vector{5})})}, + {69, + SlaterTypeAtom( + 69, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Tm + * + * Etot=-12940.174228351 Ekin=12940.174228651 + */ + SlaterTypeAtomicShell( + 0, + std::vector{86.510536, 67.746514, 56.182403, 32.500079, + 29.732223, 19.530983, + 16.170154, 8.413489, 6.712172, 3.262439, + 2.366025, + 0.935103, + 0.657290}, + std::vector{1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0525804, 0.9438281, 0.0050971, 0.0021914, -0.0015530, + 0.0012376, -0.0008732, 0.0002784, -0.0001877, 0.0000456, + -0.0000262, 0.0000066, -0.0000037, 0.0160166, -0.3600923, + -0.2454348, 1.1014411, 0.1573033, 0.0122290, -0.0048104, + 0.0004004, -0.0003404, 0.0000863, -0.0000443, 0.0000108, + -0.0000061, -0.0057355, 0.1654252, 0.1283859, -0.5613504, + -0.4044470, 0.3848124, 0.9515652, 0.0406966, -0.0165209, + 0.0023078, -0.0012604, 0.0002816, -0.0001578, 0.0010537, + -0.0771179, -0.0662482, 0.2810609, 0.2107338, 0.1755639, + -1.3483489, 0.9606634, 0.4708714, 0.0072091, -0.0013995, + 0.0002416, -0.0001263, -0.0008459, 0.0291599, 0.0237378, + -0.1026282, -0.0827698, -0.0962917, 0.5847885, -0.3483497, + -0.5433794, 0.8214232, 0.4339192, -0.0010068, 0.0005962, + 0.0000341, -0.0068199, -0.0060733, 0.0254939, 0.0188759, + 0.0286524, -0.1492318, 0.0898065, 0.1391390, -0.2074243, + -0.2185653, 0.6423859, 0.4555841}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{62.010689, 35.956011, 31.711451, 24.625796, + 17.939410, 12.772710, 8.329778, 6.821091, + 2.888972, 1.916143}, + std::vector{2, 2, 3, 4, 3, 3, 3, 4, 3, 3}, + std::vector{ + -0.0098169, -0.7605188, -0.2567408, -0.0194750, 0.0118209, + -0.0030762, 0.0009821, -0.0002295, 0.0000469, -0.0000186, + -0.0033363, -0.3801560, -0.2680982, -0.1091917, 1.1116932, + 0.2243828, -0.0041181, 0.0018951, -0.0002376, 0.0000881, + 0.0020084, 0.1782536, 0.1902134, 0.2289664, -0.9612153, + -0.3646879, 1.1548834, 0.2942109, 0.0081770, -0.0017617, + -0.0007630, -0.0586071, -0.0690668, -0.0931514, 0.3587369, + 0.1414263, -0.5123905, -0.2375736, 0.7686428, 0.4247497}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{43.554777, 24.422389, 19.822464, 14.199502, + 10.868032, 7.213810, 4.653229}, + std::vector{3, 3, 4, 4, 4, 4, 4}, + std::vector{ + 0.0042963, 0.4343149, 0.4830166, 0.1584186, 0.0001377, + 0.0020536, 0.0000566, -0.0014923, -0.2109784, -0.2465645, + -0.0872883, 0.4951290, 0.6061138, 0.1004010}, + std::vector{5, 5}, std::vector{5, 5}), + SlaterTypeAtomicShell( + 3, + std::vector{21.379996, 12.494944, 8.057008, 5.103958, + 3.112255, 1.898043}, + std::vector{4, 4, 4, 4, 4, 4}, + std::vector{0.0215569, 0.2134226, 0.3801615, 0.3618109, + 0.1988927, 0.0477029}, + std::vector{7}, std::vector{6})})}, + {70, + SlaterTypeAtom( + 70, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Yb + * + * Etot=-13391.456011419 Ekin=13391.456004461 + */ + SlaterTypeAtomicShell( + 0, + std::vector{87.352555, 68.693248, 56.955480, 32.933882, + 30.102689, 19.971201, + 16.452439, 8.583422, 6.835797, 3.307811, + 2.392500, + 0.943977, + 0.661442}, + std::vector{1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0549290, 0.9418238, 0.0046308, 0.0022641, -0.0016239, + 0.0012787, -0.0008808, 0.0002803, -0.0001872, 0.0000450, + -0.0000259, 0.0000065, -0.0000037, 0.0167699, -0.3616179, + -0.2459661, 1.1081762, 0.1514344, 0.0112489, -0.0041856, + 0.0003093, -0.0002793, 0.0000720, -0.0000364, 0.0000090, + -0.0000051, -0.0059576, 0.1662702, 0.1291897, -0.5664495, + -0.4090233, 0.3872147, 0.9572081, 0.0401699, -0.0159956, + 0.0022075, -0.0012057, 0.0002710, -0.0001517, 0.0011190, + -0.0775525, -0.0667207, 0.2838694, 0.2131653, 0.1647104, + -1.3432210, 0.9508381, 0.4818862, 0.0071813, -0.0014008, + 0.0002435, -0.0001272, -0.0008872, 0.0292132, 0.0237863, + -0.1031639, -0.0833987, -0.0907385, 0.5792017, -0.3444946, + -0.5405242, 0.8180796, 0.4334979, -0.0009986, 0.0005900, + 0.0000427, -0.0067844, -0.0060366, 0.0254316, 0.0188934, + 0.0268814, -0.1465111, 0.0879407, 0.1375085, -0.2055766, + -0.2151780, 0.6397761, 0.4572937}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{63.020058, 36.488320, 32.197498, 25.055410, + 18.221343, 12.943284, 8.468270, 6.924058, + 2.933562, 1.939912}, + std::vector{2, 2, 3, 4, 3, 3, 3, 4, 3, 3}, + std::vector{ + -0.0095943, -0.7619618, -0.2553492, -0.0186672, 0.0110206, + -0.0028627, 0.0009302, -0.0002145, 0.0000436, -0.0000172, + -0.0032402, -0.3817906, -0.2678048, -0.1033437, 1.1127560, + 0.2185524, -0.0045317, 0.0019558, -0.0002431, 0.0000900, + 0.0019622, 0.1792671, 0.1914424, 0.2283450, -0.9749620, + -0.3511139, 1.1577139, 0.2899645, 0.0079605, -0.0016886, + -0.0007424, -0.0585690, -0.0689512, -0.0917991, 0.3604070, + 0.1366692, -0.5118509, -0.2316146, 0.7618048, 0.4294879}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{44.380596, 24.846977, 20.192372, 14.457411, + 11.032791, 7.328845, 4.721620}, + std::vector{3, 3, 4, 4, 4, 4, 4}, + std::vector{ + 0.0041230, 0.4346080, 0.4834056, 0.1576035, -0.0000537, + 0.0021169, 0.0000638, -0.0014343, -0.2116265, -0.2488589, + -0.0811826, 0.4992367, 0.6007440, 0.0979458}, + std::vector{5, 5}, std::vector{5, 5}), + SlaterTypeAtomicShell( + 3, + std::vector{21.813503, 12.812141, 8.292375, 5.253542, + 3.193592, 1.935523}, + std::vector{4, 4, 4, 4, 4, 4}, + std::vector{0.0212805, 0.2118029, 0.3779314, 0.3633646, + 0.2009939, 0.0489053}, + std::vector{7}, std::vector{7})})}, + {71, + SlaterTypeAtom( + 71, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Lu + * + * Etot=-13851.807781166 Ekin=13851.807792702 + */ + SlaterTypeAtomicShell( + 0, + std::vector{88.158050, 69.634798, 57.735491, 33.352021, + 30.451377, 20.515313, + 16.747706, 8.641112, 6.885200, 3.414551, + 2.490551, + 1.042682, + 0.714282}, + std::vector{1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0576387, 0.9394633, 0.0041575, 0.0023438, -0.0017115, + 0.0013103, -0.0008633, 0.0002871, -0.0001989, 0.0000527, + -0.0000308, 0.0000075, -0.0000039, 0.0175358, -0.3631523, + -0.2462672, 1.1156124, 0.1444666, 0.0103281, -0.0035161, + 0.0002214, -0.0002304, 0.0000694, -0.0000355, 0.0000084, + -0.0000044, -0.0061864, 0.1671104, 0.1298612, -0.5718910, + -0.4147604, 0.3794722, 0.9751955, 0.0404550, -0.0170584, + 0.0026226, -0.0014475, 0.0003134, -0.0001612, 0.0011281, + -0.0780593, -0.0673942, 0.2877386, 0.2154299, 0.1527775, + -1.3356485, 1.0165279, 0.4144969, 0.0065050, -0.0011621, + 0.0001953, -0.0000910, -0.0008980, 0.0300289, 0.0246178, + -0.1070141, -0.0859171, -0.0878742, 0.5894331, -0.3795159, + -0.5440145, 0.8646575, 0.4084402, -0.0001496, 0.0002725, + 0.0001001, -0.0074363, -0.0064745, 0.0275966, 0.0209398, + 0.0262656, -0.1556477, 0.0986737, 0.1517480, -0.2360099, + -0.2254036, 0.5962871, 0.5160913}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{63.903538, 37.008976, 32.687216, 25.543805, + 18.549954, 13.120080, 8.701682, 7.137705, + 3.013129, 2.003340}, + std::vector{2, 2, 3, 4, 3, 3, 3, 4, 3, 3}, + std::vector{ + -0.0095090, -0.7636049, -0.2534685, -0.0182926, 0.0105918, + -0.0028147, 0.0009634, -0.0002176, 0.0000424, -0.0000170, + -0.0032247, -0.3834107, -0.2696530, -0.1052442, 1.1188188, + 0.2181627, -0.0060900, 0.0022206, -0.0002813, 0.0001016, + 0.0019176, 0.1808822, 0.1919663, 0.2230951, -0.9702328, + -0.3707397, 1.1592111, 0.3057180, 0.0080667, -0.0017811, + -0.0007453, -0.0609848, -0.0719194, -0.0950623, 0.3755839, + 0.1434042, -0.5233215, -0.2583804, 0.8252859, 0.3776873}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{36.177588, 22.585179, 18.486867, 11.757966, + 8.137374, 5.658663, 3.305766, 1.885996, + 1.068929}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4}, + std::vector{ + 0.0231651, 0.5665592, 0.4308225, 0.0576575, -0.0106848, + 0.0040573, -0.0008520, 0.0003061, -0.0000919, -0.0098965, + -0.2801740, -0.2340335, 0.3727748, 0.6030118, 0.1974776, + 0.0070434, -0.0003280, 0.0001115, 0.0018859, 0.0567396, + 0.0477682, -0.0887625, -0.1436141, -0.0376242, 0.3235841, + 0.5505619, 0.3110526}, + std::vector{5, 5, 1}, std::vector{5, 5, 0}), + SlaterTypeAtomicShell( + 3, + std::vector{22.312950, 13.203800, 8.660479, 5.596255, + 3.496657, 2.185855}, + std::vector{4, 4, 4, 4, 4, 4}, + std::vector{0.0210973, 0.2095382, 0.3716656, 0.3644870, + 0.1974277, 0.0408131}, + std::vector{7}, std::vector{7})})}, + {72, + SlaterTypeAtom( + 72, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Hf + * + * Etot=-14321.249598927 Ekin=14321.249546528 + */ + SlaterTypeAtomicShell( + 0, + std::vector{89.099347, 70.595058, 58.530393, 33.759966, + 30.773278, 21.051322, + 17.029709, 8.701558, 6.910123, 3.575255, + 2.615632, + 1.108804, + 0.745946}, + std::vector{1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0593139, 0.9380112, 0.0038582, 0.0023776, -0.0017756, + 0.0013330, -0.0008402, 0.0002913, -0.0002098, 0.0000614, + -0.0000346, 0.0000078, -0.0000039, 0.0181258, -0.3643254, + -0.2466302, 1.1234995, 0.1369382, 0.0093819, -0.0029128, + 0.0001369, -0.0001807, 0.0000647, -0.0000315, 0.0000069, + -0.0000034, -0.0062930, 0.1677130, 0.1306699, -0.5778613, + -0.4214634, 0.3801780, 0.9864267, 0.0402284, -0.0178359, + 0.0030870, -0.0016332, 0.0003241, -0.0001592, 0.0011268, + -0.0785363, -0.0680805, 0.2918173, 0.2185992, 0.1371865, + -1.3270031, 1.0890100, 0.3415474, 0.0056986, -0.0006965, + 0.0001214, -0.0000516, -0.0008874, 0.0307620, 0.0254374, + -0.1108356, -0.0885928, -0.0834064, 0.5983667, -0.4195729, + -0.5495651, 0.8698370, 0.4330566, 0.0009648, -0.0001201, + 0.0001295, -0.0078179, -0.0067590, 0.0290275, 0.0222613, + 0.0249158, -0.1603694, 0.1091008, 0.1614450, -0.2485256, + -0.2348173, 0.5762309, 0.5417487}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{64.972139, 37.551689, 33.182576, 26.023296, + 18.862732, 13.291252, 8.935252, 7.356536, + 3.121242, 2.075235}, + std::vector{2, 2, 3, 4, 3, 3, 3, 4, 3, 3}, + std::vector{ + -0.0092422, -0.7645456, -0.2525927, -0.0176393, 0.0098567, + -0.0026615, 0.0009600, -0.0002111, 0.0000389, -0.0000156, + -0.0031320, -0.3846335, -0.2710027, -0.1042114, 1.1221942, + 0.2167617, -0.0076668, 0.0024633, -0.0003136, 0.0001076, + 0.0018434, 0.1823390, 0.1923718, 0.2172157, -0.9668551, + -0.3884827, 1.1618042, 0.3203760, 0.0082773, -0.0017903, + -0.0007320, -0.0631584, -0.0746601, -0.0979404, 0.3906723, + 0.1478441, -0.5318386, -0.2871176, 0.8638762, 0.3533917}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{37.087770, 23.120798, 18.932868, 12.064253, + 8.406485, 5.915269, 3.542840, 2.089406, + 1.221170}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4}, + std::vector{ + 0.0211120, 0.5594538, 0.4371224, 0.0616689, -0.0122587, + 0.0047823, -0.0010781, 0.0003847, -0.0001112, -0.0090204, + -0.2785030, -0.2399802, 0.3585662, 0.6033008, 0.2090239, + 0.0081207, -0.0004134, 0.0001408, 0.0019523, 0.0632842, + 0.0554542, -0.0978792, -0.1583776, -0.0579027, 0.3372681, + 0.5642177, 0.2764801}, + std::vector{5, 5, 2}, std::vector{5, 5, 0}), + SlaterTypeAtomicShell( + 3, + std::vector{22.572535, 13.324140, 8.629242, 5.567960, + 3.525177, 2.245564}, + std::vector{4, 4, 4, 4, 4, 4}, + std::vector{0.0225000, 0.2288594, 0.3954364, 0.3557229, + 0.1652271, 0.0229193}, + std::vector{7}, std::vector{7})})}, + {73, + SlaterTypeAtom( + 73, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ta + * + * Etot=-14799.812390171 Ekin=14799.812372155 + */ + SlaterTypeAtomicShell( + 0, + std::vector{90.555103, 71.629551, 59.404889, 34.177342, + 31.149791, 21.516317, + 17.314435, 8.785183, 6.954670, 3.759950, + 2.747928, + 1.161882, + 0.770646}, + std::vector{1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0567981, 0.9403201, 0.0041386, 0.0022758, -0.0017404, + 0.0012991, -0.0007993, 0.0002883, -0.0002159, 0.0000681, + -0.0000363, 0.0000075, -0.0000037, 0.0178020, -0.3638414, + -0.2471379, 1.1291387, 0.1308367, 0.0090526, -0.0026854, + 0.0001092, -0.0001667, 0.0000666, -0.0000304, 0.0000062, + -0.0000030, -0.0061247, 0.1677265, 0.1312004, -0.5819079, + -0.4266372, 0.3815128, 0.9937583, 0.0405307, -0.0188737, + 0.0036098, -0.0017927, 0.0003258, -0.0001556, 0.0011110, + -0.0788913, -0.0684995, 0.2947295, 0.2218121, 0.1287125, + -1.3260955, 1.1468343, 0.2841795, 0.0054914, -0.0004315, + 0.0000951, -0.0000385, -0.0008554, 0.0313989, 0.0261277, + -0.1141016, -0.0912585, -0.0819476, 0.6100448, -0.4503988, + -0.5680611, 0.8619316, 0.4752824, 0.0018234, -0.0003877, + 0.0001409, -0.0080830, -0.0069715, 0.0300936, 0.0232809, + 0.0244529, -0.1646856, 0.1167050, 0.1729182, -0.2544259, + -0.2455030, 0.5663814, 0.5538834}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{65.874762, 38.086014, 33.684651, 26.517276, + 19.188001, 13.458863, 9.170764, 7.578027, + 3.241023, 2.154956}, + std::vector{2, 2, 3, 4, 3, 3, 3, 4, 3, 3}, + std::vector{ + -0.0091316, -0.7655184, -0.2514418, -0.0173825, 0.0095100, + -0.0026350, 0.0010025, -0.0002177, 0.0000384, -0.0000153, + -0.0031103, -0.3858427, -0.2728045, -0.1056497, 1.1275494, + 0.2166180, -0.0096886, 0.0027781, -0.0003580, 0.0001168, + 0.0018059, 0.1838251, 0.1931644, 0.2130961, -0.9648948, + -0.4084622, 1.1666177, 0.3341146, 0.0086087, -0.0017971, + -0.0007296, -0.0652326, -0.0772562, -0.1005102, 0.4040978, + 0.1537052, -0.5401288, -0.3158948, 0.8898631, 0.3423313}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{37.575996, 23.498893, 19.288357, 12.337771, + 8.617462, 6.109997, 3.734351, 2.242696, + 1.328980}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4}, + std::vector{ + 0.0211239, 0.5597205, 0.4353746, 0.0629273, -0.0127969, + 0.0051271, -0.0012124, 0.0004205, -0.0001175, -0.0090616, + -0.2808052, -0.2418178, 0.3538458, 0.6079660, 0.2086217, + 0.0082707, -0.0003994, 0.0001384, 0.0021282, 0.0689308, + 0.0606280, -0.1056734, -0.1711138, -0.0713431, 0.3548692, + 0.5700377, 0.2540052}, + std::vector{5, 5, 3}, std::vector{5, 5, 0}), + SlaterTypeAtomicShell( + 3, + std::vector{23.099473, 13.699995, 8.927752, 5.810732, + 3.709864, 2.355401}, + std::vector{4, 4, 4, 4, 4, 4}, + std::vector{0.0220510, 0.2279771, 0.3971811, 0.3598951, + 0.1554254, 0.0165094}, + std::vector{7}, std::vector{7})})}, + {74, + SlaterTypeAtom( + 74, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for W + * + * Etot=-15287.546162469 Ekin=15287.546102582 + */ + SlaterTypeAtomicShell( + 0, + std::vector{91.755953, 72.626980, 60.237715, 34.604318, + 31.511899, 21.938006, + 17.586218, 8.892417, 7.033853, 3.956290, + 2.878493, + 1.206903, + 0.791160}, + std::vector{1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0563746, 0.9407545, 0.0041240, 0.0022443, -0.0017492, + 0.0013089, -0.0007912, 0.0002976, -0.0002311, 0.0000761, + -0.0000379, 0.0000073, -0.0000035, 0.0179315, -0.3641739, + -0.2476125, 1.1346802, 0.1254240, 0.0085821, -0.0024650, + 0.0000847, -0.0001547, 0.0000671, -0.0000283, 0.0000055, + -0.0000026, -0.0060883, 0.1680118, 0.1318742, -0.5862267, + -0.4322737, 0.3903929, 0.9939518, 0.0408103, -0.0198406, + 0.0040284, -0.0018574, 0.0003118, -0.0001464, 0.0011494, + -0.0793836, -0.0689624, 0.2977056, 0.2259587, 0.1180749, + -1.3257672, 1.1897745, 0.2430628, 0.0059449, -0.0003658, + 0.0001010, -0.0000408, -0.0008679, 0.0320888, 0.0267751, + -0.1172269, -0.0944222, -0.0790656, 0.6209382, -0.4689246, + -0.6005327, 0.8520441, 0.5216925, 0.0024821, -0.0005842, + 0.0001551, -0.0083004, -0.0071409, 0.0309572, 0.0242500, + 0.0235910, -0.1679155, 0.1202830, 0.1874570, -0.2581941, + -0.2551460, 0.5606967, 0.5601529}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{66.950836, 38.643624, 34.200713, 27.033162, + 19.511957, 13.606262, 9.466379, 7.833344, + 3.362330, 2.236298}, + std::vector{2, 2, 3, 4, 3, 3, 3, 4, 3, 3}, + std::vector{ + -0.0088709, -0.7656930, -0.2512816, -0.0170537, 0.0090132, + -0.0025931, 0.0010549, -0.0002184, 0.0000360, -0.0000145, + -0.0030309, -0.3865866, -0.2747749, -0.1065712, 1.1323161, + 0.2171661, -0.0127777, 0.0032033, -0.0004092, 0.0001284, + 0.0017307, 0.1851489, 0.1931407, 0.2057719, -0.9560905, + -0.4433922, 1.1720459, 0.3598858, 0.0092493, -0.0018751, + -0.0007074, -0.0671632, -0.0793745, -0.1015169, 0.4142291, + 0.1641555, -0.5438365, -0.3508431, 0.9098035, 0.3360113}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{38.504169, 24.042791, 19.742726, 12.667783, + 8.915037, 6.384653, 3.919845, 2.382645, + 1.423574}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4}, + std::vector{ + 0.0192155, 0.5523440, 0.4415082, 0.0672031, -0.0142263, + 0.0056715, -0.0013207, 0.0004539, -0.0001242, -0.0082510, + -0.2789670, -0.2479188, 0.3360111, 0.6086477, 0.2234136, + 0.0094148, -0.0005802, 0.0001644, 0.0020672, 0.0726445, + 0.0662618, -0.1081430, -0.1802547, -0.0888698, 0.3701479, + 0.5737241, 0.2386444}, + std::vector{5, 5, 4}, std::vector{5, 5, 0}), + SlaterTypeAtomicShell( + 3, + std::vector{23.482851, 13.966058, 9.123084, 6.021852, + 3.920505, 2.515460}, + std::vector{4, 4, 4, 4, 4, 4}, + std::vector{0.0224768, 0.2342310, 0.4001271, 0.3529661, + 0.1452384, 0.0142784}, + std::vector{7}, std::vector{7})})}, + {75, + SlaterTypeAtom( + 75, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Re + * + * Etot=-15784.532983147 Ekin=15784.533014053 + */ + SlaterTypeAtomicShell( + 0, + std::vector{92.339350, 73.536027, 60.962814, 35.060807, + 31.839262, 22.365935, + 17.850392, 9.008373, 7.134456, 4.172463, + 3.011416, + 1.244577, + .807746}, + std::vector{1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + .0608749, .9367511, .0034534, .0023651, -.0018646, + .0014001, -.0008264, .0003256, -.0002623, .0000883, + -.0000405, .0000073, -.0000035, .0192109, -.3665220, + -.2481520, 1.1399561, .1219206, .0074216, -.0019718, + -.0000052, -.0000924, .0000505, -.0000182, .0000034, + -.0000016, -.0064404, .1690527, .1328665, -.5909589, + -.4403300, .4040010, .9915362, .0410669, -.0208435, + .0043834, -.0018423, .0002864, -.0001334, .0012762, + -.0801299, -.0696831, .3010568, .2312138, .1045431, + -1.3244010, 1.2274202, .2074168, .0071896, -.0004726, + .0001308, -.0000543, -.0009445, .0328811, .0274705, + -.1203448, -.0980775, -.0743190, .6301334, -.4796200, + -.6433998, .8367429, .5769620, .0031160, -.0007880, + .0001750, -.0084767, -.0072893, .0316391, .0251350, + .0222123, -.1697214, .1209492, .2037938, -.2580699, + -.2655703, .5556794, .5641748}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{67.926990, 39.178277, 34.698572, 27.543233, + 19.862335, 13.806206, + 9.729731, 8.070798, 3.490619, 2.324200}, + std::vector{2, 2, 3, 4, 3, 3, 3, 4, 3, 3}, + std::vector{ + .0087133, .7667356, .2501406, .0167272, -.0086089, + .0025370, -.0010798, .0002179, -.0000341, .0000138, + -.0029910, -.3877729, -.2774777, -.1104203, 1.1371397, + .2211445, -.0152577, .0035462, -.0004565, .0001373, + .0016831, .1866740, .1943937, .2026724, -.9504868, + -.4736898, 1.1779038, .3778104, .0098565, -.0019205, + -.0006958, -.0690519, -.0817402, -.1032476, .4231178, + .1743824, -.5488668, -.3813638, .9217272, .3380931}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{40.024199, 24.780256, 20.314071, 13.074404, + 9.341177, 6.767067, 4.115949, 2.531393, + 1.525586}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4}, + std::vector{.0154979, .5364331, .4555213, .0756556, + -.0169360, .0064777, -.0014048, .0004941, + -.0001329, -.0066257, -.2724478, -.2581266, + .3004991, .5999957, .2622232, .0120350, + -.0011158, .0001970, .0017658, .0744329, + .0728879, -.1042631, -.1833925, -.1152684, + .3770492, .5791345, .2292808}, + std::vector{5, 5, 5}, std::vector{5, 5, 0}), + SlaterTypeAtomicShell( + 3, + std::vector{24.113043, 14.483275, 9.678188, 6.537670, + 4.313282, 2.781860}, + std::vector{4, 4, 4, 4, 4, 4}, + std::vector{.0212201, .2202679, .3761031, .3647516, + .1610614, .0176338}, + std::vector{7}, std::vector{7})})}, + {76, + SlaterTypeAtom( + 76, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Os + * + * Etot=-16290.648385123 Ekin=16290.648421149 + */ + SlaterTypeAtomicShell( + 0, + std::vector{94.092123, 74.612868, 61.895874, 35.501252, + 32.311264, 22.659050, + 18.132147, 9.140779, 7.303703, 4.343471, + 3.121391, + 1.290204, + .828961}, + std::vector{1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + .0560322, .9411707, .0040197, .0022058, -.0017615, + .0013422, -.0008061, .0003351, -.0002764, .0000907, + -.0000397, .0000069, -.0000033, .0182442, -.3649413, + -.2485958, 1.1423518, .1183385, .0080215, -.0022939, + .0000781, -.0001594, .0000716, -.0000260, .0000047, + -.0000022, -.0061114, .1687129, .1329852, -.5923818, + -.4409395, .4082128, .9886494, .0431779, -.0230068, + .0047499, -.0019029, .0002848, -.0001303, .0013047, + -.0804974, -.0697031, .3022726, .2342012, .1060591, + -1.3352689, 1.2510503, .1858637, .0092924, -.0008707, + .0001859, -.0000771, -.0009591, .0334977, .0278678, + -.1225459, -.1010020, -.0764847, .6450788, -.4725326, + -.6945430, .8479381, .5964143, .0033887, -.0008317, + .0001916, -.0086843, -.0074008, .0322926, .0260813, + .0227584, -.1742512, .1166296, .2249225, -.2687433, + -.2689985, .5538469, .5677691}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{68.850122, 39.720013, 35.210952, 28.070224, + 20.211146, 14.001487, + 10.007660, 8.311499, 3.613318, 2.404538}, + std::vector{2, 2, 3, 4, 3, 3, 3, 4, 3, 3}, + std::vector{ + .0085965, .7673270, .2493593, .0166413, -.0083861, + .0025608, -.0011390, .0002232, -.0000330, .0000136, + -.0029679, -.3887157, -.2799362, -.1137471, 1.1411105, + .2254400, -.0181768, .0039013, -.0005007, .0001449, + .0016421, .1881006, .1951698, .1984445, -.9426703, + -.5088358, 1.1866300, .3972597, .0104369, -.0019585, + -.0006856, -.0709106, -.0837720, -.1039109, .4298548, + .1874653, -.5547657, -.4125104, .9402133, .3331557}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{40.756046, 25.241086, 20.717645, 13.383221, + 9.576954, 6.964384, 4.270338, 2.617713, + 1.568701}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4}, + std::vector{.0147734, .5332993, .4571810, .0779981, + -.0174478, .0066873, -.0014442, .0004824, + -.0001297, -.0063355, -.2727412, -.2619103, + .2909107, .6086471, .2626230, .0118827, + -.0008396, .0002420, .0017451, .0774501, + .0768707, -.1055065, -.1940807, -.1257365, + .4032371, .5725606, .2204363}, + std::vector{5, 5, 5}, std::vector{5, 5, 1}), + SlaterTypeAtomicShell( + 3, + std::vector{24.530200, 14.751454, 9.837503, 6.692180, + 4.453285, 2.851061}, + std::vector{4, 4, 4, 4, 4, 4}, + std::vector{.0213856, .2266958, .3843619, .3600703, + .1479496, .0132543}, + std::vector{7}, std::vector{7})})}, + {77, + SlaterTypeAtom( + 77, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ir + * + * Etot=-16806.11293237 Ekin=16806.112983194 + */ + SlaterTypeAtomicShell( + 0, + std::vector{95.032583, 75.575655, 62.684408, 35.958786, + 32.687170, 23.004698, + 18.395302, 9.285849, 7.566137, 4.491834, + 3.226227, + 1.331963, + 0.847928}, + std::vector{1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0575478, 0.9398472, 0.0037623, 0.0022281, -0.0017968, + 0.0013880, -0.0008335, 0.0003797, -0.0003174, 0.0000943, + -0.0000405, 0.0000069, -0.0000032, 0.0188356, -0.3660565, + -0.2491259, 1.1461907, 0.1154383, 0.0074219, -0.0020932, + 0.0000516, -0.0001412, 0.0000634, -0.0000219, 0.0000038, + -0.0000018, -0.0062462, 0.1692949, 0.1337239, -0.5958096, + -0.4463345, 0.4224641, 0.9817089, 0.0456034, -0.0253761, + 0.0046183, -0.0018146, 0.0002607, -0.0001175, 0.0014064, + -0.0811286, -0.0702059, 0.3048080, 0.2390473, 0.0973735, + -1.3393999, 1.2621349, 0.1770200, 0.0124722, -0.0015888, + 0.0002723, -0.0001132, -0.0010843, 0.0342940, 0.0283241, + -0.1249572, -0.1051792, -0.0719112, 0.6537300, -0.4328908, + -0.7636726, 0.8523744, 0.6094617, 0.0037408, -0.0009311, + 0.0002313, -0.0088831, -0.0074879, 0.0328172, 0.0271978, + 0.0213428, -0.1760109, 0.1012082, 0.2503733, -0.2752393, + -0.2685050, 0.5479532, 0.5742112}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{70.152737, 40.345105, 35.784105, 28.613630, + 20.480824, 14.033605, 10.321772, 8.552420, + 3.740117, 2.489419}, + std::vector{2, 2, 3, 4, 3, 3, 3, 4, 3, 3}, + std::vector{ + 0.0081514, 0.7648176, 0.2521346, 0.0164528, -0.0077627, + 0.0025114, -0.0012187, 0.0002196, -0.0000299, 0.0000125, + -0.0028196, -0.3879687, -0.2802834, -0.1084036, 1.1435486, + 0.2224297, -0.0246838, 0.0045298, -0.0005710, 0.0001600, + 0.0015418, 0.1886968, 0.1941492, 0.1892031, -0.9405451, + -0.5539556, 1.2171566, 0.4181399, 0.0110103, -0.0019747, + -0.0006495, -0.0723548, -0.0845182, -0.1010856, 0.4359814, + 0.2049897, -0.5678673, -0.4443678, 0.9524221, 0.3342233}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{41.611811, 25.711049, 21.115165, 13.665803, + 9.750244, 7.096141, 4.480287, 2.743124, + 1.639544}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4}, + std::vector{ + 0.0138156, 0.5303204, 0.4595620, 0.0795686, -0.0178901, + 0.0071068, -0.0016453, 0.0005016, -0.0001317, -0.0059367, + -0.2730441, -0.2660764, 0.2879990, 0.6260528, 0.2484066, + 0.0110728, -0.0003291, 0.0002058, 0.0016946, 0.0802993, + 0.0810360, -0.1091198, -0.2059996, -0.1372111, 0.4154586, + 0.5746340, 0.2194030}, + std::vector{5, 5, 5}, std::vector{5, 5, 2}), + SlaterTypeAtomicShell( + 3, + std::vector{24.853136, 14.911967, 9.790906, 6.623491, + 4.425274, 2.775013}, + std::vector{4, 4, 4, 4, 4, 4}, + std::vector{0.0221288, 0.2421892, 0.4144238, 0.3445352, + 0.1168838, 0.0071534}, + std::vector{7}, std::vector{7})})}, + {78, + SlaterTypeAtom( + 78, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Pt + * + * Etot=-17331.069712924 Ekin=17331.069666319 + */ + SlaterTypeAtomicShell( + 0, + std::vector{96.326260, 76.585788, 63.520880, 36.406532, + 33.061689, 23.311950, + 18.635661, 9.434858, 7.795365, 4.597687, + 3.229778, + 1.315052, + 0.814405}, + std::vector{1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0564219, 0.9409199, 0.0038348, 0.0021731, -0.0017725, + 0.0013857, -0.0008341, 0.0004007, -0.0003332, 0.0000854, + -0.0000346, 0.0000060, -0.0000027, 0.0188347, -0.3661319, + -0.2497546, 1.1499398, 0.1121623, 0.0068843, -0.0019294, + 0.0000168, -0.0001112, 0.0000508, -0.0000154, 0.0000028, + -0.0000012, -0.0061649, 0.1694500, 0.1344304, -0.5990768, + -0.4515767, 0.4440276, 0.9679411, 0.0461103, -0.0260532, + 0.0039709, -0.0014705, 0.0002134, -0.0000959, 0.0015119, + -0.0816891, -0.0705321, 0.3069318, 0.2450292, 0.0824652, + -1.3398353, 1.2784192, 0.1657517, 0.0138817, -0.0016521, + 0.0002897, -0.0001312, -0.0011155, 0.0347209, 0.0286654, + -0.1266740, -0.1085978, -0.0658450, 0.6587665, -0.4004553, + -0.8189454, 0.9091481, 0.5691530, 0.0036314, -0.0011112, + 0.0003141, -0.0082844, -0.0066957, 0.0297998, 0.0262673, + 0.0156943, -0.1581776, 0.0730283, 0.2559009, -0.2880679, + -0.1989232, 0.4686110, 0.6365237}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 0}), + SlaterTypeAtomicShell( + 1, + std::vector{71.132349, 40.899509, 36.308364, 29.162881, + 20.835297, 14.228098, 10.647981, 8.812642, + 3.881013, 2.545074}, + std::vector{2, 2, 3, 4, 3, 3, 3, 4, 3, 3}, + std::vector{ + 0.0080028, 0.7649351, 0.2518587, 0.0164634, -0.0075913, + 0.0025906, -0.0013155, 0.0002246, -0.0000282, 0.0000120, + -0.0027812, -0.3886250, -0.2828016, -0.1118545, 1.1462945, + 0.2295579, -0.0293458, 0.0049111, -0.0006004, 0.0001504, + 0.0014955, 0.1899808, 0.1947511, 0.1846430, -0.9299511, + -0.6060208, 1.2340786, 0.4443816, 0.0116953, -0.0017708, + -0.0006284, -0.0734491, -0.0855462, -0.1001655, 0.4365823, + 0.2217194, -0.5672633, -0.4753283, 0.9420593, 0.3567214}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{42.292119, 26.205977, 21.565757, 14.108561, + 10.150504, 7.418553, 4.495700, 2.690771, + 1.553534}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4}, + std::vector{ + 0.0132242, 0.5249554, 0.4609842, 0.0839452, -0.0173010, + 0.0063002, -0.0012098, 0.0003620, -0.0001024, -0.0057286, + -0.2719710, -0.2701972, 0.2564342, 0.6251140, 0.2788872, + 0.0119996, -0.0002754, 0.0004127, 0.0016021, 0.0798355, + 0.0817939, -0.0964965, -0.2107496, -0.1374803, 0.4537196, + 0.5480134, 0.2178775}, + std::vector{5, 5, 5}, std::vector{5, 5, 4}), + SlaterTypeAtomicShell( + 3, + std::vector{25.359777, 15.274529, 10.107702, 6.937964, + 4.649549, 2.821879}, + std::vector{4, 4, 4, 4, 4, 4}, + std::vector{0.0216615, 0.2402114, 0.4073683, 0.3475160, + 0.1182301, 0.0072572}, + std::vector{7}, std::vector{7})})}, + {79, + SlaterTypeAtom( + 79, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Au + * + * Etot=-17865.399825117 Ekin=17865.399642111 + */ + SlaterTypeAtomicShell( + 0, + std::vector{97.761363, 77.616148, 64.400892, 36.850898, + 33.489537, 23.594782, + 18.894147, 9.575477, 8.034410, 4.758171, + 3.330133, + 1.328966, + .813779}, + std::vector{1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + .0543021, .9428745, .0040559, .0020902, -.0017218, + .0013678, -.0008352, .0004369, -.0003686, .0000857, + -.0000332, .0000054, -.0000025, .0184536, -.3655835, + -.2501566, 1.1528366, .1088843, .0069891, -.0020457, + .0000622, -.0001485, .0000571, -.0000168, .0000029, + -.0000013, -.0059880, .1694183, .1347860, -.6013187, + -.4539311, .4579027, .9578920, .0487899, -.0287839, + .0039194, -.0013915, .0001906, -.0000847, .0015601, + -.0821448, -.0707136, .3086211, .2492703, .0763151, + -1.3464690, 1.3024738, .1453872, .0162429, -.0019199, + .0003148, -.0001349, -.0011655, .0353116, .0290014, + -.1286260, -.1121056, -.0632900, .6687089, -.3554815, + -.8961654, .9132912, .5859752, .0039779, -.0006598, + .0003138, -.0081410, -.0065495, .0292497, .0262101, + .0145596, -.1551612, .0544673, .2735870, -.2848893, + -.1892946, .4556329, .6453387}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 0}), + SlaterTypeAtomicShell( + 1, + std::vector{72.250241, 41.486656, 36.856869, 29.730268, + 21.210778, 14.475122, + 10.912089, 9.042813, 4.012662, 2.634539}, + std::vector{2, 2, 3, 4, 3, 3, 3, 4, 3, 3}, + std::vector{ + .0077449, .7638459, .2529503, .0164249, -.0072231, + .0024886, -.0012906, .0002131, -.0000245, .0000109, + -.0027189, -.3885513, -.2865510, -.1174461, 1.1486521, + .2380258, -.0324829, .0052408, -.0006499, .0001571, + .0014393, .1908883, .1961952, .1824186, -.9201386, + -.6438703, 1.2469365, .4580559, .0123820, -.0017885, + -.0006084, -.0748442, -.0872579, -.1000962, .4381126, + .2382120, -.5746359, -.5016528, .9473055, .3639469}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{43.833656, 26.923095, 22.141347, 14.590183, + 10.636243, 7.807086, 4.671112, 2.813334, + 1.632420}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4}, + std::vector{.0107826, .5107522, .4705240, .0930676, + -.0188622, .0064919, -.0011401, .0003642, + -.0000945, -.0046522, -.2660895, -.2778470, + .2150605, .6142858, .3253332, .0140492, + -.0011867, .0002807, .0013473, .0801907, + .0867188, -.0858641, -.2105302, -.1644004, + .4600836, .5493649, .2129632}, + std::vector{5, 5, 5}, std::vector{5, 5, 5}), + SlaterTypeAtomicShell( + 3, + std::vector{25.916349, 15.690312, 10.503734, 7.320309, + 4.940163, 3.007791}, + std::vector{4, 4, 4, 4, 4, 4}, + std::vector{.0208736, .2340553, .3940648, .3548888, + .1253131, .0078850}, + std::vector{7}, std::vector{7})})}, + {80, + SlaterTypeAtom( + 80, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Hg + * + * Etot=-18408.991254661 Ekin=18408.991325992 + */ + SlaterTypeAtomicShell( + 0, + std::vector{98.407393, 78.536315, 65.150893, 37.330051, + 33.891651, 23.937157, + 19.164856, 9.688704, 8.234789, 5.007613, + 3.538904, + 1.429284, + .889673}, + std::vector{1, 1, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + .0579610, .9396339, .0034806, .0022126, -.0018310, + .0014765, -.0009038, .0005319, -.0004669, .0001088, + -.0000408, .0000063, -.0000029, .0194801, -.3674712, + -.2505531, 1.1554335, .1076018, .0064621, -.0018700, + .0000330, -.0001321, .0000568, -.0000156, .0000026, + -.0000012, -.0063260, .1703640, .1353694, -.6037821, + -.4588287, .4677998, .9536886, .0528794, -.0333178, + .0045738, -.0015571, .0001996, -.0000884, .0017158, + -.0829030, -.0712106, .3108227, .2536265, .0716950, + -1.3535425, 1.3570118, .0914619, .0208747, -.0026074, + .0003808, -.0001569, -.0013031, .0362685, .0296133, + -.1314979, -.1162904, -.0616309, .6825517, -.3165944, + -.9896312, .8675572, .6694894, .0040119, -.0009913, + .0002967, -.0092173, -.0076291, .0337279, .0296292, + .0180210, -.1795999, .0516334, .3312508, -.2900936, + -.2681278, .5425470, .5775647}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{73.351279, 42.080191, 37.417209, 30.282585, + 21.476918, 14.469768, + 11.281557, 9.281333, 4.128865, 2.755971}, + std::vector{2, 2, 3, 4, 3, 3, 3, 4, 3, 3}, + std::vector{ + .0075136, .7624465, .2542785, .0165738, -.0070305, + .0027227, -.0015470, .0002295, -.0000261, .0000118, + -.0026374, -.3884233, -.2859315, -.1117375, 1.1502851, + .2404704, -.0441605, .0058860, -.0007330, .0001864, + .0013778, .1917436, .1950097, .1740701, -.9187055, + -.7318203, 1.3194948, .4795723, .0132060, -.0020977, + -.0005876, -.0767222, -.0882093, -.0975212, .4453609, + .2750105, -.6064221, -.5367627, .9708366, .3524783}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{45.619372, 27.639683, 22.702681, 14.977821, + 11.080054, 8.180613, 4.964891, 3.064010, + 1.838315}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4}, + std::vector{.0085415, .4974644, .4798983, .1024998, + -.0224210, .0075717, -.0013650, .0004448, + -.0001132, -.0036231, -.2606256, -.2843293, + .1842863, .5966800, .3659305, .0178022, + -.0016043, .0003513, .0011554, .0829471, + .0947075, -.0835224, -.2062859, -.2089329, + .4474578, .5721079, .2025146}, + std::vector{5, 5, 5}, std::vector{5, 5, 5}), + SlaterTypeAtomicShell( + 3, + std::vector{26.289706, 15.957370, 10.811471, 7.904799, + 5.582508, 3.629353}, + std::vector{4, 4, 4, 4, 4, 4}, + std::vector{.0211615, .2376280, .3651802, .3305479, + .1606072, .0167193}, + std::vector{7}, std::vector{7})})}, + {81, + SlaterTypeAtom( + 81, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Tl + * + * Etot=-18961.824641669 Ekin=18961.824692369 + */ + SlaterTypeAtomicShell( + 0, + std::vector{103.436743, 79.972778, 66.565494, + 37.786246, 34.935192, 23.854182, 19.646005, + 13.028118, 9.620853, 4.644696, 3.495830, + 1.538362, + 1.003827}, + std::vector{1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 3, 3}, + std::vector{ + .0362873, .9589419, .0066211, .0015190, -.0012862, + .0011015, -.0006941, .0003319, -.0002887, .0000517, + -.0000305, .0000058, -.0000026, -.0135523, .3574259, + .2506907, -1.1474438, -.1079625, -.0123038, .0047949, + -.0007067, .0006847, -.0001254, .0000650, -.0000119, + .0000053, -.0047341, .1674107, .1327365, -.5935397, + -.4324982, .3950645, .9966690, .0423874, -.0215247, + .0020271, -.0012026, .0002046, -.0000905, .0016226, + -.0826433, -.0689918, .3042875, .2463570, .1509260, + -1.3930532, .1038870, 1.3241911, .0216616, -.0060608, + .0007527, -.0003113, -.0004058, .0354640, .0308879, + -.1346307, -.1017426, -.1948673, .9191113, .4950242, + -1.7634271, .9924953, .4175842, .0021033, -.0003923, + -.0000267, -.0099642, -.0091753, .0393116, .0275214, + .0685918, -.2901465, -.1906808, .6068776, -.3654071, + -.2389689, .6377681, .5057159}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{75.656351, 42.807966, 38.003252, 22.085285, + 22.083330, 12.487931, 12.486752, 8.716768, + 4.389847, 3.082472, 1.207403, .752814}, + std::vector{2, 2, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + -.0064952, -.7572746, -.2559114, -.0269090, .0181179, + .0068118, -.0094842, -.0019129, .0002001, -.0000888, + .0000150, -.0000071, -.0019997, -.3871171, -.2490638, + .8688399, .2174464, -.0867369, .2037032, .0130402, + -.0009163, .0002706, -.0000415, .0000193, .0006459, + .1935249, .1318632, -.5375109, -.3238680, .4786939, + -.1209031, .8544410, .0136323, -.0025062, .0003067, + -.0001462, -.0001679, -.0794898, -.0528984, .2373849, + .1855248, -.0110430, .0787084, -1.0296244, .8817594, + .4664222, .0053703, -.0010483, .0000629, .0169105, + .0117490, -.0513271, -.0371981, .0098532, -.0283733, + .2378189, -.2194381, -.1713440, .5027994, .5933590}, + std::vector{3, 3, 3, 3, 1}, + std::vector{3, 3, 3, 3, 0}), + SlaterTypeAtomicShell( + 2, + std::vector{47.191938, 28.279271, 23.220471, 15.344936, + 11.487604, 8.518873, 5.232079, 3.290478, + 2.031593}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4}, + std::vector{.0071032, .4876249, .4858872, .1105288, + -.0255889, .0084954, -.0015683, .0005196, + -.0001307, -.0029673, -.2569474, -.2891861, + .1592499, .5824509, .3984668, .0212979, + -.0020300, .0004139, .0010243, .0859108, + .1018045, -.0811377, -.2041891, -.2474161, + .4377690, .5971334, .1872996}, + std::vector{5, 5, 5}, std::vector{5, 5, 5}), + SlaterTypeAtomicShell( + 3, + std::vector{26.929334, 16.499440, 11.444569, 7.430050, + 6.673895, 3.999648}, + std::vector{4, 4, 4, 5, 4, 4}, + std::vector{.0198621, .2204053, .3447011, -.5466218, + 1.0381904, .0224705}, + std::vector{7}, std::vector{7})})}, + {82, + SlaterTypeAtom( + 82, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Pb + * + * Etot=-19524.007861032 Ekin=19524.007912162 + */ + SlaterTypeAtomicShell( + 0, + std::vector{104.713731, 80.980311, 67.443613, + 38.232020, 35.410237, 23.936443, 19.871630, + 13.328775, 9.876587, 4.707823, 3.603001, + 1.658677, + 1.106132}, + std::vector{1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 3, 3}, + std::vector{ + .0357835, .9594008, .0066848, .0014634, -.0012352, + .0011039, -.0007232, .0003444, -.0002988, .0000554, + -.0000348, .0000070, -.0000031, -.0133949, .3572940, + .2507875, -1.1498639, -.1051112, -.0130036, .0054974, + -.0008731, .0008173, -.0001519, .0000855, -.0000161, + .0000071, -.0046674, .1675779, .1328456, -.5952044, + -.4319426, .4303434, .9616885, .0424207, -.0213589, + .0020112, -.0012768, .0002288, -.0000983, .0016673, + -.0831242, -.0690761, .3056666, .2493879, .1572893, + -1.4300343, .0444109, 1.4038909, .0245098, -.0079952, + .0009826, -.0004023, -.0005456, .0363675, .0311197, + -.1366460, -.1064756, -.2062312, .9689970, .5631927, + -1.8737720, 1.0535374, .3641069, .0019375, -.0002348, + -.0000060, -.0109998, -.0100100, .0431166, .0310454, + .0792624, -.3316759, -.2285084, .6933279, -.4056403, + -.2762494, .6948970, .4758364}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{76.554960, 43.341456, 38.511710, 22.531112, + 22.530723, 12.764238, 12.761651, 8.920439, + 4.517615, 3.250700, 1.317867, .862335}, + std::vector{2, 2, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + -.0064480, -.7581928, -.2546097, -.0271564, .0181643, + .0068604, -.0095047, -.0019622, .0002231, -.0001051, + .0000183, -.0000089, -.0019852, -.3882040, -.2489790, + .8475489, .2339482, -.0902468, .2126152, .0135810, + -.0010285, .0003307, -.0000500, .0000238, .0006398, + .1948833, .1322020, -.5216424, -.3303467, .4957004, + -.1666253, .8705878, .0148526, -.0031175, .0003677, + -.0001793, -.0001646, -.0816246, -.0539589, .2348838, + .1926048, -.0115094, .1080039, -1.0823431, .8888882, + .4730256, .0055654, -.0010837, .0000868, .0201172, + .0141512, -.0589523, -.0429587, .0195882, -.0452860, + .2847161, -.2452225, -.2310488, .6043551, .5081607}, + std::vector{3, 3, 3, 3, 2}, + std::vector{3, 3, 3, 3, 0}), + SlaterTypeAtomicShell( + 2, + std::vector{48.110533, 28.750592, 23.625068, 15.597300, + 11.717172, 8.758467, 5.493821, 3.502864, + 2.194676}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4}, + std::vector{.0066542, .4850206, .4873804, .1135528, + -.0282049, .0096674, -.0018642, .0005995, + -.0001452, -.0027646, -.2571754, -.2921051, + .1563671, .5803236, .4007025, .0234373, + -.0021613, .0004025, .0010049, .0897676, + .1076060, -.0854359, -.2073003, -.2740188, + .4310208, .6235440, .1733214}, + std::vector{5, 5, 5}, std::vector{5, 5, 5}), + SlaterTypeAtomicShell( + 3, + std::vector{27.357639, 16.730728, 11.435776, 7.517999, + 6.778528, 4.158712}, + std::vector{4, 4, 4, 5, 4, 4}, + std::vector{.0198836, .2303157, .3705979, -.4764123, + .9348401, .0189720}, + std::vector{7}, std::vector{7})})}, + {83, + SlaterTypeAtom( + 83, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Bi + * + * Etot=-20095.586252534 Ekin=20095.586220804 + */ + SlaterTypeAtomicShell( + 0, + std::vector{106.328367, 82.011128, 68.287892, + 38.691586, 35.822829, 24.123508, 20.086799, + 13.611590, 10.116856, 4.757245, 3.651788, + 1.800290, + 1.214185}, + std::vector{1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 3, 3}, + std::vector{ + 0.0341165, 0.9609275, 0.0068733, 0.0013863, -0.0011885, + 0.0011064, -0.0007403, 0.0003585, -0.0003104, 0.0000583, + -0.0000389, 0.0000087, -0.0000036, -0.0131842, 0.3570209, + 0.2516096, -1.1526401, -0.1029109, -0.0127695, 0.0055944, + -0.0009181, 0.0008509, -0.0001609, 0.0000966, -0.0000202, + 0.0000084, -0.0045474, 0.1676222, 0.1335414, -0.5976714, + -0.4346625, 0.4668267, 0.9293840, 0.0417890, -0.0208257, + 0.0018976, -0.0012839, 0.0002627, -0.0001055, 0.0016852, + -0.0835377, -0.0695053, 0.3075901, 0.2536983, 0.1503135, + -1.4522977, -0.0015770, 1.4684493, 0.0267628, -0.0098271, + 0.0013465, -0.0005222, -0.0006315, 0.0371747, 0.0315991, + -0.1391048, -0.1111024, -0.2091749, 1.0094573, 0.6240979, + -1.9777161, 1.1542176, 0.2728694, 0.0017622, -0.0000350, + 0.0000292, -0.0119129, -0.0107393, 0.0464098, 0.0344120, + 0.0859595, -0.3674193, -0.2670749, 0.7774072, -0.4649991, + -0.2947517, 0.7166164, 0.4890306}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{77.331767, 43.879146, 39.038245, 23.017341, + 23.016667, 13.120480, 13.118232, 9.144629, + 4.600151, 3.378836, 1.434936, 0.962057}, + std::vector{2, 2, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + -0.0064626, -0.7587573, -0.2533289, -0.0279196, 0.0186526, + 0.0070199, -0.0098684, -0.0019658, 0.0002409, -0.0001225, + 0.0000222, -0.0000106, -0.0019930, -0.3891162, -0.2484193, + 0.8190471, 0.2541202, -0.0927949, 0.2246144, 0.0132236, + -0.0010616, 0.0003731, -0.0000563, 0.0000261, 0.0006432, + 0.1961518, 0.1322456, -0.4991285, -0.3359387, 0.5089767, + -0.2343160, 0.9052883, 0.0161545, -0.0040087, 0.0004757, + -0.0002207, -0.0001589, -0.0837354, -0.0547555, 0.2292839, + 0.2003211, -0.0086403, 0.1417611, -1.1359968, 0.9326104, + 0.4395444, 0.0050712, -0.0011365, 0.0001014, 0.0227372, + 0.0159566, -0.0634256, -0.0485307, 0.0238021, -0.0623101, + 0.3290626, -0.2744868, -0.2762268, 0.6733935, 0.4608023}, + std::vector{3, 3, 3, 3, 3}, + std::vector{3, 3, 3, 3, 0}), + SlaterTypeAtomicShell( + 2, + std::vector{49.029127, 29.255646, 24.066237, 15.927546, + 12.051763, 9.043747, 5.731630, 3.700914, + 2.334962}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4}, + std::vector{ + 0.0061976, 0.4807398, 0.4887512, 0.1183975, -0.0303032, + 0.0103129, -0.0020116, 0.0006383, -0.0001485, -0.0025577, + -0.2564407, -0.2947678, 0.1409257, 0.5729942, 0.4192902, + 0.0259087, -0.0024127, 0.0004005, 0.0009800, 0.0929027, + 0.1130701, -0.0842736, -0.2072524, -0.3041246, 0.4251471, + 0.6482395, 0.1595972}, + std::vector{5, 5, 5}, std::vector{5, 5, 5}), + SlaterTypeAtomicShell( + 3, + std::vector{27.764767, 16.963291, 11.441274, 7.601823, + 6.885683, 4.337840}, + std::vector{4, 4, 4, 5, 4, 4}, + std::vector{0.0199837, 0.2393246, 0.3989225, + -0.4013883, 0.8246315, 0.0164899}, + std::vector{7}, std::vector{7})})}, + {84, + SlaterTypeAtom( + 84, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Po + * + * Etot=-20676.500744145 Ekin=20676.500625502 + */ + SlaterTypeAtomicShell( + 0, + std::vector{107.662632, 83.017194, 69.115164, + 39.156661, 36.235025, 24.316654, 20.292194, + 13.862770, 10.340302, 4.835940, 3.714369, + 1.941823, + 1.311138}, + std::vector{1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 3, 3}, + std::vector{ + .0335408, .9615019, .0068756, .0013521, -.0011684, + .0011211, -.0007610, .0003794, -.0003299, .0000625, + -.0000436, .0000106, -.0000041, -.0132086, .3571771, + .2522884, -1.1551544, -.1011324, -.0123808, .0055687, + -.0009340, .0008642, -.0001658, .0001040, -.0000235, + .0000091, -.0045048, .1678249, .1342005, -.6000423, + -.4375175, .5051071, .8955109, .0413751, -.0208043, + .0018627, -.0013213, .0002993, -.0001107, .0017741, + -.0840791, -.0698208, .3092412, .2587271, .1361868, + -1.4646827, -.0309827, 1.5144703, .0284194, -.0112159, + .0016712, -.0006029, -.0007062, .0379697, .0321115, + -.1416106, -.1155746, -.2107195, 1.0493009, .6851864, + -2.0872272, 1.2363985, .2042944, .0024488, -.0000500, + .0000656, -.0127827, -.0114235, .0495083, .0377170, + .0919189, -.4029773, -.3088320, .8665087, -.5170948, + -.3256025, .7528444, .4946105}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{78.287503, 44.424063, 39.555229, 23.458904, + 23.448994, 13.364416, 13.363421, 9.337108, + 4.710557, 3.530875, 1.603240, 1.031749}, + std::vector{2, 2, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + -.0063816, -.7592460, -.2525362, -.0281619, .0186763, + .0071009, -.0098751, -.0020497, .0002733, -.0001476, + .0000249, -.0000103, -.0019674, -.3899429, -.2484097, + .8002590, .2686797, -.0967825, .2327227, .0141570, + -.0012369, .0004802, -.0000658, .0000267, .0006349, + .1973572, .1326497, -.4857414, -.3423486, .5267164, + -.2686136, .9121452, .0173308, -.0048511, .0005101, + -.0002152, -.0001587, -.0857188, -.0558509, .2268617, + .2065815, -.0121839, .1704978, -1.1851851, .9634369, + .4232643, .0061022, -.0005230, .0000931, .0249714, + .0171766, -.0671607, -.0558279, .0196048, -.0721005, + .3755436, -.2966141, -.3238386, .6651437, .5033076}, + std::vector{3, 3, 3, 3, 3}, + std::vector{3, 3, 3, 3, 1}), + SlaterTypeAtomicShell( + 2, + std::vector{49.998233, 29.763139, 24.506491, 16.257625, + 12.359076, 9.303793, 5.946018, 3.885400, + 2.463053}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4}, + std::vector{.0057382, .4765483, .4902017, .1227910, + -.0320613, .0109043, -.0021636, .0006820, + -.0001524, -.0023535, -.2556703, -.2975487, + .1274900, .5706160, .4318088, .0276584, + -.0026435, .0003925, .0009415, .0957653, + .1182219, -.0825814, -.2104055, -.3292536, + .4234817, .6691334, .1458308}, + std::vector{5, 5, 5}, std::vector{5, 5, 5}), + SlaterTypeAtomicShell( + 3, + std::vector{28.178564, 17.204040, 11.459603, 7.676215, + 6.997082, 4.545544}, + std::vector{4, 4, 4, 5, 4, 4}, + std::vector{.0200415, .2474073, .4301177, -.3205019, + .7061270, .0151366}, + std::vector{7}, std::vector{7})})}, + {85, + SlaterTypeAtom( + 85, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for At + * + * Etot=-21266.881543541 Ekin=21266.881493653 + */ + SlaterTypeAtomicShell( + 0, + std::vector{108.903934, 84.018911, 69.951611, + 39.611892, 36.654114, 24.547370, 20.496500, + 14.102471, 10.565212, 4.939179, 3.843808, + 2.082126, + 1.407323}, + std::vector{1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 3, 3}, + std::vector{ + .0332539, .9617942, .0068748, .0013090, -.0011376, + .0011100, -.0007588, .0003992, -.0003512, .0000696, + -.0000505, .0000123, -.0000045, -.0132611, .3573754, + .2527617, -1.1579306, -.0987201, -.0121631, .0055686, + -.0009848, .0009134, -.0001828, .0001198, -.0000267, + .0000098, -.0045107, .1680981, .1346376, -.6022614, + -.4403680, .5393304, .8659456, .0407013, -.0207425, + .0018652, -.0013795, .0003135, -.0001078, .0018432, + -.0845897, -.0701147, .3110138, .2630913, .1215167, + -1.4765875, -.0602258, 1.5606882, .0308147, -.0130400, + .0018798, -.0006396, -.0007539, .0387139, .0326496, + -.1442413, -.1193767, -.2128304, 1.0930937, .7598802, + -2.2158759, 1.2910016, .1649685, .0046114, -.0003687, + .0000881, -.0135492, -.0120534, .0523611, .0405555, + .0976171, -.4386258, -.3560886, .9606495, -.5438141, + -.3757999, .7766703, .5104669}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{79.295777, 45.026511, 40.133432, 23.914315, + 23.911162, 13.577284, 13.501981, 9.503258, + 4.822702, 3.674635, 1.751098, 1.110812}, + std::vector{2, 2, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + -.0062490, -.7574734, -.2538335, -.0292880, .0192391, + .0075516, -.0102374, -.0021982, .0003212, -.0001814, + .0000296, -.0000111, -.0019388, -.3895107, -.2485208, + .7771505, .2861947, -.1079335, .2472330, .0157603, + -.0015395, .0006590, -.0000877, .0000329, .0006246, + .1979189, .1329574, -.4691949, -.3498446, .5641122, + -.3049989, .9018454, .0177679, -.0053807, .0005156, + -.0002131, -.0001591, -.0873686, -.0569077, .2219954, + .2120916, -.0329344, .2050841, -1.2239384, 1.0044047, + .3997921, .0074286, -.0000056, .0000880, .0270169, + .0183706, -.0696780, -.0624260, .0226124, -.0857368, + .4179668, -.3191468, -.3710492, .6788741, .5205260}, + std::vector{3, 3, 3, 3, 3}, + std::vector{3, 3, 3, 3, 2}), + SlaterTypeAtomicShell( + 2, + std::vector{50.967339, 30.252536, 24.929837, 16.556179, + 12.631391, 9.553285, 6.184273, 4.084597, + 2.594201}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4}, + std::vector{.0053403, .4733143, .4914435, .1264566, + -.0341821, .0117780, -.0023889, .0007335, + -.0001555, -.0021762, -.2553726, -.3002285, + .1187754, .5691878, .4388858, .0296509, + -.0027925, .0003621, .0009046, .0985443, + .1230827, -.0826159, -.2121996, -.3541969, + .4155763, .6923676, .1384108}, + std::vector{5, 5, 5}, std::vector{5, 5, 5}), + SlaterTypeAtomicShell( + 3, + std::vector{28.618551, 17.482248, 11.555443, 7.769969, + 7.135223, 4.780973}, + std::vector{4, 4, 4, 5, 4, 4}, + std::vector{.0199313, .2520908, .4552758, -.2580323, + .6140219, .0147295}, + std::vector{7}, std::vector{7})})}, + {86, + SlaterTypeAtom( + 86, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Rn + * + * Etot=-21866.772070663 Ekin=21866.772036482 + */ + SlaterTypeAtomicShell( + 0, + std::vector{110.161562, 85.019704, 70.796388, + 40.050427, 37.065897, 24.761481, 20.686346, + 14.330607, 10.794813, 5.057300, 4.066550, + 2.209589, + 1.500547}, + std::vector{1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 3, 3}, + std::vector{ + .0329517, .9621167, .0068459, .0012889, -.0011281, + .0011231, -.0007716, .0004377, -.0003925, .0000864, + -.0000650, .0000137, -.0000048, -.0132734, .3575218, + .2530795, -1.1614697, -.0951595, -.0122719, .0057686, + -.0011489, .0010701, -.0002351, .0001625, -.0000312, + .0000112, -.0044568, .1682829, .1350895, -.6050995, + -.4424084, .5781020, .8318804, .0404208, -.0212498, + .0020892, -.0016019, .0003177, -.0001052, .0019112, + -.0850950, -.0703500, .3129572, .2675298, .1024904, + -1.4863022, -.0909855, 1.6097908, .0352439, -.0163650, + .0019142, -.0006415, -.0007871, .0394232, .0331817, + -.1469808, -.1230271, -.2149576, 1.1426708, .8500038, + -2.3660702, 1.3240326, .1479778, .0078868, -.0008856, + .0000927, -.0142277, -.0126558, .0550904, .0430876, + .1033738, -.4758569, -.4082278, 1.0595089, -.5302389, + -.4523669, .7912280, .5253702}, + std::vector{1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{80.413094, 45.595893, 40.661311, 24.299025, + 24.298213, 13.697119, 13.696884, 9.640567, + 4.991556, 3.885248, 1.877545, 1.190797}, + std::vector{2, 2, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + -.0060839, -.7571905, -.2541249, -.0293931, .0190970, + .0074416, -.0097954, -.0024121, .0003923, -.0002254, + .0000328, -.0000118, -.0018905, -.3898567, -.2490845, + .7684302, .2948713, -.1090586, .2464512, .0185618, + -.0020462, .0009345, -.0001130, .0000390, .0006080, + .1988549, .1336683, -.4647665, -.3566654, .5929499, + -.2976463, .8663973, .0182063, -.0057488, .0004838, + -.0001703, -.0001628, -.0891800, -.0582923, .2226259, + .2168487, -.0484333, .2237719, -1.2638682, .9945500, + .4358856, .0080774, -.0010911, .0000892, .0287190, + .0195278, -.0727009, -.0669716, .0284913, -.0953641, + .4509851, -.3030347, -.4464629, .6989789, .5241515}, + std::vector{3, 3, 3, 3, 3}, + std::vector{3, 3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{52.058235, 30.769357, 25.372633, 16.878426, + 12.915741, 9.793952, 6.388020, 4.266585, + 2.711132}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4}, + std::vector{.0048754, .4690494, .4931618, .1307111, + -.0360688, .0125107, -.0025997, .0007947, + -.0001606, -.0019690, -.2544344, -.3030732, + .1072420, .5705827, .4463191, .0308617, + -.0029764, .0003347, .0008485, .1008496, + .1277505, -.0804229, -.2166253, -.3757659, + .4139341, .7097149, .1298232}, + std::vector{5, 5, 5}, std::vector{5, 5, 5}), + SlaterTypeAtomicShell( + 3, + std::vector{29.091519, 17.792862, 11.693545, 7.686730, + 7.106004, 4.841159}, + std::vector{4, 4, 4, 5, 4, 4}, + std::vector{.0196357, .2541992, .4806186, -.2542278, + .5847619, .0099519}, + std::vector{7}, std::vector{7})})}, + {87, + SlaterTypeAtom( + 87, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Fr + * + * Etot=-22475.85853026 Ekin=22475.858541552 + */ + SlaterTypeAtomicShell( + 0, + std::vector{101.978322, 84.676698, 70.148749, + 40.722793, 36.564250, 25.685340, 20.647336, + 10.669335, 10.668939, 5.409521, 4.319102, + 2.279605, + 1.670162, + .557011, .310522}, + std::vector{1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + .1049016, .8960690, -.0011166, .0031237, -.0025475, + .0023280, -.0015781, -.0005334, .0006894, .0002513, + -.0001689, .0000394, -.0000185, .0000021, -.0000010, + .0301072, -.3859513, -.2523583, 1.1731369, .1015472, + .0013850, -.0001159, .0002397, -.0004536, -.0000293, + .0000265, -.0000072, .0000030, -.0000003, .0000002, + -.0091116, .1778917, .1405389, -.6238729, -.4918961, + .6697092, .7955779, -.0173030, .0342886, .0029153, + -.0018688, .0003784, -.0001646, .0000174, -.0000082, + .0038646, -.0897664, -.0739110, .3247476, .2982275, + -.0604433, -1.3545903, -.1223855, 1.6310878, .0343317, + -.0135478, .0016029, -.0007249, .0000652, -.0000299, + -.0031233, .0439659, .0331312, -.1497966, -.1554445, + .0103387, .7399800, -.4603996, -1.0370255, 1.2657293, + .3119492, .0030520, .0004655, -.0000381, .0000147, + .0009162, -.0167027, -.0132695, .0589841, .0592265, + .0050434, -.3049377, .2393457, .4368223, -.4947820, + -.6073945, .8565166, .4813671, .0004398, .0001943, + -.0004537, .0042257, .0027988, -.0132290, -.0153442, + .0031248, .0663145, -.0681332, -.0969861, .1370248, + .1392960, -.2072293, -.2153866, 1.0492184, .0151924}, + std::vector{1, 1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1, 0}), + SlaterTypeAtomicShell( + 1, + std::vector{81.894857, 46.267422, 41.274041, 24.715008, + 24.713525, 13.785538, 13.784914, 9.739078, + 5.219959, 4.136671, 1.942765, 1.331098}, + std::vector{2, 2, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + -.0057213, -.7533186, -.2581576, -.0301821, .0192319, + .0075680, -.0095320, -.0026709, .0004928, -.0002795, + .0000382, -.0000159, -.0017966, -.3881639, -.2504987, + .7528279, .3093042, -.1174084, .2515588, .0225049, + -.0028907, .0013540, -.0001541, .0000618, .0005709, + .1987343, .1346064, -.4556210, -.3667702, .6437556, + -.2877773, .8074363, .0178430, -.0054594, .0003824, + -.0001565, -.0001598, -.0904082, -.0597586, .2202705, + .2220801, -.0834275, .2439392, -1.2920876, .9294218, + .5346263, .0098489, -.0021487, .0000940, .0316642, + .0217406, -.0781616, -.0747993, .0464653, -.1117125, + .5001783, -.2648081, -.5780156, .8186689, .4222476}, + std::vector{3, 3, 3, 3, 3}, + std::vector{3, 3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{53.149130, 31.255929, 25.782513, 17.066339, + 13.175203, 10.104259, 6.779322, 4.560110, + 2.969156}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4}, + std::vector{.0044859, .4662720, .4952756, .1361156, + -.0430281, .0155601, -.0033399, .0009553, + -.0001897, -.0017858, -.2543195, -.3058970, + .1060475, .5548491, .4560006, .0375433, + -.0031326, .0003250, .0008045, .1033411, + .1325415, -.0863388, -.2003948, -.4147784, + .3682830, .7454395, .1509181}, + std::vector{5, 5, 5}, std::vector{5, 5, 5}), + SlaterTypeAtomicShell( + 3, + std::vector{29.655976, 18.197881, 12.033467, 7.920612, + 7.290968, 4.727672}, + std::vector{4, 4, 4, 5, 4, 4}, + std::vector{.0188665, .2488374, .4753176, -.2872011, + .6289353, .0054266}, + std::vector{7}, std::vector{7})})}, + {88, + SlaterTypeAtom( + 88, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ra + * + * Etot=-23094.303492621 Ekin=23094.303625461 + */ + SlaterTypeAtomicShell( + 0, + std::vector{102.772371, 85.593215, 70.820905, + 41.242337, 36.905364, 25.990833, 20.824259, + 10.834095, 10.835315, 5.559242, 4.498561, + 2.306842, + 1.710801, + .761325, .569949}, + std::vector{1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + .1096751, .8915113, -.0014083, .0031514, -.0025815, + .0023840, -.0016251, -.0005837, .0007414, .0003038, + -.0002080, .0000525, -.0000306, .0000086, -.0000048, + .0318380, -.3886018, -.2535717, 1.1748681, .1029751, + -.0004920, .0007897, .0004658, -.0007541, -.0001365, + .0000991, -.0000258, .0000145, -.0000040, .0000022, + -.0096438, .1790025, .1418275, -.6264931, -.5007628, + .7018671, .7742060, -.0157038, .0313323, .0027072, + -.0017672, .0003806, -.0002055, .0000540, -.0000298, + .0042678, -.0907842, -.0746319, .3267457, .3066762, + -.0888788, -1.3498968, -.1378765, 1.6577775, .0368847, + -.0150884, .0017703, -.0009736, .0002231, -.0001209, + -.0033412, .0449412, .0338972, -.1525735, -.1615524, + .0244735, .7480979, -.4802696, -1.0696024, 1.2903628, + .3183558, .0044793, -.0003307, .0000198, -.0000031, + .0010642, -.0179371, -.0142064, .0629507, .0647567, + -.0005621, -.3237033, .2645110, .4730707, -.4934123, + -.7063196, 1.1129129, .2612706, -.0038689, .0018555, + -.0004524, .0052870, .0038403, -.0175042, -.0193205, + .0027685, .0889003, -.0853782, -.1314972, .1499719, + .2227461, -.3486209, -.2434046, .7068613, .4324472}, + std::vector{1, 1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{83.018450, 46.836527, 41.801671, 25.187270, + 25.102935, 13.925446, 13.918592, 9.852338, + 5.415789, 4.328539, 1.999556, 1.359217}, + std::vector{2, 2, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + -.0055746, -.7530880, -.2583868, -.0298978, .0186963, + .0075895, -.0093014, -.0028118, .0005555, -.0003073, + .0000366, -.0000151, -.0017521, -.3885261, -.2509679, + .7354511, .3267092, -.1236610, .2561285, .0253284, + -.0035764, .0016664, -.0001652, .0000656, .0005561, + .1996493, .1352715, -.4453769, -.3782728, .6849932, + -.2855077, .7646152, .0170906, -.0050457, .0002686, + -.0001065, -.0001638, -.0920646, -.0610444, .2176547, + .2290386, -.1118114, .2624712, -1.3244952, .9096788, + .5881836, .0095365, -.0023955, .0001031, .0343839, + .0237117, -.0823287, -.0821659, .0642914, -.1278195, + .5449588, -.2361147, -.7002996, 1.0306082, .2416654}, + std::vector{3, 3, 3, 3, 3}, + std::vector{3, 3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{54.653258, 31.812073, 26.239889, 17.292475, + 13.510169, 10.453460, 7.146561, 4.838823, + 3.220235}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4}, + std::vector{.0038909, .4608977, .4986425, .1446404, + -.0516686, .0189476, -.0041161, .0011286, + -.0002231, -.0015145, -.2526540, -.3092364, + .0969944, .5329369, .4773240, .0456041, + -.0034510, .0003466, .0007160, .1050504, + .1373652, -.0887128, -.1803875, -.4538996, + .3245785, .7742441, .1715341}, + std::vector{5, 5, 5}, std::vector{5, 5, 5}), + SlaterTypeAtomicShell( + 3, + std::vector{30.150869, 18.531819, 12.237536, 8.036556, + 7.428155, 4.881720}, + std::vector{4, 4, 4, 5, 4, 4}, + std::vector{.0184731, .2488904, .4875180, -.2696101, + .5984041, .0045264}, + std::vector{7}, std::vector{7})})}, + {89, + SlaterTypeAtom( + 89, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ac + * + * Etot=-23722.191878737 Ekin=23722.191934245 + */ + SlaterTypeAtomicShell( + 0, + std::vector{103.566421, 86.497397, 71.640446, + 41.677547, 37.312088, 26.240073, 21.005341, + 11.023570, 11.019466, 5.668415, 4.601852, + 2.470213, + 1.849037, + .836903, .612646}, + std::vector{1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + .1148917, .8865817, -.0018084, .0032439, -.0026644, + .0024891, -.0017243, -.0006456, .0008148, .0003573, + -.0002544, .0000691, -.0000388, .0000094, -.0000049, + .0323053, -.3896553, -.2530307, 1.1779345, .0992529, + .0000240, .0004731, .0003871, -.0006495, -.0001016, + .0000785, -.0000225, .0000120, -.0000029, .0000015, + -.0095859, .1793650, .1419169, -.6291373, -.5028569, + .7302286, .7510667, -.0143963, .0290129, .0024219, + -.0016462, .0003814, -.0001952, .0000437, -.0000225, + .0044302, -.0914927, -.0746269, .3285305, .3118424, + -.1115425, -1.3488819, -.1443211, 1.6772363, .0384172, + -.0164785, .0020801, -.0010821, .0002065, -.0001037, + -.0034850, .0458017, .0342622, -.1550819, -.1661853, + .0363420, .7567324, -.5036288, -1.0921824, 1.3679974, + .2659390, .0049276, -.0002693, .0000138, .0000010, + .0011511, -.0188380, -.0147892, .0659132, .0687341, + -.0052828, -.3381737, .2871040, .4984315, -.5123500, + -.7947457, 1.1273943, .3097277, -.0019019, .0009616, + -.0004716, .0056996, .0041715, -.0190195, -.0209898, + .0037936, .0966879, -.0946630, -.1439868, .1543836, + .2713632, -.3765702, -.2656102, .6435321, .5053889}, + std::vector{1, 1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{83.950462, 47.379407, 42.317464, 25.516598, + 25.513192, 14.143135, 14.143061, 10.014047, + 5.578447, 4.528351, 2.122176, 1.425686}, + std::vector{2, 2, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + -.0055220, -.7536588, -.2575405, -.0304560, .0191390, + .0077302, -.0093363, -.0029682, .0006455, -.0003654, + .0000387, -.0000150, -.0017329, -.3893565, -.2508140, + .7317337, .3265106, -.1280490, .2625049, .0272547, + -.0042495, .0020572, -.0001796, .0000674, .0005520, + .2007955, .1356290, -.4419165, -.3769287, .7119587, + -.3065927, .7528573, .0176378, -.0054979, .0002368, + -.0000925, -.0001655, -.0938109, -.0620236, .2184743, + .2309898, -.1251186, .2879628, -1.3685537, .8894145, + .6333244, .0098144, -.0022878, .0001130, .0363717, + .0251220, -.0857424, -.0852562, .0783937, -.1451990, + .5779824, -.1722212, -.8379022, 1.0861069, .2223175}, + std::vector{3, 3, 3, 3, 3}, + std::vector{3, 3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{55.806211, 32.318943, 26.673684, 17.487764, + 13.909369, 10.825716, 7.265443, 5.033503, + 3.419505, 1.865952, 1.076193}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4}, + std::vector{ + .0035600, .4573200, .5003718, .1551280, -.0630094, + .0223355, -.0050780, .0018910, -.0005589, .0001183, + -.0000338, -.0013609, -.2519913, -.3116220, .0870658, + .4984930, .5155794, .0527689, -.0068970, .0014045, + -.0003024, .0000780, .0006601, .1071095, .1414353, + -.0895327, -.1605303, -.4797120, .3079551, .7812009, + .1727998, .0007864, .0002087, -.0000872, -.0304496, + -.0378562, .0119581, .0804654, .1018100, -.0481489, + -.3603243, .0330914, .6591098, .4462350}, + std::vector{5, 5, 5, 1}, std::vector{5, 5, 5, 0}), + SlaterTypeAtomicShell( + 3, + std::vector{30.646406, 18.859879, 12.433128, 8.224069, + 7.677769, 5.545284}, + std::vector{4, 4, 4, 5, 4, 4}, + std::vector{.0180943, .2493732, .4997068, -.2180428, + .5299271, .0090766}, + std::vector{7}, std::vector{7})})}, + {90, + SlaterTypeAtom( + 90, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Th + * + * Etot=-24359.622254112 Ekin=24359.622040097 + */ + SlaterTypeAtomicShell( + 0, + std::vector{104.360470, 87.407443, 72.395723, + 42.152982, 37.702725, 26.525386, 21.190267, + 11.203617, 11.206623, 5.799329, 4.767688, + 2.619963, + 1.957576, + .895730, .642855}, + std::vector{1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + .1200990, .8815923, -.0021026, .0032826, -.0027010, + .0025422, -.0017801, -.0006966, .0008697, .0004235, + -.0003101, .0000798, -.0000428, .0000095, -.0000047, + .0333656, -.3914290, -.2532484, 1.1801209, .0980253, + -.0004182, .0006590, .0004392, -.0007177, -.0001371, + .0001062, -.0000284, .0000145, -.0000032, .0000016, + -.0098424, .1801121, .1424387, -.6313994, -.5075807, + .7558642, .7324852, -.0128007, .0262677, .0020856, + -.0014616, .0003166, -.0001503, .0000305, -.0000148, + .0047034, -.0923276, -.0749325, .3302920, .3178437, + -.1333352, -1.3489750, -.1490560, 1.6945428, .0410371, + -.0184517, .0021163, -.0010401, .0001760, -.0000830, + -.0036651, .0466871, .0347804, -.1575690, -.1711134, + .0477342, .7660402, -.5294024, -1.1153291, 1.4135093, + .2480229, .0062890, -.0005232, .0000586, -.0000191, + .0012334, -.0196466, -.0153911, .0686177, .0724514, + -.0096437, -.3519518, .3081223, .5224699, -.4789534, + -.9213468, 1.1468723, .3443889, -.0014594, .0007830, + -.0004931, .0060044, .0044220, -.0201109, -.0223145, + .0049014, .1024187, -.1023554, -.1534364, .1380332, + .3304689, -.4054897, -.2701008, .6070797, .5455172}, + std::vector{1, 1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{85.220586, 47.923019, 42.810133, 25.930725, + 25.894042, 14.310752, 14.333548, 10.146515, + 5.791359, 4.757648, 2.238531, 1.497187}, + std::vector{2, 2, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + -.0053421, -.7545122, -.2569314, -.0298021, .0184939, + .0075874, -.0089373, -.0030917, .0007417, -.0004193, + .0000391, -.0000146, -.0016649, -.3902926, -.2512736, + .7224653, .3352140, -.1321109, .2655522, .0303413, + -.0052866, .0025897, -.0001975, .0000719, .0005270, + .2019788, .1363338, -.4364264, -.3831958, .7435981, + -.3077817, .7214663, .0181174, -.0057524, .0001987, + -.0000825, -.0001661, -.0955038, -.0632900, .2179909, + .2354721, -.1474655, .3066336, -1.4038035, .8197282, + .7336526, .0104700, -.0023044, .0001191, .0381249, + .0264673, -.0879567, -.0888839, .0980544, -.1582463, + .5986024, -.0648631, -1.0066944, 1.1210335, .2164715}, + std::vector{3, 3, 3, 3, 3}, + std::vector{3, 3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{56.959163, 32.929578, 27.232169, 18.308145, + 14.322241, 10.902954, 6.981844, 4.936825, + 3.242964, 1.958372, 1.173942}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4}, + std::vector{ + .0031826, .4492931, .4986926, .1529973, -.0440481, + .0144247, -.0034667, .0015782, -.0005068, .0001523, + -.0000396, -.0012188, -.2486148, -.3126712, .0409978, + .5472579, .5212498, .0395267, -.0078739, .0017235, + -.0004956, .0001181, .0006064, .1078376, .1446990, + -.0577246, -.2208294, -.4623053, .4241750, .7434343, + .0967889, -.0023281, .0006631, -.0001103, -.0331678, + -.0427688, .0095852, .0893049, .1262592, -.1102053, + -.3812704, .0924581, .6905171, .3858830}, + std::vector{5, 5, 5, 2}, std::vector{5, 5, 5, 0}), + SlaterTypeAtomicShell( + 3, + std::vector{31.067912, 19.143075, 12.571937, 8.226585, + 7.787099, 6.101665}, + std::vector{4, 4, 4, 5, 4, 4}, + std::vector{.0180325, .2523892, .5188325, -.1870913, + .4687865, .0162251}, + std::vector{7}, std::vector{7})})}, + {91, + SlaterTypeAtom( + 91, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Pa + * + * Etot=-25007.109683472 Ekin=25007.109737912 + */ + SlaterTypeAtomicShell( + 0, + std::vector{105.154520, 88.309408, 73.179755, + 42.592913, 38.076008, 26.773490, 21.322733, + 11.450486, 11.452736, 6.017261, 4.935803, + 2.561338, + 1.895353, + .856942, .621841}, + std::vector{1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + .1256606, .8762828, -.0024453, .0033408, -.0027538, + .0026076, -.0018538, -.0007395, .0009385, .0004092, + -.0002786, .0000622, -.0000350, .0000089, -.0000046, + .0341863, -.3929341, -.2529999, 1.1836090, .0944246, + -.0001147, .0004194, .0003408, -.0006043, -.0000678, + .0000519, -.0000125, .0000064, -.0000016, .0000008, + -.0098148, .1805054, .1429047, -.6347507, -.5110795, + .7921960, .7040066, -.0100891, .0220511, .0010291, + -.0007053, .0001281, -.0000581, .0000128, -.0000064, + .0049203, -.0930729, -.0750685, .3322846, .3244885, + -.1678046, -1.3410496, -.1259436, 1.6904088, .0375163, + -.0146173, .0012028, -.0006289, .0001158, -.0000569, + -.0039166, .0474400, .0348917, -.1590664, -.1764763, + .0697701, .7603860, -.5777359, -1.1024108, 1.3130828, + .3705680, .0056215, -.0005017, .0000493, -.0000165, + .0013294, -.0195784, -.0150876, .0677603, .0734501, + -.0196615, -.3410921, .3305801, .5037307, -.4690024, + -.8526638, 1.1336456, .2850500, -.0027314, .0012535, + -.0005253, .0057118, .0040729, -.0187601, -.0215980, + .0080482, .0931346, -.1048969, -.1390012, .1375514, + .2741537, -.3643954, -.2421426, .6272943, .5138243}, + std::vector{1, 1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{86.263329, 48.638467, 43.514489, 26.497383, + 26.436470, 14.678283, 14.575967, 10.410317, + 5.938724, 4.794282, 2.231963, 1.512972}, + std::vector{2, 2, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + -.0051917, -.7487456, -.2615860, -.0325777, .0201456, + .0085048, -.0101368, -.0032442, .0007086, -.0003815, + .0000397, -.0000157, -.0016486, -.3876137, -.2510255, + .6832306, .3603350, -.1465943, .2908115, .0303849, + -.0048395, .0022274, -.0001929, .0000739, .0005302, + .2012140, .1363246, -.4066721, -.3894187, .7641091, + -.4015112, .7711521, .0180593, -.0049677, .0002054, + -.0000829, -.0001552, -.0956927, -.0632814, .2041402, + .2414667, -.1407530, .3687073, -1.4760476, .8613806, + .7035924, .0105120, -.0024280, .0001053, .0371577, + .0255950, -.0801994, -.0900730, .0800143, -.1809388, + .6372965, -.1791618, -.8508784, 1.0531476, .2499894}, + std::vector{3, 3, 3, 3, 3}, + std::vector{3, 3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{58.112116, 33.309553, 27.538253, 18.230484, + 14.427148, 11.238129, 7.505177, 5.250125, + 3.548260, 1.994271, 1.159970}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4}, + std::vector{ + .0030067, .4513832, .5010479, .1583126, -.0598390, + .0213613, -.0049186, .0018888, -.0005614, .0001250, + -.0000352, -.0011295, -.2510022, -.3159392, .0639931, + .5186800, .5189943, .0498426, -.0071428, .0015206, + -.0003411, .0000775, .0005736, .1095359, .1473926, + -.0786231, -.1771675, -.5061559, .3506529, .7776464, + .1516008, .0000430, -.0001011, -.0000836, -.0327833, + -.0419761, .0115698, .0850987, .1222370, -.0697808, + -.3881995, .0610383, .6759252, .4204505}, + std::vector{5, 5, 5, 1}, std::vector{5, 5, 5, 0}), + SlaterTypeAtomicShell( + 3, + std::vector{31.632165, 19.500417, 12.787924, 8.093836, + 7.520518, 4.364677, 2.642847, 1.592222}, + std::vector{4, 4, 4, 5, 4, 4, 4, 4}, + std::vector{.0174072, .2513461, .5307624, -.2857608, + .5656323, .0005997, .0000249, .0000194, + -.0050467, -.0859573, -.1560222, .2457048, + -.2181933, .5327375, .4243645, .1168648}, + std::vector{7, 2}, std::vector{7, 0})})}, + {92, + SlaterTypeAtom( + 92, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for U + * + * Etot=-25664.33807536 Ekin=25664.338196191 + */ + SlaterTypeAtomicShell( + 0, + std::vector{105.948569, 89.207514, 73.824657, + 43.135437, 38.435041, 27.065952, 21.462052, + 11.698336, 11.694677, 6.183263, 5.092883, + 2.598643, + 1.915613, + 0.863923, + 0.624455}, + std::vector{1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.1314908, 0.8707000, -0.0027993, 0.0034122, -0.0028187, + 0.0026946, -0.0019406, -0.0008001, 0.0010272, 0.0004334, + -0.0002902, 0.0000596, -0.0000337, 0.0000087, -0.0000045, + 0.0360605, -0.3958082, -0.2543688, 1.1844169, 0.0972836, + -0.0023122, 0.0016114, 0.0007082, -0.0011048, -0.0002467, + 0.0001694, -0.0000351, 0.0000192, -0.0000049, 0.0000025, + -0.0104367, 0.1817428, 0.1442157, -0.6366599, -0.5195679, + 0.8245638, 0.6819648, -0.0072509, 0.0174997, 0.0000580, + -0.0000975, 0.0000098, 0.0000061, -0.0000029, 0.0000016, + 0.0054282, -0.0941977, -0.0757363, 0.3337270, 0.3331668, + -0.1999833, -1.3362989, -0.1067436, 1.6897707, 0.0368797, + -0.0137299, 0.0009063, -0.0004794, 0.0000846, -0.0000410, + -0.0042967, 0.0484274, 0.0353325, -0.1605925, -0.1830407, + 0.0905686, 0.7577003, -0.6211925, -1.0919565, 1.2764231, + 0.4240410, 0.0062788, -0.0008014, 0.0001061, -0.0000447, + 0.0014728, -0.0199500, -0.0152640, 0.0683254, 0.0761320, + -0.0284888, -0.3396144, 0.3534489, 0.4974137, -0.4438245, + -0.8753248, 1.1316892, 0.2752913, -0.0028955, 0.0013112, + -0.0005596, 0.0057314, 0.0040598, -0.0186350, -0.0220267, + 0.0104142, 0.0911806, -0.1100545, -0.1348177, 0.1282830, + 0.2754573, -0.3579043, -0.2339463, 0.6309013, 0.5074851}, + std::vector{1, 1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{87.226042, 49.213004, 44.065058, 26.877372, + 26.873584, 14.962805, 14.943929, 10.636528, + 6.102765, 4.908426, 2.276364, 1.544958}, + std::vector{2, 2, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + -0.0051249, -0.7482162, -0.2616987, -0.0334721, 0.0207619, + 0.0084427, -0.0101210, -0.0033276, 0.0007073, -0.0003724, + 0.0000387, -0.0000154, -0.0016296, -0.3878068, -0.2507736, + 0.6725172, 0.3640839, -0.1444753, 0.2942467, 0.0315213, + -0.0049035, 0.0021978, -0.0001905, 0.0000735, 0.0005308, + 0.2019396, 0.1366214, -0.3976681, -0.3881445, 0.7651783, + -0.4382001, 0.7935277, 0.0191574, -0.0050914, 0.0002247, + -0.0000905, -0.0001544, -0.0967574, -0.0637979, 0.2011532, + 0.2432007, -0.1247374, 0.3990900, -1.5366656, 0.8571387, + 0.7235066, 0.0105908, -0.0024430, 0.0001039, 0.0374712, + 0.0257179, -0.0788096, -0.0906799, 0.0696329, -0.1936617, + 0.6684159, -0.1924570, -0.8406671, 1.0397185, 0.2585087}, + std::vector{3, 3, 3, 3, 3}, + std::vector{3, 3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{59.265068, 33.881203, 28.053792, 18.841775, + 14.814453, 11.425834, 7.475720, 5.271222, + 3.534011, 2.016503, 1.175780}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4}, + std::vector{ + 0.0027152, 0.4452939, 0.5000852, 0.1598839, -0.0505788, + 0.0172429, -0.0040324, 0.0016720, -0.0005060, 0.0001200, + -0.0000336, -0.0010121, -0.2486259, -0.3169844, 0.0339453, + 0.5362811, 0.5327484, 0.0445032, -0.0073936, 0.0016063, + -0.0003694, 0.0000865, 0.0005306, 0.1096356, 0.1495831, + -0.0599203, -0.2012601, -0.5089289, 0.4056180, 0.7518230, + 0.1266983, -0.0005318, 0.0000319, -0.0000765, -0.0328603, + -0.0427889, 0.0076067, 0.0873852, 0.1303788, -0.0935432, + -0.3848184, 0.0913131, 0.6762321, 0.4057067}, + std::vector{5, 5, 5, 1}, std::vector{5, 5, 5, 0}), + SlaterTypeAtomicShell( + 3, + std::vector{32.058387, 19.789922, 12.960840, 8.199212, + 7.637119, 4.494502, 2.762193, 1.697246}, + std::vector{4, 4, 4, 5, 4, 4, 4, 4}, + std::vector{ + 0.0173262, 0.2535423, 0.5411790, -0.2693791, 0.5353342, + 0.0007264, 0.0000012, 0.0000267, -0.0052546, -0.0902488, + -0.1678375, 0.2490057, -0.2087695, 0.5444776, 0.4097294, + 0.1029628}, + std::vector{7, 3}, std::vector{7, 0})})}, + {93, + SlaterTypeAtom( + 93, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Np + * + * Etot=-26331.454763705 Ekin=26331.454764105 + */ + SlaterTypeAtomicShell( + 0, + std::vector{106.891398, 90.150737, 74.606109, + 43.599769, 38.823091, 27.355986, 21.621181, + 11.948682, 11.945786, 6.351323, 5.241219, + 2.630257, + 1.923696, + 0.878188, + 0.631665}, + std::vector{1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.1343917, 0.8678982, -0.0029337, 0.0034179, -0.0028359, + 0.0027276, -0.0019933, -0.0008405, 0.0010931, 0.0004426, + -0.0002907, 0.0000555, -0.0000317, 0.0000086, -0.0000044, + 0.0368104, -0.3970082, -0.2546249, 1.1868140, 0.0953727, + -0.0024525, 0.0016558, 0.0007142, -0.0011328, -0.0002366, + 0.0001595, -0.0000307, 0.0000168, -0.0000045, 0.0000023, + -0.0105433, 0.1821941, 0.1447526, -0.6390351, -0.5239401, + 0.8498045, 0.6643896, -0.0048067, 0.0134876, -0.0007013, + 0.0003561, -0.0000635, 0.0000461, -0.0000133, 0.0000069, + 0.0056178, -0.0948431, -0.0760545, 0.3355096, 0.3390005, + -0.2242182, -1.3368266, -0.0823746, 1.6835920, 0.0359330, + -0.0125797, 0.0006273, -0.0003354, 0.0000551, -0.0000255, + -0.0045077, 0.0491461, 0.0356050, -0.1622336, -0.1880471, + 0.1070633, 0.7571182, -0.6676425, -1.0760378, 1.2369751, + 0.4790863, 0.0066803, -0.0010071, 0.0001516, -0.0000661, + 0.0015484, -0.0201991, -0.0153526, 0.0688821, 0.0781109, + -0.0354662, -0.3386774, 0.3774725, 0.4880384, -0.4223888, + -0.8931137, 1.1379661, 0.2577664, -0.0033857, 0.0014761, + -0.0005747, 0.0057232, 0.0040282, -0.0185318, -0.0222755, + 0.0122246, 0.0895205, -0.1154583, -0.1300636, 0.1204914, + 0.2757327, -0.3556423, -0.2247304, 0.6115717, 0.5262049}, + std::vector{1, 1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{88.714203, 49.950385, 44.755714, 27.391391, + 27.389735, 15.204118, 14.501265, 10.837432, + 6.297562, 5.026719, 2.313627, 1.567881}, + std::vector{2, 2, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + -0.0048270, -0.7422903, -0.2670696, -0.0356388, 0.0218842, + 0.0108430, -0.0126169, -0.0033194, 0.0007071, -0.0003571, + 0.0000371, -0.0000149, -0.0015541, -0.3849882, -0.2512748, + 0.6418773, 0.3810820, -0.2163944, 0.3756981, 0.0286987, + -0.0046485, 0.0019768, -0.0001713, 0.0000666, 0.0005013, + 0.2010913, 0.1368927, -0.3751215, -0.3935642, 0.8841048, + -0.5804887, 0.8061956, 0.0192812, -0.0046104, 0.0002056, + -0.0000843, -0.0001454, -0.0969912, -0.0643617, 0.1901189, + 0.2457944, -0.2175893, 0.5330546, -1.5975648, 0.8424604, + 0.7591643, 0.0104748, -0.0024021, 0.0001005, 0.0374270, + 0.0258674, -0.0742010, -0.0912397, 0.1119455, -0.2553151, + 0.6970016, -0.2006762, -0.8345362, 1.0321561, 0.2596025}, + std::vector{3, 3, 3, 3, 3}, + std::vector{3, 3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{60.460372, 34.353800, 28.467124, 19.209070, + 14.954731, 11.585351, 7.657167, 5.376603, + 3.587342, 2.054373, 1.197641}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4}, + std::vector{ + 0.0025074, 0.4434644, 0.4999990, 0.1592036, -0.0479455, + 0.0173030, -0.0040757, 0.0016040, -0.0004827, 0.0001158, + -0.0000325, -0.0009314, -0.2486235, -0.3190699, 0.0322588, + 0.5559391, 0.5151074, 0.0429752, -0.0065541, 0.0014416, + -0.0003336, 0.0000803, 0.0004951, 0.1107118, 0.1520348, + -0.0578188, -0.2141228, -0.5171513, 0.4253201, 0.7519919, + 0.1204323, -0.0005976, 0.0001207, -0.0000702, -0.0331798, + -0.0435882, 0.0076451, 0.0909319, 0.1329712, -0.1006215, + -0.3868394, 0.1015471, 0.6756351, 0.4010019}, + std::vector{5, 5, 5, 1}, std::vector{5, 5, 5, 0}), + SlaterTypeAtomicShell( + 3, + std::vector{32.467146, 20.059113, 13.102908, 8.251545, + 7.711586, 4.587557, 2.847582, 1.776473}, + std::vector{4, 4, 4, 5, 4, 4, 4, 4}, + std::vector{ + 0.0173290, 0.2570496, 0.5549359, -0.2495822, 0.4970536, + 0.0010352, -0.0000734, 0.0000457, -0.0054495, -0.0942117, + -0.1800340, 0.2512498, -0.1889442, 0.5524970, 0.3919522, + 0.0936136}, + std::vector{7, 4}, std::vector{7, 0})})}, + {94, + SlaterTypeAtom( + 94, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Pu + * + * Etot=-27008.719247227 Ekin=27008.719238005 + */ + SlaterTypeAtomicShell( + 0, + std::vector{107.536668, 91.001119, 75.300845, + 44.082884, 39.184732, 27.656392, 21.755071, + 12.225155, 12.224417, 6.549731, 5.344848, + 2.619722, + 1.934627, + .814951, .595810}, + std::vector{1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + .1436556, .8589779, -.0034071, .0035098, -.0029156, + .0028110, -.0020805, -.0008883, .0011832, .0004202, + -.0002610, .0000493, -.0000281, .0000072, -.0000040, + .0384552, -.3997613, -.2548158, 1.1893240, .0943748, + -.0030589, .0019434, .0007847, -.0012633, -.0002363, + .0001503, -.0000283, .0000155, -.0000039, .0000022, + -.0108789, .1831559, .1454995, -.6418875, -.5300659, + .8780865, .6462112, -.0016041, .0081125, -.0015257, + .0007922, -.0001330, .0000835, -.0000215, .0000122, + .0059652, -.0957899, -.0764420, .3374439, .3462940, + -.2544247, -1.3344042, -.0464556, 1.6681655, .0339193, + -.0102222, .0004367, -.0002406, .0000318, -.0000159, + -.0048504, .0499698, .0357783, -.1634792, -.1936684, + .1280517, .7497862, -.7227331, -1.0435061, 1.1736051, + .5539151, .0067195, -.0011027, .0001579, -.0000788, + .0016712, -.0200630, -.0150051, .0676024, .0787458, + -.0444394, -.3251499, .4000135, .4580358, -.4401745, + -.8160559, 1.0496782, .3014185, -.0032962, .0016022, + -.0006464, .0054881, .0036628, -.0171369, -.0216858, + .0151179, .0796825, -.1185972, -.1133358, .1304115, + .2240666, -.2878553, -.2343831, .7013616, .4186423}, + std::vector{1, 1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{90.239526, 50.777857, 45.540763, 27.998986, + 27.995154, 15.561206, 14.518508, 11.137490, + 6.391201, 5.039168, 2.307997, 1.580052}, + std::vector{2, 2, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + -.0045190, -.7333913, -.2747242, -.0394074, .0240194, + .0129158, -.0152814, -.0031190, .0006333, -.0003160, + .0000366, -.0000152, -.0014786, -.3805807, -.2513376, + .5962364, .4031346, -.2722243, .4555404, .0199546, + -.0034783, .0014264, -.0001393, .0000561, .0004775, + .1993453, .1368721, -.3406972, -.3965095, .9610987, + -.7647791, .8869277, .0200532, -.0044921, .0002515, + -.0000995, -.0001273, -.0965141, -.0643105, .1726608, + .2481790, -.2563021, .6768772, -1.6919159, .9001289, + .7029094, .0103642, -.0024517, .0000794, .0360158, + .0247544, -.0651927, -.0908506, .1102291, -.3068832, + .7386558, -.2889960, -.6988913, .9491279, .3129415}, + std::vector{3, 3, 3, 3, 3}, + std::vector{3, 3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{61.400727, 34.750009, 28.815000, 19.517891, + 14.876307, 11.601501, 8.051959, 5.509317, + 3.624359}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4}, + std::vector{.0024160, .4446110, .4995353, .1537642, + -.0435339, .0177018, -.0040757, .0010280, + -.0001972, -.0009037, -.2502599, -.3215019, + .0447868, .6093909, .4518300, .0390323, + -.0026048, .0003716, .0004816, .1118385, + .1538140, -.0627262, -.2385776, -.5273033, + .4394790, .7687511, .1277065}, + std::vector{5, 5, 5}, std::vector{5, 5, 5}), + SlaterTypeAtomicShell( + 3, + std::vector{32.847883, 20.322362, 13.247147, 8.319856, + 7.796263, 4.624658, 2.844790, 1.765028}, + std::vector{4, 4, 4, 5, 4, 4, 4, 4}, + std::vector{.0174196, .2605935, .5671416, -.2306420, + .4611818, .0013215, -.0001339, .0000602, + -.0054853, -.0953211, -.1850768, .2536835, + -.1667725, .5489358, .3806911, .0989754}, + std::vector{7, 6}, std::vector{7, 0})})}, + {95, + SlaterTypeAtom( + 95, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Am + * + * Etot=-27695.887018041 Ekin=27695.887174718 + */ + SlaterTypeAtomicShell( + 0, + std::vector{108.514351, 91.949998, 76.105473, + 44.549019, 39.617958, 27.944494, 21.936836, + 12.509773, 12.508435, 6.663735, 5.436424, + 2.662610, + 1.961718, + .825118, .602749}, + std::vector{1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + .1460397, .8566752, -.0035220, .0035220, -.0029320, + .0028444, -.0021445, -.0009165, .0012523, .0004133, + -.0002568, .0000482, -.0000274, .0000070, -.0000040, + .0389136, -.4005491, -.2549536, 1.1910776, .0926845, + -.0028822, .0018647, .0007543, -.0012500, -.0002088, + .0001338, -.0000252, .0000137, -.0000035, .0000019, + -.0109858, .1835816, .1457190, -.6433276, -.5322748, + .8949320, .6340188, .0003242, .0046686, -.0019533, + .0010268, -.0001673, .0001018, -.0000261, .0000147, + .0061325, -.0963816, -.0766169, .3387576, .3502018, + -.2697073, -1.3406216, -.0062252, 1.6462872, .0336752, + -.0099841, .0003999, -.0002179, .0000266, -.0000130, + -.0050704, .0506518, .0359256, -.1647040, -.1976515, + .1406855, .7482576, -.7762846, -1.0053026, 1.1844968, + .5469034, .0070352, -.0012743, .0002011, -.0001031, + .0017815, -.0203065, -.0149782, .0678004, .0803468, + -.0503220, -.3218277, .4284102, .4361602, -.4599069, + -.7938077, 1.0383038, .3083097, -.0034847, .0017022, + -.0006775, .0055068, .0036111, -.0170005, -.0219235, + .0166608, .0776063, -.1252341, -.1058402, .1351714, + .2143545, -.2797509, -.2343521, .6849676, .4333643}, + std::vector{1, 1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{91.104106, 51.359787, 46.111052, 28.473803, + 28.476350, 15.819973, 14.584813, 11.386274, + 6.553568, 5.147036, 2.343903, 1.602802}, + std::vector{2, 2, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + -.0045020, -.7326890, -.2746159, -.0406652, .0247692, + .0141849, -.0168016, -.0030283, .0006250, -.0003067, + .0000356, -.0000149, -.0014705, -.3806881, -.2503600, + .5757745, .4111776, -.3105350, .5097992, .0126433, + -.0029013, .0011482, -.0001126, .0000456, .0004760, + .1999900, .1365824, -.3252391, -.3973227, 1.0201164, + -.8823064, .9319989, .0214162, -.0046461, .0002754, + -.0001096, -.0001280, -.0973701, -.0644983, .1652237, + .2491890, -.2906020, .7910788, -1.7800021, .8914003, + .7233854, .0103265, -.0024473, .0000820, .0361360, + .0247506, -.0620665, -.0904064, .1244550, -.3558312, + .7758419, -.2924829, -.6929968, .9387166, .3181897}, + std::vector{3, 3, 3, 3, 3}, + std::vector{3, 3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{62.341082, 35.192142, 29.205796, 19.795476, + 15.067734, 11.821831, 8.312521, 5.652153, + 3.713707}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4}, + std::vector{.0023061, .4438410, .4994426, .1551124, + -.0451968, .0190414, -.0043878, .0010181, + -.0001955, -.0008545, -.2508651, -.3231736, + .0433156, .6163186, .4435902, .0414950, + -.0023050, .0003646, .0004640, .1130190, + .1560230, -.0635875, -.2359800, -.5495609, + .4427289, .7787461, .1300230}, + std::vector{5, 5, 5}, std::vector{5, 5, 5}), + SlaterTypeAtomicShell( + 3, + std::vector{33.485222, 20.732321, 13.553845, 8.696144, + 8.184470, 4.844213, 2.996931, 1.866870}, + std::vector{4, 4, 4, 5, 4, 4, 4, 4}, + std::vector{.0165266, .2558343, .5650694, -.2009870, + .4385830, .0017356, -.0002246, .0000521, + -.0052732, -.0962791, -.1867930, .2528636, + -.1842378, .5515984, .3850291, .1022711}, + std::vector{7, 7}, std::vector{7, 0})})}, + {96, + SlaterTypeAtom( + 96, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Cm + * + * Etot=-28392.770961608 Ekin=28392.770991566 + */ + SlaterTypeAtomicShell( + 0, + std::vector{109.612751, 92.936745, 76.950992, + 44.998600, 40.035230, 28.287682, 22.155737, + 12.809142, 12.807190, 6.672423, 5.474202, + 2.789448, + 2.064744, + 0.896377, + 0.641591}, + std::vector{1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.1457739, 0.8569268, -0.0035053, 0.0035054, -0.0029462, + 0.0028771, -0.0021975, -0.0009325, 0.0013121, 0.0004205, + -0.0002780, 0.0000571, -0.0000317, 0.0000075, -0.0000040, + 0.0389593, -0.4006377, -0.2550422, 1.1931275, 0.0902015, + -0.0025719, 0.0016864, 0.0006859, -0.0011829, -0.0001750, + 0.0001203, -0.0000250, 0.0000132, -0.0000031, 0.0000016, + -0.0109770, 0.1837645, 0.1458250, -0.6448156, -0.5360095, + 0.9037776, 0.6316244, 0.0021603, 0.0013414, -0.0024854, + 0.0014269, -0.0002538, 0.0001472, -0.0000345, 0.0000182, + 0.0061165, -0.0966925, -0.0768871, 0.3404227, 0.3538549, + -0.2769535, -1.3521588, 0.0429812, 1.6133999, 0.0351851, + -0.0119188, 0.0006370, -0.0003243, 0.0000416, -0.0000195, + -0.0051989, 0.0512726, 0.0361854, -0.1663909, -0.2019402, + 0.1495896, 0.7495505, -0.8321985, -0.9563855, 1.3017975, + 0.4252356, 0.0073113, -0.0012961, 0.0002062, -0.0000985, + 0.0018885, -0.0209909, -0.0153598, 0.0698018, 0.0839028, + -0.0556004, -0.3275466, 0.4675772, 0.4193337, -0.5171379, + -0.7981327, 1.0595774, 0.3270210, -0.0022251, 0.0010915, + -0.0006867, 0.0058217, 0.0038834, -0.0181982, -0.0233991, + 0.0179369, 0.0826867, -0.1384611, -0.1058510, 0.1492857, + 0.2329953, -0.3053938, -0.2457436, 0.6229734, 0.5052593}, + std::vector{1, 1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{92.375643, 52.048311, 46.755479, 28.969843, + 28.937060, 16.155524, 15.030526, 11.614807, + 6.659121, 5.292248, 2.433730, 1.651093}, + std::vector{2, 2, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + -0.0043285, -0.7287062, -0.2779879, -0.0422379, 0.0255911, + 0.0141049, -0.0167307, -0.0033257, 0.0006811, -0.0003456, + 0.0000377, -0.0000152, -0.0014223, -0.3789511, -0.2505372, + 0.5540005, 0.4242144, -0.2981920, 0.4990899, 0.0193092, + -0.0035789, 0.0015032, -0.0001378, 0.0000543, 0.0004718, + 0.1996065, 0.1371473, -0.3090416, -0.3994093, 1.0096628, + -0.9117542, 0.9549671, 0.0234032, -0.0057131, 0.0003092, + -0.0001223, -0.0001210, -0.0979745, -0.0650980, 0.1583838, + 0.2534729, -0.2676226, 0.8006235, -1.8165633, 0.8898696, + 0.7310071, 0.0100743, -0.0022957, 0.0000886, 0.0373032, + 0.0257901, -0.0610327, -0.0933263, 0.1231104, -0.3704743, + 0.8059597, -0.2668566, -0.7651239, 0.9962628, 0.2836083}, + std::vector{3, 3, 3, 3, 3}, + std::vector{3, 3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{63.281438, 35.762624, 29.732643, 20.338402, + 15.629075, 12.194421, 8.106496, 5.645416, + 3.705816, 2.098537, 1.201851}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4}, + std::vector{ + 0.0021388, 0.4379510, 0.4977560, 0.1624925, -0.0428277, + 0.0162799, -0.0037116, 0.0013245, -0.0003900, 0.0000942, + -0.0000268, -0.0007807, -0.2485072, -0.3228816, 0.0128543, + 0.5816735, 0.5063575, 0.0412005, -0.0056060, 0.0012931, + -0.0002952, 0.0000756, 0.0004338, 0.1133748, 0.1577942, + -0.0462592, -0.2330614, -0.5502053, 0.4864189, 0.7395945, + 0.0996661, -0.0009050, 0.0002808, -0.0000442, -0.0322109, + -0.0427339, 0.0037513, 0.0927599, 0.1356400, -0.1185316, + -0.3624088, 0.1315444, 0.6580025, 0.4023585}, + std::vector{5, 5, 5, 1}, std::vector{5, 5, 5, 0}), + SlaterTypeAtomicShell( + 3, + std::vector{33.822758, 20.974594, 13.682058, 8.829274, + 8.445016, 4.983619, 3.134988, 1.990129}, + std::vector{4, 4, 4, 5, 4, 4, 4, 4}, + std::vector{ + 0.0167613, 0.2600937, 0.5789462, -0.1389546, 0.3587465, + 0.0028061, -0.0004387, 0.0000925, -0.0056270, -0.1024179, + -0.2022137, 0.2395839, -0.1557370, 0.5680970, 0.3696676, + 0.0803504}, + std::vector{7, 7}, std::vector{7, 0})})}, + {97, + SlaterTypeAtom( + 97, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Bk + * + * Etot=-29099.83139408 Ekin=29099.831194369 + */ + SlaterTypeAtomicShell( + 0, + std::vector{110.699843, 93.919675, 77.746438, + 45.481241, 40.473190, 28.589737, 22.356593, + 13.102682, 13.101116, 6.776123, 5.561570, + 2.835207, + 2.098815, + .910937, .649692}, + std::vector{1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + .1457679, .8569284, -.0035086, .0034974, -.0029511, + .0029067, -.0022621, -.0009572, .0013806, .0004128, + -.0002742, .0000565, -.0000313, .0000073, -.0000039, + .0394389, -.4013003, -.2556131, 1.1943747, .0895413, + -.0027239, .0018006, .0007151, -.0012552, -.0001742, + .0001204, -.0000251, .0000132, -.0000031, .0000016, + -.0111785, .1842221, .1462231, -.6458938, -.5385884, + .9161492, .6236080, .0035950, -.0015996, -.0026680, + .0015315, -.0002681, .0001542, -.0000355, .0000186, + .0063240, -.0972803, -.0771630, .3415480, .3576288, + -.2881508, -1.3597697, .0873811, 1.5847192, .0365353, + -.0126901, .0007651, -.0003906, .0000560, -.0000269, + -.0054226, .0519146, .0363682, -.1674477, -.2058191, + .1604951, .7460039, -.8886224, -.9085497, 1.3133997, + .4141148, .0077828, -.0015242, .0002501, -.0001204, + .0019958, -.0212320, -.0153755, .0700279, .0855049, + -.0607443, -.3235534, .4972771, .3929104, -.5347427, + -.7777131, 1.0483251, .3346769, -.0020504, .0010264, + -.0007173, .0058624, .0038612, -.0181513, -.0237393, + .0193666, .0808033, -.1460761, -.0976081, .1541836, + .2246120, -.2974203, -.2491092, .6123837, .5156076}, + std::vector{1, 1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{93.295612, 52.603107, 47.296425, 29.420392, + 29.414711, 16.415002, + 15.073667, 11.874683, + 6.802757, 5.389001, 2.469651, 1.672196}, + std::vector{2, 2, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + -.0043066, -.7290202, -.2770461, -.0430827, .0260676, + .0152188, -.0181468, -.0030618, .0006412, -.0003229, + .0000355, -.0000144, -.0014050, -.3795963, -.2494507, + .5373019, .4278123, -.3421105, .5623898, .0089462, + -.0027647, .0011281, -.0001046, .0000414, .0004688, + .2004933, .1368775, -.2959189, -.3974160, 1.0753345, + -1.0493721, 1.0134902, .0247082, -.0059049, .0003336, + -.0001312, -.0001218, -.0988946, -.0652655, .1518435, + .2528225, -.3072139, .9351706, -1.9160768, .8914367, + .7382556, .0098753, -.0022330, .0000907, .0375163, + .0258156, -.0583176, -.0924686, .1396928, -.4300417, + .8512364, -.2775313, -.7538785, .9925248, .2835106}, + std::vector{3, 3, 3, 3, 3}, + std::vector{3, 3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{64.293214, 36.233835, 30.164001, 20.837165, + 15.686011, 12.214648, 8.219944, 5.676054, + 3.664204, 2.075910, 1.176063}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4}, + std::vector{ + .0020207, .4361436, .4958913, .1604699, -.0355344, + .0145153, -.0034852, .0011502, -.0003344, .0000845, + -.0000239, -.0007475, -.2483343, -.3240069, .0106592, + .6308654, .4628888, .0351893, -.0040579, .0009485, + -.0002289, .0000564, .0004090, .1141664, .1591904, + -.0397578, -.2756870, -.5355496, .5357972, .7249167, + .0833506, -.0013088, .0003197, -.0000349, -.0310459, + -.0412544, .0027386, .0989814, .1275632, -.1340026, + -.3339863, .1442840, .6443847, .4067204}, + std::vector{5, 5, 5, 1}, std::vector{5, 5, 5, 0}), + SlaterTypeAtomicShell( + 3, + std::vector{34.300865, 21.309989, 13.913638, 8.985940, + 8.603271, 5.070205, 3.182839, 2.022226}, + std::vector{4, 4, 4, 5, 4, 4, 4, 4}, + std::vector{.0164484, .2589570, .5839797, -.1352509, + .3500958, .0028374, -.0003389, .0001078, + -.0056095, -.1037726, -.2079473, .2528897, + -.1545272, .5710814, .3592487, .0772493}, + std::vector{7, 7}, std::vector{7, 1})})}, + {98, + SlaterTypeAtom( + 98, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Cf + * + * Etot=-29817.418706498 Ekin=29817.418749675 + */ + SlaterTypeAtomicShell( + 0, + std::vector{111.875922, 94.929823, 78.603768, + 45.933619, 40.930233, 28.869705, 22.532170, + 13.352997, 13.352629, 7.005320, 5.716672, + 2.804739, + 2.067300, + 0.845180, + 0.612276}, + std::vector{1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.1438653, 0.8587662, -0.0034235, 0.0034641, -0.0029303, + 0.0028988, -0.0023015, -0.0009869, 0.0014403, 0.0003938, + -0.0002457, 0.0000456, -0.0000255, 0.0000062, -0.0000035, + 0.0393326, -0.4011032, -0.2558131, 1.1961259, 0.0871355, + -0.0020908, 0.0014621, 0.0006103, -0.0011101, -0.0001229, + 0.0000820, -0.0000157, 0.0000081, -0.0000019, 0.0000011, + -0.0111501, 0.1843192, 0.1463017, -0.6469928, -0.5390839, + 0.9304552, 0.6127751, 0.0056422, -0.0056517, -0.0028968, + 0.0015487, -0.0002425, 0.0001399, -0.0000332, 0.0000188, + 0.0064546, -0.0977235, -0.0771950, 0.3424971, 0.3606379, + -0.3026099, -1.3660880, 0.1076020, 1.5805752, 0.0366072, + -0.0112758, 0.0005881, -0.0003124, 0.0000466, -0.0000246, + -0.0055045, 0.0522586, 0.0364529, -0.1682442, -0.2082502, + 0.1705347, 0.7443860, -0.9306212, -0.8870488, 1.2037579, + 0.5363006, 0.0077201, -0.0015564, 0.0002524, -0.0001332, + 0.0019724, -0.0208203, -0.0150197, 0.0685613, 0.0843203, + -0.0635043, -0.3136633, 0.5065497, 0.3711586, -0.4956960, + -0.7517861, 0.9885804, 0.3484117, -0.0029144, 0.0014694, + -0.0007332, 0.0055153, 0.0034926, -0.0166608, -0.0224730, + 0.0201323, 0.0719339, -0.1430550, -0.0842184, 0.1431913, + 0.1931930, -0.2510578, -0.2392202, 0.6842411, 0.4275269}, + std::vector{1, 1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{94.276359, 53.232647, 47.902836, 29.893329, + 29.884412, 16.680927, 15.262992, 12.121953, + 6.992505, 5.450385, 2.459366, 1.676074}, + std::vector{2, 2, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + -0.0042445, -0.7269172, -0.2783860, -0.0445325, 0.0268499, + 0.0159588, -0.0190442, -0.0030802, 0.0006142, -0.0002911, + 0.0000338, -0.0000143, -0.0013877, -0.3788920, -0.2489153, + 0.5186532, 0.4355608, -0.3636972, 0.5954029, 0.0055279, + -0.0025242, 0.0009541, -0.0000972, 0.0000399, 0.0004708, + 0.2006187, 0.1369209, -0.2822518, -0.3979065, 1.1096284, + -1.1389670, 1.0553365, 0.0256213, -0.0053179, 0.0003535, + -0.0001403, -0.0001242, -0.0991731, -0.0654102, 0.1448658, + 0.2530579, -0.3204079, 1.0245052, -1.9965948, 0.8855063, + 0.7550227, 0.0101604, -0.0023664, 0.0000845, 0.0363127, + 0.0248770, -0.0537443, -0.0900228, 0.1333142, -0.4521538, + 0.8671024, -0.3080866, -0.6731104, 0.9096380, 0.3369377}, + std::vector{3, 3, 3, 3, 3}, + std::vector{3, 3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{65.304989, 36.639006, 30.509173, 21.007637, + 15.708765, 12.348554, 8.848061, 5.968833, + 3.898454}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4}, + std::vector{ + 0.0019301, 0.4369901, 0.4968820, 0.1596459, -0.0390571, + 0.0177828, -0.0043631, 0.0008966, -0.0001758, -0.0007068, + -0.2497374, -0.3265685, 0.0203560, 0.6629813, 0.4160922, + 0.0401529, -0.0015168, 0.0003440, 0.0004005, 0.1150118, + 0.1612201, -0.0484321, -0.2718837, -0.5790154, 0.4944454, + 0.7769690, 0.1191100}, + std::vector{5, 5, 5}, std::vector{5, 5, 5}), + SlaterTypeAtomicShell( + 3, + std::vector{34.834611, 21.648291, 14.121613, 9.268811, + 9.107124, 5.183159, 3.200821, 1.986833}, + std::vector{4, 4, 4, 5, 4, 4, 4, 4}, + std::vector{ + 0.0159877, 0.2584705, 0.5923681, -0.0682969, 0.2771927, + 0.0034340, -0.0002859, 0.0001446, -0.0053753, -0.1029228, + -0.2066520, 0.2367190, -0.1375522, 0.5589028, 0.3656115, + 0.0954020}, + std::vector{7, 7}, std::vector{7, 3})})}, + {99, + SlaterTypeAtom( + 99, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Es + * + * Etot=-30544.971971799 Ekin=30544.972073537 + */ + SlaterTypeAtomicShell( + 0, + std::vector{113.057181, 95.941596, 79.416372, + 46.420884, 41.383502, 29.196911, 22.759322, + 13.642658, 13.642655, 7.115866, 5.812747, + 2.845530, + 2.094916, + .852686, .616339}, + std::vector{1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + .1419005, .8606608, -.0033386, .0034388, -.0029247, + .0029161, -.0023532, -.0010049, .0014981, .0003853, + -.0002411, .0000442, -.0000246, .0000059, -.0000034, + .0395710, -.4013389, -.2565251, 1.1969701, .0868766, + -.0023335, .0016611, .0006804, -.0012383, -.0001415, + .0000941, -.0000177, .0000093, -.0000022, .0000012, + -.0113946, .1847590, .1465841, -.6474645, -.5418164, + .9361168, .6112334, .0070614, -.0086374, -.0030833, + .0016558, -.0002550, .0001462, -.0000345, .0000196, + .0066097, -.0981965, -.0774860, .3434268, .3636321, + -.3069887, -1.3770720, .1504028, 1.5506589, .0383352, + -.0121244, .0006924, -.0003664, .0000591, -.0000317, + -.0056652, .0527739, .0366503, -.1691562, -.2114515, + .1772964, .7416387, -.9850523, -.8375474, 1.2031217, + .5367645, .0080291, -.0017032, .0002810, -.0001493, + .0020331, -.0209549, -.0150389, .0686639, .0853726, + -.0663777, -.3099981, .5323505, .3447785, -.5005692, + -.7404148, .9771131, .3554018, -.0028443, .0014407, + -.0007459, .0055085, .0034642, -.0165407, -.0225860, + .0208296, .0700393, -.1485996, -.0763100, .1434700, + .1879379, -.2447455, -.2386982, .6792990, .4309606}, + std::vector{1, 1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{94.620539, 53.578603, 48.286953, 32.337911, + 30.388793, 17.224036, + 17.059945, 12.319790, + 7.027037, 5.502393, 2.501660, 1.703475}, + std::vector{2, 2, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + -.0044414, -.7337124, -.2705810, -.0365660, .0168048, + .0086423, -.0107908, -.0030559, .0005189, -.0002523, + .0000293, -.0000122, -.0014721, -.3829110, -.2480581, + .4178846, .5523292, -.1879467, .3977531, .0344945, + -.0044386, .0017874, -.0001801, .0000732, .0005254, + .2032428, .1371068, -.2225241, -.4516253, .8087502, + -.8503501, 1.0342001, .0271219, -.0062903, .0004387, + -.0001717, -.0001269, -.1009905, -.0651127, .1160215, + .2882260, -.0644447, .6991868, -1.9074558, .9320064, + .7016593, .0099792, -.0023136, .0000792, .0368073, + .0245227, -.0430135, -.1038199, .0146462, -.3046647, + .8314537, -.3420493, -.6343600, .8955315, .3496188}, + std::vector{3, 3, 3, 3, 3}, + std::vector{3, 3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{66.137520, 37.115763, 30.941761, 21.376642, + 15.949616, 12.583516, + 9.109259, 6.116274, 3.995607}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4}, + std::vector{.0018474, .4349363, .4959896, .1622752, + -.0391932, .0183807, -.0045622, .0008746, + -.0001735, -.0006711, -.2494555, -.3273611, + .0130083, .6679902, .4138067, .0430046, + -.0012679, .0003459, .0003903, .1155788, + .1628010, -.0452600, -.2700131, -.6009865, + .4940577, .7867131, .1234768}, + std::vector{5, 5, 5}, std::vector{5, 5, 5}), + SlaterTypeAtomicShell( + 3, + std::vector{35.378820, 22.011322, 14.373323, 9.446536, + 9.271063, 5.285284, 3.259830, 2.025012}, + std::vector{4, 4, 4, 5, 4, 4, 4, 4}, + std::vector{.0154794, .2560824, .5962524, -.0697409, + .2762219, .0033936, -.0002036, .0001508, + -.0052708, -.1036081, -.2119565, .2471170, + -.1395023, .5628926, .3587591, .0914460}, + std::vector{7, 7}, std::vector{7, 4})})}, + {100, + SlaterTypeAtom( + 100, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Fm + * + * Etot=-31282.777381624 Ekin=31282.777465902 + */ + SlaterTypeAtomicShell( + 0, + std::vector{114.194993, 96.939536, 80.272446, + 46.871137, 41.840267, 29.525508, 22.997665, + 13.929243, 13.927724, 7.220250, 5.896912, + 2.884439, + 2.118890, + 0.860726, + 0.620714}, + std::vector{1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.1408700, 0.8616598, -0.0033009, 0.0034233, -0.0029287, + 0.0029381, -0.0024059, -0.0010200, 0.0015523, 0.0003739, + -0.0002344, 0.0000428, -0.0000238, 0.0000057, -0.0000033, + 0.0394851, -0.4012189, -0.2566108, 1.1987077, 0.0844499, + -0.0016998, 0.0013005, 0.0005568, -0.0010642, -0.0000921, + 0.0000639, -0.0000124, 0.0000063, -0.0000015, 0.0000008, + -0.0114126, 0.1849384, 0.1465388, -0.6484021, -0.5430780, + 0.9396990, 0.6110312, 0.0082153, -0.0112320, -0.0031699, + 0.0017035, -0.0002600, 0.0001482, -0.0000350, 0.0000198, + 0.0066378, -0.0985176, -0.0776110, 0.3446116, 0.3656603, + -0.3090754, -1.3883210, 0.1913731, 1.5208755, 0.0401977, + -0.0130686, 0.0008274, -0.0004357, 0.0000756, -0.0000410, + -0.0057566, 0.0531954, 0.0367754, -0.1701948, -0.2140152, + 0.1824828, 0.7388707, -1.0373638, -0.7884216, 1.2108487, + 0.5286860, 0.0081122, -0.0017553, 0.0002946, -0.0001568, + 0.0020730, -0.0210569, -0.0150162, 0.0687857, 0.0861939, + -0.0687535, -0.3058988, 0.5574892, 0.3182334, -0.5133332, + -0.7215356, 0.9691344, 0.3593683, -0.0028707, 0.0014535, + -0.0007535, 0.0054959, 0.0034289, -0.0164367, -0.0226428, + 0.0213798, 0.0681385, -0.1538622, -0.0685890, 0.1456379, + 0.1811399, -0.2401295, -0.2372250, 0.6726867, 0.4364098}, + std::vector{1, 1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{95.277198, 54.082634, 48.811191, 33.394546, + 30.941803, 17.591402, 17.586481, 12.569014, + 7.131364, 5.581213, 2.539015, 1.726341}, + std::vector{2, 2, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + -0.0045122, -0.7354322, -0.2674683, -0.0364398, 0.0151756, + 0.0076801, -0.0097988, -0.0027794, 0.0004620, -0.0002267, + 0.0000266, -0.0000111, -0.0015025, -0.3842516, -0.2467221, + 0.3835987, 0.5755022, -0.1778216, 0.4007038, 0.0341891, + -0.0043278, 0.0017508, -0.0001788, 0.0000726, 0.0005450, + 0.2044700, 0.1366002, -0.1991211, -0.4550108, 0.7707727, + -0.8818673, 1.0784983, 0.0283924, -0.0066914, 0.0004784, + -0.0001864, -0.0001242, -0.1020537, -0.0647394, 0.1040589, + 0.2925419, -0.0206699, 0.7104373, -1.9535680, 0.9455603, + 0.6895804, 0.0097899, -0.0022477, 0.0000798, 0.0369866, + 0.0242940, -0.0384723, -0.1047998, -0.0057264, -0.3067326, + 0.8491683, -0.3544645, -0.6170947, 0.8848237, 0.3575362}, + std::vector{3, 3, 3, 3, 3}, + std::vector{3, 3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{66.970050, 37.554036, 31.341249, 21.738456, + 16.112877, 12.720276, 9.295969, 6.209658, + 4.043504}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4}, + std::vector{ + 0.0017890, 0.4343495, 0.4947945, 0.1624089, -0.0373370, + 0.0180682, -0.0046126, 0.0008258, -0.0001651, -0.0006497, + -0.2499826, -0.3283106, 0.0104194, 0.6898988, 0.3942821, + 0.0425400, -0.0010058, 0.0003402, 0.0003771, 0.1165277, + 0.1641611, -0.0424192, -0.2862497, -0.6089090, 0.5179644, + 0.7858385, 0.1185226}, + std::vector{5, 5, 5}, std::vector{5, 5, 5}), + SlaterTypeAtomicShell( + 3, + std::vector{35.941015, 22.375531, 14.616611, 9.609589, + 9.535894, 5.379614, 3.315605, 2.061897}, + std::vector{4, 4, 4, 5, 4, 4, 4, 4}, + std::vector{ + 0.0149429, 0.2538679, 0.6017065, -0.0540005, 0.2571561, + 0.0035731, -0.0001186, 0.0001753, -0.0051511, -0.1042033, + -0.2181763, 0.2485000, -0.1306147, 0.5658439, 0.3514027, + 0.0878651}, + std::vector{7, 7}, std::vector{7, 5})})}, + {101, + SlaterTypeAtom( + 101, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Md + * + * Etot=-32030.932747565 Ekin=32030.932800758 + */ + SlaterTypeAtomicShell( + 0, + std::vector{115.391891, 97.954198, 81.129010, + 47.332097, 42.320127, 29.834074, 23.236958, + 14.207334, 14.206628, 7.354132, 6.016394, + 2.915143, + 2.137287, + 0.868222, + 0.624338}, + std::vector{1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.1387007, 0.8637621, -0.0032184, 0.0034018, -0.0029223, + 0.0029566, -0.0024654, -0.0010423, 0.0016115, 0.0003703, + -0.0002310, 0.0000407, -0.0000227, 0.0000056, -0.0000031, + 0.0393327, -0.4009507, -0.2568815, 1.1999673, 0.0826898, + -0.0011652, 0.0010186, 0.0004685, -0.0009347, -0.0000608, + 0.0000448, -0.0000088, 0.0000043, -0.0000010, 0.0000006, + -0.0114802, 0.1851420, 0.1464984, -0.6488705, -0.5431963, + 0.9430390, 0.6091989, 0.0090713, -0.0133204, -0.0031974, + 0.0017020, -0.0002481, 0.0001421, -0.0000338, 0.0000191, + 0.0067210, -0.0988838, -0.0776931, 0.3454397, 0.3670729, + -0.3102048, -1.3993738, 0.2281715, 1.4944859, 0.0423528, + -0.0139344, 0.0009005, -0.0004784, 0.0000874, -0.0000476, + -0.0058566, 0.0536066, 0.0368801, -0.1710300, -0.2160638, + 0.1867612, 0.7360743, -1.0875373, -0.7430410, 1.1840322, + 0.5570785, 0.0084677, -0.0019402, 0.0003303, -0.0001759, + 0.0020815, -0.0211037, -0.0150194, 0.0688760, 0.0865612, + -0.0699546, -0.3030232, 0.5787286, 0.2951928, -0.4970305, + -0.7283184, 0.9656736, 0.3561557, -0.0028583, 0.0014392, + -0.0007466, 0.0054638, 0.0034090, -0.0163474, -0.0225590, + 0.0215364, 0.0667691, -0.1579232, -0.0621286, 0.1398206, + 0.1818166, -0.2379489, -0.2333172, 0.6685742, 0.4396392}, + std::vector{1, 1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{95.948792, 54.581376, 49.331192, 34.497757, + 31.491063, 17.908716, 17.907648, 12.793148, + 7.268828, 5.674396, 2.570074, 1.744131}, + std::vector{2, 2, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + -0.0045776, -0.7373153, -0.2641188, -0.0363809, 0.0133867, + 0.0069554, -0.0088859, -0.0024995, 0.0004070, -0.0001980, + 0.0000231, -0.0000097, -0.0015402, -0.3856345, -0.2458139, + 0.3532552, 0.5965129, -0.1828417, 0.4155587, 0.0348440, + -0.0043721, 0.0017456, -0.0001787, 0.0000728, 0.0005644, + 0.2057248, 0.1361881, -0.1788596, -0.4583021, 0.7737909, + -0.9297820, 1.1038132, 0.0293378, -0.0067581, 0.0004908, + -0.0001916, -0.0001286, -0.1030817, -0.0645509, 0.0933026, + 0.2949639, -0.0150088, 0.7448659, -1.9909940, 0.9434374, + 0.6977626, 0.0096707, -0.0022198, 0.0000836, 0.0371323, + 0.0241469, -0.0343753, -0.1048525, -0.0086991, -0.3189347, + 0.8614517, -0.3575239, -0.6089449, 0.8781403, 0.3600879}, + std::vector{3, 3, 3, 3, 3}, + std::vector{3, 3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{67.396992, 37.977966, 31.739815, 22.096008, + 16.329719, 12.928930, 9.503720, 6.324569, + 4.112831}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4}, + std::vector{ + 0.0018018, 0.4340911, 0.4929951, 0.1634259, -0.0364908, + 0.0180152, -0.0046140, 0.0007797, -0.0001581, -0.0006551, + -0.2507179, -0.3286528, 0.0058138, 0.6983340, 0.3878846, + 0.0442815, -0.0008967, 0.0003581, 0.0003824, 0.1175069, + 0.1653317, -0.0398263, -0.2894925, -0.6239066, 0.5283939, + 0.7886670, 0.1179015}, + std::vector{5, 5, 5}, std::vector{5, 5, 5}), + SlaterTypeAtomicShell( + 3, + std::vector{36.511074, 22.750806, 14.880176, 9.847647, + 9.835102, 5.518981, 3.405016, 2.116027}, + std::vector{4, 4, 4, 5, 4, 4, 4, 4}, + std::vector{ + 0.0143953, 0.2509049, 0.6042434, -0.0418247, 0.2453018, + 0.0036293, 0.0000479, 0.0001910, -0.0050084, -0.1045139, + -0.2218970, 0.2488345, -0.1319842, 0.5670575, 0.3503629, + 0.0880302}, + std::vector{7, 7}, std::vector{7, 6})})}, + {102, + SlaterTypeAtom( + 102, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for No + * + * Etot=-32789.511914766 Ekin=32789.511728104 + */ + SlaterTypeAtomicShell( + 0, + std::vector{116.592615, 98.971720, 81.969966, + 47.801013, 42.780237, 30.158811, 23.466434, + 14.471178, 14.467021, 7.485979, 6.115088, + 2.946806, + 2.155517, + .876639, .629030}, + std::vector{1, 1, 2, 2, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + .1364676, .8659139, -.0031134, .0033671, -.0029063, + .0029562, -.0025009, -.0010589, .0016598, .0003613, + -.0002233, .0000390, -.0000218, .0000054, -.0000030, + .0393215, -.4008501, -.2573282, 1.2011636, .0814267, + -.0009850, .0009497, .0004551, -.0009204, -.0000545, + .0000409, -.0000081, .0000040, -.0000010, .0000005, + -.0115945, .1853961, .1466151, -.6494591, -.5448679, + .9474120, .6084230, .0104448, -.0164162, -.0033139, + .0017452, -.0002508, .0001437, -.0000346, .0000195, + .0068190, -.0992593, -.0778695, .3463486, .3694243, + -.3135844, -1.4101384, .2551998, 1.4783337, .0442524, + -.0145965, .0009991, -.0005337, .0001026, -.0000561, + -.0059169, .0539525, .0370768, -.1719749, -.2183128, + .1910351, .7352500, -1.1296356, -.7084604, 1.1710426, + .5735763, .0082731, -.0018701, .0003172, -.0001680, + .0020751, -.0211187, -.0150525, .0689825, .0869743, + -.0711191, -.3008970, .5964934, .2770787, -.4941868, + -.7237010, .9613819, .3549266, -.0028951, .0014503, + -.0007375, .0054285, .0033974, -.0162704, -.0225073, + .0216897, .0656491, -.1612179, -.0569932, .1376932, + .1795510, -.2353908, -.2304471, .6599199, .4475546}, + std::vector{1, 1, 1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{96.397692, 55.002426, 49.802487, 35.839240, + 32.064262, 18.129395, 18.025153, 12.950104, + 7.458310, 5.783785, 2.597180, 1.759335}, + std::vector{2, 2, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + -.0047339, -.7415176, -.2578971, -.0362544, .0109512, + .0061198, -.0076054, -.0021857, .0003556, -.0001667, + .0000193, -.0000081, -.0016179, -.3882385, -.2450315, + .3229765, .6211588, -.2027213, .4399591, .0382717, + -.0049374, .0019065, -.0001964, .0000809, .0005942, + .2076598, .1355469, -.1595406, -.4645107, .8342880, + -.9826939, 1.0841796, .0287858, -.0059307, .0004321, + -.0001696, -.0001556, -.1043629, -.0646260, .0821625, + .2941388, -.0702979, .7998145, -1.9981090, .9280226, + .7294651, .0096390, -.0022341, .0001003, .0373332, + .0241938, -.0301668, -.1030213, .0162568, -.3404168, + .8579754, -.3513832, -.6122229, .8727290, .3604510}, + std::vector{3, 3, 3, 3, 3}, + std::vector{3, 3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{67.827414, 38.426897, 32.165816, 22.509172, + 16.602324, 13.180192, 9.669792, 6.431985, + 4.179803}, + std::vector{3, 3, 4, 4, 4, 4, 4, 4, 4}, + std::vector{.0018034, .4329225, .4907430, .1654909, + -.0347585, .0171925, -.0043185, .0007127, + -.0001478, -.0006550, -.2508932, -.3284640, + -.0026462, .6968628, .3946168, .0456965, + -.0009084, .0003860, .0003875, .1181715, + .1662275, -.0351180, -.2878379, -.6363817, + .5336724, .7881967, .1169122}, + std::vector{5, 5, 5}, std::vector{5, 5, 5}), + SlaterTypeAtomicShell( + 3, + std::vector{37.081617, 23.121378, 15.134123, 10.033310, + 10.032716, 5.628460, 3.475147, 2.163825}, + std::vector{4, 4, 4, 5, 4, 4, 4, 4}, + std::vector{.0138844, .2484870, .6083247, -.0399880, + .2415370, .0028220, -.0003651, .0000742, + -.0048541, -.1043918, -.2260613, .2544537, + -.1315052, .5692081, .3455787, .0857519}, + std::vector{7, 7}, std::vector{7, 7})})}}; diff --git a/include/integratorxx/atomic_densities/k99l_anion.hpp b/include/integratorxx/atomic_densities/k99l_anion.hpp new file mode 100644 index 0000000..14ef891 --- /dev/null +++ b/include/integratorxx/atomic_densities/k99l_anion.hpp @@ -0,0 +1,2311 @@ +#include "SlaterAtomicShell.hpp" +#include +static const std::map k99l_anion{ + {1, + SlaterTypeAtom( + 1, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for H + * + * Etot=-0.487929734 Ekin=0.487929734 + */ + SlaterTypeAtomicShell( + 0, + std::vector{3.461036, 1.704290, 1.047762, 0.626983, + 0.392736, 0.304047}, + std::vector{2, 1, 1, 1, 1, 1}, + std::vector{0.0005803, 0.0754088, 0.2438040, 0.3476471, + 0.3357298, 0.0741188}, + std::vector{1}, std::vector{1})})}, + {2, SlaterTypeAtom(2, std::vector{})}, + {3, + SlaterTypeAtom( + 3, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Li + * + * Etot=-7.428232059 Ekin=7.428232059 + */ + SlaterTypeAtomicShell( + 0, + std::vector{10.425629, 5.519814, 3.412780, 2.409164, + 1.431054, 0.712248, 0.325496, 0.246090, + 0.170515}, + std::vector{1, 1, 1, 1, 1, 2, 1, 2, 1}, + std::vector{ + 0.0013502, -0.0530207, -0.1534049, -0.8060139, -0.0043575, + 0.0002544, -0.0001533, 0.0001577, -0.0001454, 0.0001816, + -0.0043493, -0.0298684, -0.0112505, -0.2120289, 0.1374335, + 0.7291380, 0.1614524, 0.0987841}, + std::vector{1, 1}, std::vector{1, 1})})}, + {4, SlaterTypeAtom(4, std::vector{})}, + {5, + SlaterTypeAtom( + 5, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for B + * + * Etot=-24.519221361 Ekin=24.51922136 + */ + SlaterTypeAtomicShell( + 0, + std::vector{15.943800, 7.666923, 6.168477, 4.180044, + 2.377138, 2.095029, 0.942132, 0.623905, + 0.230077}, + std::vector{2, 1, 2, 1, 1, 2, 1, 1, 1}, + std::vector{ + 0.0005772, 0.2253930, 0.1429940, 0.6591629, -0.0000833, + 0.0010341, 0.0003328, 0.0001253, 0.0000050, -0.0001176, + 0.0135701, 0.0352836, -0.2012845, -0.4143896, 0.0986559, + 0.8873742, 0.3004764, 0.0017500}, + std::vector{1, 1}, std::vector{1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{12.230333, 5.660905, 2.245340, 1.755314, + 1.007474, 0.593488, 0.353591, 0.230077}, + std::vector{3, 2, 3, 2, 2, 2, 2, 2}, + std::vector{0.0000408, 0.0059618, -0.0527056, + 0.2926410, 0.3761995, 0.3436074, 0.1755626, + 0.0120746}, + std::vector{2}, std::vector{0})})}, + {6, + SlaterTypeAtom( + 6, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for C + * + * Etot=-37.708843613 Ekin=37.708843614 + */ + SlaterTypeAtomicShell( + 0, + std::vector{18.920161, 9.204405, 7.499563, 5.079154, + 3.263494, 2.347924, 1.219231, 0.842734, + 0.392560}, + std::vector{2, 1, 2, 1, 1, 2, 1, 1, 1}, + std::vector{ + -0.0005423, -0.2314477, -0.1507135, -0.6430904, -0.0022351, + -0.0014913, -0.0001203, -0.0003117, 0.0000043, -0.0001251, + 0.0128461, 0.0309079, -0.1919809, -0.3898360, 0.0663604, + 0.7370742, 0.4387447, 0.0022083}, + std::vector{1, 1}, std::vector{1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{14.841621, 6.932628, 2.773007, 2.199863, + 1.282317, 0.793656, 0.523330, 0.392560}, + std::vector{3, 2, 3, 2, 2, 2, 2, 2}, + std::vector{0.0000477, 0.0062055, -0.0768275, + 0.3788502, 0.3930492, 0.3014878, 0.1173838, + 0.0051184}, + std::vector{3}, std::vector{0})})}, + {7, + SlaterTypeAtom( + 7, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for N + * + * Etot=-54.321958875 Ekin=54.321958875 + */ + SlaterTypeAtomicShell( + 0, + std::vector{21.938661, 10.856681, 8.909576, 6.067777, + 4.082589, 2.595892, 1.388357, 0.965463, + 0.432913}, + std::vector{2, 1, 2, 1, 1, 2, 1, 1, 1}, + std::vector{ + -0.0005078, -0.2080903, -0.1346853, -0.6711541, -0.0109793, + -0.0014067, -0.0001516, -0.0002992, 0.0000010, -0.0001243, + 0.0148869, 0.0297488, -0.1833422, -0.3856396, 0.1068689, + 0.8429430, 0.2729199, 0.0015565}, + std::vector{1, 1}, std::vector{1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{17.323397, 8.244327, 3.261863, 2.599742, + 1.481225, 0.888860, 0.570116, 0.432913}, + std::vector{3, 2, 3, 2, 2, 2, 2, 2}, + std::vector{0.0000491, 0.0056587, -0.1054546, + 0.4612442, 0.3948250, 0.2779229, 0.0979146, + 0.0022926}, + std::vector{3}, std::vector{1})})}, + {8, + SlaterTypeAtom( + 8, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for O + * + * Etot=-74.789745929 Ekin=74.789745907 + */ + SlaterTypeAtomicShell( + 0, + std::vector{25.016765, 12.463538, 10.294654, 7.040394, + 4.924651, 2.933290, 1.571277, 1.086933, + 0.509457}, + std::vector{2, 1, 2, 1, 1, 2, 1, 1, 1}, + std::vector{ + -0.0004660, -0.1969044, -0.1272168, -0.6798388, -0.0195203, + -0.0016231, -0.0001018, -0.0003173, 0.0000043, -0.0001224, + 0.0136299, 0.0260227, -0.1631544, -0.3892215, 0.1399950, + 0.8737968, 0.1945784, 0.0012193}, + std::vector{1, 1}, std::vector{1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{18.936558, 9.868234, 4.069436, 3.277663, + 1.941449, 1.183916, 0.739250, 0.509457}, + std::vector{3, 2, 3, 2, 2, 2, 2, 2}, + std::vector{0.0000688, 0.0043545, -0.0786626, + 0.3879735, 0.3724017, 0.3025918, 0.1405451, + 0.0085623}, + std::vector{3}, std::vector{2})})}, + {9, + SlaterTypeAtom( + 9, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for F + * + * Etot=-99.459453907 Ekin=99.459453916 + */ + SlaterTypeAtomicShell( + 0, + std::vector{27.859461, 14.198763, 11.780767, 8.031062, + 5.581766, 3.381103, 1.822975, 1.273691, + 0.601642}, + std::vector{2, 1, 2, 1, 1, 2, 1, 1, 1}, + std::vector{ + -0.0004533, -0.1771801, -0.1147043, -0.7054388, -0.0240787, + -0.0016901, -0.0002417, -0.0003235, 0.0000010, -0.0001162, + 0.0165729, 0.0264193, -0.1725638, -0.3974454, 0.1299886, + 0.8655486, 0.2209765, 0.0013423}, + std::vector{1, 1}, std::vector{1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{21.725428, 11.133649, 4.578593, 3.691125, + 2.175263, 1.339077, 0.854546, 0.601642}, + std::vector{3, 2, 3, 2, 2, 2, 2, 2}, + std::vector{0.0000591, 0.0041123, -0.0953385, + 0.4339485, 0.3711336, 0.2848333, 0.1279481, + 0.0077227}, + std::vector{3}, std::vector{3})})}, + {10, SlaterTypeAtom(10, std::vector{})}, + {11, + SlaterTypeAtom( + 11, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Na + * + * Etot=-161.85512594 Ekin=161.855125937 + */ + SlaterTypeAtomicShell( + 0, + std::vector{ + 33.336556, 17.598737, + 14.711404, 9.861039, 6.404866, 4.829528, 2.472014, + 1.193509, 0.391524, + 0.278296, 0.163409}, + std::vector{2, 1, 2, 1, 1, 2, 1, 1, 1, 2, 1}, + std::vector{ + -0.0004508, -0.1704241, -0.1142421, -0.7205942, -0.0151250, + -0.0015844, -0.0010215, 0.0000259, -0.0000053, 0.0000069, + -0.0000052, -0.0001007, 0.0302092, 0.0363231, -0.2555745, + -0.5003298, -0.0165269, 1.3397395, 0.0035027, -0.0002299, + 0.0002262, -0.0001631, 0.0000113, -0.0027062, -0.0033864, + 0.0233291, 0.0538025, -0.0090077, -0.0732966, -0.3143869, + 0.7793485, 0.2695675, 0.1628299}, + std::vector{1, 1, 1}, std::vector{1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{30.043629, 13.641469, 5.586447, 4.513905, + 2.629663, 1.869157, 0.632847, 0.163409}, + std::vector{3, 2, 3, 2, 2, 2, 2, 2}, + std::vector{0.0000391, 0.0041805, -0.1404590, + 0.5696933, 0.4801164, 0.1530404, 0.0012768, + 0.0000245}, + std::vector{3}, std::vector{3})})}, + {12, SlaterTypeAtom(12, std::vector{})}, + {13, + SlaterTypeAtom( + 13, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Al + * + * Etot=-241.878265202 Ekin=241.878265187 + */ + SlaterTypeAtomicShell( + 0, + std::vector{ + 36.399566, 20.293399, + 17.130849, 9.373457, 8.282543, 5.554571, 3.854464, + 2.087410, 0.811882, + 0.524197, 0.200917}, + std::vector{2, 1, 2, 2, 1, 2, 2, 1, 1, 1, 1}, + std::vector{ + -0.0005862, -0.2745534, -0.1936497, 0.3281195, -0.8498816, + 0.0026152, -0.0014977, 0.0003879, -0.0000525, 0.0000287, + -0.0000032, -0.0001532, 0.0179503, 0.0252617, 0.1929742, + -0.5672029, 0.3768408, 0.7095238, 0.0306829, -0.0008124, + 0.0005450, -0.0000422, 0.0000359, 0.0004280, -0.0016231, + -0.0113958, 0.1869008, 0.0277493, 0.0122557, -0.9429818, + 1.1632146, 0.2733734, 0.0024096}, + std::vector{1, 1, 1}, std::vector{1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{35.478457, 15.221279, 9.147023, 7.667927, + 4.286887, 2.732141, 2.504351, 1.009121, + 0.590791, 0.334303, 0.200917}, + std::vector{2, 3, 2, 3, 2, 3, 2, 2, 2, 2, 2}, + std::vector{ + -0.0000463, -0.0044618, 0.1384590, 0.0994466, 0.4739996, + -0.2294286, 0.5686738, 0.0010362, -0.0000047, 0.0000596, + -0.0000031, 0.0000070, 0.0006386, -0.0202861, -0.0172449, + -0.0580203, 0.0051942, -0.1354115, 0.3306397, 0.4862200, + 0.3060346, 0.0249529}, + std::vector{3, 2}, std::vector{3, 0})})}, + {14, + SlaterTypeAtom( + 14, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Si + * + * Etot=-288.889660201 Ekin=288.889660102 + */ + SlaterTypeAtomicShell( + 0, + std::vector{39.830960, 22.047483, 18.652077, + 10.310938, 9.137493, 6.065377, 4.354530, + 2.503308, + 1.029187, + 0.720996, + 0.351588}, + std::vector{2, 1, 2, 2, 1, 2, 2, 1, 1, 1, 1}, + std::vector{ + -0.0005203, -0.2524369, -0.1770929, 0.3352238, -0.8924653, + 0.0030277, -0.0019611, 0.0006791, -0.0000922, 0.0000595, + -0.0000069, -0.0001399, 0.0201415, 0.0259300, 0.1782044, + -0.5717747, 0.3405770, 0.7307786, 0.0494446, -0.0006235, + 0.0008560, -0.0000617, 0.0000377, 0.0018499, -0.0003553, + 0.0002560, 0.2240457, 0.0840205, 0.0130346, -1.1052918, + 0.9374986, 0.5429274, 0.0040359}, + std::vector{1, 1, 1}, std::vector{1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{ + 37.700775, + 16.610892, 9.943042, 8.449657, 4.852901, 3.316241, + 3.064639, 1.259502, + 0.787892, 0.501857, + 0.351588}, + std::vector{2, 3, 2, 3, 2, 3, 2, 2, 2, 2, 2}, + std::vector{ + -0.0000505, -0.0041598, 0.1334780, 0.0858841, 0.4492469, + -0.1889698, 0.5666789, 0.0015587, -0.0002711, 0.0001005, + -0.0000326, 0.0000094, 0.0007747, -0.0258912, -0.0204900, + -0.0733688, -0.0130529, -0.1668297, 0.3874979, 0.4861129, + 0.2499434, 0.0152949}, + std::vector{3, 3}, std::vector{3, 0})})}, + {15, + SlaterTypeAtom( + 15, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for P + * + * Etot=-340.698873531 Ekin=340.698873552 + */ + SlaterTypeAtomicShell( + 0, + std::vector{44.369160, 23.598828, 20.043622, 11.349839, + 10.158832, 6.412656, 4.806833, 2.815498, + 1.215465, + 0.851087, + 0.392984}, + std::vector{2, 1, 2, 2, 1, 2, 2, 1, 1, 1, 1}, + std::vector{ + -0.0004062, -0.2376169, -0.1626515, 0.3146943, -0.9009474, + 0.0018557, -0.0018915, 0.0007658, -0.0000962, 0.0000631, + -0.0000062, -0.0001141, 0.0252154, 0.0290864, 0.1588878, + -0.5703849, 0.3484053, 0.7156330, 0.0557135, 0.0000245, + 0.0008353, -0.0000317, 0.0000350, 0.0040189, 0.0014586, + 0.0147221, 0.2302141, 0.1347913, -0.0668189, -1.1875647, + 1.0023276, 0.5477627, 0.0043351}, + std::vector{1, 1, 1}, std::vector{1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{40.124946, 17.826226, 10.634247, 9.184590, + 5.316114, 3.626602, 3.365483, 1.602892, + 0.997613, 0.605218, 0.392984}, + std::vector{2, 3, 2, 3, 2, 3, 2, 2, 2, 2, 2}, + std::vector{ + -0.0000494, -0.0040312, 0.1317716, 0.0712995, 0.5023535, + -0.1722291, 0.5077528, 0.0018818, 0.0002122, 0.0002116, + -0.0000014, 0.0000117, 0.0008909, -0.0307934, -0.0227698, + -0.0656931, 0.0316790, -0.2621823, 0.3662968, 0.4974518, + 0.2886559, 0.0210666}, + std::vector{3, 3}, std::vector{3, 1})})}, + {16, + SlaterTypeAtom( + 16, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for S + * + * Etot=-397.538430165 Ekin=397.538430032 + */ + SlaterTypeAtomicShell( + 0, + std::vector{46.571054, 25.187097, 21.415230, 12.310795, + 11.127747, 6.428186, 5.028365, 2.996013, + 1.443579, + 1.005833, + 0.464283}, + std::vector{2, 1, 2, 2, 1, 2, 2, 1, 1, 1, 1}, + std::vector{ + -0.0004058, -0.2315967, -0.1581716, 0.2896646, -0.8878870, + -0.0000242, -0.0007542, 0.0003471, -0.0000039, 0.0000188, + -0.0000007, -0.0001090, 0.0315749, 0.0338849, 0.1543413, + -0.5744032, 0.5464703, 0.5390136, 0.0269750, 0.0023661, + 0.0002613, 0.0000458, 0.0000369, 0.0016898, -0.0006143, + 0.0087481, 0.2140579, 0.1463124, -0.2664403, -1.0871038, + 0.9431339, 0.6835730, 0.0052762}, + std::vector{1, 1, 1}, std::vector{1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{42.238912, 19.367238, 11.466335, 9.996813, + 5.755231, 3.903857, 3.629279, 1.858377, + 1.154252, 0.704989, 0.464283}, + std::vector{2, 3, 2, 3, 2, 3, 2, 2, 2, 2, 2}, + std::vector{ + -0.0000545, -0.0036483, 0.1263526, 0.0638382, 0.5608588, + -0.1521249, 0.4386121, 0.0020050, 0.0006668, 0.0003443, + 0.0000226, 0.0000145, 0.0009063, -0.0334683, -0.0242805, + -0.0623559, 0.0883727, -0.3493597, 0.3929020, 0.4980531, + 0.2767924, 0.0193340}, + std::vector{3, 3}, std::vector{3, 2})})}, + {17, + SlaterTypeAtom( + 17, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Cl + * + * Etot=-459.576925241 Ekin=459.576925415 + */ + SlaterTypeAtomicShell( + 0, + std::vector{50.991930, 26.778785, 22.840430, 13.082044, + 11.776618, 6.686253, 5.259265, 3.223617, + 1.606335, + 1.129735, + 0.548276}, + std::vector{2, 1, 2, 2, 1, 2, 2, 1, 1, 1, 1}, + std::vector{ + -0.0003374, -0.2263593, -0.1528670, 0.3063227, -0.9125854, + 0.0008836, -0.0015484, 0.0009407, -0.0001036, 0.0000673, + -0.0000051, -0.0000959, 0.0297587, 0.0312668, 0.1553444, + -0.5781005, 0.7009737, 0.3956730, 0.0183368, 0.0033983, + 0.0002212, 0.0000582, 0.0000349, -0.0041815, -0.0055535, + -0.0132051, 0.2216085, 0.1088838, -0.3961622, -0.9564042, + 0.9640923, 0.6906989, 0.0051699}, + std::vector{1, 1, 1}, std::vector{1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{44.014044, 20.735588, 12.212935, 10.853501, + 6.290925, 4.135144, 3.807468, 2.067738, + 1.288075, 0.805822, 0.548276}, + std::vector{2, 3, 2, 3, 2, 3, 2, 2, 2, 2, 2}, + std::vector{ + -0.0000596, -0.0034904, 0.1197393, 0.0486058, 0.5956616, + -0.1792224, 0.4467387, 0.0008766, 0.0001823, -0.0000258, + 0.0000061, 0.0000173, 0.0009464, -0.0345178, -0.0219891, + -0.0665949, 0.1632088, -0.4360400, 0.4274225, 0.4897304, + 0.2561310, 0.0169566}, + std::vector{3, 3}, std::vector{3, 3})})}, + {18, SlaterTypeAtom(18, std::vector{})}, + {19, + SlaterTypeAtom( + 19, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for K + * + * Etot=-599.161916516 Ekin=599.161916638 + */ + SlaterTypeAtomicShell( + 0, + std::vector{ + 49.991524, 27.435790, + 20.244148, + 13.647317, 7.416191, 5.499569, 5.499062, 2.240122, + 1.788620, 0.934075, + 0.304652, 0.236660, + 0.143670}, + std::vector{1, 3, 1, 3, 2, 2, 1, 2, 1, 1, 2, 1, 1}, + std::vector{ + -0.0018856, 0.0151693, 0.8145563, -0.0871817, -0.2673035, + -0.0999176, 0.5632550, -0.0062089, 0.0103345, -0.0004410, + -0.0001566, 0.0002021, 0.0000036, 0.0015077, -0.0090133, + -0.1592138, 0.0959068, 1.2653769, 0.3342032, -0.7131464, + 0.0144756, -0.0195052, 0.0004432, 0.0000610, -0.0000898, + 0.0000035, 0.0004624, -0.0029780, -0.0511508, 0.0398755, + 0.2452620, 0.7481786, -0.0941254, -0.6296306, -0.8065928, + -0.0137600, -0.0032022, 0.0042643, 0.0000134, 0.0000382, + -0.0002501, -0.0068196, 0.0067256, 0.0223608, 0.1311444, + 0.0014498, -0.0234439, -0.0836240, -0.4636688, -0.4012869, + 1.4037720, 0.1847155}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{46.062507, 24.192699, 13.842159, 9.350886, + 7.517371, 5.428016, 2.596674, 2.165503, + 1.542162, 0.604923, 0.143670}, + std::vector{2, 3, 2, 3, 2, 2, 3, 2, 2, 2, 2}, + std::vector{ + 0.0000984, 0.0030373, -0.0674562, 0.0899587, -0.7690332, + -0.2810664, 0.0036192, -0.0070662, 0.0007138, -0.0000165, + 0.0000032, 0.0000377, 0.0010852, -0.0119085, 0.0672649, + -0.2083988, -0.3423672, -0.1433941, 0.8844800, 0.4245646, + 0.0043768, 0.0001038}, + std::vector{3, 3}, std::vector{3, 3})})}, + {20, SlaterTypeAtom(20, std::vector{})}, + {21, + SlaterTypeAtom( + 21, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Sc + * + * Etot=-759.688773345 Ekin=759.688773319 + */ + SlaterTypeAtomicShell( + 0, + std::vector{ + 55.382936, 30.410195, + 22.329140, + 15.370662, 8.591628, 6.585295, 6.585295, 2.786635, + 1.829409, 1.328337, + 0.364821, 0.286519, + 0.179063}, + std::vector{1, 3, 1, 3, 2, 2, 1, 2, 1, 1, 2, 1, 1}, + std::vector{ + -0.0016163, 0.0130154, 0.8154310, -0.0802930, -0.2398332, + -0.0730315, 0.5159588, 0.0018106, -0.0027779, 0.0007526, + 0.0000753, -0.0000973, -0.0000028, 0.0014702, -0.0088182, + -0.1506719, 0.0736275, 1.2038901, 0.4034547, -0.7256294, + 0.0069953, -0.0061847, 0.0016055, 0.0001211, -0.0001598, + -0.0000027, 0.0004637, -0.0030016, -0.0519367, 0.0363948, + 0.1831352, 0.7943552, -0.1890894, -0.9101058, -0.4672033, + 0.0151767, 0.0008749, -0.0012958, 0.0000341, 0.0000642, + -0.0004231, -0.0081523, 0.0064495, 0.0157322, 0.1524469, + -0.0185463, -0.1106486, 0.1229455, -0.5711140, -0.4203956, + 1.4141094, 0.1663090}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{54.243471, 26.893549, 14.561742, 10.907417, + 8.549329, 6.370362, 2.639554, 2.283652, + 1.549144, 0.663979, 0.179063}, + std::vector{2, 3, 2, 3, 2, 2, 3, 2, 2, 2, 2}, + std::vector{ + 0.0000671, 0.0026514, -0.1105802, -0.0094599, -0.5935204, + -0.3183394, 0.0048396, -0.0081039, 0.0001409, -0.0000088, + 0.0000012, 0.0000265, 0.0010130, -0.0133089, 0.0626505, + -0.2116607, -0.3701283, -0.3440426, 1.4111325, 0.0930428, + 0.0030858, 0.0000485}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{17.759059, 13.669684, 6.574908, 4.202261, + 2.616004, 1.568423, 0.934889, 0.546028, + 0.179063}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{0.0012426, 0.0052912, 0.0309188, 0.1737675, + 0.3041901, 0.3713852, 0.2712025, 0.0803053, + 0.0005065}, + std::vector{2}, std::vector{0})})}, + {22, + SlaterTypeAtom( + 22, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ti + * + * Etot=-848.372549024 Ekin=848.372548985 + */ + SlaterTypeAtomicShell( + 0, + std::vector{ + 53.362122, 31.101929, + 23.254666, + 15.554931, 9.215081, 8.297459, 7.042452, 2.986466, + 1.953684, 1.394125, + 0.366573, 0.286915, + 0.178451}, + std::vector{1, 3, 1, 3, 2, 1, 2, 2, 1, 1, 2, 1, 1}, + std::vector{ + 0.0025362, -0.0154181, -0.8403807, 0.0711103, 0.1304860, + -0.3228601, -0.0010891, 0.0014200, -0.0020869, 0.0005397, + 0.0000524, -0.0000675, -0.0000017, 0.0028037, -0.0128454, + -0.1622881, 0.0594676, 1.0769229, -0.5313497, 0.3323238, + 0.0113035, -0.0121618, 0.0031173, 0.0003056, -0.0003865, + -0.0000133, 0.0010579, -0.0050051, -0.0591901, 0.0329751, + 0.1275466, -0.1253033, 0.8085384, -0.8876738, -0.5006406, + 0.0137533, 0.0007829, -0.0011254, 0.0000226, 0.0001615, + -0.0007656, -0.0090218, 0.0054373, 0.0078444, -0.0117579, + 0.1470180, -0.1168654, 0.0983001, -0.5034610, -0.4297602, + 1.4078860, 0.1611872}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{49.052804, 29.000740, 15.647648, 11.743528, + 9.150376, 6.821285, 2.718281, 2.335949, + 1.201431, 0.296940, 0.178451}, + std::vector{2, 3, 2, 3, 2, 2, 3, 2, 2, 2, 2}, + std::vector{ + -0.0001807, -0.0028710, 0.0963446, 0.0012375, 0.6014700, + 0.3306640, -0.0063358, 0.0099108, -0.0000473, 0.0000049, + -0.0000030, 0.0000824, 0.0012308, -0.0108845, 0.0613050, + -0.2136355, -0.3799511, -0.5104482, 1.6427784, 0.0210885, + 0.0005568, -0.0001902}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{19.219515, 14.720700, 6.901584, 4.483890, + 2.849417, 1.773766, 1.098544, 0.670500, + 0.178451}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{0.0012719, 0.0057172, 0.0403062, 0.1974766, + 0.3183531, 0.3551067, 0.2379290, 0.0567391, + 0.0001999}, + std::vector{3}, std::vector{0})})}, + {23, + SlaterTypeAtom( + 23, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for V + * + * Etot=-942.863131519 Ekin=942.863131342 + */ + SlaterTypeAtomicShell( + 0, + std::vector{ + 55.842918, 32.594460, + 24.300504, + 16.433286, 9.772722, 8.674616, 7.481430, 3.187533, + 2.042488, 1.470520, + 0.374680, 0.292746, + 0.180793}, + std::vector{1, 3, 1, 3, 2, 1, 2, 2, 1, 1, 2, 1, 1}, + std::vector{ + 0.0023893, -0.0144058, -0.8395719, 0.0688478, 0.1375056, + -0.3305081, 0.0011118, 0.0009023, -0.0013134, 0.0003736, + 0.0000385, -0.0000483, -0.0000018, 0.0026404, -0.0120557, + -0.1564619, 0.0529190, 1.0916335, -0.5671825, 0.3541262, + 0.0106635, -0.0108602, 0.0030206, 0.0002920, -0.0003638, + -0.0000145, 0.0010204, -0.0048235, -0.0578244, 0.0300052, + 0.1314529, -0.1386110, 0.8291183, -0.8803316, -0.5224418, + 0.0235315, 0.0012842, -0.0017369, -0.0000050, 0.0001552, + -0.0007364, -0.0085395, 0.0046097, 0.0090042, -0.0148109, + 0.1422670, -0.1244574, 0.1052151, -0.4770818, -0.4257615, + 1.3910464, 0.1621316}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{49.923386, 30.468610, 16.001986, 12.393599, + 9.431869, 7.200978, 2.914974, 2.500856, + 1.337711, 0.383619, 0.180793}, + std::vector{2, 3, 2, 3, 2, 2, 3, 2, 2, 2, 2}, + std::vector{ + 0.0002218, 0.0029367, -0.1335673, -0.0589027, -0.5295888, + -0.3113287, 0.0067561, -0.0106945, 0.0000588, -0.0000059, + 0.0000026, 0.0001000, 0.0012659, -0.0139067, 0.0574579, + -0.2338441, -0.3639014, -0.5230709, 1.6573337, 0.0243782, + 0.0005206, -0.0000803}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{20.565465, 15.711032, 7.172226, 4.685764, + 2.977741, 1.864561, 1.168592, 0.727885, + 0.180793}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{0.0012751, 0.0059302, 0.0517129, 0.2233057, + 0.3384978, 0.3429347, 0.2015450, 0.0379091, + 0.0001053}, + std::vector{4}, std::vector{0})})}, + {24, + SlaterTypeAtom( + 24, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Cr + * + * Etot=-1043.337096348 Ekin=1043.33709679 + */ + SlaterTypeAtomicShell( + 0, + std::vector{ + 58.382226, 34.087668, + 25.333158, 17.224734, + 10.248845, 9.051773, 7.805308, 3.374424, 2.250278, + 1.494155, 0.380715, + 0.296594, 0.182410}, + std::vector{1, 3, 1, 3, 2, 1, 2, 2, 1, 1, 2, 1, 1}, + std::vector{ + 0.0022693, -0.0136270, -0.8411367, 0.0674976, 0.1387798, + -0.3300561, 0.0019854, 0.0008220, -0.0011009, 0.0002161, + 0.0000282, -0.0000351, -0.0000013, 0.0025148, -0.0114460, + -0.1534166, 0.0512647, 1.1326040, -0.5901103, 0.3346561, + 0.0096691, -0.0086485, 0.0016700, 0.0002018, -0.0002495, + -0.0000101, 0.0010605, -0.0050188, -0.0566354, 0.0245196, + 0.1725794, -0.1329834, 0.8441142, -0.7922747, -0.6332073, + 0.0074514, 0.0008438, -0.0011308, -0.0000042, 0.0001578, + -0.0007501, -0.0080491, 0.0035125, 0.0151069, -0.0133734, + 0.1389464, -0.1084656, 0.0288549, -0.4012830, -0.4289528, + 1.3865670, 0.1603936}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{51.154838, 32.222325, 16.599417, 13.016410, + 9.775073, 7.649953, 3.078973, 2.639500, + 1.400075, 0.473342, 0.182410}, + std::vector{2, 3, 2, 3, 2, 2, 3, 2, 2, 2, 2}, + std::vector{ + 0.0002672, 0.0029329, -0.1590536, -0.1021738, -0.4606878, + -0.3136037, 0.0081783, -0.0127672, 0.0000571, -0.0000045, + 0.0000014, 0.0001133, 0.0012387, -0.0172807, 0.0510268, + -0.2360597, -0.3576656, -0.5557029, 1.6917057, 0.0219550, + 0.0004462, -0.0000064}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{21.492999, 16.491301, 7.450483, 4.896508, + 3.106206, 1.942927, 1.224260, 0.767462, + 0.182410}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{0.0013654, 0.0061977, 0.0623358, 0.2438060, + 0.3547136, 0.3327021, 0.1708187, 0.0233789, + 0.0000570}, + std::vector{5}, std::vector{0})})}, + {25, + SlaterTypeAtom( + 25, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Mn + * + * Etot=-1149.72910981 Ekin=1149.729109808 + */ + SlaterTypeAtomicShell( + 0, + std::vector{ + 60.922088, 35.578992, + 26.382693, 18.099137, + 10.799060, 9.428930, 8.235703, 3.569622, 2.363017, + 1.603296, 0.397321, + 0.309012, 0.189340}, + std::vector{1, 3, 1, 3, 2, 1, 2, 2, 1, 1, 2, 1, 1}, + std::vector{ + 0.0021852, -0.0129756, -0.8404647, 0.0655907, 0.1442246, + -0.3362495, 0.0042306, 0.0004766, -0.0006336, 0.0001352, + 0.0000160, -0.0000198, -0.0000007, 0.0023823, -0.0108415, + -0.1482076, 0.0462515, 1.1452386, -0.6213723, 0.3538115, + 0.0097765, -0.0087452, 0.0018265, 0.0001945, -0.0002392, + -0.0000098, 0.0010296, -0.0048743, -0.0551836, 0.0220359, + 0.1777468, -0.1466705, 0.8580661, -0.7990482, -0.6291384, + 0.0079291, 0.0008665, -0.0011630, -0.0000015, 0.0001587, + -0.0007548, -0.0078539, 0.0029393, 0.0166110, -0.0164642, + 0.1384264, -0.1171210, 0.0495656, -0.4042321, -0.4305054, + 1.3831057, 0.1599965}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{52.244623, 33.796475, 17.288171, 13.672378, + 10.035013, 7.962215, 3.288979, 2.819590, + 1.562578, 0.565981, 0.189340}, + std::vector{2, 3, 2, 3, 2, 2, 3, 2, 2, 2, 2}, + std::vector{ + 0.0003161, 0.0029734, -0.1732351, -0.1255228, -0.4631670, + -0.2747729, 0.0079666, -0.0126882, 0.0000586, -0.0000075, + 0.0000018, 0.0001374, 0.0012831, -0.0194840, 0.0465182, + -0.2716405, -0.3262070, -0.5458110, 1.6827274, 0.0282639, + 0.0005931, 0.0000008}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{22.548097, 17.335339, 7.728048, 5.103472, + 3.241497, 2.019729, 1.263922, 0.791292, + 0.189340}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{0.0013878, 0.0062469, 0.0734631, 0.2574239, + 0.3561627, 0.3187309, 0.1633221, 0.0243887, + 0.0000603}, + std::vector{5}, std::vector{1})})}, + {26, + SlaterTypeAtom( + 26, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Fe + * + * Etot=-1262.367073348 Ekin=1262.367073364 + */ + SlaterTypeAtomicShell( + 0, + std::vector{ + 63.375942, 37.071868, + 27.408666, 18.882781, + 11.270772, 9.806087, 8.556712, 3.753679, 2.551715, + 1.669625, 0.409589, + 0.317716, 0.194221}, + std::vector{1, 3, 1, 3, 2, 1, 2, 2, 1, 1, 2, 1, 1}, + std::vector{ + 0.0020808, -0.0122937, -0.8425080, 0.0643160, 0.1442801, + -0.3340886, 0.0048405, 0.0003360, -0.0004300, 0.0000744, + 0.0000094, -0.0000116, -0.0000004, 0.0022667, -0.0102322, + -0.1455793, 0.0459403, 1.1801846, -0.6409644, 0.3361873, + 0.0087937, -0.0072711, 0.0012345, 0.0001299, -0.0001597, + -0.0000062, 0.0010649, -0.0050139, -0.0539250, 0.0174006, + 0.2163860, -0.1430997, 0.8668394, -0.7345330, -0.7176191, + -0.0011431, 0.0005083, -0.0006988, 0.0000081, 0.0001649, + -0.0007803, -0.0075731, 0.0020915, 0.0224245, -0.0157770, + 0.1375414, -0.1071365, 0.0166856, -0.3757249, -0.4361850, + 1.3853983, 0.1576999}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{54.334408, 35.288558, 17.824366, 14.193502, + 10.165385, 8.274472, 3.490356, 2.994543, + 1.738636, 0.651020, 0.194221}, + std::vector{2, 3, 2, 3, 2, 2, 3, 2, 2, 2, 2}, + std::vector{ + 0.0003272, 0.0029407, -0.2008667, -0.1663875, -0.4400364, + -0.2318938, 0.0082595, -0.0132899, 0.0000526, -0.0000084, + 0.0000015, 0.0001317, 0.0012041, -0.0243557, 0.0393168, + -0.3173177, -0.2751673, -0.5339280, 1.6666809, 0.0365913, + 0.0007781, 0.0000004}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{23.619037, 18.190090, 8.022500, 5.298464, + 3.366204, 2.098778, 1.315008, 0.824717, + 0.194221}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{0.0013969, 0.0062623, 0.0846688, 0.2711343, + 0.3568111, 0.3052414, 0.1540352, 0.0232419, + 0.0000582}, + std::vector{5}, std::vector{2})})}, + {27, + SlaterTypeAtom( + 27, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Co + * + * Etot=-1381.351808853 Ekin=1381.351808754 + */ + SlaterTypeAtomicShell( + 0, + std::vector{65.933940, 38.602449, 28.457199, 19.680631, + 11.730375, 10.183244, 8.847546, 3.908452, + 2.781132, + 1.720412, + 0.424477, + 0.328149, + 0.198540}, + std::vector{1, 3, 1, 3, 2, 1, 2, 2, 1, 1, 2, 1, 1}, + std::vector{ + 0.0020523, -0.0118902, -0.8430505, 0.0639260, 0.1458467, + -0.3349229, 0.0050553, 0.0003082, -0.0003863, 0.0000404, + 0.0000031, -0.0000044, 0.0000001, 0.0021337, -0.0095766, + -0.1427437, 0.0467414, 1.2176181, -0.6597339, 0.3143338, + 0.0078485, -0.0061489, 0.0007070, 0.0000646, -0.0000812, + -0.0000019, 0.0010735, -0.0050393, -0.0522809, 0.0135842, + 0.2578680, -0.1297285, 0.8847775, -0.6387890, -0.8508921, + -0.0142082, -0.0004534, 0.0005051, 0.0000421, 0.0001676, + -0.0007909, -0.0072314, 0.0013471, 0.0285847, -0.0136158, + 0.1376758, -0.0919661, -0.0249661, -0.3472814, -0.4315754, + 1.3746625, 0.1611951}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{55.920505, 37.164751, 18.833573, 15.033140, + 10.752655, 8.611029, 3.713220, 3.180785, + 1.908317, 0.759136, 0.198540}, + std::vector{2, 3, 2, 3, 2, 2, 3, 2, 2, 2, 2}, + std::vector{ + 0.0003695, 0.0028970, -0.1807020, -0.1445929, -0.4880568, + -0.2231426, 0.0082193, -0.0134304, 0.0000714, -0.0000136, + 0.0000018, 0.0001621, 0.0012756, -0.0209455, 0.0393582, + -0.3234830, -0.2817259, -0.5216942, 1.6521114, 0.0466046, + 0.0009828, 0.0000134}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{24.534659, 18.971063, 8.326788, 5.499398, + 3.497383, 2.178992, 1.360938, 0.850361, + 0.198540}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{0.0014348, 0.0062919, 0.0951075, 0.2817124, + 0.3561907, 0.2958872, 0.1462523, 0.0209828, + 0.0000471}, + std::vector{5}, std::vector{3})})}, + {28, + SlaterTypeAtom( + 28, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ni + * + * Etot=-1506.821131919 Ekin=1506.821131914 + */ + SlaterTypeAtomicShell( + 0, + std::vector{69.286380, 40.172265, 29.477735, 20.544867, + 12.255834, 10.580401, 9.238444, 4.090071, + 2.913300, + 1.790912, + 0.438919, + 0.338644, + 0.202453}, + std::vector{1, 3, 1, 3, 2, 1, 2, 2, 1, 1, 2, 1, 1}, + std::vector{ + 0.0017981, -0.0109793, -0.8437800, 0.0624210, 0.1479364, + -0.3361237, 0.0060950, 0.0001003, -0.0001061, 0.0000101, + -0.0000002, -0.0000001, 0.0000002, 0.0019329, -0.0090443, + -0.1386381, 0.0439034, 1.2322485, -0.6822763, 0.3213458, + 0.0073415, -0.0053866, 0.0006197, 0.0000573, -0.0000712, + -0.0000019, -0.0010108, 0.0049382, 0.0506818, -0.0112288, + -0.2704584, 0.1359915, -0.8927781, 0.6203752, 0.8766474, + 0.0154787, 0.0005438, -0.0006173, -0.0000437, 0.0001617, + -0.0007940, -0.0069246, 0.0007890, 0.0306498, -0.0151180, + 0.1347255, -0.0933801, -0.0252236, -0.3352612, -0.4209068, + 1.3553314, 0.1672362}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{57.424455, 38.946411, 19.986887, 15.976360, + 11.468575, 8.982149, 4.070111, 3.484407, + 2.298962, 0.965531, 0.202453}, + std::vector{2, 3, 2, 3, 2, 2, 3, 2, 2, 2, 2}, + std::vector{ + 0.0004196, 0.0029000, -0.1509101, -0.1091593, -0.5430088, + -0.2295189, 0.0078118, -0.0133892, 0.0001131, -0.0000263, + 0.0000020, 0.0002154, 0.0014428, -0.0185258, 0.0361878, + -0.3001871, -0.3188535, -0.4237643, 1.5100711, 0.1104014, + 0.0019398, 0.0000268}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{25.388665, 19.711520, 8.635589, 5.694278, + 3.624230, 2.264710, 1.420470, 0.891079, + 0.202453}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{0.0014816, 0.0063271, 0.1052036, 0.2915272, + 0.3538071, 0.2847968, 0.1405086, 0.0209595, + 0.0000489}, + std::vector{5}, std::vector{4})})}, + {29, + SlaterTypeAtom( + 29, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Cu + * + * Etot=-1638.964144099 Ekin=1638.964144144 + */ + SlaterTypeAtomicShell( + 0, + std::vector{72.014363, 41.772406, 30.543805, 21.425299, + 12.757196, 10.917885, 9.613085, 4.283572, + 3.026154, + 1.863101, + 0.444541, + 0.342667, + 0.205342}, + std::vector{1, 3, 1, 3, 2, 1, 2, 2, 1, 1, 2, 1, 1}, + std::vector{ + 0.0017678, -0.0105872, -0.8421099, 0.0621223, 0.1545816, + -0.3452067, 0.0079966, -0.0001755, 0.0002562, -0.0000273, + -0.0000040, 0.0000048, 0.0000002, 0.0017646, -0.0082616, + -0.1342454, 0.0435913, 1.2541381, -0.7100510, 0.3240586, + 0.0063245, -0.0038509, 0.0004790, 0.0000366, -0.0000453, + -0.0000013, -0.0009889, 0.0048386, 0.0488660, -0.0087026, + -0.2906574, 0.1455132, -0.8925512, 0.6042882, 0.9000576, + 0.0134554, 0.0002633, -0.0002741, -0.0000319, 0.0001556, + -0.0007636, -0.0065326, 0.0004143, 0.0329187, -0.0165002, + 0.1312451, -0.0922375, -0.0264074, -0.3223327, -0.4289288, + 1.3605195, 0.1630179}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{60.062765, 40.706627, 20.710188, 16.615205, + 11.849238, 9.337764, 4.216232, 3.608526, + 2.348113, 0.992864, 0.205342}, + std::vector{2, 3, 2, 3, 2, 2, 3, 2, 2, 2, 2}, + std::vector{ + 0.0004068, 0.0027730, -0.1571512, -0.1214073, -0.5375809, + -0.2166107, 0.0083744, -0.0141787, 0.0000999, -0.0000250, + 0.0000019, 0.0001927, 0.0013124, -0.0175659, 0.0362728, + -0.3247554, -0.2970315, -0.4556855, 1.5545330, 0.0956067, + 0.0017393, 0.0000250}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{26.128341, 20.393292, 8.948380, 5.893469, + 3.754950, 2.346669, 1.470002, 0.920877, + 0.205342}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{0.0015513, 0.0063905, 0.1145629, 0.2994371, + 0.3521206, 0.2778605, 0.1337351, 0.0185435, + 0.0000418}, + std::vector{5}, std::vector{5})})}, + {30, SlaterTypeAtom(30, std::vector{})}, + {31, + SlaterTypeAtom( + 31, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ga + * + * Etot=-1923.260378638 Ekin=1923.2603788 + */ + SlaterTypeAtomicShell( + 0, + std::vector{77.246394, 44.687244, 32.588265, 22.965766, + 14.682166, 14.657637, + 11.466970, 6.395287, 3.763203, 2.189549, + 0.751315, + 0.649165, + 0.189877}, + std::vector{1, 3, 1, 3, 2, 1, 2, 1, 1, 1, 2, 1, 1}, + std::vector{ + 0.0016949, -0.0101154, -0.8461626, 0.0573561, 0.0575343, + -0.2422388, -0.0061075, 0.0011999, -0.0001216, 0.0000328, + 0.0000074, -0.0000112, -0.0000003, 0.0017580, -0.0083853, + -0.1174274, 0.0178202, 0.8250599, -0.5835042, 0.5551403, + 0.0466384, 0.0010812, 0.0005665, 0.0001285, -0.0001966, + -0.0000054, 0.0008658, -0.0042377, -0.0504926, 0.0160458, + 0.0076372, -0.3177262, 0.7089844, 1.4378066, -2.2780802, + -0.0186189, -0.0005361, 0.0007160, 0.0000122, 0.0001456, + -0.0007059, -0.0126634, 0.0081243, -0.0334700, -0.0521672, + 0.2273514, 0.2509371, -0.1946874, -0.9308754, -0.6545178, + 2.0211906, 0.0031324}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{48.751647, 38.849002, 22.797614, 17.677399, + 11.175979, 4.872316, 4.147271, 2.887329, + 1.002528, 0.579895, 0.325798, 0.189877}, + std::vector{2, 3, 2, 3, 2, 2, 3, 2, 2, 2, 2, 2}, + std::vector{ + 0.0046534, 0.0119772, -0.2345141, -0.2684543, -0.5526942, + -0.0088323, 0.0032718, -0.0021492, 0.0001111, -0.0000787, + 0.0000403, -0.0000127, 0.0014404, 0.0038674, -0.0503483, + -0.0208644, -0.5392629, 0.8743654, 0.2438786, 0.1213724, + 0.0019407, -0.0007387, 0.0003525, -0.0001016, -0.0001581, + -0.0004214, 0.0055066, 0.0011513, 0.0743668, -0.0955657, + 0.0156012, -0.1667349, 0.3475419, 0.4664435, 0.3096848, + 0.0278590}, + std::vector{3, 3, 2}, std::vector{3, 3, 0}), + SlaterTypeAtomicShell( + 2, + std::vector{27.726545, 21.855074, 9.651325, 6.348006, + 4.046633, 2.625580, 1.710788, 0.770866, + 0.189877}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{0.0017553, 0.0067472, 0.1380717, 0.3353792, + 0.3846761, 0.2433383, 0.0417798, 0.0006191, + 0.0000328}, + std::vector{5}, std::vector{5})})}, + {32, + SlaterTypeAtom( + 32, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ge + * + * Etot=-2075.394739699 Ekin=2075.394740002 + */ + SlaterTypeAtomicShell( + 0, + std::vector{79.613972, 45.818924, 33.572086, 23.611760, + 15.443246, 15.440255, + 11.983485, 6.428350, 4.034480, 2.518672, + 0.914403, + 0.791321, + 0.344495}, + std::vector{1, 3, 1, 3, 2, 1, 2, 1, 1, 1, 2, 1, 1}, + std::vector{ + 0.0017574, -0.0105069, -0.8526563, 0.0528824, 0.0466150, + -0.2241071, -0.0035038, 0.0005826, -0.0000460, 0.0000172, + 0.0000040, -0.0000062, -0.0000003, 0.0018709, -0.0090271, + -0.1123216, 0.0066706, 0.7862753, -0.5875993, 0.6038437, + 0.0469915, -0.0013647, 0.0012179, 0.0002602, -0.0004013, + -0.0000166, -0.0009778, 0.0047956, 0.0514635, -0.0130737, + 0.0072033, 0.3139092, -0.7168634, -1.6809075, 2.5018795, + 0.0283244, 0.0003050, -0.0001036, -0.0000186, 0.0001840, + -0.0008848, -0.0148718, 0.0095067, -0.0457659, -0.0496572, + 0.2625505, 0.2651306, -0.0462622, -1.2042039, -0.5018708, + 1.9558819, 0.0042540}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{51.327548, 40.786772, 23.838958, 18.479328, + 11.670561, 5.013203, 4.410244, 3.203385, + 1.275961, 0.899637, 0.555655, 0.344495}, + std::vector{2, 3, 2, 3, 2, 2, 3, 2, 2, 2, 2, 2}, + std::vector{ + 0.0044823, 0.0116359, -0.2242463, -0.2609266, -0.5680372, + -0.0098169, 0.0058178, -0.0043946, 0.0004199, -0.0003352, + 0.0001247, -0.0000306, 0.0013748, 0.0037326, -0.0475567, + -0.0196224, -0.5480380, 0.8828678, 0.1962189, 0.1531944, + 0.0023050, -0.0007029, 0.0000929, -0.0000304, -0.0002089, + -0.0005687, 0.0068204, 0.0008369, 0.1028912, -0.0988367, + 0.0630848, -0.3141338, 0.2719311, 0.4497300, 0.3904679, + 0.0339316}, + std::vector{3, 3, 3}, std::vector{3, 3, 0}), + SlaterTypeAtomicShell( + 2, + std::vector{29.320580, 22.954779, 10.041271, 6.615628, + 4.263649, 2.969233, 2.331130, 1.493057, + 0.344495}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{0.0016417, 0.0066888, 0.1468737, 0.3437621, + 0.3884478, 0.1768956, 0.0651775, 0.0081431, + 0.0000998}, + std::vector{5}, std::vector{5})})}, + {33, + SlaterTypeAtom( + 33, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for As + * + * Etot=-2234.222936911 Ekin=2234.222945522 + */ + SlaterTypeAtomicShell( + 0, + std::vector{54.379943, 40.312268, 33.668614, 22.964897, + 13.839443, 13.667421, 6.306807, 5.183466, + 3.465452, + 1.585163, + 1.006385, + 0.884865, + 0.383821}, + std::vector{1, 3, 1, 4, 2, 3, 3, 2, 2, 2, 2, 1, 1}, + std::vector{ + -0.0114407, 0.0205968, 0.9791607, -0.0248538, 0.0637049, + -0.0270581, -0.0117261, 0.0163492, -0.0011458, -0.0002507, + -0.0003647, 0.0007579, 0.0000044, -0.0464535, 0.0502391, + 0.3937002, -0.1034114, -0.8343164, -0.1311350, 0.0674989, + -0.1061532, 0.0188074, 0.0189987, 0.0204617, -0.0457405, + 0.0000530, -0.0195849, 0.0215359, 0.1581243, -0.0381069, + -0.4212188, -0.3198750, 0.2082877, 0.9440563, 0.2360044, + 0.1766325, 0.1905659, -0.4253608, 0.0004741, 0.0063761, + -0.0069607, -0.0498408, 0.0134196, 0.0844373, 0.1125919, + 0.0476326, -0.4046830, -0.6373162, 0.2844943, -0.2221690, + 1.3331490, 0.0051822}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{50.139883, 40.762467, 23.845046, 18.871367, + 13.517094, 6.273065, 5.431821, 3.943193, + 1.157275, 0.967964, 0.560220, 0.383821}, + std::vector{2, 3, 2, 3, 3, 2, 3, 3, 3, 2, 2, 2}, + std::vector{ + -0.0061472, -0.0140127, 0.3531616, 0.4428732, 0.2960448, + 0.0167162, -0.0028990, 0.0008938, 0.0002287, -0.0002736, + -0.0000170, 0.0000077, 0.0038580, 0.0086129, -0.1689808, + -0.2054690, -0.3025554, 0.6102879, 0.5229978, 0.1452139, + -0.0018831, 0.0037339, -0.0004695, 0.0001902, -0.0008612, + -0.0019383, 0.0350403, 0.0412265, 0.0694743, -0.1635560, + -0.1015518, -0.1768701, -0.5636044, 1.4163594, 0.2463488, + 0.0171069}, + std::vector{3, 3, 3}, std::vector{3, 3, 1}), + SlaterTypeAtomicShell( + 2, + std::vector{32.077423, 24.693333, 10.836043, 8.023980, + 6.771001, 4.513535, 2.963741, 1.672180, + 0.383821}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{0.0012569, 0.0058336, 0.1209636, 0.1111971, + 0.2610695, 0.4244801, 0.1916791, 0.0095066, + 0.0000718}, + std::vector{5}, std::vector{5})})}, + {34, + SlaterTypeAtom( + 34, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Se + * + * Etot=-2399.90472428 Ekin=2399.904733005 + */ + SlaterTypeAtomicShell( + 0, + std::vector{56.492283, 41.849649, 34.849601, 23.890667, + 14.338307, 14.323000, 6.610870, 5.476009, + 3.828650, + 1.741750, + 1.121369, + 0.991886, + 0.450481}, + std::vector{1, 3, 1, 4, 2, 3, 3, 2, 2, 2, 2, 1, 1}, + std::vector{ + -0.0142700, 0.0225967, 0.9788984, -0.0263316, 0.0693696, + -0.0297976, -0.0109904, 0.0154286, -0.0005167, 0.0006514, + 0.0005733, -0.0013908, 0.0000072, -0.0459459, 0.0498082, + 0.3920689, -0.1059705, -0.8145290, -0.1450358, 0.0692396, + -0.1117019, 0.0164892, 0.0123772, 0.0128815, -0.0297076, + 0.0000218, -0.0194517, 0.0214848, 0.1588263, -0.0385701, + -0.4070736, -0.3171158, 0.3155885, 0.7759354, 0.2735161, + 0.1558354, 0.1607989, -0.3711167, 0.0003433, 0.0066499, + -0.0073084, -0.0527793, 0.0139074, 0.0874963, 0.1195343, + 0.0232068, -0.3180606, -0.7305751, 0.3583077, -0.1444863, + 1.2058770, 0.0058397}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{52.021585, 42.345087, 24.776042, 19.667209, + 14.121030, 6.738664, 5.842328, 4.279773, + 1.344317, 1.133042, 0.660219, 0.450481}, + std::vector{2, 3, 2, 3, 3, 2, 3, 3, 3, 2, 2, 2}, + std::vector{ + -0.0060016, -0.0135145, 0.3472942, 0.4357847, 0.3052341, + 0.0200974, -0.0037066, 0.0011642, 0.0003573, -0.0004351, + -0.0000299, 0.0000120, -0.0038152, -0.0084432, 0.1681230, + 0.2033659, 0.3061019, -0.5503386, -0.5603257, -0.1652721, + 0.0043766, -0.0073424, 0.0001133, -0.0000973, -0.0009383, + -0.0020823, 0.0389540, 0.0458730, 0.0787100, -0.1702394, + -0.1206358, -0.2173729, -0.5105746, 1.3684020, 0.2690489, + 0.0164944}, + std::vector{3, 3, 3}, std::vector{3, 3, 2}), + SlaterTypeAtomicShell( + 2, + std::vector{33.093837, 25.549208, 11.229189, 8.375129, + 6.984656, 4.764977, 3.177210, 1.747553, + 0.450481}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{0.0012724, 0.0058150, 0.1256747, 0.1218554, + 0.2576887, 0.4281566, 0.1693564, 0.0069414, + 0.0000579}, + std::vector{5}, std::vector{5})})}, + {35, + SlaterTypeAtom( + 35, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Br + * + * Etot=-2572.536271045 Ekin=2572.536270073 + */ + SlaterTypeAtomicShell( + 0, + std::vector{58.840306, 43.270254, 35.952413, 24.803745, + 14.998407, 14.991540, 6.938357, 5.780359, + 4.192317, + 1.889531, + 1.231111, + 1.095425, + 0.527883}, + std::vector{1, 3, 1, 4, 2, 3, 3, 2, 2, 2, 2, 1, 1}, + std::vector{ + -0.0150578, 0.0234986, 0.9782386, -0.0264291, 0.0702309, + -0.0295224, -0.0103410, 0.0144823, -0.0000133, 0.0012247, + 0.0011040, -0.0027171, 0.0000091, -0.0443478, 0.0500429, + 0.3900522, -0.1054679, -0.7780784, -0.1802036, 0.0724452, + -0.1198624, 0.0168493, 0.0101188, 0.0100297, -0.0239443, + 0.0000147, -0.0188460, 0.0217071, 0.1592105, -0.0377009, + -0.3838960, -0.3249610, 0.4192798, 0.6001426, 0.3199792, + 0.1359506, 0.1335307, -0.3187011, 0.0002369, 0.0066956, + -0.0076885, -0.0551564, 0.0138228, 0.0872892, 0.1275577, + -0.0020129, -0.2114816, -0.8345737, 0.4148850, -0.0800800, + 1.1030590, 0.0061373}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{53.913287, 43.927707, 25.707038, 20.463051, + 14.724966, 7.204263, 6.238755, 4.593395, + 1.526346, 1.291162, 0.769482, 0.527883}, + std::vector{2, 3, 2, 3, 3, 2, 3, 3, 3, 2, 2, 2}, + std::vector{ + -0.0058597, -0.0130567, 0.3418309, 0.4290415, 0.3135023, + 0.0236377, -0.0044939, 0.0014399, 0.0005042, -0.0006089, + -0.0000392, 0.0000171, -0.0037417, -0.0082078, 0.1669898, + 0.2015111, 0.3080355, -0.4961278, -0.5952576, -0.1810018, + 0.0055083, -0.0084526, 0.0002975, -0.0000505, -0.0009852, + -0.0021588, 0.0418784, 0.0494357, 0.0858891, -0.1718187, + -0.1392965, -0.2545602, -0.4752443, 1.3427977, 0.2803135, + 0.0195208}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{34.476213, 26.582226, 11.687116, 8.714807, + 7.051196, 4.996404, 3.385056, 1.843194, + 0.527883}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{0.0012191, 0.0056419, 0.1256612, 0.1527871, + 0.2505389, 0.4183793, 0.1492843, 0.0056539, + 0.0000481}, + std::vector{5}, std::vector{5})})}, + {36, SlaterTypeAtom(36, std::vector{})}, + {37, + SlaterTypeAtom( + 37, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Rb + * + * Etot=-2938.354897972 Ekin=2938.354900435 + */ + SlaterTypeAtomicShell( + 0, + std::vector{ + 61.629682, 45.609573, + 37.968851, 26.259916, + 15.906141, + 15.901177, 8.802636, 5.631993, 5.201952, 2.157946, + 1.717872, 1.716577, + 0.481476, 0.250025, + 0.138072}, + std::vector{1, 3, 1, 4, 2, 3, 4, 3, 2, 2, 3, 2, 2, 2, 2}, + std::vector{ + -0.0150512, 0.0224292, 0.9798815, -0.0250764, 0.0672349, + -0.0275909, -0.0036978, -0.0047748, 0.0107653, -0.0002960, + -0.0001154, 0.0003552, 0.0000034, -0.0000021, 0.0000008, + 0.0464682, -0.0499546, -0.3953952, 0.1073309, 0.7910330, + 0.1752496, -0.0281660, -0.0501495, 0.1053812, 0.0016869, + 0.0006514, -0.0020478, -0.0000175, 0.0000105, -0.0000038, + 0.0197355, -0.0216153, -0.1620217, 0.0385223, 0.4339866, + 0.3482654, -0.1788390, 0.4374275, -1.5144490, 0.0074049, + 0.0032468, -0.0106815, -0.0000746, 0.0000434, -0.0000155, + 0.0066518, -0.0073321, -0.0547102, 0.0117024, 0.1506536, + 0.1415211, -0.0195187, -0.1853446, -0.7145223, 1.0112855, + 0.0005534, 0.3298020, 0.0003326, -0.0001714, 0.0000613, + -0.0009842, 0.0010973, 0.0081028, -0.0016040, -0.0223578, + -0.0216766, -0.0004641, 0.0428085, 0.1123919, -0.3718686, + -0.2045309, 0.2220577, 0.5596823, 0.5195034, 0.0590673}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{56.312357, 46.213720, 27.400960, 21.896380, + 15.895409, 9.262586, 7.251847, 5.278655, + 1.702362, 1.505340, 0.570910, 0.138072}, + std::vector{2, 3, 2, 3, 3, 2, 3, 3, 3, 2, 2, 2}, + std::vector{ + -0.0062682, -0.0132316, 0.3382369, 0.4181467, 0.3133550, + 0.0341586, -0.0006541, 0.0004972, 0.0000622, -0.0000914, + -0.0000003, 0.0000001, -0.0041421, -0.0086167, 0.1716350, + 0.2023561, 0.3189967, -0.3328366, -0.7087529, -0.2493203, + 0.0045788, -0.0072511, 0.0000169, 0.0000007, -0.0014323, + -0.0029817, 0.0554268, 0.0631884, 0.1177236, -0.1625820, + -0.2179102, -0.3569470, -0.5197016, 1.6934874, 0.0062741, + 0.0001394}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{36.120235, 28.064432, 12.198814, 8.899858, + 7.156927, 5.245780, 3.674489, 2.119550, + 0.138072}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3, 3}, + std::vector{0.0013195, 0.0058029, 0.1606932, 0.1633238, + 0.3038761, 0.3652525, 0.0936727, 0.0021795, + -0.0000003}, + std::vector{5}, std::vector{5})})}, + {38, SlaterTypeAtom(38, std::vector{})}, + {39, + SlaterTypeAtom( + 39, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Y + * + * Etot=-3331.683106745 Ekin=3331.683111301 + */ + SlaterTypeAtomicShell( + 0, + std::vector{ + 65.578865, 48.619329, + 40.255923, 28.236248, + 17.389229, + 17.371817, 9.690120, 6.307218, 5.892936, 2.969391, + 2.631004, 1.851811, + 0.692974, 0.361680, + 0.079350}, + std::vector{1, 3, 1, 4, 2, 3, 4, 3, 2, 2, 2, 2, 2, 1, 1}, + std::vector{ + -0.0182754, 0.0243727, 0.9790433, -0.0266879, 0.0719088, + -0.0278726, -0.0031684, -0.0037266, 0.0090488, -0.0001155, + 0.0001078, -0.0000130, 0.0000011, -0.0000007, 0.0000000, + 0.0454548, -0.0480450, -0.3928103, 0.1064778, 0.6999329, + 0.2565795, -0.0368348, -0.0587894, 0.1321206, 0.0033798, + -0.0029259, 0.0003116, -0.0000271, 0.0000173, -0.0000010, + -0.0193772, 0.0210051, 0.1631921, -0.0359939, -0.3825725, + -0.3734493, 0.2569323, -0.1714163, 1.1670834, -0.0119384, + 0.0137110, -0.0011536, 0.0001081, -0.0000709, 0.0000041, + 0.0070922, -0.0077223, -0.0599715, 0.0117869, 0.1422969, + 0.1619456, -0.0464669, -0.3649806, -0.5908750, -0.9124118, + 2.1367505, 0.1475888, -0.0005864, 0.0004481, -0.0000220, + -0.0016404, 0.0018058, 0.0140366, -0.0023834, -0.0384671, + -0.0407286, 0.0068044, 0.1339473, 0.1408412, -0.1480929, + -0.0086859, -0.5999492, 0.6069211, 0.6250722, 0.0028749}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{48.700078, 42.737411, 27.358746, 19.556496, + 15.843922, 11.432235, 7.974166, 5.932445, + 2.295395, 1.841004, 1.116257, 0.517865, + 0.192877, 0.079350}, + std::vector{2, 3, 3, 2, 3, 3, 3, 3, 4, 2, 4, 3, 2, 2}, + std::vector{ + -0.0124540, -0.0161212, -0.1094917, 0.9316712, 0.2280771, + 0.0055852, 0.0039026, -0.0008232, -0.0001255, 0.0001908, + 0.0000164, -0.0000101, 0.0000041, -0.0000012, 0.0168758, + 0.0208868, 0.1110579, -0.5058391, -0.1510063, 0.1775923, + 0.7067569, 0.2842479, -0.0029711, 0.0063396, 0.0000677, + -0.0000524, 0.0000239, -0.0000061, -0.0066349, -0.0081255, + -0.0433734, 0.1754897, 0.0512243, -0.1022261, -0.2325234, + -0.4365526, -0.2517369, 1.4699018, 0.0023821, 0.0013401, + -0.0005530, 0.0001216, 0.0010146, 0.0012440, 0.0066175, + -0.0264212, -0.0075245, 0.0157515, 0.0351708, 0.0717711, + 0.0291959, -0.2529652, 0.2172600, 0.4515458, 0.4531274, + 0.0591973}, + std::vector{3, 3, 3, 1}, std::vector{3, 3, 3, 0}), + SlaterTypeAtomicShell( + 2, + std::vector{41.573472, 31.385895, 13.106625, 12.420341, + 8.392388, 6.961804, 4.566537, 2.573134, + 1.539634, 0.923170, 0.533884, 0.079350}, + std::vector{3, 4, 3, 4, 3, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0008979, 0.0048905, 0.1768026, 0.0054093, 0.5271644, + 0.2202650, 0.1622557, 0.0026656, 0.0000865, -0.0000387, + 0.0000245, -0.0000007, -0.0001963, -0.0010802, -0.0412242, + -0.0102746, -0.0965388, -0.0770593, -0.0304051, 0.2790049, + 0.5038534, 0.3291778, 0.0507976, 0.0006043}, + std::vector{5, 1}, std::vector{5, 0})})}, + {40, + SlaterTypeAtom( + 40, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Zr + * + * Etot=-3538.994497048 Ekin=3538.994505207 + */ + SlaterTypeAtomicShell( + 0, + std::vector{ + 67.450497, 50.087841, + 41.392563, 29.203784, + 18.041660, 18.037815, + 10.118813, 6.735228, 6.345881, 4.033866, 2.682391, + 1.959441, 0.685741, + 0.366699, 0.186704}, + std::vector{1, 3, 1, 4, 2, 3, 4, 3, 2, 2, 2, 2, 2, 2, 1}, + std::vector{ + -0.0197051, 0.0251466, 0.9787454, -0.0274623, 0.0744913, + -0.0287005, -0.0030744, -0.0031680, 0.0085295, -0.0000634, + 0.0000252, -0.0000056, 0.0000002, -0.0000001, 0.0000000, + 0.0452642, -0.0472109, -0.3920777, 0.1059963, 0.6707022, + 0.2811478, -0.0385862, -0.0556716, 0.1355351, 0.0012005, + -0.0004107, 0.0000800, -0.0000050, 0.0000042, -0.0000024, + -0.0193672, 0.0207317, 0.1639758, -0.0357500, -0.3660594, + -0.3790909, 0.2790722, -0.0169612, 0.9874193, 0.0015454, + 0.0044455, -0.0003575, 0.0000420, -0.0000335, 0.0000189, + 0.0072202, -0.0077793, -0.0614383, 0.0117295, 0.1370423, + 0.1671284, -0.0412189, -0.4668059, -0.4789560, -0.2084663, + 1.3595031, 0.1965534, 0.0002784, 0.0000454, -0.0000393, + -0.0013063, 0.0014301, 0.0111611, -0.0018523, -0.0253373, + -0.0318586, -0.0009738, 0.1262526, 0.0992254, -0.0134847, + -0.1736661, -0.2657894, 0.4874538, 0.4249767, 0.2309974}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{65.754581, 53.003930, 29.684560, 24.275120, + 17.824462, 11.572641, 8.371764, 6.151678, + 2.061198, 1.843327, 0.677908, 0.186704}, + std::vector{2, 3, 2, 3, 3, 2, 3, 3, 3, 2, 2, 2}, + std::vector{ + -0.0030051, -0.0072010, 0.3214929, 0.3844645, 0.3227414, + 0.0615132, 0.0016671, -0.0002697, -0.0001622, 0.0001902, + 0.0000087, -0.0000017, -0.0023612, -0.0055707, 0.1701449, + 0.1914235, 0.3291544, -0.2437134, -0.7618044, -0.2794925, + 0.0040894, -0.0069743, 0.0000028, 0.0000015, -0.0010139, + -0.0023878, 0.0660290, 0.0715090, 0.1489441, -0.1672794, + -0.2769802, -0.4809022, -0.7835793, 2.0272951, 0.0050135, + 0.0000241}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{43.336041, 32.711952, 14.125436, 12.762793, + 8.478264, 6.944099, 4.634623, 2.960983, + 1.857180, 1.129865, 0.668007, 0.186704}, + std::vector{3, 4, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0008059, 0.0044072, 0.0821292, 0.1100197, 0.5690147, + 0.2165166, 0.1095572, 0.0030234, 0.0000887, 0.0000807, + 0.0000054, 0.0000011, -0.0001893, -0.0010483, -0.0048241, + -0.0467264, -0.1193854, -0.0843227, -0.0227410, 0.2301344, + 0.4476480, 0.3855142, 0.1184603, 0.0008638}, + std::vector{5, 3}, std::vector{5, 0})})}, + {41, + SlaterTypeAtom( + 41, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Nb + * + * Etot=-3753.57821457 Ekin=3753.578226707 + */ + SlaterTypeAtomicShell( + 0, + std::vector{ + 69.512532, 51.614236, + 42.515673, 30.184309, + 18.723442, 18.716561, + 10.523020, 7.039269, 6.671101, 3.877900, 2.886243, + 2.110581, 0.708176, + 0.373352, 0.186523}, + std::vector{1, 3, 1, 4, 2, 3, 4, 3, 2, 2, 2, 2, 2, 2, 1}, + std::vector{ + -0.0205455, 0.0256215, 0.9780452, -0.0282982, 0.0770330, + -0.0293059, -0.0030107, -0.0029777, 0.0082630, -0.0000170, + 0.0000100, 0.0000000, -0.0000002, 0.0000003, -0.0000002, + 0.0444095, -0.0463009, -0.3905523, 0.1052952, 0.6398451, + 0.3067306, -0.0429903, -0.0574503, 0.1466040, 0.0012885, + -0.0006233, 0.0000966, -0.0000043, 0.0000035, -0.0000019, + -0.0190613, 0.0204248, 0.1643599, -0.0352373, -0.3486597, + -0.3859970, 0.3038131, 0.0556090, 0.8846437, 0.0024238, + 0.0043749, -0.0001634, 0.0000342, -0.0000270, 0.0000150, + 0.0072548, -0.0078252, -0.0629156, 0.0117639, 0.1318855, + 0.1727030, -0.0455898, -0.5549741, -0.4477064, -0.2632190, + 1.4044997, 0.2553177, 0.0003490, -0.0000293, 0.0000010, + -0.0012790, 0.0014018, 0.0111381, -0.0018104, -0.0236862, + -0.0320344, -0.0004446, 0.1400280, 0.0886842, -0.0183359, + -0.1537283, -0.2690566, 0.4770890, 0.4301772, 0.2310141}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{63.780867, 52.162440, 30.371699, 24.649854, + 18.350796, 13.080766, 8.775199, 6.467897, + 2.204689, 1.967866, 0.739804, 0.186523}, + std::vector{2, 3, 2, 3, 3, 2, 3, 3, 3, 2, 2, 2}, + std::vector{ + -0.0045591, -0.0098892, 0.3242591, 0.3821090, 0.2756111, + 0.1067299, 0.0026266, -0.0003100, -0.0000747, 0.0000724, + 0.0000040, -0.0000007, -0.0036751, -0.0078177, 0.1866532, + 0.2068725, 0.3441840, -0.2546100, -0.7715525, -0.2972796, + 0.0047976, -0.0082080, -0.0000033, 0.0000025, -0.0017471, + -0.0037126, 0.0804228, 0.0856723, 0.1775524, -0.2024140, + -0.2902968, -0.5140535, -0.7846228, 2.0491495, 0.0048972, + 0.0000504}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{44.354547, 33.570462, 15.734639, 13.220427, + 8.597817, 7.171274, 4.931586, 2.978717, + 1.889005, 1.179953, 0.726010, 0.186523}, + std::vector{3, 4, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0007886, 0.0042106, 0.0306833, 0.1788440, 0.5782014, + 0.1831509, 0.1112117, 0.0025507, 0.0001239, 0.0000291, + 0.0000159, -0.0000005, -0.0002121, -0.0011547, -0.0003048, + -0.0597304, -0.1395082, -0.0973164, 0.0009345, 0.3030998, + 0.4631073, 0.3235849, 0.0737649, 0.0002410}, + std::vector{5, 4}, std::vector{5, 0})})}, + {42, + SlaterTypeAtom( + 42, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Mo + * + * Etot=-3975.526266257 Ekin=3975.526282579 + */ + SlaterTypeAtomicShell( + 0, + std::vector{ + 72.171260, 53.282680, + 43.695075, 31.308097, + 19.520212, 19.511167, + 11.093926, 7.889569, 7.662932, 6.021759, 2.932198, + 2.127438, 0.728567, + 0.379287, 0.185662}, + std::vector{1, 3, 1, 4, 2, 3, 4, 3, 2, 2, 2, 2, 2, 2, 1}, + std::vector{ + -0.0213710, 0.0267711, 0.9761296, -0.0293565, 0.0810435, + -0.0308380, -0.0032777, -0.0012007, 0.0078045, -0.0006231, + 0.0000261, -0.0000075, 0.0000005, -0.0000004, 0.0000002, + 0.0421866, -0.0455240, -0.3864815, 0.1020802, 0.5941859, + 0.3437923, -0.0447979, -0.0377410, 0.1431093, -0.0012863, + -0.0000459, -0.0000176, 0.0000004, -0.0000002, 0.0000001, + -0.0181415, 0.0201565, 0.1635538, -0.0336357, -0.3162384, + -0.3881068, 0.2936241, 0.3147814, 0.4532044, 0.1720172, + 0.0044871, -0.0002503, 0.0000391, -0.0000308, 0.0000170, + 0.0070173, -0.0078732, -0.0637235, 0.0110641, 0.1185503, + 0.1757280, -0.0254055, -0.4567790, 0.1472042, -0.8237343, + 1.3457781, 0.1807776, 0.0001479, 0.0000492, -0.0000363, + -0.0011926, 0.0013757, 0.0108980, -0.0014516, -0.0198315, + -0.0318419, -0.0136830, 0.1474970, -0.0012754, 0.0833306, + -0.2205734, -0.2000181, 0.4642576, 0.4373041, 0.2335787}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{65.418449, 53.871421, 32.139412, 25.948942, + 19.316894, 13.511969, 9.137267, 6.780455, + 2.368037, 2.109289, 0.851790, 0.185662}, + std::vector{2, 3, 2, 3, 3, 2, 3, 3, 3, 2, 2, 2}, + std::vector{ + -0.0058081, -0.0118127, 0.3049834, 0.3639126, 0.2956090, + 0.1275620, 0.0017506, -0.0000057, 0.0000386, -0.0000898, + 0.0000004, -0.0000001, -0.0042985, -0.0086949, 0.1688305, + 0.1844057, 0.3179430, -0.1740115, -0.7720077, -0.3098511, + 0.0061042, -0.0103714, -0.0000169, 0.0000039, -0.0020736, + -0.0041973, 0.0740938, 0.0767276, 0.1666213, -0.1686733, + -0.2941074, -0.5462047, -0.7423118, 2.0297033, 0.0058845, + 0.0000907}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{45.537869, 34.510321, 17.073392, 14.023118, + 8.876223, 7.317837, 4.989926, 3.040713, + 1.947284, 1.238428, 0.779653, 0.185662}, + std::vector{3, 4, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0007861, 0.0041804, 0.0090645, 0.1920552, 0.6094473, + 0.1876679, 0.0819115, 0.0014811, 0.0001400, -0.0000559, + 0.0000104, -0.0000008, -0.0002362, -0.0012839, 0.0038317, + -0.0644005, -0.1656614, -0.1183450, 0.0396706, 0.3553647, + 0.4636800, 0.2782379, 0.0465181, 0.0001190}, + std::vector{5, 5}, std::vector{5, 0})})}, + {43, + SlaterTypeAtom( + 43, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Tc + * + * Etot=-4204.764629736 Ekin=4204.764637773 + */ + SlaterTypeAtomicShell( + 0, + std::vector{ + 75.312699, 55.705916, + 45.130608, 32.948324, + 20.612275, + 20.612017, 9.748223, 7.509306, 7.509229, 3.928282, + 3.511620, 2.441652, + 0.754281, 0.391683, + 0.191237}, + std::vector{1, 3, 1, 4, 2, 3, 3, 3, 2, 4, 2, 2, 2, 2, 1}, + std::vector{ + 0.0243485, -0.0289138, -0.9712891, 0.0348639, -0.0971986, + 0.0375744, 0.0117379, 0.0038239, -0.0192551, -0.0000663, + 0.0000505, 0.0000486, -0.0000020, 0.0000017, -0.0000010, + 0.0389377, -0.0416455, -0.3776308, 0.0982839, 0.4888660, + 0.4036611, -0.2096826, -0.0870840, 0.3813834, -0.0006892, + 0.0021103, 0.0001057, 0.0000007, -0.0000014, 0.0000009, + -0.0168266, 0.0185653, 0.1607656, -0.0333496, -0.1994818, + -0.3510232, 1.0830379, 0.3951767, -0.3374335, 0.0004232, + 0.0051256, 0.0003456, 0.0000229, -0.0000169, 0.0000092, + 0.0065729, -0.0073903, -0.0636049, 0.0102854, 0.0865790, + 0.1717656, -0.2518218, -0.7946260, -0.1494111, 0.1703339, + 0.9448810, 0.4570704, 0.0006257, -0.0002252, 0.0001026, + -0.0011148, 0.0012723, 0.0108514, -0.0015012, -0.0159968, + -0.0312503, 0.0276461, 0.1691449, 0.0397904, 0.0105701, + -0.1241593, -0.3172773, 0.4641094, 0.4343993, 0.2330159}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{67.176031, 55.690402, 33.823668, 27.242414, + 20.253084, 13.943172, 9.485245, 7.076767, + 2.531225, 2.252153, 0.965516, 0.191237}, + std::vector{2, 3, 2, 3, 3, 2, 3, 3, 3, 2, 2, 2}, + std::vector{ + -0.0066817, -0.0128774, 0.2885507, 0.3455475, 0.3138828, + 0.1461839, 0.0007761, 0.0003568, 0.0001805, -0.0002915, + -0.0000045, 0.0000004, -0.0047041, -0.0090929, 0.1550686, + 0.1665313, 0.2998679, -0.1118537, -0.7756982, -0.3172883, + 0.0072250, -0.0122801, -0.0000327, 0.0000048, -0.0022851, + -0.0044197, 0.0689589, 0.0696676, 0.1580529, -0.1406968, + -0.3016106, -0.5749762, -0.7069047, 2.0163096, 0.0079077, + 0.0000933}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{46.021191, 35.133830, 18.569919, 14.659353, + 9.176789, 7.572081, 5.242938, 3.147052, + 1.997374, 1.264586, 0.796743, 0.191237}, + std::vector{3, 4, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0008472, 0.0043093, 0.0004270, 0.1955331, 0.6242047, + 0.1788231, 0.0772024, 0.0018975, 0.0001273, 0.0000808, + 0.0000100, 0.0000000, -0.0002818, -0.0014661, 0.0050921, + -0.0665411, -0.1848279, -0.1371490, 0.0724655, 0.3989416, + 0.4524227, 0.2492072, 0.0389424, 0.0000978}, + std::vector{5, 5}, std::vector{5, 1})})}, + {44, + SlaterTypeAtom( + 44, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ru + * + * Etot=-4441.528474293 Ekin=4441.528480802 + */ + SlaterTypeAtomicShell( + 0, + std::vector{ + 77.746812, 57.466455, + 46.317218, 34.073622, + 21.312636, 21.306721, + 10.096369, 7.857654, 7.824953, 4.120062, 3.846079, + 2.552612, 0.778953, + 0.401619, 0.194084}, + std::vector{1, 3, 1, 4, 3, 2, 3, 2, 3, 4, 2, 2, 2, 2, 1}, + std::vector{ + -0.0249567, 0.0293870, 0.9692208, -0.0368136, -0.0404947, + 0.1035393, -0.0131046, 0.0210085, -0.0036563, 0.0001132, + -0.0001346, -0.0000789, 0.0000030, -0.0000026, 0.0000015, + 0.0375532, -0.0403412, -0.3746753, 0.0972223, 0.4241115, + 0.4589601, -0.2222370, 0.3983462, -0.0834676, -0.0001999, + 0.0014298, -0.0001209, 0.0000089, -0.0000084, 0.0000048, + -0.0163027, 0.0180662, 0.1604227, -0.0334736, -0.3513257, + -0.1792372, 1.1389994, -0.4394253, 0.4254046, 0.0002073, + 0.0067860, 0.0006844, 0.0000166, -0.0000115, 0.0000062, + 0.0064550, -0.0072952, -0.0643758, 0.0104956, 0.1739301, + 0.0793509, -0.2630109, -0.1153945, -0.8640296, 0.2230730, + 0.9198180, 0.4790080, 0.0006417, -0.0002401, 0.0001101, + -0.0010772, 0.0012357, 0.0108076, -0.0015153, -0.0311278, + -0.0145206, 0.0280405, 0.0334452, 0.1807073, 0.0019753, + -0.1254160, -0.3078610, 0.4582059, 0.4378864, 0.2339459}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{68.938264, 57.610608, 36.267946, 28.920214, + 21.287857, 14.267432, 9.883781, 7.431783, + 2.641987, 2.349342, 0.987970, 0.194084}, + std::vector{2, 3, 2, 3, 3, 2, 3, 3, 3, 2, 2, 2}, + std::vector{ + -0.0091106, -0.0162705, 0.2685516, 0.3268001, 0.3457456, + 0.1603924, -0.0007972, 0.0009163, 0.0003552, -0.0005383, + -0.0000094, 0.0000009, -0.0058719, -0.0106090, 0.1385858, + 0.1488179, 0.2822395, -0.0441081, -0.7623887, -0.3433060, + 0.0094050, -0.0156048, -0.0000681, 0.0000080, -0.0029117, + -0.0052860, 0.0626349, 0.0618999, 0.1498222, -0.1103729, + -0.2902504, -0.6087395, -0.7374328, 2.0544390, 0.0069511, + 0.0000801}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{46.539696, 35.746927, 20.071778, 15.306154, + 9.535520, 7.866816, 5.498039, 3.241090, + 2.034099, 1.282084, 0.806257, 0.194084}, + std::vector{3, 4, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0009267, 0.0045099, -0.0038084, 0.1911556, 0.6343085, + 0.1782613, 0.0728860, 0.0026223, -0.0001145, 0.0002681, + -0.0000275, 0.0000025, -0.0003483, -0.0017471, 0.0061416, + -0.0673912, -0.2017240, -0.1590119, 0.1079659, 0.4395264, + 0.4450001, 0.2184439, 0.0268344, 0.0000770}, + std::vector{5, 5}, std::vector{5, 2})})}, + {45, + SlaterTypeAtom( + 45, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Rh + * + * Etot=-4685.875577988 Ekin=4685.875593411 + */ + SlaterTypeAtomicShell( + 0, + std::vector{ + 80.746947, 59.354316, + 47.521316, 35.255376, + 22.085628, 22.040298, + 10.532538, 8.319295, 8.317816, 3.782996, 3.488047, + 2.586704, 0.801327, + 0.410571, 0.196115}, + std::vector{1, 3, 1, 4, 2, 3, 3, 3, 2, 3, 2, 2, 2, 2, 1}, + std::vector{ + 0.0249308, -0.0300468, -0.9660031, 0.0389095, -0.1100813, + 0.0434788, 0.0151440, 0.0033839, -0.0238249, -0.0005967, + 0.0007329, 0.0001401, -0.0000057, 0.0000048, -0.0000027, + 0.0352552, -0.0392582, -0.3702798, 0.0955393, 0.4237072, + 0.4485033, -0.2276666, -0.0781996, 0.4102479, 0.0011019, + -0.0009610, -0.0004443, 0.0000196, -0.0000170, 0.0000094, + -0.0153756, 0.0176636, 0.1594030, -0.0333553, -0.1553145, + -0.3511671, 1.1387312, 0.4996869, -0.5420463, -0.0152188, + 0.0290534, 0.0021355, -0.0000414, 0.0000368, -0.0000204, + 0.0061406, -0.0073049, -0.0647284, 0.0095065, 0.0734671, + 0.1810363, -0.1986703, -0.9021562, -0.0531724, 0.1711020, + 1.0069678, 0.3374239, 0.0013532, -0.0008799, 0.0004673, + -0.0010037, 0.0012066, 0.0106503, -0.0013597, -0.0133213, + -0.0317175, 0.0131135, 0.1900746, 0.0274542, 0.0219766, + -0.1865375, -0.2478489, 0.4516593, 0.4405954, 0.2365605}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{70.895846, 59.464825, 37.952202, 30.130460, + 22.069759, 14.698635, 10.218985, 7.728522, + 2.814291, 2.497050, 1.130890, 0.196115}, + std::vector{2, 3, 2, 3, 3, 2, 3, 3, 3, 2, 2, 2}, + std::vector{ + -0.0100931, -0.0174432, 0.2584297, 0.3175271, 0.3567559, + 0.1710861, -0.0014847, 0.0011795, 0.0004688, -0.0007045, + -0.0000129, 0.0000009, -0.0062797, -0.0110075, 0.1312870, + 0.1420873, 0.2739032, -0.0109785, -0.7647787, -0.3482456, + 0.0113424, -0.0187208, -0.0000925, 0.0000079, -0.0031093, + -0.0054710, 0.0598976, 0.0598544, 0.1457256, -0.0952235, + -0.2946978, -0.6331595, -0.6868323, 2.0226641, 0.0097665, + 0.0000986}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{47.023018, 36.370436, 21.568305, 15.802277, + 9.789646, 8.085587, 5.751051, 3.321060, + 2.081540, 1.311344, 0.823347, 0.196115}, + std::vector{3, 4, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0010334, 0.0048355, -0.0053856, 0.1918578, 0.6488541, + 0.1633596, 0.0704605, 0.0025276, 0.0000909, 0.0002621, + -0.0000108, 0.0000015, -0.0004322, -0.0020821, 0.0063723, + -0.0691395, -0.2239874, -0.1872743, 0.1633227, 0.4692730, + 0.4294401, 0.1966616, 0.0188897, 0.0001237}, + std::vector{5, 5}, std::vector{5, 3})})}, + {46, + SlaterTypeAtom( + 46, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Pd + * + * Etot=-4937.891539113 Ekin=4937.891549244 + */ + SlaterTypeAtomicShell( + 0, + std::vector{ + 82.981122, 60.747521, + 48.682686, 36.184851, + 22.659076, 22.631895, + 10.854225, 8.701432, 8.695647, 4.273868, 3.566041, + 2.662568, 0.820846, + 0.418647, 0.197622}, + std::vector{1, 3, 1, 4, 2, 3, 3, 3, 2, 3, 2, 2, 2, 2, 1}, + std::vector{ + 0.0256355, -0.0312533, -0.9650744, 0.0388574, -0.1114253, + 0.0453052, 0.0185098, 0.0017076, -0.0274118, -0.0030933, + 0.0044358, -0.0002481, -0.0000004, 0.0000011, -0.0000007, + 0.0349496, -0.0397232, -0.3695798, 0.0943704, 0.4161477, + 0.4544307, -0.2255012, -0.0649154, 0.4013997, 0.0073839, + -0.0105759, 0.0005491, 0.0000011, -0.0000026, 0.0000017, + -0.0153231, 0.0179098, 0.1599679, -0.0336988, -0.1478567, + -0.3499105, 1.1587544, 0.4882484, -0.5868246, -0.0734838, + 0.1191386, -0.0088652, 0.0002009, -0.0001583, 0.0000853, + 0.0062041, -0.0073693, -0.0657128, 0.0110971, 0.0684864, + 0.1770565, -0.2191196, -0.9055084, 0.0241755, 0.2831394, + 0.8326612, 0.3604849, -0.0000912, 0.0003483, -0.0002145, + -0.0009856, 0.0012189, 0.0105606, -0.0012174, -0.0132458, + -0.0321820, -0.0010872, 0.2032059, 0.0317535, 0.0363421, + -0.2283255, -0.2143572, 0.4440534, 0.4434227, 0.2392182}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{72.763428, 61.391085, 40.145578, 31.547867, + 22.930719, 15.129838, 10.566692, 8.033038, + 2.981817, 2.638560, 1.257041, 0.197622}, + std::vector{2, 3, 2, 3, 3, 2, 3, 3, 3, 2, 2, 2}, + std::vector{ + -0.0124528, -0.0204308, 0.2473892, 0.3070254, 0.3701758, + 0.1849301, -0.0026556, 0.0016899, 0.0006865, -0.0010108, + -0.0000196, 0.0000011, 0.0073801, 0.0123087, -0.1233963, + -0.1344744, -0.2646510, -0.0264869, 0.7648512, 0.3562503, + -0.0135288, 0.0221899, 0.0001089, -0.0000075, -0.0036557, + -0.0061225, 0.0568696, 0.0571029, 0.1409789, -0.0775629, + -0.2963976, -0.6571356, -0.6477896, 1.9985808, 0.0127375, + 0.0001049}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{48.846187, 37.689441, 21.043128, 16.505499, + 10.228470, 8.492879, 5.949300, 3.510037, + 2.202995, 1.383750, 0.834115, 0.197622}, + std::vector{3, 4, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0009253, 0.0044159, -0.0093387, 0.1851618, 0.6490813, + 0.1735437, 0.0697387, 0.0024666, 0.0003901, 0.0003290, + 0.0000017, 0.0000012, -0.0003752, -0.0018337, 0.0091133, + -0.0712230, -0.2284375, -0.1878176, 0.1557415, 0.4735653, + 0.4293688, 0.1971706, 0.0159927, 0.0000088}, + std::vector{5, 5}, std::vector{5, 4})})}, + {47, + SlaterTypeAtom( + 47, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ag + * + * Etot=-5197.700044872 Ekin=5197.700026196 + */ + SlaterTypeAtomicShell( + 0, + std::vector{ + 85.305163, 62.457007, + 49.871615, 37.263502, + 23.304987, 23.300356, + 11.212479, 9.082031, 9.080096, 4.377027, 3.715784, + 2.779019, 0.834783, + 0.423437, 0.198185}, + std::vector{1, 3, 1, 4, 2, 3, 3, 3, 2, 3, 2, 2, 2, 2, 1}, + std::vector{ + 0.0261989, -0.0316693, -0.9632641, 0.0405890, -0.1172765, + 0.0481683, 0.0194031, 0.0013776, -0.0283156, -0.0025520, + 0.0036396, -0.0000997, -0.0000040, 0.0000039, -0.0000022, + 0.0341466, -0.0387649, -0.3675893, 0.0937391, 0.3954179, + 0.4666085, -0.2327256, -0.0585706, 0.4100650, 0.0081263, + -0.0117235, 0.0003247, 0.0000101, -0.0000101, 0.0000057, + -0.0150339, 0.0175584, 0.1598928, -0.0338235, -0.1334891, + -0.3497599, 1.1679093, 0.5149004, -0.6401066, -0.0758651, + 0.1234893, -0.0062150, 0.0000887, -0.0000639, 0.0000335, + 0.0061338, -0.0073302, -0.0662984, 0.0107782, 0.0647595, + 0.1811337, -0.1737942, -0.9750295, 0.0303302, 0.2554751, + 0.8568292, 0.3758082, 0.0005078, -0.0001938, 0.0000867, + -0.0009487, 0.0011755, 0.0103698, -0.0011878, -0.0122262, + -0.0317595, -0.0084512, 0.2089403, 0.0268111, 0.0304144, + -0.2088598, -0.2142774, 0.4388684, 0.4449586, 0.2404329}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{74.591010, 63.110483, 41.631608, 32.619766, + 23.644933, 15.561041, 10.856753, 8.298135, + 3.285426, 2.874497, 1.568455, 0.198185}, + std::vector{2, 3, 2, 3, 3, 2, 3, 3, 3, 2, 2, 2}, + std::vector{ + -0.0132066, -0.0211610, 0.2417236, 0.3009280, 0.3745840, + 0.1937223, -0.0035221, 0.0022412, 0.0010867, -0.0015705, + -0.0000259, 0.0000008, 0.0077084, 0.0125691, -0.1197779, + -0.1308100, -0.2602839, -0.0460055, 0.7784882, 0.3450066, + -0.0182846, 0.0295942, 0.0000310, -0.0000034, -0.0038137, + -0.0062385, 0.0555796, 0.0562085, 0.1388556, -0.0692409, + -0.3086829, -0.6779652, -0.4945313, 1.8641590, 0.0315468, + 0.0001466}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{49.287101, 38.264876, 21.633892, 17.358427, + 10.665363, 8.921103, 6.286586, 3.679086, + 2.279635, 1.433397, 0.878640, 0.198185}, + std::vector{3, 4, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0010660, 0.0049044, -0.0189552, 0.1824962, 0.6487021, + 0.1739498, 0.0797947, 0.0018546, -0.0001029, 0.0000504, + -0.0000127, 0.0000007, -0.0004589, -0.0021654, 0.0140526, + -0.0739593, -0.2340320, -0.1946674, 0.1536644, 0.4946313, + 0.4322613, 0.1799179, 0.0135599, 0.0000354}, + std::vector{5, 5}, std::vector{5, 5})})}, + {48, SlaterTypeAtom(48, std::vector{})}, + {49, + SlaterTypeAtom( + 49, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for In + * + * Etot=-5740.175135526 Ekin=5740.175132802 + */ + SlaterTypeAtomicShell( + 0, + std::vector{93.002524, 66.567623, 51.788992, 33.585927, + 24.979585, 24.848421, 15.425961, + 11.634093, 9.743264, 4.673739, 3.845632, + 2.839156, + 1.128559, + 0.694271, + 0.206907}, + std::vector{1, 3, 1, 3, 3, 2, 2, 3, 3, 3, 2, 2, 2, 2, 1}, + std::vector{ + -0.0136331, 0.0201676, 0.9432129, -0.1274000, -0.0768179, + 0.2443424, 0.0091827, -0.0027588, 0.0018663, 0.0010504, + -0.0015629, 0.0001430, -0.0000063, 0.0000029, -0.0000006, + -0.0137526, 0.0186650, 0.3270770, -0.2783703, -0.5293806, + -0.0425397, -0.2375412, 0.0431033, -0.0351150, -0.0268889, + 0.0391641, -0.0031227, 0.0000755, -0.0000278, 0.0000043, + -0.0070897, 0.0099868, 0.1457824, -0.1021796, -0.3449057, + 0.0281979, -0.3404917, 0.9149678, 0.2893303, -0.1928670, + 0.2975982, -0.0276010, 0.0011649, -0.0005256, 0.0000970, + 0.0033862, -0.0048606, -0.0632856, 0.0335642, 0.1803808, + 0.0075567, 0.0695759, -0.1568576, -0.9937052, 0.3577930, + 0.9446220, 0.1809834, -0.0022642, 0.0012266, -0.0002209, + -0.0009792, 0.0014548, 0.0165804, -0.0058906, -0.0522405, + -0.0085042, 0.0041360, 0.0020087, 0.3736605, 0.0539584, + -0.3724439, -0.4171006, 0.8159567, 0.3900812, 0.0065491}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{60.694232, 53.463933, 35.070087, 24.998843, + 20.280370, 11.448377, 9.049896, 4.240247, + 3.537174, 2.545946, 1.284620, 0.622346, + 0.345918, 0.206907}, + std::vector{2, 3, 3, 2, 3, 3, 3, 3, 2, 2, 3, 2, 2, 2}, + std::vector{ + 0.0152730, 0.0184303, 0.1062307, -0.9457889, -0.2172463, + -0.0023621, -0.0013043, -0.0026943, 0.0037452, -0.0000888, + -0.0000184, 0.0000175, -0.0000093, 0.0000031, 0.0281523, + 0.0329492, 0.1554702, -0.6259674, -0.1034032, 0.7790752, + 0.3166823, -0.0937828, 0.1438543, -0.0089575, 0.0003006, + -0.0001943, 0.0000845, -0.0000263, -0.0193177, -0.0224288, + -0.1052887, 0.3178870, -0.0060455, -0.3014483, -0.6886549, + 0.0725038, 1.1050416, 0.2402464, 0.0017357, -0.0000395, + 0.0000661, -0.0000098, 0.0034570, 0.0040055, 0.0188183, + -0.0533416, 0.0041435, 0.0465130, 0.1377247, 0.0425998, + -0.2226286, -0.1571558, 0.1844677, 0.5613938, 0.3513951, + 0.0282851}, + std::vector{3, 3, 3, 2}, std::vector{3, 3, 3, 0}), + SlaterTypeAtomicShell( + 2, + std::vector{53.933298, 41.326188, 20.719616, 19.105212, + 11.620626, 8.696235, 6.701076, 4.157477, + 2.726803, 1.795842, 0.878993, 0.206907}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0007767, 0.0039130, -0.0926586, 0.2426822, 0.5017912, + 0.3388667, 0.0614034, 0.0022610, -0.0002587, 0.0000707, + -0.0000133, 0.0000009, -0.0003690, -0.0019110, 0.0680920, + -0.1347461, -0.1106508, -0.3419774, 0.1446935, 0.4883661, + 0.4795704, 0.1361193, 0.0027374, 0.0000421}, + std::vector{5, 5}, std::vector{5, 5})})}, + {50, + SlaterTypeAtom( + 50, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Sn + * + * Etot=-6022.972651014 Ekin=6022.972630571 + */ + SlaterTypeAtomicShell( + 0, + std::vector{94.900535, 68.137341, 52.948296, 34.761265, + 26.007709, 25.949436, 16.903961, 11.858400, + 10.176580, 4.868171, 4.006024, 3.039834, + 1.301440, 0.827032, 0.348192}, + std::vector{1, 3, 1, 3, 3, 2, 2, 3, 3, 3, 2, 2, 2, 2, 1}, + std::vector{ + -0.0138183, 0.0198562, 0.9410948, -0.1279953, -0.0749505, + 0.2451754, 0.0097245, -0.0023458, 0.0017831, 0.0009141, + -0.0013809, 0.0001422, -0.0000059, 0.0000029, -0.0000008, + -0.0132508, 0.0175628, 0.3254143, -0.2638608, -0.5191222, + 0.0125773, -0.3041022, 0.0293897, -0.0262384, -0.0176844, + 0.0263304, -0.0024133, 0.0000485, -0.0000167, 0.0000031, + -0.0068447, 0.0094001, 0.1455764, -0.0986014, -0.3136082, + 0.0779480, -0.4121925, 0.8990223, 0.2807362, -0.2110214, + 0.3343813, -0.0364427, 0.0015625, -0.0007899, 0.0002104, + 0.0033716, -0.0047286, -0.0641719, 0.0317580, 0.1690211, + -0.0128240, 0.1143258, -0.0910092, -1.0320301, 0.5271259, + 0.7176434, 0.2118723, -0.0032956, 0.0021796, -0.0005747, + -0.0010673, 0.0015475, 0.0182540, -0.0057559, -0.0541201, + -0.0043821, -0.0086787, -0.0217629, 0.4226436, 0.0160398, + -0.2702319, -0.5787906, 0.7888065, 0.4667013, 0.0108722}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{61.557331, 54.446852, 35.958273, 25.603693, + 20.785282, 11.749263, 9.457270, 4.402498, + 3.621333, 2.448783, 1.797727, 0.963211, + 0.565190, 0.348192}, + std::vector{2, 3, 3, 2, 3, 3, 3, 3, 2, 2, 3, 2, 2, 2}, + std::vector{ + 0.0158245, 0.0183766, 0.1048576, -0.9423005, -0.2202437, + -0.0016597, -0.0022566, -0.0043002, 0.0058319, -0.0001775, + -0.0000665, 0.0000615, -0.0000261, 0.0000073, 0.0274683, + 0.0309618, 0.1465037, -0.6138386, -0.1130942, 0.7732700, + 0.3093412, -0.1387519, 0.2084323, -0.0168521, 0.0022398, + -0.0008740, 0.0002544, -0.0000603, -0.0191676, -0.0214240, + -0.1009453, 0.3153120, -0.0001419, -0.2781282, -0.7070862, + 0.1650614, 1.1062552, 0.1389558, -0.0039361, 0.0027254, + -0.0007383, 0.0001407, 0.0044471, 0.0049585, 0.0233928, + -0.0680307, 0.0045469, 0.0530937, 0.1847434, 0.0459218, + -0.2893138, -0.2777657, 0.0281210, 0.6083342, 0.4959805, + 0.0416434}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 0}), + SlaterTypeAtomicShell( + 2, + std::vector{55.822411, 42.711782, 22.202820, 18.939736, + 11.836843, 9.058130, 7.334322, 4.348937, + 2.914349, 1.946943, 1.009402, 0.348192}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0006748, 0.0034267, -0.0229624, 0.1790588, 0.5136533, + 0.2881761, 0.0922255, 0.0034229, -0.0006622, 0.0001708, + -0.0000326, 0.0000041, -0.0003516, -0.0018448, 0.0255010, + -0.0983034, -0.1023303, -0.3928070, 0.1654587, 0.5107462, + 0.4847946, 0.1134103, 0.0030447, 0.0000335}, + std::vector{5, 5}, std::vector{5, 5})})}, + {51, + SlaterTypeAtom( + 51, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Sb + * + * Etot=-6313.481511833 Ekin=6313.481503701 + */ + SlaterTypeAtomicShell( + 0, + std::vector{96.798546, 69.652001, 54.100312, 35.654960, + 26.659081, 26.648000, 17.135996, 12.212107, + 10.809756, 5.084521, 4.177670, 3.294303, + 1.426771, 0.923016, 0.380412}, + std::vector{1, 3, 1, 3, 3, 2, 2, 3, 3, 3, 2, 2, 2, 2, 1}, + std::vector{ + -0.0141928, 0.0199444, 0.9397293, -0.1306681, -0.0764538, + 0.2502062, 0.0106821, -0.0037390, 0.0030187, 0.0012667, + -0.0019415, 0.0002286, -0.0000047, 0.0000018, -0.0000004, + -0.0131150, 0.0171203, 0.3247224, -0.2613933, -0.5284025, + 0.0203516, -0.3073575, 0.0451257, -0.0392193, -0.0195442, + 0.0298046, -0.0033016, 0.0000268, -0.0000027, -0.0000013, + -0.0067904, 0.0091802, 0.1458471, -0.0987088, -0.3150808, + 0.0839064, -0.4307024, 0.8336697, 0.3368850, -0.2495807, + 0.4083330, -0.0543641, 0.0016560, -0.0007845, 0.0001823, + 0.0034078, -0.0047097, -0.0651759, 0.0320631, 0.1721080, + -0.0157034, 0.1309100, 0.1256863, -1.1840399, 0.7808821, + 0.3228149, 0.2950699, -0.0034688, 0.0024001, -0.0005461, + -0.0011473, 0.0016323, 0.0198790, -0.0065341, -0.0588917, + -0.0034135, -0.0141908, -0.1177532, 0.5239394, -0.0559575, + -0.0485069, -0.8008331, 0.8565773, 0.4478187, 0.0095344}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{63.108478, 55.799187, 36.824657, 26.158874, + 21.264468, 12.079975, 10.066493, 4.665185, + 3.822874, 2.819023, 1.833682, 1.026448, + 0.607960, 0.380412}, + std::vector{2, 3, 3, 2, 3, 3, 3, 3, 2, 2, 3, 2, 2, 2}, + std::vector{ + 0.0152445, 0.0177389, 0.1013657, -0.9372823, -0.2210263, + -0.0005558, -0.0034130, -0.0052029, 0.0072537, -0.0004024, + -0.0000713, 0.0000724, -0.0000300, 0.0000083, 0.0261096, + 0.0295452, 0.1398144, -0.6061088, -0.1206951, 0.7299127, + 0.3275341, -0.1989825, 0.3077075, -0.0324281, 0.0022473, + -0.0011699, 0.0003343, -0.0000806, -0.0188258, -0.0211213, + -0.0994919, 0.3189534, 0.0059632, -0.1863522, -0.7442138, + 0.4156953, 0.7229491, 0.2244747, -0.0010878, 0.0025321, + -0.0003806, 0.0001414, 0.0050029, 0.0056006, 0.0264012, + -0.0783335, 0.0042643, 0.0335532, 0.2248847, 0.0048074, + -0.1874018, -0.3902175, 0.1076938, 0.6266632, 0.4263521, + 0.0338499}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 1}), + SlaterTypeAtomicShell( + 2, + std::vector{57.719626, 44.051548, 23.600649, 19.719256, + 12.226480, 9.309346, 7.533815, 4.424274, + 3.010951, 1.978292, 1.023030, 0.380412}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0006751, 0.0035203, -0.0240347, 0.1709648, 0.5229215, + 0.2932485, 0.0860199, 0.0027357, -0.0005220, 0.0000965, + -0.0000228, 0.0000030, -0.0003863, -0.0020750, 0.0241934, + -0.0946237, -0.1144670, -0.4164377, 0.1919972, 0.5592006, + 0.4649712, 0.0739717, 0.0014905, 0.0001087}, + std::vector{5, 5}, std::vector{5, 5})})}, + {52, + SlaterTypeAtom( + 52, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Te + * + * Etot=-6611.827941644 Ekin=6611.827930431 + */ + SlaterTypeAtomicShell( + 0, + std::vector{98.696557, 71.109902, 55.203765, 36.413466, + 27.185358, 27.176295, 17.146329, 12.624989, + 11.500387, 5.338931, 4.354008, 3.598887, + 1.543469, 1.014789, 0.439220}, + std::vector{1, 3, 1, 3, 3, 2, 2, 3, 3, 3, 2, 2, 2, 2, 1}, + std::vector{ + -0.0143932, 0.0199657, 0.9392786, -0.1323231, -0.0782091, + 0.2537162, 0.0113479, -0.0058402, 0.0047792, 0.0014140, + -0.0023001, 0.0003876, -0.0000054, 0.0000022, -0.0000005, + -0.0130455, 0.0168675, 0.3246354, -0.2635481, -0.5381882, + 0.0167374, -0.2978286, 0.0749923, -0.0640411, -0.0224189, + 0.0361803, -0.0057986, 0.0000280, -0.0000018, -0.0000020, + -0.0067416, 0.0090121, 0.1463100, -0.1010178, -0.3224378, + 0.0817764, -0.4403559, 0.7030322, 0.4583352, -0.3030897, + 0.5285607, -0.0986951, 0.0020354, -0.0009962, 0.0002393, + 0.0033951, -0.0046249, -0.0661231, 0.0342491, 0.1775261, + -0.0157055, 0.1459397, 0.4593905, -1.4349070, 1.0804712, + -0.2525433, 0.4958316, -0.0043522, 0.0032828, -0.0007839, + -0.0012193, 0.0017158, 0.0212964, -0.0072532, -0.0647529, + -0.0046540, -0.0151956, -0.2893801, 0.6897869, -0.1251484, + 0.3129503, -1.1398850, 0.8986827, 0.4421499, 0.0094548}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{64.685899, 57.184474, 37.739300, 26.741405, + 21.741953, 12.398140, 10.781732, 4.928817, + 3.986007, 3.099862, 2.193439, 1.200562, + 0.704625, 0.439220}, + std::vector{2, 3, 3, 2, 3, 3, 3, 3, 2, 2, 3, 2, 2, 2}, + std::vector{ + 0.0151440, 0.0176003, 0.0998026, -0.9343140, -0.2228118, + 0.0022257, -0.0063711, -0.0073765, 0.0106251, -0.0010261, + -0.0001030, 0.0000940, -0.0000374, 0.0000102, 0.0250414, + 0.0283638, 0.1341043, -0.5997170, -0.1289629, 0.6631113, + 0.3622625, -0.2807217, 0.4584277, -0.0746964, 0.0043449, + -0.0015193, 0.0003748, -0.0000883, -0.0185982, -0.0208815, + -0.0983022, 0.3235037, 0.0130857, -0.0273966, -0.8355113, + 0.6827556, 0.2943408, 0.3298143, -0.0022837, 0.0038092, + -0.0000868, 0.0001732, 0.0055130, 0.0061761, 0.0290949, + -0.0879742, 0.0035556, -0.0162770, 0.2836807, -0.0520832, + -0.0174648, -0.5822654, 0.0694874, 0.6741054, 0.4590286, + 0.0362080}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 2}), + SlaterTypeAtomicShell( + 2, + std::vector{58.017463, 44.619250, 23.468745, 20.663265, + 12.602923, 9.590733, 7.865781, 4.505846, + 3.085856, 1.975996, 1.029740, 0.439220}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0007250, 0.0035918, -0.0485453, 0.1881888, 0.5306449, + 0.2876293, 0.0895323, 0.0030475, -0.0008033, 0.0001623, + -0.0000402, 0.0000073, -0.0004218, -0.0021485, 0.0429167, + -0.1128511, -0.1185071, -0.4534113, 0.2208888, 0.6263285, + 0.4220345, 0.0456469, 0.0008071, 0.0001145}, + std::vector{5, 5}, std::vector{5, 5})})}, + {53, + SlaterTypeAtom( + 53, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for I + * + * Etot=-6918.075874765 Ekin=6918.075851667 + */ + SlaterTypeAtomicShell( + 0, + std::vector{99.544887, 72.197354, 56.329742, 37.245551, + 27.923028, 27.919883, 17.738763, 12.821800, + 12.583482, 5.587956, 4.521078, 3.895939, + 1.664154, 1.112226, 0.508250}, + std::vector{1, 3, 1, 3, 3, 2, 2, 3, 4, 3, 2, 2, 2, 2, 1}, + std::vector{ + -0.0155173, 0.0204136, 0.9399270, -0.1302187, -0.0754311, + 0.2498953, 0.0106324, -0.0023242, 0.0013565, 0.0010172, + -0.0018215, 0.0004409, -0.0000053, 0.0000025, -0.0000006, + -0.0137756, 0.0169859, 0.3257493, -0.2566192, -0.5308314, + 0.0284192, -0.3235624, 0.0330144, -0.0221871, -0.0221393, + 0.0387951, -0.0087909, 0.0000158, 0.0000052, -0.0000043, + -0.0071152, 0.0090567, 0.1474089, -0.0988619, -0.3127303, + 0.0939526, -0.4704189, 1.0417484, 0.0968833, -0.3641140, + 0.6962698, -0.1795455, 0.0024659, -0.0012446, 0.0003127, + 0.0036292, -0.0047029, -0.0674541, 0.0334948, 0.1756113, + -0.0209970, 0.1733543, -0.5273469, -0.3864838, 1.3693752, + -0.9461459, 0.8238781, -0.0050630, 0.0041826, -0.0010541, + -0.0013745, 0.0018428, 0.0227067, -0.0068857, -0.0680776, + -0.0045298, -0.0220064, 0.1975418, 0.1998568, -0.2099566, + 0.8604314, -1.6350660, 0.9152105, 0.4586327, 0.0106418}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{66.299859, 58.616682, 38.696883, 27.346853, + 22.234664, 12.733619, 11.610025, 5.190359, + 4.147298, 3.429415, 2.407831, 1.325387, + 0.792179, 0.508250}, + std::vector{2, 3, 3, 2, 3, 3, 3, 3, 2, 2, 3, 2, 2, 2}, + std::vector{ + 0.0152038, 0.0176077, 0.0987903, -0.9311461, -0.2257140, + 0.0079736, -0.0120916, -0.0090579, 0.0139820, -0.0022583, + -0.0001386, 0.0001258, -0.0000501, 0.0000139, 0.0240919, + 0.0272491, 0.1287775, -0.5933682, -0.1375959, 0.5140604, + 0.4803682, -0.3568584, 0.6411659, -0.1545951, 0.0057791, + -0.0018849, 0.0004812, -0.0001093, -0.0185268, -0.0207655, + -0.0977567, 0.3294933, 0.0204090, 0.3046644, -1.0946434, + 0.9550797, -0.2633789, 0.5543373, -0.0024413, 0.0036966, + -0.0007063, 0.0001654, 0.0059575, 0.0066626, 0.0313864, + -0.0965045, 0.0025838, -0.1395201, 0.4044950, -0.1209106, + 0.2882797, -0.8634674, 0.0656231, 0.7009569, 0.4626981, + 0.0345341}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{58.715602, 45.423957, 25.126481, 21.192448, + 13.004131, 10.015551, 8.247493, 4.658977, + 3.214866, 1.994610, 0.998746, 0.508250}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0007950, 0.0037971, -0.0329864, 0.1667721, 0.5247984, + 0.2793710, 0.1079769, 0.0029290, -0.0007920, 0.0001308, + -0.0000396, 0.0000103, -0.0005190, -0.0025554, 0.0317327, + -0.1009594, -0.1126362, -0.4702185, 0.2106314, 0.6741838, + 0.3930051, 0.0339939, 0.0001353, 0.0001844}, + std::vector{5, 5}, std::vector{5, 5})})}}; diff --git a/include/integratorxx/atomic_densities/k99l_cation.hpp b/include/integratorxx/atomic_densities/k99l_cation.hpp new file mode 100644 index 0000000..f94b5ef --- /dev/null +++ b/include/integratorxx/atomic_densities/k99l_cation.hpp @@ -0,0 +1,2482 @@ +#include "SlaterAtomicShell.hpp" +#include +static const std::map k99l_cation{ + {1, SlaterTypeAtom(1, std::vector{})}, + {2, SlaterTypeAtom(2, std::vector{})}, + {3, + SlaterTypeAtom( + 3, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Li + * + * Etot=-7.236415201 Ekin=7.236415202 + */ + SlaterTypeAtomicShell( + 0, + std::vector{11.218455, 5.354960, 3.261521, 2.814254, + 2.363203}, + std::vector{1, 1, 1, 2, 1}, + std::vector{-0.0008729, 0.0587322, 0.2907982, + 0.0619097, 0.6128385}, + std::vector{1}, std::vector{1})})}, + {4, + SlaterTypeAtom( + 4, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Be + * + * Etot=-14.277394812 Ekin=14.277394812 + */ + SlaterTypeAtomicShell( + 0, + std::vector{12.893979, 7.512987, 5.403531, 4.422860, + 3.117200, 1.552788, 1.181205, 1.154250}, + std::vector{1, 2, 1, 2, 1, 2, 2, 1}, + std::vector{-0.0022254, -0.0118931, 0.3875011, + 0.1991663, 0.4717797, 0.0094101, 0.0045259, + -0.0194427, 0.0005419, 0.0019158, + -0.0349763, 0.0066219, -0.1099453, + 0.2390992, 1.1745744, -0.4630159}, + std::vector{1, 1}, std::vector{1, 0})})}, + {5, + SlaterTypeAtom( + 5, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for B + * + * Etot=-24.237575182 Ekin=24.237575154 + */ + SlaterTypeAtomicShell( + 0, + std::vector{19.552542, 7.836769, 6.239598, 4.180846, + 2.454754, 1.925902, 1.356578, 1.321986}, + std::vector{1, 1, 2, 1, 1, 2, 1, 2}, + std::vector{ + -0.0005259, 0.2163033, 0.1451222, 0.6724596, -0.0030166, + 0.0040794, -0.0061783, 0.0009129, 0.0001235, 0.0068743, + 0.0322259, -0.1893342, -0.9720114, -0.4406588, 1.8229831, + 0.3672927}, + std::vector{1, 1}, std::vector{1, 1})})}, + {6, + SlaterTypeAtom( + 6, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for C + * + * Etot=-37.29222377 Ekin=37.292223758 + */ + SlaterTypeAtomicShell( + 0, + std::vector{22.454541, 9.614463, 7.721450, 5.166228, + 3.178746, 2.397569, 1.425365, 1.345184}, + std::vector{1, 1, 2, 1, 1, 2, 1, 2}, + std::vector{ + -0.0005984, 0.1852569, 0.1243627, 0.7131840, 0.0023454, + 0.0009096, -0.0001368, 0.0000628, 0.0001428, 0.0086694, + 0.0286310, -0.1798031, -0.7995511, -0.3147955, 1.8811429, + -0.0340893}, + std::vector{1, 1}, std::vector{1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{14.444276, 6.956407, 4.615855, 3.483233, + 2.220195, 1.498940, 1.345184}, + std::vector{3, 2, 2, 2, 2, 2, 3}, + std::vector{0.0000857, 0.0092705, -0.0120655, + 0.0790120, 0.2559441, 0.6807658, + 0.0323882}, + std::vector{1}, std::vector{0})})}, + {7, + SlaterTypeAtom( + 7, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for N + * + * Etot=-53.888005011 Ekin=53.88800501 + */ + SlaterTypeAtomicShell( + 0, + std::vector{24.925633, 11.494691, 9.276068, 6.161493, + 3.876285, 2.839197, 1.638966, 1.490012}, + std::vector{1, 1, 2, 1, 1, 2, 1, 2}, + std::vector{ + 0.0007202, -0.1576811, -0.1069596, -0.7483314, -0.0093307, + -0.0006600, -0.0005458, 0.0000317, 0.0001677, 0.0095678, + 0.0254290, -0.1746595, -0.7005232, -0.2212778, 1.6794828, + -0.0122038}, + std::vector{1, 1}, std::vector{1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{16.238644, 8.531627, 4.960330, 3.669059, + 2.412855, 1.677083, 1.490012}, + std::vector{3, 2, 2, 2, 2, 2, 3}, + std::vector{0.0000982, 0.0062827, 0.0044830, 0.1217127, + 0.3138426, 0.5833163, 0.0223526}, + std::vector{2}, std::vector{0})})}, + {8, + SlaterTypeAtom( + 8, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for O + * + * Etot=-74.372605677 Ekin=74.372605671 + */ + SlaterTypeAtomicShell( + 0, + std::vector{28.007046, 13.302796, 10.792436, 7.133949, + 4.615700, 3.338585, 1.841282, 1.629055}, + std::vector{1, 1, 2, 1, 1, 2, 1, 2}, + std::vector{ + 0.0007370, -0.1450721, -0.0998973, -0.7613866, -0.0144516, + -0.0009627, -0.0006986, 0.0000368, 0.0001693, 0.0095572, + 0.0226110, -0.1669339, -0.6315700, -0.1518039, 1.5407668, + -0.0064379}, + std::vector{1, 1}, std::vector{1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{18.267737, 9.989752, 5.270533, 3.934220, + 2.650524, 1.853557, 1.629055}, + std::vector{3, 2, 2, 2, 2, 2, 3}, + std::vector{0.0001036, 0.0051311, 0.0262024, 0.1472171, + 0.3428229, 0.5188278, 0.0171613}, + std::vector{3}, std::vector{0})})}, + {9, + SlaterTypeAtom( + 9, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for F + * + * Etot=-98.831720195 Ekin=98.831720181 + */ + SlaterTypeAtomicShell( + 0, + std::vector{31.450094, 15.057760, 12.278272, 8.102550, + 5.356575, 3.896304, 2.053128, 1.699484}, + std::vector{1, 1, 2, 1, 1, 2, 1, 2}, + std::vector{ + 0.0006932, -0.1374212, -0.0955170, -0.7683816, -0.0182997, + -0.0011950, -0.0008885, 0.0000325, 0.0001575, 0.0099251, + 0.0209848, -0.1610834, -0.5929072, -0.0993401, 1.4467923, + -0.0009581}, + std::vector{1, 1}, std::vector{1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{20.487784, 11.578430, 5.669336, 4.138776, + 2.810319, 1.955380, 1.699484}, + std::vector{3, 2, 2, 2, 2, 2, 3}, + std::vector{0.0001017, 0.0040208, 0.0541934, 0.1861459, + 0.3445465, 0.4634053, 0.0154226}, + std::vector{3}, std::vector{1})})}, + {10, + SlaterTypeAtom( + 10, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ne + * + * Etot=-127.817814121 Ekin=127.817814176 + */ + SlaterTypeAtomicShell( + 0, + std::vector{34.921304, 16.836113, + 13.786492, 9.073331, 5.971493, 4.346384, + 2.266111, + 1.792539}, + std::vector{1, 1, 2, 1, 1, 2, 1, 2}, + std::vector{ + 0.0006517, -0.1300724, -0.0911229, -0.7765145, -0.0210099, + -0.0012269, + -0.0010239, 0.0000318, 0.0001338, 0.0145852, + 0.0240362, -0.1814771, -0.5609139, -0.0606112, 1.3920991, + 0.0016472}, + std::vector{1, 1}, std::vector{1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{22.917554, 13.143059, 6.237158, 4.379686, + 2.949963, + 2.064486, + 1.792539}, + std::vector{3, 2, 2, 2, 2, 2, 3}, + std::vector{0.0000994, 0.0033089, 0.0737967, 0.2239485, + 0.3524439, 0.4087274, + 0.0118909}, + std::vector{3}, std::vector{2})})}, + {11, + SlaterTypeAtom( + 11, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Na + * + * Etot=-161.676962609 Ekin=161.676962476 + */ + SlaterTypeAtomicShell( + 0, + std::vector{38.286368, 18.558412, 15.257782, + 10.016950, 6.613006, 4.947267, 2.474614, + 1.895886}, + std::vector{1, 1, 2, 1, 1, 2, 1, 2}, + std::vector{ + -0.0006231, 0.1289430, 0.0914534, 0.7763334, 0.0215878, + 0.0015130, 0.0011207, -0.0000302, 0.0001173, 0.0176200, + 0.0257231, -0.1956336, -0.5325836, -0.0307722, 1.3468561, + 0.0026824}, + std::vector{1, 1}, std::vector{1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{25.035874, 14.553626, 6.758888, 4.571932, + 3.037726, + 2.162522, + 1.895886}, + std::vector{3, 2, 2, 2, 2, 2, 3}, + std::vector{0.0000918, 0.0029693, 0.0948327, 0.2647974, + 0.3614230, 0.3465004, 0.0078852}, + std::vector{3}, std::vector{3})})}, + {12, + SlaterTypeAtom( + 12, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Mg + * + * Etot=-199.371809657 Ekin=199.371809657 + */ + SlaterTypeAtomicShell( + 0, + std::vector{30.489574, 16.928524, 14.613007, + 10.060309, 5.113615, 3.040431, 2.740295, + 1.461943, + 1.120710, + 1.040615}, + std::vector{3, 1, 2, 1, 2, 3, 2, 3, 3, 1}, + std::vector{ + 0.0006381, -0.3590905, -0.1990386, -0.4741561, -0.0023402, + 0.0004358, -0.0006306, 0.0001132, 0.0000004, -0.0002397, + 0.0002759, 0.0587311, 0.0551448, -0.4445466, 0.3903349, + -0.5219190, 1.2277256, 0.0138485, 0.0023073, -0.0420458, + -0.0000503, -0.0150626, -0.0140141, 0.1003790, -0.1201024, + 0.0686226, -0.3378383, 0.4161351, 0.5688742, 0.1486247}, + std::vector{1, 1, 1}, std::vector{1, 1, 0}), + SlaterTypeAtomicShell( + 1, + std::vector{27.569118, 15.967731, 7.248739, 4.754054, + 3.082852, 2.257316, 1.040615}, + std::vector{3, 2, 2, 2, 2, 2, 3}, + std::vector{0.0000884, 0.0028602, 0.1231105, 0.3114869, + 0.5050633, 0.1240642, 0.0002805}, + std::vector{3}, std::vector{3})})}, + {13, + SlaterTypeAtom( + 13, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Al + * + * Etot=-241.674670411 Ekin=241.674670713 + */ + SlaterTypeAtomicShell( + 0, + std::vector{32.296386, 18.512920, 15.998712, + 10.978117, 5.628319, 3.751762, 3.500398, + 1.701856, + 1.258305, + 1.142189}, + std::vector{3, 1, 2, 1, 2, 3, 2, 3, 3, 1}, + std::vector{ + 0.0006361, -0.3440437, -0.1939113, -0.4935399, -0.0014659, + 0.0011555, -0.0016352, 0.0002794, 0.0000213, -0.0006048, + 0.0002728, 0.0623928, 0.0565499, -0.4610859, 0.3297871, + -0.2665428, 1.0191844, -0.0014236, -0.0001947, 0.0034832, + -0.0000820, -0.0144223, -0.0131978, 0.1017995, -0.1589242, + -0.0810561, -0.2726152, 0.4002417, 0.4901999, 0.3115090}, + std::vector{1, 1, 1}, std::vector{1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{30.684557, 17.454878, 7.832108, 5.026460, + 3.397058, 2.323988, 1.142189}, + std::vector{3, 2, 2, 2, 2, 2, 3}, + std::vector{0.0000824, 0.0026588, 0.1407670, 0.3392928, + 0.5259332, 0.0502777, 0.0002970}, + std::vector{3}, std::vector{3})})}, + {14, + SlaterTypeAtom( + 14, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Si + * + * Etot=-288.573130997 Ekin=288.573130976 + */ + SlaterTypeAtomicShell( + 0, + std::vector{34.793099, 19.983744, 17.313530, + 11.902721, 6.092679, 4.310043, 4.008864, + 2.050620, + 1.491987, + 1.082471}, + std::vector{3, 1, 2, 1, 2, 3, 2, 3, 3, 1}, + std::vector{ + 0.0005962, -0.3353354, -0.1880051, -0.5071434, -0.0013365, + 0.0010953, -0.0017617, 0.0001144, 0.0001330, -0.0003908, + 0.0002624, 0.0664880, 0.0578910, -0.4740273, 0.2908872, + -0.2408478, 1.0346409, 0.0002153, -0.0006158, 0.0018110, + -0.0000838, -0.0181474, -0.0158254, 0.1180100, -0.1834909, + -0.1359697, -0.2417828, 0.3547082, 0.4507824, 0.3954924}, + std::vector{1, 1, 1}, std::vector{1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{33.691090, 19.882253, 11.295611, 7.396430, + 5.827720, 4.889860, 3.362886, 2.617048, + 1.153748, 1.082471}, + std::vector{2, 2, 4, 2, 3, 4, 2, 3, 2, 3}, + std::vector{ + -0.0001124, 0.0032217, -0.0078257, 0.4324713, 0.3549870, + 0.0874609, 0.2180429, 0.0069988, 0.0009503, -0.0000526, + 0.0000270, -0.0007130, 0.0008398, -0.0841347, -0.0194416, + 0.0102279, -0.2820027, -0.0634605, 1.0631962, 0.0867202}, + std::vector{3, 1}, std::vector{3, 0})})}, + {15, + SlaterTypeAtom( + 15, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for P + * + * Etot=-340.349775833 Ekin=340.349776116 + */ + SlaterTypeAtomicShell( + 0, + std::vector{38.181169, 21.205740, 18.450969, + 12.744580, 6.751577, 4.865898, 4.474991, + 2.361960, + 1.695251, + 1.199982}, + std::vector{3, 1, 2, 1, 2, 3, 2, 3, 3, 1}, + std::vector{ + 0.0005190, -0.3479806, -0.1896623, -0.4929711, -0.0003575, + 0.0018506, -0.0031639, 0.0000879, 0.0001357, -0.0003388, + 0.0002508, 0.0683033, 0.0571658, -0.4834348, 0.1955318, + -0.3117828, 1.1968955, 0.0009384, 0.0001069, 0.0001748, + -0.0000802, -0.0208860, -0.0174677, 0.1297079, -0.1758223, + -0.1453819, -0.2789016, 0.3554042, 0.4396081, 0.4217097}, + std::vector{1, 1, 1}, std::vector{1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{36.179826, 22.490304, 12.983974, 8.202715, + 6.407117, 5.290358, 3.328350, 2.631487, + 1.329479, 1.199982}, + std::vector{2, 2, 4, 2, 3, 4, 2, 3, 2, 3}, + std::vector{ + -0.0001255, 0.0023625, -0.0035419, 0.4401183, 0.4444320, + 0.1254342, 0.0937758, 0.0010757, 0.0012343, -0.0000704, + 0.0000334, -0.0005530, -0.0002165, -0.1031732, -0.0742596, + -0.0141574, -0.2588732, 0.0144892, 1.0531228, 0.0780512}, + std::vector{3, 2}, std::vector{3, 0})})}, + {16, + SlaterTypeAtom( + 16, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for S + * + * Etot=-397.173182672 Ekin=397.173182902 + */ + SlaterTypeAtomicShell( + 0, + std::vector{41.218079, 22.586498, 19.711791, + 13.683736, 7.190680, 5.486663, 5.004489, + 2.655271, + 1.888789, + 1.312850}, + std::vector{3, 1, 2, 1, 2, 3, 2, 3, 3, 1}, + std::vector{ + 0.0004707, -0.3419043, -0.1831483, -0.5044034, -0.0004144, + 0.0017211, -0.0030945, 0.0000437, 0.0000568, -0.0001231, + 0.0002372, 0.0734009, 0.0589310, -0.4954328, 0.1178072, + -0.3302621, 1.2894052, 0.0015659, -0.0005140, 0.0016437, + -0.0000763, -0.0244890, -0.0196349, 0.1418930, -0.2216397, + -0.2198062, -0.1805025, 0.3695179, 0.4332872, 0.4167349}, + std::vector{1, 1, 1}, std::vector{1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{38.722620, 23.967182, 13.185059, 8.930078, + 7.068496, 5.911151, 3.720582, 2.375635, + 1.457182, 1.312850}, + std::vector{2, 2, 4, 2, 3, 4, 2, 3, 2, 3}, + std::vector{ + 0.0001197, -0.0022504, 0.0036841, -0.4329361, -0.4385415, + -0.1217259, -0.1066655, -0.0002544, -0.0009481, 0.0001319, + 0.0000274, -0.0004842, -0.0010597, -0.1158339, -0.1060264, + -0.0459839, -0.1760189, 0.1048132, 0.9709810, 0.0517472}, + std::vector{3, 3}, std::vector{3, 0})})}, + {17, + SlaterTypeAtom( + 17, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Cl + * + * Etot=-459.048590564 Ekin=459.048590546 + */ + SlaterTypeAtomicShell( + 0, + std::vector{44.031394, 23.995962, 20.988580, + 14.596904, 7.765414, 6.066785, 5.496206, + 3.020085, + 2.105889, + 1.370245}, + std::vector{3, 1, 2, 1, 2, 3, 2, 3, 3, 1}, + std::vector{ + -0.0004405, 0.3379044, 0.1795108, 0.5115036, -0.0010683, + -0.0030354, 0.0055606, -0.0000324, -0.0000404, 0.0000592, + 0.0002289, 0.0754831, 0.0588621, -0.5022667, -0.0012269, + -0.4153756, 1.4861077, 0.0023314, 0.0001914, 0.0004336, + -0.0000737, -0.0286536, -0.0222061, 0.1580000, -0.2024156, + -0.2135670, -0.1863398, 0.3954535, 0.4715283, 0.3353559}, + std::vector{1, 1, 1}, std::vector{1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{40.716974, 27.023335, 15.098366, 9.729816, + 7.683095, 6.407885, 4.024439, 2.879577, + 1.576178, 1.370245}, + std::vector{2, 2, 4, 2, 3, 4, 2, 3, 2, 3}, + std::vector{ + -0.0001465, 0.0016952, -0.0014493, 0.4251351, 0.4582471, + 0.1222902, 0.0910895, 0.0004342, 0.0016382, -0.0000453, + 0.0000382, -0.0003804, -0.0013191, -0.1241108, -0.1394890, + -0.0678899, -0.1175171, 0.1327532, 0.9389690, 0.0567225}, + std::vector{3, 3}, std::vector{3, 1})})}, + {18, + SlaterTypeAtom( + 18, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ar + * + * Etot=-526.274534168 Ekin=526.274534125 + */ + SlaterTypeAtomicShell( + 0, + std::vector{46.331015, 25.548587, 22.367307, + 15.534609, 8.247562, 6.654266, 6.002988, + 3.324836, + 2.287129, + 1.445917}, + std::vector{3, 1, 2, 1, 2, 3, 2, 3, 3, 1}, + std::vector{ + -0.0004309, 0.3263347, 0.1744946, 0.5275146, -0.0052807, + -0.0069316, 0.0129751, -0.0000541, -0.0000237, 0.0000293, + 0.0002188, 0.0763964, 0.0585132, -0.5064536, -0.1675905, + -0.5349609, 1.7604617, 0.0029013, 0.0004803, 0.0001777, + -0.0000809, -0.0310652, -0.0235645, 0.1691384, -0.2090023, + -0.2310399, -0.1489902, 0.4387668, 0.4888735, 0.2636181}, + std::vector{1, 1, 1}, std::vector{1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{43.087509, 29.402017, 16.361110, 10.508043, + 8.278760, 6.839373, 4.097471, 2.976452, + 1.665758, 1.445917}, + std::vector{2, 2, 4, 2, 3, 4, 2, 3, 2, 3}, + std::vector{ + -0.0001504, 0.0014071, -0.0001129, 0.4226293, 0.4876776, + 0.1304970, 0.0563709, 0.0002690, 0.0021016, -0.0000024, + 0.0000384, -0.0002968, -0.0018472, -0.1404732, -0.1982277, + -0.1157987, 0.0246171, 0.1924433, 0.8625749, 0.0427211}, + std::vector{3, 3}, std::vector{3, 2})})}, + {19, + SlaterTypeAtom( + 19, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for K + * + * Etot=-599.017579304 Ekin=599.017579802 + */ + SlaterTypeAtomicShell( + 0, + std::vector{48.500215, 27.237366, 23.845026, + 16.459968, 8.677200, 7.307612, 6.587645, + 3.570365, + 2.457086, + 1.530063}, + std::vector{3, 1, 2, 1, 2, 3, 2, 3, 3, 1}, + std::vector{ + 0.0004340, -0.3115065, -0.1697595, -0.5470770, 0.0313619, + 0.0298369, -0.0592319, 0.0001862, -0.0001790, 0.0002412, + 0.0002126, 0.0734156, 0.0558916, -0.5038839, -0.5408956, + -0.7710328, 2.3470171, 0.0038665, 0.0000851, 0.0007546, + -0.0000714, -0.0325158, -0.0246131, 0.1771697, -0.3627896, + -0.3912260, 0.1571758, 0.4708517, 0.4800659, 0.2315453}, + std::vector{1, 1, 1}, std::vector{1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{45.464745, 32.055879, 17.643385, 11.285946, + 8.917247, 7.386591, 4.520369, 3.218533, + 1.789225, 1.530063}, + std::vector{2, 2, 4, 2, 3, 4, 2, 3, 2, 3}, + std::vector{ + -0.0001615, 0.0011888, 0.0005381, 0.4155590, 0.4909839, + 0.1268360, 0.0614818, 0.0002853, 0.0003745, -0.0000547, + 0.0000385, -0.0002331, -0.0020344, -0.1455431, -0.2190036, + -0.1304272, 0.0688736, 0.2169543, 0.8336104, 0.0395011}, + std::vector{3, 3}, std::vector{3, 3})})}, + {20, + SlaterTypeAtom( + 20, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ca + * + * Etot=-676.570012133 Ekin=676.570011413 + */ + SlaterTypeAtomicShell( + 0, + std::vector{46.826729, 26.932592, 24.414308, 20.740056, + 13.257979, 7.629463, 6.414563, 4.199025, + 2.932248, + 2.139810, + 1.063151, + 0.912488}, + std::vector{2, 4, 1, 2, 2, 3, 1, 3, 3, 3, 3, 3}, + std::vector{ + 0.0013507, -0.0146473, 0.7237433, 0.3277337, 0.0053740, + -0.0007797, 0.0034271, 0.0000430, -0.0001103, 0.0000488, + -0.0000239, 0.0000161, -0.0001507, -0.0024068, -0.4466923, + -0.3582898, -0.5918091, 0.1025515, 1.7559194, 0.0104057, + -0.0021200, 0.0011472, -0.0003739, 0.0002265, -0.0000629, + 0.0025099, 0.1515407, 0.1278590, 0.1789414, -0.1922459, + -0.5872343, 0.4276799, 0.6756945, 0.0693289, -0.0012364, + 0.0015668, 0.0000289, -0.0009068, -0.0415726, -0.0357141, + -0.0450552, 0.0669014, 0.1571400, -0.1569863, -0.1788498, + -0.1578010, 0.7445941, 0.3800610}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 0}), + SlaterTypeAtomicShell( + 1, + std::vector{36.709506, 27.615969, 20.512304, 11.829735, + 9.266923, 7.563502, 4.264903, 3.023909, + 1.893422, 0.912488}, + std::vector{3, 3, 4, 2, 3, 4, 2, 3, 2, 3}, + std::vector{ + 0.0005156, -0.0031550, -0.0039888, 0.4447597, 0.5172994, + 0.1166037, 0.0227334, -0.0000313, 0.0000942, -0.0000143, + -0.0001618, 0.0007140, -0.0005556, -0.1741201, -0.2906277, + -0.1787580, 0.2856854, 0.3851140, 0.6061761, 0.0013617}, + std::vector{3, 3}, std::vector{3, 3})})}, + {21, + SlaterTypeAtom( + 21, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Sc + * + * Etot=-759.539143556 Ekin=759.539143095 + */ + SlaterTypeAtomicShell( + 0, + std::vector{49.059902, 28.467031, 25.707095, 21.871156, + 14.040385, 8.185364, 6.790907, 4.525666, + 3.229604, + 2.464173, + 1.144467, + 0.947921}, + std::vector{2, 4, 1, 2, 2, 3, 1, 3, 3, 3, 3, 3}, + std::vector{ + 0.0013744, -0.0141542, 0.7213858, 0.3295350, 0.0057999, + -0.0007828, 0.0032755, 0.0000419, -0.0001187, 0.0000513, + -0.0000155, 0.0000100, -0.0001741, -0.0020292, -0.4525443, + -0.3593745, -0.6049503, 0.0963132, 1.7752813, 0.0109895, + -0.0025258, 0.0013380, -0.0001981, 0.0001471, -0.0000600, + 0.0024021, 0.1558072, 0.1302830, 0.1839606, -0.2004106, + -0.5992239, 0.4130271, 0.6397958, 0.1253641, 0.0001155, + 0.0004046, 0.0000311, -0.0009679, -0.0423202, -0.0362668, + -0.0444049, 0.0714847, 0.1571996, -0.1547434, -0.1612000, + -0.1637958, 0.7368654, 0.3750104}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 0}), + SlaterTypeAtomicShell( + 1, + std::vector{38.544981, 29.363523, 21.948177, 12.643064, + 9.964613, 8.157957, 4.538867, 3.265690, + 2.023922, 0.947921}, + std::vector{3, 3, 4, 2, 3, 4, 2, 3, 2, 3}, + std::vector{ + 0.0004909, -0.0027070, -0.0026896, 0.4335757, 0.5194725, + 0.1222477, 0.0240491, -0.0001993, 0.0002814, -0.0000107, + -0.0001680, 0.0006194, -0.0008905, -0.1752494, -0.2972561, + -0.1824344, 0.3005787, 0.4172178, 0.5652231, 0.0011792}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{18.357069, 13.998989, 6.408209, 5.251401, + 2.999535, 2.286812, 1.324813, 0.947921}, + std::vector{3, 4, 3, 4, 3, 4, 3, 3}, + std::vector{0.0012672, 0.0058217, 0.0797977, 0.0891597, + 0.4127642, 0.2378400, 0.3368157, + 0.0131812}, + std::vector{1}, std::vector{0})})}, + {22, + SlaterTypeAtom( + 22, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ti + * + * Etot=-848.203400164 Ekin=848.203399259 + */ + SlaterTypeAtomicShell( + 0, + std::vector{51.054089, 29.826418, 26.886993, 22.903449, + 14.743954, 8.626215, 7.241417, 5.000569, + 3.610119, + 2.756584, + 1.205403, + 0.975361}, + std::vector{2, 4, 1, 2, 2, 3, 1, 3, 3, 3, 3, 3}, + std::vector{ + 0.0014110, -0.0140914, 0.7236904, 0.3272178, 0.0045472, + -0.0009743, 0.0039199, 0.0001146, -0.0001735, 0.0000670, + -0.0000154, 0.0000097, -0.0001994, -0.0017324, -0.4683748, + -0.3687321, -0.6343711, 0.0972926, 1.8198863, 0.0120534, + -0.0021755, 0.0012404, -0.0000666, 0.0001168, -0.0000514, + 0.0022513, 0.1638083, 0.1355344, 0.1978280, -0.2125113, + -0.6250466, 0.3486921, 0.6278751, 0.2129895, 0.0011519, + -0.0001114, 0.0000297, -0.0009193, -0.0439876, -0.0373086, + -0.0472941, 0.0755472, 0.1620248, -0.1312893, -0.1650577, + -0.1690146, 0.7445441, 0.3553040}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 0}), + SlaterTypeAtomicShell( + 1, + std::vector{40.380457, 31.345684, 23.398255, 13.532375, + 10.724850, 8.792957, 4.604777, 3.480043, + 2.151940, 0.975361}, + std::vector{3, 3, 4, 2, 3, 4, 2, 3, 2, 3}, + std::vector{ + 0.0005183, -0.0022986, -0.0013068, 0.4181733, 0.5233268, + 0.1337181, 0.0237843, -0.0011755, 0.0007040, -0.0000190, + -0.0001725, 0.0005191, -0.0011567, -0.1696369, -0.2896069, + -0.1758470, 0.2981797, 0.4174306, 0.5448154, 0.0010979}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{19.217589, 14.756988, 6.708481, 5.510605, + 3.130957, 2.406248, 1.427287, 0.975361}, + std::vector{3, 4, 3, 4, 3, 4, 3, 3}, + std::vector{0.0014156, 0.0062383, 0.0972491, 0.1069795, + 0.4439239, 0.2311861, 0.2806244, + 0.0051557}, + std::vector{2}, std::vector{0})})}, + {23, + SlaterTypeAtom( + 23, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for V + * + * Etot=-942.670783347 Ekin=942.67078366 + */ + SlaterTypeAtomicShell( + 0, + std::vector{61.913739, 33.257642, 29.218779, 25.396152, + 19.166060, 11.604185, 9.324325, 8.763737, + 5.579454, + 3.914557, + 2.854948, + 1.080967}, + std::vector{2, 4, 1, 2, 2, 3, 1, 3, 3, 3, 3, 2}, + std::vector{ + 0.0005695, -0.0068804, 0.6843775, 0.3303080, 0.0466678, + 0.0015275, -0.0024708, -0.0002154, -0.0000188, -0.0000356, + 0.0000022, -0.0000004, -0.0001650, -0.0001257, -0.3433807, + -0.2134003, -0.2540462, 0.3954915, 0.7753106, 0.2743448, + 0.0092108, 0.0007623, 0.0004552, -0.0000003, 0.0000027, + 0.0011416, 0.1266037, 0.0828371, 0.0915173, -0.1413273, + -0.2984144, -0.2858991, 0.3189353, 0.6438019, 0.2557449, + 0.0007283}, + std::vector{1, 1, 1}, std::vector{1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{41.659118, 33.163417, 25.266125, 14.217441, + 11.307604, 9.281456, 4.869342, 3.729061, + 2.218956, + 1.080967}, + std::vector{3, 3, 4, 2, 3, 4, 2, 3, 2, 3}, + std::vector{ + 0.0005444, -0.0021447, -0.0009795, 0.4196007, 0.5239693, + 0.1298068, 0.0234317, -0.0010367, 0.0009180, -0.0000061, + -0.0002166, 0.0005476, -0.0011096, -0.1723165, -0.2966805, + -0.1777800, 0.3206809, 0.3885839, 0.5646447, 0.0010931}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{ + 20.434420, + 15.682969, 7.045584, 5.769930, 3.201405, 2.409510, + 1.413679, 1.080967}, + std::vector{3, 4, 3, 4, 3, 4, 3, 3}, + std::vector{0.0012879, 0.0057588, 0.1040543, 0.1155919, + 0.4366822, 0.2133536, 0.2736247, + 0.0479134}, + std::vector{4}, std::vector{0})})}, + {24, + SlaterTypeAtom( + 24, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Cr + * + * Etot=-1043.139393011 Ekin=1043.139393255 + */ + SlaterTypeAtomicShell( + 0, + std::vector{63.642624, 34.903178, 30.519477, 26.478029, + 19.488185, 12.033340, 9.989731, 9.138198, + 5.910062, + 4.127722, + 2.997876, + 1.139500}, + std::vector{2, 4, 1, 2, 2, 3, 1, 3, 3, 3, 3, 2}, + std::vector{ + 0.0006238, -0.0069634, 0.6845380, 0.3368015, 0.0432390, + 0.0022752, -0.0059438, -0.0003459, 0.0000153, -0.0000489, + 0.0000064, -0.0000007, -0.0001700, -0.0002247, -0.3660586, + -0.2370729, -0.2957423, 0.4017948, 0.8608776, 0.2579397, + 0.0084314, 0.0011197, 0.0003768, 0.0000051, -0.0000104, + 0.0013557, 0.1339027, 0.0920055, 0.1004640, -0.1571419, + -0.3200947, -0.2812644, 0.3299124, 0.6466228, 0.2503798, + 0.0007242}, + std::vector{1, 1, 1}, std::vector{1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{43.775129, 34.909328, 26.686822, 14.945896, + 11.935429, 9.815862, 5.244912, 3.976645, + 2.344857, + 1.139500}, + std::vector{3, 3, 4, 2, 3, 4, 2, 3, 2, 3}, + std::vector{ + 0.0005164, -0.0019458, -0.0006679, 0.4174336, 0.5234438, + 0.1287976, 0.0253353, -0.0007669, 0.0009423, -0.0000036, + -0.0002040, 0.0004928, -0.0011245, -0.1759278, -0.3061616, + -0.1829794, 0.3313764, 0.3975906, 0.5594122, 0.0011658}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{ + 21.704945, + 16.633117, 7.338995, 6.032009, 3.400197, 2.572565, + 1.509219, 1.139500}, + std::vector{3, 4, 3, 4, 3, 4, 3, 3}, + std::vector{0.0012835, 0.0058799, 0.1186526, 0.1207461, + 0.4425691, 0.2107620, 0.2574073, + 0.0393307}, + std::vector{5}, std::vector{0})})}, + {25, + SlaterTypeAtom( + 25, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Mn + * + * Etot=-1149.649382169 Ekin=1149.649382175 + */ + SlaterTypeAtomicShell( + 0, + std::vector{55.426379, 33.872469, 30.579180, 26.040186, + 16.959344, 10.591531, 8.185599, 5.496562, + 3.876864, + 2.817217, + 1.840470, + 1.043421}, + std::vector{2, 4, 1, 2, 2, 3, 1, 3, 3, 3, 3, 2}, + std::vector{ + 0.0018335, -0.0146756, 0.7238474, 0.3279908, -0.0002503, + -0.0024215, 0.0079989, 0.0000186, -0.0001188, 0.0000718, + -0.0000285, 0.0000098, -0.0004037, -0.0000230, -0.4795200, + -0.3728588, -0.6488545, 0.0444345, 1.8836813, 0.0086000, + -0.0014916, 0.0009599, -0.0003117, 0.0004775, -0.0000380, + 0.0019222, 0.1643789, 0.1360824, 0.1792920, -0.2122333, + -0.6070855, 0.5146860, 0.6005767, 0.0691700, -0.0018892, + 0.0028266, 0.0000195, -0.0005682, -0.0427564, -0.0357546, + -0.0437066, 0.0634878, 0.1520821, -0.2050341, -0.2179228, + -0.2460118, -0.1991513, 1.4028190}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 0}), + SlaterTypeAtomicShell( + 1, + std::vector{45.160487, 36.425345, 17.513833, 15.333053, + 12.171423, 9.925570, 4.884277, 3.881362, + 2.443865, 1.043421}, + std::vector{3, 3, 4, 2, 3, 4, 2, 3, 2, 3}, + std::vector{ + 0.0004671, -0.0015859, 0.0069050, 0.4403519, 0.5234102, + 0.1084696, 0.0121603, -0.0004651, 0.0006119, -0.0000042, + -0.0002825, 0.0009352, 0.0069608, -0.1885147, -0.3353237, + -0.1646224, 0.4647168, 0.4223264, 0.4095522, 0.0007356}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{22.909411, 17.574256, 7.648261, 6.276301, + 3.533695, 2.682042, 1.626089, 1.043421}, + std::vector{3, 4, 3, 4, 3, 4, 3, 3}, + std::vector{0.0013545, 0.0062423, 0.1420855, 0.1402108, + 0.4865370, 0.2127448, 0.1846033, + 0.0009371}, + std::vector{5}, std::vector{0})})}, + {26, + SlaterTypeAtom( + 26, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Fe + * + * Etot=-1262.213011144 Ekin=1262.213009361 + */ + SlaterTypeAtomicShell( + 0, + std::vector{58.921604, 35.749977, 32.011180, 27.362330, + 17.822536, 10.925436, 8.619044, 5.934390, + 4.217590, + 3.109311, + 2.048759, + 1.058581}, + std::vector{2, 4, 1, 2, 2, 3, 1, 3, 3, 3, 3, 2}, + std::vector{ + 0.0016020, -0.0130682, 0.7177788, 0.3321052, 0.0047755, + -0.0011592, 0.0040129, 0.0000309, -0.0001166, 0.0000647, + -0.0000212, 0.0000056, -0.0002968, -0.0007217, -0.4819340, + -0.3695623, -0.6659565, 0.0516262, 1.8901577, 0.0096256, + -0.0015131, 0.0010640, -0.0002515, 0.0003372, -0.0000321, + 0.0017648, 0.1713246, 0.1382057, 0.2065023, -0.2102670, + -0.6492464, 0.4600864, 0.6195035, 0.1150377, -0.0018243, + 0.0023805, 0.0000187, -0.0005706, -0.0430477, -0.0352188, + -0.0483298, 0.0631520, 0.1570241, -0.1761478, -0.2063082, + -0.2131432, -0.1884242, 1.3333228}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 0}), + SlaterTypeAtomicShell( + 1, + std::vector{47.283708, 38.579601, 18.556459, 15.945298, + 12.683425, 10.333394, 5.047108, 4.022037, + 2.539719, 1.058581}, + std::vector{3, 3, 4, 2, 3, 4, 2, 3, 2, 3}, + std::vector{ + 0.0004594, -0.0014223, 0.0073434, 0.4456285, 0.5227408, + 0.1026310, 0.0111735, -0.0004553, 0.0006780, -0.0000039, + -0.0002966, 0.0009123, 0.0065632, -0.1939462, -0.3438206, + -0.1641472, 0.5093886, 0.4238623, 0.3741202, 0.0007074}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{24.151149, 18.502081, 7.967724, 6.538034, + 3.668271, 2.790752, 1.708843, 1.058581}, + std::vector{3, 4, 3, 4, 3, 4, 3, 3}, + std::vector{0.0013116, 0.0061287, 0.1549814, 0.1480021, + 0.4812957, 0.1926513, 0.1913089, + 0.0037473}, + std::vector{5}, std::vector{1})})}, + {27, + SlaterTypeAtom( + 27, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Co + * + * Etot=-1381.128748962 Ekin=1381.128748178 + */ + SlaterTypeAtomicShell( + 0, + std::vector{67.496474, 39.155732, 34.186190, 29.520403, + 21.144832, 13.631425, 11.183718, + 10.403162, 6.817563, 4.747008, 3.434196, + 1.212142}, + std::vector{2, 4, 1, 2, 2, 3, 1, 3, 3, 3, 3, 2}, + std::vector{ + 0.0009036, -0.0083420, 0.6899407, 0.3436444, 0.0288215, + 0.0012758, -0.0038379, -0.0000602, -0.0000705, -0.0000050, + -0.0000058, 0.0000003, -0.0002453, 0.0001878, -0.3989003, + -0.2727763, -0.3529380, 0.3721613, 1.0090924, 0.2361916, + 0.0084847, 0.0011514, 0.0003798, 0.0000067, -0.0000038, + 0.0011829, 0.1451680, 0.1053719, 0.1126571, -0.1713230, + -0.3605983, -0.2735667, 0.3589734, 0.6478970, 0.2326551, + 0.0009348}, + std::vector{1, 1, 1}, std::vector{1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{49.592869, 39.477482, 19.512676, 16.673142, + 13.333803, 10.878716, 5.415827, 4.289946, + 2.615652, 1.212142}, + std::vector{3, 3, 4, 2, 3, 4, 2, 3, 2, 3}, + std::vector{ + 0.0003689, -0.0013412, 0.0053602, 0.4426844, 0.5234879, + 0.1047917, 0.0124798, -0.0003313, 0.0008585, 0.0000097, + -0.0002460, 0.0008744, 0.0068328, -0.1943389, -0.3462100, + -0.1684569, 0.4961583, 0.4076930, 0.4125209, 0.0008242}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{25.360930, 19.431865, 8.292261, 6.786806, + 3.803809, 2.832696, 1.640045, 1.212142}, + std::vector{3, 4, 3, 4, 3, 4, 3, 3}, + std::vector{0.0012034, 0.0056485, 0.1582785, 0.1458263, + 0.4556616, 0.1997187, 0.2139434, + 0.0289090}, + std::vector{5}, std::vector{3})})}, + {28, + SlaterTypeAtom( + 28, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ni + * + * Etot=-1506.591098366 Ekin=1506.591100054 + */ + SlaterTypeAtomicShell( + 0, + std::vector{70.729443, 40.874837, 35.511860, 30.743355, + 21.856456, 14.088234, 11.708916, + 10.777461, 7.085723, 4.926433, 3.540263, + 1.240388}, + std::vector{2, 4, 1, 2, 2, 3, 1, 3, 3, 3, 3, 2}, + std::vector{ + 0.0008182, -0.0075894, 0.6894529, 0.3431853, 0.0333722, + 0.0024364, -0.0082845, -0.0002786, -0.0000068, -0.0000304, + 0.0000019, -0.0000002, -0.0002173, 0.0000112, -0.4132680, + -0.2798549, -0.3904624, 0.3717334, 1.0701416, 0.2251446, + 0.0079933, 0.0012267, 0.0003455, 0.0000072, -0.0000318, + 0.0015597, 0.1471125, 0.1070675, 0.1144908, -0.1901565, + -0.3632219, -0.2590979, 0.3690958, 0.6549290, 0.2164717, + 0.0006191}, + std::vector{1, 1, 1}, std::vector{1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{51.337479, 40.743217, 20.807337, 17.513613, + 14.089201, 11.498336, 5.414607, 4.404412, + 2.712694, 1.240388}, + std::vector{3, 3, 4, 2, 3, 4, 2, 3, 2, 3}, + std::vector{ + 0.0003800, -0.0013907, 0.0020599, 0.4329772, 0.5281689, + 0.1136502, 0.0131123, -0.0011108, 0.0011030, 0.0000026, + -0.0002636, 0.0009608, 0.0076670, -0.1898102, -0.3392048, + -0.1642985, 0.5236154, 0.3871782, 0.3866437, 0.0008289}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{26.544851, 20.330270, 8.617473, 7.032645, + 3.934168, 2.920576, 1.683692, 1.240388}, + std::vector{3, 4, 3, 4, 3, 4, 3, 3}, + std::vector{0.0011811, 0.0055770, 0.1698116, 0.1531816, + 0.4568968, 0.1967519, 0.2027129, + 0.0253192}, + std::vector{5}, std::vector{4})})}, + {29, + SlaterTypeAtom( + 29, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Cu + * + * Etot=-1638.728241711 Ekin=1638.728242564 + */ + SlaterTypeAtomicShell( + 0, + std::vector{72.576390, 42.161112, 36.610202, 31.708712, + 22.469954, 14.638358, 12.456345, + 11.237667, 7.315857, 5.096873, 3.664368, + 1.272903}, + std::vector{2, 4, 1, 2, 2, 3, 1, 3, 3, 3, 3, 2}, + std::vector{ + 0.0008468, -0.0077985, 0.6943284, 0.3405675, 0.0288044, + 0.0017302, -0.0064270, -0.0001853, -0.0000383, -0.0000152, + -0.0000018, 0.0000001, -0.0002316, 0.0001291, -0.4364068, + -0.2952454, -0.4217387, 0.3763935, 1.1248907, 0.2298157, + 0.0081142, 0.0011001, 0.0003541, 0.0000065, -0.0000355, + 0.0015642, 0.1537632, 0.1119098, 0.1199788, -0.2000861, + -0.3734866, -0.2541269, 0.3839052, 0.6477049, 0.2069560, + 0.0006164}, + std::vector{1, 1, 1}, std::vector{1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{54.142279, 42.542133, 21.883549, 18.160695, + 14.647103, 11.953711, 5.504517, 4.493556, + 2.786438, 1.272903}, + std::vector{3, 3, 4, 2, 3, 4, 2, 3, 2, 3}, + std::vector{ + 0.0003173, -0.0012173, 0.0024285, 0.4356965, 0.5270238, + 0.1113997, 0.0125458, -0.0013115, 0.0011886, -0.0000017, + -0.0002452, 0.0009251, 0.0074957, -0.1924747, -0.3419074, + -0.1616307, 0.5693056, 0.3815658, 0.3477180, 0.0007246}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{27.700444, 21.210460, 8.945777, 7.285798, + 4.067033, 3.010777, 1.741365, 1.272903}, + std::vector{3, 4, 3, 4, 3, 4, 3, 3}, + std::vector{0.0011645, 0.0055366, 0.1802289, 0.1591255, + 0.4583858, 0.1917747, 0.1924941, + 0.0237763}, + std::vector{5}, std::vector{5})})}, + {30, + SlaterTypeAtom( + 30, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Zn + * + * Etot=-1777.567542549 Ekin=1777.567544767 + */ + SlaterTypeAtomicShell( + 0, + std::vector{56.124784, 48.111394, 34.485953, 33.388168, + 23.342782, 19.224010, + 12.474380, 5.031119, 3.977448, 1.663491, + 1.107245, + 1.106078}, + std::vector{2, 3, 3, 1, 3, 4, 3, 4, 2, 3, 4, 3}, + std::vector{ + 0.0401607, 0.0535646, 0.1053009, 0.8376894, 0.0075995, + -0.0004764, 0.0002294, 0.0000747, -0.0001551, -0.0000087, + -0.0000072, 0.0000133, -0.0124351, -0.0154241, -0.0371941, + -0.2586573, 0.3422737, 0.3342921, 0.4271521, -0.0064731, + 0.0153186, 0.0002046, 0.0001739, -0.0003214, 0.0027616, + 0.0031872, 0.0091482, 0.0975879, -0.1653311, -0.1370100, + -0.4714750, -0.2009711, 1.4344400, 0.0019475, 0.0004520, + -0.0009017, -0.0005329, -0.0006583, -0.0016591, -0.0225353, + 0.0393528, 0.0321109, 0.1235116, 0.0386465, -0.4044626, + 0.5663940, -0.1282232, 0.6238430}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 0}), + SlaterTypeAtomicShell( + 1, + std::vector{56.718520, 44.589775, 23.080841, 18.783225, + 15.170932, 12.348433, 5.638567, 4.583586, + 2.907812, 1.106078}, + std::vector{3, 3, 4, 2, 3, 4, 2, 3, 2, 3}, + std::vector{ + 0.0003053, -0.0011084, 0.0025926, 0.4395912, 0.5272539, + 0.1073302, 0.0110555, -0.0009628, 0.0009560, -0.0000058, + -0.0002517, 0.0009351, 0.0075534, -0.1973864, -0.3500021, + -0.1608848, 0.6182304, 0.4012290, 0.2856661, 0.0005108}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{28.846191, 22.109077, 9.273020, 7.528954, + 4.190940, 3.116856, 1.852033, 1.106078}, + std::vector{3, 4, 3, 4, 3, 4, 3, 3}, + std::vector{0.0011930, 0.0056798, 0.1987342, 0.1730295, + 0.4799928, 0.1915054, 0.1394555, + 0.0005976}, + std::vector{5}, std::vector{5})})}, + {31, + SlaterTypeAtom( + 31, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ga + * + * Etot=-1923.059720564 Ekin=1923.059717924 + */ + SlaterTypeAtomicShell( + 0, + std::vector{58.129217, 49.800588, 35.678566, 34.165363, + 25.196439, 15.433431, + 13.795817, 7.160881, 5.016460, 3.508628, + 1.226425, + 1.173091}, + std::vector{2, 3, 3, 1, 3, 4, 3, 3, 3, 3, 2, 3}, + std::vector{ + 0.0361110, 0.0483131, 0.0974941, 0.8504654, 0.0088048, + 0.0007574, -0.0009580, -0.0000809, 0.0000167, -0.0000091, + 0.0000026, -0.0000013, -0.0111878, -0.0141601, -0.0328174, + -0.2635809, 0.1509324, -0.6084540, 1.4978661, 0.0117727, + -0.0014358, 0.0006739, -0.0001311, 0.0000649, 0.0042686, + 0.0052733, 0.0137263, 0.1005355, -0.0673400, 0.2053214, + -0.7155045, 0.5315133, 0.6138889, 0.0490963, -0.0013110, + 0.0005851, -0.0011289, -0.0014544, -0.0034416, -0.0249656, + 0.0158204, -0.0496686, 0.1795366, -0.1798279, -0.2078280, + -0.1981349, 1.1426637, 0.0353537}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{58.092383, 45.925977, 24.082133, 19.494780, + 15.815270, 12.915989, 5.949298, 4.802193, + 3.013120, 1.173091}, + std::vector{3, 3, 4, 2, 3, 4, 2, 3, 2, 3}, + std::vector{ + 0.0003180, -0.0011125, 0.0018940, 0.4380129, 0.5255413, + 0.1095861, 0.0125567, -0.0011714, 0.0009135, -0.0000166, + -0.0002384, 0.0009019, 0.0070895, -0.2002867, -0.3531502, + -0.1649863, 0.6228785, 0.4563620, 0.2332295, 0.0004673}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{30.050487, 23.020612, 9.585062, 7.768024, + 4.351325, 3.272083, 2.044860, 1.173091}, + std::vector{3, 4, 3, 4, 3, 4, 3, 3}, + std::vector{0.0012110, 0.0058046, 0.2166264, 0.1810669, + 0.4945447, 0.1750008, 0.0978471, + 0.0003371}, + std::vector{5}, std::vector{5})})}, + {32, + SlaterTypeAtom( + 32, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ge + * + * Etot=-2075.086490667 Ekin=2075.086490249 + */ + SlaterTypeAtomicShell( + 0, + std::vector{60.410419, 51.716755, 36.938642, 35.115585, + 26.208278, 16.069421, + 14.353675, 7.503796, 5.367691, 3.949425, + 1.367639, + 1.062566}, + std::vector{2, 3, 3, 1, 3, 4, 3, 3, 3, 3, 2, 3}, + std::vector{ + 0.0338728, 0.0455735, 0.0946232, 0.8563626, 0.0094009, + 0.0010277, -0.0013253, -0.0000882, 0.0000251, -0.0000122, + 0.0000020, -0.0000007, -0.0105318, -0.0133716, -0.0323635, + -0.2663158, 0.1448229, -0.6057028, 1.5006896, 0.0129623, + -0.0020415, 0.0008293, -0.0000819, 0.0000257, 0.0040614, + 0.0050184, 0.0137474, 0.1026459, -0.0655693, 0.2054160, + -0.7238517, 0.4950984, 0.6280730, 0.0704931, -0.0001046, + 0.0000935, -0.0011861, -0.0015145, -0.0038561, -0.0277350, + 0.0168392, -0.0530246, 0.1965087, -0.1915558, -0.2022455, + -0.2592230, 1.1974781, 0.0105930}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{48.105192, 39.206452, 23.258904, 18.357385, + 13.225281, 6.763236, 5.752439, 4.709079, + 2.903905, 1.082624, 1.062566}, + std::vector{2, 3, 2, 3, 3, 2, 3, 4, 3, 3, 2}, + std::vector{ + -0.0071455, -0.0159527, 0.3504787, 0.4317270, 0.3045145, + 0.0253140, -0.0031426, 0.0011554, -0.0002723, -0.0000506, + 0.0000895, 0.0044105, 0.0096813, -0.1646899, -0.1920360, + -0.2930492, 0.4248728, 0.6474510, 0.1938902, 0.0226990, + -0.0000404, 0.0005565, -0.0010881, -0.0023969, 0.0383415, + 0.0433376, 0.0749122, -0.1285215, -0.1896157, -0.0992463, + -0.1374114, -0.0608055, 1.2118664}, + std::vector{3, 3, 1}, std::vector{3, 3, 0}), + SlaterTypeAtomicShell( + 2, + std::vector{31.101705, 23.869970, 9.908675, 8.007041, + 4.489476, 3.394937, 2.150520, 1.062566}, + std::vector{3, 4, 3, 4, 3, 4, 3, 3}, + std::vector{0.0012432, 0.0059034, 0.2335686, 0.1913422, + 0.5112354, 0.1607867, 0.0537465, + 0.0000082}, + std::vector{5}, std::vector{5})})}, + {33, + SlaterTypeAtom( + 33, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for As + * + * Etot=-2233.888333415 Ekin=2233.888335161 + */ + SlaterTypeAtomicShell( + 0, + std::vector{62.722113, 53.655034, 38.205753, 36.073902, + 27.199543, 16.710509, + 14.917489, 7.870504, 5.770042, 4.382332, + 1.510080, + 1.160525}, + std::vector{2, 3, 3, 1, 3, 4, 3, 3, 3, 3, 2, 3}, + std::vector{ + 0.0318769, 0.0431382, 0.0919660, 0.8616716, 0.0099717, + 0.0013077, -0.0017082, -0.0000966, 0.0000352, -0.0000165, + 0.0000025, -0.0000007, -0.0099435, -0.0126878, -0.0317799, + -0.2688267, 0.1393847, -0.6002070, 1.4998868, 0.0145794, + -0.0029312, 0.0010880, -0.0000968, 0.0000267, 0.0038758, + 0.0048014, 0.0137016, 0.1047067, -0.0640536, 0.2042364, + -0.7305630, 0.4465399, 0.6404036, 0.1061444, 0.0005392, + -0.0000095, -0.0012238, -0.0015489, -0.0042192, -0.0301507, + 0.0176691, -0.0549256, 0.2101857, -0.1958674, -0.1834757, + -0.3277488, 1.2201109, 0.0142554}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{50.112148, 40.770702, 24.029652, 19.126299, + 13.878221, 7.349770, 6.171504, 5.149749, + 3.373262, 1.219263, 1.160525}, + std::vector{2, 3, 2, 3, 3, 2, 3, 4, 3, 3, 2}, + std::vector{ + -0.0062944, -0.0142165, 0.3461308, 0.4181209, 0.3116139, + 0.0336384, -0.0046123, 0.0018872, -0.0006076, -0.0001012, + 0.0001653, 0.0041245, 0.0091847, -0.1654166, -0.1857325, + -0.2975515, 0.3726489, 0.6721012, 0.1998072, 0.0413126, + 0.0002096, 0.0003082, -0.0011339, -0.0025319, 0.0425792, + 0.0461048, 0.0845920, -0.1294308, -0.2124741, -0.0962099, + -0.1760212, -0.1942612, 1.3575238}, + std::vector{3, 3, 2}, std::vector{3, 3, 0}), + SlaterTypeAtomicShell( + 2, + std::vector{32.338729, 24.790487, 10.232415, 8.255651, + 4.658280, 3.508330, 2.126255, 1.160525}, + std::vector{3, 4, 3, 4, 3, 4, 3, 3}, + std::vector{0.0012433, 0.0059792, 0.2488856, 0.1965482, + 0.5260243, 0.1448670, 0.0226817, + -0.0001195}, + std::vector{5}, std::vector{5})})}, + {34, + SlaterTypeAtom( + 34, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Se + * + * Etot=-2399.558572799 Ekin=2399.558572004 + */ + SlaterTypeAtomicShell( + 0, + std::vector{65.377692, 55.847293, 39.559848, 37.014548, + 28.120190, 17.319873, + 15.459741, 8.280939, 6.220585, 4.790636, + 1.645411, + 1.254113}, + std::vector{2, 3, 3, 1, 3, 4, 3, 3, 3, 3, 2, 3}, + std::vector{ + 0.0294886, 0.0403444, 0.0894335, 0.8673363, 0.0109127, + 0.0019235, -0.0025526, -0.0001148, 0.0000556, -0.0000245, + 0.0000036, -0.0000010, -0.0092274, -0.0119081, -0.0309538, + -0.2714113, 0.1359108, -0.5958107, 1.4979871, 0.0157863, + -0.0033847, 0.0011473, -0.0001014, 0.0000239, 0.0036336, + 0.0045574, 0.0134410, 0.1068069, -0.0630390, 0.2046381, + -0.7385055, 0.3832245, 0.6571684, 0.1528048, 0.0012177, + -0.0001026, -0.0012246, -0.0015533, -0.0044756, -0.0323426, + 0.0184134, -0.0566440, 0.2224561, -0.1915327, -0.1642356, + -0.3969999, 1.2400194, 0.0165309}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{51.128102, 41.788098, 24.775858, 19.694914, + 14.273209, 7.647620, 6.289116, 5.258312, + 3.668718, 1.334716, 1.254113}, + std::vector{2, 3, 2, 3, 3, 2, 3, 4, 3, 3, 2}, + std::vector{ + -0.0066788, -0.0146156, 0.3490263, 0.4255058, 0.3045709, + 0.0296043, -0.0030929, 0.0015606, -0.0006254, -0.0000733, + 0.0001187, 0.0043265, 0.0093117, -0.1699996, -0.1959305, + -0.3048252, 0.3968056, 0.7050527, 0.1563336, 0.0361537, + -0.0007234, 0.0015739, -0.0012880, -0.0027829, 0.0472054, + 0.0524476, 0.0943158, -0.1508313, -0.2437728, -0.1027898, + -0.1741987, -0.3120666, 1.4884451}, + std::vector{3, 3, 3}, std::vector{3, 3, 0}), + SlaterTypeAtomicShell( + 2, + std::vector{33.211161, 25.555288, 10.535250, 8.471194, + 4.847360, 3.668504, 2.235460, 1.254113}, + std::vector{3, 4, 3, 4, 3, 4, 3, 3}, + std::vector{0.0012980, 0.0060971, 0.2649436, 0.2015003, + 0.5280554, 0.1202120, 0.0137631, + 0.0001282}, + std::vector{5}, std::vector{5})})}, + {35, + SlaterTypeAtom( + 35, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Br + * + * Etot=-2572.045209144 Ekin=2572.045208992 + */ + SlaterTypeAtomicShell( + 0, + std::vector{67.294844, 57.492762, 40.727731, 37.992484, + 29.205536, 17.993320, + 16.047646, 8.689741, 6.726462, 5.212538, + 1.777871, + 1.294513}, + std::vector{2, 3, 3, 1, 3, 4, 3, 3, 3, 3, 2, 3}, + std::vector{ + 0.0284514, 0.0388811, 0.0865955, 0.8714492, 0.0109695, + 0.0017623, -0.0023266, -0.0001175, 0.0000556, -0.0000222, + 0.0000033, -0.0000008, -0.0089293, -0.0114683, -0.0306397, + -0.2734770, 0.1295447, -0.5897437, 1.4975680, 0.0181583, + -0.0045596, 0.0013261, -0.0001139, 0.0000221, 0.0035506, + 0.0044332, 0.0134741, 0.1086981, -0.0608860, 0.2036528, + -0.7445358, 0.3091277, 0.6642492, 0.2179823, 0.0019710, + -0.0001773, -0.0012681, -0.0015722, -0.0048615, -0.0343696, + 0.0189184, -0.0567483, 0.2325419, -0.1866279, -0.1282985, + -0.4781425, 1.2594980, 0.0167008}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{53.152376, 43.442647, 25.742380, 20.365726, + 14.707322, 8.473316, 6.551399, 5.251324, + 2.261388, 1.369469, 1.294513}, + std::vector{2, 3, 2, 3, 3, 2, 3, 4, 3, 3, 2}, + std::vector{ + -0.0070112, -0.0152546, 0.3456798, 0.4334995, 0.3002518, + 0.0276910, 0.0001093, 0.0002758, -0.0001007, -0.0000646, + 0.0001281, -0.0045240, -0.0097033, 0.1732765, 0.2079504, + 0.3194869, -0.3779156, -0.7849565, -0.1536839, -0.0081695, + -0.0037504, 0.0077846, -0.0013741, -0.0029436, 0.0505046, + 0.0594017, 0.1032941, -0.1447437, -0.3070457, -0.1866541, + 0.1181508, -0.2553266, 1.2729773}, + std::vector{3, 3, 3}, std::vector{3, 3, 1}), + SlaterTypeAtomicShell( + 2, + std::vector{34.378207, 26.422317, 10.855664, 8.697743, + 5.068949, 3.854851, 2.230536, 1.294513}, + std::vector{3, 4, 3, 4, 3, 4, 3, 3}, + std::vector{0.0013031, 0.0061606, 0.2787546, 0.2050742, + 0.5248900, 0.1031747, 0.0083185, + -0.0000042}, + std::vector{5}, std::vector{5})})}, + {36, + SlaterTypeAtom( + 36, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Kr + * + * Etot=-2751.567391694 Ekin=2751.56739206 + */ + SlaterTypeAtomicShell( + 0, + std::vector{69.201790, 59.177858, 41.936246, 39.115180, + 29.930317, 18.521771, + 16.538482, 9.323638, 7.278250, 5.584657, + 1.906199, + 1.353182}, + std::vector{2, 3, 3, 1, 3, 4, 3, 3, 3, 3, 2, 3}, + std::vector{ + 0.0288245, 0.0391139, 0.0872321, 0.8705062, 0.0109084, + 0.0019955, -0.0026601, -0.0001261, 0.0000555, -0.0000208, + 0.0000037, -0.0000008, -0.0090699, -0.0116240, -0.0304409, + -0.2739195, 0.1315698, -0.5852963, 1.4900622, 0.0177891, + -0.0029199, 0.0008129, -0.0001035, 0.0000145, 0.0036366, + 0.0045913, 0.0132078, 0.1099202, -0.0614511, 0.2068288, + -0.7539215, 0.2018861, 0.7137320, 0.2770243, 0.0027137, + -0.0002431, -0.0013574, -0.0016709, -0.0051250, -0.0360170, + 0.0201325, -0.0574341, 0.2429318, -0.1576341, -0.1358824, + -0.5364476, 1.2764697, 0.0170976}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{55.043824, 45.044477, 26.630231, 21.305871, + 15.531247, 9.261751, 7.023782, 5.660143, + 2.584145, 1.442330, 1.353182}, + std::vector{2, 3, 2, 3, 3, 2, 3, 4, 3, 3, 2}, + std::vector{ + -0.0061112, -0.0131859, 0.3362880, 0.4090954, 0.3153418, + 0.0428210, -0.0006273, 0.0005201, -0.0002398, -0.0001652, + 0.0002999, -0.0041445, -0.0088261, 0.1697586, 0.1932593, + 0.3168204, -0.3045881, -0.8146714, -0.1769232, -0.0081013, + -0.0024515, 0.0040180, -0.0013491, -0.0028718, 0.0522544, + 0.0577485, 0.1086826, -0.1287952, -0.3301925, -0.2055060, + 0.1274863, -0.3305165, 1.3442564}, + std::vector{3, 3, 3}, std::vector{3, 3, 2}), + SlaterTypeAtomicShell( + 2, + std::vector{35.500187, 27.356628, 11.193561, 8.909671, + 5.278971, 4.049296, 2.357725, 1.353182}, + std::vector{3, 4, 3, 4, 3, 4, 3, 3}, + std::vector{0.0012946, 0.0060604, 0.2919499, 0.2144848, + 0.5141567, 0.0858503, 0.0070913, + -0.0000048}, + std::vector{5}, std::vector{5})})}, + {37, + SlaterTypeAtom( + 37, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Rb + * + * Etot=-2938.219928092 Ekin=2938.219927777 + */ + SlaterTypeAtomicShell( + 0, + std::vector{71.149733, 60.975180, 43.257856, 40.353213, + 30.610069, 18.978653, 16.972323, + 10.189589, 7.792649, 5.929193, 2.031862, + 1.420277}, + std::vector{2, 3, 3, 1, 3, 4, 3, 3, 3, 3, 2, 3}, + std::vector{ + 0.0301744, 0.0402781, 0.0902435, 0.8658911, 0.0112408, + 0.0025044, -0.0033597, -0.0001479, 0.0000603, -0.0000231, + 0.0000045, -0.0000009, -0.0095204, -0.0120499, -0.0310742, + -0.2731646, 0.1354983, -0.5904514, 1.4904807, 0.0146678, + 0.0009157, -0.0000229, -0.0000823, 0.0000044, 0.0038461, + 0.0048780, 0.0131497, 0.1106211, -0.0622954, 0.2167486, + -0.7704531, 0.1105842, 0.7610245, 0.3237940, 0.0035388, + -0.0003242, -0.0014846, -0.0018046, -0.0054340, -0.0373520, + 0.0213980, -0.0594532, 0.2552836, -0.1218866, -0.1623305, + -0.5805648, 1.2916377, 0.0177554}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{57.378975, 46.928310, 27.753521, 22.214347, + 16.267955, 10.403879, 7.474201, 6.039786, + 2.800968, 1.521567, 1.420277}, + std::vector{2, 3, 2, 3, 3, 2, 3, 4, 3, 3, 2}, + std::vector{ + -0.0060980, -0.0131145, 0.3250767, 0.3966035, 0.3160838, + 0.0632801, 0.0005540, 0.0003314, -0.0001090, -0.0000731, + 0.0001360, -0.0043035, -0.0091957, 0.1693817, 0.1902806, + 0.3251698, -0.2601739, -0.8435361, -0.1954845, -0.0098797, + -0.0039405, 0.0075979, -0.0014526, -0.0030941, 0.0544761, + 0.0595039, 0.1170630, -0.1192316, -0.3528318, -0.2200506, + 0.1508235, -0.3779373, 1.3744354}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{36.707772, 28.320179, 11.601158, 9.232610, + 5.523683, 4.174027, 2.116605, 1.420277}, + std::vector{3, 4, 3, 4, 3, 4, 3, 3}, + std::vector{0.0012620, 0.0058734, 0.2972293, 0.2175363, + 0.5157255, 0.0744064, 0.0030585, + -0.0001323}, + std::vector{5}, std::vector{5})})}, + {38, + SlaterTypeAtom( + 38, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Sr + * + * Etot=-3131.373774334 Ekin=3131.373773565 + */ + SlaterTypeAtomicShell( + 0, + std::vector{55.832561, 47.667376, 39.546125, 27.408289, + 19.326156, 16.505756, + 10.753302, 7.969094, 5.847222, 2.227859, + 2.221386, + 1.397258, + 0.872953, + 0.870502}, + std::vector{2, 3, 1, 4, 4, 2, 2, 3, 3, 4, 2, 3, 2, 3}, + std::vector{ + -0.0227814, -0.0376329, -0.9292809, 0.0344681, 0.0204385, + -0.0747146, -0.0003537, 0.0000066, 0.0000602, 0.0000463, + -0.0000540, -0.0001193, 0.0001410, -0.0000467, -0.0465249, + -0.0678614, -0.2938839, 0.1360559, 0.1105562, 0.7693705, + 0.0992302, -0.0042587, 0.0020136, 0.0004976, -0.0007326, + -0.0010397, 0.0011764, -0.0003833, -0.0229133, -0.0336902, + -0.1200758, 0.0798547, 0.1844267, 0.4486027, -0.1112054, + -0.9110756, -0.2219798, -0.0019591, 0.0002874, 0.0041917, + -0.0046894, 0.0015364, -0.0085312, -0.0126028, -0.0426714, + 0.0303344, 0.0850966, 0.1843671, -0.1152506, -0.3672756, + -0.5449302, -0.0201191, 1.3925711, 0.0276140, -0.0225586, + 0.0078800, 0.0026139, 0.0038666, 0.0129467, -0.0093209, + -0.0272066, -0.0582265, 0.0433539, 0.1109758, 0.2139755, + -0.1659523, -0.7394497, -0.6255936, 1.5277797, 0.3609472}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 0}), + SlaterTypeAtomicShell( + 1, + std::vector{62.275951, 49.890204, 28.352566, 22.968318, + 16.945207, 12.578046, 7.939440, 5.763893, + 2.759686, 1.753375, 0.870502}, + std::vector{2, 3, 2, 3, 3, 3, 3, 3, 3, 2, 2}, + std::vector{ + -0.0041086, -0.0100489, 0.3278177, 0.3928178, 0.3361405, + 0.0431626, 0.0018287, 0.0001582, -0.0000027, -0.0000069, + 0.0000017, 0.0025912, 0.0063353, -0.1427271, -0.1495711, + -0.2591225, 0.1256248, 0.7116426, 0.3392404, 0.0052204, + -0.0020713, 0.0001151, -0.0009746, -0.0024031, 0.0460990, + 0.0427462, 0.0989934, -0.0752467, -0.2281066, -0.3666722, + 0.2910393, 0.8969169, 0.0063026}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{37.420815, 28.965002, 11.860054, 9.326124, + 5.605752, 4.182849, 1.987580, 0.870502}, + std::vector{3, 4, 3, 4, 3, 4, 3, 3}, + std::vector{0.0013332, 0.0060384, 0.3194722, 0.2456156, + 0.4865553, 0.0502173, 0.0004941, + 0.0000263}, + std::vector{5}, std::vector{5})})}, + {39, + SlaterTypeAtom( + 39, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Y + * + * Etot=-3331.472879932 Ekin=3331.472882755 + */ + SlaterTypeAtomicShell( + 0, + std::vector{56.850413, 48.677772, 40.477134, 28.229729, + 20.177540, 17.391445, + 11.900211, 8.437033, 6.331381, 2.484842, + 1.991798, + 1.509806, + 0.942943, + 0.933328}, + std::vector{2, 3, 1, 4, 4, 2, 2, 3, 3, 4, 2, 3, 2, 3}, + std::vector{ + -0.0214884, -0.0352149, -0.9333391, 0.0311292, 0.0165528, + -0.0680055, 0.0005046, -0.0002484, 0.0001904, 0.0001119, + -0.0001277, -0.0001698, 0.0002001, -0.0000646, -0.0477543, + -0.0680503, -0.2958660, 0.1358306, 0.1239226, 0.7123916, + 0.1465357, -0.0028644, 0.0017995, 0.0006201, -0.0008343, + -0.0007143, 0.0008217, -0.0002622, -0.0236554, -0.0340262, + -0.1219242, 0.0778374, 0.1783849, 0.4007809, -0.0176739, + -0.8804742, -0.2863184, 0.0010634, -0.0038571, 0.0006576, + -0.0007022, 0.0002222, -0.0093144, -0.0135219, -0.0453106, + 0.0308867, 0.0905461, 0.1833170, -0.0893701, -0.3342446, + -0.5835241, -0.4790062, 1.7897552, -0.0569498, 0.0252259, + -0.0060161, 0.0030329, 0.0043603, 0.0147250, -0.0104084, + -0.0296629, -0.0600751, 0.0326458, 0.1099516, 0.2325300, + 0.0354291, -1.0313357, -0.3966628, 1.5611187, 0.2140588}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{63.029145, 50.693725, 28.596183, 23.345978, + 17.498579, 13.559960, 8.327672, 6.071610, + 2.892623, 1.902480, 0.933328}, + std::vector{2, 3, 2, 3, 3, 3, 3, 3, 3, 2, 2}, + std::vector{ + -0.0035942, -0.0087501, 0.3391940, 0.3904208, 0.3104795, + 0.0558290, 0.0025633, 0.0000103, 0.0000012, -0.0000070, + 0.0000019, 0.0024085, 0.0057996, -0.1491701, -0.1479511, + -0.2619028, 0.1089825, 0.7145623, 0.3564577, 0.0059664, + -0.0030149, 0.0001170, -0.0009643, -0.0023296, 0.0510478, + 0.0443389, 0.1097234, -0.0731069, -0.2422726, -0.3924729, + 0.4418484, 0.7611566, 0.0074626}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{38.369940, 29.841335, 12.267012, 9.649812, + 5.936284, 4.571744, 2.228486, 0.933328}, + std::vector{3, 4, 3, 4, 3, 4, 3, 3}, + std::vector{0.0013296, 0.0058586, 0.3227327, 0.2443064, + 0.4775446, 0.0523989, 0.0007909, + -0.0000252}, + std::vector{5}, std::vector{5})})}, + {40, + SlaterTypeAtom( + 40, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Zr + * + * Etot=-3538.809302333 Ekin=3538.809299988 + */ + SlaterTypeAtomicShell( + 0, + std::vector{58.988353, 50.489673, 41.797820, 29.344692, + 20.990474, 18.163822, + 12.343777, 8.654904, 6.409740, 2.637269, + 2.558706, + 1.619432, + 0.942882, + 0.942815}, + std::vector{2, 3, 1, 4, 4, 2, 2, 3, 3, 4, 2, 3, 2, 3}, + std::vector{ + -0.0249146, -0.0393088, -0.9241489, 0.0346627, 0.0181514, + -0.0755356, 0.0002656, -0.0002278, 0.0002029, 0.0000935, + -0.0001097, -0.0001487, 0.0001551, -0.0000570, -0.0476167, + -0.0679106, -0.2936026, 0.1421329, 0.1466750, 0.6682452, + 0.1625641, -0.0035853, 0.0021286, 0.0005251, -0.0008104, + -0.0006983, 0.0006943, -0.0002534, -0.0235945, -0.0340347, + -0.1219059, 0.0791711, 0.1844239, 0.3697017, 0.0167871, + -0.9371970, -0.2392804, -0.0017611, -0.0004017, 0.0023738, + -0.0023132, 0.0008540, -0.0094099, -0.0136630, -0.0460527, + 0.0319456, 0.0923889, 0.1704706, -0.0781160, -0.4014439, + -0.6471225, -0.0066072, 1.4622462, 0.0251332, -0.0183385, + 0.0047692, 0.0029843, 0.0043363, 0.0144250, -0.0101868, + -0.0307207, -0.0565352, 0.0345710, 0.1265748, 0.2632379, + -0.1537336, -0.7747059, -0.4844275, 1.5531235, 0.1657494}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 0}), + SlaterTypeAtomicShell( + 1, + std::vector{64.011332, 51.677914, 29.333676, 23.977773, + 18.149720, 14.407147, 8.665279, 6.373664, + 3.175024, 1.990389, 0.942815}, + std::vector{2, 3, 2, 3, 3, 3, 3, 3, 3, 2, 2}, + std::vector{ + -0.0037754, -0.0089619, 0.3411613, 0.3880556, 0.2958210, + 0.0703046, 0.0030787, -0.0001458, 0.0000138, -0.0000272, + 0.0000020, 0.0025808, 0.0060609, -0.1518465, -0.1461293, + -0.2646858, 0.0954824, 0.7185904, 0.3632938, 0.0057285, + -0.0018345, 0.0001171, -0.0010762, -0.0025367, 0.0530951, + 0.0432763, 0.1174702, -0.0734511, -0.2442064, -0.4256628, + 0.3825252, 0.8412707, 0.0055847}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{39.278830, 31.447784, 19.678245, 12.159796, + 10.898047, 8.338689, 5.968890, 3.563894, + 2.122982, 1.322001, 0.942815}, + std::vector{3, 4, 4, 3, 4, 4, 4, 3, 3, 3, 3}, + std::vector{ + 0.0024778, 0.0092284, 0.0252233, 0.3525257, 0.1835480, + 0.3667411, 0.1714300, 0.0192532, -0.0004612, 0.0003320, + -0.0000739, -0.0005023, -0.0018692, -0.0039917, -0.0979810, + -0.0437676, -0.1032314, -0.1068578, 0.1772681, 0.4789263, + 0.4839674, 0.0285444}, + std::vector{5, 2}, std::vector{5, 0})})}, + {41, + SlaterTypeAtom( + 41, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Nb + * + * Etot=-3753.389511414 Ekin=3753.389509791 + */ + SlaterTypeAtomicShell( + 0, + std::vector{70.434246, 62.938555, 53.062101, 48.279886, + 24.843872, 22.087857, + 14.193982, 9.738431, 8.235779, 7.847702, + 5.162961, + 3.580662, + 2.594787, + 1.040300}, + std::vector{2, 3, 1, 3, 3, 4, 4, 3, 4, 1, 3, 3, 3, 2}, + std::vector{ + 0.1290034, 0.1178289, 0.6692351, 0.1513710, -0.0030752, + -0.0079037, -0.0065843, -0.0026120, -0.0007804, 0.0247742, + 0.0003054, -0.0001080, 0.0000307, -0.0000025, -0.0704899, + -0.0628696, -0.2534954, -0.1021364, 0.4544683, 0.1296247, + -0.0879710, -0.1309517, -0.0027199, 0.7029101, -0.0004198, + 0.0000481, -0.0000444, 0.0000026, 0.0324561, 0.0286478, + 0.1100880, 0.0497600, -0.2405728, -0.1750770, -0.0530059, + 1.0722493, 0.3029841, -0.3657820, 0.0265299, -0.0001361, + 0.0008765, -0.0000137, -0.0126018, -0.0111344, -0.0423697, + -0.0194048, 0.0928315, 0.0729329, -0.0189565, -0.4519600, + -0.3984411, 0.1444695, 0.0987393, 0.8270712, 0.3623462, + 0.0013187}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{65.199713, 52.729978, 29.992350, 24.612792, + 18.951711, 15.376183, 9.020173, 6.686836, + 3.457967, 2.063821, 1.040300}, + std::vector{2, 3, 2, 3, 3, 3, 3, 3, 3, 2, 2}, + std::vector{ + -0.0037213, -0.0087380, 0.3438854, 0.3806738, 0.2723413, + 0.0969914, 0.0037839, -0.0003819, 0.0000462, -0.0000594, + 0.0000045, 0.0026759, 0.0062071, -0.1550368, -0.1400630, + -0.2628129, 0.0735162, 0.7184633, 0.3749154, 0.0060668, + -0.0011629, 0.0001696, -0.0011827, -0.0027560, 0.0554267, + 0.0397553, 0.1252819, -0.0705262, -0.2424240, -0.4528530, + 0.3691760, 0.8678025, 0.0062725}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{40.650074, 32.437413, 20.078925, 12.080830, + 10.464042, 8.390534, 6.101120, 3.367428, + 2.075086, 1.323833, 1.040300}, + std::vector{3, 4, 4, 3, 4, 4, 4, 3, 3, 3, 3}, + std::vector{ + 0.0025565, 0.0098231, 0.0290402, 0.3991230, 0.2007647, + 0.3207356, 0.1514425, 0.0105147, -0.0005552, 0.0003321, + -0.0000832, -0.0005228, -0.0020073, -0.0046669, -0.1137232, + -0.0412890, -0.1067723, -0.0794418, 0.2495784, 0.4717170, + 0.3803110, 0.0671058}, + std::vector{5, 4}, std::vector{5, 0})})}, + {42, + SlaterTypeAtom( + 42, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Mo + * + * Etot=-3975.333700239 Ekin=3975.333703157 + */ + SlaterTypeAtomicShell( + 0, + std::vector{70.316851, 64.120950, 63.625487, 49.808698, + 34.252894, 29.656433, 17.266950, + 11.512370, 9.035370, 8.397517, 7.658879, + 3.832086, + 2.741544, + 1.104770}, + std::vector{2, 3, 1, 3, 3, 4, 2, 3, 3, 4, 3, 3, 3, 2}, + std::vector{ + 0.2428114, 0.1669316, 0.5297067, 0.1580516, 0.0079361, + -0.0002918, -0.0000888, 0.0002968, 0.0010566, 0.0015077, + -0.0027904, 0.0000216, -0.0000066, 0.0000007, 0.1075843, + 0.0734835, 0.1689908, 0.1128272, 0.0092148, -0.0919812, + -1.0075960, -0.0382176, -0.0127073, -0.0368389, 0.0632866, + -0.0000940, 0.0000671, -0.0000048, 0.0559522, 0.0381921, + 0.0711541, 0.0697926, 0.0972063, 0.0153991, -0.7804026, + 0.0482299, 0.1961093, -0.6079659, 1.5213946, 0.0036936, + 0.0003928, 0.0000160, -0.0232348, -0.0158374, -0.0277235, + -0.0302564, -0.0516256, -0.0158612, 0.3519734, -0.1126817, + -1.0471199, -0.8304720, 1.1652563, 0.8502204, 0.3948471, + 0.0015481}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{67.334203, 54.308953, 30.593445, 25.228887, + 20.008098, 16.554814, 9.387916, 6.998049, + 3.663438, 2.173314, 1.104770}, + std::vector{2, 3, 2, 3, 3, 3, 3, 3, 3, 2, 2}, + std::vector{ + -0.0032884, -0.0078800, 0.3463326, 0.3724033, 0.2227741, + 0.1494521, 0.0052286, -0.0009241, 0.0001639, -0.0001437, + 0.0000154, 0.0025950, 0.0061310, -0.1583131, -0.1291347, + -0.2498777, 0.0363409, 0.7165948, 0.3887461, 0.0067935, + -0.0012075, 0.0001964, -0.0012358, -0.0029311, 0.0582957, + 0.0330569, 0.1324464, -0.0622980, -0.2454491, -0.4794905, + 0.3803921, 0.8696801, 0.0067032}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{41.841533, 33.283867, 20.477569, 12.828420, + 10.862802, 8.442859, 6.230335, 3.541145, + 2.200444, 1.415655, 1.104770}, + std::vector{3, 4, 4, 3, 4, 4, 4, 3, 3, 3, 3}, + std::vector{ + 0.0023119, 0.0090703, 0.0251736, 0.3791761, 0.2660570, + 0.3089784, 0.1226452, 0.0084224, -0.0003599, 0.0001642, + -0.0000602, -0.0004590, -0.0017933, -0.0031474, -0.1168373, + -0.0629910, -0.1175010, -0.0716590, 0.2787089, 0.4872541, + 0.3562264, 0.0533408}, + std::vector{5, 5}, std::vector{5, 0})})}, + {43, + SlaterTypeAtom( + 43, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Tc + * + * Etot=-4204.594355021 Ekin=4204.59434964 + */ + SlaterTypeAtomicShell( + 0, + std::vector{63.459187, 54.494318, 44.883169, 32.396317, + 23.922921, 21.266159, + 15.024147, 9.711884, 7.457529, 3.319045, + 2.782002, + 1.967616, + 1.010253, + 1.009785}, + std::vector{2, 3, 1, 4, 4, 2, 2, 3, 3, 4, 2, 3, 2, 3}, + std::vector{ + 0.0236719, 0.0362553, 0.9264112, -0.0307091, -0.0117065, + 0.0691396, -0.0016270, 0.0004401, -0.0003527, -0.0001386, + 0.0001768, 0.0000923, -0.0000792, 0.0000334, -0.0483387, + -0.0668604, -0.2961286, 0.1372237, 0.1717360, 0.4551932, + 0.3565580, -0.0011032, 0.0016908, 0.0005443, -0.0008705, + -0.0002815, 0.0002209, -0.0000989, 0.0236122, 0.0331445, + 0.1255338, -0.0679702, -0.1497605, -0.1821582, -0.2921268, + 0.9120836, 0.3013310, -0.0025622, 0.0082201, 0.0004739, + -0.0003649, 0.0001441, -0.0102169, -0.0145461, -0.0501783, + 0.0287014, 0.0880150, 0.1139048, 0.0238320, -0.3681955, + -0.7526050, -0.1628207, 1.6233489, 0.0052523, -0.0055635, + -0.0001872, 0.0032264, 0.0045900, 0.0155741, -0.0091541, + -0.0293672, -0.0391077, 0.0022333, 0.1114915, 0.2950714, + -0.0070789, -0.7981527, -0.3499030, 1.4187924, 0.0752041}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 0}), + SlaterTypeAtomicShell( + 1, + std::vector{67.772730, 55.044142, 31.433532, 25.888684, + 22.027894, 17.679727, 9.789992, 7.317539, + 3.784492, 2.316428, 1.009785}, + std::vector{2, 3, 2, 3, 3, 3, 3, 3, 3, 2, 2}, + std::vector{ + -0.0040050, -0.0091336, 0.3484572, 0.3512090, 0.1627990, + 0.2293541, 0.0059663, -0.0010867, 0.0001524, -0.0001351, + 0.0000102, 0.0032859, 0.0073964, -0.1625861, -0.0962222, + -0.2176192, -0.0440209, 0.7081094, 0.4107727, 0.0073977, + -0.0016141, 0.0001247, -0.0016951, -0.0038277, 0.0626702, + 0.0112120, 0.1316264, -0.0287739, -0.2503335, -0.5074785, + 0.4202982, 0.8439390, 0.0045077}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{43.402296, 34.449464, 21.222767, 13.210700, + 11.054045, 8.765156, 6.597644, 3.852519, + 2.437104, 1.563023, 1.009785}, + std::vector{3, 4, 4, 3, 4, 4, 4, 3, 3, 3, 3}, + std::vector{ + 0.0021140, 0.0084309, 0.0224561, 0.3910834, 0.2796358, + 0.2781394, 0.1264591, 0.0094279, -0.0002445, 0.0000699, + -0.0000092, -0.0004487, -0.0017880, -0.0027313, -0.1324984, + -0.0728155, -0.1238812, -0.0826318, 0.2762275, 0.5334157, + 0.3622873, 0.0072198}, + std::vector{5, 5}, std::vector{5, 0})})}, + {44, + SlaterTypeAtom( + 44, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ru + * + * Etot=-4441.321952305 Ekin=4441.321950672 + */ + SlaterTypeAtomicShell( + 0, + std::vector{69.167117, 62.279945, 58.825221, 47.281849, + 32.223937, 24.884214, 19.006287, 16.362574, + 11.204522, 11.202035, 8.027154, 4.223517, + 2.734310, 1.167416}, + std::vector{2, 3, 1, 3, 3, 4, 2, 4, 3, 4, 3, 3, 2, 2}, + std::vector{ + 0.1791679, 0.1480122, 0.6392339, 0.0968192, -0.1003045, + -0.0723659, 0.1736176, -0.0118142, 0.0115280, -0.0048459, + 0.0006163, -0.0000265, 0.0000143, -0.0000006, 0.1232829, + 0.1019294, 0.2047137, 0.1686445, 0.2730322, 0.1754813, + -1.6089906, -0.0191037, -0.0050933, 0.0008659, -0.0001650, + 0.0001837, -0.0000222, 0.0000029, 0.0542101, 0.0446273, + 0.0872987, 0.0775141, 0.0836706, -0.0487716, -0.7274971, + -0.0568524, 0.5378679, 0.2447690, 0.4602255, 0.0056119, + 0.0002202, 0.0000512, -0.0206093, -0.0170118, -0.0350962, + -0.0283774, -0.0232034, 0.0207137, 0.2561544, -0.0968665, + 0.0446249, -0.2330848, -0.6621862, 0.5327631, 0.8273787, + 0.0014500}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{69.428903, 56.654105, 32.958018, 27.420208, + 23.034579, 18.098323, 10.126508, 7.633018, + 4.046388, 2.387330, 1.167416}, + std::vector{2, 3, 2, 3, 3, 3, 3, 3, 3, 2, 2}, + std::vector{ + -0.0045575, -0.0099379, 0.3326425, 0.2991799, 0.2394590, + 0.2232088, 0.0058703, -0.0011210, 0.0001290, -0.0001297, + 0.0000105, 0.0036738, 0.0079666, -0.1570746, -0.0846934, + -0.2252312, -0.0648898, 0.7031403, 0.4205376, 0.0084384, + -0.0013621, 0.0002325, -0.0019418, -0.0042299, 0.0615651, + 0.0103489, 0.1271941, -0.0160576, -0.2431654, -0.5306555, + 0.4079783, 0.8641498, 0.0068259}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{43.919269, 35.195776, 21.834796, 13.398607, + 11.367159, 9.051785, 6.719894, 3.829794, + 2.413988, 1.540748, 1.167416}, + std::vector{3, 4, 4, 3, 4, 4, 4, 3, 3, 3, 3}, + std::vector{ + 0.0024453, 0.0091216, 0.0274107, 0.4012721, 0.2630635, + 0.2932569, 0.1116493, 0.0059421, 0.0003510, 0.0001443, + 0.0000460, -0.0005226, -0.0019431, -0.0039495, -0.1363980, + -0.0608944, -0.1420706, -0.0548364, 0.3354492, 0.4785517, + 0.3262991, 0.0456467}, + std::vector{5, 5}, std::vector{5, 2})})}, + {45, + SlaterTypeAtom( + 45, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Rh + * + * Etot=-4685.664166697 Ekin=4685.664162208 + */ + SlaterTypeAtomicShell( + 0, + std::vector{75.823917, 67.136931, 59.033655, 44.128347, + 32.577254, 26.722176, 26.701689, 19.404845, + 10.124838, 7.383255, 7.377173, 4.176825, + 3.009481, 1.204957}, + std::vector{2, 3, 1, 4, 2, 2, 3, 3, 3, 3, 4, 3, 3, 2}, + std::vector{ + 0.1071012, 0.1086305, 0.6578003, -0.0853189, 0.4541279, + -0.2336741, 0.0498724, -0.0012238, 0.0000119, -0.0000255, + 0.0000114, 0.0000037, -0.0000007, 0.0000001, -0.0449481, + -0.0449612, -0.2110404, 0.0640321, -0.0045013, -0.0130796, + 0.6072363, 0.3892791, 0.0104256, -0.0065134, 0.0026522, + -0.0003493, 0.0000600, -0.0000057, 0.0209247, 0.0207145, + 0.0905210, -0.0372273, -0.2116931, 0.3338979, -0.4445570, + -0.3220519, 1.0094401, 0.2256024, -0.0193837, 0.0028580, + 0.0005811, 0.0000010, -0.0092449, -0.0089484, -0.0368527, + 0.0202779, 0.1937841, -0.3027790, 0.2620081, 0.1230201, + -0.2871978, -0.8202565, 0.3925951, 0.8845411, 0.3109005, + 0.0011770}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{71.413902, 58.292587, 33.909267, 28.554803, + 24.386089, 18.626594, 10.451995, 7.915398, + 4.257851, 2.495199, 1.204957}, + std::vector{2, 3, 2, 3, 3, 3, 3, 3, 3, 2, 2}, + std::vector{ + -0.0046486, -0.0101311, 0.3298160, 0.2440335, 0.2846288, + 0.2367650, 0.0049117, -0.0006557, -0.0000520, -0.0000224, + -0.0000047, 0.0037822, 0.0081678, -0.1572347, -0.0585198, + -0.2344154, -0.0921999, 0.7075393, 0.4221176, 0.0088603, + -0.0011526, 0.0002251, -0.0020453, -0.0044258, 0.0627652, + -0.0003663, 0.1288607, -0.0002297, -0.2478958, -0.5507291, + 0.4114183, 0.8739274, 0.0069339}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{45.122514, 36.167790, 22.243792, 13.619067, + 11.800818, 9.470982, 6.973715, 3.912689, + 2.482661, 1.589713, 1.204957}, + std::vector{3, 4, 4, 3, 4, 4, 4, 3, 3, 3, 3}, + std::vector{ + 0.0027216, 0.0101854, 0.0352336, 0.4024365, 0.2370888, + 0.3083209, 0.1108499, 0.0045969, 0.0007399, 0.0000766, + 0.0001085, -0.0005770, -0.0021640, -0.0051951, -0.1456529, + -0.0459645, -0.1634305, -0.0402472, 0.3670030, 0.4704867, + 0.3057563, 0.0377505}, + std::vector{5, 5}, std::vector{5, 3})})}, + {46, + SlaterTypeAtom( + 46, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Pd + * + * Etot=-4937.675923704 Ekin=4937.675927723 + */ + SlaterTypeAtomicShell( + 0, + std::vector{77.029845, 69.840091, 65.668391, 54.310004, + 38.997941, 32.710801, 19.272829, 18.835602, + 13.463015, 12.999127, 8.737583, 4.594464, + 2.953575, 1.242716}, + std::vector{2, 3, 1, 3, 3, 4, 2, 4, 3, 4, 3, 3, 2, 2}, + std::vector{ + 0.2018204, 0.1537354, 0.5795954, 0.1546098, 0.0067230, + 0.0027647, -0.0033387, 0.0033351, -0.0043117, 0.0016088, + -0.0002634, 0.0000391, -0.0000210, 0.0000013, -0.0970988, + -0.0726376, -0.1862663, -0.1141952, -0.0228669, 0.0825778, + 1.0300181, 0.0115603, 0.0188292, -0.0026725, 0.0004227, + -0.0002288, 0.0000387, -0.0000040, 0.0500081, 0.0375038, + 0.0803352, 0.0639958, 0.0791030, 0.0245298, -0.7038575, + 0.1983130, -0.1920318, 0.5880246, 0.5696696, 0.0067751, + 0.0001840, 0.0000600, -0.0214682, -0.0160120, -0.0330746, + -0.0282879, -0.0420370, -0.0243930, 0.3099391, -0.1549859, + 0.2187004, -0.2442546, -0.8014019, 0.5353046, 0.8457249, + 0.0016595}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{67.203163, 56.595033, 35.847961, 31.249077, + 26.841348, 19.603644, 10.803310, 8.224438, + 4.449596, 2.601753, 1.242716}, + std::vector{2, 3, 2, 3, 3, 3, 3, 3, 3, 2, 2}, + std::vector{ + -0.0103460, -0.0177789, 0.3264580, 0.0987869, 0.3963705, + 0.2860596, 0.0073168, -0.0017500, 0.0001995, -0.0001796, + 0.0000143, 0.0094480, 0.0162023, -0.1689295, 0.0176015, + -0.2734691, -0.1405867, 0.7019128, 0.4334627, 0.0097966, + -0.0012499, 0.0002474, -0.0056890, -0.0097711, 0.0740768, + -0.0363091, 0.1456666, 0.0242189, -0.2483983, -0.5705612, + 0.4142719, 0.8796408, 0.0074480}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{46.454482, 37.217129, 22.854553, 14.037836, + 11.992854, 9.829564, 7.410295, 4.055826, + 2.560909, 1.630550, 1.242716}, + std::vector{3, 4, 4, 3, 4, 4, 4, 3, 3, 3, 3}, + std::vector{ + 0.0025833, 0.0097341, 0.0335069, 0.4078367, 0.2570812, + 0.2709085, 0.1207242, 0.0067498, 0.0002826, 0.0005217, + -0.0000039, -0.0005500, -0.0020708, -0.0047590, -0.1523392, + -0.0490615, -0.1660975, -0.0360650, 0.3893690, 0.4753941, + 0.2870992, 0.0292005}, + std::vector{5, 5}, std::vector{5, 4})})}, + {47, + SlaterTypeAtom( + 47, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ag + * + * Etot=-5197.48132816 Ekin=5197.481329747 + */ + SlaterTypeAtomicShell( + 0, + std::vector{96.205766, 92.007782, 69.316325, 58.276640, + 37.009771, 31.058364, 25.210376, 20.931374, + 12.923312, 12.019269, 7.600018, 3.561582, + 2.418015, 1.284773}, + std::vector{1, 2, 2, 3, 4, 4, 2, 3, 3, 4, 2, 2, 1, 2}, + std::vector{ + -0.3376442, -0.0857809, -0.5008874, -0.1699084, 0.0127512, + 0.0096268, -0.0472836, 0.0025700, -0.0003137, 0.0002702, + -0.0001834, 0.0000255, -0.0000268, 0.0000007, 0.1086918, + 0.0268566, 0.2053896, 0.1182025, -0.0504422, -0.1351971, + -0.5191002, -0.4343667, -0.0159702, 0.0023666, -0.0002726, + 0.0002857, -0.0001337, 0.0000029, 0.0471120, 0.0117398, + 0.0909734, 0.0557643, -0.0130550, -0.0811930, -0.2828634, + -0.4314174, 0.2386286, 0.4161500, 0.6169098, 0.0022902, + 0.0022665, -0.0000292, -0.0222314, -0.0055849, -0.0431802, + -0.0271832, 0.0033385, 0.0420014, 0.1416154, 0.2702443, + 0.3210625, -0.1154766, -1.7400495, 1.0643406, 0.6623517, + 0.0000744}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{46.559221, 41.455427, 35.819990, 23.244138, + 19.003003, 10.859053, 8.310115, 4.850725, + 3.372303, 2.438419, 1.284773}, + std::vector{2, 3, 4, 2, 3, 3, 3, 2, 2, 2, 2}, + std::vector{ + 0.0097705, 0.0359924, 0.0397502, -0.9205467, -0.1879899, + -0.0026539, -0.0004771, 0.0008558, -0.0003739, 0.0001694, + -0.0000112, 0.0394441, 0.0790464, 0.0725368, -0.6129768, + -0.0734110, 0.7816821, 0.3350763, 0.0213847, -0.0005927, + 0.0011472, -0.0000017, -0.0279194, -0.0544000, -0.0497524, + 0.3012743, -0.0221252, -0.3215567, -0.6653775, 0.0392216, + 0.9617731, 0.4334011, 0.0027405}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{47.563072, 38.124644, 23.402528, 14.295548, + 12.300093, 10.273766, 7.691333, 4.178313, + 2.645050, 1.700613, 1.284773}, + std::vector{3, 4, 4, 3, 4, 4, 4, 3, 3, 3, 3}, + std::vector{ + 0.0026889, 0.0100888, 0.0361618, 0.4167390, 0.2373092, + 0.2746241, 0.1236067, 0.0050200, 0.0000264, -0.0000600, + 0.0000366, -0.0005740, -0.0021493, -0.0052381, -0.1608625, + -0.0337440, -0.1832996, -0.0286646, 0.4128593, 0.4652739, + 0.2726433, 0.0285072}, + std::vector{5, 5}, std::vector{5, 5})})}, + {48, + SlaterTypeAtom( + 48, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Cd + * + * Etot=-5464.878604577 Ekin=5464.878604622 + */ + SlaterTypeAtomicShell( + 0, + std::vector{83.241314, 74.097257, 57.013483, 56.271343, + 37.173267, 35.081552, 20.121467, 13.161690, + 10.128010, 6.928708, 3.638910, 2.408334, + 1.385266, 1.047220}, + std::vector{2, 3, 1, 3, 3, 4, 2, 4, 4, 1, 2, 2, 1, 2}, + std::vector{ + -0.0811541, -0.0773673, -0.7640362, -0.1286896, -0.0079223, + 0.0018591, -0.0009174, -0.0000772, -0.0000735, 0.0004519, + -0.0000123, 0.0000082, -0.0000055, 0.0000006, 0.0570071, + 0.0527000, 0.2488285, 0.1089940, 0.0371403, -0.0866111, + -1.0207322, 0.0083822, 0.0099951, -0.0590514, 0.0011059, + -0.0008453, 0.0005878, -0.0000643, 0.0236004, 0.0212958, + 0.0759775, 0.0499728, 0.0798285, -0.0014448, -1.0684982, + 0.5290895, 0.1788734, 0.7400275, 0.0060670, -0.0009327, + 0.0005805, -0.0000650, -0.0055631, -0.0051236, -0.0159578, + -0.0119079, -0.0298952, -0.0071460, 0.6089006, -0.3085116, + -0.4956554, -0.6916589, 1.4790337, 0.0869634, -0.0105546, + 0.0012931, 0.0008701, 0.0008094, 0.0022237, 0.0019371, + 0.0068381, 0.0030443, -0.1830231, 0.0890768, 0.1813758, + 0.2924009, -0.3264096, -0.0459377, -0.6097235, 1.4029963}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 0}), + SlaterTypeAtomicShell( + 1, + std::vector{45.590143, 40.452978, 35.227058, 24.560040, + 18.494253, 13.375523, 12.492308, 7.727315, + 3.469794, 2.496341, 1.047220}, + std::vector{2, 3, 4, 2, 3, 3, 4, 2, 2, 2, 2}, + std::vector{ + 0.0930886, 0.1822696, 0.1367408, -1.2344683, -0.1942605, + 0.0258144, -0.0121504, 0.0049171, -0.0001556, 0.0001252, + -0.0000083, 0.1233108, 0.2239033, 0.1667356, -0.9822888, + -0.1244708, 0.1402810, 0.2932974, 0.7745982, 0.0050509, + -0.0001734, 0.0000184, -0.0816099, -0.1466644, -0.1090997, + 0.5897455, 0.0959116, 0.2344330, -0.0489109, -1.2885544, + 1.0973628, 0.3406406, 0.0009110}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{48.197499, 38.917760, 23.971606, 14.574248, + 12.816805, 10.561976, 7.894193, 4.252198, + 2.707643, 1.782312, 1.047220}, + std::vector{3, 4, 4, 3, 4, 4, 4, 3, 3, 3, 3}, + std::vector{ + 0.0030242, 0.0107823, 0.0418654, 0.4139823, 0.2229933, + 0.2944709, 0.1127872, 0.0048100, -0.0003696, 0.0001149, + -0.0000185, -0.0006672, -0.0023771, -0.0065555, -0.1724647, + -0.0268978, -0.2084554, -0.0079414, 0.4528905, 0.4862047, + 0.2195409, 0.0012032}, + std::vector{5, 5}, std::vector{5, 5})})}, + {49, + SlaterTypeAtom( + 49, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for In + * + * Etot=-5739.978386638 Ekin=5739.978378069 + */ + SlaterTypeAtomicShell( + 0, + std::vector{83.933502, 62.707779, 51.070721, 37.358361, + 23.825100, 23.806004, 16.775088, 13.128081, + 11.146827, 9.114307, 3.788603, 2.378645, + 1.102125, 1.101866}, + std::vector{1, 3, 1, 4, 3, 2, 3, 4, 2, 3, 2, 2, 2, 3}, + std::vector{ + 0.0225622, -0.0251208, -0.9772211, 0.0289174, + 0.0272873, -0.0789229, 0.0042432, 0.0033340, + -0.0093935, -0.0004269, 0.0000701, -0.0000366, + 0.0000178, -0.0000095, 0.0424295, -0.0419670, + -0.3896011, 0.0977759, 0.4128459, 0.5572575, + 0.2019082, 0.0475135, -0.1836872, 0.0003397, + -0.0001917, 0.0000283, -0.0000112, 0.0000058, + -0.0185522, 0.0188962, 0.1705401, -0.0316202, + -0.4535252, -0.3896646, -0.4212742, 0.3027331, + 1.0506147, 0.3833309, 0.0068814, -0.0006935, + 0.0002494, -0.0001245, 0.0078652, -0.0081027, + -0.0728895, 0.0111993, 0.1839230, 0.0450938, + -0.2835875, -0.3817589, 0.2480278, -0.8810597, + 1.5508642, 0.0521135, -0.0045131, 0.0020230, + -0.0022556, 0.0023498, 0.0209596, -0.0028375, + -0.0463873, 0.0162177, 0.1976860, 0.1802430, + -0.2569267, 0.2946737, -0.5107810, -0.4003841, + 1.3109940, -0.0268250}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{47.152308, 42.226582, 37.027541, 25.782094, + 20.071104, 12.947974, 12.066104, 8.031651, + 3.549498, 2.552364, 1.101866}, + std::vector{2, 3, 4, 2, 3, 4, 3, 2, 2, 2, 2}, + std::vector{ + -0.0909388, -0.1650134, -0.1196953, 1.1571852, 0.2275821, + 0.0108207, -0.0116668, -0.0024982, -0.0000042, -0.0000557, + 0.0000044, 0.1064506, 0.1820539, 0.1331028, -0.8648120, + -0.1736606, 0.2171920, 0.1747361, 0.8160347, 0.0064137, + -0.0009129, 0.0000457, -0.0694211, -0.1176530, -0.0861515, + 0.5183644, 0.1336756, -0.2111248, 0.4518188, -1.3879291, + 1.2035959, 0.2463270, 0.0015249}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{49.554320, 39.895199, 24.386414, 14.997417, + 13.047140, 10.875056, 8.197538, 4.314403, + 2.790643, 1.906550, 1.101866}, + std::vector{3, 4, 4, 3, 4, 4, 4, 3, 3, 3, 3}, + std::vector{ + 0.0029839, 0.0109443, 0.0435709, 0.4111140, 0.2482600, + 0.2657584, 0.1166268, 0.0037044, -0.0001117, -0.0000237, + 0.0000110, -0.0006588, -0.0024032, -0.0065789, -0.1815204, + -0.0281663, -0.2247243, 0.0103087, 0.4968198, 0.4819633, + 0.1642165, 0.0004534}, + std::vector{5, 5}, std::vector{5, 5})})}, + {50, + SlaterTypeAtom( + 50, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Sn + * + * Etot=-6022.678320408 Ekin=6022.678328054 + */ + SlaterTypeAtomicShell( + 0, + std::vector{89.536877, 64.885326, 51.871742, 28.332819, + 27.174333, 24.996281, 14.533367, 14.317933, + 10.981514, 5.369886, 3.998462, 3.184758, + 1.223362, 1.007489}, + std::vector{1, 3, 1, 4, 2, 3, 2, 4, 4, 4, 2, 3, 2, 3}, + std::vector{ + 0.0124864, -0.0182515, -0.9646721, -0.1045612, + -0.1091101, 0.1912018, -0.0205536, 0.0045282, + -0.0018319, -0.0007609, 0.0013557, -0.0000141, + -0.0000075, 0.0000030, -0.0217228, 0.0271544, + 0.3520699, 0.3603999, -0.1956369, -1.1417618, + -0.1009394, 0.0077124, -0.0020932, -0.0008070, + 0.0016930, -0.0000505, -0.0000009, 0.0000005, + -0.0111344, 0.0144080, 0.1584502, 0.1049425, + -0.1765178, -0.6738057, 0.2762000, 0.6536666, + 0.3415724, -0.0240446, 0.0570387, -0.0026985, + 0.0002340, -0.0000763, 0.0051986, -0.0068176, + -0.0696419, -0.0272050, 0.1156790, 0.3294724, + -0.3357313, -0.4194236, -0.6369924, 0.1425117, + 1.3447357, 0.0582806, -0.0009480, 0.0003428, + -0.0015760, 0.0020403, 0.0214149, 0.0088905, + -0.0379069, -0.1060458, 0.1219226, 0.1418838, + 0.2447101, -0.0369251, -0.6256212, -0.3312875, + 1.3114588, -0.0021416}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{87.582417, 54.009271, 36.503437, 27.647593, + 24.869429, 21.411776, 14.436127, 10.699225, + 4.605819, 4.331595, 3.215664, 2.035549, + 1.007489}, + std::vector{2, 4, 2, 4, 3, 4, 4, 4, 2, 3, 3, 3, 2}, + std::vector{ + 0.0005289, -0.0067609, -0.3345510, 0.3463708, -1.0190694, + -0.0459361, -0.0046978, 0.0009738, -0.0004984, 0.0004422, + -0.0001233, 0.0000262, -0.0000057, 0.0004188, -0.0051880, + -0.1548468, 0.1291665, -0.4463481, 0.1510796, 0.6032523, + 0.3548783, 0.0469112, -0.0150749, 0.0032913, -0.0004414, + 0.0000641, -0.0002057, 0.0025475, 0.0614795, -0.0398031, + 0.1508946, -0.1248136, -0.3717340, -0.4784763, 0.5401031, + 0.6591199, 0.2173367, 0.0043666, 0.0008529, 0.0000578, + -0.0007482, -0.0155703, 0.0083109, -0.0341119, 0.0397016, + 0.1078247, 0.1576803, -0.2588962, -0.1324358, -0.3012657, + -0.1896492, 1.3245401}, + std::vector{3, 3, 3, 1}, std::vector{3, 3, 3, 0}), + SlaterTypeAtomicShell( + 2, + std::vector{51.597942, 41.349959, 25.387026, 15.528421, + 13.034799, 11.515254, 8.788639, 4.556394, + 2.990519, 2.048564, 1.007489}, + std::vector{3, 4, 4, 3, 4, 4, 4, 3, 3, 3, 3}, + std::vector{ + 0.0023891, 0.0089931, 0.0325409, 0.4271672, 0.2858794, + 0.1879003, 0.1500725, 0.0055094, -0.0006521, 0.0001205, + -0.0000102, -0.0005217, -0.0019606, -0.0040600, -0.1926681, + -0.0125389, -0.2408208, -0.0101906, 0.5000530, 0.5149736, + 0.1335755, 0.0002978}, + std::vector{5, 5}, std::vector{5, 5})})}, + {51, + SlaterTypeAtom( + 51, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Sb + * + * Etot=-6313.165938302 Ekin=6313.165931418 + */ + SlaterTypeAtomicShell( + 0, + std::vector{91.510038, 66.158049, 52.818130, 28.908909, + 26.867097, 25.527436, 15.556395, 14.799417, + 11.405158, 5.658977, 4.195321, 3.487552, + 1.334874, 1.092702}, + std::vector{1, 3, 1, 4, 2, 3, 2, 4, 4, 4, 2, 3, 2, 3}, + std::vector{ + 0.0116119, -0.0173849, -0.9654298, -0.1028935, -0.1132982, + 0.1989488, -0.0234098, 0.0041248, -0.0018054, -0.0007638, + 0.0013815, -0.0000274, -0.0000066, 0.0000026, -0.0214418, + 0.0272206, 0.3529747, 0.3540776, -0.2089693, -1.1061964, + -0.1136923, 0.0054368, -0.0019461, -0.0008477, 0.0017937, + -0.0000659, -0.0000040, 0.0000013, -0.0109649, 0.0143562, + 0.1593518, 0.1042361, -0.1949356, -0.6559897, 0.2567280, + 0.6508623, 0.3570156, -0.0309854, 0.0733090, -0.0042461, + 0.0002261, -0.0000733, 0.0052125, -0.0069221, -0.0710107, + -0.0253196, 0.1352329, 0.3253140, -0.3311350, -0.4201703, + -0.6425591, 0.2119884, 1.2468001, 0.0778633, -0.0001673, + 0.0001919, -0.0016623, 0.0021770, 0.0230051, 0.0087925, + -0.0469837, -0.1106717, 0.1267670, 0.1496132, 0.2607673, + -0.0498818, -0.6179784, -0.3961626, 1.3445521, 0.0005651}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{89.334065, 55.165158, 37.295835, 28.116805, + 25.320500, 22.376940, 14.838804, 10.928259, + 4.786676, 4.370542, 3.125810, 1.380036, + 1.092702}, + std::vector{2, 4, 2, 4, 3, 4, 4, 4, 2, 3, 3, 3, 2}, + std::vector{ + 0.0005603, -0.0069856, -0.3343640, 0.3619419, -1.0308796, + -0.0478185, -0.0057128, 0.0013636, -0.0006235, 0.0004247, + -0.0000690, 0.0000572, -0.0000600, 0.0004547, -0.0055788, + -0.1557195, 0.1264945, -0.4508831, 0.1484171, 0.6218901, + 0.3532486, 0.0342938, -0.0070916, 0.0009196, -0.0004752, + 0.0004829, 0.0002303, -0.0028302, -0.0625881, 0.0348453, + -0.1507849, 0.1280222, 0.4043434, 0.4971943, -0.5965134, + -0.7336304, -0.1242625, -0.0020209, 0.0010183, 0.0000663, + -0.0008089, -0.0172243, 0.0084699, -0.0381096, 0.0420871, + 0.1274679, 0.1719594, -0.2735728, -0.2008144, -0.3239087, + 0.2157742, 1.0076695}, + std::vector{3, 3, 3, 2}, std::vector{3, 3, 3, 0}), + SlaterTypeAtomicShell( + 2, + std::vector{52.820747, 42.469403, 26.142129, 16.086280, + 13.482811, 11.556145, 9.064544, 4.673794, + 3.165614, 2.193029, 1.092702}, + std::vector{3, 4, 4, 3, 4, 4, 4, 3, 3, 3, 3}, + std::vector{ + 0.0022794, 0.0083947, 0.0305705, 0.4190687, 0.3222736, + 0.1697066, 0.1413863, 0.0061150, -0.0012427, 0.0002781, + -0.0000296, -0.0005038, -0.0018472, -0.0037541, -0.1952983, + -0.0512190, -0.2330723, 0.0132937, 0.5175289, 0.5074630, + 0.1139282, 0.0004400}, + std::vector{5, 5}, std::vector{5, 5})})}, + {52, + SlaterTypeAtom( + 52, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Te + * + * Etot=-6611.503390415 Ekin=6611.503399381 + */ + SlaterTypeAtomicShell( + 0, + std::vector{93.590515, 67.811741, 53.988581, 29.683372, + 26.218479, 26.207765, 16.745947, 15.345344, + 11.865154, 5.915313, 4.454222, 3.787930, + 1.441928, 1.173846}, + std::vector{1, 3, 1, 4, 2, 3, 2, 4, 4, 4, 2, 3, 2, 3}, + std::vector{ + 0.0123692, -0.0178768, -0.9638307, -0.1092143, -0.1331600, + 0.2310013, -0.0294586, 0.0039079, -0.0017628, -0.0006921, + 0.0012756, -0.0000090, -0.0000078, 0.0000028, -0.0209484, + 0.0262496, 0.3512243, 0.3531079, -0.2076912, -1.0767087, + -0.1358250, 0.0021674, -0.0007888, -0.0002739, 0.0008198, + -0.0000534, 0.0000002, -0.0000007, -0.0107535, 0.0138996, + 0.1591626, 0.1047102, -0.2115460, -0.6258428, 0.2231436, + 0.6393538, 0.3837744, -0.0347745, 0.0851227, -0.0043561, + 0.0000746, -0.0000282, 0.0052518, -0.0069153, -0.0719797, + -0.0225034, 0.1612041, 0.3094931, -0.3214480, -0.4123160, + -0.6519567, 0.2990226, 1.1093529, 0.1179949, 0.0002796, + 0.0001624, -0.0017675, 0.0023076, 0.0243631, 0.0073338, + -0.0597461, -0.1093386, 0.1297798, 0.1515744, 0.2773152, + -0.0663234, -0.5781060, -0.4801761, 1.3736657, 0.0041990}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{87.616102, 55.668833, 38.210478, 29.010304, + 26.311565, 23.126945, 15.267977, 11.277741, + 5.322612, 4.614815, 3.200239, 1.177299, + 1.173846}, + std::vector{2, 4, 2, 4, 3, 4, 4, 4, 2, 3, 3, 2, 3}, + std::vector{ + 0.0006998, -0.0072973, -0.3319198, 0.3218415, -0.9792461, + -0.0657524, -0.0051151, 0.0010890, -0.0004324, 0.0003078, + -0.0000719, 0.0000245, -0.0000132, 0.0005841, -0.0060449, + -0.1558140, 0.1054918, -0.4286083, 0.1350201, 0.6209780, + 0.3549311, 0.0390623, -0.0052126, 0.0010431, -0.0002654, + 0.0001289, -0.0003038, 0.0031386, 0.0637800, -0.0264983, + 0.1453117, -0.1238806, -0.4102726, -0.5042863, 0.4845411, + 0.8734083, 0.1064180, -0.0002962, 0.0003966, 0.0000899, + -0.0008994, -0.0186065, 0.0071787, -0.0393839, 0.0429125, + 0.1380763, 0.1837167, -0.2471212, -0.3016634, -0.4071339, + 1.4106682, -0.1044193}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 0}), + SlaterTypeAtomicShell( + 2, + std::vector{53.731320, 43.429755, 26.567495, 16.127198, + 14.562398, 12.386016, 9.261869, 4.802362, + 3.251366, 2.176784, 1.173846}, + std::vector{3, 4, 4, 3, 4, 4, 4, 3, 3, 3, 3}, + std::vector{ + 0.0028920, 0.0103667, 0.0448264, 0.4138810, 0.1738343, + 0.3117967, 0.1361438, 0.0045394, -0.0007452, 0.0001132, + -0.0000173, -0.0006035, -0.0021475, -0.0058475, -0.2132586, + 0.0194842, -0.2841288, -0.0059267, 0.5698709, 0.5068548, + 0.0665784, -0.0001401}, + std::vector{5, 5}, std::vector{5, 5})})}, + {53, + SlaterTypeAtom( + 53, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for I + * + * Etot=-6917.627270253 Ekin=6917.627269288 + */ + SlaterTypeAtomicShell( + 0, + std::vector{95.699405, 69.159533, 55.005356, 30.208358, + 27.514972, 26.665804, 16.754872, 15.428419, + 11.735418, 6.709553, 6.090588, 4.120560, + 1.546919, 1.205350}, + std::vector{1, 3, 1, 4, 2, 3, 2, 4, 4, 2, 4, 3, 2, 3}, + std::vector{ + 0.0121177, -0.0177550, -0.9641131, -0.1083059, -0.1228957, + 0.2170969, -0.0275157, 0.0037404, -0.0022116, 0.0016139, + -0.0003047, 0.0001247, -0.0000133, 0.0000040, -0.0207324, + 0.0264097, 0.3516209, 0.3594009, -0.2008652, -1.1069577, + -0.1214900, 0.0029063, -0.0013585, 0.0012441, -0.0000566, + 0.0000382, -0.0000088, 0.0000017, -0.0106515, 0.0139807, + 0.1598894, 0.1084710, -0.2009195, -0.6584985, 0.2448272, + 0.7015212, 0.3225209, 0.0414924, 0.0015184, 0.0000342, + -0.0000710, 0.0000021, 0.0052914, -0.0070738, -0.0732301, + -0.0211268, 0.1880442, 0.3547063, -0.5368859, -0.6231465, + -0.7957554, 1.1441542, 0.6729804, 0.2182860, 0.0005657, + 0.0001858, -0.0018596, 0.0024700, 0.0257338, 0.0063415, + -0.0762878, -0.1325452, 0.2390178, 0.2554965, 0.3638283, + -0.5854768, -0.2252477, -0.6227461, 1.3996221, 0.0075751}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{85.708202, 56.135051, 39.210062, 29.385706, + 26.590075, 23.838904, 15.749086, 11.794452, + 6.817071, 5.065874, 3.617986, 1.304389, + 1.205350}, + std::vector{2, 4, 2, 4, 3, 4, 4, 4, 2, 3, 3, 2, 3}, + std::vector{ + 0.0010124, -0.0085561, -0.3288613, 0.3571027, -1.0193308, + -0.0597356, -0.0059199, 0.0017021, -0.0009544, 0.0003072, + -0.0000671, 0.0000137, -0.0000069, 0.0007733, -0.0065209, + -0.1559999, 0.1214907, -0.4563591, 0.1279594, 0.5886482, + 0.3494954, 0.0829194, -0.0000684, 0.0004521, -0.0001155, + 0.0000335, -0.0004060, 0.0034459, 0.0648998, -0.0299992, + 0.1575180, -0.1230928, -0.3891740, -0.4984535, 0.2555826, + 1.0065627, 0.1806590, 0.0026251, -0.0001878, 0.0001305, + -0.0011021, -0.0193362, 0.0061948, -0.0398059, 0.0498736, + 0.1460453, 0.2017700, -0.1840762, -0.3549652, -0.4357309, + 1.2417183, 0.0589944}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 1}), + SlaterTypeAtomicShell( + 2, + std::vector{55.206878, 44.712489, 27.589169, 15.860443, + 14.874501, 13.018575, 9.469002, 4.890660, + 3.350299, 2.218200, 1.205350}, + std::vector{3, 4, 4, 3, 4, 4, 4, 3, 3, 3, 3}, + std::vector{ + 0.0027957, 0.0097982, 0.0419619, 0.4812522, 0.0262984, + 0.3922233, 0.1348872, 0.0025978, -0.0001471, -0.0000723, + 0.0000076, -0.0006319, -0.0022166, -0.0063956, -0.2515393, + 0.1121274, -0.3476807, -0.0067565, 0.6285412, 0.4680188, + 0.0448103, -0.0000061}, + std::vector{5, 5}, std::vector{5, 5})})}}; diff --git a/include/integratorxx/atomic_densities/k99l_neutral.hpp b/include/integratorxx/atomic_densities/k99l_neutral.hpp new file mode 100644 index 0000000..fc54e2f --- /dev/null +++ b/include/integratorxx/atomic_densities/k99l_neutral.hpp @@ -0,0 +1,2588 @@ +#include "SlaterAtomicShell.hpp" +#include +static const std::map k99l_neutral{ + {1, + SlaterTypeAtom(1, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for H + * + * Etot=-0.5 Ekin=0.5 + */ + SlaterTypeAtomicShell( + 0, std::vector{1.000000}, + std::vector{1}, std::vector{1.0000000}, + std::vector{1}, std::vector{0})})}, + {2, + SlaterTypeAtom(2, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for He + * + * Etot=-2.861679996 Ekin=2.861679997 + */ + SlaterTypeAtomicShell( + 0, + std::vector{6.437494, 3.384356, 2.177906, + 1.455077, 1.354958}, + std::vector{2, 1, 1, 1, 2}, + std::vector{0.0008103, 0.0798826, 0.1801610, + 0.7407925, 0.0272015}, + std::vector{1}, std::vector{1})})}, + {3, + SlaterTypeAtom( + 3, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Li + * + * Etot=-7.432726929 Ekin=7.432726945 + */ + SlaterTypeAtomicShell( + 0, + std::vector{10.335672, 5.553473, 3.453336, 2.416445, + 1.555772, 0.889955, 0.637402, 0.626614}, + std::vector{1, 1, 1, 1, 1, 1, 2, 1}, + std::vector{ + 0.0014270, -0.0514718, -0.1471640, -0.8105589, -0.0077788, + 0.0004098, -0.0005029, -0.0002691, 0.0002728, -0.0059858, + -0.0400549, -0.0273618, -0.1448297, -0.6053390, 0.5955827, + 0.9979831}, + std::vector{1, 1}, std::vector{1, 0})})}, + {4, + SlaterTypeAtom( + 4, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Be + * + * Etot=-14.573023167 Ekin=14.57302313 + */ + SlaterTypeAtomicShell( + 0, + std::vector{12.683501, 8.105927, 5.152556, 3.472467, + 2.349757, 1.406429, 0.821620, 0.786473}, + std::vector{1, 1, 1, 1, 1, 1, 2, 1}, + std::vector{ + -0.0024917, 0.0314015, 0.0849694, 0.8685562, 0.0315855, + -0.0035284, -0.0004149, 0.0012299, 0.0004442, -0.0030990, + -0.0367056, 0.0138910, -0.3598016, -0.2563459, 0.2434108, + 1.1150995}, + std::vector{1, 1}, std::vector{1, 1})})}, + {5, + SlaterTypeAtom( + 5, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for B + * + * Etot=-24.529060725 Ekin=24.529060725 + */ + SlaterTypeAtomicShell( + 0, + std::vector{16.109305, 7.628062, 6.135799, 4.167618, + 2.488602, 1.642523, 0.991698, 0.787218}, + std::vector{2, 1, 2, 1, 1, 2, 1, 1}, + std::vector{ + -0.0005529, -0.2350117, -0.1508924, -0.6421165, -0.0011507, + -0.0008611, 0.0004712, -0.0002323, -0.0001239, 0.0122241, + 0.0355967, -0.1987214, -0.5378967, -0.1199728, 1.4382402, + 0.0299258}, + std::vector{1, 1}, std::vector{1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{12.135370, 5.508493, 3.930298, 2.034395, + 1.301082, 0.919434, 0.787218}, + std::vector{3, 2, 3, 2, 2, 2, 2}, + std::vector{0.0000599, 0.0113751, 0.0095096, 0.1647518, + 0.3367860, 0.4099162, 0.1329396}, + std::vector{1}, std::vector{0})})}, + {6, + SlaterTypeAtom( + 6, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for C + * + * Etot=-37.68861896 Ekin=37.68861896 + */ + SlaterTypeAtomicShell( + 0, + std::vector{18.890445, 9.238787, 7.517513, 5.100368, + 3.276630, 2.270243, 1.192963, 0.930957}, + std::vector{2, 1, 2, 1, 1, 2, 1, 1}, + std::vector{ + -0.0005490, -0.2240196, -0.1458182, -0.6531614, -0.0040799, + -0.0011082, -0.0002033, -0.0000658, -0.0001371, 0.0125129, + 0.0314257, -0.1900434, -0.4731413, -0.0222123, 1.2890026, + 0.0176521}, + std::vector{1, 1}, std::vector{1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{15.083626, 6.565676, 4.729110, 2.494494, + 1.601933, 1.123315, 0.930957}, + std::vector{3, 2, 3, 2, 2, 2, 2}, + std::vector{0.0000552, 0.0137471, 0.0162926, 0.2011747, + 0.3651183, 0.3811596, 0.0951923}, + std::vector{2}, std::vector{0})})}, + {7, + SlaterTypeAtom( + 7, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for N + * + * Etot=-54.400934199 Ekin=54.40093418 + */ + SlaterTypeAtomicShell( + 0, + std::vector{21.666277, 10.957976, 8.981511, 6.085323, + 3.948957, 2.648617, 1.406521, 1.065447}, + std::vector{2, 1, 2, 1, 1, 2, 1, 1}, + std::vector{ + -0.0005456, -0.1970483, -0.1281924, -0.6885659, -0.0102852, + -0.0012032, -0.0003913, -0.0000291, -0.0001302, 0.0186923, + 0.0337130, -0.2066322, -0.4498099, 0.0126996, 1.2313602, + 0.0261302}, + std::vector{1, 1}, std::vector{1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{17.587523, 7.584576, 5.559658, 2.932934, + 1.874157, 1.306305, 1.065447}, + std::vector{3, 2, 3, 2, 2, 2, 2}, + std::vector{0.0000533, 0.0160353, 0.0221910, 0.2314394, + 0.3844061, 0.3515842, 0.0723077}, + std::vector{3}, std::vector{0})})}, + {8, + SlaterTypeAtom( + 8, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for O + * + * Etot=-74.809398459 Ekin=74.809398458 + */ + SlaterTypeAtomicShell( + 0, + std::vector{24.975698, 12.554759, 10.357096, 7.071190, + 4.804646, 2.785958, 1.606267, 1.124194}, + std::vector{2, 1, 2, 1, 1, 2, 1, 1}, + std::vector{ + -0.0004756, -0.1852813, -0.1195096, -0.6980503, -0.0198704, + -0.0014337, -0.0000556, -0.0001180, -0.0001236, 0.0164417, + 0.0288443, -0.1793400, -0.4384450, 0.0752410, 1.1524847, + 0.0142550}, + std::vector{1, 1}, std::vector{1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{20.797000, 8.661006, 6.427925, 3.402194, + 2.135366, 1.425500, 1.124194}, + std::vector{3, 2, 3, 2, 2, 2, 2}, + std::vector{0.0000481, 0.0171803, 0.0268010, 0.2528558, + 0.3853260, 0.3433520, 0.0652167}, + std::vector{3}, std::vector{1})})}, + {9, + SlaterTypeAtom( + 9, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for F + * + * Etot=-99.409349369 Ekin=99.409349306 + */ + SlaterTypeAtomicShell( + 0, + std::vector{27.647598, 14.291092, 11.832995, 8.080680, + 5.633450, 3.182099, 1.812284, 1.208319}, + std::vector{2, 1, 2, 1, 1, 2, 1, 1}, + std::vector{ + -0.0004697, -0.1659861, -0.1073798, -0.7181088, -0.0291976, + -0.0015668, -0.0001671, -0.0001024, -0.0001318, 0.0120793, + 0.0223256, -0.1484346, -0.4452401, 0.1053716, 1.1104016, + 0.0133407}, + std::vector{1, 1}, std::vector{1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{22.939589, 9.684811, 7.284146, 3.846095, + 2.385087, 1.560088, 1.208319}, + std::vector{3, 2, 3, 2, 2, 2, 2}, + std::vector{0.0000474, 0.0187577, 0.0309393, 0.2700273, + 0.3918133, 0.3293205, 0.0568617}, + std::vector{3}, std::vector{2})})}, + {10, + SlaterTypeAtom( + 10, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ne + * + * Etot=-128.547098079 Ekin=128.54709814 + */ + SlaterTypeAtomicShell( + 0, + std::vector{29.214419, 16.354484, + 13.516489, 9.144899, 6.491668, 3.574219, + 2.016153, + 1.304155}, + std::vector{2, 1, 2, 1, 1, 2, 1, 1}, + std::vector{ + -0.0005654, -0.1341233, + -0.0891954, -0.7527202, + -0.0417988, -0.0017244, + -0.0002064, -0.0001014, + -0.0001682, 0.0046073, 0.0131200, -0.1044881, + -0.4632619, 0.1258193, 1.0809135, 0.0127644}, + std::vector{1, 1}, std::vector{1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{ + 25.731219, + 10.674843, 8.124569, 4.295590, 2.648660, 1.710436, + 1.304155}, + std::vector{3, 2, 3, 2, 2, 2, 2}, + std::vector{ + 0.0000409, 0.0203038, + 0.0340866, 0.2801866, + 0.3958489, 0.3203928, + 0.0510413}, + std::vector{3}, + std::vector{3})})}, + {11, + SlaterTypeAtom( + 11, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Na + * + * Etot=-161.85891151 Ekin=161.858911519 + */ + SlaterTypeAtomicShell( + 0, + std::vector{ + 33.255324, 17.591424, + 14.711825, 9.845052, 6.517050, 5.163833, 2.473455, + 1.097424, 0.620107, + 0.603494}, + std::vector{2, 1, 2, 1, 1, 2, 1, 1, 2, 1}, + std::vector{ + 0.0004501, 0.1721192, 0.1153891, 0.7194672, 0.0130293, + 0.0021183, 0.0011034, -0.0000575, -0.0000167, 0.0000400, + -0.0001077, 0.0260931, 0.0324851, -0.2370856, -0.5048822, + -0.0246135, 1.3396630, 0.0054488, 0.0010882, -0.0022657, + 0.0000179, -0.0024656, -0.0035309, 0.0269246, 0.0833110, + -0.0077460, -0.1263390, -0.3585874, 0.8979831, 0.3366263}, + std::vector{1, 1, 1}, std::vector{1, 1, 0}), + SlaterTypeAtomicShell( + 1, + std::vector{28.733630, 11.509522, 8.818515, 4.565004, + 2.734448, 1.904519, 0.603494}, + std::vector{3, 2, 3, 2, 2, 2, 2}, + std::vector{0.0000406, 0.0261868, 0.0469221, 0.3344314, + 0.4892686, 0.1864531, 0.0006350}, + std::vector{3}, std::vector{3})})}, + {12, + SlaterTypeAtom( + 12, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Mg + * + * Etot=-199.61463627 Ekin=199.61463628 + */ + SlaterTypeAtomicShell( + 0, + std::vector{35.988252, 19.193253, 16.093419, + 10.773377, 7.853579, 6.023976, 2.905152, + 1.694174, + 0.750076, + 0.711410}, + std::vector{2, 1, 2, 1, 1, 2, 1, 1, 2, 1}, + std::vector{ + -0.0004360, -0.1729871, -0.1169158, -0.7144360, -0.0148335, + -0.0028713, -0.0011717, 0.0000626, 0.0000076, -0.0000173, + 0.0001304, -0.0094505, -0.0167113, 0.1266857, 0.6252975, + 0.1486317, -1.4729320, -0.0053579, -0.0001472, 0.0003601, + 0.0000306, 0.0007143, -0.0009558, 0.0081759, 0.1267181, + 0.0042013, -0.0558535, -0.6244636, 0.5390530, 0.7823663}, + std::vector{1, 1, 1}, std::vector{1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{32.077221, 12.495413, 9.644163, 5.042248, + 3.070882, 2.086080, 0.711410}, + std::vector{3, 2, 3, 2, 2, 2, 2}, + std::vector{0.0000356, 0.0286249, 0.0513208, 0.3387086, + 0.5624952, 0.0909855, 0.0006711}, + std::vector{3}, std::vector{3})})}, + {13, + SlaterTypeAtom( + 13, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Al + * + * Etot=-241.876707201 Ekin=241.876707151 + */ + SlaterTypeAtomicShell( + 0, + std::vector{39.496080, 28.634791, 13.079059, + 11.239687, 5.819769, 4.390969, 3.270281, + 1.825554, + 0.707141, + 0.647998}, + std::vector{1, 1, 1, 2, 1, 2, 1, 1, 2, 1}, + std::vector{ + 0.0016984, -0.0106334, -0.9324788, -0.0712122, -0.0047377, + -0.0037917, 0.0042404, -0.0003400, -0.0000438, 0.0000858, + -0.0006857, 0.0030978, 0.2903958, 0.1788086, 0.4039318, + -0.1398263, -1.3388160, -0.0020328, 0.0001916, -0.0005141, + -0.0001786, 0.0007977, 0.0593803, 0.0376137, 0.4131777, + 0.3590308, -0.8526617, -0.8245610, -0.6786038, 2.1291109}, + std::vector{1, 1, 1}, std::vector{1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{32.912282, 19.759796, 11.877702, 7.686895, + 5.052741, 3.511684, 2.582466, 1.012303, + 0.703112, 0.647998}, + std::vector{2, 2, 2, 2, 2, 2, 2, 2, 2, 3}, + std::vector{ + -0.0000924, 0.0018114, 0.0035228, 0.1462357, 0.3034811, + 0.5033633, 0.0995579, 0.0023526, -0.0008711, 0.0002671, + 0.0000180, -0.0003532, -0.0002071, -0.0259716, -0.0684621, + -0.0224624, -0.1694494, 0.3150565, 0.7451950, 0.0230875}, + std::vector{3, 1}, std::vector{3, 0})})}, + {14, + SlaterTypeAtom( + 14, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Si + * + * Etot=-288.854362454 Ekin=288.854362538 + */ + SlaterTypeAtomicShell( + 0, + std::vector{40.744005, 32.345799, 14.154495, + 12.216360, 6.257945, 4.879641, 3.586780, + 2.070236, + 0.975003, + 0.770863}, + std::vector{1, 1, 1, 2, 1, 2, 1, 1, 1, 1}, + std::vector{ + 0.0027330, -0.0101378, -0.9311367, -0.0745227, + -0.0042718, -0.0034503, 0.0037882, -0.0003537, + 0.0001180, -0.0000551, 0.0010884, -0.0032055, + -0.2917220, -0.1774382, -0.3282571, 0.3203634, + 1.0983224, 0.0013121, 0.0012855, -0.0003025, + -0.0003241, 0.0009458, 0.0659012, 0.0416884, + 0.6266028, 0.5323327, -1.3386717, -0.8164418, + 1.6628928, -0.0327784}, + std::vector{1, 1, 1}, std::vector{1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{ + 35.986281, 20.811651, + 11.079502, 8.569582, 5.733707, 4.091940, 3.057286, + 1.252393, 0.870155, + 0.770863}, + std::vector{2, 2, 2, 2, 2, 2, 2, 2, 2, 3}, + std::vector{ + -0.0000771, 0.0019986, 0.0027286, 0.1324846, 0.2686232, + 0.5215984, 0.1236799, 0.0026814, -0.0007868, 0.0002433, + 0.0000186, -0.0004618, 0.0010049, -0.0298094, -0.0732137, + -0.0253179, -0.2177402, 0.3957806, 0.6899150, 0.0234931}, + std::vector{3, 2}, std::vector{3, 0})})}, + {15, + SlaterTypeAtom( + 15, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for P + * + * Etot=-340.718780875 Ekin=340.718780873 + */ + SlaterTypeAtomicShell( + 0, + std::vector{46.439666, 23.444385, 19.934302, 12.335517, + 11.479363, 6.165177, 4.690649, 2.631803, + 1.110511, + 0.885109}, + std::vector{2, 1, 2, 2, 1, 2, 2, 1, 1, 1}, + std::vector{ + -0.0003053, -0.2060038, -0.1348631, 0.1932441, -0.8490745, + -0.0023024, 0.0004126, -0.0001709, 0.0000788, -0.0000352, + -0.0000832, 0.0429022, 0.0434537, 0.0832682, -0.5222080, + 0.4398440, 0.6399510, 0.0289095, 0.0010930, -0.0000757, + 0.0000516, 0.0230913, 0.0169021, 0.0630092, 0.1114601, + 0.1136681, -0.1938357, -1.0898485, 1.6678177, -0.0576567}, + std::vector{1, 1, 1}, std::vector{1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{37.277335, 18.380101, 10.933923, 9.369244, + 5.290342, 3.672062, 3.427525, 1.537478, + 1.075424, 0.885109}, + std::vector{2, 3, 2, 3, 2, 3, 2, 2, 2, 2}, + std::vector{ + -0.0000830, -0.0037430, 0.1235617, 0.0793192, 0.5133664, + -0.1399868, 0.4681291, 0.0021171, -0.0005972, 0.0002485, + 0.0000233, 0.0009662, -0.0317780, -0.0258695, -0.0918254, + 0.0001315, -0.2476404, 0.3847957, 0.5829971, 0.1655351}, + std::vector{3, 3}, std::vector{3, 0})})}, + {16, + SlaterTypeAtom( + 16, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for S + * + * Etot=-397.504895877 Ekin=397.50489583 + */ + SlaterTypeAtomicShell( + 0, + std::vector{48.422248, 25.147985, 21.424545, 12.574205, + 11.445276, 6.468338, 5.067763, 2.950475, + 1.274078, + 0.935274}, + std::vector{2, 1, 2, 2, 1, 2, 2, 1, 1, 1}, + std::vector{ + -0.0003311, -0.2185996, -0.1458971, 0.2712632, -0.8952737, + -0.0006092, -0.0004666, 0.0002312, 0.0000167, 0.0000022, + -0.0000964, 0.0340191, 0.0353772, 0.1313550, -0.5589279, + 0.5184366, 0.5633707, 0.0316144, 0.0018838, -0.0001474, + 0.0000376, 0.0034601, 0.0007431, 0.0178604, 0.2001706, + 0.1462161, -0.2861706, -1.0966241, 1.6354332, 0.0090317}, + std::vector{1, 1, 1}, std::vector{1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{40.400452, 19.793965, 11.660972, 10.088606, + 5.687485, 3.866997, 3.641627, 1.835517, + 1.197266, 0.935274}, + std::vector{2, 3, 2, 3, 2, 3, 2, 2, 2, 2}, + std::vector{ + -0.0000773, -0.0034844, 0.1229454, 0.0714001, 0.5908461, + -0.1122147, 0.3682991, 0.0025488, 0.0001394, 0.0002639, + 0.0000233, 0.0009714, -0.0352972, -0.0278951, -0.0770693, + 0.0839057, -0.3602018, 0.4024984, 0.5932585, 0.1586131}, + std::vector{3, 3}, std::vector{3, 1})})}, + {17, + SlaterTypeAtom( + 17, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Cl + * + * Etot=-459.482072328 Ekin=459.482072308 + */ + SlaterTypeAtomicShell( + 0, + std::vector{52.549831, 26.643633, 22.754804, 14.248239, + 13.203531, 6.587648, 5.115487, 3.103725, + 1.427728, + 1.006380}, + std::vector{2, 1, 2, 2, 1, 2, 2, 1, 1, 1}, + std::vector{ + -0.0002524, -0.1814618, -0.1155390, 0.2068512, -0.9022700, + -0.0017631, 0.0004191, -0.0000254, 0.0000530, -0.0000081, + -0.0000722, 0.0445893, 0.0426753, 0.0759190, -0.5277537, + 0.7717007, 0.3283319, 0.0097044, 0.0032987, -0.0004079, + 0.0000402, 0.0037577, 0.0006709, 0.0227232, 0.1486623, + 0.0455228, -0.4489641, -0.8603633, 1.6497514, 0.0275982}, + std::vector{1, 1, 1}, std::vector{1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{44.251905, 21.017294, 12.370142, 10.884681, + 6.217866, 4.148675, 3.863174, 2.015464, + 1.296207, 1.006380}, + std::vector{2, 3, 2, 3, 2, 3, 2, 2, 2, 2}, + std::vector{ + -0.0000618, -0.0032830, 0.1185708, 0.0572152, 0.6133383, + -0.1362286, 0.3818518, 0.0021977, 0.0008173, 0.0002335, + 0.0000198, 0.0009768, -0.0369629, -0.0262659, -0.0707982, + 0.1675670, -0.4534267, 0.4593440, 0.5677005, 0.1293086}, + std::vector{3, 3}, std::vector{3, 2})})}, + {18, + SlaterTypeAtom( + 18, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ar + * + * Etot=-526.817512711 Ekin=526.81751275 + */ + SlaterTypeAtomicShell( + 0, + std::vector{56.024242, 28.780167, 24.513979, 15.086379, + 14.036870, 6.944507, 5.309126, 3.317218, + 1.567689, + 1.087214}, + std::vector{2, 1, 2, 2, 1, 2, 2, 1, 1, 1}, + std::vector{ + -0.0002716, -0.1710204, -0.1141106, 0.2067242, -0.9132755, + -0.0023696, 0.0014535, -0.0007953, 0.0001863, -0.0000528, + -0.0000726, 0.0279220, 0.0286702, 0.0504759, -0.4849957, + 0.8698150, 0.2352997, 0.0088439, 0.0035499, -0.0003098, + 0.0000359, -0.0112280, -0.0115130, -0.0092934, 0.1752091, + -0.0561490, -0.5300804, -0.6888917, 1.6573375, 0.0288341}, + std::vector{1, 1, 1}, std::vector{1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{47.041050, 22.401098, 13.130477, 11.806433, + 6.780130, 4.415953, 4.077204, 2.200943, + 1.412360, 1.087214}, + std::vector{2, 3, 2, 3, 2, 3, 2, 2, 2, 2}, + std::vector{ + -0.0000613, -0.0031317, 0.1112736, 0.0425036, 0.6339220, + -0.1615644, 0.4032696, 0.0011903, -0.0000900, 0.0000414, + 0.0000202, 0.0009789, -0.0362469, -0.0220688, -0.0797423, + 0.2302612, -0.5119924, 0.4891912, 0.5535620, 0.1126417}, + std::vector{3, 3}, std::vector{3, 3})})}, + {19, + SlaterTypeAtom( + 19, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for K + * + * Etot=-599.164786322 Ekin=599.164786943 + */ + SlaterTypeAtomicShell( + 0, + std::vector{ + 48.538420, 27.178567, + 20.222095, + 13.592814, 7.647812, 6.078224, 6.077278, 3.343549, + 2.301557, 1.828604, + 0.555573, 0.543093}, + std::vector{1, 3, 1, 3, 2, 2, 1, 1, 2, 1, 2, 1}, + std::vector{ + -0.0021779, 0.0160836, 0.8188097, -0.0820494, -0.2158247, + -0.0516150, 0.4738586, 0.0002719, 0.0022252, -0.0034121, + -0.0000294, 0.0000659, 0.0018667, -0.0102939, -0.1600968, + 0.0858637, 1.0427023, 0.4336528, -0.6297128, 0.0197017, + -0.0061072, 0.0119124, 0.0000855, -0.0002013, -0.0004251, + 0.0025019, 0.0524504, -0.0473839, -0.0769891, -0.6445475, + 0.2904986, -0.9094076, 0.1553851, 1.7112623, 0.0002823, + 0.0009316, 0.0001342, -0.0007921, -0.0103128, 0.0069127, + 0.0276908, 0.0821168, -0.1213107, 0.7609340, 0.5911440, + -1.2959807, 1.4608731, -0.5367940}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 0}), + SlaterTypeAtomicShell( + 1, + std::vector{45.863372, 23.956536, 13.445654, 9.280990, + 7.576272, 5.560868, 2.249040, 1.893851, + 1.290943, 0.543093}, + std::vector{2, 3, 2, 3, 2, 2, 3, 2, 2, 2}, + std::vector{ + 0.0000979, 0.0031928, -0.0866450, 0.0491453, -0.6660660, + -0.3268554, 0.0071913, -0.0110148, 0.0005219, -0.0000095, + 0.0000354, 0.0011040, -0.0153622, 0.0620133, -0.1765320, + -0.3537264, -0.3401560, 1.3735350, 0.1055549, 0.0010773}, + std::vector{3, 3}, std::vector{3, 3})})}, + {20, + SlaterTypeAtom( + 20, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ca + * + * Etot=-676.758185346 Ekin=676.758185367 + */ + SlaterTypeAtomicShell( + 0, + std::vector{ + 55.025070, 29.333512, + 21.316999, + 14.563031, 8.075590, 6.763191, 6.263443, 2.577548, + 1.816117, 1.500414, + 0.648569, 0.625347}, + std::vector{1, 3, 1, 3, 2, 1, 2, 2, 1, 1, 2, 1}, + std::vector{ + 0.0014243, -0.0129567, -0.8089442, 0.0880966, 0.2394273, + -0.4761799, 0.0057173, -0.0121835, 0.0270307, -0.0101743, + -0.0001830, 0.0004971, 0.0011968, -0.0080951, -0.1512063, + 0.0841105, 1.1633902, -0.6311882, 0.3048988, -0.0308593, + 0.0813505, -0.0336703, -0.0008710, 0.0022405, -0.0003224, + 0.0023876, 0.0513616, -0.0422994, -0.1555700, 0.1971616, + -0.7182685, 1.1275138, 0.0596091, 0.1150448, 0.0023577, + -0.0063252, 0.0000534, -0.0004143, -0.0124182, 0.0122024, + 0.0109921, -0.0234364, 0.2343941, -0.1255387, 0.7711321, + -1.3923824, 0.9198284, 0.3965575}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{47.329816, 25.506017, 14.174024, 10.249231, + 8.135533, 5.982999, 2.330080, 2.056882, + 1.208793, 0.625347}, + std::vector{2, 3, 2, 3, 2, 2, 3, 2, 2, 2}, + std::vector{ + -0.0001120, -0.0030349, 0.0875599, -0.0316728, 0.6426078, + 0.3319706, -0.0052519, 0.0078938, 0.0001322, -0.0000458, + 0.0000462, 0.0011800, -0.0123491, 0.0651053, -0.2032528, + -0.3647918, -0.3608637, 1.4758199, 0.0280494, 0.0009427}, + std::vector{3, 3}, std::vector{3, 3})})}, + {21, + SlaterTypeAtom( + 21, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Sc + * + * Etot=-759.735717426 Ekin=759.735717464 + */ + SlaterTypeAtomicShell( + 0, + std::vector{ + 57.498657, 30.833372, + 22.361741, + 15.415630, 8.610080, 7.168035, 6.645788, 2.786909, + 1.961794, 1.588713, + 0.676641, 0.648242}, + std::vector{1, 3, 1, 3, 2, 1, 2, 2, 1, 1, 2, 1}, + std::vector{ + 0.0013535, -0.0120567, -0.8097734, 0.0850621, 0.2364389, + -0.4739453, 0.0098844, -0.0114407, 0.0244354, -0.0087021, + -0.0002086, 0.0005320, 0.0011952, -0.0079309, -0.1476516, + 0.0757744, 1.1816323, -0.6559424, 0.3207819, -0.0216877, + 0.0583152, -0.0233924, -0.0008048, 0.0019576, -0.0003663, + 0.0026465, 0.0513897, -0.0379520, -0.1710157, 0.1997936, + -0.7562835, 1.0889723, 0.1562578, 0.0876539, 0.0019419, + -0.0049723, 0.0000757, -0.0005611, -0.0124367, 0.0104546, + 0.0175538, -0.0264782, 0.2368120, -0.1453304, 0.6523544, + -1.2841630, 0.8249110, 0.5079875}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{49.842595, 26.926323, 14.480714, 10.991611, + 8.492563, 6.351088, 2.504892, 2.207803, + 1.218695, 0.648242}, + std::vector{2, 3, 2, 3, 2, 2, 3, 2, 2, 2}, + std::vector{ + -0.0001098, -0.0029004, 0.1212841, 0.0252489, 0.5745498, + 0.3129971, -0.0040544, 0.0065817, 0.0000003, -0.0000130, + 0.0000463, 0.0011609, -0.0132121, 0.0647350, -0.2299509, + -0.3568473, -0.4283568, 1.5576307, 0.0198377, 0.0006167}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{18.112701, 13.806782, 6.306244, 4.161485, + 2.673453, 1.714319, 1.087439, 0.648242}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3}, + std::vector{0.0014099, 0.0065323, 0.0442052, 0.1963389, + 0.3283685, 0.3818901, 0.2068560, + 0.0039745}, + std::vector{1}, std::vector{0})})}, + {22, + SlaterTypeAtom( + 22, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ti + * + * Etot=-848.405996326 Ekin=848.405996466 + */ + SlaterTypeAtomicShell( + 0, + std::vector{ + 60.289820, 32.299759, + 23.400426, + 16.255875, 9.147991, 7.563319, 7.020328, 2.979739, + 2.113198, 1.621186, + 0.695769, 0.664512}, + std::vector{1, 3, 1, 3, 2, 1, 2, 2, 1, 1, 2, 1}, + std::vector{ + 0.0012926, -0.0114605, -0.8115312, 0.0816377, 0.2319387, + -0.4691019, 0.0151634, -0.0092445, 0.0178036, -0.0051991, + -0.0001907, 0.0004695, 0.0012040, -0.0079860, -0.1445460, + 0.0678589, 1.1968416, -0.6774864, 0.3399134, -0.0077091, + 0.0247033, -0.0091746, -0.0005404, 0.0012567, -0.0004162, + 0.0029768, 0.0512115, -0.0333406, -0.1871558, 0.1939240, + -0.7919167, 1.0154717, 0.3017204, 0.0505037, 0.0015326, + -0.0038174, 0.0000950, -0.0006892, -0.0122019, 0.0087036, + 0.0232607, -0.0266562, 0.2360628, -0.1497692, 0.4197396, + -1.0646875, 0.7481798, 0.5949651}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{51.299773, 28.672833, 15.156461, 11.712761, + 8.887041, 6.711089, 2.704253, 2.368233, + 1.251387, 0.664512}, + std::vector{2, 3, 2, 3, 2, 2, 3, 2, 2, 2}, + std::vector{ + -0.0001234, -0.0027166, 0.1326522, 0.0474760, 0.5621316, + 0.2922171, -0.0039271, 0.0066401, -0.0000545, 0.0000022, + 0.0000553, 0.0011428, -0.0117801, 0.0659143, -0.2596441, + -0.3439841, -0.4611724, 1.5999717, 0.0168819, 0.0003730}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{19.104138, 14.658566, 6.716801, 4.401956, + 2.774678, 1.786630, 1.173680, 0.664512}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3}, + std::vector{0.0015070, 0.0067172, 0.0517986, 0.2309356, + 0.3736332, 0.3511324, 0.1432688, + 0.0010332}, + std::vector{2}, std::vector{0})})}, + {23, + SlaterTypeAtom( + 23, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for V + * + * Etot=-942.884337023 Ekin=942.88433725 + */ + SlaterTypeAtomicShell( + 0, + std::vector{ + 62.875206, 33.885936, + 24.457516, + 17.072833, 9.664612, 7.931088, 7.398658, 3.165850, + 2.266794, 1.653671, + 0.712906, 0.679086}, + std::vector{1, 3, 1, 3, 2, 1, 2, 2, 1, 1, 2, 1}, + std::vector{ + 0.0012909, -0.0109967, -0.8120094, 0.0800390, 0.2292945, + -0.4691224, 0.0218235, -0.0057876, 0.0102509, -0.0024138, + -0.0001130, 0.0002730, 0.0011806, -0.0076674, -0.1411707, + 0.0634607, 1.2164420, -0.7029589, 0.3505894, -0.0016772, + 0.0115395, -0.0042834, -0.0003807, 0.0008539, -0.0004552, + 0.0031646, 0.0506617, -0.0296552, -0.2029999, 0.1897509, + -0.8210458, 0.9478692, 0.4151478, 0.0348454, 0.0012974, + -0.0031509, 0.0001085, -0.0007610, -0.0118527, 0.0073434, + 0.0277623, -0.0264696, 0.2348937, -0.1477421, 0.2745684, + -0.9304527, 0.6846603, 0.6630154}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{52.631581, 30.669617, 15.795601, 12.334590, + 9.301379, 7.202975, 2.875851, 2.512619, + 1.286363, 0.679086}, + std::vector{2, 3, 2, 3, 2, 2, 3, 2, 2, 2}, + std::vector{ + -0.0001616, -0.0026656, 0.1549919, 0.0894393, 0.4829740, + 0.3085893, -0.0058317, 0.0094079, 0.0000017, -0.0000114, + 0.0000688, 0.0011174, -0.0154736, 0.0580016, -0.2474715, + -0.3520829, -0.4947799, 1.6362242, 0.0144381, 0.0002403}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{20.118919, 15.491232, 6.994400, 4.606157, + 2.904122, 1.867151, 1.237729, 0.679086}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3}, + std::vector{0.0015727, 0.0069095, 0.0636709, 0.2528675, + 0.3894624, 0.3290693, 0.1139047, + 0.0004478}, + std::vector{3}, std::vector{0})})}, + {24, + SlaterTypeAtom( + 24, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Cr + * + * Etot=-1043.356375551 Ekin=1043.356375276 + */ + SlaterTypeAtomicShell( + 0, + std::vector{64.134378, 35.194142, 25.454647, 17.708856, + 10.162320, 8.462113, 7.730720, 3.367156, + 2.316006, + 1.537736, + 0.699029, + 0.666408}, + std::vector{1, 3, 1, 3, 2, 1, 2, 2, 1, 1, 2, 1}, + std::vector{ + 0.0014070, -0.0110748, -0.8205511, 0.0761683, 0.2044973, + -0.4296209, 0.0176638, -0.0006641, 0.0011192, -0.0003022, + -0.0000369, 0.0000828, 0.0013617, -0.0081648, -0.1421246, + 0.0599032, 1.2251393, -0.6888312, 0.3341940, 0.0090967, + -0.0087407, 0.0016728, 0.0002488, -0.0001737, -0.0005803, + 0.0036795, 0.0511424, -0.0255986, -0.2189007, 0.1536706, + -0.8498296, 0.7471068, 0.6925615, 0.0040460, -0.0000902, + -0.0003102, 0.0001431, -0.0009114, -0.0111788, 0.0052243, + 0.0345145, -0.0293029, 0.2087831, -0.1862060, 0.0821551, + -0.6016914, 0.7365812, 0.5513708}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 0}), + SlaterTypeAtomicShell( + 1, + std::vector{54.119911, 32.347673, 16.361604, 12.870877, + 9.705787, 7.719275, 3.078646, 2.646262, + 1.486704, 0.666408}, + std::vector{2, 3, 2, 3, 2, 2, 3, 2, 2, 2}, + std::vector{ + 0.0001884, 0.0026512, -0.1813594, -0.1328680, -0.3895478, + -0.3337827, 0.0086859, -0.0135009, 0.0000344, -0.0000003, + 0.0000694, 0.0010266, -0.0207855, 0.0473677, -0.2172009, + -0.3681273, -0.5436322, 1.6733666, 0.0276998, 0.0002341}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{21.010126, 16.248352, 7.319431, 4.807319, + 3.023447, 1.852525, 1.147532, 0.666408}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3}, + std::vector{0.0015166, 0.0064929, 0.0676131, 0.2519614, + 0.3670945, 0.3299536, 0.1666695, + 0.0029340}, + std::vector{5}, std::vector{0})})}, + {25, + SlaterTypeAtom( + 25, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Mn + * + * Etot=-1149.866250992 Ekin=1149.86625098 + */ + SlaterTypeAtomicShell( + 0, + std::vector{65.615997, 36.493146, 26.490049, 18.586295, + 10.770334, 8.946835, 8.222221, 3.543574, + 2.463906, + 1.753364, + 0.743164, + 0.704089}, + std::vector{1, 3, 1, 3, 2, 1, 2, 2, 1, 1, 2, 1}, + std::vector{ + 0.0014463, -0.0107434, -0.8220966, 0.0720820, 0.1992914, + -0.4216099, 0.0184424, -0.0016396, 0.0028177, -0.0007213, + -0.0000471, 0.0001067, 0.0014587, -0.0083000, -0.1380048, + 0.0503941, 1.2042773, -0.7054832, 0.3774786, 0.0124346, + -0.0140740, 0.0028051, 0.0000751, -0.0002025, -0.0006400, + 0.0038340, 0.0507934, -0.0224750, -0.2078934, 0.1832236, + -0.8549556, 0.8735202, 0.5392017, 0.0071191, 0.0005806, + -0.0012804, 0.0001531, -0.0009212, -0.0114276, 0.0051239, + 0.0291037, -0.0268992, 0.2278690, -0.1521253, 0.1876799, + -0.8254018, 0.5930836, 0.7464188}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{52.083296, 33.806616, 17.420626, 13.771396, + 10.071962, 7.859711, 3.390377, 2.922745, + 1.760084, 0.704089}, + std::vector{2, 3, 2, 3, 2, 2, 3, 2, 2, 2}, + std::vector{ + 0.0003267, 0.0029985, -0.1595513, -0.1056915, -0.5160790, + -0.2542325, 0.0062024, -0.0105067, 0.0001346, -0.0000051, + 0.0001576, 0.0013846, -0.0179796, 0.0479529, -0.2875608, + -0.3226370, -0.4273169, 1.5653185, 0.0402565, 0.0005669}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{22.242214, 17.176523, 7.574462, 5.005562, + 3.189753, 2.065915, 1.380034, 0.704089}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3}, + std::vector{0.0016172, 0.0070783, 0.0876536, 0.2828126, + 0.3894977, 0.2966932, 0.0910173, + 0.0002949}, + std::vector{5}, std::vector{0})})}, + {26, + SlaterTypeAtom( + 26, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Fe + * + * Etot=-1262.443664689 Ekin=1262.443664533 + */ + SlaterTypeAtomicShell( + 0, + std::vector{67.039851, 37.739652, 27.502599, 19.356262, + 11.285074, 9.367472, 8.606144, 3.732769, + 2.599956, + 1.821430, + 0.761362, + 0.718583}, + std::vector{1, 3, 1, 3, 2, 1, 2, 2, 1, 1, 2, 1}, + std::vector{ + 0.0015184, -0.0106577, -0.8270191, 0.0684367, 0.1913138, + -0.4067605, 0.0184840, -0.0013668, 0.0022126, -0.0004942, + -0.0000288, 0.0000656, 0.0015653, -0.0084246, -0.1366790, + 0.0465236, 1.2166161, -0.7169434, 0.3776062, 0.0112197, + -0.0118535, 0.0022054, 0.0000615, -0.0001613, -0.0007443, + 0.0041962, 0.0507275, -0.0186454, -0.2225578, 0.1830688, + -0.8655540, 0.8448811, 0.5820667, 0.0072140, 0.0004931, + -0.0010485, 0.0001824, -0.0010310, -0.0113065, 0.0039089, + 0.0331594, -0.0278507, 0.2247979, -0.1544478, 0.1586917, + -0.7886902, 0.5508906, 0.7825338}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{53.958628, 35.552297, 18.139253, 14.420001, + 10.398009, 8.220976, 3.526362, 3.043306, + 1.742634, 0.718583}, + std::vector{2, 3, 2, 3, 2, 2, 3, 2, 2, 2}, + std::vector{ + 0.0003539, 0.0029461, -0.1710197, -0.1274017, -0.5025877, + -0.2353695, 0.0067758, -0.0113099, 0.0000849, -0.0000036, + 0.0001605, 0.0013264, -0.0188217, 0.0451461, -0.3154501, + -0.2957612, -0.4783269, 1.6251079, 0.0289213, 0.0004127}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{23.292198, 18.020857, 7.891984, 5.208309, + 3.309121, 2.122232, 1.404987, 0.718583}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3}, + std::vector{0.0016054, 0.0069661, 0.0981612, 0.2946262, + 0.3855914, 0.2865224, 0.0891893, + 0.0003175}, + std::vector{5}, std::vector{1})})}, + {27, + SlaterTypeAtom( + 27, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Co + * + * Etot=-1381.414552237 Ekin=1381.414552303 + */ + SlaterTypeAtomicShell( + 0, + std::vector{67.880489, 38.904351, 28.510966, 20.112028, + 11.806173, 9.803070, 8.992577, 3.918210, + 2.729885, + 1.879157, + 0.777145, + 0.731328}, + std::vector{1, 3, 1, 3, 2, 1, 2, 2, 1, 1, 2, 1}, + std::vector{ + 0.0016519, -0.0106873, -0.8324281, 0.0646578, 0.1823705, + -0.3900133, 0.0179088, -0.0012577, 0.0019348, -0.0003799, + -0.0000192, 0.0000448, 0.0017335, -0.0086171, -0.1356177, + 0.0425608, 1.2252448, -0.7256070, 0.3791099, 0.0105801, + -0.0107103, 0.0019459, 0.0000728, -0.0001761, -0.0008763, + 0.0045437, 0.0506573, -0.0149959, -0.2355081, 0.1824936, + -0.8737051, 0.8165784, 0.6226990, 0.0066042, 0.0004254, + -0.0008723, 0.0002176, -0.0011301, -0.0111567, 0.0027678, + 0.0366503, -0.0286333, 0.2205742, -0.1557938, 0.1307983, + -0.7520185, 0.5133699, 0.8140936}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{55.920505, 37.045603, 18.633841, 14.903522, + 10.432654, 8.406347, 3.670304, 3.170172, + 1.761172, 0.731328}, + std::vector{2, 3, 2, 3, 2, 2, 3, 2, 2, 2}, + std::vector{ + 0.0003577, 0.0028804, -0.2018877, -0.1726462, -0.4948883, + -0.1701586, 0.0067602, -0.0113278, 0.0000588, -0.0000032, + 0.0001529, 0.0012416, -0.0243883, 0.0375714, -0.3921162, + -0.2087478, -0.5137528, 1.6628454, 0.0237833, 0.0003303}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{24.172555, 18.786883, 8.199042, 5.406704, + 3.442626, 2.205849, 1.453653, 0.731328}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3}, + std::vector{0.0016416, 0.0069451, 0.1090000, 0.3032906, + 0.3786483, 0.2778314, 0.0886884, + 0.0003702}, + std::vector{5}, std::vector{2})})}, + {28, + SlaterTypeAtom( + 28, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ni + * + * Etot=-1506.870907385 Ekin=1506.870907195 + */ + SlaterTypeAtomicShell( + 0, + std::vector{69.226787, 40.178379, 29.523561, 20.825217, + 12.335507, 10.337108, 9.378273, 4.099637, + 2.864936, + 1.935115, + 0.792121, + 0.743304}, + std::vector{1, 3, 1, 3, 2, 1, 2, 2, 1, 1, 2, 1}, + std::vector{ + 0.0017658, -0.0107113, -0.8374316, 0.0619061, 0.1699209, + -0.3687887, 0.0143053, -0.0009768, 0.0014735, -0.0002638, + -0.0000136, 0.0000313, 0.0018570, -0.0087143, -0.1342940, + 0.0393427, 1.2262784, -0.7239600, 0.3756137, 0.0103158, + -0.0100626, 0.0016998, 0.0000688, -0.0001625, -0.0009759, + 0.0047668, 0.0502696, -0.0119704, -0.2460914, 0.1796269, + -0.8799152, 0.7883898, 0.6611584, 0.0077496, 0.0004304, + -0.0008707, 0.0002430, -0.0011894, -0.0109214, 0.0018380, + 0.0394703, -0.0288664, 0.2164175, -0.1552368, 0.1041796, + -0.7171979, 0.4802792, 0.8403130}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{57.991635, 38.657440, 19.286668, 15.489265, + 10.586878, 8.440193, 3.827276, 3.303890, + 1.779584, 0.743304}, + std::vector{2, 3, 2, 3, 2, 2, 3, 2, 2, 2}, + std::vector{ + 0.0003620, 0.0027976, -0.2159150, -0.1949848, -0.5233394, + -0.1068114, 0.0063656, -0.0108025, 0.0000461, -0.0000041, + 0.0001624, 0.0012422, -0.0289838, 0.0291239, -0.4624462, + -0.1291237, -0.5416602, 1.6930962, 0.0204043, 0.0002391}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{25.058793, 19.533825, 8.512016, 5.601915, + 3.574636, 2.291306, 1.503687, 0.743304}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3}, + std::vector{0.0016742, 0.0069410, 0.1192748, 0.3109624, + 0.3717722, 0.2701439, 0.0879630, + 0.0004043}, + std::vector{5}, std::vector{3})})}, + {29, + SlaterTypeAtom( + 29, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Cu + * + * Etot=-1638.96374119 Ekin=1638.96374177 + */ + SlaterTypeAtomicShell( + 0, + std::vector{70.189946, 41.413051, 30.509673, 21.267318, + 12.847734, 11.192606, 9.712223, 4.300548, + 2.962479, + 1.808143, + 0.734806, + 0.690642}, + std::vector{1, 3, 1, 3, 2, 1, 2, 2, 1, 1, 2, 1}, + std::vector{ + 0.0020207, -0.0112026, -0.8472089, 0.0598742, 0.1357926, + -0.3188339, 0.0046457, 0.0001248, -0.0001392, 0.0000234, + 0.0000022, -0.0000049, 0.0021026, -0.0091215, -0.1358250, + 0.0385834, 1.2088221, -0.6818951, 0.3440914, 0.0083590, + -0.0064395, 0.0010196, 0.0000782, -0.0001733, 0.0010930, + -0.0049447, -0.0499657, 0.0096176, 0.2570659, -0.1516614, + 0.8899292, -0.6585943, -0.8211081, -0.0075510, -0.0003114, + 0.0001435, 0.0002480, -0.0011285, -0.0090394, 0.0000444, + 0.0411595, -0.0273862, 0.1693738, -0.1563653, 0.0024820, + -0.4028755, 0.6643383, 0.5359542}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 0}), + SlaterTypeAtomicShell( + 1, + std::vector{60.062765, 40.162787, 19.924473, 16.048602, + 10.881331, 8.741628, 3.948760, 3.385906, + 1.798822, 0.690642}, + std::vector{2, 3, 2, 3, 2, 2, 3, 2, 2, 2}, + std::vector{ + 0.0003582, 0.0027114, -0.2268487, -0.2115354, -0.5151920, + -0.0877481, 0.0077786, -0.0127477, 0.0000192, -0.0000084, + 0.0001546, 0.0011697, -0.0311031, 0.0242955, -0.4931547, + -0.0861930, -0.6165142, 1.7582236, 0.0224578, 0.0000878}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{26.287704, 20.461389, 8.922963, 5.814383, + 3.626597, 2.200138, 1.349920, 0.690642}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3}, + std::vector{0.0015173, 0.0063705, 0.1178186, 0.3137382, + 0.3693059, 0.2781690, 0.1120928, + 0.0011723}, + std::vector{5}, std::vector{5})})}, + {30, + SlaterTypeAtom( + 30, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Zn + * + * Etot=-1777.848115134 Ekin=1777.848115984 + */ + SlaterTypeAtomicShell( + 0, + std::vector{72.171558, 42.777264, 31.527672, 22.081772, + 13.336452, 11.561129, + 10.027114, 4.420748, 3.230588, 2.015129, + 0.818486, + 0.764862}, + std::vector{1, 3, 1, 3, 2, 1, 2, 2, 1, 1, 2, 1}, + std::vector{ + 0.0019769, -0.0107609, -0.8494586, 0.0580937, 0.1366863, + -0.3167347, 0.0052139, -0.0001235, 0.0002172, -0.0000261, + -0.0000022, 0.0000046, 0.0020741, -0.0088027, -0.1335176, + 0.0372026, 1.2357655, -0.6992431, 0.3358924, 0.0096691, + -0.0091453, 0.0009479, 0.0000458, -0.0001038, -0.0011753, + 0.0052002, 0.0488817, -0.0048718, -0.2951158, 0.1540240, + -0.8917698, 0.6694630, 0.8268842, 0.0197176, 0.0009397, + -0.0019831, 0.0002886, -0.0012828, -0.0102453, -0.0001946, + 0.0510630, -0.0240702, 0.2096709, -0.1313166, 0.0055122, + -0.6356594, 0.4198696, 0.8894478}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{62.133895, 41.854760, 20.683667, 16.687144, + 11.270401, 9.043064, 4.115574, 3.555618, + 1.819362, 0.764862}, + std::vector{2, 3, 2, 3, 2, 2, 3, 2, 2, 2}, + std::vector{ + 0.0003765, 0.0026902, -0.2288154, -0.2182349, -0.5142568, + -0.0801772, 0.0072552, -0.0121590, 0.0000238, -0.0000025, + 0.0001517, 0.0011128, -0.0313310, 0.0220066, -0.5172974, + -0.0634072, -0.5877818, 1.7359178, 0.0153842, 0.0001286}, + std::vector{3, 3}, std::vector{3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{26.840425, 21.076327, 9.261571, 6.082216, + 3.860363, 2.445106, 1.590058, 0.764862}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3}, + std::vector{0.0016896, 0.0066854, 0.1293386, 0.3220073, + 0.3716809, 0.2607110, 0.0802155, + 0.0003242}, + std::vector{5}, std::vector{5})})}, + {31, + SlaterTypeAtom( + 31, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ga + * + * Etot=-1923.261007857 Ekin=1923.261007627 + */ + SlaterTypeAtomicShell( + 0, + std::vector{74.163075, 44.111552, 32.554208, 22.941369, + 14.638429, 11.507175, + 10.651417, 6.419062, 3.758419, 2.128908, + 0.715996, + 0.645754}, + std::vector{1, 3, 1, 3, 2, 2, 1, 1, 1, 1, 2, 1}, + std::vector{ + -0.0020125, 0.0107044, 0.8493642, -0.0517435, -0.1167559, + -0.1089497, 0.3844733, -0.0000545, -0.0001774, 0.0000409, + 0.0000080, -0.0000131, 0.0021379, -0.0090307, -0.1184356, + 0.0130268, 0.9606464, 0.8388726, -0.9434169, 0.0481297, + 0.0014032, 0.0004214, 0.0000702, -0.0001202, 0.0010632, + -0.0046042, -0.0506485, 0.0129238, 0.0751663, 0.8689100, + -0.5220104, 1.4389889, -2.2717431, -0.0160811, -0.0003620, + 0.0005797, 0.0002349, -0.0010139, -0.0130995, 0.0058638, + -0.0157824, 0.2528832, -0.0984525, 0.2874108, -0.2434421, + -0.9647349, -0.7955805, 2.1805188}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{65.541676, 44.152054, 22.005072, 17.824611, + 12.176581, 10.192581, 6.855667, 4.730498, + 3.006855, 0.905335, 0.645754}, + std::vector{2, 3, 2, 3, 2, 3, 3, 3, 2, 2, 2}, + std::vector{ + -0.0003531, -0.0024432, 0.1795597, 0.1551185, 0.6582416, + 0.0485330, 0.0027297, 0.0008101, 0.0002605, 0.0000057, + -0.0000046, 0.0001678, 0.0011738, -0.0174948, 0.0378616, + -0.4796254, 0.0568351, 0.4257664, 0.4598884, 0.2161453, + 0.0015260, -0.0004680, -0.0000210, -0.0001513, 0.0026151, + -0.0060864, 0.0830719, -0.0006801, -0.0715253, -0.0179081, + -0.2074242, 0.5634063, 0.5081831}, + std::vector{3, 3, 1}, std::vector{3, 3, 0}), + SlaterTypeAtomicShell( + 2, + std::vector{28.295386, 22.128835, 9.633176, 6.261006, + 3.907149, 2.459171, 1.565609, 0.645754}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3}, + std::vector{0.0016169, 0.0066219, 0.1418965, 0.3508943, + 0.4053581, 0.2240315, 0.0213451, + -0.0000074}, + std::vector{5}, std::vector{5})})}, + {32, + SlaterTypeAtom( + 32, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ge + * + * Etot=-2075.359731251 Ekin=2075.359730662 + */ + SlaterTypeAtomicShell( + 0, + std::vector{76.555432, 45.858462, 33.610460, 23.935761, + 15.346717, 12.026209, + 11.159105, 6.438987, 4.028666, 2.450056, + 0.836054, + 0.758093}, + std::vector{1, 3, 1, 3, 2, 2, 1, 1, 1, 1, 2, 1}, + std::vector{ + -0.0018078, 0.0095437, 0.8454451, -0.0516573, -0.1204391, + -0.1111409, 0.3934758, 0.0006752, -0.0004116, 0.0001034, + 0.0000151, -0.0000258, 0.0019448, -0.0080920, -0.1103075, + 0.0081985, 0.9323112, 0.8888362, -0.9655455, 0.0470433, + -0.0004295, 0.0007647, 0.0001016, -0.0001848, 0.0009669, + -0.0041242, -0.0487858, 0.0126617, 0.0633297, 0.8844335, + -0.5243957, 1.6725097, -2.4962937, -0.0241003, -0.0001309, + 0.0000402, 0.0001918, -0.0008175, -0.0142534, 0.0082456, + -0.0296369, 0.2942394, -0.0975860, 0.3053093, -0.1116297, + -1.2393662, -0.7723292, 2.2389290}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{69.491987, 46.214210, 22.646499, 18.407375, + 12.503901, 10.373220, 7.108357, 5.035482, + 3.291863, 1.061577, 0.758093}, + std::vector{2, 3, 2, 3, 2, 3, 3, 3, 2, 2, 2}, + std::vector{ + -0.0002894, -0.0021391, 0.1874945, 0.1674549, 0.6453349, + 0.0412213, 0.0021424, 0.0009650, 0.0001725, 0.0000048, + -0.0000053, 0.0001467, 0.0010724, -0.0207694, 0.0316648, + -0.4855325, 0.0727783, 0.3973735, 0.4512341, 0.2423111, + 0.0017566, -0.0004771, -0.0000209, -0.0001602, 0.0034417, + -0.0067488, 0.1056609, 0.0000900, -0.0749832, 0.0073854, + -0.3131488, 0.7111911, 0.3907760}, + std::vector{3, 3, 2}, std::vector{3, 3, 0}), + SlaterTypeAtomicShell( + 2, + std::vector{28.893923, 22.744772, 9.975534, 6.535857, + 4.150742, 2.687443, 1.649905, 0.758093}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3}, + std::vector{0.0017565, 0.0068668, 0.1520527, 0.3529406, + 0.4126107, 0.1985465, 0.0121971, + -0.0000393}, + std::vector{5}, std::vector{5})})}, + {33, + SlaterTypeAtom( + 33, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for As + * + * Etot=-2234.238652211 Ekin=2234.238652211 + */ + SlaterTypeAtomicShell( + 0, + std::vector{54.206035, 39.953981, 33.575117, 22.687547, + 14.286912, 13.481918, 6.115775, 5.148299, + 3.641403, + 1.809534, + 1.278811, + 0.859631}, + std::vector{1, 3, 1, 4, 2, 3, 3, 2, 2, 2, 2, 1}, + std::vector{ + -0.0097888, 0.0198534, 0.9797520, -0.0227791, 0.0528492, + -0.0175215, -0.0074662, 0.0102517, -0.0001299, -0.0000951, + 0.0001410, -0.0001060, 0.0472799, -0.0526307, -0.3963765, + 0.1035166, 0.7947179, 0.1934033, -0.0413055, 0.0681277, + -0.0048316, 0.0005478, -0.0005699, 0.0003827, 0.0196598, + -0.0221499, -0.1569388, 0.0387603, 0.4195814, 0.3662879, + -0.1365817, -1.0360940, -0.1315030, 0.0048884, -0.0050606, + 0.0031013, 0.0054786, -0.0062164, -0.0436365, 0.0098545, + 0.1211463, 0.1232891, 0.0138823, -0.2530920, -0.5047831, + 0.4859887, 0.7161727, 0.0695486}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{50.718595, 41.198849, 24.082973, 19.047410, + 13.627410, 6.013469, 5.462364, 4.087596, + 1.841936, 1.059631, 0.859631}, + std::vector{2, 3, 2, 3, 3, 2, 3, 3, 3, 2, 2}, + std::vector{ + -0.0061590, -0.0140545, 0.3456543, 0.4376157, 0.3082380, + 0.0200905, -0.0059676, 0.0015992, -0.0002968, 0.0003860, + -0.0001796, 0.0037916, 0.0084961, -0.1640727, -0.2006209, + -0.2996379, 0.6449960, 0.4353153, 0.1816630, 0.0029471, + -0.0016209, 0.0005881, -0.0009478, -0.0021377, 0.0382923, + 0.0453519, 0.0772161, -0.1889786, -0.0794897, -0.1723025, + 0.2164620, 0.6834376, 0.1978196}, + std::vector{3, 3, 3}, std::vector{3, 3, 0}), + SlaterTypeAtomicShell( + 2, + std::vector{31.332509, 24.312793, 10.554143, 6.987846, + 4.485271, 2.935044, 1.733242, 0.859631}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3}, + std::vector{0.0014237, 0.0062462, 0.1460825, 0.3475138, + 0.4309220, 0.1851549, 0.0082224, + -0.0000252}, + std::vector{5}, std::vector{5})})}, + {34, + SlaterTypeAtom( + 34, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Se + * + * Etot=-2399.867609593 Ekin=2399.867609725 + */ + SlaterTypeAtomicShell( + 0, + std::vector{56.828412, 41.684096, 34.728365, 23.727323, + 14.086853, 14.072696, 6.512291, 5.392830, + 3.949425, + 1.993854, + 1.411000, + 0.897613}, + std::vector{1, 3, 1, 4, 2, 3, 3, 2, 2, 2, 2, 1}, + std::vector{ + 0.0116221, -0.0210440, -0.9787411, 0.0252435, -0.0666383, + 0.0299996, 0.0120725, -0.0170254, 0.0009320, 0.0000644, + -0.0001040, 0.0000687, 0.0444538, -0.0512570, -0.3916991, + 0.1049385, 0.8671612, 0.0972875, -0.0629209, 0.1028540, + -0.0107288, 0.0011542, -0.0009378, 0.0005024, -0.0185939, + 0.0217226, 0.1564411, -0.0392985, -0.4567798, -0.3055537, + 0.2383658, 0.8959612, 0.1561662, -0.0044467, 0.0042356, + -0.0019600, 0.0054869, -0.0064574, -0.0461073, 0.0105428, + 0.1407371, 0.1126788, -0.0101153, -0.1833988, -0.6121357, + 0.5140505, 0.7311799, 0.0642519}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{52.491766, 42.761369, 25.120026, 19.850208, + 14.194446, 6.300767, 5.743780, 4.284076, + 1.319656, 1.131217, 0.897613}, + std::vector{2, 3, 2, 3, 3, 2, 3, 3, 3, 2, 2}, + std::vector{ + -0.0064723, -0.0144032, 0.3393958, 0.4351493, 0.3162317, + 0.0221612, -0.0069670, 0.0019448, 0.0006140, -0.0006687, + -0.0000971, -0.0039597, -0.0086921, 0.1630156, 0.2015918, + 0.3039687, -0.6238082, -0.4717771, -0.1636869, 0.0038219, + -0.0066164, 0.0003477, -0.0010594, -0.0023336, 0.0412546, + 0.0496825, 0.0849833, -0.2107925, -0.0982097, -0.2430954, + -0.5070019, 1.5097405, 0.1154106}, + std::vector{3, 3, 3}, std::vector{3, 3, 1}), + SlaterTypeAtomicShell( + 2, + std::vector{31.897983, 24.931347, 10.860020, 7.194093, + 4.709428, 3.150997, 1.826977, 0.897613}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3}, + std::vector{0.0015379, 0.0064220, 0.1590899, 0.3528155, + 0.4300900, 0.1600225, 0.0063665, + -0.0000598}, + std::vector{5}, std::vector{5})})}, + {35, + SlaterTypeAtom( + 35, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Br + * + * Etot=-2572.44133138 Ekin=2572.441331595 + */ + SlaterTypeAtomicShell( + 0, + std::vector{58.508039, 43.044755, 35.835678, 24.607114, + 14.767152, 14.754419, 6.850776, 5.703885, + 4.364524, + 2.073131, + 1.496008, + 0.956123}, + std::vector{1, 3, 1, 4, 2, 3, 3, 2, 2, 2, 2, 1}, + std::vector{ + 0.0132508, -0.0219336, -0.9789724, 0.0253791, -0.0670808, + 0.0289285, 0.0102296, -0.0146305, 0.0008038, 0.0000833, + -0.0001113, 0.0000698, 0.0450195, -0.0507053, -0.3924497, + 0.1059948, 0.8246160, 0.1376069, -0.0663372, 0.1110553, + -0.0121144, 0.0007303, -0.0006410, 0.0003342, -0.0189118, + 0.0216413, 0.1581023, -0.0388122, -0.4284223, -0.3156266, + 0.3531964, 0.6962321, 0.2248232, -0.0022267, 0.0032532, + -0.0014231, 0.0058177, -0.0067230, -0.0486811, 0.0105546, + 0.1395496, 0.1221182, -0.0316647, -0.0508543, -0.7490550, + 0.6210919, 0.6569533, 0.0420710}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{53.964914, 44.074427, 25.967586, 20.612559, + 14.804998, 7.130435, 6.280038, 4.641256, + 1.483284, 1.265163, 0.956123}, + std::vector{2, 3, 2, 3, 3, 2, 3, 3, 3, 2, 2}, + std::vector{ + -0.0063355, -0.0138313, 0.3363151, 0.4266203, 0.3220530, + 0.0256818, -0.0057859, 0.0017227, 0.0005547, -0.0006631, + -0.0000497, -0.0039510, -0.0085171, 0.1634189, 0.1987104, + 0.3063350, -0.4905817, -0.5755623, -0.1975788, 0.0055771, + -0.0096331, 0.0002427, -0.0011454, -0.0024762, 0.0445753, + 0.0526007, 0.0930826, -0.1864795, -0.1379073, -0.2798173, + -0.5058575, 1.5077209, 0.1395336}, + std::vector{3, 3, 3}, std::vector{3, 3, 2}), + SlaterTypeAtomicShell( + 2, + std::vector{32.846999, 25.721481, 11.166998, 7.375640, + 4.935945, 3.345405, 1.916340, 0.956123}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3}, + std::vector{0.0015744, 0.0065093, 0.1729358, 0.3589234, + 0.4257609, 0.1382342, 0.0047765, + -0.0000021}, + std::vector{5}, std::vector{5})})}, + {36, + SlaterTypeAtom( + 36, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Kr + * + * Etot=-2752.054975504 Ekin=2752.054976552 + */ + SlaterTypeAtomicShell( + 0, + std::vector{60.777807, 44.499723, 36.979014, 25.529164, + 15.429937, 15.427470, 7.202997, 6.034988, + 4.750173, + 2.188877, + 1.592153, + 1.023901}, + std::vector{1, 3, 1, 4, 2, 3, 3, 2, 2, 2, 2, 1}, + std::vector{ + 0.0148759, -0.0234416, -0.9783877, 0.0259097, -0.0689468, + 0.0291144, 0.0095501, -0.0137021, 0.0006363, 0.0001085, + -0.0001339, 0.0000824, 0.0439991, -0.0508013, -0.3906898, + 0.1062937, 0.7865245, 0.1733641, -0.0684596, 0.1177337, + -0.0134150, 0.0005485, -0.0005428, 0.0002903, -0.0185648, + 0.0218088, 0.1586820, -0.0384550, -0.4023743, -0.3230848, + 0.4573148, 0.4908703, 0.3098497, -0.0005023, 0.0025103, + -0.0010443, 0.0059175, -0.0070282, -0.0507087, 0.0106434, + 0.1369390, 0.1300108, -0.0513369, 0.0963564, -0.9038936, + 0.6794236, 0.6213645, 0.0338756}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{55.423460, 45.348388, 26.746410, 21.299661, + 15.365217, 8.075067, 6.762676, 4.956675, + 1.641161, 1.395473, 1.023901}, + std::vector{2, 3, 2, 3, 3, 2, 3, 3, 3, 2, 2}, + std::vector{ + -0.0062132, -0.0133944, 0.3355068, 0.4219443, 0.3213774, + 0.0286895, -0.0034907, 0.0012162, 0.0003760, -0.0004632, + -0.0000170, -0.0039511, -0.0084081, 0.1656088, 0.1992198, + 0.3102247, -0.3970577, -0.6549448, -0.2207516, 0.0056800, + -0.0090577, 0.0004744, -0.0012127, -0.0025837, 0.0478133, + 0.0558041, 0.1007406, -0.1665597, -0.1758964, -0.3108946, + -0.5032745, 1.5227627, 0.1439485}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{33.868162, 26.569736, 11.514091, 7.536640, + 5.124374, 3.510570, 2.025551, 1.023901}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3}, + std::vector{0.0015784, 0.0064515, 0.1841738, 0.3761312, + 0.4160275, 0.1139990, 0.0039681, + 0.0000090}, + std::vector{5}, std::vector{5})})}, + {37, + SlaterTypeAtom( + 37, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Rb + * + * Etot=-2938.357452181 Ekin=2938.357452286 + */ + SlaterTypeAtomicShell( + 0, + std::vector{ + 61.238288, 45.419154, + 37.904166, 26.159754, + 15.837093, + 15.837028, 8.856530, 6.318787, 5.309624, 2.093831, + 1.544223, 1.011039, + 0.525141, 0.525102}, + std::vector{1, 3, 1, 4, 2, 3, 4, 4, 2, 2, 2, 2, 2, 3}, + std::vector{ + -0.0142902, 0.0216673, 0.9805321, -0.0240895, 0.0647545, + -0.0266718, -0.0043941, -0.0024274, 0.0089300, -0.0001051, + 0.0001022, -0.0000457, 0.0000215, -0.0000103, 0.0475276, + -0.0502724, -0.3976681, 0.1068233, 0.8075864, 0.1603309, + -0.0370828, -0.0257528, 0.0887017, 0.0000388, -0.0002100, + 0.0001280, -0.0000690, 0.0000339, -0.0202379, 0.0217619, + 0.1630787, -0.0391489, -0.4356763, -0.3381059, 0.1086089, + -0.1943080, 1.3331631, -0.0023556, 0.0039761, -0.0016422, + 0.0007290, -0.0003476, 0.0068127, -0.0073618, -0.0550419, + 0.0118970, 0.1579985, 0.1422714, -0.0495287, -0.1250338, + -0.7458905, 1.1888711, 0.1410895, -0.0015651, 0.0001535, + 0.0003460, -0.0014356, 0.0015052, 0.0115905, -0.0028838, + -0.0332553, -0.0294429, 0.0140940, 0.0345714, 0.1632246, + -0.2985853, 0.0036943, -0.3644020, 1.2376598, 0.0344657}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 0}), + SlaterTypeAtomicShell( + 1, + std::vector{58.153213, 47.226370, 27.305393, 21.943275, + 15.955742, 9.305393, 7.290585, 5.311460, + 1.664002, 1.475167, 0.525102}, + std::vector{2, 3, 2, 3, 3, 2, 3, 3, 3, 2, 2}, + std::vector{ + -0.0048819, -0.0111043, 0.3350514, 0.4123617, 0.3165616, + 0.0365816, -0.0009949, 0.0006207, 0.0000967, -0.0001351, + -0.0000017, -0.0033211, -0.0074303, 0.1692676, 0.1983483, + 0.3170480, -0.3207522, -0.7038279, -0.2609028, 0.0049228, + -0.0076509, -0.0000070, -0.0011752, -0.0026368, 0.0549054, + 0.0618273, 0.1180470, -0.1598011, -0.2124898, -0.3598097, + -0.5908893, 1.7572623, 0.0024732}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{35.762583, 27.863840, 11.927910, 7.697962, + 5.232765, 3.513352, 1.532313, 0.525102}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3}, + std::vector{0.0014099, 0.0061088, 0.1911086, 0.4082720, + 0.4103741, 0.0783208, 0.0005687, + -0.0000269}, + std::vector{5}, std::vector{5})})}, + {38, + SlaterTypeAtom( + 38, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Sr + * + * Etot=-3131.545684546 Ekin=3131.545683521 + */ + SlaterTypeAtomicShell( + 0, + std::vector{ + 63.847506, 47.274210, + 39.188703, 27.364721, + 16.734172, + 16.730882, 9.349486, 6.986214, 5.834851, 4.333246, + 2.286303, 1.569080, + 0.645727, 0.597422}, + std::vector{1, 3, 1, 4, 2, 3, 4, 4, 2, 2, 2, 2, 2, 3}, + std::vector{ + -0.0177545, 0.0243267, 0.9789460, -0.0267645, 0.0722193, + -0.0286976, -0.0039470, -0.0016704, 0.0084713, -0.0006574, + 0.0000630, -0.0000224, 0.0000044, -0.0000021, 0.0454456, + -0.0485781, -0.3924185, 0.1069584, 0.7269210, 0.2349714, + -0.0369796, -0.0236862, 0.0963446, -0.0034411, 0.0000634, + -0.0000410, 0.0000070, -0.0000033, -0.0193042, 0.0211161, + 0.1618734, -0.0368655, -0.3930822, -0.3618884, 0.2088815, + -0.0521231, 1.0964473, 0.0018149, 0.0038400, -0.0005635, + 0.0001016, -0.0000466, 0.0068169, -0.0075286, -0.0574662, + 0.0111915, 0.1494970, 0.1587752, -0.0741743, -0.1367121, + -0.5162326, -0.3280181, 1.3829402, 0.0537518, -0.0011331, + 0.0004443, -0.0017508, 0.0019640, 0.0148069, -0.0025055, + -0.0395888, -0.0435787, 0.0155664, 0.0624252, 0.1793129, + 0.0246532, -0.2713697, -0.4127011, 1.1372676, 0.0845943}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{59.272426, 48.379341, 28.210855, 22.663072, + 16.507289, 9.969782, 7.589743, 5.520342, + 1.729602, 1.558351, 0.597422}, + std::vector{2, 3, 2, 3, 3, 2, 3, 3, 3, 2, 2}, + std::vector{ + -0.0052361, -0.0114863, 0.3326967, 0.4104599, 0.3159546, + 0.0409869, -0.0002693, 0.0004197, 0.0000605, -0.0000878, + -0.0000010, -0.0036550, -0.0079301, 0.1721273, 0.2006975, + 0.3265554, -0.3092982, -0.7401578, -0.2459051, 0.0038000, + -0.0059260, -0.0000245, -0.0013384, -0.0028904, 0.0598089, + 0.0680591, 0.1293009, -0.1659193, -0.2553096, -0.3975636, + -0.8360604, 2.0197647, 0.0023142}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{36.575295, 28.607388, 12.288934, 7.865863, + 5.425616, 3.736432, 1.567766, 0.597422}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3}, + std::vector{0.0014453, 0.0060802, 0.1996775, 0.4315563, + 0.3845347, 0.0670549, 0.0003473, + -0.0000335}, + std::vector{5}, std::vector{5})})}, + {39, + SlaterTypeAtom( + 39, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Y + * + * Etot=-3331.684167956 Ekin=3331.684164641 + */ + SlaterTypeAtomicShell( + 0, + std::vector{ + 65.677600, 48.695568, + 40.299003, 28.271256, + 17.344941, + 17.267598, 9.716539, 7.333781, 6.106382, 4.377257, + 2.487865, 1.782123, + 0.696713, 0.626327}, + std::vector{1, 3, 1, 4, 3, 2, 4, 4, 2, 2, 2, 2, 2, 3}, + std::vector{ + -0.0188791, 0.0248794, 0.9788154, -0.0273292, -0.0299991, + 0.0747949, -0.0037693, -0.0016007, 0.0081482, -0.0005983, + 0.0000820, -0.0000271, 0.0000033, -0.0000015, 0.0453698, + -0.0479545, -0.3922181, 0.1072635, 0.2467641, 0.7115893, + -0.0382805, -0.0242245, 0.1010985, -0.0041977, 0.0003139, + -0.0001298, 0.0000160, -0.0000072, -0.0193666, 0.0209557, + 0.1630000, -0.0370227, -0.3653089, -0.3870696, 0.2406295, + -0.0298301, 1.0419102, 0.0032733, 0.0041410, -0.0005236, + 0.0000687, -0.0000299, 0.0070679, -0.0077182, -0.0598562, + 0.0116053, 0.1661307, 0.1528031, -0.0893118, -0.1670977, + -0.5332397, -0.3651423, 1.4197921, 0.0917744, -0.0004815, + 0.0002070, -0.0018682, 0.0020667, 0.0158731, -0.0027249, + -0.0467830, -0.0416298, 0.0201208, 0.0726767, 0.1845392, + 0.0391904, -0.2630202, -0.4392445, 1.1174216, 0.0943850}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{59.900446, 49.386205, 29.527649, 23.603873, + 17.192929, 10.613393, 7.969468, 5.813073, + 1.867462, 1.678620, 0.626327}, + std::vector{2, 3, 2, 3, 3, 2, 3, 3, 3, 2, 2}, + std::vector{ + -0.0066340, -0.0134569, 0.3241549, 0.4042563, 0.3246994, + 0.0499760, -0.0002788, 0.0004417, 0.0000805, -0.0001196, + -0.0000015, -0.0044378, -0.0089414, 0.1684998, 0.1977728, + 0.3242036, -0.2691898, -0.7553278, -0.2580804, 0.0032600, + -0.0053319, 0.0000100, -0.0017263, -0.0034703, 0.0619773, + 0.0705726, 0.1366654, -0.1630263, -0.2723236, -0.4426046, + -0.9067918, 2.1182057, 0.0019785}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{40.810898, 31.088920, 13.030122, 11.548644, + 8.178911, 6.740759, 4.532441, 2.474758, + 1.534569, 0.951074, 0.626327}, + std::vector{3, 4, 3, 4, 3, 4, 3, 3, 3, 3, 3}, + std::vector{ + 0.0009670, 0.0049518, 0.1870176, 0.0116097, 0.5443438, + 0.2038900, 0.1435513, 0.0039834, -0.0008202, 0.0003846, + -0.0001036, -0.0002091, -0.0010717, -0.0473405, -0.0193085, + -0.0930002, -0.0980748, 0.0071179, 0.2950860, 0.4826028, + 0.3356767, 0.0166744}, + std::vector{5, 1}, std::vector{5, 0})})}, + {40, + SlaterTypeAtom( + 40, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Zr + * + * Etot=-3538.995062775 Ekin=3538.995058001 + */ + SlaterTypeAtomicShell( + 0, + std::vector{ + 67.592359, 50.153491, + 41.425649, 29.178763, + 17.919326, + 17.912024, 9.994816, 7.642912, 6.238086, 4.544157, + 2.661086, 1.940158, + 0.730087, 0.643883}, + std::vector{1, 3, 1, 4, 3, 2, 4, 4, 2, 2, 2, 2, 2, 3}, + std::vector{ + -0.0200934, 0.0255938, 0.9785096, -0.0282160, -0.0300996, + 0.0766117, -0.0038354, -0.0016429, 0.0086180, -0.0009570, + 0.0001423, -0.0000464, 0.0000045, -0.0000020, 0.0451571, + -0.0474142, -0.3916837, 0.1080504, 0.2710428, 0.6865250, + -0.0379529, -0.0251887, 0.1054057, -0.0079323, 0.0008655, + -0.0003133, 0.0000312, -0.0000140, -0.0193800, 0.0208376, + 0.1639511, -0.0375782, -0.3774636, -0.3754797, 0.2634943, + -0.0546856, 1.0569892, -0.0150192, 0.0058579, -0.0008924, + 0.0000901, -0.0000387, 0.0072585, -0.0078637, -0.0618098, + 0.0122299, 0.1755691, 0.1525955, -0.1023089, -0.1785952, + -0.5801306, -0.3511833, 1.4278307, 0.1234594, -0.0002587, + 0.0001264, -0.0019166, 0.0021032, 0.0163762, -0.0028827, + -0.0493803, -0.0415791, 0.0231827, 0.0778035, 0.2025866, + 0.0285603, -0.2589845, -0.4372861, 1.0982977, 0.1000195}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{60.343183, 50.196004, 30.901959, 24.531890, + 17.884138, 11.439539, 8.353774, 6.122179, + 2.017179, 1.812481, 0.643883}, + std::vector{2, 3, 2, 3, 3, 2, 3, 3, 3, 2, 2}, + std::vector{ + -0.0087377, -0.0164355, 0.3174449, 0.3978674, 0.3281361, + 0.0633748, 0.0003157, 0.0002935, 0.0000553, -0.0000931, + -0.0000001, -0.0057480, -0.0107973, 0.1676956, 0.1957775, + 0.3259147, -0.2362467, -0.7669762, -0.2724428, 0.0036571, + -0.0061078, 0.0000090, -0.0023582, -0.0044263, 0.0650633, + 0.0732587, 0.1459484, -0.1616033, -0.2856684, -0.4814032, + -0.8960979, 2.1353732, 0.0019542}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{42.479679, 32.217117, 13.438794, 12.539994, + 8.374347, 6.870380, 4.690315, 2.537352, + 1.602841, 1.043033, 0.643884}, + std::vector{3, 4, 3, 4, 3, 4, 3, 3, 3, 3, 3}, + std::vector{ + 0.0009114, 0.0048085, 0.1898195, 0.0069596, 0.5779562, + 0.1954391, 0.1162553, 0.0030268, -0.0006565, 0.0003234, + -0.0000648, -0.0002287, -0.0012234, -0.0514088, -0.0137274, + -0.1299196, -0.1192217, 0.0397585, 0.3846543, 0.4816006, + 0.2414336, 0.0043192}, + std::vector{5, 2}, std::vector{5, 0})})}, + {41, + SlaterTypeAtom( + 41, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Nb + * + * Etot=-3753.597725705 Ekin=3753.597720324 + */ + SlaterTypeAtomicShell( + 0, + std::vector{69.224980, 51.473096, 42.500584, 30.023131, + 18.478494, 18.468216, + 10.314928, 7.800341, 6.414258, 4.657761, + 2.765297, + 1.901811, + 0.740290, + 0.656651}, + std::vector{1, 3, 1, 4, 3, 2, 4, 4, 2, 2, 2, 2, 2, 3}, + std::vector{ + -0.0207875, 0.0257242, 0.9788028, -0.0282611, -0.0300606, + 0.0769261, -0.0038361, -0.0016970, 0.0084896, -0.0008054, + 0.0001100, -0.0000300, 0.0000039, -0.0000017, 0.0455627, + -0.0470486, -0.3925830, 0.1083254, 0.2805837, 0.6753090, + -0.0410331, -0.0268361, 0.1100242, -0.0068085, 0.0006478, + -0.0002029, 0.0000222, -0.0000126, -0.0196595, 0.0207850, + 0.1654445, -0.0379852, -0.3826565, -0.3711814, 0.2815037, + -0.0644218, 1.0496388, -0.0176980, 0.0056489, -0.0005838, + 0.0000622, -0.0000399, 0.0074814, -0.0079572, -0.0633958, + 0.0126932, 0.1809874, 0.1544191, -0.1235122, -0.2264745, + -0.6930958, -0.1515771, 1.4016765, 0.1174194, -0.0058731, + -0.0000076, -0.0019209, 0.0020618, 0.0163216, -0.0030020, + -0.0489758, -0.0406997, 0.0299072, 0.0843253, 0.2138689, + 0.0093458, -0.3456983, -0.3368801, 1.1020828, 0.0845055}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 0}), + SlaterTypeAtomicShell( + 1, + std::vector{61.188113, 51.173261, 31.939090, 25.360587, + 18.624521, 12.519467, 8.779237, 6.486416, + 2.181603, 1.942735, 0.656651}, + std::vector{2, 3, 2, 3, 3, 2, 3, 3, 3, 2, 2}, + std::vector{ + -0.0095873, -0.0172981, 0.3115825, 0.3837879, 0.3185574, + 0.0914658, 0.0011490, 0.0001244, 0.0000384, -0.0000804, + 0.0000002, -0.0064429, -0.0116229, 0.1684661, 0.1909675, + 0.3236150, -0.1993589, -0.7640055, -0.3019044, 0.0053615, + -0.0089047, -0.0000132, -0.0028775, -0.0052050, 0.0697544, + 0.0749692, 0.1577560, -0.1638871, -0.2818878, -0.5174511, + -0.8453690, 2.1048178, 0.0019857}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{43.214432, 33.016274, 14.004307, 13.637693, + 8.606973, 6.975387, 4.590202, 2.663261, + 1.622145, 1.012512, 0.656651}, + std::vector{3, 4, 3, 4, 3, 4, 3, 3, 3, 3, 3}, + std::vector{ + 0.0009259, 0.0046595, 0.1845676, 0.0117910, 0.6092961, + 0.2100029, 0.0698855, 0.0011129, 0.0000262, 0.0000696, + -0.0000116, -0.0002370, -0.0012064, -0.0480327, -0.0108282, + -0.1478087, -0.1227696, 0.0663925, 0.4007115, 0.4558844, + 0.2598285, 0.0058349}, + std::vector{5, 4}, std::vector{5, 0})})}, + {42, + SlaterTypeAtom( + 42, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Mo + * + * Etot=-3975.549497368 Ekin=3975.54949911 + */ + SlaterTypeAtomicShell( + 0, + std::vector{70.970218, 52.859118, 43.594250, 30.932320, + 19.096160, 19.034201, + 10.703418, 8.196596, 6.754842, 5.299063, + 2.917595, + 2.061635, + 0.766969, + 0.667426}, + std::vector{1, 3, 1, 4, 3, 2, 4, 4, 2, 2, 2, 2, 2, 3}, + std::vector{ + -0.0215607, 0.0259515, 0.9787856, -0.0285316, -0.0308321, + 0.0784890, -0.0037055, -0.0014479, 0.0085161, -0.0011190, + 0.0000728, -0.0000201, 0.0000019, -0.0000008, 0.0455870, + -0.0464268, -0.3926623, 0.1078837, 0.2926818, 0.6598986, + -0.0427041, -0.0252897, 0.1181144, -0.0113283, 0.0005304, + -0.0001898, 0.0000139, -0.0000101, -0.0197491, 0.0206067, + 0.1665049, -0.0378021, -0.3864484, -0.3646561, 0.3122055, + -0.0286266, 0.9712118, -0.0014743, 0.0042619, -0.0000973, + 0.0000020, -0.0000090, 0.0076467, -0.0080211, -0.0649656, + 0.0128633, 0.1859491, 0.1546092, -0.1343980, -0.2460812, + -0.6113319, -0.2268674, 1.3814335, 0.1491612, -0.0057063, + -0.0002989, -0.0019463, 0.0020747, 0.0166004, -0.0028652, + -0.0506314, -0.0407134, 0.0305835, 0.0933510, 0.2025343, + 0.0205952, -0.3400054, -0.3285032, 1.0755090, 0.0968801}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 0}), + SlaterTypeAtomicShell( + 1, + std::vector{67.532635, 55.500761, 33.311169, 26.716574, + 19.618106, 13.014445, 9.180252, 6.831291, + 2.310849, 2.054575, 0.667426}, + std::vector{2, 3, 2, 3, 3, 2, 3, 3, 3, 2, 2}, + std::vector{ + -0.0063586, -0.0129245, 0.2871732, 0.3570015, 0.3400397, + 0.1139194, -0.0001065, 0.0005742, 0.0001843, -0.0002866, + -0.0000029, -0.0042897, -0.0087687, 0.1502529, 0.1695017, + 0.3047416, -0.1282251, -0.7567888, -0.3264058, 0.0069826, + -0.0114316, -0.0000264, -0.0020197, -0.0041490, 0.0639549, + 0.0674084, 0.1527488, -0.1384363, -0.2776544, -0.5533700, + -0.8546911, 2.1284585, 0.0017645}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{44.896919, 34.167168, 16.927667, 14.083737, + 8.794719, 7.132066, 4.695625, 2.791184, + 1.721238, 1.089989, 0.667426}, + std::vector{3, 4, 3, 3, 3, 4, 3, 3, 3, 3, 3}, + std::vector{ + 0.0008596, 0.0044399, 0.0047783, 0.1969213, 0.6297033, + 0.1950172, 0.0548687, 0.0004897, 0.0001432, -0.0000627, + 0.0000124, -0.0002537, -0.0013349, 0.0051453, -0.0649623, + -0.1740255, -0.1314272, 0.0936650, 0.4339458, 0.4488221, + 0.2219144, 0.0029497}, + std::vector{5, 5}, std::vector{5, 0})})}, + {43, + SlaterTypeAtom( + 43, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Tc + * + * Etot=-4204.788734656 Ekin=4204.788744213 + */ + SlaterTypeAtomicShell( + 0, + std::vector{74.164305, 54.792743, 44.805211, 32.289572, + 20.180572, 20.132338, + 11.529383, 8.882526, 7.851249, 5.980539, + 3.063907, + 2.193010, + 0.862897, + 0.680109}, + std::vector{1, 3, 1, 4, 3, 2, 4, 4, 2, 2, 2, 2, 2, 2}, + std::vector{ + -0.0219095, 0.0269516, 0.9754829, -0.0300293, -0.0320959, + 0.0839449, -0.0035569, -0.0007969, 0.0074374, -0.0004738, + 0.0000254, -0.0000069, 0.0000008, -0.0000004, 0.0415437, + -0.0445812, -0.3853652, 0.1009901, 0.3592739, 0.5749670, + -0.0582885, -0.0219463, 0.1449735, -0.0036422, 0.0000299, + -0.0000443, 0.0000065, -0.0000038, -0.0179065, 0.0198090, + 0.1639985, -0.0329439, -0.3972245, -0.3158886, 0.3800262, + 0.1675627, 0.5712894, 0.1294286, 0.0043304, -0.0002813, + 0.0000825, -0.0000480, 0.0070424, -0.0079018, -0.0652693, + 0.0103547, 0.1936762, 0.1347856, -0.1391842, -0.2709719, + -0.1630909, -0.6793490, 1.4442081, 0.1216703, -0.0008762, + 0.0004937, -0.0017797, 0.0020377, 0.0166127, -0.0020786, + -0.0534145, -0.0360144, 0.0301671, 0.1101126, 0.0945927, + 0.1191161, -0.3332448, -0.3433390, 0.6036055, 0.5643350}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{66.630255, 55.413772, 34.081682, 27.355959, + 20.428471, 14.321864, 9.543653, 7.107659, + 2.425902, 2.175861, 0.680109}, + std::vector{2, 3, 2, 3, 3, 2, 3, 3, 3, 2, 2}, + std::vector{ + -0.0074757, -0.0140336, 0.2820514, 0.3351059, 0.2995358, + 0.1766295, 0.0015497, 0.0001183, 0.0001046, -0.0001818, + -0.0000009, -0.0052891, -0.0099752, 0.1530758, 0.1606575, + 0.2919110, -0.0898887, -0.7672772, -0.3328028, 0.0066631, + -0.0111822, -0.0000173, -0.0027077, -0.0051234, 0.0709520, + 0.0689970, 0.1620222, -0.1394585, -0.2985973, -0.5791179, + -0.8629667, 2.1558945, 0.0016813}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{47.460462, 35.858566, 19.502703, 14.581944, + 9.140374, 7.498466, 5.110192, 3.054737, + 1.987935, 1.308653, 0.680109}, + std::vector{3, 4, 3, 3, 3, 4, 3, 3, 3, 3, 3}, + std::vector{ + 0.0007022, 0.0038386, 0.0033116, 0.1955376, 0.6302851, + 0.1826545, 0.0660937, 0.0009246, 0.0001187, -0.0000382, + 0.0000065, -0.0002580, -0.0014443, 0.0030540, -0.0681994, + -0.1990100, -0.1444734, 0.0882628, 0.4470187, 0.4725979, + 0.1798436, 0.0010160}, + std::vector{5, 5}, std::vector{5, 0})})}, + {44, + SlaterTypeAtom( + 44, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ru + * + * Etot=-4441.539484252 Ekin=4441.539473165 + */ + SlaterTypeAtomicShell( + 0, + std::vector{75.587991, 56.101603, 45.917485, 33.095826, + 20.646878, 20.626049, + 11.711121, 9.098967, 7.950497, 6.803507, + 3.167893, + 2.231223, + 0.817674, + 0.666974}, + std::vector{1, 3, 1, 4, 2, 3, 4, 4, 2, 2, 2, 2, 2, 2}, + std::vector{ + 0.0232844, -0.0274222, -0.9760985, 0.0306301, -0.0848102, + 0.0322299, 0.0037650, 0.0006079, -0.0089046, 0.0017707, + -0.0000240, 0.0000059, -0.0000006, 0.0000004, 0.0427250, + -0.0443646, -0.3870782, 0.1033482, 0.5740429, 0.3630361, + -0.0543563, -0.0189611, 0.1460586, -0.0155637, 0.0000402, + -0.0000458, 0.0000053, -0.0000074, -0.0185471, 0.0198170, + 0.1657759, -0.0349013, -0.3173127, -0.4040189, 0.3882453, + 0.0943775, 0.4532919, 0.3080575, 0.0054792, -0.0004548, + 0.0001380, -0.0000907, 0.0073663, -0.0079812, -0.0665739, + 0.0113269, 0.1366179, 0.1986110, -0.1406479, -0.2616184, + 0.0937876, -0.9162615, 1.3957461, 0.1378832, -0.0006417, + -0.0011817, -0.0017416, 0.0019308, 0.0158502, -0.0021273, + -0.0342669, -0.0513852, 0.0288306, 0.1029374, 0.0526167, + 0.1498782, -0.3527653, -0.2507132, 0.5876874, 0.5402123}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 0}), + SlaterTypeAtomicShell( + 1, + std::vector{68.619796, 56.514248, 33.820701, 27.555949, + 21.389947, 15.693563, 9.931706, 7.447787, + 2.569516, 2.280173, 0.666974}, + std::vector{2, 3, 2, 3, 3, 2, 3, 3, 3, 2, 2}, + std::vector{ + -0.0050486, -0.0102848, 0.2701542, 0.2931985, 0.2132710, + 0.2983828, 0.0029538, -0.0002784, 0.0000480, -0.0001129, + -0.0000001, -0.0041061, -0.0083052, 0.1518429, 0.1382257, + 0.2520952, -0.0182836, -0.7586737, -0.3539394, 0.0088514, + -0.0145826, -0.0000295, -0.0024685, -0.0049999, 0.0792914, + 0.0646754, 0.1652811, -0.1378165, -0.2946319, -0.6032269, + -0.8681875, 2.1712717, 0.0015824}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{48.181841, 36.523583, 17.717806, 16.634643, + 9.655157, 7.941762, 5.347505, 3.199141, + 1.968988, 1.217727, 0.666974}, + std::vector{3, 4, 3, 4, 3, 4, 3, 3, 3, 3, 3}, + std::vector{ + 0.0007669, 0.0041056, 0.1072652, 0.0733546, 0.6346140, + 0.1971960, 0.0680989, 0.0010400, 0.0004065, 0.0000600, + 0.0000119, -0.0002571, -0.0014038, -0.0318848, -0.0289637, + -0.1961167, -0.1545370, 0.1002518, 0.4581675, 0.4503422, + 0.2095372, 0.0029183}, + std::vector{5, 5}, std::vector{5, 2})})}, + {45, + SlaterTypeAtom( + 45, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Rh + * + * Etot=-4685.881699827 Ekin=4685.881694241 + */ + SlaterTypeAtomicShell( + 0, + std::vector{77.024171, 57.422340, 46.951633, 33.967751, + 21.231867, 21.219242, + 12.051536, 9.357721, 8.131190, 6.958132, + 3.298265, + 2.284775, + 0.825117, + 0.665761}, + std::vector{1, 3, 1, 4, 3, 2, 4, 4, 2, 2, 2, 2, 2, 2}, + std::vector{ + -0.0234303, 0.0267584, 0.9766496, -0.0304873, -0.0319308, + 0.0847538, -0.0034107, -0.0008051, 0.0078500, -0.0010981, + 0.0000027, 0.0000026, -0.0000015, 0.0000010, 0.0431745, + -0.0434916, -0.3882523, 0.1027462, 0.3696220, 0.5639108, + -0.0594986, -0.0194587, 0.1621138, -0.0230732, 0.0002728, + -0.0001313, 0.0000284, -0.0000215, -0.0188112, 0.0195000, + 0.1671637, -0.0348174, -0.4058314, -0.3120984, 0.4104920, + 0.0915771, 0.4608221, 0.2776354, 0.0051626, -0.0002238, + 0.0000835, -0.0000516, 0.0075587, -0.0079073, -0.0679417, + 0.0117894, 0.2013116, 0.1372687, -0.1665171, -0.3036682, + -0.0619054, -0.7187318, 1.4100085, 0.1346605, -0.0014940, + 0.0002571, -0.0017153, 0.0018354, 0.0155290, -0.0021563, + -0.0499831, -0.0331423, 0.0342975, 0.1120336, 0.0985604, + 0.0833338, -0.3540430, -0.2201497, 0.5636576, 0.5515493}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 0}), + SlaterTypeAtomicShell( + 1, + std::vector{70.788924, 58.080359, 34.589353, 28.182221, + 22.750752, 16.701338, 10.300968, 7.763781, + 2.693156, 2.388176, 0.665761}, + std::vector{2, 3, 2, 3, 3, 2, 3, 3, 3, 2, 2}, + std::vector{ + -0.0045047, -0.0094416, 0.2444900, 0.2515044, 0.1487164, + 0.4188709, 0.0037532, -0.0005301, 0.0000232, -0.0000853, + 0.0000003, -0.0037801, -0.0078492, 0.1342656, 0.1026535, + 0.1998676, 0.0917079, -0.7534710, -0.3688023, 0.0102028, + -0.0167588, -0.0000343, -0.0025272, -0.0052435, 0.0764002, + 0.0481172, 0.1495745, -0.0959767, -0.2973272, -0.6254309, + -0.8709591, 2.1847584, 0.0015338}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{48.021841, 36.790557, 19.119353, 17.773712, + 10.020134, 8.170279, 5.403773, 3.223903, + 1.964992, 1.227727, 0.665761}, + std::vector{3, 4, 3, 4, 3, 4, 3, 3, 3, 3, 3}, + std::vector{ + 0.0009286, 0.0046539, 0.0855810, 0.0822445, 0.6544581, + 0.2038421, 0.0524595, 0.0010945, 0.0004051, 0.0001290, + 0.0000004, -0.0003408, -0.0017507, -0.0256817, -0.0321380, + -0.2153404, -0.1730314, 0.1507610, 0.4976056, 0.4298886, + 0.1650297, 0.0007133}, + std::vector{5, 5}, std::vector{5, 3})})}, + {46, + SlaterTypeAtom( + 46, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Pd + * + * Etot=-4937.921019011 Ekin=4937.921019835 + */ + SlaterTypeAtomicShell( + 0, + std::vector{95.004581, 65.455382, 48.666335, 36.523802, + 35.930115, 32.224650, 19.506212, 16.996951, + 12.296306, 7.791419, 3.447402, 2.734925, + 0.998788, 0.819759}, + std::vector{1, 3, 1, 2, 3, 4, 2, 4, 4, 2, 2, 3, 2, 1}, + std::vector{ + -0.0065116, 0.0128186, 0.9262564, 0.1171537, -0.0385269, + 0.0085097, -0.0057155, 0.0005375, -0.0006088, 0.0006199, + -0.0000306, 0.0000568, 0.0000839, -0.0001308, -0.0074969, + 0.0134169, 0.3124149, 0.2167267, -0.0557486, -0.0362660, + -1.0991398, -0.0248751, 0.0013077, -0.0022260, 0.0003207, + -0.0002444, -0.0003416, 0.0005348, 0.0037378, -0.0068092, + -0.1361160, -0.1884784, -0.0723338, -0.0650638, 1.0491518, + 0.0402924, -0.3485029, -0.9579142, -0.0061267, 0.0007871, + 0.0010208, -0.0016359, 0.0012466, -0.0021674, -0.0551328, + -0.1745136, -0.1256310, -0.1202308, 1.0316248, 0.3689975, + 0.2636284, -2.0542967, 1.4490671, 0.1039562, -0.0119308, + 0.0201819}, + std::vector{1, 1, 1, 1}, std::vector{1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{72.015150, 59.578992, 36.479116, 30.006145, + 24.034672, 17.033197, 10.715216, 8.150158, + 2.806387, 2.467078, 0.819759}, + std::vector{2, 3, 2, 3, 3, 2, 3, 3, 3, 2, 2}, + std::vector{ + -0.0054593, -0.0106678, 0.2334683, 0.2187363, 0.2042107, + 0.4113571, 0.0029849, -0.0002034, 0.0001552, -0.0002740, + -0.0000024, -0.0041170, -0.0080445, 0.1174424, 0.0776364, + 0.1862776, 0.1565152, -0.7262872, -0.4038500, 0.0142393, + -0.0224917, -0.0000745, -0.0029942, -0.0058879, 0.0682619, + 0.0311137, 0.1419942, -0.0594948, -0.2709552, -0.6594669, + -0.9139537, 2.2272338, 0.0024681}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{48.681034, 37.530522, 20.726814, 16.600467, + 10.405856, 7.629025, 5.600123, 3.476758, + 2.106938, 1.250135, 0.819759}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0009741, 0.0046706, -0.0137973, 0.1879478, 0.5063660, + 0.3362414, 0.0408972, 0.0011194, 0.0000858, -0.0000127, + 0.0000048, -0.0003947, -0.0019555, 0.0125953, -0.0744232, + -0.1043247, -0.2573355, 0.1347941, 0.4653239, 0.4237954, + 0.2203384, 0.0191275}, + std::vector{5, 5}, std::vector{5, 5})})}, + {47, + SlaterTypeAtom( + 47, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Ag + * + * Etot=-5197.698467674 Ekin=5197.698468984 + */ + SlaterTypeAtomicShell( + 0, + std::vector{81.922545, 60.961344, 49.339744, 36.344474, + 22.846089, 22.824480, + 13.009377, 9.794366, 8.903696, 4.446178, + 3.589317, + 2.519920, + 0.826013, + 0.663294}, + std::vector{1, 3, 1, 4, 3, 2, 4, 4, 2, 2, 2, 2, 2, 2}, + std::vector{ + -0.0249463, 0.0279319, 0.9727086, -0.0337753, -0.0362467, + 0.0960288, -0.0042042, -0.0009434, 0.0082152, -0.0001941, + 0.0001426, -0.0000249, 0.0000029, -0.0000019, 0.0397871, + -0.0405433, -0.3810597, 0.0969467, 0.4275905, 0.4841259, + -0.0824896, -0.0269850, 0.1886970, -0.0005026, 0.0004284, + -0.0001368, 0.0000216, -0.0000145, -0.0173562, 0.0182861, + 0.1654469, -0.0318908, -0.4139058, -0.2675541, 0.4962657, + 0.2221040, 0.4960442, 0.0282383, -0.0086790, 0.0017522, + -0.0001031, 0.0000631, 0.0070924, -0.0075458, -0.0685857, + 0.0107924, 0.2086400, 0.1246272, -0.2527818, -0.5035254, + -0.5095789, -0.1083021, 1.4622619, 0.1661500, -0.0002104, + 0.0004717, -0.0014801, 0.0015959, 0.0143847, -0.0019778, + -0.0461251, -0.0271509, 0.0525889, 0.1374074, 0.1320003, + -0.0494609, -0.2588647, -0.2187850, 0.5413805, 0.5502496}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 0}), + SlaterTypeAtomicShell( + 1, + std::vector{58.031368, 51.182468, 33.533569, 23.909244, + 19.551930, 10.860119, 8.237653, 3.358709, + 2.956246, 1.903964, 0.663294}, + std::vector{2, 3, 3, 2, 3, 3, 3, 3, 2, 2, 2}, + std::vector{ + -0.0119946, -0.0145273, -0.0910690, 0.9163004, 0.2254388, + 0.0061803, -0.0019624, -0.0007372, 0.0008735, 0.0000515, + -0.0000051, 0.0277335, 0.0321879, 0.1548314, -0.6168692, + -0.0961471, 0.7911584, 0.3369847, -0.0138382, 0.0238263, + 0.0000646, -0.0000051, -0.0192415, -0.0221456, -0.1056304, + 0.3096237, -0.0107746, -0.3417783, -0.6569599, -0.3915365, + 1.7235547, 0.0795092, 0.0004692}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{53.296212, 40.214567, 21.872645, 17.024065, + 10.708021, 7.859216, 5.770205, 3.610289, + 2.243262, 1.397570, 0.663294}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0006646, 0.0037211, -0.0072310, 0.1799224, 0.5205360, + 0.3265622, 0.0373867, 0.0007434, 0.0001743, -0.0000474, + 0.0000083, -0.0002936, -0.0016839, 0.0092799, -0.0743431, + -0.1179494, -0.2809146, 0.1653040, 0.4851980, 0.4317110, + 0.1737644, 0.0013751}, + std::vector{5, 5}, std::vector{5, 5})})}, + {48, + SlaterTypeAtom( + 48, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Cd + * + * Etot=-5465.133137188 Ekin=5465.133128301 + */ + SlaterTypeAtomicShell( + 0, + std::vector{83.516231, 62.584694, 50.503156, 37.421392, + 23.543997, 23.541419, 13.502173, + 10.284092, 9.381965, 5.195588, 3.843181, + 2.816065, + 0.968171, + 0.727812}, + std::vector{1, 3, 1, 4, 3, 2, 4, 4, 2, 2, 2, 2, 2, 2}, + std::vector{ + -0.0262527, 0.0278638, 0.9722572, -0.0354335, -0.0376474, + 0.1006402, -0.0040385, -0.0009005, 0.0081164, -0.0000454, + 0.0000091, 0.0000032, -0.0000011, 0.0000007, 0.0399346, + -0.0388316, -0.3803997, 0.0964796, 0.4438033, 0.4577397, + -0.0861852, -0.0250434, 0.2000684, -0.0022550, 0.0013520, + -0.0004150, 0.0000415, -0.0000243, -0.0174771, 0.0175762, + 0.1659283, -0.0321859, -0.4146711, -0.2531795, 0.5088309, + 0.2604848, 0.4224946, 0.0412859, -0.0070211, 0.0024176, + -0.0001127, 0.0000644, 0.0072349, -0.0073673, -0.0697793, + 0.0108675, 0.2127212, 0.1200659, -0.2482762, -0.5139857, + -0.4422349, -0.2974854, 1.5038237, 0.2473646, -0.0001749, + 0.0001399, -0.0017034, 0.0017715, 0.0165520, -0.0020934, + -0.0541342, -0.0300342, 0.0562245, 0.1660909, 0.1423706, + -0.0242428, -0.2301713, -0.3672162, 0.6462728, 0.4865533}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{60.437885, 53.012348, 34.580438, 24.629908, + 19.895718, 11.175126, 8.476139, 4.269777, + 3.164214, 2.145405, 0.727812}, + std::vector{2, 3, 3, 2, 3, 3, 3, 2, 2, 2, 2}, + std::vector{ + -0.0173275, -0.0215550, -0.1185046, 0.9550080, 0.2245251, + 0.0034041, -0.0000009, -0.0006380, 0.0003332, -0.0001008, + 0.0000051, 0.0271937, 0.0329742, 0.1545282, -0.6144704, + -0.1078982, 0.8022408, 0.3321057, 0.0110873, -0.0000626, + 0.0002263, -0.0000021, -0.0177497, -0.0213434, -0.0998002, + 0.3005211, -0.0034551, -0.3615306, -0.6836458, 0.2962730, + 1.0626495, 0.1176349, 0.0008824}, + std::vector{3, 3, 3}, std::vector{3, 3, 3}), + SlaterTypeAtomicShell( + 2, + std::vector{51.167417, 39.515824, 20.925917, 17.638488, + 10.839796, 7.941688, 6.801382, 3.849955, + 2.417483, 1.559278, 0.727812}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0009064, 0.0043120, -0.0232941, 0.1977432, 0.5717083, + 0.2456392, 0.0604243, 0.0036183, -0.0005902, 0.0001645, + -0.0000215, -0.0003999, -0.0019498, 0.0209998, -0.0922260, + -0.1242668, -0.4311272, 0.2825314, 0.5211361, 0.4469071, + 0.1356698, 0.0003908}, + std::vector{5, 5}, std::vector{5, 5})})}, + {49, + SlaterTypeAtom( + 49, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for In + * + * Etot=-5740.169150772 Ekin=5740.169150632 + */ + SlaterTypeAtomicShell( + 0, + std::vector{78.931670, 59.837425, 50.067547, 35.479347, + 23.025101, 23.015102, 17.915983, 13.827518, + 10.265558, 3.763681, 2.140831, 1.711542, + 0.959206, 0.628144}, + std::vector{1, 3, 1, 4, 3, 2, 2, 4, 4, 2, 2, 2, 2, 2}, + std::vector{ + -0.0142157, 0.0175006, 0.9859097, -0.0178604, -0.0139916, + 0.0471222, 0.0004136, 0.0002230, -0.0001413, 0.0000827, + -0.0001140, 0.0000897, -0.0000197, 0.0000058, 0.0546513, + -0.0480712, -0.4174548, 0.1080631, 0.1899635, 0.5140674, + 0.3007600, 0.0030729, -0.0004854, -0.0001266, -0.0000454, + 0.0000453, -0.0000123, 0.0000039, -0.0233526, 0.0211407, + 0.1816464, -0.0285980, -0.5747991, -0.7205153, 0.8087809, + 0.7432703, 0.3022462, 0.0107650, -0.0045254, 0.0030485, + -0.0005282, 0.0001411, 0.0092950, -0.0085762, -0.0764116, + 0.0043357, 0.4100931, 0.5401772, -0.8291304, -0.5467518, + -0.6065028, 1.5446567, 0.0499097, -0.0151329, 0.0011629, + -0.0002013, -0.0025125, 0.0022335, 0.0206063, -0.0019926, + -0.1127555, -0.1542355, 0.2421598, 0.1661975, 0.1970415, + -0.4929401, -0.6818490, 0.6092617, 0.9732952, 0.0233062}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{60.501482, 53.257212, 34.960599, 24.975942, + 20.116604, 11.258653, 9.424572, 4.754638, + 3.625842, 2.688752, 2.453862, 0.824472, + 0.628144}, + std::vector{2, 3, 3, 2, 3, 3, 3, 3, 2, 3, 2, 2, 2}, + std::vector{ + 0.0173853, 0.0210311, 0.1171843, -0.9663332, -0.2129668, + 0.0028118, -0.0098008, -0.0171060, 0.0347689, 0.0112176, + -0.0230396, 0.0000491, -0.0000274, -0.0306241, -0.0359791, + -0.1678469, 0.6518362, 0.1035377, -0.8037595, -0.1741340, + 0.3782962, -0.8592254, -0.3153626, 0.6354652, -0.0002946, + 0.0001312, -0.0202965, -0.0236607, -0.1100237, 0.3308470, + 0.0000548, -0.2157447, -0.6283409, 0.4313917, 0.0293450, + -0.5834057, 1.3763632, 0.0010460, -0.0001678, 0.0044821, + 0.0052172, 0.0242693, -0.0691407, 0.0035886, 0.0363128, + 0.1606011, -0.0621297, -0.1555203, -0.0742979, -0.1743228, + 0.5626616, 0.5436137}, + std::vector{3, 3, 3, 1}, std::vector{3, 3, 3, 0}), + SlaterTypeAtomicShell( + 2, + std::vector{55.317221, 41.994493, 21.613292, 19.210472, + 11.680393, 8.644928, 6.351845, 3.983040, + 2.589850, 1.716691, 0.628144}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0007438, 0.0040391, -0.0598389, 0.2042584, 0.5030443, + 0.3587071, 0.0474870, 0.0001790, 0.0003136, -0.0000944, + 0.0000070, -0.0003637, -0.0020226, 0.0428431, -0.1058276, + -0.1202876, -0.3285544, 0.1665113, 0.5253817, 0.4479958, + 0.1029379, 0.0003100}, + std::vector{5, 5}, std::vector{5, 5})})}, + {50, + SlaterTypeAtom( + 50, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Sn + * + * Etot=-6022.931689355 Ekin=6022.931688354 + */ + SlaterTypeAtomicShell( + 0, + std::vector{80.455846, 61.077522, 51.100199, 36.186771, + 23.454426, 23.445269, 18.620156, 14.151788, + 10.492947, 3.907598, 2.390486, 1.849969, + 1.078565, 0.728067}, + std::vector{1, 3, 1, 4, 3, 2, 2, 4, 4, 2, 2, 2, 2, 2}, + std::vector{ + -0.0144977, 0.0174734, 0.9862892, -0.0179256, -0.0137471, + 0.0471833, 0.0000230, 0.0002655, -0.0001719, 0.0001192, + -0.0001507, 0.0001101, -0.0000283, 0.0000083, 0.0553118, + -0.0481743, -0.4189688, 0.1106680, 0.1716616, 0.4931897, + 0.3362926, 0.0034871, -0.0006488, -0.0000670, -0.0001212, + 0.0001008, -0.0000276, 0.0000085, -0.0237180, 0.0212480, + 0.1830855, -0.0298278, -0.6055901, -0.8110250, 0.9229662, + 0.7575007, 0.2915521, 0.0106519, -0.0038822, 0.0022045, + -0.0004316, 0.0001092, 0.0095810, -0.0087058, -0.0780882, + 0.0053864, 0.4433990, 0.6352886, -0.9542441, -0.5789994, + -0.6151320, 1.5908849, 0.0157757, 0.0041426, -0.0008121, + 0.0002816, -0.0028319, 0.0024527, 0.0228900, -0.0029306, + -0.1291051, -0.1933617, 0.2946869, 0.1922979, 0.2150205, + -0.5092645, -0.7607948, 0.6259933, 0.9907551, 0.0244081}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{61.677788, 54.522439, 35.964661, 25.612520, + 20.778057, 11.733191, 9.474605, 4.444605, + 3.619249, 2.253177, 2.247672, 0.955341, + 0.728067}, + std::vector{2, 3, 3, 2, 3, 3, 3, 3, 2, 2, 3, 2, 2}, + std::vector{ + 0.0161149, 0.0188180, 0.1066856, -0.9448192, -0.2201772, + -0.0014636, -0.0026237, -0.0051379, 0.0069814, -0.0003514, + -0.0000026, 0.0000494, -0.0000249, 0.0277049, 0.0314146, + 0.1484704, -0.6168577, -0.1127965, 0.7761142, 0.2995494, + -0.1569917, 0.2401865, -0.0343728, 0.0118788, -0.0006735, + 0.0002595, -0.0192541, -0.0216506, -0.1019300, 0.3168417, + -0.0001023, -0.2749161, -0.7029132, 0.1829855, 1.0783529, + 0.1739445, -0.0369183, 0.0027850, -0.0007700, 0.0051882, + 0.0058165, 0.0274402, -0.0789461, 0.0056554, 0.0595664, + 0.2133200, 0.0530090, -0.3399077, -0.3851452, 0.0776064, + 0.7346774, 0.4209948}, + std::vector{3, 3, 3, 2}, std::vector{3, 3, 3, 0}), + SlaterTypeAtomicShell( + 2, + std::vector{55.746534, 42.546716, 22.054380, 19.421508, + 11.855840, 9.048137, 7.315308, 4.324680, + 2.880503, 1.913171, 0.728067}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0007571, 0.0039293, -0.0494597, 0.1996605, 0.5218006, + 0.2844154, 0.0938120, 0.0024575, -0.0001862, 0.0000049, + -0.0000019, -0.0003966, -0.0021240, 0.0412734, -0.1112105, + -0.1074823, -0.3901734, 0.1673586, 0.5215272, 0.4827935, + 0.1040839, 0.0004031}, + std::vector{5, 5}, std::vector{5, 5})})}, + {51, + SlaterTypeAtom( + 51, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Sb + * + * Etot=-6313.48531364 Ekin=6313.485313897 + */ + SlaterTypeAtomicShell( + 0, + std::vector{81.669053, 62.093595, 52.030871, 36.759376, + 23.815342, 23.814678, 19.636087, 14.494462, + 10.724371, 4.044819, 2.384963, 2.360123, + 1.204949, 0.818182}, + std::vector{1, 3, 1, 4, 3, 2, 2, 4, 4, 2, 3, 2, 2, 2}, + std::vector{ + -0.0134638, 0.0165381, 0.9868225, -0.0172073, -0.0124990, + 0.0454536, -0.0010285, 0.0003053, -0.0002028, 0.0001734, + 0.0001234, -0.0001884, -0.0000311, 0.0000093, -0.0566828, + 0.0487504, 0.4224765, -0.1137046, -0.1251989, -0.4273076, + -0.4438770, -0.0042354, 0.0009317, -0.0001021, -0.0001953, + 0.0002811, 0.0000509, -0.0000157, 0.0243091, -0.0214849, + -0.1852130, 0.0304473, 0.6819661, 1.0660930, -1.2403659, + -0.7713220, -0.2837013, -0.0100942, -0.0014736, 0.0031291, + 0.0001909, -0.0000390, 0.0098924, -0.0088482, -0.0799153, + 0.0054239, 0.5277022, 0.8994842, -1.2924573, -0.6111574, + -0.6259397, 1.6523122, 0.0205380, -0.0288217, -0.0021243, + 0.0006083, -0.0031373, 0.0026430, 0.0249416, -0.0037421, + -0.1585936, -0.2834488, 0.4094224, 0.2166477, 0.2298345, + -0.5054422, 0.4902574, -0.7170314, 1.0659010, 0.0307137}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{62.951697, 55.728392, 36.852535, 26.182019, + 21.277839, 12.070084, 10.015351, 4.633217, + 3.778525, 2.345676, 2.323959, 1.067563, + 0.818182}, + std::vector{2, 3, 3, 2, 3, 3, 3, 3, 2, 2, 3, 2, 2}, + std::vector{ + 0.0155816, 0.0179260, 0.1020306, -0.9373856, -0.2221459, + -0.0005588, -0.0035681, -0.0058771, 0.0079479, -0.0003433, + -0.0000411, 0.0000746, -0.0000352, 0.0262122, 0.0293208, + 0.1389143, -0.6041394, -0.1217624, 0.7411645, 0.3190643, + -0.1995954, 0.3036116, -0.0416820, 0.0143907, -0.0010719, + 0.0003834, -0.0188221, -0.0208711, -0.0984827, 0.3167541, + 0.0062173, -0.2038949, -0.7393844, 0.3806189, 0.8480010, + 0.1816011, -0.0429905, 0.0036478, -0.0012729, 0.0055849, + 0.0061790, 0.0291815, -0.0869754, 0.0044981, 0.0427736, + 0.2494446, 0.0026424, -0.2827206, -0.5316514, 0.1536505, + 0.8387763, 0.3459677}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 0}), + SlaterTypeAtomicShell( + 2, + std::vector{56.325199, 43.270728, 23.861190, 19.352127, + 12.040675, 9.494720, 7.952780, 4.413147, + 2.960090, 1.974195, 0.818182}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0007560, 0.0037287, -0.0169674, 0.1735366, 0.5423797, + 0.1962367, 0.1532098, 0.0032512, -0.0005976, 0.0000981, + -0.0000118, -0.0004604, -0.0023689, 0.0210008, -0.0976386, + -0.0842374, -0.4615684, 0.2037659, 0.5904422, 0.4506657, + 0.0669669, 0.0004180}, + std::vector{5, 5}, std::vector{5, 5})})}, + {52, + SlaterTypeAtom( + 52, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for Te + * + * Etot=-6611.784051172 Ekin=6611.784057214 + */ + SlaterTypeAtomicShell( + 0, + std::vector{85.845242, 64.575316, 53.318205, 38.055728, + 23.183837, 23.181322, 20.472540, 14.954391, + 11.061281, 4.106440, 2.453937, 2.078816, + 1.341043, 0.848330}, + std::vector{1, 3, 1, 4, 4, 3, 2, 4, 4, 2, 3, 2, 2, 2}, + std::vector{ + 0.0151999, -0.0182834, -0.9843584, 0.0214103, 0.0028794, + 0.0440502, -0.0826967, 0.0000206, 0.0001031, -0.0001653, + -0.0002593, 0.0003416, 0.0000063, -0.0000035, -0.0498725, + 0.0468219, 0.4110387, -0.1153153, 0.0617102, 0.0052970, + -1.0339644, -0.0041994, 0.0010196, -0.0002770, -0.0006896, + 0.0008877, 0.0000223, -0.0000109, 0.0216044, -0.0208689, + -0.1813028, 0.0332073, -0.2361289, 0.2336746, 0.4473546, + -0.7750755, -0.2957747, -0.0117599, -0.0060266, 0.0091395, + -0.0003707, 0.0000523, 0.0088323, -0.0087541, -0.0791650, + 0.0051485, -0.2021387, 0.1344749, 0.1497841, -0.6218167, + -0.6458092, 1.7987180, 0.2953830, -0.4314743, 0.0156985, + -0.0013446, -0.0029369, 0.0027536, 0.0259641, -0.0036209, + 0.0654362, -0.0356080, -0.0473504, 0.2314581, 0.2493878, + -0.5171862, 1.0492647, -1.4033196, 1.2109880, 0.0337903}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{64.520612, 57.342579, 38.066026, 26.860842, + 21.909185, 12.422323, 10.518869, 4.865646, + 3.990216, 2.979535, 1.573641, 1.082552, + 0.848330}, + std::vector{2, 3, 3, 2, 3, 3, 3, 3, 2, 2, 2, 2, 2}, + std::vector{ + 0.0144891, 0.0160548, 0.0931224, -0.9171997, -0.2316537, + -0.0008947, -0.0035780, -0.0056813, 0.0078514, -0.0003409, + -0.0001520, 0.0001445, -0.0000597, 0.0230789, 0.0249203, + 0.1205088, -0.5733180, -0.1379155, 0.7025233, 0.3468900, + -0.2234750, 0.3492052, -0.0398439, 0.0035158, -0.0019367, + 0.0006263, -0.0170852, -0.0182751, -0.0880124, 0.3037345, + 0.0182506, -0.1358468, -0.7774381, 0.5680195, 0.5397718, + 0.2374484, -0.0016545, 0.0031985, -0.0007358, 0.0053763, + 0.0057448, 0.0276365, -0.0884720, 0.0010960, 0.0235501, + 0.2815596, -0.0382135, -0.1099874, -0.6280083, 0.2602240, + 0.7459288, 0.2649131}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 1}), + SlaterTypeAtomicShell( + 2, + std::vector{57.659379, 44.352216, 24.129056, 19.832277, + 12.290430, 9.774302, 8.292981, 4.494608, + 3.020391, 1.937052, 0.848330}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0007132, 0.0034987, -0.0180595, 0.1743763, 0.5675455, + 0.1497072, 0.1740867, 0.0027133, -0.0004911, 0.0000534, + -0.0000092, -0.0004389, -0.0022355, 0.0228285, -0.1021000, + -0.0839308, -0.5117118, 0.2449969, 0.6583887, 0.4093601, + 0.0350382, 0.0001836}, + std::vector{5, 5}, std::vector{5, 5})})}, + {53, + SlaterTypeAtom( + 53, + std::vector{ + /** + * + * Slater-type orbital Hartree-Fock calculation for I + * + * Etot=-6917.980888325 Ekin=6917.980898267 + */ + SlaterTypeAtomicShell( + 0, + std::vector{90.775507, 67.802436, 55.080861, 39.986811, + 23.497728, 23.479689, 19.940176, 15.302284, + 11.327208, 4.191130, 2.668132, 2.302372, + 1.436633, 0.897975}, + std::vector{1, 3, 1, 4, 3, 4, 2, 4, 4, 2, 3, 2, 2, 2}, + std::vector{ + 0.0210910, -0.0235692, -0.9790037, 0.0303279, 0.0794190, + 0.0074855, -0.1355617, 0.0014779, -0.0005014, 0.0004004, + 0.0005376, -0.0007565, -0.0000101, 0.0000046, -0.0436467, + 0.0433924, 0.3957606, -0.1135201, -0.0341450, 0.1489421, + -1.0627837, 0.0002187, -0.0003227, 0.0007952, 0.0007992, + -0.0011659, -0.0000038, 0.0000036, 0.0193995, -0.0198191, + -0.1762111, 0.0386087, 0.2259894, -0.2644256, 0.4732098, + -0.7815536, -0.2920549, -0.0130934, -0.0072692, 0.0115033, + -0.0002506, 0.0000380, 0.0082873, -0.0086432, -0.0784868, + 0.0108011, 0.1177502, -0.2074903, 0.1630886, -0.6407296, + -0.6592307, 1.9855630, 0.5181791, -0.7992448, 0.0179623, + -0.0015257, -0.0028487, 0.0028272, 0.0267557, -0.0052902, + -0.0327946, 0.0701377, -0.0531779, 0.2479146, 0.2646822, + -0.4921759, 1.1406449, -1.5440675, 1.2088763, 0.0294759}, + std::vector{1, 1, 1, 1, 1}, + std::vector{1, 1, 1, 1, 1}), + SlaterTypeAtomicShell( + 1, + std::vector{65.960053, 58.378207, 38.587026, 27.259158, + 22.203480, 12.897653, 11.549105, 5.203779, + 4.277522, 3.458100, 1.408252, 0.963088, + 0.897975}, + std::vector{2, 3, 3, 2, 3, 3, 3, 3, 2, 2, 2, 2, 2}, + std::vector{ + 0.0140379, 0.0161272, 0.0932236, -0.9261995, -0.2227614, + 0.0061060, -0.0098136, -0.0071616, 0.0104386, -0.0008598, + -0.0001304, 0.0003745, -0.0002868, 0.0235585, 0.0264122, + 0.1255009, -0.5899244, -0.1360554, 0.4668668, 0.5427630, + -0.2971175, 0.4925415, -0.0721425, 0.0021008, -0.0041354, + 0.0029821, -0.0185441, -0.0205994, -0.0973088, 0.3299415, + 0.0185145, 0.2243914, -1.0172720, 0.9310447, -0.2390633, + 0.5531025, 0.0035396, 0.0009474, -0.0003325, 0.0065216, + 0.0072266, 0.0341602, -0.1049812, 0.0039554, -0.1161332, + 0.4048012, -0.1112487, 0.2763217, -0.9278147, 0.6651689, + 0.7272596, -0.1331586}, + std::vector{3, 3, 3, 3}, std::vector{3, 3, 3, 2}), + SlaterTypeAtomicShell( + 2, + std::vector{58.400845, 45.117174, 24.132009, 20.588554, + 12.624386, 10.217388, 8.680013, 4.627159, + 3.093797, 1.795536, 0.897975}, + std::vector{3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3}, + std::vector{ + 0.0007323, 0.0034936, -0.0294994, 0.1804500, 0.5807380, + 0.1086146, 0.2060658, 0.0026186, -0.0005043, 0.0000452, + -0.0000121, -0.0004544, -0.0022398, 0.0330601, -0.1129370, + -0.0728984, -0.5296807, 0.2335904, 0.7203740, 0.3707250, + 0.0165929, -0.0001881}, + std::vector{5, 5}, std::vector{5, 5})})}}; diff --git a/include/integratorxx/util/factorial.hpp b/include/integratorxx/util/factorial.hpp new file mode 100644 index 0000000..87bf4ff --- /dev/null +++ b/include/integratorxx/util/factorial.hpp @@ -0,0 +1,7 @@ +#pragma once + +namespace IntegratorXX { +constexpr size_t factorial(size_t n) { + return (n == 1 || n == 0) ? 1 : factorial(n - 1) * n; +} +} diff --git a/test/test_functions.hpp b/test/test_functions.hpp index bd7f34f..75fa7e1 100644 --- a/test/test_functions.hpp +++ b/test/test_functions.hpp @@ -2,12 +2,9 @@ #include #include #include "quad_matcher.hpp" - +#include namespace detail { - constexpr size_t factorial(size_t n) { - return (n == 1 || n == 0) ? 1 : factorial(n - 1) * n; - } } struct AssociatedLegendre { static inline double evaluate(int l, int m, double x) { @@ -17,8 +14,8 @@ struct AssociatedLegendre { struct SphericalHarmonic { static auto evaluate(int l, int m, double theta, double phi) { - double fac_ratio = detail::factorial(l-m); - fac_ratio /= detail::factorial(l+m); + double fac_ratio = IntegratorXX::factorial(l-m); + fac_ratio /= IntegratorXX::factorial(l+m); double prefactor = (2.0 * l + 1.0) / (4.0 * M_PI); prefactor *= fac_ratio; prefactor = std::sqrt(prefactor);