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 test_compute_modes(self): """Test computing modes in serial and parallel.""" atol = 1e-6 direct_mode_path = join(self.test_dir, 'direct_mode_%03d.txt') adjoint_mode_path = join(self.test_dir, 'adjoint_mode_%03d.txt') # starts with the correct decomposition. self.my_BPOD.R_sing_vecs = self.R_sing_vecs_true self.my_BPOD.L_sing_vecs = self.L_sing_vecs_true self.my_BPOD.sing_vals = self.sing_vals_true direct_mode_handles = [ V.VecHandleArrayText(direct_mode_path % i) for i in self.mode_nums ] adjoint_mode_handles = [ V.VecHandleArrayText(adjoint_mode_path % i) for i in self.mode_nums ] self.my_BPOD.compute_direct_modes( self.mode_nums, direct_mode_handles, direct_vec_handles=self.direct_vec_handles) self.my_BPOD.compute_adjoint_modes( self.mode_nums, adjoint_mode_handles, adjoint_vec_handles=self.adjoint_vec_handles) for mode_index, mode_handle in enumerate(direct_mode_handles): mode = mode_handle.get() np.testing.assert_allclose( mode, self.direct_mode_array[:, self.mode_nums[mode_index]], atol=atol) for mode_index, mode_handle in enumerate(adjoint_mode_handles): mode = mode_handle.get() np.testing.assert_allclose( mode, self.adjoint_mode_array[:, self.mode_nums[mode_index]], atol=atol) for direct_mode_index, direct_handle in \ enumerate(direct_mode_handles): direct_mode = direct_handle.get() for adjoint_mode_index, adjoint_handle in \ enumerate(adjoint_mode_handles): adjoint_mode = adjoint_handle.get() IP = self.my_BPOD.vec_space.inner_product( direct_mode, adjoint_mode) if self.mode_nums[direct_mode_index] != \ self.mode_nums[adjoint_mode_index]: self.assertAlmostEqual(IP, 0., places=6) else: self.assertAlmostEqual(IP, 1., places=6)
def setUp(self): self.test_dir = 'DELETE_ME_test_files_pod' if not os.access('.', os.W_OK): raise RuntimeError('Cannot write to current directory') if not os.path.isdir(self.test_dir) and _parallel.is_rank_zero(): os.mkdir(self.test_dir) self.mode_indices = [2, 4, 3, 6] self.num_vecs = 10 self.num_states = 30 self.vec_array = _parallel.call_and_bcast( np.random.random, (self.num_states, self.num_vecs)) self.correlation_mat_true = self.vec_array.conj().transpose().dot( self.vec_array) self.eigen_vals_true, self.eigen_vecs_true = \ _parallel.call_and_bcast(util.eigh, self.correlation_mat_true) self.mode_array = np.dot( self.vec_array, np.dot(self.eigen_vecs_true, np.diag(self.eigen_vals_true**-0.5))) self.vec_path = join(self.test_dir, 'vec_%03d.txt') self.vec_handles = [ V.VecHandleArrayText(self.vec_path % i) for i in range(self.num_vecs) ] for vec_index, handle in enumerate(self.vec_handles): handle.put(self.vec_array[:, vec_index]) self.my_POD = PODHandles(np.vdot, verbosity=0) _parallel.barrier()
def test_compute_modes(self): mode_path = join(self.test_dir, 'mode_%03d.txt') mode_handles = [ V.VecHandleArrayText(mode_path % i) for i in self.mode_indices ] # starts with the CORRECT decomposition. self.my_POD.eigen_vecs = self.eigen_vecs_true self.my_POD.eigen_vals = self.eigen_vals_true self.my_POD.compute_modes(self.mode_indices, mode_handles, vec_handles=self.vec_handles) for mode_index, mode_handle in enumerate(mode_handles): mode = mode_handle.get() np.testing.assert_allclose( mode.squeeze(), self.mode_array[:, self.mode_indices[mode_index]]) for mode_index1, handle1 in enumerate(mode_handles): mode1 = handle1.get() for mode_index2, handle2 in enumerate(mode_handles): mode2 = handle2.get() IP = self.my_POD.vec_space.inner_product(mode1, mode2) if self.mode_indices[mode_index1] != \ self.mode_indices[mode_index2]: self.assertAlmostEqual(IP, 0.) else: self.assertAlmostEqual(IP, 1.)
def test_derivs(self): """Test can take derivs""" dt = 0.1 true_derivs = [] num_vecs = len(self.basis_vec_handles) for i in range(num_vecs): true_derivs.append((self.A_on_basis_vec_handles[i].get() - self.basis_vec_handles[i].get()).squeeze()/dt) deriv_handles = [V.VecHandleArrayText(join(self.test_dir, 'deriv_test%d'%i)) for i in range(num_vecs)] LGP.compute_derivs_handles(self.basis_vec_handles, self.A_on_basis_vec_handles, deriv_handles, dt) derivs_loaded = [v.get() for v in deriv_handles] derivs_loaded = list(map(np.squeeze, derivs_loaded)) list(map(np.testing.assert_allclose, derivs_loaded, true_derivs))
def test_lin_combine(self): num_vecs_list = [1, 15, 40] num_states = 20 # Test cases where number of modes: # less, equal, more than num_states # less, equal, more than num_vecs # less, equal, more than total_num_vecs_in_mem num_modes_list = [1, 8, 10, 20, 25, 45, \ int(np.ceil(self.total_num_vecs_in_mem / 2.)),\ self.total_num_vecs_in_mem, self.total_num_vecs_in_mem * 2] mode_path = join(self.test_dir, 'mode_%03d.txt') vec_path = join(self.test_dir, 'vec_%03d.txt') for num_vecs in num_vecs_list: for num_modes in num_modes_list: #generate data and then broadcast to all procs #print '----- new case ----- ' #print 'num_vecs =',num_vecs #print 'num_states =',num_states #print 'num_modes =',num_modes #print 'max_vecs_per_node =',max_vecs_per_node #print 'index_from =',index_from vec_handles = [ V.VecHandleArrayText(vec_path % i) for i in range(num_vecs) ] vec_array, mode_indices, build_coeff_mat, true_modes = \ _parallel.call_and_bcast(self.generate_vecs_modes, num_states, num_vecs, num_modes) if _parallel.is_rank_zero(): for vec_index, vec_handle in enumerate(vec_handles): vec_handle.put(vec_array[:, vec_index]) _parallel.barrier() mode_handles = [ V.VecHandleArrayText(mode_path % mode_num) for mode_num in mode_indices ] # If there are more vecs than mat has rows build_coeff_mat_too_small = \ np.zeros((build_coeff_mat.shape[0]-1, build_coeff_mat.shape[1])) self.assertRaises(ValueError, self.my_vec_ops.\ lin_combine, mode_handles, vec_handles, build_coeff_mat_too_small, mode_indices) # Test the case that only one mode is desired, # in which case user might pass in an int if len(mode_indices) == 1: mode_indices = mode_indices[0] mode_handles = mode_handles[0] # Saves modes to files self.my_vec_ops.lin_combine(mode_handles, vec_handles, build_coeff_mat, mode_indices) # Change back to list so is iterable if not isinstance(mode_indices, list): mode_indices = [mode_indices] _parallel.barrier() #print 'mode_indices',mode_indices for mode_index in mode_indices: computed_mode = V.VecHandleArrayText(mode_path % mode_index).get() #print 'mode number',mode_num #print 'true mode',true_modes[:,\ # mode_num-index_from] #print 'computed mode',computed_mode np.testing.assert_allclose(computed_mode, true_modes[:, mode_index]) _parallel.barrier() _parallel.barrier()
def setUp(self): if not os.access('.', os.W_OK): raise RuntimeError('Cannot write to current directory') self.test_dir = 'DELETE_ME_test_files_bpod' if not os.path.isdir(self.test_dir): _parallel.call_from_rank_zero(os.mkdir, self.test_dir) self.mode_nums = [2, 3, 0] self.num_direct_vecs = 10 self.num_adjoint_vecs = 12 self.num_inputs = 1 self.num_outputs = 1 self.num_states = 20 #A = np.mat(np.random.random((self.num_states, self.num_states))) A = np.mat( _parallel.call_and_bcast(util.drss, self.num_states, 1, 1)[0]) B = np.mat( _parallel.call_and_bcast(np.random.random, (self.num_states, self.num_inputs))) C = np.mat( _parallel.call_and_bcast(np.random.random, (self.num_outputs, self.num_states))) self.direct_vecs = [B] A_powers = np.identity(A.shape[0]) for t in range(self.num_direct_vecs - 1): A_powers = A_powers.dot(A) self.direct_vecs.append(A_powers.dot(B)) self.direct_vec_array = np.array(self.direct_vecs).squeeze().T A_adjoint = A.H C_adjoint = C.H A_adjoint_powers = np.identity(A_adjoint.shape[0]) self.adjoint_vecs = [C_adjoint] for t in range(self.num_adjoint_vecs - 1): A_adjoint_powers = A_adjoint_powers.dot(A_adjoint) self.adjoint_vecs.append(A_adjoint_powers.dot(C_adjoint)) self.adjoint_vec_array = np.array(self.adjoint_vecs).squeeze().T self.direct_vec_path = join(self.test_dir, 'direct_vec_%03d.txt') self.adjoint_vec_path = join(self.test_dir, 'adjoint_vec_%03d.txt') self.direct_vec_handles = [ V.VecHandleArrayText(self.direct_vec_path % i) for i in range(self.num_direct_vecs) ] self.adjoint_vec_handles = [ V.VecHandleArrayText(self.adjoint_vec_path % i) for i in range(self.num_adjoint_vecs) ] if _parallel.is_rank_zero(): for i, handle in enumerate(self.direct_vec_handles): handle.put(self.direct_vecs[i]) for i, handle in enumerate(self.adjoint_vec_handles): handle.put(self.adjoint_vecs[i]) self.Hankel_mat_true = np.dot(self.adjoint_vec_array.T, self.direct_vec_array) self.L_sing_vecs_true, self.sing_vals_true, self.R_sing_vecs_true = \ _parallel.call_and_bcast(util.svd, self.Hankel_mat_true, tol=1e-10) self.direct_mode_array = self.direct_vec_array * \ np.mat(self.R_sing_vecs_true) * \ np.mat(np.diag(self.sing_vals_true ** -0.5)) self.adjoint_mode_array = self.adjoint_vec_array * \ np.mat(self.L_sing_vecs_true) *\ np.mat(np.diag(self.sing_vals_true ** -0.5)) self.my_BPOD = BPODHandles(np.vdot, verbosity=0) _parallel.barrier()
def generate_data_set(self, num_basis_vecs, num_adjoint_basis_vecs, num_states, num_inputs, num_outputs): """Generates random data, saves, and computes true reduced A,B,C.""" self.basis_vec_handles = [ V.VecHandleArrayText(self.basis_vec_path % i) for i in range(self.num_basis_vecs) ] self.adjoint_basis_vec_handles = [ V.VecHandleArrayText(self.adjoint_basis_vec_path % i) for i in range(self.num_adjoint_basis_vecs) ] self.A_on_basis_vec_handles = \ [V.VecHandleArrayText(self.A_on_basis_vec_path%i) for i in range(self.num_basis_vecs)] self.B_on_standard_basis_handles = [ V.VecHandleArrayText(self.B_on_basis_path % i) for i in range(self.num_inputs) ] self.C_on_basis_vec_handles = [ V.VecHandleArrayText(self.C_on_basis_vec_path % i) for i in range(self.num_basis_vecs) ] self.basis_vec_array = _parallel.call_and_bcast( np.random.random, (num_states, num_basis_vecs)) self.adjoint_basis_vec_array = _parallel.call_and_bcast( np.random.random, (num_states, num_adjoint_basis_vecs)) self.A_array = _parallel.call_and_bcast(np.random.random, (num_states, num_states)) self.B_array = _parallel.call_and_bcast(np.random.random, (num_states, num_inputs)) self.C_array = _parallel.call_and_bcast(np.random.random, (num_outputs, num_states)) self.basis_vecs = [ self.basis_vec_array[:, i].squeeze() for i in range(num_basis_vecs) ] self.adjoint_basis_vecs = [ self.adjoint_basis_vec_array[:, i].squeeze() for i in range(num_adjoint_basis_vecs) ] self.A_on_basis_vecs = [ np.dot(self.A_array, basis_vec).squeeze() for basis_vec in self.basis_vecs ] self.B_on_basis = [ self.B_array[:, i].squeeze() for i in range(self.num_inputs) ] self.C_on_basis_vecs = [ np.array(np.dot(self.C_array, basis_vec).squeeze(), ndmin=1) for basis_vec in self.basis_vecs ] if _parallel.is_rank_zero(): for handle, vec in zip(self.basis_vec_handles, self.basis_vecs): handle.put(vec) for handle, vec in zip(self.adjoint_basis_vec_handles, self.adjoint_basis_vecs): handle.put(vec) for handle, vec in zip(self.A_on_basis_vec_handles, self.A_on_basis_vecs): handle.put(vec) for handle, vec in zip(self.B_on_standard_basis_handles, self.B_on_basis): handle.put(vec) for handle, vec in zip(self.C_on_basis_vec_handles, self.C_on_basis_vecs): handle.put(vec) _parallel.barrier() self.A_true = np.dot(self.adjoint_basis_vec_array.T, np.dot(self.A_array, self.basis_vec_array)) self.B_true = np.dot(self.adjoint_basis_vec_array.T, self.B_array) self.C_true = np.dot(self.C_array, self.basis_vec_array) self.proj_mat = np.linalg.inv( np.dot(self.adjoint_basis_vec_array.T, self.basis_vec_array)) self.A_true_nonorth = np.dot(self.proj_mat, self.A_true) self.B_true_nonorth = np.dot(self.proj_mat, self.B_true)