def symmetric_inner_product_mat(num_states,
num_vecs,
max_vecs_per_node,
verbosity=1):
"""
Computes symmetric inner product matrix from known vecs (as in POD).
"""
vec_handles = [
MR.VecHandlePickle(join(data_dir, row_vec_name % row_num))
for row_num in range(num_vecs)
]
generate_vecs(data_dir, num_states, vec_handles)
my_VS = MR.VectorSpaceHandles(N.vdot,
max_vecs_per_node=max_vecs_per_node,
verbosity=verbosity)
prof = cProfile.Profile()
start_time = T.time()
prof.runcall(my_VS.compute_symmetric_inner_product_mat, vec_handles)
total_time = T.time() - start_time
prof.dump_stats('IP_symmetric_mat_r%d.prof' % _parallel.get_rank())
return total_time
import modred as mr
# Create directory for output files
out_dir = 'rom_ex2_out'
if not os.path.isdir(out_dir):
os.makedirs(out_dir)
# Create random modes and action on modes. Typically this data already exists
# and this section is unnecesary.
nx = 100
ny = 200
num_inputs = 2
num_outputs = 4
num_modes = 40
basis_vecs = [
mr.VecHandlePickle('%s/dir_mode_%02d.pkl' % (out_dir, i))
for i in range(num_modes)
]
adjoint_basis_vecs = [
mr.VecHandlePickle('%s/adj_mode_%02d.pkl' % (out_dir, i))
for i in range(num_modes)
]
A_on_basis_vecs = [
mr.VecHandlePickle('%s/A_on_dir_mode_%02d.pkl' % (out_dir, i))
for i in range(num_modes)
]
B_on_bases = [
mr.VecHandlePickle('%s/B_on_basis_%02d.pkl' % (out_dir, i))
for i in range(num_inputs)
]
C_on_basis_vecs = [
import numpy as N
import modred as MR
nx = 100
ny = 200
num_inputs = 2
num_outputs = 4
num_modes = 40
# Create random modes and action on modes. Typically this data already exists and
# this section is unnecesary.
basis_vecs = [
MR.VecHandlePickle('dir_mode_%02d.pkl' % i) for i in range(num_modes)
]
adjoint_basis_vecs = [
MR.VecHandlePickle('adj_mode_%02d.pkl' % i) for i in range(num_modes)
]
A_on_basis_vecs = [
MR.VecHandlePickle('A_on_dir_mode_%02d.pkl' % i) for i in range(num_modes)
]
B_on_bases = [
MR.VecHandlePickle('B_on_basis_%02d.pkl' % i) for i in range(num_inputs)
]
C_on_basis_vecs = [
N.sin(N.linspace(0, 0.1 * i, num_outputs)) for i in range(num_modes)
]
parallel = MR.parallel_default_instance
if parallel.is_rank_zero():
for handle in (basis_vecs + adjoint_basis_vecs + A_on_basis_vecs +
B_on_bases):
handle.put(N.random.random((nx, ny)))
import modred as MR
import numpy as N
num_vecs = 100
# Non-uniform grid and corresponding inner product weights.
nx = 80
ny = 100
x_grid = 1. - N.cos(N.linspace(0, N.pi, nx))
y_grid = N.linspace(0, 1., ny)**2
Y, X = N.meshgrid(y_grid, x_grid)
snapshots = [MR.VecHandlePickle('vec%d.pkl' % i) for i in range(num_vecs)]
parallel = MR.parallel_default_instance
if parallel.is_rank_zero():
for i, snap in enumerate(snapshots):
snap.put(N.sin(X * i) + N.cos(Y * i))
parallel.barrier()
weighted_IP = MR.InnerProductTrapz(x_grid, y_grid)
# Calculate DMD modes and save them to pickle files.
my_DMD = MR.DMDHandles(weighted_IP)
my_DMD.compute_decomp(snapshots)
my_DMD.put_decomp('ritz_vals.txt', 'mode_norms.txt', 'build_coeffs.txt')
mode_indices = [1, 4, 5, 0, 10]
modes = [MR.VecHandlePickle('mode%d.pkl' % i) for i in mode_indices]
my_DMD.compute_modes(mode_indices, modes)
from __future__ import print_function
from future.builtins import range
import numpy as np
import modred as mr
num_elements = 2000
num_vecs = 100
# Artificial sample times used as quadrature weights in POD.
quad_weights = np.logspace(1., 3., num=num_vecs)
base_vec_handle = mr.VecHandlePickle('base_vec.pkl')
snapshots = [
mr.VecHandlePickle('vec%d.pkl' % i,
base_vec_handle=base_vec_handle,
scale=quad_weights[i]) for i in range(num_vecs)
]
# Save arbitrary data, normally unnecessary.
num_elements = 2000
parallel = mr.parallel_default_instance
if parallel.is_rank_zero():
for snap in snapshots + [base_vec_handle]:
snap.put(np.random.random(num_elements))
parallel.barrier()
# Compute and save POD modes.
my_POD = mr.PODHandles(np.vdot)
my_POD.compute_decomp(snapshots)
my_POD.put_decomp('sing_vals.txt', 'sing_vecs.txt')
my_POD.put_correlation_mat('correlation_mat.txt')
import os
import numpy as np
from modred import parallel
import modred as mr
# Create directory for output files
out_dir = 'tutorial_ex5_out'
if not os.path.isdir(out_dir):
os.makedirs(out_dir)
# Create artificial sample times used as quadrature weights in POD
num_vecs = 100
quad_weights = np.logspace(1., 3., num=num_vecs)
base_vec_handle = mr.VecHandlePickle('%s/base_vec.pkl' % out_dir)
snapshots = [
mr.VecHandlePickle('%s/vec%d.pkl' % (out_dir, i),
base_vec_handle=base_vec_handle,
scale=quad_weights[i]) for i in mr.range(num_vecs)
]
# Save arbitrary snapshot data
num_elements = 2000
if parallel.is_rank_zero():
for snap in snapshots + [base_vec_handle]:
snap.put(np.random.random(num_elements))
parallel.barrier()
# Compute and save POD modes
my_POD = mr.PODHandles(np.vdot)
