New olaflow run processus, includeing paddle boundary condition

olaflow/processing/run_ola.py

@@ -0,0 +1,47 @@
+import argparse
+import configparser
+import logging
+import os
+import pathlib
+import shutil
+from subprocess import run, STDOUT
+
+parser = argparse.ArgumentParser(description="Run olaFlow model")
+parser.add_argument("-v", "--verbose", action="count", default=0)
+parser.add_argument("-c", "--config", default="config.ini")
+args = parser.parse_args()
+
+logging.basicConfig(level=max((10, 20 - 10 * args.verbose)))
+log = logging.getLogger("sws_ola")
+
+log.info("Starting olaFlow model")
+config = configparser.ConfigParser()
+config.read(args.config)
+
+root = pathlib.Path(config.get("olaflow", "root"))
+out = pathlib.Path(config.get("olaflow", "out"))
+logs = out.joinpath("log")
+
+shutil.copytree(root, out)
+logs.mkdir()
+
+path = config.get("olaflow", "path")
+env = {"PATH": f"{path}:{os.environ['PATH']}"}
+
+def ola_run(cmd):
+    with logs.joinpath(f"{cmd[0]}.log").open("wt") as logfile:
+        run(
+            cmd,
+            cwd=out,
+            env=env,
+            stdout=logfile,
+            stderr=STDOUT,
+        ).check_returncode()
+
+ola_run(("blockMesh",))
+ola_run(("snappyHexMesh", "-overwrite"))
+shutil.copytree(root.joinpath("0.org"), root.joinpath("0"))
+ola_run(("setFields",))
+ola_run(("decomposePar",))
+ola_run(("mpirun", "-np", "4", "olaFlow", "-parallel"))
+ola_run(("reconstructPar",))

olaflow/processing/sws_ola.py

@@ -12,6 +12,7 @@ from .olaflow import OFModel
 parser = argparse.ArgumentParser(description="Convert swash output to olaFlow input")
 parser.add_argument("-v", "--verbose", action="count", default=0)
 parser.add_argument("-c", "--config", default="config.ini")
+parser.add_argument("-o", "--output", type=pathlib.Path)
 args = parser.parse_args()
 
 logging.basicConfig(level=max((10, 20 - 10 * args.verbose)))
@@ -28,35 +29,36 @@ def data(var):
     return np.load(sws_out.joinpath(f"{var}.npy"))
 
 
+t0 = config.getfloat("olaflow", "t0")
 x = data("x")
 t = data("t")
 
+arg_t0 = np.argmin(np.abs(t - t0*1e3))
+
 watl = data("watl")
 zk = data("zk")
 velk, _ = data("velk")
 vz = data("vz")
 
-olaflow_root = pathlib.Path(config.get("olaflow", "root"))
+olaflow_root = args.output
 model = OFModel(olaflow_root)
 model.read_mesh()
 
-watl_t = interpolate.interp1d(x, watl[680])
+watl_t = interpolate.interp1d(x, watl[arg_t0] + config.getfloat("bathy", "level", fallback=0.))
 alpha_water = np.where(model.z < watl_t(model.x), 1, 0)
 
-zk_t = interpolate.interp1d(x, zk[680])
-velk_t = interpolate.interp1d(x, velk[680, :, :])(model.x)
-vz_t = interpolate.interp1d(x, vz[680])(model.x)
+zk_t = interpolate.interp1d(x, zk[arg_t0])
+velk_t = interpolate.interp1d(x, velk[arg_t0, :, :])(model.x)
+vz_t = interpolate.interp1d(x, vz[arg_t0])(model.x)
 zk_tl = zk_t(model.x)
 
-print(velk.shape)
 ux = np.zeros(model.x.shape)
 uy = np.zeros(model.x.shape)
 uz = np.zeros(model.x.shape)
-print(zk_tl.shape, velk.shape, vz.shape)
 for zk_l, velk_l, vz_l in zip(zk_tl, velk_t, vz_t):
     ux = np.where(model.z < zk_l, velk_l, ux)
     uz = np.where(model.z < zk_l, vz_l, uz)
 
-print(np.stack((ux, uy, uz)).T)
 model.write_field("alpha.water", alpha_water)
 model.write_vector_field("U", np.stack((ux, uy, uz)).T)
+plt.savefig("test.pdf")

olaflow/processing/sws_wavedict_irregular.py

@@ -19,6 +19,7 @@ logging.basicConfig(level=max((10, 20 - 10 * args.verbose)))
 log = logging.getLogger("sws_ola")
 
 log.info("Starting sws -> olaFlow converter")
+log.warning("This does not provide the correct boundary condition")
 config = configparser.ConfigParser()
 config.read(args.config)
 
@@ -30,22 +31,22 @@ def data(var):
 
 
 x = data("x")
-t = data("t")
+t = data("t")[-100:]
 
 watl = data("watl")
 
 arg_x0 = np.argmin(np.abs(x + 1250))
 
-wl = watl[:, arg_x0]
+wl = watl[-100:, arg_x0]
 
 f = fft.rfftfreq(t.size, np.diff(t).mean())[1:]
-w_fft = fft.rfft(wl)[1:]
+w_fft = fft.rfft(wl, norm="forward")[1:]
 amp = np.abs(w_fft)
 phi = np.angle(w_fft)
 
 olaflow_root = pathlib.Path(config.get("olaflow", "root"))
-org = olaflow_root.joinpath("constant", "waveDict.org").read_text()
-org = org.replace("{n}", str(t.size))
+org = olaflow_root.joinpath("constant", "waveDict_irregular.org").read_text()
+org = org.replace("{n}", str(f.size))
 org = org.replace("{wh}", "\n".join(amp.astype(np.str_)))
 org = org.replace("{wph}", "\n".join(phi.astype(np.str_)))
 org = org.replace("{wper}", "\n".join((1 / f).astype(np.str_)))

olaflow/processing/sws_wavedict_paddle.py

@@ -0,0 +1,58 @@
+import argparse
+import configparser
+import logging
+import pathlib
+
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy import interpolate
+from scipy import fft
+
+from .olaflow import OFModel
+
+parser = argparse.ArgumentParser(description="Convert swash output to olaFlow input")
+parser.add_argument("-v", "--verbose", action="count", default=0)
+parser.add_argument("-c", "--config", default="config.ini")
+parser.add_argument("-o", "--output", type=pathlib.Path)
+args = parser.parse_args()
+
+logging.basicConfig(level=max((10, 20 - 10 * args.verbose)))
+log = logging.getLogger("sws_ola")
+
+log.info("Starting sws -> olaFlow converter")
+config = configparser.ConfigParser()
+config.read(args.config)
+level = config.getfloat("bathy", "level", fallback=0.)
+
+sws_out = pathlib.Path(config.get("swash", "np_out"))
+
+
+def data(var):
+    return np.load(sws_out.joinpath(f"{var}.npy"))
+
+
+x = data("x")
+t_ = data("t")
+
+vel = data("vel")
+watl = data("watl")
+
+x0 = config.getfloat("olaflow", "x0")
+arg_x0 = np.argmin(np.abs(x - x0))
+t0 = config.getfloat("olaflow", "t0")
+tf = config.getfloat("olaflow", "tf")
+arg_t0 = -np.argmax(t_[::-1] < (t0 * 1e3))
+arg_tf = np.argmax(t_ > (tf * 1e3)) + 1
+
+t = t_[arg_t0:arg_tf] * 1e-3
+t = t - t.min()
+wl = watl[arg_t0:arg_tf, arg_x0]
+v = vel[0, arg_t0:arg_tf, arg_x0]
+
+olaflow_root = args.output
+org = olaflow_root.joinpath("constant", "waveDict_paddle.org").read_text()
+org = org.replace("{n}", str(t.size))
+org = org.replace("{t}", "\n".join(t.astype(np.str_)))
+org = org.replace("{v}", "\n".join(v.astype(np.str_)))
+org = org.replace("{eta}", "\n".join(wl.astype(np.str_)))
+olaflow_root.joinpath("constant", "waveDict").write_text(org)