def plot(
ax,
model_name,
dat,
let,
points=[0, 1, 2, 3],
is_pairs=0,
pairs=[[0, 1], [2, 3]],
is_labels=True,
is_ownticks=False,
is_ownticklabels=False,
axistitle='',
is_position=True,
position=[0.1, 0.1, 0.6, 0.8],
is_ownlims=False,
xlims=[0, 20],
ylims=[0.0, 1.0],
xlabeltext='Time',
ylabeltext=r'T [$^\circ C \,$]',
xlabelfontsize=14,
ylabelfontsize=14,
xownticks=[10, 60, 600, 3600, 24*3600, 20*24*3600],
yownticks=[0.1+i*0.1 for i in range(9)],
xticklabels=['10s', '1min', '10min', '1h', '1d', '20d'],
yticklabels=[0.1+i*0.1 for i in range(9)],
labels={0: 'North', # Outer ring
1: 'Northwest',
2: 'West',
3: 'Southwest',
4: 'South',
5: 'Southeast',
6: 'East',
7: 'Northeast',
8: 'North', # Inner ring
9: 'Northwest',
10: 'West',
11: 'Southwest',
12: 'South',
13: 'Southeast',
14: 'East',
15: 'Northeast'},
coleros=['b', 'g', 'lightblue', 'cyan', 'r', 'chocolate', 'magenta',
'orange',
'b', 'g', 'lightblue', 'cyan', 'r', 'chocolate', 'magenta',
'orange'],
xticklabelfontsize=20,
yticklabelfontsize=20,
pic_format='pdf', # 'png','eps','pdf'
):
"""
A plotting function for means of single cell ensembles against observation
time.
Parameters
----------
ax : Axes
The axes to draw to.
model_name : string
String of model name.
'wavebc' - Model wavebc
'wavereal' - Model wavereal
'wavewell' - Model wavewell
'wave' - Model wave
dat : string
String with date of model run.
let : string
String of letter of model run.
Returns
-------
ax : Axes
Axes containing figure of variable array.
pic_name : string
Containing proposed saving location for Figure.
"""
# Load single cell array
num_locs = sc.num_single_cell(model_name, dat, let)
var = np.load(
pm.py_output_filename(
sca.tag,
'single_cell',
sc.specl(model_name, dat, let)+'_'+str(num_locs),
"npy",
)
)
# Load time array
t = sc.obstimes(model_name, dat, let)
# Axis position
if is_position:
ax.set_position(position)
# Title
ax.set_title(axistitle, fontsize=30)
# Plots
nrobs_int = sc.nrobs_int(model_name, dat, let)
[ax.semilogx(t, np.mean(var, axis=1)[:nrobs_int, i], 'o',
markersize=2, label=labels[i], c=coleros[ip])
for ip, i in enumerate(points)]
# Labels
if is_labels:
ax.set_xlabel(xlabeltext, fontsize=xlabelfontsize, labelpad=0)
ax.set_ylabel(ylabeltext, fontsize=ylabelfontsize)
# Ticks
if is_ownticks:
ax.xaxis.set_ticks(xownticks)
ax.yaxis.set_ticks(yownticks)
if is_ownticklabels:
ax.xaxis.set_ticklabels(xticklabels, fontsize=xticklabelfontsize)
ax.yaxis.set_ticklabels(yticklabels, fontsize=yticklabelfontsize)
# Limits
if is_ownlims:
ax.xlim(xlims[0], xlims[1])
ax.ylim(ylims[0], ylims[1])
# Figure name
pic_name = pm.py_output_filename(
sca.tag,
'single_cell',
sc.specl(model_name, dat, let)+'_'+str(num_locs),
pic_format
)
return ax, pic_name
def read(
model_name,
dat,
let,
fdir=None,
fname=None,
varname='uindex',
nt=0,
):
"""
Reading variable array from SHEMAT-Suite vtk-file.
Parameters
----------
model_name : string
String of model name.
dat : string
String with date of model run.
let : string
String of letter of model run.
varname : string
Variable name for array to be read.
Possibilities: 'uindex' 'head','temp','kz', 'v'
nt : string
Number of time step output.
Returns
-------
numpy_array : array
Array containing the variable array
numpy_array_name : string
Containing proposed saving location for Array.
"""
# Dirs
if fdir is None:
# samples_output_dir
fdir = rm.make_output_dirs(model_name, dat, let)[1]
if fname is None:
# time_out_file
fname = rm.make_file_dir_names(model_name, nt)[17]
# Get filetype ############################################################
if fname[-3:] == 'vtk':
ftype = 'vtk'
elif fname[-2:] == 'h5' or fname[-3:] == 'hdf':
ftype = 'hdf'
else:
print(fname)
raise RuntimeError('Wrong filetype.')
# Get reader ##############################################################
if ftype == 'vtk':
reader = pf.my_vtk(fdir, fname, varname)
elif ftype == 'hdf':
reader = pf.my_hdf(fdir+'/'+fname, varname)
# Numpy Array ############################################################
if ftype == 'vtk':
numpy_array = pf.my_vtk_to_numpy(reader)
elif ftype == 'hdf':
numpy_array = reader
# Numpy Array Name ########################################################
numpy_array_name = pm.py_output_filename(
fa.tag,
varname,
sc.specl(model_name, dat, let)+'_'+str(nt),
"npy",
)
return numpy_array, numpy_array_name
fig = plt.figure(1, figsize=[15, 10], dpi=200, facecolor='white')
# Run plot function
ax, pic_name = scp.plot(
fig.add_subplot(1, 1, 1),
model_name,
dat,
let,
)
# Legend
plt.legend(prop={
'size': 10,
}, markerscale=2.5)
# Save
if is_save:
plt.savefig(pic_name)
print('Saved as ' + pic_name)
# Show
if is_show:
plt.show()
else:
plt.clf()
# Backup
if is_backup:
pm.py_backup(pm.python_scripts_dir, sca.tag, "runplot", "ipy",
sc.specl(model_name, dat, let))
def plot(
ax,
model_name,
dat,
let,
befaft='aft',
nt=10,
numpy_array_name=None,
is_grid=True,
is_mask=False,
is_labels=True,
is_ownticks=False,
axistitle='',
title_fontsize=30,
varname='kz_mean', # 'head','v','temp','kz', 'uindex'
v_component=1, # 0, 1, 2
is_position=True,
position=[0.1, 0.1, 0.6, 0.8],
is_ownlims=False,
xlims=[0.0, 620.0],
ylims=[0.0, 620.0],
alpha=1.0,
maskvalue=7,
xlabelfontsize=40,
ylabelfontsize=40,
xownticks=[0.1 + i * 0.1 for i in range(9)],
yownticks=[0.1 + i * 0.1 for i in range(9)],
diff_ticks=1,
num_cbar=7,
low_cbar=10.0285,
high_cbar=10.0304,
auto_cbar=True,
pic_format='pdf', # 'png','eps','pdf'
):
"""
A plotting function for variable arrays in a NonUniformGrid.
Parameters
----------
ax : Axes
The axes to draw to.
model_name : string
String of model name.
dat : string
String with date of model run.
let : string
String of letter of model run.
nt : integer
Number inside file name.
numpy_array_name : string
Full file name of numpy array including ending .npy
Returns
-------
ax : Axes
Axes containing image of variable array.
pic_name : string
Containing proposed saving location for Figure.
"""
# Read grid arrays from pskf/tools/plot/specs.py
x = sc.x(model_name, dat, let)
y = sc.y(model_name, dat, let)
xticks = sc.xticks(model_name, dat, let)[::diff_ticks]
yticks = sc.yticks(model_name, dat, let)[::diff_ticks]
# Load variable array
if not numpy_array_name:
var = np.load(
pm.py_output_filename(
aa.tag, varname + '_' + str(nt).zfill(4) + '_' + befaft,
sc.specl(model_name, dat, let), "npy"))
else:
var = np.load(numpy_array_name)
if varname == 'v':
var = var[:, :, v_component]
if auto_cbar:
low_cbar = var.min()
high_cbar = var.max()
# # Possible Mask
if is_mask:
var = np.ma.array(var,
mask=np.logical_or(var < maskvalue - 0.5,
var > maskvalue + 0.5))
# Axis position
if is_position:
ax.set_position(position)
# Create image
im = mpl.image.NonUniformImage(ax,
interpolation='nearest',
cmap=pf.cmap_discretize(
cm.viridis, num_cbar),
norm=colors.Normalize(vmin=low_cbar,
vmax=high_cbar,
clip=False))
im.set_data(x, y, var)
im.set_alpha(alpha)
ax.images.append(im)
# Ticks
if is_ownticks:
ax.xaxis.set_ticks(xownticks)
ax.yaxis.set_ticks(yownticks)
else:
ax.xaxis.set_ticks(xticks)
ax.yaxis.set_ticks(yticks)
# Grid
if is_grid:
ax.grid()
# Title
ax.set_title(axistitle, fontsize=title_fontsize)
# Labels
ax.set_xlabel('[m]', fontsize=xlabelfontsize, visible=is_labels)
ax.set_ylabel('[m]', fontsize=ylabelfontsize, visible=is_labels)
ax.tick_params(length=10 if is_labels else 0)
ax.set_yticklabels(ax.get_yticks(), visible=is_labels)
ax.set_xticklabels(ax.get_xticks(), visible=is_labels)
# Axis Limits
ax.set_xlim(xlims[0], xlims[1])
ax.set_ylim(ylims[0], ylims[1])
# Figure name
if varname == 'v':
varname = varname + '_' + str(v_component)
if is_mask:
varname = varname + '_' + str(maskvalue).zfill(2)
pic_name = pm.py_output_filename(aa.tag, varname + '_' + str(nt).zfill(4),
sc.specl(model_name, dat, let),
pic_format)
return ax, pic_name
def read(
model_name,
dat,
let,
varname='kz_mean',
befaft='aft',
fdir=None,
fname=None,
nt=10,
):
"""
Reading variable arrays from SHEMAT-Suite.
Parameters
----------
model_name : string
String of model name.
dat : string
String with date of model run.
let : string
String of letter of model run.
varname : string
Variable name for array to be read.
Possibilities: 'kz_mean' 'kz_std','head_mean','lz_mean', 'temp_mean'
befaft : string
Specifies whether the output is read in from
before ('bef') or after ('aft') the EnKF update.
nt : integer
Number inside file name.
fdir : string
Full directory of vtk file.
fname : string
Full name of vtk file.
Returns
-------
numpy_array : array
Array containing the variable array
numpy_array_name : string
Containing proposed saving location for Array.
"""
# Automatic file name generation
if (not fdir and not fname):
# enkf_output_dir
fdir = rm.make_output_dirs(model_name, dat, let)[2]
if befaft == 'aft':
# assim_out_file_aft
fname = rm.make_file_dir_names(model_name, nt)[19]
elif befaft == 'bef':
# assim_out_file_bef
fname = rm.make_file_dir_names(model_name, nt)[18]
# Get vtk_reader ##########################################################
vtk_reader = pf.my_vtk(fdir, fname, varname)
# Debug ###################################################################
print(varname,
vtk_reader.GetOutput().GetCellData().GetArray(0).GetValueRange())
# Numpy Array ############################################################
numpy_array = pf.my_vtk_to_numpy(vtk_reader)
# Numpy Array Name ########################################################
numpy_array_name = pm.py_output_filename(
aa.tag, varname + '_' + str(nt).zfill(4) + '_' + befaft,
sc.specl(model_name, dat, let), "npy")
return numpy_array, numpy_array_name
def read(
model_name,
dat,
let,
fdir=None,
):
"""
Reading variable array from SHEMAT-Suite vtk-file.
Parameters
----------
model_name : string
String of model name.
dat : string
String with date of model run.
let : string
String of letter of model run.
Returns
-------
numpy_array : array
Array containing the full single_cell array
numpy_array[irobs,iens,iloc]:
- irobs: Observation time index
- iens: Ensemble member index
- iloc: Single cell location index
numpy_array_name : string
Containing proposed saving location for Array.
"""
# Single cell output directory
if fdir is None:
# single_cell_output_dir
fdir = (rm.make_output_dirs(model_name, dat, let)[0] +
'/single_cell_output')
# Read single cell location and variable
locs = sc.single_cell_locs(model_name, dat, let)
variables = sc.single_cell_variables(model_name, dat, let)
# Generate empty numpy_array
nrobs_int = sc.nrobs_int(model_name, dat, let)
num_locs = sc.num_single_cell(model_name, dat, let)
nrens = sc.nrens(model_name, dat, let)
numpy_array = np.zeros([nrobs_int, nrens, num_locs])
# single_cell_output_file
for iloc, loc in enumerate(locs):
fname = ('single_cell_E1_' + str(loc[0]).zfill(4) + '_' +
str(loc[1]).zfill(4) + '_' + str(loc[2]).zfill(4) + '_' +
str(variables[iloc]).zfill(4) + '_aft' + '.txt')
numpy_array[:, :, iloc] = np.loadtxt(fdir + '/' + fname, skiprows=5)
# Numpy Array Name ########################################################
numpy_array_name = pm.py_output_filename(
sca.tag,
'single_cell',
sc.specl(model_name, dat, let) + '_' + str(num_locs),
"npy",
)
return numpy_array, numpy_array_name
def plot(
ax,
model_name,
dat,
let,
num_mon=1,
is_labels=True,
is_ownticks=True,
varname='temp', # 'head','v','temp','kz', 'uindex'
position=[0.1, 0.1, 0.8, 0.8],
xlims=[0.0, 26000.0],
ylims=[15.0, 22.0],
# marker='o',
linewidth=5,
markercolor='black',
# markeralpha=1.0,
legend_label='default',
xlabel='[m]',
ylabel='[m]',
xlabelfontsize=40,
ylabelfontsize=40,
ticklabelfontsize=20,
xownticks=[0.1+i*0.1 for i in range(9)],
yownticks=[0.1+i*0.1 for i in range(9)],
pic_format='pdf', # 'png','eps','pdf'
):
"""
A plotting function for monitoring time series.
Parameters
----------
ax : Axes
The axes to draw to.
model_name : string
String of model name.
dat : string
String with date of model run.
let : string
String of letter of model run.
Returns
-------
ax : Axes
Axes containing image of variable array.
pic_name : string
Containing proposed saving location for Figure.
"""
# Load variable array
time = np.load(pm.py_output_filename(
ma.tag,
'time',
sc.specl(model_name, dat, let)+'_'+str(num_mon),
"npy")
)
var = np.load(pm.py_output_filename(
ma.tag,
varname,
sc.specl(model_name, dat, let)+'_'+str(num_mon),
"npy")
)
ax.plot(time, var, label=legend_label, color=markercolor, lw=linewidth)
# Axis position
ax.set_position(position)
# Ticks
if is_ownticks:
ax.xaxis.set_ticks(xownticks)
ax.yaxis.set_ticks(yownticks)
# Title
# ax.set_title('Temperature field')
# Labels
ax.set_xlabel(xlabel, fontsize=xlabelfontsize, visible=is_labels)
ax.set_ylabel(ylabel, fontsize=ylabelfontsize, visible=is_labels)
ax.tick_params(length=20 if is_labels else 0, labelsize=ticklabelfontsize)
# Axis Limits
ax.set_xlim(xlims[0], xlims[1])
ax.set_ylim(ylims[0], ylims[1])
# Figure name
pic_name = pm.py_output_filename(
ma.tag,
varname,
sc.specl(model_name, dat, let)+'_'+str(num_mon),
pic_format
)
return ax, pic_name
def plot(
ax,
model_name,
dat,
let,
nt=0,
is_grid=True,
is_mask=False,
is_labels=True,
is_ownticks=False,
is_ownticklabels=False,
axistitle='',
varname='uindex', # 'head','v','temp','kz', 'uindex'
v_component=1, # 0,1,2
is_position=True,
position=[0.1, 0.1, 0.6, 0.8],
is_ownlims=False,
xlims=[0.0, 0.8032],
ylims=[0.0, 0.8032],
zlims=[0.0, 0.8032],
alpha=1.0,
maskvalue=7,
xlabelfontsize=40,
ylabelfontsize=40,
xownticks=[0.1 + i * 0.1 for i in range(9)],
yownticks=[0.1 + i * 0.1 for i in range(9)],
xticklabels=[0.1 + i * 0.1 for i in range(9)],
yticklabels=[0.1 + i * 0.1 for i in range(9)],
xticklabelfontsize=20,
yticklabelfontsize=20,
num_cbar=7,
low_cbar=10.0285,
high_cbar=10.0304,
auto_cbar=True,
pic_format='pdf', # 'png','eps','pdf'
is_xz=False,
):
"""
A plotting function for variable arrays in a NonUniformGrid.
Parameters
----------
ax : Axes
The axes to draw to.
model_name : string
String of model name.
'wavebc' - Model wavebc
'wavereal' - Model wavereal
'wavewell' - Model wavewell
'wave' - Model wave
dat : string
String with date of model run.
let : string
String of letter of model run.
Returns
-------
ax : Axes
Axes containing image of variable array.
pic_name : string
Containing proposed saving location for Figure.
"""
# Read grid arrays from pskf/tools/plot/specs.py
x = sc.x(model_name, dat, let)
y = (sc.y(model_name, dat, let) if not is_xz else sc.z(
model_name, dat, let))
xticks = sc.xticks(model_name, dat, let)
yticks = (sc.yticks(model_name, dat, let) if not is_xz else sc.zticks(
model_name, dat, let))
# Load variable array
var = np.load(
pm.py_output_filename(
fa.tag,
varname,
sc.specl(model_name, dat, let) + '_' + str(nt),
"npy",
))
if is_xz: # Quick fix for x-z-arrays
var = var.flatten().reshape(var.shape[::-1])
if varname == 'v':
var = var[:, :, v_component]
if varname == 'head':
var = var - 10.0
if varname == 'kz':
var = np.log10(var)
if auto_cbar:
low_cbar = var.min()
high_cbar = var.max()
# # Possible Mask
if is_mask:
var = np.ma.array(var,
mask=np.logical_or(var < maskvalue - 0.5,
var > maskvalue + 0.5))
# Axis position
if is_position:
ax.set_position(position)
# Create image
im = mpl.image.NonUniformImage(ax,
interpolation='nearest',
cmap=pf.cmap_discretize(
cm.viridis, num_cbar),
norm=colors.Normalize(vmin=low_cbar,
vmax=high_cbar,
clip=False))
im.set_data(x, y, var)
im.set_alpha(alpha)
ax.images.append(im)
# Ticks
if is_ownticks:
ax.xaxis.set_ticks(xownticks)
ax.yaxis.set_ticks(yownticks)
else:
ax.xaxis.set_ticks(xticks[1::10])
ax.yaxis.set_ticks(yticks[1::10])
# Grid
if is_grid:
ax.grid()
# Title
ax.set_title(axistitle, fontsize=30)
# Labels
ax.set_xlabel(r'x ($\mathrm{m}$)',
fontsize=xlabelfontsize,
visible=is_labels)
ax.set_ylabel(r'y ($\mathrm{m}$)',
fontsize=ylabelfontsize,
visible=is_labels)
ax.tick_params(length=20 if is_labels else 0)
if is_ownticklabels:
ax.set_xticklabels(xticklabels,
visible=is_labels,
fontsize=xticklabelfontsize)
ax.set_yticklabels(yticklabels,
visible=is_labels,
fontsize=yticklabelfontsize)
ax.tick_params(axis="x", which="both", top=False, labeltop=False)
ax.tick_params(axis="y", which="both", right=False, labelright=False)
# Axis Limits
if is_ownlims:
ax.set_xlim(xlims[0], xlims[1])
ax.set_ylim(ylims[0] if not is_xz else zlims[0],
ylims[1] if not is_xz else zlims[1])
else:
ax.set_xlim(
sc.xlims(model_name, dat, let)[0],
sc.xlims(model_name, dat, let)[1])
ax.set_ylim(
sc.ylims(model_name, dat, let)[0] if not is_xz else sc.zlims(
model_name, dat, let)[0],
sc.ylims(model_name, dat, let)[1] if not is_xz else sc.zlims(
model_name, dat, let)[1])
# Figure name
if varname == 'v':
varname = varname + '_' + str(v_component)
if is_mask:
varname = varname + '_' + str(maskvalue).zfill(2)
pic_name = pm.py_output_filename(
fa.tag, varname,
sc.specl(model_name, dat, let) + '_' + str(nt), pic_format)
return ax, pic_name
def mean(
model_name,
dat,
let,
varname='uindex',
mons=[0, 1],
):
"""
Computing mean monitor arrays from certain monitoring points.
Parameters
----------
model_name : string
String of model name.
dat : string
String with date of model run.
let : string
String of letter of model run.
varname : string
Variable name for array to be read.
Possibilities: 'uindex' 'head','temp','kz', 'v'
mons : array of integers
Numbers for monitoring points for mean.
IMPORTANT: num_mon = 0 corresponds to the first
monitoring point in SHEMAT monitor file.
General: num_mon = i corresponds to monitoring
point i+1
Returns
-------
mean_array : array
Array containing the mean monitor variable array
mean_array_name : string
Containing proposed saving location for Array.
"""
for imon, num_mon in enumerate(mons):
# File name
filename = pm.py_output_filename(
ma.tag, varname,
sc.specl(model_name, dat, let) + '_' + str(num_mon), "npy")
# Check existence
if not os.path.isfile(filename):
raise RuntimeError('Monitoring numpy-file does not exist: ' +
filename)
# Load filename
if imon == 0:
mean_array = np.load(filename)
else:
mean_array = mean_array + np.load(filename)
if imon == len(mons) - 1:
mean_array = mean_array / np.float(len(mons))
# Mean array name
mean_array_name = pm.py_output_filename(
ma.tag, varname,
sc.specl(model_name, dat, let) + '_' + 'mean' + '_' +
'_'.join([str(i) for i in mons]), "npy")
return mean_array, mean_array_name
def read(
model_name,
dat,
let,
fdir=None,
fname=None,
varname='uindex',
num_mon=1,
):
"""
Reading monitor arrays from SHEMAT-Suite.
Parameters
----------
model_name : string
String of model name.
dat : string
String with date of model run.
let : string
String of letter of model run.
varname : string
Variable name for array to be read.
Possibilities: 'uindex' 'head','temp','kz', 'v'
num_mon : integer
Number for monitoring point.
IMPORTANT: num_mon = 0 corresponds to the first
monitoring point in SHEMAT monitor file.
General: num_mon = i corresponds to monitoring
point i+1
Returns
-------
numpy_array : array
Array containing the monitor variable array
numpy_array_name : string
Containing proposed saving location for Array.
"""
# Dirs
if fdir is None:
# samples_output_dir
fdir = rm.make_output_dirs(model_name, dat, let)[1]
if fname is None:
# monitor_file
fname = rm.make_file_dir_names(model_name)[16]
# Read from monitor file ##################################################
numpy_array = np.genfromtxt(
fdir + '/' + fname,
dtype='f8',
comments='%',
usecols=(ma.varpos[varname]),
)
# Reshape #################################################################
num_mons = sc.num_mons(model_name, dat, let)
if np.remainder(len(numpy_array), num_mons):
raise RuntimeError('Problem with num_mons')
numpy_array = numpy_array.reshape(len(numpy_array) / num_mons, num_mons)
numpy_array = numpy_array[:, num_mon]
# Numpy Array Name ########################################################
numpy_array_name = pm.py_output_filename(
ma.tag, varname,
sc.specl(model_name, dat, let) + '_' + str(num_mon), "npy")
return numpy_array, numpy_array_name