def _online_plot_saving(self, dict_results):
transfer2D_CPE = dict_results["transfer2D_CPE"]
transfer2D_EKr = dict_results["transfer2D_EKr"]
transfer2D_EKd = dict_results["transfer2D_EKd"]
transfer2D_EK = transfer2D_EKr + transfer2D_EKd
transfer2D_EAr = dict_results["transfer2D_EAr"]
transfer2D_EAd = dict_results["transfer2D_EAd"]
transfer2D_EA = transfer2D_EAr + transfer2D_EAd
convP2D = dict_results["convP2D"]
convK2D = dict_results["convK2D"]
khE = self.oper.khE
PiCPE = cumsum_inv(transfer2D_CPE) * self.oper.deltak
PiEK = cumsum_inv(transfer2D_EK) * self.oper.deltak
PiEA = cumsum_inv(transfer2D_EA) * self.oper.deltak
PiEtot = PiEK + PiEA
CCP = cumsum_inv(convP2D) * self.oper.deltak
CCK = cumsum_inv(convK2D) * self.oper.deltak
self.axe_a.plot(khE + khE[1], PiEK, "r")
self.axe_a.plot(khE + khE[1], PiEA, "b")
self.axe_a.plot(khE + khE[1], PiEtot, "k", linewidth=2)
self.axe_a.plot(khE + khE[1], CCP, "y")
self.axe_a.plot(khE + khE[1], CCK, "y--")
self.axe_b.plot(khE + khE[1], PiCPE, "g")
def _online_plot_saving(self, dict_results):
transfer2D_E = dict_results["transfer2D_E"]
transfer2D_Z = dict_results["transfer2D_Z"]
khE = self.oper.khE
PiE = cumsum_inv(transfer2D_E) * self.oper.deltak
PiZ = cumsum_inv(transfer2D_Z) * self.oper.deltak
self.axe_a.plot(khE + khE[1], PiE, "k")
self.axe_b.plot(khE + khE[1], PiZ, "g")
def _online_plot_saving(self, dict_results):
transfer2D_CPE = dict_results["transfer2D_CPE"]
transfer2D_EK = dict_results["transfer2D_EK"]
transfer2D_EA = dict_results["transfer2D_EA"]
convA2D = dict_results["convA2D"]
khE = self.oper.khE
PiCPE = cumsum_inv(transfer2D_CPE) * self.oper.deltak
PiEK = cumsum_inv(transfer2D_EK) * self.oper.deltak
PiEA = cumsum_inv(transfer2D_EA) * self.oper.deltak
CCA = cumsum_inv(convA2D) * self.oper.deltak
self.axe_a.plot(khE + khE[1], PiEK, "r")
self.axe_a.plot(khE + khE[1], PiEA, "b")
self.axe_a.plot(khE + khE[1], CCA, "y")
self.axe_b.plot(khE + khE[1], PiCPE, "g")
def fig2_seb(path, fig=None, ax=None, t_start=None):
sim = fls.load_sim_for_plot(path, merge_missing_params=True)
path_file = os.path.join(path, "spect_energy_budg.h5")
f = h5py.File(path_file, "r")
k_f = _k_f(sim.params)
# eps = _eps(sim, t_start)
eps, E, ts, tmax = epsetstmax(path)
if t_start is None:
t_start = ts
imin_plot = _index_where(f["times"][...], t_start)
khE = (f["khE"][...] + 0.1) / k_f
transfers = 0
for key in ("Tq_AAA", "Tq_GAAs", "Tq_GAAd", "Tq_AGG", "Tq_GGG"):
transfers += f[key][imin_plot:].mean(0) / eps
Pi_tot = cumsum_inv(transfers) * sim.oper.deltak
print(eps)
ax.axhline(1.0, color="k", ls=":")
ax.set_xlabel("$k/k_f$")
ax.set_ylabel(r"$\Pi(k)/\epsilon$")
ax.set_xscale("log")
ax.set_yscale("linear")
ax.plot(khE, Pi_tot, "k", linewidth=2, label=r"$\Pi$")
ax.set_ylim([-0.1, 1.1])
def fig2_seb(path, fig=None, ax=None, t_start=None):
sim = fls.load_sim_for_plot(path, merge_missing_params=True)
path_file = os.path.join(path, "spect_energy_budg.h5")
f = h5py.File(path_file, "r")
k_f = _k_f(sim.params)
# eps = _eps(sim, t_start)
eps, E, ts, tmax = epsetstmax(path)
if t_start is None:
t_start = ts
imin_plot = _index_where(f["times"][...], t_start)
khE = (f["khE"][...] + 0.1) / k_f
transferEKr = f["transfer2D_EKr"][imin_plot:].mean(0) / eps
transferEKd = f["transfer2D_EKd"][imin_plot:].mean(0) / eps
transferEAr = f["transfer2D_EAr"][imin_plot:].mean(0) / eps
transferEAd = f["transfer2D_EAd"][imin_plot:].mean(0) / eps
# transferEPd = f['transfer2D_EPd'][imin_plot:].mean(0) / eps
PiEKr = cumsum_inv(transferEKr) * sim.oper.deltak
PiEKd = cumsum_inv(transferEKd) * sim.oper.deltak
PiEAr = cumsum_inv(transferEAr) * sim.oper.deltak
PiEAd = cumsum_inv(transferEAd) * sim.oper.deltak
# PiEPd = cumsum_inv(transferEPd) * sim.oper.deltak
print(eps)
ax.axhline(1.0, color="k", ls=":")
PiEK = PiEKr + PiEKd
PiEA = PiEAr + PiEAd
PiE = PiEK + PiEA
ax.set_xlabel("$k/k_f$")
ax.set_ylabel(r"$\Pi(k)/\epsilon$")
ax.set_xscale("log")
ax.set_yscale("linear")
ax.plot(khE, PiE, "k", linewidth=2, label=r"$\Pi$")
ax.plot(khE, PiEK, "r:", linewidth=2, label=r"$\Pi_K$")
ax.plot(khE, PiEA, "b--", linewidth=2, label=r"$\Pi_A$")
ax.set_ylim([-0.1, 1.1])
ax.legend()
def plot(self,
tmin=0,
tmax=None,
delta_t=2,
plot_diss_EK=False,
plot_conv=False):
"""Plot the energy budget."""
# Load data from file
with h5py.File(self.path_file, "r") as file:
times = file["times"][...]
kxE = file["kxE"][...]
kyE = file["kyE"][...]
dset_transferEK_kx = file["transferEK_kx"][...]
dset_transferEK_ky = file["transferEK_ky"][...]
dset_transferEA_kx = file["transferEA_kx"][...]
dset_transferEA_ky = file["transferEA_ky"][...]
dset_dissEK_kx = file["dissEK_kx"][...]
dset_dissEA_kx = file["dissEA_kx"][...]
dset_dissEK_ky = file["dissEK_ky"][...]
dset_dissEA_ky = file["dissEA_ky"][...]
if plot_conv:
dset_conv_kx = file["B_kx"][...]
dset_conv_ky = file["B_ky"][...]
if tmin is None:
tmin = 0
if tmax is None:
tmax = np.max(times)
# Average from tmin and tmax for plot
delta_t_save = np.mean(times[1:] - times[0:-1])
delta_i_plot = int(np.round(delta_t / delta_t_save))
if delta_i_plot == 0 and delta_t != 0.0:
delta_i_plot = 1
delta_t = delta_i_plot * delta_t_save
imin_plot = np.argmin(abs(times - tmin))
imax_plot = np.argmin(abs(times - tmax))
to_print = "plot(tmin={}, tmax={}, delta_t={:.2f})".format(
tmin, tmax, delta_t)
print(to_print)
tmin_plot = times[imin_plot]
tmax_plot = times[imax_plot]
print("""plot spectral energy budget
tmin = {:8.6g} ; tmax = {:8.6g} ; delta_t = {:8.6g}
imin = {:8d} ; imax = {:8d} ; delta_i = {:8d}""".format(
tmin_plot, tmax_plot, delta_t, imin_plot, imax_plot, delta_i_plot))
# Parameters of the figure
fig, ax1 = self.output.figure_axe()
ax1.set_xlabel("$k_x$")
ax1.set_ylabel(r"$\Pi$")
ax1.set_xscale("log")
ax1.set_yscale("linear")
ax1.set_title("Spectral energy budget, solver " +
self.output.name_solver + f", nh = {self.nx:5d}")
transferEK_kx = dset_transferEK_kx[imin_plot:imax_plot + 1].mean(0)
transferEA_kx = dset_transferEA_kx[imin_plot:imax_plot + 1].mean(0)
dissEK_kx = dset_dissEK_kx[imin_plot:imax_plot + 1].mean(0)
dissEA_kx = dset_dissEA_kx[imin_plot:imax_plot + 1].mean(0)
id_kx_dealiasing = np.argmin(kxE - self.sim.oper.kxmax_dealiasing) - 1
id_ky_dealiasing = np.argmin(kyE - self.sim.oper.kymax_dealiasing) - 1
transferEK_kx = transferEK_kx[:id_kx_dealiasing]
transferEA_kx = transferEA_kx[:id_kx_dealiasing]
dissEK_kx = dissEK_kx[:id_kx_dealiasing]
dissEA_kx = dissEA_kx[:id_kx_dealiasing]
kxE = kxE[:id_kx_dealiasing]
PiEK_kx = cumsum_inv(transferEK_kx[1:]) * self.oper.deltakx
PiEA_kx = cumsum_inv(transferEA_kx[1:]) * self.oper.deltakx
DissEK_kx = dissEK_kx[1:].cumsum() * self.oper.deltakx
DissEA_kx = dissEA_kx[1:].cumsum() * self.oper.deltakx
ax1.plot(kxE[1:], PiEK_kx + PiEA_kx, "k", label=r"$\Pi$")
ax1.plot(kxE[1:], PiEK_kx, "r", label=r"$\Pi_K$")
ax1.plot(kxE[1:], PiEA_kx, "b", label=r"$\Pi_A$")
ax1.plot(kxE[1:], DissEK_kx + DissEA_kx, "k--", label=r"$D$")
if plot_diss_EK:
ax1.plot(kxE[1:], DissEK_kx, "r--", label=r"$D_K$")
if plot_conv:
conv_kx = dset_conv_kx[imin_plot:imax_plot +
1].mean(0)[:id_kx_dealiasing]
conv_kx = cumsum_inv(conv_kx[1:]) * self.oper.deltakx
ax1.plot(kxE[1:], conv_kx, "c", label=r"$C$")
ax1.axhline(y=0, color="k", linestyle=":")
# Parameters of the figure
fig, ax2 = self.output.figure_axe()
ax2.set_xlabel("$k_z$")
ax2.set_ylabel(r"$\Pi$")
ax2.set_xscale("log")
ax2.set_yscale("linear")
ax2.set_title("Spectral energy budget, solver " +
self.output.name_solver + f", nh = {self.nx:5d}")
transferEK_ky = dset_transferEK_ky[imin_plot:imax_plot + 1].mean(0)
transferEA_ky = dset_transferEA_ky[imin_plot:imax_plot + 1].mean(0)
dissEK_ky = dset_dissEK_ky[imin_plot:imax_plot + 1].mean(0)
dissEA_ky = dset_dissEA_ky[imin_plot:imax_plot + 1].mean(0)
transferEK_ky = transferEK_ky[:id_ky_dealiasing]
transferEA_ky = transferEA_ky[:id_ky_dealiasing]
dissEK_ky = dissEK_ky[:id_ky_dealiasing]
dissEA_ky = dissEA_ky[:id_ky_dealiasing]
kyE = kyE[:id_ky_dealiasing]
PiEK_ky = cumsum_inv(transferEK_ky[1:]) * self.oper.deltaky
PiEA_ky = cumsum_inv(transferEA_ky[1:]) * self.oper.deltaky
DissEK_ky = dissEK_ky[1:].cumsum() * self.oper.deltaky
DissEA_ky = dissEA_ky[1:].cumsum() * self.oper.deltaky
ax2.plot(kyE[1:], PiEK_ky + PiEA_ky, "k", label=r"$\Pi$")
ax2.plot(kyE[1:], PiEK_ky, "r", label=r"$\Pi_K$")
ax2.plot(kyE[1:], PiEA_ky, "b", label=r"$\Pi_A$")
ax2.plot(kyE[1:], DissEK_ky + DissEA_ky, "k--", label=r"$D$")
if plot_diss_EK:
ax2.plot(kyE[1:], DissEK_ky, "r--", label=r"$D_K$")
if plot_conv:
conv_ky = dset_conv_ky[imin_plot:imax_plot +
1].mean(0)[:id_ky_dealiasing]
conv_ky = cumsum_inv(conv_ky[1:]) * self.oper.deltaky
ax2.plot(kyE[1:], conv_ky, "c", label=r"$C$")
ax2.axhline(y=0, color="k", linestyle=":")
# Plot forcing wave-number k_f
nkmax = self.sim.params.forcing.nkmax_forcing
nkmin = self.sim.params.forcing.nkmin_forcing
k_f = ((nkmax + nkmin) / 2) * self.sim.oper.deltak
pforcing = self.sim.params.forcing
if pforcing.enable and pforcing.type == "tcrandom_anisotropic":
angle = pforcing.tcrandom_anisotropic.angle
try:
if angle.endswith("°"):
angle = np.pi / 180 * float(angle[:-1])
except AttributeError:
pass
k_fx = np.sin(angle) * k_f
k_fy = np.cos(angle) * k_f
# ax1.axvline(x=k_fx, color="y", linestyle="-.", label="$k_{f,x}$")
# ax2.axvline(x=k_fy, color="y", linestyle="-.", label="$k_{f,z}$")
# Band forcing region kx
k_fxmin = nkmin * self.sim.oper.deltak * np.sin(angle)
k_fxmax = nkmax * self.sim.oper.deltak * np.sin(angle)
# Band forcing region ky
k_fymin = nkmin * self.sim.oper.deltak * np.cos(angle)
k_fymax = nkmax * self.sim.oper.deltak * np.cos(angle)
ax1.axvspan(k_fxmin, k_fxmax, alpha=0.15, color="black")
ax2.axvspan(k_fymin, k_fymax, alpha=0.15, color="black")
# Compute k_b: L_b = U / N
U = np.sqrt(np.mean(abs(self.sim.state.get_var("ux"))**2))
k_b = self.sim.params.N / U
ax1.axvline(x=k_b, color="y", linestyle="--", label="$k_b$")
ax2.axvline(x=k_b, color="y", linestyle="--", label="$k_b$")
ax1.legend()
ax2.legend()
def plot(self, tmin=0, tmax=1000, delta_t=2):
with h5py.File(self.path_file, "r") as h5file:
dset_times = h5file["times"]
times = dset_times[...]
# nt = len(times)
dset_khE = h5file["khE"]
khE = dset_khE[...]
dset_transfer2D_EKr = h5file["transfer2D_EKr"]
dset_transfer2D_EKd = h5file["transfer2D_EKd"]
dset_transfer2D_EAr = h5file["transfer2D_EAr"]
dset_transfer2D_EAd = h5file["transfer2D_EAd"]
dset_transfer2D_EPd = h5file["transfer2D_EPd"]
dset_convP2D = h5file["convP2D"]
dset_convK2D = h5file["convK2D"]
dset_transfer2D_CPE = h5file["transfer2D_CPE"]
delta_t_save = np.mean(times[1:] - times[0:-1])
delta_i_plot = int(np.round(delta_t / delta_t_save))
if delta_i_plot == 0 and delta_t != 0.0:
delta_i_plot = 1
delta_t = delta_i_plot * delta_t_save
imin_plot = np.argmin(abs(times - tmin))
imax_plot = np.argmin(abs(times - tmax))
tmin_plot = times[imin_plot]
tmax_plot = times[imax_plot]
to_print = "plot(tmin={}, tmax={}, delta_t={:.2f})".format(
tmin, tmax, delta_t)
print(to_print)
to_print = """plot fluxes 2D
tmin = {:8.6g} ; tmax = {:8.6g} ; delta_t = {:8.6g}
imin = {:8d} ; imax = {:8d} ; delta_i = {:8d}""".format(
tmin_plot, tmax_plot, delta_t, imin_plot, imax_plot,
delta_i_plot)
print(to_print)
x_left_axe = 0.12
z_bottom_axe = 0.36
width_axe = 0.85
height_axe = 0.57
size_axe = [x_left_axe, z_bottom_axe, width_axe, height_axe]
fig, ax1 = self.output.figure_axe(size_axe=size_axe)
ax1.set_xlabel("$k_h$")
ax1.set_ylabel("transfers")
title = (
"energy flux, solver " + self.output.name_solver +
f", nh = {self.nx:5d}" +
", c = {:.4g}, f = {:.4g}".format(np.sqrt(self.c2), self.f))
ax1.set_title(title)
ax1.set_xscale("log")
ax1.set_yscale("linear")
khE = khE + 1
if delta_t != 0.0:
for it in range(imin_plot, imax_plot, delta_i_plot):
transferEKr = dset_transfer2D_EKr[it]
transferEAr = dset_transfer2D_EAr[it]
PiEKr = cumsum_inv(transferEKr) * self.oper.deltak
PiEAr = cumsum_inv(transferEAr) * self.oper.deltak
PiE = PiEKr + PiEAr
ax1.plot(khE, PiE, "k", linewidth=1)
convK = dset_convK2D[it]
CCK = cumsum_inv(convK) * self.oper.deltak
ax1.plot(khE, CCK, "y", linewidth=1)
convP = dset_convP2D[it]
CCP = cumsum_inv(convP) * self.oper.deltak
ax1.plot(khE, CCP, "y--", linewidth=1)
# print(convK.sum()*self.oper.deltak,
# convP.sum()*self.oper.deltak,
# CCP[0], CCK[0])
transferEKr = dset_transfer2D_EKr[imin_plot:imax_plot].mean(0)
transferEKd = dset_transfer2D_EKd[imin_plot:imax_plot].mean(0)
transferEAr = dset_transfer2D_EAr[imin_plot:imax_plot].mean(0)
transferEAd = dset_transfer2D_EAd[imin_plot:imax_plot].mean(0)
transferEPd = dset_transfer2D_EPd[imin_plot:imax_plot].mean(0)
PiEKr = cumsum_inv(transferEKr) * self.oper.deltak
PiEKd = cumsum_inv(transferEKd) * self.oper.deltak
PiEAr = cumsum_inv(transferEAr) * self.oper.deltak
PiEAd = cumsum_inv(transferEAd) * self.oper.deltak
PiEPd = cumsum_inv(transferEPd) * self.oper.deltak
PiEK = PiEKr + PiEKd
PiEA = PiEAr + PiEAd
PiE = PiEK + PiEA
ax1.plot(khE, PiE, "k", linewidth=2)
ax1.plot(khE, PiEK, "r", linewidth=2)
ax1.plot(khE, PiEA, "b", linewidth=2)
ax1.plot(khE, PiEKr, "r--", linewidth=2)
ax1.plot(khE, PiEKd, "r:", linewidth=2)
ax1.plot(khE, PiEAr, "b--", linewidth=2)
ax1.plot(khE, PiEAd, "b:", linewidth=2)
ax1.plot(khE, PiEPd, "c:", linewidth=1)
convP = dset_convP2D[imin_plot:imax_plot].mean(0)
convK = dset_convK2D[imin_plot:imax_plot].mean(0)
CCP = cumsum_inv(convP) * self.oper.deltak
CCK = cumsum_inv(convK) * self.oper.deltak
ax1.plot(khE, CCP, "y--", linewidth=2)
ax1.plot(khE, CCK, "y", linewidth=2)
# print(convK.sum()*self.oper.deltak,
# convP.sum()*self.oper.deltak,
# CCP[0], CCK[0],
# CCP[1], CCK[1]
# )
dset_transfer2D_Errr = h5file["transfer2D_Errr"]
dset_transfer2D_Edrd = h5file["transfer2D_Edrd"]
dset_transfer2D_Edrr_rrd = h5file["transfer2D_Edrr_rrd"]
transferEdrr_rrd = dset_transfer2D_Edrr_rrd[
imin_plot:imax_plot].mean(0)
transferErrr = dset_transfer2D_Errr[imin_plot:imax_plot].mean(0)
transferEdrd = dset_transfer2D_Edrd[imin_plot:imax_plot].mean(0)
Pi_drr_rrd = cumsum_inv(transferEdrr_rrd) * self.oper.deltak
Pi_rrr = cumsum_inv(transferErrr) * self.oper.deltak
Pi_drd = cumsum_inv(transferEdrd) * self.oper.deltak
ax1.plot(khE, Pi_drr_rrd, "m:", linewidth=1)
ax1.plot(khE, Pi_rrr, "m--", linewidth=1)
ax1.plot(khE, Pi_drd, "m-.", linewidth=1)
dset_transfer2D_Eddd = h5file["transfer2D_Eddd"]
dset_transfer2D_Erdr = h5file["transfer2D_Erdr"]
dset_transfer2D_Eddr_rdd = h5file["transfer2D_Eddr_rdd"]
dset_transfer2D_Eudeu = h5file["transfer2D_Eudeu"]
transferEddr_rdd = dset_transfer2D_Eddr_rdd[
imin_plot:imax_plot].mean(0)
transferEddd = dset_transfer2D_Eddd[imin_plot:imax_plot].mean(0)
transferErdr = dset_transfer2D_Erdr[imin_plot:imax_plot].mean(0)
transferEudeu = dset_transfer2D_Eudeu[imin_plot:imax_plot].mean(0)
Pi_ddr_rdd = cumsum_inv(transferEddr_rdd) * self.oper.deltak
Pi_ddd = cumsum_inv(transferEddd) * self.oper.deltak
Pi_rdr = cumsum_inv(transferErdr) * self.oper.deltak
Pi_udeu = cumsum_inv(transferEudeu) * self.oper.deltak
ax1.plot(khE, Pi_ddr_rdd, "c:", linewidth=1)
ax1.plot(khE, Pi_ddd, "c--", linewidth=1)
ax1.plot(khE, Pi_rdr, "c-.", linewidth=1)
ax1.plot(khE, Pi_udeu, "g", linewidth=1)
z_bottom_axe = 0.07
height_axe = 0.17
size_axe[1] = z_bottom_axe
size_axe[3] = height_axe
ax2 = fig.add_axes(size_axe)
ax2.set_xlabel("$k_h$")
ax2.set_ylabel("transfers")
title = "Charney PE flux"
ax2.set_title(title)
ax2.set_xscale("log")
ax2.set_yscale("linear")
if delta_t != 0.0:
for it in range(imin_plot, imax_plot + 1, delta_i_plot):
transferCPE = dset_transfer2D_CPE[it]
PiCPE = cumsum_inv(transferCPE) * self.oper.deltak
ax2.plot(khE, PiCPE, "g", linewidth=1)
transferCPE = dset_transfer2D_CPE[imin_plot:imax_plot].mean(0)
PiCPE = cumsum_inv(transferCPE) * self.oper.deltak
ax2.plot(khE, PiCPE, "m", linewidth=2)
def plot(self, tmin=0, tmax=1000, delta_t=2):
with h5py.File(self.path_file, "r") as h5file:
dset_times = h5file["times"]
dset_khE = h5file["khE"]
khE = dset_khE[...]
khE = khE + khE[1]
dset_transferE = h5file["transfer2D_E"]
dset_transferZ = h5file["transfer2D_Z"]
# nb_spectra = dset_times.shape[0]
times = dset_times[...]
# nt = len(times)
delta_t_save = np.mean(times[1:] - times[0:-1])
delta_i_plot = int(np.round(delta_t / delta_t_save))
if delta_i_plot == 0 and delta_t != 0.0:
delta_i_plot = 1
delta_t = delta_i_plot * delta_t_save
imin_plot = np.argmin(abs(times - tmin))
imax_plot = np.argmin(abs(times - tmax))
to_print = "plot(tmin={}, tmax={}, delta_t={:.2f})".format(
tmin, tmax, delta_t)
print(to_print)
tmin_plot = times[imin_plot]
tmax_plot = times[imax_plot]
print("""plot spectral energy budget
tmin = {:8.6g} ; tmax = {:8.6g} ; delta_t = {:8.6g}
imin = {:8d} ; imax = {:8d} ; delta_i = {:8d}""".format(
tmin_plot,
tmax_plot,
delta_t,
imin_plot,
imax_plot,
delta_i_plot,
))
fig, ax1 = self.output.figure_axe()
ax1.set_xlabel("$k_h$")
ax1.set_ylabel("spectra")
ax1.set_xscale("log")
ax1.set_yscale("linear")
if delta_t != 0.0:
for it in range(imin_plot, imax_plot, delta_i_plot):
transferE = dset_transferE[it]
transferZ = dset_transferZ[it]
PiE = cumsum_inv(transferE) * self.oper.deltak
PiZ = cumsum_inv(transferZ) * self.oper.deltak
ax1.plot(khE, PiE, "k", linewidth=1)
ax1.plot(khE, PiZ, "g", linewidth=1)
transferE = dset_transferE[imin_plot:imax_plot].mean(0)
transferZ = dset_transferZ[imin_plot:imax_plot].mean(0)
PiE = cumsum_inv(transferE) * self.oper.deltak
PiZ = cumsum_inv(transferZ) * self.oper.deltak
ax1.plot(khE, PiE, "r", linewidth=2)
ax1.plot(khE, PiZ, "m", linewidth=2)
def plot(self, tmin=0, tmax=1000, delta_t=2):
with h5py.File(self.path_file, "r") as h5file:
dset_times = h5file["times"]
dset_khE = h5file["khE"]
khE = dset_khE[...] + 0.1 # Offset for semilog plots
times = dset_times[...]
delta_t_save = np.mean(times[1:] - times[0:-1])
delta_i_plot = int(np.round(delta_t / delta_t_save))
if delta_i_plot == 0 and delta_t != 0.0:
delta_i_plot = 1
delta_t = delta_i_plot * delta_t_save
imin_plot = np.argmin(abs(times - tmin))
imax_plot = np.argmin(abs(times - tmax))
tmin_plot = times[imin_plot]
tmax_plot = times[imax_plot]
to_print = "plot(tmin={}, tmax={}, delta_t={:.2f})".format(
tmin, tmax, delta_t)
print(to_print)
to_print = "plot fluxes 2D" + (
", tmin = {0:8.6g} ; tmax = {1:8.6g} ; delta_t = {2:8.6g}" +
", imin = {3:8d} ; imax = {4:8d} ; delta_i = {5:8d}").format(
tmin_plot, tmax_plot, delta_t, imin_plot, imax_plot,
delta_i_plot)
print(to_print)
# -------------------------
# Transfer terms
# -------------------------
x_left_axe = 0.12
z_bottom_axe = 0.46
width_axe = 0.85
height_axe = 0.47
size_axe = [x_left_axe, z_bottom_axe, width_axe, height_axe]
fig1, ax1 = self.output.figure_axe(size_axe=size_axe)
fig2, ax2 = self.output.figure_axe(size_axe=size_axe)
ax1.set_xlabel("$k_h$")
ax1.set_ylabel(r"Transfer fluxes, $\Pi(k_h)$")
z_bottom_axe = 0.07
height_axe = 0.27
size_axe[1] = z_bottom_axe
size_axe[3] = height_axe
ax11 = fig1.add_axes(size_axe)
ax11.set_xlabel("$k_h$")
ax11.set_ylabel("Transfer terms, $T(k_h)$")
title = (
"Spectral Energy Budget, solver " + self.output.name_solver +
f", nh = {self.nx:5d}" +
", c = {:.4g}, f = {:.4g}".format(np.sqrt(self.c2), self.f))
ax1.set_title(title)
ax1.set_xscale("log")
ax1.axhline()
ax11.set_title(title)
ax11.set_xscale("log")
ax11.axhline()
P = self.sim.params.forcing.forcing_rate
norm = 1 if P == 0 else P
if delta_t != 0.0:
for it in range(imin_plot, imax_plot, delta_i_plot):
transferEtot = 0.0
for key in ["GGG", "AGG", "GAAs", "GAAd", "AAA"]:
transferEtot += h5file["Tq_" + key][it]
PiEtot = cumsum_inv(transferEtot) * self.oper.deltak / norm
ax1.plot(khE, PiEtot, "k", linewidth=1)
Tq_GGG = h5file["Tq_GGG"][imin_plot:imax_plot].mean(0) / norm
Tq_AGG = h5file["Tq_AGG"][imin_plot:imax_plot].mean(0) / norm
Tq_GAAs = h5file["Tq_GAAs"][imin_plot:imax_plot].mean(0) / norm
Tq_GAAd = h5file["Tq_GAAd"][imin_plot:imax_plot].mean(0) / norm
Tq_AAA = h5file["Tq_AAA"][imin_plot:imax_plot].mean(0) / norm
Tnq = h5file["Tnq"][imin_plot:imax_plot].mean(0) / norm
Tens = h5file["Tens"][imin_plot:imax_plot].mean(0) / norm
Tq_tot = Tq_GGG + Tq_AGG + Tq_GAAs + Tq_GAAd + Tq_AAA
Pi_GGG = cumsum_inv(Tq_GGG) * self.oper.deltak
Pi_AGG = cumsum_inv(Tq_AGG) * self.oper.deltak
Pi_GAAs = cumsum_inv(Tq_GAAs) * self.oper.deltak
Pi_GAAd = cumsum_inv(Tq_GAAd) * self.oper.deltak
Pi_AAA = cumsum_inv(Tq_AAA) * self.oper.deltak
Pi_nq = cumsum_inv(Tnq) * self.oper.deltak
Pi_ens = cumsum_inv(Tens) * self.oper.deltak
Pi_tot = Pi_GGG + Pi_AGG + Pi_GAAs + Pi_GAAd + Pi_AAA
ax1.plot(khE, Pi_GGG, "g--", linewidth=2, label=r"$\Pi_{GGG}$")
ax1.plot(khE, Pi_AGG, "m--", linewidth=2, label=r"$\Pi_{GGA}$")
# ax1.plot(khE, Pi_GAAs, 'r:', linewidth=2, label=r'$\Pi_{G\pm\pm}$')
# ax1.plot(khE, Pi_GAAd, 'b:', linewidth=2, label=r'$\Pi_{G\pm\mp}$')
ax1.plot(khE,
Pi_GAAs + Pi_GAAd,
"r",
linewidth=2,
label=r"$\Pi_{GAA}$")
ax1.plot(khE, Pi_AAA, "y--", linewidth=2, label=r"$\Pi_{AAA}$")
ax1.plot(khE, Pi_nq, "k--", linewidth=1, label=r"$\Pi^{NQ}$")
ax1.plot(khE, Pi_tot, "k", linewidth=3, label=r"$\Pi_{tot}$")
ax1.legend()
ax11.plot(khE, Tq_GGG, "g--", linewidth=2, label=r"$T_{GGG}$")
ax11.plot(khE, Tq_AGG, "m--", linewidth=2, label=r"$T_{GGA}$")
ax11.plot(khE, Tq_GAAs, "r:", linewidth=2, label=r"$T_{G\pm\pm}$")
ax11.plot(khE, Tq_GAAd, "b:", linewidth=2, label=r"$T_{G\pm\mp}$")
ax11.plot(khE, Tq_AAA, "y--", linewidth=2, label=r"$T_{AAA}$")
ax11.plot(khE, Tnq, "k--", linewidth=2, label=r"$T^{NQ}$")
ax11.plot(khE, Tq_tot, "k", linewidth=3, label=r"$T_{tot}$")
ax11.legend()
# -------------------------
# Quadratic exchange terms
# -------------------------
ax2.set_xlabel(r"$k_h$")
ax2.set_ylabel(r"Exchange fluxes, $\Sigma C$")
ax2.set_xscale("log")
ax2.axhline()
# .. TODO: Normalize with energy??
exchange_GG = h5file["Cq_GG"][imin_plot:imax_plot].mean(0)
exchange_AG = h5file["Cq_AG"][imin_plot:imax_plot].mean(
0) + h5file["Cq_aG"][imin_plot:imax_plot].mean(0)
exchange_AA = h5file["Cq_AA"][imin_plot:imax_plot].mean(0)
exchange_mean = exchange_GG + exchange_AG + exchange_AA
Cflux_GG = cumsum_inv(exchange_GG) * self.oper.deltak
Cflux_AG = cumsum_inv(exchange_AG) * self.oper.deltak
Cflux_AA = cumsum_inv(exchange_AA) * self.oper.deltak
Cflux_mean = cumsum_inv(exchange_mean) * self.oper.deltak
if delta_t != 0.0:
for it in range(imin_plot, imax_plot, delta_i_plot):
exchangetot = 0.0
for key in ["GG", "AG", "aG", "AA"]:
exchangetot += h5file["Cq_" + key][it]
Cfluxtot = cumsum_inv(exchangetot) * self.oper.deltak
ax2.plot(khE, Cfluxtot, "k", linewidth=1)
ax2.plot(khE, Cflux_mean, "k", linewidth=4, label=r"$\Sigma C_{tot}$")
ax2.plot(khE, Cflux_GG, "g:", linewidth=2, label=r"$\Sigma C_{GG}$")
ax2.plot(khE, Cflux_AG, "m--", linewidth=2, label=r"$\Sigma C_{GA}$")
ax2.plot(khE, Cflux_AA, "y--", linewidth=2, label=r"$\Sigma C_{AA}$")
ax2.legend()
ax22 = fig2.add_axes(size_axe)
ax22.set_xscale("log")
ax22.axhline()
ax22.set_xlabel(r"$k_h$")
ax22.set_ylabel(r"$\Pi_{ens}(k_h)$")
ax22.plot(khE, Pi_ens, "g", linewidth=3, label=r"$\Pi_{ens}$")
ax22.legend()
fig1.canvas.draw()
fig2.canvas.draw()
def _online_plot_saving(self, dict_results):
# Tens = dict_results["Tens"]
Tq_GGG = dict_results["Tq_GGG"]
Tq_AGG = dict_results["Tq_AGG"]
Tq_GAAs = dict_results["Tq_GAAs"]
Tq_GAAd = dict_results["Tq_GAAd"]
Tq_AAA = dict_results["Tq_AAA"]
Tq_tot = Tq_GGG + Tq_AGG + Tq_GAAs + Tq_GAAd + Tq_AAA
Cq_GG = dict_results["Cq_GG"]
Cq_AG = dict_results["Cq_AG"] + dict_results["Cq_aG"]
Cq_AA = dict_results["Cq_AA"]
Cq_tot = Cq_GG + Cq_AG + Cq_AA
khE = self.oper.khE
# Piens = cumsum_inv(Tens) * self.oper.deltak
Pi_tot = cumsum_inv(Tq_tot) * self.oper.deltak
Pi_GGG = cumsum_inv(Tq_GGG) * self.oper.deltak
Pi_AGG = cumsum_inv(Tq_AGG) * self.oper.deltak
Pi_GAAs = cumsum_inv(Tq_GAAs) * self.oper.deltak
Pi_GAAd = cumsum_inv(Tq_GAAd) * self.oper.deltak
Pi_AAA = cumsum_inv(Tq_AAA) * self.oper.deltak
Cflux_tot = cumsum_inv(Cq_tot) * self.oper.deltak
Cflux_GG = cumsum_inv(Cq_GG) * self.oper.deltak
Cflux_AG = cumsum_inv(Cq_AG) * self.oper.deltak
Cflux_AA = cumsum_inv(Cq_AA) * self.oper.deltak
self.axe_a.plot(khE + khE[1],
Pi_tot,
"k",
linewidth=2,
label=r"$\Pi_{tot}$")
self.axe_a.plot(khE + khE[1],
Pi_GGG,
"g--",
linewidth=1,
label=r"$\Pi_{GGG}$")
# self.axe_a.plot(
# khE+khE[1], Piens, 'g:', linewidth=1, label=r'$\Pi_{ens}$')
self.axe_a.plot(khE + khE[1],
Pi_AGG,
"m--",
linewidth=1,
label=r"$\Pi_{GGA}$")
self.axe_a.plot(khE + khE[1],
Pi_GAAs,
"r:",
linewidth=1,
label=r"$\Pi_{G\pm\pm}$")
self.axe_a.plot(khE + khE[1],
Pi_GAAd,
"b:",
linewidth=1,
label=r"$\Pi_{G\pm\mp}$")
self.axe_a.plot(khE + khE[1],
Pi_AAA,
"y--",
linewidth=1,
label=r"$\Pi_{AAA}$")
self.axe_b.plot(khE + khE[1],
Cflux_tot,
"k",
linewidth=2,
label=r"$\Sigma C_{tot}$")
self.axe_b.plot(khE + khE[1],
Cflux_GG,
"g:",
linewidth=1,
label=r"$\Sigma C_{GG}$")
self.axe_b.plot(khE + khE[1],
Cflux_AG,
"m--",
linewidth=1,
label=r"$\Sigma C_{GA}$")
self.axe_b.plot(khE + khE[1],
Cflux_AA,
"y--",
linewidth=1,
label=r"$\Sigma C_{AA}$")
if self.nb_saved_times == 2:
title = (
"Spectral Energy Budget, solver " + self.output.name_solver +
f", nh = {self.nx:5d}" +
", c = {:.4g}, f = {:.4g}".format(np.sqrt(self.c2), self.f))
self.axe_a.set_title(title)
self.axe_a.legend()
self.axe_b.legend()
self.axe_b.set_ylabel(r"$\Sigma C(k_h)$")
