111 lines
3 KiB
Python
111 lines
3 KiB
Python
import argparse
|
|
import configparser
|
|
import logging
|
|
import pathlib
|
|
|
|
import matplotlib.pyplot as plt
|
|
import numpy as np
|
|
import pandas as pd
|
|
import scipy.signal as sgl
|
|
import scipy.fft as fft
|
|
|
|
from .read_swash import *
|
|
|
|
parser = argparse.ArgumentParser(description="Post-process swash output")
|
|
parser.add_argument("-v", "--verbose", action="count", default=0)
|
|
args = parser.parse_args()
|
|
|
|
logging.basicConfig(level=max((10, 20 - 10 * args.verbose)))
|
|
log = logging.getLogger("post")
|
|
|
|
log.info("Starting post-processing")
|
|
config = configparser.ConfigParser()
|
|
config.read("config.ini")
|
|
|
|
inp = pathlib.Path(config.get("post", "inp"))
|
|
root = pathlib.Path(config.get("swash", "out"))
|
|
|
|
log.info(f"Reading bathymetry from '{inp}'")
|
|
data = np.load(inp.joinpath(config.get("post", "case")))
|
|
x, t = data["x"], data["t"]
|
|
|
|
# Cospectral calculations
|
|
x0 = config.getint("post", "x0")
|
|
arg_x0 = np.abs(x - x0).argmin()
|
|
t0 = config.getfloat("post", "t0")
|
|
arg_t0 = np.abs(t - t0).argmin()
|
|
dt = config.getfloat("post", "dt")
|
|
f = 1 / dt
|
|
nperseg = config.getint("post", "nperseg", fallback=None)
|
|
log.info(f"Computing reflection coefficient at x={x0}")
|
|
|
|
eta = data["watl"][t > t0, arg_x0]
|
|
u = data["vel"][t > t0, 0, arg_x0]
|
|
|
|
phi_eta = np.abs(sgl.welch(eta, f, nperseg=nperseg))
|
|
phi_u = np.abs(sgl.welch(u, f, nperseg=nperseg))
|
|
phi_eta_u = np.abs(sgl.csd(eta, u, f, nperseg=nperseg))
|
|
|
|
R = np.sqrt(
|
|
(phi_eta[1] + phi_u[1] - 2 * phi_eta_u[1])
|
|
/ (phi_eta[1] + phi_u[1] + 2 * phi_eta_u[1])
|
|
)
|
|
|
|
# Plotting
|
|
log.info("Plotting results")
|
|
fig, (ax_watl, ax_vel) = plt.subplots(2)
|
|
|
|
ax_watl.plot(t, data["watl"][:, arg_x0], lw=1, label="watl")
|
|
ax_watl.set(xlabel="t (s)", ylabel="z (m)")
|
|
ax_watl.autoscale(axis="x", tight=True)
|
|
ax_watl.grid()
|
|
ax_watl.axvline(t0, c="k", alpha=0.2)
|
|
|
|
ax_vel.plot(t, data["vel"][:, 0, arg_x0], lw=1, label="vel")
|
|
ax_vel.set(xlabel="t (s)", ylabel="U (m/s)")
|
|
ax_vel.autoscale(axis="x", tight=True)
|
|
ax_vel.grid()
|
|
ax_vel.axvline(t0, c="k", alpha=0.2)
|
|
|
|
fig.tight_layout()
|
|
|
|
fig_r, ax_r = plt.subplots()
|
|
ax_fft = ax_r.twinx()
|
|
|
|
ax_fft.plot(
|
|
*sgl.welch(eta, 1/dt, nperseg=nperseg),
|
|
lw=1,
|
|
c="k",
|
|
alpha=0.2,
|
|
label="PSD ($\\eta$)",
|
|
)
|
|
ax_r.plot(phi_eta[0], R, marker="+", label="R")
|
|
ax_r.set(xlim=(0, 0.3), ylim=(0, 1), xlabel="f (Hz)", ylabel="R")
|
|
ax_fft.set(ylim=0, ylabel="PSD (m²/Hz)")
|
|
ax_r.grid()
|
|
ax_r.legend(loc="upper left")
|
|
ax_fft.legend(loc="upper right")
|
|
fig_r.tight_layout()
|
|
|
|
fig_x, ax_x = plt.subplots(figsize=(10, 1))
|
|
ax_x.plot(data["x"], -data["botl"], color="k")
|
|
ax_x.fill_between(
|
|
data["x"],
|
|
-data["botl"],
|
|
np.maximum(data["watl"][arg_t0, :], -data["botl"]),
|
|
)
|
|
ax_x.axvline(x0, c="k", alpha=0.2)
|
|
ax_x.set(xlabel="x (m)", ylabel="z (m)")
|
|
ax_x.autoscale(axis="x", tight=True)
|
|
ax_x.set(aspect="equal")
|
|
fig_x.tight_layout()
|
|
|
|
out = pathlib.Path(config.get("post", "out")).joinpath(f"t{t0}x{x0}")
|
|
log.info(f"Saving plots in '{out}'")
|
|
out.mkdir(parents=True, exist_ok=True)
|
|
|
|
fig.savefig(out.joinpath("t.png"))
|
|
fig_r.savefig(out.joinpath("R.png"))
|
|
fig_x.savefig(out.joinpath("x.png"))
|
|
|
|
log.info("Finished post-processing")
|