diff --git a/Makefile.am b/Makefile.am index 945663e..2bfe889 100644 --- a/Makefile.am +++ b/Makefile.am @@ -238,8 +238,9 @@ numpy_i = $(srcdir)/src/numpy.i python-test: $(TEST_PY) - python3 $(TEST_PY) + python3 -m pytest -v $(TEST_PY) $(RM) -r -- __pycache__ + $(RM) -f -- test_file_py.h5 unsafe_test_file_py.h5 python-install: $(pytrexio_py) $(setup_py) $(setup_cfg) cd python && \ diff --git a/python/README.md b/python/README.md index cc17805..078389c 100644 --- a/python/README.md +++ b/python/README.md @@ -12,8 +12,7 @@ can be used to convert data from one input/output file format into another. ## Requirements - python3 (>= 3.6) -- numpy (>= 1.17.3) - +- numpy (>= 1.17.3) ## Installation from PyPI @@ -31,10 +30,11 @@ For more details, see the corresponding part of the [Python documentation](https ## Additional requirements (for installation from source) -- C compiler (gcc/icc/clang) +- C compiler (gcc/icc/clang) - HDF5 library (>= 1.8) - pkgconfig (Python package) - build (Python package) +- pytest (Python package) ## Installation from source @@ -44,10 +44,10 @@ For more details, see the corresponding part of the [Python documentation](https 4. `pip install -r requirements.txt` (this installs all required python dependencies) 5. Export custom environment variables needed for the installation following the procedure below and replacing `/path/to/hdf5/` with your paths. The following two steps can be skipped if HDF5 is properly configured for `pkg-config` (i.e. if executing `pkg-config --libs hdf5` returns a list of options). - 1. `export H5_CFLAGS=-I/path/to/hdf5/include` - 2. `export H5_LDFLAGS=-L/path/to/hdf5/lib` + - `export H5_CFLAGS=-I/path/to/hdf5/include` + - `export H5_LDFLAGS=-L/path/to/hdf5/lib` 6. `pip install .` (this installs `trexio` in your environment) -7. `cd test && python test_api.py` (this executes several tests that verify the installation) +7. `cd test && python -m pytest -v test_api.py` (this executes several tests that verify the installation) You are ready to go! diff --git a/python/install_pytrexio.sh b/python/install_pytrexio.sh index 764bc85..8542874 100755 --- a/python/install_pytrexio.sh +++ b/python/install_pytrexio.sh @@ -28,6 +28,7 @@ fi # Install/upgrade packages required for the installation python3 -m pip install --upgrade setuptools build pip python3 -m pip install -r requirements.txt +python3 -m pip install pytest # export NUMPY_INCLUDEDIR environment variable needed for the proper setup #source tools/set_NUMPY_INCLUDEDIR.sh diff --git a/python/test/test_api.py b/python/test/test_api.py index 60e8dd2..e9eea8b 100644 --- a/python/test/test_api.py +++ b/python/test/test_api.py @@ -1,385 +1,320 @@ #!/usr/bin/env python3 -import os -import shutil import numpy as np - +import pytest import trexio +from benzene_data import * -#=========================================================# -#======== SETUP THE BACK END AND OUTPUT FILE NAME ========# -#=========================================================# - -# 0: TREXIO_HDF5 ; 1: TREXIO_TEXT -TEST_TREXIO_BACKEND = 0 -OUTPUT_FILENAME_TEXT = 'test_py_swig.dir' -OUTPUT_FILENAME_HDF5 = 'test_py_swig.h5' - - -# define TREXIO file name -if TEST_TREXIO_BACKEND == trexio.TREXIO_HDF5: - output_filename = OUTPUT_FILENAME_HDF5 -elif TEST_TREXIO_BACKEND == trexio.TREXIO_TEXT: - output_filename = OUTPUT_FILENAME_TEXT -else: - raise ValueError ('Specify one of the supported back ends as TEST_TREXIO_BACKEND') - - -# remove TREXIO file if exists in the current directory -try: - if TEST_TREXIO_BACKEND == trexio.TREXIO_HDF5: - os.remove(output_filename) - elif TEST_TREXIO_BACKEND == trexio.TREXIO_TEXT: - shutil.rmtree(output_filename) -except: - print('Nothing to remove.') -#=========================================================# -#============ WRITE THE DATA IN THE TEST FILE ============# -#=========================================================# +FILENAME = 'test_file_py.h5' +BACK_END = trexio.TREXIO_HDF5 -trexio.info() +def clean(): + """Remove test files.""" + import os -# test with ... as ... block -with trexio.File(output_filename, mode='w', back_end=TEST_TREXIO_BACKEND) as tfile: - trexio.write_metadata_description(tfile, 'Test file produced by the Python API') - assert trexio.has_metadata_description(tfile) - assert tfile.isOpen - -# the file handle can remain existing but the file itself is closed upon exit from the `with` block -assert not tfile.isOpen - + try: + os.remove(FILENAME) + os.remove('unsafe_' + FILENAME) + except FileNotFoundError: + pass -# create TREXIO file and open it for writing -test_file = trexio.File(output_filename, mode='w', back_end=TEST_TREXIO_BACKEND) -assert test_file.exists -# Print docstring of the trexio.open function -#print(trexio.open.__doc__) +def test_info(): + """Print the output of the trexio.info function.""" + trexio.info() -nucleus_num = 12 -try: - trexio.write_nucleus_num(test_file, -100) -except trexio.Error: - print('Raise error for an attempt to write negative nucleus_num: checked.') +def test_void(): + """Check raise of an error upon I/O on non-existing file.""" + with pytest.raises(trexio.Error): + _ = trexio.File('void.file', 'r', BACK_END) -# write nucleus_num in the file -try: - trexio.write_nucleus_num(test_file, nucleus_num) -except: - raise - -try: - trexio.write_nucleus_num(test_file, nucleus_num*2) -except trexio.Error: - print('Raise error for an attempt to overwrite nucleus_num: checked.') - -# initialize charge arrays as a list and convert it to numpy array -charges = [6., 6., 6., 6., 6., 6., 1., 1., 1., 1., 1., 1.] -#charges_np = np.array(charges, dtype=np.float32) -charges_np = np.array(charges, dtype=np.int32) - -# function call below works with both lists and numpy arrays, dimension needed for memory-safety is derived -# from the size of the list/array by SWIG using typemaps from numpy.i -trexio.write_nucleus_charge(test_file, charges_np) - -basis_shell_num = 24 -# initialize arrays of nuclear indices as a list and convert it to numpy array -indices = [i for i in range(basis_shell_num)] -# type cast is important here because by default numpy transforms a list of integers into int64 array -indices_np = np.array(indices, dtype=np.int64) - -# first write basis_shell_num because it is needed to check dimensions of basis_nucleus_index in TREXIO >= 2.0.0 -trexio.write_basis_shell_num(test_file, basis_shell_num) - -# function call below works with both lists and numpy arrays, dimension needed for memory-safety is derived -# from the size of the list/array by SWIG using typemacs from numpy.i -trexio.write_basis_nucleus_index(test_file, indices_np) - -# initialize a list of nuclear coordinates -coords = [ - [ 0.00000000 , 1.39250319 , 0.00000000 ], - [-1.20594314 , 0.69625160 , 0.00000000 ], - [-1.20594314 , -0.69625160 , 0.00000000 ], - [ 0.00000000 , -1.39250319 , 0.00000000 ], - [ 1.20594314 , -0.69625160 , 0.00000000 ], - [ 1.20594314 , 0.69625160 , 0.00000000 ], - [-2.14171677 , 1.23652075 , 0.00000000 ], - [-2.14171677 , -1.23652075 , 0.00000000 ], - [ 0.00000000 , -2.47304151 , 0.00000000 ], - [ 2.14171677 , -1.23652075 , 0.00000000 ], - [ 2.14171677 , 1.23652075 , 0.00000000 ], - [ 0.00000000 , 2.47304151 , 0.00000000 ], - ] - -# write coordinates in the file -trexio.write_nucleus_coord(test_file, coords) - - -# write ao_num (needed later to write sparse ao_2e_int_eri integrals) -trexio.write_ao_num(test_file, 600) - -# write sparse data in the file -num_integrals = 100 -indices = [i for i in range(num_integrals*4)] -values = [(3.14 + float(i)) for i in range(num_integrals)] - -trexio.write_ao_2e_int_eri(test_file, 0, num_integrals, indices, values) - - -# write mo_num (needed later to write determinants) -mo_num = 150 -trexio.write_mo_num(test_file, mo_num) - -int_num = trexio.get_int64_num(test_file) -assert(int_num == int((mo_num-1)/64+1)) -int_num *= 2 - -# write determinants in the file -num_dets = 50 -offset = 0 -dets = [i for i in range(num_dets*int_num)] -coeffs = [(3.14 + float(i)) for i in range(num_dets)] -coeffs_s2 = [(6.28 + float(i)) for i in range(num_dets)] - -trexio.write_determinant_list(test_file, offset, num_dets, dets) -trexio.write_determinant_coefficient(test_file, offset, num_dets, coeffs) - -test_file.set_state(2) -trexio.write_determinant_coefficient(test_file, offset, num_dets, coeffs_s2) -test_file.set_state(0) - -# manually check the consistency between coefficient_size and number of determinants -assert trexio.read_determinant_coefficient_size(test_file) == trexio.read_determinant_num(test_file) - -# write nucleus_point_group in the file -point_group = 'B3U' - -trexio.write_nucleus_point_group(test_file, point_group) - - -# write nucleus_label in the file -labels = [ - 'C', - 'C', - 'C', - 'C', - 'C', - 'C', - 'H', - 'H', - 'H', - 'H', - 'H', - 'H'] - -trexio.write_nucleus_label(test_file,labels) - -# close TREXIO file -# this call is no longer needed as we introduced TREXIO_File class which has a desctructor that closes the file -#trexio.close(test_file) -# without calling destructor on test_file the TREXIO_FILE is not getting created and the data is not written when using TEXT back end. -# This, the user still has to explicitly call destructor on test_file object instead of the trexio.close function. -# This is only an issue when the data is getting written and read in the same session (e.g. in Jupyter notebook) -del test_file - - -#==========================================================# -#========== DELETE THE GROUP FROM THE TEST FILE ===========# -#==========================================================# - -unsafe_file = trexio.File(output_filename, 'u', TEST_TREXIO_BACKEND) - -# overwrite existing data (only allowed in 'u' - unsafe mode) -trexio.write_nucleus_num(unsafe_file, nucleus_num) -trexio.write_nucleus_charge(unsafe_file, charges_np) -trexio.write_nucleus_coord(unsafe_file, coords) -trexio.write_nucleus_label(unsafe_file,labels) -trexio.write_nucleus_point_group(unsafe_file, point_group) - -print('Overwriting the data in UNSAFE mode: checked') - -# delete existing group (only allowed in 'u' - unsafe mode) -trexio.delete_nucleus(unsafe_file) - -assert not trexio.has_nucleus_num(unsafe_file) -assert not trexio.has_nucleus_charge(unsafe_file) -assert not trexio.has_nucleus_coord(unsafe_file) -assert not trexio.has_nucleus_label(unsafe_file) -assert not trexio.has_nucleus_point_group(unsafe_file) - -print('Deleting nucleus group in UNSAFE mode: checked') - -# restore the deleted data -trexio.write_nucleus_num(unsafe_file, nucleus_num) -trexio.write_nucleus_charge(unsafe_file, charges_np) -trexio.write_nucleus_coord(unsafe_file, coords) -trexio.write_nucleus_label(unsafe_file,labels) -trexio.write_nucleus_point_group(unsafe_file, point_group) - -del unsafe_file - -#==========================================================# -#============ READ THE DATA FROM THE TEST FILE ============# -#==========================================================# - -# open previously created TREXIO file, now in 'read' mode -test_file2 = trexio.File(output_filename, 'r', trexio.TREXIO_AUTO) -assert test_file2.exists - -# check for existence of some of the previously written variables -assert trexio.has_nucleus_num(test_file2) -assert trexio.has_nucleus_charge(test_file2) -assert trexio.has_nucleus_coord(test_file2) -assert trexio.has_nucleus_label(test_file2) -assert trexio.has_nucleus_point_group(test_file2) -assert trexio.has_ao_2e_int_eri(test_file2) -assert trexio.has_determinant_list(test_file2) -assert trexio.has_determinant_coefficient(test_file2) - -# read nucleus_num from file -rnum = trexio.read_nucleus_num(test_file2) -assert rnum==nucleus_num - -# safe call to read_nucleus_charge array of float values -rcharges_np = trexio.read_nucleus_charge(test_file2, dim=nucleus_num) -assert rcharges_np.dtype is np.dtype(np.float64) -np.testing.assert_array_almost_equal(rcharges_np, charges_np, decimal=8) - -# unsafe call to read_safe should fail with error message corresponding to TREXIO_UNSAFE_ARRAY_DIM -try: - rcharges_fail = trexio.read_nucleus_charge(test_file2, dim=nucleus_num*5) -except trexio.Error: - print('Unsafe call to safe API: checked') - -# safe call to read array of int values (nuclear indices) -rindices_np_16 = trexio.read_basis_nucleus_index(test_file2, dim=basis_shell_num, dtype=np.int16) -assert rindices_np_16.dtype is np.dtype(np.int16) -for i in range(basis_shell_num): - assert rindices_np_16[i]==indices_np[i] - -rindices_np_32 = trexio.read_basis_nucleus_index(test_file2, dim=basis_shell_num, dtype=np.int32) -assert rindices_np_32.dtype is np.dtype(np.int32) -for i in range(basis_shell_num): - assert rindices_np_32[i]==indices_np[i] - -rindices_np_64 = trexio.read_basis_nucleus_index(test_file2) -assert rindices_np_64.dtype is np.dtype(np.int64) -assert rindices_np_64.size==basis_shell_num -for i in range(basis_shell_num): - assert rindices_np_64[i]==indices_np[i] - -# read nuclear coordinates without providing optional argument dim -rcoords_np = trexio.read_nucleus_coord(test_file2) - -assert rcoords_np.size==nucleus_num*3 -np.testing.assert_array_almost_equal(rcoords_np, np.array(coords).reshape(nucleus_num,3), decimal=8) - -# set doReshape to False to get a flat 1D array (e.g. when reading matrices like nuclear coordinates) -#rcoords_reshaped_2 = trexio.read_nucleus_coord(test_file2, doReshape=False) - -# read number of integrals already present in the file -assert trexio.has_ao_2e_int_eri(test_file2) -assert trexio.read_ao_2e_int_eri_size(test_file2)==num_integrals - -# read sparse arrays on ao_2e_int_eri integrals -buf_size = 60 -offset_file = 0 -# read full buf_size (i.e. the one that does not reach EOF) -indices_sparse_np, value_sparse_np, read_buf_size, eof = trexio.read_ao_2e_int_eri(test_file2, offset_file, buf_size) -print(f'First complete sparse read size: {read_buf_size}') -#print(indices_sparse_np) -assert not eof -assert read_buf_size==buf_size -assert indices_sparse_np[0][0]==0 -assert indices_sparse_np[read_buf_size-1][3]==read_buf_size*4-1 -offset_file += buf_size - -# read incomplete buf_size (i.e. the one that does reach EOF) -indices_sparse_np, value_sparse_np, read_buf_size, eof2 = trexio.read_ao_2e_int_eri(test_file2, offset_file, buf_size) -print(f'Second incomplete sparse read size: {read_buf_size}') -#print(indices_sparse_np) -assert eof2 -assert read_buf_size==(num_integrals - buf_size) -assert indices_sparse_np[0][0]==offset_file*4 -assert indices_sparse_np[read_buf_size-1][3]==(offset_file+read_buf_size)*4-1 - -# read number of determinants already present in the file -assert trexio.has_determinant_list(test_file2) -assert trexio.read_determinant_num(test_file2)==num_dets - -# read determinants (list of ints and float coefficients) -buf_size = 20 -offset_file = 0 -# read full buf_size (i.e. the one that does not reach EOF) -dets_np, read_buf_size, eof = trexio.read_determinant_list(test_file2, offset_file, buf_size) -print(f'First complete read of determinant list: {read_buf_size}') -#print(indices_sparse_np) -assert not eof -assert read_buf_size==buf_size -assert dets_np[0][0]==0 -assert dets_np[read_buf_size-1][int_num-1]==read_buf_size*int_num-1 - -coefficients_np, read_buf_size, eof = trexio.read_determinant_coefficient(test_file2, offset_file, buf_size) -print(f'First complete read of determinant coefficients: {read_buf_size}') -#print(indices_sparse_np) -assert not eof -assert read_buf_size==buf_size - -# convert one determinant into a list of orbitals - -dets_tmp = dets_np[read_buf_size-1][:] -#print(dets_tmp) - -# divide by 2 because in this test int_num is the total number of integers (i.e. up-spin + down_spin) -orb_list_up, orb_list_dn = trexio.to_orbital_list_up_dn(int(int_num/2), dets_tmp) -assert(orb_list_up[0] == 1) -assert(orb_list_dn[0] == 0) -#print(orb_list_up) -#print(orb_list_dn) - -# read array of nuclear labels -rlabels_2d = trexio.read_nucleus_label(test_file2, dim=nucleus_num) -print(rlabels_2d) -for i in range(nucleus_num): - assert rlabels_2d[i]==labels[i] - -# read a string corresponding to nuclear point group -rpoint_group = trexio.read_nucleus_point_group(test_file2) -assert rpoint_group==point_group - -# another way to read only if the variable exists -if trexio.has_ao_num(test_file2): - rao_num = trexio.read_ao_num(test_file2) -else: - print('Pass on reading the non-existing variable ao_num: checked') - -# close TREXIO file -#trexio.close(test_file2) - -# cleaning (remove the TREXIO file) -try: - if TEST_TREXIO_BACKEND == trexio.TREXIO_HDF5: - os.remove(output_filename) - elif TEST_TREXIO_BACKEND == trexio.TREXIO_TEXT: - shutil.rmtree(output_filename) -except: - print(f'No output file {output_filename} has been produced') - -#==========================================================# - -#==========================================================# -#======= OPEN NON-EXISTING FILE TO TEST TREXIO.OPEN =======# -#==========================================================# - -try: - void_file = trexio.File('non_existing.file', 'r', TEST_TREXIO_BACKEND) -except trexio.Error as e: - if e.error == trexio.TREXIO_OPEN_ERROR: - print('Opening non-existing file returns TREXIO_OPEN_ERROR: checked') - else: - raise ValueError('[DEV]: error handling of trexio_open function has changed; check the consistency') - -#==========================================================# + +def test_orbital_list(): + """Convert one determinant into a list of orbitals.""" + orb_list_up, orb_list_dn = trexio.to_orbital_list_up_dn(int64_num, det_test) + assert orb_list_up[0] == 0 + assert orb_list_dn[0] == 1 + + +class TestIO: + """Unit tests for writing/reading different blocks of the TREXIO file.""" + + filename = FILENAME + back_end = BACK_END + mode = 'w' + test_file = None + + clean() + + + def __del__(self): + if self.test_file: + if self.test_file.isOpen: + self.test_file.close() + + + def open(self, filename=None, mode=None, back_end=None): + """Create a TREXIO file and open it for writing.""" + if not filename: + filename = self.filename + else: + self.filename = filename + if not mode: + mode = self.mode + else: + self.mode = mode + if not back_end: + back_end = self.back_end + else: + self.back_end = back_end + + self.test_file = trexio.File(filename, mode, back_end) + assert self.test_file.exists + + + def test_close(self): + """Close the file.""" + self.open() + if self.test_file.isOpen: + self.test_file.close() + assert not self.test_file.isOpen + + + def test_errors(self): + """Test some exceptions based on trexio.Error class.""" + self.open(filename='unsafe_' + self.filename, mode='w', back_end=self.back_end) + # try to write a negative number (should raise an error) + with pytest.raises(trexio.Error): + trexio.write_nucleus_num(self.test_file, -100) + + trexio.write_nucleus_num(self.test_file, nucleus_num) + + # try to overwrite a number (should raise an error) + with pytest.raises(trexio.Error): + trexio.write_nucleus_num(self.test_file, nucleus_num * 2) + + + def test_num(self): + """Write a number.""" + self.open() + trexio.write_nucleus_num(self.test_file, nucleus_num) + assert trexio.has_nucleus_num(self.test_file) + + + def test_str(self): + """Write a string.""" + self.open() + trexio.write_nucleus_point_group(self.test_file, point_group) + assert trexio.has_nucleus_point_group(self.test_file) + + + def test_array_str(self): + """Write an array of strings.""" + self.open() + if not trexio.has_nucleus_num(self.test_file): + self.test_num() + trexio.write_nucleus_label(self.test_file, nucleus_label) + assert trexio.has_nucleus_label(self.test_file) + + + def test_array_1D(self): + """Write array of charges.""" + self.open() + if not trexio.has_nucleus_num(self.test_file): + self.test_num() + trexio.write_nucleus_charge(self.test_file, nucleus_charge) + assert trexio.has_nucleus_charge(self.test_file) + + + def test_array_2D(self): + """Write array of coordinates.""" + self.open() + if not trexio.has_nucleus_num(self.test_file): + self.test_num() + trexio.write_nucleus_coord(self.test_file, nucleus_coord) + assert trexio.has_nucleus_coord(self.test_file) + + + def test_indices(self): + """Write array of indices.""" + self.open() + # type cast is important here because by default numpy transforms a list of integers into int64 array + indices_np = np.array(nucleus_index, dtype=np.int64) + # first write basis_shell_num because it is needed to check dimensions of basis_nucleus_index + trexio.write_basis_shell_num(self.test_file, basis_shell_num) + # now write the indices + trexio.write_basis_nucleus_index(self.test_file, indices_np) + assert trexio.has_basis_nucleus_index(self.test_file) + + + def test_sparse(self): + """Write a sparse array.""" + self.open() + # write ao_num (needed later to write sparse ao_2e_int_eri integrals) + trexio.write_ao_num(self.test_file, ao_num) + # one complete write (no chunking) + offset = 0 + trexio.write_ao_2e_int_eri(self.test_file, offset, num_integrals, indices, values) + assert trexio.has_ao_2e_int_eri(self.test_file) + + + def test_determinant(self): + """Write CI determinants and coefficients.""" + self.open() + # write mo_num (needed later to write determinants) + trexio.write_mo_num(self.test_file, mo_num) + # get the number of bit-strings per spin component + int_num = trexio.get_int64_num(self.test_file) + assert int_num == int64_num + # write the data for the ground state + offset = 0 + trexio.write_determinant_list(self.test_file, offset, det_num, dets) + assert trexio.has_determinant_list(self.test_file) + trexio.write_determinant_coefficient(self.test_file, offset, det_num, coeffs) + assert trexio.has_determinant_coefficient(self.test_file) + # write the data for some other state + self.test_file.set_state(2) + trexio.write_determinant_coefficient(self.test_file, offset, det_num, coeffs_s2) + assert trexio.has_determinant_coefficient(self.test_file) + self.test_file.set_state(0) + # manually check the consistency between coefficient_size and number of determinants + assert trexio.read_determinant_coefficient_size(self.test_file) == trexio.read_determinant_num(self.test_file) + + + def test_delete_group(self): + """Delete a group.""" + self.open(filename='unsafe_' + self.filename, mode='u', back_end=self.back_end) + + self.test_num() + self.test_array_1D() + self.test_array_2D() + + trexio.delete_nucleus(self.test_file) + + assert not trexio.has_nucleus_num(self.test_file) + assert not trexio.has_nucleus_charge(self.test_file) + assert not trexio.has_nucleus_coord(self.test_file) + + + def test_context_manager(self): + """Test the with ... as ... context handling.""" + with trexio.File(filename=self.filename, mode='u', back_end=self.back_end) as tfile: + trexio.write_metadata_description(tfile, 'Test file produced by the Python API') + assert trexio.has_metadata_description(tfile) + assert tfile.isOpen + # the file handle can remain existing but the file itself is closed upon exit from the `with` block + assert not tfile.isOpen + + + def test_read_num(self): + """Read a number.""" + self.open(mode='r') + num_r = trexio.read_nucleus_num(self.test_file) + assert num_r == nucleus_num + + + def test_read_array_1D(self): + """Read an array.""" + self.open(mode='r') + charges_np_r = trexio.read_nucleus_charge(self.test_file) + assert charges_np_r.dtype is np.dtype(np.float64) + assert charges_np_r.size == nucleus_num + np.testing.assert_array_almost_equal(charges_np_r, np.array(nucleus_charge), decimal=8) + + + def test_read_array_2D(self): + """Read an array.""" + self.open(mode='r') + # read nuclear coordinates without providing optional argument dim + coords_np = trexio.read_nucleus_coord(self.test_file) + assert coords_np.dtype is np.dtype(np.float64) + assert coords_np.size == nucleus_num * 3 + np.testing.assert_array_almost_equal(coords_np, np.array(nucleus_coord).reshape(nucleus_num,3), decimal=8) + + + def test_read_errors(self): + """Test some reading errors.""" + self.open(mode='r') + # unsafe call to read_safe should fail with error message corresponding to TREXIO_UNSAFE_ARRAY_DIM + with pytest.raises(trexio.Error): + _ = trexio.read_nucleus_charge(self.test_file, dim=nucleus_num/2) + + + def test_read_integers(self): + """Read some integer arrays.""" + self.open(mode='r') + + indices_np_16 = trexio.read_basis_nucleus_index(self.test_file, dtype=np.int16) + assert indices_np_16.dtype is np.dtype(np.int16) + assert (indices_np_16 == np.array(nucleus_index)).all() + + indices_np_32 = trexio.read_basis_nucleus_index(self.test_file, dtype=np.int32) + assert indices_np_32.dtype is np.dtype(np.int32) + assert (indices_np_32 == np.array(nucleus_index)).all() + + indices_np_64 = trexio.read_basis_nucleus_index(self.test_file) + assert indices_np_64.dtype is np.dtype(np.int64) + assert indices_np_64.size == basis_shell_num + assert (indices_np_64 == np.array(nucleus_index)).all() + + + def test_sparse_read(self): + """Read a sparse array.""" + self.open(mode='r') + # read sparse arrays on ao_2e_int_eri integrals + buf_size = 60 + offset_file = 0 + # read full buf_size (i.e. the one that does not reach EOF) + indices_sparse_np, value_sparse_np, read_buf_size, eof = trexio.read_ao_2e_int_eri(self.test_file, offset_file, buf_size) + #print(f'First complete sparse read size: {read_buf_size}') + assert not eof + assert read_buf_size == buf_size + assert indices_sparse_np[0][0] == 0 + assert indices_sparse_np[read_buf_size-1][3] == read_buf_size * 4 - 1 + + offset_file += buf_size + # read incomplete buf_size (i.e. the one that does reach EOF) + indices_sparse_np, value_sparse_np, read_buf_size, eof = trexio.read_ao_2e_int_eri(self.test_file, offset_file, buf_size) + #print(f'Second incomplete sparse read size: {read_buf_size}') + assert eof + assert read_buf_size == (num_integrals - buf_size) + assert indices_sparse_np[0][0] == offset_file * 4 + assert indices_sparse_np[read_buf_size-1][3] == (offset_file + read_buf_size) * 4 - 1 + + + def test_determinant_read(self): + """Read the CI determinants.""" + self.open(mode='r') + # read determinants (list of ints and float coefficients) + buf_size = 100 + offset_file = 0 + # read full buf_size (i.e. the one that does not reach EOF) + dets_np, read_buf_size, eof = trexio.read_determinant_list(self.test_file, offset_file, buf_size) + #print(f'First complete read of determinant list: {read_buf_size}') + assert not eof + assert read_buf_size == buf_size + assert dets_np[0][0] == 0 + assert dets_np[read_buf_size-1][int64_num*2-1] == read_buf_size * int64_num * 2- 1 + + coefficients_np, read_buf_size, eof = trexio.read_determinant_coefficient(self.test_file, offset_file, buf_size) + #print(f'First complete read of determinant coefficients: {read_buf_size}') + assert not eof + assert read_buf_size == buf_size + + + def test_array_str_read(self): + """Read an array of strings.""" + self.open(mode='r') + labels_r = trexio.read_nucleus_label(self.test_file) + assert len(labels_r) == nucleus_num + assert labels_r == nucleus_label + + + def test_str_read(self): + """Read a string.""" + self.open(mode='r') + point_group_r = trexio.read_nucleus_point_group(self.test_file) + assert point_group_r == point_group