def setUp(self):
if not os.access('.', os.W_OK):
raise RuntimeError('Cannot write to current directory')
self.test_dir = 'files_vectorspace_DELETE_ME'
if not os.path.isdir(self.test_dir):
parallel.call_from_rank_zero(os.mkdir, self.test_dir)
self.max_vecs_per_proc = 10
self.total_num_vecs_in_mem = (parallel.get_num_procs() *
self.max_vecs_per_proc)
self.vec_space = vspc.VectorSpaceHandles(inner_product=np.vdot,
verbosity=0)
self.vec_space.max_vecs_per_proc = self.max_vecs_per_proc
# Default data members; set verbosity to 0 even though default is 1
# so messages won't print during tests
self.default_data_members = {
'inner_product':
np.vdot,
'max_vecs_per_node':
10000,
'max_vecs_per_proc':
(10000 * parallel.get_num_nodes() // parallel.get_num_procs()),
'verbosity':
0,
'print_interval':
10,
'prev_print_time':
0.
}
parallel.barrier()
def test_init(self):
"""Test arguments passed to the constructor are assigned properly"""
# Get default data member values
# Set verbosity to false, to avoid printing warnings during tests
def my_load():
pass
def my_save():
pass
def my_IP():
pass
data_members_default = {
'put_mat': util.save_array_text,
'get_mat': util.load_array_text,
'verbosity': 0,
'eigvecs': None,
'eigvals': None,
'correlation_mat': None,
'vec_handles': None,
'vecs': None,
'vec_space': VectorSpaceHandles(inner_product=my_IP, verbosity=0)
}
for k, v in util.get_data_members(PODHandles(my_IP,
verbosity=0)).items():
self.assertEqual(v, data_members_default[k])
my_POD = PODHandles(my_IP, verbosity=0)
data_members_modified = copy.deepcopy(data_members_default)
data_members_modified['vec_space'] = VectorSpaceHandles(
inner_product=my_IP, verbosity=0)
for k, v in util.get_data_members(my_POD).items():
self.assertEqual(v, data_members_modified[k])
my_POD = PODHandles(my_IP, get_mat=my_load, verbosity=0)
data_members_modified = copy.deepcopy(data_members_default)
data_members_modified['get_mat'] = my_load
for k, v in util.get_data_members(my_POD).items():
self.assertEqual(v, data_members_modified[k])
my_POD = PODHandles(my_IP, put_mat=my_save, verbosity=0)
data_members_modified = copy.deepcopy(data_members_default)
data_members_modified['put_mat'] = my_save
for k, v in util.get_data_members(my_POD).items():
self.assertEqual(v, data_members_modified[k])
max_vecs_per_node = 500
my_POD = PODHandles(my_IP,
max_vecs_per_node=max_vecs_per_node,
verbosity=0)
data_members_modified = copy.deepcopy(data_members_default)
data_members_modified['vec_space'].max_vecs_per_node = \
max_vecs_per_node
data_members_modified['vec_space'].max_vecs_per_proc = \
max_vecs_per_node * parallel.get_num_nodes() / \
parallel.get_num_procs()
for k, v in util.get_data_members(my_POD).items():
self.assertEqual(v, data_members_modified[k])
def test_compute_inner_product_mats(self):
"""Test computation of matrix of inner products."""
num_row_vecs_list = [
1,
int(round(self.total_num_vecs_in_mem / 2.)),
self.total_num_vecs_in_mem, self.total_num_vecs_in_mem * 2,
parallel.get_num_procs() + 1
]
num_col_vecs_list = num_row_vecs_list
num_states = 6
row_vec_path = join(self.test_dir, 'row_vec_%03d.txt')
col_vec_path = join(self.test_dir, 'col_vec_%03d.txt')
for num_row_vecs in num_row_vecs_list:
for num_col_vecs in num_col_vecs_list:
# generate vecs
parallel.barrier()
row_vec_array = parallel.call_and_bcast(
np.random.random, (num_states, num_row_vecs))
col_vec_array = parallel.call_and_bcast(
np.random.random, (num_states, num_col_vecs))
row_vec_handles = [
V.VecHandleArrayText(row_vec_path % i)
for i in range(num_row_vecs)
]
col_vec_handles = [
V.VecHandleArrayText(col_vec_path % i)
for i in range(num_col_vecs)
]
# Save vecs
if parallel.is_rank_zero():
for i, h in enumerate(row_vec_handles):
h.put(row_vec_array[:, i])
for i, h in enumerate(col_vec_handles):
h.put(col_vec_array[:, i])
parallel.barrier()
# If number of rows/cols is 1, check case of passing a handle
if len(row_vec_handles) == 1:
row_vec_handles = row_vec_handles[0]
if len(col_vec_handles) == 1:
col_vec_handles = col_vec_handles[0]
# Test IP computation.
product_true = np.dot(row_vec_array.T, col_vec_array)
product_computed = self.my_vec_ops.compute_inner_product_mat(
row_vec_handles, col_vec_handles)
row_vecs = [row_vec_array[:, i] for i in range(num_row_vecs)]
col_vecs = [col_vec_array[:, i] for i in range(num_col_vecs)]
np.testing.assert_allclose(product_computed, product_true)
# Test symm IP computation
product_true = np.dot(row_vec_array.T, row_vec_array)
product_computed = \
self.my_vec_ops.compute_symmetric_inner_product_mat(
row_vec_handles)
row_vecs = [row_vec_array[:, i] for i in range(num_row_vecs)]
np.testing.assert_allclose(product_computed, product_true)
def setUp(self):
if not os.access('.', os.W_OK):
raise RuntimeError('Cannot write to current directory')
self.test_dir = 'files_vectorspace_DELETE_ME'
if not os.path.isdir(self.test_dir):
parallel.call_from_rank_zero(os.mkdir, self.test_dir)
self.max_vecs_per_proc = 10
self.total_num_vecs_in_mem = (
parallel.get_num_procs() * self.max_vecs_per_proc)
self.vec_space = vspc.VectorSpaceHandles(
inner_product=np.vdot, verbosity=0)
self.vec_space.max_vecs_per_proc = self.max_vecs_per_proc
# Default data members; set verbosity to 0 even though default is 1
# so messages won't print during tests
self.default_data_members = {
'inner_product': np.vdot, 'max_vecs_per_node': 10000,
'max_vecs_per_proc': (
10000 * parallel.get_num_nodes() // parallel.get_num_procs()),
'verbosity': 0, 'print_interval': 10, 'prev_print_time': 0.}
parallel.barrier()
def test_init(self):
"""Test arguments passed to the constructor are assigned properly."""
data_members_original = util.get_data_members(
VectorSpaceHandles(inner_product=np.vdot, verbosity=0))
self.assertEqual(data_members_original, self.default_data_members)
max_vecs_per_node = 500
my_VS = VectorSpaceHandles(inner_product=np.vdot,
max_vecs_per_node=max_vecs_per_node,
verbosity=0)
data_members = copy.deepcopy(data_members_original)
data_members['max_vecs_per_node'] = max_vecs_per_node
data_members['max_vecs_per_proc'] = max_vecs_per_node * \
parallel.get_num_nodes() // parallel.get_num_procs()
self.assertEqual(util.get_data_members(my_VS), data_members)
def test_init(self):
"""Test arguments passed to the constructor are assigned properly."""
data_members_original = util.get_data_members(
vspc.VectorSpaceHandles(inner_product=np.vdot, verbosity=0))
self.assertEqual(data_members_original, self.default_data_members)
max_vecs_per_node = 500
vec_space = vspc.VectorSpaceHandles(
inner_product=np.vdot, max_vecs_per_node=max_vecs_per_node,
verbosity=0)
data_members = copy.deepcopy(data_members_original)
data_members['max_vecs_per_node'] = max_vecs_per_node
data_members['max_vecs_per_proc'] = (
max_vecs_per_node *
parallel.get_num_nodes() // parallel.get_num_procs())
self.assertEqual(util.get_data_members(vec_space), data_members)
def test_init(self):
"""Test arguments passed to the constructor are assigned properly"""
# Get default data member values
# Set verbosity to false, to avoid printing warnings during tests
def my_load(): pass
def my_save(): pass
def my_IP(): pass
data_members_default = {
'put_array': util.save_array_text, 'get_array':util.load_array_text,
'verbosity': 0, 'eigvecs': None, 'eigvals': None,
'correlation_array': None, 'vec_handles': None, 'vecs': None,
'vec_space': VectorSpaceHandles(inner_product=my_IP, verbosity=0)}
for k,v in util.get_data_members(
pod.PODHandles(my_IP, verbosity=0)).items():
self.assertEqual(v, data_members_default[k])
my_POD = pod.PODHandles(my_IP, verbosity=0)
data_members_modified = copy.deepcopy(data_members_default)
data_members_modified['vec_space'] = VectorSpaceHandles(
inner_product=my_IP, verbosity=0)
for k,v in util.get_data_members(my_POD).items():
self.assertEqual(v, data_members_modified[k])
my_POD = pod.PODHandles(my_IP, get_array=my_load, verbosity=0)
data_members_modified = copy.deepcopy(data_members_default)
data_members_modified['get_array'] = my_load
for k,v in util.get_data_members(my_POD).items():
self.assertEqual(v, data_members_modified[k])
my_POD = pod.PODHandles(my_IP, put_array=my_save, verbosity=0)
data_members_modified = copy.deepcopy(data_members_default)
data_members_modified['put_array'] = my_save
for k,v in util.get_data_members(my_POD).items():
self.assertEqual(v, data_members_modified[k])
max_vecs_per_node = 500
my_POD = pod.PODHandles(
my_IP, max_vecs_per_node=max_vecs_per_node, verbosity=0)
data_members_modified = copy.deepcopy(data_members_default)
data_members_modified['vec_space'].max_vecs_per_node = max_vecs_per_node
data_members_modified['vec_space'].max_vecs_per_proc = (
max_vecs_per_node *
parallel.get_num_nodes() /
parallel.get_num_procs())
for k,v in util.get_data_members(my_POD).items():
self.assertEqual(v, data_members_modified[k])
def test_compute_inner_product_arrays(self):
"""Test computation of array of inner products."""
rtol = 1e-10
atol = 1e-12
num_row_vecs_list = [
1,
int(round(self.total_num_vecs_in_mem / 2.)),
self.total_num_vecs_in_mem,
self.total_num_vecs_in_mem * 2,
parallel.get_num_procs() + 1]
num_col_vecs_list = num_row_vecs_list
num_states = 6
row_vec_path = join(self.test_dir, 'row_vec_%03d.pkl')
col_vec_path = join(self.test_dir, 'col_vec_%03d.pkl')
for num_row_vecs in num_row_vecs_list:
for num_col_vecs in num_col_vecs_list:
# Generate vecs
parallel.barrier()
row_vec_array = (
parallel.call_and_bcast(
np.random.random, (num_states, num_row_vecs))
+ 1j * parallel.call_and_bcast(
np.random.random, (num_states, num_row_vecs)))
col_vec_array = (
parallel.call_and_bcast(
np.random.random, (num_states, num_col_vecs))
+ 1j * parallel.call_and_bcast(
np.random.random, (num_states, num_col_vecs)))
row_vec_handles = [
VecHandlePickle(row_vec_path % i)
for i in range(num_row_vecs)]
col_vec_handles = [
VecHandlePickle(col_vec_path % i)
for i in range(num_col_vecs)]
# Save vecs
if parallel.is_rank_zero():
for i, h in enumerate(row_vec_handles):
h.put(row_vec_array[:, i])
for i, h in enumerate(col_vec_handles):
h.put(col_vec_array[:, i])
parallel.barrier()
# If number of rows/cols is 1, check case of passing a handle
if len(row_vec_handles) == 1:
row_vec_handles = row_vec_handles[0]
if len(col_vec_handles) == 1:
col_vec_handles = col_vec_handles[0]
# Test ip computation.
product_true = np.dot(row_vec_array.conj().T, col_vec_array)
product_computed = self.vec_space.compute_inner_product_array(
row_vec_handles, col_vec_handles)
np.testing.assert_allclose(
product_computed, product_true, rtol=rtol, atol=atol)
# Test symm ip computation
product_true = np.dot(row_vec_array.conj().T, row_vec_array)
product_computed =\
self.vec_space.compute_symm_inner_product_array(
row_vec_handles)
np.testing.assert_allclose(
product_computed, product_true, rtol=rtol, atol=atol)
def test_compute_inner_product_arrays(self):
"""Test computation of array of inner products."""
rtol = 1e-10
atol = 1e-12
num_row_vecs_list = [
1,
int(round(self.total_num_vecs_in_mem / 2.)),
self.total_num_vecs_in_mem,
self.total_num_vecs_in_mem * 2,
parallel.get_num_procs() + 1]
num_col_vecs_list = num_row_vecs_list
num_states = 6
row_vec_path = join(self.test_dir, 'row_vec_%03d.pkl')
col_vec_path = join(self.test_dir, 'col_vec_%03d.pkl')
for num_row_vecs in num_row_vecs_list:
for num_col_vecs in num_col_vecs_list:
# Generate vecs
parallel.barrier()
row_vec_array = (
parallel.call_and_bcast(
np.random.random, (num_states, num_row_vecs))
+ 1j * parallel.call_and_bcast(
np.random.random, (num_states, num_row_vecs)))
col_vec_array = (
parallel.call_and_bcast(
np.random.random, (num_states, num_col_vecs))
+ 1j * parallel.call_and_bcast(
np.random.random, (num_states, num_col_vecs)))
row_vec_handles = [
VecHandlePickle(row_vec_path % i)
for i in range(num_row_vecs)]
col_vec_handles = [
VecHandlePickle(col_vec_path % i)
for i in range(num_col_vecs)]
# Save vecs
if parallel.is_rank_zero():
for i, h in enumerate(row_vec_handles):
h.put(row_vec_array[:, i])
for i, h in enumerate(col_vec_handles):
h.put(col_vec_array[:, i])
parallel.barrier()
# If number of rows/cols is 1, check case of passing a handle
if len(row_vec_handles) == 1:
row_vec_handles = row_vec_handles[0]
if len(col_vec_handles) == 1:
col_vec_handles = col_vec_handles[0]
# Test ip computation.
product_true = np.dot(row_vec_array.conj().T, col_vec_array)
product_computed = self.vec_space.compute_inner_product_array(
row_vec_handles, col_vec_handles)
np.testing.assert_allclose(
product_computed, product_true, rtol=rtol, atol=atol)
# Test symm ip computation
product_true = np.dot(row_vec_array.conj().T, row_vec_array)
product_computed =\
self.vec_space.compute_symm_inner_product_array(
row_vec_handles)
np.testing.assert_allclose(
product_computed, product_true, rtol=rtol, atol=atol)
