def load_from_nh(set_of_dir, nh):

    set_of_dir_nh = set_of_dir.filter(nh=nh, f=0)
    path = set_of_dir_nh.path_larger_t_start()

    sim = solveq2d.create_sim_plot_from_dir(path)

    tmin, tmax, tstatio = baseSW1lw.tminmaxstatio_from_sim(sim, VERBOSE=True)

    (dico_time_means,
     dico_results) = sim.output.spatial_means.compute_time_means(tstatio)
    c2 = sim.param['c2']
    c = np.sqrt(c2)
    EK = dico_time_means['EK']
    Fr = np.sqrt(2 * EK / c2)
    EA = dico_time_means['EA']
    EKr = dico_time_means['EKr']
    EKd = EK - EKr
    E = EK + EA
    epsK = dico_time_means['epsK']
    epsA = dico_time_means['epsA']
    eps = epsK + epsA
    epsK_tot = dico_time_means['epsK_tot']
    epsA_tot = dico_time_means['epsA_tot']

    Enorm = np.sqrt(eps * Lf * c)

    print 'c = {0:8.1f}, Fr = {1:8.3f}, eps = {2:8.2f}'.format(c, Fr, eps)
    return locals()
def spectra_from_namedir(nh):

    set_of_dir_nh = set_of_dir.filter(nh=nh)

    path = set_of_dir_nh.path_larger_t_start()
    sim = solveq2d.create_sim_plot_from_dir(path)
    tmin, tmax, tstatio = baseSW1lw.tminmaxstatio_from_sim(sim, VERBOSE=True)

    dico_results = sim.output.spectra.load1D_mean(tmin=tstatio)
    kh = dico_results['kh']

    spectEK = (dico_results['spectrum1Dkx_EK'] +
               dico_results['spectrum1Dkx_EK']) / 2
    spectEA = (dico_results['spectrum1Dkx_EA'] +
               dico_results['spectrum1Dkx_EA']) / 2
    spectEKr = (dico_results['spectrum1Dkx_EKr'] +
                dico_results['spectrum1Dkx_EKr']) / 2

    spectEKd = spectEK - spectEKr
    spectE = spectEK + spectEA
    dico1, dico2 = sim.output.spatial_means.compute_time_means(tstatio=tstatio)
    epsK = dico1['epsK']
    epsA = dico1['epsA']
    eps = epsK + epsA
    EK = dico1['EK']
    U = np.sqrt(2 * EK)
    c = np.sqrt(sim.param['c2'])
    return locals()
def sprectra_from_namedir(name_dir_results):
    path_dir_results = set_of_dir_results.path_dirs[name_dir_results]
    sim = solveq2d.create_sim_plot_from_dir(path_dir_results)
    dict_results = sim.output.spectra.load2D_mean(tmin=tmin)
    kh = dict_results['kh']
    EK = dict_results['spectrum2D_EK']
    EA = dict_results['spectrum2D_EA']
    EKr = dict_results['spectrum2D_EKr']
    EKd = EK - EKr
    return kh, EKr, EKd
Exemple #4
0
def print1sim(set_of_dir, f):
    """Print informations on one simulation."""

    print('\n\n')

    set_of_dir = set_of_dir.filter(f=f)
    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))

    if f > 0:
        Ro = eps**(1. / 3) * kf**(2. / 3) / f
        Bu = (kf * c / f)**2
        print('Ro = {0:.2f};    Bu =  {1:.2f}'.format(Ro, Bu))

        ftable.write('{0:4.1f} & {1:6.2g} & {2:6.2g} & '.format(f, Ro, Bu))
    else:
        ftable.write(' 0   &  $\infty$ & $\infty$ & ')

    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('\\\\')
Exemple #5
0
def load_from_namedir(set_of_dir, name_dir_results, tstatio):
    path_dir_results = set_of_dir.path_dirs[name_dir_results]
    sim = solveq2d.create_sim_plot_from_dir(path_dir_results)
    (dico_time_means, dico_results
     ) = sim.output.spatial_means.compute_time_means(tstatio)
    c2 = sim.param['c2']
    EK = dico_time_means['EK']
    Fr = np.sqrt(2*EK/c2)
    EA = dico_time_means['EA']
    EKr = dico_time_means['EKr']
    EKd = EK - EKr
    E = EK + EA
    epsK = dico_time_means['epsK']
    epsA = dico_time_means['epsA']
    eps = epsK + epsA
    epsK_tot = dico_time_means['epsK_tot']
    epsA_tot = dico_time_means['epsA_tot']
    c = np.sqrt(set_of_dir.dico_c2[name_dir_results])
    print 'c = {0:8.1f}, Fr = {1:8.3f}, eps = {2:8.2f}'.format(
        c, Fr, eps)
    return locals()
Exemple #6
0
                               SAVE_FIG=SAVE_FIG,
                               FOR_BEAMER=False,
                               fontsize=19)

dir_base = create_fig.path_base_dir + '/Results_SW1lw'

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_dir = glob.glob(str_to_find_path)

print paths_dir

sim = solveq2d.create_sim_plot_from_dir(paths_dir[0])

tmin = sim.output.spatial_means.first_saved_time()
tstatio = tmin + 4.

dico_results = sim.output.spectra.load1D_mean(tmin=tstatio)

kh = dico_results['kh']

EK = (dico_results['spectrum1Dkx_EK'] + dico_results['spectrum1Dkx_EK']) / 2
EA = (dico_results['spectrum1Dkx_EA'] + dico_results['spectrum1Dkx_EA']) / 2
EKr = (dico_results['spectrum1Dkx_EKr'] + dico_results['spectrum1Dkx_EKr']) / 2

E_tot = EK + EA
EKd = EK - EKr
def load_from_path(path):
    sim = solveq2d.create_sim_plot_from_dir(path)
    dico = sim.output.spatial_means.load()
    c = np.sqrt(sim.param.c2)
    return dico, c
Exemple #8
0
    EK = np.empty([nb_runs])
    EA = np.empty([nb_runs])
    EKr = np.empty([nb_runs])
    epsK = np.empty([nb_runs])
    epsA = np.empty([nb_runs])
    epsK_tot = np.empty([nb_runs])
    epsA_tot = np.empty([nb_runs])

    irun = -1

    for c2, name_solver in tuple_loop:
        path_dir = set_of_dir_results.one_path_from_values(solver=name_solver,
                                                           c2=c2)

        irun += 1
        sim = solveq2d.create_sim_plot_from_dir(name_dir=path_dir)

        (dict_time_means,
         dict_results) = sim.output.spatial_means.compute_time_means(tstatio)

        arr_c2[irun] = sim.param['c2']
        EK[irun] = dict_time_means['EK']

        Froude_numbers[irun] = 2 * EK[irun] / sim.param['c2']

        EA[irun] = dict_time_means['EA']
        EKr[irun] = dict_time_means['EKr']
        epsK[irun] = dict_time_means['epsK']
        epsA[irun] = dict_time_means['epsA']
        epsK_tot[irun] = dict_time_means['epsK_tot']
        epsA_tot[irun] = dict_time_means['epsA_tot']
Exemple #9
0
def load_from_namedir(set_of_dir, name_dir_results):
    path_dir_results = set_of_dir.path_dirs[name_dir_results]
    sim = solveq2d.create_sim_plot_from_dir(path_dir_results)
    dico = sim.output.spatial_means.load()
    c = np.sqrt(sim.param.c2)
    return dico, c
    short_name_article='SW1l', 
    SAVE_FIG=SAVE_FIG, 
    FOR_BEAMER=False, 
    fontsize=19
    )




name_dir_results = (
create_fig.path_base_dir+'/Results_for_article_SW1l'
'/Approach_runs_2048x2048'
'/SE2D_SW1lexlin_forcing_L=50.x50._2048x2048_c2=400_f=0_2013-05-29_23-54-57'
)

sim = solveq2d.create_sim_plot_from_dir(name_dir_results)
tmin = 30
dict_results = sim.output.spectra.load2D_mean(tmin=tmin)

kh = dict_results['kh']

EK = dict_results['spectrum2D_EK']
EA = dict_results['spectrum2D_EA']
EKr = dict_results['spectrum2D_EKr']
E_tot = EK + EA
EKd = EK - EKr
Edlin = dict_results['spectrum2D_Edlin']

fig, ax1 = create_fig.figure_axe(name_file=name_file)
ax1.set_xscale('log')
ax1.set_yscale('log')