13630814717

Committed 03 Mar 2025 12:23PM UTC coverage: 73.673% (-0.07%) from 73.743%

Build # 13630814717

Build Type

push

github

Committed by

web-flow

Commit Message

Refactor tests (#189)

* * First iteration of Q-Chem input/savedir generator.

* basis sets are now exported as Q-Chem/Gaussian-formatted strings in pyscf hfdata
dumps and used in generated Q-Chem input files.

* * Fixed basis export which could miss functions in some cases.
* Fixed multiplicity dump which was incorrect in original dump_pyscf script.

* * Export of additional molecular data.

* replace static_data by test_cases and port the existing generators

* first draft for qchem testdata generation

* works for a single calculation with a qchem-version file

* importer for excited state data

* add ground state import

* merge hfdata generators

* add ref cases to test_cases.py

* add dump functionality for qchem data

* draft for adcman mpdata generator

* mp generation seems to work

* draft for excited state data adcman generator

* Added ERI and AO dipole operator matrices to Q-Chem export.

* split eri and ao integral savedir export

* draft for adcc ground state dump

* draft for adcc excited states data dump

* draft for matrix testdata dump

* rename test_cases so pytest will be happy

* add spin flip for adcman and import only the n lowest states

* cache draft and adcc generator draft

* working adcman mp generator?

* adcman generator seems to work

* adcc generator seems to work

* test data cache access with filename

* move testcases and cache in the tests folder

* port a few adc matrix tests

* port the remaining AdcMatrix tests

* hfimport generator + amplitude test

* port projection test + add relevant cases to generators

* increase subspace size for adcman

* port reference state tests and dependencies

* port missing adcmatrix tests

* port direct_sum, einsum and misc tests

* port most backend tests + add even more testcases...

* functionality test + add systems in generators

* functionality xes + smoke test + more testcases...

* avoid duplicating data in testdata_cache

* port and fix guess test

* only load required d... (continued)

Run Details

1098 of 1780 branches covered (61.69%)

Branch coverage included in aggregate %.

33 of 69 new or added lines in 8 files covered. (47.83%)

31 existing lines in 9 files now uncovered.

7065 of 9300 relevant lines covered (75.97%)

222418.44 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.85

/libadcc/pyiface/export_ReferenceState.cc

//
// Copyright (C) 2018 by the adcc authors
//
// This file is part of adcc.
//
// adcc is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// adcc is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with adcc. If not, see <http://www.gnu.org/licenses/>.
//

#include "../ReferenceState.hh"
#include "hartree_fock_solution_hack.hh"
#include <pybind11/numpy.h>
#include <pybind11/pybind11.h>
#include <pybind11/stl.h>

namespace libadcc {
namespace py = pybind11;

py::object convert_timer(const Timer& timer) {
  // Determine the shift between the C++ and the python clocks
  py::object pynow         = py::module::import("time").attr("perf_counter");
  const double clock_shift = pynow().cast<double>() - Timer::now();

  // Shift the data and convert to python
  py::dict shifted_intervals;
  for (const auto& kv : timer.intervals) {
    py::list intlist;
    for (const auto& p : kv.second) {
      intlist.append(py::make_tuple(clock_shift + p.first, clock_shift + p.second));
    }
    shifted_intervals[py::cast(kv.first)] = intlist;
  }
  py::dict shifted_start_times;
  for (const auto& kv : timer.start_times) {
    shifted_start_times[py::cast(kv.first)] = kv.second + clock_shift;
  }

  py::object pyTimer            = py::module::import("adcc.timings").attr("Timer");
  py::object ret                = pyTimer();
  ret.attr("raw_data")          = shifted_intervals;
  ret.attr("start_times")       = shifted_start_times;
  ret.attr("time_construction") = timer.time_construction + clock_shift;
  return ret;
}

void export_ReferenceState(py::module& m) {

  py::class_<ReferenceState, std::shared_ptr<ReferenceState>>(
        m, "ReferenceState",
        "Class representing information about the reference state for adcc. Python "
        "binding to"
        ":cpp:class:`libadcc::ReferenceState`.")
        .def(py::init<std::shared_ptr<const HartreeFockSolution_i>,
                      std::shared_ptr<const MoSpaces>, bool>(),
             "Setup a ReferenceStateject using an MoSpaces object.\n"
             "\n"
             "hfsoln_ptr        Pointer to the Interface to the host program,\n"
             "                  providing the HartreeFockSolution data, which\n"
             "                  will be provided by this object.\n"
             "mo_ptr            MoSpaces object containing info about the MoSpace setup\n"
             "                  and the point group symmetry.\n"
             "symmetry_check_on_import\n"
             "                  Should symmetry of the imported objects be checked\n"
             "                  explicitly during the import process. This massively "
             "slows\n"
             "                  down the import process and has a dramatic impact on "
             "memory\n"
             "                  usage and should thus only be used for debugging import "
             "routines\n"
             "                  from the host programs. Do not enable this unless you "
             "know\n"
             "                  that you really want to.\n")
        .def_property_readonly("restricted", &ReferenceState::restricted,
                               "Return whether the reference is restricted or not.")
        .def_property_readonly(
              "spin_multiplicity", &ReferenceState::spin_multiplicity,
              "Return the spin multiplicity of the reference state. 0 indicates "
              "that the spin cannot be determined or is not integer (e.g. UHF)")
        .def_property_readonly("has_core_occupied_space",
                               &ReferenceState::has_core_occupied_space,
                               "Is a core occupied space setup, such that a core-valence "
                               "separation can be applied.")
        .def_property_readonly("irreducible_representation",
                               &ReferenceState::irreducible_representation,
                               "Reference state irreducible representation")
        .def_property_readonly("mospaces", &ReferenceState::mospaces_ptr,
                               "The MoSpaces object supplied on initialisation")
        .def_property_readonly(
              "backend", &ReferenceState::backend,
              "The identifier of the back end used for the SCF calculation.")
        .def_property_readonly("n_orbs", &ReferenceState::n_orbs,
                               "Number of molecular orbitals")
        .def_property_readonly("n_orbs_alpha", &ReferenceState::n_orbs_alpha,
                               "Number of alpha orbitals")
        .def_property_readonly("n_orbs_beta", &ReferenceState::n_orbs_beta,
                               "Number of beta orbitals")
        .def_property_readonly("n_alpha", &ReferenceState::n_alpha,
                               "Number of alpha electrons")
        .def_property_readonly("n_beta", &ReferenceState::n_beta,
                               "Number of beta electrons")
        .def_property_readonly(
              "nuclear_total_charge",
              [](const ReferenceState& ref) { return ref.nuclear_multipole(0)[0]; })
        .def_property_readonly("nuclear_dipole",
                               [](const ReferenceState& ref) {
                                 py::array_t<scalar_type> ret(std::vector<ssize_t>{3});
                                 auto res = ref.nuclear_multipole(1);
                                 std::copy(res.begin(), res.end(), ret.mutable_data());
                                 return res;
                               })
        .def_property_readonly("conv_tol", &ReferenceState::conv_tol,
                               "SCF convergence tolererance")
        .def_property_readonly("energy_scf", &ReferenceState::energy_scf,
                               "Final total SCF energy")
        //
        .def("orbital_energies", &ReferenceState::orbital_energies,
             "Return the orbital energies corresponding to the provided space")
        .def("orbital_coefficients", &ReferenceState::orbital_coefficients,
             "Return the molecular orbital coefficients corresponding to the provided "
             "space (alpha and beta coefficients are returned)")
        .def("orbital_coefficients_alpha", &ReferenceState::orbital_coefficients_alpha,
             "Return the alpha molecular orbital coefficients corresponding to the "
             "provided space")
        .def("orbital_coefficients_beta", &ReferenceState::orbital_coefficients_beta,
             "Return the beta molecular orbital coefficients corresponding to the "
             "provided space")
        .def("fock", &ReferenceState::fock,
             "Return the Fock matrix block corresponding to the provided space.")
        .def("eri", &ReferenceState::eri,
             "Return the ERI (electron-repulsion integrals) tensor block corresponding "
             "to the provided space.")
        //
        .def("import_all", &ReferenceState::import_all,
             "Normally the class only imports the Fock matrix blocks and "
             "electron-repulsion integrals of a particular space combination when this "
             "is requested by a call to above fock() or eri() functions. This function "
             "call, however, instructs the class to immediately import *all* such "
             "blocks. Typically you do not want to do this.")
        .def_property("cached_fock_blocks", &ReferenceState::cached_fock_blocks,
                      &ReferenceState::set_cached_fock_blocks,
                      "Get or set the list of momentarily cached Fock matrix blocks\n"
                      "\n"
                      "Setting this property allows to drop fock matrix blocks if they "
                      "are no longer needed to save memory.")
        .def_property("cached_eri_blocks", &ReferenceState::cached_eri_blocks,
                      &ReferenceState::set_cached_eri_blocks,
                      "Get or set the list of momentarily cached ERI tensor blocks\n"
                      "\n"
                      "Setting this property allows to drop ERI tensor blocks if they "
                      "are no longer needed to save memory.")
        .def("flush_hf_cache", &ReferenceState::flush_hf_cache,
             "Tell the contained HartreeFockSolution_i object (which was passed upon "
             "construction), that a larger amount of import operations is done and that "
             "the next request for further imports will most likely take some time, such "
             "that intermediate caches can now be flushed to save some memory or other "
             "resources.")
        .def_property_readonly(
              "timer",
              [](const ReferenceState& self) { return convert_timer(self.timer()); },
              "Obtain the timer object of this class.")
        //
        ;
}

}  // namespace libadcc

1	//
2	// Copyright (C) 2018 by the adcc authors
3	//
4	// This file is part of adcc.
5	//
6	// adcc is free software: you can redistribute it and/or modify
7	// it under the terms of the GNU General Public License as published
8	// by the Free Software Foundation, either version 3 of the License, or
9	// (at your option) any later version.
10	//
11	// adcc is distributed in the hope that it will be useful,
12	// but WITHOUT ANY WARRANTY; without even the implied warranty of
13	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	// GNU General Public License for more details.
15	//
16	// You should have received a copy of the GNU General Public License
17	// along with adcc. If not, see <http://www.gnu.org/licenses/>.
18	//
19
20	#include "../ReferenceState.hh"
21	#include "hartree_fock_solution_hack.hh"
22	#include <pybind11/numpy.h>
23	#include <pybind11/pybind11.h>
24	#include <pybind11/stl.h>
25
26	namespace libadcc {
27	namespace py = pybind11;
28
29	py::object convert_timer(const Timer& timer) {	236✔
30	// Determine the shift between the C++ and the python clocks
31	py::object pynow = py::module::import("time").attr("perf_counter");	236✔
32	const double clock_shift = pynow().cast<double>() - Timer::now();	236✔
33
34	// Shift the data and convert to python
35	py::dict shifted_intervals;	236✔
36	for (const auto& kv : timer.intervals) {	2,880✔
37	py::list intlist;	2,644✔
38	for (const auto& p : kv.second) {	5,288✔
39	intlist.append(py::make_tuple(clock_shift + p.first, clock_shift + p.second));	2,644✔
40	}
41	shifted_intervals[py::cast(kv.first)] = intlist;	2,644✔
42	}	2,644✔
43	py::dict shifted_start_times;	236✔
44	for (const auto& kv : timer.start_times) {	236✔
45	shifted_start_times[py::cast(kv.first)] = kv.second + clock_shift;	×
46	}
47
48	py::object pyTimer = py::module::import("adcc.timings").attr("Timer");	236✔
49	py::object ret = pyTimer();	236✔
50	ret.attr("raw_data") = shifted_intervals;	236✔
51	ret.attr("start_times") = shifted_start_times;	236✔
52	ret.attr("time_construction") = timer.time_construction + clock_shift;	236✔
53	return ret;	472✔
54	}	236✔
55
56	void export_ReferenceState(py::module& m) {	5✔
57
58	py::class_<ReferenceState, std::shared_ptr<ReferenceState>>(	5✔
59	m, "ReferenceState",
60	"Class representing information about the reference state for adcc. Python "
61	"binding to"
62	":cpp:class:`libadcc::ReferenceState`.")
63	.def(py::init<std::shared_ptr<const HartreeFockSolution_i>,	5✔
64	std::shared_ptr<const MoSpaces>, bool>(),	5✔
65	"Setup a ReferenceStateject using an MoSpaces object.\n"
66	"\n"
67	"hfsoln_ptr Pointer to the Interface to the host program,\n"
68	" providing the HartreeFockSolution data, which\n"
69	" will be provided by this object.\n"
70	"mo_ptr MoSpaces object containing info about the MoSpace setup\n"
71	" and the point group symmetry.\n"
72	"symmetry_check_on_import\n"
73	" Should symmetry of the imported objects be checked\n"
74	" explicitly during the import process. This massively "
75	"slows\n"
76	" down the import process and has a dramatic impact on "
77	"memory\n"
78	" usage and should thus only be used for debugging import "
79	"routines\n"
80	" from the host programs. Do not enable this unless you "
81	"know\n"
82	" that you really want to.\n")
83	.def_property_readonly("restricted", &ReferenceState::restricted,	5✔
84	"Return whether the reference is restricted or not.")
85	.def_property_readonly(	10✔
86	"spin_multiplicity", &ReferenceState::spin_multiplicity,	5✔
87	"Return the spin multiplicity of the reference state. 0 indicates "
88	"that the spin cannot be determined or is not integer (e.g. UHF)")
89	.def_property_readonly("has_core_occupied_space",	10✔
90	&ReferenceState::has_core_occupied_space,	5✔
91	"Is a core occupied space setup, such that a core-valence "
92	"separation can be applied.")
93	.def_property_readonly("irreducible_representation",	10✔
94	&ReferenceState::irreducible_representation,	5✔
95	"Reference state irreducible representation")
96	.def_property_readonly("mospaces", &ReferenceState::mospaces_ptr,	5✔
97	"The MoSpaces object supplied on initialisation")
98	.def_property_readonly(	10✔
99	"backend", &ReferenceState::backend,	5✔
100	"The identifier of the back end used for the SCF calculation.")
101	.def_property_readonly("n_orbs", &ReferenceState::n_orbs,	5✔
102	"Number of molecular orbitals")
103	.def_property_readonly("n_orbs_alpha", &ReferenceState::n_orbs_alpha,	5✔
104	"Number of alpha orbitals")
105	.def_property_readonly("n_orbs_beta", &ReferenceState::n_orbs_beta,	5✔
106	"Number of beta orbitals")
107	.def_property_readonly("n_alpha", &ReferenceState::n_alpha,	5✔
108	"Number of alpha electrons")
109	.def_property_readonly("n_beta", &ReferenceState::n_beta,	5✔
110	"Number of beta electrons")
111	.def_property_readonly(	5✔
112	"nuclear_total_charge",
113	[](const ReferenceState& ref) { return ref.nuclear_multipole(0)[0]; })	76✔
114	.def_property_readonly("nuclear_dipole",	5✔
UNCOV 115	[](const ReferenceState& ref) {	×
116	py::array_t<scalar_type> ret(std::vector<ssize_t>{3});	576✔
117	auto res = ref.nuclear_multipole(1);	288✔
118	std::copy(res.begin(), res.end(), ret.mutable_data());	288✔
119	return res;	576✔
120	})	288✔
121	.def_property_readonly("conv_tol", &ReferenceState::conv_tol,	5✔
122	"SCF convergence tolererance")
123	.def_property_readonly("energy_scf", &ReferenceState::energy_scf,	5✔
124	"Final total SCF energy")
125	//
126	.def("orbital_energies", &ReferenceState::orbital_energies,	5✔
127	"Return the orbital energies corresponding to the provided space")
128	.def("orbital_coefficients", &ReferenceState::orbital_coefficients,	5✔
129	"Return the molecular orbital coefficients corresponding to the provided "
130	"space (alpha and beta coefficients are returned)")
131	.def("orbital_coefficients_alpha", &ReferenceState::orbital_coefficients_alpha,	5✔
132	"Return the alpha molecular orbital coefficients corresponding to the "
133	"provided space")
134	.def("orbital_coefficients_beta", &ReferenceState::orbital_coefficients_beta,	5✔
135	"Return the beta molecular orbital coefficients corresponding to the "
136	"provided space")
137	.def("fock", &ReferenceState::fock,	5✔
138	"Return the Fock matrix block corresponding to the provided space.")
139	.def("eri", &ReferenceState::eri,	5✔
140	"Return the ERI (electron-repulsion integrals) tensor block corresponding "
141	"to the provided space.")
142	//
143	.def("import_all", &ReferenceState::import_all,	5✔
144	"Normally the class only imports the Fock matrix blocks and "
145	"electron-repulsion integrals of a particular space combination when this "
146	"is requested by a call to above fock() or eri() functions. This function "
147	"call, however, instructs the class to immediately import all such "
148	"blocks. Typically you do not want to do this.")
149	.def_property("cached_fock_blocks", &ReferenceState::cached_fock_blocks,	×
150	&ReferenceState::set_cached_fock_blocks,	5✔
151	"Get or set the list of momentarily cached Fock matrix blocks\n"
152	"\n"
153	"Setting this property allows to drop fock matrix blocks if they "
154	"are no longer needed to save memory.")
155	.def_property("cached_eri_blocks", &ReferenceState::cached_eri_blocks,	×
156	&ReferenceState::set_cached_eri_blocks,	5✔
157	"Get or set the list of momentarily cached ERI tensor blocks\n"
158	"\n"
159	"Setting this property allows to drop ERI tensor blocks if they "
160	"are no longer needed to save memory.")
161	.def("flush_hf_cache", &ReferenceState::flush_hf_cache,	5✔
162	"Tell the contained HartreeFockSolution_i object (which was passed upon "
163	"construction), that a larger amount of import operations is done and that "
164	"the next request for further imports will most likely take some time, such "
165	"that intermediate caches can now be flushed to save some memory or other "
166	"resources.")
167	.def_property_readonly(	5✔
168	"timer",
169	[](const ReferenceState& self) { return convert_timer(self.timer()); },	241✔
170	"Obtain the timer object of this class.")
171	//
172	;
173	}	5✔
174
175	} // namespace libadcc

adc-connect / adcc / 13630814717

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous