def plot_one_resol(resol, style_lines='-', linewidth=1):
str_resol = repr(resol)
str_to_find_path = (dir_base + '/Pure_standing_waves_' + str_resol + '*')
# print str_to_find_path
paths_dir = glob.glob(str_to_find_path)
# print paths_dir
path_base = paths_dir[0]
set_of_dir = solveq2d.SetOfDirResults(path_base)
set_of_dir = set_of_dir.filter(solver='SW1lwaves', FORCING=True, f=0)
paths = set_of_dir.paths
print paths
nb_dirs = len(paths)
# dicos = []
for ii in xrange(nb_dirs):
dico, c = load_from_path(paths[ii])
# dicos.append(dico)
t = dico['t']
E = dico['E']
color = colors[c]
ax1.plot(t / tn, E / En, color + style_lines, linewidth=linewidth)
ax2.plot(t / tn, E / En, color + style_lines, linewidth=linewidth)
def print1sim(paths):
"""Print informations on one simulation."""
print('\n\n')
if len(paths) == 1:
path = paths[0]
else:
set_of_dir = solveq2d.SetOfDirResults(paths)
path = set_of_dir.path_larger_t_start()
sim = solveq2d.create_sim_plot_from_dir(path)
param = sim.param
nx = param['nx']
c = np.sqrt(sim.param['c2'])
nu8 = param['nu_8']
f = sim.param['f']
tmin, tmax, tstatio = baseSW1lw.tminmaxstatio_from_sim(sim, VERBOSE=True)
dico1, dico2 = sim.output.spatial_means.compute_time_means(tstatio=tstatio)
epsK = dico1['epsK']
epsA = dico1['epsA']
eps = epsK + epsA
Ff = eps**(1. / 3) * kf**(-1. / 3) / c
n = 8
kd8 = (eps / nu8**3)**(1. / (3 * n - 2))
kmax = param['coef_dealiasing'] * np.pi * nx / param['Lx']
minh, maxu = minhmaxu_from_sim(sim)
ftable.write('\n')
ftable.write('{0:4d} & {1:4.0f} & '.format(nx, c))
ftable.write('{0:7.1e} & '.format(nu8))
ftable.write('{0:4.2f} & '.format(eps))
ftable.write('{0:.2f} & '.format(kmax / kd8))
ftable.write('{0:3.0f} & '.format(kd8 / kf))
ftable.write('{0:6.3f} & '.format(Ff))
ftable.write('{0:4.2f} & {1:4.2f} '.format(minh, maxu / c))
ftable.write('\\\\')
if f > 0:
Ro = (eps / Lf**2)**(1. / 3) / f
Bu = (Ro / Ff)**2
print('Ro = {0:.2f}; Bu = {1:.2f}'.format(Ro, Bu))
def plot_one_resol(resol, style_lines='-'):
"""plot on resolution."""
str_resol = repr(resol)
str_to_find_path = (
dir_base+'/Pure_standing_waves_'+
str_resol+'*'
)
paths = glob.glob(str_to_find_path)
path = paths[0]
set_of_dir = solveq2d.SetOfDirResults(path)
set_of_dir = set_of_dir.filter(solver='SW1lwaves',
FORCING=True,
c=20)
print('poum Emean_f', set_of_dir.dico_values['f'])
dicos = []
for f in set_of_dir.dico_values['f']:
dico = load_from_f(set_of_dir, f)
dicos.append(dico)
nb_f = len(dicos)
f = np.empty([nb_f])
kd = np.empty([nb_f])
EKd = np.empty([nb_f])
EA = np.empty([nb_f])
eps = np.empty([nb_f])
E = np.empty([nb_f])
for ii in xrange(nb_f):
f[ii] = dicos[ii]['f']
kd[ii] = dicos[ii]['kd']
EKd[ii] = dicos[ii]['EKd']
EA[ii] = dicos[ii]['EA']
eps[ii] = dicos[ii]['eps']
E[ii] = dicos[ii]['E']
kadim = (kd/kf)**2
ax1.plot(kadim, E, 'k'+style_lines, linewidth=2)
return kadim, E
def paths_from_nh_c_f(nh, c, f=None):
"""Return paths corresponding to nh and c."""
str_nh = repr(nh)
str_to_find_path = (
path_base_dir_results+'/Pure_standing_waves_'+
str_nh+'*/SE2D*c='+repr(c)+'_*'
)
# print str_to_find_path
paths = glob.glob(str_to_find_path)
if len(paths) == 0:
print('No path for resol = {0} and c = {1}'.format(nh, c))
if f is not None:
set_of_dir = solveq2d.SetOfDirResults(paths)
set_of_dir = set_of_dir.filter(f=f)
paths = set_of_dir.paths
return paths
def plot_one_c(c, style_lines='-', linewidth=2.2):
paths_c = baseSW1lw.paths_from_c(c)
# print paths_c
set_of_dir = solveq2d.SetOfDirResults(paths_c)
set_of_dir = set_of_dir.filter(solver='SW1lwaves',
FORCING=True,
f=0.,
c2=c**2)
dicos = []
for nh in set_of_dir.dico_values['nh']:
if nh < 7000:
dico = load_from_nh(set_of_dir, nh)
dicos.append(dico)
nb_nh = len(dicos)
nh = np.empty([nb_nh])
c = np.empty([nb_nh])
EKd = np.empty([nb_nh])
EA = np.empty([nb_nh])
eps = np.empty([nb_nh])
E = np.empty([nb_nh])
Enorm = np.empty([nb_nh])
for ii in xrange(nb_nh):
nh[ii] = dicos[ii]['nh']
c[ii] = dicos[ii]['c']
EKd[ii] = dicos[ii]['EKd']
EA[ii] = dicos[ii]['EA']
eps[ii] = dicos[ii]['eps']
E[ii] = dicos[ii]['E']
Enorm[ii] = dicos[ii]['Enorm']
Ueps = eps**(1. / 3)
line = ax1.plot(nh, E / Enorm, 'kx' + style_lines, linewidth=linewidth)
return line[0]
def plot_one_dir_base(dir_base, tstatio=40):
set_of_dir_results = solveq2d.SetOfDirResults(dir_base=dir_base)
dirs = set_of_dir_results.dirs_from_values(solver='SW1lwaves',
FORCING=True)
print dirs
print set_of_dir_results.dico_c2.keys()
nb_dirs = len(dirs)
dicos = []
temp = 0
for ii in xrange(nb_dirs):
if set_of_dir_results.dico_c2[dirs[ii]] > 50**2:
temp += 1
dico = load_from_namedir(set_of_dir_results, dirs[ii], tstatio)
dicos.append(dico)
nb_dirs = temp
c = np.empty([nb_dirs])
EKd = np.empty([nb_dirs])
EA = np.empty([nb_dirs])
eps = np.empty([nb_dirs])
E = np.empty([nb_dirs])
for ii in xrange(nb_dirs):
c[ii] = dicos[ii]['c']
EKd[ii] = dicos[ii]['EKd']
EA[ii] = dicos[ii]['EA']
eps[ii] = dicos[ii]['eps']
E[ii] = dicos[ii]['E']
K0 = 0.
K1 = 0.
K2 = 0.
K4 = 0.
K0 = 0.1
K1 = -10.
# K2 = 0.23
K4 = 0
Ueps = eps**(1./3)
def Efit_from_params(params):
K0 = params[0]
K1 = params[1]
K2 = params[2]
Efit_classic = K0*Ueps**2/(1 + 0*K1/c)**(2./3)
Efit_weak = K2*np.sqrt(Ueps**3*c)
Efit = Efit_classic + Efit_weak
return Efit, Efit_classic, Efit_weak
def to_minimize(params):
Efit, Efit_classic, Efit_weak = Efit_from_params(params)
return np.sum((Efit - E)**2)
params = np.array([K0, K1, K2])
params = optimize.fmin(to_minimize, params, xtol=1e-4, disp=True)
Efit, Efit_classic, Efit_weak = Efit_from_params(params)
K0 = params[0]
K1 = params[1]
K2 = params[2]
print('K0 ={0} ; K1 = {1} ; K2 = {2}'.format(K0, K1, K2))
# ax1.plot(c, EA/norm, 'b', linewidth=2)
# ax1.plot(c, EKd/norm, 'r', linewidth=2)
ax1.plot(c, E, 'k-x', linewidth=2)
ax1.plot(c, Efit, 'c-x', linewidth=2)
ax1.plot(c, Efit_classic, 'r-x', linewidth=2)
ax1.plot(c, Efit_weak, 'y-x', linewidth=2)
import numpy as np
import glob
import os
import matplotlib.pylab as plt
from solveq2d import solveq2d
LOAD = True
# LOAD = False
dir_base = 'Approach_runs_1024x1024'
# dir_base = 'Waves_statio_256x256'
set_of_dir_results = solveq2d.SetOfDirResults(dir_base=dir_base)
values_c2 = set_of_dir_results.values_c2
# values_c2 = [600]
values_solver = set_of_dir_results.values_solver
values_solver = ['SW1l']
tstatio = 250
if LOAD:
tuple_loop = [(c2, name_solver) for c2 in values_c2
for name_solver in values_solver]
nb_runs = 0
for c2, name_solver in tuple_loop:
SAVE_FIG=SAVE_FIG,
FOR_BEAMER=False,
fontsize=fontsize)
dir_base = baseSW1lw.path_base_dir_results
str_resol = repr(resol)
str_to_find_path = (dir_base + '/Pure_standing_waves_' + str_resol +
'*/SE2D*c=' + repr(c)) + '_*'
print(str_to_find_path)
paths = glob.glob(str_to_find_path)
print(paths)
set_of_dir = solveq2d.SetOfDirResults(paths)
path = set_of_dir.path_larger_t_start()
sim = solveq2d.create_sim_plot_from_dir(path)
tmin, tmax, tstatio = baseSW1lw.tminmaxstatio_from_sim(sim, VERBOSE=True)
dico_spectra, dico_results = sim.output.time_sigK.compute_spectra()
omega = dico_spectra['omega']
time_spectra_q = dico_spectra['time_spectra_q']
time_spectra_a = dico_spectra['time_spectra_a']
time_spectra_d = dico_spectra['time_spectra_d']
omega_shell = dico_results['omega_shell']
kh_shell = dico_results['kh_shell']
def plot_one_resol(nh, style_lines='-'):
paths = baseSW1lw.paths_from_nh(nh)
set_of_dir = solveq2d.SetOfDirResults(paths)
set_of_dir = set_of_dir.filter(solver='SW1lwaves', FORCING=True, f=0)
path = set_of_dir.path_larger_t_start()
dicos = []
for c in set_of_dir.dico_values['c']:
dico = load_from_c(set_of_dir, c)
dicos.append(dico)
nb_c = len(dicos)
c = np.empty([nb_c])
EKd = np.empty([nb_c])
EA = np.empty([nb_c])
eps = np.empty([nb_c])
E = np.empty([nb_c])
for ii in xrange(nb_c):
c[ii] = dicos[ii]['c']
EKd[ii] = dicos[ii]['EKd']
EA[ii] = dicos[ii]['EA']
eps[ii] = dicos[ii]['eps']
E[ii] = dicos[ii]['E']
K0 = 0.
K1 = 0.
K2 = 0.
K4 = 0.
K0 = 0.
K1 = 0.
K2 = 0.3
K4 = 0
Ueps = eps**(1. / 3)
def Efit_from_params(params):
K0 = params[0]
K1 = params[1]
K2 = params[2]
Efit_classic = 0 #K0*Ueps**2 #/(1 + 0*K1/c)**(2./3)
Efit_weak = K2 * np.sqrt(eps * Lf * c)
# Efit = Efit_classic + Efit_weak
Efit = Efit_weak
return Efit, Efit_classic, Efit_weak
def to_minimize(params):
Efit, Efit_classic, Efit_weak = Efit_from_params(params)
for_sum = (Efit - E)**2
return np.sum(for_sum[c > 0])
params = np.array([K0, K1, K2])
params = optimize.fmin(to_minimize, params, xtol=1e-4, disp=True)
Efit, Efit_classic, Efit_weak = Efit_from_params(params)
K2 = params[2]
print('K2 = {0}'.format(K2))
norm = np.sqrt(eps)
ax1.plot(c, E / norm, 'k' + style_lines, linewidth=2.2)
ax1.plot(c, Efit / norm, 'c' + style_lines, linewidth=2.2)