def mean_field(domain, points, bv_dict, path=None, save=True, show =
False, ics=1, ext='.png'):
"""
Given a bv_dict a set of random points, plot the r_fields generated in
random_manningsn.runSet.run_points
:param domain: :class:`~polyadcirc.run_framework.domain`
:type points: :class:`numpy.ndarray`
:param points: weights for points at which the random domain was sampled
:type bv_dict: list of ``dict``
:param bv_dict: list of basis vectors based on land classification
:type path: string or None
:param path: directory to store plots
:type save: bool
:param save: flag for whether or not to save plots
:type show: bool
:param show: flag for whether or not to show plots
:param int ics: polar coordinate option (1 = cart coords, 2 = polar
coords)
:param string ext: file extension
"""
vmax = np.max(points)
if vmax == 1.0:
vmax = np.max(points[range(points.shape[0]-1), :])
vmin = np.min(points)
clim = (vmin, vmax)
default = domain.read_default()
z = tmm.combine_basis_vectors(np.mean(points, 1), bv_dict, default,
domain.node_num)
field(domain, z, 'mean_field', clim, path, save, show, ics, ext)
def compare(basis_dir=None, default=0.012):
"""
Create a set of diagnostic plots in basis_dir/figs
:param string basis_dir: directory containing the test folder and landuse
folders
:param float default: default Manning's *n*
"""
if basis_dir is None:
basis_dir = os.getcwd()
tables = tm.read_tables(os.path.join(basis_dir, 'test'))
domain = dom.domain(basis_dir)
domain.read_spatial_grid()
fm.mkdir(os.path.join(basis_dir, 'figs'))
old_files = glob.glob(os.path.join(basis_dir, 'figs', '*.png'))
for fid in old_files:
os.remove(fid)
domain.get_Triangulation(path=basis_dir)
original = f13.read_nodal_attr_dict(os.path.join(basis_dir, 'test'))
original = tmm.dict_to_array(original, default, domain.node_num)
weights = np.array(tables[0].land_classes.values())
lim = (np.min(weights), np.max(weights))
bv_dict = tmm.get_basis_vectors(basis_dir)
combo = tmm.combine_basis_vectors(weights, bv_dict, default,
domain.node_num)
bv_array = tmm.get_basis_vec_array(basis_dir,
domain.node_num)
plt.basis_functions(domain, bv_array, path=basis_dir)
plt.field(domain, original, 'original', clim=lim, path=basis_dir)
plt.field(domain, combo, 'reconstruction', clim=lim, path=basis_dir)
plt.field(domain, original-combo, 'difference', path=basis_dir)
combo_array = tmm.combine_bv_array(weights, bv_array)
plt.field(domain, combo_array, 'combo_array', clim=lim, path=basis_dir)
plt.field(domain, original-combo_array, 'diff_ori_array', path=basis_dir)
plt.field(domain, combo-combo_array, 'diff_com_array', path=basis_dir)
combo_bv = tmm.combine_basis_vectors(np.ones(weights.shape),
bv_dict, default, domain.node_num)
plt.field(domain, combo_bv, 'combo_bv', path=basis_dir)
def random_fields(domain,
points,
bv_dict,
path=None,
save=True,
show=False,
ics=1,
ext='.png',
cmap=plt.cm.jet):
"""
Given a ``bv_dict`` a set of random points, plot the ``r_fields``
generated in
:meth:`~polyadcirc.run_framework.random_manningsn.runSet.run_points`
:param domain: :class:`~polyadcirc.run_framework.domain`
:type points: :class:`numpy.ndarray`
:param points: weights for points at which the random domain was sampled
:type bv_dict: list of ``dict``
:param bv_dict: list of basis vectors based on land classification
:type path: string or None
:param path: directory to store plots
:type save: bool
:param save: flag for whether or not to save plots
:type show: bool
:param show: flag for whether or not to show plots
:param int ics: polar coordinate option (1 = cart coords, 2 = polar
coords)
:param string ext: file extension
"""
vmax = np.max(points)
if vmax == 1.0:
vmax = np.max(points[range(points.shape[0] - 1), :])
vmin = np.min(points)
clim = (vmin, vmax)
default = domain.read_default()
for i in xrange(points.shape[1]):
z = tmm.combine_basis_vectors(points[..., i], bv_dict, default,
domain.node_num)
field(domain, z, 'random_field_' + str(i), clim, path, save, show, ics,
ext, cmap)
def run_nobatch_q(self,
data,
wall_points,
mann_points,
save_file,
num_procs=12,
procs_pnode=12,
stations=None,
screenout=True,
num_writers=None,
TpN=12):
"""
Runs :program:`ADCIRC` for all of the configurations specified by
``wall_points`` and ``mann_points`` and returns a dictonary of arrays
containing data from output files. Runs batches of :program:`PADCIRC`
as a single for loop and preps both the ``fort.13`` and fort.14`` in
the same step.
Stores only the QoI at the stations defined in `stations``. In this
case the QoI is the ``maxele63`` at the designated station.
Reads in a default Manning's *n* value from self.save_dir and stores
it in data.manningsn_default
:param data: :class:`~polyadcirc.run_framework.domain`
:type wall_points: :class:`np.array` of size (5, ``num_of_walls``)
:param wall_points: containts the box_limits, and wall_height for each
wall [ximin, xmax, ymin, ymax, wall_height]
:type mann_points: :class:`np.array` of size (``num_of_basis_vec``,
``num_of_random_fields``), ``num_of_random_fields`` MUST be the
same as ``num_of_walls``. The ith wall will be associated with
the ith field specifed by mann_points
:param mann_points: containts the weights to be used for each run
:type save_file: string
:param save_file: name of file to save mdict to
:type num_procs: int or 12
:param num_procs: number of processors per :program:`ADCIRC`
simulation, 12 on lonestar, and 16 on stamped
:param int procs_pnode: number of processors per node
:param list() stations: list of stations to gather QoI from. If
``None`` uses the stations defined in ``data``
:param boolean screenout: flag (True -- write ``ADCIRC`` output to
screen, False -- write ``ADCIRC`` output to temp file
:param int num_writers: number of MPI processes to dedicate soley to
the task of writing ascii files. This MUST be < num_procs
:param int TpN: number of tasks (cores to use) per node (wayness)
:rtype: (:class:`np.array`, :class:`np.ndarray`, :class:`np.ndarray`)
:returns: (``time_obs``, ``ts_data``, ``nts_data``)
.. note:: Currently supports ADCIRC output files ``fort.6*``,
``*.63``, ``fort.7*``, but NOT Hot Start Output
(``fort.67``, ``fort.68``)
"""
# setup and save to shelf
# set up saving
if glob.glob(self.save_dir + '/' + save_file):
os.remove(self.save_dir + '/' + save_file)
# Save matricies to *.mat file for use by MATLAB or Python
mdict = dict()
mdict['mann_pts'] = mann_points
mdict['wall_pts'] = wall_points
self.save(mdict, save_file)
#bv_array = tmm.get_basis_vec_array(self.basis_dir)
bv_dict = tmm.get_basis_vectors(self.basis_dir)
# Pre-allocate arrays for various data files
num_points = mann_points.shape[1]
num_walls = wall_points.shape[1]
if num_walls != num_points:
print "Error: num_walls != num_points"
quit()
# store the wall points with the mann_points as points
mdict['points'] = np.vstack((wall_points, mann_points))
# Pre-allocate arrays for non-timeseries data
nts_data = {}
self.nts_data = nts_data
nts_data['maxele63'] = np.empty(
(data.node_num, self.num_of_parallel_runs))
# Pre-allocate arrays for QoI data
if stations == None:
stations = data.stations['fort61']
xi = np.array([[s.x, s.y] for s in stations])
points = np.column_stack((data.array_x(), data.array_y()))
Q = np.empty((num_points, xi.shape[0]))
self.Q = Q
mdict['Q'] = Q
# Update and save
self.update_mdict(mdict)
self.save(mdict, save_file)
default = data.read_default(path=self.save_dir)
for k in xrange(0, num_points, self.num_of_parallel_runs):
if k + self.num_of_parallel_runs >= num_points - 1:
stop = num_points
step = stop - k
else:
stop = k + self.num_of_parallel_runs
step = self.num_of_parallel_runs
run_script = self.write_run_script(num_procs, step, procs_pnode,
TpN, screenout, num_writers)
self.write_prep_script(5)
# set walls
wall_dim = wall_points[..., k]
data.read_spatial_grid()
data.add_wall(wall_dim[:4], wall_dim[-1])
# update wall and prep all
for rf_dir in self.rf_dirs:
os.remove(rf_dir + '/fort.14')
shutil.copy(self.grid_dir + '/fort.14', rf_dir)
f14.update(data, path=rf_dir)
#PARALLEL: update file containing the list of rf_dirs
self.update_dir_file(self.num_of_parallel_runs)
devnull = open(os.devnull, 'w')
p = subprocess.Popen(['./prep_2.sh'],
stdout=devnull,
cwd=self.save_dir)
p.communicate()
devnull.close()
for i in xrange(0, step):
# generate the Manning's n field
r_field = tmm.combine_basis_vectors(mann_points[..., i + k],
bv_dict, default,
data.node_num)
# create the fort.13 for r_field
f13.update_mann(r_field, self.rf_dirs[i])
# do a batch run of python
#PARALLEL: update file containing the list of rf_dirs
self.update_dir_file(self.num_of_parallel_runs)
devnull = open(os.devnull, 'w')
p = subprocess.Popen(['./prep_5.sh'],
stdout=devnull,
cwd=self.save_dir)
p.communicate()
devnull.close()
devnull = open(os.devnull, 'w')
p = subprocess.Popen(['./' + run_script],
stdout=devnull,
cwd=self.base_dir)
p.communicate()
devnull.close()
# get data
for i, kk in enumerate(range(k, stop)):
output.get_data_nts(i, self.rf_dirs[i], data, self.nts_data,
["maxele.63"])
# fix dry nodes and interpolate to obtain QoI
self.fix_dry_nodes_nts(data)
for i, kk in enumerate(range(k, stop)):
values = self.nts_data["maxele63"][:, i]
Q[kk, :] = griddata(points, values, xi)
# Update and save
self.update_mdict(mdict)
self.save(mdict, save_file)
if num_points <= self.num_of_parallel_runs:
pass
elif (k + 1) % (num_points / self.num_of_parallel_runs) == 0:
msg = str(k + 1) + " of " + str(num_points)
print msg + " runs have been completed."
# save data
self.update_mdict(mdict)
self.save(mdict, save_file)
return Q
def run_points(self, data, wall_points, mann_points, save_file,
num_procs=12, procs_pnode=12, ts_names=["fort.61"],
nts_names=["maxele.63"], screenout=True, s_p_wall=
None, num_writers=None, TpN=12):
"""
Runs :program:`ADCIRC` for all of the configurations specified by
``wall_points`` and ``mann_points`` and returns a dictonary of arrays
containing data from output files. Assumes that the number of
``wall_points`` is less than the number of ``mann_points``. Runs
batches of :program:`PADCIRC` as a double for loop with the
:program:`ADCPREP` prepping the ``fort.14`` file on the exterior loop
and the ``fort.13`` file on the interior loop.
Reads in a default Manning's *n* value from self.save_dir and stores
it in data.manningsn_default
:param data: :class:`~polyadcirc.run_framework.domain`
:type wall_points: :class:`np.array` of size (5, ``num_of_walls``)
:param wall_points: containts the box_limits, and wall_height for each
wall [ximin, xmax, ymin, ymax, wall_height]
:type mann_points: :class:`np.array` of size (``num_of_basis_vec``,
``num_of_random_fields``), ``num_of_random_fields`` MUST be a
multiple of ``num_of_walls``. The ith wall will be associated with
the ith set of i*(num_of_random_fields/num_of_walls) mann_points
:param mann_points: containts the weights to be used for each run
:type save_file: string
:param save_file: name of file to save mdict to
:type num_procs: int or 12
:param num_procs: number of processors per :program:`ADCIRC`
simulation, 12 on lonestar, and 16 on stamped
:param int procs_pnode: number of processors per node
:param list() ts_names: names of ADCIRC timeseries
output files to be recorded from each run
:param list() nts_names: names of ADCIRC non timeseries
output files to be recorded from each run
:param boolean screenout: flag (True -- write ``ADCIRC`` output to
screen, False -- write ``ADCIRC`` output to temp file
:param int num_writers: number of MPI processes to dedicate soley to
the task of writing ascii files. This MUST be < num_procs
:param int TpN: number of tasks (cores to use) per node (wayness)
:rtype: (:class:`np.array`, :class:`np.ndarray`, :class:`np.ndarray`)
:returns: (``time_obs``, ``ts_data``, ``nts_data``)
.. note:: Currently supports ADCIRC output files ``fort.6*``,
``*.63``, ``fort.7*``, but NOT Hot Start Output
(``fort.67``, ``fort.68``)
"""
# setup and save to shelf
# set up saving
if glob.glob(self.save_dir+'/'+save_file):
os.remove(self.save_dir+'/'+save_file)
# Save matricies to *.mat file for use by MATLAB or Python
mdict = dict()
mdict['mann_pts'] = mann_points
mdict['wall_pts'] = wall_points
self.save(mdict, save_file)
#bv_array = tmm.get_basis_vec_array(self.basis_dir)
bv_dict = tmm.get_basis_vectors(self.basis_dir)
# Pre-allocate arrays for various data files
num_points = mann_points.shape[1]
num_walls = wall_points.shape[1]
if s_p_wall == None:
s_p_wall = num_points/num_walls*np.ones(num_walls, dtype=int)
# store the wall points with the mann_points as points
mdict['points'] = np.vstack((np.repeat(wall_points, s_p_wall, 1),
mann_points))
# Pre-allocate arrays for non-timeseries data
nts_data = {}
self.nts_data = nts_data
for fid in nts_names:
key = fid.replace('.', '')
nts_data[key] = np.zeros((data.node_num, num_points))
# Pre-allocate arrays for timeseries data
ts_data = {}
time_obs = {}
self.ts_data = ts_data
self.time_obs = time_obs
for fid in ts_names:
key = fid.replace('.', '')
meas_locs, total_obs, irtype = data.recording[key]
if irtype == 1:
ts_data[key] = np.zeros((meas_locs, total_obs, num_points))
else:
ts_data[key] = np.zeros((meas_locs, total_obs,
irtype, num_points))
time_obs[key] = np.zeros((total_obs,))
# Update and save
self.update_mdict(mdict)
self.save(mdict, save_file)
default = data.read_default(path=self.save_dir)
for w in xrange(num_walls):
# set walls
wall_dim = wall_points[..., w]
data.read_spatial_grid()
data.add_wall(wall_dim[:4], wall_dim[-1])
# update wall and prep all
for rf_dir in self.rf_dirs:
os.remove(rf_dir+'/fort.14')
shutil.copy(self.grid_dir+'/fort.14', rf_dir)
f14.update(data, path=rf_dir)
#PARALLEL: update file containing the list of rf_dirs
self.update_dir_file(self.num_of_parallel_runs)
devnull = open(os.devnull, 'w')
p = subprocess.Popen(['./prep_2.sh'], stdout=devnull,
cwd=self.save_dir)
p.communicate()
devnull.close()
for k in xrange(sum(s_p_wall[:w]), sum(s_p_wall[:w+1]),
self.num_of_parallel_runs):
if k+self.num_of_parallel_runs >= num_points-1:
stop = num_points
step = stop-k
else:
stop = k+self.num_of_parallel_runs
step = self.num_of_parallel_runs
run_script = self.write_run_script(num_procs, step,
procs_pnode, TpN, screenout,
num_writers)
self.write_prep_script(5)
for i in xrange(0, step):
# generate the Manning's n field
r_field = tmm.combine_basis_vectors(mann_points[..., i+k],
bv_dict, default,
data.node_num)
# create the fort.13 for r_field
f13.update_mann(r_field, self.rf_dirs[i])
# do a batch run of python
#PARALLEL: update file containing the list of rf_dirs
self.update_dir_file(self.num_of_parallel_runs)
devnull = open(os.devnull, 'w')
p = subprocess.Popen(['./prep_5.sh'], stdout=devnull,
cwd=self.save_dir)
p.communicate()
devnull.close()
devnull = open(os.devnull, 'w')
p = subprocess.Popen(['./'+run_script], stdout=subprocess.PIPE,
cwd=self.base_dir)
p.communicate()
devnull.close()
# get data
for i, kk in enumerate(range(k, stop)):
output.get_data_ts(kk, self.rf_dirs[i], self.ts_data,
time_obs, ts_names)
output.get_data_nts(kk, self.rf_dirs[i], data,
self.nts_data, nts_names)
# Update and save
self.update_mdict(mdict)
self.save(mdict, save_file)
# save data
self.update_mdict(mdict)
self.save(mdict, save_file)
return time_obs, ts_data, nts_data
def run_points(self,
data,
wall_points,
mann_points,
save_file,
num_procs=12,
procs_pnode=12,
ts_names=["fort.61"],
nts_names=["maxele.63"],
screenout=True,
s_p_wall=None,
num_writers=None,
TpN=12):
"""
Runs :program:`ADCIRC` for all of the configurations specified by
``wall_points`` and ``mann_points`` and returns a dictonary of arrays
containing data from output files. Assumes that the number of
``wall_points`` is less than the number of ``mann_points``. Runs
batches of :program:`PADCIRC` as a double for loop with the
:program:`ADCPREP` prepping the ``fort.14`` file on the exterior loop
and the ``fort.13`` file on the interior loop.
Reads in a default Manning's *n* value from self.save_dir and stores
it in data.manningsn_default
:param data: :class:`~polyadcirc.run_framework.domain`
:type wall_points: :class:`np.array` of size (5, ``num_of_walls``)
:param wall_points: containts the box_limits, and wall_height for each
wall [ximin, xmax, ymin, ymax, wall_height]
:type mann_points: :class:`np.array` of size (``num_of_basis_vec``,
``num_of_random_fields``), ``num_of_random_fields`` MUST be a
multiple of ``num_of_walls``. The ith wall will be associated with
the ith set of i*(num_of_random_fields/num_of_walls) mann_points
:param mann_points: containts the weights to be used for each run
:type save_file: string
:param save_file: name of file to save mdict to
:type num_procs: int or 12
:param num_procs: number of processors per :program:`ADCIRC`
simulation, 12 on lonestar, and 16 on stamped
:param int procs_pnode: number of processors per node
:param list() ts_names: names of ADCIRC timeseries
output files to be recorded from each run
:param list() nts_names: names of ADCIRC non timeseries
output files to be recorded from each run
:param boolean screenout: flag (True -- write ``ADCIRC`` output to
screen, False -- write ``ADCIRC`` output to temp file
:param int num_writers: number of MPI processes to dedicate soley to
the task of writing ascii files. This MUST be < num_procs
:param int TpN: number of tasks (cores to use) per node (wayness)
:rtype: (:class:`np.array`, :class:`np.ndarray`, :class:`np.ndarray`)
:returns: (``time_obs``, ``ts_data``, ``nts_data``)
.. note:: Currently supports ADCIRC output files ``fort.6*``,
``*.63``, ``fort.7*``, but NOT Hot Start Output
(``fort.67``, ``fort.68``)
"""
# setup and save to shelf
# set up saving
if glob.glob(self.save_dir + '/' + save_file):
os.remove(self.save_dir + '/' + save_file)
# Save matricies to *.mat file for use by MATLAB or Python
mdict = dict()
mdict['mann_pts'] = mann_points
mdict['wall_pts'] = wall_points
self.save(mdict, save_file)
#bv_array = tmm.get_basis_vec_array(self.basis_dir)
bv_dict = tmm.get_basis_vectors(self.basis_dir)
# Pre-allocate arrays for various data files
num_points = mann_points.shape[1]
num_walls = wall_points.shape[1]
if s_p_wall == None:
s_p_wall = num_points / num_walls * np.ones(num_walls, dtype=int)
# store the wall points with the mann_points as points
mdict['points'] = np.vstack((np.repeat(wall_points, s_p_wall,
1), mann_points))
# Pre-allocate arrays for non-timeseries data
nts_data = {}
self.nts_data = nts_data
for fid in nts_names:
key = fid.replace('.', '')
nts_data[key] = np.zeros((data.node_num, num_points))
# Pre-allocate arrays for timeseries data
ts_data = {}
time_obs = {}
self.ts_data = ts_data
self.time_obs = time_obs
for fid in ts_names:
key = fid.replace('.', '')
meas_locs, total_obs, irtype = data.recording[key]
if irtype == 1:
ts_data[key] = np.zeros((meas_locs, total_obs, num_points))
else:
ts_data[key] = np.zeros(
(meas_locs, total_obs, irtype, num_points))
time_obs[key] = np.zeros((total_obs, ))
# Update and save
self.update_mdict(mdict)
self.save(mdict, save_file)
default = data.read_default(path=self.save_dir)
for w in xrange(num_walls):
# set walls
wall_dim = wall_points[..., w]
data.read_spatial_grid()
data.add_wall(wall_dim[:4], wall_dim[-1])
# update wall and prep all
for rf_dir in self.rf_dirs:
os.remove(rf_dir + '/fort.14')
shutil.copy(self.grid_dir + '/fort.14', rf_dir)
f14.update(data, path=rf_dir)
#PARALLEL: update file containing the list of rf_dirs
self.update_dir_file(self.num_of_parallel_runs)
devnull = open(os.devnull, 'w')
p = subprocess.Popen(['./prep_2.sh'],
stdout=devnull,
cwd=self.save_dir)
p.communicate()
devnull.close()
for k in xrange(sum(s_p_wall[:w]), sum(s_p_wall[:w + 1]),
self.num_of_parallel_runs):
if k + self.num_of_parallel_runs >= num_points - 1:
stop = num_points
step = stop - k
else:
stop = k + self.num_of_parallel_runs
step = self.num_of_parallel_runs
run_script = self.write_run_script(num_procs, step,
procs_pnode, TpN, screenout,
num_writers)
self.write_prep_script(5)
for i in xrange(0, step):
# generate the Manning's n field
r_field = tmm.combine_basis_vectors(
mann_points[..., i + k], bv_dict, default,
data.node_num)
# create the fort.13 for r_field
f13.update_mann(r_field, self.rf_dirs[i])
# do a batch run of python
#PARALLEL: update file containing the list of rf_dirs
self.update_dir_file(self.num_of_parallel_runs)
devnull = open(os.devnull, 'w')
p = subprocess.Popen(['./prep_5.sh'],
stdout=devnull,
cwd=self.save_dir)
p.communicate()
devnull.close()
devnull = open(os.devnull, 'w')
p = subprocess.Popen(['./' + run_script],
stdout=subprocess.PIPE,
cwd=self.base_dir)
p.communicate()
devnull.close()
# get data
for i, kk in enumerate(range(k, stop)):
output.get_data_ts(kk, self.rf_dirs[i], self.ts_data,
time_obs, ts_names)
output.get_data_nts(kk, self.rf_dirs[i], data,
self.nts_data, nts_names)
# Update and save
self.update_mdict(mdict)
self.save(mdict, save_file)
# save data
self.update_mdict(mdict)
self.save(mdict, save_file)
return time_obs, ts_data, nts_data
def run_nobatch_q(self, data, mann_points, save_file,
num_procs=12, procs_pnode=12, stations=None,
screenout=True, num_writers=None, TpN=None):
"""
Runs :program:`ADCIRC` for all of the configurations specified by
``mann_points`` and returns a dictonary of arrays containing data from
output files. Runs batches of :program:`PADCIRC` as a single for loop
and preps both the ``fort.13`` and ``fort.14`` in the same step.
Stores only the QoI at the stations defined in `stations``. In this
case the QoI is the ``maxele63`` at the designated station.
Reads in a default Manning's *n* value from ``self.save_dir`` and
stores it in ``data.manningsn_default``
.. note:: Currently supports ADCIRC output files ``fort.6*``,
``*.63``, ``fort.7*``, but NOT Hot Start Output
(``fort.67``, ``fort.68``)
:param data: :class:`~polyadcirc.run_framework.domain`
:type mann_points: :class:`numpy.ndarray` of size (``num_of_basis_vec``,
``num_of_random_fields``), ``num_of_random_fields``
:param mann_points: containts the weights to be used for each run
:type save_file: string
:param save_file: name of file to save mdict to
:type num_procs: int or 12
:param num_procs: number of processors per :program:`ADCIRC`
simulation, 12 on lonestar, and 16 on stamped
:param int procs_pnode: number of processors per node
:param list stations: list of stations to gather QoI from. If
``None`` uses the stations defined in ``data``
:param bool screenout: flag (True -- write ``ADCIRC`` output to
screen, False -- write ``ADCIRC`` output to temp file
:param int num_writers: number of MPI processes to dedicate soley to
the task of writing ascii files. This MUST be less than
``num_procs``
:param int TpN: number of tasks (cores to use) per node (wayness)
:rtype: (:class:`numpy.ndarray`, :class:`numpy.ndarray`, :class:`numpy.ndarray`)
:returns: (``time_obs``, ``ts_data``, ``nts_data``)
"""
if TpN is None:
TpN = procs_pnode
# setup and save to shelf
# set up saving
if glob.glob(os.path.join(self.save_dir, save_file)):
old_files = glob.glob(os.path.join(self.save_dir, "*"+save_file))
shutil.move(os.path.join(self.save_dir, save_file),
os.path.join(self.save_dir,
str(len(old_files))+save_file))
# Save matricies to *.mat file for use by MATLAB or Python
mdict = dict()
mdict['mann_pts'] = mann_points
self.save(mdict, save_file)
bv_dict = tmm.get_basis_vectors(self.basis_dir)
# Pre-allocate arrays for various data files
num_points = mann_points.shape[1]
# Pre-allocate arrays for non-timeseries data
nts_data = {}
self.nts_data = nts_data
nts_data['maxele63'] = np.empty((data.node_num,
self.num_of_parallel_runs))
# Pre-allocate arrays for QoI data
if stations is None:
stations = data.stations['fort61']
xi = np.array([[s.x, s.y] for s in stations])
points = np.column_stack((data.array_x(), data.array_y()))
Q = np.empty((num_points, xi.shape[0]))
self.Q = Q
mdict['Q'] = Q
# Update and save
self.update_mdict(mdict)
self.save(mdict, save_file)
default = data.read_default(path=self.save_dir)
for k in xrange(0, num_points, self.num_of_parallel_runs):
if k+self.num_of_parallel_runs >= num_points:
stop = num_points
step = stop-k
else:
stop = k+self.num_of_parallel_runs
step = self.num_of_parallel_runs
run_script = self.write_run_script(num_procs, step,
procs_pnode, TpN, screenout,
num_writers)
self.write_prep_script(5)
for i in xrange(0, step):
# generate the Manning's n field
r_field = tmm.combine_basis_vectors(mann_points[..., i+k],
bv_dict, default,
data.node_num)
# create the fort.13 for r_field
data.update_mann(r_field, self.rf_dirs[i])
# do a batch run of python
#PARALLEL: update file containing the list of rf_dirs
self.update_dir_file(self.num_of_parallel_runs)
devnull = open(os.devnull, 'w')
p = subprocess.Popen(['./prep_5.sh'], stdout=devnull,
cwd=self.save_dir)
p.communicate()
devnull.close()
devnull = open(os.devnull, 'w')
p = subprocess.Popen(['./'+run_script], stdout=devnull,
cwd=self.base_dir)
p.communicate()
devnull.close()
# get data
for i, kk in enumerate(range(k, stop)):
output.get_data_nts(i, self.rf_dirs[i], data, self.nts_data,
["maxele.63"])
# fix dry nodes and interpolate to obtain QoI
self.fix_dry_nodes_nts(data)
for i, kk in enumerate(range(k, stop)):
values = self.nts_data["maxele63"][:, i]
Q[kk, :] = griddata(points, values, xi)
# Update and save
self.update_mdict(mdict)
self.save(mdict, save_file)
if num_points <= self.num_of_parallel_runs:
pass
elif (k+1)%(num_points/self.num_of_parallel_runs) == 0:
msg = str(k+1)+" of "+str(num_points)
print msg+" runs have been completed."
# save data
self.update_mdict(mdict)
self.save(mdict, save_file)
return Q
def run_points(self,
data,
points,
save_file,
num_procs=12,
procs_pnode=12,
ts_names=["fort.61"],
nts_names=["maxele.63"],
screenout=True,
cleanup_dirs=True,
num_writers=None,
TpN=12):
"""
Runs :program:`ADCIRC` for all of the configurations specified by
``points`` and returns a dictonary of arrays containing data from
output files
Reads in a default Manning's *n* value from self.save_dir and stores
it in data.manningsn_default
:param data: :class:`~polyadcirc.run_framework.domain`
:type points: :class:`np.array` of size (``num_of_basis_vec``,
``num_of_random_fields``)
:param points: containts the weights to be used for each run
:type save_file: string
:param save_file: name of file to save ``station_data`` to
:type num_procs: int or 12
:param num_procs: number of processors per :program:`ADCIRC`
simulation
:param int procs_pnode: number of processors per node, 12 on lonestar,
and 16 on stampede
:param list() ts_names: names of ADCIRC timeseries
output files to be recorded from each run
:param list() nts_names: names of ADCIRC non timeseries
output files to be recorded from each run
:param boolean screenout: flag (True -- write ``ADCIRC`` output to
screen, False -- write ``ADCIRC`` output to temp file
:param boolean cleanup_dirs: flag to delete all RF_dirs after run (True
-- yes, False -- no)
:param int num_writers: number of MPI processes to dedicate soley to
the task of writing ascii files. This MUST be < num_procs
:param int TpN: number of tasks (cores to use) per node (wayness)
:rtype: (:class:`np.array`, :class:`np.ndarray`, :class:`np.ndarray`)
:returns: (``time_obs``, ``ts_data``, ``nts_data``)
.. note:: Currently supports ADCIRC output files ``fort.6*``,
``*.63``, ``fort.7*``, but NOT Hot Start Output
(``fort.67``, ``fort.68``)
"""
# setup and save to shelf
# set up saving
if glob.glob(self.save_dir + '/' + save_file):
os.remove(self.save_dir + '/' + save_file)
# Save matricies to *.mat file for use by MATLAB or Python
mdict = dict()
mdict['mann_pts'] = points
self.save(mdict, save_file)
#bv_array = tmm.get_basis_vec_array(self.basis_dir)
bv_dict = tmm.get_basis_vectors(self.basis_dir)
# Pre-allocate arrays for various data files
num_points = points.shape[1]
# Pre-allocate arrays for non-timeseries data
nts_data = {}
self.nts_data = nts_data
for fid in nts_names:
key = fid.replace('.', '')
nts_data[key] = np.zeros((data.node_num, num_points))
# Pre-allocate arrays for timeseries data
ts_data = {}
time_obs = {}
self.ts_data = ts_data
self.time_obs = time_obs
for fid in ts_names:
key = fid.replace('.', '')
meas_locs, total_obs, irtype = data.recording[key]
if irtype == 1:
ts_data[key] = np.zeros((meas_locs, total_obs, num_points))
else:
ts_data[key] = np.zeros(
(meas_locs, total_obs, irtype, num_points))
time_obs[key] = np.zeros((total_obs, ))
# Update and save
self.update_mdict(mdict)
self.save(mdict, save_file)
default = data.read_default(path=self.save_dir)
for k in xrange(0, num_points, self.num_of_parallel_runs):
if k + self.num_of_parallel_runs >= num_points - 1:
stop = num_points
step = stop - k
else:
stop = k + self.num_of_parallel_runs
step = self.num_of_parallel_runs
run_script = self.write_run_script(num_procs, step, procs_pnode,
TpN, screenout, num_writers)
self.write_prep_script(5)
for i in xrange(0, step):
# generate the Manning's n field
r_field = tmm.combine_basis_vectors(points[...,
i + k], bv_dict,
default, data.node_num)
# create the fort.13 for r_field
f13.update_mann(r_field, self.rf_dirs[i])
# do a batch run of python
#PARALLEL: update file containing the list of rf_dirs
self.update_dir_file(self.num_of_parallel_runs)
devnull = open(os.devnull, 'w')
p = subprocess.Popen(['./prep_5.sh'],
stdout=devnull,
cwd=self.save_dir)
p.communicate()
devnull.close()
devnull = open(os.devnull, 'w')
p = subprocess.Popen(['./' + run_script],
stdout=devnull,
cwd=self.base_dir)
p.communicate()
devnull.close()
# get data
for i, kk in enumerate(range(k, stop)):
output.get_data_ts(kk, self.rf_dirs[i], self.ts_data, time_obs,
ts_names)
output.get_data_nts(kk, self.rf_dirs[i], data, self.nts_data,
nts_names)
# Update and save
self.update_mdict(mdict)
self.save(mdict, save_file)
# save data
self.update_mdict(mdict)
self.save(mdict, save_file)
if cleanup_dirs:
self.remove_random_field_directories()
return time_obs, ts_data, nts_data
def run_points(self, data, points, save_file, num_procs=12, procs_pnode=12,
ts_names=["fort.61"], nts_names=["maxele.63"],
screenout=True, cleanup_dirs=True, num_writers=None,
TpN=12):
"""
Runs :program:`ADCIRC` for all of the configurations specified by
``points`` and returns a dictonary of arrays containing data from
output files
Reads in a default Manning's *n* value from self.save_dir and stores
it in data.manningsn_default
:param data: :class:`~polyadcirc.run_framework.domain`
:type points: :class:`np.array` of size (``num_of_basis_vec``,
``num_of_random_fields``)
:param points: containts the weights to be used for each run
:type save_file: string
:param save_file: name of file to save ``station_data`` to
:type num_procs: int or 12
:param num_procs: number of processors per :program:`ADCIRC`
simulation
:param int procs_pnode: number of processors per node, 12 on lonestar,
and 16 on stampede
:param list() ts_names: names of ADCIRC timeseries
output files to be recorded from each run
:param list() nts_names: names of ADCIRC non timeseries
output files to be recorded from each run
:param boolean screenout: flag (True -- write ``ADCIRC`` output to
screen, False -- write ``ADCIRC`` output to temp file
:param boolean cleanup_dirs: flag to delete all RF_dirs after run (True
-- yes, False -- no)
:param int num_writers: number of MPI processes to dedicate soley to
the task of writing ascii files. This MUST be < num_procs
:param int TpN: number of tasks (cores to use) per node (wayness)
:rtype: (:class:`np.array`, :class:`np.ndarray`, :class:`np.ndarray`)
:returns: (``time_obs``, ``ts_data``, ``nts_data``)
.. note:: Currently supports ADCIRC output files ``fort.6*``,
``*.63``, ``fort.7*``, but NOT Hot Start Output
(``fort.67``, ``fort.68``)
"""
# setup and save to shelf
# set up saving
if glob.glob(self.save_dir+'/'+save_file):
os.remove(self.save_dir+'/'+save_file)
# Save matricies to *.mat file for use by MATLAB or Python
mdict = dict()
mdict['mann_pts'] = points
self.save(mdict, save_file)
#bv_array = tmm.get_basis_vec_array(self.basis_dir)
bv_dict = tmm.get_basis_vectors(self.basis_dir)
# Pre-allocate arrays for various data files
num_points = points.shape[1]
# Pre-allocate arrays for non-timeseries data
nts_data = {}
self.nts_data = nts_data
for fid in nts_names:
key = fid.replace('.', '')
nts_data[key] = np.zeros((data.node_num, num_points))
# Pre-allocate arrays for timeseries data
ts_data = {}
time_obs = {}
self.ts_data = ts_data
self.time_obs = time_obs
for fid in ts_names:
key = fid.replace('.', '')
meas_locs, total_obs, irtype = data.recording[key]
if irtype == 1:
ts_data[key] = np.zeros((meas_locs, total_obs, num_points))
else:
ts_data[key] = np.zeros((meas_locs, total_obs,
irtype, num_points))
time_obs[key] = np.zeros((total_obs,))
# Update and save
self.update_mdict(mdict)
self.save(mdict, save_file)
default = data.read_default(path=self.save_dir)
for k in xrange(0, num_points, self.num_of_parallel_runs):
if k+self.num_of_parallel_runs >= num_points-1:
stop = num_points
step = stop-k
else:
stop = k+self.num_of_parallel_runs
step = self.num_of_parallel_runs
run_script = self.write_run_script(num_procs, step, procs_pnode,
TpN, screenout, num_writers)
self.write_prep_script(5)
for i in xrange(0, step):
# generate the Manning's n field
r_field = tmm.combine_basis_vectors(points[..., i+k], bv_dict,
default, data.node_num)
# create the fort.13 for r_field
f13.update_mann(r_field, self.rf_dirs[i])
# do a batch run of python
#PARALLEL: update file containing the list of rf_dirs
self.update_dir_file(self.num_of_parallel_runs)
devnull = open(os.devnull, 'w')
p = subprocess.Popen(['./prep_5.sh'], stdout=devnull, cwd=
self.save_dir)
p.communicate()
devnull.close()
devnull = open(os.devnull, 'w')
p = subprocess.Popen(['./'+run_script], stdout=devnull, cwd=
self.base_dir)
p.communicate()
devnull.close()
# get data
for i, kk in enumerate(range(k, stop)):
output.get_data_ts(kk, self.rf_dirs[i], self.ts_data, time_obs,
ts_names)
output.get_data_nts(kk, self.rf_dirs[i], data, self.nts_data,
nts_names)
# Update and save
self.update_mdict(mdict)
self.save(mdict, save_file)
# save data
self.update_mdict(mdict)
self.save(mdict, save_file)
if cleanup_dirs:
self.remove_random_field_directories()
return time_obs, ts_data, nts_data
