def test_edge_cons(out,semiinf=True,lhs=True):
# test LHS edge conditions (semi-infinite)
print('Test edge conditions:')
th_vec = out['angles']
print(len(th_vec))
if semiinf:
figname = 'fig_scripts/figs/SSboltzmann-EdgeCons-semiinf.png'
edge = out['edge_lhs']
elif lhs:
figname = 'fig_scripts/figs/SSboltzmann-EdgeCons-lhs.png'
edge = out['edge_lhs']
else:
figname = 'fig_scripts/figs/SSboltzmann-EdgeCons-rhs.png'
edge = out['edge_rhs']
if 1:
print('angles (deg)')
print(th_vec[:10]*180/np.pi)
print('cosines')
print(np.cos(th_vec)[:10])
print('Im(E_edge),x=0')
print(edge['E_edge'].imag[:10])
print('Re(E_edge),x=0')
print(edge['E_edge'].real[:10])
print('Incident spectrum')
print(edge['dirspec_inc'][:10])
if 0:
plt.plot(th_vec*180/np.pi,edge['E_edge'].real)
plt.plot(th_vec*180/np.pi,edge['dirspec_inc'],'--r')
plt.show()
elif 1:
pobj = Fplt.plot_1d(th_vec*180/np.pi,edge['E_edge'].imag,
labs=['Angle, degrees','$E$'],linestyle='-',color='b')
Fplt.plot_1d(th_vec*180/np.pi,edge['E_edge'].real,
labs=None,pobj=pobj,linestyle='-',color='k')
Fplt.plot_1d(th_vec*180/np.pi,edge['dirspec_inc'].real,
labs=None,pobj=pobj,linestyle='--',color='r')
fig,ax,line = pobj
fig.savefig(figname,bbox_inches='tight',pad_inches=0.05)
ax.cla()
plt.close(fig)
print(' ')
print('Saving to file : '+figname)
print(' ')
return
def plot_diagnostics(Tp_vec, Wmiz, taux_max):
# plot MIZ width and taux max
figdir = "out_io/figs_diag"
# MIZ width:
fig = figdir + "/Wmiz.png"
f = Fplt.plot_1d(Tp_vec, Wmiz, ["$T_p$, s", "$W_{MIZ}$, km"])
plt.savefig(fig, bbox_inches="tight", pad_inches=0.05)
plt.close()
f.clf()
# tau_x
fig = figdir + "/taux.png"
f = Fplt.plot_1d(Tp_vec, taux_max, ["$T_p$, s", "stress ($x$ dir), Pa"])
plt.savefig(fig, bbox_inches="tight", pad_inches=0.05)
plt.close()
f.clf()
def plot_diagnostics(Tp_vec,Wmiz,taux_max):
# plot MIZ width and taux max
figdir = 'out_io/figs_diag'
# MIZ width:
fig = figdir+'/Wmiz.png'
f = Fplt.plot_1d(Tp_vec,Wmiz,['$T_p$, s','$W_{MIZ}$, km'])
plt.savefig(fig,bbox_inches='tight',pad_inches=0.05)
plt.close()
f.clf()
# tau_x
fig = figdir+'/taux.png'
f = Fplt.plot_1d(Tp_vec,taux_max,['$T_p$, s','stress ($x$ dir), Pa'])
plt.savefig(fig,bbox_inches='tight',pad_inches=0.05)
plt.close()
f.clf()
def plot_energy(out,width=None,n_test=0,Hs=1.,f_inc=None):
# n_test is the Fourier component to plot:
# (0 is the energy)
# NB odd n are zero
fdir = 'fig_scripts/figs/profiles/'
fdir2 = 'fig_scripts/figs/profiles/IsoFrac/'
if not os.path.exists(fdir):
os.mkdir(fdir)
if not os.path.exists(fdir2):
os.mkdir(fdir2)
if width is None:
semiinf = True
L = 500.0e3 # plotting limit
figname = fdir+'SSboltzmann_E'+str(n_test)+'_profile-semiinf.png'
figname2 = fdir2+'SSboltzmann_IsoFrac_profile-semiinf.png'
edge_keys = ['lhs']
else:
semiinf = False
L = width
figname = fdir+'SSboltzmann_E'+str(n_test)+'_profile-L'+str(width)+'.png'
figname2 = fdir2+'SSboltzmann_IsoFrac_profile-L'+str(width)+'.png'
edge_keys = ['lhs','rhs']
# plot energy vs x:
npts = 5000
xx = np.linspace(0.0,L,npts)
E_n = 0.0j*xx
#
cn = out['eig_coeffs']
M_c2th = out['edge_lhs']['M_c2th']
alp = out['inputs'][0]
alp_dis = out['inputs'][2]
th_vec = out['angles']
if 'M_E2En' in out.keys():
# have eigenvectors in position space;
# transform n=0 into Fourier space
inp0 = {}
inp_all = {}
for key in out.keys():
if type(out[key])==type([]):
print(key+' (list)')
inp0.update({key : list(out[key])})
inp_all.update({key : list(out[key])})
else:
print(key+' (np array)')
inp0.update({key:out[key].copy()})
inp_all.update({key:out[key].copy()})
Mt = out['M_E2En']
soln = out['solution']
for key in soln.keys():
if 'evecs' in key:
print('Taking FT of: '+key)
print(Mt.shape,inp_all['solution'][key].shape,inp0['solution'][key].shape)
EV = soln[key]
inp0['solution'][key] = np.array([Mt[n_test,:].dot(EV)]) # convert back to rank 2
print(Mt.shape,inp_all['solution'][key].shape,inp0['solution'][key].shape)
inp_all['solution'][key] = Mt.dot(EV)
else:
inp0 = out.copy()
inp_all = out
for key in out['solution'].keys():
if 'evecs' in key:
print('Taking '+str(n_test)+'-th row of: '+key)
inp0['solution'][key] = np.array([inp0['solution'][key][n_test,:]]) # convert back to rank 2
# calc Fourier coefficients at x:
if semiinf:
# semi-infinite
E_n = calc_expansion(out,xx,L=None,n_test=[n_test])
No2 = len(cn) # N/2
N = 2*No2
En_si = E_n
En_all = calc_expansion(out,xx,L=None)
E_coh = 0*xx # coherent energy: E going to right
iso_frac = 0*xx # amount of isotropy measure
dth = th_vec[1]-th_vec[0]
for n in range(npts):
E_th = out['M_En2E'].dot(En_all[n,:])
E_f = E_th[abs(th_vec)<dth].real # two closest intervals around 0
E_coh[n] = dth*(E_f.sum()) # integrate over these intervals
#
e0 = abs(E_n[n])*abs(E_n[n])
ea = abs(En_all[n,:])*abs(En_all[n,:])
iso_frac[n] = e0/np.sum(ea)
else:
# finite width
E_n = calc_expansion(inp0,xx,L=L)
N = len(cn)
No2 = int(N/2.)
if 0:
comp_si= 1
cg = out['inputs'][3]
Hs = out['inputs'][4]
f_inc = out['inputs'][5]
out_si = solve_boltzmann_ft_semiinf(alp=alp,N=N,alp_dis=alp_dis,cg=cg,Hs=Hs,f_inc=f_inc)
En_si = calc_expansion(out_si,xx,L=None,n_test=[n_test]) # semi-infinite profile
#
En_all = calc_expansion(inp_all,xx,L)
E_coh = 0*xx # coherent energy: E going to right
iso_frac = 0*xx # amount of isotropy measure
dth = th_vec[1]-th_vec[0]
M_ift = calc_M_En2E(th_vec)
for n in range(npts):
E_th = M_ift.dot(En_all[n,:])
E_f = E_th[abs(th_vec)<dth].real # two closest intervals around 0
E_coh[n] = dth*(E_f.sum()) # integrate over these intervals
#
e0 = abs(E_n[n])*abs(E_n[n])
ea = abs(En_all[n,:])*abs(En_all[n,:])
iso_frac[n] = e0/np.sum(ea)
th_vec = out['angles']
dth = 2*np.pi/float(N)
fwd_mask = np.zeros(N)
fwd_mask[np.cos(th_vec)>0] = 1.0
if 1:
if f_inc is None:
#dirspec_plane or analytical delta function
A = Hs/2./np.sqrt(2.)
Ec_tst = A*A/2.
else:
#dirspec_spreading
Ec_tst = 1./np.pi*(dth+.5*np.sin(2*dth))*pow(Hs/4.,2)
print('\n')
print('Check coherent energy (converted to Hs)')
print('(analytic integration at x=0)')
print(4*np.sqrt(E_coh[0]),4*np.sqrt(Ec_tst))
print('\n')
#
if 0:
for key in edge_keys:
print('************************************************')
print('check edge E')
edge = out['edge_'+key]
E_edge = edge['E_edge']
E0_p = dth*(fwd_mask*E_edge).sum()
E0_m = dth*((1-fwd_mask)*E_edge).sum()
if n_test==0:
print('E0 at edge: '+edge['which_edge'])
print('E0 fwd = '+str(E0_p))
print('E0 back = '+str(E0_m))
# print('E0 total = '+str(edge['En_edge'][0]))
print('E0 total 1 = '+str(E0_p+E0_m))
if edge['which_edge']=='lhs':
print('E0 total 2 = '+str(E_n[0]))
print('x = '+str(xx[0]))
else:
print('E0 total 2 = '+str(E_n[-1]))
print('x = '+str(xx[-1]))
print('************************************************')
print('\n')
if 0:
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
ax.plot(xx,E_n.real)
ax.set_yscale('log')
plt.show()
elif 0:#n_test==0:
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
pobj = [fig,ax]
if (not semiinf) and (comp_si==1):
Fplt.plot_1d(xx/1.0e3,4*np.sqrt(En_si.real),pobj=pobj,
plot_steps=False,linestyle='-',color='g')
Fplt.plot_1d(xx/1.0e3,4*np.sqrt(E_n.real),pobj=pobj,
plot_steps=False,labs=['$x$, km','$H_s$, m'],linestyle='-',color='k')
Fplt.plot_1d(xx/1.0e3,4*np.sqrt(E_coh),pobj=pobj,
plot_steps=False,linestyle='--',color='r')
# check vs exponential decay
Fplt.plot_1d(xx/1.0e3,Hs*np.exp(-alp/2.*xx),pobj=pobj,
plot_steps=False,linestyle='--',color='b')
# check vs equi-partition of energy
E_eq = En_si[-1].real/float(N)
Fplt.plot_1d(xx/1.0e3,4*np.sqrt(E_eq)+0*xx,pobj=pobj,
plot_steps=False,linestyle='--',color='g')
if lam[0]>0.0:
# dissipation so plot y with log scale (exponential decay)
ax.set_yscale('log')
plt.savefig(figname,bbox_inches='tight',pad_inches=0.05)
ax.cla()
plt.close(fig)
print(' ')
print('Saving to file : '+figname)
print(' ')
# plot amount of isotropy:
fig = plt.figure()
Fplt.plot_1d(xx/1.0e3,iso_frac,pobj=pobj,
plot_steps=False,labs=['$x$, km','Isotropic fraction'],linestyle='-',color='k')
Fplt.plot_1d(xx/1.0e3,1-np.exp(-alp*xx),pobj=pobj,
plot_steps=False,linestyle='--',color='r')
plt.savefig(figname2,bbox_inches='tight',pad_inches=0.05)
plt.close()
fig.clf()
print(' ')
print('Saving to file : '+figname2)
print(' ')
elif 1:
# simple plot
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
if 0:
# of E
Fplt.plot_1d(xx/1.0e3,E_n.real,pobj=[fig,ax],
plot_steps=False,labs=['$x$, km','$E$, m$^2$'],linestyle='-',color='k')
else:
# of Hs
Fplt.plot_1d(xx/1.0e3,4*np.sqrt(E_n.real),pobj=[fig,ax],
plot_steps=False,labs=['$x$, km','$H_s$, m'],linestyle='-',color='k')
if alp_dis>0.0:
ax.set_yscale('log')
fig.savefig(figname,bbox_inches='tight',pad_inches=0.05)
ax.cla()
plt.close(fig)
print(' ')
print('Saving to file : '+figname)
print(' ')
out = {'E_n':E_n,'x':xx,'n':n_test,'E_coh':E_coh}
# save data to file
if n_test==0:
Hs = 4*np.sqrt(E_n.real)
Hs_f = 4*np.sqrt(E_coh)
ddir = 'fig_scripts/figs/profiles/datfiles'
if not os.path.exists(ddir):
os.mkdir(ddir)
if width is None:
out_file = ddir+'/steady_semiinf.dat'
else:
out_file = ddir+'/steady_L'+str(width)+'.dat'
print('\n')
print('Saving data points to '+out_file)
of1 = open(out_file,'w')
of1.write('x, m Hs, m Hs (coherent), m\n')
for n in range(len(xx)):
of1.write('%f %f %f\n'%(xx[n],Hs[n],Hs_f[n]))
of1.close()
return out
E_n = Fbs.calc_energy(out,x_ice,L=ice_width,n_test=[0])
Hs_steady = 4*np.sqrt(E_n[:,0].real)
# print(x_ice)
# print(Hs_steady)
# fig = Fplt.plot_1d(1.e-3*(xe+x_ice),Hs_steady,labs=labs,color='y',linewidth=3)
#out_fields = Fdat.fn_check_prog(outdir,nstep) # load ice/wave conditions from binaries
#Hs_n = out_fields['Hs'][:,0]
#
if loop_c==Nc-1:
loop_c = 0
loop_s = loop_s+1
else:
loop_c = loop_c+1
fig = Fplt.plot_1d(1.e-3*(xe+x_ice),Hs_steady,labs=labs,f=fig,color=cols[loop_c],linestyle=lstil[loop_s])
#
figdir = 'fig_scripts/figs'
figname = figdir+'/test_steady.png'
print('saving to '+figname+'...')
plt.savefig(figname,bbox_inches='tight',pad_inches=0.05)
plt.close()
fig.clf()
#
# if 1:
# # print to dat-file
# dfil = figdir+'/test_steady1.dat'
# fid = open(dfil,'w')
# blk = 4*' '
# for loop_x in range(len(xx)):
# lin = ('%f' % (1.e3*xx[loop_x]) )
def plot_simulation(outdir=".", infile_grid=None, PLOT_INIT=0, PLOT_PROG_OPT=0):
import numpy as np
import os
import sys
import shutil
import struct
# import matplotlib.rcsetup as rc
##
## NB run from 'run' directory !!
##
w2d = os.getenv("WIM2D_PATH")
dd = w2d + "/fortran"
sys.path.append(dd + "/bin")
sys.path.append(dd + "/py_funs")
import fns_get_data as Fdat
import fns_plot_data as Fplt
# Make plots
bindir = outdir + "/binaries" # wim_init.[ab],wim_out.[ab],"prog" directory with wim_prog???.[ab]
figdir = outdir + "/figs" # where to save files
if infile_grid is None:
grid_prams = Fdat.fn_check_grid(bindir) # load grid from binaries
# dictionary with X,Y,...
else:
import fns_grid_setup as gs
# TODO read in infile_grid.txt
x0 = 0.0
y0 = 0.0
nx = 150
ny = 4
dx = 4.0e3
dy = 40.0e3
LAND_OPT = 0 # no land
grid_arrays, grid_prams = gs.get_grid_arrays(x0=x0, y0=y0, nx=nx, ny=ny, dx=dx, dy=dy, LAND_OPT=LAND_OPT)
##########################################################################
if PLOT_INIT == 1:
# Look at initial fields:
print("Plotting initial conditions...")
ice_fields, wave_fields = Fdat.fn_check_init(bindir) # load initial conditions from binaries
#
figdir1 = figdir + "/init/"
Fplt.fn_plot_init(grid_prams, ice_fields, wave_fields, figdir1) # plot initial conditions
print("Plots in " + figdir + "/init")
print(" ")
##########################################################################
################################################################
# Look at end results:
out_fields = Fdat.fn_check_out_bin(bindir)
print("Plotting results...")
figdir2 = figdir + "/final/"
Fplt.fn_plot_final(grid_prams, out_fields, figdir2)
print("Plots in " + figdir2 + "\n")
print(" ")
################################################################
if PLOT_PROG_OPT == 1:
################################################################
# Plot progress files (if they exist)
# - as colormaps
figdir3 = figdir + "/prog"
prog_files = os.listdir(bindir + "/prog")
steps = []
for pf in prog_files:
if ".a" == pf[-2:]:
stepno = pf[-5:-2]
steps.append(stepno)
# make dir for progress plots
if (not os.path.exists(figdir3)) and len(steps) > 0:
os.mkdir(figdir3)
# clear old progress plots
old_dirs = os.listdir(figdir3)
for od in old_dirs:
# need this for macs
if od != ".DS_Store":
# os.rmdir(figdir3+'/'+od)
shutil.rmtree(figdir3 + "/" + od)
for stepno in steps:
print("Plotting results at time step " + stepno + " ...")
prog_fields = Fdat.fn_check_prog(outdir, int(stepno))
figdir3_0 = figdir3 + "/" + stepno
Fplt.fn_plot_final(grid_prams, prog_fields, figdir3_0)
print("Plots in " + figdir3_0 + "\n")
################################################################
print(" ")
print("To make a movie of progress images:")
print("cd " + figdir + "/prog")
print(dd + "/tools/prog2mp4.sh Hs (or Dmax,taux,tauy)")
elif PLOT_PROG_OPT == 2:
################################################################
# Plot progress files (if they exist)
# - as profiles
steps2plot = range(0, 600, 40)
# steps2plot = range(0,140,40)
cols = ["k", "b", "r", "g", "m", "c"]
lstil = ["-", "--", "-.", ":"]
Nc = len(cols)
loop_c = -1
loop_s = 0
for nstep in steps2plot:
out_fields = Fdat.fn_check_prog(outdir, nstep) # load ice/wave conditions from binaries
Hs_n = out_fields["Hs"]
#
if loop_c == Nc - 1:
loop_c = 0
loop_s = loop_s + 1
else:
loop_c = loop_c + 1
fig = Fplt.plot_1d(xx, Hs_n, labs=labs, f=fig, color=cols[loop_c], linestyle=lstil[loop_s])
#
figname = figdir + "/convergence2steady.png"
print("saving to " + figname + "...")
plt.savefig(figname, bbox_inches="tight", pad_inches=0.05)
plt.close()
fig.clf()
lstil = ['-','--','-.',':']
Nc = len(cols)
loop_c = -1
loop_s = 0
figdir3 = figdir+'/prog'
prog_files = os.listdir(bindir+'/prog')
steps = []
for pf in prog_files:
if '.a'==pf[-2:]:
stepno = pf.strip('wim_prog').strip('.a')
steps.append(stepno)
for step in steps:
out_fields = Fdat.fn_check_prog(outdir,step) # load ice/wave conditions from binaries
Hs_n = out_fields['Hs']
#
if loop_c==Nc-1:
loop_c = 0
loop_s = loop_s+1
else:
loop_c = loop_c+1
fig = Fplt.plot_1d(xx,Hs_n,labs=labs,f=fig,color=cols[loop_c],linestyle=lstil[loop_s])
#
figname = figdir+'/convergence2steady.png'
print('saving to '+figname+'...')
plt.savefig(figname,bbox_inches='tight',pad_inches=0.05)
plt.close()
fig.clf()
def grid_setup(GRID_OPT=1,LAND_OPT=0):
outdir = '.' # wim_grid.[a,b] saved here
outdir2 = '.' # wave_info.h,grid_info.h saved here
dd = os.path.abspath(".")
dd2 = dd+'/'+outdir
print('\n')
print("Saving grid files to:")
print(dd2)
print('\n')
if not (os.path.exists(dd2)):
os.makedirs(dd2)
###########################################################
###########################################################
# set grid configurations
if type(GRID_OPT)==type('string'):
# read in parameters from infile
infile = GRID_OPT
print('using infile '+infile+' for parameters\n')
fid = open(infile)
lines = fid.readlines()
fid.close()
# check version number
Vno = 1
vno = int(lines[0].split()[0])
if vno!=Vno:
s1 = '\nWrong version of '+infile
s2 = '\nCurrent version number is '+str(vno)
s3 = '\nVersion number should be '+str(Vno)+'\n'
raise ValueError(s1+s2+s3)
# get values as floats 1st, then convert some to integers
params = []
for lin in lines[1:]:
lin2 = lin.split()
params.append(float(lin2[0]))
nx,ny,dx,dy,x0,y0,LAND_OPT = params
# convert some parameters to integers
nx = int(nx)
ny = int(ny)
LAND_OPT = int(LAND_OPT)
#
grid_arrays,grid_fields = get_grid_arrays(x0=x0,y0=y0,nx=nx,ny=ny,\
dx=dx,dy=dy,LAND_OPT=LAND_OPT)
elif GRID_OPT is 0:
# standard 1d setup:
nx = 150
ny = 4
dx = 4.0e3
dy = 10*dx # to make plots clearer
x0 = 0.
y0 = 0.
#
grid_arrays,grid_fields = get_grid_arrays(x0=x0,y0=y0,nx=nx,ny=ny,\
dx=dx,dy=dy,LAND_OPT=LAND_OPT)
elif GRID_OPT is 1:
# standard 2d setup:
nx = 150
ny = 50
dx = 4.0e3
dy = 4.0e3
x0 = 0.
y0 = 0.
#
grid_arrays,grid_fields = get_grid_arrays(x0=x0,y0=y0,nx=nx,ny=ny,\
dx=dx,dy=dy,LAND_OPT=LAND_OPT)
elif GRID_OPT is 2:
# to use with Philipp's "small-square" grid
diag_length = 96e3 # m
resolution = 0.75e3 # m
# this gives a rotated (x',y') grid to align with the sides of the square
grid_arrays,grid_fields = _get_grid_arrays_SmallSquare(diag_length,resolution)
#
nx = grid_fields['nx']
ny = grid_fields['ny']
dx = grid_fields['dx']
dy = grid_fields['dy']
print('nx = '+str(nx))
print('ny = '+str(ny))
print('dx = '+str(dx/1.e3)+'km')
print('dy = '+str(dy/1.e3)+'km')
###########################################################
###########################################################
print(' ')
print(60*'*')
gs.save_grid_info_hdr_f2py(outdir2,nx,ny,dx,dy)
gs.save_grid_f2py(outdir,grid_arrays)
print(60*'*')
print(' ')
###########################################################
###########################################################
if 0:
# check difference between binaries
# saved by pure fortran and f2py:
outdir1 = 'test/out' # fortran binaries here
# run grid_setup.sh with
# testing=1 in p_save_grid.F (recompile)
gf1 = Fdat.fn_check_grid(outdir1)
gf2 = Fdat.fn_check_grid(outdir)
keys = ['X','Y','scuy','scvx','scp2','scp2i','LANDMASK']
print('Comparing fortran to python:\n')
for key in keys:
diff = np.abs(gf1[key]-gf2[key])
diff_max = diff.max()
diff_min = diff.min()
print('max difference in : '+key+' = '+str(diff_max))
print('min difference in : '+key+' = '+str(diff_min)+'\n')
elif 1:
# check difference between binaries
# saved by f2py and the input fields:
gf = grid_fields
gf2 = Fdat.fn_check_grid(outdir)
keys = ['X','Y','scuy','scvx','scp2','scp2i','LANDMASK']
print('Comparing python in to python out:\n')
for key in keys:
diff = np.abs(gf[key]-gf2[key])
diff_max = diff.max()
diff_min = diff.min()
print('max difference in : '+key+' = '+str(diff_max))
print('min difference in : '+key+' = '+str(diff_min)+'\n')
###########################################################
###########################################################
SV_FIG = 1
if SV_FIG:
from matplotlib import pyplot as plt
# save test figure:
if not os.path.exists('out_py'):
os.mkdir('out_py')
fig = 'out_py/land.png'
#
gf = grid_fields
nx = gf['nx']
ny = gf['ny']
dx = gf['dx']
dy = gf['dy']
x = gf['X'][:,0]+dx/2.
x = np.concatenate([[x[0]-dx],x])/1.e3
y = gf['Y'][0,:]+dy/2.
y = np.concatenate([[y[0]-dy],y])/1.e3
if gf['ny']>1:
# 2d grid => make colormap of LANDMASK
z = gf['LANDMASK'].transpose()
f,ax = Fplt.cmap_3d(x,y,z,['$x$, km','$y$, km','LANDMASK'])
else:
# 1d grid => make 1d plot of LANDMASK
f,ax,line = Fplt.plot_1d(gf['X'][:,0]/1.0e3,gf['LANDMASK'][:,0],\
labs=['$x$, km','LANDMASK'])
print('Saving test figure : '+fig)
f.savefig(fig,bbox_inches='tight',pad_inches=0.05)
plt.close(f)
###########################################################
###########################################################
# print(' ')
# print(60*'*')
# print("Now compile WIM code in .Build")
# print("Run in ..")
# print(60*'*')
# print(' ')
###########################################################
return grid_fields,grid_arrays
alp=alp,N=N,alp_dis=alp_dis,cg=cg,f_inc=Fbs.dirspec_inc_spreading,Hs=Hs_in)
#
E_th = Fbs.calc_expansion(out,x_ice,L=ice_width)
dtheta = 2*np.pi/float(N)
E0 = dtheta*E_th.sum(1) # integral over directions (freq spec)
Hs_steady = 4*np.sqrt(E0.real)
#
S_th = E_th.dot(out['solution']['Rmat'].transpose())
S_cos = S_th.dot(dtheta*np.cos(out['angles'])) # integral with cos over directions
rhow = 1025 # kg/m^3
gravity = 9.81 # m/s^2
tx_steady = -(rhow*gravity/cp)*S_cos.real
#############################################################
# plot Hs
pobj = Fplt.plot_1d(1.e-3*(xe+x_ice),Hs_steady,pobj=[fig,ax1],plot_steps=False,\
labs=labs1,color='y',linewidth=3)
lines_h.append(pobj[-1])
# plot taux
pobj = Fplt.plot_1d(1.e-3*(xe+x_ice),tx_steady,pobj=[fig,ax2],plot_steps=False,\
labs=labs1,color='y',linewidth=3)
lines_t.append(pobj[-1])
text_leg.append('Steady')
if cmp_steady_num:
# compare to numerical scheme from matlab
# NB needs to be run for the same parameters
w2d = os.getenv('WIM2D_PATH')
tdir = w2d+'/matlab/boltzmann/out/'
tfil = tdir+'boltzmann_steady_numeric.dat'
#
ax = fig.add_subplot(1, 1, 1)
lines = []
legs = []
for pf in prog_files:
if ".a" == pf[-2:]:
stepno = pf.strip("wim_prog").strip(".a")
afile = pdir + "/" + pf
print(afile)
#
out_fields, info = Fdat.fn_read_general_binary(afile) # load ice/wave conditions from binaries
Hs_n = out_fields[vname][:, 0]
t_prog = info["t_out"] / 3600.0 # time in h
leg = "%5.1fh" % (t_prog)
#
loop_c = np.mod(loop_c + 1, Nc)
if loop_c == 0:
loop_s = np.mod(loop_s + 1, Ns)
fig, ax, line = Fplt.plot_1d(
xx, Hs_n, labs=labs, pobj=[fig, ax], color=cols[loop_c], linestyle=lstil[loop_s]
)
lines.append(line)
legs.append(leg)
#
ax.legend(lines, legs)
figname = figdir + "/time_dep_" + vname + ".png"
print("Saving to " + figname + "...")
fig.savefig(figname, bbox_inches="tight", pad_inches=0.05)
plt.close(fig)
