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)$")