def test_numroc(): from pyelpa import DistributedMatrix n = 100 nb = 16 assert (DistributedMatrix.numroc(n, nb, 0, 0, 3) == 36) assert (DistributedMatrix.numroc(n, nb, 1, 0, 3) == 32) assert (DistributedMatrix.numroc(n, nb, 1, 1, 3) == 36)
def test_distributed_matrix_like_other_matrix(na, nev, nblk): import numpy as np from pyelpa import ProcessorLayout, DistributedMatrix from mpi4py import MPI comm = MPI.COMM_WORLD layout_p = ProcessorLayout(comm) for dtype in [np.float64, np.float32, np.complex64, np.complex128]: a = DistributedMatrix(layout_p, na, nev, nblk, dtype=dtype) b = DistributedMatrix.like(a) assert (a.na == b.na) assert (a.nev == b.nev) assert (a.nblk == b.nblk) assert (a.data.dtype == b.data.dtype) assert (a.data.shape == b.data.shape)
def test_call_eigenvalues(na, nev, nblk): import numpy as np from pyelpa import ProcessorLayout, DistributedMatrix, Elpa from mpi4py import MPI comm = MPI.COMM_WORLD layout_p = ProcessorLayout(comm) for dtype in [np.float64, np.complex128]: # create arrays a = DistributedMatrix(layout_p, na, nev, nblk, dtype=dtype) a.data[:, :] = np.random.rand(a.na_rows, a.na_cols).astype(dtype) ev = np.zeros(na, dtype=np.float64) e = Elpa.from_distributed_matrix(a) e.eigenvalues(a.data, ev)
def test_distributed_matrix_from_world(na, nev, nblk): import numpy as np from pyelpa import DistributedMatrix for dtype in [np.float64, np.float32, np.complex64, np.complex128]: a = DistributedMatrix.from_comm_world(na, nev, nblk, dtype=dtype) assert (a.data.dtype == dtype) assert (a.data.shape == (a.na_rows, a.na_cols))
def test_distributed_matrix_global_index(na, nev, nblk): import numpy as np from pyelpa import ProcessorLayout, DistributedMatrix from mpi4py import MPI comm = MPI.COMM_WORLD layout_p = ProcessorLayout(comm) for dtype in [np.float64, np.complex128]: a = DistributedMatrix(layout_p, na, nev, nblk, dtype=dtype) for local_row in range(a.na_rows): for local_col in range(a.na_cols): global_row, global_col = a.get_global_index( local_row, local_col) l_row, l_col = a.get_local_index(global_row, global_col) assert (global_row >= 0 and global_row < a.na) assert (global_col >= 0 and global_col < a.na) assert (local_row == l_row and local_col == l_col)
def test_global_index_iterator(na, nev, nblk): import numpy as np from pyelpa import DistributedMatrix for dtype in [np.float64, np.complex128]: a = DistributedMatrix.from_comm_world(na, nev, nblk, dtype=dtype) for i, j in a.global_indices(): assert (a.is_local_index(i, j))
def test_distributed_matrix_from_processor_layout(na, nev, nblk): import numpy as np from pyelpa import ProcessorLayout, DistributedMatrix from mpi4py import MPI comm = MPI.COMM_WORLD layout_p = ProcessorLayout(comm) for dtype in [np.float64, np.float32, np.complex64, np.complex128]: a = DistributedMatrix(layout_p, na, nev, nblk, dtype=dtype) assert (a.data.dtype == dtype) assert (a.data.shape == (a.na_rows, a.na_cols))
def test_global_index_access(na, nev, nblk): import numpy as np from pyelpa import DistributedMatrix for dtype in [np.float64, np.complex128]: a = DistributedMatrix.from_comm_world(na, nev, nblk, dtype=dtype) for i, j in a.global_indices(): x = dtype(i * j) a.set_data_for_global_index(i, j, x) for i, j in a.global_indices(): x = a.get_data_for_global_index(i, j) assert (np.isclose(x, i * j))
def test_dot_product_incompatible_size(na, nev, nblk): import numpy as np from pyelpa import DistributedMatrix for dtype in [np.float64, np.complex128]: a = DistributedMatrix.from_comm_world(na, nev, nblk, dtype=dtype) # get global matrix and vector that is equal on all cores matrix = get_random_vector(na * na).reshape(na, na).astype(dtype) vector = get_random_vector(na * 2).astype(dtype) a.set_data_from_global_matrix(matrix) with pytest.raises(ValueError): product_distributed = a.dot(vector)
def test_accessing_matrix(na, nev, nblk): import numpy as np from pyelpa import DistributedMatrix for dtype in [np.float64, np.complex128]: a = DistributedMatrix.from_comm_world(na, nev, nblk, dtype=dtype) matrix = get_random_vector(na * na).reshape(na, na).astype(dtype) a.set_data_from_global_matrix(matrix) for index in range(a.na): column = a.get_column(index) assert (np.allclose(column, matrix[:, index])) row = a.get_row(index) assert (np.allclose(row, matrix[index, :]))
def test_distributed_matrix_from_communicator(na, nev, nblk): import numpy as np from pyelpa import DistributedMatrix from mpi4py import MPI comm = MPI.COMM_WORLD for dtype in [np.float64, np.float32, np.complex64, np.complex128]: a = DistributedMatrix.from_communicator(comm, na, nev, nblk, dtype=dtype) assert (a.data.dtype == dtype) assert (a.data.shape == (a.na_rows, a.na_cols))
def test_compare_eigenvalues_to_those_from_eigenvectors(na, nev, nblk): import numpy as np from pyelpa import ProcessorLayout, DistributedMatrix, Elpa from mpi4py import MPI comm = MPI.COMM_WORLD layout_p = ProcessorLayout(comm) for dtype in [np.float64, np.complex128]: # create arrays a = DistributedMatrix(layout_p, na, nev, nblk, dtype=dtype) random_matrix = np.random.rand(a.na_rows, a.na_cols).astype(dtype) a.data[:, :] = random_matrix q = DistributedMatrix(layout_p, na, nev, nblk, dtype=dtype) ev = np.zeros(na, dtype=np.float64) ev2 = np.zeros(na, dtype=np.float64) e = Elpa.from_distributed_matrix(a) e.eigenvectors(a.data, ev, q.data) a.data[:, :] = random_matrix e.eigenvalues(a.data, ev2) assert (np.allclose(ev, ev2))
def test_compare_eigenvalues_to_those_from_eigenvectors_self_functions( na, nev, nblk): import numpy as np from pyelpa import DistributedMatrix for dtype in [np.float64, np.complex128]: # create arrays a = DistributedMatrix.from_comm_world(na, nev, nblk, dtype=dtype) random_matrix = np.random.rand(a.na_rows, a.na_cols).astype(dtype) a.data[:, :] = random_matrix data = a.compute_eigenvectors() a.data[:, :] = random_matrix eigenvalues = a.compute_eigenvalues() assert (np.allclose(data['eigenvalues'], eigenvalues))
def test_global_block_access(na, nev, nblk): import numpy as np from pyelpa import DistributedMatrix for dtype in [np.float64, np.complex128]: a = DistributedMatrix.from_comm_world(na, nev, nblk, dtype=dtype) for i, j, blk_i, blk_j in a.global_block_indices(): x = np.arange(i, i + blk_i)[:, None] * np.arange( j, j + blk_j)[None, :] a.set_block_for_global_index(i, j, blk_i, blk_j, x) for i, j, blk_i, blk_j in a.global_block_indices(): original = np.arange(i, i + blk_i)[:, None] * np.arange( j, j + blk_j)[None, :] x = a.get_block_for_global_index(i, j, blk_i, blk_j) assert (np.allclose(x, original)) for i, j in a.global_indices(): x = a.get_data_for_global_index(i, j) assert (np.isclose(x, i * j))
def test_dot_product(na, nev, nblk): import numpy as np from pyelpa import ProcessorLayout, DistributedMatrix for dtype in [np.float64, np.complex128]: a = DistributedMatrix.from_comm_world(na, nev, nblk, dtype=dtype) # get global matrix and vector that is equal on all cores matrix = get_random_vector(na * na).reshape(na, na).astype(dtype) vector = get_random_vector(na).astype(dtype) a.set_data_from_global_matrix(matrix) product_distributed = a.dot(vector) product_naive = a._dot_naive(vector) product_serial = np.dot(matrix, vector) assert (np.allclose(product_distributed, product_serial)) assert (np.allclose(product_distributed, product_naive))
def test_validate_eigenvectors(na, nev, nblk): import numpy as np from pyelpa import DistributedMatrix for dtype in [np.float64, np.complex128]: a = DistributedMatrix.from_comm_world(na, nev, nblk, dtype=dtype) # get a symmetric/hermitian matrix matrix = get_random_vector(na * na).reshape(na, na).astype(dtype) matrix = 0.5 * (matrix + np.conj(matrix.T)) a.set_data_from_global_matrix(matrix) data = a.compute_eigenvectors() eigenvalues = data['eigenvalues'] eigenvectors = data['eigenvectors'] # reset data of a a.set_data_from_global_matrix(matrix) for index in range(a.nev): eigenvector = eigenvectors.get_column(index) scaled_eigenvector = eigenvalues[index] * eigenvector # test solution assert (np.allclose(a.dot(eigenvector), scaled_eigenvector))
def test_validate_eigenvectors_to_numpy(na, nev, nblk): import numpy as np from numpy import linalg from pyelpa import DistributedMatrix for dtype in [np.float64, np.complex128]: a = DistributedMatrix.from_comm_world(na, nev, nblk, dtype=dtype) # get a symmetric/hermitian matrix matrix = get_random_vector(na * na).reshape(na, na).astype(dtype) matrix = 0.5 * (matrix + np.conj(matrix.T)) a.set_data_from_global_matrix(matrix) data = a.compute_eigenvectors() eigenvalues = data['eigenvalues'] eigenvectors = data['eigenvectors'] # get numpy solution eigenvalues_np, eigenvectors_np = linalg.eigh(matrix) assert (np.allclose(eigenvalues, eigenvalues_np)) for index in range(a.nev): eigenvector = eigenvectors.get_column(index) assert (np.allclose(eigenvector, eigenvectors_np[:, index]) or np.allclose(eigenvector, -eigenvectors_np[:, index]))
def test_setting_global_matrix(na, nev, nblk): import numpy as np from pyelpa import ProcessorLayout, DistributedMatrix from mpi4py import MPI comm = MPI.COMM_WORLD layout_p = ProcessorLayout(comm) for dtype in [np.float64, np.complex128]: a = DistributedMatrix(layout_p, na, nev, nblk, dtype=dtype) # get global matrix that is equal on all cores matrix = get_random_vector(na * na).reshape(na, na).astype(dtype) a.set_data_from_global_matrix(matrix) # check data for global_row in range(a.na): for global_col in range(a.na): if not a.is_local_index(global_row, global_col): continue local_row, local_col = a.get_local_index( global_row, global_col) assert (a.data[local_row, local_col] == matrix[global_row, global_col])
def test_distributed_matrix_indexing_loop(na, nev, nblk): import numpy as np from pyelpa import ProcessorLayout, DistributedMatrix from mpi4py import MPI comm = MPI.COMM_WORLD layout_p = ProcessorLayout(comm) for dtype in [np.float64, np.complex128]: a = DistributedMatrix(layout_p, na, nev, nblk, dtype=dtype) for local_row in range(a.na_rows): for local_col in range(a.na_cols): global_row, global_col = a.get_global_index( local_row, local_col) a.data[local_row, local_col] = global_row * 10 + global_col for global_row in range(a.na): for global_col in range(a.na): if not a.is_local_index(global_row, global_col): continue local_row, local_col = a.get_local_index( global_row, global_col) assert (a.data[local_row, local_col] == global_row * 10 + global_col)
#!/usr/bin/env python import numpy as np from pyelpa import DistributedMatrix import sys # set some parameters for matrix layout na = 1000 nev = 200 nblk = 16 # create distributed matrix a = DistributedMatrix.from_comm_world(na, nev, nblk) # set matrix a by looping over indices # this is the easiest but also slowest way for global_row, global_col in a.global_indices(): a.set_data_for_global_index(global_row, global_col, global_row * global_col) print("Call ELPA eigenvectors") sys.stdout.flush() # now compute nev of na eigenvectors and eigenvalues data = a.compute_eigenvectors() eigenvalues = data['eigenvalues'] eigenvectors = data['eigenvectors'] print("Done") # now eigenvectors.data contains the local part of the eigenvector matrix # which is stored in a block-cyclic distributed layout and eigenvalues contains